From 617b6339170a56a235625f8359730ba710d3ae96 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 12 Oct 2020 13:11:03 -0700
Subject: [PATCH 0001/2400] [dev.typeparams] cmd/compile/internal/syntax:
 prepare syntax nodes for type parameters

- add TParamList fields to TypeDecl, FuncDecl
- also: change File.Lines to File.EOF so we have the actual file end position

Change-Id: Ia345f888080a884f7ac5cefd8bff3d80e4a59cdc
Reviewed-on: https://go-review.googlesource.com/c/go/+/261657
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/noder.go          |  2 +-
 src/cmd/compile/internal/syntax/nodes.go      | 33 ++++++++++---------
 src/cmd/compile/internal/syntax/parser.go     |  2 +-
 .../compile/internal/syntax/parser_test.go    |  2 +-
 4 files changed, 21 insertions(+), 18 deletions(-)

diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 5dce533e4b..8b11055983 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -60,7 +60,7 @@ func parseFiles(filenames []string) uint {
 		}
 
 		p.node()
-		lines += p.file.Lines
+		lines += p.file.EOF.Line()
 		p.file = nil // release memory
 
 		if nsyntaxerrors != 0 {
diff --git a/src/cmd/compile/internal/syntax/nodes.go b/src/cmd/compile/internal/syntax/nodes.go
index 815630fcd4..f2dbdcda29 100644
--- a/src/cmd/compile/internal/syntax/nodes.go
+++ b/src/cmd/compile/internal/syntax/nodes.go
@@ -37,7 +37,7 @@ type File struct {
 	Pragma   Pragma
 	PkgName  *Name
 	DeclList []Decl
-	Lines    uint
+	EOF      Pos
 	node
 }
 
@@ -74,11 +74,12 @@ type (
 
 	// Name Type
 	TypeDecl struct {
-		Group  *Group // nil means not part of a group
-		Pragma Pragma
-		Name   *Name
-		Alias  bool
-		Type   Expr
+		Group      *Group // nil means not part of a group
+		Pragma     Pragma
+		Name       *Name
+		TParamList []*Field // nil means no type parameters
+		Alias      bool
+		Type       Expr
 		decl
 	}
 
@@ -99,11 +100,12 @@ type (
 	// func Receiver Name Type { Body }
 	// func Receiver Name Type
 	FuncDecl struct {
-		Pragma Pragma
-		Recv   *Field // nil means regular function
-		Name   *Name
-		Type   *FuncType
-		Body   *BlockStmt // nil means no body (forward declaration)
+		Pragma     Pragma
+		Recv       *Field // nil means regular function
+		Name       *Name
+		TParamList []*Field // nil means no type parameters
+		Type       *FuncType
+		Body       *BlockStmt // nil means no body (forward declaration)
 		decl
 	}
 )
@@ -223,9 +225,10 @@ type (
 
 	// Fun(ArgList[0], ArgList[1], ...)
 	CallExpr struct {
-		Fun     Expr
-		ArgList []Expr // nil means no arguments
-		HasDots bool   // last argument is followed by ...
+		Fun      Expr
+		ArgList  []Expr // nil means no arguments
+		HasDots  bool   // last argument is followed by ...
+		Brackets bool   // []'s instead of ()'s
 		expr
 	}
 
@@ -272,7 +275,7 @@ type (
 
 	// interface { MethodList[0]; MethodList[1]; ... }
 	InterfaceType struct {
-		MethodList []*Field
+		MethodList []*Field // a field named "type" means a type constraint
 		expr
 	}
 
diff --git a/src/cmd/compile/internal/syntax/parser.go b/src/cmd/compile/internal/syntax/parser.go
index 1485b70059..146f83ed01 100644
--- a/src/cmd/compile/internal/syntax/parser.go
+++ b/src/cmd/compile/internal/syntax/parser.go
@@ -445,7 +445,7 @@ func (p *parser) fileOrNil() *File {
 	// p.tok == _EOF
 
 	p.clearPragma()
-	f.Lines = p.line
+	f.EOF = p.pos()
 
 	return f
 }
diff --git a/src/cmd/compile/internal/syntax/parser_test.go b/src/cmd/compile/internal/syntax/parser_test.go
index 81945faee9..f1c5433b40 100644
--- a/src/cmd/compile/internal/syntax/parser_test.go
+++ b/src/cmd/compile/internal/syntax/parser_test.go
@@ -76,7 +76,7 @@ func TestStdLib(t *testing.T) {
 				if *verify {
 					verifyPrint(filename, ast)
 				}
-				results <- parseResult{filename, ast.Lines}
+				results <- parseResult{filename, ast.EOF.Line()}
 			})
 		}
 	}()
-- 
GitLab


From b627988b0ca748a73867ba5fc4cfc70031c028d2 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 12 Oct 2020 14:07:31 -0700
Subject: [PATCH 0002/2400] [dev.typeparams] cmd/compile/internal/syntax:
 implement parsing of type parameters

Port from dev.go2go prototype branch. The compiler doesn't yet set the
syntax.AllowGenerics mode, so parsing of generic code remains disabled.

Known issue: The doc strings documenting the specific syntax accepted
by parser methods are not all up-to-date.

Change-Id: I13d134289fd9330fd0ed7f97c997cca6f23466fd
Reviewed-on: https://go-review.googlesource.com/c/go/+/261658
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/syntax/parser.go | 643 +++++++++++++++-------
 src/cmd/compile/internal/syntax/syntax.go |   1 +
 2 files changed, 442 insertions(+), 202 deletions(-)

diff --git a/src/cmd/compile/internal/syntax/parser.go b/src/cmd/compile/internal/syntax/parser.go
index 146f83ed01..126b87b4ee 100644
--- a/src/cmd/compile/internal/syntax/parser.go
+++ b/src/cmd/compile/internal/syntax/parser.go
@@ -459,20 +459,21 @@ func isEmptyFuncDecl(dcl Decl) bool {
 // Declarations
 
 // list parses a possibly empty, sep-separated list, optionally
-// followed by sep and enclosed by ( and ) or { and }. open is
-// one of _Lparen, or _Lbrace, sep is one of _Comma or _Semi,
-// and close is expected to be the (closing) opposite of open.
+// followed sep, and closed by close. sep must be one of _Comma
+// or _Semi, and close must be one of _Rparen, _Rbrace, or _Rbrack.
 // For each list element, f is called. After f returns true, no
 // more list elements are accepted. list returns the position
 // of the closing token.
 //
-// list = "(" { f sep } ")" |
-//        "{" { f sep } "}" . // sep is optional before ")" or "}"
+// list = { f sep } ")" |
+//        { f sep } "}" . // "," or ";" is optional before ")", "}" or "]"
 //
-func (p *parser) list(open, sep, close token, f func() bool) Pos {
-	p.want(open)
+func (p *parser) list(sep, close token, f func() bool) Pos {
+	if debug && (sep != _Comma && sep != _Semi || close != _Rparen && close != _Rbrace && close != _Rbrack) {
+		panic("invalid sep or close argument for list")
+	}
 
-	var done bool
+	done := false
 	for p.tok != _EOF && p.tok != close && !done {
 		done = f()
 		// sep is optional before close
@@ -496,7 +497,8 @@ func (p *parser) appendGroup(list []Decl, f func(*Group) Decl) []Decl {
 	if p.tok == _Lparen {
 		g := new(Group)
 		p.clearPragma()
-		p.list(_Lparen, _Semi, _Rparen, func() bool {
+		p.next() // must consume "(" after calling clearPragma!
+		p.list(_Semi, _Rparen, func() bool {
 			list = append(list, f(g))
 			return false
 		})
@@ -566,7 +568,7 @@ func (p *parser) constDecl(group *Group) Decl {
 	return d
 }
 
-// TypeSpec = identifier [ "=" ] Type .
+// TypeSpec = identifier [ TypeParams ] [ "=" ] Type .
 func (p *parser) typeDecl(group *Group) Decl {
 	if trace {
 		defer p.trace("typeDecl")()
@@ -578,8 +580,42 @@ func (p *parser) typeDecl(group *Group) Decl {
 	d.Pragma = p.takePragma()
 
 	d.Name = p.name()
-	d.Alias = p.gotAssign()
-	d.Type = p.typeOrNil()
+	if p.tok == _Lbrack {
+		// array/slice or generic type
+		pos := p.pos()
+		p.next()
+		switch p.tok {
+		case _Rbrack:
+			p.next()
+			d.Type = p.sliceType(pos)
+		case _Name:
+			// array or generic type
+			p.xnest++
+			x := p.expr()
+			p.xnest--
+			if name0, ok := x.(*Name); p.mode&AllowGenerics != 0 && ok && p.tok != _Rbrack {
+				// generic type
+				d.TParamList = p.paramList(name0, _Rbrack)
+				pos := p.pos()
+				if p.gotAssign() {
+					p.syntaxErrorAt(pos, "generic type cannot be alias")
+				}
+				d.Type = p.typeOrNil()
+			} else {
+				// x is the array length expression
+				if debug && x == nil {
+					panic("internal error: nil expression")
+				}
+				d.Type = p.arrayType(pos, x)
+			}
+		default:
+			d.Type = p.arrayType(pos, nil)
+		}
+	} else {
+		d.Alias = p.gotAssign()
+		d.Type = p.typeOrNil()
+	}
+
 	if d.Type == nil {
 		d.Type = p.badExpr()
 		p.syntaxError("in type declaration")
@@ -613,7 +649,7 @@ func (p *parser) varDecl(group *Group) Decl {
 	return d
 }
 
-// FunctionDecl = "func" FunctionName ( Function | Signature ) .
+// FunctionDecl = "func" FunctionName [ TypeParams ] ( Function | Signature ) .
 // FunctionName = identifier .
 // Function     = Signature FunctionBody .
 // MethodDecl   = "func" Receiver MethodName ( Function | Signature ) .
@@ -627,8 +663,8 @@ func (p *parser) funcDeclOrNil() *FuncDecl {
 	f.pos = p.pos()
 	f.Pragma = p.takePragma()
 
-	if p.tok == _Lparen {
-		rcvr := p.paramList()
+	if p.got(_Lparen) {
+		rcvr := p.paramList(nil, _Rparen)
 		switch len(rcvr) {
 		case 0:
 			p.error("method has no receiver")
@@ -647,6 +683,14 @@ func (p *parser) funcDeclOrNil() *FuncDecl {
 	}
 
 	f.Name = p.name()
+	if p.mode&AllowGenerics != 0 && p.got(_Lbrack) {
+		if p.tok == _Rbrack {
+			p.syntaxError("empty type parameter list")
+			p.next()
+		} else {
+			f.TParamList = p.paramList(nil, _Rbrack)
+		}
+	}
 	f.Type = p.funcType()
 	if p.tok == _Lbrace {
 		f.Body = p.funcBody()
@@ -850,13 +894,7 @@ func (p *parser) operand(keep_parens bool) Expr {
 		// Optimization: Record presence of ()'s only where needed
 		// for error reporting. Don't bother in other cases; it is
 		// just a waste of memory and time.
-
-		// Parentheses are not permitted on lhs of := .
-		// switch x.Op {
-		// case ONAME, ONONAME, OPACK, OTYPE, OLITERAL, OTYPESW:
-		// 	keep_parens = true
-		// }
-
+		//
 		// Parentheses are not permitted around T in a composite
 		// literal T{}. If the next token is a {, assume x is a
 		// composite literal type T (it may not be, { could be
@@ -879,19 +917,19 @@ func (p *parser) operand(keep_parens bool) Expr {
 	case _Func:
 		pos := p.pos()
 		p.next()
-		t := p.funcType()
+		ftyp := p.funcType()
 		if p.tok == _Lbrace {
 			p.xnest++
 
 			f := new(FuncLit)
 			f.pos = pos
-			f.Type = t
+			f.Type = ftyp
 			f.Body = p.funcBody()
 
 			p.xnest--
 			return f
 		}
-		return t
+		return ftyp
 
 	case _Lbrack, _Chan, _Map, _Struct, _Interface:
 		return p.type_() // othertype
@@ -971,6 +1009,14 @@ loop:
 
 		case _Lbrack:
 			p.next()
+
+			if p.tok == _Rbrack {
+				// invalid empty instance, slice or index expression; accept but complain
+				p.syntaxError("expecting operand")
+				p.next()
+				break
+			}
+
 			p.xnest++
 
 			var i Expr
@@ -986,6 +1032,20 @@ loop:
 					p.xnest--
 					break
 				}
+
+				if p.mode&AllowGenerics != 0 && p.tok == _Comma {
+					// x[i, ... (instantiated type)
+					// TODO(gri) Suggestion by mdempsky@: Use IndexExpr + ExprList for this case.
+					//           Then we can get rid of CallExpr.Brackets.
+					t := new(CallExpr)
+					t.pos = pos
+					t.Fun = x
+					t.ArgList, _ = p.argList(i, _Rbrack)
+					t.Brackets = true
+					x = t
+					p.xnest--
+					break
+				}
 			}
 
 			// x[i:...
@@ -1022,8 +1082,9 @@ loop:
 		case _Lparen:
 			t := new(CallExpr)
 			t.pos = pos
+			p.next()
 			t.Fun = x
-			t.ArgList, t.HasDots = p.argList()
+			t.ArgList, t.HasDots = p.argList(nil, _Rparen)
 			x = t
 
 		case _Lbrace:
@@ -1032,10 +1093,20 @@ loop:
 			t := unparen(x)
 			// determine if '{' belongs to a composite literal or a block statement
 			complit_ok := false
-			switch t.(type) {
+			switch t := t.(type) {
 			case *Name, *SelectorExpr:
 				if p.xnest >= 0 {
-					// x is considered a composite literal type
+					// x is possibly a composite literal type
+					complit_ok = true
+				}
+			case *CallExpr:
+				if t.Brackets && p.xnest >= 0 {
+					// x is possibly a composite literal type
+					complit_ok = true
+				}
+			case *IndexExpr:
+				if p.xnest >= 0 {
+					// x is possibly a composite literal type
 					complit_ok = true
 				}
 			case *ArrayType, *SliceType, *StructType, *MapType:
@@ -1085,7 +1156,8 @@ func (p *parser) complitexpr() *CompositeLit {
 	x.pos = p.pos()
 
 	p.xnest++
-	x.Rbrace = p.list(_Lbrace, _Comma, _Rbrace, func() bool {
+	p.want(_Lbrace)
+	x.Rbrace = p.list(_Comma, _Rbrace, func() bool {
 		// value
 		e := p.bare_complitexpr()
 		if p.tok == _Colon {
@@ -1170,26 +1242,10 @@ func (p *parser) typeOrNil() Expr {
 		// '[' oexpr ']' ntype
 		// '[' _DotDotDot ']' ntype
 		p.next()
-		p.xnest++
 		if p.got(_Rbrack) {
-			// []T
-			p.xnest--
-			t := new(SliceType)
-			t.pos = pos
-			t.Elem = p.type_()
-			return t
+			return p.sliceType(pos)
 		}
-
-		// [n]T
-		t := new(ArrayType)
-		t.pos = pos
-		if !p.got(_DotDotDot) {
-			t.Len = p.expr()
-		}
-		p.want(_Rbrack)
-		p.xnest--
-		t.Elem = p.type_()
-		return t
+		return p.arrayType(pos, nil)
 
 	case _Chan:
 		// _Chan non_recvchantype
@@ -1221,7 +1277,7 @@ func (p *parser) typeOrNil() Expr {
 		return p.interfaceType()
 
 	case _Name:
-		return p.dotname(p.name())
+		return p.qualifiedName(nil)
 
 	case _Lparen:
 		p.next()
@@ -1233,6 +1289,27 @@ func (p *parser) typeOrNil() Expr {
 	return nil
 }
 
+func (p *parser) typeInstance(typ Expr) Expr {
+	if trace {
+		defer p.trace("typeInstance")()
+	}
+
+	pos := p.pos()
+	p.want(_Lbrack)
+	if p.tok == _Rbrack {
+		p.error("expecting type")
+		p.next()
+		return typ
+	}
+
+	call := new(CallExpr)
+	call.pos = pos
+	call.Fun = typ
+	call.ArgList, _ = p.argList(nil, _Rbrack)
+	call.Brackets = true
+	return call
+}
+
 func (p *parser) funcType() *FuncType {
 	if trace {
 		defer p.trace("funcType")()
@@ -1240,12 +1317,41 @@ func (p *parser) funcType() *FuncType {
 
 	typ := new(FuncType)
 	typ.pos = p.pos()
-	typ.ParamList = p.paramList()
+	p.want(_Lparen)
+	typ.ParamList = p.paramList(nil, _Rparen)
 	typ.ResultList = p.funcResult()
 
 	return typ
 }
 
+// "[" has already been consumed, and pos is its position.
+// If len != nil it is the already consumed array length.
+func (p *parser) arrayType(pos Pos, len Expr) Expr {
+	if trace {
+		defer p.trace("arrayType")()
+	}
+
+	if len == nil && !p.got(_DotDotDot) {
+		p.xnest++
+		len = p.expr()
+		p.xnest--
+	}
+	p.want(_Rbrack)
+	t := new(ArrayType)
+	t.pos = pos
+	t.Len = len
+	t.Elem = p.type_()
+	return t
+}
+
+// "[" and "]" have already been consumed, and pos is the position of "[".
+func (p *parser) sliceType(pos Pos) Expr {
+	t := new(SliceType)
+	t.pos = pos
+	t.Elem = p.type_()
+	return t
+}
+
 func (p *parser) chanElem() Expr {
 	if trace {
 		defer p.trace("chanElem")()
@@ -1261,22 +1367,6 @@ func (p *parser) chanElem() Expr {
 	return typ
 }
 
-func (p *parser) dotname(name *Name) Expr {
-	if trace {
-		defer p.trace("dotname")()
-	}
-
-	if p.tok == _Dot {
-		s := new(SelectorExpr)
-		s.pos = p.pos()
-		p.next()
-		s.X = name
-		s.Sel = p.name()
-		return s
-	}
-	return name
-}
-
 // StructType = "struct" "{" { FieldDecl ";" } "}" .
 func (p *parser) structType() *StructType {
 	if trace {
@@ -1287,7 +1377,8 @@ func (p *parser) structType() *StructType {
 	typ.pos = p.pos()
 
 	p.want(_Struct)
-	p.list(_Lbrace, _Semi, _Rbrace, func() bool {
+	p.want(_Lbrace)
+	p.list(_Semi, _Rbrace, func() bool {
 		p.fieldDecl(typ)
 		return false
 	})
@@ -1305,9 +1396,56 @@ func (p *parser) interfaceType() *InterfaceType {
 	typ.pos = p.pos()
 
 	p.want(_Interface)
-	p.list(_Lbrace, _Semi, _Rbrace, func() bool {
-		if m := p.methodDecl(); m != nil {
-			typ.MethodList = append(typ.MethodList, m)
+	p.want(_Lbrace)
+	p.list(_Semi, _Rbrace, func() bool {
+		switch p.tok {
+		case _Name:
+			typ.MethodList = append(typ.MethodList, p.methodDecl())
+
+		case _Lparen:
+			p.syntaxError("cannot parenthesize embedded type")
+			f := new(Field)
+			f.pos = p.pos()
+			p.next()
+			f.Type = p.qualifiedName(nil)
+			p.want(_Rparen)
+			typ.MethodList = append(typ.MethodList, f)
+
+		case _Type:
+			if p.mode&AllowGenerics != 0 {
+				// TODO(gri) factor this better
+				type_ := new(Name)
+				type_.pos = p.pos()
+				type_.Value = "type" // cannot have a method named "type"
+				p.next()
+				if p.tok != _Semi && p.tok != _Rbrace {
+					f := new(Field)
+					f.pos = p.pos()
+					f.Name = type_
+					f.Type = p.type_()
+					typ.MethodList = append(typ.MethodList, f)
+					for p.got(_Comma) {
+						f := new(Field)
+						f.pos = p.pos()
+						f.Name = type_
+						f.Type = p.type_()
+						typ.MethodList = append(typ.MethodList, f)
+					}
+				} else {
+					p.syntaxError("expecting type")
+				}
+				break
+			}
+			fallthrough
+
+		default:
+			if p.mode&AllowGenerics != 0 {
+				p.syntaxError("expecting method, interface name, or type list")
+				p.advance(_Semi, _Rbrace, _Type)
+			} else {
+				p.syntaxError("expecting method or interface name")
+				p.advance(_Semi, _Rbrace)
+			}
 		}
 		return false
 	})
@@ -1321,8 +1459,8 @@ func (p *parser) funcResult() []*Field {
 		defer p.trace("funcResult")()
 	}
 
-	if p.tok == _Lparen {
-		return p.paramList()
+	if p.got(_Lparen) {
+		return p.paramList(nil, _Rparen)
 	}
 
 	pos := p.pos()
@@ -1368,59 +1506,71 @@ func (p *parser) fieldDecl(styp *StructType) {
 	case _Name:
 		name := p.name()
 		if p.tok == _Dot || p.tok == _Literal || p.tok == _Semi || p.tok == _Rbrace {
-			// embed oliteral
+			// embedded type
 			typ := p.qualifiedName(name)
 			tag := p.oliteral()
 			p.addField(styp, pos, nil, typ, tag)
-			return
+			break
 		}
 
-		// new_name_list ntype oliteral
+		// name1, name2, ... Type [ tag ]
 		names := p.nameList(name)
-		typ := p.type_()
+		var typ Expr
+
+		// Careful dance: We don't know if we have an embedded instantiated
+		// type T[P1, P2, ...] or a field T of array/slice type [P]E or []E.
+		if p.mode&AllowGenerics != 0 && len(names) == 1 && p.tok == _Lbrack {
+			typ = p.arrayOrTArgs()
+			if typ, ok := typ.(*CallExpr); ok {
+				// embedded type T[P1, P2, ...]
+				typ.Fun = name // name == names[0]
+				tag := p.oliteral()
+				p.addField(styp, pos, nil, typ, tag)
+				break
+			}
+		} else {
+			// T P
+			typ = p.type_()
+		}
+
 		tag := p.oliteral()
 
 		for _, name := range names {
 			p.addField(styp, name.Pos(), name, typ, tag)
 		}
 
-	case _Lparen:
+	case _Star:
 		p.next()
-		if p.tok == _Star {
-			// '(' '*' embed ')' oliteral
-			pos := p.pos()
-			p.next()
-			typ := newIndirect(pos, p.qualifiedName(nil))
-			p.want(_Rparen)
-			tag := p.oliteral()
-			p.addField(styp, pos, nil, typ, tag)
+		var typ Expr
+		if p.tok == _Lparen {
+			// *(T)
 			p.syntaxError("cannot parenthesize embedded type")
-
+			p.next()
+			typ = p.qualifiedName(nil)
+			p.got(_Rparen) // no need to complain if missing
 		} else {
-			// '(' embed ')' oliteral
-			typ := p.qualifiedName(nil)
-			p.want(_Rparen)
-			tag := p.oliteral()
-			p.addField(styp, pos, nil, typ, tag)
-			p.syntaxError("cannot parenthesize embedded type")
+			// *T
+			typ = p.qualifiedName(nil)
 		}
+		tag := p.oliteral()
+		p.addField(styp, pos, nil, newIndirect(pos, typ), tag)
 
-	case _Star:
+	case _Lparen:
+		p.syntaxError("cannot parenthesize embedded type")
 		p.next()
-		if p.got(_Lparen) {
-			// '*' '(' embed ')' oliteral
-			typ := newIndirect(pos, p.qualifiedName(nil))
-			p.want(_Rparen)
-			tag := p.oliteral()
-			p.addField(styp, pos, nil, typ, tag)
-			p.syntaxError("cannot parenthesize embedded type")
-
+		var typ Expr
+		if p.tok == _Star {
+			// (*T)
+			pos := p.pos()
+			p.next()
+			typ = newIndirect(pos, p.qualifiedName(nil))
 		} else {
-			// '*' embed oliteral
-			typ := newIndirect(pos, p.qualifiedName(nil))
-			tag := p.oliteral()
-			p.addField(styp, pos, nil, typ, tag)
+			// (T)
+			typ = p.qualifiedName(nil)
 		}
+		p.got(_Rparen) // no need to complain if missing
+		tag := p.oliteral()
+		p.addField(styp, pos, nil, typ, tag)
 
 	default:
 		p.syntaxError("expecting field name or embedded type")
@@ -1428,6 +1578,39 @@ func (p *parser) fieldDecl(styp *StructType) {
 	}
 }
 
+func (p *parser) arrayOrTArgs() Expr {
+	if trace {
+		defer p.trace("arrayOrTArgs")()
+	}
+
+	pos := p.pos()
+	p.want(_Lbrack)
+	if p.got(_Rbrack) {
+		return p.sliceType(pos)
+	}
+
+	// x [P]E or x[P]
+	args, _ := p.argList(nil, _Rbrack)
+	if len(args) == 1 {
+		if elem := p.typeOrNil(); elem != nil {
+			// x [P]E
+			t := new(ArrayType)
+			t.pos = pos
+			t.Len = args[0]
+			t.Elem = elem
+			return t
+		}
+	}
+
+	// x[P], x[P1, P2], ...
+	t := new(CallExpr)
+	t.pos = pos
+	// t.Fun will be filled in by caller
+	t.ArgList = args
+	t.Brackets = true
+	return t
+}
+
 func (p *parser) oliteral() *BasicLit {
 	if p.tok == _Literal {
 		b := new(BasicLit)
@@ -1449,51 +1632,93 @@ func (p *parser) methodDecl() *Field {
 		defer p.trace("methodDecl")()
 	}
 
-	switch p.tok {
-	case _Name:
-		name := p.name()
-
-		// accept potential name list but complain
-		hasNameList := false
-		for p.got(_Comma) {
-			p.name()
-			hasNameList = true
-		}
-		if hasNameList {
-			p.syntaxError("name list not allowed in interface type")
-			// already progressed, no need to advance
-		}
+	f := new(Field)
+	f.pos = p.pos()
+	name := p.name()
 
-		f := new(Field)
-		f.pos = name.Pos()
-		if p.tok != _Lparen {
-			// packname
-			f.Type = p.qualifiedName(name)
-			return f
-		}
+	// accept potential name list but complain
+	// TODO(gri) We probably don't need this special check anymore.
+	//           Nobody writes this kind of code. It's from ancient
+	//           Go beginnings.
+	hasNameList := false
+	for p.got(_Comma) {
+		p.name()
+		hasNameList = true
+	}
+	if hasNameList {
+		p.syntaxError("name list not allowed in interface type")
+		// already progressed, no need to advance
+	}
 
+	switch p.tok {
+	case _Lparen:
+		// method
 		f.Name = name
 		f.Type = p.funcType()
-		return f
 
-	case _Lparen:
-		p.syntaxError("cannot parenthesize embedded type")
-		f := new(Field)
-		f.pos = p.pos()
-		p.next()
-		f.Type = p.qualifiedName(nil)
-		p.want(_Rparen)
-		return f
+	case _Lbrack:
+		if p.mode&AllowGenerics != 0 {
+			// Careful dance: We don't know if we have a generic method m[T C](x T)
+			// or an embedded instantiated type T[P1, P2] (we accept generic methods
+			// for generality and robustness of parsing).
+			pos := p.pos()
+			p.next()
+
+			// empty type parameter or argument lists are not permitted
+			if p.tok == _Rbrack {
+				// name[]
+				pos := p.pos()
+				p.next()
+				if p.tok == _Lparen {
+					// name[](
+					p.errorAt(pos, "empty type parameter list")
+					f.Name = name
+					f.Type = p.funcType()
+				} else {
+					p.errorAt(pos, "empty type argument list")
+					f.Type = name
+				}
+				break
+			}
+
+			// A type argument list looks like a parameter list with only
+			// types. Parse a parameter list and decide afterwards.
+			list := p.paramList(nil, _Rbrack)
+			if len(list) > 0 && list[0].Name != nil {
+				// generic method
+				f.Name = name
+				f.Type = p.funcType()
+				// TODO(gri) Record list as type parameter list with f.Type
+				//           if we want to type-check the generic method.
+				//           For now, report an error so this is not a silent event.
+				p.errorAt(pos, "interface method cannot have type parameters")
+				break
+			}
+
+			// embedded instantiated type
+			call := new(CallExpr)
+			call.pos = pos
+			call.Fun = name
+			call.Brackets = true
+			call.ArgList = make([]Expr, len(list))
+			for i := range list {
+				call.ArgList[i] = list[i].Type
+			}
+			f.Type = call
+			break
+		}
+		fallthrough
 
 	default:
-		p.syntaxError("expecting method or interface name")
-		p.advance(_Semi, _Rbrace)
-		return nil
+		// embedded type
+		f.Type = p.qualifiedName(name)
 	}
+
+	return f
 }
 
 // ParameterDecl = [ IdentifierList ] [ "..." ] Type .
-func (p *parser) paramDeclOrNil() *Field {
+func (p *parser) paramDeclOrNil(name *Name) *Field {
 	if trace {
 		defer p.trace("paramDecl")()
 	}
@@ -1501,73 +1726,67 @@ func (p *parser) paramDeclOrNil() *Field {
 	f := new(Field)
 	f.pos = p.pos()
 
-	switch p.tok {
-	case _Name:
-		f.Name = p.name()
-		switch p.tok {
-		case _Name, _Star, _Arrow, _Func, _Lbrack, _Chan, _Map, _Struct, _Interface, _Lparen:
-			// sym name_or_type
-			f.Type = p.type_()
+	if p.tok == _Name || name != nil {
+		if name == nil {
+			name = p.name()
+		}
 
-		case _DotDotDot:
-			// sym dotdotdot
-			f.Type = p.dotsType()
+		if p.mode&AllowGenerics != 0 && p.tok == _Lbrack {
+			f.Type = p.arrayOrTArgs()
+			if typ, ok := f.Type.(*CallExpr); ok {
+				typ.Fun = name
+			} else {
+				f.Name = name
+			}
+			return f
+		}
 
-		case _Dot:
+		if p.tok == _Dot {
 			// name_or_type
-			// from dotname
-			f.Type = p.dotname(f.Name)
-			f.Name = nil
+			f.Type = p.qualifiedName(name)
+			return f
 		}
 
-	case _Arrow, _Star, _Func, _Lbrack, _Chan, _Map, _Struct, _Interface, _Lparen:
-		// name_or_type
-		f.Type = p.type_()
-
-	case _DotDotDot:
-		// dotdotdot
-		f.Type = p.dotsType()
-
-	default:
-		p.syntaxError("expecting )")
-		p.advance(_Comma, _Rparen)
-		return nil
+		f.Name = name
 	}
 
-	return f
-}
-
-// ...Type
-func (p *parser) dotsType() *DotsType {
-	if trace {
-		defer p.trace("dotsType")()
+	if p.tok == _DotDotDot {
+		t := new(DotsType)
+		t.pos = p.pos()
+		p.next()
+		t.Elem = p.typeOrNil()
+		if t.Elem == nil {
+			t.Elem = p.badExpr()
+			p.syntaxError("final argument in variadic function missing type")
+		}
+		f.Type = t
+		return f
 	}
 
-	t := new(DotsType)
-	t.pos = p.pos()
-
-	p.want(_DotDotDot)
-	t.Elem = p.typeOrNil()
-	if t.Elem == nil {
-		t.Elem = p.badExpr()
-		p.syntaxError("final argument in variadic function missing type")
+	f.Type = p.typeOrNil()
+	if f.Name != nil || f.Type != nil {
+		return f
 	}
 
-	return t
+	p.syntaxError("expecting )")
+	p.advance(_Comma, _Rparen)
+	return nil
 }
 
 // Parameters    = "(" [ ParameterList [ "," ] ] ")" .
 // ParameterList = ParameterDecl { "," ParameterDecl } .
-func (p *parser) paramList() (list []*Field) {
+// "(" or "[" has already been consumed.
+// If name != nil, it is the first name after "(" or "[".
+func (p *parser) paramList(name *Name, close token) (list []*Field) {
 	if trace {
 		defer p.trace("paramList")()
 	}
 
-	pos := p.pos()
-
-	var named int // number of parameters that have an explicit name and type
-	p.list(_Lparen, _Comma, _Rparen, func() bool {
-		if par := p.paramDeclOrNil(); par != nil {
+	var named int // number of parameters that have an explicit name and type/bound
+	p.list(_Comma, close, func() bool {
+		par := p.paramDeclOrNil(name)
+		name = nil // 1st name was consumed if present
+		if par != nil {
 			if debug && par.Name == nil && par.Type == nil {
 				panic("parameter without name or type")
 			}
@@ -1589,30 +1808,30 @@ func (p *parser) paramList() (list []*Field) {
 			}
 		}
 	} else if named != len(list) {
-		// some named => all must be named
-		ok := true
+		// some named => all must have names and types
+		var pos Pos // error position (or unknown)
 		var typ Expr
 		for i := len(list) - 1; i >= 0; i-- {
 			if par := list[i]; par.Type != nil {
 				typ = par.Type
 				if par.Name == nil {
-					ok = false
+					pos = typ.Pos()
 					n := p.newName("_")
-					n.pos = typ.Pos() // correct position
+					n.pos = pos // correct position
 					par.Name = n
 				}
 			} else if typ != nil {
 				par.Type = typ
 			} else {
 				// par.Type == nil && typ == nil => we only have a par.Name
-				ok = false
+				pos = par.Name.Pos()
 				t := p.badExpr()
-				t.pos = par.Name.Pos() // correct position
+				t.pos = pos // correct position
 				par.Type = t
 			}
 		}
-		if !ok {
-			p.syntaxErrorAt(pos, "mixed named and unnamed function parameters")
+		if pos.IsKnown() {
+			p.syntaxErrorAt(pos, "mixed named and unnamed parameters")
 		}
 	}
 
@@ -2209,15 +2428,21 @@ func (p *parser) stmtList() (l []Stmt) {
 }
 
 // Arguments = "(" [ ( ExpressionList | Type [ "," ExpressionList ] ) [ "..." ] [ "," ] ] ")" .
-func (p *parser) argList() (list []Expr, hasDots bool) {
+func (p *parser) argList(arg Expr, close token) (list []Expr, hasDots bool) {
 	if trace {
 		defer p.trace("argList")()
 	}
 
 	p.xnest++
-	p.list(_Lparen, _Comma, _Rparen, func() bool {
-		list = append(list, p.expr())
-		hasDots = p.got(_DotDotDot)
+	p.list(_Comma, close, func() bool {
+		if arg == nil {
+			arg = p.expr()
+		}
+		list = append(list, arg)
+		arg = nil
+		if close == _Rparen {
+			hasDots = p.got(_DotDotDot)
+		}
 		return hasDots
 	})
 	p.xnest--
@@ -2275,18 +2500,32 @@ func (p *parser) qualifiedName(name *Name) Expr {
 		defer p.trace("qualifiedName")()
 	}
 
+	var x Expr
 	switch {
 	case name != nil:
-		// name is provided
+		x = name
 	case p.tok == _Name:
-		name = p.name()
+		x = p.name()
 	default:
-		name = p.newName("_")
+		x = p.newName("_")
 		p.syntaxError("expecting name")
 		p.advance(_Dot, _Semi, _Rbrace)
 	}
 
-	return p.dotname(name)
+	if p.tok == _Dot {
+		s := new(SelectorExpr)
+		s.pos = p.pos()
+		p.next()
+		s.X = x
+		s.Sel = p.name()
+		x = s
+	}
+
+	if p.mode&AllowGenerics != 0 && p.tok == _Lbrack {
+		x = p.typeInstance(x)
+	}
+
+	return x
 }
 
 // ExpressionList = Expression { "," Expression } .
diff --git a/src/cmd/compile/internal/syntax/syntax.go b/src/cmd/compile/internal/syntax/syntax.go
index e51b5538b3..f3d4c09ed5 100644
--- a/src/cmd/compile/internal/syntax/syntax.go
+++ b/src/cmd/compile/internal/syntax/syntax.go
@@ -16,6 +16,7 @@ type Mode uint
 // Modes supported by the parser.
 const (
 	CheckBranches Mode = 1 << iota // check correct use of labels, break, continue, and goto statements
+	AllowGenerics
 )
 
 // Error describes a syntax error. Error implements the error interface.
-- 
GitLab


From 7668f02dec44690ee61722f08b2d80b5b0c5eccd Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Sat, 10 Oct 2020 17:02:15 -0700
Subject: [PATCH 0003/2400] [dev.typeparams] cmd/compile/internal/syntax: add
 type parameter tests

The file endings are not .go so that gofmt leaves these files alone.
They are also not .src to distinguish them from regular go source tests.

Change-Id: I741f5c037bad1ea9d6f7fda3673487d0be631350
Reviewed-on: https://go-review.googlesource.com/c/go/+/261219
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 .../compile/internal/syntax/parser_test.go    |  21 +-
 .../internal/syntax/testdata/go2/chans.go2    |  62 +++
 .../internal/syntax/testdata/go2/linalg.go2   |  83 ++++
 .../internal/syntax/testdata/go2/map.go2      | 113 +++++
 .../internal/syntax/testdata/go2/map2.go2     | 146 ++++++
 .../internal/syntax/testdata/go2/slices.go2   |  68 +++
 .../syntax/testdata/go2/smoketest.go2         |  83 ++++
 .../internal/syntax/testdata/go2/typeinst.go2 |  60 +++
 .../syntax/testdata/go2/typeinst2.go2         | 256 ++++++++++
 .../syntax/testdata/go2/typeparams.go2        | 451 ++++++++++++++++++
 10 files changed, 1341 insertions(+), 2 deletions(-)
 create mode 100644 src/cmd/compile/internal/syntax/testdata/go2/chans.go2
 create mode 100644 src/cmd/compile/internal/syntax/testdata/go2/linalg.go2
 create mode 100644 src/cmd/compile/internal/syntax/testdata/go2/map.go2
 create mode 100644 src/cmd/compile/internal/syntax/testdata/go2/map2.go2
 create mode 100644 src/cmd/compile/internal/syntax/testdata/go2/slices.go2
 create mode 100644 src/cmd/compile/internal/syntax/testdata/go2/smoketest.go2
 create mode 100644 src/cmd/compile/internal/syntax/testdata/go2/typeinst.go2
 create mode 100644 src/cmd/compile/internal/syntax/testdata/go2/typeinst2.go2
 create mode 100644 src/cmd/compile/internal/syntax/testdata/go2/typeparams.go2

diff --git a/src/cmd/compile/internal/syntax/parser_test.go b/src/cmd/compile/internal/syntax/parser_test.go
index f1c5433b40..e270879739 100644
--- a/src/cmd/compile/internal/syntax/parser_test.go
+++ b/src/cmd/compile/internal/syntax/parser_test.go
@@ -29,7 +29,24 @@ func TestParse(t *testing.T) {
 	ParseFile(*src_, func(err error) { t.Error(err) }, nil, 0)
 }
 
-func TestStdLib(t *testing.T) {
+func TestParseGo2(t *testing.T) {
+	dir := filepath.Join(testdata, "go2")
+	list, err := ioutil.ReadDir(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fi := range list {
+		name := fi.Name()
+		if !fi.IsDir() && !strings.HasPrefix(name, ".") {
+			ParseFile(filepath.Join(dir, name), func(err error) { t.Error(err) }, nil, AllowGenerics)
+		}
+	}
+}
+
+func TestStdLib(t *testing.T)        { testStdLib(t, 0) }
+func TestStdLibGeneric(t *testing.T) { testStdLib(t, AllowGenerics) }
+
+func testStdLib(t *testing.T, mode Mode) {
 	if testing.Short() {
 		t.Skip("skipping test in short mode")
 	}
@@ -68,7 +85,7 @@ func TestStdLib(t *testing.T) {
 				if debug {
 					fmt.Printf("parsing %s\n", filename)
 				}
-				ast, err := ParseFile(filename, nil, nil, 0)
+				ast, err := ParseFile(filename, nil, nil, mode)
 				if err != nil {
 					t.Error(err)
 					return
diff --git a/src/cmd/compile/internal/syntax/testdata/go2/chans.go2 b/src/cmd/compile/internal/syntax/testdata/go2/chans.go2
new file mode 100644
index 0000000000..fad2bcec9d
--- /dev/null
+++ b/src/cmd/compile/internal/syntax/testdata/go2/chans.go2
@@ -0,0 +1,62 @@
+package chans
+
+import "runtime"
+
+// Ranger returns a Sender and a Receiver. The Receiver provides a
+// Next method to retrieve values. The Sender provides a Send method
+// to send values and a Close method to stop sending values. The Next
+// method indicates when the Sender has been closed, and the Send
+// method indicates when the Receiver has been freed.
+//
+// This is a convenient way to exit a goroutine sending values when
+// the receiver stops reading them.
+func Ranger[T any]() (*Sender[T], *Receiver[T]) {
+	c := make(chan T)
+	d := make(chan bool)
+	s := &Sender[T]{values: c, done: d}
+	r := &Receiver[T]{values: c, done: d}
+	runtime.SetFinalizer(r, r.finalize)
+	return s, r
+}
+
+// A sender is used to send values to a Receiver.
+type Sender[T any] struct {
+	values chan<- T
+	done <-chan bool
+}
+
+// Send sends a value to the receiver. It returns whether any more
+// values may be sent; if it returns false the value was not sent.
+func (s *Sender[T]) Send(v T) bool {
+	select {
+	case s.values <- v:
+		return true
+	case <-s.done:
+		return false
+	}
+}
+
+// Close tells the receiver that no more values will arrive.
+// After Close is called, the Sender may no longer be used.
+func (s *Sender[T]) Close() {
+	close(s.values)
+}
+
+// A Receiver receives values from a Sender.
+type Receiver[T any] struct {
+	values <-chan T
+	done chan<- bool
+}
+
+// Next returns the next value from the channel. The bool result
+// indicates whether the value is valid, or whether the Sender has
+// been closed and no more values will be received.
+func (r *Receiver[T]) Next() (T, bool) {
+	v, ok := <-r.values
+	return v, ok
+}
+
+// finalize is a finalizer for the receiver.
+func (r *Receiver[T]) finalize() {
+	close(r.done)
+}
diff --git a/src/cmd/compile/internal/syntax/testdata/go2/linalg.go2 b/src/cmd/compile/internal/syntax/testdata/go2/linalg.go2
new file mode 100644
index 0000000000..0d27603a58
--- /dev/null
+++ b/src/cmd/compile/internal/syntax/testdata/go2/linalg.go2
@@ -0,0 +1,83 @@
+// Copyright 2019 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 linalg
+
+import "math"
+
+// Numeric is type bound that matches any numeric type.
+// It would likely be in a constraints package in the standard library.
+type Numeric interface {
+	type int, int8, int16, int32, int64,
+		uint, uint8, uint16, uint32, uint64, uintptr,
+		float32, float64,
+		complex64, complex128
+}
+
+func DotProduct[T Numeric](s1, s2 []T) T {
+	if len(s1) != len(s2) {
+		panic("DotProduct: slices of unequal length")
+	}
+	var r T
+	for i := range s1 {
+		r += s1[i] * s2[i]
+	}
+	return r
+}
+
+// NumericAbs matches numeric types with an Abs method.
+type NumericAbs[T any] interface {
+	Numeric
+
+	Abs() T
+}
+
+// AbsDifference computes the absolute value of the difference of
+// a and b, where the absolute value is determined by the Abs method.
+func AbsDifference[T NumericAbs[T]](a, b T) T {
+	d := a - b
+	return d.Abs()
+}
+
+// OrderedNumeric is a type bound that matches numeric types that support the < operator.
+type OrderedNumeric interface {
+	type int, int8, int16, int32, int64,
+		uint, uint8, uint16, uint32, uint64, uintptr,
+		float32, float64
+}
+
+// Complex is a type bound that matches the two complex types, which do not have a < operator.
+type Complex interface {
+	type complex64, complex128
+}
+
+// OrderedAbs is a helper type that defines an Abs method for
+// ordered numeric types.
+type OrderedAbs[T OrderedNumeric] T
+
+func (a OrderedAbs[T]) Abs() OrderedAbs[T] {
+	if a < 0 {
+		return -a
+	}
+	return a
+}
+
+// ComplexAbs is a helper type that defines an Abs method for
+// complex types.
+type ComplexAbs[T Complex] T
+
+func (a ComplexAbs[T]) Abs() ComplexAbs[T] {
+	r := float64(real(a))
+	i := float64(imag(a))
+	d := math.Sqrt(r * r + i * i)
+	return ComplexAbs[T](complex(d, 0))
+}
+
+func OrderedAbsDifference[T OrderedNumeric](a, b T) T {
+	return T(AbsDifference(OrderedAbs[T](a), OrderedAbs[T](b)))
+}
+
+func ComplexAbsDifference[T Complex](a, b T) T {
+	return T(AbsDifference(ComplexAbs[T](a), ComplexAbs[T](b)))
+}
diff --git a/src/cmd/compile/internal/syntax/testdata/go2/map.go2 b/src/cmd/compile/internal/syntax/testdata/go2/map.go2
new file mode 100644
index 0000000000..814d9539fd
--- /dev/null
+++ b/src/cmd/compile/internal/syntax/testdata/go2/map.go2
@@ -0,0 +1,113 @@
+// Copyright 2019 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 orderedmap provides an ordered map, implemented as a binary tree.
+package orderedmap
+
+// TODO(gri) fix imports for tests
+import "chans" // ERROR could not import
+
+// Map is an ordered map.
+type Map[K, V any] struct {
+	root    *node[K, V]
+	compare func(K, K) int
+}
+
+// node is the type of a node in the binary tree.
+type node[K, V any] struct {
+	key         K
+	val         V
+	left, right *node[K, V]
+}
+
+// New returns a new map.
+func New[K, V any](compare func(K, K) int) *Map[K, V] {
+        return &Map[K, V]{compare: compare}
+}
+
+// find looks up key in the map, and returns either a pointer
+// to the node holding key, or a pointer to the location where
+// such a node would go.
+func (m *Map[K, V]) find(key K) **node[K, V] {
+	pn := &m.root
+	for *pn != nil {
+		switch cmp := m.compare(key, (*pn).key); {
+		case cmp < 0:
+			pn = &(*pn).left
+		case cmp > 0:
+			pn = &(*pn).right
+		default:
+			return pn
+		}
+	}
+	return pn
+}
+
+// Insert inserts a new key/value into the map.
+// If the key is already present, the value is replaced.
+// Returns true if this is a new key, false if already present.
+func (m *Map[K, V]) Insert(key K, val V) bool {
+	pn := m.find(key)
+	if *pn != nil {
+		(*pn).val = val
+		return false
+	}
+        *pn = &node[K, V]{key: key, val: val}
+	return true
+}
+
+// Find returns the value associated with a key, or zero if not present.
+// The found result reports whether the key was found.
+func (m *Map[K, V]) Find(key K) (V, bool) {
+	pn := m.find(key)
+	if *pn == nil {
+		var zero V // see the discussion of zero values, above
+		return zero, false
+	}
+	return (*pn).val, true
+}
+
+// keyValue is a pair of key and value used when iterating.
+type keyValue[K, V any] struct {
+	key K
+	val V
+}
+
+// InOrder returns an iterator that does an in-order traversal of the map.
+func (m *Map[K, V]) InOrder() *Iterator[K, V] {
+	sender, receiver := chans.Ranger[keyValue[K, V]]()
+	var f func(*node[K, V]) bool
+	f = func(n *node[K, V]) bool {
+		if n == nil {
+			return true
+		}
+		// Stop sending values if sender.Send returns false,
+		// meaning that nothing is listening at the receiver end.
+		return f(n.left) &&
+                        sender.Send(keyValue[K, V]{n.key, n.val}) &&
+			f(n.right)
+	}
+	go func() {
+		f(m.root)
+		sender.Close()
+	}()
+	return &Iterator[K, V]{receiver}
+}
+
+// Iterator is used to iterate over the map.
+type Iterator[K, V any] struct {
+	r *chans.Receiver[keyValue[K, V]]
+}
+
+// Next returns the next key and value pair, and a boolean indicating
+// whether they are valid or whether we have reached the end.
+func (it *Iterator[K, V]) Next() (K, V, bool) {
+	keyval, ok := it.r.Next()
+	if !ok {
+		var zerok K
+		var zerov V
+		return zerok, zerov, false
+	}
+	return keyval.key, keyval.val, true
+}
diff --git a/src/cmd/compile/internal/syntax/testdata/go2/map2.go2 b/src/cmd/compile/internal/syntax/testdata/go2/map2.go2
new file mode 100644
index 0000000000..2833445662
--- /dev/null
+++ b/src/cmd/compile/internal/syntax/testdata/go2/map2.go2
@@ -0,0 +1,146 @@
+// Copyright 2019 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.
+
+// This file is like map.go2, but instead if importing chans, it contains
+// the necessary functionality at the end of the file.
+
+// Package orderedmap provides an ordered map, implemented as a binary tree.
+package orderedmap
+
+// Map is an ordered map.
+type Map[K, V any] struct {
+	root    *node[K, V]
+	compare func(K, K) int
+}
+
+// node is the type of a node in the binary tree.
+type node[K, V any] struct {
+	key         K
+	val         V
+	left, right *node[K, V]
+}
+
+// New returns a new map.
+func New[K, V any](compare func(K, K) int) *Map[K, V] {
+        return &Map[K, V]{compare: compare}
+}
+
+// find looks up key in the map, and returns either a pointer
+// to the node holding key, or a pointer to the location where
+// such a node would go.
+func (m *Map[K, V]) find(key K) **node[K, V] {
+	pn := &m.root
+	for *pn != nil {
+		switch cmp := m.compare(key, (*pn).key); {
+		case cmp < 0:
+			pn = &(*pn).left
+		case cmp > 0:
+			pn = &(*pn).right
+		default:
+			return pn
+		}
+	}
+	return pn
+}
+
+// Insert inserts a new key/value into the map.
+// If the key is already present, the value is replaced.
+// Returns true if this is a new key, false if already present.
+func (m *Map[K, V]) Insert(key K, val V) bool {
+	pn := m.find(key)
+	if *pn != nil {
+		(*pn).val = val
+		return false
+	}
+	*pn = &node[K, V]{key: key, val: val}
+	return true
+}
+
+// Find returns the value associated with a key, or zero if not present.
+// The found result reports whether the key was found.
+func (m *Map[K, V]) Find(key K) (V, bool) {
+	pn := m.find(key)
+	if *pn == nil {
+		var zero V // see the discussion of zero values, above
+		return zero, false
+	}
+	return (*pn).val, true
+}
+
+// keyValue is a pair of key and value used when iterating.
+type keyValue[K, V any] struct {
+	key K
+	val V
+}
+
+// InOrder returns an iterator that does an in-order traversal of the map.
+func (m *Map[K, V]) InOrder() *Iterator[K, V] {
+	sender, receiver := chans_Ranger[keyValue[K, V]]()
+	var f func(*node[K, V]) bool
+	f = func(n *node[K, V]) bool {
+		if n == nil {
+			return true
+		}
+		// Stop sending values if sender.Send returns false,
+		// meaning that nothing is listening at the receiver end.
+		return f(n.left) &&
+                        sender.Send(keyValue[K, V]{n.key, n.val}) &&
+			f(n.right)
+	}
+	go func() {
+		f(m.root)
+		sender.Close()
+	}()
+	return &Iterator[K, V]{receiver}
+}
+
+// Iterator is used to iterate over the map.
+type Iterator[K, V any] struct {
+	r *chans_Receiver[keyValue[K, V]]
+}
+
+// Next returns the next key and value pair, and a boolean indicating
+// whether they are valid or whether we have reached the end.
+func (it *Iterator[K, V]) Next() (K, V, bool) {
+	keyval, ok := it.r.Next()
+	if !ok {
+		var zerok K
+		var zerov V
+		return zerok, zerov, false
+	}
+	return keyval.key, keyval.val, true
+}
+
+// chans
+
+func chans_Ranger[T any]() (*chans_Sender[T], *chans_Receiver[T])
+
+// A sender is used to send values to a Receiver.
+type chans_Sender[T any] struct {
+	values chan<- T
+	done <-chan bool
+}
+
+func (s *chans_Sender[T]) Send(v T) bool {
+	select {
+	case s.values <- v:
+		return true
+	case <-s.done:
+		return false
+	}
+}
+
+func (s *chans_Sender[T]) Close() {
+	close(s.values)
+}
+
+type chans_Receiver[T any] struct {
+	values <-chan T
+	done chan<- bool
+}
+
+func (r *chans_Receiver[T]) Next() (T, bool) {
+	v, ok := <-r.values
+	return v, ok
+}
\ No newline at end of file
diff --git a/src/cmd/compile/internal/syntax/testdata/go2/slices.go2 b/src/cmd/compile/internal/syntax/testdata/go2/slices.go2
new file mode 100644
index 0000000000..2bacd1c2aa
--- /dev/null
+++ b/src/cmd/compile/internal/syntax/testdata/go2/slices.go2
@@ -0,0 +1,68 @@
+// Copyright 2019 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 slices implements various slice algorithms.
+package slices
+
+// Map turns a []T1 to a []T2 using a mapping function.
+func Map[T1, T2 any](s []T1, f func(T1) T2) []T2 {
+	r := make([]T2, len(s))
+	for i, v := range s {
+		r[i] = f(v)
+	}
+	return r
+}
+
+// Reduce reduces a []T1 to a single value using a reduction function.
+func Reduce[T1, T2 any](s []T1, initializer T2, f func(T2, T1) T2) T2 {
+	r := initializer
+	for _, v := range s {
+		r = f(r, v)
+	}
+	return r
+}
+
+// Filter filters values from a slice using a filter function.
+func Filter[T any](s []T, f func(T) bool) []T {
+	var r []T
+	for _, v := range s {
+		if f(v) {
+			r = append(r, v)
+		}
+	}
+	return r
+}
+
+// Example uses
+
+func limiter(x int) byte {
+	switch {
+	case x < 0:
+		return 0
+	default:
+		return byte(x)
+	case x > 255:
+		return 255
+	}
+}
+
+var input = []int{-4, 68954, 7, 44, 0, -555, 6945}
+var limited1 = Map[int, byte](input, limiter)
+var limited2 = Map(input, limiter) // using type inference
+
+func reducer(x float64, y int) float64 {
+	return x + float64(y)
+}
+
+var reduced1 = Reduce[int, float64](input, 0, reducer)
+var reduced2 = Reduce(input, 1i /* ERROR overflows */, reducer) // using type inference
+var reduced3 = Reduce(input, 1, reducer) // using type inference
+
+func filter(x int) bool {
+	return x&1 != 0
+}
+
+var filtered1 = Filter[int](input, filter)
+var filtered2 = Filter(input, filter) // using type inference
+
diff --git a/src/cmd/compile/internal/syntax/testdata/go2/smoketest.go2 b/src/cmd/compile/internal/syntax/testdata/go2/smoketest.go2
new file mode 100644
index 0000000000..e5cfba0612
--- /dev/null
+++ b/src/cmd/compile/internal/syntax/testdata/go2/smoketest.go2
@@ -0,0 +1,83 @@
+// Copyright 2020 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.
+
+// This file contains basic generic code snippets.
+
+package p
+
+// type parameter lists
+type B[P any] struct{}
+type _[P interface{}] struct{}
+type _[P B] struct{}
+type _[P B[P]] struct{}
+
+type _[A, B, C any] struct{}
+type _[A, B, C B] struct{}
+type _[A, B, C B[A, B, C]] struct{}
+type _[A1, A2 B1, A3 B2, A4, A5, A6 B3] struct{}
+
+type _[A interface{}] struct{}
+type _[A, B interface{ m() }] struct{}
+
+type _[A, B, C any] struct{}
+
+// in functions
+func _[P any]()
+func _[P interface{}]()
+func _[P B]()
+func _[P B[P]]()
+
+// in methods
+func (T) _[P any]()
+func (T) _[P interface{}]()
+func (T) _[P B]()
+func (T) _[P B[P]]()
+
+// type instantiations
+type _ T[int]
+
+// in expressions
+var _ = T[int]{}
+
+// in embedded types
+type _ struct{ T[int] }
+
+// interfaces
+type _ interface{
+	m()
+	type int
+}
+
+type _ interface{
+	type int, float, string
+	type complex128
+	underlying(underlying underlying) underlying
+}
+
+type _ interface{
+	T
+	T[int]
+}
+
+// tricky cases
+func _(T[P], T[P1, P2])
+func _(a [N]T)
+
+type _ struct{
+	T[P]
+	T[P1, P2]
+	f [N]
+}
+type _ interface{
+	m()
+
+	// generic methods - disabled for now
+	// m[] /* ERROR empty type parameter list */ ()
+	// m[ /* ERROR cannot have type parameters */ P any](P)
+
+	// instantiated types
+	// T[] /* ERROR empty type argument list */ 
+	T[P]
+	T[P1, P2]
+}
diff --git a/src/cmd/compile/internal/syntax/testdata/go2/typeinst.go2 b/src/cmd/compile/internal/syntax/testdata/go2/typeinst.go2
new file mode 100644
index 0000000000..a422d5e568
--- /dev/null
+++ b/src/cmd/compile/internal/syntax/testdata/go2/typeinst.go2
@@ -0,0 +1,60 @@
+// Copyright 2019 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 p
+
+type myInt int
+
+// Parameterized type declarations
+
+type T1[P any] P
+
+type T2[P any] struct {
+        f P
+        g int // int should still be in scope chain
+}
+
+type List[P any] []P
+
+// Alias type declarations cannot have type parameters. Syntax error.
+// TODO(gri) Disabled for now as we don't check syntax error here.
+// type A1[P any] = /* ERROR cannot be alias */ P
+
+// But an alias may refer to a generic, uninstantiated type.
+type A2 = List
+var _ A2[int]
+var _ A2 /* ERROR without instantiation */
+
+type A3 = List[int]
+var _ A3
+
+// Parameterized type instantiations
+
+var x int
+type _ x /* ERROR not a type */ [int]
+
+type _ int /* ERROR not a generic type */ [int]
+type _ myInt /* ERROR not a generic type */ [int]
+
+// TODO(gri) better error messages
+type _ T1[int]
+type _ T1[x /* ERROR not a type */ ]
+type _ T1 /* ERROR got 2 arguments but 1 type parameters */ [int, float32]
+
+var _ T2[int] = T2[int]{}
+
+var _ List[int] = []int{1, 2, 3}
+var _ List[[]int] = [][]int{{1, 2, 3}}
+var _ List[List[List[int]]]
+
+// Parameterized types containing parameterized types
+
+type T3[P any] List[P]
+
+var _ T3[int] = T3[int](List[int]{1, 2, 3})
+
+// Self-recursive generic types are not permitted
+
+type self1[P any] self1 /* ERROR illegal cycle */ [P]
+type self2[P any] *self2[P] // this is ok
diff --git a/src/cmd/compile/internal/syntax/testdata/go2/typeinst2.go2 b/src/cmd/compile/internal/syntax/testdata/go2/typeinst2.go2
new file mode 100644
index 0000000000..6e2104a515
--- /dev/null
+++ b/src/cmd/compile/internal/syntax/testdata/go2/typeinst2.go2
@@ -0,0 +1,256 @@
+// Copyright 2019 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 p
+
+type List[E any] []E
+var _ List[List[List[int]]]
+var _ List[List[List[int]]] = []List[List[int]]{}
+
+type (
+	T1[P1 any] struct {
+		f1 T2[P1, float32]
+	}
+
+	T2[P2, P3 any] struct {
+		f2 P2
+		f3 P3
+	}
+)
+
+func _() {
+	var x1 T1[int]
+	var x2 T2[int, float32]
+
+	x1.f1.f2 = 0
+	x1.f1 = x2
+}
+
+type T3[P any] T1[T2[P, P]]
+
+func _() {
+	var x1 T3[int]
+	var x2 T2[int, int]
+	x1.f1.f2 = x2
+}
+
+func f[P any] (x P) List[P] {
+	return List[P]{x}
+}
+
+var (
+	_ []int = f(0)
+	_ []float32 = f[float32](10)
+	_ List[complex128] = f(1i)
+	_ []List[int] = f(List[int]{})
+        _ List[List[int]] = []List[int]{}
+        _ = []List[int]{}
+)
+
+// Parameterized types with methods
+
+func (l List[E]) Head() (_ E, _ bool) {
+	if len(l) > 0 {
+		return l[0], true
+	}
+	return
+}
+
+// A test case for instantiating types with other types (extracted from map.go2)
+
+type Pair[K any] struct {
+	key K
+}
+
+type Receiver[T any] struct {
+	values T
+}
+
+type Iterator[K any] struct {
+	r Receiver[Pair[K]]
+}
+
+func Values [T any] (r Receiver[T]) T {
+        return r.values
+}
+
+func (it Iterator[K]) Next() K {
+        return Values[Pair[K]](it.r).key
+}
+
+// A more complex test case testing type bounds (extracted from linalg.go2 and reduced to essence)
+
+type NumericAbs[T any] interface {
+	Abs() T
+}
+
+func AbsDifference[T NumericAbs[T]](x T)
+
+type OrderedAbs[T any] T
+
+func (a OrderedAbs[T]) Abs() OrderedAbs[T]
+
+func OrderedAbsDifference[T any](x T) {
+	AbsDifference(OrderedAbs[T](x))
+}
+
+// same code, reduced to essence
+
+func g[P interface{ m() P }](x P)
+
+type T4[P any] P
+
+func (_ T4[P]) m() T4[P]
+
+func _[Q any](x Q) {
+	g(T4[Q](x))
+}
+
+// Another test case that caused  problems in the past
+
+type T5[_ interface { a() }, _ interface{}] struct{}
+
+type A[P any] struct{ x P }
+
+func (_ A[P]) a() {}
+
+var _ T5[A[int], int]
+
+// Invoking methods with parameterized receiver types uses
+// type inference to determine the actual type arguments matching
+// the receiver type parameters from the actual receiver argument.
+// Go does implicit address-taking and dereferenciation depending
+// on the actual receiver and the method's receiver type. To make
+// type inference work, the type-checker matches "pointer-ness"
+// of the actual receiver and the method's receiver type.
+// The following code tests this mechanism.
+
+type R1[A any] struct{}
+func (_ R1[A]) vm()
+func (_ *R1[A]) pm()
+
+func _[T any](r R1[T], p *R1[T]) {
+	r.vm()
+	r.pm()
+	p.vm()
+	p.pm()
+}
+
+type R2[A, B any] struct{}
+func (_ R2[A, B]) vm()
+func (_ *R2[A, B]) pm()
+
+func _[T any](r R2[T, int], p *R2[string, T]) {
+	r.vm()
+	r.pm()
+	p.vm()
+	p.pm()
+}
+
+// An interface can (explicitly) declare at most one type list.
+type _ interface {
+	m0()
+	type int, string, bool
+	type /* ERROR multiple type lists */ float32, float64
+	m1()
+	m2()
+	type /* ERROR multiple type lists */ complex64, complex128
+	type /* ERROR multiple type lists */ rune
+}
+
+// Interface type lists may contain each type at most once.
+// (If there are multiple lists, we assume the author intended
+// for them to be all in a single list, and we report the error
+// as well.)
+type _ interface {
+	type int, int /* ERROR duplicate type int */
+	type /* ERROR multiple type lists */ int /* ERROR duplicate type int */
+}
+
+type _ interface {
+	type struct{f int}, struct{g int}, struct /* ERROR duplicate type */ {f int}
+}
+
+// Interface type lists can contain any type, incl. *Named types.
+// Verify that we use the underlying type to compute the operational type.
+type MyInt int
+func add1[T interface{type MyInt}](x T) T {
+	return x + 1
+}
+
+type MyString string
+func double[T interface{type MyInt, MyString}](x T) T {
+	return x + x
+}
+
+// Embedding of interfaces with type lists leads to interfaces
+// with type lists that are the intersection of the embedded
+// type lists.
+
+type E0 interface {
+	type int, bool, string
+}
+
+type E1 interface {
+	type int, float64, string
+}
+
+type E2 interface {
+	type float64
+}
+
+type I0 interface {
+	E0
+}
+
+func f0[T I0]()
+var _ = f0[int]
+var _ = f0[bool]
+var _ = f0[string]
+var _ = f0[float64 /* ERROR does not satisfy I0 */ ]
+
+type I01 interface {
+	E0
+	E1
+}
+
+func f01[T I01]()
+var _ = f01[int]
+var _ = f01[bool /* ERROR does not satisfy I0 */ ]
+var _ = f01[string]
+var _ = f01[float64 /* ERROR does not satisfy I0 */ ]
+
+type I012 interface {
+	E0
+	E1
+	E2
+}
+
+func f012[T I012]()
+var _ = f012[int /* ERROR does not satisfy I012 */ ]
+var _ = f012[bool /* ERROR does not satisfy I012 */ ]
+var _ = f012[string /* ERROR does not satisfy I012 */ ]
+var _ = f012[float64 /* ERROR does not satisfy I012 */ ]
+
+type I12 interface {
+	E1
+	E2
+}
+
+func f12[T I12]()
+var _ = f12[int /* ERROR does not satisfy I12 */ ]
+var _ = f12[bool /* ERROR does not satisfy I12 */ ]
+var _ = f12[string /* ERROR does not satisfy I12 */ ]
+var _ = f12[float64]
+
+type I0_ interface {
+	E0
+	type int
+}
+
+func f0_[T I0_]()
+var _ = f0_[int]
+var _ = f0_[bool /* ERROR does not satisfy I0_ */ ]
+var _ = f0_[string /* ERROR does not satisfy I0_ */ ]
+var _ = f0_[float64 /* ERROR does not satisfy I0_ */ ]
diff --git a/src/cmd/compile/internal/syntax/testdata/go2/typeparams.go2 b/src/cmd/compile/internal/syntax/testdata/go2/typeparams.go2
new file mode 100644
index 0000000000..f78037f0f5
--- /dev/null
+++ b/src/cmd/compile/internal/syntax/testdata/go2/typeparams.go2
@@ -0,0 +1,451 @@
+// Copyright 2018 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 p
+
+// import "io" // for type assertion tests
+
+// The predeclared identifier "any" is only visible as a constraint
+// in a type parameter list.
+var _ any // ERROR undeclared
+func _[_ any /* ok here */ , _ interface{any /* ERROR undeclared */ }](any /* ERROR undeclared */ ) {
+        var _ any /* ERROR undeclared */
+}
+
+func identity[T any](x T) T { return x }
+
+func _[_ any](x int) int
+func _[T any](T /* ERROR redeclared */ T)()
+func _[T, T /* ERROR redeclared */ any]()
+
+func reverse[T any](list []T) []T {
+        rlist := make([]T, len(list))
+        i := len(list)
+        for _, x := range list {
+                i--
+                rlist[i] = x
+        }
+        return rlist
+}
+
+var _ = reverse /* ERROR cannot use generic function reverse */
+var _ = reverse[int, float32 /* ERROR got 2 type arguments */ ] ([]int{1, 2, 3})
+var _ = reverse[int]([ /* ERROR cannot use */ ]float32{1, 2, 3})
+var f = reverse[chan int]
+var _ = f(0 /* ERROR cannot convert 0 .* to \[\]chan int */ )
+
+func swap[A, B any](a A, b B) (B, A) { return b, a }
+
+var _ = swap /* ERROR single value is expected */ [int, float32](1, 2)
+var f32, i = swap[int, float32](swap(float32, int)(1, 2))
+var _ float32 = f32
+var _ int = i
+
+func swapswap[A, B any](a A, b B) (A, B) {
+        return swap[B, A](b, a)
+}
+
+type F[A, B any] func(A, B) (B, A)
+
+func min[T interface{ type int }](x, y T) T {
+        if x < y {
+                return x
+        }
+        return y
+}
+
+func _[T interface{type int, float32}](x, y T) bool { return x < y }
+func _[T any](x, y T) bool { return x /* ERROR cannot compare */ < y }
+func _[T interface{type int, float32, bool}](x, y T) bool { return x /* ERROR cannot compare */ < y }
+
+func _[T C1[T]](x, y T) bool { return x /* ERROR cannot compare */ < y }
+func _[T C2[T]](x, y T) bool { return x < y }
+
+type C1[T any] interface{}
+type C2[T any] interface{ type int, float32 }
+
+func new[T any]() *T {
+        var x T
+        return &x
+}
+
+var _ = new /* ERROR cannot use generic function new */
+var _ *int = new[int]()
+
+func _[T any](map[T /* ERROR invalid map key type T \(missing comparable constraint\) */]int) // w/o constraint we don't know if T is comparable
+
+func f1[T1 any](struct{T1}) int
+var _ = f1(int)(struct{T1}{})
+type T1 = int
+
+func f2[t1 any](struct{t1; x float32}) int
+var _ = f2(t1)(struct{t1; x float32}{})
+type t1 = int
+
+
+func f3[A, B, C any](A, struct{x B}, func(A, struct{x B}, *C)) int
+
+var _ = f3[int, rune, bool](1, struct{x rune}{}, nil)
+
+// indexing
+
+func _[T any] (x T, i int) { _ = x /* ERROR "cannot index" */ [i] }
+func _[T interface{ type int }] (x T, i int) { _ = x /* ERROR "cannot index" */ [i] }
+func _[T interface{ type string }] (x T, i int) { _ = x[i] }
+func _[T interface{ type []int }] (x T, i int) { _ = x[i] }
+func _[T interface{ type [10]int, *[20]int, map[string]int }] (x T, i int) { _ = x[i] }
+func _[T interface{ type string, []byte }] (x T, i int) { _ = x[i] }
+func _[T interface{ type []int, [1]rune }] (x T, i int) { _ = x /* ERROR "cannot index" */ [i] }
+func _[T interface{ type string, []rune }] (x T, i int) { _ = x /* ERROR "cannot index" */ [i] }
+
+// slicing
+// TODO(gri) implement this
+
+func _[T interface{ type string }] (x T, i, j, k int) { _ = x /* ERROR invalid operation */ [i:j:k] }
+
+// len/cap built-ins
+
+func _[T any](x T) { _ = len(x /* ERROR invalid argument */ ) }
+func _[T interface{ type int }](x T) { _ = len(x /* ERROR invalid argument */ ) }
+func _[T interface{ type string, []byte, int }](x T) { _ = len(x /* ERROR invalid argument */ ) }
+func _[T interface{ type string }](x T) { _ = len(x) }
+func _[T interface{ type [10]int }](x T) { _ = len(x) }
+func _[T interface{ type []byte }](x T) { _ = len(x) }
+func _[T interface{ type map[int]int }](x T) { _ = len(x) }
+func _[T interface{ type chan int }](x T) { _ = len(x) }
+func _[T interface{ type string, []byte, chan int }](x T) { _ = len(x) }
+
+func _[T any](x T) { _ = cap(x /* ERROR invalid argument */ ) }
+func _[T interface{ type int }](x T) { _ = cap(x /* ERROR invalid argument */ ) }
+func _[T interface{ type string, []byte, int }](x T) { _ = cap(x /* ERROR invalid argument */ ) }
+func _[T interface{ type string }](x T) { _ = cap(x /* ERROR invalid argument */ ) }
+func _[T interface{ type [10]int }](x T) { _ = cap(x) }
+func _[T interface{ type []byte }](x T) { _ = cap(x) }
+func _[T interface{ type map[int]int }](x T) { _ = cap(x /* ERROR invalid argument */ ) }
+func _[T interface{ type chan int }](x T) { _ = cap(x) }
+func _[T interface{ type []byte, chan int }](x T) { _ = cap(x) }
+
+// range iteration
+
+func _[T interface{}](x T) {
+        for range x /* ERROR cannot range */ {}
+}
+
+func _[T interface{ type string, []string }](x T) {
+        for range x {}
+        for i := range x { _ = i }
+        for i, _ := range x { _ = i }
+        for i, e := range x /* ERROR must have the same element type */ { _ = i }
+        for _, e := range x /* ERROR must have the same element type */ {}
+        var e rune
+        _ = e
+        for _, (e) = range x /* ERROR must have the same element type */ {}
+}
+
+
+func _[T interface{ type string, []rune, map[int]rune }](x T) {
+        for _, e := range x { _ = e }
+        for i, e := range x { _ = i; _ = e }
+}
+
+func _[T interface{ type string, []rune, map[string]rune }](x T) {
+        for _, e := range x { _ = e }
+        for i, e := range x /* ERROR must have the same key type */ { _ = e }
+}
+
+func _[T interface{ type string, chan int }](x T) {
+        for range x {}
+        for i := range x { _ = i }
+        for i, _ := range x { _ = i } // TODO(gri) should get an error here: channels only return one value
+}
+
+func _[T interface{ type string, chan<-int }](x T) {
+        for i := range x /* ERROR send-only channel */ { _ = i }
+}
+
+// type inference checks
+
+var _ = new() /* ERROR cannot infer T */
+
+func f4[A, B, C any](A, B) C
+
+var _ = f4(1, 2) /* ERROR cannot infer C */
+var _ = f4[int, float32, complex128](1, 2)
+
+func f5[A, B, C any](A, []*B, struct{f []C}) int
+
+var _ = f5[int, float32, complex128](0, nil, struct{f []complex128}{})
+var _ = f5(0, nil, struct{f []complex128}{}) // ERROR cannot infer
+var _ = f5(0, []*float32{new[float32]()}, struct{f []complex128}{})
+
+func f6[A any](A, []A) int
+
+var _ = f6(0, nil)
+
+func f6nil[A any](A) int
+
+var _ = f6nil(nil) // ERROR cannot infer
+
+// type inference with variadic functions
+
+func f7[T any](...T) T
+
+var _ int = f7() /* ERROR cannot infer T */
+var _ int = f7(1)
+var _ int = f7(1, 2)
+var _ int = f7([]int{}...)
+var _ int = f7 /* ERROR cannot use */ ([]float64{}...)
+var _ float64 = f7([]float64{}...)
+var _ = f7[float64](1, 2.3)
+var _ = f7(float64(1), 2.3)
+var _ = f7(1, 2.3 /* ERROR does not match */ )
+var _ = f7(1.2, 3 /* ERROR does not match */ )
+
+func f8[A, B any](A, B, ...B) int
+
+var _ = f8(1) /* ERROR not enough arguments */
+var _ = f8(1, 2.3)
+var _ = f8(1, 2.3, 3.4, 4.5)
+var _ = f8(1, 2.3, 3.4, 4 /* ERROR does not match */ )
+var _ = f8(int, float64)(1, 2.3, 3.4, 4)
+
+var _ = f8(int, float64)(0, 0, nil...) // test case for #18268
+
+// init functions cannot have type parameters
+
+func init() {}
+func init[/* ERROR func init must have no type parameters */ _ any]() {}
+func init[/* ERROR func init must have no type parameters */ P any]() {}
+
+type T struct {}
+
+func (T) m1() {}
+// The type checker accepts method type parameters if configured accordingly.
+func (T) m2[_ any]() {}
+func (T) m3[P any]() {}
+
+// type inference across parameterized types
+
+type S1[P any] struct { f P }
+
+func f9[P any](x S1[P])
+
+func _() {
+        f9[int](S1[int]{42})
+	f9(S1[int]{42})
+}
+
+type S2[A, B, C any] struct{}
+
+func f10[X, Y, Z any](a S2[X, int, Z], b S2[X, Y, bool])
+
+func _[P any]() {
+        f10[int, float32, string](S2[int, int, string]{}, S2[int, float32, bool]{})
+        f10(S2[int, int, string]{}, S2[int, float32, bool]{})
+        f10(S2[P, int, P]{}, S2[P, float32, bool]{})
+}
+
+// corner case for type inference
+// (was bug: after instanting f11, the type-checker didn't mark f11 as non-generic)
+
+func f11[T any]()
+
+func _() {
+	f11[int]()
+}
+
+// the previous example was extracted from
+
+func f12[T interface{m() T}]()
+
+type A[T any] T
+
+func (a A[T]) m() A[T]
+
+func _[T any]() {
+	f12(A[T])()
+}
+
+// method expressions
+
+func (_ S1[P]) m()
+
+func _() {
+	m := S1[int].m
+	m(struct { f int }{42})
+}
+
+func _[T any] (x T) {
+        m := S1[T].m
+        m(S1[T]{x})
+}
+
+// type parameters in methods (generalization)
+
+type R0 struct{}
+
+func (R0) _[T any](x T)
+func (R0 /* ERROR invalid receiver */ ) _[R0 any]() // scope of type parameters starts at "func"
+
+type R1[A, B any] struct{}
+
+func (_ R1[A, B]) m0(A, B)
+func (_ R1[A, B]) m1[T any](A, B, T) T
+func (_ R1 /* ERROR not a generic type */ [R1, _]) _()
+func (_ R1[A, B]) _[A /* ERROR redeclared */ any](B)
+
+func _() {
+        var r R1[int, string]
+        r.m1[rune](42, "foo", 'a')
+        r.m1[rune](42, "foo", 1.2 /* ERROR truncated to rune */)
+        r.m1(42, "foo", 1.2) // using type inference
+        var _ float64 = r.m1(42, "foo", 1.2)
+}
+
+type I1[A any] interface {
+        m1(A)
+}
+
+var _ I1[int] = r1[int]{}
+
+type r1[T any] struct{}
+
+func (_ r1[T]) m1(T)
+
+type I2[A, B any] interface {
+        m1(A)
+        m2(A) B
+}
+
+var _ I2[int, float32] = R2[int, float32]{}
+
+type R2[P, Q any] struct{}
+
+func (_ R2[X, Y]) m1(X)
+func (_ R2[X, Y]) m2(X) Y
+
+// type assertions and type switches over generic types
+// NOTE: These are currently disabled because it's unclear what the correct
+// approach is, and one can always work around by assigning the variable to
+// an interface first.
+
+// // ReadByte1 corresponds to the ReadByte example in the draft design.
+// func ReadByte1[T io.Reader](r T) (byte, error) {
+// 	if br, ok := r.(io.ByteReader); ok {
+// 		return br.ReadByte()
+// 	}
+// 	var b [1]byte
+// 	_, err := r.Read(b[:])
+// 	return b[0], err
+// }
+//
+// // ReadBytes2 is like ReadByte1 but uses a type switch instead.
+// func ReadByte2[T io.Reader](r T) (byte, error) {
+//         switch br := r.(type) {
+//         case io.ByteReader:
+//                 return br.ReadByte()
+//         }
+// 	var b [1]byte
+// 	_, err := r.Read(b[:])
+// 	return b[0], err
+// }
+//
+// // type assertions and type switches over generic types are strict
+// type I3 interface {
+//         m(int)
+// }
+//
+// type I4 interface {
+//         m() int // different signature from I3.m
+// }
+//
+// func _[T I3](x I3, p T) {
+//         // type assertions and type switches over interfaces are not strict
+//         _ = x.(I4)
+//         switch x.(type) {
+//         case I4:
+//         }
+// 
+//         // type assertions and type switches over generic types are strict
+//         _ = p /* ERROR cannot have dynamic type I4 */.(I4)
+//         switch p.(type) {
+//         case I4 /* ERROR cannot have dynamic type I4 */ :
+//         }
+// }
+
+// type assertions and type switches over generic types lead to errors for now
+
+func _[T any](x T) {
+	_ = x /* ERROR not an interface */ .(int)
+	switch x /* ERROR not an interface */ .(type) {
+	}
+
+	// work-around
+	var t interface{} = x
+	_ = t.(int)
+	switch t.(type) {
+	}
+}
+
+func _[T interface{type int}](x T) {
+	_ = x /* ERROR not an interface */ .(int)
+	switch x /* ERROR not an interface */ .(type) {
+	}
+
+	// work-around
+	var t interface{} = x
+	_ = t.(int)
+	switch t.(type) {
+	}
+}
+
+// error messages related to type bounds mention those bounds
+type C[P any] interface{}
+
+func _[P C[P]] (x P) {
+	x.m /* ERROR x.m undefined */ ()
+}
+
+type I interface {}
+
+func _[P I] (x P) {
+	x.m /* ERROR interface I has no method m */ ()
+}
+
+func _[P interface{}] (x P) {
+	x.m /* ERROR type bound for P has no method m */ ()
+}
+
+func _[P any] (x P) {
+	x.m /* ERROR type bound for P has no method m */ ()
+}
+
+// automatic distinguishing between array and generic types
+// NOTE: Disabled when using unified parameter list syntax.
+/*
+const P = 10
+type A1 [P]byte
+func _(a A1) {
+        assert(len(a) == 10)
+}
+
+type A2 [P]struct{
+        f [P]byte
+}
+func _(a A2) {
+        assert(len(a) == 10)
+        assert(len(a[0].f) == 10)
+}
+
+type A3 [P]func(x [P]A3)
+func _(a A3) {
+        assert(len(a) == 10)
+}
+
+type T2[P] struct{ P }
+var _ T2[int]
+
+type T3[P] func(P)
+var _ T3[int]
+*/
\ No newline at end of file
-- 
GitLab


From 48755e06aa2ed6ec977efc6df976bcc375a2e6f2 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 12 Oct 2020 16:19:49 -0700
Subject: [PATCH 0004/2400] [dev.typeparams] cmd/compile: enable parsing of
 generic code with new -G flag

Providing the -G flag instructs the compiler to accept type parameters.
For now, the compiler only parses such files and then exits.

Added a new test directory (test/typeparam) and initial test case.

Port from dev.go2go branch.

Change-Id: Ic11e33a9d5f012f8def0bdae205043659562ac73
Reviewed-on: https://go-review.googlesource.com/c/go/+/261660
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/main.go  | 10 ++++-
 src/cmd/compile/internal/gc/noder.go | 13 +++++--
 test/run.go                          |  2 +-
 test/typeparam/smoketest.go          | 57 ++++++++++++++++++++++++++++
 4 files changed, 77 insertions(+), 5 deletions(-)
 create mode 100644 test/typeparam/smoketest.go

diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index e4e4ce72fd..21e4757a92 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -216,6 +216,7 @@ func Main(archInit func(*Arch)) {
 	objabi.Flagcount("C", "disable printing of columns in error messages", &Debug['C']) // TODO(gri) remove eventually
 	flag.StringVar(&localimport, "D", "", "set relative `path` for local imports")
 	objabi.Flagcount("E", "debug symbol export", &Debug['E'])
+	objabi.Flagcount("G", "accept generic code", &Debug['G'])
 	objabi.Flagfn1("I", "add `directory` to import search path", addidir)
 	objabi.Flagcount("K", "debug missing line numbers", &Debug['K'])
 	objabi.Flagcount("L", "show full file names in error messages", &Debug['L'])
@@ -571,9 +572,16 @@ func Main(archInit func(*Arch)) {
 	loadsys()
 
 	timings.Start("fe", "parse")
-	lines := parseFiles(flag.Args())
+	lines := parseFiles(flag.Args(), Debug['G'] != 0)
 	timings.Stop()
 	timings.AddEvent(int64(lines), "lines")
+	if Debug['G'] != 0 {
+		// can only parse generic code for now
+		if nerrors+nsavederrors != 0 {
+			errorexit()
+		}
+		return
+	}
 
 	finishUniverse()
 
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 8b11055983..e75c645a57 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -24,7 +24,7 @@ import (
 // Each declaration in every *syntax.File is converted to a syntax tree
 // and its root represented by *Node is appended to xtop.
 // Returns the total count of parsed lines.
-func parseFiles(filenames []string) uint {
+func parseFiles(filenames []string, allowGenerics bool) uint {
 	noders := make([]*noder, 0, len(filenames))
 	// Limit the number of simultaneously open files.
 	sem := make(chan struct{}, runtime.GOMAXPROCS(0)+10)
@@ -49,7 +49,11 @@ func parseFiles(filenames []string) uint {
 			}
 			defer f.Close()
 
-			p.file, _ = syntax.Parse(base, f, p.error, p.pragma, syntax.CheckBranches) // errors are tracked via p.error
+			mode := syntax.CheckBranches
+			if allowGenerics {
+				mode |= syntax.AllowGenerics
+			}
+			p.file, _ = syntax.Parse(base, f, p.error, p.pragma, mode) // errors are tracked via p.error
 		}(filename)
 	}
 
@@ -59,7 +63,10 @@ func parseFiles(filenames []string) uint {
 			p.yyerrorpos(e.Pos, "%s", e.Msg)
 		}
 
-		p.node()
+		// noder cannot handle generic code yet
+		if !allowGenerics {
+			p.node()
+		}
 		lines += p.file.EOF.Line()
 		p.file = nil // release memory
 
diff --git a/test/run.go b/test/run.go
index 672861c8d7..7422e6922d 100644
--- a/test/run.go
+++ b/test/run.go
@@ -58,7 +58,7 @@ var (
 
 	// dirs are the directories to look for *.go files in.
 	// TODO(bradfitz): just use all directories?
-	dirs = []string{".", "ken", "chan", "interface", "syntax", "dwarf", "fixedbugs", "codegen", "runtime"}
+	dirs = []string{".", "ken", "chan", "interface", "syntax", "dwarf", "fixedbugs", "codegen", "runtime", "typeparam"}
 
 	// ratec controls the max number of tests running at a time.
 	ratec chan bool
diff --git a/test/typeparam/smoketest.go b/test/typeparam/smoketest.go
new file mode 100644
index 0000000000..d17809eb63
--- /dev/null
+++ b/test/typeparam/smoketest.go
@@ -0,0 +1,57 @@
+// compile -G
+
+// Copyright 2020 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.
+
+// This file checks simple code using type parameters.
+
+package smoketest
+
+// type parameters for functions
+func f1[P any]()
+func f2[P1, P2 any, P3 any]()
+func f3[P interface{}](x P, y T1[int])
+
+// function instantiations
+var _ = f1[int]
+var _ = f2[int, string, struct{}]
+var _ = f3[bool]
+
+// type parameters for types
+type T1[P any] struct{}
+type T2[P1, P2 any, P3 any] struct{}
+type T3[P interface{}] interface{}
+
+// type instantiations
+type _ T1[int]
+type _ T2[int, string, struct{}]
+type _ T3[bool]
+
+// methods
+func (T1[P]) m1() {}
+func (x T2[P1, P2, P3]) m1() {}
+func (_ T3[_]) m1() {}
+
+// type lists
+type _ interface {
+	m1()
+	m2()
+	type int, float32, string
+	m3()
+	type bool
+}
+
+// embedded instantiated types
+type _ struct {
+	f1, f2 int
+	T1[int]
+	T2[int, string, struct{}]
+	T3[bool]
+}
+
+type _ interface {
+	m1()
+	m2()
+	T3[bool]
+}
-- 
GitLab


From 73f529845c91818c58f26994099db17c8ee2b2f3 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 13 Oct 2020 22:33:17 -0700
Subject: [PATCH 0005/2400] [dev.typeparams] cmd/compile/internal/syntax:
 always use IndexExpr node for type instantiation

Per @mdempsky's suggestion: Instead of representing a type instantiation T[P]
by an IndexExpr node, and a type instantiation with multiple type arguments
T[P1, P2] by a CallExpr node with special Brackets flag, always use an IndexExpr.
Use a ListExpr as index in the (less common) case of multiple type arguments.

This removes the need for the CallExpr.Brackets field and cleans up the parser
code around type instantiations.

Backport of syntax package changes from https://golang.org/cl/262020.

Change-Id: I32e8bc4eafac5b3ef2e7eb40fa8c790a5a905b69
Reviewed-on: https://go-review.googlesource.com/c/go/+/262137
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/syntax/nodes.go      |   8 +-
 src/cmd/compile/internal/syntax/parser.go     | 216 +++++++++++-------
 .../compile/internal/syntax/parser_test.go    |   2 +-
 3 files changed, 138 insertions(+), 88 deletions(-)

diff --git a/src/cmd/compile/internal/syntax/nodes.go b/src/cmd/compile/internal/syntax/nodes.go
index f2dbdcda29..e5b69628ec 100644
--- a/src/cmd/compile/internal/syntax/nodes.go
+++ b/src/cmd/compile/internal/syntax/nodes.go
@@ -184,6 +184,7 @@ type (
 	}
 
 	// X[Index]
+	// X[T1, T2, ...] (with Ti = Index.(*ListExpr).ElemList[i])
 	IndexExpr struct {
 		X     Expr
 		Index Expr
@@ -225,10 +226,9 @@ type (
 
 	// Fun(ArgList[0], ArgList[1], ...)
 	CallExpr struct {
-		Fun      Expr
-		ArgList  []Expr // nil means no arguments
-		HasDots  bool   // last argument is followed by ...
-		Brackets bool   // []'s instead of ()'s
+		Fun     Expr
+		ArgList []Expr // nil means no arguments
+		HasDots bool   // last argument is followed by ...
 		expr
 	}
 
diff --git a/src/cmd/compile/internal/syntax/parser.go b/src/cmd/compile/internal/syntax/parser.go
index 126b87b4ee..dbec462ab1 100644
--- a/src/cmd/compile/internal/syntax/parser.go
+++ b/src/cmd/compile/internal/syntax/parser.go
@@ -458,15 +458,15 @@ func isEmptyFuncDecl(dcl Decl) bool {
 // ----------------------------------------------------------------------------
 // Declarations
 
-// list parses a possibly empty, sep-separated list, optionally
-// followed sep, and closed by close. sep must be one of _Comma
+// list parses a possibly empty, sep-separated list of elements, optionally
+// followed by sep, and closed by close (or EOF). sep must be one of _Comma
 // or _Semi, and close must be one of _Rparen, _Rbrace, or _Rbrack.
-// For each list element, f is called. After f returns true, no
-// more list elements are accepted. list returns the position
-// of the closing token.
 //
-// list = { f sep } ")" |
-//        { f sep } "}" . // "," or ";" is optional before ")", "}" or "]"
+// For each list element, f is called. Specifically, unless we're at close
+// (or EOF), f is called at least once. After f returns true, no more list
+// elements are accepted. list returns the position of the closing token.
+//
+// list = [ f { sep f } [sep] ] close .
 //
 func (p *parser) list(sep, close token, f func() bool) Pos {
 	if debug && (sep != _Comma && sep != _Semi || close != _Rparen && close != _Rbrace && close != _Rbrack) {
@@ -1017,43 +1017,44 @@ loop:
 				break
 			}
 
-			p.xnest++
-
 			var i Expr
 			if p.tok != _Colon {
-				i = p.expr()
-				if p.got(_Rbrack) {
-					// x[i]
-					t := new(IndexExpr)
-					t.pos = pos
-					t.X = x
-					t.Index = i
-					x = t
+				if p.mode&AllowGenerics == 0 {
+					p.xnest++
+					i = p.expr()
 					p.xnest--
-					break
-				}
-
-				if p.mode&AllowGenerics != 0 && p.tok == _Comma {
-					// x[i, ... (instantiated type)
-					// TODO(gri) Suggestion by mdempsky@: Use IndexExpr + ExprList for this case.
-					//           Then we can get rid of CallExpr.Brackets.
-					t := new(CallExpr)
-					t.pos = pos
-					t.Fun = x
-					t.ArgList, _ = p.argList(i, _Rbrack)
-					t.Brackets = true
-					x = t
-					p.xnest--
-					break
+					if p.got(_Rbrack) {
+						// x[i]
+						t := new(IndexExpr)
+						t.pos = pos
+						t.X = x
+						t.Index = i
+						x = t
+						break
+					}
+				} else {
+					var comma bool
+					i, comma = p.typeList()
+					if comma || p.tok == _Rbrack {
+						p.want(_Rbrack)
+						// x[i,] or x[i, j, ...]
+						t := new(IndexExpr)
+						t.pos = pos
+						t.X = x
+						t.Index = i
+						x = t
+						break
+					}
 				}
 			}
 
 			// x[i:...
+			p.want(_Colon)
+			p.xnest++
 			t := new(SliceExpr)
 			t.pos = pos
 			t.X = x
 			t.Index[0] = i
-			p.want(_Colon)
 			if p.tok != _Colon && p.tok != _Rbrack {
 				// x[i:j...
 				t.Index[1] = p.expr()
@@ -1074,17 +1075,16 @@ loop:
 					t.Index[2] = p.badExpr()
 				}
 			}
+			p.xnest--
 			p.want(_Rbrack)
-
 			x = t
-			p.xnest--
 
 		case _Lparen:
 			t := new(CallExpr)
 			t.pos = pos
 			p.next()
 			t.Fun = x
-			t.ArgList, t.HasDots = p.argList(nil, _Rparen)
+			t.ArgList, t.HasDots = p.argList()
 			x = t
 
 		case _Lbrace:
@@ -1093,17 +1093,12 @@ loop:
 			t := unparen(x)
 			// determine if '{' belongs to a composite literal or a block statement
 			complit_ok := false
-			switch t := t.(type) {
+			switch t.(type) {
 			case *Name, *SelectorExpr:
 				if p.xnest >= 0 {
 					// x is possibly a composite literal type
 					complit_ok = true
 				}
-			case *CallExpr:
-				if t.Brackets && p.xnest >= 0 {
-					// x is possibly a composite literal type
-					complit_ok = true
-				}
 			case *IndexExpr:
 				if p.xnest >= 0 {
 					// x is possibly a composite literal type
@@ -1302,12 +1297,12 @@ func (p *parser) typeInstance(typ Expr) Expr {
 		return typ
 	}
 
-	call := new(CallExpr)
-	call.pos = pos
-	call.Fun = typ
-	call.ArgList, _ = p.argList(nil, _Rbrack)
-	call.Brackets = true
-	return call
+	x := new(IndexExpr)
+	x.pos = pos
+	x.X = typ
+	x.Index, _ = p.typeList()
+	p.want(_Rbrack)
+	return x
 }
 
 func (p *parser) funcType() *FuncType {
@@ -1521,9 +1516,9 @@ func (p *parser) fieldDecl(styp *StructType) {
 		// type T[P1, P2, ...] or a field T of array/slice type [P]E or []E.
 		if p.mode&AllowGenerics != 0 && len(names) == 1 && p.tok == _Lbrack {
 			typ = p.arrayOrTArgs()
-			if typ, ok := typ.(*CallExpr); ok {
+			if typ, ok := typ.(*IndexExpr); ok {
 				// embedded type T[P1, P2, ...]
-				typ.Fun = name // name == names[0]
+				typ.X = name // name == names[0]
 				tag := p.oliteral()
 				p.addField(styp, pos, nil, typ, tag)
 				break
@@ -1589,25 +1584,25 @@ func (p *parser) arrayOrTArgs() Expr {
 		return p.sliceType(pos)
 	}
 
-	// x [P]E or x[P]
-	args, _ := p.argList(nil, _Rbrack)
-	if len(args) == 1 {
+	// x [n]E or x[n,], x[n1, n2], ...
+	n, comma := p.typeList()
+	p.want(_Rbrack)
+	if !comma {
 		if elem := p.typeOrNil(); elem != nil {
-			// x [P]E
+			// x [n]E
 			t := new(ArrayType)
 			t.pos = pos
-			t.Len = args[0]
+			t.Len = n
 			t.Elem = elem
 			return t
 		}
 	}
 
-	// x[P], x[P1, P2], ...
-	t := new(CallExpr)
+	// x[n,], x[n1, n2], ...
+	t := new(IndexExpr)
 	t.pos = pos
-	// t.Fun will be filled in by caller
-	t.ArgList = args
-	t.Brackets = true
+	// t.X will be filled in by caller
+	t.Index = n
 	return t
 }
 
@@ -1664,7 +1659,8 @@ func (p *parser) methodDecl() *Field {
 			pos := p.pos()
 			p.next()
 
-			// empty type parameter or argument lists are not permitted
+			// Empty type parameter or argument lists are not permitted.
+			// Treat as if [] were absent.
 			if p.tok == _Rbrack {
 				// name[]
 				pos := p.pos()
@@ -1684,7 +1680,21 @@ func (p *parser) methodDecl() *Field {
 			// A type argument list looks like a parameter list with only
 			// types. Parse a parameter list and decide afterwards.
 			list := p.paramList(nil, _Rbrack)
-			if len(list) > 0 && list[0].Name != nil {
+			if len(list) == 0 {
+				// The type parameter list is not [] but we got nothing
+				// due to other errors (reported by paramList). Treat
+				// as if [] were absent.
+				if p.tok == _Lparen {
+					f.Name = name
+					f.Type = p.funcType()
+				} else {
+					f.Type = name
+				}
+				break
+			}
+
+			// len(list) > 0
+			if list[0].Name != nil {
 				// generic method
 				f.Name = name
 				f.Type = p.funcType()
@@ -1696,15 +1706,22 @@ func (p *parser) methodDecl() *Field {
 			}
 
 			// embedded instantiated type
-			call := new(CallExpr)
-			call.pos = pos
-			call.Fun = name
-			call.Brackets = true
-			call.ArgList = make([]Expr, len(list))
-			for i := range list {
-				call.ArgList[i] = list[i].Type
+			t := new(IndexExpr)
+			t.pos = pos
+			t.X = name
+			if len(list) == 1 {
+				t.Index = list[0].Type
+			} else {
+				// len(list) > 1
+				l := new(ListExpr)
+				l.pos = list[0].Pos()
+				l.ElemList = make([]Expr, len(list))
+				for i := range list {
+					l.ElemList[i] = list[i].Type
+				}
+				t.Index = l
 			}
-			f.Type = call
+			f.Type = t
 			break
 		}
 		fallthrough
@@ -1733,8 +1750,8 @@ func (p *parser) paramDeclOrNil(name *Name) *Field {
 
 		if p.mode&AllowGenerics != 0 && p.tok == _Lbrack {
 			f.Type = p.arrayOrTArgs()
-			if typ, ok := f.Type.(*CallExpr); ok {
-				typ.Fun = name
+			if typ, ok := f.Type.(*IndexExpr); ok {
+				typ.X = name
 			} else {
 				f.Name = name
 			}
@@ -2427,22 +2444,20 @@ func (p *parser) stmtList() (l []Stmt) {
 	return
 }
 
-// Arguments = "(" [ ( ExpressionList | Type [ "," ExpressionList ] ) [ "..." ] [ "," ] ] ")" .
-func (p *parser) argList(arg Expr, close token) (list []Expr, hasDots bool) {
+// argList parses a possibly empty, comma-separated list of arguments,
+// optionally followed by a comma (if not empty), and closed by ")".
+// The last argument may be followed by "...".
+//
+// argList = [ arg { "," arg } [ "..." ] [ "," ] ] ")" .
+func (p *parser) argList() (list []Expr, hasDots bool) {
 	if trace {
 		defer p.trace("argList")()
 	}
 
 	p.xnest++
-	p.list(_Comma, close, func() bool {
-		if arg == nil {
-			arg = p.expr()
-		}
-		list = append(list, arg)
-		arg = nil
-		if close == _Rparen {
-			hasDots = p.got(_DotDotDot)
-		}
+	p.list(_Comma, _Rparen, func() bool {
+		list = append(list, p.expr())
+		hasDots = p.got(_DotDotDot)
 		return hasDots
 	})
 	p.xnest--
@@ -2548,6 +2563,41 @@ func (p *parser) exprList() Expr {
 	return x
 }
 
+// typeList parses a non-empty, comma-separated list of expressions,
+// optionally followed by a comma. The first list element may be any
+// expression, all other list elements must be type expressions.
+// If there is more than one argument, the result is a *ListExpr.
+// The comma result indicates whether there was a (separating or
+// trailing) comma.
+//
+// typeList = arg { "," arg } [ "," ] .
+func (p *parser) typeList() (x Expr, comma bool) {
+	if trace {
+		defer p.trace("typeList")()
+	}
+
+	p.xnest++
+	x = p.expr()
+	if p.got(_Comma) {
+		comma = true
+		if t := p.typeOrNil(); t != nil {
+			list := []Expr{x, t}
+			for p.got(_Comma) {
+				if t = p.typeOrNil(); t == nil {
+					break
+				}
+				list = append(list, t)
+			}
+			l := new(ListExpr)
+			l.pos = x.Pos() // == list[0].Pos()
+			l.ElemList = list
+			x = l
+		}
+	}
+	p.xnest--
+	return
+}
+
 // unparen removes all parentheses around an expression.
 func unparen(x Expr) Expr {
 	for {
diff --git a/src/cmd/compile/internal/syntax/parser_test.go b/src/cmd/compile/internal/syntax/parser_test.go
index e270879739..70651efeae 100644
--- a/src/cmd/compile/internal/syntax/parser_test.go
+++ b/src/cmd/compile/internal/syntax/parser_test.go
@@ -26,7 +26,7 @@ var (
 )
 
 func TestParse(t *testing.T) {
-	ParseFile(*src_, func(err error) { t.Error(err) }, nil, 0)
+	ParseFile(*src_, func(err error) { t.Error(err) }, nil, AllowGenerics)
 }
 
 func TestParseGo2(t *testing.T) {
-- 
GitLab


From e9e58a4d49f518ab6ce3a2b2ed4efb34e022c1d4 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 14 Oct 2020 22:09:47 -0700
Subject: [PATCH 0006/2400] [dev.typeparams] cmd/compile/internal/syntax: fix
 printing of channel types

Change-Id: I80a3ca77d0642711913c9584e70059e4ed668860
Reviewed-on: https://go-review.googlesource.com/c/go/+/262444
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/syntax/printer.go    | 10 ++++++-
 .../compile/internal/syntax/printer_test.go   | 26 +++++++++++++++----
 2 files changed, 30 insertions(+), 6 deletions(-)

diff --git a/src/cmd/compile/internal/syntax/printer.go b/src/cmd/compile/internal/syntax/printer.go
index 8ff3bfa794..c8bf59675a 100644
--- a/src/cmd/compile/internal/syntax/printer.go
+++ b/src/cmd/compile/internal/syntax/printer.go
@@ -484,7 +484,15 @@ func (p *printer) printRawNode(n Node) {
 		if n.Dir == SendOnly {
 			p.print(_Arrow)
 		}
-		p.print(blank, n.Elem)
+		p.print(blank)
+		if e, _ := n.Elem.(*ChanType); n.Dir == 0 && e != nil && e.Dir == RecvOnly {
+			// don't print chan (<-chan T) as chan <-chan T
+			p.print(_Lparen)
+			p.print(n.Elem)
+			p.print(_Rparen)
+		} else {
+			p.print(n.Elem)
+		}
 
 	// statements
 	case *DeclStmt:
diff --git a/src/cmd/compile/internal/syntax/printer_test.go b/src/cmd/compile/internal/syntax/printer_test.go
index c3b9aca229..cae2c40f6c 100644
--- a/src/cmd/compile/internal/syntax/printer_test.go
+++ b/src/cmd/compile/internal/syntax/printer_test.go
@@ -30,12 +30,28 @@ func TestPrint(t *testing.T) {
 	}
 }
 
+var stringTests = []string{
+	"package p",
+	"package p; type _ int; type T1 = struct{}; type ( _ *struct{}; T2 = float32 )",
+
+	// channels
+	"package p; type _ chan chan int",
+	"package p; type _ chan (<-chan int)",
+	"package p; type _ chan chan<- int",
+
+	"package p; type _ <-chan chan int",
+	"package p; type _ <-chan <-chan int",
+	"package p; type _ <-chan chan<- int",
+
+	"package p; type _ chan<- chan int",
+	"package p; type _ chan<- <-chan int",
+	"package p; type _ chan<- chan<- int",
+
+	// TODO(gri) expand
+}
+
 func TestPrintString(t *testing.T) {
-	for _, want := range []string{
-		"package p",
-		"package p; type _ = int; type T1 = struct{}; type ( _ = *struct{}; T2 = float32 )",
-		// TODO(gri) expand
-	} {
+	for _, want := range stringTests {
 		ast, err := Parse(nil, strings.NewReader(want), nil, nil, 0)
 		if err != nil {
 			t.Error(err)
-- 
GitLab


From 5e46c6a10f578333d9ba3f9aa2e4a0d3adb196a4 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 19 Oct 2020 15:24:39 -0700
Subject: [PATCH 0007/2400] [dev.typeparams] cmd/compile/internal/syntax: add
 Pos method

Allows syntax.Pos values to implement

interface {
	Pos() Pos
}

Preparation step for types2 package.

Change-Id: Ib0f4d7695a3d066983567d680fc3b9256a31c31d
Reviewed-on: https://go-review.googlesource.com/c/go/+/263622
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/syntax/pos.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/cmd/compile/internal/syntax/pos.go b/src/cmd/compile/internal/syntax/pos.go
index c683c7fcfc..99734d42d8 100644
--- a/src/cmd/compile/internal/syntax/pos.go
+++ b/src/cmd/compile/internal/syntax/pos.go
@@ -26,6 +26,7 @@ func MakePos(base *PosBase, line, col uint) Pos { return Pos{base, sat32(line),
 // TODO(gri) IsKnown makes an assumption about linebase < 1.
 //           Maybe we should check for Base() != nil instead.
 
+func (pos Pos) Pos() Pos       { return pos }
 func (pos Pos) IsKnown() bool  { return pos.line > 0 }
 func (pos Pos) Base() *PosBase { return pos.base }
 func (pos Pos) Line() uint     { return uint(pos.line) }
-- 
GitLab


From 6ff16fe3ee46f8e35c18226d04bd38a396eb4175 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 19 Oct 2020 15:47:40 -0700
Subject: [PATCH 0008/2400] [dev.typeparams] cmd/compile/internal/syntax: add
 utility functions for testing

Preparation step for types2 package.

Change-Id: I8f9557b1a48ad570ba38aac7b720e639218dc6a7
Reviewed-on: https://go-review.googlesource.com/c/go/+/263623
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/fmtmap_test.go                |  1 +
 src/cmd/compile/internal/syntax/testing.go    | 72 +++++++++++++++++++
 .../compile/internal/syntax/testing_test.go   | 45 ++++++++++++
 3 files changed, 118 insertions(+)
 create mode 100644 src/cmd/compile/internal/syntax/testing.go
 create mode 100644 src/cmd/compile/internal/syntax/testing_test.go

diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
index 179c60187f..a3d09576a7 100644
--- a/src/cmd/compile/fmtmap_test.go
+++ b/src/cmd/compile/fmtmap_test.go
@@ -123,6 +123,7 @@ var knownFormats = map[string]string{
 	"cmd/compile/internal/ssa.register %d":            "",
 	"cmd/compile/internal/ssa.relation %s":            "",
 	"cmd/compile/internal/syntax.Error %q":            "",
+	"cmd/compile/internal/syntax.Error %v":            "",
 	"cmd/compile/internal/syntax.Expr %#v":            "",
 	"cmd/compile/internal/syntax.LitKind %d":          "",
 	"cmd/compile/internal/syntax.Node %T":             "",
diff --git a/src/cmd/compile/internal/syntax/testing.go b/src/cmd/compile/internal/syntax/testing.go
new file mode 100644
index 0000000000..3e02dc1c5d
--- /dev/null
+++ b/src/cmd/compile/internal/syntax/testing.go
@@ -0,0 +1,72 @@
+// Copyright 2020 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.
+
+// This file implements testing support.
+
+package syntax
+
+import (
+	"io"
+	"regexp"
+	"strings"
+)
+
+// CommentsDo parses the given source and calls the provided handler for each
+// comment or error. If the text provided to handler starts with a '/' it is
+// the comment text; otherwise it is the error message.
+func CommentsDo(src io.Reader, handler func(line, col uint, text string)) {
+	var s scanner
+	s.init(src, handler, comments)
+	for s.tok != _EOF {
+		s.next()
+	}
+}
+
+// ERROR comments must start with text `ERROR "msg"` or `ERROR msg`.
+// Space around "msg" or msg is ignored.
+var errRx = regexp.MustCompile(`^ *ERROR *"?([^"]*)"?`)
+
+// ErrorMap collects all comments with comment text of the form
+// `ERROR "msg"` or `ERROR msg` from the given src and returns them
+// as []Error lists in a map indexed by line number. The position
+// for each Error is the position of the token immediately preceding
+// the comment, the Error message is the message msg extracted from
+// the comment, with all errors that are on the same line collected
+// in a slice. If there is no preceding token (the `ERROR` comment
+// appears in the beginning of the file), then the recorded position
+// is unknown (line, col = 0, 0). If there are no ERROR comments, the
+// result is nil.
+func ErrorMap(src io.Reader) (errmap map[uint][]Error) {
+	// position of previous token
+	var base *PosBase
+	var prev struct{ line, col uint }
+
+	var s scanner
+	s.init(src, func(_, _ uint, text string) {
+		if text[0] != '/' {
+			return // error, ignore
+		}
+		if text[1] == '*' {
+			text = text[:len(text)-2] // strip trailing */
+		}
+		if s := errRx.FindStringSubmatch(text[2:]); len(s) == 2 {
+			pos := MakePos(base, prev.line, prev.col)
+			err := Error{pos, strings.TrimSpace(s[1])}
+			if errmap == nil {
+				errmap = make(map[uint][]Error)
+			}
+			errmap[prev.line] = append(errmap[prev.line], err)
+		}
+	}, comments)
+
+	for s.tok != _EOF {
+		s.next()
+		if s.tok == _Semi && s.lit != "semicolon" {
+			continue // ignore automatically inserted semicolons
+		}
+		prev.line, prev.col = s.line, s.col
+	}
+
+	return
+}
diff --git a/src/cmd/compile/internal/syntax/testing_test.go b/src/cmd/compile/internal/syntax/testing_test.go
new file mode 100644
index 0000000000..d34e5eafaf
--- /dev/null
+++ b/src/cmd/compile/internal/syntax/testing_test.go
@@ -0,0 +1,45 @@
+// Copyright 2020 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 syntax
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestErrorMap(t *testing.T) {
+	const src = `/* ERROR 0:0 */ /* ERROR "0:0" */ // ERROR 0:0
+// ERROR "0:0"
+x /* ERROR 3:1 */                // ignore automatically inserted semicolon here
+/* ERROR 3:1 */                  // position of x on previous line
+   x /* ERROR 5:4 */ ;           // do not ignore this semicolon
+/* ERROR 5:22 */                 // position of ; on previous line
+	package /* ERROR 7:2 */  // indented with tab
+        import  /* ERROR 8:9 */  // indented with blanks
+`
+	m := ErrorMap(strings.NewReader(src))
+	got := 0 // number of errors found
+	for line, errlist := range m {
+		for _, err := range errlist {
+			if err.Pos.Line() != line {
+				t.Errorf("%v: got map line %d; want %d", err, err.Pos.Line(), line)
+				continue
+			}
+			// err.Pos.Line() == line
+			msg := fmt.Sprintf("%d:%d", line, err.Pos.Col())
+			if err.Msg != msg {
+				t.Errorf("%v: got msg %q; want %q", err, err.Msg, msg)
+				continue
+			}
+		}
+		got += len(errlist)
+	}
+
+	want := strings.Count(src, "ERROR")
+	if got != want {
+		t.Errorf("ErrorMap got %d errors; want %d", got, want)
+	}
+}
-- 
GitLab


From ca36ba83ab86b9eb1ddc076f0ebfda648ce31d6b Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 19 Oct 2020 15:28:22 -0700
Subject: [PATCH 0009/2400] [dev.typeparams] cmd/compile/internal/importer,
 types2: initial check-in of types2 and importer

This is a copy of the importer and types2 (unreviewed) prototype version
excluding the testdata directory containing tests (see below). Each file
is marked with the comment

// UNREVIEWED

on the first line. The plan is to check in this code wholesale (it runs and
passes all tests) and then review the code file-by-file via subsequent CLs
and remove the "// UNREVIEWED" comments as we review the files.

Since most tests are unchanged from the original go/types, the next CL will
commit those tests as they don't need to be reviewed again. (Eventually we
may want to factor them out and share them from a single place, e.g. the
test directory.)

The existing file fmtmap_test.go was updated.

Change-Id: I9bd0ad1a7e7188b501423483a44d18e623c0fe71
Reviewed-on: https://go-review.googlesource.com/c/go/+/263624
Trust: Robert Griesemer <gri@golang.org>
Trust: Keith Randall <khr@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/fmtmap_test.go                |   51 +-
 .../compile/internal/importer/exportdata.go   |   92 +
 .../compile/internal/importer/gcimporter.go   |  175 ++
 .../internal/importer/gcimporter_test.go      |  612 ++++++
 src/cmd/compile/internal/importer/iimport.go  |  616 ++++++
 src/cmd/compile/internal/importer/support.go  |  144 ++
 .../compile/internal/importer/testdata/a.go   |   15 +
 .../compile/internal/importer/testdata/b.go   |   12 +
 .../internal/importer/testdata/exports.go     |   89 +
 .../internal/importer/testdata/issue15920.go  |   12 +
 .../internal/importer/testdata/issue20046.go  |   10 +
 .../internal/importer/testdata/issue25301.go  |   18 +
 .../internal/importer/testdata/issue25596.go  |   14 +
 .../compile/internal/importer/testdata/p.go   |   14 +
 .../importer/testdata/versions/test.go        |   29 +
 src/cmd/compile/internal/types2/api.go        |  426 ++++
 src/cmd/compile/internal/types2/api_test.go   | 1741 +++++++++++++++
 .../compile/internal/types2/assignments.go    |  359 ++++
 src/cmd/compile/internal/types2/builtins.go   |  777 +++++++
 .../compile/internal/types2/builtins_test.go  |  219 ++
 src/cmd/compile/internal/types2/call.go       |  808 +++++++
 src/cmd/compile/internal/types2/check.go      |  449 ++++
 src/cmd/compile/internal/types2/check_test.go |  269 +++
 .../compile/internal/types2/conversions.go    |  164 ++
 src/cmd/compile/internal/types2/decl.go       |  981 +++++++++
 src/cmd/compile/internal/types2/errors.go     |  159 ++
 .../compile/internal/types2/errors_test.go    |   26 +
 .../compile/internal/types2/example_test.go   |  324 +++
 .../internal/types2/examples/functions.go2    |  216 ++
 .../internal/types2/examples/methods.go2      |   97 +
 .../internal/types2/examples/types.go2        |  261 +++
 src/cmd/compile/internal/types2/expr.go       | 1906 +++++++++++++++++
 src/cmd/compile/internal/types2/exprstring.go |  287 +++
 .../internal/types2/exprstring_test.go        |   97 +
 .../internal/types2/fixedbugs/issue39634.go2  |   92 +
 .../internal/types2/fixedbugs/issue39664.go2  |   16 +
 .../internal/types2/fixedbugs/issue39680.go2  |   28 +
 .../internal/types2/fixedbugs/issue39693.go2  |   15 +
 .../internal/types2/fixedbugs/issue39699.go2  |   30 +
 .../internal/types2/fixedbugs/issue39711.go2  |   12 +
 .../internal/types2/fixedbugs/issue39723.go2  |   10 +
 .../internal/types2/fixedbugs/issue39725.go2  |   17 +
 .../internal/types2/fixedbugs/issue39754.go2  |   21 +
 .../internal/types2/fixedbugs/issue39755.go2  |   24 +
 .../internal/types2/fixedbugs/issue39768.go2  |   21 +
 .../internal/types2/fixedbugs/issue39938.go2  |   51 +
 .../internal/types2/fixedbugs/issue39948.go2  |   10 +
 .../internal/types2/fixedbugs/issue39976.go2  |   17 +
 .../internal/types2/fixedbugs/issue39982.go2  |   37 +
 .../internal/types2/fixedbugs/issue40038.go2  |   16 +
 .../internal/types2/fixedbugs/issue40056.go2  |   16 +
 .../internal/types2/fixedbugs/issue40057.go2  |   18 +
 .../internal/types2/fixedbugs/issue40301.go2  |   13 +
 .../internal/types2/fixedbugs/issue40684.go2  |   16 +
 .../internal/types2/fixedbugs/issue41124.go2  |   92 +
 src/cmd/compile/internal/types2/gccgosizes.go |   41 +
 .../compile/internal/types2/hilbert_test.go   |  220 ++
 .../compile/internal/types2/importer_test.go  |   36 +
 src/cmd/compile/internal/types2/infer.go      |  359 ++++
 src/cmd/compile/internal/types2/initorder.go  |  298 +++
 .../compile/internal/types2/issues_test.go    |  533 +++++
 src/cmd/compile/internal/types2/labels.go     |  260 +++
 src/cmd/compile/internal/types2/lookup.go     |  493 +++++
 src/cmd/compile/internal/types2/methodset.go  |  261 +++
 src/cmd/compile/internal/types2/object.go     |  492 +++++
 .../compile/internal/types2/object_test.go    |   89 +
 src/cmd/compile/internal/types2/objset.go     |   32 +
 src/cmd/compile/internal/types2/operand.go    |  315 +++
 src/cmd/compile/internal/types2/package.go    |   65 +
 src/cmd/compile/internal/types2/pos.go        |  364 ++++
 src/cmd/compile/internal/types2/predicates.go |  413 ++++
 src/cmd/compile/internal/types2/resolver.go   |  714 ++++++
 .../compile/internal/types2/resolver_test.go  |  223 ++
 src/cmd/compile/internal/types2/return.go     |  180 ++
 src/cmd/compile/internal/types2/sanitize.go   |  149 ++
 src/cmd/compile/internal/types2/scope.go      |  217 ++
 src/cmd/compile/internal/types2/selection.go  |  144 ++
 src/cmd/compile/internal/types2/self_test.go  |   97 +
 src/cmd/compile/internal/types2/sizes.go      |  266 +++
 src/cmd/compile/internal/types2/sizes_test.go |  108 +
 .../compile/internal/types2/stdlib_test.go    |  320 +++
 src/cmd/compile/internal/types2/stmt.go       |  919 ++++++++
 src/cmd/compile/internal/types2/subst.go      |  554 +++++
 src/cmd/compile/internal/types2/type.go       | 1061 +++++++++
 src/cmd/compile/internal/types2/typestring.go |  480 +++++
 .../internal/types2/typestring_test.go        |  221 ++
 src/cmd/compile/internal/types2/typexpr.go    | 1280 +++++++++++
 src/cmd/compile/internal/types2/unify.go      |  454 ++++
 src/cmd/compile/internal/types2/universe.go   |  282 +++
 src/cmd/compile/internal/types2/walk.go       |  322 +++
 90 files changed, 24300 insertions(+), 3 deletions(-)
 create mode 100644 src/cmd/compile/internal/importer/exportdata.go
 create mode 100644 src/cmd/compile/internal/importer/gcimporter.go
 create mode 100644 src/cmd/compile/internal/importer/gcimporter_test.go
 create mode 100644 src/cmd/compile/internal/importer/iimport.go
 create mode 100644 src/cmd/compile/internal/importer/support.go
 create mode 100644 src/cmd/compile/internal/importer/testdata/a.go
 create mode 100644 src/cmd/compile/internal/importer/testdata/b.go
 create mode 100644 src/cmd/compile/internal/importer/testdata/exports.go
 create mode 100644 src/cmd/compile/internal/importer/testdata/issue15920.go
 create mode 100644 src/cmd/compile/internal/importer/testdata/issue20046.go
 create mode 100644 src/cmd/compile/internal/importer/testdata/issue25301.go
 create mode 100644 src/cmd/compile/internal/importer/testdata/issue25596.go
 create mode 100644 src/cmd/compile/internal/importer/testdata/p.go
 create mode 100644 src/cmd/compile/internal/importer/testdata/versions/test.go
 create mode 100644 src/cmd/compile/internal/types2/api.go
 create mode 100644 src/cmd/compile/internal/types2/api_test.go
 create mode 100644 src/cmd/compile/internal/types2/assignments.go
 create mode 100644 src/cmd/compile/internal/types2/builtins.go
 create mode 100644 src/cmd/compile/internal/types2/builtins_test.go
 create mode 100644 src/cmd/compile/internal/types2/call.go
 create mode 100644 src/cmd/compile/internal/types2/check.go
 create mode 100644 src/cmd/compile/internal/types2/check_test.go
 create mode 100644 src/cmd/compile/internal/types2/conversions.go
 create mode 100644 src/cmd/compile/internal/types2/decl.go
 create mode 100644 src/cmd/compile/internal/types2/errors.go
 create mode 100644 src/cmd/compile/internal/types2/errors_test.go
 create mode 100644 src/cmd/compile/internal/types2/example_test.go
 create mode 100644 src/cmd/compile/internal/types2/examples/functions.go2
 create mode 100644 src/cmd/compile/internal/types2/examples/methods.go2
 create mode 100644 src/cmd/compile/internal/types2/examples/types.go2
 create mode 100644 src/cmd/compile/internal/types2/expr.go
 create mode 100644 src/cmd/compile/internal/types2/exprstring.go
 create mode 100644 src/cmd/compile/internal/types2/exprstring_test.go
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue39634.go2
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue39664.go2
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue39680.go2
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue39693.go2
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue39699.go2
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue39711.go2
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue39723.go2
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue39725.go2
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue39754.go2
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue39755.go2
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue39768.go2
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue39938.go2
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue39948.go2
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue39976.go2
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue39982.go2
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue40038.go2
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue40056.go2
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue40057.go2
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue40301.go2
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue40684.go2
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue41124.go2
 create mode 100644 src/cmd/compile/internal/types2/gccgosizes.go
 create mode 100644 src/cmd/compile/internal/types2/hilbert_test.go
 create mode 100644 src/cmd/compile/internal/types2/importer_test.go
 create mode 100644 src/cmd/compile/internal/types2/infer.go
 create mode 100644 src/cmd/compile/internal/types2/initorder.go
 create mode 100644 src/cmd/compile/internal/types2/issues_test.go
 create mode 100644 src/cmd/compile/internal/types2/labels.go
 create mode 100644 src/cmd/compile/internal/types2/lookup.go
 create mode 100644 src/cmd/compile/internal/types2/methodset.go
 create mode 100644 src/cmd/compile/internal/types2/object.go
 create mode 100644 src/cmd/compile/internal/types2/object_test.go
 create mode 100644 src/cmd/compile/internal/types2/objset.go
 create mode 100644 src/cmd/compile/internal/types2/operand.go
 create mode 100644 src/cmd/compile/internal/types2/package.go
 create mode 100644 src/cmd/compile/internal/types2/pos.go
 create mode 100644 src/cmd/compile/internal/types2/predicates.go
 create mode 100644 src/cmd/compile/internal/types2/resolver.go
 create mode 100644 src/cmd/compile/internal/types2/resolver_test.go
 create mode 100644 src/cmd/compile/internal/types2/return.go
 create mode 100644 src/cmd/compile/internal/types2/sanitize.go
 create mode 100644 src/cmd/compile/internal/types2/scope.go
 create mode 100644 src/cmd/compile/internal/types2/selection.go
 create mode 100644 src/cmd/compile/internal/types2/self_test.go
 create mode 100644 src/cmd/compile/internal/types2/sizes.go
 create mode 100644 src/cmd/compile/internal/types2/sizes_test.go
 create mode 100644 src/cmd/compile/internal/types2/stdlib_test.go
 create mode 100644 src/cmd/compile/internal/types2/stmt.go
 create mode 100644 src/cmd/compile/internal/types2/subst.go
 create mode 100644 src/cmd/compile/internal/types2/type.go
 create mode 100644 src/cmd/compile/internal/types2/typestring.go
 create mode 100644 src/cmd/compile/internal/types2/typestring_test.go
 create mode 100644 src/cmd/compile/internal/types2/typexpr.go
 create mode 100644 src/cmd/compile/internal/types2/unify.go
 create mode 100644 src/cmd/compile/internal/types2/universe.go
 create mode 100644 src/cmd/compile/internal/types2/walk.go

diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
index a3d09576a7..bcc82dda2f 100644
--- a/src/cmd/compile/fmtmap_test.go
+++ b/src/cmd/compile/fmtmap_test.go
@@ -42,6 +42,10 @@ var knownFormats = map[string]string{
 	"*cmd/compile/internal/ssa.Value %s":              "",
 	"*cmd/compile/internal/ssa.Value %v":              "",
 	"*cmd/compile/internal/ssa.sparseTreeMapEntry %v": "",
+	"*cmd/compile/internal/syntax.CallExpr %s":        "",
+	"*cmd/compile/internal/syntax.CallExpr %v":        "",
+	"*cmd/compile/internal/syntax.FuncLit %s":         "",
+	"*cmd/compile/internal/syntax.IndexExpr %s":       "",
 	"*cmd/compile/internal/types.Field %p":            "",
 	"*cmd/compile/internal/types.Field %v":            "",
 	"*cmd/compile/internal/types.Sym %0S":             "",
@@ -58,6 +62,25 @@ var knownFormats = map[string]string{
 	"*cmd/compile/internal/types.Type %p":             "",
 	"*cmd/compile/internal/types.Type %s":             "",
 	"*cmd/compile/internal/types.Type %v":             "",
+	"*cmd/compile/internal/types2.Basic %s":           "",
+	"*cmd/compile/internal/types2.Chan %s":            "",
+	"*cmd/compile/internal/types2.Func %s":            "",
+	"*cmd/compile/internal/types2.Initializer %s":     "",
+	"*cmd/compile/internal/types2.Interface %s":       "",
+	"*cmd/compile/internal/types2.MethodSet %s":       "",
+	"*cmd/compile/internal/types2.Named %s":           "",
+	"*cmd/compile/internal/types2.Named %v":           "",
+	"*cmd/compile/internal/types2.Package %s":         "",
+	"*cmd/compile/internal/types2.Package %v":         "",
+	"*cmd/compile/internal/types2.Scope %p":           "",
+	"*cmd/compile/internal/types2.Selection %s":       "",
+	"*cmd/compile/internal/types2.Signature %s":       "",
+	"*cmd/compile/internal/types2.TypeName %s":        "",
+	"*cmd/compile/internal/types2.TypeName %v":        "",
+	"*cmd/compile/internal/types2.TypeParam %s":       "",
+	"*cmd/compile/internal/types2.Var %s":             "",
+	"*cmd/compile/internal/types2.operand %s":         "",
+	"*cmd/compile/internal/types2.substMap %s":        "",
 	"*cmd/internal/obj.Addr %v":                       "",
 	"*cmd/internal/obj.LSym %v":                       "",
 	"*math/big.Float %f":                              "",
@@ -67,6 +90,8 @@ var knownFormats = map[string]string{
 	"[16]byte %x":                                     "",
 	"[]*cmd/compile/internal/ssa.Block %v":            "",
 	"[]*cmd/compile/internal/ssa.Value %v":            "",
+	"[]*cmd/compile/internal/types2.Func %v":          "",
+	"[]*cmd/compile/internal/types2.TypeName %s":      "",
 	"[][]string %q":                                   "",
 	"[]byte %s":                                       "",
 	"[]byte %x":                                       "",
@@ -75,6 +100,8 @@ var knownFormats = map[string]string{
 	"[]cmd/compile/internal/ssa.posetNode %v":         "",
 	"[]cmd/compile/internal/ssa.posetUndo %v":         "",
 	"[]cmd/compile/internal/syntax.token %s":          "",
+	"[]cmd/compile/internal/types2.Type %s":           "",
+	"[]int %v":                                        "",
 	"[]string %v":                                     "",
 	"[]uint32 %v":                                     "",
 	"bool %v":                                         "",
@@ -100,6 +127,7 @@ var knownFormats = map[string]string{
 	"cmd/compile/internal/gc.fmtMode %d":              "",
 	"cmd/compile/internal/gc.initKind %d":             "",
 	"cmd/compile/internal/gc.itag %v":                 "",
+	"cmd/compile/internal/importer.itag %v":           "",
 	"cmd/compile/internal/ssa.BranchPrediction %d":    "",
 	"cmd/compile/internal/ssa.Edge %v":                "",
 	"cmd/compile/internal/ssa.GCNode %v":              "",
@@ -122,9 +150,13 @@ var knownFormats = map[string]string{
 	"cmd/compile/internal/ssa.regMask %d":             "",
 	"cmd/compile/internal/ssa.register %d":            "",
 	"cmd/compile/internal/ssa.relation %s":            "",
+	"cmd/compile/internal/syntax.ChanDir %d":          "",
+	"cmd/compile/internal/syntax.Decl %T":             "",
 	"cmd/compile/internal/syntax.Error %q":            "",
 	"cmd/compile/internal/syntax.Error %v":            "",
 	"cmd/compile/internal/syntax.Expr %#v":            "",
+	"cmd/compile/internal/syntax.Expr %T":             "",
+	"cmd/compile/internal/syntax.Expr %s":             "",
 	"cmd/compile/internal/syntax.LitKind %d":          "",
 	"cmd/compile/internal/syntax.Node %T":             "",
 	"cmd/compile/internal/syntax.Operator %s":         "",
@@ -136,12 +168,22 @@ var knownFormats = map[string]string{
 	"cmd/compile/internal/types.EType %d":             "",
 	"cmd/compile/internal/types.EType %s":             "",
 	"cmd/compile/internal/types.EType %v":             "",
+	"cmd/compile/internal/types2.Object %T":           "",
+	"cmd/compile/internal/types2.Object %p":           "",
+	"cmd/compile/internal/types2.Object %s":           "",
+	"cmd/compile/internal/types2.Object %v":           "",
+	"cmd/compile/internal/types2.Type %T":             "",
+	"cmd/compile/internal/types2.Type %s":             "",
+	"cmd/compile/internal/types2.Type %v":             "",
+	"cmd/compile/internal/types2.color %s":            "",
 	"cmd/internal/obj.ABI %v":                         "",
+	"error %s":                                        "",
 	"error %v":                                        "",
 	"float64 %.2f":                                    "",
 	"float64 %.3f":                                    "",
 	"float64 %.6g":                                    "",
 	"float64 %g":                                      "",
+	"go/constant.Value %s":                            "",
 	"int %#x":                                         "",
 	"int %-12d":                                       "",
 	"int %-6d":                                        "",
@@ -174,9 +216,10 @@ var knownFormats = map[string]string{
 	"interface{} %q":                                  "",
 	"interface{} %s":                                  "",
 	"interface{} %v":                                  "",
-	"map[*cmd/compile/internal/gc.Node]*cmd/compile/internal/ssa.Value %v": "",
-	"map[*cmd/compile/internal/gc.Node][]*cmd/compile/internal/gc.Node %v": "",
-	"map[cmd/compile/internal/ssa.ID]uint32 %v":                            "",
+	"map[*cmd/compile/internal/gc.Node]*cmd/compile/internal/ssa.Value %v":           "",
+	"map[*cmd/compile/internal/gc.Node][]*cmd/compile/internal/gc.Node %v":           "",
+	"map[*cmd/compile/internal/types2.TypeParam]cmd/compile/internal/types2.Type %s": "",
+	"map[cmd/compile/internal/ssa.ID]uint32 %v":                                      "",
 	"map[int64]uint32 %v":  "",
 	"math/big.Accuracy %s": "",
 	"reflect.Type %s":      "",
@@ -186,6 +229,7 @@ var knownFormats = map[string]string{
 	"string %-*s":          "",
 	"string %-16s":         "",
 	"string %-6s":          "",
+	"string %T":            "",
 	"string %q":            "",
 	"string %s":            "",
 	"string %v":            "",
@@ -205,6 +249,7 @@ var knownFormats = map[string]string{
 	"uint64 %08x":          "",
 	"uint64 %b":            "",
 	"uint64 %d":            "",
+	"uint64 %v":            "",
 	"uint64 %x":            "",
 	"uint8 %#x":            "",
 	"uint8 %d":             "",
diff --git a/src/cmd/compile/internal/importer/exportdata.go b/src/cmd/compile/internal/importer/exportdata.go
new file mode 100644
index 0000000000..3925a64314
--- /dev/null
+++ b/src/cmd/compile/internal/importer/exportdata.go
@@ -0,0 +1,92 @@
+// UNREVIEWED
+// Copyright 2011 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.
+
+// This file implements FindExportData.
+
+package importer
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
+)
+
+func readGopackHeader(r *bufio.Reader) (name string, size int, err error) {
+	// See $GOROOT/include/ar.h.
+	hdr := make([]byte, 16+12+6+6+8+10+2)
+	_, err = io.ReadFull(r, hdr)
+	if err != nil {
+		return
+	}
+	// leave for debugging
+	if false {
+		fmt.Printf("header: %s", hdr)
+	}
+	s := strings.TrimSpace(string(hdr[16+12+6+6+8:][:10]))
+	size, err = strconv.Atoi(s)
+	if err != nil || hdr[len(hdr)-2] != '`' || hdr[len(hdr)-1] != '\n' {
+		err = fmt.Errorf("invalid archive header")
+		return
+	}
+	name = strings.TrimSpace(string(hdr[:16]))
+	return
+}
+
+// FindExportData positions the reader r at the beginning of the
+// export data section of an underlying GC-created object/archive
+// file by reading from it. The reader must be positioned at the
+// start of the file before calling this function. The hdr result
+// is the string before the export data, either "$$" or "$$B".
+//
+func FindExportData(r *bufio.Reader) (hdr string, err error) {
+	// Read first line to make sure this is an object file.
+	line, err := r.ReadSlice('\n')
+	if err != nil {
+		err = fmt.Errorf("can't find export data (%v)", err)
+		return
+	}
+
+	if string(line) == "!<arch>\n" {
+		// Archive file. Scan to __.PKGDEF.
+		var name string
+		if name, _, err = readGopackHeader(r); err != nil {
+			return
+		}
+
+		// First entry should be __.PKGDEF.
+		if name != "__.PKGDEF" {
+			err = fmt.Errorf("go archive is missing __.PKGDEF")
+			return
+		}
+
+		// Read first line of __.PKGDEF data, so that line
+		// is once again the first line of the input.
+		if line, err = r.ReadSlice('\n'); err != nil {
+			err = fmt.Errorf("can't find export data (%v)", err)
+			return
+		}
+	}
+
+	// Now at __.PKGDEF in archive or still at beginning of file.
+	// Either way, line should begin with "go object ".
+	if !strings.HasPrefix(string(line), "go object ") {
+		err = fmt.Errorf("not a Go object file")
+		return
+	}
+
+	// Skip over object header to export data.
+	// Begins after first line starting with $$.
+	for line[0] != '$' {
+		if line, err = r.ReadSlice('\n'); err != nil {
+			err = fmt.Errorf("can't find export data (%v)", err)
+			return
+		}
+	}
+	hdr = string(line)
+
+	return
+}
diff --git a/src/cmd/compile/internal/importer/gcimporter.go b/src/cmd/compile/internal/importer/gcimporter.go
new file mode 100644
index 0000000000..feb18cf2c9
--- /dev/null
+++ b/src/cmd/compile/internal/importer/gcimporter.go
@@ -0,0 +1,175 @@
+// UNREVIEWED
+// Copyright 2011 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 importer implements Import for gc-generated object files.
+package importer
+
+import (
+	"bufio"
+	"cmd/compile/internal/types2"
+	"fmt"
+	"go/build"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// debugging/development support
+const debug = false
+
+var pkgExts = [...]string{".a", ".o"}
+
+// FindPkg returns the filename and unique package id for an import
+// path based on package information provided by build.Import (using
+// the build.Default build.Context). A relative srcDir is interpreted
+// relative to the current working directory.
+// If no file was found, an empty filename is returned.
+//
+func FindPkg(path, srcDir string) (filename, id string) {
+	if path == "" {
+		return
+	}
+
+	var noext string
+	switch {
+	default:
+		// "x" -> "$GOPATH/pkg/$GOOS_$GOARCH/x.ext", "x"
+		// Don't require the source files to be present.
+		if abs, err := filepath.Abs(srcDir); err == nil { // see issue 14282
+			srcDir = abs
+		}
+		bp, _ := build.Import(path, srcDir, build.FindOnly|build.AllowBinary)
+		if bp.PkgObj == "" {
+			id = path // make sure we have an id to print in error message
+			return
+		}
+		noext = strings.TrimSuffix(bp.PkgObj, ".a")
+		id = bp.ImportPath
+
+	case build.IsLocalImport(path):
+		// "./x" -> "/this/directory/x.ext", "/this/directory/x"
+		noext = filepath.Join(srcDir, path)
+		id = noext
+
+	case filepath.IsAbs(path):
+		// for completeness only - go/build.Import
+		// does not support absolute imports
+		// "/x" -> "/x.ext", "/x"
+		noext = path
+		id = path
+	}
+
+	if false { // for debugging
+		if path != id {
+			fmt.Printf("%s -> %s\n", path, id)
+		}
+	}
+
+	// try extensions
+	for _, ext := range pkgExts {
+		filename = noext + ext
+		if f, err := os.Stat(filename); err == nil && !f.IsDir() {
+			return
+		}
+	}
+
+	filename = "" // not found
+	return
+}
+
+// Import imports a gc-generated package given its import path and srcDir, adds
+// the corresponding package object to the packages map, and returns the object.
+// The packages map must contain all packages already imported.
+//
+func Import(packages map[string]*types2.Package, path, srcDir string, lookup func(path string) (io.ReadCloser, error)) (pkg *types2.Package, err error) {
+	var rc io.ReadCloser
+	var id string
+	if lookup != nil {
+		// With custom lookup specified, assume that caller has
+		// converted path to a canonical import path for use in the map.
+		if path == "unsafe" {
+			return types2.Unsafe, nil
+		}
+		id = path
+
+		// No need to re-import if the package was imported completely before.
+		if pkg = packages[id]; pkg != nil && pkg.Complete() {
+			return
+		}
+		f, err := lookup(path)
+		if err != nil {
+			return nil, err
+		}
+		rc = f
+	} else {
+		var filename string
+		filename, id = FindPkg(path, srcDir)
+		if filename == "" {
+			if path == "unsafe" {
+				return types2.Unsafe, nil
+			}
+			return nil, fmt.Errorf("can't find import: %q", id)
+		}
+
+		// no need to re-import if the package was imported completely before
+		if pkg = packages[id]; pkg != nil && pkg.Complete() {
+			return
+		}
+
+		// open file
+		f, err := os.Open(filename)
+		if err != nil {
+			return nil, err
+		}
+		defer func() {
+			if err != nil {
+				// add file name to error
+				err = fmt.Errorf("%s: %v", filename, err)
+			}
+		}()
+		rc = f
+	}
+	defer rc.Close()
+
+	var hdr string
+	buf := bufio.NewReader(rc)
+	if hdr, err = FindExportData(buf); err != nil {
+		return
+	}
+
+	switch hdr {
+	case "$$\n":
+		err = fmt.Errorf("import %q: old textual export format no longer supported (recompile library)", path)
+
+	case "$$B\n":
+		var data []byte
+		data, err = ioutil.ReadAll(buf)
+		if err != nil {
+			break
+		}
+
+		// The indexed export format starts with an 'i'; the older
+		// binary export format starts with a 'c', 'd', or 'v'
+		// (from "version"). Select appropriate importer.
+		if len(data) > 0 && data[0] == 'i' {
+			_, pkg, err = iImportData(packages, data[1:], id)
+		} else {
+			err = fmt.Errorf("import %q: old binary export format no longer supported (recompile library)", path)
+		}
+
+	default:
+		err = fmt.Errorf("import %q: unknown export data header: %q", path, hdr)
+	}
+
+	return
+}
+
+type byPath []*types2.Package
+
+func (a byPath) Len() int           { return len(a) }
+func (a byPath) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (a byPath) Less(i, j int) bool { return a[i].Path() < a[j].Path() }
diff --git a/src/cmd/compile/internal/importer/gcimporter_test.go b/src/cmd/compile/internal/importer/gcimporter_test.go
new file mode 100644
index 0000000000..a275524484
--- /dev/null
+++ b/src/cmd/compile/internal/importer/gcimporter_test.go
@@ -0,0 +1,612 @@
+// UNREVIEWED
+// Copyright 2011 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 importer
+
+import (
+	"bytes"
+	"cmd/compile/internal/types2"
+	"fmt"
+	"internal/testenv"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+// skipSpecialPlatforms causes the test to be skipped for platforms where
+// builders (build.golang.org) don't have access to compiled packages for
+// import.
+func skipSpecialPlatforms(t *testing.T) {
+	switch platform := runtime.GOOS + "-" + runtime.GOARCH; platform {
+	case "darwin-arm64":
+		t.Skipf("no compiled packages available for import on %s", platform)
+	}
+}
+
+// compile runs the compiler on filename, with dirname as the working directory,
+// and writes the output file to outdirname.
+func compile(t *testing.T, dirname, filename, outdirname string) string {
+	// filename must end with ".go"
+	if !strings.HasSuffix(filename, ".go") {
+		t.Fatalf("filename doesn't end in .go: %s", filename)
+	}
+	basename := filepath.Base(filename)
+	outname := filepath.Join(outdirname, basename[:len(basename)-2]+"o")
+	cmd := exec.Command(testenv.GoToolPath(t), "tool", "compile", "-o", outname, filename)
+	cmd.Dir = dirname
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Logf("%s", out)
+		t.Fatalf("go tool compile %s failed: %s", filename, err)
+	}
+	return outname
+}
+
+func testPath(t *testing.T, path, srcDir string) *types2.Package {
+	t0 := time.Now()
+	pkg, err := Import(make(map[string]*types2.Package), path, srcDir, nil)
+	if err != nil {
+		t.Errorf("testPath(%s): %s", path, err)
+		return nil
+	}
+	t.Logf("testPath(%s): %v", path, time.Since(t0))
+	return pkg
+}
+
+const maxTime = 30 * time.Second
+
+func testDir(t *testing.T, dir string, endTime time.Time) (nimports int) {
+	dirname := filepath.Join(runtime.GOROOT(), "pkg", runtime.GOOS+"_"+runtime.GOARCH, dir)
+	list, err := ioutil.ReadDir(dirname)
+	if err != nil {
+		t.Fatalf("testDir(%s): %s", dirname, err)
+	}
+	for _, f := range list {
+		if time.Now().After(endTime) {
+			t.Log("testing time used up")
+			return
+		}
+		switch {
+		case !f.IsDir():
+			// try extensions
+			for _, ext := range pkgExts {
+				if strings.HasSuffix(f.Name(), ext) {
+					name := f.Name()[0 : len(f.Name())-len(ext)] // remove extension
+					if testPath(t, filepath.Join(dir, name), dir) != nil {
+						nimports++
+					}
+				}
+			}
+		case f.IsDir():
+			nimports += testDir(t, filepath.Join(dir, f.Name()), endTime)
+		}
+	}
+	return
+}
+
+func mktmpdir(t *testing.T) string {
+	tmpdir, err := ioutil.TempDir("", "gcimporter_test")
+	if err != nil {
+		t.Fatal("mktmpdir:", err)
+	}
+	if err := os.Mkdir(filepath.Join(tmpdir, "testdata"), 0700); err != nil {
+		os.RemoveAll(tmpdir)
+		t.Fatal("mktmpdir:", err)
+	}
+	return tmpdir
+}
+
+func TestImportTestdata(t *testing.T) {
+	// This package only handles gc export data.
+	if runtime.Compiler != "gc" {
+		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+	}
+
+	tmpdir := mktmpdir(t)
+	defer os.RemoveAll(tmpdir)
+
+	compile(t, "testdata", "exports.go", filepath.Join(tmpdir, "testdata"))
+
+	if pkg := testPath(t, "./testdata/exports", tmpdir); pkg != nil {
+		// The package's Imports list must include all packages
+		// explicitly imported by exports.go, plus all packages
+		// referenced indirectly via exported objects in exports.go.
+		// With the textual export format, the list may also include
+		// additional packages that are not strictly required for
+		// import processing alone (they are exported to err "on
+		// the safe side").
+		// TODO(gri) update the want list to be precise, now that
+		// the textual export data is gone.
+		got := fmt.Sprint(pkg.Imports())
+		for _, want := range []string{"go/ast", "go/token"} {
+			if !strings.Contains(got, want) {
+				t.Errorf(`Package("exports").Imports() = %s, does not contain %s`, got, want)
+			}
+		}
+	}
+}
+
+func TestVersionHandling(t *testing.T) {
+	skipSpecialPlatforms(t)
+
+	// This package only handles gc export data.
+	if runtime.Compiler != "gc" {
+		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+	}
+
+	const dir = "./testdata/versions"
+	list, err := ioutil.ReadDir(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	tmpdir := mktmpdir(t)
+	defer os.RemoveAll(tmpdir)
+	corruptdir := filepath.Join(tmpdir, "testdata", "versions")
+	if err := os.Mkdir(corruptdir, 0700); err != nil {
+		t.Fatal(err)
+	}
+
+	for _, f := range list {
+		name := f.Name()
+		if !strings.HasSuffix(name, ".a") {
+			continue // not a package file
+		}
+		if strings.Contains(name, "corrupted") {
+			continue // don't process a leftover corrupted file
+		}
+		pkgpath := "./" + name[:len(name)-2]
+
+		if testing.Verbose() {
+			t.Logf("importing %s", name)
+		}
+
+		// test that export data can be imported
+		_, err := Import(make(map[string]*types2.Package), pkgpath, dir, nil)
+		if err != nil {
+			// ok to fail if it fails with a no longer supported error for select files
+			if strings.Contains(err.Error(), "no longer supported") {
+				switch name {
+				case "test_go1.7_0.a", "test_go1.7_1.a",
+					"test_go1.8_4.a", "test_go1.8_5.a",
+					"test_go1.11_6b.a", "test_go1.11_999b.a":
+					continue
+				}
+				// fall through
+			}
+			// ok to fail if it fails with a newer version error for select files
+			if strings.Contains(err.Error(), "newer version") {
+				switch name {
+				case "test_go1.11_999i.a":
+					continue
+				}
+				// fall through
+			}
+			t.Errorf("import %q failed: %v", pkgpath, err)
+			continue
+		}
+
+		// create file with corrupted export data
+		// 1) read file
+		data, err := ioutil.ReadFile(filepath.Join(dir, name))
+		if err != nil {
+			t.Fatal(err)
+		}
+		// 2) find export data
+		i := bytes.Index(data, []byte("\n$$B\n")) + 5
+		j := bytes.Index(data[i:], []byte("\n$$\n")) + i
+		if i < 0 || j < 0 || i > j {
+			t.Fatalf("export data section not found (i = %d, j = %d)", i, j)
+		}
+		// 3) corrupt the data (increment every 7th byte)
+		for k := j - 13; k >= i; k -= 7 {
+			data[k]++
+		}
+		// 4) write the file
+		pkgpath += "_corrupted"
+		filename := filepath.Join(corruptdir, pkgpath) + ".a"
+		ioutil.WriteFile(filename, data, 0666)
+
+		// test that importing the corrupted file results in an error
+		_, err = Import(make(map[string]*types2.Package), pkgpath, corruptdir, nil)
+		if err == nil {
+			t.Errorf("import corrupted %q succeeded", pkgpath)
+		} else if msg := err.Error(); !strings.Contains(msg, "version skew") {
+			t.Errorf("import %q error incorrect (%s)", pkgpath, msg)
+		}
+	}
+}
+
+func TestImportStdLib(t *testing.T) {
+	skipSpecialPlatforms(t)
+
+	// This package only handles gc export data.
+	if runtime.Compiler != "gc" {
+		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+	}
+
+	dt := maxTime
+	if testing.Short() && testenv.Builder() == "" {
+		dt = 10 * time.Millisecond
+	}
+	nimports := testDir(t, "", time.Now().Add(dt)) // installed packages
+	t.Logf("tested %d imports", nimports)
+}
+
+var importedObjectTests = []struct {
+	name string
+	want string
+}{
+	// non-interfaces
+	{"crypto.Hash", "type Hash uint"},
+	{"go/ast.ObjKind", "type ObjKind int"},
+	{"go/types.Qualifier", "type Qualifier func(*Package) string"},
+	{"go/types.Comparable", "func Comparable(T Type) bool"},
+	{"math.Pi", "const Pi untyped float"},
+	{"math.Sin", "func Sin(x float64) float64"},
+	{"go/ast.NotNilFilter", "func NotNilFilter(_ string, v reflect.Value) bool"},
+	{"go/internal/gcimporter.FindPkg", "func FindPkg(path string, srcDir string) (filename string, id string)"},
+
+	// interfaces
+	{"context.Context", "type Context interface{Deadline() (deadline time.Time, ok bool); Done() <-chan struct{}; Err() error; Value(key interface{}) interface{}}"},
+	{"crypto.Decrypter", "type Decrypter interface{Decrypt(rand io.Reader, msg []byte, opts DecrypterOpts) (plaintext []byte, err error); Public() PublicKey}"},
+	{"encoding.BinaryMarshaler", "type BinaryMarshaler interface{MarshalBinary() (data []byte, err error)}"},
+	{"io.Reader", "type Reader interface{Read(p []byte) (n int, err error)}"},
+	{"io.ReadWriter", "type ReadWriter interface{Reader; Writer}"},
+	{"go/ast.Node", "type Node interface{End() go/token.Pos; Pos() go/token.Pos}"},
+	// go/types.Type has grown much larger - excluded for now
+	// {"go/types.Type", "type Type interface{String() string; Underlying() Type}"},
+}
+
+func TestImportedTypes(t *testing.T) {
+	skipSpecialPlatforms(t)
+
+	// This package only handles gc export data.
+	if runtime.Compiler != "gc" {
+		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+	}
+
+	for _, test := range importedObjectTests {
+		s := strings.Split(test.name, ".")
+		if len(s) != 2 {
+			t.Fatal("inconsistent test data")
+		}
+		importPath := s[0]
+		objName := s[1]
+
+		pkg, err := Import(make(map[string]*types2.Package), importPath, ".", nil)
+		if err != nil {
+			t.Error(err)
+			continue
+		}
+
+		obj := pkg.Scope().Lookup(objName)
+		if obj == nil {
+			t.Errorf("%s: object not found", test.name)
+			continue
+		}
+
+		got := types2.ObjectString(obj, types2.RelativeTo(pkg))
+		if got != test.want {
+			t.Errorf("%s: got %q; want %q", test.name, got, test.want)
+		}
+
+		if named, _ := obj.Type().(*types2.Named); named != nil {
+			verifyInterfaceMethodRecvs(t, named, 0)
+		}
+	}
+}
+
+// verifyInterfaceMethodRecvs verifies that method receiver types
+// are named if the methods belong to a named interface type.
+func verifyInterfaceMethodRecvs(t *testing.T, named *types2.Named, level int) {
+	// avoid endless recursion in case of an embedding bug that lead to a cycle
+	if level > 10 {
+		t.Errorf("%s: embeds itself", named)
+		return
+	}
+
+	iface, _ := named.Underlying().(*types2.Interface)
+	if iface == nil {
+		return // not an interface
+	}
+
+	// check explicitly declared methods
+	for i := 0; i < iface.NumExplicitMethods(); i++ {
+		m := iface.ExplicitMethod(i)
+		recv := m.Type().(*types2.Signature).Recv()
+		if recv == nil {
+			t.Errorf("%s: missing receiver type", m)
+			continue
+		}
+		if recv.Type() != named {
+			t.Errorf("%s: got recv type %s; want %s", m, recv.Type(), named)
+		}
+	}
+
+	// check embedded interfaces (if they are named, too)
+	for i := 0; i < iface.NumEmbeddeds(); i++ {
+		// embedding of interfaces cannot have cycles; recursion will terminate
+		if etype, _ := iface.EmbeddedType(i).(*types2.Named); etype != nil {
+			verifyInterfaceMethodRecvs(t, etype, level+1)
+		}
+	}
+}
+
+func TestIssue5815(t *testing.T) {
+	skipSpecialPlatforms(t)
+
+	// This package only handles gc export data.
+	if runtime.Compiler != "gc" {
+		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+	}
+
+	pkg := importPkg(t, "strings", ".")
+
+	scope := pkg.Scope()
+	for _, name := range scope.Names() {
+		obj := scope.Lookup(name)
+		if obj.Pkg() == nil {
+			t.Errorf("no pkg for %s", obj)
+		}
+		if tname, _ := obj.(*types2.TypeName); tname != nil {
+			named := tname.Type().(*types2.Named)
+			for i := 0; i < named.NumMethods(); i++ {
+				m := named.Method(i)
+				if m.Pkg() == nil {
+					t.Errorf("no pkg for %s", m)
+				}
+			}
+		}
+	}
+}
+
+// Smoke test to ensure that imported methods get the correct package.
+func TestCorrectMethodPackage(t *testing.T) {
+	skipSpecialPlatforms(t)
+
+	// This package only handles gc export data.
+	if runtime.Compiler != "gc" {
+		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+	}
+
+	imports := make(map[string]*types2.Package)
+	_, err := Import(imports, "net/http", ".", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	mutex := imports["sync"].Scope().Lookup("Mutex").(*types2.TypeName).Type()
+	mset := types2.NewMethodSet(types2.NewPointer(mutex)) // methods of *sync.Mutex
+	sel := mset.Lookup(nil, "Lock")
+	lock := sel.Obj().(*types2.Func)
+	if got, want := lock.Pkg().Path(), "sync"; got != want {
+		t.Errorf("got package path %q; want %q", got, want)
+	}
+}
+
+func TestIssue13566(t *testing.T) {
+	skipSpecialPlatforms(t)
+
+	// This package only handles gc export data.
+	if runtime.Compiler != "gc" {
+		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+	}
+
+	// On windows, we have to set the -D option for the compiler to avoid having a drive
+	// letter and an illegal ':' in the import path - just skip it (see also issue #3483).
+	if runtime.GOOS == "windows" {
+		t.Skip("avoid dealing with relative paths/drive letters on windows")
+	}
+
+	tmpdir := mktmpdir(t)
+	defer os.RemoveAll(tmpdir)
+	testoutdir := filepath.Join(tmpdir, "testdata")
+
+	// b.go needs to be compiled from the output directory so that the compiler can
+	// find the compiled package a. We pass the full path to compile() so that we
+	// don't have to copy the file to that directory.
+	bpath, err := filepath.Abs(filepath.Join("testdata", "b.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	compile(t, "testdata", "a.go", testoutdir)
+	compile(t, testoutdir, bpath, testoutdir)
+
+	// import must succeed (test for issue at hand)
+	pkg := importPkg(t, "./testdata/b", tmpdir)
+
+	// make sure all indirectly imported packages have names
+	for _, imp := range pkg.Imports() {
+		if imp.Name() == "" {
+			t.Errorf("no name for %s package", imp.Path())
+		}
+	}
+}
+
+func TestIssue13898(t *testing.T) {
+	skipSpecialPlatforms(t)
+
+	// This package only handles gc export data.
+	if runtime.Compiler != "gc" {
+		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+	}
+
+	// import go/internal/gcimporter which imports go/types partially
+	imports := make(map[string]*types2.Package)
+	_, err := Import(imports, "go/internal/gcimporter", ".", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// look for go/types package
+	var goTypesPkg *types2.Package
+	for path, pkg := range imports {
+		if path == "go/types" {
+			goTypesPkg = pkg
+			break
+		}
+	}
+	if goTypesPkg == nil {
+		t.Fatal("go/types not found")
+	}
+
+	// look for go/types2.Object type
+	obj := lookupObj(t, goTypesPkg.Scope(), "Object")
+	typ, ok := obj.Type().(*types2.Named)
+	if !ok {
+		t.Fatalf("go/types2.Object type is %v; wanted named type", typ)
+	}
+
+	// lookup go/types2.Object.Pkg method
+	m, index, indirect := types2.LookupFieldOrMethod(typ, false, nil, "Pkg")
+	if m == nil {
+		t.Fatalf("go/types2.Object.Pkg not found (index = %v, indirect = %v)", index, indirect)
+	}
+
+	// the method must belong to go/types
+	if m.Pkg().Path() != "go/types" {
+		t.Fatalf("found %v; want go/types", m.Pkg())
+	}
+}
+
+func TestIssue15517(t *testing.T) {
+	skipSpecialPlatforms(t)
+
+	// This package only handles gc export data.
+	if runtime.Compiler != "gc" {
+		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+	}
+
+	// On windows, we have to set the -D option for the compiler to avoid having a drive
+	// letter and an illegal ':' in the import path - just skip it (see also issue #3483).
+	if runtime.GOOS == "windows" {
+		t.Skip("avoid dealing with relative paths/drive letters on windows")
+	}
+
+	tmpdir := mktmpdir(t)
+	defer os.RemoveAll(tmpdir)
+
+	compile(t, "testdata", "p.go", filepath.Join(tmpdir, "testdata"))
+
+	// Multiple imports of p must succeed without redeclaration errors.
+	// We use an import path that's not cleaned up so that the eventual
+	// file path for the package is different from the package path; this
+	// will expose the error if it is present.
+	//
+	// (Issue: Both the textual and the binary importer used the file path
+	// of the package to be imported as key into the shared packages map.
+	// However, the binary importer then used the package path to identify
+	// the imported package to mark it as complete; effectively marking the
+	// wrong package as complete. By using an "unclean" package path, the
+	// file and package path are different, exposing the problem if present.
+	// The same issue occurs with vendoring.)
+	imports := make(map[string]*types2.Package)
+	for i := 0; i < 3; i++ {
+		if _, err := Import(imports, "./././testdata/p", tmpdir, nil); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+func TestIssue15920(t *testing.T) {
+	skipSpecialPlatforms(t)
+
+	// This package only handles gc export data.
+	if runtime.Compiler != "gc" {
+		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+	}
+
+	// On windows, we have to set the -D option for the compiler to avoid having a drive
+	// letter and an illegal ':' in the import path - just skip it (see also issue #3483).
+	if runtime.GOOS == "windows" {
+		t.Skip("avoid dealing with relative paths/drive letters on windows")
+	}
+
+	compileAndImportPkg(t, "issue15920")
+}
+
+func TestIssue20046(t *testing.T) {
+	skipSpecialPlatforms(t)
+
+	// This package only handles gc export data.
+	if runtime.Compiler != "gc" {
+		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+	}
+
+	// On windows, we have to set the -D option for the compiler to avoid having a drive
+	// letter and an illegal ':' in the import path - just skip it (see also issue #3483).
+	if runtime.GOOS == "windows" {
+		t.Skip("avoid dealing with relative paths/drive letters on windows")
+	}
+
+	// "./issue20046".V.M must exist
+	pkg := compileAndImportPkg(t, "issue20046")
+	obj := lookupObj(t, pkg.Scope(), "V")
+	if m, index, indirect := types2.LookupFieldOrMethod(obj.Type(), false, nil, "M"); m == nil {
+		t.Fatalf("V.M not found (index = %v, indirect = %v)", index, indirect)
+	}
+}
+func TestIssue25301(t *testing.T) {
+	skipSpecialPlatforms(t)
+
+	// This package only handles gc export data.
+	if runtime.Compiler != "gc" {
+		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+	}
+
+	// On windows, we have to set the -D option for the compiler to avoid having a drive
+	// letter and an illegal ':' in the import path - just skip it (see also issue #3483).
+	if runtime.GOOS == "windows" {
+		t.Skip("avoid dealing with relative paths/drive letters on windows")
+	}
+
+	compileAndImportPkg(t, "issue25301")
+}
+
+func TestIssue25596(t *testing.T) {
+	skipSpecialPlatforms(t)
+
+	// This package only handles gc export data.
+	if runtime.Compiler != "gc" {
+		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+	}
+
+	// On windows, we have to set the -D option for the compiler to avoid having a drive
+	// letter and an illegal ':' in the import path - just skip it (see also issue #3483).
+	if runtime.GOOS == "windows" {
+		t.Skip("avoid dealing with relative paths/drive letters on windows")
+	}
+
+	compileAndImportPkg(t, "issue25596")
+}
+
+func importPkg(t *testing.T, path, srcDir string) *types2.Package {
+	pkg, err := Import(make(map[string]*types2.Package), path, srcDir, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return pkg
+}
+
+func compileAndImportPkg(t *testing.T, name string) *types2.Package {
+	tmpdir := mktmpdir(t)
+	defer os.RemoveAll(tmpdir)
+	compile(t, "testdata", name+".go", filepath.Join(tmpdir, "testdata"))
+	return importPkg(t, "./testdata/"+name, tmpdir)
+}
+
+func lookupObj(t *testing.T, scope *types2.Scope, name string) types2.Object {
+	if obj := scope.Lookup(name); obj != nil {
+		return obj
+	}
+	t.Fatalf("%s not found", name)
+	return nil
+}
diff --git a/src/cmd/compile/internal/importer/iimport.go b/src/cmd/compile/internal/importer/iimport.go
new file mode 100644
index 0000000000..b9c1ccfb66
--- /dev/null
+++ b/src/cmd/compile/internal/importer/iimport.go
@@ -0,0 +1,616 @@
+// UNREVIEWED
+// Copyright 2018 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.
+
+// Indexed package import.
+// See cmd/compile/internal/gc/iexport.go for the export data format.
+
+package importer
+
+import (
+	"bytes"
+	"cmd/compile/internal/syntax"
+	"cmd/compile/internal/types2"
+	"encoding/binary"
+	"fmt"
+	"go/constant"
+	"go/token"
+	"io"
+	"sort"
+)
+
+type intReader struct {
+	*bytes.Reader
+	path string
+}
+
+func (r *intReader) int64() int64 {
+	i, err := binary.ReadVarint(r.Reader)
+	if err != nil {
+		errorf("import %q: read varint error: %v", r.path, err)
+	}
+	return i
+}
+
+func (r *intReader) uint64() uint64 {
+	i, err := binary.ReadUvarint(r.Reader)
+	if err != nil {
+		errorf("import %q: read varint error: %v", r.path, err)
+	}
+	return i
+}
+
+const predeclReserved = 32
+
+type itag uint64
+
+const (
+	// Types
+	definedType itag = iota
+	pointerType
+	sliceType
+	arrayType
+	chanType
+	mapType
+	signatureType
+	structType
+	interfaceType
+)
+
+// iImportData imports a package from the serialized package data
+// and returns the number of bytes consumed and a reference to the package.
+// If the export data version is not recognized or the format is otherwise
+// compromised, an error is returned.
+func iImportData(imports map[string]*types2.Package, data []byte, path string) (_ int, pkg *types2.Package, err error) {
+	const currentVersion = 1
+	version := int64(-1)
+	defer func() {
+		if e := recover(); e != nil {
+			if version > currentVersion {
+				err = fmt.Errorf("cannot import %q (%v), export data is newer version - update tool", path, e)
+			} else {
+				err = fmt.Errorf("cannot import %q (%v), possibly version skew - reinstall package", path, e)
+			}
+		}
+	}()
+
+	r := &intReader{bytes.NewReader(data), path}
+
+	version = int64(r.uint64())
+	switch version {
+	case currentVersion, 0:
+	default:
+		errorf("unknown iexport format version %d", version)
+	}
+
+	sLen := int64(r.uint64())
+	dLen := int64(r.uint64())
+
+	whence, _ := r.Seek(0, io.SeekCurrent)
+	stringData := data[whence : whence+sLen]
+	declData := data[whence+sLen : whence+sLen+dLen]
+	r.Seek(sLen+dLen, io.SeekCurrent)
+
+	p := iimporter{
+		ipath:   path,
+		version: int(version),
+
+		stringData:  stringData,
+		stringCache: make(map[uint64]string),
+		pkgCache:    make(map[uint64]*types2.Package),
+
+		declData: declData,
+		pkgIndex: make(map[*types2.Package]map[string]uint64),
+		typCache: make(map[uint64]types2.Type),
+	}
+
+	for i, pt := range predeclared {
+		p.typCache[uint64(i)] = pt
+	}
+
+	pkgList := make([]*types2.Package, r.uint64())
+	for i := range pkgList {
+		pkgPathOff := r.uint64()
+		pkgPath := p.stringAt(pkgPathOff)
+		pkgName := p.stringAt(r.uint64())
+		_ = r.uint64() // package height; unused by go/types
+
+		if pkgPath == "" {
+			pkgPath = path
+		}
+		pkg := imports[pkgPath]
+		if pkg == nil {
+			pkg = types2.NewPackage(pkgPath, pkgName)
+			imports[pkgPath] = pkg
+		} else if pkg.Name() != pkgName {
+			errorf("conflicting names %s and %s for package %q", pkg.Name(), pkgName, path)
+		}
+
+		p.pkgCache[pkgPathOff] = pkg
+
+		nameIndex := make(map[string]uint64)
+		for nSyms := r.uint64(); nSyms > 0; nSyms-- {
+			name := p.stringAt(r.uint64())
+			nameIndex[name] = r.uint64()
+		}
+
+		p.pkgIndex[pkg] = nameIndex
+		pkgList[i] = pkg
+	}
+
+	localpkg := pkgList[0]
+
+	names := make([]string, 0, len(p.pkgIndex[localpkg]))
+	for name := range p.pkgIndex[localpkg] {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	for _, name := range names {
+		p.doDecl(localpkg, name)
+	}
+
+	for _, typ := range p.interfaceList {
+		typ.Complete()
+	}
+
+	// record all referenced packages as imports
+	list := append(([]*types2.Package)(nil), pkgList[1:]...)
+	sort.Sort(byPath(list))
+	localpkg.SetImports(list)
+
+	// package was imported completely and without errors
+	localpkg.MarkComplete()
+
+	consumed, _ := r.Seek(0, io.SeekCurrent)
+	return int(consumed), localpkg, nil
+}
+
+type iimporter struct {
+	ipath   string
+	version int
+
+	stringData  []byte
+	stringCache map[uint64]string
+	pkgCache    map[uint64]*types2.Package
+
+	declData []byte
+	pkgIndex map[*types2.Package]map[string]uint64
+	typCache map[uint64]types2.Type
+
+	interfaceList []*types2.Interface
+}
+
+func (p *iimporter) doDecl(pkg *types2.Package, name string) {
+	// See if we've already imported this declaration.
+	if obj := pkg.Scope().Lookup(name); obj != nil {
+		return
+	}
+
+	off, ok := p.pkgIndex[pkg][name]
+	if !ok {
+		errorf("%v.%v not in index", pkg, name)
+	}
+
+	r := &importReader{p: p, currPkg: pkg}
+	r.declReader.Reset(p.declData[off:])
+
+	r.obj(name)
+}
+
+func (p *iimporter) stringAt(off uint64) string {
+	if s, ok := p.stringCache[off]; ok {
+		return s
+	}
+
+	slen, n := binary.Uvarint(p.stringData[off:])
+	if n <= 0 {
+		errorf("varint failed")
+	}
+	spos := off + uint64(n)
+	s := string(p.stringData[spos : spos+slen])
+	p.stringCache[off] = s
+	return s
+}
+
+func (p *iimporter) pkgAt(off uint64) *types2.Package {
+	if pkg, ok := p.pkgCache[off]; ok {
+		return pkg
+	}
+	path := p.stringAt(off)
+	errorf("missing package %q in %q", path, p.ipath)
+	return nil
+}
+
+func (p *iimporter) typAt(off uint64, base *types2.Named) types2.Type {
+	if t, ok := p.typCache[off]; ok && (base == nil || !isInterface(t)) {
+		return t
+	}
+
+	if off < predeclReserved {
+		errorf("predeclared type missing from cache: %v", off)
+	}
+
+	r := &importReader{p: p}
+	r.declReader.Reset(p.declData[off-predeclReserved:])
+	t := r.doType(base)
+
+	if base == nil || !isInterface(t) {
+		p.typCache[off] = t
+	}
+	return t
+}
+
+type importReader struct {
+	p          *iimporter
+	declReader bytes.Reader
+	currPkg    *types2.Package
+	prevFile   string
+	prevLine   int64
+	prevColumn int64
+}
+
+func (r *importReader) obj(name string) {
+	tag := r.byte()
+	pos := r.pos()
+
+	switch tag {
+	case 'A':
+		typ := r.typ()
+
+		r.declare(types2.NewTypeName(pos, r.currPkg, name, typ))
+
+	case 'C':
+		typ, val := r.value()
+
+		r.declare(types2.NewConst(pos, r.currPkg, name, typ, val))
+
+	case 'F':
+		sig := r.signature(nil)
+
+		r.declare(types2.NewFunc(pos, r.currPkg, name, sig))
+
+	case 'T':
+		// Types can be recursive. We need to setup a stub
+		// declaration before recursing.
+		obj := types2.NewTypeName(pos, r.currPkg, name, nil)
+		named := types2.NewNamed(obj, nil, nil)
+		r.declare(obj)
+
+		underlying := r.p.typAt(r.uint64(), named).Underlying()
+		named.SetUnderlying(underlying)
+
+		if !isInterface(underlying) {
+			for n := r.uint64(); n > 0; n-- {
+				mpos := r.pos()
+				mname := r.ident()
+				recv := r.param()
+				msig := r.signature(recv)
+
+				named.AddMethod(types2.NewFunc(mpos, r.currPkg, mname, msig))
+			}
+		}
+
+	case 'V':
+		typ := r.typ()
+
+		r.declare(types2.NewVar(pos, r.currPkg, name, typ))
+
+	default:
+		errorf("unexpected tag: %v", tag)
+	}
+}
+
+func (r *importReader) declare(obj types2.Object) {
+	obj.Pkg().Scope().Insert(obj)
+}
+
+func (r *importReader) value() (typ types2.Type, val constant.Value) {
+	typ = r.typ()
+
+	switch b := typ.Underlying().(*types2.Basic); b.Info() & types2.IsConstType {
+	case types2.IsBoolean:
+		val = constant.MakeBool(r.bool())
+
+	case types2.IsString:
+		val = constant.MakeString(r.string())
+
+	case types2.IsInteger:
+		val = r.mpint(b)
+
+	case types2.IsFloat:
+		val = r.mpfloat(b)
+
+	case types2.IsComplex:
+		re := r.mpfloat(b)
+		im := r.mpfloat(b)
+		val = constant.BinaryOp(re, token.ADD, constant.MakeImag(im))
+
+	default:
+		errorf("unexpected type %v", typ) // panics
+		panic("unreachable")
+	}
+
+	return
+}
+
+func intSize(b *types2.Basic) (signed bool, maxBytes uint) {
+	if (b.Info() & types2.IsUntyped) != 0 {
+		return true, 64
+	}
+
+	switch b.Kind() {
+	case types2.Float32, types2.Complex64:
+		return true, 3
+	case types2.Float64, types2.Complex128:
+		return true, 7
+	}
+
+	signed = (b.Info() & types2.IsUnsigned) == 0
+	switch b.Kind() {
+	case types2.Int8, types2.Uint8:
+		maxBytes = 1
+	case types2.Int16, types2.Uint16:
+		maxBytes = 2
+	case types2.Int32, types2.Uint32:
+		maxBytes = 4
+	default:
+		maxBytes = 8
+	}
+
+	return
+}
+
+func (r *importReader) mpint(b *types2.Basic) constant.Value {
+	signed, maxBytes := intSize(b)
+
+	maxSmall := 256 - maxBytes
+	if signed {
+		maxSmall = 256 - 2*maxBytes
+	}
+	if maxBytes == 1 {
+		maxSmall = 256
+	}
+
+	n, _ := r.declReader.ReadByte()
+	if uint(n) < maxSmall {
+		v := int64(n)
+		if signed {
+			v >>= 1
+			if n&1 != 0 {
+				v = ^v
+			}
+		}
+		return constant.MakeInt64(v)
+	}
+
+	v := -n
+	if signed {
+		v = -(n &^ 1) >> 1
+	}
+	if v < 1 || uint(v) > maxBytes {
+		errorf("weird decoding: %v, %v => %v", n, signed, v)
+	}
+
+	buf := make([]byte, v)
+	io.ReadFull(&r.declReader, buf)
+
+	// convert to little endian
+	// TODO(gri) go/constant should have a more direct conversion function
+	//           (e.g., once it supports a big.Float based implementation)
+	for i, j := 0, len(buf)-1; i < j; i, j = i+1, j-1 {
+		buf[i], buf[j] = buf[j], buf[i]
+	}
+
+	x := constant.MakeFromBytes(buf)
+	if signed && n&1 != 0 {
+		x = constant.UnaryOp(token.SUB, x, 0)
+	}
+	return x
+}
+
+func (r *importReader) mpfloat(b *types2.Basic) constant.Value {
+	x := r.mpint(b)
+	if constant.Sign(x) == 0 {
+		return x
+	}
+
+	exp := r.int64()
+	switch {
+	case exp > 0:
+		x = constant.Shift(x, token.SHL, uint(exp))
+	case exp < 0:
+		d := constant.Shift(constant.MakeInt64(1), token.SHL, uint(-exp))
+		x = constant.BinaryOp(x, token.QUO, d)
+	}
+	return x
+}
+
+func (r *importReader) ident() string {
+	return r.string()
+}
+
+func (r *importReader) qualifiedIdent() (*types2.Package, string) {
+	name := r.string()
+	pkg := r.pkg()
+	return pkg, name
+}
+
+func (r *importReader) pos() syntax.Pos {
+	if r.p.version >= 1 {
+		r.posv1()
+	} else {
+		r.posv0()
+	}
+
+	if r.prevFile == "" && r.prevLine == 0 && r.prevColumn == 0 {
+		return syntax.Pos{}
+	}
+	// TODO(gri) fix this
+	// return r.p.fake.pos(r.prevFile, int(r.prevLine), int(r.prevColumn))
+	return syntax.Pos{}
+}
+
+func (r *importReader) posv0() {
+	delta := r.int64()
+	if delta != deltaNewFile {
+		r.prevLine += delta
+	} else if l := r.int64(); l == -1 {
+		r.prevLine += deltaNewFile
+	} else {
+		r.prevFile = r.string()
+		r.prevLine = l
+	}
+}
+
+func (r *importReader) posv1() {
+	delta := r.int64()
+	r.prevColumn += delta >> 1
+	if delta&1 != 0 {
+		delta = r.int64()
+		r.prevLine += delta >> 1
+		if delta&1 != 0 {
+			r.prevFile = r.string()
+		}
+	}
+}
+
+func (r *importReader) typ() types2.Type {
+	return r.p.typAt(r.uint64(), nil)
+}
+
+func isInterface(t types2.Type) bool {
+	_, ok := t.(*types2.Interface)
+	return ok
+}
+
+func (r *importReader) pkg() *types2.Package { return r.p.pkgAt(r.uint64()) }
+func (r *importReader) string() string       { return r.p.stringAt(r.uint64()) }
+
+func (r *importReader) doType(base *types2.Named) types2.Type {
+	switch k := r.kind(); k {
+	default:
+		errorf("unexpected kind tag in %q: %v", r.p.ipath, k)
+		return nil
+
+	case definedType:
+		pkg, name := r.qualifiedIdent()
+		r.p.doDecl(pkg, name)
+		return pkg.Scope().Lookup(name).(*types2.TypeName).Type()
+	case pointerType:
+		return types2.NewPointer(r.typ())
+	case sliceType:
+		return types2.NewSlice(r.typ())
+	case arrayType:
+		n := r.uint64()
+		return types2.NewArray(r.typ(), int64(n))
+	case chanType:
+		dir := chanDir(int(r.uint64()))
+		return types2.NewChan(dir, r.typ())
+	case mapType:
+		return types2.NewMap(r.typ(), r.typ())
+	case signatureType:
+		r.currPkg = r.pkg()
+		return r.signature(nil)
+
+	case structType:
+		r.currPkg = r.pkg()
+
+		fields := make([]*types2.Var, r.uint64())
+		tags := make([]string, len(fields))
+		for i := range fields {
+			fpos := r.pos()
+			fname := r.ident()
+			ftyp := r.typ()
+			emb := r.bool()
+			tag := r.string()
+
+			fields[i] = types2.NewField(fpos, r.currPkg, fname, ftyp, emb)
+			tags[i] = tag
+		}
+		return types2.NewStruct(fields, tags)
+
+	case interfaceType:
+		r.currPkg = r.pkg()
+
+		embeddeds := make([]types2.Type, r.uint64())
+		for i := range embeddeds {
+			_ = r.pos()
+			embeddeds[i] = r.typ()
+		}
+
+		methods := make([]*types2.Func, r.uint64())
+		for i := range methods {
+			mpos := r.pos()
+			mname := r.ident()
+
+			// TODO(mdempsky): Matches bimport.go, but I
+			// don't agree with this.
+			var recv *types2.Var
+			if base != nil {
+				recv = types2.NewVar(syntax.Pos{}, r.currPkg, "", base)
+			}
+
+			msig := r.signature(recv)
+			methods[i] = types2.NewFunc(mpos, r.currPkg, mname, msig)
+		}
+
+		typ := types2.NewInterfaceType(methods, embeddeds)
+		r.p.interfaceList = append(r.p.interfaceList, typ)
+		return typ
+	}
+}
+
+func (r *importReader) kind() itag {
+	return itag(r.uint64())
+}
+
+func (r *importReader) signature(recv *types2.Var) *types2.Signature {
+	params := r.paramList()
+	results := r.paramList()
+	variadic := params.Len() > 0 && r.bool()
+	return types2.NewSignature(recv, params, results, variadic)
+}
+
+func (r *importReader) paramList() *types2.Tuple {
+	xs := make([]*types2.Var, r.uint64())
+	for i := range xs {
+		xs[i] = r.param()
+	}
+	return types2.NewTuple(xs...)
+}
+
+func (r *importReader) param() *types2.Var {
+	pos := r.pos()
+	name := r.ident()
+	typ := r.typ()
+	return types2.NewParam(pos, r.currPkg, name, typ)
+}
+
+func (r *importReader) bool() bool {
+	return r.uint64() != 0
+}
+
+func (r *importReader) int64() int64 {
+	n, err := binary.ReadVarint(&r.declReader)
+	if err != nil {
+		errorf("readVarint: %v", err)
+	}
+	return n
+}
+
+func (r *importReader) uint64() uint64 {
+	n, err := binary.ReadUvarint(&r.declReader)
+	if err != nil {
+		errorf("readUvarint: %v", err)
+	}
+	return n
+}
+
+func (r *importReader) byte() byte {
+	x, err := r.declReader.ReadByte()
+	if err != nil {
+		errorf("declReader.ReadByte: %v", err)
+	}
+	return x
+}
diff --git a/src/cmd/compile/internal/importer/support.go b/src/cmd/compile/internal/importer/support.go
new file mode 100644
index 0000000000..4f013f4a51
--- /dev/null
+++ b/src/cmd/compile/internal/importer/support.go
@@ -0,0 +1,144 @@
+// UNREVIEWED
+// Copyright 2015 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.
+
+// This file implements support functionality for iimport.go.
+
+package importer
+
+import (
+	"cmd/compile/internal/types2"
+	"fmt"
+	"go/token"
+	"sync"
+)
+
+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
+type fakeFileSet struct {
+	fset  *token.FileSet
+	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
+	anyType{},
+}
+
+type anyType struct{}
+
+func (t anyType) Underlying() types2.Type { return t }
+func (t anyType) Under() types2.Type      { return t }
+func (t anyType) String() string          { return "any" }
+
+// types2.aType is not exported for now so we need to implemented these here.
+func (anyType) Basic() *types2.Basic         { return nil }
+func (anyType) Array() *types2.Array         { return nil }
+func (anyType) Slice() *types2.Slice         { return nil }
+func (anyType) Struct() *types2.Struct       { return nil }
+func (anyType) Pointer() *types2.Pointer     { return nil }
+func (anyType) Tuple() *types2.Tuple         { return nil }
+func (anyType) Signature() *types2.Signature { return nil }
+func (anyType) Sum() *types2.Sum             { return nil }
+func (anyType) Interface() *types2.Interface { return nil }
+func (anyType) Map() *types2.Map             { return nil }
+func (anyType) Chan() *types2.Chan           { return nil }
+func (anyType) Named() *types2.Named         { return nil }
+func (anyType) TypeParam() *types2.TypeParam { return nil }
diff --git a/src/cmd/compile/internal/importer/testdata/a.go b/src/cmd/compile/internal/importer/testdata/a.go
new file mode 100644
index 0000000000..06dafee98c
--- /dev/null
+++ b/src/cmd/compile/internal/importer/testdata/a.go
@@ -0,0 +1,15 @@
+// UNREVIEWED
+// Copyright 2016 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.
+
+// Input for TestIssue13566
+
+package a
+
+import "encoding/json"
+
+type A struct {
+	a    *A
+	json json.RawMessage
+}
diff --git a/src/cmd/compile/internal/importer/testdata/b.go b/src/cmd/compile/internal/importer/testdata/b.go
new file mode 100644
index 0000000000..a601dbccc5
--- /dev/null
+++ b/src/cmd/compile/internal/importer/testdata/b.go
@@ -0,0 +1,12 @@
+// UNREVIEWED
+// Copyright 2016 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.
+
+// Input for TestIssue13566
+
+package b
+
+import "./a"
+
+type A a.A
diff --git a/src/cmd/compile/internal/importer/testdata/exports.go b/src/cmd/compile/internal/importer/testdata/exports.go
new file mode 100644
index 0000000000..2a720fd2c1
--- /dev/null
+++ b/src/cmd/compile/internal/importer/testdata/exports.go
@@ -0,0 +1,89 @@
+// UNREVIEWED
+// Copyright 2011 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.
+
+// This file is used to generate an object file which
+// serves as test file for gcimporter_test.go.
+
+package exports
+
+import "go/ast"
+
+// Issue 3682: Correctly read dotted identifiers from export data.
+const init1 = 0
+
+func init() {}
+
+const (
+	C0 int = 0
+	C1     = 3.14159265
+	C2     = 2.718281828i
+	C3     = -123.456e-789
+	C4     = +123.456e+789
+	C5     = 1234i
+	C6     = "foo\n"
+	C7     = `bar\n`
+)
+
+type (
+	T1  int
+	T2  [10]int
+	T3  []int
+	T4  *int
+	T5  chan int
+	T6a chan<- int
+	T6b chan (<-chan int)
+	T6c chan<- (chan int)
+	T7  <-chan *ast.File
+	T8  struct{}
+	T9  struct {
+		a    int
+		b, c float32
+		d    []string `go:"tag"`
+	}
+	T10 struct {
+		T8
+		T9
+		_ *T10
+	}
+	T11 map[int]string
+	T12 interface{}
+	T13 interface {
+		m1()
+		m2(int) float32
+	}
+	T14 interface {
+		T12
+		T13
+		m3(x ...struct{}) []T9
+	}
+	T15 func()
+	T16 func(int)
+	T17 func(x int)
+	T18 func() float32
+	T19 func() (x float32)
+	T20 func(...interface{})
+	T21 struct{ next *T21 }
+	T22 struct{ link *T23 }
+	T23 struct{ link *T22 }
+	T24 *T24
+	T25 *T26
+	T26 *T27
+	T27 *T25
+	T28 func(T28) T28
+)
+
+var (
+	V0 int
+	V1         = -991.0
+	V2 float32 = 1.2
+)
+
+func F1()         {}
+func F2(x int)    {}
+func F3() int     { return 0 }
+func F4() float32 { return 0 }
+func F5(a, b, c int, u, v, w struct{ x, y T1 }, more ...interface{}) (p, q, r chan<- T10)
+
+func (p *T1) M1()
diff --git a/src/cmd/compile/internal/importer/testdata/issue15920.go b/src/cmd/compile/internal/importer/testdata/issue15920.go
new file mode 100644
index 0000000000..b402026162
--- /dev/null
+++ b/src/cmd/compile/internal/importer/testdata/issue15920.go
@@ -0,0 +1,12 @@
+// UNREVIEWED
+// Copyright 2016 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 p
+
+// The underlying type of Error is the underlying type of error.
+// Make sure we can import this again without problems.
+type Error error
+
+func F() Error { return nil }
diff --git a/src/cmd/compile/internal/importer/testdata/issue20046.go b/src/cmd/compile/internal/importer/testdata/issue20046.go
new file mode 100644
index 0000000000..e412f353ad
--- /dev/null
+++ b/src/cmd/compile/internal/importer/testdata/issue20046.go
@@ -0,0 +1,10 @@
+// UNREVIEWED
+// Copyright 2017 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 p
+
+var V interface {
+	M()
+}
diff --git a/src/cmd/compile/internal/importer/testdata/issue25301.go b/src/cmd/compile/internal/importer/testdata/issue25301.go
new file mode 100644
index 0000000000..a9dc1d7f08
--- /dev/null
+++ b/src/cmd/compile/internal/importer/testdata/issue25301.go
@@ -0,0 +1,18 @@
+// UNREVIEWED
+// Copyright 2018 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 issue25301
+
+type (
+	A = interface {
+		M()
+	}
+	T interface {
+		A
+	}
+	S struct{}
+)
+
+func (S) M() { println("m") }
diff --git a/src/cmd/compile/internal/importer/testdata/issue25596.go b/src/cmd/compile/internal/importer/testdata/issue25596.go
new file mode 100644
index 0000000000..95bef42280
--- /dev/null
+++ b/src/cmd/compile/internal/importer/testdata/issue25596.go
@@ -0,0 +1,14 @@
+// UNREVIEWED
+// Copyright 2018 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 issue25596
+
+type E interface {
+	M() T
+}
+
+type T interface {
+	E
+}
diff --git a/src/cmd/compile/internal/importer/testdata/p.go b/src/cmd/compile/internal/importer/testdata/p.go
new file mode 100644
index 0000000000..34a20eaa14
--- /dev/null
+++ b/src/cmd/compile/internal/importer/testdata/p.go
@@ -0,0 +1,14 @@
+// UNREVIEWED
+// Copyright 2016 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.
+
+// Input for TestIssue15517
+
+package p
+
+const C = 0
+
+var V int
+
+func F() {}
diff --git a/src/cmd/compile/internal/importer/testdata/versions/test.go b/src/cmd/compile/internal/importer/testdata/versions/test.go
new file mode 100644
index 0000000000..2f8eb5ced0
--- /dev/null
+++ b/src/cmd/compile/internal/importer/testdata/versions/test.go
@@ -0,0 +1,29 @@
+// UNREVIEWED
+// Copyright 2016 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.
+
+// To create a test case for a new export format version,
+// build this package with the latest compiler and store
+// the resulting .a file appropriately named in the versions
+// directory. The VersionHandling test will pick it up.
+//
+// In the testdata/versions:
+//
+// go build -o test_go1.$X_$Y.a test.go
+//
+// with $X = Go version and $Y = export format version
+// (add 'b' or 'i' to distinguish between binary and
+// indexed format starting with 1.11 as long as both
+// formats are supported).
+//
+// Make sure this source is extended such that it exercises
+// whatever export format change has taken place.
+
+package test
+
+// Any release before and including Go 1.7 didn't encode
+// the package for a blank struct field.
+type BlankField struct {
+	_ int
+}
diff --git a/src/cmd/compile/internal/types2/api.go b/src/cmd/compile/internal/types2/api.go
new file mode 100644
index 0000000000..eff90d4cdf
--- /dev/null
+++ b/src/cmd/compile/internal/types2/api.go
@@ -0,0 +1,426 @@
+// UNREVIEWED
+// Copyright 2012 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 types declares the data types and implements
+// the algorithms for type-checking of Go packages. Use
+// Config.Check to invoke the type checker for a package.
+// Alternatively, create a new type checker with NewChecker
+// and invoke it incrementally by calling Checker.Files.
+//
+// Type-checking consists of several interdependent phases:
+//
+// Name resolution maps each identifier (syntax.Name) in the program to the
+// language object (Object) it denotes.
+// Use Info.{Defs,Uses,Implicits} for the results of name resolution.
+//
+// Constant folding computes the exact constant value (constant.Value)
+// for every expression (syntax.Expr) that is a compile-time constant.
+// Use Info.Types[expr].Value for the results of constant folding.
+//
+// Type inference computes the type (Type) of every expression (syntax.Expr)
+// and checks for compliance with the language specification.
+// Use Info.Types[expr].Type for the results of type inference.
+//
+// For a tutorial, see https://golang.org/s/types-tutorial.
+//
+package types2
+
+import (
+	"bytes"
+	"cmd/compile/internal/syntax"
+	"fmt"
+	"go/constant"
+)
+
+// An Error describes a type-checking error; it implements the error interface.
+// A "soft" error is an error that still permits a valid interpretation of a
+// package (such as "unused variable"); "hard" errors may lead to unpredictable
+// behavior if ignored.
+type Error struct {
+	Pos  syntax.Pos // error position
+	Msg  string     // default error message, user-friendly
+	Full string     // full error message, for debugging (may contain internal details)
+	Soft bool       // if set, error is "soft"
+}
+
+// Error returns an error string formatted as follows:
+// filename:line:column: message
+func (err Error) Error() string {
+	return fmt.Sprintf("%s: %s", err.Pos, err.Msg)
+}
+
+// FullError returns an error string like Error, buy it may contain
+// type-checker internal details such as subscript indices for type
+// parameters and more. Useful for debugging.
+func (err Error) FullError() string {
+	return fmt.Sprintf("%s: %s", err.Pos, err.Full)
+}
+
+// An Importer resolves import paths to Packages.
+//
+// CAUTION: This interface does not support the import of locally
+// vendored packages. See https://golang.org/s/go15vendor.
+// If possible, external implementations should implement ImporterFrom.
+type Importer interface {
+	// Import returns the imported package for the given import path.
+	// The semantics is like for ImporterFrom.ImportFrom except that
+	// dir and mode are ignored (since they are not present).
+	Import(path string) (*Package, error)
+}
+
+// ImportMode is reserved for future use.
+type ImportMode int
+
+// An ImporterFrom resolves import paths to packages; it
+// supports vendoring per https://golang.org/s/go15vendor.
+// Use go/importer to obtain an ImporterFrom implementation.
+type ImporterFrom interface {
+	// Importer is present for backward-compatibility. Calling
+	// Import(path) is the same as calling ImportFrom(path, "", 0);
+	// i.e., locally vendored packages may not be found.
+	// The types package does not call Import if an ImporterFrom
+	// is present.
+	Importer
+
+	// ImportFrom returns the imported package for the given import
+	// path when imported by a package file located in dir.
+	// If the import failed, besides returning an error, ImportFrom
+	// is encouraged to cache and return a package anyway, if one
+	// was created. This will reduce package inconsistencies and
+	// follow-on type checker errors due to the missing package.
+	// The mode value must be 0; it is reserved for future use.
+	// Two calls to ImportFrom with the same path and dir must
+	// return the same package.
+	ImportFrom(path, dir string, mode ImportMode) (*Package, error)
+}
+
+// A Config specifies the configuration for type checking.
+// The zero value for Config is a ready-to-use default configuration.
+type Config struct {
+	// If IgnoreFuncBodies is set, function bodies are not
+	// type-checked.
+	IgnoreFuncBodies bool
+
+	// If AcceptMethodTypeParams is set, methods may have type parameters.
+	AcceptMethodTypeParams bool
+
+	// If InferFromConstraints is set, constraint type inference is used
+	// if some function type arguments are missing.
+	InferFromConstraints bool
+
+	// If FakeImportC is set, `import "C"` (for packages requiring Cgo)
+	// declares an empty "C" package and errors are omitted for qualified
+	// identifiers referring to package C (which won't find an object).
+	// This feature is intended for the standard library cmd/api tool.
+	//
+	// Caution: Effects may be unpredictable due to follow-on errors.
+	//          Do not use casually!
+	FakeImportC bool
+
+	// If go115UsesCgo is set, the type checker expects the
+	// _cgo_gotypes.go file generated by running cmd/cgo to be
+	// provided as a package source file. Qualified identifiers
+	// referring to package C will be resolved to cgo-provided
+	// declarations within _cgo_gotypes.go.
+	//
+	// It is an error to set both FakeImportC and go115UsesCgo.
+	go115UsesCgo bool
+
+	// If Trace is set, a debug trace is printed to stdout.
+	Trace bool
+
+	// If Error != nil, it is called with each error found
+	// during type checking; err has dynamic type Error.
+	// Secondary errors (for instance, to enumerate all types
+	// involved in an invalid recursive type declaration) have
+	// error strings that start with a '\t' character.
+	// If Error == nil, type-checking stops with the first
+	// error found.
+	Error func(err error)
+
+	// An importer is used to import packages referred to from
+	// import declarations.
+	// If the installed importer implements ImporterFrom, the type
+	// checker calls ImportFrom instead of Import.
+	// The type checker reports an error if an importer is needed
+	// but none was installed.
+	Importer Importer
+
+	// If Sizes != nil, it provides the sizing functions for package unsafe.
+	// Otherwise SizesFor("gc", "amd64") is used instead.
+	Sizes Sizes
+
+	// If DisableUnusedImportCheck is set, packages are not checked
+	// for unused imports.
+	DisableUnusedImportCheck bool
+}
+
+func srcimporter_setUsesCgo(conf *Config) {
+	conf.go115UsesCgo = true
+}
+
+// Info holds result type information for a type-checked package.
+// Only the information for which a map is provided is collected.
+// If the package has type errors, the collected information may
+// be incomplete.
+type Info struct {
+	// Types maps expressions to their types, and for constant
+	// expressions, also their values. Invalid expressions are
+	// omitted.
+	//
+	// For (possibly parenthesized) identifiers denoting built-in
+	// functions, the recorded signatures are call-site specific:
+	// if the call result is not a constant, the recorded type is
+	// an argument-specific signature. Otherwise, the recorded type
+	// is invalid.
+	//
+	// The Types map does not record the type of every identifier,
+	// only those that appear where an arbitrary expression is
+	// permitted. For instance, the identifier f in a selector
+	// expression x.f is found only in the Selections map, the
+	// identifier z in a variable declaration 'var z int' is found
+	// only in the Defs map, and identifiers denoting packages in
+	// qualified identifiers are collected in the Uses map.
+	Types map[syntax.Expr]TypeAndValue
+
+	// Inferred maps calls of parameterized functions that use
+	// type inference to the inferred type arguments and signature
+	// of the function called. The recorded "call" expression may be
+	// an *ast.CallExpr (as in f(x)), or an *ast.IndexExpr (s in f[T]).
+	Inferred map[syntax.Expr]Inferred
+
+	// Defs maps identifiers to the objects they define (including
+	// package names, dots "." of dot-imports, and blank "_" identifiers).
+	// For identifiers that do not denote objects (e.g., the package name
+	// in package clauses, or symbolic variables t in t := x.(type) of
+	// type switch headers), the corresponding objects are nil.
+	//
+	// For an embedded field, Defs returns the field *Var it defines.
+	//
+	// Invariant: Defs[id] == nil || Defs[id].Pos() == id.Pos()
+	Defs map[*syntax.Name]Object
+
+	// Uses maps identifiers to the objects they denote.
+	//
+	// For an embedded field, Uses returns the *TypeName it denotes.
+	//
+	// Invariant: Uses[id].Pos() != id.Pos()
+	Uses map[*syntax.Name]Object
+
+	// Implicits maps nodes to their implicitly declared objects, if any.
+	// The following node and object types may appear:
+	//
+	//     node               declared object
+	//
+	//     *syntax.ImportDecl    *PkgName for imports without renames
+	//     *syntax.CaseClause    type-specific *Var for each type switch case clause (incl. default)
+	//     *syntax.Field         anonymous parameter *Var (incl. unnamed results)
+	//
+	Implicits map[syntax.Node]Object
+
+	// Selections maps selector expressions (excluding qualified identifiers)
+	// to their corresponding selections.
+	Selections map[*syntax.SelectorExpr]*Selection
+
+	// Scopes maps syntax.Nodes to the scopes they define. Package scopes are not
+	// associated with a specific node but with all files belonging to a package.
+	// Thus, the package scope can be found in the type-checked Package object.
+	// Scopes nest, with the Universe scope being the outermost scope, enclosing
+	// the package scope, which contains (one or more) files scopes, which enclose
+	// function scopes which in turn enclose statement and function literal scopes.
+	// Note that even though package-level functions are declared in the package
+	// scope, the function scopes are embedded in the file scope of the file
+	// containing the function declaration.
+	//
+	// The following node types may appear in Scopes:
+	//
+	//     *syntax.File
+	//     *syntax.FuncType
+	//     *syntax.BlockStmt
+	//     *syntax.IfStmt
+	//     *syntax.SwitchStmt
+	//     *syntax.CaseClause
+	//     *syntax.CommClause
+	//     *syntax.ForStmt
+	//
+	Scopes map[syntax.Node]*Scope
+
+	// InitOrder is the list of package-level initializers in the order in which
+	// they must be executed. Initializers referring to variables related by an
+	// initialization dependency appear in topological order, the others appear
+	// in source order. Variables without an initialization expression do not
+	// appear in this list.
+	InitOrder []*Initializer
+}
+
+// TypeOf returns the type of expression e, or nil if not found.
+// Precondition: the Types, Uses and Defs maps are populated.
+//
+func (info *Info) TypeOf(e syntax.Expr) Type {
+	if t, ok := info.Types[e]; ok {
+		return t.Type
+	}
+	if id, _ := e.(*syntax.Name); id != nil {
+		if obj := info.ObjectOf(id); obj != nil {
+			return obj.Type()
+		}
+	}
+	return nil
+}
+
+// ObjectOf returns the object denoted by the specified id,
+// or nil if not found.
+//
+// If id is an embedded struct field, ObjectOf returns the field (*Var)
+// it defines, not the type (*TypeName) it uses.
+//
+// Precondition: the Uses and Defs maps are populated.
+//
+func (info *Info) ObjectOf(id *syntax.Name) Object {
+	if obj := info.Defs[id]; obj != nil {
+		return obj
+	}
+	return info.Uses[id]
+}
+
+// TypeAndValue reports the type and value (for constants)
+// of the corresponding expression.
+type TypeAndValue struct {
+	mode  operandMode
+	Type  Type
+	Value constant.Value
+}
+
+// IsVoid reports whether the corresponding expression
+// is a function call without results.
+func (tv TypeAndValue) IsVoid() bool {
+	return tv.mode == novalue
+}
+
+// IsType reports whether the corresponding expression specifies a type.
+func (tv TypeAndValue) IsType() bool {
+	return tv.mode == typexpr
+}
+
+// IsBuiltin reports whether the corresponding expression denotes
+// a (possibly parenthesized) built-in function.
+func (tv TypeAndValue) IsBuiltin() bool {
+	return tv.mode == builtin
+}
+
+// IsValue reports whether the corresponding expression is a value.
+// Builtins are not considered values. Constant values have a non-
+// nil Value.
+func (tv TypeAndValue) IsValue() bool {
+	switch tv.mode {
+	case constant_, variable, mapindex, value, commaok, commaerr:
+		return true
+	}
+	return false
+}
+
+// IsNil reports whether the corresponding expression denotes the
+// predeclared value nil.
+func (tv TypeAndValue) IsNil() bool {
+	return tv.mode == value && tv.Type == Typ[UntypedNil]
+}
+
+// Addressable reports whether the corresponding expression
+// is addressable (https://golang.org/ref/spec#Address_operators).
+func (tv TypeAndValue) Addressable() bool {
+	return tv.mode == variable
+}
+
+// Assignable reports whether the corresponding expression
+// is assignable to (provided a value of the right type).
+func (tv TypeAndValue) Assignable() bool {
+	return tv.mode == variable || tv.mode == mapindex
+}
+
+// HasOk reports whether the corresponding expression may be
+// used on the rhs of a comma-ok assignment.
+func (tv TypeAndValue) HasOk() bool {
+	return tv.mode == commaok || tv.mode == mapindex
+}
+
+// Inferred reports the inferred type arguments and signature
+// for a parameterized function call that uses type inference.
+type Inferred struct {
+	Targs []Type
+	Sig   *Signature
+}
+
+// An Initializer describes a package-level variable, or a list of variables in case
+// of a multi-valued initialization expression, and the corresponding initialization
+// expression.
+type Initializer struct {
+	Lhs []*Var // var Lhs = Rhs
+	Rhs syntax.Expr
+}
+
+func (init *Initializer) String() string {
+	var buf bytes.Buffer
+	for i, lhs := range init.Lhs {
+		if i > 0 {
+			buf.WriteString(", ")
+		}
+		buf.WriteString(lhs.Name())
+	}
+	buf.WriteString(" = ")
+	WriteExpr(&buf, init.Rhs)
+	return buf.String()
+}
+
+// Check type-checks a package and returns the resulting package object and
+// the first error if any. Additionally, if info != nil, Check populates each
+// of the non-nil maps in the Info struct.
+//
+// The package is marked as complete if no errors occurred, otherwise it is
+// incomplete. See Config.Error for controlling behavior in the presence of
+// errors.
+//
+// The package is specified by a list of *syntax.Files and corresponding
+// file set, and the package path the package is identified with.
+// The clean path must not be empty or dot (".").
+func (conf *Config) Check(path string, files []*syntax.File, info *Info) (*Package, error) {
+	pkg := NewPackage(path, "")
+	return pkg, NewChecker(conf, pkg, info).Files(files)
+}
+
+// AssertableTo reports whether a value of type V can be asserted to have type T.
+func AssertableTo(V *Interface, T Type) bool {
+	m, _ := (*Checker)(nil).assertableTo(V, T, false)
+	return m == nil
+}
+
+// AssignableTo reports whether a value of type V is assignable to a variable of type T.
+func AssignableTo(V, T Type) bool {
+	x := operand{mode: value, typ: V}
+	return x.assignableTo(nil, T, nil) // check not needed for non-constant x
+}
+
+// ConvertibleTo reports whether a value of type V is convertible to a value of type T.
+func ConvertibleTo(V, T Type) bool {
+	x := operand{mode: value, typ: V}
+	return x.convertibleTo(nil, T) // check not needed for non-constant x
+}
+
+// Implements reports whether type V implements interface T.
+func Implements(V Type, T *Interface) bool {
+	f, _ := MissingMethod(V, T, true)
+	return f == nil
+}
+
+// Identical reports whether x and y are identical types.
+// Receivers of Signature types are ignored.
+func Identical(x, y Type) bool {
+	return (*Checker)(nil).identical(x, y)
+}
+
+// IdenticalIgnoreTags reports whether x and y are identical types if tags are ignored.
+// Receivers of Signature types are ignored.
+func IdenticalIgnoreTags(x, y Type) bool {
+	return (*Checker)(nil).identicalIgnoreTags(x, y)
+}
diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go
new file mode 100644
index 0000000000..403df3f941
--- /dev/null
+++ b/src/cmd/compile/internal/types2/api_test.go
@@ -0,0 +1,1741 @@
+// UNREVIEWED
+// Copyright 2013 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 types2_test
+
+import (
+	"bytes"
+	"cmd/compile/internal/syntax"
+	"fmt"
+	"internal/testenv"
+	"reflect"
+	"regexp"
+	"strings"
+	"testing"
+
+	. "cmd/compile/internal/types2"
+)
+
+func unimplemented() {
+	panic("unimplemented")
+}
+
+func parseSrc(path, src string) (*syntax.File, error) {
+	errh := func(error) {} // dummy error handler so that parsing continues in presence of errors
+	return syntax.Parse(syntax.NewFileBase(path), strings.NewReader(src), errh, nil, syntax.AllowGenerics)
+}
+
+func pkgFor(path, source string, info *Info) (*Package, error) {
+	f, err := parseSrc(path, source)
+	if err != nil {
+		return nil, err
+	}
+	conf := Config{Importer: defaultImporter()}
+	return conf.Check(f.PkgName.Value, []*syntax.File{f}, info)
+}
+
+func mustTypecheck(t *testing.T, path, source string, info *Info) string {
+	pkg, err := pkgFor(path, source, info)
+	if err != nil {
+		name := path
+		if pkg != nil {
+			name = "package " + pkg.Name()
+		}
+		t.Fatalf("%s: didn't type-check (%s)", name, err)
+	}
+	return pkg.Name()
+}
+
+func mayTypecheck(t *testing.T, path, source string, info *Info) (string, error) {
+	f, err := parseSrc(path, source)
+	if f == nil { // ignore errors unless f is nil
+		t.Fatalf("%s: unable to parse: %s", path, err)
+	}
+	conf := Config{
+		AcceptMethodTypeParams: true,
+		InferFromConstraints:   true,
+		Error:                  func(err error) {},
+		Importer:               defaultImporter(),
+	}
+	pkg, err := conf.Check(f.PkgName.Value, []*syntax.File{f}, info)
+	return pkg.Name(), err
+}
+
+func TestValuesInfo(t *testing.T) {
+	var tests = []struct {
+		src  string
+		expr string // constant expression
+		typ  string // constant type
+		val  string // constant value
+	}{
+		{`package a0; const _ = false`, `false`, `untyped bool`, `false`},
+		{`package a1; const _ = 0`, `0`, `untyped int`, `0`},
+		{`package a2; const _ = 'A'`, `'A'`, `untyped rune`, `65`},
+		{`package a3; const _ = 0.`, `0.`, `untyped float`, `0`},
+		{`package a4; const _ = 0i`, `0i`, `untyped complex`, `(0 + 0i)`},
+		{`package a5; const _ = "foo"`, `"foo"`, `untyped string`, `"foo"`},
+
+		{`package b0; var _ = false`, `false`, `bool`, `false`},
+		{`package b1; var _ = 0`, `0`, `int`, `0`},
+		{`package b2; var _ = 'A'`, `'A'`, `rune`, `65`},
+		{`package b3; var _ = 0.`, `0.`, `float64`, `0`},
+		{`package b4; var _ = 0i`, `0i`, `complex128`, `(0 + 0i)`},
+		{`package b5; var _ = "foo"`, `"foo"`, `string`, `"foo"`},
+
+		{`package c0a; var _ = bool(false)`, `false`, `bool`, `false`},
+		{`package c0b; var _ = bool(false)`, `bool(false)`, `bool`, `false`},
+		{`package c0c; type T bool; var _ = T(false)`, `T(false)`, `c0c.T`, `false`},
+
+		{`package c1a; var _ = int(0)`, `0`, `int`, `0`},
+		{`package c1b; var _ = int(0)`, `int(0)`, `int`, `0`},
+		{`package c1c; type T int; var _ = T(0)`, `T(0)`, `c1c.T`, `0`},
+
+		{`package c2a; var _ = rune('A')`, `'A'`, `rune`, `65`},
+		{`package c2b; var _ = rune('A')`, `rune('A')`, `rune`, `65`},
+		{`package c2c; type T rune; var _ = T('A')`, `T('A')`, `c2c.T`, `65`},
+
+		{`package c3a; var _ = float32(0.)`, `0.`, `float32`, `0`},
+		{`package c3b; var _ = float32(0.)`, `float32(0.)`, `float32`, `0`},
+		{`package c3c; type T float32; var _ = T(0.)`, `T(0.)`, `c3c.T`, `0`},
+
+		{`package c4a; var _ = complex64(0i)`, `0i`, `complex64`, `(0 + 0i)`},
+		{`package c4b; var _ = complex64(0i)`, `complex64(0i)`, `complex64`, `(0 + 0i)`},
+		{`package c4c; type T complex64; var _ = T(0i)`, `T(0i)`, `c4c.T`, `(0 + 0i)`},
+
+		{`package c5a; var _ = string("foo")`, `"foo"`, `string`, `"foo"`},
+		{`package c5b; var _ = string("foo")`, `string("foo")`, `string`, `"foo"`},
+		{`package c5c; type T string; var _ = T("foo")`, `T("foo")`, `c5c.T`, `"foo"`},
+		{`package c5d; var _ = string(65)`, `65`, `untyped int`, `65`},
+		{`package c5e; var _ = string('A')`, `'A'`, `untyped rune`, `65`},
+		{`package c5f; type T string; var _ = T('A')`, `'A'`, `untyped rune`, `65`},
+		{`package c5g; var s uint; var _ = string(1 << s)`, `1 << s`, `untyped int`, ``},
+
+		{`package d0; var _ = []byte("foo")`, `"foo"`, `string`, `"foo"`},
+		{`package d1; var _ = []byte(string("foo"))`, `"foo"`, `string`, `"foo"`},
+		{`package d2; var _ = []byte(string("foo"))`, `string("foo")`, `string`, `"foo"`},
+		{`package d3; type T []byte; var _ = T("foo")`, `"foo"`, `string`, `"foo"`},
+
+		{`package e0; const _ = float32( 1e-200)`, `float32(1e-200)`, `float32`, `0`},
+		{`package e1; const _ = float32(-1e-200)`, `float32(-1e-200)`, `float32`, `0`},
+		{`package e2; const _ = float64( 1e-2000)`, `float64(1e-2000)`, `float64`, `0`},
+		{`package e3; const _ = float64(-1e-2000)`, `float64(-1e-2000)`, `float64`, `0`},
+		{`package e4; const _ = complex64( 1e-200)`, `complex64(1e-200)`, `complex64`, `(0 + 0i)`},
+		{`package e5; const _ = complex64(-1e-200)`, `complex64(-1e-200)`, `complex64`, `(0 + 0i)`},
+		{`package e6; const _ = complex128( 1e-2000)`, `complex128(1e-2000)`, `complex128`, `(0 + 0i)`},
+		{`package e7; const _ = complex128(-1e-2000)`, `complex128(-1e-2000)`, `complex128`, `(0 + 0i)`},
+
+		{`package f0 ; var _ float32 =  1e-200`, `1e-200`, `float32`, `0`},
+		{`package f1 ; var _ float32 = -1e-200`, `-1e-200`, `float32`, `0`},
+		{`package f2a; var _ float64 =  1e-2000`, `1e-2000`, `float64`, `0`},
+		{`package f3a; var _ float64 = -1e-2000`, `-1e-2000`, `float64`, `0`},
+		{`package f2b; var _         =  1e-2000`, `1e-2000`, `float64`, `0`},
+		{`package f3b; var _         = -1e-2000`, `-1e-2000`, `float64`, `0`},
+		{`package f4 ; var _ complex64  =  1e-200 `, `1e-200`, `complex64`, `(0 + 0i)`},
+		{`package f5 ; var _ complex64  = -1e-200 `, `-1e-200`, `complex64`, `(0 + 0i)`},
+		{`package f6a; var _ complex128 =  1e-2000i`, `1e-2000i`, `complex128`, `(0 + 0i)`},
+		{`package f7a; var _ complex128 = -1e-2000i`, `-1e-2000i`, `complex128`, `(0 + 0i)`},
+		{`package f6b; var _            =  1e-2000i`, `1e-2000i`, `complex128`, `(0 + 0i)`},
+		{`package f7b; var _            = -1e-2000i`, `-1e-2000i`, `complex128`, `(0 + 0i)`},
+
+		{`package g0; const (a = len([iota]int{}); b; c); const _ = c`, `c`, `int`, `2`}, // issue #22341
+	}
+
+	for _, test := range tests {
+		info := Info{
+			Types: make(map[syntax.Expr]TypeAndValue),
+		}
+		name := mustTypecheck(t, "ValuesInfo", test.src, &info)
+
+		// look for expression
+		var expr syntax.Expr
+		for e := range info.Types {
+			if ExprString(e) == test.expr {
+				expr = e
+				break
+			}
+		}
+		if expr == nil {
+			t.Errorf("package %s: no expression found for %s", name, test.expr)
+			continue
+		}
+		tv := info.Types[expr]
+
+		// check that type is correct
+		if got := tv.Type.String(); got != test.typ {
+			t.Errorf("package %s: got type %s; want %s", name, got, test.typ)
+			continue
+		}
+
+		// if we have a constant, check that value is correct
+		if tv.Value != nil {
+			if got := tv.Value.ExactString(); got != test.val {
+				t.Errorf("package %s: got value %s; want %s", name, got, test.val)
+			}
+		} else {
+			if test.val != "" {
+				t.Errorf("package %s: no constant found; want %s", name, test.val)
+			}
+		}
+	}
+}
+
+func TestTypesInfo(t *testing.T) {
+	var tests = []struct {
+		src  string
+		expr string // expression
+		typ  string // value type
+	}{
+		// single-valued expressions of untyped constants
+		{`package b0; var x interface{} = false`, `false`, `bool`},
+		{`package b1; var x interface{} = 0`, `0`, `int`},
+		{`package b2; var x interface{} = 0.`, `0.`, `float64`},
+		{`package b3; var x interface{} = 0i`, `0i`, `complex128`},
+		{`package b4; var x interface{} = "foo"`, `"foo"`, `string`},
+
+		// comma-ok expressions
+		{`package p0; var x interface{}; var _, _ = x.(int)`,
+			`x.(int)`,
+			`(int, bool)`,
+		},
+		{`package p1; var x interface{}; func _() { _, _ = x.(int) }`,
+			`x.(int)`,
+			`(int, bool)`,
+		},
+		{`package p2a; type mybool bool; var m map[string]complex128; var b mybool; func _() { _, b = m["foo"] }`,
+			`m["foo"]`,
+			`(complex128, p2a.mybool)`,
+		},
+		{`package p2b; var m map[string]complex128; var b bool; func _() { _, b = m["foo"] }`,
+			`m["foo"]`,
+			`(complex128, bool)`,
+		},
+		{`package p3; var c chan string; var _, _ = <-c`,
+			`<-c`,
+			`(string, bool)`,
+		},
+
+		// issue 6796
+		{`package issue6796_a; var x interface{}; var _, _ = (x.(int))`,
+			`x.(int)`,
+			`(int, bool)`,
+		},
+		{`package issue6796_b; var c chan string; var _, _ = (<-c)`,
+			`(<-c)`,
+			`(string, bool)`,
+		},
+		{`package issue6796_c; var c chan string; var _, _ = (<-c)`,
+			`<-c`,
+			`(string, bool)`,
+		},
+		{`package issue6796_d; var c chan string; var _, _ = ((<-c))`,
+			`(<-c)`,
+			`(string, bool)`,
+		},
+		{`package issue6796_e; func f(c chan string) { _, _ = ((<-c)) }`,
+			`(<-c)`,
+			`(string, bool)`,
+		},
+
+		// issue 7060
+		{`package issue7060_a; var ( m map[int]string; x, ok = m[0] )`,
+			`m[0]`,
+			`(string, bool)`,
+		},
+		{`package issue7060_b; var ( m map[int]string; x, ok interface{} = m[0] )`,
+			`m[0]`,
+			`(string, bool)`,
+		},
+		{`package issue7060_c; func f(x interface{}, ok bool, m map[int]string) { x, ok = m[0] }`,
+			`m[0]`,
+			`(string, bool)`,
+		},
+		{`package issue7060_d; var ( ch chan string; x, ok = <-ch )`,
+			`<-ch`,
+			`(string, bool)`,
+		},
+		{`package issue7060_e; var ( ch chan string; x, ok interface{} = <-ch )`,
+			`<-ch`,
+			`(string, bool)`,
+		},
+		{`package issue7060_f; func f(x interface{}, ok bool, ch chan string) { x, ok = <-ch }`,
+			`<-ch`,
+			`(string, bool)`,
+		},
+
+		// issue 28277
+		{`package issue28277_a; func f(...int)`,
+			`...int`,
+			`[]int`,
+		},
+		{`package issue28277_b; func f(a, b int, c ...[]struct{})`,
+			`...[]struct{}`,
+			`[][]struct{}`,
+		},
+
+		// tests for broken code that doesn't parse or type-check
+		{`package x0; func _() { var x struct {f string}; x.f := 0 }`, `x.f`, `string`},
+		{`package x1; func _() { var z string; type x struct {f string}; y := &x{q: z}}`, `z`, `string`},
+		{`package x2; func _() { var a, b string; type x struct {f string}; z := &x{f: a, f: b,}}`, `b`, `string`},
+		{`package x3; var x = panic("");`, `panic`, `func(interface{})`},
+		{`package x4; func _() { panic("") }`, `panic`, `func(interface{})`},
+		{`package x5; func _() { var x map[string][...]int; x = map[string][...]int{"": {1,2,3}} }`, `x`, `map[string][-1]int`},
+
+		// parameterized functions
+		{`package p0; func f[T any](T); var _ = f[int]`, `f`, `func[T₁ any](T₁)`},
+		{`package p1; func f[T any](T); var _ = f[int]`, `f[int]`, `func(int)`},
+		{`package p2; func f[T any](T); var _ = f(42)`, `f`, `func[T₁ any](T₁)`},
+		{`package p2; func f[T any](T); var _ = f(42)`, `f(42)`, `()`},
+
+		// type parameters
+		{`package t0; type t[] int; var _ t`, `t`, `t0.t`}, // t[] is a syntax error that is ignored in this test in favor of t
+		{`package t1; type t[P any] int; var _ t[int]`, `t`, `t1.t[P₁ any]`},
+		{`package t2; type t[P interface{}] int; var _ t[int]`, `t`, `t2.t[P₁ interface{}]`},
+		{`package t3; type t[P, Q interface{}] int; var _ t[int, int]`, `t`, `t3.t[P₁, Q₂ interface{}]`},
+		{`package t4; type t[P, Q interface{ m() }] int; var _ t[int, int]`, `t`, `t4.t[P₁, Q₂ interface{m()}]`},
+
+		// instantiated types must be sanitized
+		{`package g0; type t[P any] int; var x struct{ f t[int] }; var _ = x.f`, `x.f`, `g0.t[int]`},
+	}
+
+	for _, test := range tests {
+		info := Info{Types: make(map[syntax.Expr]TypeAndValue)}
+		name, _ := mayTypecheck(t, "TypesInfo", test.src, &info)
+
+		// look for expression type
+		var typ Type
+		for e, tv := range info.Types {
+			if ExprString(e) == test.expr {
+				typ = tv.Type
+				break
+			}
+		}
+		if typ == nil {
+			t.Errorf("package %s: no type found for %s", name, test.expr)
+			continue
+		}
+
+		// check that type is correct
+		if got := typ.String(); got != test.typ {
+			t.Errorf("package %s: got %s; want %s", name, got, test.typ)
+		}
+	}
+}
+
+func TestInferredInfo(t *testing.T) {
+	var tests = []struct {
+		src   string
+		fun   string
+		targs []string
+		sig   string
+	}{
+		{`package p0; func f[T any](T); func _() { f(42) }`,
+			`f`,
+			[]string{`int`},
+			`func(int)`,
+		},
+		{`package p1; func f[T any](T) T; func _() { f('@') }`,
+			`f`,
+			[]string{`rune`},
+			`func(rune) rune`,
+		},
+		{`package p2; func f[T any](...T) T; func _() { f(0i) }`,
+			`f`,
+			[]string{`complex128`},
+			`func(...complex128) complex128`,
+		},
+		{`package p3; func f[A, B, C any](A, *B, []C); func _() { f(1.2, new(string), []byte{}) }`,
+			`f`,
+			[]string{`float64`, `string`, `byte`},
+			`func(float64, *string, []byte)`,
+		},
+		{`package p4; func f[A, B any](A, *B, ...[]B); func _() { f(1.2, new(byte)) }`,
+			`f`,
+			[]string{`float64`, `byte`},
+			`func(float64, *byte, ...[]byte)`,
+		},
+
+		// we don't know how to translate these but we can type-check them
+		{`package q0; type T struct{}; func (T) m[P any](P); func _(x T) { x.m(42) }`,
+			`x.m`,
+			[]string{`int`},
+			`func(int)`,
+		},
+		{`package q1; type T struct{}; func (T) m[P any](P) P; func _(x T) { x.m(42) }`,
+			`x.m`,
+			[]string{`int`},
+			`func(int) int`,
+		},
+		{`package q2; type T struct{}; func (T) m[P any](...P) P; func _(x T) { x.m(42) }`,
+			`x.m`,
+			[]string{`int`},
+			`func(...int) int`,
+		},
+		{`package q3; type T struct{}; func (T) m[A, B, C any](A, *B, []C); func _(x T) { x.m(1.2, new(string), []byte{}) }`,
+			`x.m`,
+			[]string{`float64`, `string`, `byte`},
+			`func(float64, *string, []byte)`,
+		},
+		{`package q4; type T struct{}; func (T) m[A, B any](A, *B, ...[]B); func _(x T) { x.m(1.2, new(byte)) }`,
+			`x.m`,
+			[]string{`float64`, `byte`},
+			`func(float64, *byte, ...[]byte)`,
+		},
+
+		{`package r0; type T[P any] struct{}; func (_ T[P]) m[Q any](Q); func _[P any](x T[P]) { x.m(42) }`,
+			`x.m`,
+			[]string{`int`},
+			`func(int)`,
+		},
+		// TODO(gri) record method type parameters in syntax.FuncType so we can check this
+		// {`package r1; type T interface{ m[P any](P) }; func _(x T) { x.m(4.2) }`,
+		// 	`x.m`,
+		// 	[]string{`float64`},
+		// 	`func(float64)`,
+		// },
+
+		{`package s1; func f[T any, P interface{type *T}](x T); func _(x string) { f(x) }`,
+			`f`,
+			[]string{`string`, `*string`},
+			`func(x string)`,
+		},
+		{`package s2; func f[T any, P interface{type *T}](x []T); func _(x []int) { f(x) }`,
+			`f`,
+			[]string{`int`, `*int`},
+			`func(x []int)`,
+		},
+		{`package s3; type C[T any] interface{type chan<- T}; func f[T any, P C[T]](x []T); func _(x []int) { f(x) }`,
+			`f`,
+			[]string{`int`, `chan<- int`},
+			`func(x []int)`,
+		},
+		{`package s4; type C[T any] interface{type chan<- T}; func f[T any, P C[T], Q C[[]*P]](x []T); func _(x []int) { f(x) }`,
+			`f`,
+			[]string{`int`, `chan<- int`, `chan<- []*chan<- int`},
+			`func(x []int)`,
+		},
+
+		{`package t1; func f[T any, P interface{type *T}]() T; func _() { _ = f[string] }`,
+			`f`,
+			[]string{`string`, `*string`},
+			`func() string`,
+		},
+		{`package t2; type C[T any] interface{type chan<- T}; func f[T any, P C[T]]() []T; func _() { _ = f[int] }`,
+			`f`,
+			[]string{`int`, `chan<- int`},
+			`func() []int`,
+		},
+		{`package t3; type C[T any] interface{type chan<- T}; func f[T any, P C[T], Q C[[]*P]]() []T; func _() { _ = f[int] }`,
+			`f`,
+			[]string{`int`, `chan<- int`, `chan<- []*chan<- int`},
+			`func() []int`,
+		},
+	}
+
+	for _, test := range tests {
+		info := Info{Inferred: make(map[syntax.Expr]Inferred)}
+		name, err := mayTypecheck(t, "InferredInfo", test.src, &info)
+		if err != nil {
+			t.Errorf("package %s: %v", name, err)
+			continue
+		}
+
+		// look for inferred type arguments and signature
+		var targs []Type
+		var sig *Signature
+		for call, inf := range info.Inferred {
+			var fun syntax.Expr
+			switch x := call.(type) {
+			case *syntax.CallExpr:
+				fun = x.Fun
+			case *syntax.IndexExpr:
+				fun = x.X
+			default:
+				panic(fmt.Sprintf("unexpected call expression type %T", call))
+			}
+			if ExprString(fun) == test.fun {
+				targs = inf.Targs
+				sig = inf.Sig
+				break
+			}
+		}
+		if targs == nil {
+			t.Errorf("package %s: no inferred information found for %s", name, test.fun)
+			continue
+		}
+
+		// check that type arguments are correct
+		if len(targs) != len(test.targs) {
+			t.Errorf("package %s: got %d type arguments; want %d", name, len(targs), len(test.targs))
+			continue
+		}
+		for i, targ := range targs {
+			if got := targ.String(); got != test.targs[i] {
+				t.Errorf("package %s, %d. type argument: got %s; want %s", name, i, got, test.targs[i])
+				continue
+			}
+		}
+
+		// check that signature is correct
+		if got := sig.String(); got != test.sig {
+			t.Errorf("package %s: got %s; want %s", name, got, test.sig)
+		}
+	}
+}
+
+func TestDefsInfo(t *testing.T) {
+	var tests = []struct {
+		src  string
+		obj  string
+		want string
+	}{
+		{`package p0; const x = 42`, `x`, `const p0.x untyped int`},
+		{`package p1; const x int = 42`, `x`, `const p1.x int`},
+		{`package p2; var x int`, `x`, `var p2.x int`},
+		{`package p3; type x int`, `x`, `type p3.x int`},
+		{`package p4; func f()`, `f`, `func p4.f()`},
+
+		// generic types must be sanitized
+		// (need to use sufficiently nested types to provoke unexpanded types)
+		{`package g0; type t[P any] P; const x = t[int](42)`, `x`, `const g0.x g0.t[int]`},
+		{`package g1; type t[P any] P; var x = t[int](42)`, `x`, `var g1.x g1.t[int]`},
+		{`package g2; type t[P any] P; type x struct{ f t[int] }`, `x`, `type g2.x struct{f g2.t[int]}`},
+		{`package g3; type t[P any] P; func f(x struct{ f t[string] }); var g = f`, `g`, `var g3.g func(x struct{f g3.t[string]})`},
+	}
+
+	for _, test := range tests {
+		info := Info{
+			Defs: make(map[*syntax.Name]Object),
+		}
+		name := mustTypecheck(t, "DefsInfo", test.src, &info)
+
+		// find object
+		var def Object
+		for id, obj := range info.Defs {
+			if id.Value == test.obj {
+				def = obj
+				break
+			}
+		}
+		if def == nil {
+			t.Errorf("package %s: %s not found", name, test.obj)
+			continue
+		}
+
+		if got := def.String(); got != test.want {
+			t.Errorf("package %s: got %s; want %s", name, got, test.want)
+		}
+	}
+}
+
+func TestUsesInfo(t *testing.T) {
+	var tests = []struct {
+		src  string
+		obj  string
+		want string
+	}{
+		{`package p0; func _() { _ = x }; const x = 42`, `x`, `const p0.x untyped int`},
+		{`package p1; func _() { _ = x }; const x int = 42`, `x`, `const p1.x int`},
+		{`package p2; func _() { _ = x }; var x int`, `x`, `var p2.x int`},
+		{`package p3; func _() { type _ x }; type x int`, `x`, `type p3.x int`},
+		{`package p4; func _() { _ = f }; func f()`, `f`, `func p4.f()`},
+
+		// generic types must be sanitized
+		// (need to use sufficiently nested types to provoke unexpanded types)
+		{`package g0; func _() { _ = x }; type t[P any] P; const x = t[int](42)`, `x`, `const g0.x g0.t[int]`},
+		{`package g1; func _() { _ = x }; type t[P any] P; var x = t[int](42)`, `x`, `var g1.x g1.t[int]`},
+		{`package g2; func _() { type _ x }; type t[P any] P; type x struct{ f t[int] }`, `x`, `type g2.x struct{f g2.t[int]}`},
+		{`package g3; func _() { _ = f }; type t[P any] P; func f(x struct{ f t[string] })`, `f`, `func g3.f(x struct{f g3.t[string]})`},
+	}
+
+	for _, test := range tests {
+		info := Info{
+			Uses: make(map[*syntax.Name]Object),
+		}
+		name := mustTypecheck(t, "UsesInfo", test.src, &info)
+
+		// find object
+		var use Object
+		for id, obj := range info.Uses {
+			if id.Value == test.obj {
+				use = obj
+				break
+			}
+		}
+		if use == nil {
+			t.Errorf("package %s: %s not found", name, test.obj)
+			continue
+		}
+
+		if got := use.String(); got != test.want {
+			t.Errorf("package %s: got %s; want %s", name, got, test.want)
+		}
+	}
+}
+
+func TestImplicitsInfo(t *testing.T) {
+	testenv.MustHaveGoBuild(t)
+
+	var tests = []struct {
+		src  string
+		want string
+	}{
+		{`package p2; import . "fmt"; var _ = Println`, ""},           // no Implicits entry
+		{`package p0; import local "fmt"; var _ = local.Println`, ""}, // no Implicits entry
+		{`package p1; import "fmt"; var _ = fmt.Println`, "importSpec: package fmt"},
+
+		{`package p3; func f(x interface{}) { switch x.(type) { case int: } }`, ""}, // no Implicits entry
+		{`package p4; func f(x interface{}) { switch t := x.(type) { case int: _ = t } }`, "caseClause: var t int"},
+		{`package p5; func f(x interface{}) { switch t := x.(type) { case int, uint: _ = t } }`, "caseClause: var t interface{}"},
+		{`package p6; func f(x interface{}) { switch t := x.(type) { default: _ = t } }`, "caseClause: var t interface{}"},
+
+		{`package p7; func f(x int) {}`, ""}, // no Implicits entry
+		{`package p8; func f(int) {}`, "field: var  int"},
+		{`package p9; func f() (complex64) { return 0 }`, "field: var  complex64"},
+		{`package p10; type T struct{}; func (*T) f() {}`, "field: var  *p10.T"},
+	}
+
+	for _, test := range tests {
+		info := Info{
+			Implicits: make(map[syntax.Node]Object),
+		}
+		name := mustTypecheck(t, "ImplicitsInfo", test.src, &info)
+
+		// the test cases expect at most one Implicits entry
+		if len(info.Implicits) > 1 {
+			t.Errorf("package %s: %d Implicits entries found", name, len(info.Implicits))
+			continue
+		}
+
+		// extract Implicits entry, if any
+		var got string
+		for n, obj := range info.Implicits {
+			switch x := n.(type) {
+			case *syntax.ImportDecl:
+				got = "importSpec"
+			case *syntax.CaseClause:
+				got = "caseClause"
+			case *syntax.Field:
+				got = "field"
+			default:
+				t.Fatalf("package %s: unexpected %T", name, x)
+			}
+			got += ": " + obj.String()
+		}
+
+		// verify entry
+		if got != test.want {
+			t.Errorf("package %s: got %q; want %q", name, got, test.want)
+		}
+	}
+}
+
+func predString(tv TypeAndValue) string {
+	var buf bytes.Buffer
+	pred := func(b bool, s string) {
+		if b {
+			if buf.Len() > 0 {
+				buf.WriteString(", ")
+			}
+			buf.WriteString(s)
+		}
+	}
+
+	pred(tv.IsVoid(), "void")
+	pred(tv.IsType(), "type")
+	pred(tv.IsBuiltin(), "builtin")
+	pred(tv.IsValue() && tv.Value != nil, "const")
+	pred(tv.IsValue() && tv.Value == nil, "value")
+	pred(tv.IsNil(), "nil")
+	pred(tv.Addressable(), "addressable")
+	pred(tv.Assignable(), "assignable")
+	pred(tv.HasOk(), "hasOk")
+
+	if buf.Len() == 0 {
+		return "invalid"
+	}
+	return buf.String()
+}
+
+func TestPredicatesInfo(t *testing.T) {
+	testenv.MustHaveGoBuild(t)
+
+	var tests = []struct {
+		src  string
+		expr string
+		pred string
+	}{
+		// void
+		{`package n0; func f() { f() }`, `f()`, `void`},
+
+		// types
+		{`package t0; type _ int`, `int`, `type`},
+		{`package t1; type _ []int`, `[]int`, `type`},
+		{`package t2; type _ func()`, `func()`, `type`},
+		{`package t3; type _ func(int)`, `int`, `type`},
+		{`package t3; type _ func(...int)`, `...int`, `type`},
+
+		// built-ins
+		{`package b0; var _ = len("")`, `len`, `builtin`},
+		{`package b1; var _ = (len)("")`, `(len)`, `builtin`},
+
+		// constants
+		{`package c0; var _ = 42`, `42`, `const`},
+		{`package c1; var _ = "foo" + "bar"`, `"foo" + "bar"`, `const`},
+		{`package c2; const (i = 1i; _ = i)`, `i`, `const`},
+
+		// values
+		{`package v0; var (a, b int; _ = a + b)`, `a + b`, `value`},
+		{`package v1; var _ = &[]int{1}`, `([]int literal)`, `value`},
+		{`package v2; var _ = func(){}`, `(func() literal)`, `value`},
+		{`package v4; func f() { _ = f }`, `f`, `value`},
+		{`package v3; var _ *int = nil`, `nil`, `value, nil`},
+		{`package v3; var _ *int = (nil)`, `(nil)`, `value, nil`},
+
+		// addressable (and thus assignable) operands
+		{`package a0; var (x int; _ = x)`, `x`, `value, addressable, assignable`},
+		{`package a1; var (p *int; _ = *p)`, `*p`, `value, addressable, assignable`},
+		{`package a2; var (s []int; _ = s[0])`, `s[0]`, `value, addressable, assignable`},
+		{`package a3; var (s struct{f int}; _ = s.f)`, `s.f`, `value, addressable, assignable`},
+		{`package a4; var (a [10]int; _ = a[0])`, `a[0]`, `value, addressable, assignable`},
+		{`package a5; func _(x int) { _ = x }`, `x`, `value, addressable, assignable`},
+		{`package a6; func _()(x int) { _ = x; return }`, `x`, `value, addressable, assignable`},
+		{`package a7; type T int; func (x T) _() { _ = x }`, `x`, `value, addressable, assignable`},
+		// composite literals are not addressable
+
+		// assignable but not addressable values
+		{`package s0; var (m map[int]int; _ = m[0])`, `m[0]`, `value, assignable, hasOk`},
+		{`package s1; var (m map[int]int; _, _ = m[0])`, `m[0]`, `value, assignable, hasOk`},
+
+		// hasOk expressions
+		{`package k0; var (ch chan int; _ = <-ch)`, `<-ch`, `value, hasOk`},
+		{`package k1; var (ch chan int; _, _ = <-ch)`, `<-ch`, `value, hasOk`},
+
+		// missing entries
+		// - package names are collected in the Uses map
+		// - identifiers being declared are collected in the Defs map
+		{`package m0; import "os"; func _() { _ = os.Stdout }`, `os`, `<missing>`},
+		{`package m1; import p "os"; func _() { _ = p.Stdout }`, `p`, `<missing>`},
+		{`package m2; const c = 0`, `c`, `<missing>`},
+		{`package m3; type T int`, `T`, `<missing>`},
+		{`package m4; var v int`, `v`, `<missing>`},
+		{`package m5; func f() {}`, `f`, `<missing>`},
+		{`package m6; func _(x int) {}`, `x`, `<missing>`},
+		{`package m6; func _()(x int) { return }`, `x`, `<missing>`},
+		{`package m6; type T int; func (x T) _() {}`, `x`, `<missing>`},
+	}
+
+	for _, test := range tests {
+		info := Info{Types: make(map[syntax.Expr]TypeAndValue)}
+		name := mustTypecheck(t, "PredicatesInfo", test.src, &info)
+
+		// look for expression predicates
+		got := "<missing>"
+		for e, tv := range info.Types {
+			//println(name, ExprString(e))
+			if ExprString(e) == test.expr {
+				got = predString(tv)
+				break
+			}
+		}
+
+		if got != test.pred {
+			t.Errorf("package %s: got %s; want %s", name, got, test.pred)
+		}
+	}
+}
+
+func TestScopesInfo(t *testing.T) {
+	testenv.MustHaveGoBuild(t)
+
+	var tests = []struct {
+		src    string
+		scopes []string // list of scope descriptors of the form kind:varlist
+	}{
+		{`package p0`, []string{
+			"file:",
+		}},
+		{`package p1; import ( "fmt"; m "math"; _ "os" ); var ( _ = fmt.Println; _ = m.Pi )`, []string{
+			"file:fmt m",
+		}},
+		{`package p2; func _() {}`, []string{
+			"file:", "func:",
+		}},
+		{`package p3; func _(x, y int) {}`, []string{
+			"file:", "func:x y",
+		}},
+		{`package p4; func _(x, y int) { x, z := 1, 2; _ = z }`, []string{
+			"file:", "func:x y z", // redeclaration of x
+		}},
+		{`package p5; func _(x, y int) (u, _ int) { return }`, []string{
+			"file:", "func:u x y",
+		}},
+		{`package p6; func _() { { var x int; _ = x } }`, []string{
+			"file:", "func:", "block:x",
+		}},
+		{`package p7; func _() { if true {} }`, []string{
+			"file:", "func:", "if:", "block:",
+		}},
+		{`package p8; func _() { if x := 0; x < 0 { y := x; _ = y } }`, []string{
+			"file:", "func:", "if:x", "block:y",
+		}},
+		{`package p9; func _() { switch x := 0; x {} }`, []string{
+			"file:", "func:", "switch:x",
+		}},
+		{`package p10; func _() { switch x := 0; x { case 1: y := x; _ = y; default: }}`, []string{
+			"file:", "func:", "switch:x", "case:y", "case:",
+		}},
+		{`package p11; func _(t interface{}) { switch t.(type) {} }`, []string{
+			"file:", "func:t", "switch:",
+		}},
+		{`package p12; func _(t interface{}) { switch t := t; t.(type) {} }`, []string{
+			"file:", "func:t", "switch:t",
+		}},
+		{`package p13; func _(t interface{}) { switch x := t.(type) { case int: _ = x } }`, []string{
+			"file:", "func:t", "switch:", "case:x", // x implicitly declared
+		}},
+		{`package p14; func _() { select{} }`, []string{
+			"file:", "func:",
+		}},
+		{`package p15; func _(c chan int) { select{ case <-c: } }`, []string{
+			"file:", "func:c", "select:",
+		}},
+		{`package p16; func _(c chan int) { select{ case i := <-c: x := i; _ = x} }`, []string{
+			"file:", "func:c", "select:i x",
+		}},
+		{`package p17; func _() { for{} }`, []string{
+			"file:", "func:", "for:", "block:",
+		}},
+		{`package p18; func _(n int) { for i := 0; i < n; i++ { _ = i } }`, []string{
+			"file:", "func:n", "for:i", "block:",
+		}},
+		{`package p19; func _(a []int) { for i := range a { _ = i} }`, []string{
+			"file:", "func:a", "for:i", "block:",
+		}},
+		{`package p20; var s int; func _(a []int) { for i, x := range a { s += x; _ = i } }`, []string{
+			"file:", "func:a", "for:i x", "block:",
+		}},
+	}
+
+	for _, test := range tests {
+		info := Info{Scopes: make(map[syntax.Node]*Scope)}
+		name := mustTypecheck(t, "ScopesInfo", test.src, &info)
+
+		// number of scopes must match
+		if len(info.Scopes) != len(test.scopes) {
+			t.Errorf("package %s: got %d scopes; want %d", name, len(info.Scopes), len(test.scopes))
+		}
+
+		// scope descriptions must match
+		for node, scope := range info.Scopes {
+			var kind string
+			switch node.(type) {
+			case *syntax.File:
+				kind = "file"
+			case *syntax.FuncType:
+				kind = "func"
+			case *syntax.BlockStmt:
+				kind = "block"
+			case *syntax.IfStmt:
+				kind = "if"
+			case *syntax.SwitchStmt:
+				kind = "switch"
+			case *syntax.SelectStmt:
+				kind = "select"
+			case *syntax.CaseClause:
+				kind = "case"
+			case *syntax.CommClause:
+				kind = "comm"
+			case *syntax.ForStmt:
+				kind = "for"
+			default:
+				kind = fmt.Sprintf("%T", node)
+			}
+
+			// look for matching scope description
+			desc := kind + ":" + strings.Join(scope.Names(), " ")
+			found := false
+			for _, d := range test.scopes {
+				if desc == d {
+					found = true
+					break
+				}
+			}
+			if !found {
+				t.Errorf("package %s: no matching scope found for %s", name, desc)
+			}
+		}
+	}
+}
+
+func TestInitOrderInfo(t *testing.T) {
+	var tests = []struct {
+		src   string
+		inits []string
+	}{
+		{`package p0; var (x = 1; y = x)`, []string{
+			"x = 1", "y = x",
+		}},
+		{`package p1; var (a = 1; b = 2; c = 3)`, []string{
+			"a = 1", "b = 2", "c = 3",
+		}},
+		{`package p2; var (a, b, c = 1, 2, 3)`, []string{
+			"a = 1", "b = 2", "c = 3",
+		}},
+		{`package p3; var _ = f(); func f() int { return 1 }`, []string{
+			"_ = f()", // blank var
+		}},
+		{`package p4; var (a = 0; x = y; y = z; z = 0)`, []string{
+			"a = 0", "z = 0", "y = z", "x = y",
+		}},
+		{`package p5; var (a, _ = m[0]; m map[int]string)`, []string{
+			"a, _ = m[0]", // blank var
+		}},
+		{`package p6; var a, b = f(); func f() (_, _ int) { return z, z }; var z = 0`, []string{
+			"z = 0", "a, b = f()",
+		}},
+		{`package p7; var (a = func() int { return b }(); b = 1)`, []string{
+			"b = 1", "a = (func() int literal)()",
+		}},
+		{`package p8; var (a, b = func() (_, _ int) { return c, c }(); c = 1)`, []string{
+			"c = 1", "a, b = (func() (_, _ int) literal)()",
+		}},
+		{`package p9; type T struct{}; func (T) m() int { _ = y; return 0 }; var x, y = T.m, 1`, []string{
+			"y = 1", "x = T.m",
+		}},
+		{`package p10; var (d = c + b; a = 0; b = 0; c = 0)`, []string{
+			"a = 0", "b = 0", "c = 0", "d = c + b",
+		}},
+		{`package p11; var (a = e + c; b = d + c; c = 0; d = 0; e = 0)`, []string{
+			"c = 0", "d = 0", "b = d + c", "e = 0", "a = e + c",
+		}},
+		// emit an initializer for n:1 initializations only once (not for each node
+		// on the lhs which may appear in different order in the dependency graph)
+		{`package p12; var (a = x; b = 0; x, y = m[0]; m map[int]int)`, []string{
+			"b = 0", "x, y = m[0]", "a = x",
+		}},
+		// test case from spec section on package initialization
+		{`package p12
+
+		var (
+			a = c + b
+			b = f()
+			c = f()
+			d = 3
+		)
+
+		func f() int {
+			d++
+			return d
+		}`, []string{
+			"d = 3", "b = f()", "c = f()", "a = c + b",
+		}},
+		// test case for issue 7131
+		{`package main
+
+		var counter int
+		func next() int { counter++; return counter }
+
+		var _ = makeOrder()
+		func makeOrder() []int { return []int{f, b, d, e, c, a} }
+
+		var a       = next()
+		var b, c    = next(), next()
+		var d, e, f = next(), next(), next()
+		`, []string{
+			"a = next()", "b = next()", "c = next()", "d = next()", "e = next()", "f = next()", "_ = makeOrder()",
+		}},
+		// test case for issue 10709
+		{`package p13
+
+		var (
+		    v = t.m()
+		    t = makeT(0)
+		)
+
+		type T struct{}
+
+		func (T) m() int { return 0 }
+
+		func makeT(n int) T {
+		    if n > 0 {
+		        return makeT(n-1)
+		    }
+		    return T{}
+		}`, []string{
+			"t = makeT(0)", "v = t.m()",
+		}},
+		// test case for issue 10709: same as test before, but variable decls swapped
+		{`package p14
+
+		var (
+		    t = makeT(0)
+		    v = t.m()
+		)
+
+		type T struct{}
+
+		func (T) m() int { return 0 }
+
+		func makeT(n int) T {
+		    if n > 0 {
+		        return makeT(n-1)
+		    }
+		    return T{}
+		}`, []string{
+			"t = makeT(0)", "v = t.m()",
+		}},
+		// another candidate possibly causing problems with issue 10709
+		{`package p15
+
+		var y1 = f1()
+
+		func f1() int { return g1() }
+		func g1() int { f1(); return x1 }
+
+		var x1 = 0
+
+		var y2 = f2()
+
+		func f2() int { return g2() }
+		func g2() int { return x2 }
+
+		var x2 = 0`, []string{
+			"x1 = 0", "y1 = f1()", "x2 = 0", "y2 = f2()",
+		}},
+	}
+
+	for _, test := range tests {
+		info := Info{}
+		name := mustTypecheck(t, "InitOrderInfo", test.src, &info)
+
+		// number of initializers must match
+		if len(info.InitOrder) != len(test.inits) {
+			t.Errorf("package %s: got %d initializers; want %d", name, len(info.InitOrder), len(test.inits))
+			continue
+		}
+
+		// initializers must match
+		for i, want := range test.inits {
+			got := info.InitOrder[i].String()
+			if got != want {
+				t.Errorf("package %s, init %d: got %s; want %s", name, i, got, want)
+				continue
+			}
+		}
+	}
+}
+
+func TestMultiFileInitOrder(t *testing.T) {
+	mustParse := func(src string) *syntax.File {
+		f, err := parseSrc("main", src)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return f
+	}
+
+	fileA := mustParse(`package main; var a = 1`)
+	fileB := mustParse(`package main; var b = 2`)
+
+	// The initialization order must not depend on the parse
+	// order of the files, only on the presentation order to
+	// the type-checker.
+	for _, test := range []struct {
+		files []*syntax.File
+		want  string
+	}{
+		{[]*syntax.File{fileA, fileB}, "[a = 1 b = 2]"},
+		{[]*syntax.File{fileB, fileA}, "[b = 2 a = 1]"},
+	} {
+		var info Info
+		if _, err := new(Config).Check("main", test.files, &info); err != nil {
+			t.Fatal(err)
+		}
+		if got := fmt.Sprint(info.InitOrder); got != test.want {
+			t.Fatalf("got %s; want %s", got, test.want)
+		}
+	}
+}
+
+func TestFiles(t *testing.T) {
+	var sources = []string{
+		"package p; type T struct{}; func (T) m1() {}",
+		"package p; func (T) m2() {}; var x interface{ m1(); m2() } = T{}",
+		"package p; func (T) m3() {}; var y interface{ m1(); m2(); m3() } = T{}",
+		"package p",
+	}
+
+	var conf Config
+	pkg := NewPackage("p", "p")
+	var info Info
+	check := NewChecker(&conf, pkg, &info)
+
+	for i, src := range sources {
+		filename := fmt.Sprintf("sources%d", i)
+		f, err := parseSrc(filename, src)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := check.Files([]*syntax.File{f}); err != nil {
+			t.Error(err)
+		}
+	}
+
+	// check InitOrder is [x y]
+	var vars []string
+	for _, init := range info.InitOrder {
+		for _, v := range init.Lhs {
+			vars = append(vars, v.Name())
+		}
+	}
+	if got, want := fmt.Sprint(vars), "[x y]"; got != want {
+		t.Errorf("InitOrder == %s, want %s", got, want)
+	}
+}
+
+type testImporter map[string]*Package
+
+func (m testImporter) Import(path string) (*Package, error) {
+	if pkg := m[path]; pkg != nil {
+		return pkg, nil
+	}
+	return nil, fmt.Errorf("package %q not found", path)
+}
+
+func TestSelection(t *testing.T) {
+	t.Skip("requires fixes around source positions")
+
+	selections := make(map[*syntax.SelectorExpr]*Selection)
+
+	imports := make(testImporter)
+	conf := Config{Importer: imports}
+	makePkg := func(path, src string) {
+		f, err := parseSrc(path+".go", src)
+		if err != nil {
+			t.Fatal(err)
+		}
+		pkg, err := conf.Check(path, []*syntax.File{f}, &Info{Selections: selections})
+		if err != nil {
+			t.Fatal(err)
+		}
+		imports[path] = pkg
+	}
+
+	const libSrc = `
+package lib
+type T float64
+const C T = 3
+var V T
+func F() {}
+func (T) M() {}
+`
+	const mainSrc = `
+package main
+import "lib"
+
+type A struct {
+	*B
+	C
+}
+
+type B struct {
+	b int
+}
+
+func (B) f(int)
+
+type C struct {
+	c int
+}
+
+func (C) g()
+func (*C) h()
+
+func main() {
+	// qualified identifiers
+	var _ lib.T
+        _ = lib.C
+        _ = lib.F
+        _ = lib.V
+	_ = lib.T.M
+
+	// fields
+	_ = A{}.B
+	_ = new(A).B
+
+	_ = A{}.C
+	_ = new(A).C
+
+	_ = A{}.b
+	_ = new(A).b
+
+	_ = A{}.c
+	_ = new(A).c
+
+	// methods
+        _ = A{}.f
+        _ = new(A).f
+        _ = A{}.g
+        _ = new(A).g
+        _ = new(A).h
+
+        _ = B{}.f
+        _ = new(B).f
+
+        _ = C{}.g
+        _ = new(C).g
+        _ = new(C).h
+
+	// method expressions
+        _ = A.f
+        _ = (*A).f
+        _ = B.f
+        _ = (*B).f
+}`
+
+	wantOut := map[string][2]string{
+		"lib.T.M": {"method expr (lib.T) M(lib.T)", ".[0]"},
+
+		"A{}.B":    {"field (main.A) B *main.B", ".[0]"},
+		"new(A).B": {"field (*main.A) B *main.B", "->[0]"},
+		"A{}.C":    {"field (main.A) C main.C", ".[1]"},
+		"new(A).C": {"field (*main.A) C main.C", "->[1]"},
+		"A{}.b":    {"field (main.A) b int", "->[0 0]"},
+		"new(A).b": {"field (*main.A) b int", "->[0 0]"},
+		"A{}.c":    {"field (main.A) c int", ".[1 0]"},
+		"new(A).c": {"field (*main.A) c int", "->[1 0]"},
+
+		"A{}.f":    {"method (main.A) f(int)", "->[0 0]"},
+		"new(A).f": {"method (*main.A) f(int)", "->[0 0]"},
+		"A{}.g":    {"method (main.A) g()", ".[1 0]"},
+		"new(A).g": {"method (*main.A) g()", "->[1 0]"},
+		"new(A).h": {"method (*main.A) h()", "->[1 1]"}, // TODO(gri) should this report .[1 1] ?
+		"B{}.f":    {"method (main.B) f(int)", ".[0]"},
+		"new(B).f": {"method (*main.B) f(int)", "->[0]"},
+		"C{}.g":    {"method (main.C) g()", ".[0]"},
+		"new(C).g": {"method (*main.C) g()", "->[0]"},
+		"new(C).h": {"method (*main.C) h()", "->[1]"}, // TODO(gri) should this report .[1] ?
+
+		"A.f":    {"method expr (main.A) f(main.A, int)", "->[0 0]"},
+		"(*A).f": {"method expr (*main.A) f(*main.A, int)", "->[0 0]"},
+		"B.f":    {"method expr (main.B) f(main.B, int)", ".[0]"},
+		"(*B).f": {"method expr (*main.B) f(*main.B, int)", "->[0]"},
+	}
+
+	makePkg("lib", libSrc)
+	makePkg("main", mainSrc)
+
+	for e, sel := range selections {
+		_ = sel.String() // assertion: must not panic
+
+		unimplemented()
+		_ = e
+		// start := fset.Position(e.Pos()).Offset
+		// end := fset.Position(e.End()).Offset
+		// syntax := mainSrc[start:end] // (all SelectorExprs are in main, not lib)
+
+		direct := "."
+		if sel.Indirect() {
+			direct = "->"
+		}
+		got := [2]string{
+			sel.String(),
+			fmt.Sprintf("%s%v", direct, sel.Index()),
+		}
+		unimplemented()
+		_ = got
+		// want := wantOut[syntax]
+		// if want != got {
+		// 	t.Errorf("%s: got %q; want %q", syntax, got, want)
+		// }
+		// delete(wantOut, syntax)
+
+		// We must explicitly assert properties of the
+		// Signature's receiver since it doesn't participate
+		// in Identical() or String().
+		sig, _ := sel.Type().(*Signature)
+		if sel.Kind() == MethodVal {
+			got := sig.Recv().Type()
+			want := sel.Recv()
+			if !Identical(got, want) {
+				unimplemented()
+				// t.Errorf("%s: Recv() = %s, want %s", syntax, got, want)
+			}
+		} else if sig != nil && sig.Recv() != nil {
+			t.Errorf("%s: signature has receiver %s", sig, sig.Recv().Type())
+		}
+	}
+	// Assert that all wantOut entries were used exactly once.
+	for syntax := range wantOut {
+		t.Errorf("no syntax.Selection found with syntax %q", syntax)
+	}
+}
+
+func TestIssue8518(t *testing.T) {
+	imports := make(testImporter)
+	conf := Config{
+		Error:    func(err error) { t.Log(err) }, // don't exit after first error
+		Importer: imports,
+	}
+	makePkg := func(path, src string) {
+		f, err := parseSrc(path, src)
+		if err != nil {
+			t.Fatal(err)
+		}
+		pkg, _ := conf.Check(path, []*syntax.File{f}, nil) // errors logged via conf.Error
+		imports[path] = pkg
+	}
+
+	const libSrc = `
+package a
+import "missing"
+const C1 = foo
+const C2 = missing.C
+`
+
+	const mainSrc = `
+package main
+import "a"
+var _ = a.C1
+var _ = a.C2
+`
+
+	makePkg("a", libSrc)
+	makePkg("main", mainSrc) // don't crash when type-checking this package
+}
+
+func TestLookupFieldOrMethod(t *testing.T) {
+	// Test cases assume a lookup of the form a.f or x.f, where a stands for an
+	// addressable value, and x for a non-addressable value (even though a variable
+	// for ease of test case writing).
+	var tests = []struct {
+		src      string
+		found    bool
+		index    []int
+		indirect bool
+	}{
+		// field lookups
+		{"var x T; type T struct{}", false, nil, false},
+		{"var x T; type T struct{ f int }", true, []int{0}, false},
+		{"var x T; type T struct{ a, b, f, c int }", true, []int{2}, false},
+
+		// method lookups
+		{"var a T; type T struct{}; func (T) f() {}", true, []int{0}, false},
+		{"var a *T; type T struct{}; func (T) f() {}", true, []int{0}, true},
+		{"var a T; type T struct{}; func (*T) f() {}", true, []int{0}, false},
+		{"var a *T; type T struct{}; func (*T) f() {}", true, []int{0}, true}, // TODO(gri) should this report indirect = false?
+
+		// collisions
+		{"type ( E1 struct{ f int }; E2 struct{ f int }; x struct{ E1; *E2 })", false, []int{1, 0}, false},
+		{"type ( E1 struct{ f int }; E2 struct{}; x struct{ E1; *E2 }); func (E2) f() {}", false, []int{1, 0}, false},
+
+		// outside methodset
+		// (*T).f method exists, but value of type T is not addressable
+		{"var x T; type T struct{}; func (*T) f() {}", false, nil, true},
+	}
+
+	for _, test := range tests {
+		pkg, err := pkgFor("test", "package p;"+test.src, nil)
+		if err != nil {
+			t.Errorf("%s: incorrect test case: %s", test.src, err)
+			continue
+		}
+
+		obj := pkg.Scope().Lookup("a")
+		if obj == nil {
+			if obj = pkg.Scope().Lookup("x"); obj == nil {
+				t.Errorf("%s: incorrect test case - no object a or x", test.src)
+				continue
+			}
+		}
+
+		f, index, indirect := LookupFieldOrMethod(obj.Type(), obj.Name() == "a", pkg, "f")
+		if (f != nil) != test.found {
+			if f == nil {
+				t.Errorf("%s: got no object; want one", test.src)
+			} else {
+				t.Errorf("%s: got object = %v; want none", test.src, f)
+			}
+		}
+		if !sameSlice(index, test.index) {
+			t.Errorf("%s: got index = %v; want %v", test.src, index, test.index)
+		}
+		if indirect != test.indirect {
+			t.Errorf("%s: got indirect = %v; want %v", test.src, indirect, test.indirect)
+		}
+	}
+}
+
+func sameSlice(a, b []int) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i, x := range a {
+		if x != b[i] {
+			return false
+		}
+	}
+	return true
+}
+
+// TestScopeLookupParent ensures that (*Scope).LookupParent returns
+// the correct result at various positions within the source.
+func TestScopeLookupParent(t *testing.T) {
+	imports := make(testImporter)
+	conf := Config{Importer: imports}
+	var info Info
+	makePkg := func(path, src string) {
+		f, err := parseSrc(path, src)
+		if err != nil {
+			t.Fatal(err)
+		}
+		imports[path], err = conf.Check(path, []*syntax.File{f}, &info)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	makePkg("lib", "package lib; var X int")
+	// Each /*name=kind:line*/ comment makes the test look up the
+	// name at that point and checks that it resolves to a decl of
+	// the specified kind and line number.  "undef" means undefined.
+	mainSrc := `
+/*lib=pkgname:5*/ /*X=var:1*/ /*Pi=const:8*/ /*T=typename:9*/ /*Y=var:10*/ /*F=func:12*/
+package main
+
+import "lib"
+import . "lib"
+
+const Pi = 3.1415
+type T struct{}
+var Y, _ = lib.X, X
+
+func F(){
+	const pi, e = 3.1415, /*pi=undef*/ 2.71828 /*pi=const:13*/ /*e=const:13*/
+	type /*t=undef*/ t /*t=typename:14*/ *t
+	print(Y) /*Y=var:10*/
+	x, Y := Y, /*x=undef*/ /*Y=var:10*/ Pi /*x=var:16*/ /*Y=var:16*/ ; _ = x; _ = Y
+	var F = /*F=func:12*/ F /*F=var:17*/ ; _ = F
+
+	var a []int
+	for i, x := range /*i=undef*/ /*x=var:16*/ a /*i=var:20*/ /*x=var:20*/ { _ = i; _ = x }
+
+	var i interface{}
+	switch y := i.(type) { /*y=undef*/
+	case /*y=undef*/ int /*y=var:23*/ :
+	case float32, /*y=undef*/ float64 /*y=var:23*/ :
+	default /*y=var:23*/:
+		println(y)
+	}
+	/*y=undef*/
+
+        switch int := i.(type) {
+        case /*int=typename:0*/ int /*int=var:31*/ :
+        	println(int)
+        default /*int=var:31*/ :
+        }
+}
+/*main=undef*/
+`
+
+	info.Uses = make(map[*syntax.Name]Object)
+	makePkg("main", mainSrc)
+	mainScope := imports["main"].Scope()
+
+	rx := regexp.MustCompile(`^/\*(\w*)=([\w:]*)\*/$`)
+
+	base := syntax.NewFileBase("main")
+	syntax.CommentsDo(strings.NewReader(mainSrc), func(line, col uint, text string) {
+		pos := syntax.MakePos(base, line, col)
+
+		// Syntax errors are not comments.
+		if text[0] != '/' {
+			t.Errorf("%s: %s", pos, text)
+			return
+		}
+
+		// Parse the assertion in the comment.
+		m := rx.FindStringSubmatch(text)
+		if m == nil {
+			t.Errorf("%s: bad comment: %s", pos, text)
+			return
+		}
+		name, want := m[1], m[2]
+
+		// Look up the name in the innermost enclosing scope.
+		inner := mainScope.Innermost(pos)
+		if inner == nil {
+			t.Errorf("%s: at %s: can't find innermost scope", pos, text)
+			return
+		}
+		got := "undef"
+		if _, obj := inner.LookupParent(name, pos); obj != nil {
+			kind := strings.ToLower(strings.TrimPrefix(reflect.TypeOf(obj).String(), "*types2."))
+			got = fmt.Sprintf("%s:%d", kind, obj.Pos().Line())
+		}
+		if got != want {
+			t.Errorf("%s: at %s: %s resolved to %s, want %s", pos, text, name, got, want)
+		}
+	})
+
+	// Check that for each referring identifier,
+	// a lookup of its name on the innermost
+	// enclosing scope returns the correct object.
+
+	for id, wantObj := range info.Uses {
+		inner := mainScope.Innermost(id.Pos())
+		if inner == nil {
+			t.Errorf("%s: can't find innermost scope enclosing %q", id.Pos(), id.Value)
+			continue
+		}
+
+		// Exclude selectors and qualified identifiers---lexical
+		// refs only.  (Ideally, we'd see if the AST parent is a
+		// SelectorExpr, but that requires PathEnclosingInterval
+		// from golang.org/x/tools/go/ast/astutil.)
+		if id.Value == "X" {
+			continue
+		}
+
+		_, gotObj := inner.LookupParent(id.Value, id.Pos())
+		if gotObj != wantObj {
+			t.Errorf("%s: got %v, want %v", id.Pos(), gotObj, wantObj)
+			continue
+		}
+	}
+}
+
+func TestIdentical_issue15173(t *testing.T) {
+	// Identical should allow nil arguments and be symmetric.
+	for _, test := range []struct {
+		x, y Type
+		want bool
+	}{
+		{Typ[Int], Typ[Int], true},
+		{Typ[Int], nil, false},
+		{nil, Typ[Int], false},
+		{nil, nil, true},
+	} {
+		if got := Identical(test.x, test.y); got != test.want {
+			t.Errorf("Identical(%v, %v) = %t", test.x, test.y, got)
+		}
+	}
+}
+
+func TestIssue15305(t *testing.T) {
+	const src = "package p; func f() int16; var _ = f(undef)"
+	f, err := parseSrc("issue15305.go", src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	conf := Config{
+		Error: func(err error) {}, // allow errors
+	}
+	info := &Info{
+		Types: make(map[syntax.Expr]TypeAndValue),
+	}
+	conf.Check("p", []*syntax.File{f}, info) // ignore result
+	for e, tv := range info.Types {
+		if _, ok := e.(*syntax.CallExpr); ok {
+			if tv.Type != Typ[Int16] {
+				t.Errorf("CallExpr has type %v, want int16", tv.Type)
+			}
+			return
+		}
+	}
+	t.Errorf("CallExpr has no type")
+}
+
+// TestCompositeLitTypes verifies that Info.Types registers the correct
+// types for composite literal expressions and composite literal type
+// expressions.
+func TestCompositeLitTypes(t *testing.T) {
+	for _, test := range []struct {
+		lit, typ string
+	}{
+		{`[16]byte{}`, `[16]byte`},
+		{`[...]byte{}`, `[0]byte`},                // test for issue #14092
+		{`[...]int{1, 2, 3}`, `[3]int`},           // test for issue #14092
+		{`[...]int{90: 0, 98: 1, 2}`, `[100]int`}, // test for issue #14092
+		{`[]int{}`, `[]int`},
+		{`map[string]bool{"foo": true}`, `map[string]bool`},
+		{`struct{}{}`, `struct{}`},
+		{`struct{x, y int; z complex128}{}`, `struct{x int; y int; z complex128}`},
+	} {
+		f, err := parseSrc(test.lit, "package p; var _ = "+test.lit)
+		if err != nil {
+			t.Fatalf("%s: %v", test.lit, err)
+		}
+
+		info := &Info{
+			Types: make(map[syntax.Expr]TypeAndValue),
+		}
+		if _, err = new(Config).Check("p", []*syntax.File{f}, info); err != nil {
+			t.Fatalf("%s: %v", test.lit, err)
+		}
+
+		cmptype := func(x syntax.Expr, want string) {
+			tv, ok := info.Types[x]
+			if !ok {
+				t.Errorf("%s: no Types entry found", test.lit)
+				return
+			}
+			if tv.Type == nil {
+				t.Errorf("%s: type is nil", test.lit)
+				return
+			}
+			if got := tv.Type.String(); got != want {
+				t.Errorf("%s: got %v, want %s", test.lit, got, want)
+			}
+		}
+
+		// test type of composite literal expression
+		rhs := f.DeclList[0].(*syntax.VarDecl).Values
+		cmptype(rhs, test.typ)
+
+		// test type of composite literal type expression
+		cmptype(rhs.(*syntax.CompositeLit).Type, test.typ)
+	}
+}
+
+// TestObjectParents verifies that objects have parent scopes or not
+// as specified by the Object interface.
+func TestObjectParents(t *testing.T) {
+	const src = `
+package p
+
+const C = 0
+
+type T1 struct {
+	a, b int
+	T2
+}
+
+type T2 interface {
+	im1()
+	im2()
+}
+
+func (T1) m1() {}
+func (*T1) m2() {}
+
+func f(x int) { y := x; print(y) }
+`
+
+	f, err := parseSrc("src", src)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	info := &Info{
+		Defs: make(map[*syntax.Name]Object),
+	}
+	if _, err = new(Config).Check("p", []*syntax.File{f}, info); err != nil {
+		t.Fatal(err)
+	}
+
+	for ident, obj := range info.Defs {
+		if obj == nil {
+			// only package names and implicit vars have a nil object
+			// (in this test we only need to handle the package name)
+			if ident.Value != "p" {
+				t.Errorf("%v has nil object", ident)
+			}
+			continue
+		}
+
+		// struct fields, type-associated and interface methods
+		// have no parent scope
+		wantParent := true
+		switch obj := obj.(type) {
+		case *Var:
+			if obj.IsField() {
+				wantParent = false
+			}
+		case *Func:
+			if obj.Type().(*Signature).Recv() != nil { // method
+				wantParent = false
+			}
+		}
+
+		gotParent := obj.Parent() != nil
+		switch {
+		case gotParent && !wantParent:
+			t.Errorf("%v: want no parent, got %s", ident, obj.Parent())
+		case !gotParent && wantParent:
+			t.Errorf("%v: no parent found", ident)
+		}
+	}
+}
+
+// TestFailedImport tests that we don't get follow-on errors
+// elsewhere in a package due to failing to import a package.
+func TestFailedImport(t *testing.T) {
+	testenv.MustHaveGoBuild(t)
+
+	const src = `
+package p
+
+import foo "go/types/thisdirectorymustnotexistotherwisethistestmayfail/foo" // should only see an error here
+
+const c = foo.C
+type T = foo.T
+var v T = c
+func f(x T) T { return foo.F(x) }
+`
+	f, err := parseSrc("src", src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	files := []*syntax.File{f}
+
+	// type-check using all possible importers
+	for _, compiler := range []string{"gc", "gccgo", "source"} {
+		errcount := 0
+		conf := Config{
+			Error: func(err error) {
+				// we should only see the import error
+				if errcount > 0 || !strings.Contains(err.Error(), "could not import") {
+					t.Errorf("for %s importer, got unexpected error: %v", compiler, err)
+				}
+				errcount++
+			},
+			//Importer: importer.For(compiler, nil),
+		}
+
+		info := &Info{
+			Uses: make(map[*syntax.Name]Object),
+		}
+		pkg, _ := conf.Check("p", files, info)
+		if pkg == nil {
+			t.Errorf("for %s importer, type-checking failed to return a package", compiler)
+			continue
+		}
+
+		imports := pkg.Imports()
+		if len(imports) != 1 {
+			t.Errorf("for %s importer, got %d imports, want 1", compiler, len(imports))
+			continue
+		}
+		imp := imports[0]
+		if imp.Name() != "foo" {
+			t.Errorf(`for %s importer, got %q, want "foo"`, compiler, imp.Name())
+			continue
+		}
+
+		// verify that all uses of foo refer to the imported package foo (imp)
+		for ident, obj := range info.Uses {
+			if ident.Value == "foo" {
+				if obj, ok := obj.(*PkgName); ok {
+					if obj.Imported() != imp {
+						t.Errorf("%s resolved to %v; want %v", ident.Value, obj.Imported(), imp)
+					}
+				} else {
+					t.Errorf("%s resolved to %v; want package name", ident.Value, obj)
+				}
+			}
+		}
+	}
+}
diff --git a/src/cmd/compile/internal/types2/assignments.go b/src/cmd/compile/internal/types2/assignments.go
new file mode 100644
index 0000000000..93d3255686
--- /dev/null
+++ b/src/cmd/compile/internal/types2/assignments.go
@@ -0,0 +1,359 @@
+// UNREVIEWED
+// Copyright 2013 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.
+
+// This file implements initialization and assignment checks.
+
+package types2
+
+import "cmd/compile/internal/syntax"
+
+// assignment reports whether x can be assigned to a variable of type T,
+// if necessary by attempting to convert untyped values to the appropriate
+// type. context describes the context in which the assignment takes place.
+// Use T == nil to indicate assignment to an untyped blank identifier.
+// x.mode is set to invalid if the assignment failed.
+func (check *Checker) assignment(x *operand, T Type, context string) {
+	check.singleValue(x)
+
+	switch x.mode {
+	case invalid:
+		return // error reported before
+	case constant_, variable, mapindex, value, commaok, commaerr:
+		// ok
+	default:
+		// we may get here because of other problems (issue #39634, crash 12)
+		check.errorf(x, "cannot assign %s to %s in %s", x, T, context)
+		return
+	}
+
+	if isUntyped(x.typ) {
+		target := T
+		// spec: "If an untyped constant is assigned to a variable of interface
+		// type or the blank identifier, the constant is first converted to type
+		// bool, rune, int, float64, complex128 or string respectively, depending
+		// on whether the value is a boolean, rune, integer, floating-point, complex,
+		// or string constant."
+		if T == nil || IsInterface(T) {
+			if T == nil && x.typ == Typ[UntypedNil] {
+				check.errorf(x, "use of untyped nil in %s", context)
+				x.mode = invalid
+				return
+			}
+			target = Default(x.typ)
+		}
+		check.convertUntyped(x, target)
+		if x.mode == invalid {
+			return
+		}
+	}
+	// x.typ is typed
+
+	// A generic (non-instantiated) function value cannot be assigned to a variable.
+	if sig := x.typ.Signature(); sig != nil && len(sig.tparams) > 0 {
+		check.errorf(x, "cannot use generic function %s without instantiation in %s", x, context)
+	}
+
+	// spec: "If a left-hand side is the blank identifier, any typed or
+	// non-constant value except for the predeclared identifier nil may
+	// be assigned to it."
+	if T == nil {
+		return
+	}
+
+	if reason := ""; !x.assignableTo(check, T, &reason) {
+		if reason != "" {
+			check.errorf(x, "cannot use %s as %s value in %s: %s", x, T, context, reason)
+		} else {
+			check.errorf(x, "cannot use %s as %s value in %s", x, T, context)
+		}
+		x.mode = invalid
+	}
+}
+
+func (check *Checker) initConst(lhs *Const, x *operand) {
+	if x.mode == invalid || x.typ == Typ[Invalid] || lhs.typ == Typ[Invalid] {
+		if lhs.typ == nil {
+			lhs.typ = Typ[Invalid]
+		}
+		return
+	}
+
+	// rhs must be a constant
+	if x.mode != constant_ {
+		check.errorf(x, "%s is not constant", x)
+		if lhs.typ == nil {
+			lhs.typ = Typ[Invalid]
+		}
+		return
+	}
+	assert(isConstType(x.typ))
+
+	// If the lhs doesn't have a type yet, use the type of x.
+	if lhs.typ == nil {
+		lhs.typ = x.typ
+	}
+
+	check.assignment(x, lhs.typ, "constant declaration")
+	if x.mode == invalid {
+		return
+	}
+
+	lhs.val = x.val
+}
+
+func (check *Checker) initVar(lhs *Var, x *operand, context string) Type {
+	if x.mode == invalid || x.typ == Typ[Invalid] || lhs.typ == Typ[Invalid] {
+		if lhs.typ == nil {
+			lhs.typ = Typ[Invalid]
+		}
+		return nil
+	}
+
+	// If the lhs doesn't have a type yet, use the type of x.
+	if lhs.typ == nil {
+		typ := x.typ
+		if isUntyped(typ) {
+			// convert untyped types to default types
+			if typ == Typ[UntypedNil] {
+				check.errorf(x, "use of untyped nil in %s", context)
+				lhs.typ = Typ[Invalid]
+				return nil
+			}
+			typ = Default(typ)
+		}
+		lhs.typ = typ
+	}
+
+	check.assignment(x, lhs.typ, context)
+	if x.mode == invalid {
+		return nil
+	}
+
+	return x.typ
+}
+
+func (check *Checker) assignVar(lhs syntax.Expr, x *operand) Type {
+	if x.mode == invalid || x.typ == Typ[Invalid] {
+		check.useLHS(lhs)
+		return nil
+	}
+
+	// Determine if the lhs is a (possibly parenthesized) identifier.
+	ident, _ := unparen(lhs).(*syntax.Name)
+
+	// Don't evaluate lhs if it is the blank identifier.
+	if ident != nil && ident.Value == "_" {
+		check.recordDef(ident, nil)
+		check.assignment(x, nil, "assignment to _ identifier")
+		if x.mode == invalid {
+			return nil
+		}
+		return x.typ
+	}
+
+	// If the lhs is an identifier denoting a variable v, this assignment
+	// is not a 'use' of v. Remember current value of v.used and restore
+	// after evaluating the lhs via check.expr.
+	var v *Var
+	var v_used bool
+	if ident != nil {
+		if obj := check.lookup(ident.Value); obj != nil {
+			// It's ok to mark non-local variables, but ignore variables
+			// from other packages to avoid potential race conditions with
+			// dot-imported variables.
+			if w, _ := obj.(*Var); w != nil && w.pkg == check.pkg {
+				v = w
+				v_used = v.used
+			}
+		}
+	}
+
+	var z operand
+	check.expr(&z, lhs)
+	if v != nil {
+		v.used = v_used // restore v.used
+	}
+
+	if z.mode == invalid || z.typ == Typ[Invalid] {
+		return nil
+	}
+
+	// spec: "Each left-hand side operand must be addressable, a map index
+	// expression, or the blank identifier. Operands may be parenthesized."
+	switch z.mode {
+	case invalid:
+		return nil
+	case variable, mapindex:
+		// ok
+	default:
+		if sel, ok := z.expr.(*syntax.SelectorExpr); ok {
+			var op operand
+			check.expr(&op, sel.X)
+			if op.mode == mapindex {
+				check.errorf(&z, "cannot assign to struct field %s in map", ExprString(z.expr))
+				return nil
+			}
+		}
+		check.errorf(&z, "cannot assign to %s", &z)
+		return nil
+	}
+
+	check.assignment(x, z.typ, "assignment")
+	if x.mode == invalid {
+		return nil
+	}
+
+	return x.typ
+}
+
+// If returnPos is valid, initVars is called to type-check the assignment of
+// return expressions, and returnPos is the position of the return statement.
+func (check *Checker) initVars(lhs []*Var, orig_rhs []syntax.Expr, returnPos syntax.Pos) {
+	rhs, commaOk := check.exprList(orig_rhs, len(lhs) == 2 && !returnPos.IsKnown())
+
+	if len(lhs) != len(rhs) {
+		// invalidate lhs
+		for _, obj := range lhs {
+			if obj.typ == nil {
+				obj.typ = Typ[Invalid]
+			}
+		}
+		// don't report an error if we already reported one
+		for _, x := range rhs {
+			if x.mode == invalid {
+				return
+			}
+		}
+		if returnPos.IsKnown() {
+			check.errorf(returnPos, "wrong number of return values (want %d, got %d)", len(lhs), len(rhs))
+			return
+		}
+		check.errorf(rhs[0], "cannot initialize %d variables with %d values", len(lhs), len(rhs))
+		return
+	}
+
+	context := "assignment"
+	if returnPos.IsKnown() {
+		context = "return statement"
+	}
+
+	if commaOk {
+		var a [2]Type
+		for i := range a {
+			a[i] = check.initVar(lhs[i], rhs[i], context)
+		}
+		check.recordCommaOkTypes(orig_rhs[0], a)
+		return
+	}
+
+	for i, lhs := range lhs {
+		check.initVar(lhs, rhs[i], context)
+	}
+}
+
+func (check *Checker) assignVars(lhs, orig_rhs []syntax.Expr) {
+	rhs, commaOk := check.exprList(orig_rhs, len(lhs) == 2)
+
+	if len(lhs) != len(rhs) {
+		check.useLHS(lhs...)
+		// don't report an error if we already reported one
+		for _, x := range rhs {
+			if x.mode == invalid {
+				return
+			}
+		}
+		check.errorf(rhs[0], "cannot assign %d values to %d variables", len(rhs), len(lhs))
+		return
+	}
+
+	if commaOk {
+		var a [2]Type
+		for i := range a {
+			a[i] = check.assignVar(lhs[i], rhs[i])
+		}
+		check.recordCommaOkTypes(orig_rhs[0], a)
+		return
+	}
+
+	for i, lhs := range lhs {
+		check.assignVar(lhs, rhs[i])
+	}
+}
+
+// unpack unpacks a *syntax.ListExpr into a list of syntax.Expr.
+// Helper introduced for the go/types -> types2 port.
+// TODO(gri) Should find a more efficient solution that doesn't
+//           require introduction of a new slice for simple
+//           expressions.
+func unpackExpr(x syntax.Expr) []syntax.Expr {
+	if x, _ := x.(*syntax.ListExpr); x != nil {
+		return x.ElemList
+	}
+	if x != nil {
+		return []syntax.Expr{x}
+	}
+	return nil
+}
+
+func (check *Checker) shortVarDecl(pos syntax.Pos, lhs, rhs []syntax.Expr) {
+	top := len(check.delayed)
+	scope := check.scope
+
+	// collect lhs variables
+	var newVars []*Var
+	var lhsVars = make([]*Var, len(lhs))
+	for i, lhs := range lhs {
+		var obj *Var
+		if ident, _ := lhs.(*syntax.Name); ident != nil {
+			// Use the correct obj if the ident is redeclared. The
+			// variable's scope starts after the declaration; so we
+			// must use Scope.Lookup here and call Scope.Insert
+			// (via check.declare) later.
+			name := ident.Value
+			if alt := scope.Lookup(name); alt != nil {
+				// redeclared object must be a variable
+				if alt, _ := alt.(*Var); alt != nil {
+					obj = alt
+				} else {
+					check.errorf(lhs, "cannot assign to %s", lhs)
+				}
+				check.recordUse(ident, alt)
+			} else {
+				// declare new variable, possibly a blank (_) variable
+				obj = NewVar(ident.Pos(), check.pkg, name, nil)
+				if name != "_" {
+					newVars = append(newVars, obj)
+				}
+				check.recordDef(ident, obj)
+			}
+		} else {
+			check.useLHS(lhs)
+			check.errorf(lhs, "cannot declare %s", lhs)
+		}
+		if obj == nil {
+			obj = NewVar(lhs.Pos(), check.pkg, "_", nil) // dummy variable
+		}
+		lhsVars[i] = obj
+	}
+
+	check.initVars(lhsVars, rhs, nopos)
+
+	// process function literals in rhs expressions before scope changes
+	check.processDelayed(top)
+
+	// declare new variables
+	if len(newVars) > 0 {
+		// spec: "The scope of a constant or variable identifier declared inside
+		// a function begins at the end of the ConstSpec or VarSpec (ShortVarDecl
+		// for short variable declarations) and ends at the end of the innermost
+		// containing block."
+		scopePos := endPos(rhs[len(rhs)-1])
+		for _, obj := range newVars {
+			check.declare(scope, nil, obj, scopePos) // recordObject already called
+		}
+	} else {
+		check.softErrorf(pos, "no new variables on left side of :=")
+	}
+}
diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go
new file mode 100644
index 0000000000..c1706fd873
--- /dev/null
+++ b/src/cmd/compile/internal/types2/builtins.go
@@ -0,0 +1,777 @@
+// UNREVIEWED
+// Copyright 2012 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.
+
+// This file implements typechecking of builtin function calls.
+
+package types2
+
+import (
+	"cmd/compile/internal/syntax"
+	"go/constant"
+	"go/token"
+)
+
+// builtin type-checks a call to the built-in specified by id and
+// reports whether the call is valid, with *x holding the result;
+// but x.expr is not set. If the call is invalid, the result is
+// false, and *x is undefined.
+//
+func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (_ bool) {
+	// append is the only built-in that permits the use of ... for the last argument
+	bin := predeclaredFuncs[id]
+	if call.HasDots && id != _Append {
+		//check.invalidOpf(call.Ellipsis, "invalid use of ... with built-in %s", bin.name)
+		check.invalidOpf(call, "invalid use of ... with built-in %s", bin.name)
+		check.use(call.ArgList...)
+		return
+	}
+
+	// For len(x) and cap(x) we need to know if x contains any function calls or
+	// receive operations. Save/restore current setting and set hasCallOrRecv to
+	// false for the evaluation of x so that we can check it afterwards.
+	// Note: We must do this _before_ calling exprList because exprList evaluates
+	//       all arguments.
+	if id == _Len || id == _Cap {
+		defer func(b bool) {
+			check.hasCallOrRecv = b
+		}(check.hasCallOrRecv)
+		check.hasCallOrRecv = false
+	}
+
+	// determine actual arguments
+	var arg func(*operand, int) // TODO(gri) remove use of arg getter in favor of using xlist directly
+	nargs := len(call.ArgList)
+	switch id {
+	default:
+		// make argument getter
+		xlist, _ := check.exprList(call.ArgList, false)
+		arg = func(x *operand, i int) { *x = *xlist[i]; x.typ = expand(x.typ) }
+		nargs = len(xlist)
+		// evaluate first argument, if present
+		if nargs > 0 {
+			arg(x, 0)
+			if x.mode == invalid {
+				return
+			}
+		}
+	case _Make, _New, _Offsetof, _Trace:
+		// arguments require special handling
+	}
+
+	// check argument count
+	{
+		msg := ""
+		if nargs < bin.nargs {
+			msg = "not enough"
+		} else if !bin.variadic && nargs > bin.nargs {
+			msg = "too many"
+		}
+		if msg != "" {
+			check.invalidOpf(call, "%s arguments for %s (expected %d, found %d)", msg, call, bin.nargs, nargs)
+			return
+		}
+	}
+
+	switch id {
+	case _Append:
+		// append(s S, x ...T) S, where T is the element type of S
+		// spec: "The variadic function append appends zero or more values x to s of type
+		// S, which must be a slice type, and returns the resulting slice, also of type S.
+		// The values x are passed to a parameter of type ...T where T is the element type
+		// of S and the respective parameter passing rules apply."
+		S := x.typ
+		var T Type
+		if s := S.Slice(); s != nil {
+			T = s.elem
+		} else {
+			check.invalidArgf(x, "%s is not a slice", x)
+			return
+		}
+
+		// remember arguments that have been evaluated already
+		alist := []operand{*x}
+
+		// spec: "As a special case, append also accepts a first argument assignable
+		// to type []byte with a second argument of string type followed by ... .
+		// This form appends the bytes of the string.
+		if nargs == 2 && call.HasDots && x.assignableTo(check, NewSlice(universeByte), nil) {
+			arg(x, 1)
+			if x.mode == invalid {
+				return
+			}
+			if isString(x.typ) {
+				if check.Types != nil {
+					sig := makeSig(S, S, x.typ)
+					sig.variadic = true
+					check.recordBuiltinType(call.Fun, sig)
+				}
+				x.mode = value
+				x.typ = S
+				break
+			}
+			alist = append(alist, *x)
+			// fallthrough
+		}
+
+		// check general case by creating custom signature
+		sig := makeSig(S, S, NewSlice(T)) // []T required for variadic signature
+		sig.variadic = true
+		var xlist []*operand
+		// convert []operand to []*operand
+		for i := range alist {
+			xlist = append(xlist, &alist[i])
+		}
+		for i := len(alist); i < nargs; i++ {
+			var x operand
+			arg(&x, i)
+			xlist = append(xlist, &x)
+		}
+		check.arguments(call, sig, xlist) // discard result (we know the result type)
+		// ok to continue even if check.arguments reported errors
+
+		x.mode = value
+		x.typ = S
+		if check.Types != nil {
+			check.recordBuiltinType(call.Fun, sig)
+		}
+
+	case _Cap, _Len:
+		// cap(x)
+		// len(x)
+		mode := invalid
+		var typ Type
+		var val constant.Value
+		switch typ = implicitArrayDeref(optype(x.typ.Under())); t := typ.(type) {
+		case *Basic:
+			if isString(t) && id == _Len {
+				if x.mode == constant_ {
+					mode = constant_
+					val = constant.MakeInt64(int64(len(constant.StringVal(x.val))))
+				} else {
+					mode = value
+				}
+			}
+
+		case *Array:
+			mode = value
+			// spec: "The expressions len(s) and cap(s) are constants
+			// if the type of s is an array or pointer to an array and
+			// the expression s does not contain channel receives or
+			// function calls; in this case s is not evaluated."
+			if !check.hasCallOrRecv {
+				mode = constant_
+				if t.len >= 0 {
+					val = constant.MakeInt64(t.len)
+				} else {
+					val = constant.MakeUnknown()
+				}
+			}
+
+		case *Slice, *Chan:
+			mode = value
+
+		case *Map:
+			if id == _Len {
+				mode = value
+			}
+
+		case *Sum:
+			if t.is(func(t Type) bool {
+				switch t := t.Under().(type) {
+				case *Basic:
+					if isString(t) && id == _Len {
+						return true
+					}
+				case *Array, *Slice, *Chan:
+					return true
+				case *Map:
+					if id == _Len {
+						return true
+					}
+				}
+				return false
+			}) {
+				mode = value
+			}
+		}
+
+		if mode == invalid && typ != Typ[Invalid] {
+			check.invalidArgf(x, "%s for %s", x, bin.name)
+			return
+		}
+
+		x.mode = mode
+		x.typ = Typ[Int]
+		x.val = val
+		if check.Types != nil && mode != constant_ {
+			check.recordBuiltinType(call.Fun, makeSig(x.typ, typ))
+		}
+
+	case _Close:
+		// close(c)
+		c := x.typ.Chan()
+		if c == nil {
+			check.invalidArgf(x, "%s is not a channel", x)
+			return
+		}
+		if c.dir == RecvOnly {
+			check.invalidArgf(x, "%s must not be a receive-only channel", x)
+			return
+		}
+
+		x.mode = novalue
+		if check.Types != nil {
+			check.recordBuiltinType(call.Fun, makeSig(nil, c))
+		}
+
+	case _Complex:
+		// complex(x, y floatT) complexT
+		var y operand
+		arg(&y, 1)
+		if y.mode == invalid {
+			return
+		}
+
+		// convert or check untyped arguments
+		d := 0
+		if isUntyped(x.typ) {
+			d |= 1
+		}
+		if isUntyped(y.typ) {
+			d |= 2
+		}
+		switch d {
+		case 0:
+			// x and y are typed => nothing to do
+		case 1:
+			// only x is untyped => convert to type of y
+			check.convertUntyped(x, y.typ)
+		case 2:
+			// only y is untyped => convert to type of x
+			check.convertUntyped(&y, x.typ)
+		case 3:
+			// x and y are untyped =>
+			// 1) if both are constants, convert them to untyped
+			//    floating-point numbers if possible,
+			// 2) if one of them is not constant (possible because
+			//    it contains a shift that is yet untyped), convert
+			//    both of them to float64 since they must have the
+			//    same type to succeed (this will result in an error
+			//    because shifts of floats are not permitted)
+			if x.mode == constant_ && y.mode == constant_ {
+				toFloat := func(x *operand) {
+					if isNumeric(x.typ) && constant.Sign(constant.Imag(x.val)) == 0 {
+						x.typ = Typ[UntypedFloat]
+					}
+				}
+				toFloat(x)
+				toFloat(&y)
+			} else {
+				check.convertUntyped(x, Typ[Float64])
+				check.convertUntyped(&y, Typ[Float64])
+				// x and y should be invalid now, but be conservative
+				// and check below
+			}
+		}
+		if x.mode == invalid || y.mode == invalid {
+			return
+		}
+
+		// both argument types must be identical
+		if !check.identical(x.typ, y.typ) {
+			check.invalidArgf(x, "mismatched types %s and %s", x.typ, y.typ)
+			return
+		}
+
+		// the argument types must be of floating-point type
+		f := func(x Type) Type {
+			if t := x.Basic(); t != nil {
+				switch t.kind {
+				case Float32:
+					return Typ[Complex64]
+				case Float64:
+					return Typ[Complex128]
+				case UntypedFloat:
+					return Typ[UntypedComplex]
+				}
+			}
+			return nil
+		}
+		resTyp := check.applyTypeFunc(f, x.typ)
+		if resTyp == nil {
+			check.invalidArgf(x, "arguments have type %s, expected floating-point", x.typ)
+			return
+		}
+
+		// if both arguments are constants, the result is a constant
+		if x.mode == constant_ && y.mode == constant_ {
+			x.val = constant.BinaryOp(constant.ToFloat(x.val), token.ADD, constant.MakeImag(constant.ToFloat(y.val)))
+		} else {
+			x.mode = value
+		}
+
+		if check.Types != nil && x.mode != constant_ {
+			check.recordBuiltinType(call.Fun, makeSig(resTyp, x.typ, x.typ))
+		}
+
+		x.typ = resTyp
+
+	case _Copy:
+		// copy(x, y []T) int
+		var dst Type
+		if t := x.typ.Slice(); t != nil {
+			dst = t.elem
+		}
+
+		var y operand
+		arg(&y, 1)
+		if y.mode == invalid {
+			return
+		}
+		var src Type
+		switch t := optype(y.typ.Under()).(type) {
+		case *Basic:
+			if isString(y.typ) {
+				src = universeByte
+			}
+		case *Slice:
+			src = t.elem
+		}
+
+		if dst == nil || src == nil {
+			check.invalidArgf(x, "copy expects slice arguments; found %s and %s", x, &y)
+			return
+		}
+
+		if !check.identical(dst, src) {
+			check.invalidArgf(x, "arguments to copy %s and %s have different element types %s and %s", x, &y, dst, src)
+			return
+		}
+
+		if check.Types != nil {
+			check.recordBuiltinType(call.Fun, makeSig(Typ[Int], x.typ, y.typ))
+		}
+		x.mode = value
+		x.typ = Typ[Int]
+
+	case _Delete:
+		// delete(m, k)
+		m := x.typ.Map()
+		if m == nil {
+			check.invalidArgf(x, "%s is not a map", x)
+			return
+		}
+		arg(x, 1) // k
+		if x.mode == invalid {
+			return
+		}
+
+		if !x.assignableTo(check, m.key, nil) {
+			check.invalidArgf(x, "%s is not assignable to %s", x, m.key)
+			return
+		}
+
+		x.mode = novalue
+		if check.Types != nil {
+			check.recordBuiltinType(call.Fun, makeSig(nil, m, m.key))
+		}
+
+	case _Imag, _Real:
+		// imag(complexT) floatT
+		// real(complexT) floatT
+
+		// convert or check untyped argument
+		if isUntyped(x.typ) {
+			if x.mode == constant_ {
+				// an untyped constant number can always be considered
+				// as a complex constant
+				if isNumeric(x.typ) {
+					x.typ = Typ[UntypedComplex]
+				}
+			} else {
+				// an untyped non-constant argument may appear if
+				// it contains a (yet untyped non-constant) shift
+				// expression: convert it to complex128 which will
+				// result in an error (shift of complex value)
+				check.convertUntyped(x, Typ[Complex128])
+				// x should be invalid now, but be conservative and check
+				if x.mode == invalid {
+					return
+				}
+			}
+		}
+
+		// the argument must be of complex type
+		f := func(x Type) Type {
+			if t := x.Basic(); t != nil {
+				switch t.kind {
+				case Complex64:
+					return Typ[Float32]
+				case Complex128:
+					return Typ[Float64]
+				case UntypedComplex:
+					return Typ[UntypedFloat]
+				}
+			}
+			return nil
+		}
+		resTyp := check.applyTypeFunc(f, x.typ)
+		if resTyp == nil {
+			check.invalidArgf(x, "argument has type %s, expected complex type", x.typ)
+			return
+		}
+
+		// if the argument is a constant, the result is a constant
+		if x.mode == constant_ {
+			if id == _Real {
+				x.val = constant.Real(x.val)
+			} else {
+				x.val = constant.Imag(x.val)
+			}
+		} else {
+			x.mode = value
+		}
+
+		if check.Types != nil && x.mode != constant_ {
+			check.recordBuiltinType(call.Fun, makeSig(resTyp, x.typ))
+		}
+
+		x.typ = resTyp
+
+	case _Make:
+		// make(T, n)
+		// make(T, n, m)
+		// (no argument evaluated yet)
+		arg0 := call.ArgList[0]
+		T := check.varType(arg0)
+		if T == Typ[Invalid] {
+			return
+		}
+
+		min, max := -1, 10
+		var valid func(t Type) bool
+		valid = func(t Type) bool {
+			var m int
+			switch t := optype(t.Under()).(type) {
+			case *Slice:
+				m = 2
+			case *Map, *Chan:
+				m = 1
+			case *Sum:
+				return t.is(valid)
+			default:
+				return false
+			}
+			if m > min {
+				min = m
+			}
+			if m+1 < max {
+				max = m + 1
+			}
+			return true
+		}
+
+		if !valid(T) {
+			check.invalidArgf(arg0, "cannot make %s; type must be slice, map, or channel", arg0)
+			return
+		}
+		if nargs < min || max < nargs {
+			if min == max {
+				check.errorf(call, "%v expects %d arguments; found %d", call, min, nargs)
+			} else {
+				check.errorf(call, "%v expects %d or %d arguments; found %d", call, min, max, nargs)
+			}
+			return
+		}
+
+		types := []Type{T}
+		var sizes []int64 // constant integer arguments, if any
+		for _, arg := range call.ArgList[1:] {
+			typ, size := check.index(arg, -1) // ok to continue with typ == Typ[Invalid]
+			types = append(types, typ)
+			if size >= 0 {
+				sizes = append(sizes, size)
+			}
+		}
+		if len(sizes) == 2 && sizes[0] > sizes[1] {
+			check.invalidArgf(call.ArgList[1], "length and capacity swapped")
+			// safe to continue
+		}
+		x.mode = value
+		x.typ = T
+		if check.Types != nil {
+			check.recordBuiltinType(call.Fun, makeSig(x.typ, types...))
+		}
+
+	case _New:
+		// new(T)
+		// (no argument evaluated yet)
+		T := check.varType(call.ArgList[0])
+		if T == Typ[Invalid] {
+			return
+		}
+
+		x.mode = value
+		x.typ = &Pointer{base: T}
+		if check.Types != nil {
+			check.recordBuiltinType(call.Fun, makeSig(x.typ, T))
+		}
+
+	case _Panic:
+		// panic(x)
+		// record panic call if inside a function with result parameters
+		// (for use in Checker.isTerminating)
+		if check.sig != nil && check.sig.results.Len() > 0 {
+			// function has result parameters
+			p := check.isPanic
+			if p == nil {
+				// allocate lazily
+				p = make(map[*syntax.CallExpr]bool)
+				check.isPanic = p
+			}
+			p[call] = true
+		}
+
+		check.assignment(x, &emptyInterface, "argument to panic")
+		if x.mode == invalid {
+			return
+		}
+
+		x.mode = novalue
+		if check.Types != nil {
+			check.recordBuiltinType(call.Fun, makeSig(nil, &emptyInterface))
+		}
+
+	case _Print, _Println:
+		// print(x, y, ...)
+		// println(x, y, ...)
+		var params []Type
+		if nargs > 0 {
+			params = make([]Type, nargs)
+			for i := 0; i < nargs; i++ {
+				if i > 0 {
+					arg(x, i) // first argument already evaluated
+				}
+				check.assignment(x, nil, "argument to "+predeclaredFuncs[id].name)
+				if x.mode == invalid {
+					// TODO(gri) "use" all arguments?
+					return
+				}
+				params[i] = x.typ
+			}
+		}
+
+		x.mode = novalue
+		if check.Types != nil {
+			check.recordBuiltinType(call.Fun, makeSig(nil, params...))
+		}
+
+	case _Recover:
+		// recover() interface{}
+		x.mode = value
+		x.typ = &emptyInterface
+		if check.Types != nil {
+			check.recordBuiltinType(call.Fun, makeSig(x.typ))
+		}
+
+	case _Alignof:
+		// unsafe.Alignof(x T) uintptr
+		if x.typ.TypeParam() != nil {
+			check.invalidOpf(call, "unsafe.Alignof undefined for %s", x)
+			return
+		}
+		check.assignment(x, nil, "argument to unsafe.Alignof")
+		if x.mode == invalid {
+			return
+		}
+
+		x.mode = constant_
+		x.val = constant.MakeInt64(check.conf.alignof(x.typ))
+		x.typ = Typ[Uintptr]
+		// result is constant - no need to record signature
+
+	case _Offsetof:
+		// unsafe.Offsetof(x T) uintptr, where x must be a selector
+		// (no argument evaluated yet)
+		arg0 := call.ArgList[0]
+		selx, _ := unparen(arg0).(*syntax.SelectorExpr)
+		if selx == nil {
+			check.invalidArgf(arg0, "%s is not a selector expression", arg0)
+			check.use(arg0)
+			return
+		}
+
+		check.expr(x, selx.X)
+		if x.mode == invalid {
+			return
+		}
+
+		base := derefStructPtr(x.typ)
+		sel := selx.Sel.Value
+		obj, index, indirect := check.lookupFieldOrMethod(base, false, check.pkg, sel)
+		switch obj.(type) {
+		case nil:
+			check.invalidArgf(x, "%s has no single field %s", base, sel)
+			return
+		case *Func:
+			// TODO(gri) Using derefStructPtr may result in methods being found
+			// that don't actually exist. An error either way, but the error
+			// message is confusing. See: https://play.golang.org/p/al75v23kUy ,
+			// but go/types reports: "invalid argument: x.m is a method value".
+			check.invalidArgf(arg0, "%s is a method value", arg0)
+			return
+		}
+		if indirect {
+			check.invalidArgf(x, "field %s is embedded via a pointer in %s", sel, base)
+			return
+		}
+
+		// TODO(gri) Should we pass x.typ instead of base (and indirect report if derefStructPtr indirected)?
+		check.recordSelection(selx, FieldVal, base, obj, index, false)
+
+		offs := check.conf.offsetof(base, index)
+		x.mode = constant_
+		x.val = constant.MakeInt64(offs)
+		x.typ = Typ[Uintptr]
+		// result is constant - no need to record signature
+
+	case _Sizeof:
+		// unsafe.Sizeof(x T) uintptr
+		if x.typ.TypeParam() != nil {
+			check.invalidOpf(call, "unsafe.Sizeof undefined for %s", x)
+			return
+		}
+		check.assignment(x, nil, "argument to unsafe.Sizeof")
+		if x.mode == invalid {
+			return
+		}
+
+		x.mode = constant_
+		x.val = constant.MakeInt64(check.conf.sizeof(x.typ))
+		x.typ = Typ[Uintptr]
+		// result is constant - no need to record signature
+
+	case _Assert:
+		// assert(pred) causes a typechecker error if pred is false.
+		// The result of assert is the value of pred if there is no error.
+		// Note: assert is only available in self-test mode.
+		if x.mode != constant_ || !isBoolean(x.typ) {
+			check.invalidArgf(x, "%s is not a boolean constant", x)
+			return
+		}
+		if x.val.Kind() != constant.Bool {
+			check.errorf(x, "internal error: value of %s should be a boolean constant", x)
+			return
+		}
+		if !constant.BoolVal(x.val) {
+			check.errorf(call, "%v failed", call)
+			// compile-time assertion failure - safe to continue
+		}
+		// result is constant - no need to record signature
+
+	case _Trace:
+		// trace(x, y, z, ...) dumps the positions, expressions, and
+		// values of its arguments. The result of trace is the value
+		// of the first argument.
+		// Note: trace is only available in self-test mode.
+		// (no argument evaluated yet)
+		if nargs == 0 {
+			check.dump("%v: trace() without arguments", posFor(call))
+			x.mode = novalue
+			break
+		}
+		var t operand
+		x1 := x
+		for _, arg := range call.ArgList {
+			check.rawExpr(x1, arg, nil) // permit trace for types, e.g.: new(trace(T))
+			check.dump("%v: %s", posFor(x1), x1)
+			x1 = &t // use incoming x only for first argument
+		}
+		// trace is only available in test mode - no need to record signature
+
+	default:
+		unreachable()
+	}
+
+	return true
+}
+
+// applyTypeFunc applies f to x. If x is a type parameter,
+// the result is a type parameter constrained by an new
+// interface bound. The type bounds for that interface
+// are computed by applying f to each of the type bounds
+// of x. If any of these applications of f return nil,
+// applyTypeFunc returns nil.
+// If x is not a type parameter, the result is f(x).
+func (check *Checker) applyTypeFunc(f func(Type) Type, x Type) Type {
+	if tp := x.TypeParam(); tp != nil {
+		// Test if t satisfies the requirements for the argument
+		// type and collect possible result types at the same time.
+		var rtypes []Type
+		if !tp.Bound().is(func(x Type) bool {
+			if r := f(x); r != nil {
+				rtypes = append(rtypes, r)
+				return true
+			}
+			return false
+		}) {
+			return nil
+		}
+
+		// TODO(gri) Would it be ok to return just the one type
+		//           if len(rtypes) == 1? What about top-level
+		//           uses of real() where the result is used to
+		//           define type and initialize a variable?
+
+		// construct a suitable new type parameter
+		tpar := NewTypeName(nopos, nil /* = Universe pkg */, "<type parameter>", nil)
+		ptyp := check.NewTypeParam(tp.ptr, tpar, 0, &emptyInterface) // assigns type to tpar as a side-effect
+		tsum := NewSum(rtypes)
+		ptyp.bound = &Interface{types: tsum, allMethods: markComplete, allTypes: tsum}
+
+		return ptyp
+	}
+
+	return f(x)
+}
+
+// makeSig makes a signature for the given argument and result types.
+// Default types are used for untyped arguments, and res may be nil.
+func makeSig(res Type, args ...Type) *Signature {
+	list := make([]*Var, len(args))
+	for i, param := range args {
+		list[i] = NewVar(nopos, nil, "", Default(param))
+	}
+	params := NewTuple(list...)
+	var result *Tuple
+	if res != nil {
+		assert(!isUntyped(res))
+		result = NewTuple(NewVar(nopos, nil, "", res))
+	}
+	return &Signature{params: params, results: result}
+}
+
+// implicitArrayDeref returns A if typ is of the form *A and A is an array;
+// otherwise it returns typ.
+//
+func implicitArrayDeref(typ Type) Type {
+	if p, ok := typ.(*Pointer); ok {
+		if a := p.base.Array(); a != nil {
+			return a
+		}
+	}
+	return typ
+}
+
+// unparen returns e with any enclosing parentheses stripped.
+func unparen(e syntax.Expr) syntax.Expr {
+	for {
+		p, ok := e.(*syntax.ParenExpr)
+		if !ok {
+			return e
+		}
+		e = p.X
+	}
+}
diff --git a/src/cmd/compile/internal/types2/builtins_test.go b/src/cmd/compile/internal/types2/builtins_test.go
new file mode 100644
index 0000000000..9f737bc9bb
--- /dev/null
+++ b/src/cmd/compile/internal/types2/builtins_test.go
@@ -0,0 +1,219 @@
+// UNREVIEWED
+// Copyright 2013 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 types2_test
+
+import (
+	"cmd/compile/internal/syntax"
+	"fmt"
+	"testing"
+
+	. "cmd/compile/internal/types2"
+)
+
+var builtinCalls = []struct {
+	name, src, sig string
+}{
+	{"append", `var s []int; _ = append(s)`, `func([]int, ...int) []int`},
+	{"append", `var s []int; _ = append(s, 0)`, `func([]int, ...int) []int`},
+	{"append", `var s []int; _ = (append)(s, 0)`, `func([]int, ...int) []int`},
+	{"append", `var s []byte; _ = ((append))(s, 0)`, `func([]byte, ...byte) []byte`},
+	{"append", `var s []byte; _ = append(s, "foo"...)`, `func([]byte, string...) []byte`},
+	{"append", `type T []byte; var s T; var str string; _ = append(s, str...)`, `func(p.T, string...) p.T`},
+	{"append", `type T []byte; type U string; var s T; var str U; _ = append(s, str...)`, `func(p.T, p.U...) p.T`},
+
+	{"cap", `var s [10]int; _ = cap(s)`, `invalid type`},  // constant
+	{"cap", `var s [10]int; _ = cap(&s)`, `invalid type`}, // constant
+	{"cap", `var s []int64; _ = cap(s)`, `func([]int64) int`},
+	{"cap", `var c chan<-bool; _ = cap(c)`, `func(chan<- bool) int`},
+
+	{"len", `_ = len("foo")`, `invalid type`}, // constant
+	{"len", `var s string; _ = len(s)`, `func(string) int`},
+	{"len", `var s [10]int; _ = len(s)`, `invalid type`},  // constant
+	{"len", `var s [10]int; _ = len(&s)`, `invalid type`}, // constant
+	{"len", `var s []int64; _ = len(s)`, `func([]int64) int`},
+	{"len", `var c chan<-bool; _ = len(c)`, `func(chan<- bool) int`},
+	{"len", `var m map[string]float32; _ = len(m)`, `func(map[string]float32) int`},
+
+	{"close", `var c chan int; close(c)`, `func(chan int)`},
+	{"close", `var c chan<- chan string; close(c)`, `func(chan<- chan string)`},
+
+	{"complex", `_ = complex(1, 0)`, `invalid type`}, // constant
+	{"complex", `var re float32; _ = complex(re, 1.0)`, `func(float32, float32) complex64`},
+	{"complex", `var im float64; _ = complex(1, im)`, `func(float64, float64) complex128`},
+	{"complex", `type F32 float32; var re, im F32; _ = complex(re, im)`, `func(p.F32, p.F32) complex64`},
+	{"complex", `type F64 float64; var re, im F64; _ = complex(re, im)`, `func(p.F64, p.F64) complex128`},
+
+	{"copy", `var src, dst []byte; copy(dst, src)`, `func([]byte, []byte) int`},
+	{"copy", `type T [][]int; var src, dst T; _ = copy(dst, src)`, `func(p.T, p.T) int`},
+	{"copy", `var src string; var dst []byte; copy(dst, src)`, `func([]byte, string) int`},
+	{"copy", `type T string; type U []byte; var src T; var dst U; copy(dst, src)`, `func(p.U, p.T) int`},
+	{"copy", `var dst []byte; copy(dst, "hello")`, `func([]byte, string) int`},
+
+	{"delete", `var m map[string]bool; delete(m, "foo")`, `func(map[string]bool, string)`},
+	{"delete", `type (K string; V int); var m map[K]V; delete(m, "foo")`, `func(map[p.K]p.V, p.K)`},
+
+	{"imag", `_ = imag(1i)`, `invalid type`}, // constant
+	{"imag", `var c complex64; _ = imag(c)`, `func(complex64) float32`},
+	{"imag", `var c complex128; _ = imag(c)`, `func(complex128) float64`},
+	{"imag", `type C64 complex64; var c C64; _ = imag(c)`, `func(p.C64) float32`},
+	{"imag", `type C128 complex128; var c C128; _ = imag(c)`, `func(p.C128) float64`},
+
+	{"real", `_ = real(1i)`, `invalid type`}, // constant
+	{"real", `var c complex64; _ = real(c)`, `func(complex64) float32`},
+	{"real", `var c complex128; _ = real(c)`, `func(complex128) float64`},
+	{"real", `type C64 complex64; var c C64; _ = real(c)`, `func(p.C64) float32`},
+	{"real", `type C128 complex128; var c C128; _ = real(c)`, `func(p.C128) float64`},
+
+	{"make", `_ = make([]int, 10)`, `func([]int, int) []int`},
+	{"make", `type T []byte; _ = make(T, 10, 20)`, `func(p.T, int, int) p.T`},
+
+	// issue #37349
+	{"make", `              _ = make([]int, 0   )`, `func([]int, int) []int`},
+	{"make", `var l    int; _ = make([]int, l   )`, `func([]int, int) []int`},
+	{"make", `              _ = make([]int, 0, 0)`, `func([]int, int, int) []int`},
+	{"make", `var l    int; _ = make([]int, l, 0)`, `func([]int, int, int) []int`},
+	{"make", `var    c int; _ = make([]int, 0, c)`, `func([]int, int, int) []int`},
+	{"make", `var l, c int; _ = make([]int, l, c)`, `func([]int, int, int) []int`},
+
+	// issue #37393
+	{"make", `                _ = make([]int       , 0   )`, `func([]int, int) []int`},
+	{"make", `var l    byte ; _ = make([]int8      , l   )`, `func([]int8, byte) []int8`},
+	{"make", `                _ = make([]int16     , 0, 0)`, `func([]int16, int, int) []int16`},
+	{"make", `var l    int16; _ = make([]string    , l, 0)`, `func([]string, int16, int) []string`},
+	{"make", `var    c int32; _ = make([]float64   , 0, c)`, `func([]float64, int, int32) []float64`},
+	{"make", `var l, c uint ; _ = make([]complex128, l, c)`, `func([]complex128, uint, uint) []complex128`},
+
+	{"new", `_ = new(int)`, `func(int) *int`},
+	{"new", `type T struct{}; _ = new(T)`, `func(p.T) *p.T`},
+
+	{"panic", `panic(0)`, `func(interface{})`},
+	{"panic", `panic("foo")`, `func(interface{})`},
+
+	{"print", `print()`, `func()`},
+	{"print", `print(0)`, `func(int)`},
+	{"print", `print(1, 2.0, "foo", true)`, `func(int, float64, string, bool)`},
+
+	{"println", `println()`, `func()`},
+	{"println", `println(0)`, `func(int)`},
+	{"println", `println(1, 2.0, "foo", true)`, `func(int, float64, string, bool)`},
+
+	{"recover", `recover()`, `func() interface{}`},
+	{"recover", `_ = recover()`, `func() interface{}`},
+
+	{"Alignof", `_ = unsafe.Alignof(0)`, `invalid type`},                 // constant
+	{"Alignof", `var x struct{}; _ = unsafe.Alignof(x)`, `invalid type`}, // constant
+
+	{"Offsetof", `var x struct{f bool}; _ = unsafe.Offsetof(x.f)`, `invalid type`},           // constant
+	{"Offsetof", `var x struct{_ int; f bool}; _ = unsafe.Offsetof((&x).f)`, `invalid type`}, // constant
+
+	{"Sizeof", `_ = unsafe.Sizeof(0)`, `invalid type`},                 // constant
+	{"Sizeof", `var x struct{}; _ = unsafe.Sizeof(x)`, `invalid type`}, // constant
+
+	{"assert", `assert(true)`, `invalid type`},                                    // constant
+	{"assert", `type B bool; const pred B = 1 < 2; assert(pred)`, `invalid type`}, // constant
+
+	// no tests for trace since it produces output as a side-effect
+}
+
+func TestBuiltinSignatures(t *testing.T) {
+	DefPredeclaredTestFuncs()
+
+	seen := map[string]bool{"trace": true} // no test for trace built-in; add it manually
+	for _, call := range builtinCalls {
+		testBuiltinSignature(t, call.name, call.src, call.sig)
+		seen[call.name] = true
+	}
+
+	// make sure we didn't miss one
+	for _, name := range Universe.Names() {
+		if _, ok := Universe.Lookup(name).(*Builtin); ok && !seen[name] {
+			t.Errorf("missing test for %s", name)
+		}
+	}
+	for _, name := range Unsafe.Scope().Names() {
+		if _, ok := Unsafe.Scope().Lookup(name).(*Builtin); ok && !seen[name] {
+			t.Errorf("missing test for unsafe.%s", name)
+		}
+	}
+}
+
+func testBuiltinSignature(t *testing.T, name, src0, want string) {
+	src := fmt.Sprintf(`package p; import "unsafe"; type _ unsafe.Pointer /* use unsafe */; func _() { %s }`, src0)
+	f, err := parseSrc("", src)
+	if err != nil {
+		t.Errorf("%s: %s", src0, err)
+		return
+	}
+
+	conf := Config{Importer: defaultImporter()}
+	uses := make(map[*syntax.Name]Object)
+	types := make(map[syntax.Expr]TypeAndValue)
+	_, err = conf.Check(f.PkgName.Value, []*syntax.File{f}, &Info{Uses: uses, Types: types})
+	if err != nil {
+		t.Errorf("%s: %s", src0, err)
+		return
+	}
+
+	// find called function
+	n := 0
+	var fun syntax.Expr
+	for x := range types {
+		if call, _ := x.(*syntax.CallExpr); call != nil {
+			fun = call.Fun
+			n++
+		}
+	}
+	if n != 1 {
+		t.Errorf("%s: got %d CallExprs; want 1", src0, n)
+		return
+	}
+
+	// check recorded types for fun and descendents (may be parenthesized)
+	for {
+		// the recorded type for the built-in must match the wanted signature
+		typ := types[fun].Type
+		if typ == nil {
+			t.Errorf("%s: no type recorded for %s", src0, ExprString(fun))
+			return
+		}
+		if got := typ.String(); got != want {
+			t.Errorf("%s: got type %s; want %s", src0, got, want)
+			return
+		}
+
+		// called function must be a (possibly parenthesized, qualified)
+		// identifier denoting the expected built-in
+		switch p := fun.(type) {
+		case *syntax.Name:
+			obj := uses[p]
+			if obj == nil {
+				t.Errorf("%s: no object found for %s", src0, p.Value)
+				return
+			}
+			bin, _ := obj.(*Builtin)
+			if bin == nil {
+				t.Errorf("%s: %s does not denote a built-in", src0, p.Value)
+				return
+			}
+			if bin.Name() != name {
+				t.Errorf("%s: got built-in %s; want %s", src0, bin.Name(), name)
+				return
+			}
+			return // we're done
+
+		case *syntax.ParenExpr:
+			fun = p.X // unpack
+
+		case *syntax.SelectorExpr:
+			// built-in from package unsafe - ignore details
+			return // we're done
+
+		default:
+			t.Errorf("%s: invalid function call", src0)
+			return
+		}
+	}
+}
diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
new file mode 100644
index 0000000000..a29096322a
--- /dev/null
+++ b/src/cmd/compile/internal/types2/call.go
@@ -0,0 +1,808 @@
+// UNREVIEWED
+// Copyright 2013 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.
+
+// This file implements typechecking of call and selector expressions.
+
+package types2
+
+import (
+	"cmd/compile/internal/syntax"
+	"strings"
+	"unicode"
+)
+
+// funcInst type-checks a function instantiaton inst and returns the result in x.
+// The operand x must be the evaluation of inst.X and its type must be a signature.
+func (check *Checker) funcInst(x *operand, inst *syntax.IndexExpr) {
+	args, ok := check.exprOrTypeList(unpackExpr(inst.Index))
+	if ok && len(args) > 0 && args[0].mode != typexpr {
+		check.errorf(args[0], "%s is not a type", args[0])
+		ok = false
+	}
+	if !ok {
+		x.mode = invalid
+		x.expr = inst
+		return
+	}
+
+	// check number of type arguments
+	n := len(args)
+	sig := x.typ.(*Signature)
+	if !check.conf.InferFromConstraints && n != len(sig.tparams) || n > len(sig.tparams) {
+		check.errorf(args[n-1], "got %d type arguments but want %d", n, len(sig.tparams))
+		x.mode = invalid
+		x.expr = inst
+		return
+	}
+
+	// collect types
+	targs := make([]Type, n)
+	poslist := make([]syntax.Pos, n)
+	for i, a := range args {
+		if a.mode != typexpr {
+			// error was reported earlier
+			x.mode = invalid
+			x.expr = inst
+			return
+		}
+		targs[i] = a.typ
+		poslist[i] = a.Pos()
+	}
+
+	// if we don't have enough type arguments, use constraint type inference
+	var inferred bool
+	if n < len(sig.tparams) {
+		var failed int
+		targs, failed = check.inferB(sig.tparams, targs)
+		if targs == nil {
+			// error was already reported
+			x.mode = invalid
+			x.expr = inst
+			return
+		}
+		if failed >= 0 {
+			// at least one type argument couldn't be inferred
+			assert(targs[failed] == nil)
+			tpar := sig.tparams[failed]
+			check.errorf(inst, "cannot infer %s (%s) (%s)", tpar.name, tpar.pos, targs)
+			x.mode = invalid
+			x.expr = inst
+			return
+		}
+		// all type arguments were inferred sucessfully
+		if debug {
+			for _, targ := range targs {
+				assert(targ != nil)
+			}
+		}
+		//check.dump("### inferred targs = %s", targs)
+		n = len(targs)
+		inferred = true
+	}
+	assert(n == len(sig.tparams))
+
+	// instantiate function signature
+	for i, typ := range targs {
+		// some positions may be missing if types are inferred
+		var pos syntax.Pos
+		if i < len(poslist) {
+			pos = poslist[i]
+		}
+		check.ordinaryType(pos, typ)
+	}
+	res := check.instantiate(x.Pos(), sig, targs, poslist).(*Signature)
+	assert(res.tparams == nil) // signature is not generic anymore
+	if inferred {
+		check.recordInferred(inst, targs, res)
+	}
+	x.typ = res
+	x.mode = value
+	x.expr = inst
+}
+
+func (check *Checker) call(x *operand, call *syntax.CallExpr) exprKind {
+	check.exprOrType(x, call.Fun)
+
+	switch x.mode {
+	case invalid:
+		check.use(call.ArgList...)
+		x.expr = call
+		return statement
+
+	case typexpr:
+		// conversion
+		T := x.typ
+		x.mode = invalid
+		switch n := len(call.ArgList); n {
+		case 0:
+			check.errorf(call, "missing argument in conversion to %s", T)
+		case 1:
+			check.expr(x, call.ArgList[0])
+			if x.mode != invalid {
+				if t := T.Interface(); t != nil {
+					check.completeInterface(nopos, t)
+					if t.IsConstraint() {
+						check.errorf(call, "cannot use interface %s in conversion (contains type list or is comparable)", T)
+						break
+					}
+				}
+				check.conversion(x, T)
+			}
+		default:
+			check.use(call.ArgList...)
+			check.errorf(call.ArgList[n-1], "too many arguments in conversion to %s", T)
+		}
+		x.expr = call
+		return conversion
+
+	case builtin:
+		id := x.id
+		if !check.builtin(x, call, id) {
+			x.mode = invalid
+		}
+		x.expr = call
+		// a non-constant result implies a function call
+		if x.mode != invalid && x.mode != constant_ {
+			check.hasCallOrRecv = true
+		}
+		return predeclaredFuncs[id].kind
+
+	default:
+		// function/method call
+		cgocall := x.mode == cgofunc
+
+		sig := x.typ.Signature()
+		if sig == nil {
+			check.invalidOpf(x, "cannot call non-function %s", x)
+			x.mode = invalid
+			x.expr = call
+			return statement
+		}
+
+		// evaluate arguments
+		args, ok := check.exprOrTypeList(call.ArgList)
+		if !ok {
+			x.mode = invalid
+			x.expr = call
+			return expression
+		}
+
+		sig = check.arguments(call, sig, args)
+
+		// determine result
+		switch sig.results.Len() {
+		case 0:
+			x.mode = novalue
+		case 1:
+			if cgocall {
+				x.mode = commaerr
+			} else {
+				x.mode = value
+			}
+			x.typ = sig.results.vars[0].typ // unpack tuple
+		default:
+			x.mode = value
+			x.typ = sig.results
+		}
+		x.expr = call
+		check.hasCallOrRecv = true
+
+		// if type inference failed, a parametrized result must be invalidated
+		// (operands cannot have a parametrized type)
+		if x.mode == value && len(sig.tparams) > 0 && isParameterized(sig.tparams, x.typ) {
+			x.mode = invalid
+		}
+
+		return statement
+	}
+}
+
+// exprOrTypeList returns a list of operands and reports an error if the
+// list contains a mix of values and types (ignoring invalid operands).
+// TODO(gri) Now we can split this into exprList and typeList.
+func (check *Checker) exprOrTypeList(elist []syntax.Expr) (xlist []*operand, ok bool) {
+	ok = true
+
+	switch len(elist) {
+	case 0:
+		// nothing to do
+
+	case 1:
+		// single (possibly comma-ok) value or type, or function returning multiple values
+		e := elist[0]
+		var x operand
+		check.multiExprOrType(&x, e)
+		if t, ok := x.typ.(*Tuple); ok && x.mode != invalid && x.mode != typexpr {
+			// multiple values
+			xlist = make([]*operand, t.Len())
+			for i, v := range t.vars {
+				xlist[i] = &operand{mode: value, expr: e, typ: v.typ}
+			}
+			break
+		}
+
+		check.instantiatedOperand(&x)
+
+		// exactly one (possibly invalid or comma-ok) value or type
+		xlist = []*operand{&x}
+
+	default:
+		// multiple (possibly invalid) values or types
+		xlist = make([]*operand, len(elist))
+		ntypes := 0
+		for i, e := range elist {
+			var x operand
+			check.exprOrType(&x, e)
+			xlist[i] = &x
+			switch x.mode {
+			case invalid:
+				ntypes = len(xlist) // make 'if' condition fail below (no additional error in this case)
+			case typexpr:
+				ntypes++
+				check.instantiatedOperand(&x)
+			}
+		}
+		if 0 < ntypes && ntypes < len(xlist) {
+			check.errorf(xlist[0], "mix of value and type expressions")
+			ok = false
+		}
+	}
+
+	return
+}
+
+func (check *Checker) exprList(elist []syntax.Expr, allowCommaOk bool) (xlist []*operand, commaOk bool) {
+	switch len(elist) {
+	case 0:
+		// nothing to do
+
+	case 1:
+		// single (possibly comma-ok) value, or function returning multiple values
+		e := elist[0]
+		var x operand
+		check.multiExpr(&x, e)
+		if t, ok := x.typ.(*Tuple); ok && x.mode != invalid {
+			// multiple values
+			xlist = make([]*operand, t.Len())
+			for i, v := range t.vars {
+				xlist[i] = &operand{mode: value, expr: e, typ: v.typ}
+			}
+			break
+		}
+
+		// exactly one (possibly invalid or comma-ok) value
+		xlist = []*operand{&x}
+		if allowCommaOk && (x.mode == mapindex || x.mode == commaok || x.mode == commaerr) {
+			x.mode = value
+			xlist = append(xlist, &operand{mode: value, expr: e, typ: Typ[UntypedBool]})
+			commaOk = true
+		}
+
+	default:
+		// multiple (possibly invalid) values
+		xlist = make([]*operand, len(elist))
+		for i, e := range elist {
+			var x operand
+			check.expr(&x, e)
+			xlist[i] = &x
+		}
+	}
+
+	return
+}
+
+func (check *Checker) arguments(call *syntax.CallExpr, sig *Signature, args []*operand) (rsig *Signature) {
+	rsig = sig
+
+	// TODO(gri) try to eliminate this extra verification loop
+	for _, a := range args {
+		switch a.mode {
+		case typexpr:
+			check.errorf(a, "%s used as value", a)
+			return
+		case invalid:
+			return
+		}
+	}
+
+	// Function call argument/parameter count requirements
+	//
+	//               | standard call    | dotdotdot call |
+	// --------------+------------------+----------------+
+	// standard func | nargs == npars   | invalid        |
+	// --------------+------------------+----------------+
+	// variadic func | nargs >= npars-1 | nargs == npars |
+	// --------------+------------------+----------------+
+
+	nargs := len(args)
+	npars := sig.params.Len()
+	ddd := call.HasDots
+
+	// set up parameters
+	sig_params := sig.params // adjusted for variadic functions (may be nil for empty parameter lists!)
+	adjusted := false        // indicates if sig_params is different from t.params
+	if sig.variadic {
+		if ddd {
+			// variadic_func(a, b, c...)
+			if len(call.ArgList) == 1 && nargs > 1 {
+				// f()... is not permitted if f() is multi-valued
+				//check.errorf(call.Ellipsis, "cannot use ... with %d-valued %s", nargs, call.ArgList[0])
+				check.errorf(call, "cannot use ... with %d-valued %s", nargs, call.ArgList[0])
+				return
+			}
+		} else {
+			// variadic_func(a, b, c)
+			if nargs >= npars-1 {
+				// Create custom parameters for arguments: keep
+				// the first npars-1 parameters and add one for
+				// each argument mapping to the ... parameter.
+				vars := make([]*Var, npars-1) // npars > 0 for variadic functions
+				copy(vars, sig.params.vars)
+				last := sig.params.vars[npars-1]
+				typ := last.typ.(*Slice).elem
+				for len(vars) < nargs {
+					vars = append(vars, NewParam(last.pos, last.pkg, last.name, typ))
+				}
+				sig_params = NewTuple(vars...) // possibly nil!
+				adjusted = true
+				npars = nargs
+			} else {
+				// nargs < npars-1
+				npars-- // for correct error message below
+			}
+		}
+	} else {
+		if ddd {
+			// standard_func(a, b, c...)
+			//check.errorf(call.Ellipsis, "cannot use ... in call to non-variadic %s", call.Fun)
+			check.errorf(call, "cannot use ... in call to non-variadic %s", call.Fun)
+			return
+		}
+		// standard_func(a, b, c)
+	}
+
+	// check argument count
+	switch {
+	case nargs < npars:
+		check.errorf(call, "not enough arguments in call to %s", call.Fun)
+		return
+	case nargs > npars:
+		check.errorf(args[npars], "too many arguments in call to %s", call.Fun) // report at first extra argument
+		return
+	}
+
+	// infer type arguments and instantiate signature if necessary
+	if len(sig.tparams) > 0 {
+		// TODO(gri) provide position information for targs so we can feed
+		//           it to the instantiate call for better error reporting
+		targs, failed := check.infer(sig.tparams, sig_params, args)
+		if targs == nil {
+			return // error already reported
+		}
+		if failed >= 0 {
+			// Some type arguments couldn't be inferred. Use
+			// bounds type inference to try to make progress.
+			if check.conf.InferFromConstraints {
+				targs, failed = check.inferB(sig.tparams, targs)
+				if targs == nil {
+					return // error already reported
+				}
+			}
+			if failed >= 0 {
+				// at least one type argument couldn't be inferred
+				assert(targs[failed] == nil)
+				tpar := sig.tparams[failed]
+				// TODO(gri) here we'd like to use the position of the call's ')'
+				check.errorf(call.Pos(), "cannot infer %s (%s) (%s)", tpar.name, tpar.pos, targs)
+				return
+			}
+		}
+		// all type arguments were inferred sucessfully
+		if debug {
+			for _, targ := range targs {
+				assert(targ != nil)
+			}
+		}
+		//check.dump("### inferred targs = %s", targs)
+
+		// compute result signature
+		rsig = check.instantiate(call.Pos(), sig, targs, nil).(*Signature)
+		assert(rsig.tparams == nil) // signature is not generic anymore
+		check.recordInferred(call, targs, rsig)
+
+		// Optimization: Only if the parameter list was adjusted do we
+		// need to compute it from the adjusted list; otherwise we can
+		// simply use the result signature's parameter list.
+		if adjusted {
+			sig_params = check.subst(call.Pos(), sig_params, makeSubstMap(sig.tparams, targs)).(*Tuple)
+		} else {
+			sig_params = rsig.params
+		}
+	}
+
+	// check arguments
+	for i, a := range args {
+		check.assignment(a, sig_params.vars[i].typ, "argument")
+	}
+
+	return
+}
+
+var cgoPrefixes = [...]string{
+	"_Ciconst_",
+	"_Cfconst_",
+	"_Csconst_",
+	"_Ctype_",
+	"_Cvar_", // actually a pointer to the var
+	"_Cfpvar_fp_",
+	"_Cfunc_",
+	"_Cmacro_", // function to evaluate the expanded expression
+}
+
+func (check *Checker) selector(x *operand, e *syntax.SelectorExpr) {
+	// these must be declared before the "goto Error" statements
+	var (
+		obj      Object
+		index    []int
+		indirect bool
+	)
+
+	sel := e.Sel.Value
+	// If the identifier refers to a package, handle everything here
+	// so we don't need a "package" mode for operands: package names
+	// can only appear in qualified identifiers which are mapped to
+	// selector expressions.
+	if ident, ok := e.X.(*syntax.Name); ok {
+		obj := check.lookup(ident.Value)
+		if pname, _ := obj.(*PkgName); pname != nil {
+			assert(pname.pkg == check.pkg)
+			check.recordUse(ident, pname)
+			pname.used = true
+			pkg := pname.imported
+
+			var exp Object
+			funcMode := value
+			if pkg.cgo {
+				// cgo special cases C.malloc: it's
+				// rewritten to _CMalloc and does not
+				// support two-result calls.
+				if sel == "malloc" {
+					sel = "_CMalloc"
+				} else {
+					funcMode = cgofunc
+				}
+				for _, prefix := range cgoPrefixes {
+					// cgo objects are part of the current package (in file
+					// _cgo_gotypes.go). Use regular lookup.
+					_, exp = check.scope.LookupParent(prefix+sel, check.pos)
+					if exp != nil {
+						break
+					}
+				}
+				if exp == nil {
+					check.errorf(e.Sel, "%s not declared by package C", sel)
+					goto Error
+				}
+				check.objDecl(exp, nil)
+			} else {
+				exp = pkg.scope.Lookup(sel)
+				if exp == nil {
+					if !pkg.fake {
+						check.errorf(e.Sel, "%s not declared by package %s", sel, pkg.name)
+					}
+					goto Error
+				}
+				if !exp.Exported() {
+					check.errorf(e.Sel, "%s not exported by package %s", sel, pkg.name)
+					// ok to continue
+				}
+			}
+			check.recordUse(e.Sel, exp)
+
+			// Simplified version of the code for *syntax.Names:
+			// - imported objects are always fully initialized
+			switch exp := exp.(type) {
+			case *Const:
+				assert(exp.Val() != nil)
+				x.mode = constant_
+				x.typ = exp.typ
+				x.val = exp.val
+			case *TypeName:
+				x.mode = typexpr
+				x.typ = exp.typ
+			case *Var:
+				x.mode = variable
+				x.typ = exp.typ
+				if pkg.cgo && strings.HasPrefix(exp.name, "_Cvar_") {
+					x.typ = x.typ.(*Pointer).base
+				}
+			case *Func:
+				x.mode = funcMode
+				x.typ = exp.typ
+				if pkg.cgo && strings.HasPrefix(exp.name, "_Cmacro_") {
+					x.mode = value
+					x.typ = x.typ.(*Signature).results.vars[0].typ
+				}
+			case *Builtin:
+				x.mode = builtin
+				x.typ = exp.typ
+				x.id = exp.id
+			default:
+				check.dump("%v: unexpected object %v", posFor(e.Sel), exp)
+				unreachable()
+			}
+			x.expr = e
+			return
+		}
+	}
+
+	check.exprOrType(x, e.X)
+	if x.mode == invalid {
+		goto Error
+	}
+
+	check.instantiatedOperand(x)
+
+	obj, index, indirect = check.lookupFieldOrMethod(x.typ, x.mode == variable, check.pkg, sel)
+	if obj == nil {
+		switch {
+		case index != nil:
+			// TODO(gri) should provide actual type where the conflict happens
+			check.errorf(e.Sel, "ambiguous selector %s.%s", x.expr, sel)
+		case indirect:
+			check.errorf(e.Sel, "cannot call pointer method %s on %s", sel, x.typ)
+		default:
+			var why string
+			if tpar := x.typ.TypeParam(); tpar != nil {
+				// Type parameter bounds don't specify fields, so don't mention "field".
+				switch obj := tpar.Bound().obj.(type) {
+				case nil:
+					why = check.sprintf("type bound for %s has no method %s", x.typ, sel)
+				case *TypeName:
+					why = check.sprintf("interface %s has no method %s", obj.name, sel)
+				}
+			} else {
+				why = check.sprintf("type %s has no field or method %s", x.typ, sel)
+			}
+
+			// Check if capitalization of sel matters and provide better error message in that case.
+			if len(sel) > 0 {
+				var changeCase string
+				if r := rune(sel[0]); unicode.IsUpper(r) {
+					changeCase = string(unicode.ToLower(r)) + sel[1:]
+				} else {
+					changeCase = string(unicode.ToUpper(r)) + sel[1:]
+				}
+				if obj, _, _ = check.lookupFieldOrMethod(x.typ, x.mode == variable, check.pkg, changeCase); obj != nil {
+					why += ", but does have " + changeCase
+				}
+			}
+
+			check.errorf(e.Sel, "%s.%s undefined (%s)", x.expr, sel, why)
+
+		}
+		goto Error
+	}
+
+	// methods may not have a fully set up signature yet
+	if m, _ := obj.(*Func); m != nil {
+		// check.dump("### found method %s", m)
+		check.objDecl(m, nil)
+		// If m has a parameterized receiver type, infer the type parameter
+		// values from the actual receiver provided and then substitute the
+		// type parameters in the signature accordingly.
+		// TODO(gri) factor this code out
+		sig := m.typ.(*Signature)
+		if len(sig.rparams) > 0 {
+			//check.dump("### recv typ = %s", x.typ)
+			//check.dump("### method = %s rparams = %s tparams = %s", m, sig.rparams, sig.tparams)
+			// The method may have a pointer receiver, but the actually provided receiver
+			// may be a (hopefully addressable) non-pointer value, or vice versa. Here we
+			// only care about inferring receiver type parameters; to make the inference
+			// work, match up pointer-ness of receiver and argument.
+			arg := x
+			if ptrRecv := isPointer(sig.recv.typ); ptrRecv != isPointer(arg.typ) {
+				copy := *arg
+				if ptrRecv {
+					copy.typ = NewPointer(arg.typ)
+				} else {
+					copy.typ = arg.typ.(*Pointer).base
+				}
+				arg = &copy
+			}
+			targs, failed := check.infer(sig.rparams, NewTuple(sig.recv), []*operand{arg})
+			//check.dump("### inferred targs = %s", targs)
+			if failed >= 0 {
+				// We may reach here if there were other errors (see issue #40056).
+				// check.infer will report a follow-up error.
+				// TODO(gri) avoid the follow-up error or provide better explanation.
+				goto Error
+			}
+			// Don't modify m. Instead - for now - make a copy of m and use that instead.
+			// (If we modify m, some tests will fail; possibly because the m is in use.)
+			// TODO(gri) investigate and provide a correct explanation here
+			copy := *m
+			copy.typ = check.subst(e.Pos(), m.typ, makeSubstMap(sig.rparams, targs))
+			obj = &copy
+		}
+		// TODO(gri) we also need to do substitution for parameterized interface methods
+		//           (this breaks code in testdata/linalg.go2 at the moment)
+		//           12/20/2019: Is this TODO still correct?
+	}
+
+	if x.mode == typexpr {
+		// method expression
+		m, _ := obj.(*Func)
+		if m == nil {
+			// TODO(gri) should check if capitalization of sel matters and provide better error message in that case
+			check.errorf(e.Sel, "%s.%s undefined (type %s has no method %s)", x.expr, sel, x.typ, sel)
+			goto Error
+		}
+
+		check.recordSelection(e, MethodExpr, x.typ, m, index, indirect)
+
+		// the receiver type becomes the type of the first function
+		// argument of the method expression's function type
+		var params []*Var
+		sig := m.typ.(*Signature)
+		if sig.params != nil {
+			params = sig.params.vars
+		}
+		x.mode = value
+		x.typ = &Signature{
+			tparams:  sig.tparams,
+			params:   NewTuple(append([]*Var{NewVar(nopos, check.pkg, "_", x.typ)}, params...)...),
+			results:  sig.results,
+			variadic: sig.variadic,
+		}
+
+		check.addDeclDep(m)
+
+	} else {
+		// regular selector
+		switch obj := obj.(type) {
+		case *Var:
+			check.recordSelection(e, FieldVal, x.typ, obj, index, indirect)
+			if x.mode == variable || indirect {
+				x.mode = variable
+			} else {
+				x.mode = value
+			}
+			x.typ = obj.typ
+
+		case *Func:
+			// TODO(gri) If we needed to take into account the receiver's
+			// addressability, should we report the type &(x.typ) instead?
+			check.recordSelection(e, MethodVal, x.typ, obj, index, indirect)
+
+			// TODO(gri) The verification pass below is disabled for now because
+			//           method sets don't match method lookup in some cases.
+			//           For instance, if we made a copy above when creating a
+			//           custom method for a parameterized received type, the
+			//           method set method doesn't match (no copy there). There
+			///          may be other situations.
+			disabled := true
+			if !disabled && debug {
+				// Verify that LookupFieldOrMethod and MethodSet.Lookup agree.
+				// TODO(gri) This only works because we call LookupFieldOrMethod
+				// _before_ calling NewMethodSet: LookupFieldOrMethod completes
+				// any incomplete interfaces so they are available to NewMethodSet
+				// (which assumes that interfaces have been completed already).
+				typ := x.typ
+				if x.mode == variable {
+					// If typ is not an (unnamed) pointer or an interface,
+					// use *typ instead, because the method set of *typ
+					// includes the methods of typ.
+					// Variables are addressable, so we can always take their
+					// address.
+					if _, ok := typ.(*Pointer); !ok && !IsInterface(typ) {
+						typ = &Pointer{base: typ}
+					}
+				}
+				// If we created a synthetic pointer type above, we will throw
+				// away the method set computed here after use.
+				// TODO(gri) Method set computation should probably always compute
+				// both, the value and the pointer receiver method set and represent
+				// them in a single structure.
+				// TODO(gri) Consider also using a method set cache for the lifetime
+				// of checker once we rely on MethodSet lookup instead of individual
+				// lookup.
+				mset := NewMethodSet(typ)
+				if m := mset.Lookup(check.pkg, sel); m == nil || m.obj != obj {
+					check.dump("%v: (%s).%v -> %s", posFor(e), typ, obj.name, m)
+					check.dump("%s\n", mset)
+					// Caution: MethodSets are supposed to be used externally
+					// only (after all interface types were completed). It's
+					// now possible that we get here incorrectly. Not urgent
+					// to fix since we only run this code in debug mode.
+					// TODO(gri) fix this eventually.
+					panic("method sets and lookup don't agree")
+				}
+			}
+
+			x.mode = value
+
+			// remove receiver
+			sig := *obj.typ.(*Signature)
+			sig.recv = nil
+			x.typ = &sig
+
+			check.addDeclDep(obj)
+
+		default:
+			unreachable()
+		}
+	}
+
+	// everything went well
+	x.expr = e
+	return
+
+Error:
+	x.mode = invalid
+	x.expr = e
+}
+
+// use type-checks each argument.
+// Useful to make sure expressions are evaluated
+// (and variables are "used") in the presence of other errors.
+// The arguments may be nil.
+// TODO(gri) make this accept a []syntax.Expr and use an unpack function when we have a ListExpr?
+func (check *Checker) use(arg ...syntax.Expr) {
+	var x operand
+	for _, e := range arg {
+		// Certain AST fields may legally be nil (e.g., the ast.SliceExpr.High field).
+		if e == nil {
+			continue
+		}
+		if l, _ := e.(*syntax.ListExpr); l != nil {
+			check.use(l.ElemList...)
+			continue
+		}
+		check.rawExpr(&x, e, nil)
+	}
+}
+
+// useLHS is like use, but doesn't "use" top-level identifiers.
+// It should be called instead of use if the arguments are
+// expressions on the lhs of an assignment.
+// The arguments must not be nil.
+func (check *Checker) useLHS(arg ...syntax.Expr) {
+	var x operand
+	for _, e := range arg {
+		// If the lhs is an identifier denoting a variable v, this assignment
+		// is not a 'use' of v. Remember current value of v.used and restore
+		// after evaluating the lhs via check.rawExpr.
+		var v *Var
+		var v_used bool
+		if ident, _ := unparen(e).(*syntax.Name); ident != nil {
+			// never type-check the blank name on the lhs
+			if ident.Value == "_" {
+				continue
+			}
+			if _, obj := check.scope.LookupParent(ident.Value, nopos); obj != nil {
+				// It's ok to mark non-local variables, but ignore variables
+				// from other packages to avoid potential race conditions with
+				// dot-imported variables.
+				if w, _ := obj.(*Var); w != nil && w.pkg == check.pkg {
+					v = w
+					v_used = v.used
+				}
+			}
+		}
+		check.rawExpr(&x, e, nil)
+		if v != nil {
+			v.used = v_used // restore v.used
+		}
+	}
+}
+
+// instantiatedOperand reports an error of x is an uninstantiated (generic) type and sets x.typ to Typ[Invalid].
+func (check *Checker) instantiatedOperand(x *operand) {
+	if x.mode == typexpr && isGeneric(x.typ) {
+		check.errorf(x, "cannot use generic type %s without instantiation", x.typ)
+		x.typ = Typ[Invalid]
+	}
+}
diff --git a/src/cmd/compile/internal/types2/check.go b/src/cmd/compile/internal/types2/check.go
new file mode 100644
index 0000000000..4504586545
--- /dev/null
+++ b/src/cmd/compile/internal/types2/check.go
@@ -0,0 +1,449 @@
+// UNREVIEWED
+// Copyright 2011 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.
+
+// This file implements the Check function, which drives type-checking.
+
+package types2
+
+import (
+	"cmd/compile/internal/syntax"
+	"errors"
+	"fmt"
+	"go/constant"
+)
+
+var nopos syntax.Pos
+
+// debugging/development support
+const debug = true // leave on during development
+
+// If forceStrict is set, the type-checker enforces additional
+// rules not specified by the Go 1 spec, but which will
+// catch guaranteed run-time errors if the respective
+// code is executed. In other words, programs passing in
+// strict mode are Go 1 compliant, but not all Go 1 programs
+// will pass in strict mode. The additional rules are:
+//
+// - A type assertion x.(T) where T is an interface type
+//   is invalid if any (statically known) method that exists
+//   for both x and T have different signatures.
+//
+const forceStrict = false
+
+// If methodTypeParamsOk is set, type parameters are
+// permitted in method declarations (in interfaces, too).
+// Generalization and experimental feature.
+const methodTypeParamsOk = true
+
+// exprInfo stores information about an untyped expression.
+type exprInfo struct {
+	isLhs bool // expression is lhs operand of a shift with delayed type-check
+	mode  operandMode
+	typ   *Basic
+	val   constant.Value // constant value; or nil (if not a constant)
+}
+
+// A context represents the context within which an object is type-checked.
+type context struct {
+	decl          *declInfo                 // package-level declaration whose init expression/function body is checked
+	scope         *Scope                    // top-most scope for lookups
+	pos           syntax.Pos                // if valid, identifiers are looked up as if at position pos (used by Eval)
+	iota          constant.Value            // value of iota in a constant declaration; nil otherwise
+	sig           *Signature                // function signature if inside a function; nil otherwise
+	isPanic       map[*syntax.CallExpr]bool // set of panic call expressions (used for termination check)
+	hasLabel      bool                      // set if a function makes use of labels (only ~1% of functions); unused outside functions
+	hasCallOrRecv bool                      // set if an expression contains a function call or channel receive operation
+}
+
+// lookup looks up name in the current context and returns the matching object, or nil.
+func (ctxt *context) lookup(name string) Object {
+	_, obj := ctxt.scope.LookupParent(name, ctxt.pos)
+	return obj
+}
+
+// An importKey identifies an imported package by import path and source directory
+// (directory containing the file containing the import). In practice, the directory
+// may always be the same, or may not matter. Given an (import path, directory), an
+// importer must always return the same package (but given two different import paths,
+// an importer may still return the same package by mapping them to the same package
+// paths).
+type importKey struct {
+	path, dir string
+}
+
+// A Checker maintains the state of the type checker.
+// It must be created with NewChecker.
+type Checker struct {
+	// package information
+	// (initialized by NewChecker, valid for the life-time of checker)
+	conf *Config
+	pkg  *Package
+	*Info
+	nextId uint64                      // unique Id for type parameters (first valid Id is 1)
+	objMap map[Object]*declInfo        // maps package-level objects and (non-interface) methods to declaration info
+	impMap map[importKey]*Package      // maps (import path, source directory) to (complete or fake) package
+	posMap map[*Interface][]syntax.Pos // maps interface types to lists of embedded interface positions
+	typMap map[string]*Named           // maps an instantiated named type hash to a *Named type
+	pkgCnt map[string]int              // counts number of imported packages with a given name (for better error messages)
+
+	// information collected during type-checking of a set of package files
+	// (initialized by Files, valid only for the duration of check.Files;
+	// maps and lists are allocated on demand)
+	files            []*syntax.File                     // package files
+	unusedDotImports map[*Scope]map[*Package]syntax.Pos // positions of unused dot-imported packages for each file scope
+
+	firstErr error                    // first error encountered
+	methods  map[*TypeName][]*Func    // maps package scope type names to associated non-blank (non-interface) methods
+	untyped  map[syntax.Expr]exprInfo // map of expressions without final type
+	delayed  []func()                 // stack of delayed action segments; segments are processed in FIFO order
+	finals   []func()                 // list of final actions; processed at the end of type-checking the current set of files
+	objPath  []Object                 // path of object dependencies during type inference (for cycle reporting)
+
+	// context within which the current object is type-checked
+	// (valid only for the duration of type-checking a specific object)
+	context
+
+	// debugging
+	indent int // indentation for tracing
+}
+
+// addUnusedImport adds the position of a dot-imported package
+// pkg to the map of dot imports for the given file scope.
+func (check *Checker) addUnusedDotImport(scope *Scope, pkg *Package, pos syntax.Pos) {
+	mm := check.unusedDotImports
+	if mm == nil {
+		mm = make(map[*Scope]map[*Package]syntax.Pos)
+		check.unusedDotImports = mm
+	}
+	m := mm[scope]
+	if m == nil {
+		m = make(map[*Package]syntax.Pos)
+		mm[scope] = m
+	}
+	m[pkg] = pos
+}
+
+// addDeclDep adds the dependency edge (check.decl -> to) if check.decl exists
+func (check *Checker) addDeclDep(to Object) {
+	from := check.decl
+	if from == nil {
+		return // not in a package-level init expression
+	}
+	if _, found := check.objMap[to]; !found {
+		return // to is not a package-level object
+	}
+	from.addDep(to)
+}
+
+func (check *Checker) rememberUntyped(e syntax.Expr, lhs bool, mode operandMode, typ *Basic, val constant.Value) {
+	m := check.untyped
+	if m == nil {
+		m = make(map[syntax.Expr]exprInfo)
+		check.untyped = m
+	}
+	m[e] = exprInfo{lhs, mode, typ, val}
+}
+
+// later pushes f on to the stack of actions that will be processed later;
+// either at the end of the current statement, or in case of a local constant
+// or variable declaration, before the constant or variable is in scope
+// (so that f still sees the scope before any new declarations).
+func (check *Checker) later(f func()) {
+	check.delayed = append(check.delayed, f)
+}
+
+// atEnd adds f to the list of actions processed at the end
+// of type-checking, before initialization order computation.
+// Actions added by atEnd are processed after any actions
+// added by later.
+func (check *Checker) atEnd(f func()) {
+	check.finals = append(check.finals, f)
+}
+
+// push pushes obj onto the object path and returns its index in the path.
+func (check *Checker) push(obj Object) int {
+	check.objPath = append(check.objPath, obj)
+	return len(check.objPath) - 1
+}
+
+// pop pops and returns the topmost object from the object path.
+func (check *Checker) pop() Object {
+	i := len(check.objPath) - 1
+	obj := check.objPath[i]
+	check.objPath[i] = nil
+	check.objPath = check.objPath[:i]
+	return obj
+}
+
+// NewChecker returns a new Checker instance for a given package.
+// Package files may be added incrementally via checker.Files.
+func NewChecker(conf *Config, pkg *Package, info *Info) *Checker {
+	// make sure we have a configuration
+	if conf == nil {
+		conf = new(Config)
+	}
+
+	// make sure we have an info struct
+	if info == nil {
+		info = new(Info)
+	}
+
+	return &Checker{
+		conf:   conf,
+		pkg:    pkg,
+		Info:   info,
+		nextId: 1,
+		objMap: make(map[Object]*declInfo),
+		impMap: make(map[importKey]*Package),
+		posMap: make(map[*Interface][]syntax.Pos),
+		typMap: make(map[string]*Named),
+		pkgCnt: make(map[string]int),
+	}
+}
+
+// initFiles initializes the files-specific portion of checker.
+// The provided files must all belong to the same package.
+func (check *Checker) initFiles(files []*syntax.File) {
+	// start with a clean slate (check.Files may be called multiple times)
+	check.files = nil
+	check.unusedDotImports = nil
+
+	check.firstErr = nil
+	check.methods = nil
+	check.untyped = nil
+	check.delayed = nil
+	check.finals = nil
+
+	// determine package name and collect valid files
+	pkg := check.pkg
+	for _, file := range files {
+		switch name := file.PkgName.Value; pkg.name {
+		case "":
+			if name != "_" {
+				pkg.name = name
+			} else {
+				check.errorf(file.PkgName, "invalid package name _")
+			}
+			fallthrough
+
+		case name:
+			check.files = append(check.files, file)
+
+		default:
+			check.errorf(file, "package %s; expected %s", name, pkg.name)
+			// ignore this file
+		}
+	}
+}
+
+// A bailout panic is used for early termination.
+type bailout struct{}
+
+func (check *Checker) handleBailout(err *error) {
+	switch p := recover().(type) {
+	case nil, bailout:
+		// normal return or early exit
+		*err = check.firstErr
+	default:
+		// re-panic
+		panic(p)
+	}
+}
+
+// Files checks the provided files as part of the checker's package.
+func (check *Checker) Files(files []*syntax.File) error { return check.checkFiles(files) }
+
+var errBadCgo = errors.New("cannot use FakeImportC and go115UsesCgo together")
+
+func (check *Checker) checkFiles(files []*syntax.File) (err error) {
+	if check.conf.FakeImportC && check.conf.go115UsesCgo {
+		return errBadCgo
+	}
+
+	defer check.handleBailout(&err)
+
+	print := func(msg string) {
+		if check.conf.Trace {
+			fmt.Println(msg)
+		}
+	}
+
+	print("== initFiles ==")
+	check.initFiles(files)
+
+	print("== collectObjects ==")
+	check.collectObjects()
+
+	print("== packageObjects ==")
+	check.packageObjects()
+
+	print("== processDelayed ==")
+	check.processDelayed(0) // incl. all functions
+	check.processFinals()
+
+	print("== initOrder ==")
+	check.initOrder()
+
+	if !check.conf.DisableUnusedImportCheck {
+		print("== unusedImports ==")
+		check.unusedImports()
+	}
+
+	print("== recordUntyped ==")
+	check.recordUntyped()
+
+	if check.Info != nil {
+		print("== sanitizeInfo ==")
+		sanitizeInfo(check.Info)
+	}
+
+	check.pkg.complete = true
+	return
+}
+
+// processDelayed processes all delayed actions pushed after top.
+func (check *Checker) processDelayed(top int) {
+	// If each delayed action pushes a new action, the
+	// stack will continue to grow during this loop.
+	// However, it is only processing functions (which
+	// are processed in a delayed fashion) that may
+	// add more actions (such as nested functions), so
+	// this is a sufficiently bounded process.
+	for i := top; i < len(check.delayed); i++ {
+		check.delayed[i]() // may append to check.delayed
+	}
+	assert(top <= len(check.delayed)) // stack must not have shrunk
+	check.delayed = check.delayed[:top]
+}
+
+func (check *Checker) processFinals() {
+	n := len(check.finals)
+	for _, f := range check.finals {
+		f() // must not append to check.finals
+	}
+	if len(check.finals) != n {
+		panic("internal error: final action list grew")
+	}
+}
+
+func (check *Checker) recordUntyped() {
+	if !debug && check.Types == nil {
+		return // nothing to do
+	}
+
+	for x, info := range check.untyped {
+		if debug && isTyped(info.typ) {
+			check.dump("%v: %s (type %s) is typed", posFor(x), x, info.typ)
+			unreachable()
+		}
+		check.recordTypeAndValue(x, info.mode, info.typ, info.val)
+	}
+}
+
+func (check *Checker) recordTypeAndValue(x syntax.Expr, mode operandMode, typ Type, val constant.Value) {
+	assert(x != nil)
+	assert(typ != nil)
+	if mode == invalid {
+		return // omit
+	}
+	if mode == constant_ {
+		assert(val != nil)
+		assert(typ == Typ[Invalid] || isConstType(typ))
+	}
+	if m := check.Types; m != nil {
+		m[x] = TypeAndValue{mode, typ, val}
+	}
+}
+
+func (check *Checker) recordBuiltinType(f syntax.Expr, sig *Signature) {
+	// f must be a (possibly parenthesized) identifier denoting a built-in
+	// (built-ins in package unsafe always produce a constant result and
+	// we don't record their signatures, so we don't see qualified idents
+	// here): record the signature for f and possible children.
+	for {
+		check.recordTypeAndValue(f, builtin, sig, nil)
+		switch p := f.(type) {
+		case *syntax.Name:
+			return // we're done
+		case *syntax.ParenExpr:
+			f = p.X
+		default:
+			unreachable()
+		}
+	}
+}
+
+func (check *Checker) recordCommaOkTypes(x syntax.Expr, a [2]Type) {
+	assert(x != nil)
+	if a[0] == nil || a[1] == nil {
+		return
+	}
+	assert(isTyped(a[0]) && isTyped(a[1]) && (isBoolean(a[1]) || a[1] == universeError))
+	if m := check.Types; m != nil {
+		for {
+			tv := m[x]
+			assert(tv.Type != nil) // should have been recorded already
+			pos := x.Pos()
+			tv.Type = NewTuple(
+				NewVar(pos, check.pkg, "", a[0]),
+				NewVar(pos, check.pkg, "", a[1]),
+			)
+			m[x] = tv
+			// if x is a parenthesized expression (p.X), update p.X
+			p, _ := x.(*syntax.ParenExpr)
+			if p == nil {
+				break
+			}
+			x = p.X
+		}
+	}
+}
+
+func (check *Checker) recordInferred(call syntax.Expr, targs []Type, sig *Signature) {
+	assert(call != nil)
+	assert(sig != nil)
+	if m := check.Inferred; m != nil {
+		m[call] = Inferred{targs, sig}
+	}
+}
+
+func (check *Checker) recordDef(id *syntax.Name, obj Object) {
+	assert(id != nil)
+	if m := check.Defs; m != nil {
+		m[id] = obj
+	}
+}
+
+func (check *Checker) recordUse(id *syntax.Name, obj Object) {
+	assert(id != nil)
+	assert(obj != nil)
+	if m := check.Uses; m != nil {
+		m[id] = obj
+	}
+}
+
+func (check *Checker) recordImplicit(node syntax.Node, obj Object) {
+	assert(node != nil)
+	assert(obj != nil)
+	if m := check.Implicits; m != nil {
+		m[node] = obj
+	}
+}
+
+func (check *Checker) recordSelection(x *syntax.SelectorExpr, kind SelectionKind, recv Type, obj Object, index []int, indirect bool) {
+	assert(obj != nil && (recv == nil || len(index) > 0))
+	check.recordUse(x.Sel, obj)
+	if m := check.Selections; m != nil {
+		m[x] = &Selection{kind, recv, obj, index, indirect}
+	}
+}
+
+func (check *Checker) recordScope(node syntax.Node, scope *Scope) {
+	assert(node != nil)
+	assert(scope != nil)
+	if m := check.Scopes; m != nil {
+		m[node] = scope
+	}
+}
diff --git a/src/cmd/compile/internal/types2/check_test.go b/src/cmd/compile/internal/types2/check_test.go
new file mode 100644
index 0000000000..4dac76ea80
--- /dev/null
+++ b/src/cmd/compile/internal/types2/check_test.go
@@ -0,0 +1,269 @@
+// UNREVIEWED
+// Copyright 2011 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.
+
+// This file implements a typechecker test harness. The packages specified
+// in tests are typechecked. Error messages reported by the typechecker are
+// compared against the error messages expected in the test files.
+//
+// Expected errors are indicated in the test files by putting a comment
+// of the form /* ERROR "rx" */ immediately following an offending token.
+// The harness will verify that an error matching the regular expression
+// rx is reported at that source position. Consecutive comments may be
+// used to indicate multiple errors for the same token position.
+//
+// For instance, the following test file indicates that a "not declared"
+// error should be reported for the undeclared variable x:
+//
+//	package p
+//	func f() {
+//		_ = x /* ERROR "not declared" */ + 1
+//	}
+
+// TODO(gri) Also collect strict mode errors of the form /* STRICT ... */
+//           and test against strict mode.
+
+package types2_test
+
+import (
+	"cmd/compile/internal/syntax"
+	"flag"
+	"fmt"
+	"internal/testenv"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+
+	. "cmd/compile/internal/types2"
+)
+
+var (
+	haltOnError = flag.Bool("halt", false, "halt on error")
+	listErrors  = flag.Bool("errlist", false, "list errors")
+	testFiles   = flag.String("files", "", "space-separated list of test files")
+)
+
+func parseFiles(t *testing.T, filenames []string) ([]*syntax.File, []error) {
+	var files []*syntax.File
+	var errlist []error
+	errh := func(err error) { errlist = append(errlist, err) }
+	for _, filename := range filenames {
+		file, err := syntax.ParseFile(filename, errh, nil, syntax.AllowGenerics)
+		if file == nil {
+			t.Fatalf("%s: %s", filename, err)
+		}
+		files = append(files, file)
+	}
+	return files, errlist
+}
+
+func unpackError(err error) syntax.Error {
+	switch err := err.(type) {
+	case syntax.Error:
+		return err
+	case Error:
+		return syntax.Error{Pos: err.Pos, Msg: err.Msg}
+	default:
+		return syntax.Error{Msg: err.Error()}
+	}
+}
+
+func delta(x, y uint) uint {
+	switch {
+	case x < y:
+		return y - x
+	case x > y:
+		return x - y
+	default:
+		return 0
+	}
+}
+
+func checkFiles(t *testing.T, sources []string, colDelta uint, trace bool) {
+	// parse files and collect parser errors
+	files, errlist := parseFiles(t, sources)
+
+	pkgName := "<no package>"
+	if len(files) > 0 {
+		pkgName = files[0].PkgName.Value
+	}
+
+	if *listErrors && len(errlist) > 0 {
+		t.Errorf("--- %s:", pkgName)
+		for _, err := range errlist {
+			t.Error(err)
+		}
+	}
+
+	// typecheck and collect typechecker errors
+	var conf Config
+	conf.AcceptMethodTypeParams = true
+	conf.InferFromConstraints = true
+	// special case for importC.src
+	if len(sources) == 1 && strings.HasSuffix(sources[0], "importC.src") {
+		conf.FakeImportC = true
+	}
+	conf.Trace = trace
+	conf.Importer = defaultImporter()
+	conf.Error = func(err error) {
+		if *haltOnError {
+			defer panic(err)
+		}
+		if *listErrors {
+			t.Error(err)
+			return
+		}
+		// Ignore secondary error messages starting with "\t";
+		// they are clarifying messages for a primary error.
+		if !strings.Contains(err.Error(), ": \t") {
+			errlist = append(errlist, err)
+		}
+	}
+	conf.Check(pkgName, files, nil)
+
+	if *listErrors {
+		return
+	}
+
+	// collect expected errors
+	errmap := make(map[string]map[uint][]syntax.Error)
+	for _, filename := range sources {
+		f, err := os.Open(filename)
+		if err != nil {
+			t.Error(err)
+			continue
+		}
+		if m := syntax.ErrorMap(f); len(m) > 0 {
+			errmap[filename] = m
+		}
+		f.Close()
+	}
+
+	// match against found errors
+	for _, err := range errlist {
+		got := unpackError(err)
+
+		// find list of errors for the respective error line
+		filename := got.Pos.Base().Filename()
+		filemap := errmap[filename]
+		var line uint
+		var list []syntax.Error
+		if filemap != nil {
+			line = got.Pos.Line()
+			list = filemap[line]
+		}
+		// list may be nil
+
+		// one of errors in list should match the current error
+		index := -1 // list index of matching message, if any
+		for i, want := range list {
+			rx, err := regexp.Compile(want.Msg)
+			if err != nil {
+				t.Errorf("%s:%d:%d: %v", filename, line, want.Pos.Col(), err)
+				continue
+			}
+			if rx.MatchString(got.Msg) {
+				index = i
+				break
+			}
+		}
+		if index < 0 {
+			t.Errorf("%s: no error expected: %q", got.Pos, got.Msg)
+			continue
+		}
+
+		// column position must be within expected colDelta
+		want := list[index]
+		if delta(got.Pos.Col(), want.Pos.Col()) > colDelta {
+			t.Errorf("%s: got col = %d; want %d", got.Pos, got.Pos.Col(), want.Pos.Col())
+		}
+
+		// eliminate from list
+		if n := len(list) - 1; n > 0 {
+			// not the last entry - swap in last element and shorten list by 1
+			list[index] = list[n]
+			filemap[line] = list[:n]
+		} else {
+			// last entry - remove list from filemap
+			delete(filemap, line)
+		}
+
+		// if filemap is empty, eliminate from errmap
+		if len(filemap) == 0 {
+			delete(errmap, filename)
+		}
+	}
+
+	// there should be no expected errors left
+	if len(errmap) > 0 {
+		t.Errorf("--- %s: unreported errors:", pkgName)
+		for filename, filemap := range errmap {
+			for line, list := range filemap {
+				for _, err := range list {
+					t.Errorf("%s:%d:%d: %s", filename, line, err.Pos.Col(), err.Msg)
+				}
+			}
+		}
+	}
+}
+
+// TestCheck is for manual testing of selected input files, provided with -files.
+func TestCheck(t *testing.T) {
+	if *testFiles == "" {
+		return
+	}
+	testenv.MustHaveGoBuild(t)
+	DefPredeclaredTestFuncs()
+	checkFiles(t, strings.Split(*testFiles, " "), 0, testing.Verbose())
+}
+
+// TODO(gri) Enable once we have added the testdata tests.
+// func TestTestdata(t *testing.T)  { DefPredeclaredTestFuncs(); testDir(t, 75, "testdata") } // TODO(gri) narrow column tolerance
+func TestExamples(t *testing.T)  { testDir(t, 0, "examples") }
+func TestFixedbugs(t *testing.T) { testDir(t, 0, "fixedbugs") }
+
+func testDir(t *testing.T, colDelta uint, dir string) {
+	testenv.MustHaveGoBuild(t)
+
+	fis, err := ioutil.ReadDir(dir)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	for count, fi := range fis {
+		path := filepath.Join(dir, fi.Name())
+
+		// if fi is a directory, its files make up a single package
+		if fi.IsDir() {
+			if testing.Verbose() {
+				fmt.Printf("%3d %s\n", count, path)
+			}
+			fis, err := ioutil.ReadDir(path)
+			if err != nil {
+				t.Error(err)
+				continue
+			}
+			files := make([]string, len(fis))
+			for i, fi := range fis {
+				// if fi is a directory, checkFiles below will complain
+				files[i] = filepath.Join(path, fi.Name())
+				if testing.Verbose() {
+					fmt.Printf("\t%s\n", files[i])
+				}
+			}
+			checkFiles(t, files, colDelta, false)
+			continue
+		}
+
+		// otherwise, fi is a stand-alone file
+		if testing.Verbose() {
+			fmt.Printf("%3d %s\n", count, path)
+		}
+		checkFiles(t, []string{path}, colDelta, false)
+	}
+}
diff --git a/src/cmd/compile/internal/types2/conversions.go b/src/cmd/compile/internal/types2/conversions.go
new file mode 100644
index 0000000000..9ff548593f
--- /dev/null
+++ b/src/cmd/compile/internal/types2/conversions.go
@@ -0,0 +1,164 @@
+// UNREVIEWED
+// Copyright 2012 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.
+
+// This file implements typechecking of conversions.
+
+package types2
+
+import "go/constant"
+
+// Conversion type-checks the conversion T(x).
+// The result is in x.
+func (check *Checker) conversion(x *operand, T Type) {
+	constArg := x.mode == constant_
+
+	var ok bool
+	switch {
+	case constArg && isConstType(T):
+		// constant conversion
+		switch t := T.Basic(); {
+		case representableConst(x.val, check, t, &x.val):
+			ok = true
+		case isInteger(x.typ) && isString(t):
+			codepoint := int64(-1)
+			if i, ok := constant.Int64Val(x.val); ok {
+				codepoint = i
+			}
+			// If codepoint < 0 the absolute value is too large (or unknown) for
+			// conversion. This is the same as converting any other out-of-range
+			// value - let string(codepoint) do the work.
+			x.val = constant.MakeString(string(rune(codepoint)))
+			ok = true
+		}
+	case x.convertibleTo(check, T):
+		// non-constant conversion
+		x.mode = value
+		ok = true
+	}
+
+	if !ok {
+		check.errorf(x, "cannot convert %s to %s", x, T)
+		x.mode = invalid
+		return
+	}
+
+	// The conversion argument types are final. For untyped values the
+	// conversion provides the type, per the spec: "A constant may be
+	// given a type explicitly by a constant declaration or conversion,...".
+	if isUntyped(x.typ) {
+		final := T
+		// - For conversions to interfaces, use the argument's default type.
+		// - For conversions of untyped constants to non-constant types, also
+		//   use the default type (e.g., []byte("foo") should report string
+		//   not []byte as type for the constant "foo").
+		// - Keep untyped nil for untyped nil arguments.
+		// - For integer to string conversions, keep the argument type.
+		//   (See also the TODO below.)
+		if IsInterface(T) || constArg && !isConstType(T) {
+			final = Default(x.typ)
+		} else if isInteger(x.typ) && isString(T) {
+			final = x.typ
+		}
+		check.updateExprType(x.expr, final, true)
+	}
+
+	x.typ = T
+}
+
+// TODO(gri) convertibleTo checks if T(x) is valid. It assumes that the type
+// of x is fully known, but that's not the case for say string(1<<s + 1.0):
+// Here, the type of 1<<s + 1.0 will be UntypedFloat which will lead to the
+// (correct!) refusal of the conversion. But the reported error is essentially
+// "cannot convert untyped float value to string", yet the correct error (per
+// the spec) is that we cannot shift a floating-point value: 1 in 1<<s should
+// be converted to UntypedFloat because of the addition of 1.0. Fixing this
+// is tricky because we'd have to run updateExprType on the argument first.
+// (Issue #21982.)
+
+// convertibleTo reports whether T(x) is valid.
+// The check parameter may be nil if convertibleTo is invoked through an
+// exported API call, i.e., when all methods have been type-checked.
+func (x *operand) convertibleTo(check *Checker, T Type) bool {
+	// "x is assignable to T"
+	if x.assignableTo(check, T, nil) {
+		return true
+	}
+
+	// "x's type and T have identical underlying types if tags are ignored"
+	V := x.typ
+	Vu := V.Under()
+	Tu := T.Under()
+	if check.identicalIgnoreTags(Vu, Tu) {
+		return true
+	}
+
+	// "x's type and T are unnamed pointer types and their pointer base types
+	// have identical underlying types if tags are ignored"
+	if V, ok := V.(*Pointer); ok {
+		if T, ok := T.(*Pointer); ok {
+			if check.identicalIgnoreTags(V.base.Under(), T.base.Under()) {
+				return true
+			}
+		}
+	}
+
+	// "x's type and T are both integer or floating point types"
+	if isIntegerOrFloat(V) && isIntegerOrFloat(T) {
+		return true
+	}
+
+	// "x's type and T are both complex types"
+	if isComplex(V) && isComplex(T) {
+		return true
+	}
+
+	// "x is an integer or a slice of bytes or runes and T is a string type"
+	if (isInteger(V) || isBytesOrRunes(Vu)) && isString(T) {
+		return true
+	}
+
+	// "x is a string and T is a slice of bytes or runes"
+	if isString(V) && isBytesOrRunes(Tu) {
+		return true
+	}
+
+	// package unsafe:
+	// "any pointer or value of underlying type uintptr can be converted into a unsafe.Pointer"
+	if (isPointer(Vu) || isUintptr(Vu)) && isUnsafePointer(T) {
+		return true
+	}
+	// "and vice versa"
+	if isUnsafePointer(V) && (isPointer(Tu) || isUintptr(Tu)) {
+		return true
+	}
+
+	return false
+}
+
+func isUintptr(typ Type) bool {
+	t := typ.Basic()
+	return t != nil && t.kind == Uintptr
+}
+
+func isUnsafePointer(typ Type) bool {
+	// TODO(gri): Is this typ.Basic() instead of typ.(*Basic) correct?
+	//            (The former calls typ.Under(), while the latter doesn't.)
+	//            The spec does not say so, but gc claims it is. See also
+	//            issue 6326.
+	t := typ.Basic()
+	return t != nil && t.kind == UnsafePointer
+}
+
+func isPointer(typ Type) bool {
+	return typ.Pointer() != nil
+}
+
+func isBytesOrRunes(typ Type) bool {
+	if s := typ.Slice(); s != nil {
+		t := s.elem.Basic()
+		return t != nil && (t.kind == Byte || t.kind == Rune)
+	}
+	return false
+}
diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
new file mode 100644
index 0000000000..ef8dc7a245
--- /dev/null
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -0,0 +1,981 @@
+// UNREVIEWED
+// Copyright 2014 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 types2
+
+import (
+	"cmd/compile/internal/syntax"
+	"fmt"
+	"go/constant"
+)
+
+func (check *Checker) reportAltDecl(obj Object) {
+	if pos := obj.Pos(); pos.IsKnown() {
+		// We use "other" rather than "previous" here because
+		// the first declaration seen may not be textually
+		// earlier in the source.
+		check.errorf(pos, "\tother declaration of %s", obj.Name()) // secondary error, \t indented
+	}
+}
+
+func (check *Checker) declare(scope *Scope, id *syntax.Name, obj Object, pos syntax.Pos) {
+	// spec: "The blank identifier, represented by the underscore
+	// character _, may be used in a declaration like any other
+	// identifier but the declaration does not introduce a new
+	// binding."
+	if obj.Name() != "_" {
+		if alt := scope.Insert(obj); alt != nil {
+			check.errorf(obj.Pos(), "%s redeclared in this block", obj.Name())
+			check.reportAltDecl(alt)
+			return
+		}
+		obj.setScopePos(pos)
+	}
+	if id != nil {
+		check.recordDef(id, obj)
+	}
+}
+
+// pathString returns a string of the form a->b-> ... ->g for a path [a, b, ... g].
+func pathString(path []Object) string {
+	var s string
+	for i, p := range path {
+		if i > 0 {
+			s += "->"
+		}
+		s += p.Name()
+	}
+	return s
+}
+
+// objDecl type-checks the declaration of obj in its respective (file) context.
+// For the meaning of def, see Checker.definedType, in typexpr.go.
+func (check *Checker) objDecl(obj Object, def *Named) {
+	if check.conf.Trace && obj.Type() == nil {
+		if check.indent == 0 {
+			fmt.Println() // empty line between top-level objects for readability
+		}
+		check.trace(obj.Pos(), "-- checking %s (%s, objPath = %s)", obj, obj.color(), pathString(check.objPath))
+		check.indent++
+		defer func() {
+			check.indent--
+			check.trace(obj.Pos(), "=> %s (%s)", obj, obj.color())
+		}()
+	}
+
+	// Checking the declaration of obj means inferring its type
+	// (and possibly its value, for constants).
+	// An object's type (and thus the object) may be in one of
+	// three states which are expressed by colors:
+	//
+	// - an object whose type is not yet known is painted white (initial color)
+	// - an object whose type is in the process of being inferred is painted grey
+	// - an object whose type is fully inferred is painted black
+	//
+	// During type inference, an object's color changes from white to grey
+	// to black (pre-declared objects are painted black from the start).
+	// A black object (i.e., its type) can only depend on (refer to) other black
+	// ones. White and grey objects may depend on white and black objects.
+	// A dependency on a grey object indicates a cycle which may or may not be
+	// valid.
+	//
+	// When objects turn grey, they are pushed on the object path (a stack);
+	// they are popped again when they turn black. Thus, if a grey object (a
+	// cycle) is encountered, it is on the object path, and all the objects
+	// it depends on are the remaining objects on that path. Color encoding
+	// is such that the color value of a grey object indicates the index of
+	// that object in the object path.
+
+	// During type-checking, white objects may be assigned a type without
+	// traversing through objDecl; e.g., when initializing constants and
+	// variables. Update the colors of those objects here (rather than
+	// everywhere where we set the type) to satisfy the color invariants.
+	if obj.color() == white && obj.Type() != nil {
+		obj.setColor(black)
+		return
+	}
+
+	switch obj.color() {
+	case white:
+		assert(obj.Type() == nil)
+		// All color values other than white and black are considered grey.
+		// Because black and white are < grey, all values >= grey are grey.
+		// Use those values to encode the object's index into the object path.
+		obj.setColor(grey + color(check.push(obj)))
+		defer func() {
+			check.pop().setColor(black)
+		}()
+
+	case black:
+		assert(obj.Type() != nil)
+		return
+
+	default:
+		// Color values other than white or black are considered grey.
+		fallthrough
+
+	case grey:
+		// We have a cycle.
+		// In the existing code, this is marked by a non-nil type
+		// for the object except for constants and variables whose
+		// type may be non-nil (known), or nil if it depends on the
+		// not-yet known initialization value.
+		// In the former case, set the type to Typ[Invalid] because
+		// we have an initialization cycle. The cycle error will be
+		// reported later, when determining initialization order.
+		// TODO(gri) Report cycle here and simplify initialization
+		// order code.
+		switch obj := obj.(type) {
+		case *Const:
+			if check.cycle(obj) || obj.typ == nil {
+				obj.typ = Typ[Invalid]
+			}
+
+		case *Var:
+			if check.cycle(obj) || obj.typ == nil {
+				obj.typ = Typ[Invalid]
+			}
+
+		case *TypeName:
+			if check.cycle(obj) {
+				// break cycle
+				// (without this, calling underlying()
+				// below may lead to an endless loop
+				// if we have a cycle for a defined
+				// (*Named) type)
+				obj.typ = Typ[Invalid]
+			}
+
+		case *Func:
+			if check.cycle(obj) {
+				// Don't set obj.typ to Typ[Invalid] here
+				// because plenty of code type-asserts that
+				// functions have a *Signature type. Grey
+				// functions have their type set to an empty
+				// signature which makes it impossible to
+				// initialize a variable with the function.
+			}
+
+		default:
+			unreachable()
+		}
+		assert(obj.Type() != nil)
+		return
+	}
+
+	d := check.objMap[obj]
+	if d == nil {
+		check.dump("%v: %s should have been declared", obj.Pos(), obj)
+		unreachable()
+	}
+
+	// save/restore current context and setup object context
+	defer func(ctxt context) {
+		check.context = ctxt
+	}(check.context)
+	check.context = context{
+		scope: d.file,
+	}
+
+	// Const and var declarations must not have initialization
+	// cycles. We track them by remembering the current declaration
+	// in check.decl. Initialization expressions depending on other
+	// consts, vars, or functions, add dependencies to the current
+	// check.decl.
+	switch obj := obj.(type) {
+	case *Const:
+		check.decl = d // new package-level const decl
+		check.constDecl(obj, d.vtyp, d.init)
+	case *Var:
+		check.decl = d // new package-level var decl
+		check.varDecl(obj, d.lhs, d.vtyp, d.init)
+	case *TypeName:
+		// invalid recursive types are detected via path
+		check.typeDecl(obj, d.tdecl, def)
+		check.collectMethods(obj) // methods can only be added to top-level types
+	case *Func:
+		// functions may be recursive - no need to track dependencies
+		check.funcDecl(obj, d)
+	default:
+		unreachable()
+	}
+}
+
+// cycle checks if the cycle starting with obj is valid and
+// reports an error if it is not.
+func (check *Checker) cycle(obj Object) (isCycle bool) {
+	// The object map contains the package scope objects and the non-interface methods.
+	if debug {
+		info := check.objMap[obj]
+		inObjMap := info != nil && (info.fdecl == nil || info.fdecl.Recv == nil) // exclude methods
+		isPkgObj := obj.Parent() == check.pkg.scope
+		if isPkgObj != inObjMap {
+			check.dump("%v: inconsistent object map for %s (isPkgObj = %v, inObjMap = %v)", obj.Pos(), obj, isPkgObj, inObjMap)
+			unreachable()
+		}
+	}
+
+	// Count cycle objects.
+	assert(obj.color() >= grey)
+	start := obj.color() - grey // index of obj in objPath
+	cycle := check.objPath[start:]
+	nval := 0 // number of (constant or variable) values in the cycle
+	ndef := 0 // number of type definitions in the cycle
+	for _, obj := range cycle {
+		switch obj := obj.(type) {
+		case *Const, *Var:
+			nval++
+		case *TypeName:
+			// Determine if the type name is an alias or not. For
+			// package-level objects, use the object map which
+			// provides syntactic information (which doesn't rely
+			// on the order in which the objects are set up). For
+			// local objects, we can rely on the order, so use
+			// the object's predicate.
+			// TODO(gri) It would be less fragile to always access
+			// the syntactic information. We should consider storing
+			// this information explicitly in the object.
+			var alias bool
+			if d := check.objMap[obj]; d != nil {
+				alias = d.tdecl.Alias // package-level object
+			} else {
+				alias = obj.IsAlias() // function local object
+			}
+			if !alias {
+				ndef++
+			}
+		case *Func:
+			// ignored for now
+		default:
+			unreachable()
+		}
+	}
+
+	if check.conf.Trace {
+		check.trace(obj.Pos(), "## cycle detected: objPath = %s->%s (len = %d)", pathString(cycle), obj.Name(), len(cycle))
+		check.trace(obj.Pos(), "## cycle contains: %d values, %d type definitions", nval, ndef)
+		defer func() {
+			if isCycle {
+				check.trace(obj.Pos(), "=> error: cycle is invalid")
+			}
+		}()
+	}
+
+	// A cycle involving only constants and variables is invalid but we
+	// ignore them here because they are reported via the initialization
+	// cycle check.
+	if nval == len(cycle) {
+		return false
+	}
+
+	// A cycle involving only types (and possibly functions) must have at least
+	// one type definition to be permitted: If there is no type definition, we
+	// have a sequence of alias type names which will expand ad infinitum.
+	if nval == 0 && ndef > 0 {
+		return false // cycle is permitted
+	}
+
+	check.cycleError(cycle)
+
+	return true
+}
+
+type typeInfo uint
+
+// validType verifies that the given type does not "expand" infinitely
+// producing a cycle in the type graph. Cycles are detected by marking
+// defined types.
+// (Cycles involving alias types, as in "type A = [10]A" are detected
+// earlier, via the objDecl cycle detection mechanism.)
+func (check *Checker) validType(typ Type, path []Object) typeInfo {
+	const (
+		unknown typeInfo = iota
+		marked
+		valid
+		invalid
+	)
+
+	switch t := typ.(type) {
+	case *Array:
+		return check.validType(t.elem, path)
+
+	case *Struct:
+		for _, f := range t.fields {
+			if check.validType(f.typ, path) == invalid {
+				return invalid
+			}
+		}
+
+	case *Interface:
+		for _, etyp := range t.embeddeds {
+			if check.validType(etyp, path) == invalid {
+				return invalid
+			}
+		}
+
+	case *Named:
+		// don't touch the type if it is from a different package or the Universe scope
+		// (doing so would lead to a race condition - was issue #35049)
+		if t.obj.pkg != check.pkg {
+			return valid
+		}
+
+		// don't report a 2nd error if we already know the type is invalid
+		// (e.g., if a cycle was detected earlier, via Checker.underlying).
+		if t.underlying == Typ[Invalid] {
+			t.info = invalid
+			return invalid
+		}
+
+		switch t.info {
+		case unknown:
+			t.info = marked
+			t.info = check.validType(t.orig, append(path, t.obj)) // only types of current package added to path
+		case marked:
+			// cycle detected
+			for i, tn := range path {
+				if t.obj.pkg != check.pkg {
+					panic("internal error: type cycle via package-external type")
+				}
+				if tn == t.obj {
+					check.cycleError(path[i:])
+					t.info = invalid
+					return t.info
+				}
+			}
+			panic("internal error: cycle start not found")
+		}
+		return t.info
+
+	case *instance:
+		return check.validType(t.expand(), path)
+	}
+
+	return valid
+}
+
+// cycleError reports a declaration cycle starting with
+// the object in cycle that is "first" in the source.
+func (check *Checker) cycleError(cycle []Object) {
+	// TODO(gri) Should we start with the last (rather than the first) object in the cycle
+	//           since that is the earliest point in the source where we start seeing the
+	//           cycle? That would be more consistent with other error messages.
+	i := firstInSrc(cycle)
+	obj := cycle[i]
+	check.errorf(obj.Pos(), "illegal cycle in declaration of %s", obj.Name())
+	for range cycle {
+		check.errorf(obj.Pos(), "\t%s refers to", obj.Name()) // secondary error, \t indented
+		i++
+		if i >= len(cycle) {
+			i = 0
+		}
+		obj = cycle[i]
+	}
+	check.errorf(obj.Pos(), "\t%s", obj.Name())
+}
+
+// TODO(gri) This functionality should probably be with the Pos implementation.
+func cmpPos(p, q syntax.Pos) int {
+	// TODO(gri) is RelFilename correct here?
+	pname := p.RelFilename()
+	qname := q.RelFilename()
+	switch {
+	case pname < qname:
+		return -1
+	case pname > qname:
+		return +1
+	}
+
+	pline := p.Line()
+	qline := q.Line()
+	switch {
+	case pline < qline:
+		return -1
+	case pline > qline:
+		return +1
+	}
+
+	pcol := p.Col()
+	qcol := q.Col()
+	switch {
+	case pcol < qcol:
+		return -1
+	case pcol > qcol:
+		return +1
+	}
+
+	return 0
+}
+
+// firstInSrc reports the index of the object with the "smallest"
+// source position in path. path must not be empty.
+func firstInSrc(path []Object) int {
+	fst, pos := 0, path[0].Pos()
+	for i, t := range path[1:] {
+		if cmpPos(t.Pos(), pos) < 0 {
+			fst, pos = i+1, t.Pos()
+		}
+	}
+	return fst
+}
+
+func (check *Checker) constDecl(obj *Const, typ, init syntax.Expr) {
+	assert(obj.typ == nil)
+
+	// use the correct value of iota
+	defer func(iota constant.Value) { check.iota = iota }(check.iota)
+	check.iota = obj.val
+
+	// provide valid constant value under all circumstances
+	obj.val = constant.MakeUnknown()
+
+	// determine type, if any
+	if typ != nil {
+		t := check.typ(typ)
+		if !isConstType(t) {
+			// don't report an error if the type is an invalid C (defined) type
+			// (issue #22090)
+			if t.Under() != Typ[Invalid] {
+				check.errorf(typ, "invalid constant type %s", t)
+			}
+			obj.typ = Typ[Invalid]
+			return
+		}
+		obj.typ = t
+	}
+
+	// check initialization
+	var x operand
+	if init != nil {
+		check.expr(&x, init)
+	}
+	check.initConst(obj, &x)
+}
+
+func (check *Checker) varDecl(obj *Var, lhs []*Var, typ, init syntax.Expr) {
+	assert(obj.typ == nil)
+
+	// determine type, if any
+	if typ != nil {
+		obj.typ = check.varType(typ)
+		// We cannot spread the type to all lhs variables if there
+		// are more than one since that would mark them as checked
+		// (see Checker.objDecl) and the assignment of init exprs,
+		// if any, would not be checked.
+		//
+		// TODO(gri) If we have no init expr, we should distribute
+		// a given type otherwise we need to re-evalate the type
+		// expr for each lhs variable, leading to duplicate work.
+	}
+
+	// check initialization
+	if init == nil {
+		if typ == nil {
+			// error reported before by arityMatch
+			obj.typ = Typ[Invalid]
+		}
+		return
+	}
+
+	if lhs == nil || len(lhs) == 1 {
+		assert(lhs == nil || lhs[0] == obj)
+		var x operand
+		check.expr(&x, init)
+		check.initVar(obj, &x, "variable declaration")
+		return
+	}
+
+	if debug {
+		// obj must be one of lhs
+		found := false
+		for _, lhs := range lhs {
+			if obj == lhs {
+				found = true
+				break
+			}
+		}
+		if !found {
+			panic("inconsistent lhs")
+		}
+	}
+
+	// We have multiple variables on the lhs and one init expr.
+	// Make sure all variables have been given the same type if
+	// one was specified, otherwise they assume the type of the
+	// init expression values (was issue #15755).
+	if typ != nil {
+		for _, lhs := range lhs {
+			lhs.typ = obj.typ
+		}
+	}
+
+	check.initVars(lhs, []syntax.Expr{init}, nopos)
+}
+
+// Under returns the expanded underlying type of n0; possibly by following
+// forward chains of named types. If an underlying type is found, resolve
+// the chain by setting the underlying type for each defined type in the
+// chain before returning it. If no underlying type is found or a cycle
+// is detected, the result is Typ[Invalid]. If a cycle is detected and
+// n0.check != nil, the cycle is reported.
+func (n0 *Named) Under() Type {
+	u := n0.underlying
+	if u == nil {
+		return Typ[Invalid]
+	}
+
+	// If the underlying type of a defined type is not a defined
+	// type, then that is the desired underlying type.
+	n := u.Named()
+	if n == nil {
+		return u // common case
+	}
+
+	// Otherwise, follow the forward chain.
+	seen := map[*Named]int{n0: 0}
+	path := []Object{n0.obj}
+	for {
+		u = n.underlying
+		if u == nil {
+			u = Typ[Invalid]
+			break
+		}
+		n1 := u.Named()
+		if n1 == nil {
+			break // end of chain
+		}
+
+		seen[n] = len(seen)
+		path = append(path, n.obj)
+		n = n1
+
+		if i, ok := seen[n]; ok {
+			// cycle
+			if n0.check != nil {
+				n0.check.cycleError(path[i:])
+			}
+			u = Typ[Invalid]
+			break
+		}
+	}
+
+	for n := range seen {
+		// We should never have to update the underlying type of an imported type;
+		// those underlying types should have been resolved during the import.
+		// Also, doing so would lead to a race condition (was issue #31749).
+		// Do this check always, not just in debug more (it's cheap).
+		if n0.check != nil && n.obj.pkg != n0.check.pkg {
+			panic("internal error: imported type with unresolved underlying type")
+		}
+		n.underlying = u
+	}
+
+	return u
+}
+
+func (n *Named) setUnderlying(typ Type) {
+	if n != nil {
+		n.underlying = typ
+	}
+}
+
+func (check *Checker) typeDecl(obj *TypeName, tdecl *syntax.TypeDecl, def *Named) {
+	assert(obj.typ == nil)
+
+	check.later(func() {
+		check.validType(obj.typ, nil)
+	})
+
+	alias := tdecl.Alias
+	if alias && tdecl.TParamList != nil {
+		// The parser will ensure this but we may still get an invalid AST.
+		// Complain and continue as regular type definition.
+		check.errorf(tdecl, "generic type cannot be alias")
+		alias = false
+	}
+
+	if alias {
+		// type alias declaration
+
+		obj.typ = Typ[Invalid]
+		obj.typ = check.anyType(tdecl.Type)
+
+	} else {
+		// defined type declaration
+
+		named := &Named{check: check, obj: obj}
+		def.setUnderlying(named)
+		obj.typ = named // make sure recursive type declarations terminate
+
+		if tdecl.TParamList != nil {
+			check.openScope(tdecl, "type parameters")
+			defer check.closeScope()
+			named.tparams = check.collectTypeParams(tdecl.TParamList)
+		}
+
+		// determine underlying type of named
+		named.orig = check.definedType(tdecl.Type, named)
+
+		// The underlying type of named may be itself a named type that is
+		// incomplete:
+		//
+		//	type (
+		//		A B
+		//		B *C
+		//		C A
+		//	)
+		//
+		// The type of C is the (named) type of A which is incomplete,
+		// and which has as its underlying type the named type B.
+		// Determine the (final, unnamed) underlying type by resolving
+		// any forward chain.
+		// TODO(gri) Investigate if we can just use named.origin here
+		//           and rely on lazy computation of the underlying type.
+		named.underlying = named.Under()
+	}
+
+}
+
+func (check *Checker) collectTypeParams(list []*syntax.Field) (tparams []*TypeName) {
+	// Type parameter lists should not be empty. The parser will
+	// complain but we still may get an incorrect AST: ignore it.
+	if len(list) == 0 {
+		return
+	}
+
+	// Declare type parameters up-front, with empty interface as type bound.
+	// The scope of type parameters starts at the beginning of the type parameter
+	// list (so we can have mutually recursive parameterized interfaces).
+	for _, f := range list {
+		tparams = check.declareTypeParam(tparams, f.Name)
+	}
+
+	var bound Type
+	for i, j := 0, 0; i < len(list); i = j {
+		f := list[i]
+		ftype := f.Type
+
+		// determine the range of type parameters list[i:j] with identical type bound
+		// (declared as in (type a, b, c B))
+		j = i + 1
+		for j < len(list) && list[j].Type == ftype {
+			j++
+		}
+
+		// this should never be the case, but be careful
+		if ftype == nil {
+			continue
+		}
+
+		// If the type bound expects exactly one type argument, permit leaving
+		// it away and use the corresponding type parameter as implicit argument.
+		// This allows us to write (type p b(p), q b(q), r b(r)) as (type p, q, r b).
+		// Enabled if enableImplicitTParam is set.
+		const enableImplicitTParam = false
+
+		// The predeclared identifier "any" is visible only as a constraint
+		// in a type parameter list. Look for it before general constraint
+		// resolution.
+		if tident, _ := f.Type.(*syntax.Name); tident != nil && tident.Value == "any" && check.lookup("any") == nil {
+			bound = universeAny
+		} else if enableImplicitTParam {
+			bound = check.anyType(f.Type)
+		} else {
+			bound = check.typ(f.Type)
+		}
+
+		// type bound must be an interface
+		// TODO(gri) We should delay the interface check because
+		//           we may not have a complete interface yet:
+		//           type C(type T C) interface {}
+		//           (issue #39724).
+		if _, ok := bound.Under().(*Interface); ok {
+			if enableImplicitTParam && isGeneric(bound) {
+				base := bound.(*Named) // only a *Named type can be generic
+				if j-i != 1 || len(base.tparams) != 1 {
+					// TODO(gri) make this error message better
+					check.errorf(ftype, "cannot use generic type %s without instantiation (more than one type parameter)", bound)
+					bound = Typ[Invalid]
+					continue
+				}
+				// We have exactly one type parameter.
+				// "Manually" instantiate the bound with each type
+				// parameter the bound applies to.
+				// TODO(gri) this code (in more general form) is also in
+				// checker.typInternal for the *ast.CallExpr case. Factor?
+				typ := new(instance)
+				typ.check = check
+				typ.pos = ftype.Pos()
+				typ.base = base
+				typ.targs = []Type{tparams[i].typ}
+				typ.poslist = []syntax.Pos{f.Name.Pos()}
+				// Make sure we check instantiation works at least once
+				// and that the resulting type is valid.
+				check.atEnd(func() {
+					check.validType(typ.expand(), nil)
+				})
+				// update bound and recorded type
+				bound = typ
+				check.recordTypeAndValue(ftype, typexpr, typ, nil)
+			}
+			// set the type bounds
+			for i < j {
+				tparams[i].typ.(*TypeParam).bound = bound
+				i++
+			}
+		} else if bound != Typ[Invalid] {
+			check.errorf(f.Type, "%s is not an interface", bound)
+		}
+	}
+
+	return
+}
+
+func (check *Checker) declareTypeParam(tparams []*TypeName, name *syntax.Name) []*TypeName {
+	var ptr bool
+	nstr := name.Value
+	if len(nstr) > 0 && nstr[0] == '*' {
+		ptr = true
+		nstr = nstr[1:]
+	}
+	tpar := NewTypeName(name.Pos(), check.pkg, nstr, nil)
+	check.NewTypeParam(ptr, tpar, len(tparams), &emptyInterface) // assigns type to tpar as a side-effect
+	check.declare(check.scope, name, tpar, check.scope.pos)      // TODO(gri) check scope position
+	tparams = append(tparams, tpar)
+
+	if check.conf.Trace {
+		check.trace(name.Pos(), "type param = %v", tparams[len(tparams)-1])
+	}
+
+	return tparams
+}
+
+func (check *Checker) collectMethods(obj *TypeName) {
+	// get associated methods
+	// (Checker.collectObjects only collects methods with non-blank names;
+	// Checker.resolveBaseTypeName ensures that obj is not an alias name
+	// if it has attached methods.)
+	methods := check.methods[obj]
+	if methods == nil {
+		return
+	}
+	delete(check.methods, obj)
+	assert(!check.objMap[obj].tdecl.Alias) // don't use TypeName.IsAlias (requires fully set up object)
+
+	// use an objset to check for name conflicts
+	var mset objset
+
+	// spec: "If the base type is a struct type, the non-blank method
+	// and field names must be distinct."
+	base := obj.typ.Named() // shouldn't fail but be conservative
+	if base != nil {
+		if t, _ := base.underlying.(*Struct); t != nil {
+			for _, fld := range t.fields {
+				if fld.name != "_" {
+					assert(mset.insert(fld) == nil)
+				}
+			}
+		}
+
+		// Checker.Files may be called multiple times; additional package files
+		// may add methods to already type-checked types. Add pre-existing methods
+		// so that we can detect redeclarations.
+		for _, m := range base.methods {
+			assert(m.name != "_")
+			assert(mset.insert(m) == nil)
+		}
+	}
+
+	// add valid methods
+	for _, m := range methods {
+		// spec: "For a base type, the non-blank names of methods bound
+		// to it must be unique."
+		assert(m.name != "_")
+		if alt := mset.insert(m); alt != nil {
+			switch alt.(type) {
+			case *Var:
+				check.errorf(m.pos, "field and method with the same name %s", m.name)
+			case *Func:
+				check.errorf(m.pos, "method %s already declared for %s", m.name, obj)
+			default:
+				unreachable()
+			}
+			check.reportAltDecl(alt)
+			continue
+		}
+
+		if base != nil {
+			base.methods = append(base.methods, m)
+		}
+	}
+}
+
+func (check *Checker) funcDecl(obj *Func, decl *declInfo) {
+	assert(obj.typ == nil)
+
+	// func declarations cannot use iota
+	assert(check.iota == nil)
+
+	sig := new(Signature)
+	obj.typ = sig // guard against cycles
+
+	// Avoid cycle error when referring to method while type-checking the signature.
+	// This avoids a nuisance in the best case (non-parameterized receiver type) and
+	// since the method is not a type, we get an error. If we have a parameterized
+	// receiver type, instantiating the receiver type leads to the instantiation of
+	// its methods, and we don't want a cycle error in that case.
+	// TODO(gri) review if this is correct and/or whether we still need this?
+	saved := obj.color_
+	obj.color_ = black
+	fdecl := decl.fdecl
+	check.funcType(sig, fdecl.Recv, fdecl.TParamList, fdecl.Type)
+	obj.color_ = saved
+
+	// function body must be type-checked after global declarations
+	// (functions implemented elsewhere have no body)
+	if !check.conf.IgnoreFuncBodies && fdecl.Body != nil {
+		check.later(func() {
+			check.funcBody(decl, obj.name, sig, fdecl.Body, nil)
+		})
+	}
+}
+
+func (check *Checker) declStmt(list []syntax.Decl) {
+	pkg := check.pkg
+
+	first := -1                // index of first ConstDecl in the current group, or -1
+	var last *syntax.ConstDecl // last ConstDecl with init expressions, or nil
+	for index, decl := range list {
+		if _, ok := decl.(*syntax.ConstDecl); !ok {
+			first = -1 // we're not in a constant declaration
+		}
+
+		switch s := decl.(type) {
+		case *syntax.ConstDecl:
+			top := len(check.delayed)
+
+			// iota is the index of the current constDecl within the group
+			if first < 0 || list[index-1].(*syntax.ConstDecl).Group != s.Group {
+				first = index
+				last = nil
+			}
+			iota := constant.MakeInt64(int64(index - first))
+
+			// determine which initialization expressions to use
+			inherited := true
+			switch {
+			case s.Type != nil || s.Values != nil:
+				last = s
+				inherited = false
+			case last == nil:
+				last = new(syntax.ConstDecl) // make sure last exists
+				inherited = false
+			}
+
+			// declare all constants
+			lhs := make([]*Const, len(s.NameList))
+			values := unpackExpr(last.Values)
+			for i, name := range s.NameList {
+				obj := NewConst(name.Pos(), pkg, name.Value, nil, iota)
+				lhs[i] = obj
+
+				var init syntax.Expr
+				if i < len(values) {
+					init = values[i]
+				}
+
+				check.constDecl(obj, last.Type, init)
+			}
+
+			// Constants must always have init values.
+			check.arity(s.Pos(), s.NameList, values, true, inherited)
+
+			// process function literals in init expressions before scope changes
+			check.processDelayed(top)
+
+			// spec: "The scope of a constant or variable identifier declared
+			// inside a function begins at the end of the ConstSpec or VarSpec
+			// (ShortVarDecl for short variable declarations) and ends at the
+			// end of the innermost containing block."
+			scopePos := endPos(s)
+			for i, name := range s.NameList {
+				check.declare(check.scope, name, lhs[i], scopePos)
+			}
+
+		case *syntax.VarDecl:
+			top := len(check.delayed)
+
+			lhs0 := make([]*Var, len(s.NameList))
+			for i, name := range s.NameList {
+				lhs0[i] = NewVar(name.Pos(), pkg, name.Value, nil)
+			}
+
+			// initialize all variables
+			values := unpackExpr(s.Values)
+			for i, obj := range lhs0 {
+				var lhs []*Var
+				var init syntax.Expr
+				switch len(values) {
+				case len(s.NameList):
+					// lhs and rhs match
+					init = values[i]
+				case 1:
+					// rhs is expected to be a multi-valued expression
+					lhs = lhs0
+					init = values[0]
+				default:
+					if i < len(values) {
+						init = values[i]
+					}
+				}
+				check.varDecl(obj, lhs, s.Type, init)
+				if len(values) == 1 {
+					// If we have a single lhs variable we are done either way.
+					// If we have a single rhs expression, it must be a multi-
+					// valued expression, in which case handling the first lhs
+					// variable will cause all lhs variables to have a type
+					// assigned, and we are done as well.
+					if debug {
+						for _, obj := range lhs0 {
+							assert(obj.typ != nil)
+						}
+					}
+					break
+				}
+			}
+
+			// If we have no type, we must have values.
+			if s.Type == nil || values != nil {
+				check.arity(s.Pos(), s.NameList, values, false, false)
+			}
+
+			// process function literals in init expressions before scope changes
+			check.processDelayed(top)
+
+			// declare all variables
+			// (only at this point are the variable scopes (parents) set)
+			scopePos := endPos(s) // see constant declarations
+			for i, name := range s.NameList {
+				// see constant declarations
+				check.declare(check.scope, name, lhs0[i], scopePos)
+			}
+
+		case *syntax.TypeDecl:
+			obj := NewTypeName(s.Name.Pos(), pkg, s.Name.Value, nil)
+			// spec: "The scope of a type identifier declared inside a function
+			// begins at the identifier in the TypeSpec and ends at the end of
+			// the innermost containing block."
+			scopePos := s.Name.Pos()
+			check.declare(check.scope, s.Name, obj, scopePos)
+			// mark and unmark type before calling typeDecl; its type is still nil (see Checker.objDecl)
+			obj.setColor(grey + color(check.push(obj)))
+			check.typeDecl(obj, s, nil)
+			check.pop().setColor(black)
+
+		default:
+			check.invalidASTf(s, "unknown syntax.Decl node %T", s)
+		}
+	}
+}
diff --git a/src/cmd/compile/internal/types2/errors.go b/src/cmd/compile/internal/types2/errors.go
new file mode 100644
index 0000000000..5211439f89
--- /dev/null
+++ b/src/cmd/compile/internal/types2/errors.go
@@ -0,0 +1,159 @@
+// UNREVIEWED
+// Copyright 2012 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.
+
+// This file implements various error reporters.
+
+package types2
+
+import (
+	"cmd/compile/internal/syntax"
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+func unimplemented() {
+	panic("unimplemented")
+}
+
+func assert(p bool) {
+	if !p {
+		panic("assertion failed")
+	}
+}
+
+func unreachable() {
+	panic("unreachable")
+}
+
+func (check *Checker) qualifier(pkg *Package) string {
+	// Qualify the package unless it's the package being type-checked.
+	if pkg != check.pkg {
+		// If the same package name was used by multiple packages, display the full path.
+		if check.pkgCnt[pkg.name] > 1 {
+			return strconv.Quote(pkg.path)
+		}
+		return pkg.name
+	}
+	return ""
+}
+
+func (check *Checker) sprintf(format string, args ...interface{}) string {
+	for i, arg := range args {
+		switch a := arg.(type) {
+		case nil:
+			arg = "<nil>"
+		case operand:
+			panic("internal error: should always pass *operand")
+		case *operand:
+			arg = operandString(a, check.qualifier)
+		case syntax.Pos:
+			arg = a.String()
+		case syntax.Expr:
+			arg = ExprString(a)
+		case Object:
+			arg = ObjectString(a, check.qualifier)
+		case Type:
+			arg = TypeString(a, check.qualifier)
+		}
+		args[i] = arg
+	}
+	return fmt.Sprintf(format, args...)
+}
+
+func (check *Checker) trace(pos syntax.Pos, format string, args ...interface{}) {
+	fmt.Printf("%s:\t%s%s\n",
+		pos,
+		strings.Repeat(".  ", check.indent),
+		check.sprintf(format, args...),
+	)
+}
+
+// dump is only needed for debugging
+func (check *Checker) dump(format string, args ...interface{}) {
+	fmt.Println(check.sprintf(format, args...))
+}
+
+func (check *Checker) err(pos syntax.Pos, msg string, soft bool) {
+	// Cheap trick: Don't report errors with messages containing
+	// "invalid operand" or "invalid type" as those tend to be
+	// follow-on errors which don't add useful information. Only
+	// exclude them if these strings are not at the beginning,
+	// and only if we have at least one error already reported.
+	if check.firstErr != nil && (strings.Index(msg, "invalid operand") > 0 || strings.Index(msg, "invalid type") > 0) {
+		return
+	}
+
+	err := Error{pos, stripAnnotations(msg), msg, soft}
+	if check.firstErr == nil {
+		check.firstErr = err
+	}
+
+	if check.conf.Trace {
+		check.trace(pos, "ERROR: %s", msg)
+	}
+
+	f := check.conf.Error
+	if f == nil {
+		panic(bailout{}) // report only first error
+	}
+	f(err)
+}
+
+type poser interface {
+	Pos() syntax.Pos
+}
+
+func (check *Checker) error(at poser, msg string) {
+	check.err(posFor(at), msg, false)
+}
+
+func (check *Checker) errorf(at poser, format string, args ...interface{}) {
+	check.err(posFor(at), check.sprintf(format, args...), false)
+}
+
+func (check *Checker) softErrorf(at poser, format string, args ...interface{}) {
+	check.err(posFor(at), check.sprintf(format, args...), true)
+}
+
+func (check *Checker) invalidASTf(at poser, format string, args ...interface{}) {
+	check.errorf(at, "invalid AST: "+format, args...)
+}
+
+func (check *Checker) invalidArgf(at poser, format string, args ...interface{}) {
+	check.errorf(at, "invalid argument: "+format, args...)
+}
+
+func (check *Checker) invalidOpf(at poser, format string, args ...interface{}) {
+	check.errorf(at, "invalid operation: "+format, args...)
+}
+
+// posFor reports the left (= start) position of at.
+func posFor(at poser) syntax.Pos {
+	switch x := at.(type) {
+	case *operand:
+		if x.expr != nil {
+			return startPos(x.expr)
+		}
+	case syntax.Node:
+		return startPos(x)
+	}
+	return at.Pos()
+}
+
+// stripAnnotations removes internal (type) annotations from s.
+func stripAnnotations(s string) string {
+	var b strings.Builder
+	for _, r := range s {
+		// strip #'s and subscript digits
+		if r != instanceMarker && !('₀' <= r && r < '₀'+10) { // '₀' == U+2080
+			b.WriteRune(r)
+		}
+	}
+	if b.Len() < len(s) {
+		return b.String()
+	}
+	return s
+}
diff --git a/src/cmd/compile/internal/types2/errors_test.go b/src/cmd/compile/internal/types2/errors_test.go
new file mode 100644
index 0000000000..51ae5fdb73
--- /dev/null
+++ b/src/cmd/compile/internal/types2/errors_test.go
@@ -0,0 +1,26 @@
+// UNREVIEWED
+// Copyright 2020 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 types2
+
+import "testing"
+
+func TestStripAnnotations(t *testing.T) {
+	for _, test := range []struct {
+		in, want string
+	}{
+		{"", ""},
+		{"   ", "   "},
+		{"foo", "foo"},
+		{"foo₀", "foo"},
+		{"foo(T₀)", "foo(T)"},
+		{"#foo(T₀)", "foo(T)"},
+	} {
+		got := stripAnnotations(test.in)
+		if got != test.want {
+			t.Errorf("%q: got %q; want %q", test.in, got, test.want)
+		}
+	}
+}
diff --git a/src/cmd/compile/internal/types2/example_test.go b/src/cmd/compile/internal/types2/example_test.go
new file mode 100644
index 0000000000..dcdeaca0c0
--- /dev/null
+++ b/src/cmd/compile/internal/types2/example_test.go
@@ -0,0 +1,324 @@
+// UNREVIEWED
+// Copyright 2015 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.
+
+// Only run where builders (build.golang.org) have
+// access to compiled packages for import.
+//
+// +build !arm,!arm64
+
+package types2_test
+
+// This file shows examples of basic usage of the go/types API.
+//
+// To locate a Go package, use (*go/build.Context).Import.
+// To load, parse, and type-check a complete Go program
+// from source, use golang.org/x/tools/go/loader.
+
+import (
+	"bytes"
+	"cmd/compile/internal/syntax"
+	"cmd/compile/internal/types2"
+	"fmt"
+	"log"
+	"regexp"
+	"sort"
+	"strings"
+)
+
+// ExampleScope prints the tree of Scopes of a package created from a
+// set of parsed files.
+func ExampleScope() {
+	// Parse the source files for a package.
+	var files []*syntax.File
+	for _, file := range []struct{ name, input string }{
+		{"main.go", `
+package main
+import "fmt"
+func main() {
+	freezing := FToC(-18)
+	fmt.Println(freezing, Boiling) }
+`},
+		{"celsius.go", `
+package main
+import "fmt"
+type Celsius float64
+func (c Celsius) String() string { return fmt.Sprintf("%g°C", c) }
+func FToC(f float64) Celsius { return Celsius(f - 32 / 9 * 5) }
+const Boiling Celsius = 100
+func Unused() { {}; {{ var x int; _ = x }} } // make sure empty block scopes get printed
+`},
+	} {
+		f, err := parseSrc(file.name, file.input)
+		if err != nil {
+			log.Fatal(err)
+		}
+		files = append(files, f)
+	}
+
+	// Type-check a package consisting of these files.
+	// Type information for the imported "fmt" package
+	// comes from $GOROOT/pkg/$GOOS_$GOOARCH/fmt.a.
+	conf := types2.Config{Importer: defaultImporter()}
+	pkg, err := conf.Check("temperature", files, nil)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Print the tree of scopes.
+	// For determinism, we redact addresses.
+	var buf bytes.Buffer
+	pkg.Scope().WriteTo(&buf, 0, true)
+	rx := regexp.MustCompile(` 0x[a-fA-F0-9]*`)
+	fmt.Println(rx.ReplaceAllString(buf.String(), ""))
+
+	// Output:
+	// package "temperature" scope {
+	// .  const temperature.Boiling temperature.Celsius
+	// .  type temperature.Celsius float64
+	// .  func temperature.FToC(f float64) temperature.Celsius
+	// .  func temperature.Unused()
+	// .  func temperature.main()
+	// .  main.go scope {
+	// .  .  package fmt
+	// .  .  function scope {
+	// .  .  .  var freezing temperature.Celsius
+	// .  .  }
+	// .  }
+	// .  celsius.go scope {
+	// .  .  package fmt
+	// .  .  function scope {
+	// .  .  .  var c temperature.Celsius
+	// .  .  }
+	// .  .  function scope {
+	// .  .  .  var f float64
+	// .  .  }
+	// .  .  function scope {
+	// .  .  .  block scope {
+	// .  .  .  }
+	// .  .  .  block scope {
+	// .  .  .  .  block scope {
+	// .  .  .  .  .  var x int
+	// .  .  .  .  }
+	// .  .  .  }
+	// .  .  }
+	// .  }
+	// }
+}
+
+// ExampleMethodSet prints the method sets of various types.
+func ExampleMethodSet() {
+	// Parse a single source file.
+	const input = `
+package temperature
+import "fmt"
+type Celsius float64
+func (c Celsius) String() string  { return fmt.Sprintf("%g°C", c) }
+func (c *Celsius) SetF(f float64) { *c = Celsius(f - 32 / 9 * 5) }
+
+type S struct { I; m int }
+type I interface { m() byte }
+`
+	f, err := parseSrc("celsius.go", input)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Type-check a package consisting of this file.
+	// Type information for the imported packages
+	// comes from $GOROOT/pkg/$GOOS_$GOOARCH/fmt.a.
+	conf := types2.Config{Importer: defaultImporter()}
+	pkg, err := conf.Check("temperature", []*syntax.File{f}, nil)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Print the method sets of Celsius and *Celsius.
+	celsius := pkg.Scope().Lookup("Celsius").Type()
+	for _, t := range []types2.Type{celsius, types2.NewPointer(celsius)} {
+		fmt.Printf("Method set of %s:\n", t)
+		mset := types2.NewMethodSet(t)
+		for i := 0; i < mset.Len(); i++ {
+			fmt.Println(mset.At(i))
+		}
+		fmt.Println()
+	}
+
+	// Print the method set of S.
+	styp := pkg.Scope().Lookup("S").Type()
+	fmt.Printf("Method set of %s:\n", styp)
+	fmt.Println(types2.NewMethodSet(styp))
+
+	// Output:
+	// Method set of temperature.Celsius:
+	// method (temperature.Celsius) String() string
+	//
+	// Method set of *temperature.Celsius:
+	// method (*temperature.Celsius) SetF(f float64)
+	// method (*temperature.Celsius) String() string
+	//
+	// Method set of temperature.S:
+	// MethodSet {}
+}
+
+// ExampleInfo prints various facts recorded by the type checker in a
+// types2.Info struct: definitions of and references to each named object,
+// and the type, value, and mode of every expression in the package.
+func ExampleInfo() {
+	// Parse a single source file.
+	const input = `
+package fib
+
+type S string
+
+var a, b, c = len(b), S(c), "hello"
+
+func fib(x int) int {
+	if x < 2 {
+		return x
+	}
+	return fib(x-1) - fib(x-2)
+}`
+	f, err := parseSrc("fib.go", input)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Type-check the package.
+	// We create an empty map for each kind of input
+	// we're interested in, and Check populates them.
+	info := types2.Info{
+		Types: make(map[syntax.Expr]types2.TypeAndValue),
+		Defs:  make(map[*syntax.Name]types2.Object),
+		Uses:  make(map[*syntax.Name]types2.Object),
+	}
+	var conf types2.Config
+	pkg, err := conf.Check("fib", []*syntax.File{f}, &info)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Print package-level variables in initialization order.
+	fmt.Printf("InitOrder: %v\n\n", info.InitOrder)
+
+	// For each named object, print the line and
+	// column of its definition and each of its uses.
+	fmt.Println("Defs and Uses of each named object:")
+	usesByObj := make(map[types2.Object][]string)
+	for id, obj := range info.Uses {
+		posn := id.Pos()
+		lineCol := fmt.Sprintf("%d:%d", posn.Line(), posn.Col())
+		usesByObj[obj] = append(usesByObj[obj], lineCol)
+	}
+	var items []string
+	for obj, uses := range usesByObj {
+		sort.Strings(uses)
+		item := fmt.Sprintf("%s:\n  defined at %s\n  used at %s",
+			types2.ObjectString(obj, types2.RelativeTo(pkg)),
+			obj.Pos(),
+			strings.Join(uses, ", "))
+		items = append(items, item)
+	}
+	sort.Strings(items) // sort by line:col, in effect
+	fmt.Println(strings.Join(items, "\n"))
+	fmt.Println()
+
+	// TODO(gri) Enable once positions are updated/verified
+	// fmt.Println("Types and Values of each expression:")
+	// items = nil
+	// for expr, tv := range info.Types {
+	// 	var buf bytes.Buffer
+	// 	posn := expr.Pos()
+	// 	tvstr := tv.Type.String()
+	// 	if tv.Value != nil {
+	// 		tvstr += " = " + tv.Value.String()
+	// 	}
+	// 	// line:col | expr | mode : type = value
+	// 	fmt.Fprintf(&buf, "%2d:%2d | %-19s | %-7s : %s",
+	// 		posn.Line(), posn.Col(), types2.ExprString(expr),
+	// 		mode(tv), tvstr)
+	// 	items = append(items, buf.String())
+	// }
+	// sort.Strings(items)
+	// fmt.Println(strings.Join(items, "\n"))
+
+	// Output:
+	// InitOrder: [c = "hello" b = S(c) a = len(b)]
+	//
+	// Defs and Uses of each named object:
+	// builtin len:
+	//   defined at <unknown position>
+	//   used at 6:15
+	// func fib(x int) int:
+	//   defined at fib.go:8:6
+	//   used at 12:20, 12:9
+	// type S string:
+	//   defined at fib.go:4:6
+	//   used at 6:23
+	// type int:
+	//   defined at <unknown position>
+	//   used at 8:12, 8:17
+	// type string:
+	//   defined at <unknown position>
+	//   used at 4:8
+	// var b S:
+	//   defined at fib.go:6:8
+	//   used at 6:19
+	// var c string:
+	//   defined at fib.go:6:11
+	//   used at 6:25
+	// var x int:
+	//   defined at fib.go:8:10
+	//   used at 10:10, 12:13, 12:24, 9:5
+
+	// TODO(gri) Enable once positions are updated/verified
+	// Types and Values of each expression:
+	//  4: 8 | string              | type    : string
+	//  6:15 | len                 | builtin : func(string) int
+	//  6:15 | len(b)              | value   : int
+	//  6:19 | b                   | var     : fib.S
+	//  6:23 | S                   | type    : fib.S
+	//  6:23 | S(c)                | value   : fib.S
+	//  6:25 | c                   | var     : string
+	//  6:29 | "hello"             | value   : string = "hello"
+	//  8:12 | int                 | type    : int
+	//  8:17 | int                 | type    : int
+	//  9: 5 | x                   | var     : int
+	//  9: 5 | x < 2               | value   : untyped bool
+	//  9: 9 | 2                   | value   : int = 2
+	// 10:10 | x                   | var     : int
+	// 12: 9 | fib                 | value   : func(x int) int
+	// 12: 9 | fib(x - 1)          | value   : int
+	// 12: 9 | fib(x - 1) - fib(x - 2) | value   : int
+	// 12:13 | x                   | var     : int
+	// 12:13 | x - 1               | value   : int
+	// 12:15 | 1                   | value   : int = 1
+	// 12:20 | fib                 | value   : func(x int) int
+	// 12:20 | fib(x - 2)          | value   : int
+	// 12:24 | x                   | var     : int
+	// 12:24 | x - 2               | value   : int
+	// 12:26 | 2                   | value   : int = 2
+}
+
+func mode(tv types2.TypeAndValue) string {
+	switch {
+	case tv.IsVoid():
+		return "void"
+	case tv.IsType():
+		return "type"
+	case tv.IsBuiltin():
+		return "builtin"
+	case tv.IsNil():
+		return "nil"
+	case tv.Assignable():
+		if tv.Addressable() {
+			return "var"
+		}
+		return "mapindex"
+	case tv.IsValue():
+		return "value"
+	default:
+		return "unknown"
+	}
+}
diff --git a/src/cmd/compile/internal/types2/examples/functions.go2 b/src/cmd/compile/internal/types2/examples/functions.go2
new file mode 100644
index 0000000000..ab4c192c00
--- /dev/null
+++ b/src/cmd/compile/internal/types2/examples/functions.go2
@@ -0,0 +1,216 @@
+// UNREVIEWED
+// Copyright 2019 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.
+
+// This file shows some examples of type-parameterized functions.
+
+package p
+
+// Reverse is a generic function that takes a []T argument and
+// reverses that slice in place.
+func Reverse[T any](list []T) {
+	i := 0
+	j := len(list)-1
+	for i < j {
+		list[i], list[j] = list[j], list[i]
+		i++
+		j--
+	}
+}
+
+func _() {
+	// Reverse can be called with an explicit type argument.
+	Reverse[int](nil)
+	Reverse[string]([]string{"foo", "bar"})
+	Reverse[struct{x, y int}]([]struct{x, y int}{{1, 2}, {2, 3}, {3, 4}})
+
+	// Since the type parameter is used for an incoming argument,
+	// it can be inferred from the provided argument's type.
+	Reverse([]string{"foo", "bar"})
+	Reverse([]struct{x, y int}{{1, 2}, {2, 3}, {3, 4}})
+
+	// But the incoming argument must have a type, even if it's a
+	// default type. An untyped nil won't work.
+	// Reverse(nil) // this won't type-check
+
+	// A typed nil will work, though.
+	Reverse([]int(nil))
+}
+
+// Certain functions, such as the built-in `new` could be written using
+// type parameters.
+func new[T any]() *T {
+	var x T
+	return &x
+}
+
+// When calling our own `new`, we need to pass the type parameter
+// explicitly since there is no (value) argument from which the
+// result type could be inferred. We don't try to infer the
+// result type from the assignment to keep things simple and
+// easy to understand.
+var _ = new[int]()
+var _ *float64 = new[float64]() // the result type is indeed *float64
+
+// A function may have multiple type parameters, of course.
+func foo[A, B, C any](a A, b []B, c *C) B {
+	// do something here
+	return b[0]
+}
+
+// As before, we can pass type parameters explicitly.
+var s = foo[int, string, float64](1, []string{"first"}, new[float64]())
+
+// Or we can use type inference.
+var _ float64 = foo(42, []float64{1.0}, &s)
+
+// Type inference works in a straight-forward manner even
+// for variadic functions.
+func variadic[A, B any](A, B, ...B) int
+
+// var _ = variadic(1) // ERROR not enough arguments
+var _ = variadic(1, 2.3)
+var _ = variadic(1, 2.3, 3.4, 4.5)
+var _ = variadic[int, float64](1, 2.3, 3.4, 4)
+
+// Type inference also works in recursive function calls where
+// the inferred type is the type parameter of the caller.
+func f1[T any](x T) {
+	f1(x)
+}
+
+func f2a[T any](x, y T) {
+	f2a(x, y)
+}
+
+func f2b[T any](x, y T) {
+	f2b(y, x)
+}
+
+func g2a[P, Q any](x P, y Q) {
+	g2a(x, y)
+}
+
+func g2b[P, Q any](x P, y Q) {
+	g2b(y, x)
+}
+
+// Here's an example of a recursive function call with variadic
+// arguments and type inference inferring the type parameter of
+// the caller (i.e., itself).
+func max[T interface{ type int }](x ...T) T {
+	var x0 T
+	if len(x) > 0 {
+		x0 = x[0]
+	}
+	if len(x) > 1 {
+		x1 := max(x[1:]...)
+		if x1 > x0 {
+			return x1
+		}
+	}
+	return x0
+}
+
+// When inferring channel types, the channel direction is ignored
+// for the purpose of type inference. Once the type has been in-
+// fered, the usual parameter passing rules are applied.
+// Thus even if a type can be inferred successfully, the function
+// call may not be valid.
+
+func fboth[T any](chan T)
+func frecv[T any](<-chan T)
+func fsend[T any](chan<- T)
+
+func _() {
+	var both chan int
+	var recv <-chan int
+	var send chan<-int
+
+	fboth(both)
+	fboth(recv /* ERROR cannot use */ )
+	fboth(send /* ERROR cannot use */ )
+
+	frecv(both)
+	frecv(recv)
+	frecv(send /* ERROR cannot use */ )
+
+	fsend(both)
+	fsend(recv /* ERROR cannot use */)
+	fsend(send)
+}
+
+func ffboth[T any](func(chan T))
+func ffrecv[T any](func(<-chan T))
+func ffsend[T any](func(chan<- T))
+
+func _() {
+	var both func(chan int)
+	var recv func(<-chan int)
+	var send func(chan<- int)
+
+	ffboth(both)
+	ffboth(recv /* ERROR cannot use */ )
+	ffboth(send /* ERROR cannot use */ )
+
+	ffrecv(both /* ERROR cannot use */ )
+	ffrecv(recv)
+	ffrecv(send /* ERROR cannot use */ )
+
+	ffsend(both /* ERROR cannot use */ )
+	ffsend(recv /* ERROR cannot use */ )
+	ffsend(send)
+}
+
+// When inferring elements of unnamed composite parameter types,
+// if the arguments are defined types, use their underlying types.
+// Even though the matching types are not exactly structurally the
+// same (one is a type literal, the other a named type), because
+// assignment is permitted, parameter passing is permitted as well,
+// so type inference should be able to handle these cases well.
+
+func g1[T any]([]T)
+func g2[T any]([]T, T)
+func g3[T any](*T, ...T)
+
+func _() {
+	type intSlize []int
+	g1([]int{})
+	g1(intSlize{})
+	g2(nil, 0)
+
+	type myString string
+	var s1 string
+	g3(nil, "1", myString("2"), "3")
+	g3(&s1, "1", myString /* ERROR does not match */ ("2"), "3")
+	_ = s1
+
+	type myStruct struct{x int}
+	var s2 myStruct
+	g3(nil, struct{x int}{}, myStruct{})
+	g3(&s2, struct{x int}{}, myStruct{})
+	g3(nil, myStruct{}, struct{x int}{})
+	g3(&s2, myStruct{}, struct{x int}{})
+}
+
+// Here's a realistic example.
+
+func append[T any](s []T, t ...T) []T
+
+func _() {
+	var f func()
+	type Funcs []func()
+	var funcs Funcs
+	_ = append(funcs, f)
+}
+
+// Generic type declarations cannot have empty type parameter lists
+// (that would indicate a slice type). Thus, generic functions cannot
+// have empty type parameter lists, either. This is a syntax error.
+
+func h[] /* ERROR empty type parameter list */ ()
+
+func _() {
+	h[] /* ERROR operand */ ()
+}
diff --git a/src/cmd/compile/internal/types2/examples/methods.go2 b/src/cmd/compile/internal/types2/examples/methods.go2
new file mode 100644
index 0000000000..52f835f80e
--- /dev/null
+++ b/src/cmd/compile/internal/types2/examples/methods.go2
@@ -0,0 +1,97 @@
+// UNREVIEWED
+// Copyright 2019 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.
+
+// This file shows some examples of methods on type-parameterized types.
+
+package p
+
+// Parameterized types may have methods.
+type T1[A any] struct{ a A }
+
+// When declaring a method for a parameterized type, the "instantiated"
+// receiver type acts as an implicit declaration of the type parameters
+// for the receiver type. In the example below, method m1 on type T1 has
+// the receiver type T1[A] which declares the type parameter A for use
+// with this method. That is, within the method m1, A stands for the
+// actual type argument provided to an instantiated T1.
+func (t T1[A]) m1() A { return t.a }
+
+// For instance, if T1 is instantiated with the type int, the type
+// parameter A in m1 assumes that type (int) as well and we can write
+// code like this:
+var x T1[int]
+var _ int = x.m1()
+
+// Because the type parameter provided to a parameterized receiver type
+// is declared through that receiver declaration, it must be an identifier.
+// It cannot possibly be some other type because the receiver type is not
+// instantiated with concrete types, it is standing for the parameterized
+// receiver type.
+func (t T1[[ /* ERROR must be an identifier */ ]int]) m2() {}
+
+// Note that using what looks like a predeclared identifier, say int,
+// as type parameter in this situation is deceptive and considered bad
+// style. In m3 below, int is the name of the local receiver type parameter
+// and it shadows the predeclared identifier int which then cannot be used
+// anymore as expected.
+// This is no different from locally redelaring a predeclared identifier
+// and usually should be avoided. There are some notable exceptions; e.g.,
+// sometimes it makes sense to use the identifier "copy" which happens to
+// also be the name of a predeclared built-in function.
+func (t T1[int]) m3() { var _ int = 42 /* ERROR cannot convert 42 .* to int */ }
+
+// The names of the type parameters used in a parameterized receiver
+// type don't have to match the type parameter names in the the declaration
+// of the type used for the receiver. In our example, even though T1 is
+// declared with type parameter named A, methods using that receiver type
+// are free to use their own name for that type parameter. That is, the
+// name of type parameters is always local to the declaration where they
+// are introduced. In our example we can write a method m2 and use the
+// name X instead of A for the type parameter w/o any difference.
+func (t T1[X]) m4() X { return t.a }
+
+// If the receiver type is parameterized, type parameters must always be
+// provided: this simply follows from the general rule that a parameterized
+// type must be instantiated before it can be used. A method receiver
+// declaration using a parameterized receiver type is no exception. It is
+// simply that such receiver type expressions perform two tasks simultaneously:
+// they declare the (local) type parameters and then use them to instantiate
+// the receiver type. Forgetting to provide a type parameter leads to an error.
+func (t T1 /* ERROR generic type .* without instantiation */ ) m5() {}
+
+// However, sometimes we don't need the type parameter, and thus it is
+// inconvenient to have to choose a name. Since the receiver type expression
+// serves as a declaration for its type parameters, we are free to choose the
+// blank identifier:
+func (t T1[_]) m6() {}
+
+// Naturally, these rules apply to any number of type parameters on the receiver
+// type. Here are some more complex examples.
+type T2[A, B, C any] struct {
+        a A
+        b B
+        c C
+}
+
+// Naming of the type parameters is local and has no semantic impact:
+func (t T2[A, B, C]) m1() (A, B, C) { return t.a, t.b, t.c }
+func (t T2[C, B, A]) m2() (C, B, A) { return t.a, t.b, t.c }
+func (t T2[X, Y, Z]) m3() (X, Y, Z) { return t.a, t.b, t.c }
+
+// Type parameters may be left blank if they are not needed:
+func (t T2[A, _, C]) m4() (A, C) { return t.a, t.c }
+func (t T2[_, _, X]) m5() X { return t.c }
+func (t T2[_, _, _]) m6() {}
+
+// As usual, blank names may be used for any object which we don't care about
+// using later. For instance, we may write an unnamed method with a receiver
+// that cannot be accessed:
+func (_ T2[_, _, _]) _() int { return 42 }
+
+// Because a receiver parameter list is simply a parameter list, we can
+// leave the receiver argument away for receiver types.
+type T0 struct{}
+func (T0) _() {}
+func (T1[A]) _() {}
diff --git a/src/cmd/compile/internal/types2/examples/types.go2 b/src/cmd/compile/internal/types2/examples/types.go2
new file mode 100644
index 0000000000..be8d44e599
--- /dev/null
+++ b/src/cmd/compile/internal/types2/examples/types.go2
@@ -0,0 +1,261 @@
+// UNREVIEWED
+// Copyright 2019 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.
+
+// This file shows some examples of generic types.
+
+package p
+
+// List is just what it says - a slice of E elements.
+type List[E any] []E
+
+// A generic (parameterized) type must always be instantiated
+// before it can be used to designate the type of a variable
+// (including a struct field, or function parameter); though
+// for the latter cases, the provided type may be another type
+// parameter. So:
+var _ List[byte] = []byte{}
+
+// A generic binary tree might be declared as follows.
+type Tree[E any] struct {
+	left, right *Tree[E]
+	payload E
+}
+
+// A simple instantiation of Tree:
+var root1 Tree[int]
+
+// The actual type parameter provided may be a generic type itself:
+var root2 Tree[List[int]]
+
+// A couple of more complex examples.
+// We don't need extra parentheses around the element type of the slices on
+// the right (unlike when we use ()'s rather than []'s for type parameters).
+var _ List[List[int]] = []List[int]{}
+var _ List[List[List[Tree[int]]]] = []List[List[Tree[int]]]{}
+
+// Type parameters act like type aliases when used in generic types
+// in the sense that we can "emulate" a specific type instantiation
+// with type aliases.
+type T1[P any] struct {
+	f P
+}
+
+type T2[P any] struct {
+	f struct {
+		g P
+	}
+}
+
+var x1 T1[struct{ g int }]
+var x2 T2[int]
+
+func _() {
+	// This assignment is invalid because the types of x1, x2 are T1(...)
+	// and T2(...) respectively, which are two different defined types.
+	x1 = x2 // ERROR assignment
+
+	// This assignment is valid because the types of x1.f and x2.f are
+	// both struct { g int }; the type parameters act like type aliases
+	// and their actual names don't come into play here.
+	x1.f = x2.f
+}
+
+// We can verify this behavior using type aliases instead:
+type T1a struct {
+	f A1
+}
+type A1 = struct { g int }
+
+type T2a struct {
+	f struct {
+		g A2
+	}
+}
+type A2 = int
+
+var x1a T1a
+var x2a T2a
+
+func _() {
+	x1a = x2a // ERROR assignment
+	x1a.f = x2a.f
+}
+
+// Another interesting corner case are generic types that don't use
+// their type arguments. For instance:
+type T[P any] struct{}
+
+var xint T[int]
+var xbool T[bool]
+
+// Are these two variables of the same type? After all, their underlying
+// types are identical. We consider them to be different because each type
+// instantiation creates a new named type, in this case T<int> and T<bool>
+// even if their underlying types are identical. This is sensible because
+// we might still have methods that have different signatures or behave
+// differently depending on the type arguments, and thus we can't possibly
+// consider such types identical. Consequently:
+func _() {
+	xint = xbool // ERROR assignment
+}
+
+// Generic types cannot be used without instantiation.
+var _ T // ERROR cannot use generic type T
+
+// In type context, generic (parameterized) types cannot be parenthesized before
+// being instantiated. See also NOTES entry from 12/4/2019.
+var _ (T /* ERROR cannot use generic type T */ )[ /* ERROR unexpected \[ */ int]
+
+// All types may be parameterized, including interfaces.
+type I1[T any] interface{
+	m1(T)
+}
+
+// Generic interfaces may be embedded as one would expect.
+type I2 interface {
+	I1(int)     // method!
+	I1[string]  // embedded I1
+}
+
+func _() {
+	var x I2
+	x.I1(0)
+	x.m1("foo")
+}
+
+type I0 interface {
+	m0()
+}
+
+type I3 interface {
+	I0
+	I1[bool]
+	m(string)
+}
+
+func _() {
+	var x I3
+	x.m0()
+	x.m1(true)
+	x.m("foo")
+}
+
+type _ struct {
+	( /* ERROR cannot parenthesize */ int8)
+	( /* ERROR cannot parenthesize */ *int16)
+	*( /* ERROR cannot parenthesize */ int32)
+	List[int]
+
+	int8 /* ERROR int8 redeclared */
+	* /* ERROR int16 redeclared */ int16
+	List /* ERROR List redeclared */ [int]
+}
+
+// It's possible to declare local types whose underlying types
+// are type parameters. As with ordinary type definitions, the
+// types underlying properties are "inherited" but the methods
+// are not.
+func _[T interface{ m(); type int }]() {
+	type L T
+	var x L
+
+	// m is not defined on L (it is not "inherited" from
+	// its underlying type).
+	x.m /* ERROR x.m undefined */ ()
+
+	// But the properties of T, such that as that it supports
+	// the operations of the types given by its type bound,
+	// are also the properties of L.
+	x++
+	_ = x - x
+
+	// On the other hand, if we define a local alias for T,
+	// that alias stands for T as expected.
+	type A = T
+	var y A
+	y.m()
+	_ = y < 0
+}
+
+// As a special case, an explicit type argument may be omitted
+// from a type parameter bound if the type bound expects exactly
+// one type argument. In that case, the type argument is the
+// respective type parameter to which the type bound applies.
+// Note: We may not permit this syntactic sugar at first.
+// Note: This is now disabled. All examples below are adjusted.
+type Adder[T any] interface {
+	Add(T) T
+}
+
+// We don't need to explicitly instantiate the Adder bound
+// if we have exactly one type parameter.
+func Sum[T Adder[T]](list []T) T {
+	var sum T
+	for _, x := range list {
+		sum = sum.Add(x)
+	}
+	return sum
+}
+
+// Valid and invalid variations.
+type B0 interface {}
+type B1[_ any] interface{}
+type B2[_, _ any] interface{}
+
+func _[T1 B0]()
+func _[T1 B1[T1]]()
+func _[T1 B2 /* ERROR cannot use generic type .* without instantiation */ ]()
+
+func _[T1, T2 B0]()
+func _[T1 B1[T1], T2 B1[T2]]()
+func _[T1, T2 B2 /* ERROR cannot use generic type .* without instantiation */ ]()
+
+func _[T1 B0, T2 B1[T2]]() // here B1 applies to T2
+
+// When the type argument is left away, the type bound is
+// instantiated for each type parameter with that type
+// parameter.
+// Note: We may not permit this syntactic sugar at first.
+func _[A Adder[A], B Adder[B], C Adder[A]]() {
+	var a A // A's type bound is Adder[A]
+	a = a.Add(a)
+	var b B // B's type bound is Adder[B]
+	b = b.Add(b)
+	var c C // C's type bound is Adder[A]
+	a = c.Add(a)
+}
+
+// The type of variables (incl. parameters and return values) cannot
+// be an interface with type constraints or be/embed comparable.
+type I interface {
+	type int
+}
+
+var (
+	_ interface /* ERROR contains type constraints */ {type int}
+	_ I /* ERROR contains type constraints */
+)
+
+func _(I /* ERROR contains type constraints */ )
+func _(x, y, z I /* ERROR contains type constraints */ )
+func _() I /* ERROR contains type constraints */
+
+func _() {
+	var _ I /* ERROR contains type constraints */
+}
+
+type C interface {
+	comparable
+}
+
+var _ comparable /* ERROR comparable */
+var _ C /* ERROR comparable */
+
+func _(_ comparable /* ERROR comparable */ , _ C /* ERROR comparable */ )
+
+func _() {
+	var _ comparable /* ERROR comparable */
+	var _ C /* ERROR comparable */
+}
\ No newline at end of file
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
new file mode 100644
index 0000000000..f83aa86f6e
--- /dev/null
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -0,0 +1,1906 @@
+// UNREVIEWED
+// Copyright 2012 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.
+
+// This file implements typechecking of expressions.
+
+package types2
+
+import (
+	"cmd/compile/internal/syntax"
+	"fmt"
+	"go/constant"
+	"go/token"
+	"math"
+)
+
+/*
+Basic algorithm:
+
+Expressions are checked recursively, top down. Expression checker functions
+are generally of the form:
+
+  func f(x *operand, e *syntax.Expr, ...)
+
+where e is the expression to be checked, and x is the result of the check.
+The check performed by f may fail in which case x.mode == invalid, and
+related error messages will have been issued by f.
+
+If a hint argument is present, it is the composite literal element type
+of an outer composite literal; it is used to type-check composite literal
+elements that have no explicit type specification in the source
+(e.g.: []T{{...}, {...}}, the hint is the type T in this case).
+
+All expressions are checked via rawExpr, which dispatches according
+to expression kind. Upon returning, rawExpr is recording the types and
+constant values for all expressions that have an untyped type (those types
+may change on the way up in the expression tree). Usually these are constants,
+but the results of comparisons or non-constant shifts of untyped constants
+may also be untyped, but not constant.
+
+Untyped expressions may eventually become fully typed (i.e., not untyped),
+typically when the value is assigned to a variable, or is used otherwise.
+The updateExprType method is used to record this final type and update
+the recorded types: the type-checked expression tree is again traversed down,
+and the new type is propagated as needed. Untyped constant expression values
+that become fully typed must now be representable by the full type (constant
+sub-expression trees are left alone except for their roots). This mechanism
+ensures that a client sees the actual (run-time) type an untyped value would
+have. It also permits type-checking of lhs shift operands "as if the shift
+were not present": when updateExprType visits an untyped lhs shift operand
+and assigns it it's final type, that type must be an integer type, and a
+constant lhs must be representable as an integer.
+
+When an expression gets its final type, either on the way out from rawExpr,
+on the way down in updateExprType, or at the end of the type checker run,
+the type (and constant value, if any) is recorded via Info.Types, if present.
+*/
+
+type opPredicates map[syntax.Operator]func(Type) bool
+
+var unaryOpPredicates = opPredicates{
+	syntax.Add: isNumeric,
+	syntax.Sub: isNumeric,
+	syntax.Xor: isInteger,
+	syntax.Not: isBoolean,
+}
+
+func (check *Checker) op(m opPredicates, x *operand, op syntax.Operator) bool {
+	if pred := m[op]; pred != nil {
+		if !pred(x.typ) {
+			check.invalidOpf(x, "operator %s not defined for %s", op, x)
+			return false
+		}
+	} else {
+		check.invalidASTf(x, "unknown operator %s", op)
+		return false
+	}
+	return true
+}
+
+func op2token(op syntax.Operator) token.Token {
+	switch op {
+	case syntax.Def: // :
+		unreachable()
+	case syntax.Not: // !
+		return token.NOT
+	case syntax.Recv: // <-
+		unreachable()
+
+	case syntax.OrOr: // ||
+		return token.LOR
+	case syntax.AndAnd: // &&
+		return token.LAND
+
+	case syntax.Eql: // ==
+		return token.EQL
+	case syntax.Neq: // !=
+		return token.NEQ
+	case syntax.Lss: // <
+		return token.LSS
+	case syntax.Leq: // <=
+		return token.LEQ
+	case syntax.Gtr: // >
+		return token.GTR
+	case syntax.Geq: // >=
+		return token.GEQ
+
+	case syntax.Add: // +
+		return token.ADD
+	case syntax.Sub: // -
+		return token.SUB
+	case syntax.Or: // |
+		return token.OR
+	case syntax.Xor: // ^
+		return token.XOR
+
+	case syntax.Mul: // *
+		return token.MUL
+	case syntax.Div: // /
+		return token.QUO
+	case syntax.Rem: // %
+		return token.REM
+	case syntax.And: // &
+		return token.AND
+	case syntax.AndNot: // &^
+		return token.AND_NOT
+	case syntax.Shl: // <<
+		return token.SHL
+	case syntax.Shr: // >>
+		return token.SHR
+	}
+
+	return token.ILLEGAL
+}
+
+// The unary expression e may be nil. It's passed in for better error messages only.
+func (check *Checker) unary(x *operand, e *syntax.Operation, op syntax.Operator) {
+	switch op {
+	case syntax.And:
+		// spec: "As an exception to the addressability
+		// requirement x may also be a composite literal."
+		if _, ok := unparen(x.expr).(*syntax.CompositeLit); !ok && x.mode != variable {
+			check.invalidOpf(x, "cannot take address of %s", x)
+			x.mode = invalid
+			return
+		}
+		x.mode = value
+		x.typ = &Pointer{base: x.typ}
+		return
+
+	case syntax.Recv:
+		typ := x.typ.Chan()
+		if typ == nil {
+			check.invalidOpf(x, "cannot receive from non-channel %s", x)
+			x.mode = invalid
+			return
+		}
+		if typ.dir == SendOnly {
+			check.invalidOpf(x, "cannot receive from send-only channel %s", x)
+			x.mode = invalid
+			return
+		}
+		x.mode = commaok
+		x.typ = typ.elem
+		check.hasCallOrRecv = true
+		return
+	}
+
+	if !check.op(unaryOpPredicates, x, op) {
+		x.mode = invalid
+		return
+	}
+
+	if x.mode == constant_ {
+		typ := x.typ.Basic()
+		var prec uint
+		if isUnsigned(typ) {
+			prec = uint(check.conf.sizeof(typ) * 8)
+		}
+		x.val = constant.UnaryOp(op2token(op), x.val, prec)
+		// Typed constants must be representable in
+		// their type after each constant operation.
+		if isTyped(typ) {
+			if e != nil {
+				x.expr = e // for better error message
+			}
+			check.representable(x, typ)
+		}
+		return
+	}
+
+	x.mode = value
+	// x.typ remains unchanged
+}
+
+func isShift(op syntax.Operator) bool {
+	return op == syntax.Shl || op == syntax.Shr
+}
+
+func isComparison(op syntax.Operator) bool {
+	// Note: tokens are not ordered well to make this much easier
+	switch op {
+	case syntax.Eql, syntax.Neq, syntax.Lss, syntax.Leq, syntax.Gtr, syntax.Geq:
+		return true
+	}
+	return false
+}
+
+func fitsFloat32(x constant.Value) bool {
+	f32, _ := constant.Float32Val(x)
+	f := float64(f32)
+	return !math.IsInf(f, 0)
+}
+
+func roundFloat32(x constant.Value) constant.Value {
+	f32, _ := constant.Float32Val(x)
+	f := float64(f32)
+	if !math.IsInf(f, 0) {
+		return constant.MakeFloat64(f)
+	}
+	return nil
+}
+
+func fitsFloat64(x constant.Value) bool {
+	f, _ := constant.Float64Val(x)
+	return !math.IsInf(f, 0)
+}
+
+func roundFloat64(x constant.Value) constant.Value {
+	f, _ := constant.Float64Val(x)
+	if !math.IsInf(f, 0) {
+		return constant.MakeFloat64(f)
+	}
+	return nil
+}
+
+// representableConst reports whether x can be represented as
+// value of the given basic type and for the configuration
+// provided (only needed for int/uint sizes).
+//
+// If rounded != nil, *rounded is set to the rounded value of x for
+// representable floating-point and complex values, and to an Int
+// value for integer values; it is left alone otherwise.
+// It is ok to provide the addressof the first argument for rounded.
+//
+// The check parameter may be nil if representableConst is invoked
+// (indirectly) through an exported API call (AssignableTo, ConvertibleTo)
+// because we don't need the Checker's config for those calls.
+func representableConst(x constant.Value, check *Checker, typ *Basic, rounded *constant.Value) bool {
+	if x.Kind() == constant.Unknown {
+		return true // avoid follow-up errors
+	}
+
+	var conf *Config
+	if check != nil {
+		conf = check.conf
+	}
+
+	switch {
+	case isInteger(typ):
+		x := constant.ToInt(x)
+		if x.Kind() != constant.Int {
+			return false
+		}
+		if rounded != nil {
+			*rounded = x
+		}
+		if x, ok := constant.Int64Val(x); ok {
+			switch typ.kind {
+			case Int:
+				var s = uint(conf.sizeof(typ)) * 8
+				return int64(-1)<<(s-1) <= x && x <= int64(1)<<(s-1)-1
+			case Int8:
+				const s = 8
+				return -1<<(s-1) <= x && x <= 1<<(s-1)-1
+			case Int16:
+				const s = 16
+				return -1<<(s-1) <= x && x <= 1<<(s-1)-1
+			case Int32:
+				const s = 32
+				return -1<<(s-1) <= x && x <= 1<<(s-1)-1
+			case Int64, UntypedInt:
+				return true
+			case Uint, Uintptr:
+				if s := uint(conf.sizeof(typ)) * 8; s < 64 {
+					return 0 <= x && x <= int64(1)<<s-1
+				}
+				return 0 <= x
+			case Uint8:
+				const s = 8
+				return 0 <= x && x <= 1<<s-1
+			case Uint16:
+				const s = 16
+				return 0 <= x && x <= 1<<s-1
+			case Uint32:
+				const s = 32
+				return 0 <= x && x <= 1<<s-1
+			case Uint64:
+				return 0 <= x
+			default:
+				unreachable()
+			}
+		}
+		// x does not fit into int64
+		switch n := constant.BitLen(x); typ.kind {
+		case Uint, Uintptr:
+			var s = uint(conf.sizeof(typ)) * 8
+			return constant.Sign(x) >= 0 && n <= int(s)
+		case Uint64:
+			return constant.Sign(x) >= 0 && n <= 64
+		case UntypedInt:
+			return true
+		}
+
+	case isFloat(typ):
+		x := constant.ToFloat(x)
+		if x.Kind() != constant.Float {
+			return false
+		}
+		switch typ.kind {
+		case Float32:
+			if rounded == nil {
+				return fitsFloat32(x)
+			}
+			r := roundFloat32(x)
+			if r != nil {
+				*rounded = r
+				return true
+			}
+		case Float64:
+			if rounded == nil {
+				return fitsFloat64(x)
+			}
+			r := roundFloat64(x)
+			if r != nil {
+				*rounded = r
+				return true
+			}
+		case UntypedFloat:
+			return true
+		default:
+			unreachable()
+		}
+
+	case isComplex(typ):
+		x := constant.ToComplex(x)
+		if x.Kind() != constant.Complex {
+			return false
+		}
+		switch typ.kind {
+		case Complex64:
+			if rounded == nil {
+				return fitsFloat32(constant.Real(x)) && fitsFloat32(constant.Imag(x))
+			}
+			re := roundFloat32(constant.Real(x))
+			im := roundFloat32(constant.Imag(x))
+			if re != nil && im != nil {
+				*rounded = constant.BinaryOp(re, token.ADD, constant.MakeImag(im))
+				return true
+			}
+		case Complex128:
+			if rounded == nil {
+				return fitsFloat64(constant.Real(x)) && fitsFloat64(constant.Imag(x))
+			}
+			re := roundFloat64(constant.Real(x))
+			im := roundFloat64(constant.Imag(x))
+			if re != nil && im != nil {
+				*rounded = constant.BinaryOp(re, token.ADD, constant.MakeImag(im))
+				return true
+			}
+		case UntypedComplex:
+			return true
+		default:
+			unreachable()
+		}
+
+	case isString(typ):
+		return x.Kind() == constant.String
+
+	case isBoolean(typ):
+		return x.Kind() == constant.Bool
+	}
+
+	return false
+}
+
+// representable checks that a constant operand is representable in the given basic type.
+func (check *Checker) representable(x *operand, typ *Basic) {
+	assert(x.mode == constant_)
+	if !representableConst(x.val, check, typ, &x.val) {
+		var msg string
+		if isNumeric(x.typ) && isNumeric(typ) {
+			// numeric conversion : error msg
+			//
+			// integer -> integer : overflows
+			// integer -> float   : overflows (actually not possible)
+			// float   -> integer : truncated
+			// float   -> float   : overflows
+			//
+			if !isInteger(x.typ) && isInteger(typ) {
+				msg = "%s truncated to %s"
+			} else {
+				msg = "%s overflows %s"
+			}
+		} else {
+			msg = "cannot convert %s to %s"
+		}
+		check.errorf(x, msg, x, typ)
+		x.mode = invalid
+	}
+}
+
+// updateExprType updates the type of x to typ and invokes itself
+// recursively for the operands of x, depending on expression kind.
+// If typ is still an untyped and not the final type, updateExprType
+// only updates the recorded untyped type for x and possibly its
+// operands. Otherwise (i.e., typ is not an untyped type anymore,
+// or it is the final type for x), the type and value are recorded.
+// Also, if x is a constant, it must be representable as a value of typ,
+// and if x is the (formerly untyped) lhs operand of a non-constant
+// shift, it must be an integer value.
+//
+func (check *Checker) updateExprType(x syntax.Expr, typ Type, final bool) {
+	old, found := check.untyped[x]
+	if !found {
+		return // nothing to do
+	}
+
+	// update operands of x if necessary
+	switch x := x.(type) {
+	case *syntax.BadExpr,
+		*syntax.FuncLit,
+		*syntax.CompositeLit,
+		*syntax.IndexExpr,
+		*syntax.SliceExpr,
+		*syntax.AssertExpr,
+		//*syntax.StarExpr,
+		*syntax.KeyValueExpr,
+		*syntax.ArrayType,
+		*syntax.StructType,
+		*syntax.FuncType,
+		*syntax.InterfaceType,
+		*syntax.MapType,
+		*syntax.ChanType:
+		// These expression are never untyped - nothing to do.
+		// The respective sub-expressions got their final types
+		// upon assignment or use.
+		if debug {
+			check.dump("%v: found old type(%s): %s (new: %s)", posFor(x), x, old.typ, typ)
+			unreachable()
+		}
+		return
+
+	case *syntax.CallExpr:
+		// Resulting in an untyped constant (e.g., built-in complex).
+		// The respective calls take care of calling updateExprType
+		// for the arguments if necessary.
+
+	case *syntax.Name, *syntax.BasicLit, *syntax.SelectorExpr:
+		// An identifier denoting a constant, a constant literal,
+		// or a qualified identifier (imported untyped constant).
+		// No operands to take care of.
+
+	case *syntax.ParenExpr:
+		check.updateExprType(x.X, typ, final)
+
+	// case *syntax.UnaryExpr:
+	// 	// If x is a constant, the operands were constants.
+	// 	// The operands don't need to be updated since they
+	// 	// never get "materialized" into a typed value. If
+	// 	// left in the untyped map, they will be processed
+	// 	// at the end of the type check.
+	// 	if old.val != nil {
+	// 		break
+	// 	}
+	// 	check.updateExprType(x.X, typ, final)
+
+	case *syntax.Operation:
+		if x.Y == nil {
+			// unary expression
+			if x.Op == syntax.Mul {
+				// see commented out code for StarExpr above
+				// TODO(gri) needs cleanup
+				if debug {
+					unimplemented()
+				}
+				return
+			}
+			// If x is a constant, the operands were constants.
+			// The operands don't need to be updated since they
+			// never get "materialized" into a typed value. If
+			// left in the untyped map, they will be processed
+			// at the end of the type check.
+			if old.val != nil {
+				break
+			}
+			check.updateExprType(x.X, typ, final)
+			break
+		}
+
+		// binary expression
+		if old.val != nil {
+			break // see comment for unary expressions
+		}
+		if isComparison(x.Op) {
+			// The result type is independent of operand types
+			// and the operand types must have final types.
+		} else if isShift(x.Op) {
+			// The result type depends only on lhs operand.
+			// The rhs type was updated when checking the shift.
+			check.updateExprType(x.X, typ, final)
+		} else {
+			// The operand types match the result type.
+			check.updateExprType(x.X, typ, final)
+			check.updateExprType(x.Y, typ, final)
+		}
+
+	default:
+		unreachable()
+	}
+
+	// If the new type is not final and still untyped, just
+	// update the recorded type.
+	if !final && isUntyped(typ) {
+		old.typ = typ.Basic()
+		check.untyped[x] = old
+		return
+	}
+
+	// Otherwise we have the final (typed or untyped type).
+	// Remove it from the map of yet untyped expressions.
+	delete(check.untyped, x)
+
+	if old.isLhs {
+		// If x is the lhs of a shift, its final type must be integer.
+		// We already know from the shift check that it is representable
+		// as an integer if it is a constant.
+		if !isInteger(typ) {
+			check.invalidOpf(x, "shifted operand %s (type %s) must be integer", x, typ)
+			return
+		}
+		// Even if we have an integer, if the value is a constant we
+		// still must check that it is representable as the specific
+		// int type requested (was issue #22969). Fall through here.
+	}
+	if old.val != nil {
+		// If x is a constant, it must be representable as a value of typ.
+		c := operand{old.mode, x, old.typ, old.val, 0}
+		check.convertUntyped(&c, typ)
+		if c.mode == invalid {
+			return
+		}
+	}
+
+	// Everything's fine, record final type and value for x.
+	check.recordTypeAndValue(x, old.mode, typ, old.val)
+}
+
+// updateExprVal updates the value of x to val.
+func (check *Checker) updateExprVal(x syntax.Expr, val constant.Value) {
+	if info, ok := check.untyped[x]; ok {
+		info.val = val
+		check.untyped[x] = info
+	}
+}
+
+// convertUntyped attempts to set the type of an untyped value to the target type.
+func (check *Checker) convertUntyped(x *operand, target Type) {
+	target = expand(target)
+	if x.mode == invalid || isTyped(x.typ) || target == Typ[Invalid] {
+		return
+	}
+
+	// TODO(gri) Sloppy code - clean up. This function is central
+	//           to assignment and expression checking.
+
+	if isUntyped(target) {
+		// both x and target are untyped
+		xkind := x.typ.(*Basic).kind
+		tkind := target.(*Basic).kind
+		if isNumeric(x.typ) && isNumeric(target) {
+			if xkind < tkind {
+				x.typ = target
+				check.updateExprType(x.expr, target, false)
+			}
+		} else if xkind != tkind {
+			goto Error
+		}
+		return
+	}
+
+	// In case of a type parameter, conversion must succeed against
+	// all types enumerated by the type parameter bound.
+	// TODO(gri) We should not need this because we have the code
+	// for Sum types in convertUntypedInternal. But at least one
+	// test fails. Investigate.
+	if t := target.TypeParam(); t != nil {
+		types := t.Bound().allTypes
+		if types == nil {
+			goto Error
+		}
+
+		for _, t := range unpack(types) {
+			check.convertUntypedInternal(x, t)
+			if x.mode == invalid {
+				goto Error
+			}
+		}
+
+		// keep nil untyped (was bug #39755)
+		if x.isNil() {
+			target = Typ[UntypedNil]
+		}
+		x.typ = target
+		check.updateExprType(x.expr, target, true) // UntypedNils are final
+		return
+	}
+
+	check.convertUntypedInternal(x, target)
+	return
+
+Error:
+	// TODO(gri) better error message (explain cause)
+	check.errorf(x, "cannot convert %s to %s", x, target)
+	x.mode = invalid
+}
+
+// convertUntypedInternal should only be called by convertUntyped.
+func (check *Checker) convertUntypedInternal(x *operand, target Type) {
+	assert(isTyped(target))
+
+	// typed target
+	switch t := optype(target.Under()).(type) {
+	case *Basic:
+		if x.mode == constant_ {
+			check.representable(x, t)
+			if x.mode == invalid {
+				return
+			}
+			// expression value may have been rounded - update if needed
+			check.updateExprVal(x.expr, x.val)
+		} else {
+			// Non-constant untyped values may appear as the
+			// result of comparisons (untyped bool), intermediate
+			// (delayed-checked) rhs operands of shifts, and as
+			// the value nil.
+			switch x.typ.(*Basic).kind {
+			case UntypedBool:
+				if !isBoolean(target) {
+					goto Error
+				}
+			case UntypedInt, UntypedRune, UntypedFloat, UntypedComplex:
+				if !isNumeric(target) {
+					goto Error
+				}
+			case UntypedString:
+				// Non-constant untyped string values are not
+				// permitted by the spec and should not occur.
+				unreachable()
+			case UntypedNil:
+				// Unsafe.Pointer is a basic type that includes nil.
+				if !hasNil(target) {
+					goto Error
+				}
+			default:
+				goto Error
+			}
+		}
+	case *Sum:
+		t.is(func(t Type) bool {
+			check.convertUntypedInternal(x, t)
+			return x.mode != invalid
+		})
+	case *Interface:
+		// Update operand types to the default type rather then
+		// the target (interface) type: values must have concrete
+		// dynamic types. If the value is nil, keep it untyped
+		// (this is important for tools such as go vet which need
+		// the dynamic type for argument checking of say, print
+		// functions)
+		if x.isNil() {
+			target = Typ[UntypedNil]
+		} else {
+			// cannot assign untyped values to non-empty interfaces
+			check.completeInterface(nopos, t)
+			if !t.Empty() {
+				goto Error
+			}
+			target = Default(x.typ)
+		}
+	case *Pointer, *Signature, *Slice, *Map, *Chan:
+		if !x.isNil() {
+			goto Error
+		}
+		// keep nil untyped - see comment for interfaces, above
+		target = Typ[UntypedNil]
+	default:
+		goto Error
+	}
+
+	x.typ = target
+	check.updateExprType(x.expr, target, true) // UntypedNils are final
+	return
+
+Error:
+	check.errorf(x, "cannot convert %s to %s", x, target)
+	x.mode = invalid
+}
+
+func (check *Checker) comparison(x, y *operand, op syntax.Operator) {
+	// spec: "In any comparison, the first operand must be assignable
+	// to the type of the second operand, or vice versa."
+	err := ""
+	if x.assignableTo(check, y.typ, nil) || y.assignableTo(check, x.typ, nil) {
+		defined := false
+		switch op {
+		case syntax.Eql, syntax.Neq:
+			// spec: "The equality operators == and != apply to operands that are comparable."
+			defined = Comparable(x.typ) && Comparable(y.typ) || x.isNil() && hasNil(y.typ) || y.isNil() && hasNil(x.typ)
+		case syntax.Lss, syntax.Leq, syntax.Gtr, syntax.Geq:
+			// spec: The ordering operators <, <=, >, and >= apply to operands that are ordered."
+			defined = isOrdered(x.typ) && isOrdered(y.typ)
+		default:
+			unreachable()
+		}
+		if !defined {
+			typ := x.typ
+			if x.isNil() {
+				typ = y.typ
+			}
+			err = check.sprintf("operator %s not defined for %s", op, typ)
+		}
+	} else {
+		err = check.sprintf("mismatched types %s and %s", x.typ, y.typ)
+	}
+
+	if err != "" {
+		check.errorf(x, "cannot compare %s %s %s (%s)", x.expr, op, y.expr, err)
+		x.mode = invalid
+		return
+	}
+
+	if x.mode == constant_ && y.mode == constant_ {
+		x.val = constant.MakeBool(constant.Compare(x.val, op2token(op), y.val))
+		// The operands are never materialized; no need to update
+		// their types.
+	} else {
+		x.mode = value
+		// The operands have now their final types, which at run-
+		// time will be materialized. Update the expression trees.
+		// If the current types are untyped, the materialized type
+		// is the respective default type.
+		check.updateExprType(x.expr, Default(x.typ), true)
+		check.updateExprType(y.expr, Default(y.typ), true)
+	}
+
+	// spec: "Comparison operators compare two operands and yield
+	//        an untyped boolean value."
+	x.typ = Typ[UntypedBool]
+}
+
+func (check *Checker) shift(x, y *operand, e *syntax.Operation, op syntax.Operator) {
+	untypedx := isUntyped(x.typ)
+
+	var xval constant.Value
+	if x.mode == constant_ {
+		xval = constant.ToInt(x.val)
+	}
+
+	if isInteger(x.typ) || untypedx && xval != nil && xval.Kind() == constant.Int {
+		// The lhs is of integer type or an untyped constant representable
+		// as an integer. Nothing to do.
+	} else {
+		// shift has no chance
+		check.invalidOpf(x, "shifted operand %s must be integer", x)
+		x.mode = invalid
+		return
+	}
+
+	// spec: "The right operand in a shift expression must have integer type
+	// or be an untyped constant representable by a value of type uint."
+	switch {
+	case isInteger(y.typ):
+		// nothing to do
+	case isUntyped(y.typ):
+		check.convertUntyped(y, Typ[Uint])
+		if y.mode == invalid {
+			x.mode = invalid
+			return
+		}
+	default:
+		check.invalidOpf(y, "shift count %s must be integer", y)
+		x.mode = invalid
+		return
+	}
+
+	var yval constant.Value
+	if y.mode == constant_ {
+		// rhs must be an integer value
+		// (Either it was of an integer type already, or it was
+		// untyped and successfully converted to a uint above.)
+		yval = constant.ToInt(y.val)
+		assert(yval.Kind() == constant.Int)
+		if constant.Sign(yval) < 0 {
+			check.invalidOpf(y, "negative shift count %s", y)
+			x.mode = invalid
+			return
+		}
+	}
+
+	if x.mode == constant_ {
+		if y.mode == constant_ {
+			// rhs must be within reasonable bounds in constant shifts
+			const shiftBound = 1023 - 1 + 52 // so we can express smallestFloat64
+			s, ok := constant.Uint64Val(yval)
+			if !ok || s > shiftBound {
+				check.invalidOpf(y, "invalid shift count %s", y)
+				x.mode = invalid
+				return
+			}
+			// The lhs is representable as an integer but may not be an integer
+			// (e.g., 2.0, an untyped float) - this can only happen for untyped
+			// non-integer numeric constants. Correct the type so that the shift
+			// result is of integer type.
+			if !isInteger(x.typ) {
+				x.typ = Typ[UntypedInt]
+			}
+			// x is a constant so xval != nil and it must be of Int kind.
+			x.val = constant.Shift(xval, op2token(op), uint(s))
+			// Typed constants must be representable in
+			// their type after each constant operation.
+			if isTyped(x.typ) {
+				if e != nil {
+					x.expr = e // for better error message
+				}
+				check.representable(x, x.typ.Basic())
+			}
+			return
+		}
+
+		// non-constant shift with constant lhs
+		if untypedx {
+			// spec: "If the left operand of a non-constant shift
+			// expression is an untyped constant, the type of the
+			// constant is what it would be if the shift expression
+			// were replaced by its left operand alone.".
+			//
+			// Delay operand checking until we know the final type
+			// by marking the lhs expression as lhs shift operand.
+			//
+			// Usually (in correct programs), the lhs expression
+			// is in the untyped map. However, it is possible to
+			// create incorrect programs where the same expression
+			// is evaluated twice (via a declaration cycle) such
+			// that the lhs expression type is determined in the
+			// first round and thus deleted from the map, and then
+			// not found in the second round (double insertion of
+			// the same expr node still just leads to one entry for
+			// that node, and it can only be deleted once).
+			// Be cautious and check for presence of entry.
+			// Example: var e, f = int(1<<""[f]) // issue 11347
+			if info, found := check.untyped[x.expr]; found {
+				info.isLhs = true
+				check.untyped[x.expr] = info
+			}
+			// keep x's type
+			x.mode = value
+			return
+		}
+	}
+
+	// non-constant shift - lhs must be an integer
+	if !isInteger(x.typ) {
+		check.invalidOpf(x, "shifted operand %s must be integer", x)
+		x.mode = invalid
+		return
+	}
+
+	x.mode = value
+}
+
+var binaryOpPredicates = opPredicates{
+	syntax.Add: isNumericOrString,
+	syntax.Sub: isNumeric,
+	syntax.Mul: isNumeric,
+	syntax.Div: isNumeric,
+	syntax.Rem: isInteger,
+
+	syntax.And:    isInteger,
+	syntax.Or:     isInteger,
+	syntax.Xor:    isInteger,
+	syntax.AndNot: isInteger,
+
+	syntax.AndAnd: isBoolean,
+	syntax.OrOr:   isBoolean,
+}
+
+// The binary expression e may be nil. It's passed in for better error messages only.
+func (check *Checker) binary(x *operand, e *syntax.Operation, lhs, rhs syntax.Expr, op syntax.Operator) {
+	var y operand
+
+	check.expr(x, lhs)
+	check.expr(&y, rhs)
+
+	if x.mode == invalid {
+		return
+	}
+	if y.mode == invalid {
+		x.mode = invalid
+		x.expr = y.expr
+		return
+	}
+
+	if isShift(op) {
+		check.shift(x, &y, e, op)
+		return
+	}
+
+	check.convertUntyped(x, y.typ)
+	if x.mode == invalid {
+		return
+	}
+	check.convertUntyped(&y, x.typ)
+	if y.mode == invalid {
+		x.mode = invalid
+		return
+	}
+
+	if isComparison(op) {
+		check.comparison(x, &y, op)
+		return
+	}
+
+	if !check.identical(x.typ, y.typ) {
+		// only report an error if we have valid types
+		// (otherwise we had an error reported elsewhere already)
+		if x.typ != Typ[Invalid] && y.typ != Typ[Invalid] {
+			check.invalidOpf(x, "mismatched types %s and %s", x.typ, y.typ)
+		}
+		x.mode = invalid
+		return
+	}
+
+	if !check.op(binaryOpPredicates, x, op) {
+		x.mode = invalid
+		return
+	}
+
+	if op == syntax.Div || op == syntax.Rem {
+		// check for zero divisor
+		if (x.mode == constant_ || isInteger(x.typ)) && y.mode == constant_ && constant.Sign(y.val) == 0 {
+			check.invalidOpf(&y, "division by zero")
+			x.mode = invalid
+			return
+		}
+
+		// check for divisor underflow in complex division (see issue 20227)
+		if x.mode == constant_ && y.mode == constant_ && isComplex(x.typ) {
+			re, im := constant.Real(y.val), constant.Imag(y.val)
+			re2, im2 := constant.BinaryOp(re, token.MUL, re), constant.BinaryOp(im, token.MUL, im)
+			if constant.Sign(re2) == 0 && constant.Sign(im2) == 0 {
+				check.invalidOpf(&y, "division by zero")
+				x.mode = invalid
+				return
+			}
+		}
+	}
+
+	if x.mode == constant_ && y.mode == constant_ {
+		xval := x.val
+		yval := y.val
+		typ := x.typ.Basic()
+		// force integer division of integer operands
+		tok := op2token(op)
+		if op == syntax.Div && isInteger(typ) {
+			tok = token.QUO_ASSIGN
+		}
+		x.val = constant.BinaryOp(xval, tok, yval)
+		// Typed constants must be representable in
+		// their type after each constant operation.
+		if isTyped(typ) {
+			if e != nil {
+				x.expr = e // for better error message
+			}
+			check.representable(x, typ)
+		}
+		return
+	}
+
+	x.mode = value
+	// x.typ is unchanged
+}
+
+// index checks an index expression for validity.
+// If max >= 0, it is the upper bound for index.
+// If the result typ is != Typ[Invalid], index is valid and typ is its (possibly named) integer type.
+// If the result val >= 0, index is valid and val is its constant int value.
+func (check *Checker) index(index syntax.Expr, max int64) (typ Type, val int64) {
+	typ = Typ[Invalid]
+	val = -1
+
+	var x operand
+	check.expr(&x, index)
+	if x.mode == invalid {
+		return
+	}
+
+	// an untyped constant must be representable as Int
+	check.convertUntyped(&x, Typ[Int])
+	if x.mode == invalid {
+		return
+	}
+
+	// the index must be of integer type
+	if !isInteger(x.typ) {
+		check.invalidArgf(&x, "index %s must be integer", &x)
+		return
+	}
+
+	if x.mode != constant_ {
+		return x.typ, -1
+	}
+
+	// a constant index i must be in bounds
+	if constant.Sign(x.val) < 0 {
+		check.invalidArgf(&x, "index %s must not be negative", &x)
+		return
+	}
+
+	v, valid := constant.Int64Val(constant.ToInt(x.val))
+	if !valid || max >= 0 && v >= max {
+		check.errorf(&x, "index %s is out of bounds", &x)
+		return
+	}
+
+	// 0 <= v [ && v < max ]
+	return Typ[Int], v
+}
+
+// indexElts checks the elements (elts) of an array or slice composite literal
+// against the literal's element type (typ), and the element indices against
+// the literal length if known (length >= 0). It returns the length of the
+// literal (maximum index value + 1).
+//
+func (check *Checker) indexedElts(elts []syntax.Expr, typ Type, length int64) int64 {
+	visited := make(map[int64]bool, len(elts))
+	var index, max int64
+	for _, e := range elts {
+		// determine and check index
+		validIndex := false
+		eval := e
+		if kv, _ := e.(*syntax.KeyValueExpr); kv != nil {
+			if typ, i := check.index(kv.Key, length); typ != Typ[Invalid] {
+				if i >= 0 {
+					index = i
+					validIndex = true
+				} else {
+					check.errorf(e, "index %s must be integer constant", kv.Key)
+				}
+			}
+			eval = kv.Value
+		} else if length >= 0 && index >= length {
+			check.errorf(e, "index %d is out of bounds (>= %d)", index, length)
+		} else {
+			validIndex = true
+		}
+
+		// if we have a valid index, check for duplicate entries
+		if validIndex {
+			if visited[index] {
+				check.errorf(e, "duplicate index %d in array or slice literal", index)
+			}
+			visited[index] = true
+		}
+		index++
+		if index > max {
+			max = index
+		}
+
+		// check element against composite literal element type
+		var x operand
+		check.exprWithHint(&x, eval, typ)
+		check.assignment(&x, typ, "array or slice literal")
+	}
+	return max
+}
+
+// exprKind describes the kind of an expression; the kind
+// determines if an expression is valid in 'statement context'.
+type exprKind int
+
+const (
+	conversion exprKind = iota
+	expression
+	statement
+)
+
+// rawExpr typechecks expression e and initializes x with the expression
+// value or type. If an error occurred, x.mode is set to invalid.
+// If hint != nil, it is the type of a composite literal element.
+//
+func (check *Checker) rawExpr(x *operand, e syntax.Expr, hint Type) exprKind {
+	if check.conf.Trace {
+		check.trace(e.Pos(), "expr %s", e)
+		check.indent++
+		defer func() {
+			check.indent--
+			check.trace(e.Pos(), "=> %s", x)
+		}()
+	}
+
+	kind := check.exprInternal(x, e, hint)
+
+	// convert x into a user-friendly set of values
+	// TODO(gri) this code can be simplified
+	var typ Type
+	var val constant.Value
+	switch x.mode {
+	case invalid:
+		typ = Typ[Invalid]
+	case novalue:
+		typ = (*Tuple)(nil)
+	case constant_:
+		typ = x.typ
+		val = x.val
+	default:
+		typ = x.typ
+	}
+	assert(x.expr != nil && typ != nil)
+
+	if isUntyped(typ) {
+		// delay type and value recording until we know the type
+		// or until the end of type checking
+		check.rememberUntyped(x.expr, false, x.mode, typ.(*Basic), val)
+	} else {
+		check.recordTypeAndValue(e, x.mode, typ, val)
+	}
+
+	return kind
+}
+
+// exprInternal contains the core of type checking of expressions.
+// Must only be called by rawExpr.
+//
+func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKind {
+	// make sure x has a valid state in case of bailout
+	// (was issue 5770)
+	x.mode = invalid
+	x.typ = Typ[Invalid]
+
+	switch e := e.(type) {
+	case nil:
+		unreachable()
+
+	case *syntax.BadExpr:
+		goto Error // error was reported before
+
+	case *syntax.Name:
+		check.ident(x, e, nil, false)
+
+	case *syntax.DotsType:
+		// ellipses are handled explicitly where they are legal
+		// (array composite literals and parameter lists)
+		check.error(e, "invalid use of '...'")
+		goto Error
+
+	case *syntax.BasicLit:
+		x.setConst(e.Kind, e.Value)
+		if x.mode == invalid {
+			check.invalidASTf(e, "invalid literal %v", e.Value)
+			goto Error
+		}
+
+	case *syntax.FuncLit:
+		if sig, ok := check.typ(e.Type).(*Signature); ok {
+			// Anonymous functions are considered part of the
+			// init expression/func declaration which contains
+			// them: use existing package-level declaration info.
+			decl := check.decl // capture for use in closure below
+			iota := check.iota // capture for use in closure below (#22345)
+			// Don't type-check right away because the function may
+			// be part of a type definition to which the function
+			// body refers. Instead, type-check as soon as possible,
+			// but before the enclosing scope contents changes (#22992).
+			check.later(func() {
+				check.funcBody(decl, "<function literal>", sig, e.Body, iota)
+			})
+			x.mode = value
+			x.typ = sig
+		} else {
+			check.invalidASTf(e, "invalid function literal %s", e)
+			goto Error
+		}
+
+	case *syntax.CompositeLit:
+		var typ, base Type
+
+		switch {
+		case e.Type != nil:
+			// composite literal type present - use it
+			// [...]T array types may only appear with composite literals.
+			// Check for them here so we don't have to handle ... in general.
+			if atyp, _ := e.Type.(*syntax.ArrayType); atyp != nil && atyp.Len == nil {
+				// We have an "open" [...]T array type.
+				// Create a new ArrayType with unknown length (-1)
+				// and finish setting it up after analyzing the literal.
+				typ = &Array{len: -1, elem: check.varType(atyp.Elem)}
+				base = typ
+				break
+			}
+			typ = check.typ(e.Type)
+			base = typ
+
+		case hint != nil:
+			// no composite literal type present - use hint (element type of enclosing type)
+			typ = hint
+			base, _ = deref(typ.Under()) // *T implies &T{}
+
+		default:
+			// TODO(gri) provide better error messages depending on context
+			check.error(e, "missing type in composite literal")
+			goto Error
+		}
+
+		switch utyp := optype(base.Under()).(type) {
+		case *Struct:
+			if len(e.ElemList) == 0 {
+				break
+			}
+			fields := utyp.fields
+			if _, ok := e.ElemList[0].(*syntax.KeyValueExpr); ok {
+				// all elements must have keys
+				visited := make([]bool, len(fields))
+				for _, e := range e.ElemList {
+					kv, _ := e.(*syntax.KeyValueExpr)
+					if kv == nil {
+						check.error(e, "mixture of field:value and value elements in struct literal")
+						continue
+					}
+					key, _ := kv.Key.(*syntax.Name)
+					// do all possible checks early (before exiting due to errors)
+					// so we don't drop information on the floor
+					check.expr(x, kv.Value)
+					if key == nil {
+						check.errorf(kv, "invalid field name %s in struct literal", kv.Key)
+						continue
+					}
+					i := fieldIndex(utyp.fields, check.pkg, key.Value)
+					if i < 0 {
+						check.errorf(kv, "unknown field %s in struct literal", key.Value)
+						continue
+					}
+					fld := fields[i]
+					check.recordUse(key, fld)
+					etyp := fld.typ
+					check.assignment(x, etyp, "struct literal")
+					// 0 <= i < len(fields)
+					if visited[i] {
+						check.errorf(kv, "duplicate field name %s in struct literal", key.Value)
+						continue
+					}
+					visited[i] = true
+				}
+			} else {
+				// no element must have a key
+				for i, e := range e.ElemList {
+					if kv, _ := e.(*syntax.KeyValueExpr); kv != nil {
+						check.error(kv, "mixture of field:value and value elements in struct literal")
+						continue
+					}
+					check.expr(x, e)
+					if i >= len(fields) {
+						check.error(x, "too many values in struct literal")
+						break // cannot continue
+					}
+					// i < len(fields)
+					fld := fields[i]
+					if !fld.Exported() && fld.pkg != check.pkg {
+						check.errorf(x, "implicit assignment to unexported field %s in %s literal", fld.name, typ)
+						continue
+					}
+					etyp := fld.typ
+					check.assignment(x, etyp, "struct literal")
+				}
+				if len(e.ElemList) < len(fields) {
+					check.error(e.Rbrace, "too few values in struct literal")
+					// ok to continue
+				}
+			}
+
+		case *Array:
+			// Prevent crash if the array referred to is not yet set up. Was issue #18643.
+			// This is a stop-gap solution. Should use Checker.objPath to report entire
+			// path starting with earliest declaration in the source. TODO(gri) fix this.
+			if utyp.elem == nil {
+				check.error(e, "illegal cycle in type declaration")
+				goto Error
+			}
+			n := check.indexedElts(e.ElemList, utyp.elem, utyp.len)
+			// If we have an array of unknown length (usually [...]T arrays, but also
+			// arrays [n]T where n is invalid) set the length now that we know it and
+			// record the type for the array (usually done by check.typ which is not
+			// called for [...]T). We handle [...]T arrays and arrays with invalid
+			// length the same here because it makes sense to "guess" the length for
+			// the latter if we have a composite literal; e.g. for [n]int{1, 2, 3}
+			// where n is invalid for some reason, it seems fair to assume it should
+			// be 3 (see also Checked.arrayLength and issue #27346).
+			if utyp.len < 0 {
+				utyp.len = n
+				// e.Type is missing if we have a composite literal element
+				// that is itself a composite literal with omitted type. In
+				// that case there is nothing to record (there is no type in
+				// the source at that point).
+				if e.Type != nil {
+					check.recordTypeAndValue(e.Type, typexpr, utyp, nil)
+				}
+			}
+
+		case *Slice:
+			// Prevent crash if the slice referred to is not yet set up.
+			// See analogous comment for *Array.
+			if utyp.elem == nil {
+				check.error(e, "illegal cycle in type declaration")
+				goto Error
+			}
+			check.indexedElts(e.ElemList, utyp.elem, -1)
+
+		case *Map:
+			// Prevent crash if the map referred to is not yet set up.
+			// See analogous comment for *Array.
+			if utyp.key == nil || utyp.elem == nil {
+				check.error(e, "illegal cycle in type declaration")
+				goto Error
+			}
+			visited := make(map[interface{}][]Type, len(e.ElemList))
+			for _, e := range e.ElemList {
+				kv, _ := e.(*syntax.KeyValueExpr)
+				if kv == nil {
+					check.error(e, "missing key in map literal")
+					continue
+				}
+				check.exprWithHint(x, kv.Key, utyp.key)
+				check.assignment(x, utyp.key, "map literal")
+				if x.mode == invalid {
+					continue
+				}
+				if x.mode == constant_ {
+					duplicate := false
+					// if the key is of interface type, the type is also significant when checking for duplicates
+					xkey := keyVal(x.val)
+					if utyp.key.Interface() != nil {
+						for _, vtyp := range visited[xkey] {
+							if check.identical(vtyp, x.typ) {
+								duplicate = true
+								break
+							}
+						}
+						visited[xkey] = append(visited[xkey], x.typ)
+					} else {
+						_, duplicate = visited[xkey]
+						visited[xkey] = nil
+					}
+					if duplicate {
+						check.errorf(x, "duplicate key %s in map literal", x.val)
+						continue
+					}
+				}
+				check.exprWithHint(x, kv.Value, utyp.elem)
+				check.assignment(x, utyp.elem, "map literal")
+			}
+
+		default:
+			// when "using" all elements unpack KeyValueExpr
+			// explicitly because check.use doesn't accept them
+			for _, e := range e.ElemList {
+				if kv, _ := e.(*syntax.KeyValueExpr); kv != nil {
+					// Ideally, we should also "use" kv.Key but we can't know
+					// if it's an externally defined struct key or not. Going
+					// forward anyway can lead to other errors. Give up instead.
+					e = kv.Value
+				}
+				check.use(e)
+			}
+			// if utyp is invalid, an error was reported before
+			if utyp != Typ[Invalid] {
+				check.errorf(e, "invalid composite literal type %s", typ)
+				goto Error
+			}
+		}
+
+		x.mode = value
+		x.typ = typ
+
+	case *syntax.ParenExpr:
+		kind := check.rawExpr(x, e.X, nil)
+		x.expr = e
+		return kind
+
+	case *syntax.SelectorExpr:
+		check.selector(x, e)
+
+	case *syntax.IndexExpr:
+		check.exprOrType(x, e.X)
+		if x.mode == invalid {
+			check.use(e.Index)
+			goto Error
+		}
+
+		if x.mode == typexpr {
+			// type instantiation
+			x.mode = invalid
+			x.typ = check.varType(e)
+			if x.typ != Typ[Invalid] {
+				x.mode = typexpr
+			}
+			return expression
+		}
+
+		if x.mode == value {
+			if sig := x.typ.Signature(); sig != nil && len(sig.tparams) > 0 {
+				// function instantiation
+				check.funcInst(x, e)
+				return expression
+			}
+		}
+
+		// ordinary index expression
+		valid := false
+		length := int64(-1) // valid if >= 0
+		switch typ := optype(x.typ.Under()).(type) {
+		case *Basic:
+			if isString(typ) {
+				valid = true
+				if x.mode == constant_ {
+					length = int64(len(constant.StringVal(x.val)))
+				}
+				// an indexed string always yields a byte value
+				// (not a constant) even if the string and the
+				// index are constant
+				x.mode = value
+				x.typ = universeByte // use 'byte' name
+			}
+
+		case *Array:
+			valid = true
+			length = typ.len
+			if x.mode != variable {
+				x.mode = value
+			}
+			x.typ = typ.elem
+
+		case *Pointer:
+			if typ := typ.base.Array(); typ != nil {
+				valid = true
+				length = typ.len
+				x.mode = variable
+				x.typ = typ.elem
+			}
+
+		case *Slice:
+			valid = true
+			x.mode = variable
+			x.typ = typ.elem
+
+		case *Map:
+			var key operand
+			check.expr(&key, e.Index)
+			check.assignment(&key, typ.key, "map index")
+			if x.mode == invalid {
+				goto Error
+			}
+			x.mode = mapindex
+			x.typ = typ.elem
+			x.expr = e
+			return expression
+
+		case *Sum:
+			// A sum type can be indexed if all the sum's types
+			// support indexing and have the same element type.
+			var elem Type
+			if typ.is(func(t Type) bool {
+				var e Type
+				switch t := t.Under().(type) {
+				case *Basic:
+					if isString(t) {
+						e = universeByte
+					}
+				case *Array:
+					e = t.elem
+				case *Pointer:
+					if t := t.base.Array(); t != nil {
+						e = t.elem
+					}
+				case *Slice:
+					e = t.elem
+				case *Map:
+					e = t.elem
+				case *TypeParam:
+					check.errorf(x, "type of %s contains a type parameter - cannot index (implementation restriction)", x)
+				case *instance:
+					unimplemented()
+				}
+				if e != nil && (e == elem || elem == nil) {
+					elem = e
+					return true
+				}
+				return false
+			}) {
+				valid = true
+				x.mode = variable
+				x.typ = elem
+			}
+		}
+
+		if !valid {
+			check.invalidOpf(x, "cannot index %s", x)
+			goto Error
+		}
+
+		if e.Index == nil {
+			check.invalidASTf(e, "missing index for %s", x)
+			goto Error
+		}
+
+		index := e.Index
+		if l, _ := index.(*syntax.ListExpr); l != nil {
+			if n := len(l.ElemList); n <= 1 {
+				check.invalidASTf(e, "invalid use of ListExpr for index expression %s with %d indices", e, n)
+				goto Error
+			}
+			// len(l.ElemList) > 1
+			check.invalidOpf(l.ElemList[1], "more than one index")
+			index = l.ElemList[0] // continue with first index
+		}
+
+		// In pathological (invalid) cases (e.g.: type T1 [][[]T1{}[0][0]]T0)
+		// the element type may be accessed before it's set. Make sure we have
+		// a valid type.
+		if x.typ == nil {
+			x.typ = Typ[Invalid]
+		}
+
+		check.index(index, length)
+		// ok to continue
+
+	case *syntax.SliceExpr:
+		check.expr(x, e.X)
+		if x.mode == invalid {
+			check.use(e.Index[:]...)
+			goto Error
+		}
+
+		valid := false
+		length := int64(-1) // valid if >= 0
+		switch typ := optype(x.typ.Under()).(type) {
+		case *Basic:
+			if isString(typ) {
+				if e.Full {
+					check.invalidOpf(x, "3-index slice of string")
+					goto Error
+				}
+				valid = true
+				if x.mode == constant_ {
+					length = int64(len(constant.StringVal(x.val)))
+				}
+				// spec: "For untyped string operands the result
+				// is a non-constant value of type string."
+				if typ.kind == UntypedString {
+					x.typ = Typ[String]
+				}
+			}
+
+		case *Array:
+			valid = true
+			length = typ.len
+			if x.mode != variable {
+				check.invalidOpf(x, "cannot slice %s (value not addressable)", x)
+				goto Error
+			}
+			x.typ = &Slice{elem: typ.elem}
+
+		case *Pointer:
+			if typ := typ.base.Array(); typ != nil {
+				valid = true
+				length = typ.len
+				x.typ = &Slice{elem: typ.elem}
+			}
+
+		case *Slice:
+			valid = true
+			// x.typ doesn't change
+
+		case *Sum, *TypeParam:
+			check.errorf(x, "generic slice expressions not yet implemented")
+			goto Error
+		}
+
+		if !valid {
+			check.invalidOpf(x, "cannot slice %s", x)
+			goto Error
+		}
+
+		x.mode = value
+
+		// spec: "Only the first index may be omitted; it defaults to 0."
+		if e.Full && (e.Index[1] == nil || e.Index[2] == nil) {
+			check.invalidASTf(e, "2nd and 3rd index required in 3-index slice")
+			goto Error
+		}
+
+		// check indices
+		var ind [3]int64
+		for i, expr := range e.Index {
+			x := int64(-1)
+			switch {
+			case expr != nil:
+				// The "capacity" is only known statically for strings, arrays,
+				// and pointers to arrays, and it is the same as the length for
+				// those types.
+				max := int64(-1)
+				if length >= 0 {
+					max = length + 1
+				}
+				if _, v := check.index(expr, max); v >= 0 {
+					x = v
+				}
+			case i == 0:
+				// default is 0 for the first index
+				x = 0
+			case length >= 0:
+				// default is length (== capacity) otherwise
+				x = length
+			}
+			ind[i] = x
+		}
+
+		// constant indices must be in range
+		// (check.index already checks that existing indices >= 0)
+	L:
+		for i, x := range ind[:len(ind)-1] {
+			if x > 0 {
+				for _, y := range ind[i+1:] {
+					if y >= 0 && x > y {
+						check.errorf(e, "invalid slice indices: %d > %d", x, y)
+						break L // only report one error, ok to continue
+					}
+				}
+			}
+		}
+
+	case *syntax.AssertExpr:
+		check.expr(x, e.X)
+		if x.mode == invalid {
+			goto Error
+		}
+		var xtyp *Interface
+		var strict bool
+		switch t := optype(x.typ.Under()).(type) {
+		case *Interface:
+			xtyp = t
+		// Disabled for now. It is not clear what the right approach is
+		// here. Also, the implementation below is inconsistent because
+		// the underlying type of a type parameter is either itself or
+		// a sum type if the corresponding type bound contains a type list.
+		// case *TypeParam:
+		// 	xtyp = t.Bound()
+		// 	strict = true
+		default:
+			check.invalidOpf(x, "%s is not an interface type", x)
+			goto Error
+		}
+		// x.(type) expressions are encoded via TypeSwitchGuards
+		if e.Type == nil {
+			check.invalidASTf(e, "invalid use of AssertExpr")
+			goto Error
+		}
+		T := check.varType(e.Type)
+		if T == Typ[Invalid] {
+			goto Error
+		}
+		check.typeAssertion(posFor(x), x, xtyp, T, strict)
+		x.mode = commaok
+		x.typ = T
+
+	case *syntax.TypeSwitchGuard:
+		// x.(type) expressions are handled explicitly in type switches
+		check.invalidASTf(e, "use of .(type) outside type switch")
+		goto Error
+
+	case *syntax.CallExpr:
+		return check.call(x, e)
+
+	// case *syntax.UnaryExpr:
+	// 	check.expr(x, e.X)
+	// 	if x.mode == invalid {
+	// 		goto Error
+	// 	}
+	// 	check.unary(x, e, e.Op)
+	// 	if x.mode == invalid {
+	// 		goto Error
+	// 	}
+	// 	if e.Op == token.ARROW {
+	// 		x.expr = e
+	// 		return statement // receive operations may appear in statement context
+	// 	}
+
+	// case *syntax.BinaryExpr:
+	// 	check.binary(x, e, e.X, e.Y, e.Op)
+	// 	if x.mode == invalid {
+	// 		goto Error
+	// 	}
+
+	case *syntax.Operation:
+		if e.Y == nil {
+			// unary expression
+			if e.Op == syntax.Mul {
+				// pointer indirection
+				check.exprOrType(x, e.X)
+				switch x.mode {
+				case invalid:
+					goto Error
+				case typexpr:
+					x.typ = &Pointer{base: x.typ}
+				default:
+					if typ := x.typ.Pointer(); typ != nil {
+						x.mode = variable
+						x.typ = typ.base
+					} else {
+						check.invalidOpf(x, "cannot indirect %s", x)
+						goto Error
+					}
+				}
+				break
+			}
+
+			check.expr(x, e.X)
+			if x.mode == invalid {
+				goto Error
+			}
+			check.unary(x, e, e.Op)
+			if x.mode == invalid {
+				goto Error
+			}
+			if e.Op == syntax.Recv {
+				x.expr = e
+				return statement // receive operations may appear in statement context
+			}
+			break
+		}
+
+		// binary expression
+		check.binary(x, e, e.X, e.Y, e.Op)
+		if x.mode == invalid {
+			goto Error
+		}
+
+	case *syntax.KeyValueExpr:
+		// key:value expressions are handled in composite literals
+		check.invalidASTf(e, "no key:value expected")
+		goto Error
+
+	case *syntax.ArrayType, *syntax.SliceType, *syntax.StructType, *syntax.FuncType,
+		*syntax.InterfaceType, *syntax.MapType, *syntax.ChanType:
+		x.mode = typexpr
+		x.typ = check.typ(e)
+		// Note: rawExpr (caller of exprInternal) will call check.recordTypeAndValue
+		// even though check.typ has already called it. This is fine as both
+		// times the same expression and type are recorded. It is also not a
+		// performance issue because we only reach here for composite literal
+		// types, which are comparatively rare.
+
+	default:
+		panic(fmt.Sprintf("%s: unknown expression type %T", posFor(e), e))
+	}
+
+	// everything went well
+	x.expr = e
+	return expression
+
+Error:
+	x.mode = invalid
+	x.expr = e
+	return statement // avoid follow-up errors
+}
+
+func keyVal(x constant.Value) interface{} {
+	switch x.Kind() {
+	case constant.Bool:
+		return constant.BoolVal(x)
+	case constant.String:
+		return constant.StringVal(x)
+	case constant.Int:
+		if v, ok := constant.Int64Val(x); ok {
+			return v
+		}
+		if v, ok := constant.Uint64Val(x); ok {
+			return v
+		}
+	case constant.Float:
+		v, _ := constant.Float64Val(x)
+		return v
+	case constant.Complex:
+		r, _ := constant.Float64Val(constant.Real(x))
+		i, _ := constant.Float64Val(constant.Imag(x))
+		return complex(r, i)
+	}
+	return x
+}
+
+// typeAssertion checks that x.(T) is legal; xtyp must be the type of x.
+func (check *Checker) typeAssertion(pos syntax.Pos, x *operand, xtyp *Interface, T Type, strict bool) {
+	method, wrongType := check.assertableTo(xtyp, T, strict)
+	if method == nil {
+		return
+	}
+	var msg string
+	if wrongType != nil {
+		if check.identical(method.typ, wrongType.typ) {
+			msg = fmt.Sprintf("missing method %s (%s has pointer receiver)", method.name, method.name)
+		} else {
+			msg = fmt.Sprintf("wrong type for method %s (have %s, want %s)", method.name, wrongType.typ, method.typ)
+		}
+	} else {
+		msg = "missing method " + method.name
+	}
+	check.errorf(pos, "%s cannot have dynamic type %s (%s)", x, T, msg)
+}
+
+// expr typechecks expression e and initializes x with the expression value.
+// The result must be a single value.
+// If an error occurred, x.mode is set to invalid.
+//
+func (check *Checker) expr(x *operand, e syntax.Expr) {
+	check.rawExpr(x, e, nil)
+	check.exclude(x, 1<<novalue|1<<builtin|1<<typexpr)
+	check.singleValue(x)
+}
+
+// multiExpr is like expr but the result may also be a multi-value.
+func (check *Checker) multiExpr(x *operand, e syntax.Expr) {
+	check.rawExpr(x, e, nil)
+	check.exclude(x, 1<<novalue|1<<builtin|1<<typexpr)
+}
+
+// multiExprOrType is like multiExpr but the result may also be a type.
+func (check *Checker) multiExprOrType(x *operand, e syntax.Expr) {
+	check.rawExpr(x, e, nil)
+	check.exclude(x, 1<<novalue|1<<builtin)
+}
+
+// exprWithHint typechecks expression e and initializes x with the expression value;
+// hint is the type of a composite literal element.
+// If an error occurred, x.mode is set to invalid.
+//
+func (check *Checker) exprWithHint(x *operand, e syntax.Expr, hint Type) {
+	assert(hint != nil)
+	check.rawExpr(x, e, hint)
+	check.exclude(x, 1<<novalue|1<<builtin|1<<typexpr)
+	check.singleValue(x)
+}
+
+// exprOrType typechecks expression or type e and initializes x with the expression value or type.
+// If an error occurred, x.mode is set to invalid.
+//
+func (check *Checker) exprOrType(x *operand, e syntax.Expr) {
+	check.rawExpr(x, e, nil)
+	check.exclude(x, 1<<novalue)
+	check.singleValue(x)
+}
+
+// exclude reports an error if x.mode is in modeset and sets x.mode to invalid.
+// The modeset may contain any of 1<<novalue, 1<<builtin, 1<<typexpr.
+func (check *Checker) exclude(x *operand, modeset uint) {
+	if modeset&(1<<x.mode) != 0 {
+		var msg string
+		switch x.mode {
+		case novalue:
+			if modeset&(1<<typexpr) != 0 {
+				msg = "%s used as value"
+			} else {
+				msg = "%s used as value or type"
+			}
+		case builtin:
+			msg = "%s must be called"
+		case typexpr:
+			msg = "%s is not an expression"
+		default:
+			unreachable()
+		}
+		check.errorf(x, msg, x)
+		x.mode = invalid
+	}
+}
+
+// singleValue reports an error if x describes a tuple and sets x.mode to invalid.
+func (check *Checker) singleValue(x *operand) {
+	if x.mode == value {
+		// tuple types are never named - no need for underlying type below
+		if t, ok := x.typ.(*Tuple); ok {
+			assert(t.Len() != 1)
+			check.errorf(x, "%d-valued %s where single value is expected", t.Len(), x)
+			x.mode = invalid
+		}
+	}
+}
diff --git a/src/cmd/compile/internal/types2/exprstring.go b/src/cmd/compile/internal/types2/exprstring.go
new file mode 100644
index 0000000000..e187d050e6
--- /dev/null
+++ b/src/cmd/compile/internal/types2/exprstring.go
@@ -0,0 +1,287 @@
+// UNREVIEWED
+// Copyright 2013 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.
+
+// This file implements printing of expressions.
+
+package types2
+
+import (
+	"bytes"
+	"cmd/compile/internal/syntax"
+)
+
+// ExprString returns the (possibly shortened) string representation for x.
+// Shortened representations are suitable for user interfaces but may not
+// necessarily follow Go syntax.
+func ExprString(x syntax.Expr) string {
+	var buf bytes.Buffer
+	WriteExpr(&buf, x)
+	return buf.String()
+}
+
+// WriteExpr writes the (possibly shortened) string representation for x to buf.
+// Shortened representations are suitable for user interfaces but may not
+// necessarily follow Go syntax.
+func WriteExpr(buf *bytes.Buffer, x syntax.Expr) {
+	// The AST preserves source-level parentheses so there is
+	// no need to introduce them here to correct for different
+	// operator precedences. (This assumes that the AST was
+	// generated by a Go parser.)
+
+	// TODO(gri): This assumption is not correct - we need to recreate
+	//            parentheses in expressions.
+
+	switch x := x.(type) {
+	default:
+		buf.WriteString("(ast: bad expr)") // nil, syntax.BadExpr, syntax.KeyValueExpr
+
+	case *syntax.Name:
+		buf.WriteString(x.Value)
+
+	case *syntax.DotsType:
+		buf.WriteString("...")
+		if x.Elem != nil {
+			WriteExpr(buf, x.Elem)
+		}
+
+	case *syntax.BasicLit:
+		buf.WriteString(x.Value)
+
+	case *syntax.FuncLit:
+		buf.WriteByte('(')
+		WriteExpr(buf, x.Type)
+		buf.WriteString(" literal)") // shortened
+
+	case *syntax.CompositeLit:
+		buf.WriteByte('(')
+		WriteExpr(buf, x.Type)
+		buf.WriteString(" literal)") // shortened
+
+	case *syntax.ParenExpr:
+		buf.WriteByte('(')
+		WriteExpr(buf, x.X)
+		buf.WriteByte(')')
+
+	case *syntax.SelectorExpr:
+		WriteExpr(buf, x.X)
+		buf.WriteByte('.')
+		buf.WriteString(x.Sel.Value)
+
+	case *syntax.IndexExpr:
+		WriteExpr(buf, x.X)
+		buf.WriteByte('[')
+		WriteExpr(buf, x.Index) // x.Index may be a *ListExpr
+		buf.WriteByte(']')
+
+	case *syntax.SliceExpr:
+		WriteExpr(buf, x.X)
+		buf.WriteByte('[')
+		if x.Index[0] != nil {
+			WriteExpr(buf, x.Index[0])
+		}
+		buf.WriteByte(':')
+		if x.Index[1] != nil {
+			WriteExpr(buf, x.Index[1])
+		}
+		if x.Full {
+			buf.WriteByte(':')
+			if x.Index[2] != nil {
+				WriteExpr(buf, x.Index[2])
+			}
+		}
+		buf.WriteByte(']')
+
+	case *syntax.AssertExpr:
+		WriteExpr(buf, x.X)
+		buf.WriteString(".(")
+		WriteExpr(buf, x.Type)
+		buf.WriteByte(')')
+
+	case *syntax.CallExpr:
+		WriteExpr(buf, x.Fun)
+		buf.WriteByte('(')
+		writeExprList(buf, x.ArgList)
+		if x.HasDots {
+			buf.WriteString("...")
+		}
+		buf.WriteByte(')')
+
+	case *syntax.ListExpr:
+		writeExprList(buf, x.ElemList)
+
+	case *syntax.Operation:
+		// TODO(gri) This would be simpler if x.X == nil meant unary expression.
+		if x.Y == nil {
+			// unary expression
+			buf.WriteString(x.Op.String())
+			WriteExpr(buf, x.X)
+		} else {
+			// binary expression
+			WriteExpr(buf, x.X)
+			buf.WriteByte(' ')
+			buf.WriteString(x.Op.String())
+			buf.WriteByte(' ')
+			WriteExpr(buf, x.Y)
+		}
+
+		// case *ast.StarExpr:
+		// 	buf.WriteByte('*')
+		// 	WriteExpr(buf, x.X)
+
+		// case *ast.UnaryExpr:
+		// 	buf.WriteString(x.Op.String())
+		// 	WriteExpr(buf, x.X)
+
+		// case *ast.BinaryExpr:
+		// 	WriteExpr(buf, x.X)
+		// 	buf.WriteByte(' ')
+		// 	buf.WriteString(x.Op.String())
+		// 	buf.WriteByte(' ')
+		// 	WriteExpr(buf, x.Y)
+
+	case *syntax.ArrayType:
+		if x.Len == nil {
+			buf.WriteString("[...]")
+		} else {
+			buf.WriteByte('[')
+			WriteExpr(buf, x.Len)
+			buf.WriteByte(']')
+		}
+		WriteExpr(buf, x.Elem)
+
+	case *syntax.SliceType:
+		buf.WriteString("[]")
+		WriteExpr(buf, x.Elem)
+
+	case *syntax.StructType:
+		buf.WriteString("struct{")
+		writeFieldList(buf, x.FieldList, "; ", false)
+		buf.WriteByte('}')
+
+	case *syntax.FuncType:
+		buf.WriteString("func")
+		writeSigExpr(buf, x)
+
+	case *syntax.InterfaceType:
+		// separate type list types from method list
+		// TODO(gri) we can get rid of this extra code if writeExprList does the separation
+		var types []syntax.Expr
+		var methods []*syntax.Field
+		for _, f := range x.MethodList {
+			if f.Name != nil && f.Name.Value == "type" {
+				// type list type
+				types = append(types, f.Type)
+			} else {
+				// method or embedded interface
+				methods = append(methods, f)
+			}
+		}
+
+		buf.WriteString("interface{")
+		writeFieldList(buf, methods, "; ", true)
+		if len(types) > 0 {
+			if len(methods) > 0 {
+				buf.WriteString("; ")
+			}
+			buf.WriteString("type ")
+			writeExprList(buf, types)
+		}
+		buf.WriteByte('}')
+
+	case *syntax.MapType:
+		buf.WriteString("map[")
+		WriteExpr(buf, x.Key)
+		buf.WriteByte(']')
+		WriteExpr(buf, x.Value)
+
+	case *syntax.ChanType:
+		var s string
+		switch x.Dir {
+		case syntax.SendOnly:
+			s = "chan<- "
+		case syntax.RecvOnly:
+			s = "<-chan "
+		default:
+			s = "chan "
+		}
+		buf.WriteString(s)
+		if e, _ := x.Elem.(*syntax.ChanType); x.Dir != syntax.SendOnly && e != nil && e.Dir == syntax.RecvOnly {
+			// don't print chan (<-chan T) as chan <-chan T (but chan<- <-chan T is ok)
+			buf.WriteByte('(')
+			WriteExpr(buf, x.Elem)
+			buf.WriteByte(')')
+		} else {
+			WriteExpr(buf, x.Elem)
+		}
+	}
+}
+
+func writeSigExpr(buf *bytes.Buffer, sig *syntax.FuncType) {
+	buf.WriteByte('(')
+	writeFieldList(buf, sig.ParamList, ", ", false)
+	buf.WriteByte(')')
+
+	res := sig.ResultList
+	n := len(res)
+	if n == 0 {
+		// no result
+		return
+	}
+
+	buf.WriteByte(' ')
+	if n == 1 && res[0].Name == nil {
+		// single unnamed result
+		WriteExpr(buf, res[0].Type)
+		return
+	}
+
+	// multiple or named result(s)
+	buf.WriteByte('(')
+	writeFieldList(buf, res, ", ", false)
+	buf.WriteByte(')')
+}
+
+func writeFieldList(buf *bytes.Buffer, list []*syntax.Field, sep string, iface bool) {
+	for i := 0; i < len(list); {
+		f := list[i]
+		if i > 0 {
+			buf.WriteString(sep)
+		}
+
+		// if we don't have a name, we have an embedded type
+		if f.Name == nil {
+			WriteExpr(buf, f.Type)
+			i++
+			continue
+		}
+
+		// types of interface methods consist of signatures only
+		if sig, _ := f.Type.(*syntax.FuncType); sig != nil && iface {
+			buf.WriteString(f.Name.Value)
+			writeSigExpr(buf, sig)
+			i++
+			continue
+		}
+
+		// write the type only once for a sequence of fields with the same type
+		t := f.Type
+		buf.WriteString(f.Name.Value)
+		for i++; i < len(list) && list[i].Type == t; i++ {
+			buf.WriteString(", ")
+			buf.WriteString(list[i].Name.Value)
+		}
+		buf.WriteByte(' ')
+		WriteExpr(buf, t)
+	}
+}
+
+func writeExprList(buf *bytes.Buffer, list []syntax.Expr) {
+	for i, x := range list {
+		if i > 0 {
+			buf.WriteString(", ")
+		}
+		WriteExpr(buf, x)
+	}
+}
diff --git a/src/cmd/compile/internal/types2/exprstring_test.go b/src/cmd/compile/internal/types2/exprstring_test.go
new file mode 100644
index 0000000000..d7b9d5b2ef
--- /dev/null
+++ b/src/cmd/compile/internal/types2/exprstring_test.go
@@ -0,0 +1,97 @@
+// UNREVIEWED
+// Copyright 2013 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 types2_test
+
+import (
+	"testing"
+
+	"cmd/compile/internal/syntax"
+	. "cmd/compile/internal/types2"
+)
+
+var testExprs = []testEntry{
+	// basic type literals
+	dup("x"),
+	dup("true"),
+	dup("42"),
+	dup("3.1415"),
+	dup("2.71828i"),
+	dup(`'a'`),
+	dup(`"foo"`),
+	dup("`bar`"),
+
+	// func and composite literals
+	{"func(){}", "(func() literal)"},
+	{"func(x int) complex128 {}", "(func(x int) complex128 literal)"},
+	{"[]int{1, 2, 3}", "([]int literal)"},
+
+	// non-type expressions
+	dup("(x)"),
+	dup("x.f"),
+	dup("a[i]"),
+
+	dup("s[:]"),
+	dup("s[i:]"),
+	dup("s[:j]"),
+	dup("s[i:j]"),
+	dup("s[:j:k]"),
+	dup("s[i:j:k]"),
+
+	dup("x.(T)"),
+
+	dup("x.([10]int)"),
+	dup("x.([...]int)"),
+
+	dup("x.(struct{})"),
+	dup("x.(struct{x int; y, z float32; E})"),
+
+	dup("x.(func())"),
+	dup("x.(func(x int))"),
+	dup("x.(func() int)"),
+	dup("x.(func(x, y int, z float32) (r int))"),
+	dup("x.(func(a, b, c int))"),
+	dup("x.(func(x ...T))"),
+
+	dup("x.(interface{})"),
+	dup("x.(interface{m(); n(x int); E})"),
+	dup("x.(interface{m(); n(x int) T; E; F})"),
+
+	dup("x.(map[K]V)"),
+
+	dup("x.(chan E)"),
+	dup("x.(<-chan E)"),
+	dup("x.(chan<- chan int)"),
+	dup("x.(chan<- <-chan int)"),
+	dup("x.(<-chan chan int)"),
+	dup("x.(chan (<-chan int))"),
+
+	dup("f()"),
+	dup("f(x)"),
+	dup("int(x)"),
+	dup("f(x, x + y)"),
+	dup("f(s...)"),
+	dup("f(a, s...)"),
+
+	dup("*x"),
+	dup("&x"),
+	dup("x + y"),
+	dup("x + y << (2 * s)"),
+}
+
+func TestExprString(t *testing.T) {
+	for _, test := range testExprs {
+		src := "package p; var _ = " + test.src
+		f, err := parseSrc("expr", src)
+		if err != nil {
+			t.Errorf("%s: %s", test.src, err)
+			continue
+		}
+		x := f.DeclList[0].(*syntax.VarDecl).Values
+		if got := ExprString(x); got != test.str {
+			t.Errorf("%s: got %s, want %s", test.src, got, test.str)
+		}
+	}
+}
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39634.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39634.go2
new file mode 100644
index 0000000000..f37930d0e8
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39634.go2
@@ -0,0 +1,92 @@
+// UNREVIEWED
+// Copyright 2020 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.
+
+// Examples adjusted to match new [T any] syntax for type parameters.
+// Also, previously permitted empty type parameter lists and instantiations
+// are now syntax errors.
+
+package p
+
+// crash 1
+type nt1[_ any]interface{g /* ERROR undeclared name */ }
+type ph1[e nt1[e],g(d /* ERROR undeclared name */ )]s /* ERROR undeclared name */
+func(*ph1[e,e /* ERROR redeclared */ ])h(d /* ERROR undeclared name */ )
+
+// crash 2
+// Disabled: empty []'s are now syntax errors. This example leads to too many follow-on errors.
+// type Numeric2 interface{t2 /* ERROR not a type */ }
+// func t2[T Numeric2](s[]T){0 /* ERROR not a type */ []{s /* ERROR cannot index */ [0][0]}}
+
+// crash 3
+type t3 *interface{ t3.p /* ERROR no field or method p */ }
+
+// crash 4
+type Numeric4 interface{t4 /* ERROR not a type */ }
+func t4[T Numeric4](s[]T){if( /* ERROR non-boolean */ 0){*s /* ERROR cannot indirect */ [0]}}
+
+// crash 7
+type foo7 interface { bar() }
+type x7[A any] struct{ foo7 }
+func main7() { var _ foo7 = x7[int]{} }
+
+// crash 8
+type foo8[A any] interface { type A }
+func bar8[A foo8[A]](a A) {}
+func main8() {}
+
+// crash 9
+type foo9[A any] interface { type foo9 /* ERROR interface contains type constraints */ [A] }
+func _() { var _ = new(foo9 /* ERROR interface contains type constraints */ [int]) }
+
+// crash 12
+var u /* ERROR cycle */ , i [func /* ERROR used as value */ /* ERROR used as value */ (u, c /* ERROR undeclared */ /* ERROR undeclared */ ) {}(0, len)]c /* ERROR undeclared */ /* ERROR undeclared */
+
+// crash 15
+func y15() { var a /* ERROR declared but not used */ interface{ p() } = G15[string]{} }
+type G15[X any] s /* ERROR undeclared name */
+func (G15 /* ERROR generic type .* without instantiation */ ) p()
+
+// crash 16
+type Foo16[T any] r16 /* ERROR not a type */
+func r16[T any]() Foo16[Foo16[T]]
+
+// crash 17
+type Y17 interface{ c() }
+type Z17 interface {
+	c() Y17
+	Y17 /* ERROR duplicate method */
+}
+func F17[T Z17](T)
+
+// crash 18
+type o18[T any] []func(_ o18[[]_ /* ERROR cannot use _ */ ])
+
+// crash 19
+type Z19 [][[]Z19{}[0][0]]c19 /* ERROR undeclared */
+
+// crash 20
+type Z20 /* ERROR illegal cycle */ interface{ Z20 }
+func F20[t Z20]() { F20(t /* ERROR invalid composite literal type */ {}) }
+
+// crash 21
+type Z21 /* ERROR illegal cycle */ interface{ Z21 }
+func F21[T Z21]() { ( /* ERROR not used */ F21[Z21]) }
+
+// crash 24
+type T24[P any] P
+func (r T24[P]) m() { T24 /* ERROR without instantiation */ .m() }
+
+// crash 25
+type T25[A any] int
+func (t T25[A]) m1() {}
+var x T25 /* ERROR without instantiation */ .m1
+
+// crash 26
+type T26 = interface{ F26[ /* ERROR cannot have type parameters */ Z any]() }
+func F26[Z any]() T26 { return F26 /* ERROR without instantiation */ /* ERROR missing method */ [] /* ERROR operand */ }
+
+// crash 27
+func e27[T any]() interface{ x27 /* ERROR not a type */ }
+func x27() { e27( /* ERROR cannot infer T */ ) }
\ No newline at end of file
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39664.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39664.go2
new file mode 100644
index 0000000000..cf566c3e24
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39664.go2
@@ -0,0 +1,16 @@
+// UNREVIEWED
+// Copyright 2020 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 p
+
+type T[_ any] struct {}
+
+func (T /* ERROR instantiation */ ) m()
+
+func _() {
+	var x interface { m() }
+	x = T[int]{}
+	_ = x
+}
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39680.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39680.go2
new file mode 100644
index 0000000000..3239c57d43
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39680.go2
@@ -0,0 +1,28 @@
+// UNREVIEWED
+// Copyright 2020 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 p
+
+import "fmt"
+
+// Minimal test case.
+func _[T interface{type T}](x T) T{
+	return x
+}
+
+// Test case from issue.
+type constr[T any] interface {
+	type T
+}
+
+func Print[T constr[T]](s []T) {
+	for _, v := range s {
+		fmt.Print(v)
+	}
+}
+
+func f() {
+	Print([]string{"Hello, ", "playground\n"})
+}
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39693.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39693.go2
new file mode 100644
index 0000000000..6f4d701185
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39693.go2
@@ -0,0 +1,15 @@
+// UNREVIEWED
+// Copyright 2020 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 p
+
+type Number interface {
+	int     /* ERROR int is not an interface */
+	float64 /* ERROR float64 is not an interface */
+}
+
+func Add[T Number](a, b T) T {
+	return a /* ERROR not defined */ + b
+}
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39699.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39699.go2
new file mode 100644
index 0000000000..c8655efee5
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39699.go2
@@ -0,0 +1,30 @@
+// UNREVIEWED
+// Copyright 2020 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 p
+
+type T0 interface{
+}
+
+type T1 interface{
+	type int
+}
+
+type T2 interface{
+	comparable
+}
+
+type T3 interface {
+	T0
+	T1
+	T2
+}
+
+func _() {
+	_ = T0(0)
+	_ = T1 /* ERROR cannot use interface T1 in conversion */ (1)
+	_ = T2 /* ERROR cannot use interface T2 in conversion */ (2)
+	_ = T3 /* ERROR cannot use interface T3 in conversion */ (3)
+}
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39711.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39711.go2
new file mode 100644
index 0000000000..8edce78c10
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39711.go2
@@ -0,0 +1,12 @@
+// UNREVIEWED
+// Copyright 2020 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 p
+
+// Do not report a duplicate type error for this type list.
+// (Check types after interfaces have been completed.)
+type _ interface {
+	type interface{ Error() string }, interface{ String() string }
+}
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39723.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39723.go2
new file mode 100644
index 0000000000..8a4006ef84
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39723.go2
@@ -0,0 +1,10 @@
+// UNREVIEWED
+// Copyright 2020 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 p
+
+// A constraint must be an interface; it cannot
+// be a type parameter, for instance.
+func _[A interface{ type interface{} }, B A /* ERROR not an interface */ ]()
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39725.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39725.go2
new file mode 100644
index 0000000000..6de661a38e
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39725.go2
@@ -0,0 +1,17 @@
+// UNREVIEWED
+// Copyright 2020 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 p
+
+func f1[T1, T2 any](T1, T2, struct{a T1; b T2})
+func _() {
+	f1(42, string("foo"), struct /* ERROR does not match inferred type struct\{a int; b string\} */ {a, b int}{})
+}
+
+// simplified test case from issue
+func f2[T any](_ []T, _ func(T))
+func _() {
+	f2([]string{}, func /* ERROR does not match inferred type func\(string\) */ (f []byte) {})
+}
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39754.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39754.go2
new file mode 100644
index 0000000000..36b774faaf
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39754.go2
@@ -0,0 +1,21 @@
+// UNREVIEWED
+// Copyright 2020 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 p
+
+type Optional[T any] struct {}
+
+func (_ Optional[T]) Val() (T, bool)
+
+type Box[T any] interface {
+	Val() (T, bool)
+}
+
+func f[V interface{}, A, B Box[V]]() {}
+
+func _() {
+	f[int, Optional[int], Optional[int]]()
+	f[int, Optional[int], Optional /* ERROR does not satisfy Box */ [string]]()
+}
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39755.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39755.go2
new file mode 100644
index 0000000000..93aea85215
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39755.go2
@@ -0,0 +1,24 @@
+// UNREVIEWED
+// Copyright 2020 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 p
+
+func _[T interface{type map[string]int}](x T) {
+	_ = x == nil
+}
+
+// simplified test case from issue
+
+type PathParamsConstraint interface {
+        type map[string]string, []struct{key, value string}
+}
+
+type PathParams[T PathParamsConstraint] struct {
+	t T
+}
+
+func (pp *PathParams[T]) IsNil() bool {
+	return pp.t == nil // this must succeed
+}
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39768.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39768.go2
new file mode 100644
index 0000000000..81b4a91f2c
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39768.go2
@@ -0,0 +1,21 @@
+// UNREVIEWED
+// Copyright 2020 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 p
+
+type T[P any] P
+type A = T
+var x A[int]
+var _ A /* ERROR cannot use generic type */
+
+type B = T[int]
+var y B = x
+var _ B /* ERROR not a generic type */ [int]
+
+// test case from issue
+
+type Vector[T any] []T
+type VectorAlias = Vector
+var v Vector[int]
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39938.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39938.go2
new file mode 100644
index 0000000000..19e69e6486
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39938.go2
@@ -0,0 +1,51 @@
+// UNREVIEWED
+// Copyright 2020 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.
+
+// Check "infinite expansion" cycle errors across instantiated types.
+
+package p
+
+type E0[P any] P
+type E1[P any] *P
+type E2[P any] struct{ P }
+type E3[P any] struct{ *P }
+
+type T0 /* ERROR illegal cycle */ struct {
+        _ E0[T0]
+}
+
+type T0_ /* ERROR illegal cycle */ struct {
+        E0[T0_]
+}
+
+type T1 struct {
+        _ E1[T1]
+}
+
+type T2 /* ERROR illegal cycle */ struct {
+        _ E2[T2]
+}
+
+type T3 struct {
+        _ E3[T3]
+}
+
+// some more complex cases
+
+type T4 /* ERROR illegal cycle */ struct {
+	_ E0[E2[T4]]
+}
+
+type T5 struct {
+	_ E0[E2[E0[E1[E2[[10]T5]]]]]
+}
+
+type T6 /* ERROR illegal cycle */ struct {
+	_ E0[[10]E2[E0[E2[E2[T6]]]]]
+}
+
+type T7 struct {
+	_ E0[[]E2[E0[E2[E2[T6]]]]]
+}
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39948.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39948.go2
new file mode 100644
index 0000000000..dede9c5797
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39948.go2
@@ -0,0 +1,10 @@
+// UNREVIEWED
+// Copyright 2020 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 p
+
+type T[P any] interface{
+	P // ERROR P is a type parameter, not an interface
+}
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39976.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39976.go2
new file mode 100644
index 0000000000..2ab9664f88
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39976.go2
@@ -0,0 +1,17 @@
+// UNREVIEWED
+// Copyright 2020 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 p
+
+type policy[K, V any] interface{}
+type LRU[K, V any] struct{}
+
+func NewCache[K, V any](p policy[K, V])
+
+func _() {
+	var lru LRU[int, string]
+	NewCache[int, string](&lru)
+	NewCache(& /* ERROR does not match policy\[K, V\] \(cannot infer K and V\) */ lru)
+}
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39982.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39982.go2
new file mode 100644
index 0000000000..3abdfcb1b0
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39982.go2
@@ -0,0 +1,37 @@
+// UNREVIEWED
+// Copyright 2020 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 p
+
+type (
+	T[_ any] struct{}
+	S[_ any] struct {
+		data T[*T[int]]
+	}
+)
+
+func _() {
+	_ = S[int]{
+		data: T[*T[int]]{},
+	}
+}
+
+// full test case from issue
+
+type (
+	Element[TElem any] struct{}
+
+	entry[K comparable] struct{}
+
+	Cache[K comparable] struct {
+		data map[K]*Element[*entry[K]]
+	}
+)
+
+func _() {
+	_ = Cache[int]{
+		data: make(map[int](*Element[*entry[int]])),
+	}
+}
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue40038.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue40038.go2
new file mode 100644
index 0000000000..fe3963aac2
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue40038.go2
@@ -0,0 +1,16 @@
+// UNREVIEWED
+// Copyright 2020 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 p
+
+type A[T any] int
+
+func (A[T]) m(A[T])
+
+func f[P interface{m(P)}]()
+
+func _() {
+	_ = f[A[int]]
+}
\ No newline at end of file
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue40056.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue40056.go2
new file mode 100644
index 0000000000..0c78c3f289
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue40056.go2
@@ -0,0 +1,16 @@
+// UNREVIEWED
+// Copyright 2020 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 p
+
+func _() {
+	NewS( /* ERROR cannot infer T */ ) .M()
+}
+
+type S struct {}
+
+func NewS[T any]() *S
+
+func (_ *S /* ERROR S is not a generic type */ [T]) M()
\ No newline at end of file
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue40057.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue40057.go2
new file mode 100644
index 0000000000..b2ff11e4bf
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue40057.go2
@@ -0,0 +1,18 @@
+// UNREVIEWED
+// Copyright 2020 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 p
+
+func _() {
+	var x interface{}
+	switch t := x.(type) {
+	case S /* ERROR cannot use generic type */ :
+		t.m()
+	}
+}
+
+type S[T any] struct {}
+
+func (_ S[T]) m()
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue40301.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue40301.go2
new file mode 100644
index 0000000000..6a3dfc741e
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue40301.go2
@@ -0,0 +1,13 @@
+// UNREVIEWED
+// Copyright 2020 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 p
+
+import "unsafe"
+
+func _[T any](x T) {
+	_ = unsafe /* ERROR undefined */ .Alignof(x)
+	_ = unsafe /* ERROR undefined */ .Sizeof(x)
+}
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue40684.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue40684.go2
new file mode 100644
index 0000000000..001c6d7b99
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue40684.go2
@@ -0,0 +1,16 @@
+// UNREVIEWED
+// Copyright 2020 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 p
+
+type T[_ any] int
+
+func f[_ any]()
+func g[_, _ any]()
+
+func _() {
+	_ = f[T /* ERROR without instantiation */ ]
+	_ = g[T /* ERROR without instantiation */ , T /* ERROR without instantiation */ ]
+}
\ No newline at end of file
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue41124.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue41124.go2
new file mode 100644
index 0000000000..3098f44948
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue41124.go2
@@ -0,0 +1,92 @@
+// UNREVIEWED
+// Copyright 2020 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 p
+
+// Test case from issue.
+
+type Nat interface {
+	type Zero, Succ
+}
+
+type Zero struct{}
+type Succ struct{
+	Nat // ERROR interface contains type constraints
+}
+
+// Struct tests.
+
+type I1 interface {
+	comparable
+}
+
+type I2 interface {
+	type int
+}
+
+type I3 interface {
+	I1
+	I2
+}
+
+type _ struct {
+	f I1 // ERROR interface is .* comparable
+}
+
+type _ struct {
+	comparable // ERROR interface is .* comparable
+}
+
+type _ struct{
+	I1 // ERROR interface is .* comparable
+}
+
+type _ struct{
+	I2 // ERROR interface contains type constraints
+}
+
+type _ struct{
+	I3 // ERROR interface contains type constraints
+}
+
+// General composite types.
+
+type (
+	_ [10]I1 // ERROR interface is .* comparable
+	_ [10]I2 // ERROR interface contains type constraints
+
+	_ []I1 // ERROR interface is .* comparable
+	_ []I2 // ERROR interface contains type constraints
+
+	_ *I3 // ERROR interface contains type constraints
+	_ map[I1 /* ERROR interface is .* comparable */ ]I2 // ERROR interface contains type constraints
+	_ chan I3 // ERROR interface contains type constraints
+	_ func(I1 /* ERROR interface is .* comparable */ )
+	_ func() I2 // ERROR interface contains type constraints
+)
+
+// Other cases.
+
+var _ = [...]I3 /* ERROR interface contains type constraints */ {}
+
+func _(x interface{}) {
+	_ = x.(I3 /* ERROR interface contains type constraints */ )
+}
+
+type T1[_ any] struct{}
+type T3[_, _, _ any] struct{}
+var _ T1[I2 /* ERROR interface contains type constraints */ ]
+var _ T3[int, I2 /* ERROR interface contains type constraints */ , float32]
+
+func f1[_ any]() int
+var _ = f1[I2 /* ERROR interface contains type constraints */ ]()
+func f3[_, _, _ any]() int
+var _ = f3[int, I2 /* ERROR interface contains type constraints */ , float32]()
+
+func _(x interface{}) {
+	switch x.(type) {
+	case I2 /* ERROR interface contains type constraints */ :
+	}
+}
diff --git a/src/cmd/compile/internal/types2/gccgosizes.go b/src/cmd/compile/internal/types2/gccgosizes.go
new file mode 100644
index 0000000000..d3c79745a2
--- /dev/null
+++ b/src/cmd/compile/internal/types2/gccgosizes.go
@@ -0,0 +1,41 @@
+// UNREVIEWED
+// Copyright 2019 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.
+
+// This is a copy of the file generated during the gccgo build process.
+// Last update 2019-01-22.
+
+package types2
+
+var gccgoArchSizes = map[string]*StdSizes{
+	"386":         {4, 4},
+	"alpha":       {8, 8},
+	"amd64":       {8, 8},
+	"amd64p32":    {4, 8},
+	"arm":         {4, 8},
+	"armbe":       {4, 8},
+	"arm64":       {8, 8},
+	"arm64be":     {8, 8},
+	"ia64":        {8, 8},
+	"m68k":        {4, 2},
+	"mips":        {4, 8},
+	"mipsle":      {4, 8},
+	"mips64":      {8, 8},
+	"mips64le":    {8, 8},
+	"mips64p32":   {4, 8},
+	"mips64p32le": {4, 8},
+	"nios2":       {4, 8},
+	"ppc":         {4, 8},
+	"ppc64":       {8, 8},
+	"ppc64le":     {8, 8},
+	"riscv":       {4, 8},
+	"riscv64":     {8, 8},
+	"s390":        {4, 8},
+	"s390x":       {8, 8},
+	"sh":          {4, 8},
+	"shbe":        {4, 8},
+	"sparc":       {4, 8},
+	"sparc64":     {8, 8},
+	"wasm":        {8, 8},
+}
diff --git a/src/cmd/compile/internal/types2/hilbert_test.go b/src/cmd/compile/internal/types2/hilbert_test.go
new file mode 100644
index 0000000000..ee0c4daea6
--- /dev/null
+++ b/src/cmd/compile/internal/types2/hilbert_test.go
@@ -0,0 +1,220 @@
+// UNREVIEWED
+// Copyright 2013 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 types2_test
+
+import (
+	"bytes"
+	"cmd/compile/internal/syntax"
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"testing"
+
+	. "cmd/compile/internal/types2"
+)
+
+var (
+	H   = flag.Int("H", 5, "Hilbert matrix size")
+	out = flag.String("out", "", "write generated program to out")
+)
+
+func TestHilbert(t *testing.T) {
+	// generate source
+	src := program(*H, *out)
+	if *out != "" {
+		ioutil.WriteFile(*out, src, 0666)
+		return
+	}
+
+	// parse source
+	// TODO(gri) get rid of []bytes to string conversion below
+	f, err := parseSrc("hilbert.go", string(src))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// type-check file
+	DefPredeclaredTestFuncs() // define assert built-in
+	conf := Config{Importer: defaultImporter()}
+	_, err = conf.Check(f.PkgName.Value, []*syntax.File{f}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func program(n int, out string) []byte {
+	var g gen
+
+	g.p(`// Code generated by: go test -run=Hilbert -H=%d -out=%q. DO NOT EDIT.
+
+// +`+`build ignore
+
+// This program tests arbitrary precision constant arithmetic
+// by generating the constant elements of a Hilbert matrix H,
+// its inverse I, and the product P = H*I. The product should
+// be the identity matrix.
+package main
+
+func main() {
+	if !ok {
+		printProduct()
+		return
+	}
+	println("PASS")
+}
+
+`, n, out)
+	g.hilbert(n)
+	g.inverse(n)
+	g.product(n)
+	g.verify(n)
+	g.printProduct(n)
+	g.binomials(2*n - 1)
+	g.factorials(2*n - 1)
+
+	return g.Bytes()
+}
+
+type gen struct {
+	bytes.Buffer
+}
+
+func (g *gen) p(format string, args ...interface{}) {
+	fmt.Fprintf(&g.Buffer, format, args...)
+}
+
+func (g *gen) hilbert(n int) {
+	g.p(`// Hilbert matrix, n = %d
+const (
+`, n)
+	for i := 0; i < n; i++ {
+		g.p("\t")
+		for j := 0; j < n; j++ {
+			if j > 0 {
+				g.p(", ")
+			}
+			g.p("h%d_%d", i, j)
+		}
+		if i == 0 {
+			g.p(" = ")
+			for j := 0; j < n; j++ {
+				if j > 0 {
+					g.p(", ")
+				}
+				g.p("1.0/(iota + %d)", j+1)
+			}
+		}
+		g.p("\n")
+	}
+	g.p(")\n\n")
+}
+
+func (g *gen) inverse(n int) {
+	g.p(`// Inverse Hilbert matrix
+const (
+`)
+	for i := 0; i < n; i++ {
+		for j := 0; j < n; j++ {
+			s := "+"
+			if (i+j)&1 != 0 {
+				s = "-"
+			}
+			g.p("\ti%d_%d = %s%d * b%d_%d * b%d_%d * b%d_%d * b%d_%d\n",
+				i, j, s, i+j+1, n+i, n-j-1, n+j, n-i-1, i+j, i, i+j, i)
+		}
+		g.p("\n")
+	}
+	g.p(")\n\n")
+}
+
+func (g *gen) product(n int) {
+	g.p(`// Product matrix
+const (
+`)
+	for i := 0; i < n; i++ {
+		for j := 0; j < n; j++ {
+			g.p("\tp%d_%d = ", i, j)
+			for k := 0; k < n; k++ {
+				if k > 0 {
+					g.p(" + ")
+				}
+				g.p("h%d_%d*i%d_%d", i, k, k, j)
+			}
+			g.p("\n")
+		}
+		g.p("\n")
+	}
+	g.p(")\n\n")
+}
+
+func (g *gen) verify(n int) {
+	g.p(`// Verify that product is the identity matrix
+const ok =
+`)
+	for i := 0; i < n; i++ {
+		for j := 0; j < n; j++ {
+			if j == 0 {
+				g.p("\t")
+			} else {
+				g.p(" && ")
+			}
+			v := 0
+			if i == j {
+				v = 1
+			}
+			g.p("p%d_%d == %d", i, j, v)
+		}
+		g.p(" &&\n")
+	}
+	g.p("\ttrue\n\n")
+
+	// verify ok at type-check time
+	if *out == "" {
+		g.p("const _ = assert(ok)\n\n")
+	}
+}
+
+func (g *gen) printProduct(n int) {
+	g.p("func printProduct() {\n")
+	for i := 0; i < n; i++ {
+		g.p("\tprintln(")
+		for j := 0; j < n; j++ {
+			if j > 0 {
+				g.p(", ")
+			}
+			g.p("p%d_%d", i, j)
+		}
+		g.p(")\n")
+	}
+	g.p("}\n\n")
+}
+
+func (g *gen) binomials(n int) {
+	g.p(`// Binomials
+const (
+`)
+	for j := 0; j <= n; j++ {
+		if j > 0 {
+			g.p("\n")
+		}
+		for k := 0; k <= j; k++ {
+			g.p("\tb%d_%d = f%d / (f%d*f%d)\n", j, k, j, k, j-k)
+		}
+	}
+	g.p(")\n\n")
+}
+
+func (g *gen) factorials(n int) {
+	g.p(`// Factorials
+const (
+	f0 = 1
+	f1 = 1
+`)
+	for i := 2; i <= n; i++ {
+		g.p("\tf%d = f%d * %d\n", i, i-1, i)
+	}
+	g.p(")\n\n")
+}
diff --git a/src/cmd/compile/internal/types2/importer_test.go b/src/cmd/compile/internal/types2/importer_test.go
new file mode 100644
index 0000000000..90476c4269
--- /dev/null
+++ b/src/cmd/compile/internal/types2/importer_test.go
@@ -0,0 +1,36 @@
+// UNREVIEWED
+// Copyright 2020 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.
+
+// This file implements the (temporary) plumbing to get importing to work.
+
+package types2_test
+
+import (
+	gcimporter "cmd/compile/internal/importer"
+	"cmd/compile/internal/types2"
+	"io"
+)
+
+func defaultImporter() types2.Importer {
+	return &gcimports{
+		packages: make(map[string]*types2.Package),
+	}
+}
+
+type gcimports struct {
+	packages map[string]*types2.Package
+	lookup   func(path string) (io.ReadCloser, error)
+}
+
+func (m *gcimports) Import(path string) (*types2.Package, error) {
+	return m.ImportFrom(path, "" /* no vendoring */, 0)
+}
+
+func (m *gcimports) ImportFrom(path, srcDir string, mode types2.ImportMode) (*types2.Package, error) {
+	if mode != 0 {
+		panic("mode must be 0")
+	}
+	return gcimporter.Import(m.packages, path, srcDir, m.lookup)
+}
diff --git a/src/cmd/compile/internal/types2/infer.go b/src/cmd/compile/internal/types2/infer.go
new file mode 100644
index 0000000000..b52a834e5a
--- /dev/null
+++ b/src/cmd/compile/internal/types2/infer.go
@@ -0,0 +1,359 @@
+// UNREVIEWED
+// Copyright 2018 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.
+
+// This file implements type parameter inference given
+// a list of concrete arguments and a parameter list.
+
+package types2
+
+import "strings"
+
+// infer returns the list of actual type arguments for the given list of type parameters tparams
+// by inferring them from the actual arguments args for the parameters params. If type inference
+// is impossible because unification fails, an error is reported and the resulting types list is
+// nil, and index is 0. Otherwise, types is the list of inferred type arguments, and index is
+// the index of the first type argument in that list that couldn't be inferred (and thus is nil).
+// If all type arguments where inferred successfully, index is < 0.
+func (check *Checker) infer(tparams []*TypeName, params *Tuple, args []*operand) (types []Type, index int) {
+	assert(params.Len() == len(args))
+
+	u := newUnifier(check, false)
+	u.x.init(tparams)
+
+	errorf := func(kind string, tpar, targ Type, arg *operand) {
+		// provide a better error message if we can
+		targs, failed := u.x.types()
+		if failed == 0 {
+			// The first type parameter couldn't be inferred.
+			// If none of them could be inferred, don't try
+			// to provide the inferred type in the error msg.
+			allFailed := true
+			for _, targ := range targs {
+				if targ != nil {
+					allFailed = false
+					break
+				}
+			}
+			if allFailed {
+				check.errorf(arg, "%s %s of %s does not match %s (cannot infer %s)", kind, targ, arg.expr, tpar, typeNamesString(tparams))
+				return
+			}
+		}
+		smap := makeSubstMap(tparams, targs)
+		inferred := check.subst(arg.Pos(), tpar, smap)
+		if inferred != tpar {
+			check.errorf(arg, "%s %s of %s does not match inferred type %s for %s", kind, targ, arg.expr, inferred, tpar)
+		} else {
+			check.errorf(arg, "%s %s of %s does not match %s", kind, targ, arg.expr, tpar)
+		}
+	}
+
+	// Terminology: generic parameter = function parameter with a type-parameterized type
+
+	// 1st pass: Unify parameter and argument types for generic parameters with typed arguments
+	//           and collect the indices of generic parameters with untyped arguments.
+	var indices []int
+	for i, arg := range args {
+		par := params.At(i)
+		// If we permit bidirectional unification, this conditional code needs to be
+		// executed even if par.typ is not parameterized since the argument may be a
+		// generic function (for which we want to infer // its type arguments).
+		if isParameterized(tparams, par.typ) {
+			if arg.mode == invalid {
+				// An error was reported earlier. Ignore this targ
+				// and continue, we may still be able to infer all
+				// targs resulting in fewer follon-on errors.
+				continue
+			}
+			if targ := arg.typ; isTyped(targ) {
+				// If we permit bidirectional unification, and targ is
+				// a generic function, we need to initialize u.y with
+				// the respectice type parameters of targ.
+				if !u.unify(par.typ, targ) {
+					errorf("type", par.typ, targ, arg)
+					return nil, 0
+				}
+			} else {
+				indices = append(indices, i)
+			}
+		}
+	}
+
+	// Some generic parameters with untyped arguments may have been given a type
+	// indirectly through another generic parameter with a typed argument; we can
+	// ignore those now. (This only means that we know the types for those generic
+	// parameters; it doesn't mean untyped arguments can be passed safely. We still
+	// need to verify that assignment of those arguments is valid when we check
+	// function parameter passing external to infer.)
+	j := 0
+	for _, i := range indices {
+		par := params.At(i)
+		// Since untyped types are all basic (i.e., non-composite) types, an
+		// untyped argument will never match a composite parameter type; the
+		// only parameter type it can possibly match against is a *TypeParam.
+		// Thus, only keep the indices of generic parameters that are not of
+		// composite types and which don't have a type inferred yet.
+		if tpar, _ := par.typ.(*TypeParam); tpar != nil && u.x.at(tpar.index) == nil {
+			indices[j] = i
+			j++
+		}
+	}
+	indices = indices[:j]
+
+	// 2nd pass: Unify parameter and default argument types for remaining generic parameters.
+	for _, i := range indices {
+		par := params.At(i)
+		arg := args[i]
+		targ := Default(arg.typ)
+		// The default type for an untyped nil is untyped nil. We must not
+		// infer an untyped nil type as type parameter type. Ignore untyped
+		// nil by making sure all default argument types are typed.
+		if isTyped(targ) && !u.unify(par.typ, targ) {
+			errorf("default type", par.typ, targ, arg)
+			return nil, 0
+		}
+	}
+
+	return u.x.types()
+}
+
+// typeNamesString produces a string containing all the
+// type names in list suitable for human consumption.
+func typeNamesString(list []*TypeName) string {
+	// common cases
+	n := len(list)
+	switch n {
+	case 0:
+		return ""
+	case 1:
+		return list[0].name
+	case 2:
+		return list[0].name + " and " + list[1].name
+	}
+
+	// general case (n > 2)
+	var b strings.Builder
+	for i, tname := range list[:n-1] {
+		if i > 0 {
+			b.WriteString(", ")
+		}
+		b.WriteString(tname.name)
+	}
+	b.WriteString(", and ")
+	b.WriteString(list[n-1].name)
+	return b.String()
+}
+
+// IsParameterized reports whether typ contains any of the type parameters of tparams.
+func isParameterized(tparams []*TypeName, typ Type) bool {
+	w := tpWalker{
+		seen:    make(map[Type]bool),
+		tparams: tparams,
+	}
+	return w.isParameterized(typ)
+}
+
+type tpWalker struct {
+	seen    map[Type]bool
+	tparams []*TypeName
+}
+
+func (w *tpWalker) isParameterized(typ Type) (res bool) {
+	// detect cycles
+	if x, ok := w.seen[typ]; ok {
+		return x
+	}
+	w.seen[typ] = false
+	defer func() {
+		w.seen[typ] = res
+	}()
+
+	switch t := typ.(type) {
+	case nil, *Basic: // TODO(gri) should nil be handled here?
+		break
+
+	case *Array:
+		return w.isParameterized(t.elem)
+
+	case *Slice:
+		return w.isParameterized(t.elem)
+
+	case *Struct:
+		for _, fld := range t.fields {
+			if w.isParameterized(fld.typ) {
+				return true
+			}
+		}
+
+	case *Pointer:
+		return w.isParameterized(t.base)
+
+	case *Tuple:
+		n := t.Len()
+		for i := 0; i < n; i++ {
+			if w.isParameterized(t.At(i).typ) {
+				return true
+			}
+		}
+
+	case *Sum:
+		return w.isParameterizedList(t.types)
+
+	case *Signature:
+		// t.tparams may not be nil if we are looking at a signature
+		// of a generic function type (or an interface method) that is
+		// part of the type we're testing. We don't care about these type
+		// parameters.
+		// Similarly, the receiver of a method may declare (rather then
+		// use) type parameters, we don't care about those either.
+		// Thus, we only need to look at the input and result parameters.
+		return w.isParameterized(t.params) || w.isParameterized(t.results)
+
+	case *Interface:
+		if t.allMethods != nil {
+			// interface is complete - quick test
+			for _, m := range t.allMethods {
+				if w.isParameterized(m.typ) {
+					return true
+				}
+			}
+			return w.isParameterizedList(unpack(t.allTypes))
+		}
+
+		return t.iterate(func(t *Interface) bool {
+			for _, m := range t.methods {
+				if w.isParameterized(m.typ) {
+					return true
+				}
+			}
+			return w.isParameterizedList(unpack(t.types))
+		}, nil)
+
+	case *Map:
+		return w.isParameterized(t.key) || w.isParameterized(t.elem)
+
+	case *Chan:
+		return w.isParameterized(t.elem)
+
+	case *Named:
+		return w.isParameterizedList(t.targs)
+
+	case *TypeParam:
+		// t must be one of w.tparams
+		return t.index < len(w.tparams) && w.tparams[t.index].typ == t
+
+	case *instance:
+		return w.isParameterizedList(t.targs)
+
+	default:
+		unreachable()
+	}
+
+	return false
+}
+
+func (w *tpWalker) isParameterizedList(list []Type) bool {
+	for _, t := range list {
+		if w.isParameterized(t) {
+			return true
+		}
+	}
+	return false
+}
+
+// inferB returns the list of actual type arguments inferred from the type parameters'
+// bounds and an initial set of type arguments. If type inference is impossible because
+// unification fails, an error is reported, the resulting types list is nil, and index is 0.
+// Otherwise, types is the list of inferred type arguments, and index is the index of the
+// first type argument in that list that couldn't be inferred (and thus is nil). If all
+// type arguments where inferred successfully, index is < 0. The number of type arguments
+// provided may be less than the number of type parameters, but there must be at least one.
+func (check *Checker) inferB(tparams []*TypeName, targs []Type) (types []Type, index int) {
+	assert(len(tparams) >= len(targs) && len(targs) > 0)
+
+	// Setup bidirectional unification between those structural bounds
+	// and the corresponding type arguments (which may be nil!).
+	u := newUnifier(check, false)
+	u.x.init(tparams)
+	u.y = u.x // type parameters between LHS and RHS of unification are identical
+
+	// Set the type arguments which we know already.
+	for i, targ := range targs {
+		if targ != nil {
+			u.x.set(i, targ)
+		}
+	}
+
+	// Unify type parameters with their structural constraints, if any.
+	for _, tpar := range tparams {
+		typ := tpar.typ.(*TypeParam)
+		sbound := check.structuralType(typ.bound.Under())
+		if sbound != nil {
+			//check.dump(">>> unify(%s, %s)", tpar, sbound)
+			if !u.unify(typ, sbound) {
+				check.errorf(tpar.pos, "%s does not match %s", tpar, sbound)
+				return nil, 0
+			}
+			//check.dump(">>> => indices = %v, types = %s", u.x.indices, u.types)
+		}
+	}
+
+	// u.x.types() now contains the incoming type arguments plus any additional type
+	// arguments for which there were structural constraints. The newly inferred non-
+	// nil entries may still contain references to other type parameters. For instance,
+	// for [type A interface{}, B interface{type []C}, C interface{type *A}], if A == int
+	// was given, unification produced the type list [int, []C, *A]. We eliminate the
+	// remaining type parameters by substituting the type parameters in this type list
+	// until nothing changes anymore.
+	types, index = u.x.types()
+	if debug {
+		for i, targ := range targs {
+			assert(targ == nil || types[i] == targ)
+		}
+	}
+
+	// dirty tracks the indices of all types that may still contain type parameters.
+	// We know that nil types entries and entries corresponding to provided (non-nil)
+	// type arguments are clean, so exclude them from the start.
+	var dirty []int
+	for i, typ := range types {
+		if typ != nil && (i >= len(targs) || targs[i] == nil) {
+			dirty = append(dirty, i)
+		}
+	}
+
+	for len(dirty) > 0 {
+		// TODO(gri) Instead of creating a new smap for each iteration,
+		// provide an update operation for smaps and only change when
+		// needed. Optimization.
+		smap := makeSubstMap(tparams, types)
+		n := 0
+		for _, index := range dirty {
+			t0 := types[index]
+			if t1 := check.subst(nopos, t0, smap); t1 != t0 {
+				types[index] = t1
+				dirty[n] = index
+				n++
+			}
+		}
+		dirty = dirty[:n]
+	}
+	//check.dump(">>> inferred types = %s", types)
+
+	return
+}
+
+// structuralType returns the structural type of a constraint, if any.
+func (check *Checker) structuralType(constraint Type) Type {
+	if iface, _ := constraint.(*Interface); iface != nil {
+		check.completeInterface(nopos, iface)
+		types := unpack(iface.allTypes)
+		if len(types) == 1 {
+			return types[0]
+		}
+		return nil
+	}
+	return constraint
+}
diff --git a/src/cmd/compile/internal/types2/initorder.go b/src/cmd/compile/internal/types2/initorder.go
new file mode 100644
index 0000000000..3bb92d9622
--- /dev/null
+++ b/src/cmd/compile/internal/types2/initorder.go
@@ -0,0 +1,298 @@
+// UNREVIEWED
+// Copyright 2014 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 types2
+
+import (
+	"container/heap"
+	"fmt"
+)
+
+// initOrder computes the Info.InitOrder for package variables.
+func (check *Checker) initOrder() {
+	// An InitOrder may already have been computed if a package is
+	// built from several calls to (*Checker).Files. Clear it.
+	check.Info.InitOrder = check.Info.InitOrder[:0]
+
+	// Compute the object dependency graph and initialize
+	// a priority queue with the list of graph nodes.
+	pq := nodeQueue(dependencyGraph(check.objMap))
+	heap.Init(&pq)
+
+	const debug = false
+	if debug {
+		fmt.Printf("Computing initialization order for %s\n\n", check.pkg)
+		fmt.Println("Object dependency graph:")
+		for obj, d := range check.objMap {
+			// only print objects that may appear in the dependency graph
+			if obj, _ := obj.(dependency); obj != nil {
+				if len(d.deps) > 0 {
+					fmt.Printf("\t%s depends on\n", obj.Name())
+					for dep := range d.deps {
+						fmt.Printf("\t\t%s\n", dep.Name())
+					}
+				} else {
+					fmt.Printf("\t%s has no dependencies\n", obj.Name())
+				}
+			}
+		}
+		fmt.Println()
+
+		fmt.Println("Transposed object dependency graph (functions eliminated):")
+		for _, n := range pq {
+			fmt.Printf("\t%s depends on %d nodes\n", n.obj.Name(), n.ndeps)
+			for p := range n.pred {
+				fmt.Printf("\t\t%s is dependent\n", p.obj.Name())
+			}
+		}
+		fmt.Println()
+
+		fmt.Println("Processing nodes:")
+	}
+
+	// Determine initialization order by removing the highest priority node
+	// (the one with the fewest dependencies) and its edges from the graph,
+	// repeatedly, until there are no nodes left.
+	// In a valid Go program, those nodes always have zero dependencies (after
+	// removing all incoming dependencies), otherwise there are initialization
+	// cycles.
+	emitted := make(map[*declInfo]bool)
+	for len(pq) > 0 {
+		// get the next node
+		n := heap.Pop(&pq).(*graphNode)
+
+		if debug {
+			fmt.Printf("\t%s (src pos %d) depends on %d nodes now\n",
+				n.obj.Name(), n.obj.order(), n.ndeps)
+		}
+
+		// if n still depends on other nodes, we have a cycle
+		if n.ndeps > 0 {
+			cycle := findPath(check.objMap, n.obj, n.obj, make(map[Object]bool))
+			// If n.obj is not part of the cycle (e.g., n.obj->b->c->d->c),
+			// cycle will be nil. Don't report anything in that case since
+			// the cycle is reported when the algorithm gets to an object
+			// in the cycle.
+			// Furthermore, once an object in the cycle is encountered,
+			// the cycle will be broken (dependency count will be reduced
+			// below), and so the remaining nodes in the cycle don't trigger
+			// another error (unless they are part of multiple cycles).
+			if cycle != nil {
+				check.reportCycle(cycle)
+			}
+			// Ok to continue, but the variable initialization order
+			// will be incorrect at this point since it assumes no
+			// cycle errors.
+		}
+
+		// reduce dependency count of all dependent nodes
+		// and update priority queue
+		for p := range n.pred {
+			p.ndeps--
+			heap.Fix(&pq, p.index)
+		}
+
+		// record the init order for variables with initializers only
+		v, _ := n.obj.(*Var)
+		info := check.objMap[v]
+		if v == nil || !info.hasInitializer() {
+			continue
+		}
+
+		// n:1 variable declarations such as: a, b = f()
+		// introduce a node for each lhs variable (here: a, b);
+		// but they all have the same initializer - emit only
+		// one, for the first variable seen
+		if emitted[info] {
+			continue // initializer already emitted, if any
+		}
+		emitted[info] = true
+
+		infoLhs := info.lhs // possibly nil (see declInfo.lhs field comment)
+		if infoLhs == nil {
+			infoLhs = []*Var{v}
+		}
+		init := &Initializer{infoLhs, info.init}
+		check.Info.InitOrder = append(check.Info.InitOrder, init)
+	}
+
+	if debug {
+		fmt.Println()
+		fmt.Println("Initialization order:")
+		for _, init := range check.Info.InitOrder {
+			fmt.Printf("\t%s\n", init)
+		}
+		fmt.Println()
+	}
+}
+
+// findPath returns the (reversed) list of objects []Object{to, ... from}
+// such that there is a path of object dependencies from 'from' to 'to'.
+// If there is no such path, the result is nil.
+func findPath(objMap map[Object]*declInfo, from, to Object, seen map[Object]bool) []Object {
+	if seen[from] {
+		return nil
+	}
+	seen[from] = true
+
+	for d := range objMap[from].deps {
+		if d == to {
+			return []Object{d}
+		}
+		if P := findPath(objMap, d, to, seen); P != nil {
+			return append(P, d)
+		}
+	}
+
+	return nil
+}
+
+// reportCycle reports an error for the given cycle.
+func (check *Checker) reportCycle(cycle []Object) {
+	obj := cycle[0]
+	check.errorf(obj, "initialization cycle for %s", obj.Name())
+	// subtle loop: print cycle[i] for i = 0, n-1, n-2, ... 1 for len(cycle) = n
+	for i := len(cycle) - 1; i >= 0; i-- {
+		check.errorf(obj, "\t%s refers to", obj.Name()) // secondary error, \t indented
+		obj = cycle[i]
+	}
+	// print cycle[0] again to close the cycle
+	check.errorf(obj, "\t%s", obj.Name())
+}
+
+// ----------------------------------------------------------------------------
+// Object dependency graph
+
+// A dependency is an object that may be a dependency in an initialization
+// expression. Only constants, variables, and functions can be dependencies.
+// Constants are here because constant expression cycles are reported during
+// initialization order computation.
+type dependency interface {
+	Object
+	isDependency()
+}
+
+// A graphNode represents a node in the object dependency graph.
+// Each node p in n.pred represents an edge p->n, and each node
+// s in n.succ represents an edge n->s; with a->b indicating that
+// a depends on b.
+type graphNode struct {
+	obj        dependency // object represented by this node
+	pred, succ nodeSet    // consumers and dependencies of this node (lazily initialized)
+	index      int        // node index in graph slice/priority queue
+	ndeps      int        // number of outstanding dependencies before this object can be initialized
+}
+
+type nodeSet map[*graphNode]bool
+
+func (s *nodeSet) add(p *graphNode) {
+	if *s == nil {
+		*s = make(nodeSet)
+	}
+	(*s)[p] = true
+}
+
+// dependencyGraph computes the object dependency graph from the given objMap,
+// with any function nodes removed. The resulting graph contains only constants
+// and variables.
+func dependencyGraph(objMap map[Object]*declInfo) []*graphNode {
+	// M is the dependency (Object) -> graphNode mapping
+	M := make(map[dependency]*graphNode)
+	for obj := range objMap {
+		// only consider nodes that may be an initialization dependency
+		if obj, _ := obj.(dependency); obj != nil {
+			M[obj] = &graphNode{obj: obj}
+		}
+	}
+
+	// compute edges for graph M
+	// (We need to include all nodes, even isolated ones, because they still need
+	// to be scheduled for initialization in correct order relative to other nodes.)
+	for obj, n := range M {
+		// for each dependency obj -> d (= deps[i]), create graph edges n->s and s->n
+		for d := range objMap[obj].deps {
+			// only consider nodes that may be an initialization dependency
+			if d, _ := d.(dependency); d != nil {
+				d := M[d]
+				n.succ.add(d)
+				d.pred.add(n)
+			}
+		}
+	}
+
+	// remove function nodes and collect remaining graph nodes in G
+	// (Mutually recursive functions may introduce cycles among themselves
+	// which are permitted. Yet such cycles may incorrectly inflate the dependency
+	// count for variables which in turn may not get scheduled for initialization
+	// in correct order.)
+	var G []*graphNode
+	for obj, n := range M {
+		if _, ok := obj.(*Func); ok {
+			// connect each predecessor p of n with each successor s
+			// and drop the function node (don't collect it in G)
+			for p := range n.pred {
+				// ignore self-cycles
+				if p != n {
+					// Each successor s of n becomes a successor of p, and
+					// each predecessor p of n becomes a predecessor of s.
+					for s := range n.succ {
+						// ignore self-cycles
+						if s != n {
+							p.succ.add(s)
+							s.pred.add(p)
+							delete(s.pred, n) // remove edge to n
+						}
+					}
+					delete(p.succ, n) // remove edge to n
+				}
+			}
+		} else {
+			// collect non-function nodes
+			G = append(G, n)
+		}
+	}
+
+	// fill in index and ndeps fields
+	for i, n := range G {
+		n.index = i
+		n.ndeps = len(n.succ)
+	}
+
+	return G
+}
+
+// ----------------------------------------------------------------------------
+// Priority queue
+
+// nodeQueue implements the container/heap interface;
+// a nodeQueue may be used as a priority queue.
+type nodeQueue []*graphNode
+
+func (a nodeQueue) Len() int { return len(a) }
+
+func (a nodeQueue) Swap(i, j int) {
+	x, y := a[i], a[j]
+	a[i], a[j] = y, x
+	x.index, y.index = j, i
+}
+
+func (a nodeQueue) Less(i, j int) bool {
+	x, y := a[i], a[j]
+	// nodes are prioritized by number of incoming dependencies (1st key)
+	// and source order (2nd key)
+	return x.ndeps < y.ndeps || x.ndeps == y.ndeps && x.obj.order() < y.obj.order()
+}
+
+func (a *nodeQueue) Push(x interface{}) {
+	panic("unreachable")
+}
+
+func (a *nodeQueue) Pop() interface{} {
+	n := len(*a)
+	x := (*a)[n-1]
+	x.index = -1 // for safety
+	*a = (*a)[:n-1]
+	return x
+}
diff --git a/src/cmd/compile/internal/types2/issues_test.go b/src/cmd/compile/internal/types2/issues_test.go
new file mode 100644
index 0000000000..6d39f99424
--- /dev/null
+++ b/src/cmd/compile/internal/types2/issues_test.go
@@ -0,0 +1,533 @@
+// UNREVIEWED
+// Copyright 2013 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.
+
+// This file implements tests for various issues.
+
+package types2_test
+
+import (
+	"bytes"
+	"cmd/compile/internal/syntax"
+	"fmt"
+	"internal/testenv"
+	"sort"
+	"strings"
+	"testing"
+
+	. "cmd/compile/internal/types2"
+)
+
+func mustParse(t *testing.T, src string) *syntax.File {
+	f, err := parseSrc("", src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return f
+}
+func TestIssue5770(t *testing.T) {
+	f := mustParse(t, `package p; type S struct{T}`)
+	var conf Config
+	// conf := Config{Importer: importer.Default()}
+	_, err := conf.Check(f.PkgName.Value, []*syntax.File{f}, nil) // do not crash
+	want := "undeclared name: T"
+	if err == nil || !strings.Contains(err.Error(), want) {
+		t.Errorf("got: %v; want: %s", err, want)
+	}
+}
+
+func TestIssue5849(t *testing.T) {
+	src := `
+package p
+var (
+	s uint
+	_ = uint8(8)
+	_ = uint16(16) << s
+	_ = uint32(32 << s)
+	_ = uint64(64 << s + s)
+	_ = (interface{})("foo")
+	_ = (interface{})(nil)
+)`
+	f := mustParse(t, src)
+
+	var conf Config
+	types := make(map[syntax.Expr]TypeAndValue)
+	_, err := conf.Check(f.PkgName.Value, []*syntax.File{f}, &Info{Types: types})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for x, tv := range types {
+		var want Type
+		switch x := x.(type) {
+		case *syntax.BasicLit:
+			switch x.Value {
+			case `8`:
+				want = Typ[Uint8]
+			case `16`:
+				want = Typ[Uint16]
+			case `32`:
+				want = Typ[Uint32]
+			case `64`:
+				want = Typ[Uint] // because of "+ s", s is of type uint
+			case `"foo"`:
+				want = Typ[String]
+			}
+		case *syntax.Name:
+			if x.Value == "nil" {
+				want = Typ[UntypedNil]
+			}
+		}
+		if want != nil && !Identical(tv.Type, want) {
+			t.Errorf("got %s; want %s", tv.Type, want)
+		}
+	}
+}
+
+func TestIssue6413(t *testing.T) {
+	src := `
+package p
+func f() int {
+	defer f()
+	go f()
+	return 0
+}
+`
+	f := mustParse(t, src)
+
+	var conf Config
+	types := make(map[syntax.Expr]TypeAndValue)
+	_, err := conf.Check(f.PkgName.Value, []*syntax.File{f}, &Info{Types: types})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want := Typ[Int]
+	n := 0
+	for x, tv := range types {
+		if _, ok := x.(*syntax.CallExpr); ok {
+			if tv.Type != want {
+				t.Errorf("%s: got %s; want %s", x.Pos(), tv.Type, want)
+			}
+			n++
+		}
+	}
+
+	if n != 2 {
+		t.Errorf("got %d CallExprs; want 2", n)
+	}
+}
+
+func TestIssue7245(t *testing.T) {
+	src := `
+package p
+func (T) m() (res bool) { return }
+type T struct{} // receiver type after method declaration
+`
+	f := mustParse(t, src)
+
+	var conf Config
+	defs := make(map[*syntax.Name]Object)
+	_, err := conf.Check(f.PkgName.Value, []*syntax.File{f}, &Info{Defs: defs})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	m := f.DeclList[0].(*syntax.FuncDecl)
+	res1 := defs[m.Name].(*Func).Type().(*Signature).Results().At(0)
+	res2 := defs[m.Type.ResultList[0].Name].(*Var)
+
+	if res1 != res2 {
+		t.Errorf("got %s (%p) != %s (%p)", res1, res2, res1, res2)
+	}
+}
+
+// This tests that uses of existing vars on the LHS of an assignment
+// are Uses, not Defs; and also that the (illegal) use of a non-var on
+// the LHS of an assignment is a Use nonetheless.
+func TestIssue7827(t *testing.T) {
+	const src = `
+package p
+func _() {
+	const w = 1        // defs w
+        x, y := 2, 3       // defs x, y
+        w, x, z := 4, 5, 6 // uses w, x, defs z; error: cannot assign to w
+        _, _, _ = x, y, z  // uses x, y, z
+}
+`
+	f := mustParse(t, src)
+
+	const want = `L3 defs func p._()
+L4 defs const w untyped int
+L5 defs var x int
+L5 defs var y int
+L6 defs var z int
+L6 uses const w untyped int
+L6 uses var x int
+L7 uses var x int
+L7 uses var y int
+L7 uses var z int`
+
+	// don't abort at the first error
+	conf := Config{Error: func(err error) { t.Log(err) }}
+	defs := make(map[*syntax.Name]Object)
+	uses := make(map[*syntax.Name]Object)
+	_, err := conf.Check(f.PkgName.Value, []*syntax.File{f}, &Info{Defs: defs, Uses: uses})
+	if s := fmt.Sprint(err); !strings.HasSuffix(s, "cannot assign to w") {
+		t.Errorf("Check: unexpected error: %s", s)
+	}
+
+	var facts []string
+	for id, obj := range defs {
+		if obj != nil {
+			fact := fmt.Sprintf("L%d defs %s", id.Pos().Line(), obj)
+			facts = append(facts, fact)
+		}
+	}
+	for id, obj := range uses {
+		fact := fmt.Sprintf("L%d uses %s", id.Pos().Line(), obj)
+		facts = append(facts, fact)
+	}
+	sort.Strings(facts)
+
+	got := strings.Join(facts, "\n")
+	if got != want {
+		t.Errorf("Unexpected defs/uses\ngot:\n%s\nwant:\n%s", got, want)
+	}
+}
+
+// This tests that the package associated with the types.Object.Pkg method
+// is the type's package independent of the order in which the imports are
+// listed in the sources src1, src2 below.
+// The actual issue is in go/internal/gcimporter which has a corresponding
+// test; we leave this test here to verify correct behavior at the go/types
+// level.
+func TestIssue13898(t *testing.T) {
+	testenv.MustHaveGoBuild(t)
+
+	const src0 = `
+package main
+
+import "go/types"
+
+func main() {
+	var info types.Info
+	for _, obj := range info.Uses {
+		_ = obj.Pkg()
+	}
+}
+`
+	// like src0, but also imports go/importer
+	const src1 = `
+package main
+
+import (
+	"go/types"
+	_ "go/importer"
+)
+
+func main() {
+	var info types.Info
+	for _, obj := range info.Uses {
+		_ = obj.Pkg()
+	}
+}
+`
+	// like src1 but with different import order
+	// (used to fail with this issue)
+	const src2 = `
+package main
+
+import (
+	_ "go/importer"
+	"go/types"
+)
+
+func main() {
+	var info types.Info
+	for _, obj := range info.Uses {
+		_ = obj.Pkg()
+	}
+}
+`
+	f := func(test, src string) {
+		f := mustParse(t, src)
+		conf := Config{Importer: defaultImporter()}
+		info := Info{Uses: make(map[*syntax.Name]Object)}
+		_, err := conf.Check("main", []*syntax.File{f}, &info)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		var pkg *Package
+		count := 0
+		for id, obj := range info.Uses {
+			if id.Value == "Pkg" {
+				pkg = obj.Pkg()
+				count++
+			}
+		}
+		if count != 1 {
+			t.Fatalf("%s: got %d entries named Pkg; want 1", test, count)
+		}
+		if pkg.Name() != "types" {
+			t.Fatalf("%s: got %v; want package types2", test, pkg)
+		}
+	}
+
+	f("src0", src0)
+	f("src1", src1)
+	f("src2", src2)
+}
+
+func TestIssue22525(t *testing.T) {
+	f := mustParse(t, `package p; func f() { var a, b, c, d, e int }`)
+
+	got := "\n"
+	conf := Config{Error: func(err error) { got += err.Error() + "\n" }}
+	conf.Check(f.PkgName.Value, []*syntax.File{f}, nil) // do not crash
+	want := `
+:1:27: a declared but not used
+:1:30: b declared but not used
+:1:33: c declared but not used
+:1:36: d declared but not used
+:1:39: e declared but not used
+`
+	if got != want {
+		t.Errorf("got: %swant: %s", got, want)
+	}
+}
+
+func TestIssue25627(t *testing.T) {
+	t.Skip("requires syntax tree inspection")
+
+	const prefix = `package p; import "unsafe"; type P *struct{}; type I interface{}; type T `
+	// The src strings (without prefix) are constructed such that the number of semicolons
+	// plus one corresponds to the number of fields expected in the respective struct.
+	for _, src := range []string{
+		`struct { x Missing }`,
+		`struct { Missing }`,
+		`struct { *Missing }`,
+		`struct { unsafe.Pointer }`,
+		`struct { P }`,
+		`struct { *I }`,
+		`struct { a int; b Missing; *Missing }`,
+	} {
+		f := mustParse(t, prefix+src)
+
+		conf := Config{Importer: defaultImporter(), Error: func(err error) {}}
+		info := &Info{Types: make(map[syntax.Expr]TypeAndValue)}
+		_, err := conf.Check(f.PkgName.Value, []*syntax.File{f}, info)
+		if err != nil {
+			if _, ok := err.(Error); !ok {
+				t.Fatal(err)
+			}
+		}
+
+		unimplemented()
+		/*
+			ast.Inspect(f, func(n syntax.Node) bool {
+				if spec, _ := n.(*syntax.TypeDecl); spec != nil {
+					if tv, ok := info.Types[spec.Type]; ok && spec.Name.Value == "T" {
+						want := strings.Count(src, ";") + 1
+						if got := tv.Type.(*Struct).NumFields(); got != want {
+							t.Errorf("%s: got %d fields; want %d", src, got, want)
+						}
+					}
+				}
+				return true
+			})
+		*/
+	}
+}
+
+func TestIssue28005(t *testing.T) {
+	// method names must match defining interface name for this test
+	// (see last comment in this function)
+	sources := [...]string{
+		"package p; type A interface{ A() }",
+		"package p; type B interface{ B() }",
+		"package p; type X interface{ A; B }",
+	}
+
+	// compute original file ASTs
+	var orig [len(sources)]*syntax.File
+	for i, src := range sources {
+		orig[i] = mustParse(t, src)
+	}
+
+	// run the test for all order permutations of the incoming files
+	for _, perm := range [][len(sources)]int{
+		{0, 1, 2},
+		{0, 2, 1},
+		{1, 0, 2},
+		{1, 2, 0},
+		{2, 0, 1},
+		{2, 1, 0},
+	} {
+		// create file order permutation
+		files := make([]*syntax.File, len(sources))
+		for i := range perm {
+			files[i] = orig[perm[i]]
+		}
+
+		// type-check package with given file order permutation
+		var conf Config
+		info := &Info{Defs: make(map[*syntax.Name]Object)}
+		_, err := conf.Check("", files, info)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		// look for interface object X
+		var obj Object
+		for name, def := range info.Defs {
+			if name.Value == "X" {
+				obj = def
+				break
+			}
+		}
+		if obj == nil {
+			t.Fatal("object X not found")
+		}
+		iface := obj.Type().Interface() // object X must be an interface
+		if iface == nil {
+			t.Fatalf("%s is not an interface", obj)
+		}
+
+		// Each iface method m is embedded; and m's receiver base type name
+		// must match the method's name per the choice in the source file.
+		for i := 0; i < iface.NumMethods(); i++ {
+			m := iface.Method(i)
+			recvName := m.Type().(*Signature).Recv().Type().(*Named).Obj().Name()
+			if recvName != m.Name() {
+				t.Errorf("perm %v: got recv %s; want %s", perm, recvName, m.Name())
+			}
+		}
+	}
+}
+
+func TestIssue28282(t *testing.T) {
+	// create type interface { error }
+	et := Universe.Lookup("error").Type()
+	it := NewInterfaceType(nil, []Type{et})
+	it.Complete()
+	// verify that after completing the interface, the embedded method remains unchanged
+	want := et.Interface().Method(0)
+	got := it.Method(0)
+	if got != want {
+		t.Fatalf("%s.Method(0): got %q (%p); want %q (%p)", it, got, got, want, want)
+	}
+	// verify that lookup finds the same method in both interfaces (redundant check)
+	obj, _, _ := LookupFieldOrMethod(et, false, nil, "Error")
+	if obj != want {
+		t.Fatalf("%s.Lookup: got %q (%p); want %q (%p)", et, obj, obj, want, want)
+	}
+	obj, _, _ = LookupFieldOrMethod(it, false, nil, "Error")
+	if obj != want {
+		t.Fatalf("%s.Lookup: got %q (%p); want %q (%p)", it, obj, obj, want, want)
+	}
+}
+
+func TestIssue29029(t *testing.T) {
+	f1 := mustParse(t, `package p; type A interface { M() }`)
+	f2 := mustParse(t, `package p; var B interface { A }`)
+
+	// printInfo prints the *Func definitions recorded in info, one *Func per line.
+	printInfo := func(info *Info) string {
+		var buf bytes.Buffer
+		for _, obj := range info.Defs {
+			if fn, ok := obj.(*Func); ok {
+				fmt.Fprintln(&buf, fn)
+			}
+		}
+		return buf.String()
+	}
+
+	// The *Func (method) definitions for package p must be the same
+	// independent on whether f1 and f2 are type-checked together, or
+	// incrementally.
+
+	// type-check together
+	var conf Config
+	info := &Info{Defs: make(map[*syntax.Name]Object)}
+	check := NewChecker(&conf, NewPackage("", "p"), info)
+	if err := check.Files([]*syntax.File{f1, f2}); err != nil {
+		t.Fatal(err)
+	}
+	want := printInfo(info)
+
+	// type-check incrementally
+	info = &Info{Defs: make(map[*syntax.Name]Object)}
+	check = NewChecker(&conf, NewPackage("", "p"), info)
+	if err := check.Files([]*syntax.File{f1}); err != nil {
+		t.Fatal(err)
+	}
+	if err := check.Files([]*syntax.File{f2}); err != nil {
+		t.Fatal(err)
+	}
+	got := printInfo(info)
+
+	if got != want {
+		t.Errorf("\ngot : %swant: %s", got, want)
+	}
+}
+
+func TestIssue34151(t *testing.T) {
+	const asrc = `package a; type I interface{ M() }; type T struct { F interface { I } }`
+	const bsrc = `package b; import "a"; type T struct { F interface { a.I } }; var _ = a.T(T{})`
+
+	a, err := pkgFor("a", asrc, nil)
+	if err != nil {
+		t.Fatalf("package %s failed to typecheck: %v", a.Name(), err)
+	}
+
+	bast := mustParse(t, bsrc)
+	conf := Config{Importer: importHelper{a}}
+	b, err := conf.Check(bast.PkgName.Value, []*syntax.File{bast}, nil)
+	if err != nil {
+		t.Errorf("package %s failed to typecheck: %v", b.Name(), err)
+	}
+}
+
+type importHelper struct {
+	pkg *Package
+}
+
+func (h importHelper) Import(path string) (*Package, error) {
+	if path != h.pkg.Path() {
+		return nil, fmt.Errorf("got package path %q; want %q", path, h.pkg.Path())
+	}
+	return h.pkg, nil
+}
+
+// TestIssue34921 verifies that we don't update an imported type's underlying
+// type when resolving an underlying type. Specifically, when determining the
+// underlying type of b.T (which is the underlying type of a.T, which is int)
+// we must not set the underlying type of a.T again since that would lead to
+// a race condition if package b is imported elsewhere, in a package that is
+// concurrently type-checked.
+func TestIssue34921(t *testing.T) {
+	defer func() {
+		if r := recover(); r != nil {
+			t.Error(r)
+		}
+	}()
+
+	var sources = []string{
+		`package a; type T int`,
+		`package b; import "a"; type T a.T`,
+	}
+
+	var pkg *Package
+	for _, src := range sources {
+		f := mustParse(t, src)
+		conf := Config{Importer: importHelper{pkg}}
+		res, err := conf.Check(f.PkgName.Value, []*syntax.File{f}, nil)
+		if err != nil {
+			t.Errorf("%q failed to typecheck: %v", src, err)
+		}
+		pkg = res // res is imported by the next package in this test
+	}
+}
diff --git a/src/cmd/compile/internal/types2/labels.go b/src/cmd/compile/internal/types2/labels.go
new file mode 100644
index 0000000000..ca5fe6b389
--- /dev/null
+++ b/src/cmd/compile/internal/types2/labels.go
@@ -0,0 +1,260 @@
+// UNREVIEWED
+// Copyright 2013 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 types2
+
+import (
+	"cmd/compile/internal/syntax"
+)
+
+// labels checks correct label use in body.
+func (check *Checker) labels(body *syntax.BlockStmt) {
+	// set of all labels in this body
+	all := NewScope(nil, body.Pos(), endPos(body), "label")
+
+	fwdJumps := check.blockBranches(all, nil, nil, body.List)
+
+	// If there are any forward jumps left, no label was found for
+	// the corresponding goto statements. Either those labels were
+	// never defined, or they are inside blocks and not reachable
+	// for the respective gotos.
+	for _, jmp := range fwdJumps {
+		var msg string
+		name := jmp.Label.Value
+		if alt := all.Lookup(name); alt != nil {
+			msg = "goto %s jumps into block"
+			alt.(*Label).used = true // avoid another error
+		} else {
+			msg = "label %s not declared"
+		}
+		check.errorf(jmp.Label, msg, name)
+	}
+
+	// spec: "It is illegal to define a label that is never used."
+	for _, obj := range all.elems {
+		if lbl := obj.(*Label); !lbl.used {
+			check.softErrorf(lbl.pos, "label %s declared but not used", lbl.name)
+		}
+	}
+}
+
+// A block tracks label declarations in a block and its enclosing blocks.
+type block struct {
+	parent *block                         // enclosing block
+	lstmt  *syntax.LabeledStmt            // labeled statement to which this block belongs, or nil
+	labels map[string]*syntax.LabeledStmt // allocated lazily
+}
+
+// insert records a new label declaration for the current block.
+// The label must not have been declared before in any block.
+func (b *block) insert(s *syntax.LabeledStmt) {
+	name := s.Label.Value
+	if debug {
+		assert(b.gotoTarget(name) == nil)
+	}
+	labels := b.labels
+	if labels == nil {
+		labels = make(map[string]*syntax.LabeledStmt)
+		b.labels = labels
+	}
+	labels[name] = s
+}
+
+// gotoTarget returns the labeled statement in the current
+// or an enclosing block with the given label name, or nil.
+func (b *block) gotoTarget(name string) *syntax.LabeledStmt {
+	for s := b; s != nil; s = s.parent {
+		if t := s.labels[name]; t != nil {
+			return t
+		}
+	}
+	return nil
+}
+
+// enclosingTarget returns the innermost enclosing labeled
+// statement with the given label name, or nil.
+func (b *block) enclosingTarget(name string) *syntax.LabeledStmt {
+	for s := b; s != nil; s = s.parent {
+		if t := s.lstmt; t != nil && t.Label.Value == name {
+			return t
+		}
+	}
+	return nil
+}
+
+// blockBranches processes a block's statement list and returns the set of outgoing forward jumps.
+// all is the scope of all declared labels, parent the set of labels declared in the immediately
+// enclosing block, and lstmt is the labeled statement this block is associated with (or nil).
+func (check *Checker) blockBranches(all *Scope, parent *block, lstmt *syntax.LabeledStmt, list []syntax.Stmt) []*syntax.BranchStmt {
+	b := &block{parent, lstmt, nil}
+
+	var (
+		varDeclPos         syntax.Pos
+		fwdJumps, badJumps []*syntax.BranchStmt
+	)
+
+	// All forward jumps jumping over a variable declaration are possibly
+	// invalid (they may still jump out of the block and be ok).
+	// recordVarDecl records them for the given position.
+	recordVarDecl := func(pos syntax.Pos) {
+		varDeclPos = pos
+		badJumps = append(badJumps[:0], fwdJumps...) // copy fwdJumps to badJumps
+	}
+
+	jumpsOverVarDecl := func(jmp *syntax.BranchStmt) bool {
+		if varDeclPos.IsKnown() {
+			for _, bad := range badJumps {
+				if jmp == bad {
+					return true
+				}
+			}
+		}
+		return false
+	}
+
+	var stmtBranches func(syntax.Stmt)
+	stmtBranches = func(s syntax.Stmt) {
+		switch s := s.(type) {
+		case *syntax.DeclStmt:
+			for _, d := range s.DeclList {
+				if d, _ := d.(*syntax.VarDecl); d != nil {
+					recordVarDecl(d.Pos())
+				}
+			}
+
+		case *syntax.LabeledStmt:
+			// declare non-blank label
+			if name := s.Label.Value; name != "_" {
+				lbl := NewLabel(s.Label.Pos(), check.pkg, name)
+				if alt := all.Insert(lbl); alt != nil {
+					check.softErrorf(lbl.pos, "label %s already declared", name)
+					check.reportAltDecl(alt)
+					// ok to continue
+				} else {
+					b.insert(s)
+					check.recordDef(s.Label, lbl)
+				}
+				// resolve matching forward jumps and remove them from fwdJumps
+				i := 0
+				for _, jmp := range fwdJumps {
+					if jmp.Label.Value == name {
+						// match
+						lbl.used = true
+						check.recordUse(jmp.Label, lbl)
+						if jumpsOverVarDecl(jmp) {
+							check.softErrorf(
+								jmp.Label,
+								"goto %s jumps over variable declaration at line %d",
+								name,
+								varDeclPos.Line(),
+							)
+							// ok to continue
+						}
+					} else {
+						// no match - record new forward jump
+						fwdJumps[i] = jmp
+						i++
+					}
+				}
+				fwdJumps = fwdJumps[:i]
+				lstmt = s
+			}
+			stmtBranches(s.Stmt)
+
+		case *syntax.BranchStmt:
+			if s.Label == nil {
+				return // checked in 1st pass (check.stmt)
+			}
+
+			// determine and validate target
+			name := s.Label.Value
+			switch s.Tok {
+			case syntax.Break:
+				// spec: "If there is a label, it must be that of an enclosing
+				// "for", "switch", or "select" statement, and that is the one
+				// whose execution terminates."
+				valid := false
+				if t := b.enclosingTarget(name); t != nil {
+					switch t.Stmt.(type) {
+					case *syntax.SwitchStmt, *syntax.SelectStmt, *syntax.ForStmt:
+						valid = true
+					}
+				}
+				if !valid {
+					check.errorf(s.Label, "invalid break label %s", name)
+					return
+				}
+
+			case syntax.Continue:
+				// spec: "If there is a label, it must be that of an enclosing
+				// "for" statement, and that is the one whose execution advances."
+				valid := false
+				if t := b.enclosingTarget(name); t != nil {
+					switch t.Stmt.(type) {
+					case *syntax.ForStmt:
+						valid = true
+					}
+				}
+				if !valid {
+					check.errorf(s.Label, "invalid continue label %s", name)
+					return
+				}
+
+			case syntax.Goto:
+				if b.gotoTarget(name) == nil {
+					// label may be declared later - add branch to forward jumps
+					fwdJumps = append(fwdJumps, s)
+					return
+				}
+
+			default:
+				check.invalidASTf(s, "branch statement: %s %s", s.Tok, name)
+				return
+			}
+
+			// record label use
+			obj := all.Lookup(name)
+			obj.(*Label).used = true
+			check.recordUse(s.Label, obj)
+
+		case *syntax.AssignStmt:
+			if s.Op == syntax.Def {
+				recordVarDecl(s.Pos())
+			}
+
+		case *syntax.BlockStmt:
+			// Unresolved forward jumps inside the nested block
+			// become forward jumps in the current block.
+			fwdJumps = append(fwdJumps, check.blockBranches(all, b, lstmt, s.List)...)
+
+		case *syntax.IfStmt:
+			stmtBranches(s.Then)
+			if s.Else != nil {
+				stmtBranches(s.Else)
+			}
+
+		case *syntax.SwitchStmt:
+			b := &block{b, lstmt, nil}
+			for _, s := range s.Body {
+				fwdJumps = append(fwdJumps, check.blockBranches(all, b, nil, s.Body)...)
+			}
+
+		case *syntax.SelectStmt:
+			b := &block{b, lstmt, nil}
+			for _, s := range s.Body {
+				fwdJumps = append(fwdJumps, check.blockBranches(all, b, nil, s.Body)...)
+			}
+
+		case *syntax.ForStmt:
+			stmtBranches(s.Body)
+		}
+	}
+
+	for _, s := range list {
+		stmtBranches(s)
+	}
+
+	return fwdJumps
+}
diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go
new file mode 100644
index 0000000000..277212c568
--- /dev/null
+++ b/src/cmd/compile/internal/types2/lookup.go
@@ -0,0 +1,493 @@
+// UNREVIEWED
+// Copyright 2013 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.
+
+// This file implements various field and method lookup functions.
+
+package types2
+
+// LookupFieldOrMethod looks up a field or method with given package and name
+// in T and returns the corresponding *Var or *Func, an index sequence, and a
+// bool indicating if there were any pointer indirections on the path to the
+// field or method. If addressable is set, T is the type of an addressable
+// variable (only matters for method lookups).
+//
+// The last index entry is the field or method index in the (possibly embedded)
+// type where the entry was found, either:
+//
+//	1) the list of declared methods of a named type; or
+//	2) the list of all methods (method set) of an interface type; or
+//	3) the list of fields of a struct type.
+//
+// The earlier index entries are the indices of the embedded struct fields
+// traversed to get to the found entry, starting at depth 0.
+//
+// If no entry is found, a nil object is returned. In this case, the returned
+// index and indirect values have the following meaning:
+//
+//	- If index != nil, the index sequence points to an ambiguous entry
+//	(the same name appeared more than once at the same embedding level).
+//
+//	- If indirect is set, a method with a pointer receiver type was found
+//      but there was no pointer on the path from the actual receiver type to
+//	the method's formal receiver base type, nor was the receiver addressable.
+//
+func LookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (obj Object, index []int, indirect bool) {
+	return (*Checker)(nil).lookupFieldOrMethod(T, addressable, pkg, name)
+}
+
+// Internal use of Checker.lookupFieldOrMethod: If the obj result is a method
+// associated with a concrete (non-interface) type, the method's signature
+// may not be fully set up. Call Checker.objDecl(obj, nil) before accessing
+// the method's type.
+// TODO(gri) Now that we provide the *Checker, we can probably remove this
+// caveat by calling Checker.objDecl from lookupFieldOrMethod. Investigate.
+
+// lookupFieldOrMethod is like the external version but completes interfaces
+// as necessary.
+func (check *Checker) lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (obj Object, index []int, indirect bool) {
+	// Methods cannot be associated to a named pointer type
+	// (spec: "The type denoted by T is called the receiver base type;
+	// it must not be a pointer or interface type and it must be declared
+	// in the same package as the method.").
+	// Thus, if we have a named pointer type, proceed with the underlying
+	// pointer type but discard the result if it is a method since we would
+	// not have found it for T (see also issue 8590).
+	if t := T.Named(); t != nil {
+		if p, _ := t.underlying.(*Pointer); p != nil {
+			obj, index, indirect = check.rawLookupFieldOrMethod(p, false, pkg, name)
+			if _, ok := obj.(*Func); ok {
+				return nil, nil, false
+			}
+			return
+		}
+	}
+
+	return check.rawLookupFieldOrMethod(T, addressable, pkg, name)
+}
+
+// TODO(gri) The named type consolidation and seen maps below must be
+//           indexed by unique keys for a given type. Verify that named
+//           types always have only one representation (even when imported
+//           indirectly via different packages.)
+
+// rawLookupFieldOrMethod should only be called by lookupFieldOrMethod and missingMethod.
+func (check *Checker) rawLookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (obj Object, index []int, indirect bool) {
+	// WARNING: The code in this function is extremely subtle - do not modify casually!
+	//          This function and NewMethodSet should be kept in sync.
+
+	if name == "_" {
+		return // blank fields/methods are never found
+	}
+
+	typ, isPtr := deref(T)
+
+	// *typ where typ is an interface has no methods.
+	// Be cautious: typ may be nil (issue 39634, crash #3).
+	if typ == nil || isPtr && IsInterface(typ) {
+		return
+	}
+
+	// Start with typ as single entry at shallowest depth.
+	current := []embeddedType{{typ, nil, isPtr, false}}
+
+	// Named types that we have seen already, allocated lazily.
+	// Used to avoid endless searches in case of recursive types.
+	// Since only Named types can be used for recursive types, we
+	// only need to track those.
+	// (If we ever allow type aliases to construct recursive types,
+	// we must use type identity rather than pointer equality for
+	// the map key comparison, as we do in consolidateMultiples.)
+	var seen map[*Named]bool
+
+	// search current depth
+	for len(current) > 0 {
+		var next []embeddedType // embedded types found at current depth
+
+		// look for (pkg, name) in all types at current depth
+		var tpar *TypeParam // set if obj receiver is a type parameter
+		for _, e := range current {
+			typ := e.typ
+
+			// If we have a named type, we may have associated methods.
+			// Look for those first.
+			if named := typ.Named(); named != nil {
+				if seen[named] {
+					// We have seen this type before, at a more shallow depth
+					// (note that multiples of this type at the current depth
+					// were consolidated before). The type at that depth shadows
+					// this same type at the current depth, so we can ignore
+					// this one.
+					continue
+				}
+				if seen == nil {
+					seen = make(map[*Named]bool)
+				}
+				seen[named] = true
+
+				// look for a matching attached method
+				if i, m := lookupMethod(named.methods, pkg, name); m != nil {
+					// potential match
+					// caution: method may not have a proper signature yet
+					index = concat(e.index, i)
+					if obj != nil || e.multiples {
+						return nil, index, false // collision
+					}
+					obj = m
+					indirect = e.indirect
+					continue // we can't have a matching field or interface method
+				}
+
+				// continue with underlying type, but only if it's not a type parameter
+				// TODO(gri) is this what we want to do for type parameters? (spec question)
+				typ = named.Under()
+				if typ.TypeParam() != nil {
+					continue
+				}
+			}
+
+			tpar = nil
+			switch t := typ.(type) {
+			case *Struct:
+				// look for a matching field and collect embedded types
+				for i, f := range t.fields {
+					if f.sameId(pkg, name) {
+						assert(f.typ != nil)
+						index = concat(e.index, i)
+						if obj != nil || e.multiples {
+							return nil, index, false // collision
+						}
+						obj = f
+						indirect = e.indirect
+						continue // we can't have a matching interface method
+					}
+					// Collect embedded struct fields for searching the next
+					// lower depth, but only if we have not seen a match yet
+					// (if we have a match it is either the desired field or
+					// we have a name collision on the same depth; in either
+					// case we don't need to look further).
+					// Embedded fields are always of the form T or *T where
+					// T is a type name. If e.typ appeared multiple times at
+					// this depth, f.typ appears multiple times at the next
+					// depth.
+					if obj == nil && f.embedded {
+						typ, isPtr := deref(f.typ)
+						// TODO(gri) optimization: ignore types that can't
+						// have fields or methods (only Named, Struct, and
+						// Interface types need to be considered).
+						next = append(next, embeddedType{typ, concat(e.index, i), e.indirect || isPtr, e.multiples})
+					}
+				}
+
+			case *Interface:
+				// look for a matching method
+				// TODO(gri) t.allMethods is sorted - use binary search
+				check.completeInterface(nopos, t)
+				if i, m := lookupMethod(t.allMethods, pkg, name); m != nil {
+					assert(m.typ != nil)
+					index = concat(e.index, i)
+					if obj != nil || e.multiples {
+						return nil, index, false // collision
+					}
+					obj = m
+					indirect = e.indirect
+				}
+
+			case *TypeParam:
+				if i, m := lookupMethod(t.Bound().allMethods, pkg, name); m != nil {
+					assert(m.typ != nil)
+					index = concat(e.index, i)
+					if obj != nil || e.multiples {
+						return nil, index, false // collision
+					}
+					tpar = t
+					obj = m
+					indirect = e.indirect
+				}
+				if obj == nil {
+					// At this point we're not (yet) looking into methods
+					// that any underlyng type of the types in the type list
+					// migth have.
+					// TODO(gri) Do we want to specify the language that way?
+				}
+			}
+		}
+
+		if obj != nil {
+			// found a potential match
+			// spec: "A method call x.m() is valid if the method set of (the type of) x
+			//        contains m and the argument list can be assigned to the parameter
+			//        list of m. If x is addressable and &x's method set contains m, x.m()
+			//        is shorthand for (&x).m()".
+			if f, _ := obj.(*Func); f != nil {
+				// determine if method has a pointer receiver
+				hasPtrRecv := tpar == nil && ptrRecv(f) || tpar != nil && tpar.ptr
+				if hasPtrRecv && !indirect && !addressable {
+					return nil, nil, true // pointer/addressable receiver required
+				}
+			}
+			return
+		}
+
+		current = check.consolidateMultiples(next)
+	}
+
+	return nil, nil, false // not found
+}
+
+// embeddedType represents an embedded type
+type embeddedType struct {
+	typ       Type
+	index     []int // embedded field indices, starting with index at depth 0
+	indirect  bool  // if set, there was a pointer indirection on the path to this field
+	multiples bool  // if set, typ appears multiple times at this depth
+}
+
+// consolidateMultiples collects multiple list entries with the same type
+// into a single entry marked as containing multiples. The result is the
+// consolidated list.
+func (check *Checker) consolidateMultiples(list []embeddedType) []embeddedType {
+	if len(list) <= 1 {
+		return list // at most one entry - nothing to do
+	}
+
+	n := 0                     // number of entries w/ unique type
+	prev := make(map[Type]int) // index at which type was previously seen
+	for _, e := range list {
+		if i, found := check.lookupType(prev, e.typ); found {
+			list[i].multiples = true
+			// ignore this entry
+		} else {
+			prev[e.typ] = n
+			list[n] = e
+			n++
+		}
+	}
+	return list[:n]
+}
+
+func (check *Checker) lookupType(m map[Type]int, typ Type) (int, bool) {
+	// fast path: maybe the types are equal
+	if i, found := m[typ]; found {
+		return i, true
+	}
+
+	for t, i := range m {
+		if check.identical(t, typ) {
+			return i, true
+		}
+	}
+
+	return 0, false
+}
+
+// MissingMethod returns (nil, false) if V implements T, otherwise it
+// returns a missing method required by T and whether it is missing or
+// just has the wrong type.
+//
+// For non-interface types V, or if static is set, V implements T if all
+// methods of T are present in V. Otherwise (V is an interface and static
+// is not set), MissingMethod only checks that methods of T which are also
+// present in V have matching types (e.g., for a type assertion x.(T) where
+// x is of interface type V).
+//
+func MissingMethod(V Type, T *Interface, static bool) (method *Func, wrongType bool) {
+	m, typ := (*Checker)(nil).missingMethod(V, T, static)
+	return m, typ != nil
+}
+
+// missingMethod is like MissingMethod but accepts a *Checker as
+// receiver and an addressable flag.
+// The receiver may be nil if missingMethod is invoked through
+// an exported API call (such as MissingMethod), i.e., when all
+// methods have been type-checked.
+// If the type has the correctly named method, but with the wrong
+// signature, the existing method is returned as well.
+// To improve error messages, also report the wrong signature
+// when the method exists on *V instead of V.
+func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method, wrongType *Func) {
+	check.completeInterface(nopos, T)
+
+	// fast path for common case
+	if T.Empty() {
+		return
+	}
+
+	if ityp := V.Interface(); ityp != nil {
+		check.completeInterface(nopos, ityp)
+		// TODO(gri) allMethods is sorted - can do this more efficiently
+		for _, m := range T.allMethods {
+			_, f := lookupMethod(ityp.allMethods, m.pkg, m.name)
+
+			if f == nil {
+				// if m is the magic method == we're ok (interfaces are comparable)
+				if m.name == "==" || !static {
+					continue
+				}
+				return m, f
+			}
+
+			// both methods must have the same number of type parameters
+			ftyp := f.typ.(*Signature)
+			mtyp := m.typ.(*Signature)
+			if len(ftyp.tparams) != len(mtyp.tparams) {
+				return m, f
+			}
+
+			// If the methods have type parameters we don't care whether they
+			// are the same or not, as long as they match up. Use unification
+			// to see if they can be made to match.
+			// TODO(gri) is this always correct? what about type bounds?
+			// (Alternative is to rename/subst type parameters and compare.)
+			u := newUnifier(check, true)
+			u.x.init(ftyp.tparams)
+			if !u.unify(ftyp, mtyp) {
+				return m, f
+			}
+		}
+
+		return
+	}
+
+	// A concrete type implements T if it implements all methods of T.
+	Vd, _ := deref(V)
+	Vn := Vd.Named()
+	for _, m := range T.allMethods {
+		// TODO(gri) should this be calling lookupFieldOrMethod instead (and why not)?
+		obj, _, _ := check.rawLookupFieldOrMethod(V, false, m.pkg, m.name)
+
+		// Check if *V implements this method of T.
+		if obj == nil {
+			ptr := NewPointer(V)
+			obj, _, _ = check.rawLookupFieldOrMethod(ptr, false, m.pkg, m.name)
+			if obj != nil {
+				return m, obj.(*Func)
+			}
+		}
+
+		// we must have a method (not a field of matching function type)
+		f, _ := obj.(*Func)
+		if f == nil {
+			// if m is the magic method == and V is comparable, we're ok
+			if m.name == "==" && Comparable(V) {
+				continue
+			}
+			return m, nil
+		}
+
+		// methods may not have a fully set up signature yet
+		if check != nil {
+			check.objDecl(f, nil)
+		}
+
+		// both methods must have the same number of type parameters
+		ftyp := f.typ.(*Signature)
+		mtyp := m.typ.(*Signature)
+		if len(ftyp.tparams) != len(mtyp.tparams) {
+			return m, f
+		}
+
+		// If V is a (instantiated) generic type, its methods are still
+		// parameterized using the original (declaration) receiver type
+		// parameters (subst simply copies the existing method list, it
+		// does not instantiate the methods).
+		// In order to compare the signatures, substitute the receiver
+		// type parameters of ftyp with V's instantiation type arguments.
+		// This lazily instantiates the signature of method f.
+		if Vn != nil && len(Vn.tparams) > 0 {
+			// Be careful: The number of type arguments may not match
+			// the number of receiver parameters. If so, an error was
+			// reported earlier but the length discrepancy is still
+			// here. Exit early in this case to prevent an assertion
+			// failure in makeSubstMap.
+			// TODO(gri) Can we avoid this check by fixing the lengths?
+			if len(ftyp.rparams) != len(Vn.targs) {
+				return
+			}
+			ftyp = check.subst(nopos, ftyp, makeSubstMap(ftyp.rparams, Vn.targs)).(*Signature)
+		}
+
+		// If the methods have type parameters we don't care whether they
+		// are the same or not, as long as they match up. Use unification
+		// to see if they can be made to match.
+		// TODO(gri) is this always correct? what about type bounds?
+		// (Alternative is to rename/subst type parameters and compare.)
+		u := newUnifier(check, true)
+		u.x.init(ftyp.tparams)
+		if !u.unify(ftyp, mtyp) {
+			return m, f
+		}
+	}
+
+	return
+}
+
+// assertableTo reports whether a value of type V can be asserted to have type T.
+// It returns (nil, false) as affirmative answer. Otherwise it returns a missing
+// method required by V and whether it is missing or just has the wrong type.
+// The receiver may be nil if assertableTo is invoked through an exported API call
+// (such as AssertableTo), i.e., when all methods have been type-checked.
+// If strict (or the global constant forceStrict) is set, assertions that
+// are known to fail are not permitted.
+func (check *Checker) assertableTo(V *Interface, T Type, strict bool) (method, wrongType *Func) {
+	// no static check is required if T is an interface
+	// spec: "If T is an interface type, x.(T) asserts that the
+	//        dynamic type of x implements the interface T."
+	if T.Interface() != nil && !(strict || forceStrict) {
+		return
+	}
+	return check.missingMethod(T, V, false)
+}
+
+// deref dereferences typ if it is a *Pointer and returns its base and true.
+// Otherwise it returns (typ, false).
+func deref(typ Type) (Type, bool) {
+	if p, _ := typ.(*Pointer); p != nil {
+		return p.base, true
+	}
+	return typ, false
+}
+
+// derefStructPtr dereferences typ if it is a (named or unnamed) pointer to a
+// (named or unnamed) struct and returns its base. Otherwise it returns typ.
+func derefStructPtr(typ Type) Type {
+	if p := typ.Pointer(); p != nil {
+		if p.base.Struct() != nil {
+			return p.base
+		}
+	}
+	return typ
+}
+
+// concat returns the result of concatenating list and i.
+// The result does not share its underlying array with list.
+func concat(list []int, i int) []int {
+	var t []int
+	t = append(t, list...)
+	return append(t, i)
+}
+
+// fieldIndex returns the index for the field with matching package and name, or a value < 0.
+func fieldIndex(fields []*Var, pkg *Package, name string) int {
+	if name != "_" {
+		for i, f := range fields {
+			if f.sameId(pkg, name) {
+				return i
+			}
+		}
+	}
+	return -1
+}
+
+// lookupMethod returns the index of and method with matching package and name, or (-1, nil).
+func lookupMethod(methods []*Func, pkg *Package, name string) (int, *Func) {
+	if name != "_" {
+		for i, m := range methods {
+			if m.sameId(pkg, name) {
+				return i, m
+			}
+		}
+	}
+	return -1, nil
+}
diff --git a/src/cmd/compile/internal/types2/methodset.go b/src/cmd/compile/internal/types2/methodset.go
new file mode 100644
index 0000000000..9f7315a0fa
--- /dev/null
+++ b/src/cmd/compile/internal/types2/methodset.go
@@ -0,0 +1,261 @@
+// UNREVIEWED
+// Copyright 2013 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.
+
+// This file implements method sets.
+
+package types2
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+)
+
+// A MethodSet is an ordered set of concrete or abstract (interface) methods;
+// a method is a MethodVal selection, and they are ordered by ascending m.Obj().Id().
+// The zero value for a MethodSet is a ready-to-use empty method set.
+type MethodSet struct {
+	list []*Selection
+}
+
+func (s *MethodSet) String() string {
+	if s.Len() == 0 {
+		return "MethodSet {}"
+	}
+
+	var buf strings.Builder
+	fmt.Fprintln(&buf, "MethodSet {")
+	for _, f := range s.list {
+		fmt.Fprintf(&buf, "\t%s\n", f)
+	}
+	fmt.Fprintln(&buf, "}")
+	return buf.String()
+}
+
+// Len returns the number of methods in s.
+func (s *MethodSet) Len() int { return len(s.list) }
+
+// At returns the i'th method in s for 0 <= i < s.Len().
+func (s *MethodSet) At(i int) *Selection { return s.list[i] }
+
+// Lookup returns the method with matching package and name, or nil if not found.
+func (s *MethodSet) Lookup(pkg *Package, name string) *Selection {
+	if s.Len() == 0 {
+		return nil
+	}
+
+	key := Id(pkg, name)
+	i := sort.Search(len(s.list), func(i int) bool {
+		m := s.list[i]
+		return m.obj.Id() >= key
+	})
+	if i < len(s.list) {
+		m := s.list[i]
+		if m.obj.Id() == key {
+			return m
+		}
+	}
+	return nil
+}
+
+// Shared empty method set.
+var emptyMethodSet MethodSet
+
+// Note: NewMethodSet is intended for external use only as it
+//       requires interfaces to be complete. If may be used
+//       internally if LookupFieldOrMethod completed the same
+//       interfaces beforehand.
+
+// NewMethodSet returns the method set for the given type T.
+// It always returns a non-nil method set, even if it is empty.
+func NewMethodSet(T Type) *MethodSet {
+	// WARNING: The code in this function is extremely subtle - do not modify casually!
+	//          This function and lookupFieldOrMethod should be kept in sync.
+
+	// method set up to the current depth, allocated lazily
+	var base methodSet
+
+	typ, isPtr := deref(T)
+
+	// *typ where typ is an interface has no methods.
+	if isPtr && IsInterface(typ) {
+		return &emptyMethodSet
+	}
+
+	// Start with typ as single entry at shallowest depth.
+	current := []embeddedType{{typ, nil, isPtr, false}}
+
+	// Named types that we have seen already, allocated lazily.
+	// Used to avoid endless searches in case of recursive types.
+	// Since only Named types can be used for recursive types, we
+	// only need to track those.
+	// (If we ever allow type aliases to construct recursive types,
+	// we must use type identity rather than pointer equality for
+	// the map key comparison, as we do in consolidateMultiples.)
+	var seen map[*Named]bool
+
+	// collect methods at current depth
+	for len(current) > 0 {
+		var next []embeddedType // embedded types found at current depth
+
+		// field and method sets at current depth, indexed by names (Id's), and allocated lazily
+		var fset map[string]bool // we only care about the field names
+		var mset methodSet
+
+		for _, e := range current {
+			typ := e.typ
+
+			// If we have a named type, we may have associated methods.
+			// Look for those first.
+			if named := typ.Named(); named != nil {
+				if seen[named] {
+					// We have seen this type before, at a more shallow depth
+					// (note that multiples of this type at the current depth
+					// were consolidated before). The type at that depth shadows
+					// this same type at the current depth, so we can ignore
+					// this one.
+					continue
+				}
+				if seen == nil {
+					seen = make(map[*Named]bool)
+				}
+				seen[named] = true
+
+				mset = mset.add(named.methods, e.index, e.indirect, e.multiples)
+
+				// continue with underlying type
+				typ = named.underlying
+			}
+
+			switch t := typ.(type) {
+			case *Struct:
+				for i, f := range t.fields {
+					if fset == nil {
+						fset = make(map[string]bool)
+					}
+					fset[f.Id()] = true
+
+					// Embedded fields are always of the form T or *T where
+					// T is a type name. If typ appeared multiple times at
+					// this depth, f.Type appears multiple times at the next
+					// depth.
+					if f.embedded {
+						typ, isPtr := deref(f.typ)
+						// TODO(gri) optimization: ignore types that can't
+						// have fields or methods (only Named, Struct, and
+						// Interface types need to be considered).
+						next = append(next, embeddedType{typ, concat(e.index, i), e.indirect || isPtr, e.multiples})
+					}
+				}
+
+			case *Interface:
+				mset = mset.add(t.allMethods, e.index, true, e.multiples)
+			}
+		}
+
+		// Add methods and collisions at this depth to base if no entries with matching
+		// names exist already.
+		for k, m := range mset {
+			if _, found := base[k]; !found {
+				// Fields collide with methods of the same name at this depth.
+				if fset[k] {
+					m = nil // collision
+				}
+				if base == nil {
+					base = make(methodSet)
+				}
+				base[k] = m
+			}
+		}
+
+		// Add all (remaining) fields at this depth as collisions (since they will
+		// hide any method further down) if no entries with matching names exist already.
+		for k := range fset {
+			if _, found := base[k]; !found {
+				if base == nil {
+					base = make(methodSet)
+				}
+				base[k] = nil // collision
+			}
+		}
+
+		// It's ok to call consolidateMultiples with a nil *Checker because
+		// MethodSets are not used internally (outside debug mode). When used
+		// externally, interfaces are expected to be completed and then we do
+		// not need a *Checker to complete them when (indirectly) calling
+		// Checker.identical via consolidateMultiples.
+		current = (*Checker)(nil).consolidateMultiples(next)
+	}
+
+	if len(base) == 0 {
+		return &emptyMethodSet
+	}
+
+	// collect methods
+	var list []*Selection
+	for _, m := range base {
+		if m != nil {
+			m.recv = T
+			list = append(list, m)
+		}
+	}
+	// sort by unique name
+	sort.Slice(list, func(i, j int) bool {
+		return list[i].obj.Id() < list[j].obj.Id()
+	})
+	return &MethodSet{list}
+}
+
+// A methodSet is a set of methods and name collisions.
+// A collision indicates that multiple methods with the
+// same unique id, or a field with that id appeared.
+type methodSet map[string]*Selection // a nil entry indicates a name collision
+
+// Add adds all functions in list to the method set s.
+// If multiples is set, every function in list appears multiple times
+// and is treated as a collision.
+func (s methodSet) add(list []*Func, index []int, indirect bool, multiples bool) methodSet {
+	if len(list) == 0 {
+		return s
+	}
+	if s == nil {
+		s = make(methodSet)
+	}
+	for i, f := range list {
+		key := f.Id()
+		// if f is not in the set, add it
+		if !multiples {
+			// TODO(gri) A found method may not be added because it's not in the method set
+			// (!indirect && ptrRecv(f)). A 2nd method on the same level may be in the method
+			// set and may not collide with the first one, thus leading to a false positive.
+			// Is that possible? Investigate.
+			if _, found := s[key]; !found && (indirect || !ptrRecv(f)) {
+				s[key] = &Selection{MethodVal, nil, f, concat(index, i), indirect}
+				continue
+			}
+		}
+		s[key] = nil // collision
+	}
+	return s
+}
+
+// ptrRecv reports whether the receiver is of the form *T.
+func ptrRecv(f *Func) bool {
+	// If a method's receiver type is set, use that as the source of truth for the receiver.
+	// Caution: Checker.funcDecl (decl.go) marks a function by setting its type to an empty
+	// signature. We may reach here before the signature is fully set up: we must explicitly
+	// check if the receiver is set (we cannot just look for non-nil f.typ).
+	if sig, _ := f.typ.(*Signature); sig != nil && sig.recv != nil {
+		_, isPtr := deref(sig.recv.typ)
+		return isPtr
+	}
+
+	// If a method's type is not set it may be a method/function that is:
+	// 1) client-supplied (via NewFunc with no signature), or
+	// 2) internally created but not yet type-checked.
+	// For case 1) we can't do anything; the client must know what they are doing.
+	// For case 2) we can use the information gathered by the resolver.
+	return f.hasPtrRecv
+}
diff --git a/src/cmd/compile/internal/types2/object.go b/src/cmd/compile/internal/types2/object.go
new file mode 100644
index 0000000000..6e6f48c036
--- /dev/null
+++ b/src/cmd/compile/internal/types2/object.go
@@ -0,0 +1,492 @@
+// UNREVIEWED
+// Copyright 2013 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 types2
+
+import (
+	"bytes"
+	"cmd/compile/internal/syntax"
+	"fmt"
+	"go/constant"
+	"go/token"
+)
+
+// An Object describes a named language entity such as a package,
+// constant, type, variable, function (incl. methods), or label.
+// All objects implement the Object interface.
+//
+type Object interface {
+	Parent() *Scope  // scope in which this object is declared; nil for methods and struct fields
+	Pos() syntax.Pos // position of object identifier in declaration
+	Pkg() *Package   // package to which this object belongs; nil for labels and objects in the Universe scope
+	Name() string    // package local object name
+	Type() Type      // object type
+	Exported() bool  // reports whether the name starts with a capital letter
+	Id() string      // object name if exported, qualified name if not exported (see func Id)
+
+	// String returns a human-readable string of the object.
+	String() string
+
+	// order reflects a package-level object's source order: if object
+	// a is before object b in the source, then a.order() < b.order().
+	// order returns a value > 0 for package-level objects; it returns
+	// 0 for all other objects (including objects in file scopes).
+	order() uint32
+
+	// color returns the object's color.
+	color() color
+
+	// setType sets the type of the object.
+	setType(Type)
+
+	// setOrder sets the order number of the object. It must be > 0.
+	setOrder(uint32)
+
+	// setColor sets the object's color. It must not be white.
+	setColor(color color)
+
+	// setParent sets the parent scope of the object.
+	setParent(*Scope)
+
+	// sameId reports whether obj.Id() and Id(pkg, name) are the same.
+	sameId(pkg *Package, name string) bool
+
+	// scopePos returns the start position of the scope of this Object
+	scopePos() syntax.Pos
+
+	// setScopePos sets the start position of the scope for this Object.
+	setScopePos(pos syntax.Pos)
+}
+
+// Id returns name if it is exported, otherwise it
+// returns the name qualified with the package path.
+func Id(pkg *Package, name string) string {
+	if token.IsExported(name) {
+		return name
+	}
+	// unexported names need the package path for differentiation
+	// (if there's no package, make sure we don't start with '.'
+	// as that may change the order of methods between a setup
+	// inside a package and outside a package - which breaks some
+	// tests)
+	path := "_"
+	// pkg is nil for objects in Universe scope and possibly types
+	// introduced via Eval (see also comment in object.sameId)
+	if pkg != nil && pkg.path != "" {
+		path = pkg.path
+	}
+	return path + "." + name
+}
+
+// An object implements the common parts of an Object.
+type object struct {
+	parent    *Scope
+	pos       syntax.Pos
+	pkg       *Package
+	name      string
+	typ       Type
+	order_    uint32
+	color_    color
+	scopePos_ syntax.Pos
+}
+
+// color encodes the color of an object (see Checker.objDecl for details).
+type color uint32
+
+// An object may be painted in one of three colors.
+// Color values other than white or black are considered grey.
+const (
+	white color = iota
+	black
+	grey // must be > white and black
+)
+
+func (c color) String() string {
+	switch c {
+	case white:
+		return "white"
+	case black:
+		return "black"
+	default:
+		return "grey"
+	}
+}
+
+// colorFor returns the (initial) color for an object depending on
+// whether its type t is known or not.
+func colorFor(t Type) color {
+	if t != nil {
+		return black
+	}
+	return white
+}
+
+// Parent returns the scope in which the object is declared.
+// The result is nil for methods and struct fields.
+func (obj *object) Parent() *Scope { return obj.parent }
+
+// Pos returns the declaration position of the object's identifier.
+func (obj *object) Pos() syntax.Pos { return obj.pos }
+
+// Pkg returns the package to which the object belongs.
+// The result is nil for labels and objects in the Universe scope.
+func (obj *object) Pkg() *Package { return obj.pkg }
+
+// Name returns the object's (package-local, unqualified) name.
+func (obj *object) Name() string { return obj.name }
+
+// Type returns the object's type.
+func (obj *object) Type() Type { return obj.typ }
+
+// Exported reports whether the object is exported (starts with a capital letter).
+// It doesn't take into account whether the object is in a local (function) scope
+// or not.
+func (obj *object) Exported() bool { return token.IsExported(obj.name) }
+
+// Id is a wrapper for Id(obj.Pkg(), obj.Name()).
+func (obj *object) Id() string { return Id(obj.pkg, obj.name) }
+
+func (obj *object) String() string       { panic("abstract") }
+func (obj *object) order() uint32        { return obj.order_ }
+func (obj *object) color() color         { return obj.color_ }
+func (obj *object) scopePos() syntax.Pos { return obj.scopePos_ }
+
+func (obj *object) setParent(parent *Scope)    { obj.parent = parent }
+func (obj *object) setType(typ Type)           { obj.typ = typ }
+func (obj *object) setOrder(order uint32)      { assert(order > 0); obj.order_ = order }
+func (obj *object) setColor(color color)       { assert(color != white); obj.color_ = color }
+func (obj *object) setScopePos(pos syntax.Pos) { obj.scopePos_ = pos }
+
+func (obj *object) sameId(pkg *Package, name string) bool {
+	// spec:
+	// "Two identifiers are different if they are spelled differently,
+	// or if they appear in different packages and are not exported.
+	// Otherwise, they are the same."
+	if name != obj.name {
+		return false
+	}
+	// obj.Name == name
+	if obj.Exported() {
+		return true
+	}
+	// not exported, so packages must be the same (pkg == nil for
+	// fields in Universe scope; this can only happen for types
+	// introduced via Eval)
+	if pkg == nil || obj.pkg == nil {
+		return pkg == obj.pkg
+	}
+	// pkg != nil && obj.pkg != nil
+	return pkg.path == obj.pkg.path
+}
+
+// A PkgName represents an imported Go package.
+// PkgNames don't have a type.
+type PkgName struct {
+	object
+	imported *Package
+	used     bool // set if the package was used
+}
+
+// NewPkgName returns a new PkgName object representing an imported package.
+// The remaining arguments set the attributes found with all Objects.
+func NewPkgName(pos syntax.Pos, pkg *Package, name string, imported *Package) *PkgName {
+	return &PkgName{object{nil, pos, pkg, name, Typ[Invalid], 0, black, nopos}, imported, false}
+}
+
+// Imported returns the package that was imported.
+// It is distinct from Pkg(), which is the package containing the import statement.
+func (obj *PkgName) Imported() *Package { return obj.imported }
+
+// A Const represents a declared constant.
+type Const struct {
+	object
+	val constant.Value
+}
+
+// NewConst returns a new constant with value val.
+// The remaining arguments set the attributes found with all Objects.
+func NewConst(pos syntax.Pos, pkg *Package, name string, typ Type, val constant.Value) *Const {
+	return &Const{object{nil, pos, pkg, name, typ, 0, colorFor(typ), nopos}, val}
+}
+
+// Val returns the constant's value.
+func (obj *Const) Val() constant.Value { return obj.val }
+
+func (*Const) isDependency() {} // a constant may be a dependency of an initialization expression
+
+// A TypeName represents a name for a (defined or alias) type.
+type TypeName struct {
+	object
+}
+
+// NewTypeName returns a new type name denoting the given typ.
+// The remaining arguments set the attributes found with all Objects.
+//
+// The typ argument may be a defined (Named) type or an alias type.
+// It may also be nil such that the returned TypeName can be used as
+// argument for NewNamed, which will set the TypeName's type as a side-
+// effect.
+func NewTypeName(pos syntax.Pos, pkg *Package, name string, typ Type) *TypeName {
+	return &TypeName{object{nil, pos, pkg, name, typ, 0, colorFor(typ), nopos}}
+}
+
+// IsAlias reports whether obj is an alias name for a type.
+func (obj *TypeName) IsAlias() bool {
+	switch t := obj.typ.(type) {
+	case nil:
+		return false
+	case *Basic:
+		// unsafe.Pointer is not an alias.
+		if obj.pkg == Unsafe {
+			return false
+		}
+		// Any user-defined type name for a basic type is an alias for a
+		// basic type (because basic types are pre-declared in the Universe
+		// scope, outside any package scope), and so is any type name with
+		// a different name than the name of the basic type it refers to.
+		// Additionally, we need to look for "byte" and "rune" because they
+		// are aliases but have the same names (for better error messages).
+		return obj.pkg != nil || t.name != obj.name || t == universeByte || t == universeRune
+	case *Named:
+		return obj != t.obj
+	default:
+		return true
+	}
+}
+
+// A Variable represents a declared variable (including function parameters and results, and struct fields).
+type Var struct {
+	object
+	embedded bool // if set, the variable is an embedded struct field, and name is the type name
+	isField  bool // var is struct field
+	used     bool // set if the variable was used
+}
+
+// NewVar returns a new variable.
+// The arguments set the attributes found with all Objects.
+func NewVar(pos syntax.Pos, pkg *Package, name string, typ Type) *Var {
+	return &Var{object: object{nil, pos, pkg, name, typ, 0, colorFor(typ), nopos}}
+}
+
+// NewParam returns a new variable representing a function parameter.
+func NewParam(pos syntax.Pos, pkg *Package, name string, typ Type) *Var {
+	return &Var{object: object{nil, pos, pkg, name, typ, 0, colorFor(typ), nopos}, used: true} // parameters are always 'used'
+}
+
+// NewField returns a new variable representing a struct field.
+// For embedded fields, the name is the unqualified type name
+/// under which the field is accessible.
+func NewField(pos syntax.Pos, pkg *Package, name string, typ Type, embedded bool) *Var {
+	return &Var{object: object{nil, pos, pkg, name, typ, 0, colorFor(typ), nopos}, embedded: embedded, isField: true}
+}
+
+// Anonymous reports whether the variable is an embedded field.
+// Same as Embedded; only present for backward-compatibility.
+func (obj *Var) Anonymous() bool { return obj.embedded }
+
+// Embedded reports whether the variable is an embedded field.
+func (obj *Var) Embedded() bool { return obj.embedded }
+
+// IsField reports whether the variable is a struct field.
+func (obj *Var) IsField() bool { return obj.isField }
+
+func (*Var) isDependency() {} // a variable may be a dependency of an initialization expression
+
+// A Func represents a declared function, concrete method, or abstract
+// (interface) method. Its Type() is always a *Signature.
+// 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
+}
+
+// NewFunc returns a new function with the given signature, representing
+// the function's type.
+func NewFunc(pos syntax.Pos, pkg *Package, name string, sig *Signature) *Func {
+	// don't store a (typed) nil signature
+	var typ Type
+	if sig != nil {
+		typ = sig
+	}
+	return &Func{object{nil, pos, pkg, name, typ, 0, colorFor(typ), nopos}, false}
+}
+
+// FullName returns the package- or receiver-type-qualified name of
+// function or method obj.
+func (obj *Func) FullName() string {
+	var buf bytes.Buffer
+	writeFuncName(&buf, obj, nil)
+	return buf.String()
+}
+
+// Scope returns the scope of the function's body block.
+func (obj *Func) Scope() *Scope { return obj.typ.(*Signature).scope }
+
+func (*Func) isDependency() {} // a function may be a dependency of an initialization expression
+
+// A Label represents a declared label.
+// Labels don't have a type.
+type Label struct {
+	object
+	used bool // set if the label was used
+}
+
+// NewLabel returns a new label.
+func NewLabel(pos syntax.Pos, pkg *Package, name string) *Label {
+	return &Label{object{pos: pos, pkg: pkg, name: name, typ: Typ[Invalid], color_: black}, false}
+}
+
+// A Builtin represents a built-in function.
+// Builtins don't have a valid type.
+type Builtin struct {
+	object
+	id builtinId
+}
+
+func newBuiltin(id builtinId) *Builtin {
+	return &Builtin{object{name: predeclaredFuncs[id].name, typ: Typ[Invalid], color_: black}, id}
+}
+
+// Nil represents the predeclared value nil.
+type Nil struct {
+	object
+}
+
+func writeObject(buf *bytes.Buffer, obj Object, qf Qualifier) {
+	var tname *TypeName
+	typ := obj.Type()
+
+	switch obj := obj.(type) {
+	case *PkgName:
+		fmt.Fprintf(buf, "package %s", obj.Name())
+		if path := obj.imported.path; path != "" && path != obj.name {
+			fmt.Fprintf(buf, " (%q)", path)
+		}
+		return
+
+	case *Const:
+		buf.WriteString("const")
+
+	case *TypeName:
+		tname = obj
+		buf.WriteString("type")
+
+	case *Var:
+		if obj.isField {
+			buf.WriteString("field")
+		} else {
+			buf.WriteString("var")
+		}
+
+	case *Func:
+		buf.WriteString("func ")
+		writeFuncName(buf, obj, qf)
+		if typ != nil {
+			WriteSignature(buf, typ.(*Signature), qf)
+		}
+		return
+
+	case *Label:
+		buf.WriteString("label")
+		typ = nil
+
+	case *Builtin:
+		buf.WriteString("builtin")
+		typ = nil
+
+	case *Nil:
+		buf.WriteString("nil")
+		return
+
+	default:
+		panic(fmt.Sprintf("writeObject(%T)", obj))
+	}
+
+	buf.WriteByte(' ')
+
+	// For package-level objects, qualify the name.
+	if obj.Pkg() != nil && obj.Pkg().scope.Lookup(obj.Name()) == obj {
+		writePackage(buf, obj.Pkg(), qf)
+	}
+	buf.WriteString(obj.Name())
+
+	if typ == nil {
+		return
+	}
+
+	if tname != nil {
+		// We have a type object: Don't print anything more for
+		// basic types since there's no more information (names
+		// are the same; see also comment in TypeName.IsAlias).
+		if _, ok := typ.(*Basic); ok {
+			return
+		}
+		if tname.IsAlias() {
+			buf.WriteString(" =")
+		} else {
+			typ = typ.Under()
+		}
+	}
+
+	buf.WriteByte(' ')
+	WriteType(buf, typ, qf)
+}
+
+func writePackage(buf *bytes.Buffer, pkg *Package, qf Qualifier) {
+	if pkg == nil {
+		return
+	}
+	var s string
+	if qf != nil {
+		s = qf(pkg)
+	} else {
+		s = pkg.Path()
+	}
+	if s != "" {
+		buf.WriteString(s)
+		buf.WriteByte('.')
+	}
+}
+
+// ObjectString returns the string form of obj.
+// The Qualifier controls the printing of
+// package-level objects, and may be nil.
+func ObjectString(obj Object, qf Qualifier) string {
+	var buf bytes.Buffer
+	writeObject(&buf, obj, qf)
+	return buf.String()
+}
+
+func (obj *PkgName) String() string  { return ObjectString(obj, nil) }
+func (obj *Const) String() string    { return ObjectString(obj, nil) }
+func (obj *TypeName) String() string { return ObjectString(obj, nil) }
+func (obj *Var) String() string      { return ObjectString(obj, nil) }
+func (obj *Func) String() string     { return ObjectString(obj, nil) }
+func (obj *Label) String() string    { return ObjectString(obj, nil) }
+func (obj *Builtin) String() string  { return ObjectString(obj, nil) }
+func (obj *Nil) String() string      { return ObjectString(obj, nil) }
+
+func writeFuncName(buf *bytes.Buffer, f *Func, qf Qualifier) {
+	if f.typ != nil {
+		sig := f.typ.(*Signature)
+		if recv := sig.Recv(); recv != nil {
+			buf.WriteByte('(')
+			if _, ok := recv.Type().(*Interface); ok {
+				// gcimporter creates abstract methods of
+				// named interfaces using the interface type
+				// (not the named type) as the receiver.
+				// Don't print it in full.
+				buf.WriteString("interface")
+			} else {
+				WriteType(buf, recv.Type(), qf)
+			}
+			buf.WriteByte(')')
+			buf.WriteByte('.')
+		} else if f.pkg != nil {
+			writePackage(buf, f.pkg, qf)
+		}
+	}
+	buf.WriteString(f.name)
+}
diff --git a/src/cmd/compile/internal/types2/object_test.go b/src/cmd/compile/internal/types2/object_test.go
new file mode 100644
index 0000000000..8f11c87451
--- /dev/null
+++ b/src/cmd/compile/internal/types2/object_test.go
@@ -0,0 +1,89 @@
+// UNREVIEWED
+// Copyright 2016 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 types2
+
+import (
+	"cmd/compile/internal/syntax"
+	"strings"
+	"testing"
+)
+
+func parseSrc(path, src string) (*syntax.File, error) {
+	return syntax.Parse(syntax.NewFileBase(path), strings.NewReader(src), nil, nil, 0)
+}
+
+func TestIsAlias(t *testing.T) {
+	check := func(obj *TypeName, want bool) {
+		if got := obj.IsAlias(); got != want {
+			t.Errorf("%v: got IsAlias = %v; want %v", obj, got, want)
+		}
+	}
+
+	// predeclared types
+	check(Unsafe.Scope().Lookup("Pointer").(*TypeName), false)
+	for _, name := range Universe.Names() {
+		if obj, _ := Universe.Lookup(name).(*TypeName); obj != nil {
+			check(obj, name == "byte" || name == "rune")
+		}
+	}
+
+	// various other types
+	pkg := NewPackage("p", "p")
+	t1 := NewTypeName(nopos, pkg, "t1", nil)
+	n1 := NewNamed(t1, new(Struct), nil)
+	for _, test := range []struct {
+		name  *TypeName
+		alias bool
+	}{
+		{NewTypeName(nopos, nil, "t0", nil), false}, // no type yet
+		{NewTypeName(nopos, pkg, "t0", nil), false}, // no type yet
+		{t1, false}, // type name refers to named type and vice versa
+		{NewTypeName(nopos, nil, "t2", &emptyInterface), true}, // type name refers to unnamed type
+		{NewTypeName(nopos, pkg, "t3", n1), true},              // type name refers to named type with different type name
+		{NewTypeName(nopos, nil, "t4", Typ[Int32]), true},      // type name refers to basic type with different name
+		{NewTypeName(nopos, nil, "int32", Typ[Int32]), false},  // type name refers to basic type with same name
+		{NewTypeName(nopos, pkg, "int32", Typ[Int32]), true},   // type name is declared in user-defined package (outside Universe)
+		{NewTypeName(nopos, nil, "rune", Typ[Rune]), true},     // type name refers to basic type rune which is an alias already
+	} {
+		check(test.name, test.alias)
+	}
+}
+
+// TestEmbeddedMethod checks that an embedded method is represented by
+// the same Func Object as the original method. See also issue #34421.
+func TestEmbeddedMethod(t *testing.T) {
+	const src = `package p; type I interface { error }`
+
+	// type-check src
+	f, err := parseSrc("", src)
+	if err != nil {
+		t.Fatalf("parse failed: %s", err)
+	}
+	var conf Config
+	pkg, err := conf.Check(f.PkgName.Value, []*syntax.File{f}, nil)
+	if err != nil {
+		t.Fatalf("typecheck failed: %s", err)
+	}
+
+	// get original error.Error method
+	eface := Universe.Lookup("error")
+	orig, _, _ := LookupFieldOrMethod(eface.Type(), false, nil, "Error")
+	if orig == nil {
+		t.Fatalf("original error.Error not found")
+	}
+
+	// get embedded error.Error method
+	iface := pkg.Scope().Lookup("I")
+	embed, _, _ := LookupFieldOrMethod(iface.Type(), false, nil, "Error")
+	if embed == nil {
+		t.Fatalf("embedded error.Error not found")
+	}
+
+	// original and embedded Error object should be identical
+	if orig != embed {
+		t.Fatalf("%s (%p) != %s (%p)", orig, orig, embed, embed)
+	}
+}
diff --git a/src/cmd/compile/internal/types2/objset.go b/src/cmd/compile/internal/types2/objset.go
new file mode 100644
index 0000000000..ef06315705
--- /dev/null
+++ b/src/cmd/compile/internal/types2/objset.go
@@ -0,0 +1,32 @@
+// UNREVIEWED
+// Copyright 2013 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.
+
+// This file implements objsets.
+//
+// An objset is similar to a Scope but objset elements
+// are identified by their unique id, instead of their
+// object name.
+
+package types2
+
+// An objset is a set of objects identified by their unique id.
+// The zero value for objset is a ready-to-use empty objset.
+type objset map[string]Object // initialized lazily
+
+// insert attempts to insert an object obj into objset s.
+// If s already contains an alternative object alt with
+// the same name, insert leaves s unchanged and returns alt.
+// Otherwise it inserts obj and returns nil.
+func (s *objset) insert(obj Object) Object {
+	id := obj.Id()
+	if alt := (*s)[id]; alt != nil {
+		return alt
+	}
+	if *s == nil {
+		*s = make(map[string]Object)
+	}
+	(*s)[id] = obj
+	return nil
+}
diff --git a/src/cmd/compile/internal/types2/operand.go b/src/cmd/compile/internal/types2/operand.go
new file mode 100644
index 0000000000..fe88921893
--- /dev/null
+++ b/src/cmd/compile/internal/types2/operand.go
@@ -0,0 +1,315 @@
+// UNREVIEWED
+// Copyright 2012 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.
+
+// This file defines operands and associated operations.
+
+package types2
+
+import (
+	"bytes"
+	"cmd/compile/internal/syntax"
+	"fmt"
+	"go/constant"
+	"go/token"
+)
+
+// An operandMode specifies the (addressing) mode of an operand.
+type operandMode byte
+
+const (
+	invalid   operandMode = iota // operand is invalid
+	novalue                      // operand represents no value (result of a function call w/o result)
+	builtin                      // operand is a built-in function
+	typexpr                      // operand is a type
+	constant_                    // operand is a constant; the operand's typ is a Basic type
+	variable                     // operand is an addressable variable
+	mapindex                     // operand is a map index expression (acts like a variable on lhs, commaok on rhs of an assignment)
+	value                        // operand is a computed value
+	commaok                      // like value, but operand may be used in a comma,ok expression
+	commaerr                     // like commaok, but second value is error, not boolean
+	cgofunc                      // operand is a cgo function
+)
+
+var operandModeString = [...]string{
+	invalid:   "invalid operand",
+	novalue:   "no value",
+	builtin:   "built-in",
+	typexpr:   "type",
+	constant_: "constant",
+	variable:  "variable",
+	mapindex:  "map index expression",
+	value:     "value",
+	commaok:   "comma, ok expression",
+	commaerr:  "comma, error expression",
+	cgofunc:   "cgo function",
+}
+
+// An operand represents an intermediate value during type checking.
+// Operands have an (addressing) mode, the expression evaluating to
+// the operand, the operand's type, a value for constants, and an id
+// for built-in functions.
+// The zero value of operand is a ready to use invalid operand.
+//
+type operand struct {
+	mode operandMode
+	expr syntax.Expr
+	typ  Type
+	val  constant.Value
+	id   builtinId
+}
+
+// Pos returns the position of the expression corresponding to x.
+// If x is invalid the position is nopos.
+//
+func (x *operand) Pos() syntax.Pos {
+	// x.expr may not be set if x is invalid
+	if x.expr == nil {
+		return nopos
+	}
+	return x.expr.Pos()
+}
+
+// Operand string formats
+// (not all "untyped" cases can appear due to the type system,
+// but they fall out naturally here)
+//
+// mode       format
+//
+// invalid    <expr> (               <mode>                    )
+// novalue    <expr> (               <mode>                    )
+// builtin    <expr> (               <mode>                    )
+// typexpr    <expr> (               <mode>                    )
+//
+// constant   <expr> (<untyped kind> <mode>                    )
+// constant   <expr> (               <mode>       of type <typ>)
+// constant   <expr> (<untyped kind> <mode> <val>              )
+// constant   <expr> (               <mode> <val> of type <typ>)
+//
+// variable   <expr> (<untyped kind> <mode>                    )
+// variable   <expr> (               <mode>       of type <typ>)
+//
+// mapindex   <expr> (<untyped kind> <mode>                    )
+// mapindex   <expr> (               <mode>       of type <typ>)
+//
+// value      <expr> (<untyped kind> <mode>                    )
+// value      <expr> (               <mode>       of type <typ>)
+//
+// commaok    <expr> (<untyped kind> <mode>                    )
+// commaok    <expr> (               <mode>       of type <typ>)
+//
+// commaerr   <expr> (<untyped kind> <mode>                    )
+// commaerr   <expr> (               <mode>       of type <typ>)
+//
+// cgofunc    <expr> (<untyped kind> <mode>                    )
+// cgofunc    <expr> (               <mode>       of type <typ>)
+//
+func operandString(x *operand, qf Qualifier) string {
+	var buf bytes.Buffer
+
+	var expr string
+	if x.expr != nil {
+		expr = ExprString(x.expr)
+	} else {
+		switch x.mode {
+		case builtin:
+			expr = predeclaredFuncs[x.id].name
+		case typexpr:
+			expr = TypeString(x.typ, qf)
+		case constant_:
+			expr = x.val.String()
+		}
+	}
+
+	// <expr> (
+	if expr != "" {
+		buf.WriteString(expr)
+		buf.WriteString(" (")
+	}
+
+	// <untyped kind>
+	hasType := false
+	switch x.mode {
+	case invalid, novalue, builtin, typexpr:
+		// no type
+	default:
+		// should have a type, but be cautious (don't crash during printing)
+		if x.typ != nil {
+			if isUntyped(x.typ) {
+				buf.WriteString(x.typ.(*Basic).name)
+				buf.WriteByte(' ')
+				break
+			}
+			hasType = true
+		}
+	}
+
+	// <mode>
+	buf.WriteString(operandModeString[x.mode])
+
+	// <val>
+	if x.mode == constant_ {
+		if s := x.val.String(); s != expr {
+			buf.WriteByte(' ')
+			buf.WriteString(s)
+		}
+	}
+
+	// <typ>
+	if hasType {
+		if x.typ != Typ[Invalid] {
+			var intro string
+			switch {
+			case isGeneric(x.typ):
+				intro = " of generic type "
+			case x.typ.TypeParam() != nil:
+				intro = " of type parameter type "
+			default:
+				intro = " of type "
+			}
+			buf.WriteString(intro)
+			WriteType(&buf, x.typ, qf)
+		} else {
+			buf.WriteString(" with invalid type")
+		}
+	}
+
+	// )
+	if expr != "" {
+		buf.WriteByte(')')
+	}
+
+	return buf.String()
+}
+
+func (x *operand) String() string {
+	return operandString(x, nil)
+}
+
+// setConst sets x to the untyped constant for literal lit.
+func (x *operand) setConst(k syntax.LitKind, lit string) {
+	var tok token.Token
+	var kind BasicKind
+	switch k {
+	case syntax.IntLit:
+		tok = token.INT
+		kind = UntypedInt
+	case syntax.FloatLit:
+		tok = token.FLOAT
+		kind = UntypedFloat
+	case syntax.ImagLit:
+		tok = token.IMAG
+		kind = UntypedComplex
+	case syntax.RuneLit:
+		tok = token.CHAR
+		kind = UntypedRune
+	case syntax.StringLit:
+		tok = token.STRING
+		kind = UntypedString
+	default:
+		unreachable()
+	}
+
+	x.mode = constant_
+	x.typ = Typ[kind]
+	x.val = constant.MakeFromLiteral(lit, tok, 0)
+}
+
+// isNil reports whether x is the nil value.
+func (x *operand) isNil() bool {
+	return x.mode == value && x.typ == Typ[UntypedNil]
+}
+
+// TODO(gri) The functions operand.assignableTo, checker.convertUntyped,
+//           checker.representable, and checker.assignment are
+//           overlapping in functionality. Need to simplify and clean up.
+
+// assignableTo reports whether x is assignable to a variable of type T.
+// If the result is false and a non-nil reason is provided, it may be set
+// to a more detailed explanation of the failure (result != "").
+// The check parameter may be nil if assignableTo is invoked through
+// an exported API call, i.e., when all methods have been type-checked.
+func (x *operand) assignableTo(check *Checker, T Type, reason *string) bool {
+	if x.mode == invalid || T == Typ[Invalid] {
+		return true // avoid spurious errors
+	}
+
+	V := x.typ
+
+	// x's type is identical to T
+	if check.identical(V, T) {
+		return true
+	}
+
+	Vu := optype(V.Under())
+	Tu := optype(T.Under())
+
+	// x is an untyped value representable by a value of type T
+	// TODO(gri) This is borrowing from checker.convertUntyped and
+	//           checker.representable. Need to clean up.
+	if isUntyped(Vu) {
+		switch t := Tu.(type) {
+		case *Basic:
+			if x.isNil() && t.kind == UnsafePointer {
+				return true
+			}
+			if x.mode == constant_ {
+				return representableConst(x.val, check, t, nil)
+			}
+			// The result of a comparison is an untyped boolean,
+			// but may not be a constant.
+			if Vb, _ := Vu.(*Basic); Vb != nil {
+				return Vb.kind == UntypedBool && isBoolean(Tu)
+			}
+		case *Sum:
+			return t.is(func(t Type) bool {
+				// TODO(gri) this could probably be more efficient
+				return x.assignableTo(check, t, reason)
+			})
+		case *Interface:
+			check.completeInterface(nopos, t)
+			return x.isNil() || t.Empty()
+		case *Pointer, *Signature, *Slice, *Map, *Chan:
+			return x.isNil()
+		}
+	}
+	// Vu is typed
+
+	// x's type V and T have identical underlying types
+	// and at least one of V or T is not a named type
+	if check.identical(Vu, Tu) && (!isNamed(V) || !isNamed(T)) {
+		return true
+	}
+
+	// T is an interface type and x implements T
+	if Ti, ok := Tu.(*Interface); ok {
+		if m, wrongType := check.missingMethod(V, Ti, true); m != nil /* Implements(V, Ti) */ {
+			if reason != nil {
+				if wrongType != nil {
+					if check.identical(m.typ, wrongType.typ) {
+						*reason = fmt.Sprintf("missing method %s (%s has pointer receiver)", m.name, m.name)
+					} else {
+						*reason = fmt.Sprintf("wrong type for method %s (have %s, want %s)", m.Name(), wrongType.typ, m.typ)
+					}
+
+				} else {
+					*reason = "missing method " + m.Name()
+				}
+			}
+			return false
+		}
+		return true
+	}
+
+	// x is a bidirectional channel value, T is a channel
+	// type, x's type V and T have identical element types,
+	// and at least one of V or T is not a named type
+	if Vc, ok := Vu.(*Chan); ok && Vc.dir == SendRecv {
+		if Tc, ok := Tu.(*Chan); ok && check.identical(Vc.elem, Tc.elem) {
+			return !isNamed(V) || !isNamed(T)
+		}
+	}
+
+	return false
+}
diff --git a/src/cmd/compile/internal/types2/package.go b/src/cmd/compile/internal/types2/package.go
new file mode 100644
index 0000000000..03ae6ff5b7
--- /dev/null
+++ b/src/cmd/compile/internal/types2/package.go
@@ -0,0 +1,65 @@
+// UNREVIEWED
+// Copyright 2013 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 types2
+
+import (
+	"fmt"
+)
+
+// A Package describes a Go package.
+type Package struct {
+	path     string
+	name     string
+	scope    *Scope
+	complete bool
+	imports  []*Package
+	fake     bool // scope lookup errors are silently dropped if package is fake (internal use only)
+	cgo      bool // uses of this package will be rewritten into uses of declarations from _cgo_gotypes.go
+}
+
+// NewPackage returns a new Package for the given package path and name.
+// The package is not complete and contains no explicit imports.
+func NewPackage(path, name string) *Package {
+	scope := NewScope(Universe, nopos, nopos, fmt.Sprintf("package %q", path))
+	return &Package{path: path, name: name, scope: scope}
+}
+
+// Path returns the package path.
+func (pkg *Package) Path() string { return pkg.path }
+
+// Name returns the package name.
+func (pkg *Package) Name() string { return pkg.name }
+
+// SetName sets the package name.
+func (pkg *Package) SetName(name string) { pkg.name = name }
+
+// Scope returns the (complete or incomplete) package scope
+// holding the objects declared at package level (TypeNames,
+// Consts, Vars, and Funcs).
+func (pkg *Package) Scope() *Scope { return pkg.scope }
+
+// A package is complete if its scope contains (at least) all
+// exported objects; otherwise it is incomplete.
+func (pkg *Package) Complete() bool { return pkg.complete }
+
+// MarkComplete marks a package as complete.
+func (pkg *Package) MarkComplete() { pkg.complete = true }
+
+// Imports returns the list of packages directly imported by
+// pkg; the list is in source order.
+//
+// If pkg was loaded from export data, Imports includes packages that
+// provide package-level objects referenced by pkg. This may be more or
+// less than the set of packages directly imported by pkg's source code.
+func (pkg *Package) Imports() []*Package { return pkg.imports }
+
+// SetImports sets the list of explicitly imported packages to list.
+// It is the caller's responsibility to make sure list elements are unique.
+func (pkg *Package) SetImports(list []*Package) { pkg.imports = list }
+
+func (pkg *Package) String() string {
+	return fmt.Sprintf("package %s (%q)", pkg.name, pkg.path)
+}
diff --git a/src/cmd/compile/internal/types2/pos.go b/src/cmd/compile/internal/types2/pos.go
new file mode 100644
index 0000000000..4dd839b7dc
--- /dev/null
+++ b/src/cmd/compile/internal/types2/pos.go
@@ -0,0 +1,364 @@
+// UNREVIEWED
+// Copyright 2012 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.
+
+// This file implements helper functions for scope position computations.
+
+package types2
+
+import "cmd/compile/internal/syntax"
+
+// startPos returns the start position of n.
+func startPos(n syntax.Node) syntax.Pos {
+	// Cases for nodes which don't need a correction are commented out.
+	for m := n; ; {
+		switch n := m.(type) {
+		case nil:
+			panic("internal error: nil")
+
+		// packages
+		case *syntax.File:
+			// file block starts at the beginning of the file
+			return syntax.MakePos(n.Pos().Base(), 1, 1)
+
+		// declarations
+		// case *syntax.ImportDecl:
+		// case *syntax.ConstDecl:
+		// case *syntax.TypeDecl:
+		// case *syntax.VarDecl:
+		// case *syntax.FuncDecl:
+
+		// expressions
+		// case *syntax.BadExpr:
+		// case *syntax.Name:
+		// case *syntax.BasicLit:
+		case *syntax.CompositeLit:
+			if n.Type != nil {
+				m = n.Type
+				continue
+			}
+			return n.Pos()
+		// case *syntax.KeyValueExpr:
+		// case *syntax.FuncLit:
+		// case *syntax.ParenExpr:
+		case *syntax.SelectorExpr:
+			m = n.X
+		case *syntax.IndexExpr:
+			m = n.X
+		// case *syntax.SliceExpr:
+		case *syntax.AssertExpr:
+			m = n.X
+		case *syntax.TypeSwitchGuard:
+			if n.Lhs != nil {
+				m = n.Lhs
+				continue
+			}
+			m = n.X
+		case *syntax.Operation:
+			if n.Y != nil {
+				m = n.X
+				continue
+			}
+			return n.Pos()
+		case *syntax.CallExpr:
+			m = n.Fun
+		case *syntax.ListExpr:
+			if len(n.ElemList) > 0 {
+				m = n.ElemList[0]
+				continue
+			}
+			return n.Pos()
+		// types
+		// case *syntax.ArrayType:
+		// case *syntax.SliceType:
+		// case *syntax.DotsType:
+		// case *syntax.StructType:
+		// case *syntax.Field:
+		// case *syntax.InterfaceType:
+		// case *syntax.FuncType:
+		// case *syntax.MapType:
+		// case *syntax.ChanType:
+
+		// statements
+		// case *syntax.EmptyStmt:
+		// case *syntax.LabeledStmt:
+		// case *syntax.BlockStmt:
+		// case *syntax.ExprStmt:
+		case *syntax.SendStmt:
+			m = n.Chan
+		// case *syntax.DeclStmt:
+		case *syntax.AssignStmt:
+			m = n.Lhs
+		// case *syntax.BranchStmt:
+		// case *syntax.CallStmt:
+		// case *syntax.ReturnStmt:
+		// case *syntax.IfStmt:
+		// case *syntax.ForStmt:
+		// case *syntax.SwitchStmt:
+		// case *syntax.SelectStmt:
+
+		// helper nodes
+		case *syntax.RangeClause:
+			if n.Lhs != nil {
+				m = n.Lhs
+				continue
+			}
+			m = n.X
+		// case *syntax.CaseClause:
+		// case *syntax.CommClause:
+
+		default:
+			return n.Pos()
+		}
+	}
+}
+
+// endPos returns the approximate end position of n in the source.
+// For some nodes (*syntax.Name, *syntax.BasicLit) it returns
+// the position immediately following the node; for others
+// (*syntax.BlockStmt, *syntax.SwitchStmt, etc.) it returns
+// the position of the closing '}'; and for some (*syntax.ParenExpr)
+// the returned position is the end position of the last enclosed
+// expression.
+// Thus, endPos should not be used for exact demarcation of the
+// end of a node in the source; it is mostly useful to determine
+// scope ranges where there is some leeway.
+func endPos(n syntax.Node) syntax.Pos {
+	for m := n; ; {
+		switch n := m.(type) {
+		case nil:
+			panic("internal error: nil")
+
+		// packages
+		case *syntax.File:
+			return n.EOF
+
+		// declarations
+		case *syntax.ImportDecl:
+			m = n.Path
+		case *syntax.ConstDecl:
+			if n.Values != nil {
+				m = n.Values
+				continue
+			}
+			if n.Type != nil {
+				m = n.Type
+				continue
+			}
+			if l := len(n.NameList); l > 0 {
+				m = n.NameList[l-1]
+				continue
+			}
+			return n.Pos()
+		case *syntax.TypeDecl:
+			m = n.Type
+		case *syntax.VarDecl:
+			if n.Values != nil {
+				m = n.Values
+				continue
+			}
+			if n.Type != nil {
+				m = n.Type
+				continue
+			}
+			if l := len(n.NameList); l > 0 {
+				m = n.NameList[l-1]
+				continue
+			}
+			return n.Pos()
+		case *syntax.FuncDecl:
+			if n.Body != nil {
+				m = n.Body
+				continue
+			}
+			m = n.Type
+
+		// expressions
+		case *syntax.BadExpr:
+			return n.Pos()
+		case *syntax.Name:
+			p := n.Pos()
+			return syntax.MakePos(p.Base(), p.Line(), p.Col()+uint(len(n.Value)))
+		case *syntax.BasicLit:
+			p := n.Pos()
+			return syntax.MakePos(p.Base(), p.Line(), p.Col()+uint(len(n.Value)))
+		case *syntax.CompositeLit:
+			return n.Rbrace
+		case *syntax.KeyValueExpr:
+			m = n.Value
+		case *syntax.FuncLit:
+			m = n.Body
+		case *syntax.ParenExpr:
+			m = n.X
+		case *syntax.SelectorExpr:
+			m = n.Sel
+		case *syntax.IndexExpr:
+			m = n.Index
+		case *syntax.SliceExpr:
+			for i := len(n.Index) - 1; i >= 0; i-- {
+				if x := n.Index[i]; x != nil {
+					m = x
+					continue
+				}
+			}
+			m = n.X
+		case *syntax.AssertExpr:
+			m = n.Type
+		case *syntax.TypeSwitchGuard:
+			m = n.X
+		case *syntax.Operation:
+			if n.Y != nil {
+				m = n.Y
+				continue
+			}
+			m = n.X
+		case *syntax.CallExpr:
+			if l := lastExpr(n.ArgList); l != nil {
+				m = l
+				continue
+			}
+			m = n.Fun
+		case *syntax.ListExpr:
+			if l := lastExpr(n.ElemList); l != nil {
+				m = l
+				continue
+			}
+			return n.Pos()
+
+		// types
+		case *syntax.ArrayType:
+			m = n.Elem
+		case *syntax.SliceType:
+			m = n.Elem
+		case *syntax.DotsType:
+			m = n.Elem
+		case *syntax.StructType:
+			if l := lastField(n.FieldList); l != nil {
+				m = l
+				continue
+			}
+			return n.Pos()
+			// TODO(gri) need to take TagList into account
+		case *syntax.Field:
+			if n.Type != nil {
+				m = n.Type
+				continue
+			}
+			m = n.Name
+		case *syntax.InterfaceType:
+			if l := lastField(n.MethodList); l != nil {
+				m = l
+				continue
+			}
+			return n.Pos()
+		case *syntax.FuncType:
+			if l := lastField(n.ResultList); l != nil {
+				m = l
+				continue
+			}
+			if l := lastField(n.ParamList); l != nil {
+				m = l
+				continue
+			}
+			return n.Pos()
+		case *syntax.MapType:
+			m = n.Value
+		case *syntax.ChanType:
+			m = n.Elem
+
+		// statements
+		case *syntax.EmptyStmt:
+			return n.Pos()
+		case *syntax.LabeledStmt:
+			m = n.Stmt
+		case *syntax.BlockStmt:
+			return n.Rbrace
+		case *syntax.ExprStmt:
+			m = n.X
+		case *syntax.SendStmt:
+			m = n.Value
+		case *syntax.DeclStmt:
+			if l := lastDecl(n.DeclList); l != nil {
+				m = l
+				continue
+			}
+			return n.Pos()
+		case *syntax.AssignStmt:
+			m = n.Rhs
+		case *syntax.BranchStmt:
+			if n.Label != nil {
+				m = n.Label
+				continue
+			}
+			return n.Pos()
+		case *syntax.CallStmt:
+			m = n.Call
+		case *syntax.ReturnStmt:
+			if n.Results != nil {
+				m = n.Results
+				continue
+			}
+			return n.Pos()
+		case *syntax.IfStmt:
+			if n.Else != nil {
+				m = n.Else
+				continue
+			}
+			m = n.Then
+		case *syntax.ForStmt:
+			m = n.Body
+		case *syntax.SwitchStmt:
+			return n.Rbrace
+		case *syntax.SelectStmt:
+			return n.Rbrace
+
+		// helper nodes
+		case *syntax.RangeClause:
+			m = n.X
+		case *syntax.CaseClause:
+			if l := lastStmt(n.Body); l != nil {
+				m = l
+				continue
+			}
+			return n.Colon
+		case *syntax.CommClause:
+			if l := lastStmt(n.Body); l != nil {
+				m = l
+				continue
+			}
+			return n.Colon
+
+		default:
+			return n.Pos()
+		}
+	}
+}
+
+func lastDecl(list []syntax.Decl) syntax.Decl {
+	if l := len(list); l > 0 {
+		return list[l-1]
+	}
+	return nil
+}
+
+func lastExpr(list []syntax.Expr) syntax.Expr {
+	if l := len(list); l > 0 {
+		return list[l-1]
+	}
+	return nil
+}
+
+func lastStmt(list []syntax.Stmt) syntax.Stmt {
+	if l := len(list); l > 0 {
+		return list[l-1]
+	}
+	return nil
+}
+
+func lastField(list []*syntax.Field) *syntax.Field {
+	if l := len(list); l > 0 {
+		return list[l-1]
+	}
+	return nil
+}
diff --git a/src/cmd/compile/internal/types2/predicates.go b/src/cmd/compile/internal/types2/predicates.go
new file mode 100644
index 0000000000..f3a5818b3f
--- /dev/null
+++ b/src/cmd/compile/internal/types2/predicates.go
@@ -0,0 +1,413 @@
+// UNREVIEWED
+// Copyright 2012 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.
+
+// This file implements commonly used type predicates.
+
+package types2
+
+import (
+	"sort"
+)
+
+// isNamed reports whether typ has a name.
+// isNamed may be called with types that are not fully set up.
+func isNamed(typ Type) bool {
+	switch typ.(type) {
+	case *Basic, *Named, *TypeParam, *instance:
+		return true
+	}
+	return false
+}
+
+// isGeneric reports whether a type is a generic, uninstantiated type (generic signatures are not included).
+func isGeneric(typ Type) bool {
+	// A parameterized type is only instantiated if it doesn't have an instantiation already.
+	named, _ := typ.(*Named)
+	return named != nil && named.obj != nil && named.tparams != nil && named.targs == nil
+}
+
+func is(typ Type, what BasicInfo) bool {
+	switch t := optype(typ.Under()).(type) {
+	case *Basic:
+		return t.info&what != 0
+	case *Sum:
+		return t.is(func(typ Type) bool { return is(typ, what) })
+	}
+	return false
+}
+
+func isBoolean(typ Type) bool  { return is(typ, IsBoolean) }
+func isInteger(typ Type) bool  { return is(typ, IsInteger) }
+func isUnsigned(typ Type) bool { return is(typ, IsUnsigned) }
+func isFloat(typ Type) bool    { return is(typ, IsFloat) }
+func isComplex(typ Type) bool  { return is(typ, IsComplex) }
+func isNumeric(typ Type) bool  { return is(typ, IsNumeric) }
+func isString(typ Type) bool   { return is(typ, IsString) }
+
+// Note that if typ is a type parameter, isInteger(typ) || isFloat(typ) does not
+// produce the expected result because a type list that contains both an integer
+// and a floating-point type is neither (all) integers, nor (all) floats.
+// Use isIntegerOrFloat instead.
+func isIntegerOrFloat(typ Type) bool { return is(typ, IsInteger|IsFloat) }
+
+// isNumericOrString is the equivalent of isIntegerOrFloat for isNumeric(typ) || isString(typ).
+func isNumericOrString(typ Type) bool { return is(typ, IsNumeric|IsString) }
+
+// isTyped reports whether typ is typed; i.e., not an untyped
+// constant or boolean. isTyped may be called with types that
+// are not fully set up.
+func isTyped(typ Type) bool {
+	// isTyped is called with types that are not fully
+	// set up. Must not call Basic()!
+	// A *Named or *instance type is always typed, so
+	// we only need to check if we have a true *Basic
+	// type.
+	t, _ := typ.(*Basic)
+	return t == nil || t.info&IsUntyped == 0
+}
+
+// isUntyped(typ) is the same as !isTyped(typ).
+func isUntyped(typ Type) bool {
+	return !isTyped(typ)
+}
+
+func isOrdered(typ Type) bool { return is(typ, IsOrdered) }
+
+func isConstType(typ Type) bool {
+	t := typ.Basic()
+	return t != nil && t.info&IsConstType != 0
+}
+
+// IsInterface reports whether typ is an interface type.
+func IsInterface(typ Type) bool {
+	return typ.Interface() != nil
+}
+
+// Comparable reports whether values of type T are comparable.
+func Comparable(T Type) bool {
+	// If T is a type parameter not constraint by any type
+	// list (i.e., it's underlying type is the top type),
+	// T is comparable if it has the == method. Otherwise,
+	// the underlying type "wins". For instance
+	//
+	//     interface{ comparable; type []byte }
+	//
+	// is not comparable because []byte is not comparable.
+	if t := T.TypeParam(); t != nil && optype(t) == theTop {
+		return t.Bound().IsComparable()
+	}
+
+	switch t := optype(T.Under()).(type) {
+	case *Basic:
+		// assume invalid types to be comparable
+		// to avoid follow-up errors
+		return t.kind != UntypedNil
+	case *Pointer, *Interface, *Chan:
+		return true
+	case *Struct:
+		for _, f := range t.fields {
+			if !Comparable(f.typ) {
+				return false
+			}
+		}
+		return true
+	case *Array:
+		return Comparable(t.elem)
+	case *Sum:
+		return t.is(Comparable)
+	case *TypeParam:
+		return t.Bound().IsComparable()
+	}
+	return false
+}
+
+// hasNil reports whether a type includes the nil value.
+func hasNil(typ Type) bool {
+	switch t := optype(typ.Under()).(type) {
+	case *Basic:
+		return t.kind == UnsafePointer
+	case *Slice, *Pointer, *Signature, *Interface, *Map, *Chan:
+		return true
+	case *Sum:
+		return t.is(hasNil)
+	}
+	return false
+}
+
+// identical reports whether x and y are identical types.
+// Receivers of Signature types are ignored.
+func (check *Checker) identical(x, y Type) bool {
+	return check.identical0(x, y, true, nil)
+}
+
+// identicalIgnoreTags reports whether x and y are identical types if tags are ignored.
+// Receivers of Signature types are ignored.
+func (check *Checker) identicalIgnoreTags(x, y Type) bool {
+	return check.identical0(x, y, false, nil)
+}
+
+// An ifacePair is a node in a stack of interface type pairs compared for identity.
+type ifacePair struct {
+	x, y *Interface
+	prev *ifacePair
+}
+
+func (p *ifacePair) identical(q *ifacePair) bool {
+	return p.x == q.x && p.y == q.y || p.x == q.y && p.y == q.x
+}
+
+// For changes to this code the corresponding changes should be made to unifier.nify.
+func (check *Checker) identical0(x, y Type, cmpTags bool, p *ifacePair) bool {
+	// types must be expanded for comparison
+	x = expandf(x)
+	y = expandf(y)
+
+	if x == y {
+		return true
+	}
+
+	switch x := x.(type) {
+	case *Basic:
+		// Basic types are singletons except for the rune and byte
+		// aliases, thus we cannot solely rely on the x == y check
+		// above. See also comment in TypeName.IsAlias.
+		if y, ok := y.(*Basic); ok {
+			return x.kind == y.kind
+		}
+
+	case *Array:
+		// Two array types are identical if they have identical element types
+		// and the same array length.
+		if y, ok := y.(*Array); ok {
+			// If one or both array lengths are unknown (< 0) due to some error,
+			// assume they are the same to avoid spurious follow-on errors.
+			return (x.len < 0 || y.len < 0 || x.len == y.len) && check.identical0(x.elem, y.elem, cmpTags, p)
+		}
+
+	case *Slice:
+		// Two slice types are identical if they have identical element types.
+		if y, ok := y.(*Slice); ok {
+			return check.identical0(x.elem, y.elem, cmpTags, p)
+		}
+
+	case *Struct:
+		// Two struct types are identical if they have the same sequence of fields,
+		// and if corresponding fields have the same names, and identical types,
+		// and identical tags. Two embedded fields are considered to have the same
+		// name. Lower-case field names from different packages are always different.
+		if y, ok := y.(*Struct); ok {
+			if x.NumFields() == y.NumFields() {
+				for i, f := range x.fields {
+					g := y.fields[i]
+					if f.embedded != g.embedded ||
+						cmpTags && x.Tag(i) != y.Tag(i) ||
+						!f.sameId(g.pkg, g.name) ||
+						!check.identical0(f.typ, g.typ, cmpTags, p) {
+						return false
+					}
+				}
+				return true
+			}
+		}
+
+	case *Pointer:
+		// Two pointer types are identical if they have identical base types.
+		if y, ok := y.(*Pointer); ok {
+			return check.identical0(x.base, y.base, cmpTags, p)
+		}
+
+	case *Tuple:
+		// Two tuples types are identical if they have the same number of elements
+		// and corresponding elements have identical types.
+		if y, ok := y.(*Tuple); ok {
+			if x.Len() == y.Len() {
+				if x != nil {
+					for i, v := range x.vars {
+						w := y.vars[i]
+						if !check.identical0(v.typ, w.typ, cmpTags, p) {
+							return false
+						}
+					}
+				}
+				return true
+			}
+		}
+
+	case *Signature:
+		// Two function types are identical if they have the same number of parameters
+		// and result values, corresponding parameter and result types are identical,
+		// and either both functions are variadic or neither is. Parameter and result
+		// names are not required to match.
+		// Generic functions must also have matching type parameter lists, but for the
+		// parameter names.
+		if y, ok := y.(*Signature); ok {
+			return x.variadic == y.variadic &&
+				check.identicalTParams(x.tparams, y.tparams, cmpTags, p) &&
+				check.identical0(x.params, y.params, cmpTags, p) &&
+				check.identical0(x.results, y.results, cmpTags, p)
+		}
+
+	case *Sum:
+		// Two sum types are identical if they contain the same types.
+		// (Sum types always consist of at least two types. Also, the
+		// the set (list) of types in a sum type consists of unique
+		// types - each type appears exactly once. Thus, two sum types
+		// must contain the same number of types to have chance of
+		// being equal.
+		if y, ok := y.(*Sum); ok && len(x.types) == len(y.types) {
+			// Every type in x.types must be in y.types.
+			// Quadratic algorithm, but probably good enough for now.
+			// TODO(gri) we need a fast quick type ID/hash for all types.
+		L:
+			for _, x := range x.types {
+				for _, y := range y.types {
+					if Identical(x, y) {
+						continue L // x is in y.types
+					}
+				}
+				return false // x is not in y.types
+			}
+			return true
+		}
+
+	case *Interface:
+		// Two interface types are identical if they have the same set of methods with
+		// the same names and identical function types. Lower-case method names from
+		// different packages are always different. The order of the methods is irrelevant.
+		if y, ok := y.(*Interface); ok {
+			// If identical0 is called (indirectly) via an external API entry point
+			// (such as Identical, IdenticalIgnoreTags, etc.), check is nil. But in
+			// that case, interfaces are expected to be complete and lazy completion
+			// here is not needed.
+			if check != nil {
+				check.completeInterface(nopos, x)
+				check.completeInterface(nopos, y)
+			}
+			a := x.allMethods
+			b := y.allMethods
+			if len(a) == len(b) {
+				// Interface types are the only types where cycles can occur
+				// that are not "terminated" via named types; and such cycles
+				// can only be created via method parameter types that are
+				// anonymous interfaces (directly or indirectly) embedding
+				// the current interface. Example:
+				//
+				//    type T interface {
+				//        m() interface{T}
+				//    }
+				//
+				// If two such (differently named) interfaces are compared,
+				// endless recursion occurs if the cycle is not detected.
+				//
+				// If x and y were compared before, they must be equal
+				// (if they were not, the recursion would have stopped);
+				// search the ifacePair stack for the same pair.
+				//
+				// This is a quadratic algorithm, but in practice these stacks
+				// are extremely short (bounded by the nesting depth of interface
+				// type declarations that recur via parameter types, an extremely
+				// rare occurrence). An alternative implementation might use a
+				// "visited" map, but that is probably less efficient overall.
+				q := &ifacePair{x, y, p}
+				for p != nil {
+					if p.identical(q) {
+						return true // same pair was compared before
+					}
+					p = p.prev
+				}
+				if debug {
+					assert(sort.IsSorted(byUniqueMethodName(a)))
+					assert(sort.IsSorted(byUniqueMethodName(b)))
+				}
+				for i, f := range a {
+					g := b[i]
+					if f.Id() != g.Id() || !check.identical0(f.typ, g.typ, cmpTags, q) {
+						return false
+					}
+				}
+				return true
+			}
+		}
+
+	case *Map:
+		// Two map types are identical if they have identical key and value types.
+		if y, ok := y.(*Map); ok {
+			return check.identical0(x.key, y.key, cmpTags, p) && check.identical0(x.elem, y.elem, cmpTags, p)
+		}
+
+	case *Chan:
+		// Two channel types are identical if they have identical value types
+		// and the same direction.
+		if y, ok := y.(*Chan); ok {
+			return x.dir == y.dir && check.identical0(x.elem, y.elem, cmpTags, p)
+		}
+
+	case *Named:
+		// Two named types are identical if their type names originate
+		// in the same type declaration.
+		if y, ok := y.(*Named); ok {
+			// TODO(gri) Why is x == y not sufficient? And if it is,
+			//           we can just return false here because x == y
+			//           is caught in the very beginning of this function.
+			return x.obj == y.obj
+		}
+
+	case *TypeParam:
+		// nothing to do (x and y being equal is caught in the very beginning of this function)
+
+	// case *instance:
+	//	unreachable since types are expanded
+
+	case *bottom, *top:
+		// Either both types are theBottom, or both are theTop in which
+		// case the initial x == y check will have caught them. Otherwise
+		// they are not identical.
+
+	case nil:
+		// avoid a crash in case of nil type
+
+	default:
+		unreachable()
+	}
+
+	return false
+}
+
+func (check *Checker) identicalTParams(x, y []*TypeName, cmpTags bool, p *ifacePair) bool {
+	if len(x) != len(y) {
+		return false
+	}
+	for i, x := range x {
+		y := y[i]
+		if !check.identical0(x.typ.(*TypeParam).bound, y.typ.(*TypeParam).bound, cmpTags, p) {
+			return false
+		}
+	}
+	return true
+}
+
+// Default returns the default "typed" type for an "untyped" type;
+// it returns the incoming type for all other types. The default type
+// for untyped nil is untyped nil.
+//
+func Default(typ Type) Type {
+	if t, ok := typ.(*Basic); ok {
+		switch t.kind {
+		case UntypedBool:
+			return Typ[Bool]
+		case UntypedInt:
+			return Typ[Int]
+		case UntypedRune:
+			return universeRune // use 'rune' name
+		case UntypedFloat:
+			return Typ[Float64]
+		case UntypedComplex:
+			return Typ[Complex128]
+		case UntypedString:
+			return Typ[String]
+		}
+	}
+	return typ
+}
diff --git a/src/cmd/compile/internal/types2/resolver.go b/src/cmd/compile/internal/types2/resolver.go
new file mode 100644
index 0000000000..b116888bf2
--- /dev/null
+++ b/src/cmd/compile/internal/types2/resolver.go
@@ -0,0 +1,714 @@
+// UNREVIEWED
+// Copyright 2013 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 types2
+
+import (
+	"cmd/compile/internal/syntax"
+	"fmt"
+	"go/constant"
+	"sort"
+	"strconv"
+	"strings"
+	"unicode"
+)
+
+// A declInfo describes a package-level const, type, var, or func declaration.
+type declInfo struct {
+	file  *Scope           // scope of file containing this declaration
+	lhs   []*Var           // lhs of n:1 variable declarations, or nil
+	vtyp  syntax.Expr      // type, or nil (for const and var declarations only)
+	init  syntax.Expr      // init/orig expression, or nil (for const and var declarations only)
+	tdecl *syntax.TypeDecl // type declaration, or nil
+	fdecl *syntax.FuncDecl // func declaration, or nil
+
+	// The deps field tracks initialization expression dependencies.
+	deps map[Object]bool // lazily initialized
+}
+
+// hasInitializer reports whether the declared object has an initialization
+// expression or function body.
+func (d *declInfo) hasInitializer() bool {
+	return d.init != nil || d.fdecl != nil && d.fdecl.Body != nil
+}
+
+// addDep adds obj to the set of objects d's init expression depends on.
+func (d *declInfo) addDep(obj Object) {
+	m := d.deps
+	if m == nil {
+		m = make(map[Object]bool)
+		d.deps = m
+	}
+	m[obj] = true
+}
+
+// arity checks that the lhs and rhs of a const or var decl
+// have a matching number of names and initialization values.
+// If inherited is set, the initialization values are from
+// another (constant) declaration.
+func (check *Checker) arity(pos syntax.Pos, names []*syntax.Name, inits []syntax.Expr, constDecl, inherited bool) {
+	l := len(names)
+	r := len(inits)
+
+	switch {
+	case l < r:
+		n := inits[l]
+		if inherited {
+			check.errorf(pos, "extra init expr at %s", n.Pos())
+		} else {
+			check.errorf(n, "extra init expr %s", n)
+		}
+	case l > r && (constDecl || r != 1): // if r == 1 it may be a multi-valued function and we can't say anything yet
+		n := names[r]
+		check.errorf(n, "missing init expr for %s", n.Value)
+	}
+}
+
+func validatedImportPath(path string) (string, error) {
+	s, err := strconv.Unquote(path)
+	if err != nil {
+		return "", err
+	}
+	if s == "" {
+		return "", fmt.Errorf("empty string")
+	}
+	const illegalChars = `!"#$%&'()*,:;<=>?[\]^{|}` + "`\uFFFD"
+	for _, r := range s {
+		if !unicode.IsGraphic(r) || unicode.IsSpace(r) || strings.ContainsRune(illegalChars, r) {
+			return s, fmt.Errorf("invalid character %#U", r)
+		}
+	}
+	return s, nil
+}
+
+// declarePkgObj declares obj in the package scope, records its ident -> obj mapping,
+// and updates check.objMap. The object must not be a function or method.
+func (check *Checker) declarePkgObj(ident *syntax.Name, obj Object, d *declInfo) {
+	assert(ident.Value == obj.Name())
+
+	// spec: "A package-scope or file-scope identifier with name init
+	// may only be declared to be a function with this (func()) signature."
+	if ident.Value == "init" {
+		check.errorf(ident, "cannot declare init - must be func")
+		return
+	}
+
+	// spec: "The main package must have package name main and declare
+	// a function main that takes no arguments and returns no value."
+	if ident.Value == "main" && check.pkg.name == "main" {
+		check.errorf(ident, "cannot declare main - must be func")
+		return
+	}
+
+	check.declare(check.pkg.scope, ident, obj, nopos)
+	check.objMap[obj] = d
+	obj.setOrder(uint32(len(check.objMap)))
+}
+
+// filename returns a filename suitable for debugging output.
+func (check *Checker) filename(fileNo int) string {
+	file := check.files[fileNo]
+	if pos := file.Pos(); pos.IsKnown() {
+		// return check.fset.File(pos).Name()
+		// TODO(gri) do we need the actual file name here?
+		return pos.RelFilename()
+	}
+	return fmt.Sprintf("file[%d]", fileNo)
+}
+
+func (check *Checker) importPackage(pos syntax.Pos, path, dir string) *Package {
+	// If we already have a package for the given (path, dir)
+	// pair, use it instead of doing a full import.
+	// Checker.impMap only caches packages that are marked Complete
+	// or fake (dummy packages for failed imports). Incomplete but
+	// non-fake packages do require an import to complete them.
+	key := importKey{path, dir}
+	imp := check.impMap[key]
+	if imp != nil {
+		return imp
+	}
+
+	// no package yet => import it
+	if path == "C" && (check.conf.FakeImportC || check.conf.go115UsesCgo) {
+		imp = NewPackage("C", "C")
+		imp.fake = true // package scope is not populated
+		imp.cgo = check.conf.go115UsesCgo
+	} else {
+		// ordinary import
+		var err error
+		if importer := check.conf.Importer; importer == nil {
+			err = fmt.Errorf("Config.Importer not installed")
+		} else if importerFrom, ok := importer.(ImporterFrom); ok {
+			imp, err = importerFrom.ImportFrom(path, dir, 0)
+			if imp == nil && err == nil {
+				err = fmt.Errorf("Config.Importer.ImportFrom(%s, %s, 0) returned nil but no error", path, dir)
+			}
+		} else {
+			imp, err = importer.Import(path)
+			if imp == nil && err == nil {
+				err = fmt.Errorf("Config.Importer.Import(%s) returned nil but no error", path)
+			}
+		}
+		// make sure we have a valid package name
+		// (errors here can only happen through manipulation of packages after creation)
+		if err == nil && imp != nil && (imp.name == "_" || imp.name == "") {
+			err = fmt.Errorf("invalid package name: %q", imp.name)
+			imp = nil // create fake package below
+		}
+		if err != nil {
+			check.errorf(pos, "could not import %s (%s)", path, err)
+			if imp == nil {
+				// create a new fake package
+				// come up with a sensible package name (heuristic)
+				name := path
+				if i := len(name); i > 0 && name[i-1] == '/' {
+					name = name[:i-1]
+				}
+				if i := strings.LastIndex(name, "/"); i >= 0 {
+					name = name[i+1:]
+				}
+				imp = NewPackage(path, name)
+			}
+			// continue to use the package as best as we can
+			imp.fake = true // avoid follow-up lookup failures
+		}
+	}
+
+	// package should be complete or marked fake, but be cautious
+	if imp.complete || imp.fake {
+		check.impMap[key] = imp
+		check.pkgCnt[imp.name]++
+		return imp
+	}
+
+	// something went wrong (importer may have returned incomplete package without error)
+	return nil
+}
+
+// collectObjects collects all file and package objects and inserts them
+// into their respective scopes. It also performs imports and associates
+// methods with receiver base type names.
+func (check *Checker) collectObjects() {
+	pkg := check.pkg
+
+	// pkgImports is the set of packages already imported by any package file seen
+	// so far. Used to avoid duplicate entries in pkg.imports. Allocate and populate
+	// it (pkg.imports may not be empty if we are checking test files incrementally).
+	// Note that pkgImports is keyed by package (and thus package path), not by an
+	// importKey value. Two different importKey values may map to the same package
+	// which is why we cannot use the check.impMap here.
+	var pkgImports = make(map[*Package]bool)
+	for _, imp := range pkg.imports {
+		pkgImports[imp] = true
+	}
+
+	type methodInfo struct {
+		obj  *Func        // method
+		ptr  bool         // true if pointer receiver
+		recv *syntax.Name // receiver type name
+	}
+	var methods []methodInfo // collected methods with valid receivers and non-blank _ names
+	var fileScopes []*Scope
+	for fileNo, file := range check.files {
+		// The package identifier denotes the current package,
+		// but there is no corresponding package object.
+		check.recordDef(file.PkgName, nil)
+
+		fileScope := NewScope(check.pkg.scope, startPos(file), endPos(file), check.filename(fileNo))
+		fileScopes = append(fileScopes, fileScope)
+		check.recordScope(file, fileScope)
+
+		// determine file directory, necessary to resolve imports
+		// FileName may be "" (typically for tests) in which case
+		// we get "." as the directory which is what we would want.
+		fileDir := dir(file.PkgName.Pos().RelFilename()) // TODO(gri) should this be filename?
+
+		first := -1                // index of first ConstDecl in the current group, or -1
+		var last *syntax.ConstDecl // last ConstDecl with init expressions, or nil
+		for index, decl := range file.DeclList {
+			if _, ok := decl.(*syntax.ConstDecl); !ok {
+				first = -1 // we're not in a constant declaration
+			}
+
+			switch s := decl.(type) {
+			case *syntax.ImportDecl:
+				// import package
+				path, err := validatedImportPath(s.Path.Value)
+				if err != nil {
+					check.errorf(s.Path, "invalid import path (%s)", err)
+					continue
+				}
+
+				imp := check.importPackage(s.Path.Pos(), path, fileDir)
+				if imp == nil {
+					continue
+				}
+
+				// add package to list of explicit imports
+				// (this functionality is provided as a convenience
+				// for clients; it is not needed for type-checking)
+				if !pkgImports[imp] {
+					pkgImports[imp] = true
+					pkg.imports = append(pkg.imports, imp)
+				}
+
+				// local name overrides imported package name
+				name := imp.name
+				if s.LocalPkgName != nil {
+					name = s.LocalPkgName.Value
+					if path == "C" {
+						// match cmd/compile (not prescribed by spec)
+						check.errorf(s.LocalPkgName, `cannot rename import "C"`)
+						continue
+					}
+					if name == "init" {
+						check.errorf(s.LocalPkgName, "cannot declare init - must be func")
+						continue
+					}
+				}
+
+				obj := NewPkgName(s.Pos(), pkg, name, imp)
+				if s.LocalPkgName != nil {
+					// in a dot-import, the dot represents the package
+					check.recordDef(s.LocalPkgName, obj)
+				} else {
+					check.recordImplicit(s, obj)
+				}
+
+				if path == "C" {
+					// match cmd/compile (not prescribed by spec)
+					obj.used = true
+				}
+
+				// add import to file scope
+				if name == "." {
+					// merge imported scope with file scope
+					for _, obj := range imp.scope.elems {
+						// A package scope may contain non-exported objects,
+						// do not import them!
+						if obj.Exported() {
+							// declare dot-imported object
+							// (Do not use check.declare because it modifies the object
+							// via Object.setScopePos, which leads to a race condition;
+							// the object may be imported into more than one file scope
+							// concurrently. See issue #32154.)
+							if alt := fileScope.Insert(obj); alt != nil {
+								check.errorf(s.LocalPkgName, "%s redeclared in this block", obj.Name())
+								check.reportAltDecl(alt)
+							}
+						}
+					}
+					// add position to set of dot-import positions for this file
+					// (this is only needed for "imported but not used" errors)
+					check.addUnusedDotImport(fileScope, imp, s.Pos())
+				} else {
+					// declare imported package object in file scope
+					// (no need to provide s.LocalPkgName since we called check.recordDef earlier)
+					check.declare(fileScope, nil, obj, nopos)
+				}
+
+			case *syntax.ConstDecl:
+				// iota is the index of the current constDecl within the group
+				if first < 0 || file.DeclList[index-1].(*syntax.ConstDecl).Group != s.Group {
+					first = index
+					last = nil
+				}
+				iota := constant.MakeInt64(int64(index - first))
+
+				// determine which initialization expressions to use
+				inherited := true
+				switch {
+				case s.Type != nil || s.Values != nil:
+					last = s
+					inherited = false
+				case last == nil:
+					last = new(syntax.ConstDecl) // make sure last exists
+					inherited = false
+				}
+
+				// declare all constants
+				values := unpackExpr(last.Values)
+				for i, name := range s.NameList {
+					obj := NewConst(name.Pos(), pkg, name.Value, nil, iota)
+
+					var init syntax.Expr
+					if i < len(values) {
+						init = values[i]
+					}
+
+					d := &declInfo{file: fileScope, vtyp: last.Type, init: init}
+					check.declarePkgObj(name, obj, d)
+				}
+
+				// Constants must always have init values.
+				check.arity(s.Pos(), s.NameList, values, true, inherited)
+
+			case *syntax.VarDecl:
+				lhs := make([]*Var, len(s.NameList))
+				// If there's exactly one rhs initializer, use
+				// the same declInfo d1 for all lhs variables
+				// so that each lhs variable depends on the same
+				// rhs initializer (n:1 var declaration).
+				var d1 *declInfo
+				if _, ok := s.Values.(*syntax.ListExpr); !ok {
+					// The lhs elements are only set up after the for loop below,
+					// but that's ok because declarePkgObj only collects the declInfo
+					// for a later phase.
+					d1 = &declInfo{file: fileScope, lhs: lhs, vtyp: s.Type, init: s.Values}
+				}
+
+				// declare all variables
+				values := unpackExpr(s.Values)
+				for i, name := range s.NameList {
+					obj := NewVar(name.Pos(), pkg, name.Value, nil)
+					lhs[i] = obj
+
+					d := d1
+					if d == nil {
+						// individual assignments
+						var init syntax.Expr
+						if i < len(values) {
+							init = values[i]
+						}
+						d = &declInfo{file: fileScope, vtyp: s.Type, init: init}
+					}
+
+					check.declarePkgObj(name, obj, d)
+				}
+
+				// If we have no type, we must have values.
+				if s.Type == nil || values != nil {
+					check.arity(s.Pos(), s.NameList, values, false, false)
+				}
+
+			case *syntax.TypeDecl:
+				obj := NewTypeName(s.Name.Pos(), pkg, s.Name.Value, nil)
+				check.declarePkgObj(s.Name, obj, &declInfo{file: fileScope, tdecl: s})
+
+			case *syntax.FuncDecl:
+				d := s // TODO(gri) get rid of this
+				name := d.Name.Value
+				obj := NewFunc(d.Name.Pos(), pkg, name, nil)
+				if d.Recv == nil {
+					// regular function
+					if name == "init" {
+						if d.TParamList != nil {
+							//check.softErrorf(d.TParamList.Pos(), "func init must have no type parameters")
+							check.softErrorf(d.Name, "func init must have no type parameters")
+						}
+						if t := d.Type; len(t.ParamList) != 0 || len(t.ResultList) != 0 {
+							check.softErrorf(d, "func init must have no arguments and no return values")
+						}
+						// don't declare init functions in the package scope - they are invisible
+						obj.parent = pkg.scope
+						check.recordDef(d.Name, obj)
+						// init functions must have a body
+						if d.Body == nil {
+							// TODO(gri) make this error message consistent with the others above
+							check.softErrorf(obj.pos, "missing function body")
+						}
+					} else {
+						check.declare(pkg.scope, d.Name, obj, nopos)
+					}
+				} else {
+					// method
+					// d.Recv != nil
+					if !methodTypeParamsOk && len(d.TParamList) != 0 {
+						//check.invalidASTf(d.TParamList.Pos(), "method must have no type parameters")
+						check.invalidASTf(d, "method must have no type parameters")
+					}
+					ptr, recv, _ := check.unpackRecv(d.Recv.Type, false)
+					// (Methods with invalid receiver cannot be associated to a type, and
+					// methods with blank _ names are never found; no need to collect any
+					// of them. They will still be type-checked with all the other functions.)
+					if recv != nil && name != "_" {
+						methods = append(methods, methodInfo{obj, ptr, recv})
+					}
+					check.recordDef(d.Name, obj)
+				}
+				info := &declInfo{file: fileScope, fdecl: d}
+				// Methods are not package-level objects but we still track them in the
+				// object map so that we can handle them like regular functions (if the
+				// receiver is invalid); also we need their fdecl info when associating
+				// them with their receiver base type, below.
+				check.objMap[obj] = info
+				obj.setOrder(uint32(len(check.objMap)))
+
+			default:
+				check.invalidASTf(s, "unknown syntax.Decl node %T", s)
+			}
+		}
+	}
+
+	// verify that objects in package and file scopes have different names
+	for _, scope := range fileScopes {
+		for _, obj := range scope.elems {
+			if alt := pkg.scope.Lookup(obj.Name()); alt != nil {
+				if pkg, ok := obj.(*PkgName); ok {
+					check.errorf(alt, "%s already declared through import of %s", alt.Name(), pkg.Imported())
+					check.reportAltDecl(pkg)
+				} else {
+					check.errorf(alt, "%s already declared through dot-import of %s", alt.Name(), obj.Pkg())
+					// TODO(gri) dot-imported objects don't have a position; reportAltDecl won't print anything
+					check.reportAltDecl(obj)
+				}
+			}
+		}
+	}
+
+	// Now that we have all package scope objects and all methods,
+	// associate methods with receiver base type name where possible.
+	// Ignore methods that have an invalid receiver. They will be
+	// type-checked later, with regular functions.
+	if methods != nil {
+		check.methods = make(map[*TypeName][]*Func)
+		for i := range methods {
+			m := &methods[i]
+			// Determine the receiver base type and associate m with it.
+			ptr, base := check.resolveBaseTypeName(m.ptr, m.recv)
+			if base != nil {
+				m.obj.hasPtrRecv = ptr
+				check.methods[base] = append(check.methods[base], m.obj)
+			}
+		}
+	}
+}
+
+// unpackRecv unpacks a receiver type and returns its components: ptr indicates whether
+// rtyp is a pointer receiver, rname is the receiver type name, and tparams are its
+// type parameters, if any. The type parameters are only unpacked if unpackParams is
+// set. If rname is nil, the receiver is unusable (i.e., the source has a bug which we
+// cannot easily work around).
+func (check *Checker) unpackRecv(rtyp syntax.Expr, unpackParams bool) (ptr bool, rname *syntax.Name, tparams []*syntax.Name) {
+L: // unpack receiver type
+	// This accepts invalid receivers such as ***T and does not
+	// work for other invalid receivers, but we don't care. The
+	// validity of receiver expressions is checked elsewhere.
+	for {
+		switch t := rtyp.(type) {
+		case *syntax.ParenExpr:
+			rtyp = t.X
+		// case *ast.StarExpr:
+		// 	rtyp = t.X
+		case *syntax.Operation:
+			if t.Op != syntax.Mul || t.Y != nil {
+				break
+			}
+			rtyp = t.X
+		default:
+			break L
+		}
+	}
+
+	// unpack type parameters, if any
+	if ptyp, _ := rtyp.(*syntax.IndexExpr); ptyp != nil {
+		rtyp = ptyp.X
+		if unpackParams {
+			for _, arg := range unpackExpr(ptyp.Index) {
+				var par *syntax.Name
+				switch arg := arg.(type) {
+				case *syntax.Name:
+					par = arg
+				case *syntax.BadExpr:
+					// ignore - error already reported by parser
+				case nil:
+					check.invalidASTf(ptyp, "parameterized receiver contains nil parameters")
+				default:
+					check.errorf(arg, "receiver type parameter %s must be an identifier", arg)
+				}
+				if par == nil {
+					par = newName(arg.Pos(), "_")
+				}
+				tparams = append(tparams, par)
+			}
+
+		}
+	}
+
+	// unpack receiver name
+	if name, _ := rtyp.(*syntax.Name); name != nil {
+		rname = name
+	}
+
+	return
+}
+
+// resolveBaseTypeName returns the non-alias base type name for typ, and whether
+// there was a pointer indirection to get to it. The base type name must be declared
+// in package scope, and there can be at most one pointer indirection. If no such type
+// name exists, the returned base is nil.
+func (check *Checker) resolveBaseTypeName(seenPtr bool, typ syntax.Expr) (ptr bool, base *TypeName) {
+	// Algorithm: Starting from a type expression, which may be a name,
+	// we follow that type through alias declarations until we reach a
+	// non-alias type name. If we encounter anything but pointer types or
+	// parentheses we're done. If we encounter more than one pointer type
+	// we're done.
+	ptr = seenPtr
+	var seen map[*TypeName]bool
+	for {
+		typ = unparen(typ)
+
+		// check if we have a pointer type
+		// if pexpr, _ := typ.(*ast.StarExpr); pexpr != nil {
+		if pexpr, _ := typ.(*syntax.Operation); pexpr != nil && pexpr.Op == syntax.Mul && pexpr.Y == nil {
+			// if we've already seen a pointer, we're done
+			if ptr {
+				return false, nil
+			}
+			ptr = true
+			typ = unparen(pexpr.X) // continue with pointer base type
+		}
+
+		// typ must be a name
+		name, _ := typ.(*syntax.Name)
+		if name == nil {
+			return false, nil
+		}
+
+		// name must denote an object found in the current package scope
+		// (note that dot-imported objects are not in the package scope!)
+		obj := check.pkg.scope.Lookup(name.Value)
+		if obj == nil {
+			return false, nil
+		}
+
+		// the object must be a type name...
+		tname, _ := obj.(*TypeName)
+		if tname == nil {
+			return false, nil
+		}
+
+		// ... which we have not seen before
+		if seen[tname] {
+			return false, nil
+		}
+
+		// we're done if tdecl defined tname as a new type
+		// (rather than an alias)
+		tdecl := check.objMap[tname].tdecl // must exist for objects in package scope
+		if !tdecl.Alias {
+			return ptr, tname
+		}
+
+		// otherwise, continue resolving
+		typ = tdecl.Type
+		if seen == nil {
+			seen = make(map[*TypeName]bool)
+		}
+		seen[tname] = true
+	}
+}
+
+// packageObjects typechecks all package objects, but not function bodies.
+func (check *Checker) packageObjects() {
+	// process package objects in source order for reproducible results
+	objList := make([]Object, len(check.objMap))
+	i := 0
+	for obj := range check.objMap {
+		objList[i] = obj
+		i++
+	}
+	sort.Sort(inSourceOrder(objList))
+
+	// add new methods to already type-checked types (from a prior Checker.Files call)
+	for _, obj := range objList {
+		if obj, _ := obj.(*TypeName); obj != nil && obj.typ != nil {
+			check.collectMethods(obj)
+		}
+	}
+
+	// We process non-alias declarations first, in order to avoid situations where
+	// the type of an alias declaration is needed before it is available. In general
+	// this is still not enough, as it is possible to create sufficiently convoluted
+	// recursive type definitions that will cause a type alias to be needed before it
+	// is available (see issue #25838 for examples).
+	// As an aside, the cmd/compiler suffers from the same problem (#25838).
+	var aliasList []*TypeName
+	// phase 1
+	for _, obj := range objList {
+		// If we have a type alias, collect it for the 2nd phase.
+		if tname, _ := obj.(*TypeName); tname != nil && check.objMap[tname].tdecl.Alias {
+			aliasList = append(aliasList, tname)
+			continue
+		}
+
+		check.objDecl(obj, nil)
+	}
+	// phase 2
+	for _, obj := range aliasList {
+		check.objDecl(obj, nil)
+	}
+
+	// At this point we may have a non-empty check.methods map; this means that not all
+	// entries were deleted at the end of typeDecl because the respective receiver base
+	// types were not found. In that case, an error was reported when declaring those
+	// methods. We can now safely discard this map.
+	check.methods = nil
+}
+
+// inSourceOrder implements the sort.Sort interface.
+type inSourceOrder []Object
+
+func (a inSourceOrder) Len() int           { return len(a) }
+func (a inSourceOrder) Less(i, j int) bool { return a[i].order() < a[j].order() }
+func (a inSourceOrder) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+
+// unusedImports checks for unused imports.
+func (check *Checker) unusedImports() {
+	// if function bodies are not checked, packages' uses are likely missing - don't check
+	if check.conf.IgnoreFuncBodies {
+		return
+	}
+
+	// spec: "It is illegal (...) to directly import a package without referring to
+	// any of its exported identifiers. To import a package solely for its side-effects
+	// (initialization), use the blank identifier as explicit package name."
+
+	// check use of regular imported packages
+	for _, scope := range check.pkg.scope.children /* file scopes */ {
+		for _, obj := range scope.elems {
+			if obj, ok := obj.(*PkgName); ok {
+				// Unused "blank imports" are automatically ignored
+				// since _ identifiers are not entered into scopes.
+				if !obj.used {
+					path := obj.imported.path
+					base := pkgName(path)
+					if obj.name == base {
+						check.softErrorf(obj.pos, "%q imported but not used", path)
+					} else {
+						check.softErrorf(obj.pos, "%q imported but not used as %s", path, obj.name)
+					}
+				}
+			}
+		}
+	}
+
+	// check use of dot-imported packages
+	for _, unusedDotImports := range check.unusedDotImports {
+		for pkg, pos := range unusedDotImports {
+			check.softErrorf(pos, "%q imported but not used", pkg.path)
+		}
+	}
+}
+
+// pkgName returns the package name (last element) of an import path.
+func pkgName(path string) string {
+	if i := strings.LastIndex(path, "/"); i >= 0 {
+		path = path[i+1:]
+	}
+	return path
+}
+
+// dir makes a good-faith attempt to return the directory
+// portion of path. If path is empty, the result is ".".
+// (Per the go/build package dependency tests, we cannot import
+// path/filepath and simply use filepath.Dir.)
+func dir(path string) string {
+	if i := strings.LastIndexAny(path, `/\`); i > 0 {
+		return path[:i]
+	}
+	// i <= 0
+	return "."
+}
diff --git a/src/cmd/compile/internal/types2/resolver_test.go b/src/cmd/compile/internal/types2/resolver_test.go
new file mode 100644
index 0000000000..cdfdba6b43
--- /dev/null
+++ b/src/cmd/compile/internal/types2/resolver_test.go
@@ -0,0 +1,223 @@
+// UNREVIEWED
+// Copyright 2011 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 types2_test
+
+import (
+	"cmd/compile/internal/syntax"
+	"fmt"
+	"internal/testenv"
+	"sort"
+	"testing"
+
+	. "cmd/compile/internal/types2"
+)
+
+type resolveTestImporter struct {
+	importer ImporterFrom
+	imported map[string]bool
+}
+
+func (imp *resolveTestImporter) Import(string) (*Package, error) {
+	panic("should not be called")
+}
+
+func (imp *resolveTestImporter) ImportFrom(path, srcDir string, mode ImportMode) (*Package, error) {
+	if mode != 0 {
+		panic("mode must be 0")
+	}
+	if imp.importer == nil {
+		imp.importer = defaultImporter().(ImporterFrom)
+		imp.imported = make(map[string]bool)
+	}
+	pkg, err := imp.importer.ImportFrom(path, srcDir, mode)
+	if err != nil {
+		return nil, err
+	}
+	imp.imported[path] = true
+	return pkg, nil
+}
+
+func TestResolveIdents(t *testing.T) {
+	testenv.MustHaveGoBuild(t)
+
+	sources := []string{
+		`
+		package p
+		import "fmt"
+		import "math"
+		const pi = math.Pi
+		func sin(x float64) float64 {
+			return math.Sin(x)
+		}
+		var Println = fmt.Println
+		`,
+		`
+		package p
+		import "fmt"
+		type errorStringer struct { fmt.Stringer; error }
+		func f() string {
+			_ = "foo"
+			return fmt.Sprintf("%d", g())
+		}
+		func g() (x int) { return }
+		`,
+		`
+		package p
+		import . "go/parser"
+		import "sync"
+		func h() Mode { return ImportsOnly }
+		var _, x int = 1, 2
+		func init() {}
+		type T struct{ *sync.Mutex; a, b, c int}
+		type I interface{ m() }
+		var _ = T{a: 1, b: 2, c: 3}
+		func (_ T) m() {}
+		func (T) _() {}
+		var i I
+		var _ = i.m
+		func _(s []int) { for i, x := range s { _, _ = i, x } }
+		func _(x interface{}) {
+			switch x := x.(type) {
+			case int:
+				_ = x
+			}
+			switch {} // implicit 'true' tag
+		}
+		`,
+		`
+		package p
+		type S struct{}
+		func (T) _() {}
+		func (T) _() {}
+		`,
+		`
+		package p
+		func _() {
+		L0:
+		L1:
+			goto L0
+			for {
+				goto L1
+			}
+			if true {
+				goto L2
+			}
+		L2:
+		}
+		`,
+	}
+
+	pkgnames := []string{
+		"fmt",
+		"math",
+	}
+
+	// parse package files
+	var files []*syntax.File
+	for i, src := range sources {
+		f, err := parseSrc(fmt.Sprintf("sources[%d]", i), src)
+		if err != nil {
+			t.Fatal(err)
+		}
+		files = append(files, f)
+	}
+
+	// resolve and type-check package AST
+	importer := new(resolveTestImporter)
+	conf := Config{Importer: importer}
+	uses := make(map[*syntax.Name]Object)
+	defs := make(map[*syntax.Name]Object)
+	_, err := conf.Check("testResolveIdents", files, &Info{Defs: defs, Uses: uses})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// check that all packages were imported
+	for _, name := range pkgnames {
+		if !importer.imported[name] {
+			t.Errorf("package %s not imported", name)
+		}
+	}
+
+	// check that qualified identifiers are resolved
+	for _, f := range files {
+		Walk(f, func(n syntax.Node) bool {
+			if s, ok := n.(*syntax.SelectorExpr); ok {
+				if x, ok := s.X.(*syntax.Name); ok {
+					obj := uses[x]
+					if obj == nil {
+						t.Errorf("%s: unresolved qualified identifier %s", x.Pos(), x.Value)
+						return true
+					}
+					if _, ok := obj.(*PkgName); ok && uses[s.Sel] == nil {
+						t.Errorf("%s: unresolved selector %s", s.Sel.Pos(), s.Sel.Value)
+						return true
+					}
+					return true
+				}
+				return true
+			}
+			return false
+		})
+	}
+
+	for id, obj := range uses {
+		if obj == nil {
+			t.Errorf("%s: Uses[%s] == nil", id.Pos(), id.Value)
+		}
+	}
+
+	// Check that each identifier in the source is found in uses or defs or both.
+	// We need the foundUses/Defs maps (rather then just deleting the found objects
+	// from the uses and defs maps) because Walk traverses shared nodes multiple
+	// times (e.g. types in field lists such as "a, b, c int").
+	foundUses := make(map[*syntax.Name]bool)
+	foundDefs := make(map[*syntax.Name]bool)
+	var both []string
+	for _, f := range files {
+		Walk(f, func(n syntax.Node) bool {
+			if x, ok := n.(*syntax.Name); ok {
+				var objects int
+				if _, found := uses[x]; found {
+					objects |= 1
+					foundUses[x] = true
+				}
+				if _, found := defs[x]; found {
+					objects |= 2
+					foundDefs[x] = true
+				}
+				switch objects {
+				case 0:
+					t.Errorf("%s: unresolved identifier %s", x.Pos(), x.Value)
+				case 3:
+					both = append(both, x.Value)
+				}
+				return true
+			}
+			return false
+		})
+	}
+
+	// check the expected set of idents that are simultaneously uses and defs
+	sort.Strings(both)
+	if got, want := fmt.Sprint(both), "[Mutex Stringer error]"; got != want {
+		t.Errorf("simultaneous uses/defs = %s, want %s", got, want)
+	}
+
+	// any left-over identifiers didn't exist in the source
+	for x := range uses {
+		if !foundUses[x] {
+			t.Errorf("%s: identifier %s not present in source", x.Pos(), x.Value)
+		}
+	}
+	for x := range defs {
+		if !foundDefs[x] {
+			t.Errorf("%s: identifier %s not present in source", x.Pos(), x.Value)
+		}
+	}
+
+	// TODO(gri) add tests to check ImplicitObj callbacks
+}
diff --git a/src/cmd/compile/internal/types2/return.go b/src/cmd/compile/internal/types2/return.go
new file mode 100644
index 0000000000..88234b1723
--- /dev/null
+++ b/src/cmd/compile/internal/types2/return.go
@@ -0,0 +1,180 @@
+// UNREVIEWED
+// Copyright 2013 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.
+
+// This file implements isTerminating.
+
+package types2
+
+import (
+	"cmd/compile/internal/syntax"
+)
+
+// isTerminating reports if s is a terminating statement.
+// If s is labeled, label is the label name; otherwise s
+// is "".
+func (check *Checker) isTerminating(s syntax.Stmt, label string) bool {
+	switch s := s.(type) {
+	default:
+		unreachable()
+
+	case *syntax.DeclStmt, *syntax.EmptyStmt, *syntax.SendStmt,
+		*syntax.AssignStmt, *syntax.CallStmt:
+		// no chance
+
+	case *syntax.LabeledStmt:
+		return check.isTerminating(s.Stmt, s.Label.Value)
+
+	case *syntax.ExprStmt:
+		// calling the predeclared (possibly parenthesized) panic() function is terminating
+		if call, ok := unparen(s.X).(*syntax.CallExpr); ok && check.isPanic[call] {
+			return true
+		}
+
+	case *syntax.ReturnStmt:
+		return true
+
+	case *syntax.BranchStmt:
+		if s.Tok == syntax.Goto || s.Tok == syntax.Fallthrough {
+			return true
+		}
+
+	case *syntax.BlockStmt:
+		return check.isTerminatingList(s.List, "")
+
+	case *syntax.IfStmt:
+		if s.Else != nil &&
+			check.isTerminating(s.Then, "") &&
+			check.isTerminating(s.Else, "") {
+			return true
+		}
+
+	case *syntax.SwitchStmt:
+		return check.isTerminatingSwitch(s.Body, label)
+
+	case *syntax.SelectStmt:
+		for _, cc := range s.Body {
+			if !check.isTerminatingList(cc.Body, "") || hasBreakList(cc.Body, label, true) {
+				return false
+			}
+
+		}
+		return true
+
+	case *syntax.ForStmt:
+		if s.Cond == nil && !hasBreak(s.Body, label, true) {
+			return true
+		}
+	}
+
+	return false
+}
+
+func (check *Checker) isTerminatingList(list []syntax.Stmt, label string) bool {
+	// trailing empty statements are permitted - skip them
+	for i := len(list) - 1; i >= 0; i-- {
+		if _, ok := list[i].(*syntax.EmptyStmt); !ok {
+			return check.isTerminating(list[i], label)
+		}
+	}
+	return false // all statements are empty
+}
+
+func (check *Checker) isTerminatingSwitch(body []*syntax.CaseClause, label string) bool {
+	hasDefault := false
+	for _, cc := range body {
+		if cc.Cases == nil {
+			hasDefault = true
+		}
+		if !check.isTerminatingList(cc.Body, "") || hasBreakList(cc.Body, label, true) {
+			return false
+		}
+	}
+	return hasDefault
+}
+
+// TODO(gri) For nested breakable statements, the current implementation of hasBreak
+//	     will traverse the same subtree repeatedly, once for each label. Replace
+//           with a single-pass label/break matching phase.
+
+// hasBreak reports if s is or contains a break statement
+// referring to the label-ed statement or implicit-ly the
+// closest outer breakable statement.
+func hasBreak(s syntax.Stmt, label string, implicit bool) bool {
+	switch s := s.(type) {
+	default:
+		unreachable()
+
+	case *syntax.DeclStmt, *syntax.EmptyStmt, *syntax.ExprStmt,
+		*syntax.SendStmt, *syntax.AssignStmt, *syntax.CallStmt,
+		*syntax.ReturnStmt:
+		// no chance
+
+	case *syntax.LabeledStmt:
+		return hasBreak(s.Stmt, label, implicit)
+
+	case *syntax.BranchStmt:
+		if s.Tok == syntax.Break {
+			if s.Label == nil {
+				return implicit
+			}
+			if s.Label.Value == label {
+				return true
+			}
+		}
+
+	case *syntax.BlockStmt:
+		return hasBreakList(s.List, label, implicit)
+
+	case *syntax.IfStmt:
+		if hasBreak(s.Then, label, implicit) ||
+			s.Else != nil && hasBreak(s.Else, label, implicit) {
+			return true
+		}
+
+	case *syntax.SwitchStmt:
+		if label != "" && hasBreakCaseList(s.Body, label, false) {
+			return true
+		}
+
+	case *syntax.SelectStmt:
+		if label != "" && hasBreakCommList(s.Body, label, false) {
+			return true
+		}
+
+	case *syntax.ForStmt:
+		if label != "" && hasBreak(s.Body, label, false) {
+			return true
+		}
+	}
+
+	return false
+}
+
+func hasBreakList(list []syntax.Stmt, label string, implicit bool) bool {
+	for _, s := range list {
+		if hasBreak(s, label, implicit) {
+			return true
+		}
+	}
+	return false
+}
+
+func hasBreakCaseList(list []*syntax.CaseClause, label string, implicit bool) bool {
+	for _, s := range list {
+		if hasBreakList(s.Body, label, implicit) {
+			return true
+		}
+	}
+	return false
+}
+
+func hasBreakCommList(list []*syntax.CommClause, label string, implicit bool) bool {
+	for _, s := range list {
+		if hasBreakList(s.Body, label, implicit) {
+			return true
+		}
+	}
+	return false
+}
diff --git a/src/cmd/compile/internal/types2/sanitize.go b/src/cmd/compile/internal/types2/sanitize.go
new file mode 100644
index 0000000000..bac569416b
--- /dev/null
+++ b/src/cmd/compile/internal/types2/sanitize.go
@@ -0,0 +1,149 @@
+// UNREVIEWED
+// Copyright 2020 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 types2
+
+func sanitizeInfo(info *Info) {
+	var s sanitizer = make(map[Type]Type)
+
+	// Note: Some map entries are not references.
+	// If modified, they must be assigned back.
+
+	for e, tv := range info.Types {
+		tv.Type = s.typ(tv.Type)
+		info.Types[e] = tv
+	}
+
+	for e, inf := range info.Inferred {
+		for i, targ := range inf.Targs {
+			inf.Targs[i] = s.typ(targ)
+		}
+		inf.Sig = s.typ(inf.Sig).(*Signature)
+		info.Inferred[e] = inf
+	}
+
+	for _, obj := range info.Defs {
+		if obj != nil {
+			obj.setType(s.typ(obj.Type()))
+		}
+	}
+
+	for _, obj := range info.Uses {
+		if obj != nil {
+			obj.setType(s.typ(obj.Type()))
+		}
+	}
+
+	// TODO(gri) sanitize as needed
+	// - info.Implicits
+	// - info.Selections
+	// - info.Scopes
+	// - info.InitOrder
+}
+
+type sanitizer map[Type]Type
+
+func (s sanitizer) typ(typ Type) Type {
+	if t, found := s[typ]; found {
+		return t
+	}
+	s[typ] = typ
+
+	switch t := typ.(type) {
+	case nil, *Basic, *bottom, *top:
+		// nothing to do
+
+	case *Array:
+		t.elem = s.typ(t.elem)
+
+	case *Slice:
+		t.elem = s.typ(t.elem)
+
+	case *Struct:
+		s.varList(t.fields)
+
+	case *Pointer:
+		t.base = s.typ(t.base)
+
+	case *Tuple:
+		s.tuple(t)
+
+	case *Signature:
+		s.var_(t.recv)
+		s.tuple(t.params)
+		s.tuple(t.results)
+
+	case *Sum:
+		s.typeList(t.types)
+
+	case *Interface:
+		s.funcList(t.methods)
+		s.typ(t.types)
+		s.typeList(t.embeddeds)
+		s.funcList(t.allMethods)
+		s.typ(t.allTypes)
+
+	case *Map:
+		t.key = s.typ(t.key)
+		t.elem = s.typ(t.elem)
+
+	case *Chan:
+		t.elem = s.typ(t.elem)
+
+	case *Named:
+		t.orig = s.typ(t.orig)
+		t.underlying = s.typ(t.underlying)
+		s.typeList(t.targs)
+		s.funcList(t.methods)
+
+	case *TypeParam:
+		t.bound = s.typ(t.bound)
+
+	case *instance:
+		typ = t.expand()
+		s[t] = typ
+
+	default:
+		unimplemented()
+	}
+
+	return typ
+}
+
+func (s sanitizer) var_(v *Var) {
+	if v != nil {
+		v.typ = s.typ(v.typ)
+	}
+}
+
+func (s sanitizer) varList(list []*Var) {
+	for _, v := range list {
+		s.var_(v)
+	}
+}
+
+func (s sanitizer) tuple(t *Tuple) {
+	if t != nil {
+		s.varList(t.vars)
+	}
+}
+
+func (s sanitizer) func_(f *Func) {
+	if f != nil {
+		f.typ = s.typ(f.typ)
+	}
+}
+
+func (s sanitizer) funcList(list []*Func) {
+	for _, f := range list {
+		s.func_(f)
+	}
+}
+
+func (s sanitizer) typeList(list []Type) {
+	for i, t := range list {
+		list[i] = s.typ(t)
+	}
+}
diff --git a/src/cmd/compile/internal/types2/scope.go b/src/cmd/compile/internal/types2/scope.go
new file mode 100644
index 0000000000..c8243ac36c
--- /dev/null
+++ b/src/cmd/compile/internal/types2/scope.go
@@ -0,0 +1,217 @@
+// UNREVIEWED
+// Copyright 2013 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.
+
+// This file implements Scopes.
+
+package types2
+
+import (
+	"bytes"
+	"cmd/compile/internal/syntax"
+	"fmt"
+	"io"
+	"sort"
+	"strings"
+)
+
+// A Scope maintains a set of objects and links to its containing
+// (parent) and contained (children) scopes. Objects may be inserted
+// and looked up by name. The zero value for Scope is a ready-to-use
+// empty scope.
+type Scope struct {
+	parent   *Scope
+	children []*Scope
+	elems    map[string]Object // lazily allocated
+	pos, end syntax.Pos        // scope extent; may be invalid
+	comment  string            // for debugging only
+	isFunc   bool              // set if this is a function scope (internal use only)
+}
+
+// NewScope returns a new, empty scope contained in the given parent
+// scope, if any. The comment is for debugging only.
+func NewScope(parent *Scope, pos, end syntax.Pos, comment string) *Scope {
+	s := &Scope{parent, nil, nil, pos, end, comment, false}
+	// don't add children to Universe scope!
+	if parent != nil && parent != Universe {
+		parent.children = append(parent.children, s)
+	}
+	return s
+}
+
+// Parent returns the scope's containing (parent) scope.
+func (s *Scope) Parent() *Scope { return s.parent }
+
+// Len returns the number of scope elements.
+func (s *Scope) Len() int { return len(s.elems) }
+
+// Names returns the scope's element names in sorted order.
+func (s *Scope) Names() []string {
+	names := make([]string, len(s.elems))
+	i := 0
+	for name := range s.elems {
+		names[i] = name
+		i++
+	}
+	sort.Strings(names)
+	return names
+}
+
+// NumChildren returns the number of scopes nested in s.
+func (s *Scope) NumChildren() int { return len(s.children) }
+
+// Child returns the i'th child scope for 0 <= i < NumChildren().
+func (s *Scope) Child(i int) *Scope { return s.children[i] }
+
+// Lookup returns the object in scope s with the given name if such an
+// object exists; otherwise the result is nil.
+func (s *Scope) Lookup(name string) Object {
+	return s.elems[name]
+}
+
+// LookupParent follows the parent chain of scopes starting with s until
+// it finds a scope where Lookup(name) returns a non-nil object, and then
+// returns that scope and object. If a valid position pos is provided,
+// only objects that were declared at or before pos are considered.
+// If no such scope and object exists, the result is (nil, nil).
+//
+// Note that obj.Parent() may be different from the returned scope if the
+// object was inserted into the scope and already had a parent at that
+// time (see Insert). This can only happen for dot-imported objects
+// whose scope is the scope of the package that exported them.
+func (s *Scope) LookupParent(name string, pos syntax.Pos) (*Scope, Object) {
+	for ; s != nil; s = s.parent {
+		if obj := s.elems[name]; obj != nil && (!pos.IsKnown() || cmpPos(obj.scopePos(), pos) <= 0) {
+			return s, obj
+		}
+	}
+	return nil, nil
+}
+
+// Insert attempts to insert an object obj into scope s.
+// If s already contains an alternative object alt with
+// the same name, Insert leaves s unchanged and returns alt.
+// Otherwise it inserts obj, sets the object's parent scope
+// if not already set, and returns nil.
+func (s *Scope) Insert(obj Object) Object {
+	name := obj.Name()
+	if alt := s.elems[name]; alt != nil {
+		return alt
+	}
+	if s.elems == nil {
+		s.elems = make(map[string]Object)
+	}
+	s.elems[name] = obj
+	if obj.Parent() == nil {
+		obj.setParent(s)
+	}
+	return nil
+}
+
+// Squash merges s with its parent scope p by adding all
+// objects of s to p, adding all children of s to the
+// children of p, and removing s from p's children.
+// The function f is called for each object obj in s which
+// has an object alt in p. s should be discarded after
+// having been squashed.
+func (s *Scope) Squash(err func(obj, alt Object)) {
+	p := s.parent
+	assert(p != nil)
+	for _, obj := range s.elems {
+		obj.setParent(nil)
+		if alt := p.Insert(obj); alt != nil {
+			err(obj, alt)
+		}
+	}
+
+	j := -1 // index of s in p.children
+	for i, ch := range p.children {
+		if ch == s {
+			j = i
+			break
+		}
+	}
+	assert(j >= 0)
+	k := len(p.children) - 1
+	p.children[j] = p.children[k]
+	p.children = p.children[:k]
+
+	p.children = append(p.children, s.children...)
+
+	s.children = nil
+	s.elems = nil
+}
+
+// Pos and End describe the scope's source code extent [pos, end).
+// The results are guaranteed to be valid only if the type-checked
+// AST has complete position information. The extent is undefined
+// for Universe and package scopes.
+func (s *Scope) Pos() syntax.Pos { return s.pos }
+func (s *Scope) End() syntax.Pos { return s.end }
+
+// Contains reports whether pos is within the scope's extent.
+// The result is guaranteed to be valid only if the type-checked
+// AST has complete position information.
+func (s *Scope) Contains(pos syntax.Pos) bool {
+	return cmpPos(s.pos, pos) <= 0 && cmpPos(pos, s.end) < 0
+}
+
+// Innermost returns the innermost (child) scope containing
+// pos. If pos is not within any scope, the result is nil.
+// The result is also nil for the Universe scope.
+// The result is guaranteed to be valid only if the type-checked
+// AST has complete position information.
+func (s *Scope) Innermost(pos syntax.Pos) *Scope {
+	// Package scopes do not have extents since they may be
+	// discontiguous, so iterate over the package's files.
+	if s.parent == Universe {
+		for _, s := range s.children {
+			if inner := s.Innermost(pos); inner != nil {
+				return inner
+			}
+		}
+	}
+
+	if s.Contains(pos) {
+		for _, s := range s.children {
+			if s.Contains(pos) {
+				return s.Innermost(pos)
+			}
+		}
+		return s
+	}
+	return nil
+}
+
+// WriteTo writes a string representation of the scope to w,
+// with the scope elements sorted by name.
+// The level of indentation is controlled by n >= 0, with
+// n == 0 for no indentation.
+// If recurse is set, it also writes nested (children) scopes.
+func (s *Scope) WriteTo(w io.Writer, n int, recurse bool) {
+	const ind = ".  "
+	indn := strings.Repeat(ind, n)
+
+	fmt.Fprintf(w, "%s%s scope %p {\n", indn, s.comment, s)
+
+	indn1 := indn + ind
+	for _, name := range s.Names() {
+		fmt.Fprintf(w, "%s%s\n", indn1, s.elems[name])
+	}
+
+	if recurse {
+		for _, s := range s.children {
+			s.WriteTo(w, n+1, recurse)
+		}
+	}
+
+	fmt.Fprintf(w, "%s}\n", indn)
+}
+
+// String returns a string representation of the scope, for debugging.
+func (s *Scope) String() string {
+	var buf bytes.Buffer
+	s.WriteTo(&buf, 0, false)
+	return buf.String()
+}
diff --git a/src/cmd/compile/internal/types2/selection.go b/src/cmd/compile/internal/types2/selection.go
new file mode 100644
index 0000000000..da0e9ab526
--- /dev/null
+++ b/src/cmd/compile/internal/types2/selection.go
@@ -0,0 +1,144 @@
+// UNREVIEWED
+// Copyright 2013 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.
+
+// This file implements Selections.
+
+package types2
+
+import (
+	"bytes"
+	"fmt"
+)
+
+// SelectionKind describes the kind of a selector expression x.f
+// (excluding qualified identifiers).
+type SelectionKind int
+
+const (
+	FieldVal   SelectionKind = iota // x.f is a struct field selector
+	MethodVal                       // x.f is a method selector
+	MethodExpr                      // x.f is a method expression
+)
+
+// A Selection describes a selector expression x.f.
+// For the declarations:
+//
+//	type T struct{ x int; E }
+//	type E struct{}
+//	func (e E) m() {}
+//	var p *T
+//
+// the following relations exist:
+//
+//	Selector    Kind          Recv    Obj    Type       Index     Indirect
+//
+//	p.x         FieldVal      T       x      int        {0}       true
+//	p.m         MethodVal     *T      m      func()     {1, 0}    true
+//	T.m         MethodExpr    T       m      func(T)    {1, 0}    false
+//
+type Selection struct {
+	kind     SelectionKind
+	recv     Type   // type of x
+	obj      Object // object denoted by x.f
+	index    []int  // path from x to x.f
+	indirect bool   // set if there was any pointer indirection on the path
+}
+
+// Kind returns the selection kind.
+func (s *Selection) Kind() SelectionKind { return s.kind }
+
+// Recv returns the type of x in x.f.
+func (s *Selection) Recv() Type { return s.recv }
+
+// Obj returns the object denoted by x.f; a *Var for
+// a field selection, and a *Func in all other cases.
+func (s *Selection) Obj() Object { return s.obj }
+
+// Type returns the type of x.f, which may be different from the type of f.
+// See Selection for more information.
+func (s *Selection) Type() Type {
+	switch s.kind {
+	case MethodVal:
+		// The type of x.f is a method with its receiver type set
+		// to the type of x.
+		sig := *s.obj.(*Func).typ.(*Signature)
+		recv := *sig.recv
+		recv.typ = s.recv
+		sig.recv = &recv
+		return &sig
+
+	case MethodExpr:
+		// The type of x.f is a function (without receiver)
+		// and an additional first argument with the same type as x.
+		// TODO(gri) Similar code is already in call.go - factor!
+		// TODO(gri) Compute this eagerly to avoid allocations.
+		sig := *s.obj.(*Func).typ.(*Signature)
+		arg0 := *sig.recv
+		sig.recv = nil
+		arg0.typ = s.recv
+		var params []*Var
+		if sig.params != nil {
+			params = sig.params.vars
+		}
+		sig.params = NewTuple(append([]*Var{&arg0}, params...)...)
+		return &sig
+	}
+
+	// In all other cases, the type of x.f is the type of x.
+	return s.obj.Type()
+}
+
+// Index describes the path from x to f in x.f.
+// The last index entry is the field or method index of the type declaring f;
+// either:
+//
+//	1) the list of declared methods of a named type; or
+//	2) the list of methods of an interface type; or
+//	3) the list of fields of a struct type.
+//
+// The earlier index entries are the indices of the embedded fields implicitly
+// traversed to get from (the type of) x to f, starting at embedding depth 0.
+func (s *Selection) Index() []int { return s.index }
+
+// Indirect reports whether any pointer indirection was required to get from
+// x to f in x.f.
+func (s *Selection) Indirect() bool { return s.indirect }
+
+func (s *Selection) String() string { return SelectionString(s, nil) }
+
+// SelectionString returns the string form of s.
+// The Qualifier controls the printing of
+// package-level objects, and may be nil.
+//
+// Examples:
+//	"field (T) f int"
+//	"method (T) f(X) Y"
+//	"method expr (T) f(X) Y"
+//
+func SelectionString(s *Selection, qf Qualifier) string {
+	var k string
+	switch s.kind {
+	case FieldVal:
+		k = "field "
+	case MethodVal:
+		k = "method "
+	case MethodExpr:
+		k = "method expr "
+	default:
+		unreachable()
+	}
+	var buf bytes.Buffer
+	buf.WriteString(k)
+	buf.WriteByte('(')
+	WriteType(&buf, s.Recv(), qf)
+	fmt.Fprintf(&buf, ") %s", s.obj.Name())
+	if T := s.Type(); s.kind == FieldVal {
+		buf.WriteByte(' ')
+		WriteType(&buf, T, qf)
+	} else {
+		WriteSignature(&buf, T.(*Signature), qf)
+	}
+	return buf.String()
+}
diff --git a/src/cmd/compile/internal/types2/self_test.go b/src/cmd/compile/internal/types2/self_test.go
new file mode 100644
index 0000000000..6d7971e50f
--- /dev/null
+++ b/src/cmd/compile/internal/types2/self_test.go
@@ -0,0 +1,97 @@
+// UNREVIEWED
+// Copyright 2013 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 types2_test
+
+import (
+	"cmd/compile/internal/syntax"
+	"flag"
+	"fmt"
+	"path/filepath"
+	"testing"
+	"time"
+
+	. "cmd/compile/internal/types2"
+)
+
+var benchmark = flag.Bool("b", false, "run benchmarks")
+
+func TestSelf(t *testing.T) {
+	files, err := pkgFiles(".")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	conf := Config{Importer: defaultImporter()}
+	_, err = conf.Check("go/types", files, nil)
+	if err != nil {
+		// Importing go/constant doesn't work in the
+		// build dashboard environment. Don't report an error
+		// for now so that the build remains green.
+		// TODO(gri) fix this
+		t.Log(err) // replace w/ t.Fatal eventually
+		return
+	}
+}
+
+func TestBenchmark(t *testing.T) {
+	if !*benchmark {
+		return
+	}
+
+	// We're not using testing's benchmarking mechanism directly
+	// because we want custom output.
+
+	for _, p := range []string{"types", "constant", filepath.Join("internal", "gcimporter")} {
+		path := filepath.Join("..", p)
+		runbench(t, path, false)
+		runbench(t, path, true)
+		fmt.Println()
+	}
+}
+
+func runbench(t *testing.T, path string, ignoreFuncBodies bool) {
+	files, err := pkgFiles(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	b := testing.Benchmark(func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			conf := Config{IgnoreFuncBodies: ignoreFuncBodies}
+			conf.Check(path, files, nil)
+		}
+	})
+
+	// determine line count
+	var lines uint
+	for _, f := range files {
+		lines += f.EOF.Line()
+	}
+
+	d := time.Duration(b.NsPerOp())
+	fmt.Printf(
+		"%s: %s for %d lines (%d lines/s), ignoreFuncBodies = %v\n",
+		filepath.Base(path), d, lines, int64(float64(lines)/d.Seconds()), ignoreFuncBodies,
+	)
+}
+
+func pkgFiles(path string) ([]*syntax.File, error) {
+	filenames, err := pkgFilenames(path) // from stdlib_test.go
+	if err != nil {
+		return nil, err
+	}
+
+	var files []*syntax.File
+	for _, filename := range filenames {
+		file, err := syntax.ParseFile(filename, nil, nil, 0)
+		if err != nil {
+			return nil, err
+		}
+		files = append(files, file)
+	}
+
+	return files, nil
+}
diff --git a/src/cmd/compile/internal/types2/sizes.go b/src/cmd/compile/internal/types2/sizes.go
new file mode 100644
index 0000000000..cae71c139c
--- /dev/null
+++ b/src/cmd/compile/internal/types2/sizes.go
@@ -0,0 +1,266 @@
+// UNREVIEWED
+// Copyright 2013 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.
+
+// This file implements Sizes.
+
+package types2
+
+// Sizes defines the sizing functions for package unsafe.
+type Sizes interface {
+	// Alignof returns the alignment of a variable of type T.
+	// Alignof must implement the alignment guarantees required by the spec.
+	Alignof(T Type) int64
+
+	// Offsetsof returns the offsets of the given struct fields, in bytes.
+	// Offsetsof must implement the offset guarantees required by the spec.
+	Offsetsof(fields []*Var) []int64
+
+	// Sizeof returns the size of a variable of type T.
+	// Sizeof must implement the size guarantees required by the spec.
+	Sizeof(T Type) int64
+}
+
+// StdSizes is a convenience type for creating commonly used Sizes.
+// It makes the following simplifying assumptions:
+//
+//	- The size of explicitly sized basic types (int16, etc.) is the
+//	  specified size.
+//	- The size of strings and interfaces is 2*WordSize.
+//	- The size of slices is 3*WordSize.
+//	- The size of an array of n elements corresponds to the size of
+//	  a struct of n consecutive fields of the array's element type.
+//      - The size of a struct is the offset of the last field plus that
+//	  field's size. As with all element types, if the struct is used
+//	  in an array its size must first be aligned to a multiple of the
+//	  struct's alignment.
+//	- All other types have size WordSize.
+//	- Arrays and structs are aligned per spec definition; all other
+//	  types are naturally aligned with a maximum alignment MaxAlign.
+//
+// *StdSizes implements Sizes.
+//
+type StdSizes struct {
+	WordSize int64 // word size in bytes - must be >= 4 (32bits)
+	MaxAlign int64 // maximum alignment in bytes - must be >= 1
+}
+
+func (s *StdSizes) Alignof(T Type) int64 {
+	// For arrays and structs, alignment is defined in terms
+	// of alignment of the elements and fields, respectively.
+	switch t := optype(T.Under()).(type) {
+	case *Array:
+		// spec: "For a variable x of array type: unsafe.Alignof(x)
+		// is the same as unsafe.Alignof(x[0]), but at least 1."
+		return s.Alignof(t.elem)
+	case *Struct:
+		// spec: "For a variable x of struct type: unsafe.Alignof(x)
+		// is the largest of the values unsafe.Alignof(x.f) for each
+		// field f of x, but at least 1."
+		max := int64(1)
+		for _, f := range t.fields {
+			if a := s.Alignof(f.typ); a > max {
+				max = a
+			}
+		}
+		return max
+	case *Slice, *Interface:
+		// Multiword data structures are effectively structs
+		// in which each element has size WordSize.
+		return s.WordSize
+	case *Basic:
+		// Strings are like slices and interfaces.
+		if t.Info()&IsString != 0 {
+			return s.WordSize
+		}
+	}
+	a := s.Sizeof(T) // may be 0
+	// spec: "For a variable x of any type: unsafe.Alignof(x) is at least 1."
+	if a < 1 {
+		return 1
+	}
+	// complex{64,128} are aligned like [2]float{32,64}.
+	if isComplex(T) {
+		a /= 2
+	}
+	if a > s.MaxAlign {
+		return s.MaxAlign
+	}
+	return a
+}
+
+func (s *StdSizes) Offsetsof(fields []*Var) []int64 {
+	offsets := make([]int64, len(fields))
+	var o int64
+	for i, f := range fields {
+		a := s.Alignof(f.typ)
+		o = align(o, a)
+		offsets[i] = o
+		o += s.Sizeof(f.typ)
+	}
+	return offsets
+}
+
+var basicSizes = [...]byte{
+	Bool:       1,
+	Int8:       1,
+	Int16:      2,
+	Int32:      4,
+	Int64:      8,
+	Uint8:      1,
+	Uint16:     2,
+	Uint32:     4,
+	Uint64:     8,
+	Float32:    4,
+	Float64:    8,
+	Complex64:  8,
+	Complex128: 16,
+}
+
+func (s *StdSizes) Sizeof(T Type) int64 {
+	switch t := optype(T.Under()).(type) {
+	case *Basic:
+		assert(isTyped(T))
+		k := t.kind
+		if int(k) < len(basicSizes) {
+			if s := basicSizes[k]; s > 0 {
+				return int64(s)
+			}
+		}
+		if k == String {
+			return s.WordSize * 2
+		}
+	case *Array:
+		n := t.len
+		if n <= 0 {
+			return 0
+		}
+		// n > 0
+		a := s.Alignof(t.elem)
+		z := s.Sizeof(t.elem)
+		return align(z, a)*(n-1) + z
+	case *Slice:
+		return s.WordSize * 3
+	case *Struct:
+		n := t.NumFields()
+		if n == 0 {
+			return 0
+		}
+		offsets := s.Offsetsof(t.fields)
+		return offsets[n-1] + s.Sizeof(t.fields[n-1].typ)
+	case *Sum:
+		panic("Sizeof unimplemented for type sum")
+	case *Interface:
+		return s.WordSize * 2
+	}
+	return s.WordSize // catch-all
+}
+
+// common architecture word sizes and alignments
+var gcArchSizes = map[string]*StdSizes{
+	"386":      {4, 4},
+	"arm":      {4, 4},
+	"arm64":    {8, 8},
+	"amd64":    {8, 8},
+	"amd64p32": {4, 8},
+	"mips":     {4, 4},
+	"mipsle":   {4, 4},
+	"mips64":   {8, 8},
+	"mips64le": {8, 8},
+	"ppc64":    {8, 8},
+	"ppc64le":  {8, 8},
+	"riscv64":  {8, 8},
+	"s390x":    {8, 8},
+	"sparc64":  {8, 8},
+	"wasm":     {8, 8},
+	// When adding more architectures here,
+	// update the doc string of SizesFor below.
+}
+
+// SizesFor returns the Sizes used by a compiler for an architecture.
+// The result is nil if a compiler/architecture pair is not known.
+//
+// Supported architectures for compiler "gc":
+// "386", "arm", "arm64", "amd64", "amd64p32", "mips", "mipsle",
+// "mips64", "mips64le", "ppc64", "ppc64le", "riscv64", "s390x", "sparc64", "wasm".
+func SizesFor(compiler, arch string) Sizes {
+	var m map[string]*StdSizes
+	switch compiler {
+	case "gc":
+		m = gcArchSizes
+	case "gccgo":
+		m = gccgoArchSizes
+	default:
+		return nil
+	}
+	s, ok := m[arch]
+	if !ok {
+		return nil
+	}
+	return s
+}
+
+// stdSizes is used if Config.Sizes == nil.
+var stdSizes = SizesFor("gc", "amd64")
+
+func (conf *Config) alignof(T Type) int64 {
+	if s := conf.Sizes; s != nil {
+		if a := s.Alignof(T); a >= 1 {
+			return a
+		}
+		panic("Config.Sizes.Alignof returned an alignment < 1")
+	}
+	return stdSizes.Alignof(T)
+}
+
+func (conf *Config) offsetsof(T *Struct) []int64 {
+	var offsets []int64
+	if T.NumFields() > 0 {
+		// compute offsets on demand
+		if s := conf.Sizes; s != nil {
+			offsets = s.Offsetsof(T.fields)
+			// sanity checks
+			if len(offsets) != T.NumFields() {
+				panic("Config.Sizes.Offsetsof returned the wrong number of offsets")
+			}
+			for _, o := range offsets {
+				if o < 0 {
+					panic("Config.Sizes.Offsetsof returned an offset < 0")
+				}
+			}
+		} else {
+			offsets = stdSizes.Offsetsof(T.fields)
+		}
+	}
+	return offsets
+}
+
+// offsetof returns the offset of the field specified via
+// the index sequence relative to typ. All embedded fields
+// must be structs (rather than pointer to structs).
+func (conf *Config) offsetof(typ Type, index []int) int64 {
+	var o int64
+	for _, i := range index {
+		s := typ.Struct()
+		o += conf.offsetsof(s)[i]
+		typ = s.fields[i].typ
+	}
+	return o
+}
+
+func (conf *Config) sizeof(T Type) int64 {
+	if s := conf.Sizes; s != nil {
+		if z := s.Sizeof(T); z >= 0 {
+			return z
+		}
+		panic("Config.Sizes.Sizeof returned a size < 0")
+	}
+	return stdSizes.Sizeof(T)
+}
+
+// align returns the smallest y >= x such that y % a == 0.
+func align(x, a int64) int64 {
+	y := x + a - 1
+	return y - y%a
+}
diff --git a/src/cmd/compile/internal/types2/sizes_test.go b/src/cmd/compile/internal/types2/sizes_test.go
new file mode 100644
index 0000000000..b246909d2a
--- /dev/null
+++ b/src/cmd/compile/internal/types2/sizes_test.go
@@ -0,0 +1,108 @@
+// UNREVIEWED
+// Copyright 2016 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.
+
+// This file contains tests for sizes.
+
+package types2_test
+
+import (
+	"cmd/compile/internal/syntax"
+	"cmd/compile/internal/types2"
+	"testing"
+)
+
+// findStructType typechecks src and returns the first struct type encountered.
+func findStructType(t *testing.T, src string) *types2.Struct {
+	f, err := parseSrc("x.go", src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	info := types2.Info{Types: make(map[syntax.Expr]types2.TypeAndValue)}
+	var conf types2.Config
+	_, err = conf.Check("x", []*syntax.File{f}, &info)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, tv := range info.Types {
+		if ts, ok := tv.Type.(*types2.Struct); ok {
+			return ts
+		}
+	}
+	t.Fatalf("failed to find a struct type in src:\n%s\n", src)
+	return nil
+}
+
+// Issue 16316
+func TestMultipleSizeUse(t *testing.T) {
+	const src = `
+package main
+
+type S struct {
+    i int
+    b bool
+    s string
+    n int
+}
+`
+	ts := findStructType(t, src)
+	sizes := types2.StdSizes{WordSize: 4, MaxAlign: 4}
+	if got := sizes.Sizeof(ts); got != 20 {
+		t.Errorf("Sizeof(%v) with WordSize 4 = %d want 20", ts, got)
+	}
+	sizes = types2.StdSizes{WordSize: 8, MaxAlign: 8}
+	if got := sizes.Sizeof(ts); got != 40 {
+		t.Errorf("Sizeof(%v) with WordSize 8 = %d want 40", ts, got)
+	}
+}
+
+// Issue 16464
+func TestAlignofNaclSlice(t *testing.T) {
+	const src = `
+package main
+
+var s struct {
+	x *int
+	y []byte
+}
+`
+	ts := findStructType(t, src)
+	sizes := &types2.StdSizes{WordSize: 4, MaxAlign: 8}
+	var fields []*types2.Var
+	// Make a copy manually :(
+	for i := 0; i < ts.NumFields(); i++ {
+		fields = append(fields, ts.Field(i))
+	}
+	offsets := sizes.Offsetsof(fields)
+	if offsets[0] != 0 || offsets[1] != 4 {
+		t.Errorf("OffsetsOf(%v) = %v want %v", ts, offsets, []int{0, 4})
+	}
+}
+
+func TestIssue16902(t *testing.T) {
+	const src = `
+package a
+
+import "unsafe"
+
+const _ = unsafe.Offsetof(struct{ x int64 }{}.x)
+`
+	f, err := parseSrc("x.go", src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	info := types2.Info{Types: make(map[syntax.Expr]types2.TypeAndValue)}
+	conf := types2.Config{
+		Importer: defaultImporter(),
+		Sizes:    &types2.StdSizes{WordSize: 8, MaxAlign: 8},
+	}
+	_, err = conf.Check("x", []*syntax.File{f}, &info)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, tv := range info.Types {
+		_ = conf.Sizes.Sizeof(tv.Type)
+		_ = conf.Sizes.Alignof(tv.Type)
+	}
+}
diff --git a/src/cmd/compile/internal/types2/stdlib_test.go b/src/cmd/compile/internal/types2/stdlib_test.go
new file mode 100644
index 0000000000..bc8b81998a
--- /dev/null
+++ b/src/cmd/compile/internal/types2/stdlib_test.go
@@ -0,0 +1,320 @@
+// UNREVIEWED
+// Copyright 2013 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.
+
+// This file tests types.Check by using it to
+// typecheck the standard library and tests.
+
+package types2_test
+
+import (
+	"bytes"
+	"cmd/compile/internal/syntax"
+	"fmt"
+	"go/build"
+	"internal/testenv"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	. "cmd/compile/internal/types2"
+)
+
+var stdLibImporter = defaultImporter()
+
+func TestStdlib(t *testing.T) {
+	testenv.MustHaveGoBuild(t)
+
+	pkgCount := 0
+	duration := walkPkgDirs(filepath.Join(runtime.GOROOT(), "src"), func(dir string, filenames []string) {
+		typecheck(t, dir, filenames)
+		pkgCount++
+	}, t.Error)
+
+	if testing.Verbose() {
+		fmt.Println(pkgCount, "packages typechecked in", duration)
+	}
+}
+
+// firstComment returns the contents of the first non-empty comment in
+// the given file, "skip", or the empty string. No matter the present
+// comments, if any of them contains a build tag, the result is always
+// "skip". Only comments within the first 4K of the file are considered.
+// TODO(gri) should only read until we see "package" token.
+func firstComment(filename string) (first string) {
+	f, err := os.Open(filename)
+	if err != nil {
+		return ""
+	}
+	defer f.Close()
+
+	// read at most 4KB
+	var buf [4 << 10]byte
+	n, _ := f.Read(buf[:])
+	src := bytes.NewBuffer(buf[:n])
+
+	// TODO(gri) we need a better way to terminate CommentsDo
+	defer func() {
+		if p := recover(); p != nil {
+			if s, ok := p.(string); ok {
+				first = s
+			}
+		}
+	}()
+
+	syntax.CommentsDo(src, func(_, _ uint, text string) {
+		if text[0] != '/' {
+			return // not a comment
+		}
+
+		// extract comment text
+		if text[1] == '*' {
+			text = text[:len(text)-2]
+		}
+		text = strings.TrimSpace(text[2:])
+
+		if strings.HasPrefix(text, "+build ") {
+			panic("skip")
+		}
+		if first == "" {
+			first = text // text may be "" but that's ok
+		}
+		// continue as we may still see build tags
+	})
+
+	return
+}
+
+func testTestDir(t *testing.T, path string, ignore ...string) {
+	files, err := ioutil.ReadDir(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	excluded := make(map[string]bool)
+	for _, filename := range ignore {
+		excluded[filename] = true
+	}
+
+	for _, f := range files {
+		// filter directory contents
+		if f.IsDir() || !strings.HasSuffix(f.Name(), ".go") || excluded[f.Name()] {
+			continue
+		}
+
+		// get per-file instructions
+		expectErrors := false
+		filename := filepath.Join(path, f.Name())
+		if comment := firstComment(filename); comment != "" {
+			fields := strings.Fields(comment)
+			switch fields[0] {
+			case "skip", "compiledir":
+				continue // ignore this file
+			case "errorcheck":
+				expectErrors = true
+				for _, arg := range fields[1:] {
+					if arg == "-0" || arg == "-+" || arg == "-std" {
+						// Marked explicitly as not expected errors (-0),
+						// or marked as compiling runtime/stdlib, which is only done
+						// to trigger runtime/stdlib-only error output.
+						// In both cases, the code should typecheck.
+						expectErrors = false
+						break
+					}
+				}
+			}
+		}
+
+		// parse and type-check file
+		if testing.Verbose() {
+			fmt.Println("\t", filename)
+		}
+		file, err := syntax.ParseFile(filename, nil, nil, 0)
+		if err == nil {
+			conf := Config{Importer: stdLibImporter}
+			_, err = conf.Check(filename, []*syntax.File{file}, nil)
+		}
+
+		if expectErrors {
+			if err == nil {
+				t.Errorf("expected errors but found none in %s", filename)
+			}
+		} else {
+			if err != nil {
+				t.Error(err)
+			}
+		}
+	}
+}
+
+func TestStdTest(t *testing.T) {
+	testenv.MustHaveGoBuild(t)
+
+	if testing.Short() && testenv.Builder() == "" {
+		t.Skip("skipping in short mode")
+	}
+
+	testTestDir(t, filepath.Join(runtime.GOROOT(), "test"),
+		"cmplxdivide.go", // also needs file cmplxdivide1.go - ignore
+		"directive.go",   // tests compiler rejection of bad directive placement - ignore
+	)
+}
+
+func TestStdFixed(t *testing.T) {
+	testenv.MustHaveGoBuild(t)
+
+	if testing.Short() && testenv.Builder() == "" {
+		t.Skip("skipping in short mode")
+	}
+
+	testTestDir(t, filepath.Join(runtime.GOROOT(), "test", "fixedbugs"),
+		"bug248.go", "bug302.go", "bug369.go", // complex test instructions - ignore
+		"issue6889.go",   // gc-specific test
+		"issue7746.go",   // large constants - consumes too much memory
+		"issue11362.go",  // canonical import path check
+		"issue16369.go",  // go/types handles this correctly - not an issue
+		"issue18459.go",  // go/types doesn't check validity of //go:xxx directives
+		"issue18882.go",  // go/types doesn't check validity of //go:xxx directives
+		"issue20232.go",  // go/types handles larger constants than gc
+		"issue20529.go",  // go/types does not have constraints on stack size
+		"issue22200.go",  // go/types does not have constraints on stack size
+		"issue22200b.go", // go/types does not have constraints on stack size
+		"issue25507.go",  // go/types does not have constraints on stack size
+		"issue20780.go",  // go/types does not have constraints on stack size
+		"issue31747.go",  // go/types does not have constraints on language level (-lang=go1.12) (see #31793)
+		"issue34329.go",  // go/types does not have constraints on language level (-lang=go1.13) (see #31793)
+		"bug251.go",      // issue #34333 which was exposed with fix for #34151
+	)
+}
+
+func TestStdKen(t *testing.T) {
+	testenv.MustHaveGoBuild(t)
+
+	testTestDir(t, filepath.Join(runtime.GOROOT(), "test", "ken"))
+}
+
+// Package paths of excluded packages.
+var excluded = map[string]bool{
+	"builtin": true,
+}
+
+// typecheck typechecks the given package files.
+func typecheck(t *testing.T, path string, filenames []string) {
+	// parse package files
+	var files []*syntax.File
+	for _, filename := range filenames {
+		errh := func(err error) { t.Error(err) }
+		file, err := syntax.ParseFile(filename, errh, nil, 0)
+		if err != nil {
+			return
+		}
+
+		if testing.Verbose() {
+			if len(files) == 0 {
+				fmt.Println("package", file.PkgName.Value)
+			}
+			fmt.Println("\t", filename)
+		}
+
+		files = append(files, file)
+	}
+
+	// typecheck package files
+	conf := Config{
+		Error:    func(err error) { t.Error(err) },
+		Importer: stdLibImporter,
+	}
+	info := Info{Uses: make(map[*syntax.Name]Object)}
+	conf.Check(path, files, &info)
+
+	// Perform checks of API invariants.
+
+	// All Objects have a package, except predeclared ones.
+	errorError := Universe.Lookup("error").Type().Interface().ExplicitMethod(0) // (error).Error
+	for id, obj := range info.Uses {
+		predeclared := obj == Universe.Lookup(obj.Name()) || obj == errorError
+		if predeclared == (obj.Pkg() != nil) {
+			posn := id.Pos()
+			if predeclared {
+				t.Errorf("%s: predeclared object with package: %s", posn, obj)
+			} else {
+				t.Errorf("%s: user-defined object without package: %s", posn, obj)
+			}
+		}
+	}
+}
+
+// pkgFilenames returns the list of package filenames for the given directory.
+func pkgFilenames(dir string) ([]string, error) {
+	ctxt := build.Default
+	ctxt.CgoEnabled = false
+	pkg, err := ctxt.ImportDir(dir, 0)
+	if err != nil {
+		if _, nogo := err.(*build.NoGoError); nogo {
+			return nil, nil // no *.go files, not an error
+		}
+		return nil, err
+	}
+	if excluded[pkg.ImportPath] {
+		return nil, nil
+	}
+	var filenames []string
+	for _, name := range pkg.GoFiles {
+		filenames = append(filenames, filepath.Join(pkg.Dir, name))
+	}
+	for _, name := range pkg.TestGoFiles {
+		filenames = append(filenames, filepath.Join(pkg.Dir, name))
+	}
+	return filenames, nil
+}
+
+func walkPkgDirs(dir string, pkgh func(dir string, filenames []string), errh func(args ...interface{})) time.Duration {
+	w := walker{time.Now(), 10 * time.Millisecond, pkgh, errh}
+	w.walk(dir)
+	return time.Since(w.start)
+}
+
+type walker struct {
+	start time.Time
+	dmax  time.Duration
+	pkgh  func(dir string, filenames []string)
+	errh  func(args ...interface{})
+}
+
+func (w *walker) walk(dir string) {
+	// limit run time for short tests
+	if testing.Short() && time.Since(w.start) >= w.dmax {
+		return
+	}
+
+	fis, err := ioutil.ReadDir(dir)
+	if err != nil {
+		w.errh(err)
+		return
+	}
+
+	// apply pkgh to the files in directory dir
+	// but ignore files directly under $GOROOT/src (might be temporary test files).
+	if dir != filepath.Join(runtime.GOROOT(), "src") {
+		files, err := pkgFilenames(dir)
+		if err != nil {
+			w.errh(err)
+			return
+		}
+		if files != nil {
+			w.pkgh(dir, files)
+		}
+	}
+
+	// traverse subdirectories, but don't walk into testdata
+	for _, fi := range fis {
+		if fi.IsDir() && fi.Name() != "testdata" {
+			w.walk(filepath.Join(dir, fi.Name()))
+		}
+	}
+}
diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go
new file mode 100644
index 0000000000..2f1347faf4
--- /dev/null
+++ b/src/cmd/compile/internal/types2/stmt.go
@@ -0,0 +1,919 @@
+// UNREVIEWED
+// Copyright 2012 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.
+
+// This file implements typechecking of statements.
+
+package types2
+
+import (
+	"cmd/compile/internal/syntax"
+	"go/constant"
+	"sort"
+)
+
+func (check *Checker) funcBody(decl *declInfo, name string, sig *Signature, body *syntax.BlockStmt, iota constant.Value) {
+	if check.conf.Trace {
+		check.trace(body.Pos(), "--- %s: %s", name, sig)
+		defer func() {
+			check.trace(endPos(body), "--- <end>")
+		}()
+	}
+
+	// set function scope extent
+	sig.scope.pos = body.Pos()
+	sig.scope.end = endPos(body)
+
+	// save/restore current context and setup function context
+	// (and use 0 indentation at function start)
+	defer func(ctxt context, indent int) {
+		check.context = ctxt
+		check.indent = indent
+	}(check.context, check.indent)
+	check.context = context{
+		decl:  decl,
+		scope: sig.scope,
+		iota:  iota,
+		sig:   sig,
+	}
+	check.indent = 0
+
+	check.stmtList(0, body.List)
+
+	if check.hasLabel {
+		check.labels(body)
+	}
+
+	if sig.results.Len() > 0 && !check.isTerminating(body, "") {
+		check.error(body.Rbrace, "missing return")
+	}
+
+	// TODO(gri) Should we make it an error to declare generic functions
+	//           where the type parameters are not used?
+	// 12/19/2018: Probably not - it can make sense to have an API with
+	//           all functions uniformly sharing the same type parameters.
+
+	// spec: "Implementation restriction: A compiler may make it illegal to
+	// declare a variable inside a function body if the variable is never used."
+	check.usage(sig.scope)
+}
+
+func (check *Checker) usage(scope *Scope) {
+	var unused []*Var
+	for _, elem := range scope.elems {
+		if v, _ := elem.(*Var); v != nil && !v.used {
+			unused = append(unused, v)
+		}
+	}
+	sort.Slice(unused, func(i, j int) bool {
+		return cmpPos(unused[i].pos, unused[j].pos) < 0
+	})
+	for _, v := range unused {
+		check.softErrorf(v.pos, "%s declared but not used", v.name)
+	}
+
+	for _, scope := range scope.children {
+		// Don't go inside function literal scopes a second time;
+		// they are handled explicitly by funcBody.
+		if !scope.isFunc {
+			check.usage(scope)
+		}
+	}
+}
+
+// stmtContext is a bitset describing which
+// control-flow statements are permissible,
+// and provides additional context information
+// for better error messages.
+type stmtContext uint
+
+const (
+	// permissible control-flow statements
+	breakOk stmtContext = 1 << iota
+	continueOk
+	fallthroughOk
+
+	// additional context information
+	finalSwitchCase
+)
+
+func (check *Checker) simpleStmt(s syntax.Stmt) {
+	if s != nil {
+		check.stmt(0, s)
+	}
+}
+
+func trimTrailingEmptyStmts(list []syntax.Stmt) []syntax.Stmt {
+	for i := len(list); i > 0; i-- {
+		if _, ok := list[i-1].(*syntax.EmptyStmt); !ok {
+			return list[:i]
+		}
+	}
+	return nil
+}
+
+func (check *Checker) stmtList(ctxt stmtContext, list []syntax.Stmt) {
+	ok := ctxt&fallthroughOk != 0
+	inner := ctxt &^ fallthroughOk
+	list = trimTrailingEmptyStmts(list) // trailing empty statements are "invisible" to fallthrough analysis
+	for i, s := range list {
+		inner := inner
+		if ok && i+1 == len(list) {
+			inner |= fallthroughOk
+		}
+		check.stmt(inner, s)
+	}
+}
+
+func (check *Checker) multipleSwitchDefaults(list []*syntax.CaseClause) {
+	var first *syntax.CaseClause
+	for _, c := range list {
+		if c.Cases == nil {
+			if first != nil {
+				check.errorf(c, "multiple defaults (first at %s)", first.Pos())
+				// TODO(gri) probably ok to bail out after first error (and simplify this code)
+			} else {
+				first = c
+			}
+		}
+	}
+}
+
+func (check *Checker) multipleSelectDefaults(list []*syntax.CommClause) {
+	var first *syntax.CommClause
+	for _, c := range list {
+		if c.Comm == nil {
+			if first != nil {
+				check.errorf(c, "multiple defaults (first at %s)", first.Pos())
+				// TODO(gri) probably ok to bail out after first error (and simplify this code)
+			} else {
+				first = c
+			}
+		}
+	}
+}
+
+func (check *Checker) openScope(node syntax.Node, comment string) {
+	scope := NewScope(check.scope, node.Pos(), endPos(node), comment)
+	check.recordScope(node, scope)
+	check.scope = scope
+}
+
+func (check *Checker) closeScope() {
+	check.scope = check.scope.Parent()
+}
+
+func (check *Checker) suspendedCall(keyword string, call *syntax.CallExpr) {
+	var x operand
+	var msg string
+	switch check.rawExpr(&x, call, nil) {
+	case conversion:
+		msg = "requires function call, not conversion"
+	case expression:
+		msg = "discards result of"
+	case statement:
+		return
+	default:
+		unreachable()
+	}
+	check.errorf(&x, "%s %s %s", keyword, msg, &x)
+}
+
+// goVal returns the Go value for val, or nil.
+func goVal(val constant.Value) interface{} {
+	// val should exist, but be conservative and check
+	if val == nil {
+		return nil
+	}
+	// Match implementation restriction of other compilers.
+	// gc only checks duplicates for integer, floating-point
+	// and string values, so only create Go values for these
+	// types.
+	switch val.Kind() {
+	case constant.Int:
+		if x, ok := constant.Int64Val(val); ok {
+			return x
+		}
+		if x, ok := constant.Uint64Val(val); ok {
+			return x
+		}
+	case constant.Float:
+		if x, ok := constant.Float64Val(val); ok {
+			return x
+		}
+	case constant.String:
+		return constant.StringVal(val)
+	}
+	return nil
+}
+
+// A valueMap maps a case value (of a basic Go type) to a list of positions
+// where the same case value appeared, together with the corresponding case
+// types.
+// Since two case values may have the same "underlying" value but different
+// types we need to also check the value's types (e.g., byte(1) vs myByte(1))
+// when the switch expression is of interface type.
+type (
+	valueMap  map[interface{}][]valueType // underlying Go value -> valueType
+	valueType struct {
+		pos syntax.Pos
+		typ Type
+	}
+)
+
+func (check *Checker) caseValues(x *operand, values []syntax.Expr, seen valueMap) {
+L:
+	for _, e := range values {
+		var v operand
+		check.expr(&v, e)
+		if x.mode == invalid || v.mode == invalid {
+			continue L
+		}
+		check.convertUntyped(&v, x.typ)
+		if v.mode == invalid {
+			continue L
+		}
+		// Order matters: By comparing v against x, error positions are at the case values.
+		res := v // keep original v unchanged
+		check.comparison(&res, x, syntax.Eql)
+		if res.mode == invalid {
+			continue L
+		}
+		if v.mode != constant_ {
+			continue L // we're done
+		}
+		// look for duplicate values
+		if val := goVal(v.val); val != nil {
+			// look for duplicate types for a given value
+			// (quadratic algorithm, but these lists tend to be very short)
+			for _, vt := range seen[val] {
+				if check.identical(v.typ, vt.typ) {
+					check.errorf(&v, "duplicate case %s in expression switch", &v)
+					check.error(vt.pos, "\tprevious case") // secondary error, \t indented
+					continue L
+				}
+			}
+			seen[val] = append(seen[val], valueType{v.Pos(), v.typ})
+		}
+	}
+}
+
+func (check *Checker) caseTypes(x *operand, xtyp *Interface, types []syntax.Expr, seen map[Type]syntax.Pos, strict bool) (T Type) {
+L:
+	for _, e := range types {
+		T = check.typOrNil(e)
+		if T == Typ[Invalid] {
+			continue L
+		}
+		if T != nil {
+			check.ordinaryType(e.Pos(), T)
+		}
+		// look for duplicate types
+		// (quadratic algorithm, but type switches tend to be reasonably small)
+		for t, pos := range seen {
+			if T == nil && t == nil || T != nil && t != nil && check.identical(T, t) {
+				// talk about "case" rather than "type" because of nil case
+				Ts := "nil"
+				if T != nil {
+					Ts = T.String()
+				}
+				check.errorf(e, "duplicate case %s in type switch", Ts)
+				check.error(pos, "\tprevious case") // secondary error, \t indented
+				continue L
+			}
+		}
+		seen[T] = e.Pos()
+		if T != nil {
+			check.typeAssertion(e.Pos(), x, xtyp, T, strict)
+		}
+	}
+	return
+}
+
+// stmt typechecks statement s.
+func (check *Checker) stmt(ctxt stmtContext, s syntax.Stmt) {
+	// statements must end with the same top scope as they started with
+	if debug {
+		defer func(scope *Scope) {
+			// don't check if code is panicking
+			if p := recover(); p != nil {
+				panic(p)
+			}
+			assert(scope == check.scope)
+		}(check.scope)
+	}
+
+	// process collected function literals before scope changes
+	defer check.processDelayed(len(check.delayed))
+
+	inner := ctxt &^ (fallthroughOk | finalSwitchCase)
+	switch s := s.(type) {
+	case *syntax.EmptyStmt:
+		// ignore
+
+	case *syntax.DeclStmt:
+		check.declStmt(s.DeclList)
+
+	case *syntax.LabeledStmt:
+		check.hasLabel = true
+		check.stmt(ctxt, s.Stmt)
+
+	case *syntax.ExprStmt:
+		// spec: "With the exception of specific built-in functions,
+		// function and method calls and receive operations can appear
+		// in statement context. Such statements may be parenthesized."
+		var x operand
+		kind := check.rawExpr(&x, s.X, nil)
+		var msg string
+		switch x.mode {
+		default:
+			if kind == statement {
+				return
+			}
+			msg = "is not used"
+		case builtin:
+			msg = "must be called"
+		case typexpr:
+			msg = "is not an expression"
+		}
+		check.errorf(&x, "%s %s", &x, msg)
+
+	case *syntax.SendStmt:
+		var ch, x operand
+		check.expr(&ch, s.Chan)
+		check.expr(&x, s.Value)
+		if ch.mode == invalid || x.mode == invalid {
+			return
+		}
+
+		tch := ch.typ.Chan()
+		if tch == nil {
+			check.invalidOpf(s, "cannot send to non-chan type %s", ch.typ)
+			return
+		}
+
+		if tch.dir == RecvOnly {
+			check.invalidOpf(s, "cannot send to receive-only type %s", tch)
+			return
+		}
+
+		check.assignment(&x, tch.elem, "send")
+
+	case *syntax.AssignStmt:
+		lhs := unpackExpr(s.Lhs)
+		rhs := unpackExpr(s.Rhs)
+		if s.Op == 0 || s.Op == syntax.Def {
+			// regular assignment or short variable declaration
+			if len(lhs) == 0 {
+				check.invalidASTf(s, "missing lhs in assignment")
+				return
+			}
+			if s.Op == syntax.Def {
+				check.shortVarDecl(s.Pos(), lhs, rhs)
+			} else {
+				// regular assignment
+				check.assignVars(lhs, rhs)
+			}
+		} else {
+			// assignment operations
+			if len(lhs) != 1 || len(rhs) != 1 {
+				check.errorf(s, "assignment operation %s requires single-valued expressions", s.Op)
+				return
+			}
+
+			// provide better error messages for x++ and x--
+			if rhs[0] == syntax.ImplicitOne {
+				var x operand
+				check.expr(&x, lhs[0])
+				if x.mode == invalid {
+					return
+				}
+				if !isNumeric(x.typ) {
+					check.invalidOpf(lhs[0], "%s%s%s (non-numeric type %s)", lhs[0], s.Op, s.Op, x.typ)
+					return
+				}
+			}
+
+			var x operand
+			check.binary(&x, nil, lhs[0], rhs[0], s.Op)
+			if x.mode == invalid {
+				return
+			}
+			check.assignVar(lhs[0], &x)
+		}
+
+	// case *syntax.GoStmt:
+	// 	check.suspendedCall("go", s.Call)
+
+	// case *syntax.DeferStmt:
+	// 	check.suspendedCall("defer", s.Call)
+	case *syntax.CallStmt:
+		// TODO(gri) get rid of this conversion to string
+		kind := "go"
+		if s.Tok == syntax.Defer {
+			kind = "defer"
+		}
+		check.suspendedCall(kind, s.Call)
+
+	case *syntax.ReturnStmt:
+		res := check.sig.results
+		results := unpackExpr(s.Results)
+		if res.Len() > 0 {
+			// function returns results
+			// (if one, say the first, result parameter is named, all of them are named)
+			if len(results) == 0 && res.vars[0].name != "" {
+				// spec: "Implementation restriction: A compiler may disallow an empty expression
+				// list in a "return" statement if a different entity (constant, type, or variable)
+				// with the same name as a result parameter is in scope at the place of the return."
+				for _, obj := range res.vars {
+					if alt := check.lookup(obj.name); alt != nil && alt != obj {
+						check.errorf(s, "result parameter %s not in scope at return", obj.name)
+						check.errorf(alt, "\tinner declaration of %s", obj)
+						// ok to continue
+					}
+				}
+			} else {
+				// return has results or result parameters are unnamed
+				check.initVars(res.vars, results, s.Pos())
+			}
+		} else if len(results) > 0 {
+			check.error(results[0], "no result values expected")
+			check.use(results...)
+		}
+
+	case *syntax.BranchStmt:
+		if s.Label != nil {
+			check.hasLabel = true
+			return // checked in 2nd pass (check.labels)
+		}
+		switch s.Tok {
+		case syntax.Break:
+			if ctxt&breakOk == 0 {
+				check.error(s, "break not in for, switch, or select statement")
+			}
+		case syntax.Continue:
+			if ctxt&continueOk == 0 {
+				check.error(s, "continue not in for statement")
+			}
+		case syntax.Fallthrough:
+			if ctxt&fallthroughOk == 0 {
+				msg := "fallthrough statement out of place"
+				if ctxt&finalSwitchCase != 0 {
+					msg = "cannot fallthrough final case in switch"
+				}
+				check.error(s, msg)
+			}
+		default:
+			check.invalidASTf(s, "branch statement: %s", s.Tok)
+		}
+
+	case *syntax.BlockStmt:
+		check.openScope(s, "block")
+		defer check.closeScope()
+
+		check.stmtList(inner, s.List)
+
+	case *syntax.IfStmt:
+		check.openScope(s, "if")
+		defer check.closeScope()
+
+		check.simpleStmt(s.Init)
+		var x operand
+		check.expr(&x, s.Cond)
+		if x.mode != invalid && !isBoolean(x.typ) {
+			check.error(s.Cond, "non-boolean condition in if statement")
+		}
+		check.stmt(inner, s.Then)
+		// The parser produces a correct AST but if it was modified
+		// elsewhere the else branch may be invalid. Check again.
+		switch s.Else.(type) {
+		case nil:
+			// valid or error already reported
+		case *syntax.IfStmt, *syntax.BlockStmt:
+			check.stmt(inner, s.Else)
+		default:
+			check.error(s.Else, "invalid else branch in if statement")
+		}
+
+	case *syntax.SwitchStmt:
+		inner |= breakOk
+		check.openScope(s, "switch")
+		defer check.closeScope()
+
+		check.simpleStmt(s.Init)
+
+		if g, _ := s.Tag.(*syntax.TypeSwitchGuard); g != nil {
+			check.typeSwitchStmt(inner, s, g)
+		} else {
+			check.switchStmt(inner, s)
+		}
+
+	case *syntax.SelectStmt:
+		inner |= breakOk
+
+		check.multipleSelectDefaults(s.Body)
+
+		for _, clause := range s.Body {
+			if clause == nil {
+				continue // error reported before
+			}
+
+			// clause.Comm must be a SendStmt, RecvStmt, or default case
+			valid := false
+			var rhs syntax.Expr // rhs of RecvStmt, or nil
+			switch s := clause.Comm.(type) {
+			case nil, *syntax.SendStmt:
+				valid = true
+			case *syntax.AssignStmt:
+				if _, ok := s.Rhs.(*syntax.ListExpr); !ok {
+					rhs = s.Rhs
+				}
+			case *syntax.ExprStmt:
+				rhs = s.X
+			}
+
+			// if present, rhs must be a receive operation
+			if rhs != nil {
+				if x, _ := unparen(rhs).(*syntax.Operation); x != nil && x.Y == nil && x.Op == syntax.Recv {
+					valid = true
+				}
+			}
+
+			if !valid {
+				check.error(clause.Comm, "select case must be send or receive (possibly with assignment)")
+				continue
+			}
+
+			check.openScope(s, "case")
+			if clause.Comm != nil {
+				check.stmt(inner, clause.Comm)
+			}
+			check.stmtList(inner, clause.Body)
+			check.closeScope()
+		}
+
+	case *syntax.ForStmt:
+		inner |= breakOk | continueOk
+		check.openScope(s, "for")
+		defer check.closeScope()
+
+		if rclause, _ := s.Init.(*syntax.RangeClause); rclause != nil {
+			check.rangeStmt(inner, s, rclause)
+			break
+		}
+
+		check.simpleStmt(s.Init)
+		if s.Cond != nil {
+			var x operand
+			check.expr(&x, s.Cond)
+			if x.mode != invalid && !isBoolean(x.typ) {
+				check.error(s.Cond, "non-boolean condition in for statement")
+			}
+		}
+		check.simpleStmt(s.Post)
+		// spec: "The init statement may be a short variable
+		// declaration, but the post statement must not."
+		if s, _ := s.Post.(*syntax.AssignStmt); s != nil && s.Op == syntax.Def {
+			// The parser already reported an error.
+			// Don't call useLHS here because we want to use the lhs in
+			// this erroneous statement so that we don't get errors about
+			// these lhs variables being declared but not used.
+			check.use(s.Lhs) // avoid follow-up errors
+		}
+		check.stmt(inner, s.Body)
+
+	default:
+		check.error(s, "invalid statement")
+	}
+}
+
+func newName(pos syntax.Pos, value string) *syntax.Name {
+	n := new(syntax.Name)
+	// TODO(gri) why does this not work?
+	//n.pos = pos
+	n.Value = value
+	return n
+}
+
+func (check *Checker) switchStmt(inner stmtContext, s *syntax.SwitchStmt) {
+	// init statement already handled
+
+	var x operand
+	if s.Tag != nil {
+		check.expr(&x, s.Tag)
+		// By checking assignment of x to an invisible temporary
+		// (as a compiler would), we get all the relevant checks.
+		check.assignment(&x, nil, "switch expression")
+	} else {
+		// spec: "A missing switch expression is
+		// equivalent to the boolean value true."
+		x.mode = constant_
+		x.typ = Typ[Bool]
+		x.val = constant.MakeBool(true)
+		// TODO(gri) should have a better position here
+		pos := s.Rbrace
+		if len(s.Body) > 0 {
+			pos = s.Body[0].Pos()
+		}
+		x.expr = newName(pos, "true")
+	}
+
+	check.multipleSwitchDefaults(s.Body)
+
+	seen := make(valueMap) // map of seen case values to positions and types
+	for i, clause := range s.Body {
+		if clause == nil {
+			check.invalidASTf(clause, "incorrect expression switch case")
+			continue
+		}
+		check.caseValues(&x, unpackExpr(clause.Cases), seen)
+		check.openScope(clause, "case")
+		inner := inner
+		if i+1 < len(s.Body) {
+			inner |= fallthroughOk
+		} else {
+			inner |= finalSwitchCase
+		}
+		check.stmtList(inner, clause.Body)
+		check.closeScope()
+	}
+}
+
+func (check *Checker) typeSwitchStmt(inner stmtContext, s *syntax.SwitchStmt, guard *syntax.TypeSwitchGuard) {
+	// init statement already handled
+
+	// A type switch guard must be of the form:
+	//
+	//     TypeSwitchGuard = [ identifier ":=" ] PrimaryExpr "." "(" "type" ")" .
+	//                          \__lhs__/        \___rhs___/
+
+	// check lhs, if any
+	lhs := guard.Lhs
+	if lhs != nil {
+		if lhs.Value == "_" {
+			// _ := x.(type) is an invalid short variable declaration
+			check.softErrorf(lhs, "no new variable on left side of :=")
+			lhs = nil // avoid declared but not used error below
+		} else {
+			check.recordDef(lhs, nil) // lhs variable is implicitly declared in each cause clause
+		}
+	}
+
+	// check rhs
+	var x operand
+	check.expr(&x, guard.X)
+	if x.mode == invalid {
+		return
+	}
+	var xtyp *Interface
+	var strict bool
+	switch t := x.typ.Under().(type) {
+	case *Interface:
+		xtyp = t
+	// Disabled for now. See comment in the implementation of type assertions (expr.go).
+	// case *TypeParam:
+	// 	xtyp = t.Bound()
+	// 	strict = true
+	default:
+		check.errorf(&x, "%s is not an interface or generic type", &x)
+		return
+	}
+
+	check.multipleSwitchDefaults(s.Body)
+
+	var lhsVars []*Var                // list of implicitly declared lhs variables
+	seen := make(map[Type]syntax.Pos) // map of seen types to positions
+	for _, clause := range s.Body {
+		if clause == nil {
+			check.invalidASTf(s, "incorrect type switch case")
+			continue
+		}
+		// Check each type in this type switch case.
+		cases := unpackExpr(clause.Cases)
+		T := check.caseTypes(&x, xtyp, cases, seen, strict)
+		check.openScope(clause, "case")
+		// If lhs exists, declare a corresponding variable in the case-local scope.
+		if lhs != nil {
+			// spec: "The TypeSwitchGuard may include a short variable declaration.
+			// When that form is used, the variable is declared at the beginning of
+			// the implicit block in each clause. In clauses with a case listing
+			// exactly one type, the variable has that type; otherwise, the variable
+			// has the type of the expression in the TypeSwitchGuard."
+			if len(cases) != 1 || T == nil {
+				T = x.typ
+			}
+			obj := NewVar(lhs.Pos(), check.pkg, lhs.Value, T)
+			scopePos := clause.Pos() // for default clause (len(List) == 0)
+			if n := len(cases); n > 0 {
+				scopePos = endPos(cases[n-1])
+			}
+			check.declare(check.scope, nil, obj, scopePos)
+			check.recordImplicit(clause, obj)
+			// For the "declared but not used" error, all lhs variables act as
+			// one; i.e., if any one of them is 'used', all of them are 'used'.
+			// Collect them for later analysis.
+			lhsVars = append(lhsVars, obj)
+		}
+		check.stmtList(inner, clause.Body)
+		check.closeScope()
+	}
+
+	// If lhs exists, we must have at least one lhs variable that was used.
+	if lhs != nil {
+		var used bool
+		for _, v := range lhsVars {
+			if v.used {
+				used = true
+			}
+			v.used = true // avoid usage error when checking entire function
+		}
+		if !used {
+			check.softErrorf(lhs, "%s declared but not used", lhs.Value)
+		}
+	}
+}
+
+func (check *Checker) rangeStmt(inner stmtContext, s *syntax.ForStmt, rclause *syntax.RangeClause) {
+	// scope already opened
+
+	// check expression to iterate over
+	var x operand
+	check.expr(&x, rclause.X)
+
+	// determine lhs, if any
+	sKey := rclause.Lhs // possibly nil
+	var sValue syntax.Expr
+	if p, _ := sKey.(*syntax.ListExpr); p != nil {
+		if len(p.ElemList) != 2 {
+			check.invalidASTf(s, "invalid lhs in range clause")
+			return
+		}
+		sKey = p.ElemList[0]
+		sValue = p.ElemList[1]
+	}
+
+	// determine key/value types
+	var key, val Type
+	if x.mode != invalid {
+		typ := optype(x.typ.Under())
+		if _, ok := typ.(*Chan); ok && sValue != nil {
+			// TODO(gri) this also needs to happen for channels in generic variables
+			check.softErrorf(sValue, "range over %s permits only one iteration variable", &x)
+			// ok to continue
+		}
+		var msg string
+		key, val, msg = rangeKeyVal(typ, isVarName(sKey), isVarName(sValue))
+		if key == nil || msg != "" {
+			if msg != "" {
+				msg = ": " + msg
+			}
+			check.softErrorf(&x, "cannot range over %s%s", &x, msg)
+			// ok to continue
+		}
+	}
+
+	// check assignment to/declaration of iteration variables
+	// (irregular assignment, cannot easily map to existing assignment checks)
+
+	// lhs expressions and initialization value (rhs) types
+	lhs := [2]syntax.Expr{sKey, sValue}
+	rhs := [2]Type{key, val} // key, val may be nil
+
+	if rclause.Def {
+		// short variable declaration; variable scope starts after the range clause
+		// (the for loop opens a new scope, so variables on the lhs never redeclare
+		// previously declared variables)
+		var vars []*Var
+		for i, lhs := range lhs {
+			if lhs == nil {
+				continue
+			}
+
+			// determine lhs variable
+			var obj *Var
+			if ident, _ := lhs.(*syntax.Name); ident != nil {
+				// declare new variable
+				name := ident.Value
+				obj = NewVar(ident.Pos(), check.pkg, name, nil)
+				check.recordDef(ident, obj)
+				// _ variables don't count as new variables
+				if name != "_" {
+					vars = append(vars, obj)
+				}
+			} else {
+				check.errorf(lhs, "cannot declare %s", lhs)
+				obj = NewVar(lhs.Pos(), check.pkg, "_", nil) // dummy variable
+			}
+
+			// initialize lhs variable
+			if typ := rhs[i]; typ != nil {
+				x.mode = value
+				x.expr = lhs // we don't have a better rhs expression to use here
+				x.typ = typ
+				check.initVar(obj, &x, "range clause")
+			} else {
+				obj.typ = Typ[Invalid]
+				obj.used = true // don't complain about unused variable
+			}
+		}
+
+		// declare variables
+		if len(vars) > 0 {
+			scopePos := endPos(rclause.X) // TODO(gri) should this just be s.Body.Pos (spec clarification)?
+			for _, obj := range vars {
+				// spec: "The scope of a constant or variable identifier declared inside
+				// a function begins at the end of the ConstSpec or VarSpec (ShortVarDecl
+				// for short variable declarations) and ends at the end of the innermost
+				// containing block."
+				check.declare(check.scope, nil /* recordDef already called */, obj, scopePos)
+			}
+		} else {
+			check.error(s, "no new variables on left side of :=")
+		}
+	} else {
+		// ordinary assignment
+		for i, lhs := range lhs {
+			if lhs == nil {
+				continue
+			}
+			if typ := rhs[i]; typ != nil {
+				x.mode = value
+				x.expr = lhs // we don't have a better rhs expression to use here
+				x.typ = typ
+				check.assignVar(lhs, &x)
+			}
+		}
+	}
+
+	check.stmt(inner, s.Body)
+}
+
+// isVarName reports whether x is a non-nil, non-blank (_) expression.
+func isVarName(x syntax.Expr) bool {
+	if x == nil {
+		return false
+	}
+	ident, _ := unparen(x).(*syntax.Name)
+	return ident == nil || ident.Value != "_"
+}
+
+// rangeKeyVal returns the key and value type produced by a range clause
+// over an expression of type typ, and possibly an error message. If the
+// range clause is not permitted the returned key is nil or msg is not
+// empty (in that case we still may have a non-nil key type which can be
+// used to reduce the chance for follow-on errors).
+// The wantKey, wantVal, and hasVal flags indicate which of the iteration
+// variables are used or present; this matters if we range over a generic
+// type where not all keys or values are of the same type.
+func rangeKeyVal(typ Type, wantKey, wantVal bool) (Type, Type, string) {
+	switch typ := typ.(type) {
+	case *Basic:
+		if isString(typ) {
+			return Typ[Int], universeRune, "" // use 'rune' name
+		}
+	case *Array:
+		return Typ[Int], typ.elem, ""
+	case *Slice:
+		return Typ[Int], typ.elem, ""
+	case *Pointer:
+		if typ := typ.base.Array(); typ != nil {
+			return Typ[Int], typ.elem, ""
+		}
+	case *Map:
+		return typ.key, typ.elem, ""
+	case *Chan:
+		var msg string
+		if typ.dir == SendOnly {
+			msg = "send-only channel"
+		}
+		return typ.elem, Typ[Invalid], msg
+	case *Sum:
+		first := true
+		var key, val Type
+		var msg string
+		typ.is(func(t Type) bool {
+			k, v, m := rangeKeyVal(t.Under(), wantKey, wantVal)
+			if k == nil || m != "" {
+				key, val, msg = k, v, m
+				return false
+			}
+			if first {
+				key, val, msg = k, v, m
+				first = false
+				return true
+			}
+			if wantKey && !Identical(key, k) {
+				key, val, msg = nil, nil, "all possible values must have the same key type"
+				return false
+			}
+			if wantVal && !Identical(val, v) {
+				key, val, msg = nil, nil, "all possible values must have the same element type"
+				return false
+			}
+			return true
+		})
+		return key, val, msg
+	}
+	return nil, nil, ""
+}
diff --git a/src/cmd/compile/internal/types2/subst.go b/src/cmd/compile/internal/types2/subst.go
new file mode 100644
index 0000000000..27c907de10
--- /dev/null
+++ b/src/cmd/compile/internal/types2/subst.go
@@ -0,0 +1,554 @@
+// UNREVIEWED
+// Copyright 2018 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.
+
+// This file implements instantiation of generic types
+// through substitution of type parameters by actual
+// types.
+
+package types2
+
+import (
+	"bytes"
+	"cmd/compile/internal/syntax"
+	"fmt"
+)
+
+type substMap struct {
+	// The targs field is currently needed for *Named type substitution.
+	// TODO(gri) rewrite that code, get rid of this field, and make this
+	//           struct just the map (proj)
+	targs []Type
+	proj  map[*TypeParam]Type
+}
+
+// makeSubstMap creates a new substitution map mapping tpars[i] to targs[i].
+// If targs[i] is nil, tpars[i] is not substituted.
+func makeSubstMap(tpars []*TypeName, targs []Type) *substMap {
+	assert(len(tpars) == len(targs))
+	proj := make(map[*TypeParam]Type, len(tpars))
+	for i, tpar := range tpars {
+		// We must expand type arguments otherwise *Instance
+		// types end up as components in composite types.
+		// TODO(gri) explain why this causes problems, if it does
+		targ := expand(targs[i]) // possibly nil
+		targs[i] = targ
+		proj[tpar.typ.(*TypeParam)] = targ
+	}
+	return &substMap{targs, proj}
+}
+
+func (m *substMap) String() string {
+	return fmt.Sprintf("%s", m.proj)
+}
+
+func (m *substMap) empty() bool {
+	return len(m.proj) == 0
+}
+
+func (m *substMap) lookup(tpar *TypeParam) Type {
+	if t := m.proj[tpar]; t != nil {
+		return t
+	}
+	return tpar
+}
+
+func (check *Checker) instantiate(pos syntax.Pos, typ Type, targs []Type, poslist []syntax.Pos) (res Type) {
+	if check.conf.Trace {
+		check.trace(pos, "-- instantiating %s with %s", typ, typeListString(targs))
+		check.indent++
+		defer func() {
+			check.indent--
+			var under Type
+			if res != nil {
+				// Calling Under() here may lead to endless instantiations.
+				// Test case: type T[P any] T[P]
+				// TODO(gri) investigate if that's a bug or to be expected.
+				under = res.Underlying()
+			}
+			check.trace(pos, "=> %s (under = %s)", res, under)
+		}()
+	}
+
+	assert(poslist == nil || len(poslist) <= len(targs))
+
+	// TODO(gri) What is better here: work with TypeParams, or work with TypeNames?
+	var tparams []*TypeName
+	switch t := typ.(type) {
+	case *Named:
+		tparams = t.tparams
+	case *Signature:
+		tparams = t.tparams
+		defer func() {
+			// If we had an unexpected failure somewhere don't
+			// panic below when asserting res.(*Signature).
+			if res == nil {
+				return
+			}
+			// If the signature doesn't use its type parameters, subst
+			// will not make a copy. In that case, make a copy now (so
+			// we can set tparams to nil w/o causing side-effects).
+			if t == res {
+				copy := *t
+				res = &copy
+			}
+			// After instantiating a generic signature, it is not generic
+			// anymore; we need to set tparams to nil.
+			res.(*Signature).tparams = nil
+		}()
+
+	default:
+		check.dump("%v: cannot instantiate %v", pos, typ)
+		unreachable() // only defined types and (defined) functions can be generic
+
+	}
+
+	// the number of supplied types must match the number of type parameters
+	if len(targs) != len(tparams) {
+		// TODO(gri) provide better error message
+		check.errorf(pos, "got %d arguments but %d type parameters", len(targs), len(tparams))
+		return Typ[Invalid]
+	}
+
+	if len(tparams) == 0 {
+		return typ // nothing to do (minor optimization)
+	}
+
+	smap := makeSubstMap(tparams, targs)
+
+	// check bounds
+	for i, tname := range tparams {
+		tpar := tname.typ.(*TypeParam)
+		iface := tpar.Bound()
+		if iface.Empty() {
+			continue // no type bound
+		}
+
+		targ := targs[i]
+
+		// best position for error reporting
+		pos := pos
+		if i < len(poslist) {
+			pos = poslist[i]
+		}
+
+		// The type parameter bound is parameterized with the same type parameters
+		// as the instantiated type; before we can use it for bounds checking we
+		// need to instantiate it with the type arguments with which we instantiate
+		// the parameterized type.
+		iface = check.subst(pos, iface, smap).(*Interface)
+
+		// targ must implement iface (methods)
+		// - check only if we have methods
+		check.completeInterface(nopos, iface)
+		if len(iface.allMethods) > 0 {
+			// If the type argument is a type parameter itself, its pointer designation
+			// must match the pointer designation of the callee's type parameter.
+			// If the type argument is a pointer to a type parameter, the type argument's
+			// method set is empty.
+			// TODO(gri) is this what we want? (spec question)
+			if tparg := targ.TypeParam(); tparg != nil {
+				if tparg.ptr != tpar.ptr {
+					check.errorf(pos, "pointer designation mismatch")
+					break
+				}
+			} else if base, isPtr := deref(targ); isPtr && base.TypeParam() != nil {
+				check.errorf(pos, "%s has no methods", targ)
+				break
+			}
+			// If a type parameter is marked as a pointer type, the type bound applies
+			// to a pointer of the type argument.
+			actual := targ
+			if tpar.ptr {
+				actual = NewPointer(targ)
+			}
+			if m, wrong := check.missingMethod(actual, iface, true); m != nil {
+				// TODO(gri) needs to print updated name to avoid major confusion in error message!
+				//           (print warning for now)
+				// check.softErrorf(pos, "%s does not satisfy %s (warning: name not updated) = %s (missing method %s)", targ, tpar.bound, iface, m)
+				if m.name == "==" {
+					// We don't want to report "missing method ==".
+					check.softErrorf(pos, "%s does not satisfy comparable", targ)
+				} else if wrong != nil {
+					// TODO(gri) This can still report uninstantiated types which makes the error message
+					//           more difficult to read then necessary.
+					check.softErrorf(pos,
+						"%s does not satisfy %s: wrong method signature\n\tgot  %s\n\twant %s",
+						targ, tpar.bound, wrong, m,
+					)
+				} else {
+					check.softErrorf(pos, "%s does not satisfy %s (missing method %s)", targ, tpar.bound, m.name)
+				}
+				break
+			}
+		}
+
+		// targ's underlying type must also be one of the interface types listed, if any
+		if iface.allTypes == nil {
+			continue // nothing to do
+		}
+		// iface.allTypes != nil
+
+		// If targ is itself a type parameter, each of its possible types, but at least one, must be in the
+		// list of iface types (i.e., the targ type list must be a non-empty subset of the iface types).
+		if targ := targ.TypeParam(); targ != nil {
+			targBound := targ.Bound()
+			if targBound.allTypes == nil {
+				check.softErrorf(pos, "%s does not satisfy %s (%s has no type constraints)", targ, tpar.bound, targ)
+				break
+			}
+			for _, t := range unpack(targBound.allTypes) {
+				if !iface.isSatisfiedBy(t.Under()) {
+					// TODO(gri) match this error message with the one below (or vice versa)
+					check.softErrorf(pos, "%s does not satisfy %s (%s type constraint %s not found in %s)", targ, tpar.bound, targ, t, iface.allTypes)
+					break
+				}
+			}
+			break
+		}
+
+		// Otherwise, targ's type or underlying type must also be one of the interface types listed, if any.
+		if !iface.isSatisfiedBy(targ) {
+			check.softErrorf(pos, "%s does not satisfy %s (%s not found in %s)", targ, tpar.bound, targ.Under(), iface.allTypes)
+			break
+		}
+	}
+
+	return check.subst(pos, typ, smap)
+}
+
+// subst returns the type typ with its type parameters tpars replaced by
+// the corresponding type arguments targs, recursively.
+// subst is functional in the sense that it doesn't modify the incoming
+// type. If a substitution took place, the result type is different from
+// from the incoming type.
+func (check *Checker) subst(pos syntax.Pos, typ Type, smap *substMap) Type {
+	if smap.empty() {
+		return typ
+	}
+
+	// common cases
+	switch t := typ.(type) {
+	case *Basic:
+		return typ // nothing to do
+	case *TypeParam:
+		return smap.lookup(t)
+	}
+
+	// general case
+	subst := subster{check, pos, make(map[Type]Type), smap}
+	return subst.typ(typ)
+}
+
+type subster struct {
+	check *Checker
+	pos   syntax.Pos
+	cache map[Type]Type
+	smap  *substMap
+}
+
+func (subst *subster) typ(typ Type) Type {
+	switch t := typ.(type) {
+	case nil:
+		// Call typOrNil if it's possible that typ is nil.
+		panic("nil typ")
+
+	case *Basic, *bottom, *top:
+		// nothing to do
+
+	case *Array:
+		elem := subst.typOrNil(t.elem)
+		if elem != t.elem {
+			return &Array{len: t.len, elem: elem}
+		}
+
+	case *Slice:
+		elem := subst.typOrNil(t.elem)
+		if elem != t.elem {
+			return &Slice{elem: elem}
+		}
+
+	case *Struct:
+		if fields, copied := subst.varList(t.fields); copied {
+			return &Struct{fields: fields, tags: t.tags}
+		}
+
+	case *Pointer:
+		base := subst.typ(t.base)
+		if base != t.base {
+			return &Pointer{base: base}
+		}
+
+	case *Tuple:
+		return subst.tuple(t)
+
+	case *Signature:
+		// TODO(gri) rethink the recv situation with respect to methods on parameterized types
+		// recv := subst.var_(t.recv) // TODO(gri) this causes a stack overflow - explain
+		recv := t.recv
+		params := subst.tuple(t.params)
+		results := subst.tuple(t.results)
+		if recv != t.recv || params != t.params || results != t.results {
+			return &Signature{
+				rparams:  t.rparams,
+				tparams:  t.tparams,
+				scope:    t.scope,
+				recv:     recv,
+				params:   params,
+				results:  results,
+				variadic: t.variadic,
+			}
+		}
+
+	case *Sum:
+		types, copied := subst.typeList(t.types)
+		if copied {
+			// Don't do it manually, with a Sum literal: the new
+			// types list may not be unique and NewSum may remove
+			// duplicates.
+			return NewSum(types)
+		}
+
+	case *Interface:
+		methods, mcopied := subst.funcList(t.methods)
+		types := t.types
+		if t.types != nil {
+			types = subst.typ(t.types)
+		}
+		embeddeds, ecopied := subst.typeList(t.embeddeds)
+		if mcopied || types != t.types || ecopied {
+			iface := &Interface{methods: methods, types: types, embeddeds: embeddeds}
+			subst.check.posMap[iface] = subst.check.posMap[t] // satisfy completeInterface requirement
+			subst.check.completeInterface(nopos, iface)
+			return iface
+		}
+
+	case *Map:
+		key := subst.typ(t.key)
+		elem := subst.typ(t.elem)
+		if key != t.key || elem != t.elem {
+			return &Map{key: key, elem: elem}
+		}
+
+	case *Chan:
+		elem := subst.typ(t.elem)
+		if elem != t.elem {
+			return &Chan{dir: t.dir, elem: elem}
+		}
+
+	case *Named:
+		subst.check.indent++
+		defer func() {
+			subst.check.indent--
+		}()
+		dump := func(format string, args ...interface{}) {
+			if subst.check.conf.Trace {
+				subst.check.trace(subst.pos, format, args...)
+			}
+		}
+
+		if t.tparams == nil {
+			dump(">>> %s is not parameterized", t)
+			return t // type is not parameterized
+		}
+
+		var new_targs []Type
+
+		if len(t.targs) > 0 {
+
+			// already instantiated
+			dump(">>> %s already instantiated", t)
+			assert(len(t.targs) == len(t.tparams))
+			// For each (existing) type argument targ, determine if it needs
+			// to be substituted; i.e., if it is or contains a type parameter
+			// that has a type argument for it.
+			for i, targ := range t.targs {
+				dump(">>> %d targ = %s", i, targ)
+				new_targ := subst.typ(targ)
+				if new_targ != targ {
+					dump(">>> substituted %d targ %s => %s", i, targ, new_targ)
+					if new_targs == nil {
+						new_targs = make([]Type, len(t.tparams))
+						copy(new_targs, t.targs)
+					}
+					new_targs[i] = new_targ
+				}
+			}
+
+			if new_targs == nil {
+				dump(">>> nothing to substitute in %s", t)
+				return t // nothing to substitute
+			}
+
+		} else {
+
+			// not yet instantiated
+			dump(">>> first instantiation of %s", t)
+			new_targs = subst.smap.targs
+
+		}
+
+		// before creating a new named type, check if we have this one already
+		h := instantiatedHash(t, new_targs)
+		dump(">>> new type hash: %s", h)
+		if named, found := subst.check.typMap[h]; found {
+			dump(">>> found %s", named)
+			subst.cache[t] = named
+			return named
+		}
+
+		// create a new named type and populate caches to avoid endless recursion
+		tname := NewTypeName(subst.pos, t.obj.pkg, t.obj.name, nil)
+		named := subst.check.NewNamed(tname, t.underlying, t.methods) // method signatures are updated lazily
+		named.tparams = t.tparams                                     // new type is still parameterized
+		named.targs = new_targs
+		subst.check.typMap[h] = named
+		subst.cache[t] = named
+
+		// do the substitution
+		dump(">>> subst %s with %s (new: %s)", t.underlying, subst.smap, new_targs)
+		named.underlying = subst.typOrNil(t.underlying)
+		named.orig = named.underlying // for cycle detection (Checker.validType)
+
+		return named
+
+	case *TypeParam:
+		return subst.smap.lookup(t)
+
+	case *instance:
+		// TODO(gri) can we avoid the expansion here and just substitute the type parameters?
+		return subst.typ(t.expand())
+
+	default:
+		unimplemented()
+	}
+
+	return typ
+}
+
+// TODO(gri) Eventually, this should be more sophisticated.
+//           It won't work correctly for locally declared types.
+func instantiatedHash(typ *Named, targs []Type) string {
+	var buf bytes.Buffer
+	writeTypeName(&buf, typ.obj, nil)
+	buf.WriteByte('(')
+	writeTypeList(&buf, targs, nil, nil)
+	buf.WriteByte(')')
+
+	// With respect to the represented type, whether a
+	// type is fully expanded or stored as instance
+	// does not matter - they are the same types.
+	// Remove the instanceMarkers printed for instances.
+	res := buf.Bytes()
+	i := 0
+	for _, b := range res {
+		if b != instanceMarker {
+			res[i] = b
+			i++
+		}
+	}
+
+	return string(res[:i])
+}
+
+func typeListString(list []Type) string {
+	var buf bytes.Buffer
+	writeTypeList(&buf, list, nil, nil)
+	return buf.String()
+}
+
+// typOrNil is like typ but if the argument is nil it is replaced with Typ[Invalid].
+// A nil type may appear in pathological cases such as type T[P any] []func(_ T([]_))
+// where an array/slice element is accessed before it is set up.
+func (subst *subster) typOrNil(typ Type) Type {
+	if typ == nil {
+		return Typ[Invalid]
+	}
+	return subst.typ(typ)
+}
+
+func (subst *subster) var_(v *Var) *Var {
+	if v != nil {
+		if typ := subst.typ(v.typ); typ != v.typ {
+			copy := *v
+			copy.typ = typ
+			return &copy
+		}
+	}
+	return v
+}
+
+func (subst *subster) tuple(t *Tuple) *Tuple {
+	if t != nil {
+		if vars, copied := subst.varList(t.vars); copied {
+			return &Tuple{vars: vars}
+		}
+	}
+	return t
+}
+
+func (subst *subster) varList(in []*Var) (out []*Var, copied bool) {
+	out = in
+	for i, v := range in {
+		if w := subst.var_(v); w != v {
+			if !copied {
+				// first variable that got substituted => allocate new out slice
+				// and copy all variables
+				new := make([]*Var, len(in))
+				copy(new, out)
+				out = new
+				copied = true
+			}
+			out[i] = w
+		}
+	}
+	return
+}
+
+func (subst *subster) func_(f *Func) *Func {
+	if f != nil {
+		if typ := subst.typ(f.typ); typ != f.typ {
+			copy := *f
+			copy.typ = typ
+			return &copy
+		}
+	}
+	return f
+}
+
+func (subst *subster) funcList(in []*Func) (out []*Func, copied bool) {
+	out = in
+	for i, f := range in {
+		if g := subst.func_(f); g != f {
+			if !copied {
+				// first function that got substituted => allocate new out slice
+				// and copy all functions
+				new := make([]*Func, len(in))
+				copy(new, out)
+				out = new
+				copied = true
+			}
+			out[i] = g
+		}
+	}
+	return
+}
+
+func (subst *subster) typeList(in []Type) (out []Type, copied bool) {
+	out = in
+	for i, t := range in {
+		if u := subst.typ(t); u != t {
+			if !copied {
+				// first function that got substituted => allocate new out slice
+				// and copy all functions
+				new := make([]Type, len(in))
+				copy(new, out)
+				out = new
+				copied = true
+			}
+			out[i] = u
+		}
+	}
+	return
+}
diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
new file mode 100644
index 0000000000..c26d243f3c
--- /dev/null
+++ b/src/cmd/compile/internal/types2/type.go
@@ -0,0 +1,1061 @@
+// UNREVIEWED
+// Copyright 2011 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 types2
+
+import (
+	"cmd/compile/internal/syntax"
+	"fmt"
+	"sort"
+)
+
+// A Type represents a type of Go.
+// All types implement the Type interface.
+type Type interface {
+	// Underlying returns the underlying type of a type
+	// w/o following forwarding chains. Only used by
+	// client packages (here for backward-compatibility).
+	Underlying() Type
+
+	// Under returns the true expanded underlying type.
+	// If it doesn't exist, the result is Typ[Invalid].
+	// Under must only be called when a type is known
+	// to be fully set up.
+	Under() Type
+
+	// String returns a string representation of a type.
+	String() string
+
+	// Converters
+	// A converter must only be called when a type is
+	// known to be fully set up. A converter returns
+	// a type's operational type (see comment for optype)
+	// or nil if the type is receiver is not of the
+	// respective type.
+	Basic() *Basic
+	Array() *Array
+	Slice() *Slice
+	Struct() *Struct
+	Pointer() *Pointer
+	Tuple() *Tuple
+	Signature() *Signature
+	Sum() *Sum
+	Interface() *Interface
+	Map() *Map
+	Chan() *Chan
+
+	// If the receiver for Named and TypeParam is of
+	// the respective type (possibly after unpacking
+	// an instance type), these methods return that
+	// type. Otherwise the result is nil.
+	Named() *Named
+	TypeParam() *TypeParam
+}
+
+// aType implements default type behavior
+type aType struct{}
+
+// These methods must be implemented by each type.
+func (aType) Underlying() Type { panic("unreachable") }
+func (aType) Under() Type      { panic("unreachable") }
+func (aType) String() string   { panic("unreachable") }
+
+// Each type is implementing its version of these methods
+// (Basic must implement Basic, etc.), the other methods
+// are inherited.
+func (aType) Basic() *Basic         { return nil }
+func (aType) Array() *Array         { return nil }
+func (aType) Slice() *Slice         { return nil }
+func (aType) Struct() *Struct       { return nil }
+func (aType) Pointer() *Pointer     { return nil }
+func (aType) Tuple() *Tuple         { return nil }
+func (aType) Signature() *Signature { return nil }
+func (aType) Sum() *Sum             { return nil }
+func (aType) Interface() *Interface { return nil }
+func (aType) Map() *Map             { return nil }
+func (aType) Chan() *Chan           { return nil }
+
+func (aType) Named() *Named         { return nil }
+func (aType) TypeParam() *TypeParam { return nil }
+
+// BasicKind describes the kind of basic type.
+type BasicKind int
+
+const (
+	Invalid BasicKind = iota // type is invalid
+
+	// predeclared types
+	Bool
+	Int
+	Int8
+	Int16
+	Int32
+	Int64
+	Uint
+	Uint8
+	Uint16
+	Uint32
+	Uint64
+	Uintptr
+	Float32
+	Float64
+	Complex64
+	Complex128
+	String
+	UnsafePointer
+
+	// types for untyped values
+	UntypedBool
+	UntypedInt
+	UntypedRune
+	UntypedFloat
+	UntypedComplex
+	UntypedString
+	UntypedNil
+
+	// aliases
+	Byte = Uint8
+	Rune = Int32
+)
+
+// BasicInfo is a set of flags describing properties of a basic type.
+type BasicInfo int
+
+// Properties of basic types.
+const (
+	IsBoolean BasicInfo = 1 << iota
+	IsInteger
+	IsUnsigned
+	IsFloat
+	IsComplex
+	IsString
+	IsUntyped
+
+	IsOrdered   = IsInteger | IsFloat | IsString
+	IsNumeric   = IsInteger | IsFloat | IsComplex
+	IsConstType = IsBoolean | IsNumeric | IsString
+)
+
+// A Basic represents a basic type.
+type Basic struct {
+	kind BasicKind
+	info BasicInfo
+	name string
+	aType
+}
+
+// Kind returns the kind of basic type b.
+func (b *Basic) Kind() BasicKind { return b.kind }
+
+// Info returns information about properties of basic type b.
+func (b *Basic) Info() BasicInfo { return b.info }
+
+// Name returns the name of basic type b.
+func (b *Basic) Name() string { return b.name }
+
+// An Array represents an array type.
+type Array struct {
+	len  int64
+	elem Type
+	aType
+}
+
+// NewArray returns a new array type for the given element type and length.
+// A negative length indicates an unknown length.
+func NewArray(elem Type, len int64) *Array { return &Array{len: len, elem: elem} }
+
+// Len returns the length of array a.
+// A negative result indicates an unknown length.
+func (a *Array) Len() int64 { return a.len }
+
+// Elem returns element type of array a.
+func (a *Array) Elem() Type { return a.elem }
+
+// A Slice represents a slice type.
+type Slice struct {
+	elem Type
+	aType
+}
+
+// NewSlice returns a new slice type for the given element type.
+func NewSlice(elem Type) *Slice { return &Slice{elem: elem} }
+
+// Elem returns the element type of slice s.
+func (s *Slice) Elem() Type { return s.elem }
+
+// A Struct represents a struct type.
+type Struct struct {
+	fields []*Var
+	tags   []string // field tags; nil if there are no tags
+	aType
+}
+
+// NewStruct returns a new struct with the given fields and corresponding field tags.
+// If a field with index i has a tag, tags[i] must be that tag, but len(tags) may be
+// only as long as required to hold the tag with the largest index i. Consequently,
+// if no field has a tag, tags may be nil.
+func NewStruct(fields []*Var, tags []string) *Struct {
+	var fset objset
+	for _, f := range fields {
+		if f.name != "_" && fset.insert(f) != nil {
+			panic("multiple fields with the same name")
+		}
+	}
+	if len(tags) > len(fields) {
+		panic("more tags than fields")
+	}
+	return &Struct{fields: fields, tags: tags}
+}
+
+// NumFields returns the number of fields in the struct (including blank and embedded fields).
+func (s *Struct) NumFields() int { return len(s.fields) }
+
+// Field returns the i'th field for 0 <= i < NumFields().
+func (s *Struct) Field(i int) *Var { return s.fields[i] }
+
+// Tag returns the i'th field tag for 0 <= i < NumFields().
+func (s *Struct) Tag(i int) string {
+	if i < len(s.tags) {
+		return s.tags[i]
+	}
+	return ""
+}
+
+// A Pointer represents a pointer type.
+type Pointer struct {
+	base Type // element type
+	aType
+}
+
+// NewPointer returns a new pointer type for the given element (base) type.
+func NewPointer(elem Type) *Pointer { return &Pointer{base: elem} }
+
+// Elem returns the element type for the given pointer p.
+func (p *Pointer) Elem() Type { return p.base }
+
+// A Tuple represents an ordered list of variables; a nil *Tuple is a valid (empty) tuple.
+// Tuples are used as components of signatures and to represent the type of multiple
+// assignments; they are not first class types of Go.
+type Tuple struct {
+	vars []*Var
+	aType
+}
+
+// NewTuple returns a new tuple for the given variables.
+func NewTuple(x ...*Var) *Tuple {
+	if len(x) > 0 {
+		return &Tuple{vars: x}
+	}
+	return nil
+}
+
+// We cannot rely on the embedded X() *X methods because (*Tuple)(nil)
+// is a valid *Tuple value but (*Tuple)(nil).X() would panic without
+// these implementations. At the moment we only need X = Basic, Named,
+// but add all because missing one leads to very confusing bugs.
+// TODO(gri) Don't represent empty tuples with a (*Tuple)(nil) pointer;
+//           it's too subtle and causes problems.
+func (*Tuple) Basic() *Basic     { return nil }
+func (*Tuple) Array() *Array     { return nil }
+func (*Tuple) Slice() *Slice     { return nil }
+func (*Tuple) Struct() *Struct   { return nil }
+func (*Tuple) Pointer() *Pointer { return nil }
+
+// func (*Tuple) Tuple() *Tuple      // implemented below
+func (*Tuple) Signature() *Signature { return nil }
+func (*Tuple) Sum() *Sum             { return nil }
+func (*Tuple) Interface() *Interface { return nil }
+func (*Tuple) Map() *Map             { return nil }
+func (*Tuple) Chan() *Chan           { return nil }
+
+func (*Tuple) Named() *Named         { return nil }
+func (*Tuple) TypeParam() *TypeParam { return nil }
+
+// Len returns the number variables of tuple t.
+func (t *Tuple) Len() int {
+	if t != nil {
+		return len(t.vars)
+	}
+	return 0
+}
+
+// At returns the i'th variable of tuple t.
+func (t *Tuple) At(i int) *Var { return t.vars[i] }
+
+// A Signature represents a (non-builtin) function or method type.
+// The receiver is ignored when comparing signatures for identity.
+type Signature struct {
+	// We need to keep the scope in Signature (rather than passing it around
+	// and store it in the Func Object) because when type-checking a function
+	// literal we call the general type checker which returns a general Type.
+	// We then unpack the *Signature and use the scope for the literal body.
+	rparams  []*TypeName // reveiver type parameters from left to right; or nil
+	tparams  []*TypeName // type parameters from left to right; or nil
+	scope    *Scope      // function scope, present for package-local signatures
+	recv     *Var        // nil if not a method
+	params   *Tuple      // (incoming) parameters from left to right; or nil
+	results  *Tuple      // (outgoing) results from left to right; or nil
+	variadic bool        // true if the last parameter's type is of the form ...T (or string, for append built-in only)
+	aType
+}
+
+// NewSignature returns a new function type for the given receiver, parameters,
+// and results, either of which may be nil. If variadic is set, the function
+// is variadic, it must have at least one parameter, and the last parameter
+// must be of unnamed slice type.
+func NewSignature(recv *Var, params, results *Tuple, variadic bool) *Signature {
+	if variadic {
+		n := params.Len()
+		if n == 0 {
+			panic("types.NewSignature: variadic function must have at least one parameter")
+		}
+		if _, ok := params.At(n - 1).typ.(*Slice); !ok {
+			panic("types.NewSignature: variadic parameter must be of unnamed slice type")
+		}
+	}
+	return &Signature{recv: recv, params: params, results: results, variadic: variadic}
+}
+
+// Recv returns the receiver of signature s (if a method), or nil if a
+// function. It is ignored when comparing signatures for identity.
+//
+// For an abstract method, Recv returns the enclosing interface either
+// as a *Named or an *Interface. Due to embedding, an interface may
+// contain methods whose receiver type is a different interface.
+func (s *Signature) Recv() *Var { return s.recv }
+
+// TParams returns the type parameters of signature s, or nil.
+func (s *Signature) TParams() []*TypeName { return s.tparams }
+
+// SetTParams sets the type parameters of signature s.
+func (s *Signature) SetTParams(tparams []*TypeName) { s.tparams = tparams }
+
+// Params returns the parameters of signature s, or nil.
+func (s *Signature) Params() *Tuple { return s.params }
+
+// Results returns the results of signature s, or nil.
+func (s *Signature) Results() *Tuple { return s.results }
+
+// Variadic reports whether the signature s is variadic.
+func (s *Signature) Variadic() bool { return s.variadic }
+
+// A Sum represents a set of possible types.
+// Sums are currently used to represent type lists of interfaces
+// and thus the underlying types of type parameters; they are not
+// first class types of Go.
+type Sum struct {
+	types []Type // types are unique
+	aType
+}
+
+// NewSum returns a new Sum type consisting of the provided
+// types if there are more than one. If there is exactly one
+// type, it returns that type. If the list of types is empty
+// the result is nil.
+func NewSum(types []Type) Type {
+	if len(types) == 0 {
+		return nil
+	}
+
+	// What should happen if types contains a sum type?
+	// Do we flatten the types list? For now we check
+	// and panic. This should not be possible for the
+	// current use case of type lists.
+	// TODO(gri) Come up with the rules for sum types.
+	for _, t := range types {
+		if _, ok := t.(*Sum); ok {
+			panic("sum type contains sum type - unimplemented")
+		}
+	}
+
+	if len(types) == 1 {
+		return types[0]
+	}
+	return &Sum{types: types}
+}
+
+// is reports whether all types in t satisfy pred.
+func (s *Sum) is(pred func(Type) bool) bool {
+	if s == nil {
+		return false
+	}
+	for _, t := range s.types {
+		if !pred(t) {
+			return false
+		}
+	}
+	return true
+}
+
+// An Interface represents an interface type.
+type Interface struct {
+	methods   []*Func // ordered list of explicitly declared methods
+	types     Type    // (possibly a Sum) type declared with a type list (TODO(gri) need better field name)
+	embeddeds []Type  // ordered list of explicitly embedded types
+
+	allMethods []*Func // ordered list of methods declared with or embedded in this interface (TODO(gri): replace with mset)
+	allTypes   Type    // intersection of all embedded and locally declared types  (TODO(gri) need better field name)
+
+	obj Object // type declaration defining this interface; or nil (for better error messages)
+
+	aType
+}
+
+// unpack unpacks a type into a list of types.
+// TODO(gri) Try to eliminate the need for this function.
+func unpack(typ Type) []Type {
+	if typ == nil {
+		return nil
+	}
+	if sum := typ.Sum(); sum != nil {
+		return sum.types
+	}
+	return []Type{typ}
+}
+
+// is reports whether interface t represents types that all satisfy pred.
+func (t *Interface) is(pred func(Type) bool) bool {
+	if t.allTypes == nil {
+		return false // we must have at least one type! (was bug)
+	}
+	for _, t := range unpack(t.allTypes) {
+		if !pred(t) {
+			return false
+		}
+	}
+	return true
+}
+
+// emptyInterface represents the empty (completed) interface
+var emptyInterface = Interface{allMethods: markComplete}
+
+// markComplete is used to mark an empty interface as completely
+// set up by setting the allMethods field to a non-nil empty slice.
+var markComplete = make([]*Func, 0)
+
+// NewInterface returns a new (incomplete) interface for the given methods and embedded types.
+// Each embedded type must have an underlying type of interface type.
+// NewInterface takes ownership of the provided methods and may modify their types by setting
+// missing receivers. To compute the method set of the interface, Complete must be called.
+//
+// Deprecated: Use NewInterfaceType instead which allows any (even non-defined) interface types
+// to be embedded. This is necessary for interfaces that embed alias type names referring to
+// non-defined (literal) interface types.
+func NewInterface(methods []*Func, embeddeds []*Named) *Interface {
+	tnames := make([]Type, len(embeddeds))
+	for i, t := range embeddeds {
+		tnames[i] = t
+	}
+	return NewInterfaceType(methods, tnames)
+}
+
+// NewInterfaceType returns a new (incomplete) interface for the given methods and embedded types.
+// Each embedded type must have an underlying type of interface type (this property is not
+// verified for defined types, which may be in the process of being set up and which don't
+// have a valid underlying type yet).
+// NewInterfaceType takes ownership of the provided methods and may modify their types by setting
+// missing receivers. To compute the method set of the interface, Complete must be called.
+func NewInterfaceType(methods []*Func, embeddeds []Type) *Interface {
+	if len(methods) == 0 && len(embeddeds) == 0 {
+		return &emptyInterface
+	}
+
+	// set method receivers if necessary
+	typ := new(Interface)
+	for _, m := range methods {
+		if sig := m.typ.(*Signature); sig.recv == nil {
+			sig.recv = NewVar(m.pos, m.pkg, "", typ)
+		}
+	}
+
+	// All embedded types should be interfaces; however, defined types
+	// may not yet be fully resolved. Only verify that non-defined types
+	// are interfaces. This matches the behavior of the code before the
+	// fix for #25301 (issue #25596).
+	for _, t := range embeddeds {
+		if _, ok := t.(*Named); !ok && !IsInterface(t) {
+			panic("embedded type is not an interface")
+		}
+	}
+
+	// sort for API stability
+	sort.Sort(byUniqueMethodName(methods))
+	sort.Stable(byUniqueTypeName(embeddeds))
+
+	typ.methods = methods
+	typ.embeddeds = embeddeds
+	return typ
+}
+
+// NumExplicitMethods returns the number of explicitly declared methods of interface t.
+func (t *Interface) NumExplicitMethods() int { return len(t.methods) }
+
+// ExplicitMethod returns the i'th explicitly declared method of interface t for 0 <= i < t.NumExplicitMethods().
+// The methods are ordered by their unique Id.
+func (t *Interface) ExplicitMethod(i int) *Func { return t.methods[i] }
+
+// NumEmbeddeds returns the number of embedded types in interface t.
+func (t *Interface) NumEmbeddeds() int { return len(t.embeddeds) }
+
+// Embedded returns the i'th embedded defined (*Named) type of interface t for 0 <= i < t.NumEmbeddeds().
+// The result is nil if the i'th embedded type is not a defined type.
+//
+// Deprecated: Use EmbeddedType which is not restricted to defined (*Named) types.
+func (t *Interface) Embedded(i int) *Named { tname, _ := t.embeddeds[i].(*Named); return tname }
+
+// EmbeddedType returns the i'th embedded type of interface t for 0 <= i < t.NumEmbeddeds().
+func (t *Interface) EmbeddedType(i int) Type { return t.embeddeds[i] }
+
+// NumMethods returns the total number of methods of interface t.
+// The interface must have been completed.
+func (t *Interface) NumMethods() int { t.assertCompleteness(); return len(t.allMethods) }
+
+func (t *Interface) assertCompleteness() {
+	if t.allMethods == nil {
+		panic("interface is incomplete")
+	}
+}
+
+// Method returns the i'th method of interface t for 0 <= i < t.NumMethods().
+// The methods are ordered by their unique Id.
+// The interface must have been completed.
+func (t *Interface) Method(i int) *Func { t.assertCompleteness(); return t.allMethods[i] }
+
+// Empty reports whether t is the empty interface.
+func (t *Interface) Empty() bool {
+	if t.allMethods != nil {
+		// interface is complete - quick test
+		// A non-nil allTypes may still be empty and represents the bottom type.
+		return len(t.allMethods) == 0 && t.allTypes == nil
+	}
+	return !t.iterate(func(t *Interface) bool {
+		if len(t.methods) > 0 || t.types != nil {
+			return true
+		}
+		return false
+	}, nil)
+}
+
+// HasTypeList reports whether interface t has a type list, possibly from an embedded type.
+func (t *Interface) HasTypeList() bool {
+	if t.allMethods != nil {
+		// interface is complete - quick test
+		return t.allTypes != nil
+	}
+
+	return t.iterate(func(t *Interface) bool {
+		if t.types != nil {
+			return true
+		}
+		return false
+	}, nil)
+}
+
+// IsComparable reports whether interface t is or embeds the predeclared interface "comparable".
+func (t *Interface) IsComparable() bool {
+	if t.allMethods != nil {
+		// interface is complete - quick test
+		_, m := lookupMethod(t.allMethods, nil, "==")
+		return m != nil
+	}
+
+	return t.iterate(func(t *Interface) bool {
+		_, m := lookupMethod(t.methods, nil, "==")
+		return m != nil
+	}, nil)
+}
+
+// IsConstraint reports t.HasTypeList() || t.IsComparable().
+func (t *Interface) IsConstraint() bool {
+	if t.allMethods != nil {
+		// interface is complete - quick test
+		if t.allTypes != nil {
+			return true
+		}
+		_, m := lookupMethod(t.allMethods, nil, "==")
+		return m != nil
+	}
+
+	return t.iterate(func(t *Interface) bool {
+		if t.types != nil {
+			return true
+		}
+		_, m := lookupMethod(t.methods, nil, "==")
+		return m != nil
+	}, nil)
+}
+
+// iterate calls f with t and then with any embedded interface of t, recursively, until f returns true.
+// iterate reports whether any call to f returned true.
+func (t *Interface) iterate(f func(*Interface) bool, seen map[*Interface]bool) bool {
+	if f(t) {
+		return true
+	}
+	for _, e := range t.embeddeds {
+		// e should be an interface but be careful (it may be invalid)
+		if e := e.Interface(); e != nil {
+			// Cyclic interfaces such as "type E interface { E }" are not permitted
+			// but they are still constructed and we need to detect such cycles.
+			if seen[e] {
+				continue
+			}
+			if seen == nil {
+				seen = make(map[*Interface]bool)
+			}
+			seen[e] = true
+			if e.iterate(f, seen) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// isSatisfiedBy reports whether interface t's type list is satisfied by the type typ.
+// If the the type list is empty (absent), typ trivially satisfies the interface.
+// TODO(gri) This is not a great name. Eventually, we should have a more comprehensive
+//           "implements" predicate.
+func (t *Interface) isSatisfiedBy(typ Type) bool {
+	t.Complete()
+	if t.allTypes == nil {
+		return true
+	}
+	types := unpack(t.allTypes)
+	return includes(types, typ) || includes(types, typ.Under())
+}
+
+// Complete computes the interface's method set. It must be called by users of
+// NewInterfaceType and NewInterface after the interface's embedded types are
+// fully defined and before using the interface type in any way other than to
+// form other types. The interface must not contain duplicate methods or a
+// panic occurs. Complete returns the receiver.
+func (t *Interface) Complete() *Interface {
+	// TODO(gri) consolidate this method with Checker.completeInterface
+	if t.allMethods != nil {
+		return t
+	}
+
+	t.allMethods = markComplete // avoid infinite recursion
+
+	var todo []*Func
+	var methods []*Func
+	var seen objset
+	addMethod := func(m *Func, explicit bool) {
+		switch other := seen.insert(m); {
+		case other == nil:
+			methods = append(methods, m)
+		case explicit:
+			panic("duplicate method " + m.name)
+		default:
+			// check method signatures after all locally embedded interfaces are computed
+			todo = append(todo, m, other.(*Func))
+		}
+	}
+
+	for _, m := range t.methods {
+		addMethod(m, true)
+	}
+
+	allTypes := t.types
+
+	for _, typ := range t.embeddeds {
+		utyp := typ.Under()
+		etyp := utyp.Interface()
+		if etyp == nil {
+			if utyp != Typ[Invalid] {
+				panic(fmt.Sprintf("%s is not an interface", typ))
+			}
+			continue
+		}
+		etyp.Complete()
+		for _, m := range etyp.allMethods {
+			addMethod(m, false)
+		}
+		allTypes = intersect(allTypes, etyp.allTypes)
+	}
+
+	for i := 0; i < len(todo); i += 2 {
+		m := todo[i]
+		other := todo[i+1]
+		if !Identical(m.typ, other.typ) {
+			panic("duplicate method " + m.name)
+		}
+	}
+
+	if methods != nil {
+		sort.Sort(byUniqueMethodName(methods))
+		t.allMethods = methods
+	}
+	t.allTypes = allTypes
+
+	return t
+}
+
+// A Map represents a map type.
+type Map struct {
+	key, elem Type
+	aType
+}
+
+// NewMap returns a new map for the given key and element types.
+func NewMap(key, elem Type) *Map {
+	return &Map{key: key, elem: elem}
+}
+
+// Key returns the key type of map m.
+func (m *Map) Key() Type { return m.key }
+
+// Elem returns the element type of map m.
+func (m *Map) Elem() Type { return m.elem }
+
+// A Chan represents a channel type.
+type Chan struct {
+	dir  ChanDir
+	elem Type
+	aType
+}
+
+// A ChanDir value indicates a channel direction.
+type ChanDir int
+
+// The direction of a channel is indicated by one of these constants.
+const (
+	SendRecv ChanDir = iota
+	SendOnly
+	RecvOnly
+)
+
+// NewChan returns a new channel type for the given direction and element type.
+func NewChan(dir ChanDir, elem Type) *Chan {
+	return &Chan{dir: dir, elem: elem}
+}
+
+// Dir returns the direction of channel c.
+func (c *Chan) Dir() ChanDir { return c.dir }
+
+// Elem returns the element type of channel c.
+func (c *Chan) Elem() Type { return c.elem }
+
+// A Named represents a named (defined) type.
+type Named struct {
+	check      *Checker    // for Named.Under implementation
+	info       typeInfo    // for cycle detection
+	obj        *TypeName   // corresponding declared object
+	orig       Type        // type (on RHS of declaration) this *Named type is derived of (for cycle reporting)
+	underlying Type        // possibly a *Named during setup; never a *Named once set up completely
+	tparams    []*TypeName // type parameters, or nil
+	targs      []Type      // type arguments (after instantiation), or nil
+	methods    []*Func     // methods declared for this type (not the method set of this type); signatures are type-checked lazily
+	aType
+}
+
+// NewNamed returns a new named type for the given type name, underlying type, and associated methods.
+// If the given type name obj doesn't have a type yet, its type is set to the returned named type.
+// The underlying type must not be a *Named.
+func NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named {
+	if _, ok := underlying.(*Named); ok {
+		panic("types.NewNamed: underlying type must not be *Named")
+	}
+	typ := &Named{obj: obj, orig: underlying, underlying: underlying, methods: methods}
+	if obj.typ == nil {
+		obj.typ = typ
+	}
+	return typ
+}
+
+func (check *Checker) NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named {
+	typ := &Named{check: check, obj: obj, orig: underlying, underlying: underlying, methods: methods}
+	if obj.typ == nil {
+		obj.typ = typ
+	}
+	return typ
+}
+
+// Obj returns the type name for the named type t.
+func (t *Named) Obj() *TypeName { return t.obj }
+
+// Converter methods
+func (t *Named) Basic() *Basic         { return t.Under().Basic() }
+func (t *Named) Array() *Array         { return t.Under().Array() }
+func (t *Named) Slice() *Slice         { return t.Under().Slice() }
+func (t *Named) Struct() *Struct       { return t.Under().Struct() }
+func (t *Named) Pointer() *Pointer     { return t.Under().Pointer() }
+func (t *Named) Tuple() *Tuple         { return t.Under().Tuple() }
+func (t *Named) Signature() *Signature { return t.Under().Signature() }
+func (t *Named) Interface() *Interface { return t.Under().Interface() }
+func (t *Named) Map() *Map             { return t.Under().Map() }
+func (t *Named) Chan() *Chan           { return t.Under().Chan() }
+
+// func (t *Named) Named() *Named      // declared below
+func (t *Named) TypeParam() *TypeParam { return t.Under().TypeParam() }
+
+// TODO(gri) Come up with a better representation and API to distinguish
+//           between parameterized instantiated and non-instantiated types.
+
+// TParams returns the type parameters of the named type t, or nil.
+// The result is non-nil for an (originally) parameterized type even if it is instantiated.
+func (t *Named) TParams() []*TypeName { return t.tparams }
+
+// TArgs returns the type arguments after instantiation of the named type t, or nil if not instantiated.
+func (t *Named) TArgs() []Type { return t.targs }
+
+// SetTArgs sets the type arguments of Named.
+func (t *Named) SetTArgs(args []Type) { t.targs = args }
+
+// NumMethods returns the number of explicit methods whose receiver is named type t.
+func (t *Named) NumMethods() int { return len(t.methods) }
+
+// Method returns the i'th method of named type t for 0 <= i < t.NumMethods().
+func (t *Named) Method(i int) *Func { return t.methods[i] }
+
+// SetUnderlying sets the underlying type and marks t as complete.
+func (t *Named) SetUnderlying(underlying Type) {
+	if underlying == nil {
+		panic("types.Named.SetUnderlying: underlying type must not be nil")
+	}
+	if _, ok := underlying.(*Named); ok {
+		panic("types.Named.SetUnderlying: underlying type must not be *Named")
+	}
+	t.underlying = underlying
+}
+
+// AddMethod adds method m unless it is already in the method list.
+func (t *Named) AddMethod(m *Func) {
+	if i, _ := lookupMethod(t.methods, m.pkg, m.name); i < 0 {
+		t.methods = append(t.methods, m)
+	}
+}
+
+// A TypeParam represents a type parameter type.
+type TypeParam struct {
+	check *Checker  // for lazy type bound completion
+	id    uint64    // unique id
+	ptr   bool      // pointer designation
+	obj   *TypeName // corresponding type name
+	index int       // parameter index
+	bound Type      // *Named or *Interface; underlying type is always *Interface
+	aType
+}
+
+// NewTypeParam returns a new TypeParam.
+func (check *Checker) NewTypeParam(ptr bool, obj *TypeName, index int, bound Type) *TypeParam {
+	assert(bound != nil)
+	typ := &TypeParam{check: check, id: check.nextId, ptr: ptr, obj: obj, index: index, bound: bound}
+	check.nextId++
+	if obj.typ == nil {
+		obj.typ = typ
+	}
+	return typ
+}
+
+func (t *TypeParam) Bound() *Interface {
+	iface := t.bound.Interface()
+	// use the type bound position if we have one
+	pos := nopos
+	if n, _ := t.bound.(*Named); n != nil {
+		pos = n.obj.pos
+	}
+	t.check.completeInterface(pos, iface)
+	return iface
+}
+
+// optype returns a type's operational type. Except for
+// type parameters, the operational type is the same
+// as the underlying type (as returned by Under). For
+// Type parameters, the operational type is determined
+// by the corresponding type bound's type list. The
+// result may be the bottom or top type, but it is never
+// the incoming type parameter.
+func optype(typ Type) Type {
+	if t := typ.TypeParam(); t != nil {
+		// If the optype is typ, return the top type as we have
+		// no information. It also prevents infinite recursion
+		// via the TypeParam converter methods. This can happen
+		// for a type parameter list of the form:
+		// (type T interface { type T }).
+		// See also issue #39680.
+		if u := t.Bound().allTypes; u != nil && u != typ {
+			// u != typ and u is a type parameter => u.Under() != typ, so this is ok
+			return u.Under()
+		}
+		return theTop
+	}
+	return typ
+}
+
+// Converter methods
+func (t *TypeParam) Basic() *Basic         { return optype(t).Basic() }
+func (t *TypeParam) Array() *Array         { return optype(t).Array() }
+func (t *TypeParam) Slice() *Slice         { return optype(t).Slice() }
+func (t *TypeParam) Struct() *Struct       { return optype(t).Struct() }
+func (t *TypeParam) Pointer() *Pointer     { return optype(t).Pointer() }
+func (t *TypeParam) Tuple() *Tuple         { return optype(t).Tuple() }
+func (t *TypeParam) Signature() *Signature { return optype(t).Signature() }
+func (t *TypeParam) Sum() *Sum             { return optype(t).Sum() }
+func (t *TypeParam) Interface() *Interface { return optype(t).Interface() }
+func (t *TypeParam) Map() *Map             { return optype(t).Map() }
+func (t *TypeParam) Chan() *Chan           { return optype(t).Chan() }
+
+// func (t *TypeParam) Named() *Named         // Named does not unpack type parameters
+// func (t *TypeParam) TypeParam() *TypeParam // declared below
+
+// An instance represents an instantiated generic type syntactically
+// (without expanding the instantiation). Type instances appear only
+// during type-checking and are replaced by their fully instantiated
+// (expanded) types before the end of type-checking.
+type instance struct {
+	check   *Checker     // for lazy instantiation
+	pos     syntax.Pos   // position of type instantiation; for error reporting only
+	base    *Named       // parameterized type to be instantiated
+	targs   []Type       // type arguments
+	poslist []syntax.Pos // position of each targ; for error reporting only
+	value   Type         // base(targs...) after instantiation or Typ[Invalid]; nil if not yet set
+	aType
+}
+
+// Converter methods
+func (t *instance) Basic() *Basic         { return t.Under().Basic() }
+func (t *instance) Array() *Array         { return t.Under().Array() }
+func (t *instance) Slice() *Slice         { return t.Under().Slice() }
+func (t *instance) Struct() *Struct       { return t.Under().Struct() }
+func (t *instance) Pointer() *Pointer     { return t.Under().Pointer() }
+func (t *instance) Tuple() *Tuple         { return t.Under().Tuple() }
+func (t *instance) Signature() *Signature { return t.Under().Signature() }
+func (t *instance) Sum() *Sum             { return t.Under().Sum() }
+func (t *instance) Interface() *Interface { return t.Under().Interface() }
+func (t *instance) Map() *Map             { return t.Under().Map() }
+func (t *instance) Chan() *Chan           { return t.Under().Chan() }
+
+func (t *instance) Named() *Named         { return t.expand().Named() }
+func (t *instance) TypeParam() *TypeParam { return t.expand().TypeParam() }
+
+// expand returns the instantiated (= expanded) type of t.
+// The result is either an instantiated *Named type, or
+// Typ[Invalid] if there was an error.
+func (t *instance) expand() Type {
+	v := t.value
+	if v == nil {
+		v = t.check.instantiate(t.pos, t.base, t.targs, t.poslist)
+		if v == nil {
+			v = Typ[Invalid]
+		}
+		t.value = v
+	}
+	// After instantiation we must have an invalid or a *Named type.
+	if debug && v != Typ[Invalid] {
+		_ = v.(*Named)
+	}
+	return v
+}
+
+// expand expands a type instance into its instantiated
+// type and leaves all other types alone. expand does
+// not recurse.
+func expand(typ Type) Type {
+	if t, _ := typ.(*instance); t != nil {
+		return t.expand()
+	}
+	return typ
+}
+
+// expandf is set to expand.
+// Call expandf when calling expand causes compile-time cycle error.
+var expandf func(Type) Type
+
+func init() { expandf = expand }
+
+// bottom represents the bottom of the type lattice.
+// It is the underlying type of a type parameter that
+// cannot be satisfied by any type, usually because
+// the intersection of type constraints left nothing).
+type bottom struct {
+	aType
+}
+
+// theBottom is the singleton bottom type.
+var theBottom = &bottom{}
+
+// top represents the top of the type lattice.
+// It is the underlying type of a type parameter that
+// can be satisfied by any type (ignoring methods),
+// usually because the type constraint has no type
+// list.
+type top struct {
+	aType
+}
+
+// theTop is the singleton top type.
+var theTop = &top{}
+
+// Type-specific implementations of type converters.
+func (t *Basic) Basic() *Basic             { return t }
+func (t *Array) Array() *Array             { return t }
+func (t *Slice) Slice() *Slice             { return t }
+func (t *Struct) Struct() *Struct          { return t }
+func (t *Pointer) Pointer() *Pointer       { return t }
+func (t *Tuple) Tuple() *Tuple             { return t }
+func (t *Signature) Signature() *Signature { return t }
+func (t *Sum) Sum() *Sum                   { return t }
+func (t *Interface) Interface() *Interface { return t }
+func (t *Map) Map() *Map                   { return t }
+func (t *Chan) Chan() *Chan                { return t }
+
+func (t *Named) Named() *Named             { return t }
+func (t *TypeParam) TypeParam() *TypeParam { return t }
+
+// Type-specific implementations of Underlying.
+func (t *Basic) Underlying() Type     { return t }
+func (t *Array) Underlying() Type     { return t }
+func (t *Slice) Underlying() Type     { return t }
+func (t *Struct) Underlying() Type    { return t }
+func (t *Pointer) Underlying() Type   { return t }
+func (t *Tuple) Underlying() Type     { return t }
+func (t *Signature) Underlying() Type { return t }
+func (t *Sum) Underlying() Type       { return t }
+func (t *Interface) Underlying() Type { return t }
+func (t *Map) Underlying() Type       { return t }
+func (t *Chan) Underlying() Type      { return t }
+func (t *Named) Underlying() Type     { return t.underlying }
+func (t *TypeParam) Underlying() Type { return t }
+func (t *instance) Underlying() Type  { return t }
+func (t *bottom) Underlying() Type    { return t }
+func (t *top) Underlying() Type       { return t }
+
+// Type-specific implementations of Under.
+func (t *Basic) Under() Type     { return t }
+func (t *Array) Under() Type     { return t }
+func (t *Slice) Under() Type     { return t }
+func (t *Struct) Under() Type    { return t }
+func (t *Pointer) Under() Type   { return t }
+func (t *Tuple) Under() Type     { return t }
+func (t *Signature) Under() Type { return t }
+func (t *Sum) Under() Type       { return t } // TODO(gri) is this correct?
+func (t *Interface) Under() Type { return t }
+func (t *Map) Under() Type       { return t }
+func (t *Chan) Under() Type      { return t }
+
+// see decl.go for implementation of Named.Under
+func (t *TypeParam) Under() Type { return t }
+func (t *instance) Under() Type  { return t.expand().Under() }
+func (t *bottom) Under() Type    { return t }
+func (t *top) Under() Type       { return t }
+
+// Type-specific implementations of String.
+func (t *Basic) String() string     { return TypeString(t, nil) }
+func (t *Array) String() string     { return TypeString(t, nil) }
+func (t *Slice) String() string     { return TypeString(t, nil) }
+func (t *Struct) String() string    { return TypeString(t, nil) }
+func (t *Pointer) String() string   { return TypeString(t, nil) }
+func (t *Tuple) String() string     { return TypeString(t, nil) }
+func (t *Signature) String() string { return TypeString(t, nil) }
+func (t *Sum) String() string       { return TypeString(t, nil) }
+func (t *Interface) String() string { return TypeString(t, nil) }
+func (t *Map) String() string       { return TypeString(t, nil) }
+func (t *Chan) String() string      { return TypeString(t, nil) }
+func (t *Named) String() string     { return TypeString(t, nil) }
+func (t *TypeParam) String() string { return TypeString(t, nil) }
+func (t *instance) String() string  { return TypeString(t, nil) }
+func (t *bottom) String() string    { return TypeString(t, nil) }
+func (t *top) String() string       { return TypeString(t, nil) }
diff --git a/src/cmd/compile/internal/types2/typestring.go b/src/cmd/compile/internal/types2/typestring.go
new file mode 100644
index 0000000000..98021797a1
--- /dev/null
+++ b/src/cmd/compile/internal/types2/typestring.go
@@ -0,0 +1,480 @@
+// UNREVIEWED
+// Copyright 2013 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.
+
+// This file implements printing of types.
+
+package types2
+
+import (
+	"bytes"
+	"fmt"
+	"unicode/utf8"
+)
+
+// A Qualifier controls how named package-level objects are printed in
+// calls to TypeString, ObjectString, and SelectionString.
+//
+// These three formatting routines call the Qualifier for each
+// package-level object O, and if the Qualifier returns a non-empty
+// string p, the object is printed in the form p.O.
+// If it returns an empty string, only the object name O is printed.
+//
+// Using a nil Qualifier is equivalent to using (*Package).Path: the
+// object is qualified by the import path, e.g., "encoding/json.Marshal".
+//
+type Qualifier func(*Package) string
+
+// RelativeTo returns a Qualifier that fully qualifies members of
+// all packages other than pkg.
+func RelativeTo(pkg *Package) Qualifier {
+	if pkg == nil {
+		return nil
+	}
+	return func(other *Package) string {
+		if pkg == other {
+			return "" // same package; unqualified
+		}
+		return other.Path()
+	}
+}
+
+// If gcCompatibilityMode is set, printing of types is modified
+// to match the representation of some types in the gc compiler:
+//
+//	- byte and rune lose their alias name and simply stand for
+//	  uint8 and int32 respectively
+//	- embedded interfaces get flattened (the embedding info is lost,
+//	  and certain recursive interface types cannot be printed anymore)
+//
+// This makes it easier to compare packages computed with the type-
+// checker vs packages imported from gc export data.
+//
+// Caution: This flag affects all uses of WriteType, globally.
+// It is only provided for testing in conjunction with
+// gc-generated data.
+//
+// This flag is exported in the x/tools/go/types package. We don't
+// need it at the moment in the std repo and so we don't export it
+// anymore. We should eventually try to remove it altogether.
+// TODO(gri) remove this
+var gcCompatibilityMode bool
+
+// TypeString returns the string representation of typ.
+// The Qualifier controls the printing of
+// package-level objects, and may be nil.
+func TypeString(typ Type, qf Qualifier) string {
+	var buf bytes.Buffer
+	WriteType(&buf, typ, qf)
+	return buf.String()
+}
+
+// WriteType writes the string representation of typ to buf.
+// The Qualifier controls the printing of
+// package-level objects, and may be nil.
+func WriteType(buf *bytes.Buffer, typ Type, qf Qualifier) {
+	writeType(buf, typ, qf, make([]Type, 0, 8))
+}
+
+// instanceMarker is the prefix for an instantiated type
+// in "non-evaluated" instance form.
+const instanceMarker = '#'
+
+func writeType(buf *bytes.Buffer, typ Type, qf Qualifier, visited []Type) {
+	// Theoretically, this is a quadratic lookup algorithm, but in
+	// practice deeply nested composite types with unnamed component
+	// types are uncommon. This code is likely more efficient than
+	// using a map.
+	for _, t := range visited {
+		if t == typ {
+			fmt.Fprintf(buf, "○%T", goTypeName(typ)) // cycle to typ
+			return
+		}
+	}
+	visited = append(visited, typ)
+
+	switch t := typ.(type) {
+	case nil:
+		buf.WriteString("<nil>")
+
+	case *Basic:
+		if t.kind == UnsafePointer {
+			buf.WriteString("unsafe.")
+		}
+		if gcCompatibilityMode {
+			// forget the alias names
+			switch t.kind {
+			case Byte:
+				t = Typ[Uint8]
+			case Rune:
+				t = Typ[Int32]
+			}
+		}
+		buf.WriteString(t.name)
+
+	case *Array:
+		fmt.Fprintf(buf, "[%d]", t.len)
+		writeType(buf, t.elem, qf, visited)
+
+	case *Slice:
+		buf.WriteString("[]")
+		writeType(buf, t.elem, qf, visited)
+
+	case *Struct:
+		buf.WriteString("struct{")
+		for i, f := range t.fields {
+			if i > 0 {
+				buf.WriteString("; ")
+			}
+			buf.WriteString(f.name)
+			if f.embedded {
+				// emphasize that the embedded field's name
+				// doesn't match the field's type name
+				if f.name != embeddedFieldName(f.typ) {
+					buf.WriteString(" /* = ")
+					writeType(buf, f.typ, qf, visited)
+					buf.WriteString(" */")
+				}
+			} else {
+				buf.WriteByte(' ')
+				writeType(buf, f.typ, qf, visited)
+			}
+			if tag := t.Tag(i); tag != "" {
+				fmt.Fprintf(buf, " %q", tag)
+			}
+		}
+		buf.WriteByte('}')
+
+	case *Pointer:
+		buf.WriteByte('*')
+		writeType(buf, t.base, qf, visited)
+
+	case *Tuple:
+		writeTuple(buf, t, false, qf, visited)
+
+	case *Signature:
+		buf.WriteString("func")
+		writeSignature(buf, t, qf, visited)
+
+	case *Sum:
+		for i, t := range t.types {
+			if i > 0 {
+				buf.WriteString(", ")
+			}
+			writeType(buf, t, qf, visited)
+		}
+
+	case *Interface:
+		// We write the source-level methods and embedded types rather
+		// than the actual method set since resolved method signatures
+		// may have non-printable cycles if parameters have embedded
+		// interface types that (directly or indirectly) embed the
+		// current interface. For instance, consider the result type
+		// of m:
+		//
+		//     type T interface{
+		//         m() interface{ T }
+		//     }
+		//
+		buf.WriteString("interface{")
+		empty := true
+		if gcCompatibilityMode {
+			// print flattened interface
+			// (useful to compare against gc-generated interfaces)
+			for i, m := range t.allMethods {
+				if i > 0 {
+					buf.WriteString("; ")
+				}
+				buf.WriteString(m.name)
+				writeSignature(buf, m.typ.(*Signature), qf, visited)
+				empty = false
+			}
+			if !empty && t.allTypes != nil {
+				buf.WriteString("; ")
+			}
+			if t.allTypes != nil {
+				buf.WriteString("type ")
+				writeType(buf, t.allTypes, qf, visited)
+			}
+		} else {
+			// print explicit interface methods and embedded types
+			for i, m := range t.methods {
+				if i > 0 {
+					buf.WriteString("; ")
+				}
+				buf.WriteString(m.name)
+				writeSignature(buf, m.typ.(*Signature), qf, visited)
+				empty = false
+			}
+			if !empty && t.types != nil {
+				buf.WriteString("; ")
+			}
+			if t.types != nil {
+				buf.WriteString("type ")
+				writeType(buf, t.types, qf, visited)
+				empty = false
+			}
+			if !empty && len(t.embeddeds) > 0 {
+				buf.WriteString("; ")
+			}
+			for i, typ := range t.embeddeds {
+				if i > 0 {
+					buf.WriteString("; ")
+				}
+				writeType(buf, typ, qf, visited)
+				empty = false
+			}
+		}
+		if t.allMethods == nil || len(t.methods) > len(t.allMethods) {
+			if !empty {
+				buf.WriteByte(' ')
+			}
+			buf.WriteString("/* incomplete */")
+		}
+		buf.WriteByte('}')
+
+	case *Map:
+		buf.WriteString("map[")
+		writeType(buf, t.key, qf, visited)
+		buf.WriteByte(']')
+		writeType(buf, t.elem, qf, visited)
+
+	case *Chan:
+		var s string
+		var parens bool
+		switch t.dir {
+		case SendRecv:
+			s = "chan "
+			// chan (<-chan T) requires parentheses
+			if c, _ := t.elem.(*Chan); c != nil && c.dir == RecvOnly {
+				parens = true
+			}
+		case SendOnly:
+			s = "chan<- "
+		case RecvOnly:
+			s = "<-chan "
+		default:
+			panic("unreachable")
+		}
+		buf.WriteString(s)
+		if parens {
+			buf.WriteByte('(')
+		}
+		writeType(buf, t.elem, qf, visited)
+		if parens {
+			buf.WriteByte(')')
+		}
+
+	case *Named:
+		writeTypeName(buf, t.obj, qf)
+		if t.targs != nil {
+			// instantiated type
+			buf.WriteByte('[')
+			writeTypeList(buf, t.targs, qf, visited)
+			buf.WriteByte(']')
+		} else if t.tparams != nil {
+			// parameterized type
+			writeTParamList(buf, t.tparams, qf, visited)
+		}
+
+	case *TypeParam:
+		s := "?"
+		if t.obj != nil {
+			s = t.obj.name
+		}
+		buf.WriteString(s + subscript(t.id))
+
+	case *instance:
+		buf.WriteByte(instanceMarker) // indicate "non-evaluated" syntactic instance
+		writeTypeName(buf, t.base.obj, qf)
+		buf.WriteByte('[')
+		writeTypeList(buf, t.targs, qf, visited)
+		buf.WriteByte(']')
+
+	case *bottom:
+		buf.WriteString("⊥")
+
+	case *top:
+		buf.WriteString("⊤")
+
+	default:
+		// For externally defined implementations of Type.
+		buf.WriteString(t.String())
+	}
+}
+
+func writeTypeList(buf *bytes.Buffer, list []Type, qf Qualifier, visited []Type) {
+	for i, typ := range list {
+		if i > 0 {
+			buf.WriteString(", ")
+		}
+		writeType(buf, typ, qf, visited)
+	}
+}
+
+func writeTParamList(buf *bytes.Buffer, list []*TypeName, qf Qualifier, visited []Type) {
+	// bound returns the type bound for tname. The result is never nil.
+	bound := func(tname *TypeName) Type {
+		// be careful to avoid crashes in case of inconsistencies
+		if t, _ := tname.typ.(*TypeParam); t != nil && t.bound != nil {
+			return t.bound
+		}
+		return &emptyInterface
+	}
+
+	// If a single type bound is not the empty interface, we have to write them all.
+	var writeBounds bool
+	for _, p := range list {
+		// bound(p) should be an interface but be careful (it may be invalid)
+		b := bound(p).Interface()
+		if b != nil && !b.Empty() {
+			writeBounds = true
+			break
+		}
+	}
+	writeBounds = true // always write the bounds for new type parameter list syntax
+
+	buf.WriteString("[")
+	var prev Type
+	for i, p := range list {
+		b := bound(p)
+		if i > 0 {
+			if writeBounds && b != prev {
+				// type bound changed - write previous one before advancing
+				buf.WriteByte(' ')
+				writeType(buf, prev, qf, visited)
+			}
+			buf.WriteString(", ")
+		}
+		prev = b
+
+		if t, _ := p.typ.(*TypeParam); t != nil {
+			if t.ptr {
+				buf.WriteByte('*')
+			}
+			writeType(buf, t, qf, visited)
+		} else {
+			buf.WriteString(p.name)
+		}
+	}
+	if writeBounds && prev != nil {
+		buf.WriteByte(' ')
+		writeType(buf, prev, qf, visited)
+	}
+	buf.WriteByte(']')
+}
+
+func writeTypeName(buf *bytes.Buffer, obj *TypeName, qf Qualifier) {
+	s := "<Named w/o object>"
+	if obj != nil {
+		if obj.pkg != nil {
+			writePackage(buf, obj.pkg, qf)
+		}
+		// TODO(gri): function-local named types should be displayed
+		// differently from named types at package level to avoid
+		// ambiguity.
+		s = obj.name
+	}
+	buf.WriteString(s)
+}
+
+func writeTuple(buf *bytes.Buffer, tup *Tuple, variadic bool, qf Qualifier, visited []Type) {
+	buf.WriteByte('(')
+	if tup != nil {
+		for i, v := range tup.vars {
+			if i > 0 {
+				buf.WriteString(", ")
+			}
+			if v.name != "" {
+				buf.WriteString(v.name)
+				buf.WriteByte(' ')
+			}
+			typ := v.typ
+			if variadic && i == len(tup.vars)-1 {
+				if s, ok := typ.(*Slice); ok {
+					buf.WriteString("...")
+					typ = s.elem
+				} else {
+					// special case:
+					// append(s, "foo"...) leads to signature func([]byte, string...)
+					if t := typ.Basic(); t == nil || t.kind != String {
+						panic("internal error: string type expected")
+					}
+					writeType(buf, typ, qf, visited)
+					buf.WriteString("...")
+					continue
+				}
+			}
+			writeType(buf, typ, qf, visited)
+		}
+	}
+	buf.WriteByte(')')
+}
+
+// WriteSignature writes the representation of the signature sig to buf,
+// without a leading "func" keyword.
+// The Qualifier controls the printing of
+// package-level objects, and may be nil.
+func WriteSignature(buf *bytes.Buffer, sig *Signature, qf Qualifier) {
+	writeSignature(buf, sig, qf, make([]Type, 0, 8))
+}
+
+func writeSignature(buf *bytes.Buffer, sig *Signature, qf Qualifier, visited []Type) {
+	if sig.tparams != nil {
+		writeTParamList(buf, sig.tparams, qf, visited)
+	}
+
+	writeTuple(buf, sig.params, sig.variadic, qf, visited)
+
+	n := sig.results.Len()
+	if n == 0 {
+		// no result
+		return
+	}
+
+	buf.WriteByte(' ')
+	if n == 1 && sig.results.vars[0].name == "" {
+		// single unnamed result
+		writeType(buf, sig.results.vars[0].typ, qf, visited)
+		return
+	}
+
+	// multiple or named result(s)
+	writeTuple(buf, sig.results, false, qf, visited)
+}
+
+// embeddedFieldName returns an embedded field's name given its type.
+// The result is "" if the type doesn't have an embedded field name.
+func embeddedFieldName(typ Type) string {
+	switch t := typ.(type) {
+	case *Basic:
+		return t.name
+	case *Named:
+		return t.obj.name
+	case *Pointer:
+		// *T is ok, but **T is not
+		if _, ok := t.base.(*Pointer); !ok {
+			return embeddedFieldName(t.base)
+		}
+	case *instance:
+		return t.base.obj.name
+	}
+	return "" // not a (pointer to) a defined type
+}
+
+// subscript returns the decimal (utf8) representation of x using subscript digits.
+func subscript(x uint64) string {
+	const w = len("₀") // all digits 0...9 have the same utf8 width
+	var buf [32 * w]byte
+	i := len(buf)
+	for {
+		i -= w
+		utf8.EncodeRune(buf[i:], '₀'+rune(x%10)) // '₀' == U+2080
+		x /= 10
+		if x == 0 {
+			break
+		}
+	}
+	return string(buf[i:])
+}
diff --git a/src/cmd/compile/internal/types2/typestring_test.go b/src/cmd/compile/internal/types2/typestring_test.go
new file mode 100644
index 0000000000..f1f7e34bf8
--- /dev/null
+++ b/src/cmd/compile/internal/types2/typestring_test.go
@@ -0,0 +1,221 @@
+// UNREVIEWED
+// Copyright 2012 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 types2_test
+
+import (
+	"internal/testenv"
+	"testing"
+
+	"cmd/compile/internal/syntax"
+	. "cmd/compile/internal/types2"
+)
+
+const filename = "<src>"
+
+func makePkg(src string) (*Package, error) {
+	file, err := parseSrc(filename, src)
+	if err != nil {
+		return nil, err
+	}
+	// use the package name as package path
+	conf := Config{Importer: defaultImporter()}
+	return conf.Check(file.PkgName.Value, []*syntax.File{file}, nil)
+}
+
+type testEntry struct {
+	src, str string
+}
+
+// dup returns a testEntry where both src and str are the same.
+func dup(s string) testEntry {
+	return testEntry{s, s}
+}
+
+// types that don't depend on any other type declarations
+var independentTestTypes = []testEntry{
+	// basic types
+	dup("int"),
+	dup("float32"),
+	dup("string"),
+
+	// arrays
+	dup("[10]int"),
+
+	// slices
+	dup("[]int"),
+	dup("[][]int"),
+
+	// structs
+	dup("struct{}"),
+	dup("struct{x int}"),
+	{`struct {
+		x, y int
+		z float32 "foo"
+	}`, `struct{x int; y int; z float32 "foo"}`},
+	{`struct {
+		string
+		elems []complex128
+	}`, `struct{string; elems []complex128}`},
+
+	// pointers
+	dup("*int"),
+	dup("***struct{}"),
+	dup("*struct{a int; b float32}"),
+
+	// functions
+	dup("func()"),
+	dup("func(x int)"),
+	{"func(x, y int)", "func(x int, y int)"},
+	{"func(x, y int, z string)", "func(x int, y int, z string)"},
+	dup("func(int)"),
+	{"func(int, string, byte)", "func(int, string, byte)"},
+
+	dup("func() int"),
+	{"func() (string)", "func() string"},
+	dup("func() (u int)"),
+	{"func() (u, v int, w string)", "func() (u int, v int, w string)"},
+
+	dup("func(int) string"),
+	dup("func(x int) string"),
+	dup("func(x int) (u string)"),
+	{"func(x, y int) (u string)", "func(x int, y int) (u string)"},
+
+	dup("func(...int) string"),
+	dup("func(x ...int) string"),
+	dup("func(x ...int) (u string)"),
+	{"func(x int, y ...int) (u string)", "func(x int, y ...int) (u string)"},
+
+	// interfaces
+	dup("interface{}"),
+	dup("interface{m()}"),
+	dup(`interface{String() string; m(int) float32}`),
+	dup(`interface{type int, float32, complex128}`),
+
+	// maps
+	dup("map[string]int"),
+	{"map[struct{x, y int}][]byte", "map[struct{x int; y int}][]byte"},
+
+	// channels
+	dup("chan<- chan int"),
+	dup("chan<- <-chan int"),
+	dup("<-chan <-chan int"),
+	dup("chan (<-chan int)"),
+	dup("chan<- func()"),
+	dup("<-chan []func() int"),
+}
+
+// types that depend on other type declarations (src in TestTypes)
+var dependentTestTypes = []testEntry{
+	// interfaces
+	dup(`interface{io.Reader; io.Writer}`),
+	dup(`interface{m() int; io.Writer}`),
+	{`interface{m() interface{T}}`, `interface{m() interface{p.T}}`},
+}
+
+func TestTypeString(t *testing.T) {
+	testenv.MustHaveGoBuild(t)
+
+	var tests []testEntry
+	tests = append(tests, independentTestTypes...)
+	tests = append(tests, dependentTestTypes...)
+
+	for _, test := range tests {
+		src := `package p; import "io"; type _ io.Writer; type T ` + test.src
+		pkg, err := makePkg(src)
+		if err != nil {
+			t.Errorf("%s: %s", src, err)
+			continue
+		}
+		typ := pkg.Scope().Lookup("T").Type().Underlying()
+		if got := typ.String(); got != test.str {
+			t.Errorf("%s: got %s, want %s", test.src, got, test.str)
+		}
+	}
+}
+
+var nopos syntax.Pos
+
+func TestIncompleteInterfaces(t *testing.T) {
+	sig := NewSignature(nil, nil, nil, false)
+	m := NewFunc(nopos, nil, "m", sig)
+	for _, test := range []struct {
+		typ  *Interface
+		want string
+	}{
+		{new(Interface), "interface{/* incomplete */}"},
+		{new(Interface).Complete(), "interface{}"},
+
+		{NewInterface(nil, nil), "interface{}"},
+		{NewInterface(nil, nil).Complete(), "interface{}"},
+		{NewInterface([]*Func{}, nil), "interface{}"},
+		{NewInterface([]*Func{}, nil).Complete(), "interface{}"},
+		{NewInterface(nil, []*Named{}), "interface{}"},
+		{NewInterface(nil, []*Named{}).Complete(), "interface{}"},
+		{NewInterface([]*Func{m}, nil), "interface{m() /* incomplete */}"},
+		{NewInterface([]*Func{m}, nil).Complete(), "interface{m()}"},
+		{NewInterface(nil, []*Named{newDefined(new(Interface).Complete())}), "interface{T /* incomplete */}"},
+		{NewInterface(nil, []*Named{newDefined(new(Interface).Complete())}).Complete(), "interface{T}"},
+		{NewInterface(nil, []*Named{newDefined(NewInterface([]*Func{m}, nil))}), "interface{T /* incomplete */}"},
+		{NewInterface(nil, []*Named{newDefined(NewInterface([]*Func{m}, nil).Complete())}), "interface{T /* incomplete */}"},
+		{NewInterface(nil, []*Named{newDefined(NewInterface([]*Func{m}, nil).Complete())}).Complete(), "interface{T}"},
+
+		{NewInterfaceType(nil, nil), "interface{}"},
+		{NewInterfaceType(nil, nil).Complete(), "interface{}"},
+		{NewInterfaceType([]*Func{}, nil), "interface{}"},
+		{NewInterfaceType([]*Func{}, nil).Complete(), "interface{}"},
+		{NewInterfaceType(nil, []Type{}), "interface{}"},
+		{NewInterfaceType(nil, []Type{}).Complete(), "interface{}"},
+		{NewInterfaceType([]*Func{m}, nil), "interface{m() /* incomplete */}"},
+		{NewInterfaceType([]*Func{m}, nil).Complete(), "interface{m()}"},
+		{NewInterfaceType(nil, []Type{new(Interface).Complete()}), "interface{interface{} /* incomplete */}"},
+		{NewInterfaceType(nil, []Type{new(Interface).Complete()}).Complete(), "interface{interface{}}"},
+		{NewInterfaceType(nil, []Type{NewInterfaceType([]*Func{m}, nil)}), "interface{interface{m() /* incomplete */} /* incomplete */}"},
+		{NewInterfaceType(nil, []Type{NewInterfaceType([]*Func{m}, nil).Complete()}), "interface{interface{m()} /* incomplete */}"},
+		{NewInterfaceType(nil, []Type{NewInterfaceType([]*Func{m}, nil).Complete()}).Complete(), "interface{interface{m()}}"},
+	} {
+		got := test.typ.String()
+		if got != test.want {
+			t.Errorf("got: %s, want: %s", got, test.want)
+		}
+	}
+}
+
+// newDefined creates a new defined type named T with the given underlying type.
+// Helper function for use with TestIncompleteInterfaces only.
+func newDefined(underlying Type) *Named {
+	tname := NewTypeName(nopos, nil, "T", nil)
+	return NewNamed(tname, underlying, nil)
+}
+
+func TestQualifiedTypeString(t *testing.T) {
+	p, _ := pkgFor("p.go", "package p; type T int", nil)
+	q, _ := pkgFor("q.go", "package q", nil)
+
+	pT := p.Scope().Lookup("T").Type()
+	for _, test := range []struct {
+		typ  Type
+		this *Package
+		want string
+	}{
+		{nil, nil, "<nil>"},
+		{pT, nil, "p.T"},
+		{pT, p, "T"},
+		{pT, q, "p.T"},
+		{NewPointer(pT), p, "*T"},
+		{NewPointer(pT), q, "*p.T"},
+	} {
+		qualifier := func(pkg *Package) string {
+			if pkg != test.this {
+				return pkg.Name()
+			}
+			return ""
+		}
+		if got := TypeString(test.typ, qualifier); got != test.want {
+			t.Errorf("TypeString(%s, %s) = %s, want %s",
+				test.this, test.typ, got, test.want)
+		}
+	}
+}
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
new file mode 100644
index 0000000000..ae5ea669f5
--- /dev/null
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -0,0 +1,1280 @@
+// UNREVIEWED
+// Copyright 2013 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.
+
+// This file implements type-checking of identifiers and type expressions.
+
+package types2
+
+import (
+	"cmd/compile/internal/syntax"
+	"fmt"
+	"go/constant"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+// ident type-checks identifier e and initializes x with the value or type of e.
+// If an error occurred, x.mode is set to invalid.
+// For the meaning of def, see Checker.definedType, below.
+// If wantType is set, the identifier e is expected to denote a type.
+//
+func (check *Checker) ident(x *operand, e *syntax.Name, def *Named, wantType bool) {
+	x.mode = invalid
+	x.expr = e
+
+	// Note that we cannot use check.lookup here because the returned scope
+	// may be different from obj.Parent(). See also Scope.LookupParent doc.
+	scope, obj := check.scope.LookupParent(e.Value, check.pos)
+	if obj == nil {
+		if e.Value == "_" {
+			check.errorf(e, "cannot use _ as value or type")
+		} else {
+			check.errorf(e, "undeclared name: %s", e.Value)
+		}
+		return
+	}
+	check.recordUse(e, obj)
+
+	// Type-check the object.
+	// Only call Checker.objDecl if the object doesn't have a type yet
+	// (in which case we must actually determine it) or the object is a
+	// TypeName and we also want a type (in which case we might detect
+	// a cycle which needs to be reported). Otherwise we can skip the
+	// call and avoid a possible cycle error in favor of the more
+	// informative "not a type/value" error that this function's caller
+	// will issue (see issue #25790).
+	typ := obj.Type()
+	if _, gotType := obj.(*TypeName); typ == nil || gotType && wantType {
+		check.objDecl(obj, def)
+		typ = obj.Type() // type must have been assigned by Checker.objDecl
+	}
+	assert(typ != nil)
+
+	// The object may be dot-imported: If so, remove its package from
+	// the map of unused dot imports for the respective file scope.
+	// (This code is only needed for dot-imports. Without them,
+	// we only have to mark variables, see *Var case below).
+	if pkg := obj.Pkg(); pkg != check.pkg && pkg != nil {
+		delete(check.unusedDotImports[scope], pkg)
+	}
+
+	switch obj := obj.(type) {
+	case *PkgName:
+		check.errorf(e, "use of package %s not in selector", obj.name)
+		return
+
+	case *Const:
+		check.addDeclDep(obj)
+		if typ == Typ[Invalid] {
+			return
+		}
+		if obj == universeIota {
+			if check.iota == nil {
+				check.errorf(e, "cannot use iota outside constant declaration")
+				return
+			}
+			x.val = check.iota
+		} else {
+			x.val = obj.val
+		}
+		assert(x.val != nil)
+		x.mode = constant_
+
+	case *TypeName:
+		x.mode = typexpr
+
+	case *Var:
+		// It's ok to mark non-local variables, but ignore variables
+		// from other packages to avoid potential race conditions with
+		// dot-imported variables.
+		if obj.pkg == check.pkg {
+			obj.used = true
+		}
+		check.addDeclDep(obj)
+		if typ == Typ[Invalid] {
+			return
+		}
+		x.mode = variable
+
+	case *Func:
+		check.addDeclDep(obj)
+		x.mode = value
+
+	case *Builtin:
+		x.id = obj.id
+		x.mode = builtin
+
+	case *Nil:
+		x.mode = value
+
+	default:
+		unreachable()
+	}
+
+	x.typ = typ
+}
+
+// typ type-checks the type expression e and returns its type, or Typ[Invalid].
+// The type must not be an (uninstantiated) generic type.
+func (check *Checker) typ(e syntax.Expr) Type {
+	return check.definedType(e, nil)
+}
+
+// varType type-checks the type expression e and returns its type, or Typ[Invalid].
+// The type must not be an (uninstantiated) generic type and it must be ordinary
+// (see ordinaryType).
+func (check *Checker) varType(e syntax.Expr) Type {
+	typ := check.definedType(e, nil)
+	check.ordinaryType(startPos(e), typ)
+	return typ
+}
+
+// ordinaryType reports an error if typ is an interface type containing
+// type lists or is (or embeds) the predeclared type comparable.
+func (check *Checker) ordinaryType(pos syntax.Pos, typ Type) {
+	// We don't want to call Under() (via Interface) or complete interfaces while we
+	// are in the middle of type-checking parameter declarations that might belong to
+	// interface methods. Delay this check to the end of type-checking.
+	check.atEnd(func() {
+		if t := typ.Interface(); t != nil {
+			check.completeInterface(pos, t) // TODO(gri) is this the correct position?
+			if t.allTypes != nil {
+				check.softErrorf(pos, "interface contains type constraints (%s)", t.allTypes)
+				return
+			}
+			if t.IsComparable() {
+				check.softErrorf(pos, "interface is (or embeds) comparable")
+			}
+		}
+	})
+}
+
+// anyType type-checks the type expression e and returns its type, or Typ[Invalid].
+// The type may be generic or instantiated.
+func (check *Checker) anyType(e syntax.Expr) Type {
+	typ := check.typInternal(e, nil)
+	assert(isTyped(typ))
+	check.recordTypeAndValue(e, typexpr, typ, nil)
+	return typ
+}
+
+// definedType is like typ but also accepts a type name def.
+// If def != nil, e is the type specification for the defined type def, declared
+// in a type declaration, and def.underlying will be set to the type of e before
+// any components of e are type-checked.
+//
+func (check *Checker) definedType(e syntax.Expr, def *Named) Type {
+	typ := check.typInternal(e, def)
+	assert(isTyped(typ))
+	if isGeneric(typ) {
+		check.errorf(e, "cannot use generic type %s without instantiation", typ)
+		typ = Typ[Invalid]
+	}
+	check.recordTypeAndValue(e, typexpr, typ, nil)
+	return typ
+}
+
+// genericType is like typ but the type must be an (uninstantiated) generic type.
+func (check *Checker) genericType(e syntax.Expr, reportErr bool) Type {
+	typ := check.typInternal(e, nil)
+	assert(isTyped(typ))
+	if typ != Typ[Invalid] && !isGeneric(typ) {
+		if reportErr {
+			check.errorf(e, "%s is not a generic type", typ)
+		}
+		typ = Typ[Invalid]
+	}
+	// TODO(gri) what is the correct call below?
+	check.recordTypeAndValue(e, typexpr, typ, nil)
+	return typ
+}
+
+// isubst returns an x with identifiers substituted per the substitution map smap.
+// isubst only handles the case of (valid) method receiver type expressions correctly.
+func isubst(x syntax.Expr, smap map[*syntax.Name]*syntax.Name) syntax.Expr {
+	switch n := x.(type) {
+	case *syntax.Name:
+		if alt := smap[n]; alt != nil {
+			return alt
+		}
+	// case *syntax.StarExpr:
+	// 	X := isubst(n.X, smap)
+	// 	if X != n.X {
+	// 		new := *n
+	// 		new.X = X
+	// 		return &new
+	// 	}
+	case *syntax.Operation:
+		if n.Op == syntax.Mul && n.Y == nil {
+			X := isubst(n.X, smap)
+			if X != n.X {
+				new := *n
+				new.X = X
+				return &new
+			}
+		}
+	case *syntax.IndexExpr:
+		Index := isubst(n.Index, smap)
+		if Index != n.Index {
+			new := *n
+			new.Index = Index
+			return &new
+		}
+	case *syntax.ListExpr:
+		var elems []syntax.Expr
+		for i, elem := range n.ElemList {
+			Elem := isubst(elem, smap)
+			if Elem != elem {
+				if elems == nil {
+					elems = make([]syntax.Expr, len(n.ElemList))
+					copy(elems, n.ElemList)
+				}
+				elems[i] = Elem
+			}
+		}
+		if elems != nil {
+			new := *n
+			new.ElemList = elems
+			return &new
+		}
+	case *syntax.ParenExpr:
+		return isubst(n.X, smap) // no need to keep parentheses
+	default:
+		// Other receiver type expressions are invalid.
+		// It's fine to ignore those here as they will
+		// be checked elsewhere.
+	}
+	return x
+}
+
+// funcType type-checks a function or method type.
+func (check *Checker) funcType(sig *Signature, recvPar *syntax.Field, tparams []*syntax.Field, ftyp *syntax.FuncType) {
+	check.openScope(ftyp, "function")
+	check.scope.isFunc = true
+	check.recordScope(ftyp, check.scope)
+	sig.scope = check.scope
+	defer check.closeScope()
+
+	var recvTyp syntax.Expr // rewritten receiver type; valid if != nil
+	if recvPar != nil {
+		// collect generic receiver type parameters, if any
+		// - a receiver type parameter is like any other type parameter, except that it is declared implicitly
+		// - the receiver specification acts as local declaration for its type parameters, which may be blank
+		_, rname, rparams := check.unpackRecv(recvPar.Type, true)
+		if len(rparams) > 0 {
+			// Blank identifiers don't get declared and regular type-checking of the instantiated
+			// parameterized receiver type expression fails in Checker.collectParams of receiver.
+			// Identify blank type parameters and substitute each with a unique new identifier named
+			// "n_" (where n is the parameter index) and which cannot conflict with any user-defined
+			// name.
+			var smap map[*syntax.Name]*syntax.Name // substitution map from "_" to "!n" identifiers
+			for i, p := range rparams {
+				if p.Value == "_" {
+					new := *p
+					new.Value = fmt.Sprintf("%d_", i)
+					rparams[i] = &new // use n_ identifier instead of _ so it can be looked up
+					if smap == nil {
+						smap = make(map[*syntax.Name]*syntax.Name)
+					}
+					smap[p] = &new
+				}
+			}
+			if smap != nil {
+				// blank identifiers were found => use rewritten receiver type
+				recvTyp = isubst(recvPar.Type, smap)
+			}
+			// TODO(gri) rework declareTypeParams
+			sig.rparams = nil
+			for _, rparam := range rparams {
+				sig.rparams = check.declareTypeParam(sig.rparams, rparam)
+			}
+			// determine receiver type to get its type parameters
+			// and the respective type parameter bounds
+			var recvTParams []*TypeName
+			if rname != nil {
+				// recv should be a Named type (otherwise an error is reported elsewhere)
+				// Also: Don't report an error via genericType since it will be reported
+				//       again when we type-check the signature.
+				// TODO(gri) maybe the receiver should be marked as invalid instead?
+				if recv := check.genericType(rname, false).Named(); recv != nil {
+					recvTParams = recv.tparams
+				}
+			}
+			// provide type parameter bounds
+			// - only do this if we have the right number (otherwise an error is reported elsewhere)
+			if len(sig.rparams) == len(recvTParams) {
+				// We have a list of *TypeNames but we need a list of Types.
+				// While creating this list, also update type parameter pointer designation
+				// for each (*TypeParam) list entry, by copying the information from the
+				// receiver base type's type parameters.
+				list := make([]Type, len(sig.rparams))
+				for i, t := range sig.rparams {
+					t.typ.(*TypeParam).ptr = recvTParams[i].typ.(*TypeParam).ptr
+					list[i] = t.typ
+				}
+				for i, tname := range sig.rparams {
+					bound := recvTParams[i].typ.(*TypeParam).bound
+					// bound is (possibly) parameterized in the context of the
+					// receiver type declaration. Substitute parameters for the
+					// current context.
+					// TODO(gri) should we assume now that bounds always exist?
+					//           (no bound == empty interface)
+					if bound != nil {
+						bound = check.subst(tname.pos, bound, makeSubstMap(recvTParams, list))
+						tname.typ.(*TypeParam).bound = bound
+					}
+				}
+			}
+		}
+	}
+
+	if tparams != nil {
+		sig.tparams = check.collectTypeParams(tparams)
+		// Always type-check method type parameters but complain if they are not enabled.
+		// (A separate check is needed when type-checking interface method signatures because
+		// they don't have a receiver specification.)
+		if recvPar != nil && !check.conf.AcceptMethodTypeParams {
+			check.errorf(ftyp, "methods cannot have type parameters")
+		}
+	}
+
+	// Value (non-type) parameters' scope starts in the function body. Use a temporary scope for their
+	// declarations and then squash that scope into the parent scope (and report any redeclarations at
+	// that time).
+	scope := NewScope(check.scope, nopos, nopos, "function body (temp. scope)")
+	var recvList []*Var // TODO(gri) remove the need for making a list here
+	if recvPar != nil {
+		recvList, _ = check.collectParams(scope, []*syntax.Field{recvPar}, recvTyp, false) // use rewritten receiver type, if any
+	}
+	params, variadic := check.collectParams(scope, ftyp.ParamList, nil, true)
+	results, _ := check.collectParams(scope, ftyp.ResultList, nil, false)
+	scope.Squash(func(obj, alt Object) {
+		check.errorf(obj, "%s redeclared in this block", obj.Name())
+		check.reportAltDecl(alt)
+	})
+
+	if recvPar != nil {
+		// recv parameter list present (may be empty)
+		// spec: "The receiver is specified via an extra parameter section preceding the
+		// method name. That parameter section must declare a single parameter, the receiver."
+		var recv *Var
+		switch len(recvList) {
+		case 0:
+			// error reported by resolver
+			recv = NewParam(nopos, nil, "", Typ[Invalid]) // ignore recv below
+		default:
+			// more than one receiver
+			check.error(recvList[len(recvList)-1].Pos(), "method must have exactly one receiver")
+			fallthrough // continue with first receiver
+		case 1:
+			recv = recvList[0]
+		}
+
+		// TODO(gri) We should delay rtyp expansion to when we actually need the
+		//           receiver; thus all checks here should be delayed to later.
+		rtyp, _ := deref(recv.typ)
+		rtyp = expand(rtyp)
+
+		// spec: "The receiver type must be of the form T or *T where T is a type name."
+		// (ignore invalid types - error was reported before)
+		if t := rtyp; t != Typ[Invalid] {
+			var err string
+			if T := t.Named(); T != nil {
+				// spec: "The type denoted by T is called the receiver base type; it must not
+				// be a pointer or interface type and it must be declared in the same package
+				// as the method."
+				if T.obj.pkg != check.pkg {
+					err = "type not defined in this package"
+				} else {
+					switch u := optype(T.Under()).(type) {
+					case *Basic:
+						// unsafe.Pointer is treated like a regular pointer
+						if u.kind == UnsafePointer {
+							err = "unsafe.Pointer"
+						}
+					case *Pointer, *Interface:
+						err = "pointer or interface type"
+					}
+				}
+			} else {
+				err = "basic or unnamed type"
+			}
+			if err != "" {
+				check.errorf(recv.pos, "invalid receiver %s (%s)", recv.typ, err)
+				// ok to continue
+			}
+		}
+		sig.recv = recv
+	}
+
+	sig.params = NewTuple(params...)
+	sig.results = NewTuple(results...)
+	sig.variadic = variadic
+}
+
+// goTypeName returns the Go type name for typ and
+// removes any occurences of "types." from that name.
+func goTypeName(typ Type) string {
+	return strings.ReplaceAll(fmt.Sprintf("%T", typ), "types.", "")
+}
+
+// typInternal drives type checking of types.
+// Must only be called by definedType or genericType.
+//
+func (check *Checker) typInternal(e0 syntax.Expr, def *Named) (T Type) {
+	if check.conf.Trace {
+		check.trace(e0.Pos(), "type %s", e0)
+		check.indent++
+		defer func() {
+			check.indent--
+			var under Type
+			if T != nil {
+				// Calling Under() here may lead to endless instantiations.
+				// Test case: type T[P any] *T[P]
+				// TODO(gri) investigate if that's a bug or to be expected
+				// (see also analogous comment in Checker.instantiate).
+				under = T.Underlying()
+			}
+			if T == under {
+				check.trace(e0.Pos(), "=> %s // %s", T, goTypeName(T))
+			} else {
+				check.trace(e0.Pos(), "=> %s (under = %s) // %s", T, under, goTypeName(T))
+			}
+		}()
+	}
+
+	switch e := e0.(type) {
+	case *syntax.BadExpr:
+		// ignore - error reported before
+
+	case *syntax.Name:
+		var x operand
+		check.ident(&x, e, def, true)
+
+		switch x.mode {
+		case typexpr:
+			typ := x.typ
+			def.setUnderlying(typ)
+			return typ
+		case invalid:
+			// ignore - error reported before
+		case novalue:
+			check.errorf(&x, "%s used as type", &x)
+		default:
+			check.errorf(&x, "%s is not a type", &x)
+		}
+
+	case *syntax.SelectorExpr:
+		var x operand
+		check.selector(&x, e)
+
+		switch x.mode {
+		case typexpr:
+			typ := x.typ
+			def.setUnderlying(typ)
+			return typ
+		case invalid:
+			// ignore - error reported before
+		case novalue:
+			check.errorf(&x, "%s used as type", &x)
+		default:
+			check.errorf(&x, "%s is not a type", &x)
+		}
+
+	case *syntax.IndexExpr:
+		return check.instantiatedType(e.X, unpackExpr(e.Index), def)
+
+	case *syntax.ParenExpr:
+		// Generic types must be instantiated before they can be used in any form.
+		// Consequently, generic types cannot be parenthesized.
+		return check.definedType(e.X, def)
+
+	case *syntax.ArrayType:
+		typ := new(Array)
+		def.setUnderlying(typ)
+		if e.Len != nil {
+			typ.len = check.arrayLength(e.Len)
+		} else {
+			// [...]array
+			check.errorf(e, "invalid use of [...] array (outside a composite literal)")
+			typ.len = -1
+		}
+		typ.elem = check.varType(e.Elem)
+		return typ
+
+	case *syntax.SliceType:
+		typ := new(Slice)
+		def.setUnderlying(typ)
+		typ.elem = check.varType(e.Elem)
+		return typ
+
+	case *syntax.StructType:
+		typ := new(Struct)
+		def.setUnderlying(typ)
+		check.structType(typ, e)
+		return typ
+
+	case *syntax.Operation:
+		if e.Op == syntax.Mul && e.Y == nil {
+			typ := new(Pointer)
+			def.setUnderlying(typ)
+			typ.base = check.varType(e.X)
+			return typ
+		}
+
+	case *syntax.FuncType:
+		typ := new(Signature)
+		def.setUnderlying(typ)
+		check.funcType(typ, nil, nil, e)
+		return typ
+
+	case *syntax.InterfaceType:
+		typ := new(Interface)
+		def.setUnderlying(typ)
+		if def != nil {
+			typ.obj = def.obj
+		}
+		check.interfaceType(typ, e, def)
+		return typ
+
+	case *syntax.MapType:
+		typ := new(Map)
+		def.setUnderlying(typ)
+
+		typ.key = check.varType(e.Key)
+		typ.elem = check.varType(e.Value)
+
+		// spec: "The comparison operators == and != must be fully defined
+		// for operands of the key type; thus the key type must not be a
+		// function, map, or slice."
+		//
+		// Delay this check because it requires fully setup types;
+		// it is safe to continue in any case (was issue 6667).
+		check.atEnd(func() {
+			if !Comparable(typ.key) {
+				var why string
+				if typ.key.TypeParam() != nil {
+					why = " (missing comparable constraint)"
+				}
+				check.errorf(e.Key, "invalid map key type %s%s", typ.key, why)
+			}
+		})
+
+		return typ
+
+	case *syntax.ChanType:
+		typ := new(Chan)
+		def.setUnderlying(typ)
+
+		dir := SendRecv
+		switch e.Dir {
+		case 0:
+			// nothing to do
+		case syntax.SendOnly:
+			dir = SendOnly
+		case syntax.RecvOnly:
+			dir = RecvOnly
+		default:
+			check.invalidASTf(e, "unknown channel direction %d", e.Dir)
+			// ok to continue
+		}
+
+		typ.dir = dir
+		typ.elem = check.varType(e.Elem)
+		return typ
+
+	default:
+		check.errorf(e0, "%s is not a type", e0)
+		check.use(e0)
+	}
+
+	typ := Typ[Invalid]
+	def.setUnderlying(typ)
+	return typ
+}
+
+// typeOrNil type-checks the type expression (or nil value) e
+// and returns the type of e, or nil. If e is a type, it must
+// not be an (uninstantiated) generic type.
+// If e is neither a type nor nil, typeOrNil returns Typ[Invalid].
+// TODO(gri) should we also disallow non-var types?
+func (check *Checker) typOrNil(e syntax.Expr) Type {
+	var x operand
+	check.rawExpr(&x, e, nil)
+	switch x.mode {
+	case invalid:
+		// ignore - error reported before
+	case novalue:
+		check.errorf(&x, "%s used as type", &x)
+	case typexpr:
+		check.instantiatedOperand(&x)
+		return x.typ
+	case value:
+		if x.isNil() {
+			return nil
+		}
+		fallthrough
+	default:
+		check.errorf(&x, "%s is not a type", &x)
+	}
+	return Typ[Invalid]
+}
+
+func (check *Checker) instantiatedType(x syntax.Expr, targs []syntax.Expr, def *Named) Type {
+	b := check.genericType(x, true) // TODO(gri) what about cycles?
+	if b == Typ[Invalid] {
+		return b // error already reported
+	}
+	base := b.Named()
+	if base == nil {
+		unreachable() // should have been caught by genericType
+	}
+
+	// create a new type Instance rather than instantiate the type
+	// TODO(gri) should do argument number check here rather than
+	// when instantiating the type?
+	typ := new(instance)
+	def.setUnderlying(typ)
+
+	typ.check = check
+	typ.pos = x.Pos()
+	typ.base = base
+
+	// evaluate arguments (always)
+	typ.targs = check.typeList(targs)
+	if typ.targs == nil {
+		def.setUnderlying(Typ[Invalid]) // avoid later errors due to lazy instantiation
+		return Typ[Invalid]
+	}
+
+	// determine argument positions (for error reporting)
+	typ.poslist = make([]syntax.Pos, len(targs))
+	for i, arg := range targs {
+		typ.poslist[i] = arg.Pos()
+	}
+
+	// make sure we check instantiation works at least once
+	// and that the resulting type is valid
+	check.atEnd(func() {
+		t := typ.expand()
+		check.validType(t, nil)
+	})
+
+	return typ
+}
+
+// arrayLength type-checks the array length expression e
+// and returns the constant length >= 0, or a value < 0
+// to indicate an error (and thus an unknown length).
+func (check *Checker) arrayLength(e syntax.Expr) int64 {
+	var x operand
+	check.expr(&x, e)
+	if x.mode != constant_ {
+		if x.mode != invalid {
+			check.errorf(&x, "array length %s must be constant", &x)
+		}
+		return -1
+	}
+	if isUntyped(x.typ) || isInteger(x.typ) {
+		if val := constant.ToInt(x.val); val.Kind() == constant.Int {
+			if representableConst(val, check, Typ[Int], nil) {
+				if n, ok := constant.Int64Val(val); ok && n >= 0 {
+					return n
+				}
+				check.errorf(&x, "invalid array length %s", &x)
+				return -1
+			}
+		}
+	}
+	check.errorf(&x, "array length %s must be integer", &x)
+	return -1
+}
+
+// typeList provides the list of types corresponding to the incoming expression list.
+// If an error occured, the result is nil, but all list elements were type-checked.
+func (check *Checker) typeList(list []syntax.Expr) []Type {
+	res := make([]Type, len(list)) // res != nil even if len(list) == 0
+	for i, x := range list {
+		t := check.varType(x)
+		if t == Typ[Invalid] {
+			res = nil
+		}
+		if res != nil {
+			res[i] = t
+		}
+	}
+	return res
+}
+
+// collectParams declares the parameters of list in scope and returns the corresponding
+// variable list. If type0 != nil, it is used instead of the first type in list.
+func (check *Checker) collectParams(scope *Scope, list []*syntax.Field, type0 syntax.Expr, variadicOk bool) (params []*Var, variadic bool) {
+	if list == nil {
+		return
+	}
+
+	var named, anonymous bool
+
+	var typ Type
+	var prev syntax.Expr
+	for i, field := range list {
+		ftype := field.Type
+		// type-check type of grouped fields only once
+		if ftype != prev {
+			prev = ftype
+			if i == 0 && type0 != nil {
+				ftype = type0
+			}
+			if t, _ := ftype.(*syntax.DotsType); t != nil {
+				ftype = t.Elem
+				if variadicOk && i == len(list)-1 {
+					variadic = true
+				} else {
+					check.softErrorf(t, "can only use ... with final parameter in list")
+					// ignore ... and continue
+				}
+			}
+			typ = check.varType(ftype)
+		}
+		// The parser ensures that f.Tag is nil and we don't
+		// care if a constructed AST contains a non-nil tag.
+		if field.Name != nil {
+			// named parameter
+			name := field.Name.Value
+			if name == "" {
+				check.invalidASTf(field.Name, "anonymous parameter")
+				// ok to continue
+			}
+			par := NewParam(field.Name.Pos(), check.pkg, name, typ)
+			check.declare(scope, field.Name, par, scope.pos)
+			params = append(params, par)
+			named = true
+		} else {
+			// anonymous parameter
+			par := NewParam(ftype.Pos(), check.pkg, "", typ)
+			check.recordImplicit(field, par)
+			params = append(params, par)
+			anonymous = true
+		}
+	}
+
+	if named && anonymous {
+		check.invalidASTf(list[0], "list contains both named and anonymous parameters")
+		// ok to continue
+	}
+
+	// For a variadic function, change the last parameter's type from T to []T.
+	// Since we type-checked T rather than ...T, we also need to retro-actively
+	// record the type for ...T.
+	if variadic {
+		last := params[len(params)-1]
+		last.typ = &Slice{elem: last.typ}
+		check.recordTypeAndValue(list[len(list)-1].Type, typexpr, last.typ, nil)
+	}
+
+	return
+}
+
+func (check *Checker) declareInSet(oset *objset, pos syntax.Pos, obj Object) bool {
+	if alt := oset.insert(obj); alt != nil {
+		check.errorf(pos, "%s redeclared", obj.Name())
+		check.reportAltDecl(alt)
+		return false
+	}
+	return true
+}
+
+func (check *Checker) interfaceType(ityp *Interface, iface *syntax.InterfaceType, def *Named) {
+	var tname *syntax.Name // most recent "type" name
+	var types []syntax.Expr
+	for _, f := range iface.MethodList {
+		if f.Name != nil {
+			// We have a method with name f.Name, or a type
+			// of a type list (f.Name.Value == "type").
+			name := f.Name.Value
+			if name == "_" {
+				check.errorf(f.Name, "invalid method name _")
+				continue // ignore
+			}
+
+			if name == "type" {
+				// Always collect all type list entries, even from
+				// different type lists, under the assumption that
+				// the author intended to include all types.
+				types = append(types, f.Type)
+				if tname != nil && tname != f.Name {
+					check.errorf(f.Name, "cannot have multiple type lists in an interface")
+				}
+				tname = f.Name
+				continue
+			}
+
+			typ := check.typ(f.Type)
+			sig, _ := typ.(*Signature)
+			if sig == nil {
+				if typ != Typ[Invalid] {
+					check.invalidASTf(f.Type, "%s is not a method signature", typ)
+				}
+				continue // ignore
+			}
+
+			// Always type-check method type parameters but complain if they are not enabled.
+			// (This extra check is needed here because interface method signatures don't have
+			// a receiver specification.)
+			if sig.tparams != nil && !check.conf.AcceptMethodTypeParams {
+				check.errorf(f.Type, "methods cannot have type parameters")
+			}
+
+			// use named receiver type if available (for better error messages)
+			var recvTyp Type = ityp
+			if def != nil {
+				recvTyp = def
+			}
+			sig.recv = NewVar(f.Name.Pos(), check.pkg, "", recvTyp)
+
+			m := NewFunc(f.Name.Pos(), check.pkg, name, sig)
+			check.recordDef(f.Name, m)
+			ityp.methods = append(ityp.methods, m)
+		} else {
+			// We have an embedded type. completeInterface will
+			// eventually verify that we have an interface.
+			ityp.embeddeds = append(ityp.embeddeds, check.typ(f.Type))
+			check.posMap[ityp] = append(check.posMap[ityp], f.Type.Pos())
+		}
+	}
+
+	// type constraints
+	ityp.types = NewSum(check.collectTypeConstraints(iface.Pos(), types))
+
+	if len(ityp.methods) == 0 && ityp.types == nil && len(ityp.embeddeds) == 0 {
+		// empty interface
+		ityp.allMethods = markComplete
+		return
+	}
+
+	// sort for API stability
+	sort.Sort(byUniqueMethodName(ityp.methods))
+	sort.Stable(byUniqueTypeName(ityp.embeddeds))
+
+	check.later(func() { check.completeInterface(iface.Pos(), ityp) })
+}
+
+func (check *Checker) completeInterface(pos syntax.Pos, ityp *Interface) {
+	if ityp.allMethods != nil {
+		return
+	}
+
+	// completeInterface may be called via the LookupFieldOrMethod,
+	// MissingMethod, Identical, or IdenticalIgnoreTags external API
+	// in which case check will be nil. In this case, type-checking
+	// must be finished and all interfaces should have been completed.
+	if check == nil {
+		panic("internal error: incomplete interface")
+	}
+
+	if check.conf.Trace {
+		// Types don't generally have position information.
+		// If we don't have a valid pos provided, try to use
+		// one close enough.
+		if !pos.IsKnown() && len(ityp.methods) > 0 {
+			pos = ityp.methods[0].pos
+		}
+
+		check.trace(pos, "complete %s", ityp)
+		check.indent++
+		defer func() {
+			check.indent--
+			check.trace(pos, "=> %s (methods = %v, types = %v)", ityp, ityp.allMethods, ityp.allTypes)
+		}()
+	}
+
+	// An infinitely expanding interface (due to a cycle) is detected
+	// elsewhere (Checker.validType), so here we simply assume we only
+	// have valid interfaces. Mark the interface as complete to avoid
+	// infinite recursion if the validType check occurs later for some
+	// reason.
+	ityp.allMethods = markComplete
+
+	// Methods of embedded interfaces are collected unchanged; i.e., the identity
+	// of a method I.m's Func Object of an interface I is the same as that of
+	// the method m in an interface that embeds interface I. On the other hand,
+	// if a method is embedded via multiple overlapping embedded interfaces, we
+	// don't provide a guarantee which "original m" got chosen for the embedding
+	// interface. See also issue #34421.
+	//
+	// If we don't care to provide this identity guarantee anymore, instead of
+	// reusing the original method in embeddings, we can clone the method's Func
+	// Object and give it the position of a corresponding embedded interface. Then
+	// we can get rid of the mpos map below and simply use the cloned method's
+	// position.
+
+	var seen objset
+	var methods []*Func
+	mpos := make(map[*Func]syntax.Pos) // method specification or method embedding position, for good error messages
+	addMethod := func(pos syntax.Pos, m *Func, explicit bool) {
+		switch other := seen.insert(m); {
+		case other == nil:
+			methods = append(methods, m)
+			mpos[m] = pos
+		case explicit:
+			check.errorf(pos, "duplicate method %s", m.name)
+			check.errorf(mpos[other.(*Func)], "\tother declaration of %s", m.name) // secondary error, \t indented
+		default:
+			// check method signatures after all types are computed (issue #33656)
+			check.atEnd(func() {
+				if !check.identical(m.typ, other.Type()) {
+					check.errorf(pos, "duplicate method %s", m.name)
+					check.errorf(mpos[other.(*Func)], "\tother declaration of %s", m.name) // secondary error, \t indented
+				}
+			})
+		}
+	}
+
+	for _, m := range ityp.methods {
+		addMethod(m.pos, m, true)
+	}
+
+	// collect types
+	allTypes := ityp.types
+
+	posList := check.posMap[ityp]
+	for i, typ := range ityp.embeddeds {
+		pos := posList[i] // embedding position
+		utyp := typ.Under()
+		etyp := utyp.Interface()
+		if etyp == nil {
+			if utyp != Typ[Invalid] {
+				var format string
+				if _, ok := utyp.(*TypeParam); ok {
+					format = "%s is a type parameter, not an interface"
+				} else {
+					format = "%s is not an interface"
+				}
+				check.errorf(pos, format, typ)
+			}
+			continue
+		}
+		check.completeInterface(pos, etyp)
+		for _, m := range etyp.allMethods {
+			addMethod(pos, m, false) // use embedding position pos rather than m.pos
+		}
+		allTypes = intersect(allTypes, etyp.allTypes)
+	}
+
+	if methods != nil {
+		sort.Sort(byUniqueMethodName(methods))
+		ityp.allMethods = methods
+	}
+	ityp.allTypes = allTypes
+}
+
+// intersect computes the intersection of the types x and y.
+// Note: A incomming nil type stands for the top type. A top
+// type result is returned as nil.
+func intersect(x, y Type) (r Type) {
+	defer func() {
+		if r == theTop {
+			r = nil
+		}
+	}()
+
+	switch {
+	case x == theBottom || y == theBottom:
+		return theBottom
+	case x == nil || x == theTop:
+		return y
+	case y == nil || x == theTop:
+		return x
+	}
+
+	xtypes := unpack(x)
+	ytypes := unpack(y)
+	// Compute the list rtypes which includes only
+	// types that are in both xtypes and ytypes.
+	// Quadratic algorithm, but good enough for now.
+	// TODO(gri) fix this
+	var rtypes []Type
+	for _, x := range xtypes {
+		if includes(ytypes, x) {
+			rtypes = append(rtypes, x)
+		}
+	}
+
+	if rtypes == nil {
+		return theBottom
+	}
+	return NewSum(rtypes)
+}
+
+// byUniqueTypeName named type lists can be sorted by their unique type names.
+type byUniqueTypeName []Type
+
+func (a byUniqueTypeName) Len() int           { return len(a) }
+func (a byUniqueTypeName) Less(i, j int) bool { return sortName(a[i]) < sortName(a[j]) }
+func (a byUniqueTypeName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+
+func sortName(t Type) string {
+	if named := t.Named(); named != nil {
+		return named.obj.Id()
+	}
+	return ""
+}
+
+// byUniqueMethodName method lists can be sorted by their unique method names.
+type byUniqueMethodName []*Func
+
+func (a byUniqueMethodName) Len() int           { return len(a) }
+func (a byUniqueMethodName) Less(i, j int) bool { return a[i].Id() < a[j].Id() }
+func (a byUniqueMethodName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+
+func (check *Checker) tag(t *syntax.BasicLit) string {
+	if t != nil {
+		if t.Kind == syntax.StringLit {
+			if val, err := strconv.Unquote(t.Value); err == nil {
+				return val
+			}
+		}
+		check.invalidASTf(t, "incorrect tag syntax: %q", t.Value)
+	}
+	return ""
+}
+
+func (check *Checker) structType(styp *Struct, e *syntax.StructType) {
+	if e.FieldList == nil {
+		return
+	}
+
+	// struct fields and tags
+	var fields []*Var
+	var tags []string
+
+	// for double-declaration checks
+	var fset objset
+
+	// current field typ and tag
+	var typ Type
+	var tag string
+	add := func(ident *syntax.Name, embedded bool, pos syntax.Pos) {
+		if tag != "" && tags == nil {
+			tags = make([]string, len(fields))
+		}
+		if tags != nil {
+			tags = append(tags, tag)
+		}
+
+		name := ident.Value
+		fld := NewField(pos, check.pkg, name, typ, embedded)
+		// spec: "Within a struct, non-blank field names must be unique."
+		if name == "_" || check.declareInSet(&fset, pos, fld) {
+			fields = append(fields, fld)
+			check.recordDef(ident, fld)
+		}
+	}
+
+	// addInvalid adds an embedded field of invalid type to the struct for
+	// fields with errors; this keeps the number of struct fields in sync
+	// with the source as long as the fields are _ or have different names
+	// (issue #25627).
+	addInvalid := func(ident *syntax.Name, pos syntax.Pos) {
+		typ = Typ[Invalid]
+		tag = ""
+		add(ident, true, pos)
+	}
+
+	var prev syntax.Expr
+	for i, f := range e.FieldList {
+		// Fields declared syntactically with the same type (e.g.: a, b, c T)
+		// share the same type expression. Only check type if it's a new type.
+		if i == 0 || f.Type != prev {
+			typ = check.varType(f.Type)
+			prev = f.Type
+		}
+		if i < len(e.TagList) {
+			tag = check.tag(e.TagList[i])
+		}
+		if f.Name != nil {
+			// named field
+			add(f.Name, false, f.Name.Pos())
+		} else {
+			// embedded field
+			// spec: "An embedded type must be specified as a (possibly parenthesized) type name T or
+			// as a pointer to a non-interface type name *T, and T itself may not be a pointer type."
+			pos := startPos(f.Type)
+			name := embeddedFieldIdent(f.Type)
+			if name == nil {
+				check.errorf(pos, "invalid embedded field type %s", f.Type)
+				name = &syntax.Name{Value: "_"} // TODO(gri) need to set position to pos
+				addInvalid(name, pos)
+				continue
+			}
+			add(name, true, pos)
+			// Because we have a name, typ must be of the form T or *T, where T is the name
+			// of a (named or alias) type, and t (= deref(typ)) must be the type of T.
+			// We must delay this check to the end because we don't want to instantiate
+			// (via t.Under()) a possibly incomplete type.
+			embeddedTyp := typ // for closure below
+			embeddedPos := pos
+			check.atEnd(func() {
+				t, isPtr := deref(embeddedTyp)
+				switch t := optype(t.Under()).(type) {
+				case *Basic:
+					if t == Typ[Invalid] {
+						// error was reported before
+						return
+					}
+					// unsafe.Pointer is treated like a regular pointer
+					if t.kind == UnsafePointer {
+						check.errorf(embeddedPos, "embedded field type cannot be unsafe.Pointer")
+					}
+				case *Pointer:
+					check.errorf(embeddedPos, "embedded field type cannot be a pointer")
+				case *Interface:
+					if isPtr {
+						check.errorf(embeddedPos, "embedded field type cannot be a pointer to an interface")
+					}
+				}
+			})
+		}
+	}
+
+	styp.fields = fields
+	styp.tags = tags
+}
+
+func embeddedFieldIdent(e syntax.Expr) *syntax.Name {
+	switch e := e.(type) {
+	case *syntax.Name:
+		return e
+	case *syntax.Operation:
+		if base := ptrBase(e); base != nil {
+			// *T is valid, but **T is not
+			if op, _ := base.(*syntax.Operation); op == nil || ptrBase(op) == nil {
+				return embeddedFieldIdent(e.X)
+			}
+		}
+	case *syntax.SelectorExpr:
+		return e.Sel
+	case *syntax.IndexExpr:
+		return embeddedFieldIdent(e.X)
+	case *syntax.ParenExpr:
+		return embeddedFieldIdent(e.X)
+	}
+	return nil // invalid embedded field
+}
+
+func (check *Checker) collectTypeConstraints(pos syntax.Pos, types []syntax.Expr) []Type {
+	list := make([]Type, 0, len(types)) // assume all types are correct
+	for _, texpr := range types {
+		if texpr == nil {
+			check.invalidASTf(pos, "missing type constraint")
+			continue
+		}
+		typ := check.varType(texpr)
+		// A type constraint may be a predeclared type or a
+		// composite type composed of only predeclared types.
+		// TODO(gri) If we enable this again it also must run
+		// at the end.
+		const restricted = false
+		var why string
+		if restricted && !check.typeConstraint(typ, &why) {
+			check.errorf(texpr, "invalid type constraint %s (%s)", typ, why)
+			continue
+		}
+		list = append(list, typ)
+	}
+
+	// Ensure that each type is only present once in the type list.
+	// Types may be interfaces, which may not be complete yet. It's
+	// ok to do this check at the end because it's not a requirement
+	// for correctness of the code.
+	check.atEnd(func() {
+		uniques := make([]Type, 0, len(list)) // assume all types are unique
+		for i, t := range list {
+			if t := t.Interface(); t != nil {
+				check.completeInterface(types[i].Pos(), t)
+			}
+			if includes(uniques, t) {
+				check.softErrorf(types[i], "duplicate type %s in type list", t)
+			}
+			uniques = append(uniques, t)
+		}
+	})
+
+	return list
+}
+
+// includes reports whether typ is in list
+func includes(list []Type, typ Type) bool {
+	for _, e := range list {
+		if Identical(typ, e) {
+			return true
+		}
+	}
+	return false
+}
+
+// typeConstraint checks that typ may be used in a type list.
+// For now this just checks for the absence of defined (*Named) types.
+func (check *Checker) typeConstraint(typ Type, why *string) bool {
+	switch t := typ.(type) {
+	case *Basic:
+		// ok
+	case *Array:
+		return check.typeConstraint(t.elem, why)
+	case *Slice:
+		return check.typeConstraint(t.elem, why)
+	case *Struct:
+		for _, f := range t.fields {
+			if !check.typeConstraint(f.typ, why) {
+				return false
+			}
+		}
+	case *Pointer:
+		return check.typeConstraint(t.base, why)
+	case *Tuple:
+		if t == nil {
+			return true
+		}
+		for _, v := range t.vars {
+			if !check.typeConstraint(v.typ, why) {
+				return false
+			}
+		}
+	case *Signature:
+		if len(t.tparams) != 0 {
+			panic("type parameter in function type")
+		}
+		return (t.recv == nil || check.typeConstraint(t.recv.typ, why)) &&
+			check.typeConstraint(t.params, why) &&
+			check.typeConstraint(t.results, why)
+	case *Interface:
+		t.assertCompleteness()
+		for _, m := range t.allMethods {
+			if !check.typeConstraint(m.typ, why) {
+				return false
+			}
+		}
+	case *Map:
+		return check.typeConstraint(t.key, why) && check.typeConstraint(t.elem, why)
+	case *Chan:
+		return check.typeConstraint(t.elem, why)
+	case *Named:
+		*why = check.sprintf("contains defined type %s", t)
+		return false
+	case *TypeParam:
+		// ok, e.g.: func f (type T interface { type T }) ()
+	default:
+		unreachable()
+	}
+	return true
+}
+
+func ptrBase(x *syntax.Operation) syntax.Expr {
+	if x.Op == syntax.Mul && x.Y == nil {
+		return x.X
+	}
+	return nil
+}
diff --git a/src/cmd/compile/internal/types2/unify.go b/src/cmd/compile/internal/types2/unify.go
new file mode 100644
index 0000000000..7c639366ef
--- /dev/null
+++ b/src/cmd/compile/internal/types2/unify.go
@@ -0,0 +1,454 @@
+// UNREVIEWED
+// Copyright 2020 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.
+
+// This file implements type unification.
+
+package types2
+
+import "sort"
+
+// The unifier maintains two separate sets of type parameters x and y
+// which are used to resolve type parameters in the x and y arguments
+// provided to the unify call. For unidirectional unification, only
+// one of these sets (say x) is provided, and then type parameters are
+// only resolved for the x argument passed to unify, not the y argument
+// (even if that also contains possibly the same type parameters). This
+// is crucial to infer the type parameters of self-recursive calls:
+//
+//	func f[type P](a P) { f(a) }
+//
+// For the call f(a) we want to infer that the type argument for P is P.
+// During unification, the parameter type P must be resolved to the type
+// parameter P ("x" side), but the argument type P must be left alone so
+// that unification resolves the type parameter P to P.
+//
+// For bidirection unification, both sets are provided. This enables
+// unification to go from argument to parameter type and vice versa.
+// For constraint type inference, we use bidirectional unification
+// where both the x and y type parameters are identical. This is done
+// by setting up one of them (using init) and then assigning its value
+// to the other.
+
+// A unifier maintains the current type parameters for x and y
+// and the respective types inferred for each type parameter.
+// A unifier is created by calling newUnifier.
+type unifier struct {
+	check *Checker
+	exact bool
+	x, y  tparamsList // x and y must initialized via tparamsList.init
+	types []Type      // inferred types, shared by x and y
+}
+
+// newUnifier returns a new unifier.
+// If exact is set, unification requires unified types to match
+// exactly. If exact is not set, a named type's underlying type
+// is considered if unification would fail otherwise, and the
+// direction of channels is ignored.
+func newUnifier(check *Checker, exact bool) *unifier {
+	u := &unifier{check: check, exact: exact}
+	u.x.unifier = u
+	u.y.unifier = u
+	return u
+}
+
+// unify attempts to unify x and y and reports whether it succeeded.
+func (u *unifier) unify(x, y Type) bool {
+	return u.nify(x, y, nil)
+}
+
+// A tparamsList describes a list of type parameters and the types inferred for them.
+type tparamsList struct {
+	unifier *unifier
+	tparams []*TypeName
+	// For each tparams element, there is a corresponding type slot index in indices.
+	// index  < 0: unifier.types[-index] == nil
+	// index == 0: no type slot allocated yet
+	// index  > 0: unifier.types[index] == typ
+	// Joined tparams elements share the same type slot and thus have the same index.
+	// By using a negative index for nil types we don't need to check unifier.types
+	// to see if we have a type or not.
+	indices []int // len(d.indices) == len(d.tparams)
+}
+
+// init initializes d with the given type parameters.
+// The type parameters must be in the order in which they appear in their declaration
+// (this ensures that the tparams indices match the respective type parameter index).
+func (d *tparamsList) init(tparams []*TypeName) {
+	if len(tparams) == 0 {
+		return
+	}
+	if debug {
+		for i, tpar := range tparams {
+			assert(i == tpar.typ.(*TypeParam).index)
+		}
+	}
+	d.tparams = tparams
+	d.indices = make([]int, len(tparams))
+}
+
+// join unifies the i'th type parameter of x with the j'th type parameter of y.
+// If both type parameters already have a type associated with them and they are
+// not joined, join fails and return false.
+func (u *unifier) join(i, j int) bool {
+	ti := u.x.indices[i]
+	tj := u.y.indices[j]
+	switch {
+	case ti == 0 && tj == 0:
+		// Neither type parameter has a type slot associated with them.
+		// Allocate a new joined nil type slot (negative index).
+		u.types = append(u.types, nil)
+		u.x.indices[i] = -len(u.types)
+		u.y.indices[j] = -len(u.types)
+	case ti == 0:
+		// The type parameter for x has no type slot yet. Use slot of y.
+		u.x.indices[i] = tj
+	case tj == 0:
+		// The type parameter for y has no type slot yet. Use slot of x.
+		u.y.indices[j] = ti
+
+	// Both type parameters have a slot: ti != 0 && tj != 0.
+	case ti == tj:
+		// Both type parameters already share the same slot. Nothing to do.
+		break
+	case ti > 0 && tj > 0:
+		// Both type parameters have (possibly different) inferred types. Cannot join.
+		return false
+	case ti > 0:
+		// Only the type parameter for x has an inferred type. Use x slot for y.
+		u.y.setIndex(j, ti)
+	// This case is handled like the default case.
+	// case tj > 0:
+	// 	// Only the type parameter for y has an inferred type. Use y slot for x.
+	// 	u.x.setIndex(i, tj)
+	default:
+		// Neither type parameter has an inferred type. Use y slot for x
+		// (or x slot for y, it doesn't matter).
+		u.x.setIndex(i, tj)
+	}
+	return true
+}
+
+// If typ is a type parameter of d, index returns the type parameter index.
+// Otherwise, the result is < 0.
+func (d *tparamsList) index(typ Type) int {
+	if t, ok := typ.(*TypeParam); ok {
+		if i := t.index; i < len(d.tparams) && d.tparams[i].typ == t {
+			return i
+		}
+	}
+	return -1
+}
+
+// setIndex sets the type slot index for the i'th type parameter
+// (and all its joined parameters) to tj. The type parameter
+// must have a (possibly nil) type slot associated with it.
+func (d *tparamsList) setIndex(i, tj int) {
+	ti := d.indices[i]
+	assert(ti != 0 && tj != 0)
+	for k, tk := range d.indices {
+		if tk == ti {
+			d.indices[k] = tj
+		}
+	}
+}
+
+// at returns the type set for the i'th type parameter; or nil.
+func (d *tparamsList) at(i int) Type {
+	if ti := d.indices[i]; ti > 0 {
+		return d.unifier.types[ti-1]
+	}
+	return nil
+}
+
+// set sets the type typ for the i'th type parameter;
+// typ must not be nil and it must not have been set before.
+func (d *tparamsList) set(i int, typ Type) {
+	assert(typ != nil)
+	u := d.unifier
+	switch ti := d.indices[i]; {
+	case ti < 0:
+		u.types[-ti-1] = typ
+		d.setIndex(i, -ti)
+	case ti == 0:
+		u.types = append(u.types, typ)
+		d.indices[i] = len(u.types)
+	default:
+		panic("type already set")
+	}
+}
+
+// types returns the list of inferred types (via unification) for the type parameters
+// described by d, and an index. If all types were inferred, the returned index is < 0.
+// Otherwise, it is the index of the first type parameter which couldn't be inferred;
+// i.e., for which list[index] is nil.
+func (d *tparamsList) types() (list []Type, index int) {
+	list = make([]Type, len(d.tparams))
+	index = -1
+	for i := range d.tparams {
+		t := d.at(i)
+		list[i] = t
+		if index < 0 && t == nil {
+			index = i
+		}
+	}
+	return
+}
+
+func (u *unifier) nifyEq(x, y Type, p *ifacePair) bool {
+	return x == y || u.nify(x, y, p)
+}
+
+// nify implements the core unification algorithm which is an
+// adapted version of Checker.identical0. For changes to that
+// code the corresponding changes should be made here.
+// Must not be called directly from outside the unifier.
+func (u *unifier) nify(x, y Type, p *ifacePair) bool {
+	// types must be expanded for comparison
+	x = expand(x)
+	y = expand(y)
+
+	if !u.exact {
+		// If exact unification is known to fail because we attempt to
+		// match a type name against an unnamed type literal, consider
+		// the underlying type of the named type.
+		// (Subtle: We use isNamed to include any type with a name (incl.
+		// basic types and type parameters. We use Named() because we only
+		// want *Named types.)
+		switch {
+		case !isNamed(x) && y != nil && y.Named() != nil:
+			return u.nify(x, y.Under(), p)
+		case x != nil && x.Named() != nil && !isNamed(y):
+			return u.nify(x.Under(), y, p)
+		}
+	}
+
+	// Cases where at least one of x or y is a type parameter.
+	switch i, j := u.x.index(x), u.y.index(y); {
+	case i >= 0 && j >= 0:
+		// both x and y are type parameters
+		if u.join(i, j) {
+			return true
+		}
+		// both x and y have an inferred type - they must match
+		return u.nifyEq(u.x.at(i), u.y.at(j), p)
+
+	case i >= 0:
+		// x is a type parameter, y is not
+		if tx := u.x.at(i); tx != nil {
+			return u.nifyEq(tx, y, p)
+		}
+		// otherwise, infer type from y
+		u.x.set(i, y)
+		return true
+
+	case j >= 0:
+		// y is a type parameter, x is not
+		if ty := u.y.at(j); ty != nil {
+			return u.nifyEq(x, ty, p)
+		}
+		// otherwise, infer type from x
+		u.y.set(j, x)
+		return true
+	}
+
+	// For type unification, do not shortcut (x == y) for identical
+	// types. Instead keep comparing them element-wise to unify the
+	// matching (and equal type parameter types). A simple test case
+	// where this matters is: func f[P any](a P) { f(a) } .
+
+	switch x := x.(type) {
+	case *Basic:
+		// Basic types are singletons except for the rune and byte
+		// aliases, thus we cannot solely rely on the x == y check
+		// above. See also comment in TypeName.IsAlias.
+		if y, ok := y.(*Basic); ok {
+			return x.kind == y.kind
+		}
+
+	case *Array:
+		// Two array types are identical if they have identical element types
+		// and the same array length.
+		if y, ok := y.(*Array); ok {
+			// If one or both array lengths are unknown (< 0) due to some error,
+			// assume they are the same to avoid spurious follow-on errors.
+			return (x.len < 0 || y.len < 0 || x.len == y.len) && u.nify(x.elem, y.elem, p)
+		}
+
+	case *Slice:
+		// Two slice types are identical if they have identical element types.
+		if y, ok := y.(*Slice); ok {
+			return u.nify(x.elem, y.elem, p)
+		}
+
+	case *Struct:
+		// Two struct types are identical if they have the same sequence of fields,
+		// and if corresponding fields have the same names, and identical types,
+		// and identical tags. Two embedded fields are considered to have the same
+		// name. Lower-case field names from different packages are always different.
+		if y, ok := y.(*Struct); ok {
+			if x.NumFields() == y.NumFields() {
+				for i, f := range x.fields {
+					g := y.fields[i]
+					if f.embedded != g.embedded ||
+						x.Tag(i) != y.Tag(i) ||
+						!f.sameId(g.pkg, g.name) ||
+						!u.nify(f.typ, g.typ, p) {
+						return false
+					}
+				}
+				return true
+			}
+		}
+
+	case *Pointer:
+		// Two pointer types are identical if they have identical base types.
+		if y, ok := y.(*Pointer); ok {
+			return u.nify(x.base, y.base, p)
+		}
+
+	case *Tuple:
+		// Two tuples types are identical if they have the same number of elements
+		// and corresponding elements have identical types.
+		if y, ok := y.(*Tuple); ok {
+			if x.Len() == y.Len() {
+				if x != nil {
+					for i, v := range x.vars {
+						w := y.vars[i]
+						if !u.nify(v.typ, w.typ, p) {
+							return false
+						}
+					}
+				}
+				return true
+			}
+		}
+
+	case *Signature:
+		// Two function types are identical if they have the same number of parameters
+		// and result values, corresponding parameter and result types are identical,
+		// and either both functions are variadic or neither is. Parameter and result
+		// names are not required to match.
+		// TODO(gri) handle type parameters or document why we can ignore them.
+		if y, ok := y.(*Signature); ok {
+			return x.variadic == y.variadic &&
+				u.nify(x.params, y.params, p) &&
+				u.nify(x.results, y.results, p)
+		}
+
+	case *Sum:
+		// This should not happen with the current internal use of sum types.
+		panic("type inference across sum types not implemented")
+
+	case *Interface:
+		// Two interface types are identical if they have the same set of methods with
+		// the same names and identical function types. Lower-case method names from
+		// different packages are always different. The order of the methods is irrelevant.
+		if y, ok := y.(*Interface); ok {
+			// If identical0 is called (indirectly) via an external API entry point
+			// (such as Identical, IdenticalIgnoreTags, etc.), check is nil. But in
+			// that case, interfaces are expected to be complete and lazy completion
+			// here is not needed.
+			if u.check != nil {
+				u.check.completeInterface(nopos, x)
+				u.check.completeInterface(nopos, y)
+			}
+			a := x.allMethods
+			b := y.allMethods
+			if len(a) == len(b) {
+				// Interface types are the only types where cycles can occur
+				// that are not "terminated" via named types; and such cycles
+				// can only be created via method parameter types that are
+				// anonymous interfaces (directly or indirectly) embedding
+				// the current interface. Example:
+				//
+				//    type T interface {
+				//        m() interface{T}
+				//    }
+				//
+				// If two such (differently named) interfaces are compared,
+				// endless recursion occurs if the cycle is not detected.
+				//
+				// If x and y were compared before, they must be equal
+				// (if they were not, the recursion would have stopped);
+				// search the ifacePair stack for the same pair.
+				//
+				// This is a quadratic algorithm, but in practice these stacks
+				// are extremely short (bounded by the nesting depth of interface
+				// type declarations that recur via parameter types, an extremely
+				// rare occurrence). An alternative implementation might use a
+				// "visited" map, but that is probably less efficient overall.
+				q := &ifacePair{x, y, p}
+				for p != nil {
+					if p.identical(q) {
+						return true // same pair was compared before
+					}
+					p = p.prev
+				}
+				if debug {
+					assert(sort.IsSorted(byUniqueMethodName(a)))
+					assert(sort.IsSorted(byUniqueMethodName(b)))
+				}
+				for i, f := range a {
+					g := b[i]
+					if f.Id() != g.Id() || !u.nify(f.typ, g.typ, q) {
+						return false
+					}
+				}
+				return true
+			}
+		}
+
+	case *Map:
+		// Two map types are identical if they have identical key and value types.
+		if y, ok := y.(*Map); ok {
+			return u.nify(x.key, y.key, p) && u.nify(x.elem, y.elem, p)
+		}
+
+	case *Chan:
+		// Two channel types are identical if they have identical value types.
+		if y, ok := y.(*Chan); ok {
+			return (!u.exact || x.dir == y.dir) && u.nify(x.elem, y.elem, p)
+		}
+
+	case *Named:
+		// Two named types are identical if their type names originate
+		// in the same type declaration.
+		// if y, ok := y.(*Named); ok {
+		// 	return x.obj == y.obj
+		// }
+		if y, ok := y.(*Named); ok {
+			// TODO(gri) This is not always correct: two types may have the same names
+			//           in the same package if one of them is nested in a function.
+			//           Extremely unlikely but we need an always correct solution.
+			if x.obj.pkg == y.obj.pkg && x.obj.name == y.obj.name {
+				assert(len(x.targs) == len(y.targs))
+				for i, x := range x.targs {
+					if !u.nify(x, y.targs[i], p) {
+						return false
+					}
+				}
+				return true
+			}
+		}
+
+	case *TypeParam:
+		// Two type parameters (which are not part of the type parameters of the
+		// enclosing type as those are handled in the beginning of this function)
+		// are identical if they originate in the same declaration.
+		return x == y
+
+	// case *instance:
+	//	unreachable since types are expanded
+
+	case nil:
+		// avoid a crash in case of nil type
+
+	default:
+		u.check.dump("### u.nify(%s, %s), u.x.tparams = %s", x, y, u.x.tparams)
+		unreachable()
+	}
+
+	return false
+}
diff --git a/src/cmd/compile/internal/types2/universe.go b/src/cmd/compile/internal/types2/universe.go
new file mode 100644
index 0000000000..c1961d7455
--- /dev/null
+++ b/src/cmd/compile/internal/types2/universe.go
@@ -0,0 +1,282 @@
+// UNREVIEWED
+// Copyright 2011 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.
+
+// This file sets up the universe scope and the unsafe package.
+
+package types2
+
+import (
+	"go/constant"
+	"strings"
+)
+
+// The Universe scope contains all predeclared objects of Go.
+// It is the outermost scope of any chain of nested scopes.
+var Universe *Scope
+
+// The Unsafe package is the package returned by an importer
+// for the import path "unsafe".
+var Unsafe *Package
+
+var (
+	universeIota  *Const
+	universeByte  *Basic // uint8 alias, but has name "byte"
+	universeRune  *Basic // int32 alias, but has name "rune"
+	universeAny   *Named
+	universeError *Named
+)
+
+// Typ contains the predeclared *Basic types indexed by their
+// corresponding BasicKind.
+//
+// The *Basic type for Typ[Byte] will have the name "uint8".
+// Use Universe.Lookup("byte").Type() to obtain the specific
+// alias basic type named "byte" (and analogous for "rune").
+var Typ = []*Basic{
+	Invalid: {Invalid, 0, "invalid type", aType{}},
+
+	Bool:          {Bool, IsBoolean, "bool", aType{}},
+	Int:           {Int, IsInteger, "int", aType{}},
+	Int8:          {Int8, IsInteger, "int8", aType{}},
+	Int16:         {Int16, IsInteger, "int16", aType{}},
+	Int32:         {Int32, IsInteger, "int32", aType{}},
+	Int64:         {Int64, IsInteger, "int64", aType{}},
+	Uint:          {Uint, IsInteger | IsUnsigned, "uint", aType{}},
+	Uint8:         {Uint8, IsInteger | IsUnsigned, "uint8", aType{}},
+	Uint16:        {Uint16, IsInteger | IsUnsigned, "uint16", aType{}},
+	Uint32:        {Uint32, IsInteger | IsUnsigned, "uint32", aType{}},
+	Uint64:        {Uint64, IsInteger | IsUnsigned, "uint64", aType{}},
+	Uintptr:       {Uintptr, IsInteger | IsUnsigned, "uintptr", aType{}},
+	Float32:       {Float32, IsFloat, "float32", aType{}},
+	Float64:       {Float64, IsFloat, "float64", aType{}},
+	Complex64:     {Complex64, IsComplex, "complex64", aType{}},
+	Complex128:    {Complex128, IsComplex, "complex128", aType{}},
+	String:        {String, IsString, "string", aType{}},
+	UnsafePointer: {UnsafePointer, 0, "Pointer", aType{}},
+
+	UntypedBool:    {UntypedBool, IsBoolean | IsUntyped, "untyped bool", aType{}},
+	UntypedInt:     {UntypedInt, IsInteger | IsUntyped, "untyped int", aType{}},
+	UntypedRune:    {UntypedRune, IsInteger | IsUntyped, "untyped rune", aType{}},
+	UntypedFloat:   {UntypedFloat, IsFloat | IsUntyped, "untyped float", aType{}},
+	UntypedComplex: {UntypedComplex, IsComplex | IsUntyped, "untyped complex", aType{}},
+	UntypedString:  {UntypedString, IsString | IsUntyped, "untyped string", aType{}},
+	UntypedNil:     {UntypedNil, IsUntyped, "untyped nil", aType{}},
+}
+
+var aliases = [...]*Basic{
+	{Byte, IsInteger | IsUnsigned, "byte", aType{}},
+	{Rune, IsInteger, "rune", aType{}},
+}
+
+func defPredeclaredTypes() {
+	for _, t := range Typ {
+		def(NewTypeName(nopos, nil, t.name, t))
+	}
+	for _, t := range aliases {
+		def(NewTypeName(nopos, nil, t.name, t))
+	}
+
+	// any
+	// (Predeclared and entered into universe scope so we do all the
+	// usual checks; but removed again from scope later since it's
+	// only visible as constraint in a type parameter list.)
+	{
+		typ := &Named{underlying: &emptyInterface}
+		def(NewTypeName(nopos, nil, "any", typ))
+	}
+
+	// Error has a nil package in its qualified name since it is in no package
+	{
+		res := NewVar(nopos, nil, "", Typ[String])
+		sig := &Signature{results: NewTuple(res)}
+		err := NewFunc(nopos, nil, "Error", sig)
+		typ := &Named{underlying: NewInterfaceType([]*Func{err}, nil).Complete()}
+		sig.recv = NewVar(nopos, nil, "", typ)
+		def(NewTypeName(nopos, nil, "error", typ))
+	}
+}
+
+var predeclaredConsts = [...]struct {
+	name string
+	kind BasicKind
+	val  constant.Value
+}{
+	{"true", UntypedBool, constant.MakeBool(true)},
+	{"false", UntypedBool, constant.MakeBool(false)},
+	{"iota", UntypedInt, constant.MakeInt64(0)},
+}
+
+func defPredeclaredConsts() {
+	for _, c := range predeclaredConsts {
+		def(NewConst(nopos, nil, c.name, Typ[c.kind], c.val))
+	}
+}
+
+func defPredeclaredNil() {
+	def(&Nil{object{name: "nil", typ: Typ[UntypedNil], color_: black}})
+}
+
+// A builtinId is the id of a builtin function.
+type builtinId int
+
+const (
+	// universe scope
+	_Append builtinId = iota
+	_Cap
+	_Close
+	_Complex
+	_Copy
+	_Delete
+	_Imag
+	_Len
+	_Make
+	_New
+	_Panic
+	_Print
+	_Println
+	_Real
+	_Recover
+
+	// package unsafe
+	_Alignof
+	_Offsetof
+	_Sizeof
+
+	// testing support
+	_Assert
+	_Trace
+)
+
+var predeclaredFuncs = [...]struct {
+	name     string
+	nargs    int
+	variadic bool
+	kind     exprKind
+}{
+	_Append:  {"append", 1, true, expression},
+	_Cap:     {"cap", 1, false, expression},
+	_Close:   {"close", 1, false, statement},
+	_Complex: {"complex", 2, false, expression},
+	_Copy:    {"copy", 2, false, statement},
+	_Delete:  {"delete", 2, false, statement},
+	_Imag:    {"imag", 1, false, expression},
+	_Len:     {"len", 1, false, expression},
+	_Make:    {"make", 1, true, expression},
+	_New:     {"new", 1, false, expression},
+	_Panic:   {"panic", 1, false, statement},
+	_Print:   {"print", 0, true, statement},
+	_Println: {"println", 0, true, statement},
+	_Real:    {"real", 1, false, expression},
+	_Recover: {"recover", 0, false, statement},
+
+	_Alignof:  {"Alignof", 1, false, expression},
+	_Offsetof: {"Offsetof", 1, false, expression},
+	_Sizeof:   {"Sizeof", 1, false, expression},
+
+	_Assert: {"assert", 1, false, statement},
+	_Trace:  {"trace", 0, true, statement},
+}
+
+func defPredeclaredFuncs() {
+	for i := range predeclaredFuncs {
+		id := builtinId(i)
+		if id == _Assert || id == _Trace {
+			continue // only define these in testing environment
+		}
+		def(newBuiltin(id))
+	}
+}
+
+// DefPredeclaredTestFuncs defines the assert and trace built-ins.
+// These built-ins are intended for debugging and testing of this
+// package only.
+func DefPredeclaredTestFuncs() {
+	if Universe.Lookup("assert") != nil {
+		return // already defined
+	}
+	def(newBuiltin(_Assert))
+	def(newBuiltin(_Trace))
+}
+
+func defPredeclaredComparable() {
+	// The "comparable" interface can be imagined as defined like
+	//
+	// type comparable interface {
+	//         == () untyped bool
+	//         != () untyped bool
+	// }
+	//
+	// == and != cannot be user-declared but we can declare
+	// a magic method == and check for its presence when needed.
+
+	// Define interface { == () }. We don't care about the signature
+	// for == so leave it empty except for the receiver, which is
+	// set up later to match the usual interface method assumptions.
+	sig := new(Signature)
+	eql := NewFunc(nopos, nil, "==", sig)
+	iface := NewInterfaceType([]*Func{eql}, nil).Complete()
+
+	// set up the defined type for the interface
+	obj := NewTypeName(nopos, nil, "comparable", nil)
+	named := NewNamed(obj, iface, nil)
+	obj.color_ = black
+	sig.recv = NewVar(nopos, nil, "", named) // complete == signature
+
+	def(obj)
+}
+
+func init() {
+	Universe = NewScope(nil, nopos, nopos, "universe")
+	Unsafe = NewPackage("unsafe", "unsafe")
+	Unsafe.complete = true
+
+	defPredeclaredTypes()
+	defPredeclaredConsts()
+	defPredeclaredNil()
+	defPredeclaredFuncs()
+	defPredeclaredComparable()
+
+	universeIota = Universe.Lookup("iota").(*Const)
+	universeByte = Universe.Lookup("byte").(*TypeName).typ.(*Basic)
+	universeRune = Universe.Lookup("rune").(*TypeName).typ.(*Basic)
+	universeAny = Universe.Lookup("any").(*TypeName).typ.(*Named)
+	universeError = Universe.Lookup("error").(*TypeName).typ.(*Named)
+
+	// "any" is only visible as constraint in a type parameter list
+	delete(Universe.elems, "any")
+}
+
+// Objects with names containing blanks are internal and not entered into
+// a scope. Objects with exported names are inserted in the unsafe package
+// scope; other objects are inserted in the universe scope.
+//
+func def(obj Object) {
+	assert(obj.color() == black)
+	name := obj.Name()
+	if strings.Contains(name, " ") {
+		return // nothing to do
+	}
+	// fix Obj link for named types
+	if typ := obj.Type().Named(); typ != nil {
+		typ.obj = obj.(*TypeName)
+	}
+	// exported identifiers go into package unsafe
+	scope := Universe
+	if obj.Exported() {
+		scope = Unsafe.scope
+		// set Pkg field
+		switch obj := obj.(type) {
+		case *TypeName:
+			obj.pkg = Unsafe
+		case *Builtin:
+			obj.pkg = Unsafe
+		default:
+			unreachable()
+		}
+	}
+	if scope.Insert(obj) != nil {
+		panic("internal error: double declaration")
+	}
+}
diff --git a/src/cmd/compile/internal/types2/walk.go b/src/cmd/compile/internal/types2/walk.go
new file mode 100644
index 0000000000..18cfb28ade
--- /dev/null
+++ b/src/cmd/compile/internal/types2/walk.go
@@ -0,0 +1,322 @@
+// UNREVIEWED
+// Copyright 2012 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.
+
+// This file implements syntax tree walking.
+// TODO(gri) A more general API should probably be in
+//           the syntax package.
+
+package types2
+
+import (
+	"cmd/compile/internal/syntax"
+	"fmt"
+)
+
+// Walk traverses a syntax in pre-order: It starts by calling f(root);
+// root must not be nil. If f returns false (== "continue"), Walk calls
+// f recursively for each of the non-nil children of that node; if f
+// returns true (== "stop"), Walk does not traverse the respective node's
+// children.
+// Some nodes may be shared among multiple parent nodes (e.g., types in
+// field lists such as type T in "a, b, c T"). Such shared nodes are
+// walked multiple times.
+// TODO(gri) Revisit this design. It may make sense to walk those nodes
+//           only once. A place where this matters is TestResolveIdents.
+func Walk(root syntax.Node, f func(syntax.Node) bool) {
+	w := walker{f}
+	w.node(root)
+}
+
+type walker struct {
+	f func(syntax.Node) bool
+}
+
+func (w *walker) node(n syntax.Node) {
+	if n == nil {
+		panic("invalid syntax tree: nil node")
+	}
+
+	if w.f(n) {
+		return
+	}
+
+	switch n := n.(type) {
+	// packages
+	case *syntax.File:
+		w.node(n.PkgName)
+		w.declList(n.DeclList)
+
+	// declarations
+	case *syntax.ImportDecl:
+		if n.LocalPkgName != nil {
+			w.node(n.LocalPkgName)
+		}
+		w.node(n.Path)
+
+	case *syntax.ConstDecl:
+		w.nameList(n.NameList)
+		if n.Type != nil {
+			w.node(n.Type)
+		}
+		if n.Values != nil {
+			w.node(n.Values)
+		}
+
+	case *syntax.TypeDecl:
+		w.node(n.Name)
+		w.fieldList(n.TParamList)
+		w.node(n.Type)
+
+	case *syntax.VarDecl:
+		w.nameList(n.NameList)
+		if n.Type != nil {
+			w.node(n.Type)
+		}
+		if n.Values != nil {
+			w.node(n.Values)
+		}
+
+	case *syntax.FuncDecl:
+		if n.Recv != nil {
+			w.node(n.Recv)
+		}
+		w.node(n.Name)
+		w.fieldList(n.TParamList)
+		w.node(n.Type)
+		if n.Body != nil {
+			w.node(n.Body)
+		}
+
+	// expressions
+	case *syntax.BadExpr: // nothing to do
+	case *syntax.Name:
+	case *syntax.BasicLit: // nothing to do
+
+	case *syntax.CompositeLit:
+		if n.Type != nil {
+			w.node(n.Type)
+		}
+		w.exprList(n.ElemList)
+
+	case *syntax.KeyValueExpr:
+		w.node(n.Key)
+		w.node(n.Value)
+
+	case *syntax.FuncLit:
+		w.node(n.Type)
+		w.node(n.Body)
+
+	case *syntax.ParenExpr:
+		w.node(n.X)
+
+	case *syntax.SelectorExpr:
+		w.node(n.X)
+		w.node(n.Sel)
+
+	case *syntax.IndexExpr:
+		w.node(n.X)
+		w.node(n.Index)
+
+	case *syntax.SliceExpr:
+		w.node(n.X)
+		for _, x := range n.Index {
+			if x != nil {
+				w.node(x)
+			}
+		}
+
+	case *syntax.AssertExpr:
+		w.node(n.X)
+		w.node(n.Type)
+
+	case *syntax.TypeSwitchGuard:
+		if n.Lhs != nil {
+			w.node(n.Lhs)
+		}
+		w.node(n.X)
+
+	case *syntax.Operation:
+		w.node(n.X)
+		if n.Y != nil {
+			w.node(n.Y)
+		}
+
+	case *syntax.CallExpr:
+		w.node(n.Fun)
+		w.exprList(n.ArgList)
+
+	case *syntax.ListExpr:
+		w.exprList(n.ElemList)
+
+	// types
+	case *syntax.ArrayType:
+		if n.Len != nil {
+			w.node(n.Len)
+		}
+		w.node(n.Elem)
+
+	case *syntax.SliceType:
+		w.node(n.Elem)
+
+	case *syntax.DotsType:
+		w.node(n.Elem)
+
+	case *syntax.StructType:
+		w.fieldList(n.FieldList)
+		for _, t := range n.TagList {
+			if t != nil {
+				w.node(t)
+			}
+		}
+
+	case *syntax.Field:
+		if n.Name != nil {
+			w.node(n.Name)
+		}
+		w.node(n.Type)
+
+	case *syntax.InterfaceType:
+		w.fieldList(n.MethodList)
+
+	case *syntax.FuncType:
+		w.fieldList(n.ParamList)
+		w.fieldList(n.ResultList)
+
+	case *syntax.MapType:
+		w.node(n.Key)
+		w.node(n.Value)
+
+	case *syntax.ChanType:
+		w.node(n.Elem)
+
+	// statements
+	case *syntax.EmptyStmt: // nothing to do
+
+	case *syntax.LabeledStmt:
+		w.node(n.Label)
+		w.node(n.Stmt)
+
+	case *syntax.BlockStmt:
+		w.stmtList(n.List)
+
+	case *syntax.ExprStmt:
+		w.node(n.X)
+
+	case *syntax.SendStmt:
+		w.node(n.Chan)
+		w.node(n.Value)
+
+	case *syntax.DeclStmt:
+		w.declList(n.DeclList)
+
+	case *syntax.AssignStmt:
+		w.node(n.Lhs)
+		w.node(n.Rhs)
+
+	case *syntax.BranchStmt:
+		if n.Label != nil {
+			w.node(n.Label)
+		}
+		// Target points to nodes elsewhere in the syntax tree
+
+	case *syntax.CallStmt:
+		w.node(n.Call)
+
+	case *syntax.ReturnStmt:
+		if n.Results != nil {
+			w.node(n.Results)
+		}
+
+	case *syntax.IfStmt:
+		if n.Init != nil {
+			w.node(n.Init)
+		}
+		w.node(n.Cond)
+		w.node(n.Then)
+		if n.Else != nil {
+			w.node(n.Else)
+		}
+
+	case *syntax.ForStmt:
+		if n.Init != nil {
+			w.node(n.Init)
+		}
+		if n.Cond != nil {
+			w.node(n.Cond)
+		}
+		if n.Post != nil {
+			w.node(n.Post)
+		}
+		w.node(n.Body)
+
+	case *syntax.SwitchStmt:
+		if n.Init != nil {
+			w.node(n.Init)
+		}
+		if n.Tag != nil {
+			w.node(n.Tag)
+		}
+		for _, s := range n.Body {
+			w.node(s)
+		}
+
+	case *syntax.SelectStmt:
+		for _, s := range n.Body {
+			w.node(s)
+		}
+
+	// helper nodes
+	case *syntax.RangeClause:
+		if n.Lhs != nil {
+			w.node(n.Lhs)
+		}
+		w.node(n.X)
+
+	case *syntax.CaseClause:
+		if n.Cases != nil {
+			w.node(n.Cases)
+		}
+		w.stmtList(n.Body)
+
+	case *syntax.CommClause:
+		if n.Comm != nil {
+			w.node(n.Comm)
+		}
+		w.stmtList(n.Body)
+
+	default:
+		panic(fmt.Sprintf("internal error: unknown node type %T", n))
+	}
+}
+
+func (w *walker) declList(list []syntax.Decl) {
+	for _, n := range list {
+		w.node(n)
+	}
+}
+
+func (w *walker) exprList(list []syntax.Expr) {
+	for _, n := range list {
+		w.node(n)
+	}
+}
+
+func (w *walker) stmtList(list []syntax.Stmt) {
+	for _, n := range list {
+		w.node(n)
+	}
+}
+
+func (w *walker) nameList(list []*syntax.Name) {
+	for _, n := range list {
+		w.node(n)
+	}
+}
+
+func (w *walker) fieldList(list []*syntax.Field) {
+	for _, n := range list {
+		w.node(n)
+	}
+}
-- 
GitLab


From befc62a2c47859d4cb63ee1f9b6e0b7f95a4c50a Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 19 Oct 2020 21:10:37 -0700
Subject: [PATCH 0010/2400] [dev.typeparams] cmd/compile/internal/types2: add
 testdata directory

Exact copy of src/go/types/testdata. Testdata tests still disabled.

Change-Id: Idff5fff7f1adcfd626f700b1f21f5a14ce1a74f1
Reviewed-on: https://go-review.googlesource.com/c/go/+/263630
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 .../internal/types2/testdata/blank.src        |   5 +
 .../internal/types2/testdata/builtins.src     | 902 ++++++++++++++++
 .../internal/types2/testdata/const0.src       | 350 +++++++
 .../internal/types2/testdata/const1.src       | 322 ++++++
 .../internal/types2/testdata/constdecl.src    | 110 ++
 .../internal/types2/testdata/conversions.src  |  93 ++
 .../internal/types2/testdata/conversions2.src | 313 ++++++
 .../internal/types2/testdata/cycles.src       | 174 ++++
 .../internal/types2/testdata/cycles1.src      |  77 ++
 .../internal/types2/testdata/cycles2.src      |  98 ++
 .../internal/types2/testdata/cycles3.src      |  60 ++
 .../internal/types2/testdata/cycles4.src      | 110 ++
 .../internal/types2/testdata/cycles5.src      | 200 ++++
 .../internal/types2/testdata/decls0.src       | 206 ++++
 .../internal/types2/testdata/decls1.src       | 144 +++
 .../internal/types2/testdata/decls3.src       | 309 ++++++
 .../internal/types2/testdata/decls4.src       | 199 ++++
 .../internal/types2/testdata/decls5.src       |  10 +
 .../internal/types2/testdata/errors.src       |  60 ++
 .../internal/types2/testdata/expr0.src        | 180 ++++
 .../internal/types2/testdata/expr1.src        | 127 +++
 .../internal/types2/testdata/expr2.src        | 260 +++++
 .../internal/types2/testdata/expr3.src        | 562 ++++++++++
 .../internal/types2/testdata/gotos.src        | 560 ++++++++++
 .../internal/types2/testdata/importC.src      |  54 +
 .../internal/types2/testdata/init0.src        | 106 ++
 .../internal/types2/testdata/init1.src        |  97 ++
 .../internal/types2/testdata/init2.src        | 139 +++
 .../internal/types2/testdata/issues.src       | 365 +++++++
 .../internal/types2/testdata/labels.src       | 207 ++++
 .../internal/types2/testdata/literals.src     | 111 ++
 .../internal/types2/testdata/methodsets.src   | 214 ++++
 .../internal/types2/testdata/shifts.src       | 395 +++++++
 .../internal/types2/testdata/stmt0.src        | 980 ++++++++++++++++++
 .../internal/types2/testdata/stmt1.src        | 259 +++++
 .../internal/types2/testdata/vardecl.src      | 206 ++++
 36 files changed, 8564 insertions(+)
 create mode 100644 src/cmd/compile/internal/types2/testdata/blank.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/builtins.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/const0.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/const1.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/constdecl.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/conversions.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/conversions2.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/cycles.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/cycles1.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/cycles2.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/cycles3.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/cycles4.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/cycles5.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/decls0.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/decls1.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/decls3.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/decls4.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/decls5.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/errors.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/expr0.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/expr1.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/expr2.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/expr3.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/gotos.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/importC.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/init0.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/init1.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/init2.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/issues.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/labels.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/literals.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/methodsets.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/shifts.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/stmt0.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/stmt1.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/vardecl.src

diff --git a/src/cmd/compile/internal/types2/testdata/blank.src b/src/cmd/compile/internal/types2/testdata/blank.src
new file mode 100644
index 0000000000..6a2507f482
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/blank.src
@@ -0,0 +1,5 @@
+// Copyright 2014 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 _ /* ERROR invalid package name */
diff --git a/src/cmd/compile/internal/types2/testdata/builtins.src b/src/cmd/compile/internal/types2/testdata/builtins.src
new file mode 100644
index 0000000000..ecdba51553
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/builtins.src
@@ -0,0 +1,902 @@
+// Copyright 2012 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.
+
+// builtin calls
+
+package builtins
+
+import "unsafe"
+
+func f0() {}
+
+func append1() {
+	var b byte
+	var x int
+	var s []byte
+	_ = append() // ERROR not enough arguments
+	_ = append("foo" /* ERROR not a slice */ )
+	_ = append(nil /* ERROR not a slice */ , s)
+	_ = append(x /* ERROR not a slice */ , s)
+	_ = append(s)
+	_ = append(s, nil...)
+	append /* ERROR not used */ (s)
+
+	_ = append(s, b)
+	_ = append(s, x /* ERROR cannot use x */ )
+	_ = append(s, s /* ERROR cannot use s */ )
+	_ = append(s... /* ERROR can only use ... with matching parameter */ )
+	_ = append(s, b, s... /* ERROR can only use ... with matching parameter */ )
+	_ = append(s, 1, 2, 3)
+	_ = append(s, 1, 2, 3, x /* ERROR cannot use x */ , 5, 6, 6)
+	_ = append(s, 1, 2, s... /* ERROR can only use ... with matching parameter */ )
+	_ = append([]interface{}(nil), 1, 2, "foo", x, 3.1425, false)
+
+	type S []byte
+	type T string
+	var t T
+	_ = append(s, "foo" /* ERROR cannot convert */ )
+	_ = append(s, "foo"...)
+	_ = append(S(s), "foo" /* ERROR cannot convert */ )
+	_ = append(S(s), "foo"...)
+	_ = append(s, t /* ERROR cannot use t */ )
+	_ = append(s, t...)
+	_ = append(s, T("foo")...)
+	_ = append(S(s), t /* ERROR cannot use t */ )
+	_ = append(S(s), t...)
+	_ = append(S(s), T("foo")...)
+	_ = append([]string{}, t /* ERROR cannot use t */ , "foo")
+	_ = append([]T{}, t, "foo")
+}
+
+// from the spec
+func append2() {
+	s0 := []int{0, 0}
+	s1 := append(s0, 2)                // append a single element     s1 == []int{0, 0, 2}
+	s2 := append(s1, 3, 5, 7)          // append multiple elements    s2 == []int{0, 0, 2, 3, 5, 7}
+	s3 := append(s2, s0...)            // append a slice              s3 == []int{0, 0, 2, 3, 5, 7, 0, 0}
+	s4 := append(s3[3:6], s3[2:]...)   // append overlapping slice    s4 == []int{3, 5, 7, 2, 3, 5, 7, 0, 0}
+
+	var t []interface{}
+	t = append(t, 42, 3.1415, "foo")   //                             t == []interface{}{42, 3.1415, "foo"}
+
+	var b []byte
+	b = append(b, "bar"...)            // append string contents      b == []byte{'b', 'a', 'r' }
+
+	_ = s4
+}
+
+func append3() {
+	f1 := func() (s []int) { return }
+	f2 := func() (s []int, x int) { return }
+	f3 := func() (s []int, x, y int) { return }
+	f5 := func() (s []interface{}, x int, y float32, z string, b bool) { return }
+	ff := func() (int, float32) { return 0, 0 }
+	_ = append(f0 /* ERROR used as value */ ())
+	_ = append(f1())
+	_ = append(f2())
+	_ = append(f3())
+	_ = append(f5())
+	_ = append(ff /* ERROR not a slice */ ()) // TODO(gri) better error message
+}
+
+func cap1() {
+	var a [10]bool
+	var p *[20]int
+	var c chan string
+	_ = cap() // ERROR not enough arguments
+	_ = cap(1, 2) // ERROR too many arguments
+	_ = cap(42 /* ERROR invalid */)
+	const _3 = cap(a)
+	assert(_3 == 10)
+	const _4 = cap(p)
+	assert(_4 == 20)
+	_ = cap(c)
+	cap /* ERROR not used */ (c)
+
+	// issue 4744
+	type T struct{ a [10]int }
+	const _ = cap(((*T)(nil)).a)
+
+	var s [][]byte
+	_ = cap(s)
+	_ = cap(s... /* ERROR invalid use of \.\.\. */ )
+}
+
+func cap2() {
+	f1a := func() (a [10]int) { return }
+	f1s := func() (s []int) { return }
+	f2 := func() (s []int, x int) { return }
+	_ = cap(f0 /* ERROR used as value */ ())
+	_ = cap(f1a())
+	_ = cap(f1s())
+	_ = cap(f2()) // ERROR too many arguments
+}
+
+// test cases for issue 7387
+func cap3() {
+	var f = func() int { return 0 }
+	var x = f()
+	const (
+		_ = cap([4]int{})
+		_ = cap([4]int{x})
+		_ = cap /* ERROR not constant */ ([4]int{f()})
+		_ = cap /* ERROR not constant */ ([4]int{cap([]int{})})
+		_ = cap([4]int{cap([4]int{})})
+	)
+	var y float64
+	var z complex128
+	const (
+		_ = cap([4]float64{})
+		_ = cap([4]float64{y})
+		_ = cap([4]float64{real(2i)})
+		_ = cap /* ERROR not constant */ ([4]float64{real(z)})
+	)
+	var ch chan [10]int
+	const (
+		_ = cap /* ERROR not constant */ (<-ch)
+		_ = cap /* ERROR not constant */ ([4]int{(<-ch)[0]})
+	)
+}
+
+func close1() {
+	var c chan int
+	var r <-chan int
+	close() // ERROR not enough arguments
+	close(1, 2) // ERROR too many arguments
+	close(42 /* ERROR not a channel */)
+	close(r /* ERROR receive-only channel */)
+	close(c)
+	_ = close /* ERROR used as value */ (c)
+
+	var s []chan int
+	close(s... /* ERROR invalid use of \.\.\. */ )
+}
+
+func close2() {
+	f1 := func() (ch chan int) { return }
+	f2 := func() (ch chan int, x int) { return }
+	close(f0 /* ERROR used as value */ ())
+	close(f1())
+	close(f2()) // ERROR too many arguments
+}
+
+func complex1() {
+	var i32 int32
+	var f32 float32
+	var f64 float64
+	var c64 complex64
+	var c128 complex128
+	_ = complex() // ERROR not enough arguments
+	_ = complex(1) // ERROR not enough arguments
+	_ = complex(true /* ERROR mismatched types */ , 0)
+	_ = complex(i32 /* ERROR expected floating-point */ , 0)
+	_ = complex("foo" /* ERROR mismatched types */ , 0)
+	_ = complex(c64 /* ERROR expected floating-point */ , 0)
+	_ = complex(0 /* ERROR mismatched types */ , true)
+	_ = complex(0 /* ERROR expected floating-point */ , i32)
+	_ = complex(0 /* ERROR mismatched types */ , "foo")
+	_ = complex(0 /* ERROR expected floating-point */ , c64)
+	_ = complex(f32, f32)
+	_ = complex(f32, 1)
+	_ = complex(f32, 1.0)
+	_ = complex(f32, 'a')
+	_ = complex(f64, f64)
+	_ = complex(f64, 1)
+	_ = complex(f64, 1.0)
+	_ = complex(f64, 'a')
+	_ = complex(f32 /* ERROR mismatched types */ , f64)
+	_ = complex(f64 /* ERROR mismatched types */ , f32)
+	_ = complex(1, 1)
+	_ = complex(1, 1.1)
+	_ = complex(1, 'a')
+	complex /* ERROR not used */ (1, 2)
+
+	var _ complex64 = complex(f32, f32)
+	var _ complex64 = complex /* ERROR cannot use .* in variable declaration */ (f64, f64)
+
+	var _ complex128 = complex /* ERROR cannot use .* in variable declaration */ (f32, f32)
+	var _ complex128 = complex(f64, f64)
+
+	// untyped constants
+	const _ int = complex(1, 0)
+	const _ float32 = complex(1, 0)
+	const _ complex64 = complex(1, 0)
+	const _ complex128 = complex(1, 0)
+	const _ = complex(0i, 0i)
+	const _ = complex(0i, 0)
+	const _ int = 1.0 + complex(1, 0i)
+
+	const _ int = complex /* ERROR int */ (1.1, 0)
+	const _ float32 = complex /* ERROR float32 */ (1, 2)
+
+	// untyped values
+	var s uint
+	_ = complex(1 /* ERROR integer */ <<s, 0)
+	const _ = complex /* ERROR not constant */ (1 /* ERROR integer */ <<s, 0)
+	var _ int = complex /* ERROR cannot use .* in variable declaration */ (1 /* ERROR integer */ <<s, 0)
+
+	// floating-point argument types must be identical
+	type F32 float32
+	type F64 float64
+	var x32 F32
+	var x64 F64
+	c64 = complex(x32, x32)
+	_ = complex(x32 /* ERROR mismatched types */ , f32)
+	_ = complex(f32 /* ERROR mismatched types */ , x32)
+	c128 = complex(x64, x64)
+	_ = c128
+	_ = complex(x64 /* ERROR mismatched types */ , f64)
+	_ = complex(f64 /* ERROR mismatched types */ , x64)
+
+	var t []float32
+	_ = complex(t... /* ERROR invalid use of \.\.\. */ )
+}
+
+func complex2() {
+	f1 := func() (x float32) { return }
+	f2 := func() (x, y float32) { return }
+	f3 := func() (x, y, z float32) { return }
+	_ = complex(f0 /* ERROR used as value */ ())
+	_ = complex(f1()) // ERROR not enough arguments
+	_ = complex(f2())
+	_ = complex(f3()) // ERROR too many arguments
+}
+
+func copy1() {
+	copy() // ERROR not enough arguments
+	copy("foo") // ERROR not enough arguments
+	copy([ /* ERROR copy expects slice arguments */ ...]int{}, []int{})
+	copy([ /* ERROR copy expects slice arguments */ ]int{}, [...]int{})
+	copy([ /* ERROR different element types */ ]int8{}, "foo")
+
+	// spec examples
+	var a = [...]int{0, 1, 2, 3, 4, 5, 6, 7}
+	var s = make([]int, 6)
+	var b = make([]byte, 5)
+	n1 := copy(s, a[0:])            // n1 == 6, s == []int{0, 1, 2, 3, 4, 5}
+	n2 := copy(s, s[2:])            // n2 == 4, s == []int{2, 3, 4, 5, 4, 5}
+	n3 := copy(b, "Hello, World!")  // n3 == 5, b == []byte("Hello")
+	_, _, _ = n1, n2, n3
+
+	var t [][]int
+	copy(t, t)
+	copy(t /* ERROR copy expects slice arguments */ , nil)
+	copy(nil /* ERROR copy expects slice arguments */ , t)
+	copy(nil /* ERROR copy expects slice arguments */ , nil)
+	copy(t... /* ERROR invalid use of \.\.\. */ )
+}
+
+func copy2() {
+	f1 := func() (a []int) { return }
+	f2 := func() (a, b []int) { return }
+	f3 := func() (a, b, c []int) { return }
+	copy(f0 /* ERROR used as value */ ())
+	copy(f1()) // ERROR not enough arguments
+	copy(f2())
+	copy(f3()) // ERROR too many arguments
+}
+
+func delete1() {
+	var m map[string]int
+	var s string
+	delete() // ERROR not enough arguments
+	delete(1) // ERROR not enough arguments
+	delete(1, 2, 3) // ERROR too many arguments
+	delete(m, 0 /* ERROR not assignable */)
+	delete(m, s)
+	_ = delete /* ERROR used as value */ (m, s)
+
+	var t []map[string]string
+	delete(t... /* ERROR invalid use of \.\.\. */ )
+}
+
+func delete2() {
+	f1 := func() (m map[string]int) { return }
+	f2 := func() (m map[string]int, k string) { return }
+	f3 := func() (m map[string]int, k string, x float32) { return }
+	delete(f0 /* ERROR used as value */ ())
+	delete(f1()) // ERROR not enough arguments
+	delete(f2())
+	delete(f3()) // ERROR too many arguments
+}
+
+func imag1() {
+	var f32 float32
+	var f64 float64
+	var c64 complex64
+	var c128 complex128
+	_ = imag() // ERROR not enough arguments
+	_ = imag(1, 2) // ERROR too many arguments
+	_ = imag(10)
+	_ = imag(2.7182818)
+	_ = imag("foo" /* ERROR expected complex */)
+	_ = imag('a')
+	const _5 = imag(1 + 2i)
+	assert(_5 == 2)
+	f32 = _5
+	f64 = _5
+	const _6 = imag(0i)
+	assert(_6 == 0)
+	f32 = imag(c64)
+	f64 = imag(c128)
+	f32 = imag /* ERROR cannot use .* in assignment */ (c128)
+	f64 = imag /* ERROR cannot use .* in assignment */ (c64)
+	imag /* ERROR not used */ (c64)
+	_, _ = f32, f64
+
+	// complex type may not be predeclared
+	type C64 complex64
+	type C128 complex128
+	var x64 C64
+	var x128 C128
+	f32 = imag(x64)
+	f64 = imag(x128)
+
+	var a []complex64
+	_ = imag(a... /* ERROR invalid use of \.\.\. */ )
+
+	// if argument is untyped, result is untyped
+	const _ byte = imag(1.2 + 3i)
+	const _ complex128 = imag(1.2 + 3i)
+
+	// lhs constant shift operands are typed as complex128
+	var s uint
+	_ = imag(1 /* ERROR must be integer */ << s)
+}
+
+func imag2() {
+	f1 := func() (x complex128) { return }
+	f2 := func() (x, y complex128) { return }
+	_ = imag(f0 /* ERROR used as value */ ())
+	_ = imag(f1())
+	_ = imag(f2()) // ERROR too many arguments
+}
+
+func len1() {
+	const c = "foobar"
+	var a [10]bool
+	var p *[20]int
+	var m map[string]complex128
+	_ = len() // ERROR not enough arguments
+	_ = len(1, 2) // ERROR too many arguments
+	_ = len(42 /* ERROR invalid */)
+	const _3 = len(c)
+	assert(_3 == 6)
+	const _4 = len(a)
+	assert(_4 == 10)
+	const _5 = len(p)
+	assert(_5 == 20)
+	_ = len(m)
+	len /* ERROR not used */ (c)
+
+	// esoteric case
+	var t string
+	var hash map[interface{}][]*[10]int
+	const n = len /* ERROR not constant */ (hash[recover()][len(t)])
+	assert(n == 10) // ok because n has unknown value and no error is reported
+	var ch <-chan int
+	const nn = len /* ERROR not constant */ (hash[<-ch][len(t)])
+
+	// issue 4744
+	type T struct{ a [10]int }
+	const _ = len(((*T)(nil)).a)
+
+	var s [][]byte
+	_ = len(s)
+	_ = len(s... /* ERROR invalid use of \.\.\. */ )
+}
+
+func len2() {
+	f1 := func() (x []int) { return }
+	f2 := func() (x, y []int) { return }
+	_ = len(f0 /* ERROR used as value */ ())
+	_ = len(f1())
+	_ = len(f2()) // ERROR too many arguments
+}
+
+// test cases for issue 7387
+func len3() {
+	var f = func() int { return 0 }
+	var x = f()
+	const (
+		_ = len([4]int{})
+		_ = len([4]int{x})
+		_ = len /* ERROR not constant */ ([4]int{f()})
+		_ = len /* ERROR not constant */ ([4]int{len([]int{})})
+		_ = len([4]int{len([4]int{})})
+	)
+	var y float64
+	var z complex128
+	const (
+		_ = len([4]float64{})
+		_ = len([4]float64{y})
+		_ = len([4]float64{real(2i)})
+		_ = len /* ERROR not constant */ ([4]float64{real(z)})
+	)
+	var ch chan [10]int
+	const (
+		_ = len /* ERROR not constant */ (<-ch)
+		_ = len /* ERROR not constant */ ([4]int{(<-ch)[0]})
+	)
+}
+
+func make1() {
+	var n int
+	var m float32
+	var s uint
+
+	_ = make() // ERROR not enough arguments
+	_ = make(1 /* ERROR not a type */)
+	_ = make(int /* ERROR cannot make */)
+
+	// slices
+	_ = make/* ERROR arguments */ ([]int)
+	_ = make/* ERROR arguments */ ([]int, 2, 3, 4)
+	_ = make([]int, int /* ERROR not an expression */)
+	_ = make([]int, 10, float32 /* ERROR not an expression */)
+	_ = make([]int, "foo" /* ERROR cannot convert */)
+	_ = make([]int, 10, 2.3 /* ERROR truncated */)
+	_ = make([]int, 5, 10.0)
+	_ = make([]int, 0i)
+	_ = make([]int, 1.0)
+	_ = make([]int, 1.0<<s)
+	_ = make([]int, 1.1 /* ERROR int */ <<s)
+	_ = make([]int, - /* ERROR must not be negative */ 1, 10)
+	_ = make([]int, 0, - /* ERROR must not be negative */ 1)
+	_ = make([]int, - /* ERROR must not be negative */ 1, - /* ERROR must not be negative */ 1)
+	_ = make([]int, 1 /* ERROR overflows */ <<100, 1 /* ERROR overflows */ <<100)
+	_ = make([]int, 10 /* ERROR length and capacity swapped */ , 9)
+	_ = make([]int, 1 /* ERROR overflows */ <<100, 12345)
+	_ = make([]int, m /* ERROR must be integer */ )
+        _ = &make /* ERROR cannot take address */ ([]int, 0)
+
+	// maps
+	_ = make /* ERROR arguments */ (map[int]string, 10, 20)
+	_ = make(map[int]float32, int /* ERROR not an expression */)
+	_ = make(map[int]float32, "foo" /* ERROR cannot convert */)
+	_ = make(map[int]float32, 10)
+	_ = make(map[int]float32, n)
+	_ = make(map[int]float32, int64(n))
+	_ = make(map[string]bool, 10.0)
+	_ = make(map[string]bool, 10.0<<s)
+        _ = &make /* ERROR cannot take address */ (map[string]bool)
+
+	// channels
+	_ = make /* ERROR arguments */ (chan int, 10, 20)
+	_ = make(chan int, int /* ERROR not an expression */)
+	_ = make(chan<- int, "foo" /* ERROR cannot convert */)
+	_ = make(chan int, - /* ERROR must not be negative */ 10)
+	_ = make(<-chan float64, 10)
+	_ = make(chan chan int, n)
+	_ = make(chan string, int64(n))
+	_ = make(chan bool, 10.0)
+	_ = make(chan bool, 10.0<<s)
+        _ = &make /* ERROR cannot take address */ (chan bool)
+
+	make /* ERROR not used */ ([]int, 10)
+
+	var t []int
+	_ = make([]int, t[0], t[1])
+	_ = make([]int, t... /* ERROR invalid use of \.\.\. */ )
+}
+
+func make2() {
+	f1 /* ERROR not used */ := func() (x []int) { return }
+	_ = make(f0 /* ERROR not a type */ ())
+	_ = make(f1 /* ERROR not a type */ ())
+}
+
+func new1() {
+	_ = new() // ERROR not enough arguments
+	_ = new(1, 2) // ERROR too many arguments
+	_ = new("foo" /* ERROR not a type */)
+	p := new(float64)
+	_ = new(struct{ x, y int })
+	q := new(*float64)
+	_ = *p == **q
+	new /* ERROR not used */ (int)
+        _ = &new /* ERROR cannot take address */ (int)
+
+	_ = new(int... /* ERROR invalid use of \.\.\. */ )
+}
+
+func new2() {
+	f1 /* ERROR not used */ := func() (x []int) { return }
+	_ = new(f0 /* ERROR not a type */ ())
+	_ = new(f1 /* ERROR not a type */ ())
+}
+
+func panic1() {
+	panic() // ERROR not enough arguments
+	panic(1, 2) // ERROR too many arguments
+	panic(0)
+	panic("foo")
+	panic(false)
+	panic(1<<10)
+	panic(1 /* ERROR overflows */ <<1000)
+	_ = panic /* ERROR used as value */ (0)
+
+	var s []byte
+	panic(s)
+	panic(s... /* ERROR invalid use of \.\.\. */ )
+}
+
+func panic2() {
+	f1 := func() (x int) { return }
+	f2 := func() (x, y int) { return }
+	panic(f0 /* ERROR used as value */ ())
+	panic(f1())
+	panic(f2()) // ERROR too many arguments
+}
+
+func print1() {
+	print()
+	print(1)
+	print(1, 2)
+	print("foo")
+	print(2.718281828)
+	print(false)
+	print(1<<10)
+	print(1 /* ERROR overflows */ <<1000)
+	println(nil /* ERROR untyped nil */ )
+
+	var s []int
+	print(s... /* ERROR invalid use of \.\.\. */ )
+	_ = print /* ERROR used as value */ ()
+}
+
+func print2() {
+	f1 := func() (x int) { return }
+	f2 := func() (x, y int) { return }
+	f3 := func() (x int, y float32, z string) { return }
+	print(f0 /* ERROR used as value */ ())
+	print(f1())
+	print(f2())
+	print(f3())
+}
+
+func println1() {
+	println()
+	println(1)
+	println(1, 2)
+	println("foo")
+	println(2.718281828)
+	println(false)
+	println(1<<10)
+	println(1 /* ERROR overflows */ <<1000)
+	println(nil /* ERROR untyped nil */ )
+
+	var s []int
+	println(s... /* ERROR invalid use of \.\.\. */ )
+	_ = println /* ERROR used as value */ ()
+}
+
+func println2() {
+	f1 := func() (x int) { return }
+	f2 := func() (x, y int) { return }
+	f3 := func() (x int, y float32, z string) { return }
+	println(f0 /* ERROR used as value */ ())
+	println(f1())
+	println(f2())
+	println(f3())
+}
+
+func real1() {
+	var f32 float32
+	var f64 float64
+	var c64 complex64
+	var c128 complex128
+	_ = real() // ERROR not enough arguments
+	_ = real(1, 2) // ERROR too many arguments
+	_ = real(10)
+	_ = real(2.7182818)
+	_ = real("foo" /* ERROR expected complex */)
+	const _5 = real(1 + 2i)
+	assert(_5 == 1)
+	f32 = _5
+	f64 = _5
+	const _6 = real(0i)
+	assert(_6 == 0)
+	f32 = real(c64)
+	f64 = real(c128)
+	f32 = real /* ERROR cannot use .* in assignment */ (c128)
+	f64 = real /* ERROR cannot use .* in assignment */ (c64)
+	real /* ERROR not used */ (c64)
+
+	// complex type may not be predeclared
+	type C64 complex64
+	type C128 complex128
+	var x64 C64
+	var x128 C128
+	f32 = imag(x64)
+	f64 = imag(x128)
+	_, _ = f32, f64
+
+	var a []complex64
+	_ = real(a... /* ERROR invalid use of \.\.\. */ )
+
+	// if argument is untyped, result is untyped
+	const _ byte = real(1 + 2.3i)
+	const _ complex128 = real(1 + 2.3i)
+
+	// lhs constant shift operands are typed as complex128
+	var s uint
+	_ = real(1 /* ERROR must be integer */ << s)
+}
+
+func real2() {
+	f1 := func() (x complex128) { return }
+	f2 := func() (x, y complex128) { return }
+	_ = real(f0 /* ERROR used as value */ ())
+	_ = real(f1())
+	_ = real(f2()) // ERROR too many arguments
+}
+
+func recover1() {
+	_ = recover()
+	_ = recover(10) // ERROR too many arguments
+	recover()
+
+	var s []int
+	recover(s... /* ERROR invalid use of \.\.\. */ )
+}
+
+func recover2() {
+	f1 := func() (x int) { return }
+	f2 := func() (x, y int) { return }
+	_ = recover(f0 /* ERROR used as value */ ())
+	_ = recover(f1()) // ERROR too many arguments
+	_ = recover(f2()) // ERROR too many arguments
+}
+
+// assuming types.DefaultPtrSize == 8
+type S0 struct{      // offset
+	a bool       //  0
+	b rune       //  4
+	c *int       //  8
+	d bool       // 16
+	e complex128 // 24
+}                    // 40
+
+type S1 struct{   // offset
+	x float32 //  0
+	y string  //  8
+	z *S1     // 24
+	S0        // 32
+}                 // 72
+
+type S2 struct{ // offset
+	*S1     //  0
+}               //  8
+
+type S3 struct { // offset
+	a int64  //  0
+	b int32  //  8
+}                // 12
+
+type S4 struct { // offset
+	S3       //  0
+	int32    // 12
+}                // 16
+
+type S5 struct {   // offset
+	a [3]int32 //  0
+	b int32    // 12
+}                  // 16
+
+func (S2) m() {}
+
+func Alignof1() {
+	var x int
+	_ = unsafe.Alignof() // ERROR not enough arguments
+	_ = unsafe.Alignof(1, 2) // ERROR too many arguments
+	_ = unsafe.Alignof(int /* ERROR not an expression */)
+	_ = unsafe.Alignof(42)
+	_ = unsafe.Alignof(new(struct{}))
+	_ = unsafe.Alignof(1<<10)
+	_ = unsafe.Alignof(1 /* ERROR overflows */ <<1000)
+	_ = unsafe.Alignof(nil /* ERROR "untyped nil */ )
+	unsafe /* ERROR not used */ .Alignof(x)
+
+	var y S0
+	assert(unsafe.Alignof(y.a) == 1)
+	assert(unsafe.Alignof(y.b) == 4)
+	assert(unsafe.Alignof(y.c) == 8)
+	assert(unsafe.Alignof(y.d) == 1)
+	assert(unsafe.Alignof(y.e) == 8)
+
+	var s []byte
+	_ = unsafe.Alignof(s)
+	_ = unsafe.Alignof(s... /* ERROR invalid use of \.\.\. */ )
+}
+
+func Alignof2() {
+	f1 := func() (x int32) { return }
+	f2 := func() (x, y int32) { return }
+	_ = unsafe.Alignof(f0 /* ERROR used as value */ ())
+	assert(unsafe.Alignof(f1()) == 4)
+	_ = unsafe.Alignof(f2()) // ERROR too many arguments
+}
+
+func Offsetof1() {
+	var x struct{ f int }
+	_ = unsafe.Offsetof() // ERROR not enough arguments
+	_ = unsafe.Offsetof(1, 2) // ERROR too many arguments
+	_ = unsafe.Offsetof(int /* ERROR not a selector expression */ )
+	_ = unsafe.Offsetof(x /* ERROR not a selector expression */ )
+	_ = unsafe.Offsetof(nil /* ERROR not a selector expression */ )
+	_ = unsafe.Offsetof(x.f)
+	_ = unsafe.Offsetof((x.f))
+	_ = unsafe.Offsetof((((((((x))).f)))))
+	unsafe /* ERROR not used */ .Offsetof(x.f)
+
+	var y0 S0
+	assert(unsafe.Offsetof(y0.a) == 0)
+	assert(unsafe.Offsetof(y0.b) == 4)
+	assert(unsafe.Offsetof(y0.c) == 8)
+	assert(unsafe.Offsetof(y0.d) == 16)
+	assert(unsafe.Offsetof(y0.e) == 24)
+
+	var y1 S1
+	assert(unsafe.Offsetof(y1.x) == 0)
+	assert(unsafe.Offsetof(y1.y) == 8)
+	assert(unsafe.Offsetof(y1.z) == 24)
+	assert(unsafe.Offsetof(y1.S0) == 32)
+
+	assert(unsafe.Offsetof(y1.S0.a) == 0) // relative to S0
+	assert(unsafe.Offsetof(y1.a) == 32)   // relative to S1
+	assert(unsafe.Offsetof(y1.b) == 36)   // relative to S1
+	assert(unsafe.Offsetof(y1.c) == 40)   // relative to S1
+	assert(unsafe.Offsetof(y1.d) == 48)   // relative to S1
+	assert(unsafe.Offsetof(y1.e) == 56)   // relative to S1
+
+	var y1p *S1
+	assert(unsafe.Offsetof(y1p.S0) == 32)
+
+	type P *S1
+	var p P = y1p
+	assert(unsafe.Offsetof(p.S0) == 32)
+
+	var y2 S2
+	assert(unsafe.Offsetof(y2.S1) == 0)
+	_ = unsafe.Offsetof(y2 /* ERROR embedded via a pointer */ .x)
+	_ = unsafe.Offsetof(y2 /* ERROR method value */ .m)
+
+	var s []byte
+	_ = unsafe.Offsetof(s... /* ERROR invalid use of \.\.\. */ )
+}
+
+func Offsetof2() {
+	f1 := func() (x int32) { return }
+	f2 := func() (x, y int32) { return }
+	_ = unsafe.Offsetof(f0 /* ERROR not a selector expression */ ())
+	_ = unsafe.Offsetof(f1 /* ERROR not a selector expression */ ())
+	_ = unsafe.Offsetof(f2 /* ERROR not a selector expression */ ())
+}
+
+func Sizeof1() {
+	var x int
+	_ = unsafe.Sizeof() // ERROR not enough arguments
+	_ = unsafe.Sizeof(1, 2) // ERROR too many arguments
+	_ = unsafe.Sizeof(int /* ERROR not an expression */)
+	_ = unsafe.Sizeof(42)
+	_ = unsafe.Sizeof(new(complex128))
+	_ = unsafe.Sizeof(1<<10)
+	_ = unsafe.Sizeof(1 /* ERROR overflows */ <<1000)
+	_ = unsafe.Sizeof(nil /* ERROR untyped nil */ )
+	unsafe /* ERROR not used */ .Sizeof(x)
+
+	// basic types have size guarantees
+	assert(unsafe.Sizeof(byte(0)) == 1)
+	assert(unsafe.Sizeof(uint8(0)) == 1)
+	assert(unsafe.Sizeof(int8(0)) == 1)
+	assert(unsafe.Sizeof(uint16(0)) == 2)
+	assert(unsafe.Sizeof(int16(0)) == 2)
+	assert(unsafe.Sizeof(uint32(0)) == 4)
+	assert(unsafe.Sizeof(int32(0)) == 4)
+	assert(unsafe.Sizeof(float32(0)) == 4)
+	assert(unsafe.Sizeof(uint64(0)) == 8)
+	assert(unsafe.Sizeof(int64(0)) == 8)
+	assert(unsafe.Sizeof(float64(0)) == 8)
+	assert(unsafe.Sizeof(complex64(0)) == 8)
+	assert(unsafe.Sizeof(complex128(0)) == 16)
+
+	var y0 S0
+	assert(unsafe.Sizeof(y0.a) == 1)
+	assert(unsafe.Sizeof(y0.b) == 4)
+	assert(unsafe.Sizeof(y0.c) == 8)
+	assert(unsafe.Sizeof(y0.d) == 1)
+	assert(unsafe.Sizeof(y0.e) == 16)
+	assert(unsafe.Sizeof(y0) == 40)
+
+	var y1 S1
+	assert(unsafe.Sizeof(y1) == 72)
+
+	var y2 S2
+	assert(unsafe.Sizeof(y2) == 8)
+
+	var y3 S3
+	assert(unsafe.Sizeof(y3) == 12)
+
+	var y4 S4
+	assert(unsafe.Sizeof(y4) == 16)
+
+	var y5 S5
+	assert(unsafe.Sizeof(y5) == 16)
+
+	var a3 [10]S3
+	assert(unsafe.Sizeof(a3) == 156)
+
+	// test case for issue 5670
+	type T struct {
+		a int32
+		_ int32
+		c int32
+	}
+	assert(unsafe.Sizeof(T{}) == 12)
+
+	var s []byte
+	_ = unsafe.Sizeof(s)
+	_ = unsafe.Sizeof(s... /* ERROR invalid use of \.\.\. */ )
+}
+
+func Sizeof2() {
+	f1 := func() (x int64) { return }
+	f2 := func() (x, y int64) { return }
+	_ = unsafe.Sizeof(f0 /* ERROR used as value */ ())
+	assert(unsafe.Sizeof(f1()) == 8)
+	_ = unsafe.Sizeof(f2()) // ERROR too many arguments
+}
+
+// self-testing only
+func assert1() {
+	var x int
+	assert() /* ERROR not enough arguments */
+	assert(1, 2) /* ERROR too many arguments */
+	assert("foo" /* ERROR boolean constant */ )
+	assert(x /* ERROR boolean constant */)
+	assert(true)
+	assert /* ERROR failed */ (false)
+	_ = assert(true)
+
+	var s []byte
+	assert(s... /* ERROR invalid use of \.\.\. */ )
+}
+
+func assert2() {
+	f1 := func() (x bool) { return }
+	f2 := func() (x bool) { return }
+	assert(f0 /* ERROR used as value */ ())
+	assert(f1 /* ERROR boolean constant */ ())
+	assert(f2 /* ERROR boolean constant */ ())
+}
+
+// self-testing only
+func trace1() {
+	// Uncomment the code below to test trace - will produce console output
+	// _ = trace /* ERROR no value */ ()
+	// _ = trace(1)
+	// _ = trace(true, 1.2, '\'', "foo", 42i, "foo" <= "bar")
+
+	var s []byte
+	trace(s... /* ERROR invalid use of \.\.\. */ )
+}
+
+func trace2() {
+	f1 := func() (x int) { return }
+	f2 := func() (x int, y string) { return }
+	f3 := func() (x int, y string, z []int) { return }
+	_ = f1
+	_ = f2
+	_ = f3
+	// Uncomment the code below to test trace - will produce console output
+	// trace(f0())
+	// trace(f1())
+	// trace(f2())
+	// trace(f3())
+	// trace(f0(), 1)
+	// trace(f1(), 1, 2)
+	// trace(f2(), 1, 2, 3)
+	// trace(f3(), 1, 2, 3, 4)
+}
diff --git a/src/cmd/compile/internal/types2/testdata/const0.src b/src/cmd/compile/internal/types2/testdata/const0.src
new file mode 100644
index 0000000000..adbbf2863b
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/const0.src
@@ -0,0 +1,350 @@
+// Copyright 2012 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.
+
+// constant declarations
+
+package const0
+
+import "unsafe"
+
+// constants declarations must be initialized by constants
+var x = 0
+const c0 = x /* ERROR "not constant" */
+
+// typed constants must have constant types
+const _ interface /* ERROR invalid constant type */ {} = 0
+
+func _ () {
+	const _ interface /* ERROR invalid constant type */ {} = 0
+	for i := 0; i < 10; i++ {} // don't crash with non-nil iota here
+}
+
+// untyped constants
+const (
+	// boolean values
+	ub0 = false
+	ub1 = true
+	ub2 = 2 < 1
+	ub3 = ui1 == uf1
+	ub4 = true /* ERROR "cannot convert" */ == 0
+
+	// integer values
+	ui0 = 0
+	ui1 = 1
+	ui2 = 42
+	ui3 = 3141592653589793238462643383279502884197169399375105820974944592307816406286
+	ui4 = -10
+
+	ui5 = ui0 + ui1
+	ui6 = ui1 - ui1
+	ui7 = ui2 * ui1
+	ui8 = ui3 / ui3
+	ui9 = ui3 % ui3
+
+	ui10 = 1 / 0 /* ERROR "division by zero" */
+	ui11 = ui1 / 0 /* ERROR "division by zero" */
+	ui12 = ui3 / ui0 /* ERROR "division by zero" */
+	ui13 = 1 % 0 /* ERROR "division by zero" */
+	ui14 = ui1 % 0 /* ERROR "division by zero" */
+	ui15 = ui3 % ui0 /* ERROR "division by zero" */
+
+	ui16 = ui2 & ui3
+	ui17 = ui2 | ui3
+	ui18 = ui2 ^ ui3
+	ui19 = 1 /* ERROR "invalid operation" */ % 1.0
+
+	// floating point values
+	uf0 = 0.
+	uf1 = 1.
+	uf2 = 4.2e1
+	uf3 = 3.141592653589793238462643383279502884197169399375105820974944592307816406286
+	uf4 = 1e-1
+
+	uf5 = uf0 + uf1
+	uf6 = uf1 - uf1
+	uf7 = uf2 * uf1
+	uf8 = uf3 / uf3
+	uf9 = uf3 /* ERROR "not defined" */ % uf3
+
+	uf10 = 1 / 0 /* ERROR "division by zero" */
+	uf11 = uf1 / 0 /* ERROR "division by zero" */
+	uf12 = uf3 / uf0 /* ERROR "division by zero" */
+
+	uf16 = uf2 /* ERROR "not defined" */ & uf3
+	uf17 = uf2 /* ERROR "not defined" */ | uf3
+	uf18 = uf2 /* ERROR "not defined" */ ^ uf3
+
+	// complex values
+	uc0 = 0.i
+	uc1 = 1.i
+	uc2 = 4.2e1i
+	uc3 = 3.141592653589793238462643383279502884197169399375105820974944592307816406286i
+	uc4 = 1e-1i
+
+	uc5 = uc0 + uc1
+	uc6 = uc1 - uc1
+	uc7 = uc2 * uc1
+	uc8 = uc3 / uc3
+	uc9 = uc3 /* ERROR "not defined" */ % uc3
+
+	uc10 = 1 / 0 /* ERROR "division by zero" */
+	uc11 = uc1 / 0 /* ERROR "division by zero" */
+	uc12 = uc3 / uc0 /* ERROR "division by zero" */
+
+	uc16 = uc2 /* ERROR "not defined" */ & uc3
+	uc17 = uc2 /* ERROR "not defined" */ | uc3
+	uc18 = uc2 /* ERROR "not defined" */ ^ uc3
+)
+
+type (
+	mybool bool
+	myint int
+	myfloat float64
+	mycomplex complex128
+)
+
+// typed constants
+const (
+	// boolean values
+	tb0 bool = false
+	tb1 bool = true
+	tb2 mybool = 2 < 1
+	tb3 mybool = ti1 /* ERROR "mismatched types" */ == tf1
+
+	// integer values
+	ti0 int8 = ui0
+	ti1 int32 = ui1
+	ti2 int64 = ui2
+	ti3 myint = ui3 /* ERROR "overflows" */
+	ti4 myint = ui4
+
+	ti5 = ti0 /* ERROR "mismatched types" */ + ti1
+	ti6 = ti1 - ti1
+	ti7 = ti2 /* ERROR "mismatched types" */ * ti1
+	ti8 = ti3 / ti3
+	ti9 = ti3 % ti3
+
+	ti10 = 1 / 0 /* ERROR "division by zero" */
+	ti11 = ti1 / 0 /* ERROR "division by zero" */
+	ti12 = ti3 /* ERROR "mismatched types" */ / ti0
+	ti13 = 1 % 0 /* ERROR "division by zero" */
+	ti14 = ti1 % 0 /* ERROR "division by zero" */
+	ti15 = ti3 /* ERROR "mismatched types" */ % ti0
+
+	ti16 = ti2 /* ERROR "mismatched types" */ & ti3
+	ti17 = ti2 /* ERROR "mismatched types" */ | ti4
+	ti18 = ti2 ^ ti5 // no mismatched types error because the type of ti5 is unknown
+
+	// floating point values
+	tf0 float32 = 0.
+	tf1 float32 = 1.
+	tf2 float64 = 4.2e1
+	tf3 myfloat = 3.141592653589793238462643383279502884197169399375105820974944592307816406286
+	tf4 myfloat = 1e-1
+
+	tf5 = tf0 + tf1
+	tf6 = tf1 - tf1
+	tf7 = tf2 /* ERROR "mismatched types" */ * tf1
+	tf8 = tf3 / tf3
+	tf9 = tf3 /* ERROR "not defined" */ % tf3
+
+	tf10 = 1 / 0 /* ERROR "division by zero" */
+	tf11 = tf1 / 0 /* ERROR "division by zero" */
+	tf12 = tf3 /* ERROR "mismatched types" */ / tf0
+
+	tf16 = tf2 /* ERROR "mismatched types" */ & tf3
+	tf17 = tf2 /* ERROR "mismatched types" */ | tf3
+	tf18 = tf2 /* ERROR "mismatched types" */ ^ tf3
+
+	// complex values
+	tc0 = 0.i
+	tc1 = 1.i
+	tc2 = 4.2e1i
+	tc3 = 3.141592653589793238462643383279502884197169399375105820974944592307816406286i
+	tc4 = 1e-1i
+
+	tc5 = tc0 + tc1
+	tc6 = tc1 - tc1
+	tc7 = tc2 * tc1
+	tc8 = tc3 / tc3
+	tc9 = tc3 /* ERROR "not defined" */ % tc3
+
+	tc10 = 1 / 0 /* ERROR "division by zero" */
+	tc11 = tc1 / 0 /* ERROR "division by zero" */
+	tc12 = tc3 / tc0 /* ERROR "division by zero" */
+
+	tc16 = tc2 /* ERROR "not defined" */ & tc3
+	tc17 = tc2 /* ERROR "not defined" */ | tc3
+	tc18 = tc2 /* ERROR "not defined" */ ^ tc3
+)
+
+// initialization cycles
+const (
+	a /* ERROR "initialization cycle" */ = a
+	b /* ERROR "initialization cycle" */ , c /* ERROR "initialization cycle" */, d, e = e, d, c, b // TODO(gri) should only have one cycle error
+	f float64 = d
+)
+
+// multiple initialization
+const (
+	a1, a2, a3 = 7, 3.1415926, "foo"
+	b1, b2, b3 = b3, b1, 42
+	c1, c2, c3  /* ERROR "missing init expr for c3" */ = 1, 2
+	d1, d2, d3 = 1, 2, 3, 4 /* ERROR "extra init expr 4" */
+	_p0 = assert(a1 == 7)
+	_p1 = assert(a2 == 3.1415926)
+	_p2 = assert(a3 == "foo")
+	_p3 = assert(b1 == 42)
+	_p4 = assert(b2 == 42)
+	_p5 = assert(b3 == 42)
+)
+
+func _() {
+	const (
+		a1, a2, a3 = 7, 3.1415926, "foo"
+		b1, b2, b3 = b3, b1, 42
+		c1, c2, c3  /* ERROR "missing init expr for c3" */ = 1, 2
+		d1, d2, d3 = 1, 2, 3, 4 /* ERROR "extra init expr 4" */
+		_p0 = assert(a1 == 7)
+		_p1 = assert(a2 == 3.1415926)
+		_p2 = assert(a3 == "foo")
+		_p3 = assert(b1 == 42)
+		_p4 = assert(b2 == 42)
+		_p5 = assert(b3 == 42)
+	)
+}
+
+// iota
+const (
+	iota0 = iota
+	iota1 = iota
+	iota2 = iota*2
+	_a0 = assert(iota0 == 0)
+	_a1 = assert(iota1 == 1)
+	_a2 = assert(iota2 == 4)
+	iota6 = iota*3
+
+	iota7
+	iota8
+	_a3 = assert(iota7 == 21)
+	_a4 = assert(iota8 == 24)
+)
+
+const (
+	_b0 = iota
+	_b1 = assert(iota + iota2 == 5)
+	_b2 = len([iota]int{}) // iota may appear in a type!
+	_b3 = assert(_b2 == 2)
+	_b4 = len(A{})
+)
+
+type A [iota /* ERROR "cannot use iota" */ ]int
+
+// constant expressions with operands across different
+// constant declarations must use the right iota values
+const (
+	_c0 = iota
+	_c1
+	_c2
+	_x = _c2 + _d1 + _e0 // 3
+)
+
+const (
+	_d0 = iota
+	_d1
+)
+
+const (
+	_e0 = iota
+)
+
+var _ = assert(_x == 3)
+
+// special cases
+const (
+	_n0 = nil /* ERROR "not constant" */
+	_n1 = [ /* ERROR "not constant" */ ]int{}
+)
+
+// iotas must not be usable in expressions outside constant declarations
+type _ [iota /* ERROR "iota outside constant decl" */ ]byte
+var _ = iota /* ERROR "iota outside constant decl" */
+func _() {
+	_ = iota /* ERROR "iota outside constant decl" */
+	const _ = iota
+	_ = iota /* ERROR "iota outside constant decl" */
+}
+
+func _() {
+	iota := 123
+	const x = iota /* ERROR "is not constant" */
+	var y = iota
+	_ = y
+}
+
+// iotas are usable inside closures in constant declarations (#22345)
+const (
+	_ = iota
+	_ = len([iota]byte{})
+	_ = unsafe.Sizeof(iota)
+	_ = unsafe.Sizeof(func() { _ = iota })
+	_ = unsafe.Sizeof(func() { var _ = iota })
+	_ = unsafe.Sizeof(func() { const _ = iota })
+	_ = unsafe.Sizeof(func() { type _ [iota]byte })
+	_ = unsafe.Sizeof(func() { func() int { return iota }() })
+)
+
+// verify inner and outer const declarations have distinct iotas
+const (
+	zero = iota
+	one  = iota
+	_    = unsafe.Sizeof(func() {
+		var x [iota]int // [2]int
+		const (
+			Zero = iota
+			One
+			Two
+			_ = unsafe.Sizeof([iota-1]int{} == x) // assert types are equal
+			_ = unsafe.Sizeof([Two]int{} == x)    // assert types are equal
+		)
+		var z [iota]int                           // [2]int
+		_ = unsafe.Sizeof([2]int{} == z)          // assert types are equal
+	})
+	three = iota // the sequence continues
+)
+var _ [three]int = [3]int{} // assert 'three' has correct value
+
+var (
+	_ = iota /* ERROR "iota outside constant decl" */
+	_ = unsafe.Sizeof(iota  /* ERROR "iota outside constant decl" */ )
+	_ = unsafe.Sizeof(func() { _ = iota /* ERROR "iota outside constant decl" */ })
+	_ = unsafe.Sizeof(func() { var _ = iota /* ERROR "iota outside constant decl" */ })
+	_ = unsafe.Sizeof(func() { type _ [iota /* ERROR "iota outside constant decl" */ ]byte })
+	_ = unsafe.Sizeof(func() { func() int { return iota /* ERROR "iota outside constant decl" */ }() })
+)
+
+// constant arithmetic precision and rounding must lead to expected (integer) results
+var _ = []int64{
+	0.0005 * 1e9,
+	0.001 * 1e9,
+	0.005 * 1e9,
+	0.01 * 1e9,
+	0.05 * 1e9,
+	0.1 * 1e9,
+	0.5 * 1e9,
+	1 * 1e9,
+	5 * 1e9,
+}
+
+const _ = unsafe.Sizeof(func() {
+	const _ = 0
+	_ = iota
+
+	const (
+	   zero = iota
+	   one
+	)
+	assert(one == 1)
+	assert(iota == 0)
+})
diff --git a/src/cmd/compile/internal/types2/testdata/const1.src b/src/cmd/compile/internal/types2/testdata/const1.src
new file mode 100644
index 0000000000..d82770464f
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/const1.src
@@ -0,0 +1,322 @@
+// Copyright 2012 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.
+
+// constant conversions
+
+package const1
+
+const(
+	mi = ^int(0)
+	mu = ^uint(0)
+	mp = ^uintptr(0)
+
+	logSizeofInt     = uint(mi>>8&1 + mi>>16&1 + mi>>32&1)
+	logSizeofUint    = uint(mu>>8&1 + mu>>16&1 + mu>>32&1)
+	logSizeofUintptr = uint(mp>>8&1 + mp>>16&1 + mp>>32&1)
+)
+
+const (
+	minInt8 = -1<<(8<<iota - 1)
+	minInt16
+	minInt32
+	minInt64
+	minInt = -1<<(8<<logSizeofInt - 1)
+)
+
+const (
+	maxInt8 = 1<<(8<<iota - 1) - 1
+	maxInt16
+	maxInt32
+	maxInt64
+	maxInt = 1<<(8<<logSizeofInt - 1) - 1
+)
+
+const (
+	maxUint8 = 1<<(8<<iota) - 1
+	maxUint16
+	maxUint32
+	maxUint64
+	maxUint    = 1<<(8<<logSizeofUint) - 1
+	maxUintptr = 1<<(8<<logSizeofUintptr) - 1
+)
+
+const (
+	smallestFloat32 = 1.0 / (1<<(127 - 1 + 23))
+	smallestFloat64 = 1.0 / (1<<(1023 - 1 + 52))
+)
+
+const (
+	_ = assert(smallestFloat32 > 0)
+	_ = assert(smallestFloat64 > 0)
+)
+
+const (
+	maxFloat32 = 1<<127 * (1<<24 - 1) / (1.0<<23)
+	maxFloat64 = 1<<1023 * (1<<53 - 1) / (1.0<<52)
+)
+
+const (
+	_ int8 = minInt8 /* ERROR "overflows" */ - 1
+	_ int8 = minInt8
+	_ int8 = maxInt8
+	_ int8 = maxInt8 /* ERROR "overflows" */ + 1
+	_ int8 = smallestFloat64 /* ERROR "truncated" */
+
+	_ = int8(minInt8 /* ERROR "cannot convert" */ - 1)
+	_ = int8(minInt8)
+	_ = int8(maxInt8)
+	_ = int8(maxInt8 /* ERROR "cannot convert" */ + 1)
+	_ = int8(smallestFloat64 /* ERROR "cannot convert" */)
+)
+
+const (
+	_ int16 = minInt16 /* ERROR "overflows" */ - 1
+	_ int16 = minInt16
+	_ int16 = maxInt16
+	_ int16 = maxInt16 /* ERROR "overflows" */ + 1
+	_ int16 = smallestFloat64 /* ERROR "truncated" */
+
+	_ = int16(minInt16 /* ERROR "cannot convert" */ - 1)
+	_ = int16(minInt16)
+	_ = int16(maxInt16)
+	_ = int16(maxInt16 /* ERROR "cannot convert" */ + 1)
+	_ = int16(smallestFloat64 /* ERROR "cannot convert" */)
+)
+
+const (
+	_ int32 = minInt32 /* ERROR "overflows" */ - 1
+	_ int32 = minInt32
+	_ int32 = maxInt32
+	_ int32 = maxInt32 /* ERROR "overflows" */ + 1
+	_ int32 = smallestFloat64 /* ERROR "truncated" */
+
+	_ = int32(minInt32 /* ERROR "cannot convert" */ - 1)
+	_ = int32(minInt32)
+	_ = int32(maxInt32)
+	_ = int32(maxInt32 /* ERROR "cannot convert" */ + 1)
+	_ = int32(smallestFloat64 /* ERROR "cannot convert" */)
+)
+
+const (
+	_ int64 = minInt64 /* ERROR "overflows" */ - 1
+	_ int64 = minInt64
+	_ int64 = maxInt64
+	_ int64 = maxInt64 /* ERROR "overflows" */ + 1
+	_ int64 = smallestFloat64 /* ERROR "truncated" */
+
+	_ = int64(minInt64 /* ERROR "cannot convert" */ - 1)
+	_ = int64(minInt64)
+	_ = int64(maxInt64)
+	_ = int64(maxInt64 /* ERROR "cannot convert" */ + 1)
+	_ = int64(smallestFloat64 /* ERROR "cannot convert" */)
+)
+
+const (
+	_ int = minInt /* ERROR "overflows" */ - 1
+	_ int = minInt
+	_ int = maxInt
+	_ int = maxInt /* ERROR "overflows" */ + 1
+	_ int = smallestFloat64 /* ERROR "truncated" */
+
+	_ = int(minInt /* ERROR "cannot convert" */ - 1)
+	_ = int(minInt)
+	_ = int(maxInt)
+	_ = int(maxInt /* ERROR "cannot convert" */ + 1)
+	_ = int(smallestFloat64 /* ERROR "cannot convert" */)
+)
+
+const (
+	_ uint8 = 0 /* ERROR "overflows" */ - 1
+	_ uint8 = 0
+	_ uint8 = maxUint8
+	_ uint8 = maxUint8 /* ERROR "overflows" */ + 1
+	_ uint8 = smallestFloat64 /* ERROR "truncated" */
+
+	_ = uint8(0 /* ERROR "cannot convert" */ - 1)
+	_ = uint8(0)
+	_ = uint8(maxUint8)
+	_ = uint8(maxUint8 /* ERROR "cannot convert" */ + 1)
+	_ = uint8(smallestFloat64 /* ERROR "cannot convert" */)
+)
+
+const (
+	_ uint16 = 0 /* ERROR "overflows" */ - 1
+	_ uint16 = 0
+	_ uint16 = maxUint16
+	_ uint16 = maxUint16 /* ERROR "overflows" */ + 1
+	_ uint16 = smallestFloat64 /* ERROR "truncated" */
+
+	_ = uint16(0 /* ERROR "cannot convert" */ - 1)
+	_ = uint16(0)
+	_ = uint16(maxUint16)
+	_ = uint16(maxUint16 /* ERROR "cannot convert" */ + 1)
+	_ = uint16(smallestFloat64 /* ERROR "cannot convert" */)
+)
+
+const (
+	_ uint32 = 0 /* ERROR "overflows" */ - 1
+	_ uint32 = 0
+	_ uint32 = maxUint32
+	_ uint32 = maxUint32 /* ERROR "overflows" */ + 1
+	_ uint32 = smallestFloat64 /* ERROR "truncated" */
+
+	_ = uint32(0 /* ERROR "cannot convert" */ - 1)
+	_ = uint32(0)
+	_ = uint32(maxUint32)
+	_ = uint32(maxUint32 /* ERROR "cannot convert" */ + 1)
+	_ = uint32(smallestFloat64 /* ERROR "cannot convert" */)
+)
+
+const (
+	_ uint64 = 0 /* ERROR "overflows" */ - 1
+	_ uint64 = 0
+	_ uint64 = maxUint64
+	_ uint64 = maxUint64 /* ERROR "overflows" */ + 1
+	_ uint64 = smallestFloat64 /* ERROR "truncated" */
+
+	_ = uint64(0 /* ERROR "cannot convert" */ - 1)
+	_ = uint64(0)
+	_ = uint64(maxUint64)
+	_ = uint64(maxUint64 /* ERROR "cannot convert" */ + 1)
+	_ = uint64(smallestFloat64 /* ERROR "cannot convert" */)
+)
+
+const (
+	_ uint = 0 /* ERROR "overflows" */ - 1
+	_ uint = 0
+	_ uint = maxUint
+	_ uint = maxUint /* ERROR "overflows" */ + 1
+	_ uint = smallestFloat64 /* ERROR "truncated" */
+
+	_ = uint(0 /* ERROR "cannot convert" */ - 1)
+	_ = uint(0)
+	_ = uint(maxUint)
+	_ = uint(maxUint /* ERROR "cannot convert" */ + 1)
+	_ = uint(smallestFloat64 /* ERROR "cannot convert" */)
+)
+
+const (
+	_ uintptr = 0 /* ERROR "overflows" */ - 1
+	_ uintptr = 0
+	_ uintptr = maxUintptr
+	_ uintptr = maxUintptr /* ERROR "overflows" */ + 1
+	_ uintptr = smallestFloat64 /* ERROR "truncated" */
+
+	_ = uintptr(0 /* ERROR "cannot convert" */ - 1)
+	_ = uintptr(0)
+	_ = uintptr(maxUintptr)
+	_ = uintptr(maxUintptr /* ERROR "cannot convert" */ + 1)
+	_ = uintptr(smallestFloat64 /* ERROR "cannot convert" */)
+)
+
+const (
+	_ float32 = minInt64
+	_ float64 = minInt64
+	_ complex64 = minInt64
+	_ complex128 = minInt64
+
+	_ = float32(minInt64)
+	_ = float64(minInt64)
+	_ = complex64(minInt64)
+	_ = complex128(minInt64)
+)
+
+const (
+	_ float32 = maxUint64
+	_ float64 = maxUint64
+	_ complex64 = maxUint64
+	_ complex128 = maxUint64
+
+	_ = float32(maxUint64)
+	_ = float64(maxUint64)
+	_ = complex64(maxUint64)
+	_ = complex128(maxUint64)
+)
+
+// TODO(gri) find smaller deltas below
+
+const delta32 = maxFloat32/(1 << 23)
+
+const (
+	_ float32 = - /* ERROR "overflow" */ (maxFloat32 + delta32)
+	_ float32 = -maxFloat32
+	_ float32 = maxFloat32
+	_ float32 = maxFloat32 /* ERROR "overflow" */ + delta32
+
+	_ = float32(- /* ERROR "cannot convert" */ (maxFloat32 + delta32))
+	_ = float32(-maxFloat32)
+	_ = float32(maxFloat32)
+	_ = float32(maxFloat32 /* ERROR "cannot convert" */ + delta32)
+
+	_ = assert(float32(smallestFloat32) == smallestFloat32)
+	_ = assert(float32(smallestFloat32/2) == 0)
+	_ = assert(float32(smallestFloat64) == 0)
+	_ = assert(float32(smallestFloat64/2) == 0)
+)
+
+const delta64 = maxFloat64/(1 << 52)
+
+const (
+	_ float64 = - /* ERROR "overflow" */ (maxFloat64 + delta64)
+	_ float64 = -maxFloat64
+	_ float64 = maxFloat64
+	_ float64 = maxFloat64 /* ERROR "overflow" */ + delta64
+
+	_ = float64(- /* ERROR "cannot convert" */ (maxFloat64 + delta64))
+	_ = float64(-maxFloat64)
+	_ = float64(maxFloat64)
+	_ = float64(maxFloat64 /* ERROR "cannot convert" */ + delta64)
+
+	_ = assert(float64(smallestFloat32) == smallestFloat32)
+	_ = assert(float64(smallestFloat32/2) == smallestFloat32/2)
+	_ = assert(float64(smallestFloat64) == smallestFloat64)
+	_ = assert(float64(smallestFloat64/2) == 0)
+)
+
+const (
+	_ complex64 = - /* ERROR "overflow" */ (maxFloat32 + delta32)
+	_ complex64 = -maxFloat32
+	_ complex64 = maxFloat32
+	_ complex64 = maxFloat32 /* ERROR "overflow" */ + delta32
+
+	_ = complex64(- /* ERROR "cannot convert" */ (maxFloat32 + delta32))
+	_ = complex64(-maxFloat32)
+	_ = complex64(maxFloat32)
+	_ = complex64(maxFloat32 /* ERROR "cannot convert" */ + delta32)
+)
+
+const (
+	_ complex128 = - /* ERROR "overflow" */ (maxFloat64 + delta64)
+	_ complex128 = -maxFloat64
+	_ complex128 = maxFloat64
+	_ complex128 = maxFloat64 /* ERROR "overflow" */ + delta64
+
+	_ = complex128(- /* ERROR "cannot convert" */ (maxFloat64 + delta64))
+	_ = complex128(-maxFloat64)
+	_ = complex128(maxFloat64)
+	_ = complex128(maxFloat64 /* ERROR "cannot convert" */ + delta64)
+)
+
+// Initialization of typed constant and conversion are the same:
+const (
+	f32 = 1 + smallestFloat32
+	x32 float32 = f32
+	y32 = float32(f32)
+	_ = assert(x32 - y32 == 0)
+)
+
+const (
+	f64 = 1 + smallestFloat64
+	x64 float64 = f64
+	y64 = float64(f64)
+	_ = assert(x64 - y64 == 0)
+)
+
+const (
+	_ = int8(-1) << 7
+	_ = int8 /* ERROR "overflows" */ (-1) << 8
+
+	_ = uint32(1) << 31
+	_ = uint32 /* ERROR "overflows" */ (1) << 32
+)
diff --git a/src/cmd/compile/internal/types2/testdata/constdecl.src b/src/cmd/compile/internal/types2/testdata/constdecl.src
new file mode 100644
index 0000000000..c2f40ed6e6
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/constdecl.src
@@ -0,0 +1,110 @@
+// Copyright 2013 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 constdecl
+
+import "math"
+import "unsafe"
+
+var v int
+
+// Const decls must be initialized by constants.
+const _ = v /* ERROR "not constant" */
+const _ = math /* ERROR "not constant" */ .Sin(0)
+const _ = int /* ERROR "not an expression" */
+
+func _() {
+	const _ = v /* ERROR "not constant" */
+	const _ = math /* ERROR "not constant" */ .Sin(0)
+	const _ = int /* ERROR "not an expression" */
+}
+
+// Identifier and expression arity must match.
+// The first error message is produced by the parser.
+// In a real-world scenario, the type-checker would not be run
+// in this case and the 2nd error message would not appear.
+const _ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */
+const _ = 1, 2 /* ERROR "extra init expr 2" */
+
+const _ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */ int
+const _ int = 1, 2 /* ERROR "extra init expr 2" */
+
+const (
+	_ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */
+	_ = 1, 2 /* ERROR "extra init expr 2" */
+
+	_ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */ int
+	_ int = 1, 2 /* ERROR "extra init expr 2" */
+)
+
+const (
+	_ = 1
+	_
+	_, _ /* ERROR "missing init expr for _" */
+	_
+)
+
+const (
+	_, _ = 1, 2
+	_, _
+	_ /* ERROR "extra init expr at" */
+	_, _
+	_, _, _ /* ERROR "missing init expr for _" */
+	_, _
+)
+
+func _() {
+	const _ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */
+	const _ = 1, 2 /* ERROR "extra init expr 2" */
+
+	const _ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */ int
+	const _ int = 1, 2 /* ERROR "extra init expr 2" */
+
+	const (
+		_ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */
+		_ = 1, 2 /* ERROR "extra init expr 2" */
+
+		_ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */ int
+		_ int = 1, 2 /* ERROR "extra init expr 2" */
+	)
+
+	const (
+		_ = 1
+		_
+		_, _ /* ERROR "missing init expr for _" */
+		_
+	)
+
+	const (
+		_, _ = 1, 2
+		_, _
+		_ /* ERROR "extra init expr at" */
+		_, _
+		_, _, _ /* ERROR "missing init expr for _" */
+		_, _
+	)
+}
+
+// Test case for constant with invalid initialization.
+// Caused panic because the constant value was not set up (gri - 7/8/2014).
+func _() {
+	const (
+	    x string = missing /* ERROR "undeclared name" */
+	    y = x + ""
+	)
+}
+
+// Test case for constants depending on function literals (see also #22992).
+const A /* ERROR initialization cycle */ = unsafe.Sizeof(func() { _ = A })
+
+func _() {
+	// The function literal below must not see a.
+	const a = unsafe.Sizeof(func() { _ = a /* ERROR "undeclared name" */ })
+	const b = unsafe.Sizeof(func() { _ = a })
+
+	// The function literal below must not see x, y, or z.
+	const x, y, z = 0, 1, unsafe.Sizeof(func() { _ = x /* ERROR "undeclared name" */ + y /* ERROR "undeclared name" */ + z /* ERROR "undeclared name" */ })
+}
+
+// TODO(gri) move extra tests from testdata/const0.src into here
diff --git a/src/cmd/compile/internal/types2/testdata/conversions.src b/src/cmd/compile/internal/types2/testdata/conversions.src
new file mode 100644
index 0000000000..e1336c0456
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/conversions.src
@@ -0,0 +1,93 @@
+// Copyright 2012 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.
+
+// conversions
+
+package conversions
+
+import "unsafe"
+
+// argument count
+var (
+	_ = int() /* ERROR "missing argument" */
+	_ = int(1, 2 /* ERROR "too many arguments" */ )
+)
+
+// numeric constant conversions are in const1.src.
+
+func string_conversions() {
+	const A = string(65)
+	assert(A == "A")
+	const E = string(-1)
+	assert(E == "\uFFFD")
+	assert(E == string(1234567890))
+
+	type myint int
+	assert(A == string(myint(65)))
+
+	type mystring string
+	const _ mystring = mystring("foo")
+
+	const _ = string(true /* ERROR "cannot convert" */ )
+	const _ = string(1.2 /* ERROR "cannot convert" */ )
+	const _ = string(nil /* ERROR "cannot convert" */ )
+
+	// issues 11357, 11353: argument must be of integer type
+	_ = string(0.0 /* ERROR "cannot convert" */ )
+	_ = string(0i /* ERROR "cannot convert" */ )
+	_ = string(1 /* ERROR "cannot convert" */ + 2i)
+}
+
+func interface_conversions() {
+	type E interface{}
+
+	type I1 interface{
+		m1()
+	}
+
+	type I2 interface{
+		m1()
+		m2(x int)
+	}
+
+	type I3 interface{
+		m1()
+		m2() int
+	}
+
+	var e E
+	var i1 I1
+	var i2 I2
+	var i3 I3
+
+	_ = E(0)
+	_ = E(nil)
+	_ = E(e)
+	_ = E(i1)
+	_ = E(i2)
+
+	_ = I1(0 /* ERROR "cannot convert" */ )
+	_ = I1(nil)
+	_ = I1(i1)
+	_ = I1(e /* ERROR "cannot convert" */ )
+	_ = I1(i2)
+
+	_ = I2(nil)
+	_ = I2(i1 /* ERROR "cannot convert" */ )
+	_ = I2(i2)
+	_ = I2(i3 /* ERROR "cannot convert" */ )
+
+	_ = I3(nil)
+	_ = I3(i1 /* ERROR "cannot convert" */ )
+	_ = I3(i2 /* ERROR "cannot convert" */ )
+	_ = I3(i3)
+
+	// TODO(gri) add more tests, improve error message
+}
+
+func issue6326() {
+	type T unsafe.Pointer
+	var x T
+	_ = uintptr(x) // see issue 6326
+}
diff --git a/src/cmd/compile/internal/types2/testdata/conversions2.src b/src/cmd/compile/internal/types2/testdata/conversions2.src
new file mode 100644
index 0000000000..93a5f182fb
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/conversions2.src
@@ -0,0 +1,313 @@
+// Copyright 2016 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.
+
+// Test various valid and invalid struct assignments and conversions.
+// Does not compile.
+
+package conversions2
+
+type I interface {
+	m()
+}
+
+// conversions between structs
+
+func _() {
+	type S struct{}
+	type T struct{}
+	var s S
+	var t T
+	var u struct{}
+	s = s
+	s = t // ERROR "cannot use .* in assignment"
+	s = u
+	s = S(s)
+	s = S(t)
+	s = S(u)
+	t = u
+	t = T(u)
+}
+
+func _() {
+	type S struct{ x int }
+	type T struct {
+		x int "foo"
+	}
+	var s S
+	var t T
+	var u struct {
+		x int "bar"
+	}
+	s = s
+	s = t // ERROR "cannot use .* in assignment"
+	s = u // ERROR "cannot use .* in assignment"
+	s = S(s)
+	s = S(t)
+	s = S(u)
+	t = u // ERROR "cannot use .* in assignment"
+	t = T(u)
+}
+
+func _() {
+	type E struct{ x int }
+	type S struct{ x E }
+	type T struct {
+		x E "foo"
+	}
+	var s S
+	var t T
+	var u struct {
+		x E "bar"
+	}
+	s = s
+	s = t // ERROR "cannot use .* in assignment"
+	s = u // ERROR "cannot use .* in assignment"
+	s = S(s)
+	s = S(t)
+	s = S(u)
+	t = u // ERROR "cannot use .* in assignment"
+	t = T(u)
+}
+
+func _() {
+	type S struct {
+		x struct {
+			x int "foo"
+		}
+	}
+	type T struct {
+		x struct {
+			x int "bar"
+		} "foo"
+	}
+	var s S
+	var t T
+	var u struct {
+		x struct {
+			x int "bar"
+		} "bar"
+	}
+	s = s
+	s = t // ERROR "cannot use .* in assignment"
+	s = u // ERROR "cannot use .* in assignment"
+	s = S(s)
+	s = S(t)
+	s = S(u)
+	t = u // ERROR "cannot use .* in assignment"
+	t = T(u)
+}
+
+func _() {
+	type E1 struct {
+		x int "foo"
+	}
+	type E2 struct {
+		x int "bar"
+	}
+	type S struct{ x E1 }
+	type T struct {
+		x E2 "foo"
+	}
+	var s S
+	var t T
+	var u struct {
+		x E2 "bar"
+	}
+	s = s
+	s = t // ERROR "cannot use .* in assignment"
+	s = u // ERROR "cannot use .* in assignment"
+	s = S(s)
+	s = S(t /* ERROR "cannot convert" */ )
+	s = S(u /* ERROR "cannot convert" */ )
+	t = u   // ERROR "cannot use .* in assignment"
+	t = T(u)
+}
+
+func _() {
+	type E struct{ x int }
+	type S struct {
+		f func(struct {
+			x int "foo"
+		})
+	}
+	type T struct {
+		f func(struct {
+			x int "bar"
+		})
+	}
+	var s S
+	var t T
+	var u struct{ f func(E) }
+	s = s
+	s = t // ERROR "cannot use .* in assignment"
+	s = u // ERROR "cannot use .* in assignment"
+	s = S(s)
+	s = S(t)
+	s = S(u /* ERROR "cannot convert" */ )
+	t = u   // ERROR "cannot use .* in assignment"
+	t = T(u /* ERROR "cannot convert" */ )
+}
+
+// conversions between pointers to structs
+
+func _() {
+	type S struct{}
+	type T struct{}
+	var s *S
+	var t *T
+	var u *struct{}
+	s = s
+	s = t // ERROR "cannot use .* in assignment"
+	s = u // ERROR "cannot use .* in assignment"
+	s = (*S)(s)
+	s = (*S)(t)
+	s = (*S)(u)
+	t = u // ERROR "cannot use .* in assignment"
+	t = (*T)(u)
+}
+
+func _() {
+	type S struct{ x int }
+	type T struct {
+		x int "foo"
+	}
+	var s *S
+	var t *T
+	var u *struct {
+		x int "bar"
+	}
+	s = s
+	s = t // ERROR "cannot use .* in assignment"
+	s = u // ERROR "cannot use .* in assignment"
+	s = (*S)(s)
+	s = (*S)(t)
+	s = (*S)(u)
+	t = u // ERROR "cannot use .* in assignment"
+	t = (*T)(u)
+}
+
+func _() {
+	type E struct{ x int }
+	type S struct{ x E }
+	type T struct {
+		x E "foo"
+	}
+	var s *S
+	var t *T
+	var u *struct {
+		x E "bar"
+	}
+	s = s
+	s = t // ERROR "cannot use .* in assignment"
+	s = u // ERROR "cannot use .* in assignment"
+	s = (*S)(s)
+	s = (*S)(t)
+	s = (*S)(u)
+	t = u // ERROR "cannot use .* in assignment"
+	t = (*T)(u)
+}
+
+func _() {
+	type S struct {
+		x struct {
+			x int "foo"
+		}
+	}
+	type T struct {
+		x struct {
+			x int "bar"
+		} "foo"
+	}
+	var s *S
+	var t *T
+	var u *struct {
+		x struct {
+			x int "bar"
+		} "bar"
+	}
+	s = s
+	s = t // ERROR "cannot use .* in assignment"
+	s = u // ERROR "cannot use .* in assignment"
+	s = (*S)(s)
+	s = (*S)(t)
+	s = (*S)(u)
+	t = u // ERROR "cannot use .* in assignment"
+	t = (*T)(u)
+}
+
+func _() {
+	type E1 struct {
+		x int "foo"
+	}
+	type E2 struct {
+		x int "bar"
+	}
+	type S struct{ x E1 }
+	type T struct {
+		x E2 "foo"
+	}
+	var s *S
+	var t *T
+	var u *struct {
+		x E2 "bar"
+	}
+	s = s
+	s = t // ERROR "cannot use .* in assignment"
+	s = u // ERROR "cannot use .* in assignment"
+	s = (*S)(s)
+	s = (*S)(t /* ERROR "cannot convert" */ )
+	s = (*S)(u /* ERROR "cannot convert" */ )
+	t = u      // ERROR "cannot use .* in assignment"
+	t = (*T)(u)
+}
+
+func _() {
+	type E struct{ x int }
+	type S struct {
+		f func(struct {
+			x int "foo"
+		})
+	}
+	type T struct {
+		f func(struct {
+			x int "bar"
+		})
+	}
+	var s *S
+	var t *T
+	var u *struct{ f func(E) }
+	s = s
+	s = t // ERROR "cannot use .* in assignment"
+	s = u // ERROR "cannot use .* in assignment"
+	s = (*S)(s)
+	s = (*S)(t)
+	s = (*S)(u /* ERROR "cannot convert" */ )
+	t = u      // ERROR "cannot use .* in assignment"
+	t = (*T)(u /* ERROR "cannot convert" */ )
+}
+
+func _() {
+	type E struct{ x int }
+	type S struct {
+		f func(*struct {
+			x int "foo"
+		})
+	}
+	type T struct {
+		f func(*struct {
+			x int "bar"
+		})
+	}
+	var s *S
+	var t *T
+	var u *struct{ f func(E) }
+	s = s
+	s = t // ERROR "cannot use .* in assignment"
+	s = u // ERROR "cannot use .* in assignment"
+	s = (*S)(s)
+	s = (*S)(t)
+	s = (*S)(u /* ERROR "cannot convert" */ )
+	t = u      // ERROR "cannot use .* in assignment"
+	t = (*T)(u /* ERROR "cannot convert" */ )
+}
diff --git a/src/cmd/compile/internal/types2/testdata/cycles.src b/src/cmd/compile/internal/types2/testdata/cycles.src
new file mode 100644
index 0000000000..b2ee8ecd5f
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/cycles.src
@@ -0,0 +1,174 @@
+// Copyright 2013 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 cycles
+
+import "unsafe"
+
+type (
+	T0 int
+	T1 /* ERROR cycle */ T1
+	T2 *T2
+
+	T3 /* ERROR cycle */ T4
+	T4 T5
+	T5 T3
+
+	T6 T7
+	T7 *T8
+	T8 T6
+
+	// arrays
+	A0 /* ERROR cycle */ [10]A0
+	A1 [10]*A1
+
+	A2 /* ERROR cycle */ [10]A3
+	A3 [10]A4
+	A4 A2
+
+	A5 [10]A6
+	A6 *A5
+
+	// slices
+	L0 []L0
+
+	// structs
+	S0 /* ERROR cycle */ struct{ _ S0 }
+	S1 /* ERROR cycle */ struct{ S1 }
+	S2 struct{ _ *S2 }
+	S3 struct{ *S3 }
+
+	S4 /* ERROR cycle */ struct{ S5 }
+	S5 struct{ S6 }
+	S6 S4
+
+	// pointers
+	P0 *P0
+
+	// functions
+	F0 func(F0)
+	F1 func() F1
+	F2 func(F2) F2
+
+	// interfaces
+	I0 /* ERROR cycle */ interface{ I0 }
+
+	I1 /* ERROR cycle */ interface{ I2 }
+	I2 interface{ I3 }
+	I3 interface{ I1 }
+
+	I4 interface{ f(I4) }
+
+	// testcase for issue 5090
+	I5 interface{ f(I6) }
+	I6 interface{ I5 }
+
+	// maps
+	M0 map[M0 /* ERROR invalid map key */ ]M0
+
+	// channels
+	C0 chan C0
+)
+
+// test case for issue #34771
+type (
+	AA /* ERROR cycle */ B
+	B C
+	C [10]D
+	D E
+	E AA
+)
+
+func _() {
+	type (
+		t1 /* ERROR cycle */ t1
+		t2 *t2
+
+		t3 t4 /* ERROR undeclared */
+		t4 t5 /* ERROR undeclared */
+		t5 t3
+
+		// arrays
+		a0 /* ERROR cycle */ [10]a0
+		a1 [10]*a1
+
+		// slices
+		l0 []l0
+
+		// structs
+		s0 /* ERROR cycle */ struct{ _ s0 }
+		s1 /* ERROR cycle */ struct{ s1 }
+		s2 struct{ _ *s2 }
+		s3 struct{ *s3 }
+
+		// pointers
+		p0 *p0
+
+		// functions
+		f0 func(f0)
+		f1 func() f1
+		f2 func(f2) f2
+
+		// interfaces
+		i0 /* ERROR cycle */ interface{ i0 }
+
+		// maps
+		m0 map[m0 /* ERROR invalid map key */ ]m0
+
+		// channels
+		c0 chan c0
+	)
+}
+
+// test cases for issue 6667
+
+type A [10]map[A /* ERROR invalid map key */ ]bool
+
+type S struct {
+	m map[S /* ERROR invalid map key */ ]bool
+}
+
+// test cases for issue 7236
+// (cycle detection must not be dependent on starting point of resolution)
+
+type (
+	P1 *T9
+	T9 /* ERROR cycle */ T9
+
+	T10 /* ERROR cycle */ T10
+	P2 *T10
+)
+
+func (T11) m() {}
+
+type T11 /* ERROR cycle */ struct{ T11 }
+
+type T12 /* ERROR cycle */ struct{ T12 }
+
+func (*T12) m() {}
+
+type (
+	P3 *T13
+	T13 /* ERROR cycle */ T13
+)
+
+// test cases for issue 18643
+// (type cycle detection when non-type expressions are involved)
+type (
+	T14 [len(T14 /* ERROR cycle */ {})]int
+	T15 [][len(T15 /* ERROR cycle */ {})]int
+	T16 map[[len(T16 /* ERROR cycle */ {1:2})]int]int
+	T17 map[int][len(T17 /* ERROR cycle */ {1:2})]int
+)
+
+// Test case for types depending on function literals (see also #22992).
+type T20 chan [unsafe.Sizeof(func(ch T20){ _ = <-ch })]byte
+type T22 = chan [unsafe.Sizeof(func(ch T20){ _ = <-ch })]byte
+
+func _() {
+	type T0 func(T0)
+	type T1 /* ERROR cycle */ = func(T1)
+	type T2 chan [unsafe.Sizeof(func(ch T2){ _ = <-ch })]byte
+	type T3 /* ERROR cycle */ = chan [unsafe.Sizeof(func(ch T3){ _ = <-ch })]byte
+}
diff --git a/src/cmd/compile/internal/types2/testdata/cycles1.src b/src/cmd/compile/internal/types2/testdata/cycles1.src
new file mode 100644
index 0000000000..ae2b38ebec
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/cycles1.src
@@ -0,0 +1,77 @@
+// Copyright 2013 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 p
+
+type (
+	A interface {
+		a() interface {
+			ABC1
+		}
+	}
+	B interface {
+		b() interface {
+			ABC2
+		}
+	}
+	C interface {
+		c() interface {
+			ABC3
+		}
+	}
+
+	AB interface {
+		A
+		B
+	}
+	BC interface {
+		B
+		C
+	}
+
+	ABC1 interface {
+		A
+		B
+		C
+	}
+	ABC2 interface {
+		AB
+		C
+	}
+	ABC3 interface {
+		A
+		BC
+	}
+)
+
+var (
+	x1 ABC1
+	x2 ABC2
+	x3 ABC3
+)
+
+func _() {
+	// all types have the same method set
+	x1 = x2
+	x2 = x1
+
+	x1 = x3
+	x3 = x1
+
+	x2 = x3
+	x3 = x2
+
+	// all methods return the same type again
+	x1 = x1.a()
+	x1 = x1.b()
+	x1 = x1.c()
+
+	x2 = x2.a()
+	x2 = x2.b()
+	x2 = x2.c()
+
+	x3 = x3.a()
+	x3 = x3.b()
+	x3 = x3.c()
+}
diff --git a/src/cmd/compile/internal/types2/testdata/cycles2.src b/src/cmd/compile/internal/types2/testdata/cycles2.src
new file mode 100644
index 0000000000..1a7f40ae4b
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/cycles2.src
@@ -0,0 +1,98 @@
+// Copyright 2013 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 p
+
+import "unsafe"
+
+// Test case for issue 5090
+
+type t interface {
+	f(u)
+}
+
+type u interface {
+	t
+}
+
+func _() {
+	var t t
+	var u u
+
+	t.f(t)
+	t.f(u)
+
+	u.f(t)
+	u.f(u)
+}
+
+
+// Test case for issues #6589, #33656.
+
+type A interface {
+	a() interface {
+		AB
+	}
+}
+
+type B interface {
+	b() interface {
+		AB
+	}
+}
+
+type AB interface {
+	a() interface {
+		A
+		B
+	}
+	b() interface {
+		A
+		B
+	}
+}
+
+var x AB
+var y interface {
+	A
+	B
+}
+
+var _ = x == y
+
+
+// Test case for issue 6638.
+
+type T interface {
+	m() [T(nil).m /* ERROR undefined */ ()[0]]int
+}
+
+// Variations of this test case.
+
+type T1 /* ERROR cycle */ interface {
+	m() [x1.m()[0]]int
+}
+
+var x1 T1
+
+type T2 /* ERROR cycle */ interface {
+	m() [len(x2.m())]int
+}
+
+var x2 T2
+
+type T3 /* ERROR cycle */ interface {
+	m() [unsafe.Sizeof(x3.m)]int
+}
+
+var x3 T3
+
+type T4 /* ERROR cycle */ interface {
+	m() [unsafe.Sizeof(cast4(x4.m))]int // cast is invalid but we have a cycle, so all bets are off
+}
+
+var x4 T4
+var _ = cast4(x4.m)
+
+type cast4 func()
diff --git a/src/cmd/compile/internal/types2/testdata/cycles3.src b/src/cmd/compile/internal/types2/testdata/cycles3.src
new file mode 100644
index 0000000000..5e89b627f0
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/cycles3.src
@@ -0,0 +1,60 @@
+// Copyright 2013 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 p
+
+import "unsafe"
+
+var (
+	_ A = A(nil).a().b().c().d().e().f()
+	_ A = A(nil).b().c().d().e().f()
+	_ A = A(nil).c().d().e().f()
+	_ A = A(nil).d().e().f()
+	_ A = A(nil).e().f()
+	_ A = A(nil).f()
+	_ A = A(nil)
+)
+
+type (
+	A interface {
+		a() B
+		B
+	}
+
+	B interface {
+		b() C
+		C
+	}
+
+	C interface {
+		c() D
+		D
+	}
+
+	D interface {
+		d() E
+		E
+	}
+
+	E interface {
+		e() F
+		F
+	}
+
+	F interface {
+		f() A
+	}
+)
+
+type (
+	U /* ERROR cycle */ interface {
+		V
+	}
+
+	V interface {
+		v() [unsafe.Sizeof(u)]int
+	}
+)
+
+var u U
diff --git a/src/cmd/compile/internal/types2/testdata/cycles4.src b/src/cmd/compile/internal/types2/testdata/cycles4.src
new file mode 100644
index 0000000000..445babca68
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/cycles4.src
@@ -0,0 +1,110 @@
+// Copyright 2013 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 p
+
+// Check that all methods of T are collected before
+// determining the result type of m (which embeds
+// all methods of T).
+
+type T interface {
+	m() interface {T}
+	E
+}
+
+var _ = T.m(nil).m().e()
+
+type E interface {
+	e() int
+}
+
+// Check that unresolved forward chains are followed
+// (see also comment in resolver.go, checker.typeDecl).
+
+var _ = C.m(nil).m().e()
+
+type A B
+
+type B interface {
+	m() interface{C}
+	E
+}
+
+type C A
+
+// Check that interface type comparison for identity
+// does not recur endlessly.
+
+type T1 interface {
+	m() interface{T1}
+}
+
+type T2 interface {
+	m() interface{T2}
+}
+
+func _(x T1, y T2) {
+	// Checking for assignability of interfaces must check
+	// if all methods of x are present in y, and that they
+	// have identical signatures. The signatures recur via
+	// the result type, which is an interface that embeds
+	// a single method m that refers to the very interface
+	// that contains it. This requires cycle detection in
+	// identity checks for interface types.
+	x = y
+}
+
+type T3 interface {
+	m() interface{T4}
+}
+
+type T4 interface {
+	m() interface{T3}
+}
+
+func _(x T1, y T3) {
+	x = y
+}
+
+// Check that interfaces are type-checked in order of
+// (embedded interface) dependencies (was issue 7158).
+
+var x1 T5 = T7(nil)
+
+type T5 interface {
+	T6
+}
+
+type T6 interface {
+	m() T7
+}
+type T7 interface {
+	T5
+}
+
+// Actual test case from issue 7158.
+
+func wrapNode() Node {
+	return wrapElement()
+}
+
+func wrapElement() Element {
+	return nil
+}
+
+type EventTarget interface {
+	AddEventListener(Event)
+}
+
+type Node interface {
+	EventTarget
+}
+
+type Element interface {
+	Node
+}
+
+type Event interface {
+	Target() Element
+}
diff --git a/src/cmd/compile/internal/types2/testdata/cycles5.src b/src/cmd/compile/internal/types2/testdata/cycles5.src
new file mode 100644
index 0000000000..397adcce01
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/cycles5.src
@@ -0,0 +1,200 @@
+// Copyright 2017 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 p
+
+import "unsafe"
+
+// test case from issue #18395
+
+type (
+	A interface { B }
+	B interface { C }
+	C interface { D; F() A }
+	D interface { G() B }
+)
+
+var _ = A(nil).G // G must be found
+
+
+// test case from issue #21804
+
+type sourceBridge interface {
+	listVersions() ([]Version, error)
+}
+
+type Constraint interface {
+	copyTo(*ConstraintMsg)
+}
+
+type ConstraintMsg struct{}
+
+func (m *ConstraintMsg) asUnpairedVersion() UnpairedVersion {
+	return nil
+}
+
+type Version interface {
+	Constraint
+}
+
+type UnpairedVersion interface {
+	Version
+}
+
+var _ Constraint = UnpairedVersion(nil)
+
+
+// derived test case from issue #21804
+
+type (
+	_ interface{ m(B1) }
+	A1 interface{ a(D1) }
+	B1 interface{ A1 }
+	C1 interface{ B1 }
+	D1 interface{ C1 }
+)
+
+var _ A1 = C1(nil)
+
+
+// derived test case from issue #22701
+
+func F(x I4) interface{} {
+	return x.Method()
+}
+
+type Unused interface {
+	RefersToI1(a I1)
+}
+
+type I1 interface {
+	I2
+	I3
+}
+
+type I2 interface {
+	RefersToI4() I4
+}
+
+type I3 interface {
+	Method() interface{}
+}
+
+type I4 interface {
+	I1
+}
+
+
+// check embedding of error interface
+
+type Error interface{ error }
+
+var err Error
+var _ = err.Error()
+
+
+// more esoteric cases
+
+type (
+	T1 interface { T2 }
+	T2 /* ERROR cycle */ T2
+)
+
+type (
+	T3 interface { T4 }
+	T4 /* ERROR cycle */ T5
+	T5 = T6
+	T6 = T7
+	T7 = T4
+)
+
+
+// arbitrary code may appear inside an interface
+
+const n = unsafe.Sizeof(func(){})
+
+type I interface {
+	m([unsafe.Sizeof(func() { I.m(nil, [n]byte{}) })]byte)
+}
+
+
+// test cases for varias alias cycles
+
+type T10 /* ERROR cycle */ = *T10                 // issue #25141
+type T11 /* ERROR cycle */ = interface{ f(T11) }  // issue #23139
+
+// issue #18640
+type (
+	aa = bb
+	bb struct {
+		*aa
+	}
+)
+
+type (
+	a struct{ *b }
+	b = c
+	c struct{ *b }
+)
+
+// issue #24939
+type (
+	_ interface {
+		M(P)
+	}
+
+	M interface {
+		F() P
+	}
+
+	P = interface {
+		I() M
+	}
+)
+
+// issue #8699
+type T12 /* ERROR cycle */ [len(a12)]int
+var a12 = makeArray()
+func makeArray() (res T12) { return }
+
+// issue #20770
+var r /* ERROR cycle */ = newReader()
+func newReader() r
+
+// variations of the theme of #8699 and #20770
+var arr /* ERROR cycle */ = f()
+func f() [len(arr)]int
+
+// issue #25790
+func ff(ff /* ERROR not a type */ )
+func gg((gg /* ERROR not a type */ ))
+
+type T13 /* ERROR cycle */ [len(b13)]int
+var b13 T13
+
+func g1() [unsafe.Sizeof(g1)]int
+func g2() [unsafe.Sizeof(x2)]int
+var x2 = g2
+
+// verify that we get the correct sizes for the functions above
+// (note: assert is statically evaluated in go/types test mode)
+func init() {
+	assert(unsafe.Sizeof(g1) == 8)
+	assert(unsafe.Sizeof(x2) == 8)
+}
+
+func h() [h /* ERROR no value */ ()[0]]int { panic(0) }
+
+var c14 /* ERROR cycle */ T14
+type T14 [uintptr(unsafe.Sizeof(&c14))]byte
+
+// issue #34333
+type T15 /* ERROR cycle */ struct {
+	f func() T16
+	b T16
+}
+
+type T16 struct {
+	T15
+}
\ No newline at end of file
diff --git a/src/cmd/compile/internal/types2/testdata/decls0.src b/src/cmd/compile/internal/types2/testdata/decls0.src
new file mode 100644
index 0000000000..5501b65915
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/decls0.src
@@ -0,0 +1,206 @@
+// Copyright 2011 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.
+
+// type declarations
+
+package decls0
+
+import "unsafe"
+
+const pi = 3.1415
+
+type (
+	N undeclared /* ERROR "undeclared" */
+	B bool
+	I int32
+	A [10]P
+	T struct {
+		x, y P
+	}
+	P *T
+	R (*R)
+	F func(A) I
+	Y interface {
+		f(A) I
+	}
+	S [](((P)))
+	M map[I]F
+	C chan<- I
+
+	// blank types must be typechecked
+	_ pi /* ERROR "not a type" */
+	_ struct{}
+	_ struct{ pi /* ERROR "not a type" */ }
+)
+
+
+// declarations of init
+const _, init /* ERROR "cannot declare init" */ , _ = 0, 1, 2
+type init /* ERROR "cannot declare init" */ struct{}
+var _, init /* ERROR "cannot declare init" */ int
+
+func init() {}
+func init /* ERROR "missing function body" */ ()
+
+func _() { const init = 0 }
+func _() { type init int }
+func _() { var init int; _ = init }
+
+// invalid array types
+type (
+	iA0 [... /* ERROR "invalid use of '...'" */ ]byte
+	// The error message below could be better. At the moment
+	// we believe an integer that is too large is not an integer.
+	// But at least we get an error.
+	iA1 [1 /* ERROR "must be integer" */ <<100]int
+	iA2 [- /* ERROR "invalid array length" */ 1]complex128
+	iA3 ["foo" /* ERROR "must be integer" */ ]string
+	iA4 [float64 /* ERROR "must be integer" */ (0)]int
+)
+
+
+type (
+	p1 pi.foo /* ERROR "no field or method foo" */
+	p2 unsafe.Pointer
+)
+
+
+type (
+	Pi pi /* ERROR "not a type" */
+
+	a /* ERROR "illegal cycle" */ a
+	a /* ERROR "redeclared" */ int
+
+	b /* ERROR "illegal cycle" */ c
+	c d
+	d e
+	e b
+
+	t *t
+
+	U V
+	V *W
+	W U
+
+	P1 *S2
+	P2 P1
+
+	S0 struct {
+	}
+	S1 struct {
+		a, b, c int
+		u, v, a /* ERROR "redeclared" */ float32
+	}
+	S2 struct {
+		S0 // embedded field
+		S0 /* ERROR "redeclared" */ int
+	}
+	S3 struct {
+		x S2
+	}
+	S4/* ERROR "illegal cycle" */ struct {
+		S4
+	}
+	S5 /* ERROR "illegal cycle" */ struct {
+		S6
+	}
+	S6 struct {
+		field S7
+	}
+	S7 struct {
+		S5
+	}
+
+	L1 []L1
+	L2 []int
+
+	A1 [10.0]int
+	A2 /* ERROR "illegal cycle" */ [10]A2
+	A3 /* ERROR "illegal cycle" */ [10]struct {
+		x A4
+	}
+	A4 [10]A3
+
+	F1 func()
+	F2 func(x, y, z float32)
+	F3 func(x, y, x /* ERROR "redeclared" */ float32)
+	F4 func() (x, y, x /* ERROR "redeclared" */ float32)
+	F5 func(x int) (x /* ERROR "redeclared" */ float32)
+	F6 func(x ...int)
+
+	I1 interface{}
+	I2 interface {
+		m1()
+	}
+	I3 interface {
+		m1()
+		m1 /* ERROR "duplicate method" */ ()
+	}
+	I4 interface {
+		m1(x, y, x /* ERROR "redeclared" */ float32)
+		m2() (x, y, x /* ERROR "redeclared" */ float32)
+		m3(x int) (x /* ERROR "redeclared" */ float32)
+	}
+	I5 interface {
+		m1(I5)
+	}
+	I6 interface {
+		S0 /* ERROR "not an interface" */
+	}
+	I7 interface {
+		I1
+		I1
+	}
+	I8 /* ERROR "illegal cycle" */ interface {
+		I8
+	}
+	I9 /* ERROR "illegal cycle" */ interface {
+		I10
+	}
+	I10 interface {
+		I11
+	}
+	I11 interface {
+		I9
+	}
+
+	C1 chan int
+	C2 <-chan int
+	C3 chan<- C3
+	C4 chan C5
+	C5 chan C6
+	C6 chan C4
+
+	M1 map[Last]string
+	M2 map[string]M2
+
+	Last int
+)
+
+// cycles in function/method declarations
+// (test cases for issues #5217, #25790 and variants)
+func f1(x f1 /* ERROR "not a type" */ ) {}
+func f2(x *f2 /* ERROR "not a type" */ ) {}
+func f3() (x f3 /* ERROR "not a type" */ ) { return }
+func f4() (x *f4 /* ERROR "not a type" */ ) { return }
+
+func (S0) m1 /* ERROR illegal cycle */ (x S0 /* ERROR value .* is not a type */ .m1) {}
+func (S0) m2 /* ERROR illegal cycle */ (x *S0 /* ERROR value .* is not a type */ .m2) {}
+func (S0) m3 /* ERROR illegal cycle */ () (x S0 /* ERROR value .* is not a type */ .m3) { return }
+func (S0) m4 /* ERROR illegal cycle */ () (x *S0 /* ERROR value .* is not a type */ .m4) { return }
+
+// interfaces may not have any blank methods
+type BlankI interface {
+	_ /* ERROR "invalid method name" */ ()
+	_ /* ERROR "invalid method name" */ (float32) int
+	m()
+}
+
+// non-interface types may have multiple blank methods
+type BlankT struct{}
+
+func (BlankT) _() {}
+func (BlankT) _(int) {}
+func (BlankT) _() int { return 0 }
+func (BlankT) _(int) int { return 0}
diff --git a/src/cmd/compile/internal/types2/testdata/decls1.src b/src/cmd/compile/internal/types2/testdata/decls1.src
new file mode 100644
index 0000000000..e6beb78358
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/decls1.src
@@ -0,0 +1,144 @@
+// Copyright 2012 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.
+
+// variable declarations
+
+package decls1
+
+import (
+	"math"
+)
+
+// Global variables without initialization
+var (
+	a, b bool
+	c byte
+	d uint8
+	r rune
+	i int
+	j, k, l int
+	x, y float32
+	xx, yy float64
+	u, v complex64
+	uu, vv complex128
+	s, t string
+	array []byte
+	iface interface{}
+
+	blank _ /* ERROR "cannot use _" */
+)
+
+// Global variables with initialization
+var (
+	s1 = i + j
+	s2 = i /* ERROR "mismatched types" */ + x
+	s3 = c + d
+	s4 = s + t
+	s5 = s /* ERROR "invalid operation" */ / t
+	s6 = array[t1]
+	s7 = array[x /* ERROR "integer" */]
+	s8 = &a
+	s10 = &42 /* ERROR "cannot take address" */
+	s11 = &v
+	s12 = -(u + *t11) / *&v
+	s13 = a /* ERROR "shifted operand" */ << d
+	s14 = i << j
+	s18 = math.Pi * 10.0
+	s19 = s1 /* ERROR "cannot call" */ ()
+ 	s20 = f0 /* ERROR "no value" */ ()
+	s21 = f6(1, s1, i)
+	s22 = f6(1, s1, uu /* ERROR "cannot use .* in argument" */ )
+
+	t1 int = i + j
+	t2 int = i /* ERROR "mismatched types" */ + x
+	t3 int = c /* ERROR "cannot use .* variable declaration" */ + d
+	t4 string = s + t
+	t5 string = s /* ERROR "invalid operation" */ / t
+	t6 byte = array[t1]
+	t7 byte = array[x /* ERROR "must be integer" */]
+	t8 *int = & /* ERROR "cannot use .* variable declaration" */ a
+	t10 *int = &42 /* ERROR "cannot take address" */
+	t11 *complex64 = &v
+	t12 complex64 = -(u + *t11) / *&v
+	t13 int = a /* ERROR "shifted operand" */ << d
+	t14 int = i << j
+	t15 math /* ERROR "not in selector" */
+	t16 math.xxx /* ERROR "not declared" */
+	t17 math /* ERROR "not a type" */ .Pi
+	t18 float64 = math.Pi * 10.0
+	t19 int = t1 /* ERROR "cannot call" */ ()
+	t20 int = f0 /* ERROR "no value" */ ()
+	t21 int = a /* ERROR "cannot use .* variable declaration" */
+)
+
+// Various more complex expressions
+var (
+	u1 = x /* ERROR "not an interface" */ .(int)
+	u2 = iface.([]int)
+	u3 = iface.(a /* ERROR "not a type" */ )
+	u4, ok = iface.(int)
+	u5, ok2, ok3 = iface /* ERROR "cannot initialize" */ .(int)
+)
+
+// Constant expression initializations
+var (
+	v1 = 1 /* ERROR "cannot convert" */ + "foo"
+	v2 = c + 255
+	v3 = c + 256 /* ERROR "overflows" */
+	v4 = r + 2147483647
+	v5 = r + 2147483648 /* ERROR "overflows" */
+	v6 = 42
+	v7 = v6 + 9223372036854775807
+	v8 = v6 + 9223372036854775808 /* ERROR "overflows" */
+	v9 = i + 1 << 10
+	v10 byte = 1024 /* ERROR "overflows" */
+	v11 = xx/yy*yy - xx
+	v12 = true && false
+	v13 = nil /* ERROR "use of untyped nil" */
+)
+
+// Multiple assignment expressions
+var (
+	m1a, m1b = 1, 2
+	m2a, m2b, m2c /* ERROR "missing init expr for m2c" */ = 1, 2
+	m3a, m3b = 1, 2, 3 /* ERROR "extra init expr 3" */
+)
+
+func _() {
+	var (
+		m1a, m1b = 1, 2
+		m2a, m2b, m2c /* ERROR "missing init expr for m2c" */ = 1, 2
+		m3a, m3b = 1, 2, 3 /* ERROR "extra init expr 3" */
+	)
+
+	_, _ = m1a, m1b
+	_, _, _ = m2a, m2b, m2c
+	_, _ = m3a, m3b
+}
+
+// Declaration of parameters and results
+func f0() {}
+func f1(a /* ERROR "not a type" */) {}
+func f2(a, b, c d /* ERROR "not a type" */) {}
+
+func f3() int { return 0 }
+func f4() a /* ERROR "not a type" */ { return 0 }
+func f5() (a, b, c d /* ERROR "not a type" */) { return }
+
+func f6(a, b, c int) complex128 { return 0 }
+
+// Declaration of receivers
+type T struct{}
+
+func (T) m0() {}
+func (*T) m1() {}
+func (x T) m2() {}
+func (x *T) m3() {}
+
+// Initialization functions
+func init() {}
+func /* ERROR "no arguments and no return values" */ init(int) {}
+func /* ERROR "no arguments and no return values" */ init() int { return 0 }
+func /* ERROR "no arguments and no return values" */ init(int) int { return 0 }
+func (T) init(int) int { return 0 }
diff --git a/src/cmd/compile/internal/types2/testdata/decls3.src b/src/cmd/compile/internal/types2/testdata/decls3.src
new file mode 100644
index 0000000000..745175c710
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/decls3.src
@@ -0,0 +1,309 @@
+// Copyright 2012 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.
+
+// embedded types
+
+package decls3
+
+import "unsafe"
+import "fmt"
+
+// fields with the same name at the same level cancel each other out
+
+func _() {
+	type (
+		T1 struct { X int }
+		T2 struct { X int }
+		T3 struct { T1; T2 } // X is embedded twice at the same level via T1->X, T2->X
+	)
+
+	var t T3
+	_ = t.X /* ERROR "ambiguous selector t.X" */
+}
+
+func _() {
+	type (
+		T1 struct { X int }
+		T2 struct { T1 }
+		T3 struct { T1 }
+		T4 struct { T2; T3 } // X is embedded twice at the same level via T2->T1->X, T3->T1->X
+	)
+
+	var t T4
+	_ = t.X /* ERROR "ambiguous selector t.X" */
+}
+
+func issue4355() {
+	type (
+	    T1 struct {X int}
+	    T2 struct {T1}
+	    T3 struct {T2}
+	    T4 struct {T2}
+	    T5 struct {T3; T4} // X is embedded twice at the same level via T3->T2->T1->X, T4->T2->T1->X
+	)
+
+	var t T5
+	_ = t.X /* ERROR "ambiguous selector t.X" */
+}
+
+func _() {
+	type State int
+	type A struct{ State }
+	type B struct{ fmt.State }
+	type T struct{ A; B }
+
+	var t T
+	_ = t.State /* ERROR "ambiguous selector t.State" */
+}
+
+// Embedded fields can be predeclared types.
+
+func _() {
+	type T0 struct{
+		int
+		float32
+		f int
+	}
+	var x T0
+	_ = x.int
+	_ = x.float32
+	_ = x.f
+
+	type T1 struct{
+		T0
+	}
+	var y T1
+	_ = y.int
+	_ = y.float32
+	_ = y.f
+}
+
+// Restrictions on embedded field types.
+
+func _() {
+	type I1 interface{}
+	type I2 interface{}
+	type P1 *int
+	type P2 *int
+	type UP unsafe.Pointer
+
+	type T1 struct {
+		I1
+		* /* ERROR "cannot be a pointer to an interface" */ I2
+		* /* ERROR "cannot be a pointer to an interface" */ error
+		P1 /* ERROR "cannot be a pointer" */
+		* /* ERROR "cannot be a pointer" */ P2
+	}
+
+	// unsafe.Pointers are treated like regular pointers when embedded
+	type T2 struct {
+		unsafe /* ERROR "cannot be unsafe.Pointer" */ .Pointer
+		*/* ERROR "cannot be unsafe.Pointer" */ /* ERROR "Pointer redeclared" */ unsafe.Pointer
+		UP /* ERROR "cannot be unsafe.Pointer" */
+		* /* ERROR "cannot be unsafe.Pointer" */  /* ERROR "UP redeclared" */ UP
+	}
+}
+
+// Named types that are pointers.
+
+type S struct{ x int }
+func (*S) m() {}
+type P *S
+
+func _() {
+	var s *S
+	_ = s.x
+	_ = s.m
+
+	var p P
+	_ = p.x
+	_ = p.m /* ERROR "no field or method" */
+	_ = P.m /* ERROR "no field or method" */
+}
+
+// Borrowed from the FieldByName test cases in reflect/all_test.go.
+
+type D1 struct {
+	d int
+}
+type D2 struct {
+	d int
+}
+
+type S0 struct {
+	A, B, C int
+	D1
+	D2
+}
+
+type S1 struct {
+	B int
+	S0
+}
+
+type S2 struct {
+	A int
+	*S1
+}
+
+type S1x struct {
+	S1
+}
+
+type S1y struct {
+	S1
+}
+
+type S3 struct {
+	S1x
+	S2
+	D, E int
+	*S1y
+}
+
+type S4 struct {
+	*S4
+	A int
+}
+
+// The X in S6 and S7 annihilate, but they also block the X in S8.S9.
+type S5 struct {
+	S6
+	S7
+	S8
+}
+
+type S6 struct {
+	X int
+}
+
+type S7 S6
+
+type S8 struct {
+	S9
+}
+
+type S9 struct {
+	X int
+	Y int
+}
+
+// The X in S11.S6 and S12.S6 annihilate, but they also block the X in S13.S8.S9.
+type S10 struct {
+	S11
+	S12
+	S13
+}
+
+type S11 struct {
+	S6
+}
+
+type S12 struct {
+	S6
+}
+
+type S13 struct {
+	S8
+}
+
+func _() {
+	_ = struct{}{}.Foo /* ERROR "no field or method" */
+	_ = S0{}.A
+	_ = S0{}.D /* ERROR "no field or method" */
+	_ = S1{}.A
+	_ = S1{}.B
+	_ = S1{}.S0
+	_ = S1{}.C
+	_ = S2{}.A
+	_ = S2{}.S1
+	_ = S2{}.B
+	_ = S2{}.C
+	_ = S2{}.D /* ERROR "no field or method" */
+	_ = S3{}.S1 /* ERROR "ambiguous selector \(S3 literal\).S1" */
+	_ = S3{}.A
+	_ = S3{}.B /* ERROR "ambiguous selector" \(S3 literal\).B */
+	_ = S3{}.D
+	_ = S3{}.E
+	_ = S4{}.A
+	_ = S4{}.B /* ERROR "no field or method" */
+	_ = S5{}.X /* ERROR "ambiguous selector \(S5 literal\).X" */
+	_ = S5{}.Y
+	_ = S10{}.X /* ERROR "ambiguous selector \(S10 literal\).X" */
+	_ = S10{}.Y
+}
+
+// Borrowed from the FieldByName benchmark in reflect/all_test.go.
+
+type R0 struct {
+	*R1
+	*R2
+	*R3
+	*R4
+}
+
+type R1 struct {
+	*R5
+	*R6
+	*R7
+	*R8
+}
+
+type R2 R1
+type R3 R1
+type R4 R1
+
+type R5 struct {
+	*R9
+	*R10
+	*R11
+	*R12
+}
+
+type R6 R5
+type R7 R5
+type R8 R5
+
+type R9 struct {
+	*R13
+	*R14
+	*R15
+	*R16
+}
+
+type R10 R9
+type R11 R9
+type R12 R9
+
+type R13 struct {
+	*R17
+	*R18
+	*R19
+	*R20
+}
+
+type R14 R13
+type R15 R13
+type R16 R13
+
+type R17 struct {
+	*R21
+	*R22
+	*R23
+	*R24
+}
+
+type R18 R17
+type R19 R17
+type R20 R17
+
+type R21 struct {
+	X int
+}
+
+type R22 R21
+type R23 R21
+type R24 R21
+
+var _ = R0{}.X /* ERROR "ambiguous selector \(R0 literal\).X" */
\ No newline at end of file
diff --git a/src/cmd/compile/internal/types2/testdata/decls4.src b/src/cmd/compile/internal/types2/testdata/decls4.src
new file mode 100644
index 0000000000..140bbfd31f
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/decls4.src
@@ -0,0 +1,199 @@
+// Copyright 2016 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.
+
+// type aliases
+
+package decls4
+
+type (
+	T0 [10]int
+	T1 []byte
+	T2 struct {
+		x int
+	}
+	T3 interface{
+		m() T2
+	}
+	T4 func(int, T0) chan T2
+)
+
+type (
+	Ai = int
+	A0 = T0
+	A1 = T1
+	A2 = T2
+	A3 = T3
+	A4 = T4
+
+	A10 = [10]int
+	A11 = []byte
+	A12 = struct {
+		x int
+	}
+	A13 = interface{
+		m() A2
+	}
+	A14 = func(int, A0) chan A2
+)
+
+// check assignment compatibility due to equality of types
+var (
+	xi_ int
+	ai Ai = xi_
+
+	x0 T0
+	a0 A0 = x0
+
+	x1 T1
+	a1 A1 = x1
+
+	x2 T2
+	a2 A2 = x2
+
+	x3 T3
+	a3 A3 = x3
+
+	x4 T4
+	a4 A4 = x4
+)
+
+// alias receiver types
+func (Ai /* ERROR "invalid receiver" */) m1() {}
+func (T0) m1() {}
+func (A0) m1 /* ERROR already declared */ () {}
+func (A0) m2 () {}
+func (A3 /* ERROR invalid receiver */ ) m1 () {}
+func (A10 /* ERROR invalid receiver */ ) m1() {}
+
+// x0 has methods m1, m2 declared via receiver type names T0 and A0
+var _ interface{ m1(); m2() } = x0
+
+// alias receiver types (test case for issue #23042)
+type T struct{}
+
+var (
+	_ = T.m
+	_ = T{}.m
+	_ interface{m()} = T{}
+)
+
+var (
+	_ = T.n
+	_ = T{}.n
+	_ interface{m(); n()} = T{}
+)
+
+type U = T
+func (U) m() {}
+
+// alias receiver types (long type declaration chains)
+type (
+	V0 = V1
+	V1 = (V2)
+	V2 = ((V3))
+	V3 = T
+)
+
+func (V0) m /* ERROR already declared */ () {}
+func (V1) n() {}
+
+// alias receiver types (invalid due to cycles)
+type (
+	W0 /* ERROR illegal cycle */ = W1
+	W1 = (W2)
+	W2 = ((W0))
+)
+
+func (W0) m() {} // no error expected (due to above cycle error)
+func (W1) n() {}
+
+// alias receiver types (invalid due to builtin underlying type)
+type (
+	B0 = B1
+	B1 = B2
+	B2 = int
+)
+
+func (B0 /* ERROR invalid receiver */ ) m() {}
+func (B1 /* ERROR invalid receiver */ ) n() {}
+
+// cycles
+type (
+	C2 /* ERROR illegal cycle */ = C2
+	C3 /* ERROR illegal cycle */ = C4
+	C4 = C3
+	C5 struct {
+		f *C6
+	}
+	C6 = C5
+	C7 /* ERROR illegal cycle */  struct {
+		f C8
+	}
+	C8 = C7
+)
+
+// embedded fields
+var (
+	s0 struct { T0 }
+	s1 struct { A0 } = s0 /* ERROR cannot use */ // embedded field names are different
+)
+
+// embedding and lookup of fields and methods
+func _(s struct{A0}) { s.A0 = x0 }
+
+type eX struct{xf int}
+
+func (eX) xm()
+
+type eY = struct{eX} // field/method set of eY includes xf, xm
+
+type eZ = *struct{eX} // field/method set of eZ includes xf, xm
+
+type eA struct {
+	eX // eX contributes xf, xm to eA
+}
+
+type eA2 struct {
+	*eX // *eX contributes xf, xm to eA
+}
+
+type eB struct {
+	eY // eY contributes xf, xm to eB
+}
+
+type eB2 struct {
+	*eY // *eY contributes xf, xm to eB
+}
+
+type eC struct {
+	eZ // eZ contributes xf, xm to eC
+}
+
+var (
+	_ = eA{}.xf
+	_ = eA{}.xm
+	_ = eA2{}.xf
+	_ = eA2{}.xm
+	_ = eB{}.xf
+	_ = eB{}.xm
+	_ = eB2{}.xf
+	_ = eB2{}.xm
+	_ = eC{}.xf
+	_ = eC{}.xm
+)
+
+// ambiguous selectors due to embedding via type aliases
+type eD struct {
+	eY
+	eZ
+}
+
+var (
+	_ = eD{}.xf /* ERROR ambiguous selector \(eD literal\).xf */
+	_ = eD{}.xm /* ERROR ambiguous selector \(eD literal\).xm */
+)
+
+var (
+	_ interface{ xm() } = eD /* ERROR missing method xm */ {}
+)
\ No newline at end of file
diff --git a/src/cmd/compile/internal/types2/testdata/decls5.src b/src/cmd/compile/internal/types2/testdata/decls5.src
new file mode 100644
index 0000000000..88d31946da
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/decls5.src
@@ -0,0 +1,10 @@
+// Copyright 2017 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
+
+// declarations of main
+const _, main /* ERROR "cannot declare main" */ , _ = 0, 1, 2
+type main /* ERROR "cannot declare main" */ struct{}
+var _, main /* ERROR "cannot declare main" */ int
diff --git a/src/cmd/compile/internal/types2/testdata/errors.src b/src/cmd/compile/internal/types2/testdata/errors.src
new file mode 100644
index 0000000000..ff929217c4
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/errors.src
@@ -0,0 +1,60 @@
+// Copyright 2013 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 errors
+
+// Testing precise operand formatting in error messages
+// (matching messages are regular expressions, hence the \'s).
+func f(x int, m map[string]int) {
+	// no values
+	_ = f /* ERROR "f\(0, m\) \(no value\) used as value" */ (0, m)
+
+	// built-ins
+	_ = println /* ERROR "println \(built-in\) must be called" */
+
+	// types
+	_ = complex128 /* ERROR "complex128 \(type\) is not an expression" */
+
+	// constants
+	const c1 = 991
+	const c2 float32 = 0.5
+	0 /* ERROR "0 \(untyped int constant\) is not used" */
+	c1 /* ERROR "c1 \(untyped int constant 991\) is not used" */
+	c2 /* ERROR "c2 \(constant 0.5 of type float32\) is not used" */
+	c1 /* ERROR "c1 \+ c2 \(constant 991.5 of type float32\) is not used" */ + c2
+
+	// variables
+	x /* ERROR "x \(variable of type int\) is not used" */
+
+	// values
+	x /* ERROR "x != x \(untyped bool value\) is not used" */ != x
+	x /* ERROR "x \+ x \(value of type int\) is not used" */ + x
+
+	// value, ok's
+	const s = "foo"
+	m /* ERROR "m\[s\] \(map index expression of type int\) is not used" */ [s]
+}
+
+// Valid ERROR comments can have a variety of forms.
+func _() {
+	0 /* ERROR "0 .* is not used" */
+	0 /* ERROR 0 .* is not used */
+	0 // ERROR "0 .* is not used"
+	0 // ERROR 0 .* is not used
+}
+
+// Don't report spurious errors as a consequence of earlier errors.
+// Add more tests as needed.
+func _() {
+	if err := foo /* ERROR undeclared */ (); err != nil /* no error here */ {}
+}
+
+// Use unqualified names for package-local objects.
+type T struct{}
+var _ int = T /* ERROR value of type T */ {} // use T in error message rather then errors.T
+
+// Don't report errors containing "invalid type" (issue #24182).
+func _(x *missing /* ERROR undeclared name: missing */ ) {
+	x.m() // there shouldn't be an error here referring to *invalid type
+}
diff --git a/src/cmd/compile/internal/types2/testdata/expr0.src b/src/cmd/compile/internal/types2/testdata/expr0.src
new file mode 100644
index 0000000000..1aac726327
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/expr0.src
@@ -0,0 +1,180 @@
+// Copyright 2012 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.
+
+// unary expressions
+
+package expr0 
+
+type mybool bool
+
+var (
+	// bool
+	b0 = true
+	b1 bool = b0
+	b2 = !true
+	b3 = !b1
+	b4 bool = !true
+	b5 bool = !b4
+	b6 = +b0 /* ERROR "not defined" */
+	b7 = -b0 /* ERROR "not defined" */
+	b8 = ^b0 /* ERROR "not defined" */
+	b9 = *b0 /* ERROR "cannot indirect" */
+	b10 = &true /* ERROR "cannot take address" */
+	b11 = &b0
+	b12 = <-b0 /* ERROR "cannot receive" */
+	b13 = & & /* ERROR "cannot take address" */ b0
+
+	// byte
+	_ = byte(0)
+	_ = byte(- /* ERROR "cannot convert" */ 1)
+	_ = - /* ERROR "-byte\(1\) \(constant -1 of type byte\) overflows byte" */ byte(1) // test for issue 11367
+	_ = byte /* ERROR "overflows byte" */ (0) - byte(1)
+
+	// int
+	i0 = 1
+	i1 int = i0
+	i2 = +1
+	i3 = +i0
+	i4 int = +1
+	i5 int = +i4
+	i6 = -1
+	i7 = -i0
+	i8 int = -1
+	i9 int = -i4
+	i10 = !i0 /* ERROR "not defined" */
+	i11 = ^1
+	i12 = ^i0
+	i13 int = ^1
+	i14 int = ^i4
+	i15 = *i0 /* ERROR "cannot indirect" */
+	i16 = &i0
+	i17 = *i16
+	i18 = <-i16 /* ERROR "cannot receive" */
+
+	// uint
+	u0 = uint(1)
+	u1 uint = u0
+	u2 = +1
+	u3 = +u0
+	u4 uint = +1
+	u5 uint = +u4
+	u6 = -1
+	u7 = -u0
+	u8 uint = - /* ERROR "overflows" */ 1
+	u9 uint = -u4
+	u10 = !u0 /* ERROR "not defined" */
+	u11 = ^1
+	u12 = ^i0
+	u13 uint = ^ /* ERROR "overflows" */ 1
+	u14 uint = ^u4
+	u15 = *u0 /* ERROR "cannot indirect" */
+	u16 = &u0
+	u17 = *u16
+	u18 = <-u16 /* ERROR "cannot receive" */
+	u19 = ^uint(0)
+
+	// float64
+	f0 = float64(1)
+	f1 float64 = f0
+	f2 = +1
+	f3 = +f0
+	f4 float64 = +1
+	f5 float64 = +f4
+	f6 = -1
+	f7 = -f0
+	f8 float64 = -1
+	f9 float64 = -f4
+	f10 = !f0 /* ERROR "not defined" */
+	f11 = ^1
+	f12 = ^i0
+	f13 float64 = ^1
+	f14 float64 = ^f4 /* ERROR "not defined" */
+	f15 = *f0 /* ERROR "cannot indirect" */
+	f16 = &f0
+	f17 = *u16
+	f18 = <-u16 /* ERROR "cannot receive" */
+
+	// complex128
+	c0 = complex128(1)
+	c1 complex128 = c0
+	c2 = +1
+	c3 = +c0
+	c4 complex128 = +1
+	c5 complex128 = +c4
+	c6 = -1
+	c7 = -c0
+	c8 complex128 = -1
+	c9 complex128 = -c4
+	c10 = !c0 /* ERROR "not defined" */
+	c11 = ^1
+	c12 = ^i0
+	c13 complex128 = ^1
+	c14 complex128 = ^c4 /* ERROR "not defined" */
+	c15 = *c0 /* ERROR "cannot indirect" */
+	c16 = &c0
+	c17 = *u16
+	c18 = <-u16 /* ERROR "cannot receive" */
+
+	// string
+	s0 = "foo"
+	s1 = +"foo" /* ERROR "not defined" */
+	s2 = -s0 /* ERROR "not defined" */
+	s3 = !s0 /* ERROR "not defined" */
+	s4 = ^s0 /* ERROR "not defined" */
+	s5 = *s4
+	s6 = &s4
+	s7 = *s6
+	s8 = <-s7
+
+	// channel
+	ch chan int
+	rc <-chan float64
+	sc chan <- string
+	ch0 = +ch /* ERROR "not defined" */
+	ch1 = -ch /* ERROR "not defined" */
+	ch2 = !ch /* ERROR "not defined" */
+	ch3 = ^ch /* ERROR "not defined" */
+	ch4 = *ch /* ERROR "cannot indirect" */
+	ch5 = &ch
+	ch6 = *ch5
+	ch7 = <-ch
+	ch8 = <-rc
+	ch9 = <-sc /* ERROR "cannot receive" */
+	ch10, ok = <-ch
+	// ok is of type bool
+	ch11, myok = <-ch
+	_ mybool = myok /* ERROR "cannot use .* in variable declaration" */
+)
+
+// address of composite literals
+type T struct{x, y int}
+
+func f() T { return T{} }
+
+var (
+	_ = &T{1, 2}
+	_ = &[...]int{}
+	_ = &[]int{}
+	_ = &[]int{}
+	_ = &map[string]T{}
+	_ = &(T{1, 2})
+	_ = &((((T{1, 2}))))
+	_ = &f /* ERROR "cannot take address" */ ()
+)
+
+// recursive pointer types
+type P *P
+
+var (
+	p1 P = new(P)
+	p2 P = *p1
+	p3 P = &p2
+)
+
+func g() (a, b int) { return }
+
+func _() {
+	_ = -g /* ERROR 2-valued g */ ()
+	_ = <-g /* ERROR 2-valued g */ ()
+}
diff --git a/src/cmd/compile/internal/types2/testdata/expr1.src b/src/cmd/compile/internal/types2/testdata/expr1.src
new file mode 100644
index 0000000000..4ead815158
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/expr1.src
@@ -0,0 +1,127 @@
+// Copyright 2012 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.
+
+// binary expressions
+
+package expr1
+
+type mybool bool
+
+func _(x, y bool, z mybool) {
+	x = x || y
+	x = x || true
+	x = x || false
+	x = x && y
+	x = x && true
+	x = x && false
+
+	z = z /* ERROR mismatched types */ || y
+	z = z || true
+	z = z || false
+	z = z /* ERROR mismatched types */ && y
+	z = z && true
+	z = z && false
+}
+
+type myint int
+
+func _(x, y int, z myint) {
+	x = x + 1
+	x = x + 1.0
+	x = x + 1.1 // ERROR truncated to int
+	x = x + y
+	x = x - y
+	x = x * y
+	x = x / y
+	x = x % y
+	x = x << y
+	x = x >> y
+
+	z = z + 1
+	z = z + 1.0
+	z = z + 1.1 // ERROR truncated to int
+	z = z /* ERROR mismatched types */ + y
+	z = z /* ERROR mismatched types */ - y
+	z = z /* ERROR mismatched types */ * y
+	z = z /* ERROR mismatched types */ / y
+	z = z /* ERROR mismatched types */ % y
+	z = z << y
+	z = z >> y
+}
+
+type myuint uint
+
+func _(x, y uint, z myuint) {
+	x = x + 1
+	x = x + - /* ERROR overflows uint */ 1
+	x = x + 1.0
+	x = x + 1.1 // ERROR truncated to uint
+	x = x + y
+	x = x - y
+	x = x * y
+	x = x / y
+	x = x % y
+	x = x << y
+	x = x >> y
+
+	z = z + 1
+	z = x + - /* ERROR overflows uint */ 1
+	z = z + 1.0
+	z = z + 1.1 // ERROR truncated to uint
+	z = z /* ERROR mismatched types */ + y
+	z = z /* ERROR mismatched types */ - y
+	z = z /* ERROR mismatched types */ * y
+	z = z /* ERROR mismatched types */ / y
+	z = z /* ERROR mismatched types */ % y
+	z = z << y
+	z = z >> y
+}
+
+type myfloat64 float64
+
+func _(x, y float64, z myfloat64) {
+	x = x + 1
+	x = x + -1
+	x = x + 1.0
+	x = x + 1.1
+	x = x + y
+	x = x - y
+	x = x * y
+	x = x / y
+	x = x /* ERROR not defined */ % y
+	x = x /* ERROR operand x .* must be integer */ << y
+	x = x /* ERROR operand x .* must be integer */ >> y
+
+	z = z + 1
+	z = z + -1
+	z = z + 1.0
+	z = z + 1.1
+	z = z /* ERROR mismatched types */ + y
+	z = z /* ERROR mismatched types */ - y
+	z = z /* ERROR mismatched types */ * y
+	z = z /* ERROR mismatched types */ / y
+	z = z /* ERROR mismatched types */ % y
+	z = z /* ERROR operand z .* must be integer */ << y
+	z = z /* ERROR operand z .* must be integer */ >> y
+}
+
+type mystring string
+
+func _(x, y string, z mystring) {
+	x = x + "foo"
+	x = x /* ERROR not defined */ - "foo"
+	x = x + 1 // ERROR cannot convert
+	x = x + y
+	x = x /* ERROR not defined */ - y
+	x = x * 10 // ERROR cannot convert
+}
+
+func f() (a, b int) { return }
+
+func _(x int) {
+	_ = f /* ERROR 2-valued f */ () + 1
+	_ = x + f /* ERROR 2-valued f */ ()
+	_ = f /* ERROR 2-valued f */ () + f
+	_ = f /* ERROR 2-valued f */ () + f /* ERROR 2-valued f */ ()
+}
diff --git a/src/cmd/compile/internal/types2/testdata/expr2.src b/src/cmd/compile/internal/types2/testdata/expr2.src
new file mode 100644
index 0000000000..0c959e8011
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/expr2.src
@@ -0,0 +1,260 @@
+// Copyright 2012 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.
+
+// comparisons
+
+package expr2
+
+func _bool() {
+	const t = true == true
+	const f = true == false
+	_ = t /* ERROR "cannot compare" */ < f
+	_ = 0 /* ERROR "cannot convert" */ == t
+	var b bool
+	var x, y float32
+	b = x < y
+	_ = b
+	_ = struct{b bool}{x < y}
+}
+
+// corner cases
+var (
+	v0 = nil /* ERROR "cannot compare" */ == nil
+)
+
+func arrays() {
+	// basics
+	var a, b [10]int
+	_ = a == b
+	_ = a != b
+	_ = a /* ERROR < not defined */ < b
+	_ = a == nil /* ERROR cannot convert */
+
+	type C [10]int
+	var c C
+	_ = a == c
+
+	type D [10]int
+	var d D
+	_ = c /* ERROR mismatched types */ == d
+
+	var e [10]func() int
+	_ = e /* ERROR == not defined */ == e
+}
+
+func structs() {
+	// basics
+	var s, t struct {
+		x int
+		a [10]float32
+		_ bool
+	}
+	_ = s == t
+	_ = s != t
+	_ = s /* ERROR < not defined */ < t
+	_ = s == nil /* ERROR cannot convert */
+
+	type S struct {
+		x int
+		a [10]float32
+		_ bool
+	}
+	type T struct {
+		x int
+		a [10]float32
+		_ bool
+	}
+	var ss S
+	var tt T
+	_ = s == ss
+	_ = ss /* ERROR mismatched types */ == tt
+
+	var u struct {
+		x int
+		a [10]map[string]int
+	}
+	_ = u /* ERROR cannot compare */ == u
+}
+
+func pointers() {
+	// nil
+	_ = nil /* ERROR == not defined */ == nil
+	_ = nil /* ERROR != not defined */ != nil
+	_ = nil /* ERROR < not defined */ < nil
+	_ = nil /* ERROR <= not defined */ <= nil
+	_ = nil /* ERROR > not defined */ > nil
+	_ = nil /* ERROR >= not defined */ >= nil
+
+	// basics
+	var p, q *int
+	_ = p == q
+	_ = p != q
+
+	_ = p == nil
+	_ = p != nil
+	_ = nil == q
+	_ = nil != q
+
+	_ = p /* ERROR < not defined */ < q
+	_ = p /* ERROR <= not defined */ <= q
+	_ = p /* ERROR > not defined */ > q
+	_ = p /* ERROR >= not defined */ >= q
+
+	// various element types
+	type (
+		S1 struct{}
+		S2 struct{}
+		P1 *S1
+		P2 *S2
+	)
+	var (
+		ps1 *S1
+		ps2 *S2
+		p1 P1
+		p2 P2
+	)
+	_ = ps1 == ps1
+	_ = ps1 /* ERROR mismatched types */ == ps2
+	_ = ps2 /* ERROR mismatched types */ == ps1
+
+	_ = p1 == p1
+	_ = p1 /* ERROR mismatched types */ == p2
+
+	_ = p1 == ps1
+}
+
+func channels() {
+	// basics
+	var c, d chan int
+	_ = c == d
+	_ = c != d
+	_ = c == nil
+	_ = c /* ERROR < not defined */ < d
+
+	// various element types (named types)
+	type (
+		C1 chan int
+		C1r <-chan int
+		C1s chan<- int
+		C2 chan float32
+	)
+	var (
+		c1 C1
+		c1r C1r
+		c1s C1s
+		c1a chan int
+		c2 C2
+	)
+	_ = c1 == c1
+	_ = c1 /* ERROR mismatched types */ == c1r
+	_ = c1 /* ERROR mismatched types */ == c1s
+	_ = c1r /* ERROR mismatched types */ == c1s
+	_ = c1 == c1a
+	_ = c1a == c1
+	_ = c1 /* ERROR mismatched types */ == c2
+	_ = c1a /* ERROR mismatched types */ == c2
+
+	// various element types (unnamed types)
+	var (
+		d1 chan int
+		d1r <-chan int
+		d1s chan<- int
+		d1a chan<- int
+		d2 chan float32
+	)
+	_ = d1 == d1
+	_ = d1 == d1r
+	_ = d1 == d1s
+	_ = d1r /* ERROR mismatched types */ == d1s
+	_ = d1 == d1a
+	_ = d1a == d1
+	_ = d1 /* ERROR mismatched types */ == d2
+	_ = d1a /* ERROR mismatched types */ == d2
+}
+
+// for interfaces test
+type S1 struct{}
+type S11 struct{}
+type S2 struct{}
+func (*S1) m() int
+func (*S11) m() int
+func (*S11) n()
+func (*S2) m() float32
+
+func interfaces() {
+	// basics
+	var i, j interface{ m() int }
+	_ = i == j
+	_ = i != j
+	_ = i == nil
+	_ = i /* ERROR < not defined */ < j
+
+	// various interfaces
+	var ii interface { m() int; n() }
+	var k interface { m() float32 }
+	_ = i == ii
+	_ = i /* ERROR mismatched types */ == k
+
+	// interfaces vs values
+	var s1 S1
+	var s11 S11
+	var s2 S2
+
+	_ = i == 0 /* ERROR cannot convert */
+	_ = i /* ERROR mismatched types */ == s1
+	_ = i == &s1
+	_ = i == &s11
+
+	_ = i /* ERROR mismatched types */ == s2
+	_ = i /* ERROR mismatched types */ == &s2
+
+	// issue #28164
+	// testcase from issue
+	_ = interface /* ERROR cannot compare */ {}(nil) == []int(nil)
+
+	// related cases
+	var e interface{}
+	var s []int
+	var x int
+	_ = e /* ERROR cannot compare */ == s
+	_ = s /* ERROR cannot compare */ == e
+	_ = e /* ERROR cannot compare */ < x
+	_ = x /* ERROR cannot compare */ < e
+}
+
+func slices() {
+	// basics
+	var s []int
+	_ = s == nil
+	_ = s != nil
+	_ = s /* ERROR < not defined */ < nil
+
+	// slices are not otherwise comparable
+	_ = s /* ERROR == not defined */ == s
+	_ = s /* ERROR < not defined */ < s
+}
+
+func maps() {
+	// basics
+	var m map[string]int
+	_ = m == nil
+	_ = m != nil
+	_ = m /* ERROR < not defined */ < nil
+
+	// maps are not otherwise comparable
+	_ = m /* ERROR == not defined */ == m
+	_ = m /* ERROR < not defined */ < m
+}
+
+func funcs() {
+	// basics
+	var f func(int) float32
+	_ = f == nil
+	_ = f != nil
+	_ = f /* ERROR < not defined */ < nil
+
+	// funcs are not otherwise comparable
+	_ = f /* ERROR == not defined */ == f
+	_ = f /* ERROR < not defined */ < f
+}
diff --git a/src/cmd/compile/internal/types2/testdata/expr3.src b/src/cmd/compile/internal/types2/testdata/expr3.src
new file mode 100644
index 0000000000..63af9fc867
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/expr3.src
@@ -0,0 +1,562 @@
+// Copyright 2012 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 expr3
+
+import "time"
+
+func indexes() {
+	_ = 1 /* ERROR "cannot index" */ [0]
+	_ = indexes /* ERROR "cannot index" */ [0]
+	_ = ( /* ERROR "cannot slice" */ 12 + 3)[1:2]
+
+	var a [10]int
+	_ = a[true /* ERROR "cannot convert" */ ]
+	_ = a["foo" /* ERROR "cannot convert" */ ]
+	_ = a[1.1 /* ERROR "truncated" */ ]
+	_ = a[1.0]
+	_ = a[- /* ERROR "negative" */ 1]
+	_ = a[- /* ERROR "negative" */ 1 :]
+	_ = a[: - /* ERROR "negative" */ 1]
+	_ = a[: /* ERROR "2nd index required" */ : /* ERROR "3rd index required" */ ]
+	_ = a[0: /* ERROR "2nd index required" */ : /* ERROR "3rd index required" */ ]
+	_ = a[0: /* ERROR "2nd index required" */ :10]
+	_ = a[:10:10]
+
+	var a0 int
+	a0 = a[0]
+	_ = a0
+	var a1 int32
+	a1 = a /* ERROR "cannot use .* in assignment" */ [1]
+	_ = a1
+
+	_ = a[9]
+	_ = a[10 /* ERROR "index .* out of bounds" */ ]
+	_ = a[1 /* ERROR "overflows" */ <<100]
+	_ = a[10:]
+	_ = a[:10]
+	_ = a[10:10]
+	_ = a[11 /* ERROR "index .* out of bounds" */ :]
+	_ = a[: 11 /* ERROR "index .* out of bounds" */ ]
+	_ = a[: 1 /* ERROR "overflows" */ <<100]
+	_ = a[:10:10]
+	_ = a[:11 /* ERROR "index .* out of bounds" */ :10]
+	_ = a[:10:11 /* ERROR "index .* out of bounds" */ ]
+	_ = a[10:0:10] /* ERROR "invalid slice indices" */
+	_ = a[0:10:0] /* ERROR "invalid slice indices" */
+	_ = a[10:0:0] /* ERROR "invalid slice indices" */
+	_ = &a /* ERROR "cannot take address" */ [:10]
+
+	pa := &a
+	_ = pa[9]
+	_ = pa[10 /* ERROR "index .* out of bounds" */ ]
+	_ = pa[1 /* ERROR "overflows" */ <<100]
+	_ = pa[10:]
+	_ = pa[:10]
+	_ = pa[10:10]
+	_ = pa[11 /* ERROR "index .* out of bounds" */ :]
+	_ = pa[: 11 /* ERROR "index .* out of bounds" */ ]
+	_ = pa[: 1 /* ERROR "overflows" */ <<100]
+	_ = pa[:10:10]
+	_ = pa[:11 /* ERROR "index .* out of bounds" */ :10]
+	_ = pa[:10:11 /* ERROR "index .* out of bounds" */ ]
+	_ = pa[10:0:10] /* ERROR "invalid slice indices" */
+	_ = pa[0:10:0] /* ERROR "invalid slice indices" */
+	_ = pa[10:0:0] /* ERROR "invalid slice indices" */
+	_ = &pa /* ERROR "cannot take address" */ [:10]
+
+	var b [0]int
+	_ = b[0 /* ERROR "index .* out of bounds" */ ]
+	_ = b[:]
+	_ = b[0:]
+	_ = b[:0]
+	_ = b[0:0]
+	_ = b[0:0:0]
+	_ = b[1 /* ERROR "index .* out of bounds" */ :0:0]
+
+	var s []int
+	_ = s[- /* ERROR "negative" */ 1]
+	_ = s[- /* ERROR "negative" */ 1 :]
+	_ = s[: - /* ERROR "negative" */ 1]
+	_ = s[0]
+	_ = s[1:2]
+	_ = s[2:1] /* ERROR "invalid slice indices" */
+	_ = s[2:]
+	_ = s[: 1 /* ERROR "overflows" */ <<100]
+	_ = s[1 /* ERROR "overflows" */ <<100 :]
+	_ = s[1 /* ERROR "overflows" */ <<100 : 1 /* ERROR "overflows" */ <<100]
+	_ = s[: /* ERROR "2nd index required" */ :  /* ERROR "3rd index required" */ ]
+	_ = s[:10:10]
+	_ = s[10:0:10] /* ERROR "invalid slice indices" */
+	_ = s[0:10:0] /* ERROR "invalid slice indices" */
+	_ = s[10:0:0] /* ERROR "invalid slice indices" */
+	_ = &s /* ERROR "cannot take address" */ [:10]
+
+	var m map[string]int
+	_ = m[0 /* ERROR "cannot convert" */ ]
+	_ = m /* ERROR "cannot slice" */ ["foo" : "bar"]
+	_ = m["foo"]
+	// ok is of type bool
+	type mybool bool
+	var ok mybool
+	_, ok = m["bar"]
+	_ = ok
+
+	var t string
+	_ = t[- /* ERROR "negative" */ 1]
+	_ = t[- /* ERROR "negative" */ 1 :]
+	_ = t[: - /* ERROR "negative" */ 1]
+	_ = t /* ERROR "3-index slice of string" */ [1:2:3]
+	_ = "foo" /* ERROR "3-index slice of string" */ [1:2:3]
+	var t0 byte
+	t0 = t[0]
+	_ = t0
+	var t1 rune
+	t1 = t /* ERROR "cannot use .* in assignment" */ [2]
+	_ = t1
+	_ = ("foo" + "bar")[5]
+	_ = ("foo" + "bar")[6 /* ERROR "index .* out of bounds" */ ]
+
+	const c = "foo"
+	_ = c[- /* ERROR "negative" */ 1]
+	_ = c[- /* ERROR "negative" */ 1 :]
+	_ = c[: - /* ERROR "negative" */ 1]
+	var c0 byte
+	c0 = c[0]
+	_ = c0
+	var c2 float32
+	c2 = c /* ERROR "cannot use .* in assignment" */ [2]
+	_ = c[3 /* ERROR "index .* out of bounds" */ ]
+	_ = ""[0 /* ERROR "index .* out of bounds" */ ]
+	_ = c2
+
+	_ = s[1<<30] // no compile-time error here
+
+	// issue 4913
+	type mystring string
+	var ss string
+	var ms mystring
+	var i, j int
+	ss = "foo"[1:2]
+	ss = "foo"[i:j]
+	ms = "foo" /* ERROR "cannot use .* in assignment" */ [1:2]
+	ms = "foo" /* ERROR "cannot use .* in assignment" */ [i:j]
+	_, _ = ss, ms
+}
+
+type T struct {
+	x int
+	y func()
+}
+
+func (*T) m() {}
+
+func method_expressions() {
+	_ = T.a /* ERROR "no field or method" */
+	_ = T.x /* ERROR "has no method" */
+	_ = T.m /* ERROR "cannot call pointer method m on T" */
+	_ = (*T).m
+
+	var f func(*T) = T.m /* ERROR "cannot call pointer method m on T" */
+	var g func(*T) = (*T).m
+	_, _ = f, g
+
+	_ = T.y /* ERROR "has no method" */
+	_ = (*T).y /* ERROR "has no method" */
+}
+
+func struct_literals() {
+	type T0 struct {
+		a, b, c int
+	}
+
+	type T1 struct {
+		T0
+		a, b int
+		u float64
+		s string
+	}
+
+	// keyed elements
+	_ = T1{}
+	_ = T1{a: 0, 1 /* ERROR "mixture of .* elements" */ }
+	_ = T1{aa /* ERROR "unknown field" */ : 0}
+	_ = T1{1 /* ERROR "invalid field name" */ : 0}
+	_ = T1{a: 0, s: "foo", u: 0, a /* ERROR "duplicate field" */: 10}
+	_ = T1{a: "foo" /* ERROR "cannot convert" */ }
+	_ = T1{c /* ERROR "unknown field" */ : 0}
+	_ = T1{T0: { /* ERROR "missing type" */ }} // struct literal element type may not be elided
+	_ = T1{T0: T0{}}
+	_ = T1{T0 /* ERROR "invalid field name" */ .a: 0}
+
+	// unkeyed elements
+	_ = T0{1, 2, 3}
+	_ = T0{1, b /* ERROR "mixture" */ : 2, 3}
+	_ = T0{1, 2} /* ERROR "too few values" */
+	_ = T0{1, 2, 3, 4  /* ERROR "too many values" */ }
+	_ = T0{1, "foo" /* ERROR "cannot convert" */, 3.4  /* ERROR "truncated" */}
+
+	// invalid type
+	type P *struct{
+		x int
+	}
+	_ = P /* ERROR "invalid composite literal type" */ {}
+
+	// unexported fields
+	_ = time.Time{}
+	_ = time.Time{sec /* ERROR "unknown field" */ : 0}
+	_ = time.Time{
+		0 /* ERROR implicit assignment to unexported field wall in time.Time literal */,
+		0 /* ERROR implicit assignment */ ,
+		nil /* ERROR implicit assignment */ ,
+	}
+}
+
+func array_literals() {
+	type A0 [0]int
+	_ = A0{}
+	_ = A0{0 /* ERROR "index .* out of bounds" */}
+	_ = A0{0 /* ERROR "index .* out of bounds" */ : 0}
+
+	type A1 [10]int
+	_ = A1{}
+	_ = A1{0, 1, 2}
+	_ = A1{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
+	_ = A1{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 /* ERROR "index .* out of bounds" */ }
+	_ = A1{- /* ERROR "negative" */ 1: 0}
+	_ = A1{8: 8, 9}
+	_ = A1{8: 8, 9, 10 /* ERROR "index .* out of bounds" */ }
+	_ = A1{0, 1, 2, 0 /* ERROR "duplicate index" */ : 0, 3: 3, 4}
+	_ = A1{5: 5, 6, 7, 3: 3, 4}
+	_ = A1{5: 5, 6, 7, 3: 3, 4, 5 /* ERROR "duplicate index" */ }
+	_ = A1{10 /* ERROR "index .* out of bounds" */ : 10, 10 /* ERROR "index .* out of bounds" */ : 10}
+	_ = A1{5: 5, 6, 7, 3: 3, 1 /* ERROR "overflows" */ <<100: 4, 5 /* ERROR "duplicate index" */ }
+	_ = A1{5: 5, 6, 7, 4: 4, 1 /* ERROR "overflows" */ <<100: 4}
+	_ = A1{2.0}
+	_ = A1{2.1 /* ERROR "truncated" */ }
+	_ = A1{"foo" /* ERROR "cannot convert" */ }
+
+	// indices must be integer constants
+	i := 1
+	const f = 2.1
+	const s = "foo"
+	_ = A1{i /* ERROR "index i must be integer constant" */ : 0}
+	_ = A1{f /* ERROR "truncated" */ : 0}
+	_ = A1{s /* ERROR "cannot convert" */ : 0}
+
+	a0 := [...]int{}
+	assert(len(a0) == 0)
+
+	a1 := [...]int{0, 1, 2}
+	assert(len(a1) == 3)
+	var a13 [3]int
+	var a14 [4]int
+	a13 = a1
+	a14 = a1 /* ERROR "cannot use .* in assignment" */
+	_, _ = a13, a14
+
+	a2 := [...]int{- /* ERROR "negative" */ 1: 0}
+	_ = a2
+
+	a3 := [...]int{0, 1, 2, 0 /* ERROR "duplicate index" */ : 0, 3: 3, 4}
+	assert(len(a3) == 5) // somewhat arbitrary
+
+	a4 := [...]complex128{0, 1, 2, 1<<10-2: -1i, 1i, 400: 10, 12, 14}
+	assert(len(a4) == 1024)
+
+	// composite literal element types may be elided
+	type T []int
+	_ = [10]T{T{}, {}, 5: T{1, 2, 3}, 7: {1, 2, 3}}
+	a6 := [...]T{T{}, {}, 5: T{1, 2, 3}, 7: {1, 2, 3}}
+	assert(len(a6) == 8)
+
+	// recursively so
+	_ = [10][10]T{{}, [10]T{{}}, {{1, 2, 3}}}
+
+	// from the spec
+	type Point struct { x, y float32 }
+	_ = [...]Point{Point{1.5, -3.5}, Point{0, 0}}
+	_ = [...]Point{{1.5, -3.5}, {0, 0}}
+	_ = [][]int{[]int{1, 2, 3}, []int{4, 5}}
+	_ = [][]int{{1, 2, 3}, {4, 5}}
+	_ = [...]*Point{&Point{1.5, -3.5}, &Point{0, 0}}
+	_ = [...]*Point{{1.5, -3.5}, {0, 0}}
+}
+
+func slice_literals() {
+	type S0 []int
+	_ = S0{}
+	_ = S0{0, 1, 2}
+	_ = S0{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
+	_ = S0{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+	_ = S0{- /* ERROR "negative" */ 1: 0}
+	_ = S0{8: 8, 9}
+	_ = S0{8: 8, 9, 10}
+	_ = S0{0, 1, 2, 0 /* ERROR "duplicate index" */ : 0, 3: 3, 4}
+	_ = S0{5: 5, 6, 7, 3: 3, 4}
+	_ = S0{5: 5, 6, 7, 3: 3, 4, 5 /* ERROR "duplicate index" */ }
+	_ = S0{10: 10, 10 /* ERROR "duplicate index" */ : 10}
+	_ = S0{5: 5, 6, 7, 3: 3, 1 /* ERROR "overflows" */ <<100: 4, 5 /* ERROR "duplicate index" */ }
+	_ = S0{5: 5, 6, 7, 4: 4, 1 /* ERROR "overflows" */ <<100: 4}
+	_ = S0{2.0}
+	_ = S0{2.1 /* ERROR "truncated" */ }
+	_ = S0{"foo" /* ERROR "cannot convert" */ }
+
+	// indices must be resolved correctly
+	const index1 = 1
+	_ = S0{index1: 1}
+	_ = S0{index2: 2}
+	_ = S0{index3 /* ERROR "undeclared name" */ : 3}
+
+	// indices must be integer constants
+	i := 1
+	const f = 2.1
+	const s = "foo"
+	_ = S0{i /* ERROR "index i must be integer constant" */ : 0}
+	_ = S0{f /* ERROR "truncated" */ : 0}
+	_ = S0{s /* ERROR "cannot convert" */ : 0}
+
+	// composite literal element types may be elided
+	type T []int
+	_ = []T{T{}, {}, 5: T{1, 2, 3}, 7: {1, 2, 3}}
+	_ = [][]int{{1, 2, 3}, {4, 5}}
+
+	// recursively so
+	_ = [][]T{{}, []T{{}}, {{1, 2, 3}}}
+
+	// issue 17954
+	type T0 *struct { s string }
+	_ = []T0{{}}
+	_ = []T0{{"foo"}}
+
+	type T1 *struct{ int }
+	_ = []T1{}
+	_ = []T1{{0}, {1}, {2}}
+
+	type T2 T1
+	_ = []T2{}
+	_ = []T2{{0}, {1}, {2}}
+
+	_ = map[T0]T2{}
+	_ = map[T0]T2{{}: {}}
+}
+
+const index2 int = 2
+
+type N int
+func (N) f() {}
+
+func map_literals() {
+	type M0 map[string]int
+	type M1 map[bool]int
+	type M2 map[*int]int
+
+	_ = M0{}
+	_ = M0{1 /* ERROR "missing key" */ }
+	_ = M0{1 /* ERROR "cannot convert" */ : 2}
+	_ = M0{"foo": "bar" /* ERROR "cannot convert" */ }
+	_ = M0{"foo": 1, "bar": 2, "foo" /* ERROR "duplicate key" */ : 3 }
+
+	_ = map[interface{}]int{2: 1, 2 /* ERROR "duplicate key" */ : 1}
+	_ = map[interface{}]int{int(2): 1, int16(2): 1}
+	_ = map[interface{}]int{int16(2): 1, int16 /* ERROR "duplicate key" */ (2): 1}
+
+	type S string
+
+	_ = map[interface{}]int{"a": 1, "a" /* ERROR "duplicate key" */ : 1}
+	_ = map[interface{}]int{"a": 1, S("a"): 1}
+	_ = map[interface{}]int{S("a"): 1, S /* ERROR "duplicate key" */ ("a"): 1}
+	_ = map[interface{}]int{1.0: 1, 1.0 /* ERROR "duplicate key" */: 1}
+	_ = map[interface{}]int{int64(-1): 1, int64 /* ERROR "duplicate key" */ (-1) : 1}
+	_ = map[interface{}]int{^uint64(0): 1, ^ /* ERROR "duplicate key" */ uint64(0): 1}
+	_ = map[interface{}]int{complex(1,2): 1, complex /* ERROR "duplicate key" */ (1,2) : 1}
+
+	type I interface {
+		f()
+	}
+
+	_ = map[I]int{N(0): 1, N(2): 1}
+	_ = map[I]int{N(2): 1, N /* ERROR "duplicate key" */ (2): 1}
+
+	// map keys must be resolved correctly
+	key1 := "foo"
+	_ = M0{key1: 1}
+	_ = M0{key2: 2}
+	_ = M0{key3 /* ERROR "undeclared name" */ : 2}
+
+	var value int
+	_ = M1{true: 1, false: 0}
+	_ = M2{nil: 0, &value: 1}
+
+	// composite literal element types may be elided
+	type T [2]int
+	_ = map[int]T{0: T{3, 4}, 1: {5, 6}}
+
+	// recursively so
+	_ = map[int][]T{0: {}, 1: {{}, T{1, 2}}}
+
+	// composite literal key types may be elided
+	_ = map[T]int{T{3, 4}: 0, {5, 6}: 1}
+
+	// recursively so
+	_ = map[[2]T]int{{}: 0, {{}}: 1, [2]T{{}}: 2, {T{1, 2}}: 3}
+
+	// composite literal element and key types may be elided
+	_ = map[T]T{{}: {}, {1, 2}: T{3, 4}, T{4, 5}: {}}
+	_ = map[T]M0{{} : {}, T{1, 2}: M0{"foo": 0}, {1, 3}: {"foo": 1}}
+
+	// recursively so
+	_ = map[[2]T][]T{{}: {}, {{}}: {{}, T{1, 2}}, [2]T{{}}: nil, {T{1, 2}}: {{}, {}}}
+
+	// from the spec
+	type Point struct { x, y float32 }
+	_ = map[string]Point{"orig": {0, 0}}
+	_ = map[*Point]string{{0, 0}: "orig"}
+
+	// issue 17954
+	type T0 *struct{ s string }
+	type T1 *struct{ int }
+	type T2 T1
+
+	_ = map[T0]T2{}
+	_ = map[T0]T2{{}: {}}
+}
+
+var key2 string = "bar"
+
+type I interface {
+	m()
+}
+
+type I2 interface {
+	m(int)
+}
+
+type T1 struct{}
+type T2 struct{}
+
+func (T2) m(int) {}
+
+type mybool bool
+
+func type_asserts() {
+	var x int
+	_ = x /* ERROR "not an interface" */ .(int)
+
+	var e interface{}
+	var ok bool
+	x, ok = e.(int)
+	_ = ok
+
+	// ok value is of type bool
+	var myok mybool
+	_, myok = e.(int)
+	_ = myok
+
+	var t I
+	_ = t /* ERROR "use of .* outside type switch" */ .(type)
+	_ = t /* ERROR "missing method m" */ .(T)
+	_ = t.(*T)
+	_ = t /* ERROR "missing method m" */ .(T1)
+	_ = t /* ERROR "wrong type for method m" */ .(T2)
+	_ = t /* STRICT "wrong type for method m" */ .(I2) // only an error in strict mode (issue 8561)
+
+	// e doesn't statically have an m, but may have one dynamically.
+	_ = e.(I2)
+}
+
+func f0() {}
+func f1(x int) {}
+func f2(u float32, s string) {}
+func fs(s []byte) {}
+func fv(x ...int) {}
+func fi(x ... interface{}) {}
+func (T) fm(x ...int)
+
+func g0() {}
+func g1() int { return 0}
+func g2() (u float32, s string) { return }
+func gs() []byte { return nil }
+
+func _calls() {
+	var x int
+	var y float32
+	var s []int
+
+	f0()
+	_ = f0 /* ERROR "used as value" */ ()
+	f0(g0 /* ERROR "too many arguments" */ )
+
+	f1(0)
+	f1(x)
+	f1(10.0)
+	f1() /* ERROR "too few arguments" */
+	f1(x, y /* ERROR "too many arguments" */ )
+	f1(s /* ERROR "cannot use .* in argument" */ )
+	f1(x ... /* ERROR "cannot use ..." */ )
+	f1(g0 /* ERROR "used as value" */ ())
+	f1(g1())
+	f1(g2 /* ERROR "cannot use g2" */ /* ERROR "too many arguments" */ ())
+
+	f2() /* ERROR "too few arguments" */
+	f2(3.14) /* ERROR "too few arguments" */
+	f2(3.14, "foo")
+	f2(x /* ERROR "cannot use .* in argument" */ , "foo")
+	f2(g0 /* ERROR "used as value" */ ())
+	f2(g1 /* ERROR "cannot use .* in argument" */ ()) /* ERROR "too few arguments" */
+	f2(g2())
+
+	fs() /* ERROR "too few arguments" */
+	fs(g0 /* ERROR "used as value" */ ())
+	fs(g1 /* ERROR "cannot use .* in argument" */ ())
+	fs(g2 /* ERROR "cannot use .* in argument" */ /* ERROR "too many arguments" */ ())
+	fs(gs())
+
+	fv()
+	fv(1, 2.0, x)
+	fv(s /* ERROR "cannot use .* in argument" */ )
+	fv(s...)
+	fv(x /* ERROR "cannot use" */ ...)
+	fv(1, s... /* ERROR "can only use ... with matching parameter" */ )
+	fv(gs /* ERROR "cannot use .* in argument" */ ())
+	fv(gs /* ERROR "cannot use .* in argument" */ ()...)
+
+	var t T
+	t.fm()
+	t.fm(1, 2.0, x)
+	t.fm(s /* ERROR "cannot use .* in argument" */ )
+	t.fm(g1())
+	t.fm(1, s... /* ERROR "can only use ... with matching parameter" */ )
+	t.fm(gs /* ERROR "cannot use .* in argument" */ ())
+	t.fm(gs /* ERROR "cannot use .* in argument" */ ()...)
+
+	T.fm(t, )
+	T.fm(t, 1, 2.0, x)
+	T.fm(t, s /* ERROR "cannot use .* in argument" */ )
+	T.fm(t, g1())
+	T.fm(t, 1, s... /* ERROR "can only use ... with matching parameter" */ )
+	T.fm(t, gs /* ERROR "cannot use .* in argument" */ ())
+	T.fm(t, gs /* ERROR "cannot use .* in argument" */ ()...)
+
+	var i interface{ fm(x ...int) } = t
+	i.fm()
+	i.fm(1, 2.0, x)
+	i.fm(s /* ERROR "cannot use .* in argument" */ )
+	i.fm(g1())
+	i.fm(1, s... /* ERROR "can only use ... with matching parameter" */ )
+	i.fm(gs /* ERROR "cannot use .* in argument" */ ())
+	i.fm(gs /* ERROR "cannot use .* in argument" */ ()...)
+
+	fi()
+	fi(1, 2.0, x, 3.14, "foo")
+	fi(g2())
+	fi(0, g2)
+	fi(0, g2 /* ERROR "2-valued g2" */ ())
+}
+
+func issue6344() {
+	type T []interface{}
+	var x T
+	fi(x...) // ... applies also to named slices
+}
diff --git a/src/cmd/compile/internal/types2/testdata/gotos.src b/src/cmd/compile/internal/types2/testdata/gotos.src
new file mode 100644
index 0000000000..069a94bbbf
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/gotos.src
@@ -0,0 +1,560 @@
+// Copyright 2011 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.
+
+// This file is a modified copy of $GOROOT/test/goto.go.
+
+package gotos
+
+var (
+	i, n int
+	x    []int
+	c    chan int
+	m    map[int]int
+	s    string
+)
+
+// goto after declaration okay
+func _() {
+	x := 1
+	goto L
+L:
+	_ = x
+}
+
+// goto before declaration okay
+func _() {
+	goto L
+L:
+	x := 1
+	_ = x
+}
+
+// goto across declaration not okay
+func _() {
+	goto L /* ERROR "goto L jumps over variable declaration at line 36" */
+	x := 1
+	_ = x
+L:
+}
+
+// goto across declaration in inner scope okay
+func _() {
+	goto L
+	{
+		x := 1
+		_ = x
+	}
+L:
+}
+
+// goto across declaration after inner scope not okay
+func _() {
+	goto L /* ERROR "goto L jumps over variable declaration at line 58" */
+	{
+		x := 1
+		_ = x
+	}
+	x := 1
+	_ = x
+L:
+}
+
+// goto across declaration in reverse okay
+func _() {
+L:
+	x := 1
+	_ = x
+	goto L
+}
+
+func _() {
+L: L1:
+	x := 1
+	_ = x
+	goto L
+	goto L1
+}
+
+// error shows first offending variable
+func _() {
+	goto L /* ERROR "goto L jumps over variable declaration at line 84" */
+	x := 1
+	_ = x
+	y := 1
+	_ = y
+L:
+}
+
+// goto not okay even if code path is dead
+func _() {
+	goto L /* ERROR "goto L jumps over variable declaration" */
+	x := 1
+	_ = x
+	y := 1
+	_ = y
+	return
+L:
+}
+
+// goto into outer block okay
+func _() {
+	{
+		goto L
+	}
+L:
+}
+
+func _() {
+	{
+		goto L
+		goto L1
+	}
+L: L1:
+}
+
+// goto backward into outer block okay
+func _() {
+L:
+	{
+		goto L
+	}
+}
+
+func _() {
+L: L1:
+	{
+		goto L
+		goto L1
+	}
+}
+
+// goto into inner block not okay
+func _() {
+	goto L /* ERROR "goto L jumps into block" */
+	{
+	L:
+	}
+}
+
+func _() {
+	goto L /* ERROR "goto L jumps into block" */
+	goto L1 /* ERROR "goto L1 jumps into block" */
+	{
+	L: L1:
+	}
+}
+
+// goto backward into inner block still not okay
+func _() {
+	{
+	L:
+	}
+	goto L /* ERROR "goto L jumps into block" */
+}
+
+func _() {
+	{
+	L: L1:
+	}
+	goto L /* ERROR "goto L jumps into block" */
+	goto L1 /* ERROR "goto L1 jumps into block" */
+}
+
+// error shows first (outermost) offending block
+func _() {
+	goto L /* ERROR "goto L jumps into block" */
+	{
+		{
+			{
+			L:
+			}
+		}
+	}
+}
+
+// error prefers block diagnostic over declaration diagnostic
+func _() {
+	goto L /* ERROR "goto L jumps into block" */
+	x := 1
+	_ = x
+	{
+	L:
+	}
+}
+
+// many kinds of blocks, all invalid to jump into or among,
+// but valid to jump out of
+
+// if
+
+func _() {
+L:
+	if true {
+		goto L
+	}
+}
+
+func _() {
+L:
+	if true {
+		goto L
+	} else {
+	}
+}
+
+func _() {
+L:
+	if false {
+	} else {
+		goto L
+	}
+}
+
+func _() {
+	goto L /* ERROR "goto L jumps into block" */
+	if true {
+	L:
+	}
+}
+
+func _() {
+	goto L /* ERROR "goto L jumps into block" */
+	if true {
+	L:
+	} else {
+	}
+}
+
+func _() {
+	goto L /* ERROR "goto L jumps into block" */
+	if true {
+	} else {
+	L:
+	}
+}
+
+func _() {
+	if false {
+	L:
+	} else {
+		goto L /* ERROR "goto L jumps into block" */
+	}
+}
+
+func _() {
+	if true {
+		goto L /* ERROR "goto L jumps into block" */
+	} else {
+	L:
+	}
+}
+
+func _() {
+	if true {
+		goto L /* ERROR "goto L jumps into block" */
+	} else if false {
+	L:
+	}
+}
+
+func _() {
+	if true {
+		goto L /* ERROR "goto L jumps into block" */
+	} else if false {
+	L:
+	} else {
+	}
+}
+
+func _() {
+	if true {
+		goto L /* ERROR "goto L jumps into block" */
+	} else if false {
+	} else {
+	L:
+	}
+}
+
+func _() {
+	if true {
+		goto L /* ERROR "goto L jumps into block" */
+	} else {
+		L:
+	}
+}
+
+func _() {
+	if true {
+		L:
+	} else {
+		goto L /* ERROR "goto L jumps into block" */
+	}
+}
+
+// for
+
+func _() {
+	for {
+		goto L
+	}
+L:
+}
+
+func _() {
+	for {
+		goto L
+	L:
+	}
+}
+
+func _() {
+	for {
+	L:
+	}
+	goto L /* ERROR "goto L jumps into block" */
+}
+
+func _() {
+	for {
+		goto L
+	L1:
+	}
+L:
+	goto L1 /* ERROR "goto L1 jumps into block" */
+}
+
+func _() {
+	for i < n {
+	L:
+	}
+	goto L /* ERROR "goto L jumps into block" */
+}
+
+func _() {
+	for i = 0; i < n; i++ {
+	L:
+	}
+	goto L /* ERROR "goto L jumps into block" */
+}
+
+func _() {
+	for i = range x {
+	L:
+	}
+	goto L /* ERROR "goto L jumps into block" */
+}
+
+func _() {
+	for i = range c {
+	L:
+	}
+	goto L /* ERROR "goto L jumps into block" */
+}
+
+func _() {
+	for i = range m {
+	L:
+	}
+	goto L /* ERROR "goto L jumps into block" */
+}
+
+func _() {
+	for i = range s {
+	L:
+	}
+	goto L /* ERROR "goto L jumps into block" */
+}
+
+// switch
+
+func _() {
+L:
+	switch i {
+	case 0:
+		goto L
+	}
+}
+
+func _() {
+L:
+	switch i {
+	case 0:
+
+	default:
+		goto L
+	}
+}
+
+func _() {
+	switch i {
+	case 0:
+
+	default:
+	L:
+		goto L
+	}
+}
+
+func _() {
+	switch i {
+	case 0:
+
+	default:
+		goto L
+	L:
+	}
+}
+
+func _() {
+	switch i {
+	case 0:
+		goto L
+	L:
+		;
+	default:
+	}
+}
+
+func _() {
+	goto L /* ERROR "goto L jumps into block" */
+	switch i {
+	case 0:
+	L:
+	}
+}
+
+func _() {
+	goto L /* ERROR "goto L jumps into block" */
+	switch i {
+	case 0:
+	L:
+		;
+	default:
+	}
+}
+
+func _() {
+	goto L /* ERROR "goto L jumps into block" */
+	switch i {
+	case 0:
+	default:
+	L:
+	}
+}
+
+func _() {
+	switch i {
+	default:
+		goto L /* ERROR "goto L jumps into block" */
+	case 0:
+	L:
+	}
+}
+
+func _() {
+	switch i {
+	case 0:
+	L:
+		;
+	default:
+		goto L /* ERROR "goto L jumps into block" */
+	}
+}
+
+// select
+// different from switch.  the statement has no implicit block around it.
+
+func _() {
+L:
+	select {
+	case <-c:
+		goto L
+	}
+}
+
+func _() {
+L:
+	select {
+	case c <- 1:
+
+	default:
+		goto L
+	}
+}
+
+func _() {
+	select {
+	case <-c:
+
+	default:
+	L:
+		goto L
+	}
+}
+
+func _() {
+	select {
+	case c <- 1:
+
+	default:
+		goto L
+	L:
+	}
+}
+
+func _() {
+	select {
+	case <-c:
+		goto L
+	L:
+		;
+	default:
+	}
+}
+
+func _() {
+	goto L /* ERROR "goto L jumps into block" */
+	select {
+	case c <- 1:
+	L:
+	}
+}
+
+func _() {
+	goto L /* ERROR "goto L jumps into block" */
+	select {
+	case c <- 1:
+	L:
+		;
+	default:
+	}
+}
+
+func _() {
+	goto L /* ERROR "goto L jumps into block" */
+	select {
+	case <-c:
+	default:
+	L:
+	}
+}
+
+func _() {
+	select {
+	default:
+		goto L /* ERROR "goto L jumps into block" */
+	case <-c:
+	L:
+	}
+}
+
+func _() {
+	select {
+	case <-c:
+	L:
+		;
+	default:
+		goto L /* ERROR "goto L jumps into block" */
+	}
+}
diff --git a/src/cmd/compile/internal/types2/testdata/importC.src b/src/cmd/compile/internal/types2/testdata/importC.src
new file mode 100644
index 0000000000..f55be2d5c5
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/importC.src
@@ -0,0 +1,54 @@
+// Copyright 2015 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 importC
+
+import "C"
+import _ /* ERROR cannot rename import "C" */ "C"
+import foo /* ERROR cannot rename import "C" */ "C"
+import . /* ERROR cannot rename import "C" */ "C"
+
+// Test cases extracted from issue #22090.
+
+import "unsafe"
+
+const _ C.int = 0xff // no error due to invalid constant type
+
+type T struct {
+	Name    string
+	Ordinal int
+}
+
+func _(args []T) {
+	var s string
+	for i, v := range args {
+		cname := C.CString(v.Name)
+		args[i].Ordinal = int(C.sqlite3_bind_parameter_index(s, cname)) // no error due to i not being "used"
+		C.free(unsafe.Pointer(cname))
+	}
+}
+
+type CType C.Type
+
+const _ CType = C.X // no error due to invalid constant type
+const _ = C.X
+
+// Test cases extracted from issue #23712.
+
+func _() {
+	var a [C.ArrayLength]byte
+	_ = a[0] // no index out of bounds error here
+}
+
+// Additional tests to verify fix for #23712.
+
+func _() {
+	var a [C.ArrayLength1]byte
+	_ = 1 / len(a) // no division by zero error here and below
+	_ = 1 / cap(a)
+	_ = uint(unsafe.Sizeof(a)) // must not be negative
+
+	var b [C.ArrayLength2]byte
+	a = b // should be valid
+}
diff --git a/src/cmd/compile/internal/types2/testdata/init0.src b/src/cmd/compile/internal/types2/testdata/init0.src
new file mode 100644
index 0000000000..6e8746afb6
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/init0.src
@@ -0,0 +1,106 @@
+// Copyright 2013 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.
+
+// initialization cycles
+
+package init0
+
+// initialization cycles (we don't know the types)
+const (
+	s0 /* ERROR initialization cycle */ = s0
+
+	x0 /* ERROR initialization cycle */ = y0
+	y0 = x0
+
+	a0 = b0
+	b0 /* ERROR initialization cycle */ = c0
+	c0 = d0
+	d0 = b0
+)
+
+var (
+	s1 /* ERROR initialization cycle */ = s1
+
+	x1 /* ERROR initialization cycle */ = y1
+	y1 = x1
+
+	a1 = b1
+	b1 /* ERROR initialization cycle */ = c1
+	c1 = d1
+	d1 = b1
+)
+
+// initialization cycles (we know the types)
+const (
+	s2 /* ERROR initialization cycle */ int = s2
+
+	x2 /* ERROR initialization cycle */ int = y2
+	y2 = x2
+
+	a2 = b2
+	b2 /* ERROR initialization cycle */ int = c2
+	c2 = d2
+	d2 = b2
+)
+
+var (
+	s3 /* ERROR initialization cycle */ int = s3
+
+	x3 /* ERROR initialization cycle */ int = y3
+	y3 = x3
+
+	a3 = b3
+	b3 /* ERROR initialization cycle */ int = c3
+	c3 = d3
+	d3 = b3
+)
+
+// cycles via struct fields
+
+type S1 struct {
+	f int
+}
+const cx3 S1 /* ERROR invalid constant type */ = S1{cx3.f}
+var vx3 /* ERROR initialization cycle */ S1 = S1{vx3.f}
+
+// cycles via functions
+
+var x4 = x5
+var x5 /* ERROR initialization cycle */ = f1()
+func f1() int { return x5*10 }
+
+var x6, x7 /* ERROR initialization cycle */ = f2()
+var x8 = x7
+func f2() (int, int) { return f3() + f3(), 0 }
+func f3() int { return x8 }
+
+// cycles via function literals
+
+var x9 /* ERROR initialization cycle */ = func() int { return x9 }()
+
+var x10 /* ERROR initialization cycle */ = f4()
+
+func f4() int {
+	_ = func() {
+		_ = x10
+	}
+	return 0
+}
+
+// cycles via method expressions
+
+type T1 struct{}
+
+func (T1) m() bool { _ = x11; return false }
+
+var x11 /* ERROR initialization cycle */ = T1.m(T1{})
+
+// cycles via method values
+
+type T2 struct{}
+
+func (T2) m() bool { _ = x12; return false }
+
+var t1 T2
+var x12 /* ERROR initialization cycle */ = t1.m
diff --git a/src/cmd/compile/internal/types2/testdata/init1.src b/src/cmd/compile/internal/types2/testdata/init1.src
new file mode 100644
index 0000000000..39ca31466b
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/init1.src
@@ -0,0 +1,97 @@
+// Copyright 2013 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.
+
+// initialization cycles
+
+package init1
+
+// issue 6683 (marked as WorkingAsIntended)
+
+type T0 struct{}
+
+func (T0) m() int { return y0 }
+
+var x0 = T0{}
+
+var y0 /* ERROR initialization cycle */ = x0.m()
+
+type T1 struct{}
+
+func (T1) m() int { return y1 }
+
+var x1 interface {
+	m() int
+} = T1{}
+
+var y1 = x1.m() // no cycle reported, x1 is of interface type
+
+// issue 6703 (modified)
+
+var x2 /* ERROR initialization cycle */ = T2.m
+
+var y2 = x2
+
+type T2 struct{}
+
+func (T2) m() int {
+	_ = y2
+	return 0
+}
+
+var x3 /* ERROR initialization cycle */ = T3.m(T3{}) // <<<< added (T3{})
+
+var y3 = x3
+
+type T3 struct{}
+
+func (T3) m() int {
+	_ = y3
+	return 0
+}
+
+var x4 /* ERROR initialization cycle */ = T4{}.m // <<<< added {}
+
+var y4 = x4
+
+type T4 struct{}
+
+func (T4) m() int {
+	_ = y4
+	return 0
+}
+
+var x5 /* ERROR initialization cycle */ = T5{}.m() // <<<< added ()
+
+var y5 = x5
+
+type T5 struct{}
+
+func (T5) m() int {
+	_ = y5
+	return 0
+}
+
+// issue 4847
+// simplified test case
+
+var x6 = f6
+var y6 /* ERROR initialization cycle */ = f6
+func f6() { _ = y6 }
+
+// full test case
+
+type (
+      E int
+      S int
+)
+
+type matcher func(s *S) E
+
+func matchList(s *S) E { return matcher(matchAnyFn)(s) }
+
+var foo = matcher(matchList)
+
+var matchAny /* ERROR initialization cycle */ = matcher(matchList)
+
+func matchAnyFn(s *S) (err E) { return matchAny(s) }
\ No newline at end of file
diff --git a/src/cmd/compile/internal/types2/testdata/init2.src b/src/cmd/compile/internal/types2/testdata/init2.src
new file mode 100644
index 0000000000..614db6c949
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/init2.src
@@ -0,0 +1,139 @@
+// Copyright 2014 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.
+
+// initialization cycles
+
+package init2
+
+// cycles through functions
+
+func f1() int { _ = x1; return 0 }
+var x1 /* ERROR initialization cycle */ = f1
+
+func f2() int { _ = x2; return 0 }
+var x2 /* ERROR initialization cycle */ = f2()
+
+// cycles through method expressions
+
+type T3 int
+func (T3) m() int { _ = x3; return 0 }
+var x3 /* ERROR initialization cycle */ = T3.m
+
+type T4 int
+func (T4) m() int { _ = x4; return 0 }
+var x4 /* ERROR initialization cycle */ = T4.m(0)
+
+type T3p int
+func (*T3p) m() int { _ = x3p; return 0 }
+var x3p /* ERROR initialization cycle */ = (*T3p).m
+
+type T4p int
+func (*T4p) m() int { _ = x4p; return 0 }
+var x4p /* ERROR initialization cycle */ = (*T4p).m(nil)
+
+// cycles through method expressions of embedded methods
+
+type T5 struct { E5 }
+type E5 int
+func (E5) m() int { _ = x5; return 0 }
+var x5 /* ERROR initialization cycle */ = T5.m
+
+type T6 struct { E6 }
+type E6 int
+func (E6) m() int { _ = x6; return 0 }
+var x6 /* ERROR initialization cycle */ = T6.m(T6{0})
+
+type T5p struct { E5p }
+type E5p int
+func (*E5p) m() int { _ = x5p; return 0 }
+var x5p /* ERROR initialization cycle */ = (*T5p).m
+
+type T6p struct { E6p }
+type E6p int
+func (*E6p) m() int { _ = x6p; return 0 }
+var x6p /* ERROR initialization cycle */ = (*T6p).m(nil)
+
+// cycles through method values
+
+type T7 int
+func (T7) m() int { _ = x7; return 0 }
+var x7 /* ERROR initialization cycle */ = T7(0).m
+
+type T8 int
+func (T8) m() int { _ = x8; return 0 }
+var x8 /* ERROR initialization cycle */ = T8(0).m()
+
+type T7p int
+func (*T7p) m() int { _ = x7p; return 0 }
+var x7p /* ERROR initialization cycle */ = new(T7p).m
+
+type T8p int
+func (*T8p) m() int { _ = x8p; return 0 }
+var x8p /* ERROR initialization cycle */ = new(T8p).m()
+
+type T7v int
+func (T7v) m() int { _ = x7v; return 0 }
+var x7var T7v
+var x7v /* ERROR initialization cycle */ = x7var.m
+
+type T8v int
+func (T8v) m() int { _ = x8v; return 0 }
+var x8var T8v
+var x8v /* ERROR initialization cycle */ = x8var.m()
+
+type T7pv int
+func (*T7pv) m() int { _ = x7pv; return 0 }
+var x7pvar *T7pv
+var x7pv /* ERROR initialization cycle */ = x7pvar.m
+
+type T8pv int
+func (*T8pv) m() int { _ = x8pv; return 0 }
+var x8pvar *T8pv
+var x8pv /* ERROR initialization cycle */ = x8pvar.m()
+
+// cycles through method values of embedded methods
+
+type T9 struct { E9 }
+type E9 int
+func (E9) m() int { _ = x9; return 0 }
+var x9 /* ERROR initialization cycle */ = T9{0}.m
+
+type T10 struct { E10 }
+type E10 int
+func (E10) m() int { _ = x10; return 0 }
+var x10 /* ERROR initialization cycle */ = T10{0}.m()
+
+type T9p struct { E9p }
+type E9p int
+func (*E9p) m() int { _ = x9p; return 0 }
+var x9p /* ERROR initialization cycle */ = new(T9p).m
+
+type T10p struct { E10p }
+type E10p int
+func (*E10p) m() int { _ = x10p; return 0 }
+var x10p /* ERROR initialization cycle */ = new(T10p).m()
+
+type T9v struct { E9v }
+type E9v int
+func (E9v) m() int { _ = x9v; return 0 }
+var x9var T9v
+var x9v /* ERROR initialization cycle */ = x9var.m
+
+type T10v struct { E10v }
+type E10v int
+func (E10v) m() int { _ = x10v; return 0 }
+var x10var T10v
+var x10v /* ERROR initialization cycle */ = x10var.m()
+
+type T9pv struct { E9pv }
+type E9pv int
+func (*E9pv) m() int { _ = x9pv; return 0 }
+var x9pvar *T9pv
+var x9pv /* ERROR initialization cycle */ = x9pvar.m
+
+type T10pv struct { E10pv }
+type E10pv int
+func (*E10pv) m() int { _ = x10pv; return 0 }
+var x10pvar *T10pv
+var x10pv /* ERROR initialization cycle */ = x10pvar.m()
diff --git a/src/cmd/compile/internal/types2/testdata/issues.src b/src/cmd/compile/internal/types2/testdata/issues.src
new file mode 100644
index 0000000000..4944f6f618
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/issues.src
@@ -0,0 +1,365 @@
+// Copyright 2014 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 issues
+
+import (
+	"fmt"
+	syn "cmd/compile/internal/syntax"
+	t1 "text/template"
+	t2 "html/template"
+)
+
+func issue7035() {
+	type T struct{ X int }
+	_ = func() {
+		fmt.Println() // must refer to imported fmt rather than the fmt below
+	}
+	fmt := new(T)
+	_ = fmt.X
+}
+
+func issue8066() {
+	const (
+		_ = float32(340282356779733661637539395458142568447)
+		_ = float32(340282356779733661637539395458142568448 /* ERROR cannot convert */ )
+	)
+}
+
+// Check that a missing identifier doesn't lead to a spurious error cascade.
+func issue8799a() {
+	x, ok := missing /* ERROR undeclared */ ()
+	_ = !ok
+	_ = x
+}
+
+func issue8799b(x int, ok bool) {
+	x, ok = missing /* ERROR undeclared */ ()
+	_ = !ok
+	_ = x
+}
+
+func issue9182() {
+	type Point C /* ERROR undeclared */ .Point
+	// no error for composite literal based on unknown type
+	_ = Point{x: 1, y: 2}
+}
+
+func f0() (a []int)         { return }
+func f1() (a []int, b int)  { return }
+func f2() (a, b []int)      { return }
+
+func append_([]int, ...int) {}
+
+func issue9473(a []int, b ...int) {
+	// variadic builtin function
+	_ = append(f0())
+	_ = append(f0(), f0()...)
+	_ = append(f1())
+	_ = append(f2 /* ERROR cannot use .* in argument */ ())
+	_ = append(f2()... /* ERROR cannot use ... */ )
+	_ = append(f0(), f1 /* ERROR 2-valued f1 */ ())
+	_ = append(f0(), f2 /* ERROR 2-valued f2 */ ())
+	_ = append(f0(), f1 /* ERROR 2-valued f1 */ ()...)
+	_ = append(f0(), f2 /* ERROR 2-valued f2 */ ()...)
+
+	// variadic user-defined function
+	append_(f0())
+	append_(f0(), f0()...)
+	append_(f1())
+	append_(f2 /* ERROR cannot use .* in argument */ ())
+	append_(f2()... /* ERROR cannot use ... */ )
+	append_(f0(), f1 /* ERROR 2-valued f1 */ ())
+	append_(f0(), f2 /* ERROR 2-valued f2 */ ())
+	append_(f0(), f1 /* ERROR 2-valued f1 */ ()...)
+	append_(f0(), f2 /* ERROR 2-valued f2 */ ()...)
+}
+
+// Check that embedding a non-interface type in an interface results in a good error message.
+func issue10979() {
+	type _ interface {
+		int /* ERROR int is not an interface */
+	}
+	type T struct{}
+	type _ interface {
+		T /* ERROR T is not an interface */
+	}
+	type _ interface {
+		nosuchtype /* ERROR undeclared name: nosuchtype */
+	}
+	type _ interface {
+		fmt.Nosuchtype /* ERROR Nosuchtype not declared by package fmt */
+	}
+	type _ interface {
+		nosuchpkg /* ERROR undeclared name: nosuchpkg */ .Nosuchtype
+	}
+	type I interface {
+		I.m /* ERROR no field or method m */
+		m()
+	}
+}
+
+// issue11347
+// These should not crash.
+var a1, b1 /* ERROR cycle */ , c1 /* ERROR cycle */ b1 = 0 > 0<<""[""[c1]]>c1
+var a2, b2 /* ERROR cycle */ = 0 /* ERROR cannot initialize */ /* ERROR cannot initialize */ > 0<<""[b2]
+var a3, b3 /* ERROR cycle */ = int /* ERROR cannot initialize */ /* ERROR cannot initialize */ (1<<""[b3])
+
+// issue10260
+// Check that error messages explain reason for interface assignment failures.
+type (
+	I0 interface{}
+	I1 interface{ foo() }
+	I2 interface{ foo(x int) }
+	T0 struct{}
+	T1 struct{}
+	T2 struct{}
+)
+
+func (*T1) foo() {}
+func (*T2) foo(x int) {}
+
+func issue10260() {
+	var (
+		i0 I0
+		i1 I1
+		i2 I2
+		t0 *T0
+		t1 *T1
+		t2 *T2
+	)
+
+	var x I1
+	x = T1 /* ERROR cannot use .*: missing method foo \(foo has pointer receiver\) */ {}
+	_ = x /* ERROR .* cannot have dynamic type T1 \(missing method foo \(foo has pointer receiver\)\) */ .(T1)
+
+	T1{}.foo /* ERROR cannot call pointer method foo on T1 */ ()
+	x.Foo /* ERROR "x.Foo undefined \(type I1 has no field or method Foo, but does have foo\)" */ ()
+
+	_ = i2 /* ERROR i2 .* cannot have dynamic type \*T1 \(wrong type for method foo \(have func\(\), want func\(x int\)\)\) */ .(*T1)
+
+	i1 = i0 /* ERROR cannot use .* missing method foo */
+	i1 = t0 /* ERROR cannot use .* missing method foo */
+	i1 = i2 /* ERROR cannot use .* wrong type for method foo */
+	i1 = t2 /* ERROR cannot use .* wrong type for method foo */
+	i2 = i1 /* ERROR cannot use .* wrong type for method foo */
+	i2 = t1 /* ERROR cannot use .* wrong type for method foo */
+
+	_ = func() I1 { return i0 /* ERROR cannot use .* missing method foo */ }
+	_ = func() I1 { return t0 /* ERROR cannot use .* missing method foo */ }
+	_ = func() I1 { return i2 /* ERROR cannot use .* wrong type for method foo */ }
+	_ = func() I1 { return t2 /* ERROR cannot use .* wrong type for method foo */ }
+	_ = func() I2 { return i1 /* ERROR cannot use .* wrong type for method foo */ }
+	_ = func() I2 { return t1 /* ERROR cannot use .* wrong type for method foo */ }
+
+	// a few more - less exhaustive now
+
+	f := func(I1, I2){}
+	f(i0 /* ERROR cannot use .* missing method foo */ , i1 /* ERROR cannot use .* wrong type for method foo \(have func\(\), want func\(x int\)\) */ )
+
+	_ = [...]I1{i0 /* ERROR cannot use .* missing method foo */ }
+	_ = [...]I1{i2 /* ERROR cannot use .* wrong type for method foo */ }
+	_ = []I1{i0 /* ERROR cannot use .* missing method foo */ }
+	_ = []I1{i2 /* ERROR cannot use .* wrong type for method foo */ }
+	_ = map[int]I1{0: i0 /* ERROR cannot use .* missing method foo */ }
+	_ = map[int]I1{0: i2 /* ERROR cannot use .* wrong type for method foo */ }
+
+	make(chan I1) <- i0 /* ERROR cannot use .* in send: missing method foo */
+	make(chan I1) <- i2 /* ERROR cannot use .* in send: wrong type for method foo */
+}
+
+// Check that constants representable as integers are in integer form
+// before being used in operations that are only defined on integers.
+func issue14229() {
+	// from the issue
+	const _ = int64(-1<<63) % 1e6
+
+	// related
+	const (
+		a int = 3
+		b = 4.0
+		_ = a / b
+		_ = a % b
+		_ = b / a
+		_ = b % a
+	)
+}
+
+// Check that in a n:1 variable declaration with type and initialization
+// expression the type is distributed to all variables of the lhs before
+// the initialization expression assignment is checked.
+func issue15755() {
+	// from issue
+	var i interface{}
+	type b bool
+	var x, y b = i.(b)
+	_ = x == y
+
+	// related: we should see an error since the result of f1 is ([]int, int)
+	var u, v []int = f1 /* ERROR cannot use f1 */ ()
+	_ = u
+	_ = v
+}
+
+// Test that we don't get "declared but not used"
+// errors in the context of invalid/C objects.
+func issue20358() {
+	var F C /* ERROR "undeclared" */ .F
+	var A C /* ERROR "undeclared" */ .A
+	var S C /* ERROR "undeclared" */ .S
+	type T C /* ERROR "undeclared" */ .T
+	type P C /* ERROR "undeclared" */ .P
+
+	// these variables must be "used" even though
+	// the LHS expressions/types below in which
+	// context they are used are unknown/invalid
+	var f, a, s1, s2, s3, t, p int
+
+	_ = F(f)
+	_ = A[a]
+	_ = S[s1:s2:s3]
+	_ = T{t}
+	_ = P{f: p}
+}
+
+// Test that we don't declare lhs variables in short variable
+// declarations before we type-check function literals on the
+// rhs.
+func issue24026() {
+	f := func() int { f(0) /* must refer to outer f */; return 0 }
+	_ = f
+
+	_ = func() {
+		f := func() { _ = f() /* must refer to outer f */ }
+		_ = f
+	}
+
+	// b and c must not be visible inside function literal
+	a := 0
+	a, b, c := func() (int, int, int) {
+		return a, b /* ERROR undeclared */ , c /* ERROR undeclared */
+	}()
+	_, _ = b, c
+}
+
+func f(int) {} // for issue24026
+
+// Test that we don't report a "missing return statement" error
+// (due to incorrect context when type-checking interfaces).
+func issue24140(x interface{}) int {
+        switch x.(type) {
+        case interface{}:
+                return 0
+        default:
+                panic(0)
+        }
+}
+
+// Test that we don't crash when the 'if' condition is missing.
+func issue25438() {
+	if { /* ERROR missing condition */ }
+	if x := 0; /* ERROR missing condition */ { _ = x }
+	if
+	{ /* ERROR missing condition */ }
+}
+
+// Test that we can embed alias type names in interfaces.
+type issue25301 interface {
+	E
+}
+
+type E = interface {
+	m()
+}
+
+// Test case from issue.
+// cmd/compile reports a cycle as well.
+type issue25301b /* ERROR cycle */ = interface {
+	m() interface{ issue25301b }
+}
+
+type issue25301c interface {
+	notE // ERROR struct\{\} is not an interface
+}
+
+type notE = struct{}
+
+// Test that method declarations don't introduce artificial cycles
+// (issue #26124).
+const CC TT = 1
+type TT int
+func (TT) MM() [CC]TT
+
+// Reduced test case from issue #26124.
+const preloadLimit LNumber = 128
+type LNumber float64
+func (LNumber) assertFunction() *LFunction
+type LFunction struct {
+	GFunction LGFunction
+}
+type LGFunction func(*LState)
+type LState struct {
+	reg *registry
+}
+type registry struct {
+	alloc *allocator
+}
+type allocator struct {
+	_ [int(preloadLimit)]int
+}
+
+// Test that we don't crash when type-checking composite literals
+// containing errors in the type.
+var issue27346 = [][n /* ERROR undeclared */ ]int{
+	0: {},
+}
+
+var issue22467 = map[int][... /* ERROR invalid use of ... */ ]int{0: {}}
+
+// Test that invalid use of ... in parameter lists is recognized
+// (issue #28281).
+func issue28281a(int, int, ...int)
+func issue28281b(a, b int, c ...int)
+func issue28281c(a, b, c ... /* ERROR can only use ... with final parameter */ int)
+func issue28281d(... /* ERROR can only use ... with final parameter */ int, int)
+func issue28281e(a, b, c  ... /* ERROR can only use ... with final parameter */ int, d int)
+func issue28281f(... /* ERROR can only use ... with final parameter */ int, ... /* ERROR can only use ... with final parameter */ int, int)
+func (... /* ERROR expected type */ TT) f()
+func issue28281g() (... /* ERROR expected type */ TT)
+
+// Issue #26234: Make various field/method lookup errors easier to read by matching cmd/compile's output
+func issue26234a(f *syn.File) {
+	// The error message below should refer to the actual package name (syntax)
+	// not the local package name (syn).
+	f.foo /* ERROR f.foo undefined \(type \*syntax.File has no field or method foo\) */
+}
+
+type T struct {
+	x int
+	E1
+	E2
+}
+
+type E1 struct{ f int }
+type E2 struct{ f int }
+
+func issue26234b(x T) {
+	_ = x.f /* ERROR ambiguous selector x.f */
+}
+
+func issue26234c() {
+	T.x /* ERROR T.x undefined \(type T has no method x\) */ ()
+}
+
+func issue35895() {
+	// T is defined in this package, don't qualify its name with the package name.
+	var _ T = 0 // ERROR cannot convert 0 \(untyped int constant\) to T
+
+	// There is only one package with name syntax imported, only use the (global) package name in error messages.
+	var _ *syn.File = 0 // ERROR cannot convert 0 \(untyped int constant\) to \*syntax.File
+
+	// Because both t1 and t2 have the same global package name (template),
+	// qualify packages with full path name in this case.
+	var _ t1.Template = t2 /* ERROR cannot use .* \(value of type "html/template".Template\) as "text/template".Template */ .Template{}
+}
diff --git a/src/cmd/compile/internal/types2/testdata/labels.src b/src/cmd/compile/internal/types2/testdata/labels.src
new file mode 100644
index 0000000000..9f42406965
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/labels.src
@@ -0,0 +1,207 @@
+// Copyright 2011 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.
+
+// This file is a modified concatenation of the files
+// $GOROOT/test/label.go and $GOROOT/test/label1.go.
+
+package labels
+
+var x int
+
+func f0() {
+L1 /* ERROR "label L1 declared but not used" */ :
+	for {
+	}
+L2 /* ERROR "label L2 declared but not used" */ :
+	select {
+	}
+L3 /* ERROR "label L3 declared but not used" */ :
+	switch {
+	}
+L4 /* ERROR "label L4 declared but not used" */ :
+	if true {
+	}
+L5 /* ERROR "label L5 declared but not used" */ :
+	f0()
+L6:
+	f0()
+L6 /* ERROR "label L6 already declared" */ :
+	f0()
+	if x == 20 {
+		goto L6
+	}
+
+L7:
+	for {
+		break L7
+		break L8 /* ERROR "invalid break label L8" */
+	}
+
+// A label must be directly associated with a switch, select, or
+// for statement; it cannot be the label of a labeled statement.
+
+L7a /* ERROR "declared but not used" */ : L7b:
+	for {
+		break L7a /* ERROR "invalid break label L7a" */
+		continue L7a /* ERROR "invalid continue label L7a" */
+		continue L7b
+	}
+
+L8:
+	for {
+		if x == 21 {
+			continue L8
+			continue L7 /* ERROR "invalid continue label L7" */
+		}
+	}
+
+L9:
+	switch {
+	case true:
+		break L9
+	defalt /* ERROR "label defalt declared but not used" */ :
+	}
+
+L10:
+	select {
+	default:
+		break L10
+		break L9 /* ERROR "invalid break label L9" */
+	}
+
+	goto L10a
+L10a: L10b:
+	select {
+	default:
+		break L10a /* ERROR "invalid break label L10a" */
+		break L10b
+		continue L10b /* ERROR "invalid continue label L10b" */
+	}
+}
+
+func f1() {
+L1:
+	for {
+		if x == 0 {
+			break L1
+		}
+		if x == 1 {
+			continue L1
+		}
+		goto L1
+	}
+
+L2:
+	select {
+	default:
+		if x == 0 {
+			break L2
+		}
+		if x == 1 {
+			continue L2 /* ERROR "invalid continue label L2" */
+		}
+		goto L2
+	}
+
+L3:
+	switch {
+	case x > 10:
+		if x == 11 {
+			break L3
+		}
+		if x == 12 {
+			continue L3 /* ERROR "invalid continue label L3" */
+		}
+		goto L3
+	}
+
+L4:
+	if true {
+		if x == 13 {
+			break L4 /* ERROR "invalid break label L4" */
+		}
+		if x == 14 {
+			continue L4 /* ERROR "invalid continue label L4" */
+		}
+		if x == 15 {
+			goto L4
+		}
+	}
+
+L5:
+	f1()
+	if x == 16 {
+		break L5 /* ERROR "invalid break label L5" */
+	}
+	if x == 17 {
+		continue L5 /* ERROR "invalid continue label L5" */
+	}
+	if x == 18 {
+		goto L5
+	}
+
+	for {
+		if x == 19 {
+			break L1 /* ERROR "invalid break label L1" */
+		}
+		if x == 20 {
+			continue L1 /* ERROR "invalid continue label L1" */
+		}
+		if x == 21 {
+			goto L1
+		}
+	}
+}
+
+// Additional tests not in the original files.
+
+func f2() {
+L1 /* ERROR "label L1 declared but not used" */ :
+	if x == 0 {
+		for {
+			continue L1 /* ERROR "invalid continue label L1" */
+		}
+	}
+}
+
+func f3() {
+L1:
+L2:
+L3:
+	for {
+		break L1 /* ERROR "invalid break label L1" */
+		break L2 /* ERROR "invalid break label L2" */
+		break L3
+		continue L1 /* ERROR "invalid continue label L1" */
+		continue L2 /* ERROR "invalid continue label L2" */
+		continue L3
+		goto L1
+		goto L2
+		goto L3
+	}
+}
+
+// Blank labels are never declared.
+
+func f4() {
+_:
+_: // multiple blank labels are ok
+	goto _ /* ERROR "label _ not declared" */
+}
+
+func f5() {
+_:
+	for {
+		break _ /* ERROR "invalid break label _" */
+		continue _ /* ERROR "invalid continue label _" */
+	}
+}
+
+func f6() {
+_:
+	switch {
+	default:
+		break _ /* ERROR "invalid break label _" */
+	}
+}
diff --git a/src/cmd/compile/internal/types2/testdata/literals.src b/src/cmd/compile/internal/types2/testdata/literals.src
new file mode 100644
index 0000000000..494a465f48
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/literals.src
@@ -0,0 +1,111 @@
+// Copyright 2019 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.
+
+// This file tests various representations of literals
+// and compares them with literals or constant expressions
+// of equal values.
+
+package literals
+
+func _() {
+	// 0-octals
+	assert(0_123 == 0123)
+	assert(0123_456 == 0123456)
+
+	// decimals
+	assert(1_234 == 1234)
+	assert(1_234_567 == 1234567)
+
+	// hexadecimals
+	assert(0X_0 == 0)
+	assert(0X_1234 == 0x1234)
+	assert(0X_CAFE_f00d == 0xcafef00d)
+
+	// octals
+	assert(0o0 == 0)
+	assert(0o1234 == 01234)
+	assert(0o01234567 == 01234567)
+
+	assert(0O0 == 0)
+	assert(0O1234 == 01234)
+	assert(0O01234567 == 01234567)
+
+	assert(0o_0 == 0)
+	assert(0o_1234 == 01234)
+	assert(0o0123_4567 == 01234567)
+
+	assert(0O_0 == 0)
+	assert(0O_1234 == 01234)
+	assert(0O0123_4567 == 01234567)
+
+	// binaries
+	assert(0b0 == 0)
+	assert(0b1011 == 0xb)
+	assert(0b00101101 == 0x2d)
+
+	assert(0B0 == 0)
+	assert(0B1011 == 0xb)
+	assert(0B00101101 == 0x2d)
+
+	assert(0b_0 == 0)
+	assert(0b10_11 == 0xb)
+	assert(0b_0010_1101 == 0x2d)
+
+	// decimal floats
+	assert(1_2_3. == 123.)
+	assert(0_123. == 123.)
+
+	assert(0_0e0 == 0.)
+	assert(1_2_3e0 == 123.)
+	assert(0_123e0 == 123.)
+
+	assert(0e-0_0 == 0.)
+	assert(1_2_3E+0 == 123.)
+	assert(0123E1_2_3 == 123e123)
+
+	assert(0.e+1 == 0.)
+	assert(123.E-1_0 == 123e-10)
+	assert(01_23.e123 == 123e123)
+
+	assert(.0e-1 == .0)
+	assert(.123E+10 == .123e10)
+	assert(.0123E123 == .0123e123)
+
+	assert(1_2_3.123 == 123.123)
+	assert(0123.01_23 == 123.0123)
+
+	// hexadecimal floats
+	assert(0x0.p+0 == 0.)
+	assert(0Xdeadcafe.p-10 == 0xdeadcafe/1024.0)
+	assert(0x1234.P84 == 0x1234000000000000000000000)
+
+	assert(0x.1p-0 == 1./16)
+	assert(0X.deadcafep4 == 1.0*0xdeadcafe/0x10000000)
+	assert(0x.1234P+12 == 1.0*0x1234/0x10)
+
+	assert(0x0p0 == 0.)
+	assert(0Xdeadcafep+1 == 0x1bd5b95fc)
+	assert(0x1234P-10 == 0x1234/1024.0)
+
+	assert(0x0.0p0 == 0.)
+	assert(0Xdead.cafep+1 == 1.0*0x1bd5b95fc/0x10000)
+	assert(0x12.34P-10 == 1.0*0x1234/0x40000)
+
+	assert(0Xdead_cafep+1 == 0xdeadcafep+1)
+	assert(0x_1234P-10 == 0x1234p-10)
+
+	assert(0X_dead_cafe.p-10 == 0xdeadcafe.p-10)
+	assert(0x12_34.P1_2_3 == 0x1234.p123)
+
+	assert(1_234i == 1234i)
+	assert(1_234_567i == 1234567i)
+
+	assert(0.i == 0i)
+	assert(123.i == 123i)
+	assert(0123.i == 123i)
+
+	assert(0.e+1i == 0i)
+	assert(123.E-1_0i == 123e-10i)
+	assert(01_23.e123i == 123e123i)
+}
diff --git a/src/cmd/compile/internal/types2/testdata/methodsets.src b/src/cmd/compile/internal/types2/testdata/methodsets.src
new file mode 100644
index 0000000000..9fb10deb9a
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/methodsets.src
@@ -0,0 +1,214 @@
+// Copyright 2013 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 methodsets
+
+type T0 struct {}
+
+func (T0) v0() {}
+func (*T0) p0() {}
+
+type T1 struct {} // like T0 with different method names
+
+func (T1) v1() {}
+func (*T1) p1() {}
+
+type T2 interface {
+	v2()
+	p2()
+}
+
+type T3 struct {
+	T0
+	*T1
+	T2
+}
+
+// Method expressions
+func _() {
+	var (
+		_ func(T0) = T0.v0
+		_ = T0.p0 /* ERROR "cannot call pointer method p0 on T0" */
+
+		_ func (*T0) = (*T0).v0
+		_ func (*T0) = (*T0).p0
+
+		// T1 is like T0
+
+		_ func(T2) = T2.v2
+		_ func(T2) = T2.p2
+
+		_ func(T3) = T3.v0
+		_ func(T3) = T3.p0 /* ERROR "cannot call pointer method p0 on T3" */
+		_ func(T3) = T3.v1
+		_ func(T3) = T3.p1
+		_ func(T3) = T3.v2
+		_ func(T3) = T3.p2
+
+		_ func(*T3) = (*T3).v0
+		_ func(*T3) = (*T3).p0
+		_ func(*T3) = (*T3).v1
+		_ func(*T3) = (*T3).p1
+		_ func(*T3) = (*T3).v2
+		_ func(*T3) = (*T3).p2
+	)
+}
+
+// Method values with addressable receivers
+func _() {
+	var (
+		v0 T0
+		_ func() = v0.v0
+		_ func() = v0.p0
+	)
+
+	var (
+		p0 *T0
+		_ func() = p0.v0
+		_ func() = p0.p0
+	)
+
+	// T1 is like T0
+
+	var (
+		v2 T2
+		_ func() = v2.v2
+		_ func() = v2.p2
+	)
+
+	var (
+		v4 T3
+		_ func() = v4.v0
+		_ func() = v4.p0
+		_ func() = v4.v1
+		_ func() = v4.p1
+		_ func() = v4.v2
+		_ func() = v4.p2
+	)
+
+	var (
+		p4 *T3
+		_ func() = p4.v0
+		_ func() = p4.p0
+		_ func() = p4.v1
+		_ func() = p4.p1
+		_ func() = p4.v2
+		_ func() = p4.p2
+	)
+}
+
+// Method calls with addressable receivers
+func _() {
+	var v0 T0
+	v0.v0()
+	v0.p0()
+
+	var p0 *T0
+	p0.v0()
+	p0.p0()
+
+	// T1 is like T0
+
+	var v2 T2
+	v2.v2()
+	v2.p2()
+
+	var v4 T3
+	v4.v0()
+	v4.p0()
+	v4.v1()
+	v4.p1()
+	v4.v2()
+	v4.p2()
+
+	var p4 *T3
+	p4.v0()
+	p4.p0()
+	p4.v1()
+	p4.p1()
+	p4.v2()
+	p4.p2()
+}
+
+// Method values with value receivers
+func _() {
+	var (
+		_ func() = T0{}.v0
+		_ func() = T0{}.p0 /* ERROR "cannot call pointer method p0 on T0" */
+
+		_ func() = (&T0{}).v0
+		_ func() = (&T0{}).p0
+
+		// T1 is like T0
+
+		// no values for T2
+
+		_ func() = T3{}.v0
+		_ func() = T3{}.p0 /* ERROR "cannot call pointer method p0 on T3" */
+		_ func() = T3{}.v1
+		_ func() = T3{}.p1
+		_ func() = T3{}.v2
+		_ func() = T3{}.p2
+
+		_ func() = (&T3{}).v0
+		_ func() = (&T3{}).p0
+		_ func() = (&T3{}).v1
+		_ func() = (&T3{}).p1
+		_ func() = (&T3{}).v2
+		_ func() = (&T3{}).p2
+	)
+}
+
+// Method calls with value receivers
+func _() {
+	T0{}.v0()
+	T0{}.p0 /* ERROR "cannot call pointer method p0 on T0" */ ()
+
+	(&T0{}).v0()
+	(&T0{}).p0()
+
+	// T1 is like T0
+
+	// no values for T2
+
+	T3{}.v0()
+	T3{}.p0 /* ERROR "cannot call pointer method p0 on T3" */ ()
+	T3{}.v1()
+	T3{}.p1()
+	T3{}.v2()
+	T3{}.p2()
+
+	(&T3{}).v0()
+	(&T3{}).p0()
+	(&T3{}).v1()
+	(&T3{}).p1()
+	(&T3{}).v2()
+	(&T3{}).p2()
+}
+
+// *T has no methods if T is an interface type
+func issue5918() {
+	var (
+		err error
+		_ = err.Error()
+		_ func() string = err.Error
+		_ func(error) string = error.Error
+
+		perr = &err
+		_ = perr.Error /* ERROR "no field or method" */ ()
+		_ func() string = perr.Error /* ERROR "no field or method" */
+		_ func(*error) string = (*error).Error /* ERROR "no field or method" */
+	)
+
+	type T *interface{ m() int }
+	var (
+		x T
+		_ = (*x).m()
+		_ = (*x).m
+
+		_ = x.m /* ERROR "no field or method" */ ()
+		_ = x.m /* ERROR "no field or method" */
+		_ = T.m /* ERROR "no field or method" */
+	)
+}
diff --git a/src/cmd/compile/internal/types2/testdata/shifts.src b/src/cmd/compile/internal/types2/testdata/shifts.src
new file mode 100644
index 0000000000..c9a38ae169
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/shifts.src
@@ -0,0 +1,395 @@
+// Copyright 2013 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 shifts
+
+func shifts0() {
+	// basic constant shifts
+	const (
+		s = 10
+		_ = 0<<0
+		_ = 1<<s
+		_ = 1<<- /* ERROR "negative shift count" */ 1
+		// For the test below we may decide to convert to int
+		// rather than uint and then report a negative shift
+		// count instead, which might be a better error. The
+		// (minor) difference is that this would restrict the
+		// shift count range by half (from all uint values to
+		// the positive int values).
+		// This depends on the exact spec wording which is not
+		// done yet.
+		// TODO(gri) revisit and adjust when spec change is done
+		_ = 1<<- /* ERROR "truncated to uint" */ 1.0
+		_ = 1<<1075 /* ERROR "invalid shift" */
+		_ = 2.0<<1
+		_ = 1<<1.0
+		_ = 1<<(1+0i)
+
+		_ int = 2<<s
+		_ float32 = 2<<s
+		_ complex64 = 2<<s
+
+		_ int = 2.0<<s
+		_ float32 = 2.0<<s
+		_ complex64 = 2.0<<s
+
+		_ int = 'a'<<s
+		_ float32 = 'a'<<s
+		_ complex64 = 'a'<<s
+	)
+}
+
+func shifts1() {
+	// basic non-constant shifts
+	var (
+		i int
+		u uint
+
+		_ = 1<<0
+		_ = 1<<i
+		_ = 1<<u
+		_ = 1<<"foo" /* ERROR "cannot convert" */
+		_ = i<<0
+		_ = i<<- /* ERROR "negative shift count" */ 1
+		_ = i<<1.0
+		_ = 1<<(1+0i)
+		_ = 1 /* ERROR "overflows" */ <<100
+
+		_ uint = 1 << 0
+		_ uint = 1 << u
+		_ float32 = 1 /* ERROR "must be integer" */ << u
+
+		// for issue 14822
+		_ = 1<<( /* ERROR "invalid shift count" */ 1<<64-1)
+		_ = 1<<( /* ERROR "invalid shift count" */ 1<<64)
+		_ = u<<(1<<63) // valid
+		_ = u<<(1<<64) // valid
+	)
+}
+
+func shifts2() {
+	// from the spec
+	var (
+		s uint = 33
+		i = 1<<s           // 1 has type int
+		j int32 = 1<<s     // 1 has type int32; j == 0
+		k = uint64(1<<s)   // 1 has type uint64; k == 1<<33
+		m int = 1.0<<s     // 1.0 has type int
+		n = 1.0<<s != i    // 1.0 has type int; n == false if ints are 32bits in size
+		o = 1<<s == 2<<s   // 1 and 2 have type int; o == true if ints are 32bits in size
+		p = 1<<s == 1<<33  // illegal if ints are 32bits in size: 1 has type int, but 1<<33 overflows int
+		u = 1.0 /* ERROR "must be integer" */ <<s         // illegal: 1.0 has type float64, cannot shift
+		u1 = 1.0 /* ERROR "must be integer" */ <<s != 0   // illegal: 1.0 has type float64, cannot shift
+		u2 = 1 /* ERROR "must be integer" */ <<s != 1.0   // illegal: 1 has type float64, cannot shift
+		v float32 = 1 /* ERROR "must be integer" */ <<s   // illegal: 1 has type float32, cannot shift
+		w int64 = 1.0<<33  // 1.0<<33 is a constant shift expression
+	)
+	_, _, _, _, _, _, _, _, _, _, _, _ = i, j, k, m, n, o, p, u, u1, u2, v, w
+}
+
+func shifts3(a int16, b float32) {
+	// random tests
+	var (
+		s uint = 11
+		u = 1 /* ERROR "must be integer" */ <<s + 1.0
+		v complex128 = 1 /* ERROR "must be integer" */ << s + 1.0 /* ERROR "must be integer" */ << s + 1
+	)
+	x := 1.0 /* ERROR "must be integer" */ <<s + 1
+	shifts3(1.0 << s, 1 /* ERROR "must be integer" */ >> s)
+	_, _, _ = u, v, x
+}
+
+func shifts4() {
+	// shifts in comparisons w/ untyped operands
+	var s uint
+
+	_ = 1<<s == 1
+	_ = 1 /* ERROR "integer" */ <<s == 1.
+	_ = 1. /* ERROR "integer" */ <<s == 1
+	_ = 1. /* ERROR "integer" */ <<s == 1.
+
+	_ = 1<<s + 1 == 1
+	_ = 1 /* ERROR "integer" */ <<s + 1 == 1.
+	_ = 1 /* ERROR "integer" */ <<s + 1. == 1
+	_ = 1 /* ERROR "integer" */ <<s + 1. == 1.
+	_ = 1. /* ERROR "integer" */ <<s + 1 == 1
+	_ = 1. /* ERROR "integer" */ <<s + 1 == 1.
+	_ = 1. /* ERROR "integer" */ <<s + 1. == 1
+	_ = 1. /* ERROR "integer" */ <<s + 1. == 1.
+
+	_ = 1<<s == 1<<s
+	_ = 1 /* ERROR "integer" */ <<s == 1. /* ERROR "integer" */ <<s
+	_ = 1. /* ERROR "integer" */ <<s == 1 /* ERROR "integer" */ <<s
+	_ = 1. /* ERROR "integer" */ <<s == 1. /* ERROR "integer" */ <<s
+
+	_ = 1<<s + 1<<s == 1
+	_ = 1 /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s == 1.
+	_ = 1 /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s == 1
+	_ = 1 /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s == 1.
+	_ = 1. /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s == 1
+	_ = 1. /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s == 1.
+	_ = 1. /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s == 1
+	_ = 1. /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s == 1.
+
+	_ = 1<<s + 1<<s == 1<<s + 1<<s
+	_ = 1 /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s == 1 /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s
+	_ = 1 /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s == 1. /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s
+	_ = 1 /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s == 1. /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s
+	_ = 1 /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s == 1 /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s
+	_ = 1 /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s == 1 /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s
+	_ = 1 /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s == 1. /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s
+	_ = 1 /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s == 1. /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s
+	_ = 1. /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s == 1 /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s
+	_ = 1. /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s == 1 /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s
+	_ = 1. /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s == 1. /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s
+	_ = 1. /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s == 1. /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s
+	_ = 1. /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s == 1 /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s
+	_ = 1. /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s == 1 /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s
+	_ = 1. /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s == 1. /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s
+	_ = 1. /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s == 1. /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s
+}
+
+func shifts5() {
+	// shifts in comparisons w/ typed operands
+	var s uint
+	var x int
+
+	_ = 1<<s == x
+	_ = 1.<<s == x
+	_ = 1.1 /* ERROR "int" */ <<s == x
+
+	_ = 1<<s + x == 1
+	_ = 1<<s + x == 1.
+	_ = 1<<s + x == 1.1 /* ERROR "int" */
+	_ = 1.<<s + x == 1
+	_ = 1.<<s + x == 1.
+	_ = 1.<<s + x == 1.1 /* ERROR "int" */
+	_ = 1.1 /* ERROR "int" */ <<s + x == 1
+	_ = 1.1 /* ERROR "int" */ <<s + x == 1.
+	_ = 1.1 /* ERROR "int" */ <<s + x == 1.1
+
+	_ = 1<<s == x<<s
+	_ = 1.<<s == x<<s
+	_ = 1.1  /* ERROR "int" */ <<s == x<<s
+}
+
+func shifts6() {
+	// shifts as operands in non-arithmetic operations and as arguments
+	var a [10]int
+	var s uint
+
+	_ = a[1<<s]
+	_ = a[1.0]
+	_ = a[1.0<<s]
+
+	_ = make([]int, 1.0)
+	_ = make([]int, 1.0<<s)
+	_ = make([]int, 1.1 /* ERROR "must be integer" */ <<s)
+
+	_ = float32(1)
+	_ = float32(1 /* ERROR "must be integer" */ <<s)
+	_ = float32(1.0)
+	_ = float32(1.0 /* ERROR "must be integer" */ <<s)
+	_ = float32(1.1 /* ERROR "must be integer" */ <<s)
+
+	_ = int32(0x80000000 /* ERROR "overflows int32" */ << s)
+	// TODO(rfindley) Eliminate the redundant error here.
+	_ = int32(( /* ERROR "truncated to int32" */ 0x80000000 /* ERROR "truncated to int32" */ + 0i) << s)
+
+	_ = int(1+0i<<0)
+	_ = int((1+0i)<<s)
+	_ = int(1.0<<s)
+	_ = int(complex(1, 0)<<s)
+	_ = int(float32/* ERROR "must be integer" */(1.0) <<s)
+	_ = int(1.1 /* ERROR must be integer */ <<s)
+	_ = int(( /* ERROR "must be integer" */ 1+1i)  <<s)
+
+	_ = complex(1 /* ERROR "must be integer" */ <<s, 0)
+
+	var b []int
+	_ = append(b, 1<<s)
+	_ = append(b, 1.0<<s)
+	_ = append(b, (1+0i)<<s)
+	_ = append(b, 1.1 /* ERROR "must be integer" */ <<s)
+	_ = append(b, (1 + 0i) <<s)
+	_ = append(b, ( /* ERROR "must be integer" */ 1 + 1i)  <<s)
+
+	_ = complex(1.0 /* ERROR "must be integer" */ <<s, 0)
+	_ = complex(1.1 /* ERROR "must be integer" */ <<s, 0)
+	_ = complex(0, 1.0 /* ERROR "must be integer" */ <<s)
+	_ = complex(0, 1.1 /* ERROR "must be integer" */ <<s)
+
+	// TODO(gri) The delete below is not type-checked correctly yet.
+	// var m1 map[int]string
+	// delete(m1, 1<<s)
+}
+
+func shifts7() {
+	// shifts of shifts
+	var s uint
+	var x int
+	_ = x
+
+	_ = 1<<(1<<s)
+	_ = 1<<(1.<<s)
+	_ = 1. /* ERROR "integer" */ <<(1<<s)
+	_ = 1. /* ERROR "integer" */ <<(1.<<s)
+
+	x = 1<<(1<<s)
+	x = 1<<(1.<<s)
+	x = 1.<<(1<<s)
+	x = 1.<<(1.<<s)
+
+	_ = (1<<s)<<(1<<s)
+	_ = (1<<s)<<(1.<<s)
+	_ = ( /* ERROR "integer" */ 1.<<s)<<(1<<s)
+	_ = ( /* ERROR "integer" */ 1.<<s)<<(1.<<s)
+
+	x = (1<<s)<<(1<<s)
+	x = (1<<s)<<(1.<<s)
+	x = ( /* ERROR "integer" */ 1.<<s)<<(1<<s)
+	x = ( /* ERROR "integer" */ 1.<<s)<<(1.<<s)
+}
+
+func shifts8() {
+	// shift examples from shift discussion: better error messages
+	var s uint
+	_ = 1.0 /* ERROR "shifted operand 1.0 \(type float64\) must be integer" */ <<s == 1
+	_ = 1.0 /* ERROR "shifted operand 1.0 \(type float64\) must be integer" */ <<s == 1.0
+	_ = 1 /* ERROR "shifted operand 1 \(type float64\) must be integer" */ <<s == 1.0
+	_ = 1 /* ERROR "shifted operand 1 \(type float64\) must be integer" */ <<s + 1.0 == 1
+	_ = 1 /* ERROR "shifted operand 1 \(type float64\) must be integer" */ <<s + 1.1 == 1
+	_ = 1 /* ERROR "shifted operand 1 \(type float64\) must be integer" */ <<s + 1 == 1.0
+
+	// additional cases
+	_ = complex(1.0 /* ERROR "shifted operand 1.0 \(type float64\) must be integer" */ <<s, 1)
+	_ = complex(1.0, 1 /* ERROR "shifted operand 1 \(type float64\) must be integer" */ <<s)
+
+	_ = int(1.<<s)
+	_ = int(1.1 /* ERROR "shifted operand .* must be integer" */ <<s)
+	_ = float32(1 /* ERROR "shifted operand .* must be integer" */ <<s)
+	_ = float32(1. /* ERROR "shifted operand .* must be integer" */ <<s)
+	_ = float32(1.1 /* ERROR "shifted operand .* must be integer" */ <<s)
+	// TODO(gri) the error messages for these two are incorrect - disabled for now
+	// _ = complex64(1<<s)
+	// _ = complex64(1.<<s)
+	_ = complex64(1.1 /* ERROR "shifted operand .* must be integer" */ <<s)
+}
+
+func shifts9() {
+	// various originally failing snippets of code from the std library
+	// from src/compress/lzw/reader.go:90
+	{
+		var d struct {
+			bits     uint32
+			width    uint
+		}
+		_ = uint16(d.bits & (1<<d.width - 1))
+	}
+
+	// from src/debug/dwarf/buf.go:116
+	{
+		var ux uint64
+		var bits uint
+		x := int64(ux)
+		if x&(1<<(bits-1)) != 0 {}
+	}
+
+	// from src/encoding/asn1/asn1.go:160
+	{
+		var bytes []byte
+		if bytes[len(bytes)-1]&((1<<bytes[0])-1) != 0 {}
+	}
+
+	// from src/math/big/rat.go:140
+	{
+		var exp int
+		var mantissa uint64
+		shift := uint64(-1022 - (exp - 1)) // [1..53)
+		_ = mantissa & (1<<shift - 1)
+	}
+
+	// from src/net/interface.go:51
+	{
+		type Flags uint
+		var f Flags
+		var i int
+		if f&(1<<uint(i)) != 0 {}
+	}
+
+	// from src/runtime/softfloat64.go:234
+	{
+		var gm uint64
+		var shift uint
+		_ = gm & (1<<shift - 1)
+	}
+
+	// from src/strconv/atof.go:326
+	{
+		var mant uint64
+		var mantbits uint
+		if mant == 2<<mantbits {}
+	}
+
+	// from src/route_bsd.go:82
+	{
+		var Addrs int32
+		const rtaRtMask = 1
+		var i uint
+		if Addrs&rtaRtMask&(1<<i) == 0 {}
+	}
+
+	// from src/text/scanner/scanner.go:540
+	{
+		var s struct { Whitespace uint64 }
+		var ch rune
+		for s.Whitespace&(1<<uint(ch)) != 0 {}
+	}
+}
+
+func issue5895() {
+	var x = 'a' << 1 // type of x must be rune
+	var _ rune = x
+}
+
+func issue11325() {
+	var _ = 0 >> 1.1 /* ERROR "truncated to uint" */ // example from issue 11325
+	_ = 0 >> 1.1 /* ERROR "truncated to uint" */
+	_ = 0 << 1.1 /* ERROR "truncated to uint" */
+	_ = 0 >> 1.
+	_ = 1 >> 1.1 /* ERROR "truncated to uint" */
+	_ = 1 >> 1.
+	_ = 1. >> 1
+	_ = 1. >> 1.
+	_ = 1.1 /* ERROR "must be integer" */ >> 1
+}
+
+func issue11594() {
+	var _ = complex64 /* ERROR "must be integer" */ (1) << 2 // example from issue 11594
+	_ = float32 /* ERROR "must be integer" */ (0) << 1
+	_ = float64 /* ERROR "must be integer" */ (0) >> 2
+	_ = complex64 /* ERROR "must be integer" */ (0) << 3
+	_ = complex64 /* ERROR "must be integer" */ (0) >> 4
+}
+
+func issue21727() {
+	var s uint
+	var a = make([]int, 1<<s + 1.2 /* ERROR "truncated to int" */ )
+	var _ = a[1<<s - 2.3 /* ERROR "truncated to int" */ ]
+	var _ int = 1<<s + 3.4 /* ERROR "truncated to int" */
+	var _ = string(1 << s)
+	var _ = string(1.0 /* ERROR "cannot convert" */ << s)
+}
+
+func issue22969() {
+	var s uint
+	var a []byte
+	_ = a[0xffffffffffffffff /* ERROR "overflows int" */ <<s] // example from issue 22969
+	_ = make([]int, 0xffffffffffffffff /* ERROR "overflows int" */ << s)
+	_ = make([]int, 0, 0xffffffffffffffff /* ERROR "overflows int" */ << s)
+	var _ byte = 0x100 /* ERROR "overflows byte" */ << s
+	var _ int8 = 0xff /* ERROR "overflows int8" */ << s
+	var _ int16 = 0xffff /* ERROR "overflows int16" */ << s
+	var _ int32 = 0x80000000 /* ERROR "overflows int32" */ << s
+}
diff --git a/src/cmd/compile/internal/types2/testdata/stmt0.src b/src/cmd/compile/internal/types2/testdata/stmt0.src
new file mode 100644
index 0000000000..446997ac09
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/stmt0.src
@@ -0,0 +1,980 @@
+// Copyright 2012 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.
+
+// statements
+
+package stmt0
+
+func assignments0() (int, int) {
+	var a, b, c int
+	var ch chan int
+	f0 := func() {}
+	f1 := func() int { return 1 }
+	f2 := func() (int, int) { return 1, 2 }
+	f3 := func() (int, int, int) { return 1, 2, 3 }
+
+	a, b, c = 1, 2, 3
+	a, b, c = 1 /* ERROR "cannot assign [1-9]+ values to [1-9]+ variables" */ , 2
+	a, b, c = 1 /* ERROR "cannot assign [1-9]+ values to [1-9]+ variables" */ , 2, 3, 4
+	_, _, _ = a, b, c
+
+	a = f0 /* ERROR "used as value" */ ()
+	a = f1()
+	a = f2 /* ERROR "cannot assign [1-9]+ values to [1-9]+ variables" */ ()
+	a, b = f2()
+	a, b, c = f2 /* ERROR "cannot assign [1-9]+ values to [1-9]+ variables" */ ()
+	a, b, c = f3()
+	a, b = f3 /* ERROR "cannot assign [1-9]+ values to [1-9]+ variables" */ ()
+
+	a, b, c = <- /* ERROR "cannot assign [1-9]+ values to [1-9]+ variables" */ ch
+
+	return /* ERROR "wrong number of return values" */
+	return /* ERROR "wrong number of return values" */ 1
+	return 1, 2
+	return /* ERROR "wrong number of return values" */ 1, 2, 3
+}
+
+func assignments1() {
+	b, i, f, c, s := false, 1, 1.0, 1i, "foo"
+	b = i /* ERROR "cannot use .* in assignment" */
+	i = f /* ERROR "cannot use .* in assignment" */
+	f = c /* ERROR "cannot use .* in assignment" */
+	c = s /* ERROR "cannot use .* in assignment" */
+	s = b /* ERROR "cannot use .* in assignment" */
+
+	v0, v1, v2 := 1 /* ERROR "cannot initialize" */ , 2, 3, 4
+	_, _, _ = v0, v1, v2
+
+	b = true
+
+	i += 1
+	i += "foo" /* ERROR "cannot convert.*int" */
+
+	f -= 1
+	f /= 0
+	f = float32(0)/0 /* ERROR "division by zero" */
+	f -= "foo" /* ERROR "cannot convert.*float64" */
+
+	c *= 1
+	c /= 0
+
+	s += "bar"
+	s += 1 /* ERROR "cannot convert.*string" */
+
+	var u64 uint64
+	u64 += 1<<u64
+
+	undeclared /* ERROR "undeclared" */ = 991
+
+	// test cases for issue 5800
+	var (
+		_ int = nil /* ERROR "untyped nil value" */
+		_ [10]int = nil /* ERROR "untyped nil value" */
+		_ []byte = nil
+		_ struct{} = nil /* ERROR "untyped nil value" */
+		_ func() = nil
+		_ map[int]string = nil
+		_ chan int = nil
+	)
+
+	// test cases for issue 5500
+	_ = func() (int, bool) {
+		var m map[int]int
+		return /* ERROR "wrong number of return values" */ m[0]
+	}
+
+	g := func(int, bool){}
+	var m map[int]int
+	g(m[0]) /* ERROR "too few arguments" */
+
+	// assignments to _
+	_ = nil /* ERROR "use of untyped nil" */
+	_ = 1 /* ERROR overflow */ <<1000
+	(_) = 0
+}
+
+func assignments2() {
+	type mybool bool
+	var m map[string][]bool
+	var s []bool
+	var b bool
+	var d mybool
+	_ = s
+	_ = b
+	_ = d
+
+	// assignments to map index expressions are ok
+	s, b = m["foo"]
+	_, d = m["bar"]
+	m["foo"] = nil
+	m["foo"] = nil /* ERROR cannot assign [1-9]+ values to [1-9]+ variables */ , false
+	_ = append(m["foo"])
+	_ = append(m["foo"], true)
+
+	var c chan int
+	_, b = <-c
+	_, d = <-c
+	<- /* ERROR cannot assign */ c = 0
+	<-c = 0 /* ERROR cannot assign [1-9]+ values to [1-9]+ variables */ , false
+
+	var x interface{}
+	_, b = x.(int)
+	x /* ERROR cannot assign */ .(int) = 0
+	x.(int) = 0 /* ERROR cannot assign [1-9]+ values to [1-9]+ variables */ , false
+
+	assignments2 /* ERROR used as value */ () = nil
+	int /* ERROR not an expression */ = 0
+}
+
+func issue6487() {
+	type S struct{x int}
+	_ = &S /* ERROR "cannot take address" */ {}.x
+	_ = &( /* ERROR "cannot take address" */ S{}.x)
+	_ = (&S{}).x
+	S /* ERROR "cannot assign" */ {}.x = 0
+	(&S{}).x = 0
+
+	type M map[string]S
+	var m M
+	m /* ERROR "cannot assign to struct field" */ ["foo"].x = 0
+	_ = &( /* ERROR "cannot take address" */ m["foo"].x)
+	_ = &m /* ERROR "cannot take address" */ ["foo"].x
+}
+
+func issue6766a() {
+	a, a /* ERROR redeclared */ := 1, 2
+	_ = a
+	a, b, b /* ERROR redeclared */ := 1, 2, 3
+	_ = b
+	c, c /* ERROR redeclared */, b := 1, 2, 3
+	_ = c
+	a, b := /* ERROR no new variables */ 1, 2
+}
+
+func shortVarDecls1() {
+	const c = 0
+	type d int
+	a, b, c /* ERROR "cannot assign" */ , d /* ERROR "cannot assign" */  := 1, "zwei", 3.0, 4
+	var _ int = a // a is of type int
+	var _ string = b // b is of type string
+}
+
+func incdecs() {
+	const c = 3.14
+	c /* ERROR "cannot assign" */ ++
+	s := "foo"
+	s /* ERROR "invalid operation" */ --
+	3.14 /* ERROR "cannot assign" */ ++
+	var (
+		x int
+		y float32
+		z complex128
+	)
+	x++
+	y--
+	z++
+}
+
+func sends() {
+	var ch chan int
+	var rch <-chan int
+	var x int
+	x <- /* ERROR "cannot send" */ x
+	rch <- /* ERROR "cannot send" */ x
+	ch <- "foo" /* ERROR "cannot convert" */
+	ch <- x
+}
+
+func selects() {
+	select {}
+	var (
+		ch chan int
+		sc chan <- bool
+	)
+	select {
+	case <-ch:
+	case (<-ch):
+	case t := <-ch:
+		_ = t
+	case t := (<-ch):
+		_ = t
+	case t, ok := <-ch:
+		_, _ = t, ok
+	case t, ok := (<-ch):
+		_, _ = t, ok
+	case <-sc /* ERROR "cannot receive from send-only channel" */ :
+	}
+	select {
+	default:
+	default /* ERROR "multiple defaults" */ :
+	}
+	select {
+	case a, b := <-ch:
+		_, b = a, b
+	case x /* ERROR send or receive */ :
+	case a /* ERROR send or receive */ := ch:
+	}
+
+	// test for issue 9570: ch2 in second case falsely resolved to
+	// ch2 declared in body of first case
+	ch1 := make(chan int)
+	ch2 := make(chan int)
+	select {
+	case <-ch1:
+		var ch2 /* ERROR ch2 declared but not used */ chan bool
+	case i := <-ch2:
+		print(i + 1)
+	}
+}
+
+func gos() {
+	go 1 /* ERROR HERE "function must be invoked" */
+	go int /* ERROR "go requires function call, not conversion" */ (0)
+	go gos()
+	var c chan int
+	go close(c)
+	go len /* ERROR "go discards result" */ (c)
+}
+
+func defers() {
+	defer 1 /* ERROR HERE "function must be invoked" */
+	defer int /* ERROR "defer requires function call, not conversion" */ (0)
+	defer defers()
+	var c chan int
+	defer close(c)
+	defer len /* ERROR "defer discards result" */ (c)
+}
+
+func breaks() {
+	var x, y int
+
+	break /* ERROR "break" */
+	{
+		break /* ERROR "break" */
+	}
+	if x < y {
+		break /* ERROR "break" */
+	}
+
+	switch x {
+	case 0:
+		break
+	case 1:
+		if x == y {
+			break
+		}
+	default:
+		break
+		break
+	}
+
+	var z interface{}
+	switch z.(type) {
+	case int:
+		break
+	}
+
+	for {
+		break
+	}
+
+	var a []int
+	for _ = range a {
+		break
+	}
+
+	for {
+		if x == y {
+			break
+		}
+	}
+
+	var ch chan int
+	select {
+	case <-ch:
+		break
+	}
+
+	select {
+	case <-ch:
+		if x == y {
+			break
+		}
+	default:
+		break
+	}
+}
+
+func continues() {
+	var x, y int
+
+	continue /* ERROR "continue" */
+	{
+		continue /* ERROR "continue" */
+	}
+
+	if x < y {
+		continue /* ERROR "continue" */
+	}
+
+	switch x {
+	case 0:
+		continue /* ERROR "continue" */
+	}
+
+	var z interface{}
+	switch z.(type) {
+	case int:
+		continue /* ERROR "continue" */
+	}
+
+	var ch chan int
+	select {
+	case <-ch:
+		continue /* ERROR "continue" */
+	}
+
+	for i := 0; i < 10; i++ {
+		continue
+		if x < y {
+			continue
+			break
+		}
+		switch x {
+		case y:
+			continue
+		default:
+			break
+		}
+		select {
+		case <-ch:
+			continue
+		}
+	}
+
+	var a []int
+	for _ = range a {
+		continue
+		if x < y {
+			continue
+			break
+		}
+		switch x {
+		case y:
+			continue
+		default:
+			break
+		}
+		select {
+		case <-ch:
+			continue
+		}
+	}
+}
+
+func returns0() {
+	return
+	return 0 /* ERROR no result values expected */
+}
+
+func returns1(x float64) (int, *float64) {
+	return 0, &x
+	return /* ERROR wrong number of return values */
+	return "foo" /* ERROR "cannot convert" */, x /* ERROR "cannot use .* in return statement" */
+	return /* ERROR wrong number of return values */ 0, &x, 1
+}
+
+func returns2() (a, b int) {
+	return
+	return 1, "foo" /* ERROR cannot convert */
+	return /* ERROR wrong number of return values */ 1, 2, 3
+	{
+		type a int
+		return 1, 2
+		return /* ERROR a not in scope at return */
+	}
+}
+
+func returns3() (_ int) {
+	return
+	{
+		var _ int // blank (_) identifiers never shadow since they are in no scope
+		return
+	}
+}
+
+func switches0() {
+	var x int
+
+	switch x {
+	}
+
+	switch x {
+	default:
+	default /* ERROR "multiple defaults" */ :
+	}
+
+	switch {
+	case 1  /* ERROR "cannot convert" */ :
+	}
+
+	true := "false"
+	_ = true
+	// A tagless switch is equivalent to the bool
+        // constant true, not the identifier 'true'.
+	switch {
+	case "false" /* ERROR "cannot convert" */:
+	}
+
+	switch int32(x) {
+	case 1, 2:
+	case x /* ERROR "cannot compare" */ :
+	}
+
+	switch x {
+	case 1 /* ERROR "overflows" */ << 100:
+	}
+
+	switch x {
+	case 1:
+	case 1 /* ERROR "duplicate case" */ :
+	case ( /* ERROR "duplicate case" */ 1):
+	case 2, 3, 4:
+	case 5, 1 /* ERROR "duplicate case" */ :
+	}
+
+	switch uint64(x) {
+	case 1<<64 - 1:
+	case 1 /* ERROR duplicate case */ <<64 - 1:
+	case 2, 3, 4:
+	case 5, 1 /* ERROR duplicate case */ <<64 - 1:
+	}
+
+	var y32 float32
+	switch y32 {
+	case 1.1:
+	case 11/10: // integer division!
+	case 11. /* ERROR duplicate case */ /10:
+	case 2, 3.0, 4.1:
+	case 5.2, 1.10 /* ERROR duplicate case */ :
+	}
+
+	var y64 float64
+	switch y64 {
+	case 1.1:
+	case 11/10: // integer division!
+	case 11. /* ERROR duplicate case */ /10:
+	case 2, 3.0, 4.1:
+	case 5.2, 1.10 /* ERROR duplicate case */ :
+	}
+
+	var s string
+	switch s {
+	case "foo":
+	case "foo" /* ERROR duplicate case */ :
+	case "f" /* ERROR duplicate case */ + "oo":
+	case "abc", "def", "ghi":
+	case "jkl", "foo" /* ERROR duplicate case */ :
+	}
+
+	type T int
+	type F float64
+	type S string
+	type B bool
+	var i interface{}
+	switch i {
+	case nil:
+	case nil: // no duplicate detection
+	case (*int)(nil):
+	case (*int)(nil): // do duplicate detection
+	case 1:
+	case byte(1):
+	case int /* ERROR duplicate case */ (1):
+	case T(1):
+	case 1.0:
+	case F(1.0):
+	case F /* ERROR duplicate case */ (1.0):
+	case "hello":
+	case S("hello"):
+	case S /* ERROR duplicate case */ ("hello"):
+	case 1==1, B(false):
+	case false, B(2==2):
+	}
+
+	// switch on array
+	var a [3]int
+	switch a {
+	case [3]int{1, 2, 3}:
+	case [3]int{1, 2, 3}: // no duplicate detection
+	case [ /* ERROR "mismatched types */ 4]int{4, 5, 6}:
+	}
+
+	// switch on channel
+	var c1, c2 chan int
+	switch c1 {
+	case nil:
+	case c1:
+	case c2:
+	case c1, c2: // no duplicate detection
+	}
+}
+
+func switches1() {
+	fallthrough /* ERROR "fallthrough statement out of place" */
+
+	var x int
+	switch x {
+	case 0:
+		fallthrough /* ERROR "fallthrough statement out of place" */
+		break
+	case 1:
+		fallthrough
+	case 2:
+		fallthrough; ; ; // trailing empty statements are ok
+	case 3:
+	default:
+		fallthrough; ;
+	case 4:
+		fallthrough /* ERROR "cannot fallthrough final case in switch" */
+	}
+
+	var y interface{}
+	switch y.(type) {
+	case int:
+		fallthrough /* ERROR "fallthrough statement out of place" */ ; ; ;
+	default:
+	}
+
+	switch x {
+	case 0:
+		if x == 0 {
+			fallthrough /* ERROR "fallthrough statement out of place" */
+		}
+	}
+
+	switch x {
+	case 0:
+		goto L1
+		L1: fallthrough; ;
+	case 1:
+		goto L2
+		goto L3
+		goto L4
+		L2: L3: L4: fallthrough
+	default:
+	}
+
+	switch x {
+	case 0:
+		goto L5
+		L5: fallthrough
+	default:
+		goto L6
+		goto L7
+		goto L8
+		L6: L7: L8: fallthrough /* ERROR "cannot fallthrough final case in switch" */
+	}
+
+	switch x {
+	case 0:
+		fallthrough; ;
+	case 1:
+		{
+			fallthrough /* ERROR "fallthrough statement out of place" */
+		}
+	case 2:
+		fallthrough
+	case 3:
+		fallthrough /* ERROR "fallthrough statement out of place" */
+		{ /* empty block is not an empty statement */ }; ;
+	default:
+		fallthrough /* ERROR "cannot fallthrough final case in switch" */
+	}
+
+	switch x {
+	case 0:
+		{
+			fallthrough /* ERROR "fallthrough statement out of place" */
+		}
+	}
+}
+
+func switches2() {
+	// untyped nil is not permitted as switch expression
+	switch nil /* ERROR "use of untyped nil" */ {
+	case 1, 2, "foo": // don't report additional errors here
+	}
+
+	// untyped constants are converted to default types
+	switch 1<<63-1 {
+	}
+	switch 1 /* ERROR "overflows int" */ << 63 {
+	}
+	var x int
+	switch 1.0 {
+	case 1.0, 2.0, x /* ERROR "mismatched types int and float64" */ :
+	}
+	switch x {
+	case 1.0:
+	}
+
+	// untyped bools become of type bool
+	type B bool
+	var b B = true
+	switch x == x {
+	case b /* ERROR "mismatched types B and bool" */ :
+	}
+	switch {
+	case b /* ERROR "mismatched types B and bool" */ :
+	}
+}
+
+func issue11667() {
+	switch 9223372036854775808 /* ERROR "overflows int" */ {
+	}
+	switch 9223372036854775808 /* ERROR "overflows int" */ {
+	case 9223372036854775808:
+	}
+	var x int
+	switch x {
+	case 9223372036854775808 /* ERROR "overflows int" */ :
+	}
+	var y float64
+	switch y {
+	case 9223372036854775808:
+	}
+}
+
+func issue11687() {
+	f := func() (_, _ int) { return }
+	switch f /* ERROR "2-valued f" */ () {
+	}
+	var x int
+	switch f /* ERROR "2-valued f" */ () {
+	case x:
+	}
+	switch x {
+	case f /* ERROR "2-valued f" */ ():
+	}
+}
+
+type I interface {
+	m()
+}
+
+type I2 interface {
+	m(int)
+}
+
+type T struct{}
+type T1 struct{}
+type T2 struct{}
+
+func (T) m() {}
+func (T2) m(int) {}
+
+func typeswitches() {
+	var i int
+	var x interface{}
+
+	switch x.(type) {}
+	switch (x /* ERROR "outside type switch" */ .(type)) {}
+
+	switch x.(type) {
+	default:
+	default /* ERROR "multiple defaults" */ :
+	}
+
+	switch x /* ERROR "declared but not used" */ := x.(type) {}
+	switch _ /* ERROR "no new variable on left side of :=" */ := x.(type) {}
+
+	switch x := x.(type) {
+	case int:
+		var y int = x
+		_ = y
+	}
+
+	switch x := i /* ERROR "not an interface" */ .(type) {}
+
+	switch t := x.(type) {
+	case nil:
+		var v bool = t /* ERROR "cannot use .* in variable declaration" */
+		_ = v
+	case int:
+		var v int = t
+		_ = v
+	case float32, complex64:
+		var v float32 = t /* ERROR "cannot use .* in variable declaration" */
+		_ = v
+	default:
+		var v float32 = t /* ERROR "cannot use .* in variable declaration" */
+		_ = v
+	}
+
+	var t I
+	switch t.(type) {
+	case T:
+	case T1 /* ERROR "missing method m" */ :
+	case T2 /* ERROR "wrong type for method m" */ :
+	case I2 /* STRICT "wrong type for method m" */ : // only an error in strict mode (issue 8561)
+	}
+}
+
+// Test that each case clause uses the correct type of the variable
+// declared by the type switch (issue 5504).
+func typeswitch0() {
+	switch y := interface{}(nil).(type) {
+	case int:
+		func() int { return y + 0 }()
+	case float32:
+		func() float32 { return y }()
+	}
+}
+
+// Test correct scope setup.
+// (no redeclaration errors expected in the type switch)
+func typeswitch1() {
+	var t I
+	switch t := t; t := t.(type) {
+	case nil:
+		var _ I = t
+	case T:
+		var _ T = t
+	default:
+		var _ I = t
+	}
+}
+
+// Test correct typeswitch against interface types.
+type A interface { a() }
+type B interface { b() }
+type C interface { a(int) }
+
+func typeswitch2() {
+	switch A(nil).(type) {
+	case A:
+	case B:
+	case C /* STRICT "cannot have dynamic type" */: // only an error in strict mode (issue 8561)
+	}
+}
+
+func typeswitch3(x interface{}) {
+	switch x.(type) {
+	case int:
+	case float64:
+	case int /* ERROR duplicate case */ :
+	}
+
+	switch x.(type) {
+	case nil:
+	case int:
+	case nil /* ERROR duplicate case */ , nil /* ERROR duplicate case */ :
+	}
+
+	type F func(int)
+	switch x.(type) {
+	case nil:
+	case int, func(int):
+	case float32, func /* ERROR duplicate case */ (x int):
+	case F:
+	}
+}
+
+func fors1() {
+	for {}
+	var i string
+	_ = i
+	for i := 0; i < 10; i++ {}
+	for i := 0; i < 10; j /* ERROR cannot declare */ := 0 {}
+}
+
+func rangeloops1() {
+	var (
+		x int
+		a [10]float32
+		b []string
+		p *[10]complex128
+		pp **[10]complex128
+		s string
+		m map[int]bool
+		c chan int
+		sc chan<- int
+		rc <-chan int
+	)
+
+	for range x /* ERROR "cannot range over" */ {}
+	for _ = range x /* ERROR "cannot range over" */ {}
+	for i := range x /* ERROR "cannot range over" */ {}
+
+	for range a {}
+	for i := range a {
+		var ii int
+		ii = i
+		_ = ii
+	}
+	for i, x := range a {
+		var ii int
+		ii = i
+		_ = ii
+		var xx float64
+		xx = x /* ERROR "cannot use .* in assignment" */
+		_ = xx
+	}
+	var ii int
+	var xx float32
+	for ii, xx = range a {}
+	_, _ = ii, xx
+
+	for range b {}
+	for i := range b {
+		var ii int
+		ii = i
+		_ = ii
+	}
+	for i, x := range b {
+		var ii int
+		ii = i
+		_ = ii
+		var xx string
+		xx = x
+		_ = xx
+	}
+
+	for range s {}
+	for i := range s {
+		var ii int
+		ii = i
+		_ = ii
+	}
+	for i, x := range s {
+		var ii int
+		ii = i
+		_ = ii
+		var xx rune
+		xx = x
+		_ = xx
+	}
+
+	for range p {}
+	for _, x := range p {
+		var xx complex128
+		xx = x
+		_ = xx
+	}
+
+	for range pp /* ERROR "cannot range over" */ {}
+	for _, x := range pp /* ERROR "cannot range over" */ {}
+
+	for range m {}
+	for k := range m {
+		var kk int32
+		kk = k /* ERROR "cannot use .* in assignment" */
+		_ = kk
+	}
+	for k, v := range m {
+		var kk int
+		kk = k
+		_ = kk
+		if v {}
+	}
+
+	for range c {}
+	for _, _ /* ERROR "only one iteration variable" */ = range c {}
+	for e := range c {
+		var ee int
+		ee = e
+		_ = ee
+	}
+	for _ = range sc /* ERROR "cannot range over send-only channel" */ {}
+	for _ = range rc {}
+
+	// constant strings
+	const cs = "foo"
+	for range cs {}
+	for range "" {}
+	for i, x := range cs { _, _ = i, x }
+	for i, x := range "" {
+		var ii int
+		ii = i
+		_ = ii
+		var xx rune
+		xx = x
+		_ = xx
+	}
+}
+
+func rangeloops2() {
+	type I int
+	type R rune
+
+	var a [10]int
+	var i I
+	_ = i
+	for i /* ERROR cannot use .* in assignment */ = range a {}
+	for i /* ERROR cannot use .* in assignment */ = range &a {}
+	for i /* ERROR cannot use .* in assignment */ = range a[:] {}
+
+	var s string
+	var r R
+	_ = r
+	for i /* ERROR cannot use .* in assignment */ = range s {}
+	for i /* ERROR cannot use .* in assignment */ = range "foo" {}
+	for _, r /* ERROR cannot use .* in assignment */ = range s {}
+	for _, r /* ERROR cannot use .* in assignment */ = range "foo" {}
+}
+
+func issue6766b() {
+	for _ := /* ERROR no new variables */ range "" {}
+	for a, a /* ERROR redeclared */ := range "" { _ = a }
+	var a int
+	_ = a
+	for a, a /* ERROR redeclared */ := range []int{1, 2, 3} { _ = a }
+}
+
+// Test that despite errors in the range clause,
+// the loop body is still type-checked (and thus
+// errors reported).
+func issue10148() {
+	for y /* ERROR declared but not used */ := range "" {
+		_ = "" /* ERROR cannot convert */ + 1
+	}
+	for range 1 /* ERROR cannot range over 1 */ {
+		_ = "" /* ERROR cannot convert */ + 1
+	}
+	for y := range 1 /* ERROR cannot range over 1 */ {
+		_ = "" /* ERROR cannot convert */ + 1
+	}
+}
+
+func labels0() {
+	goto L0
+	goto L1
+	L0:
+	L1:
+	L1 /* ERROR "already declared" */ :
+	if true {
+		goto L2
+		L2:
+		L0 /* ERROR "already declared" */ :
+	}
+	_ = func() {
+		goto L0
+		goto L1
+		goto L2
+		L0:
+		L1:
+		L2:
+	}
+}
+
+func expression_statements(ch chan int) {
+	expression_statements(ch)
+	<-ch
+	println()
+
+	0 /* ERROR "not used" */
+	1 /* ERROR "not used" */ +2
+	cap /* ERROR "not used" */ (ch)
+	println /* ERROR "must be called" */
+}
diff --git a/src/cmd/compile/internal/types2/testdata/stmt1.src b/src/cmd/compile/internal/types2/testdata/stmt1.src
new file mode 100644
index 0000000000..f79f92058b
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/stmt1.src
@@ -0,0 +1,259 @@
+// Copyright 2013 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.
+
+// terminating statements
+
+package stmt1
+
+func _() {}
+
+func _() int {} /* ERROR "missing return" */
+
+func _() int { panic(0) }
+func _() int { (panic(0)) }
+
+// block statements
+func _(x, y int) (z int) {
+	{
+		return
+	}
+}
+
+func _(x, y int) (z int) {
+	{
+		return; ; ; // trailing empty statements are ok
+	}
+	; ; ;
+}
+
+func _(x, y int) (z int) {
+	{
+	}
+} /* ERROR "missing return" */
+
+func _(x, y int) (z int) {
+	{
+		; ; ;
+	}
+	; ; ;
+} /* ERROR "missing return" */
+
+// if statements
+func _(x, y int) (z int) {
+	if x < y { return }
+	return 1
+}
+
+func _(x, y int) (z int) {
+	if x < y { return; ; ; ; }
+	return 1
+}
+
+func _(x, y int) (z int) {
+	if x < y { return }
+	return 1; ;
+}
+
+func _(x, y int) (z int) {
+	if x < y { return }
+} /* ERROR "missing return" */
+
+func _(x, y int) (z int) {
+	if x < y {
+	} else { return 1
+	}
+} /* ERROR "missing return" */
+
+func _(x, y int) (z int) {
+	if x < y { return
+	} else { return
+	}
+}
+
+// for statements
+func _(x, y int) (z int) {
+	for x < y {
+		return
+	}
+} /* ERROR "missing return" */
+
+func _(x, y int) (z int) {
+	for {
+		return
+	}
+}
+
+func _(x, y int) (z int) {
+	for {
+		return; ; ; ;
+	}
+}
+
+func _(x, y int) (z int) {
+	for {
+		return
+		break
+	}
+	; ; ;
+} /* ERROR "missing return" */
+
+func _(x, y int) (z int) {
+	for {
+		for { break }
+		return
+	}
+}
+
+func _(x, y int) (z int) {
+	for {
+		for { break }
+		return ; ;
+	}
+	;
+}
+
+func _(x, y int) (z int) {
+L:	for {
+		for { break L }
+		return
+	}
+} /* ERROR "missing return" */
+
+// switch statements
+func _(x, y int) (z int) {
+	switch x {
+	case 0: return
+	default: return
+	}
+}
+
+func _(x, y int) (z int) {
+	switch x {
+	case 0: return;
+	default: return; ; ;
+	}
+}
+
+func _(x, y int) (z int) {
+	switch x {
+	case 0: return
+	}
+} /* ERROR "missing return" */
+
+func _(x, y int) (z int) {
+	switch x {
+	case 0: return
+	case 1: break
+	}
+} /* ERROR "missing return" */
+
+func _(x, y int) (z int) {
+	switch x {
+	case 0: return
+	default:
+		switch y {
+		case 0: break
+		}
+		panic(0)
+	}
+}
+
+func _(x, y int) (z int) {
+	switch x {
+	case 0: return
+	default:
+		switch y {
+		case 0: break
+		}
+		panic(0); ; ;
+	}
+	;
+}
+
+func _(x, y int) (z int) {
+L:	switch x {
+	case 0: return
+	default:
+		switch y {
+		case 0: break L
+		}
+		panic(0)
+	}
+} /* ERROR "missing return" */
+
+// select statements
+func _(ch chan int) (z int) {
+	select {}
+} // nice!
+
+func _(ch chan int) (z int) {
+	select {}
+	; ;
+}
+
+func _(ch chan int) (z int) {
+	select {
+	default: break
+	}
+} /* ERROR "missing return" */
+
+func _(ch chan int) (z int) {
+	select {
+	case <-ch: return
+	default: break
+	}
+} /* ERROR "missing return" */
+
+func _(ch chan int) (z int) {
+	select {
+	case <-ch: return
+	default:
+		for i := 0; i < 10; i++ {
+			break
+		}
+		return
+	}
+}
+
+func _(ch chan int) (z int) {
+	select {
+	case <-ch: return; ; ;
+	default:
+		for i := 0; i < 10; i++ {
+			break
+		}
+		return; ; ;
+	}
+	; ; ;
+}
+
+func _(ch chan int) (z int) {
+L:	select {
+	case <-ch: return
+	default:
+		for i := 0; i < 10; i++ {
+			break L
+		}
+		return
+	}
+	; ; ;
+} /* ERROR "missing return" */
+
+func parenPanic() int {
+	((((((panic)))(0))))
+}
+
+func issue23218a() int {
+	{
+		panic := func(interface{}){}
+		panic(0)
+	}
+} /* ERROR "missing return" */
+
+func issue23218b() int {
+	{
+		panic := func(interface{}){}
+		((((panic))))(0)
+	}
+} /* ERROR "missing return" */
diff --git a/src/cmd/compile/internal/types2/testdata/vardecl.src b/src/cmd/compile/internal/types2/testdata/vardecl.src
new file mode 100644
index 0000000000..54f5ef1e10
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/vardecl.src
@@ -0,0 +1,206 @@
+// Copyright 2013 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 vardecl
+
+// Prerequisites.
+import "math"
+func f() {}
+func g() (x, y int) { return }
+var m map[string]int
+
+// Var decls must have a type or an initializer.
+var _ int
+var _, _ int
+
+// The first error message is produced by the parser.
+// In a real-world scenario, the type-checker would not be run
+// in this case and the 2nd error message would not appear.
+var _ /* ERROR "missing variable type" */ /* ERROR "missing type or init expr" */
+var _ /* ERROR "missing variable type" */ /* ERROR "missing type or init expr" */, _
+var _ /* ERROR "missing variable type" */ /* ERROR "missing type or init expr" */, _, _
+
+// The initializer must be an expression.
+var _ = int /* ERROR "not an expression" */
+var _ = f /* ERROR "used as value" */ ()
+
+// Identifier and expression arity must match.
+var _, _ = 1, 2
+var _ = 1, 2 /* ERROR "extra init expr 2" */
+var _, _ = 1 /* ERROR "cannot initialize [0-9]+ variables with [0-9]+ values" */
+var _, _, _ /* ERROR "missing init expr for _" */ = 1, 2
+
+var _ = g /* ERROR "2-valued g" */ ()
+var _, _ = g()
+var _, _, _ = g /* ERROR "cannot initialize [0-9]+ variables with [0-9]+ values" */ ()
+
+var _ = m["foo"]
+var _, _ = m["foo"]
+var _, _, _ = m  /* ERROR "cannot initialize [0-9]+ variables with [0-9]+ values" */ ["foo"]
+
+var _, _ int = 1, 2
+var _ int = 1, 2 /* ERROR "extra init expr 2" */
+var _, _ int = 1 /* ERROR "cannot initialize [0-9]+ variables with [0-9]+ values" */
+var _, _, _ /* ERROR "missing init expr for _" */ int = 1, 2
+
+var (
+	_, _ = 1, 2
+	_ = 1, 2 /* ERROR "extra init expr 2" */
+	_, _ = 1 /* ERROR "cannot initialize [0-9]+ variables with [0-9]+ values" */
+	_, _, _ /* ERROR "missing init expr for _" */ = 1, 2
+
+	_ = g /* ERROR "2-valued g" */ ()
+	_, _ = g()
+	_, _, _ = g /* ERROR "cannot initialize [0-9]+ variables with [0-9]+ values" */ ()
+
+	_ = m["foo"]
+	_, _ = m["foo"]
+	_, _, _ = m /* ERROR "cannot initialize [0-9]+ variables with [0-9]+ values" */ ["foo"]
+
+	_, _ int = 1, 2
+	_ int = 1, 2 /* ERROR "extra init expr 2" */
+	_, _ int = 1 /* ERROR "cannot initialize [0-9]+ variables with [0-9]+ values" */
+	_, _, _ /* ERROR "missing init expr for _" */ int = 1, 2
+)
+
+// Variables declared in function bodies must be 'used'.
+type T struct{}
+func (r T) _(a, b, c int) (u, v, w int) {
+	var x1 /* ERROR "declared but not used" */ int
+	var x2 /* ERROR "declared but not used" */ int
+	x1 = 1
+	(x2) = 2
+
+	y1 /* ERROR "declared but not used" */ := 1
+	y2 /* ERROR "declared but not used" */ := 2
+	y1 = 1
+	(y1) = 2
+
+	{
+		var x1 /* ERROR "declared but not used" */ int
+		var x2 /* ERROR "declared but not used" */ int
+		x1 = 1
+		(x2) = 2
+
+		y1 /* ERROR "declared but not used" */ := 1
+		y2 /* ERROR "declared but not used" */ := 2
+		y1 = 1
+		(y1) = 2
+	}
+
+	if x /* ERROR "declared but not used" */ := 0; a < b {}
+
+	switch x /* ERROR "declared but not used" */, y := 0, 1; a {
+	case 0:
+		_ = y
+	case 1:
+		x /* ERROR "declared but not used" */ := 0
+	}
+
+	var t interface{}
+	switch t /* ERROR "declared but not used" */ := t.(type) {}
+
+	switch t /* ERROR "declared but not used" */ := t.(type) {
+	case int:
+	}
+
+	switch t /* ERROR "declared but not used" */ := t.(type) {
+	case int:
+	case float32, complex64:
+		t = nil
+	}
+
+	switch t := t.(type) {
+	case int:
+	case float32, complex64:
+		_ = t
+	}
+
+	switch t := t.(type) {
+	case int:
+	case float32:
+	case string:
+		_ = func() string {
+			return t
+		}
+	}
+
+	switch t := t; t /* ERROR "declared but not used" */ := t.(type) {}
+
+	var z1 /* ERROR "declared but not used" */ int
+	var z2 int
+	_ = func(a, b, c int) (u, v, w int) {
+		z1 = a
+		(z1) = b
+		a = z2
+		return
+	}
+
+	var s []int
+	var i /* ERROR "declared but not used" */ , j int
+	for i, j = range s {
+		_ = j
+	}
+
+	for i, j /* ERROR "declared but not used" */ := range s {
+		_ = func() int {
+			return i
+		}
+	}
+	return
+}
+
+// Unused variables in function literals must lead to only one error (issue #22524).
+func _() {
+	_ = func() {
+		var x /* ERROR declared but not used */ int
+	}
+}
+
+// Invalid (unused) expressions must not lead to spurious "declared but not used errors"
+func _() {
+	var a, b, c int
+	var x, y int
+	x, y = a /* ERROR cannot assign [0-9]+ values to [0-9]+ variables */ , b, c
+	_ = x
+	_ = y
+}
+
+func _() {
+	var x int
+	return x /* ERROR no result values expected */
+	return math /* ERROR no result values expected */ .Sin(0)
+}
+
+func _() int {
+	var x, y int
+	return /* ERROR wrong number of return values */ x, y
+}
+
+// Short variable declarations must declare at least one new non-blank variable.
+func _() {
+	_ := /* ERROR no new variables */ 0
+	_, a := 0, 1
+	_, a := /* ERROR no new variables */ 0, 1
+	_, a, b := 0, 1, 2
+	_, _, _ := /* ERROR no new variables */ 0, 1, 2
+
+	_ = a
+	_ = b
+}
+
+// Test case for variables depending on function literals (see also #22992).
+var A /* ERROR initialization cycle */ = func() int { return A }()
+
+func _() {
+	// The function literal below must not see a.
+	var a = func() int { return a /* ERROR "undeclared name" */ }()
+	var _ = func() int { return a }()
+
+	// The function literal below must not see x, y, or z.
+	var x, y, z = 0, 1, func() int { return x /* ERROR "undeclared name" */ + y /* ERROR "undeclared name" */ + z /* ERROR "undeclared name" */ }()
+	_, _, _ = x, y, z
+}
+
+// TODO(gri) consolidate other var decl checks in this file
\ No newline at end of file
-- 
GitLab


From 1d07306a447ae50d3eae5eed6ecc4f30a2528c96 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 19 Oct 2020 21:38:31 -0700
Subject: [PATCH 0011/2400] [dev.typeparams] cmd/compile/internal/types2:
 adjust tests, enable Testdata tests

Types2 uses a different test runner and has fewer/better
errors in some cases (error messages match the compiler).
Adjust the tests and enable them.

Change-Id: I74877f54a81a3918a80774452cef5bcaad8a98e6
Reviewed-on: https://go-review.googlesource.com/c/go/+/263631
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/types2/check_test.go |   3 +-
 .../internal/types2/testdata/builtins.src     |  10 +-
 .../internal/types2/testdata/constdecl.src    |  19 ++-
 .../internal/types2/testdata/decls0.src       |  10 +-
 .../types2/testdata/decls2/decls2a.src        | 111 ++++++++++++++++++
 .../types2/testdata/decls2/decls2b.src        |  75 ++++++++++++
 .../internal/types2/testdata/expr3.src        |  37 +++---
 .../testdata/importdecl0/importdecl0a.src     |  53 +++++++++
 .../testdata/importdecl0/importdecl0b.src     |  30 +++++
 .../testdata/importdecl1/importdecl1a.src     |  22 ++++
 .../testdata/importdecl1/importdecl1b.src     |  11 ++
 .../testdata/issue25008/issue25008a.src       |  15 +++
 .../testdata/issue25008/issue25008b.src       |   9 ++
 .../internal/types2/testdata/issues.src       |   4 +-
 .../internal/types2/testdata/shifts.src       |  11 +-
 .../internal/types2/testdata/stmt0.src        |   8 +-
 .../internal/types2/testdata/vardecl.src      |   9 +-
 17 files changed, 381 insertions(+), 56 deletions(-)
 create mode 100644 src/cmd/compile/internal/types2/testdata/decls2/decls2a.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/decls2/decls2b.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/importdecl0/importdecl0a.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/importdecl0/importdecl0b.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/importdecl1/importdecl1a.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/importdecl1/importdecl1b.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/issue25008/issue25008a.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/issue25008/issue25008b.src

diff --git a/src/cmd/compile/internal/types2/check_test.go b/src/cmd/compile/internal/types2/check_test.go
index 4dac76ea80..85bf0728c0 100644
--- a/src/cmd/compile/internal/types2/check_test.go
+++ b/src/cmd/compile/internal/types2/check_test.go
@@ -221,8 +221,7 @@ func TestCheck(t *testing.T) {
 	checkFiles(t, strings.Split(*testFiles, " "), 0, testing.Verbose())
 }
 
-// TODO(gri) Enable once we have added the testdata tests.
-// func TestTestdata(t *testing.T)  { DefPredeclaredTestFuncs(); testDir(t, 75, "testdata") } // TODO(gri) narrow column tolerance
+func TestTestdata(t *testing.T)  { DefPredeclaredTestFuncs(); testDir(t, 75, "testdata") } // TODO(gri) narrow column tolerance
 func TestExamples(t *testing.T)  { testDir(t, 0, "examples") }
 func TestFixedbugs(t *testing.T) { testDir(t, 0, "fixedbugs") }
 
diff --git a/src/cmd/compile/internal/types2/testdata/builtins.src b/src/cmd/compile/internal/types2/testdata/builtins.src
index ecdba51553..69cc48798e 100644
--- a/src/cmd/compile/internal/types2/testdata/builtins.src
+++ b/src/cmd/compile/internal/types2/testdata/builtins.src
@@ -25,11 +25,11 @@ func append1() {
 	_ = append(s, b)
 	_ = append(s, x /* ERROR cannot use x */ )
 	_ = append(s, s /* ERROR cannot use s */ )
-	_ = append(s... /* ERROR can only use ... with matching parameter */ )
-	_ = append(s, b, s... /* ERROR can only use ... with matching parameter */ )
+	_ = append(s... ) /* ERROR not enough arguments */
+	_ = append(s, b, s /* ERROR too many arguments */ ... )
 	_ = append(s, 1, 2, 3)
 	_ = append(s, 1, 2, 3, x /* ERROR cannot use x */ , 5, 6, 6)
-	_ = append(s, 1, 2, s... /* ERROR can only use ... with matching parameter */ )
+	_ = append(s, 1, 2 /* ERROR too many arguments */ , s... )
 	_ = append([]interface{}(nil), 1, 2, "foo", x, 3.1425, false)
 
 	type S []byte
@@ -482,7 +482,7 @@ func make1() {
 }
 
 func make2() {
-	f1 /* ERROR not used */ := func() (x []int) { return }
+	f1 := func() (x []int) { return }
 	_ = make(f0 /* ERROR not a type */ ())
 	_ = make(f1 /* ERROR not a type */ ())
 }
@@ -502,7 +502,7 @@ func new1() {
 }
 
 func new2() {
-	f1 /* ERROR not used */ := func() (x []int) { return }
+	f1 := func() (x []int) { return }
 	_ = new(f0 /* ERROR not a type */ ())
 	_ = new(f1 /* ERROR not a type */ ())
 }
diff --git a/src/cmd/compile/internal/types2/testdata/constdecl.src b/src/cmd/compile/internal/types2/testdata/constdecl.src
index c2f40ed6e6..e9a5162e9c 100644
--- a/src/cmd/compile/internal/types2/testdata/constdecl.src
+++ b/src/cmd/compile/internal/types2/testdata/constdecl.src
@@ -21,20 +21,17 @@ func _() {
 }
 
 // Identifier and expression arity must match.
-// The first error message is produced by the parser.
-// In a real-world scenario, the type-checker would not be run
-// in this case and the 2nd error message would not appear.
-const _ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */
+const _ /* ERROR "missing init expr for _" */
 const _ = 1, 2 /* ERROR "extra init expr 2" */
 
-const _ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */ int
+const _ /* ERROR "missing init expr for _" */ int
 const _ int = 1, 2 /* ERROR "extra init expr 2" */
 
 const (
-	_ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */
+	_ /* ERROR "missing init expr for _" */
 	_ = 1, 2 /* ERROR "extra init expr 2" */
 
-	_ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */ int
+	_ /* ERROR "missing init expr for _" */ int
 	_ int = 1, 2 /* ERROR "extra init expr 2" */
 )
 
@@ -55,17 +52,17 @@ const (
 )
 
 func _() {
-	const _ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */
+	const _ /* ERROR "missing init expr for _" */
 	const _ = 1, 2 /* ERROR "extra init expr 2" */
 
-	const _ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */ int
+	const _ /* ERROR "missing init expr for _" */ int
 	const _ int = 1, 2 /* ERROR "extra init expr 2" */
 
 	const (
-		_ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */
+		_ /* ERROR "missing init expr for _" */
 		_ = 1, 2 /* ERROR "extra init expr 2" */
 
-		_ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */ int
+		_ /* ERROR "missing init expr for _" */ int
 		_ int = 1, 2 /* ERROR "extra init expr 2" */
 	)
 
diff --git a/src/cmd/compile/internal/types2/testdata/decls0.src b/src/cmd/compile/internal/types2/testdata/decls0.src
index 5501b65915..e78d8867e0 100644
--- a/src/cmd/compile/internal/types2/testdata/decls0.src
+++ b/src/cmd/compile/internal/types2/testdata/decls0.src
@@ -49,7 +49,7 @@ func _() { var init int; _ = init }
 
 // invalid array types
 type (
-	iA0 [... /* ERROR "invalid use of '...'" */ ]byte
+	iA0 [... /* ERROR "invalid use of \[...\] array" */ ]byte
 	// The error message below could be better. At the moment
 	// we believe an integer that is too large is not an integer.
 	// But at least we get an error.
@@ -185,10 +185,10 @@ func f2(x *f2 /* ERROR "not a type" */ ) {}
 func f3() (x f3 /* ERROR "not a type" */ ) { return }
 func f4() (x *f4 /* ERROR "not a type" */ ) { return }
 
-func (S0) m1 /* ERROR illegal cycle */ (x S0 /* ERROR value .* is not a type */ .m1) {}
-func (S0) m2 /* ERROR illegal cycle */ (x *S0 /* ERROR value .* is not a type */ .m2) {}
-func (S0) m3 /* ERROR illegal cycle */ () (x S0 /* ERROR value .* is not a type */ .m3) { return }
-func (S0) m4 /* ERROR illegal cycle */ () (x *S0 /* ERROR value .* is not a type */ .m4) { return }
+func (S0) m1(x S0 /* ERROR value .* is not a type */ .m1) {}
+func (S0) m2(x *S0 /* ERROR value .* is not a type */ .m2) {}
+func (S0) m3() (x S0 /* ERROR value .* is not a type */ .m3) { return }
+func (S0) m4() (x *S0 /* ERROR value .* is not a type */ .m4) { return }
 
 // interfaces may not have any blank methods
 type BlankI interface {
diff --git a/src/cmd/compile/internal/types2/testdata/decls2/decls2a.src b/src/cmd/compile/internal/types2/testdata/decls2/decls2a.src
new file mode 100644
index 0000000000..d077db55dd
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/decls2/decls2a.src
@@ -0,0 +1,111 @@
+// Copyright 2012 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.
+
+// method declarations
+
+package decls2
+
+import "time"
+import "unsafe"
+
+// T1 declared before its methods.
+type T1 struct{
+	f int
+}
+
+func (T1) m() {}
+func (T1) m /* ERROR "already declared" */ () {}
+func (x *T1) f /* ERROR "field and method" */ () {}
+
+// Conflict between embedded field and method name,
+// with the embedded field being a basic type.
+type T1b struct {
+	int
+}
+
+func (T1b) int /* ERROR "field and method" */ () {}
+
+type T1c struct {
+	time.Time
+}
+
+func (T1c) Time /* ERROR "field and method" */ () int { return 0 }
+
+// Disabled for now: LookupFieldOrMethod will find Pointer even though
+// it's double-declared (it would cost extra in the common case to verify
+// this). But the MethodSet computation will not find it due to the name
+// collision caused by the double-declaration, leading to an internal
+// inconsistency while we are verifying one computation against the other.
+// var _ = T1c{}.Pointer
+
+// T2's method declared before the type.
+func (*T2) f /* ERROR "field and method" */ () {}
+
+type T2 struct {
+	f int
+}
+
+// Methods declared without a declared type.
+func (undeclared /* ERROR "undeclared" */) m() {}
+func (x *undeclared /* ERROR "undeclared" */) m() {}
+
+func (pi /* ERROR "not a type" */) m1() {}
+func (x pi /* ERROR "not a type" */) m2() {}
+func (x *pi /* ERROR "not a type" */ ) m3() {}
+
+// Blank types.
+type _ struct { m int }
+type _ struct { m int }
+
+func (_ /* ERROR "cannot use _" */) m() {}
+func m(_ /* ERROR "cannot use _" */) {}
+
+// Methods with receiver base type declared in another file.
+func (T3) m1() {}
+func (*T3) m2() {}
+func (x T3) m3() {}
+func (x *T3) f /* ERROR "field and method" */ () {}
+
+// Methods of non-struct type.
+type T4 func()
+
+func (self T4) m() func() { return self }
+
+// Methods associated with an interface.
+type T5 interface {
+	m() int
+}
+
+func (T5 /* ERROR "invalid receiver" */ ) m1() {}
+func (T5 /* ERROR "invalid receiver" */ ) m2() {}
+
+// Methods associated with a named pointer type.
+type ptr *int
+func (ptr /* ERROR "invalid receiver" */ ) _() {}
+func (* /* ERROR "invalid receiver" */ ptr) _() {}
+
+// Methods with zero or multiple receivers.
+func ( /* ERROR "no receiver" */ ) _() {}
+func (T3, * /* ERROR "multiple receivers" */ T3) _() {}
+func (T3, T3, T3 /* ERROR "multiple receivers" */ ) _() {}
+func (a, b /* ERROR "multiple receivers" */ T3) _() {}
+func (a, b, c /* ERROR "multiple receivers" */ T3) _() {}
+
+// Methods associated with non-local or unnamed types.
+func (int /* ERROR "invalid receiver" */ ) m() {}
+func ([ /* ERROR "invalid receiver" */ ]int) m() {}
+func (time /* ERROR "invalid receiver" */ .Time) m() {}
+func (* /* ERROR "invalid receiver" */ time.Time) m() {}
+func (x /* ERROR "invalid receiver" */ interface{}) m() {}
+
+// Unsafe.Pointer is treated like a pointer when used as receiver type.
+type UP unsafe.Pointer
+func (UP /* ERROR "invalid" */ ) m1() {}
+func (* /* ERROR "invalid" */ UP) m2() {}
+
+// Double declarations across package files
+const c_double = 0
+type t_double int
+var v_double int
+func f_double() {}
diff --git a/src/cmd/compile/internal/types2/testdata/decls2/decls2b.src b/src/cmd/compile/internal/types2/testdata/decls2/decls2b.src
new file mode 100644
index 0000000000..8e82c6dcde
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/decls2/decls2b.src
@@ -0,0 +1,75 @@
+// Copyright 2012 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.
+
+// method declarations
+
+package decls2
+
+import "io"
+
+const pi = 3.1415
+
+func (T1) m /* ERROR "already declared" */ () {}
+func (T2) m(io.Writer) {}
+
+type T3 struct {
+	f *T3
+}
+
+type T6 struct {
+	x int
+}
+
+func (t *T6) m1() int {
+	return t.x
+}
+
+func f() {
+	var t *T6
+	t.m1()
+}
+
+// Double declarations across package files
+const c_double /* ERROR "redeclared" */ = 0
+type t_double  /* ERROR "redeclared" */ int
+var v_double /* ERROR "redeclared" */ int
+func f_double /* ERROR "redeclared" */ () {}
+
+// Blank methods need to be type-checked.
+// Verify by checking that errors are reported.
+func (T /* ERROR "undeclared" */ ) _() {}
+func (T1) _(undeclared /* ERROR "undeclared" */ ) {}
+func (T1) _() int { return "foo" /* ERROR "cannot convert" */ }
+
+// Methods with undeclared receiver type can still be checked.
+// Verify by checking that errors are reported.
+func (Foo /* ERROR "undeclared" */ ) m() {}
+func (Foo /* ERROR "undeclared" */ ) m(undeclared /* ERROR "undeclared" */ ) {}
+func (Foo /* ERROR "undeclared" */ ) m() int { return "foo" /* ERROR "cannot convert" */ }
+
+func (Foo /* ERROR "undeclared" */ ) _() {}
+func (Foo /* ERROR "undeclared" */ ) _(undeclared /* ERROR "undeclared" */ ) {}
+func (Foo /* ERROR "undeclared" */ ) _() int { return "foo" /* ERROR "cannot convert" */ }
+
+// Receiver declarations are regular parameter lists;
+// receiver types may use parentheses, and the list
+// may have a trailing comma.
+type T7 struct {}
+
+func (T7) m1() {}
+func ((T7)) m2() {}
+func ((*T7)) m3() {}
+func (x *(T7),) m4() {}
+func (x (*(T7)),) m5() {}
+func (x ((*((T7)))),) m6() {}
+
+// Check that methods with parenthesized receiver are actually present (issue #23130).
+var (
+	_ = T7.m1
+	_ = T7.m2
+	_ = (*T7).m3
+	_ = (*T7).m4
+	_ = (*T7).m5
+	_ = (*T7).m6
+)
\ No newline at end of file
diff --git a/src/cmd/compile/internal/types2/testdata/expr3.src b/src/cmd/compile/internal/types2/testdata/expr3.src
index 63af9fc867..3c6e36f148 100644
--- a/src/cmd/compile/internal/types2/testdata/expr3.src
+++ b/src/cmd/compile/internal/types2/testdata/expr3.src
@@ -7,8 +7,9 @@ package expr3
 import "time"
 
 func indexes() {
+	var x int
 	_ = 1 /* ERROR "cannot index" */ [0]
-	_ = indexes /* ERROR "cannot index" */ [0]
+	_ = x /* ERROR "cannot index" */ [0]
 	_ = ( /* ERROR "cannot slice" */ 12 + 3)[1:2]
 
 	var a [10]int
@@ -19,9 +20,9 @@ func indexes() {
 	_ = a[- /* ERROR "negative" */ 1]
 	_ = a[- /* ERROR "negative" */ 1 :]
 	_ = a[: - /* ERROR "negative" */ 1]
-	_ = a[: /* ERROR "2nd index required" */ : /* ERROR "3rd index required" */ ]
-	_ = a[0: /* ERROR "2nd index required" */ : /* ERROR "3rd index required" */ ]
-	_ = a[0: /* ERROR "2nd index required" */ :10]
+	_ = a[: /* ERROR "middle index required" */ : /* ERROR "final index required" */ ]
+	_ = a[0: /* ERROR "middle index required" */ : /* ERROR "final index required" */ ]
+	_ = a[0: /* ERROR "middle index required" */ :10]
 	_ = a[:10:10]
 
 	var a0 int
@@ -86,7 +87,7 @@ func indexes() {
 	_ = s[: 1 /* ERROR "overflows" */ <<100]
 	_ = s[1 /* ERROR "overflows" */ <<100 :]
 	_ = s[1 /* ERROR "overflows" */ <<100 : 1 /* ERROR "overflows" */ <<100]
-	_ = s[: /* ERROR "2nd index required" */ :  /* ERROR "3rd index required" */ ]
+	_ = s[: /* ERROR "middle index required" */ :  /* ERROR "final index required" */ ]
 	_ = s[:10:10]
 	_ = s[10:0:10] /* ERROR "invalid slice indices" */
 	_ = s[0:10:0] /* ERROR "invalid slice indices" */
@@ -143,6 +144,10 @@ func indexes() {
 	ms = "foo" /* ERROR "cannot use .* in assignment" */ [1:2]
 	ms = "foo" /* ERROR "cannot use .* in assignment" */ [i:j]
 	_, _ = ss, ms
+
+	// With type parameters, index expressions may have multiple indices.
+	_ = a[i, j /* ERROR "more than one index" */ ]
+	_ = a[i, j /* ERROR "more than one index" */ , j]
 }
 
 type T struct {
@@ -491,26 +496,26 @@ func _calls() {
 	f1(0)
 	f1(x)
 	f1(10.0)
-	f1() /* ERROR "too few arguments" */
+	f1() /* ERROR "not enough arguments" */
 	f1(x, y /* ERROR "too many arguments" */ )
 	f1(s /* ERROR "cannot use .* in argument" */ )
 	f1(x ... /* ERROR "cannot use ..." */ )
 	f1(g0 /* ERROR "used as value" */ ())
 	f1(g1())
-	f1(g2 /* ERROR "cannot use g2" */ /* ERROR "too many arguments" */ ())
+	f1(g2 /* ERROR "too many arguments" */ ())
 
-	f2() /* ERROR "too few arguments" */
-	f2(3.14) /* ERROR "too few arguments" */
+	f2() /* ERROR "not enough arguments" */
+	f2(3.14) /* ERROR "not enough arguments" */
 	f2(3.14, "foo")
 	f2(x /* ERROR "cannot use .* in argument" */ , "foo")
 	f2(g0 /* ERROR "used as value" */ ())
-	f2(g1 /* ERROR "cannot use .* in argument" */ ()) /* ERROR "too few arguments" */
+	f2(g1()) /* ERROR "not enough arguments" */
 	f2(g2())
 
-	fs() /* ERROR "too few arguments" */
+	fs() /* ERROR "not enough arguments" */
 	fs(g0 /* ERROR "used as value" */ ())
 	fs(g1 /* ERROR "cannot use .* in argument" */ ())
-	fs(g2 /* ERROR "cannot use .* in argument" */ /* ERROR "too many arguments" */ ())
+	fs(g2 /* ERROR "too many arguments" */ ())
 	fs(gs())
 
 	fv()
@@ -518,7 +523,7 @@ func _calls() {
 	fv(s /* ERROR "cannot use .* in argument" */ )
 	fv(s...)
 	fv(x /* ERROR "cannot use" */ ...)
-	fv(1, s... /* ERROR "can only use ... with matching parameter" */ )
+	fv(1, s /* ERROR "too many arguments" */ ... )
 	fv(gs /* ERROR "cannot use .* in argument" */ ())
 	fv(gs /* ERROR "cannot use .* in argument" */ ()...)
 
@@ -527,7 +532,7 @@ func _calls() {
 	t.fm(1, 2.0, x)
 	t.fm(s /* ERROR "cannot use .* in argument" */ )
 	t.fm(g1())
-	t.fm(1, s... /* ERROR "can only use ... with matching parameter" */ )
+	t.fm(1, s /* ERROR "too many arguments" */ ... )
 	t.fm(gs /* ERROR "cannot use .* in argument" */ ())
 	t.fm(gs /* ERROR "cannot use .* in argument" */ ()...)
 
@@ -535,7 +540,7 @@ func _calls() {
 	T.fm(t, 1, 2.0, x)
 	T.fm(t, s /* ERROR "cannot use .* in argument" */ )
 	T.fm(t, g1())
-	T.fm(t, 1, s... /* ERROR "can only use ... with matching parameter" */ )
+	T.fm(t, 1, s /* ERROR "too many arguments" */ ... )
 	T.fm(t, gs /* ERROR "cannot use .* in argument" */ ())
 	T.fm(t, gs /* ERROR "cannot use .* in argument" */ ()...)
 
@@ -544,7 +549,7 @@ func _calls() {
 	i.fm(1, 2.0, x)
 	i.fm(s /* ERROR "cannot use .* in argument" */ )
 	i.fm(g1())
-	i.fm(1, s... /* ERROR "can only use ... with matching parameter" */ )
+	i.fm(1, s /* ERROR "too many arguments" */ ... )
 	i.fm(gs /* ERROR "cannot use .* in argument" */ ())
 	i.fm(gs /* ERROR "cannot use .* in argument" */ ()...)
 
diff --git a/src/cmd/compile/internal/types2/testdata/importdecl0/importdecl0a.src b/src/cmd/compile/internal/types2/testdata/importdecl0/importdecl0a.src
new file mode 100644
index 0000000000..e96fca3cdd
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/importdecl0/importdecl0a.src
@@ -0,0 +1,53 @@
+// Copyright 2013 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 importdecl0
+
+import ()
+
+import (
+	// we can have multiple blank imports (was bug)
+	_ "math"
+	_ "net/rpc"
+	init /* ERROR "cannot declare init" */ "fmt"
+	// reflect defines a type "flag" which shows up in the gc export data
+	"reflect"
+	. /* ERROR "imported but not used" */ "reflect"
+)
+
+import "math" /* ERROR "imported but not used" */
+import m /* ERROR "imported but not used as m" */ "math"
+import _ "math"
+
+import (
+	"math/big" /* ERROR "imported but not used" */
+	b /* ERROR "imported but not used" */ "math/big"
+	_ "math/big"
+)
+
+import "fmt"
+import f1 "fmt"
+import f2 "fmt"
+
+// reflect.flag must not be visible in this package
+type flag int
+type _ reflect.flag /* ERROR "not exported" */
+
+// imported package name may conflict with local objects
+type reflect /* ERROR "reflect already declared" */ int
+
+// dot-imported exported objects may conflict with local objects
+type Value /* ERROR "Value already declared through dot-import of package reflect" */ struct{}
+
+var _ = fmt.Println // use "fmt"
+
+func _() {
+	f1.Println() // use "fmt"
+}
+
+func _() {
+	_ = func() {
+		f2.Println() // use "fmt"
+	}
+}
diff --git a/src/cmd/compile/internal/types2/testdata/importdecl0/importdecl0b.src b/src/cmd/compile/internal/types2/testdata/importdecl0/importdecl0b.src
new file mode 100644
index 0000000000..48ecb5e46f
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/importdecl0/importdecl0b.src
@@ -0,0 +1,30 @@
+// Copyright 2013 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 importdecl0
+
+import "math"
+import m "math"
+
+import . "testing" // declares T in file scope
+import . /* ERROR "imported but not used" */ "unsafe"
+import . "fmt"     // declares Println in file scope
+
+import (
+	"" /* ERROR invalid import path */
+	"a!b" /* ERROR invalid import path */
+	"abc\xffdef" /* ERROR invalid import path */
+)
+
+// using "math" in this file doesn't affect its use in other files
+const Pi0 = math.Pi
+const Pi1 = m.Pi
+
+type _ T // use "testing"
+
+func _() func() interface{} {
+	return func() interface{} {
+		return Println // use "fmt"
+	}
+}
diff --git a/src/cmd/compile/internal/types2/testdata/importdecl1/importdecl1a.src b/src/cmd/compile/internal/types2/testdata/importdecl1/importdecl1a.src
new file mode 100644
index 0000000000..d377c01638
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/importdecl1/importdecl1a.src
@@ -0,0 +1,22 @@
+// Copyright 2014 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.
+
+// Test case for issue 8969.
+
+package importdecl1
+
+import "go/ast"
+import . "unsafe"
+
+var _ Pointer // use dot-imported package unsafe
+
+// Test cases for issue 23914.
+
+type A interface {
+	// Methods m1, m2 must be type-checked in this file scope
+	// even when embedded in an interface in a different
+	// file of the same package.
+	m1() ast.Node
+	m2() Pointer
+}
diff --git a/src/cmd/compile/internal/types2/testdata/importdecl1/importdecl1b.src b/src/cmd/compile/internal/types2/testdata/importdecl1/importdecl1b.src
new file mode 100644
index 0000000000..ee70bbd8e7
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/importdecl1/importdecl1b.src
@@ -0,0 +1,11 @@
+// Copyright 2014 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 importdecl1
+
+import . /* ERROR "imported but not used" */ "unsafe"
+
+type B interface {
+	A
+}
diff --git a/src/cmd/compile/internal/types2/testdata/issue25008/issue25008a.src b/src/cmd/compile/internal/types2/testdata/issue25008/issue25008a.src
new file mode 100644
index 0000000000..cf71ca10e4
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/issue25008/issue25008a.src
@@ -0,0 +1,15 @@
+// Copyright 2018 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 p
+
+import "io"
+
+type A interface {
+        io.Reader
+}
+
+func f(a A) {
+        a.Read(nil)
+}
diff --git a/src/cmd/compile/internal/types2/testdata/issue25008/issue25008b.src b/src/cmd/compile/internal/types2/testdata/issue25008/issue25008b.src
new file mode 100644
index 0000000000..f132b7fab3
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/issue25008/issue25008b.src
@@ -0,0 +1,9 @@
+// Copyright 2018 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 p
+
+type B interface {
+    A
+}
diff --git a/src/cmd/compile/internal/types2/testdata/issues.src b/src/cmd/compile/internal/types2/testdata/issues.src
index 4944f6f618..1bfc7fec75 100644
--- a/src/cmd/compile/internal/types2/testdata/issues.src
+++ b/src/cmd/compile/internal/types2/testdata/issues.src
@@ -325,8 +325,8 @@ func issue28281c(a, b, c ... /* ERROR can only use ... with final parameter */ i
 func issue28281d(... /* ERROR can only use ... with final parameter */ int, int)
 func issue28281e(a, b, c  ... /* ERROR can only use ... with final parameter */ int, d int)
 func issue28281f(... /* ERROR can only use ... with final parameter */ int, ... /* ERROR can only use ... with final parameter */ int, int)
-func (... /* ERROR expected type */ TT) f()
-func issue28281g() (... /* ERROR expected type */ TT)
+func (... /* ERROR can only use ... with final parameter in list */ TT) f()
+func issue28281g() (... /* ERROR can only use ... with final parameter in list */ TT)
 
 // Issue #26234: Make various field/method lookup errors easier to read by matching cmd/compile's output
 func issue26234a(f *syn.File) {
diff --git a/src/cmd/compile/internal/types2/testdata/shifts.src b/src/cmd/compile/internal/types2/testdata/shifts.src
index c9a38ae169..04a679f5bb 100644
--- a/src/cmd/compile/internal/types2/testdata/shifts.src
+++ b/src/cmd/compile/internal/types2/testdata/shifts.src
@@ -193,14 +193,15 @@ func shifts6() {
 	_ = float32(1.0 /* ERROR "must be integer" */ <<s)
 	_ = float32(1.1 /* ERROR "must be integer" */ <<s)
 
-	_ = int32(0x80000000 /* ERROR "overflows int32" */ << s)
+	// TODO(gri) port fixes from go/types
+	// _ = int32(0x80000000 /* ERROR "overflows int32" */ << s)
 	// TODO(rfindley) Eliminate the redundant error here.
-	_ = int32(( /* ERROR "truncated to int32" */ 0x80000000 /* ERROR "truncated to int32" */ + 0i) << s)
+	// _ = int32(( /* ERROR "truncated to int32" */ 0x80000000 /* ERROR "truncated to int32" */ + 0i) << s)
 
 	_ = int(1+0i<<0)
-	_ = int((1+0i)<<s)
-	_ = int(1.0<<s)
-	_ = int(complex(1, 0)<<s)
+	// _ = int((1+0i)<<s)
+	// _ = int(1.0<<s)
+	// _ = int(complex(1, 0)<<s)
 	_ = int(float32/* ERROR "must be integer" */(1.0) <<s)
 	_ = int(1.1 /* ERROR must be integer */ <<s)
 	_ = int(( /* ERROR "must be integer" */ 1+1i)  <<s)
diff --git a/src/cmd/compile/internal/types2/testdata/stmt0.src b/src/cmd/compile/internal/types2/testdata/stmt0.src
index 446997ac09..959f7d5659 100644
--- a/src/cmd/compile/internal/types2/testdata/stmt0.src
+++ b/src/cmd/compile/internal/types2/testdata/stmt0.src
@@ -86,7 +86,7 @@ func assignments1() {
 
 	g := func(int, bool){}
 	var m map[int]int
-	g(m[0]) /* ERROR "too few arguments" */
+	g(m[0]) /* ERROR "not enough arguments" */
 
 	// assignments to _
 	_ = nil /* ERROR "use of untyped nil" */
@@ -229,7 +229,7 @@ func selects() {
 }
 
 func gos() {
-	go 1 /* ERROR HERE "function must be invoked" */
+	go 1 /* ERROR must be function call */ /* ERROR cannot call non-function */
 	go int /* ERROR "go requires function call, not conversion" */ (0)
 	go gos()
 	var c chan int
@@ -238,7 +238,7 @@ func gos() {
 }
 
 func defers() {
-	defer 1 /* ERROR HERE "function must be invoked" */
+	defer 1 /* ERROR must be function call */ /* ERROR cannot call non-function */
 	defer int /* ERROR "defer requires function call, not conversion" */ (0)
 	defer defers()
 	var c chan int
@@ -886,7 +886,7 @@ func rangeloops1() {
 		ee = e
 		_ = ee
 	}
-	for _ = range sc /* ERROR "cannot range over send-only channel" */ {}
+	for _ = range sc /* ERROR "send-only channel" */ {}
 	for _ = range rc {}
 
 	// constant strings
diff --git a/src/cmd/compile/internal/types2/testdata/vardecl.src b/src/cmd/compile/internal/types2/testdata/vardecl.src
index 54f5ef1e10..d8980f2ede 100644
--- a/src/cmd/compile/internal/types2/testdata/vardecl.src
+++ b/src/cmd/compile/internal/types2/testdata/vardecl.src
@@ -14,12 +14,9 @@ var m map[string]int
 var _ int
 var _, _ int
 
-// The first error message is produced by the parser.
-// In a real-world scenario, the type-checker would not be run
-// in this case and the 2nd error message would not appear.
-var _ /* ERROR "missing variable type" */ /* ERROR "missing type or init expr" */
-var _ /* ERROR "missing variable type" */ /* ERROR "missing type or init expr" */, _
-var _ /* ERROR "missing variable type" */ /* ERROR "missing type or init expr" */, _, _
+var _ /* ERROR "expecting type" */
+var _, _ /* ERROR "expecting type" */
+var _, _, _ /* ERROR "expecting type" */
 
 // The initializer must be an expression.
 var _ = int /* ERROR "not an expression" */
-- 
GitLab


From 755d6de1d8cf9d7fff3a64eac30090cdfebe7c14 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 19 Oct 2020 21:49:57 -0700
Subject: [PATCH 0012/2400] [dev.typeparams] cmd/compile/internal/types2: add
 some more tests

Change-Id: I36fce5462d11dd2e8fc9a619118c6a63eed4980a
Reviewed-on: https://go-review.googlesource.com/c/go/+/263633
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 .../internal/types2/testdata/issue23203a.src  | 14 ++++
 .../internal/types2/testdata/issue23203b.src  | 14 ++++
 .../internal/types2/testdata/issue26390.src   | 11 +++
 .../internal/types2/testdata/issue28251.src   | 65 +++++++++++++++
 .../internal/types2/testdata/issue6977.src    | 82 +++++++++++++++++++
 5 files changed, 186 insertions(+)
 create mode 100644 src/cmd/compile/internal/types2/testdata/issue23203a.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/issue23203b.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/issue26390.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/issue28251.src
 create mode 100644 src/cmd/compile/internal/types2/testdata/issue6977.src

diff --git a/src/cmd/compile/internal/types2/testdata/issue23203a.src b/src/cmd/compile/internal/types2/testdata/issue23203a.src
new file mode 100644
index 0000000000..48cb5889cd
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/issue23203a.src
@@ -0,0 +1,14 @@
+// Copyright 2018 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 "unsafe"
+
+type T struct{}
+
+func (T) m1()                         {}
+func (T) m2([unsafe.Sizeof(T.m1)]int) {}
+
+func main() {}
diff --git a/src/cmd/compile/internal/types2/testdata/issue23203b.src b/src/cmd/compile/internal/types2/testdata/issue23203b.src
new file mode 100644
index 0000000000..638ec6c5ce
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/issue23203b.src
@@ -0,0 +1,14 @@
+// Copyright 2018 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 "unsafe"
+
+type T struct{}
+
+func (T) m2([unsafe.Sizeof(T.m1)]int) {}
+func (T) m1()                         {}
+
+func main() {}
diff --git a/src/cmd/compile/internal/types2/testdata/issue26390.src b/src/cmd/compile/internal/types2/testdata/issue26390.src
new file mode 100644
index 0000000000..b8e67e9bdd
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/issue26390.src
@@ -0,0 +1,11 @@
+// Copyright 2018 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 issue26390
+
+type A = T
+
+func (t *T) m() *A { return t }
+
+type T struct{}
diff --git a/src/cmd/compile/internal/types2/testdata/issue28251.src b/src/cmd/compile/internal/types2/testdata/issue28251.src
new file mode 100644
index 0000000000..cd79e0e8b5
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/issue28251.src
@@ -0,0 +1,65 @@
+// Copyright 2018 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.
+
+// This file contains test cases for various forms of
+// method receiver declarations, per the spec clarification
+// https://golang.org/cl/142757.
+
+package issue28251
+
+// test case from issue28251
+type T struct{}
+
+type T0 = *T
+
+func (T0) m() {}
+
+func _() { (&T{}).m() }
+
+// various alternative forms
+type (
+        T1 = (((T)))
+)
+
+func ((*(T1))) m1() {}
+func _() { (T{}).m2() }
+func _() { (&T{}).m2() }
+
+type (
+        T2 = (((T3)))
+        T3 = T
+)
+
+func (T2) m2() {}
+func _() { (T{}).m2() }
+func _() { (&T{}).m2() }
+
+type (
+        T4 = ((*(T5)))
+        T5 = T
+)
+
+func (T4) m4() {}
+func _() { (T{}).m4 /* ERROR "cannot call pointer method m4 on T" */ () }
+func _() { (&T{}).m4() }
+
+type (
+        T6 = (((T7)))
+        T7 = (*(T8))
+        T8 = T
+)
+
+func (T6) m6() {}
+func _() { (T{}).m6 /* ERROR "cannot call pointer method m6 on T" */ () }
+func _() { (&T{}).m6() }
+
+type (
+        T9 = *T10
+        T10 = *T11
+        T11 = T
+)
+
+func (T9 /* ERROR invalid receiver \*\*T */ ) m9() {}
+func _() { (T{}).m9 /* ERROR has no field or method m9 */ () }
+func _() { (&T{}).m9 /* ERROR has no field or method m9 */ () }
diff --git a/src/cmd/compile/internal/types2/testdata/issue6977.src b/src/cmd/compile/internal/types2/testdata/issue6977.src
new file mode 100644
index 0000000000..8f4e9ba2b2
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/issue6977.src
@@ -0,0 +1,82 @@
+// Copyright 2019 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 p
+
+import "io"
+
+// Alan's initial report.
+
+type I interface { f(); String() string }
+type J interface { g(); String() string }
+
+type IJ1 = interface { I; J }
+type IJ2 = interface { f(); g(); String() string }
+
+var _ = (*IJ1)(nil) == (*IJ2)(nil) // static assert that IJ1 and IJ2 are identical types
+
+// The canonical example.
+
+type ReadWriteCloser interface { io.ReadCloser; io.WriteCloser }
+
+// Some more cases.
+
+type M interface { m() }
+type M32 interface { m() int32 }
+type M64 interface { m() int64 }
+
+type U1 interface { m() }
+type U2 interface { m(); M }
+type U3 interface { M; m() }
+type U4 interface { M; M; M }
+type U5 interface { U1; U2; U3; U4 }
+
+type U6 interface { m(); m /* ERROR duplicate method */ () }
+type U7 interface { M32 /* ERROR duplicate method */ ; m() }
+type U8 interface { m(); M32 /* ERROR duplicate method */ }
+type U9 interface { M32; M64 /* ERROR duplicate method */ }
+
+// Verify that repeated embedding of the same interface(s)
+// eliminates duplicate methods early (rather than at the
+// end) to prevent exponential memory and time use.
+// Without early elimination, computing T29 may take dozens
+// of minutes.
+type (
+        T0 interface { m() }
+        T1 interface { T0; T0 }
+        T2 interface { T1; T1 }
+        T3 interface { T2; T2 }
+        T4 interface { T3; T3 }
+        T5 interface { T4; T4 }
+        T6 interface { T5; T5 }
+        T7 interface { T6; T6 }
+        T8 interface { T7; T7 }
+        T9 interface { T8; T8 }
+
+        T10 interface { T9; T9 }
+        T11 interface { T10; T10 }
+        T12 interface { T11; T11 }
+        T13 interface { T12; T12 }
+        T14 interface { T13; T13 }
+        T15 interface { T14; T14 }
+        T16 interface { T15; T15 }
+        T17 interface { T16; T16 }
+        T18 interface { T17; T17 }
+        T19 interface { T18; T18 }
+
+        T20 interface { T19; T19 }
+        T21 interface { T20; T20 }
+        T22 interface { T21; T21 }
+        T23 interface { T22; T22 }
+        T24 interface { T23; T23 }
+        T25 interface { T24; T24 }
+        T26 interface { T25; T25 }
+        T27 interface { T26; T26 }
+        T28 interface { T27; T27 }
+        T29 interface { T28; T28 }
+)
+
+// Verify that m is present.
+var x T29
+var _ = x.m
-- 
GitLab


From 7a8a720c800bb296c9f23a4c91bf2005f3221a93 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 19 Oct 2020 21:41:37 -0700
Subject: [PATCH 0013/2400] [dev.typeparams] cmd/compile/internal/types2: add
 *.go2 (generic) tests

Change-Id: I33453736ac05cd7c2e666b280974719c734701fa
Reviewed-on: https://go-review.googlesource.com/c/go/+/263632
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 .../internal/types2/testdata/builtins.go2     |  53 +++
 .../internal/types2/testdata/chans.go2        |  62 +++
 .../internal/types2/testdata/issues.go2       | 249 +++++++++++
 .../internal/types2/testdata/linalg.go2       |  83 ++++
 .../compile/internal/types2/testdata/map.go2  | 113 +++++
 .../compile/internal/types2/testdata/map2.go2 | 146 ++++++
 .../internal/types2/testdata/mtypeparams.go2  |  52 +++
 .../internal/types2/testdata/slices.go2       |  68 +++
 .../internal/types2/testdata/tinference.go2   | 105 +++++
 .../compile/internal/types2/testdata/tmp.go2  |  17 +
 .../internal/types2/testdata/typeinst.go2     |  59 +++
 .../internal/types2/testdata/typeinst2.go2    | 256 +++++++++++
 .../internal/types2/testdata/typeparams.go2   | 422 ++++++++++++++++++
 13 files changed, 1685 insertions(+)
 create mode 100644 src/cmd/compile/internal/types2/testdata/builtins.go2
 create mode 100644 src/cmd/compile/internal/types2/testdata/chans.go2
 create mode 100644 src/cmd/compile/internal/types2/testdata/issues.go2
 create mode 100644 src/cmd/compile/internal/types2/testdata/linalg.go2
 create mode 100644 src/cmd/compile/internal/types2/testdata/map.go2
 create mode 100644 src/cmd/compile/internal/types2/testdata/map2.go2
 create mode 100644 src/cmd/compile/internal/types2/testdata/mtypeparams.go2
 create mode 100644 src/cmd/compile/internal/types2/testdata/slices.go2
 create mode 100644 src/cmd/compile/internal/types2/testdata/tinference.go2
 create mode 100644 src/cmd/compile/internal/types2/testdata/tmp.go2
 create mode 100644 src/cmd/compile/internal/types2/testdata/typeinst.go2
 create mode 100644 src/cmd/compile/internal/types2/testdata/typeinst2.go2
 create mode 100644 src/cmd/compile/internal/types2/testdata/typeparams.go2

diff --git a/src/cmd/compile/internal/types2/testdata/builtins.go2 b/src/cmd/compile/internal/types2/testdata/builtins.go2
new file mode 100644
index 0000000000..3918d836b5
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/builtins.go2
@@ -0,0 +1,53 @@
+// Copyright 2020 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.
+
+// This file tests built-in calls on generic types.
+
+package builtins
+
+type Bmc interface {
+	type map[rune]string, chan int
+}
+
+type Bms interface {
+	type map[string]int, []int
+}
+
+type Bcs interface {
+	type chan bool, []float64
+}
+
+type Bss interface {
+	type []int, []string
+}
+
+func _[T any] () {
+	_ = make(T /* ERROR invalid argument */ )
+	_ = make(T /* ERROR invalid argument */ , 10)
+	_ = make(T /* ERROR invalid argument */ , 10, 20)
+}
+
+func _[T Bmc] () {
+	_ = make(T)
+	_ = make(T, 10)
+	_ = make /* ERROR expects 1 or 2 arguments */ (T, 10, 20)
+}
+
+func _[T Bms] () {
+	_ = make /* ERROR expects 2 arguments */ (T)
+	_ = make(T, 10)
+	_ = make /* ERROR expects 2 arguments */ (T, 10, 20)
+}
+
+func _[T Bcs] () {
+	_ = make /* ERROR expects 2 arguments */ (T)
+	_ = make(T, 10)
+	_ = make /* ERROR expects 2 arguments */ (T, 10, 20)
+}
+
+func _[T Bss] () {
+	_ = make /* ERROR expects 2 or 3 arguments */ (T)
+	_ = make(T, 10)
+	_ = make(T, 10, 20)
+}
diff --git a/src/cmd/compile/internal/types2/testdata/chans.go2 b/src/cmd/compile/internal/types2/testdata/chans.go2
new file mode 100644
index 0000000000..fad2bcec9d
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/chans.go2
@@ -0,0 +1,62 @@
+package chans
+
+import "runtime"
+
+// Ranger returns a Sender and a Receiver. The Receiver provides a
+// Next method to retrieve values. The Sender provides a Send method
+// to send values and a Close method to stop sending values. The Next
+// method indicates when the Sender has been closed, and the Send
+// method indicates when the Receiver has been freed.
+//
+// This is a convenient way to exit a goroutine sending values when
+// the receiver stops reading them.
+func Ranger[T any]() (*Sender[T], *Receiver[T]) {
+	c := make(chan T)
+	d := make(chan bool)
+	s := &Sender[T]{values: c, done: d}
+	r := &Receiver[T]{values: c, done: d}
+	runtime.SetFinalizer(r, r.finalize)
+	return s, r
+}
+
+// A sender is used to send values to a Receiver.
+type Sender[T any] struct {
+	values chan<- T
+	done <-chan bool
+}
+
+// Send sends a value to the receiver. It returns whether any more
+// values may be sent; if it returns false the value was not sent.
+func (s *Sender[T]) Send(v T) bool {
+	select {
+	case s.values <- v:
+		return true
+	case <-s.done:
+		return false
+	}
+}
+
+// Close tells the receiver that no more values will arrive.
+// After Close is called, the Sender may no longer be used.
+func (s *Sender[T]) Close() {
+	close(s.values)
+}
+
+// A Receiver receives values from a Sender.
+type Receiver[T any] struct {
+	values <-chan T
+	done chan<- bool
+}
+
+// Next returns the next value from the channel. The bool result
+// indicates whether the value is valid, or whether the Sender has
+// been closed and no more values will be received.
+func (r *Receiver[T]) Next() (T, bool) {
+	v, ok := <-r.values
+	return v, ok
+}
+
+// finalize is a finalizer for the receiver.
+func (r *Receiver[T]) finalize() {
+	close(r.done)
+}
diff --git a/src/cmd/compile/internal/types2/testdata/issues.go2 b/src/cmd/compile/internal/types2/testdata/issues.go2
new file mode 100644
index 0000000000..1c73b5da92
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/issues.go2
@@ -0,0 +1,249 @@
+// Copyright 2020 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.
+
+// This file contains regression tests for bugs found.
+
+package p
+
+import "io"
+import "context"
+
+// Interfaces are always comparable (though the comparison may panic at runtime).
+func eql[T comparable](x, y T) bool {
+	return x == y
+}
+
+func _() {
+	var x interface{}
+	var y interface{ m() }
+	eql(x, y /* ERROR does not match */ ) // interfaces of different types
+	eql(x, x)
+	eql(y, y)
+	eql(y, nil)
+	eql[io.Reader](nil, nil)
+}
+
+// If we have a receiver of pointer type (below: *T) we must ignore
+// the pointer in the implementation of the method lookup because
+// the type bound of T is an interface and pointer to interface types
+// have no methods and then the lookup would fail.
+type C[T any] interface {
+    m()
+}
+
+// using type bound C
+func _[T C[T]](x *T) {
+	x.m()
+}
+
+// using an interface literal as bound
+func _[T interface{ m() }](x *T) {
+	x.m()
+}
+
+func f2[_ interface{ m1(); m2() }]()
+
+type T struct{}
+func (T) m1()
+func (*T) m2()
+
+func _() {
+	f2[T /* ERROR wrong method signature */ ]()
+	f2[*T]()
+}
+
+// When a type parameter is used as an argument to instantiate a parameterized
+// type with a type list constraint, all of the type argument's types in its
+// bound, but at least one (!), must be in the type list of the bound of the
+// corresponding parameterized type's type parameter.
+type T1[P interface{type uint}] struct{}
+
+func _[P any]() {
+    _ = T1[P /* ERROR P has no type constraints */ ]{}
+}
+
+// This is the original (simplified) program causing the same issue.
+type Unsigned interface {
+	type uint
+}
+
+type T2[U Unsigned] struct {
+    s U
+}
+
+func (u T2[U]) Add1() U {
+    return u.s + 1
+}
+
+func NewT2[U any]() T2[U /* ERROR U has no type constraints */ ] {
+    return T2[U /* ERROR U has no type constraints */ ]{}
+}
+
+func _() {
+    u := NewT2[string]()
+    _ = u.Add1()
+}
+
+// When we encounter an instantiated type such as Elem[T] we must
+// not "expand" the instantiation when the type to be instantiated
+// (Elem in this case) is not yet fully set up.
+type Elem[T any] struct {
+	next *Elem[T]
+	list *List[T]
+}
+
+type List[T any] struct {
+	root Elem[T]
+}
+
+func (l *List[T]) Init() {
+	l.root.next = &l.root
+}
+
+// This is the original program causing the same issue.
+type Element2[TElem any] struct {
+	next, prev *Element2[TElem]
+	list *List2[TElem]
+	Value TElem
+}
+
+type List2[TElem any] struct {
+	root Element2[TElem]
+	len  int
+}
+
+func (l *List2[TElem]) Init() *List2[TElem] {
+	l.root.next = &l.root
+	l.root.prev = &l.root
+	l.len = 0
+	return l
+}
+
+// Self-recursive instantiations must work correctly.
+type A[P any] struct { _ *A[P] }
+
+type AB[P any] struct { _ *BA[P] }
+type BA[P any] struct { _ *AB[P] }
+
+// And a variation that also caused a problem with an
+// unresolved underlying type.
+type Element3[TElem any] struct {
+	next, prev *Element3[TElem]
+	list *List3[TElem]
+	Value TElem
+}
+
+func (e *Element3[TElem]) Next() *Element3[TElem] {
+	if p := e.next; e.list != nil && p != &e.list.root {
+		return p
+	}
+	return nil
+}
+
+type List3[TElem any] struct {
+	root Element3[TElem]
+	len  int
+}
+
+// Infinite generic type declarations must lead to an error.
+type inf1[T any] struct{ _ inf1 /* ERROR illegal cycle */ [T] }
+type inf2[T any] struct{ inf2 /* ERROR illegal cycle */ [T] }
+
+// The implementation of conversions T(x) between integers and floating-point
+// numbers checks that both T and x have either integer or floating-point
+// type. When the type of T or x is a type parameter, the respective simple
+// predicate disjunction in the implementation was wrong because if a type list
+// contains both an integer and a floating-point type, the type parameter is
+// neither an integer or a floating-point number.
+func convert[T1, T2 interface{type int, uint, float32}](v T1) T2 {
+	return T2(v)
+}
+
+func _() {
+	convert[int, uint](5)
+}
+
+// When testing binary operators, for +, the operand types must either be
+// both numeric, or both strings. The implementation had the same problem
+// with this check as the conversion issue above (issue #39623).
+
+func issue39623[T interface{type int, string}](x, y T) T {
+	return x + y
+}
+
+// Simplified, from https://go2goplay.golang.org/p/efS6x6s-9NI:
+func Sum[T interface{type int, string}](s []T) (sum T) {
+	for _, v := range s {
+		sum += v
+	}
+	return
+}
+
+// Assignability of an unnamed pointer type to a type parameter that
+// has a matching underlying type.
+func _[T interface{}, PT interface{type *T}] (x T) PT {
+    return &x
+}
+
+// Indexing of generic types containing type parameters in their type list:
+func at[T interface{ type []E }, E interface{}](x T, i int) E {
+        return x[i]
+}
+
+// A generic type inside a function acts like a named type. Its underlying
+// type is itself, its "operational type" is defined by the type list in
+// the tybe bound, if any.
+func _[T interface{type int}](x T) {
+	type myint int
+	var _ int = int(x)
+	var _ T = 42
+	var _ T = T(myint(42))
+}
+
+// Indexing a generic type with an array type bound checks length.
+// (Example by mdempsky@.)
+func _[T interface { type [10]int }](x T) {
+	_ = x[9] // ok
+	_ = x[20 /* ERROR out of bounds */ ]
+}
+
+// Pointer indirection of a generic type.
+func _[T interface{ type *int }](p T) int {
+	return *p
+}
+
+// Channel sends and receives on generic types.
+func _[T interface{ type chan int }](ch T) int {
+	ch <- 0
+	return <- ch
+}
+
+// Calling of a generic variable.
+func _[T interface{ type func() }](f T) {
+	f()
+	go f()
+}
+
+// We must compare against the underlying type of type list entries
+// when checking if a constraint is satisfied by a type. The under-
+// lying type of each type list entry must be computed after the
+// interface has been instantiated as its typelist may contain a
+// type parameter that was substituted with a defined type.
+// Test case from an (originally) failing example.
+
+type sliceOf[E any] interface{ type []E }
+
+func append[T interface{}, S sliceOf[T], T2 interface{ type T }](s S, t ...T2) S
+
+var f           func()
+var cancelSlice []context.CancelFunc
+var _ = append[context.CancelFunc, []context.CancelFunc, context.CancelFunc](cancelSlice, f)
+
+// A generic function must be instantiated with a type, not a value.
+
+func g[T any](T) T
+
+var _ = g[int]
+var _ = g[nil /* ERROR is not a type */ ]
+var _ = g(0)
diff --git a/src/cmd/compile/internal/types2/testdata/linalg.go2 b/src/cmd/compile/internal/types2/testdata/linalg.go2
new file mode 100644
index 0000000000..0d27603a58
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/linalg.go2
@@ -0,0 +1,83 @@
+// Copyright 2019 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 linalg
+
+import "math"
+
+// Numeric is type bound that matches any numeric type.
+// It would likely be in a constraints package in the standard library.
+type Numeric interface {
+	type int, int8, int16, int32, int64,
+		uint, uint8, uint16, uint32, uint64, uintptr,
+		float32, float64,
+		complex64, complex128
+}
+
+func DotProduct[T Numeric](s1, s2 []T) T {
+	if len(s1) != len(s2) {
+		panic("DotProduct: slices of unequal length")
+	}
+	var r T
+	for i := range s1 {
+		r += s1[i] * s2[i]
+	}
+	return r
+}
+
+// NumericAbs matches numeric types with an Abs method.
+type NumericAbs[T any] interface {
+	Numeric
+
+	Abs() T
+}
+
+// AbsDifference computes the absolute value of the difference of
+// a and b, where the absolute value is determined by the Abs method.
+func AbsDifference[T NumericAbs[T]](a, b T) T {
+	d := a - b
+	return d.Abs()
+}
+
+// OrderedNumeric is a type bound that matches numeric types that support the < operator.
+type OrderedNumeric interface {
+	type int, int8, int16, int32, int64,
+		uint, uint8, uint16, uint32, uint64, uintptr,
+		float32, float64
+}
+
+// Complex is a type bound that matches the two complex types, which do not have a < operator.
+type Complex interface {
+	type complex64, complex128
+}
+
+// OrderedAbs is a helper type that defines an Abs method for
+// ordered numeric types.
+type OrderedAbs[T OrderedNumeric] T
+
+func (a OrderedAbs[T]) Abs() OrderedAbs[T] {
+	if a < 0 {
+		return -a
+	}
+	return a
+}
+
+// ComplexAbs is a helper type that defines an Abs method for
+// complex types.
+type ComplexAbs[T Complex] T
+
+func (a ComplexAbs[T]) Abs() ComplexAbs[T] {
+	r := float64(real(a))
+	i := float64(imag(a))
+	d := math.Sqrt(r * r + i * i)
+	return ComplexAbs[T](complex(d, 0))
+}
+
+func OrderedAbsDifference[T OrderedNumeric](a, b T) T {
+	return T(AbsDifference(OrderedAbs[T](a), OrderedAbs[T](b)))
+}
+
+func ComplexAbsDifference[T Complex](a, b T) T {
+	return T(AbsDifference(ComplexAbs[T](a), ComplexAbs[T](b)))
+}
diff --git a/src/cmd/compile/internal/types2/testdata/map.go2 b/src/cmd/compile/internal/types2/testdata/map.go2
new file mode 100644
index 0000000000..814d9539fd
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/map.go2
@@ -0,0 +1,113 @@
+// Copyright 2019 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 orderedmap provides an ordered map, implemented as a binary tree.
+package orderedmap
+
+// TODO(gri) fix imports for tests
+import "chans" // ERROR could not import
+
+// Map is an ordered map.
+type Map[K, V any] struct {
+	root    *node[K, V]
+	compare func(K, K) int
+}
+
+// node is the type of a node in the binary tree.
+type node[K, V any] struct {
+	key         K
+	val         V
+	left, right *node[K, V]
+}
+
+// New returns a new map.
+func New[K, V any](compare func(K, K) int) *Map[K, V] {
+        return &Map[K, V]{compare: compare}
+}
+
+// find looks up key in the map, and returns either a pointer
+// to the node holding key, or a pointer to the location where
+// such a node would go.
+func (m *Map[K, V]) find(key K) **node[K, V] {
+	pn := &m.root
+	for *pn != nil {
+		switch cmp := m.compare(key, (*pn).key); {
+		case cmp < 0:
+			pn = &(*pn).left
+		case cmp > 0:
+			pn = &(*pn).right
+		default:
+			return pn
+		}
+	}
+	return pn
+}
+
+// Insert inserts a new key/value into the map.
+// If the key is already present, the value is replaced.
+// Returns true if this is a new key, false if already present.
+func (m *Map[K, V]) Insert(key K, val V) bool {
+	pn := m.find(key)
+	if *pn != nil {
+		(*pn).val = val
+		return false
+	}
+        *pn = &node[K, V]{key: key, val: val}
+	return true
+}
+
+// Find returns the value associated with a key, or zero if not present.
+// The found result reports whether the key was found.
+func (m *Map[K, V]) Find(key K) (V, bool) {
+	pn := m.find(key)
+	if *pn == nil {
+		var zero V // see the discussion of zero values, above
+		return zero, false
+	}
+	return (*pn).val, true
+}
+
+// keyValue is a pair of key and value used when iterating.
+type keyValue[K, V any] struct {
+	key K
+	val V
+}
+
+// InOrder returns an iterator that does an in-order traversal of the map.
+func (m *Map[K, V]) InOrder() *Iterator[K, V] {
+	sender, receiver := chans.Ranger[keyValue[K, V]]()
+	var f func(*node[K, V]) bool
+	f = func(n *node[K, V]) bool {
+		if n == nil {
+			return true
+		}
+		// Stop sending values if sender.Send returns false,
+		// meaning that nothing is listening at the receiver end.
+		return f(n.left) &&
+                        sender.Send(keyValue[K, V]{n.key, n.val}) &&
+			f(n.right)
+	}
+	go func() {
+		f(m.root)
+		sender.Close()
+	}()
+	return &Iterator[K, V]{receiver}
+}
+
+// Iterator is used to iterate over the map.
+type Iterator[K, V any] struct {
+	r *chans.Receiver[keyValue[K, V]]
+}
+
+// Next returns the next key and value pair, and a boolean indicating
+// whether they are valid or whether we have reached the end.
+func (it *Iterator[K, V]) Next() (K, V, bool) {
+	keyval, ok := it.r.Next()
+	if !ok {
+		var zerok K
+		var zerov V
+		return zerok, zerov, false
+	}
+	return keyval.key, keyval.val, true
+}
diff --git a/src/cmd/compile/internal/types2/testdata/map2.go2 b/src/cmd/compile/internal/types2/testdata/map2.go2
new file mode 100644
index 0000000000..2833445662
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/map2.go2
@@ -0,0 +1,146 @@
+// Copyright 2019 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.
+
+// This file is like map.go2, but instead if importing chans, it contains
+// the necessary functionality at the end of the file.
+
+// Package orderedmap provides an ordered map, implemented as a binary tree.
+package orderedmap
+
+// Map is an ordered map.
+type Map[K, V any] struct {
+	root    *node[K, V]
+	compare func(K, K) int
+}
+
+// node is the type of a node in the binary tree.
+type node[K, V any] struct {
+	key         K
+	val         V
+	left, right *node[K, V]
+}
+
+// New returns a new map.
+func New[K, V any](compare func(K, K) int) *Map[K, V] {
+        return &Map[K, V]{compare: compare}
+}
+
+// find looks up key in the map, and returns either a pointer
+// to the node holding key, or a pointer to the location where
+// such a node would go.
+func (m *Map[K, V]) find(key K) **node[K, V] {
+	pn := &m.root
+	for *pn != nil {
+		switch cmp := m.compare(key, (*pn).key); {
+		case cmp < 0:
+			pn = &(*pn).left
+		case cmp > 0:
+			pn = &(*pn).right
+		default:
+			return pn
+		}
+	}
+	return pn
+}
+
+// Insert inserts a new key/value into the map.
+// If the key is already present, the value is replaced.
+// Returns true if this is a new key, false if already present.
+func (m *Map[K, V]) Insert(key K, val V) bool {
+	pn := m.find(key)
+	if *pn != nil {
+		(*pn).val = val
+		return false
+	}
+	*pn = &node[K, V]{key: key, val: val}
+	return true
+}
+
+// Find returns the value associated with a key, or zero if not present.
+// The found result reports whether the key was found.
+func (m *Map[K, V]) Find(key K) (V, bool) {
+	pn := m.find(key)
+	if *pn == nil {
+		var zero V // see the discussion of zero values, above
+		return zero, false
+	}
+	return (*pn).val, true
+}
+
+// keyValue is a pair of key and value used when iterating.
+type keyValue[K, V any] struct {
+	key K
+	val V
+}
+
+// InOrder returns an iterator that does an in-order traversal of the map.
+func (m *Map[K, V]) InOrder() *Iterator[K, V] {
+	sender, receiver := chans_Ranger[keyValue[K, V]]()
+	var f func(*node[K, V]) bool
+	f = func(n *node[K, V]) bool {
+		if n == nil {
+			return true
+		}
+		// Stop sending values if sender.Send returns false,
+		// meaning that nothing is listening at the receiver end.
+		return f(n.left) &&
+                        sender.Send(keyValue[K, V]{n.key, n.val}) &&
+			f(n.right)
+	}
+	go func() {
+		f(m.root)
+		sender.Close()
+	}()
+	return &Iterator[K, V]{receiver}
+}
+
+// Iterator is used to iterate over the map.
+type Iterator[K, V any] struct {
+	r *chans_Receiver[keyValue[K, V]]
+}
+
+// Next returns the next key and value pair, and a boolean indicating
+// whether they are valid or whether we have reached the end.
+func (it *Iterator[K, V]) Next() (K, V, bool) {
+	keyval, ok := it.r.Next()
+	if !ok {
+		var zerok K
+		var zerov V
+		return zerok, zerov, false
+	}
+	return keyval.key, keyval.val, true
+}
+
+// chans
+
+func chans_Ranger[T any]() (*chans_Sender[T], *chans_Receiver[T])
+
+// A sender is used to send values to a Receiver.
+type chans_Sender[T any] struct {
+	values chan<- T
+	done <-chan bool
+}
+
+func (s *chans_Sender[T]) Send(v T) bool {
+	select {
+	case s.values <- v:
+		return true
+	case <-s.done:
+		return false
+	}
+}
+
+func (s *chans_Sender[T]) Close() {
+	close(s.values)
+}
+
+type chans_Receiver[T any] struct {
+	values <-chan T
+	done chan<- bool
+}
+
+func (r *chans_Receiver[T]) Next() (T, bool) {
+	v, ok := <-r.values
+	return v, ok
+}
\ No newline at end of file
diff --git a/src/cmd/compile/internal/types2/testdata/mtypeparams.go2 b/src/cmd/compile/internal/types2/testdata/mtypeparams.go2
new file mode 100644
index 0000000000..c2f282bae1
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/mtypeparams.go2
@@ -0,0 +1,52 @@
+// Copyright 2020 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.
+
+// If types2.Config.AcceptMethodTypeParams is set,
+// the type checker accepts methods that have their
+// own type parameter list.
+
+package p
+
+type S struct{}
+
+func (S) m[T any](v T)
+
+// TODO(gri) Once we collect interface method type parameters
+//           in the parser, we can enable these tests again.
+/*
+type I interface {
+   m[T any](v T)
+}
+
+type J interface {
+   m[T any](v T)
+}
+
+var _ I = S{}
+var _ I = J(nil)
+
+type C interface{ n() }
+
+type Sc struct{}
+
+func (Sc) m[T C](v T)
+
+type Ic interface {
+   m[T C](v T)
+}
+
+type Jc interface {
+   m[T C](v T)
+}
+
+var _ Ic = Sc{}
+var _ Ic = Jc(nil)
+
+// TODO(gri) These should fail because the constraints don't match.
+var _ I = Sc{}
+var _ I = Jc(nil)
+
+var _ Ic = S{}
+var _ Ic = J(nil)
+*/
\ No newline at end of file
diff --git a/src/cmd/compile/internal/types2/testdata/slices.go2 b/src/cmd/compile/internal/types2/testdata/slices.go2
new file mode 100644
index 0000000000..2bacd1c2aa
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/slices.go2
@@ -0,0 +1,68 @@
+// Copyright 2019 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 slices implements various slice algorithms.
+package slices
+
+// Map turns a []T1 to a []T2 using a mapping function.
+func Map[T1, T2 any](s []T1, f func(T1) T2) []T2 {
+	r := make([]T2, len(s))
+	for i, v := range s {
+		r[i] = f(v)
+	}
+	return r
+}
+
+// Reduce reduces a []T1 to a single value using a reduction function.
+func Reduce[T1, T2 any](s []T1, initializer T2, f func(T2, T1) T2) T2 {
+	r := initializer
+	for _, v := range s {
+		r = f(r, v)
+	}
+	return r
+}
+
+// Filter filters values from a slice using a filter function.
+func Filter[T any](s []T, f func(T) bool) []T {
+	var r []T
+	for _, v := range s {
+		if f(v) {
+			r = append(r, v)
+		}
+	}
+	return r
+}
+
+// Example uses
+
+func limiter(x int) byte {
+	switch {
+	case x < 0:
+		return 0
+	default:
+		return byte(x)
+	case x > 255:
+		return 255
+	}
+}
+
+var input = []int{-4, 68954, 7, 44, 0, -555, 6945}
+var limited1 = Map[int, byte](input, limiter)
+var limited2 = Map(input, limiter) // using type inference
+
+func reducer(x float64, y int) float64 {
+	return x + float64(y)
+}
+
+var reduced1 = Reduce[int, float64](input, 0, reducer)
+var reduced2 = Reduce(input, 1i /* ERROR overflows */, reducer) // using type inference
+var reduced3 = Reduce(input, 1, reducer) // using type inference
+
+func filter(x int) bool {
+	return x&1 != 0
+}
+
+var filtered1 = Filter[int](input, filter)
+var filtered2 = Filter(input, filter) // using type inference
+
diff --git a/src/cmd/compile/internal/types2/testdata/tinference.go2 b/src/cmd/compile/internal/types2/testdata/tinference.go2
new file mode 100644
index 0000000000..a53fde0a2a
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/tinference.go2
@@ -0,0 +1,105 @@
+// Copyright 2020 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 tinferenceB
+
+import "strconv"
+
+type any interface{}
+
+func f0[A any, B interface{type C}, C interface{type D}, D interface{type A}](A, B, C, D)
+func _() {
+	f := f0[string]
+	f("a", "b", "c", "d")
+	f0("a", "b", "c", "d")
+}
+
+func f1[A any, B interface{type A}](A, B)
+func _() {
+	f := f1[int]
+	f(int(0), int(0))
+	f1(int(0), int(0))
+}
+
+func f2[A any, B interface{type []A}](A, B)
+func _() {
+	f := f2[byte]
+	f(byte(0), []byte{})
+	f2(byte(0), []byte{})
+}
+
+func f3[A any, B interface{type C}, C interface{type *A}](A, B, C)
+func _() {
+	f := f3[int]
+	var x int
+	f(x, &x, &x)
+	f3(x, &x, &x)
+}
+
+func f4[A any, B interface{type []C}, C interface{type *A}](A, B, C)
+func _() {
+	f := f4[int]
+	var x int
+	f(x, []*int{}, &x)
+	f4(x, []*int{}, &x)
+}
+
+func f5[A interface{type struct{b B; c C}}, B any, C interface{type *B}](x B) A
+func _() {
+	x := f5(1.2)
+	var _ float64 = x.b
+	var _ float64 = *x.c
+}
+
+func f6[A any, B interface{type struct{f []A}}](B) A
+func _() {
+	x := f6(struct{f []string}{})
+	var _ string = x
+}
+
+// TODO(gri) Need to flag invalid recursive constraints. At the
+// moment these cause infinite recursions and stack overflow.
+// func f7[A interface{type B}, B interface{type A}]()
+
+// More realistic examples
+
+func Double[S interface{ type []E }, E interface{ type int, int8, int16, int32, int64 }](s S) S {
+	r := make(S, len(s))
+	for i, v := range s {
+		r[i] = v + v
+	}
+	return r
+}
+
+type MySlice []int
+
+var _ = Double(MySlice{1})
+
+// From the draft design.
+
+type Setter[B any] interface {
+	Set(string)
+	type *B
+}
+
+func FromStrings[T interface{}, PT Setter[T]](s []string) []T {
+	result := make([]T, len(s))
+	for i, v := range s {
+		// The type of &result[i] is *T which is in the type list
+		// of Setter2, so we can convert it to PT.
+		p := PT(&result[i])
+		// PT has a Set method.
+		p.Set(v)
+	}
+	return result
+}
+
+type Settable int
+
+func (p *Settable) Set(s string) {
+	i, _ := strconv.Atoi(s) // real code should not ignore the error
+	*p = Settable(i)
+}
+
+var _ = FromStrings[Settable]([]string{"1", "2"})
diff --git a/src/cmd/compile/internal/types2/testdata/tmp.go2 b/src/cmd/compile/internal/types2/testdata/tmp.go2
new file mode 100644
index 0000000000..dae78caff8
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/tmp.go2
@@ -0,0 +1,17 @@
+// Copyright 2020 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.
+
+// This file is meant as "dumping ground" for debugging code.
+
+package p
+
+// fun test case
+type C[P interface{m()}] P
+
+func (r C[P]) m() { r.m() }
+
+func f[T interface{m(); n()}](x T) {
+	y := C[T](x)
+	y.m()
+}
diff --git a/src/cmd/compile/internal/types2/testdata/typeinst.go2 b/src/cmd/compile/internal/types2/testdata/typeinst.go2
new file mode 100644
index 0000000000..6757cd57fd
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/typeinst.go2
@@ -0,0 +1,59 @@
+// Copyright 2019 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 p
+
+type myInt int
+
+// Parameterized type declarations
+
+type T1[P any] P
+
+type T2[P any] struct {
+        f P
+        g int // int should still be in scope chain
+}
+
+type List[P any] []P
+
+// Alias type declarations cannot have type parameters. Syntax error.
+type A1[P any] = /* ERROR cannot be alias */ P
+
+// But an alias may refer to a generic, uninstantiated type.
+type A2 = List
+var _ A2[int]
+var _ A2 /* ERROR without instantiation */
+
+type A3 = List[int]
+var _ A3
+
+// Parameterized type instantiations
+
+var x int
+type _ x /* ERROR not a type */ [int]
+
+type _ int[] // ERROR expecting type
+type _ myInt[] // ERROR expecting type
+
+// TODO(gri) better error messages
+type _ T1 /* ERROR without instantiation */ [] // ERROR expecting type
+type _ T1[x /* ERROR not a type */ ]
+type _ T1 /* ERROR got 2 arguments but 1 type parameters */ [int, float32]
+
+var _ T2[int] = T2[int]{}
+
+var _ List[int] = []int{1, 2, 3}
+var _ List[[]int] = [][]int{{1, 2, 3}}
+var _ List[List[List[int]]]
+
+// Parameterized types containing parameterized types
+
+type T3[P any] List[P]
+
+var _ T3[int] = T3[int](List[int]{1, 2, 3})
+
+// Self-recursive generic types are not permitted
+
+type self1[P any] self1 /* ERROR illegal cycle */ [P]
+type self2[P any] *self2[P] // this is ok
diff --git a/src/cmd/compile/internal/types2/testdata/typeinst2.go2 b/src/cmd/compile/internal/types2/testdata/typeinst2.go2
new file mode 100644
index 0000000000..6e2104a515
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/typeinst2.go2
@@ -0,0 +1,256 @@
+// Copyright 2019 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 p
+
+type List[E any] []E
+var _ List[List[List[int]]]
+var _ List[List[List[int]]] = []List[List[int]]{}
+
+type (
+	T1[P1 any] struct {
+		f1 T2[P1, float32]
+	}
+
+	T2[P2, P3 any] struct {
+		f2 P2
+		f3 P3
+	}
+)
+
+func _() {
+	var x1 T1[int]
+	var x2 T2[int, float32]
+
+	x1.f1.f2 = 0
+	x1.f1 = x2
+}
+
+type T3[P any] T1[T2[P, P]]
+
+func _() {
+	var x1 T3[int]
+	var x2 T2[int, int]
+	x1.f1.f2 = x2
+}
+
+func f[P any] (x P) List[P] {
+	return List[P]{x}
+}
+
+var (
+	_ []int = f(0)
+	_ []float32 = f[float32](10)
+	_ List[complex128] = f(1i)
+	_ []List[int] = f(List[int]{})
+        _ List[List[int]] = []List[int]{}
+        _ = []List[int]{}
+)
+
+// Parameterized types with methods
+
+func (l List[E]) Head() (_ E, _ bool) {
+	if len(l) > 0 {
+		return l[0], true
+	}
+	return
+}
+
+// A test case for instantiating types with other types (extracted from map.go2)
+
+type Pair[K any] struct {
+	key K
+}
+
+type Receiver[T any] struct {
+	values T
+}
+
+type Iterator[K any] struct {
+	r Receiver[Pair[K]]
+}
+
+func Values [T any] (r Receiver[T]) T {
+        return r.values
+}
+
+func (it Iterator[K]) Next() K {
+        return Values[Pair[K]](it.r).key
+}
+
+// A more complex test case testing type bounds (extracted from linalg.go2 and reduced to essence)
+
+type NumericAbs[T any] interface {
+	Abs() T
+}
+
+func AbsDifference[T NumericAbs[T]](x T)
+
+type OrderedAbs[T any] T
+
+func (a OrderedAbs[T]) Abs() OrderedAbs[T]
+
+func OrderedAbsDifference[T any](x T) {
+	AbsDifference(OrderedAbs[T](x))
+}
+
+// same code, reduced to essence
+
+func g[P interface{ m() P }](x P)
+
+type T4[P any] P
+
+func (_ T4[P]) m() T4[P]
+
+func _[Q any](x Q) {
+	g(T4[Q](x))
+}
+
+// Another test case that caused  problems in the past
+
+type T5[_ interface { a() }, _ interface{}] struct{}
+
+type A[P any] struct{ x P }
+
+func (_ A[P]) a() {}
+
+var _ T5[A[int], int]
+
+// Invoking methods with parameterized receiver types uses
+// type inference to determine the actual type arguments matching
+// the receiver type parameters from the actual receiver argument.
+// Go does implicit address-taking and dereferenciation depending
+// on the actual receiver and the method's receiver type. To make
+// type inference work, the type-checker matches "pointer-ness"
+// of the actual receiver and the method's receiver type.
+// The following code tests this mechanism.
+
+type R1[A any] struct{}
+func (_ R1[A]) vm()
+func (_ *R1[A]) pm()
+
+func _[T any](r R1[T], p *R1[T]) {
+	r.vm()
+	r.pm()
+	p.vm()
+	p.pm()
+}
+
+type R2[A, B any] struct{}
+func (_ R2[A, B]) vm()
+func (_ *R2[A, B]) pm()
+
+func _[T any](r R2[T, int], p *R2[string, T]) {
+	r.vm()
+	r.pm()
+	p.vm()
+	p.pm()
+}
+
+// An interface can (explicitly) declare at most one type list.
+type _ interface {
+	m0()
+	type int, string, bool
+	type /* ERROR multiple type lists */ float32, float64
+	m1()
+	m2()
+	type /* ERROR multiple type lists */ complex64, complex128
+	type /* ERROR multiple type lists */ rune
+}
+
+// Interface type lists may contain each type at most once.
+// (If there are multiple lists, we assume the author intended
+// for them to be all in a single list, and we report the error
+// as well.)
+type _ interface {
+	type int, int /* ERROR duplicate type int */
+	type /* ERROR multiple type lists */ int /* ERROR duplicate type int */
+}
+
+type _ interface {
+	type struct{f int}, struct{g int}, struct /* ERROR duplicate type */ {f int}
+}
+
+// Interface type lists can contain any type, incl. *Named types.
+// Verify that we use the underlying type to compute the operational type.
+type MyInt int
+func add1[T interface{type MyInt}](x T) T {
+	return x + 1
+}
+
+type MyString string
+func double[T interface{type MyInt, MyString}](x T) T {
+	return x + x
+}
+
+// Embedding of interfaces with type lists leads to interfaces
+// with type lists that are the intersection of the embedded
+// type lists.
+
+type E0 interface {
+	type int, bool, string
+}
+
+type E1 interface {
+	type int, float64, string
+}
+
+type E2 interface {
+	type float64
+}
+
+type I0 interface {
+	E0
+}
+
+func f0[T I0]()
+var _ = f0[int]
+var _ = f0[bool]
+var _ = f0[string]
+var _ = f0[float64 /* ERROR does not satisfy I0 */ ]
+
+type I01 interface {
+	E0
+	E1
+}
+
+func f01[T I01]()
+var _ = f01[int]
+var _ = f01[bool /* ERROR does not satisfy I0 */ ]
+var _ = f01[string]
+var _ = f01[float64 /* ERROR does not satisfy I0 */ ]
+
+type I012 interface {
+	E0
+	E1
+	E2
+}
+
+func f012[T I012]()
+var _ = f012[int /* ERROR does not satisfy I012 */ ]
+var _ = f012[bool /* ERROR does not satisfy I012 */ ]
+var _ = f012[string /* ERROR does not satisfy I012 */ ]
+var _ = f012[float64 /* ERROR does not satisfy I012 */ ]
+
+type I12 interface {
+	E1
+	E2
+}
+
+func f12[T I12]()
+var _ = f12[int /* ERROR does not satisfy I12 */ ]
+var _ = f12[bool /* ERROR does not satisfy I12 */ ]
+var _ = f12[string /* ERROR does not satisfy I12 */ ]
+var _ = f12[float64]
+
+type I0_ interface {
+	E0
+	type int
+}
+
+func f0_[T I0_]()
+var _ = f0_[int]
+var _ = f0_[bool /* ERROR does not satisfy I0_ */ ]
+var _ = f0_[string /* ERROR does not satisfy I0_ */ ]
+var _ = f0_[float64 /* ERROR does not satisfy I0_ */ ]
diff --git a/src/cmd/compile/internal/types2/testdata/typeparams.go2 b/src/cmd/compile/internal/types2/testdata/typeparams.go2
new file mode 100644
index 0000000000..54cb34ec3b
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/typeparams.go2
@@ -0,0 +1,422 @@
+// Copyright 2020 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 p
+
+// import "io" // for type assertion tests
+
+// The predeclared identifier "any" is only visible as a constraint
+// in a type parameter list.
+var _ any // ERROR undeclared
+func _[_ any /* ok here */ , _ interface{any /* ERROR undeclared */ }](any /* ERROR undeclared */ ) {
+        var _ any /* ERROR undeclared */
+}
+
+func identity[T any](x T) T { return x }
+
+func _[_ any](x int) int
+func _[T any](T /* ERROR redeclared */ T)()
+func _[T, T /* ERROR redeclared */ any]()
+
+func reverse[T any](list []T) []T {
+        rlist := make([]T, len(list))
+        i := len(list)
+        for _, x := range list {
+                i--
+                rlist[i] = x
+        }
+        return rlist
+}
+
+var _ = reverse /* ERROR cannot use generic function reverse */
+var _ = reverse[int, float32 /* ERROR got 2 type arguments */ ] ([]int{1, 2, 3})
+var _ = reverse[int]([ /* ERROR cannot use */ ]float32{1, 2, 3})
+var f = reverse[chan int]
+var _ = f(0 /* ERROR cannot convert 0 .* to \[\]chan int */ )
+
+func swap[A, B any](a A, b B) (B, A) { return b, a }
+
+var _ = swap /* ERROR single value is expected */ [int, float32](1, 2)
+var f32, i = swap[int, float32](swap[float32, int](1, 2))
+var _ float32 = f32
+var _ int = i
+
+func swapswap[A, B any](a A, b B) (A, B) {
+        return swap[B, A](b, a)
+}
+
+type F[A, B any] func(A, B) (B, A)
+
+func min[T interface{ type int }](x, y T) T {
+        if x < y {
+                return x
+        }
+        return y
+}
+
+func _[T interface{type int, float32}](x, y T) bool { return x < y }
+func _[T any](x, y T) bool { return x /* ERROR cannot compare */ < y }
+func _[T interface{type int, float32, bool}](x, y T) bool { return x /* ERROR cannot compare */ < y }
+
+func _[T C1[T]](x, y T) bool { return x /* ERROR cannot compare */ < y }
+func _[T C2[T]](x, y T) bool { return x < y }
+
+type C1[T any] interface{}
+type C2[T any] interface{ type int, float32 }
+
+func new[T any]() *T {
+        var x T
+        return &x
+}
+
+var _ = new /* ERROR cannot use generic function new */
+var _ *int = new[int]()
+
+func _[T any](map[T /* ERROR invalid map key type T \(missing comparable constraint\) */]int) // w/o constraint we don't know if T is comparable
+
+func f1[T1 any](struct{T1}) int
+var _ = f1[int](struct{T1}{})
+type T1 = int
+
+func f2[t1 any](struct{t1; x float32}) int
+var _ = f2[t1](struct{t1; x float32}{})
+type t1 = int
+
+
+func f3[A, B, C any](A, struct{x B}, func(A, struct{x B}, *C)) int
+
+var _ = f3[int, rune, bool](1, struct{x rune}{}, nil)
+
+// indexing
+
+func _[T any] (x T, i int) { _ = x /* ERROR "cannot index" */ [i] }
+func _[T interface{ type int }] (x T, i int) { _ = x /* ERROR "cannot index" */ [i] }
+func _[T interface{ type string }] (x T, i int) { _ = x[i] }
+func _[T interface{ type []int }] (x T, i int) { _ = x[i] }
+func _[T interface{ type [10]int, *[20]int, map[string]int }] (x T, i int) { _ = x[i] }
+func _[T interface{ type string, []byte }] (x T, i int) { _ = x[i] }
+func _[T interface{ type []int, [1]rune }] (x T, i int) { _ = x /* ERROR "cannot index" */ [i] }
+func _[T interface{ type string, []rune }] (x T, i int) { _ = x /* ERROR "cannot index" */ [i] }
+
+// slicing
+// TODO(gri) implement this
+
+func _[T interface{ type string }] (x T, i, j, k int) { _ = x /* ERROR invalid operation */ [i:j:k] }
+
+// len/cap built-ins
+
+func _[T any](x T) { _ = len(x /* ERROR invalid argument */ ) }
+func _[T interface{ type int }](x T) { _ = len(x /* ERROR invalid argument */ ) }
+func _[T interface{ type string, []byte, int }](x T) { _ = len(x /* ERROR invalid argument */ ) }
+func _[T interface{ type string }](x T) { _ = len(x) }
+func _[T interface{ type [10]int }](x T) { _ = len(x) }
+func _[T interface{ type []byte }](x T) { _ = len(x) }
+func _[T interface{ type map[int]int }](x T) { _ = len(x) }
+func _[T interface{ type chan int }](x T) { _ = len(x) }
+func _[T interface{ type string, []byte, chan int }](x T) { _ = len(x) }
+
+func _[T any](x T) { _ = cap(x /* ERROR invalid argument */ ) }
+func _[T interface{ type int }](x T) { _ = cap(x /* ERROR invalid argument */ ) }
+func _[T interface{ type string, []byte, int }](x T) { _ = cap(x /* ERROR invalid argument */ ) }
+func _[T interface{ type string }](x T) { _ = cap(x /* ERROR invalid argument */ ) }
+func _[T interface{ type [10]int }](x T) { _ = cap(x) }
+func _[T interface{ type []byte }](x T) { _ = cap(x) }
+func _[T interface{ type map[int]int }](x T) { _ = cap(x /* ERROR invalid argument */ ) }
+func _[T interface{ type chan int }](x T) { _ = cap(x) }
+func _[T interface{ type []byte, chan int }](x T) { _ = cap(x) }
+
+// range iteration
+
+func _[T interface{}](x T) {
+        for range x /* ERROR cannot range */ {}
+}
+
+func _[T interface{ type string, []string }](x T) {
+        for range x {}
+        for i := range x { _ = i }
+        for i, _ := range x { _ = i }
+        for i, e := range x /* ERROR must have the same element type */ { _ = i }
+        for _, e := range x /* ERROR must have the same element type */ {}
+        var e rune
+        _ = e
+        for _, (e) = range x /* ERROR must have the same element type */ {}
+}
+
+
+func _[T interface{ type string, []rune, map[int]rune }](x T) {
+        for _, e := range x { _ = e }
+        for i, e := range x { _ = i; _ = e }
+}
+
+func _[T interface{ type string, []rune, map[string]rune }](x T) {
+        for _, e := range x { _ = e }
+        for i, e := range x /* ERROR must have the same key type */ { _ = e }
+}
+
+func _[T interface{ type string, chan int }](x T) {
+        for range x {}
+        for i := range x { _ = i }
+        for i, _ := range x { _ = i } // TODO(gri) should get an error here: channels only return one value
+}
+
+func _[T interface{ type string, chan<-int }](x T) {
+        for i := range x /* ERROR send-only channel */ { _ = i }
+}
+
+// type inference checks
+
+var _ = new() /* ERROR cannot infer T */
+
+func f4[A, B, C any](A, B) C
+
+var _ = f4(1, 2) /* ERROR cannot infer C */
+var _ = f4[int, float32, complex128](1, 2)
+
+func f5[A, B, C any](A, []*B, struct{f []C}) int
+
+var _ = f5[int, float32, complex128](0, nil, struct{f []complex128}{})
+var _ = f5(0, nil, struct{f []complex128}{}) // ERROR cannot infer
+var _ = f5(0, []*float32{new[float32]()}, struct{f []complex128}{})
+
+func f6[A any](A, []A) int
+
+var _ = f6(0, nil)
+
+func f6nil[A any](A) int
+
+var _ = f6nil(nil) // ERROR cannot infer
+
+// type inference with variadic functions
+
+func f7[T any](...T) T
+
+var _ int = f7() /* ERROR cannot infer T */
+var _ int = f7(1)
+var _ int = f7(1, 2)
+var _ int = f7([]int{}...)
+var _ int = f7 /* ERROR cannot use */ ([]float64{}...)
+var _ float64 = f7([]float64{}...)
+var _ = f7[float64](1, 2.3)
+var _ = f7(float64(1), 2.3)
+var _ = f7(1, 2.3 /* ERROR does not match */ )
+var _ = f7(1.2, 3 /* ERROR does not match */ )
+
+func f8[A, B any](A, B, ...B) int
+
+var _ = f8(1) /* ERROR not enough arguments */
+var _ = f8(1, 2.3)
+var _ = f8(1, 2.3, 3.4, 4.5)
+var _ = f8(1, 2.3, 3.4, 4 /* ERROR does not match */ )
+var _ = f8[int, float64](1, 2.3, 3.4, 4)
+
+var _ = f8[int, float64](0, 0, nil...) // test case for #18268
+
+// init functions cannot have type parameters
+
+func init() {}
+func init[/* ERROR func init must have no type parameters */ _ any]() {}
+func init[/* ERROR func init must have no type parameters */ P any]() {}
+
+type T struct {}
+
+func (T) m1() {}
+// The type checker accepts method type parameters if configured accordingly.
+func (T) m2[_ any]() {}
+func (T) m3[P any]() {}
+
+// type inference across parameterized types
+
+type S1[P any] struct { f P }
+
+func f9[P any](x S1[P])
+
+func _() {
+        f9[int](S1[int]{42})
+	f9(S1[int]{42})
+}
+
+type S2[A, B, C any] struct{}
+
+func f10[X, Y, Z any](a S2[X, int, Z], b S2[X, Y, bool])
+
+func _[P any]() {
+        f10[int, float32, string](S2[int, int, string]{}, S2[int, float32, bool]{})
+        f10(S2[int, int, string]{}, S2[int, float32, bool]{})
+        f10(S2[P, int, P]{}, S2[P, float32, bool]{})
+}
+
+// corner case for type inference
+// (was bug: after instanting f11, the type-checker didn't mark f11 as non-generic)
+
+func f11[T any]()
+
+func _() {
+	f11[int]()
+}
+
+// the previous example was extracted from
+
+func f12[T interface{m() T}]()
+
+type A[T any] T
+
+func (a A[T]) m() A[T]
+
+func _[T any]() {
+	f12[A[T]]()
+}
+
+// method expressions
+
+func (_ S1[P]) m()
+
+func _() {
+	m := S1[int].m
+	m(struct { f int }{42})
+}
+
+func _[T any] (x T) {
+        m := S1[T].m
+        m(S1[T]{x})
+}
+
+// type parameters in methods (generalization)
+
+type R0 struct{}
+
+func (R0) _[T any](x T)
+func (R0 /* ERROR invalid receiver */ ) _[R0 any]() // scope of type parameters starts at "func"
+
+type R1[A, B any] struct{}
+
+func (_ R1[A, B]) m0(A, B)
+func (_ R1[A, B]) m1[T any](A, B, T) T
+func (_ R1 /* ERROR not a generic type */ [R1, _]) _()
+func (_ R1[A, B]) _[A /* ERROR redeclared */ any](B)
+
+func _() {
+        var r R1[int, string]
+        r.m1[rune](42, "foo", 'a')
+        r.m1[rune](42, "foo", 1.2 /* ERROR truncated to rune */)
+        r.m1(42, "foo", 1.2) // using type inference
+        var _ float64 = r.m1(42, "foo", 1.2)
+}
+
+type I1[A any] interface {
+        m1(A)
+}
+
+var _ I1[int] = r1[int]{}
+
+type r1[T any] struct{}
+
+func (_ r1[T]) m1(T)
+
+type I2[A, B any] interface {
+        m1(A)
+        m2(A) B
+}
+
+var _ I2[int, float32] = R2[int, float32]{}
+
+type R2[P, Q any] struct{}
+
+func (_ R2[X, Y]) m1(X)
+func (_ R2[X, Y]) m2(X) Y
+
+// type assertions and type switches over generic types
+// NOTE: These are currently disabled because it's unclear what the correct
+// approach is, and one can always work around by assigning the variable to
+// an interface first.
+
+// // ReadByte1 corresponds to the ReadByte example in the draft design.
+// func ReadByte1[T io.Reader](r T) (byte, error) {
+// 	if br, ok := r.(io.ByteReader); ok {
+// 		return br.ReadByte()
+// 	}
+// 	var b [1]byte
+// 	_, err := r.Read(b[:])
+// 	return b[0], err
+// }
+//
+// // ReadBytes2 is like ReadByte1 but uses a type switch instead.
+// func ReadByte2[T io.Reader](r T) (byte, error) {
+//         switch br := r.(type) {
+//         case io.ByteReader:
+//                 return br.ReadByte()
+//         }
+// 	var b [1]byte
+// 	_, err := r.Read(b[:])
+// 	return b[0], err
+// }
+//
+// // type assertions and type switches over generic types are strict
+// type I3 interface {
+//         m(int)
+// }
+//
+// type I4 interface {
+//         m() int // different signature from I3.m
+// }
+//
+// func _[T I3](x I3, p T) {
+//         // type assertions and type switches over interfaces are not strict
+//         _ = x.(I4)
+//         switch x.(type) {
+//         case I4:
+//         }
+//
+//         // type assertions and type switches over generic types are strict
+//         _ = p /* ERROR cannot have dynamic type I4 */.(I4)
+//         switch p.(type) {
+//         case I4 /* ERROR cannot have dynamic type I4 */ :
+//         }
+// }
+
+// type assertions and type switches over generic types lead to errors for now
+
+func _[T any](x T) {
+	_ = x /* ERROR not an interface */ .(int)
+	switch x /* ERROR not an interface */ .(type) {
+	}
+
+	// work-around
+	var t interface{} = x
+	_ = t.(int)
+	switch t.(type) {
+	}
+}
+
+func _[T interface{type int}](x T) {
+	_ = x /* ERROR not an interface */ .(int)
+	switch x /* ERROR not an interface */ .(type) {
+	}
+
+	// work-around
+	var t interface{} = x
+	_ = t.(int)
+	switch t.(type) {
+	}
+}
+
+// error messages related to type bounds mention those bounds
+type C[P any] interface{}
+
+func _[P C[P]] (x P) {
+	x.m /* ERROR x.m undefined */ ()
+}
+
+type I interface {}
+
+func _[P I] (x P) {
+	x.m /* ERROR interface I has no method m */ ()
+}
+
+func _[P interface{}] (x P) {
+	x.m /* ERROR type bound for P has no method m */ ()
+}
+
+func _[P any] (x P) {
+	x.m /* ERROR type bound for P has no method m */ ()
+}
-- 
GitLab


From a10fe9f6e750454c9f4fcae7f86bab0c9cca43c7 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 21 Oct 2020 14:36:21 -0400
Subject: [PATCH 0014/2400] go/ast: import AST changes supporting typeparams
 from dev.go2go

Minimal changes are made to existing types in go/ast to support type
parameters. Namely:
 + FieldList is overloaded to hold type parameter lists. In this case,
   the field name becomes the type identifier, and the field type
   becomes the constraint.
 + FuncType and TypeSpec gain a TParams FieldList.
 + CallExpr gains a 'Brackets' flag, signaling that it uses '[]' rather
   than '()', representing a generic type expression with type
   parameters.

Modifications from dev.go2go: the 'UseBrackets' field was removed from
ast.File, as this support is no longer necessary.

Change-Id: I21fd7390f1800dece3c14e6ec015fb2419e9fc52
Reviewed-on: https://go-review.googlesource.com/c/go/+/264181
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Trust: Robert Findley <rfindley@google.com>
---
 src/go/ast/ast.go          | 43 +++++++++++++++++++++++++-------------
 src/go/ast/example_test.go | 33 +++++++++++++++--------------
 src/go/ast/walk.go         | 10 ++++++++-
 3 files changed, 54 insertions(+), 32 deletions(-)

diff --git a/src/go/ast/ast.go b/src/go/ast/ast.go
index 1061f1d3ce..df5498159a 100644
--- a/src/go/ast/ast.go
+++ b/src/go/ast/ast.go
@@ -188,11 +188,14 @@ func isDirective(c string) bool {
 // in a signature.
 // Field.Names is nil for unnamed parameters (parameter lists which only contain types)
 // and embedded struct fields. In the latter case, the field name is the type name.
+// Field.Names contains a single name "type" for elements of interface type lists.
+// Types belonging to the same type list share the same "type" identifier which also
+// records the position of that keyword.
 //
 type Field struct {
 	Doc     *CommentGroup // associated documentation; or nil
-	Names   []*Ident      // field/method/parameter names; or nil
-	Type    Expr          // field/method/parameter type
+	Names   []*Ident      // field/method/(type) parameter names, or type "type"; or nil
+	Type    Expr          // field/method/parameter type, type list type; or nil
 	Tag     *BasicLit     // field tag; or nil
 	Comment *CommentGroup // line comments; or nil
 }
@@ -201,14 +204,23 @@ func (f *Field) Pos() token.Pos {
 	if len(f.Names) > 0 {
 		return f.Names[0].Pos()
 	}
-	return f.Type.Pos()
+	if f.Type != nil {
+		return f.Type.Pos()
+	}
+	return token.NoPos
 }
 
 func (f *Field) End() token.Pos {
 	if f.Tag != nil {
 		return f.Tag.End()
 	}
-	return f.Type.End()
+	if f.Type != nil {
+		return f.Type.End()
+	}
+	if len(f.Names) > 0 {
+		return f.Names[len(f.Names)-1].End()
+	}
+	return token.NoPos
 }
 
 // A FieldList represents a list of Fields, enclosed by parentheses or braces.
@@ -242,7 +254,7 @@ func (f *FieldList) End() token.Pos {
 	return token.NoPos
 }
 
-// NumFields returns the number of parameters or struct fields represented by a FieldList.
+// NumFields returns the number of (type) parameters or struct fields represented by a FieldList.
 func (f *FieldList) NumFields() int {
 	n := 0
 	if f != nil {
@@ -285,12 +297,6 @@ type (
 	}
 
 	// A BasicLit node represents a literal of basic type.
-	//
-	// Note that for the CHAR and STRING kinds, the literal is stored
-	// with its quotes. For example, for a double-quoted STRING, the
-	// first and the last rune in the Value field will be ". The
-	// Unquote and UnquoteChar functions in the strconv package can be
-	// used to unquote STRING and CHAR values, respectively.
 	BasicLit struct {
 		ValuePos token.Pos   // literal position
 		Kind     token.Token // token.INT, token.FLOAT, token.IMAG, token.CHAR, or token.STRING
@@ -361,6 +367,7 @@ type (
 		Args     []Expr    // function arguments; or nil
 		Ellipsis token.Pos // position of "..." (token.NoPos if there is no "...")
 		Rparen   token.Pos // position of ")"
+		Brackets bool      // if set, "[" and "]" are used instead of "(" and ")"
 	}
 
 	// A StarExpr node represents an expression of the form "*" Expression.
@@ -432,6 +439,7 @@ type (
 	// A FuncType node represents a function type.
 	FuncType struct {
 		Func    token.Pos  // position of "func" keyword (token.NoPos if there is no "func")
+		TParams *FieldList // type parameters; or nil
 		Params  *FieldList // (incoming) parameters; non-nil
 		Results *FieldList // (outgoing) results; or nil
 	}
@@ -439,8 +447,8 @@ type (
 	// An InterfaceType node represents an interface type.
 	InterfaceType struct {
 		Interface  token.Pos  // position of "interface" keyword
-		Methods    *FieldList // list of methods
-		Incomplete bool       // true if (source) methods are missing in the Methods list
+		Methods    *FieldList // list of embedded interfaces, methods, or types
+		Incomplete bool       // true if (source) methods or types are missing in the Methods list
 	}
 
 	// A MapType node represents a map type.
@@ -893,6 +901,7 @@ type (
 	TypeSpec struct {
 		Doc     *CommentGroup // associated documentation; or nil
 		Name    *Ident        // type name
+		TParams *FieldList    // type parameters; or nil
 		Assign  token.Pos     // position of '=', if any
 		Type    Expr          // *Ident, *ParenExpr, *SelectorExpr, *StarExpr, or any of the *XxxTypes
 		Comment *CommentGroup // line comments; or nil
@@ -960,7 +969,7 @@ type (
 	GenDecl struct {
 		Doc    *CommentGroup // associated documentation; or nil
 		TokPos token.Pos     // position of Tok
-		Tok    token.Token   // IMPORT, CONST, TYPE, VAR
+		Tok    token.Token   // IMPORT, CONST, TYPE, or VAR
 		Lparen token.Pos     // position of '(', if any
 		Specs  []Spec
 		Rparen token.Pos // position of ')', if any
@@ -971,11 +980,15 @@ type (
 		Doc  *CommentGroup // associated documentation; or nil
 		Recv *FieldList    // receiver (methods); or nil (functions)
 		Name *Ident        // function/method name
-		Type *FuncType     // function signature: parameters, results, and position of "func" keyword
+		Type *FuncType     // function signature: type and value parameters, results, and position of "func" keyword
 		Body *BlockStmt    // function body; or nil for external (non-Go) function
 	}
 )
 
+func (f *FuncDecl) IsMethod() bool {
+	return f.Recv.NumFields() != 0
+}
+
 // Pos and End implementations for declaration nodes.
 
 func (d *BadDecl) Pos() token.Pos  { return d.From }
diff --git a/src/go/ast/example_test.go b/src/go/ast/example_test.go
index e3013f64be..c2b35205bb 100644
--- a/src/go/ast/example_test.go
+++ b/src/go/ast/example_test.go
@@ -119,22 +119,23 @@ func main() {
 	//     40  .  .  .  .  .  .  .  }
 	//     41  .  .  .  .  .  .  .  Ellipsis: -
 	//     42  .  .  .  .  .  .  .  Rparen: 4:25
-	//     43  .  .  .  .  .  .  }
-	//     44  .  .  .  .  .  }
-	//     45  .  .  .  .  }
-	//     46  .  .  .  .  Rbrace: 5:1
-	//     47  .  .  .  }
-	//     48  .  .  }
-	//     49  .  }
-	//     50  .  Scope: *ast.Scope {
-	//     51  .  .  Objects: map[string]*ast.Object (len = 1) {
-	//     52  .  .  .  "main": *(obj @ 11)
-	//     53  .  .  }
-	//     54  .  }
-	//     55  .  Unresolved: []*ast.Ident (len = 1) {
-	//     56  .  .  0: *(obj @ 29)
-	//     57  .  }
-	//     58  }
+	//     43  .  .  .  .  .  .  .  Brackets: false
+	//     44  .  .  .  .  .  .  }
+	//     45  .  .  .  .  .  }
+	//     46  .  .  .  .  }
+	//     47  .  .  .  .  Rbrace: 5:1
+	//     48  .  .  .  }
+	//     49  .  .  }
+	//     50  .  }
+	//     51  .  Scope: *ast.Scope {
+	//     52  .  .  Objects: map[string]*ast.Object (len = 1) {
+	//     53  .  .  .  "main": *(obj @ 11)
+	//     54  .  .  }
+	//     55  .  }
+	//     56  .  Unresolved: []*ast.Ident (len = 1) {
+	//     57  .  .  0: *(obj @ 29)
+	//     58  .  }
+	//     59  }
 }
 
 // This example illustrates how to remove a variable declaration
diff --git a/src/go/ast/walk.go b/src/go/ast/walk.go
index 8ca21959b1..f909c00b4b 100644
--- a/src/go/ast/walk.go
+++ b/src/go/ast/walk.go
@@ -71,7 +71,9 @@ func Walk(v Visitor, node Node) {
 			Walk(v, n.Doc)
 		}
 		walkIdentList(v, n.Names)
-		Walk(v, n.Type)
+		if n.Type != nil {
+			Walk(v, n.Type)
+		}
 		if n.Tag != nil {
 			Walk(v, n.Tag)
 		}
@@ -161,6 +163,9 @@ func Walk(v Visitor, node Node) {
 		Walk(v, n.Fields)
 
 	case *FuncType:
+		if n.TParams != nil {
+			Walk(v, n.TParams)
+		}
 		if n.Params != nil {
 			Walk(v, n.Params)
 		}
@@ -315,6 +320,9 @@ func Walk(v Visitor, node Node) {
 			Walk(v, n.Doc)
 		}
 		Walk(v, n.Name)
+		if n.TParams != nil {
+			Walk(v, n.TParams)
+		}
 		Walk(v, n.Type)
 		if n.Comment != nil {
 			Walk(v, n.Comment)
-- 
GitLab


From 87eab74628bc23831bd783806e8ec16927bd9a50 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 22 Oct 2020 15:32:05 -0700
Subject: [PATCH 0015/2400] [dev.typeparams] cmd/compile: enable type-checking
 of generic code

This change makes a first connection between the compiler and types2.
When the -G flag is provided, the compiler accepts code using type
parameters; with this change generic code is also type-checked (but
then compilation ends).

Change-Id: I0fa6f6213267a458a6b33afe8ff26869fd838a63
Reviewed-on: https://go-review.googlesource.com/c/go/+/264303
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/dep_test.go      |  7 +-
 src/cmd/compile/internal/gc/noder.go         | 69 ++++++++++++++++++--
 src/cmd/compile/internal/importer/iimport.go | 18 +++--
 src/cmd/compile/internal/types2/errors.go    |  4 +-
 src/cmd/compile/internal/types2/infer.go     |  5 +-
 src/cmd/compile/internal/types2/methodset.go |  5 +-
 src/cmd/compile/internal/types2/object.go    | 12 +++-
 src/cmd/compile/internal/types2/typexpr.go   |  2 +-
 src/cmd/dist/buildtool.go                    |  3 +
 test/typeparam/smoketest.go                  |  5 +-
 test/typeparam/tparam1.go                    | 42 ++++++++++++
 11 files changed, 147 insertions(+), 25 deletions(-)
 create mode 100644 test/typeparam/tparam1.go

diff --git a/src/cmd/compile/internal/gc/dep_test.go b/src/cmd/compile/internal/gc/dep_test.go
index c1dac93386..ecc9a70ce4 100644
--- a/src/cmd/compile/internal/gc/dep_test.go
+++ b/src/cmd/compile/internal/gc/dep_test.go
@@ -19,7 +19,12 @@ func TestDeps(t *testing.T) {
 	for _, dep := range strings.Fields(strings.Trim(string(out), "[]")) {
 		switch dep {
 		case "go/build", "go/token":
-			t.Errorf("undesired dependency on %q", dep)
+			// cmd/compile/internal/importer introduces a dependency
+			// on go/build and go/token; cmd/compile/internal/ uses
+			// go/constant which uses go/token in its API. Once we
+			// got rid of those dependencies, enable this check again.
+			// TODO(gri) fix this
+			// t.Errorf("undesired dependency on %q", dep)
 		}
 	}
 }
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 528593df52..9685794ec4 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"fmt"
+	"io"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -13,8 +14,10 @@ import (
 	"strings"
 	"unicode/utf8"
 
+	"cmd/compile/internal/importer"
 	"cmd/compile/internal/syntax"
 	"cmd/compile/internal/types"
+	"cmd/compile/internal/types2"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
 	"cmd/internal/src"
@@ -24,7 +27,7 @@ import (
 // Each declaration in every *syntax.File is converted to a syntax tree
 // and its root represented by *Node is appended to xtop.
 // Returns the total count of parsed lines.
-func parseFiles(filenames []string, allowGenerics bool) uint {
+func parseFiles(filenames []string, allowGenerics bool) (lines uint) {
 	noders := make([]*noder, 0, len(filenames))
 	// Limit the number of simultaneously open files.
 	sem := make(chan struct{}, runtime.GOMAXPROCS(0)+10)
@@ -57,16 +60,52 @@ func parseFiles(filenames []string, allowGenerics bool) uint {
 		}(filename)
 	}
 
-	var lines uint
+	if allowGenerics {
+		nodersmap := make(map[string]*noder)
+		var files []*syntax.File
+		for _, p := range noders {
+			for e := range p.err {
+				p.yyerrorpos(e.Pos, "%s", e.Msg)
+			}
+
+			nodersmap[p.file.Pos().RelFilename()] = p
+			files = append(files, p.file)
+			lines += p.file.EOF.Line()
+
+			if nsyntaxerrors != 0 {
+				errorexit()
+			}
+		}
+
+		conf := types2.Config{
+			InferFromConstraints: true,
+			Error: func(err error) {
+				terr := err.(types2.Error)
+				if len(terr.Msg) > 0 && terr.Msg[0] == '\t' {
+					// types2 reports error clarifications via separate
+					// error messages which are indented with a tab.
+					// Ignore them to satisfy tools and tests that expect
+					// only one error in such cases.
+					// TODO(gri) Need to adjust error reporting in types2.
+					return
+				}
+				p := nodersmap[terr.Pos.RelFilename()]
+				yyerrorl(p.makeXPos(terr.Pos), "%s", terr.Msg)
+			},
+			Importer: &gcimports{
+				packages: make(map[string]*types2.Package),
+			},
+		}
+		conf.Check(Ctxt.Pkgpath, files, nil)
+		return
+	}
+
 	for _, p := range noders {
 		for e := range p.err {
 			p.yyerrorpos(e.Pos, "%s", e.Msg)
 		}
 
-		// noder cannot handle generic code yet
-		if !allowGenerics {
-			p.node()
-		}
+		p.node()
 		lines += p.file.EOF.Line()
 		p.file = nil // release memory
 
@@ -78,8 +117,24 @@ func parseFiles(filenames []string, allowGenerics bool) uint {
 	}
 
 	localpkg.Height = myheight
+	return
+}
 
-	return lines
+// Temporary import helper to get type2-based type-checking going.
+type gcimports struct {
+	packages map[string]*types2.Package
+	lookup   func(path string) (io.ReadCloser, error)
+}
+
+func (m *gcimports) Import(path string) (*types2.Package, error) {
+	return m.ImportFrom(path, "" /* no vendoring */, 0)
+}
+
+func (m *gcimports) ImportFrom(path, srcDir string, mode types2.ImportMode) (*types2.Package, error) {
+	if mode != 0 {
+		panic("mode must be 0")
+	}
+	return importer.Import(m.packages, path, srcDir, m.lookup)
 }
 
 // makeSrcPosBase translates from a *syntax.PosBase to a *src.PosBase.
diff --git a/src/cmd/compile/internal/importer/iimport.go b/src/cmd/compile/internal/importer/iimport.go
index b9c1ccfb66..6cb8e9377d 100644
--- a/src/cmd/compile/internal/importer/iimport.go
+++ b/src/cmd/compile/internal/importer/iimport.go
@@ -58,6 +58,8 @@ const (
 	interfaceType
 )
 
+const io_SeekCurrent = 1 // io.SeekCurrent (not defined in Go 1.4)
+
 // iImportData imports a package from the serialized package data
 // and returns the number of bytes consumed and a reference to the package.
 // If the export data version is not recognized or the format is otherwise
@@ -87,10 +89,10 @@ func iImportData(imports map[string]*types2.Package, data []byte, path string) (
 	sLen := int64(r.uint64())
 	dLen := int64(r.uint64())
 
-	whence, _ := r.Seek(0, io.SeekCurrent)
+	whence, _ := r.Seek(0, io_SeekCurrent)
 	stringData := data[whence : whence+sLen]
 	declData := data[whence+sLen : whence+sLen+dLen]
-	r.Seek(sLen+dLen, io.SeekCurrent)
+	r.Seek(sLen+dLen, io_SeekCurrent)
 
 	p := iimporter{
 		ipath:   path,
@@ -162,7 +164,7 @@ func iImportData(imports map[string]*types2.Package, data []byte, path string) (
 	// package was imported completely and without errors
 	localpkg.MarkComplete()
 
-	consumed, _ := r.Seek(0, io.SeekCurrent)
+	consumed, _ := r.Seek(0, io_SeekCurrent)
 	return int(consumed), localpkg, nil
 }
 
@@ -193,7 +195,10 @@ func (p *iimporter) doDecl(pkg *types2.Package, name string) {
 	}
 
 	r := &importReader{p: p, currPkg: pkg}
-	r.declReader.Reset(p.declData[off:])
+	// Reader.Reset is not available in Go 1.4.
+	// Use bytes.NewReader for now.
+	// r.declReader.Reset(p.declData[off:])
+	r.declReader = *bytes.NewReader(p.declData[off:])
 
 	r.obj(name)
 }
@@ -232,7 +237,10 @@ func (p *iimporter) typAt(off uint64, base *types2.Named) types2.Type {
 	}
 
 	r := &importReader{p: p}
-	r.declReader.Reset(p.declData[off-predeclReserved:])
+	// Reader.Reset is not available in Go 1.4.
+	// Use bytes.NewReader for now.
+	// r.declReader.Reset(p.declData[off-predeclReserved:])
+	r.declReader = *bytes.NewReader(p.declData[off-predeclReserved:])
 	t := r.doType(base)
 
 	if base == nil || !isInterface(t) {
diff --git a/src/cmd/compile/internal/types2/errors.go b/src/cmd/compile/internal/types2/errors.go
index 5211439f89..07f9aad48b 100644
--- a/src/cmd/compile/internal/types2/errors.go
+++ b/src/cmd/compile/internal/types2/errors.go
@@ -8,6 +8,7 @@
 package types2
 
 import (
+	"bytes"
 	"cmd/compile/internal/syntax"
 	"fmt"
 	"strconv"
@@ -145,7 +146,8 @@ func posFor(at poser) syntax.Pos {
 
 // stripAnnotations removes internal (type) annotations from s.
 func stripAnnotations(s string) string {
-	var b strings.Builder
+	// Would like to use strings.Builder but it's not available in Go 1.4.
+	var b bytes.Buffer
 	for _, r := range s {
 		// strip #'s and subscript digits
 		if r != instanceMarker && !('₀' <= r && r < '₀'+10) { // '₀' == U+2080
diff --git a/src/cmd/compile/internal/types2/infer.go b/src/cmd/compile/internal/types2/infer.go
index b52a834e5a..125d3f31b9 100644
--- a/src/cmd/compile/internal/types2/infer.go
+++ b/src/cmd/compile/internal/types2/infer.go
@@ -8,7 +8,7 @@
 
 package types2
 
-import "strings"
+import "bytes"
 
 // infer returns the list of actual type arguments for the given list of type parameters tparams
 // by inferring them from the actual arguments args for the parameters params. If type inference
@@ -134,7 +134,8 @@ func typeNamesString(list []*TypeName) string {
 	}
 
 	// general case (n > 2)
-	var b strings.Builder
+	// Would like to use strings.Builder but it's not available in Go 1.4.
+	var b bytes.Buffer
 	for i, tname := range list[:n-1] {
 		if i > 0 {
 			b.WriteString(", ")
diff --git a/src/cmd/compile/internal/types2/methodset.go b/src/cmd/compile/internal/types2/methodset.go
index 9f7315a0fa..eb8f1221cc 100644
--- a/src/cmd/compile/internal/types2/methodset.go
+++ b/src/cmd/compile/internal/types2/methodset.go
@@ -8,9 +8,9 @@
 package types2
 
 import (
+	"bytes"
 	"fmt"
 	"sort"
-	"strings"
 )
 
 // A MethodSet is an ordered set of concrete or abstract (interface) methods;
@@ -25,7 +25,8 @@ func (s *MethodSet) String() string {
 		return "MethodSet {}"
 	}
 
-	var buf strings.Builder
+	// Would like to use strings.Builder but it's not available in Go 1.4.
+	var buf bytes.Buffer
 	fmt.Fprintln(&buf, "MethodSet {")
 	for _, f := range s.list {
 		fmt.Fprintf(&buf, "\t%s\n", f)
diff --git a/src/cmd/compile/internal/types2/object.go b/src/cmd/compile/internal/types2/object.go
index 6e6f48c036..42fae762d3 100644
--- a/src/cmd/compile/internal/types2/object.go
+++ b/src/cmd/compile/internal/types2/object.go
@@ -10,7 +10,8 @@ import (
 	"cmd/compile/internal/syntax"
 	"fmt"
 	"go/constant"
-	"go/token"
+	"unicode"
+	"unicode/utf8"
 )
 
 // An Object describes a named language entity such as a package,
@@ -60,10 +61,15 @@ type Object interface {
 	setScopePos(pos syntax.Pos)
 }
 
+func isExported(name string) bool {
+	ch, _ := utf8.DecodeRuneInString(name)
+	return unicode.IsUpper(ch)
+}
+
 // Id returns name if it is exported, otherwise it
 // returns the name qualified with the package path.
 func Id(pkg *Package, name string) string {
-	if token.IsExported(name) {
+	if isExported(name) {
 		return name
 	}
 	// unexported names need the package path for differentiation
@@ -143,7 +149,7 @@ func (obj *object) Type() Type { return obj.typ }
 // Exported reports whether the object is exported (starts with a capital letter).
 // It doesn't take into account whether the object is in a local (function) scope
 // or not.
-func (obj *object) Exported() bool { return token.IsExported(obj.name) }
+func (obj *object) Exported() bool { return isExported(obj.name) }
 
 // Id is a wrapper for Id(obj.Pkg(), obj.Name()).
 func (obj *object) Id() string { return Id(obj.pkg, obj.name) }
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index ae5ea669f5..0edd7731fa 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -418,7 +418,7 @@ func (check *Checker) funcType(sig *Signature, recvPar *syntax.Field, tparams []
 // goTypeName returns the Go type name for typ and
 // removes any occurences of "types." from that name.
 func goTypeName(typ Type) string {
-	return strings.ReplaceAll(fmt.Sprintf("%T", typ), "types.", "")
+	return strings.Replace(fmt.Sprintf("%T", typ), "types.", "", -1) // strings.ReplaceAll is not available in Go 1.4
 }
 
 // typInternal drives type checking of types.
diff --git a/src/cmd/dist/buildtool.go b/src/cmd/dist/buildtool.go
index 37b3d45977..f5dcd34cc1 100644
--- a/src/cmd/dist/buildtool.go
+++ b/src/cmd/dist/buildtool.go
@@ -41,6 +41,7 @@ var bootstrapDirs = []string{
 	"cmd/compile/internal/arm",
 	"cmd/compile/internal/arm64",
 	"cmd/compile/internal/gc",
+	"cmd/compile/internal/importer",
 	"cmd/compile/internal/logopt",
 	"cmd/compile/internal/mips",
 	"cmd/compile/internal/mips64",
@@ -50,6 +51,7 @@ var bootstrapDirs = []string{
 	"cmd/compile/internal/ssa",
 	"cmd/compile/internal/syntax",
 	"cmd/compile/internal/types",
+	"cmd/compile/internal/types2",
 	"cmd/compile/internal/x86",
 	"cmd/compile/internal/wasm",
 	"cmd/internal/bio",
@@ -96,6 +98,7 @@ var bootstrapDirs = []string{
 	"debug/elf",
 	"debug/macho",
 	"debug/pe",
+	"go/constant",
 	"internal/goversion",
 	"internal/race",
 	"internal/unsafeheader",
diff --git a/test/typeparam/smoketest.go b/test/typeparam/smoketest.go
index d17809eb63..b7d6201b2c 100644
--- a/test/typeparam/smoketest.go
+++ b/test/typeparam/smoketest.go
@@ -30,8 +30,8 @@ type _ T3[bool]
 
 // methods
 func (T1[P]) m1() {}
-func (x T2[P1, P2, P3]) m1() {}
-func (_ T3[_]) m1() {}
+func (T1[_]) m2() {}
+func (x T2[P1, P2, P3]) m() {}
 
 // type lists
 type _ interface {
@@ -39,7 +39,6 @@ type _ interface {
 	m2()
 	type int, float32, string
 	m3()
-	type bool
 }
 
 // embedded instantiated types
diff --git a/test/typeparam/tparam1.go b/test/typeparam/tparam1.go
new file mode 100644
index 0000000000..5d6dcb6a62
--- /dev/null
+++ b/test/typeparam/tparam1.go
@@ -0,0 +1,42 @@
+// errorcheck -G
+
+// Copyright 2020 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.
+
+// Basic type parameter list type-checking (not syntax) errors.
+
+package tparam1
+
+// The predeclared identifier "any" is only visible as a constraint
+// in a type parameter list.
+var _ any // ERROR "undeclared"
+func _(_ any) // ERROR "undeclared"
+type _[_ any /* ok here */ ] struct{}
+
+const N = 10
+
+type (
+        _[] struct{} // slice
+        _[N] struct{} // array
+        _[T any] struct{}
+        _[T, T any] struct{} // ERROR "T redeclared"
+        _[T1, T2 any, T3 any] struct{}
+)
+
+func _[T any]()
+func _[T, T any]() // ERROR "T redeclared"
+func _[T1, T2 any](x T1) T2
+
+// Type parameters are visible from opening [ to end of function.
+type C interface{}
+
+func _[T interface{}]()
+func _[T C]()
+func _[T struct{}]() // ERROR "not an interface"
+func _[T interface{ m() T }]()
+func _[T1 interface{ m() T2 }, T2 interface{ m() T1 }]() {
+        var _ T1
+}
+
+// TODO(gri) expand this
-- 
GitLab


From 38af45b4cb4ce42b338ba9960419684b2c2c5e72 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 27 Oct 2020 11:19:47 -0700
Subject: [PATCH 0016/2400] [dev.typeparams] cmd/compile/internal/types2:
 review of package.go

f=package.go; diff $f ../../../../go/types/$f
5c5
< package types2
---
> package types
8a9
> 	"go/token"
25c26
< 	scope := NewScope(Universe, nopos, nopos, fmt.Sprintf("package %q", path))
---
> 	scope := NewScope(Universe, token.NoPos, token.NoPos, fmt.Sprintf("package %q", path))

Change-Id: I3a34b39e337c2d0224445e5dc5fbd4a6a53f0363
Reviewed-on: https://go-review.googlesource.com/c/go/+/265677
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/package.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/package.go b/src/cmd/compile/internal/types2/package.go
index 03ae6ff5b7..31b1e71787 100644
--- a/src/cmd/compile/internal/types2/package.go
+++ b/src/cmd/compile/internal/types2/package.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2013 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.
-- 
GitLab


From 6e98406ac3e654f4df15f662f51eda46434af332 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 27 Oct 2020 11:26:54 -0700
Subject: [PATCH 0017/2400] [dev.typeparams] cmd/compile/internal/types2:
 review of initorder.go

Difference: errorf now accepts any value that implements
the poser interface in place of a position argument. All
types2 Objects implement poser.

type poser interface {
	Pos() syntax.Pos
}

f=initorder.go; diff $f ../../../../go/types/$f
5c5
< package types2
---
> package types
154c154
< 	check.errorf(obj, "initialization cycle for %s", obj.Name())
---
> 	check.errorf(obj.Pos(), "initialization cycle for %s", obj.Name())
157c157
< 		check.errorf(obj, "\t%s refers to", obj.Name()) // secondary error, \t indented
---
> 		check.errorf(obj.Pos(), "\t%s refers to", obj.Name()) // secondary error, \t indented
161c161
< 	check.errorf(obj, "\t%s", obj.Name())
---
> 	check.errorf(obj.Pos(), "\t%s", obj.Name())

Change-Id: Id85074fd15a04bb4ff6e8b68a44be6ac5919c71a
Reviewed-on: https://go-review.googlesource.com/c/go/+/265678
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/initorder.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/initorder.go b/src/cmd/compile/internal/types2/initorder.go
index 3bb92d9622..4ef24764a6 100644
--- a/src/cmd/compile/internal/types2/initorder.go
+++ b/src/cmd/compile/internal/types2/initorder.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2014 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.
-- 
GitLab


From abb31c2558d58013ae191d926ed7cdd9d3201762 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 27 Oct 2020 11:32:44 -0700
Subject: [PATCH 0018/2400] [dev.typeparams] cmd/compile/internal/types2:
 review of hilbert_test.go

Primary differences:
1) syntax package is used instead of the go/* packages
2) parseSrc is a helper function that is used
   in place of parser.parseFile.
3) defaultImporter is a helper function providing
   access to an importer.

f=hilbert_test.go; diff $f ../../../../go/types/$f
5c5
< package types2_test
---
> package types_test
9d8
< 	"cmd/compile/internal/syntax"
11a11,14
> 	"go/ast"
> 	"go/importer"
> 	"go/parser"
> 	"go/token"
15c18
< 	. "cmd/compile/internal/types2"
---
> 	. "go/types"
32,33c35,36
< 	// TODO(gri) get rid of []bytes to string conversion below
< 	f, err := parseSrc("hilbert.go", string(src))
---
> 	fset := token.NewFileSet()
> 	f, err := parser.ParseFile(fset, "hilbert.go", src, 0)
40,41c43,44
< 	conf := Config{Importer: defaultImporter()}
< 	_, err = conf.Check(f.PkgName.Value, []*syntax.File{f}, nil)
---
> 	conf := Config{Importer: importer.Default()}
> 	_, err = conf.Check(f.Name.Name, fset, []*ast.File{f}, nil)

Change-Id: I65851725a3b6ac35b87177f90b788c469a54a986
Reviewed-on: https://go-review.googlesource.com/c/go/+/265679
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/hilbert_test.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/hilbert_test.go b/src/cmd/compile/internal/types2/hilbert_test.go
index ee0c4daea6..9f9dad6b64 100644
--- a/src/cmd/compile/internal/types2/hilbert_test.go
+++ b/src/cmd/compile/internal/types2/hilbert_test.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2013 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.
-- 
GitLab


From ff6ab114c9ed22b92b3e2c44bcdf5cbc04e33cdc Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 27 Oct 2020 11:40:00 -0700
Subject: [PATCH 0019/2400] [dev.typeparams] cmd/compile/internal/types: review
 of gccgosizes.go

Except for the package name, this file is unchanged from the go/types version.

f=gccgosizes.go; diff $f ../../../../go/types/$f
8c8
< package types2
---
> package types

Change-Id: I23a8432f3e6f21eec8220f89a24df26e91ad41ab
Reviewed-on: https://go-review.googlesource.com/c/go/+/265697
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/gccgosizes.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/gccgosizes.go b/src/cmd/compile/internal/types2/gccgosizes.go
index d3c79745a2..05aba53472 100644
--- a/src/cmd/compile/internal/types2/gccgosizes.go
+++ b/src/cmd/compile/internal/types2/gccgosizes.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2019 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.
-- 
GitLab


From c32ac6c15f52e5508ee92702aa885ad5116516cb Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 27 Oct 2020 11:43:46 -0700
Subject: [PATCH 0020/2400] [dev.typeparams] cmd/compile/internal/types: review
 of selection.go

Except for the package name, this file is unchanged from the go/types version.

f=selection.go; diff $f ../../../../go/types/$f
7c7
< package types2
---
> package types

Change-Id: I09c26a744f445ec992c554d293e3ca9896b5c849
Reviewed-on: https://go-review.googlesource.com/c/go/+/265698
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/selection.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/selection.go b/src/cmd/compile/internal/types2/selection.go
index da0e9ab526..8128aeee2e 100644
--- a/src/cmd/compile/internal/types2/selection.go
+++ b/src/cmd/compile/internal/types2/selection.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2013 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.
-- 
GitLab


From 9392b82919632d832eff2d86fbe15defd57fcb2a Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 27 Oct 2020 11:46:54 -0700
Subject: [PATCH 0021/2400] [dev.typeparams] cmd/compile/internal/types: review
 of objset.go

Except for the package name, this file is unchanged from the go/types version.

f=objset.go; diff $f ../../../../go/types/$f
11c11
< package types2
---
> package types

Change-Id: I5a03b08ec006d87cb31139f708d844fcfddbbb56
Reviewed-on: https://go-review.googlesource.com/c/go/+/265699
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/objset.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/objset.go b/src/cmd/compile/internal/types2/objset.go
index ef06315705..88ff0af9ca 100644
--- a/src/cmd/compile/internal/types2/objset.go
+++ b/src/cmd/compile/internal/types2/objset.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2013 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.
-- 
GitLab


From 41ff51ae00ed098702522572ea482de33c6525fc Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 27 Oct 2020 11:50:46 -0700
Subject: [PATCH 0022/2400] [dev.typeparams] cmd/compile/internal/types2:
 review of scopes.go

This file has a few changes compared to the go/types version:
1) syntax.Pos is used instead of token.Pos.
2) The cmpPos helper function (defined elsewhere) is used to
   compare positions (syntax.Pos positions cannot be compared
   directly with <=).
3) A new method Scope.Squash was added (primary difference).

f=scope.go; diff $f ../../../../go/types/$f
7c7
< package types2
---
> package types
11d10
< 	"cmd/compile/internal/syntax"
12a12
> 	"go/token"
26c26
< 	pos, end syntax.Pos        // scope extent; may be invalid
---
> 	pos, end token.Pos         // scope extent; may be invalid
33c33
< func NewScope(parent *Scope, pos, end syntax.Pos, comment string) *Scope {
---
> func NewScope(parent *Scope, pos, end token.Pos, comment string) *Scope {
82c82
< func (s *Scope) LookupParent(name string, pos syntax.Pos) (*Scope, Object) {
---
> func (s *Scope) LookupParent(name string, pos token.Pos) (*Scope, Object) {
84c84
< 		if obj := s.elems[name]; obj != nil && (!pos.IsKnown() || cmpPos(obj.scopePos(), pos) <= 0) {
---
> 		if obj := s.elems[name]; obj != nil && (!pos.IsValid() || obj.scopePos() <= pos) {
111,144d110
< // Squash merges s with its parent scope p by adding all
< // objects of s to p, adding all children of s to the
< // children of p, and removing s from p's children.
< // The function f is called for each object obj in s which
< // has an object alt in p. s should be discarded after
< // having been squashed.
< func (s *Scope) Squash(err func(obj, alt Object)) {
< 	p := s.parent
< 	assert(p != nil)
< 	for _, obj := range s.elems {
< 		obj.setParent(nil)
< 		if alt := p.Insert(obj); alt != nil {
< 			err(obj, alt)
< 		}
< 	}
<
< 	j := -1 // index of s in p.children
< 	for i, ch := range p.children {
< 		if ch == s {
< 			j = i
< 			break
< 		}
< 	}
< 	assert(j >= 0)
< 	k := len(p.children) - 1
< 	p.children[j] = p.children[k]
< 	p.children = p.children[:k]
<
< 	p.children = append(p.children, s.children...)
<
< 	s.children = nil
< 	s.elems = nil
< }
<
149,150c115,116
< func (s *Scope) Pos() syntax.Pos { return s.pos }
< func (s *Scope) End() syntax.Pos { return s.end }
---
> func (s *Scope) Pos() token.Pos { return s.pos }
> func (s *Scope) End() token.Pos { return s.end }
155,156c121,122
< func (s *Scope) Contains(pos syntax.Pos) bool {
< 	return cmpPos(s.pos, pos) <= 0 && cmpPos(pos, s.end) < 0
---
> func (s *Scope) Contains(pos token.Pos) bool {
> 	return s.pos <= pos && pos < s.end
164c130
< func (s *Scope) Innermost(pos syntax.Pos) *Scope {
---
> func (s *Scope) Innermost(pos token.Pos) *Scope {

Change-Id: If6c459f45dae8980ffb3a902a46b1700e9b55dc7
Reviewed-on: https://go-review.googlesource.com/c/go/+/265700
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/scope.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/scope.go b/src/cmd/compile/internal/types2/scope.go
index c8243ac36c..fd0b6241f5 100644
--- a/src/cmd/compile/internal/types2/scope.go
+++ b/src/cmd/compile/internal/types2/scope.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2013 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.
-- 
GitLab


From 6877ee1e07d82896becc2f624ef314613d3df4a0 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 10 Nov 2020 13:28:17 -0800
Subject: [PATCH 0023/2400] [dev.typeparams] cmd/compile: use existing findpkg
 algorithm when importing through types2

Change-Id: I9044de7829d22addb5bc570401508082e3f007eb
Reviewed-on: https://go-review.googlesource.com/c/go/+/269057
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/cmd/compile/internal/gc/noder.go |  7 +++++++
 test/typeparam/importtest.go         | 16 ++++++++++++++++
 2 files changed, 23 insertions(+)
 create mode 100644 test/typeparam/importtest.go

diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 14bacc14a8..4ed91035a5 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -95,6 +95,13 @@ func parseFiles(filenames []string, allowGenerics bool) (lines uint) {
 			},
 			Importer: &gcimports{
 				packages: make(map[string]*types2.Package),
+				lookup: func(path string) (io.ReadCloser, error) {
+					file, ok := findpkg(path)
+					if !ok {
+						return nil, fmt.Errorf("can't find import: %q", path)
+					}
+					return os.Open(file)
+				},
 			},
 		}
 		conf.Check(Ctxt.Pkgpath, files, nil)
diff --git a/test/typeparam/importtest.go b/test/typeparam/importtest.go
new file mode 100644
index 0000000000..9cb30e8a7c
--- /dev/null
+++ b/test/typeparam/importtest.go
@@ -0,0 +1,16 @@
+// compile -G
+
+// Copyright 2020 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.
+
+// This file checks that basic importing works in -G mode.
+
+package p
+
+import "fmt"
+import "math"
+
+func f(x float64) {
+	fmt.Println(math.Sin(x))
+}
-- 
GitLab


From 21400491728520e648d8f1634605ea2b704a8fc2 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 17 Nov 2020 16:12:29 -0800
Subject: [PATCH 0024/2400] [dev.typeparams] cmd/compile/internal/types2: port
 of https://golang.org/cl/270957

This ports the latest updates to the dev.go2go version of types2
to the dev.typeparams version.

Change-Id: Ic1b09a8aaeefc701a5c194a587be26e0878e64da
Reviewed-on: https://go-review.googlesource.com/c/go/+/270958
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/expr.go       | 65 +++++++++++++++----
 .../internal/types2/testdata/expr3.src        |  1 +
 .../internal/types2/testdata/typeparams.go2   | 10 ++-
 3 files changed, 61 insertions(+), 15 deletions(-)

diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index f83aa86f6e..7c07950b01 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -1467,18 +1467,18 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 			var key operand
 			check.expr(&key, e.Index)
 			check.assignment(&key, typ.key, "map index")
-			if x.mode == invalid {
-				goto Error
-			}
+			// ok to continue even if indexing failed - map element type is known
 			x.mode = mapindex
 			x.typ = typ.elem
 			x.expr = e
 			return expression
 
 		case *Sum:
-			// A sum type can be indexed if all the sum's types
-			// support indexing and have the same element type.
-			var elem Type
+			// A sum type can be indexed if all of the sum's types
+			// support indexing and have the same index and element
+			// type. Special rules apply for maps in the sum type.
+			var tkey, telem Type // key is for map types only
+			nmaps := 0           // number of map types in sum type
 			if typ.is(func(t Type) bool {
 				var e Type
 				switch t := t.Under().(type) {
@@ -1495,21 +1495,58 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 				case *Slice:
 					e = t.elem
 				case *Map:
+					// If there are multiple maps in the sum type,
+					// they must have identical key types.
+					// TODO(gri) We may be able to relax this rule
+					// but it becomes complicated very quickly.
+					if tkey != nil && !Identical(t.key, tkey) {
+						return false
+					}
+					tkey = t.key
 					e = t.elem
+					nmaps++
 				case *TypeParam:
 					check.errorf(x, "type of %s contains a type parameter - cannot index (implementation restriction)", x)
 				case *instance:
-					unimplemented()
+					panic("unimplemented")
 				}
-				if e != nil && (e == elem || elem == nil) {
-					elem = e
-					return true
+				if e == nil || telem != nil && !Identical(e, telem) {
+					return false
 				}
-				return false
+				telem = e
+				return true
 			}) {
-				valid = true
-				x.mode = variable
-				x.typ = elem
+				// If there are maps, the index expression must be assignable
+				// to the map key type (as for simple map index expressions).
+				if nmaps > 0 {
+					var key operand
+					check.expr(&key, e.Index)
+					check.assignment(&key, tkey, "map index")
+					// ok to continue even if indexing failed - map element type is known
+
+					// If there are only maps, we are done.
+					if nmaps == len(typ.types) {
+						x.mode = mapindex
+						x.typ = telem
+						x.expr = e
+						return expression
+					}
+
+					// Otherwise we have mix of maps and other types. For
+					// now we require that the map key be an integer type.
+					// TODO(gri) This is probably not good enough.
+					valid = isInteger(tkey)
+					// avoid 2nd indexing error if indexing failed above
+					if !valid && key.mode == invalid {
+						goto Error
+					}
+					x.mode = value // map index expressions are not addressable
+				} else {
+					// no maps
+					valid = true
+					x.mode = variable
+				}
+				x.typ = telem
 			}
 		}
 
diff --git a/src/cmd/compile/internal/types2/testdata/expr3.src b/src/cmd/compile/internal/types2/testdata/expr3.src
index 3c6e36f148..071c9bb367 100644
--- a/src/cmd/compile/internal/types2/testdata/expr3.src
+++ b/src/cmd/compile/internal/types2/testdata/expr3.src
@@ -103,6 +103,7 @@ func indexes() {
 	var ok mybool
 	_, ok = m["bar"]
 	_ = ok
+	_ = m[0 /* ERROR "cannot convert 0" */ ] + "foo" // ERROR "cannot convert"
 
 	var t string
 	_ = t[- /* ERROR "negative" */ 1]
diff --git a/src/cmd/compile/internal/types2/testdata/typeparams.go2 b/src/cmd/compile/internal/types2/testdata/typeparams.go2
index 54cb34ec3b..04f563029f 100644
--- a/src/cmd/compile/internal/types2/testdata/typeparams.go2
+++ b/src/cmd/compile/internal/types2/testdata/typeparams.go2
@@ -94,11 +94,19 @@ func _[T any] (x T, i int) { _ = x /* ERROR "cannot index" */ [i] }
 func _[T interface{ type int }] (x T, i int) { _ = x /* ERROR "cannot index" */ [i] }
 func _[T interface{ type string }] (x T, i int) { _ = x[i] }
 func _[T interface{ type []int }] (x T, i int) { _ = x[i] }
-func _[T interface{ type [10]int, *[20]int, map[string]int }] (x T, i int) { _ = x[i] }
+func _[T interface{ type [10]int, *[20]int, map[int]int }] (x T, i int) { _ = x[i] }
 func _[T interface{ type string, []byte }] (x T, i int) { _ = x[i] }
 func _[T interface{ type []int, [1]rune }] (x T, i int) { _ = x /* ERROR "cannot index" */ [i] }
 func _[T interface{ type string, []rune }] (x T, i int) { _ = x /* ERROR "cannot index" */ [i] }
 
+// indexing with various combinations of map types in type lists (see issue #42616)
+func _[T interface{ type []E, map[int]E }, E any](x T, i int) { _ = x[i] }
+func _[T interface{ type []E }, E any](x T, i int) { _ = &x[i] }
+func _[T interface{ type map[int]E }, E any](x T, i int) { _, _ = x[i] } // comma-ok permitted
+func _[T interface{ type []E, map[int]E }, E any](x T, i int) { _ = &x /* ERROR cannot take address */ [i] }
+func _[T interface{ type []E, map[int]E, map[uint]E }, E any](x T, i int) { _ = x /* ERROR cannot index */ [i] } // different map element types
+func _[T interface{ type []E, map[string]E }, E any](x T, i int) { _ = x[i /* ERROR cannot use i */ ] }
+
 // slicing
 // TODO(gri) implement this
 
-- 
GitLab


From 0123c9b32165302deb200683b4f855d572a934b6 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 19 Nov 2020 09:09:15 -0800
Subject: [PATCH 0025/2400] [dev.typeparams] cmd/compile/internal/types2:
 report an error for invalid constant values

This is https://golang.org/cl/271377 ported to types2.

Updates #42695.

Change-Id: I475bdcaeace5b0e87d4476a6d660996534289666
Reviewed-on: https://go-review.googlesource.com/c/go/+/271520
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/types2/expr.go         |  6 +++++-
 .../internal/types2/fixedbugs/issue42695.src    | 17 +++++++++++++++++
 src/cmd/compile/internal/types2/operand.go      |  8 +++++++-
 3 files changed, 29 insertions(+), 2 deletions(-)
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue42695.src

diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 7c07950b01..94649ca4cc 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -1168,7 +1168,11 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 	case *syntax.BasicLit:
 		x.setConst(e.Kind, e.Value)
 		if x.mode == invalid {
-			check.invalidASTf(e, "invalid literal %v", e.Value)
+			// The parser already establishes syntactic correctness.
+			// If we reach here it's because of number under-/overflow.
+			// TODO(gri) setConst (and in turn the go/constant package)
+			// should return an error describing the issue.
+			check.errorf(e, "malformed constant: %s", e.Value)
 			goto Error
 		}
 
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue42695.src b/src/cmd/compile/internal/types2/fixedbugs/issue42695.src
new file mode 100644
index 0000000000..d0d6200969
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue42695.src
@@ -0,0 +1,17 @@
+// Copyright 2020 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 issue42695
+
+const _ = 6e5518446744 // ERROR malformed constant
+const _ uint8 = 6e5518446744 // ERROR malformed constant
+
+var _ = 6e5518446744 // ERROR malformed constant
+var _ uint8 = 6e5518446744 // ERROR malformed constant
+
+func f(x int) int {
+        return x + 6e5518446744 // ERROR malformed constant
+}
+
+var _ = f(6e5518446744 /* ERROR malformed constant */ )
diff --git a/src/cmd/compile/internal/types2/operand.go b/src/cmd/compile/internal/types2/operand.go
index fe88921893..0a19760423 100644
--- a/src/cmd/compile/internal/types2/operand.go
+++ b/src/cmd/compile/internal/types2/operand.go
@@ -211,9 +211,15 @@ func (x *operand) setConst(k syntax.LitKind, lit string) {
 		unreachable()
 	}
 
+	val := constant.MakeFromLiteral(lit, tok, 0)
+	if val.Kind() == constant.Unknown {
+		x.mode = invalid
+		x.typ = Typ[Invalid]
+		return
+	}
 	x.mode = constant_
 	x.typ = Typ[kind]
-	x.val = constant.MakeFromLiteral(lit, tok, 0)
+	x.val = val
 }
 
 // isNil reports whether x is the nil value.
-- 
GitLab


From 8fbdacf64c982b9a7f8cb27754bb01cedffa53c7 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 19 Nov 2020 17:49:05 -0800
Subject: [PATCH 0026/2400] [dev.typeparams] cmd/compile/internal/types2:
 report constant overflow in binary ops

This is the go.types changes of https://golang.org/cl/271706
ported to types2.

Also: Fixed a bug in the go/types version (was using the
wrong position in the error message).

Change-Id: I798b80243a66f0be5b943a6951d7a1ff769abca2
Reviewed-on: https://go-review.googlesource.com/c/go/+/271806
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/expr.go              | 12 ++++++++++--
 .../compile/internal/types2/fixedbugs/issue20583.src | 12 ++++++++++++
 src/cmd/compile/internal/types2/stmt.go              |  2 +-
 src/go/types/expr.go                                 |  2 +-
 4 files changed, 24 insertions(+), 4 deletions(-)
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue20583.src

diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 94649ca4cc..e166e9926c 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -897,7 +897,7 @@ var binaryOpPredicates = opPredicates{
 }
 
 // The binary expression e may be nil. It's passed in for better error messages only.
-func (check *Checker) binary(x *operand, e *syntax.Operation, lhs, rhs syntax.Expr, op syntax.Operator) {
+func (check *Checker) binary(x *operand, e *syntax.Operation, lhs, rhs syntax.Expr, op syntax.Operator, opPos syntax.Pos) {
 	var y operand
 
 	check.expr(x, lhs)
@@ -977,6 +977,14 @@ func (check *Checker) binary(x *operand, e *syntax.Operation, lhs, rhs syntax.Ex
 			tok = token.QUO_ASSIGN
 		}
 		x.val = constant.BinaryOp(xval, tok, yval)
+		// report error if valid operands lead to an invalid result
+		if xval.Kind() != constant.Unknown && yval.Kind() != constant.Unknown && x.val.Kind() == constant.Unknown {
+			// TODO(gri) We should report exactly what went wrong. At the
+			//           moment we don't have the (go/constant) API for that.
+			//           See also TODO in go/constant/value.go.
+			check.errorf(opPos, "constant result is not representable")
+			// TODO(gri) Should we mark operands with unknown values as invalid?
+		}
 		// Typed constants must be representable in
 		// their type after each constant operation.
 		if isTyped(typ) {
@@ -1791,7 +1799,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 		}
 
 		// binary expression
-		check.binary(x, e, e.X, e.Y, e.Op)
+		check.binary(x, e, e.X, e.Y, e.Op, e.Y.Pos()) // TODO(gri) should have OpPos here (like in go/types)
 		if x.mode == invalid {
 			goto Error
 		}
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue20583.src b/src/cmd/compile/internal/types2/fixedbugs/issue20583.src
new file mode 100644
index 0000000000..efc1acee0f
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue20583.src
@@ -0,0 +1,12 @@
+// Copyright 2020 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 issue20583
+const (
+	_ = 6e886451608 /* ERROR malformed constant */ /2
+	_ = 6e886451608i /* ERROR malformed constant */ /2
+	_ = 0 * 1e+1000000000 // ERROR malformed constant
+	x = 1e100000000
+	_ = x*x*x*x*x*x*x /* ERROR not representable */ // TODO(gri) this error should be at the last *
+)
diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go
index 2f1347faf4..d88f65b15e 100644
--- a/src/cmd/compile/internal/types2/stmt.go
+++ b/src/cmd/compile/internal/types2/stmt.go
@@ -396,7 +396,7 @@ func (check *Checker) stmt(ctxt stmtContext, s syntax.Stmt) {
 			}
 
 			var x operand
-			check.binary(&x, nil, lhs[0], rhs[0], s.Op)
+			check.binary(&x, nil, lhs[0], rhs[0], s.Op, rhs[0].Pos()) // TODO(gri) should have TokPos here (like in go/types)
 			if x.mode == invalid {
 				return
 			}
diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 4e19f30477..eb2056125a 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -890,7 +890,7 @@ func (check *Checker) binary(x *operand, e *ast.BinaryExpr, lhs, rhs ast.Expr, o
 			// TODO(gri) We should report exactly what went wrong. At the
 			//           moment we don't have the (go/constant) API for that.
 			//           See also TODO in go/constant/value.go.
-			check.errorf(atPos(e.OpPos), _InvalidConstVal, "constant result is not representable")
+			check.errorf(atPos(opPos), _InvalidConstVal, "constant result is not representable")
 			// TODO(gri) Should we mark operands with unknown values as invalid?
 		}
 		// Typed constants must be representable in
-- 
GitLab


From e1047302bdbfcac0f2331ebd5f6126a8b3c3b9b3 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 23 Nov 2020 00:15:40 -0800
Subject: [PATCH 0027/2400] [dev.regabi] cmd/compile/internal/types: add
 pos/sym/typ params to NewField

These are almost always set, so might as well expect callers to
provide them. They're also all required by go/types's corresponding
New{Field,Func,Param,Var} functions, so this eases API compatibility.

Passes toolstash-check.

Change-Id: Ib3fa355d4961243cd285b41915e87652ae2c22f6
Reviewed-on: https://go-review.googlesource.com/c/go/+/272386
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/gc/align.go    |  7 ++---
 src/cmd/compile/internal/gc/closure.go  |  5 ++--
 src/cmd/compile/internal/gc/dcl.go      | 39 ++++---------------------
 src/cmd/compile/internal/gc/iimport.go  | 28 ++++--------------
 src/cmd/compile/internal/gc/reflect.go  | 12 +++-----
 src/cmd/compile/internal/gc/universe.go | 17 ++++++-----
 src/cmd/compile/internal/types/type.go  | 11 +++++--
 7 files changed, 37 insertions(+), 82 deletions(-)

diff --git a/src/cmd/compile/internal/gc/align.go b/src/cmd/compile/internal/gc/align.go
index a3a0c8fce8..1f7631d199 100644
--- a/src/cmd/compile/internal/gc/align.go
+++ b/src/cmd/compile/internal/gc/align.go
@@ -74,11 +74,8 @@ func expandiface(t *types.Type) {
 		// (including broken ones, if any) and add to t's
 		// method set.
 		for _, t1 := range m.Type.Fields().Slice() {
-			f := types.NewField()
-			f.Pos = m.Pos // preserve embedding position
-			f.Sym = t1.Sym
-			f.Type = t1.Type
-			f.SetBroke(t1.Broke())
+			// Use m.Pos rather than t1.Pos to preserve embedding position.
+			f := types.NewField(m.Pos, t1.Sym, t1.Type)
 			addMethod(f, false)
 		}
 	}
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index bd350f696e..42a9b4f3e8 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"cmd/compile/internal/syntax"
 	"cmd/compile/internal/types"
+	"cmd/internal/src"
 	"fmt"
 )
 
@@ -266,10 +267,8 @@ func transformclosure(xfunc *Node) {
 			v.SetClass(PPARAM)
 			decls = append(decls, v)
 
-			fld := types.NewField()
+			fld := types.NewField(src.NoXPos, v.Sym, v.Type)
 			fld.Nname = asTypesNode(v)
-			fld.Type = v.Type
-			fld.Sym = v.Sym
 			params = append(params, fld)
 		}
 
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 6e90eb4d65..96c3a6faba 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -543,35 +543,19 @@ func structfield(n *Node) *types.Field {
 		Fatalf("structfield: oops %v\n", n)
 	}
 
-	f := types.NewField()
-	f.Pos = n.Pos
-	f.Sym = n.Sym
-
 	if n.Left != nil {
 		n.Left = typecheck(n.Left, ctxType)
 		n.Type = n.Left.Type
 		n.Left = nil
 	}
 
-	f.Type = n.Type
-	if f.Type == nil {
-		f.SetBroke(true)
-	}
-
+	f := types.NewField(n.Pos, n.Sym, n.Type)
 	if n.Embedded() {
 		checkembeddedtype(n.Type)
 		f.Embedded = 1
-	} else {
-		f.Embedded = 0
 	}
-
-	switch u := n.Val().U.(type) {
-	case string:
-		f.Note = u
-	default:
-		yyerror("field tag must be a string")
-	case nil:
-		// no-op
+	if n.HasVal() {
+		f.Note = n.Val().U.(string)
 	}
 
 	lineno = lno
@@ -671,13 +655,7 @@ func interfacefield(n *Node) *types.Field {
 		n.Left = nil
 	}
 
-	f := types.NewField()
-	f.Pos = n.Pos
-	f.Sym = n.Sym
-	f.Type = n.Type
-	if f.Type == nil {
-		f.SetBroke(true)
-	}
+	f := types.NewField(n.Pos, n.Sym, n.Type)
 
 	lineno = lno
 	return f
@@ -705,9 +683,7 @@ func fakeRecv() *Node {
 }
 
 func fakeRecvField() *types.Field {
-	f := types.NewField()
-	f.Type = types.FakeRecvType()
-	return f
+	return types.NewField(src.NoXPos, nil, types.FakeRecvType())
 }
 
 // isifacemethod reports whether (field) m is
@@ -920,10 +896,7 @@ func addmethod(msym *types.Sym, t *types.Type, local, nointerface bool) *types.F
 		return f
 	}
 
-	f := types.NewField()
-	f.Pos = lineno
-	f.Sym = msym
-	f.Type = t
+	f := types.NewField(lineno, msym, t)
 	f.SetNointerface(nointerface)
 
 	mt.Methods().Append(f)
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index c0114d0e53..376a167e16 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -327,11 +327,7 @@ func (r *importReader) doDecl(n *Node) {
 			recv := r.param()
 			mtyp := r.signature(recv)
 
-			f := types.NewField()
-			f.Pos = mpos
-			f.Sym = msym
-			f.Type = mtyp
-			ms[i] = f
+			ms[i] = types.NewField(mpos, msym, mtyp)
 
 			m := newfuncnamel(mpos, methodSym(recv.Type, msym))
 			m.Type = mtyp
@@ -547,10 +543,7 @@ func (r *importReader) typ1() *types.Type {
 			emb := r.bool()
 			note := r.string()
 
-			f := types.NewField()
-			f.Pos = pos
-			f.Sym = sym
-			f.Type = typ
+			f := types.NewField(pos, sym, typ)
 			if emb {
 				f.Embedded = 1
 			}
@@ -571,10 +564,7 @@ func (r *importReader) typ1() *types.Type {
 			pos := r.pos()
 			typ := r.typ()
 
-			f := types.NewField()
-			f.Pos = pos
-			f.Type = typ
-			embeddeds[i] = f
+			embeddeds[i] = types.NewField(pos, nil, typ)
 		}
 
 		methods := make([]*types.Field, r.uint64())
@@ -583,11 +573,7 @@ func (r *importReader) typ1() *types.Type {
 			sym := r.ident()
 			typ := r.signature(fakeRecvField())
 
-			f := types.NewField()
-			f.Pos = pos
-			f.Sym = sym
-			f.Type = typ
-			methods[i] = f
+			methods[i] = types.NewField(pos, sym, typ)
 		}
 
 		t := types.New(TINTER)
@@ -624,11 +610,7 @@ func (r *importReader) paramList() []*types.Field {
 }
 
 func (r *importReader) param() *types.Field {
-	f := types.NewField()
-	f.Pos = r.pos()
-	f.Sym = r.ident()
-	f.Type = r.typ()
-	return f
+	return types.NewField(r.pos(), r.ident(), r.typ())
 }
 
 func (r *importReader) bool() bool {
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 9401eba7a5..05e476b76b 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -73,10 +73,8 @@ func uncommonSize(t *types.Type) int { // Sizeof(runtime.uncommontype{})
 }
 
 func makefield(name string, t *types.Type) *types.Field {
-	f := types.NewField()
-	f.Type = t
-	f.Sym = (*types.Pkg)(nil).Lookup(name)
-	return f
+	sym := (*types.Pkg)(nil).Lookup(name)
+	return types.NewField(src.NoXPos, sym, t)
 }
 
 // bmap makes the map bucket type given the type of the map.
@@ -301,13 +299,11 @@ func hiter(t *types.Type) *types.Type {
 // stksize bytes of args.
 func deferstruct(stksize int64) *types.Type {
 	makefield := func(name string, typ *types.Type) *types.Field {
-		f := types.NewField()
-		f.Type = typ
 		// Unlike the global makefield function, this one needs to set Pkg
 		// because these types might be compared (in SSA CSE sorting).
 		// TODO: unify this makefield and the global one above.
-		f.Sym = &types.Sym{Name: name, Pkg: localpkg}
-		return f
+		sym := &types.Sym{Name: name, Pkg: localpkg}
+		return types.NewField(src.NoXPos, sym, typ)
 	}
 	argtype := types.NewArray(types.Types[TUINT8], stksize)
 	argtype.Width = stksize
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index ff8cabd8e3..559d47da1a 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -6,7 +6,10 @@
 
 package gc
 
-import "cmd/compile/internal/types"
+import (
+	"cmd/compile/internal/types"
+	"cmd/internal/src"
+)
 
 // builtinpkg is a fake package that declares the universe block.
 var builtinpkg *types.Pkg
@@ -355,16 +358,14 @@ func typeinit() {
 }
 
 func makeErrorInterface() *types.Type {
-	field := types.NewField()
-	field.Type = types.Types[TSTRING]
-	f := functypefield(fakeRecvField(), nil, []*types.Field{field})
+	sig := functypefield(fakeRecvField(), nil, []*types.Field{
+		types.NewField(src.NoXPos, nil, types.Types[TSTRING]),
+	})
 
-	field = types.NewField()
-	field.Sym = lookup("Error")
-	field.Type = f
+	method := types.NewField(src.NoXPos, lookup("Error"), sig)
 
 	t := types.New(TINTER)
-	t.SetInterface([]*types.Field{field})
+	t.SetInterface([]*types.Field{method})
 	return t
 }
 
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 023ab9af88..c6d14e9e09 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -583,10 +583,17 @@ func NewFuncArgs(f *Type) *Type {
 	return t
 }
 
-func NewField() *Field {
-	return &Field{
+func NewField(pos src.XPos, sym *Sym, typ *Type) *Field {
+	f := &Field{
+		Pos:    pos,
+		Sym:    sym,
+		Type:   typ,
 		Offset: BADWIDTH,
 	}
+	if typ == nil {
+		f.SetBroke(true)
+	}
+	return f
 }
 
 // SubstAny walks t, replacing instances of "any" with successive
-- 
GitLab


From b30c7a80443c6aed5a7f57ae4c57d691ea88ad9a Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 22 Nov 2020 13:47:55 -0800
Subject: [PATCH 0028/2400] [dev.regabi] cmd/compile/internal/gc: add
 MethodName for getting referenced method

A common operation throughout the front end is getting the ONAME for a
method used in a method selector, method expression, or method value.
This CL adds MethodName as a uniform API for doing this for all of
these kinds of nodes.

For method selectors (ODOTMETH) and method expressions (ONAMEs where
isMethodExpression reports true), we take advantage of the Node.Opt
field to save the types.Field. This is the approach we already started
taking in golang.org/cl/271217 (caching types.Field in Node.Opt for
ODOT).

For method values (OCALLPART), we continue using the existing
callpartMethod helper function. Escape analysis already uses Node.Opt
for tracking the method value's closure's data flow.

A subsequent, automated refactoring CL will make more use of this
method. For now, we just address a few cases in inl.go that aren't
easily automated.

Passes toolstash-check.

Change-Id: Ic92b288b2d8b2fa7e18e3b68634326b8ef0d869b
Reviewed-on: https://go-review.googlesource.com/c/go/+/272387
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/fmtmap_test.go           |  1 -
 src/cmd/compile/internal/gc/closure.go   |  1 +
 src/cmd/compile/internal/gc/inl.go       | 11 ++---------
 src/cmd/compile/internal/gc/syntax.go    |  6 +++++-
 src/cmd/compile/internal/gc/typecheck.go | 21 +++++++++++++++++++++
 5 files changed, 29 insertions(+), 11 deletions(-)

diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
index 0811df7f7b..a8698de307 100644
--- a/src/cmd/compile/fmtmap_test.go
+++ b/src/cmd/compile/fmtmap_test.go
@@ -50,7 +50,6 @@ var knownFormats = map[string]string{
 	"*cmd/compile/internal/types.Sym %v":              "",
 	"*cmd/compile/internal/types.Type %#L":            "",
 	"*cmd/compile/internal/types.Type %#v":            "",
-	"*cmd/compile/internal/types.Type %+v":            "",
 	"*cmd/compile/internal/types.Type %-S":            "",
 	"*cmd/compile/internal/types.Type %0S":            "",
 	"*cmd/compile/internal/types.Type %L":             "",
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index 42a9b4f3e8..dd6640667d 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -435,6 +435,7 @@ func typecheckpartialcall(fn *Node, sym *types.Sym) {
 	fn.Right = newname(sym)
 	fn.Op = OCALLPART
 	fn.Type = xfunc.Type
+	fn.SetOpt(nil) // clear types.Field from ODOTMETH
 }
 
 // makepartialcall returns a DCLFUNC node representing the wrapper function (*-fm) needed
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 419056985f..1fab67391b 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -358,9 +358,6 @@ func (v *hairyVisitor) visit(n *Node) bool {
 		if t == nil {
 			Fatalf("no function type for [%p] %+v\n", n.Left, n.Left)
 		}
-		if t.Nname() == nil {
-			Fatalf("no function definition for [%p] %+v\n", t, t)
-		}
 		if isRuntimePkg(n.Left.Sym.Pkg) {
 			fn := n.Left.Sym.Name
 			if fn == "heapBits.nextArena" {
@@ -372,7 +369,7 @@ func (v *hairyVisitor) visit(n *Node) bool {
 				break
 			}
 		}
-		if inlfn := asNode(t.FuncType().Nname).Func; inlfn.Inl != nil {
+		if inlfn := n.Left.MethodName().Func; inlfn.Inl != nil {
 			v.budget -= inlfn.Inl.Cost
 			break
 		}
@@ -703,11 +700,7 @@ func inlnode(n *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 			Fatalf("no function type for [%p] %+v\n", n.Left, n.Left)
 		}
 
-		if n.Left.Type.Nname() == nil {
-			Fatalf("no function definition for [%p] %+v\n", n.Left.Type, n.Left.Type)
-		}
-
-		n = mkinlcall(n, asNode(n.Left.Type.FuncType().Nname), maxCost, inlMap)
+		n = mkinlcall(n, n.Left.MethodName(), maxCost, inlMap)
 	}
 
 	lineno = lno
diff --git a/src/cmd/compile/internal/gc/syntax.go b/src/cmd/compile/internal/gc/syntax.go
index 43358333b8..e46a0dadf3 100644
--- a/src/cmd/compile/internal/gc/syntax.go
+++ b/src/cmd/compile/internal/gc/syntax.go
@@ -266,7 +266,11 @@ func (n *Node) Opt() interface{} {
 // SetOpt sets the optimizer data for the node, which must not have been used with SetVal.
 // SetOpt(nil) is ignored for Vals to simplify call sites that are clearing Opts.
 func (n *Node) SetOpt(x interface{}) {
-	if x == nil && n.HasVal() {
+	if x == nil {
+		if n.HasOpt() {
+			n.SetHasOpt(false)
+			n.E = nil
+		}
 		return
 	}
 	if n.HasVal() {
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index c0b05035f0..1c371c0e9d 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -2416,6 +2416,7 @@ func typecheckMethodExpr(n *Node) (res *Node) {
 	n.Type = methodfunc(m.Type, n.Left.Type)
 	n.Xoffset = 0
 	n.SetClass(PFUNC)
+	n.SetOpt(m)
 	// methodSym already marked n.Sym as a function.
 
 	// Issue 25065. Make sure that we emit the symbol for a local method.
@@ -2538,6 +2539,7 @@ func lookdot(n *Node, t *types.Type, dostrcmp int) *types.Field {
 		n.Xoffset = f2.Offset
 		n.Type = f2.Type
 		n.Op = ODOTMETH
+		n.SetOpt(f2)
 
 		return f2
 	}
@@ -4017,3 +4019,22 @@ func curpkg() *types.Pkg {
 
 	return fnpkg(fn)
 }
+
+// MethodName returns the ONAME representing the method
+// referenced by expression n, which must be a method selector,
+// method expression, or method value.
+func (n *Node) MethodName() *Node {
+	return asNode(n.MethodFunc().Type.Nname())
+}
+
+// MethodFunc is like MethodName, but returns the types.Field instead.
+func (n *Node) MethodFunc() *types.Field {
+	switch {
+	case n.Op == ODOTMETH || n.isMethodExpression():
+		return n.Opt().(*types.Field)
+	case n.Op == OCALLPART:
+		return callpartMethod(n)
+	}
+	Fatalf("unexpected node: %v (%v)", n, n.Op)
+	panic("unreachable")
+}
-- 
GitLab


From a324aebb7ddc38c8d52165df4db75bf7ea63480e Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 23 Nov 2020 17:15:00 -0800
Subject: [PATCH 0029/2400] [dev.typeparams] go/types,
 cmd/compile/internal/types2: fix incorrect string(int) conversion
 (regression)

This is a 1:1 port of the go/types changes in
https://golang.org/cl/272666 (master branch).

Updates #42790.

Change-Id: I5da372961df48129b25777ed705b84d7201393ec
Reviewed-on: https://go-review.googlesource.com/c/go/+/272669
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/types2/conversions.go | 16 ++++++++--------
 src/go/types/conversions.go                    | 16 ++++++++--------
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/cmd/compile/internal/types2/conversions.go b/src/cmd/compile/internal/types2/conversions.go
index 9ff548593f..0f6a990935 100644
--- a/src/cmd/compile/internal/types2/conversions.go
+++ b/src/cmd/compile/internal/types2/conversions.go
@@ -7,7 +7,10 @@
 
 package types2
 
-import "go/constant"
+import (
+	"go/constant"
+	"unicode"
+)
 
 // Conversion type-checks the conversion T(x).
 // The result is in x.
@@ -22,14 +25,11 @@ func (check *Checker) conversion(x *operand, T Type) {
 		case representableConst(x.val, check, t, &x.val):
 			ok = true
 		case isInteger(x.typ) && isString(t):
-			codepoint := int64(-1)
-			if i, ok := constant.Int64Val(x.val); ok {
-				codepoint = i
+			codepoint := unicode.ReplacementChar
+			if i, ok := constant.Uint64Val(x.val); ok && i <= unicode.MaxRune {
+				codepoint = rune(i)
 			}
-			// If codepoint < 0 the absolute value is too large (or unknown) for
-			// conversion. This is the same as converting any other out-of-range
-			// value - let string(codepoint) do the work.
-			x.val = constant.MakeString(string(rune(codepoint)))
+			x.val = constant.MakeString(string(codepoint))
 			ok = true
 		}
 	case x.convertibleTo(check, T):
diff --git a/src/go/types/conversions.go b/src/go/types/conversions.go
index 0955391d7b..1cab1cc70f 100644
--- a/src/go/types/conversions.go
+++ b/src/go/types/conversions.go
@@ -6,7 +6,10 @@
 
 package types
 
-import "go/constant"
+import (
+	"go/constant"
+	"unicode"
+)
 
 // Conversion type-checks the conversion T(x).
 // The result is in x.
@@ -21,14 +24,11 @@ func (check *Checker) conversion(x *operand, T Type) {
 		case representableConst(x.val, check, t, &x.val):
 			ok = true
 		case isInteger(x.typ) && isString(t):
-			codepoint := int64(-1)
-			if i, ok := constant.Int64Val(x.val); ok {
-				codepoint = i
+			codepoint := unicode.ReplacementChar
+			if i, ok := constant.Uint64Val(x.val); ok && i <= unicode.MaxRune {
+				codepoint = rune(i)
 			}
-			// If codepoint < 0 the absolute value is too large (or unknown) for
-			// conversion. This is the same as converting any other out-of-range
-			// value - let string(codepoint) do the work.
-			x.val = constant.MakeString(string(rune(codepoint)))
+			x.val = constant.MakeString(string(codepoint))
 			ok = true
 		}
 	case x.convertibleTo(check, T):
-- 
GitLab


From d5928847debd0b16f89a5fd018646b2e3e9a8cb9 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 22 Nov 2020 10:45:44 -0800
Subject: [PATCH 0030/2400] [dev.regabi] cmd/compile/internal/gc: prep for
 Func.Nname removal refactoring

There are three bits of method-handling code where we separately go
from Field->Type and then Type->Node. By shuffling the code around a
little to go Field->Type->Node in a single statement, we're able to
more easily remove Type from the operation.

Passes toolstash-check.

Change-Id: Ife98216d70d3b867fa153449abef0e56a4fb242a
Reviewed-on: https://go-review.googlesource.com/c/go/+/272388
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/gc/bexport.go   | 16 ++++++++++------
 src/cmd/compile/internal/gc/dcl.go       |  3 ++-
 src/cmd/compile/internal/gc/iexport.go   |  5 ++---
 src/cmd/compile/internal/gc/iimport.go   | 11 +++--------
 src/cmd/compile/internal/gc/typecheck.go |  2 +-
 5 files changed, 18 insertions(+), 19 deletions(-)

diff --git a/src/cmd/compile/internal/gc/bexport.go b/src/cmd/compile/internal/gc/bexport.go
index 10f21f86df..f4720f8402 100644
--- a/src/cmd/compile/internal/gc/bexport.go
+++ b/src/cmd/compile/internal/gc/bexport.go
@@ -12,6 +12,15 @@ type exporter struct {
 	marked map[*types.Type]bool // types already seen by markType
 }
 
+// markObject visits a reachable object.
+func (p *exporter) markObject(n *Node) {
+	if n.Op == ONAME && n.Class() == PFUNC {
+		inlFlood(n)
+	}
+
+	p.markType(n.Type)
+}
+
 // markType recursively visits types reachable from t to identify
 // functions whose inline bodies may be needed.
 func (p *exporter) markType(t *types.Type) {
@@ -28,7 +37,7 @@ func (p *exporter) markType(t *types.Type) {
 	if t.Sym != nil && t.Etype != TINTER {
 		for _, m := range t.Methods().Slice() {
 			if types.IsExported(m.Sym.Name) {
-				p.markType(m.Type)
+				p.markObject(asNode(m.Type.Nname()))
 			}
 		}
 	}
@@ -63,11 +72,6 @@ func (p *exporter) markType(t *types.Type) {
 		}
 
 	case TFUNC:
-		// If t is the type of a function or method, then
-		// t.Nname() is its ONAME. Mark its inline body and
-		// any recursively called functions for export.
-		inlFlood(asNode(t.Nname()))
-
 		for _, f := range t.Results().FieldSlice() {
 			p.markType(f.Type)
 		}
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 96c3a6faba..6af0369246 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -824,7 +824,7 @@ func methodSymSuffix(recv *types.Type, msym *types.Sym, suffix string) *types.Sy
 // - msym is the method symbol
 // - t is function type (with receiver)
 // Returns a pointer to the existing or added Field; or nil if there's an error.
-func addmethod(msym *types.Sym, t *types.Type, local, nointerface bool) *types.Field {
+func addmethod(n *Node, msym *types.Sym, t *types.Type, local, nointerface bool) *types.Field {
 	if msym == nil {
 		Fatalf("no method symbol")
 	}
@@ -897,6 +897,7 @@ func addmethod(msym *types.Sym, t *types.Type, local, nointerface bool) *types.F
 	}
 
 	f := types.NewField(lineno, msym, t)
+	f.Type.SetNname(asTypesNode(n.Func.Nname))
 	f.SetNointerface(nointerface)
 
 	mt.Methods().Append(f)
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index 1f53d8ca7d..af5f1b70e4 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -243,14 +243,13 @@ const (
 )
 
 func iexport(out *bufio.Writer) {
-	// Mark inline bodies that are reachable through exported types.
+	// Mark inline bodies that are reachable through exported objects.
 	// (Phase 0 of bexport.go.)
 	{
 		// TODO(mdempsky): Separate from bexport logic.
 		p := &exporter{marked: make(map[*types.Type]bool)}
 		for _, n := range exportlist {
-			sym := n.Sym
-			p.markType(asNode(sym.Def).Type)
+			p.markObject(n)
 		}
 	}
 
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 376a167e16..de2ea3558c 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -327,19 +327,14 @@ func (r *importReader) doDecl(n *Node) {
 			recv := r.param()
 			mtyp := r.signature(recv)
 
-			ms[i] = types.NewField(mpos, msym, mtyp)
-
 			m := newfuncnamel(mpos, methodSym(recv.Type, msym))
 			m.Type = mtyp
 			m.SetClass(PFUNC)
 			// methodSym already marked m.Sym as a function.
 
-			// (comment from parser.go)
-			// inl.C's inlnode in on a dotmeth node expects to find the inlineable body as
-			// (dotmeth's type).Nname.Inl, and dotmeth's type has been pulled
-			// out by typecheck's lookdot as this $$.ttype. So by providing
-			// this back link here we avoid special casing there.
-			mtyp.SetNname(asTypesNode(m))
+			f := types.NewField(mpos, msym, mtyp)
+			f.Type.SetNname(asTypesNode(m))
+			ms[i] = f
 		}
 		t.Methods().Set(ms)
 
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 1c371c0e9d..d2e805a72f 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -3412,7 +3412,7 @@ func typecheckfunc(n *Node) {
 	t.FuncType().Nname = asTypesNode(n.Func.Nname)
 	rcvr := t.Recv()
 	if rcvr != nil && n.Func.Shortname != nil {
-		m := addmethod(n.Func.Shortname, t, true, n.Func.Pragma&Nointerface != 0)
+		m := addmethod(n, n.Func.Shortname, t, true, n.Func.Pragma&Nointerface != 0)
 		if m == nil {
 			return
 		}
-- 
GitLab


From c50c7a8c068aa4f6f9aaf288dac984c67197d0e0 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 22 Nov 2020 20:43:16 -0800
Subject: [PATCH 0031/2400] [dev.regabi] cmd/compile/internal/gc: refactor to
 use stop using Func.Nname

Automated factoring produced by rf script below to replace uses of
Func.Nname with Field.Nname or Node.MethodName as appropriate.

Some dead assignments to Func.Nname are left behind; these will be
removed in a subequent remove-only CL.

Passes toolstash-check.

[git-generate]
cd src/cmd/compile/internal/gc
rf '
ex \
  import "cmd/compile/internal/types"; \
  var f *types.Field; \
  var n *types.Node; \
  f.Type.Nname() -> f.Nname; \
  f.Type.SetNname(n) -> f.Nname = n; \
  f.Type.FuncType().Nname -> f.Nname

ex \
  var n *Node; \
  asNode(n.Type.Nname()) -> n.MethodName(); \
  asNode(n.Type.FuncType().Nname) -> n.MethodName(); \
  asNode(callpartMethod(n).Type.Nname()) -> n.MethodName()
'

Change-Id: Iaae054324dfe7da6f5d8b8d57a1e05b58cc5968c
Reviewed-on: https://go-review.googlesource.com/c/go/+/272389
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/gc/bexport.go   | 2 +-
 src/cmd/compile/internal/gc/dcl.go       | 2 +-
 src/cmd/compile/internal/gc/escape.go    | 4 ++--
 src/cmd/compile/internal/gc/iexport.go   | 2 +-
 src/cmd/compile/internal/gc/iimport.go   | 4 ++--
 src/cmd/compile/internal/gc/initorder.go | 4 ++--
 src/cmd/compile/internal/gc/inl.go       | 6 +++---
 src/cmd/compile/internal/gc/scc.go       | 6 +++---
 src/cmd/compile/internal/gc/typecheck.go | 2 +-
 9 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/cmd/compile/internal/gc/bexport.go b/src/cmd/compile/internal/gc/bexport.go
index f4720f8402..6564024a0c 100644
--- a/src/cmd/compile/internal/gc/bexport.go
+++ b/src/cmd/compile/internal/gc/bexport.go
@@ -37,7 +37,7 @@ func (p *exporter) markType(t *types.Type) {
 	if t.Sym != nil && t.Etype != TINTER {
 		for _, m := range t.Methods().Slice() {
 			if types.IsExported(m.Sym.Name) {
-				p.markObject(asNode(m.Type.Nname()))
+				p.markObject(asNode(m.Nname))
 			}
 		}
 	}
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 6af0369246..e1dc647f82 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -897,7 +897,7 @@ func addmethod(n *Node, msym *types.Sym, t *types.Type, local, nointerface bool)
 	}
 
 	f := types.NewField(lineno, msym, t)
-	f.Type.SetNname(asTypesNode(n.Func.Nname))
+	f.Nname = asTypesNode(n.Func.Nname)
 	f.SetNointerface(nointerface)
 
 	mt.Methods().Append(f)
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 618bdf78e2..142eacf7d8 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -544,7 +544,7 @@ func (e *Escape) exprSkipInit(k EscHole, n *Node) {
 		for i := m.Type.NumResults(); i > 0; i-- {
 			ks = append(ks, e.heapHole())
 		}
-		paramK := e.tagHole(ks, asNode(m.Type.Nname()), m.Type.Recv())
+		paramK := e.tagHole(ks, asNode(m.Nname), m.Type.Recv())
 
 		e.expr(e.teeHole(paramK, closureK), n.Left)
 
@@ -778,7 +778,7 @@ func (e *Escape) call(ks []EscHole, call, where *Node) {
 				fn = v.Func.Closure.Func.Nname
 			}
 		case OCALLMETH:
-			fn = asNode(call.Left.Type.FuncType().Nname)
+			fn = call.Left.MethodName()
 		}
 
 		fntype := call.Left.Type
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index af5f1b70e4..47910eb3b9 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -994,7 +994,7 @@ func (w *exportWriter) funcExt(n *Node) {
 
 func (w *exportWriter) methExt(m *types.Field) {
 	w.bool(m.Nointerface())
-	w.funcExt(asNode(m.Type.Nname()))
+	w.funcExt(asNode(m.Nname))
 }
 
 func (w *exportWriter) linkname(s *types.Sym) {
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index de2ea3558c..a37730343a 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -333,7 +333,7 @@ func (r *importReader) doDecl(n *Node) {
 			// methodSym already marked m.Sym as a function.
 
 			f := types.NewField(mpos, msym, mtyp)
-			f.Type.SetNname(asTypesNode(m))
+			f.Nname = asTypesNode(m)
 			ms[i] = f
 		}
 		t.Methods().Set(ms)
@@ -667,7 +667,7 @@ func (r *importReader) methExt(m *types.Field) {
 	if r.bool() {
 		m.SetNointerface(true)
 	}
-	r.funcExt(asNode(m.Type.Nname()))
+	r.funcExt(asNode(m.Nname))
 }
 
 func (r *importReader) linkname(s *types.Sym) {
diff --git a/src/cmd/compile/internal/gc/initorder.go b/src/cmd/compile/internal/gc/initorder.go
index 41f1349bbe..2d7c0176d5 100644
--- a/src/cmd/compile/internal/gc/initorder.go
+++ b/src/cmd/compile/internal/gc/initorder.go
@@ -277,7 +277,7 @@ func (d *initDeps) visit(n *Node) bool {
 	switch n.Op {
 	case ONAME:
 		if n.isMethodExpression() {
-			d.foundDep(asNode(n.Type.FuncType().Nname))
+			d.foundDep(n.MethodName())
 			return false
 		}
 
@@ -290,7 +290,7 @@ func (d *initDeps) visit(n *Node) bool {
 		d.inspectList(n.Func.Closure.Nbody)
 
 	case ODOTMETH, OCALLPART:
-		d.foundDep(asNode(n.Type.FuncType().Nname))
+		d.foundDep(n.MethodName())
 	}
 
 	return true
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 1fab67391b..4908dc4463 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -267,7 +267,7 @@ func inlFlood(n *Node) {
 			switch n.Class() {
 			case PFUNC:
 				if n.isMethodExpression() {
-					inlFlood(asNode(n.Type.Nname()))
+					inlFlood(n.MethodName())
 				} else {
 					inlFlood(n)
 					exportsym(n)
@@ -277,7 +277,7 @@ func inlFlood(n *Node) {
 			}
 
 		case ODOTMETH:
-			fn := asNode(n.Type.Nname())
+			fn := n.MethodName()
 			inlFlood(fn)
 
 		case OCALLPART:
@@ -714,7 +714,7 @@ func inlCallee(fn *Node) *Node {
 	switch {
 	case fn.Op == ONAME && fn.Class() == PFUNC:
 		if fn.isMethodExpression() {
-			n := asNode(fn.Type.Nname())
+			n := fn.MethodName()
 			// Check that receiver type matches fn.Left.
 			// TODO(mdempsky): Handle implicit dereference
 			// of pointer receiver argument?
diff --git a/src/cmd/compile/internal/gc/scc.go b/src/cmd/compile/internal/gc/scc.go
index 5c7935aa87..14f77d613a 100644
--- a/src/cmd/compile/internal/gc/scc.go
+++ b/src/cmd/compile/internal/gc/scc.go
@@ -78,7 +78,7 @@ func (v *bottomUpVisitor) visit(n *Node) uint32 {
 		case ONAME:
 			if n.Class() == PFUNC {
 				if n.isMethodExpression() {
-					n = asNode(n.Type.Nname())
+					n = n.MethodName()
 				}
 				if n != nil && n.Name.Defn != nil {
 					if m := v.visit(n.Name.Defn); m < min {
@@ -87,14 +87,14 @@ func (v *bottomUpVisitor) visit(n *Node) uint32 {
 				}
 			}
 		case ODOTMETH:
-			fn := asNode(n.Type.Nname())
+			fn := n.MethodName()
 			if fn != nil && fn.Op == ONAME && fn.Class() == PFUNC && fn.Name.Defn != nil {
 				if m := v.visit(fn.Name.Defn); m < min {
 					min = m
 				}
 			}
 		case OCALLPART:
-			fn := asNode(callpartMethod(n).Type.Nname())
+			fn := asNode(callpartMethod(n).Nname)
 			if fn != nil && fn.Op == ONAME && fn.Class() == PFUNC && fn.Name.Defn != nil {
 				if m := v.visit(fn.Name.Defn); m < min {
 					min = m
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index d2e805a72f..53a547c3bb 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -4024,7 +4024,7 @@ func curpkg() *types.Pkg {
 // referenced by expression n, which must be a method selector,
 // method expression, or method value.
 func (n *Node) MethodName() *Node {
-	return asNode(n.MethodFunc().Type.Nname())
+	return asNode(n.MethodFunc().Nname)
 }
 
 // MethodFunc is like MethodName, but returns the types.Field instead.
-- 
GitLab


From c754f25241134eaa68c8f26ed5372cadeb49ef89 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 22 Nov 2020 20:45:42 -0800
Subject: [PATCH 0032/2400] [dev.regabi] cmd/compile/internal/types: remove
 Func.Nname

Now that there's no code remaining that uses Func.Nname, we can get
rid of it along with the remaining code that uselessly assigns to it.

Passes toolstash-check.

Change-Id: I104ab3bb5122fb824c741bc6e4d9d54fefe5646e
Reviewed-on: https://go-review.googlesource.com/c/go/+/272390
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/gc/export.go         |  1 -
 src/cmd/compile/internal/gc/inl.go            |  4 ----
 src/cmd/compile/internal/gc/reflect.go        |  8 +------
 src/cmd/compile/internal/gc/typecheck.go      |  1 -
 src/cmd/compile/internal/types/sizeof_test.go |  2 +-
 src/cmd/compile/internal/types/type.go        | 23 +------------------
 6 files changed, 3 insertions(+), 36 deletions(-)

diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index c6917e0f81..5179b6c05b 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -164,7 +164,6 @@ func importfunc(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) {
 	}
 
 	n.Func = new(Func)
-	t.SetNname(asTypesNode(n))
 
 	if Debug.E != 0 {
 		fmt.Printf("import func %v%S\n", s, t)
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 4908dc4463..4aa561da6e 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -221,10 +221,6 @@ func caninl(fn *Node) {
 		Body: inlcopylist(fn.Nbody.Slice()),
 	}
 
-	// hack, TODO, check for better way to link method nodes back to the thing with the ->inl
-	// this is so export can find the body of a method
-	fn.Type.FuncType().Nname = asTypesNode(n)
-
 	if Debug.m > 1 {
 		fmt.Printf("%v: can inline %#v with cost %d as: %#v { %#v }\n", fn.Line(), n, inlineMaxBudget-visitor.budget, fn.Type, asNodes(n.Func.Inl.Body))
 	} else if Debug.m != 0 {
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 05e476b76b..1ac7a8490f 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -365,13 +365,7 @@ func methodfunc(f *types.Type, receiver *types.Type) *types.Type {
 		out = append(out, d)
 	}
 
-	t := functype(nil, in, out)
-	if f.Nname() != nil {
-		// Link to name of original method function.
-		t.SetNname(f.Nname())
-	}
-
-	return t
+	return functype(nil, in, out)
 }
 
 // methods returns the methods of the non-interface type t, sorted by name.
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 53a547c3bb..391115637e 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -3409,7 +3409,6 @@ func typecheckfunc(n *Node) {
 		return
 	}
 	n.Type = t
-	t.FuncType().Nname = asTypesNode(n.Func.Nname)
 	rcvr := t.Recv()
 	if rcvr != nil && n.Func.Shortname != nil {
 		m := addmethod(n, n.Func.Shortname, t, true, n.Func.Pragma&Nointerface != 0)
diff --git a/src/cmd/compile/internal/types/sizeof_test.go b/src/cmd/compile/internal/types/sizeof_test.go
index ea947d8f41..0cf343e8f1 100644
--- a/src/cmd/compile/internal/types/sizeof_test.go
+++ b/src/cmd/compile/internal/types/sizeof_test.go
@@ -24,7 +24,7 @@ func TestSizeof(t *testing.T) {
 		{Type{}, 52, 88},
 		{Map{}, 20, 40},
 		{Forward{}, 20, 32},
-		{Func{}, 32, 56},
+		{Func{}, 28, 48},
 		{Struct{}, 16, 32},
 		{Interface{}, 8, 16},
 		{Chan{}, 8, 16},
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index c6d14e9e09..62c5c34484 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -247,8 +247,7 @@ type Func struct {
 	Results  *Type // function results
 	Params   *Type // function params
 
-	Nname *Node
-	pkg   *Pkg
+	pkg *Pkg
 
 	// Argwid is the total width of the function receiver, params, and results.
 	// It gets calculated via a temporary TFUNCARGS type.
@@ -807,26 +806,6 @@ func (t *Type) FuncArgs() *Type {
 	return t.Extra.(FuncArgs).T
 }
 
-// Nname returns the associated function's nname.
-func (t *Type) Nname() *Node {
-	switch t.Etype {
-	case TFUNC:
-		return t.Extra.(*Func).Nname
-	}
-	Fatalf("Type.Nname %v %v", t.Etype, t)
-	return nil
-}
-
-// Nname sets the associated function's nname.
-func (t *Type) SetNname(n *Node) {
-	switch t.Etype {
-	case TFUNC:
-		t.Extra.(*Func).Nname = n
-	default:
-		Fatalf("Type.SetNname %v %v", t.Etype, t)
-	}
-}
-
 // IsFuncArgStruct reports whether t is a struct representing function parameters.
 func (t *Type) IsFuncArgStruct() bool {
 	return t.Etype == TSTRUCT && t.Extra.(*Struct).Funarg != FunargNone
-- 
GitLab


From 7b144ed4f7a730f5c9375bca65010446ad9f4b73 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 15 Nov 2020 11:40:25 -0500
Subject: [PATCH 0033/2400] [dev.regabi] cmd/compile: rewrite concurrentFlagOk
 to be clearer

The current implementation copies Debug, clears a bunch of flags
that are meant to be considered OK, and then checks the result
against the zero value. But more flags are cleared than remain:
it's easier to write and to understand to just check the ones that
need checking.

This phrasing also makes it safe to move more flags into the struct.

It turns out that some of the flags being checked should probably
not be checked, but this CL is meant to be a strict semantic no-op,
so left a TODO to clean up the function a bit more later.

Change-Id: I7afe6d7b32b5b889c40dd339568e8602e02df9bc
Reviewed-on: https://go-review.googlesource.com/c/go/+/271666
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/main.go | 28 +++++++++++-----------------
 1 file changed, 11 insertions(+), 17 deletions(-)

diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index a6963a3d66..61742fc8ce 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -1418,24 +1418,18 @@ func IsAlias(sym *types.Sym) bool {
 	return sym.Def != nil && asNode(sym.Def).Sym != sym
 }
 
-// By default, assume any debug flags are incompatible with concurrent
-// compilation. A few are safe and potentially in common use for
-// normal compiles, though; return true for those.
+// concurrentFlagOk reports whether the current compiler flags
+// are compatible with concurrent compilation.
 func concurrentFlagOk() bool {
-	// Report whether any debug flag that would prevent concurrent
-	// compilation is set, by zeroing out the allowed ones and then
-	// checking if the resulting struct is zero.
-	d := Debug
-	d.B = 0 // disable bounds checking
-	d.C = 0 // disable printing of columns in error messages
-	d.e = 0 // no limit on errors; errors all come from non-concurrent code
-	d.N = 0 // disable optimizations
-	d.l = 0 // disable inlining
-	d.w = 0 // all printing happens before compilation
-	d.W = 0 // all printing happens before compilation
-	d.S = 0 // printing disassembly happens at the end (but see concurrentBackendAllowed below)
-
-	return d == DebugFlags{}
+	// TODO(rsc): Many of these are fine. Remove them.
+	return Debug.P == 0 &&
+		Debug.E == 0 &&
+		Debug.K == 0 &&
+		Debug.L == 0 &&
+		Debug.h == 0 &&
+		Debug.j == 0 &&
+		Debug.m == 0 &&
+		Debug.r == 0
 }
 
 func concurrentBackendAllowed() bool {
-- 
GitLab


From 5fd949e4bd18ec2068e614c17be0a74969dc13b8 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 19 Nov 2020 17:16:50 -0500
Subject: [PATCH 0034/2400] [dev.regabi] cmd/compile: initialize importMap
 lazily

This sets up the next CL, moving importMap to a global zeroed struct.

Change-Id: I1acc91b440d3da6e28fb32bd275fb3cd36db4e97
Reviewed-on: https://go-review.googlesource.com/c/go/+/272046
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/main.go | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 61742fc8ce..d1b4161277 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -877,11 +877,14 @@ func writebench(filename string) error {
 }
 
 var (
-	importMap   = map[string]string{}
+	importMap   map[string]string
 	packageFile map[string]string // nil means not in use
 )
 
 func addImportMap(s string) {
+	if importMap == nil {
+		importMap = make(map[string]string)
+	}
 	if strings.Count(s, "=") != 1 {
 		log.Fatal("-importmap argument must be of the form source=actual")
 	}
@@ -894,6 +897,9 @@ func addImportMap(s string) {
 }
 
 func readImportCfg(file string) {
+	if importMap == nil {
+		importMap = make(map[string]string)
+	}
 	packageFile = map[string]string{}
 	data, err := ioutil.ReadFile(file)
 	if err != nil {
-- 
GitLab


From 357c576878137c8840b702c64167470f1669f064 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 16 Nov 2020 11:08:38 -0500
Subject: [PATCH 0035/2400] [dev.regabi] cmd/compile: clean up error API

Prepare for factoring the error API out of this package by
cleaning it up. The doc comments use the intended new names,
which will be introduced in the next CL.

Change-Id: Ie4c8d4262422da32a9a9f750fda42c225b6b42a8
Reviewed-on: https://go-review.googlesource.com/c/go/+/272248
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/_rex.20201123151057                  |   1 +
 src/cmd/compile/internal/gc/dcl.go       |   3 -
 src/cmd/compile/internal/gc/go.go        |  10 -
 src/cmd/compile/internal/gc/initorder.go |   4 +-
 src/cmd/compile/internal/gc/lex.go       |   4 -
 src/cmd/compile/internal/gc/main.go      |  44 +---
 src/cmd/compile/internal/gc/mpfloat.go   |   4 +-
 src/cmd/compile/internal/gc/mpint.go     |  24 +--
 src/cmd/compile/internal/gc/noder.go     |   4 +-
 src/cmd/compile/internal/gc/pgen.go      |   9 +-
 src/cmd/compile/internal/gc/print.go     | 243 +++++++++++++++++++++++
 src/cmd/compile/internal/gc/subr.go      | 174 ----------------
 src/cmd/compile/internal/gc/typecheck.go |  10 +-
 src/cmd/compile/internal/gc/walk.go      |   3 +-
 14 files changed, 283 insertions(+), 254 deletions(-)
 create mode 100644 src/_rex.20201123151057
 create mode 100644 src/cmd/compile/internal/gc/print.go

diff --git a/src/_rex.20201123151057 b/src/_rex.20201123151057
new file mode 100644
index 0000000000..8b13789179
--- /dev/null
+++ b/src/_rex.20201123151057
@@ -0,0 +1 @@
+
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index e1dc647f82..d3b7590257 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -19,9 +19,6 @@ var externdcl []*Node
 
 func testdclstack() {
 	if !types.IsDclstackValid() {
-		if nerrors != 0 {
-			errorexit()
-		}
 		Fatalf("mark left on the dclstack")
 	}
 }
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index da6b6d6e72..c53fde7e24 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -102,16 +102,6 @@ var pragcgobuf [][]string
 var outfile string
 var linkobj string
 
-// nerrors is the number of compiler errors reported
-// since the last call to saveerrors.
-var nerrors int
-
-// nsavederrors is the total number of compiler errors
-// reported before the last call to saveerrors.
-var nsavederrors int
-
-var nsyntaxerrors int
-
 var decldepth int32
 
 var nolocalimports bool
diff --git a/src/cmd/compile/internal/gc/initorder.go b/src/cmd/compile/internal/gc/initorder.go
index 2d7c0176d5..102cb769db 100644
--- a/src/cmd/compile/internal/gc/initorder.go
+++ b/src/cmd/compile/internal/gc/initorder.go
@@ -104,9 +104,7 @@ func initOrder(l []*Node) []*Node {
 				// confused us and there might not be
 				// a loop. Let the user fix those
 				// first.
-				if nerrors > 0 {
-					errorexit()
-				}
+				ExitIfErrors()
 
 				findInitLoopAndExit(firstLHS(n), new([]*Node))
 				Fatalf("initialization unfinished, but failed to identify loop")
diff --git a/src/cmd/compile/internal/gc/lex.go b/src/cmd/compile/internal/gc/lex.go
index 7cce371408..c58479952e 100644
--- a/src/cmd/compile/internal/gc/lex.go
+++ b/src/cmd/compile/internal/gc/lex.go
@@ -12,10 +12,6 @@ import (
 	"strings"
 )
 
-// lineno is the source position at the start of the most recently lexed token.
-// TODO(gri) rename and eventually remove
-var lineno src.XPos
-
 func makePos(base *src.PosBase, line, col uint) src.XPos {
 	return Ctxt.PosTable.XPos(src.MakePos(base, line, col))
 }
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index d1b4161277..89dbca0cf1 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -119,7 +119,7 @@ func usage() {
 }
 
 func hidePanic() {
-	if Debug_panic == 0 && nsavederrors+nerrors > 0 {
+	if Debug_panic == 0 && Errors() > 0 {
 		// If we've already complained about things
 		// in the program, don't bother complaining
 		// about a panic too; let the user clean up
@@ -567,7 +567,6 @@ func Main(archInit func(*Arch)) {
 	initUniverse()
 
 	dclcontext = PEXTERN
-	nerrors = 0
 
 	autogeneratedPos = makePos(src.NewFileBase("<autogenerated>", "<autogenerated>"), 1, 0)
 
@@ -625,10 +624,10 @@ func Main(archInit func(*Arch)) {
 		if n.Op == ODCLFUNC {
 			Curfn = n
 			decldepth = 1
-			saveerrors()
+			errorsBefore := Errors()
 			typecheckslice(Curfn.Nbody.Slice(), ctxStmt)
 			checkreturn(Curfn)
-			if nerrors != 0 {
+			if Errors() > errorsBefore {
 				Curfn.Nbody.Set(nil) // type errors; do not compile
 			}
 			// Now that we've checked whether n terminates,
@@ -641,11 +640,9 @@ func Main(archInit func(*Arch)) {
 	// check past phase 9 isn't sufficient, as we may exit with other errors
 	// before then, thus skipping map key errors.
 	checkMapKeys()
-	timings.AddEvent(fcount, "funcs")
+	ExitIfErrors()
 
-	if nsavederrors+nerrors != 0 {
-		errorexit()
-	}
+	timings.AddEvent(fcount, "funcs")
 
 	fninit(xtop)
 
@@ -660,12 +657,8 @@ func Main(archInit func(*Arch)) {
 		}
 	}
 	capturevarscomplete = true
-
 	Curfn = nil
-
-	if nsavederrors+nerrors != 0 {
-		errorexit()
-	}
+	ExitIfErrors()
 
 	// Phase 5: Inlining
 	timings.Start("fe", "inlining")
@@ -674,14 +667,10 @@ func Main(archInit func(*Arch)) {
 		// otherwise lazily when used or re-exported.
 		for _, n := range importlist {
 			if n.Func.Inl != nil {
-				saveerrors()
 				typecheckinl(n)
 			}
 		}
-
-		if nsavederrors+nerrors != 0 {
-			errorexit()
-		}
+		ExitIfErrors()
 	}
 
 	if Debug.l != 0 {
@@ -793,10 +782,7 @@ func Main(archInit func(*Arch)) {
 	// Check the map keys again, since we typechecked the external
 	// declarations.
 	checkMapKeys()
-
-	if nerrors+nsavederrors != 0 {
-		errorexit()
-	}
+	ExitIfErrors()
 
 	// Write object data to disk.
 	timings.Start("be", "dumpobj")
@@ -827,10 +813,7 @@ func Main(archInit func(*Arch)) {
 	}
 
 	logopt.FlushLoggedOpts(Ctxt, myimportpath)
-
-	if nerrors+nsavederrors != 0 {
-		errorexit()
-	}
+	ExitIfErrors()
 
 	flusherrors()
 	timings.Stop()
@@ -1011,11 +994,6 @@ func readSymABIs(file, myimportpath string) {
 	}
 }
 
-func saveerrors() {
-	nsavederrors += nerrors
-	nerrors = 0
-}
-
 func arsize(b *bufio.Reader, name string) int {
 	var buf [ArhdrSize]byte
 	if _, err := io.ReadFull(b, buf[:]); err != nil {
@@ -1396,7 +1374,7 @@ func clearImports() {
 			// leave s->block set to cause redeclaration
 			// errors if a conflicting top-level name is
 			// introduced by a different file.
-			if !n.Name.Used() && nsyntaxerrors == 0 {
+			if !n.Name.Used() && SyntaxErrors() == 0 {
 				unused = append(unused, importedPkg{n.Pos, n.Name.Pkg.Path, s.Name})
 			}
 			s.Def = nil
@@ -1405,7 +1383,7 @@ func clearImports() {
 		if IsAlias(s) {
 			// throw away top-level name left over
 			// from previous import . "x"
-			if n.Name != nil && n.Name.Pack != nil && !n.Name.Pack.Name.Used() && nsyntaxerrors == 0 {
+			if n.Name != nil && n.Name.Pack != nil && !n.Name.Pack.Name.Used() && SyntaxErrors() == 0 {
 				unused = append(unused, importedPkg{n.Name.Pack.Pos, n.Name.Pack.Name.Pkg.Path, ""})
 				n.Name.Pack.Name.SetUsed(true)
 			}
diff --git a/src/cmd/compile/internal/gc/mpfloat.go b/src/cmd/compile/internal/gc/mpfloat.go
index 401aef319d..9962f4b413 100644
--- a/src/cmd/compile/internal/gc/mpfloat.go
+++ b/src/cmd/compile/internal/gc/mpfloat.go
@@ -136,7 +136,7 @@ func (a *Mpflt) Float64() float64 {
 	x, _ := a.Val.Float64()
 
 	// check for overflow
-	if math.IsInf(x, 0) && nsavederrors+nerrors == 0 {
+	if math.IsInf(x, 0) && Errors() == 0 {
 		Fatalf("ovf in Mpflt Float64")
 	}
 
@@ -148,7 +148,7 @@ func (a *Mpflt) Float32() float64 {
 	x := float64(x32)
 
 	// check for overflow
-	if math.IsInf(x, 0) && nsavederrors+nerrors == 0 {
+	if math.IsInf(x, 0) && Errors() == 0 {
 		Fatalf("ovf in Mpflt Float32")
 	}
 
diff --git a/src/cmd/compile/internal/gc/mpint.go b/src/cmd/compile/internal/gc/mpint.go
index 340350bca7..79eb60e65d 100644
--- a/src/cmd/compile/internal/gc/mpint.go
+++ b/src/cmd/compile/internal/gc/mpint.go
@@ -72,7 +72,7 @@ func (a *Mpint) SetFloat(b *Mpflt) bool {
 
 func (a *Mpint) Add(b *Mpint) {
 	if a.Ovf || b.Ovf {
-		if nsavederrors+nerrors == 0 {
+		if Errors() == 0 {
 			Fatalf("ovf in Mpint Add")
 		}
 		a.SetOverflow()
@@ -88,7 +88,7 @@ func (a *Mpint) Add(b *Mpint) {
 
 func (a *Mpint) Sub(b *Mpint) {
 	if a.Ovf || b.Ovf {
-		if nsavederrors+nerrors == 0 {
+		if Errors() == 0 {
 			Fatalf("ovf in Mpint Sub")
 		}
 		a.SetOverflow()
@@ -104,7 +104,7 @@ func (a *Mpint) Sub(b *Mpint) {
 
 func (a *Mpint) Mul(b *Mpint) {
 	if a.Ovf || b.Ovf {
-		if nsavederrors+nerrors == 0 {
+		if Errors() == 0 {
 			Fatalf("ovf in Mpint Mul")
 		}
 		a.SetOverflow()
@@ -120,7 +120,7 @@ func (a *Mpint) Mul(b *Mpint) {
 
 func (a *Mpint) Quo(b *Mpint) {
 	if a.Ovf || b.Ovf {
-		if nsavederrors+nerrors == 0 {
+		if Errors() == 0 {
 			Fatalf("ovf in Mpint Quo")
 		}
 		a.SetOverflow()
@@ -137,7 +137,7 @@ func (a *Mpint) Quo(b *Mpint) {
 
 func (a *Mpint) Rem(b *Mpint) {
 	if a.Ovf || b.Ovf {
-		if nsavederrors+nerrors == 0 {
+		if Errors() == 0 {
 			Fatalf("ovf in Mpint Rem")
 		}
 		a.SetOverflow()
@@ -154,7 +154,7 @@ func (a *Mpint) Rem(b *Mpint) {
 
 func (a *Mpint) Or(b *Mpint) {
 	if a.Ovf || b.Ovf {
-		if nsavederrors+nerrors == 0 {
+		if Errors() == 0 {
 			Fatalf("ovf in Mpint Or")
 		}
 		a.SetOverflow()
@@ -166,7 +166,7 @@ func (a *Mpint) Or(b *Mpint) {
 
 func (a *Mpint) And(b *Mpint) {
 	if a.Ovf || b.Ovf {
-		if nsavederrors+nerrors == 0 {
+		if Errors() == 0 {
 			Fatalf("ovf in Mpint And")
 		}
 		a.SetOverflow()
@@ -178,7 +178,7 @@ func (a *Mpint) And(b *Mpint) {
 
 func (a *Mpint) AndNot(b *Mpint) {
 	if a.Ovf || b.Ovf {
-		if nsavederrors+nerrors == 0 {
+		if Errors() == 0 {
 			Fatalf("ovf in Mpint AndNot")
 		}
 		a.SetOverflow()
@@ -190,7 +190,7 @@ func (a *Mpint) AndNot(b *Mpint) {
 
 func (a *Mpint) Xor(b *Mpint) {
 	if a.Ovf || b.Ovf {
-		if nsavederrors+nerrors == 0 {
+		if Errors() == 0 {
 			Fatalf("ovf in Mpint Xor")
 		}
 		a.SetOverflow()
@@ -202,7 +202,7 @@ func (a *Mpint) Xor(b *Mpint) {
 
 func (a *Mpint) Lsh(b *Mpint) {
 	if a.Ovf || b.Ovf {
-		if nsavederrors+nerrors == 0 {
+		if Errors() == 0 {
 			Fatalf("ovf in Mpint Lsh")
 		}
 		a.SetOverflow()
@@ -229,7 +229,7 @@ func (a *Mpint) Lsh(b *Mpint) {
 
 func (a *Mpint) Rsh(b *Mpint) {
 	if a.Ovf || b.Ovf {
-		if nsavederrors+nerrors == 0 {
+		if Errors() == 0 {
 			Fatalf("ovf in Mpint Rsh")
 		}
 		a.SetOverflow()
@@ -267,7 +267,7 @@ func (a *Mpint) Neg() {
 
 func (a *Mpint) Int64() int64 {
 	if a.Ovf {
-		if nsavederrors+nerrors == 0 {
+		if Errors() == 0 {
 			Fatalf("constant overflow")
 		}
 		return 0
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 67d24ef0bc..c7119f96f3 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -64,7 +64,7 @@ func parseFiles(filenames []string) uint {
 		lines += p.file.Lines
 		p.file = nil // release memory
 
-		if nsyntaxerrors != 0 {
+		if SyntaxErrors() != 0 {
 			errorexit()
 		}
 		// Always run testdclstack here, even when debug_dclstack is not set, as a sanity measure.
@@ -333,7 +333,7 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
 	val := p.basicLit(imp.Path)
 	ipkg := importfile(&val)
 	if ipkg == nil {
-		if nerrors == 0 {
+		if Errors() == 0 {
 			Fatalf("phase error in import")
 		}
 		return
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index 353f4b08c9..6dbb69281c 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -198,7 +198,7 @@ func funccompile(fn *Node) {
 	}
 
 	if fn.Type == nil {
-		if nerrors == 0 {
+		if Errors() == 0 {
 			Fatalf("funccompile missing type")
 		}
 		return
@@ -224,10 +224,9 @@ func funccompile(fn *Node) {
 }
 
 func compile(fn *Node) {
-	saveerrors()
-
+	errorsBefore := Errors()
 	order(fn)
-	if nerrors != 0 {
+	if Errors() > errorsBefore {
 		return
 	}
 
@@ -237,7 +236,7 @@ func compile(fn *Node) {
 	fn.Func.initLSym(true)
 
 	walk(fn)
-	if nerrors != 0 {
+	if Errors() > errorsBefore {
 		return
 	}
 	if instrumenting {
diff --git a/src/cmd/compile/internal/gc/print.go b/src/cmd/compile/internal/gc/print.go
new file mode 100644
index 0000000000..1dbd58df42
--- /dev/null
+++ b/src/cmd/compile/internal/gc/print.go
@@ -0,0 +1,243 @@
+// Copyright 2020 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 gc
+
+import (
+	"cmd/internal/objabi"
+	"cmd/internal/src"
+	"fmt"
+	"os"
+	"runtime/debug"
+	"sort"
+	"strings"
+)
+
+// An errorMsg is a queued error message, waiting to be printed.
+type errorMsg struct {
+	pos src.XPos
+	msg string
+}
+
+// Pos is the current source position being processed,
+// printed by Errorf, ErrorfLang, Fatalf, and Warnf.
+var lineno src.XPos
+
+var (
+	errorMsgs       []errorMsg
+	numErrors       int // number of entries in errorMsgs that are errors (as opposed to warnings)
+	numSyntaxErrors int
+)
+
+// Errors returns the number of errors reported.
+func Errors() int {
+	return numErrors
+}
+
+// SyntaxErrors returns the number of syntax errors reported
+func SyntaxErrors() int {
+	return numSyntaxErrors
+}
+
+// addErrorMsg adds a new errorMsg (which may be a warning) to errorMsgs.
+func addErrorMsg(pos src.XPos, format string, args ...interface{}) {
+	msg := fmt.Sprintf(format, args...)
+	// Only add the position if know the position.
+	// See issue golang.org/issue/11361.
+	if pos.IsKnown() {
+		msg = fmt.Sprintf("%v: %s", linestr(pos), msg)
+	}
+	errorMsgs = append(errorMsgs, errorMsg{
+		pos: pos,
+		msg: msg + "\n",
+	})
+}
+
+// FmtPos formats pos as a file:line string.
+func linestr(pos src.XPos) string {
+	if Ctxt == nil {
+		return "???"
+	}
+	return Ctxt.OutermostPos(pos).Format(Debug.C == 0, Debug.L == 1)
+}
+
+// byPos sorts errors by source position.
+type byPos []errorMsg
+
+func (x byPos) Len() int           { return len(x) }
+func (x byPos) Less(i, j int) bool { return x[i].pos.Before(x[j].pos) }
+func (x byPos) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
+
+// FlushErrors sorts errors seen so far by line number, prints them to stdout,
+// and empties the errors array.
+func flusherrors() {
+	Ctxt.Bso.Flush()
+	if len(errorMsgs) == 0 {
+		return
+	}
+	sort.Stable(byPos(errorMsgs))
+	for i, err := range errorMsgs {
+		if i == 0 || err.msg != errorMsgs[i-1].msg {
+			fmt.Printf("%s", err.msg)
+		}
+	}
+	errorMsgs = errorMsgs[:0]
+}
+
+// lasterror keeps track of the most recently issued error,
+// to avoid printing multiple error messages on the same line.
+var lasterror struct {
+	syntax src.XPos // source position of last syntax error
+	other  src.XPos // source position of last non-syntax error
+	msg    string   // error message of last non-syntax error
+}
+
+// sameline reports whether two positions a, b are on the same line.
+func sameline(a, b src.XPos) bool {
+	p := Ctxt.PosTable.Pos(a)
+	q := Ctxt.PosTable.Pos(b)
+	return p.Base() == q.Base() && p.Line() == q.Line()
+}
+
+// Errorf reports a formatted error at the current line.
+func yyerror(format string, args ...interface{}) {
+	yyerrorl(lineno, format, args...)
+}
+
+// ErrorfAt reports a formatted error message at pos.
+func yyerrorl(pos src.XPos, format string, args ...interface{}) {
+	msg := fmt.Sprintf(format, args...)
+
+	if strings.HasPrefix(msg, "syntax error") {
+		numSyntaxErrors++
+		// only one syntax error per line, no matter what error
+		if sameline(lasterror.syntax, pos) {
+			return
+		}
+		lasterror.syntax = pos
+	} else {
+		// only one of multiple equal non-syntax errors per line
+		// (flusherrors shows only one of them, so we filter them
+		// here as best as we can (they may not appear in order)
+		// so that we don't count them here and exit early, and
+		// then have nothing to show for.)
+		if sameline(lasterror.other, pos) && lasterror.msg == msg {
+			return
+		}
+		lasterror.other = pos
+		lasterror.msg = msg
+	}
+
+	addErrorMsg(pos, "%s", msg)
+	numErrors++
+
+	hcrash()
+	if numErrors >= 10 && Debug.e == 0 {
+		flusherrors()
+		fmt.Printf("%v: too many errors\n", linestr(pos))
+		errorexit()
+	}
+}
+
+// ErrorfVers reports that a language feature (format, args) requires a later version of Go.
+func yyerrorv(lang string, format string, args ...interface{}) {
+	yyerror("%s requires %s or later (-lang was set to %s; check go.mod)", fmt.Sprintf(format, args...), lang, flag_lang)
+}
+
+// UpdateErrorDot is a clumsy hack that rewrites the last error,
+// if it was "LINE: undefined: NAME", to be "LINE: undefined: NAME in EXPR".
+// It is used to give better error messages for dot (selector) expressions.
+func UpdateErrorDot(line string, name, expr string) {
+	if len(errorMsgs) == 0 {
+		return
+	}
+	e := &errorMsgs[len(errorMsgs)-1]
+	if strings.HasPrefix(e.msg, line) && e.msg == fmt.Sprintf("%v: undefined: %v\n", line, name) {
+		e.msg = fmt.Sprintf("%v: undefined: %v in %v\n", line, name, expr)
+	}
+}
+
+// Warnf reports a formatted warning at the current line.
+// In general the Go compiler does NOT generate warnings,
+// so this should be used only when the user has opted in
+// to additional output by setting a particular flag.
+func Warn(format string, args ...interface{}) {
+	Warnl(lineno, format, args...)
+}
+
+// WarnfAt reports a formatted warning at pos.
+// In general the Go compiler does NOT generate warnings,
+// so this should be used only when the user has opted in
+// to additional output by setting a particular flag.
+func Warnl(pos src.XPos, format string, args ...interface{}) {
+	addErrorMsg(pos, format, args...)
+	if Debug.m != 0 {
+		flusherrors()
+	}
+}
+
+// Fatal reports a fatal error - an internal problem - at the current line and exits.
+// If other errors have already been printed, then Fatal just quietly exits.
+// (The internal problem may have been caused by incomplete information
+// after the already-reported errors, so best to let users fix those and
+// try again without being bothered about a spurious internal error.)
+//
+// But if no errors have been printed, or if -d panic has been specified,
+// Fatal prints the error as an "internal compiler error". In a released build,
+// it prints an error asking to file a bug report. In development builds, it
+// prints a stack trace.
+//
+// If -h has been specified, Fatal panics to force the usual runtime info dump.
+func Fatalf(format string, args ...interface{}) {
+	flusherrors()
+
+	if Debug_panic != 0 || numErrors == 0 {
+		fmt.Printf("%v: internal compiler error: ", linestr(lineno))
+		fmt.Printf(format, args...)
+		fmt.Printf("\n")
+
+		// If this is a released compiler version, ask for a bug report.
+		if strings.HasPrefix(objabi.Version, "go") {
+			fmt.Printf("\n")
+			fmt.Printf("Please file a bug report including a short program that triggers the error.\n")
+			fmt.Printf("https://golang.org/issue/new\n")
+		} else {
+			// Not a release; dump a stack trace, too.
+			fmt.Println()
+			os.Stdout.Write(debug.Stack())
+			fmt.Println()
+		}
+	}
+
+	hcrash()
+	errorexit()
+}
+
+// hcrash crashes the compiler when -h is set, to find out where a message is generated.
+func hcrash() {
+	if Debug.h != 0 {
+		flusherrors()
+		if outfile != "" {
+			os.Remove(outfile)
+		}
+		panic("-h")
+	}
+}
+
+// ErrorExit handles an error-status exit.
+// It flushes any pending errors, removes the output file, and exits.
+func errorexit() {
+	flusherrors()
+	if outfile != "" {
+		os.Remove(outfile)
+	}
+	os.Exit(2)
+}
+
+// ExitIfErrors calls ErrorExit if any errors have been reported.
+func ExitIfErrors() {
+	if Errors() > 0 {
+		errorexit()
+	}
+}
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index defefd76b3..9760823e96 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -6,13 +6,10 @@ package gc
 
 import (
 	"cmd/compile/internal/types"
-	"cmd/internal/objabi"
 	"cmd/internal/src"
 	"crypto/md5"
 	"encoding/binary"
 	"fmt"
-	"os"
-	"runtime/debug"
 	"sort"
 	"strconv"
 	"strings"
@@ -21,13 +18,6 @@ import (
 	"unicode/utf8"
 )
 
-type Error struct {
-	pos src.XPos
-	msg string
-}
-
-var errors []Error
-
 // largeStack is info about a function whose stack frame is too large (rare).
 type largeStack struct {
 	locals int64
@@ -41,170 +31,6 @@ var (
 	largeStackFrames   []largeStack
 )
 
-func errorexit() {
-	flusherrors()
-	if outfile != "" {
-		os.Remove(outfile)
-	}
-	os.Exit(2)
-}
-
-func adderrorname(n *Node) {
-	if n.Op != ODOT {
-		return
-	}
-	old := fmt.Sprintf("%v: undefined: %v\n", n.Line(), n.Left)
-	if len(errors) > 0 && errors[len(errors)-1].pos.Line() == n.Pos.Line() && errors[len(errors)-1].msg == old {
-		errors[len(errors)-1].msg = fmt.Sprintf("%v: undefined: %v in %v\n", n.Line(), n.Left, n)
-	}
-}
-
-func adderr(pos src.XPos, format string, args ...interface{}) {
-	msg := fmt.Sprintf(format, args...)
-	// Only add the position if know the position.
-	// See issue golang.org/issue/11361.
-	if pos.IsKnown() {
-		msg = fmt.Sprintf("%v: %s", linestr(pos), msg)
-	}
-	errors = append(errors, Error{
-		pos: pos,
-		msg: msg + "\n",
-	})
-}
-
-// byPos sorts errors by source position.
-type byPos []Error
-
-func (x byPos) Len() int           { return len(x) }
-func (x byPos) Less(i, j int) bool { return x[i].pos.Before(x[j].pos) }
-func (x byPos) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
-
-// flusherrors sorts errors seen so far by line number, prints them to stdout,
-// and empties the errors array.
-func flusherrors() {
-	Ctxt.Bso.Flush()
-	if len(errors) == 0 {
-		return
-	}
-	sort.Stable(byPos(errors))
-	for i, err := range errors {
-		if i == 0 || err.msg != errors[i-1].msg {
-			fmt.Printf("%s", err.msg)
-		}
-	}
-	errors = errors[:0]
-}
-
-func hcrash() {
-	if Debug.h != 0 {
-		flusherrors()
-		if outfile != "" {
-			os.Remove(outfile)
-		}
-		var x *int
-		*x = 0
-	}
-}
-
-func linestr(pos src.XPos) string {
-	return Ctxt.OutermostPos(pos).Format(Debug.C == 0, Debug.L == 1)
-}
-
-// lasterror keeps track of the most recently issued error.
-// It is used to avoid multiple error messages on the same
-// line.
-var lasterror struct {
-	syntax src.XPos // source position of last syntax error
-	other  src.XPos // source position of last non-syntax error
-	msg    string   // error message of last non-syntax error
-}
-
-// sameline reports whether two positions a, b are on the same line.
-func sameline(a, b src.XPos) bool {
-	p := Ctxt.PosTable.Pos(a)
-	q := Ctxt.PosTable.Pos(b)
-	return p.Base() == q.Base() && p.Line() == q.Line()
-}
-
-func yyerrorl(pos src.XPos, format string, args ...interface{}) {
-	msg := fmt.Sprintf(format, args...)
-
-	if strings.HasPrefix(msg, "syntax error") {
-		nsyntaxerrors++
-		// only one syntax error per line, no matter what error
-		if sameline(lasterror.syntax, pos) {
-			return
-		}
-		lasterror.syntax = pos
-	} else {
-		// only one of multiple equal non-syntax errors per line
-		// (flusherrors shows only one of them, so we filter them
-		// here as best as we can (they may not appear in order)
-		// so that we don't count them here and exit early, and
-		// then have nothing to show for.)
-		if sameline(lasterror.other, pos) && lasterror.msg == msg {
-			return
-		}
-		lasterror.other = pos
-		lasterror.msg = msg
-	}
-
-	adderr(pos, "%s", msg)
-
-	hcrash()
-	nerrors++
-	if nsavederrors+nerrors >= 10 && Debug.e == 0 {
-		flusherrors()
-		fmt.Printf("%v: too many errors\n", linestr(pos))
-		errorexit()
-	}
-}
-
-func yyerrorv(lang string, format string, args ...interface{}) {
-	what := fmt.Sprintf(format, args...)
-	yyerrorl(lineno, "%s requires %s or later (-lang was set to %s; check go.mod)", what, lang, flag_lang)
-}
-
-func yyerror(format string, args ...interface{}) {
-	yyerrorl(lineno, format, args...)
-}
-
-func Warn(fmt_ string, args ...interface{}) {
-	Warnl(lineno, fmt_, args...)
-}
-
-func Warnl(line src.XPos, fmt_ string, args ...interface{}) {
-	adderr(line, fmt_, args...)
-	if Debug.m != 0 {
-		flusherrors()
-	}
-}
-
-func Fatalf(fmt_ string, args ...interface{}) {
-	flusherrors()
-
-	if Debug_panic != 0 || nsavederrors+nerrors == 0 {
-		fmt.Printf("%v: internal compiler error: ", linestr(lineno))
-		fmt.Printf(fmt_, args...)
-		fmt.Printf("\n")
-
-		// If this is a released compiler version, ask for a bug report.
-		if strings.HasPrefix(objabi.Version, "go") {
-			fmt.Printf("\n")
-			fmt.Printf("Please file a bug report including a short program that triggers the error.\n")
-			fmt.Printf("https://golang.org/issue/new\n")
-		} else {
-			// Not a release; dump a stack trace, too.
-			fmt.Println()
-			os.Stdout.Write(debug.Stack())
-			fmt.Println()
-		}
-	}
-
-	hcrash()
-	errorexit()
-}
-
 // hasUniquePos reports whether n has a unique position that can be
 // used for reporting error messages.
 //
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 391115637e..41f0c3f2a5 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -280,7 +280,7 @@ func typecheck(n *Node, top int) (res *Node) {
 			yyerrorl(n.Pos, "constant definition loop%s", cycleTrace(cycleFor(n)))
 		}
 
-		if nsavederrors+nerrors == 0 {
+		if Errors() == 0 {
 			var trace string
 			for i := len(typecheck_tcstack) - 1; i >= 0; i-- {
 				x := typecheck_tcstack[i]
@@ -891,7 +891,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 		t := n.Left.Type
 		if t == nil {
-			adderrorname(n)
+			UpdateErrorDot(n.Line(), n.Left.String(), n.String())
 			n.Type = nil
 			return n
 		}
@@ -3641,7 +3641,7 @@ func typecheckdef(n *Node) {
 			if n.SubOp() != 0 { // like OPRINTN
 				break
 			}
-			if nsavederrors+nerrors > 0 {
+			if Errors() > 0 {
 				// Can have undefined variables in x := foo
 				// that make x have an n.name.Defn == nil.
 				// If there are other errors anyway, don't
@@ -3686,9 +3686,9 @@ func typecheckdef(n *Node) {
 		n.SetWalkdef(1)
 		setTypeNode(n, types.New(TFORW))
 		n.Type.Sym = n.Sym
-		nerrors0 := nerrors
+		errorsBefore := Errors()
 		typecheckdeftype(n)
-		if n.Type.Etype == TFORW && nerrors > nerrors0 {
+		if n.Type.Etype == TFORW && Errors() > errorsBefore {
 			// Something went wrong during type-checking,
 			// but it was reported. Silence future errors.
 			n.Type.SetBroke(true)
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index a7b6e7fcb3..a61cb3f651 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -20,6 +20,7 @@ const zeroValSize = 1024 // must match value of runtime/map.go:maxZero
 
 func walk(fn *Node) {
 	Curfn = fn
+	errorsBefore := Errors()
 
 	if Debug.W != 0 {
 		s := fmt.Sprintf("\nbefore walk %v", Curfn.Func.Nname.Sym)
@@ -59,7 +60,7 @@ func walk(fn *Node) {
 	}
 
 	lineno = lno
-	if nerrors != 0 {
+	if Errors() > errorsBefore {
 		return
 	}
 	walkstmtlist(Curfn.Nbody.Slice())
-- 
GitLab


From e37597f7f0ad0be32d854c9b7b3556009b728538 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 16 Nov 2020 11:36:13 -0500
Subject: [PATCH 0036/2400] [dev.regabi] cmd/compile: rename a few 'base'
 identifiers

We want to introduce a package cmd/compile/internal/base,
and these will shadow it at points where it is needed.

Change-Id: Ic936733fba1ccba8c2ca1fdedbd4d2989df4bbf4
Reviewed-on: https://go-review.googlesource.com/c/go/+/272249
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/escape.go | 20 ++++++++++----------
 src/cmd/compile/internal/gc/lex.go    |  4 ++--
 src/cmd/compile/internal/gc/noder.go  |  8 ++++----
 src/cmd/compile/internal/gc/obj.go    |  8 ++++----
 src/cmd/compile/internal/gc/pgen.go   | 10 +++++-----
 src/cmd/compile/internal/gc/swt.go    |  6 +++---
 src/cmd/compile/internal/gc/unsafe.go |  8 ++++----
 7 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 142eacf7d8..1fc51745f4 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -1152,16 +1152,16 @@ func (e *Escape) walkOne(root *EscLocation, walkgen uint32, enqueue func(*EscLoc
 		l := todo[len(todo)-1]
 		todo = todo[:len(todo)-1]
 
-		base := l.derefs
+		derefs := l.derefs
 
 		// If l.derefs < 0, then l's address flows to root.
-		addressOf := base < 0
+		addressOf := derefs < 0
 		if addressOf {
 			// For a flow path like "root = &l; l = x",
 			// l's address flows to root, but x's does
 			// not. We recognize this by lower bounding
-			// base at 0.
-			base = 0
+			// derefs at 0.
+			derefs = 0
 
 			// If l's address flows to a non-transient
 			// location, then l can't be transiently
@@ -1181,15 +1181,15 @@ func (e *Escape) walkOne(root *EscLocation, walkgen uint32, enqueue func(*EscLoc
 			if l.isName(PPARAM) {
 				if (logopt.Enabled() || Debug.m >= 2) && !l.escapes {
 					if Debug.m >= 2 {
-						fmt.Printf("%s: parameter %v leaks to %s with derefs=%d:\n", linestr(l.n.Pos), l.n, e.explainLoc(root), base)
+						fmt.Printf("%s: parameter %v leaks to %s with derefs=%d:\n", linestr(l.n.Pos), l.n, e.explainLoc(root), derefs)
 					}
 					explanation := e.explainPath(root, l)
 					if logopt.Enabled() {
 						logopt.LogOpt(l.n.Pos, "leak", "escape", e.curfn.funcname(),
-							fmt.Sprintf("parameter %v leaks to %s with derefs=%d", l.n, e.explainLoc(root), base), explanation)
+							fmt.Sprintf("parameter %v leaks to %s with derefs=%d", l.n, e.explainLoc(root), derefs), explanation)
 					}
 				}
-				l.leakTo(root, base)
+				l.leakTo(root, derefs)
 			}
 
 			// If l's address flows somewhere that
@@ -1215,10 +1215,10 @@ func (e *Escape) walkOne(root *EscLocation, walkgen uint32, enqueue func(*EscLoc
 			if edge.src.escapes {
 				continue
 			}
-			derefs := base + edge.derefs
-			if edge.src.walkgen != walkgen || edge.src.derefs > derefs {
+			d := derefs + edge.derefs
+			if edge.src.walkgen != walkgen || edge.src.derefs > d {
 				edge.src.walkgen = walkgen
-				edge.src.derefs = derefs
+				edge.src.derefs = d
 				edge.src.dst = l
 				edge.src.dstEdgeIdx = i
 				todo = append(todo, edge.src)
diff --git a/src/cmd/compile/internal/gc/lex.go b/src/cmd/compile/internal/gc/lex.go
index c58479952e..f01891f365 100644
--- a/src/cmd/compile/internal/gc/lex.go
+++ b/src/cmd/compile/internal/gc/lex.go
@@ -12,8 +12,8 @@ import (
 	"strings"
 )
 
-func makePos(base *src.PosBase, line, col uint) src.XPos {
-	return Ctxt.PosTable.XPos(src.MakePos(base, line, col))
+func makePos(b *src.PosBase, line, col uint) src.XPos {
+	return Ctxt.PosTable.XPos(src.MakePos(b, line, col))
 }
 
 func isSpace(c rune) bool {
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index c7119f96f3..27bc9b5629 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -1382,16 +1382,16 @@ func checkLangCompat(lit *syntax.BasicLit) {
 	if s[0] != '0' {
 		return
 	}
-	base := s[1]
-	if base == 'b' || base == 'B' {
+	radix := s[1]
+	if radix == 'b' || radix == 'B' {
 		yyerrorv("go1.13", "binary literals")
 		return
 	}
-	if base == 'o' || base == 'O' {
+	if radix == 'o' || radix == 'O' {
 		yyerrorv("go1.13", "0o/0O-style octal literals")
 		return
 	}
-	if lit.Kind != syntax.IntLit && (base == 'x' || base == 'X') {
+	if lit.Kind != syntax.IntLit && (radix == 'x' || radix == 'X') {
 		yyerrorv("go1.13", "hexadecimal floating-point literals")
 	}
 }
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 32aa7c5bb1..8fe480b65f 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -544,13 +544,13 @@ func dsymptrWeakOff(s *obj.LSym, off int, x *obj.LSym) int {
 // arr must be an ONAME. slicesym does not modify n.
 func slicesym(n, arr *Node, lencap int64) {
 	s := n.Sym.Linksym()
-	base := n.Xoffset
+	off := n.Xoffset
 	if arr.Op != ONAME {
 		Fatalf("slicesym non-name arr %v", arr)
 	}
-	s.WriteAddr(Ctxt, base, Widthptr, arr.Sym.Linksym(), arr.Xoffset)
-	s.WriteInt(Ctxt, base+sliceLenOffset, Widthptr, lencap)
-	s.WriteInt(Ctxt, base+sliceCapOffset, Widthptr, lencap)
+	s.WriteAddr(Ctxt, off, Widthptr, arr.Sym.Linksym(), arr.Xoffset)
+	s.WriteInt(Ctxt, off+sliceLenOffset, Widthptr, lencap)
+	s.WriteInt(Ctxt, off+sliceCapOffset, Widthptr, lencap)
 }
 
 // addrsym writes the static address of a to n. a must be an ONAME.
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index 6dbb69281c..9c1bd285ae 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -698,20 +698,20 @@ func preInliningDcls(fnsym *obj.LSym) []*Node {
 // to do with its offset in the user variable.
 func stackOffset(slot ssa.LocalSlot) int32 {
 	n := slot.N.(*Node)
-	var base int64
+	var off int64
 	switch n.Class() {
 	case PAUTO:
 		if Ctxt.FixedFrameSize() == 0 {
-			base -= int64(Widthptr)
+			off -= int64(Widthptr)
 		}
 		if objabi.Framepointer_enabled || objabi.GOARCH == "arm64" {
 			// There is a word space for FP on ARM64 even if the frame pointer is disabled
-			base -= int64(Widthptr)
+			off -= int64(Widthptr)
 		}
 	case PPARAM, PPARAMOUT:
-		base += Ctxt.FixedFrameSize()
+		off += Ctxt.FixedFrameSize()
 	}
-	return int32(base + n.Xoffset + slot.Off)
+	return int32(off + n.Xoffset + slot.Off)
 }
 
 // createComplexVar builds a single DWARF variable entry and location list.
diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index 8d9fbe300e..9205f4142a 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -720,9 +720,9 @@ func (s *typeSwitch) flush() {
 // less(i) should return a boolean expression. If it evaluates true,
 // then cases before i will be tested; otherwise, cases i and later.
 //
-// base(i, nif) should setup nif (an OIF node) to test case i. In
+// leaf(i, nif) should setup nif (an OIF node) to test case i. In
 // particular, it should set nif.Left and nif.Nbody.
-func binarySearch(n int, out *Nodes, less func(i int) *Node, base func(i int, nif *Node)) {
+func binarySearch(n int, out *Nodes, less func(i int) *Node, leaf func(i int, nif *Node)) {
 	const binarySearchMin = 4 // minimum number of cases for binary search
 
 	var do func(lo, hi int, out *Nodes)
@@ -731,7 +731,7 @@ func binarySearch(n int, out *Nodes, less func(i int) *Node, base func(i int, ni
 		if n < binarySearchMin {
 			for i := lo; i < hi; i++ {
 				nif := nod(OIF, nil, nil)
-				base(i, nif)
+				leaf(i, nif)
 				lineno = lineno.WithNotStmt()
 				nif.Left = typecheck(nif.Left, ctxExpr)
 				nif.Left = defaultlit(nif.Left, nil)
diff --git a/src/cmd/compile/internal/gc/unsafe.go b/src/cmd/compile/internal/gc/unsafe.go
index 2233961561..a3151e83bf 100644
--- a/src/cmd/compile/internal/gc/unsafe.go
+++ b/src/cmd/compile/internal/gc/unsafe.go
@@ -31,7 +31,7 @@ func evalunsafe(n *Node) int64 {
 		// Since r->left may be mutated by typechecking, check it explicitly
 		// first to track it correctly.
 		n.Left.Left = typecheck(n.Left.Left, ctxExpr)
-		base := n.Left.Left
+		sbase := n.Left.Left
 
 		n.Left = typecheck(n.Left, ctxExpr)
 		if n.Left.Type == nil {
@@ -48,15 +48,15 @@ func evalunsafe(n *Node) int64 {
 			return 0
 		}
 
-		// Sum offsets for dots until we reach base.
+		// Sum offsets for dots until we reach sbase.
 		var v int64
-		for r := n.Left; r != base; r = r.Left {
+		for r := n.Left; r != sbase; r = r.Left {
 			switch r.Op {
 			case ODOTPTR:
 				// For Offsetof(s.f), s may itself be a pointer,
 				// but accessing f must not otherwise involve
 				// indirection via embedded pointer types.
-				if r.Left != base {
+				if r.Left != sbase {
 					yyerror("invalid expression %v: selector implies indirection of embedded %v", n, r.Left)
 					return 0
 				}
-- 
GitLab


From 228b732ad988a457c0f3d42f6aeb0fe338a5c4ec Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 16 Nov 2020 12:18:09 -0500
Subject: [PATCH 0037/2400] [dev.regabi] cmd/compile: prepare for package ir

The next CL will introduce a package ir to hold the IR definitions.
This CL adjusts a few names and makes a few other minor changes
to make the next CL - an automated one - smoother.

Change-Id: Ie787a34732efd5b3d171bf0c1220b6dd91994ce3
Reviewed-on: https://go-review.googlesource.com/c/go/+/272251
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/escape.go    | 35 ++++++++++++++++++++
 src/cmd/compile/internal/gc/fmt.go       | 42 ++++++++----------------
 src/cmd/compile/internal/gc/iimport.go   | 32 +++++++++---------
 src/cmd/compile/internal/gc/subr.go      |  9 -----
 src/cmd/compile/internal/gc/typecheck.go | 14 ++++----
 5 files changed, 72 insertions(+), 60 deletions(-)

diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 1fc51745f4..757b4652ca 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -140,6 +140,41 @@ type EscEdge struct {
 	notes  *EscNote
 }
 
+func init() {
+	EscFmt = escFmt
+}
+
+// escFmt is called from node printing to print information about escape analysis results.
+func escFmt(n *Node, short bool) string {
+	text := ""
+	switch n.Esc {
+	case EscUnknown:
+		break
+
+	case EscHeap:
+		text = "esc(h)"
+
+	case EscNone:
+		text = "esc(no)"
+
+	case EscNever:
+		if !short {
+			text = "esc(N)"
+		}
+
+	default:
+		text = fmt.Sprintf("esc(%d)", n.Esc)
+	}
+
+	if e, ok := n.Opt().(*EscLocation); ok && e.loopDepth != 0 {
+		if text != "" {
+			text += " "
+		}
+		text += fmt.Sprintf("ld(%d)", e.loopDepth)
+	}
+	return text
+}
+
 // escapeFuncs performs escape analysis on a minimal batch of
 // functions.
 func escapeFuncs(fns []*Node, recursive bool) {
diff --git a/src/cmd/compile/internal/gc/fmt.go b/src/cmd/compile/internal/gc/fmt.go
index f92f5d0e88..f61ea8aaac 100644
--- a/src/cmd/compile/internal/gc/fmt.go
+++ b/src/cmd/compile/internal/gc/fmt.go
@@ -415,19 +415,22 @@ func (n *Node) format(s fmt.State, verb rune, mode fmtMode) {
 	}
 }
 
+// EscFmt is set by the escape analysis code to add escape analysis details to the node print.
+var EscFmt func(n *Node, short bool) string
+
 // *Node details
 func (n *Node) jconv(s fmt.State, flag FmtFlag) {
-	c := flag & FmtShort
+	short := flag&FmtShort != 0
 
-	// Useful to see which nodes in a Node Dump/dumplist are actually identical
+	// Useful to see which nodes in an AST printout are actually identical
 	if Debug_dumpptrs != 0 {
 		fmt.Fprintf(s, " p(%p)", n)
 	}
-	if c == 0 && n.Name != nil && n.Name.Vargen != 0 {
+	if !short && n.Name != nil && n.Name.Vargen != 0 {
 		fmt.Fprintf(s, " g(%d)", n.Name.Vargen)
 	}
 
-	if Debug_dumpptrs != 0 && c == 0 && n.Name != nil && n.Name.Defn != nil {
+	if Debug_dumpptrs != 0 && !short && n.Name != nil && n.Name.Defn != nil {
 		// Useful to see where Defn is set and what node it points to
 		fmt.Fprintf(s, " defn(%p)", n.Name.Defn)
 	}
@@ -443,7 +446,7 @@ func (n *Node) jconv(s fmt.State, flag FmtFlag) {
 		fmt.Fprintf(s, " l(%s%d)", pfx, n.Pos.Line())
 	}
 
-	if c == 0 && n.Xoffset != BADWIDTH {
+	if !short && n.Xoffset != BADWIDTH {
 		fmt.Fprintf(s, " x(%d)", n.Xoffset)
 	}
 
@@ -455,30 +458,13 @@ func (n *Node) jconv(s fmt.State, flag FmtFlag) {
 		fmt.Fprintf(s, " colas(%v)", n.Colas())
 	}
 
-	switch n.Esc {
-	case EscUnknown:
-		break
-
-	case EscHeap:
-		fmt.Fprint(s, " esc(h)")
-
-	case EscNone:
-		fmt.Fprint(s, " esc(no)")
-
-	case EscNever:
-		if c == 0 {
-			fmt.Fprint(s, " esc(N)")
+	if EscFmt != nil {
+		if esc := EscFmt(n, short); esc != "" {
+			fmt.Fprintf(s, " %s", esc)
 		}
-
-	default:
-		fmt.Fprintf(s, " esc(%d)", n.Esc)
-	}
-
-	if e, ok := n.Opt().(*EscLocation); ok && e.loopDepth != 0 {
-		fmt.Fprintf(s, " ld(%d)", e.loopDepth)
 	}
 
-	if c == 0 && n.Typecheck() != 0 {
+	if !short && n.Typecheck() != 0 {
 		fmt.Fprintf(s, " tc(%d)", n.Typecheck())
 	}
 
@@ -518,11 +504,11 @@ func (n *Node) jconv(s fmt.State, flag FmtFlag) {
 		fmt.Fprint(s, " nonnil")
 	}
 
-	if c == 0 && n.HasCall() {
+	if !short && n.HasCall() {
 		fmt.Fprint(s, " hascall")
 	}
 
-	if c == 0 && n.Name != nil && n.Name.Used() {
+	if !short && n.Name != nil && n.Name.Used() {
 		fmt.Fprint(s, " used")
 	}
 }
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index a37730343a..df193cd8e1 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -98,16 +98,16 @@ func (r *intReader) uint64() uint64 {
 }
 
 func iimport(pkg *types.Pkg, in *bio.Reader) (fingerprint goobj.FingerprintType) {
-	ir := &intReader{in, pkg}
+	ird := &intReader{in, pkg}
 
-	version := ir.uint64()
+	version := ird.uint64()
 	if version != iexportVersion {
 		yyerror("import %q: unknown export format version %d", pkg.Path, version)
 		errorexit()
 	}
 
-	sLen := ir.uint64()
-	dLen := ir.uint64()
+	sLen := ird.uint64()
+	dLen := ird.uint64()
 
 	// Map string (and data) section into memory as a single large
 	// string. This reduces heap fragmentation and allows
@@ -138,10 +138,10 @@ func iimport(pkg *types.Pkg, in *bio.Reader) (fingerprint goobj.FingerprintType)
 	}
 
 	// Declaration index.
-	for nPkgs := ir.uint64(); nPkgs > 0; nPkgs-- {
-		pkg := p.pkgAt(ir.uint64())
-		pkgName := p.stringAt(ir.uint64())
-		pkgHeight := int(ir.uint64())
+	for nPkgs := ird.uint64(); nPkgs > 0; nPkgs-- {
+		pkg := p.pkgAt(ird.uint64())
+		pkgName := p.stringAt(ird.uint64())
+		pkgHeight := int(ird.uint64())
 		if pkg.Name == "" {
 			pkg.Name = pkgName
 			pkg.Height = pkgHeight
@@ -158,9 +158,9 @@ func iimport(pkg *types.Pkg, in *bio.Reader) (fingerprint goobj.FingerprintType)
 			}
 		}
 
-		for nSyms := ir.uint64(); nSyms > 0; nSyms-- {
-			s := pkg.Lookup(p.stringAt(ir.uint64()))
-			off := ir.uint64()
+		for nSyms := ird.uint64(); nSyms > 0; nSyms-- {
+			s := pkg.Lookup(p.stringAt(ird.uint64()))
+			off := ird.uint64()
 
 			if _, ok := declImporter[s]; ok {
 				continue
@@ -177,12 +177,12 @@ func iimport(pkg *types.Pkg, in *bio.Reader) (fingerprint goobj.FingerprintType)
 	}
 
 	// Inline body index.
-	for nPkgs := ir.uint64(); nPkgs > 0; nPkgs-- {
-		pkg := p.pkgAt(ir.uint64())
+	for nPkgs := ird.uint64(); nPkgs > 0; nPkgs-- {
+		pkg := p.pkgAt(ird.uint64())
 
-		for nSyms := ir.uint64(); nSyms > 0; nSyms-- {
-			s := pkg.Lookup(p.stringAt(ir.uint64()))
-			off := ir.uint64()
+		for nSyms := ird.uint64(); nSyms > 0; nSyms-- {
+			s := pkg.Lookup(p.stringAt(ird.uint64()))
+			off := ird.uint64()
 
 			if _, ok := inlineImporter[s]; ok {
 				continue
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 9760823e96..849043bfe2 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -1585,15 +1585,6 @@ func liststmt(l []*Node) *Node {
 	return n
 }
 
-func (l Nodes) asblock() *Node {
-	n := nod(OBLOCK, nil, nil)
-	n.List = l
-	if l.Len() != 0 {
-		n.Pos = l.First().Pos
-	}
-	return n
-}
-
 func ngotype(n *Node) *types.Sym {
 	if n.Type != nil {
 		return typenamesym(n.Type)
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 41f0c3f2a5..f13d9a3e26 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -3867,7 +3867,7 @@ func checkreturn(fn *Node) {
 }
 
 func deadcode(fn *Node) {
-	deadcodeslice(fn.Nbody)
+	deadcodeslice(&fn.Nbody)
 	deadcodefn(fn)
 }
 
@@ -3897,7 +3897,7 @@ func deadcodefn(fn *Node) {
 	fn.Nbody.Set([]*Node{nod(OEMPTY, nil, nil)})
 }
 
-func deadcodeslice(nn Nodes) {
+func deadcodeslice(nn *Nodes) {
 	var lastLabel = -1
 	for i, n := range nn.Slice() {
 		if n != nil && n.Op == OLABEL {
@@ -3939,12 +3939,12 @@ func deadcodeslice(nn Nodes) {
 			}
 		}
 
-		deadcodeslice(n.Ninit)
-		deadcodeslice(n.Nbody)
-		deadcodeslice(n.List)
-		deadcodeslice(n.Rlist)
+		deadcodeslice(&n.Ninit)
+		deadcodeslice(&n.Nbody)
+		deadcodeslice(&n.List)
+		deadcodeslice(&n.Rlist)
 		if cut {
-			*nn.slice = nn.Slice()[:i+1]
+			nn.Set(nn.Slice()[:i+1])
 			break
 		}
 	}
-- 
GitLab


From 1abb12fc97d87ea67ce87a04ad6500bdfe1dbb7d Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 17 Nov 2020 12:53:34 -0800
Subject: [PATCH 0038/2400] [dev.regabi] go/constant: optimize BitLen

Avoids an unnecessary heap allocation when computing the bit length of
int64 values.

Change-Id: I69dfc510e461daf3e83b0b7b6c0707f6526a32d0
Reviewed-on: https://go-review.googlesource.com/c/go/+/272646
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/constant/value.go      |  7 ++++++-
 src/go/constant/value_test.go | 21 +++++++++++++++++++++
 2 files changed, 27 insertions(+), 1 deletion(-)

diff --git a/src/go/constant/value.go b/src/go/constant/value.go
index 116c7575d9..59606dc479 100644
--- a/src/go/constant/value.go
+++ b/src/go/constant/value.go
@@ -17,6 +17,7 @@ import (
 	"go/token"
 	"math"
 	"math/big"
+	"math/bits"
 	"strconv"
 	"strings"
 	"sync"
@@ -610,7 +611,11 @@ func Make(x interface{}) Value {
 func BitLen(x Value) int {
 	switch x := x.(type) {
 	case int64Val:
-		return i64toi(x).val.BitLen()
+		u := uint64(x)
+		if x < 0 {
+			u = uint64(-x)
+		}
+		return 64 - bits.LeadingZeros64(u)
 	case intVal:
 		return x.val.BitLen()
 	case unknownVal:
diff --git a/src/go/constant/value_test.go b/src/go/constant/value_test.go
index 1a5025cbbd..1ad6784f9a 100644
--- a/src/go/constant/value_test.go
+++ b/src/go/constant/value_test.go
@@ -655,3 +655,24 @@ func BenchmarkStringAdd(b *testing.B) {
 		})
 	}
 }
+
+var bitLenTests = []struct {
+	val  int64
+	want int
+}{
+	{0, 0},
+	{1, 1},
+	{-16, 5},
+	{1 << 61, 62},
+	{1 << 62, 63},
+	{-1 << 62, 63},
+	{-1 << 63, 64},
+}
+
+func TestBitLen(t *testing.T) {
+	for _, test := range bitLenTests {
+		if got := BitLen(MakeInt64(test.val)); got != test.want {
+			t.Errorf("%v: got %v, want %v", test.val, got, test.want)
+		}
+	}
+}
-- 
GitLab


From 96f3fb7244680fbb04549914384ced7afe433daf Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 23 Nov 2020 04:28:25 -0800
Subject: [PATCH 0039/2400] [dev.regabi] go/constant: avoid heap allocations in
 match

When type switching from interface{} to T, and then returning the T as
interface{} again, it's better to return the original interface{}
value. This avoids needing to heap allocate the T for
non-pointer-shaped types (i.e., int64Val, complexVal, stringVal).

Change-Id: I25c83b3f9ec9bd2ffeec5a65279b68f4fcef8a19
Reviewed-on: https://go-review.googlesource.com/c/go/+/272647
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/constant/value.go | 33 ++++++++++++++++++---------------
 1 file changed, 18 insertions(+), 15 deletions(-)

diff --git a/src/go/constant/value.go b/src/go/constant/value.go
index 59606dc479..4a89ef3b94 100644
--- a/src/go/constant/value.go
+++ b/src/go/constant/value.go
@@ -1023,52 +1023,55 @@ func match(x, y Value) (_, _ Value) {
 	}
 	// ord(x) <= ord(y)
 
-	switch x := x.(type) {
+	// Prefer to return the original x and y arguments when possible,
+	// to avoid unnecessary heap allocations.
+
+	switch x1 := x.(type) {
 	case boolVal, *stringVal, complexVal:
 		return x, y
 
 	case int64Val:
-		switch y := y.(type) {
+		switch y.(type) {
 		case int64Val:
 			return x, y
 		case intVal:
-			return i64toi(x), y
+			return i64toi(x1), y
 		case ratVal:
-			return i64tor(x), y
+			return i64tor(x1), y
 		case floatVal:
-			return i64tof(x), y
+			return i64tof(x1), y
 		case complexVal:
-			return vtoc(x), y
+			return vtoc(x1), y
 		}
 
 	case intVal:
-		switch y := y.(type) {
+		switch y.(type) {
 		case intVal:
 			return x, y
 		case ratVal:
-			return itor(x), y
+			return itor(x1), y
 		case floatVal:
-			return itof(x), y
+			return itof(x1), y
 		case complexVal:
-			return vtoc(x), y
+			return vtoc(x1), y
 		}
 
 	case ratVal:
-		switch y := y.(type) {
+		switch y.(type) {
 		case ratVal:
 			return x, y
 		case floatVal:
-			return rtof(x), y
+			return rtof(x1), y
 		case complexVal:
-			return vtoc(x), y
+			return vtoc(x1), y
 		}
 
 	case floatVal:
-		switch y := y.(type) {
+		switch y.(type) {
 		case floatVal:
 			return x, y
 		case complexVal:
-			return vtoc(x), y
+			return vtoc(x1), y
 		}
 	}
 
-- 
GitLab


From 668e3a598f56d2c9618d800a163f3e784ba3ae0b Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 16 Nov 2020 08:44:40 -0800
Subject: [PATCH 0040/2400] [dev.regabi] cmd/compile: cleanup type switch
 typechecking

Address outstanding TODO, which simplifies subsequent CLs.

Now the compiler always type checks type-switch case clauses (like
gccgo), but it treats clause variables as broken if an appropriate
type cannot be determined for it (like go/types).

Passes toolstash-check.

Change-Id: Iedfe9cdf38c6865211e4b93391f1cf72c1bed136
Reviewed-on: https://go-review.googlesource.com/c/go/+/272648
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/swt.go | 16 ++++++++--------
 test/fixedbugs/bug340.go           |  3 ++-
 2 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index 9205f4142a..9ab5f0c248 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -89,22 +89,22 @@ func typecheckTypeSwitch(n *Node) {
 			if len(ls) == 1 {
 				if ls[0].Op == OTYPE {
 					vt = ls[0].Type
-				} else if ls[0].Op != OLITERAL { // TODO(mdempsky): Should be !ls[0].isNil()
+				} else if !ls[0].isNil() {
 					// Invalid single-type case;
 					// mark variable as broken.
 					vt = nil
 				}
 			}
 
-			// TODO(mdempsky): It should be possible to
-			// still typecheck the case body.
-			if vt == nil {
-				continue
-			}
-
 			nvar := ncase.Rlist.First()
 			nvar.Type = vt
-			nvar = typecheck(nvar, ctxExpr|ctxAssign)
+			if vt != nil {
+				nvar = typecheck(nvar, ctxExpr|ctxAssign)
+			} else {
+				// Clause variable is broken; prevent typechecking.
+				nvar.SetTypecheck(1)
+				nvar.SetWalkdef(1)
+			}
 			ncase.Rlist.SetFirst(nvar)
 		}
 
diff --git a/test/fixedbugs/bug340.go b/test/fixedbugs/bug340.go
index 118bbacc22..a067940408 100644
--- a/test/fixedbugs/bug340.go
+++ b/test/fixedbugs/bug340.go
@@ -12,6 +12,7 @@ func main() {
 	var x interface{}
 	switch t := x.(type) {
 	case 0:		// ERROR "type"
-		t.x = 1 // ERROR "type interface \{\}|reference to undefined field or method"
+		t.x = 1
+		x.x = 1 // ERROR "type interface \{\}|reference to undefined field or method"
 	}
 }
-- 
GitLab


From 4af2decf3004261ff7cb500f511c6414a9d0f68a Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 15 Nov 2020 17:19:08 -0800
Subject: [PATCH 0041/2400] [dev.regabi] cmd/compile: add (unused) ONIL
 constant

Subsequent CL will make use of ONIL. Split out separately so that the
next CL can pass toolstash-check.

Change-Id: I49d77bedbe2cac4a5da149c925cda969e50b0b2d
Reviewed-on: https://go-review.googlesource.com/c/go/+/272649
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/op_string.go | 299 ++++++++++++-----------
 src/cmd/compile/internal/gc/syntax.go    |   1 +
 2 files changed, 151 insertions(+), 149 deletions(-)

diff --git a/src/cmd/compile/internal/gc/op_string.go b/src/cmd/compile/internal/gc/op_string.go
index 41d588309c..f7d31f912c 100644
--- a/src/cmd/compile/internal/gc/op_string.go
+++ b/src/cmd/compile/internal/gc/op_string.go
@@ -14,158 +14,159 @@ func _() {
 	_ = x[OTYPE-3]
 	_ = x[OPACK-4]
 	_ = x[OLITERAL-5]
-	_ = x[OADD-6]
-	_ = x[OSUB-7]
-	_ = x[OOR-8]
-	_ = x[OXOR-9]
-	_ = x[OADDSTR-10]
-	_ = x[OADDR-11]
-	_ = x[OANDAND-12]
-	_ = x[OAPPEND-13]
-	_ = x[OBYTES2STR-14]
-	_ = x[OBYTES2STRTMP-15]
-	_ = x[ORUNES2STR-16]
-	_ = x[OSTR2BYTES-17]
-	_ = x[OSTR2BYTESTMP-18]
-	_ = x[OSTR2RUNES-19]
-	_ = x[OAS-20]
-	_ = x[OAS2-21]
-	_ = x[OAS2DOTTYPE-22]
-	_ = x[OAS2FUNC-23]
-	_ = x[OAS2MAPR-24]
-	_ = x[OAS2RECV-25]
-	_ = x[OASOP-26]
-	_ = x[OCALL-27]
-	_ = x[OCALLFUNC-28]
-	_ = x[OCALLMETH-29]
-	_ = x[OCALLINTER-30]
-	_ = x[OCALLPART-31]
-	_ = x[OCAP-32]
-	_ = x[OCLOSE-33]
-	_ = x[OCLOSURE-34]
-	_ = x[OCOMPLIT-35]
-	_ = x[OMAPLIT-36]
-	_ = x[OSTRUCTLIT-37]
-	_ = x[OARRAYLIT-38]
-	_ = x[OSLICELIT-39]
-	_ = x[OPTRLIT-40]
-	_ = x[OCONV-41]
-	_ = x[OCONVIFACE-42]
-	_ = x[OCONVNOP-43]
-	_ = x[OCOPY-44]
-	_ = x[ODCL-45]
-	_ = x[ODCLFUNC-46]
-	_ = x[ODCLFIELD-47]
-	_ = x[ODCLCONST-48]
-	_ = x[ODCLTYPE-49]
-	_ = x[ODELETE-50]
-	_ = x[ODOT-51]
-	_ = x[ODOTPTR-52]
-	_ = x[ODOTMETH-53]
-	_ = x[ODOTINTER-54]
-	_ = x[OXDOT-55]
-	_ = x[ODOTTYPE-56]
-	_ = x[ODOTTYPE2-57]
-	_ = x[OEQ-58]
-	_ = x[ONE-59]
-	_ = x[OLT-60]
-	_ = x[OLE-61]
-	_ = x[OGE-62]
-	_ = x[OGT-63]
-	_ = x[ODEREF-64]
-	_ = x[OINDEX-65]
-	_ = x[OINDEXMAP-66]
-	_ = x[OKEY-67]
-	_ = x[OSTRUCTKEY-68]
-	_ = x[OLEN-69]
-	_ = x[OMAKE-70]
-	_ = x[OMAKECHAN-71]
-	_ = x[OMAKEMAP-72]
-	_ = x[OMAKESLICE-73]
-	_ = x[OMAKESLICECOPY-74]
-	_ = x[OMUL-75]
-	_ = x[ODIV-76]
-	_ = x[OMOD-77]
-	_ = x[OLSH-78]
-	_ = x[ORSH-79]
-	_ = x[OAND-80]
-	_ = x[OANDNOT-81]
-	_ = x[ONEW-82]
-	_ = x[ONEWOBJ-83]
-	_ = x[ONOT-84]
-	_ = x[OBITNOT-85]
-	_ = x[OPLUS-86]
-	_ = x[ONEG-87]
-	_ = x[OOROR-88]
-	_ = x[OPANIC-89]
-	_ = x[OPRINT-90]
-	_ = x[OPRINTN-91]
-	_ = x[OPAREN-92]
-	_ = x[OSEND-93]
-	_ = x[OSLICE-94]
-	_ = x[OSLICEARR-95]
-	_ = x[OSLICESTR-96]
-	_ = x[OSLICE3-97]
-	_ = x[OSLICE3ARR-98]
-	_ = x[OSLICEHEADER-99]
-	_ = x[ORECOVER-100]
-	_ = x[ORECV-101]
-	_ = x[ORUNESTR-102]
-	_ = x[OSELRECV-103]
-	_ = x[OSELRECV2-104]
-	_ = x[OIOTA-105]
-	_ = x[OREAL-106]
-	_ = x[OIMAG-107]
-	_ = x[OCOMPLEX-108]
-	_ = x[OALIGNOF-109]
-	_ = x[OOFFSETOF-110]
-	_ = x[OSIZEOF-111]
-	_ = x[OBLOCK-112]
-	_ = x[OBREAK-113]
-	_ = x[OCASE-114]
-	_ = x[OCONTINUE-115]
-	_ = x[ODEFER-116]
-	_ = x[OEMPTY-117]
-	_ = x[OFALL-118]
-	_ = x[OFOR-119]
-	_ = x[OFORUNTIL-120]
-	_ = x[OGOTO-121]
-	_ = x[OIF-122]
-	_ = x[OLABEL-123]
-	_ = x[OGO-124]
-	_ = x[ORANGE-125]
-	_ = x[ORETURN-126]
-	_ = x[OSELECT-127]
-	_ = x[OSWITCH-128]
-	_ = x[OTYPESW-129]
-	_ = x[OTCHAN-130]
-	_ = x[OTMAP-131]
-	_ = x[OTSTRUCT-132]
-	_ = x[OTINTER-133]
-	_ = x[OTFUNC-134]
-	_ = x[OTARRAY-135]
-	_ = x[ODDD-136]
-	_ = x[OINLCALL-137]
-	_ = x[OEFACE-138]
-	_ = x[OITAB-139]
-	_ = x[OIDATA-140]
-	_ = x[OSPTR-141]
-	_ = x[OCLOSUREVAR-142]
-	_ = x[OCFUNC-143]
-	_ = x[OCHECKNIL-144]
-	_ = x[OVARDEF-145]
-	_ = x[OVARKILL-146]
-	_ = x[OVARLIVE-147]
-	_ = x[ORESULT-148]
-	_ = x[OINLMARK-149]
-	_ = x[ORETJMP-150]
-	_ = x[OGETG-151]
-	_ = x[OEND-152]
+	_ = x[ONIL-6]
+	_ = x[OADD-7]
+	_ = x[OSUB-8]
+	_ = x[OOR-9]
+	_ = x[OXOR-10]
+	_ = x[OADDSTR-11]
+	_ = x[OADDR-12]
+	_ = x[OANDAND-13]
+	_ = x[OAPPEND-14]
+	_ = x[OBYTES2STR-15]
+	_ = x[OBYTES2STRTMP-16]
+	_ = x[ORUNES2STR-17]
+	_ = x[OSTR2BYTES-18]
+	_ = x[OSTR2BYTESTMP-19]
+	_ = x[OSTR2RUNES-20]
+	_ = x[OAS-21]
+	_ = x[OAS2-22]
+	_ = x[OAS2DOTTYPE-23]
+	_ = x[OAS2FUNC-24]
+	_ = x[OAS2MAPR-25]
+	_ = x[OAS2RECV-26]
+	_ = x[OASOP-27]
+	_ = x[OCALL-28]
+	_ = x[OCALLFUNC-29]
+	_ = x[OCALLMETH-30]
+	_ = x[OCALLINTER-31]
+	_ = x[OCALLPART-32]
+	_ = x[OCAP-33]
+	_ = x[OCLOSE-34]
+	_ = x[OCLOSURE-35]
+	_ = x[OCOMPLIT-36]
+	_ = x[OMAPLIT-37]
+	_ = x[OSTRUCTLIT-38]
+	_ = x[OARRAYLIT-39]
+	_ = x[OSLICELIT-40]
+	_ = x[OPTRLIT-41]
+	_ = x[OCONV-42]
+	_ = x[OCONVIFACE-43]
+	_ = x[OCONVNOP-44]
+	_ = x[OCOPY-45]
+	_ = x[ODCL-46]
+	_ = x[ODCLFUNC-47]
+	_ = x[ODCLFIELD-48]
+	_ = x[ODCLCONST-49]
+	_ = x[ODCLTYPE-50]
+	_ = x[ODELETE-51]
+	_ = x[ODOT-52]
+	_ = x[ODOTPTR-53]
+	_ = x[ODOTMETH-54]
+	_ = x[ODOTINTER-55]
+	_ = x[OXDOT-56]
+	_ = x[ODOTTYPE-57]
+	_ = x[ODOTTYPE2-58]
+	_ = x[OEQ-59]
+	_ = x[ONE-60]
+	_ = x[OLT-61]
+	_ = x[OLE-62]
+	_ = x[OGE-63]
+	_ = x[OGT-64]
+	_ = x[ODEREF-65]
+	_ = x[OINDEX-66]
+	_ = x[OINDEXMAP-67]
+	_ = x[OKEY-68]
+	_ = x[OSTRUCTKEY-69]
+	_ = x[OLEN-70]
+	_ = x[OMAKE-71]
+	_ = x[OMAKECHAN-72]
+	_ = x[OMAKEMAP-73]
+	_ = x[OMAKESLICE-74]
+	_ = x[OMAKESLICECOPY-75]
+	_ = x[OMUL-76]
+	_ = x[ODIV-77]
+	_ = x[OMOD-78]
+	_ = x[OLSH-79]
+	_ = x[ORSH-80]
+	_ = x[OAND-81]
+	_ = x[OANDNOT-82]
+	_ = x[ONEW-83]
+	_ = x[ONEWOBJ-84]
+	_ = x[ONOT-85]
+	_ = x[OBITNOT-86]
+	_ = x[OPLUS-87]
+	_ = x[ONEG-88]
+	_ = x[OOROR-89]
+	_ = x[OPANIC-90]
+	_ = x[OPRINT-91]
+	_ = x[OPRINTN-92]
+	_ = x[OPAREN-93]
+	_ = x[OSEND-94]
+	_ = x[OSLICE-95]
+	_ = x[OSLICEARR-96]
+	_ = x[OSLICESTR-97]
+	_ = x[OSLICE3-98]
+	_ = x[OSLICE3ARR-99]
+	_ = x[OSLICEHEADER-100]
+	_ = x[ORECOVER-101]
+	_ = x[ORECV-102]
+	_ = x[ORUNESTR-103]
+	_ = x[OSELRECV-104]
+	_ = x[OSELRECV2-105]
+	_ = x[OIOTA-106]
+	_ = x[OREAL-107]
+	_ = x[OIMAG-108]
+	_ = x[OCOMPLEX-109]
+	_ = x[OALIGNOF-110]
+	_ = x[OOFFSETOF-111]
+	_ = x[OSIZEOF-112]
+	_ = x[OBLOCK-113]
+	_ = x[OBREAK-114]
+	_ = x[OCASE-115]
+	_ = x[OCONTINUE-116]
+	_ = x[ODEFER-117]
+	_ = x[OEMPTY-118]
+	_ = x[OFALL-119]
+	_ = x[OFOR-120]
+	_ = x[OFORUNTIL-121]
+	_ = x[OGOTO-122]
+	_ = x[OIF-123]
+	_ = x[OLABEL-124]
+	_ = x[OGO-125]
+	_ = x[ORANGE-126]
+	_ = x[ORETURN-127]
+	_ = x[OSELECT-128]
+	_ = x[OSWITCH-129]
+	_ = x[OTYPESW-130]
+	_ = x[OTCHAN-131]
+	_ = x[OTMAP-132]
+	_ = x[OTSTRUCT-133]
+	_ = x[OTINTER-134]
+	_ = x[OTFUNC-135]
+	_ = x[OTARRAY-136]
+	_ = x[ODDD-137]
+	_ = x[OINLCALL-138]
+	_ = x[OEFACE-139]
+	_ = x[OITAB-140]
+	_ = x[OIDATA-141]
+	_ = x[OSPTR-142]
+	_ = x[OCLOSUREVAR-143]
+	_ = x[OCFUNC-144]
+	_ = x[OCHECKNIL-145]
+	_ = x[OVARDEF-146]
+	_ = x[OVARKILL-147]
+	_ = x[OVARLIVE-148]
+	_ = x[ORESULT-149]
+	_ = x[OINLMARK-150]
+	_ = x[ORETJMP-151]
+	_ = x[OGETG-152]
+	_ = x[OEND-153]
 }
 
-const _Op_name = "XXXNAMENONAMETYPEPACKLITERALADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLFIELDDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNEWOBJNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECVSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFBLOCKBREAKCASECONTINUEDEFEREMPTYFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYDDDINLCALLEFACEITABIDATASPTRCLOSUREVARCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKRETJMPGETGEND"
+const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLFIELDDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNEWOBJNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECVSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFBLOCKBREAKCASECONTINUEDEFEREMPTYFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYDDDINLCALLEFACEITABIDATASPTRCLOSUREVARCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKRETJMPGETGEND"
 
-var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 36, 39, 45, 49, 55, 61, 70, 82, 91, 100, 112, 121, 123, 126, 136, 143, 150, 157, 161, 165, 173, 181, 190, 198, 201, 206, 213, 220, 226, 235, 243, 251, 257, 261, 270, 277, 281, 284, 291, 299, 307, 314, 320, 323, 329, 336, 344, 348, 355, 363, 365, 367, 369, 371, 373, 375, 380, 385, 393, 396, 405, 408, 412, 420, 427, 436, 449, 452, 455, 458, 461, 464, 467, 473, 476, 482, 485, 491, 495, 498, 502, 507, 512, 518, 523, 527, 532, 540, 548, 554, 563, 574, 581, 585, 592, 599, 607, 611, 615, 619, 626, 633, 641, 647, 652, 657, 661, 669, 674, 679, 683, 686, 694, 698, 700, 705, 707, 712, 718, 724, 730, 736, 741, 745, 752, 758, 763, 769, 772, 779, 784, 788, 793, 797, 807, 812, 820, 826, 833, 840, 846, 853, 859, 863, 866}
+var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 310, 317, 323, 326, 332, 339, 347, 351, 358, 366, 368, 370, 372, 374, 376, 378, 383, 388, 396, 399, 408, 411, 415, 423, 430, 439, 452, 455, 458, 461, 464, 467, 470, 476, 479, 485, 488, 494, 498, 501, 505, 510, 515, 521, 526, 530, 535, 543, 551, 557, 566, 577, 584, 588, 595, 602, 610, 614, 618, 622, 629, 636, 644, 650, 655, 660, 664, 672, 677, 682, 686, 689, 697, 701, 703, 708, 710, 715, 721, 727, 733, 739, 744, 748, 755, 761, 766, 772, 775, 782, 787, 791, 796, 800, 810, 815, 823, 829, 836, 843, 849, 856, 862, 866, 869}
 
 func (i Op) String() string {
 	if i >= Op(len(_Op_index)-1) {
diff --git a/src/cmd/compile/internal/gc/syntax.go b/src/cmd/compile/internal/gc/syntax.go
index e46a0dadf3..b86510a294 100644
--- a/src/cmd/compile/internal/gc/syntax.go
+++ b/src/cmd/compile/internal/gc/syntax.go
@@ -758,6 +758,7 @@ const (
 	OTYPE    // type name
 	OPACK    // import
 	OLITERAL // literal
+	ONIL     // nil
 
 	// expressions
 	OADD          // Left + Right
-- 
GitLab


From 88a9e2f9ad0ad3ef1e254e9150f4649e57b0a296 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 13 Nov 2020 20:38:21 -0800
Subject: [PATCH 0042/2400] [dev.regabi] cmd/compile: replace CTNIL with ONIL

Properly speaking, "nil" is a zero value, not a constant. So
go/constant does not have a representation for it. To allow replacing
Val with constant.Value, we split out ONIL separately from OLITERAL so
we can get rid of CTNIL.

Passes toolstash-check.

Change-Id: I4c8e60cae3b3c91bbac43b3b0cf2a4ade028d6cb
Reviewed-on: https://go-review.googlesource.com/c/go/+/272650
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/const.go     | 19 +++++------------
 src/cmd/compile/internal/gc/esc.go       |  2 +-
 src/cmd/compile/internal/gc/escape.go    |  2 +-
 src/cmd/compile/internal/gc/fmt.go       | 12 +++++------
 src/cmd/compile/internal/gc/iexport.go   | 17 +++++++++-------
 src/cmd/compile/internal/gc/iimport.go   | 22 ++++++++++++--------
 src/cmd/compile/internal/gc/inl.go       |  4 ++--
 src/cmd/compile/internal/gc/obj.go       |  9 +++++---
 src/cmd/compile/internal/gc/order.go     |  6 +++---
 src/cmd/compile/internal/gc/sinit.go     | 26 ++++++++++++++++--------
 src/cmd/compile/internal/gc/ssa.go       | 22 ++++++++++----------
 src/cmd/compile/internal/gc/subr.go      | 16 ++++++++-------
 src/cmd/compile/internal/gc/swt.go       |  2 +-
 src/cmd/compile/internal/gc/syntax.go    |  2 +-
 src/cmd/compile/internal/gc/typecheck.go |  9 +++++---
 src/cmd/compile/internal/gc/universe.go  |  4 +---
 src/cmd/compile/internal/gc/walk.go      | 11 +++++-----
 src/cmd/compile/internal/types/type.go   |  2 +-
 18 files changed, 100 insertions(+), 87 deletions(-)

diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index b92c8d66b5..42ac3a26f8 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -24,7 +24,6 @@ const (
 	CTCPLX
 	CTSTR
 	CTBOOL
-	CTNIL
 )
 
 type Val struct {
@@ -34,7 +33,6 @@ type Val struct {
 	// *Mpflt   float when Ctype() == CTFLT
 	// *Mpcplx  pair of floats when Ctype() == CTCPLX
 	// string   string when Ctype() == CTSTR
-	// *Nilval  when Ctype() == CTNIL
 	U interface{}
 }
 
@@ -45,8 +43,6 @@ func (v Val) Ctype() Ctype {
 		panic("unreachable")
 	case nil:
 		return CTxxx
-	case *NilVal:
-		return CTNIL
 	case bool:
 		return CTBOOL
 	case *Mpint:
@@ -71,8 +67,6 @@ func eqval(a, b Val) bool {
 	default:
 		Fatalf("unexpected Ctype for %T", a.U)
 		panic("unreachable")
-	case *NilVal:
-		return true
 	case bool:
 		y := b.U.(bool)
 		return x == y
@@ -99,8 +93,6 @@ func (v Val) Interface() interface{} {
 	default:
 		Fatalf("unexpected Interface for %T", v.U)
 		panic("unreachable")
-	case *NilVal:
-		return nil
 	case bool, string:
 		return x
 	case *Mpint:
@@ -112,8 +104,6 @@ func (v Val) Interface() interface{} {
 	}
 }
 
-type NilVal struct{}
-
 // Int64Val returns n as an int64.
 // n must be an integer or rune constant.
 func (n *Node) Int64Val() int64 {
@@ -245,7 +235,7 @@ func convlit1(n *Node, t *types.Type, explicit bool, context func() string) *Nod
 		return n
 	}
 
-	if n.Op == OLITERAL {
+	if n.Op == OLITERAL || n.Op == ONIL {
 		// Can't always set n.Type directly on OLITERAL nodes.
 		// See discussion on CL 20813.
 		n = n.rawcopy()
@@ -253,6 +243,9 @@ func convlit1(n *Node, t *types.Type, explicit bool, context func() string) *Nod
 
 	// Nil is technically not a constant, so handle it specially.
 	if n.Type.Etype == TNIL {
+		if n.Op != ONIL {
+			Fatalf("unexpected op: %v (%v)", n, n.Op)
+		}
 		if t == nil {
 			yyerror("use of untyped nil")
 			n.SetDiag(true)
@@ -1039,8 +1032,6 @@ func idealType(ct Ctype) *types.Type {
 		return types.UntypedFloat
 	case CTCPLX:
 		return types.UntypedComplex
-	case CTNIL:
-		return types.Types[TNIL]
 	}
 	Fatalf("unexpected Ctype: %v", ct)
 	return nil
@@ -1189,7 +1180,7 @@ func indexconst(n *Node) int64 {
 // Expressions derived from nil, like string([]byte(nil)), while they
 // may be known at compile time, are not Go language constants.
 func (n *Node) isGoConst() bool {
-	return n.Op == OLITERAL && n.Val().Ctype() != CTNIL
+	return n.Op == OLITERAL
 }
 
 func hascallchan(n *Node) bool {
diff --git a/src/cmd/compile/internal/gc/esc.go b/src/cmd/compile/internal/gc/esc.go
index 6f328ab5ea..b7d1dfc92a 100644
--- a/src/cmd/compile/internal/gc/esc.go
+++ b/src/cmd/compile/internal/gc/esc.go
@@ -152,7 +152,7 @@ func mayAffectMemory(n *Node) bool {
 	// We're ignoring things like division by zero, index out of range,
 	// and nil pointer dereference here.
 	switch n.Op {
-	case ONAME, OCLOSUREVAR, OLITERAL:
+	case ONAME, OCLOSUREVAR, OLITERAL, ONIL:
 		return false
 
 	// Left+Right group.
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 757b4652ca..bc0eb98d76 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -476,7 +476,7 @@ func (e *Escape) exprSkipInit(k EscHole, n *Node) {
 	default:
 		Fatalf("unexpected expr: %v", n)
 
-	case OLITERAL, OGETG, OCLOSUREVAR, OTYPE:
+	case OLITERAL, ONIL, OGETG, OCLOSUREVAR, OTYPE:
 		// nop
 
 	case ONAME:
diff --git a/src/cmd/compile/internal/gc/fmt.go b/src/cmd/compile/internal/gc/fmt.go
index f61ea8aaac..9b57d131b1 100644
--- a/src/cmd/compile/internal/gc/fmt.go
+++ b/src/cmd/compile/internal/gc/fmt.go
@@ -571,9 +571,6 @@ func (v Val) vconv(s fmt.State, flag FmtFlag) {
 	case bool:
 		fmt.Fprint(s, u)
 
-	case *NilVal:
-		fmt.Fprint(s, "nil")
-
 	default:
 		fmt.Fprintf(s, "<ctype=%d>", v.Ctype())
 	}
@@ -1207,6 +1204,7 @@ var opprec = []int{
 	OMAPLIT:        8,
 	ONAME:          8,
 	ONEW:           8,
+	ONIL:           8,
 	ONONAME:        8,
 	OOFFSETOF:      8,
 	OPACK:          8,
@@ -1323,6 +1321,9 @@ func (n *Node) exprfmt(s fmt.State, prec int, mode fmtMode) {
 	case OPAREN:
 		mode.Fprintf(s, "(%v)", n.Left)
 
+	case ONIL:
+		fmt.Fprint(s, "nil")
+
 	case OLITERAL: // this is a bit of a mess
 		if mode == FErr {
 			if n.Orig != nil && n.Orig != n {
@@ -1334,10 +1335,7 @@ func (n *Node) exprfmt(s fmt.State, prec int, mode fmtMode) {
 				return
 			}
 		}
-		if n.Val().Ctype() == CTNIL && n.Orig != nil && n.Orig != n {
-			n.Orig.exprfmt(s, prec, mode)
-			return
-		}
+
 		if n.Type != nil && !n.Type.IsUntyped() {
 			// Need parens when type begins with what might
 			// be misinterpreted as a unary operator: * or <-.
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index 47910eb3b9..b48a840d00 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -759,8 +759,6 @@ func constTypeOf(typ *types.Type) Ctype {
 	}
 
 	switch typ.Etype {
-	case TCHAN, TFUNC, TMAP, TNIL, TINTER, TPTR, TSLICE, TUNSAFEPTR:
-		return CTNIL
 	case TBOOL:
 		return CTBOOL
 	case TSTRING:
@@ -790,9 +788,6 @@ func (w *exportWriter) value(typ *types.Type, v Val) {
 	// and provides a useful consistency check.
 
 	switch constTypeOf(typ) {
-	case CTNIL:
-		// Only one value; nothing to encode.
-		_ = v.U.(*NilVal)
 	case CTBOOL:
 		w.bool(v.U.(bool))
 	case CTSTR:
@@ -1207,11 +1202,19 @@ func (w *exportWriter) expr(n *Node) {
 	switch op := n.Op; op {
 	// expressions
 	// (somewhat closely following the structure of exprfmt in fmt.go)
-	case OLITERAL:
-		if n.Val().Ctype() == CTNIL && n.Orig != nil && n.Orig != n {
+	case ONIL:
+		if !n.Type.HasNil() {
+			Fatalf("unexpected type for nil: %v", n.Type)
+		}
+		if n.Orig != nil && n.Orig != n {
 			w.expr(n.Orig)
 			break
 		}
+		w.op(OLITERAL)
+		w.pos(n.Pos)
+		w.typ(n.Type)
+
+	case OLITERAL:
 		w.op(OLITERAL)
 		w.pos(n.Pos)
 		w.value(n.Type, n.Val())
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index df193cd8e1..ac565a6632 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -293,7 +293,8 @@ func (r *importReader) doDecl(n *Node) {
 		importalias(r.p.ipkg, pos, n.Sym, typ)
 
 	case 'C':
-		typ, val := r.value()
+		typ := r.typ()
+		val := r.value(typ)
 
 		importconst(r.p.ipkg, pos, n.Sym, typ, val)
 
@@ -354,12 +355,8 @@ func (r *importReader) doDecl(n *Node) {
 	}
 }
 
-func (p *importReader) value() (typ *types.Type, v Val) {
-	typ = p.typ()
-
+func (p *importReader) value(typ *types.Type) (v Val) {
 	switch constTypeOf(typ) {
-	case CTNIL:
-		v.U = &NilVal{}
 	case CTBOOL:
 		v.U = p.bool()
 	case CTSTR:
@@ -810,11 +807,20 @@ func (r *importReader) node() *Node {
 	// case OPAREN:
 	// 	unreachable - unpacked by exporter
 
+	// case ONIL:
+	//	unreachable - mapped to OLITERAL
+
 	case OLITERAL:
 		pos := r.pos()
-		typ, val := r.value()
+		typ := r.typ()
 
-		n := npos(pos, nodlit(val))
+		var n *Node
+		if typ.HasNil() {
+			n = nodnil()
+		} else {
+			n = nodlit(r.value(typ))
+		}
+		n = npos(pos, n)
 		n.Type = typ
 		return n
 
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 4aa561da6e..a882e91dce 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -459,7 +459,7 @@ func inlcopy(n *Node) *Node {
 	}
 
 	switch n.Op {
-	case ONAME, OTYPE, OLITERAL:
+	case ONAME, OTYPE, OLITERAL, ONIL:
 		return n
 	}
 
@@ -1322,7 +1322,7 @@ func (subst *inlsubst) node(n *Node) *Node {
 		}
 		return n
 
-	case OLITERAL, OTYPE:
+	case OLITERAL, ONIL, OTYPE:
 		// If n is a named constant or type, we can continue
 		// using it in the inline copy. Otherwise, make a copy
 		// so we can update the line number.
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 8fe480b65f..77f9afb44d 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -591,12 +591,15 @@ func litsym(n, c *Node, wid int) {
 	if n.Op != ONAME {
 		Fatalf("litsym n op %v", n.Op)
 	}
-	if c.Op != OLITERAL {
-		Fatalf("litsym c op %v", c.Op)
-	}
 	if n.Sym == nil {
 		Fatalf("litsym nil n sym")
 	}
+	if c.Op == ONIL {
+		return
+	}
+	if c.Op != OLITERAL {
+		Fatalf("litsym c op %v", c.Op)
+	}
 	s := n.Sym.Linksym()
 	switch u := c.Val().U.(type) {
 	case bool:
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 863de5b6c7..11c8b1fa25 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -119,7 +119,7 @@ func (o *Order) cheapExpr(n *Node) *Node {
 	}
 
 	switch n.Op {
-	case ONAME, OLITERAL:
+	case ONAME, OLITERAL, ONIL:
 		return n
 	case OLEN, OCAP:
 		l := o.cheapExpr(n.Left)
@@ -143,7 +143,7 @@ func (o *Order) cheapExpr(n *Node) *Node {
 // The intended use is to apply to x when rewriting x += y into x = x + y.
 func (o *Order) safeExpr(n *Node) *Node {
 	switch n.Op {
-	case ONAME, OLITERAL:
+	case ONAME, OLITERAL, ONIL:
 		return n
 
 	case ODOT, OLEN, OCAP:
@@ -202,7 +202,7 @@ func isaddrokay(n *Node) bool {
 // The result of addrTemp MUST be assigned back to n, e.g.
 // 	n.Left = o.addrTemp(n.Left)
 func (o *Order) addrTemp(n *Node) *Node {
-	if consttype(n) != CTxxx {
+	if n.Op == OLITERAL || n.Op == ONIL {
 		// TODO: expand this to all static composite literal nodes?
 		n = defaultlit(n, nil)
 		dowidth(n.Type)
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 212fcc022d..c199ff6317 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -104,6 +104,9 @@ func (s *InitSchedule) staticcopy(l *Node, r *Node) bool {
 		s.append(nod(OAS, l, conv(r, l.Type)))
 		return true
 
+	case ONIL:
+		return true
+
 	case OLITERAL:
 		if isZero(r) {
 			return true
@@ -139,7 +142,7 @@ func (s *InitSchedule) staticcopy(l *Node, r *Node) bool {
 			e := &p.E[i]
 			n.Xoffset = l.Xoffset + e.Xoffset
 			n.Type = e.Expr.Type
-			if e.Expr.Op == OLITERAL {
+			if e.Expr.Op == OLITERAL || e.Expr.Op == ONIL {
 				litsym(n, e.Expr, int(n.Type.Width))
 				continue
 			}
@@ -171,6 +174,9 @@ func (s *InitSchedule) staticassign(l *Node, r *Node) bool {
 	case ONAME:
 		return s.staticcopy(l, r)
 
+	case ONIL:
+		return true
+
 	case OLITERAL:
 		if isZero(r) {
 			return true
@@ -232,7 +238,7 @@ func (s *InitSchedule) staticassign(l *Node, r *Node) bool {
 			e := &p.E[i]
 			n.Xoffset = l.Xoffset + e.Xoffset
 			n.Type = e.Expr.Type
-			if e.Expr.Op == OLITERAL {
+			if e.Expr.Op == OLITERAL || e.Expr.Op == ONIL {
 				litsym(n, e.Expr, int(n.Type.Width))
 				continue
 			}
@@ -269,13 +275,14 @@ func (s *InitSchedule) staticassign(l *Node, r *Node) bool {
 		for val.Op == OCONVIFACE {
 			val = val.Left
 		}
+
 		if val.Type.IsInterface() {
 			// val is an interface type.
 			// If val is nil, we can statically initialize l;
 			// both words are zero and so there no work to do, so report success.
 			// If val is non-nil, we have no concrete type to record,
 			// and we won't be able to statically initialize its value, so report failure.
-			return Isconst(val, CTNIL)
+			return val.Op == ONIL
 		}
 
 		markTypeUsedInInterface(val.Type, l.Sym.Linksym())
@@ -296,7 +303,7 @@ func (s *InitSchedule) staticassign(l *Node, r *Node) bool {
 
 		// Emit data.
 		if isdirectiface(val.Type) {
-			if Isconst(val, CTNIL) {
+			if val.Op == ONIL {
 				// Nil is zero, nothing to do.
 				return true
 			}
@@ -462,7 +469,7 @@ func isStaticCompositeLiteral(n *Node) bool {
 			}
 		}
 		return true
-	case OLITERAL:
+	case OLITERAL, ONIL:
 		return true
 	case OCONVIFACE:
 		// See staticassign's OCONVIFACE case for comments.
@@ -471,9 +478,9 @@ func isStaticCompositeLiteral(n *Node) bool {
 			val = val.Left
 		}
 		if val.Type.IsInterface() {
-			return Isconst(val, CTNIL)
+			return val.Op == ONIL
 		}
-		if isdirectiface(val.Type) && Isconst(val, CTNIL) {
+		if isdirectiface(val.Type) && val.Op == ONIL {
 			return true
 		}
 		return isStaticCompositeLiteral(val)
@@ -1105,13 +1112,14 @@ func (s *InitSchedule) addvalue(p *InitPlan, xoffset int64, n *Node) {
 
 func isZero(n *Node) bool {
 	switch n.Op {
+	case ONIL:
+		return true
+
 	case OLITERAL:
 		switch u := n.Val().U.(type) {
 		default:
 			Dump("unexpected literal", n)
 			Fatalf("isZero")
-		case *NilVal:
-			return true
 		case string:
 			return u == ""
 		case bool:
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 0b38e70cd2..709b2d434e 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -1993,7 +1993,7 @@ func (s *state) ssaShiftOp(op Op, t *types.Type, u *types.Type) ssa.Op {
 
 // expr converts the expression n to ssa, adds it to s and returns the ssa result.
 func (s *state) expr(n *Node) *ssa.Value {
-	if !(n.Op == ONAME || n.Op == OLITERAL && n.Sym != nil) {
+	if hasUniquePos(n) {
 		// ONAMEs and named OLITERALs have the line number
 		// of the decl, not the use. See issue 14742.
 		s.pushLine(n.Pos)
@@ -2029,6 +2029,16 @@ func (s *state) expr(n *Node) *ssa.Value {
 	case OCLOSUREVAR:
 		addr := s.addr(n)
 		return s.load(n.Type, addr)
+	case ONIL:
+		t := n.Type
+		switch {
+		case t.IsSlice():
+			return s.constSlice(t)
+		case t.IsInterface():
+			return s.constInterface(t)
+		default:
+			return s.constNil(t)
+		}
 	case OLITERAL:
 		switch u := n.Val().U.(type) {
 		case *Mpint:
@@ -2053,16 +2063,6 @@ func (s *state) expr(n *Node) *ssa.Value {
 			return s.entryNewValue0A(ssa.OpConstString, n.Type, u)
 		case bool:
 			return s.constBool(u)
-		case *NilVal:
-			t := n.Type
-			switch {
-			case t.IsSlice():
-				return s.constSlice(t)
-			case t.IsInterface():
-				return s.constInterface(t)
-			default:
-				return s.constNil(t)
-			}
 		case *Mpflt:
 			switch n.Type.Size() {
 			case 4:
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 849043bfe2..7c13aef214 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -41,7 +41,7 @@ func hasUniquePos(n *Node) bool {
 	switch n.Op {
 	case ONAME, OPACK:
 		return false
-	case OLITERAL, OTYPE:
+	case OLITERAL, ONIL, OTYPE:
 		if n.Sym != nil {
 			return false
 		}
@@ -257,7 +257,9 @@ func nodintconst(v int64) *Node {
 }
 
 func nodnil() *Node {
-	return nodlit(Val{new(NilVal)})
+	n := nod(ONIL, nil, nil)
+	n.Type = types.Types[TNIL]
+	return n
 }
 
 func nodbool(b bool) *Node {
@@ -298,7 +300,7 @@ func treecopy(n *Node, pos src.XPos) *Node {
 		// crashing (golang.org/issue/11361).
 		fallthrough
 
-	case ONAME, ONONAME, OLITERAL, OTYPE:
+	case ONAME, ONONAME, OLITERAL, ONIL, OTYPE:
 		return n
 
 	}
@@ -308,7 +310,7 @@ func treecopy(n *Node, pos src.XPos) *Node {
 func (n *Node) isNil() bool {
 	// Check n.Orig because constant propagation may produce typed nil constants,
 	// which don't exist in the Go spec.
-	return Isconst(n.Orig, CTNIL)
+	return n.Orig.Op == ONIL
 }
 
 func isptrto(t *types.Type, et types.EType) bool {
@@ -807,7 +809,7 @@ func calcHasCall(n *Node) bool {
 	}
 
 	switch n.Op {
-	case OLITERAL, ONAME, OTYPE:
+	case OLITERAL, ONIL, ONAME, OTYPE:
 		if n.HasCall() {
 			Fatalf("OLITERAL/ONAME/OTYPE should never have calls: %+v", n)
 		}
@@ -926,7 +928,7 @@ func safeexpr(n *Node, init *Nodes) *Node {
 	}
 
 	switch n.Op {
-	case ONAME, OLITERAL:
+	case ONAME, OLITERAL, ONIL:
 		return n
 
 	case ODOT, OLEN, OCAP:
@@ -988,7 +990,7 @@ func copyexpr(n *Node, t *types.Type, init *Nodes) *Node {
 // result may not be assignable.
 func cheapexpr(n *Node, init *Nodes) *Node {
 	switch n.Op {
-	case ONAME, OLITERAL:
+	case ONAME, OLITERAL, ONIL:
 		return n
 	}
 
diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index 9ab5f0c248..5f4e9e4b40 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -261,7 +261,7 @@ func walkExprSwitch(sw *Node) {
 	}
 
 	cond = walkexpr(cond, &sw.Ninit)
-	if cond.Op != OLITERAL {
+	if cond.Op != OLITERAL && cond.Op != ONIL {
 		cond = copyexpr(cond, cond.Type, &sw.Nbody)
 	}
 
diff --git a/src/cmd/compile/internal/gc/syntax.go b/src/cmd/compile/internal/gc/syntax.go
index b86510a294..f364ed1527 100644
--- a/src/cmd/compile/internal/gc/syntax.go
+++ b/src/cmd/compile/internal/gc/syntax.go
@@ -294,7 +294,7 @@ func (n *Node) SetIota(x int64) {
 // Extra care must be taken when mutating such a node.
 func (n *Node) mayBeShared() bool {
 	switch n.Op {
-	case ONAME, OLITERAL, OTYPE:
+	case ONAME, OLITERAL, ONIL, OTYPE:
 		return true
 	}
 	return false
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index f13d9a3e26..32619b08d1 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -363,7 +363,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			n.Type = types.UntypedString
 		}
 
-	case ONONAME:
+	case ONIL, ONONAME:
 		ok |= ctxExpr
 
 	case ONAME:
@@ -1590,7 +1590,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 		n.Type = t
 		if !t.IsSlice() {
-			if Isconst(args.First(), CTNIL) {
+			if args.First().isNil() {
 				yyerror("first argument to append must be typed slice; have untyped nil")
 				n.Type = nil
 				return n
@@ -3193,6 +3193,9 @@ func samesafeexpr(l *Node, r *Node) bool {
 
 	case OLITERAL:
 		return eqval(l.Val(), r.Val())
+
+	case ONIL:
+		return true
 	}
 
 	return false
@@ -3596,7 +3599,7 @@ func typecheckdef(n *Node) {
 		}
 		if !e.isGoConst() {
 			if !e.Diag() {
-				if Isconst(e, CTNIL) {
+				if e.Op == ONIL {
 					yyerrorl(n.Pos, "const initializer cannot be nil")
 				} else {
 					yyerrorl(n.Pos, "const initializer %v is not a constant", e)
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index 559d47da1a..32bf37e322 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -157,9 +157,7 @@ func lexinit() {
 
 	types.Types[TNIL] = types.New(TNIL)
 	s = builtinpkg.Lookup("nil")
-	var v Val
-	v.U = new(NilVal)
-	s.Def = asTypesNode(nodlit(v))
+	s.Def = asTypesNode(nodnil())
 	asNode(s.Def).Sym = s
 	asNode(s.Def).Name = new(Name)
 
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index a61cb3f651..ac43a8e1be 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -465,7 +465,7 @@ opswitch:
 
 	case ONONAME, OEMPTY, OGETG, ONEWOBJ:
 
-	case OTYPE, ONAME, OLITERAL:
+	case OTYPE, ONAME, OLITERAL, ONIL:
 		// TODO(mdempsky): Just return n; see discussion on CL 38655.
 		// Perhaps refactor to use Node.mayBeShared for these instead.
 		// If these return early, make sure to still call
@@ -2277,7 +2277,7 @@ func varexpr(n *Node) bool {
 	}
 
 	switch n.Op {
-	case OLITERAL:
+	case OLITERAL, ONIL:
 		return true
 
 	case ONAME:
@@ -2332,7 +2332,7 @@ func vmatch2(l *Node, r *Node) bool {
 	case ONAME:
 		return l == r
 
-	case OLITERAL:
+	case OLITERAL, ONIL:
 		return false
 	}
 
@@ -2373,7 +2373,7 @@ func vmatch1(l *Node, r *Node) bool {
 
 		return vmatch2(l, r)
 
-	case OLITERAL:
+	case OLITERAL, ONIL:
 		return false
 	}
 
@@ -3190,7 +3190,7 @@ func eqfor(t *types.Type) (n *Node, needsize bool) {
 // The result of walkcompare MUST be assigned back to n, e.g.
 // 	n.Left = walkcompare(n.Left, init)
 func walkcompare(n *Node, init *Nodes) *Node {
-	if n.Left.Type.IsInterface() && n.Right.Type.IsInterface() && n.Left.Op != OLITERAL && n.Right.Op != OLITERAL {
+	if n.Left.Type.IsInterface() && n.Right.Type.IsInterface() && n.Left.Op != ONIL && n.Right.Op != ONIL {
 		return walkcompareInterface(n, init)
 	}
 
@@ -3788,6 +3788,7 @@ func candiscard(n *Node) bool {
 		OTYPE,
 		OPACK,
 		OLITERAL,
+		ONIL,
 		OADD,
 		OSUB,
 		OOR,
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 62c5c34484..82db9e4dbc 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -1265,7 +1265,7 @@ func (t *Type) IsPtrShaped() bool {
 // HasNil reports whether the set of values determined by t includes nil.
 func (t *Type) HasNil() bool {
 	switch t.Etype {
-	case TCHAN, TFUNC, TINTER, TMAP, TPTR, TSLICE, TUNSAFEPTR:
+	case TCHAN, TFUNC, TINTER, TMAP, TNIL, TPTR, TSLICE, TUNSAFEPTR:
 		return true
 	}
 	return false
-- 
GitLab


From 6dae48fb0ba772d30c664a8a31732a46e980e536 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 20 Nov 2020 13:23:58 -0800
Subject: [PATCH 0043/2400] [dev.regabi] cmd/compile: refactor type/value
 assertions

Small refactoring to make subsequent CLs clearer.

Passes toolstash-check.

Change-Id: I1a6ae599f491220d44aaabae0b7bed4aff46ee92
Reviewed-on: https://go-review.googlesource.com/c/go/+/272651
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/const.go     | 23 ++++++++++++++++++-----
 src/cmd/compile/internal/gc/iexport.go   |  4 +---
 src/cmd/compile/internal/gc/syntax.go    |  3 +++
 src/cmd/compile/internal/gc/typecheck.go |  2 +-
 4 files changed, 23 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 42ac3a26f8..4e7318cfc6 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -275,8 +275,8 @@ func convlit1(n *Node, t *types.Type, explicit bool, context func() string) *Nod
 		if v.U == nil {
 			break
 		}
-		n.SetVal(v)
 		n.Type = t
+		n.SetVal(v)
 		return n
 
 	case OPLUS, ONEG, OBITNOT, ONOT, OREAL, OIMAG:
@@ -979,9 +979,6 @@ func setconst(n *Node, v Val) {
 		Xoffset: BADWIDTH,
 	}
 	n.SetVal(v)
-	if vt := idealType(v.Ctype()); n.Type.IsUntyped() && n.Type != vt {
-		Fatalf("untyped type mismatch, have: %v, want: %v", n.Type, vt)
-	}
 
 	// Check range.
 	lno := setlineno(n)
@@ -1000,6 +997,22 @@ func setconst(n *Node, v Val) {
 	}
 }
 
+func assertRepresents(t *types.Type, v Val) {
+	if !represents(t, v) {
+		Fatalf("%v does not represent %v", t, v)
+	}
+}
+
+func represents(t *types.Type, v Val) bool {
+	if !t.IsUntyped() {
+		// TODO(mdempsky): Stricter handling of typed types.
+		return true
+	}
+
+	vt := idealType(v.Ctype())
+	return t == vt
+}
+
 func setboolconst(n *Node, v bool) {
 	setconst(n, Val{U: v})
 }
@@ -1013,8 +1026,8 @@ func setintconst(n *Node, v int64) {
 // nodlit returns a new untyped constant with value v.
 func nodlit(v Val) *Node {
 	n := nod(OLITERAL, nil, nil)
-	n.SetVal(v)
 	n.Type = idealType(v.Ctype())
+	n.SetVal(v)
 	return n
 }
 
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index b48a840d00..c3385f785a 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -777,9 +777,7 @@ func constTypeOf(typ *types.Type) Ctype {
 }
 
 func (w *exportWriter) value(typ *types.Type, v Val) {
-	if vt := idealType(v.Ctype()); typ.IsUntyped() && typ != vt {
-		Fatalf("exporter: untyped type mismatch, have: %v, want: %v", typ, vt)
-	}
+	assertRepresents(typ, v)
 	w.typ(typ)
 
 	// Each type has only one admissible constant representation,
diff --git a/src/cmd/compile/internal/gc/syntax.go b/src/cmd/compile/internal/gc/syntax.go
index f364ed1527..de516dec69 100644
--- a/src/cmd/compile/internal/gc/syntax.go
+++ b/src/cmd/compile/internal/gc/syntax.go
@@ -251,6 +251,9 @@ func (n *Node) SetVal(v Val) {
 		Dump("have Opt", n)
 		Fatalf("have Opt")
 	}
+	if n.Op == OLITERAL {
+		assertRepresents(n.Type, v)
+	}
 	n.SetHasVal(true)
 	n.E = v.U
 }
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 32619b08d1..443a3f7827 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -3624,8 +3624,8 @@ func typecheckdef(n *Node) {
 			e = convlit(e, t)
 		}
 
-		n.SetVal(e.Val())
 		n.Type = e.Type
+		n.SetVal(e.Val())
 
 	case ONAME:
 		if n.Name.Param.Ntype != nil {
-- 
GitLab


From c767d73227704ba4e22e366e89d1885f52d4b6cc Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 13 Nov 2020 18:33:19 -0800
Subject: [PATCH 0044/2400] [dev.regabi] cmd/compile: remove CTRUNE

Since CL 255217, we've been able to rely on types.UntypedRune to
identify untyped rune literals, rather than needing Mpint.Rune /
CTRUNE. This makes way for switching to using go/constant, which
doesn't have a separate notion of rune constants distinct from integer
constants.

Passes toolstash-check.

Change-Id: I319861f4758aeea17345c101b167cb307e706a0e
Reviewed-on: https://go-review.googlesource.com/c/go/+/272652
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/const.go     | 86 +++++++++---------------
 src/cmd/compile/internal/gc/fmt.go       | 55 ++++++++-------
 src/cmd/compile/internal/gc/iimport.go   |  1 -
 src/cmd/compile/internal/gc/mpint.go     |  5 +-
 src/cmd/compile/internal/gc/noder.go     |  4 +-
 src/cmd/compile/internal/gc/typecheck.go |  2 +-
 src/cmd/compile/internal/gc/walk.go      |  5 +-
 7 files changed, 71 insertions(+), 87 deletions(-)

diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 4e7318cfc6..326f44a2fe 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -19,7 +19,6 @@ const (
 	CTxxx Ctype = iota
 
 	CTINT
-	CTRUNE
 	CTFLT
 	CTCPLX
 	CTSTR
@@ -29,7 +28,7 @@ const (
 type Val struct {
 	// U contains one of:
 	// bool     bool when Ctype() == CTBOOL
-	// *Mpint   int when Ctype() == CTINT, rune when Ctype() == CTRUNE
+	// *Mpint   int when Ctype() == CTINT
 	// *Mpflt   float when Ctype() == CTFLT
 	// *Mpcplx  pair of floats when Ctype() == CTCPLX
 	// string   string when Ctype() == CTSTR
@@ -37,7 +36,7 @@ type Val struct {
 }
 
 func (v Val) Ctype() Ctype {
-	switch x := v.U.(type) {
+	switch v.U.(type) {
 	default:
 		Fatalf("unexpected Ctype for %T", v.U)
 		panic("unreachable")
@@ -46,9 +45,6 @@ func (v Val) Ctype() Ctype {
 	case bool:
 		return CTBOOL
 	case *Mpint:
-		if x.Rune {
-			return CTRUNE
-		}
 		return CTINT
 	case *Mpflt:
 		return CTFLT
@@ -384,7 +380,7 @@ func convertVal(v Val, t *types.Type, explicit bool) Val {
 			return v
 		}
 
-	case CTINT, CTRUNE:
+	case CTINT:
 		if explicit && t.IsString() {
 			return tostr(v)
 		}
@@ -449,11 +445,6 @@ func toflt(v Val) Val {
 func toint(v Val) Val {
 	switch u := v.U.(type) {
 	case *Mpint:
-		if u.Rune {
-			i := new(Mpint)
-			i.Set(u)
-			v.U = i
-		}
 
 	case *Mpflt:
 		i := new(Mpint)
@@ -560,11 +551,7 @@ func consttype(n *Node) Ctype {
 }
 
 func Isconst(n *Node, ct Ctype) bool {
-	t := consttype(n)
-
-	// If the caller is asking for CTINT, allow CTRUNE too.
-	// Makes life easier for back ends.
-	return t == ct || (ct == CTINT && t == CTRUNE)
+	return consttype(n) == ct
 }
 
 // evconst rewrites constant expressions into OLITERAL nodes.
@@ -710,7 +697,7 @@ func compareOp(x Val, op Op, y Val) bool {
 			return x != y
 		}
 
-	case CTINT, CTRUNE:
+	case CTINT:
 		x, y := x.U.(*Mpint), y.U.(*Mpint)
 		return cmpZero(x.Cmp(y), op)
 
@@ -784,11 +771,10 @@ Outer:
 			return Val{U: x || y}
 		}
 
-	case CTINT, CTRUNE:
+	case CTINT:
 		x, y := x.U.(*Mpint), y.U.(*Mpint)
 
 		u := new(Mpint)
-		u.Rune = x.Rune || y.Rune
 		u.Set(x)
 		switch op {
 		case OADD:
@@ -879,16 +865,15 @@ func unaryOp(op Op, x Val, t *types.Type) Val {
 	switch op {
 	case OPLUS:
 		switch x.Ctype() {
-		case CTINT, CTRUNE, CTFLT, CTCPLX:
+		case CTINT, CTFLT, CTCPLX:
 			return x
 		}
 
 	case ONEG:
 		switch x.Ctype() {
-		case CTINT, CTRUNE:
+		case CTINT:
 			x := x.U.(*Mpint)
 			u := new(Mpint)
-			u.Rune = x.Rune
 			u.Set(x)
 			u.Neg()
 			return Val{U: u}
@@ -912,11 +897,10 @@ func unaryOp(op Op, x Val, t *types.Type) Val {
 
 	case OBITNOT:
 		switch x.Ctype() {
-		case CTINT, CTRUNE:
+		case CTINT:
 			x := x.U.(*Mpint)
 
 			u := new(Mpint)
-			u.Rune = x.Rune
 			if t.IsSigned() || t.IsUntyped() {
 				// Signed values change sign.
 				u.SetInt64(-1)
@@ -937,14 +921,11 @@ func unaryOp(op Op, x Val, t *types.Type) Val {
 }
 
 func shiftOp(x Val, op Op, y Val) Val {
-	if x.Ctype() != CTRUNE {
-		x = toint(x)
-	}
+	x = toint(x)
 	y = toint(y)
 
 	u := new(Mpint)
 	u.Set(x.U.(*Mpint))
-	u.Rune = x.U.(*Mpint).Rune
 	switch op {
 	case OLSH:
 		u.Lsh(y.U.(*Mpint))
@@ -1010,7 +991,7 @@ func represents(t *types.Type, v Val) bool {
 	}
 
 	vt := idealType(v.Ctype())
-	return t == vt
+	return t == vt || (t == types.UntypedRune && vt == types.UntypedInt)
 }
 
 func setboolconst(n *Node, v bool) {
@@ -1039,8 +1020,6 @@ func idealType(ct Ctype) *types.Type {
 		return types.UntypedBool
 	case CTINT:
 		return types.UntypedInt
-	case CTRUNE:
-		return types.UntypedRune
 	case CTFLT:
 		return types.UntypedFloat
 	case CTCPLX:
@@ -1091,31 +1070,30 @@ func defaultlit2(l *Node, r *Node, force bool) (*Node, *Node) {
 	return l, r
 }
 
-func ctype(t *types.Type) Ctype {
-	switch t {
-	case types.UntypedBool:
-		return CTBOOL
-	case types.UntypedString:
-		return CTSTR
-	case types.UntypedInt:
-		return CTINT
-	case types.UntypedRune:
-		return CTRUNE
-	case types.UntypedFloat:
-		return CTFLT
-	case types.UntypedComplex:
-		return CTCPLX
+func mixUntyped(t1, t2 *types.Type) *types.Type {
+	if t1 == t2 {
+		return t1
+	}
+
+	rank := func(t *types.Type) int {
+		switch t {
+		case types.UntypedInt:
+			return 0
+		case types.UntypedRune:
+			return 1
+		case types.UntypedFloat:
+			return 2
+		case types.UntypedComplex:
+			return 3
+		}
+		Fatalf("bad type %v", t)
+		panic("unreachable")
 	}
-	Fatalf("bad type %v", t)
-	panic("unreachable")
-}
 
-func mixUntyped(t1, t2 *types.Type) *types.Type {
-	t := t1
-	if ctype(t2) > ctype(t1) {
-		t = t2
+	if rank(t2) > rank(t1) {
+		return t2
 	}
-	return t
+	return t1
 }
 
 func defaultType(t *types.Type) *types.Type {
diff --git a/src/cmd/compile/internal/gc/fmt.go b/src/cmd/compile/internal/gc/fmt.go
index 9b57d131b1..740fdab977 100644
--- a/src/cmd/compile/internal/gc/fmt.go
+++ b/src/cmd/compile/internal/gc/fmt.go
@@ -526,28 +526,12 @@ func (v Val) Format(s fmt.State, verb rune) {
 func (v Val) vconv(s fmt.State, flag FmtFlag) {
 	switch u := v.U.(type) {
 	case *Mpint:
-		if !u.Rune {
-			if flag&FmtSharp != 0 {
-				fmt.Fprint(s, u.String())
-				return
-			}
-			fmt.Fprint(s, u.GoString())
+		if flag&FmtSharp != 0 {
+			fmt.Fprint(s, u.String())
 			return
 		}
-
-		switch x := u.Int64(); {
-		case ' ' <= x && x < utf8.RuneSelf && x != '\\' && x != '\'':
-			fmt.Fprintf(s, "'%c'", int(x))
-
-		case 0 <= x && x < 1<<16:
-			fmt.Fprintf(s, "'\\u%04x'", uint(int(x)))
-
-		case 0 <= x && x <= utf8.MaxRune:
-			fmt.Fprintf(s, "'\\U%08x'", uint64(x))
-
-		default:
-			fmt.Fprintf(s, "('\\x00' + %v)", u)
-		}
+		fmt.Fprint(s, u.GoString())
+		return
 
 	case *Mpflt:
 		if flag&FmtSharp != 0 {
@@ -1336,19 +1320,40 @@ func (n *Node) exprfmt(s fmt.State, prec int, mode fmtMode) {
 			}
 		}
 
+		needUnparen := false
 		if n.Type != nil && !n.Type.IsUntyped() {
 			// Need parens when type begins with what might
 			// be misinterpreted as a unary operator: * or <-.
 			if n.Type.IsPtr() || (n.Type.IsChan() && n.Type.ChanDir() == types.Crecv) {
-				mode.Fprintf(s, "(%v)(%v)", n.Type, n.Val())
-				return
+				mode.Fprintf(s, "(%v)(", n.Type)
 			} else {
-				mode.Fprintf(s, "%v(%v)", n.Type, n.Val())
-				return
+				mode.Fprintf(s, "%v(", n.Type)
 			}
+			needUnparen = true
 		}
 
-		mode.Fprintf(s, "%v", n.Val())
+		if n.Type == types.UntypedRune {
+			u := n.Val().U.(*Mpint)
+			switch x := u.Int64(); {
+			case ' ' <= x && x < utf8.RuneSelf && x != '\\' && x != '\'':
+				fmt.Fprintf(s, "'%c'", int(x))
+
+			case 0 <= x && x < 1<<16:
+				fmt.Fprintf(s, "'\\u%04x'", uint(int(x)))
+
+			case 0 <= x && x <= utf8.MaxRune:
+				fmt.Fprintf(s, "'\\U%08x'", uint64(x))
+
+			default:
+				fmt.Fprintf(s, "('\\x00' + %v)", u)
+			}
+		} else {
+			mode.Fprintf(s, "%v", n.Val())
+		}
+
+		if needUnparen {
+			mode.Fprintf(s, ")")
+		}
 
 	// Special case: name used as local variable in export.
 	// _ becomes ~b%d internally; print as _ for export
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index ac565a6632..fc6b7ecb9f 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -363,7 +363,6 @@ func (p *importReader) value(typ *types.Type) (v Val) {
 		v.U = p.string()
 	case CTINT:
 		x := new(Mpint)
-		x.Rune = typ == types.UntypedRune
 		p.mpint(&x.Val, typ)
 		v.U = x
 	case CTFLT:
diff --git a/src/cmd/compile/internal/gc/mpint.go b/src/cmd/compile/internal/gc/mpint.go
index 79eb60e65d..199b2659d1 100644
--- a/src/cmd/compile/internal/gc/mpint.go
+++ b/src/cmd/compile/internal/gc/mpint.go
@@ -13,9 +13,8 @@ import (
 
 // Mpint represents an integer constant.
 type Mpint struct {
-	Val  big.Int
-	Ovf  bool // set if Val overflowed compiler limit (sticky)
-	Rune bool // set if syntax indicates default type rune
+	Val big.Int
+	Ovf bool // set if Val overflowed compiler limit (sticky)
 }
 
 func (a *Mpint) SetOverflow() {
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 27bc9b5629..303b04cd46 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -656,6 +656,9 @@ func (p *noder) expr(expr syntax.Expr) *Node {
 		return p.mkname(expr)
 	case *syntax.BasicLit:
 		n := nodlit(p.basicLit(expr))
+		if expr.Kind == syntax.RuneLit {
+			n.Type = types.UntypedRune
+		}
 		n.SetDiag(expr.Bad) // avoid follow-on errors if there was a syntax error
 		return n
 	case *syntax.CompositeLit:
@@ -1428,7 +1431,6 @@ func (p *noder) basicLit(lit *syntax.BasicLit) Val {
 
 	case syntax.RuneLit:
 		x := new(Mpint)
-		x.Rune = true
 		if !lit.Bad {
 			u, _ := strconv.Unquote(s)
 			var r rune
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 443a3f7827..3fb59c8deb 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -3724,7 +3724,7 @@ func checkmake(t *types.Type, arg string, np **Node) bool {
 	// Do range checks for constants before defaultlit
 	// to avoid redundant "constant NNN overflows int" errors.
 	switch consttype(n) {
-	case CTINT, CTRUNE, CTFLT, CTCPLX:
+	case CTINT, CTFLT, CTCPLX:
 		v := toint(n.Val()).U.(*Mpint)
 		if v.CmpInt64(0) < 0 {
 			yyerror("negative %s argument in make(%v)", arg, t)
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index ac43a8e1be..e7351d1792 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -1931,10 +1931,11 @@ func walkprint(nn *Node, init *Nodes) *Node {
 	calls := []*Node{mkcall("printlock", nil, init)}
 	for i, n := range nn.List.Slice() {
 		if n.Op == OLITERAL {
-			switch n.Val().Ctype() {
-			case CTRUNE:
+			if n.Type == types.UntypedRune {
 				n = defaultlit(n, types.Runetype)
+			}
 
+			switch n.Val().Ctype() {
 			case CTINT:
 				n = defaultlit(n, types.Types[TINT64])
 
-- 
GitLab


From 015423a15bcfae148d5121bcf4ba5b50d0847cd0 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 23 Nov 2020 21:48:38 -0800
Subject: [PATCH 0045/2400] [dev.regabi] strconv: add to bootstrap packages

go/constant relies on strconv for parsing Go literals, while older
versions of strconv either lack recent Go language features (e.g., Go
1.13's new numeric literals) or have errors (e.g., mishandling of
carriage returns in raw string literals prior to Go 1.8).

This requires two changes:

1. Splitting out the internal/bytealg dependency into a separate file,
which can be easily substituted with a simple loop for bootstrap
builds.

2. Updating eisel_lemire.go to not utilize Go 1.13 functionality
(underscores in numeric literals and signed shift counts).

Change-Id: Ib48a858a03b155eebdcd08d577aec2254337e70e
Reviewed-on: https://go-review.googlesource.com/c/go/+/272749
Reviewed-by: Robert Griesemer <gri@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/dep_test.go |  2 +-
 src/cmd/dist/buildtool.go               |  2 ++
 src/strconv/bytealg.go                  | 14 ++++++++++++++
 src/strconv/bytealg_bootstrap.go        | 17 +++++++++++++++++
 src/strconv/eisel_lemire.go             | 16 ++++++++--------
 src/strconv/quote.go                    |  6 ------
 6 files changed, 42 insertions(+), 15 deletions(-)
 create mode 100644 src/strconv/bytealg.go
 create mode 100644 src/strconv/bytealg_bootstrap.go

diff --git a/src/cmd/compile/internal/gc/dep_test.go b/src/cmd/compile/internal/gc/dep_test.go
index c1dac93386..a185bc9f54 100644
--- a/src/cmd/compile/internal/gc/dep_test.go
+++ b/src/cmd/compile/internal/gc/dep_test.go
@@ -18,7 +18,7 @@ func TestDeps(t *testing.T) {
 	}
 	for _, dep := range strings.Fields(strings.Trim(string(out), "[]")) {
 		switch dep {
-		case "go/build", "go/token":
+		case "go/build", "go/scanner":
 			t.Errorf("undesired dependency on %q", dep)
 		}
 	}
diff --git a/src/cmd/dist/buildtool.go b/src/cmd/dist/buildtool.go
index 37b3d45977..e39f284db5 100644
--- a/src/cmd/dist/buildtool.go
+++ b/src/cmd/dist/buildtool.go
@@ -96,6 +96,7 @@ var bootstrapDirs = []string{
 	"debug/elf",
 	"debug/macho",
 	"debug/pe",
+	"go/constant",
 	"internal/goversion",
 	"internal/race",
 	"internal/unsafeheader",
@@ -103,6 +104,7 @@ var bootstrapDirs = []string{
 	"math/big",
 	"math/bits",
 	"sort",
+	"strconv",
 }
 
 // File prefixes that are ignored by go/build anyway, and cause
diff --git a/src/strconv/bytealg.go b/src/strconv/bytealg.go
new file mode 100644
index 0000000000..7f66f2a8bb
--- /dev/null
+++ b/src/strconv/bytealg.go
@@ -0,0 +1,14 @@
+// Copyright 2009 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.
+
+// +build !compiler_bootstrap
+
+package strconv
+
+import "internal/bytealg"
+
+// contains reports whether the string contains the byte c.
+func contains(s string, c byte) bool {
+	return bytealg.IndexByteString(s, c) != -1
+}
diff --git a/src/strconv/bytealg_bootstrap.go b/src/strconv/bytealg_bootstrap.go
new file mode 100644
index 0000000000..a3a547d1b6
--- /dev/null
+++ b/src/strconv/bytealg_bootstrap.go
@@ -0,0 +1,17 @@
+// Copyright 2020 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.
+
+// +build compiler_bootstrap
+
+package strconv
+
+// contains reports whether the string contains the byte c.
+func contains(s string, c byte) bool {
+	for i := 0; i < len(s); i++ {
+		if s[i] == c {
+			return true
+		}
+	}
+	return false
+}
diff --git a/src/strconv/eisel_lemire.go b/src/strconv/eisel_lemire.go
index 6c7f852eba..fecd1b9345 100644
--- a/src/strconv/eisel_lemire.go
+++ b/src/strconv/eisel_lemire.go
@@ -29,7 +29,7 @@ func eiselLemire64(man uint64, exp10 int, neg bool) (f float64, ok bool) {
 	// Exp10 Range.
 	if man == 0 {
 		if neg {
-			f = math.Float64frombits(0x80000000_00000000) // Negative zero.
+			f = math.Float64frombits(0x8000000000000000) // Negative zero.
 		}
 		return f, true
 	}
@@ -39,7 +39,7 @@ func eiselLemire64(man uint64, exp10 int, neg bool) (f float64, ok bool) {
 
 	// Normalization.
 	clz := bits.LeadingZeros64(man)
-	man <<= clz
+	man <<= uint(clz)
 	const float64ExponentBias = 1023
 	retExp2 := uint64(217706*exp10>>16+64+float64ExponentBias) - uint64(clz)
 
@@ -84,9 +84,9 @@ func eiselLemire64(man uint64, exp10 int, neg bool) (f float64, ok bool) {
 	if retExp2-1 >= 0x7FF-1 {
 		return 0, false
 	}
-	retBits := retExp2<<52 | retMantissa&0x000FFFFF_FFFFFFFF
+	retBits := retExp2<<52 | retMantissa&0x000FFFFFFFFFFFFF
 	if neg {
-		retBits |= 0x80000000_00000000
+		retBits |= 0x8000000000000000
 	}
 	return math.Float64frombits(retBits), true
 }
@@ -114,7 +114,7 @@ func eiselLemire32(man uint64, exp10 int, neg bool) (f float32, ok bool) {
 
 	// Normalization.
 	clz := bits.LeadingZeros64(man)
-	man <<= clz
+	man <<= uint(clz)
 	const float32ExponentBias = 127
 	retExp2 := uint64(217706*exp10>>16+64+float32ExponentBias) - uint64(clz)
 
@@ -122,13 +122,13 @@ func eiselLemire32(man uint64, exp10 int, neg bool) (f float32, ok bool) {
 	xHi, xLo := bits.Mul64(man, detailedPowersOfTen[exp10-detailedPowersOfTenMinExp10][1])
 
 	// Wider Approximation.
-	if xHi&0x3F_FFFFFFFF == 0x3F_FFFFFFFF && xLo+man < man {
+	if xHi&0x3FFFFFFFFF == 0x3FFFFFFFFF && xLo+man < man {
 		yHi, yLo := bits.Mul64(man, detailedPowersOfTen[exp10-detailedPowersOfTenMinExp10][0])
 		mergedHi, mergedLo := xHi, xLo+yHi
 		if mergedLo < xLo {
 			mergedHi++
 		}
-		if mergedHi&0x3F_FFFFFFFF == 0x3F_FFFFFFFF && mergedLo+1 == 0 && yLo+man < man {
+		if mergedHi&0x3FFFFFFFFF == 0x3FFFFFFFFF && mergedLo+1 == 0 && yLo+man < man {
 			return 0, false
 		}
 		xHi, xLo = mergedHi, mergedLo
@@ -140,7 +140,7 @@ func eiselLemire32(man uint64, exp10 int, neg bool) (f float32, ok bool) {
 	retExp2 -= 1 ^ msb
 
 	// Half-way Ambiguity.
-	if xLo == 0 && xHi&0x3F_FFFFFFFF == 0 && retMantissa&3 == 1 {
+	if xLo == 0 && xHi&0x3FFFFFFFFF == 0 && retMantissa&3 == 1 {
 		return 0, false
 	}
 
diff --git a/src/strconv/quote.go b/src/strconv/quote.go
index bcbdbc514d..4ffa10b72e 100644
--- a/src/strconv/quote.go
+++ b/src/strconv/quote.go
@@ -7,7 +7,6 @@
 package strconv
 
 import (
-	"internal/bytealg"
 	"unicode/utf8"
 )
 
@@ -436,11 +435,6 @@ func Unquote(s string) (string, error) {
 	return string(buf), nil
 }
 
-// contains reports whether the string contains the byte c.
-func contains(s string, c byte) bool {
-	return bytealg.IndexByteString(s, c) != -1
-}
-
 // bsearch16 returns the smallest i such that a[i] >= x.
 // If there is no such i, bsearch16 returns len(a).
 func bsearch16(a []uint16, x uint16) int {
-- 
GitLab


From b56762129e97b15587c15d85e18e2d719528657a Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 17 Nov 2020 11:06:53 -0500
Subject: [PATCH 0046/2400] [dev.typeparams] import go2go changes to parse type
 parameters

This CL imports changes on the go2go branch to support parsing type
params, as well as the unsubmitted changes from CL 269300 to remove
support for parenthesize type parameter syntax.

Change-Id: I27ab942ce69eab62c2a1800f8f9661c4dcb233fe
Reviewed-on: https://go-review.googlesource.com/c/go/+/270857
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Trust: Robert Findley <rfindley@google.com>
---
 src/go/parser/error_test.go        |  14 +-
 src/go/parser/interface.go         |   1 +
 src/go/parser/parser.go            | 764 ++++++++++++++++++++---------
 src/go/parser/short_test.go        | 122 ++++-
 src/go/parser/testdata/chans.go2   |  62 +++
 src/go/parser/testdata/linalg.go2  |  83 ++++
 src/go/parser/testdata/map.go2     | 109 ++++
 src/go/parser/testdata/metrics.go2 |  58 +++
 src/go/parser/testdata/set.go2     |  31 ++
 src/go/parser/testdata/slices.go2  |  31 ++
 src/go/parser/testdata/sort.go2    |  27 +
 src/go/types/testdata/issues.src   |   4 +-
 12 files changed, 1063 insertions(+), 243 deletions(-)
 create mode 100644 src/go/parser/testdata/chans.go2
 create mode 100644 src/go/parser/testdata/linalg.go2
 create mode 100644 src/go/parser/testdata/map.go2
 create mode 100644 src/go/parser/testdata/metrics.go2
 create mode 100644 src/go/parser/testdata/set.go2
 create mode 100644 src/go/parser/testdata/slices.go2
 create mode 100644 src/go/parser/testdata/sort.go2

diff --git a/src/go/parser/error_test.go b/src/go/parser/error_test.go
index 9b79097acf..ed9e9473da 100644
--- a/src/go/parser/error_test.go
+++ b/src/go/parser/error_test.go
@@ -114,6 +114,7 @@ func expectedErrors(fset *token.FileSet, filename string, src []byte) map[token.
 // of found errors and reports discrepancies.
 //
 func compareErrors(t *testing.T, fset *token.FileSet, expected map[token.Pos]string, found scanner.ErrorList) {
+	t.Helper()
 	for _, error := range found {
 		// error.Pos is a token.Position, but we want
 		// a token.Pos so we can do a map lookup
@@ -149,7 +150,8 @@ func compareErrors(t *testing.T, fset *token.FileSet, expected map[token.Pos]str
 	}
 }
 
-func checkErrors(t *testing.T, filename string, input interface{}) {
+func checkErrors(t *testing.T, filename string, input interface{}, mode Mode) {
+	t.Helper()
 	src, err := readSource(filename, input)
 	if err != nil {
 		t.Error(err)
@@ -157,7 +159,7 @@ func checkErrors(t *testing.T, filename string, input interface{}) {
 	}
 
 	fset := token.NewFileSet()
-	_, err = ParseFile(fset, filename, src, DeclarationErrors|AllErrors)
+	_, err = ParseFile(fset, filename, src, mode)
 	found, ok := err.(scanner.ErrorList)
 	if err != nil && !ok {
 		t.Error(err)
@@ -180,8 +182,12 @@ func TestErrors(t *testing.T) {
 	}
 	for _, fi := range list {
 		name := fi.Name()
-		if !fi.IsDir() && !strings.HasPrefix(name, ".") && strings.HasSuffix(name, ".src") {
-			checkErrors(t, filepath.Join(testdata, name), nil)
+		if !fi.IsDir() && !strings.HasPrefix(name, ".") && (strings.HasSuffix(name, ".src") || strings.HasSuffix(name, ".go2")) {
+			mode := DeclarationErrors | AllErrors
+			if strings.HasSuffix(name, ".go2") {
+				mode |= ParseTypeParams
+			}
+			checkErrors(t, filepath.Join(testdata, name), nil, mode)
 		}
 	}
 }
diff --git a/src/go/parser/interface.go b/src/go/parser/interface.go
index cc7e455c4d..1c9a1acd66 100644
--- a/src/go/parser/interface.go
+++ b/src/go/parser/interface.go
@@ -55,6 +55,7 @@ const (
 	Trace                                          // print a trace of parsed productions
 	DeclarationErrors                              // report declaration errors
 	SpuriousErrors                                 // same as AllErrors, for backward-compatibility
+	ParseTypeParams                                // Placeholder. Will control the parsing of type parameters.
 	AllErrors         = SpuriousErrors             // report all errors (not just the first 10 on different lines)
 )
 
diff --git a/src/go/parser/parser.go b/src/go/parser/parser.go
index 31a73985bf..6d92373c33 100644
--- a/src/go/parser/parser.go
+++ b/src/go/parser/parser.go
@@ -34,7 +34,7 @@ type parser struct {
 
 	// Tracing/debugging
 	mode   Mode // parsing mode
-	trace  bool // == (mode & Trace != 0)
+	trace  bool // == (mode&Trace != 0)
 	indent int  // indentation used for tracing output
 
 	// Comments
@@ -181,7 +181,7 @@ func (p *parser) tryResolve(x ast.Expr, collectUnresolved bool) {
 	if ident == nil {
 		return
 	}
-	assert(ident.Obj == nil, "identifier already declared or resolved")
+	assert(ident.Obj == nil, fmt.Sprintf("identifier %s already declared or resolved", ident.Name))
 	if ident.Name == "_" {
 		return
 	}
@@ -352,6 +352,10 @@ func (p *parser) next() {
 type bailout struct{}
 
 func (p *parser) error(pos token.Pos, msg string) {
+	if p.trace {
+		defer un(trace(p, "error: "+msg))
+	}
+
 	epos := p.file.Position(pos)
 
 	// If AllErrors is not set, discard errors reported on the same line
@@ -594,9 +598,7 @@ func (p *parser) parseLhsList() []ast.Expr {
 	switch p.tok {
 	case token.DEFINE:
 		// lhs of a short variable declaration
-		// but doesn't enter scope until later:
-		// caller must call p.shortVarDecl(p.makeIdentList(list))
-		// at appropriate time.
+		// but doesn't enter scope until later.
 	case token.COLON:
 		// lhs of a label declaration or a communication clause of a select
 		// statement (parseLhsList is not called when parsing the case clause
@@ -643,14 +645,29 @@ func (p *parser) parseType() ast.Expr {
 	return typ
 }
 
+func (p *parser) parseQualifiedIdent(ident *ast.Ident) ast.Expr {
+	if p.trace {
+		defer un(trace(p, "QualifiedIdent"))
+	}
+
+	typ := p.parseTypeName(ident)
+	if p.tok == token.LBRACK {
+		typ = p.parseTypeInstance(typ)
+	}
+
+	return typ
+}
+
 // If the result is an identifier, it is not resolved.
-func (p *parser) parseTypeName() ast.Expr {
+func (p *parser) parseTypeName(ident *ast.Ident) ast.Expr {
 	if p.trace {
 		defer un(trace(p, "TypeName"))
 	}
 
-	ident := p.parseIdent()
-	// don't resolve ident yet - it may be a parameter or field name
+	if ident == nil {
+		ident = p.parseIdent()
+		// don't resolve ident yet - it may be a parameter or field name
+	}
 
 	if p.tok == token.PERIOD {
 		// ident is a package name
@@ -663,12 +680,11 @@ func (p *parser) parseTypeName() ast.Expr {
 	return ident
 }
 
-func (p *parser) parseArrayType() ast.Expr {
+func (p *parser) parseArrayLen() ast.Expr {
 	if p.trace {
-		defer un(trace(p, "ArrayType"))
+		defer un(trace(p, "ArrayLen"))
 	}
 
-	lbrack := p.expect(token.LBRACK)
 	p.exprLev++
 	var len ast.Expr
 	// always permit ellipsis for more fault-tolerant parsing
@@ -679,26 +695,47 @@ func (p *parser) parseArrayType() ast.Expr {
 		len = p.parseRhs()
 	}
 	p.exprLev--
-	p.expect(token.RBRACK)
-	elt := p.parseType()
 
-	return &ast.ArrayType{Lbrack: lbrack, Len: len, Elt: elt}
+	return len
 }
 
-func (p *parser) makeIdentList(list []ast.Expr) []*ast.Ident {
-	idents := make([]*ast.Ident, len(list))
-	for i, x := range list {
-		ident, isIdent := x.(*ast.Ident)
-		if !isIdent {
-			if _, isBad := x.(*ast.BadExpr); !isBad {
-				// only report error if it's a new one
-				p.errorExpected(x.Pos(), "identifier")
-			}
-			ident = &ast.Ident{NamePos: x.Pos(), Name: "_"}
+func (p *parser) parseArrayFieldOrTypeInstance(x *ast.Ident) (*ast.Ident, ast.Expr) {
+	if p.trace {
+		defer un(trace(p, "ArrayFieldOrTypeInstance"))
+	}
+
+	// TODO(gri) Should we allow a trailing comma in a type argument
+	//           list such as T[P,]? (We do in parseTypeInstance).
+	lbrack := p.expect(token.LBRACK)
+	var args []ast.Expr
+	if p.tok != token.RBRACK {
+		p.exprLev++
+		args = append(args, p.parseRhsOrType())
+		for p.tok == token.COMMA {
+			p.next()
+			args = append(args, p.parseRhsOrType())
 		}
-		idents[i] = ident
+		p.exprLev--
+	}
+	rbrack := p.expect(token.RBRACK)
+
+	if len(args) == 0 {
+		// x []E
+		elt := p.parseType()
+		return x, &ast.ArrayType{Lbrack: lbrack, Elt: elt}
 	}
-	return idents
+
+	// x [P]E or x[P]
+	if len(args) == 1 {
+		elt := p.tryType()
+		if elt != nil {
+			// x [P]E
+			return x, &ast.ArrayType{Lbrack: lbrack, Len: args[0], Elt: elt}
+		}
+	}
+
+	// x[P], x[P1, P2], ...
+	return nil, &ast.CallExpr{Fun: x, Lparen: lbrack, Args: args, Rparen: rbrack, Brackets: true}
 }
 
 func (p *parser) parseFieldDecl(scope *ast.Scope) *ast.Field {
@@ -708,37 +745,44 @@ func (p *parser) parseFieldDecl(scope *ast.Scope) *ast.Field {
 
 	doc := p.leadComment
 
-	// 1st FieldDecl
-	// A type name used as an anonymous field looks like a field identifier.
-	var list []ast.Expr
-	for {
-		list = append(list, p.parseVarType(false))
-		if p.tok != token.COMMA {
-			break
+	var names []*ast.Ident
+	var typ ast.Expr
+	if p.tok == token.IDENT {
+		name := p.parseIdent()
+		if p.tok == token.PERIOD || p.tok == token.STRING || p.tok == token.SEMICOLON || p.tok == token.RBRACE {
+			// embedded type
+			typ = name
+			if p.tok == token.PERIOD {
+				typ = p.parseQualifiedIdent(name)
+			} else {
+				p.resolve(typ)
+			}
+		} else {
+			// name1, name2, ... T
+			names = []*ast.Ident{name}
+			for p.tok == token.COMMA {
+				p.next()
+				names = append(names, p.parseIdent())
+			}
+			// Careful dance: We don't know if we have an embedded instantiated
+			// type T[P1, P2, ...] or a field T of array type []E or [P]E.
+			if len(names) == 1 && p.tok == token.LBRACK {
+				name, typ = p.parseArrayFieldOrTypeInstance(name)
+				if name == nil {
+					names = nil
+				}
+			} else {
+				// T P
+				typ = p.parseType()
+			}
 		}
-		p.next()
-	}
-
-	typ := p.tryVarType(false)
-
-	// analyze case
-	var idents []*ast.Ident
-	if typ != nil {
-		// IdentifierList Type
-		idents = p.makeIdentList(list)
 	} else {
-		// ["*"] TypeName (AnonymousField)
-		typ = list[0] // we always have at least one element
-		if n := len(list); n > 1 {
-			p.errorExpected(p.pos, "type")
-			typ = &ast.BadExpr{From: p.pos, To: p.pos}
-		} else if !isTypeName(deref(typ)) {
-			p.errorExpected(typ.Pos(), "anonymous field")
-			typ = &ast.BadExpr{From: typ.Pos(), To: p.safePos(typ.End())}
-		}
+		// embedded, possibly generic type
+		// (using the enclosing parentheses to distinguish it from a named field declaration)
+		// TODO(gri) confirm that this doesn't allow parenthesized embedded type
+		typ = p.parseType()
 	}
 
-	// Tag
 	var tag *ast.BasicLit
 	if p.tok == token.STRING {
 		tag = &ast.BasicLit{ValuePos: p.pos, Kind: p.tok, Value: p.lit}
@@ -747,10 +791,8 @@ func (p *parser) parseFieldDecl(scope *ast.Scope) *ast.Field {
 
 	p.expectSemi() // call before accessing p.linecomment
 
-	field := &ast.Field{Doc: doc, Names: idents, Type: typ, Tag: tag, Comment: p.lineComment}
-	p.declare(field, nil, scope, ast.Var, idents...)
-	p.resolve(typ)
-
+	field := &ast.Field{Doc: doc, Names: names, Type: typ, Tag: tag, Comment: p.lineComment}
+	p.declare(field, nil, scope, ast.Var, names...)
 	return field
 }
 
@@ -792,107 +834,222 @@ func (p *parser) parsePointerType() *ast.StarExpr {
 	return &ast.StarExpr{Star: star, X: base}
 }
 
-// If the result is an identifier, it is not resolved.
-func (p *parser) tryVarType(isParam bool) ast.Expr {
-	if isParam && p.tok == token.ELLIPSIS {
-		pos := p.pos
-		p.next()
-		typ := p.tryIdentOrType() // don't use parseType so we can provide better error message
-		if typ != nil {
-			p.resolve(typ)
-		} else {
-			p.error(pos, "'...' parameter is missing type")
-			typ = &ast.BadExpr{From: pos, To: p.pos}
-		}
-		return &ast.Ellipsis{Ellipsis: pos, Elt: typ}
+func (p *parser) parseDotsType() *ast.Ellipsis {
+	if p.trace {
+		defer un(trace(p, "DotsType"))
 	}
-	return p.tryIdentOrType()
+
+	pos := p.expect(token.ELLIPSIS)
+	elt := p.parseType()
+
+	return &ast.Ellipsis{Ellipsis: pos, Elt: elt}
 }
 
-// If the result is an identifier, it is not resolved.
-func (p *parser) parseVarType(isParam bool) ast.Expr {
-	typ := p.tryVarType(isParam)
-	if typ == nil {
-		pos := p.pos
-		p.errorExpected(pos, "type")
-		p.next() // make progress
-		typ = &ast.BadExpr{From: pos, To: p.pos}
+type field struct {
+	name *ast.Ident
+	typ  ast.Expr
+}
+
+func (p *parser) parseParamDecl(name *ast.Ident) (f field) {
+	if p.trace {
+		defer un(trace(p, "ParamDeclOrNil"))
 	}
-	return typ
+
+	ptok := p.tok
+	if name != nil {
+		p.tok = token.IDENT // force token.IDENT case in switch below
+	}
+
+	switch p.tok {
+	case token.IDENT:
+		if name != nil {
+			f.name = name
+			p.tok = ptok
+		} else {
+			f.name = p.parseIdent()
+		}
+		switch p.tok {
+		case token.IDENT, token.MUL, token.ARROW, token.FUNC, token.CHAN, token.MAP, token.STRUCT, token.INTERFACE, token.LPAREN:
+			// name type
+			f.typ = p.parseType()
+
+		case token.LBRACK:
+			// name[type1, type2, ...] or name []type or name [len]type
+			f.name, f.typ = p.parseArrayFieldOrTypeInstance(f.name)
+
+		case token.ELLIPSIS:
+			// name ...type
+			f.typ = p.parseDotsType()
+
+		case token.PERIOD:
+			// qualified.typename
+			f.typ = p.parseQualifiedIdent(f.name)
+			f.name = nil
+		}
+
+	case token.MUL, token.ARROW, token.FUNC, token.LBRACK, token.CHAN, token.MAP, token.STRUCT, token.INTERFACE, token.LPAREN:
+		// type
+		f.typ = p.parseType()
+
+	case token.ELLIPSIS:
+		// ...type
+		// (always accepted)
+		f.typ = p.parseDotsType()
+
+	default:
+		p.errorExpected(p.pos, ")")
+		p.advance(exprEnd)
+	}
+
+	return
 }
 
-func (p *parser) parseParameterList(scope *ast.Scope, ellipsisOk bool) (params []*ast.Field) {
+func (p *parser) parseParameterList(scope *ast.Scope, name0 *ast.Ident, closing token.Token, parseParamDecl func(*ast.Ident) field, tparams bool) (params []*ast.Field) {
 	if p.trace {
 		defer un(trace(p, "ParameterList"))
 	}
 
-	// 1st ParameterDecl
-	// A list of identifiers looks like a list of type names.
-	var list []ast.Expr
-	for {
-		list = append(list, p.parseVarType(ellipsisOk))
-		if p.tok != token.COMMA {
-			break
+	pos := p.pos
+	if name0 != nil {
+		pos = name0.Pos()
+	}
+
+	var list []field
+	var named int // number of parameters that have an explicit name and type
+
+	for name0 != nil || p.tok != closing && p.tok != token.EOF {
+		par := parseParamDecl(name0)
+		name0 = nil // 1st name was consumed if present
+		if par.name != nil || par.typ != nil {
+			list = append(list, par)
+			if par.name != nil && par.typ != nil {
+				named++
+			}
 		}
-		p.next()
-		if p.tok == token.RPAREN {
+		if !p.atComma("parameter list", closing) {
 			break
 		}
+		p.next()
 	}
 
-	// analyze case
-	if typ := p.tryVarType(ellipsisOk); typ != nil {
-		// IdentifierList Type
-		idents := p.makeIdentList(list)
-		field := &ast.Field{Names: idents, Type: typ}
-		params = append(params, field)
-		// Go spec: The scope of an identifier denoting a function
-		// parameter or result variable is the function body.
-		p.declare(field, nil, scope, ast.Var, idents...)
-		p.resolve(typ)
-		if !p.atComma("parameter list", token.RPAREN) {
-			return
+	if len(list) == 0 {
+		return // not uncommon
+	}
+
+	// TODO(gri) parameter distribution and conversion to []*ast.Field
+	//           can be combined and made more efficient
+
+	// distribute parameter types
+	if named == 0 {
+		// all unnamed => found names are type names
+		for i := 0; i < len(list); i++ {
+			par := &list[i]
+			if typ := par.name; typ != nil {
+				p.resolve(typ)
+				par.typ = typ
+				par.name = nil
+			}
 		}
-		p.next()
-		for p.tok != token.RPAREN && p.tok != token.EOF {
-			idents := p.parseIdentList()
-			typ := p.parseVarType(ellipsisOk)
-			field := &ast.Field{Names: idents, Type: typ}
-			params = append(params, field)
-			// Go spec: The scope of an identifier denoting a function
-			// parameter or result variable is the function body.
-			p.declare(field, nil, scope, ast.Var, idents...)
-			p.resolve(typ)
-			if !p.atComma("parameter list", token.RPAREN) {
-				break
+		if tparams {
+			p.error(pos, "all type parameters must be named")
+		}
+	} else if named != len(list) {
+		// some named => all must be named
+		ok := true
+		var typ ast.Expr
+		for i := len(list) - 1; i >= 0; i-- {
+			if par := &list[i]; par.typ != nil {
+				typ = par.typ
+				if par.name == nil {
+					ok = false
+					n := ast.NewIdent("_")
+					n.NamePos = typ.Pos() // correct position
+					par.name = n
+				}
+			} else if typ != nil {
+				par.typ = typ
+			} else {
+				// par.typ == nil && typ == nil => we only have a par.name
+				ok = false
+				par.typ = &ast.BadExpr{From: par.name.Pos(), To: p.pos}
+			}
+		}
+		if !ok {
+			if tparams {
+				p.error(pos, "all type parameters must be named")
+			} else {
+				p.error(pos, "mixed named and unnamed parameters")
 			}
-			p.next()
+		}
+	}
+
+	// convert list []*ast.Field
+	if named == 0 {
+		// parameter list consists of types only
+		for _, par := range list {
+			assert(par.typ != nil, "nil type in unnamed parameter list")
+			params = append(params, &ast.Field{Type: par.typ})
 		}
 		return
 	}
 
-	// Type { "," Type } (anonymous parameters)
-	params = make([]*ast.Field, len(list))
-	for i, typ := range list {
-		p.resolve(typ)
-		params[i] = &ast.Field{Type: typ}
+	// parameter list consists of named parameters with types
+	var names []*ast.Ident
+	var typ ast.Expr
+	addParams := func() {
+		assert(typ != nil, "nil type in named parameter list")
+		field := &ast.Field{Names: names, Type: typ}
+		// Go spec: The scope of an identifier denoting a function
+		// parameter or result variable is the function body.
+		p.declare(field, nil, scope, ast.Var, names...)
+		params = append(params, field)
+		names = nil
+	}
+	for _, par := range list {
+		if par.typ != typ {
+			if len(names) > 0 {
+				addParams()
+			}
+			typ = par.typ
+		}
+		names = append(names, par.name)
+	}
+	if len(names) > 0 {
+		addParams()
 	}
 	return
 }
 
-func (p *parser) parseParameters(scope *ast.Scope, ellipsisOk bool) *ast.FieldList {
+func (p *parser) parseParameters(scope *ast.Scope, acceptTParams bool) (tparams, params *ast.FieldList) {
 	if p.trace {
 		defer un(trace(p, "Parameters"))
 	}
 
-	var params []*ast.Field
-	lparen := p.expect(token.LPAREN)
+	if acceptTParams && p.tok == token.LBRACK {
+		opening := p.pos
+		p.next()
+		// [T any](params) syntax
+		list := p.parseParameterList(scope, nil, token.RBRACK, p.parseParamDecl, true)
+		rbrack := p.expect(token.RBRACK)
+		tparams = &ast.FieldList{Opening: opening, List: list, Closing: rbrack}
+		// Type parameter lists must not be empty.
+		if tparams != nil && tparams.NumFields() == 0 {
+			p.error(tparams.Closing, "empty type parameter list")
+			tparams = nil // avoid follow-on errors
+		}
+	}
+
+	opening := p.expect(token.LPAREN)
+
+	var fields []*ast.Field
 	if p.tok != token.RPAREN {
-		params = p.parseParameterList(scope, ellipsisOk)
+		fields = p.parseParameterList(scope, nil, token.RPAREN, p.parseParamDecl, false)
 	}
+
 	rparen := p.expect(token.RPAREN)
+	params = &ast.FieldList{Opening: opening, List: fields, Closing: rparen}
 
-	return &ast.FieldList{Opening: lparen, List: params, Closing: rparen}
+	return
 }
 
 func (p *parser) parseResult(scope *ast.Scope) *ast.FieldList {
@@ -901,7 +1058,8 @@ func (p *parser) parseResult(scope *ast.Scope) *ast.FieldList {
 	}
 
 	if p.tok == token.LPAREN {
-		return p.parseParameters(scope, false)
+		_, results := p.parseParameters(scope, false)
+		return results
 	}
 
 	typ := p.tryType()
@@ -914,17 +1072,6 @@ func (p *parser) parseResult(scope *ast.Scope) *ast.FieldList {
 	return nil
 }
 
-func (p *parser) parseSignature(scope *ast.Scope) (params, results *ast.FieldList) {
-	if p.trace {
-		defer un(trace(p, "Signature"))
-	}
-
-	params = p.parseParameters(scope, true)
-	results = p.parseResult(scope)
-
-	return
-}
-
 func (p *parser) parseFuncType() (*ast.FuncType, *ast.Scope) {
 	if p.trace {
 		defer un(trace(p, "FuncType"))
@@ -932,7 +1079,11 @@ func (p *parser) parseFuncType() (*ast.FuncType, *ast.Scope) {
 
 	pos := p.expect(token.FUNC)
 	scope := ast.NewScope(p.topScope) // function scope
-	params, results := p.parseSignature(scope)
+	tparams, params := p.parseParameters(scope, true)
+	if tparams != nil {
+		p.error(tparams.Pos(), "function type cannot have type parameters")
+	}
+	results := p.parseResult(scope)
 
 	return &ast.FuncType{Func: pos, Params: params, Results: results}, scope
 }
@@ -945,17 +1096,65 @@ func (p *parser) parseMethodSpec(scope *ast.Scope) *ast.Field {
 	doc := p.leadComment
 	var idents []*ast.Ident
 	var typ ast.Expr
-	x := p.parseTypeName()
-	if ident, isIdent := x.(*ast.Ident); isIdent && p.tok == token.LPAREN {
-		// method
-		idents = []*ast.Ident{ident}
-		scope := ast.NewScope(nil) // method scope
-		params, results := p.parseSignature(scope)
-		typ = &ast.FuncType{Func: token.NoPos, Params: params, Results: results}
+	x := p.parseTypeName(nil)
+	if ident, _ := x.(*ast.Ident); ident != nil {
+		switch p.tok {
+		case token.LBRACK:
+			// generic method or embedded instantiated type
+			lbrack := p.pos
+			p.next()
+			p.exprLev++
+			x := p.parseExpr(true) // we don't know yet if we're a lhs or rhs expr
+			p.exprLev--
+			if name0, _ := x.(*ast.Ident); name0 != nil && p.tok != token.COMMA && p.tok != token.RBRACK {
+				// generic method m[T any]
+				scope := ast.NewScope(nil) // method scope
+				list := p.parseParameterList(scope, name0, token.RBRACK, p.parseParamDecl, true)
+				rbrack := p.expect(token.RBRACK)
+				tparams := &ast.FieldList{Opening: lbrack, List: list, Closing: rbrack}
+				// TODO(rfindley) refactor to share code with parseFuncType.
+				_, params := p.parseParameters(scope, false)
+				results := p.parseResult(scope)
+				idents = []*ast.Ident{ident}
+				typ = &ast.FuncType{Func: token.NoPos, TParams: tparams, Params: params, Results: results}
+			} else {
+				// embedded instantiated type
+				// TODO(rfindley) should resolve all identifiers in x.
+				list := []ast.Expr{x}
+				if p.atComma("type argument list", token.RBRACK) {
+					p.exprLev++
+					for p.tok != token.RBRACK && p.tok != token.EOF {
+						list = append(list, p.parseType())
+						if !p.atComma("type argument list", token.RBRACK) {
+							break
+						}
+						p.next()
+					}
+					p.exprLev--
+				}
+				rbrack := p.expectClosing(token.RBRACK, "type argument list")
+				typ = &ast.CallExpr{Fun: ident, Lparen: lbrack, Args: list, Rparen: rbrack, Brackets: true}
+			}
+		case token.LPAREN:
+			// ordinary method
+			// TODO(rfindley) refactor to share code with parseFuncType.
+			scope := ast.NewScope(nil) // method scope
+			_, params := p.parseParameters(scope, false)
+			results := p.parseResult(scope)
+			idents = []*ast.Ident{ident}
+			typ = &ast.FuncType{Func: token.NoPos, Params: params, Results: results}
+		default:
+			// embedded type
+			typ = x
+			p.resolve(typ)
+		}
 	} else {
-		// embedded interface
+		// embedded, possibly instantiated type
 		typ = x
-		p.resolve(typ)
+		if p.tok == token.LBRACK {
+			// embedded instantiated interface
+			typ = p.parseTypeInstance(typ)
+		}
 	}
 	p.expectSemi() // call before accessing p.linecomment
 
@@ -974,8 +1173,24 @@ func (p *parser) parseInterfaceType() *ast.InterfaceType {
 	lbrace := p.expect(token.LBRACE)
 	scope := ast.NewScope(nil) // interface scope
 	var list []*ast.Field
-	for p.tok == token.IDENT {
-		list = append(list, p.parseMethodSpec(scope))
+L:
+	for {
+		switch p.tok {
+		case token.IDENT, token.LPAREN:
+			list = append(list, p.parseMethodSpec(scope))
+		case token.TYPE:
+			// all types in a type list share the same field name "type"
+			// (since type is a keyword, a Go program cannot have that field name)
+			name := []*ast.Ident{{NamePos: p.pos, Name: "type"}}
+			p.next()
+			// add each type as a field named "type"
+			for _, typ := range p.parseTypeList() {
+				list = append(list, &ast.Field{Names: name, Type: typ})
+			}
+			p.expectSemi()
+		default:
+			break L
+		}
 	}
 	rbrace := p.expect(token.RBRACE)
 
@@ -1028,13 +1243,44 @@ func (p *parser) parseChanType() *ast.ChanType {
 	return &ast.ChanType{Begin: pos, Arrow: arrow, Dir: dir, Value: value}
 }
 
+func (p *parser) parseTypeInstance(typ ast.Expr) ast.Expr {
+	if p.trace {
+		defer un(trace(p, "TypeInstance"))
+	}
+
+	opening := p.expect(token.LBRACK)
+
+	p.exprLev++
+	var list []ast.Expr
+	for p.tok != token.RBRACK && p.tok != token.EOF {
+		list = append(list, p.parseType())
+		if !p.atComma("type argument list", token.RBRACK) {
+			break
+		}
+		p.next()
+	}
+	p.exprLev--
+
+	closing := p.expectClosing(token.RBRACK, "type argument list")
+
+	return &ast.CallExpr{Fun: typ, Lparen: opening, Args: list, Rparen: closing, Brackets: true}
+}
+
 // If the result is an identifier, it is not resolved.
 func (p *parser) tryIdentOrType() ast.Expr {
 	switch p.tok {
 	case token.IDENT:
-		return p.parseTypeName()
+		typ := p.parseTypeName(nil)
+		if p.tok == token.LBRACK {
+			typ = p.parseTypeInstance(typ)
+		}
+		return typ
 	case token.LBRACK:
-		return p.parseArrayType()
+		lbrack := p.expect(token.LBRACK)
+		alen := p.parseArrayLen()
+		p.expect(token.RBRACK)
+		elt := p.parseType()
+		return &ast.ArrayType{Lbrack: lbrack, Len: alen, Elt: elt}
 	case token.STRUCT:
 		return p.parseStructType()
 	case token.MUL:
@@ -1169,7 +1415,7 @@ func (p *parser) parseOperand(lhs bool) ast.Expr {
 		return p.parseFuncTypeOrLit()
 	}
 
-	if typ := p.tryIdentOrType(); typ != nil {
+	if typ := p.tryIdentOrType(); typ != nil { // do not consume trailing type parameters
 		// could be type for composite literal or conversion
 		_, isIdent := typ.(*ast.Ident)
 		assert(!isIdent, "type cannot be identifier")
@@ -1211,28 +1457,53 @@ func (p *parser) parseTypeAssertion(x ast.Expr) ast.Expr {
 	return &ast.TypeAssertExpr{X: x, Type: typ, Lparen: lparen, Rparen: rparen}
 }
 
-func (p *parser) parseIndexOrSlice(x ast.Expr) ast.Expr {
+func (p *parser) parseIndexOrSliceOrInstance(x ast.Expr) ast.Expr {
 	if p.trace {
-		defer un(trace(p, "IndexOrSlice"))
+		defer un(trace(p, "parseIndexOrSliceOrInstance"))
 	}
 
-	const N = 3 // change the 3 to 2 to disable 3-index slices
 	lbrack := p.expect(token.LBRACK)
+	if p.tok == token.RBRACK {
+		// empty index, slice or index expressions are not permitted;
+		// accept them for parsing tolerance, but complain
+		p.errorExpected(p.pos, "operand")
+		p.next()
+		return x
+	}
 	p.exprLev++
+
+	const N = 3 // change the 3 to 2 to disable 3-index slices
+	var args []ast.Expr
 	var index [N]ast.Expr
 	var colons [N - 1]token.Pos
 	if p.tok != token.COLON {
-		index[0] = p.parseRhs()
+		// We can't know if we have an index expression or a type instantiation;
+		// so even if we see a (named) type we are not going to be in type context.
+		index[0] = p.parseRhsOrType()
 	}
 	ncolons := 0
-	for p.tok == token.COLON && ncolons < len(colons) {
-		colons[ncolons] = p.pos
-		ncolons++
-		p.next()
-		if p.tok != token.COLON && p.tok != token.RBRACK && p.tok != token.EOF {
-			index[ncolons] = p.parseRhs()
+	switch p.tok {
+	case token.COLON:
+		// slice expression
+		for p.tok == token.COLON && ncolons < len(colons) {
+			colons[ncolons] = p.pos
+			ncolons++
+			p.next()
+			if p.tok != token.COLON && p.tok != token.RBRACK && p.tok != token.EOF {
+				index[ncolons] = p.parseRhs()
+			}
+		}
+	case token.COMMA:
+		// instance expression
+		args = append(args, index[0])
+		for p.tok == token.COMMA {
+			p.next()
+			if p.tok != token.RBRACK && p.tok != token.EOF {
+				args = append(args, p.parseType())
+			}
 		}
 	}
+
 	p.exprLev--
 	rbrack := p.expect(token.RBRACK)
 
@@ -1255,7 +1526,13 @@ func (p *parser) parseIndexOrSlice(x ast.Expr) ast.Expr {
 		return &ast.SliceExpr{X: x, Lbrack: lbrack, Low: index[0], High: index[1], Max: index[2], Slice3: slice3, Rbrack: rbrack}
 	}
 
-	return &ast.IndexExpr{X: x, Lbrack: lbrack, Index: index[0], Rbrack: rbrack}
+	if len(args) == 0 {
+		// index expression
+		return &ast.IndexExpr{X: x, Lbrack: lbrack, Index: index[0], Rbrack: rbrack}
+	}
+
+	// instance expression
+	return &ast.CallExpr{Fun: x, Lparen: lbrack, Args: args, Rparen: rbrack, Brackets: true}
 }
 
 func (p *parser) parseCallOrConversion(fun ast.Expr) *ast.CallExpr {
@@ -1404,45 +1681,6 @@ func (p *parser) checkExpr(x ast.Expr) ast.Expr {
 	return x
 }
 
-// isTypeName reports whether x is a (qualified) TypeName.
-func isTypeName(x ast.Expr) bool {
-	switch t := x.(type) {
-	case *ast.BadExpr:
-	case *ast.Ident:
-	case *ast.SelectorExpr:
-		_, isIdent := t.X.(*ast.Ident)
-		return isIdent
-	default:
-		return false // all other nodes are not type names
-	}
-	return true
-}
-
-// isLiteralType reports whether x is a legal composite literal type.
-func isLiteralType(x ast.Expr) bool {
-	switch t := x.(type) {
-	case *ast.BadExpr:
-	case *ast.Ident:
-	case *ast.SelectorExpr:
-		_, isIdent := t.X.(*ast.Ident)
-		return isIdent
-	case *ast.ArrayType:
-	case *ast.StructType:
-	case *ast.MapType:
-	default:
-		return false // all other nodes are not legal composite literal types
-	}
-	return true
-}
-
-// If x is of the form *T, deref returns T, otherwise it returns x.
-func deref(x ast.Expr) ast.Expr {
-	if p, isPtr := x.(*ast.StarExpr); isPtr {
-		x = p.X
-	}
-	return x
-}
-
 // If x is of the form (T), unparen returns unparen(T), otherwise it returns x.
 func unparen(x ast.Expr) ast.Expr {
 	if p, isParen := x.(*ast.ParenExpr); isParen {
@@ -1470,13 +1708,12 @@ func (p *parser) checkExprOrType(x ast.Expr) ast.Expr {
 }
 
 // If lhs is set and the result is an identifier, it is not resolved.
-func (p *parser) parsePrimaryExpr(lhs bool) ast.Expr {
+func (p *parser) parsePrimaryExpr(lhs bool) (x ast.Expr) {
 	if p.trace {
 		defer un(trace(p, "PrimaryExpr"))
 	}
 
-	x := p.parseOperand(lhs)
-L:
+	x = p.parseOperand(lhs)
 	for {
 		switch p.tok {
 		case token.PERIOD:
@@ -1500,28 +1737,48 @@ L:
 			if lhs {
 				p.resolve(x)
 			}
-			x = p.parseIndexOrSlice(p.checkExpr(x))
+			x = p.parseIndexOrSliceOrInstance(p.checkExpr(x))
 		case token.LPAREN:
 			if lhs {
 				p.resolve(x)
 			}
 			x = p.parseCallOrConversion(p.checkExprOrType(x))
 		case token.LBRACE:
-			if isLiteralType(x) && (p.exprLev >= 0 || !isTypeName(x)) {
-				if lhs {
-					p.resolve(x)
+			// operand may have returned a parenthesized complit
+			// type; accept it but complain if we have a complit
+			t := unparen(x)
+			// determine if '{' belongs to a composite literal or a block statement
+			switch t := t.(type) {
+			case *ast.BadExpr, *ast.Ident, *ast.SelectorExpr:
+				if p.exprLev < 0 {
+					return
 				}
-				x = p.parseLiteralValue(x)
-			} else {
-				break L
+				// x is possibly a composite literal type
+			case *ast.CallExpr:
+				if !t.Brackets || p.exprLev < 0 {
+					return
+				}
+				// x is possibly a composite literal type
+			case *ast.IndexExpr:
+				if p.exprLev < 0 {
+					return
+				}
+				// x is possibly a composite literal type
+			case *ast.ArrayType, *ast.StructType, *ast.MapType:
+				// x is a composite literal type
+			default:
+				return
+			}
+			if t != x {
+				p.error(t.Pos(), "cannot parenthesize type in composite literal")
+				// already progressed, no need to advance
 			}
+			x = p.parseLiteralValue(x)
 		default:
-			break L
+			return
 		}
 		lhs = false // no need to try to resolve again
 	}
-
-	return x
 }
 
 // If lhs is set and the result is an identifier, it is not resolved.
@@ -1846,14 +2103,14 @@ func (p *parser) parseIfHeader() (init ast.Stmt, cond ast.Expr) {
 	}
 	// p.tok != token.LBRACE
 
-	outer := p.exprLev
+	prevLev := p.exprLev
 	p.exprLev = -1
 
 	if p.tok != token.SEMICOLON {
 		// accept potential variable declaration but complain
 		if p.tok == token.VAR {
 			p.next()
-			p.error(p.pos, fmt.Sprintf("var declaration not allowed in 'IF' initializer"))
+			p.error(p.pos, "var declaration not allowed in 'IF' initializer")
 		}
 		init, _ = p.parseSimpleStmt(basic)
 	}
@@ -1894,7 +2151,7 @@ func (p *parser) parseIfHeader() (init ast.Stmt, cond ast.Expr) {
 		cond = &ast.BadExpr{From: p.pos, To: p.pos}
 	}
 
-	p.exprLev = outer
+	p.exprLev = prevLev
 	return
 }
 
@@ -2275,7 +2532,7 @@ func (p *parser) parseStmt() (s ast.Stmt) {
 // ----------------------------------------------------------------------------
 // Declarations
 
-type parseSpecFunction func(doc *ast.CommentGroup, keyword token.Token, iota int) ast.Spec
+type parseSpecFunction func(doc *ast.CommentGroup, pos token.Pos, keyword token.Token, iota int) ast.Spec
 
 func isValidImport(lit string) bool {
 	const illegalChars = `!"#$%&'()*,:;<=>?[\]^{|}` + "`\uFFFD"
@@ -2288,7 +2545,7 @@ func isValidImport(lit string) bool {
 	return s != ""
 }
 
-func (p *parser) parseImportSpec(doc *ast.CommentGroup, _ token.Token, _ int) ast.Spec {
+func (p *parser) parseImportSpec(doc *ast.CommentGroup, _ token.Pos, _ token.Token, _ int) ast.Spec {
 	if p.trace {
 		defer un(trace(p, "ImportSpec"))
 	}
@@ -2327,7 +2584,7 @@ func (p *parser) parseImportSpec(doc *ast.CommentGroup, _ token.Token, _ int) as
 	return spec
 }
 
-func (p *parser) parseValueSpec(doc *ast.CommentGroup, keyword token.Token, iota int) ast.Spec {
+func (p *parser) parseValueSpec(doc *ast.CommentGroup, _ token.Pos, keyword token.Token, iota int) ast.Spec {
 	if p.trace {
 		defer un(trace(p, keyword.String()+"Spec"))
 	}
@@ -2374,7 +2631,21 @@ func (p *parser) parseValueSpec(doc *ast.CommentGroup, keyword token.Token, iota
 	return spec
 }
 
-func (p *parser) parseTypeSpec(doc *ast.CommentGroup, _ token.Token, _ int) ast.Spec {
+func (p *parser) parseGenericType(spec *ast.TypeSpec, openPos token.Pos, name0 *ast.Ident, closeTok token.Token) {
+	p.openScope()
+	list := p.parseParameterList(p.topScope, name0, closeTok, p.parseParamDecl, true)
+	closePos := p.expect(closeTok)
+	spec.TParams = &ast.FieldList{Opening: openPos, List: list, Closing: closePos}
+	// Type alias cannot have type parameters. Accept them for robustness but complain.
+	if p.tok == token.ASSIGN {
+		p.error(p.pos, "generic type cannot be alias")
+		p.next()
+	}
+	spec.Type = p.parseType()
+	p.closeScope()
+}
+
+func (p *parser) parseTypeSpec(doc *ast.CommentGroup, _ token.Pos, _ token.Token, _ int) ast.Spec {
 	if p.trace {
 		defer un(trace(p, "TypeSpec"))
 	}
@@ -2387,11 +2658,44 @@ func (p *parser) parseTypeSpec(doc *ast.CommentGroup, _ token.Token, _ int) ast.
 	// (Global identifiers are resolved in a separate phase after parsing.)
 	spec := &ast.TypeSpec{Doc: doc, Name: ident}
 	p.declare(spec, nil, p.topScope, ast.Typ, ident)
-	if p.tok == token.ASSIGN {
-		spec.Assign = p.pos
+
+	switch p.tok {
+	case token.LBRACK:
+		lbrack := p.pos
 		p.next()
+		if p.tok == token.IDENT {
+			// array type or generic type [T any]
+			p.exprLev++
+			x := p.parseExpr(true) // we don't know yet if we're a lhs or rhs expr
+			p.exprLev--
+			if name0, _ := x.(*ast.Ident); name0 != nil && p.tok != token.RBRACK {
+				// generic type [T any];
+				p.parseGenericType(spec, lbrack, name0, token.RBRACK)
+			} else {
+				// array type
+				// TODO(rfindley) should resolve all identifiers in x.
+				p.expect(token.RBRACK)
+				elt := p.parseType()
+				spec.Type = &ast.ArrayType{Lbrack: lbrack, Len: x, Elt: elt}
+			}
+		} else {
+			// array type
+			alen := p.parseArrayLen()
+			p.expect(token.RBRACK)
+			elt := p.parseType()
+			spec.Type = &ast.ArrayType{Lbrack: lbrack, Len: alen, Elt: elt}
+		}
+
+	default:
+		// no type parameters
+		if p.tok == token.ASSIGN {
+			// type alias
+			spec.Assign = p.pos
+			p.next()
+		}
+		spec.Type = p.parseType()
 	}
-	spec.Type = p.parseType()
+
 	p.expectSemi() // call before accessing p.linecomment
 	spec.Comment = p.lineComment
 
@@ -2411,12 +2715,12 @@ func (p *parser) parseGenDecl(keyword token.Token, f parseSpecFunction) *ast.Gen
 		lparen = p.pos
 		p.next()
 		for iota := 0; p.tok != token.RPAREN && p.tok != token.EOF; iota++ {
-			list = append(list, f(p.leadComment, keyword, iota))
+			list = append(list, f(p.leadComment, pos, keyword, iota))
 		}
 		rparen = p.expect(token.RPAREN)
 		p.expectSemi()
 	} else {
-		list = append(list, f(nil, keyword, 0))
+		list = append(list, f(nil, pos, keyword, 0))
 	}
 
 	return &ast.GenDecl{
@@ -2440,12 +2744,13 @@ func (p *parser) parseFuncDecl() *ast.FuncDecl {
 
 	var recv *ast.FieldList
 	if p.tok == token.LPAREN {
-		recv = p.parseParameters(scope, false)
+		_, recv = p.parseParameters(scope, false)
 	}
 
 	ident := p.parseIdent()
 
-	params, results := p.parseSignature(scope)
+	tparams, params := p.parseParameters(scope, true)
+	results := p.parseResult(scope)
 
 	var body *ast.BlockStmt
 	if p.tok == token.LBRACE {
@@ -2469,6 +2774,7 @@ func (p *parser) parseFuncDecl() *ast.FuncDecl {
 		Name: ident,
 		Type: &ast.FuncType{
 			Func:    pos,
+			TParams: tparams,
 			Params:  params,
 			Results: results,
 		},
diff --git a/src/go/parser/short_test.go b/src/go/parser/short_test.go
index 49bb681e09..46fa764466 100644
--- a/src/go/parser/short_test.go
+++ b/src/go/parser/short_test.go
@@ -48,14 +48,106 @@ var valids = []string{
 	`package p; var _ = map[*P]int{&P{}:0, {}:1}`,
 	`package p; type T = int`,
 	`package p; type (T = p.T; _ = struct{}; x = *T)`,
+	`package p; type T (*int)`,
+
+	// structs with parameterized embedded fields (for symmetry with interfaces)
+	`package p; type _ struct{ ((int)) }`,
+	`package p; type _ struct{ (*(int)) }`,
+	`package p; type _ struct{ ([]byte) }`, // disallowed by type-checker
+
+	// type parameters
+	`package p; type T[P any] struct { P }`,
+	`package p; type T[P comparable] struct { P }`,
+	`package p; type T[P comparable[P]] struct { P }`,
+	`package p; type T[P1, P2 any] struct { P1; f []P2 }`,
+	`package p; type _ []T[int]`,
+
+	`package p; var _ = func()T(nil)`,
+	`package p; func _[T any]()`,
+	`package p; func _[T any]()()`,
+	`package p; func _(T (P))`,
+	`package p; func _(T []E)`,
+	`package p; func _(T [P]E)`,
+	`package p; func _(x T[P1, P2, P3])`,
+	`package p; func _(x p.T[Q])`,
+	`package p; func _(p.T[Q])`,
+
+	`package p; var _ T[chan int]`,
+	`package p; func f[A, B any](); func _() { _ = f[int, int] }`,
+
+	`package p; type _[A interface{},] struct{}`,
+	`package p; type _[A interface{}] struct{}`,
+	`package p; type _[A, B any,] struct{}`,
+	`package p; type _[A, B any] struct{}`,
+	`package p; type _[A any,] struct{}`,
+	`package p; type _ [A+B]struct{}`, // this is an array!
+	`package p; type _[A any]struct{}`,
+	`package p; type _[A any] struct{ A }`, // this is not an array!
+
+	`package p; func _[T any]()`,
+	`package p; func _[T any](x T)`,
+	`package p; func _[T1, T2 any](x T)`,
+
+	`package p; func (R) _()`,
+	`package p; func (R[P]) _[T any]()`,
+	`package p; func (_ R[P]) _[T any](x T)`,
+	`package p; func (_ R[P, Q]) _[T1, T2 any](x T)`,
+
+	`package p; var _ = []T[int]{}`,
+	`package p; var _ = [10]T[int]{}`,
+	`package p; var _ = func()T[int]{}`,
+	`package p; var _ = map[T[int]]T[int]{}`,
+	`package p; var _ = chan T[int](x)`,
+	`package p; func _(T[P])`,
+	`package p; func _(T[P1, P2, P3])`,
+	`package p; func _(T[P]) T[P]`,
+	`package p; func _(_ T[P], T P) T[P]`,
+
+	`package p; func _[A, B any](a A) B`,
+	`package p; func _[A, B C](a A) B`,
+	`package p; func _[A, B C[A, B]](a A) B`,
+
+	// method type parameters (if methodTypeParamsOk)
+	`package p; func (T) _[A, B any](a A) B`,
+	`package p; func (T) _[A, B C](a A) B`,
+	`package p; func (T) _[A, B C[A, B]](a A) B`,
+
+	// method type parameters are not permitted in interfaces.
+	`package p; type _[A, B any] interface { _(a A) B }`,
+	`package p; type _[A, B C[A, B]] interface { _(a A) B }`,
+
+	// type bounds
+	`package p; func _[T1, T2 interface{}](x T1) T2`,
+	`package p; func _[T1 interface{ m() }, T2, T3 interface{}](x T1, y T3) T2`,
+
+	// struct embedding
+	`package p; type _ struct{ T[P] }`,
+	`package p; type _ struct{ T[struct{a, b, c int}] }`,
+	`package p; type _ struct{ f [n]E }`,
+	`package p; type _ struct{ f [a+b+c+d]E }`,
+
+	// interfaces with type lists
+	`package p; type _ interface{type int}`,
+	`package p; type _ interface{type int, float32; type bool; m(); type string;}`,
+
+	// interface embedding
+	`package p; type I1 interface{}; type I2 interface{ I1 }`,
+	`package p; type I1[T any] interface{}; type I2 interface{ I1[int] }`,
+	`package p; type I1[T any] interface{}; type I2[T any] interface{ I1[T] }`,
 }
 
 func TestValid(t *testing.T) {
 	for _, src := range valids {
-		checkErrors(t, src, src)
+		checkErrors(t, src, src, DeclarationErrors|AllErrors)
 	}
 }
 
+// TestSingle is useful to track down a problem with a single short test program.
+func TestSingle(t *testing.T) {
+	const src = `package p; var _ = T[P]{}`
+	checkErrors(t, src, src, DeclarationErrors|AllErrors)
+}
+
 var invalids = []string{
 	`foo /* ERROR "expected 'package'" */ !`,
 	`package p; func f() { if { /* ERROR "missing condition" */ } };`,
@@ -79,7 +171,6 @@ var invalids = []string{
 	`package p; var a = chan /* ERROR "expected expression" */ int;`,
 	`package p; var a = []int{[ /* ERROR "expected expression" */ ]int};`,
 	`package p; var a = ( /* ERROR "expected expression" */ []int);`,
-	`package p; var a = a[[ /* ERROR "expected expression" */ ]int:[]int];`,
 	`package p; var a = <- /* ERROR "expected expression" */ chan int;`,
 	`package p; func f() { select { case _ <- chan /* ERROR "expected expression" */ int: } };`,
 	`package p; func f() { _ = (<-<- /* ERROR "expected 'chan'" */ chan int)(nil) };`,
@@ -102,7 +193,22 @@ var invalids = []string{
 	`package p; func f() { go f /* ERROR HERE "function must be invoked" */ }`,
 	`package p; func f() { defer func() {} /* ERROR HERE "function must be invoked" */ }`,
 	`package p; func f() { go func() { func() { f(x func /* ERROR "missing ','" */ (){}) } } }`,
-	`package p; func f(x func(), u v func /* ERROR "missing ','" */ ()){}`,
+	//`package p; func f(x func(), u v func /* ERROR "missing ','" */ ()){}`,
+
+	// type parameters
+	`package p; var _ func[ /* ERROR "cannot have type parameters" */ T any](T)`,
+	`package p; func _() (type /* ERROR "found 'type'" */ T)(T)`,
+	`package p; func (type /* ERROR "found 'type'" */ T)(T) _()`,
+	`package p; type _[A+B, /* ERROR "expected ']'" */ ] int`,
+	`package p; type _[_ any] int; var _ = T[] /* ERROR "expected operand" */ {}`,
+	`package p; type T[P any] = /* ERROR "cannot be alias" */ T0`,
+	`package p; func _[]/* ERROR "empty type parameter list" */()`,
+
+	// errors that could be improved
+	`package p; var a = a[[]int:[ /* ERROR "expected expression" */ ]int];`,                      // TODO: should this be on the ':'?
+	`package p; type _[A/* ERROR "all type parameters must be named" */,] struct{ A }`,           // TODO: a better location would be after the ']'
+	`package p; func _[type /* ERROR "all type parameters must be named" */P, *Q interface{}]()`, // TODO: this is confusing.
+	`package p; type I1 interface{}; type I2 interface{ (/* ERROR "expected 'IDENT'" */I1) }`,    // TODO: compiler error is 'syntax error: cannot parenthesize embedded type'
 
 	// issue 8656
 	`package p; func f() (a b string /* ERROR "missing ','" */ , ok bool)`,
@@ -118,11 +224,11 @@ var invalids = []string{
 	`package p; var _ = struct { x int, /* ERROR "expected ';', found ','" */ y float }{};`,
 
 	// issue 11611
-	`package p; type _ struct { int, } /* ERROR "expected type, found '}'" */ ;`,
+	`package p; type _ struct { int, } /* ERROR "expected 'IDENT', found '}'" */ ;`,
 	`package p; type _ struct { int, float } /* ERROR "expected type, found '}'" */ ;`,
-	`package p; type _ struct { ( /* ERROR "expected anonymous field" */ int) };`,
-	`package p; func _()(x, y, z ... /* ERROR "expected '\)', found '...'" */ int){}`,
-	`package p; func _()(... /* ERROR "expected type, found '...'" */ int){}`,
+	//`package p; type _ struct { ( /* ERROR "cannot parenthesize embedded type" */ int) };`,
+	//`package p; func _()(x, y, z ... /* ERROR "expected '\)', found '...'" */ int){}`,
+	//`package p; func _()(... /* ERROR "expected type, found '...'" */ int){}`,
 
 	// issue 13475
 	`package p; func f() { if true {} else ; /* ERROR "expected if statement or block" */ }`,
@@ -131,6 +237,6 @@ var invalids = []string{
 
 func TestInvalid(t *testing.T) {
 	for _, src := range invalids {
-		checkErrors(t, src, src)
+		checkErrors(t, src, src, DeclarationErrors|AllErrors)
 	}
 }
diff --git a/src/go/parser/testdata/chans.go2 b/src/go/parser/testdata/chans.go2
new file mode 100644
index 0000000000..fad2bcec9d
--- /dev/null
+++ b/src/go/parser/testdata/chans.go2
@@ -0,0 +1,62 @@
+package chans
+
+import "runtime"
+
+// Ranger returns a Sender and a Receiver. The Receiver provides a
+// Next method to retrieve values. The Sender provides a Send method
+// to send values and a Close method to stop sending values. The Next
+// method indicates when the Sender has been closed, and the Send
+// method indicates when the Receiver has been freed.
+//
+// This is a convenient way to exit a goroutine sending values when
+// the receiver stops reading them.
+func Ranger[T any]() (*Sender[T], *Receiver[T]) {
+	c := make(chan T)
+	d := make(chan bool)
+	s := &Sender[T]{values: c, done: d}
+	r := &Receiver[T]{values: c, done: d}
+	runtime.SetFinalizer(r, r.finalize)
+	return s, r
+}
+
+// A sender is used to send values to a Receiver.
+type Sender[T any] struct {
+	values chan<- T
+	done <-chan bool
+}
+
+// Send sends a value to the receiver. It returns whether any more
+// values may be sent; if it returns false the value was not sent.
+func (s *Sender[T]) Send(v T) bool {
+	select {
+	case s.values <- v:
+		return true
+	case <-s.done:
+		return false
+	}
+}
+
+// Close tells the receiver that no more values will arrive.
+// After Close is called, the Sender may no longer be used.
+func (s *Sender[T]) Close() {
+	close(s.values)
+}
+
+// A Receiver receives values from a Sender.
+type Receiver[T any] struct {
+	values <-chan T
+	done chan<- bool
+}
+
+// Next returns the next value from the channel. The bool result
+// indicates whether the value is valid, or whether the Sender has
+// been closed and no more values will be received.
+func (r *Receiver[T]) Next() (T, bool) {
+	v, ok := <-r.values
+	return v, ok
+}
+
+// finalize is a finalizer for the receiver.
+func (r *Receiver[T]) finalize() {
+	close(r.done)
+}
diff --git a/src/go/parser/testdata/linalg.go2 b/src/go/parser/testdata/linalg.go2
new file mode 100644
index 0000000000..fba0d02eb2
--- /dev/null
+++ b/src/go/parser/testdata/linalg.go2
@@ -0,0 +1,83 @@
+// Copyright 2019 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 linalg
+
+import "math"
+
+// Numeric is type bound that matches any numeric type.
+// It would likely be in a constraints package in the standard library.
+type Numeric interface {
+	type int, int8, int16, int32, int64,
+		uint, uint8, uint16, uint32, uint64, uintptr,
+		float32, float64,
+		complex64, complex128
+}
+
+func DotProduct[T Numeric](s1, s2 []T) T {
+	if len(s1) != len(s2) {
+		panic("DotProduct: slices of unequal length")
+	}
+	var r T
+	for i := range s1 {
+		r += s1[i] * s2[i]
+	}
+	return r
+}
+
+// NumericAbs matches numeric types with an Abs method.
+type NumericAbs[T any] interface {
+	Numeric
+
+	Abs() T
+}
+
+// AbsDifference computes the absolute value of the difference of
+// a and b, where the absolute value is determined by the Abs method.
+func AbsDifference[T NumericAbs](a, b T) T {
+	d := a - b
+	return d.Abs()
+}
+
+// OrderedNumeric is a type bound that matches numeric types that support the < operator.
+type OrderedNumeric interface {
+	type int, int8, int16, int32, int64,
+		uint, uint8, uint16, uint32, uint64, uintptr,
+		float32, float64
+}
+
+// Complex is a type bound that matches the two complex types, which do not have a < operator.
+type Complex interface {
+	type complex64, complex128
+}
+
+// OrderedAbs is a helper type that defines an Abs method for
+// ordered numeric types.
+type OrderedAbs[T OrderedNumeric] T
+
+func (a OrderedAbs[T]) Abs() OrderedAbs[T] {
+	if a < 0 {
+		return -a
+	}
+	return a
+}
+
+// ComplexAbs is a helper type that defines an Abs method for
+// complex types.
+type ComplexAbs[T Complex] T
+
+func (a ComplexAbs[T]) Abs() ComplexAbs[T] {
+	r := float64(real(a))
+	i := float64(imag(a))
+	d := math.Sqrt(r * r + i * i)
+	return ComplexAbs[T](complex(d, 0))
+}
+
+func OrderedAbsDifference[T OrderedNumeric](a, b T) T {
+	return T(AbsDifference(OrderedAbs[T](a), OrderedAbs[T](b)))
+}
+
+func ComplexAbsDifference[T Complex](a, b T) T {
+	return T(AbsDifference(ComplexAbs[T](a), ComplexAbs[T](b)))
+}
diff --git a/src/go/parser/testdata/map.go2 b/src/go/parser/testdata/map.go2
new file mode 100644
index 0000000000..74c79ae44f
--- /dev/null
+++ b/src/go/parser/testdata/map.go2
@@ -0,0 +1,109 @@
+// Package orderedmap provides an ordered map, implemented as a binary tree.
+package orderedmap
+
+import "chans"
+
+// Map is an ordered map.
+type Map[K, V any] struct {
+	root    *node[K, V]
+	compare func(K, K) int
+}
+
+// node is the type of a node in the binary tree.
+type node[K, V any] struct {
+	key         K
+	val         V
+	left, right *node[K, V]
+}
+
+// New returns a new map.
+func New[K, V any](compare func(K, K) int) *Map[K, V] {
+        return &Map[K, V]{compare: compare}
+}
+
+// find looks up key in the map, and returns either a pointer
+// to the node holding key, or a pointer to the location where
+// such a node would go.
+func (m *Map[K, V]) find(key K) **node[K, V] {
+	pn := &m.root
+	for *pn != nil {
+		switch cmp := m.compare(key, (*pn).key); {
+		case cmp < 0:
+			pn = &(*pn).left
+		case cmp > 0:
+			pn = &(*pn).right
+		default:
+			return pn
+		}
+	}
+	return pn
+}
+
+// Insert inserts a new key/value into the map.
+// If the key is already present, the value is replaced.
+// Returns true if this is a new key, false if already present.
+func (m *Map[K, V]) Insert(key K, val V) bool {
+	pn := m.find(key)
+	if *pn != nil {
+		(*pn).val = val
+		return false
+	}
+        *pn = &node[K, V]{key: key, val: val}
+	return true
+}
+
+// Find returns the value associated with a key, or zero if not present.
+// The found result reports whether the key was found.
+func (m *Map[K, V]) Find(key K) (V, bool) {
+	pn := m.find(key)
+	if *pn == nil {
+		var zero V // see the discussion of zero values, above
+		return zero, false
+	}
+	return (*pn).val, true
+}
+
+// keyValue is a pair of key and value used when iterating.
+type keyValue[K, V any] struct {
+	key K
+	val V
+}
+
+// InOrder returns an iterator that does an in-order traversal of the map.
+func (m *Map[K, V]) InOrder() *Iterator[K, V] {
+	sender, receiver := chans.Ranger[keyValue[K, V]]()
+	var f func(*node[K, V]) bool
+	f = func(n *node[K, V]) bool {
+		if n == nil {
+			return true
+		}
+		// Stop sending values if sender.Send returns false,
+		// meaning that nothing is listening at the receiver end.
+		return f(n.left) &&
+                        // TODO
+			// sender.Send(keyValue[K, V]{n.key, n.val}) &&
+			f(n.right)
+	}
+	go func() {
+		f(m.root)
+		sender.Close()
+	}()
+	return &Iterator{receiver}
+}
+
+// Iterator is used to iterate over the map.
+type Iterator[K, V any] struct {
+	r *chans.Receiver[keyValue[K, V]]
+}
+
+// Next returns the next key and value pair, and a boolean indicating
+// whether they are valid or whether we have reached the end.
+func (it *Iterator[K, V]) Next() (K, V, bool) {
+	keyval, ok := it.r.Next()
+	if !ok {
+		var zerok K
+		var zerov V
+		return zerok, zerov, false
+	}
+	return keyval.key, keyval.val, true
+}
diff --git a/src/go/parser/testdata/metrics.go2 b/src/go/parser/testdata/metrics.go2
new file mode 100644
index 0000000000..ef1c66b241
--- /dev/null
+++ b/src/go/parser/testdata/metrics.go2
@@ -0,0 +1,58 @@
+package metrics
+
+import "sync"
+
+type Metric1[T comparable] struct {
+	mu sync.Mutex
+	m  map[T]int
+}
+
+func (m *Metric1[T]) Add(v T) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.m == nil {
+		m.m = make(map[T]int)
+	}
+	m[v]++
+}
+
+type key2[T1, T2 comparable] struct {
+	f1 T1
+	f2 T2
+}
+
+type Metric2[T1, T2 cmp2] struct {
+	mu sync.Mutex
+	m  map[key2[T1, T2]]int
+}
+
+func (m *Metric2[T1, T2]) Add(v1 T1, v2 T2) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.m == nil {
+		m.m = make(map[key2[T1, T2]]int)
+	}
+	m[key[T1, T2]{v1, v2}]++
+}
+
+type key3[T1, T2, T3 comparable] struct {
+	f1 T1
+	f2 T2
+	f3 T3
+}
+
+type Metric3[T1, T2, T3 comparable] struct {
+	mu sync.Mutex
+	m  map[key3[T1, T2, T3]]int
+}
+
+func (m *Metric3[T1, T2, T3]) Add(v1 T1, v2 T2, v3 T3) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.m == nil {
+		m.m = make(map[key3]int)
+	}
+	m[key[T1, T2, T3]{v1, v2, v3}]++
+}
+
+// Repeat for the maximum number of permitted arguments.
diff --git a/src/go/parser/testdata/set.go2 b/src/go/parser/testdata/set.go2
new file mode 100644
index 0000000000..0da6377cbd
--- /dev/null
+++ b/src/go/parser/testdata/set.go2
@@ -0,0 +1,31 @@
+// Package set implements sets of any type.
+package set
+
+type Set[Elem comparable] map[Elem]struct{}
+
+func Make[Elem comparable]() Set[Elem] {
+	return make(Set(Elem))
+}
+
+func (s Set[Elem]) Add(v Elem) {
+	s[v] = struct{}{}
+}
+
+func (s Set[Elem]) Delete(v Elem) {
+	delete(s, v)
+}
+
+func (s Set[Elem]) Contains(v Elem) bool {
+	_, ok := s[v]
+	return ok
+}
+
+func (s Set[Elem]) Len() int {
+	return len(s)
+}
+
+func (s Set[Elem]) Iterate(f func(Elem)) {
+	for v := range s {
+		f(v)
+	}
+}
diff --git a/src/go/parser/testdata/slices.go2 b/src/go/parser/testdata/slices.go2
new file mode 100644
index 0000000000..e060212f29
--- /dev/null
+++ b/src/go/parser/testdata/slices.go2
@@ -0,0 +1,31 @@
+// Package slices implements various slice algorithms.
+package slices
+
+// Map turns a []T1 to a []T2 using a mapping function.
+func Map[T1, T2 any](s []T1, f func(T1) T2) []T2 {
+	r := make([]T2, len(s))
+	for i, v := range s {
+		r[i] = f(v)
+	}
+	return r
+}
+
+// Reduce reduces a []T1 to a single value using a reduction function.
+func Reduce[T1, T2 any](s []T1, initializer T2, f func(T2, T1) T2) T2 {
+	r := initializer
+	for _, v := range s {
+		r = f(r, v)
+	}
+	return r
+}
+
+// Filter filters values from a slice using a filter function.
+func Filter[T any](s []T, f func(T) bool) []T {
+	var r []T
+	for _, v := range s {
+		if f(v) {
+			r = append(r, v)
+		}
+	}
+	return r
+}
diff --git a/src/go/parser/testdata/sort.go2 b/src/go/parser/testdata/sort.go2
new file mode 100644
index 0000000000..88be79f966
--- /dev/null
+++ b/src/go/parser/testdata/sort.go2
@@ -0,0 +1,27 @@
+package sort
+
+type orderedSlice[Elem comparable] []Elem
+
+func (s orderedSlice[Elem]) Len() int           { return len(s) }
+func (s orderedSlice[Elem]) Less(i, j int) bool { return s[i] < s[j] }
+func (s orderedSlice[Elem]) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
+// OrderedSlice sorts the slice s in ascending order.
+// The elements of s must be ordered using the < operator.
+func OrderedSlice[Elem comparable](s []Elem) {
+	sort.Sort(orderedSlice[Elem](s))
+}
+
+type sliceFn[Elem any] struct {
+	s []Elem
+	f func(Elem, Elem) bool
+}
+
+func (s sliceFn[Elem]) Len() int           { return len(s.s) }
+func (s sliceFn[Elem]) Less(i, j int) bool { return s.f(s.s[i], s.s[j]) }
+func (s sliceFn[Elem]) Swap(i, j int)      { s.s[i], s.s[j] = s.s[j], s.s[i] }
+
+// SliceFn sorts the slice s according to the function f.
+func SliceFn[Elem any](s []Elem, f func(Elem, Elem) bool) {
+	Sort(sliceFn[Elem]{s, f})
+}
diff --git a/src/go/types/testdata/issues.src b/src/go/types/testdata/issues.src
index e0c5d7a37c..db415eadfb 100644
--- a/src/go/types/testdata/issues.src
+++ b/src/go/types/testdata/issues.src
@@ -325,8 +325,8 @@ func issue28281c(a, b, c ... /* ERROR can only use ... with final parameter */ i
 func issue28281d(... /* ERROR can only use ... with final parameter */ int, int)
 func issue28281e(a, b, c  ... /* ERROR can only use ... with final parameter */ int, d int)
 func issue28281f(... /* ERROR can only use ... with final parameter */ int, ... /* ERROR can only use ... with final parameter */ int, int)
-func (... /* ERROR expected type */ TT) f()
-func issue28281g() (... /* ERROR expected type */ TT)
+func (... /* ERROR can only use ... with final parameter */ TT) f()
+func issue28281g() (... /* ERROR can only use ... with final parameter */ TT)
 
 // Issue #26234: Make various field/method lookup errors easier to read by matching cmd/compile's output
 func issue26234a(f *syn.File) {
-- 
GitLab


From 0fb733b7f79001092897282749bf5942953b0675 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 18 Nov 2020 15:02:58 -0500
Subject: [PATCH 0047/2400] [dev.typeparams] go/parser: support the
 ParseTypeParams mode

Support is added for parsing type parameters only if the ParseTypeParams
mode is set, otherwise emitting syntax errors for source code that is
invalid without type parameters.

Rather than have large conditional blocks switching between legacy
parser logic and new parser logic, effort is made to minimize special
handling for ParseTypeParams.

Change-Id: I243f6c4b9b8eb1313b838e8649b6cc1e5e8339ba
Reviewed-on: https://go-review.googlesource.com/c/go/+/271218
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Trust: Robert Findley <rfindley@google.com>
---
 src/go/parser/error_test.go |  13 ++-
 src/go/parser/parser.go     |  51 ++++++---
 src/go/parser/short_test.go | 218 ++++++++++++++++++++----------------
 3 files changed, 165 insertions(+), 117 deletions(-)

diff --git a/src/go/parser/error_test.go b/src/go/parser/error_test.go
index ed9e9473da..83bfdd40ad 100644
--- a/src/go/parser/error_test.go
+++ b/src/go/parser/error_test.go
@@ -150,7 +150,7 @@ func compareErrors(t *testing.T, fset *token.FileSet, expected map[token.Pos]str
 	}
 }
 
-func checkErrors(t *testing.T, filename string, input interface{}, mode Mode) {
+func checkErrors(t *testing.T, filename string, input interface{}, mode Mode, expectErrors bool) {
 	t.Helper()
 	src, err := readSource(filename, input)
 	if err != nil {
@@ -167,9 +167,12 @@ func checkErrors(t *testing.T, filename string, input interface{}, mode Mode) {
 	}
 	found.RemoveMultiples()
 
-	// we are expecting the following errors
-	// (collect these after parsing a file so that it is found in the file set)
-	expected := expectedErrors(fset, filename, src)
+	expected := map[token.Pos]string{}
+	if expectErrors {
+		// we are expecting the following errors
+		// (collect these after parsing a file so that it is found in the file set)
+		expected = expectedErrors(fset, filename, src)
+	}
 
 	// verify errors returned by the parser
 	compareErrors(t, fset, expected, found)
@@ -187,7 +190,7 @@ func TestErrors(t *testing.T) {
 			if strings.HasSuffix(name, ".go2") {
 				mode |= ParseTypeParams
 			}
-			checkErrors(t, filepath.Join(testdata, name), nil, mode)
+			checkErrors(t, filepath.Join(testdata, name), nil, mode, true)
 		}
 	}
 }
diff --git a/src/go/parser/parser.go b/src/go/parser/parser.go
index 6d92373c33..9c414c411e 100644
--- a/src/go/parser/parser.go
+++ b/src/go/parser/parser.go
@@ -651,7 +651,7 @@ func (p *parser) parseQualifiedIdent(ident *ast.Ident) ast.Expr {
 	}
 
 	typ := p.parseTypeName(ident)
-	if p.tok == token.LBRACK {
+	if p.tok == token.LBRACK && p.mode&ParseTypeParams != 0 {
 		typ = p.parseTypeInstance(typ)
 	}
 
@@ -708,12 +708,22 @@ func (p *parser) parseArrayFieldOrTypeInstance(x *ast.Ident) (*ast.Ident, ast.Ex
 	//           list such as T[P,]? (We do in parseTypeInstance).
 	lbrack := p.expect(token.LBRACK)
 	var args []ast.Expr
+	var firstComma token.Pos
+	// TODO(rfindley): consider changing parseRhsOrType so that this function variable
+	// is not needed.
+	argparser := p.parseRhsOrType
+	if p.mode&ParseTypeParams == 0 {
+		argparser = p.parseRhs
+	}
 	if p.tok != token.RBRACK {
 		p.exprLev++
-		args = append(args, p.parseRhsOrType())
+		args = append(args, argparser())
 		for p.tok == token.COMMA {
+			if !firstComma.IsValid() {
+				firstComma = p.pos
+			}
 			p.next()
-			args = append(args, p.parseRhsOrType())
+			args = append(args, argparser())
 		}
 		p.exprLev--
 	}
@@ -732,6 +742,15 @@ func (p *parser) parseArrayFieldOrTypeInstance(x *ast.Ident) (*ast.Ident, ast.Ex
 			// x [P]E
 			return x, &ast.ArrayType{Lbrack: lbrack, Len: args[0], Elt: elt}
 		}
+		if p.mode&ParseTypeParams == 0 {
+			p.error(rbrack, "missing element type in array type expression")
+			return nil, &ast.BadExpr{From: args[0].Pos(), To: args[0].End()}
+		}
+	}
+
+	if p.mode&ParseTypeParams == 0 {
+		p.error(firstComma, "expected ']', found ','")
+		return x, &ast.BadExpr{From: args[0].Pos(), To: args[len(args)-1].End()}
 	}
 
 	// x[P], x[P1, P2], ...
@@ -1025,7 +1044,7 @@ func (p *parser) parseParameters(scope *ast.Scope, acceptTParams bool) (tparams,
 		defer un(trace(p, "Parameters"))
 	}
 
-	if acceptTParams && p.tok == token.LBRACK {
+	if p.mode&ParseTypeParams != 0 && acceptTParams && p.tok == token.LBRACK {
 		opening := p.pos
 		p.next()
 		// [T any](params) syntax
@@ -1098,8 +1117,8 @@ func (p *parser) parseMethodSpec(scope *ast.Scope) *ast.Field {
 	var typ ast.Expr
 	x := p.parseTypeName(nil)
 	if ident, _ := x.(*ast.Ident); ident != nil {
-		switch p.tok {
-		case token.LBRACK:
+		switch {
+		case p.tok == token.LBRACK && p.mode&ParseTypeParams != 0:
 			// generic method or embedded instantiated type
 			lbrack := p.pos
 			p.next()
@@ -1135,7 +1154,7 @@ func (p *parser) parseMethodSpec(scope *ast.Scope) *ast.Field {
 				rbrack := p.expectClosing(token.RBRACK, "type argument list")
 				typ = &ast.CallExpr{Fun: ident, Lparen: lbrack, Args: list, Rparen: rbrack, Brackets: true}
 			}
-		case token.LPAREN:
+		case p.tok == token.LPAREN:
 			// ordinary method
 			// TODO(rfindley) refactor to share code with parseFuncType.
 			scope := ast.NewScope(nil) // method scope
@@ -1151,7 +1170,7 @@ func (p *parser) parseMethodSpec(scope *ast.Scope) *ast.Field {
 	} else {
 		// embedded, possibly instantiated type
 		typ = x
-		if p.tok == token.LBRACK {
+		if p.tok == token.LBRACK && p.mode&ParseTypeParams != 0 {
 			// embedded instantiated interface
 			typ = p.parseTypeInstance(typ)
 		}
@@ -1173,12 +1192,10 @@ func (p *parser) parseInterfaceType() *ast.InterfaceType {
 	lbrace := p.expect(token.LBRACE)
 	scope := ast.NewScope(nil) // interface scope
 	var list []*ast.Field
-L:
-	for {
-		switch p.tok {
-		case token.IDENT, token.LPAREN:
+	for p.tok == token.IDENT || p.mode&ParseTypeParams != 0 && p.tok == token.TYPE {
+		if p.tok == token.IDENT {
 			list = append(list, p.parseMethodSpec(scope))
-		case token.TYPE:
+		} else {
 			// all types in a type list share the same field name "type"
 			// (since type is a keyword, a Go program cannot have that field name)
 			name := []*ast.Ident{{NamePos: p.pos, Name: "type"}}
@@ -1188,10 +1205,10 @@ L:
 				list = append(list, &ast.Field{Names: name, Type: typ})
 			}
 			p.expectSemi()
-		default:
-			break L
 		}
 	}
+	// TODO(rfindley): the error produced here could be improved, since we could
+	// accept a identifier, 'type', or a '}' at this point.
 	rbrace := p.expect(token.RBRACE)
 
 	return &ast.InterfaceType{
@@ -1271,7 +1288,7 @@ func (p *parser) tryIdentOrType() ast.Expr {
 	switch p.tok {
 	case token.IDENT:
 		typ := p.parseTypeName(nil)
-		if p.tok == token.LBRACK {
+		if p.tok == token.LBRACK && p.mode&ParseTypeParams != 0 {
 			typ = p.parseTypeInstance(typ)
 		}
 		return typ
@@ -2668,7 +2685,7 @@ func (p *parser) parseTypeSpec(doc *ast.CommentGroup, _ token.Pos, _ token.Token
 			p.exprLev++
 			x := p.parseExpr(true) // we don't know yet if we're a lhs or rhs expr
 			p.exprLev--
-			if name0, _ := x.(*ast.Ident); name0 != nil && p.tok != token.RBRACK {
+			if name0, _ := x.(*ast.Ident); p.mode&ParseTypeParams != 0 && name0 != nil && p.tok != token.RBRACK {
 				// generic type [T any];
 				p.parseGenericType(spec, lbrack, name0, token.RBRACK)
 			} else {
diff --git a/src/go/parser/short_test.go b/src/go/parser/short_test.go
index 46fa764466..3676c27559 100644
--- a/src/go/parser/short_test.go
+++ b/src/go/parser/short_test.go
@@ -49,103 +49,100 @@ var valids = []string{
 	`package p; type T = int`,
 	`package p; type (T = p.T; _ = struct{}; x = *T)`,
 	`package p; type T (*int)`,
-
-	// structs with parameterized embedded fields (for symmetry with interfaces)
 	`package p; type _ struct{ ((int)) }`,
 	`package p; type _ struct{ (*(int)) }`,
 	`package p; type _ struct{ ([]byte) }`, // disallowed by type-checker
-
-	// type parameters
-	`package p; type T[P any] struct { P }`,
-	`package p; type T[P comparable] struct { P }`,
-	`package p; type T[P comparable[P]] struct { P }`,
-	`package p; type T[P1, P2 any] struct { P1; f []P2 }`,
-	`package p; type _ []T[int]`,
-
 	`package p; var _ = func()T(nil)`,
-	`package p; func _[T any]()`,
-	`package p; func _[T any]()()`,
 	`package p; func _(T (P))`,
 	`package p; func _(T []E)`,
 	`package p; func _(T [P]E)`,
-	`package p; func _(x T[P1, P2, P3])`,
-	`package p; func _(x p.T[Q])`,
-	`package p; func _(p.T[Q])`,
-
-	`package p; var _ T[chan int]`,
-	`package p; func f[A, B any](); func _() { _ = f[int, int] }`,
-
-	`package p; type _[A interface{},] struct{}`,
-	`package p; type _[A interface{}] struct{}`,
-	`package p; type _[A, B any,] struct{}`,
-	`package p; type _[A, B any] struct{}`,
-	`package p; type _[A any,] struct{}`,
-	`package p; type _ [A+B]struct{}`, // this is an array!
-	`package p; type _[A any]struct{}`,
-	`package p; type _[A any] struct{ A }`, // this is not an array!
-
-	`package p; func _[T any]()`,
-	`package p; func _[T any](x T)`,
-	`package p; func _[T1, T2 any](x T)`,
-
+	`package p; type _ [A+B]struct{}`,
 	`package p; func (R) _()`,
-	`package p; func (R[P]) _[T any]()`,
-	`package p; func (_ R[P]) _[T any](x T)`,
-	`package p; func (_ R[P, Q]) _[T1, T2 any](x T)`,
-
-	`package p; var _ = []T[int]{}`,
-	`package p; var _ = [10]T[int]{}`,
-	`package p; var _ = func()T[int]{}`,
-	`package p; var _ = map[T[int]]T[int]{}`,
-	`package p; var _ = chan T[int](x)`,
-	`package p; func _(T[P])`,
-	`package p; func _(T[P1, P2, P3])`,
-	`package p; func _(T[P]) T[P]`,
-	`package p; func _(_ T[P], T P) T[P]`,
-
-	`package p; func _[A, B any](a A) B`,
-	`package p; func _[A, B C](a A) B`,
-	`package p; func _[A, B C[A, B]](a A) B`,
-
-	// method type parameters (if methodTypeParamsOk)
-	`package p; func (T) _[A, B any](a A) B`,
-	`package p; func (T) _[A, B C](a A) B`,
-	`package p; func (T) _[A, B C[A, B]](a A) B`,
-
-	// method type parameters are not permitted in interfaces.
-	`package p; type _[A, B any] interface { _(a A) B }`,
-	`package p; type _[A, B C[A, B]] interface { _(a A) B }`,
-
-	// type bounds
-	`package p; func _[T1, T2 interface{}](x T1) T2`,
-	`package p; func _[T1 interface{ m() }, T2, T3 interface{}](x T1, y T3) T2`,
-
-	// struct embedding
-	`package p; type _ struct{ T[P] }`,
-	`package p; type _ struct{ T[struct{a, b, c int}] }`,
 	`package p; type _ struct{ f [n]E }`,
 	`package p; type _ struct{ f [a+b+c+d]E }`,
+	`package p; type I1 interface{}; type I2 interface{ I1 }`,
+}
 
-	// interfaces with type lists
-	`package p; type _ interface{type int}`,
-	`package p; type _ interface{type int, float32; type bool; m(); type string;}`,
+// validWithTParamsOnly holds source code examples that are valid if
+// ParseTypeParams is set, but invalid if not. When checking with the
+// ParseTypeParams set, errors are ignored.
+var validWithTParamsOnly = []string{
+	`package p; type _ []T[ /* ERROR "expected ';', found '\['" */ int]`,
+	`package p; type T[P any /* ERROR "expected ']', found any" */ ] struct { P }`,
+	`package p; type T[P comparable /* ERROR "expected ']', found comparable" */ ] struct { P }`,
+	`package p; type T[P comparable /* ERROR "expected ']', found comparable" */ [P]] struct { P }`,
+	`package p; type T[P1, /* ERROR "expected ']', found ','" */ P2 any] struct { P1; f []P2 }`,
+	`package p; func _[ /* ERROR "expected '\(', found '\['" */ T any]()()`,
+	`package p; func _(T (P))`,
+	`package p; func f[ /* ERROR "expected '\(', found '\['" */ A, B any](); func _() { _ = f[int, int] }`,
+	`package p; func _(x /* ERROR "mixed named and unnamed parameters" */ T[P1, P2, P3])`,
+	`package p; func _(x /* ERROR "mixed named and unnamed parameters" */ p.T[Q])`,
+	`package p; func _(p.T[ /* ERROR "missing ',' in parameter list" */ Q])`,
+	`package p; type _[A interface /* ERROR "expected ']', found 'interface'" */ {},] struct{}`,
+	`package p; type _[A interface /* ERROR "expected ']', found 'interface'" */ {}] struct{}`,
+	`package p; type _[A, /* ERROR "expected ']', found ','" */  B any,] struct{}`,
+	`package p; type _[A, /* ERROR "expected ']', found ','" */ B any] struct{}`,
+	`package p; type _[A any /* ERROR "expected ']', found any" */,] struct{}`,
+	`package p; type _[A any /* ERROR "expected ']', found any" */ ]struct{}`,
+	`package p; type _[A any /* ERROR "expected ']', found any" */ ] struct{ A }`,
+	`package p; func _[ /* ERROR "expected '\(', found '\['" */ T any]()`,
+	`package p; func _[ /* ERROR "expected '\(', found '\['" */ T any](x T)`,
+	`package p; func _[ /* ERROR "expected '\(', found '\['" */ T1, T2 any](x T)`,
+	`package p; func _[ /* ERROR "expected '\(', found '\['" */ A, B any](a A) B`,
+	`package p; func _[ /* ERROR "expected '\(', found '\['" */ A, B C](a A) B`,
+	`package p; func _[ /* ERROR "expected '\(', found '\['" */ A, B C[A, B]](a A) B`,
+	`package p; func (T) _[ /* ERROR "expected '\(', found '\['" */ A, B any](a A) B`,
+	`package p; func (T) _[ /* ERROR "expected '\(', found '\['" */ A, B C](a A) B`,
+	`package p; func (T) _[ /* ERROR "expected '\(', found '\['" */ A, B C[A, B]](a A) B`,
+	`package p; type _[A, /* ERROR "expected ']', found ','" */ B any] interface { _(a A) B }`,
+	`package p; type _[A, /* ERROR "expected ']', found ','" */ B C[A, B]] interface { _(a A) B }`,
+	`package p; func _[ /* ERROR "expected '\(', found '\['" */ T1, T2 interface{}](x T1) T2`,
+	`package p; func _[ /* ERROR "expected '\(', found '\['" */ T1 interface{ m() }, T2, T3 interface{}](x T1, y T3) T2`,
+	`package p; var _ = [ /* ERROR "expected expression" */ ]T[int]{}`,
+	`package p; var _ = [ /* ERROR "expected expression" */ 10]T[int]{}`,
+	`package p; var _ = func /* ERROR "expected expression" */ ()T[int]{}`,
+	`package p; var _ = map /* ERROR "expected expression" */ [T[int]]T[int]{}`,
+	`package p; var _ = chan /* ERROR "expected expression" */ T[int](x)`,
+	`package p; func _(_ T[ /* ERROR "missing ',' in parameter list" */ P], T P) T[P]`,
+	`package p; var _ T[ /* ERROR "expected ';', found '\['" */ chan int]`,
 
-	// interface embedding
-	`package p; type I1 interface{}; type I2 interface{ I1 }`,
-	`package p; type I1[T any] interface{}; type I2 interface{ I1[int] }`,
-	`package p; type I1[T any] interface{}; type I2[T any] interface{ I1[T] }`,
+	// TODO(rfindley) this error message could be improved.
+	`package p; func (_ /* ERROR "mixed named and unnamed parameters" */ R[P]) _[T any](x T)`,
+	`package p; func (_ /* ERROR "mixed named and unnamed parameters" */ R[ P, Q]) _[T1, T2 any](x T)`,
+
+	`package p; func (R[P] /* ERROR "missing element type" */ ) _[T any]()`,
+	`package p; func _(T[P] /* ERROR "missing element type" */ )`,
+	`package p; func _(T[P1, /* ERROR "expected ']', found ','" */ P2, P3 ])`,
+	`package p; func _(T[P] /* ERROR "missing element type" */ ) T[P]`,
+	`package p; type _ struct{ T[P] /* ERROR "missing element type" */ }`,
+	`package p; type _ struct{ T[struct /* ERROR "expected expression" */ {a, b, c int}] }`,
+	`package p; type _ interface{type /* ERROR "expected '}', found 'type'" */ int}`,
+	`package p; type _ interface{type /* ERROR "expected '}', found 'type'" */ int, float32; type bool; m(); type string;}`,
+	`package p; type I1[T any /* ERROR "expected ']', found any" */ ] interface{}; type I2 interface{ I1[int] }`,
+	`package p; type I1[T any /* ERROR "expected ']', found any" */ ] interface{}; type I2[T any] interface{ I1[T] }`,
+	`package p; type _ interface { f[ /* ERROR "expected ';', found '\['" */ T any]() }`,
 }
 
 func TestValid(t *testing.T) {
-	for _, src := range valids {
-		checkErrors(t, src, src, DeclarationErrors|AllErrors)
-	}
+	t.Run("no tparams", func(t *testing.T) {
+		for _, src := range valids {
+			checkErrors(t, src, src, DeclarationErrors|AllErrors, false)
+		}
+	})
+	t.Run("tparams", func(t *testing.T) {
+		for _, src := range valids {
+			checkErrors(t, src, src, DeclarationErrors|AllErrors|ParseTypeParams, false)
+		}
+		for _, src := range validWithTParamsOnly {
+			checkErrors(t, src, src, DeclarationErrors|AllErrors|ParseTypeParams, false)
+		}
+	})
 }
 
 // TestSingle is useful to track down a problem with a single short test program.
 func TestSingle(t *testing.T) {
 	const src = `package p; var _ = T[P]{}`
-	checkErrors(t, src, src, DeclarationErrors|AllErrors)
+	checkErrors(t, src, src, DeclarationErrors|AllErrors|ParseTypeParams, true)
 }
 
 var invalids = []string{
@@ -193,22 +190,14 @@ var invalids = []string{
 	`package p; func f() { go f /* ERROR HERE "function must be invoked" */ }`,
 	`package p; func f() { defer func() {} /* ERROR HERE "function must be invoked" */ }`,
 	`package p; func f() { go func() { func() { f(x func /* ERROR "missing ','" */ (){}) } } }`,
-	//`package p; func f(x func(), u v func /* ERROR "missing ','" */ ()){}`,
-
-	// type parameters
-	`package p; var _ func[ /* ERROR "cannot have type parameters" */ T any](T)`,
 	`package p; func _() (type /* ERROR "found 'type'" */ T)(T)`,
 	`package p; func (type /* ERROR "found 'type'" */ T)(T) _()`,
 	`package p; type _[A+B, /* ERROR "expected ']'" */ ] int`,
-	`package p; type _[_ any] int; var _ = T[] /* ERROR "expected operand" */ {}`,
-	`package p; type T[P any] = /* ERROR "cannot be alias" */ T0`,
-	`package p; func _[]/* ERROR "empty type parameter list" */()`,
 
-	// errors that could be improved
-	`package p; var a = a[[]int:[ /* ERROR "expected expression" */ ]int];`,                      // TODO: should this be on the ':'?
-	`package p; type _[A/* ERROR "all type parameters must be named" */,] struct{ A }`,           // TODO: a better location would be after the ']'
-	`package p; func _[type /* ERROR "all type parameters must be named" */P, *Q interface{}]()`, // TODO: this is confusing.
-	`package p; type I1 interface{}; type I2 interface{ (/* ERROR "expected 'IDENT'" */I1) }`,    // TODO: compiler error is 'syntax error: cannot parenthesize embedded type'
+	// TODO: this error should be positioned on the ':'
+	`package p; var a = a[[]int:[ /* ERROR "expected expression" */ ]int];`,
+	// TODO: the compiler error is better here: "cannot parenthesize embedded type"
+	`package p; type I1 interface{}; type I2 interface{ (/* ERROR "expected '}', found '\('" */ I1) }`,
 
 	// issue 8656
 	`package p; func f() (a b string /* ERROR "missing ','" */ , ok bool)`,
@@ -226,17 +215,56 @@ var invalids = []string{
 	// issue 11611
 	`package p; type _ struct { int, } /* ERROR "expected 'IDENT', found '}'" */ ;`,
 	`package p; type _ struct { int, float } /* ERROR "expected type, found '}'" */ ;`,
-	//`package p; type _ struct { ( /* ERROR "cannot parenthesize embedded type" */ int) };`,
-	//`package p; func _()(x, y, z ... /* ERROR "expected '\)', found '...'" */ int){}`,
-	//`package p; func _()(... /* ERROR "expected type, found '...'" */ int){}`,
 
 	// issue 13475
 	`package p; func f() { if true {} else ; /* ERROR "expected if statement or block" */ }`,
 	`package p; func f() { if true {} else defer /* ERROR "expected if statement or block" */ f() }`,
 }
 
+// invalidNoTParamErrs holds invalid source code examples annotated with the
+// error messages produced when ParseTypeParams is not set.
+var invalidNoTParamErrs = []string{
+	`package p; type _[_ any /* ERROR "expected ']', found any" */ ] int; var _ = T[]{}`,
+	`package p; type T[P any /* ERROR "expected ']', found any" */ ] = T0`,
+	`package p; var _ func[ /* ERROR "expected '\(', found '\['" */ T any](T)`,
+	`package p; func _[ /* ERROR "expected '\(', found '\['" */ ]()`,
+	`package p; type _[A, /* ERROR "expected ']', found ','" */] struct{ A }`,
+	`package p; func _[ /* ERROR "expected '\(', found '\['" */ type P, *Q interface{}]()`,
+}
+
+// invalidTParamErrs holds invalid source code examples annotated with the
+// error messages produced when ParseTypeParams is set.
+var invalidTParamErrs = []string{
+	`package p; type _[_ any] int; var _ = T[] /* ERROR "expected operand" */ {}`,
+	`package p; type T[P any] = /* ERROR "cannot be alias" */ T0`,
+	`package p; var _ func[ /* ERROR "cannot have type parameters" */ T any](T)`,
+	`package p; func _[]/* ERROR "empty type parameter list" */()`,
+
+	// TODO(rfindley) a better location would be after the ']'
+	`package p; type _[A/* ERROR "all type parameters must be named" */,] struct{ A }`,
+
+	// TODO(rfindley) this error is confusing.
+	`package p; func _[type /* ERROR "all type parameters must be named" */P, *Q interface{}]()`,
+}
+
 func TestInvalid(t *testing.T) {
-	for _, src := range invalids {
-		checkErrors(t, src, src, DeclarationErrors|AllErrors)
-	}
+	t.Run("no tparams", func(t *testing.T) {
+		for _, src := range invalids {
+			checkErrors(t, src, src, DeclarationErrors|AllErrors, true)
+		}
+		for _, src := range validWithTParamsOnly {
+			checkErrors(t, src, src, DeclarationErrors|AllErrors, true)
+		}
+		for _, src := range invalidNoTParamErrs {
+			checkErrors(t, src, src, DeclarationErrors|AllErrors, true)
+		}
+	})
+	t.Run("tparams", func(t *testing.T) {
+		for _, src := range invalids {
+			checkErrors(t, src, src, DeclarationErrors|AllErrors|ParseTypeParams, true)
+		}
+		for _, src := range invalidTParamErrs {
+			checkErrors(t, src, src, DeclarationErrors|AllErrors|ParseTypeParams, true)
+		}
+	})
 }
-- 
GitLab


From 742c05e3bce2cf2f4631762cb5fb733d2a92bc91 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 23 Nov 2020 13:42:43 -0800
Subject: [PATCH 0048/2400] [dev.regabi] cmd/compile: prep refactoring for
 switching to go/constant

This CL replaces gc.Ctype (along with its CTINT, etc. constants) with
constant.Kind; renames Val.Ctype to Val.Kind; and replaces a handful
of abstraction-violating patterns that can be readily expressed
differently.

The next commit will actually replace Val with constant.Value.

Passes toolstash-check.

[git-generate]
cd src/cmd/compile/internal/gc

sed -i 's/type Ctype uint8/type Ctype = constant.Kind/' const.go
goimports -w const.go

rf '
inline -rm Ctype
mv Val.Ctype Val.Kind

ex import "go/constant"; \
  CTxxx  -> constant.Unknown; \
  CTINT  -> constant.Int; \
  CTFLT  -> constant.Float; \
  CTCPLX -> constant.Complex; \
  CTBOOL -> constant.Bool; \
  CTSTR  -> constant.String

rm CTxxx CTINT CTFLT CTCPLX CTBOOL CTSTR

ex import "cmd/compile/internal/types"; \
  var t *types.Type; \
  var v, v2 Val; \
  v.U.(*Mpint).Cmp(maxintval[TINT]) > 0 -> doesoverflow(v, types.Types[TINT]); \
  v.U.(*Mpint).Cmp(v2.U.(*Mpint)) > 0 -> compareOp(v, OGT, v2); \
  maxintval[t.Etype].Cmp(maxintval[TUINT]) <= 0 -> t.Size() <= types.Types[TUINT].Size(); \
  maxintval[t.Etype].Cmp(maxintval[TUINT]) >  0 -> t.Size() >  types.Types[TUINT].Size();
'

go test cmd/compile -u

Change-Id: I6c22ec0597508845f88eee639a0d76cbaa66d08f
Reviewed-on: https://go-review.googlesource.com/c/go/+/272653
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/fmtmap_test.go           |   4 +-
 src/cmd/compile/internal/gc/const.go     | 130 ++++++++++-------------
 src/cmd/compile/internal/gc/dcl.go       |   3 +-
 src/cmd/compile/internal/gc/export.go    |   5 +-
 src/cmd/compile/internal/gc/fmt.go       |   2 +-
 src/cmd/compile/internal/gc/iexport.go   |  29 ++---
 src/cmd/compile/internal/gc/iimport.go   |  11 +-
 src/cmd/compile/internal/gc/inl.go       |   3 +-
 src/cmd/compile/internal/gc/noder.go     |   5 +-
 src/cmd/compile/internal/gc/obj.go       |   3 +-
 src/cmd/compile/internal/gc/ssa.go       |  11 +-
 src/cmd/compile/internal/gc/swt.go       |   3 +-
 src/cmd/compile/internal/gc/typecheck.go |  47 ++++----
 src/cmd/compile/internal/gc/walk.go      |  51 ++++-----
 14 files changed, 153 insertions(+), 154 deletions(-)

diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
index a8698de307..51134e4919 100644
--- a/src/cmd/compile/fmtmap_test.go
+++ b/src/cmd/compile/fmtmap_test.go
@@ -85,8 +85,6 @@ var knownFormats = map[string]string{
 	"cmd/compile/internal/gc.Class %d":                "",
 	"cmd/compile/internal/gc.Class %s":                "",
 	"cmd/compile/internal/gc.Class %v":                "",
-	"cmd/compile/internal/gc.Ctype %d":                "",
-	"cmd/compile/internal/gc.Ctype %v":                "",
 	"cmd/compile/internal/gc.Nodes %#v":               "",
 	"cmd/compile/internal/gc.Nodes %+v":               "",
 	"cmd/compile/internal/gc.Nodes %.v":               "",
@@ -138,6 +136,8 @@ var knownFormats = map[string]string{
 	"float64 %.3f":                                    "",
 	"float64 %.6g":                                    "",
 	"float64 %g":                                      "",
+	"go/constant.Kind %d":                             "",
+	"go/constant.Kind %v":                             "",
 	"int %#x":                                         "",
 	"int %-12d":                                       "",
 	"int %-6d":                                        "",
diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 326f44a2fe..c30d24ae1a 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -8,23 +8,11 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"fmt"
+	"go/constant"
 	"math/big"
 	"strings"
 )
 
-// Ctype describes the constant kind of an "ideal" (untyped) constant.
-type Ctype uint8
-
-const (
-	CTxxx Ctype = iota
-
-	CTINT
-	CTFLT
-	CTCPLX
-	CTSTR
-	CTBOOL
-)
-
 type Val struct {
 	// U contains one of:
 	// bool     bool when Ctype() == CTBOOL
@@ -35,28 +23,28 @@ type Val struct {
 	U interface{}
 }
 
-func (v Val) Ctype() Ctype {
+func (v Val) Kind() constant.Kind {
 	switch v.U.(type) {
 	default:
 		Fatalf("unexpected Ctype for %T", v.U)
 		panic("unreachable")
 	case nil:
-		return CTxxx
+		return constant.Unknown
 	case bool:
-		return CTBOOL
+		return constant.Bool
 	case *Mpint:
-		return CTINT
+		return constant.Int
 	case *Mpflt:
-		return CTFLT
+		return constant.Float
 	case *Mpcplx:
-		return CTCPLX
+		return constant.Complex
 	case string:
-		return CTSTR
+		return constant.String
 	}
 }
 
 func eqval(a, b Val) bool {
-	if a.Ctype() != b.Ctype() {
+	if a.Kind() != b.Kind() {
 		return false
 	}
 	switch x := a.U.(type) {
@@ -103,7 +91,7 @@ func (v Val) Interface() interface{} {
 // Int64Val returns n as an int64.
 // n must be an integer or rune constant.
 func (n *Node) Int64Val() int64 {
-	if !Isconst(n, CTINT) {
+	if !Isconst(n, constant.Int) {
 		Fatalf("Int64Val(%v)", n)
 	}
 	return n.Val().U.(*Mpint).Int64()
@@ -111,7 +99,7 @@ func (n *Node) Int64Val() int64 {
 
 // CanInt64 reports whether it is safe to call Int64Val() on n.
 func (n *Node) CanInt64() bool {
-	if !Isconst(n, CTINT) {
+	if !Isconst(n, constant.Int) {
 		return false
 	}
 
@@ -123,7 +111,7 @@ func (n *Node) CanInt64() bool {
 // BoolVal returns n as a bool.
 // n must be a boolean constant.
 func (n *Node) BoolVal() bool {
-	if !Isconst(n, CTBOOL) {
+	if !Isconst(n, constant.Bool) {
 		Fatalf("BoolVal(%v)", n)
 	}
 	return n.Val().U.(bool)
@@ -132,7 +120,7 @@ func (n *Node) BoolVal() bool {
 // StringVal returns the value of a literal string Node as a string.
 // n must be a string constant.
 func (n *Node) StringVal() string {
-	if !Isconst(n, CTSTR) {
+	if !Isconst(n, constant.String) {
 		Fatalf("StringVal(%v)", n)
 	}
 	return n.Val().U.(string)
@@ -369,23 +357,23 @@ func operandType(op Op, t *types.Type) *types.Type {
 // If explicit is true, then conversions from integer to string are
 // also allowed.
 func convertVal(v Val, t *types.Type, explicit bool) Val {
-	switch ct := v.Ctype(); ct {
-	case CTBOOL:
+	switch ct := v.Kind(); ct {
+	case constant.Bool:
 		if t.IsBoolean() {
 			return v
 		}
 
-	case CTSTR:
+	case constant.String:
 		if t.IsString() {
 			return v
 		}
 
-	case CTINT:
+	case constant.Int:
 		if explicit && t.IsString() {
 			return tostr(v)
 		}
 		fallthrough
-	case CTFLT, CTCPLX:
+	case constant.Float, constant.Complex:
 		switch {
 		case t.IsInteger():
 			v = toint(v)
@@ -543,14 +531,14 @@ func tostr(v Val) Val {
 	return v
 }
 
-func consttype(n *Node) Ctype {
+func consttype(n *Node) constant.Kind {
 	if n == nil || n.Op != OLITERAL {
-		return CTxxx
+		return constant.Unknown
 	}
-	return n.Val().Ctype()
+	return n.Val().Kind()
 }
 
-func Isconst(n *Node, ct Ctype) bool {
+func Isconst(n *Node, ct constant.Kind) bool {
 	return consttype(n) == ct
 }
 
@@ -596,11 +584,11 @@ func evconst(n *Node) {
 		// Merge adjacent constants in the argument list.
 		s := n.List.Slice()
 		for i1 := 0; i1 < len(s); i1++ {
-			if Isconst(s[i1], CTSTR) && i1+1 < len(s) && Isconst(s[i1+1], CTSTR) {
+			if Isconst(s[i1], constant.String) && i1+1 < len(s) && Isconst(s[i1+1], constant.String) {
 				// merge from i1 up to but not including i2
 				var strs []string
 				i2 := i1
-				for i2 < len(s) && Isconst(s[i2], CTSTR) {
+				for i2 < len(s) && Isconst(s[i2], constant.String) {
 					strs = append(strs, s[i2].StringVal())
 					i2++
 				}
@@ -613,7 +601,7 @@ func evconst(n *Node) {
 			}
 		}
 
-		if len(s) == 1 && Isconst(s[0], CTSTR) {
+		if len(s) == 1 && Isconst(s[0], constant.String) {
 			n.Op = OLITERAL
 			n.SetVal(s[0].Val())
 		} else {
@@ -623,7 +611,7 @@ func evconst(n *Node) {
 	case OCAP, OLEN:
 		switch nl.Type.Etype {
 		case TSTRING:
-			if Isconst(nl, CTSTR) {
+			if Isconst(nl, constant.String) {
 				setintconst(n, int64(len(nl.StringVal())))
 			}
 		case TARRAY:
@@ -674,9 +662,9 @@ func evconst(n *Node) {
 
 func match(x, y Val) (Val, Val) {
 	switch {
-	case x.Ctype() == CTCPLX || y.Ctype() == CTCPLX:
+	case x.Kind() == constant.Complex || y.Kind() == constant.Complex:
 		return tocplx(x), tocplx(y)
-	case x.Ctype() == CTFLT || y.Ctype() == CTFLT:
+	case x.Kind() == constant.Float || y.Kind() == constant.Float:
 		return toflt(x), toflt(y)
 	}
 
@@ -687,8 +675,8 @@ func match(x, y Val) (Val, Val) {
 func compareOp(x Val, op Op, y Val) bool {
 	x, y = match(x, y)
 
-	switch x.Ctype() {
-	case CTBOOL:
+	switch x.Kind() {
+	case constant.Bool:
 		x, y := x.U.(bool), y.U.(bool)
 		switch op {
 		case OEQ:
@@ -697,15 +685,15 @@ func compareOp(x Val, op Op, y Val) bool {
 			return x != y
 		}
 
-	case CTINT:
+	case constant.Int:
 		x, y := x.U.(*Mpint), y.U.(*Mpint)
 		return cmpZero(x.Cmp(y), op)
 
-	case CTFLT:
+	case constant.Float:
 		x, y := x.U.(*Mpflt), y.U.(*Mpflt)
 		return cmpZero(x.Cmp(y), op)
 
-	case CTCPLX:
+	case constant.Complex:
 		x, y := x.U.(*Mpcplx), y.U.(*Mpcplx)
 		eq := x.Real.Cmp(&y.Real) == 0 && x.Imag.Cmp(&y.Imag) == 0
 		switch op {
@@ -715,7 +703,7 @@ func compareOp(x Val, op Op, y Val) bool {
 			return !eq
 		}
 
-	case CTSTR:
+	case constant.String:
 		x, y := x.U.(string), y.U.(string)
 		switch op {
 		case OEQ:
@@ -761,8 +749,8 @@ func binaryOp(x Val, op Op, y Val) Val {
 	x, y = match(x, y)
 
 Outer:
-	switch x.Ctype() {
-	case CTBOOL:
+	switch x.Kind() {
+	case constant.Bool:
 		x, y := x.U.(bool), y.U.(bool)
 		switch op {
 		case OANDAND:
@@ -771,7 +759,7 @@ Outer:
 			return Val{U: x || y}
 		}
 
-	case CTINT:
+	case constant.Int:
 		x, y := x.U.(*Mpint), y.U.(*Mpint)
 
 		u := new(Mpint)
@@ -808,7 +796,7 @@ Outer:
 		}
 		return Val{U: u}
 
-	case CTFLT:
+	case constant.Float:
 		x, y := x.U.(*Mpflt), y.U.(*Mpflt)
 
 		u := newMpflt()
@@ -831,7 +819,7 @@ Outer:
 		}
 		return Val{U: u}
 
-	case CTCPLX:
+	case constant.Complex:
 		x, y := x.U.(*Mpcplx), y.U.(*Mpcplx)
 
 		u := newMpcmplx()
@@ -864,28 +852,28 @@ Outer:
 func unaryOp(op Op, x Val, t *types.Type) Val {
 	switch op {
 	case OPLUS:
-		switch x.Ctype() {
-		case CTINT, CTFLT, CTCPLX:
+		switch x.Kind() {
+		case constant.Int, constant.Float, constant.Complex:
 			return x
 		}
 
 	case ONEG:
-		switch x.Ctype() {
-		case CTINT:
+		switch x.Kind() {
+		case constant.Int:
 			x := x.U.(*Mpint)
 			u := new(Mpint)
 			u.Set(x)
 			u.Neg()
 			return Val{U: u}
 
-		case CTFLT:
+		case constant.Float:
 			x := x.U.(*Mpflt)
 			u := newMpflt()
 			u.Set(x)
 			u.Neg()
 			return Val{U: u}
 
-		case CTCPLX:
+		case constant.Complex:
 			x := x.U.(*Mpcplx)
 			u := newMpcmplx()
 			u.Real.Set(&x.Real)
@@ -896,8 +884,8 @@ func unaryOp(op Op, x Val, t *types.Type) Val {
 		}
 
 	case OBITNOT:
-		switch x.Ctype() {
-		case CTINT:
+		switch x.Kind() {
+		case constant.Int:
 			x := x.U.(*Mpint)
 
 			u := new(Mpint)
@@ -967,12 +955,12 @@ func setconst(n *Node, v Val) {
 	lineno = lno
 
 	if !n.Type.IsUntyped() {
-		switch v.Ctype() {
+		switch v.Kind() {
 		// Truncate precision for non-ideal float.
-		case CTFLT:
+		case constant.Float:
 			n.SetVal(Val{truncfltlit(v.U.(*Mpflt), n.Type)})
 		// Truncate precision for non-ideal complex.
-		case CTCPLX:
+		case constant.Complex:
 			n.SetVal(Val{trunccmplxlit(v.U.(*Mpcplx), n.Type)})
 		}
 	}
@@ -990,7 +978,7 @@ func represents(t *types.Type, v Val) bool {
 		return true
 	}
 
-	vt := idealType(v.Ctype())
+	vt := idealType(v.Kind())
 	return t == vt || (t == types.UntypedRune && vt == types.UntypedInt)
 }
 
@@ -1007,22 +995,22 @@ func setintconst(n *Node, v int64) {
 // nodlit returns a new untyped constant with value v.
 func nodlit(v Val) *Node {
 	n := nod(OLITERAL, nil, nil)
-	n.Type = idealType(v.Ctype())
+	n.Type = idealType(v.Kind())
 	n.SetVal(v)
 	return n
 }
 
-func idealType(ct Ctype) *types.Type {
+func idealType(ct constant.Kind) *types.Type {
 	switch ct {
-	case CTSTR:
+	case constant.String:
 		return types.UntypedString
-	case CTBOOL:
+	case constant.Bool:
 		return types.UntypedBool
-	case CTINT:
+	case constant.Int:
 		return types.UntypedInt
-	case CTFLT:
+	case constant.Float:
 		return types.UntypedFloat
-	case CTCPLX:
+	case constant.Complex:
 		return types.UntypedComplex
 	}
 	Fatalf("unexpected Ctype: %v", ct)
@@ -1121,7 +1109,7 @@ func defaultType(t *types.Type) *types.Type {
 }
 
 func smallintconst(n *Node) bool {
-	if n.Op == OLITERAL && Isconst(n, CTINT) && n.Type != nil {
+	if n.Op == OLITERAL && Isconst(n, constant.Int) && n.Type != nil {
 		switch simtype[n.Type.Etype] {
 		case TINT8,
 			TUINT8,
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index d3b7590257..e0a6f6ac92 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -10,6 +10,7 @@ import (
 	"cmd/internal/obj"
 	"cmd/internal/src"
 	"fmt"
+	"go/constant"
 	"strings"
 )
 
@@ -637,7 +638,7 @@ func interfacefield(n *Node) *types.Field {
 		Fatalf("interfacefield: oops %v\n", n)
 	}
 
-	if n.Val().Ctype() != CTxxx {
+	if n.Val().Kind() != constant.Unknown {
 		yyerror("interface method cannot have annotation")
 	}
 
diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index 5179b6c05b..15251062b4 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -9,6 +9,7 @@ import (
 	"cmd/internal/bio"
 	"cmd/internal/src"
 	"fmt"
+	"go/constant"
 )
 
 var (
@@ -208,8 +209,8 @@ func dumpasmhdr() {
 		}
 		switch n.Op {
 		case OLITERAL:
-			t := n.Val().Ctype()
-			if t == CTFLT || t == CTCPLX {
+			t := n.Val().Kind()
+			if t == constant.Float || t == constant.Complex {
 				break
 			}
 			fmt.Fprintf(b, "#define const_%s %#v\n", n.Sym.Name, n.Val())
diff --git a/src/cmd/compile/internal/gc/fmt.go b/src/cmd/compile/internal/gc/fmt.go
index 740fdab977..650fb9681e 100644
--- a/src/cmd/compile/internal/gc/fmt.go
+++ b/src/cmd/compile/internal/gc/fmt.go
@@ -556,7 +556,7 @@ func (v Val) vconv(s fmt.State, flag FmtFlag) {
 		fmt.Fprint(s, u)
 
 	default:
-		fmt.Fprintf(s, "<ctype=%d>", v.Ctype())
+		fmt.Fprintf(s, "<ctype=%d>", v.Kind())
 	}
 }
 
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index c3385f785a..d661fca2d1 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -210,6 +210,7 @@ import (
 	"crypto/md5"
 	"encoding/binary"
 	"fmt"
+	"go/constant"
 	"io"
 	"math/big"
 	"sort"
@@ -748,28 +749,28 @@ func (w *exportWriter) param(f *types.Field) {
 	w.typ(f.Type)
 }
 
-func constTypeOf(typ *types.Type) Ctype {
+func constTypeOf(typ *types.Type) constant.Kind {
 	switch typ {
 	case types.UntypedInt, types.UntypedRune:
-		return CTINT
+		return constant.Int
 	case types.UntypedFloat:
-		return CTFLT
+		return constant.Float
 	case types.UntypedComplex:
-		return CTCPLX
+		return constant.Complex
 	}
 
 	switch typ.Etype {
 	case TBOOL:
-		return CTBOOL
+		return constant.Bool
 	case TSTRING:
-		return CTSTR
+		return constant.String
 	case TINT, TINT8, TINT16, TINT32, TINT64,
 		TUINT, TUINT8, TUINT16, TUINT32, TUINT64, TUINTPTR:
-		return CTINT
+		return constant.Int
 	case TFLOAT32, TFLOAT64:
-		return CTFLT
+		return constant.Float
 	case TCOMPLEX64, TCOMPLEX128:
-		return CTCPLX
+		return constant.Complex
 	}
 
 	Fatalf("unexpected constant type: %v", typ)
@@ -786,15 +787,15 @@ func (w *exportWriter) value(typ *types.Type, v Val) {
 	// and provides a useful consistency check.
 
 	switch constTypeOf(typ) {
-	case CTBOOL:
+	case constant.Bool:
 		w.bool(v.U.(bool))
-	case CTSTR:
+	case constant.String:
 		w.string(v.U.(string))
-	case CTINT:
+	case constant.Int:
 		w.mpint(&v.U.(*Mpint).Val, typ)
-	case CTFLT:
+	case constant.Float:
 		w.mpfloat(&v.U.(*Mpflt).Val, typ)
-	case CTCPLX:
+	case constant.Complex:
 		x := v.U.(*Mpcplx)
 		w.mpfloat(&x.Real.Val, typ)
 		w.mpfloat(&x.Imag.Val, typ)
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index fc6b7ecb9f..0fa11c5f59 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -15,6 +15,7 @@ import (
 	"cmd/internal/src"
 	"encoding/binary"
 	"fmt"
+	"go/constant"
 	"io"
 	"math/big"
 	"os"
@@ -357,19 +358,19 @@ func (r *importReader) doDecl(n *Node) {
 
 func (p *importReader) value(typ *types.Type) (v Val) {
 	switch constTypeOf(typ) {
-	case CTBOOL:
+	case constant.Bool:
 		v.U = p.bool()
-	case CTSTR:
+	case constant.String:
 		v.U = p.string()
-	case CTINT:
+	case constant.Int:
 		x := new(Mpint)
 		p.mpint(&x.Val, typ)
 		v.U = x
-	case CTFLT:
+	case constant.Float:
 		x := newMpflt()
 		p.float(x, typ)
 		v.U = x
-	case CTCPLX:
+	case constant.Complex:
 		x := newMpcmplx()
 		p.float(&x.Real, typ)
 		p.float(&x.Imag, typ)
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index a882e91dce..6d07e156ea 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -32,6 +32,7 @@ import (
 	"cmd/internal/obj"
 	"cmd/internal/src"
 	"fmt"
+	"go/constant"
 	"strings"
 )
 
@@ -417,7 +418,7 @@ func (v *hairyVisitor) visit(n *Node) bool {
 		}
 
 	case OIF:
-		if Isconst(n.Left, CTBOOL) {
+		if Isconst(n.Left, constant.Bool) {
 			// This if and the condition cost nothing.
 			return v.visitList(n.Ninit) || v.visitList(n.Nbody) ||
 				v.visitList(n.Rlist)
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 303b04cd46..3ef8583f6d 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"fmt"
+	"go/constant"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -803,7 +804,7 @@ func (p *noder) sum(x syntax.Expr) *Node {
 	chunks := make([]string, 0, 1)
 
 	n := p.expr(x)
-	if Isconst(n, CTSTR) && n.Sym == nil {
+	if Isconst(n, constant.String) && n.Sym == nil {
 		nstr = n
 		chunks = append(chunks, nstr.StringVal())
 	}
@@ -812,7 +813,7 @@ func (p *noder) sum(x syntax.Expr) *Node {
 		add := adds[i]
 
 		r := p.expr(add.Y)
-		if Isconst(r, CTSTR) && r.Sym == nil {
+		if Isconst(r, constant.String) && r.Sym == nil {
 			if nstr != nil {
 				// Collapse r into nstr instead of adding to n.
 				chunks = append(chunks, r.StringVal())
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 77f9afb44d..499b8ef2e5 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -13,6 +13,7 @@ import (
 	"crypto/sha256"
 	"encoding/json"
 	"fmt"
+	"go/constant"
 	"io"
 	"io/ioutil"
 	"os"
@@ -263,7 +264,7 @@ func dumpGlobalConst(n *Node) {
 	case TUINTPTR:
 		// ok
 	case TIDEAL:
-		if !Isconst(n, CTINT) {
+		if !Isconst(n, constant.Int) {
 			return
 		}
 		x := n.Val().U.(*Mpint)
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 709b2d434e..e23a189d71 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"encoding/binary"
 	"fmt"
+	"go/constant"
 	"html"
 	"os"
 	"path/filepath"
@@ -1277,7 +1278,7 @@ func (s *state) stmt(n *Node) {
 			// We're assigning a slicing operation back to its source.
 			// Don't write back fields we aren't changing. See issue #14855.
 			i, j, k := rhs.SliceBounds()
-			if i != nil && (i.Op == OLITERAL && i.Val().Ctype() == CTINT && i.Int64Val() == 0) {
+			if i != nil && (i.Op == OLITERAL && i.Val().Kind() == constant.Int && i.Int64Val() == 0) {
 				// [0:...] is the same as [:...]
 				i = nil
 			}
@@ -1305,7 +1306,7 @@ func (s *state) stmt(n *Node) {
 		s.assign(n.Left, r, deref, skip)
 
 	case OIF:
-		if Isconst(n.Left, CTBOOL) {
+		if Isconst(n.Left, constant.Bool) {
 			s.stmtList(n.Left.Ninit)
 			if n.Left.BoolVal() {
 				s.stmtList(n.Nbody)
@@ -2093,7 +2094,7 @@ func (s *state) expr(n *Node) *ssa.Value {
 			}
 
 		default:
-			s.Fatalf("unhandled OLITERAL %v", n.Val().Ctype())
+			s.Fatalf("unhandled OLITERAL %v", n.Val().Kind())
 			return nil
 		}
 	case OCONVNOP:
@@ -2617,7 +2618,7 @@ func (s *state) expr(n *Node) *ssa.Value {
 	case OINDEX:
 		switch {
 		case n.Left.Type.IsString():
-			if n.Bounded() && Isconst(n.Left, CTSTR) && Isconst(n.Right, CTINT) {
+			if n.Bounded() && Isconst(n.Left, constant.String) && Isconst(n.Right, constant.Int) {
 				// Replace "abc"[1] with 'b'.
 				// Delayed until now because "abc"[1] is not an ideal constant.
 				// See test/fixedbugs/issue11370.go.
@@ -2629,7 +2630,7 @@ func (s *state) expr(n *Node) *ssa.Value {
 			i = s.boundsCheck(i, len, ssa.BoundsIndex, n.Bounded())
 			ptrtyp := s.f.Config.Types.BytePtr
 			ptr := s.newValue1(ssa.OpStringPtr, ptrtyp, a)
-			if Isconst(n.Right, CTINT) {
+			if Isconst(n.Right, constant.Int) {
 				ptr = s.newValue1I(ssa.OpOffPtr, ptrtyp, n.Right.Int64Val(), ptr)
 			} else {
 				ptr = s.newValue2(ssa.OpAddPtr, ptrtyp, ptr, i)
diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index 5f4e9e4b40..068f1a34e1 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
+	"go/constant"
 	"sort"
 )
 
@@ -442,7 +443,7 @@ func (c *exprClause) test(exprname *Node) *Node {
 	}
 
 	// Optimize "switch true { ...}" and "switch false { ... }".
-	if Isconst(exprname, CTBOOL) && !c.lo.Type.IsInterface() {
+	if Isconst(exprname, constant.Bool) && !c.lo.Type.IsInterface() {
 		if exprname.BoolVal() {
 			return c.lo
 		} else {
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 3fb59c8deb..11c1ae38ea 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"cmd/compile/internal/types"
 	"fmt"
+	"go/constant"
 	"strings"
 )
 
@@ -359,7 +360,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 	case OLITERAL:
 		ok |= ctxExpr
 
-		if n.Type == nil && n.Val().Ctype() == CTSTR {
+		if n.Type == nil && n.Val().Kind() == constant.String {
 			n.Type = types.UntypedString
 		}
 
@@ -425,7 +426,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		} else {
 			n.Left = indexlit(typecheck(n.Left, ctxExpr))
 			l := n.Left
-			if consttype(l) != CTINT {
+			if consttype(l) != constant.Int {
 				switch {
 				case l.Type == nil:
 					// Error already reported elsewhere.
@@ -802,7 +803,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			n.Right = nil
 		}
 
-		if (op == ODIV || op == OMOD) && Isconst(r, CTINT) {
+		if (op == ODIV || op == OMOD) && Isconst(r, constant.Int) {
 			if r.Val().U.(*Mpint).CmpInt64(0) == 0 {
 				yyerror("division by zero")
 				n.Type = nil
@@ -1044,15 +1045,15 @@ func typecheck1(n *Node, top int) (res *Node) {
 				break
 			}
 
-			if !n.Bounded() && Isconst(n.Right, CTINT) {
+			if !n.Bounded() && Isconst(n.Right, constant.Int) {
 				x := n.Right.Int64Val()
 				if x < 0 {
 					yyerror("invalid %s index %v (index must be non-negative)", why, n.Right)
 				} else if t.IsArray() && x >= t.NumElem() {
 					yyerror("invalid array index %v (out of bounds for %d-element array)", n.Right, t.NumElem())
-				} else if Isconst(n.Left, CTSTR) && x >= int64(len(n.Left.StringVal())) {
+				} else if Isconst(n.Left, constant.String) && x >= int64(len(n.Left.StringVal())) {
 					yyerror("invalid string index %v (out of bounds for %d-byte string)", n.Right, len(n.Left.StringVal()))
-				} else if n.Right.Val().U.(*Mpint).Cmp(maxintval[TINT]) > 0 {
+				} else if doesoverflow(n.Right.Val(), types.Types[TINT]) {
 					yyerror("invalid %s index %v (index too large)", why, n.Right)
 				}
 			}
@@ -1147,15 +1148,15 @@ func typecheck1(n *Node, top int) (res *Node) {
 		l = defaultlit(l, types.Types[TINT])
 		c = defaultlit(c, types.Types[TINT])
 
-		if Isconst(l, CTINT) && l.Int64Val() < 0 {
+		if Isconst(l, constant.Int) && l.Int64Val() < 0 {
 			Fatalf("len for OSLICEHEADER must be non-negative")
 		}
 
-		if Isconst(c, CTINT) && c.Int64Val() < 0 {
+		if Isconst(c, constant.Int) && c.Int64Val() < 0 {
 			Fatalf("cap for OSLICEHEADER must be non-negative")
 		}
 
-		if Isconst(l, CTINT) && Isconst(c, CTINT) && l.Val().U.(*Mpint).Cmp(c.Val().U.(*Mpint)) > 0 {
+		if Isconst(l, constant.Int) && Isconst(c, constant.Int) && compareOp(l.Val(), OGT, c.Val()) {
 			Fatalf("len larger than cap for OSLICEHEADER")
 		}
 
@@ -1196,8 +1197,8 @@ func typecheck1(n *Node, top int) (res *Node) {
 			yyerror("non-integer len argument in OMAKESLICECOPY")
 		}
 
-		if Isconst(n.Left, CTINT) {
-			if n.Left.Val().U.(*Mpint).Cmp(maxintval[TINT]) > 0 {
+		if Isconst(n.Left, constant.Int) {
+			if doesoverflow(n.Left.Val(), types.Types[TINT]) {
 				Fatalf("len for OMAKESLICECOPY too large")
 			}
 			if n.Left.Int64Val() < 0 {
@@ -1773,7 +1774,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 				n.Type = nil
 				return n
 			}
-			if Isconst(l, CTINT) && r != nil && Isconst(r, CTINT) && l.Val().U.(*Mpint).Cmp(r.Val().U.(*Mpint)) > 0 {
+			if Isconst(l, constant.Int) && r != nil && Isconst(r, constant.Int) && compareOp(l.Val(), OGT, r.Val()) {
 				yyerror("len larger than cap in make(%v)", t)
 				n.Type = nil
 				return n
@@ -1865,7 +1866,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		ls := n.List.Slice()
 		for i1, n1 := range ls {
 			// Special case for print: int constant is int64, not int.
-			if Isconst(n1, CTINT) {
+			if Isconst(n1, constant.Int) {
 				ls[i1] = defaultlit(ls[i1], types.Types[TINT64])
 			} else {
 				ls[i1] = defaultlit(ls[i1], nil)
@@ -2187,10 +2188,10 @@ func checksliceindex(l *Node, r *Node, tp *types.Type) bool {
 		} else if tp != nil && tp.NumElem() >= 0 && r.Int64Val() > tp.NumElem() {
 			yyerror("invalid slice index %v (out of bounds for %d-element array)", r, tp.NumElem())
 			return false
-		} else if Isconst(l, CTSTR) && r.Int64Val() > int64(len(l.StringVal())) {
+		} else if Isconst(l, constant.String) && r.Int64Val() > int64(len(l.StringVal())) {
 			yyerror("invalid slice index %v (out of bounds for %d-byte string)", r, len(l.StringVal()))
 			return false
-		} else if r.Val().U.(*Mpint).Cmp(maxintval[TINT]) > 0 {
+		} else if doesoverflow(r.Val(), types.Types[TINT]) {
 			yyerror("invalid slice index %v (index too large)", r)
 			return false
 		}
@@ -2200,7 +2201,7 @@ func checksliceindex(l *Node, r *Node, tp *types.Type) bool {
 }
 
 func checksliceconst(lo *Node, hi *Node) bool {
-	if lo != nil && hi != nil && lo.Op == OLITERAL && hi.Op == OLITERAL && lo.Val().U.(*Mpint).Cmp(hi.Val().U.(*Mpint)) > 0 {
+	if lo != nil && hi != nil && lo.Op == OLITERAL && hi.Op == OLITERAL && compareOp(lo.Val(), OGT, hi.Val()) {
 		yyerror("invalid slice index: %v > %v", lo, hi)
 		return false
 	}
@@ -3431,7 +3432,7 @@ func typecheckfunc(n *Node) {
 // The result of stringtoruneslit MUST be assigned back to n, e.g.
 // 	n.Left = stringtoruneslit(n.Left)
 func stringtoruneslit(n *Node) *Node {
-	if n.Left.Op != OLITERAL || n.Left.Val().Ctype() != CTSTR {
+	if n.Left.Op != OLITERAL || n.Left.Val().Kind() != constant.String {
 		Fatalf("stringtoarraylit %v", n)
 	}
 
@@ -3724,7 +3725,7 @@ func checkmake(t *types.Type, arg string, np **Node) bool {
 	// Do range checks for constants before defaultlit
 	// to avoid redundant "constant NNN overflows int" errors.
 	switch consttype(n) {
-	case CTINT, CTFLT, CTCPLX:
+	case constant.Int, constant.Float, constant.Complex:
 		v := toint(n.Val()).U.(*Mpint)
 		if v.CmpInt64(0) < 0 {
 			yyerror("negative %s argument in make(%v)", arg, t)
@@ -3885,11 +3886,11 @@ func deadcodefn(fn *Node) {
 		}
 		switch n.Op {
 		case OIF:
-			if !Isconst(n.Left, CTBOOL) || n.Nbody.Len() > 0 || n.Rlist.Len() > 0 {
+			if !Isconst(n.Left, constant.Bool) || n.Nbody.Len() > 0 || n.Rlist.Len() > 0 {
 				return
 			}
 		case OFOR:
-			if !Isconst(n.Left, CTBOOL) || n.Left.BoolVal() {
+			if !Isconst(n.Left, constant.Bool) || n.Left.BoolVal() {
 				return
 			}
 		default:
@@ -3917,7 +3918,7 @@ func deadcodeslice(nn *Nodes) {
 		}
 		if n.Op == OIF {
 			n.Left = deadcodeexpr(n.Left)
-			if Isconst(n.Left, CTBOOL) {
+			if Isconst(n.Left, constant.Bool) {
 				var body Nodes
 				if n.Left.BoolVal() {
 					n.Rlist = Nodes{}
@@ -3961,7 +3962,7 @@ func deadcodeexpr(n *Node) *Node {
 	case OANDAND:
 		n.Left = deadcodeexpr(n.Left)
 		n.Right = deadcodeexpr(n.Right)
-		if Isconst(n.Left, CTBOOL) {
+		if Isconst(n.Left, constant.Bool) {
 			if n.Left.BoolVal() {
 				return n.Right // true && x => x
 			} else {
@@ -3971,7 +3972,7 @@ func deadcodeexpr(n *Node) *Node {
 	case OOROR:
 		n.Left = deadcodeexpr(n.Left)
 		n.Right = deadcodeexpr(n.Right)
-		if Isconst(n.Left, CTBOOL) {
+		if Isconst(n.Left, constant.Bool) {
 			if n.Left.BoolVal() {
 				return n.Left // true || x => true
 			} else {
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index e7351d1792..4bbc58ce13 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -11,6 +11,7 @@ import (
 	"cmd/internal/sys"
 	"encoding/binary"
 	"fmt"
+	"go/constant"
 	"strings"
 )
 
@@ -1045,15 +1046,15 @@ opswitch:
 		}
 		if t.IsArray() {
 			n.SetBounded(bounded(r, t.NumElem()))
-			if Debug.m != 0 && n.Bounded() && !Isconst(n.Right, CTINT) {
+			if Debug.m != 0 && n.Bounded() && !Isconst(n.Right, constant.Int) {
 				Warn("index bounds check elided")
 			}
 			if smallintconst(n.Right) && !n.Bounded() {
 				yyerror("index out of bounds")
 			}
-		} else if Isconst(n.Left, CTSTR) {
+		} else if Isconst(n.Left, constant.String) {
 			n.SetBounded(bounded(r, int64(len(n.Left.StringVal()))))
-			if Debug.m != 0 && n.Bounded() && !Isconst(n.Right, CTINT) {
+			if Debug.m != 0 && n.Bounded() && !Isconst(n.Right, constant.Int) {
 				Warn("index bounds check elided")
 			}
 			if smallintconst(n.Right) && !n.Bounded() {
@@ -1061,8 +1062,8 @@ opswitch:
 			}
 		}
 
-		if Isconst(n.Right, CTINT) {
-			if n.Right.Val().U.(*Mpint).CmpInt64(0) < 0 || n.Right.Val().U.(*Mpint).Cmp(maxintval[TINT]) > 0 {
+		if Isconst(n.Right, constant.Int) {
+			if n.Right.Val().U.(*Mpint).CmpInt64(0) < 0 || doesoverflow(n.Right.Val(), types.Types[TINT]) {
 				yyerror("index out of bounds")
 			}
 		}
@@ -1192,7 +1193,7 @@ opswitch:
 		// Type checking guarantees that TIDEAL size is positive and fits in an int.
 		// The case of size overflow when converting TUINT or TUINTPTR to TINT
 		// will be handled by the negative range checks in makechan during runtime.
-		if size.Type.IsKind(TIDEAL) || maxintval[size.Type.Etype].Cmp(maxintval[TUINT]) <= 0 {
+		if size.Type.IsKind(TIDEAL) || size.Type.Size() <= types.Types[TUINT].Size() {
 			fnname = "makechan"
 			argtype = types.Types[TINT]
 		}
@@ -1222,7 +1223,7 @@ opswitch:
 			// BUCKETSIZE runtime.makemap will allocate the buckets on the heap.
 			// Maximum key and elem size is 128 bytes, larger objects
 			// are stored with an indirection. So max bucket size is 2048+eps.
-			if !Isconst(hint, CTINT) ||
+			if !Isconst(hint, constant.Int) ||
 				hint.Val().U.(*Mpint).CmpInt64(BUCKETSIZE) <= 0 {
 
 				// In case hint is larger than BUCKETSIZE runtime.makemap
@@ -1256,7 +1257,7 @@ opswitch:
 			}
 		}
 
-		if Isconst(hint, CTINT) && hint.Val().U.(*Mpint).CmpInt64(BUCKETSIZE) <= 0 {
+		if Isconst(hint, constant.Int) && hint.Val().U.(*Mpint).CmpInt64(BUCKETSIZE) <= 0 {
 			// Handling make(map[any]any) and
 			// make(map[any]any, hint) where hint <= BUCKETSIZE
 			// special allows for faster map initialization and
@@ -1300,7 +1301,7 @@ opswitch:
 			// See checkmake call in TMAP case of OMAKE case in OpSwitch in typecheck1 function.
 			// The case of hint overflow when converting TUINT or TUINTPTR to TINT
 			// will be handled by the negative range checks in makemap during runtime.
-			if hint.Type.IsKind(TIDEAL) || maxintval[hint.Type.Etype].Cmp(maxintval[TUINT]) <= 0 {
+			if hint.Type.IsKind(TIDEAL) || hint.Type.Size() <= types.Types[TUINT].Size() {
 				fnname = "makemap"
 				argtype = types.Types[TINT]
 			}
@@ -1370,8 +1371,8 @@ opswitch:
 			// Type checking guarantees that TIDEAL len/cap are positive and fit in an int.
 			// The case of len or cap overflow when converting TUINT or TUINTPTR to TINT
 			// will be handled by the negative range checks in makeslice during runtime.
-			if (len.Type.IsKind(TIDEAL) || maxintval[len.Type.Etype].Cmp(maxintval[TUINT]) <= 0) &&
-				(cap.Type.IsKind(TIDEAL) || maxintval[cap.Type.Etype].Cmp(maxintval[TUINT]) <= 0) {
+			if (len.Type.IsKind(TIDEAL) || len.Type.Size() <= types.Types[TUINT].Size()) &&
+				(cap.Type.IsKind(TIDEAL) || cap.Type.Size() <= types.Types[TUINT].Size()) {
 				fnname = "makeslice"
 				argtype = types.Types[TINT]
 			}
@@ -1486,7 +1487,7 @@ opswitch:
 
 	case OSTR2BYTES:
 		s := n.Left
-		if Isconst(s, CTSTR) {
+		if Isconst(s, constant.String) {
 			sc := s.StringVal()
 
 			// Allocate a [n]byte of the right size.
@@ -1914,7 +1915,7 @@ func walkprint(nn *Node, init *Nodes) *Node {
 	t := make([]*Node, 0, len(s))
 	for i := 0; i < len(s); {
 		var strs []string
-		for i < len(s) && Isconst(s[i], CTSTR) {
+		for i < len(s) && Isconst(s[i], constant.String) {
 			strs = append(strs, s[i].StringVal())
 			i++
 		}
@@ -1935,11 +1936,11 @@ func walkprint(nn *Node, init *Nodes) *Node {
 				n = defaultlit(n, types.Runetype)
 			}
 
-			switch n.Val().Ctype() {
-			case CTINT:
+			switch n.Val().Kind() {
+			case constant.Int:
 				n = defaultlit(n, types.Types[TINT64])
 
-			case CTFLT:
+			case constant.Float:
 				n = defaultlit(n, types.Types[TFLOAT64])
 			}
 		}
@@ -1994,7 +1995,7 @@ func walkprint(nn *Node, init *Nodes) *Node {
 			on = syslook("printbool")
 		case TSTRING:
 			cs := ""
-			if Isconst(n, CTSTR) {
+			if Isconst(n, constant.String) {
 				cs = n.StringVal()
 			}
 			switch cs {
@@ -2850,7 +2851,7 @@ func isAppendOfMake(n *Node) bool {
 
 	// The care of overflow of the len argument to make will be handled by an explicit check of int(len) < 0 during runtime.
 	y := second.Left
-	if !Isconst(y, CTINT) && maxintval[y.Type.Etype].Cmp(maxintval[TUINT]) > 0 {
+	if !Isconst(y, constant.Int) && y.Type.Size() > types.Types[TUINT].Size() {
 		return false
 	}
 
@@ -3471,12 +3472,12 @@ func walkcompareString(n *Node, init *Nodes) *Node {
 	// Rewrite comparisons to short constant strings as length+byte-wise comparisons.
 	var cs, ncs *Node // const string, non-const string
 	switch {
-	case Isconst(n.Left, CTSTR) && Isconst(n.Right, CTSTR):
+	case Isconst(n.Left, constant.String) && Isconst(n.Right, constant.String):
 		// ignore; will be constant evaluated
-	case Isconst(n.Left, CTSTR):
+	case Isconst(n.Left, constant.String):
 		cs = n.Left
 		ncs = n.Right
-	case Isconst(n.Right, CTSTR):
+	case Isconst(n.Right, constant.String):
 		cs = n.Right
 		ncs = n.Left
 	}
@@ -3485,7 +3486,7 @@ func walkcompareString(n *Node, init *Nodes) *Node {
 		// Our comparison below assumes that the non-constant string
 		// is on the left hand side, so rewrite "" cmp x to x cmp "".
 		// See issue 24817.
-		if Isconst(n.Left, CTSTR) {
+		if Isconst(n.Left, constant.String) {
 			cmp = brrev(cmp)
 		}
 
@@ -3841,17 +3842,17 @@ func candiscard(n *Node) bool {
 
 		// Discardable as long as we know it's not division by zero.
 	case ODIV, OMOD:
-		if Isconst(n.Right, CTINT) && n.Right.Val().U.(*Mpint).CmpInt64(0) != 0 {
+		if Isconst(n.Right, constant.Int) && n.Right.Val().U.(*Mpint).CmpInt64(0) != 0 {
 			break
 		}
-		if Isconst(n.Right, CTFLT) && n.Right.Val().U.(*Mpflt).CmpFloat64(0) != 0 {
+		if Isconst(n.Right, constant.Float) && n.Right.Val().U.(*Mpflt).CmpFloat64(0) != 0 {
 			break
 		}
 		return false
 
 		// Discardable as long as we know it won't fail because of a bad size.
 	case OMAKECHAN, OMAKEMAP:
-		if Isconst(n.Left, CTINT) && n.Left.Val().U.(*Mpint).CmpInt64(0) == 0 {
+		if Isconst(n.Left, constant.Int) && n.Left.Val().U.(*Mpint).CmpInt64(0) == 0 {
 			break
 		}
 		return false
-- 
GitLab


From 8e2106327cf27b2d281a3e4432fcae552d4b29aa Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 18 Nov 2020 15:14:24 -0500
Subject: [PATCH 0049/2400] [dev.regabi] cmd/compile: clean up tests to know
 less about Node

We want to refactor a bit, and these tests know too much about
the layout of Nodes. Use standard constructors instead.

Change-Id: I91f0325c89ea60086655414468c53419ebeacea4
Reviewed-on: https://go-review.googlesource.com/c/go/+/272626
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/gc/pgen_test.go | 147 ++++++++++++-----------
 1 file changed, 79 insertions(+), 68 deletions(-)

diff --git a/src/cmd/compile/internal/gc/pgen_test.go b/src/cmd/compile/internal/gc/pgen_test.go
index b1db29825c..932ab47d02 100644
--- a/src/cmd/compile/internal/gc/pgen_test.go
+++ b/src/cmd/compile/internal/gc/pgen_test.go
@@ -35,106 +35,110 @@ func markNeedZero(n *Node) *Node {
 	return n
 }
 
-func nodeWithClass(n Node, c Class) *Node {
-	n.SetClass(c)
-	n.Name = new(Name)
-	return &n
-}
-
 // Test all code paths for cmpstackvarlt.
 func TestCmpstackvar(t *testing.T) {
+	nod := func(xoffset int64, t *types.Type, s *types.Sym, cl Class) *Node {
+		if s == nil {
+			s = &types.Sym{Name: "."}
+		}
+		n := newname(s)
+		n.Type = t
+		n.Xoffset = xoffset
+		n.SetClass(cl)
+		return n
+	}
 	testdata := []struct {
 		a, b *Node
 		lt   bool
 	}{
 		{
-			nodeWithClass(Node{}, PAUTO),
-			nodeWithClass(Node{}, PFUNC),
+			nod(0, nil, nil, PAUTO),
+			nod(0, nil, nil, PFUNC),
 			false,
 		},
 		{
-			nodeWithClass(Node{}, PFUNC),
-			nodeWithClass(Node{}, PAUTO),
+			nod(0, nil, nil, PFUNC),
+			nod(0, nil, nil, PAUTO),
 			true,
 		},
 		{
-			nodeWithClass(Node{Xoffset: 0}, PFUNC),
-			nodeWithClass(Node{Xoffset: 10}, PFUNC),
+			nod(0, nil, nil, PFUNC),
+			nod(10, nil, nil, PFUNC),
 			true,
 		},
 		{
-			nodeWithClass(Node{Xoffset: 20}, PFUNC),
-			nodeWithClass(Node{Xoffset: 10}, PFUNC),
+			nod(20, nil, nil, PFUNC),
+			nod(10, nil, nil, PFUNC),
 			false,
 		},
 		{
-			nodeWithClass(Node{Xoffset: 10}, PFUNC),
-			nodeWithClass(Node{Xoffset: 10}, PFUNC),
+			nod(10, nil, nil, PFUNC),
+			nod(10, nil, nil, PFUNC),
 			false,
 		},
 		{
-			nodeWithClass(Node{Xoffset: 10}, PPARAM),
-			nodeWithClass(Node{Xoffset: 20}, PPARAMOUT),
+			nod(10, nil, nil, PPARAM),
+			nod(20, nil, nil, PPARAMOUT),
 			true,
 		},
 		{
-			nodeWithClass(Node{Xoffset: 10}, PPARAMOUT),
-			nodeWithClass(Node{Xoffset: 20}, PPARAM),
+			nod(10, nil, nil, PPARAMOUT),
+			nod(20, nil, nil, PPARAM),
 			true,
 		},
 		{
-			markUsed(nodeWithClass(Node{}, PAUTO)),
-			nodeWithClass(Node{}, PAUTO),
+			markUsed(nod(0, nil, nil, PAUTO)),
+			nod(0, nil, nil, PAUTO),
 			true,
 		},
 		{
-			nodeWithClass(Node{}, PAUTO),
-			markUsed(nodeWithClass(Node{}, PAUTO)),
+			nod(0, nil, nil, PAUTO),
+			markUsed(nod(0, nil, nil, PAUTO)),
 			false,
 		},
 		{
-			nodeWithClass(Node{Type: typeWithoutPointers()}, PAUTO),
-			nodeWithClass(Node{Type: typeWithPointers()}, PAUTO),
+			nod(0, typeWithoutPointers(), nil, PAUTO),
+			nod(0, typeWithPointers(), nil, PAUTO),
 			false,
 		},
 		{
-			nodeWithClass(Node{Type: typeWithPointers()}, PAUTO),
-			nodeWithClass(Node{Type: typeWithoutPointers()}, PAUTO),
+			nod(0, typeWithPointers(), nil, PAUTO),
+			nod(0, typeWithoutPointers(), nil, PAUTO),
 			true,
 		},
 		{
-			markNeedZero(nodeWithClass(Node{Type: &types.Type{}}, PAUTO)),
-			nodeWithClass(Node{Type: &types.Type{}, Name: &Name{}}, PAUTO),
+			markNeedZero(nod(0, &types.Type{}, nil, PAUTO)),
+			nod(0, &types.Type{}, nil, PAUTO),
 			true,
 		},
 		{
-			nodeWithClass(Node{Type: &types.Type{}, Name: &Name{}}, PAUTO),
-			markNeedZero(nodeWithClass(Node{Type: &types.Type{}}, PAUTO)),
+			nod(0, &types.Type{}, nil, PAUTO),
+			markNeedZero(nod(0, &types.Type{}, nil, PAUTO)),
 			false,
 		},
 		{
-			nodeWithClass(Node{Type: &types.Type{Width: 1}, Name: &Name{}}, PAUTO),
-			nodeWithClass(Node{Type: &types.Type{Width: 2}, Name: &Name{}}, PAUTO),
+			nod(0, &types.Type{Width: 1}, nil, PAUTO),
+			nod(0, &types.Type{Width: 2}, nil, PAUTO),
 			false,
 		},
 		{
-			nodeWithClass(Node{Type: &types.Type{Width: 2}, Name: &Name{}}, PAUTO),
-			nodeWithClass(Node{Type: &types.Type{Width: 1}, Name: &Name{}}, PAUTO),
+			nod(0, &types.Type{Width: 2}, nil, PAUTO),
+			nod(0, &types.Type{Width: 1}, nil, PAUTO),
 			true,
 		},
 		{
-			nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "abc"}}, PAUTO),
-			nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "xyz"}}, PAUTO),
+			nod(0, &types.Type{}, &types.Sym{Name: "abc"}, PAUTO),
+			nod(0, &types.Type{}, &types.Sym{Name: "xyz"}, PAUTO),
 			true,
 		},
 		{
-			nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "abc"}}, PAUTO),
-			nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "abc"}}, PAUTO),
+			nod(0, &types.Type{}, &types.Sym{Name: "abc"}, PAUTO),
+			nod(0, &types.Type{}, &types.Sym{Name: "abc"}, PAUTO),
 			false,
 		},
 		{
-			nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "xyz"}}, PAUTO),
-			nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "abc"}}, PAUTO),
+			nod(0, &types.Type{}, &types.Sym{Name: "xyz"}, PAUTO),
+			nod(0, &types.Type{}, &types.Sym{Name: "abc"}, PAUTO),
 			false,
 		},
 	}
@@ -151,35 +155,42 @@ func TestCmpstackvar(t *testing.T) {
 }
 
 func TestStackvarSort(t *testing.T) {
+	nod := func(xoffset int64, t *types.Type, s *types.Sym, cl Class) *Node {
+		n := newname(s)
+		n.Type = t
+		n.Xoffset = xoffset
+		n.SetClass(cl)
+		return n
+	}
 	inp := []*Node{
-		nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{}}, PFUNC),
-		nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{}}, PAUTO),
-		nodeWithClass(Node{Xoffset: 0, Type: &types.Type{}, Sym: &types.Sym{}}, PFUNC),
-		nodeWithClass(Node{Xoffset: 10, Type: &types.Type{}, Sym: &types.Sym{}}, PFUNC),
-		nodeWithClass(Node{Xoffset: 20, Type: &types.Type{}, Sym: &types.Sym{}}, PFUNC),
-		markUsed(nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{}}, PAUTO)),
-		nodeWithClass(Node{Type: typeWithoutPointers(), Sym: &types.Sym{}}, PAUTO),
-		nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{}}, PAUTO),
-		markNeedZero(nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{}}, PAUTO)),
-		nodeWithClass(Node{Type: &types.Type{Width: 1}, Sym: &types.Sym{}}, PAUTO),
-		nodeWithClass(Node{Type: &types.Type{Width: 2}, Sym: &types.Sym{}}, PAUTO),
-		nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "abc"}}, PAUTO),
-		nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "xyz"}}, PAUTO),
+		nod(0, &types.Type{}, &types.Sym{}, PFUNC),
+		nod(0, &types.Type{}, &types.Sym{}, PAUTO),
+		nod(0, &types.Type{}, &types.Sym{}, PFUNC),
+		nod(10, &types.Type{}, &types.Sym{}, PFUNC),
+		nod(20, &types.Type{}, &types.Sym{}, PFUNC),
+		markUsed(nod(0, &types.Type{}, &types.Sym{}, PAUTO)),
+		nod(0, typeWithoutPointers(), &types.Sym{}, PAUTO),
+		nod(0, &types.Type{}, &types.Sym{}, PAUTO),
+		markNeedZero(nod(0, &types.Type{}, &types.Sym{}, PAUTO)),
+		nod(0, &types.Type{Width: 1}, &types.Sym{}, PAUTO),
+		nod(0, &types.Type{Width: 2}, &types.Sym{}, PAUTO),
+		nod(0, &types.Type{}, &types.Sym{Name: "abc"}, PAUTO),
+		nod(0, &types.Type{}, &types.Sym{Name: "xyz"}, PAUTO),
 	}
 	want := []*Node{
-		nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{}}, PFUNC),
-		nodeWithClass(Node{Xoffset: 0, Type: &types.Type{}, Sym: &types.Sym{}}, PFUNC),
-		nodeWithClass(Node{Xoffset: 10, Type: &types.Type{}, Sym: &types.Sym{}}, PFUNC),
-		nodeWithClass(Node{Xoffset: 20, Type: &types.Type{}, Sym: &types.Sym{}}, PFUNC),
-		markUsed(nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{}}, PAUTO)),
-		markNeedZero(nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{}}, PAUTO)),
-		nodeWithClass(Node{Type: &types.Type{Width: 2}, Sym: &types.Sym{}}, PAUTO),
-		nodeWithClass(Node{Type: &types.Type{Width: 1}, Sym: &types.Sym{}}, PAUTO),
-		nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{}}, PAUTO),
-		nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{}}, PAUTO),
-		nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "abc"}}, PAUTO),
-		nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "xyz"}}, PAUTO),
-		nodeWithClass(Node{Type: typeWithoutPointers(), Sym: &types.Sym{}}, PAUTO),
+		nod(0, &types.Type{}, &types.Sym{}, PFUNC),
+		nod(0, &types.Type{}, &types.Sym{}, PFUNC),
+		nod(10, &types.Type{}, &types.Sym{}, PFUNC),
+		nod(20, &types.Type{}, &types.Sym{}, PFUNC),
+		markUsed(nod(0, &types.Type{}, &types.Sym{}, PAUTO)),
+		markNeedZero(nod(0, &types.Type{}, &types.Sym{}, PAUTO)),
+		nod(0, &types.Type{Width: 2}, &types.Sym{}, PAUTO),
+		nod(0, &types.Type{Width: 1}, &types.Sym{}, PAUTO),
+		nod(0, &types.Type{}, &types.Sym{}, PAUTO),
+		nod(0, &types.Type{}, &types.Sym{}, PAUTO),
+		nod(0, &types.Type{}, &types.Sym{Name: "abc"}, PAUTO),
+		nod(0, &types.Type{}, &types.Sym{Name: "xyz"}, PAUTO),
+		nod(0, typeWithoutPointers(), &types.Sym{}, PAUTO),
 	}
 	sort.Sort(byStackVar(inp))
 	if !reflect.DeepEqual(want, inp) {
-- 
GitLab


From fd11a32c92a2621c6f52edec2a0339f4b7d794e8 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 16 Nov 2020 17:00:10 -0500
Subject: [PATCH 0050/2400] [dev.regabi] cmd/compile: clean up Node.Func

The original meaning of type Func was "extra fields factored out
of a few cases of type Node having to do with functions",
but those specific cases didn't necessarily have any relation.
A typical declared function is represented by an ODCLFUNC Node
at its declaration and an ONAME node at its uses, and both those
have a .Func field, but they are *different* Funcs.
Similarly, a closure is represented both by an OCLOSURE Node for
the value itself and an ODCLFUNC Node for the underlying function
implementing the closure. Those too have *different* Funcs,
and the Func.Closure field in one points to the other and vice versa.
This has led to no end of confusion over the years.

This CL elevates type Func to be the canonical identifier for
a given Go function.

This looks like a trivial CL but in fact is the result of a lot of
scaffolding and rewriting, discarded once the result was achieved, to
separate out the three different kinds of Func nodes into three
separate fields, limited in use to each specific Node type, to
understand which Func fields are used by which Node types and what the
possible overlaps are. There were a few overlaps, most notably around
closures, which led to more fields being added to type Func to keep
them separate even though there is now a single Func instead of two
different ones for each function.

A future CL can and should change Curfn to be a *Func instead of
a *Node, finally eliminating the confusion about whether Curfn
is an ODCLFUNC node (as it is most of the time) or an ONAME node
(as it is when type-checking an inlined function body).

Although sizeof_test.go makes it look like Func is growing by two
words, there are now half as many Funcs in a running compilation,
so the memory footprint has actually been reduced substantially.

Change-Id: I598bd96c95728093dc769a835d48f2154a406a61
Reviewed-on: https://go-review.googlesource.com/c/go/+/272253
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/closure.go     | 155 ++++++++++-----------
 src/cmd/compile/internal/gc/dcl.go         |  20 +--
 src/cmd/compile/internal/gc/esc.go         |   5 +-
 src/cmd/compile/internal/gc/escape.go      |   6 +-
 src/cmd/compile/internal/gc/fmt.go         |  12 +-
 src/cmd/compile/internal/gc/gen.go         |   2 +-
 src/cmd/compile/internal/gc/iimport.go     |   2 +-
 src/cmd/compile/internal/gc/initorder.go   |   2 +-
 src/cmd/compile/internal/gc/inl.go         |  10 +-
 src/cmd/compile/internal/gc/main.go        |   6 +-
 src/cmd/compile/internal/gc/noder.go       |   2 +-
 src/cmd/compile/internal/gc/order.go       |   2 +-
 src/cmd/compile/internal/gc/pgen.go        |  65 ++++++---
 src/cmd/compile/internal/gc/scc.go         |   2 +-
 src/cmd/compile/internal/gc/sinit.go       |   2 +-
 src/cmd/compile/internal/gc/sizeof_test.go |   2 +-
 src/cmd/compile/internal/gc/subr.go        |   3 +-
 src/cmd/compile/internal/gc/syntax.go      |  86 ++++++------
 src/cmd/compile/internal/gc/walk.go        |   7 +-
 19 files changed, 210 insertions(+), 181 deletions(-)

diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index dd6640667d..577d6565f5 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -15,25 +15,25 @@ func (p *noder) funcLit(expr *syntax.FuncLit) *Node {
 	xtype := p.typeExpr(expr.Type)
 	ntype := p.typeExpr(expr.Type)
 
-	xfunc := p.nod(expr, ODCLFUNC, nil, nil)
-	xfunc.Func.SetIsHiddenClosure(Curfn != nil)
-	xfunc.Func.Nname = newfuncnamel(p.pos(expr), nblank.Sym) // filled in by typecheckclosure
-	xfunc.Func.Nname.Name.Param.Ntype = xtype
-	xfunc.Func.Nname.Name.Defn = xfunc
+	dcl := p.nod(expr, ODCLFUNC, nil, nil)
+	fn := dcl.Func
+	fn.SetIsHiddenClosure(Curfn != nil)
+	fn.Nname = newfuncnamel(p.pos(expr), nblank.Sym, fn) // filled in by typecheckclosure
+	fn.Nname.Name.Param.Ntype = xtype
+	fn.Nname.Name.Defn = dcl
 
 	clo := p.nod(expr, OCLOSURE, nil, nil)
-	clo.Func.Ntype = ntype
+	clo.Func = fn
+	fn.ClosureType = ntype
+	fn.OClosure = clo
 
-	xfunc.Func.Closure = clo
-	clo.Func.Closure = xfunc
-
-	p.funcBody(xfunc, expr.Body)
+	p.funcBody(dcl, expr.Body)
 
 	// closure-specific variables are hanging off the
 	// ordinary ones in the symbol table; see oldname.
 	// unhook them.
 	// make the list of pointers for the closure call.
-	for _, v := range xfunc.Func.Cvars.Slice() {
+	for _, v := range fn.ClosureVars.Slice() {
 		// Unlink from v1; see comment in syntax.go type Param for these fields.
 		v1 := v.Name.Defn
 		v1.Name.Param.Innermost = v.Name.Param.Outer
@@ -77,25 +77,26 @@ func (p *noder) funcLit(expr *syntax.FuncLit) *Node {
 // TODO: This creation of the named function should probably really be done in a
 // separate pass from type-checking.
 func typecheckclosure(clo *Node, top int) {
-	xfunc := clo.Func.Closure
+	fn := clo.Func
+	dcl := fn.Decl
 	// Set current associated iota value, so iota can be used inside
 	// function in ConstSpec, see issue #22344
 	if x := getIotaValue(); x >= 0 {
-		xfunc.SetIota(x)
+		dcl.SetIota(x)
 	}
 
-	clo.Func.Ntype = typecheck(clo.Func.Ntype, ctxType)
-	clo.Type = clo.Func.Ntype.Type
-	clo.Func.Top = top
+	fn.ClosureType = typecheck(fn.ClosureType, ctxType)
+	clo.Type = fn.ClosureType.Type
+	fn.ClosureCalled = top&ctxCallee != 0
 
-	// Do not typecheck xfunc twice, otherwise, we will end up pushing
-	// xfunc to xtop multiple times, causing initLSym called twice.
+	// Do not typecheck dcl twice, otherwise, we will end up pushing
+	// dcl to xtop multiple times, causing initLSym called twice.
 	// See #30709
-	if xfunc.Typecheck() == 1 {
+	if dcl.Typecheck() == 1 {
 		return
 	}
 
-	for _, ln := range xfunc.Func.Cvars.Slice() {
+	for _, ln := range fn.ClosureVars.Slice() {
 		n := ln.Name.Defn
 		if !n.Name.Captured() {
 			n.Name.SetCaptured(true)
@@ -111,9 +112,9 @@ func typecheckclosure(clo *Node, top int) {
 		}
 	}
 
-	xfunc.Func.Nname.Sym = closurename(Curfn)
-	setNodeNameFunc(xfunc.Func.Nname)
-	xfunc = typecheck(xfunc, ctxStmt)
+	fn.Nname.Sym = closurename(Curfn)
+	setNodeNameFunc(fn.Nname)
+	dcl = typecheck(dcl, ctxStmt)
 
 	// Type check the body now, but only if we're inside a function.
 	// At top level (in a variable initialization: curfn==nil) we're not
@@ -121,15 +122,15 @@ func typecheckclosure(clo *Node, top int) {
 	// underlying closure function we create is added to xtop.
 	if Curfn != nil && clo.Type != nil {
 		oldfn := Curfn
-		Curfn = xfunc
+		Curfn = dcl
 		olddd := decldepth
 		decldepth = 1
-		typecheckslice(xfunc.Nbody.Slice(), ctxStmt)
+		typecheckslice(dcl.Nbody.Slice(), ctxStmt)
 		decldepth = olddd
 		Curfn = oldfn
 	}
 
-	xtop = append(xtop, xfunc)
+	xtop = append(xtop, dcl)
 }
 
 // globClosgen is like Func.Closgen, but for the global scope.
@@ -143,7 +144,7 @@ func closurename(outerfunc *Node) *types.Sym {
 	gen := &globClosgen
 
 	if outerfunc != nil {
-		if outerfunc.Func.Closure != nil {
+		if outerfunc.Func.OClosure != nil {
 			prefix = ""
 		}
 
@@ -169,12 +170,11 @@ var capturevarscomplete bool
 // by value or by reference.
 // We use value capturing for values <= 128 bytes that are never reassigned
 // after capturing (effectively constant).
-func capturevars(xfunc *Node) {
+func capturevars(dcl *Node) {
 	lno := lineno
-	lineno = xfunc.Pos
-
-	clo := xfunc.Func.Closure
-	cvars := xfunc.Func.Cvars.Slice()
+	lineno = dcl.Pos
+	fn := dcl.Func
+	cvars := fn.ClosureVars.Slice()
 	out := cvars[:0]
 	for _, v := range cvars {
 		if v.Type == nil {
@@ -216,21 +216,21 @@ func capturevars(xfunc *Node) {
 		}
 
 		outer = typecheck(outer, ctxExpr)
-		clo.Func.Enter.Append(outer)
+		fn.ClosureEnter.Append(outer)
 	}
 
-	xfunc.Func.Cvars.Set(out)
+	fn.ClosureVars.Set(out)
 	lineno = lno
 }
 
 // transformclosure is called in a separate phase after escape analysis.
 // It transform closure bodies to properly reference captured variables.
-func transformclosure(xfunc *Node) {
+func transformclosure(dcl *Node) {
 	lno := lineno
-	lineno = xfunc.Pos
-	clo := xfunc.Func.Closure
+	lineno = dcl.Pos
+	fn := dcl.Func
 
-	if clo.Func.Top&ctxCallee != 0 {
+	if fn.ClosureCalled {
 		// If the closure is directly called, we transform it to a plain function call
 		// with variables passed as args. This avoids allocation of a closure object.
 		// Here we do only a part of the transformation. Walk of OCALLFUNC(OCLOSURE)
@@ -247,12 +247,12 @@ func transformclosure(xfunc *Node) {
 		//	}(byval, &byref, 42)
 
 		// f is ONAME of the actual function.
-		f := xfunc.Func.Nname
+		f := fn.Nname
 
 		// We are going to insert captured variables before input args.
 		var params []*types.Field
 		var decls []*Node
-		for _, v := range xfunc.Func.Cvars.Slice() {
+		for _, v := range fn.ClosureVars.Slice() {
 			if !v.Name.Byval() {
 				// If v of type T is captured by reference,
 				// we introduce function param &v *T
@@ -275,16 +275,16 @@ func transformclosure(xfunc *Node) {
 		if len(params) > 0 {
 			// Prepend params and decls.
 			f.Type.Params().SetFields(append(params, f.Type.Params().FieldSlice()...))
-			xfunc.Func.Dcl = append(decls, xfunc.Func.Dcl...)
+			fn.Dcl = append(decls, fn.Dcl...)
 		}
 
 		dowidth(f.Type)
-		xfunc.Type = f.Type // update type of ODCLFUNC
+		dcl.Type = f.Type // update type of ODCLFUNC
 	} else {
 		// The closure is not called, so it is going to stay as closure.
 		var body []*Node
 		offset := int64(Widthptr)
-		for _, v := range xfunc.Func.Cvars.Slice() {
+		for _, v := range fn.ClosureVars.Slice() {
 			// cv refers to the field inside of closure OSTRUCTLIT.
 			cv := nod(OCLOSUREVAR, nil, nil)
 
@@ -299,7 +299,7 @@ func transformclosure(xfunc *Node) {
 			if v.Name.Byval() && v.Type.Width <= int64(2*Widthptr) {
 				// If it is a small variable captured by value, downgrade it to PAUTO.
 				v.SetClass(PAUTO)
-				xfunc.Func.Dcl = append(xfunc.Func.Dcl, v)
+				fn.Dcl = append(fn.Dcl, v)
 				body = append(body, nod(OAS, v, cv))
 			} else {
 				// Declare variable holding addresses taken from closure
@@ -308,8 +308,8 @@ func transformclosure(xfunc *Node) {
 				addr.Type = types.NewPtr(v.Type)
 				addr.SetClass(PAUTO)
 				addr.Name.SetUsed(true)
-				addr.Name.Curfn = xfunc
-				xfunc.Func.Dcl = append(xfunc.Func.Dcl, addr)
+				addr.Name.Curfn = dcl
+				fn.Dcl = append(fn.Dcl, addr)
 				v.Name.Param.Heapaddr = addr
 				if v.Name.Byval() {
 					cv = nod(OADDR, cv, nil)
@@ -320,8 +320,8 @@ func transformclosure(xfunc *Node) {
 
 		if len(body) > 0 {
 			typecheckslice(body, ctxStmt)
-			xfunc.Func.Enter.Set(body)
-			xfunc.Func.SetNeedctxt(true)
+			fn.Enter.Set(body)
+			fn.SetNeedctxt(true)
 		}
 	}
 
@@ -331,19 +331,17 @@ func transformclosure(xfunc *Node) {
 // hasemptycvars reports whether closure clo has an
 // empty list of captured vars.
 func hasemptycvars(clo *Node) bool {
-	xfunc := clo.Func.Closure
-	return xfunc.Func.Cvars.Len() == 0
+	return clo.Func.ClosureVars.Len() == 0
 }
 
 // closuredebugruntimecheck applies boilerplate checks for debug flags
 // and compiling runtime
 func closuredebugruntimecheck(clo *Node) {
 	if Debug_closure > 0 {
-		xfunc := clo.Func.Closure
 		if clo.Esc == EscHeap {
-			Warnl(clo.Pos, "heap closure, captured vars = %v", xfunc.Func.Cvars)
+			Warnl(clo.Pos, "heap closure, captured vars = %v", clo.Func.ClosureVars)
 		} else {
-			Warnl(clo.Pos, "stack closure, captured vars = %v", xfunc.Func.Cvars)
+			Warnl(clo.Pos, "stack closure, captured vars = %v", clo.Func.ClosureVars)
 		}
 	}
 	if compiling_runtime && clo.Esc == EscHeap {
@@ -371,7 +369,7 @@ func closureType(clo *Node) *types.Type {
 	fields := []*Node{
 		namedfield(".F", types.Types[TUINTPTR]),
 	}
-	for _, v := range clo.Func.Closure.Func.Cvars.Slice() {
+	for _, v := range clo.Func.ClosureVars.Slice() {
 		typ := v.Type
 		if !v.Name.Byval() {
 			typ = types.NewPtr(typ)
@@ -384,14 +382,14 @@ func closureType(clo *Node) *types.Type {
 }
 
 func walkclosure(clo *Node, init *Nodes) *Node {
-	xfunc := clo.Func.Closure
+	fn := clo.Func
 
 	// If no closure vars, don't bother wrapping.
 	if hasemptycvars(clo) {
 		if Debug_closure > 0 {
 			Warnl(clo.Pos, "closure converted to global")
 		}
-		return xfunc.Func.Nname
+		return fn.Nname
 	}
 	closuredebugruntimecheck(clo)
 
@@ -399,7 +397,7 @@ func walkclosure(clo *Node, init *Nodes) *Node {
 
 	clos := nod(OCOMPLIT, nil, typenod(typ))
 	clos.Esc = clo.Esc
-	clos.List.Set(append([]*Node{nod(OCFUNC, xfunc.Func.Nname, nil)}, clo.Func.Enter.Slice()...))
+	clos.List.Set(append([]*Node{nod(OCFUNC, fn.Nname, nil)}, fn.ClosureEnter.Slice()...))
 
 	clos = nod(OADDR, clos, nil)
 	clos.Esc = clo.Esc
@@ -419,8 +417,8 @@ func walkclosure(clo *Node, init *Nodes) *Node {
 	return walkexpr(clos, init)
 }
 
-func typecheckpartialcall(fn *Node, sym *types.Sym) {
-	switch fn.Op {
+func typecheckpartialcall(dot *Node, sym *types.Sym) {
+	switch dot.Op {
 	case ODOTINTER, ODOTMETH:
 		break
 
@@ -429,19 +427,19 @@ func typecheckpartialcall(fn *Node, sym *types.Sym) {
 	}
 
 	// Create top-level function.
-	xfunc := makepartialcall(fn, fn.Type, sym)
-	fn.Func = xfunc.Func
-	fn.Func.SetWrapper(true)
-	fn.Right = newname(sym)
-	fn.Op = OCALLPART
-	fn.Type = xfunc.Type
-	fn.SetOpt(nil) // clear types.Field from ODOTMETH
+	dcl := makepartialcall(dot, dot.Type, sym)
+	dcl.Func.SetWrapper(true)
+	dot.Op = OCALLPART
+	dot.Right = newname(sym)
+	dot.Type = dcl.Type
+	dot.Func = dcl.Func
+	dot.SetOpt(nil) // clear types.Field from ODOTMETH
 }
 
 // makepartialcall returns a DCLFUNC node representing the wrapper function (*-fm) needed
 // for partial calls.
-func makepartialcall(fn *Node, t0 *types.Type, meth *types.Sym) *Node {
-	rcvrtype := fn.Left.Type
+func makepartialcall(dot *Node, t0 *types.Type, meth *types.Sym) *Node {
+	rcvrtype := dot.Left.Type
 	sym := methodSymSuffix(rcvrtype, meth, "-fm")
 
 	if sym.Uniq() {
@@ -468,9 +466,10 @@ func makepartialcall(fn *Node, t0 *types.Type, meth *types.Sym) *Node {
 	tfn.List.Set(structargs(t0.Params(), true))
 	tfn.Rlist.Set(structargs(t0.Results(), false))
 
-	xfunc := dclfunc(sym, tfn)
-	xfunc.Func.SetDupok(true)
-	xfunc.Func.SetNeedctxt(true)
+	dcl := dclfunc(sym, tfn)
+	fn := dcl.Func
+	fn.SetDupok(true)
+	fn.SetNeedctxt(true)
 
 	tfn.Type.SetPkg(t0.Pkg())
 
@@ -502,20 +501,20 @@ func makepartialcall(fn *Node, t0 *types.Type, meth *types.Sym) *Node {
 	}
 	body = append(body, call)
 
-	xfunc.Nbody.Set(body)
+	dcl.Nbody.Set(body)
 	funcbody()
 
-	xfunc = typecheck(xfunc, ctxStmt)
+	dcl = typecheck(dcl, ctxStmt)
 	// Need to typecheck the body of the just-generated wrapper.
 	// typecheckslice() requires that Curfn is set when processing an ORETURN.
-	Curfn = xfunc
-	typecheckslice(xfunc.Nbody.Slice(), ctxStmt)
-	sym.Def = asTypesNode(xfunc)
-	xtop = append(xtop, xfunc)
+	Curfn = dcl
+	typecheckslice(dcl.Nbody.Slice(), ctxStmt)
+	sym.Def = asTypesNode(dcl)
+	xtop = append(xtop, dcl)
 	Curfn = savecurfn
 	lineno = saveLineNo
 
-	return xfunc
+	return dcl
 }
 
 // partialCallType returns the struct type used to hold all the information
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index e0a6f6ac92..59888cce7e 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -206,11 +206,13 @@ func newnoname(s *types.Sym) *Node {
 }
 
 // newfuncnamel generates a new name node for a function or method.
-// TODO(rsc): Use an ODCLFUNC node instead. See comment in CL 7360.
-func newfuncnamel(pos src.XPos, s *types.Sym) *Node {
+func newfuncnamel(pos src.XPos, s *types.Sym, fn *Func) *Node {
+	if fn.Nname != nil {
+		Fatalf("newfuncnamel - already have name")
+	}
 	n := newnamel(pos, s)
-	n.Func = new(Func)
-	n.Func.SetIsHiddenClosure(Curfn != nil)
+	n.Func = fn
+	fn.Nname = n
 	return n
 }
 
@@ -287,7 +289,7 @@ func oldname(s *types.Sym) *Node {
 			c.Name.Param.Outer = n.Name.Param.Innermost
 			n.Name.Param.Innermost = c
 
-			Curfn.Func.Cvars.Append(c)
+			Curfn.Func.ClosureVars.Append(c)
 		}
 
 		// return ref to closure var, not original
@@ -388,10 +390,8 @@ func funchdr(n *Node) {
 
 	types.Markdcl()
 
-	if n.Func.Nname != nil {
+	if n.Func.Nname != nil && n.Func.Nname.Name.Param.Ntype != nil {
 		funcargs(n.Func.Nname.Name.Param.Ntype)
-	} else if n.Func.Ntype != nil {
-		funcargs(n.Func.Ntype)
 	} else {
 		funcargs2(n.Type)
 	}
@@ -973,7 +973,7 @@ func dclfunc(sym *types.Sym, tfn *Node) *Node {
 	}
 
 	fn := nod(ODCLFUNC, nil, nil)
-	fn.Func.Nname = newfuncnamel(lineno, sym)
+	fn.Func.Nname = newfuncnamel(lineno, sym, fn.Func)
 	fn.Func.Nname.Name.Defn = fn
 	fn.Func.Nname.Name.Param.Ntype = tfn
 	setNodeNameFunc(fn.Func.Nname)
@@ -1043,7 +1043,7 @@ func (c *nowritebarrierrecChecker) findExtraCalls(n *Node) bool {
 	case ONAME:
 		callee = arg.Name.Defn
 	case OCLOSURE:
-		callee = arg.Func.Closure
+		callee = arg.Func.Decl
 	default:
 		Fatalf("expected ONAME or OCLOSURE node, got %+v", arg)
 	}
diff --git a/src/cmd/compile/internal/gc/esc.go b/src/cmd/compile/internal/gc/esc.go
index b7d1dfc92a..c4159101f2 100644
--- a/src/cmd/compile/internal/gc/esc.go
+++ b/src/cmd/compile/internal/gc/esc.go
@@ -259,8 +259,9 @@ func addrescapes(n *Node) {
 		// heap in f, not in the inner closure. Flip over to f before calling moveToHeap.
 		oldfn := Curfn
 		Curfn = n.Name.Curfn
-		if Curfn.Func.Closure != nil && Curfn.Op == OCLOSURE {
-			Curfn = Curfn.Func.Closure
+		if Curfn.Op == OCLOSURE {
+			Curfn = Curfn.Func.Decl
+			panic("can't happen")
 		}
 		ln := lineno
 		lineno = Curfn.Pos
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index bc0eb98d76..07cc549825 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -623,7 +623,7 @@ func (e *Escape) exprSkipInit(k EscHole, n *Node) {
 		k = e.spill(k, n)
 
 		// Link addresses of captured variables to closure.
-		for _, v := range n.Func.Closure.Func.Cvars.Slice() {
+		for _, v := range n.Func.ClosureVars.Slice() {
 			if v.Op == OXXX { // unnamed out argument; see dcl.go:/^funcargs
 				continue
 			}
@@ -810,7 +810,7 @@ func (e *Escape) call(ks []EscHole, call, where *Node) {
 			case v.Op == ONAME && v.Class() == PFUNC:
 				fn = v
 			case v.Op == OCLOSURE:
-				fn = v.Func.Closure.Func.Nname
+				fn = v.Func.Nname
 			}
 		case OCALLMETH:
 			fn = call.Left.MethodName()
@@ -1358,7 +1358,7 @@ func (e *Escape) outlives(l, other *EscLocation) bool {
 		//
 		//    var u int  // okay to stack allocate
 		//    *(func() *int { return &u }()) = 42
-		if containsClosure(other.curfn, l.curfn) && l.curfn.Func.Closure.Func.Top&ctxCallee != 0 {
+		if containsClosure(other.curfn, l.curfn) && l.curfn.Func.ClosureCalled {
 			return false
 		}
 
diff --git a/src/cmd/compile/internal/gc/fmt.go b/src/cmd/compile/internal/gc/fmt.go
index 650fb9681e..e62a526eeb 100644
--- a/src/cmd/compile/internal/gc/fmt.go
+++ b/src/cmd/compile/internal/gc/fmt.go
@@ -1417,7 +1417,7 @@ func (n *Node) exprfmt(s fmt.State, prec int, mode fmtMode) {
 			mode.Fprintf(s, "%v { %v }", n.Type, n.Nbody)
 			return
 		}
-		mode.Fprintf(s, "%v { %v }", n.Type, n.Func.Closure.Nbody)
+		mode.Fprintf(s, "%v { %v }", n.Type, n.Func.Decl.Nbody)
 
 	case OCOMPLIT:
 		if mode == FErr {
@@ -1717,8 +1717,8 @@ func (n *Node) nodedump(s fmt.State, flag FmtFlag, mode fmtMode) {
 		}
 	}
 
-	if n.Op == OCLOSURE && n.Func.Closure != nil && n.Func.Closure.Func.Nname.Sym != nil {
-		mode.Fprintf(s, " fnName %v", n.Func.Closure.Func.Nname.Sym)
+	if n.Op == OCLOSURE && n.Func.Decl != nil && n.Func.Nname.Sym != nil {
+		mode.Fprintf(s, " fnName %v", n.Func.Nname.Sym)
 	}
 	if n.Sym != nil && n.Op != ONAME {
 		mode.Fprintf(s, " %v", n.Sym)
@@ -1735,12 +1735,12 @@ func (n *Node) nodedump(s fmt.State, flag FmtFlag, mode fmtMode) {
 		if n.Right != nil {
 			mode.Fprintf(s, "%v", n.Right)
 		}
-		if n.Func != nil && n.Func.Closure != nil && n.Func.Closure.Nbody.Len() != 0 {
+		if n.Op == OCLOSURE && n.Func != nil && n.Func.Decl != nil && n.Func.Decl.Nbody.Len() != 0 {
 			indent(s)
 			// The function associated with a closure
-			mode.Fprintf(s, "%v-clofunc%v", n.Op, n.Func.Closure)
+			mode.Fprintf(s, "%v-clofunc%v", n.Op, n.Func.Decl)
 		}
-		if n.Func != nil && n.Func.Dcl != nil && len(n.Func.Dcl) != 0 {
+		if n.Op == ODCLFUNC && n.Func != nil && n.Func.Dcl != nil && len(n.Func.Dcl) != 0 {
 			indent(s)
 			// The dcls for a func or closure
 			mode.Fprintf(s, "%v-dcl%v", n.Op, asNodes(n.Func.Dcl))
diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
index 929653ebbd..d882d6d672 100644
--- a/src/cmd/compile/internal/gc/gen.go
+++ b/src/cmd/compile/internal/gc/gen.go
@@ -54,7 +54,7 @@ func tempAt(pos src.XPos, curfn *Node, t *types.Type) *Node {
 	if curfn == nil {
 		Fatalf("no curfn for tempAt")
 	}
-	if curfn.Func.Closure != nil && curfn.Op == OCLOSURE {
+	if curfn.Op == OCLOSURE {
 		Dump("tempAt", curfn)
 		Fatalf("adding tempAt to wrong closure function")
 	}
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 0fa11c5f59..a3a01e59cd 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -329,7 +329,7 @@ func (r *importReader) doDecl(n *Node) {
 			recv := r.param()
 			mtyp := r.signature(recv)
 
-			m := newfuncnamel(mpos, methodSym(recv.Type, msym))
+			m := newfuncnamel(mpos, methodSym(recv.Type, msym), new(Func))
 			m.Type = mtyp
 			m.SetClass(PFUNC)
 			// methodSym already marked m.Sym as a function.
diff --git a/src/cmd/compile/internal/gc/initorder.go b/src/cmd/compile/internal/gc/initorder.go
index 102cb769db..f82df04b73 100644
--- a/src/cmd/compile/internal/gc/initorder.go
+++ b/src/cmd/compile/internal/gc/initorder.go
@@ -285,7 +285,7 @@ func (d *initDeps) visit(n *Node) bool {
 		}
 
 	case OCLOSURE:
-		d.inspectList(n.Func.Closure.Nbody)
+		d.inspectList(n.Func.Decl.Nbody)
 
 	case ODOTMETH, OCALLPART:
 		d.foundDep(n.MethodName())
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 6d07e156ea..db53b2aae1 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -722,7 +722,7 @@ func inlCallee(fn *Node) *Node {
 		}
 		return fn
 	case fn.Op == OCLOSURE:
-		c := fn.Func.Closure
+		c := fn.Func.Decl
 		caninl(c)
 		return c.Func.Nname
 	}
@@ -806,7 +806,7 @@ func reassigned(n *Node) (bool, *Node) {
 	// We need to walk the function body to check for reassignments so we follow the
 	// linkage to the ODCLFUNC node as that is where body is held.
 	if f.Op == OCLOSURE {
-		f = f.Func.Closure
+		f = f.Func.Decl
 	}
 	v := reassignVisitor{name: n}
 	a := v.visitList(f.Nbody)
@@ -976,8 +976,8 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 
 	// Handle captured variables when inlining closures.
 	if fn.Name.Defn != nil {
-		if c := fn.Name.Defn.Func.Closure; c != nil {
-			for _, v := range c.Func.Closure.Func.Cvars.Slice() {
+		if c := fn.Name.Defn.Func.OClosure; c != nil {
+			for _, v := range c.Func.ClosureVars.Slice() {
 				if v.Op == OXXX {
 					continue
 				}
@@ -987,7 +987,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 				// NB: if we enabled inlining of functions containing OCLOSURE or refined
 				// the reassigned check via some sort of copy propagation this would most
 				// likely need to be changed to a loop to walk up to the correct Param
-				if o == nil || (o.Name.Curfn != Curfn && o.Name.Curfn.Func.Closure != Curfn) {
+				if o == nil || (o.Name.Curfn != Curfn && o.Name.Curfn.Func.OClosure != Curfn) {
 					Fatalf("%v: unresolvable capture %v %v\n", n.Line(), fn, v)
 				}
 
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 89dbca0cf1..cf4ec039f1 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -651,7 +651,7 @@ func Main(archInit func(*Arch)) {
 	// because variables captured by value do not escape.
 	timings.Start("fe", "capturevars")
 	for _, n := range xtop {
-		if n.Op == ODCLFUNC && n.Func.Closure != nil {
+		if n.Op == ODCLFUNC && n.Func.OClosure != nil {
 			Curfn = n
 			capturevars(n)
 		}
@@ -724,7 +724,7 @@ func Main(archInit func(*Arch)) {
 	// before walk reaches a call of a closure.
 	timings.Start("fe", "xclosures")
 	for _, n := range xtop {
-		if n.Op == ODCLFUNC && n.Func.Closure != nil {
+		if n.Op == ODCLFUNC && n.Func.OClosure != nil {
 			Curfn = n
 			transformclosure(n)
 		}
@@ -829,7 +829,7 @@ func Main(archInit func(*Arch)) {
 func numNonClosures(list []*Node) int {
 	count := 0
 	for _, n := range list {
-		if n.Func.Closure == nil {
+		if n.Func.OClosure == nil {
 			count++
 		}
 	}
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 3ef8583f6d..f8c84a75bf 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -537,7 +537,7 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) *Node {
 		name = nblank.Sym // filled in by typecheckfunc
 	}
 
-	f.Func.Nname = newfuncnamel(p.pos(fun.Name), name)
+	f.Func.Nname = newfuncnamel(p.pos(fun.Name), name, f.Func)
 	f.Func.Nname.Name.Defn = f
 	f.Func.Nname.Name.Param.Ntype = t
 
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 11c8b1fa25..a62d468c9c 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -1256,7 +1256,7 @@ func (o *Order) expr(n, lhs *Node) *Node {
 		}
 
 	case OCLOSURE:
-		if n.Transient() && n.Func.Closure.Func.Cvars.Len() > 0 {
+		if n.Transient() && n.Func.ClosureVars.Len() > 0 {
 			prealloc[n] = o.newTemp(closureType(n), false)
 		}
 
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index 9c1bd285ae..0f0f6b7107 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -404,30 +404,59 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 		}
 	}
 
+	// Back when there were two different *Funcs for a function, this code
+	// was not consistent about whether a particular *Node being processed
+	// was an ODCLFUNC or ONAME node. Partly this is because inlined function
+	// bodies have no ODCLFUNC node, which was it's own inconsistency.
+	// In any event, the handling of the two different nodes for DWARF purposes
+	// was subtly different, likely in unintended ways. CL 272253 merged the
+	// two nodes' Func fields, so that code sees the same *Func whether it is
+	// holding the ODCLFUNC or the ONAME. This resulted in changes in the
+	// DWARF output. To preserve the existing DWARF output and leave an
+	// intentional change for a future CL, this code does the following when
+	// fn.Op == ONAME:
+	//
+	// 1. Disallow use of createComplexVars in createDwarfVars.
+	//    It was not possible to reach that code for an ONAME before,
+	//    because the DebugInfo was set only on the ODCLFUNC Func.
+	//    Calling into it in the ONAME case causes an index out of bounds panic.
+	//
+	// 2. Do not populate apdecls. fn.Func.Dcl was in the ODCLFUNC Func,
+	//    not the ONAME Func. Populating apdecls for the ONAME case results
+	//    in selected being populated after createSimpleVars is called in
+	//    createDwarfVars, and then that causes the loop to skip all the entries
+	//    in dcl, meaning that the RecordAutoType calls don't happen.
+	//
+	// These two adjustments keep toolstash -cmp working for now.
+	// Deciding the right answer is, as they say, future work.
+	isODCLFUNC := fn.Op == ODCLFUNC
+
 	var apdecls []*Node
 	// Populate decls for fn.
-	for _, n := range fn.Func.Dcl {
-		if n.Op != ONAME { // might be OTYPE or OLITERAL
-			continue
-		}
-		switch n.Class() {
-		case PAUTO:
-			if !n.Name.Used() {
-				// Text == nil -> generating abstract function
-				if fnsym.Func().Text != nil {
-					Fatalf("debuginfo unused node (AllocFrame should truncate fn.Func.Dcl)")
+	if isODCLFUNC {
+		for _, n := range fn.Func.Dcl {
+			if n.Op != ONAME { // might be OTYPE or OLITERAL
+				continue
+			}
+			switch n.Class() {
+			case PAUTO:
+				if !n.Name.Used() {
+					// Text == nil -> generating abstract function
+					if fnsym.Func().Text != nil {
+						Fatalf("debuginfo unused node (AllocFrame should truncate fn.Func.Dcl)")
+					}
+					continue
 				}
+			case PPARAM, PPARAMOUT:
+			default:
 				continue
 			}
-		case PPARAM, PPARAMOUT:
-		default:
-			continue
+			apdecls = append(apdecls, n)
+			fnsym.Func().RecordAutoType(ngotype(n).Linksym())
 		}
-		apdecls = append(apdecls, n)
-		fnsym.Func().RecordAutoType(ngotype(n).Linksym())
 	}
 
-	decls, dwarfVars := createDwarfVars(fnsym, fn.Func, apdecls)
+	decls, dwarfVars := createDwarfVars(fnsym, isODCLFUNC, fn.Func, apdecls)
 
 	// For each type referenced by the functions auto vars but not
 	// already referenced by a dwarf var, attach a dummy relocation to
@@ -575,12 +604,12 @@ func createComplexVars(fnsym *obj.LSym, fn *Func) ([]*Node, []*dwarf.Var, map[*N
 
 // createDwarfVars process fn, returning a list of DWARF variables and the
 // Nodes they represent.
-func createDwarfVars(fnsym *obj.LSym, fn *Func, apDecls []*Node) ([]*Node, []*dwarf.Var) {
+func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *Func, apDecls []*Node) ([]*Node, []*dwarf.Var) {
 	// Collect a raw list of DWARF vars.
 	var vars []*dwarf.Var
 	var decls []*Node
 	var selected map[*Node]bool
-	if Ctxt.Flag_locationlists && Ctxt.Flag_optimize && fn.DebugInfo != nil {
+	if Ctxt.Flag_locationlists && Ctxt.Flag_optimize && fn.DebugInfo != nil && complexOK {
 		decls, vars, selected = createComplexVars(fnsym, fn)
 	} else {
 		decls, vars, selected = createSimpleVars(fnsym, apDecls)
diff --git a/src/cmd/compile/internal/gc/scc.go b/src/cmd/compile/internal/gc/scc.go
index 14f77d613a..8e41ebac29 100644
--- a/src/cmd/compile/internal/gc/scc.go
+++ b/src/cmd/compile/internal/gc/scc.go
@@ -101,7 +101,7 @@ func (v *bottomUpVisitor) visit(n *Node) uint32 {
 				}
 			}
 		case OCLOSURE:
-			if m := v.visit(n.Func.Closure); m < min {
+			if m := v.visit(n.Func.Decl); m < min {
 				min = m
 			}
 		}
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index c199ff6317..5727245562 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -261,7 +261,7 @@ func (s *InitSchedule) staticassign(l *Node, r *Node) bool {
 			}
 			// Closures with no captured variables are globals,
 			// so the assignment can be done at link time.
-			pfuncsym(l, r.Func.Closure.Func.Nname)
+			pfuncsym(l, r.Func.Nname)
 			return true
 		}
 		closuredebugruntimecheck(r)
diff --git a/src/cmd/compile/internal/gc/sizeof_test.go b/src/cmd/compile/internal/gc/sizeof_test.go
index ce4a216c2e..2f2eba4c67 100644
--- a/src/cmd/compile/internal/gc/sizeof_test.go
+++ b/src/cmd/compile/internal/gc/sizeof_test.go
@@ -20,7 +20,7 @@ func TestSizeof(t *testing.T) {
 		_32bit uintptr     // size on 32bit platforms
 		_64bit uintptr     // size on 64bit platforms
 	}{
-		{Func{}, 124, 224},
+		{Func{}, 132, 240},
 		{Name{}, 32, 56},
 		{Param{}, 24, 48},
 		{Node{}, 76, 128},
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 7c13aef214..1aa3af929c 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -139,13 +139,14 @@ func nod(op Op, nleft, nright *Node) *Node {
 func nodl(pos src.XPos, op Op, nleft, nright *Node) *Node {
 	var n *Node
 	switch op {
-	case OCLOSURE, ODCLFUNC:
+	case ODCLFUNC:
 		var x struct {
 			n Node
 			f Func
 		}
 		n = &x.n
 		n.Func = &x.f
+		n.Func.Decl = n
 	case ONAME:
 		Fatalf("use newname instead")
 	case OLABEL, OPACK:
diff --git a/src/cmd/compile/internal/gc/syntax.go b/src/cmd/compile/internal/gc/syntax.go
index de516dec69..435fd78fce 100644
--- a/src/cmd/compile/internal/gc/syntax.go
+++ b/src/cmd/compile/internal/gc/syntax.go
@@ -578,62 +578,66 @@ func (p *Param) SetEmbedFiles(list []string) {
 	*(*p.Extra).(*embedFileList) = list
 }
 
-// Functions
+// A Func corresponds to a single function in a Go program
+// (and vice versa: each function is denoted by exactly one *Func).
 //
-// A simple function declaration is represented as an ODCLFUNC node f
-// and an ONAME node n. They're linked to one another through
-// f.Func.Nname == n and n.Name.Defn == f. When functions are
-// referenced by name in an expression, the function's ONAME node is
-// used directly.
+// There are multiple nodes that represent a Func in the IR.
 //
-// Function names have n.Class() == PFUNC. This distinguishes them
-// from variables of function type.
+// The ONAME node (Func.Name) is used for plain references to it.
+// The ODCLFUNC node (Func.Decl) is used for its declaration code.
+// The OCLOSURE node (Func.Closure) is used for a reference to a
+// function literal.
 //
-// Confusingly, n.Func and f.Func both exist, but commonly point to
-// different Funcs. (Exception: an OCALLPART's Func does point to its
-// ODCLFUNC's Func.)
+// A Func for an imported function will have only an ONAME node.
+// A declared function or method has an ONAME and an ODCLFUNC.
+// A function literal is represented directly by an OCLOSURE, but it also
+// has an ODCLFUNC (and a matching ONAME) representing the compiled
+// underlying form of the closure, which accesses the captured variables
+// using a special data structure passed in a register.
 //
-// A method declaration is represented like functions, except n.Sym
+// A method declaration is represented like functions, except f.Sym
 // will be the qualified method name (e.g., "T.m") and
 // f.Func.Shortname is the bare method name (e.g., "m").
 //
-// Method expressions are represented as ONAME/PFUNC nodes like
-// function names, but their Left and Right fields still point to the
-// type and method, respectively. They can be distinguished from
-// normal functions with isMethodExpression. Also, unlike function
-// name nodes, method expression nodes exist for each method
-// expression. The declaration ONAME can be accessed with
-// x.Type.Nname(), where x is the method expression ONAME node.
+// A method expression (T.M) is represented as an ONAME node
+// like a function name would be, but n.Left and n.Right point to
+// the type and method, respectively. A method expression can
+// be distinguished from a normal function ONAME by checking
+// n.IsMethodExpression. Unlike ordinary ONAME nodes, each
+// distinct mention of a method expression in the source code
+// constructs a fresh ONAME node.
+// TODO(rsc): Method expressions deserve their own opcode
+// instead of violating invariants of ONAME.
 //
-// Method values are represented by ODOTMETH/ODOTINTER when called
-// immediately, and OCALLPART otherwise. They are like method
-// expressions, except that for ODOTMETH/ODOTINTER the method name is
-// stored in Sym instead of Right.
-//
-// Closures are represented by OCLOSURE node c. They link back and
-// forth with the ODCLFUNC via Func.Closure; that is, c.Func.Closure
-// == f and f.Func.Closure == c.
-//
-// Function bodies are stored in f.Nbody, and inline function bodies
-// are stored in n.Func.Inl. Pragmas are stored in f.Func.Pragma.
-//
-// Imported functions skip the ODCLFUNC, so n.Name.Defn is nil. They
-// also use Dcl instead of Inldcl.
-
-// Func holds Node fields used only with function-like nodes.
+// A method value (t.M) is represented by ODOTMETH/ODOTINTER
+// when it is called directly and by OCALLPART otherwise.
+// These are like method expressions, except that for ODOTMETH/ODOTINTER,
+// the method name is stored in Sym instead of Right.
+// Each OCALLPART ends up being implemented as a new
+// function, a bit like a closure, with its own ODCLFUNC.
+// The OCALLPART has uses n.Func to record the linkage to
+// the generated ODCLFUNC (as n.Func.Decl), but there is no
+// pointer from the Func back to the OCALLPART.
 type Func struct {
+	Nname    *Node // ONAME node
+	Decl     *Node // ODCLFUNC node
+	OClosure *Node // OCLOSURE node
+
 	Shortname *types.Sym
+
 	// Extra entry code for the function. For example, allocate and initialize
-	// memory for escaping parameters. However, just for OCLOSURE, Enter is a
-	// list of ONAME nodes of captured variables
+	// memory for escaping parameters.
 	Enter Nodes
 	Exit  Nodes
-	// ONAME nodes for closure params, each should have closurevar set
-	Cvars Nodes
 	// ONAME nodes for all params/locals for this func/closure, does NOT
 	// include closurevars until transformclosure runs.
 	Dcl []*Node
 
+	ClosureEnter  Nodes // list of ONAME nodes of captured variables
+	ClosureType   *Node // closure representation type
+	ClosureCalled bool  // closure is only immediately called
+	ClosureVars   Nodes // closure params; each has closurevar set
+
 	// Parents records the parent scope of each scope within a
 	// function. The root scope (0) has no parent, so the i'th
 	// scope's parent is stored at Parents[i-1].
@@ -649,10 +653,6 @@ type Func struct {
 
 	FieldTrack map[*types.Sym]struct{}
 	DebugInfo  *ssa.FuncDebug
-	Ntype      *Node // signature
-	Top        int   // top context (ctxCallee, etc)
-	Closure    *Node // OCLOSURE <-> ODCLFUNC (see header comment above)
-	Nname      *Node // The ONAME node associated with an ODCLFUNC (both have same Type)
 	lsym       *obj.LSym
 
 	Inl *Inline
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 4bbc58ce13..ae344fc8e1 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -562,12 +562,11 @@ opswitch:
 			// transformclosure already did all preparation work.
 
 			// Prepend captured variables to argument list.
-			n.List.Prepend(n.Left.Func.Enter.Slice()...)
-
-			n.Left.Func.Enter.Set(nil)
+			n.List.Prepend(n.Left.Func.ClosureEnter.Slice()...)
+			n.Left.Func.ClosureEnter.Set(nil)
 
 			// Replace OCLOSURE with ONAME/PFUNC.
-			n.Left = n.Left.Func.Closure.Func.Nname
+			n.Left = n.Left.Func.Nname
 
 			// Update type of OCALLFUNC node.
 			// Output arguments had not changed, but their offsets could.
-- 
GitLab


From 4f9d54e41d80f06b8806bcbb23c015572b78d9fc Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 24 Nov 2020 10:25:41 -0500
Subject: [PATCH 0051/2400] [dev.regabi] cmd/compile: add OMETHEXPR

This CL is obviously OK but does not pass toolstash -cmp,
because it renumbers the Op codes. In a separate CL so that
we can use toolstash -cmp on the CL with real changes
related to OMETHEXPR.

Change-Id: I1db978e3f2652b3bdf51f7981a3ba5137641c8c7
Reviewed-on: https://go-review.googlesource.com/c/go/+/272866
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/op_string.go | 87 ++++++++++++------------
 src/cmd/compile/internal/gc/syntax.go    |  1 +
 2 files changed, 45 insertions(+), 43 deletions(-)

diff --git a/src/cmd/compile/internal/gc/op_string.go b/src/cmd/compile/internal/gc/op_string.go
index f7d31f912c..16fd79e477 100644
--- a/src/cmd/compile/internal/gc/op_string.go
+++ b/src/cmd/compile/internal/gc/op_string.go
@@ -121,52 +121,53 @@ func _() {
 	_ = x[OALIGNOF-110]
 	_ = x[OOFFSETOF-111]
 	_ = x[OSIZEOF-112]
-	_ = x[OBLOCK-113]
-	_ = x[OBREAK-114]
-	_ = x[OCASE-115]
-	_ = x[OCONTINUE-116]
-	_ = x[ODEFER-117]
-	_ = x[OEMPTY-118]
-	_ = x[OFALL-119]
-	_ = x[OFOR-120]
-	_ = x[OFORUNTIL-121]
-	_ = x[OGOTO-122]
-	_ = x[OIF-123]
-	_ = x[OLABEL-124]
-	_ = x[OGO-125]
-	_ = x[ORANGE-126]
-	_ = x[ORETURN-127]
-	_ = x[OSELECT-128]
-	_ = x[OSWITCH-129]
-	_ = x[OTYPESW-130]
-	_ = x[OTCHAN-131]
-	_ = x[OTMAP-132]
-	_ = x[OTSTRUCT-133]
-	_ = x[OTINTER-134]
-	_ = x[OTFUNC-135]
-	_ = x[OTARRAY-136]
-	_ = x[ODDD-137]
-	_ = x[OINLCALL-138]
-	_ = x[OEFACE-139]
-	_ = x[OITAB-140]
-	_ = x[OIDATA-141]
-	_ = x[OSPTR-142]
-	_ = x[OCLOSUREVAR-143]
-	_ = x[OCFUNC-144]
-	_ = x[OCHECKNIL-145]
-	_ = x[OVARDEF-146]
-	_ = x[OVARKILL-147]
-	_ = x[OVARLIVE-148]
-	_ = x[ORESULT-149]
-	_ = x[OINLMARK-150]
-	_ = x[ORETJMP-151]
-	_ = x[OGETG-152]
-	_ = x[OEND-153]
+	_ = x[OMETHEXPR-113]
+	_ = x[OBLOCK-114]
+	_ = x[OBREAK-115]
+	_ = x[OCASE-116]
+	_ = x[OCONTINUE-117]
+	_ = x[ODEFER-118]
+	_ = x[OEMPTY-119]
+	_ = x[OFALL-120]
+	_ = x[OFOR-121]
+	_ = x[OFORUNTIL-122]
+	_ = x[OGOTO-123]
+	_ = x[OIF-124]
+	_ = x[OLABEL-125]
+	_ = x[OGO-126]
+	_ = x[ORANGE-127]
+	_ = x[ORETURN-128]
+	_ = x[OSELECT-129]
+	_ = x[OSWITCH-130]
+	_ = x[OTYPESW-131]
+	_ = x[OTCHAN-132]
+	_ = x[OTMAP-133]
+	_ = x[OTSTRUCT-134]
+	_ = x[OTINTER-135]
+	_ = x[OTFUNC-136]
+	_ = x[OTARRAY-137]
+	_ = x[ODDD-138]
+	_ = x[OINLCALL-139]
+	_ = x[OEFACE-140]
+	_ = x[OITAB-141]
+	_ = x[OIDATA-142]
+	_ = x[OSPTR-143]
+	_ = x[OCLOSUREVAR-144]
+	_ = x[OCFUNC-145]
+	_ = x[OCHECKNIL-146]
+	_ = x[OVARDEF-147]
+	_ = x[OVARKILL-148]
+	_ = x[OVARLIVE-149]
+	_ = x[ORESULT-150]
+	_ = x[OINLMARK-151]
+	_ = x[ORETJMP-152]
+	_ = x[OGETG-153]
+	_ = x[OEND-154]
 }
 
-const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLFIELDDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNEWOBJNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECVSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFBLOCKBREAKCASECONTINUEDEFEREMPTYFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYDDDINLCALLEFACEITABIDATASPTRCLOSUREVARCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKRETJMPGETGEND"
+const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLFIELDDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNEWOBJNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECVSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRBLOCKBREAKCASECONTINUEDEFEREMPTYFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYDDDINLCALLEFACEITABIDATASPTRCLOSUREVARCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKRETJMPGETGEND"
 
-var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 310, 317, 323, 326, 332, 339, 347, 351, 358, 366, 368, 370, 372, 374, 376, 378, 383, 388, 396, 399, 408, 411, 415, 423, 430, 439, 452, 455, 458, 461, 464, 467, 470, 476, 479, 485, 488, 494, 498, 501, 505, 510, 515, 521, 526, 530, 535, 543, 551, 557, 566, 577, 584, 588, 595, 602, 610, 614, 618, 622, 629, 636, 644, 650, 655, 660, 664, 672, 677, 682, 686, 689, 697, 701, 703, 708, 710, 715, 721, 727, 733, 739, 744, 748, 755, 761, 766, 772, 775, 782, 787, 791, 796, 800, 810, 815, 823, 829, 836, 843, 849, 856, 862, 866, 869}
+var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 310, 317, 323, 326, 332, 339, 347, 351, 358, 366, 368, 370, 372, 374, 376, 378, 383, 388, 396, 399, 408, 411, 415, 423, 430, 439, 452, 455, 458, 461, 464, 467, 470, 476, 479, 485, 488, 494, 498, 501, 505, 510, 515, 521, 526, 530, 535, 543, 551, 557, 566, 577, 584, 588, 595, 602, 610, 614, 618, 622, 629, 636, 644, 650, 658, 663, 668, 672, 680, 685, 690, 694, 697, 705, 709, 711, 716, 718, 723, 729, 735, 741, 747, 752, 756, 763, 769, 774, 780, 783, 790, 795, 799, 804, 808, 818, 823, 831, 837, 844, 851, 857, 864, 870, 874, 877}
 
 func (i Op) String() string {
 	if i >= Op(len(_Op_index)-1) {
diff --git a/src/cmd/compile/internal/gc/syntax.go b/src/cmd/compile/internal/gc/syntax.go
index 435fd78fce..343d5b171c 100644
--- a/src/cmd/compile/internal/gc/syntax.go
+++ b/src/cmd/compile/internal/gc/syntax.go
@@ -891,6 +891,7 @@ const (
 	OALIGNOF     // unsafe.Alignof(Left)
 	OOFFSETOF    // unsafe.Offsetof(Left)
 	OSIZEOF      // unsafe.Sizeof(Left)
+	OMETHEXPR    // method expression
 
 	// statements
 	OBLOCK // { List } (block of code)
-- 
GitLab


From ee6132a698172a063ad2aa5b8d603f589c16e019 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 18 Nov 2020 11:25:29 -0500
Subject: [PATCH 0052/2400] [dev.regabi] cmd/compile: introduce OMETHEXPR
 instead of overloading ONAME

A method expression today is an ONAME that has none of the
invariants or properties of other ONAMEs and is always a special case
(hence the Node.IsMethodExpression method).
Remove the special cases by making a separate Op.

Passes toolstash -cmp.

Change-Id: I7667693c9155d5486a6924dbf75ebb59891c4afc
Reviewed-on: https://go-review.googlesource.com/c/go/+/272867
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/escape.go    |  2 +-
 src/cmd/compile/internal/gc/fmt.go       |  8 +++---
 src/cmd/compile/internal/gc/iexport.go   | 14 ++++------
 src/cmd/compile/internal/gc/initorder.go |  9 +++---
 src/cmd/compile/internal/gc/inl.go       | 35 ++++++++++++------------
 src/cmd/compile/internal/gc/scc.go       | 10 +++++--
 src/cmd/compile/internal/gc/sinit.go     | 14 +++++-----
 src/cmd/compile/internal/gc/ssa.go       |  3 ++
 src/cmd/compile/internal/gc/syntax.go    | 18 +++---------
 src/cmd/compile/internal/gc/typecheck.go | 10 +++----
 src/cmd/compile/internal/gc/walk.go      |  2 +-
 11 files changed, 60 insertions(+), 65 deletions(-)

diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 07cc549825..497151d02f 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -476,7 +476,7 @@ func (e *Escape) exprSkipInit(k EscHole, n *Node) {
 	default:
 		Fatalf("unexpected expr: %v", n)
 
-	case OLITERAL, ONIL, OGETG, OCLOSUREVAR, OTYPE:
+	case OLITERAL, ONIL, OGETG, OCLOSUREVAR, OTYPE, OMETHEXPR:
 		// nop
 
 	case ONAME:
diff --git a/src/cmd/compile/internal/gc/fmt.go b/src/cmd/compile/internal/gc/fmt.go
index e62a526eeb..addb010e5c 100644
--- a/src/cmd/compile/internal/gc/fmt.go
+++ b/src/cmd/compile/internal/gc/fmt.go
@@ -1355,15 +1355,15 @@ func (n *Node) exprfmt(s fmt.State, prec int, mode fmtMode) {
 			mode.Fprintf(s, ")")
 		}
 
-	// Special case: name used as local variable in export.
-	// _ becomes ~b%d internally; print as _ for export
 	case ONAME:
+		// Special case: name used as local variable in export.
+		// _ becomes ~b%d internally; print as _ for export
 		if mode == FErr && n.Sym != nil && n.Sym.Name[0] == '~' && n.Sym.Name[1] == 'b' {
 			fmt.Fprint(s, "_")
 			return
 		}
 		fallthrough
-	case OPACK, ONONAME:
+	case OPACK, ONONAME, OMETHEXPR:
 		fmt.Fprint(s, smodeString(n.Sym, mode))
 
 	case OTYPE:
@@ -1695,7 +1695,7 @@ func (n *Node) nodedump(s fmt.State, flag FmtFlag, mode fmtMode) {
 	case OLITERAL:
 		mode.Fprintf(s, "%v-%v%j", n.Op, n.Val(), n)
 
-	case ONAME, ONONAME:
+	case ONAME, ONONAME, OMETHEXPR:
 		if n.Sym != nil {
 			mode.Fprintf(s, "%v-%v%j", n.Op, n.Sym, n)
 		} else {
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index d661fca2d1..842025705b 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -1218,18 +1218,16 @@ func (w *exportWriter) expr(n *Node) {
 		w.pos(n.Pos)
 		w.value(n.Type, n.Val())
 
-	case ONAME:
+	case OMETHEXPR:
 		// Special case: explicit name of func (*T) method(...) is turned into pkg.(*T).method,
 		// but for export, this should be rendered as (*pkg.T).meth.
 		// These nodes have the special property that they are names with a left OTYPE and a right ONAME.
-		if n.isMethodExpression() {
-			w.op(OXDOT)
-			w.pos(n.Pos)
-			w.expr(n.Left) // n.Left.Op == OTYPE
-			w.selector(n.Right.Sym)
-			break
-		}
+		w.op(OXDOT)
+		w.pos(n.Pos)
+		w.expr(n.Left) // n.Left.Op == OTYPE
+		w.selector(n.Right.Sym)
 
+	case ONAME:
 		// Package scope name.
 		if (n.Class() == PEXTERN || n.Class() == PFUNC) && !n.isBlank() {
 			w.op(ONONAME)
diff --git a/src/cmd/compile/internal/gc/initorder.go b/src/cmd/compile/internal/gc/initorder.go
index f82df04b73..ecbfc5631a 100644
--- a/src/cmd/compile/internal/gc/initorder.go
+++ b/src/cmd/compile/internal/gc/initorder.go
@@ -273,12 +273,11 @@ func (d *initDeps) inspectList(l Nodes) { inspectList(l, d.visit) }
 // referenced by n, if any.
 func (d *initDeps) visit(n *Node) bool {
 	switch n.Op {
-	case ONAME:
-		if n.isMethodExpression() {
-			d.foundDep(n.MethodName())
-			return false
-		}
+	case OMETHEXPR:
+		d.foundDep(n.MethodName())
+		return false
 
+	case ONAME:
 		switch n.Class() {
 		case PEXTERN, PFUNC:
 			d.foundDep(n)
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index db53b2aae1..0695b161f1 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -260,15 +260,14 @@ func inlFlood(n *Node) {
 	// because after inlining they might be callable.
 	inspectList(asNodes(n.Func.Inl.Body), func(n *Node) bool {
 		switch n.Op {
+		case OMETHEXPR:
+			inlFlood(n.MethodName())
+
 		case ONAME:
 			switch n.Class() {
 			case PFUNC:
-				if n.isMethodExpression() {
-					inlFlood(n.MethodName())
-				} else {
-					inlFlood(n)
-					exportsym(n)
-				}
+				inlFlood(n)
+				exportsym(n)
 			case PEXTERN:
 				exportsym(n)
 			}
@@ -709,17 +708,16 @@ func inlnode(n *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 func inlCallee(fn *Node) *Node {
 	fn = staticValue(fn)
 	switch {
-	case fn.Op == ONAME && fn.Class() == PFUNC:
-		if fn.isMethodExpression() {
-			n := fn.MethodName()
-			// Check that receiver type matches fn.Left.
-			// TODO(mdempsky): Handle implicit dereference
-			// of pointer receiver argument?
-			if n == nil || !types.Identical(n.Type.Recv().Type, fn.Left.Type) {
-				return nil
-			}
-			return n
+	case fn.Op == OMETHEXPR:
+		n := fn.MethodName()
+		// Check that receiver type matches fn.Left.
+		// TODO(mdempsky): Handle implicit dereference
+		// of pointer receiver argument?
+		if n == nil || !types.Identical(n.Type.Recv().Type, fn.Left.Type) {
+			return nil
 		}
+		return n
+	case fn.Op == ONAME && fn.Class() == PFUNC:
 		return fn
 	case fn.Op == OCLOSURE:
 		c := fn.Func.Decl
@@ -963,7 +961,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 			ninit.AppendNodes(&callee.Ninit)
 			callee = callee.Left
 		}
-		if callee.Op != ONAME && callee.Op != OCLOSURE {
+		if callee.Op != ONAME && callee.Op != OCLOSURE && callee.Op != OMETHEXPR {
 			Fatalf("unexpected callee expression: %v", callee)
 		}
 	}
@@ -1323,6 +1321,9 @@ func (subst *inlsubst) node(n *Node) *Node {
 		}
 		return n
 
+	case OMETHEXPR:
+		return n
+
 	case OLITERAL, ONIL, OTYPE:
 		// If n is a named constant or type, we can continue
 		// using it in the inline copy. Otherwise, make a copy
diff --git a/src/cmd/compile/internal/gc/scc.go b/src/cmd/compile/internal/gc/scc.go
index 8e41ebac29..891012cbc9 100644
--- a/src/cmd/compile/internal/gc/scc.go
+++ b/src/cmd/compile/internal/gc/scc.go
@@ -77,15 +77,19 @@ func (v *bottomUpVisitor) visit(n *Node) uint32 {
 		switch n.Op {
 		case ONAME:
 			if n.Class() == PFUNC {
-				if n.isMethodExpression() {
-					n = n.MethodName()
-				}
 				if n != nil && n.Name.Defn != nil {
 					if m := v.visit(n.Name.Defn); m < min {
 						min = m
 					}
 				}
 			}
+		case OMETHEXPR:
+			fn := n.MethodName()
+			if fn != nil && fn.Name.Defn != nil {
+				if m := v.visit(fn.Name.Defn); m < min {
+					min = m
+				}
+			}
 		case ODOTMETH:
 			fn := n.MethodName()
 			if fn != nil && fn.Op == ONAME && fn.Class() == PFUNC && fn.Name.Defn != nil {
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 5727245562..3b4056cf7d 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -68,7 +68,7 @@ func (s *InitSchedule) tryStaticInit(n *Node) bool {
 // like staticassign but we are copying an already
 // initialized value r.
 func (s *InitSchedule) staticcopy(l *Node, r *Node) bool {
-	if r.Op != ONAME {
+	if r.Op != ONAME && r.Op != OMETHEXPR {
 		return false
 	}
 	if r.Class() == PFUNC {
@@ -95,7 +95,7 @@ func (s *InitSchedule) staticcopy(l *Node, r *Node) bool {
 	}
 
 	switch r.Op {
-	case ONAME:
+	case ONAME, OMETHEXPR:
 		if s.staticcopy(l, r) {
 			return true
 		}
@@ -171,7 +171,7 @@ func (s *InitSchedule) staticassign(l *Node, r *Node) bool {
 	}
 
 	switch r.Op {
-	case ONAME:
+	case ONAME, OMETHEXPR:
 		return s.staticcopy(l, r)
 
 	case ONIL:
@@ -383,7 +383,7 @@ func readonlystaticname(t *types.Type) *Node {
 }
 
 func (n *Node) isSimpleName() bool {
-	return n.Op == ONAME && n.Class() != PAUTOHEAP && n.Class() != PEXTERN
+	return (n.Op == ONAME || n.Op == OMETHEXPR) && n.Class() != PAUTOHEAP && n.Class() != PEXTERN
 }
 
 func litas(l *Node, r *Node, init *Nodes) {
@@ -870,7 +870,7 @@ func anylit(n *Node, var_ *Node, init *Nodes) {
 	default:
 		Fatalf("anylit: not lit, op=%v node=%v", n.Op, n)
 
-	case ONAME:
+	case ONAME, OMETHEXPR:
 		a := nod(OAS, var_, n)
 		a = typecheck(a, ctxStmt)
 		init.Append(a)
@@ -1007,7 +1007,7 @@ func stataddr(nam *Node, n *Node) bool {
 	}
 
 	switch n.Op {
-	case ONAME:
+	case ONAME, OMETHEXPR:
 		*nam = *n
 		return true
 
@@ -1172,7 +1172,7 @@ func genAsStatic(as *Node) {
 	switch {
 	case as.Right.Op == OLITERAL:
 		litsym(&nam, as.Right, int(as.Right.Type.Width))
-	case as.Right.Op == ONAME && as.Right.Class() == PFUNC:
+	case (as.Right.Op == ONAME || as.Right.Op == OMETHEXPR) && as.Right.Class() == PFUNC:
 		pfuncsym(&nam, as.Right)
 	default:
 		Fatalf("genAsStatic: rhs %v", as.Right)
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index e23a189d71..88ff8d684c 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -2016,6 +2016,9 @@ func (s *state) expr(n *Node) *ssa.Value {
 	case OCFUNC:
 		aux := n.Left.Sym.Linksym()
 		return s.entryNewValue1A(ssa.OpAddr, n.Type, aux, s.sb)
+	case OMETHEXPR:
+		sym := funcsym(n.Sym).Linksym()
+		return s.entryNewValue1A(ssa.OpAddr, types.NewPtr(n.Type), sym, s.sb)
 	case ONAME:
 		if n.Class() == PFUNC {
 			// "value" of a function is the address of the function's closure
diff --git a/src/cmd/compile/internal/gc/syntax.go b/src/cmd/compile/internal/gc/syntax.go
index 343d5b171c..39f2996808 100644
--- a/src/cmd/compile/internal/gc/syntax.go
+++ b/src/cmd/compile/internal/gc/syntax.go
@@ -303,11 +303,6 @@ func (n *Node) mayBeShared() bool {
 	return false
 }
 
-// isMethodExpression reports whether n represents a method expression T.M.
-func (n *Node) isMethodExpression() bool {
-	return n.Op == ONAME && n.Left != nil && n.Left.Op == OTYPE && n.Right != nil && n.Right.Op == ONAME
-}
-
 // funcname returns the name (without the package) of the function n.
 func (n *Node) funcname() string {
 	if n == nil || n.Func == nil || n.Func.Nname == nil {
@@ -599,15 +594,10 @@ func (p *Param) SetEmbedFiles(list []string) {
 // will be the qualified method name (e.g., "T.m") and
 // f.Func.Shortname is the bare method name (e.g., "m").
 //
-// A method expression (T.M) is represented as an ONAME node
-// like a function name would be, but n.Left and n.Right point to
-// the type and method, respectively. A method expression can
-// be distinguished from a normal function ONAME by checking
-// n.IsMethodExpression. Unlike ordinary ONAME nodes, each
-// distinct mention of a method expression in the source code
-// constructs a fresh ONAME node.
-// TODO(rsc): Method expressions deserve their own opcode
-// instead of violating invariants of ONAME.
+// A method expression (T.M) is represented as an OMETHEXPR node,
+// in which n.Left and n.Right point to the type and method, respectively.
+// Each distinct mention of a method expression in the source code
+// constructs a fresh node.
 //
 // A method value (t.M) is represented by ODOTMETH/ODOTINTER
 // when it is called directly and by OCALLPART otherwise.
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 11c1ae38ea..5cc7c8a34c 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -2408,7 +2408,7 @@ func typecheckMethodExpr(n *Node) (res *Node) {
 		return n
 	}
 
-	n.Op = ONAME
+	n.Op = OMETHEXPR
 	if n.Name == nil {
 		n.Name = new(Name)
 	}
@@ -2668,7 +2668,7 @@ notenough:
 			// call is the expression being called, not the overall call.
 			// Method expressions have the form T.M, and the compiler has
 			// rewritten those to ONAME nodes but left T in Left.
-			if call.isMethodExpression() {
+			if call.Op == OMETHEXPR {
 				yyerror("not enough arguments in call to method expression %v%s", call, details)
 			} else {
 				yyerror("not enough arguments in call to %v%s", call, details)
@@ -4032,10 +4032,10 @@ func (n *Node) MethodName() *Node {
 
 // MethodFunc is like MethodName, but returns the types.Field instead.
 func (n *Node) MethodFunc() *types.Field {
-	switch {
-	case n.Op == ODOTMETH || n.isMethodExpression():
+	switch n.Op {
+	case ODOTMETH, OMETHEXPR:
 		return n.Opt().(*types.Field)
-	case n.Op == OCALLPART:
+	case OCALLPART:
 		return callpartMethod(n)
 	}
 	Fatalf("unexpected node: %v (%v)", n, n.Op)
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index ae344fc8e1..7bf5281a67 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -464,7 +464,7 @@ opswitch:
 		Dump("walk", n)
 		Fatalf("walkexpr: switch 1 unknown op %+S", n)
 
-	case ONONAME, OEMPTY, OGETG, ONEWOBJ:
+	case ONONAME, OEMPTY, OGETG, ONEWOBJ, OMETHEXPR:
 
 	case OTYPE, ONAME, OLITERAL, ONIL:
 		// TODO(mdempsky): Just return n; see discussion on CL 38655.
-- 
GitLab


From c22bc745c3b822cdf6da0ea2f9b5cac858e5a5ac Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 24 Nov 2020 11:07:48 -0500
Subject: [PATCH 0053/2400] [dev.regabi] cmd/compile: delete n.List after
 collapsing OADDSTR to OLITERAL

The leftover n.List is clearly unnecessary, but it makes the
inlining cost of the expression unnecessarily high.

This change breaks toolstash -cmp:

	# cmd/internal/src
	toolstash: compiler output differs, with optimizers disabled (-N)

	inconsistent log line:
	/tmp/go-build866291351/b230/_pkg_.a.log:77:
		/Users/rsc/go/src/cmd/internal/src/pos.go:275:6: can inline (*PosBase).SymFilename with cost 9 as: method(*PosBase) func() string { if b != nil { return b.symFilename }; return "gofile..??" }
	/tmp/go-build866291351/b230/_pkg_.a.stash.log:77:
		/Users/rsc/go/src/cmd/internal/src/pos.go:275:6: can inline (*PosBase).SymFilename with cost 11 as: method(*PosBase) func() string { if b != nil { return b.symFilename }; return "gofile..??" }

Separated from other constant work so that the bigger CL can pass toolstash -cmp.

Change-Id: I5c7ddbc8373207b5b9824eafb8639488da0ca1b7
Reviewed-on: https://go-review.googlesource.com/c/go/+/272868
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/const.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index c30d24ae1a..ebf3896a0a 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -604,6 +604,7 @@ func evconst(n *Node) {
 		if len(s) == 1 && Isconst(s[0], constant.String) {
 			n.Op = OLITERAL
 			n.SetVal(s[0].Val())
+			n.List.Set(nil)
 		} else {
 			n.List.Set(s)
 		}
-- 
GitLab


From 6826287c6b1ff2e3f23611472a9d81ac5e3aa89a Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 24 Nov 2020 09:37:54 -0500
Subject: [PATCH 0054/2400] [dev.regabi] cmd/compile: replace evconst with
 non-mutating version

evconst is one of the largest sources of Op rewrites,
which prevent separating different kinds of nodes
(in this case, arithmetic nodes and OLITERAL nodes).

The change in swt.go is necessary because otherwise
the syntax graph ends up containing that OLEN expression
multiple times, which violates the invariant that it's a tree
except for ONAME, OLITERAL, and OTYPE nodes.
(Before, the OLEN was overwritten by an OLITERAL, so the
invariant still held, but now that we don't overwrite it,
we need a different copy for each instance.)

Passes toolstash -cmp.

Change-Id: Ia004774ab6852fb384805d0f9f9f234b40842811
Reviewed-on: https://go-review.googlesource.com/c/go/+/272869
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/const.go     | 115 +++++++++++++----------
 src/cmd/compile/internal/gc/swt.go       |   5 +-
 src/cmd/compile/internal/gc/typecheck.go |  15 ++-
 src/cmd/compile/internal/gc/walk.go      |   4 +-
 4 files changed, 76 insertions(+), 63 deletions(-)

diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index ebf3896a0a..18d5feb813 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -542,87 +542,105 @@ func Isconst(n *Node, ct constant.Kind) bool {
 	return consttype(n) == ct
 }
 
-// evconst rewrites constant expressions into OLITERAL nodes.
-func evconst(n *Node) {
+// evalConst returns a constant-evaluated expression equivalent to n.
+// If n is not a constant, evalConst returns n.
+// Otherwise, evalConst returns a new OLITERAL with the same value as n,
+// and with .Orig pointing back to n.
+func evalConst(n *Node) *Node {
 	nl, nr := n.Left, n.Right
 
 	// Pick off just the opcodes that can be constant evaluated.
 	switch op := n.Op; op {
 	case OPLUS, ONEG, OBITNOT, ONOT:
 		if nl.Op == OLITERAL {
-			setconst(n, unaryOp(op, nl.Val(), n.Type))
+			return origConst(n, unaryOp(op, nl.Val(), n.Type))
 		}
 
 	case OADD, OSUB, OMUL, ODIV, OMOD, OOR, OXOR, OAND, OANDNOT, OOROR, OANDAND:
 		if nl.Op == OLITERAL && nr.Op == OLITERAL {
-			setconst(n, binaryOp(nl.Val(), op, nr.Val()))
+			return origConst(n, binaryOp(nl.Val(), op, nr.Val()))
 		}
 
 	case OEQ, ONE, OLT, OLE, OGT, OGE:
 		if nl.Op == OLITERAL && nr.Op == OLITERAL {
-			setboolconst(n, compareOp(nl.Val(), op, nr.Val()))
+			return origBoolConst(n, compareOp(nl.Val(), op, nr.Val()))
 		}
 
 	case OLSH, ORSH:
 		if nl.Op == OLITERAL && nr.Op == OLITERAL {
-			setconst(n, shiftOp(nl.Val(), op, nr.Val()))
+			return origConst(n, shiftOp(nl.Val(), op, nr.Val()))
 		}
 
 	case OCONV, ORUNESTR:
 		if okforconst[n.Type.Etype] && nl.Op == OLITERAL {
-			setconst(n, convertVal(nl.Val(), n.Type, true))
+			return origConst(n, convertVal(nl.Val(), n.Type, true))
 		}
 
 	case OCONVNOP:
 		if okforconst[n.Type.Etype] && nl.Op == OLITERAL {
 			// set so n.Orig gets OCONV instead of OCONVNOP
 			n.Op = OCONV
-			setconst(n, nl.Val())
+			return origConst(n, nl.Val())
 		}
 
 	case OADDSTR:
 		// Merge adjacent constants in the argument list.
 		s := n.List.Slice()
-		for i1 := 0; i1 < len(s); i1++ {
-			if Isconst(s[i1], constant.String) && i1+1 < len(s) && Isconst(s[i1+1], constant.String) {
-				// merge from i1 up to but not including i2
+		need := 0
+		for i := 0; i < len(s); i++ {
+			if i == 0 || !Isconst(s[i-1], constant.String) || !Isconst(s[i], constant.String) {
+				// Can't merge s[i] into s[i-1]; need a slot in the list.
+				need++
+			}
+		}
+		if need == len(s) {
+			return n
+		}
+		if need == 1 {
+			var strs []string
+			for _, c := range s {
+				strs = append(strs, c.StringVal())
+			}
+			return origConst(n, Val{U: strings.Join(strs, "")})
+		}
+		newList := make([]*Node, 0, need)
+		for i := 0; i < len(s); i++ {
+			if Isconst(s[i], constant.String) && i+1 < len(s) && Isconst(s[i+1], constant.String) {
+				// merge from i up to but not including i2
 				var strs []string
-				i2 := i1
+				i2 := i
 				for i2 < len(s) && Isconst(s[i2], constant.String) {
 					strs = append(strs, s[i2].StringVal())
 					i2++
 				}
 
-				nl := *s[i1]
-				nl.Orig = &nl
-				nl.SetVal(Val{strings.Join(strs, "")})
-				s[i1] = &nl
-				s = append(s[:i1+1], s[i2:]...)
+				nl := origConst(s[i], Val{U: strings.Join(strs, "")})
+				nl.Orig = nl // it's bigger than just s[i]
+				newList = append(newList, nl)
+				i = i2 - 1
+			} else {
+				newList = append(newList, s[i])
 			}
 		}
 
-		if len(s) == 1 && Isconst(s[0], constant.String) {
-			n.Op = OLITERAL
-			n.SetVal(s[0].Val())
-			n.List.Set(nil)
-		} else {
-			n.List.Set(s)
-		}
+		n = n.copy()
+		n.List.Set(newList)
+		return n
 
 	case OCAP, OLEN:
 		switch nl.Type.Etype {
 		case TSTRING:
 			if Isconst(nl, constant.String) {
-				setintconst(n, int64(len(nl.StringVal())))
+				return origIntConst(n, int64(len(nl.StringVal())))
 			}
 		case TARRAY:
 			if !hascallchan(nl) {
-				setintconst(n, nl.Type.NumElem())
+				return origIntConst(n, nl.Type.NumElem())
 			}
 		}
 
 	case OALIGNOF, OOFFSETOF, OSIZEOF:
-		setintconst(n, evalunsafe(n))
+		return origIntConst(n, evalunsafe(n))
 
 	case OREAL, OIMAG:
 		if nl.Op == OLITERAL {
@@ -647,7 +665,7 @@ func evconst(n *Node) {
 				}
 				re = im
 			}
-			setconst(n, Val{re})
+			return origConst(n, Val{re})
 		}
 
 	case OCOMPLEX:
@@ -656,9 +674,11 @@ func evconst(n *Node) {
 			c := newMpcmplx()
 			c.Real.Set(toflt(nl.Val()).U.(*Mpflt))
 			c.Imag.Set(toflt(nr.Val()).U.(*Mpflt))
-			setconst(n, Val{c})
+			return origConst(n, Val{c})
 		}
 	}
+
+	return n
 }
 
 func match(x, y Val) (Val, Val) {
@@ -927,27 +947,21 @@ func shiftOp(x Val, op Op, y Val) Val {
 	return Val{U: u}
 }
 
-// setconst rewrites n as an OLITERAL with value v.
-func setconst(n *Node, v Val) {
-	// If constant folding failed, mark n as broken and give up.
+// origConst returns an OLITERAL with orig n and value v.
+func origConst(n *Node, v Val) *Node {
+	// If constant folding was attempted (we were called)
+	// but it produced an invalid constant value,
+	// mark n as broken and give up.
 	if v.U == nil {
 		n.Type = nil
-		return
-	}
-
-	// Ensure n.Orig still points to a semantically-equivalent
-	// expression after we rewrite n into a constant.
-	if n.Orig == n {
-		n.Orig = n.sepcopy()
+		return n
 	}
 
-	*n = Node{
-		Op:      OLITERAL,
-		Pos:     n.Pos,
-		Orig:    n.Orig,
-		Type:    n.Type,
-		Xoffset: BADWIDTH,
-	}
+	orig := n
+	n = nod(OLITERAL, nil, nil)
+	n.Orig = orig
+	n.Pos = orig.Pos
+	n.Type = orig.Type
 	n.SetVal(v)
 
 	// Check range.
@@ -965,6 +979,7 @@ func setconst(n *Node, v Val) {
 			n.SetVal(Val{trunccmplxlit(v.U.(*Mpcplx), n.Type)})
 		}
 	}
+	return n
 }
 
 func assertRepresents(t *types.Type, v Val) {
@@ -983,14 +998,14 @@ func represents(t *types.Type, v Val) bool {
 	return t == vt || (t == types.UntypedRune && vt == types.UntypedInt)
 }
 
-func setboolconst(n *Node, v bool) {
-	setconst(n, Val{U: v})
+func origBoolConst(n *Node, v bool) *Node {
+	return origConst(n, Val{U: v})
 }
 
-func setintconst(n *Node, v int64) {
+func origIntConst(n *Node, v int64) *Node {
 	u := new(Mpint)
 	u.SetInt64(v)
-	setconst(n, Val{u})
+	return origConst(n, Val{u})
 }
 
 // nodlit returns a new untyped constant with value v.
diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index 068f1a34e1..8459bd7c18 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -386,14 +386,13 @@ func (s *exprSwitch) flush() {
 		runs = append(runs, cc[start:])
 
 		// Perform two-level binary search.
-		nlen := nod(OLEN, s.exprname, nil)
 		binarySearch(len(runs), &s.done,
 			func(i int) *Node {
-				return nod(OLE, nlen, nodintconst(runLen(runs[i-1])))
+				return nod(OLE, nod(OLEN, s.exprname, nil), nodintconst(runLen(runs[i-1])))
 			},
 			func(i int, nif *Node) {
 				run := runs[i]
-				nif.Left = nod(OEQ, nlen, nodintconst(runLen(run)))
+				nif.Left = nod(OEQ, nod(OLEN, s.exprname, nil), nodintconst(runLen(run)))
 				s.search(run, &nif.Nbody)
 			},
 		)
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 5cc7c8a34c..e014a0ba2d 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -776,7 +776,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		}
 
 		if iscmp[n.Op] {
-			evconst(n)
+			n = evalConst(n)
 			t = types.UntypedBool
 			if n.Op != OLITERAL {
 				l, r = defaultlit2(l, r, true)
@@ -786,12 +786,13 @@ func typecheck1(n *Node, top int) (res *Node) {
 		}
 
 		if et == TSTRING && n.Op == OADD {
-			// create OADDSTR node with list of strings in x + y + z + (w + v) + ...
-			n.Op = OADDSTR
-
+			// create or update OADDSTR node with list of strings in x + y + z + (w + v) + ...
 			if l.Op == OADDSTR {
-				n.List.Set(l.List.Slice())
+				orig := n
+				n = l
+				n.Pos = orig.Pos
 			} else {
+				n = nodl(n.Pos, OADDSTR, nil, nil)
 				n.List.Set1(l)
 			}
 			if r.Op == OADDSTR {
@@ -799,8 +800,6 @@ func typecheck1(n *Node, top int) (res *Node) {
 			} else {
 				n.List.Append(r)
 			}
-			n.Left = nil
-			n.Right = nil
 		}
 
 		if (op == ODIV || op == OMOD) && Isconst(r, constant.Int) {
@@ -2091,7 +2090,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		}
 	}
 
-	evconst(n)
+	n = evalConst(n)
 	if n.Op == OTYPE && top&ctxType == 0 {
 		if !n.Type.Broke() {
 			yyerror("type %v is not an expression", n.Type)
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 7bf5281a67..9971fb0c0d 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -513,7 +513,7 @@ opswitch:
 		}
 		if t.IsArray() {
 			safeexpr(n.Left, init)
-			setintconst(n, t.NumElem())
+			n = origIntConst(n, t.NumElem())
 			n.SetTypecheck(1)
 		}
 
@@ -1580,7 +1580,7 @@ opswitch:
 	// walk of y%1 may have replaced it by 0.
 	// Check whether n with its updated args is itself now a constant.
 	t := n.Type
-	evconst(n)
+	n = evalConst(n)
 	if n.Type != t {
 		Fatalf("evconst changed Type: %v had type %v, now %v", n, t, n.Type)
 	}
-- 
GitLab


From 7d72951229a4d55c5643d0ec7d7f7653d6efda3d Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 13 Nov 2020 23:36:48 -0800
Subject: [PATCH 0055/2400] [dev.regabi] cmd/compile: replace Val with
 go/constant.Value
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This replaces the compiler's legacy constant representation with
go/constant, which is used by go/types. This should ease integrating
with the new go/types-based type checker in the future.

Performance difference is mixed, but there's still room for
improvement.

name                      old time/op       new time/op       delta
Template                        280ms ± 6%        281ms ± 6%    ~     (p=0.488 n=592+587)
Unicode                         132ms ±11%        129ms ±11%  -2.61%  (p=0.000 n=592+591)
GoTypes                         865ms ± 3%        866ms ± 3%  +0.16%  (p=0.019 n=572+577)
Compiler                        3.60s ± 3%        3.60s ± 3%    ~     (p=0.083 n=578+582)
SSA                             8.27s ± 2%        8.28s ± 2%  +0.14%  (p=0.002 n=575+580)
Flate                           177ms ± 8%        176ms ± 8%    ~     (p=0.133 n=580+590)
GoParser                        238ms ± 7%        237ms ± 6%    ~     (p=0.569 n=587+591)
Reflect                         542ms ± 4%        543ms ± 4%    ~     (p=0.064 n=581+579)
Tar                             244ms ± 6%        244ms ± 6%    ~     (p=0.880 n=586+584)
XML                             322ms ± 5%        322ms ± 5%    ~     (p=0.449 n=589+590)
LinkCompiler                    454ms ± 6%        453ms ± 6%    ~     (p=0.249 n=585+583)
ExternalLinkCompiler            1.35s ± 4%        1.35s ± 4%    ~     (p=0.968 n=590+588)
LinkWithoutDebugCompiler        279ms ± 7%        280ms ± 7%    ~     (p=0.270 n=589+586)
[Geo mean]                      535ms             534ms       -0.17%

name                      old user-time/op  new user-time/op  delta
Template                        599ms ±22%        602ms ±21%    ~     (p=0.377 n=588+590)
Unicode                         410ms ±43%        376ms ±39%  -8.36%  (p=0.000 n=596+586)
GoTypes                         1.96s ±15%        1.97s ±17%  +0.70%  (p=0.031 n=596+594)
Compiler                        7.47s ± 9%        7.50s ± 8%  +0.38%  (p=0.031 n=591+583)
SSA                             16.2s ± 4%        16.2s ± 5%    ~     (p=0.617 n=531+531)
Flate                           298ms ±25%        292ms ±30%  -2.14%  (p=0.001 n=594+596)
GoParser                        379ms ±20%        381ms ±21%    ~     (p=0.312 n=578+584)
Reflect                         1.24s ±20%        1.25s ±23%  +0.88%  (p=0.031 n=592+596)
Tar                             471ms ±23%        473ms ±21%    ~     (p=0.616 n=593+587)
XML                             674ms ±20%        681ms ±21%  +1.03%  (p=0.050 n=584+587)
LinkCompiler                    842ms ±10%        839ms ±10%    ~     (p=0.074 n=587+590)
ExternalLinkCompiler            1.65s ± 7%        1.65s ± 7%    ~     (p=0.767 n=590+585)
LinkWithoutDebugCompiler        378ms ±11%        379ms ±12%    ~     (p=0.677 n=591+586)
[Geo mean]                      1.02s             1.02s       -0.52%

name                      old alloc/op      new alloc/op      delta
Template                       37.4MB ± 0%       37.4MB ± 0%  +0.06%  (p=0.000 n=589+585)
Unicode                        29.6MB ± 0%       28.6MB ± 0%  -3.11%  (p=0.000 n=574+566)
GoTypes                         120MB ± 0%        120MB ± 0%  -0.01%  (p=0.000 n=594+593)
Compiler                        568MB ± 0%        568MB ± 0%  -0.02%  (p=0.000 n=588+591)
SSA                            1.45GB ± 0%       1.45GB ± 0%  -0.16%  (p=0.000 n=596+592)
Flate                          22.6MB ± 0%       22.5MB ± 0%  -0.36%  (p=0.000 n=593+595)
GoParser                       30.1MB ± 0%       30.1MB ± 0%  -0.01%  (p=0.000 n=590+594)
Reflect                        77.8MB ± 0%       77.8MB ± 0%    ~     (p=0.631 n=584+591)
Tar                            34.1MB ± 0%       34.1MB ± 0%  -0.04%  (p=0.000 n=584+588)
XML                            43.6MB ± 0%       43.6MB ± 0%  +0.07%  (p=0.000 n=593+591)
LinkCompiler                   98.6MB ± 0%       98.6MB ± 0%    ~     (p=0.096 n=590+589)
ExternalLinkCompiler           89.6MB ± 0%       89.6MB ± 0%    ~     (p=0.695 n=590+587)
LinkWithoutDebugCompiler       57.2MB ± 0%       57.2MB ± 0%    ~     (p=0.674 n=590+589)
[Geo mean]                     78.5MB            78.3MB       -0.28%

name                      old allocs/op     new allocs/op     delta
Template                         379k ± 0%         380k ± 0%  +0.33%  (p=0.000 n=593+590)
Unicode                          344k ± 0%         338k ± 0%  -1.67%  (p=0.000 n=594+589)
GoTypes                         1.30M ± 0%        1.31M ± 0%  +0.19%  (p=0.000 n=592+591)
Compiler                        5.40M ± 0%        5.41M ± 0%  +0.23%  (p=0.000 n=587+585)
SSA                             14.2M ± 0%        14.2M ± 0%  +0.08%  (p=0.000 n=594+591)
Flate                            231k ± 0%         230k ± 0%  -0.42%  (p=0.000 n=588+589)
GoParser                         314k ± 0%         315k ± 0%  +0.16%  (p=0.000 n=587+594)
Reflect                          975k ± 0%         976k ± 0%  +0.10%  (p=0.000 n=590+594)
Tar                              344k ± 0%         345k ± 0%  +0.24%  (p=0.000 n=595+590)
XML                              422k ± 0%         424k ± 0%  +0.57%  (p=0.000 n=590+589)
LinkCompiler                     538k ± 0%         538k ± 0%  -0.00%  (p=0.045 n=592+587)
ExternalLinkCompiler             593k ± 0%         593k ± 0%    ~     (p=0.171 n=588+587)
LinkWithoutDebugCompiler         172k ± 0%         172k ± 0%    ~     (p=0.996 n=590+585)
[Geo mean]                       685k              685k       -0.02%

name                      old maxRSS/op     new maxRSS/op     delta
Template                        53.7M ± 8%        53.8M ± 8%    ~     (p=0.666 n=576+574)
Unicode                         54.4M ±12%        55.0M ±10%  +1.15%  (p=0.000 n=591+588)
GoTypes                         95.1M ± 4%        95.1M ± 4%    ~     (p=0.948 n=589+591)
Compiler                         334M ± 6%         334M ± 6%    ~     (p=0.875 n=592+593)
SSA                              792M ± 5%         791M ± 5%    ~     (p=0.067 n=592+591)
Flate                           39.9M ±11%        40.0M ±10%    ~     (p=0.131 n=596+596)
GoParser                        45.2M ±11%        45.3M ±11%    ~     (p=0.353 n=592+590)
Reflect                         76.1M ± 5%        76.2M ± 5%    ~     (p=0.114 n=594+594)
Tar                             49.4M ±10%        49.6M ± 9%  +0.57%  (p=0.015 n=590+593)
XML                             57.4M ± 9%        57.7M ± 8%  +0.67%  (p=0.000 n=592+580)
LinkCompiler                     183M ± 2%         183M ± 2%    ~     (p=0.229 n=587+591)
ExternalLinkCompiler             187M ± 2%         187M ± 3%    ~     (p=0.362 n=571+562)
LinkWithoutDebugCompiler         143M ± 3%         143M ± 3%    ~     (p=0.350 n=584+586)
[Geo mean]                       103M              103M       +0.23%

Passes toolstash-check.

Fixes #4617.

Change-Id: Id4f6759b4afc5e002770091d0d4f6e272ee6cbdd
Reviewed-on: https://go-review.googlesource.com/c/go/+/272654
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/fmtmap_test.go           |  12 +-
 src/cmd/compile/internal/gc/const.go     | 895 +++++++++--------------
 src/cmd/compile/internal/gc/dcl.go       |   4 +-
 src/cmd/compile/internal/gc/export.go    |   2 +-
 src/cmd/compile/internal/gc/fmt.go       |  84 +--
 src/cmd/compile/internal/gc/go.go        |   8 -
 src/cmd/compile/internal/gc/iexport.go   |  30 +-
 src/cmd/compile/internal/gc/iimport.go   |  36 +-
 src/cmd/compile/internal/gc/main.go      |   7 +-
 src/cmd/compile/internal/gc/mpfloat.go   | 357 ---------
 src/cmd/compile/internal/gc/mpint.go     | 303 --------
 src/cmd/compile/internal/gc/noder.go     |  85 +--
 src/cmd/compile/internal/gc/obj.go       |  71 +-
 src/cmd/compile/internal/gc/sinit.go     |  20 +-
 src/cmd/compile/internal/gc/ssa.go       |  43 +-
 src/cmd/compile/internal/gc/subr.go      |   9 +-
 src/cmd/compile/internal/gc/swt.go       |   3 +-
 src/cmd/compile/internal/gc/syntax.go    |  16 +-
 src/cmd/compile/internal/gc/typecheck.go |  55 +-
 src/cmd/compile/internal/gc/universe.go  |  33 -
 src/cmd/compile/internal/gc/walk.go      |  20 +-
 src/cmd/compile/internal/types/type.go   |  14 +-
 test/fixedbugs/issue20232.go             |   4 +-
 23 files changed, 572 insertions(+), 1539 deletions(-)
 delete mode 100644 src/cmd/compile/internal/gc/mpfloat.go
 delete mode 100644 src/cmd/compile/internal/gc/mpint.go

diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
index 51134e4919..691eee3a1b 100644
--- a/src/cmd/compile/fmtmap_test.go
+++ b/src/cmd/compile/fmtmap_test.go
@@ -22,8 +22,6 @@ package main_test
 var knownFormats = map[string]string{
 	"*bytes.Buffer %s":                                "",
 	"*cmd/compile/internal/gc.EscLocation %v":         "",
-	"*cmd/compile/internal/gc.Mpflt %v":               "",
-	"*cmd/compile/internal/gc.Mpint %v":               "",
 	"*cmd/compile/internal/gc.Node %#v":               "",
 	"*cmd/compile/internal/gc.Node %+S":               "",
 	"*cmd/compile/internal/gc.Node %+v":               "",
@@ -60,9 +58,7 @@ var knownFormats = map[string]string{
 	"*cmd/internal/obj.Addr %v":                       "",
 	"*cmd/internal/obj.LSym %v":                       "",
 	"*math/big.Float %f":                              "",
-	"*math/big.Int %#x":                               "",
 	"*math/big.Int %s":                                "",
-	"*math/big.Int %v":                                "",
 	"[16]byte %x":                                     "",
 	"[]*cmd/compile/internal/ssa.Block %v":            "",
 	"[]*cmd/compile/internal/ssa.Value %v":            "",
@@ -91,9 +87,6 @@ var knownFormats = map[string]string{
 	"cmd/compile/internal/gc.Nodes %v":                "",
 	"cmd/compile/internal/gc.Op %#v":                  "",
 	"cmd/compile/internal/gc.Op %v":                   "",
-	"cmd/compile/internal/gc.Val %#v":                 "",
-	"cmd/compile/internal/gc.Val %T":                  "",
-	"cmd/compile/internal/gc.Val %v":                  "",
 	"cmd/compile/internal/gc.fmtMode %d":              "",
 	"cmd/compile/internal/gc.initKind %d":             "",
 	"cmd/compile/internal/gc.itag %v":                 "",
@@ -134,10 +127,10 @@ var knownFormats = map[string]string{
 	"error %v":                                        "",
 	"float64 %.2f":                                    "",
 	"float64 %.3f":                                    "",
-	"float64 %.6g":                                    "",
 	"float64 %g":                                      "",
-	"go/constant.Kind %d":                             "",
 	"go/constant.Kind %v":                             "",
+	"go/constant.Value %#v":                           "",
+	"go/constant.Value %v":                            "",
 	"int %#x":                                         "",
 	"int %-12d":                                       "",
 	"int %-6d":                                        "",
@@ -155,7 +148,6 @@ var knownFormats = map[string]string{
 	"int32 %v":                                        "",
 	"int32 %x":                                        "",
 	"int64 %#x":                                       "",
-	"int64 %+d":                                       "",
 	"int64 %-10d":                                     "",
 	"int64 %.5d":                                      "",
 	"int64 %d":                                        "",
diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 18d5feb813..84f0b11712 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -9,83 +9,80 @@ import (
 	"cmd/internal/src"
 	"fmt"
 	"go/constant"
+	"go/token"
+	"math"
 	"math/big"
 	"strings"
+	"unicode"
 )
 
-type Val struct {
-	// U contains one of:
-	// bool     bool when Ctype() == CTBOOL
-	// *Mpint   int when Ctype() == CTINT
-	// *Mpflt   float when Ctype() == CTFLT
-	// *Mpcplx  pair of floats when Ctype() == CTCPLX
-	// string   string when Ctype() == CTSTR
-	U interface{}
-}
+const (
+	// Maximum size in bits for big.Ints before signalling
+	// overflow and also mantissa precision for big.Floats.
+	Mpprec = 512
+)
 
-func (v Val) Kind() constant.Kind {
-	switch v.U.(type) {
+// ValueInterface returns the constant value stored in n as an interface{}.
+// It returns int64s for ints and runes, float64s for floats,
+// and complex128s for complex values.
+func (n *Node) ValueInterface() interface{} {
+	switch v := n.Val(); v.Kind() {
 	default:
-		Fatalf("unexpected Ctype for %T", v.U)
+		Fatalf("unexpected constant: %v", v)
 		panic("unreachable")
-	case nil:
-		return constant.Unknown
-	case bool:
-		return constant.Bool
-	case *Mpint:
-		return constant.Int
-	case *Mpflt:
-		return constant.Float
-	case *Mpcplx:
-		return constant.Complex
-	case string:
-		return constant.String
+	case constant.Bool:
+		return constant.BoolVal(v)
+	case constant.String:
+		return constant.StringVal(v)
+	case constant.Int:
+		return int64Val(n.Type, v)
+	case constant.Float:
+		return float64Val(v)
+	case constant.Complex:
+		return complex(float64Val(constant.Real(v)), float64Val(constant.Imag(v)))
 	}
 }
 
-func eqval(a, b Val) bool {
-	if a.Kind() != b.Kind() {
-		return false
+// int64Val returns v converted to int64.
+// Note: if t is uint64, very large values will be converted to negative int64.
+func int64Val(t *types.Type, v constant.Value) int64 {
+	if t.IsUnsigned() {
+		if x, ok := constant.Uint64Val(v); ok {
+			return int64(x)
+		}
+	} else {
+		if x, ok := constant.Int64Val(v); ok {
+			return x
+		}
 	}
-	switch x := a.U.(type) {
-	default:
-		Fatalf("unexpected Ctype for %T", a.U)
-		panic("unreachable")
-	case bool:
-		y := b.U.(bool)
-		return x == y
-	case *Mpint:
-		y := b.U.(*Mpint)
-		return x.Cmp(y) == 0
-	case *Mpflt:
-		y := b.U.(*Mpflt)
-		return x.Cmp(y) == 0
-	case *Mpcplx:
-		y := b.U.(*Mpcplx)
-		return x.Real.Cmp(&y.Real) == 0 && x.Imag.Cmp(&y.Imag) == 0
-	case string:
-		y := b.U.(string)
-		return x == y
+	Fatalf("%v out of range for %v", v, t)
+	panic("unreachable")
+}
+
+func float64Val(v constant.Value) float64 {
+	if x, _ := constant.Float64Val(v); !math.IsInf(x, 0) {
+		return x + 0 // avoid -0 (should not be needed, but be conservative)
 	}
+	Fatalf("bad float64 value: %v", v)
+	panic("unreachable")
 }
 
-// Interface returns the constant value stored in v as an interface{}.
-// It returns int64s for ints and runes, float64s for floats,
-// complex128s for complex values, and nil for constant nils.
-func (v Val) Interface() interface{} {
-	switch x := v.U.(type) {
+func bigFloatVal(v constant.Value) *big.Float {
+	f := new(big.Float)
+	f.SetPrec(Mpprec)
+	switch u := constant.Val(v).(type) {
+	case int64:
+		f.SetInt64(u)
+	case *big.Int:
+		f.SetInt(u)
+	case *big.Float:
+		f.Set(u)
+	case *big.Rat:
+		f.SetRat(u)
 	default:
-		Fatalf("unexpected Interface for %T", v.U)
-		panic("unreachable")
-	case bool, string:
-		return x
-	case *Mpint:
-		return x.Int64()
-	case *Mpflt:
-		return x.Float64()
-	case *Mpcplx:
-		return complex(x.Real.Float64(), x.Imag.Float64())
+		Fatalf("unexpected: %v", u)
 	}
+	return f
 }
 
 // Int64Val returns n as an int64.
@@ -94,7 +91,11 @@ func (n *Node) Int64Val() int64 {
 	if !Isconst(n, constant.Int) {
 		Fatalf("Int64Val(%v)", n)
 	}
-	return n.Val().U.(*Mpint).Int64()
+	x, ok := constant.Int64Val(n.Val())
+	if !ok {
+		Fatalf("Int64Val(%v)", n)
+	}
+	return x
 }
 
 // CanInt64 reports whether it is safe to call Int64Val() on n.
@@ -105,7 +106,21 @@ func (n *Node) CanInt64() bool {
 
 	// if the value inside n cannot be represented as an int64, the
 	// return value of Int64 is undefined
-	return n.Val().U.(*Mpint).CmpInt64(n.Int64Val()) == 0
+	_, ok := constant.Int64Val(n.Val())
+	return ok
+}
+
+// Uint64Val returns n as an uint64.
+// n must be an integer or rune constant.
+func (n *Node) Uint64Val() uint64 {
+	if !Isconst(n, constant.Int) {
+		Fatalf("Uint64Val(%v)", n)
+	}
+	x, ok := constant.Uint64Val(n.Val())
+	if !ok {
+		Fatalf("Uint64Val(%v)", n)
+	}
+	return x
 }
 
 // BoolVal returns n as a bool.
@@ -114,7 +129,7 @@ func (n *Node) BoolVal() bool {
 	if !Isconst(n, constant.Bool) {
 		Fatalf("BoolVal(%v)", n)
 	}
-	return n.Val().U.(bool)
+	return constant.BoolVal(n.Val())
 }
 
 // StringVal returns the value of a literal string Node as a string.
@@ -123,68 +138,48 @@ func (n *Node) StringVal() string {
 	if !Isconst(n, constant.String) {
 		Fatalf("StringVal(%v)", n)
 	}
-	return n.Val().U.(string)
+	return constant.StringVal(n.Val())
 }
 
-// truncate float literal fv to 32-bit or 64-bit precision
-// according to type; return truncated value.
-func truncfltlit(oldv *Mpflt, t *types.Type) *Mpflt {
-	if t == nil {
-		return oldv
+func roundFloat(v constant.Value, sz int64) constant.Value {
+	switch sz {
+	case 4:
+		f, _ := constant.Float32Val(v)
+		return makeFloat64(float64(f))
+	case 8:
+		f, _ := constant.Float64Val(v)
+		return makeFloat64(f)
 	}
+	Fatalf("unexpected size: %v", sz)
+	panic("unreachable")
+}
 
-	if overflow(Val{oldv}, t) {
+// truncate float literal fv to 32-bit or 64-bit precision
+// according to type; return truncated value.
+func truncfltlit(v constant.Value, t *types.Type) constant.Value {
+	if t.IsUntyped() || overflow(v, t) {
 		// If there was overflow, simply continuing would set the
 		// value to Inf which in turn would lead to spurious follow-on
 		// errors. Avoid this by returning the existing value.
-		return oldv
-	}
-
-	fv := newMpflt()
-
-	// convert large precision literal floating
-	// into limited precision (float64 or float32)
-	switch t.Etype {
-	case types.TFLOAT32:
-		fv.SetFloat64(oldv.Float32())
-	case types.TFLOAT64:
-		fv.SetFloat64(oldv.Float64())
-	default:
-		Fatalf("truncfltlit: unexpected Etype %v", t.Etype)
+		return v
 	}
 
-	return fv
+	return roundFloat(v, t.Size())
 }
 
 // truncate Real and Imag parts of Mpcplx to 32-bit or 64-bit
 // precision, according to type; return truncated value. In case of
 // overflow, calls yyerror but does not truncate the input value.
-func trunccmplxlit(oldv *Mpcplx, t *types.Type) *Mpcplx {
-	if t == nil {
-		return oldv
-	}
-
-	if overflow(Val{oldv}, t) {
+func trunccmplxlit(v constant.Value, t *types.Type) constant.Value {
+	if t.IsUntyped() || overflow(v, t) {
 		// If there was overflow, simply continuing would set the
 		// value to Inf which in turn would lead to spurious follow-on
 		// errors. Avoid this by returning the existing value.
-		return oldv
-	}
-
-	cv := newMpcmplx()
-
-	switch t.Etype {
-	case types.TCOMPLEX64:
-		cv.Real.SetFloat64(oldv.Real.Float32())
-		cv.Imag.SetFloat64(oldv.Imag.Float32())
-	case types.TCOMPLEX128:
-		cv.Real.SetFloat64(oldv.Real.Float64())
-		cv.Imag.SetFloat64(oldv.Imag.Float64())
-	default:
-		Fatalf("trunccplxlit: unexpected Etype %v", t.Etype)
+		return v
 	}
 
-	return cv
+	fsz := t.Size() / 2
+	return makeComplex(roundFloat(constant.Real(v), fsz), roundFloat(constant.Imag(v), fsz))
 }
 
 // TODO(mdempsky): Replace these with better APIs.
@@ -256,7 +251,7 @@ func convlit1(n *Node, t *types.Type, explicit bool, context func() string) *Nod
 
 	case OLITERAL:
 		v := convertVal(n.Val(), t, explicit)
-		if v.U == nil {
+		if v.Kind() == constant.Unknown {
 			break
 		}
 		n.Type = t
@@ -356,7 +351,7 @@ func operandType(op Op, t *types.Type) *types.Type {
 //
 // If explicit is true, then conversions from integer to string are
 // also allowed.
-func convertVal(v Val, t *types.Type, explicit bool) Val {
+func convertVal(v constant.Value, t *types.Type, explicit bool) constant.Value {
 	switch ct := v.Kind(); ct {
 	case constant.Bool:
 		if t.IsBoolean() {
@@ -381,153 +376,131 @@ func convertVal(v Val, t *types.Type, explicit bool) Val {
 			return v
 		case t.IsFloat():
 			v = toflt(v)
-			v = Val{truncfltlit(v.U.(*Mpflt), t)}
+			v = truncfltlit(v, t)
 			return v
 		case t.IsComplex():
 			v = tocplx(v)
-			v = Val{trunccmplxlit(v.U.(*Mpcplx), t)}
+			v = trunccmplxlit(v, t)
 			return v
 		}
 	}
 
-	return Val{}
+	return constant.MakeUnknown()
 }
 
-func tocplx(v Val) Val {
-	switch u := v.U.(type) {
-	case *Mpint:
-		c := newMpcmplx()
-		c.Real.SetInt(u)
-		c.Imag.SetFloat64(0.0)
-		v.U = c
-
-	case *Mpflt:
-		c := newMpcmplx()
-		c.Real.Set(u)
-		c.Imag.SetFloat64(0.0)
-		v.U = c
-	}
-
-	return v
+func tocplx(v constant.Value) constant.Value {
+	return constant.ToComplex(v)
 }
 
-func toflt(v Val) Val {
-	switch u := v.U.(type) {
-	case *Mpint:
-		f := newMpflt()
-		f.SetInt(u)
-		v.U = f
-
-	case *Mpcplx:
-		f := newMpflt()
-		f.Set(&u.Real)
-		if u.Imag.CmpFloat64(0) != 0 {
-			yyerror("constant %v truncated to real", u.GoString())
+func toflt(v constant.Value) constant.Value {
+	if v.Kind() == constant.Complex {
+		if constant.Sign(constant.Imag(v)) != 0 {
+			yyerror("constant %v truncated to real", v)
 		}
-		v.U = f
+		v = constant.Real(v)
 	}
 
-	return v
+	return constant.ToFloat(v)
 }
 
-func toint(v Val) Val {
-	switch u := v.U.(type) {
-	case *Mpint:
-
-	case *Mpflt:
-		i := new(Mpint)
-		if !i.SetFloat(u) {
-			if i.checkOverflow(0) {
-				yyerror("integer too large")
-			} else {
-				// The value of u cannot be represented as an integer;
-				// so we need to print an error message.
-				// Unfortunately some float values cannot be
-				// reasonably formatted for inclusion in an error
-				// message (example: 1 + 1e-100), so first we try to
-				// format the float; if the truncation resulted in
-				// something that looks like an integer we omit the
-				// value from the error message.
-				// (See issue #11371).
-				var t big.Float
-				t.Parse(u.GoString(), 10)
-				if t.IsInt() {
-					yyerror("constant truncated to integer")
-				} else {
-					yyerror("constant %v truncated to integer", u.GoString())
-				}
-			}
+func toint(v constant.Value) constant.Value {
+	if v.Kind() == constant.Complex {
+		if constant.Sign(constant.Imag(v)) != 0 {
+			yyerror("constant %v truncated to integer", v)
 		}
-		v.U = i
+		v = constant.Real(v)
+	}
 
-	case *Mpcplx:
-		i := new(Mpint)
-		if !i.SetFloat(&u.Real) || u.Imag.CmpFloat64(0) != 0 {
-			yyerror("constant %v truncated to integer", u.GoString())
-		}
+	if v := constant.ToInt(v); v.Kind() == constant.Int {
+		return v
+	}
 
-		v.U = i
+	// The value of v cannot be represented as an integer;
+	// so we need to print an error message.
+	// Unfortunately some float values cannot be
+	// reasonably formatted for inclusion in an error
+	// message (example: 1 + 1e-100), so first we try to
+	// format the float; if the truncation resulted in
+	// something that looks like an integer we omit the
+	// value from the error message.
+	// (See issue #11371).
+	f := bigFloatVal(v)
+	if f.MantExp(nil) > 2*Mpprec {
+		yyerror("integer too large")
+	} else {
+		var t big.Float
+		t.Parse(fmt.Sprint(v), 0)
+		if t.IsInt() {
+			yyerror("constant truncated to integer")
+		} else {
+			yyerror("constant %v truncated to integer", v)
+		}
 	}
 
-	return v
+	// Prevent follow-on errors.
+	// TODO(mdempsky): Use constant.MakeUnknown() instead.
+	return constant.MakeInt64(1)
 }
 
-func doesoverflow(v Val, t *types.Type) bool {
-	switch u := v.U.(type) {
-	case *Mpint:
-		if !t.IsInteger() {
-			Fatalf("overflow: %v integer constant", t)
+// doesoverflow reports whether constant value v is too large
+// to represent with type t.
+func doesoverflow(v constant.Value, t *types.Type) bool {
+	switch {
+	case t.IsInteger():
+		bits := uint(8 * t.Size())
+		if t.IsUnsigned() {
+			x, ok := constant.Uint64Val(v)
+			return !ok || x>>bits != 0
 		}
-		return u.Cmp(minintval[t.Etype]) < 0 || u.Cmp(maxintval[t.Etype]) > 0
-
-	case *Mpflt:
-		if !t.IsFloat() {
-			Fatalf("overflow: %v floating-point constant", t)
+		x, ok := constant.Int64Val(v)
+		if x < 0 {
+			x = ^x
 		}
-		return u.Cmp(minfltval[t.Etype]) <= 0 || u.Cmp(maxfltval[t.Etype]) >= 0
-
-	case *Mpcplx:
-		if !t.IsComplex() {
-			Fatalf("overflow: %v complex constant", t)
+		return !ok || x>>(bits-1) != 0
+	case t.IsFloat():
+		switch t.Size() {
+		case 4:
+			f, _ := constant.Float32Val(v)
+			return math.IsInf(float64(f), 0)
+		case 8:
+			f, _ := constant.Float64Val(v)
+			return math.IsInf(f, 0)
 		}
-		return u.Real.Cmp(minfltval[t.Etype]) <= 0 || u.Real.Cmp(maxfltval[t.Etype]) >= 0 ||
-			u.Imag.Cmp(minfltval[t.Etype]) <= 0 || u.Imag.Cmp(maxfltval[t.Etype]) >= 0
+	case t.IsComplex():
+		ft := floatForComplex(t)
+		return doesoverflow(constant.Real(v), ft) || doesoverflow(constant.Imag(v), ft)
 	}
-
-	return false
+	Fatalf("doesoverflow: %v, %v", v, t)
+	panic("unreachable")
 }
 
-func overflow(v Val, t *types.Type) bool {
+// overflow reports whether constant value v is too large
+// to represent with type t, and emits an error message if so.
+func overflow(v constant.Value, t *types.Type) bool {
 	// v has already been converted
 	// to appropriate form for t.
-	if t == nil || t.Etype == TIDEAL {
+	if t.IsUntyped() {
 		return false
 	}
-
-	// Only uintptrs may be converted to pointers, which cannot overflow.
-	if t.IsPtr() || t.IsUnsafePtr() {
-		return false
+	if v.Kind() == constant.Int && constant.BitLen(v) > Mpprec {
+		yyerror("integer too large")
+		return true
 	}
-
 	if doesoverflow(v, t) {
-		yyerror("constant %v overflows %v", v, t)
+		yyerror("constant %v overflows %v", vconv(v, 0), t)
 		return true
 	}
-
 	return false
-
 }
 
-func tostr(v Val) Val {
-	switch u := v.U.(type) {
-	case *Mpint:
-		var r rune = 0xFFFD
-		if u.Cmp(minintval[TINT32]) >= 0 && u.Cmp(maxintval[TINT32]) <= 0 {
-			r = rune(u.Int64())
+func tostr(v constant.Value) constant.Value {
+	if v.Kind() == constant.Int {
+		r := unicode.ReplacementChar
+		if x, ok := constant.Uint64Val(v); ok && x <= unicode.MaxRune {
+			r = rune(x)
 		}
-		v.U = string(r)
+		v = constant.MakeString(string(r))
 	}
-
 	return v
 }
 
@@ -542,6 +515,35 @@ func Isconst(n *Node, ct constant.Kind) bool {
 	return consttype(n) == ct
 }
 
+var tokenForOp = [...]token.Token{
+	OPLUS:   token.ADD,
+	ONEG:    token.SUB,
+	ONOT:    token.NOT,
+	OBITNOT: token.XOR,
+
+	OADD:    token.ADD,
+	OSUB:    token.SUB,
+	OMUL:    token.MUL,
+	ODIV:    token.QUO,
+	OMOD:    token.REM,
+	OOR:     token.OR,
+	OXOR:    token.XOR,
+	OAND:    token.AND,
+	OANDNOT: token.AND_NOT,
+	OOROR:   token.LOR,
+	OANDAND: token.LAND,
+
+	OEQ: token.EQL,
+	ONE: token.NEQ,
+	OLT: token.LSS,
+	OLE: token.LEQ,
+	OGT: token.GTR,
+	OGE: token.GEQ,
+
+	OLSH: token.SHL,
+	ORSH: token.SHR,
+}
+
 // evalConst returns a constant-evaluated expression equivalent to n.
 // If n is not a constant, evalConst returns n.
 // Otherwise, evalConst returns a new OLITERAL with the same value as n,
@@ -553,22 +555,52 @@ func evalConst(n *Node) *Node {
 	switch op := n.Op; op {
 	case OPLUS, ONEG, OBITNOT, ONOT:
 		if nl.Op == OLITERAL {
-			return origConst(n, unaryOp(op, nl.Val(), n.Type))
+			var prec uint
+			if n.Type.IsUnsigned() {
+				prec = uint(n.Type.Size() * 8)
+			}
+			return origConst(n, constant.UnaryOp(tokenForOp[op], nl.Val(), prec))
 		}
 
 	case OADD, OSUB, OMUL, ODIV, OMOD, OOR, OXOR, OAND, OANDNOT, OOROR, OANDAND:
 		if nl.Op == OLITERAL && nr.Op == OLITERAL {
-			return origConst(n, binaryOp(nl.Val(), op, nr.Val()))
+			rval := nr.Val()
+
+			// check for divisor underflow in complex division (see issue 20227)
+			if op == ODIV && n.Type.IsComplex() && constant.Sign(square(constant.Real(rval))) == 0 && constant.Sign(square(constant.Imag(rval))) == 0 {
+				yyerror("complex division by zero")
+				n.Type = nil
+				return n
+			}
+			if (op == ODIV || op == OMOD) && constant.Sign(rval) == 0 {
+				yyerror("division by zero")
+				n.Type = nil
+				return n
+			}
+
+			tok := tokenForOp[op]
+			if op == ODIV && n.Type.IsInteger() {
+				tok = token.QUO_ASSIGN // integer division
+			}
+			return origConst(n, constant.BinaryOp(nl.Val(), tok, rval))
 		}
 
 	case OEQ, ONE, OLT, OLE, OGT, OGE:
 		if nl.Op == OLITERAL && nr.Op == OLITERAL {
-			return origBoolConst(n, compareOp(nl.Val(), op, nr.Val()))
+			return origBoolConst(n, constant.Compare(nl.Val(), tokenForOp[op], nr.Val()))
 		}
 
 	case OLSH, ORSH:
 		if nl.Op == OLITERAL && nr.Op == OLITERAL {
-			return origConst(n, shiftOp(nl.Val(), op, nr.Val()))
+			// shiftBound from go/types; "so we can express smallestFloat64"
+			const shiftBound = 1023 - 1 + 52
+			s, ok := constant.Uint64Val(nr.Val())
+			if !ok || s > shiftBound {
+				yyerror("invalid shift count %v", nr)
+				n.Type = nil
+				break
+			}
+			return origConst(n, constant.Shift(toint(nl.Val()), tokenForOp[op], uint(s)))
 		}
 
 	case OCONV, ORUNESTR:
@@ -601,7 +633,7 @@ func evalConst(n *Node) *Node {
 			for _, c := range s {
 				strs = append(strs, c.StringVal())
 			}
-			return origConst(n, Val{U: strings.Join(strs, "")})
+			return origConst(n, constant.MakeString(strings.Join(strs, "")))
 		}
 		newList := make([]*Node, 0, need)
 		for i := 0; i < len(s); i++ {
@@ -614,7 +646,7 @@ func evalConst(n *Node) *Node {
 					i2++
 				}
 
-				nl := origConst(s[i], Val{U: strings.Join(strs, "")})
+				nl := origConst(s[i], constant.MakeString(strings.Join(strs, "")))
 				nl.Orig = nl // it's bigger than just s[i]
 				newList = append(newList, nl)
 				i = i2 - 1
@@ -642,319 +674,84 @@ func evalConst(n *Node) *Node {
 	case OALIGNOF, OOFFSETOF, OSIZEOF:
 		return origIntConst(n, evalunsafe(n))
 
-	case OREAL, OIMAG:
+	case OREAL:
 		if nl.Op == OLITERAL {
-			var re, im *Mpflt
-			switch u := nl.Val().U.(type) {
-			case *Mpint:
-				re = newMpflt()
-				re.SetInt(u)
-				// im = 0
-			case *Mpflt:
-				re = u
-				// im = 0
-			case *Mpcplx:
-				re = &u.Real
-				im = &u.Imag
-			default:
-				Fatalf("impossible")
-			}
-			if n.Op == OIMAG {
-				if im == nil {
-					im = newMpflt()
-				}
-				re = im
-			}
-			return origConst(n, Val{re})
+			return origConst(n, constant.Real(nl.Val()))
+		}
+
+	case OIMAG:
+		if nl.Op == OLITERAL {
+			return origConst(n, constant.Imag(nl.Val()))
 		}
 
 	case OCOMPLEX:
 		if nl.Op == OLITERAL && nr.Op == OLITERAL {
-			// make it a complex literal
-			c := newMpcmplx()
-			c.Real.Set(toflt(nl.Val()).U.(*Mpflt))
-			c.Imag.Set(toflt(nr.Val()).U.(*Mpflt))
-			return origConst(n, Val{c})
+			return origConst(n, makeComplex(nl.Val(), nr.Val()))
 		}
 	}
 
 	return n
 }
 
-func match(x, y Val) (Val, Val) {
-	switch {
-	case x.Kind() == constant.Complex || y.Kind() == constant.Complex:
-		return tocplx(x), tocplx(y)
-	case x.Kind() == constant.Float || y.Kind() == constant.Float:
-		return toflt(x), toflt(y)
+func makeInt(i *big.Int) constant.Value {
+	if i.IsInt64() {
+		return constant.Make(i.Int64()) // workaround #42640 (Int64Val(Make(big.NewInt(10))) returns (10, false), not (10, true))
 	}
-
-	// Mixed int/rune are fine.
-	return x, y
+	return constant.Make(i)
 }
 
-func compareOp(x Val, op Op, y Val) bool {
-	x, y = match(x, y)
-
-	switch x.Kind() {
-	case constant.Bool:
-		x, y := x.U.(bool), y.U.(bool)
-		switch op {
-		case OEQ:
-			return x == y
-		case ONE:
-			return x != y
-		}
-
-	case constant.Int:
-		x, y := x.U.(*Mpint), y.U.(*Mpint)
-		return cmpZero(x.Cmp(y), op)
-
-	case constant.Float:
-		x, y := x.U.(*Mpflt), y.U.(*Mpflt)
-		return cmpZero(x.Cmp(y), op)
-
-	case constant.Complex:
-		x, y := x.U.(*Mpcplx), y.U.(*Mpcplx)
-		eq := x.Real.Cmp(&y.Real) == 0 && x.Imag.Cmp(&y.Imag) == 0
-		switch op {
-		case OEQ:
-			return eq
-		case ONE:
-			return !eq
-		}
-
-	case constant.String:
-		x, y := x.U.(string), y.U.(string)
-		switch op {
-		case OEQ:
-			return x == y
-		case ONE:
-			return x != y
-		case OLT:
-			return x < y
-		case OLE:
-			return x <= y
-		case OGT:
-			return x > y
-		case OGE:
-			return x >= y
-		}
+func makeFloat64(f float64) constant.Value {
+	if math.IsInf(f, 0) {
+		Fatalf("infinity is not a valid constant")
 	}
-
-	Fatalf("compareOp: bad comparison: %v %v %v", x, op, y)
-	panic("unreachable")
+	v := constant.MakeFloat64(f)
+	v = constant.ToFloat(v) // workaround #42641 (MakeFloat64(0).Kind() returns Int, not Float)
+	return v
 }
 
-func cmpZero(x int, op Op) bool {
-	switch op {
-	case OEQ:
-		return x == 0
-	case ONE:
-		return x != 0
-	case OLT:
-		return x < 0
-	case OLE:
-		return x <= 0
-	case OGT:
-		return x > 0
-	case OGE:
-		return x >= 0
-	}
-
-	Fatalf("cmpZero: want comparison operator, got %v", op)
-	panic("unreachable")
+func makeComplex(real, imag constant.Value) constant.Value {
+	return constant.BinaryOp(constant.ToFloat(real), token.ADD, constant.MakeImag(constant.ToFloat(imag)))
 }
 
-func binaryOp(x Val, op Op, y Val) Val {
-	x, y = match(x, y)
-
-Outer:
-	switch x.Kind() {
-	case constant.Bool:
-		x, y := x.U.(bool), y.U.(bool)
-		switch op {
-		case OANDAND:
-			return Val{U: x && y}
-		case OOROR:
-			return Val{U: x || y}
-		}
-
-	case constant.Int:
-		x, y := x.U.(*Mpint), y.U.(*Mpint)
-
-		u := new(Mpint)
-		u.Set(x)
-		switch op {
-		case OADD:
-			u.Add(y)
-		case OSUB:
-			u.Sub(y)
-		case OMUL:
-			u.Mul(y)
-		case ODIV:
-			if y.CmpInt64(0) == 0 {
-				yyerror("division by zero")
-				return Val{}
-			}
-			u.Quo(y)
-		case OMOD:
-			if y.CmpInt64(0) == 0 {
-				yyerror("division by zero")
-				return Val{}
-			}
-			u.Rem(y)
-		case OOR:
-			u.Or(y)
-		case OAND:
-			u.And(y)
-		case OANDNOT:
-			u.AndNot(y)
-		case OXOR:
-			u.Xor(y)
-		default:
-			break Outer
-		}
-		return Val{U: u}
-
-	case constant.Float:
-		x, y := x.U.(*Mpflt), y.U.(*Mpflt)
-
-		u := newMpflt()
-		u.Set(x)
-		switch op {
-		case OADD:
-			u.Add(y)
-		case OSUB:
-			u.Sub(y)
-		case OMUL:
-			u.Mul(y)
-		case ODIV:
-			if y.CmpFloat64(0) == 0 {
-				yyerror("division by zero")
-				return Val{}
-			}
-			u.Quo(y)
-		default:
-			break Outer
-		}
-		return Val{U: u}
-
-	case constant.Complex:
-		x, y := x.U.(*Mpcplx), y.U.(*Mpcplx)
-
-		u := newMpcmplx()
-		u.Real.Set(&x.Real)
-		u.Imag.Set(&x.Imag)
-		switch op {
-		case OADD:
-			u.Real.Add(&y.Real)
-			u.Imag.Add(&y.Imag)
-		case OSUB:
-			u.Real.Sub(&y.Real)
-			u.Imag.Sub(&y.Imag)
-		case OMUL:
-			u.Mul(y)
-		case ODIV:
-			if !u.Div(y) {
-				yyerror("complex division by zero")
-				return Val{}
-			}
-		default:
-			break Outer
-		}
-		return Val{U: u}
-	}
+func square(x constant.Value) constant.Value {
+	return constant.BinaryOp(x, token.MUL, x)
+}
 
-	Fatalf("binaryOp: bad operation: %v %v %v", x, op, y)
-	panic("unreachable")
+// For matching historical "constant OP overflow" error messages.
+var overflowNames = [...]string{
+	OADD: "addition",
+	OSUB: "subtraction",
+	OMUL: "multiplication",
+	OLSH: "shift",
 }
 
-func unaryOp(op Op, x Val, t *types.Type) Val {
-	switch op {
-	case OPLUS:
-		switch x.Kind() {
-		case constant.Int, constant.Float, constant.Complex:
-			return x
-		}
+// origConst returns an OLITERAL with orig n and value v.
+func origConst(n *Node, v constant.Value) *Node {
+	lno := setlineno(n)
+	v = convertVal(v, n.Type, false)
+	lineno = lno
 
-	case ONEG:
-		switch x.Kind() {
-		case constant.Int:
-			x := x.U.(*Mpint)
-			u := new(Mpint)
-			u.Set(x)
-			u.Neg()
-			return Val{U: u}
-
-		case constant.Float:
-			x := x.U.(*Mpflt)
-			u := newMpflt()
-			u.Set(x)
-			u.Neg()
-			return Val{U: u}
-
-		case constant.Complex:
-			x := x.U.(*Mpcplx)
-			u := newMpcmplx()
-			u.Real.Set(&x.Real)
-			u.Imag.Set(&x.Imag)
-			u.Real.Neg()
-			u.Imag.Neg()
-			return Val{U: u}
+	switch v.Kind() {
+	case constant.Unknown:
+		// If constant folding was attempted (we were called)
+		// but it produced an invalid constant value,
+		// mark n as broken and give up.
+		if Errors() == 0 {
+			Fatalf("should have reported an error")
 		}
+		n.Type = nil
+		return n
 
-	case OBITNOT:
-		switch x.Kind() {
-		case constant.Int:
-			x := x.U.(*Mpint)
-
-			u := new(Mpint)
-			if t.IsSigned() || t.IsUntyped() {
-				// Signed values change sign.
-				u.SetInt64(-1)
-			} else {
-				// Unsigned values invert their bits.
-				u.Set(maxintval[t.Etype])
+	case constant.Int:
+		if constant.BitLen(v) > Mpprec {
+			what := overflowNames[n.Op]
+			if what == "" {
+				Fatalf("unexpected overflow: %v", n.Op)
 			}
-			u.Xor(x)
-			return Val{U: u}
+			yyerror("constant %v overflow", what)
+			n.Type = nil
+			return n
 		}
-
-	case ONOT:
-		return Val{U: !x.U.(bool)}
-	}
-
-	Fatalf("unaryOp: bad operation: %v %v", op, x)
-	panic("unreachable")
-}
-
-func shiftOp(x Val, op Op, y Val) Val {
-	x = toint(x)
-	y = toint(y)
-
-	u := new(Mpint)
-	u.Set(x.U.(*Mpint))
-	switch op {
-	case OLSH:
-		u.Lsh(y.U.(*Mpint))
-	case ORSH:
-		u.Rsh(y.U.(*Mpint))
-	default:
-		Fatalf("shiftOp: bad operator: %v", op)
-		panic("unreachable")
-	}
-	return Val{U: u}
-}
-
-// origConst returns an OLITERAL with orig n and value v.
-func origConst(n *Node, v Val) *Node {
-	// If constant folding was attempted (we were called)
-	// but it produced an invalid constant value,
-	// mark n as broken and give up.
-	if v.U == nil {
-		n.Type = nil
-		return n
 	}
 
 	orig := n
@@ -963,53 +760,45 @@ func origConst(n *Node, v Val) *Node {
 	n.Pos = orig.Pos
 	n.Type = orig.Type
 	n.SetVal(v)
-
-	// Check range.
-	lno := setlineno(n)
-	overflow(v, n.Type)
-	lineno = lno
-
-	if !n.Type.IsUntyped() {
-		switch v.Kind() {
-		// Truncate precision for non-ideal float.
-		case constant.Float:
-			n.SetVal(Val{truncfltlit(v.U.(*Mpflt), n.Type)})
-		// Truncate precision for non-ideal complex.
-		case constant.Complex:
-			n.SetVal(Val{trunccmplxlit(v.U.(*Mpcplx), n.Type)})
-		}
-	}
 	return n
 }
 
-func assertRepresents(t *types.Type, v Val) {
+func assertRepresents(t *types.Type, v constant.Value) {
 	if !represents(t, v) {
 		Fatalf("%v does not represent %v", t, v)
 	}
 }
 
-func represents(t *types.Type, v Val) bool {
-	if !t.IsUntyped() {
-		// TODO(mdempsky): Stricter handling of typed types.
-		return true
+func represents(t *types.Type, v constant.Value) bool {
+	switch v.Kind() {
+	case constant.Unknown:
+		return okforconst[t.Etype]
+	case constant.Bool:
+		return t.IsBoolean()
+	case constant.String:
+		return t.IsString()
+	case constant.Int:
+		return t.IsInteger()
+	case constant.Float:
+		return t.IsFloat()
+	case constant.Complex:
+		return t.IsComplex()
 	}
 
-	vt := idealType(v.Kind())
-	return t == vt || (t == types.UntypedRune && vt == types.UntypedInt)
+	Fatalf("unexpected constant kind: %v", v)
+	panic("unreachable")
 }
 
 func origBoolConst(n *Node, v bool) *Node {
-	return origConst(n, Val{U: v})
+	return origConst(n, constant.MakeBool(v))
 }
 
 func origIntConst(n *Node, v int64) *Node {
-	u := new(Mpint)
-	u.SetInt64(v)
-	return origConst(n, Val{u})
+	return origConst(n, constant.MakeInt64(v))
 }
 
 // nodlit returns a new untyped constant with value v.
-func nodlit(v Val) *Node {
+func nodlit(v constant.Value) *Node {
 	n := nod(OLITERAL, nil, nil)
 	n.Type = idealType(v.Kind())
 	n.SetVal(v)
@@ -1125,25 +914,10 @@ func defaultType(t *types.Type) *types.Type {
 }
 
 func smallintconst(n *Node) bool {
-	if n.Op == OLITERAL && Isconst(n, constant.Int) && n.Type != nil {
-		switch simtype[n.Type.Etype] {
-		case TINT8,
-			TUINT8,
-			TINT16,
-			TUINT16,
-			TINT32,
-			TUINT32,
-			TBOOL:
-			return true
-
-		case TIDEAL, TINT64, TUINT64, TPTR:
-			v, ok := n.Val().U.(*Mpint)
-			if ok && v.Cmp(minintval[TINT32]) >= 0 && v.Cmp(maxintval[TINT32]) <= 0 {
-				return true
-			}
-		}
+	if n.Op == OLITERAL {
+		v, ok := constant.Int64Val(n.Val())
+		return ok && int64(int32(v)) == v
 	}
-
 	return false
 }
 
@@ -1156,17 +930,18 @@ func indexconst(n *Node) int64 {
 	if n.Op != OLITERAL {
 		return -1
 	}
+	if !n.Type.IsInteger() && n.Type.Etype != TIDEAL {
+		return -1
+	}
 
-	v := toint(n.Val()) // toint returns argument unchanged if not representable as an *Mpint
-	vi, ok := v.U.(*Mpint)
-	if !ok || vi.CmpInt64(0) < 0 {
+	v := toint(n.Val())
+	if v.Kind() != constant.Int || constant.Sign(v) < 0 {
 		return -1
 	}
-	if vi.Cmp(maxintval[TINT]) > 0 {
+	if doesoverflow(v, types.Types[TINT]) {
 		return -2
 	}
-
-	return vi.Int64()
+	return int64Val(types.Types[TINT], v)
 }
 
 // isGoConst reports whether n is a Go language constant (as opposed to a
@@ -1276,7 +1051,7 @@ func (s *constSet) add(pos src.XPos, n *Node, what, where string) {
 	case types.Runetype:
 		typ = types.Types[TINT32]
 	}
-	k := constSetKey{typ, n.Val().Interface()}
+	k := constSetKey{typ, n.ValueInterface()}
 
 	if hasUniquePos(n) {
 		pos = n.Pos
@@ -1301,7 +1076,7 @@ func (s *constSet) add(pos src.XPos, n *Node, what, where string) {
 // TODO(mdempsky): This could probably be a fmt.go flag.
 func nodeAndVal(n *Node) string {
 	show := n.String()
-	val := n.Val().Interface()
+	val := n.ValueInterface()
 	if s := fmt.Sprintf("%#v", val); show != s {
 		show += " (value " + s + ")"
 	}
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 59888cce7e..4311421174 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -553,7 +553,7 @@ func structfield(n *Node) *types.Field {
 		f.Embedded = 1
 	}
 	if n.HasVal() {
-		f.Note = n.Val().U.(string)
+		f.Note = constant.StringVal(n.Val())
 	}
 
 	lineno = lno
@@ -638,7 +638,7 @@ func interfacefield(n *Node) *types.Field {
 		Fatalf("interfacefield: oops %v\n", n)
 	}
 
-	if n.Val().Kind() != constant.Unknown {
+	if n.HasVal() {
 		yyerror("interface method cannot have annotation")
 	}
 
diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index 15251062b4..9ee3b080b8 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -143,7 +143,7 @@ func importobj(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op Op, ctxt Class, t
 
 // importconst declares symbol s as an imported constant with type t and value val.
 // ipkg is the package being imported
-func importconst(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type, val Val) {
+func importconst(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type, val constant.Value) {
 	n := importobj(ipkg, pos, s, OLITERAL, PEXTERN, t)
 	if n == nil { // TODO: Check that value matches.
 		return
diff --git a/src/cmd/compile/internal/gc/fmt.go b/src/cmd/compile/internal/gc/fmt.go
index addb010e5c..f9888aec41 100644
--- a/src/cmd/compile/internal/gc/fmt.go
+++ b/src/cmd/compile/internal/gc/fmt.go
@@ -9,6 +9,7 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"fmt"
+	"go/constant"
 	"io"
 	"strconv"
 	"strings"
@@ -334,7 +335,7 @@ func (m fmtMode) prepareArgs(args []interface{}) {
 				args[i] = (*fmtSymErr)(arg)
 			case Nodes:
 				args[i] = fmtNodesErr(arg)
-			case Val, int32, int64, string, types.EType:
+			case int32, int64, string, types.EType, constant.Value:
 				// OK: printing these types doesn't depend on mode
 			default:
 				Fatalf("mode.prepareArgs type %T", arg)
@@ -353,7 +354,7 @@ func (m fmtMode) prepareArgs(args []interface{}) {
 				args[i] = (*fmtSymDbg)(arg)
 			case Nodes:
 				args[i] = fmtNodesDbg(arg)
-			case Val, int32, int64, string, types.EType:
+			case int32, int64, string, types.EType, constant.Value:
 				// OK: printing these types doesn't depend on mode
 			default:
 				Fatalf("mode.prepareArgs type %T", arg)
@@ -372,7 +373,7 @@ func (m fmtMode) prepareArgs(args []interface{}) {
 				args[i] = (*fmtSymTypeId)(arg)
 			case Nodes:
 				args[i] = fmtNodesTypeId(arg)
-			case Val, int32, int64, string, types.EType:
+			case int32, int64, string, types.EType, constant.Value:
 				// OK: printing these types doesn't depend on mode
 			default:
 				Fatalf("mode.prepareArgs type %T", arg)
@@ -391,7 +392,7 @@ func (m fmtMode) prepareArgs(args []interface{}) {
 				args[i] = (*fmtSymTypeIdName)(arg)
 			case Nodes:
 				args[i] = fmtNodesTypeIdName(arg)
-			case Val, int32, int64, string, types.EType:
+			case int32, int64, string, types.EType, constant.Value:
 				// OK: printing these types doesn't depend on mode
 			default:
 				Fatalf("mode.prepareArgs type %T", arg)
@@ -513,51 +514,37 @@ func (n *Node) jconv(s fmt.State, flag FmtFlag) {
 	}
 }
 
-func (v Val) Format(s fmt.State, verb rune) {
-	switch verb {
-	case 'v':
-		v.vconv(s, fmtFlag(s, verb))
-
-	default:
-		fmt.Fprintf(s, "%%!%c(Val=%T)", verb, v)
-	}
-}
+func vconv(v constant.Value, flag FmtFlag) string {
+	if flag&FmtSharp == 0 && v.Kind() == constant.Complex {
+		real, imag := constant.Real(v), constant.Imag(v)
 
-func (v Val) vconv(s fmt.State, flag FmtFlag) {
-	switch u := v.U.(type) {
-	case *Mpint:
-		if flag&FmtSharp != 0 {
-			fmt.Fprint(s, u.String())
-			return
+		var re string
+		sre := constant.Sign(real)
+		if sre != 0 {
+			re = real.String()
 		}
-		fmt.Fprint(s, u.GoString())
-		return
 
-	case *Mpflt:
-		if flag&FmtSharp != 0 {
-			fmt.Fprint(s, u.String())
-			return
+		var im string
+		sim := constant.Sign(imag)
+		if sim != 0 {
+			im = imag.String()
 		}
-		fmt.Fprint(s, u.GoString())
-		return
 
-	case *Mpcplx:
-		if flag&FmtSharp != 0 {
-			fmt.Fprint(s, u.String())
-			return
+		switch {
+		case sre == 0 && sim == 0:
+			return "0"
+		case sre == 0:
+			return im + "i"
+		case sim == 0:
+			return re
+		case sim < 0:
+			return fmt.Sprintf("(%s%si)", re, im)
+		default:
+			return fmt.Sprintf("(%s+%si)", re, im)
 		}
-		fmt.Fprint(s, u.GoString())
-		return
-
-	case string:
-		fmt.Fprint(s, strconv.Quote(u))
-
-	case bool:
-		fmt.Fprint(s, u)
-
-	default:
-		fmt.Fprintf(s, "<ctype=%d>", v.Kind())
 	}
+
+	return v.String()
 }
 
 /*
@@ -1333,8 +1320,12 @@ func (n *Node) exprfmt(s fmt.State, prec int, mode fmtMode) {
 		}
 
 		if n.Type == types.UntypedRune {
-			u := n.Val().U.(*Mpint)
-			switch x := u.Int64(); {
+			switch x, ok := constant.Int64Val(n.Val()); {
+			case !ok:
+				fallthrough
+			default:
+				fmt.Fprintf(s, "('\\x00' + %v)", n.Val())
+
 			case ' ' <= x && x < utf8.RuneSelf && x != '\\' && x != '\'':
 				fmt.Fprintf(s, "'%c'", int(x))
 
@@ -1343,12 +1334,9 @@ func (n *Node) exprfmt(s fmt.State, prec int, mode fmtMode) {
 
 			case 0 <= x && x <= utf8.MaxRune:
 				fmt.Fprintf(s, "'\\U%08x'", uint64(x))
-
-			default:
-				fmt.Fprintf(s, "('\\x00' + %v)", u)
 			}
 		} else {
-			mode.Fprintf(s, "%v", n.Val())
+			fmt.Fprint(s, vconv(n.Val(), fmtFlag(s, 'v')))
 		}
 
 		if needUnparen {
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index c53fde7e24..1242fc06cb 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -178,14 +178,6 @@ var (
 	iscmp [OEND]bool
 )
 
-var minintval [NTYPE]*Mpint
-
-var maxintval [NTYPE]*Mpint
-
-var minfltval [NTYPE]*Mpflt
-
-var maxfltval [NTYPE]*Mpflt
-
 var xtop []*Node
 
 var exportlist []*Node
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index 842025705b..447f938a0a 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -777,7 +777,7 @@ func constTypeOf(typ *types.Type) constant.Kind {
 	return 0
 }
 
-func (w *exportWriter) value(typ *types.Type, v Val) {
+func (w *exportWriter) value(typ *types.Type, v constant.Value) {
 	assertRepresents(typ, v)
 	w.typ(typ)
 
@@ -788,17 +788,16 @@ func (w *exportWriter) value(typ *types.Type, v Val) {
 
 	switch constTypeOf(typ) {
 	case constant.Bool:
-		w.bool(v.U.(bool))
+		w.bool(constant.BoolVal(v))
 	case constant.String:
-		w.string(v.U.(string))
+		w.string(constant.StringVal(v))
 	case constant.Int:
-		w.mpint(&v.U.(*Mpint).Val, typ)
+		w.mpint(v, typ)
 	case constant.Float:
-		w.mpfloat(&v.U.(*Mpflt).Val, typ)
+		w.mpfloat(v, typ)
 	case constant.Complex:
-		x := v.U.(*Mpcplx)
-		w.mpfloat(&x.Real.Val, typ)
-		w.mpfloat(&x.Imag.Val, typ)
+		w.mpfloat(constant.Real(v), typ)
+		w.mpfloat(constant.Imag(v), typ)
 	}
 }
 
@@ -847,15 +846,19 @@ func intSize(typ *types.Type) (signed bool, maxBytes uint) {
 // single byte.
 //
 // TODO(mdempsky): Is this level of complexity really worthwhile?
-func (w *exportWriter) mpint(x *big.Int, typ *types.Type) {
+func (w *exportWriter) mpint(x constant.Value, typ *types.Type) {
 	signed, maxBytes := intSize(typ)
 
-	negative := x.Sign() < 0
+	negative := constant.Sign(x) < 0
 	if !signed && negative {
 		Fatalf("negative unsigned integer; type %v, value %v", typ, x)
 	}
 
-	b := x.Bytes()
+	b := constant.Bytes(x) // little endian
+	for i, j := 0, len(b)-1; i < j; i, j = i+1, j-1 {
+		b[i], b[j] = b[j], b[i]
+	}
+
 	if len(b) > 0 && b[0] == 0 {
 		Fatalf("leading zeros")
 	}
@@ -910,7 +913,8 @@ func (w *exportWriter) mpint(x *big.Int, typ *types.Type) {
 // mantissa is an integer. The value is written out as mantissa (as a
 // multi-precision integer) and then the exponent, except exponent is
 // omitted if mantissa is zero.
-func (w *exportWriter) mpfloat(f *big.Float, typ *types.Type) {
+func (w *exportWriter) mpfloat(v constant.Value, typ *types.Type) {
+	f := bigFloatVal(v)
 	if f.IsInf() {
 		Fatalf("infinite constant")
 	}
@@ -928,7 +932,7 @@ func (w *exportWriter) mpfloat(f *big.Float, typ *types.Type) {
 	if acc != big.Exact {
 		Fatalf("mantissa scaling failed for %f (%s)", f, acc)
 	}
-	w.mpint(manti, typ)
+	w.mpint(makeInt(manti), typ)
 	if manti.Sign() != 0 {
 		w.int64(exp)
 	}
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index a3a01e59cd..3f50a94061 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -356,27 +356,24 @@ func (r *importReader) doDecl(n *Node) {
 	}
 }
 
-func (p *importReader) value(typ *types.Type) (v Val) {
+func (p *importReader) value(typ *types.Type) constant.Value {
 	switch constTypeOf(typ) {
 	case constant.Bool:
-		v.U = p.bool()
+		return constant.MakeBool(p.bool())
 	case constant.String:
-		v.U = p.string()
+		return constant.MakeString(p.string())
 	case constant.Int:
-		x := new(Mpint)
-		p.mpint(&x.Val, typ)
-		v.U = x
+		var i big.Int
+		p.mpint(&i, typ)
+		return makeInt(&i)
 	case constant.Float:
-		x := newMpflt()
-		p.float(x, typ)
-		v.U = x
+		return p.float(typ)
 	case constant.Complex:
-		x := newMpcmplx()
-		p.float(&x.Real, typ)
-		p.float(&x.Imag, typ)
-		v.U = x
+		return makeComplex(p.float(typ), p.float(typ))
 	}
-	return
+
+	Fatalf("unexpected value type: %v", typ)
+	panic("unreachable")
 }
 
 func (p *importReader) mpint(x *big.Int, typ *types.Type) {
@@ -418,14 +415,15 @@ func (p *importReader) mpint(x *big.Int, typ *types.Type) {
 	}
 }
 
-func (p *importReader) float(x *Mpflt, typ *types.Type) {
+func (p *importReader) float(typ *types.Type) constant.Value {
 	var mant big.Int
 	p.mpint(&mant, typ)
-	m := x.Val.SetInt(&mant)
-	if m.Sign() == 0 {
-		return
+	var f big.Float
+	f.SetInt(&mant)
+	if f.Sign() != 0 {
+		f.SetMantExp(&f, int(p.int64()))
 	}
-	m.SetMantExp(m, int(p.int64()))
+	return constant.Make(&f)
 }
 
 func (r *importReader) ident() *types.Sym {
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index cf4ec039f1..fca1334a19 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -21,6 +21,7 @@ import (
 	"cmd/internal/sys"
 	"flag"
 	"fmt"
+	"go/constant"
 	"internal/goversion"
 	"io"
 	"io/ioutil"
@@ -1135,13 +1136,13 @@ func loadsys() {
 // imported so far.
 var myheight int
 
-func importfile(f *Val) *types.Pkg {
-	path_, ok := f.U.(string)
-	if !ok {
+func importfile(f constant.Value) *types.Pkg {
+	if f.Kind() != constant.String {
 		yyerror("import path must be a string")
 		return nil
 	}
 
+	path_ := constant.StringVal(f)
 	if len(path_) == 0 {
 		yyerror("import path is empty")
 		return nil
diff --git a/src/cmd/compile/internal/gc/mpfloat.go b/src/cmd/compile/internal/gc/mpfloat.go
deleted file mode 100644
index 9962f4b413..0000000000
--- a/src/cmd/compile/internal/gc/mpfloat.go
+++ /dev/null
@@ -1,357 +0,0 @@
-// Copyright 2009 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 gc
-
-import (
-	"fmt"
-	"math"
-	"math/big"
-)
-
-// implements float arithmetic
-
-const (
-	// Maximum size in bits for Mpints before signalling
-	// overflow and also mantissa precision for Mpflts.
-	Mpprec = 512
-	// Turn on for constant arithmetic debugging output.
-	Mpdebug = false
-)
-
-// Mpflt represents a floating-point constant.
-type Mpflt struct {
-	Val big.Float
-}
-
-// Mpcplx represents a complex constant.
-type Mpcplx struct {
-	Real Mpflt
-	Imag Mpflt
-}
-
-// Use newMpflt (not new(Mpflt)!) to get the correct default precision.
-func newMpflt() *Mpflt {
-	var a Mpflt
-	a.Val.SetPrec(Mpprec)
-	return &a
-}
-
-// Use newMpcmplx (not new(Mpcplx)!) to get the correct default precision.
-func newMpcmplx() *Mpcplx {
-	var a Mpcplx
-	a.Real = *newMpflt()
-	a.Imag = *newMpflt()
-	return &a
-}
-
-func (a *Mpflt) SetInt(b *Mpint) {
-	if b.checkOverflow(0) {
-		// sign doesn't really matter but copy anyway
-		a.Val.SetInf(b.Val.Sign() < 0)
-		return
-	}
-	a.Val.SetInt(&b.Val)
-}
-
-func (a *Mpflt) Set(b *Mpflt) {
-	a.Val.Set(&b.Val)
-}
-
-func (a *Mpflt) Add(b *Mpflt) {
-	if Mpdebug {
-		fmt.Printf("\n%v + %v", a, b)
-	}
-
-	a.Val.Add(&a.Val, &b.Val)
-
-	if Mpdebug {
-		fmt.Printf(" = %v\n\n", a)
-	}
-}
-
-func (a *Mpflt) AddFloat64(c float64) {
-	var b Mpflt
-
-	b.SetFloat64(c)
-	a.Add(&b)
-}
-
-func (a *Mpflt) Sub(b *Mpflt) {
-	if Mpdebug {
-		fmt.Printf("\n%v - %v", a, b)
-	}
-
-	a.Val.Sub(&a.Val, &b.Val)
-
-	if Mpdebug {
-		fmt.Printf(" = %v\n\n", a)
-	}
-}
-
-func (a *Mpflt) Mul(b *Mpflt) {
-	if Mpdebug {
-		fmt.Printf("%v\n * %v\n", a, b)
-	}
-
-	a.Val.Mul(&a.Val, &b.Val)
-
-	if Mpdebug {
-		fmt.Printf(" = %v\n\n", a)
-	}
-}
-
-func (a *Mpflt) MulFloat64(c float64) {
-	var b Mpflt
-
-	b.SetFloat64(c)
-	a.Mul(&b)
-}
-
-func (a *Mpflt) Quo(b *Mpflt) {
-	if Mpdebug {
-		fmt.Printf("%v\n / %v\n", a, b)
-	}
-
-	a.Val.Quo(&a.Val, &b.Val)
-
-	if Mpdebug {
-		fmt.Printf(" = %v\n\n", a)
-	}
-}
-
-func (a *Mpflt) Cmp(b *Mpflt) int {
-	return a.Val.Cmp(&b.Val)
-}
-
-func (a *Mpflt) CmpFloat64(c float64) int {
-	if c == 0 {
-		return a.Val.Sign() // common case shortcut
-	}
-	return a.Val.Cmp(big.NewFloat(c))
-}
-
-func (a *Mpflt) Float64() float64 {
-	x, _ := a.Val.Float64()
-
-	// check for overflow
-	if math.IsInf(x, 0) && Errors() == 0 {
-		Fatalf("ovf in Mpflt Float64")
-	}
-
-	return x + 0 // avoid -0 (should not be needed, but be conservative)
-}
-
-func (a *Mpflt) Float32() float64 {
-	x32, _ := a.Val.Float32()
-	x := float64(x32)
-
-	// check for overflow
-	if math.IsInf(x, 0) && Errors() == 0 {
-		Fatalf("ovf in Mpflt Float32")
-	}
-
-	return x + 0 // avoid -0 (should not be needed, but be conservative)
-}
-
-func (a *Mpflt) SetFloat64(c float64) {
-	if Mpdebug {
-		fmt.Printf("\nconst %g", c)
-	}
-
-	// convert -0 to 0
-	if c == 0 {
-		c = 0
-	}
-	a.Val.SetFloat64(c)
-
-	if Mpdebug {
-		fmt.Printf(" = %v\n", a)
-	}
-}
-
-func (a *Mpflt) Neg() {
-	// avoid -0
-	if a.Val.Sign() != 0 {
-		a.Val.Neg(&a.Val)
-	}
-}
-
-func (a *Mpflt) SetString(as string) {
-	f, _, err := a.Val.Parse(as, 0)
-	if err != nil {
-		yyerror("malformed constant: %s (%v)", as, err)
-		a.Val.SetFloat64(0)
-		return
-	}
-
-	if f.IsInf() {
-		yyerror("constant too large: %s", as)
-		a.Val.SetFloat64(0)
-		return
-	}
-
-	// -0 becomes 0
-	if f.Sign() == 0 && f.Signbit() {
-		a.Val.SetFloat64(0)
-	}
-}
-
-func (f *Mpflt) String() string {
-	return f.Val.Text('b', 0)
-}
-
-func (fvp *Mpflt) GoString() string {
-	// determine sign
-	sign := ""
-	f := &fvp.Val
-	if f.Sign() < 0 {
-		sign = "-"
-		f = new(big.Float).Abs(f)
-	}
-
-	// Don't try to convert infinities (will not terminate).
-	if f.IsInf() {
-		return sign + "Inf"
-	}
-
-	// Use exact fmt formatting if in float64 range (common case):
-	// proceed if f doesn't underflow to 0 or overflow to inf.
-	if x, _ := f.Float64(); f.Sign() == 0 == (x == 0) && !math.IsInf(x, 0) {
-		return fmt.Sprintf("%s%.6g", sign, x)
-	}
-
-	// Out of float64 range. Do approximate manual to decimal
-	// conversion to avoid precise but possibly slow Float
-	// formatting.
-	// f = mant * 2**exp
-	var mant big.Float
-	exp := f.MantExp(&mant) // 0.5 <= mant < 1.0
-
-	// approximate float64 mantissa m and decimal exponent d
-	// f ~ m * 10**d
-	m, _ := mant.Float64()                     // 0.5 <= m < 1.0
-	d := float64(exp) * (math.Ln2 / math.Ln10) // log_10(2)
-
-	// adjust m for truncated (integer) decimal exponent e
-	e := int64(d)
-	m *= math.Pow(10, d-float64(e))
-
-	// ensure 1 <= m < 10
-	switch {
-	case m < 1-0.5e-6:
-		// The %.6g format below rounds m to 5 digits after the
-		// decimal point. Make sure that m*10 < 10 even after
-		// rounding up: m*10 + 0.5e-5 < 10 => m < 1 - 0.5e6.
-		m *= 10
-		e--
-	case m >= 10:
-		m /= 10
-		e++
-	}
-
-	return fmt.Sprintf("%s%.6ge%+d", sign, m, e)
-}
-
-// complex multiply v *= rv
-//	(a, b) * (c, d) = (a*c - b*d, b*c + a*d)
-func (v *Mpcplx) Mul(rv *Mpcplx) {
-	var ac, ad, bc, bd Mpflt
-
-	ac.Set(&v.Real)
-	ac.Mul(&rv.Real) // ac
-
-	bd.Set(&v.Imag)
-	bd.Mul(&rv.Imag) // bd
-
-	bc.Set(&v.Imag)
-	bc.Mul(&rv.Real) // bc
-
-	ad.Set(&v.Real)
-	ad.Mul(&rv.Imag) // ad
-
-	v.Real.Set(&ac)
-	v.Real.Sub(&bd) // ac-bd
-
-	v.Imag.Set(&bc)
-	v.Imag.Add(&ad) // bc+ad
-}
-
-// complex divide v /= rv
-//	(a, b) / (c, d) = ((a*c + b*d), (b*c - a*d))/(c*c + d*d)
-func (v *Mpcplx) Div(rv *Mpcplx) bool {
-	if rv.Real.CmpFloat64(0) == 0 && rv.Imag.CmpFloat64(0) == 0 {
-		return false
-	}
-
-	var ac, ad, bc, bd, cc_plus_dd Mpflt
-
-	cc_plus_dd.Set(&rv.Real)
-	cc_plus_dd.Mul(&rv.Real) // cc
-
-	ac.Set(&rv.Imag)
-	ac.Mul(&rv.Imag)    // dd
-	cc_plus_dd.Add(&ac) // cc+dd
-
-	// We already checked that c and d are not both zero, but we can't
-	// assume that c²+d² != 0 follows, because for tiny values of c
-	// and/or d c²+d² can underflow to zero.  Check that c²+d² is
-	// nonzero, return if it's not.
-	if cc_plus_dd.CmpFloat64(0) == 0 {
-		return false
-	}
-
-	ac.Set(&v.Real)
-	ac.Mul(&rv.Real) // ac
-
-	bd.Set(&v.Imag)
-	bd.Mul(&rv.Imag) // bd
-
-	bc.Set(&v.Imag)
-	bc.Mul(&rv.Real) // bc
-
-	ad.Set(&v.Real)
-	ad.Mul(&rv.Imag) // ad
-
-	v.Real.Set(&ac)
-	v.Real.Add(&bd)         // ac+bd
-	v.Real.Quo(&cc_plus_dd) // (ac+bd)/(cc+dd)
-
-	v.Imag.Set(&bc)
-	v.Imag.Sub(&ad)         // bc-ad
-	v.Imag.Quo(&cc_plus_dd) // (bc+ad)/(cc+dd)
-
-	return true
-}
-
-func (v *Mpcplx) String() string {
-	return fmt.Sprintf("(%s+%si)", v.Real.String(), v.Imag.String())
-}
-
-func (v *Mpcplx) GoString() string {
-	var re string
-	sre := v.Real.CmpFloat64(0)
-	if sre != 0 {
-		re = v.Real.GoString()
-	}
-
-	var im string
-	sim := v.Imag.CmpFloat64(0)
-	if sim != 0 {
-		im = v.Imag.GoString()
-	}
-
-	switch {
-	case sre == 0 && sim == 0:
-		return "0"
-	case sre == 0:
-		return im + "i"
-	case sim == 0:
-		return re
-	case sim < 0:
-		return fmt.Sprintf("(%s%si)", re, im)
-	default:
-		return fmt.Sprintf("(%s+%si)", re, im)
-	}
-}
diff --git a/src/cmd/compile/internal/gc/mpint.go b/src/cmd/compile/internal/gc/mpint.go
deleted file mode 100644
index 199b2659d1..0000000000
--- a/src/cmd/compile/internal/gc/mpint.go
+++ /dev/null
@@ -1,303 +0,0 @@
-// Copyright 2009 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 gc
-
-import (
-	"fmt"
-	"math/big"
-)
-
-// implements integer arithmetic
-
-// Mpint represents an integer constant.
-type Mpint struct {
-	Val big.Int
-	Ovf bool // set if Val overflowed compiler limit (sticky)
-}
-
-func (a *Mpint) SetOverflow() {
-	a.Val.SetUint64(1) // avoid spurious div-zero errors
-	a.Ovf = true
-}
-
-func (a *Mpint) checkOverflow(extra int) bool {
-	// We don't need to be precise here, any reasonable upper limit would do.
-	// For now, use existing limit so we pass all the tests unchanged.
-	if a.Val.BitLen()+extra > Mpprec {
-		a.SetOverflow()
-	}
-	return a.Ovf
-}
-
-func (a *Mpint) Set(b *Mpint) {
-	a.Val.Set(&b.Val)
-}
-
-func (a *Mpint) SetFloat(b *Mpflt) bool {
-	// avoid converting huge floating-point numbers to integers
-	// (2*Mpprec is large enough to permit all tests to pass)
-	if b.Val.MantExp(nil) > 2*Mpprec {
-		a.SetOverflow()
-		return false
-	}
-
-	if _, acc := b.Val.Int(&a.Val); acc == big.Exact {
-		return true
-	}
-
-	const delta = 16 // a reasonably small number of bits > 0
-	var t big.Float
-	t.SetPrec(Mpprec - delta)
-
-	// try rounding down a little
-	t.SetMode(big.ToZero)
-	t.Set(&b.Val)
-	if _, acc := t.Int(&a.Val); acc == big.Exact {
-		return true
-	}
-
-	// try rounding up a little
-	t.SetMode(big.AwayFromZero)
-	t.Set(&b.Val)
-	if _, acc := t.Int(&a.Val); acc == big.Exact {
-		return true
-	}
-
-	a.Ovf = false
-	return false
-}
-
-func (a *Mpint) Add(b *Mpint) {
-	if a.Ovf || b.Ovf {
-		if Errors() == 0 {
-			Fatalf("ovf in Mpint Add")
-		}
-		a.SetOverflow()
-		return
-	}
-
-	a.Val.Add(&a.Val, &b.Val)
-
-	if a.checkOverflow(0) {
-		yyerror("constant addition overflow")
-	}
-}
-
-func (a *Mpint) Sub(b *Mpint) {
-	if a.Ovf || b.Ovf {
-		if Errors() == 0 {
-			Fatalf("ovf in Mpint Sub")
-		}
-		a.SetOverflow()
-		return
-	}
-
-	a.Val.Sub(&a.Val, &b.Val)
-
-	if a.checkOverflow(0) {
-		yyerror("constant subtraction overflow")
-	}
-}
-
-func (a *Mpint) Mul(b *Mpint) {
-	if a.Ovf || b.Ovf {
-		if Errors() == 0 {
-			Fatalf("ovf in Mpint Mul")
-		}
-		a.SetOverflow()
-		return
-	}
-
-	a.Val.Mul(&a.Val, &b.Val)
-
-	if a.checkOverflow(0) {
-		yyerror("constant multiplication overflow")
-	}
-}
-
-func (a *Mpint) Quo(b *Mpint) {
-	if a.Ovf || b.Ovf {
-		if Errors() == 0 {
-			Fatalf("ovf in Mpint Quo")
-		}
-		a.SetOverflow()
-		return
-	}
-
-	a.Val.Quo(&a.Val, &b.Val)
-
-	if a.checkOverflow(0) {
-		// can only happen for div-0 which should be checked elsewhere
-		yyerror("constant division overflow")
-	}
-}
-
-func (a *Mpint) Rem(b *Mpint) {
-	if a.Ovf || b.Ovf {
-		if Errors() == 0 {
-			Fatalf("ovf in Mpint Rem")
-		}
-		a.SetOverflow()
-		return
-	}
-
-	a.Val.Rem(&a.Val, &b.Val)
-
-	if a.checkOverflow(0) {
-		// should never happen
-		yyerror("constant modulo overflow")
-	}
-}
-
-func (a *Mpint) Or(b *Mpint) {
-	if a.Ovf || b.Ovf {
-		if Errors() == 0 {
-			Fatalf("ovf in Mpint Or")
-		}
-		a.SetOverflow()
-		return
-	}
-
-	a.Val.Or(&a.Val, &b.Val)
-}
-
-func (a *Mpint) And(b *Mpint) {
-	if a.Ovf || b.Ovf {
-		if Errors() == 0 {
-			Fatalf("ovf in Mpint And")
-		}
-		a.SetOverflow()
-		return
-	}
-
-	a.Val.And(&a.Val, &b.Val)
-}
-
-func (a *Mpint) AndNot(b *Mpint) {
-	if a.Ovf || b.Ovf {
-		if Errors() == 0 {
-			Fatalf("ovf in Mpint AndNot")
-		}
-		a.SetOverflow()
-		return
-	}
-
-	a.Val.AndNot(&a.Val, &b.Val)
-}
-
-func (a *Mpint) Xor(b *Mpint) {
-	if a.Ovf || b.Ovf {
-		if Errors() == 0 {
-			Fatalf("ovf in Mpint Xor")
-		}
-		a.SetOverflow()
-		return
-	}
-
-	a.Val.Xor(&a.Val, &b.Val)
-}
-
-func (a *Mpint) Lsh(b *Mpint) {
-	if a.Ovf || b.Ovf {
-		if Errors() == 0 {
-			Fatalf("ovf in Mpint Lsh")
-		}
-		a.SetOverflow()
-		return
-	}
-
-	s := b.Int64()
-	if s < 0 || s >= Mpprec {
-		msg := "shift count too large"
-		if s < 0 {
-			msg = "invalid negative shift count"
-		}
-		yyerror("%s: %d", msg, s)
-		a.SetInt64(0)
-		return
-	}
-
-	if a.checkOverflow(int(s)) {
-		yyerror("constant shift overflow")
-		return
-	}
-	a.Val.Lsh(&a.Val, uint(s))
-}
-
-func (a *Mpint) Rsh(b *Mpint) {
-	if a.Ovf || b.Ovf {
-		if Errors() == 0 {
-			Fatalf("ovf in Mpint Rsh")
-		}
-		a.SetOverflow()
-		return
-	}
-
-	s := b.Int64()
-	if s < 0 {
-		yyerror("invalid negative shift count: %d", s)
-		if a.Val.Sign() < 0 {
-			a.SetInt64(-1)
-		} else {
-			a.SetInt64(0)
-		}
-		return
-	}
-
-	a.Val.Rsh(&a.Val, uint(s))
-}
-
-func (a *Mpint) Cmp(b *Mpint) int {
-	return a.Val.Cmp(&b.Val)
-}
-
-func (a *Mpint) CmpInt64(c int64) int {
-	if c == 0 {
-		return a.Val.Sign() // common case shortcut
-	}
-	return a.Val.Cmp(big.NewInt(c))
-}
-
-func (a *Mpint) Neg() {
-	a.Val.Neg(&a.Val)
-}
-
-func (a *Mpint) Int64() int64 {
-	if a.Ovf {
-		if Errors() == 0 {
-			Fatalf("constant overflow")
-		}
-		return 0
-	}
-
-	return a.Val.Int64()
-}
-
-func (a *Mpint) SetInt64(c int64) {
-	a.Val.SetInt64(c)
-}
-
-func (a *Mpint) SetString(as string) {
-	_, ok := a.Val.SetString(as, 0)
-	if !ok {
-		// The lexer checks for correct syntax of the literal
-		// and reports detailed errors. Thus SetString should
-		// never fail (in theory it might run out of memory,
-		// but that wouldn't be reported as an error here).
-		Fatalf("malformed integer constant: %s", as)
-		return
-	}
-	if a.checkOverflow(0) {
-		yyerror("constant too large: %s", as)
-	}
-}
-
-func (a *Mpint) GoString() string {
-	return a.Val.String()
-}
-
-func (a *Mpint) String() string {
-	return fmt.Sprintf("%#x", &a.Val)
-}
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index f8c84a75bf..47b1958f18 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"fmt"
 	"go/constant"
+	"go/token"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -331,8 +332,7 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
 		p.checkUnused(pragma)
 	}
 
-	val := p.basicLit(imp.Path)
-	ipkg := importfile(&val)
+	ipkg := importfile(p.basicLit(imp.Path))
 	if ipkg == nil {
 		if Errors() == 0 {
 			Fatalf("phase error in import")
@@ -824,7 +824,7 @@ func (p *noder) sum(x syntax.Expr) *Node {
 			chunks = append(chunks, nstr.StringVal())
 		} else {
 			if len(chunks) > 1 {
-				nstr.SetVal(Val{U: strings.Join(chunks, "")})
+				nstr.SetVal(constant.MakeString(strings.Join(chunks, "")))
 			}
 			nstr = nil
 			chunks = chunks[:0]
@@ -832,7 +832,7 @@ func (p *noder) sum(x syntax.Expr) *Node {
 		n = p.nod(add, OADD, n, r)
 	}
 	if len(chunks) > 1 {
-		nstr.SetVal(Val{U: strings.Join(chunks, "")})
+		nstr.SetVal(constant.MakeString(strings.Join(chunks, "")))
 	}
 
 	return n
@@ -1400,64 +1400,43 @@ func checkLangCompat(lit *syntax.BasicLit) {
 	}
 }
 
-func (p *noder) basicLit(lit *syntax.BasicLit) Val {
+func (p *noder) basicLit(lit *syntax.BasicLit) constant.Value {
 	// We don't use the errors of the conversion routines to determine
 	// if a literal string is valid because the conversion routines may
 	// accept a wider syntax than the language permits. Rely on lit.Bad
 	// instead.
-	switch s := lit.Value; lit.Kind {
-	case syntax.IntLit:
-		checkLangCompat(lit)
-		x := new(Mpint)
-		if !lit.Bad {
-			x.SetString(s)
-		}
-		return Val{U: x}
-
-	case syntax.FloatLit:
-		checkLangCompat(lit)
-		x := newMpflt()
-		if !lit.Bad {
-			x.SetString(s)
-		}
-		return Val{U: x}
+	if lit.Bad {
+		return constant.MakeUnknown()
+	}
 
-	case syntax.ImagLit:
+	switch lit.Kind {
+	case syntax.IntLit, syntax.FloatLit, syntax.ImagLit:
 		checkLangCompat(lit)
-		x := newMpcmplx()
-		if !lit.Bad {
-			x.Imag.SetString(strings.TrimSuffix(s, "i"))
-		}
-		return Val{U: x}
-
-	case syntax.RuneLit:
-		x := new(Mpint)
-		if !lit.Bad {
-			u, _ := strconv.Unquote(s)
-			var r rune
-			if len(u) == 1 {
-				r = rune(u[0])
-			} else {
-				r, _ = utf8.DecodeRuneInString(u)
-			}
-			x.SetInt64(int64(r))
-		}
-		return Val{U: x}
+	}
 
-	case syntax.StringLit:
-		var x string
-		if !lit.Bad {
-			if len(s) > 0 && s[0] == '`' {
-				// strip carriage returns from raw string
-				s = strings.Replace(s, "\r", "", -1)
-			}
-			x, _ = strconv.Unquote(s)
-		}
-		return Val{U: x}
+	v := constant.MakeFromLiteral(lit.Value, tokenForLitKind[lit.Kind], 0)
+	if v.Kind() == constant.Unknown {
+		// TODO(mdempsky): Better error message?
+		p.yyerrorpos(lit.Pos(), "malformed constant: %s", lit.Value)
+	}
 
-	default:
-		panic("unhandled BasicLit kind")
+	// go/constant uses big.Rat by default, which is more precise, but
+	// causes toolstash -cmp and some tests to fail. For now, convert
+	// to big.Float to match cmd/compile's historical precision.
+	// TODO(mdempsky): Remove.
+	if v.Kind() == constant.Float {
+		v = constant.Make(bigFloatVal(v))
 	}
+
+	return v
+}
+
+var tokenForLitKind = [...]token.Token{
+	syntax.IntLit:    token.INT,
+	syntax.RuneLit:   token.CHAR,
+	syntax.FloatLit:  token.FLOAT,
+	syntax.ImagLit:   token.IMAG,
+	syntax.StringLit: token.STRING,
 }
 
 func (p *noder) name(name *syntax.Name) *types.Sym {
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 499b8ef2e5..d51f50ccab 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -250,33 +250,18 @@ func dumpGlobalConst(n *Node) {
 		return
 	}
 	// only export integer constants for now
-	switch t.Etype {
-	case TINT8:
-	case TINT16:
-	case TINT32:
-	case TINT64:
-	case TINT:
-	case TUINT8:
-	case TUINT16:
-	case TUINT32:
-	case TUINT64:
-	case TUINT:
-	case TUINTPTR:
-		// ok
-	case TIDEAL:
-		if !Isconst(n, constant.Int) {
-			return
-		}
-		x := n.Val().U.(*Mpint)
-		if x.Cmp(minintval[TINT]) < 0 || x.Cmp(maxintval[TINT]) > 0 {
+	if !t.IsInteger() {
+		return
+	}
+	v := n.Val()
+	if t.IsUntyped() {
+		// Export untyped integers as int (if they fit).
+		t = types.Types[TINT]
+		if doesoverflow(v, t) {
 			return
 		}
-		// Ideal integers we export as int (if they fit).
-		t = types.Types[TINT]
-	default:
-		return
 	}
-	Ctxt.DwarfIntConst(myimportpath, n.Sym.Name, typesymname(t), n.Int64Val())
+	Ctxt.DwarfIntConst(myimportpath, n.Sym.Name, typesymname(t), int64Val(t, v))
 }
 
 func dumpglobls() {
@@ -595,6 +580,9 @@ func litsym(n, c *Node, wid int) {
 	if n.Sym == nil {
 		Fatalf("litsym nil n sym")
 	}
+	if !types.Identical(n.Type, c.Type) {
+		Fatalf("litsym: type mismatch: %v has type %v, but %v has type %v", n, n.Type, c, c.Type)
+	}
 	if c.Op == ONIL {
 		return
 	}
@@ -602,16 +590,16 @@ func litsym(n, c *Node, wid int) {
 		Fatalf("litsym c op %v", c.Op)
 	}
 	s := n.Sym.Linksym()
-	switch u := c.Val().U.(type) {
-	case bool:
-		i := int64(obj.Bool2int(u))
+	switch u := c.Val(); u.Kind() {
+	case constant.Bool:
+		i := int64(obj.Bool2int(constant.BoolVal(u)))
 		s.WriteInt(Ctxt, n.Xoffset, wid, i)
 
-	case *Mpint:
-		s.WriteInt(Ctxt, n.Xoffset, wid, u.Int64())
+	case constant.Int:
+		s.WriteInt(Ctxt, n.Xoffset, wid, int64Val(n.Type, u))
 
-	case *Mpflt:
-		f := u.Float64()
+	case constant.Float:
+		f, _ := constant.Float64Val(u)
 		switch n.Type.Etype {
 		case TFLOAT32:
 			s.WriteFloat32(Ctxt, n.Xoffset, float32(f))
@@ -619,22 +607,23 @@ func litsym(n, c *Node, wid int) {
 			s.WriteFloat64(Ctxt, n.Xoffset, f)
 		}
 
-	case *Mpcplx:
-		r := u.Real.Float64()
-		i := u.Imag.Float64()
+	case constant.Complex:
+		re, _ := constant.Float64Val(constant.Real(u))
+		im, _ := constant.Float64Val(constant.Imag(u))
 		switch n.Type.Etype {
 		case TCOMPLEX64:
-			s.WriteFloat32(Ctxt, n.Xoffset, float32(r))
-			s.WriteFloat32(Ctxt, n.Xoffset+4, float32(i))
+			s.WriteFloat32(Ctxt, n.Xoffset, float32(re))
+			s.WriteFloat32(Ctxt, n.Xoffset+4, float32(im))
 		case TCOMPLEX128:
-			s.WriteFloat64(Ctxt, n.Xoffset, r)
-			s.WriteFloat64(Ctxt, n.Xoffset+8, i)
+			s.WriteFloat64(Ctxt, n.Xoffset, re)
+			s.WriteFloat64(Ctxt, n.Xoffset+8, im)
 		}
 
-	case string:
-		symdata := stringsym(n.Pos, u)
+	case constant.String:
+		i := constant.StringVal(u)
+		symdata := stringsym(n.Pos, i)
 		s.WriteAddr(Ctxt, n.Xoffset, Widthptr, symdata, 0)
-		s.WriteInt(Ctxt, n.Xoffset+int64(Widthptr), Widthptr, int64(len(u)))
+		s.WriteInt(Ctxt, n.Xoffset+int64(Widthptr), Widthptr, int64(len(i)))
 
 	default:
 		Fatalf("litsym unhandled OLITERAL %v", c)
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 3b4056cf7d..6da3c5e10b 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -8,6 +8,7 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"fmt"
+	"go/constant"
 )
 
 type InitEntry struct {
@@ -1116,20 +1117,13 @@ func isZero(n *Node) bool {
 		return true
 
 	case OLITERAL:
-		switch u := n.Val().U.(type) {
+		switch u := n.Val(); u.Kind() {
+		case constant.String:
+			return constant.StringVal(u) == ""
+		case constant.Bool:
+			return !constant.BoolVal(u)
 		default:
-			Dump("unexpected literal", n)
-			Fatalf("isZero")
-		case string:
-			return u == ""
-		case bool:
-			return !u
-		case *Mpint:
-			return u.CmpInt64(0) == 0
-		case *Mpflt:
-			return u.CmpFloat64(0) == 0
-		case *Mpcplx:
-			return u.Real.CmpFloat64(0) == 0 && u.Imag.CmpFloat64(0) == 0
+			return constant.Sign(u) == 0
 		}
 
 	case OARRAYLIT:
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 88ff8d684c..7a8dda2938 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -2044,9 +2044,9 @@ func (s *state) expr(n *Node) *ssa.Value {
 			return s.constNil(t)
 		}
 	case OLITERAL:
-		switch u := n.Val().U.(type) {
-		case *Mpint:
-			i := u.Int64()
+		switch u := n.Val(); u.Kind() {
+		case constant.Int:
+			i := int64Val(n.Type, u)
 			switch n.Type.Size() {
 			case 1:
 				return s.constInt8(n.Type, int8(i))
@@ -2060,44 +2060,45 @@ func (s *state) expr(n *Node) *ssa.Value {
 				s.Fatalf("bad integer size %d", n.Type.Size())
 				return nil
 			}
-		case string:
-			if u == "" {
+		case constant.String:
+			i := constant.StringVal(u)
+			if i == "" {
 				return s.constEmptyString(n.Type)
 			}
-			return s.entryNewValue0A(ssa.OpConstString, n.Type, u)
-		case bool:
-			return s.constBool(u)
-		case *Mpflt:
+			return s.entryNewValue0A(ssa.OpConstString, n.Type, i)
+		case constant.Bool:
+			return s.constBool(constant.BoolVal(u))
+		case constant.Float:
+			f, _ := constant.Float64Val(u)
 			switch n.Type.Size() {
 			case 4:
-				return s.constFloat32(n.Type, u.Float32())
+				return s.constFloat32(n.Type, f)
 			case 8:
-				return s.constFloat64(n.Type, u.Float64())
+				return s.constFloat64(n.Type, f)
 			default:
 				s.Fatalf("bad float size %d", n.Type.Size())
 				return nil
 			}
-		case *Mpcplx:
-			r := &u.Real
-			i := &u.Imag
+		case constant.Complex:
+			re, _ := constant.Float64Val(constant.Real(u))
+			im, _ := constant.Float64Val(constant.Imag(u))
 			switch n.Type.Size() {
 			case 8:
 				pt := types.Types[TFLOAT32]
 				return s.newValue2(ssa.OpComplexMake, n.Type,
-					s.constFloat32(pt, r.Float32()),
-					s.constFloat32(pt, i.Float32()))
+					s.constFloat32(pt, re),
+					s.constFloat32(pt, im))
 			case 16:
 				pt := types.Types[TFLOAT64]
 				return s.newValue2(ssa.OpComplexMake, n.Type,
-					s.constFloat64(pt, r.Float64()),
-					s.constFloat64(pt, i.Float64()))
+					s.constFloat64(pt, re),
+					s.constFloat64(pt, im))
 			default:
-				s.Fatalf("bad float size %d", n.Type.Size())
+				s.Fatalf("bad complex size %d", n.Type.Size())
 				return nil
 			}
-
 		default:
-			s.Fatalf("unhandled OLITERAL %v", n.Val().Kind())
+			s.Fatalf("unhandled OLITERAL %v", u.Kind())
 			return nil
 		}
 	case OCONVNOP:
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 1aa3af929c..ebc5af63e1 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -10,6 +10,7 @@ import (
 	"crypto/md5"
 	"encoding/binary"
 	"fmt"
+	"go/constant"
 	"sort"
 	"strconv"
 	"strings"
@@ -252,9 +253,7 @@ func (x methcmp) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
 func (x methcmp) Less(i, j int) bool { return x[i].Sym.Less(x[j].Sym) }
 
 func nodintconst(v int64) *Node {
-	u := new(Mpint)
-	u.SetInt64(v)
-	return nodlit(Val{u})
+	return nodlit(constant.MakeInt64(v))
 }
 
 func nodnil() *Node {
@@ -264,11 +263,11 @@ func nodnil() *Node {
 }
 
 func nodbool(b bool) *Node {
-	return nodlit(Val{b})
+	return nodlit(constant.MakeBool(b))
 }
 
 func nodstr(s string) *Node {
-	return nodlit(Val{s})
+	return nodlit(constant.MakeString(s))
 }
 
 // treecopy recursively copies n, with the exception of
diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index 8459bd7c18..c249a85b64 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -8,6 +8,7 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"go/constant"
+	"go/token"
 	"sort"
 )
 
@@ -400,7 +401,7 @@ func (s *exprSwitch) flush() {
 	}
 
 	sort.Slice(cc, func(i, j int) bool {
-		return compareOp(cc[i].lo.Val(), OLT, cc[j].lo.Val())
+		return constant.Compare(cc[i].lo.Val(), token.LSS, cc[j].lo.Val())
 	})
 
 	// Merge consecutive integer cases.
diff --git a/src/cmd/compile/internal/gc/syntax.go b/src/cmd/compile/internal/gc/syntax.go
index 39f2996808..3b585ea341 100644
--- a/src/cmd/compile/internal/gc/syntax.go
+++ b/src/cmd/compile/internal/gc/syntax.go
@@ -12,6 +12,7 @@ import (
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
 	"cmd/internal/src"
+	"go/constant"
 	"sort"
 )
 
@@ -236,16 +237,17 @@ func (n *Node) MarkReadonly() {
 	n.Sym.Linksym().Type = objabi.SRODATA
 }
 
-// Val returns the Val for the node.
-func (n *Node) Val() Val {
+// Val returns the constant.Value for the node.
+func (n *Node) Val() constant.Value {
 	if !n.HasVal() {
-		return Val{}
+		return constant.MakeUnknown()
 	}
-	return Val{n.E}
+	return *n.E.(*constant.Value)
 }
 
-// SetVal sets the Val for the node, which must not have been used with SetOpt.
-func (n *Node) SetVal(v Val) {
+// SetVal sets the constant.Value for the node,
+// which must not have been used with SetOpt.
+func (n *Node) SetVal(v constant.Value) {
 	if n.HasOpt() {
 		Debug.h = 1
 		Dump("have Opt", n)
@@ -255,7 +257,7 @@ func (n *Node) SetVal(v Val) {
 		assertRepresents(n.Type, v)
 	}
 	n.SetHasVal(true)
-	n.E = v.U
+	n.E = &v
 }
 
 // Opt returns the optimizer data for the node.
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index e014a0ba2d..d1bc781a54 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -8,6 +8,7 @@ import (
 	"cmd/compile/internal/types"
 	"fmt"
 	"go/constant"
+	"go/token"
 	"strings"
 )
 
@@ -361,7 +362,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		ok |= ctxExpr
 
 		if n.Type == nil && n.Val().Kind() == constant.String {
-			n.Type = types.UntypedString
+			Fatalf("string literal missing type")
 		}
 
 	case ONIL, ONONAME:
@@ -446,12 +447,13 @@ func typecheck1(n *Node, top int) (res *Node) {
 				return n
 			}
 
-			bound := v.U.(*Mpint).Int64()
-			if bound < 0 {
+			if constant.Sign(v) < 0 {
 				yyerror("array bound must be non-negative")
 				n.Type = nil
 				return n
 			}
+
+			bound, _ := constant.Int64Val(v)
 			t = types.NewArray(r.Type, bound)
 		}
 
@@ -776,8 +778,9 @@ func typecheck1(n *Node, top int) (res *Node) {
 		}
 
 		if iscmp[n.Op] {
-			n = evalConst(n)
 			t = types.UntypedBool
+			n.Type = t
+			n = evalConst(n)
 			if n.Op != OLITERAL {
 				l, r = defaultlit2(l, r, true)
 				n.Left = l
@@ -803,7 +806,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		}
 
 		if (op == ODIV || op == OMOD) && Isconst(r, constant.Int) {
-			if r.Val().U.(*Mpint).CmpInt64(0) == 0 {
+			if constant.Sign(r.Val()) == 0 {
 				yyerror("division by zero")
 				n.Type = nil
 				return n
@@ -1045,14 +1048,14 @@ func typecheck1(n *Node, top int) (res *Node) {
 			}
 
 			if !n.Bounded() && Isconst(n.Right, constant.Int) {
-				x := n.Right.Int64Val()
-				if x < 0 {
+				x := n.Right.Val()
+				if constant.Sign(x) < 0 {
 					yyerror("invalid %s index %v (index must be non-negative)", why, n.Right)
-				} else if t.IsArray() && x >= t.NumElem() {
+				} else if t.IsArray() && constant.Compare(x, token.GEQ, constant.MakeInt64(t.NumElem())) {
 					yyerror("invalid array index %v (out of bounds for %d-element array)", n.Right, t.NumElem())
-				} else if Isconst(n.Left, constant.String) && x >= int64(len(n.Left.StringVal())) {
+				} else if Isconst(n.Left, constant.String) && constant.Compare(x, token.GEQ, constant.MakeInt64(int64(len(n.Left.StringVal())))) {
 					yyerror("invalid string index %v (out of bounds for %d-byte string)", n.Right, len(n.Left.StringVal()))
-				} else if doesoverflow(n.Right.Val(), types.Types[TINT]) {
+				} else if doesoverflow(x, types.Types[TINT]) {
 					yyerror("invalid %s index %v (index too large)", why, n.Right)
 				}
 			}
@@ -1155,7 +1158,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			Fatalf("cap for OSLICEHEADER must be non-negative")
 		}
 
-		if Isconst(l, constant.Int) && Isconst(c, constant.Int) && compareOp(l.Val(), OGT, c.Val()) {
+		if Isconst(l, constant.Int) && Isconst(c, constant.Int) && constant.Compare(l.Val(), token.GTR, c.Val()) {
 			Fatalf("len larger than cap for OSLICEHEADER")
 		}
 
@@ -1200,7 +1203,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			if doesoverflow(n.Left.Val(), types.Types[TINT]) {
 				Fatalf("len for OMAKESLICECOPY too large")
 			}
-			if n.Left.Int64Val() < 0 {
+			if constant.Sign(n.Left.Val()) < 0 {
 				Fatalf("len for OMAKESLICECOPY must be non-negative")
 			}
 		}
@@ -1773,7 +1776,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 				n.Type = nil
 				return n
 			}
-			if Isconst(l, constant.Int) && r != nil && Isconst(r, constant.Int) && compareOp(l.Val(), OGT, r.Val()) {
+			if Isconst(l, constant.Int) && r != nil && Isconst(r, constant.Int) && constant.Compare(l.Val(), token.GTR, r.Val()) {
 				yyerror("len larger than cap in make(%v)", t)
 				n.Type = nil
 				return n
@@ -2181,16 +2184,17 @@ func checksliceindex(l *Node, r *Node, tp *types.Type) bool {
 	}
 
 	if r.Op == OLITERAL {
-		if r.Int64Val() < 0 {
+		x := r.Val()
+		if constant.Sign(x) < 0 {
 			yyerror("invalid slice index %v (index must be non-negative)", r)
 			return false
-		} else if tp != nil && tp.NumElem() >= 0 && r.Int64Val() > tp.NumElem() {
+		} else if tp != nil && tp.NumElem() >= 0 && constant.Compare(x, token.GTR, constant.MakeInt64(tp.NumElem())) {
 			yyerror("invalid slice index %v (out of bounds for %d-element array)", r, tp.NumElem())
 			return false
-		} else if Isconst(l, constant.String) && r.Int64Val() > int64(len(l.StringVal())) {
+		} else if Isconst(l, constant.String) && constant.Compare(x, token.GTR, constant.MakeInt64(int64(len(l.StringVal())))) {
 			yyerror("invalid slice index %v (out of bounds for %d-byte string)", r, len(l.StringVal()))
 			return false
-		} else if doesoverflow(r.Val(), types.Types[TINT]) {
+		} else if doesoverflow(x, types.Types[TINT]) {
 			yyerror("invalid slice index %v (index too large)", r)
 			return false
 		}
@@ -2200,7 +2204,7 @@ func checksliceindex(l *Node, r *Node, tp *types.Type) bool {
 }
 
 func checksliceconst(lo *Node, hi *Node) bool {
-	if lo != nil && hi != nil && lo.Op == OLITERAL && hi.Op == OLITERAL && compareOp(lo.Val(), OGT, hi.Val()) {
+	if lo != nil && hi != nil && lo.Op == OLITERAL && hi.Op == OLITERAL && constant.Compare(lo.Val(), token.GTR, hi.Val()) {
 		yyerror("invalid slice index: %v > %v", lo, hi)
 		return false
 	}
@@ -3192,7 +3196,7 @@ func samesafeexpr(l *Node, r *Node) bool {
 		return samesafeexpr(l.Left, r.Left) && samesafeexpr(l.Right, r.Right)
 
 	case OLITERAL:
-		return eqval(l.Val(), r.Val())
+		return constant.Compare(l.Val(), token.EQL, r.Val())
 
 	case ONIL:
 		return true
@@ -3625,7 +3629,9 @@ func typecheckdef(n *Node) {
 		}
 
 		n.Type = e.Type
-		n.SetVal(e.Val())
+		if n.Type != nil {
+			n.SetVal(e.Val())
+		}
 
 	case ONAME:
 		if n.Name.Param.Ntype != nil {
@@ -3723,14 +3729,13 @@ func checkmake(t *types.Type, arg string, np **Node) bool {
 
 	// Do range checks for constants before defaultlit
 	// to avoid redundant "constant NNN overflows int" errors.
-	switch consttype(n) {
-	case constant.Int, constant.Float, constant.Complex:
-		v := toint(n.Val()).U.(*Mpint)
-		if v.CmpInt64(0) < 0 {
+	if n.Op == OLITERAL {
+		v := toint(n.Val())
+		if constant.Sign(v) < 0 {
 			yyerror("negative %s argument in make(%v)", arg, t)
 			return false
 		}
-		if v.Cmp(maxintval[TINT]) > 0 {
+		if doesoverflow(v, types.Types[TINT]) {
 			yyerror("%s argument too large in make(%v)", arg, t)
 			return false
 		}
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index 32bf37e322..8c32f2f6d2 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -209,8 +209,6 @@ func typeinit() {
 			okforand[et] = true
 			okforconst[et] = true
 			issimple[et] = true
-			minintval[et] = new(Mpint)
-			maxintval[et] = new(Mpint)
 		}
 
 		if isFloat[et] {
@@ -220,8 +218,6 @@ func typeinit() {
 			okforarith[et] = true
 			okforconst[et] = true
 			issimple[et] = true
-			minfltval[et] = newMpflt()
-			maxfltval[et] = newMpflt()
 		}
 
 		if isComplex[et] {
@@ -310,31 +306,6 @@ func typeinit() {
 	iscmp[OEQ] = true
 	iscmp[ONE] = true
 
-	maxintval[TINT8].SetString("0x7f")
-	minintval[TINT8].SetString("-0x80")
-	maxintval[TINT16].SetString("0x7fff")
-	minintval[TINT16].SetString("-0x8000")
-	maxintval[TINT32].SetString("0x7fffffff")
-	minintval[TINT32].SetString("-0x80000000")
-	maxintval[TINT64].SetString("0x7fffffffffffffff")
-	minintval[TINT64].SetString("-0x8000000000000000")
-
-	maxintval[TUINT8].SetString("0xff")
-	maxintval[TUINT16].SetString("0xffff")
-	maxintval[TUINT32].SetString("0xffffffff")
-	maxintval[TUINT64].SetString("0xffffffffffffffff")
-
-	// f is valid float if min < f < max.  (min and max are not themselves valid.)
-	maxfltval[TFLOAT32].SetString("33554431p103") // 2^24-1 p (127-23) + 1/2 ulp
-	minfltval[TFLOAT32].SetString("-33554431p103")
-	maxfltval[TFLOAT64].SetString("18014398509481983p970") // 2^53-1 p (1023-52) + 1/2 ulp
-	minfltval[TFLOAT64].SetString("-18014398509481983p970")
-
-	maxfltval[TCOMPLEX64] = maxfltval[TFLOAT32]
-	minfltval[TCOMPLEX64] = minfltval[TFLOAT32]
-	maxfltval[TCOMPLEX128] = maxfltval[TFLOAT64]
-	minfltval[TCOMPLEX128] = minfltval[TFLOAT64]
-
 	types.Types[TINTER] = types.New(TINTER) // empty interface
 
 	// simple aliases
@@ -410,10 +381,6 @@ func lexinit1() {
 		}
 
 		simtype[s.etype] = sameas
-		minfltval[s.etype] = minfltval[sameas]
-		maxfltval[s.etype] = maxfltval[sameas]
-		minintval[s.etype] = minintval[sameas]
-		maxintval[s.etype] = maxintval[sameas]
 
 		t := types.New(s.etype)
 		t.Sym = s1
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 9971fb0c0d..b1bac06fd0 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -12,6 +12,7 @@ import (
 	"encoding/binary"
 	"fmt"
 	"go/constant"
+	"go/token"
 	"strings"
 )
 
@@ -1002,7 +1003,7 @@ opswitch:
 						break opswitch
 					}
 				case TUINT64:
-					c := uint64(n.Right.Int64Val())
+					c := n.Right.Uint64Val()
 					if c < 1<<16 {
 						break opswitch
 					}
@@ -1062,7 +1063,7 @@ opswitch:
 		}
 
 		if Isconst(n.Right, constant.Int) {
-			if n.Right.Val().U.(*Mpint).CmpInt64(0) < 0 || doesoverflow(n.Right.Val(), types.Types[TINT]) {
+			if v := n.Right.Val(); constant.Sign(v) < 0 || doesoverflow(v, types.Types[TINT]) {
 				yyerror("index out of bounds")
 			}
 		}
@@ -1223,7 +1224,7 @@ opswitch:
 			// Maximum key and elem size is 128 bytes, larger objects
 			// are stored with an indirection. So max bucket size is 2048+eps.
 			if !Isconst(hint, constant.Int) ||
-				hint.Val().U.(*Mpint).CmpInt64(BUCKETSIZE) <= 0 {
+				constant.Compare(hint.Val(), token.LEQ, constant.MakeInt64(BUCKETSIZE)) {
 
 				// In case hint is larger than BUCKETSIZE runtime.makemap
 				// will allocate the buckets on the heap, see #20184
@@ -1256,7 +1257,7 @@ opswitch:
 			}
 		}
 
-		if Isconst(hint, constant.Int) && hint.Val().U.(*Mpint).CmpInt64(BUCKETSIZE) <= 0 {
+		if Isconst(hint, constant.Int) && constant.Compare(hint.Val(), token.LEQ, constant.MakeInt64(BUCKETSIZE)) {
 			// Handling make(map[any]any) and
 			// make(map[any]any, hint) where hint <= BUCKETSIZE
 			// special allows for faster map initialization and
@@ -1588,8 +1589,8 @@ opswitch:
 		n = typecheck(n, ctxExpr)
 		// Emit string symbol now to avoid emitting
 		// any concurrently during the backend.
-		if s, ok := n.Val().U.(string); ok {
-			_ = stringsym(n.Pos, s)
+		if v := n.Val(); v.Kind() == constant.String {
+			_ = stringsym(n.Pos, constant.StringVal(v))
 		}
 	}
 
@@ -3841,17 +3842,14 @@ func candiscard(n *Node) bool {
 
 		// Discardable as long as we know it's not division by zero.
 	case ODIV, OMOD:
-		if Isconst(n.Right, constant.Int) && n.Right.Val().U.(*Mpint).CmpInt64(0) != 0 {
-			break
-		}
-		if Isconst(n.Right, constant.Float) && n.Right.Val().U.(*Mpflt).CmpFloat64(0) != 0 {
+		if n.Right.Op == OLITERAL && constant.Sign(n.Right.Val()) != 0 {
 			break
 		}
 		return false
 
 		// Discardable as long as we know it won't fail because of a bad size.
 	case OMAKECHAN, OMAKEMAP:
-		if Isconst(n.Left, constant.Int) && n.Left.Val().U.(*Mpint).CmpInt64(0) == 0 {
+		if Isconst(n.Left, constant.Int) && constant.Sign(n.Left.Val()) == 0 {
 			break
 		}
 		return false
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 82db9e4dbc..f1a01b64da 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -1212,7 +1212,7 @@ func (t *Type) IsInteger() bool {
 	case TINT8, TUINT8, TINT16, TUINT16, TINT32, TUINT32, TINT64, TUINT64, TINT, TUINT, TUINTPTR:
 		return true
 	}
-	return false
+	return t == UntypedInt || t == UntypedRune
 }
 
 func (t *Type) IsSigned() bool {
@@ -1223,12 +1223,20 @@ func (t *Type) IsSigned() bool {
 	return false
 }
 
+func (t *Type) IsUnsigned() bool {
+	switch t.Etype {
+	case TUINT8, TUINT16, TUINT32, TUINT64, TUINT, TUINTPTR:
+		return true
+	}
+	return false
+}
+
 func (t *Type) IsFloat() bool {
-	return t.Etype == TFLOAT32 || t.Etype == TFLOAT64
+	return t.Etype == TFLOAT32 || t.Etype == TFLOAT64 || t == UntypedFloat
 }
 
 func (t *Type) IsComplex() bool {
-	return t.Etype == TCOMPLEX64 || t.Etype == TCOMPLEX128
+	return t.Etype == TCOMPLEX64 || t.Etype == TCOMPLEX128 || t == UntypedComplex
 }
 
 // IsPtr reports whether t is a regular Go pointer type.
diff --git a/test/fixedbugs/issue20232.go b/test/fixedbugs/issue20232.go
index f91c74936b..fbe8cdebfb 100644
--- a/test/fixedbugs/issue20232.go
+++ b/test/fixedbugs/issue20232.go
@@ -6,6 +6,6 @@
 
 package main
 
-const _ = 6e5518446744 // ERROR "malformed constant: 6e5518446744 \(exponent overflow\)"
+const _ = 6e5518446744 // ERROR "malformed constant: 6e5518446744"
 const _ = 1e-1000000000
-const _ = 1e+1000000000 // ERROR "constant too large"
+const _ = 1e+1000000000
-- 
GitLab


From 484449c6416662c5453257c641d015c1fca681ea Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 24 Nov 2020 12:35:33 -0800
Subject: [PATCH 0056/2400] [dev.regabi] cmd/compile: remove file mistakenly
 added by CL 272248

Change-Id: Ib27a2ab499960cda3bedfd6c1d10a4038c519df5
Reviewed-on: https://go-review.googlesource.com/c/go/+/272986
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/_rex.20201123151057 | 1 -
 1 file changed, 1 deletion(-)
 delete mode 100644 src/_rex.20201123151057

diff --git a/src/_rex.20201123151057 b/src/_rex.20201123151057
deleted file mode 100644
index 8b13789179..0000000000
--- a/src/_rex.20201123151057
+++ /dev/null
@@ -1 +0,0 @@
-
-- 
GitLab


From 4a6b4fd13965fe8428c9177bdd824a48dff553c0 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 24 Nov 2020 15:52:13 -0800
Subject: [PATCH 0057/2400] [dev.regabi] add FatalfAt and fix Fatalf docs

I've wanted a FatalfAt function for a while, but under the old "-l"
suffix naming convention it would have been called "Fatalfl", which is
just atrocious.

Change-Id: If87f692ecdff478769426d4b054ac396e5c1e42e
Reviewed-on: https://go-review.googlesource.com/c/go/+/273013
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/gc/print.go | 26 +++++++++++++++++++++-----
 1 file changed, 21 insertions(+), 5 deletions(-)

diff --git a/src/cmd/compile/internal/gc/print.go b/src/cmd/compile/internal/gc/print.go
index 1dbd58df42..52585814f6 100644
--- a/src/cmd/compile/internal/gc/print.go
+++ b/src/cmd/compile/internal/gc/print.go
@@ -177,23 +177,39 @@ func Warnl(pos src.XPos, format string, args ...interface{}) {
 	}
 }
 
-// Fatal reports a fatal error - an internal problem - at the current line and exits.
-// If other errors have already been printed, then Fatal just quietly exits.
+// Fatalf reports a fatal error - an internal problem - at the current line and exits.
+// If other errors have already been printed, then Fatalf just quietly exits.
 // (The internal problem may have been caused by incomplete information
 // after the already-reported errors, so best to let users fix those and
 // try again without being bothered about a spurious internal error.)
 //
 // But if no errors have been printed, or if -d panic has been specified,
-// Fatal prints the error as an "internal compiler error". In a released build,
+// Fatalf prints the error as an "internal compiler error". In a released build,
 // it prints an error asking to file a bug report. In development builds, it
 // prints a stack trace.
 //
-// If -h has been specified, Fatal panics to force the usual runtime info dump.
+// If -h has been specified, Fatalf panics to force the usual runtime info dump.
 func Fatalf(format string, args ...interface{}) {
+	FatalfAt(lineno, format, args...)
+}
+
+// FatalfAt reports a fatal error - an internal problem - at pos and exits.
+// If other errors have already been printed, then FatalfAt just quietly exits.
+// (The internal problem may have been caused by incomplete information
+// after the already-reported errors, so best to let users fix those and
+// try again without being bothered about a spurious internal error.)
+//
+// But if no errors have been printed, or if -d panic has been specified,
+// FatalfAt prints the error as an "internal compiler error". In a released build,
+// it prints an error asking to file a bug report. In development builds, it
+// prints a stack trace.
+//
+// If -h has been specified, FatalfAt panics to force the usual runtime info dump.
+func FatalfAt(pos src.XPos, format string, args ...interface{}) {
 	flusherrors()
 
 	if Debug_panic != 0 || numErrors == 0 {
-		fmt.Printf("%v: internal compiler error: ", linestr(lineno))
+		fmt.Printf("%v: internal compiler error: ", linestr(pos))
 		fmt.Printf(format, args...)
 		fmt.Printf("\n")
 
-- 
GitLab


From 9e0e43d84d1bb653a74ccc7f90a80dfa9c665fbf Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 24 Nov 2020 22:09:57 -0500
Subject: [PATCH 0058/2400] [dev.regabi] cmd/compile: remove uses of dummy

Per https://developers.google.com/style/inclusive-documentation,
since we are editing some of this code anyway and it is easier
to put the cleanup in a separate CL.

Change-Id: Ib6b851f43f9cc0a57676564477d4ff22abb1cee5
Reviewed-on: https://go-review.googlesource.com/c/go/+/273106
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/align.go          |  2 +-
 src/cmd/compile/internal/gc/escape.go         |  2 +-
 src/cmd/compile/internal/gc/init.go           | 21 +++--
 src/cmd/compile/internal/gc/main.go           |  4 +-
 src/cmd/compile/internal/gc/pgen.go           |  2 +-
 src/cmd/compile/internal/gc/phi.go            |  2 +-
 src/cmd/compile/internal/gc/ssa.go            |  8 +-
 src/cmd/compile/internal/gc/typecheck.go      |  4 +-
 src/cmd/compile/internal/ssa/export_test.go   | 92 +++++++++----------
 src/cmd/compile/internal/ssa/poset.go         | 54 +++++------
 src/cmd/compile/internal/ssa/regalloc.go      |  2 +-
 .../compile/internal/syntax/dumper_test.go    |  2 +-
 src/cmd/compile/internal/syntax/nodes.go      |  2 +-
 .../compile/internal/syntax/printer_test.go   |  2 +-
 src/cmd/compile/internal/types/type.go        |  2 +-
 15 files changed, 100 insertions(+), 101 deletions(-)

diff --git a/src/cmd/compile/internal/gc/align.go b/src/cmd/compile/internal/gc/align.go
index 1f7631d199..563bd5030c 100644
--- a/src/cmd/compile/internal/gc/align.go
+++ b/src/cmd/compile/internal/gc/align.go
@@ -392,7 +392,7 @@ func dowidth(t *types.Type) {
 		w = 1 // anything will do
 
 	case TANY:
-		// dummy type; should be replaced before use.
+		// not a real type; should be replaced before use.
 		Fatalf("dowidth any")
 
 	case TSTRING:
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 497151d02f..50674e1a1a 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -574,7 +574,7 @@ func (e *Escape) exprSkipInit(k EscHole, n *Node) {
 		// parameters all flow to the heap.
 		//
 		// TODO(mdempsky): Change ks into a callback, so that
-		// we don't have to create this dummy slice?
+		// we don't have to create this slice?
 		var ks []EscHole
 		for i := m.Type.NumResults(); i > 0; i-- {
 			ks = append(ks, e.heapHole())
diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index ec9cc4bddc..c3b66a2ad2 100644
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -15,8 +15,9 @@ import (
 // the name, normally "pkg.init", is altered to "pkg.init.0".
 var renameinitgen int
 
-// Dummy function for autotmps generated during typechecking.
-var dummyInitFn = nod(ODCLFUNC, nil, nil)
+// Function collecting autotmps generated during typechecking,
+// to be included in the package-level init function.
+var initTodo = nod(ODCLFUNC, nil, nil)
 
 func renameinit() *types.Sym {
 	s := lookupN("init.", renameinitgen)
@@ -46,11 +47,11 @@ func fninit(n []*Node) {
 		lineno = nf[0].Pos // prolog/epilog gets line number of first init stmt
 		initializers := lookup("init")
 		fn := dclfunc(initializers, nod(OTFUNC, nil, nil))
-		for _, dcl := range dummyInitFn.Func.Dcl {
+		for _, dcl := range initTodo.Func.Dcl {
 			dcl.Name.Curfn = fn
 		}
-		fn.Func.Dcl = append(fn.Func.Dcl, dummyInitFn.Func.Dcl...)
-		dummyInitFn.Func.Dcl = nil
+		fn.Func.Dcl = append(fn.Func.Dcl, initTodo.Func.Dcl...)
+		initTodo.Func.Dcl = nil
 
 		fn.Nbody.Set(nf)
 		funcbody()
@@ -62,13 +63,13 @@ func fninit(n []*Node) {
 		xtop = append(xtop, fn)
 		fns = append(fns, initializers.Linksym())
 	}
-	if dummyInitFn.Func.Dcl != nil {
-		// We only generate temps using dummyInitFn if there
+	if initTodo.Func.Dcl != nil {
+		// We only generate temps using initTodo if there
 		// are package-scope initialization statements, so
 		// something's weird if we get here.
-		Fatalf("dummyInitFn still has declarations")
+		Fatalf("initTodo still has declarations")
 	}
-	dummyInitFn = nil
+	initTodo = nil
 
 	// Record user init functions.
 	for i := 0; i < renameinitgen; i++ {
@@ -88,7 +89,7 @@ func fninit(n []*Node) {
 	// Make an .inittask structure.
 	sym := lookup(".inittask")
 	nn := newname(sym)
-	nn.Type = types.Types[TUINT8] // dummy type
+	nn.Type = types.Types[TUINT8] // fake type
 	nn.SetClass(PEXTERN)
 	sym.Def = asTypesNode(nn)
 	exportsym(nn)
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index fca1334a19..428bf31fa9 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -1254,9 +1254,7 @@ func importfile(f constant.Value) *types.Pkg {
 		}
 	}
 
-	// In the importfile, if we find:
-	// $$\n  (textual format): not supported anymore
-	// $$B\n (binary format) : import directly, then feed the lexer a dummy statement
+	// Expect $$B\n to signal binary import format.
 
 	// look for $$
 	var c byte
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index 0f0f6b7107..7c1d5543e3 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -459,7 +459,7 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 	decls, dwarfVars := createDwarfVars(fnsym, isODCLFUNC, fn.Func, apdecls)
 
 	// For each type referenced by the functions auto vars but not
-	// already referenced by a dwarf var, attach a dummy relocation to
+	// already referenced by a dwarf var, attach an R_USETYPE relocation to
 	// the function symbol to insure that the type included in DWARF
 	// processing during linking.
 	typesyms := []*obj.LSym{}
diff --git a/src/cmd/compile/internal/gc/phi.go b/src/cmd/compile/internal/gc/phi.go
index 5218cd0ef3..4beaa11a7e 100644
--- a/src/cmd/compile/internal/gc/phi.go
+++ b/src/cmd/compile/internal/gc/phi.go
@@ -59,7 +59,7 @@ type phiState struct {
 	hasDef *sparseSet   // has a write of the variable we're processing
 
 	// miscellaneous
-	placeholder *ssa.Value // dummy value to use as a "not set yet" placeholder.
+	placeholder *ssa.Value // value to use as a "not set yet" placeholder.
 }
 
 func (s *phiState) insertPhis() {
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 7a8dda2938..f196bee4a2 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -692,10 +692,10 @@ func (s *state) Warnl(pos src.XPos, msg string, args ...interface{}) { s.f.Warnl
 func (s *state) Debug_checknil() bool                                { return s.f.Frontend().Debug_checknil() }
 
 var (
-	// dummy node for the memory variable
+	// marker node for the memory variable
 	memVar = Node{Op: ONAME, Sym: &types.Sym{Name: "mem"}}
 
-	// dummy nodes for temporary variables
+	// marker nodes for temporary variables
 	ptrVar       = Node{Op: ONAME, Sym: &types.Sym{Name: "ptr"}}
 	lenVar       = Node{Op: ONAME, Sym: &types.Sym{Name: "len"}}
 	newlenVar    = Node{Op: ONAME, Sym: &types.Sym{Name: "newlen"}}
@@ -4793,7 +4793,7 @@ func (s *state) getMethodClosure(fn *Node) *ssa.Value {
 	n2.SetClass(PFUNC)
 	// n2.Sym already existed, so it's already marked as a function.
 	n2.Pos = fn.Pos
-	n2.Type = types.Types[TUINT8] // dummy type for a static closure. Could use runtime.funcval if we had it.
+	n2.Type = types.Types[TUINT8] // fake type for a static closure. Could use runtime.funcval if we had it.
 	return s.expr(n2)
 }
 
@@ -6054,7 +6054,7 @@ func (s *state) mem() *ssa.Value {
 
 func (s *state) addNamedValue(n *Node, v *ssa.Value) {
 	if n.Class() == Pxxx {
-		// Don't track our dummy nodes (&memVar etc.).
+		// Don't track our marker nodes (&memVar etc.).
 		return
 	}
 	if n.IsAutoTmp() {
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index d1bc781a54..9cc1dee773 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -2153,11 +2153,11 @@ func typecheckargs(n *Node) {
 	// If we're outside of function context, then this call will
 	// be executed during the generated init function. However,
 	// init.go hasn't yet created it. Instead, associate the
-	// temporary variables with dummyInitFn for now, and init.go
+	// temporary variables with initTodo for now, and init.go
 	// will reassociate them later when it's appropriate.
 	static := Curfn == nil
 	if static {
-		Curfn = dummyInitFn
+		Curfn = initTodo
 	}
 	for _, f := range t.FieldSlice() {
 		t := temp(f.Type)
diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go
index b4c3e5cfdf..bfe94ff160 100644
--- a/src/cmd/compile/internal/ssa/export_test.go
+++ b/src/cmd/compile/internal/ssa/export_test.go
@@ -36,10 +36,10 @@ func testConfigArch(tb testing.TB, arch string) *Conf {
 		tb.Fatalf("unknown arch %s", arch)
 	}
 	if ctxt.Arch.PtrSize != 8 {
-		tb.Fatal("dummyTypes is 64-bit only")
+		tb.Fatal("testTypes is 64-bit only")
 	}
 	c := &Conf{
-		config: NewConfig(arch, dummyTypes, ctxt, true),
+		config: NewConfig(arch, testTypes, ctxt, true),
 		tb:     tb,
 	}
 	return c
@@ -53,108 +53,108 @@ type Conf struct {
 
 func (c *Conf) Frontend() Frontend {
 	if c.fe == nil {
-		c.fe = DummyFrontend{t: c.tb, ctxt: c.config.ctxt}
+		c.fe = TestFrontend{t: c.tb, ctxt: c.config.ctxt}
 	}
 	return c.fe
 }
 
-// DummyFrontend is a test-only frontend.
+// TestFrontend is a test-only frontend.
 // It assumes 64 bit integers and pointers.
-type DummyFrontend struct {
+type TestFrontend struct {
 	t    testing.TB
 	ctxt *obj.Link
 }
 
-type DummyAuto struct {
+type TestAuto struct {
 	t *types.Type
 	s string
 }
 
-func (d *DummyAuto) Typ() *types.Type {
+func (d *TestAuto) Typ() *types.Type {
 	return d.t
 }
 
-func (d *DummyAuto) String() string {
+func (d *TestAuto) String() string {
 	return d.s
 }
 
-func (d *DummyAuto) StorageClass() StorageClass {
+func (d *TestAuto) StorageClass() StorageClass {
 	return ClassAuto
 }
 
-func (d *DummyAuto) IsSynthetic() bool {
+func (d *TestAuto) IsSynthetic() bool {
 	return false
 }
 
-func (d *DummyAuto) IsAutoTmp() bool {
+func (d *TestAuto) IsAutoTmp() bool {
 	return true
 }
 
-func (DummyFrontend) StringData(s string) *obj.LSym {
+func (TestFrontend) StringData(s string) *obj.LSym {
 	return nil
 }
-func (DummyFrontend) Auto(pos src.XPos, t *types.Type) GCNode {
-	return &DummyAuto{t: t, s: "aDummyAuto"}
+func (TestFrontend) Auto(pos src.XPos, t *types.Type) GCNode {
+	return &TestAuto{t: t, s: "aTestAuto"}
 }
-func (d DummyFrontend) SplitString(s LocalSlot) (LocalSlot, LocalSlot) {
-	return LocalSlot{N: s.N, Type: dummyTypes.BytePtr, Off: s.Off}, LocalSlot{N: s.N, Type: dummyTypes.Int, Off: s.Off + 8}
+func (d TestFrontend) SplitString(s LocalSlot) (LocalSlot, LocalSlot) {
+	return LocalSlot{N: s.N, Type: testTypes.BytePtr, Off: s.Off}, LocalSlot{N: s.N, Type: testTypes.Int, Off: s.Off + 8}
 }
-func (d DummyFrontend) SplitInterface(s LocalSlot) (LocalSlot, LocalSlot) {
-	return LocalSlot{N: s.N, Type: dummyTypes.BytePtr, Off: s.Off}, LocalSlot{N: s.N, Type: dummyTypes.BytePtr, Off: s.Off + 8}
+func (d TestFrontend) SplitInterface(s LocalSlot) (LocalSlot, LocalSlot) {
+	return LocalSlot{N: s.N, Type: testTypes.BytePtr, Off: s.Off}, LocalSlot{N: s.N, Type: testTypes.BytePtr, Off: s.Off + 8}
 }
-func (d DummyFrontend) SplitSlice(s LocalSlot) (LocalSlot, LocalSlot, LocalSlot) {
+func (d TestFrontend) SplitSlice(s LocalSlot) (LocalSlot, LocalSlot, LocalSlot) {
 	return LocalSlot{N: s.N, Type: s.Type.Elem().PtrTo(), Off: s.Off},
-		LocalSlot{N: s.N, Type: dummyTypes.Int, Off: s.Off + 8},
-		LocalSlot{N: s.N, Type: dummyTypes.Int, Off: s.Off + 16}
+		LocalSlot{N: s.N, Type: testTypes.Int, Off: s.Off + 8},
+		LocalSlot{N: s.N, Type: testTypes.Int, Off: s.Off + 16}
 }
-func (d DummyFrontend) SplitComplex(s LocalSlot) (LocalSlot, LocalSlot) {
+func (d TestFrontend) SplitComplex(s LocalSlot) (LocalSlot, LocalSlot) {
 	if s.Type.Size() == 16 {
-		return LocalSlot{N: s.N, Type: dummyTypes.Float64, Off: s.Off}, LocalSlot{N: s.N, Type: dummyTypes.Float64, Off: s.Off + 8}
+		return LocalSlot{N: s.N, Type: testTypes.Float64, Off: s.Off}, LocalSlot{N: s.N, Type: testTypes.Float64, Off: s.Off + 8}
 	}
-	return LocalSlot{N: s.N, Type: dummyTypes.Float32, Off: s.Off}, LocalSlot{N: s.N, Type: dummyTypes.Float32, Off: s.Off + 4}
+	return LocalSlot{N: s.N, Type: testTypes.Float32, Off: s.Off}, LocalSlot{N: s.N, Type: testTypes.Float32, Off: s.Off + 4}
 }
-func (d DummyFrontend) SplitInt64(s LocalSlot) (LocalSlot, LocalSlot) {
+func (d TestFrontend) SplitInt64(s LocalSlot) (LocalSlot, LocalSlot) {
 	if s.Type.IsSigned() {
-		return LocalSlot{N: s.N, Type: dummyTypes.Int32, Off: s.Off + 4}, LocalSlot{N: s.N, Type: dummyTypes.UInt32, Off: s.Off}
+		return LocalSlot{N: s.N, Type: testTypes.Int32, Off: s.Off + 4}, LocalSlot{N: s.N, Type: testTypes.UInt32, Off: s.Off}
 	}
-	return LocalSlot{N: s.N, Type: dummyTypes.UInt32, Off: s.Off + 4}, LocalSlot{N: s.N, Type: dummyTypes.UInt32, Off: s.Off}
+	return LocalSlot{N: s.N, Type: testTypes.UInt32, Off: s.Off + 4}, LocalSlot{N: s.N, Type: testTypes.UInt32, Off: s.Off}
 }
-func (d DummyFrontend) SplitStruct(s LocalSlot, i int) LocalSlot {
+func (d TestFrontend) SplitStruct(s LocalSlot, i int) LocalSlot {
 	return LocalSlot{N: s.N, Type: s.Type.FieldType(i), Off: s.Off + s.Type.FieldOff(i)}
 }
-func (d DummyFrontend) SplitArray(s LocalSlot) LocalSlot {
+func (d TestFrontend) SplitArray(s LocalSlot) LocalSlot {
 	return LocalSlot{N: s.N, Type: s.Type.Elem(), Off: s.Off}
 }
 
-func (d DummyFrontend) SplitSlot(parent *LocalSlot, suffix string, offset int64, t *types.Type) LocalSlot {
+func (d TestFrontend) SplitSlot(parent *LocalSlot, suffix string, offset int64, t *types.Type) LocalSlot {
 	return LocalSlot{N: parent.N, Type: t, Off: offset}
 }
-func (DummyFrontend) Line(_ src.XPos) string {
+func (TestFrontend) Line(_ src.XPos) string {
 	return "unknown.go:0"
 }
-func (DummyFrontend) AllocFrame(f *Func) {
+func (TestFrontend) AllocFrame(f *Func) {
 }
-func (d DummyFrontend) Syslook(s string) *obj.LSym {
+func (d TestFrontend) Syslook(s string) *obj.LSym {
 	return d.ctxt.Lookup(s)
 }
-func (DummyFrontend) UseWriteBarrier() bool {
+func (TestFrontend) UseWriteBarrier() bool {
 	return true // only writebarrier_test cares
 }
-func (DummyFrontend) SetWBPos(pos src.XPos) {
+func (TestFrontend) SetWBPos(pos src.XPos) {
 }
 
-func (d DummyFrontend) Logf(msg string, args ...interface{}) { d.t.Logf(msg, args...) }
-func (d DummyFrontend) Log() bool                            { return true }
+func (d TestFrontend) Logf(msg string, args ...interface{}) { d.t.Logf(msg, args...) }
+func (d TestFrontend) Log() bool                            { return true }
 
-func (d DummyFrontend) Fatalf(_ src.XPos, msg string, args ...interface{}) { d.t.Fatalf(msg, args...) }
-func (d DummyFrontend) Warnl(_ src.XPos, msg string, args ...interface{})  { d.t.Logf(msg, args...) }
-func (d DummyFrontend) Debug_checknil() bool                               { return false }
+func (d TestFrontend) Fatalf(_ src.XPos, msg string, args ...interface{}) { d.t.Fatalf(msg, args...) }
+func (d TestFrontend) Warnl(_ src.XPos, msg string, args ...interface{})  { d.t.Logf(msg, args...) }
+func (d TestFrontend) Debug_checknil() bool                               { return false }
 
-func (d DummyFrontend) MyImportPath() string {
+func (d TestFrontend) MyImportPath() string {
 	return "my/import/path"
 }
 
-var dummyTypes Types
+var testTypes Types
 
 func init() {
 	// Initialize just enough of the universe and the types package to make our tests function.
@@ -198,12 +198,12 @@ func init() {
 		t.Align = uint8(typ.width)
 		types.Types[typ.et] = t
 	}
-	dummyTypes.SetTypPtrs()
+	testTypes.SetTypPtrs()
 }
 
-func (d DummyFrontend) DerefItab(sym *obj.LSym, off int64) *obj.LSym { return nil }
+func (d TestFrontend) DerefItab(sym *obj.LSym, off int64) *obj.LSym { return nil }
 
-func (d DummyFrontend) CanSSA(t *types.Type) bool {
-	// There are no un-SSAable types in dummy land.
+func (d TestFrontend) CanSSA(t *types.Type) bool {
+	// There are no un-SSAable types in test land.
 	return true
 }
diff --git a/src/cmd/compile/internal/ssa/poset.go b/src/cmd/compile/internal/ssa/poset.go
index f5a2b3a8c2..1e04b48ba4 100644
--- a/src/cmd/compile/internal/ssa/poset.go
+++ b/src/cmd/compile/internal/ssa/poset.go
@@ -136,13 +136,13 @@ type posetNode struct {
 // Most internal data structures are pre-allocated and flat, so for instance adding a
 // new relation does not cause any allocation. For performance reasons,
 // each node has only up to two outgoing edges (like a binary tree), so intermediate
-// "dummy" nodes are required to represent more than two relations. For instance,
+// "extra" nodes are required to represent more than two relations. For instance,
 // to record that A<I, A<J, A<K (with no known relation between I,J,K), we create the
 // following DAG:
 //
 //         A
 //        / \
-//       I  dummy
+//       I  extra
 //           /  \
 //          J    K
 //
@@ -223,7 +223,7 @@ func (po *poset) addchild(i1, i2 uint32, strict bool) {
 		po.setchr(i1, e2)
 		po.upush(undoSetChr, i1, 0)
 	} else {
-		// If n1 already has two children, add an intermediate dummy
+		// If n1 already has two children, add an intermediate extra
 		// node to record the relation correctly (without relating
 		// n2 to other existing nodes). Use a non-deterministic value
 		// to decide whether to append on the left or the right, to avoid
@@ -231,27 +231,27 @@ func (po *poset) addchild(i1, i2 uint32, strict bool) {
 		//
 		//      n1
 		//     /  \
-		//   i1l  dummy
+		//   i1l  extra
 		//        /   \
 		//      i1r   n2
 		//
-		dummy := po.newnode(nil)
+		extra := po.newnode(nil)
 		if (i1^i2)&1 != 0 { // non-deterministic
-			po.setchl(dummy, i1r)
-			po.setchr(dummy, e2)
-			po.setchr(i1, newedge(dummy, false))
+			po.setchl(extra, i1r)
+			po.setchr(extra, e2)
+			po.setchr(i1, newedge(extra, false))
 			po.upush(undoSetChr, i1, i1r)
 		} else {
-			po.setchl(dummy, i1l)
-			po.setchr(dummy, e2)
-			po.setchl(i1, newedge(dummy, false))
+			po.setchl(extra, i1l)
+			po.setchr(extra, e2)
+			po.setchl(i1, newedge(extra, false))
 			po.upush(undoSetChl, i1, i1l)
 		}
 	}
 }
 
 // newnode allocates a new node bound to SSA value n.
-// If n is nil, this is a dummy node (= only used internally).
+// If n is nil, this is an extra node (= only used internally).
 func (po *poset) newnode(n *Value) uint32 {
 	i := po.lastidx + 1
 	po.lastidx++
@@ -380,9 +380,9 @@ func (po *poset) newconst(n *Value) {
 
 	case higherptr != 0:
 		// Higher bound only. To record n < higher, we need
-		// a dummy root:
+		// an extra root:
 		//
-		//        dummy
+		//        extra
 		//        /   \
 		//      root   \
 		//       /      n
@@ -395,11 +395,11 @@ func (po *poset) newconst(n *Value) {
 		if r2 != po.roots[0] { // all constants should be in root #0
 			panic("constant not in root #0")
 		}
-		dummy := po.newnode(nil)
-		po.changeroot(r2, dummy)
-		po.upush(undoChangeRoot, dummy, newedge(r2, false))
-		po.addchild(dummy, r2, false)
-		po.addchild(dummy, i, false)
+		extra := po.newnode(nil)
+		po.changeroot(r2, extra)
+		po.upush(undoChangeRoot, extra, newedge(r2, false))
+		po.addchild(extra, r2, false)
+		po.addchild(extra, i, false)
 		po.addchild(i, i2, true)
 	}
 
@@ -612,7 +612,7 @@ func (po *poset) findroot(i uint32) uint32 {
 	panic("findroot didn't find any root")
 }
 
-// mergeroot merges two DAGs into one DAG by creating a new dummy root
+// mergeroot merges two DAGs into one DAG by creating a new extra root
 func (po *poset) mergeroot(r1, r2 uint32) uint32 {
 	// Root #0 is special as it contains all constants. Since mergeroot
 	// discards r2 as root and keeps r1, make sure that r2 is not root #0,
@@ -1004,7 +1004,7 @@ func (po *poset) setOrder(n1, n2 *Value, strict bool) bool {
 	case !f1 && f2:
 		// n1 is not in any DAG but n2 is. If n2 is a root, we can put
 		// n1 in its place as a root; otherwise, we need to create a new
-		// dummy root to record the relation.
+		// extra root to record the relation.
 		i1 = po.newnode(n1)
 
 		if po.isroot(i2) {
@@ -1020,17 +1020,17 @@ func (po *poset) setOrder(n1, n2 *Value, strict bool) bool {
 
 		// Re-parent as follows:
 		//
-		//                  dummy
+		//                  extra
 		//     r            /   \
 		//      \   ===>   r    i1
 		//      i2          \   /
 		//                    i2
 		//
-		dummy := po.newnode(nil)
-		po.changeroot(r, dummy)
-		po.upush(undoChangeRoot, dummy, newedge(r, false))
-		po.addchild(dummy, r, false)
-		po.addchild(dummy, i1, false)
+		extra := po.newnode(nil)
+		po.changeroot(r, extra)
+		po.upush(undoChangeRoot, extra, newedge(r, false))
+		po.addchild(extra, r, false)
+		po.addchild(extra, i1, false)
 		po.addchild(i1, i2, strict)
 
 	case f1 && f2:
diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go
index 0339b073ae..4ed884c3e7 100644
--- a/src/cmd/compile/internal/ssa/regalloc.go
+++ b/src/cmd/compile/internal/ssa/regalloc.go
@@ -104,7 +104,7 @@
 // If b3 is the primary predecessor of b2, then we use x3 in b2 and
 // add a x4:CX->BX copy at the end of b4.
 // But the definition of x3 doesn't dominate b2.  We should really
-// insert a dummy phi at the start of b2 (x5=phi(x3,x4):BX) to keep
+// insert an extra phi at the start of b2 (x5=phi(x3,x4):BX) to keep
 // SSA form. For now, we ignore this problem as remaining in strict
 // SSA form isn't needed after regalloc. We'll just leave the use
 // of x3 not dominated by the definition of x3, and the CX->BX copy
diff --git a/src/cmd/compile/internal/syntax/dumper_test.go b/src/cmd/compile/internal/syntax/dumper_test.go
index f84bd2d705..22680dce78 100644
--- a/src/cmd/compile/internal/syntax/dumper_test.go
+++ b/src/cmd/compile/internal/syntax/dumper_test.go
@@ -13,7 +13,7 @@ func TestDump(t *testing.T) {
 		t.Skip("skipping test in short mode")
 	}
 
-	// provide a dummy error handler so parsing doesn't stop after first error
+	// provide a no-op error handler so parsing doesn't stop after first error
 	ast, err := ParseFile(*src_, func(error) {}, nil, CheckBranches)
 	if err != nil {
 		t.Error(err)
diff --git a/src/cmd/compile/internal/syntax/nodes.go b/src/cmd/compile/internal/syntax/nodes.go
index 815630fcd4..487cab19fe 100644
--- a/src/cmd/compile/internal/syntax/nodes.go
+++ b/src/cmd/compile/internal/syntax/nodes.go
@@ -114,7 +114,7 @@ func (*decl) aDecl() {}
 
 // All declarations belonging to the same group point to the same Group node.
 type Group struct {
-	dummy int // not empty so we are guaranteed different Group instances
+	_ int // not empty so we are guaranteed different Group instances
 }
 
 // ----------------------------------------------------------------------------
diff --git a/src/cmd/compile/internal/syntax/printer_test.go b/src/cmd/compile/internal/syntax/printer_test.go
index c3b9aca229..fe72e7a374 100644
--- a/src/cmd/compile/internal/syntax/printer_test.go
+++ b/src/cmd/compile/internal/syntax/printer_test.go
@@ -18,7 +18,7 @@ func TestPrint(t *testing.T) {
 		t.Skip("skipping test in short mode")
 	}
 
-	// provide a dummy error handler so parsing doesn't stop after first error
+	// provide a no-op error handler so parsing doesn't stop after first error
 	ast, err := ParseFile(*src_, func(error) {}, nil, 0)
 	if err != nil {
 		t.Error(err)
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index f1a01b64da..b93409aac1 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -10,7 +10,7 @@ import (
 	"fmt"
 )
 
-// Dummy Node so we can refer to *Node without actually
+// Our own “Node” so we can refer to *gc.Node without actually
 // having a gc.Node. Necessary to break import cycles.
 // TODO(gri) try to eliminate soon
 type Node struct{ _ int }
-- 
GitLab


From 9262909764ea63285805c87f8d41837a532fda62 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 22 Nov 2020 12:09:08 -0500
Subject: [PATCH 0059/2400] [dev.regabi] cmd/compile: rewrite problematic use
 of Node fields

For the upcoming rewrite to access methods, a few direct accesses
are problematic for the automated tool, most notably direct copies
or use of Node structs as opposed to pointers.

Fix these manually.

Passes toolstash -cmp.

Change-Id: I8bdbb33216737c09e1edda284d5c414422d86284
Reviewed-on: https://go-review.googlesource.com/c/go/+/273006
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/esc.go       |   4 +-
 src/cmd/compile/internal/gc/escape.go    |  10 +-
 src/cmd/compile/internal/gc/iimport.go   |  10 +-
 src/cmd/compile/internal/gc/sinit.go     |  40 ++--
 src/cmd/compile/internal/gc/ssa.go       | 224 +++++++++++------------
 src/cmd/compile/internal/gc/typecheck.go |  18 +-
 6 files changed, 156 insertions(+), 150 deletions(-)

diff --git a/src/cmd/compile/internal/gc/esc.go b/src/cmd/compile/internal/gc/esc.go
index c4159101f2..6003f6608c 100644
--- a/src/cmd/compile/internal/gc/esc.go
+++ b/src/cmd/compile/internal/gc/esc.go
@@ -53,8 +53,8 @@ func funcSym(fn *Node) *types.Sym {
 // Walk hasn't generated (goto|label).Left.Sym.Label yet, so we'll cheat
 // and set it to one of the following two. Then in esc we'll clear it again.
 var (
-	looping    Node
-	nonlooping Node
+	looping    = nod(OXXX, nil, nil)
+	nonlooping = nod(OXXX, nil, nil)
 )
 
 func isSliceSelfAssign(dst, src *Node) bool {
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 50674e1a1a..b6975c79a4 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -227,13 +227,13 @@ func (e *Escape) walkFunc(fn *Node) {
 	inspectList(fn.Nbody, func(n *Node) bool {
 		switch n.Op {
 		case OLABEL:
-			n.Sym.Label = asTypesNode(&nonlooping)
+			n.Sym.Label = asTypesNode(nonlooping)
 
 		case OGOTO:
 			// If we visited the label before the goto,
 			// then this is a looping label.
-			if n.Sym.Label == asTypesNode(&nonlooping) {
-				n.Sym.Label = asTypesNode(&looping)
+			if n.Sym.Label == asTypesNode(nonlooping) {
+				n.Sym.Label = asTypesNode(looping)
 			}
 		}
 
@@ -309,11 +309,11 @@ func (e *Escape) stmt(n *Node) {
 
 	case OLABEL:
 		switch asNode(n.Sym.Label) {
-		case &nonlooping:
+		case nonlooping:
 			if Debug.m > 2 {
 				fmt.Printf("%v:%v non-looping label\n", linestr(lineno), n)
 			}
-		case &looping:
+		case looping:
 			if Debug.m > 2 {
 				fmt.Printf("%v: %v looping label\n", linestr(lineno), n)
 			}
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 3f50a94061..352335a993 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -839,7 +839,8 @@ func (r *importReader) node() *Node {
 		if s := r.ident(); s != nil {
 			n.Left = npos(n.Pos, newnoname(s))
 		}
-		n.Right, _ = r.exprsOrNil()
+		right, _ := r.exprsOrNil()
+		n.Right = right
 		return n
 
 	// case OTARRAY, OTMAP, OTCHAN, OTSTRUCT, OTINTER, OTFUNC:
@@ -1021,7 +1022,9 @@ func (r *importReader) node() *Node {
 	case OFOR:
 		n := nodl(r.pos(), OFOR, nil, nil)
 		n.Ninit.Set(r.stmtList())
-		n.Left, n.Right = r.exprsOrNil()
+		left, right := r.exprsOrNil()
+		n.Left = left
+		n.Right = right
 		n.Nbody.Set(r.stmtList())
 		return n
 
@@ -1035,7 +1038,8 @@ func (r *importReader) node() *Node {
 	case OSELECT, OSWITCH:
 		n := nodl(r.pos(), op, nil, nil)
 		n.Ninit.Set(r.stmtList())
-		n.Left, _ = r.exprsOrNil()
+		left, _ := r.exprsOrNil()
+		n.Left = left
 		n.List.Set(r.caseList(n))
 		return n
 
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 6da3c5e10b..e15d558a78 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -186,9 +186,8 @@ func (s *InitSchedule) staticassign(l *Node, r *Node) bool {
 		return true
 
 	case OADDR:
-		var nam Node
-		if stataddr(&nam, r.Left) {
-			addrsym(l, &nam)
+		if nam := stataddr(r.Left); nam != nil {
+			addrsym(l, nam)
 			return true
 		}
 		fallthrough
@@ -609,11 +608,11 @@ func slicelit(ctxt initContext, n *Node, var_ *Node, init *Nodes) {
 
 		// copy static to slice
 		var_ = typecheck(var_, ctxExpr|ctxAssign)
-		var nam Node
-		if !stataddr(&nam, var_) || nam.Class() != PEXTERN {
+		nam := stataddr(var_)
+		if nam == nil || nam.Class() != PEXTERN {
 			Fatalf("slicelit: %v", var_)
 		}
-		slicesym(&nam, vstat, t.NumElem())
+		slicesym(nam, vstat, t.NumElem())
 		return
 	}
 
@@ -1001,30 +1000,31 @@ func getlit(lit *Node) int {
 	return -1
 }
 
-// stataddr sets nam to the static address of n and reports whether it succeeded.
-func stataddr(nam *Node, n *Node) bool {
+// stataddr returns the static address of n, if n has one, or else nil.
+func stataddr(n *Node) *Node {
 	if n == nil {
-		return false
+		return nil
 	}
 
 	switch n.Op {
 	case ONAME, OMETHEXPR:
-		*nam = *n
-		return true
+		return n.sepcopy()
 
 	case ODOT:
-		if !stataddr(nam, n.Left) {
+		nam := stataddr(n.Left)
+		if nam == nil {
 			break
 		}
 		nam.Xoffset += n.Xoffset
 		nam.Type = n.Type
-		return true
+		return nam
 
 	case OINDEX:
 		if n.Left.Type.IsSlice() {
 			break
 		}
-		if !stataddr(nam, n.Left) {
+		nam := stataddr(n.Left)
+		if nam == nil {
 			break
 		}
 		l := getlit(n.Right)
@@ -1038,10 +1038,10 @@ func stataddr(nam *Node, n *Node) bool {
 		}
 		nam.Xoffset += int64(l) * n.Type.Width
 		nam.Type = n.Type
-		return true
+		return nam
 	}
 
-	return false
+	return nil
 }
 
 func (s *InitSchedule) initplan(n *Node) {
@@ -1158,16 +1158,16 @@ func genAsStatic(as *Node) {
 		Fatalf("genAsStatic as.Left not typechecked")
 	}
 
-	var nam Node
-	if !stataddr(&nam, as.Left) || (nam.Class() != PEXTERN && as.Left != nblank) {
+	nam := stataddr(as.Left)
+	if nam == nil || (nam.Class() != PEXTERN && as.Left != nblank) {
 		Fatalf("genAsStatic: lhs %v", as.Left)
 	}
 
 	switch {
 	case as.Right.Op == OLITERAL:
-		litsym(&nam, as.Right, int(as.Right.Type.Width))
+		litsym(nam, as.Right, int(as.Right.Type.Width))
 	case (as.Right.Op == ONAME || as.Right.Op == OMETHEXPR) && as.Right.Class() == PFUNC:
-		pfuncsym(&nam, as.Right)
+		pfuncsym(nam, as.Right)
 	default:
 		Fatalf("genAsStatic: rhs %v", as.Right)
 	}
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index f196bee4a2..f00f5d94a1 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -388,7 +388,7 @@ func buildssa(fn *Node, worker int) *ssa.Func {
 	s.sb = s.entryNewValue0(ssa.OpSB, types.Types[TUINTPTR])
 
 	s.startBlock(s.f.Entry)
-	s.vars[&memVar] = s.startmem
+	s.vars[memVar] = s.startmem
 	if s.hasOpenDefers {
 		// Create the deferBits variable and stack slot.  deferBits is a
 		// bitmask showing which of the open-coded defers in this function
@@ -397,7 +397,7 @@ func buildssa(fn *Node, worker int) *ssa.Func {
 		s.deferBitsTemp = deferBitsTemp
 		// For this value, AuxInt is initialized to zero by default
 		startDeferBits := s.entryNewValue0(ssa.OpConst8, types.Types[TUINT8])
-		s.vars[&deferBitsVar] = startDeferBits
+		s.vars[deferBitsVar] = startDeferBits
 		s.deferBitsAddr = s.addr(deferBitsTemp)
 		s.store(types.Types[TUINT8], s.deferBitsAddr, startDeferBits)
 		// Make sure that the deferBits stack slot is kept alive (for use
@@ -405,7 +405,7 @@ func buildssa(fn *Node, worker int) *ssa.Func {
 		// all checking code on deferBits in the function exit can be
 		// eliminated, because the defer statements were all
 		// unconditional.
-		s.vars[&memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, deferBitsTemp, s.mem(), false)
+		s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, deferBitsTemp, s.mem(), false)
 	}
 
 	// Generate addresses of local declarations
@@ -691,18 +691,22 @@ func (s *state) Fatalf(msg string, args ...interface{}) {
 func (s *state) Warnl(pos src.XPos, msg string, args ...interface{}) { s.f.Warnl(pos, msg, args...) }
 func (s *state) Debug_checknil() bool                                { return s.f.Frontend().Debug_checknil() }
 
+func ssaMarker(name string) *Node {
+	return newname(&types.Sym{Name: name})
+}
+
 var (
 	// marker node for the memory variable
-	memVar = Node{Op: ONAME, Sym: &types.Sym{Name: "mem"}}
+	memVar = ssaMarker("mem")
 
 	// marker nodes for temporary variables
-	ptrVar       = Node{Op: ONAME, Sym: &types.Sym{Name: "ptr"}}
-	lenVar       = Node{Op: ONAME, Sym: &types.Sym{Name: "len"}}
-	newlenVar    = Node{Op: ONAME, Sym: &types.Sym{Name: "newlen"}}
-	capVar       = Node{Op: ONAME, Sym: &types.Sym{Name: "cap"}}
-	typVar       = Node{Op: ONAME, Sym: &types.Sym{Name: "typ"}}
-	okVar        = Node{Op: ONAME, Sym: &types.Sym{Name: "ok"}}
-	deferBitsVar = Node{Op: ONAME, Sym: &types.Sym{Name: "deferBits"}}
+	ptrVar       = ssaMarker("ptr")
+	lenVar       = ssaMarker("len")
+	newlenVar    = ssaMarker("newlen")
+	capVar       = ssaMarker("cap")
+	typVar       = ssaMarker("typ")
+	okVar        = ssaMarker("ok")
+	deferBitsVar = ssaMarker("deferBits")
 )
 
 // startBlock sets the current block we're generating code in to b.
@@ -1027,14 +1031,14 @@ func (s *state) rawLoad(t *types.Type, src *ssa.Value) *ssa.Value {
 }
 
 func (s *state) store(t *types.Type, dst, val *ssa.Value) {
-	s.vars[&memVar] = s.newValue3A(ssa.OpStore, types.TypeMem, t, dst, val, s.mem())
+	s.vars[memVar] = s.newValue3A(ssa.OpStore, types.TypeMem, t, dst, val, s.mem())
 }
 
 func (s *state) zero(t *types.Type, dst *ssa.Value) {
 	s.instrument(t, dst, true)
 	store := s.newValue2I(ssa.OpZero, types.TypeMem, t.Size(), dst, s.mem())
 	store.Aux = t
-	s.vars[&memVar] = store
+	s.vars[memVar] = store
 }
 
 func (s *state) move(t *types.Type, dst, src *ssa.Value) {
@@ -1042,7 +1046,7 @@ func (s *state) move(t *types.Type, dst, src *ssa.Value) {
 	s.instrument(t, dst, true)
 	store := s.newValue3I(ssa.OpMove, types.TypeMem, t.Size(), dst, src, s.mem())
 	store.Aux = t
-	s.vars[&memVar] = store
+	s.vars[memVar] = store
 }
 
 // stmtList converts the statement list n to SSA and adds it to s.
@@ -1509,7 +1513,7 @@ func (s *state) stmt(n *Node) {
 
 	case OVARDEF:
 		if !s.canSSA(n.Left) {
-			s.vars[&memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, n.Left, s.mem(), false)
+			s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, n.Left, s.mem(), false)
 		}
 	case OVARKILL:
 		// Insert a varkill op to record that a variable is no longer live.
@@ -1517,7 +1521,7 @@ func (s *state) stmt(n *Node) {
 		// varkill in the store chain is enough to keep it correctly ordered
 		// with respect to call ops.
 		if !s.canSSA(n.Left) {
-			s.vars[&memVar] = s.newValue1Apos(ssa.OpVarKill, types.TypeMem, n.Left, s.mem(), false)
+			s.vars[memVar] = s.newValue1Apos(ssa.OpVarKill, types.TypeMem, n.Left, s.mem(), false)
 		}
 
 	case OVARLIVE:
@@ -1530,7 +1534,7 @@ func (s *state) stmt(n *Node) {
 		default:
 			s.Fatalf("VARLIVE variable %v must be Auto or Arg", n.Left)
 		}
-		s.vars[&memVar] = s.newValue1A(ssa.OpVarLive, types.TypeMem, n.Left, s.mem())
+		s.vars[memVar] = s.newValue1A(ssa.OpVarLive, types.TypeMem, n.Left, s.mem())
 
 	case OCHECKNIL:
 		p := s.expr(n.Left)
@@ -1576,7 +1580,7 @@ func (s *state) exit() *ssa.Block {
 	for _, n := range s.returns {
 		addr := s.decladdrs[n]
 		val := s.variable(n, n.Type)
-		s.vars[&memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
+		s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
 		s.store(n.Type, addr, val)
 		// TODO: if val is ever spilled, we'd like to use the
 		// PPARAMOUT slot for spilling it. That won't happen
@@ -2843,14 +2847,14 @@ func (s *state) append(n *Node, inplace bool) *ssa.Value {
 	c := s.newValue1(ssa.OpSliceCap, types.Types[TINT], slice)
 	nl := s.newValue2(s.ssaOp(OADD, types.Types[TINT]), types.Types[TINT], l, s.constInt(types.Types[TINT], nargs))
 
-	cmp := s.newValue2(s.ssaOp(OLT, types.Types[TUINT]), types.Types[TBOOL], c, nl)
-	s.vars[&ptrVar] = p
+	cmp := s.newValue2(s.ssaOp(OLT, types.Types[TUINT]), types.Types[types.TBOOL], c, nl)
+	s.vars[ptrVar] = p
 
 	if !inplace {
-		s.vars[&newlenVar] = nl
-		s.vars[&capVar] = c
+		s.vars[newlenVar] = nl
+		s.vars[capVar] = c
 	} else {
-		s.vars[&lenVar] = l
+		s.vars[lenVar] = l
 	}
 
 	b := s.endBlock()
@@ -2868,18 +2872,18 @@ func (s *state) append(n *Node, inplace bool) *ssa.Value {
 	if inplace {
 		if sn.Op == ONAME && sn.Class() != PEXTERN {
 			// Tell liveness we're about to build a new slice
-			s.vars[&memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, sn, s.mem())
+			s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, sn, s.mem())
 		}
 		capaddr := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.IntPtr, sliceCapOffset, addr)
 		s.store(types.Types[TINT], capaddr, r[2])
 		s.store(pt, addr, r[0])
 		// load the value we just stored to avoid having to spill it
-		s.vars[&ptrVar] = s.load(pt, addr)
-		s.vars[&lenVar] = r[1] // avoid a spill in the fast path
+		s.vars[ptrVar] = s.load(pt, addr)
+		s.vars[lenVar] = r[1] // avoid a spill in the fast path
 	} else {
-		s.vars[&ptrVar] = r[0]
-		s.vars[&newlenVar] = s.newValue2(s.ssaOp(OADD, types.Types[TINT]), types.Types[TINT], r[1], s.constInt(types.Types[TINT], nargs))
-		s.vars[&capVar] = r[2]
+		s.vars[ptrVar] = r[0]
+		s.vars[newlenVar] = s.newValue2(s.ssaOp(OADD, types.Types[TINT]), types.Types[TINT], r[1], s.constInt(types.Types[TINT], nargs))
+		s.vars[capVar] = r[2]
 	}
 
 	b = s.endBlock()
@@ -2889,7 +2893,7 @@ func (s *state) append(n *Node, inplace bool) *ssa.Value {
 	s.startBlock(assign)
 
 	if inplace {
-		l = s.variable(&lenVar, types.Types[TINT]) // generates phi for len
+		l = s.variable(lenVar, types.Types[TINT]) // generates phi for len
 		nl = s.newValue2(s.ssaOp(OADD, types.Types[TINT]), types.Types[TINT], l, s.constInt(types.Types[TINT], nargs))
 		lenaddr := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.IntPtr, sliceLenOffset, addr)
 		s.store(types.Types[TINT], lenaddr, nl)
@@ -2912,10 +2916,10 @@ func (s *state) append(n *Node, inplace bool) *ssa.Value {
 		}
 	}
 
-	p = s.variable(&ptrVar, pt) // generates phi for ptr
+	p = s.variable(ptrVar, pt) // generates phi for ptr
 	if !inplace {
-		nl = s.variable(&newlenVar, types.Types[TINT]) // generates phi for nl
-		c = s.variable(&capVar, types.Types[TINT])     // generates phi for cap
+		nl = s.variable(newlenVar, types.Types[TINT]) // generates phi for nl
+		c = s.variable(capVar, types.Types[TINT])     // generates phi for cap
 	}
 	p2 := s.newValue2(ssa.OpPtrIndex, pt, p, l)
 	for i, arg := range args {
@@ -2927,13 +2931,13 @@ func (s *state) append(n *Node, inplace bool) *ssa.Value {
 		}
 	}
 
-	delete(s.vars, &ptrVar)
+	delete(s.vars, ptrVar)
 	if inplace {
-		delete(s.vars, &lenVar)
+		delete(s.vars, lenVar)
 		return nil
 	}
-	delete(s.vars, &newlenVar)
-	delete(s.vars, &capVar)
+	delete(s.vars, newlenVar)
+	delete(s.vars, capVar)
 	// make result
 	return s.newValue3(ssa.OpSliceMake, n.Type, p, nl, c)
 }
@@ -3074,7 +3078,7 @@ func (s *state) assign(left *Node, right *ssa.Value, deref bool, skip skipMask)
 	// If this assignment clobbers an entire local variable, then emit
 	// OpVarDef so liveness analysis knows the variable is redefined.
 	if base := clobberBase(left); base.Op == ONAME && base.Class() != PEXTERN && skip == 0 {
-		s.vars[&memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, base, s.mem(), !base.IsAutoTmp())
+		s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, base, s.mem(), !base.IsAutoTmp())
 	}
 
 	// Left is not ssa-able. Compute its address.
@@ -3332,7 +3336,7 @@ func init() {
 	add("runtime", "KeepAlive",
 		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
 			data := s.newValue1(ssa.OpIData, s.f.Config.Types.BytePtr, args[0])
-			s.vars[&memVar] = s.newValue2(ssa.OpKeepAlive, types.TypeMem, data, s.mem())
+			s.vars[memVar] = s.newValue2(ssa.OpKeepAlive, types.TypeMem, data, s.mem())
 			return nil
 		},
 		all...)
@@ -3380,79 +3384,79 @@ func init() {
 	addF("runtime/internal/atomic", "Load",
 		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue2(ssa.OpAtomicLoad32, types.NewTuple(types.Types[TUINT32], types.TypeMem), args[0], s.mem())
-			s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[TUINT32], v)
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Load8",
 		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue2(ssa.OpAtomicLoad8, types.NewTuple(types.Types[TUINT8], types.TypeMem), args[0], s.mem())
-			s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[TUINT8], v)
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Load64",
 		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue2(ssa.OpAtomicLoad64, types.NewTuple(types.Types[TUINT64], types.TypeMem), args[0], s.mem())
-			s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[TUINT64], v)
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "LoadAcq",
 		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue2(ssa.OpAtomicLoadAcq32, types.NewTuple(types.Types[TUINT32], types.TypeMem), args[0], s.mem())
-			s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[TUINT32], v)
 		},
 		sys.PPC64, sys.S390X)
 	addF("runtime/internal/atomic", "LoadAcq64",
 		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue2(ssa.OpAtomicLoadAcq64, types.NewTuple(types.Types[TUINT64], types.TypeMem), args[0], s.mem())
-			s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[TUINT64], v)
 		},
 		sys.PPC64)
 	addF("runtime/internal/atomic", "Loadp",
 		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue2(ssa.OpAtomicLoadPtr, types.NewTuple(s.f.Config.Types.BytePtr, types.TypeMem), args[0], s.mem())
-			s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, s.f.Config.Types.BytePtr, v)
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 
 	addF("runtime/internal/atomic", "Store",
 		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			s.vars[&memVar] = s.newValue3(ssa.OpAtomicStore32, types.TypeMem, args[0], args[1], s.mem())
+			s.vars[memVar] = s.newValue3(ssa.OpAtomicStore32, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Store8",
 		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			s.vars[&memVar] = s.newValue3(ssa.OpAtomicStore8, types.TypeMem, args[0], args[1], s.mem())
+			s.vars[memVar] = s.newValue3(ssa.OpAtomicStore8, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Store64",
 		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			s.vars[&memVar] = s.newValue3(ssa.OpAtomicStore64, types.TypeMem, args[0], args[1], s.mem())
+			s.vars[memVar] = s.newValue3(ssa.OpAtomicStore64, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "StorepNoWB",
 		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			s.vars[&memVar] = s.newValue3(ssa.OpAtomicStorePtrNoWB, types.TypeMem, args[0], args[1], s.mem())
+			s.vars[memVar] = s.newValue3(ssa.OpAtomicStorePtrNoWB, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "StoreRel",
 		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			s.vars[&memVar] = s.newValue3(ssa.OpAtomicStoreRel32, types.TypeMem, args[0], args[1], s.mem())
+			s.vars[memVar] = s.newValue3(ssa.OpAtomicStoreRel32, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.PPC64, sys.S390X)
 	addF("runtime/internal/atomic", "StoreRel64",
 		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			s.vars[&memVar] = s.newValue3(ssa.OpAtomicStoreRel64, types.TypeMem, args[0], args[1], s.mem())
+			s.vars[memVar] = s.newValue3(ssa.OpAtomicStoreRel64, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.PPC64)
@@ -3460,14 +3464,14 @@ func init() {
 	addF("runtime/internal/atomic", "Xchg",
 		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue3(ssa.OpAtomicExchange32, types.NewTuple(types.Types[TUINT32], types.TypeMem), args[0], args[1], s.mem())
-			s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[TUINT32], v)
 		},
 		sys.AMD64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Xchg64",
 		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue3(ssa.OpAtomicExchange64, types.NewTuple(types.Types[TUINT64], types.TypeMem), args[0], args[1], s.mem())
-			s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[TUINT64], v)
 		},
 		sys.AMD64, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
@@ -3512,7 +3516,7 @@ func init() {
 
 	atomicXchgXaddEmitterARM64 := func(s *state, n *Node, args []*ssa.Value, op ssa.Op, typ types.EType) {
 		v := s.newValue3(op, types.NewTuple(types.Types[typ], types.TypeMem), args[0], args[1], s.mem())
-		s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+		s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 		s.vars[n] = s.newValue1(ssa.OpSelect0, types.Types[typ], v)
 	}
 	addF("runtime/internal/atomic", "Xchg",
@@ -3525,14 +3529,14 @@ func init() {
 	addF("runtime/internal/atomic", "Xadd",
 		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue3(ssa.OpAtomicAdd32, types.NewTuple(types.Types[TUINT32], types.TypeMem), args[0], args[1], s.mem())
-			s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[TUINT32], v)
 		},
 		sys.AMD64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Xadd64",
 		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue3(ssa.OpAtomicAdd64, types.NewTuple(types.Types[TUINT64], types.TypeMem), args[0], args[1], s.mem())
-			s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[TUINT64], v)
 		},
 		sys.AMD64, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
@@ -3546,29 +3550,29 @@ func init() {
 
 	addF("runtime/internal/atomic", "Cas",
 		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			v := s.newValue4(ssa.OpAtomicCompareAndSwap32, types.NewTuple(types.Types[TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
-			s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
-			return s.newValue1(ssa.OpSelect0, types.Types[TBOOL], v)
+			v := s.newValue4(ssa.OpAtomicCompareAndSwap32, types.NewTuple(types.Types[types.TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
+			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+			return s.newValue1(ssa.OpSelect0, types.Types[types.TBOOL], v)
 		},
 		sys.AMD64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Cas64",
 		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			v := s.newValue4(ssa.OpAtomicCompareAndSwap64, types.NewTuple(types.Types[TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
-			s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
-			return s.newValue1(ssa.OpSelect0, types.Types[TBOOL], v)
+			v := s.newValue4(ssa.OpAtomicCompareAndSwap64, types.NewTuple(types.Types[types.TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
+			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+			return s.newValue1(ssa.OpSelect0, types.Types[types.TBOOL], v)
 		},
 		sys.AMD64, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "CasRel",
 		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			v := s.newValue4(ssa.OpAtomicCompareAndSwap32, types.NewTuple(types.Types[TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
-			s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
-			return s.newValue1(ssa.OpSelect0, types.Types[TBOOL], v)
+			v := s.newValue4(ssa.OpAtomicCompareAndSwap32, types.NewTuple(types.Types[types.TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
+			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+			return s.newValue1(ssa.OpSelect0, types.Types[types.TBOOL], v)
 		},
 		sys.PPC64)
 
 	atomicCasEmitterARM64 := func(s *state, n *Node, args []*ssa.Value, op ssa.Op, typ types.EType) {
-		v := s.newValue4(op, types.NewTuple(types.Types[TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
-		s.vars[&memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
+		v := s.newValue4(op, types.NewTuple(types.Types[types.TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
+		s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 		s.vars[n] = s.newValue1(ssa.OpSelect0, types.Types[typ], v)
 	}
 
@@ -3581,31 +3585,31 @@ func init() {
 
 	addF("runtime/internal/atomic", "And8",
 		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			s.vars[&memVar] = s.newValue3(ssa.OpAtomicAnd8, types.TypeMem, args[0], args[1], s.mem())
+			s.vars[memVar] = s.newValue3(ssa.OpAtomicAnd8, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.MIPS, sys.PPC64, sys.S390X)
 	addF("runtime/internal/atomic", "And",
 		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			s.vars[&memVar] = s.newValue3(ssa.OpAtomicAnd32, types.TypeMem, args[0], args[1], s.mem())
+			s.vars[memVar] = s.newValue3(ssa.OpAtomicAnd32, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.MIPS, sys.PPC64, sys.S390X)
 	addF("runtime/internal/atomic", "Or8",
 		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			s.vars[&memVar] = s.newValue3(ssa.OpAtomicOr8, types.TypeMem, args[0], args[1], s.mem())
+			s.vars[memVar] = s.newValue3(ssa.OpAtomicOr8, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.PPC64, sys.S390X)
 	addF("runtime/internal/atomic", "Or",
 		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			s.vars[&memVar] = s.newValue3(ssa.OpAtomicOr32, types.TypeMem, args[0], args[1], s.mem())
+			s.vars[memVar] = s.newValue3(ssa.OpAtomicOr32, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.MIPS, sys.PPC64, sys.S390X)
 
 	atomicAndOrEmitterARM64 := func(s *state, n *Node, args []*ssa.Value, op ssa.Op, typ types.EType) {
-		s.vars[&memVar] = s.newValue3(op, types.TypeMem, args[0], args[1], s.mem())
+		s.vars[memVar] = s.newValue3(op, types.TypeMem, args[0], args[1], s.mem())
 	}
 
 	addF("runtime/internal/atomic", "And8",
@@ -4274,8 +4278,8 @@ func (s *state) openDeferRecord(n *Node) {
 	// Update deferBits only after evaluation and storage to stack of
 	// args/receiver/interface is successful.
 	bitvalue := s.constInt8(types.Types[TUINT8], 1<<uint(index))
-	newDeferBits := s.newValue2(ssa.OpOr8, types.Types[TUINT8], s.variable(&deferBitsVar, types.Types[TUINT8]), bitvalue)
-	s.vars[&deferBitsVar] = newDeferBits
+	newDeferBits := s.newValue2(ssa.OpOr8, types.Types[TUINT8], s.variable(deferBitsVar, types.Types[TUINT8]), bitvalue)
+	s.vars[deferBitsVar] = newDeferBits
 	s.store(types.Types[TUINT8], s.deferBitsAddr, newDeferBits)
 }
 
@@ -4304,15 +4308,15 @@ func (s *state) openDeferSave(n *Node, t *types.Type, val *ssa.Value) *ssa.Value
 		// declared in the entry block, so that it will be live for the
 		// defer exit code (which will actually access it only if the
 		// associated defer call has been activated).
-		s.defvars[s.f.Entry.ID][&memVar] = s.entryNewValue1A(ssa.OpVarDef, types.TypeMem, argTemp, s.defvars[s.f.Entry.ID][&memVar])
-		s.defvars[s.f.Entry.ID][&memVar] = s.entryNewValue1A(ssa.OpVarLive, types.TypeMem, argTemp, s.defvars[s.f.Entry.ID][&memVar])
-		addrArgTemp = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(argTemp.Type), argTemp, s.sp, s.defvars[s.f.Entry.ID][&memVar])
+		s.defvars[s.f.Entry.ID][memVar] = s.entryNewValue1A(ssa.OpVarDef, types.TypeMem, argTemp, s.defvars[s.f.Entry.ID][memVar])
+		s.defvars[s.f.Entry.ID][memVar] = s.entryNewValue1A(ssa.OpVarLive, types.TypeMem, argTemp, s.defvars[s.f.Entry.ID][memVar])
+		addrArgTemp = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(argTemp.Type), argTemp, s.sp, s.defvars[s.f.Entry.ID][memVar])
 	} else {
 		// Special case if we're still in the entry block. We can't use
 		// the above code, since s.defvars[s.f.Entry.ID] isn't defined
 		// until we end the entry block with s.endBlock().
-		s.vars[&memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, argTemp, s.mem(), false)
-		s.vars[&memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, argTemp, s.mem(), false)
+		s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, argTemp, s.mem(), false)
+		s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, argTemp, s.mem(), false)
 		addrArgTemp = s.newValue2Apos(ssa.OpLocalAddr, types.NewPtr(argTemp.Type), argTemp, s.sp, s.mem(), false)
 	}
 	if t.HasPointers() {
@@ -4352,7 +4356,7 @@ func (s *state) openDeferExit() {
 		bCond := s.f.NewBlock(ssa.BlockPlain)
 		bEnd := s.f.NewBlock(ssa.BlockPlain)
 
-		deferBits := s.variable(&deferBitsVar, types.Types[TUINT8])
+		deferBits := s.variable(deferBitsVar, types.Types[TUINT8])
 		// Generate code to check if the bit associated with the current
 		// defer is set.
 		bitval := s.constInt8(types.Types[TUINT8], 1<<uint(i))
@@ -4373,7 +4377,7 @@ func (s *state) openDeferExit() {
 		s.store(types.Types[TUINT8], s.deferBitsAddr, maskedval)
 		// Use this value for following tests, so we keep previous
 		// bits cleared.
-		s.vars[&deferBitsVar] = maskedval
+		s.vars[deferBitsVar] = maskedval
 
 		// Generate code to call the function call of the defer, using the
 		// closure/receiver/args that were stored in argtmps at the point
@@ -4443,25 +4447,25 @@ func (s *state) openDeferExit() {
 		}
 		call.AuxInt = stksize
 		if testLateExpansion {
-			s.vars[&memVar] = s.newValue1I(ssa.OpSelectN, types.TypeMem, int64(len(ACResults)), call)
+			s.vars[memVar] = s.newValue1I(ssa.OpSelectN, types.TypeMem, int64(len(ACResults)), call)
 		} else {
-			s.vars[&memVar] = call
+			s.vars[memVar] = call
 		}
 		// Make sure that the stack slots with pointers are kept live
 		// through the call (which is a pre-emption point). Also, we will
 		// use the first call of the last defer exit to compute liveness
 		// for the deferreturn, so we want all stack slots to be live.
 		if r.closureNode != nil {
-			s.vars[&memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, r.closureNode, s.mem(), false)
+			s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, r.closureNode, s.mem(), false)
 		}
 		if r.rcvrNode != nil {
 			if r.rcvrNode.Type.HasPointers() {
-				s.vars[&memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, r.rcvrNode, s.mem(), false)
+				s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, r.rcvrNode, s.mem(), false)
 			}
 		}
 		for _, argNode := range r.argNodes {
 			if argNode.Type.HasPointers() {
-				s.vars[&memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, argNode, s.mem(), false)
+				s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, argNode, s.mem(), false)
 			}
 		}
 
@@ -4554,7 +4558,7 @@ func (s *state) call(n *Node, k callKind, returnResultAddr bool) *ssa.Value {
 		t := deferstruct(stksize)
 		d := tempAt(n.Pos, s.curfn, t)
 
-		s.vars[&memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, d, s.mem())
+		s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, d, s.mem())
 		addr := s.addr(d)
 
 		// Must match reflect.go:deferstruct and src/runtime/runtime2.go:_defer.
@@ -4729,9 +4733,9 @@ func (s *state) call(n *Node, k callKind, returnResultAddr bool) *ssa.Value {
 	}
 	if testLateExpansion {
 		s.prevCall = call
-		s.vars[&memVar] = s.newValue1I(ssa.OpSelectN, types.TypeMem, int64(len(ACResults)), call)
+		s.vars[memVar] = s.newValue1I(ssa.OpSelectN, types.TypeMem, int64(len(ACResults)), call)
 	} else {
-		s.vars[&memVar] = call
+		s.vars[memVar] = call
 	}
 	// Insert OVARLIVE nodes
 	s.stmtList(n.Nbody)
@@ -5204,10 +5208,10 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
 		callArgs = append(callArgs, s.mem())
 		call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 		call.AddArgs(callArgs...)
-		s.vars[&memVar] = s.newValue1I(ssa.OpSelectN, types.TypeMem, int64(len(ACResults)), call)
+		s.vars[memVar] = s.newValue1I(ssa.OpSelectN, types.TypeMem, int64(len(ACResults)), call)
 	} else {
 		call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, aux, s.mem())
-		s.vars[&memVar] = call
+		s.vars[memVar] = call
 	}
 
 	if !returns {
@@ -5257,7 +5261,7 @@ func (s *state) storeType(t *types.Type, left, right *ssa.Value, skip skipMask,
 
 	if skip == 0 && (!t.HasPointers() || ssa.IsStackAddr(left)) {
 		// Known to not have write barrier. Store the whole type.
-		s.vars[&memVar] = s.newValue3Apos(ssa.OpStore, types.TypeMem, t, left, right, s.mem(), leftIsStmt)
+		s.vars[memVar] = s.newValue3Apos(ssa.OpStore, types.TypeMem, t, left, right, s.mem(), leftIsStmt)
 		return
 	}
 
@@ -5880,12 +5884,12 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
 			// nonempty -> empty
 			// Need to load type from itab
 			off := s.newValue1I(ssa.OpOffPtr, byteptr, int64(Widthptr), itab)
-			s.vars[&typVar] = s.load(byteptr, off)
+			s.vars[typVar] = s.load(byteptr, off)
 			s.endBlock()
 
 			// itab is nil, might as well use that as the nil result.
 			s.startBlock(bFail)
-			s.vars[&typVar] = itab
+			s.vars[typVar] = itab
 			s.endBlock()
 
 			// Merge point.
@@ -5894,9 +5898,9 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
 			bFail.AddEdgeTo(bEnd)
 			s.startBlock(bEnd)
 			idata := s.newValue1(ssa.OpIData, n.Type, iface)
-			res = s.newValue2(ssa.OpIMake, n.Type, s.variable(&typVar, byteptr), idata)
+			res = s.newValue2(ssa.OpIMake, n.Type, s.variable(typVar, byteptr), idata)
 			resok = cond
-			delete(s.vars, &typVar)
+			delete(s.vars, typVar)
 			return
 		}
 		// converting to a nonempty interface needs a runtime call.
@@ -5942,7 +5946,7 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
 		// unSSAable type, use temporary.
 		// TODO: get rid of some of these temporaries.
 		tmp = tempAt(n.Pos, s.curfn, n.Type)
-		s.vars[&memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, tmp, s.mem())
+		s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, tmp, s.mem())
 		addr = s.addr(tmp)
 	}
 
@@ -5981,7 +5985,7 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
 	bEnd := s.f.NewBlock(ssa.BlockPlain)
 	// Note that we need a new valVar each time (unlike okVar where we can
 	// reuse the variable) because it might have a different type every time.
-	valVar := &Node{Op: ONAME, Sym: &types.Sym{Name: "val"}}
+	valVar := ssaMarker("val")
 
 	// type assertion succeeded
 	s.startBlock(bOk)
@@ -5996,7 +6000,7 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
 		p := s.newValue1(ssa.OpIData, types.NewPtr(n.Type), iface)
 		s.move(n.Type, addr, p)
 	}
-	s.vars[&okVar] = s.constBool(true)
+	s.vars[okVar] = s.constBool(true)
 	s.endBlock()
 	bOk.AddEdgeTo(bEnd)
 
@@ -6007,7 +6011,7 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
 	} else {
 		s.zero(n.Type, addr)
 	}
-	s.vars[&okVar] = s.constBool(false)
+	s.vars[okVar] = s.constBool(false)
 	s.endBlock()
 	bFail.AddEdgeTo(bEnd)
 
@@ -6018,10 +6022,10 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
 		delete(s.vars, valVar)
 	} else {
 		res = s.load(n.Type, addr)
-		s.vars[&memVar] = s.newValue1A(ssa.OpVarKill, types.TypeMem, tmp, s.mem())
+		s.vars[memVar] = s.newValue1A(ssa.OpVarKill, types.TypeMem, tmp, s.mem())
 	}
-	resok = s.variable(&okVar, types.Types[TBOOL])
-	delete(s.vars, &okVar)
+	resok = s.variable(okVar, types.Types[types.TBOOL])
+	delete(s.vars, okVar)
 	return res, resok
 }
 
@@ -6049,12 +6053,12 @@ func (s *state) variable(name *Node, t *types.Type) *ssa.Value {
 }
 
 func (s *state) mem() *ssa.Value {
-	return s.variable(&memVar, types.TypeMem)
+	return s.variable(memVar, types.TypeMem)
 }
 
 func (s *state) addNamedValue(n *Node, v *ssa.Value) {
 	if n.Class() == Pxxx {
-		// Don't track our marker nodes (&memVar etc.).
+		// Don't track our marker nodes (memVar etc.).
 		return
 	}
 	if n.IsAutoTmp() {
@@ -7064,17 +7068,9 @@ func (e *ssafn) SplitSlot(parent *ssa.LocalSlot, suffix string, offset int64, t
 	}
 
 	s := &types.Sym{Name: node.Sym.Name + suffix, Pkg: localpkg}
-
-	n := &Node{
-		Name: new(Name),
-		Op:   ONAME,
-		Pos:  parent.N.(*Node).Pos,
-	}
-	n.Orig = n
-
+	n := newnamel(parent.N.(*Node).Pos, s)
 	s.Def = asTypesNode(n)
 	asNode(s.Def).Name.SetUsed(true)
-	n.Sym = s
 	n.Type = t
 	n.SetClass(PAUTO)
 	n.Esc = EscNever
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 9cc1dee773..a4acdfaed3 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -1692,8 +1692,8 @@ func typecheck1(n *Node, top int) (res *Node) {
 			n.Type = nil
 			return n
 		}
-		var why string
-		n.Op, why = convertop(n.Left.Op == OLITERAL, t, n.Type)
+		op, why := convertop(n.Left.Op == OLITERAL, t, n.Type)
+		n.Op = op
 		if n.Op == OXXX {
 			if !n.Diag() && !n.Type.Broke() && !n.Left.Diag() {
 				yyerror("cannot convert %L to type %v%s", n.Left, n.Type, why)
@@ -3021,7 +3021,8 @@ func typecheckarraylit(elemType *types.Type, bound int64, elts []*Node, ctx stri
 	var key, length int64
 	for i, elt := range elts {
 		setlineno(elt)
-		vp := &elts[i]
+		r := elts[i]
+		var kv *Node
 		if elt.Op == OKEY {
 			elt.Left = typecheck(elt.Left, ctxExpr)
 			key = indexconst(elt.Left)
@@ -3036,13 +3037,18 @@ func typecheckarraylit(elemType *types.Type, bound int64, elts []*Node, ctx stri
 				}
 				key = -(1 << 30) // stay negative for a while
 			}
-			vp = &elt.Right
+			kv = elt
+			r = elt.Right
 		}
 
-		r := *vp
 		r = pushtype(r, elemType)
 		r = typecheck(r, ctxExpr)
-		*vp = assignconv(r, elemType, ctx)
+		r = assignconv(r, elemType, ctx)
+		if kv != nil {
+			kv.Right = r
+		} else {
+			elts[i] = r
+		}
 
 		if key >= 0 {
 			if indices != nil {
-- 
GitLab


From d166ef6876850571d08288c63315db2b47c851f5 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 17 Nov 2020 11:18:45 -0500
Subject: [PATCH 0060/2400] [dev.regabi] cmd/compile: add Node field getters
 and setters

The goal is to move Node to being an interface and then break
up the one big struct into many implementations.

Step 1 is to convert all current uses of Node to only use methods,
so that the existing algorithms keep working even as the underlying
implementations are adjusted.

Step 0 - this CL - is to add the getters and setters for Step 1.

Change-Id: I0570d8727c3ccb64113627bb9bebcb0dc39da07a
Reviewed-on: https://go-review.googlesource.com/c/go/+/273007
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/syntax.go | 35 +++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/src/cmd/compile/internal/gc/syntax.go b/src/cmd/compile/internal/gc/syntax.go
index 3b585ea341..65ae7f23d8 100644
--- a/src/cmd/compile/internal/gc/syntax.go
+++ b/src/cmd/compile/internal/gc/syntax.go
@@ -63,6 +63,41 @@ type Node struct {
 	aux uint8
 }
 
+func (n *Node) GetLeft() *Node        { return n.Left }
+func (n *Node) SetLeft(x *Node)       { n.Left = x }
+func (n *Node) GetRight() *Node       { return n.Right }
+func (n *Node) SetRight(x *Node)      { n.Right = x }
+func (n *Node) GetOrig() *Node        { return n.Orig }
+func (n *Node) SetOrig(x *Node)       { n.Orig = x }
+func (n *Node) GetType() *types.Type  { return n.Type }
+func (n *Node) SetType(x *types.Type) { n.Type = x }
+func (n *Node) GetFunc() *Func        { return n.Func }
+func (n *Node) SetFunc(x *Func)       { n.Func = x }
+func (n *Node) GetName() *Name        { return n.Name }
+func (n *Node) SetName(x *Name)       { n.Name = x }
+func (n *Node) GetSym() *types.Sym    { return n.Sym }
+func (n *Node) SetSym(x *types.Sym)   { n.Sym = x }
+func (n *Node) GetPos() src.XPos      { return n.Pos }
+func (n *Node) SetPos(x src.XPos)     { n.Pos = x }
+func (n *Node) GetXoffset() int64     { return n.Xoffset }
+func (n *Node) SetXoffset(x int64)    { n.Xoffset = x }
+func (n *Node) GetEsc() uint16        { return n.Esc }
+func (n *Node) SetEsc(x uint16)       { n.Esc = x }
+func (n *Node) GetOp() Op             { return n.Op }
+func (n *Node) SetOp(x Op)            { n.Op = x }
+func (n *Node) GetNinit() Nodes       { return n.Ninit }
+func (n *Node) SetNinit(x Nodes)      { n.Ninit = x }
+func (n *Node) PtrNinit() *Nodes      { return &n.Ninit }
+func (n *Node) GetNbody() Nodes       { return n.Nbody }
+func (n *Node) SetNbody(x Nodes)      { n.Nbody = x }
+func (n *Node) PtrNbody() *Nodes      { return &n.Nbody }
+func (n *Node) GetList() Nodes        { return n.List }
+func (n *Node) SetList(x Nodes)       { n.List = x }
+func (n *Node) PtrList() *Nodes       { return &n.List }
+func (n *Node) GetRlist() Nodes       { return n.Rlist }
+func (n *Node) SetRlist(x Nodes)      { n.Rlist = x }
+func (n *Node) PtrRlist() *Nodes      { return &n.Rlist }
+
 func (n *Node) ResetAux() {
 	n.aux = 0
 }
-- 
GitLab


From 6e583d65abd2b044997430984c43b80cad398cc1 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 24 Nov 2020 23:58:36 -0500
Subject: [PATCH 0061/2400] [dev.regabi] cmd/compile: simplify fmt handling of
 Nodes

The existing code introduces many types in what appears to be an
attempt to avoid allocation when converting formatting argument lists.
Simplify by accepting that allocation is going to happen, especially
when Node itself turns into an interface.

Change-Id: I3c0d45ca01eace4924deb43c0ea7dc6d65943d08
Reviewed-on: https://go-review.googlesource.com/c/go/+/272929
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/fmt.go | 187 ++++++++---------------------
 1 file changed, 51 insertions(+), 136 deletions(-)

diff --git a/src/cmd/compile/internal/gc/fmt.go b/src/cmd/compile/internal/gc/fmt.go
index f9888aec41..f995d2e2ec 100644
--- a/src/cmd/compile/internal/gc/fmt.go
+++ b/src/cmd/compile/internal/gc/fmt.go
@@ -238,72 +238,49 @@ func (o Op) oconv(s fmt.State, flag FmtFlag, mode fmtMode) {
 	fmt.Fprint(s, o.String())
 }
 
-type (
-	fmtMode int
-
-	fmtNodeErr        Node
-	fmtNodeDbg        Node
-	fmtNodeTypeId     Node
-	fmtNodeTypeIdName Node
-
-	fmtOpErr        Op
-	fmtOpDbg        Op
-	fmtOpTypeId     Op
-	fmtOpTypeIdName Op
-
-	fmtTypeErr        types.Type
-	fmtTypeDbg        types.Type
-	fmtTypeTypeId     types.Type
-	fmtTypeTypeIdName types.Type
-
-	fmtSymErr        types.Sym
-	fmtSymDbg        types.Sym
-	fmtSymTypeId     types.Sym
-	fmtSymTypeIdName types.Sym
-
-	fmtNodesErr        Nodes
-	fmtNodesDbg        Nodes
-	fmtNodesTypeId     Nodes
-	fmtNodesTypeIdName Nodes
-)
+type fmtMode int
 
-func (n *fmtNodeErr) Format(s fmt.State, verb rune)        { (*Node)(n).format(s, verb, FErr) }
-func (n *fmtNodeDbg) Format(s fmt.State, verb rune)        { (*Node)(n).format(s, verb, FDbg) }
-func (n *fmtNodeTypeId) Format(s fmt.State, verb rune)     { (*Node)(n).format(s, verb, FTypeId) }
-func (n *fmtNodeTypeIdName) Format(s fmt.State, verb rune) { (*Node)(n).format(s, verb, FTypeIdName) }
-func (n *Node) Format(s fmt.State, verb rune)              { n.format(s, verb, FErr) }
-
-func (o fmtOpErr) Format(s fmt.State, verb rune)        { Op(o).format(s, verb, FErr) }
-func (o fmtOpDbg) Format(s fmt.State, verb rune)        { Op(o).format(s, verb, FDbg) }
-func (o fmtOpTypeId) Format(s fmt.State, verb rune)     { Op(o).format(s, verb, FTypeId) }
-func (o fmtOpTypeIdName) Format(s fmt.State, verb rune) { Op(o).format(s, verb, FTypeIdName) }
-func (o Op) Format(s fmt.State, verb rune)              { o.format(s, verb, FErr) }
-
-func (t *fmtTypeErr) Format(s fmt.State, verb rune) { typeFormat((*types.Type)(t), s, verb, FErr) }
-func (t *fmtTypeDbg) Format(s fmt.State, verb rune) { typeFormat((*types.Type)(t), s, verb, FDbg) }
-func (t *fmtTypeTypeId) Format(s fmt.State, verb rune) {
-	typeFormat((*types.Type)(t), s, verb, FTypeId)
+type fmtNode struct {
+	x *Node
+	m fmtMode
 }
-func (t *fmtTypeTypeIdName) Format(s fmt.State, verb rune) {
-	typeFormat((*types.Type)(t), s, verb, FTypeIdName)
+
+func (f *fmtNode) Format(s fmt.State, verb rune) { f.x.format(s, verb, f.m) }
+
+type fmtOp struct {
+	x Op
+	m fmtMode
 }
 
-// func (t *types.Type) Format(s fmt.State, verb rune)     // in package types
+func (f *fmtOp) Format(s fmt.State, verb rune) { f.x.format(s, verb, f.m) }
 
-func (y *fmtSymErr) Format(s fmt.State, verb rune)    { symFormat((*types.Sym)(y), s, verb, FErr) }
-func (y *fmtSymDbg) Format(s fmt.State, verb rune)    { symFormat((*types.Sym)(y), s, verb, FDbg) }
-func (y *fmtSymTypeId) Format(s fmt.State, verb rune) { symFormat((*types.Sym)(y), s, verb, FTypeId) }
-func (y *fmtSymTypeIdName) Format(s fmt.State, verb rune) {
-	symFormat((*types.Sym)(y), s, verb, FTypeIdName)
+type fmtType struct {
+	x *types.Type
+	m fmtMode
 }
 
-// func (y *types.Sym) Format(s fmt.State, verb rune)            // in package types  { y.format(s, verb, FErr) }
+func (f *fmtType) Format(s fmt.State, verb rune) { typeFormat(f.x, s, verb, f.m) }
+
+type fmtSym struct {
+	x *types.Sym
+	m fmtMode
+}
 
-func (n fmtNodesErr) Format(s fmt.State, verb rune)        { (Nodes)(n).format(s, verb, FErr) }
-func (n fmtNodesDbg) Format(s fmt.State, verb rune)        { (Nodes)(n).format(s, verb, FDbg) }
-func (n fmtNodesTypeId) Format(s fmt.State, verb rune)     { (Nodes)(n).format(s, verb, FTypeId) }
-func (n fmtNodesTypeIdName) Format(s fmt.State, verb rune) { (Nodes)(n).format(s, verb, FTypeIdName) }
-func (n Nodes) Format(s fmt.State, verb rune)              { n.format(s, verb, FErr) }
+func (f *fmtSym) Format(s fmt.State, verb rune) { symFormat(f.x, s, verb, f.m) }
+
+type fmtNodes struct {
+	x Nodes
+	m fmtMode
+}
+
+func (f *fmtNodes) Format(s fmt.State, verb rune) { f.x.format(s, verb, f.m) }
+
+func (n *Node) Format(s fmt.State, verb rune) { n.format(s, verb, FErr) }
+func (o Op) Format(s fmt.State, verb rune)    { o.format(s, verb, FErr) }
+
+// func (t *types.Type) Format(s fmt.State, verb rune)     // in package types
+// func (y *types.Sym) Format(s fmt.State, verb rune)            // in package types  { y.format(s, verb, FErr) }
+func (n Nodes) Format(s fmt.State, verb rune) { n.format(s, verb, FErr) }
 
 func (m fmtMode) Fprintf(s fmt.State, format string, args ...interface{}) {
 	m.prepareArgs(args)
@@ -321,85 +298,23 @@ func (m fmtMode) Sprint(args ...interface{}) string {
 }
 
 func (m fmtMode) prepareArgs(args []interface{}) {
-	switch m {
-	case FErr:
-		for i, arg := range args {
-			switch arg := arg.(type) {
-			case Op:
-				args[i] = fmtOpErr(arg)
-			case *Node:
-				args[i] = (*fmtNodeErr)(arg)
-			case *types.Type:
-				args[i] = (*fmtTypeErr)(arg)
-			case *types.Sym:
-				args[i] = (*fmtSymErr)(arg)
-			case Nodes:
-				args[i] = fmtNodesErr(arg)
-			case int32, int64, string, types.EType, constant.Value:
-				// OK: printing these types doesn't depend on mode
-			default:
-				Fatalf("mode.prepareArgs type %T", arg)
-			}
-		}
-	case FDbg:
-		for i, arg := range args {
-			switch arg := arg.(type) {
-			case Op:
-				args[i] = fmtOpDbg(arg)
-			case *Node:
-				args[i] = (*fmtNodeDbg)(arg)
-			case *types.Type:
-				args[i] = (*fmtTypeDbg)(arg)
-			case *types.Sym:
-				args[i] = (*fmtSymDbg)(arg)
-			case Nodes:
-				args[i] = fmtNodesDbg(arg)
-			case int32, int64, string, types.EType, constant.Value:
-				// OK: printing these types doesn't depend on mode
-			default:
-				Fatalf("mode.prepareArgs type %T", arg)
-			}
-		}
-	case FTypeId:
-		for i, arg := range args {
-			switch arg := arg.(type) {
-			case Op:
-				args[i] = fmtOpTypeId(arg)
-			case *Node:
-				args[i] = (*fmtNodeTypeId)(arg)
-			case *types.Type:
-				args[i] = (*fmtTypeTypeId)(arg)
-			case *types.Sym:
-				args[i] = (*fmtSymTypeId)(arg)
-			case Nodes:
-				args[i] = fmtNodesTypeId(arg)
-			case int32, int64, string, types.EType, constant.Value:
-				// OK: printing these types doesn't depend on mode
-			default:
-				Fatalf("mode.prepareArgs type %T", arg)
-			}
-		}
-	case FTypeIdName:
-		for i, arg := range args {
-			switch arg := arg.(type) {
-			case Op:
-				args[i] = fmtOpTypeIdName(arg)
-			case *Node:
-				args[i] = (*fmtNodeTypeIdName)(arg)
-			case *types.Type:
-				args[i] = (*fmtTypeTypeIdName)(arg)
-			case *types.Sym:
-				args[i] = (*fmtSymTypeIdName)(arg)
-			case Nodes:
-				args[i] = fmtNodesTypeIdName(arg)
-			case int32, int64, string, types.EType, constant.Value:
-				// OK: printing these types doesn't depend on mode
-			default:
-				Fatalf("mode.prepareArgs type %T", arg)
-			}
+	for i, arg := range args {
+		switch arg := arg.(type) {
+		case Op:
+			args[i] = &fmtOp{arg, m}
+		case *Node:
+			args[i] = &fmtNode{arg, m}
+		case *types.Type:
+			args[i] = &fmtType{arg, m}
+		case *types.Sym:
+			args[i] = &fmtSym{arg, m}
+		case Nodes:
+			args[i] = &fmtNodes{arg, m}
+		case int32, int64, string, types.EType, constant.Value:
+			// OK: printing these types doesn't depend on mode
+		default:
+			Fatalf("mode.prepareArgs type %T", arg)
 		}
-	default:
-		Fatalf("mode.prepareArgs mode %d", m)
 	}
 }
 
-- 
GitLab


From 18573aea3cc5098c5c27e357e15c507a05de5599 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 16 Nov 2020 00:59:30 -0500
Subject: [PATCH 0062/2400] [dev.regabi] cmd/compile: clean up flag handling
 [generated]

The flag values have grown fairly haphazard, with no organization
or even common naming convention. This CL moves all flag values
into the Flag struct (formerly misnamed Debug), except for a few
that live in Ctxt fields instead.

This CL is entirely automated changes.
A followup CL will make a few manual cleanups, leaving this CL
completely automated and easier to regenerate during merge
conflicts.

Cleaning up flags is necessary because the printing routines
look at some of them, and the printing routines need to move
out of package gc to a new package shared by gc and any
other packages that split out of gc.

[git-generate]

cd src/cmd/compile/internal/gc
rf '
	mv Debug Flag
	mv DebugFlags Flags
	mv Flags.e Flags.LowerE
	mv Flags.h Flags.LowerH
	mv Flags.j Flags.LowerJ
	mv Flags.l Flags.LowerL
	mv Flags.m Flags.LowerM
	mv Flags.r Flags.LowerR
	mv Flags.w Flags.LowerW
	mv Flags.P Flags.Percent
	mv compiling_runtime Flag.CompilingRuntime
	mv compiling_std Flag.Std
	mv localimport Flag.D
	mv asmhdr Flag.AsmHdr
	mv buildid Flag.BuildID
	mv nBackendWorkers Flag.LowerC
	mv pure_go Flag.Complete
	mv debugstr Flag.LowerD
	mv flagDWARF Flag.Dwarf
	mv genDwarfInline Flag.GenDwarfInl
	mv flag_installsuffix Flag.InstallSuffix
	mv flag_lang Flag.Lang
	mv linkobj Flag.LinkObj
	mv debuglive Flag.Live
	mv flag_msan Flag.MSan
	mv nolocalimports Flag.NoLocalImports
	mv outfile Flag.LowerO
	mv myimportpath Ctxt.Pkgpath
	mv writearchive Flag.Pack
	mv flag_race Flag.Race
	mv spectre Flag.Spectre
	mv trace Flag.LowerT
	mv pathPrefix Flag.TrimPath
	mv Debug_vlog Ctxt.Debugvlog
	mv use_writebarrier Flag.WB
	mv Main.flag_shared Flag.Shared
	mv Main.flag_dynlink Flag.Dynlink
	mv Main.goversion Flag.GoVersion
	mv Main.symabisPath Flag.SymABIs
	mv cpuprofile Flag.CPUProfile
	mv memprofile Flag.MemProfile
	mv traceprofile Flag.TraceProfile
	mv blockprofile Flag.BlockProfile
	mv mutexprofile Flag.MutexProfile
	mv benchfile Flag.Bench
	mv Main.smallFrames Flag.SmallFrames
	mv Main.jsonLogOpt Flag.JSON

	add Flag:$ \
		Cfg struct{}
	mv embedCfg Flag.Cfg.Embed
	mv idirs Flag.Cfg.ImportDirs
	mv importMap Flag.Cfg.ImportMap
	mv packageFile Flag.Cfg.PackageFile
	mv spectreIndex Flag.Cfg.SpectreIndex

	mv addidir addImportDir

	mv main.go:/Wasm/-0,/ssaDump/-3 ParseFlags

	mv usage Flag Flags ParseFlags \
		concurrentFlagOk concurrentBackendAllowed \
		addImportDir addImportMap \
		readImportCfg readEmbedCfg \
		flag.go

	# Remove //go:generate line copied from main.go
	# along with two self-assignments from the merge.
	rm flag.go:/go:generate/-+ \
		flag.go:/Ctxt.Pkgpath = Ctxt.Pkgpath/-+ \
		flag.go:/Ctxt.Debugvlog = Ctxt.Debugvlog/-+
'

Change-Id: I10431c15fe7d9f48024d53141d4224d957dbf334
Reviewed-on: https://go-review.googlesource.com/c/go/+/271667
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/alg.go       |   8 +-
 src/cmd/compile/internal/gc/closure.go   |   4 +-
 src/cmd/compile/internal/gc/dcl.go       |   2 +-
 src/cmd/compile/internal/gc/dwinl.go     |   2 +-
 src/cmd/compile/internal/gc/embed.go     |  39 +-
 src/cmd/compile/internal/gc/esc.go       |  18 +-
 src/cmd/compile/internal/gc/escape.go    |  32 +-
 src/cmd/compile/internal/gc/export.go    |  16 +-
 src/cmd/compile/internal/gc/flag.go      | 516 +++++++++++++++++++++++
 src/cmd/compile/internal/gc/go.go        |  53 +--
 src/cmd/compile/internal/gc/gsubr.go     |   8 +-
 src/cmd/compile/internal/gc/iimport.go   |   4 +-
 src/cmd/compile/internal/gc/inl.go       |  50 +--
 src/cmd/compile/internal/gc/main.go      | 512 ++--------------------
 src/cmd/compile/internal/gc/noder.go     |  18 +-
 src/cmd/compile/internal/gc/obj.go       |  14 +-
 src/cmd/compile/internal/gc/order.go     |   4 +-
 src/cmd/compile/internal/gc/pgen.go      |  17 +-
 src/cmd/compile/internal/gc/plive.go     |   8 +-
 src/cmd/compile/internal/gc/print.go     |  18 +-
 src/cmd/compile/internal/gc/racewalk.go  |   8 +-
 src/cmd/compile/internal/gc/range.go     |   4 +-
 src/cmd/compile/internal/gc/reflect.go   |  16 +-
 src/cmd/compile/internal/gc/select.go    |   6 +-
 src/cmd/compile/internal/gc/sinit.go     |   2 +-
 src/cmd/compile/internal/gc/ssa.go       |  44 +-
 src/cmd/compile/internal/gc/subr.go      |   8 +-
 src/cmd/compile/internal/gc/syntax.go    |   6 +-
 src/cmd/compile/internal/gc/typecheck.go |  21 +-
 src/cmd/compile/internal/gc/util.go      |  25 +-
 src/cmd/compile/internal/gc/walk.go      |  26 +-
 31 files changed, 752 insertions(+), 757 deletions(-)
 create mode 100644 src/cmd/compile/internal/gc/flag.go

diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index 2f7fa27bb9..c1d8de6bad 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -282,7 +282,7 @@ func genhash(t *types.Type) *obj.LSym {
 	}
 
 	sym := typesymprefix(".hash", t)
-	if Debug.r != 0 {
+	if Flag.LowerR != 0 {
 		fmt.Printf("genhash %v %v %v\n", closure, sym, t)
 	}
 
@@ -374,7 +374,7 @@ func genhash(t *types.Type) *obj.LSym {
 	r.List.Append(nh)
 	fn.Nbody.Append(r)
 
-	if Debug.r != 0 {
+	if Flag.LowerR != 0 {
 		dumplist("genhash body", fn.Nbody)
 	}
 
@@ -509,7 +509,7 @@ func geneq(t *types.Type) *obj.LSym {
 		return closure
 	}
 	sym := typesymprefix(".eq", t)
-	if Debug.r != 0 {
+	if Flag.LowerR != 0 {
 		fmt.Printf("geneq %v\n", t)
 	}
 
@@ -753,7 +753,7 @@ func geneq(t *types.Type) *obj.LSym {
 	// We should really do a generic CL that shares epilogues across
 	// the board. See #24936.
 
-	if Debug.r != 0 {
+	if Flag.LowerR != 0 {
 		dumplist("geneq body", fn.Nbody)
 	}
 
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index 577d6565f5..f850cbe280 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -203,7 +203,7 @@ func capturevars(dcl *Node) {
 			outer = nod(OADDR, outer, nil)
 		}
 
-		if Debug.m > 1 {
+		if Flag.LowerM > 1 {
 			var name *types.Sym
 			if v.Name.Curfn != nil && v.Name.Curfn.Func.Nname != nil {
 				name = v.Name.Curfn.Func.Nname.Sym
@@ -344,7 +344,7 @@ func closuredebugruntimecheck(clo *Node) {
 			Warnl(clo.Pos, "stack closure, captured vars = %v", clo.Func.ClosureVars)
 		}
 	}
-	if compiling_runtime && clo.Esc == EscHeap {
+	if Flag.CompilingRuntime && clo.Esc == EscHeap {
 		yyerrorl(clo.Pos, "heap-allocated closure, not allowed in runtime")
 	}
 }
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 4311421174..3f193e3a01 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -946,7 +946,7 @@ func makefuncsym(s *types.Sym) {
 	if s.IsBlank() {
 		return
 	}
-	if compiling_runtime && (s.Name == "getg" || s.Name == "getclosureptr" || s.Name == "getcallerpc" || s.Name == "getcallersp") {
+	if Flag.CompilingRuntime && (s.Name == "getg" || s.Name == "getclosureptr" || s.Name == "getcallerpc" || s.Name == "getcallersp") {
 		// runtime.getg(), getclosureptr(), getcallerpc(), and
 		// getcallersp() are not real functions and so do not
 		// get funcsyms.
diff --git a/src/cmd/compile/internal/gc/dwinl.go b/src/cmd/compile/internal/gc/dwinl.go
index bb5ae61cbb..48d78f6cd7 100644
--- a/src/cmd/compile/internal/gc/dwinl.go
+++ b/src/cmd/compile/internal/gc/dwinl.go
@@ -213,7 +213,7 @@ func genAbstractFunc(fn *obj.LSym) {
 	if Debug_gendwarfinl != 0 {
 		Ctxt.Logf("DwarfAbstractFunc(%v)\n", fn.Name)
 	}
-	Ctxt.DwarfAbstractFunc(ifn, fn, myimportpath)
+	Ctxt.DwarfAbstractFunc(ifn, fn, Ctxt.Pkgpath)
 }
 
 // Undo any versioning performed when a name was written
diff --git a/src/cmd/compile/internal/gc/embed.go b/src/cmd/compile/internal/gc/embed.go
index 103949c1f9..5559d62813 100644
--- a/src/cmd/compile/internal/gc/embed.go
+++ b/src/cmd/compile/internal/gc/embed.go
@@ -8,9 +8,7 @@ import (
 	"cmd/compile/internal/syntax"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
-	"encoding/json"
-	"io/ioutil"
-	"log"
+
 	"path"
 	"sort"
 	"strconv"
@@ -19,27 +17,6 @@ import (
 
 var embedlist []*Node
 
-var embedCfg struct {
-	Patterns map[string][]string
-	Files    map[string]string
-}
-
-func readEmbedCfg(file string) {
-	data, err := ioutil.ReadFile(file)
-	if err != nil {
-		log.Fatalf("-embedcfg: %v", err)
-	}
-	if err := json.Unmarshal(data, &embedCfg); err != nil {
-		log.Fatalf("%s: %v", file, err)
-	}
-	if embedCfg.Patterns == nil {
-		log.Fatalf("%s: invalid embedcfg: missing Patterns", file)
-	}
-	if embedCfg.Files == nil {
-		log.Fatalf("%s: invalid embedcfg: missing Files", file)
-	}
-}
-
 const (
 	embedUnknown = iota
 	embedBytes
@@ -69,7 +46,7 @@ func varEmbed(p *noder, names []*Node, typ *Node, exprs []*Node, embeds []Pragma
 		p.yyerrorpos(pos, "invalid go:embed: missing import \"embed\"")
 		return exprs
 	}
-	if embedCfg.Patterns == nil {
+	if Flag.Cfg.Embed.Patterns == nil {
 		p.yyerrorpos(pos, "invalid go:embed: build system did not supply embed configuration")
 		return exprs
 	}
@@ -98,12 +75,12 @@ func varEmbed(p *noder, names []*Node, typ *Node, exprs []*Node, embeds []Pragma
 	var list []string
 	for _, e := range embeds {
 		for _, pattern := range e.Patterns {
-			files, ok := embedCfg.Patterns[pattern]
+			files, ok := Flag.Cfg.Embed.Patterns[pattern]
 			if !ok {
 				p.yyerrorpos(e.Pos, "invalid go:embed: build system did not map pattern: %s", pattern)
 			}
 			for _, file := range files {
-				if embedCfg.Files[file] == "" {
+				if Flag.Cfg.Embed.Files[file] == "" {
 					p.yyerrorpos(e.Pos, "invalid go:embed: build system did not map file: %s", file)
 					continue
 				}
@@ -152,7 +129,7 @@ func varEmbed(p *noder, names []*Node, typ *Node, exprs []*Node, embeds []Pragma
 // can't tell whether "string" and "byte" really mean "string" and "byte".
 // The result must be confirmed later, after type checking, using embedKind.
 func embedKindApprox(typ *Node) int {
-	if typ.Sym != nil && typ.Sym.Name == "FS" && (typ.Sym.Pkg.Path == "embed" || (typ.Sym.Pkg == localpkg && myimportpath == "embed")) {
+	if typ.Sym != nil && typ.Sym.Name == "FS" && (typ.Sym.Pkg.Path == "embed" || (typ.Sym.Pkg == localpkg && Ctxt.Pkgpath == "embed")) {
 		return embedFiles
 	}
 	// These are not guaranteed to match only string and []byte -
@@ -170,7 +147,7 @@ func embedKindApprox(typ *Node) int {
 
 // embedKind determines the kind of embedding variable.
 func embedKind(typ *types.Type) int {
-	if typ.Sym != nil && typ.Sym.Name == "FS" && (typ.Sym.Pkg.Path == "embed" || (typ.Sym.Pkg == localpkg && myimportpath == "embed")) {
+	if typ.Sym != nil && typ.Sym.Name == "FS" && (typ.Sym.Pkg.Path == "embed" || (typ.Sym.Pkg == localpkg && Ctxt.Pkgpath == "embed")) {
 		return embedFiles
 	}
 	if typ == types.Types[TSTRING] {
@@ -221,7 +198,7 @@ func initEmbed(v *Node) {
 
 	case embedString, embedBytes:
 		file := files[0]
-		fsym, size, err := fileStringSym(v.Pos, embedCfg.Files[file], kind == embedString, nil)
+		fsym, size, err := fileStringSym(v.Pos, Flag.Cfg.Embed.Files[file], kind == embedString, nil)
 		if err != nil {
 			yyerrorl(v.Pos, "embed %s: %v", file, err)
 		}
@@ -257,7 +234,7 @@ func initEmbed(v *Node) {
 				off = duintptr(slicedata, off, 0)
 				off += hashSize
 			} else {
-				fsym, size, err := fileStringSym(v.Pos, embedCfg.Files[file], true, hash)
+				fsym, size, err := fileStringSym(v.Pos, Flag.Cfg.Embed.Files[file], true, hash)
 				if err != nil {
 					yyerrorl(v.Pos, "embed %s: %v", file, err)
 				}
diff --git a/src/cmd/compile/internal/gc/esc.go b/src/cmd/compile/internal/gc/esc.go
index 6003f6608c..74b85e1ae8 100644
--- a/src/cmd/compile/internal/gc/esc.go
+++ b/src/cmd/compile/internal/gc/esc.go
@@ -283,10 +283,10 @@ func addrescapes(n *Node) {
 
 // moveToHeap records the parameter or local variable n as moved to the heap.
 func moveToHeap(n *Node) {
-	if Debug.r != 0 {
+	if Flag.LowerR != 0 {
 		Dump("MOVE", n)
 	}
-	if compiling_runtime {
+	if Flag.CompilingRuntime {
 		yyerror("%v escapes to heap, not allowed in runtime", n)
 	}
 	if n.Class() == PAUTOHEAP {
@@ -360,7 +360,7 @@ func moveToHeap(n *Node) {
 	n.Xoffset = 0
 	n.Name.Param.Heapaddr = heapaddr
 	n.Esc = EscHeap
-	if Debug.m != 0 {
+	if Flag.LowerM != 0 {
 		Warnl(n.Pos, "moved to heap: %v", n)
 	}
 }
@@ -390,7 +390,7 @@ func (e *Escape) paramTag(fn *Node, narg int, f *types.Field) string {
 		// but we are reusing the ability to annotate an individual function
 		// argument and pass those annotations along to importing code.
 		if f.Type.IsUintptr() {
-			if Debug.m != 0 {
+			if Flag.LowerM != 0 {
 				Warnl(f.Pos, "assuming %v is unsafe uintptr", name())
 			}
 			return unsafeUintptrTag
@@ -405,11 +405,11 @@ func (e *Escape) paramTag(fn *Node, narg int, f *types.Field) string {
 		// External functions are assumed unsafe, unless
 		// //go:noescape is given before the declaration.
 		if fn.Func.Pragma&Noescape != 0 {
-			if Debug.m != 0 && f.Sym != nil {
+			if Flag.LowerM != 0 && f.Sym != nil {
 				Warnl(f.Pos, "%v does not escape", name())
 			}
 		} else {
-			if Debug.m != 0 && f.Sym != nil {
+			if Flag.LowerM != 0 && f.Sym != nil {
 				Warnl(f.Pos, "leaking param: %v", name())
 			}
 			esc.AddHeap(0)
@@ -420,14 +420,14 @@ func (e *Escape) paramTag(fn *Node, narg int, f *types.Field) string {
 
 	if fn.Func.Pragma&UintptrEscapes != 0 {
 		if f.Type.IsUintptr() {
-			if Debug.m != 0 {
+			if Flag.LowerM != 0 {
 				Warnl(f.Pos, "marking %v as escaping uintptr", name())
 			}
 			return uintptrEscapesTag
 		}
 		if f.IsDDD() && f.Type.Elem().IsUintptr() {
 			// final argument is ...uintptr.
-			if Debug.m != 0 {
+			if Flag.LowerM != 0 {
 				Warnl(f.Pos, "marking %v as escaping ...uintptr", name())
 			}
 			return uintptrEscapesTag
@@ -449,7 +449,7 @@ func (e *Escape) paramTag(fn *Node, narg int, f *types.Field) string {
 	esc := loc.paramEsc
 	esc.Optimize()
 
-	if Debug.m != 0 && !loc.escapes {
+	if Flag.LowerM != 0 && !loc.escapes {
 		if esc.Empty() {
 			Warnl(f.Pos, "%v does not escape", name())
 		}
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index b6975c79a4..27645fb888 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -205,7 +205,7 @@ func (e *Escape) initFunc(fn *Node) {
 		Fatalf("unexpected node: %v", fn)
 	}
 	fn.Esc = EscFuncPlanned
-	if Debug.m > 3 {
+	if Flag.LowerM > 3 {
 		Dump("escAnalyze", fn)
 	}
 
@@ -282,7 +282,7 @@ func (e *Escape) stmt(n *Node) {
 		lineno = lno
 	}()
 
-	if Debug.m > 2 {
+	if Flag.LowerM > 2 {
 		fmt.Printf("%v:[%d] %v stmt: %v\n", linestr(lineno), e.loopDepth, funcSym(e.curfn), n)
 	}
 
@@ -310,11 +310,11 @@ func (e *Escape) stmt(n *Node) {
 	case OLABEL:
 		switch asNode(n.Sym.Label) {
 		case nonlooping:
-			if Debug.m > 2 {
+			if Flag.LowerM > 2 {
 				fmt.Printf("%v:%v non-looping label\n", linestr(lineno), n)
 			}
 		case looping:
-			if Debug.m > 2 {
+			if Flag.LowerM > 2 {
 				fmt.Printf("%v: %v looping label\n", linestr(lineno), n)
 			}
 			e.loopDepth++
@@ -752,7 +752,7 @@ func (e *Escape) addrs(l Nodes) []EscHole {
 func (e *Escape) assign(dst, src *Node, why string, where *Node) {
 	// Filter out some no-op assignments for escape analysis.
 	ignore := dst != nil && src != nil && isSelfAssign(dst, src)
-	if ignore && Debug.m != 0 {
+	if ignore && Flag.LowerM != 0 {
 		Warnl(where.Pos, "%v ignoring self-assignment in %S", funcSym(e.curfn), where)
 	}
 
@@ -966,7 +966,7 @@ func (k EscHole) note(where *Node, why string) EscHole {
 	if where == nil || why == "" {
 		Fatalf("note: missing where/why")
 	}
-	if Debug.m >= 2 || logopt.Enabled() {
+	if Flag.LowerM >= 2 || logopt.Enabled() {
 		k.notes = &EscNote{
 			next:  k.notes,
 			where: where,
@@ -1112,9 +1112,9 @@ func (e *Escape) flow(k EscHole, src *EscLocation) {
 		return
 	}
 	if dst.escapes && k.derefs < 0 { // dst = &src
-		if Debug.m >= 2 || logopt.Enabled() {
+		if Flag.LowerM >= 2 || logopt.Enabled() {
 			pos := linestr(src.n.Pos)
-			if Debug.m >= 2 {
+			if Flag.LowerM >= 2 {
 				fmt.Printf("%s: %v escapes to heap:\n", pos, src.n)
 			}
 			explanation := e.explainFlow(pos, dst, src, k.derefs, k.notes, []*logopt.LoggedOpt{})
@@ -1214,8 +1214,8 @@ func (e *Escape) walkOne(root *EscLocation, walkgen uint32, enqueue func(*EscLoc
 			// that value flow for tagging the function
 			// later.
 			if l.isName(PPARAM) {
-				if (logopt.Enabled() || Debug.m >= 2) && !l.escapes {
-					if Debug.m >= 2 {
+				if (logopt.Enabled() || Flag.LowerM >= 2) && !l.escapes {
+					if Flag.LowerM >= 2 {
 						fmt.Printf("%s: parameter %v leaks to %s with derefs=%d:\n", linestr(l.n.Pos), l.n, e.explainLoc(root), derefs)
 					}
 					explanation := e.explainPath(root, l)
@@ -1231,8 +1231,8 @@ func (e *Escape) walkOne(root *EscLocation, walkgen uint32, enqueue func(*EscLoc
 			// outlives it, then l needs to be heap
 			// allocated.
 			if addressOf && !l.escapes {
-				if logopt.Enabled() || Debug.m >= 2 {
-					if Debug.m >= 2 {
+				if logopt.Enabled() || Flag.LowerM >= 2 {
+					if Flag.LowerM >= 2 {
 						fmt.Printf("%s: %v escapes to heap:\n", linestr(l.n.Pos), l.n)
 					}
 					explanation := e.explainPath(root, l)
@@ -1270,7 +1270,7 @@ func (e *Escape) explainPath(root, src *EscLocation) []*logopt.LoggedOpt {
 	for {
 		// Prevent infinite loop.
 		if visited[src] {
-			if Debug.m >= 2 {
+			if Flag.LowerM >= 2 {
 				fmt.Printf("%s:   warning: truncated explanation due to assignment cycle; see golang.org/issue/35518\n", pos)
 			}
 			break
@@ -1298,7 +1298,7 @@ func (e *Escape) explainFlow(pos string, dst, srcloc *EscLocation, derefs int, n
 	if derefs >= 0 {
 		ops = strings.Repeat("*", derefs)
 	}
-	print := Debug.m >= 2
+	print := Flag.LowerM >= 2
 
 	flow := fmt.Sprintf("   flow: %s = %s%v:", e.explainLoc(dst), ops, e.explainLoc(srcloc))
 	if print {
@@ -1452,7 +1452,7 @@ func (e *Escape) finish(fns []*Node) {
 
 		if loc.escapes {
 			if n.Op != ONAME {
-				if Debug.m != 0 {
+				if Flag.LowerM != 0 {
 					Warnl(n.Pos, "%S escapes to heap", n)
 				}
 				if logopt.Enabled() {
@@ -1462,7 +1462,7 @@ func (e *Escape) finish(fns []*Node) {
 			n.Esc = EscHeap
 			addrescapes(n)
 		} else {
-			if Debug.m != 0 && n.Op != ONAME {
+			if Flag.LowerM != 0 && n.Op != ONAME {
 				Warnl(n.Pos, "%S does not escape", n)
 			}
 			n.Esc = EscNone
diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index 9ee3b080b8..edd2703238 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -32,7 +32,7 @@ func exportsym(n *Node) {
 	}
 	n.Sym.SetOnExportList(true)
 
-	if Debug.E != 0 {
+	if Flag.E != 0 {
 		fmt.Printf("export symbol %v\n", n.Sym)
 	}
 
@@ -57,7 +57,7 @@ func autoexport(n *Node, ctxt Class) {
 	if types.IsExported(n.Sym.Name) || initname(n.Sym.Name) {
 		exportsym(n)
 	}
-	if asmhdr != "" && !n.Sym.Asm() {
+	if Flag.AsmHdr != "" && !n.Sym.Asm() {
 		n.Sym.SetAsm(true)
 		asmlist = append(asmlist, n)
 	}
@@ -72,7 +72,7 @@ func dumpexport(bout *bio.Writer) {
 	exportf(bout, "\n$$\n")
 
 	if Debug_export != 0 {
-		fmt.Printf("BenchmarkExportSize:%s 1 %d bytes\n", myimportpath, size)
+		fmt.Printf("BenchmarkExportSize:%s 1 %d bytes\n", Ctxt.Pkgpath, size)
 	}
 }
 
@@ -151,7 +151,7 @@ func importconst(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type, val
 
 	n.SetVal(val)
 
-	if Debug.E != 0 {
+	if Flag.E != 0 {
 		fmt.Printf("import const %v %L = %v\n", s, t, val)
 	}
 }
@@ -166,7 +166,7 @@ func importfunc(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) {
 
 	n.Func = new(Func)
 
-	if Debug.E != 0 {
+	if Flag.E != 0 {
 		fmt.Printf("import func %v%S\n", s, t)
 	}
 }
@@ -179,7 +179,7 @@ func importvar(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) {
 		return
 	}
 
-	if Debug.E != 0 {
+	if Flag.E != 0 {
 		fmt.Printf("import var %v %L\n", s, t)
 	}
 }
@@ -192,13 +192,13 @@ func importalias(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) {
 		return
 	}
 
-	if Debug.E != 0 {
+	if Flag.E != 0 {
 		fmt.Printf("import type %v = %L\n", s, t)
 	}
 }
 
 func dumpasmhdr() {
-	b, err := bio.Create(asmhdr)
+	b, err := bio.Create(Flag.AsmHdr)
 	if err != nil {
 		Fatalf("%v", err)
 	}
diff --git a/src/cmd/compile/internal/gc/flag.go b/src/cmd/compile/internal/gc/flag.go
new file mode 100644
index 0000000000..3861c9a028
--- /dev/null
+++ b/src/cmd/compile/internal/gc/flag.go
@@ -0,0 +1,516 @@
+// Copyright 2009 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 gc
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"runtime"
+	"strconv"
+	"strings"
+
+	"cmd/compile/internal/logopt"
+	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/types"
+	"cmd/internal/dwarf"
+	"cmd/internal/obj"
+	"cmd/internal/objabi"
+	"cmd/internal/sys"
+)
+
+func usage() {
+	fmt.Fprintf(os.Stderr, "usage: compile [options] file.go...\n")
+	objabi.Flagprint(os.Stderr)
+	Exit(2)
+}
+
+var Flag Flags
+
+// gc debug flags
+type Flags struct {
+	Percent, B, C, E,
+	K, L, N, S,
+	W, LowerE, LowerH, LowerJ,
+	LowerL, LowerM, LowerR, LowerW int
+	CompilingRuntime bool
+	Std              bool
+	D                string
+	AsmHdr           string
+	BuildID          string
+	LowerC           int
+	Complete         bool
+	LowerD           string
+	Dwarf            bool
+	GenDwarfInl      int
+	InstallSuffix    string
+	Lang             string
+	LinkObj          string
+	Live             int
+	MSan             bool
+	NoLocalImports   bool
+	LowerO           string
+	Pack             bool
+	Race             bool
+	Spectre          string
+	LowerT           bool
+	TrimPath         string
+	WB               bool
+	Shared           bool
+	Dynlink          bool
+	GoVersion        string
+	SymABIs          string
+	CPUProfile       string
+	MemProfile       string
+	TraceProfile     string
+	BlockProfile     string
+	MutexProfile     string
+	Bench            string
+	SmallFrames      bool
+	JSON             string
+
+	Cfg struct {
+		Embed struct {
+			Patterns map[string][]string
+			Files    map[string]string
+		}
+		ImportDirs   []string
+		ImportMap    map[string]string
+		PackageFile  map[string]string
+		SpectreIndex bool
+	}
+}
+
+func ParseFlags() {
+	Wasm := objabi.GOARCH == "wasm"
+
+	// Whether the limit for stack-allocated objects is much smaller than normal.
+	// This can be helpful for diagnosing certain causes of GC latency. See #27732.
+	Flag.SmallFrames = false
+	Flag.JSON = ""
+
+	flag.BoolVar(&Flag.CompilingRuntime, "+", false, "compiling runtime")
+	flag.BoolVar(&Flag.Std, "std", false, "compiling standard library")
+	flag.StringVar(&Flag.D, "D", "", "set relative `path` for local imports")
+
+	objabi.Flagcount("%", "debug non-static initializers", &Flag.Percent)
+	objabi.Flagcount("B", "disable bounds checking", &Flag.B)
+	objabi.Flagcount("C", "disable printing of columns in error messages", &Flag.C)
+	objabi.Flagcount("E", "debug symbol export", &Flag.E)
+	objabi.Flagcount("K", "debug missing line numbers", &Flag.K)
+	objabi.Flagcount("L", "show full file names in error messages", &Flag.L)
+	objabi.Flagcount("N", "disable optimizations", &Flag.N)
+	objabi.Flagcount("S", "print assembly listing", &Flag.S)
+	objabi.Flagcount("W", "debug parse tree after type checking", &Flag.W)
+	objabi.Flagcount("e", "no limit on number of errors reported", &Flag.LowerE)
+	objabi.Flagcount("h", "halt on error", &Flag.LowerH)
+	objabi.Flagcount("j", "debug runtime-initialized variables", &Flag.LowerJ)
+	objabi.Flagcount("l", "disable inlining", &Flag.LowerL)
+	objabi.Flagcount("m", "print optimization decisions", &Flag.LowerM)
+	objabi.Flagcount("r", "debug generated wrappers", &Flag.LowerR)
+	objabi.Flagcount("w", "debug type checking", &Flag.LowerW)
+
+	objabi.Flagfn1("I", "add `directory` to import search path", addImportDir)
+	objabi.AddVersionFlag() // -V
+	flag.StringVar(&Flag.AsmHdr, "asmhdr", "", "write assembly header to `file`")
+	flag.StringVar(&Flag.BuildID, "buildid", "", "record `id` as the build id in the export metadata")
+	flag.IntVar(&Flag.LowerC, "c", 1, "concurrency during compilation, 1 means no concurrency")
+	flag.BoolVar(&Flag.Complete, "complete", false, "compiling complete package (no C or assembly)")
+	flag.StringVar(&Flag.LowerD, "d", "", "print debug information about items in `list`; try -d help")
+	flag.BoolVar(&Flag.Dwarf, "dwarf", !Wasm, "generate DWARF symbols")
+	flag.BoolVar(&Ctxt.Flag_locationlists, "dwarflocationlists", true, "add location lists to DWARF in optimized mode")
+	flag.IntVar(&Flag.GenDwarfInl, "gendwarfinl", 2, "generate DWARF inline info records")
+	objabi.Flagfn1("embedcfg", "read go:embed configuration from `file`", readEmbedCfg)
+	objabi.Flagfn1("importmap", "add `definition` of the form source=actual to import map", addImportMap)
+	objabi.Flagfn1("importcfg", "read import configuration from `file`", readImportCfg)
+	flag.StringVar(&Flag.InstallSuffix, "installsuffix", "", "set pkg directory `suffix`")
+	flag.StringVar(&Flag.Lang, "lang", "", "release to compile for")
+	flag.StringVar(&Flag.LinkObj, "linkobj", "", "write linker-specific object to `file`")
+	objabi.Flagcount("live", "debug liveness analysis", &Flag.Live)
+	if sys.MSanSupported(objabi.GOOS, objabi.GOARCH) {
+		flag.BoolVar(&Flag.MSan, "msan", false, "build code compatible with C/C++ memory sanitizer")
+	}
+	flag.BoolVar(&Flag.NoLocalImports, "nolocalimports", false, "reject local (relative) imports")
+	flag.StringVar(&Flag.LowerO, "o", "", "write output to `file`")
+	flag.StringVar(&Ctxt.Pkgpath, "p", "", "set expected package import `path`")
+	flag.BoolVar(&Flag.Pack, "pack", false, "write to file.a instead of file.o")
+	if sys.RaceDetectorSupported(objabi.GOOS, objabi.GOARCH) {
+		flag.BoolVar(&Flag.Race, "race", false, "enable race detector")
+	}
+	flag.StringVar(&Flag.Spectre, "spectre", Flag.Spectre, "enable spectre mitigations in `list` (all, index, ret)")
+	if enableTrace {
+		flag.BoolVar(&Flag.LowerT, "t", false, "trace type-checking")
+	}
+	flag.StringVar(&Flag.TrimPath, "trimpath", "", "remove `prefix` from recorded source file paths")
+	flag.BoolVar(&Ctxt.Debugvlog, "v", false, "increase debug verbosity")
+	flag.BoolVar(&Flag.WB, "wb", true, "enable write barrier")
+	if supportsDynlink(thearch.LinkArch.Arch) {
+		flag.BoolVar(&Flag.Shared, "shared", false, "generate code that can be linked into a shared library")
+		flag.BoolVar(&Flag.Dynlink, "dynlink", false, "support references to Go symbols defined in other shared libraries")
+		flag.BoolVar(&Ctxt.Flag_linkshared, "linkshared", false, "generate code that will be linked against Go shared libraries")
+	}
+	flag.StringVar(&Flag.CPUProfile, "cpuprofile", "", "write cpu profile to `file`")
+	flag.StringVar(&Flag.MemProfile, "memprofile", "", "write memory profile to `file`")
+	flag.Int64Var(&memprofilerate, "memprofilerate", 0, "set runtime.MemProfileRate to `rate`")
+	flag.StringVar(&Flag.GoVersion, "goversion", "", "required version of the runtime")
+	flag.StringVar(&Flag.SymABIs, "symabis", "", "read symbol ABIs from `file`")
+	flag.StringVar(&Flag.TraceProfile, "traceprofile", "", "write an execution trace to `file`")
+	flag.StringVar(&Flag.BlockProfile, "blockprofile", "", "write block profile to `file`")
+	flag.StringVar(&Flag.MutexProfile, "mutexprofile", "", "write mutex profile to `file`")
+	flag.StringVar(&Flag.Bench, "bench", "", "append benchmark times to `file`")
+	flag.BoolVar(&Flag.SmallFrames, "smallframes", false, "reduce the size limit for stack allocated objects")
+	flag.BoolVar(&Ctxt.UseBASEntries, "dwarfbasentries", Ctxt.UseBASEntries, "use base address selection entries in DWARF")
+	flag.StringVar(&Flag.JSON, "json", "", "version,destination for JSON compiler/optimizer logging")
+
+	objabi.Flagparse(usage)
+
+	for _, f := range strings.Split(Flag.Spectre, ",") {
+		f = strings.TrimSpace(f)
+		switch f {
+		default:
+			log.Fatalf("unknown setting -spectre=%s", f)
+		case "":
+			// nothing
+		case "all":
+			Flag.Cfg.SpectreIndex = true
+			Ctxt.Retpoline = true
+		case "index":
+			Flag.Cfg.SpectreIndex = true
+		case "ret":
+			Ctxt.Retpoline = true
+		}
+	}
+
+	if Flag.Cfg.SpectreIndex {
+		switch objabi.GOARCH {
+		case "amd64":
+			// ok
+		default:
+			log.Fatalf("GOARCH=%s does not support -spectre=index", objabi.GOARCH)
+		}
+	}
+
+	// Record flags that affect the build result. (And don't
+	// record flags that don't, since that would cause spurious
+	// changes in the binary.)
+	recordFlags("B", "N", "l", "msan", "race", "shared", "dynlink", "dwarflocationlists", "dwarfbasentries", "smallframes", "spectre")
+
+	if Flag.SmallFrames {
+		maxStackVarSize = 128 * 1024
+		maxImplicitStackVarSize = 16 * 1024
+	}
+
+	Ctxt.Flag_shared = Flag.Dynlink || Flag.Shared
+	Ctxt.Flag_dynlink = Flag.Dynlink
+	Ctxt.Flag_optimize = Flag.N == 0
+
+	Ctxt.Debugasm = Flag.S
+	if Flag.Dwarf {
+		Ctxt.DebugInfo = debuginfo
+		Ctxt.GenAbstractFunc = genAbstractFunc
+		Ctxt.DwFixups = obj.NewDwarfFixupTable(Ctxt)
+	} else {
+		// turn off inline generation if no dwarf at all
+		Flag.GenDwarfInl = 0
+		Ctxt.Flag_locationlists = false
+	}
+
+	if flag.NArg() < 1 && Flag.LowerD != "help" && Flag.LowerD != "ssa/help" {
+		usage()
+	}
+
+	if Flag.GoVersion != "" && Flag.GoVersion != runtime.Version() {
+		fmt.Printf("compile: version %q does not match go tool version %q\n", runtime.Version(), Flag.GoVersion)
+		Exit(2)
+	}
+
+	checkLang()
+
+	if Flag.SymABIs != "" {
+		readSymABIs(Flag.SymABIs, Ctxt.Pkgpath)
+	}
+
+	thearch.LinkArch.Init(Ctxt)
+
+	if Flag.LowerO == "" {
+		p := flag.Arg(0)
+		if i := strings.LastIndex(p, "/"); i >= 0 {
+			p = p[i+1:]
+		}
+		if runtime.GOOS == "windows" {
+			if i := strings.LastIndex(p, `\`); i >= 0 {
+				p = p[i+1:]
+			}
+		}
+		if i := strings.LastIndex(p, "."); i >= 0 {
+			p = p[:i]
+		}
+		suffix := ".o"
+		if Flag.Pack {
+			suffix = ".a"
+		}
+		Flag.LowerO = p + suffix
+	}
+
+	startProfile()
+
+	if Flag.Race && Flag.MSan {
+		log.Fatal("cannot use both -race and -msan")
+	}
+	if Flag.Race || Flag.MSan {
+		// -race and -msan imply -d=checkptr for now.
+		Debug_checkptr = 1
+	}
+	if ispkgin(omit_pkgs) {
+		Flag.Race = false
+		Flag.MSan = false
+	}
+	if Flag.Race {
+		racepkg = types.NewPkg("runtime/race", "")
+	}
+	if Flag.MSan {
+		msanpkg = types.NewPkg("runtime/msan", "")
+	}
+	if Flag.Race || Flag.MSan {
+		instrumenting = true
+	}
+
+	if Flag.CompilingRuntime && Flag.N != 0 {
+		log.Fatal("cannot disable optimizations while compiling runtime")
+	}
+	if Flag.LowerC < 1 {
+		log.Fatalf("-c must be at least 1, got %d", Flag.LowerC)
+	}
+	if Flag.LowerC > 1 && !concurrentBackendAllowed() {
+		log.Fatalf("cannot use concurrent backend compilation with provided flags; invoked as %v", os.Args)
+	}
+	if Ctxt.Flag_locationlists && len(Ctxt.Arch.DWARFRegisters) == 0 {
+		log.Fatalf("location lists requested but register mapping not available on %v", Ctxt.Arch.Name)
+	}
+
+	// parse -d argument
+	if Flag.LowerD != "" {
+	Split:
+		for _, name := range strings.Split(Flag.LowerD, ",") {
+			if name == "" {
+				continue
+			}
+			// display help about the -d option itself and quit
+			if name == "help" {
+				fmt.Print(debugHelpHeader)
+				maxLen := len("ssa/help")
+				for _, t := range debugtab {
+					if len(t.name) > maxLen {
+						maxLen = len(t.name)
+					}
+				}
+				for _, t := range debugtab {
+					fmt.Printf("\t%-*s\t%s\n", maxLen, t.name, t.help)
+				}
+				// ssa options have their own help
+				fmt.Printf("\t%-*s\t%s\n", maxLen, "ssa/help", "print help about SSA debugging")
+				fmt.Print(debugHelpFooter)
+				os.Exit(0)
+			}
+			val, valstring, haveInt := 1, "", true
+			if i := strings.IndexAny(name, "=:"); i >= 0 {
+				var err error
+				name, valstring = name[:i], name[i+1:]
+				val, err = strconv.Atoi(valstring)
+				if err != nil {
+					val, haveInt = 1, false
+				}
+			}
+			for _, t := range debugtab {
+				if t.name != name {
+					continue
+				}
+				switch vp := t.val.(type) {
+				case nil:
+					// Ignore
+				case *string:
+					*vp = valstring
+				case *int:
+					if !haveInt {
+						log.Fatalf("invalid debug value %v", name)
+					}
+					*vp = val
+				default:
+					panic("bad debugtab type")
+				}
+				continue Split
+			}
+			// special case for ssa for now
+			if strings.HasPrefix(name, "ssa/") {
+				// expect form ssa/phase/flag
+				// e.g. -d=ssa/generic_cse/time
+				// _ in phase name also matches space
+				phase := name[4:]
+				flag := "debug" // default flag is debug
+				if i := strings.Index(phase, "/"); i >= 0 {
+					flag = phase[i+1:]
+					phase = phase[:i]
+				}
+				err := ssa.PhaseOption(phase, flag, val, valstring)
+				if err != "" {
+					log.Fatalf(err)
+				}
+				continue Split
+			}
+			log.Fatalf("unknown debug key -d %s\n", name)
+		}
+	}
+
+	if Flag.CompilingRuntime {
+		// Runtime can't use -d=checkptr, at least not yet.
+		Debug_checkptr = 0
+
+		// Fuzzing the runtime isn't interesting either.
+		Debug_libfuzzer = 0
+	}
+
+	// set via a -d flag
+	Ctxt.Debugpcln = Debug_pctab
+	if Flag.Dwarf {
+		dwarf.EnableLogging(Debug_gendwarfinl != 0)
+	}
+
+	if Debug_softfloat != 0 {
+		thearch.SoftFloat = true
+	}
+
+	// enable inlining.  for now:
+	//	default: inlining on.  (Debug.l == 1)
+	//	-l: inlining off  (Debug.l == 0)
+	//	-l=2, -l=3: inlining on again, with extra debugging (Debug.l > 1)
+	if Flag.LowerL <= 1 {
+		Flag.LowerL = 1 - Flag.LowerL
+	}
+
+	if Flag.JSON != "" { // parse version,destination from json logging optimization.
+		logopt.LogJsonOption(Flag.JSON)
+	}
+}
+
+// concurrentFlagOk reports whether the current compiler flags
+// are compatible with concurrent compilation.
+func concurrentFlagOk() bool {
+	// TODO(rsc): Many of these are fine. Remove them.
+	return Flag.Percent == 0 &&
+		Flag.E == 0 &&
+		Flag.K == 0 &&
+		Flag.L == 0 &&
+		Flag.LowerH == 0 &&
+		Flag.LowerJ == 0 &&
+		Flag.LowerM == 0 &&
+		Flag.LowerR == 0
+}
+
+func concurrentBackendAllowed() bool {
+	if !concurrentFlagOk() {
+		return false
+	}
+
+	// Debug.S by itself is ok, because all printing occurs
+	// while writing the object file, and that is non-concurrent.
+	// Adding Debug_vlog, however, causes Debug.S to also print
+	// while flushing the plist, which happens concurrently.
+	if Ctxt.Debugvlog || Flag.LowerD != "" || Flag.Live > 0 {
+		return false
+	}
+	// TODO: Test and delete this condition.
+	if objabi.Fieldtrack_enabled != 0 {
+		return false
+	}
+	// TODO: fix races and enable the following flags
+	if Ctxt.Flag_shared || Ctxt.Flag_dynlink || Flag.Race {
+		return false
+	}
+	return true
+}
+
+func addImportDir(dir string) {
+	if dir != "" {
+		Flag.Cfg.ImportDirs = append(Flag.Cfg.ImportDirs, dir)
+	}
+}
+
+func addImportMap(s string) {
+	if Flag.Cfg.ImportMap == nil {
+		Flag.Cfg.ImportMap = make(map[string]string)
+	}
+	if strings.Count(s, "=") != 1 {
+		log.Fatal("-importmap argument must be of the form source=actual")
+	}
+	i := strings.Index(s, "=")
+	source, actual := s[:i], s[i+1:]
+	if source == "" || actual == "" {
+		log.Fatal("-importmap argument must be of the form source=actual; source and actual must be non-empty")
+	}
+	Flag.Cfg.ImportMap[source] = actual
+}
+
+func readImportCfg(file string) {
+	if Flag.Cfg.ImportMap == nil {
+		Flag.Cfg.ImportMap = make(map[string]string)
+	}
+	Flag.Cfg.PackageFile = map[string]string{}
+	data, err := ioutil.ReadFile(file)
+	if err != nil {
+		log.Fatalf("-importcfg: %v", err)
+	}
+
+	for lineNum, line := range strings.Split(string(data), "\n") {
+		lineNum++ // 1-based
+		line = strings.TrimSpace(line)
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+
+		var verb, args string
+		if i := strings.Index(line, " "); i < 0 {
+			verb = line
+		} else {
+			verb, args = line[:i], strings.TrimSpace(line[i+1:])
+		}
+		var before, after string
+		if i := strings.Index(args, "="); i >= 0 {
+			before, after = args[:i], args[i+1:]
+		}
+		switch verb {
+		default:
+			log.Fatalf("%s:%d: unknown directive %q", file, lineNum, verb)
+		case "importmap":
+			if before == "" || after == "" {
+				log.Fatalf(`%s:%d: invalid importmap: syntax is "importmap old=new"`, file, lineNum)
+			}
+			Flag.Cfg.ImportMap[before] = after
+		case "packagefile":
+			if before == "" || after == "" {
+				log.Fatalf(`%s:%d: invalid packagefile: syntax is "packagefile path=filename"`, file, lineNum)
+			}
+			Flag.Cfg.PackageFile[before] = after
+		}
+	}
+}
+
+func readEmbedCfg(file string) {
+	data, err := ioutil.ReadFile(file)
+	if err != nil {
+		log.Fatalf("-embedcfg: %v", err)
+	}
+	if err := json.Unmarshal(data, &Flag.Cfg.Embed); err != nil {
+		log.Fatalf("%s: %v", file, err)
+	}
+	if Flag.Cfg.Embed.Patterns == nil {
+		log.Fatalf("%s: invalid embedcfg: missing Patterns", file)
+	}
+	if Flag.Cfg.Embed.Files == nil {
+		log.Fatalf("%s: invalid embedcfg: missing Files", file)
+	}
+}
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index 1242fc06cb..6cab03d726 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -39,7 +39,7 @@ var (
 
 // isRuntimePkg reports whether p is package runtime.
 func isRuntimePkg(p *types.Pkg) bool {
-	if compiling_runtime && p == localpkg {
+	if Flag.CompilingRuntime && p == localpkg {
 		return true
 	}
 	return p.Path == "runtime"
@@ -48,7 +48,7 @@ func isRuntimePkg(p *types.Pkg) bool {
 // isReflectPkg reports whether p is package reflect.
 func isReflectPkg(p *types.Pkg) bool {
 	if p == localpkg {
-		return myimportpath == "reflect"
+		return Ctxt.Pkgpath == "reflect"
 	}
 	return p.Path == "reflect"
 }
@@ -99,25 +99,8 @@ var (
 
 var pragcgobuf [][]string
 
-var outfile string
-var linkobj string
-
 var decldepth int32
 
-var nolocalimports bool
-
-// gc debug flags
-type DebugFlags struct {
-	P, B, C, E,
-	K, L, N, S,
-	W, e, h, j,
-	l, m, r, w int
-}
-
-var Debug DebugFlags
-
-var debugstr string
-
 var Debug_checknil int
 var Debug_typeassert int
 
@@ -145,12 +128,6 @@ var gopkg *types.Pkg // pseudo-package for method symbols on anonymous receiver
 
 var zerosize int64
 
-var myimportpath string
-
-var localimport string
-
-var asmhdr string
-
 var simtype [NTYPE]types.EType
 
 var (
@@ -201,23 +178,6 @@ var nblank *Node
 
 var typecheckok bool
 
-var compiling_runtime bool
-
-// Compiling the standard library
-var compiling_std bool
-
-var use_writebarrier bool
-
-var pure_go bool
-
-var flag_installsuffix string
-
-var flag_race bool
-
-var flag_msan bool
-
-var flagDWARF bool
-
 // Whether we are adding any sort of code instrumentation, such as
 // when the race detector is enabled.
 var instrumenting bool
@@ -225,17 +185,8 @@ var instrumenting bool
 // Whether we are tracking lexical scopes for DWARF.
 var trackScopes bool
 
-// Controls generation of DWARF inlined instance records. Zero
-// disables, 1 emits inlined routines but suppresses var info,
-// and 2 emits inlined routines with tracking of formals/locals.
-var genDwarfInline int
-
-var debuglive int
-
 var Ctxt *obj.Link
 
-var writearchive bool
-
 var nodfp *Node
 
 var disable_checknil int
diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go
index d599a383e7..00d425a77c 100644
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ b/src/cmd/compile/internal/gc/gsubr.go
@@ -58,7 +58,7 @@ type Progs struct {
 func newProgs(fn *Node, worker int) *Progs {
 	pp := new(Progs)
 	if Ctxt.CanReuseProgs() {
-		sz := len(sharedProgArray) / nBackendWorkers
+		sz := len(sharedProgArray) / Flag.LowerC
 		pp.progcache = sharedProgArray[sz*worker : sz*(worker+1)]
 	}
 	pp.curfn = fn
@@ -90,7 +90,7 @@ func (pp *Progs) NewProg() *obj.Prog {
 // Flush converts from pp to machine code.
 func (pp *Progs) Flush() {
 	plist := &obj.Plist{Firstpc: pp.Text, Curfn: pp.curfn}
-	obj.Flushplist(Ctxt, plist, pp.NewProg, myimportpath)
+	obj.Flushplist(Ctxt, plist, pp.NewProg, Ctxt.Pkgpath)
 }
 
 // Free clears pp and any associated resources.
@@ -133,7 +133,7 @@ func (pp *Progs) Prog(as obj.As) *obj.Prog {
 	pp.clearp(pp.next)
 	p.Link = pp.next
 
-	if !pp.pos.IsKnown() && Debug.K != 0 {
+	if !pp.pos.IsKnown() && Flag.K != 0 {
 		Warn("prog: unknown position (line 0)")
 	}
 
@@ -278,7 +278,7 @@ func (f *Func) initLSym(hasBody bool) {
 	// Clumsy but important.
 	// See test/recover.go for test cases and src/reflect/value.go
 	// for the actual functions being considered.
-	if myimportpath == "reflect" {
+	if Ctxt.Pkgpath == "reflect" {
 		switch f.Nname.Sym.Name {
 		case "callReflect", "callMethod":
 			flag |= obj.WRAPPER
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 352335a993..a8a84b8cbc 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -714,8 +714,8 @@ func (r *importReader) doInline(n *Node) {
 
 	importlist = append(importlist, n)
 
-	if Debug.E > 0 && Debug.m > 2 {
-		if Debug.m > 3 {
+	if Flag.E > 0 && Flag.LowerM > 2 {
+		if Flag.LowerM > 3 {
 			fmt.Printf("inl body for %v %#v: %+v\n", n, n.Type, asNodes(n.Func.Inl.Body))
 		} else {
 			fmt.Printf("inl body for %v %#v: %v\n", n, n.Type, asNodes(n.Func.Inl.Body))
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 0695b161f1..50091e9c11 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -86,7 +86,7 @@ func typecheckinl(fn *Node) {
 		return // typecheckinl on local function
 	}
 
-	if Debug.m > 2 || Debug_export != 0 {
+	if Flag.LowerM > 2 || Debug_export != 0 {
 		fmt.Printf("typecheck import [%v] %L { %#v }\n", fn.Sym, fn, asNodes(fn.Func.Inl.Body))
 	}
 
@@ -118,10 +118,10 @@ func caninl(fn *Node) {
 	}
 
 	var reason string // reason, if any, that the function was not inlined
-	if Debug.m > 1 || logopt.Enabled() {
+	if Flag.LowerM > 1 || logopt.Enabled() {
 		defer func() {
 			if reason != "" {
-				if Debug.m > 1 {
+				if Flag.LowerM > 1 {
 					fmt.Printf("%v: cannot inline %v: %s\n", fn.Line(), fn.Func.Nname, reason)
 				}
 				if logopt.Enabled() {
@@ -138,7 +138,7 @@ func caninl(fn *Node) {
 	}
 
 	// If marked "go:norace" and -race compilation, don't inline.
-	if flag_race && fn.Func.Pragma&Norace != 0 {
+	if Flag.Race && fn.Func.Pragma&Norace != 0 {
 		reason = "marked go:norace with -race compilation"
 		return
 	}
@@ -189,7 +189,7 @@ func caninl(fn *Node) {
 	defer n.Func.SetInlinabilityChecked(true)
 
 	cc := int32(inlineExtraCallCost)
-	if Debug.l == 4 {
+	if Flag.LowerL == 4 {
 		cc = 1 // this appears to yield better performance than 0.
 	}
 
@@ -222,9 +222,9 @@ func caninl(fn *Node) {
 		Body: inlcopylist(fn.Nbody.Slice()),
 	}
 
-	if Debug.m > 1 {
+	if Flag.LowerM > 1 {
 		fmt.Printf("%v: can inline %#v with cost %d as: %#v { %#v }\n", fn.Line(), n, inlineMaxBudget-visitor.budget, fn.Type, asNodes(n.Func.Inl.Body))
-	} else if Debug.m != 0 {
+	} else if Flag.LowerM != 0 {
 		fmt.Printf("%v: can inline %v\n", fn.Line(), n)
 	}
 	if logopt.Enabled() {
@@ -433,7 +433,7 @@ func (v *hairyVisitor) visit(n *Node) bool {
 	v.budget--
 
 	// When debugging, don't stop early, to get full cost of inlining this function
-	if v.budget < 0 && Debug.m < 2 && !logopt.Enabled() {
+	if v.budget < 0 && Flag.LowerM < 2 && !logopt.Enabled() {
 		return true
 	}
 
@@ -676,7 +676,7 @@ func inlnode(n *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 
 	switch n.Op {
 	case OCALLFUNC:
-		if Debug.m > 3 {
+		if Flag.LowerM > 3 {
 			fmt.Printf("%v:call to func %+v\n", n.Line(), n.Left)
 		}
 		if isIntrinsicCall(n) {
@@ -687,7 +687,7 @@ func inlnode(n *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 		}
 
 	case OCALLMETH:
-		if Debug.m > 3 {
+		if Flag.LowerM > 3 {
 			fmt.Printf("%v:call to meth %L\n", n.Line(), n.Left.Right)
 		}
 
@@ -922,7 +922,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	}
 
 	if inlMap[fn] {
-		if Debug.m > 1 {
+		if Flag.LowerM > 1 {
 			fmt.Printf("%v: cannot inline %v into %v: repeated recursive cycle\n", n.Line(), fn, Curfn.funcname())
 		}
 		return n
@@ -936,12 +936,12 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	}
 
 	// We have a function node, and it has an inlineable body.
-	if Debug.m > 1 {
+	if Flag.LowerM > 1 {
 		fmt.Printf("%v: inlining call to %v %#v { %#v }\n", n.Line(), fn.Sym, fn.Type, asNodes(fn.Func.Inl.Body))
-	} else if Debug.m != 0 {
+	} else if Flag.LowerM != 0 {
 		fmt.Printf("%v: inlining call to %v\n", n.Line(), fn)
 	}
-	if Debug.m > 2 {
+	if Flag.LowerM > 2 {
 		fmt.Printf("%v: Before inlining: %+v\n", n.Line(), n)
 	}
 
@@ -1026,7 +1026,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 		}
 		inlf := typecheck(inlvar(ln), ctxExpr)
 		inlvars[ln] = inlf
-		if genDwarfInline > 0 {
+		if Flag.GenDwarfInl > 0 {
 			if ln.Class() == PPARAM {
 				inlf.Name.SetInlFormal(true)
 			} else {
@@ -1064,7 +1064,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 			m = retvar(t, i)
 		}
 
-		if genDwarfInline > 0 {
+		if Flag.GenDwarfInl > 0 {
 			// Don't update the src.Pos on a return variable if it
 			// was manufactured by the inliner (e.g. "~R2"); such vars
 			// were not part of the original callee.
@@ -1165,7 +1165,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	inlMark.Xoffset = int64(newIndex)
 	ninit.Append(inlMark)
 
-	if genDwarfInline > 0 {
+	if Flag.GenDwarfInl > 0 {
 		if !fn.Sym.Linksym().WasInlined() {
 			Ctxt.DwFixups.SetPrecursorFunc(fn.Sym.Linksym(), fn)
 			fn.Sym.Linksym().Set(obj.AttrWasInlined, true)
@@ -1188,7 +1188,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 
 	typecheckslice(body, ctxStmt)
 
-	if genDwarfInline > 0 {
+	if Flag.GenDwarfInl > 0 {
 		for _, v := range inlfvars {
 			v.Pos = subst.updatedPos(v.Pos)
 		}
@@ -1216,7 +1216,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 		}
 	}
 
-	if Debug.m > 2 {
+	if Flag.LowerM > 2 {
 		fmt.Printf("%v: After inlining %+v\n\n", call.Line(), call)
 	}
 
@@ -1227,7 +1227,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 // PAUTO's in the calling functions, and link them off of the
 // PPARAM's, PAUTOS and PPARAMOUTs of the called function.
 func inlvar(var_ *Node) *Node {
-	if Debug.m > 3 {
+	if Flag.LowerM > 3 {
 		fmt.Printf("inlvar %+v\n", var_)
 	}
 
@@ -1310,13 +1310,13 @@ func (subst *inlsubst) node(n *Node) *Node {
 	switch n.Op {
 	case ONAME:
 		if inlvar := subst.inlvars[n]; inlvar != nil { // These will be set during inlnode
-			if Debug.m > 2 {
+			if Flag.LowerM > 2 {
 				fmt.Printf("substituting name %+v  ->  %+v\n", n, inlvar)
 			}
 			return inlvar
 		}
 
-		if Debug.m > 2 {
+		if Flag.LowerM > 2 {
 			fmt.Printf("not substituting name %+v\n", n)
 		}
 		return n
@@ -1449,21 +1449,21 @@ func devirtualizeCall(call *Node) {
 	x = typecheck(x, ctxExpr|ctxCallee)
 	switch x.Op {
 	case ODOTMETH:
-		if Debug.m != 0 {
+		if Flag.LowerM != 0 {
 			Warnl(call.Pos, "devirtualizing %v to %v", call.Left, typ)
 		}
 		call.Op = OCALLMETH
 		call.Left = x
 	case ODOTINTER:
 		// Promoted method from embedded interface-typed field (#42279).
-		if Debug.m != 0 {
+		if Flag.LowerM != 0 {
 			Warnl(call.Pos, "partially devirtualizing %v to %v", call.Left, typ)
 		}
 		call.Op = OCALLINTER
 		call.Left = x
 	default:
 		// TODO(mdempsky): Turn back into Fatalf after more testing.
-		if Debug.m != 0 {
+		if Flag.LowerM != 0 {
 			Warnl(call.Pos, "failed to devirtualize %v (%v)", x, x.Op)
 		}
 		return
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 428bf31fa9..8edc0d4495 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -10,7 +10,7 @@ import (
 	"bufio"
 	"bytes"
 	"cmd/compile/internal/logopt"
-	"cmd/compile/internal/ssa"
+
 	"cmd/compile/internal/types"
 	"cmd/internal/bio"
 	"cmd/internal/dwarf"
@@ -35,12 +35,6 @@ import (
 	"strings"
 )
 
-var (
-	buildid      string
-	spectre      string
-	spectreIndex bool
-)
-
 var (
 	Debug_append       int
 	Debug_checkptr     int
@@ -51,7 +45,6 @@ var (
 	Debug_libfuzzer    int
 	Debug_panic        int
 	Debug_slice        int
-	Debug_vlog         bool
 	Debug_wb           int
 	Debug_pctab        string
 	Debug_locationlist int
@@ -113,12 +106,6 @@ Key "pctab" supports values:
 	"pctospadj", "pctofile", "pctoline", "pctoinline", "pctopcdata"
 `
 
-func usage() {
-	fmt.Fprintf(os.Stderr, "usage: compile [options] file.go...\n")
-	objabi.Flagprint(os.Stderr)
-	Exit(2)
-}
-
 func hidePanic() {
 	if Debug_panic == 0 && Errors() > 0 {
 		// If we've already complained about things
@@ -139,7 +126,6 @@ func supportsDynlink(arch *sys.Arch) bool {
 
 // timing data for compiler phases
 var timings Timings
-var benchfile string
 
 var nowritebarrierrecCheck *nowritebarrierrecChecker
 
@@ -204,321 +190,7 @@ func Main(archInit func(*Arch)) {
 	// pseudo-package used for methods with anonymous receivers
 	gopkg = types.NewPkg("go", "")
 
-	Wasm := objabi.GOARCH == "wasm"
-
-	// Whether the limit for stack-allocated objects is much smaller than normal.
-	// This can be helpful for diagnosing certain causes of GC latency. See #27732.
-	smallFrames := false
-	jsonLogOpt := ""
-
-	flag.BoolVar(&compiling_runtime, "+", false, "compiling runtime")
-	flag.BoolVar(&compiling_std, "std", false, "compiling standard library")
-	flag.StringVar(&localimport, "D", "", "set relative `path` for local imports")
-
-	objabi.Flagcount("%", "debug non-static initializers", &Debug.P)
-	objabi.Flagcount("B", "disable bounds checking", &Debug.B)
-	objabi.Flagcount("C", "disable printing of columns in error messages", &Debug.C)
-	objabi.Flagcount("E", "debug symbol export", &Debug.E)
-	objabi.Flagcount("K", "debug missing line numbers", &Debug.K)
-	objabi.Flagcount("L", "show full file names in error messages", &Debug.L)
-	objabi.Flagcount("N", "disable optimizations", &Debug.N)
-	objabi.Flagcount("S", "print assembly listing", &Debug.S)
-	objabi.Flagcount("W", "debug parse tree after type checking", &Debug.W)
-	objabi.Flagcount("e", "no limit on number of errors reported", &Debug.e)
-	objabi.Flagcount("h", "halt on error", &Debug.h)
-	objabi.Flagcount("j", "debug runtime-initialized variables", &Debug.j)
-	objabi.Flagcount("l", "disable inlining", &Debug.l)
-	objabi.Flagcount("m", "print optimization decisions", &Debug.m)
-	objabi.Flagcount("r", "debug generated wrappers", &Debug.r)
-	objabi.Flagcount("w", "debug type checking", &Debug.w)
-
-	objabi.Flagfn1("I", "add `directory` to import search path", addidir)
-	objabi.AddVersionFlag() // -V
-	flag.StringVar(&asmhdr, "asmhdr", "", "write assembly header to `file`")
-	flag.StringVar(&buildid, "buildid", "", "record `id` as the build id in the export metadata")
-	flag.IntVar(&nBackendWorkers, "c", 1, "concurrency during compilation, 1 means no concurrency")
-	flag.BoolVar(&pure_go, "complete", false, "compiling complete package (no C or assembly)")
-	flag.StringVar(&debugstr, "d", "", "print debug information about items in `list`; try -d help")
-	flag.BoolVar(&flagDWARF, "dwarf", !Wasm, "generate DWARF symbols")
-	flag.BoolVar(&Ctxt.Flag_locationlists, "dwarflocationlists", true, "add location lists to DWARF in optimized mode")
-	flag.IntVar(&genDwarfInline, "gendwarfinl", 2, "generate DWARF inline info records")
-	objabi.Flagfn1("embedcfg", "read go:embed configuration from `file`", readEmbedCfg)
-	objabi.Flagfn1("importmap", "add `definition` of the form source=actual to import map", addImportMap)
-	objabi.Flagfn1("importcfg", "read import configuration from `file`", readImportCfg)
-	flag.StringVar(&flag_installsuffix, "installsuffix", "", "set pkg directory `suffix`")
-	flag.StringVar(&flag_lang, "lang", "", "release to compile for")
-	flag.StringVar(&linkobj, "linkobj", "", "write linker-specific object to `file`")
-	objabi.Flagcount("live", "debug liveness analysis", &debuglive)
-	if sys.MSanSupported(objabi.GOOS, objabi.GOARCH) {
-		flag.BoolVar(&flag_msan, "msan", false, "build code compatible with C/C++ memory sanitizer")
-	}
-	flag.BoolVar(&nolocalimports, "nolocalimports", false, "reject local (relative) imports")
-	flag.StringVar(&outfile, "o", "", "write output to `file`")
-	flag.StringVar(&myimportpath, "p", "", "set expected package import `path`")
-	flag.BoolVar(&writearchive, "pack", false, "write to file.a instead of file.o")
-	if sys.RaceDetectorSupported(objabi.GOOS, objabi.GOARCH) {
-		flag.BoolVar(&flag_race, "race", false, "enable race detector")
-	}
-	flag.StringVar(&spectre, "spectre", spectre, "enable spectre mitigations in `list` (all, index, ret)")
-	if enableTrace {
-		flag.BoolVar(&trace, "t", false, "trace type-checking")
-	}
-	flag.StringVar(&pathPrefix, "trimpath", "", "remove `prefix` from recorded source file paths")
-	flag.BoolVar(&Debug_vlog, "v", false, "increase debug verbosity")
-	flag.BoolVar(&use_writebarrier, "wb", true, "enable write barrier")
-	var flag_shared bool
-	var flag_dynlink bool
-	if supportsDynlink(thearch.LinkArch.Arch) {
-		flag.BoolVar(&flag_shared, "shared", false, "generate code that can be linked into a shared library")
-		flag.BoolVar(&flag_dynlink, "dynlink", false, "support references to Go symbols defined in other shared libraries")
-		flag.BoolVar(&Ctxt.Flag_linkshared, "linkshared", false, "generate code that will be linked against Go shared libraries")
-	}
-	flag.StringVar(&cpuprofile, "cpuprofile", "", "write cpu profile to `file`")
-	flag.StringVar(&memprofile, "memprofile", "", "write memory profile to `file`")
-	flag.Int64Var(&memprofilerate, "memprofilerate", 0, "set runtime.MemProfileRate to `rate`")
-	var goversion string
-	flag.StringVar(&goversion, "goversion", "", "required version of the runtime")
-	var symabisPath string
-	flag.StringVar(&symabisPath, "symabis", "", "read symbol ABIs from `file`")
-	flag.StringVar(&traceprofile, "traceprofile", "", "write an execution trace to `file`")
-	flag.StringVar(&blockprofile, "blockprofile", "", "write block profile to `file`")
-	flag.StringVar(&mutexprofile, "mutexprofile", "", "write mutex profile to `file`")
-	flag.StringVar(&benchfile, "bench", "", "append benchmark times to `file`")
-	flag.BoolVar(&smallFrames, "smallframes", false, "reduce the size limit for stack allocated objects")
-	flag.BoolVar(&Ctxt.UseBASEntries, "dwarfbasentries", Ctxt.UseBASEntries, "use base address selection entries in DWARF")
-	flag.StringVar(&jsonLogOpt, "json", "", "version,destination for JSON compiler/optimizer logging")
-
-	objabi.Flagparse(usage)
-
-	Ctxt.Pkgpath = myimportpath
-
-	for _, f := range strings.Split(spectre, ",") {
-		f = strings.TrimSpace(f)
-		switch f {
-		default:
-			log.Fatalf("unknown setting -spectre=%s", f)
-		case "":
-			// nothing
-		case "all":
-			spectreIndex = true
-			Ctxt.Retpoline = true
-		case "index":
-			spectreIndex = true
-		case "ret":
-			Ctxt.Retpoline = true
-		}
-	}
-
-	if spectreIndex {
-		switch objabi.GOARCH {
-		case "amd64":
-			// ok
-		default:
-			log.Fatalf("GOARCH=%s does not support -spectre=index", objabi.GOARCH)
-		}
-	}
-
-	// Record flags that affect the build result. (And don't
-	// record flags that don't, since that would cause spurious
-	// changes in the binary.)
-	recordFlags("B", "N", "l", "msan", "race", "shared", "dynlink", "dwarflocationlists", "dwarfbasentries", "smallframes", "spectre")
-
-	if smallFrames {
-		maxStackVarSize = 128 * 1024
-		maxImplicitStackVarSize = 16 * 1024
-	}
-
-	Ctxt.Flag_shared = flag_dynlink || flag_shared
-	Ctxt.Flag_dynlink = flag_dynlink
-	Ctxt.Flag_optimize = Debug.N == 0
-
-	Ctxt.Debugasm = Debug.S
-	Ctxt.Debugvlog = Debug_vlog
-	if flagDWARF {
-		Ctxt.DebugInfo = debuginfo
-		Ctxt.GenAbstractFunc = genAbstractFunc
-		Ctxt.DwFixups = obj.NewDwarfFixupTable(Ctxt)
-	} else {
-		// turn off inline generation if no dwarf at all
-		genDwarfInline = 0
-		Ctxt.Flag_locationlists = false
-	}
-
-	if flag.NArg() < 1 && debugstr != "help" && debugstr != "ssa/help" {
-		usage()
-	}
-
-	if goversion != "" && goversion != runtime.Version() {
-		fmt.Printf("compile: version %q does not match go tool version %q\n", runtime.Version(), goversion)
-		Exit(2)
-	}
-
-	checkLang()
-
-	if symabisPath != "" {
-		readSymABIs(symabisPath, myimportpath)
-	}
-
-	thearch.LinkArch.Init(Ctxt)
-
-	if outfile == "" {
-		p := flag.Arg(0)
-		if i := strings.LastIndex(p, "/"); i >= 0 {
-			p = p[i+1:]
-		}
-		if runtime.GOOS == "windows" {
-			if i := strings.LastIndex(p, `\`); i >= 0 {
-				p = p[i+1:]
-			}
-		}
-		if i := strings.LastIndex(p, "."); i >= 0 {
-			p = p[:i]
-		}
-		suffix := ".o"
-		if writearchive {
-			suffix = ".a"
-		}
-		outfile = p + suffix
-	}
-
-	startProfile()
-
-	if flag_race && flag_msan {
-		log.Fatal("cannot use both -race and -msan")
-	}
-	if flag_race || flag_msan {
-		// -race and -msan imply -d=checkptr for now.
-		Debug_checkptr = 1
-	}
-	if ispkgin(omit_pkgs) {
-		flag_race = false
-		flag_msan = false
-	}
-	if flag_race {
-		racepkg = types.NewPkg("runtime/race", "")
-	}
-	if flag_msan {
-		msanpkg = types.NewPkg("runtime/msan", "")
-	}
-	if flag_race || flag_msan {
-		instrumenting = true
-	}
-
-	if compiling_runtime && Debug.N != 0 {
-		log.Fatal("cannot disable optimizations while compiling runtime")
-	}
-	if nBackendWorkers < 1 {
-		log.Fatalf("-c must be at least 1, got %d", nBackendWorkers)
-	}
-	if nBackendWorkers > 1 && !concurrentBackendAllowed() {
-		log.Fatalf("cannot use concurrent backend compilation with provided flags; invoked as %v", os.Args)
-	}
-	if Ctxt.Flag_locationlists && len(Ctxt.Arch.DWARFRegisters) == 0 {
-		log.Fatalf("location lists requested but register mapping not available on %v", Ctxt.Arch.Name)
-	}
-
-	// parse -d argument
-	if debugstr != "" {
-	Split:
-		for _, name := range strings.Split(debugstr, ",") {
-			if name == "" {
-				continue
-			}
-			// display help about the -d option itself and quit
-			if name == "help" {
-				fmt.Print(debugHelpHeader)
-				maxLen := len("ssa/help")
-				for _, t := range debugtab {
-					if len(t.name) > maxLen {
-						maxLen = len(t.name)
-					}
-				}
-				for _, t := range debugtab {
-					fmt.Printf("\t%-*s\t%s\n", maxLen, t.name, t.help)
-				}
-				// ssa options have their own help
-				fmt.Printf("\t%-*s\t%s\n", maxLen, "ssa/help", "print help about SSA debugging")
-				fmt.Print(debugHelpFooter)
-				os.Exit(0)
-			}
-			val, valstring, haveInt := 1, "", true
-			if i := strings.IndexAny(name, "=:"); i >= 0 {
-				var err error
-				name, valstring = name[:i], name[i+1:]
-				val, err = strconv.Atoi(valstring)
-				if err != nil {
-					val, haveInt = 1, false
-				}
-			}
-			for _, t := range debugtab {
-				if t.name != name {
-					continue
-				}
-				switch vp := t.val.(type) {
-				case nil:
-					// Ignore
-				case *string:
-					*vp = valstring
-				case *int:
-					if !haveInt {
-						log.Fatalf("invalid debug value %v", name)
-					}
-					*vp = val
-				default:
-					panic("bad debugtab type")
-				}
-				continue Split
-			}
-			// special case for ssa for now
-			if strings.HasPrefix(name, "ssa/") {
-				// expect form ssa/phase/flag
-				// e.g. -d=ssa/generic_cse/time
-				// _ in phase name also matches space
-				phase := name[4:]
-				flag := "debug" // default flag is debug
-				if i := strings.Index(phase, "/"); i >= 0 {
-					flag = phase[i+1:]
-					phase = phase[:i]
-				}
-				err := ssa.PhaseOption(phase, flag, val, valstring)
-				if err != "" {
-					log.Fatalf(err)
-				}
-				continue Split
-			}
-			log.Fatalf("unknown debug key -d %s\n", name)
-		}
-	}
-
-	if compiling_runtime {
-		// Runtime can't use -d=checkptr, at least not yet.
-		Debug_checkptr = 0
-
-		// Fuzzing the runtime isn't interesting either.
-		Debug_libfuzzer = 0
-	}
-
-	// set via a -d flag
-	Ctxt.Debugpcln = Debug_pctab
-	if flagDWARF {
-		dwarf.EnableLogging(Debug_gendwarfinl != 0)
-	}
-
-	if Debug_softfloat != 0 {
-		thearch.SoftFloat = true
-	}
-
-	// enable inlining.  for now:
-	//	default: inlining on.  (Debug.l == 1)
-	//	-l: inlining off  (Debug.l == 0)
-	//	-l=2, -l=3: inlining on again, with extra debugging (Debug.l > 1)
-	if Debug.l <= 1 {
-		Debug.l = 1 - Debug.l
-	}
-
-	if jsonLogOpt != "" { // parse version,destination from json logging optimization.
-		logopt.LogJsonOption(jsonLogOpt)
-	}
+	ParseFlags()
 
 	ssaDump = os.Getenv("GOSSAFUNC")
 	ssaDir = os.Getenv("GOSSADIR")
@@ -534,7 +206,7 @@ func Main(archInit func(*Arch)) {
 		}
 	}
 
-	trackScopes = flagDWARF
+	trackScopes = Flag.Dwarf
 
 	Widthptr = thearch.LinkArch.PtrSize
 	Widthreg = thearch.LinkArch.RegSize
@@ -674,7 +346,7 @@ func Main(archInit func(*Arch)) {
 		ExitIfErrors()
 	}
 
-	if Debug.l != 0 {
+	if Flag.LowerL != 0 {
 		// Find functions that can be inlined and clone them before walk expands them.
 		visitBottomUp(xtop, func(list []*Node, recursive bool) {
 			numfns := numNonClosures(list)
@@ -685,7 +357,7 @@ func Main(archInit func(*Arch)) {
 					// across more than one function.
 					caninl(n)
 				} else {
-					if Debug.m > 1 {
+					if Flag.LowerM > 1 {
 						fmt.Printf("%v: cannot inline %v: recursive\n", n.Line(), n.Func.Nname)
 					}
 				}
@@ -716,7 +388,7 @@ func Main(archInit func(*Arch)) {
 	// checking. This must happen before transformclosure.
 	// We'll do the final check after write barriers are
 	// inserted.
-	if compiling_runtime {
+	if Flag.CompilingRuntime {
 		nowritebarrierrecCheck = newNowritebarrierrecChecker()
 	}
 
@@ -768,9 +440,9 @@ func Main(archInit func(*Arch)) {
 	// DWARF inlining gen so as to avoid problems with generated
 	// method wrappers.
 	if Ctxt.DwFixups != nil {
-		Ctxt.DwFixups.Finalize(myimportpath, Debug_gendwarfinl != 0)
+		Ctxt.DwFixups.Finalize(Ctxt.Pkgpath, Debug_gendwarfinl != 0)
 		Ctxt.DwFixups = nil
-		genDwarfInline = 0
+		Flag.GenDwarfInl = 0
 	}
 
 	// Phase 9: Check external declarations.
@@ -790,7 +462,7 @@ func Main(archInit func(*Arch)) {
 	dumpdata()
 	Ctxt.NumberSyms()
 	dumpobj()
-	if asmhdr != "" {
+	if Flag.AsmHdr != "" {
 		dumpasmhdr()
 	}
 
@@ -813,14 +485,14 @@ func Main(archInit func(*Arch)) {
 		Fatalf("%d uncompiled functions", len(compilequeue))
 	}
 
-	logopt.FlushLoggedOpts(Ctxt, myimportpath)
+	logopt.FlushLoggedOpts(Ctxt, Ctxt.Pkgpath)
 	ExitIfErrors()
 
 	flusherrors()
 	timings.Stop()
 
-	if benchfile != "" {
-		if err := writebench(benchfile); err != nil {
+	if Flag.Bench != "" {
+		if err := writebench(Flag.Bench); err != nil {
 			log.Fatalf("cannot write benchmark data: %v", err)
 		}
 	}
@@ -847,7 +519,7 @@ func writebench(filename string) error {
 	fmt.Fprintln(&buf, "commit:", objabi.Version)
 	fmt.Fprintln(&buf, "goos:", runtime.GOOS)
 	fmt.Fprintln(&buf, "goarch:", runtime.GOARCH)
-	timings.Write(&buf, "BenchmarkCompile:"+myimportpath+":")
+	timings.Write(&buf, "BenchmarkCompile:"+Ctxt.Pkgpath+":")
 
 	n, err := f.Write(buf.Bytes())
 	if err != nil {
@@ -860,70 +532,6 @@ func writebench(filename string) error {
 	return f.Close()
 }
 
-var (
-	importMap   map[string]string
-	packageFile map[string]string // nil means not in use
-)
-
-func addImportMap(s string) {
-	if importMap == nil {
-		importMap = make(map[string]string)
-	}
-	if strings.Count(s, "=") != 1 {
-		log.Fatal("-importmap argument must be of the form source=actual")
-	}
-	i := strings.Index(s, "=")
-	source, actual := s[:i], s[i+1:]
-	if source == "" || actual == "" {
-		log.Fatal("-importmap argument must be of the form source=actual; source and actual must be non-empty")
-	}
-	importMap[source] = actual
-}
-
-func readImportCfg(file string) {
-	if importMap == nil {
-		importMap = make(map[string]string)
-	}
-	packageFile = map[string]string{}
-	data, err := ioutil.ReadFile(file)
-	if err != nil {
-		log.Fatalf("-importcfg: %v", err)
-	}
-
-	for lineNum, line := range strings.Split(string(data), "\n") {
-		lineNum++ // 1-based
-		line = strings.TrimSpace(line)
-		if line == "" || strings.HasPrefix(line, "#") {
-			continue
-		}
-
-		var verb, args string
-		if i := strings.Index(line, " "); i < 0 {
-			verb = line
-		} else {
-			verb, args = line[:i], strings.TrimSpace(line[i+1:])
-		}
-		var before, after string
-		if i := strings.Index(args, "="); i >= 0 {
-			before, after = args[:i], args[i+1:]
-		}
-		switch verb {
-		default:
-			log.Fatalf("%s:%d: unknown directive %q", file, lineNum, verb)
-		case "importmap":
-			if before == "" || after == "" {
-				log.Fatalf(`%s:%d: invalid importmap: syntax is "importmap old=new"`, file, lineNum)
-			}
-			importMap[before] = after
-		case "packagefile":
-			if before == "" || after == "" {
-				log.Fatalf(`%s:%d: invalid packagefile: syntax is "packagefile path=filename"`, file, lineNum)
-			}
-			packageFile[before] = after
-		}
-	}
-}
-
 // symabiDefs and symabiRefs record the defined and referenced ABIs of
 // symbols required by non-Go code. These are keyed by link symbol
 // name, where the local package prefix is always `"".`
@@ -1009,14 +617,6 @@ func arsize(b *bufio.Reader, name string) int {
 	return i
 }
 
-var idirs []string
-
-func addidir(dir string) {
-	if dir != "" {
-		idirs = append(idirs, dir)
-	}
-}
-
 func isDriveLetter(b byte) bool {
 	return 'a' <= b && b <= 'z' || 'A' <= b && b <= 'Z'
 }
@@ -1031,12 +631,12 @@ func islocalname(name string) bool {
 
 func findpkg(name string) (file string, ok bool) {
 	if islocalname(name) {
-		if nolocalimports {
+		if Flag.NoLocalImports {
 			return "", false
 		}
 
-		if packageFile != nil {
-			file, ok = packageFile[name]
+		if Flag.Cfg.PackageFile != nil {
+			file, ok = Flag.Cfg.PackageFile[name]
 			return file, ok
 		}
 
@@ -1062,12 +662,12 @@ func findpkg(name string) (file string, ok bool) {
 		return "", false
 	}
 
-	if packageFile != nil {
-		file, ok = packageFile[name]
+	if Flag.Cfg.PackageFile != nil {
+		file, ok = Flag.Cfg.PackageFile[name]
 		return file, ok
 	}
 
-	for _, dir := range idirs {
+	for _, dir := range Flag.Cfg.ImportDirs {
 		file = fmt.Sprintf("%s/%s.a", dir, name)
 		if _, err := os.Stat(file); err == nil {
 			return file, true
@@ -1081,13 +681,13 @@ func findpkg(name string) (file string, ok bool) {
 	if objabi.GOROOT != "" {
 		suffix := ""
 		suffixsep := ""
-		if flag_installsuffix != "" {
+		if Flag.InstallSuffix != "" {
 			suffixsep = "_"
-			suffix = flag_installsuffix
-		} else if flag_race {
+			suffix = Flag.InstallSuffix
+		} else if Flag.Race {
 			suffixsep = "_"
 			suffix = "race"
-		} else if flag_msan {
+		} else if Flag.MSan {
 			suffixsep = "_"
 			suffix = "msan"
 		}
@@ -1161,12 +761,12 @@ func importfile(f constant.Value) *types.Pkg {
 		errorexit()
 	}
 
-	if myimportpath != "" && path_ == myimportpath {
+	if Ctxt.Pkgpath != "" && path_ == Ctxt.Pkgpath {
 		yyerror("import %q while compiling that package (import cycle)", path_)
 		errorexit()
 	}
 
-	if mapped, ok := importMap[path_]; ok {
+	if mapped, ok := Flag.Cfg.ImportMap[path_]; ok {
 		path_ = mapped
 	}
 
@@ -1181,8 +781,8 @@ func importfile(f constant.Value) *types.Pkg {
 		}
 
 		prefix := Ctxt.Pathname
-		if localimport != "" {
-			prefix = localimport
+		if Flag.D != "" {
+			prefix = Flag.D
 		}
 		path_ = path.Join(prefix, path_)
 
@@ -1308,7 +908,7 @@ func importfile(f constant.Value) *types.Pkg {
 	}
 
 	// assume files move (get installed) so don't record the full path
-	if packageFile != nil {
+	if Flag.Cfg.PackageFile != nil {
 		// If using a packageFile map, assume path_ can be recorded directly.
 		Ctxt.AddImport(path_, fingerprint)
 	} else {
@@ -1401,47 +1001,10 @@ func IsAlias(sym *types.Sym) bool {
 	return sym.Def != nil && asNode(sym.Def).Sym != sym
 }
 
-// concurrentFlagOk reports whether the current compiler flags
-// are compatible with concurrent compilation.
-func concurrentFlagOk() bool {
-	// TODO(rsc): Many of these are fine. Remove them.
-	return Debug.P == 0 &&
-		Debug.E == 0 &&
-		Debug.K == 0 &&
-		Debug.L == 0 &&
-		Debug.h == 0 &&
-		Debug.j == 0 &&
-		Debug.m == 0 &&
-		Debug.r == 0
-}
-
-func concurrentBackendAllowed() bool {
-	if !concurrentFlagOk() {
-		return false
-	}
-
-	// Debug.S by itself is ok, because all printing occurs
-	// while writing the object file, and that is non-concurrent.
-	// Adding Debug_vlog, however, causes Debug.S to also print
-	// while flushing the plist, which happens concurrently.
-	if Debug_vlog || debugstr != "" || debuglive > 0 {
-		return false
-	}
-	// TODO: Test and delete this condition.
-	if objabi.Fieldtrack_enabled != 0 {
-		return false
-	}
-	// TODO: fix races and enable the following flags
-	if Ctxt.Flag_shared || Ctxt.Flag_dynlink || flag_race {
-		return false
-	}
-	return true
-}
-
 // recordFlags records the specified command-line flags to be placed
 // in the DWARF info.
 func recordFlags(flags ...string) {
-	if myimportpath == "" {
+	if Ctxt.Pkgpath == "" {
 		// We can't record the flags if we don't know what the
 		// package name is.
 		return
@@ -1484,7 +1047,7 @@ func recordFlags(flags ...string) {
 	if cmd.Len() == 0 {
 		return
 	}
-	s := Ctxt.Lookup(dwarf.CUInfoPrefix + "producer." + myimportpath)
+	s := Ctxt.Lookup(dwarf.CUInfoPrefix + "producer." + Ctxt.Pkgpath)
 	s.Type = objabi.SDWARFCUINFO
 	// Sometimes (for example when building tests) we can link
 	// together two package main archives. So allow dups.
@@ -1496,7 +1059,7 @@ func recordFlags(flags ...string) {
 // recordPackageName records the name of the package being
 // compiled, so that the linker can save it in the compile unit's DIE.
 func recordPackageName() {
-	s := Ctxt.Lookup(dwarf.CUInfoPrefix + "packagename." + myimportpath)
+	s := Ctxt.Lookup(dwarf.CUInfoPrefix + "packagename." + Ctxt.Pkgpath)
 	s.Type = objabi.SDWARFCUINFO
 	// Sometimes (for example when building tests) we can link
 	// together two package main archives. So allow dups.
@@ -1505,9 +1068,6 @@ func recordPackageName() {
 	s.P = []byte(localpkg.Name)
 }
 
-// flag_lang is the language version we are compiling for, set by the -lang flag.
-var flag_lang string
-
 // currentLang returns the current language version.
 func currentLang() string {
 	return fmt.Sprintf("go1.%d", goversion.Version)
@@ -1548,23 +1108,23 @@ func langSupported(major, minor int, pkg *types.Pkg) bool {
 // checkLang verifies that the -lang flag holds a valid value, and
 // exits if not. It initializes data used by langSupported.
 func checkLang() {
-	if flag_lang == "" {
+	if Flag.Lang == "" {
 		return
 	}
 
 	var err error
-	langWant, err = parseLang(flag_lang)
+	langWant, err = parseLang(Flag.Lang)
 	if err != nil {
-		log.Fatalf("invalid value %q for -lang: %v", flag_lang, err)
+		log.Fatalf("invalid value %q for -lang: %v", Flag.Lang, err)
 	}
 
-	if def := currentLang(); flag_lang != def {
+	if def := currentLang(); Flag.Lang != def {
 		defVers, err := parseLang(def)
 		if err != nil {
 			log.Fatalf("internal error parsing default lang %q: %v", def, err)
 		}
 		if langWant.major > defVers.major || (langWant.major == defVers.major && langWant.minor > defVers.minor) {
-			log.Fatalf("invalid value %q for -lang: max known version is %q", flag_lang, def)
+			log.Fatalf("invalid value %q for -lang: max known version is %q", Flag.Lang, def)
 		}
 	}
 }
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 47b1958f18..2d3da884a2 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -118,15 +118,13 @@ func (p *noder) yyerrorpos(pos syntax.Pos, format string, args ...interface{}) {
 	yyerrorl(p.makeXPos(pos), format, args...)
 }
 
-var pathPrefix string
-
 // TODO(gri) Can we eliminate fileh in favor of absFilename?
 func fileh(name string) string {
-	return objabi.AbsFile("", name, pathPrefix)
+	return objabi.AbsFile("", name, Flag.TrimPath)
 }
 
 func absFilename(name string) string {
-	return objabi.AbsFile(Ctxt.Pathname, name, pathPrefix)
+	return objabi.AbsFile(Ctxt.Pathname, name, Flag.TrimPath)
 }
 
 // noder transforms package syntax's AST into a Node tree.
@@ -269,10 +267,10 @@ func (p *noder) node() {
 		} else {
 			// Use the default object symbol name if the
 			// user didn't provide one.
-			if myimportpath == "" {
+			if Ctxt.Pkgpath == "" {
 				p.yyerrorpos(n.pos, "//go:linkname requires linkname argument or -p compiler flag")
 			} else {
-				s.Linkname = objabi.PathToPrefix(myimportpath) + "." + n.local
+				s.Linkname = objabi.PathToPrefix(Ctxt.Pkgpath) + "." + n.local
 			}
 		}
 	}
@@ -561,7 +559,7 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) *Node {
 			yyerrorl(f.Pos, "can only use //go:noescape with external func implementations")
 		}
 	} else {
-		if pure_go || strings.HasPrefix(f.funcname(), "init.") {
+		if Flag.Complete || strings.HasPrefix(f.funcname(), "init.") {
 			// Linknamed functions are allowed to have no body. Hopefully
 			// the linkname target has a body. See issue 23311.
 			isLinknamed := false
@@ -1621,7 +1619,7 @@ func (p *noder) pragma(pos syntax.Pos, blankLine bool, text string, old syntax.P
 		// For security, we disallow //go:cgo_* directives other
 		// than cgo_import_dynamic outside cgo-generated files.
 		// Exception: they are allowed in the standard library, for runtime and syscall.
-		if !isCgoGeneratedFile(pos) && !compiling_std {
+		if !isCgoGeneratedFile(pos) && !Flag.Std {
 			p.error(syntax.Error{Pos: pos, Msg: fmt.Sprintf("//%s only allowed in cgo-generated code", text)})
 		}
 		p.pragcgo(pos, text)
@@ -1633,10 +1631,10 @@ func (p *noder) pragma(pos syntax.Pos, blankLine bool, text string, old syntax.P
 		}
 		flag := pragmaFlag(verb)
 		const runtimePragmas = Systemstack | Nowritebarrier | Nowritebarrierrec | Yeswritebarrierrec
-		if !compiling_runtime && flag&runtimePragmas != 0 {
+		if !Flag.CompilingRuntime && flag&runtimePragmas != 0 {
 			p.error(syntax.Error{Pos: pos, Msg: fmt.Sprintf("//%s only allowed in runtime", verb)})
 		}
-		if flag == 0 && !allowedStdPragmas[verb] && compiling_std {
+		if flag == 0 && !allowedStdPragmas[verb] && Flag.Std {
 			p.error(syntax.Error{Pos: pos, Msg: fmt.Sprintf("//%s is not allowed in the standard library", verb)})
 		}
 		pragma.Flag |= flag
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index d51f50ccab..170d997cd6 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -47,12 +47,12 @@ const (
 )
 
 func dumpobj() {
-	if linkobj == "" {
-		dumpobj1(outfile, modeCompilerObj|modeLinkerObj)
+	if Flag.LinkObj == "" {
+		dumpobj1(Flag.LowerO, modeCompilerObj|modeLinkerObj)
 		return
 	}
-	dumpobj1(outfile, modeCompilerObj)
-	dumpobj1(linkobj, modeLinkerObj)
+	dumpobj1(Flag.LowerO, modeCompilerObj)
+	dumpobj1(Flag.LinkObj, modeLinkerObj)
 }
 
 func dumpobj1(outfile string, mode int) {
@@ -79,8 +79,8 @@ func dumpobj1(outfile string, mode int) {
 
 func printObjHeader(bout *bio.Writer) {
 	fmt.Fprintf(bout, "go object %s %s %s %s\n", objabi.GOOS, objabi.GOARCH, objabi.Version, objabi.Expstring())
-	if buildid != "" {
-		fmt.Fprintf(bout, "build id %q\n", buildid)
+	if Flag.BuildID != "" {
+		fmt.Fprintf(bout, "build id %q\n", Flag.BuildID)
 	}
 	if localpkg.Name == "main" {
 		fmt.Fprintf(bout, "main\n")
@@ -261,7 +261,7 @@ func dumpGlobalConst(n *Node) {
 			return
 		}
 	}
-	Ctxt.DwarfIntConst(myimportpath, n.Sym.Name, typesymname(t), int64Val(t, v))
+	Ctxt.DwarfIntConst(Ctxt.Pkgpath, n.Sym.Name, typesymname(t), int64Val(t, v))
 }
 
 func dumpglobls() {
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index a62d468c9c..ee0c8f2711 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -50,7 +50,7 @@ type Order struct {
 // Order rewrites fn.Nbody to apply the ordering constraints
 // described in the comment at the top of the file.
 func order(fn *Node) {
-	if Debug.W > 1 {
+	if Flag.W > 1 {
 		s := fmt.Sprintf("\nbefore order %v", fn.Func.Nname.Sym)
 		dumplist(s, fn.Nbody)
 	}
@@ -323,7 +323,7 @@ func (o *Order) stmtList(l Nodes) {
 // and rewrites it to:
 //  m = OMAKESLICECOPY([]T, x, s); nil
 func orderMakeSliceCopy(s []*Node) {
-	if Debug.N != 0 || instrumenting {
+	if Flag.N != 0 || instrumenting {
 		return
 	}
 
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index 7c1d5543e3..fe13a161bd 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -22,8 +22,7 @@ import (
 // "Portable" code generation.
 
 var (
-	nBackendWorkers int     // number of concurrent backend workers, set by a compiler flag
-	compilequeue    []*Node // functions waiting to be compiled
+	compilequeue []*Node // functions waiting to be compiled
 )
 
 func emitptrargsmap(fn *Node) {
@@ -292,7 +291,7 @@ func compilenow(fn *Node) bool {
 	if fn.IsMethod() && isInlinableButNotInlined(fn) {
 		return false
 	}
-	return nBackendWorkers == 1 && Debug_compilelater == 0
+	return Flag.LowerC == 1 && Debug_compilelater == 0
 }
 
 // isInlinableButNotInlined returns true if 'fn' was marked as an
@@ -375,8 +374,8 @@ func compileFunctions() {
 		}
 		var wg sync.WaitGroup
 		Ctxt.InParallel = true
-		c := make(chan *Node, nBackendWorkers)
-		for i := 0; i < nBackendWorkers; i++ {
+		c := make(chan *Node, Flag.LowerC)
+		for i := 0; i < Flag.LowerC; i++ {
 			wg.Add(1)
 			go func(worker int) {
 				for fn := range c {
@@ -482,7 +481,7 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 
 	scopes := assembleScopes(fnsym, fn, dwarfVars, varScopes)
 	var inlcalls dwarf.InlCalls
-	if genDwarfInline > 0 {
+	if Flag.GenDwarfInl > 0 {
 		inlcalls = assembleInlines(fnsym, dwarfVars)
 	}
 	return scopes, inlcalls
@@ -552,7 +551,7 @@ func createSimpleVar(fnsym *obj.LSym, n *Node) *dwarf.Var {
 	typename := dwarf.InfoPrefix + typesymname(n.Type)
 	delete(fnsym.Func().Autot, ngotype(n).Linksym())
 	inlIndex := 0
-	if genDwarfInline > 1 {
+	if Flag.GenDwarfInl > 1 {
 		if n.Name.InlFormal() || n.Name.InlLocal() {
 			inlIndex = posInlIndex(n.Pos) + 1
 			if n.Name.InlFormal() {
@@ -673,7 +672,7 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *Func, apDecls []*Node)
 			}
 		}
 		inlIndex := 0
-		if genDwarfInline > 1 {
+		if Flag.GenDwarfInl > 1 {
 			if n.Name.InlFormal() || n.Name.InlLocal() {
 				inlIndex = posInlIndex(n.Pos) + 1
 				if n.Name.InlFormal() {
@@ -762,7 +761,7 @@ func createComplexVar(fnsym *obj.LSym, fn *Func, varID ssa.VarID) *dwarf.Var {
 	delete(fnsym.Func().Autot, gotype)
 	typename := dwarf.InfoPrefix + gotype.Name[len("type."):]
 	inlIndex := 0
-	if genDwarfInline > 1 {
+	if Flag.GenDwarfInl > 1 {
 		if n.Name.InlFormal() || n.Name.InlLocal() {
 			inlIndex = posInlIndex(n.Pos) + 1
 			if n.Name.InlFormal() {
diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/gc/plive.go
index a48173e0d6..5f4af06b80 100644
--- a/src/cmd/compile/internal/gc/plive.go
+++ b/src/cmd/compile/internal/gc/plive.go
@@ -509,7 +509,7 @@ func allUnsafe(f *ssa.Func) bool {
 	// go:nosplit functions are similar. Since safe points used to
 	// be coupled with stack checks, go:nosplit often actually
 	// means "no safe points in this function".
-	return compiling_runtime || f.NoSplit
+	return Flag.CompilingRuntime || f.NoSplit
 }
 
 // markUnsafePoints finds unsafe points and computes lv.unsafePoints.
@@ -966,7 +966,7 @@ func (lv *Liveness) compact(b *ssa.Block) {
 }
 
 func (lv *Liveness) showlive(v *ssa.Value, live bvec) {
-	if debuglive == 0 || lv.fn.funcname() == "init" || strings.HasPrefix(lv.fn.funcname(), ".") {
+	if Flag.Live == 0 || lv.fn.funcname() == "init" || strings.HasPrefix(lv.fn.funcname(), ".") {
 		return
 	}
 	if !(v == nil || v.Op.IsCall()) {
@@ -1235,7 +1235,7 @@ func liveness(e *ssafn, f *ssa.Func, pp *Progs) LivenessMap {
 	lv.prologue()
 	lv.solve()
 	lv.epilogue()
-	if debuglive > 0 {
+	if Flag.Live > 0 {
 		lv.showlive(nil, lv.stackMaps[0])
 		for _, b := range f.Blocks {
 			for _, val := range b.Values {
@@ -1245,7 +1245,7 @@ func liveness(e *ssafn, f *ssa.Func, pp *Progs) LivenessMap {
 			}
 		}
 	}
-	if debuglive >= 2 {
+	if Flag.Live >= 2 {
 		lv.printDebug()
 	}
 
diff --git a/src/cmd/compile/internal/gc/print.go b/src/cmd/compile/internal/gc/print.go
index 52585814f6..6b5f670812 100644
--- a/src/cmd/compile/internal/gc/print.go
+++ b/src/cmd/compile/internal/gc/print.go
@@ -59,7 +59,7 @@ func linestr(pos src.XPos) string {
 	if Ctxt == nil {
 		return "???"
 	}
-	return Ctxt.OutermostPos(pos).Format(Debug.C == 0, Debug.L == 1)
+	return Ctxt.OutermostPos(pos).Format(Flag.C == 0, Flag.L == 1)
 }
 
 // byPos sorts errors by source position.
@@ -133,7 +133,7 @@ func yyerrorl(pos src.XPos, format string, args ...interface{}) {
 	numErrors++
 
 	hcrash()
-	if numErrors >= 10 && Debug.e == 0 {
+	if numErrors >= 10 && Flag.LowerE == 0 {
 		flusherrors()
 		fmt.Printf("%v: too many errors\n", linestr(pos))
 		errorexit()
@@ -142,7 +142,7 @@ func yyerrorl(pos src.XPos, format string, args ...interface{}) {
 
 // ErrorfVers reports that a language feature (format, args) requires a later version of Go.
 func yyerrorv(lang string, format string, args ...interface{}) {
-	yyerror("%s requires %s or later (-lang was set to %s; check go.mod)", fmt.Sprintf(format, args...), lang, flag_lang)
+	yyerror("%s requires %s or later (-lang was set to %s; check go.mod)", fmt.Sprintf(format, args...), lang, Flag.Lang)
 }
 
 // UpdateErrorDot is a clumsy hack that rewrites the last error,
@@ -172,7 +172,7 @@ func Warn(format string, args ...interface{}) {
 // to additional output by setting a particular flag.
 func Warnl(pos src.XPos, format string, args ...interface{}) {
 	addErrorMsg(pos, format, args...)
-	if Debug.m != 0 {
+	if Flag.LowerM != 0 {
 		flusherrors()
 	}
 }
@@ -232,10 +232,10 @@ func FatalfAt(pos src.XPos, format string, args ...interface{}) {
 
 // hcrash crashes the compiler when -h is set, to find out where a message is generated.
 func hcrash() {
-	if Debug.h != 0 {
+	if Flag.LowerH != 0 {
 		flusherrors()
-		if outfile != "" {
-			os.Remove(outfile)
+		if Flag.LowerO != "" {
+			os.Remove(Flag.LowerO)
 		}
 		panic("-h")
 	}
@@ -245,8 +245,8 @@ func hcrash() {
 // It flushes any pending errors, removes the output file, and exits.
 func errorexit() {
 	flusherrors()
-	if outfile != "" {
-		os.Remove(outfile)
+	if Flag.LowerO != "" {
+		os.Remove(Flag.LowerO)
 	}
 	os.Exit(2)
 }
diff --git a/src/cmd/compile/internal/gc/racewalk.go b/src/cmd/compile/internal/gc/racewalk.go
index 3552617401..733d19c024 100644
--- a/src/cmd/compile/internal/gc/racewalk.go
+++ b/src/cmd/compile/internal/gc/racewalk.go
@@ -47,9 +47,9 @@ var omit_pkgs = []string{
 var norace_inst_pkgs = []string{"sync", "sync/atomic"}
 
 func ispkgin(pkgs []string) bool {
-	if myimportpath != "" {
+	if Ctxt.Pkgpath != "" {
 		for _, p := range pkgs {
-			if myimportpath == p {
+			if Ctxt.Pkgpath == p {
 				return true
 			}
 		}
@@ -63,11 +63,11 @@ func instrument(fn *Node) {
 		return
 	}
 
-	if !flag_race || !ispkgin(norace_inst_pkgs) {
+	if !Flag.Race || !ispkgin(norace_inst_pkgs) {
 		fn.Func.SetInstrumentBody(true)
 	}
 
-	if flag_race {
+	if Flag.Race {
 		lno := lineno
 		lineno = src.NoXPos
 
diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index 1b4d765d42..44776e988e 100644
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -466,7 +466,7 @@ func walkrange(n *Node) *Node {
 //
 // where == for keys of map m is reflexive.
 func isMapClear(n *Node) bool {
-	if Debug.N != 0 || instrumenting {
+	if Flag.N != 0 || instrumenting {
 		return false
 	}
 
@@ -533,7 +533,7 @@ func mapClear(m *Node) *Node {
 //
 // Parameters are as in walkrange: "for v1, v2 = range a".
 func arrayClear(n, v1, v2, a *Node) bool {
-	if Debug.N != 0 || instrumenting {
+	if Flag.N != 0 || instrumenting {
 		return false
 	}
 
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 1ac7a8490f..674a3bf3fb 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -488,14 +488,14 @@ func dimportpath(p *types.Pkg) {
 	// If we are compiling the runtime package, there are two runtime packages around
 	// -- localpkg and Runtimepkg. We don't want to produce import path symbols for
 	// both of them, so just produce one for localpkg.
-	if myimportpath == "runtime" && p == Runtimepkg {
+	if Ctxt.Pkgpath == "runtime" && p == Runtimepkg {
 		return
 	}
 
 	str := p.Path
 	if p == localpkg {
 		// Note: myimportpath != "", or else dgopkgpath won't call dimportpath.
-		str = myimportpath
+		str = Ctxt.Pkgpath
 	}
 
 	s := Ctxt.Lookup("type..importpath." + p.Prefix + ".")
@@ -510,7 +510,7 @@ func dgopkgpath(s *obj.LSym, ot int, pkg *types.Pkg) int {
 		return duintptr(s, ot, 0)
 	}
 
-	if pkg == localpkg && myimportpath == "" {
+	if pkg == localpkg && Ctxt.Pkgpath == "" {
 		// If we don't know the full import path of the package being compiled
 		// (i.e. -p was not passed on the compiler command line), emit a reference to
 		// type..importpath.""., which the linker will rewrite using the correct import path.
@@ -529,7 +529,7 @@ func dgopkgpathOff(s *obj.LSym, ot int, pkg *types.Pkg) int {
 	if pkg == nil {
 		return duint32(s, ot, 0)
 	}
-	if pkg == localpkg && myimportpath == "" {
+	if pkg == localpkg && Ctxt.Pkgpath == "" {
 		// If we don't know the full import path of the package being compiled
 		// (i.e. -p was not passed on the compiler command line), emit a reference to
 		// type..importpath.""., which the linker will rewrite using the correct import path.
@@ -1158,7 +1158,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 		dupok = obj.DUPOK
 	}
 
-	if myimportpath != "runtime" || (tbase != types.Types[tbase.Etype] && tbase != types.Bytetype && tbase != types.Runetype && tbase != types.Errortype) { // int, float, etc
+	if Ctxt.Pkgpath != "runtime" || (tbase != types.Types[tbase.Etype] && tbase != types.Bytetype && tbase != types.Runetype && tbase != types.Errortype) { // int, float, etc
 		// named types from other files are defined only by those files
 		if tbase.Sym != nil && tbase.Sym.Pkg != localpkg {
 			if i, ok := typeSymIdx[tbase]; ok {
@@ -1613,7 +1613,7 @@ func dumpbasictypes() {
 	// so this is as good as any.
 	// another possible choice would be package main,
 	// but using runtime means fewer copies in object files.
-	if myimportpath == "runtime" {
+	if Ctxt.Pkgpath == "runtime" {
 		for i := types.EType(1); i <= TBOOL; i++ {
 			dtypesym(types.NewPtr(types.Types[i]))
 		}
@@ -1629,10 +1629,10 @@ func dumpbasictypes() {
 		// add paths for runtime and main, which 6l imports implicitly.
 		dimportpath(Runtimepkg)
 
-		if flag_race {
+		if Flag.Race {
 			dimportpath(racepkg)
 		}
-		if flag_msan {
+		if Flag.MSan {
 			dimportpath(msanpkg)
 		}
 		dimportpath(types.NewPkg("main", ""))
diff --git a/src/cmd/compile/internal/gc/select.go b/src/cmd/compile/internal/gc/select.go
index 97e0424ce0..8e6b15af53 100644
--- a/src/cmd/compile/internal/gc/select.go
+++ b/src/cmd/compile/internal/gc/select.go
@@ -255,7 +255,7 @@ func walkselectcases(cases *Nodes) []*Node {
 	order := temp(types.NewArray(types.Types[TUINT16], 2*int64(ncas)))
 
 	var pc0, pcs *Node
-	if flag_race {
+	if Flag.Race {
 		pcs = temp(types.NewArray(types.Types[TUINTPTR], int64(ncas)))
 		pc0 = typecheck(nod(OADDR, nod(OINDEX, pcs, nodintconst(0)), nil), ctxExpr)
 	} else {
@@ -308,7 +308,7 @@ func walkselectcases(cases *Nodes) []*Node {
 
 		// TODO(mdempsky): There should be a cleaner way to
 		// handle this.
-		if flag_race {
+		if Flag.Race {
 			r = mkcall("selectsetpc", nil, nil, nod(OADDR, nod(OINDEX, pcs, nodintconst(int64(i))), nil))
 			init = append(init, r)
 		}
@@ -331,7 +331,7 @@ func walkselectcases(cases *Nodes) []*Node {
 	// selv and order are no longer alive after selectgo.
 	init = append(init, nod(OVARKILL, selv, nil))
 	init = append(init, nod(OVARKILL, order, nil))
-	if flag_race {
+	if Flag.Race {
 		init = append(init, nod(OVARKILL, pcs, nil))
 	}
 
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index e15d558a78..741e0ef9a3 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -40,7 +40,7 @@ func (s *InitSchedule) append(n *Node) {
 // staticInit adds an initialization statement n to the schedule.
 func (s *InitSchedule) staticInit(n *Node) {
 	if !s.tryStaticInit(n) {
-		if Debug.P != 0 {
+		if Flag.Percent != 0 {
 			Dump("nonstatic", n)
 		}
 		s.append(n)
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index f00f5d94a1..260df2f54f 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -60,10 +60,10 @@ func initssaconfig() {
 	_ = types.NewPtr(types.Types[TINT64])                             // *int64
 	_ = types.NewPtr(types.Errortype)                                 // *error
 	types.NewPtrCacheEnabled = false
-	ssaConfig = ssa.NewConfig(thearch.LinkArch.Name, *types_, Ctxt, Debug.N == 0)
+	ssaConfig = ssa.NewConfig(thearch.LinkArch.Name, *types_, Ctxt, Flag.N == 0)
 	ssaConfig.SoftFloat = thearch.SoftFloat
-	ssaConfig.Race = flag_race
-	ssaCaches = make([]ssa.Cache, nBackendWorkers)
+	ssaConfig.Race = Flag.Race
+	ssaCaches = make([]ssa.Cache, Flag.LowerC)
 
 	// Set up some runtime functions we'll need to call.
 	assertE2I = sysfunc("assertE2I")
@@ -291,7 +291,7 @@ func buildssa(fn *Node, worker int) *ssa.Func {
 	name := fn.funcname()
 	printssa := false
 	if ssaDump != "" { // match either a simple name e.g. "(*Reader).Reset", or a package.name e.g. "compress/gzip.(*Reader).Reset"
-		printssa = name == ssaDump || myimportpath+"."+name == ssaDump
+		printssa = name == ssaDump || Ctxt.Pkgpath+"."+name == ssaDump
 	}
 	var astBuf *bytes.Buffer
 	if printssa {
@@ -342,7 +342,7 @@ func buildssa(fn *Node, worker int) *ssa.Func {
 	if printssa {
 		ssaDF := ssaDumpFile
 		if ssaDir != "" {
-			ssaDF = filepath.Join(ssaDir, myimportpath+"."+name+".html")
+			ssaDF = filepath.Join(ssaDir, Ctxt.Pkgpath+"."+name+".html")
 			ssaD := filepath.Dir(ssaDF)
 			os.MkdirAll(ssaD, 0755)
 		}
@@ -358,7 +358,7 @@ func buildssa(fn *Node, worker int) *ssa.Func {
 	s.fwdVars = map[*Node]*ssa.Value{}
 	s.startmem = s.entryNewValue0(ssa.OpInitMem, types.TypeMem)
 
-	s.hasOpenDefers = Debug.N == 0 && s.hasdefer && !s.curfn.Func.OpenCodedDeferDisallowed()
+	s.hasOpenDefers = Flag.N == 0 && s.hasdefer && !s.curfn.Func.OpenCodedDeferDisallowed()
 	switch {
 	case s.hasOpenDefers && (Ctxt.Flag_shared || Ctxt.Flag_dynlink) && thearch.LinkArch.Name == "386":
 		// Don't support open-coded defers for 386 ONLY when using shared
@@ -752,7 +752,7 @@ func (s *state) pushLine(line src.XPos) {
 		// the frontend may emit node with line number missing,
 		// use the parent line number in this case.
 		line = s.peekPos()
-		if Debug.K != 0 {
+		if Flag.K != 0 {
 			Warn("buildssa: unknown position (line 0)")
 		}
 	} else {
@@ -988,13 +988,13 @@ func (s *state) instrument(t *types.Type, addr *ssa.Value, wr bool) {
 	var fn *obj.LSym
 	needWidth := false
 
-	if flag_msan {
+	if Flag.MSan {
 		fn = msanread
 		if wr {
 			fn = msanwrite
 		}
 		needWidth = true
-	} else if flag_race && t.NumComponents(types.CountBlankFields) > 1 {
+	} else if Flag.Race && t.NumComponents(types.CountBlankFields) > 1 {
 		// for composite objects we have to write every address
 		// because a write might happen to any subobject.
 		// composites with only one element don't have subobjects, though.
@@ -1003,7 +1003,7 @@ func (s *state) instrument(t *types.Type, addr *ssa.Value, wr bool) {
 			fn = racewriterange
 		}
 		needWidth = true
-	} else if flag_race {
+	} else if Flag.Race {
 		// for non-composite objects we can write just the start
 		// address, as any write must write the first byte.
 		fn = raceread
@@ -1090,7 +1090,7 @@ func (s *state) stmt(n *Node) {
 	case OCALLMETH, OCALLINTER:
 		s.callResult(n, callNormal)
 		if n.Op == OCALLFUNC && n.Left.Op == ONAME && n.Left.Class() == PFUNC {
-			if fn := n.Left.Sym.Name; compiling_runtime && fn == "throw" ||
+			if fn := n.Left.Sym.Name; Flag.CompilingRuntime && fn == "throw" ||
 				n.Left.Sym.Pkg == Runtimepkg && (fn == "throwinit" || fn == "gopanic" || fn == "panicwrap" || fn == "block" || fn == "panicmakeslicelen" || fn == "panicmakeslicecap") {
 				m := s.mem()
 				b := s.endBlock()
@@ -1225,7 +1225,7 @@ func (s *state) stmt(n *Node) {
 				// Check whether we're writing the result of an append back to the same slice.
 				// If so, we handle it specially to avoid write barriers on the fast
 				// (non-growth) path.
-				if !samesafeexpr(n.Left, rhs.List.First()) || Debug.N != 0 {
+				if !samesafeexpr(n.Left, rhs.List.First()) || Flag.N != 0 {
 					break
 				}
 				// If the slice can be SSA'd, it'll be on the stack,
@@ -4130,9 +4130,9 @@ func findIntrinsic(sym *types.Sym) intrinsicBuilder {
 	}
 	pkg := sym.Pkg.Path
 	if sym.Pkg == localpkg {
-		pkg = myimportpath
+		pkg = Ctxt.Pkgpath
 	}
-	if flag_race && pkg == "sync/atomic" {
+	if Flag.Race && pkg == "sync/atomic" {
 		// The race detector needs to be able to intercept these calls.
 		// We can't intrinsify them.
 		return nil
@@ -4930,7 +4930,7 @@ func (s *state) addr(n *Node) *ssa.Value {
 // canSSA reports whether n is SSA-able.
 // n must be an ONAME (or an ODOT sequence with an ONAME base).
 func (s *state) canSSA(n *Node) bool {
-	if Debug.N != 0 {
+	if Flag.N != 0 {
 		return false
 	}
 	for n.Op == ODOT || (n.Op == OINDEX && n.Left.Type.IsArray()) {
@@ -5041,7 +5041,7 @@ func (s *state) nilCheck(ptr *ssa.Value) {
 func (s *state) boundsCheck(idx, len *ssa.Value, kind ssa.BoundsKind, bounded bool) *ssa.Value {
 	idx = s.extendIndex(idx, len, kind, bounded)
 
-	if bounded || Debug.B != 0 {
+	if bounded || Flag.B != 0 {
 		// If bounded or bounds checking is flag-disabled, then no check necessary,
 		// just return the extended index.
 		//
@@ -5114,7 +5114,7 @@ func (s *state) boundsCheck(idx, len *ssa.Value, kind ssa.BoundsKind, bounded bo
 	s.startBlock(bNext)
 
 	// In Spectre index mode, apply an appropriate mask to avoid speculative out-of-bounds accesses.
-	if spectreIndex {
+	if Flag.Cfg.SpectreIndex {
 		op := ssa.OpSpectreIndex
 		if kind != ssa.BoundsIndex && kind != ssa.BoundsIndexU {
 			op = ssa.OpSpectreSliceIndex
@@ -6235,7 +6235,7 @@ func emitStackObjects(e *ssafn, pp *Progs) {
 	p.To.Name = obj.NAME_EXTERN
 	p.To.Sym = x
 
-	if debuglive != 0 {
+	if Flag.Live != 0 {
 		for _, v := range vars {
 			Warnl(v.Pos, "stack object %v %s", v, v.Type.String())
 		}
@@ -6397,7 +6397,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 		}
 		// Emit control flow instructions for block
 		var next *ssa.Block
-		if i < len(f.Blocks)-1 && Debug.N == 0 {
+		if i < len(f.Blocks)-1 && Flag.N == 0 {
 			// If -N, leave next==nil so every block with successors
 			// ends in a JMP (except call blocks - plive doesn't like
 			// select{send,recv} followed by a JMP call).  Helps keep
@@ -6705,7 +6705,7 @@ func (s *state) extendIndex(idx, len *ssa.Value, kind ssa.BoundsKind, bounded bo
 		} else {
 			lo = s.newValue1(ssa.OpInt64Lo, types.Types[TUINT], idx)
 		}
-		if bounded || Debug.B != 0 {
+		if bounded || Flag.B != 0 {
 			return lo
 		}
 		bNext := s.f.NewBlock(ssa.BlockPlain)
@@ -7117,7 +7117,7 @@ func (e *ssafn) Debug_checknil() bool {
 }
 
 func (e *ssafn) UseWriteBarrier() bool {
-	return use_writebarrier
+	return Flag.WB
 }
 
 func (e *ssafn) Syslook(name string) *obj.LSym {
@@ -7142,7 +7142,7 @@ func (e *ssafn) SetWBPos(pos src.XPos) {
 }
 
 func (e *ssafn) MyImportPath() string {
-	return myimportpath
+	return Ctxt.Pkgpath
 }
 
 func (n *Node) Typ() *types.Type {
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index ebc5af63e1..32312e9545 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -49,7 +49,7 @@ func hasUniquePos(n *Node) bool {
 	}
 
 	if !n.Pos.IsKnown() {
-		if Debug.K != 0 {
+		if Flag.K != 0 {
 			Warn("setlineno: unknown position (line 0)")
 		}
 		return false
@@ -1334,7 +1334,7 @@ func structargs(tl *types.Type, mustname bool) []*Node {
 //	method - M func (t T)(), a TFIELD type struct
 //	newnam - the eventual mangled name of this function
 func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
-	if false && Debug.r != 0 {
+	if false && Flag.LowerR != 0 {
 		fmt.Printf("genwrapper rcvrtype=%v method=%v newnam=%v\n", rcvr, method, newnam)
 	}
 
@@ -1407,7 +1407,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 		fn.Nbody.Append(call)
 	}
 
-	if false && Debug.r != 0 {
+	if false && Flag.LowerR != 0 {
 		dumplist("genwrapper body", fn.Nbody)
 	}
 
@@ -1548,7 +1548,7 @@ func implements(t, iface *types.Type, m, samename **types.Field, ptr *int) bool
 		// the method does not exist for value types.
 		rcvr := tm.Type.Recv().Type
 		if rcvr.IsPtr() && !t0.IsPtr() && !followptr && !isifacemethod(tm.Type) {
-			if false && Debug.r != 0 {
+			if false && Flag.LowerR != 0 {
 				yyerror("interface pointer mismatch")
 			}
 
diff --git a/src/cmd/compile/internal/gc/syntax.go b/src/cmd/compile/internal/gc/syntax.go
index 65ae7f23d8..75a7ae2c7a 100644
--- a/src/cmd/compile/internal/gc/syntax.go
+++ b/src/cmd/compile/internal/gc/syntax.go
@@ -284,7 +284,7 @@ func (n *Node) Val() constant.Value {
 // which must not have been used with SetOpt.
 func (n *Node) SetVal(v constant.Value) {
 	if n.HasOpt() {
-		Debug.h = 1
+		Flag.LowerH = 1
 		Dump("have Opt", n)
 		Fatalf("have Opt")
 	}
@@ -314,7 +314,7 @@ func (n *Node) SetOpt(x interface{}) {
 		return
 	}
 	if n.HasVal() {
-		Debug.h = 1
+		Flag.LowerH = 1
 		Dump("have Val", n)
 		Fatalf("have Val")
 	}
@@ -367,7 +367,7 @@ func (n *Node) pkgFuncName() string {
 	}
 	pkg := s.Pkg
 
-	p := myimportpath
+	p := Ctxt.Pkgpath
 	if pkg != nil && pkg.Path != "" {
 		p = pkg.Path
 	}
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index a4acdfaed3..7b299e553b 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -15,7 +15,6 @@ import (
 // To enable tracing support (-t flag), set enableTrace to true.
 const enableTrace = false
 
-var trace bool
 var traceIndent []byte
 var skipDowidthForTracing bool
 
@@ -85,7 +84,7 @@ func resolve(n *Node) (res *Node) {
 	}
 
 	// only trace if there's work to do
-	if enableTrace && trace {
+	if enableTrace && Flag.LowerT {
 		defer tracePrint("resolve", n)(&res)
 	}
 
@@ -212,7 +211,7 @@ func typecheck(n *Node, top int) (res *Node) {
 	}
 
 	// only trace if there's work to do
-	if enableTrace && trace {
+	if enableTrace && Flag.LowerT {
 		defer tracePrint("typecheck", n)(&res)
 	}
 
@@ -326,7 +325,7 @@ func indexlit(n *Node) *Node {
 // The result of typecheck1 MUST be assigned back to n, e.g.
 // 	n.Left = typecheck1(n.Left, top)
 func typecheck1(n *Node, top int) (res *Node) {
-	if enableTrace && trace {
+	if enableTrace && Flag.LowerT {
 		defer tracePrint("typecheck1", n)(&res)
 	}
 
@@ -2359,7 +2358,7 @@ func lookdot1(errnode *Node, s *types.Sym, t *types.Type, fs *types.Fields, dost
 // typecheckMethodExpr checks selector expressions (ODOT) where the
 // base expression is a type expression (OTYPE).
 func typecheckMethodExpr(n *Node) (res *Node) {
-	if enableTrace && trace {
+	if enableTrace && Flag.LowerT {
 		defer tracePrint("typecheckMethodExpr", n)(&res)
 	}
 
@@ -2797,7 +2796,7 @@ func pushtype(n *Node, t *types.Type) *Node {
 // The result of typecheckcomplit MUST be assigned back to n, e.g.
 // 	n.Left = typecheckcomplit(n.Left)
 func typecheckcomplit(n *Node) (res *Node) {
-	if enableTrace && trace {
+	if enableTrace && Flag.LowerT {
 		defer tracePrint("typecheckcomplit", n)(&res)
 	}
 
@@ -3215,7 +3214,7 @@ func samesafeexpr(l *Node, r *Node) bool {
 // if this assignment is the definition of a var on the left side,
 // fill in the var's type.
 func typecheckas(n *Node) {
-	if enableTrace && trace {
+	if enableTrace && Flag.LowerT {
 		defer tracePrint("typecheckas", n)(nil)
 	}
 
@@ -3273,7 +3272,7 @@ func checkassignto(src *types.Type, dst *Node) {
 }
 
 func typecheckas2(n *Node) {
-	if enableTrace && trace {
+	if enableTrace && Flag.LowerT {
 		defer tracePrint("typecheckas2", n)(nil)
 	}
 
@@ -3406,7 +3405,7 @@ out:
 
 // type check function definition
 func typecheckfunc(n *Node) {
-	if enableTrace && trace {
+	if enableTrace && Flag.LowerT {
 		defer tracePrint("typecheckfunc", n)(nil)
 	}
 
@@ -3520,7 +3519,7 @@ func setUnderlying(t, underlying *types.Type) {
 }
 
 func typecheckdeftype(n *Node) {
-	if enableTrace && trace {
+	if enableTrace && Flag.LowerT {
 		defer tracePrint("typecheckdeftype", n)(nil)
 	}
 
@@ -3540,7 +3539,7 @@ func typecheckdeftype(n *Node) {
 }
 
 func typecheckdef(n *Node) {
-	if enableTrace && trace {
+	if enableTrace && Flag.LowerT {
 		defer tracePrint("typecheckdef", n)(nil)
 	}
 
diff --git a/src/cmd/compile/internal/gc/util.go b/src/cmd/compile/internal/gc/util.go
index 58be2f8253..d1a5993daf 100644
--- a/src/cmd/compile/internal/gc/util.go
+++ b/src/cmd/compile/internal/gc/util.go
@@ -32,18 +32,13 @@ func Exit(code int) {
 }
 
 var (
-	blockprofile   string
-	cpuprofile     string
-	memprofile     string
 	memprofilerate int64
-	traceprofile   string
 	traceHandler   func(string)
-	mutexprofile   string
 )
 
 func startProfile() {
-	if cpuprofile != "" {
-		f, err := os.Create(cpuprofile)
+	if Flag.CPUProfile != "" {
+		f, err := os.Create(Flag.CPUProfile)
 		if err != nil {
 			Fatalf("%v", err)
 		}
@@ -52,11 +47,11 @@ func startProfile() {
 		}
 		atExit(pprof.StopCPUProfile)
 	}
-	if memprofile != "" {
+	if Flag.MemProfile != "" {
 		if memprofilerate != 0 {
 			runtime.MemProfileRate = int(memprofilerate)
 		}
-		f, err := os.Create(memprofile)
+		f, err := os.Create(Flag.MemProfile)
 		if err != nil {
 			Fatalf("%v", err)
 		}
@@ -75,8 +70,8 @@ func startProfile() {
 		// Not doing memory profiling; disable it entirely.
 		runtime.MemProfileRate = 0
 	}
-	if blockprofile != "" {
-		f, err := os.Create(blockprofile)
+	if Flag.BlockProfile != "" {
+		f, err := os.Create(Flag.BlockProfile)
 		if err != nil {
 			Fatalf("%v", err)
 		}
@@ -86,8 +81,8 @@ func startProfile() {
 			f.Close()
 		})
 	}
-	if mutexprofile != "" {
-		f, err := os.Create(mutexprofile)
+	if Flag.MutexProfile != "" {
+		f, err := os.Create(Flag.MutexProfile)
 		if err != nil {
 			Fatalf("%v", err)
 		}
@@ -97,7 +92,7 @@ func startProfile() {
 			f.Close()
 		})
 	}
-	if traceprofile != "" && traceHandler != nil {
-		traceHandler(traceprofile)
+	if Flag.TraceProfile != "" && traceHandler != nil {
+		traceHandler(Flag.TraceProfile)
 	}
 }
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index b1bac06fd0..c2d8411a59 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -24,7 +24,7 @@ func walk(fn *Node) {
 	Curfn = fn
 	errorsBefore := Errors()
 
-	if Debug.W != 0 {
+	if Flag.W != 0 {
 		s := fmt.Sprintf("\nbefore walk %v", Curfn.Func.Nname.Sym)
 		dumplist(s, Curfn.Nbody)
 	}
@@ -66,14 +66,14 @@ func walk(fn *Node) {
 		return
 	}
 	walkstmtlist(Curfn.Nbody.Slice())
-	if Debug.W != 0 {
+	if Flag.W != 0 {
 		s := fmt.Sprintf("after walk %v", Curfn.Func.Nname.Sym)
 		dumplist(s, Curfn.Nbody)
 	}
 
 	zeroResults()
 	heapmoves()
-	if Debug.W != 0 && Curfn.Func.Enter.Len() > 0 {
+	if Flag.W != 0 && Curfn.Func.Enter.Len() > 0 {
 		s := fmt.Sprintf("enter %v", Curfn.Func.Nname.Sym)
 		dumplist(s, Curfn.Func.Enter)
 	}
@@ -186,7 +186,7 @@ func walkstmt(n *Node) *Node {
 	case ODCL:
 		v := n.Left
 		if v.Class() == PAUTOHEAP {
-			if compiling_runtime {
+			if Flag.CompilingRuntime {
 				yyerror("%v escapes to heap, not allowed in runtime", v)
 			}
 			if prealloc[v] == nil {
@@ -439,7 +439,7 @@ func walkexpr(n *Node, init *Nodes) *Node {
 
 	lno := setlineno(n)
 
-	if Debug.w > 1 {
+	if Flag.LowerW > 1 {
 		Dump("before walk expr", n)
 	}
 
@@ -1046,7 +1046,7 @@ opswitch:
 		}
 		if t.IsArray() {
 			n.SetBounded(bounded(r, t.NumElem()))
-			if Debug.m != 0 && n.Bounded() && !Isconst(n.Right, constant.Int) {
+			if Flag.LowerM != 0 && n.Bounded() && !Isconst(n.Right, constant.Int) {
 				Warn("index bounds check elided")
 			}
 			if smallintconst(n.Right) && !n.Bounded() {
@@ -1054,7 +1054,7 @@ opswitch:
 			}
 		} else if Isconst(n.Left, constant.String) {
 			n.SetBounded(bounded(r, int64(len(n.Left.StringVal()))))
-			if Debug.m != 0 && n.Bounded() && !Isconst(n.Right, constant.Int) {
+			if Flag.LowerM != 0 && n.Bounded() && !Isconst(n.Right, constant.Int) {
 				Warn("index bounds check elided")
 			}
 			if smallintconst(n.Right) && !n.Bounded() {
@@ -1174,7 +1174,7 @@ opswitch:
 		Fatalf("append outside assignment")
 
 	case OCOPY:
-		n = copyany(n, init, instrumenting && !compiling_runtime)
+		n = copyany(n, init, instrumenting && !Flag.CompilingRuntime)
 
 		// cannot use chanfn - closechan takes any, not chan any
 	case OCLOSE:
@@ -1596,7 +1596,7 @@ opswitch:
 
 	updateHasCall(n)
 
-	if Debug.w != 0 && n != nil {
+	if Flag.LowerW != 0 && n != nil {
 		Dump("after walk expr", n)
 	}
 
@@ -2784,7 +2784,7 @@ func appendslice(n *Node, init *Nodes) *Node {
 		ptr1, len1 := nptr1.backingArrayPtrLen()
 		ptr2, len2 := nptr2.backingArrayPtrLen()
 		ncopy = mkcall1(fn, types.Types[TINT], &nodes, typename(elemtype), ptr1, len1, ptr2, len2)
-	} else if instrumenting && !compiling_runtime {
+	} else if instrumenting && !Flag.CompilingRuntime {
 		// rely on runtime to instrument:
 		//  copy(s[len(l1):], l2)
 		// l2 can be a slice or string.
@@ -2827,7 +2827,7 @@ func appendslice(n *Node, init *Nodes) *Node {
 // isAppendOfMake reports whether n is of the form append(x , make([]T, y)...).
 // isAppendOfMake assumes n has already been typechecked.
 func isAppendOfMake(n *Node) bool {
-	if Debug.N != 0 || instrumenting {
+	if Flag.N != 0 || instrumenting {
 		return false
 	}
 
@@ -3036,7 +3036,7 @@ func walkappend(n *Node, init *Nodes, dst *Node) *Node {
 
 	// General case, with no function calls left as arguments.
 	// Leave for gen, except that instrumentation requires old form.
-	if !instrumenting || compiling_runtime {
+	if !instrumenting || Flag.CompilingRuntime {
 		return n
 	}
 
@@ -3991,7 +3991,7 @@ func canMergeLoads() bool {
 // isRuneCount reports whether n is of the form len([]rune(string)).
 // These are optimized into a call to runtime.countrunes.
 func isRuneCount(n *Node) bool {
-	return Debug.N == 0 && !instrumenting && n.Op == OLEN && n.Left.Op == OSTR2RUNES
+	return Flag.N == 0 && !instrumenting && n.Op == OLEN && n.Left.Op == OSTR2RUNES
 }
 
 func walkCheckPtrAlignment(n *Node, init *Nodes, count *Node) *Node {
-- 
GitLab


From 259fd8adbb15f2a44433c7b8b40a35e97992b345 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 24 Nov 2020 21:56:47 -0800
Subject: [PATCH 0063/2400] [dev.regabi] cmd/compile: fix reporting of overflow

In the previous CL, I had incorrectly removed one of the error
messages from issue20232.go, because I thought go/constant was just
handling it. But actually the compiler was panicking in nodlit,
because it didn't handle constant.Unknown. So this CL makes it leave
n.Type == nil for unknown constant.Values.

While here, also address #42732 by making sure to report an error
message when origConst is called with an unknown constant.Value (as
can happen when multiplying two floating-point constants overflows).

Finally, add OXOR and OBITNOT to the list of operations to report
errors about, since they're also constant expressions that can produce
a constant with a greater bit length than their operands.

Fixes #42732.

Change-Id: I4a538fbae9b3ac4c553d7de5625dc0c87d9acce3
Reviewed-on: https://go-review.googlesource.com/c/go/+/272928
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/gc/const.go | 45 +++++++++++++---------------
 test/const2.go                       | 11 +++++++
 test/fixedbugs/issue20232.go         |  5 ++--
 3 files changed, 35 insertions(+), 26 deletions(-)

diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 84f0b11712..e72962124a 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -718,11 +718,14 @@ func square(x constant.Value) constant.Value {
 }
 
 // For matching historical "constant OP overflow" error messages.
+// TODO(mdempsky): Replace with error messages like go/types uses.
 var overflowNames = [...]string{
-	OADD: "addition",
-	OSUB: "subtraction",
-	OMUL: "multiplication",
-	OLSH: "shift",
+	OADD:    "addition",
+	OSUB:    "subtraction",
+	OMUL:    "multiplication",
+	OLSH:    "shift",
+	OXOR:    "bitwise XOR",
+	OBITNOT: "bitwise complement",
 }
 
 // origConst returns an OLITERAL with orig n and value v.
@@ -732,32 +735,24 @@ func origConst(n *Node, v constant.Value) *Node {
 	lineno = lno
 
 	switch v.Kind() {
+	case constant.Int:
+		if constant.BitLen(v) <= Mpprec {
+			break
+		}
+		fallthrough
 	case constant.Unknown:
-		// If constant folding was attempted (we were called)
-		// but it produced an invalid constant value,
-		// mark n as broken and give up.
-		if Errors() == 0 {
-			Fatalf("should have reported an error")
+		what := overflowNames[n.Op]
+		if what == "" {
+			Fatalf("unexpected overflow: %v", n.Op)
 		}
+		yyerrorl(n.Pos, "constant %v overflow", what)
 		n.Type = nil
 		return n
-
-	case constant.Int:
-		if constant.BitLen(v) > Mpprec {
-			what := overflowNames[n.Op]
-			if what == "" {
-				Fatalf("unexpected overflow: %v", n.Op)
-			}
-			yyerror("constant %v overflow", what)
-			n.Type = nil
-			return n
-		}
 	}
 
 	orig := n
-	n = nod(OLITERAL, nil, nil)
+	n = nodl(orig.Pos, OLITERAL, nil, nil)
 	n.Orig = orig
-	n.Pos = orig.Pos
 	n.Type = orig.Type
 	n.SetVal(v)
 	return n
@@ -800,8 +795,10 @@ func origIntConst(n *Node, v int64) *Node {
 // nodlit returns a new untyped constant with value v.
 func nodlit(v constant.Value) *Node {
 	n := nod(OLITERAL, nil, nil)
-	n.Type = idealType(v.Kind())
-	n.SetVal(v)
+	if k := v.Kind(); k != constant.Unknown {
+		n.Type = idealType(k)
+		n.SetVal(v)
+	}
 	return n
 }
 
diff --git a/test/const2.go b/test/const2.go
index 048d0cb9f3..d104a2fa71 100644
--- a/test/const2.go
+++ b/test/const2.go
@@ -19,3 +19,14 @@ const LargeB = LargeA * LargeA * LargeA
 const LargeC = LargeB * LargeB * LargeB // GC_ERROR "constant multiplication overflow"
 
 const AlsoLargeA = LargeA << 400 << 400 >> 400 >> 400 // GC_ERROR "constant shift overflow"
+
+// Issue #42732.
+
+const a = 1e+500000000
+const b = a * a // ERROR "constant multiplication overflow"
+const c = b * b
+
+const MaxInt512 = (1<<256 - 1) * (1<<256 + 1)
+const _ = MaxInt512 + 1  // ERROR "constant addition overflow"
+const _ = MaxInt512 ^ -1 // ERROR "constant bitwise XOR overflow"
+const _ = ^MaxInt512     // ERROR "constant bitwise complement overflow"
diff --git a/test/fixedbugs/issue20232.go b/test/fixedbugs/issue20232.go
index fbe8cdebfb..7a0300a4c4 100644
--- a/test/fixedbugs/issue20232.go
+++ b/test/fixedbugs/issue20232.go
@@ -6,6 +6,7 @@
 
 package main
 
-const _ = 6e5518446744 // ERROR "malformed constant: 6e5518446744"
+const x = 6e5518446744 // ERROR "malformed constant: 6e5518446744"
+const _ = x * x
 const _ = 1e-1000000000
-const _ = 1e+1000000000
+const _ = 1e+1000000000 // ERROR "malformed constant: 1e\+1000000000"
-- 
GitLab


From 756661c82a2ffa285c16f36d5a5290e057fa75bd Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 16 Nov 2020 01:15:33 -0500
Subject: [PATCH 0064/2400] [dev.regabi] cmd/compile: finish cleanup of Flag
 initialization

Now that all flags are in a struct, use struct tags to set the usage messages
and use reflection to walk the struct and register all the flags.

Also move some flag usage back into main.go that shouldn't
come with the rest of flag.go into package base.

Change-Id: Ie655582194906c9ab425c3d01ad8c304bc49bfe0
Reviewed-on: https://go-review.googlesource.com/c/go/+/271668
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/fmtmap_test.go      |   1 +
 src/cmd/compile/internal/gc/flag.go | 447 ++++++++++++++--------------
 src/cmd/compile/internal/gc/main.go |  75 ++++-
 3 files changed, 298 insertions(+), 225 deletions(-)

diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
index 691eee3a1b..e32233bcaf 100644
--- a/src/cmd/compile/fmtmap_test.go
+++ b/src/cmd/compile/fmtmap_test.go
@@ -168,6 +168,7 @@ var knownFormats = map[string]string{
 	"map[int64]uint32 %v":  "",
 	"math/big.Accuracy %s": "",
 	"reflect.Type %s":      "",
+	"reflect.Type %v":      "",
 	"rune %#U":             "",
 	"rune %c":              "",
 	"rune %q":              "",
diff --git a/src/cmd/compile/internal/gc/flag.go b/src/cmd/compile/internal/gc/flag.go
index 3861c9a028..090287ef62 100644
--- a/src/cmd/compile/internal/gc/flag.go
+++ b/src/cmd/compile/internal/gc/flag.go
@@ -11,15 +11,12 @@ import (
 	"io/ioutil"
 	"log"
 	"os"
+	"reflect"
 	"runtime"
 	"strconv"
 	"strings"
 
-	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
-	"cmd/compile/internal/types"
-	"cmd/internal/dwarf"
-	"cmd/internal/obj"
 	"cmd/internal/objabi"
 	"cmd/internal/sys"
 )
@@ -30,195 +27,153 @@ func usage() {
 	Exit(2)
 }
 
-var Flag Flags
-
-// gc debug flags
-type Flags struct {
-	Percent, B, C, E,
-	K, L, N, S,
-	W, LowerE, LowerH, LowerJ,
-	LowerL, LowerM, LowerR, LowerW int
-	CompilingRuntime bool
-	Std              bool
-	D                string
-	AsmHdr           string
-	BuildID          string
-	LowerC           int
-	Complete         bool
-	LowerD           string
-	Dwarf            bool
-	GenDwarfInl      int
-	InstallSuffix    string
-	Lang             string
-	LinkObj          string
-	Live             int
-	MSan             bool
-	NoLocalImports   bool
-	LowerO           string
-	Pack             bool
-	Race             bool
-	Spectre          string
-	LowerT           bool
-	TrimPath         string
-	WB               bool
-	Shared           bool
-	Dynlink          bool
-	GoVersion        string
-	SymABIs          string
-	CPUProfile       string
-	MemProfile       string
-	TraceProfile     string
-	BlockProfile     string
-	MutexProfile     string
-	Bench            string
-	SmallFrames      bool
-	JSON             string
-
+// Flag holds the parsed command-line flags.
+// See ParseFlag for non-zero defaults.
+var Flag CmdFlags
+
+// A CountFlag is a counting integer flag.
+// It accepts -name=value to set the value directly,
+// but it also accepts -name with no =value to increment the count.
+type CountFlag int
+
+// CmdFlags defines the command-line flags (see var Flag).
+// Each struct field is a different flag, by default named for the lower-case of the field name.
+// If the flag name is a single letter, the default flag name is left upper-case.
+// If the flag name is "Lower" followed by a single letter, the default flag name is the lower-case of the last letter.
+//
+// If this default flag name can't be made right, the `flag` struct tag can be used to replace it,
+// but this should be done only in exceptional circumstances: it helps everyone if the flag name
+// is obvious from the field name when the flag is used elsewhere in the compiler sources.
+// The `flag:"-"` struct tag makes a field invisible to the flag logic and should also be used sparingly.
+//
+// Each field must have a `help` struct tag giving the flag help message.
+//
+// The allowed field types are bool, int, string, pointers to those (for values stored elsewhere),
+// CountFlag (for a counting flag), and func(string) (for a flag that uses special code for parsing).
+type CmdFlags struct {
+	// Single letters
+	B CountFlag    "help:\"disable bounds checking\""
+	C CountFlag    "help:\"disable printing of columns in error messages\""
+	D string       "help:\"set relative `path` for local imports\""
+	E CountFlag    "help:\"debug symbol export\""
+	I func(string) "help:\"add `directory` to import search path\""
+	K CountFlag    "help:\"debug missing line numbers\""
+	L CountFlag    "help:\"show full file names in error messages\""
+	N CountFlag    "help:\"disable optimizations\""
+	S CountFlag    "help:\"print assembly listing\""
+	// V is added by objabi.AddVersionFlag
+	W CountFlag "help:\"debug parse tree after type checking\""
+
+	LowerC int       "help:\"concurrency during compilation (1 means no concurrency)\""
+	LowerD string    "help:\"enable debugging settings; try -d help\""
+	LowerE CountFlag "help:\"no limit on number of errors reported\""
+	LowerH CountFlag "help:\"halt on error\""
+	LowerJ CountFlag "help:\"debug runtime-initialized variables\""
+	LowerL CountFlag "help:\"disable inlining\""
+	LowerM CountFlag "help:\"print optimization decisions\""
+	LowerO string    "help:\"write output to `file`\""
+	LowerP *string   "help:\"set expected package import `path`\"" // &Ctxt.Pkgpath, set below
+	LowerR CountFlag "help:\"debug generated wrappers\""
+	LowerT bool      "help:\"enable tracing for debugging the compiler\""
+	LowerW CountFlag "help:\"debug type checking\""
+	LowerV *bool     "help:\"increase debug verbosity\""
+
+	// Special characters
+	Percent          int  "flag:\"%\" help:\"debug non-static initializers\""
+	CompilingRuntime bool "flag:\"+\" help:\"compiling runtime\""
+
+	// Longer names
+	AsmHdr             string       "help:\"write assembly header to `file`\""
+	Bench              string       "help:\"append benchmark times to `file`\""
+	BlockProfile       string       "help:\"write block profile to `file`\""
+	BuildID            string       "help:\"record `id` as the build id in the export metadata\""
+	CPUProfile         string       "help:\"write cpu profile to `file`\""
+	Complete           bool         "help:\"compiling complete package (no C or assembly)\""
+	Dwarf              bool         "help:\"generate DWARF symbols\""
+	DwarfBASEntries    *bool        "help:\"use base address selection entries in DWARF\""                        // &Ctxt.UseBASEntries, set below
+	DwarfLocationLists *bool        "help:\"add location lists to DWARF in optimized mode\""                      // &Ctxt.Flag_locationlists, set below
+	Dynlink            *bool        "help:\"support references to Go symbols defined in other shared libraries\"" // &Ctxt.Flag_dynlink, set below
+	EmbedCfg           func(string) "help:\"read go:embed configuration from `file`\""
+	GenDwarfInl        int          "help:\"generate DWARF inline info records\"" // 0=disabled, 1=funcs, 2=funcs+formals/locals
+	GoVersion          string       "help:\"required version of the runtime\""
+	ImportCfg          func(string) "help:\"read import configuration from `file`\""
+	ImportMap          func(string) "help:\"add `definition` of the form source=actual to import map\""
+	InstallSuffix      string       "help:\"set pkg directory `suffix`\""
+	JSON               string       "help:\"version,file for JSON compiler/optimizer detail output\""
+	Lang               string       "help:\"Go language version source code expects\""
+	LinkObj            string       "help:\"write linker-specific object to `file`\""
+	LinkShared         *bool        "help:\"generate code that will be linked against Go shared libraries\"" // &Ctxt.Flag_linkshared, set below
+	Live               CountFlag    "help:\"debug liveness analysis\""
+	MSan               bool         "help:\"build code compatible with C/C++ memory sanitizer\""
+	MemProfile         string       "help:\"write memory profile to `file`\""
+	MemProfileRate     int64        "help:\"set runtime.MemProfileRate to `rate`\""
+	MutexProfile       string       "help:\"write mutex profile to `file`\""
+	NoLocalImports     bool         "help:\"reject local (relative) imports\""
+	Pack               bool         "help:\"write to file.a instead of file.o\""
+	Race               bool         "help:\"enable race detector\""
+	Shared             *bool        "help:\"generate code that can be linked into a shared library\"" // &Ctxt.Flag_shared, set below
+	SmallFrames        bool         "help:\"reduce the size limit for stack allocated objects\""      // small stacks, to diagnose GC latency; see golang.org/issue/27732
+	Spectre            string       "help:\"enable spectre mitigations in `list` (all, index, ret)\""
+	Std                bool         "help:\"compiling standard library\""
+	SymABIs            string       "help:\"read symbol ABIs from `file`\""
+	TraceProfile       string       "help:\"write an execution trace to `file`\""
+	TrimPath           string       "help:\"remove `prefix` from recorded source file paths\""
+	WB                 bool         "help:\"enable write barrier\"" // TODO: remove
+
+	// Configuration derived from flags; not a flag itself.
 	Cfg struct {
-		Embed struct {
+		Embed struct { // set by -embedcfg
 			Patterns map[string][]string
 			Files    map[string]string
 		}
-		ImportDirs   []string
-		ImportMap    map[string]string
-		PackageFile  map[string]string
-		SpectreIndex bool
+		ImportDirs   []string          // appended to by -I
+		ImportMap    map[string]string // set by -importmap OR -importcfg
+		PackageFile  map[string]string // set by -importcfg; nil means not in use
+		SpectreIndex bool              // set by -spectre=index or -spectre=all
 	}
 }
 
+// ParseFlags parses the command-line flags into Flag.
 func ParseFlags() {
-	Wasm := objabi.GOARCH == "wasm"
-
-	// Whether the limit for stack-allocated objects is much smaller than normal.
-	// This can be helpful for diagnosing certain causes of GC latency. See #27732.
-	Flag.SmallFrames = false
-	Flag.JSON = ""
-
-	flag.BoolVar(&Flag.CompilingRuntime, "+", false, "compiling runtime")
-	flag.BoolVar(&Flag.Std, "std", false, "compiling standard library")
-	flag.StringVar(&Flag.D, "D", "", "set relative `path` for local imports")
-
-	objabi.Flagcount("%", "debug non-static initializers", &Flag.Percent)
-	objabi.Flagcount("B", "disable bounds checking", &Flag.B)
-	objabi.Flagcount("C", "disable printing of columns in error messages", &Flag.C)
-	objabi.Flagcount("E", "debug symbol export", &Flag.E)
-	objabi.Flagcount("K", "debug missing line numbers", &Flag.K)
-	objabi.Flagcount("L", "show full file names in error messages", &Flag.L)
-	objabi.Flagcount("N", "disable optimizations", &Flag.N)
-	objabi.Flagcount("S", "print assembly listing", &Flag.S)
-	objabi.Flagcount("W", "debug parse tree after type checking", &Flag.W)
-	objabi.Flagcount("e", "no limit on number of errors reported", &Flag.LowerE)
-	objabi.Flagcount("h", "halt on error", &Flag.LowerH)
-	objabi.Flagcount("j", "debug runtime-initialized variables", &Flag.LowerJ)
-	objabi.Flagcount("l", "disable inlining", &Flag.LowerL)
-	objabi.Flagcount("m", "print optimization decisions", &Flag.LowerM)
-	objabi.Flagcount("r", "debug generated wrappers", &Flag.LowerR)
-	objabi.Flagcount("w", "debug type checking", &Flag.LowerW)
-
-	objabi.Flagfn1("I", "add `directory` to import search path", addImportDir)
-	objabi.AddVersionFlag() // -V
-	flag.StringVar(&Flag.AsmHdr, "asmhdr", "", "write assembly header to `file`")
-	flag.StringVar(&Flag.BuildID, "buildid", "", "record `id` as the build id in the export metadata")
-	flag.IntVar(&Flag.LowerC, "c", 1, "concurrency during compilation, 1 means no concurrency")
-	flag.BoolVar(&Flag.Complete, "complete", false, "compiling complete package (no C or assembly)")
-	flag.StringVar(&Flag.LowerD, "d", "", "print debug information about items in `list`; try -d help")
-	flag.BoolVar(&Flag.Dwarf, "dwarf", !Wasm, "generate DWARF symbols")
-	flag.BoolVar(&Ctxt.Flag_locationlists, "dwarflocationlists", true, "add location lists to DWARF in optimized mode")
-	flag.IntVar(&Flag.GenDwarfInl, "gendwarfinl", 2, "generate DWARF inline info records")
-	objabi.Flagfn1("embedcfg", "read go:embed configuration from `file`", readEmbedCfg)
-	objabi.Flagfn1("importmap", "add `definition` of the form source=actual to import map", addImportMap)
-	objabi.Flagfn1("importcfg", "read import configuration from `file`", readImportCfg)
-	flag.StringVar(&Flag.InstallSuffix, "installsuffix", "", "set pkg directory `suffix`")
-	flag.StringVar(&Flag.Lang, "lang", "", "release to compile for")
-	flag.StringVar(&Flag.LinkObj, "linkobj", "", "write linker-specific object to `file`")
-	objabi.Flagcount("live", "debug liveness analysis", &Flag.Live)
-	if sys.MSanSupported(objabi.GOOS, objabi.GOARCH) {
-		flag.BoolVar(&Flag.MSan, "msan", false, "build code compatible with C/C++ memory sanitizer")
-	}
-	flag.BoolVar(&Flag.NoLocalImports, "nolocalimports", false, "reject local (relative) imports")
-	flag.StringVar(&Flag.LowerO, "o", "", "write output to `file`")
-	flag.StringVar(&Ctxt.Pkgpath, "p", "", "set expected package import `path`")
-	flag.BoolVar(&Flag.Pack, "pack", false, "write to file.a instead of file.o")
-	if sys.RaceDetectorSupported(objabi.GOOS, objabi.GOARCH) {
-		flag.BoolVar(&Flag.Race, "race", false, "enable race detector")
-	}
-	flag.StringVar(&Flag.Spectre, "spectre", Flag.Spectre, "enable spectre mitigations in `list` (all, index, ret)")
-	if enableTrace {
-		flag.BoolVar(&Flag.LowerT, "t", false, "trace type-checking")
-	}
-	flag.StringVar(&Flag.TrimPath, "trimpath", "", "remove `prefix` from recorded source file paths")
-	flag.BoolVar(&Ctxt.Debugvlog, "v", false, "increase debug verbosity")
-	flag.BoolVar(&Flag.WB, "wb", true, "enable write barrier")
-	if supportsDynlink(thearch.LinkArch.Arch) {
-		flag.BoolVar(&Flag.Shared, "shared", false, "generate code that can be linked into a shared library")
-		flag.BoolVar(&Flag.Dynlink, "dynlink", false, "support references to Go symbols defined in other shared libraries")
-		flag.BoolVar(&Ctxt.Flag_linkshared, "linkshared", false, "generate code that will be linked against Go shared libraries")
-	}
-	flag.StringVar(&Flag.CPUProfile, "cpuprofile", "", "write cpu profile to `file`")
-	flag.StringVar(&Flag.MemProfile, "memprofile", "", "write memory profile to `file`")
-	flag.Int64Var(&memprofilerate, "memprofilerate", 0, "set runtime.MemProfileRate to `rate`")
-	flag.StringVar(&Flag.GoVersion, "goversion", "", "required version of the runtime")
-	flag.StringVar(&Flag.SymABIs, "symabis", "", "read symbol ABIs from `file`")
-	flag.StringVar(&Flag.TraceProfile, "traceprofile", "", "write an execution trace to `file`")
-	flag.StringVar(&Flag.BlockProfile, "blockprofile", "", "write block profile to `file`")
-	flag.StringVar(&Flag.MutexProfile, "mutexprofile", "", "write mutex profile to `file`")
-	flag.StringVar(&Flag.Bench, "bench", "", "append benchmark times to `file`")
-	flag.BoolVar(&Flag.SmallFrames, "smallframes", false, "reduce the size limit for stack allocated objects")
-	flag.BoolVar(&Ctxt.UseBASEntries, "dwarfbasentries", Ctxt.UseBASEntries, "use base address selection entries in DWARF")
-	flag.StringVar(&Flag.JSON, "json", "", "version,destination for JSON compiler/optimizer logging")
+	Flag.I = addImportDir
+
+	Flag.LowerC = 1
+	Flag.LowerP = &Ctxt.Pkgpath
+	Flag.LowerV = &Ctxt.Debugvlog
+
+	Flag.Dwarf = objabi.GOARCH != "wasm"
+	Flag.DwarfBASEntries = &Ctxt.UseBASEntries
+	Flag.DwarfLocationLists = &Ctxt.Flag_locationlists
+	*Flag.DwarfLocationLists = true
+	Flag.Dynlink = &Ctxt.Flag_dynlink
+	Flag.EmbedCfg = readEmbedCfg
+	Flag.GenDwarfInl = 2
+	Flag.ImportCfg = readImportCfg
+	Flag.ImportMap = addImportMap
+	Flag.LinkShared = &Ctxt.Flag_linkshared
+	Flag.Shared = &Ctxt.Flag_shared
+	Flag.WB = true
+
+	Flag.Cfg.ImportMap = make(map[string]string)
 
+	objabi.AddVersionFlag() // -V
+	registerFlags()
 	objabi.Flagparse(usage)
 
-	for _, f := range strings.Split(Flag.Spectre, ",") {
-		f = strings.TrimSpace(f)
-		switch f {
-		default:
-			log.Fatalf("unknown setting -spectre=%s", f)
-		case "":
-			// nothing
-		case "all":
-			Flag.Cfg.SpectreIndex = true
-			Ctxt.Retpoline = true
-		case "index":
-			Flag.Cfg.SpectreIndex = true
-		case "ret":
-			Ctxt.Retpoline = true
-		}
+	if Flag.MSan && !sys.MSanSupported(objabi.GOOS, objabi.GOARCH) {
+		log.Fatalf("%s/%s does not support -msan", objabi.GOOS, objabi.GOARCH)
 	}
-
-	if Flag.Cfg.SpectreIndex {
-		switch objabi.GOARCH {
-		case "amd64":
-			// ok
-		default:
-			log.Fatalf("GOARCH=%s does not support -spectre=index", objabi.GOARCH)
-		}
+	if Flag.Race && !sys.RaceDetectorSupported(objabi.GOOS, objabi.GOARCH) {
+		log.Fatalf("%s/%s does not support -race", objabi.GOOS, objabi.GOARCH)
 	}
-
-	// Record flags that affect the build result. (And don't
-	// record flags that don't, since that would cause spurious
-	// changes in the binary.)
-	recordFlags("B", "N", "l", "msan", "race", "shared", "dynlink", "dwarflocationlists", "dwarfbasentries", "smallframes", "spectre")
-
-	if Flag.SmallFrames {
-		maxStackVarSize = 128 * 1024
-		maxImplicitStackVarSize = 16 * 1024
+	if (*Flag.Shared || *Flag.Dynlink || *Flag.LinkShared) && !Ctxt.Arch.InFamily(sys.AMD64, sys.ARM, sys.ARM64, sys.I386, sys.PPC64, sys.RISCV64, sys.S390X) {
+		log.Fatalf("%s/%s does not support -shared", objabi.GOOS, objabi.GOARCH)
 	}
+	parseSpectre(Flag.Spectre) // left as string for recordFlags
 
-	Ctxt.Flag_shared = Flag.Dynlink || Flag.Shared
-	Ctxt.Flag_dynlink = Flag.Dynlink
+	Ctxt.Flag_shared = Ctxt.Flag_dynlink || Ctxt.Flag_shared
 	Ctxt.Flag_optimize = Flag.N == 0
-
-	Ctxt.Debugasm = Flag.S
-	if Flag.Dwarf {
-		Ctxt.DebugInfo = debuginfo
-		Ctxt.GenAbstractFunc = genAbstractFunc
-		Ctxt.DwFixups = obj.NewDwarfFixupTable(Ctxt)
-	} else {
-		// turn off inline generation if no dwarf at all
-		Flag.GenDwarfInl = 0
-		Ctxt.Flag_locationlists = false
-	}
+	Ctxt.Debugasm = int(Flag.S)
 
 	if flag.NArg() < 1 && Flag.LowerD != "help" && Flag.LowerD != "ssa/help" {
 		usage()
@@ -229,14 +184,6 @@ func ParseFlags() {
 		Exit(2)
 	}
 
-	checkLang()
-
-	if Flag.SymABIs != "" {
-		readSymABIs(Flag.SymABIs, Ctxt.Pkgpath)
-	}
-
-	thearch.LinkArch.Init(Ctxt)
-
 	if Flag.LowerO == "" {
 		p := flag.Arg(0)
 		if i := strings.LastIndex(p, "/"); i >= 0 {
@@ -257,8 +204,6 @@ func ParseFlags() {
 		Flag.LowerO = p + suffix
 	}
 
-	startProfile()
-
 	if Flag.Race && Flag.MSan {
 		log.Fatal("cannot use both -race and -msan")
 	}
@@ -266,19 +211,6 @@ func ParseFlags() {
 		// -race and -msan imply -d=checkptr for now.
 		Debug_checkptr = 1
 	}
-	if ispkgin(omit_pkgs) {
-		Flag.Race = false
-		Flag.MSan = false
-	}
-	if Flag.Race {
-		racepkg = types.NewPkg("runtime/race", "")
-	}
-	if Flag.MSan {
-		msanpkg = types.NewPkg("runtime/msan", "")
-	}
-	if Flag.Race || Flag.MSan {
-		instrumenting = true
-	}
 
 	if Flag.CompilingRuntime && Flag.N != 0 {
 		log.Fatal("cannot disable optimizations while compiling runtime")
@@ -289,9 +221,6 @@ func ParseFlags() {
 	if Flag.LowerC > 1 && !concurrentBackendAllowed() {
 		log.Fatalf("cannot use concurrent backend compilation with provided flags; invoked as %v", os.Args)
 	}
-	if Ctxt.Flag_locationlists && len(Ctxt.Arch.DWARFRegisters) == 0 {
-		log.Fatalf("location lists requested but register mapping not available on %v", Ctxt.Arch.Name)
-	}
 
 	// parse -d argument
 	if Flag.LowerD != "" {
@@ -376,24 +305,77 @@ func ParseFlags() {
 
 	// set via a -d flag
 	Ctxt.Debugpcln = Debug_pctab
-	if Flag.Dwarf {
-		dwarf.EnableLogging(Debug_gendwarfinl != 0)
-	}
+}
 
-	if Debug_softfloat != 0 {
-		thearch.SoftFloat = true
-	}
+// registerFlags adds flag registrations for all the fields in Flag.
+// See the comment on type CmdFlags for the rules.
+func registerFlags() {
+	var (
+		boolType      = reflect.TypeOf(bool(false))
+		intType       = reflect.TypeOf(int(0))
+		stringType    = reflect.TypeOf(string(""))
+		ptrBoolType   = reflect.TypeOf(new(bool))
+		ptrIntType    = reflect.TypeOf(new(int))
+		ptrStringType = reflect.TypeOf(new(string))
+		countType     = reflect.TypeOf(CountFlag(0))
+		funcType      = reflect.TypeOf((func(string))(nil))
+	)
+
+	v := reflect.ValueOf(&Flag).Elem()
+	t := v.Type()
+	for i := 0; i < t.NumField(); i++ {
+		f := t.Field(i)
+		if f.Name == "Cfg" {
+			continue
+		}
 
-	// enable inlining.  for now:
-	//	default: inlining on.  (Debug.l == 1)
-	//	-l: inlining off  (Debug.l == 0)
-	//	-l=2, -l=3: inlining on again, with extra debugging (Debug.l > 1)
-	if Flag.LowerL <= 1 {
-		Flag.LowerL = 1 - Flag.LowerL
-	}
+		var name string
+		if len(f.Name) == 1 {
+			name = f.Name
+		} else if len(f.Name) == 6 && f.Name[:5] == "Lower" && 'A' <= f.Name[5] && f.Name[5] <= 'Z' {
+			name = string(rune(f.Name[5] + 'a' - 'A'))
+		} else {
+			name = strings.ToLower(f.Name)
+		}
+		if tag := f.Tag.Get("flag"); tag != "" {
+			name = tag
+		}
+
+		help := f.Tag.Get("help")
+		if help == "" {
+			panic(fmt.Sprintf("base.Flag.%s is missing help text", f.Name))
+		}
+
+		if k := f.Type.Kind(); (k == reflect.Ptr || k == reflect.Func) && v.Field(i).IsNil() {
+			panic(fmt.Sprintf("base.Flag.%s is uninitialized %v", f.Name, f.Type))
+		}
 
-	if Flag.JSON != "" { // parse version,destination from json logging optimization.
-		logopt.LogJsonOption(Flag.JSON)
+		switch f.Type {
+		case boolType:
+			p := v.Field(i).Addr().Interface().(*bool)
+			flag.BoolVar(p, name, *p, help)
+		case intType:
+			p := v.Field(i).Addr().Interface().(*int)
+			flag.IntVar(p, name, *p, help)
+		case stringType:
+			p := v.Field(i).Addr().Interface().(*string)
+			flag.StringVar(p, name, *p, help)
+		case ptrBoolType:
+			p := v.Field(i).Interface().(*bool)
+			flag.BoolVar(p, name, *p, help)
+		case ptrIntType:
+			p := v.Field(i).Interface().(*int)
+			flag.IntVar(p, name, *p, help)
+		case ptrStringType:
+			p := v.Field(i).Interface().(*string)
+			flag.StringVar(p, name, *p, help)
+		case countType:
+			p := (*int)(v.Field(i).Addr().Interface().(*CountFlag))
+			objabi.Flagcount(name, help, p)
+		case funcType:
+			f := v.Field(i).Interface().(func(string))
+			objabi.Flagfn1(name, help, f)
+		}
 	}
 }
 
@@ -514,3 +496,32 @@ func readEmbedCfg(file string) {
 		log.Fatalf("%s: invalid embedcfg: missing Files", file)
 	}
 }
+
+// parseSpectre parses the spectre configuration from the string s.
+func parseSpectre(s string) {
+	for _, f := range strings.Split(s, ",") {
+		f = strings.TrimSpace(f)
+		switch f {
+		default:
+			log.Fatalf("unknown setting -spectre=%s", f)
+		case "":
+			// nothing
+		case "all":
+			Flag.Cfg.SpectreIndex = true
+			Ctxt.Retpoline = true
+		case "index":
+			Flag.Cfg.SpectreIndex = true
+		case "ret":
+			Ctxt.Retpoline = true
+		}
+	}
+
+	if Flag.Cfg.SpectreIndex {
+		switch objabi.GOARCH {
+		case "amd64":
+			// ok
+		default:
+			log.Fatalf("GOARCH=%s does not support -spectre=index", objabi.GOARCH)
+		}
+	}
+}
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 8edc0d4495..9cf988bca8 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -18,7 +18,6 @@ import (
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
 	"cmd/internal/src"
-	"cmd/internal/sys"
 	"flag"
 	"fmt"
 	"go/constant"
@@ -118,12 +117,6 @@ func hidePanic() {
 	}
 }
 
-// supportsDynlink reports whether or not the code generator for the given
-// architecture supports the -shared and -dynlink flags.
-func supportsDynlink(arch *sys.Arch) bool {
-	return arch.InFamily(sys.AMD64, sys.ARM, sys.ARM64, sys.I386, sys.PPC64, sys.RISCV64, sys.S390X)
-}
-
 // timing data for compiler phases
 var timings Timings
 
@@ -192,6 +185,74 @@ func Main(archInit func(*Arch)) {
 
 	ParseFlags()
 
+	// Record flags that affect the build result. (And don't
+	// record flags that don't, since that would cause spurious
+	// changes in the binary.)
+	recordFlags("B", "N", "l", "msan", "race", "shared", "dynlink", "dwarflocationlists", "dwarfbasentries", "smallframes", "spectre")
+
+	if !enableTrace && Flag.LowerT {
+		log.Fatalf("compiler not built with support for -t")
+	}
+
+	// Enable inlining (after recordFlags, to avoid recording the rewritten -l).  For now:
+	//	default: inlining on.  (Flag.LowerL == 1)
+	//	-l: inlining off  (Flag.LowerL == 0)
+	//	-l=2, -l=3: inlining on again, with extra debugging (Flag.LowerL > 1)
+	if Flag.LowerL <= 1 {
+		Flag.LowerL = 1 - Flag.LowerL
+	}
+
+	if Flag.SmallFrames {
+		maxStackVarSize = 128 * 1024
+		maxImplicitStackVarSize = 16 * 1024
+	}
+
+	if Flag.Dwarf {
+		Ctxt.DebugInfo = debuginfo
+		Ctxt.GenAbstractFunc = genAbstractFunc
+		Ctxt.DwFixups = obj.NewDwarfFixupTable(Ctxt)
+	} else {
+		// turn off inline generation if no dwarf at all
+		Flag.GenDwarfInl = 0
+		Ctxt.Flag_locationlists = false
+	}
+	if Ctxt.Flag_locationlists && len(Ctxt.Arch.DWARFRegisters) == 0 {
+		log.Fatalf("location lists requested but register mapping not available on %v", Ctxt.Arch.Name)
+	}
+
+	checkLang()
+
+	if Flag.SymABIs != "" {
+		readSymABIs(Flag.SymABIs, Ctxt.Pkgpath)
+	}
+
+	if ispkgin(omit_pkgs) {
+		Flag.Race = false
+		Flag.MSan = false
+	}
+
+	thearch.LinkArch.Init(Ctxt)
+	startProfile()
+	if Flag.Race {
+		racepkg = types.NewPkg("runtime/race", "")
+	}
+	if Flag.MSan {
+		msanpkg = types.NewPkg("runtime/msan", "")
+	}
+	if Flag.Race || Flag.MSan {
+		instrumenting = true
+	}
+	if Flag.Dwarf {
+		dwarf.EnableLogging(Debug_gendwarfinl != 0)
+	}
+	if Debug_softfloat != 0 {
+		thearch.SoftFloat = true
+	}
+
+	if Flag.JSON != "" { // parse version,destination from json logging optimization.
+		logopt.LogJsonOption(Flag.JSON)
+	}
+
 	ssaDump = os.Getenv("GOSSAFUNC")
 	ssaDir = os.Getenv("GOSSADIR")
 	if ssaDump != "" {
-- 
GitLab


From 3c240f5d17e4ad3ddd342645b63fe20ecbb7fcae Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 16 Nov 2020 01:17:25 -0500
Subject: [PATCH 0065/2400] [dev.regabi] cmd/compile: clean up debug flag (-d)
 handling [generated]

The debug table is not as haphazard as flags, but there are still
a few mismatches between command-line names and variable names.
This CL moves them all into a consistent home (var Debug, like var Flag).

Code updated automatically using the rf command below.
A followup CL will make a few manual cleanups, leaving this CL
completely automated and easier to regenerate during merge
conflicts.

[git-generate]
cd src/cmd/compile/internal/gc
rf '
	add main.go var Debug struct{}
	mv Debug_append Debug.Append
	mv Debug_checkptr Debug.Checkptr
	mv Debug_closure Debug.Closure
	mv Debug_compilelater Debug.CompileLater
	mv disable_checknil Debug.DisableNil
	mv debug_dclstack Debug.DclStack
	mv Debug_gcprog Debug.GCProg
	mv Debug_libfuzzer Debug.Libfuzzer
	mv Debug_checknil Debug.Nil
	mv Debug_panic Debug.Panic
	mv Debug_slice Debug.Slice
	mv Debug_typeassert Debug.TypeAssert
	mv Debug_wb Debug.WB
	mv Debug_export Debug.Export
	mv Debug_pctab Debug.PCTab
	mv Debug_locationlist Debug.LocationLists
	mv Debug_typecheckinl Debug.TypecheckInl
	mv Debug_gendwarfinl Debug.DwarfInl
	mv Debug_softfloat Debug.SoftFloat
	mv Debug_defer Debug.Defer
	mv Debug_dumpptrs Debug.DumpPtrs

	mv flag.go:/parse.-d/-1,/unknown.debug/+2 parseDebug

	mv debugtab Debug parseDebug \
		debugHelpHeader debugHelpFooter \
		debug.go

	# Remove //go:generate line copied from main.go
	rm debug.go:/go:generate/-+
'

Change-Id: I625761ca5659be4052f7161a83baa00df75cca91
Reviewed-on: https://go-review.googlesource.com/c/go/+/272246
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/amd64/ssa.go   |   2 +-
 src/cmd/compile/internal/arm/ssa.go     |   2 +-
 src/cmd/compile/internal/arm64/ssa.go   |   2 +-
 src/cmd/compile/internal/gc/alg.go      |   4 +-
 src/cmd/compile/internal/gc/closure.go  |   4 +-
 src/cmd/compile/internal/gc/debug.go    | 167 ++++++++++++++++++++++++
 src/cmd/compile/internal/gc/dwinl.go    |   6 +-
 src/cmd/compile/internal/gc/export.go   |   8 +-
 src/cmd/compile/internal/gc/flag.go     |  84 +-----------
 src/cmd/compile/internal/gc/fmt.go      |   4 +-
 src/cmd/compile/internal/gc/go.go       |   5 -
 src/cmd/compile/internal/gc/inl.go      |   8 +-
 src/cmd/compile/internal/gc/main.go     |  83 +-----------
 src/cmd/compile/internal/gc/order.go    |   4 +-
 src/cmd/compile/internal/gc/pgen.go     |   2 +-
 src/cmd/compile/internal/gc/print.go    |   2 +-
 src/cmd/compile/internal/gc/reflect.go  |   6 +-
 src/cmd/compile/internal/gc/sinit.go    |   2 +-
 src/cmd/compile/internal/gc/ssa.go      |  20 +--
 src/cmd/compile/internal/gc/subr.go     |   2 +-
 src/cmd/compile/internal/gc/syntax.go   |   2 +-
 src/cmd/compile/internal/gc/walk.go     |   6 +-
 src/cmd/compile/internal/mips/ssa.go    |   2 +-
 src/cmd/compile/internal/mips64/ssa.go  |   2 +-
 src/cmd/compile/internal/ppc64/ssa.go   |   2 +-
 src/cmd/compile/internal/riscv64/ssa.go |   2 +-
 src/cmd/compile/internal/s390x/ssa.go   |   2 +-
 src/cmd/compile/internal/wasm/ssa.go    |   2 +-
 src/cmd/compile/internal/x86/ssa.go     |   2 +-
 29 files changed, 226 insertions(+), 213 deletions(-)
 create mode 100644 src/cmd/compile/internal/gc/debug.go

diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index 5ff05a0edd..1f2d626721 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -1164,7 +1164,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		if logopt.Enabled() {
 			logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
 		}
-		if gc.Debug_checknil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
+		if gc.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
 			gc.Warnl(v.Pos, "generated nil check")
 		}
 	case ssa.OpAMD64MOVBatomicload, ssa.OpAMD64MOVLatomicload, ssa.OpAMD64MOVQatomicload:
diff --git a/src/cmd/compile/internal/arm/ssa.go b/src/cmd/compile/internal/arm/ssa.go
index 765a771546..82a5172ec7 100644
--- a/src/cmd/compile/internal/arm/ssa.go
+++ b/src/cmd/compile/internal/arm/ssa.go
@@ -741,7 +741,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		if logopt.Enabled() {
 			logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
 		}
-		if gc.Debug_checknil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
+		if gc.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
 			gc.Warnl(v.Pos, "generated nil check")
 		}
 	case ssa.OpARMLoweredZero:
diff --git a/src/cmd/compile/internal/arm64/ssa.go b/src/cmd/compile/internal/arm64/ssa.go
index 22b28a9308..dcbd8f9474 100644
--- a/src/cmd/compile/internal/arm64/ssa.go
+++ b/src/cmd/compile/internal/arm64/ssa.go
@@ -1038,7 +1038,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		if logopt.Enabled() {
 			logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
 		}
-		if gc.Debug_checknil != 0 && v.Pos.Line() > 1 { // v.Line==1 in generated wrappers
+		if gc.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Line==1 in generated wrappers
 			gc.Warnl(v.Pos, "generated nil check")
 		}
 	case ssa.OpARM64Equal,
diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index c1d8de6bad..87b905ed59 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -387,7 +387,7 @@ func genhash(t *types.Type) *obj.LSym {
 	typecheckslice(fn.Nbody.Slice(), ctxStmt)
 	Curfn = nil
 
-	if debug_dclstack != 0 {
+	if Debug.DclStack != 0 {
 		testdclstack()
 	}
 
@@ -766,7 +766,7 @@ func geneq(t *types.Type) *obj.LSym {
 	typecheckslice(fn.Nbody.Slice(), ctxStmt)
 	Curfn = nil
 
-	if debug_dclstack != 0 {
+	if Debug.DclStack != 0 {
 		testdclstack()
 	}
 
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index f850cbe280..c25a446999 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -337,7 +337,7 @@ func hasemptycvars(clo *Node) bool {
 // closuredebugruntimecheck applies boilerplate checks for debug flags
 // and compiling runtime
 func closuredebugruntimecheck(clo *Node) {
-	if Debug_closure > 0 {
+	if Debug.Closure > 0 {
 		if clo.Esc == EscHeap {
 			Warnl(clo.Pos, "heap closure, captured vars = %v", clo.Func.ClosureVars)
 		} else {
@@ -386,7 +386,7 @@ func walkclosure(clo *Node, init *Nodes) *Node {
 
 	// If no closure vars, don't bother wrapping.
 	if hasemptycvars(clo) {
-		if Debug_closure > 0 {
+		if Debug.Closure > 0 {
 			Warnl(clo.Pos, "closure converted to global")
 		}
 		return fn.Nname
diff --git a/src/cmd/compile/internal/gc/debug.go b/src/cmd/compile/internal/gc/debug.go
new file mode 100644
index 0000000000..f6be3d57b0
--- /dev/null
+++ b/src/cmd/compile/internal/gc/debug.go
@@ -0,0 +1,167 @@
+// Copyright 2009 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 gc
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"strconv"
+	"strings"
+
+	"cmd/compile/internal/ssa"
+	"cmd/internal/objabi"
+)
+
+// Debug arguments.
+// These can be specified with the -d flag, as in "-d nil"
+// to set the debug_checknil variable.
+// Multiple options can be comma-separated.
+// Each option accepts an optional argument, as in "gcprog=2"
+var debugtab = []struct {
+	name string
+	help string
+	val  interface{} // must be *int or *string
+}{
+	{"append", "print information about append compilation", &Debug.Append},
+	{"checkptr", "instrument unsafe pointer conversions", &Debug.Checkptr},
+	{"closure", "print information about closure compilation", &Debug.Closure},
+	{"compilelater", "compile functions as late as possible", &Debug.CompileLater},
+	{"disablenil", "disable nil checks", &Debug.DisableNil},
+	{"dclstack", "run internal dclstack check", &Debug.DclStack},
+	{"dumpptrs", "show Node pointer values in Dump/dumplist output", &Debug.DumpPtrs},
+	{"gcprog", "print dump of GC programs", &Debug.GCProg},
+	{"libfuzzer", "coverage instrumentation for libfuzzer", &Debug.Libfuzzer},
+	{"nil", "print information about nil checks", &Debug.Nil},
+	{"panic", "do not hide any compiler panic", &Debug.Panic},
+	{"slice", "print information about slice compilation", &Debug.Slice},
+	{"typeassert", "print information about type assertion inlining", &Debug.TypeAssert},
+	{"wb", "print information about write barriers", &Debug.WB},
+	{"export", "print export data", &Debug.Export},
+	{"pctab", "print named pc-value table", &Debug.PCTab},
+	{"locationlists", "print information about DWARF location list creation", &Debug.LocationLists},
+	{"typecheckinl", "eager typechecking of inline function bodies", &Debug.TypecheckInl},
+	{"dwarfinl", "print information about DWARF inlined function creation", &Debug.DwarfInl},
+	{"softfloat", "force compiler to emit soft-float code", &Debug.SoftFloat},
+	{"defer", "print information about defer compilation", &Debug.Defer},
+	{"fieldtrack", "enable fieldtracking", &objabi.Fieldtrack_enabled},
+}
+
+var Debug struct {
+	Append        int
+	Checkptr      int
+	Closure       int
+	CompileLater  int
+	DisableNil    int
+	DclStack      int
+	GCProg        int
+	Libfuzzer     int
+	Nil           int
+	Panic         int
+	Slice         int
+	TypeAssert    int
+	WB            int
+	Export        int
+	PCTab         string
+	LocationLists int
+	TypecheckInl  int
+	DwarfInl      int
+	SoftFloat     int
+	Defer         int
+	DumpPtrs      int
+}
+
+func parseDebug() {
+	// parse -d argument
+	if Flag.LowerD != "" {
+	Split:
+		for _, name := range strings.Split(Flag.LowerD, ",") {
+			if name == "" {
+				continue
+			}
+			// display help about the -d option itself and quit
+			if name == "help" {
+				fmt.Print(debugHelpHeader)
+				maxLen := len("ssa/help")
+				for _, t := range debugtab {
+					if len(t.name) > maxLen {
+						maxLen = len(t.name)
+					}
+				}
+				for _, t := range debugtab {
+					fmt.Printf("\t%-*s\t%s\n", maxLen, t.name, t.help)
+				}
+				// ssa options have their own help
+				fmt.Printf("\t%-*s\t%s\n", maxLen, "ssa/help", "print help about SSA debugging")
+				fmt.Print(debugHelpFooter)
+				os.Exit(0)
+			}
+			val, valstring, haveInt := 1, "", true
+			if i := strings.IndexAny(name, "=:"); i >= 0 {
+				var err error
+				name, valstring = name[:i], name[i+1:]
+				val, err = strconv.Atoi(valstring)
+				if err != nil {
+					val, haveInt = 1, false
+				}
+			}
+			for _, t := range debugtab {
+				if t.name != name {
+					continue
+				}
+				switch vp := t.val.(type) {
+				case nil:
+					// Ignore
+				case *string:
+					*vp = valstring
+				case *int:
+					if !haveInt {
+						log.Fatalf("invalid debug value %v", name)
+					}
+					*vp = val
+				default:
+					panic("bad debugtab type")
+				}
+				continue Split
+			}
+			// special case for ssa for now
+			if strings.HasPrefix(name, "ssa/") {
+				// expect form ssa/phase/flag
+				// e.g. -d=ssa/generic_cse/time
+				// _ in phase name also matches space
+				phase := name[4:]
+				flag := "debug" // default flag is debug
+				if i := strings.Index(phase, "/"); i >= 0 {
+					flag = phase[i+1:]
+					phase = phase[:i]
+				}
+				err := ssa.PhaseOption(phase, flag, val, valstring)
+				if err != "" {
+					log.Fatalf(err)
+				}
+				continue Split
+			}
+			log.Fatalf("unknown debug key -d %s\n", name)
+		}
+	}
+}
+
+const debugHelpHeader = `usage: -d arg[,arg]* and arg is <key>[=<value>]
+
+<key> is one of:
+
+`
+
+const debugHelpFooter = `
+<value> is key-specific.
+
+Key "checkptr" supports values:
+	"0": instrumentation disabled
+	"1": conversions involving unsafe.Pointer are instrumented
+	"2": conversions to unsafe.Pointer force heap allocation
+
+Key "pctab" supports values:
+	"pctospadj", "pctofile", "pctoline", "pctoinline", "pctopcdata"
+`
diff --git a/src/cmd/compile/internal/gc/dwinl.go b/src/cmd/compile/internal/gc/dwinl.go
index 48d78f6cd7..edde7a4cc5 100644
--- a/src/cmd/compile/internal/gc/dwinl.go
+++ b/src/cmd/compile/internal/gc/dwinl.go
@@ -26,7 +26,7 @@ type varPos struct {
 func assembleInlines(fnsym *obj.LSym, dwVars []*dwarf.Var) dwarf.InlCalls {
 	var inlcalls dwarf.InlCalls
 
-	if Debug_gendwarfinl != 0 {
+	if Debug.DwarfInl != 0 {
 		Ctxt.Logf("assembling DWARF inlined routine info for %v\n", fnsym.Name)
 	}
 
@@ -181,7 +181,7 @@ func assembleInlines(fnsym *obj.LSym, dwVars []*dwarf.Var) dwarf.InlCalls {
 	}
 
 	// Debugging
-	if Debug_gendwarfinl != 0 {
+	if Debug.DwarfInl != 0 {
 		dumpInlCalls(inlcalls)
 		dumpInlVars(dwVars)
 	}
@@ -210,7 +210,7 @@ func genAbstractFunc(fn *obj.LSym) {
 		Ctxt.Diag("failed to locate precursor fn for %v", fn)
 		return
 	}
-	if Debug_gendwarfinl != 0 {
+	if Debug.DwarfInl != 0 {
 		Ctxt.Logf("DwarfAbstractFunc(%v)\n", fn.Name)
 	}
 	Ctxt.DwarfAbstractFunc(ifn, fn, Ctxt.Pkgpath)
diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index edd2703238..48f77fa182 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -12,13 +12,9 @@ import (
 	"go/constant"
 )
 
-var (
-	Debug_export int // if set, print debugging information about export data
-)
-
 func exportf(bout *bio.Writer, format string, args ...interface{}) {
 	fmt.Fprintf(bout, format, args...)
-	if Debug_export != 0 {
+	if Debug.Export != 0 {
 		fmt.Printf(format, args...)
 	}
 }
@@ -71,7 +67,7 @@ func dumpexport(bout *bio.Writer) {
 	size := bout.Offset() - off
 	exportf(bout, "\n$$\n")
 
-	if Debug_export != 0 {
+	if Debug.Export != 0 {
 		fmt.Printf("BenchmarkExportSize:%s 1 %d bytes\n", Ctxt.Pkgpath, size)
 	}
 }
diff --git a/src/cmd/compile/internal/gc/flag.go b/src/cmd/compile/internal/gc/flag.go
index 090287ef62..06b0a88ba3 100644
--- a/src/cmd/compile/internal/gc/flag.go
+++ b/src/cmd/compile/internal/gc/flag.go
@@ -13,10 +13,9 @@ import (
 	"os"
 	"reflect"
 	"runtime"
-	"strconv"
+
 	"strings"
 
-	"cmd/compile/internal/ssa"
 	"cmd/internal/objabi"
 	"cmd/internal/sys"
 )
@@ -209,7 +208,7 @@ func ParseFlags() {
 	}
 	if Flag.Race || Flag.MSan {
 		// -race and -msan imply -d=checkptr for now.
-		Debug_checkptr = 1
+		Debug.Checkptr = 1
 	}
 
 	if Flag.CompilingRuntime && Flag.N != 0 {
@@ -222,89 +221,18 @@ func ParseFlags() {
 		log.Fatalf("cannot use concurrent backend compilation with provided flags; invoked as %v", os.Args)
 	}
 
-	// parse -d argument
-	if Flag.LowerD != "" {
-	Split:
-		for _, name := range strings.Split(Flag.LowerD, ",") {
-			if name == "" {
-				continue
-			}
-			// display help about the -d option itself and quit
-			if name == "help" {
-				fmt.Print(debugHelpHeader)
-				maxLen := len("ssa/help")
-				for _, t := range debugtab {
-					if len(t.name) > maxLen {
-						maxLen = len(t.name)
-					}
-				}
-				for _, t := range debugtab {
-					fmt.Printf("\t%-*s\t%s\n", maxLen, t.name, t.help)
-				}
-				// ssa options have their own help
-				fmt.Printf("\t%-*s\t%s\n", maxLen, "ssa/help", "print help about SSA debugging")
-				fmt.Print(debugHelpFooter)
-				os.Exit(0)
-			}
-			val, valstring, haveInt := 1, "", true
-			if i := strings.IndexAny(name, "=:"); i >= 0 {
-				var err error
-				name, valstring = name[:i], name[i+1:]
-				val, err = strconv.Atoi(valstring)
-				if err != nil {
-					val, haveInt = 1, false
-				}
-			}
-			for _, t := range debugtab {
-				if t.name != name {
-					continue
-				}
-				switch vp := t.val.(type) {
-				case nil:
-					// Ignore
-				case *string:
-					*vp = valstring
-				case *int:
-					if !haveInt {
-						log.Fatalf("invalid debug value %v", name)
-					}
-					*vp = val
-				default:
-					panic("bad debugtab type")
-				}
-				continue Split
-			}
-			// special case for ssa for now
-			if strings.HasPrefix(name, "ssa/") {
-				// expect form ssa/phase/flag
-				// e.g. -d=ssa/generic_cse/time
-				// _ in phase name also matches space
-				phase := name[4:]
-				flag := "debug" // default flag is debug
-				if i := strings.Index(phase, "/"); i >= 0 {
-					flag = phase[i+1:]
-					phase = phase[:i]
-				}
-				err := ssa.PhaseOption(phase, flag, val, valstring)
-				if err != "" {
-					log.Fatalf(err)
-				}
-				continue Split
-			}
-			log.Fatalf("unknown debug key -d %s\n", name)
-		}
-	}
+	parseDebug()
 
 	if Flag.CompilingRuntime {
 		// Runtime can't use -d=checkptr, at least not yet.
-		Debug_checkptr = 0
+		Debug.Checkptr = 0
 
 		// Fuzzing the runtime isn't interesting either.
-		Debug_libfuzzer = 0
+		Debug.Libfuzzer = 0
 	}
 
 	// set via a -d flag
-	Ctxt.Debugpcln = Debug_pctab
+	Ctxt.Debugpcln = Debug.PCTab
 }
 
 // registerFlags adds flag registrations for all the fields in Flag.
diff --git a/src/cmd/compile/internal/gc/fmt.go b/src/cmd/compile/internal/gc/fmt.go
index f995d2e2ec..51e139e319 100644
--- a/src/cmd/compile/internal/gc/fmt.go
+++ b/src/cmd/compile/internal/gc/fmt.go
@@ -339,14 +339,14 @@ func (n *Node) jconv(s fmt.State, flag FmtFlag) {
 	short := flag&FmtShort != 0
 
 	// Useful to see which nodes in an AST printout are actually identical
-	if Debug_dumpptrs != 0 {
+	if Debug.DumpPtrs != 0 {
 		fmt.Fprintf(s, " p(%p)", n)
 	}
 	if !short && n.Name != nil && n.Name.Vargen != 0 {
 		fmt.Fprintf(s, " g(%d)", n.Name.Vargen)
 	}
 
-	if Debug_dumpptrs != 0 && !short && n.Name != nil && n.Name.Defn != nil {
+	if Debug.DumpPtrs != 0 && !short && n.Name != nil && n.Name.Defn != nil {
 		// Useful to see where Defn is set and what node it points to
 		fmt.Fprintf(s, " defn(%p)", n.Name.Defn)
 	}
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index 6cab03d726..947dae476b 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -101,9 +101,6 @@ var pragcgobuf [][]string
 
 var decldepth int32
 
-var Debug_checknil int
-var Debug_typeassert int
-
 var localpkg *types.Pkg // package being compiled
 
 var inimport bool // set during import
@@ -189,8 +186,6 @@ var Ctxt *obj.Link
 
 var nodfp *Node
 
-var disable_checknil int
-
 var autogeneratedPos src.XPos
 
 // interface to back end
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 50091e9c11..fc467dd95a 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -86,7 +86,7 @@ func typecheckinl(fn *Node) {
 		return // typecheckinl on local function
 	}
 
-	if Flag.LowerM > 2 || Debug_export != 0 {
+	if Flag.LowerM > 2 || Debug.Export != 0 {
 		fmt.Printf("typecheck import [%v] %L { %#v }\n", fn.Sym, fn, asNodes(fn.Func.Inl.Body))
 	}
 
@@ -144,7 +144,7 @@ func caninl(fn *Node) {
 	}
 
 	// If marked "go:nocheckptr" and -d checkptr compilation, don't inline.
-	if Debug_checkptr != 0 && fn.Func.Pragma&NoCheckPtr != 0 {
+	if Debug.Checkptr != 0 && fn.Func.Pragma&NoCheckPtr != 0 {
 		reason = "marked go:nocheckptr"
 		return
 	}
@@ -595,7 +595,7 @@ func inlnode(n *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	case OCALLMETH:
 		// Prevent inlining some reflect.Value methods when using checkptr,
 		// even when package reflect was compiled without it (#35073).
-		if s := n.Left.Sym; Debug_checkptr != 0 && isReflectPkg(s.Pkg) && (s.Name == "Value.UnsafeAddr" || s.Name == "Value.Pointer") {
+		if s := n.Left.Sym; Debug.Checkptr != 0 && isReflectPkg(s.Pkg) && (s.Name == "Value.UnsafeAddr" || s.Name == "Value.Pointer") {
 			return n
 		}
 	}
@@ -931,7 +931,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	defer func() {
 		inlMap[fn] = false
 	}()
-	if Debug_typecheckinl == 0 {
+	if Debug.TypecheckInl == 0 {
 		typecheckinl(fn)
 	}
 
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 9cf988bca8..0d41f81a52 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -34,79 +34,8 @@ import (
 	"strings"
 )
 
-var (
-	Debug_append       int
-	Debug_checkptr     int
-	Debug_closure      int
-	Debug_compilelater int
-	debug_dclstack     int
-	Debug_dumpptrs     int
-	Debug_libfuzzer    int
-	Debug_panic        int
-	Debug_slice        int
-	Debug_wb           int
-	Debug_pctab        string
-	Debug_locationlist int
-	Debug_typecheckinl int
-	Debug_gendwarfinl  int
-	Debug_softfloat    int
-	Debug_defer        int
-)
-
-// Debug arguments.
-// These can be specified with the -d flag, as in "-d nil"
-// to set the debug_checknil variable.
-// Multiple options can be comma-separated.
-// Each option accepts an optional argument, as in "gcprog=2"
-var debugtab = []struct {
-	name string
-	help string
-	val  interface{} // must be *int or *string
-}{
-	{"append", "print information about append compilation", &Debug_append},
-	{"checkptr", "instrument unsafe pointer conversions", &Debug_checkptr},
-	{"closure", "print information about closure compilation", &Debug_closure},
-	{"compilelater", "compile functions as late as possible", &Debug_compilelater},
-	{"disablenil", "disable nil checks", &disable_checknil},
-	{"dclstack", "run internal dclstack check", &debug_dclstack},
-	{"dumpptrs", "show Node pointer values in Dump/dumplist output", &Debug_dumpptrs},
-	{"gcprog", "print dump of GC programs", &Debug_gcprog},
-	{"libfuzzer", "coverage instrumentation for libfuzzer", &Debug_libfuzzer},
-	{"nil", "print information about nil checks", &Debug_checknil},
-	{"panic", "do not hide any compiler panic", &Debug_panic},
-	{"slice", "print information about slice compilation", &Debug_slice},
-	{"typeassert", "print information about type assertion inlining", &Debug_typeassert},
-	{"wb", "print information about write barriers", &Debug_wb},
-	{"export", "print export data", &Debug_export},
-	{"pctab", "print named pc-value table", &Debug_pctab},
-	{"locationlists", "print information about DWARF location list creation", &Debug_locationlist},
-	{"typecheckinl", "eager typechecking of inline function bodies", &Debug_typecheckinl},
-	{"dwarfinl", "print information about DWARF inlined function creation", &Debug_gendwarfinl},
-	{"softfloat", "force compiler to emit soft-float code", &Debug_softfloat},
-	{"defer", "print information about defer compilation", &Debug_defer},
-	{"fieldtrack", "enable fieldtracking", &objabi.Fieldtrack_enabled},
-}
-
-const debugHelpHeader = `usage: -d arg[,arg]* and arg is <key>[=<value>]
-
-<key> is one of:
-
-`
-
-const debugHelpFooter = `
-<value> is key-specific.
-
-Key "checkptr" supports values:
-	"0": instrumentation disabled
-	"1": conversions involving unsafe.Pointer are instrumented
-	"2": conversions to unsafe.Pointer force heap allocation
-
-Key "pctab" supports values:
-	"pctospadj", "pctofile", "pctoline", "pctoinline", "pctopcdata"
-`
-
 func hidePanic() {
-	if Debug_panic == 0 && Errors() > 0 {
+	if Debug.Panic == 0 && Errors() > 0 {
 		// If we've already complained about things
 		// in the program, don't bother complaining
 		// about a panic too; let the user clean up
@@ -243,9 +172,9 @@ func Main(archInit func(*Arch)) {
 		instrumenting = true
 	}
 	if Flag.Dwarf {
-		dwarf.EnableLogging(Debug_gendwarfinl != 0)
+		dwarf.EnableLogging(Debug.DwarfInl != 0)
 	}
-	if Debug_softfloat != 0 {
+	if Debug.SoftFloat != 0 {
 		thearch.SoftFloat = true
 	}
 
@@ -396,7 +325,7 @@ func Main(archInit func(*Arch)) {
 
 	// Phase 5: Inlining
 	timings.Start("fe", "inlining")
-	if Debug_typecheckinl != 0 {
+	if Debug.TypecheckInl != 0 {
 		// Typecheck imported function bodies if Debug.l > 1,
 		// otherwise lazily when used or re-exported.
 		for _, n := range importlist {
@@ -501,7 +430,7 @@ func Main(archInit func(*Arch)) {
 	// DWARF inlining gen so as to avoid problems with generated
 	// method wrappers.
 	if Ctxt.DwFixups != nil {
-		Ctxt.DwFixups.Finalize(Ctxt.Pkgpath, Debug_gendwarfinl != 0)
+		Ctxt.DwFixups.Finalize(Ctxt.Pkgpath, Debug.DwarfInl != 0)
 		Ctxt.DwFixups = nil
 		Flag.GenDwarfInl = 0
 	}
@@ -944,7 +873,7 @@ func importfile(f constant.Value) *types.Pkg {
 		return nil
 
 	case 'B':
-		if Debug_export != 0 {
+		if Debug.Export != 0 {
 			fmt.Printf("importing %s (%s)\n", path_, file)
 		}
 		imp.ReadByte() // skip \n after $$B
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index ee0c8f2711..90c08b1b75 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -384,7 +384,7 @@ func orderMakeSliceCopy(s []*Node) {
 
 // edge inserts coverage instrumentation for libfuzzer.
 func (o *Order) edge() {
-	if Debug_libfuzzer == 0 {
+	if Debug.Libfuzzer == 0 {
 		return
 	}
 
@@ -998,7 +998,7 @@ func (o *Order) stmt(n *Node) {
 	// For now just clean all the temporaries at the end.
 	// In practice that's fine.
 	case OSWITCH:
-		if Debug_libfuzzer != 0 && !hasDefaultCase(n) {
+		if Debug.Libfuzzer != 0 && !hasDefaultCase(n) {
 			// Add empty "default:" case for instrumentation.
 			n.List.Append(nod(OCASE, nil, nil))
 		}
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index fe13a161bd..19a24a3235 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -291,7 +291,7 @@ func compilenow(fn *Node) bool {
 	if fn.IsMethod() && isInlinableButNotInlined(fn) {
 		return false
 	}
-	return Flag.LowerC == 1 && Debug_compilelater == 0
+	return Flag.LowerC == 1 && Debug.CompileLater == 0
 }
 
 // isInlinableButNotInlined returns true if 'fn' was marked as an
diff --git a/src/cmd/compile/internal/gc/print.go b/src/cmd/compile/internal/gc/print.go
index 6b5f670812..345f433fe4 100644
--- a/src/cmd/compile/internal/gc/print.go
+++ b/src/cmd/compile/internal/gc/print.go
@@ -208,7 +208,7 @@ func Fatalf(format string, args ...interface{}) {
 func FatalfAt(pos src.XPos, format string, args ...interface{}) {
 	flusherrors()
 
-	if Debug_panic != 0 || numErrors == 0 {
+	if Debug.Panic != 0 || numErrors == 0 {
 		fmt.Printf("%v: internal compiler error: ", linestr(pos))
 		fmt.Printf(format, args...)
 		fmt.Printf("\n")
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 674a3bf3fb..11ccc15a25 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -1787,13 +1787,11 @@ type GCProg struct {
 	w      gcprog.Writer
 }
 
-var Debug_gcprog int // set by -d gcprog
-
 func (p *GCProg) init(lsym *obj.LSym) {
 	p.lsym = lsym
 	p.symoff = 4 // first 4 bytes hold program length
 	p.w.Init(p.writeByte)
-	if Debug_gcprog > 0 {
+	if Debug.GCProg > 0 {
 		fmt.Fprintf(os.Stderr, "compile: start GCProg for %v\n", lsym)
 		p.w.Debug(os.Stderr)
 	}
@@ -1807,7 +1805,7 @@ func (p *GCProg) end() {
 	p.w.End()
 	duint32(p.lsym, 0, uint32(p.symoff-4))
 	ggloblsym(p.lsym, int32(p.symoff), obj.DUPOK|obj.RODATA|obj.LOCAL)
-	if Debug_gcprog > 0 {
+	if Debug.GCProg > 0 {
 		fmt.Fprintf(os.Stderr, "compile: end GCProg for %v\n", p.lsym)
 	}
 }
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 741e0ef9a3..1f89baa3c0 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -256,7 +256,7 @@ func (s *InitSchedule) staticassign(l *Node, r *Node) bool {
 
 	case OCLOSURE:
 		if hasemptycvars(r) {
-			if Debug_closure > 0 {
+			if Debug.Closure > 0 {
 				Warnl(r.Pos, "closure converted to global")
 			}
 			// Closures with no captured variables are globals,
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 260df2f54f..f06f08e6ab 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -1102,7 +1102,7 @@ func (s *state) stmt(n *Node) {
 			}
 		}
 	case ODEFER:
-		if Debug_defer > 0 {
+		if Debug.Defer > 0 {
 			var defertype string
 			if s.hasOpenDefers {
 				defertype = "open-coded"
@@ -1232,12 +1232,12 @@ func (s *state) stmt(n *Node) {
 				// so there will be no write barriers,
 				// so there's no need to attempt to prevent them.
 				if s.canSSA(n.Left) {
-					if Debug_append > 0 { // replicating old diagnostic message
+					if Debug.Append > 0 { // replicating old diagnostic message
 						Warnl(n.Pos, "append: len-only update (in local slice)")
 					}
 					break
 				}
-				if Debug_append > 0 {
+				if Debug.Append > 0 {
 					Warnl(n.Pos, "append: len-only update")
 				}
 				s.append(rhs, true)
@@ -5026,7 +5026,7 @@ func (s *state) exprPtr(n *Node, bounded bool, lineno src.XPos) *ssa.Value {
 // Used only for automatically inserted nil checks,
 // not for user code like 'x != nil'.
 func (s *state) nilCheck(ptr *ssa.Value) {
-	if disable_checknil != 0 || s.curfn.Func.NilCheckDisabled() {
+	if Debug.DisableNil != 0 || s.curfn.Func.NilCheckDisabled() {
 		return
 	}
 	s.newValue2(ssa.OpNilCheck, types.TypeVoid, ptr, s.mem())
@@ -5837,7 +5837,7 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
 		if n.Type.IsEmptyInterface() {
 			// Converting to an empty interface.
 			// Input could be an empty or nonempty interface.
-			if Debug_typeassert > 0 {
+			if Debug.TypeAssert > 0 {
 				Warnl(n.Pos, "type assertion inlined")
 			}
 
@@ -5904,7 +5904,7 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
 			return
 		}
 		// converting to a nonempty interface needs a runtime call.
-		if Debug_typeassert > 0 {
+		if Debug.TypeAssert > 0 {
 			Warnl(n.Pos, "type assertion not inlined")
 		}
 		if n.Left.Type.IsEmptyInterface() {
@@ -5921,14 +5921,14 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
 		return s.rtcall(assertI2I, true, []*types.Type{n.Type}, target, iface)[0], nil
 	}
 
-	if Debug_typeassert > 0 {
+	if Debug.TypeAssert > 0 {
 		Warnl(n.Pos, "type assertion inlined")
 	}
 
 	// Converting to a concrete type.
 	direct := isdirectiface(n.Type)
 	itab := s.newValue1(ssa.OpITab, byteptr, iface) // type word of interface
-	if Debug_typeassert > 0 {
+	if Debug.TypeAssert > 0 {
 		Warnl(n.Pos, "type assertion inlined")
 	}
 	var targetITab *ssa.Value
@@ -6474,7 +6474,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 	}
 
 	if Ctxt.Flag_locationlists {
-		e.curfn.Func.DebugInfo = ssa.BuildFuncDebug(Ctxt, f, Debug_locationlist > 1, stackOffset)
+		e.curfn.Func.DebugInfo = ssa.BuildFuncDebug(Ctxt, f, Debug.LocationLists > 1, stackOffset)
 		bstart := s.bstart
 		// Note that at this moment, Prog.Pc is a sequence number; it's
 		// not a real PC until after assembly, so this mapping has to
@@ -7113,7 +7113,7 @@ func (e *ssafn) Warnl(pos src.XPos, fmt_ string, args ...interface{}) {
 }
 
 func (e *ssafn) Debug_checknil() bool {
-	return Debug_checknil != 0
+	return Debug.Nil != 0
 }
 
 func (e *ssafn) UseWriteBarrier() bool {
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 32312e9545..989d10a561 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -1412,7 +1412,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	}
 
 	funcbody()
-	if debug_dclstack != 0 {
+	if Debug.DclStack != 0 {
 		testdclstack()
 	}
 
diff --git a/src/cmd/compile/internal/gc/syntax.go b/src/cmd/compile/internal/gc/syntax.go
index 75a7ae2c7a..f771a7184e 100644
--- a/src/cmd/compile/internal/gc/syntax.go
+++ b/src/cmd/compile/internal/gc/syntax.go
@@ -764,7 +764,7 @@ func (f *Func) SetInstrumentBody(b bool)           { f.flags.set(funcInstrumentB
 func (f *Func) SetOpenCodedDeferDisallowed(b bool) { f.flags.set(funcOpenCodedDeferDisallowed, b) }
 
 func (f *Func) setWBPos(pos src.XPos) {
-	if Debug_wb != 0 {
+	if Debug.WB != 0 {
 		Warnl(pos, "write barrier")
 	}
 	if !f.WBPos.IsKnown() {
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index c2d8411a59..de2733909e 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -1685,7 +1685,7 @@ func reduceSlice(n *Node) *Node {
 	n.SetSliceBounds(low, high, max)
 	if (n.Op == OSLICE || n.Op == OSLICESTR) && low == nil && high == nil {
 		// Reduce x[:] to x.
-		if Debug_slice > 0 {
+		if Debug.Slice > 0 {
 			Warn("slice: omit slice operation")
 		}
 		return n.Left
@@ -3262,7 +3262,7 @@ func walkcompare(n *Node, init *Nodes) *Node {
 
 	switch t.Etype {
 	default:
-		if Debug_libfuzzer != 0 && t.IsInteger() {
+		if Debug.Libfuzzer != 0 && t.IsInteger() {
 			n.Left = cheapexpr(n.Left, init)
 			n.Right = cheapexpr(n.Right, init)
 
@@ -4087,5 +4087,5 @@ func walkCheckPtrArithmetic(n *Node, init *Nodes) *Node {
 // function fn at a given level. See debugHelpFooter for defined
 // levels.
 func checkPtr(fn *Node, level int) bool {
-	return Debug_checkptr >= level && fn.Func.Pragma&NoCheckPtr == 0
+	return Debug.Checkptr >= level && fn.Func.Pragma&NoCheckPtr == 0
 }
diff --git a/src/cmd/compile/internal/mips/ssa.go b/src/cmd/compile/internal/mips/ssa.go
index 9d11c6bf53..1d2e2c79e6 100644
--- a/src/cmd/compile/internal/mips/ssa.go
+++ b/src/cmd/compile/internal/mips/ssa.go
@@ -766,7 +766,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		if logopt.Enabled() {
 			logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
 		}
-		if gc.Debug_checknil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
+		if gc.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
 			gc.Warnl(v.Pos, "generated nil check")
 		}
 	case ssa.OpMIPSFPFlagTrue,
diff --git a/src/cmd/compile/internal/mips64/ssa.go b/src/cmd/compile/internal/mips64/ssa.go
index 2727c4d8a8..067b8158c9 100644
--- a/src/cmd/compile/internal/mips64/ssa.go
+++ b/src/cmd/compile/internal/mips64/ssa.go
@@ -724,7 +724,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		if logopt.Enabled() {
 			logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
 		}
-		if gc.Debug_checknil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
+		if gc.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
 			gc.Warnl(v.Pos, "generated nil check")
 		}
 	case ssa.OpMIPS64FPFlagTrue,
diff --git a/src/cmd/compile/internal/ppc64/ssa.go b/src/cmd/compile/internal/ppc64/ssa.go
index 3e20c44a4c..f0e7c41923 100644
--- a/src/cmd/compile/internal/ppc64/ssa.go
+++ b/src/cmd/compile/internal/ppc64/ssa.go
@@ -1852,7 +1852,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		if logopt.Enabled() {
 			logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
 		}
-		if gc.Debug_checknil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
+		if gc.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
 			gc.Warnl(v.Pos, "generated nil check")
 		}
 
diff --git a/src/cmd/compile/internal/riscv64/ssa.go b/src/cmd/compile/internal/riscv64/ssa.go
index 0beb5b4bd1..d49927ee04 100644
--- a/src/cmd/compile/internal/riscv64/ssa.go
+++ b/src/cmd/compile/internal/riscv64/ssa.go
@@ -586,7 +586,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		gc.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = riscv.REG_ZERO
-		if gc.Debug_checknil != 0 && v.Pos.Line() > 1 { // v.Pos == 1 in generated wrappers
+		if gc.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos == 1 in generated wrappers
 			gc.Warnl(v.Pos, "generated nil check")
 		}
 
diff --git a/src/cmd/compile/internal/s390x/ssa.go b/src/cmd/compile/internal/s390x/ssa.go
index 8037357131..cb13f8d3c0 100644
--- a/src/cmd/compile/internal/s390x/ssa.go
+++ b/src/cmd/compile/internal/s390x/ssa.go
@@ -642,7 +642,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		if logopt.Enabled() {
 			logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
 		}
-		if gc.Debug_checknil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
+		if gc.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
 			gc.Warnl(v.Pos, "generated nil check")
 		}
 	case ssa.OpS390XMVC:
diff --git a/src/cmd/compile/internal/wasm/ssa.go b/src/cmd/compile/internal/wasm/ssa.go
index a36fbca4e0..3f05515b9a 100644
--- a/src/cmd/compile/internal/wasm/ssa.go
+++ b/src/cmd/compile/internal/wasm/ssa.go
@@ -165,7 +165,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		if logopt.Enabled() {
 			logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
 		}
-		if gc.Debug_checknil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
+		if gc.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
 			gc.Warnl(v.Pos, "generated nil check")
 		}
 
diff --git a/src/cmd/compile/internal/x86/ssa.go b/src/cmd/compile/internal/x86/ssa.go
index fbf76d0c5e..65d7e75a53 100644
--- a/src/cmd/compile/internal/x86/ssa.go
+++ b/src/cmd/compile/internal/x86/ssa.go
@@ -850,7 +850,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		if logopt.Enabled() {
 			logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
 		}
-		if gc.Debug_checknil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
+		if gc.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
 			gc.Warnl(v.Pos, "generated nil check")
 		}
 	case ssa.OpClobber:
-- 
GitLab


From eb3086e5a8958723ae696ea48d4cc7981c6779fa Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 16 Nov 2020 01:44:47 -0500
Subject: [PATCH 0066/2400] [dev.regabi] cmd/compile: finish cleanup of Debug
 parsing

Now that the debug settings are in a struct, use struct tags to set
the usage messages and use reflection to populate debugtab,
much like we did for the Flag struct.

Change-Id: Id2ba30c30a9158c062527715a68bf4dd94679457
Reviewed-on: https://go-review.googlesource.com/c/go/+/272247
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/debug.go | 261 +++++++++++++++------------
 src/cmd/compile/internal/gc/flag.go  |  33 ++--
 src/cmd/compile/internal/gc/main.go  |   3 +-
 3 files changed, 162 insertions(+), 135 deletions(-)

diff --git a/src/cmd/compile/internal/gc/debug.go b/src/cmd/compile/internal/gc/debug.go
index f6be3d57b0..98e6631e5b 100644
--- a/src/cmd/compile/internal/gc/debug.go
+++ b/src/cmd/compile/internal/gc/debug.go
@@ -2,149 +2,176 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// Debug arguments, set by -d flag.
+
 package gc
 
 import (
 	"fmt"
 	"log"
 	"os"
+	"reflect"
 	"strconv"
 	"strings"
 
-	"cmd/compile/internal/ssa"
 	"cmd/internal/objabi"
 )
 
-// Debug arguments.
-// These can be specified with the -d flag, as in "-d nil"
-// to set the debug_checknil variable.
-// Multiple options can be comma-separated.
-// Each option accepts an optional argument, as in "gcprog=2"
-var debugtab = []struct {
+// Debug holds the parsed debugging configuration values.
+var Debug = DebugFlags{
+	Fieldtrack: &objabi.Fieldtrack_enabled,
+}
+
+// DebugFlags defines the debugging configuration values (see var Debug).
+// Each struct field is a different value, named for the lower-case of the field name.
+// Each field must be an int or string and must have a `help` struct tag.
+//
+// The -d option takes a comma-separated list of settings.
+// Each setting is name=value; for ints, name is short for name=1.
+type DebugFlags struct {
+	Append        int    `help:"print information about append compilation"`
+	Checkptr      int    `help:"instrument unsafe pointer conversions"`
+	Closure       int    `help:"print information about closure compilation"`
+	CompileLater  int    `help:"compile functions as late as possible"`
+	DclStack      int    `help:"run internal dclstack check"`
+	Defer         int    `help:"print information about defer compilation"`
+	DisableNil    int    `help:"disable nil checks"`
+	DumpPtrs      int    `help:"show Node pointers values in dump output"`
+	DwarfInl      int    `help:"print information about DWARF inlined function creation"`
+	Export        int    `help:"print export data"`
+	Fieldtrack    *int   `help:"enable field tracking"`
+	GCProg        int    `help:"print dump of GC programs"`
+	Libfuzzer     int    `help:"enable coverage instrumentation for libfuzzer"`
+	LocationLists int    `help:"print information about DWARF location list creation"`
+	Nil           int    `help:"print information about nil checks"`
+	PCTab         string `help:"print named pc-value table"`
+	Panic         int    `help:"show all compiler panics"`
+	Slice         int    `help:"print information about slice compilation"`
+	SoftFloat     int    `help:"force compiler to emit soft-float code"`
+	TypeAssert    int    `help:"print information about type assertion inlining"`
+	TypecheckInl  int    `help:"eager typechecking of inline function bodies"`
+	WB            int    `help:"print information about write barriers"`
+
+	any bool // set when any of the values have been set
+}
+
+// Any reports whether any of the debug flags have been set.
+func (d *DebugFlags) Any() bool { return d.any }
+
+type debugField struct {
 	name string
 	help string
-	val  interface{} // must be *int or *string
-}{
-	{"append", "print information about append compilation", &Debug.Append},
-	{"checkptr", "instrument unsafe pointer conversions", &Debug.Checkptr},
-	{"closure", "print information about closure compilation", &Debug.Closure},
-	{"compilelater", "compile functions as late as possible", &Debug.CompileLater},
-	{"disablenil", "disable nil checks", &Debug.DisableNil},
-	{"dclstack", "run internal dclstack check", &Debug.DclStack},
-	{"dumpptrs", "show Node pointer values in Dump/dumplist output", &Debug.DumpPtrs},
-	{"gcprog", "print dump of GC programs", &Debug.GCProg},
-	{"libfuzzer", "coverage instrumentation for libfuzzer", &Debug.Libfuzzer},
-	{"nil", "print information about nil checks", &Debug.Nil},
-	{"panic", "do not hide any compiler panic", &Debug.Panic},
-	{"slice", "print information about slice compilation", &Debug.Slice},
-	{"typeassert", "print information about type assertion inlining", &Debug.TypeAssert},
-	{"wb", "print information about write barriers", &Debug.WB},
-	{"export", "print export data", &Debug.Export},
-	{"pctab", "print named pc-value table", &Debug.PCTab},
-	{"locationlists", "print information about DWARF location list creation", &Debug.LocationLists},
-	{"typecheckinl", "eager typechecking of inline function bodies", &Debug.TypecheckInl},
-	{"dwarfinl", "print information about DWARF inlined function creation", &Debug.DwarfInl},
-	{"softfloat", "force compiler to emit soft-float code", &Debug.SoftFloat},
-	{"defer", "print information about defer compilation", &Debug.Defer},
-	{"fieldtrack", "enable fieldtracking", &objabi.Fieldtrack_enabled},
+	val  interface{} // *int or *string
 }
 
-var Debug struct {
-	Append        int
-	Checkptr      int
-	Closure       int
-	CompileLater  int
-	DisableNil    int
-	DclStack      int
-	GCProg        int
-	Libfuzzer     int
-	Nil           int
-	Panic         int
-	Slice         int
-	TypeAssert    int
-	WB            int
-	Export        int
-	PCTab         string
-	LocationLists int
-	TypecheckInl  int
-	DwarfInl      int
-	SoftFloat     int
-	Defer         int
-	DumpPtrs      int
+var debugTab []debugField
+
+func init() {
+	v := reflect.ValueOf(&Debug).Elem()
+	t := v.Type()
+	for i := 0; i < t.NumField(); i++ {
+		f := t.Field(i)
+		if f.Name == "any" {
+			continue
+		}
+		name := strings.ToLower(f.Name)
+		help := f.Tag.Get("help")
+		if help == "" {
+			panic(fmt.Sprintf("base.Debug.%s is missing help text", f.Name))
+		}
+		ptr := v.Field(i).Addr().Interface()
+		switch ptr.(type) {
+		default:
+			panic(fmt.Sprintf("base.Debug.%s has invalid type %v (must be int or string)", f.Name, f.Type))
+		case *int, *string:
+			// ok
+		case **int:
+			ptr = *ptr.(**int) // record the *int itself
+		}
+		debugTab = append(debugTab, debugField{name, help, ptr})
+	}
 }
 
-func parseDebug() {
+// DebugSSA is called to set a -d ssa/... option.
+// If nil, those options are reported as invalid options.
+// If DebugSSA returns a non-empty string, that text is reported as a compiler error.
+var DebugSSA func(phase, flag string, val int, valString string) string
+
+// parseDebug parses the -d debug string argument.
+func parseDebug(debugstr string) {
 	// parse -d argument
-	if Flag.LowerD != "" {
-	Split:
-		for _, name := range strings.Split(Flag.LowerD, ",") {
-			if name == "" {
-				continue
-			}
-			// display help about the -d option itself and quit
-			if name == "help" {
-				fmt.Print(debugHelpHeader)
-				maxLen := len("ssa/help")
-				for _, t := range debugtab {
-					if len(t.name) > maxLen {
-						maxLen = len(t.name)
-					}
-				}
-				for _, t := range debugtab {
-					fmt.Printf("\t%-*s\t%s\n", maxLen, t.name, t.help)
+	if debugstr == "" {
+		return
+	}
+	Debug.any = true
+Split:
+	for _, name := range strings.Split(debugstr, ",") {
+		if name == "" {
+			continue
+		}
+		// display help about the -d option itself and quit
+		if name == "help" {
+			fmt.Print(debugHelpHeader)
+			maxLen := len("ssa/help")
+			for _, t := range debugTab {
+				if len(t.name) > maxLen {
+					maxLen = len(t.name)
 				}
-				// ssa options have their own help
-				fmt.Printf("\t%-*s\t%s\n", maxLen, "ssa/help", "print help about SSA debugging")
-				fmt.Print(debugHelpFooter)
-				os.Exit(0)
 			}
-			val, valstring, haveInt := 1, "", true
-			if i := strings.IndexAny(name, "=:"); i >= 0 {
-				var err error
-				name, valstring = name[:i], name[i+1:]
-				val, err = strconv.Atoi(valstring)
-				if err != nil {
-					val, haveInt = 1, false
-				}
+			for _, t := range debugTab {
+				fmt.Printf("\t%-*s\t%s\n", maxLen, t.name, t.help)
 			}
-			for _, t := range debugtab {
-				if t.name != name {
-					continue
-				}
-				switch vp := t.val.(type) {
-				case nil:
-					// Ignore
-				case *string:
-					*vp = valstring
-				case *int:
-					if !haveInt {
-						log.Fatalf("invalid debug value %v", name)
-					}
-					*vp = val
-				default:
-					panic("bad debugtab type")
-				}
-				continue Split
+			// ssa options have their own help
+			fmt.Printf("\t%-*s\t%s\n", maxLen, "ssa/help", "print help about SSA debugging")
+			fmt.Print(debugHelpFooter)
+			os.Exit(0)
+		}
+		val, valstring, haveInt := 1, "", true
+		if i := strings.IndexAny(name, "=:"); i >= 0 {
+			var err error
+			name, valstring = name[:i], name[i+1:]
+			val, err = strconv.Atoi(valstring)
+			if err != nil {
+				val, haveInt = 1, false
 			}
-			// special case for ssa for now
-			if strings.HasPrefix(name, "ssa/") {
-				// expect form ssa/phase/flag
-				// e.g. -d=ssa/generic_cse/time
-				// _ in phase name also matches space
-				phase := name[4:]
-				flag := "debug" // default flag is debug
-				if i := strings.Index(phase, "/"); i >= 0 {
-					flag = phase[i+1:]
-					phase = phase[:i]
-				}
-				err := ssa.PhaseOption(phase, flag, val, valstring)
-				if err != "" {
-					log.Fatalf(err)
+		}
+		for _, t := range debugTab {
+			if t.name != name {
+				continue
+			}
+			switch vp := t.val.(type) {
+			case nil:
+				// Ignore
+			case *string:
+				*vp = valstring
+			case *int:
+				if !haveInt {
+					log.Fatalf("invalid debug value %v", name)
 				}
-				continue Split
+				*vp = val
+			default:
+				panic("bad debugtab type")
+			}
+			continue Split
+		}
+		// special case for ssa for now
+		if DebugSSA != nil && strings.HasPrefix(name, "ssa/") {
+			// expect form ssa/phase/flag
+			// e.g. -d=ssa/generic_cse/time
+			// _ in phase name also matches space
+			phase := name[4:]
+			flag := "debug" // default flag is debug
+			if i := strings.Index(phase, "/"); i >= 0 {
+				flag = phase[i+1:]
+				phase = phase[:i]
+			}
+			err := DebugSSA(phase, flag, val, valstring)
+			if err != "" {
+				log.Fatalf(err)
 			}
-			log.Fatalf("unknown debug key -d %s\n", name)
+			continue Split
 		}
+		log.Fatalf("unknown debug key -d %s\n", name)
 	}
 }
 
diff --git a/src/cmd/compile/internal/gc/flag.go b/src/cmd/compile/internal/gc/flag.go
index 06b0a88ba3..29aac3aa28 100644
--- a/src/cmd/compile/internal/gc/flag.go
+++ b/src/cmd/compile/internal/gc/flag.go
@@ -63,19 +63,19 @@ type CmdFlags struct {
 	// V is added by objabi.AddVersionFlag
 	W CountFlag "help:\"debug parse tree after type checking\""
 
-	LowerC int       "help:\"concurrency during compilation (1 means no concurrency)\""
-	LowerD string    "help:\"enable debugging settings; try -d help\""
-	LowerE CountFlag "help:\"no limit on number of errors reported\""
-	LowerH CountFlag "help:\"halt on error\""
-	LowerJ CountFlag "help:\"debug runtime-initialized variables\""
-	LowerL CountFlag "help:\"disable inlining\""
-	LowerM CountFlag "help:\"print optimization decisions\""
-	LowerO string    "help:\"write output to `file`\""
-	LowerP *string   "help:\"set expected package import `path`\"" // &Ctxt.Pkgpath, set below
-	LowerR CountFlag "help:\"debug generated wrappers\""
-	LowerT bool      "help:\"enable tracing for debugging the compiler\""
-	LowerW CountFlag "help:\"debug type checking\""
-	LowerV *bool     "help:\"increase debug verbosity\""
+	LowerC int          "help:\"concurrency during compilation (1 means no concurrency)\""
+	LowerD func(string) "help:\"enable debugging settings; try -d help\""
+	LowerE CountFlag    "help:\"no limit on number of errors reported\""
+	LowerH CountFlag    "help:\"halt on error\""
+	LowerJ CountFlag    "help:\"debug runtime-initialized variables\""
+	LowerL CountFlag    "help:\"disable inlining\""
+	LowerM CountFlag    "help:\"print optimization decisions\""
+	LowerO string       "help:\"write output to `file`\""
+	LowerP *string      "help:\"set expected package import `path`\"" // &Ctxt.Pkgpath, set below
+	LowerR CountFlag    "help:\"debug generated wrappers\""
+	LowerT bool         "help:\"enable tracing for debugging the compiler\""
+	LowerW CountFlag    "help:\"debug type checking\""
+	LowerV *bool        "help:\"increase debug verbosity\""
 
 	// Special characters
 	Percent          int  "flag:\"%\" help:\"debug non-static initializers\""
@@ -137,6 +137,7 @@ func ParseFlags() {
 	Flag.I = addImportDir
 
 	Flag.LowerC = 1
+	Flag.LowerD = parseDebug
 	Flag.LowerP = &Ctxt.Pkgpath
 	Flag.LowerV = &Ctxt.Debugvlog
 
@@ -174,7 +175,7 @@ func ParseFlags() {
 	Ctxt.Flag_optimize = Flag.N == 0
 	Ctxt.Debugasm = int(Flag.S)
 
-	if flag.NArg() < 1 && Flag.LowerD != "help" && Flag.LowerD != "ssa/help" {
+	if flag.NArg() < 1 {
 		usage()
 	}
 
@@ -221,8 +222,6 @@ func ParseFlags() {
 		log.Fatalf("cannot use concurrent backend compilation with provided flags; invoked as %v", os.Args)
 	}
 
-	parseDebug()
-
 	if Flag.CompilingRuntime {
 		// Runtime can't use -d=checkptr, at least not yet.
 		Debug.Checkptr = 0
@@ -330,7 +329,7 @@ func concurrentBackendAllowed() bool {
 	// while writing the object file, and that is non-concurrent.
 	// Adding Debug_vlog, however, causes Debug.S to also print
 	// while flushing the plist, which happens concurrently.
-	if Ctxt.Debugvlog || Flag.LowerD != "" || Flag.Live > 0 {
+	if Ctxt.Debugvlog || Debug.Any() || Flag.Live > 0 {
 		return false
 	}
 	// TODO: Test and delete this condition.
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 0d41f81a52..2794ba3694 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -10,7 +10,7 @@ import (
 	"bufio"
 	"bytes"
 	"cmd/compile/internal/logopt"
-
+	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
 	"cmd/internal/bio"
 	"cmd/internal/dwarf"
@@ -112,6 +112,7 @@ func Main(archInit func(*Arch)) {
 	// pseudo-package used for methods with anonymous receivers
 	gopkg = types.NewPkg("go", "")
 
+	DebugSSA = ssa.PhaseOption
 	ParseFlags()
 
 	// Record flags that affect the build result. (And don't
-- 
GitLab


From 26b66fd60b258d323d7b8df2c489d5bd292c0809 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 19 Nov 2020 20:49:23 -0500
Subject: [PATCH 0067/2400] [dev.regabi] cmd/compile: introduce
 cmd/compile/internal/base [generated]

Move Flag, Debug, Ctxt, Exit, and error messages to
new package cmd/compile/internal/base.

These are the core functionality that everything in gc uses
and which otherwise prevent splitting any other code
out of gc into different packages.

A minor milestone: the compiler source code
no longer contains the string "yy".

[git-generate]
cd src/cmd/compile/internal/gc
rf '
        mv atExit AtExit
        mv Ctxt atExitFuncs AtExit Exit base.go

        mv lineno Pos
        mv linestr FmtPos
        mv flusherrors FlushErrors
        mv yyerror Errorf
        mv yyerrorl ErrorfAt
        mv yyerrorv ErrorfVers
        mv noder.yyerrorpos noder.errorAt
        mv Warnl WarnfAt
        mv errorexit ErrorExit

        mv base.go debug.go flag.go print.go cmd/compile/internal/base
'

: # update comments
sed -i '' 's/yyerrorl/ErrorfAt/g; s/yyerror/Errorf/g' *.go

: # bootstrap.go is not built by default so invisible to rf
sed -i '' 's/Fatalf/base.Fatalf/' bootstrap.go
goimports -w bootstrap.go

: # update cmd/dist to add internal/base
cd ../../../dist
sed -i '' '/internal.amd64/a\
	"cmd/compile/internal/base",
' buildtool.go
gofmt -w buildtool.go

Change-Id: I59903c7084222d6eaee38823fd222159ba24a31a
Reviewed-on: https://go-review.googlesource.com/c/go/+/272250
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/amd64/ggen.go        |   3 +-
 src/cmd/compile/internal/amd64/ssa.go         |   9 +-
 src/cmd/compile/internal/arm/ssa.go           |   7 +-
 src/cmd/compile/internal/arm64/ssa.go         |   7 +-
 src/cmd/compile/internal/base/base.go         |  28 +
 .../compile/internal/{gc => base}/debug.go    |   2 +-
 src/cmd/compile/internal/{gc => base}/flag.go |   3 +-
 .../compile/internal/{gc => base}/print.go    |  53 +-
 src/cmd/compile/internal/gc/alg.go            |  29 +-
 src/cmd/compile/internal/gc/align.go          |  51 +-
 src/cmd/compile/internal/gc/bootstrap.go      |   7 +-
 src/cmd/compile/internal/gc/bv.go             |  12 +-
 src/cmd/compile/internal/gc/closure.go        |  45 +-
 src/cmd/compile/internal/gc/const.go          |  91 ++--
 src/cmd/compile/internal/gc/dcl.go            | 127 ++---
 src/cmd/compile/internal/gc/dump.go           |   3 +-
 src/cmd/compile/internal/gc/dwinl.go          |  65 +--
 src/cmd/compile/internal/gc/embed.go          |  43 +-
 src/cmd/compile/internal/gc/esc.go            |  53 +-
 src/cmd/compile/internal/gc/escape.go         |  99 ++--
 src/cmd/compile/internal/gc/export.go         |  31 +-
 src/cmd/compile/internal/gc/fmt.go            |  15 +-
 src/cmd/compile/internal/gc/gen.go            |   9 +-
 src/cmd/compile/internal/gc/go.go             |   7 +-
 src/cmd/compile/internal/gc/gsubr.go          |  33 +-
 src/cmd/compile/internal/gc/iexport.go        |  57 ++-
 src/cmd/compile/internal/gc/iimport.go        |  75 +--
 src/cmd/compile/internal/gc/init.go           |   5 +-
 src/cmd/compile/internal/gc/initorder.go      |  22 +-
 src/cmd/compile/internal/gc/inl.go            | 121 ++---
 src/cmd/compile/internal/gc/lex.go            |   3 +-
 src/cmd/compile/internal/gc/main.go           | 261 +++++-----
 src/cmd/compile/internal/gc/noder.go          | 115 ++---
 src/cmd/compile/internal/gc/obj.go            | 109 ++--
 src/cmd/compile/internal/gc/order.go          |  45 +-
 src/cmd/compile/internal/gc/pgen.go           |  69 +--
 src/cmd/compile/internal/gc/plive.go          |  41 +-
 src/cmd/compile/internal/gc/racewalk.go       |  15 +-
 src/cmd/compile/internal/gc/range.go          |  25 +-
 src/cmd/compile/internal/gc/reflect.go        | 119 ++---
 src/cmd/compile/internal/gc/scope.go          |   3 +-
 src/cmd/compile/internal/gc/select.go         |  43 +-
 src/cmd/compile/internal/gc/sinit.go          |  47 +-
 src/cmd/compile/internal/gc/ssa.go            | 143 +++---
 src/cmd/compile/internal/gc/subr.go           |  97 ++--
 src/cmd/compile/internal/gc/swt.go            |  51 +-
 src/cmd/compile/internal/gc/syntax.go         |  33 +-
 src/cmd/compile/internal/gc/trace.go          |   8 +-
 src/cmd/compile/internal/gc/typecheck.go      | 477 +++++++++---------
 src/cmd/compile/internal/gc/universe.go       |   5 +-
 src/cmd/compile/internal/gc/unsafe.go         |  14 +-
 src/cmd/compile/internal/gc/util.go           |  59 +--
 src/cmd/compile/internal/gc/walk.go           | 179 +++----
 src/cmd/compile/internal/mips/ggen.go         |   5 +-
 src/cmd/compile/internal/mips/ssa.go          |   7 +-
 src/cmd/compile/internal/mips64/ssa.go        |   7 +-
 src/cmd/compile/internal/ppc64/ggen.go        |   9 +-
 src/cmd/compile/internal/ppc64/ssa.go         |   9 +-
 src/cmd/compile/internal/riscv64/ggen.go      |   3 +-
 src/cmd/compile/internal/riscv64/ssa.go       |  15 +-
 src/cmd/compile/internal/s390x/ggen.go        |   3 +-
 src/cmd/compile/internal/s390x/ssa.go         |   7 +-
 src/cmd/compile/internal/wasm/ssa.go          |   7 +-
 src/cmd/compile/internal/x86/galign.go        |   5 +-
 src/cmd/compile/internal/x86/ssa.go           |  13 +-
 src/cmd/compile/main.go                       |   3 +-
 src/cmd/dist/buildtool.go                     |   2 +
 67 files changed, 1626 insertions(+), 1542 deletions(-)
 create mode 100644 src/cmd/compile/internal/base/base.go
 rename src/cmd/compile/internal/{gc => base}/debug.go (99%)
 rename src/cmd/compile/internal/{gc => base}/flag.go (99%)
 rename src/cmd/compile/internal/{gc => base}/print.go (89%)

diff --git a/src/cmd/compile/internal/amd64/ggen.go b/src/cmd/compile/internal/amd64/ggen.go
index 0c1456f4d0..ec98b8cca1 100644
--- a/src/cmd/compile/internal/amd64/ggen.go
+++ b/src/cmd/compile/internal/amd64/ggen.go
@@ -5,6 +5,7 @@
 package amd64
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
 	"cmd/internal/obj"
 	"cmd/internal/obj/x86"
@@ -64,7 +65,7 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.Pr
 	if cnt%int64(gc.Widthreg) != 0 {
 		// should only happen with nacl
 		if cnt%int64(gc.Widthptr) != 0 {
-			gc.Fatalf("zerorange count not a multiple of widthptr %d", cnt)
+			base.Fatalf("zerorange count not a multiple of widthptr %d", cnt)
 		}
 		if *state&ax == 0 {
 			p = pp.Appendpp(p, x86.AMOVQ, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index 1f2d626721..5e3b962076 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"math"
 
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
@@ -975,7 +976,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		r := v.Reg()
 		// See the comments in cmd/internal/obj/x86/obj6.go
 		// near CanUse1InsnTLS for a detailed explanation of these instructions.
-		if x86.CanUse1InsnTLS(gc.Ctxt) {
+		if x86.CanUse1InsnTLS(base.Ctxt) {
 			// MOVQ (TLS), r
 			p := s.Prog(x86.AMOVQ)
 			p.From.Type = obj.TYPE_MEM
@@ -1017,7 +1018,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		}
 		p := s.Prog(mov)
 		p.From.Type = obj.TYPE_ADDR
-		p.From.Offset = -gc.Ctxt.FixedFrameSize() // 0 on amd64, just to be consistent with other architectures
+		p.From.Offset = -base.Ctxt.FixedFrameSize() // 0 on amd64, just to be consistent with other architectures
 		p.From.Name = obj.NAME_PARAM
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
@@ -1164,8 +1165,8 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		if logopt.Enabled() {
 			logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
 		}
-		if gc.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
-			gc.Warnl(v.Pos, "generated nil check")
+		if base.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
+			base.WarnfAt(v.Pos, "generated nil check")
 		}
 	case ssa.OpAMD64MOVBatomicload, ssa.OpAMD64MOVLatomicload, ssa.OpAMD64MOVQatomicload:
 		p := s.Prog(v.Op.Asm())
diff --git a/src/cmd/compile/internal/arm/ssa.go b/src/cmd/compile/internal/arm/ssa.go
index 82a5172ec7..7d34cc5170 100644
--- a/src/cmd/compile/internal/arm/ssa.go
+++ b/src/cmd/compile/internal/arm/ssa.go
@@ -9,6 +9,7 @@ import (
 	"math"
 	"math/bits"
 
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
@@ -741,8 +742,8 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		if logopt.Enabled() {
 			logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
 		}
-		if gc.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
-			gc.Warnl(v.Pos, "generated nil check")
+		if base.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
+			base.WarnfAt(v.Pos, "generated nil check")
 		}
 	case ssa.OpARMLoweredZero:
 		// MOVW.P	Rarg2, 4(R1)
@@ -849,7 +850,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		// caller's SP is FixedFrameSize below the address of the first arg
 		p := s.Prog(arm.AMOVW)
 		p.From.Type = obj.TYPE_ADDR
-		p.From.Offset = -gc.Ctxt.FixedFrameSize()
+		p.From.Offset = -base.Ctxt.FixedFrameSize()
 		p.From.Name = obj.NAME_PARAM
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
diff --git a/src/cmd/compile/internal/arm64/ssa.go b/src/cmd/compile/internal/arm64/ssa.go
index dcbd8f9474..5e6f607708 100644
--- a/src/cmd/compile/internal/arm64/ssa.go
+++ b/src/cmd/compile/internal/arm64/ssa.go
@@ -7,6 +7,7 @@ package arm64
 import (
 	"math"
 
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
@@ -1038,8 +1039,8 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		if logopt.Enabled() {
 			logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
 		}
-		if gc.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Line==1 in generated wrappers
-			gc.Warnl(v.Pos, "generated nil check")
+		if base.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Line==1 in generated wrappers
+			base.WarnfAt(v.Pos, "generated nil check")
 		}
 	case ssa.OpARM64Equal,
 		ssa.OpARM64NotEqual,
@@ -1068,7 +1069,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		// caller's SP is FixedFrameSize below the address of the first arg
 		p := s.Prog(arm64.AMOVD)
 		p.From.Type = obj.TYPE_ADDR
-		p.From.Offset = -gc.Ctxt.FixedFrameSize()
+		p.From.Offset = -base.Ctxt.FixedFrameSize()
 		p.From.Name = obj.NAME_PARAM
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
diff --git a/src/cmd/compile/internal/base/base.go b/src/cmd/compile/internal/base/base.go
new file mode 100644
index 0000000000..e26b378472
--- /dev/null
+++ b/src/cmd/compile/internal/base/base.go
@@ -0,0 +1,28 @@
+// Copyright 2009 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 base
+
+import (
+	"os"
+
+	"cmd/internal/obj"
+)
+
+var Ctxt *obj.Link
+
+var atExitFuncs []func()
+
+func AtExit(f func()) {
+	atExitFuncs = append(atExitFuncs, f)
+}
+
+func Exit(code int) {
+	for i := len(atExitFuncs) - 1; i >= 0; i-- {
+		f := atExitFuncs[i]
+		atExitFuncs = atExitFuncs[:i]
+		f()
+	}
+	os.Exit(code)
+}
diff --git a/src/cmd/compile/internal/gc/debug.go b/src/cmd/compile/internal/base/debug.go
similarity index 99%
rename from src/cmd/compile/internal/gc/debug.go
rename to src/cmd/compile/internal/base/debug.go
index 98e6631e5b..45a552a4d9 100644
--- a/src/cmd/compile/internal/gc/debug.go
+++ b/src/cmd/compile/internal/base/debug.go
@@ -4,7 +4,7 @@
 
 // Debug arguments, set by -d flag.
 
-package gc
+package base
 
 import (
 	"fmt"
diff --git a/src/cmd/compile/internal/gc/flag.go b/src/cmd/compile/internal/base/flag.go
similarity index 99%
rename from src/cmd/compile/internal/gc/flag.go
rename to src/cmd/compile/internal/base/flag.go
index 29aac3aa28..aadc70f496 100644
--- a/src/cmd/compile/internal/gc/flag.go
+++ b/src/cmd/compile/internal/base/flag.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package base
 
 import (
 	"encoding/json"
@@ -13,7 +13,6 @@ import (
 	"os"
 	"reflect"
 	"runtime"
-
 	"strings"
 
 	"cmd/internal/objabi"
diff --git a/src/cmd/compile/internal/gc/print.go b/src/cmd/compile/internal/base/print.go
similarity index 89%
rename from src/cmd/compile/internal/gc/print.go
rename to src/cmd/compile/internal/base/print.go
index 345f433fe4..6831b3ada3 100644
--- a/src/cmd/compile/internal/gc/print.go
+++ b/src/cmd/compile/internal/base/print.go
@@ -2,16 +2,17 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package base
 
 import (
-	"cmd/internal/objabi"
-	"cmd/internal/src"
 	"fmt"
 	"os"
 	"runtime/debug"
 	"sort"
 	"strings"
+
+	"cmd/internal/objabi"
+	"cmd/internal/src"
 )
 
 // An errorMsg is a queued error message, waiting to be printed.
@@ -22,7 +23,7 @@ type errorMsg struct {
 
 // Pos is the current source position being processed,
 // printed by Errorf, ErrorfLang, Fatalf, and Warnf.
-var lineno src.XPos
+var Pos src.XPos
 
 var (
 	errorMsgs       []errorMsg
@@ -46,7 +47,7 @@ func addErrorMsg(pos src.XPos, format string, args ...interface{}) {
 	// Only add the position if know the position.
 	// See issue golang.org/issue/11361.
 	if pos.IsKnown() {
-		msg = fmt.Sprintf("%v: %s", linestr(pos), msg)
+		msg = fmt.Sprintf("%v: %s", FmtPos(pos), msg)
 	}
 	errorMsgs = append(errorMsgs, errorMsg{
 		pos: pos,
@@ -55,7 +56,7 @@ func addErrorMsg(pos src.XPos, format string, args ...interface{}) {
 }
 
 // FmtPos formats pos as a file:line string.
-func linestr(pos src.XPos) string {
+func FmtPos(pos src.XPos) string {
 	if Ctxt == nil {
 		return "???"
 	}
@@ -71,7 +72,7 @@ func (x byPos) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
 
 // FlushErrors sorts errors seen so far by line number, prints them to stdout,
 // and empties the errors array.
-func flusherrors() {
+func FlushErrors() {
 	Ctxt.Bso.Flush()
 	if len(errorMsgs) == 0 {
 		return
@@ -101,12 +102,12 @@ func sameline(a, b src.XPos) bool {
 }
 
 // Errorf reports a formatted error at the current line.
-func yyerror(format string, args ...interface{}) {
-	yyerrorl(lineno, format, args...)
+func Errorf(format string, args ...interface{}) {
+	ErrorfAt(Pos, format, args...)
 }
 
 // ErrorfAt reports a formatted error message at pos.
-func yyerrorl(pos src.XPos, format string, args ...interface{}) {
+func ErrorfAt(pos src.XPos, format string, args ...interface{}) {
 	msg := fmt.Sprintf(format, args...)
 
 	if strings.HasPrefix(msg, "syntax error") {
@@ -134,15 +135,15 @@ func yyerrorl(pos src.XPos, format string, args ...interface{}) {
 
 	hcrash()
 	if numErrors >= 10 && Flag.LowerE == 0 {
-		flusherrors()
-		fmt.Printf("%v: too many errors\n", linestr(pos))
-		errorexit()
+		FlushErrors()
+		fmt.Printf("%v: too many errors\n", FmtPos(pos))
+		ErrorExit()
 	}
 }
 
 // ErrorfVers reports that a language feature (format, args) requires a later version of Go.
-func yyerrorv(lang string, format string, args ...interface{}) {
-	yyerror("%s requires %s or later (-lang was set to %s; check go.mod)", fmt.Sprintf(format, args...), lang, Flag.Lang)
+func ErrorfVers(lang string, format string, args ...interface{}) {
+	Errorf("%s requires %s or later (-lang was set to %s; check go.mod)", fmt.Sprintf(format, args...), lang, Flag.Lang)
 }
 
 // UpdateErrorDot is a clumsy hack that rewrites the last error,
@@ -163,17 +164,17 @@ func UpdateErrorDot(line string, name, expr string) {
 // so this should be used only when the user has opted in
 // to additional output by setting a particular flag.
 func Warn(format string, args ...interface{}) {
-	Warnl(lineno, format, args...)
+	WarnfAt(Pos, format, args...)
 }
 
 // WarnfAt reports a formatted warning at pos.
 // In general the Go compiler does NOT generate warnings,
 // so this should be used only when the user has opted in
 // to additional output by setting a particular flag.
-func Warnl(pos src.XPos, format string, args ...interface{}) {
+func WarnfAt(pos src.XPos, format string, args ...interface{}) {
 	addErrorMsg(pos, format, args...)
 	if Flag.LowerM != 0 {
-		flusherrors()
+		FlushErrors()
 	}
 }
 
@@ -190,7 +191,7 @@ func Warnl(pos src.XPos, format string, args ...interface{}) {
 //
 // If -h has been specified, Fatalf panics to force the usual runtime info dump.
 func Fatalf(format string, args ...interface{}) {
-	FatalfAt(lineno, format, args...)
+	FatalfAt(Pos, format, args...)
 }
 
 // FatalfAt reports a fatal error - an internal problem - at pos and exits.
@@ -206,10 +207,10 @@ func Fatalf(format string, args ...interface{}) {
 //
 // If -h has been specified, FatalfAt panics to force the usual runtime info dump.
 func FatalfAt(pos src.XPos, format string, args ...interface{}) {
-	flusherrors()
+	FlushErrors()
 
 	if Debug.Panic != 0 || numErrors == 0 {
-		fmt.Printf("%v: internal compiler error: ", linestr(pos))
+		fmt.Printf("%v: internal compiler error: ", FmtPos(pos))
 		fmt.Printf(format, args...)
 		fmt.Printf("\n")
 
@@ -227,13 +228,13 @@ func FatalfAt(pos src.XPos, format string, args ...interface{}) {
 	}
 
 	hcrash()
-	errorexit()
+	ErrorExit()
 }
 
 // hcrash crashes the compiler when -h is set, to find out where a message is generated.
 func hcrash() {
 	if Flag.LowerH != 0 {
-		flusherrors()
+		FlushErrors()
 		if Flag.LowerO != "" {
 			os.Remove(Flag.LowerO)
 		}
@@ -243,8 +244,8 @@ func hcrash() {
 
 // ErrorExit handles an error-status exit.
 // It flushes any pending errors, removes the output file, and exits.
-func errorexit() {
-	flusherrors()
+func ErrorExit() {
+	FlushErrors()
 	if Flag.LowerO != "" {
 		os.Remove(Flag.LowerO)
 	}
@@ -254,6 +255,6 @@ func errorexit() {
 // ExitIfErrors calls ErrorExit if any errors have been reported.
 func ExitIfErrors() {
 	if Errors() > 0 {
-		errorexit()
+		ErrorExit()
 	}
 }
diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index 87b905ed59..517aaa4b81 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"fmt"
@@ -203,7 +204,7 @@ func algtype1(t *types.Type) (AlgKind, *types.Type) {
 		return ret, nil
 	}
 
-	Fatalf("algtype1: unexpected type %v", t)
+	base.Fatalf("algtype1: unexpected type %v", t)
 	return 0, nil
 }
 
@@ -214,7 +215,7 @@ func genhash(t *types.Type) *obj.LSym {
 	switch algtype(t) {
 	default:
 		// genhash is only called for types that have equality
-		Fatalf("genhash %v", t)
+		base.Fatalf("genhash %v", t)
 	case AMEM0:
 		return sysClosure("memhash0")
 	case AMEM8:
@@ -282,11 +283,11 @@ func genhash(t *types.Type) *obj.LSym {
 	}
 
 	sym := typesymprefix(".hash", t)
-	if Flag.LowerR != 0 {
+	if base.Flag.LowerR != 0 {
 		fmt.Printf("genhash %v %v %v\n", closure, sym, t)
 	}
 
-	lineno = autogeneratedPos // less confusing than end of input
+	base.Pos = autogeneratedPos // less confusing than end of input
 	dclcontext = PEXTERN
 
 	// func sym(p *T, h uintptr) uintptr
@@ -374,7 +375,7 @@ func genhash(t *types.Type) *obj.LSym {
 	r.List.Append(nh)
 	fn.Nbody.Append(r)
 
-	if Flag.LowerR != 0 {
+	if base.Flag.LowerR != 0 {
 		dumplist("genhash body", fn.Nbody)
 	}
 
@@ -387,7 +388,7 @@ func genhash(t *types.Type) *obj.LSym {
 	typecheckslice(fn.Nbody.Slice(), ctxStmt)
 	Curfn = nil
 
-	if Debug.DclStack != 0 {
+	if base.Debug.DclStack != 0 {
 		testdclstack()
 	}
 
@@ -407,7 +408,7 @@ func hashfor(t *types.Type) *Node {
 
 	switch a, _ := algtype1(t); a {
 	case AMEM:
-		Fatalf("hashfor with AMEM type")
+		base.Fatalf("hashfor with AMEM type")
 	case AINTER:
 		sym = Runtimepkg.Lookup("interhash")
 	case ANILINTER:
@@ -509,13 +510,13 @@ func geneq(t *types.Type) *obj.LSym {
 		return closure
 	}
 	sym := typesymprefix(".eq", t)
-	if Flag.LowerR != 0 {
+	if base.Flag.LowerR != 0 {
 		fmt.Printf("geneq %v\n", t)
 	}
 
 	// Autogenerate code for equality of structs and arrays.
 
-	lineno = autogeneratedPos // less confusing than end of input
+	base.Pos = autogeneratedPos // less confusing than end of input
 	dclcontext = PEXTERN
 
 	// func sym(p, q *T) bool
@@ -539,7 +540,7 @@ func geneq(t *types.Type) *obj.LSym {
 	// so t must be either an array or a struct.
 	switch t.Etype {
 	default:
-		Fatalf("geneq %v", t)
+		base.Fatalf("geneq %v", t)
 
 	case TARRAY:
 		nelem := t.NumElem()
@@ -753,7 +754,7 @@ func geneq(t *types.Type) *obj.LSym {
 	// We should really do a generic CL that shares epilogues across
 	// the board. See #24936.
 
-	if Flag.LowerR != 0 {
+	if base.Flag.LowerR != 0 {
 		dumplist("geneq body", fn.Nbody)
 	}
 
@@ -766,7 +767,7 @@ func geneq(t *types.Type) *obj.LSym {
 	typecheckslice(fn.Nbody.Slice(), ctxStmt)
 	Curfn = nil
 
-	if Debug.DclStack != 0 {
+	if base.Debug.DclStack != 0 {
 		testdclstack()
 	}
 
@@ -859,7 +860,7 @@ func eqstring(s, t *Node) (eqlen, eqmem *Node) {
 // eqtab must be evaluated before eqdata, and shortcircuiting is required.
 func eqinterface(s, t *Node) (eqtab, eqdata *Node) {
 	if !types.Identical(s.Type, t.Type) {
-		Fatalf("eqinterface %v %v", s.Type, t.Type)
+		base.Fatalf("eqinterface %v %v", s.Type, t.Type)
 	}
 	// func ifaceeq(tab *uintptr, x, y unsafe.Pointer) (ret bool)
 	// func efaceeq(typ *uintptr, x, y unsafe.Pointer) (ret bool)
@@ -949,7 +950,7 @@ func memrun(t *types.Type, start int) (size int64, next int) {
 // by padding.
 func ispaddedfield(t *types.Type, i int) bool {
 	if !t.IsStruct() {
-		Fatalf("ispaddedfield called non-struct %v", t)
+		base.Fatalf("ispaddedfield called non-struct %v", t)
 	}
 	end := t.Width
 	if i+1 < t.NumFields() {
diff --git a/src/cmd/compile/internal/gc/align.go b/src/cmd/compile/internal/gc/align.go
index 563bd5030c..a8cbbfd322 100644
--- a/src/cmd/compile/internal/gc/align.go
+++ b/src/cmd/compile/internal/gc/align.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"bytes"
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"fmt"
 	"sort"
@@ -21,7 +22,7 @@ var defercalc int
 
 func Rnd(o int64, r int64) int64 {
 	if r < 1 || r > 8 || r&(r-1) != 0 {
-		Fatalf("rnd %d", r)
+		base.Fatalf("rnd %d", r)
 	}
 	return (o + r - 1) &^ (r - 1)
 }
@@ -39,7 +40,7 @@ func expandiface(t *types.Type) {
 		case langSupported(1, 14, t.Pkg()) && !explicit && types.Identical(m.Type, prev.Type):
 			return
 		default:
-			yyerrorl(m.Pos, "duplicate method %s", m.Sym.Name)
+			base.ErrorfAt(m.Pos, "duplicate method %s", m.Sym.Name)
 		}
 		methods = append(methods, m)
 	}
@@ -59,7 +60,7 @@ func expandiface(t *types.Type) {
 		}
 
 		if !m.Type.IsInterface() {
-			yyerrorl(m.Pos, "interface contains embedded non-interface %v", m.Type)
+			base.ErrorfAt(m.Pos, "interface contains embedded non-interface %v", m.Type)
 			m.SetBroke(true)
 			t.SetBroke(true)
 			// Add to fields so that error messages
@@ -83,7 +84,7 @@ func expandiface(t *types.Type) {
 	sort.Sort(methcmp(methods))
 
 	if int64(len(methods)) >= thearch.MAXWIDTH/int64(Widthptr) {
-		yyerrorl(typePos(t), "interface too large")
+		base.ErrorfAt(typePos(t), "interface too large")
 	}
 	for i, m := range methods {
 		m.Offset = int64(i) * int64(Widthptr)
@@ -134,7 +135,7 @@ func widstruct(errtype *types.Type, t *types.Type, o int64, flag int) int64 {
 
 		w := f.Type.Width
 		if w < 0 {
-			Fatalf("invalid width %d", f.Type.Width)
+			base.Fatalf("invalid width %d", f.Type.Width)
 		}
 		if w == 0 {
 			lastzero = o
@@ -147,7 +148,7 @@ func widstruct(errtype *types.Type, t *types.Type, o int64, flag int) int64 {
 			maxwidth = 1<<31 - 1
 		}
 		if o >= maxwidth {
-			yyerrorl(typePos(errtype), "type %L too large", errtype)
+			base.ErrorfAt(typePos(errtype), "type %L too large", errtype)
 			o = 8 // small but nonzero
 		}
 	}
@@ -235,7 +236,7 @@ func reportTypeLoop(t *types.Type) {
 
 	var l []*types.Type
 	if !findTypeLoop(t, &l) {
-		Fatalf("failed to find type loop for: %v", t)
+		base.Fatalf("failed to find type loop for: %v", t)
 	}
 
 	// Rotate loop so that the earliest type declaration is first.
@@ -250,11 +251,11 @@ func reportTypeLoop(t *types.Type) {
 	var msg bytes.Buffer
 	fmt.Fprintf(&msg, "invalid recursive type %v\n", l[0])
 	for _, t := range l {
-		fmt.Fprintf(&msg, "\t%v: %v refers to\n", linestr(typePos(t)), t)
+		fmt.Fprintf(&msg, "\t%v: %v refers to\n", base.FmtPos(typePos(t)), t)
 		t.SetBroke(true)
 	}
-	fmt.Fprintf(&msg, "\t%v: %v", linestr(typePos(l[0])), l[0])
-	yyerrorl(typePos(l[0]), msg.String())
+	fmt.Fprintf(&msg, "\t%v: %v", base.FmtPos(typePos(l[0])), l[0])
+	base.ErrorfAt(typePos(l[0]), msg.String())
 }
 
 // dowidth calculates and stores the size and alignment for t.
@@ -268,7 +269,7 @@ func dowidth(t *types.Type) {
 		return
 	}
 	if Widthptr == 0 {
-		Fatalf("dowidth without betypeinit")
+		base.Fatalf("dowidth without betypeinit")
 	}
 
 	if t == nil {
@@ -292,7 +293,7 @@ func dowidth(t *types.Type) {
 			return
 		}
 		t.SetBroke(true)
-		Fatalf("width not calculated: %v", t)
+		base.Fatalf("width not calculated: %v", t)
 	}
 
 	// break infinite recursion if the broken recursive type
@@ -304,9 +305,9 @@ func dowidth(t *types.Type) {
 	// defer checkwidth calls until after we're done
 	defercheckwidth()
 
-	lno := lineno
+	lno := base.Pos
 	if asNode(t.Nod) != nil {
-		lineno = asNode(t.Nod).Pos
+		base.Pos = asNode(t.Nod).Pos
 	}
 
 	t.Width = -2
@@ -327,7 +328,7 @@ func dowidth(t *types.Type) {
 	var w int64
 	switch et {
 	default:
-		Fatalf("dowidth: unknown type: %v", t)
+		base.Fatalf("dowidth: unknown type: %v", t)
 
 	// compiler-specific stuff
 	case TINT8, TUINT8, TBOOL:
@@ -378,7 +379,7 @@ func dowidth(t *types.Type) {
 		t1 := t.ChanArgs()
 		dowidth(t1) // just in case
 		if t1.Elem().Width >= 1<<16 {
-			yyerrorl(typePos(t1), "channel element type too large (>64kB)")
+			base.ErrorfAt(typePos(t1), "channel element type too large (>64kB)")
 		}
 		w = 1 // anything will do
 
@@ -393,11 +394,11 @@ func dowidth(t *types.Type) {
 
 	case TANY:
 		// not a real type; should be replaced before use.
-		Fatalf("dowidth any")
+		base.Fatalf("dowidth any")
 
 	case TSTRING:
 		if sizeofString == 0 {
-			Fatalf("early dowidth string")
+			base.Fatalf("early dowidth string")
 		}
 		w = sizeofString
 		t.Align = uint8(Widthptr)
@@ -411,7 +412,7 @@ func dowidth(t *types.Type) {
 		if t.Elem().Width != 0 {
 			cap := (uint64(thearch.MAXWIDTH) - 1) / uint64(t.Elem().Width)
 			if uint64(t.NumElem()) > cap {
-				yyerrorl(typePos(t), "type %L larger than address space", t)
+				base.ErrorfAt(typePos(t), "type %L larger than address space", t)
 			}
 		}
 		w = t.NumElem() * t.Elem().Width
@@ -427,7 +428,7 @@ func dowidth(t *types.Type) {
 
 	case TSTRUCT:
 		if t.IsFuncArgStruct() {
-			Fatalf("dowidth fn struct %v", t)
+			base.Fatalf("dowidth fn struct %v", t)
 		}
 		w = widstruct(t, t, 0, 1)
 
@@ -447,24 +448,24 @@ func dowidth(t *types.Type) {
 		w = widstruct(t1, t1.Results(), w, Widthreg)
 		t1.Extra.(*types.Func).Argwid = w
 		if w%int64(Widthreg) != 0 {
-			Warn("bad type %v %d\n", t1, w)
+			base.Warn("bad type %v %d\n", t1, w)
 		}
 		t.Align = 1
 	}
 
 	if Widthptr == 4 && w != int64(int32(w)) {
-		yyerrorl(typePos(t), "type %v too large", t)
+		base.ErrorfAt(typePos(t), "type %v too large", t)
 	}
 
 	t.Width = w
 	if t.Align == 0 {
 		if w == 0 || w > 8 || w&(w-1) != 0 {
-			Fatalf("invalid alignment for %v", t)
+			base.Fatalf("invalid alignment for %v", t)
 		}
 		t.Align = uint8(w)
 	}
 
-	lineno = lno
+	base.Pos = lno
 
 	resumecheckwidth()
 }
@@ -495,7 +496,7 @@ func checkwidth(t *types.Type) {
 	// function arg structs should not be checked
 	// outside of the enclosing function.
 	if t.IsFuncArgStruct() {
-		Fatalf("checkwidth %v", t)
+		base.Fatalf("checkwidth %v", t)
 	}
 
 	if defercalc == 0 {
diff --git a/src/cmd/compile/internal/gc/bootstrap.go b/src/cmd/compile/internal/gc/bootstrap.go
index 967f75a9ac..2e13d6b57a 100644
--- a/src/cmd/compile/internal/gc/bootstrap.go
+++ b/src/cmd/compile/internal/gc/bootstrap.go
@@ -6,8 +6,11 @@
 
 package gc
 
-import "runtime"
+import (
+	"cmd/compile/internal/base"
+	"runtime"
+)
 
 func startMutexProfiling() {
-	Fatalf("mutex profiling unavailable in version %v", runtime.Version())
+	base.Fatalf("mutex profiling unavailable in version %v", runtime.Version())
 }
diff --git a/src/cmd/compile/internal/gc/bv.go b/src/cmd/compile/internal/gc/bv.go
index e32ab97ad5..d82851e7cb 100644
--- a/src/cmd/compile/internal/gc/bv.go
+++ b/src/cmd/compile/internal/gc/bv.go
@@ -6,6 +6,8 @@ package gc
 
 import (
 	"math/bits"
+
+	"cmd/compile/internal/base"
 )
 
 const (
@@ -35,7 +37,7 @@ func bvbulkalloc(nbit int32, count int32) bulkBvec {
 	nword := (nbit + wordBits - 1) / wordBits
 	size := int64(nword) * int64(count)
 	if int64(int32(size*4)) != size*4 {
-		Fatalf("bvbulkalloc too big: nbit=%d count=%d nword=%d size=%d", nbit, count, nword, size)
+		base.Fatalf("bvbulkalloc too big: nbit=%d count=%d nword=%d size=%d", nbit, count, nword, size)
 	}
 	return bulkBvec{
 		words: make([]uint32, size),
@@ -52,7 +54,7 @@ func (b *bulkBvec) next() bvec {
 
 func (bv1 bvec) Eq(bv2 bvec) bool {
 	if bv1.n != bv2.n {
-		Fatalf("bvequal: lengths %d and %d are not equal", bv1.n, bv2.n)
+		base.Fatalf("bvequal: lengths %d and %d are not equal", bv1.n, bv2.n)
 	}
 	for i, x := range bv1.b {
 		if x != bv2.b[i] {
@@ -68,7 +70,7 @@ func (dst bvec) Copy(src bvec) {
 
 func (bv bvec) Get(i int32) bool {
 	if i < 0 || i >= bv.n {
-		Fatalf("bvget: index %d is out of bounds with length %d\n", i, bv.n)
+		base.Fatalf("bvget: index %d is out of bounds with length %d\n", i, bv.n)
 	}
 	mask := uint32(1 << uint(i%wordBits))
 	return bv.b[i>>wordShift]&mask != 0
@@ -76,7 +78,7 @@ func (bv bvec) Get(i int32) bool {
 
 func (bv bvec) Set(i int32) {
 	if i < 0 || i >= bv.n {
-		Fatalf("bvset: index %d is out of bounds with length %d\n", i, bv.n)
+		base.Fatalf("bvset: index %d is out of bounds with length %d\n", i, bv.n)
 	}
 	mask := uint32(1 << uint(i%wordBits))
 	bv.b[i/wordBits] |= mask
@@ -84,7 +86,7 @@ func (bv bvec) Set(i int32) {
 
 func (bv bvec) Unset(i int32) {
 	if i < 0 || i >= bv.n {
-		Fatalf("bvunset: index %d is out of bounds with length %d\n", i, bv.n)
+		base.Fatalf("bvunset: index %d is out of bounds with length %d\n", i, bv.n)
 	}
 	mask := uint32(1 << uint(i%wordBits))
 	bv.b[i/wordBits] &^= mask
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index c25a446999..ad255c9c06 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/syntax"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
@@ -101,7 +102,7 @@ func typecheckclosure(clo *Node, top int) {
 		if !n.Name.Captured() {
 			n.Name.SetCaptured(true)
 			if n.Name.Decldepth == 0 {
-				Fatalf("typecheckclosure: var %S does not have decldepth assigned", n)
+				base.Fatalf("typecheckclosure: var %S does not have decldepth assigned", n)
 			}
 
 			// Ignore assignments to the variable in straightline code
@@ -171,8 +172,8 @@ var capturevarscomplete bool
 // We use value capturing for values <= 128 bytes that are never reassigned
 // after capturing (effectively constant).
 func capturevars(dcl *Node) {
-	lno := lineno
-	lineno = dcl.Pos
+	lno := base.Pos
+	base.Pos = dcl.Pos
 	fn := dcl.Func
 	cvars := fn.ClosureVars.Slice()
 	out := cvars[:0]
@@ -203,7 +204,7 @@ func capturevars(dcl *Node) {
 			outer = nod(OADDR, outer, nil)
 		}
 
-		if Flag.LowerM > 1 {
+		if base.Flag.LowerM > 1 {
 			var name *types.Sym
 			if v.Name.Curfn != nil && v.Name.Curfn.Func.Nname != nil {
 				name = v.Name.Curfn.Func.Nname.Sym
@@ -212,7 +213,7 @@ func capturevars(dcl *Node) {
 			if v.Name.Byval() {
 				how = "value"
 			}
-			Warnl(v.Pos, "%v capturing by %s: %v (addr=%v assign=%v width=%d)", name, how, v.Sym, outermost.Name.Addrtaken(), outermost.Name.Assigned(), int32(v.Type.Width))
+			base.WarnfAt(v.Pos, "%v capturing by %s: %v (addr=%v assign=%v width=%d)", name, how, v.Sym, outermost.Name.Addrtaken(), outermost.Name.Assigned(), int32(v.Type.Width))
 		}
 
 		outer = typecheck(outer, ctxExpr)
@@ -220,14 +221,14 @@ func capturevars(dcl *Node) {
 	}
 
 	fn.ClosureVars.Set(out)
-	lineno = lno
+	base.Pos = lno
 }
 
 // transformclosure is called in a separate phase after escape analysis.
 // It transform closure bodies to properly reference captured variables.
 func transformclosure(dcl *Node) {
-	lno := lineno
-	lineno = dcl.Pos
+	lno := base.Pos
+	base.Pos = dcl.Pos
 	fn := dcl.Func
 
 	if fn.ClosureCalled {
@@ -325,7 +326,7 @@ func transformclosure(dcl *Node) {
 		}
 	}
 
-	lineno = lno
+	base.Pos = lno
 }
 
 // hasemptycvars reports whether closure clo has an
@@ -337,15 +338,15 @@ func hasemptycvars(clo *Node) bool {
 // closuredebugruntimecheck applies boilerplate checks for debug flags
 // and compiling runtime
 func closuredebugruntimecheck(clo *Node) {
-	if Debug.Closure > 0 {
+	if base.Debug.Closure > 0 {
 		if clo.Esc == EscHeap {
-			Warnl(clo.Pos, "heap closure, captured vars = %v", clo.Func.ClosureVars)
+			base.WarnfAt(clo.Pos, "heap closure, captured vars = %v", clo.Func.ClosureVars)
 		} else {
-			Warnl(clo.Pos, "stack closure, captured vars = %v", clo.Func.ClosureVars)
+			base.WarnfAt(clo.Pos, "stack closure, captured vars = %v", clo.Func.ClosureVars)
 		}
 	}
-	if Flag.CompilingRuntime && clo.Esc == EscHeap {
-		yyerrorl(clo.Pos, "heap-allocated closure, not allowed in runtime")
+	if base.Flag.CompilingRuntime && clo.Esc == EscHeap {
+		base.ErrorfAt(clo.Pos, "heap-allocated closure, not allowed in runtime")
 	}
 }
 
@@ -386,8 +387,8 @@ func walkclosure(clo *Node, init *Nodes) *Node {
 
 	// If no closure vars, don't bother wrapping.
 	if hasemptycvars(clo) {
-		if Debug.Closure > 0 {
-			Warnl(clo.Pos, "closure converted to global")
+		if base.Debug.Closure > 0 {
+			base.WarnfAt(clo.Pos, "closure converted to global")
 		}
 		return fn.Nname
 	}
@@ -423,7 +424,7 @@ func typecheckpartialcall(dot *Node, sym *types.Sym) {
 		break
 
 	default:
-		Fatalf("invalid typecheckpartialcall")
+		base.Fatalf("invalid typecheckpartialcall")
 	}
 
 	// Create top-level function.
@@ -448,13 +449,13 @@ func makepartialcall(dot *Node, t0 *types.Type, meth *types.Sym) *Node {
 	sym.SetUniq(true)
 
 	savecurfn := Curfn
-	saveLineNo := lineno
+	saveLineNo := base.Pos
 	Curfn = nil
 
 	// Set line number equal to the line number where the method is declared.
 	var m *types.Field
 	if lookdot0(meth, rcvrtype, &m, false) == 1 && m.Pos.IsKnown() {
-		lineno = m.Pos
+		base.Pos = m.Pos
 	}
 	// Note: !m.Pos.IsKnown() happens for method expressions where
 	// the method is implicitly declared. The Error method of the
@@ -512,7 +513,7 @@ func makepartialcall(dot *Node, t0 *types.Type, meth *types.Sym) *Node {
 	sym.Def = asTypesNode(dcl)
 	xtop = append(xtop, dcl)
 	Curfn = savecurfn
-	lineno = saveLineNo
+	base.Pos = saveLineNo
 
 	return dcl
 }
@@ -579,14 +580,14 @@ func walkpartialcall(n *Node, init *Nodes) *Node {
 // referenced by method value n.
 func callpartMethod(n *Node) *types.Field {
 	if n.Op != OCALLPART {
-		Fatalf("expected OCALLPART, got %v", n)
+		base.Fatalf("expected OCALLPART, got %v", n)
 	}
 
 	// TODO(mdempsky): Optimize this. If necessary,
 	// makepartialcall could save m for us somewhere.
 	var m *types.Field
 	if lookdot0(n.Right.Sym, n.Left.Type, &m, false) != 1 {
-		Fatalf("failed to find field for OCALLPART")
+		base.Fatalf("failed to find field for OCALLPART")
 	}
 
 	return m
diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index e72962124a..98473b4cfb 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"fmt"
@@ -28,7 +29,7 @@ const (
 func (n *Node) ValueInterface() interface{} {
 	switch v := n.Val(); v.Kind() {
 	default:
-		Fatalf("unexpected constant: %v", v)
+		base.Fatalf("unexpected constant: %v", v)
 		panic("unreachable")
 	case constant.Bool:
 		return constant.BoolVal(v)
@@ -55,7 +56,7 @@ func int64Val(t *types.Type, v constant.Value) int64 {
 			return x
 		}
 	}
-	Fatalf("%v out of range for %v", v, t)
+	base.Fatalf("%v out of range for %v", v, t)
 	panic("unreachable")
 }
 
@@ -63,7 +64,7 @@ func float64Val(v constant.Value) float64 {
 	if x, _ := constant.Float64Val(v); !math.IsInf(x, 0) {
 		return x + 0 // avoid -0 (should not be needed, but be conservative)
 	}
-	Fatalf("bad float64 value: %v", v)
+	base.Fatalf("bad float64 value: %v", v)
 	panic("unreachable")
 }
 
@@ -80,7 +81,7 @@ func bigFloatVal(v constant.Value) *big.Float {
 	case *big.Rat:
 		f.SetRat(u)
 	default:
-		Fatalf("unexpected: %v", u)
+		base.Fatalf("unexpected: %v", u)
 	}
 	return f
 }
@@ -89,11 +90,11 @@ func bigFloatVal(v constant.Value) *big.Float {
 // n must be an integer or rune constant.
 func (n *Node) Int64Val() int64 {
 	if !Isconst(n, constant.Int) {
-		Fatalf("Int64Val(%v)", n)
+		base.Fatalf("Int64Val(%v)", n)
 	}
 	x, ok := constant.Int64Val(n.Val())
 	if !ok {
-		Fatalf("Int64Val(%v)", n)
+		base.Fatalf("Int64Val(%v)", n)
 	}
 	return x
 }
@@ -114,11 +115,11 @@ func (n *Node) CanInt64() bool {
 // n must be an integer or rune constant.
 func (n *Node) Uint64Val() uint64 {
 	if !Isconst(n, constant.Int) {
-		Fatalf("Uint64Val(%v)", n)
+		base.Fatalf("Uint64Val(%v)", n)
 	}
 	x, ok := constant.Uint64Val(n.Val())
 	if !ok {
-		Fatalf("Uint64Val(%v)", n)
+		base.Fatalf("Uint64Val(%v)", n)
 	}
 	return x
 }
@@ -127,7 +128,7 @@ func (n *Node) Uint64Val() uint64 {
 // n must be a boolean constant.
 func (n *Node) BoolVal() bool {
 	if !Isconst(n, constant.Bool) {
-		Fatalf("BoolVal(%v)", n)
+		base.Fatalf("BoolVal(%v)", n)
 	}
 	return constant.BoolVal(n.Val())
 }
@@ -136,7 +137,7 @@ func (n *Node) BoolVal() bool {
 // n must be a string constant.
 func (n *Node) StringVal() string {
 	if !Isconst(n, constant.String) {
-		Fatalf("StringVal(%v)", n)
+		base.Fatalf("StringVal(%v)", n)
 	}
 	return constant.StringVal(n.Val())
 }
@@ -150,7 +151,7 @@ func roundFloat(v constant.Value, sz int64) constant.Value {
 		f, _ := constant.Float64Val(v)
 		return makeFloat64(f)
 	}
-	Fatalf("unexpected size: %v", sz)
+	base.Fatalf("unexpected size: %v", sz)
 	panic("unreachable")
 }
 
@@ -169,7 +170,7 @@ func truncfltlit(v constant.Value, t *types.Type) constant.Value {
 
 // truncate Real and Imag parts of Mpcplx to 32-bit or 64-bit
 // precision, according to type; return truncated value. In case of
-// overflow, calls yyerror but does not truncate the input value.
+// overflow, calls Errorf but does not truncate the input value.
 func trunccmplxlit(v constant.Value, t *types.Type) constant.Value {
 	if t.IsUntyped() || overflow(v, t) {
 		// If there was overflow, simply continuing would set the
@@ -199,10 +200,10 @@ func defaultlit(n *Node, t *types.Type) *Node { return convlit1(n, t, false, nil
 // message.
 func convlit1(n *Node, t *types.Type, explicit bool, context func() string) *Node {
 	if explicit && t == nil {
-		Fatalf("explicit conversion missing type")
+		base.Fatalf("explicit conversion missing type")
 	}
 	if t != nil && t.IsUntyped() {
-		Fatalf("bad conversion to untyped: %v", t)
+		base.Fatalf("bad conversion to untyped: %v", t)
 	}
 
 	if n == nil || n.Type == nil {
@@ -223,10 +224,10 @@ func convlit1(n *Node, t *types.Type, explicit bool, context func() string) *Nod
 	// Nil is technically not a constant, so handle it specially.
 	if n.Type.Etype == TNIL {
 		if n.Op != ONIL {
-			Fatalf("unexpected op: %v (%v)", n, n.Op)
+			base.Fatalf("unexpected op: %v (%v)", n, n.Op)
 		}
 		if t == nil {
-			yyerror("use of untyped nil")
+			base.Errorf("use of untyped nil")
 			n.SetDiag(true)
 			n.Type = nil
 			return n
@@ -247,7 +248,7 @@ func convlit1(n *Node, t *types.Type, explicit bool, context func() string) *Nod
 
 	switch n.Op {
 	default:
-		Fatalf("unexpected untyped expression: %v", n)
+		base.Fatalf("unexpected untyped expression: %v", n)
 
 	case OLITERAL:
 		v := convertVal(n.Val(), t, explicit)
@@ -287,7 +288,7 @@ func convlit1(n *Node, t *types.Type, explicit bool, context func() string) *Nod
 			return n
 		}
 		if !types.Identical(n.Left.Type, n.Right.Type) {
-			yyerror("invalid operation: %v (mismatched types %v and %v)", n, n.Left.Type, n.Right.Type)
+			base.Errorf("invalid operation: %v (mismatched types %v and %v)", n, n.Left.Type, n.Right.Type)
 			n.Type = nil
 			return n
 		}
@@ -306,7 +307,7 @@ func convlit1(n *Node, t *types.Type, explicit bool, context func() string) *Nod
 		n.Left = convlit1(n.Left, t, explicit, nil)
 		n.Type = n.Left.Type
 		if n.Type != nil && !n.Type.IsInteger() {
-			yyerror("invalid operation: %v (shift of type %v)", n, n.Type)
+			base.Errorf("invalid operation: %v (shift of type %v)", n, n.Type)
 			n.Type = nil
 		}
 		return n
@@ -315,11 +316,11 @@ func convlit1(n *Node, t *types.Type, explicit bool, context func() string) *Nod
 	if !n.Diag() {
 		if !t.Broke() {
 			if explicit {
-				yyerror("cannot convert %L to type %v", n, t)
+				base.Errorf("cannot convert %L to type %v", n, t)
 			} else if context != nil {
-				yyerror("cannot use %L as type %v in %s", n, t, context())
+				base.Errorf("cannot use %L as type %v in %s", n, t, context())
 			} else {
-				yyerror("cannot use %L as type %v", n, t)
+				base.Errorf("cannot use %L as type %v", n, t)
 			}
 		}
 		n.SetDiag(true)
@@ -395,7 +396,7 @@ func tocplx(v constant.Value) constant.Value {
 func toflt(v constant.Value) constant.Value {
 	if v.Kind() == constant.Complex {
 		if constant.Sign(constant.Imag(v)) != 0 {
-			yyerror("constant %v truncated to real", v)
+			base.Errorf("constant %v truncated to real", v)
 		}
 		v = constant.Real(v)
 	}
@@ -406,7 +407,7 @@ func toflt(v constant.Value) constant.Value {
 func toint(v constant.Value) constant.Value {
 	if v.Kind() == constant.Complex {
 		if constant.Sign(constant.Imag(v)) != 0 {
-			yyerror("constant %v truncated to integer", v)
+			base.Errorf("constant %v truncated to integer", v)
 		}
 		v = constant.Real(v)
 	}
@@ -426,14 +427,14 @@ func toint(v constant.Value) constant.Value {
 	// (See issue #11371).
 	f := bigFloatVal(v)
 	if f.MantExp(nil) > 2*Mpprec {
-		yyerror("integer too large")
+		base.Errorf("integer too large")
 	} else {
 		var t big.Float
 		t.Parse(fmt.Sprint(v), 0)
 		if t.IsInt() {
-			yyerror("constant truncated to integer")
+			base.Errorf("constant truncated to integer")
 		} else {
-			yyerror("constant %v truncated to integer", v)
+			base.Errorf("constant %v truncated to integer", v)
 		}
 	}
 
@@ -470,7 +471,7 @@ func doesoverflow(v constant.Value, t *types.Type) bool {
 		ft := floatForComplex(t)
 		return doesoverflow(constant.Real(v), ft) || doesoverflow(constant.Imag(v), ft)
 	}
-	Fatalf("doesoverflow: %v, %v", v, t)
+	base.Fatalf("doesoverflow: %v, %v", v, t)
 	panic("unreachable")
 }
 
@@ -483,11 +484,11 @@ func overflow(v constant.Value, t *types.Type) bool {
 		return false
 	}
 	if v.Kind() == constant.Int && constant.BitLen(v) > Mpprec {
-		yyerror("integer too large")
+		base.Errorf("integer too large")
 		return true
 	}
 	if doesoverflow(v, t) {
-		yyerror("constant %v overflows %v", vconv(v, 0), t)
+		base.Errorf("constant %v overflows %v", vconv(v, 0), t)
 		return true
 	}
 	return false
@@ -568,12 +569,12 @@ func evalConst(n *Node) *Node {
 
 			// check for divisor underflow in complex division (see issue 20227)
 			if op == ODIV && n.Type.IsComplex() && constant.Sign(square(constant.Real(rval))) == 0 && constant.Sign(square(constant.Imag(rval))) == 0 {
-				yyerror("complex division by zero")
+				base.Errorf("complex division by zero")
 				n.Type = nil
 				return n
 			}
 			if (op == ODIV || op == OMOD) && constant.Sign(rval) == 0 {
-				yyerror("division by zero")
+				base.Errorf("division by zero")
 				n.Type = nil
 				return n
 			}
@@ -596,7 +597,7 @@ func evalConst(n *Node) *Node {
 			const shiftBound = 1023 - 1 + 52
 			s, ok := constant.Uint64Val(nr.Val())
 			if !ok || s > shiftBound {
-				yyerror("invalid shift count %v", nr)
+				base.Errorf("invalid shift count %v", nr)
 				n.Type = nil
 				break
 			}
@@ -702,7 +703,7 @@ func makeInt(i *big.Int) constant.Value {
 
 func makeFloat64(f float64) constant.Value {
 	if math.IsInf(f, 0) {
-		Fatalf("infinity is not a valid constant")
+		base.Fatalf("infinity is not a valid constant")
 	}
 	v := constant.MakeFloat64(f)
 	v = constant.ToFloat(v) // workaround #42641 (MakeFloat64(0).Kind() returns Int, not Float)
@@ -732,7 +733,7 @@ var overflowNames = [...]string{
 func origConst(n *Node, v constant.Value) *Node {
 	lno := setlineno(n)
 	v = convertVal(v, n.Type, false)
-	lineno = lno
+	base.Pos = lno
 
 	switch v.Kind() {
 	case constant.Int:
@@ -743,9 +744,9 @@ func origConst(n *Node, v constant.Value) *Node {
 	case constant.Unknown:
 		what := overflowNames[n.Op]
 		if what == "" {
-			Fatalf("unexpected overflow: %v", n.Op)
+			base.Fatalf("unexpected overflow: %v", n.Op)
 		}
-		yyerrorl(n.Pos, "constant %v overflow", what)
+		base.ErrorfAt(n.Pos, "constant %v overflow", what)
 		n.Type = nil
 		return n
 	}
@@ -760,7 +761,7 @@ func origConst(n *Node, v constant.Value) *Node {
 
 func assertRepresents(t *types.Type, v constant.Value) {
 	if !represents(t, v) {
-		Fatalf("%v does not represent %v", t, v)
+		base.Fatalf("%v does not represent %v", t, v)
 	}
 }
 
@@ -780,7 +781,7 @@ func represents(t *types.Type, v constant.Value) bool {
 		return t.IsComplex()
 	}
 
-	Fatalf("unexpected constant kind: %v", v)
+	base.Fatalf("unexpected constant kind: %v", v)
 	panic("unreachable")
 }
 
@@ -815,7 +816,7 @@ func idealType(ct constant.Kind) *types.Type {
 	case constant.Complex:
 		return types.UntypedComplex
 	}
-	Fatalf("unexpected Ctype: %v", ct)
+	base.Fatalf("unexpected Ctype: %v", ct)
 	return nil
 }
 
@@ -876,7 +877,7 @@ func mixUntyped(t1, t2 *types.Type) *types.Type {
 		case types.UntypedComplex:
 			return 3
 		}
-		Fatalf("bad type %v", t)
+		base.Fatalf("bad type %v", t)
 		panic("unreachable")
 	}
 
@@ -906,7 +907,7 @@ func defaultType(t *types.Type) *types.Type {
 		return types.Types[TCOMPLEX128]
 	}
 
-	Fatalf("bad type %v", t)
+	base.Fatalf("bad type %v", t)
 	return nil
 }
 
@@ -1023,7 +1024,7 @@ func (s *constSet) add(pos src.XPos, n *Node, what, where string) {
 		return
 	}
 	if n.Type.IsUntyped() {
-		Fatalf("%v is untyped", n)
+		base.Fatalf("%v is untyped", n)
 	}
 
 	// Consts are only duplicates if they have the same value and
@@ -1059,9 +1060,9 @@ func (s *constSet) add(pos src.XPos, n *Node, what, where string) {
 	}
 
 	if prevPos, isDup := s.m[k]; isDup {
-		yyerrorl(pos, "duplicate %s %s in %s\n\tprevious %s at %v",
+		base.ErrorfAt(pos, "duplicate %s %s in %s\n\tprevious %s at %v",
 			what, nodeAndVal(n), where,
-			what, linestr(prevPos))
+			what, base.FmtPos(prevPos))
 	} else {
 		s.m[k] = pos
 	}
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 3f193e3a01..63a52a9f36 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"bytes"
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/src"
@@ -20,7 +21,7 @@ var externdcl []*Node
 
 func testdclstack() {
 	if !types.IsDclstackValid() {
-		Fatalf("mark left on the dclstack")
+		base.Fatalf("mark left on the dclstack")
 	}
 }
 
@@ -31,7 +32,7 @@ func redeclare(pos src.XPos, s *types.Sym, where string) {
 		if pkg == nil {
 			pkg = s.Pkg
 		}
-		yyerrorl(pos, "%v redeclared %s\n"+
+		base.ErrorfAt(pos, "%v redeclared %s\n"+
 			"\tprevious declaration during import %q", s, where, pkg.Path)
 	} else {
 		prevPos := s.Lastlineno
@@ -44,8 +45,8 @@ func redeclare(pos src.XPos, s *types.Sym, where string) {
 			pos, prevPos = prevPos, pos
 		}
 
-		yyerrorl(pos, "%v redeclared %s\n"+
-			"\tprevious declaration at %v", s, where, linestr(prevPos))
+		base.ErrorfAt(pos, "%v redeclared %s\n"+
+			"\tprevious declaration at %v", s, where, base.FmtPos(prevPos))
 	}
 }
 
@@ -71,22 +72,22 @@ func declare(n *Node, ctxt Class) {
 
 	// kludgy: typecheckok means we're past parsing. Eg genwrapper may declare out of package names later.
 	if !inimport && !typecheckok && s.Pkg != localpkg {
-		yyerrorl(n.Pos, "cannot declare name %v", s)
+		base.ErrorfAt(n.Pos, "cannot declare name %v", s)
 	}
 
 	gen := 0
 	if ctxt == PEXTERN {
 		if s.Name == "init" {
-			yyerrorl(n.Pos, "cannot declare init - must be func")
+			base.ErrorfAt(n.Pos, "cannot declare init - must be func")
 		}
 		if s.Name == "main" && s.Pkg.Name == "main" {
-			yyerrorl(n.Pos, "cannot declare main - must be func")
+			base.ErrorfAt(n.Pos, "cannot declare main - must be func")
 		}
 		externdcl = append(externdcl, n)
 	} else {
 		if Curfn == nil && ctxt == PAUTO {
-			lineno = n.Pos
-			Fatalf("automatic outside function")
+			base.Pos = n.Pos
+			base.Fatalf("automatic outside function")
 		}
 		if Curfn != nil && ctxt != PFUNC {
 			Curfn.Func.Dcl = append(Curfn.Func.Dcl, n)
@@ -115,7 +116,7 @@ func declare(n *Node, ctxt Class) {
 	}
 
 	s.Block = types.Block
-	s.Lastlineno = lineno
+	s.Lastlineno = base.Pos
 	s.Def = asTypesNode(n)
 	n.Name.Vargen = int32(gen)
 	n.SetClass(ctxt)
@@ -128,7 +129,7 @@ func declare(n *Node, ctxt Class) {
 
 func addvar(n *Node, t *types.Type, ctxt Class) {
 	if n == nil || n.Sym == nil || (n.Op != ONAME && n.Op != ONONAME) || t == nil {
-		Fatalf("addvar: n=%v t=%v nil", n, t)
+		base.Fatalf("addvar: n=%v t=%v nil", n, t)
 	}
 
 	n.Op = ONAME
@@ -165,7 +166,7 @@ func variter(vl []*Node, t *Node, el []*Node) []*Node {
 		var e *Node
 		if doexpr {
 			if len(el) == 0 {
-				yyerror("assignment mismatch: %d variables but %d values", len(vl), nel)
+				base.Errorf("assignment mismatch: %d variables but %d values", len(vl), nel)
 				break
 			}
 			e = el[0]
@@ -189,7 +190,7 @@ func variter(vl []*Node, t *Node, el []*Node) []*Node {
 	}
 
 	if len(el) != 0 {
-		yyerror("assignment mismatch: %d variables but %d values", len(vl), nel)
+		base.Errorf("assignment mismatch: %d variables but %d values", len(vl), nel)
 	}
 	return init
 }
@@ -197,7 +198,7 @@ func variter(vl []*Node, t *Node, el []*Node) []*Node {
 // newnoname returns a new ONONAME Node associated with symbol s.
 func newnoname(s *types.Sym) *Node {
 	if s == nil {
-		Fatalf("newnoname nil")
+		base.Fatalf("newnoname nil")
 	}
 	n := nod(ONONAME, nil, nil)
 	n.Sym = s
@@ -208,7 +209,7 @@ func newnoname(s *types.Sym) *Node {
 // newfuncnamel generates a new name node for a function or method.
 func newfuncnamel(pos src.XPos, s *types.Sym, fn *Func) *Node {
 	if fn.Nname != nil {
-		Fatalf("newfuncnamel - already have name")
+		base.Fatalf("newfuncnamel - already have name")
 	}
 	n := newnamel(pos, s)
 	n.Func = fn
@@ -304,7 +305,7 @@ func importName(sym *types.Sym) *Node {
 	n := oldname(sym)
 	if !types.IsExported(sym.Name) && sym.Pkg != localpkg {
 		n.SetDiag(true)
-		yyerror("cannot refer to unexported name %s.%s", sym.Pkg.Name, sym.Name)
+		base.Errorf("cannot refer to unexported name %s.%s", sym.Pkg.Name, sym.Name)
 	}
 	return n
 }
@@ -336,13 +337,13 @@ func colasdefn(left []*Node, defn *Node) {
 			continue
 		}
 		if !colasname(n) {
-			yyerrorl(defn.Pos, "non-name %v on left side of :=", n)
+			base.ErrorfAt(defn.Pos, "non-name %v on left side of :=", n)
 			nerr++
 			continue
 		}
 
 		if !n.Sym.Uniq() {
-			yyerrorl(defn.Pos, "%v repeated on left side of :=", n.Sym)
+			base.ErrorfAt(defn.Pos, "%v repeated on left side of :=", n.Sym)
 			n.SetDiag(true)
 			nerr++
 			continue
@@ -362,7 +363,7 @@ func colasdefn(left []*Node, defn *Node) {
 	}
 
 	if nnew == 0 && nerr == 0 {
-		yyerrorl(defn.Pos, "no new variables on left side of :=")
+		base.ErrorfAt(defn.Pos, "no new variables on left side of :=")
 	}
 }
 
@@ -370,11 +371,11 @@ func colasdefn(left []*Node, defn *Node) {
 // interface field declaration.
 func ifacedcl(n *Node) {
 	if n.Op != ODCLFIELD || n.Left == nil {
-		Fatalf("ifacedcl")
+		base.Fatalf("ifacedcl")
 	}
 
 	if n.Sym.IsBlank() {
-		yyerror("methods must have a unique non-blank name")
+		base.Errorf("methods must have a unique non-blank name")
 	}
 }
 
@@ -399,7 +400,7 @@ func funchdr(n *Node) {
 
 func funcargs(nt *Node) {
 	if nt.Op != OTFUNC {
-		Fatalf("funcargs %v", nt.Op)
+		base.Fatalf("funcargs %v", nt.Op)
 	}
 
 	// re-start the variable generation number
@@ -449,7 +450,7 @@ func funcargs(nt *Node) {
 
 func funcarg(n *Node, ctxt Class) {
 	if n.Op != ODCLFIELD {
-		Fatalf("funcarg %v", n.Op)
+		base.Fatalf("funcarg %v", n.Op)
 	}
 	if n.Sym == nil {
 		return
@@ -469,7 +470,7 @@ func funcarg(n *Node, ctxt Class) {
 // used functype directly to parse the function's type.
 func funcargs2(t *types.Type) {
 	if t.Etype != TFUNC {
-		Fatalf("funcargs2 %v", t)
+		base.Fatalf("funcargs2 %v", t)
 	}
 
 	for _, f := range t.Recvs().Fields().Slice() {
@@ -522,23 +523,23 @@ func checkembeddedtype(t *types.Type) {
 	if t.Sym == nil && t.IsPtr() {
 		t = t.Elem()
 		if t.IsInterface() {
-			yyerror("embedded type cannot be a pointer to interface")
+			base.Errorf("embedded type cannot be a pointer to interface")
 		}
 	}
 
 	if t.IsPtr() || t.IsUnsafePtr() {
-		yyerror("embedded type cannot be a pointer")
+		base.Errorf("embedded type cannot be a pointer")
 	} else if t.Etype == TFORW && !t.ForwardType().Embedlineno.IsKnown() {
-		t.ForwardType().Embedlineno = lineno
+		t.ForwardType().Embedlineno = base.Pos
 	}
 }
 
 func structfield(n *Node) *types.Field {
-	lno := lineno
-	lineno = n.Pos
+	lno := base.Pos
+	base.Pos = n.Pos
 
 	if n.Op != ODCLFIELD {
-		Fatalf("structfield: oops %v\n", n)
+		base.Fatalf("structfield: oops %v\n", n)
 	}
 
 	if n.Left != nil {
@@ -556,7 +557,7 @@ func structfield(n *Node) *types.Field {
 		f.Note = constant.StringVal(n.Val())
 	}
 
-	lineno = lno
+	base.Pos = lno
 	return f
 }
 
@@ -570,7 +571,7 @@ func checkdupfields(what string, fss ...[]*types.Field) {
 				continue
 			}
 			if seen[f.Sym] {
-				yyerrorl(f.Pos, "duplicate %s %s", what, f.Sym.Name)
+				base.ErrorfAt(f.Pos, "duplicate %s %s", what, f.Sym.Name)
 				continue
 			}
 			seen[f.Sym] = true
@@ -631,15 +632,15 @@ func tofunargsfield(fields []*types.Field, funarg types.Funarg) *types.Type {
 }
 
 func interfacefield(n *Node) *types.Field {
-	lno := lineno
-	lineno = n.Pos
+	lno := base.Pos
+	base.Pos = n.Pos
 
 	if n.Op != ODCLFIELD {
-		Fatalf("interfacefield: oops %v\n", n)
+		base.Fatalf("interfacefield: oops %v\n", n)
 	}
 
 	if n.HasVal() {
-		yyerror("interface method cannot have annotation")
+		base.Errorf("interface method cannot have annotation")
 	}
 
 	// MethodSpec = MethodName Signature | InterfaceTypeName .
@@ -655,7 +656,7 @@ func interfacefield(n *Node) *types.Field {
 
 	f := types.NewField(n.Pos, n.Sym, n.Type)
 
-	lineno = lno
+	base.Pos = lno
 	return f
 }
 
@@ -774,13 +775,13 @@ func methodSym(recv *types.Type, msym *types.Sym) *types.Sym {
 // start with a letter, number, or period.
 func methodSymSuffix(recv *types.Type, msym *types.Sym, suffix string) *types.Sym {
 	if msym.IsBlank() {
-		Fatalf("blank method name")
+		base.Fatalf("blank method name")
 	}
 
 	rsym := recv.Sym
 	if recv.IsPtr() {
 		if rsym != nil {
-			Fatalf("declared pointer receiver type: %v", recv)
+			base.Fatalf("declared pointer receiver type: %v", recv)
 		}
 		rsym = recv.Elem().Sym
 	}
@@ -824,13 +825,13 @@ func methodSymSuffix(recv *types.Type, msym *types.Sym, suffix string) *types.Sy
 // Returns a pointer to the existing or added Field; or nil if there's an error.
 func addmethod(n *Node, msym *types.Sym, t *types.Type, local, nointerface bool) *types.Field {
 	if msym == nil {
-		Fatalf("no method symbol")
+		base.Fatalf("no method symbol")
 	}
 
 	// get parent type sym
 	rf := t.Recv() // ptr to this structure
 	if rf == nil {
-		yyerror("missing receiver")
+		base.Errorf("missing receiver")
 		return nil
 	}
 
@@ -840,7 +841,7 @@ func addmethod(n *Node, msym *types.Sym, t *types.Type, local, nointerface bool)
 		t := pa
 		if t != nil && t.IsPtr() {
 			if t.Sym != nil {
-				yyerror("invalid receiver type %v (%v is a pointer type)", pa, t)
+				base.Errorf("invalid receiver type %v (%v is a pointer type)", pa, t)
 				return nil
 			}
 			t = t.Elem()
@@ -850,21 +851,21 @@ func addmethod(n *Node, msym *types.Sym, t *types.Type, local, nointerface bool)
 		case t == nil || t.Broke():
 			// rely on typecheck having complained before
 		case t.Sym == nil:
-			yyerror("invalid receiver type %v (%v is not a defined type)", pa, t)
+			base.Errorf("invalid receiver type %v (%v is not a defined type)", pa, t)
 		case t.IsPtr():
-			yyerror("invalid receiver type %v (%v is a pointer type)", pa, t)
+			base.Errorf("invalid receiver type %v (%v is a pointer type)", pa, t)
 		case t.IsInterface():
-			yyerror("invalid receiver type %v (%v is an interface type)", pa, t)
+			base.Errorf("invalid receiver type %v (%v is an interface type)", pa, t)
 		default:
 			// Should have picked off all the reasons above,
 			// but just in case, fall back to generic error.
-			yyerror("invalid receiver type %v (%L / %L)", pa, pa, t)
+			base.Errorf("invalid receiver type %v (%L / %L)", pa, pa, t)
 		}
 		return nil
 	}
 
 	if local && mt.Sym.Pkg != localpkg {
-		yyerror("cannot define new methods on non-local type %v", mt)
+		base.Errorf("cannot define new methods on non-local type %v", mt)
 		return nil
 	}
 
@@ -875,7 +876,7 @@ func addmethod(n *Node, msym *types.Sym, t *types.Type, local, nointerface bool)
 	if mt.IsStruct() {
 		for _, f := range mt.Fields().Slice() {
 			if f.Sym == msym {
-				yyerror("type %v has both field and method named %v", mt, msym)
+				base.Errorf("type %v has both field and method named %v", mt, msym)
 				f.SetBroke(true)
 				return nil
 			}
@@ -889,12 +890,12 @@ func addmethod(n *Node, msym *types.Sym, t *types.Type, local, nointerface bool)
 		// types.Identical only checks that incoming and result parameters match,
 		// so explicitly check that the receiver parameters match too.
 		if !types.Identical(t, f.Type) || !types.Identical(t.Recv().Type, f.Type.Recv().Type) {
-			yyerror("method redeclared: %v.%v\n\t%v\n\t%v", mt, msym, f.Type, t)
+			base.Errorf("method redeclared: %v.%v\n\t%v\n\t%v", mt, msym, f.Type, t)
 		}
 		return f
 	}
 
-	f := types.NewField(lineno, msym, t)
+	f := types.NewField(base.Pos, msym, t)
 	f.Nname = asTypesNode(n.Func.Nname)
 	f.SetNointerface(nointerface)
 
@@ -923,7 +924,7 @@ func funcsym(s *types.Sym) *types.Sym {
 	// When dynamically linking, the necessary function
 	// symbols will be created explicitly with makefuncsym.
 	// See the makefuncsym comment for details.
-	if !Ctxt.Flag_dynlink && !existed {
+	if !base.Ctxt.Flag_dynlink && !existed {
 		funcsyms = append(funcsyms, s)
 	}
 	funcsymsmu.Unlock()
@@ -940,13 +941,13 @@ func funcsym(s *types.Sym) *types.Sym {
 // So instead, when dynamic linking, we only create
 // the s·f stubs in s's package.
 func makefuncsym(s *types.Sym) {
-	if !Ctxt.Flag_dynlink {
-		Fatalf("makefuncsym dynlink")
+	if !base.Ctxt.Flag_dynlink {
+		base.Fatalf("makefuncsym dynlink")
 	}
 	if s.IsBlank() {
 		return
 	}
-	if Flag.CompilingRuntime && (s.Name == "getg" || s.Name == "getclosureptr" || s.Name == "getcallerpc" || s.Name == "getcallersp") {
+	if base.Flag.CompilingRuntime && (s.Name == "getg" || s.Name == "getclosureptr" || s.Name == "getcallerpc" || s.Name == "getcallersp") {
 		// runtime.getg(), getclosureptr(), getcallerpc(), and
 		// getcallersp() are not real functions and so do not
 		// get funcsyms.
@@ -960,7 +961,7 @@ func makefuncsym(s *types.Sym) {
 // setNodeNameFunc marks a node as a function.
 func setNodeNameFunc(n *Node) {
 	if n.Op != ONAME || n.Class() != Pxxx {
-		Fatalf("expected ONAME/Pxxx node, got %v", n)
+		base.Fatalf("expected ONAME/Pxxx node, got %v", n)
 	}
 
 	n.SetClass(PFUNC)
@@ -969,11 +970,11 @@ func setNodeNameFunc(n *Node) {
 
 func dclfunc(sym *types.Sym, tfn *Node) *Node {
 	if tfn.Op != OTFUNC {
-		Fatalf("expected OTFUNC node, got %v", tfn)
+		base.Fatalf("expected OTFUNC node, got %v", tfn)
 	}
 
 	fn := nod(ODCLFUNC, nil, nil)
-	fn.Func.Nname = newfuncnamel(lineno, sym, fn.Func)
+	fn.Func.Nname = newfuncnamel(base.Pos, sym, fn.Func)
 	fn.Func.Nname.Name.Defn = fn
 	fn.Func.Nname.Name.Param.Ntype = tfn
 	setNodeNameFunc(fn.Func.Nname)
@@ -1045,10 +1046,10 @@ func (c *nowritebarrierrecChecker) findExtraCalls(n *Node) bool {
 	case OCLOSURE:
 		callee = arg.Func.Decl
 	default:
-		Fatalf("expected ONAME or OCLOSURE node, got %+v", arg)
+		base.Fatalf("expected ONAME or OCLOSURE node, got %+v", arg)
 	}
 	if callee.Op != ODCLFUNC {
-		Fatalf("expected ODCLFUNC node, got %+v", callee)
+		base.Fatalf("expected ODCLFUNC node, got %+v", callee)
 	}
 	c.extraCalls[c.curfn] = append(c.extraCalls[c.curfn], nowritebarrierrecCall{callee, n.Pos})
 	return true
@@ -1064,7 +1065,7 @@ func (c *nowritebarrierrecChecker) findExtraCalls(n *Node) bool {
 // This can be called concurrently for different from Nodes.
 func (c *nowritebarrierrecChecker) recordCall(from *Node, to *obj.LSym, pos src.XPos) {
 	if from.Op != ODCLFUNC {
-		Fatalf("expected ODCLFUNC, got %v", from)
+		base.Fatalf("expected ODCLFUNC, got %v", from)
 	}
 	// We record this information on the *Func so this is
 	// concurrent-safe.
@@ -1105,7 +1106,7 @@ func (c *nowritebarrierrecChecker) check() {
 		}
 		// Check go:nowritebarrier functions.
 		if n.Func.Pragma&Nowritebarrier != 0 && n.Func.WBPos.IsKnown() {
-			yyerrorl(n.Func.WBPos, "write barrier prohibited")
+			base.ErrorfAt(n.Func.WBPos, "write barrier prohibited")
 		}
 	}
 
@@ -1133,10 +1134,10 @@ func (c *nowritebarrierrecChecker) check() {
 			var err bytes.Buffer
 			call := funcs[fn]
 			for call.target != nil {
-				fmt.Fprintf(&err, "\n\t%v: called by %v", linestr(call.lineno), call.target.Func.Nname)
+				fmt.Fprintf(&err, "\n\t%v: called by %v", base.FmtPos(call.lineno), call.target.Func.Nname)
 				call = funcs[call.target]
 			}
-			yyerrorl(fn.Func.WBPos, "write barrier prohibited by caller; %v%s", fn.Func.Nname, err.String())
+			base.ErrorfAt(fn.Func.WBPos, "write barrier prohibited by caller; %v%s", fn.Func.Nname, err.String())
 			continue
 		}
 
diff --git a/src/cmd/compile/internal/gc/dump.go b/src/cmd/compile/internal/gc/dump.go
index 29eb1c1e48..56dc474465 100644
--- a/src/cmd/compile/internal/gc/dump.go
+++ b/src/cmd/compile/internal/gc/dump.go
@@ -9,6 +9,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"fmt"
@@ -146,7 +147,7 @@ func (p *dumper) dump(x reflect.Value, depth int) {
 		x = reflect.ValueOf(v.Slice())
 
 	case src.XPos:
-		p.printf("%s", linestr(v))
+		p.printf("%s", base.FmtPos(v))
 		return
 
 	case *types.Node:
diff --git a/src/cmd/compile/internal/gc/dwinl.go b/src/cmd/compile/internal/gc/dwinl.go
index edde7a4cc5..5da2871748 100644
--- a/src/cmd/compile/internal/gc/dwinl.go
+++ b/src/cmd/compile/internal/gc/dwinl.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/internal/dwarf"
 	"cmd/internal/obj"
 	"cmd/internal/src"
@@ -26,8 +27,8 @@ type varPos struct {
 func assembleInlines(fnsym *obj.LSym, dwVars []*dwarf.Var) dwarf.InlCalls {
 	var inlcalls dwarf.InlCalls
 
-	if Debug.DwarfInl != 0 {
-		Ctxt.Logf("assembling DWARF inlined routine info for %v\n", fnsym.Name)
+	if base.Debug.DwarfInl != 0 {
+		base.Ctxt.Logf("assembling DWARF inlined routine info for %v\n", fnsym.Name)
 	}
 
 	// This maps inline index (from Ctxt.InlTree) to index in inlcalls.Calls
@@ -106,7 +107,7 @@ func assembleInlines(fnsym *obj.LSym, dwVars []*dwarf.Var) dwarf.InlCalls {
 			}
 			m = makePreinlineDclMap(fnsym)
 		} else {
-			ifnlsym := Ctxt.InlTree.InlinedFunction(int(ii - 1))
+			ifnlsym := base.Ctxt.InlTree.InlinedFunction(int(ii - 1))
 			m = makePreinlineDclMap(ifnlsym)
 		}
 
@@ -181,7 +182,7 @@ func assembleInlines(fnsym *obj.LSym, dwVars []*dwarf.Var) dwarf.InlCalls {
 	}
 
 	// Debugging
-	if Debug.DwarfInl != 0 {
+	if base.Debug.DwarfInl != 0 {
 		dumpInlCalls(inlcalls)
 		dumpInlVars(dwVars)
 	}
@@ -205,15 +206,15 @@ func assembleInlines(fnsym *obj.LSym, dwVars []*dwarf.Var) dwarf.InlCalls {
 // abstract function DIE for an inlined routine imported from a
 // previously compiled package.
 func genAbstractFunc(fn *obj.LSym) {
-	ifn := Ctxt.DwFixups.GetPrecursorFunc(fn)
+	ifn := base.Ctxt.DwFixups.GetPrecursorFunc(fn)
 	if ifn == nil {
-		Ctxt.Diag("failed to locate precursor fn for %v", fn)
+		base.Ctxt.Diag("failed to locate precursor fn for %v", fn)
 		return
 	}
-	if Debug.DwarfInl != 0 {
-		Ctxt.Logf("DwarfAbstractFunc(%v)\n", fn.Name)
+	if base.Debug.DwarfInl != 0 {
+		base.Ctxt.Logf("DwarfAbstractFunc(%v)\n", fn.Name)
 	}
-	Ctxt.DwarfAbstractFunc(ifn, fn, Ctxt.Pkgpath)
+	base.Ctxt.DwarfAbstractFunc(ifn, fn, base.Ctxt.Pkgpath)
 }
 
 // Undo any versioning performed when a name was written
@@ -235,7 +236,7 @@ func makePreinlineDclMap(fnsym *obj.LSym) map[varPos]int {
 	dcl := preInliningDcls(fnsym)
 	m := make(map[varPos]int)
 	for i, n := range dcl {
-		pos := Ctxt.InnermostPos(n.Pos)
+		pos := base.Ctxt.InnermostPos(n.Pos)
 		vp := varPos{
 			DeclName: unversion(n.Sym.Name),
 			DeclFile: pos.RelFilename(),
@@ -243,7 +244,7 @@ func makePreinlineDclMap(fnsym *obj.LSym) map[varPos]int {
 			DeclCol:  pos.Col(),
 		}
 		if _, found := m[vp]; found {
-			Fatalf("child dcl collision on symbol %s within %v\n", n.Sym.Name, fnsym.Name)
+			base.Fatalf("child dcl collision on symbol %s within %v\n", n.Sym.Name, fnsym.Name)
 		}
 		m[vp] = i
 	}
@@ -260,17 +261,17 @@ func insertInlCall(dwcalls *dwarf.InlCalls, inlIdx int, imap map[int]int) int {
 	// is one. We do this first so that parents appear before their
 	// children in the resulting table.
 	parCallIdx := -1
-	parInlIdx := Ctxt.InlTree.Parent(inlIdx)
+	parInlIdx := base.Ctxt.InlTree.Parent(inlIdx)
 	if parInlIdx >= 0 {
 		parCallIdx = insertInlCall(dwcalls, parInlIdx, imap)
 	}
 
 	// Create new entry for this inline
-	inlinedFn := Ctxt.InlTree.InlinedFunction(inlIdx)
-	callXPos := Ctxt.InlTree.CallPos(inlIdx)
-	absFnSym := Ctxt.DwFixups.AbsFuncDwarfSym(inlinedFn)
-	pb := Ctxt.PosTable.Pos(callXPos).Base()
-	callFileSym := Ctxt.Lookup(pb.SymFilename())
+	inlinedFn := base.Ctxt.InlTree.InlinedFunction(inlIdx)
+	callXPos := base.Ctxt.InlTree.CallPos(inlIdx)
+	absFnSym := base.Ctxt.DwFixups.AbsFuncDwarfSym(inlinedFn)
+	pb := base.Ctxt.PosTable.Pos(callXPos).Base()
+	callFileSym := base.Ctxt.Lookup(pb.SymFilename())
 	ic := dwarf.InlCall{
 		InlIndex:  inlIdx,
 		CallFile:  callFileSym,
@@ -298,7 +299,7 @@ func insertInlCall(dwcalls *dwarf.InlCalls, inlIdx int, imap map[int]int) int {
 // the index for a node from the inlined body of D will refer to the
 // call to D from C. Whew.
 func posInlIndex(xpos src.XPos) int {
-	pos := Ctxt.PosTable.Pos(xpos)
+	pos := base.Ctxt.PosTable.Pos(xpos)
 	if b := pos.Base(); b != nil {
 		ii := b.InliningIndex()
 		if ii >= 0 {
@@ -324,7 +325,7 @@ func addRange(calls []dwarf.InlCall, start, end int64, ii int, imap map[int]int)
 	// Append range to correct inlined call
 	callIdx, found := imap[ii]
 	if !found {
-		Fatalf("can't find inlIndex %d in imap for prog at %d\n", ii, start)
+		base.Fatalf("can't find inlIndex %d in imap for prog at %d\n", ii, start)
 	}
 	call := &calls[callIdx]
 	call.Ranges = append(call.Ranges, dwarf.Range{Start: start, End: end})
@@ -332,23 +333,23 @@ func addRange(calls []dwarf.InlCall, start, end int64, ii int, imap map[int]int)
 
 func dumpInlCall(inlcalls dwarf.InlCalls, idx, ilevel int) {
 	for i := 0; i < ilevel; i++ {
-		Ctxt.Logf("  ")
+		base.Ctxt.Logf("  ")
 	}
 	ic := inlcalls.Calls[idx]
-	callee := Ctxt.InlTree.InlinedFunction(ic.InlIndex)
-	Ctxt.Logf("  %d: II:%d (%s) V: (", idx, ic.InlIndex, callee.Name)
+	callee := base.Ctxt.InlTree.InlinedFunction(ic.InlIndex)
+	base.Ctxt.Logf("  %d: II:%d (%s) V: (", idx, ic.InlIndex, callee.Name)
 	for _, f := range ic.InlVars {
-		Ctxt.Logf(" %v", f.Name)
+		base.Ctxt.Logf(" %v", f.Name)
 	}
-	Ctxt.Logf(" ) C: (")
+	base.Ctxt.Logf(" ) C: (")
 	for _, k := range ic.Children {
-		Ctxt.Logf(" %v", k)
+		base.Ctxt.Logf(" %v", k)
 	}
-	Ctxt.Logf(" ) R:")
+	base.Ctxt.Logf(" ) R:")
 	for _, r := range ic.Ranges {
-		Ctxt.Logf(" [%d,%d)", r.Start, r.End)
+		base.Ctxt.Logf(" [%d,%d)", r.Start, r.End)
 	}
-	Ctxt.Logf("\n")
+	base.Ctxt.Logf("\n")
 	for _, k := range ic.Children {
 		dumpInlCall(inlcalls, k, ilevel+1)
 	}
@@ -373,7 +374,7 @@ func dumpInlVars(dwvars []*dwarf.Var) {
 		if dwv.IsInAbstract {
 			ia = 1
 		}
-		Ctxt.Logf("V%d: %s CI:%d II:%d IA:%d %s\n", i, dwv.Name, dwv.ChildIndex, dwv.InlIndex-1, ia, typ)
+		base.Ctxt.Logf("V%d: %s CI:%d II:%d IA:%d %s\n", i, dwv.Name, dwv.ChildIndex, dwv.InlIndex-1, ia, typ)
 	}
 }
 
@@ -410,7 +411,7 @@ func checkInlCall(funcName string, inlCalls dwarf.InlCalls, funcSize int64, idx,
 
 	// Callee
 	ic := inlCalls.Calls[idx]
-	callee := Ctxt.InlTree.InlinedFunction(ic.InlIndex).Name
+	callee := base.Ctxt.InlTree.InlinedFunction(ic.InlIndex).Name
 	calleeRanges := ic.Ranges
 
 	// Caller
@@ -418,14 +419,14 @@ func checkInlCall(funcName string, inlCalls dwarf.InlCalls, funcSize int64, idx,
 	parentRanges := []dwarf.Range{dwarf.Range{Start: int64(0), End: funcSize}}
 	if parentIdx != -1 {
 		pic := inlCalls.Calls[parentIdx]
-		caller = Ctxt.InlTree.InlinedFunction(pic.InlIndex).Name
+		caller = base.Ctxt.InlTree.InlinedFunction(pic.InlIndex).Name
 		parentRanges = pic.Ranges
 	}
 
 	// Callee ranges contained in caller ranges?
 	c, m := rangesContainsAll(parentRanges, calleeRanges)
 	if !c {
-		Fatalf("** malformed inlined routine range in %s: caller %s callee %s II=%d %s\n", funcName, caller, callee, idx, m)
+		base.Fatalf("** malformed inlined routine range in %s: caller %s callee %s II=%d %s\n", funcName, caller, callee, idx, m)
 	}
 
 	// Now visit kids
diff --git a/src/cmd/compile/internal/gc/embed.go b/src/cmd/compile/internal/gc/embed.go
index 5559d62813..f6c1b7cdcc 100644
--- a/src/cmd/compile/internal/gc/embed.go
+++ b/src/cmd/compile/internal/gc/embed.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/syntax"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -43,30 +44,30 @@ func varEmbed(p *noder, names []*Node, typ *Node, exprs []*Node, embeds []Pragma
 
 	pos := embeds[0].Pos
 	if !haveEmbed {
-		p.yyerrorpos(pos, "invalid go:embed: missing import \"embed\"")
+		p.errorAt(pos, "invalid go:embed: missing import \"embed\"")
 		return exprs
 	}
-	if Flag.Cfg.Embed.Patterns == nil {
-		p.yyerrorpos(pos, "invalid go:embed: build system did not supply embed configuration")
+	if base.Flag.Cfg.Embed.Patterns == nil {
+		p.errorAt(pos, "invalid go:embed: build system did not supply embed configuration")
 		return exprs
 	}
 	if len(names) > 1 {
-		p.yyerrorpos(pos, "go:embed cannot apply to multiple vars")
+		p.errorAt(pos, "go:embed cannot apply to multiple vars")
 		return exprs
 	}
 	if len(exprs) > 0 {
-		p.yyerrorpos(pos, "go:embed cannot apply to var with initializer")
+		p.errorAt(pos, "go:embed cannot apply to var with initializer")
 		return exprs
 	}
 	if typ == nil {
 		// Should not happen, since len(exprs) == 0 now.
-		p.yyerrorpos(pos, "go:embed cannot apply to var without type")
+		p.errorAt(pos, "go:embed cannot apply to var without type")
 		return exprs
 	}
 
 	kind := embedKindApprox(typ)
 	if kind == embedUnknown {
-		p.yyerrorpos(pos, "go:embed cannot apply to var of type %v", typ)
+		p.errorAt(pos, "go:embed cannot apply to var of type %v", typ)
 		return exprs
 	}
 
@@ -75,13 +76,13 @@ func varEmbed(p *noder, names []*Node, typ *Node, exprs []*Node, embeds []Pragma
 	var list []string
 	for _, e := range embeds {
 		for _, pattern := range e.Patterns {
-			files, ok := Flag.Cfg.Embed.Patterns[pattern]
+			files, ok := base.Flag.Cfg.Embed.Patterns[pattern]
 			if !ok {
-				p.yyerrorpos(e.Pos, "invalid go:embed: build system did not map pattern: %s", pattern)
+				p.errorAt(e.Pos, "invalid go:embed: build system did not map pattern: %s", pattern)
 			}
 			for _, file := range files {
-				if Flag.Cfg.Embed.Files[file] == "" {
-					p.yyerrorpos(e.Pos, "invalid go:embed: build system did not map file: %s", file)
+				if base.Flag.Cfg.Embed.Files[file] == "" {
+					p.errorAt(e.Pos, "invalid go:embed: build system did not map file: %s", file)
 					continue
 				}
 				if !have[file] {
@@ -103,7 +104,7 @@ func varEmbed(p *noder, names []*Node, typ *Node, exprs []*Node, embeds []Pragma
 
 	if kind == embedString || kind == embedBytes {
 		if len(list) > 1 {
-			p.yyerrorpos(pos, "invalid go:embed: multiple files for type %v", typ)
+			p.errorAt(pos, "invalid go:embed: multiple files for type %v", typ)
 			return exprs
 		}
 	}
@@ -129,7 +130,7 @@ func varEmbed(p *noder, names []*Node, typ *Node, exprs []*Node, embeds []Pragma
 // can't tell whether "string" and "byte" really mean "string" and "byte".
 // The result must be confirmed later, after type checking, using embedKind.
 func embedKindApprox(typ *Node) int {
-	if typ.Sym != nil && typ.Sym.Name == "FS" && (typ.Sym.Pkg.Path == "embed" || (typ.Sym.Pkg == localpkg && Ctxt.Pkgpath == "embed")) {
+	if typ.Sym != nil && typ.Sym.Name == "FS" && (typ.Sym.Pkg.Path == "embed" || (typ.Sym.Pkg == localpkg && base.Ctxt.Pkgpath == "embed")) {
 		return embedFiles
 	}
 	// These are not guaranteed to match only string and []byte -
@@ -147,7 +148,7 @@ func embedKindApprox(typ *Node) int {
 
 // embedKind determines the kind of embedding variable.
 func embedKind(typ *types.Type) int {
-	if typ.Sym != nil && typ.Sym.Name == "FS" && (typ.Sym.Pkg.Path == "embed" || (typ.Sym.Pkg == localpkg && Ctxt.Pkgpath == "embed")) {
+	if typ.Sym != nil && typ.Sym.Name == "FS" && (typ.Sym.Pkg.Path == "embed" || (typ.Sym.Pkg == localpkg && base.Ctxt.Pkgpath == "embed")) {
 		return embedFiles
 	}
 	if typ == types.Types[TSTRING] {
@@ -194,13 +195,13 @@ func initEmbed(v *Node) {
 	files := v.Name.Param.EmbedFiles()
 	switch kind := embedKind(v.Type); kind {
 	case embedUnknown:
-		yyerrorl(v.Pos, "go:embed cannot apply to var of type %v", v.Type)
+		base.ErrorfAt(v.Pos, "go:embed cannot apply to var of type %v", v.Type)
 
 	case embedString, embedBytes:
 		file := files[0]
-		fsym, size, err := fileStringSym(v.Pos, Flag.Cfg.Embed.Files[file], kind == embedString, nil)
+		fsym, size, err := fileStringSym(v.Pos, base.Flag.Cfg.Embed.Files[file], kind == embedString, nil)
 		if err != nil {
-			yyerrorl(v.Pos, "embed %s: %v", file, err)
+			base.ErrorfAt(v.Pos, "embed %s: %v", file, err)
 		}
 		sym := v.Sym.Linksym()
 		off := 0
@@ -211,7 +212,7 @@ func initEmbed(v *Node) {
 		}
 
 	case embedFiles:
-		slicedata := Ctxt.Lookup(`"".` + v.Sym.Name + `.files`)
+		slicedata := base.Ctxt.Lookup(`"".` + v.Sym.Name + `.files`)
 		off := 0
 		// []files pointed at by Files
 		off = dsymptr(slicedata, off, slicedata, 3*Widthptr) // []file, pointing just past slice
@@ -234,13 +235,13 @@ func initEmbed(v *Node) {
 				off = duintptr(slicedata, off, 0)
 				off += hashSize
 			} else {
-				fsym, size, err := fileStringSym(v.Pos, Flag.Cfg.Embed.Files[file], true, hash)
+				fsym, size, err := fileStringSym(v.Pos, base.Flag.Cfg.Embed.Files[file], true, hash)
 				if err != nil {
-					yyerrorl(v.Pos, "embed %s: %v", file, err)
+					base.ErrorfAt(v.Pos, "embed %s: %v", file, err)
 				}
 				off = dsymptr(slicedata, off, fsym, 0) // data string
 				off = duintptr(slicedata, off, uint64(size))
-				off = int(slicedata.WriteBytes(Ctxt, int64(off), hash))
+				off = int(slicedata.WriteBytes(base.Ctxt, int64(off), hash))
 			}
 		}
 		ggloblsym(slicedata, int32(off), obj.RODATA|obj.LOCAL)
diff --git a/src/cmd/compile/internal/gc/esc.go b/src/cmd/compile/internal/gc/esc.go
index 74b85e1ae8..5cf8c4a1c6 100644
--- a/src/cmd/compile/internal/gc/esc.go
+++ b/src/cmd/compile/internal/gc/esc.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"fmt"
 )
@@ -263,11 +264,11 @@ func addrescapes(n *Node) {
 			Curfn = Curfn.Func.Decl
 			panic("can't happen")
 		}
-		ln := lineno
-		lineno = Curfn.Pos
+		ln := base.Pos
+		base.Pos = Curfn.Pos
 		moveToHeap(n)
 		Curfn = oldfn
-		lineno = ln
+		base.Pos = ln
 
 	// ODOTPTR has already been introduced,
 	// so these are the non-pointer ODOT and OINDEX.
@@ -283,15 +284,15 @@ func addrescapes(n *Node) {
 
 // moveToHeap records the parameter or local variable n as moved to the heap.
 func moveToHeap(n *Node) {
-	if Flag.LowerR != 0 {
+	if base.Flag.LowerR != 0 {
 		Dump("MOVE", n)
 	}
-	if Flag.CompilingRuntime {
-		yyerror("%v escapes to heap, not allowed in runtime", n)
+	if base.Flag.CompilingRuntime {
+		base.Errorf("%v escapes to heap, not allowed in runtime", n)
 	}
 	if n.Class() == PAUTOHEAP {
 		Dump("n", n)
-		Fatalf("double move to heap")
+		base.Fatalf("double move to heap")
 	}
 
 	// Allocate a local stack variable to hold the pointer to the heap copy.
@@ -311,7 +312,7 @@ func moveToHeap(n *Node) {
 	// the function.
 	if n.Class() == PPARAM || n.Class() == PPARAMOUT {
 		if n.Xoffset == BADWIDTH {
-			Fatalf("addrescapes before param assignment")
+			base.Fatalf("addrescapes before param assignment")
 		}
 
 		// We rewrite n below to be a heap variable (indirection of heapaddr).
@@ -350,7 +351,7 @@ func moveToHeap(n *Node) {
 			}
 		}
 		if !found {
-			Fatalf("cannot find %v in local variable list", n)
+			base.Fatalf("cannot find %v in local variable list", n)
 		}
 		Curfn.Func.Dcl = append(Curfn.Func.Dcl, n)
 	}
@@ -360,8 +361,8 @@ func moveToHeap(n *Node) {
 	n.Xoffset = 0
 	n.Name.Param.Heapaddr = heapaddr
 	n.Esc = EscHeap
-	if Flag.LowerM != 0 {
-		Warnl(n.Pos, "moved to heap: %v", n)
+	if base.Flag.LowerM != 0 {
+		base.WarnfAt(n.Pos, "moved to heap: %v", n)
 	}
 }
 
@@ -390,8 +391,8 @@ func (e *Escape) paramTag(fn *Node, narg int, f *types.Field) string {
 		// but we are reusing the ability to annotate an individual function
 		// argument and pass those annotations along to importing code.
 		if f.Type.IsUintptr() {
-			if Flag.LowerM != 0 {
-				Warnl(f.Pos, "assuming %v is unsafe uintptr", name())
+			if base.Flag.LowerM != 0 {
+				base.WarnfAt(f.Pos, "assuming %v is unsafe uintptr", name())
 			}
 			return unsafeUintptrTag
 		}
@@ -405,12 +406,12 @@ func (e *Escape) paramTag(fn *Node, narg int, f *types.Field) string {
 		// External functions are assumed unsafe, unless
 		// //go:noescape is given before the declaration.
 		if fn.Func.Pragma&Noescape != 0 {
-			if Flag.LowerM != 0 && f.Sym != nil {
-				Warnl(f.Pos, "%v does not escape", name())
+			if base.Flag.LowerM != 0 && f.Sym != nil {
+				base.WarnfAt(f.Pos, "%v does not escape", name())
 			}
 		} else {
-			if Flag.LowerM != 0 && f.Sym != nil {
-				Warnl(f.Pos, "leaking param: %v", name())
+			if base.Flag.LowerM != 0 && f.Sym != nil {
+				base.WarnfAt(f.Pos, "leaking param: %v", name())
 			}
 			esc.AddHeap(0)
 		}
@@ -420,15 +421,15 @@ func (e *Escape) paramTag(fn *Node, narg int, f *types.Field) string {
 
 	if fn.Func.Pragma&UintptrEscapes != 0 {
 		if f.Type.IsUintptr() {
-			if Flag.LowerM != 0 {
-				Warnl(f.Pos, "marking %v as escaping uintptr", name())
+			if base.Flag.LowerM != 0 {
+				base.WarnfAt(f.Pos, "marking %v as escaping uintptr", name())
 			}
 			return uintptrEscapesTag
 		}
 		if f.IsDDD() && f.Type.Elem().IsUintptr() {
 			// final argument is ...uintptr.
-			if Flag.LowerM != 0 {
-				Warnl(f.Pos, "marking %v as escaping ...uintptr", name())
+			if base.Flag.LowerM != 0 {
+				base.WarnfAt(f.Pos, "marking %v as escaping ...uintptr", name())
 			}
 			return uintptrEscapesTag
 		}
@@ -449,22 +450,22 @@ func (e *Escape) paramTag(fn *Node, narg int, f *types.Field) string {
 	esc := loc.paramEsc
 	esc.Optimize()
 
-	if Flag.LowerM != 0 && !loc.escapes {
+	if base.Flag.LowerM != 0 && !loc.escapes {
 		if esc.Empty() {
-			Warnl(f.Pos, "%v does not escape", name())
+			base.WarnfAt(f.Pos, "%v does not escape", name())
 		}
 		if x := esc.Heap(); x >= 0 {
 			if x == 0 {
-				Warnl(f.Pos, "leaking param: %v", name())
+				base.WarnfAt(f.Pos, "leaking param: %v", name())
 			} else {
 				// TODO(mdempsky): Mention level=x like below?
-				Warnl(f.Pos, "leaking param content: %v", name())
+				base.WarnfAt(f.Pos, "leaking param content: %v", name())
 			}
 		}
 		for i := 0; i < numEscResults; i++ {
 			if x := esc.Result(i); x >= 0 {
 				res := fn.Type.Results().Field(i).Sym
-				Warnl(f.Pos, "leaking param: %v to result %v level=%d", name(), res, x)
+				base.WarnfAt(f.Pos, "leaking param: %v to result %v level=%d", name(), res, x)
 			}
 		}
 	}
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 27645fb888..aaf768d85a 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
@@ -180,7 +181,7 @@ func escFmt(n *Node, short bool) string {
 func escapeFuncs(fns []*Node, recursive bool) {
 	for _, fn := range fns {
 		if fn.Op != ODCLFUNC {
-			Fatalf("unexpected node: %v", fn)
+			base.Fatalf("unexpected node: %v", fn)
 		}
 	}
 
@@ -202,10 +203,10 @@ func escapeFuncs(fns []*Node, recursive bool) {
 
 func (e *Escape) initFunc(fn *Node) {
 	if fn.Op != ODCLFUNC || fn.Esc != EscFuncUnknown {
-		Fatalf("unexpected node: %v", fn)
+		base.Fatalf("unexpected node: %v", fn)
 	}
 	fn.Esc = EscFuncPlanned
-	if Flag.LowerM > 3 {
+	if base.Flag.LowerM > 3 {
 		Dump("escAnalyze", fn)
 	}
 
@@ -279,18 +280,18 @@ func (e *Escape) stmt(n *Node) {
 
 	lno := setlineno(n)
 	defer func() {
-		lineno = lno
+		base.Pos = lno
 	}()
 
-	if Flag.LowerM > 2 {
-		fmt.Printf("%v:[%d] %v stmt: %v\n", linestr(lineno), e.loopDepth, funcSym(e.curfn), n)
+	if base.Flag.LowerM > 2 {
+		fmt.Printf("%v:[%d] %v stmt: %v\n", base.FmtPos(base.Pos), e.loopDepth, funcSym(e.curfn), n)
 	}
 
 	e.stmts(n.Ninit)
 
 	switch n.Op {
 	default:
-		Fatalf("unexpected stmt: %v", n)
+		base.Fatalf("unexpected stmt: %v", n)
 
 	case ODCLCONST, ODCLTYPE, OEMPTY, OFALL, OINLMARK:
 		// nop
@@ -310,16 +311,16 @@ func (e *Escape) stmt(n *Node) {
 	case OLABEL:
 		switch asNode(n.Sym.Label) {
 		case nonlooping:
-			if Flag.LowerM > 2 {
-				fmt.Printf("%v:%v non-looping label\n", linestr(lineno), n)
+			if base.Flag.LowerM > 2 {
+				fmt.Printf("%v:%v non-looping label\n", base.FmtPos(base.Pos), n)
 			}
 		case looping:
-			if Flag.LowerM > 2 {
-				fmt.Printf("%v: %v looping label\n", linestr(lineno), n)
+			if base.Flag.LowerM > 2 {
+				fmt.Printf("%v: %v looping label\n", base.FmtPos(base.Pos), n)
 			}
 			e.loopDepth++
 		default:
-			Fatalf("label missing tag")
+			base.Fatalf("label missing tag")
 		}
 		n.Sym.Label = nil
 
@@ -460,7 +461,7 @@ func (e *Escape) exprSkipInit(k EscHole, n *Node) {
 
 	lno := setlineno(n)
 	defer func() {
-		lineno = lno
+		base.Pos = lno
 	}()
 
 	uintptrEscapesHack := k.uintptrEscapesHack
@@ -474,7 +475,7 @@ func (e *Escape) exprSkipInit(k EscHole, n *Node) {
 
 	switch n.Op {
 	default:
-		Fatalf("unexpected expr: %v", n)
+		base.Fatalf("unexpected expr: %v", n)
 
 	case OLITERAL, ONIL, OGETG, OCLOSUREVAR, OTYPE, OMETHEXPR:
 		// nop
@@ -653,7 +654,7 @@ func (e *Escape) exprSkipInit(k EscHole, n *Node) {
 // for conversions from an unsafe.Pointer.
 func (e *Escape) unsafeValue(k EscHole, n *Node) {
 	if n.Type.Etype != TUINTPTR {
-		Fatalf("unexpected type %v for %v", n.Type, n)
+		base.Fatalf("unexpected type %v for %v", n.Type, n)
 	}
 
 	e.stmts(n.Ninit)
@@ -711,7 +712,7 @@ func (e *Escape) addr(n *Node) EscHole {
 
 	switch n.Op {
 	default:
-		Fatalf("unexpected addr: %v", n)
+		base.Fatalf("unexpected addr: %v", n)
 	case ONAME:
 		if n.Class() == PEXTERN {
 			break
@@ -752,8 +753,8 @@ func (e *Escape) addrs(l Nodes) []EscHole {
 func (e *Escape) assign(dst, src *Node, why string, where *Node) {
 	// Filter out some no-op assignments for escape analysis.
 	ignore := dst != nil && src != nil && isSelfAssign(dst, src)
-	if ignore && Flag.LowerM != 0 {
-		Warnl(where.Pos, "%v ignoring self-assignment in %S", funcSym(e.curfn), where)
+	if ignore && base.Flag.LowerM != 0 {
+		base.WarnfAt(where.Pos, "%v ignoring self-assignment in %S", funcSym(e.curfn), where)
 	}
 
 	k := e.addr(dst)
@@ -797,7 +798,7 @@ func (e *Escape) call(ks []EscHole, call, where *Node) {
 
 	switch call.Op {
 	default:
-		Fatalf("unexpected call op: %v", call.Op)
+		base.Fatalf("unexpected call op: %v", call.Op)
 
 	case OCALLFUNC, OCALLMETH, OCALLINTER:
 		fixVariadicCall(call)
@@ -936,7 +937,7 @@ func (e *Escape) tagHole(ks []EscHole, fn *Node, param *types.Field) EscHole {
 func (e *Escape) inMutualBatch(fn *Node) bool {
 	if fn.Name.Defn != nil && fn.Name.Defn.Esc < EscFuncTagged {
 		if fn.Name.Defn.Esc == EscFuncUnknown {
-			Fatalf("graph inconsistency")
+			base.Fatalf("graph inconsistency")
 		}
 		return true
 	}
@@ -964,9 +965,9 @@ type EscNote struct {
 
 func (k EscHole) note(where *Node, why string) EscHole {
 	if where == nil || why == "" {
-		Fatalf("note: missing where/why")
+		base.Fatalf("note: missing where/why")
 	}
-	if Flag.LowerM >= 2 || logopt.Enabled() {
+	if base.Flag.LowerM >= 2 || logopt.Enabled() {
 		k.notes = &EscNote{
 			next:  k.notes,
 			where: where,
@@ -979,7 +980,7 @@ func (k EscHole) note(where *Node, why string) EscHole {
 func (k EscHole) shift(delta int) EscHole {
 	k.derefs += delta
 	if k.derefs < -1 {
-		Fatalf("derefs underflow: %v", k.derefs)
+		base.Fatalf("derefs underflow: %v", k.derefs)
 	}
 	return k
 }
@@ -1016,7 +1017,7 @@ func (e *Escape) teeHole(ks ...EscHole) EscHole {
 		// *ltmp" and "l2 = ltmp" and return "ltmp = &_"
 		// instead.
 		if k.derefs < 0 {
-			Fatalf("teeHole: negative derefs")
+			base.Fatalf("teeHole: negative derefs")
 		}
 
 		e.flow(k, loc)
@@ -1054,7 +1055,7 @@ func canonicalNode(n *Node) *Node {
 	if n != nil && n.Op == ONAME && n.Name.IsClosureVar() {
 		n = n.Name.Defn
 		if n.Name.IsClosureVar() {
-			Fatalf("still closure var")
+			base.Fatalf("still closure var")
 		}
 	}
 
@@ -1063,10 +1064,10 @@ func canonicalNode(n *Node) *Node {
 
 func (e *Escape) newLoc(n *Node, transient bool) *EscLocation {
 	if e.curfn == nil {
-		Fatalf("e.curfn isn't set")
+		base.Fatalf("e.curfn isn't set")
 	}
 	if n != nil && n.Type != nil && n.Type.NotInHeap() {
-		yyerrorl(n.Pos, "%v is incomplete (or unallocatable); stack allocation disallowed", n.Type)
+		base.ErrorfAt(n.Pos, "%v is incomplete (or unallocatable); stack allocation disallowed", n.Type)
 	}
 
 	n = canonicalNode(n)
@@ -1079,11 +1080,11 @@ func (e *Escape) newLoc(n *Node, transient bool) *EscLocation {
 	e.allLocs = append(e.allLocs, loc)
 	if n != nil {
 		if n.Op == ONAME && n.Name.Curfn != e.curfn {
-			Fatalf("curfn mismatch: %v != %v", n.Name.Curfn, e.curfn)
+			base.Fatalf("curfn mismatch: %v != %v", n.Name.Curfn, e.curfn)
 		}
 
 		if n.HasOpt() {
-			Fatalf("%v already has a location", n)
+			base.Fatalf("%v already has a location", n)
 		}
 		n.SetOpt(loc)
 
@@ -1112,9 +1113,9 @@ func (e *Escape) flow(k EscHole, src *EscLocation) {
 		return
 	}
 	if dst.escapes && k.derefs < 0 { // dst = &src
-		if Flag.LowerM >= 2 || logopt.Enabled() {
-			pos := linestr(src.n.Pos)
-			if Flag.LowerM >= 2 {
+		if base.Flag.LowerM >= 2 || logopt.Enabled() {
+			pos := base.FmtPos(src.n.Pos)
+			if base.Flag.LowerM >= 2 {
 				fmt.Printf("%s: %v escapes to heap:\n", pos, src.n)
 			}
 			explanation := e.explainFlow(pos, dst, src, k.derefs, k.notes, []*logopt.LoggedOpt{})
@@ -1214,9 +1215,9 @@ func (e *Escape) walkOne(root *EscLocation, walkgen uint32, enqueue func(*EscLoc
 			// that value flow for tagging the function
 			// later.
 			if l.isName(PPARAM) {
-				if (logopt.Enabled() || Flag.LowerM >= 2) && !l.escapes {
-					if Flag.LowerM >= 2 {
-						fmt.Printf("%s: parameter %v leaks to %s with derefs=%d:\n", linestr(l.n.Pos), l.n, e.explainLoc(root), derefs)
+				if (logopt.Enabled() || base.Flag.LowerM >= 2) && !l.escapes {
+					if base.Flag.LowerM >= 2 {
+						fmt.Printf("%s: parameter %v leaks to %s with derefs=%d:\n", base.FmtPos(l.n.Pos), l.n, e.explainLoc(root), derefs)
 					}
 					explanation := e.explainPath(root, l)
 					if logopt.Enabled() {
@@ -1231,9 +1232,9 @@ func (e *Escape) walkOne(root *EscLocation, walkgen uint32, enqueue func(*EscLoc
 			// outlives it, then l needs to be heap
 			// allocated.
 			if addressOf && !l.escapes {
-				if logopt.Enabled() || Flag.LowerM >= 2 {
-					if Flag.LowerM >= 2 {
-						fmt.Printf("%s: %v escapes to heap:\n", linestr(l.n.Pos), l.n)
+				if logopt.Enabled() || base.Flag.LowerM >= 2 {
+					if base.Flag.LowerM >= 2 {
+						fmt.Printf("%s: %v escapes to heap:\n", base.FmtPos(l.n.Pos), l.n)
 					}
 					explanation := e.explainPath(root, l)
 					if logopt.Enabled() {
@@ -1265,12 +1266,12 @@ func (e *Escape) walkOne(root *EscLocation, walkgen uint32, enqueue func(*EscLoc
 // explainPath prints an explanation of how src flows to the walk root.
 func (e *Escape) explainPath(root, src *EscLocation) []*logopt.LoggedOpt {
 	visited := make(map[*EscLocation]bool)
-	pos := linestr(src.n.Pos)
+	pos := base.FmtPos(src.n.Pos)
 	var explanation []*logopt.LoggedOpt
 	for {
 		// Prevent infinite loop.
 		if visited[src] {
-			if Flag.LowerM >= 2 {
+			if base.Flag.LowerM >= 2 {
 				fmt.Printf("%s:   warning: truncated explanation due to assignment cycle; see golang.org/issue/35518\n", pos)
 			}
 			break
@@ -1279,7 +1280,7 @@ func (e *Escape) explainPath(root, src *EscLocation) []*logopt.LoggedOpt {
 		dst := src.dst
 		edge := &dst.edges[src.dstEdgeIdx]
 		if edge.src != src {
-			Fatalf("path inconsistency: %v != %v", edge.src, src)
+			base.Fatalf("path inconsistency: %v != %v", edge.src, src)
 		}
 
 		explanation = e.explainFlow(pos, dst, src, edge.derefs, edge.notes, explanation)
@@ -1298,7 +1299,7 @@ func (e *Escape) explainFlow(pos string, dst, srcloc *EscLocation, derefs int, n
 	if derefs >= 0 {
 		ops = strings.Repeat("*", derefs)
 	}
-	print := Flag.LowerM >= 2
+	print := base.Flag.LowerM >= 2
 
 	flow := fmt.Sprintf("   flow: %s = %s%v:", e.explainLoc(dst), ops, e.explainLoc(srcloc))
 	if print {
@@ -1316,7 +1317,7 @@ func (e *Escape) explainFlow(pos string, dst, srcloc *EscLocation, derefs int, n
 
 	for note := notes; note != nil; note = note.next {
 		if print {
-			fmt.Printf("%s:     from %v (%v) at %s\n", pos, note.where, note.why, linestr(note.where.Pos))
+			fmt.Printf("%s:     from %v (%v) at %s\n", pos, note.where, note.why, base.FmtPos(note.where.Pos))
 		}
 		if logopt.Enabled() {
 			explanation = append(explanation, logopt.NewLoggedOpt(note.where.Pos, "escflow", "escape", e.curfn.funcname(),
@@ -1394,7 +1395,7 @@ func (e *Escape) outlives(l, other *EscLocation) bool {
 // containsClosure reports whether c is a closure contained within f.
 func containsClosure(f, c *Node) bool {
 	if f.Op != ODCLFUNC || c.Op != ODCLFUNC {
-		Fatalf("bad containsClosure: %v, %v", f, c)
+		base.Fatalf("bad containsClosure: %v, %v", f, c)
 	}
 
 	// Common case.
@@ -1452,8 +1453,8 @@ func (e *Escape) finish(fns []*Node) {
 
 		if loc.escapes {
 			if n.Op != ONAME {
-				if Flag.LowerM != 0 {
-					Warnl(n.Pos, "%S escapes to heap", n)
+				if base.Flag.LowerM != 0 {
+					base.WarnfAt(n.Pos, "%S escapes to heap", n)
 				}
 				if logopt.Enabled() {
 					logopt.LogOpt(n.Pos, "escape", "escape", e.curfn.funcname())
@@ -1462,8 +1463,8 @@ func (e *Escape) finish(fns []*Node) {
 			n.Esc = EscHeap
 			addrescapes(n)
 		} else {
-			if Flag.LowerM != 0 && n.Op != ONAME {
-				Warnl(n.Pos, "%S does not escape", n)
+			if base.Flag.LowerM != 0 && n.Op != ONAME {
+				base.WarnfAt(n.Pos, "%S does not escape", n)
 			}
 			n.Esc = EscNone
 			if loc.transient {
@@ -1516,7 +1517,7 @@ func (l *EscLeaks) add(i, derefs int) {
 func (l *EscLeaks) set(i, derefs int) {
 	v := derefs + 1
 	if v < 0 {
-		Fatalf("invalid derefs count: %v", derefs)
+		base.Fatalf("invalid derefs count: %v", derefs)
 	}
 	if v > math.MaxUint8 {
 		v = math.MaxUint8
diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index 48f77fa182..1fa64fbe44 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/bio"
 	"cmd/internal/src"
@@ -14,7 +15,7 @@ import (
 
 func exportf(bout *bio.Writer, format string, args ...interface{}) {
 	fmt.Fprintf(bout, format, args...)
-	if Debug.Export != 0 {
+	if base.Debug.Export != 0 {
 		fmt.Printf(format, args...)
 	}
 }
@@ -28,7 +29,7 @@ func exportsym(n *Node) {
 	}
 	n.Sym.SetOnExportList(true)
 
-	if Flag.E != 0 {
+	if base.Flag.E != 0 {
 		fmt.Printf("export symbol %v\n", n.Sym)
 	}
 
@@ -53,7 +54,7 @@ func autoexport(n *Node, ctxt Class) {
 	if types.IsExported(n.Sym.Name) || initname(n.Sym.Name) {
 		exportsym(n)
 	}
-	if Flag.AsmHdr != "" && !n.Sym.Asm() {
+	if base.Flag.AsmHdr != "" && !n.Sym.Asm() {
 		n.Sym.SetAsm(true)
 		asmlist = append(asmlist, n)
 	}
@@ -67,8 +68,8 @@ func dumpexport(bout *bio.Writer) {
 	size := bout.Offset() - off
 	exportf(bout, "\n$$\n")
 
-	if Debug.Export != 0 {
-		fmt.Printf("BenchmarkExportSize:%s 1 %d bytes\n", Ctxt.Pkgpath, size)
+	if base.Debug.Export != 0 {
+		fmt.Printf("BenchmarkExportSize:%s 1 %d bytes\n", base.Ctxt.Pkgpath, size)
 	}
 }
 
@@ -80,7 +81,7 @@ func importsym(ipkg *types.Pkg, s *types.Sym, op Op) *Node {
 		// is declarations for Runtimepkg, which are populated
 		// by loadsys instead.
 		if s.Pkg != Runtimepkg {
-			Fatalf("missing ONONAME for %v\n", s)
+			base.Fatalf("missing ONONAME for %v\n", s)
 		}
 
 		n = dclname(s)
@@ -88,7 +89,7 @@ func importsym(ipkg *types.Pkg, s *types.Sym, op Op) *Node {
 		s.Importdef = ipkg
 	}
 	if n.Op != ONONAME && n.Op != op {
-		redeclare(lineno, s, fmt.Sprintf("during import %q", ipkg.Path))
+		redeclare(base.Pos, s, fmt.Sprintf("during import %q", ipkg.Path))
 	}
 	return n
 }
@@ -111,7 +112,7 @@ func importtype(ipkg *types.Pkg, pos src.XPos, s *types.Sym) *types.Type {
 
 	t := n.Type
 	if t == nil {
-		Fatalf("importtype %v", s)
+		base.Fatalf("importtype %v", s)
 	}
 	return t
 }
@@ -122,7 +123,7 @@ func importobj(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op Op, ctxt Class, t
 	n := importsym(ipkg, s, op)
 	if n.Op != ONONAME {
 		if n.Op == op && (n.Class() != ctxt || !types.Identical(n.Type, t)) {
-			redeclare(lineno, s, fmt.Sprintf("during import %q", ipkg.Path))
+			redeclare(base.Pos, s, fmt.Sprintf("during import %q", ipkg.Path))
 		}
 		return nil
 	}
@@ -147,7 +148,7 @@ func importconst(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type, val
 
 	n.SetVal(val)
 
-	if Flag.E != 0 {
+	if base.Flag.E != 0 {
 		fmt.Printf("import const %v %L = %v\n", s, t, val)
 	}
 }
@@ -162,7 +163,7 @@ func importfunc(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) {
 
 	n.Func = new(Func)
 
-	if Flag.E != 0 {
+	if base.Flag.E != 0 {
 		fmt.Printf("import func %v%S\n", s, t)
 	}
 }
@@ -175,7 +176,7 @@ func importvar(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) {
 		return
 	}
 
-	if Flag.E != 0 {
+	if base.Flag.E != 0 {
 		fmt.Printf("import var %v %L\n", s, t)
 	}
 }
@@ -188,15 +189,15 @@ func importalias(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) {
 		return
 	}
 
-	if Flag.E != 0 {
+	if base.Flag.E != 0 {
 		fmt.Printf("import type %v = %L\n", s, t)
 	}
 }
 
 func dumpasmhdr() {
-	b, err := bio.Create(Flag.AsmHdr)
+	b, err := bio.Create(base.Flag.AsmHdr)
 	if err != nil {
-		Fatalf("%v", err)
+		base.Fatalf("%v", err)
 	}
 	fmt.Fprintf(b, "// generated by compile -asmhdr from package %s\n\n", localpkg.Name)
 	for _, n := range asmlist {
diff --git a/src/cmd/compile/internal/gc/fmt.go b/src/cmd/compile/internal/gc/fmt.go
index 51e139e319..9248eb22aa 100644
--- a/src/cmd/compile/internal/gc/fmt.go
+++ b/src/cmd/compile/internal/gc/fmt.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"bytes"
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"fmt"
@@ -47,7 +48,7 @@ func fmtFlag(s fmt.State, verb rune) FmtFlag {
 		flag |= FmtSign
 	}
 	if s.Flag(' ') {
-		Fatalf("FmtUnsigned in format string")
+		base.Fatalf("FmtUnsigned in format string")
 	}
 	if _, ok := s.Precision(); ok {
 		flag |= FmtComma
@@ -313,7 +314,7 @@ func (m fmtMode) prepareArgs(args []interface{}) {
 		case int32, int64, string, types.EType, constant.Value:
 			// OK: printing these types doesn't depend on mode
 		default:
-			Fatalf("mode.prepareArgs type %T", arg)
+			base.Fatalf("mode.prepareArgs type %T", arg)
 		}
 	}
 }
@@ -339,14 +340,14 @@ func (n *Node) jconv(s fmt.State, flag FmtFlag) {
 	short := flag&FmtShort != 0
 
 	// Useful to see which nodes in an AST printout are actually identical
-	if Debug.DumpPtrs != 0 {
+	if base.Debug.DumpPtrs != 0 {
 		fmt.Fprintf(s, " p(%p)", n)
 	}
 	if !short && n.Name != nil && n.Name.Vargen != 0 {
 		fmt.Fprintf(s, " g(%d)", n.Name.Vargen)
 	}
 
-	if Debug.DumpPtrs != 0 && !short && n.Name != nil && n.Name.Defn != nil {
+	if base.Debug.DumpPtrs != 0 && !short && n.Name != nil && n.Name.Defn != nil {
 		// Useful to see where Defn is set and what node it points to
 		fmt.Fprintf(s, " defn(%p)", n.Name.Defn)
 	}
@@ -817,7 +818,7 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode fmtMode, visited
 			case mt.Hiter:
 				b.WriteString("map.iter[")
 			default:
-				Fatalf("unknown internal map type")
+				base.Fatalf("unknown internal map type")
 			}
 			tconv2(b, m.Key(), 0, mode, visited)
 			b.WriteByte(']')
@@ -1416,7 +1417,7 @@ func (n *Node) exprfmt(s fmt.State, prec int, mode fmtMode) {
 
 	case OSLICEHEADER:
 		if n.List.Len() != 2 {
-			Fatalf("bad OSLICEHEADER list length %d", n.List.Len())
+			base.Fatalf("bad OSLICEHEADER list length %d", n.List.Len())
 		}
 		mode.Fprintf(s, "sliceheader{%v,%v,%v}", n.Left, n.List.First(), n.List.Second())
 
@@ -1806,7 +1807,7 @@ func (n *Node) nconv(s fmt.State, flag FmtFlag, mode fmtMode) {
 		dumpdepth--
 
 	default:
-		Fatalf("unhandled %%N mode: %d", mode)
+		base.Fatalf("unhandled %%N mode: %d", mode)
 	}
 }
 
diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
index d882d6d672..a70bddca81 100644
--- a/src/cmd/compile/internal/gc/gen.go
+++ b/src/cmd/compile/internal/gc/gen.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/src"
@@ -52,14 +53,14 @@ func autotmpname(n int) string {
 // make a new Node off the books
 func tempAt(pos src.XPos, curfn *Node, t *types.Type) *Node {
 	if curfn == nil {
-		Fatalf("no curfn for tempAt")
+		base.Fatalf("no curfn for tempAt")
 	}
 	if curfn.Op == OCLOSURE {
 		Dump("tempAt", curfn)
-		Fatalf("adding tempAt to wrong closure function")
+		base.Fatalf("adding tempAt to wrong closure function")
 	}
 	if t == nil {
-		Fatalf("tempAt called with nil type")
+		base.Fatalf("tempAt called with nil type")
 	}
 
 	s := &types.Sym{
@@ -82,5 +83,5 @@ func tempAt(pos src.XPos, curfn *Node, t *types.Type) *Node {
 }
 
 func temp(t *types.Type) *Node {
-	return tempAt(lineno, Curfn, t)
+	return tempAt(base.Pos, Curfn, t)
 }
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index 947dae476b..e9ff5aeb13 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -39,7 +40,7 @@ var (
 
 // isRuntimePkg reports whether p is package runtime.
 func isRuntimePkg(p *types.Pkg) bool {
-	if Flag.CompilingRuntime && p == localpkg {
+	if base.Flag.CompilingRuntime && p == localpkg {
 		return true
 	}
 	return p.Path == "runtime"
@@ -48,7 +49,7 @@ func isRuntimePkg(p *types.Pkg) bool {
 // isReflectPkg reports whether p is package reflect.
 func isReflectPkg(p *types.Pkg) bool {
 	if p == localpkg {
-		return Ctxt.Pkgpath == "reflect"
+		return base.Ctxt.Pkgpath == "reflect"
 	}
 	return p.Path == "reflect"
 }
@@ -182,8 +183,6 @@ var instrumenting bool
 // Whether we are tracking lexical scopes for DWARF.
 var trackScopes bool
 
-var Ctxt *obj.Link
-
 var nodfp *Node
 
 var autogeneratedPos src.XPos
diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go
index 00d425a77c..92a3611cb7 100644
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ b/src/cmd/compile/internal/gc/gsubr.go
@@ -31,6 +31,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/ssa"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
@@ -57,8 +58,8 @@ type Progs struct {
 // worker indicates which of the backend workers will use the Progs.
 func newProgs(fn *Node, worker int) *Progs {
 	pp := new(Progs)
-	if Ctxt.CanReuseProgs() {
-		sz := len(sharedProgArray) / Flag.LowerC
+	if base.Ctxt.CanReuseProgs() {
+		sz := len(sharedProgArray) / base.Flag.LowerC
 		pp.progcache = sharedProgArray[sz*worker : sz*(worker+1)]
 	}
 	pp.curfn = fn
@@ -83,19 +84,19 @@ func (pp *Progs) NewProg() *obj.Prog {
 	} else {
 		p = new(obj.Prog)
 	}
-	p.Ctxt = Ctxt
+	p.Ctxt = base.Ctxt
 	return p
 }
 
 // Flush converts from pp to machine code.
 func (pp *Progs) Flush() {
 	plist := &obj.Plist{Firstpc: pp.Text, Curfn: pp.curfn}
-	obj.Flushplist(Ctxt, plist, pp.NewProg, Ctxt.Pkgpath)
+	obj.Flushplist(base.Ctxt, plist, pp.NewProg, base.Ctxt.Pkgpath)
 }
 
 // Free clears pp and any associated resources.
 func (pp *Progs) Free() {
-	if Ctxt.CanReuseProgs() {
+	if base.Ctxt.CanReuseProgs() {
 		// Clear progs to enable GC and avoid abuse.
 		s := pp.progcache[:pp.cacheidx]
 		for i := range s {
@@ -133,8 +134,8 @@ func (pp *Progs) Prog(as obj.As) *obj.Prog {
 	pp.clearp(pp.next)
 	p.Link = pp.next
 
-	if !pp.pos.IsKnown() && Flag.K != 0 {
-		Warn("prog: unknown position (line 0)")
+	if !pp.pos.IsKnown() && base.Flag.K != 0 {
+		base.Warn("prog: unknown position (line 0)")
 	}
 
 	p.As = as
@@ -174,7 +175,7 @@ func (pp *Progs) Appendpp(p *obj.Prog, as obj.As, ftype obj.AddrType, freg int16
 
 func (pp *Progs) settext(fn *Node) {
 	if pp.Text != nil {
-		Fatalf("Progs.settext called twice")
+		base.Fatalf("Progs.settext called twice")
 	}
 	ptxt := pp.Prog(obj.ATEXT)
 	pp.Text = ptxt
@@ -193,7 +194,7 @@ func (pp *Progs) settext(fn *Node) {
 // called for both functions with bodies and functions without bodies.
 func (f *Func) initLSym(hasBody bool) {
 	if f.lsym != nil {
-		Fatalf("Func.initLSym called twice")
+		base.Fatalf("Func.initLSym called twice")
 	}
 
 	if nam := f.Nname; !nam.isBlank() {
@@ -215,7 +216,7 @@ func (f *Func) initLSym(hasBody bool) {
 			// using the expected ABI.
 			want := obj.ABIInternal
 			if f.lsym.ABI() != want {
-				Fatalf("function symbol %s has the wrong ABI %v, expected %v", f.lsym.Name, f.lsym.ABI(), want)
+				base.Fatalf("function symbol %s has the wrong ABI %v, expected %v", f.lsym.Name, f.lsym.ABI(), want)
 			}
 		}
 
@@ -249,7 +250,7 @@ func (f *Func) initLSym(hasBody bool) {
 			}
 			asym.SetABI(aliasABI)
 			asym.Set(obj.AttrDuplicateOK, true)
-			Ctxt.ABIAliases = append(Ctxt.ABIAliases, asym)
+			base.Ctxt.ABIAliases = append(base.Ctxt.ABIAliases, asym)
 		}
 	}
 
@@ -278,14 +279,14 @@ func (f *Func) initLSym(hasBody bool) {
 	// Clumsy but important.
 	// See test/recover.go for test cases and src/reflect/value.go
 	// for the actual functions being considered.
-	if Ctxt.Pkgpath == "reflect" {
+	if base.Ctxt.Pkgpath == "reflect" {
 		switch f.Nname.Sym.Name {
 		case "callReflect", "callMethod":
 			flag |= obj.WRAPPER
 		}
 	}
 
-	Ctxt.InitTextSym(f.lsym, flag)
+	base.Ctxt.InitTextSym(f.lsym, flag)
 }
 
 func ggloblnod(nam *Node) {
@@ -298,7 +299,7 @@ func ggloblnod(nam *Node) {
 	if nam.Type != nil && !nam.Type.HasPointers() {
 		flags |= obj.NOPTR
 	}
-	Ctxt.Globl(s, nam.Type.Width, flags)
+	base.Ctxt.Globl(s, nam.Type.Width, flags)
 	if nam.Name.LibfuzzerExtraCounter() {
 		s.Type = objabi.SLIBFUZZER_EXTRA_COUNTER
 	}
@@ -315,7 +316,7 @@ func ggloblsym(s *obj.LSym, width int32, flags int16) {
 		s.Set(obj.AttrLocal, true)
 		flags &^= obj.LOCAL
 	}
-	Ctxt.Globl(s, int64(width), int(flags))
+	base.Ctxt.Globl(s, int64(width), int(flags))
 }
 
 func Addrconst(a *obj.Addr, v int64) {
@@ -326,7 +327,7 @@ func Addrconst(a *obj.Addr, v int64) {
 
 func Patch(p *obj.Prog, to *obj.Prog) {
 	if p.To.Type != obj.TYPE_BRANCH {
-		Fatalf("patch: not a branch")
+		base.Fatalf("patch: not a branch")
 	}
 	p.To.SetTarget(to)
 	p.To.Offset = to.Pc
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index 447f938a0a..246a057ade 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -204,6 +204,7 @@ package gc
 import (
 	"bufio"
 	"bytes"
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/goobj"
 	"cmd/internal/src"
@@ -266,7 +267,7 @@ func iexport(out *bufio.Writer) {
 		p.typIndex[pt] = uint64(i)
 	}
 	if len(p.typIndex) > predeclReserved {
-		Fatalf("too many predeclared types: %d > %d", len(p.typIndex), predeclReserved)
+		base.Fatalf("too many predeclared types: %d > %d", len(p.typIndex), predeclReserved)
 	}
 
 	// Initialize work queue with exported declarations.
@@ -304,8 +305,8 @@ func iexport(out *bufio.Writer) {
 
 	// Add fingerprint (used by linker object file).
 	// Attach this to the end, so tools (e.g. gcimporter) don't care.
-	copy(Ctxt.Fingerprint[:], h.Sum(nil)[:])
-	out.Write(Ctxt.Fingerprint[:])
+	copy(base.Ctxt.Fingerprint[:], h.Sum(nil)[:])
+	out.Write(base.Ctxt.Fingerprint[:])
 }
 
 // writeIndex writes out an object index. mainIndex indicates whether
@@ -394,7 +395,7 @@ func (p *iexporter) stringOff(s string) uint64 {
 // pushDecl adds n to the declaration work queue, if not already present.
 func (p *iexporter) pushDecl(n *Node) {
 	if n.Sym == nil || asNode(n.Sym.Def) != n && n.Op != OTYPE {
-		Fatalf("weird Sym: %v, %v", n, n.Sym)
+		base.Fatalf("weird Sym: %v, %v", n, n.Sym)
 	}
 
 	// Don't export predeclared declarations.
@@ -437,7 +438,7 @@ func (p *iexporter) doDecl(n *Node) {
 
 		case PFUNC:
 			if n.IsMethod() {
-				Fatalf("unexpected method: %v", n)
+				base.Fatalf("unexpected method: %v", n)
 			}
 
 			// Function.
@@ -447,7 +448,7 @@ func (p *iexporter) doDecl(n *Node) {
 			w.funcExt(n)
 
 		default:
-			Fatalf("unexpected class: %v, %v", n, n.Class())
+			base.Fatalf("unexpected class: %v, %v", n, n.Class())
 		}
 
 	case OLITERAL:
@@ -503,7 +504,7 @@ func (p *iexporter) doDecl(n *Node) {
 		}
 
 	default:
-		Fatalf("unexpected node: %v", n)
+		base.Fatalf("unexpected node: %v", n)
 	}
 
 	p.declIndex[n] = w.flush()
@@ -523,7 +524,7 @@ func (p *iexporter) doInline(f *Node) {
 }
 
 func (w *exportWriter) pos(pos src.XPos) {
-	p := Ctxt.PosTable.Pos(pos)
+	p := base.Ctxt.PosTable.Pos(pos)
 	file := p.Base().AbsFilename()
 	line := int64(p.RelLine())
 	column := int64(p.RelCol())
@@ -579,7 +580,7 @@ func (w *exportWriter) qualifiedIdent(n *Node) {
 
 func (w *exportWriter) selector(s *types.Sym) {
 	if w.currPkg == nil {
-		Fatalf("missing currPkg")
+		base.Fatalf("missing currPkg")
 	}
 
 	// Method selectors are rewritten into method symbols (of the
@@ -594,7 +595,7 @@ func (w *exportWriter) selector(s *types.Sym) {
 			pkg = localpkg
 		}
 		if s.Pkg != pkg {
-			Fatalf("package mismatch in selector: %v in package %q, but want %q", s, s.Pkg.Path, pkg.Path)
+			base.Fatalf("package mismatch in selector: %v in package %q, but want %q", s, s.Pkg.Path, pkg.Path)
 		}
 	}
 
@@ -633,7 +634,7 @@ func (w *exportWriter) startType(k itag) {
 func (w *exportWriter) doTyp(t *types.Type) {
 	if t.Sym != nil {
 		if t.Sym.Pkg == builtinpkg || t.Sym.Pkg == unsafepkg {
-			Fatalf("builtin type missing from typIndex: %v", t)
+			base.Fatalf("builtin type missing from typIndex: %v", t)
 		}
 
 		w.startType(definedType)
@@ -710,7 +711,7 @@ func (w *exportWriter) doTyp(t *types.Type) {
 		}
 
 	default:
-		Fatalf("unexpected type: %v", t)
+		base.Fatalf("unexpected type: %v", t)
 	}
 }
 
@@ -773,7 +774,7 @@ func constTypeOf(typ *types.Type) constant.Kind {
 		return constant.Complex
 	}
 
-	Fatalf("unexpected constant type: %v", typ)
+	base.Fatalf("unexpected constant type: %v", typ)
 	return 0
 }
 
@@ -851,7 +852,7 @@ func (w *exportWriter) mpint(x constant.Value, typ *types.Type) {
 
 	negative := constant.Sign(x) < 0
 	if !signed && negative {
-		Fatalf("negative unsigned integer; type %v, value %v", typ, x)
+		base.Fatalf("negative unsigned integer; type %v, value %v", typ, x)
 	}
 
 	b := constant.Bytes(x) // little endian
@@ -860,10 +861,10 @@ func (w *exportWriter) mpint(x constant.Value, typ *types.Type) {
 	}
 
 	if len(b) > 0 && b[0] == 0 {
-		Fatalf("leading zeros")
+		base.Fatalf("leading zeros")
 	}
 	if uint(len(b)) > maxBytes {
-		Fatalf("bad mpint length: %d > %d (type %v, value %v)", len(b), maxBytes, typ, x)
+		base.Fatalf("bad mpint length: %d > %d (type %v, value %v)", len(b), maxBytes, typ, x)
 	}
 
 	maxSmall := 256 - maxBytes
@@ -900,7 +901,7 @@ func (w *exportWriter) mpint(x constant.Value, typ *types.Type) {
 		}
 	}
 	if n < maxSmall || n >= 256 {
-		Fatalf("encoding mistake: %d, %v, %v => %d", len(b), signed, negative, n)
+		base.Fatalf("encoding mistake: %d, %v, %v => %d", len(b), signed, negative, n)
 	}
 
 	w.data.WriteByte(byte(n))
@@ -916,7 +917,7 @@ func (w *exportWriter) mpint(x constant.Value, typ *types.Type) {
 func (w *exportWriter) mpfloat(v constant.Value, typ *types.Type) {
 	f := bigFloatVal(v)
 	if f.IsInf() {
-		Fatalf("infinite constant")
+		base.Fatalf("infinite constant")
 	}
 
 	// Break into f = mant × 2**exp, with 0.5 <= mant < 1.
@@ -930,7 +931,7 @@ func (w *exportWriter) mpfloat(v constant.Value, typ *types.Type) {
 
 	manti, acc := mant.Int(nil)
 	if acc != big.Exact {
-		Fatalf("mantissa scaling failed for %f (%s)", f, acc)
+		base.Fatalf("mantissa scaling failed for %f (%s)", f, acc)
 	}
 	w.mpint(makeInt(manti), typ)
 	if manti.Sign() != 0 {
@@ -1158,7 +1159,7 @@ func (w *exportWriter) stmt(n *Node) {
 		w.string(n.Sym.Name)
 
 	default:
-		Fatalf("exporter: CANNOT EXPORT: %v\nPlease notify gri@\n", n.Op)
+		base.Fatalf("exporter: CANNOT EXPORT: %v\nPlease notify gri@\n", n.Op)
 	}
 }
 
@@ -1169,7 +1170,7 @@ func (w *exportWriter) caseList(sw *Node) {
 	w.uint64(uint64(len(cases)))
 	for _, cas := range cases {
 		if cas.Op != OCASE {
-			Fatalf("expected OCASE, got %v", cas)
+			base.Fatalf("expected OCASE, got %v", cas)
 		}
 		w.pos(cas.Pos)
 		w.stmtList(cas.List)
@@ -1207,7 +1208,7 @@ func (w *exportWriter) expr(n *Node) {
 	// (somewhat closely following the structure of exprfmt in fmt.go)
 	case ONIL:
 		if !n.Type.HasNil() {
-			Fatalf("unexpected type for nil: %v", n.Type)
+			base.Fatalf("unexpected type for nil: %v", n.Type)
 		}
 		if n.Orig != nil && n.Orig != n {
 			w.expr(n.Orig)
@@ -1256,7 +1257,7 @@ func (w *exportWriter) expr(n *Node) {
 		var s *types.Sym
 		if n.Left != nil {
 			if n.Left.Op != ONONAME {
-				Fatalf("expected ONONAME, got %v", n.Left)
+				base.Fatalf("expected ONONAME, got %v", n.Left)
 			}
 			s = n.Left.Sym
 		}
@@ -1365,7 +1366,7 @@ func (w *exportWriter) expr(n *Node) {
 		if op == OAPPEND {
 			w.bool(n.IsDDD())
 		} else if n.IsDDD() {
-			Fatalf("exporter: unexpected '...' with %v call", op)
+			base.Fatalf("exporter: unexpected '...' with %v call", op)
 		}
 
 	case OCALL, OCALLFUNC, OCALLMETH, OCALLINTER, OGETG:
@@ -1419,7 +1420,7 @@ func (w *exportWriter) expr(n *Node) {
 		// has already been replaced with literals
 
 	default:
-		Fatalf("cannot export %v (%d) node\n"+
+		base.Fatalf("cannot export %v (%d) node\n"+
 			"\t==> please file an issue and assign to gri@", n.Op, int(n.Op))
 	}
 }
@@ -1484,18 +1485,18 @@ func (w *exportWriter) localIdent(s *types.Sym, v int32) {
 
 	// TODO(mdempsky): Fix autotmp hack.
 	if i := strings.LastIndex(name, "."); i >= 0 && !strings.HasPrefix(name, ".autotmp_") {
-		Fatalf("unexpected dot in identifier: %v", name)
+		base.Fatalf("unexpected dot in identifier: %v", name)
 	}
 
 	if v > 0 {
 		if strings.Contains(name, "·") {
-			Fatalf("exporter: unexpected · in symbol name")
+			base.Fatalf("exporter: unexpected · in symbol name")
 		}
 		name = fmt.Sprintf("%s·%d", name, v)
 	}
 
 	if !types.IsExported(name) && s.Pkg != w.currPkg {
-		Fatalf("weird package in name: %v => %v, not %q", s, name, w.currPkg.Path)
+		base.Fatalf("weird package in name: %v => %v, not %q", s, name, w.currPkg.Path)
 	}
 
 	w.string(name)
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index a8a84b8cbc..cc0209ed03 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -8,6 +8,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/bio"
 	"cmd/internal/goobj"
@@ -60,7 +61,7 @@ func expandInline(fn *Node) {
 
 	r := importReaderFor(fn, inlineImporter)
 	if r == nil {
-		Fatalf("missing import reader for %v", fn)
+		base.Fatalf("missing import reader for %v", fn)
 	}
 
 	r.doInline(fn)
@@ -83,8 +84,8 @@ type intReader struct {
 func (r *intReader) int64() int64 {
 	i, err := binary.ReadVarint(r.Reader)
 	if err != nil {
-		yyerror("import %q: read error: %v", r.pkg.Path, err)
-		errorexit()
+		base.Errorf("import %q: read error: %v", r.pkg.Path, err)
+		base.ErrorExit()
 	}
 	return i
 }
@@ -92,8 +93,8 @@ func (r *intReader) int64() int64 {
 func (r *intReader) uint64() uint64 {
 	i, err := binary.ReadUvarint(r.Reader)
 	if err != nil {
-		yyerror("import %q: read error: %v", r.pkg.Path, err)
-		errorexit()
+		base.Errorf("import %q: read error: %v", r.pkg.Path, err)
+		base.ErrorExit()
 	}
 	return i
 }
@@ -103,8 +104,8 @@ func iimport(pkg *types.Pkg, in *bio.Reader) (fingerprint goobj.FingerprintType)
 
 	version := ird.uint64()
 	if version != iexportVersion {
-		yyerror("import %q: unknown export format version %d", pkg.Path, version)
-		errorexit()
+		base.Errorf("import %q: unknown export format version %d", pkg.Path, version)
+		base.ErrorExit()
 	}
 
 	sLen := ird.uint64()
@@ -115,8 +116,8 @@ func iimport(pkg *types.Pkg, in *bio.Reader) (fingerprint goobj.FingerprintType)
 	// returning individual substrings very efficiently.
 	data, err := mapFile(in.File(), in.Offset(), int64(sLen+dLen))
 	if err != nil {
-		yyerror("import %q: mapping input: %v", pkg.Path, err)
-		errorexit()
+		base.Errorf("import %q: mapping input: %v", pkg.Path, err)
+		base.ErrorExit()
 	}
 	stringData := data[:sLen]
 	declData := data[sLen:]
@@ -152,10 +153,10 @@ func iimport(pkg *types.Pkg, in *bio.Reader) (fingerprint goobj.FingerprintType)
 			pkg.Lookup("_").Def = asTypesNode(nblank)
 		} else {
 			if pkg.Name != pkgName {
-				Fatalf("conflicting package names %v and %v for path %q", pkg.Name, pkgName, pkg.Path)
+				base.Fatalf("conflicting package names %v and %v for path %q", pkg.Name, pkgName, pkg.Path)
 			}
 			if pkg.Height != pkgHeight {
-				Fatalf("conflicting package heights %v and %v for path %q", pkg.Height, pkgHeight, pkg.Path)
+				base.Fatalf("conflicting package heights %v and %v for path %q", pkg.Height, pkgHeight, pkg.Path)
 			}
 		}
 
@@ -171,7 +172,7 @@ func iimport(pkg *types.Pkg, in *bio.Reader) (fingerprint goobj.FingerprintType)
 			// Create stub declaration. If used, this will
 			// be overwritten by expandDecl.
 			if s.Def != nil {
-				Fatalf("unexpected definition for %v: %v", s, asNode(s.Def))
+				base.Fatalf("unexpected definition for %v: %v", s, asNode(s.Def))
 			}
 			s.Def = asTypesNode(npos(src.NoXPos, dclname(s)))
 		}
@@ -195,8 +196,8 @@ func iimport(pkg *types.Pkg, in *bio.Reader) (fingerprint goobj.FingerprintType)
 	// Fingerprint.
 	_, err = io.ReadFull(in, fingerprint[:])
 	if err != nil {
-		yyerror("import %s: error reading fingerprint", pkg.Path)
-		errorexit()
+		base.Errorf("import %s: error reading fingerprint", pkg.Path)
+		base.ErrorExit()
 	}
 	return fingerprint
 }
@@ -218,7 +219,7 @@ func (p *iimporter) stringAt(off uint64) string {
 
 	slen, n := binary.Uvarint(x[:n])
 	if n <= 0 {
-		Fatalf("varint failed")
+		base.Fatalf("varint failed")
 	}
 	spos := off + uint64(n)
 	return p.stringData[spos : spos+slen]
@@ -281,7 +282,7 @@ func (r *importReader) setPkg() {
 
 func (r *importReader) doDecl(n *Node) {
 	if n.Op != ONONAME {
-		Fatalf("doDecl: unexpected Op for %v: %v", n.Sym, n.Op)
+		base.Fatalf("doDecl: unexpected Op for %v: %v", n.Sym, n.Op)
 	}
 
 	tag := r.byte()
@@ -352,7 +353,7 @@ func (r *importReader) doDecl(n *Node) {
 		r.varExt(n)
 
 	default:
-		Fatalf("unexpected tag: %v", tag)
+		base.Fatalf("unexpected tag: %v", tag)
 	}
 }
 
@@ -372,7 +373,7 @@ func (p *importReader) value(typ *types.Type) constant.Value {
 		return makeComplex(p.float(typ), p.float(typ))
 	}
 
-	Fatalf("unexpected value type: %v", typ)
+	base.Fatalf("unexpected value type: %v", typ)
 	panic("unreachable")
 }
 
@@ -405,7 +406,7 @@ func (p *importReader) mpint(x *big.Int, typ *types.Type) {
 		v = -(n &^ 1) >> 1
 	}
 	if v < 1 || uint(v) > maxBytes {
-		Fatalf("weird decoding: %v, %v => %v", n, signed, v)
+		base.Fatalf("weird decoding: %v, %v => %v", n, signed, v)
 	}
 	b := make([]byte, v)
 	p.Read(b)
@@ -462,10 +463,10 @@ func (r *importReader) pos() src.XPos {
 	}
 
 	if r.prevBase == nil {
-		Fatalf("missing posbase")
+		base.Fatalf("missing posbase")
 	}
 	pos := src.MakePos(r.prevBase, uint(r.prevLine), uint(r.prevColumn))
-	return Ctxt.PosTable.XPos(pos)
+	return base.Ctxt.PosTable.XPos(pos)
 }
 
 func (r *importReader) typ() *types.Type {
@@ -476,7 +477,7 @@ func (p *iimporter) typAt(off uint64) *types.Type {
 	t, ok := p.typCache[off]
 	if !ok {
 		if off < predeclReserved {
-			Fatalf("predeclared type missing from cache: %d", off)
+			base.Fatalf("predeclared type missing from cache: %d", off)
 		}
 		t = p.newReader(off-predeclReserved, nil).typ1()
 		p.typCache[off] = t
@@ -487,7 +488,7 @@ func (p *iimporter) typAt(off uint64) *types.Type {
 func (r *importReader) typ1() *types.Type {
 	switch k := r.kind(); k {
 	default:
-		Fatalf("unexpected kind tag in %q: %v", r.p.ipkg.Path, k)
+		base.Fatalf("unexpected kind tag in %q: %v", r.p.ipkg.Path, k)
 		return nil
 
 	case definedType:
@@ -502,7 +503,7 @@ func (r *importReader) typ1() *types.Type {
 			expandDecl(n)
 		}
 		if n.Op != OTYPE {
-			Fatalf("expected OTYPE, got %v: %v, %v", n.Op, n.Sym, n)
+			base.Fatalf("expected OTYPE, got %v: %v, %v", n.Op, n.Sym, n)
 		}
 		return n.Type
 	case pointerType:
@@ -610,7 +611,7 @@ func (r *importReader) bool() bool {
 func (r *importReader) int64() int64 {
 	n, err := binary.ReadVarint(r)
 	if err != nil {
-		Fatalf("readVarint: %v", err)
+		base.Fatalf("readVarint: %v", err)
 	}
 	return n
 }
@@ -618,7 +619,7 @@ func (r *importReader) int64() int64 {
 func (r *importReader) uint64() uint64 {
 	n, err := binary.ReadUvarint(r)
 	if err != nil {
-		Fatalf("readVarint: %v", err)
+		base.Fatalf("readVarint: %v", err)
 	}
 	return n
 }
@@ -626,7 +627,7 @@ func (r *importReader) uint64() uint64 {
 func (r *importReader) byte() byte {
 	x, err := r.ReadByte()
 	if err != nil {
-		Fatalf("declReader.ReadByte: %v", err)
+		base.Fatalf("declReader.ReadByte: %v", err)
 	}
 	return x
 }
@@ -674,7 +675,7 @@ func (r *importReader) symIdx(s *types.Sym) {
 	idx := int32(r.int64())
 	if idx != -1 {
 		if s.Linkname != "" {
-			Fatalf("bad index for linknamed symbol: %v %d\n", lsym, idx)
+			base.Fatalf("bad index for linknamed symbol: %v %d\n", lsym, idx)
 		}
 		lsym.SymIdx = idx
 		lsym.Set(obj.AttrIndexed, true)
@@ -695,7 +696,7 @@ var typeSymIdx = make(map[*types.Type][2]int64)
 
 func (r *importReader) doInline(n *Node) {
 	if len(n.Func.Inl.Body) != 0 {
-		Fatalf("%v already has inline body", n)
+		base.Fatalf("%v already has inline body", n)
 	}
 
 	funchdr(n)
@@ -714,8 +715,8 @@ func (r *importReader) doInline(n *Node) {
 
 	importlist = append(importlist, n)
 
-	if Flag.E > 0 && Flag.LowerM > 2 {
-		if Flag.LowerM > 3 {
+	if base.Flag.E > 0 && base.Flag.LowerM > 2 {
+		if base.Flag.LowerM > 3 {
 			fmt.Printf("inl body for %v %#v: %+v\n", n, n.Type, asNodes(n.Func.Inl.Body))
 		} else {
 			fmt.Printf("inl body for %v %#v: %v\n", n, n.Type, asNodes(n.Func.Inl.Body))
@@ -793,7 +794,7 @@ func (r *importReader) exprList() []*Node {
 func (r *importReader) expr() *Node {
 	n := r.node()
 	if n != nil && n.Op == OBLOCK {
-		Fatalf("unexpected block node: %v", n)
+		base.Fatalf("unexpected block node: %v", n)
 	}
 	return n
 }
@@ -854,11 +855,11 @@ func (r *importReader) node() *Node {
 
 	case OSTRUCTLIT:
 		// TODO(mdempsky): Export position information for OSTRUCTKEY nodes.
-		savedlineno := lineno
-		lineno = r.pos()
-		n := nodl(lineno, OCOMPLIT, nil, typenod(r.typ()))
+		savedlineno := base.Pos
+		base.Pos = r.pos()
+		n := nodl(base.Pos, OCOMPLIT, nil, typenod(r.typ()))
 		n.List.Set(r.elemList()) // special handling of field names
-		lineno = savedlineno
+		base.Pos = savedlineno
 		return n
 
 	// case OARRAYLIT, OSLICELIT, OMAPLIT:
@@ -1070,7 +1071,7 @@ func (r *importReader) node() *Node {
 		return nil
 
 	default:
-		Fatalf("cannot import %v (%d) node\n"+
+		base.Fatalf("cannot import %v (%d) node\n"+
 			"\t==> please file an issue and assign to gri@", op, int(op))
 		panic("unreachable") // satisfy compiler
 	}
diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index c3b66a2ad2..9319faf6a0 100644
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 )
@@ -44,7 +45,7 @@ func fninit(n []*Node) {
 
 	// Make a function that contains all the initialization statements.
 	if len(nf) > 0 {
-		lineno = nf[0].Pos // prolog/epilog gets line number of first init stmt
+		base.Pos = nf[0].Pos // prolog/epilog gets line number of first init stmt
 		initializers := lookup("init")
 		fn := dclfunc(initializers, nod(OTFUNC, nil, nil))
 		for _, dcl := range initTodo.Func.Dcl {
@@ -67,7 +68,7 @@ func fninit(n []*Node) {
 		// We only generate temps using initTodo if there
 		// are package-scope initialization statements, so
 		// something's weird if we get here.
-		Fatalf("initTodo still has declarations")
+		base.Fatalf("initTodo still has declarations")
 	}
 	initTodo = nil
 
diff --git a/src/cmd/compile/internal/gc/initorder.go b/src/cmd/compile/internal/gc/initorder.go
index ecbfc5631a..f553a3f057 100644
--- a/src/cmd/compile/internal/gc/initorder.go
+++ b/src/cmd/compile/internal/gc/initorder.go
@@ -8,6 +8,8 @@ import (
 	"bytes"
 	"container/heap"
 	"fmt"
+
+	"cmd/compile/internal/base"
 )
 
 // Package initialization
@@ -89,7 +91,7 @@ func initOrder(l []*Node) []*Node {
 		case ODCLCONST, ODCLFUNC, ODCLTYPE:
 			// nop
 		default:
-			Fatalf("unexpected package-level statement: %v", n)
+			base.Fatalf("unexpected package-level statement: %v", n)
 		}
 	}
 
@@ -104,10 +106,10 @@ func initOrder(l []*Node) []*Node {
 				// confused us and there might not be
 				// a loop. Let the user fix those
 				// first.
-				ExitIfErrors()
+				base.ExitIfErrors()
 
 				findInitLoopAndExit(firstLHS(n), new([]*Node))
-				Fatalf("initialization unfinished, but failed to identify loop")
+				base.Fatalf("initialization unfinished, but failed to identify loop")
 			}
 		}
 	}
@@ -115,7 +117,7 @@ func initOrder(l []*Node) []*Node {
 	// Invariant consistency check. If this is non-zero, then we
 	// should have found a cycle above.
 	if len(o.blocking) != 0 {
-		Fatalf("expected empty map: %v", o.blocking)
+		base.Fatalf("expected empty map: %v", o.blocking)
 	}
 
 	return s.out
@@ -123,7 +125,7 @@ func initOrder(l []*Node) []*Node {
 
 func (o *InitOrder) processAssign(n *Node) {
 	if n.Initorder() != InitNotStarted || n.Xoffset != BADWIDTH {
-		Fatalf("unexpected state: %v, %v, %v", n, n.Initorder(), n.Xoffset)
+		base.Fatalf("unexpected state: %v, %v, %v", n, n.Initorder(), n.Xoffset)
 	}
 
 	n.SetInitorder(InitPending)
@@ -154,7 +156,7 @@ func (o *InitOrder) flushReady(initialize func(*Node)) {
 	for o.ready.Len() != 0 {
 		n := heap.Pop(&o.ready).(*Node)
 		if n.Initorder() != InitPending || n.Xoffset != 0 {
-			Fatalf("unexpected state: %v, %v, %v", n, n.Initorder(), n.Xoffset)
+			base.Fatalf("unexpected state: %v, %v, %v", n, n.Initorder(), n.Xoffset)
 		}
 
 		initialize(n)
@@ -238,8 +240,8 @@ func reportInitLoopAndExit(l []*Node) {
 	}
 	fmt.Fprintf(&msg, "\t%v: %v", l[0].Line(), l[0])
 
-	yyerrorl(l[0].Pos, msg.String())
-	errorexit()
+	base.ErrorfAt(l[0].Pos, msg.String())
+	base.ErrorExit()
 }
 
 // collectDeps returns all of the package-level functions and
@@ -256,7 +258,7 @@ func collectDeps(n *Node, transitive bool) NodeSet {
 	case ODCLFUNC:
 		d.inspectList(n.Nbody)
 	default:
-		Fatalf("unexpected Op: %v", n.Op)
+		base.Fatalf("unexpected Op: %v", n.Op)
 	}
 	return d.seen
 }
@@ -347,6 +349,6 @@ func firstLHS(n *Node) *Node {
 		return n.List.First()
 	}
 
-	Fatalf("unexpected Op: %v", n.Op)
+	base.Fatalf("unexpected Op: %v", n.Op)
 	return nil
 }
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index fc467dd95a..d71ea9b5ed 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -27,6 +27,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -60,7 +61,7 @@ func fnpkg(fn *Node) *types.Pkg {
 			rcvr = rcvr.Elem()
 		}
 		if rcvr.Sym == nil {
-			Fatalf("receiver with no sym: [%v] %L  (%v)", fn.Sym, fn, rcvr)
+			base.Fatalf("receiver with no sym: [%v] %L  (%v)", fn.Sym, fn, rcvr)
 		}
 		return rcvr.Sym.Pkg
 	}
@@ -86,7 +87,7 @@ func typecheckinl(fn *Node) {
 		return // typecheckinl on local function
 	}
 
-	if Flag.LowerM > 2 || Debug.Export != 0 {
+	if base.Flag.LowerM > 2 || base.Debug.Export != 0 {
 		fmt.Printf("typecheck import [%v] %L { %#v }\n", fn.Sym, fn, asNodes(fn.Func.Inl.Body))
 	}
 
@@ -103,7 +104,7 @@ func typecheckinl(fn *Node) {
 	fn.Func.Inl.Dcl = append(fn.Func.Inl.Dcl, fn.Func.Dcl...)
 	fn.Func.Dcl = nil
 
-	lineno = lno
+	base.Pos = lno
 }
 
 // Caninl determines whether fn is inlineable.
@@ -111,17 +112,17 @@ func typecheckinl(fn *Node) {
 // fn and ->nbody will already have been typechecked.
 func caninl(fn *Node) {
 	if fn.Op != ODCLFUNC {
-		Fatalf("caninl %v", fn)
+		base.Fatalf("caninl %v", fn)
 	}
 	if fn.Func.Nname == nil {
-		Fatalf("caninl no nname %+v", fn)
+		base.Fatalf("caninl no nname %+v", fn)
 	}
 
 	var reason string // reason, if any, that the function was not inlined
-	if Flag.LowerM > 1 || logopt.Enabled() {
+	if base.Flag.LowerM > 1 || logopt.Enabled() {
 		defer func() {
 			if reason != "" {
-				if Flag.LowerM > 1 {
+				if base.Flag.LowerM > 1 {
 					fmt.Printf("%v: cannot inline %v: %s\n", fn.Line(), fn.Func.Nname, reason)
 				}
 				if logopt.Enabled() {
@@ -138,13 +139,13 @@ func caninl(fn *Node) {
 	}
 
 	// If marked "go:norace" and -race compilation, don't inline.
-	if Flag.Race && fn.Func.Pragma&Norace != 0 {
+	if base.Flag.Race && fn.Func.Pragma&Norace != 0 {
 		reason = "marked go:norace with -race compilation"
 		return
 	}
 
 	// If marked "go:nocheckptr" and -d checkptr compilation, don't inline.
-	if Debug.Checkptr != 0 && fn.Func.Pragma&NoCheckPtr != 0 {
+	if base.Debug.Checkptr != 0 && fn.Func.Pragma&NoCheckPtr != 0 {
 		reason = "marked go:nocheckptr"
 		return
 	}
@@ -179,7 +180,7 @@ func caninl(fn *Node) {
 	}
 
 	if fn.Typecheck() == 0 {
-		Fatalf("caninl on non-typechecked function %v", fn)
+		base.Fatalf("caninl on non-typechecked function %v", fn)
 	}
 
 	n := fn.Func.Nname
@@ -189,7 +190,7 @@ func caninl(fn *Node) {
 	defer n.Func.SetInlinabilityChecked(true)
 
 	cc := int32(inlineExtraCallCost)
-	if Flag.LowerL == 4 {
+	if base.Flag.LowerL == 4 {
 		cc = 1 // this appears to yield better performance than 0.
 	}
 
@@ -222,9 +223,9 @@ func caninl(fn *Node) {
 		Body: inlcopylist(fn.Nbody.Slice()),
 	}
 
-	if Flag.LowerM > 1 {
+	if base.Flag.LowerM > 1 {
 		fmt.Printf("%v: can inline %#v with cost %d as: %#v { %#v }\n", fn.Line(), n, inlineMaxBudget-visitor.budget, fn.Type, asNodes(n.Func.Inl.Body))
-	} else if Flag.LowerM != 0 {
+	} else if base.Flag.LowerM != 0 {
 		fmt.Printf("%v: can inline %v\n", fn.Line(), n)
 	}
 	if logopt.Enabled() {
@@ -239,10 +240,10 @@ func inlFlood(n *Node) {
 		return
 	}
 	if n.Op != ONAME || n.Class() != PFUNC {
-		Fatalf("inlFlood: unexpected %v, %v, %v", n, n.Op, n.Class())
+		base.Fatalf("inlFlood: unexpected %v, %v, %v", n, n.Op, n.Class())
 	}
 	if n.Func == nil {
-		Fatalf("inlFlood: missing Func on %v", n)
+		base.Fatalf("inlFlood: missing Func on %v", n)
 	}
 	if n.Func.Inl == nil {
 		return
@@ -286,7 +287,7 @@ func inlFlood(n *Node) {
 			//
 			// When we do, we'll probably want:
 			//     inlFlood(n.Func.Closure.Func.Nname)
-			Fatalf("unexpected closure in inlinable function")
+			base.Fatalf("unexpected closure in inlinable function")
 		}
 		return true
 	})
@@ -352,7 +353,7 @@ func (v *hairyVisitor) visit(n *Node) bool {
 	case OCALLMETH:
 		t := n.Left.Type
 		if t == nil {
-			Fatalf("no function type for [%p] %+v\n", n.Left, n.Left)
+			base.Fatalf("no function type for [%p] %+v\n", n.Left, n.Left)
 		}
 		if isRuntimePkg(n.Left.Sym.Pkg) {
 			fn := n.Left.Sym.Name
@@ -413,7 +414,7 @@ func (v *hairyVisitor) visit(n *Node) bool {
 	case OBREAK, OCONTINUE:
 		if n.Sym != nil {
 			// Should have short-circuited due to labeledControl above.
-			Fatalf("unexpected labeled break/continue: %v", n)
+			base.Fatalf("unexpected labeled break/continue: %v", n)
 		}
 
 	case OIF:
@@ -433,7 +434,7 @@ func (v *hairyVisitor) visit(n *Node) bool {
 	v.budget--
 
 	// When debugging, don't stop early, to get full cost of inlining this function
-	if v.budget < 0 && Flag.LowerM < 2 && !logopt.Enabled() {
+	if v.budget < 0 && base.Flag.LowerM < 2 && !logopt.Enabled() {
 		return true
 	}
 
@@ -465,7 +466,7 @@ func inlcopy(n *Node) *Node {
 
 	m := n.copy()
 	if n.Op != OCALLPART && m.Func != nil {
-		Fatalf("unexpected Func: %v", m)
+		base.Fatalf("unexpected Func: %v", m)
 	}
 	m.Left = inlcopy(n.Left)
 	m.Right = inlcopy(n.Right)
@@ -517,7 +518,7 @@ func inlcalls(fn *Node) {
 	inlMap := make(map[*Node]bool)
 	fn = inlnode(fn, maxCost, inlMap)
 	if fn != Curfn {
-		Fatalf("inlnode replaced curfn")
+		base.Fatalf("inlnode replaced curfn")
 	}
 	Curfn = savefn
 }
@@ -548,7 +549,7 @@ func inlconv2expr(n *Node) *Node {
 // statements.
 func inlconv2list(n *Node) []*Node {
 	if n.Op != OINLCALL || n.Rlist.Len() == 0 {
-		Fatalf("inlconv2list %+v\n", n)
+		base.Fatalf("inlconv2list %+v\n", n)
 	}
 
 	s := n.Rlist.Slice()
@@ -595,7 +596,7 @@ func inlnode(n *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	case OCALLMETH:
 		// Prevent inlining some reflect.Value methods when using checkptr,
 		// even when package reflect was compiled without it (#35073).
-		if s := n.Left.Sym; Debug.Checkptr != 0 && isReflectPkg(s.Pkg) && (s.Name == "Value.UnsafeAddr" || s.Name == "Value.Pointer") {
+		if s := n.Left.Sym; base.Debug.Checkptr != 0 && isReflectPkg(s.Pkg) && (s.Name == "Value.UnsafeAddr" || s.Name == "Value.Pointer") {
 			return n
 		}
 	}
@@ -676,7 +677,7 @@ func inlnode(n *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 
 	switch n.Op {
 	case OCALLFUNC:
-		if Flag.LowerM > 3 {
+		if base.Flag.LowerM > 3 {
 			fmt.Printf("%v:call to func %+v\n", n.Line(), n.Left)
 		}
 		if isIntrinsicCall(n) {
@@ -687,19 +688,19 @@ func inlnode(n *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 		}
 
 	case OCALLMETH:
-		if Flag.LowerM > 3 {
+		if base.Flag.LowerM > 3 {
 			fmt.Printf("%v:call to meth %L\n", n.Line(), n.Left.Right)
 		}
 
 		// typecheck should have resolved ODOTMETH->type, whose nname points to the actual function.
 		if n.Left.Type == nil {
-			Fatalf("no function type for [%p] %+v\n", n.Left, n.Left)
+			base.Fatalf("no function type for [%p] %+v\n", n.Left, n.Left)
 		}
 
 		n = mkinlcall(n, n.Left.MethodName(), maxCost, inlMap)
 	}
 
-	lineno = lno
+	base.Pos = lno
 	return n
 }
 
@@ -767,12 +768,12 @@ FindRHS:
 				break FindRHS
 			}
 		}
-		Fatalf("%v missing from LHS of %v", n, defn)
+		base.Fatalf("%v missing from LHS of %v", n, defn)
 	default:
 		return nil
 	}
 	if rhs == nil {
-		Fatalf("RHS is nil: %v", defn)
+		base.Fatalf("RHS is nil: %v", defn)
 	}
 
 	unsafe, _ := reassigned(n)
@@ -791,7 +792,7 @@ FindRHS:
 // TODO: handle initial declaration not including an assignment and followed by a single assignment?
 func reassigned(n *Node) (bool, *Node) {
 	if n.Op != ONAME {
-		Fatalf("reassigned %v", n)
+		base.Fatalf("reassigned %v", n)
 	}
 	// no way to reliably check for no-reassignment of globals, assume it can be
 	if n.Name.Curfn == nil {
@@ -869,7 +870,7 @@ func inlParam(t *types.Field, as *Node, inlvars map[*Node]*Node) *Node {
 
 	inlvar := inlvars[n]
 	if inlvar == nil {
-		Fatalf("missing inlvar for %v", n)
+		base.Fatalf("missing inlvar for %v", n)
 	}
 	as.Ninit.Append(nod(ODCL, inlvar, nil))
 	inlvar.Name.Defn = as
@@ -922,7 +923,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	}
 
 	if inlMap[fn] {
-		if Flag.LowerM > 1 {
+		if base.Flag.LowerM > 1 {
 			fmt.Printf("%v: cannot inline %v into %v: repeated recursive cycle\n", n.Line(), fn, Curfn.funcname())
 		}
 		return n
@@ -931,17 +932,17 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	defer func() {
 		inlMap[fn] = false
 	}()
-	if Debug.TypecheckInl == 0 {
+	if base.Debug.TypecheckInl == 0 {
 		typecheckinl(fn)
 	}
 
 	// We have a function node, and it has an inlineable body.
-	if Flag.LowerM > 1 {
+	if base.Flag.LowerM > 1 {
 		fmt.Printf("%v: inlining call to %v %#v { %#v }\n", n.Line(), fn.Sym, fn.Type, asNodes(fn.Func.Inl.Body))
-	} else if Flag.LowerM != 0 {
+	} else if base.Flag.LowerM != 0 {
 		fmt.Printf("%v: inlining call to %v\n", n.Line(), fn)
 	}
-	if Flag.LowerM > 2 {
+	if base.Flag.LowerM > 2 {
 		fmt.Printf("%v: Before inlining: %+v\n", n.Line(), n)
 	}
 
@@ -962,7 +963,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 			callee = callee.Left
 		}
 		if callee.Op != ONAME && callee.Op != OCLOSURE && callee.Op != OMETHEXPR {
-			Fatalf("unexpected callee expression: %v", callee)
+			base.Fatalf("unexpected callee expression: %v", callee)
 		}
 	}
 
@@ -986,7 +987,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 				// the reassigned check via some sort of copy propagation this would most
 				// likely need to be changed to a loop to walk up to the correct Param
 				if o == nil || (o.Name.Curfn != Curfn && o.Name.Curfn.Func.OClosure != Curfn) {
-					Fatalf("%v: unresolvable capture %v %v\n", n.Line(), fn, v)
+					base.Fatalf("%v: unresolvable capture %v %v\n", n.Line(), fn, v)
 				}
 
 				if v.Name.Byval() {
@@ -1022,11 +1023,11 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 			// this never actually happens. We currently
 			// perform inlining before escape analysis, so
 			// nothing should have moved to the heap yet.
-			Fatalf("impossible: %v", ln)
+			base.Fatalf("impossible: %v", ln)
 		}
 		inlf := typecheck(inlvar(ln), ctxExpr)
 		inlvars[ln] = inlf
-		if Flag.GenDwarfInl > 0 {
+		if base.Flag.GenDwarfInl > 0 {
 			if ln.Class() == PPARAM {
 				inlf.Name.SetInlFormal(true)
 			} else {
@@ -1064,7 +1065,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 			m = retvar(t, i)
 		}
 
-		if Flag.GenDwarfInl > 0 {
+		if base.Flag.GenDwarfInl > 0 {
 			// Don't update the src.Pos on a return variable if it
 			// was manufactured by the inliner (e.g. "~R2"); such vars
 			// were not part of the original callee.
@@ -1083,7 +1084,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	as.SetColas(true)
 	if n.Op == OCALLMETH {
 		if n.Left.Left == nil {
-			Fatalf("method call without receiver: %+v", n)
+			base.Fatalf("method call without receiver: %+v", n)
 		}
 		as.Rlist.Append(n.Left.Left)
 	}
@@ -1150,10 +1151,10 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	inlgen++
 
 	parent := -1
-	if b := Ctxt.PosTable.Pos(n.Pos).Base(); b != nil {
+	if b := base.Ctxt.PosTable.Pos(n.Pos).Base(); b != nil {
 		parent = b.InliningIndex()
 	}
-	newIndex := Ctxt.InlTree.Add(parent, n.Pos, fn.Sym.Linksym())
+	newIndex := base.Ctxt.InlTree.Add(parent, n.Pos, fn.Sym.Linksym())
 
 	// Add an inline mark just before the inlined body.
 	// This mark is inline in the code so that it's a reasonable spot
@@ -1165,9 +1166,9 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	inlMark.Xoffset = int64(newIndex)
 	ninit.Append(inlMark)
 
-	if Flag.GenDwarfInl > 0 {
+	if base.Flag.GenDwarfInl > 0 {
 		if !fn.Sym.Linksym().WasInlined() {
-			Ctxt.DwFixups.SetPrecursorFunc(fn.Sym.Linksym(), fn)
+			base.Ctxt.DwFixups.SetPrecursorFunc(fn.Sym.Linksym(), fn)
 			fn.Sym.Linksym().Set(obj.AttrWasInlined, true)
 		}
 	}
@@ -1188,7 +1189,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 
 	typecheckslice(body, ctxStmt)
 
-	if Flag.GenDwarfInl > 0 {
+	if base.Flag.GenDwarfInl > 0 {
 		for _, v := range inlfvars {
 			v.Pos = subst.updatedPos(v.Pos)
 		}
@@ -1216,7 +1217,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 		}
 	}
 
-	if Flag.LowerM > 2 {
+	if base.Flag.LowerM > 2 {
 		fmt.Printf("%v: After inlining %+v\n\n", call.Line(), call)
 	}
 
@@ -1227,7 +1228,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 // PAUTO's in the calling functions, and link them off of the
 // PPARAM's, PAUTOS and PPARAMOUTs of the called function.
 func inlvar(var_ *Node) *Node {
-	if Flag.LowerM > 3 {
+	if base.Flag.LowerM > 3 {
 		fmt.Printf("inlvar %+v\n", var_)
 	}
 
@@ -1310,13 +1311,13 @@ func (subst *inlsubst) node(n *Node) *Node {
 	switch n.Op {
 	case ONAME:
 		if inlvar := subst.inlvars[n]; inlvar != nil { // These will be set during inlnode
-			if Flag.LowerM > 2 {
+			if base.Flag.LowerM > 2 {
 				fmt.Printf("substituting name %+v  ->  %+v\n", n, inlvar)
 			}
 			return inlvar
 		}
 
-		if Flag.LowerM > 2 {
+		if base.Flag.LowerM > 2 {
 			fmt.Printf("not substituting name %+v\n", n)
 		}
 		return n
@@ -1382,7 +1383,7 @@ func (subst *inlsubst) node(n *Node) *Node {
 	m.Ninit.Set(nil)
 
 	if n.Op == OCLOSURE {
-		Fatalf("cannot inline function containing closure: %+v", n)
+		base.Fatalf("cannot inline function containing closure: %+v", n)
 	}
 
 	m.Left = subst.node(n.Left)
@@ -1396,7 +1397,7 @@ func (subst *inlsubst) node(n *Node) *Node {
 }
 
 func (subst *inlsubst) updatedPos(xpos src.XPos) src.XPos {
-	pos := Ctxt.PosTable.Pos(xpos)
+	pos := base.Ctxt.PosTable.Pos(xpos)
 	oldbase := pos.Base() // can be nil
 	newbase := subst.bases[oldbase]
 	if newbase == nil {
@@ -1404,7 +1405,7 @@ func (subst *inlsubst) updatedPos(xpos src.XPos) src.XPos {
 		subst.bases[oldbase] = newbase
 	}
 	pos.SetBase(newbase)
-	return Ctxt.PosTable.XPos(pos)
+	return base.Ctxt.PosTable.XPos(pos)
 }
 
 func pruneUnusedAutos(ll []*Node, vis *hairyVisitor) []*Node {
@@ -1449,22 +1450,22 @@ func devirtualizeCall(call *Node) {
 	x = typecheck(x, ctxExpr|ctxCallee)
 	switch x.Op {
 	case ODOTMETH:
-		if Flag.LowerM != 0 {
-			Warnl(call.Pos, "devirtualizing %v to %v", call.Left, typ)
+		if base.Flag.LowerM != 0 {
+			base.WarnfAt(call.Pos, "devirtualizing %v to %v", call.Left, typ)
 		}
 		call.Op = OCALLMETH
 		call.Left = x
 	case ODOTINTER:
 		// Promoted method from embedded interface-typed field (#42279).
-		if Flag.LowerM != 0 {
-			Warnl(call.Pos, "partially devirtualizing %v to %v", call.Left, typ)
+		if base.Flag.LowerM != 0 {
+			base.WarnfAt(call.Pos, "partially devirtualizing %v to %v", call.Left, typ)
 		}
 		call.Op = OCALLINTER
 		call.Left = x
 	default:
 		// TODO(mdempsky): Turn back into Fatalf after more testing.
-		if Flag.LowerM != 0 {
-			Warnl(call.Pos, "failed to devirtualize %v (%v)", x, x.Op)
+		if base.Flag.LowerM != 0 {
+			base.WarnfAt(call.Pos, "failed to devirtualize %v (%v)", x, x.Op)
 		}
 		return
 	}
diff --git a/src/cmd/compile/internal/gc/lex.go b/src/cmd/compile/internal/gc/lex.go
index f01891f365..30ef4d0eb2 100644
--- a/src/cmd/compile/internal/gc/lex.go
+++ b/src/cmd/compile/internal/gc/lex.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/syntax"
 	"cmd/internal/objabi"
 	"cmd/internal/src"
@@ -13,7 +14,7 @@ import (
 )
 
 func makePos(b *src.PosBase, line, col uint) src.XPos {
-	return Ctxt.PosTable.XPos(src.MakePos(b, line, col))
+	return base.Ctxt.PosTable.XPos(src.MakePos(b, line, col))
 }
 
 func isSpace(c rune) bool {
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 2794ba3694..c66139027a 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -9,6 +9,7 @@ package gc
 import (
 	"bufio"
 	"bytes"
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
@@ -35,13 +36,13 @@ import (
 )
 
 func hidePanic() {
-	if Debug.Panic == 0 && Errors() > 0 {
+	if base.Debug.Panic == 0 && base.Errors() > 0 {
 		// If we've already complained about things
 		// in the program, don't bother complaining
 		// about a panic too; let the user clean up
 		// the code and try again.
 		if err := recover(); err != nil {
-			errorexit()
+			base.ErrorExit()
 		}
 	}
 }
@@ -61,16 +62,16 @@ func Main(archInit func(*Arch)) {
 
 	archInit(&thearch)
 
-	Ctxt = obj.Linknew(thearch.LinkArch)
-	Ctxt.DiagFunc = yyerror
-	Ctxt.DiagFlush = flusherrors
-	Ctxt.Bso = bufio.NewWriter(os.Stdout)
+	base.Ctxt = obj.Linknew(thearch.LinkArch)
+	base.Ctxt.DiagFunc = base.Errorf
+	base.Ctxt.DiagFlush = base.FlushErrors
+	base.Ctxt.Bso = bufio.NewWriter(os.Stdout)
 
 	// UseBASEntries is preferred because it shaves about 2% off build time, but LLDB, dsymutil, and dwarfdump
 	// on Darwin don't support it properly, especially since macOS 10.14 (Mojave).  This is exposed as a flag
 	// to allow testing with LLVM tools on Linux, and to help with reporting this bug to the LLVM project.
 	// See bugs 31188 and 21945 (CLs 170638, 98075, 72371).
-	Ctxt.UseBASEntries = Ctxt.Headtype != objabi.Hdarwin
+	base.Ctxt.UseBASEntries = base.Ctxt.Headtype != objabi.Hdarwin
 
 	localpkg = types.NewPkg("", "")
 	localpkg.Prefix = "\"\""
@@ -112,15 +113,15 @@ func Main(archInit func(*Arch)) {
 	// pseudo-package used for methods with anonymous receivers
 	gopkg = types.NewPkg("go", "")
 
-	DebugSSA = ssa.PhaseOption
-	ParseFlags()
+	base.DebugSSA = ssa.PhaseOption
+	base.ParseFlags()
 
 	// Record flags that affect the build result. (And don't
 	// record flags that don't, since that would cause spurious
 	// changes in the binary.)
 	recordFlags("B", "N", "l", "msan", "race", "shared", "dynlink", "dwarflocationlists", "dwarfbasentries", "smallframes", "spectre")
 
-	if !enableTrace && Flag.LowerT {
+	if !enableTrace && base.Flag.LowerT {
 		log.Fatalf("compiler not built with support for -t")
 	}
 
@@ -128,59 +129,59 @@ func Main(archInit func(*Arch)) {
 	//	default: inlining on.  (Flag.LowerL == 1)
 	//	-l: inlining off  (Flag.LowerL == 0)
 	//	-l=2, -l=3: inlining on again, with extra debugging (Flag.LowerL > 1)
-	if Flag.LowerL <= 1 {
-		Flag.LowerL = 1 - Flag.LowerL
+	if base.Flag.LowerL <= 1 {
+		base.Flag.LowerL = 1 - base.Flag.LowerL
 	}
 
-	if Flag.SmallFrames {
+	if base.Flag.SmallFrames {
 		maxStackVarSize = 128 * 1024
 		maxImplicitStackVarSize = 16 * 1024
 	}
 
-	if Flag.Dwarf {
-		Ctxt.DebugInfo = debuginfo
-		Ctxt.GenAbstractFunc = genAbstractFunc
-		Ctxt.DwFixups = obj.NewDwarfFixupTable(Ctxt)
+	if base.Flag.Dwarf {
+		base.Ctxt.DebugInfo = debuginfo
+		base.Ctxt.GenAbstractFunc = genAbstractFunc
+		base.Ctxt.DwFixups = obj.NewDwarfFixupTable(base.Ctxt)
 	} else {
 		// turn off inline generation if no dwarf at all
-		Flag.GenDwarfInl = 0
-		Ctxt.Flag_locationlists = false
+		base.Flag.GenDwarfInl = 0
+		base.Ctxt.Flag_locationlists = false
 	}
-	if Ctxt.Flag_locationlists && len(Ctxt.Arch.DWARFRegisters) == 0 {
-		log.Fatalf("location lists requested but register mapping not available on %v", Ctxt.Arch.Name)
+	if base.Ctxt.Flag_locationlists && len(base.Ctxt.Arch.DWARFRegisters) == 0 {
+		log.Fatalf("location lists requested but register mapping not available on %v", base.Ctxt.Arch.Name)
 	}
 
 	checkLang()
 
-	if Flag.SymABIs != "" {
-		readSymABIs(Flag.SymABIs, Ctxt.Pkgpath)
+	if base.Flag.SymABIs != "" {
+		readSymABIs(base.Flag.SymABIs, base.Ctxt.Pkgpath)
 	}
 
 	if ispkgin(omit_pkgs) {
-		Flag.Race = false
-		Flag.MSan = false
+		base.Flag.Race = false
+		base.Flag.MSan = false
 	}
 
-	thearch.LinkArch.Init(Ctxt)
+	thearch.LinkArch.Init(base.Ctxt)
 	startProfile()
-	if Flag.Race {
+	if base.Flag.Race {
 		racepkg = types.NewPkg("runtime/race", "")
 	}
-	if Flag.MSan {
+	if base.Flag.MSan {
 		msanpkg = types.NewPkg("runtime/msan", "")
 	}
-	if Flag.Race || Flag.MSan {
+	if base.Flag.Race || base.Flag.MSan {
 		instrumenting = true
 	}
-	if Flag.Dwarf {
-		dwarf.EnableLogging(Debug.DwarfInl != 0)
+	if base.Flag.Dwarf {
+		dwarf.EnableLogging(base.Debug.DwarfInl != 0)
 	}
-	if Debug.SoftFloat != 0 {
+	if base.Debug.SoftFloat != 0 {
 		thearch.SoftFloat = true
 	}
 
-	if Flag.JSON != "" { // parse version,destination from json logging optimization.
-		logopt.LogJsonOption(Flag.JSON)
+	if base.Flag.JSON != "" { // parse version,destination from json logging optimization.
+		logopt.LogJsonOption(base.Flag.JSON)
 	}
 
 	ssaDump = os.Getenv("GOSSAFUNC")
@@ -197,7 +198,7 @@ func Main(archInit func(*Arch)) {
 		}
 	}
 
-	trackScopes = Flag.Dwarf
+	trackScopes = base.Flag.Dwarf
 
 	Widthptr = thearch.LinkArch.PtrSize
 	Widthreg = thearch.LinkArch.RegSize
@@ -207,7 +208,7 @@ func Main(archInit func(*Arch)) {
 	// would lead to import cycles)
 	types.Widthptr = Widthptr
 	types.Dowidth = dowidth
-	types.Fatalf = Fatalf
+	types.Fatalf = base.Fatalf
 	types.Sconv = func(s *types.Sym, flag, mode int) string {
 		return sconv(s, FmtFlag(flag), fmtMode(mode))
 	}
@@ -226,7 +227,7 @@ func Main(archInit func(*Arch)) {
 	types.FmtLeft = int(FmtLeft)
 	types.FmtUnsigned = int(FmtUnsigned)
 	types.FErr = int(FErr)
-	types.Ctxt = Ctxt
+	types.Ctxt = base.Ctxt
 
 	initUniverse()
 
@@ -288,10 +289,10 @@ func Main(archInit func(*Arch)) {
 		if n.Op == ODCLFUNC {
 			Curfn = n
 			decldepth = 1
-			errorsBefore := Errors()
+			errorsBefore := base.Errors()
 			typecheckslice(Curfn.Nbody.Slice(), ctxStmt)
 			checkreturn(Curfn)
-			if Errors() > errorsBefore {
+			if base.Errors() > errorsBefore {
 				Curfn.Nbody.Set(nil) // type errors; do not compile
 			}
 			// Now that we've checked whether n terminates,
@@ -304,7 +305,7 @@ func Main(archInit func(*Arch)) {
 	// check past phase 9 isn't sufficient, as we may exit with other errors
 	// before then, thus skipping map key errors.
 	checkMapKeys()
-	ExitIfErrors()
+	base.ExitIfErrors()
 
 	timings.AddEvent(fcount, "funcs")
 
@@ -322,11 +323,11 @@ func Main(archInit func(*Arch)) {
 	}
 	capturevarscomplete = true
 	Curfn = nil
-	ExitIfErrors()
+	base.ExitIfErrors()
 
 	// Phase 5: Inlining
 	timings.Start("fe", "inlining")
-	if Debug.TypecheckInl != 0 {
+	if base.Debug.TypecheckInl != 0 {
 		// Typecheck imported function bodies if Debug.l > 1,
 		// otherwise lazily when used or re-exported.
 		for _, n := range importlist {
@@ -334,10 +335,10 @@ func Main(archInit func(*Arch)) {
 				typecheckinl(n)
 			}
 		}
-		ExitIfErrors()
+		base.ExitIfErrors()
 	}
 
-	if Flag.LowerL != 0 {
+	if base.Flag.LowerL != 0 {
 		// Find functions that can be inlined and clone them before walk expands them.
 		visitBottomUp(xtop, func(list []*Node, recursive bool) {
 			numfns := numNonClosures(list)
@@ -348,7 +349,7 @@ func Main(archInit func(*Arch)) {
 					// across more than one function.
 					caninl(n)
 				} else {
-					if Flag.LowerM > 1 {
+					if base.Flag.LowerM > 1 {
 						fmt.Printf("%v: cannot inline %v: recursive\n", n.Line(), n.Func.Nname)
 					}
 				}
@@ -379,7 +380,7 @@ func Main(archInit func(*Arch)) {
 	// checking. This must happen before transformclosure.
 	// We'll do the final check after write barriers are
 	// inserted.
-	if Flag.CompilingRuntime {
+	if base.Flag.CompilingRuntime {
 		nowritebarrierrecCheck = newNowritebarrierrecChecker()
 	}
 
@@ -430,10 +431,10 @@ func Main(archInit func(*Arch)) {
 	// Finalize DWARF inline routine DIEs, then explicitly turn off
 	// DWARF inlining gen so as to avoid problems with generated
 	// method wrappers.
-	if Ctxt.DwFixups != nil {
-		Ctxt.DwFixups.Finalize(Ctxt.Pkgpath, Debug.DwarfInl != 0)
-		Ctxt.DwFixups = nil
-		Flag.GenDwarfInl = 0
+	if base.Ctxt.DwFixups != nil {
+		base.Ctxt.DwFixups.Finalize(base.Ctxt.Pkgpath, base.Debug.DwarfInl != 0)
+		base.Ctxt.DwFixups = nil
+		base.Flag.GenDwarfInl = 0
 	}
 
 	// Phase 9: Check external declarations.
@@ -446,14 +447,14 @@ func Main(archInit func(*Arch)) {
 	// Check the map keys again, since we typechecked the external
 	// declarations.
 	checkMapKeys()
-	ExitIfErrors()
+	base.ExitIfErrors()
 
 	// Write object data to disk.
 	timings.Start("be", "dumpobj")
 	dumpdata()
-	Ctxt.NumberSyms()
+	base.Ctxt.NumberSyms()
 	dumpobj()
-	if Flag.AsmHdr != "" {
+	if base.Flag.AsmHdr != "" {
 		dumpasmhdr()
 	}
 
@@ -463,27 +464,27 @@ func Main(archInit func(*Arch)) {
 	})
 	for _, large := range largeStackFrames {
 		if large.callee != 0 {
-			yyerrorl(large.pos, "stack frame too large (>1GB): %d MB locals + %d MB args + %d MB callee", large.locals>>20, large.args>>20, large.callee>>20)
+			base.ErrorfAt(large.pos, "stack frame too large (>1GB): %d MB locals + %d MB args + %d MB callee", large.locals>>20, large.args>>20, large.callee>>20)
 		} else {
-			yyerrorl(large.pos, "stack frame too large (>1GB): %d MB locals + %d MB args", large.locals>>20, large.args>>20)
+			base.ErrorfAt(large.pos, "stack frame too large (>1GB): %d MB locals + %d MB args", large.locals>>20, large.args>>20)
 		}
 	}
 
 	if len(funcStack) != 0 {
-		Fatalf("funcStack is non-empty: %v", len(funcStack))
+		base.Fatalf("funcStack is non-empty: %v", len(funcStack))
 	}
 	if len(compilequeue) != 0 {
-		Fatalf("%d uncompiled functions", len(compilequeue))
+		base.Fatalf("%d uncompiled functions", len(compilequeue))
 	}
 
-	logopt.FlushLoggedOpts(Ctxt, Ctxt.Pkgpath)
-	ExitIfErrors()
+	logopt.FlushLoggedOpts(base.Ctxt, base.Ctxt.Pkgpath)
+	base.ExitIfErrors()
 
-	flusherrors()
+	base.FlushErrors()
 	timings.Stop()
 
-	if Flag.Bench != "" {
-		if err := writebench(Flag.Bench); err != nil {
+	if base.Flag.Bench != "" {
+		if err := writebench(base.Flag.Bench); err != nil {
 			log.Fatalf("cannot write benchmark data: %v", err)
 		}
 	}
@@ -510,7 +511,7 @@ func writebench(filename string) error {
 	fmt.Fprintln(&buf, "commit:", objabi.Version)
 	fmt.Fprintln(&buf, "goos:", runtime.GOOS)
 	fmt.Fprintln(&buf, "goarch:", runtime.GOARCH)
-	timings.Write(&buf, "BenchmarkCompile:"+Ctxt.Pkgpath+":")
+	timings.Write(&buf, "BenchmarkCompile:"+base.Ctxt.Pkgpath+":")
 
 	n, err := f.Write(buf.Bytes())
 	if err != nil {
@@ -622,12 +623,12 @@ func islocalname(name string) bool {
 
 func findpkg(name string) (file string, ok bool) {
 	if islocalname(name) {
-		if Flag.NoLocalImports {
+		if base.Flag.NoLocalImports {
 			return "", false
 		}
 
-		if Flag.Cfg.PackageFile != nil {
-			file, ok = Flag.Cfg.PackageFile[name]
+		if base.Flag.Cfg.PackageFile != nil {
+			file, ok = base.Flag.Cfg.PackageFile[name]
 			return file, ok
 		}
 
@@ -649,16 +650,16 @@ func findpkg(name string) (file string, ok bool) {
 	// don't want to see "encoding/../encoding/base64"
 	// as different from "encoding/base64".
 	if q := path.Clean(name); q != name {
-		yyerror("non-canonical import path %q (should be %q)", name, q)
+		base.Errorf("non-canonical import path %q (should be %q)", name, q)
 		return "", false
 	}
 
-	if Flag.Cfg.PackageFile != nil {
-		file, ok = Flag.Cfg.PackageFile[name]
+	if base.Flag.Cfg.PackageFile != nil {
+		file, ok = base.Flag.Cfg.PackageFile[name]
 		return file, ok
 	}
 
-	for _, dir := range Flag.Cfg.ImportDirs {
+	for _, dir := range base.Flag.Cfg.ImportDirs {
 		file = fmt.Sprintf("%s/%s.a", dir, name)
 		if _, err := os.Stat(file); err == nil {
 			return file, true
@@ -672,13 +673,13 @@ func findpkg(name string) (file string, ok bool) {
 	if objabi.GOROOT != "" {
 		suffix := ""
 		suffixsep := ""
-		if Flag.InstallSuffix != "" {
+		if base.Flag.InstallSuffix != "" {
 			suffixsep = "_"
-			suffix = Flag.InstallSuffix
-		} else if Flag.Race {
+			suffix = base.Flag.InstallSuffix
+		} else if base.Flag.Race {
 			suffixsep = "_"
 			suffix = "race"
-		} else if Flag.MSan {
+		} else if base.Flag.MSan {
 			suffixsep = "_"
 			suffix = "msan"
 		}
@@ -715,7 +716,7 @@ func loadsys() {
 		case varTag:
 			importvar(Runtimepkg, src.NoXPos, sym, typ)
 		default:
-			Fatalf("unhandled declaration tag %v", d.tag)
+			base.Fatalf("unhandled declaration tag %v", d.tag)
 		}
 	}
 
@@ -729,13 +730,13 @@ var myheight int
 
 func importfile(f constant.Value) *types.Pkg {
 	if f.Kind() != constant.String {
-		yyerror("import path must be a string")
+		base.Errorf("import path must be a string")
 		return nil
 	}
 
 	path_ := constant.StringVal(f)
 	if len(path_) == 0 {
-		yyerror("import path is empty")
+		base.Errorf("import path is empty")
 		return nil
 	}
 
@@ -748,16 +749,16 @@ func importfile(f constant.Value) *types.Pkg {
 	// the main package, just as we reserve the import
 	// path "math" to identify the standard math package.
 	if path_ == "main" {
-		yyerror("cannot import \"main\"")
-		errorexit()
+		base.Errorf("cannot import \"main\"")
+		base.ErrorExit()
 	}
 
-	if Ctxt.Pkgpath != "" && path_ == Ctxt.Pkgpath {
-		yyerror("import %q while compiling that package (import cycle)", path_)
-		errorexit()
+	if base.Ctxt.Pkgpath != "" && path_ == base.Ctxt.Pkgpath {
+		base.Errorf("import %q while compiling that package (import cycle)", path_)
+		base.ErrorExit()
 	}
 
-	if mapped, ok := Flag.Cfg.ImportMap[path_]; ok {
+	if mapped, ok := base.Flag.Cfg.ImportMap[path_]; ok {
 		path_ = mapped
 	}
 
@@ -767,13 +768,13 @@ func importfile(f constant.Value) *types.Pkg {
 
 	if islocalname(path_) {
 		if path_[0] == '/' {
-			yyerror("import path cannot be absolute path")
+			base.Errorf("import path cannot be absolute path")
 			return nil
 		}
 
-		prefix := Ctxt.Pathname
-		if Flag.D != "" {
-			prefix = Flag.D
+		prefix := base.Ctxt.Pathname
+		if base.Flag.D != "" {
+			prefix = base.Flag.D
 		}
 		path_ = path.Join(prefix, path_)
 
@@ -784,8 +785,8 @@ func importfile(f constant.Value) *types.Pkg {
 
 	file, found := findpkg(path_)
 	if !found {
-		yyerror("can't find import: %q", path_)
-		errorexit()
+		base.Errorf("can't find import: %q", path_)
+		base.ErrorExit()
 	}
 
 	importpkg := types.NewPkg(path_, "")
@@ -797,48 +798,48 @@ func importfile(f constant.Value) *types.Pkg {
 
 	imp, err := bio.Open(file)
 	if err != nil {
-		yyerror("can't open import: %q: %v", path_, err)
-		errorexit()
+		base.Errorf("can't open import: %q: %v", path_, err)
+		base.ErrorExit()
 	}
 	defer imp.Close()
 
 	// check object header
 	p, err := imp.ReadString('\n')
 	if err != nil {
-		yyerror("import %s: reading input: %v", file, err)
-		errorexit()
+		base.Errorf("import %s: reading input: %v", file, err)
+		base.ErrorExit()
 	}
 
 	if p == "!<arch>\n" { // package archive
 		// package export block should be first
 		sz := arsize(imp.Reader, "__.PKGDEF")
 		if sz <= 0 {
-			yyerror("import %s: not a package file", file)
-			errorexit()
+			base.Errorf("import %s: not a package file", file)
+			base.ErrorExit()
 		}
 		p, err = imp.ReadString('\n')
 		if err != nil {
-			yyerror("import %s: reading input: %v", file, err)
-			errorexit()
+			base.Errorf("import %s: reading input: %v", file, err)
+			base.ErrorExit()
 		}
 	}
 
 	if !strings.HasPrefix(p, "go object ") {
-		yyerror("import %s: not a go object file: %s", file, p)
-		errorexit()
+		base.Errorf("import %s: not a go object file: %s", file, p)
+		base.ErrorExit()
 	}
 	q := fmt.Sprintf("%s %s %s %s\n", objabi.GOOS, objabi.GOARCH, objabi.Version, objabi.Expstring())
 	if p[10:] != q {
-		yyerror("import %s: object is [%s] expected [%s]", file, p[10:], q)
-		errorexit()
+		base.Errorf("import %s: object is [%s] expected [%s]", file, p[10:], q)
+		base.ErrorExit()
 	}
 
 	// process header lines
 	for {
 		p, err = imp.ReadString('\n')
 		if err != nil {
-			yyerror("import %s: reading input: %v", file, err)
-			errorexit()
+			base.Errorf("import %s: reading input: %v", file, err)
+			base.ErrorExit()
 		}
 		if p == "\n" {
 			break // header ends with blank line
@@ -870,41 +871,41 @@ func importfile(f constant.Value) *types.Pkg {
 	var fingerprint goobj.FingerprintType
 	switch c {
 	case '\n':
-		yyerror("cannot import %s: old export format no longer supported (recompile library)", path_)
+		base.Errorf("cannot import %s: old export format no longer supported (recompile library)", path_)
 		return nil
 
 	case 'B':
-		if Debug.Export != 0 {
+		if base.Debug.Export != 0 {
 			fmt.Printf("importing %s (%s)\n", path_, file)
 		}
 		imp.ReadByte() // skip \n after $$B
 
 		c, err = imp.ReadByte()
 		if err != nil {
-			yyerror("import %s: reading input: %v", file, err)
-			errorexit()
+			base.Errorf("import %s: reading input: %v", file, err)
+			base.ErrorExit()
 		}
 
 		// Indexed format is distinguished by an 'i' byte,
 		// whereas previous export formats started with 'c', 'd', or 'v'.
 		if c != 'i' {
-			yyerror("import %s: unexpected package format byte: %v", file, c)
-			errorexit()
+			base.Errorf("import %s: unexpected package format byte: %v", file, c)
+			base.ErrorExit()
 		}
 		fingerprint = iimport(importpkg, imp)
 
 	default:
-		yyerror("no import in %q", path_)
-		errorexit()
+		base.Errorf("no import in %q", path_)
+		base.ErrorExit()
 	}
 
 	// assume files move (get installed) so don't record the full path
-	if Flag.Cfg.PackageFile != nil {
+	if base.Flag.Cfg.PackageFile != nil {
 		// If using a packageFile map, assume path_ can be recorded directly.
-		Ctxt.AddImport(path_, fingerprint)
+		base.Ctxt.AddImport(path_, fingerprint)
 	} else {
 		// For file "/Users/foo/go/pkg/darwin_amd64/math.a" record "math.a".
-		Ctxt.AddImport(file[len(file)-len(path_)-len(".a"):], fingerprint)
+		base.Ctxt.AddImport(file[len(file)-len(path_)-len(".a"):], fingerprint)
 	}
 
 	if importpkg.Height >= myheight {
@@ -926,21 +927,21 @@ func pkgnotused(lineno src.XPos, path string, name string) {
 		elem = elem[i+1:]
 	}
 	if name == "" || elem == name {
-		yyerrorl(lineno, "imported and not used: %q", path)
+		base.ErrorfAt(lineno, "imported and not used: %q", path)
 	} else {
-		yyerrorl(lineno, "imported and not used: %q as %s", path, name)
+		base.ErrorfAt(lineno, "imported and not used: %q as %s", path, name)
 	}
 }
 
 func mkpackage(pkgname string) {
 	if localpkg.Name == "" {
 		if pkgname == "_" {
-			yyerror("invalid package name _")
+			base.Errorf("invalid package name _")
 		}
 		localpkg.Name = pkgname
 	} else {
 		if pkgname != localpkg.Name {
-			yyerror("package %s; expected %s", pkgname, localpkg.Name)
+			base.Errorf("package %s; expected %s", pkgname, localpkg.Name)
 		}
 	}
 }
@@ -964,7 +965,7 @@ func clearImports() {
 			// leave s->block set to cause redeclaration
 			// errors if a conflicting top-level name is
 			// introduced by a different file.
-			if !n.Name.Used() && SyntaxErrors() == 0 {
+			if !n.Name.Used() && base.SyntaxErrors() == 0 {
 				unused = append(unused, importedPkg{n.Pos, n.Name.Pkg.Path, s.Name})
 			}
 			s.Def = nil
@@ -973,7 +974,7 @@ func clearImports() {
 		if IsAlias(s) {
 			// throw away top-level name left over
 			// from previous import . "x"
-			if n.Name != nil && n.Name.Pack != nil && !n.Name.Pack.Name.Used() && SyntaxErrors() == 0 {
+			if n.Name != nil && n.Name.Pack != nil && !n.Name.Pack.Name.Used() && base.SyntaxErrors() == 0 {
 				unused = append(unused, importedPkg{n.Name.Pack.Pos, n.Name.Pack.Name.Pkg.Path, ""})
 				n.Name.Pack.Name.SetUsed(true)
 			}
@@ -995,7 +996,7 @@ func IsAlias(sym *types.Sym) bool {
 // recordFlags records the specified command-line flags to be placed
 // in the DWARF info.
 func recordFlags(flags ...string) {
-	if Ctxt.Pkgpath == "" {
+	if base.Ctxt.Pkgpath == "" {
 		// We can't record the flags if we don't know what the
 		// package name is.
 		return
@@ -1038,24 +1039,24 @@ func recordFlags(flags ...string) {
 	if cmd.Len() == 0 {
 		return
 	}
-	s := Ctxt.Lookup(dwarf.CUInfoPrefix + "producer." + Ctxt.Pkgpath)
+	s := base.Ctxt.Lookup(dwarf.CUInfoPrefix + "producer." + base.Ctxt.Pkgpath)
 	s.Type = objabi.SDWARFCUINFO
 	// Sometimes (for example when building tests) we can link
 	// together two package main archives. So allow dups.
 	s.Set(obj.AttrDuplicateOK, true)
-	Ctxt.Data = append(Ctxt.Data, s)
+	base.Ctxt.Data = append(base.Ctxt.Data, s)
 	s.P = cmd.Bytes()[1:]
 }
 
 // recordPackageName records the name of the package being
 // compiled, so that the linker can save it in the compile unit's DIE.
 func recordPackageName() {
-	s := Ctxt.Lookup(dwarf.CUInfoPrefix + "packagename." + Ctxt.Pkgpath)
+	s := base.Ctxt.Lookup(dwarf.CUInfoPrefix + "packagename." + base.Ctxt.Pkgpath)
 	s.Type = objabi.SDWARFCUINFO
 	// Sometimes (for example when building tests) we can link
 	// together two package main archives. So allow dups.
 	s.Set(obj.AttrDuplicateOK, true)
-	Ctxt.Data = append(Ctxt.Data, s)
+	base.Ctxt.Data = append(base.Ctxt.Data, s)
 	s.P = []byte(localpkg.Name)
 }
 
@@ -1099,23 +1100,23 @@ func langSupported(major, minor int, pkg *types.Pkg) bool {
 // checkLang verifies that the -lang flag holds a valid value, and
 // exits if not. It initializes data used by langSupported.
 func checkLang() {
-	if Flag.Lang == "" {
+	if base.Flag.Lang == "" {
 		return
 	}
 
 	var err error
-	langWant, err = parseLang(Flag.Lang)
+	langWant, err = parseLang(base.Flag.Lang)
 	if err != nil {
-		log.Fatalf("invalid value %q for -lang: %v", Flag.Lang, err)
+		log.Fatalf("invalid value %q for -lang: %v", base.Flag.Lang, err)
 	}
 
-	if def := currentLang(); Flag.Lang != def {
+	if def := currentLang(); base.Flag.Lang != def {
 		defVers, err := parseLang(def)
 		if err != nil {
 			log.Fatalf("internal error parsing default lang %q: %v", def, err)
 		}
 		if langWant.major > defVers.major || (langWant.major == defVers.major && langWant.minor > defVers.minor) {
-			log.Fatalf("invalid value %q for -lang: max known version is %q", Flag.Lang, def)
+			log.Fatalf("invalid value %q for -lang: max known version is %q", base.Flag.Lang, def)
 		}
 	}
 }
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 2d3da884a2..6dae2cd0a4 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -16,6 +16,7 @@ import (
 	"unicode"
 	"unicode/utf8"
 
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/syntax"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -59,15 +60,15 @@ func parseFiles(filenames []string) uint {
 	var lines uint
 	for _, p := range noders {
 		for e := range p.err {
-			p.yyerrorpos(e.Pos, "%s", e.Msg)
+			p.errorAt(e.Pos, "%s", e.Msg)
 		}
 
 		p.node()
 		lines += p.file.Lines
 		p.file = nil // release memory
 
-		if SyntaxErrors() != 0 {
-			errorexit()
+		if base.SyntaxErrors() != 0 {
+			base.ErrorExit()
 		}
 		// Always run testdclstack here, even when debug_dclstack is not set, as a sanity measure.
 		testdclstack()
@@ -111,20 +112,20 @@ func (p *noder) makeSrcPosBase(b0 *syntax.PosBase) *src.PosBase {
 }
 
 func (p *noder) makeXPos(pos syntax.Pos) (_ src.XPos) {
-	return Ctxt.PosTable.XPos(src.MakePos(p.makeSrcPosBase(pos.Base()), pos.Line(), pos.Col()))
+	return base.Ctxt.PosTable.XPos(src.MakePos(p.makeSrcPosBase(pos.Base()), pos.Line(), pos.Col()))
 }
 
-func (p *noder) yyerrorpos(pos syntax.Pos, format string, args ...interface{}) {
-	yyerrorl(p.makeXPos(pos), format, args...)
+func (p *noder) errorAt(pos syntax.Pos, format string, args ...interface{}) {
+	base.ErrorfAt(p.makeXPos(pos), format, args...)
 }
 
 // TODO(gri) Can we eliminate fileh in favor of absFilename?
 func fileh(name string) string {
-	return objabi.AbsFile("", name, Flag.TrimPath)
+	return objabi.AbsFile("", name, base.Flag.TrimPath)
 }
 
 func absFilename(name string) string {
-	return objabi.AbsFile(Ctxt.Pathname, name, Flag.TrimPath)
+	return objabi.AbsFile(base.Ctxt.Pathname, name, base.Flag.TrimPath)
 }
 
 // noder transforms package syntax's AST into a Node tree.
@@ -162,8 +163,8 @@ func (p *noder) funcBody(fn *Node, block *syntax.BlockStmt) {
 		}
 		fn.Nbody.Set(body)
 
-		lineno = p.makeXPos(block.Rbrace)
-		fn.Func.Endlineno = lineno
+		base.Pos = p.makeXPos(block.Rbrace)
+		fn.Func.Endlineno = base.Pos
 	}
 
 	funcbody()
@@ -193,7 +194,7 @@ func (p *noder) closeScope(pos syntax.Pos) {
 			// no variables were declared in this scope, so we can retract it.
 
 			if int(p.scope) != len(Curfn.Func.Parents) {
-				Fatalf("scope tracking inconsistency, no variables declared but scopes were not retracted")
+				base.Fatalf("scope tracking inconsistency, no variables declared but scopes were not retracted")
 			}
 
 			p.scope = Curfn.Func.Parents[p.scope-1]
@@ -258,7 +259,7 @@ func (p *noder) node() {
 
 	for _, n := range p.linknames {
 		if !p.importedUnsafe {
-			p.yyerrorpos(n.pos, "//go:linkname only allowed in Go files that import \"unsafe\"")
+			p.errorAt(n.pos, "//go:linkname only allowed in Go files that import \"unsafe\"")
 			continue
 		}
 		s := lookup(n.local)
@@ -267,10 +268,10 @@ func (p *noder) node() {
 		} else {
 			// Use the default object symbol name if the
 			// user didn't provide one.
-			if Ctxt.Pkgpath == "" {
-				p.yyerrorpos(n.pos, "//go:linkname requires linkname argument or -p compiler flag")
+			if base.Ctxt.Pkgpath == "" {
+				p.errorAt(n.pos, "//go:linkname requires linkname argument or -p compiler flag")
 			} else {
-				s.Linkname = objabi.PathToPrefix(Ctxt.Pkgpath) + "." + n.local
+				s.Linkname = objabi.PathToPrefix(base.Ctxt.Pkgpath) + "." + n.local
 			}
 		}
 	}
@@ -288,7 +289,7 @@ func (p *noder) node() {
 	}
 
 	pragcgobuf = append(pragcgobuf, p.pragcgobuf...)
-	lineno = src.NoXPos
+	base.Pos = src.NoXPos
 	clearImports()
 }
 
@@ -332,8 +333,8 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
 
 	ipkg := importfile(p.basicLit(imp.Path))
 	if ipkg == nil {
-		if Errors() == 0 {
-			Fatalf("phase error in import")
+		if base.Errors() == 0 {
+			base.Fatalf("phase error in import")
 		}
 		return
 	}
@@ -363,7 +364,7 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
 		importdot(ipkg, pack)
 		return
 	case "init":
-		yyerrorl(pack.Pos, "cannot import package as init - init must be a func")
+		base.ErrorfAt(pack.Pos, "cannot import package as init - init must be a func")
 		return
 	case "_":
 		return
@@ -393,7 +394,7 @@ func (p *noder) varDecl(decl *syntax.VarDecl) []*Node {
 				// so at that point it hasn't seen the imports.
 				// We're left to check now, just before applying the //go:embed lines.
 				for _, e := range pragma.Embeds {
-					p.yyerrorpos(e.Pos, "//go:embed only allowed in Go files that import \"embed\"")
+					p.errorAt(e.Pos, "//go:embed only allowed in Go files that import \"embed\"")
 				}
 			} else {
 				exprs = varEmbed(p, names, typ, exprs, pragma.Embeds)
@@ -437,7 +438,7 @@ func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []*Node {
 		cs.typ, cs.values = typ, values
 	} else {
 		if typ != nil {
-			yyerror("const declaration cannot have type without expression")
+			base.Errorf("const declaration cannot have type without expression")
 		}
 		typ, values = cs.typ, cs.values
 	}
@@ -445,7 +446,7 @@ func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []*Node {
 	nn := make([]*Node, 0, len(names))
 	for i, n := range names {
 		if i >= len(values) {
-			yyerror("missing value in const declaration")
+			base.Errorf("missing value in const declaration")
 			break
 		}
 		v := values[i]
@@ -464,7 +465,7 @@ func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []*Node {
 	}
 
 	if len(values) > len(names) {
-		yyerror("extra expression in const declaration")
+		base.Errorf("extra expression in const declaration")
 	}
 
 	cs.iota++
@@ -493,7 +494,7 @@ func (p *noder) typeDecl(decl *syntax.TypeDecl) *Node {
 
 	nod := p.nod(decl, ODCLTYPE, n, nil)
 	if param.Alias() && !langSupported(1, 9, localpkg) {
-		yyerrorl(nod.Pos, "type aliases only supported as of -lang=go1.9")
+		base.ErrorfAt(nod.Pos, "type aliases only supported as of -lang=go1.9")
 	}
 	return nod
 }
@@ -521,13 +522,13 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) *Node {
 		if name.Name == "init" {
 			name = renameinit()
 			if t.List.Len() > 0 || t.Rlist.Len() > 0 {
-				yyerrorl(f.Pos, "func init must have no arguments and no return values")
+				base.ErrorfAt(f.Pos, "func init must have no arguments and no return values")
 			}
 		}
 
 		if localpkg.Name == "main" && name.Name == "main" {
 			if t.List.Len() > 0 || t.Rlist.Len() > 0 {
-				yyerrorl(f.Pos, "func main must have no arguments and no return values")
+				base.ErrorfAt(f.Pos, "func main must have no arguments and no return values")
 			}
 		}
 	} else {
@@ -542,7 +543,7 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) *Node {
 	if pragma, ok := fun.Pragma.(*Pragma); ok {
 		f.Func.Pragma = pragma.Flag & FuncPragmas
 		if pragma.Flag&Systemstack != 0 && pragma.Flag&Nosplit != 0 {
-			yyerrorl(f.Pos, "go:nosplit and go:systemstack cannot be combined")
+			base.ErrorfAt(f.Pos, "go:nosplit and go:systemstack cannot be combined")
 		}
 		pragma.Flag &^= FuncPragmas
 		p.checkUnused(pragma)
@@ -556,10 +557,10 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) *Node {
 
 	if fun.Body != nil {
 		if f.Func.Pragma&Noescape != 0 {
-			yyerrorl(f.Pos, "can only use //go:noescape with external func implementations")
+			base.ErrorfAt(f.Pos, "can only use //go:noescape with external func implementations")
 		}
 	} else {
-		if Flag.Complete || strings.HasPrefix(f.funcname(), "init.") {
+		if base.Flag.Complete || strings.HasPrefix(f.funcname(), "init.") {
 			// Linknamed functions are allowed to have no body. Hopefully
 			// the linkname target has a body. See issue 23311.
 			isLinknamed := false
@@ -570,7 +571,7 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) *Node {
 				}
 			}
 			if !isLinknamed {
-				yyerrorl(f.Pos, "missing function body")
+				base.ErrorfAt(f.Pos, "missing function body")
 			}
 		}
 	}
@@ -610,13 +611,13 @@ func (p *noder) param(param *syntax.Field, dddOk, final bool) *Node {
 	if typ.Op == ODDD {
 		if !dddOk {
 			// We mark these as syntax errors to get automatic elimination
-			// of multiple such errors per line (see yyerrorl in subr.go).
-			yyerror("syntax error: cannot use ... in receiver or result parameter list")
+			// of multiple such errors per line (see ErrorfAt in subr.go).
+			base.Errorf("syntax error: cannot use ... in receiver or result parameter list")
 		} else if !final {
 			if param.Name == nil {
-				yyerror("syntax error: cannot use ... with non-final parameter")
+				base.Errorf("syntax error: cannot use ... with non-final parameter")
 			} else {
-				p.yyerrorpos(param.Name.Pos(), "syntax error: cannot use ... with non-final parameter %s", param.Name.Value)
+				p.errorAt(param.Name.Pos(), "syntax error: cannot use ... with non-final parameter %s", param.Name.Value)
 			}
 		}
 		typ.Op = OTARRAY
@@ -670,7 +671,7 @@ func (p *noder) expr(expr syntax.Expr) *Node {
 			l[i] = p.wrapname(expr.ElemList[i], e)
 		}
 		n.List.Set(l)
-		lineno = p.makeXPos(expr.Rbrace)
+		base.Pos = p.makeXPos(expr.Rbrace)
 		return n
 	case *syntax.KeyValueExpr:
 		// use position of expr.Key rather than of expr (which has position of ':')
@@ -752,7 +753,7 @@ func (p *noder) expr(expr syntax.Expr) *Node {
 		if expr.Lhs != nil {
 			n.Left = p.declName(expr.Lhs)
 			if n.Left.isBlank() {
-				yyerror("invalid variable name %v in type switch", n.Left)
+				base.Errorf("invalid variable name %v in type switch", n.Left)
 			}
 		}
 		return n
@@ -916,12 +917,12 @@ func (p *noder) packname(expr syntax.Expr) *types.Sym {
 		name := p.name(expr.X.(*syntax.Name))
 		def := asNode(name.Def)
 		if def == nil {
-			yyerror("undefined: %v", name)
+			base.Errorf("undefined: %v", name)
 			return name
 		}
 		var pkg *types.Pkg
 		if def.Op != OPACK {
-			yyerror("%v is not a package", name)
+			base.Errorf("%v is not a package", name)
 			pkg = localpkg
 		} else {
 			def.Name.SetUsed(true)
@@ -1026,7 +1027,7 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) *Node {
 			op = OCONTINUE
 		case syntax.Fallthrough:
 			if !fallOK {
-				yyerror("fallthrough statement out of place")
+				base.Errorf("fallthrough statement out of place")
 			}
 			op = OFALL
 		case syntax.Goto:
@@ -1066,7 +1067,7 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) *Node {
 					break
 				}
 				if asNode(ln.Sym.Def) != ln {
-					yyerror("%s is shadowed during return", ln.Sym.Name)
+					base.Errorf("%s is shadowed during return", ln.Sym.Name)
 				}
 			}
 		}
@@ -1107,7 +1108,7 @@ func (p *noder) assignList(expr syntax.Expr, defn *Node, colas bool) []*Node {
 
 		name, ok := expr.(*syntax.Name)
 		if !ok {
-			p.yyerrorpos(expr.Pos(), "non-name %v on left side of :=", p.expr(expr))
+			p.errorAt(expr.Pos(), "non-name %v on left side of :=", p.expr(expr))
 			newOrErr = true
 			continue
 		}
@@ -1118,7 +1119,7 @@ func (p *noder) assignList(expr syntax.Expr, defn *Node, colas bool) []*Node {
 		}
 
 		if seen[sym] {
-			p.yyerrorpos(expr.Pos(), "%v repeated on left side of :=", sym)
+			p.errorAt(expr.Pos(), "%v repeated on left side of :=", sym)
 			newOrErr = true
 			continue
 		}
@@ -1138,7 +1139,7 @@ func (p *noder) assignList(expr syntax.Expr, defn *Node, colas bool) []*Node {
 	}
 
 	if !newOrErr {
-		yyerrorl(defn.Pos, "no new variables on left side of :=")
+		base.ErrorfAt(defn.Pos, "no new variables on left side of :=")
 	}
 	return res
 }
@@ -1256,10 +1257,10 @@ func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *Node, rbrace
 		n.Nbody.Set(p.stmtsFall(body, true))
 		if l := n.Nbody.Len(); l > 0 && n.Nbody.Index(l-1).Op == OFALL {
 			if tswitch != nil {
-				yyerror("cannot fallthrough in type switch")
+				base.Errorf("cannot fallthrough in type switch")
 			}
 			if i+1 == len(clauses) {
-				yyerror("cannot fallthrough final case in switch")
+				base.Errorf("cannot fallthrough final case in switch")
 			}
 		}
 
@@ -1378,7 +1379,7 @@ func checkLangCompat(lit *syntax.BasicLit) {
 	}
 	// len(s) > 2
 	if strings.Contains(s, "_") {
-		yyerrorv("go1.13", "underscores in numeric literals")
+		base.ErrorfVers("go1.13", "underscores in numeric literals")
 		return
 	}
 	if s[0] != '0' {
@@ -1386,15 +1387,15 @@ func checkLangCompat(lit *syntax.BasicLit) {
 	}
 	radix := s[1]
 	if radix == 'b' || radix == 'B' {
-		yyerrorv("go1.13", "binary literals")
+		base.ErrorfVers("go1.13", "binary literals")
 		return
 	}
 	if radix == 'o' || radix == 'O' {
-		yyerrorv("go1.13", "0o/0O-style octal literals")
+		base.ErrorfVers("go1.13", "0o/0O-style octal literals")
 		return
 	}
 	if lit.Kind != syntax.IntLit && (radix == 'x' || radix == 'X') {
-		yyerrorv("go1.13", "hexadecimal floating-point literals")
+		base.ErrorfVers("go1.13", "hexadecimal floating-point literals")
 	}
 }
 
@@ -1415,7 +1416,7 @@ func (p *noder) basicLit(lit *syntax.BasicLit) constant.Value {
 	v := constant.MakeFromLiteral(lit.Value, tokenForLitKind[lit.Kind], 0)
 	if v.Kind() == constant.Unknown {
 		// TODO(mdempsky): Better error message?
-		p.yyerrorpos(lit.Pos(), "malformed constant: %s", lit.Value)
+		p.errorAt(lit.Pos(), "malformed constant: %s", lit.Value)
 	}
 
 	// go/constant uses big.Rat by default, which is more precise, but
@@ -1474,7 +1475,7 @@ func (p *noder) nodSym(orig syntax.Node, op Op, left *Node, sym *types.Sym) *Nod
 
 func (p *noder) pos(n syntax.Node) src.XPos {
 	// TODO(gri): orig.Pos() should always be known - fix package syntax
-	xpos := lineno
+	xpos := base.Pos
 	if pos := n.Pos(); pos.IsKnown() {
 		xpos = p.makeXPos(pos)
 	}
@@ -1483,7 +1484,7 @@ func (p *noder) pos(n syntax.Node) src.XPos {
 
 func (p *noder) setlineno(n syntax.Node) {
 	if n != nil {
-		lineno = p.pos(n)
+		base.Pos = p.pos(n)
 	}
 }
 
@@ -1525,12 +1526,12 @@ type PragmaEmbed struct {
 func (p *noder) checkUnused(pragma *Pragma) {
 	for _, pos := range pragma.Pos {
 		if pos.Flag&pragma.Flag != 0 {
-			p.yyerrorpos(pos.Pos, "misplaced compiler directive")
+			p.errorAt(pos.Pos, "misplaced compiler directive")
 		}
 	}
 	if len(pragma.Embeds) > 0 {
 		for _, e := range pragma.Embeds {
-			p.yyerrorpos(e.Pos, "misplaced go:embed directive")
+			p.errorAt(e.Pos, "misplaced go:embed directive")
 		}
 	}
 }
@@ -1619,7 +1620,7 @@ func (p *noder) pragma(pos syntax.Pos, blankLine bool, text string, old syntax.P
 		// For security, we disallow //go:cgo_* directives other
 		// than cgo_import_dynamic outside cgo-generated files.
 		// Exception: they are allowed in the standard library, for runtime and syscall.
-		if !isCgoGeneratedFile(pos) && !Flag.Std {
+		if !isCgoGeneratedFile(pos) && !base.Flag.Std {
 			p.error(syntax.Error{Pos: pos, Msg: fmt.Sprintf("//%s only allowed in cgo-generated code", text)})
 		}
 		p.pragcgo(pos, text)
@@ -1631,10 +1632,10 @@ func (p *noder) pragma(pos syntax.Pos, blankLine bool, text string, old syntax.P
 		}
 		flag := pragmaFlag(verb)
 		const runtimePragmas = Systemstack | Nowritebarrier | Nowritebarrierrec | Yeswritebarrierrec
-		if !Flag.CompilingRuntime && flag&runtimePragmas != 0 {
+		if !base.Flag.CompilingRuntime && flag&runtimePragmas != 0 {
 			p.error(syntax.Error{Pos: pos, Msg: fmt.Sprintf("//%s only allowed in runtime", verb)})
 		}
-		if flag == 0 && !allowedStdPragmas[verb] && Flag.Std {
+		if flag == 0 && !allowedStdPragmas[verb] && base.Flag.Std {
 			p.error(syntax.Error{Pos: pos, Msg: fmt.Sprintf("//%s is not allowed in the standard library", verb)})
 		}
 		pragma.Flag |= flag
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 170d997cd6..6c659c91c7 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/bio"
 	"cmd/internal/obj"
@@ -47,20 +48,20 @@ const (
 )
 
 func dumpobj() {
-	if Flag.LinkObj == "" {
-		dumpobj1(Flag.LowerO, modeCompilerObj|modeLinkerObj)
+	if base.Flag.LinkObj == "" {
+		dumpobj1(base.Flag.LowerO, modeCompilerObj|modeLinkerObj)
 		return
 	}
-	dumpobj1(Flag.LowerO, modeCompilerObj)
-	dumpobj1(Flag.LinkObj, modeLinkerObj)
+	dumpobj1(base.Flag.LowerO, modeCompilerObj)
+	dumpobj1(base.Flag.LinkObj, modeLinkerObj)
 }
 
 func dumpobj1(outfile string, mode int) {
 	bout, err := bio.Create(outfile)
 	if err != nil {
-		flusherrors()
+		base.FlushErrors()
 		fmt.Printf("can't create %s: %v\n", outfile, err)
-		errorexit()
+		base.ErrorExit()
 	}
 	defer bout.Close()
 	bout.WriteString("!<arch>\n")
@@ -79,8 +80,8 @@ func dumpobj1(outfile string, mode int) {
 
 func printObjHeader(bout *bio.Writer) {
 	fmt.Fprintf(bout, "go object %s %s %s %s\n", objabi.GOOS, objabi.GOARCH, objabi.Version, objabi.Expstring())
-	if Flag.BuildID != "" {
-		fmt.Fprintf(bout, "build id %q\n", Flag.BuildID)
+	if base.Flag.BuildID != "" {
+		fmt.Fprintf(bout, "build id %q\n", base.Flag.BuildID)
 	}
 	if localpkg.Name == "main" {
 		fmt.Fprintf(bout, "main\n")
@@ -169,13 +170,13 @@ func dumpdata() {
 	addGCLocals()
 
 	if exportlistLen != len(exportlist) {
-		Fatalf("exportlist changed after compile functions loop")
+		base.Fatalf("exportlist changed after compile functions loop")
 	}
 	if ptabsLen != len(ptabs) {
-		Fatalf("ptabs changed after compile functions loop")
+		base.Fatalf("ptabs changed after compile functions loop")
 	}
 	if itabsLen != len(itabs) {
-		Fatalf("itabs changed after compile functions loop")
+		base.Fatalf("itabs changed after compile functions loop")
 	}
 }
 
@@ -187,18 +188,18 @@ func dumpLinkerObj(bout *bio.Writer) {
 		fmt.Fprintf(bout, "\n$$\n\n$$\n\n")
 		fmt.Fprintf(bout, "\n$$  // cgo\n")
 		if err := json.NewEncoder(bout).Encode(pragcgobuf); err != nil {
-			Fatalf("serializing pragcgobuf: %v", err)
+			base.Fatalf("serializing pragcgobuf: %v", err)
 		}
 		fmt.Fprintf(bout, "\n$$\n\n")
 	}
 
 	fmt.Fprintf(bout, "\n!\n")
 
-	obj.WriteObjFile(Ctxt, bout)
+	obj.WriteObjFile(base.Ctxt, bout)
 }
 
 func addptabs() {
-	if !Ctxt.Flag_dynlink || localpkg.Name != "main" {
+	if !base.Ctxt.Flag_dynlink || localpkg.Name != "main" {
 		return
 	}
 	for _, exportn := range exportlist {
@@ -228,7 +229,7 @@ func addptabs() {
 
 func dumpGlobal(n *Node) {
 	if n.Type == nil {
-		Fatalf("external %v nil type\n", n)
+		base.Fatalf("external %v nil type\n", n)
 	}
 	if n.Class() == PFUNC {
 		return
@@ -261,7 +262,7 @@ func dumpGlobalConst(n *Node) {
 			return
 		}
 	}
-	Ctxt.DwarfIntConst(Ctxt.Pkgpath, n.Sym.Name, typesymname(t), int64Val(t, v))
+	base.Ctxt.DwarfIntConst(base.Ctxt.Pkgpath, n.Sym.Name, typesymname(t), int64Val(t, v))
 }
 
 func dumpglobls() {
@@ -293,7 +294,7 @@ func dumpglobls() {
 // This is done during the sequential phase after compilation, since
 // global symbols can't be declared during parallel compilation.
 func addGCLocals() {
-	for _, s := range Ctxt.Text {
+	for _, s := range base.Ctxt.Text {
 		fn := s.Func()
 		if fn == nil {
 			continue
@@ -316,9 +317,9 @@ func addGCLocals() {
 
 func duintxx(s *obj.LSym, off int, v uint64, wid int) int {
 	if off&(wid-1) != 0 {
-		Fatalf("duintxxLSym: misaligned: v=%d wid=%d off=%d", v, wid, off)
+		base.Fatalf("duintxxLSym: misaligned: v=%d wid=%d off=%d", v, wid, off)
 	}
-	s.WriteInt(Ctxt, int64(off), wid, int64(v))
+	s.WriteInt(base.Ctxt, int64(off), wid, int64(v))
 	return off + wid
 }
 
@@ -369,7 +370,7 @@ func stringsym(pos src.XPos, s string) (data *obj.LSym) {
 		symname = strconv.Quote(s)
 	}
 
-	symdata := Ctxt.Lookup(stringSymPrefix + symname)
+	symdata := base.Ctxt.Lookup(stringSymPrefix + symname)
 	if !symdata.OnList() {
 		off := dstringdata(symdata, 0, s, pos, "string")
 		ggloblsym(symdata, int32(off), obj.DUPOK|obj.RODATA|obj.LOCAL)
@@ -447,7 +448,7 @@ func fileStringSym(pos src.XPos, file string, readonly bool, hash []byte) (*obj.
 	var symdata *obj.LSym
 	if readonly {
 		symname := fmt.Sprintf(stringSymPattern, size, sum)
-		symdata = Ctxt.Lookup(stringSymPrefix + symname)
+		symdata = base.Ctxt.Lookup(stringSymPrefix + symname)
 		if !symdata.OnList() {
 			info := symdata.NewFileInfo()
 			info.Name = file
@@ -489,7 +490,7 @@ func slicedata(pos src.XPos, s string) *Node {
 
 func slicebytes(nam *Node, s string) {
 	if nam.Op != ONAME {
-		Fatalf("slicebytes %v", nam)
+		base.Fatalf("slicebytes %v", nam)
 	}
 	slicesym(nam, slicedata(nam.Pos, s), int64(len(s)))
 }
@@ -499,29 +500,29 @@ func dstringdata(s *obj.LSym, off int, t string, pos src.XPos, what string) int
 	// causing a cryptic error message by the linker. Check for oversize objects here
 	// and provide a useful error message instead.
 	if int64(len(t)) > 2e9 {
-		yyerrorl(pos, "%v with length %v is too big", what, len(t))
+		base.ErrorfAt(pos, "%v with length %v is too big", what, len(t))
 		return 0
 	}
 
-	s.WriteString(Ctxt, int64(off), len(t), t)
+	s.WriteString(base.Ctxt, int64(off), len(t), t)
 	return off + len(t)
 }
 
 func dsymptr(s *obj.LSym, off int, x *obj.LSym, xoff int) int {
 	off = int(Rnd(int64(off), int64(Widthptr)))
-	s.WriteAddr(Ctxt, int64(off), Widthptr, x, int64(xoff))
+	s.WriteAddr(base.Ctxt, int64(off), Widthptr, x, int64(xoff))
 	off += Widthptr
 	return off
 }
 
 func dsymptrOff(s *obj.LSym, off int, x *obj.LSym) int {
-	s.WriteOff(Ctxt, int64(off), x, 0)
+	s.WriteOff(base.Ctxt, int64(off), x, 0)
 	off += 4
 	return off
 }
 
 func dsymptrWeakOff(s *obj.LSym, off int, x *obj.LSym) int {
-	s.WriteWeakOff(Ctxt, int64(off), x, 0)
+	s.WriteWeakOff(base.Ctxt, int64(off), x, 0)
 	off += 4
 	return off
 }
@@ -532,79 +533,79 @@ func slicesym(n, arr *Node, lencap int64) {
 	s := n.Sym.Linksym()
 	off := n.Xoffset
 	if arr.Op != ONAME {
-		Fatalf("slicesym non-name arr %v", arr)
+		base.Fatalf("slicesym non-name arr %v", arr)
 	}
-	s.WriteAddr(Ctxt, off, Widthptr, arr.Sym.Linksym(), arr.Xoffset)
-	s.WriteInt(Ctxt, off+sliceLenOffset, Widthptr, lencap)
-	s.WriteInt(Ctxt, off+sliceCapOffset, Widthptr, lencap)
+	s.WriteAddr(base.Ctxt, off, Widthptr, arr.Sym.Linksym(), arr.Xoffset)
+	s.WriteInt(base.Ctxt, off+sliceLenOffset, Widthptr, lencap)
+	s.WriteInt(base.Ctxt, off+sliceCapOffset, Widthptr, lencap)
 }
 
 // addrsym writes the static address of a to n. a must be an ONAME.
 // Neither n nor a is modified.
 func addrsym(n, a *Node) {
 	if n.Op != ONAME {
-		Fatalf("addrsym n op %v", n.Op)
+		base.Fatalf("addrsym n op %v", n.Op)
 	}
 	if n.Sym == nil {
-		Fatalf("addrsym nil n sym")
+		base.Fatalf("addrsym nil n sym")
 	}
 	if a.Op != ONAME {
-		Fatalf("addrsym a op %v", a.Op)
+		base.Fatalf("addrsym a op %v", a.Op)
 	}
 	s := n.Sym.Linksym()
-	s.WriteAddr(Ctxt, n.Xoffset, Widthptr, a.Sym.Linksym(), a.Xoffset)
+	s.WriteAddr(base.Ctxt, n.Xoffset, Widthptr, a.Sym.Linksym(), a.Xoffset)
 }
 
 // pfuncsym writes the static address of f to n. f must be a global function.
 // Neither n nor f is modified.
 func pfuncsym(n, f *Node) {
 	if n.Op != ONAME {
-		Fatalf("pfuncsym n op %v", n.Op)
+		base.Fatalf("pfuncsym n op %v", n.Op)
 	}
 	if n.Sym == nil {
-		Fatalf("pfuncsym nil n sym")
+		base.Fatalf("pfuncsym nil n sym")
 	}
 	if f.Class() != PFUNC {
-		Fatalf("pfuncsym class not PFUNC %d", f.Class())
+		base.Fatalf("pfuncsym class not PFUNC %d", f.Class())
 	}
 	s := n.Sym.Linksym()
-	s.WriteAddr(Ctxt, n.Xoffset, Widthptr, funcsym(f.Sym).Linksym(), f.Xoffset)
+	s.WriteAddr(base.Ctxt, n.Xoffset, Widthptr, funcsym(f.Sym).Linksym(), f.Xoffset)
 }
 
 // litsym writes the static literal c to n.
 // Neither n nor c is modified.
 func litsym(n, c *Node, wid int) {
 	if n.Op != ONAME {
-		Fatalf("litsym n op %v", n.Op)
+		base.Fatalf("litsym n op %v", n.Op)
 	}
 	if n.Sym == nil {
-		Fatalf("litsym nil n sym")
+		base.Fatalf("litsym nil n sym")
 	}
 	if !types.Identical(n.Type, c.Type) {
-		Fatalf("litsym: type mismatch: %v has type %v, but %v has type %v", n, n.Type, c, c.Type)
+		base.Fatalf("litsym: type mismatch: %v has type %v, but %v has type %v", n, n.Type, c, c.Type)
 	}
 	if c.Op == ONIL {
 		return
 	}
 	if c.Op != OLITERAL {
-		Fatalf("litsym c op %v", c.Op)
+		base.Fatalf("litsym c op %v", c.Op)
 	}
 	s := n.Sym.Linksym()
 	switch u := c.Val(); u.Kind() {
 	case constant.Bool:
 		i := int64(obj.Bool2int(constant.BoolVal(u)))
-		s.WriteInt(Ctxt, n.Xoffset, wid, i)
+		s.WriteInt(base.Ctxt, n.Xoffset, wid, i)
 
 	case constant.Int:
-		s.WriteInt(Ctxt, n.Xoffset, wid, int64Val(n.Type, u))
+		s.WriteInt(base.Ctxt, n.Xoffset, wid, int64Val(n.Type, u))
 
 	case constant.Float:
 		f, _ := constant.Float64Val(u)
 		switch n.Type.Etype {
 		case TFLOAT32:
-			s.WriteFloat32(Ctxt, n.Xoffset, float32(f))
+			s.WriteFloat32(base.Ctxt, n.Xoffset, float32(f))
 		case TFLOAT64:
-			s.WriteFloat64(Ctxt, n.Xoffset, f)
+			s.WriteFloat64(base.Ctxt, n.Xoffset, f)
 		}
 
 	case constant.Complex:
@@ -612,20 +613,20 @@ func litsym(n, c *Node, wid int) {
 		im, _ := constant.Float64Val(constant.Imag(u))
 		switch n.Type.Etype {
 		case TCOMPLEX64:
-			s.WriteFloat32(Ctxt, n.Xoffset, float32(re))
-			s.WriteFloat32(Ctxt, n.Xoffset+4, float32(im))
+			s.WriteFloat32(base.Ctxt, n.Xoffset, float32(re))
+			s.WriteFloat32(base.Ctxt, n.Xoffset+4, float32(im))
 		case TCOMPLEX128:
-			s.WriteFloat64(Ctxt, n.Xoffset, re)
-			s.WriteFloat64(Ctxt, n.Xoffset+8, im)
+			s.WriteFloat64(base.Ctxt, n.Xoffset, re)
+			s.WriteFloat64(base.Ctxt, n.Xoffset+8, im)
 		}
 
 	case constant.String:
 		i := constant.StringVal(u)
 		symdata := stringsym(n.Pos, i)
-		s.WriteAddr(Ctxt, n.Xoffset, Widthptr, symdata, 0)
-		s.WriteInt(Ctxt, n.Xoffset+int64(Widthptr), Widthptr, int64(len(i)))
+		s.WriteAddr(base.Ctxt, n.Xoffset, Widthptr, symdata, 0)
+		s.WriteInt(base.Ctxt, n.Xoffset+int64(Widthptr), Widthptr, int64(len(i)))
 
 	default:
-		Fatalf("litsym unhandled OLITERAL %v", c)
+		base.Fatalf("litsym unhandled OLITERAL %v", c)
 	}
 }
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 90c08b1b75..3b0f316696 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"fmt"
@@ -50,7 +51,7 @@ type Order struct {
 // Order rewrites fn.Nbody to apply the ordering constraints
 // described in the comment at the top of the file.
 func order(fn *Node) {
-	if Flag.W > 1 {
+	if base.Flag.W > 1 {
 		s := fmt.Sprintf("\nbefore order %v", fn.Func.Nname.Sym)
 		dumplist(s, fn.Nbody)
 	}
@@ -181,7 +182,7 @@ func (o *Order) safeExpr(n *Node) *Node {
 		return typecheck(a, ctxExpr)
 
 	default:
-		Fatalf("order.safeExpr %v", n.Op)
+		base.Fatalf("order.safeExpr %v", n.Op)
 		return nil // not reached
 	}
 }
@@ -210,7 +211,7 @@ func (o *Order) addrTemp(n *Node) *Node {
 		var s InitSchedule
 		s.staticassign(vstat, n)
 		if s.out != nil {
-			Fatalf("staticassign of const generated code: %+v", n)
+			base.Fatalf("staticassign of const generated code: %+v", n)
 		}
 		vstat = typecheck(vstat, ctxExpr)
 		return vstat
@@ -323,7 +324,7 @@ func (o *Order) stmtList(l Nodes) {
 // and rewrites it to:
 //  m = OMAKESLICECOPY([]T, x, s); nil
 func orderMakeSliceCopy(s []*Node) {
-	if Flag.N != 0 || instrumenting {
+	if base.Flag.N != 0 || instrumenting {
 		return
 	}
 
@@ -384,7 +385,7 @@ func orderMakeSliceCopy(s []*Node) {
 
 // edge inserts coverage instrumentation for libfuzzer.
 func (o *Order) edge() {
-	if Debug.Libfuzzer == 0 {
+	if base.Debug.Libfuzzer == 0 {
 		return
 	}
 
@@ -450,7 +451,7 @@ func (o *Order) init(n *Node) {
 		// For concurrency safety, don't mutate potentially shared nodes.
 		// First, ensure that no work is required here.
 		if n.Ninit.Len() > 0 {
-			Fatalf("order.init shared node with ninit")
+			base.Fatalf("order.init shared node with ninit")
 		}
 		return
 	}
@@ -463,7 +464,7 @@ func (o *Order) init(n *Node) {
 func (o *Order) call(n *Node) {
 	if n.Ninit.Len() > 0 {
 		// Caller should have already called o.init(n).
-		Fatalf("%v with unexpected ninit", n.Op)
+		base.Fatalf("%v with unexpected ninit", n.Op)
 	}
 
 	// Builtin functions.
@@ -526,7 +527,7 @@ func (o *Order) call(n *Node) {
 func (o *Order) mapAssign(n *Node) {
 	switch n.Op {
 	default:
-		Fatalf("order.mapAssign %v", n.Op)
+		base.Fatalf("order.mapAssign %v", n.Op)
 
 	case OAS, OASOP:
 		if n.Left.Op == OINDEXMAP {
@@ -582,7 +583,7 @@ func (o *Order) stmt(n *Node) {
 
 	switch n.Op {
 	default:
-		Fatalf("order.stmt %v", n.Op)
+		base.Fatalf("order.stmt %v", n.Op)
 
 	case OVARKILL, OVARLIVE, OINLMARK:
 		o.out = append(o.out, n)
@@ -659,7 +660,7 @@ func (o *Order) stmt(n *Node) {
 			_ = mapKeyReplaceStrConv(r.Right)
 			r.Right = o.mapKeyTemp(r.Left.Type, r.Right)
 		default:
-			Fatalf("order.stmt: %v", r.Op)
+			base.Fatalf("order.stmt: %v", r.Op)
 		}
 
 		o.okAs2(n)
@@ -776,7 +777,7 @@ func (o *Order) stmt(n *Node) {
 		orderBody := true
 		switch n.Type.Etype {
 		default:
-			Fatalf("order.stmt range %v", n.Type)
+			base.Fatalf("order.stmt range %v", n.Type)
 
 		case TARRAY, TSLICE:
 			if n.List.Len() < 2 || n.List.Second().isBlank() {
@@ -843,7 +844,7 @@ func (o *Order) stmt(n *Node) {
 
 		for _, n2 := range n.List.Slice() {
 			if n2.Op != OCASE {
-				Fatalf("order select case %v", n2.Op)
+				base.Fatalf("order select case %v", n2.Op)
 			}
 			r := n2.Left
 			setlineno(n2)
@@ -851,7 +852,7 @@ func (o *Order) stmt(n *Node) {
 			// Append any new body prologue to ninit.
 			// The next loop will insert ninit into nbody.
 			if n2.Ninit.Len() != 0 {
-				Fatalf("order select ninit")
+				base.Fatalf("order select ninit")
 			}
 			if r == nil {
 				continue
@@ -859,7 +860,7 @@ func (o *Order) stmt(n *Node) {
 			switch r.Op {
 			default:
 				Dump("select case", r)
-				Fatalf("unknown op in select %v", r.Op)
+				base.Fatalf("unknown op in select %v", r.Op)
 
 			// If this is case x := <-ch or case x, y := <-ch, the case has
 			// the ODCL nodes to declare x and y. We want to delay that
@@ -881,7 +882,7 @@ func (o *Order) stmt(n *Node) {
 
 				if r.Ninit.Len() != 0 {
 					dumplist("ninit", r.Ninit)
-					Fatalf("ninit on select recv")
+					base.Fatalf("ninit on select recv")
 				}
 
 				// case x = <-c
@@ -943,7 +944,7 @@ func (o *Order) stmt(n *Node) {
 			case OSEND:
 				if r.Ninit.Len() != 0 {
 					dumplist("ninit", r.Ninit)
-					Fatalf("ninit on select send")
+					base.Fatalf("ninit on select send")
 				}
 
 				// case c <- x
@@ -998,7 +999,7 @@ func (o *Order) stmt(n *Node) {
 	// For now just clean all the temporaries at the end.
 	// In practice that's fine.
 	case OSWITCH:
-		if Debug.Libfuzzer != 0 && !hasDefaultCase(n) {
+		if base.Debug.Libfuzzer != 0 && !hasDefaultCase(n) {
 			// Add empty "default:" case for instrumentation.
 			n.List.Append(nod(OCASE, nil, nil))
 		}
@@ -1007,7 +1008,7 @@ func (o *Order) stmt(n *Node) {
 		n.Left = o.expr(n.Left, nil)
 		for _, ncas := range n.List.Slice() {
 			if ncas.Op != OCASE {
-				Fatalf("order switch case %v", ncas.Op)
+				base.Fatalf("order switch case %v", ncas.Op)
 			}
 			o.exprListInPlace(ncas.List)
 			orderBlock(&ncas.Nbody, o.free)
@@ -1017,13 +1018,13 @@ func (o *Order) stmt(n *Node) {
 		o.cleanTemp(t)
 	}
 
-	lineno = lno
+	base.Pos = lno
 }
 
 func hasDefaultCase(n *Node) bool {
 	for _, ncas := range n.List.Slice() {
 		if ncas.Op != OCASE {
-			Fatalf("expected case, found %v", ncas.Op)
+			base.Fatalf("expected case, found %v", ncas.Op)
 		}
 		if ncas.List.Len() == 0 {
 			return true
@@ -1330,7 +1331,7 @@ func (o *Order) expr(n, lhs *Node) *Node {
 		var dynamics []*Node
 		for _, r := range entries {
 			if r.Op != OKEY {
-				Fatalf("OMAPLIT entry not OKEY: %v\n", r)
+				base.Fatalf("OMAPLIT entry not OKEY: %v\n", r)
 			}
 
 			if !isStaticCompositeLiteral(r.Left) || !isStaticCompositeLiteral(r.Right) {
@@ -1369,7 +1370,7 @@ func (o *Order) expr(n, lhs *Node) *Node {
 		}
 	}
 
-	lineno = lno
+	base.Pos = lno
 	return n
 }
 
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index 19a24a3235..f10599dc28 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
 	"cmd/internal/dwarf"
@@ -29,7 +30,7 @@ func emitptrargsmap(fn *Node) {
 	if fn.funcname() == "_" || fn.Func.Nname.Sym.Linkname != "" {
 		return
 	}
-	lsym := Ctxt.Lookup(fn.Func.lsym.Name + ".args_stackmap")
+	lsym := base.Ctxt.Lookup(fn.Func.lsym.Name + ".args_stackmap")
 
 	nptr := int(fn.Type.ArgWidth() / int64(Widthptr))
 	bv := bvalloc(int32(nptr) * 2)
@@ -164,7 +165,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 		dowidth(n.Type)
 		w := n.Type.Width
 		if w >= thearch.MAXWIDTH || w < 0 {
-			Fatalf("bad width")
+			base.Fatalf("bad width")
 		}
 		if w == 0 && lastHasPtr {
 			// Pad between a pointer-containing object and a zero-sized object.
@@ -193,12 +194,12 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 
 func funccompile(fn *Node) {
 	if Curfn != nil {
-		Fatalf("funccompile %v inside %v", fn.Func.Nname.Sym, Curfn.Func.Nname.Sym)
+		base.Fatalf("funccompile %v inside %v", fn.Func.Nname.Sym, Curfn.Func.Nname.Sym)
 	}
 
 	if fn.Type == nil {
-		if Errors() == 0 {
-			Fatalf("funccompile missing type")
+		if base.Errors() == 0 {
+			base.Fatalf("funccompile missing type")
 		}
 		return
 	}
@@ -223,9 +224,9 @@ func funccompile(fn *Node) {
 }
 
 func compile(fn *Node) {
-	errorsBefore := Errors()
+	errorsBefore := base.Errors()
 	order(fn)
-	if Errors() > errorsBefore {
+	if base.Errors() > errorsBefore {
 		return
 	}
 
@@ -235,7 +236,7 @@ func compile(fn *Node) {
 	fn.Func.initLSym(true)
 
 	walk(fn)
-	if Errors() > errorsBefore {
+	if base.Errors() > errorsBefore {
 		return
 	}
 	if instrumenting {
@@ -265,7 +266,7 @@ func compile(fn *Node) {
 				// Also make sure we allocate a linker symbol
 				// for the stack object data, for the same reason.
 				if fn.Func.lsym.Func().StackObjects == nil {
-					fn.Func.lsym.Func().StackObjects = Ctxt.Lookup(fn.Func.lsym.Name + ".stkobj")
+					fn.Func.lsym.Func().StackObjects = base.Ctxt.Lookup(fn.Func.lsym.Name + ".stkobj")
 				}
 			}
 		}
@@ -291,7 +292,7 @@ func compilenow(fn *Node) bool {
 	if fn.IsMethod() && isInlinableButNotInlined(fn) {
 		return false
 	}
-	return Flag.LowerC == 1 && Debug.CompileLater == 0
+	return base.Flag.LowerC == 1 && base.Debug.CompileLater == 0
 }
 
 // isInlinableButNotInlined returns true if 'fn' was marked as an
@@ -373,9 +374,9 @@ func compileFunctions() {
 			})
 		}
 		var wg sync.WaitGroup
-		Ctxt.InParallel = true
-		c := make(chan *Node, Flag.LowerC)
-		for i := 0; i < Flag.LowerC; i++ {
+		base.Ctxt.InParallel = true
+		c := make(chan *Node, base.Flag.LowerC)
+		for i := 0; i < base.Flag.LowerC; i++ {
 			wg.Add(1)
 			go func(worker int) {
 				for fn := range c {
@@ -390,7 +391,7 @@ func compileFunctions() {
 		close(c)
 		compilequeue = nil
 		wg.Wait()
-		Ctxt.InParallel = false
+		base.Ctxt.InParallel = false
 		sizeCalculationDisabled = false
 	}
 }
@@ -399,7 +400,7 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 	fn := curfn.(*Node)
 	if fn.Func.Nname != nil {
 		if expect := fn.Func.Nname.Sym.Linksym(); fnsym != expect {
-			Fatalf("unexpected fnsym: %v != %v", fnsym, expect)
+			base.Fatalf("unexpected fnsym: %v != %v", fnsym, expect)
 		}
 	}
 
@@ -442,7 +443,7 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 				if !n.Name.Used() {
 					// Text == nil -> generating abstract function
 					if fnsym.Func().Text != nil {
-						Fatalf("debuginfo unused node (AllocFrame should truncate fn.Func.Dcl)")
+						base.Fatalf("debuginfo unused node (AllocFrame should truncate fn.Func.Dcl)")
 					}
 					continue
 				}
@@ -481,7 +482,7 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 
 	scopes := assembleScopes(fnsym, fn, dwarfVars, varScopes)
 	var inlcalls dwarf.InlCalls
-	if Flag.GenDwarfInl > 0 {
+	if base.Flag.GenDwarfInl > 0 {
 		inlcalls = assembleInlines(fnsym, dwarfVars)
 	}
 	return scopes, inlcalls
@@ -533,7 +534,7 @@ func createSimpleVar(fnsym *obj.LSym, n *Node) *dwarf.Var {
 	switch n.Class() {
 	case PAUTO:
 		abbrev = dwarf.DW_ABRV_AUTO
-		if Ctxt.FixedFrameSize() == 0 {
+		if base.Ctxt.FixedFrameSize() == 0 {
 			offs -= int64(Widthptr)
 		}
 		if objabi.Framepointer_enabled || objabi.GOARCH == "arm64" {
@@ -543,15 +544,15 @@ func createSimpleVar(fnsym *obj.LSym, n *Node) *dwarf.Var {
 
 	case PPARAM, PPARAMOUT:
 		abbrev = dwarf.DW_ABRV_PARAM
-		offs += Ctxt.FixedFrameSize()
+		offs += base.Ctxt.FixedFrameSize()
 	default:
-		Fatalf("createSimpleVar unexpected class %v for node %v", n.Class(), n)
+		base.Fatalf("createSimpleVar unexpected class %v for node %v", n.Class(), n)
 	}
 
 	typename := dwarf.InfoPrefix + typesymname(n.Type)
 	delete(fnsym.Func().Autot, ngotype(n).Linksym())
 	inlIndex := 0
-	if Flag.GenDwarfInl > 1 {
+	if base.Flag.GenDwarfInl > 1 {
 		if n.Name.InlFormal() || n.Name.InlLocal() {
 			inlIndex = posInlIndex(n.Pos) + 1
 			if n.Name.InlFormal() {
@@ -559,14 +560,14 @@ func createSimpleVar(fnsym *obj.LSym, n *Node) *dwarf.Var {
 			}
 		}
 	}
-	declpos := Ctxt.InnermostPos(declPos(n))
+	declpos := base.Ctxt.InnermostPos(declPos(n))
 	return &dwarf.Var{
 		Name:          n.Sym.Name,
 		IsReturnValue: n.Class() == PPARAMOUT,
 		IsInlFormal:   n.Name.InlFormal(),
 		Abbrev:        abbrev,
 		StackOffset:   int32(offs),
-		Type:          Ctxt.Lookup(typename),
+		Type:          base.Ctxt.Lookup(typename),
 		DeclFile:      declpos.RelFilename(),
 		DeclLine:      declpos.RelLine(),
 		DeclCol:       declpos.Col(),
@@ -608,7 +609,7 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *Func, apDecls []*Node)
 	var vars []*dwarf.Var
 	var decls []*Node
 	var selected map[*Node]bool
-	if Ctxt.Flag_locationlists && Ctxt.Flag_optimize && fn.DebugInfo != nil && complexOK {
+	if base.Ctxt.Flag_locationlists && base.Ctxt.Flag_optimize && fn.DebugInfo != nil && complexOK {
 		decls, vars, selected = createComplexVars(fnsym, fn)
 	} else {
 		decls, vars, selected = createSimpleVars(fnsym, apDecls)
@@ -672,7 +673,7 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *Func, apDecls []*Node)
 			}
 		}
 		inlIndex := 0
-		if Flag.GenDwarfInl > 1 {
+		if base.Flag.GenDwarfInl > 1 {
 			if n.Name.InlFormal() || n.Name.InlLocal() {
 				inlIndex = posInlIndex(n.Pos) + 1
 				if n.Name.InlFormal() {
@@ -680,13 +681,13 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *Func, apDecls []*Node)
 				}
 			}
 		}
-		declpos := Ctxt.InnermostPos(n.Pos)
+		declpos := base.Ctxt.InnermostPos(n.Pos)
 		vars = append(vars, &dwarf.Var{
 			Name:          n.Sym.Name,
 			IsReturnValue: isReturnValue,
 			Abbrev:        abbrev,
 			StackOffset:   int32(n.Xoffset),
-			Type:          Ctxt.Lookup(typename),
+			Type:          base.Ctxt.Lookup(typename),
 			DeclFile:      declpos.RelFilename(),
 			DeclLine:      declpos.RelLine(),
 			DeclCol:       declpos.Col(),
@@ -707,7 +708,7 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *Func, apDecls []*Node)
 // names of the variables may have been "versioned" to avoid conflicts
 // with local vars; disregard this versioning when sorting.
 func preInliningDcls(fnsym *obj.LSym) []*Node {
-	fn := Ctxt.DwFixups.GetPrecursorFunc(fnsym).(*Node)
+	fn := base.Ctxt.DwFixups.GetPrecursorFunc(fnsym).(*Node)
 	var rdcl []*Node
 	for _, n := range fn.Func.Inl.Dcl {
 		c := n.Sym.Name[0]
@@ -729,7 +730,7 @@ func stackOffset(slot ssa.LocalSlot) int32 {
 	var off int64
 	switch n.Class() {
 	case PAUTO:
-		if Ctxt.FixedFrameSize() == 0 {
+		if base.Ctxt.FixedFrameSize() == 0 {
 			off -= int64(Widthptr)
 		}
 		if objabi.Framepointer_enabled || objabi.GOARCH == "arm64" {
@@ -737,7 +738,7 @@ func stackOffset(slot ssa.LocalSlot) int32 {
 			off -= int64(Widthptr)
 		}
 	case PPARAM, PPARAMOUT:
-		off += Ctxt.FixedFrameSize()
+		off += base.Ctxt.FixedFrameSize()
 	}
 	return int32(off + n.Xoffset + slot.Off)
 }
@@ -761,7 +762,7 @@ func createComplexVar(fnsym *obj.LSym, fn *Func, varID ssa.VarID) *dwarf.Var {
 	delete(fnsym.Func().Autot, gotype)
 	typename := dwarf.InfoPrefix + gotype.Name[len("type."):]
 	inlIndex := 0
-	if Flag.GenDwarfInl > 1 {
+	if base.Flag.GenDwarfInl > 1 {
 		if n.Name.InlFormal() || n.Name.InlLocal() {
 			inlIndex = posInlIndex(n.Pos) + 1
 			if n.Name.InlFormal() {
@@ -769,13 +770,13 @@ func createComplexVar(fnsym *obj.LSym, fn *Func, varID ssa.VarID) *dwarf.Var {
 			}
 		}
 	}
-	declpos := Ctxt.InnermostPos(n.Pos)
+	declpos := base.Ctxt.InnermostPos(n.Pos)
 	dvar := &dwarf.Var{
 		Name:          n.Sym.Name,
 		IsReturnValue: n.Class() == PPARAMOUT,
 		IsInlFormal:   n.Name.InlFormal(),
 		Abbrev:        abbrev,
-		Type:          Ctxt.Lookup(typename),
+		Type:          base.Ctxt.Lookup(typename),
 		// The stack offset is used as a sorting key, so for decomposed
 		// variables just give it the first one. It's not used otherwise.
 		// This won't work well if the first slot hasn't been assigned a stack
@@ -790,7 +791,7 @@ func createComplexVar(fnsym *obj.LSym, fn *Func, varID ssa.VarID) *dwarf.Var {
 	list := debug.LocationLists[varID]
 	if len(list) != 0 {
 		dvar.PutLocationList = func(listSym, startPC dwarf.Sym) {
-			debug.PutLocationList(list, Ctxt, listSym.(*obj.LSym), startPC.(*obj.LSym))
+			debug.PutLocationList(list, base.Ctxt, listSym.(*obj.LSym), startPC.(*obj.LSym))
 		}
 	}
 	return dvar
diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/gc/plive.go
index 5f4af06b80..da2298480a 100644
--- a/src/cmd/compile/internal/gc/plive.go
+++ b/src/cmd/compile/internal/gc/plive.go
@@ -15,6 +15,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -226,7 +227,7 @@ func getvariables(fn *Node) ([]*Node, map[*Node]int32) {
 
 func (lv *Liveness) initcache() {
 	if lv.cache.initialized {
-		Fatalf("liveness cache initialized twice")
+		base.Fatalf("liveness cache initialized twice")
 		return
 	}
 	lv.cache.initialized = true
@@ -341,7 +342,7 @@ func affectedNode(v *ssa.Value) (*Node, ssa.SymEffect) {
 	case *Node:
 		return a, e
 	default:
-		Fatalf("weird aux: %s", v.LongString())
+		base.Fatalf("weird aux: %s", v.LongString())
 		return nil, e
 	}
 }
@@ -406,7 +407,7 @@ func (lv *Liveness) blockEffects(b *ssa.Block) *BlockEffects {
 // on future calls with the same type t.
 func onebitwalktype1(t *types.Type, off int64, bv bvec) {
 	if t.Align > 0 && off&int64(t.Align-1) != 0 {
-		Fatalf("onebitwalktype1: invalid initial alignment: type %v has alignment %d, but offset is %v", t, t.Align, off)
+		base.Fatalf("onebitwalktype1: invalid initial alignment: type %v has alignment %d, but offset is %v", t, t.Align, off)
 	}
 	if !t.HasPointers() {
 		// Note: this case ensures that pointers to go:notinheap types
@@ -417,14 +418,14 @@ func onebitwalktype1(t *types.Type, off int64, bv bvec) {
 	switch t.Etype {
 	case TPTR, TUNSAFEPTR, TFUNC, TCHAN, TMAP:
 		if off&int64(Widthptr-1) != 0 {
-			Fatalf("onebitwalktype1: invalid alignment, %v", t)
+			base.Fatalf("onebitwalktype1: invalid alignment, %v", t)
 		}
 		bv.Set(int32(off / int64(Widthptr))) // pointer
 
 	case TSTRING:
 		// struct { byte *str; intgo len; }
 		if off&int64(Widthptr-1) != 0 {
-			Fatalf("onebitwalktype1: invalid alignment, %v", t)
+			base.Fatalf("onebitwalktype1: invalid alignment, %v", t)
 		}
 		bv.Set(int32(off / int64(Widthptr))) //pointer in first slot
 
@@ -433,7 +434,7 @@ func onebitwalktype1(t *types.Type, off int64, bv bvec) {
 		// or, when isnilinter(t)==true:
 		// struct { Type *type; void *data; }
 		if off&int64(Widthptr-1) != 0 {
-			Fatalf("onebitwalktype1: invalid alignment, %v", t)
+			base.Fatalf("onebitwalktype1: invalid alignment, %v", t)
 		}
 		// The first word of an interface is a pointer, but we don't
 		// treat it as such.
@@ -452,7 +453,7 @@ func onebitwalktype1(t *types.Type, off int64, bv bvec) {
 	case TSLICE:
 		// struct { byte *array; uintgo len; uintgo cap; }
 		if off&int64(Widthptr-1) != 0 {
-			Fatalf("onebitwalktype1: invalid TARRAY alignment, %v", t)
+			base.Fatalf("onebitwalktype1: invalid TARRAY alignment, %v", t)
 		}
 		bv.Set(int32(off / int64(Widthptr))) // pointer in first slot (BitsPointer)
 
@@ -473,7 +474,7 @@ func onebitwalktype1(t *types.Type, off int64, bv bvec) {
 		}
 
 	default:
-		Fatalf("onebitwalktype1: unexpected type, %v", t)
+		base.Fatalf("onebitwalktype1: unexpected type, %v", t)
 	}
 }
 
@@ -509,7 +510,7 @@ func allUnsafe(f *ssa.Func) bool {
 	// go:nosplit functions are similar. Since safe points used to
 	// be coupled with stack checks, go:nosplit often actually
 	// means "no safe points in this function".
-	return Flag.CompilingRuntime || f.NoSplit
+	return base.Flag.CompilingRuntime || f.NoSplit
 }
 
 // markUnsafePoints finds unsafe points and computes lv.unsafePoints.
@@ -791,7 +792,7 @@ func (lv *Liveness) epilogue() {
 			if n.Class() == PPARAMOUT {
 				if n.Name.IsOutputParamHeapAddr() {
 					// Just to be paranoid.  Heap addresses are PAUTOs.
-					Fatalf("variable %v both output param and heap output param", n)
+					base.Fatalf("variable %v both output param and heap output param", n)
 				}
 				if n.Name.Param.Heapaddr != nil {
 					// If this variable moved to the heap, then
@@ -816,7 +817,7 @@ func (lv *Liveness) epilogue() {
 				livedefer.Set(int32(i))
 				// It was already marked as Needzero when created.
 				if !n.Name.Needzero() {
-					Fatalf("all pointer-containing defer arg slots should have Needzero set")
+					base.Fatalf("all pointer-containing defer arg slots should have Needzero set")
 				}
 			}
 		}
@@ -878,7 +879,7 @@ func (lv *Liveness) epilogue() {
 
 		if b == lv.f.Entry {
 			if index != 0 {
-				Fatalf("bad index for entry point: %v", index)
+				base.Fatalf("bad index for entry point: %v", index)
 			}
 
 			// Check to make sure only input variables are live.
@@ -889,7 +890,7 @@ func (lv *Liveness) epilogue() {
 				if n.Class() == PPARAM {
 					continue // ok
 				}
-				Fatalf("bad live variable at entry of %v: %L", lv.fn.Func.Nname, n)
+				base.Fatalf("bad live variable at entry of %v: %L", lv.fn.Func.Nname, n)
 			}
 
 			// Record live variables.
@@ -966,7 +967,7 @@ func (lv *Liveness) compact(b *ssa.Block) {
 }
 
 func (lv *Liveness) showlive(v *ssa.Value, live bvec) {
-	if Flag.Live == 0 || lv.fn.funcname() == "init" || strings.HasPrefix(lv.fn.funcname(), ".") {
+	if base.Flag.Live == 0 || lv.fn.funcname() == "init" || strings.HasPrefix(lv.fn.funcname(), ".") {
 		return
 	}
 	if !(v == nil || v.Op.IsCall()) {
@@ -1002,7 +1003,7 @@ func (lv *Liveness) showlive(v *ssa.Value, live bvec) {
 		}
 	}
 
-	Warnl(pos, s)
+	base.WarnfAt(pos, s)
 }
 
 func (lv *Liveness) printbvec(printed bool, name string, live bvec) bool {
@@ -1088,7 +1089,7 @@ func (lv *Liveness) printDebug() {
 
 		if b == lv.f.Entry {
 			live := lv.stackMaps[0]
-			fmt.Printf("(%s) function entry\n", linestr(lv.fn.Func.Nname.Pos))
+			fmt.Printf("(%s) function entry\n", base.FmtPos(lv.fn.Func.Nname.Pos))
 			fmt.Printf("\tlive=")
 			printed = false
 			for j, n := range lv.vars {
@@ -1105,7 +1106,7 @@ func (lv *Liveness) printDebug() {
 		}
 
 		for _, v := range b.Values {
-			fmt.Printf("(%s) %v\n", linestr(v.Pos), v.LongString())
+			fmt.Printf("(%s) %v\n", base.FmtPos(v.Pos), v.LongString())
 
 			pcdata := lv.livenessMap.Get(v)
 
@@ -1214,7 +1215,7 @@ func (lv *Liveness) emit() (argsSym, liveSym *obj.LSym) {
 	// These symbols will be added to Ctxt.Data by addGCLocals
 	// after parallel compilation is done.
 	makeSym := func(tmpSym *obj.LSym) *obj.LSym {
-		return Ctxt.LookupInit(fmt.Sprintf("gclocals·%x", md5.Sum(tmpSym.P)), func(lsym *obj.LSym) {
+		return base.Ctxt.LookupInit(fmt.Sprintf("gclocals·%x", md5.Sum(tmpSym.P)), func(lsym *obj.LSym) {
 			lsym.P = tmpSym.P
 			lsym.Set(obj.AttrContentAddressable, true)
 		})
@@ -1235,7 +1236,7 @@ func liveness(e *ssafn, f *ssa.Func, pp *Progs) LivenessMap {
 	lv.prologue()
 	lv.solve()
 	lv.epilogue()
-	if Flag.Live > 0 {
+	if base.Flag.Live > 0 {
 		lv.showlive(nil, lv.stackMaps[0])
 		for _, b := range f.Blocks {
 			for _, val := range b.Values {
@@ -1245,7 +1246,7 @@ func liveness(e *ssafn, f *ssa.Func, pp *Progs) LivenessMap {
 			}
 		}
 	}
-	if Flag.Live >= 2 {
+	if base.Flag.Live >= 2 {
 		lv.printDebug()
 	}
 
diff --git a/src/cmd/compile/internal/gc/racewalk.go b/src/cmd/compile/internal/gc/racewalk.go
index 733d19c024..20b4bc583b 100644
--- a/src/cmd/compile/internal/gc/racewalk.go
+++ b/src/cmd/compile/internal/gc/racewalk.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"cmd/internal/sys"
@@ -47,9 +48,9 @@ var omit_pkgs = []string{
 var norace_inst_pkgs = []string{"sync", "sync/atomic"}
 
 func ispkgin(pkgs []string) bool {
-	if Ctxt.Pkgpath != "" {
+	if base.Ctxt.Pkgpath != "" {
 		for _, p := range pkgs {
-			if Ctxt.Pkgpath == p {
+			if base.Ctxt.Pkgpath == p {
 				return true
 			}
 		}
@@ -63,13 +64,13 @@ func instrument(fn *Node) {
 		return
 	}
 
-	if !Flag.Race || !ispkgin(norace_inst_pkgs) {
+	if !base.Flag.Race || !ispkgin(norace_inst_pkgs) {
 		fn.Func.SetInstrumentBody(true)
 	}
 
-	if Flag.Race {
-		lno := lineno
-		lineno = src.NoXPos
+	if base.Flag.Race {
+		lno := base.Pos
+		base.Pos = src.NoXPos
 
 		if thearch.LinkArch.Arch.Family != sys.AMD64 {
 			fn.Func.Enter.Prepend(mkcall("racefuncenterfp", nil, nil))
@@ -88,6 +89,6 @@ func instrument(fn *Node) {
 			fn.Func.Enter.Prepend(mkcall("racefuncenter", nil, nil, nodpc))
 			fn.Func.Exit.Append(mkcall("racefuncexit", nil, nil))
 		}
-		lineno = lno
+		base.Pos = lno
 	}
 }
diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index 44776e988e..568c5138ec 100644
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/sys"
 	"unicode/utf8"
@@ -61,7 +62,7 @@ func typecheckrangeExpr(n *Node) {
 	toomany := false
 	switch t.Etype {
 	default:
-		yyerrorl(n.Pos, "cannot range over %L", n.Right)
+		base.ErrorfAt(n.Pos, "cannot range over %L", n.Right)
 		return
 
 	case TARRAY, TSLICE:
@@ -74,7 +75,7 @@ func typecheckrangeExpr(n *Node) {
 
 	case TCHAN:
 		if !t.ChanDir().CanRecv() {
-			yyerrorl(n.Pos, "invalid operation: range %v (receive from send-only type %v)", n.Right, n.Right.Type)
+			base.ErrorfAt(n.Pos, "invalid operation: range %v (receive from send-only type %v)", n.Right, n.Right.Type)
 			return
 		}
 
@@ -90,7 +91,7 @@ func typecheckrangeExpr(n *Node) {
 	}
 
 	if n.List.Len() > 2 || toomany {
-		yyerrorl(n.Pos, "too many variables in range")
+		base.ErrorfAt(n.Pos, "too many variables in range")
 	}
 
 	var v1, v2 *Node
@@ -117,7 +118,7 @@ func typecheckrangeExpr(n *Node) {
 			v1.Type = t1
 		} else if v1.Type != nil {
 			if op, why := assignop(t1, v1.Type); op == OXXX {
-				yyerrorl(n.Pos, "cannot assign type %v to %L in range%s", t1, v1, why)
+				base.ErrorfAt(n.Pos, "cannot assign type %v to %L in range%s", t1, v1, why)
 			}
 		}
 		checkassign(n, v1)
@@ -128,7 +129,7 @@ func typecheckrangeExpr(n *Node) {
 			v2.Type = t2
 		} else if v2.Type != nil {
 			if op, why := assignop(t2, v2.Type); op == OXXX {
-				yyerrorl(n.Pos, "cannot assign type %v to %L in range%s", t2, v2, why)
+				base.ErrorfAt(n.Pos, "cannot assign type %v to %L in range%s", t2, v2, why)
 			}
 		}
 		checkassign(n, v2)
@@ -160,7 +161,7 @@ func walkrange(n *Node) *Node {
 		m := n.Right
 		lno := setlineno(m)
 		n = mapClear(m)
-		lineno = lno
+		base.Pos = lno
 		return n
 	}
 
@@ -196,7 +197,7 @@ func walkrange(n *Node) *Node {
 	}
 
 	if v1 == nil && v2 != nil {
-		Fatalf("walkrange: v2 != nil while v1 == nil")
+		base.Fatalf("walkrange: v2 != nil while v1 == nil")
 	}
 
 	// n.List has no meaning anymore, clear it
@@ -211,11 +212,11 @@ func walkrange(n *Node) *Node {
 	var init []*Node
 	switch t.Etype {
 	default:
-		Fatalf("walkrange")
+		base.Fatalf("walkrange")
 
 	case TARRAY, TSLICE:
 		if arrayClear(n, v1, v2, a) {
-			lineno = lno
+			base.Pos = lno
 			return n
 		}
 
@@ -454,7 +455,7 @@ func walkrange(n *Node) *Node {
 
 	n = walkstmt(n)
 
-	lineno = lno
+	base.Pos = lno
 	return n
 }
 
@@ -466,7 +467,7 @@ func walkrange(n *Node) *Node {
 //
 // where == for keys of map m is reflexive.
 func isMapClear(n *Node) bool {
-	if Flag.N != 0 || instrumenting {
+	if base.Flag.N != 0 || instrumenting {
 		return false
 	}
 
@@ -533,7 +534,7 @@ func mapClear(m *Node) *Node {
 //
 // Parameters are as in walkrange: "for v1, v2 = range a".
 func arrayClear(n, v1, v2, a *Node) bool {
-	if Flag.N != 0 || instrumenting {
+	if base.Flag.N != 0 || instrumenting {
 		return false
 	}
 
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 11ccc15a25..456903e7d7 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/gcprog"
 	"cmd/internal/obj"
@@ -131,52 +132,52 @@ func bmap(t *types.Type) *types.Type {
 
 	// Check invariants that map code depends on.
 	if !IsComparable(t.Key()) {
-		Fatalf("unsupported map key type for %v", t)
+		base.Fatalf("unsupported map key type for %v", t)
 	}
 	if BUCKETSIZE < 8 {
-		Fatalf("bucket size too small for proper alignment")
+		base.Fatalf("bucket size too small for proper alignment")
 	}
 	if keytype.Align > BUCKETSIZE {
-		Fatalf("key align too big for %v", t)
+		base.Fatalf("key align too big for %v", t)
 	}
 	if elemtype.Align > BUCKETSIZE {
-		Fatalf("elem align too big for %v", t)
+		base.Fatalf("elem align too big for %v", t)
 	}
 	if keytype.Width > MAXKEYSIZE {
-		Fatalf("key size to large for %v", t)
+		base.Fatalf("key size to large for %v", t)
 	}
 	if elemtype.Width > MAXELEMSIZE {
-		Fatalf("elem size to large for %v", t)
+		base.Fatalf("elem size to large for %v", t)
 	}
 	if t.Key().Width > MAXKEYSIZE && !keytype.IsPtr() {
-		Fatalf("key indirect incorrect for %v", t)
+		base.Fatalf("key indirect incorrect for %v", t)
 	}
 	if t.Elem().Width > MAXELEMSIZE && !elemtype.IsPtr() {
-		Fatalf("elem indirect incorrect for %v", t)
+		base.Fatalf("elem indirect incorrect for %v", t)
 	}
 	if keytype.Width%int64(keytype.Align) != 0 {
-		Fatalf("key size not a multiple of key align for %v", t)
+		base.Fatalf("key size not a multiple of key align for %v", t)
 	}
 	if elemtype.Width%int64(elemtype.Align) != 0 {
-		Fatalf("elem size not a multiple of elem align for %v", t)
+		base.Fatalf("elem size not a multiple of elem align for %v", t)
 	}
 	if bucket.Align%keytype.Align != 0 {
-		Fatalf("bucket align not multiple of key align %v", t)
+		base.Fatalf("bucket align not multiple of key align %v", t)
 	}
 	if bucket.Align%elemtype.Align != 0 {
-		Fatalf("bucket align not multiple of elem align %v", t)
+		base.Fatalf("bucket align not multiple of elem align %v", t)
 	}
 	if keys.Offset%int64(keytype.Align) != 0 {
-		Fatalf("bad alignment of keys in bmap for %v", t)
+		base.Fatalf("bad alignment of keys in bmap for %v", t)
 	}
 	if elems.Offset%int64(elemtype.Align) != 0 {
-		Fatalf("bad alignment of elems in bmap for %v", t)
+		base.Fatalf("bad alignment of elems in bmap for %v", t)
 	}
 
 	// Double-check that overflow field is final memory in struct,
 	// with no padding at end.
 	if overflow.Offset != bucket.Width-int64(Widthptr) {
-		Fatalf("bad offset of overflow in bmap for %v", t)
+		base.Fatalf("bad offset of overflow in bmap for %v", t)
 	}
 
 	t.MapType().Bucket = bucket
@@ -227,7 +228,7 @@ func hmap(t *types.Type) *types.Type {
 	// The size of hmap should be 48 bytes on 64 bit
 	// and 28 bytes on 32 bit platforms.
 	if size := int64(8 + 5*Widthptr); hmap.Width != size {
-		Fatalf("hmap size not correct: got %d, want %d", hmap.Width, size)
+		base.Fatalf("hmap size not correct: got %d, want %d", hmap.Width, size)
 	}
 
 	t.MapType().Hmap = hmap
@@ -288,7 +289,7 @@ func hiter(t *types.Type) *types.Type {
 	hiter.SetFields(fields)
 	dowidth(hiter)
 	if hiter.Width != int64(12*Widthptr) {
-		Fatalf("hash_iter size not correct %d %d", hiter.Width, 12*Widthptr)
+		base.Fatalf("hash_iter size not correct %d %d", hiter.Width, 12*Widthptr)
 	}
 	t.MapType().Hiter = hiter
 	hiter.StructType().Map = t
@@ -391,10 +392,10 @@ func methods(t *types.Type) []*Sig {
 	var ms []*Sig
 	for _, f := range mt.AllMethods().Slice() {
 		if !f.IsMethod() {
-			Fatalf("non-method on %v method %v %v\n", mt, f.Sym, f)
+			base.Fatalf("non-method on %v method %v %v\n", mt, f.Sym, f)
 		}
 		if f.Type.Recv() == nil {
-			Fatalf("receiver with no type on %v method %v %v\n", mt, f.Sym, f)
+			base.Fatalf("receiver with no type on %v method %v %v\n", mt, f.Sym, f)
 		}
 		if f.Nointerface() {
 			continue
@@ -450,12 +451,12 @@ func imethods(t *types.Type) []*Sig {
 			continue
 		}
 		if f.Sym.IsBlank() {
-			Fatalf("unexpected blank symbol in interface method set")
+			base.Fatalf("unexpected blank symbol in interface method set")
 		}
 		if n := len(methods); n > 0 {
 			last := methods[n-1]
 			if !last.name.Less(f.Sym) {
-				Fatalf("sigcmp vs sortinter %v %v", last.name, f.Sym)
+				base.Fatalf("sigcmp vs sortinter %v %v", last.name, f.Sym)
 			}
 		}
 
@@ -488,17 +489,17 @@ func dimportpath(p *types.Pkg) {
 	// If we are compiling the runtime package, there are two runtime packages around
 	// -- localpkg and Runtimepkg. We don't want to produce import path symbols for
 	// both of them, so just produce one for localpkg.
-	if Ctxt.Pkgpath == "runtime" && p == Runtimepkg {
+	if base.Ctxt.Pkgpath == "runtime" && p == Runtimepkg {
 		return
 	}
 
 	str := p.Path
 	if p == localpkg {
 		// Note: myimportpath != "", or else dgopkgpath won't call dimportpath.
-		str = Ctxt.Pkgpath
+		str = base.Ctxt.Pkgpath
 	}
 
-	s := Ctxt.Lookup("type..importpath." + p.Prefix + ".")
+	s := base.Ctxt.Lookup("type..importpath." + p.Prefix + ".")
 	ot := dnameData(s, 0, str, "", nil, false)
 	ggloblsym(s, int32(ot), obj.DUPOK|obj.RODATA)
 	s.Set(obj.AttrContentAddressable, true)
@@ -510,13 +511,13 @@ func dgopkgpath(s *obj.LSym, ot int, pkg *types.Pkg) int {
 		return duintptr(s, ot, 0)
 	}
 
-	if pkg == localpkg && Ctxt.Pkgpath == "" {
+	if pkg == localpkg && base.Ctxt.Pkgpath == "" {
 		// If we don't know the full import path of the package being compiled
 		// (i.e. -p was not passed on the compiler command line), emit a reference to
 		// type..importpath.""., which the linker will rewrite using the correct import path.
 		// Every package that imports this one directly defines the symbol.
 		// See also https://groups.google.com/forum/#!topic/golang-dev/myb9s53HxGQ.
-		ns := Ctxt.Lookup(`type..importpath."".`)
+		ns := base.Ctxt.Lookup(`type..importpath."".`)
 		return dsymptr(s, ot, ns, 0)
 	}
 
@@ -529,13 +530,13 @@ func dgopkgpathOff(s *obj.LSym, ot int, pkg *types.Pkg) int {
 	if pkg == nil {
 		return duint32(s, ot, 0)
 	}
-	if pkg == localpkg && Ctxt.Pkgpath == "" {
+	if pkg == localpkg && base.Ctxt.Pkgpath == "" {
 		// If we don't know the full import path of the package being compiled
 		// (i.e. -p was not passed on the compiler command line), emit a reference to
 		// type..importpath.""., which the linker will rewrite using the correct import path.
 		// Every package that imports this one directly defines the symbol.
 		// See also https://groups.google.com/forum/#!topic/golang-dev/myb9s53HxGQ.
-		ns := Ctxt.Lookup(`type..importpath."".`)
+		ns := base.Ctxt.Lookup(`type..importpath."".`)
 		return dsymptrOff(s, ot, ns)
 	}
 
@@ -546,7 +547,7 @@ func dgopkgpathOff(s *obj.LSym, ot int, pkg *types.Pkg) int {
 // dnameField dumps a reflect.name for a struct field.
 func dnameField(lsym *obj.LSym, ot int, spkg *types.Pkg, ft *types.Field) int {
 	if !types.IsExported(ft.Sym.Name) && ft.Sym.Pkg != spkg {
-		Fatalf("package mismatch for %v", ft.Sym)
+		base.Fatalf("package mismatch for %v", ft.Sym)
 	}
 	nsym := dname(ft.Sym.Name, ft.Note, nil, types.IsExported(ft.Sym.Name))
 	return dsymptr(lsym, ot, nsym, 0)
@@ -555,10 +556,10 @@ func dnameField(lsym *obj.LSym, ot int, spkg *types.Pkg, ft *types.Field) int {
 // dnameData writes the contents of a reflect.name into s at offset ot.
 func dnameData(s *obj.LSym, ot int, name, tag string, pkg *types.Pkg, exported bool) int {
 	if len(name) > 1<<16-1 {
-		Fatalf("name too long: %s", name)
+		base.Fatalf("name too long: %s", name)
 	}
 	if len(tag) > 1<<16-1 {
-		Fatalf("tag too long: %s", tag)
+		base.Fatalf("tag too long: %s", tag)
 	}
 
 	// Encode name and tag. See reflect/type.go for details.
@@ -586,7 +587,7 @@ func dnameData(s *obj.LSym, ot int, name, tag string, pkg *types.Pkg, exported b
 		copy(tb[2:], tag)
 	}
 
-	ot = int(s.WriteBytes(Ctxt, int64(ot), b))
+	ot = int(s.WriteBytes(base.Ctxt, int64(ot), b))
 
 	if pkg != nil {
 		ot = dgopkgpathOff(s, ot, pkg)
@@ -623,7 +624,7 @@ func dname(name, tag string, pkg *types.Pkg, exported bool) *obj.LSym {
 		sname = fmt.Sprintf(`%s"".%d`, sname, dnameCount)
 		dnameCount++
 	}
-	s := Ctxt.Lookup(sname)
+	s := base.Ctxt.Lookup(sname)
 	if len(s.P) > 0 {
 		return s
 	}
@@ -643,7 +644,7 @@ func dextratype(lsym *obj.LSym, ot int, t *types.Type, dataAdd int) int {
 	}
 	noff := int(Rnd(int64(ot), int64(Widthptr)))
 	if noff != ot {
-		Fatalf("unexpected alignment in dextratype for %v", t)
+		base.Fatalf("unexpected alignment in dextratype for %v", t)
 	}
 
 	for _, a := range m {
@@ -655,11 +656,11 @@ func dextratype(lsym *obj.LSym, ot int, t *types.Type, dataAdd int) int {
 	dataAdd += uncommonSize(t)
 	mcount := len(m)
 	if mcount != int(uint16(mcount)) {
-		Fatalf("too many methods on %v: %d", t, mcount)
+		base.Fatalf("too many methods on %v: %d", t, mcount)
 	}
 	xcount := sort.Search(mcount, func(i int) bool { return !types.IsExported(m[i].name.Name) })
 	if dataAdd != int(uint32(dataAdd)) {
-		Fatalf("methods are too far away on %v: %d", t, dataAdd)
+		base.Fatalf("methods are too far away on %v: %d", t, dataAdd)
 	}
 
 	ot = duint16(lsym, ot, uint16(mcount))
@@ -788,7 +789,7 @@ func typeptrdata(t *types.Type) int64 {
 		return lastPtrField.Offset + typeptrdata(lastPtrField.Type)
 
 	default:
-		Fatalf("typeptrdata: unexpected type, %v", t)
+		base.Fatalf("typeptrdata: unexpected type, %v", t)
 		return 0
 	}
 }
@@ -888,7 +889,7 @@ func dcommontype(lsym *obj.LSym, t *types.Type) int {
 		i = 1
 	}
 	if i&(i-1) != 0 {
-		Fatalf("invalid alignment %d for %v", t.Align, t)
+		base.Fatalf("invalid alignment %d for %v", t.Align, t)
 	}
 	ot = duint8(lsym, ot, t.Align) // align
 	ot = duint8(lsym, ot, t.Align) // fieldAlign
@@ -979,7 +980,7 @@ func typesymprefix(prefix string, t *types.Type) *types.Sym {
 
 func typenamesym(t *types.Type) *types.Sym {
 	if t == nil || (t.IsPtr() && t.Elem() == nil) || t.IsUntyped() {
-		Fatalf("typenamesym %v", t)
+		base.Fatalf("typenamesym %v", t)
 	}
 	s := typesym(t)
 	signatmu.Lock()
@@ -1006,7 +1007,7 @@ func typename(t *types.Type) *Node {
 
 func itabname(t, itype *types.Type) *Node {
 	if t == nil || (t.IsPtr() && t.Elem() == nil) || t.IsUntyped() || !itype.IsInterface() || itype.IsEmptyInterface() {
-		Fatalf("itabname(%v, %v)", t, itype)
+		base.Fatalf("itabname(%v, %v)", t, itype)
 	}
 	s := itabpkg.Lookup(t.ShortString() + "," + itype.ShortString())
 	if s.Def == nil {
@@ -1065,7 +1066,7 @@ func isreflexive(t *types.Type) bool {
 		return true
 
 	default:
-		Fatalf("bad type for map key: %v", t)
+		base.Fatalf("bad type for map key: %v", t)
 		return false
 	}
 }
@@ -1095,7 +1096,7 @@ func needkeyupdate(t *types.Type) bool {
 		return false
 
 	default:
-		Fatalf("bad type for map key: %v", t)
+		base.Fatalf("bad type for map key: %v", t)
 		return true
 	}
 }
@@ -1135,7 +1136,7 @@ func formalType(t *types.Type) *types.Type {
 func dtypesym(t *types.Type) *obj.LSym {
 	t = formalType(t)
 	if t.IsUntyped() {
-		Fatalf("dtypesym %v", t)
+		base.Fatalf("dtypesym %v", t)
 	}
 
 	s := typesym(t)
@@ -1158,7 +1159,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 		dupok = obj.DUPOK
 	}
 
-	if Ctxt.Pkgpath != "runtime" || (tbase != types.Types[tbase.Etype] && tbase != types.Bytetype && tbase != types.Runetype && tbase != types.Errortype) { // int, float, etc
+	if base.Ctxt.Pkgpath != "runtime" || (tbase != types.Types[tbase.Etype] && tbase != types.Bytetype && tbase != types.Runetype && tbase != types.Errortype) { // int, float, etc
 		// named types from other files are defined only by those files
 		if tbase.Sym != nil && tbase.Sym.Pkg != localpkg {
 			if i, ok := typeSymIdx[tbase]; ok {
@@ -1377,7 +1378,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 			ot = dsymptr(lsym, ot, dtypesym(f.Type), 0)
 			offsetAnon := uint64(f.Offset) << 1
 			if offsetAnon>>1 != uint64(f.Offset) {
-				Fatalf("%v: bad field offset for %s", t, f.Sym.Name)
+				base.Fatalf("%v: bad field offset for %s", t, f.Sym.Name)
 			}
 			if f.Embedded != 0 {
 				offsetAnon |= 1
@@ -1394,7 +1395,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 	//
 	// When buildmode=shared, all types are in typelinks so the
 	// runtime can deduplicate type pointers.
-	keep := Ctxt.Flag_dynlink
+	keep := base.Ctxt.Flag_dynlink
 	if !keep && t.Sym == nil {
 		// For an unnamed type, we only need the link if the type can
 		// be created at run time by reflect.PtrTo and similar
@@ -1471,7 +1472,7 @@ func genfun(t, it *types.Type) []*obj.LSym {
 	}
 
 	if len(sigs) != 0 {
-		Fatalf("incomplete itab")
+		base.Fatalf("incomplete itab")
 	}
 
 	return out
@@ -1572,7 +1573,7 @@ func dumptabs() {
 	// process ptabs
 	if localpkg.Name == "main" && len(ptabs) > 0 {
 		ot := 0
-		s := Ctxt.Lookup("go.plugin.tabs")
+		s := base.Ctxt.Lookup("go.plugin.tabs")
 		for _, p := range ptabs {
 			// Dump ptab symbol into go.pluginsym package.
 			//
@@ -1591,7 +1592,7 @@ func dumptabs() {
 		ggloblsym(s, int32(ot), int16(obj.RODATA))
 
 		ot = 0
-		s = Ctxt.Lookup("go.plugin.exports")
+		s = base.Ctxt.Lookup("go.plugin.exports")
 		for _, p := range ptabs {
 			ot = dsymptr(s, ot, p.s.Linksym(), 0)
 		}
@@ -1613,7 +1614,7 @@ func dumpbasictypes() {
 	// so this is as good as any.
 	// another possible choice would be package main,
 	// but using runtime means fewer copies in object files.
-	if Ctxt.Pkgpath == "runtime" {
+	if base.Ctxt.Pkgpath == "runtime" {
 		for i := types.EType(1); i <= TBOOL; i++ {
 			dtypesym(types.NewPtr(types.Types[i]))
 		}
@@ -1629,10 +1630,10 @@ func dumpbasictypes() {
 		// add paths for runtime and main, which 6l imports implicitly.
 		dimportpath(Runtimepkg)
 
-		if Flag.Race {
+		if base.Flag.Race {
 			dimportpath(racepkg)
 		}
-		if Flag.MSan {
+		if base.Flag.MSan {
 			dimportpath(msanpkg)
 		}
 		dimportpath(types.NewPkg("main", ""))
@@ -1767,7 +1768,7 @@ func fillptrmask(t *types.Type, ptrmask []byte) {
 func dgcprog(t *types.Type) (*obj.LSym, int64) {
 	dowidth(t)
 	if t.Width == BADWIDTH {
-		Fatalf("dgcprog: %v badwidth", t)
+		base.Fatalf("dgcprog: %v badwidth", t)
 	}
 	lsym := typesymprefix(".gcprog", t).Linksym()
 	var p GCProg
@@ -1776,7 +1777,7 @@ func dgcprog(t *types.Type) (*obj.LSym, int64) {
 	offset := p.w.BitIndex() * int64(Widthptr)
 	p.end()
 	if ptrdata := typeptrdata(t); offset < ptrdata || offset > t.Width {
-		Fatalf("dgcprog: %v: offset=%d but ptrdata=%d size=%d", t, offset, ptrdata, t.Width)
+		base.Fatalf("dgcprog: %v: offset=%d but ptrdata=%d size=%d", t, offset, ptrdata, t.Width)
 	}
 	return lsym, offset
 }
@@ -1791,7 +1792,7 @@ func (p *GCProg) init(lsym *obj.LSym) {
 	p.lsym = lsym
 	p.symoff = 4 // first 4 bytes hold program length
 	p.w.Init(p.writeByte)
-	if Debug.GCProg > 0 {
+	if base.Debug.GCProg > 0 {
 		fmt.Fprintf(os.Stderr, "compile: start GCProg for %v\n", lsym)
 		p.w.Debug(os.Stderr)
 	}
@@ -1805,7 +1806,7 @@ func (p *GCProg) end() {
 	p.w.End()
 	duint32(p.lsym, 0, uint32(p.symoff-4))
 	ggloblsym(p.lsym, int32(p.symoff), obj.DUPOK|obj.RODATA|obj.LOCAL)
-	if Debug.GCProg > 0 {
+	if base.Debug.GCProg > 0 {
 		fmt.Fprintf(os.Stderr, "compile: end GCProg for %v\n", p.lsym)
 	}
 }
@@ -1821,7 +1822,7 @@ func (p *GCProg) emit(t *types.Type, offset int64) {
 	}
 	switch t.Etype {
 	default:
-		Fatalf("GCProg.emit: unexpected type %v", t)
+		base.Fatalf("GCProg.emit: unexpected type %v", t)
 
 	case TSTRING:
 		p.w.Ptr(offset / int64(Widthptr))
@@ -1836,7 +1837,7 @@ func (p *GCProg) emit(t *types.Type, offset int64) {
 	case TARRAY:
 		if t.NumElem() == 0 {
 			// should have been handled by haspointers check above
-			Fatalf("GCProg.emit: empty array")
+			base.Fatalf("GCProg.emit: empty array")
 		}
 
 		// Flatten array-of-array-of-array to just a big array by multiplying counts.
@@ -1869,7 +1870,7 @@ func (p *GCProg) emit(t *types.Type, offset int64) {
 // size bytes of zeros.
 func zeroaddr(size int64) *Node {
 	if size >= 1<<31 {
-		Fatalf("map elem too big %d", size)
+		base.Fatalf("map elem too big %d", size)
 	}
 	if zerosize < size {
 		zerosize = size
diff --git a/src/cmd/compile/internal/gc/scope.go b/src/cmd/compile/internal/gc/scope.go
index e66b859e10..ace1d6bd9c 100644
--- a/src/cmd/compile/internal/gc/scope.go
+++ b/src/cmd/compile/internal/gc/scope.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/internal/dwarf"
 	"cmd/internal/obj"
 	"cmd/internal/src"
@@ -13,7 +14,7 @@ import (
 
 // See golang.org/issue/20390.
 func xposBefore(p, q src.XPos) bool {
-	return Ctxt.PosTable.Pos(p).Before(Ctxt.PosTable.Pos(q))
+	return base.Ctxt.PosTable.Pos(p).Before(base.Ctxt.PosTable.Pos(q))
 }
 
 func findScope(marks []Mark, pos src.XPos) ScopeID {
diff --git a/src/cmd/compile/internal/gc/select.go b/src/cmd/compile/internal/gc/select.go
index 8e6b15af53..8d4c8d2be1 100644
--- a/src/cmd/compile/internal/gc/select.go
+++ b/src/cmd/compile/internal/gc/select.go
@@ -4,7 +4,10 @@
 
 package gc
 
-import "cmd/compile/internal/types"
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/types"
+)
 
 // select
 func typecheckselect(sel *Node) {
@@ -14,18 +17,18 @@ func typecheckselect(sel *Node) {
 	for _, ncase := range sel.List.Slice() {
 		if ncase.Op != OCASE {
 			setlineno(ncase)
-			Fatalf("typecheckselect %v", ncase.Op)
+			base.Fatalf("typecheckselect %v", ncase.Op)
 		}
 
 		if ncase.List.Len() == 0 {
 			// default
 			if def != nil {
-				yyerrorl(ncase.Pos, "multiple defaults in select (first at %v)", def.Line())
+				base.ErrorfAt(ncase.Pos, "multiple defaults in select (first at %v)", def.Line())
 			} else {
 				def = ncase
 			}
 		} else if ncase.List.Len() > 1 {
-			yyerrorl(ncase.Pos, "select cases cannot be lists")
+			base.ErrorfAt(ncase.Pos, "select cases cannot be lists")
 		} else {
 			ncase.List.SetFirst(typecheck(ncase.List.First(), ctxStmt))
 			n := ncase.List.First()
@@ -41,7 +44,7 @@ func typecheckselect(sel *Node) {
 					// on the same line). This matches the approach before 1.10.
 					pos = ncase.Pos
 				}
-				yyerrorl(pos, "select case must be receive, send or assign recv")
+				base.ErrorfAt(pos, "select case must be receive, send or assign recv")
 
 			// convert x = <-c into OSELRECV(x, <-c).
 			// remove implicit conversions; the eventual assignment
@@ -52,7 +55,7 @@ func typecheckselect(sel *Node) {
 				}
 
 				if n.Right.Op != ORECV {
-					yyerrorl(n.Pos, "select assignment must have receive on right hand side")
+					base.ErrorfAt(n.Pos, "select assignment must have receive on right hand side")
 					break
 				}
 
@@ -61,7 +64,7 @@ func typecheckselect(sel *Node) {
 				// convert x, ok = <-c into OSELRECV2(x, <-c) with ntest=ok
 			case OAS2RECV:
 				if n.Right.Op != ORECV {
-					yyerrorl(n.Pos, "select assignment must have receive on right hand side")
+					base.ErrorfAt(n.Pos, "select assignment must have receive on right hand side")
 					break
 				}
 
@@ -84,13 +87,13 @@ func typecheckselect(sel *Node) {
 		typecheckslice(ncase.Nbody.Slice(), ctxStmt)
 	}
 
-	lineno = lno
+	base.Pos = lno
 }
 
 func walkselect(sel *Node) {
 	lno := setlineno(sel)
 	if sel.Nbody.Len() != 0 {
-		Fatalf("double walkselect")
+		base.Fatalf("double walkselect")
 	}
 
 	init := sel.Ninit.Slice()
@@ -102,12 +105,12 @@ func walkselect(sel *Node) {
 	sel.Nbody.Set(init)
 	walkstmtlist(sel.Nbody.Slice())
 
-	lineno = lno
+	base.Pos = lno
 }
 
 func walkselectcases(cases *Nodes) []*Node {
 	ncas := cases.Len()
-	sellineno := lineno
+	sellineno := base.Pos
 
 	// optimization: zero-case select
 	if ncas == 0 {
@@ -125,7 +128,7 @@ func walkselectcases(cases *Nodes) []*Node {
 			n.Ninit.Set(nil)
 			switch n.Op {
 			default:
-				Fatalf("select %v", n.Op)
+				base.Fatalf("select %v", n.Op)
 
 			case OSEND:
 				// already ok
@@ -202,7 +205,7 @@ func walkselectcases(cases *Nodes) []*Node {
 		r.Ninit.Set(cas.Ninit.Slice())
 		switch n.Op {
 		default:
-			Fatalf("select %v", n.Op)
+			base.Fatalf("select %v", n.Op)
 
 		case OSEND:
 			// if selectnbsend(c, v) { body } else { default body }
@@ -245,7 +248,7 @@ func walkselectcases(cases *Nodes) []*Node {
 	var init []*Node
 
 	// generate sel-struct
-	lineno = sellineno
+	base.Pos = sellineno
 	selv := temp(types.NewArray(scasetype(), int64(ncas)))
 	r := nod(OAS, selv, nil)
 	r = typecheck(r, ctxStmt)
@@ -255,7 +258,7 @@ func walkselectcases(cases *Nodes) []*Node {
 	order := temp(types.NewArray(types.Types[TUINT16], 2*int64(ncas)))
 
 	var pc0, pcs *Node
-	if Flag.Race {
+	if base.Flag.Race {
 		pcs = temp(types.NewArray(types.Types[TUINTPTR], int64(ncas)))
 		pc0 = typecheck(nod(OADDR, nod(OINDEX, pcs, nodintconst(0)), nil), ctxExpr)
 	} else {
@@ -278,7 +281,7 @@ func walkselectcases(cases *Nodes) []*Node {
 		var c, elem *Node
 		switch n.Op {
 		default:
-			Fatalf("select %v", n.Op)
+			base.Fatalf("select %v", n.Op)
 		case OSEND:
 			i = nsends
 			nsends++
@@ -308,17 +311,17 @@ func walkselectcases(cases *Nodes) []*Node {
 
 		// TODO(mdempsky): There should be a cleaner way to
 		// handle this.
-		if Flag.Race {
+		if base.Flag.Race {
 			r = mkcall("selectsetpc", nil, nil, nod(OADDR, nod(OINDEX, pcs, nodintconst(int64(i))), nil))
 			init = append(init, r)
 		}
 	}
 	if nsends+nrecvs != ncas {
-		Fatalf("walkselectcases: miscount: %v + %v != %v", nsends, nrecvs, ncas)
+		base.Fatalf("walkselectcases: miscount: %v + %v != %v", nsends, nrecvs, ncas)
 	}
 
 	// run the select
-	lineno = sellineno
+	base.Pos = sellineno
 	chosen := temp(types.Types[TINT])
 	recvOK := temp(types.Types[TBOOL])
 	r = nod(OAS2, nil, nil)
@@ -331,7 +334,7 @@ func walkselectcases(cases *Nodes) []*Node {
 	// selv and order are no longer alive after selectgo.
 	init = append(init, nod(OVARKILL, selv, nil))
 	init = append(init, nod(OVARKILL, order, nil))
-	if Flag.Race {
+	if base.Flag.Race {
 		init = append(init, nod(OVARKILL, pcs, nil))
 	}
 
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 1f89baa3c0..219435d6de 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"fmt"
@@ -40,7 +41,7 @@ func (s *InitSchedule) append(n *Node) {
 // staticInit adds an initialization statement n to the schedule.
 func (s *InitSchedule) staticInit(n *Node) {
 	if !s.tryStaticInit(n) {
-		if Flag.Percent != 0 {
+		if base.Flag.Percent != 0 {
 			Dump("nonstatic", n)
 		}
 		s.append(n)
@@ -62,7 +63,7 @@ func (s *InitSchedule) tryStaticInit(n *Node) bool {
 		return true
 	}
 	lno := setlineno(n)
-	defer func() { lineno = lno }()
+	defer func() { base.Pos = lno }()
 	return s.staticassign(n.Left, n.Right)
 }
 
@@ -256,8 +257,8 @@ func (s *InitSchedule) staticassign(l *Node, r *Node) bool {
 
 	case OCLOSURE:
 		if hasemptycvars(r) {
-			if Debug.Closure > 0 {
-				Warnl(r.Pos, "closure converted to global")
+			if base.Debug.Closure > 0 {
+				base.WarnfAt(r.Pos, "closure converted to global")
 			}
 			// Closures with no captured variables are globals,
 			// so the assignment can be done at link time.
@@ -462,7 +463,7 @@ func isStaticCompositeLiteral(n *Node) bool {
 	case OSTRUCTLIT:
 		for _, r := range n.List.Slice() {
 			if r.Op != OSTRUCTKEY {
-				Fatalf("isStaticCompositeLiteral: rhs not OSTRUCTKEY: %v", r)
+				base.Fatalf("isStaticCompositeLiteral: rhs not OSTRUCTKEY: %v", r)
 			}
 			if !isStaticCompositeLiteral(r.Left) {
 				return false
@@ -517,7 +518,7 @@ func fixedlit(ctxt initContext, kind initKind, n *Node, var_ *Node, init *Nodes)
 			if r.Op == OKEY {
 				k = indexconst(r.Left)
 				if k < 0 {
-					Fatalf("fixedlit: invalid index %v", r.Left)
+					base.Fatalf("fixedlit: invalid index %v", r.Left)
 				}
 				r = r.Right
 			}
@@ -531,7 +532,7 @@ func fixedlit(ctxt initContext, kind initKind, n *Node, var_ *Node, init *Nodes)
 	case OSTRUCTLIT:
 		splitnode = func(r *Node) (*Node, *Node) {
 			if r.Op != OSTRUCTKEY {
-				Fatalf("fixedlit: rhs not OSTRUCTKEY: %v", r)
+				base.Fatalf("fixedlit: rhs not OSTRUCTKEY: %v", r)
 			}
 			if r.Sym.IsBlank() || isBlank {
 				return nblank, r.Left
@@ -540,7 +541,7 @@ func fixedlit(ctxt initContext, kind initKind, n *Node, var_ *Node, init *Nodes)
 			return nodSym(ODOT, var_, r.Sym), r.Left
 		}
 	default:
-		Fatalf("fixedlit bad op: %v", n.Op)
+		base.Fatalf("fixedlit bad op: %v", n.Op)
 	}
 
 	for _, r := range n.List.Slice() {
@@ -578,7 +579,7 @@ func fixedlit(ctxt initContext, kind initKind, n *Node, var_ *Node, init *Nodes)
 			a = walkstmt(a)
 			init.Append(a)
 		default:
-			Fatalf("fixedlit: bad kind %d", kind)
+			base.Fatalf("fixedlit: bad kind %d", kind)
 		}
 
 	}
@@ -610,7 +611,7 @@ func slicelit(ctxt initContext, n *Node, var_ *Node, init *Nodes) {
 		var_ = typecheck(var_, ctxExpr|ctxAssign)
 		nam := stataddr(var_)
 		if nam == nil || nam.Class() != PEXTERN {
-			Fatalf("slicelit: %v", var_)
+			base.Fatalf("slicelit: %v", var_)
 		}
 		slicesym(nam, vstat, t.NumElem())
 		return
@@ -709,7 +710,7 @@ func slicelit(ctxt initContext, n *Node, var_ *Node, init *Nodes) {
 		if value.Op == OKEY {
 			index = indexconst(value.Left)
 			if index < 0 {
-				Fatalf("slicelit: invalid index %v", value.Left)
+				base.Fatalf("slicelit: invalid index %v", value.Left)
 			}
 			value = value.Right
 		}
@@ -770,7 +771,7 @@ func maplit(n *Node, m *Node, init *Nodes) {
 	// All remaining entries are static. Double-check that.
 	for _, r := range entries {
 		if !isStaticCompositeLiteral(r.Left) || !isStaticCompositeLiteral(r.Right) {
-			Fatalf("maplit: entry is not a literal: %v", r)
+			base.Fatalf("maplit: entry is not a literal: %v", r)
 		}
 	}
 
@@ -868,7 +869,7 @@ func anylit(n *Node, var_ *Node, init *Nodes) {
 	t := n.Type
 	switch n.Op {
 	default:
-		Fatalf("anylit: not lit, op=%v node=%v", n.Op, n)
+		base.Fatalf("anylit: not lit, op=%v node=%v", n.Op, n)
 
 	case ONAME, OMETHEXPR:
 		a := nod(OAS, var_, n)
@@ -877,7 +878,7 @@ func anylit(n *Node, var_ *Node, init *Nodes) {
 
 	case OPTRLIT:
 		if !t.IsPtr() {
-			Fatalf("anylit: not ptr")
+			base.Fatalf("anylit: not ptr")
 		}
 
 		var r *Node
@@ -905,7 +906,7 @@ func anylit(n *Node, var_ *Node, init *Nodes) {
 
 	case OSTRUCTLIT, OARRAYLIT:
 		if !t.IsStruct() && !t.IsArray() {
-			Fatalf("anylit: not struct/array")
+			base.Fatalf("anylit: not struct/array")
 		}
 
 		if var_.isSimpleName() && n.List.Len() > 4 {
@@ -951,7 +952,7 @@ func anylit(n *Node, var_ *Node, init *Nodes) {
 
 	case OMAPLIT:
 		if !t.IsMap() {
-			Fatalf("anylit: not map")
+			base.Fatalf("anylit: not map")
 		}
 		maplit(n, var_, init)
 	}
@@ -1052,7 +1053,7 @@ func (s *InitSchedule) initplan(n *Node) {
 	s.initplans[n] = p
 	switch n.Op {
 	default:
-		Fatalf("initplan")
+		base.Fatalf("initplan")
 
 	case OARRAYLIT, OSLICELIT:
 		var k int64
@@ -1060,7 +1061,7 @@ func (s *InitSchedule) initplan(n *Node) {
 			if a.Op == OKEY {
 				k = indexconst(a.Left)
 				if k < 0 {
-					Fatalf("initplan arraylit: invalid index %v", a.Left)
+					base.Fatalf("initplan arraylit: invalid index %v", a.Left)
 				}
 				a = a.Right
 			}
@@ -1071,7 +1072,7 @@ func (s *InitSchedule) initplan(n *Node) {
 	case OSTRUCTLIT:
 		for _, a := range n.List.Slice() {
 			if a.Op != OSTRUCTKEY {
-				Fatalf("initplan structlit")
+				base.Fatalf("initplan structlit")
 			}
 			if a.Sym.IsBlank() {
 				continue
@@ -1082,7 +1083,7 @@ func (s *InitSchedule) initplan(n *Node) {
 	case OMAPLIT:
 		for _, a := range n.List.Slice() {
 			if a.Op != OKEY {
-				Fatalf("initplan maplit")
+				base.Fatalf("initplan maplit")
 			}
 			s.addvalue(p, -1, a.Right)
 		}
@@ -1155,12 +1156,12 @@ func isvaluelit(n *Node) bool {
 
 func genAsStatic(as *Node) {
 	if as.Left.Type == nil {
-		Fatalf("genAsStatic as.Left not typechecked")
+		base.Fatalf("genAsStatic as.Left not typechecked")
 	}
 
 	nam := stataddr(as.Left)
 	if nam == nil || (nam.Class() != PEXTERN && as.Left != nblank) {
-		Fatalf("genAsStatic: lhs %v", as.Left)
+		base.Fatalf("genAsStatic: lhs %v", as.Left)
 	}
 
 	switch {
@@ -1169,6 +1170,6 @@ func genAsStatic(as *Node) {
 	case (as.Right.Op == ONAME || as.Right.Op == OMETHEXPR) && as.Right.Class() == PFUNC:
 		pfuncsym(nam, as.Right)
 	default:
-		Fatalf("genAsStatic: rhs %v", as.Right)
+		base.Fatalf("genAsStatic: rhs %v", as.Right)
 	}
 }
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index f06f08e6ab..e892a01da0 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -15,6 +15,7 @@ import (
 
 	"bufio"
 	"bytes"
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -60,10 +61,10 @@ func initssaconfig() {
 	_ = types.NewPtr(types.Types[TINT64])                             // *int64
 	_ = types.NewPtr(types.Errortype)                                 // *error
 	types.NewPtrCacheEnabled = false
-	ssaConfig = ssa.NewConfig(thearch.LinkArch.Name, *types_, Ctxt, Flag.N == 0)
+	ssaConfig = ssa.NewConfig(thearch.LinkArch.Name, *types_, base.Ctxt, base.Flag.N == 0)
 	ssaConfig.SoftFloat = thearch.SoftFloat
-	ssaConfig.Race = Flag.Race
-	ssaCaches = make([]ssa.Cache, Flag.LowerC)
+	ssaConfig.Race = base.Flag.Race
+	ssaCaches = make([]ssa.Cache, base.Flag.LowerC)
 
 	// Set up some runtime functions we'll need to call.
 	assertE2I = sysfunc("assertE2I")
@@ -240,7 +241,7 @@ func dvarint(x *obj.LSym, off int, v int64) int {
 //      - Size of the argument
 //      - Offset of where argument should be placed in the args frame when making call
 func (s *state) emitOpenDeferInfo() {
-	x := Ctxt.Lookup(s.curfn.Func.lsym.Name + ".opendefer")
+	x := base.Ctxt.Lookup(s.curfn.Func.lsym.Name + ".opendefer")
 	s.curfn.Func.lsym.Func().OpenCodedDeferInfo = x
 	off := 0
 
@@ -291,7 +292,7 @@ func buildssa(fn *Node, worker int) *ssa.Func {
 	name := fn.funcname()
 	printssa := false
 	if ssaDump != "" { // match either a simple name e.g. "(*Reader).Reset", or a package.name e.g. "compress/gzip.(*Reader).Reset"
-		printssa = name == ssaDump || Ctxt.Pkgpath+"."+name == ssaDump
+		printssa = name == ssaDump || base.Ctxt.Pkgpath+"."+name == ssaDump
 	}
 	var astBuf *bytes.Buffer
 	if printssa {
@@ -342,7 +343,7 @@ func buildssa(fn *Node, worker int) *ssa.Func {
 	if printssa {
 		ssaDF := ssaDumpFile
 		if ssaDir != "" {
-			ssaDF = filepath.Join(ssaDir, Ctxt.Pkgpath+"."+name+".html")
+			ssaDF = filepath.Join(ssaDir, base.Ctxt.Pkgpath+"."+name+".html")
 			ssaD := filepath.Dir(ssaDF)
 			os.MkdirAll(ssaD, 0755)
 		}
@@ -358,9 +359,9 @@ func buildssa(fn *Node, worker int) *ssa.Func {
 	s.fwdVars = map[*Node]*ssa.Value{}
 	s.startmem = s.entryNewValue0(ssa.OpInitMem, types.TypeMem)
 
-	s.hasOpenDefers = Flag.N == 0 && s.hasdefer && !s.curfn.Func.OpenCodedDeferDisallowed()
+	s.hasOpenDefers = base.Flag.N == 0 && s.hasdefer && !s.curfn.Func.OpenCodedDeferDisallowed()
 	switch {
-	case s.hasOpenDefers && (Ctxt.Flag_shared || Ctxt.Flag_dynlink) && thearch.LinkArch.Name == "386":
+	case s.hasOpenDefers && (base.Ctxt.Flag_shared || base.Ctxt.Flag_dynlink) && thearch.LinkArch.Name == "386":
 		// Don't support open-coded defers for 386 ONLY when using shared
 		// libraries, because there is extra code (added by rewriteToUseGot())
 		// preceding the deferreturn/ret code that is generated by gencallret()
@@ -478,7 +479,7 @@ func buildssa(fn *Node, worker int) *ssa.Func {
 
 func dumpSourcesColumn(writer *ssa.HTMLWriter, fn *Node) {
 	// Read sources of target function fn.
-	fname := Ctxt.PosTable.Pos(fn.Pos).Filename()
+	fname := base.Ctxt.PosTable.Pos(fn.Pos).Filename()
 	targetFn, err := readFuncLines(fname, fn.Pos.Line(), fn.Func.Endlineno.Line())
 	if err != nil {
 		writer.Logf("cannot read sources for function %v: %v", fn, err)
@@ -494,7 +495,7 @@ func dumpSourcesColumn(writer *ssa.HTMLWriter, fn *Node) {
 		} else {
 			elno = fi.Name.Defn.Func.Endlineno
 		}
-		fname := Ctxt.PosTable.Pos(fi.Pos).Filename()
+		fname := base.Ctxt.PosTable.Pos(fi.Pos).Filename()
 		fnLines, err := readFuncLines(fname, fi.Pos.Line(), elno.Line())
 		if err != nil {
 			writer.Logf("cannot read sources for inlined function %v: %v", fi, err)
@@ -752,8 +753,8 @@ func (s *state) pushLine(line src.XPos) {
 		// the frontend may emit node with line number missing,
 		// use the parent line number in this case.
 		line = s.peekPos()
-		if Flag.K != 0 {
-			Warn("buildssa: unknown position (line 0)")
+		if base.Flag.K != 0 {
+			base.Warn("buildssa: unknown position (line 0)")
 		}
 	} else {
 		s.lastPos = line
@@ -988,13 +989,13 @@ func (s *state) instrument(t *types.Type, addr *ssa.Value, wr bool) {
 	var fn *obj.LSym
 	needWidth := false
 
-	if Flag.MSan {
+	if base.Flag.MSan {
 		fn = msanread
 		if wr {
 			fn = msanwrite
 		}
 		needWidth = true
-	} else if Flag.Race && t.NumComponents(types.CountBlankFields) > 1 {
+	} else if base.Flag.Race && t.NumComponents(types.CountBlankFields) > 1 {
 		// for composite objects we have to write every address
 		// because a write might happen to any subobject.
 		// composites with only one element don't have subobjects, though.
@@ -1003,7 +1004,7 @@ func (s *state) instrument(t *types.Type, addr *ssa.Value, wr bool) {
 			fn = racewriterange
 		}
 		needWidth = true
-	} else if Flag.Race {
+	} else if base.Flag.Race {
 		// for non-composite objects we can write just the start
 		// address, as any write must write the first byte.
 		fn = raceread
@@ -1090,7 +1091,7 @@ func (s *state) stmt(n *Node) {
 	case OCALLMETH, OCALLINTER:
 		s.callResult(n, callNormal)
 		if n.Op == OCALLFUNC && n.Left.Op == ONAME && n.Left.Class() == PFUNC {
-			if fn := n.Left.Sym.Name; Flag.CompilingRuntime && fn == "throw" ||
+			if fn := n.Left.Sym.Name; base.Flag.CompilingRuntime && fn == "throw" ||
 				n.Left.Sym.Pkg == Runtimepkg && (fn == "throwinit" || fn == "gopanic" || fn == "panicwrap" || fn == "block" || fn == "panicmakeslicelen" || fn == "panicmakeslicecap") {
 				m := s.mem()
 				b := s.endBlock()
@@ -1102,7 +1103,7 @@ func (s *state) stmt(n *Node) {
 			}
 		}
 	case ODEFER:
-		if Debug.Defer > 0 {
+		if base.Debug.Defer > 0 {
 			var defertype string
 			if s.hasOpenDefers {
 				defertype = "open-coded"
@@ -1111,7 +1112,7 @@ func (s *state) stmt(n *Node) {
 			} else {
 				defertype = "heap-allocated"
 			}
-			Warnl(n.Pos, "%s defer", defertype)
+			base.WarnfAt(n.Pos, "%s defer", defertype)
 		}
 		if s.hasOpenDefers {
 			s.openDeferRecord(n.Left)
@@ -1225,20 +1226,20 @@ func (s *state) stmt(n *Node) {
 				// Check whether we're writing the result of an append back to the same slice.
 				// If so, we handle it specially to avoid write barriers on the fast
 				// (non-growth) path.
-				if !samesafeexpr(n.Left, rhs.List.First()) || Flag.N != 0 {
+				if !samesafeexpr(n.Left, rhs.List.First()) || base.Flag.N != 0 {
 					break
 				}
 				// If the slice can be SSA'd, it'll be on the stack,
 				// so there will be no write barriers,
 				// so there's no need to attempt to prevent them.
 				if s.canSSA(n.Left) {
-					if Debug.Append > 0 { // replicating old diagnostic message
-						Warnl(n.Pos, "append: len-only update (in local slice)")
+					if base.Debug.Append > 0 { // replicating old diagnostic message
+						base.WarnfAt(n.Pos, "append: len-only update (in local slice)")
 					}
 					break
 				}
-				if Debug.Append > 0 {
-					Warnl(n.Pos, "append: len-only update")
+				if base.Debug.Append > 0 {
+					base.WarnfAt(n.Pos, "append: len-only update")
 				}
 				s.append(rhs, true)
 				return
@@ -1814,7 +1815,7 @@ func floatForComplex(t *types.Type) *types.Type {
 	case TCOMPLEX128:
 		return types.Types[TFLOAT64]
 	}
-	Fatalf("unexpected type: %v", t)
+	base.Fatalf("unexpected type: %v", t)
 	return nil
 }
 
@@ -1825,7 +1826,7 @@ func complexForFloat(t *types.Type) *types.Type {
 	case TFLOAT64:
 		return types.Types[TCOMPLEX128]
 	}
-	Fatalf("unexpected type: %v", t)
+	base.Fatalf("unexpected type: %v", t)
 	return nil
 }
 
@@ -4130,9 +4131,9 @@ func findIntrinsic(sym *types.Sym) intrinsicBuilder {
 	}
 	pkg := sym.Pkg.Path
 	if sym.Pkg == localpkg {
-		pkg = Ctxt.Pkgpath
+		pkg = base.Ctxt.Pkgpath
 	}
-	if Flag.Race && pkg == "sync/atomic" {
+	if base.Flag.Race && pkg == "sync/atomic" {
 		// The race detector needs to be able to intercept these calls.
 		// We can't intrinsify them.
 		return nil
@@ -4172,7 +4173,7 @@ func (s *state) intrinsicCall(n *Node) *ssa.Value {
 		if x.Op == ssa.OpSelect0 || x.Op == ssa.OpSelect1 {
 			x = x.Args[0]
 		}
-		Warnl(n.Pos, "intrinsic substitution for %v with %s", n.Left.Sym.Name, x.LongString())
+		base.WarnfAt(n.Pos, "intrinsic substitution for %v with %s", n.Left.Sym.Name, x.LongString())
 	}
 	return v
 }
@@ -4240,7 +4241,7 @@ func (s *state) openDeferRecord(n *Node) {
 		}
 	} else if n.Op == OCALLMETH {
 		if fn.Op != ODOTMETH {
-			Fatalf("OCALLMETH: n.Left not an ODOTMETH: %v", fn)
+			base.Fatalf("OCALLMETH: n.Left not an ODOTMETH: %v", fn)
 		}
 		closureVal := s.getMethodClosure(fn)
 		// We must always store the function value in a stack slot for the
@@ -4250,7 +4251,7 @@ func (s *state) openDeferRecord(n *Node) {
 		opendefer.closureNode = closure.Aux.(*Node)
 	} else {
 		if fn.Op != ODOTINTER {
-			Fatalf("OCALLINTER: n.Left not an ODOTINTER: %v", fn.Op)
+			base.Fatalf("OCALLINTER: n.Left not an ODOTINTER: %v", fn.Op)
 		}
 		closure, rcvr := s.getClosureAndRcvr(fn)
 		opendefer.closure = s.openDeferSave(nil, closure.Type, closure)
@@ -4382,7 +4383,7 @@ func (s *state) openDeferExit() {
 		// Generate code to call the function call of the defer, using the
 		// closure/receiver/args that were stored in argtmps at the point
 		// of the defer statement.
-		argStart := Ctxt.FixedFrameSize()
+		argStart := base.Ctxt.FixedFrameSize()
 		fn := r.n.Left
 		stksize := fn.Type.ArgWidth()
 		var ACArgs []ssa.Param
@@ -4499,7 +4500,7 @@ func (s *state) call(n *Node, k callKind, returnResultAddr bool) *ssa.Value {
 		nf := res.NumFields()
 		for i := 0; i < nf; i++ {
 			fp := res.Field(i)
-			ACResults = append(ACResults, ssa.Param{Type: fp.Type, Offset: int32(fp.Offset + Ctxt.FixedFrameSize())})
+			ACResults = append(ACResults, ssa.Param{Type: fp.Type, Offset: int32(fp.Offset + base.Ctxt.FixedFrameSize())})
 		}
 	}
 
@@ -4604,14 +4605,14 @@ func (s *state) call(n *Node, k callKind, returnResultAddr bool) *ssa.Value {
 		}
 
 		// Call runtime.deferprocStack with pointer to _defer record.
-		ACArgs = append(ACArgs, ssa.Param{Type: types.Types[TUINTPTR], Offset: int32(Ctxt.FixedFrameSize())})
+		ACArgs = append(ACArgs, ssa.Param{Type: types.Types[TUINTPTR], Offset: int32(base.Ctxt.FixedFrameSize())})
 		aux := ssa.StaticAuxCall(deferprocStack, ACArgs, ACResults)
 		if testLateExpansion {
 			callArgs = append(callArgs, addr, s.mem())
 			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 			call.AddArgs(callArgs...)
 		} else {
-			arg0 := s.constOffPtrSP(types.Types[TUINTPTR], Ctxt.FixedFrameSize())
+			arg0 := s.constOffPtrSP(types.Types[TUINTPTR], base.Ctxt.FixedFrameSize())
 			s.store(types.Types[TUINTPTR], arg0, addr)
 			call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, aux, s.mem())
 		}
@@ -4625,7 +4626,7 @@ func (s *state) call(n *Node, k callKind, returnResultAddr bool) *ssa.Value {
 	} else {
 		// Store arguments to stack, including defer/go arguments and receiver for method calls.
 		// These are written in SP-offset order.
-		argStart := Ctxt.FixedFrameSize()
+		argStart := base.Ctxt.FixedFrameSize()
 		// Defer/go args.
 		if k != callNormal {
 			// Write argsize and closure (args to newproc/deferproc).
@@ -4766,13 +4767,13 @@ func (s *state) call(n *Node, k callKind, returnResultAddr bool) *ssa.Value {
 		if testLateExpansion {
 			return s.newValue1I(ssa.OpSelectNAddr, pt, 0, call)
 		}
-		return s.constOffPtrSP(pt, fp.Offset+Ctxt.FixedFrameSize())
+		return s.constOffPtrSP(pt, fp.Offset+base.Ctxt.FixedFrameSize())
 	}
 
 	if testLateExpansion {
 		return s.newValue1I(ssa.OpSelectN, fp.Type, 0, call)
 	}
-	return s.load(n.Type, s.constOffPtrSP(types.NewPtr(fp.Type), fp.Offset+Ctxt.FixedFrameSize()))
+	return s.load(n.Type, s.constOffPtrSP(types.NewPtr(fp.Type), fp.Offset+base.Ctxt.FixedFrameSize()))
 }
 
 // maybeNilCheckClosure checks if a nil check of a closure is needed in some
@@ -4930,7 +4931,7 @@ func (s *state) addr(n *Node) *ssa.Value {
 // canSSA reports whether n is SSA-able.
 // n must be an ONAME (or an ODOT sequence with an ONAME base).
 func (s *state) canSSA(n *Node) bool {
-	if Flag.N != 0 {
+	if base.Flag.N != 0 {
 		return false
 	}
 	for n.Op == ODOT || (n.Op == OINDEX && n.Left.Type.IsArray()) {
@@ -5026,7 +5027,7 @@ func (s *state) exprPtr(n *Node, bounded bool, lineno src.XPos) *ssa.Value {
 // Used only for automatically inserted nil checks,
 // not for user code like 'x != nil'.
 func (s *state) nilCheck(ptr *ssa.Value) {
-	if Debug.DisableNil != 0 || s.curfn.Func.NilCheckDisabled() {
+	if base.Debug.DisableNil != 0 || s.curfn.Func.NilCheckDisabled() {
 		return
 	}
 	s.newValue2(ssa.OpNilCheck, types.TypeVoid, ptr, s.mem())
@@ -5041,7 +5042,7 @@ func (s *state) nilCheck(ptr *ssa.Value) {
 func (s *state) boundsCheck(idx, len *ssa.Value, kind ssa.BoundsKind, bounded bool) *ssa.Value {
 	idx = s.extendIndex(idx, len, kind, bounded)
 
-	if bounded || Flag.B != 0 {
+	if bounded || base.Flag.B != 0 {
 		// If bounded or bounds checking is flag-disabled, then no check necessary,
 		// just return the extended index.
 		//
@@ -5114,7 +5115,7 @@ func (s *state) boundsCheck(idx, len *ssa.Value, kind ssa.BoundsKind, bounded bo
 	s.startBlock(bNext)
 
 	// In Spectre index mode, apply an appropriate mask to avoid speculative out-of-bounds accesses.
-	if Flag.Cfg.SpectreIndex {
+	if base.Flag.Cfg.SpectreIndex {
 		op := ssa.OpSpectreIndex
 		if kind != ssa.BoundsIndex && kind != ssa.BoundsIndexU {
 			op = ssa.OpSpectreSliceIndex
@@ -5133,7 +5134,7 @@ func (s *state) check(cmp *ssa.Value, fn *obj.LSym) {
 	b.Likely = ssa.BranchLikely
 	bNext := s.f.NewBlock(ssa.BlockPlain)
 	line := s.peekPos()
-	pos := Ctxt.PosTable.Pos(line)
+	pos := base.Ctxt.PosTable.Pos(line)
 	fl := funcLine{f: fn, base: pos.Base(), line: pos.Line()}
 	bPanic := s.panics[fl]
 	if bPanic == nil {
@@ -5172,7 +5173,7 @@ func (s *state) intDivide(n *Node, a, b *ssa.Value) *ssa.Value {
 func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args ...*ssa.Value) []*ssa.Value {
 	s.prevCall = nil
 	// Write args to the stack
-	off := Ctxt.FixedFrameSize()
+	off := base.Ctxt.FixedFrameSize()
 	testLateExpansion := ssa.LateCallExpansionEnabledWithin(s.f)
 	var ACArgs []ssa.Param
 	var ACResults []ssa.Param
@@ -5219,7 +5220,7 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
 		b := s.endBlock()
 		b.Kind = ssa.BlockExit
 		b.SetControl(call)
-		call.AuxInt = off - Ctxt.FixedFrameSize()
+		call.AuxInt = off - base.Ctxt.FixedFrameSize()
 		if len(results) > 0 {
 			s.Fatalf("panic call can't have results")
 		}
@@ -5837,8 +5838,8 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
 		if n.Type.IsEmptyInterface() {
 			// Converting to an empty interface.
 			// Input could be an empty or nonempty interface.
-			if Debug.TypeAssert > 0 {
-				Warnl(n.Pos, "type assertion inlined")
+			if base.Debug.TypeAssert > 0 {
+				base.WarnfAt(n.Pos, "type assertion inlined")
 			}
 
 			// Get itab/type field from input.
@@ -5904,8 +5905,8 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
 			return
 		}
 		// converting to a nonempty interface needs a runtime call.
-		if Debug.TypeAssert > 0 {
-			Warnl(n.Pos, "type assertion not inlined")
+		if base.Debug.TypeAssert > 0 {
+			base.WarnfAt(n.Pos, "type assertion not inlined")
 		}
 		if n.Left.Type.IsEmptyInterface() {
 			if commaok {
@@ -5921,15 +5922,15 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
 		return s.rtcall(assertI2I, true, []*types.Type{n.Type}, target, iface)[0], nil
 	}
 
-	if Debug.TypeAssert > 0 {
-		Warnl(n.Pos, "type assertion inlined")
+	if base.Debug.TypeAssert > 0 {
+		base.WarnfAt(n.Pos, "type assertion inlined")
 	}
 
 	// Converting to a concrete type.
 	direct := isdirectiface(n.Type)
 	itab := s.newValue1(ssa.OpITab, byteptr, iface) // type word of interface
-	if Debug.TypeAssert > 0 {
-		Warnl(n.Pos, "type assertion inlined")
+	if base.Debug.TypeAssert > 0 {
+		base.WarnfAt(n.Pos, "type assertion inlined")
 	}
 	var targetITab *ssa.Value
 	if n.Left.Type.IsEmptyInterface() {
@@ -6235,9 +6236,9 @@ func emitStackObjects(e *ssafn, pp *Progs) {
 	p.To.Name = obj.NAME_EXTERN
 	p.To.Sym = x
 
-	if Flag.Live != 0 {
+	if base.Flag.Live != 0 {
 		for _, v := range vars {
-			Warnl(v.Pos, "stack object %v %s", v, v.Type.String())
+			base.WarnfAt(v.Pos, "stack object %v %s", v, v.Type.String())
 		}
 	}
 }
@@ -6277,7 +6278,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 
 	s.ScratchFpMem = e.scratchFpMem
 
-	if Ctxt.Flag_locationlists {
+	if base.Ctxt.Flag_locationlists {
 		if cap(f.Cache.ValueToProgAfter) < f.NumValues() {
 			f.Cache.ValueToProgAfter = make([]*obj.Prog, f.NumValues())
 		}
@@ -6373,7 +6374,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 				thearch.SSAGenValue(&s, v)
 			}
 
-			if Ctxt.Flag_locationlists {
+			if base.Ctxt.Flag_locationlists {
 				valueToProgAfter[v.ID] = s.pp.next
 			}
 
@@ -6397,7 +6398,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 		}
 		// Emit control flow instructions for block
 		var next *ssa.Block
-		if i < len(f.Blocks)-1 && Flag.N == 0 {
+		if i < len(f.Blocks)-1 && base.Flag.N == 0 {
 			// If -N, leave next==nil so every block with successors
 			// ends in a JMP (except call blocks - plive doesn't like
 			// select{send,recv} followed by a JMP call).  Helps keep
@@ -6473,8 +6474,8 @@ func genssa(f *ssa.Func, pp *Progs) {
 		}
 	}
 
-	if Ctxt.Flag_locationlists {
-		e.curfn.Func.DebugInfo = ssa.BuildFuncDebug(Ctxt, f, Debug.LocationLists > 1, stackOffset)
+	if base.Ctxt.Flag_locationlists {
+		e.curfn.Func.DebugInfo = ssa.BuildFuncDebug(base.Ctxt, f, base.Debug.LocationLists > 1, stackOffset)
 		bstart := s.bstart
 		// Note that at this moment, Prog.Pc is a sequence number; it's
 		// not a real PC until after assembly, so this mapping has to
@@ -6705,7 +6706,7 @@ func (s *state) extendIndex(idx, len *ssa.Value, kind ssa.BoundsKind, bounded bo
 		} else {
 			lo = s.newValue1(ssa.OpInt64Lo, types.Types[TUINT], idx)
 		}
-		if bounded || Flag.B != 0 {
+		if bounded || base.Flag.B != 0 {
 			return lo
 		}
 		bNext := s.f.NewBlock(ssa.BlockPlain)
@@ -6807,7 +6808,7 @@ func CheckLoweredPhi(v *ssa.Value) {
 func CheckLoweredGetClosurePtr(v *ssa.Value) {
 	entry := v.Block.Func.Entry
 	if entry != v.Block || entry.Values[0] != v {
-		Fatalf("in %s, badly placed LoweredGetClosurePtr: %v %v", v.Block.Func.Name, v.Block, v)
+		base.Fatalf("in %s, badly placed LoweredGetClosurePtr: %v %v", v.Block.Func.Name, v.Block, v)
 	}
 }
 
@@ -6869,7 +6870,7 @@ func (s *SSAGenState) Call(v *ssa.Value) *obj.Prog {
 		case sys.ARM, sys.ARM64, sys.MIPS, sys.MIPS64:
 			p.To.Type = obj.TYPE_MEM
 		default:
-			Fatalf("unknown indirect call family")
+			base.Fatalf("unknown indirect call family")
 		}
 		p.To.Reg = v.Args[0].Reg()
 	}
@@ -6884,7 +6885,7 @@ func (s *SSAGenState) PrepareCall(v *ssa.Value) {
 	if !idx.StackMapValid() {
 		// See Liveness.hasStackMap.
 		if sym, ok := v.Aux.(*ssa.AuxCall); !ok || !(sym.Fn == typedmemclr || sym.Fn == typedmemmove) {
-			Fatalf("missing stack map index for %v", v.LongString())
+			base.Fatalf("missing stack map index for %v", v.LongString())
 		}
 	}
 
@@ -7085,7 +7086,7 @@ func (e *ssafn) CanSSA(t *types.Type) bool {
 }
 
 func (e *ssafn) Line(pos src.XPos) string {
-	return linestr(pos)
+	return base.FmtPos(pos)
 }
 
 // Log logs a message from the compiler.
@@ -7101,23 +7102,23 @@ func (e *ssafn) Log() bool {
 
 // Fatal reports a compiler error and exits.
 func (e *ssafn) Fatalf(pos src.XPos, msg string, args ...interface{}) {
-	lineno = pos
+	base.Pos = pos
 	nargs := append([]interface{}{e.curfn.funcname()}, args...)
-	Fatalf("'%s': "+msg, nargs...)
+	base.Fatalf("'%s': "+msg, nargs...)
 }
 
 // Warnl reports a "warning", which is usually flag-triggered
 // logging output for the benefit of tests.
 func (e *ssafn) Warnl(pos src.XPos, fmt_ string, args ...interface{}) {
-	Warnl(pos, fmt_, args...)
+	base.WarnfAt(pos, fmt_, args...)
 }
 
 func (e *ssafn) Debug_checknil() bool {
-	return Debug.Nil != 0
+	return base.Debug.Nil != 0
 }
 
 func (e *ssafn) UseWriteBarrier() bool {
-	return Flag.WB
+	return base.Flag.WB
 }
 
 func (e *ssafn) Syslook(name string) *obj.LSym {
@@ -7142,7 +7143,7 @@ func (e *ssafn) SetWBPos(pos src.XPos) {
 }
 
 func (e *ssafn) MyImportPath() string {
-	return Ctxt.Pkgpath
+	return base.Ctxt.Pkgpath
 }
 
 func (n *Node) Typ() *types.Type {
@@ -7157,7 +7158,7 @@ func (n *Node) StorageClass() ssa.StorageClass {
 	case PAUTO:
 		return ssa.ClassAuto
 	default:
-		Fatalf("untranslatable storage class for %v: %s", n, n.Class())
+		base.Fatalf("untranslatable storage class for %v: %s", n, n.Class())
 		return 0
 	}
 }
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 989d10a561..00402a1bee 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"crypto/md5"
@@ -49,8 +50,8 @@ func hasUniquePos(n *Node) bool {
 	}
 
 	if !n.Pos.IsKnown() {
-		if Flag.K != 0 {
-			Warn("setlineno: unknown position (line 0)")
+		if base.Flag.K != 0 {
+			base.Warn("setlineno: unknown position (line 0)")
 		}
 		return false
 	}
@@ -59,9 +60,9 @@ func hasUniquePos(n *Node) bool {
 }
 
 func setlineno(n *Node) src.XPos {
-	lno := lineno
+	lno := base.Pos
 	if n != nil && hasUniquePos(n) {
-		lineno = n.Pos
+		base.Pos = n.Pos
 	}
 	return lno
 }
@@ -87,11 +88,11 @@ func lookupN(prefix string, n int) *types.Sym {
 // user labels.
 func autolabel(prefix string) *types.Sym {
 	if prefix[0] != '.' {
-		Fatalf("autolabel prefix must start with '.', have %q", prefix)
+		base.Fatalf("autolabel prefix must start with '.', have %q", prefix)
 	}
 	fn := Curfn
 	if Curfn == nil {
-		Fatalf("autolabel outside function")
+		base.Fatalf("autolabel outside function")
 	}
 	n := fn.Func.Label
 	fn.Func.Label++
@@ -112,7 +113,7 @@ func importdot(opkg *types.Pkg, pack *Node) {
 		s1 := lookup(s.Name)
 		if s1.Def != nil {
 			pkgerror := fmt.Sprintf("during import %q", opkg.Path)
-			redeclare(lineno, s1, pkgerror)
+			redeclare(base.Pos, s1, pkgerror)
 			continue
 		}
 
@@ -120,7 +121,7 @@ func importdot(opkg *types.Pkg, pack *Node) {
 		s1.Block = s.Block
 		if asNode(s1.Def).Name == nil {
 			Dump("s1def", asNode(s1.Def))
-			Fatalf("missing Name")
+			base.Fatalf("missing Name")
 		}
 		asNode(s1.Def).Name.Pack = pack
 		s1.Origpkg = opkg
@@ -129,12 +130,12 @@ func importdot(opkg *types.Pkg, pack *Node) {
 
 	if n == 0 {
 		// can't possibly be used - there were no symbols
-		yyerrorl(pack.Pos, "imported and not used: %q", opkg.Path)
+		base.ErrorfAt(pack.Pos, "imported and not used: %q", opkg.Path)
 	}
 }
 
 func nod(op Op, nleft, nright *Node) *Node {
-	return nodl(lineno, op, nleft, nright)
+	return nodl(base.Pos, op, nleft, nright)
 }
 
 func nodl(pos src.XPos, op Op, nleft, nright *Node) *Node {
@@ -149,7 +150,7 @@ func nodl(pos src.XPos, op Op, nleft, nright *Node) *Node {
 		n.Func = &x.f
 		n.Func.Decl = n
 	case ONAME:
-		Fatalf("use newname instead")
+		base.Fatalf("use newname instead")
 	case OLABEL, OPACK:
 		var x struct {
 			n Node
@@ -171,7 +172,7 @@ func nodl(pos src.XPos, op Op, nleft, nright *Node) *Node {
 
 // newname returns a new ONAME Node associated with symbol s.
 func newname(s *types.Sym) *Node {
-	n := newnamel(lineno, s)
+	n := newnamel(base.Pos, s)
 	n.Name.Curfn = Curfn
 	return n
 }
@@ -180,7 +181,7 @@ func newname(s *types.Sym) *Node {
 // The caller is responsible for setting n.Name.Curfn.
 func newnamel(pos src.XPos, s *types.Sym) *Node {
 	if s == nil {
-		Fatalf("newnamel nil")
+		base.Fatalf("newnamel nil")
 	}
 
 	var x struct {
@@ -203,7 +204,7 @@ func newnamel(pos src.XPos, s *types.Sym) *Node {
 // nodSym makes a Node with Op op and with the Left field set to left
 // and the Sym field set to sym. This is for ODOT and friends.
 func nodSym(op Op, left *Node, sym *types.Sym) *Node {
-	return nodlSym(lineno, op, left, sym)
+	return nodlSym(base.Pos, op, left, sym)
 }
 
 // nodlSym makes a Node with position Pos, with Op op, and with the Left field set to left
@@ -290,7 +291,7 @@ func treecopy(n *Node, pos src.XPos) *Node {
 		}
 		if m.Name != nil && n.Op != ODCLFIELD {
 			Dump("treecopy", n)
-			Fatalf("treecopy Name")
+			base.Fatalf("treecopy Name")
 		}
 		return m
 
@@ -625,7 +626,7 @@ func assignconvfn(n *Node, t *types.Type, context func() string) *Node {
 	}
 
 	if t.Etype == TBLANK && n.Type.Etype == TNIL {
-		yyerror("use of untyped nil")
+		base.Errorf("use of untyped nil")
 	}
 
 	n = convlit1(n, t, false, context)
@@ -654,7 +655,7 @@ func assignconvfn(n *Node, t *types.Type, context func() string) *Node {
 
 	op, why := assignop(n.Type, t)
 	if op == OXXX {
-		yyerror("cannot use %L as type %v in %s%s", n, t, context(), why)
+		base.Errorf("cannot use %L as type %v in %s%s", n, t, context(), why)
 		op = OCONV
 	}
 
@@ -687,7 +688,7 @@ func (n *Node) SliceBounds() (low, high, max *Node) {
 		s := n.List.Slice()
 		return s[0], s[1], s[2]
 	}
-	Fatalf("SliceBounds op %v: %v", n.Op, n)
+	base.Fatalf("SliceBounds op %v: %v", n.Op, n)
 	return nil, nil, nil
 }
 
@@ -697,7 +698,7 @@ func (n *Node) SetSliceBounds(low, high, max *Node) {
 	switch n.Op {
 	case OSLICE, OSLICEARR, OSLICESTR:
 		if max != nil {
-			Fatalf("SetSliceBounds %v given three bounds", n.Op)
+			base.Fatalf("SetSliceBounds %v given three bounds", n.Op)
 		}
 		s := n.List.Slice()
 		if s == nil {
@@ -724,7 +725,7 @@ func (n *Node) SetSliceBounds(low, high, max *Node) {
 		s[2] = max
 		return
 	}
-	Fatalf("SetSliceBounds op %v: %v", n.Op, n)
+	base.Fatalf("SetSliceBounds op %v: %v", n.Op, n)
 }
 
 // IsSlice3 reports whether o is a slice3 op (OSLICE3, OSLICE3ARR).
@@ -736,7 +737,7 @@ func (o Op) IsSlice3() bool {
 	case OSLICE3, OSLICE3ARR:
 		return true
 	}
-	Fatalf("IsSlice3 op %v", o)
+	base.Fatalf("IsSlice3 op %v", o)
 	return false
 }
 
@@ -746,7 +747,7 @@ func (n *Node) backingArrayPtrLen() (ptr, len *Node) {
 	var init Nodes
 	c := cheapexpr(n, &init)
 	if c != n || init.Len() != 0 {
-		Fatalf("backingArrayPtrLen not cheap: %v", n)
+		base.Fatalf("backingArrayPtrLen not cheap: %v", n)
 	}
 	ptr = nod(OSPTR, n, nil)
 	if n.Type.IsString() {
@@ -763,7 +764,7 @@ func (n *Node) backingArrayPtrLen() (ptr, len *Node) {
 // associated with the label n, if any.
 func (n *Node) labeledControl() *Node {
 	if n.Op != OLABEL {
-		Fatalf("labeledControl %v", n.Op)
+		base.Fatalf("labeledControl %v", n.Op)
 	}
 	ctl := n.Name.Defn
 	if ctl == nil {
@@ -779,7 +780,7 @@ func (n *Node) labeledControl() *Node {
 func syslook(name string) *Node {
 	s := Runtimepkg.Lookup(name)
 	if s == nil || s.Def == nil {
-		Fatalf("syslook: can't find runtime.%s", name)
+		base.Fatalf("syslook: can't find runtime.%s", name)
 	}
 	return asNode(s.Def)
 }
@@ -811,7 +812,7 @@ func calcHasCall(n *Node) bool {
 	switch n.Op {
 	case OLITERAL, ONIL, ONAME, OTYPE:
 		if n.HasCall() {
-			Fatalf("OLITERAL/ONAME/OTYPE should never have calls: %+v", n)
+			base.Fatalf("OLITERAL/ONAME/OTYPE should never have calls: %+v", n)
 		}
 		return false
 	case OCALL, OCALLFUNC, OCALLMETH, OCALLINTER:
@@ -870,7 +871,7 @@ func badtype(op Op, tl, tr *types.Type) {
 		}
 	}
 
-	yyerror("illegal types for operand: %v%s", op, s)
+	base.Errorf("illegal types for operand: %v%s", op, s)
 }
 
 // brcom returns !(op).
@@ -890,7 +891,7 @@ func brcom(op Op) Op {
 	case OGE:
 		return OLT
 	}
-	Fatalf("brcom: no com for %v\n", op)
+	base.Fatalf("brcom: no com for %v\n", op)
 	return op
 }
 
@@ -911,7 +912,7 @@ func brrev(op Op) Op {
 	case OGE:
 		return OLE
 	}
-	Fatalf("brrev: no rev for %v\n", op)
+	base.Fatalf("brrev: no rev for %v\n", op)
 	return op
 }
 
@@ -972,7 +973,7 @@ func safeexpr(n *Node, init *Nodes) *Node {
 
 	// make a copy; must not be used as an lvalue
 	if islvalue(n) {
-		Fatalf("missing lvalue case in safeexpr: %v", n)
+		base.Fatalf("missing lvalue case in safeexpr: %v", n)
 	}
 	return cheapexpr(n, init)
 }
@@ -1161,7 +1162,7 @@ func adddot(n *Node) *Node {
 			n.Left.SetImplicit(true)
 		}
 	case ambig:
-		yyerror("ambiguous selector %v", n)
+		base.Errorf("ambiguous selector %v", n)
 		n.Left = nil
 	}
 
@@ -1334,7 +1335,7 @@ func structargs(tl *types.Type, mustname bool) []*Node {
 //	method - M func (t T)(), a TFIELD type struct
 //	newnam - the eventual mangled name of this function
 func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
-	if false && Flag.LowerR != 0 {
+	if false && base.Flag.LowerR != 0 {
 		fmt.Printf("genwrapper rcvrtype=%v method=%v newnam=%v\n", rcvr, method, newnam)
 	}
 
@@ -1350,7 +1351,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 		return
 	}
 
-	lineno = autogeneratedPos
+	base.Pos = autogeneratedPos
 	dclcontext = PEXTERN
 
 	tfn := nod(OTFUNC, nil, nil)
@@ -1384,7 +1385,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	// the TOC to the appropriate value for that module. But if it returns
 	// directly to the wrapper's caller, nothing will reset it to the correct
 	// value for that function.
-	if !instrumenting && rcvr.IsPtr() && methodrcvr.IsPtr() && method.Embedded != 0 && !isifacemethod(method.Type) && !(thearch.LinkArch.Name == "ppc64le" && Ctxt.Flag_dynlink) {
+	if !instrumenting && rcvr.IsPtr() && methodrcvr.IsPtr() && method.Embedded != 0 && !isifacemethod(method.Type) && !(thearch.LinkArch.Name == "ppc64le" && base.Ctxt.Flag_dynlink) {
 		// generate tail call: adjust pointer receiver and jump to embedded method.
 		dot = dot.Left // skip final .M
 		// TODO(mdempsky): Remove dependency on dotlist.
@@ -1407,12 +1408,12 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 		fn.Nbody.Append(call)
 	}
 
-	if false && Flag.LowerR != 0 {
+	if false && base.Flag.LowerR != 0 {
 		dumplist("genwrapper body", fn.Nbody)
 	}
 
 	funcbody()
-	if Debug.DclStack != 0 {
+	if base.Debug.DclStack != 0 {
 		testdclstack()
 	}
 
@@ -1464,7 +1465,7 @@ func ifacelookdot(s *types.Sym, t *types.Type, ignorecase bool) (m *types.Field,
 	path, ambig := dotpath(s, t, &m, ignorecase)
 	if path == nil {
 		if ambig {
-			yyerror("%v.%v is ambiguous", t, s)
+			base.Errorf("%v.%v is ambiguous", t, s)
 		}
 		return nil, false
 	}
@@ -1477,7 +1478,7 @@ func ifacelookdot(s *types.Sym, t *types.Type, ignorecase bool) (m *types.Field,
 	}
 
 	if !m.IsMethod() {
-		yyerror("%v.%v is a field, not a method", t, s)
+		base.Errorf("%v.%v is a field, not a method", t, s)
 		return nil, followptr
 	}
 
@@ -1548,8 +1549,8 @@ func implements(t, iface *types.Type, m, samename **types.Field, ptr *int) bool
 		// the method does not exist for value types.
 		rcvr := tm.Type.Recv().Type
 		if rcvr.IsPtr() && !t0.IsPtr() && !followptr && !isifacemethod(tm.Type) {
-			if false && Flag.LowerR != 0 {
-				yyerror("interface pointer mismatch")
+			if false && base.Flag.LowerR != 0 {
+				base.Errorf("interface pointer mismatch")
 			}
 
 			*m = im
@@ -1624,40 +1625,40 @@ var reservedimports = []string{
 
 func isbadimport(path string, allowSpace bool) bool {
 	if strings.Contains(path, "\x00") {
-		yyerror("import path contains NUL")
+		base.Errorf("import path contains NUL")
 		return true
 	}
 
 	for _, ri := range reservedimports {
 		if path == ri {
-			yyerror("import path %q is reserved and cannot be used", path)
+			base.Errorf("import path %q is reserved and cannot be used", path)
 			return true
 		}
 	}
 
 	for _, r := range path {
 		if r == utf8.RuneError {
-			yyerror("import path contains invalid UTF-8 sequence: %q", path)
+			base.Errorf("import path contains invalid UTF-8 sequence: %q", path)
 			return true
 		}
 
 		if r < 0x20 || r == 0x7f {
-			yyerror("import path contains control character: %q", path)
+			base.Errorf("import path contains control character: %q", path)
 			return true
 		}
 
 		if r == '\\' {
-			yyerror("import path contains backslash; use slash: %q", path)
+			base.Errorf("import path contains backslash; use slash: %q", path)
 			return true
 		}
 
 		if !allowSpace && unicode.IsSpace(r) {
-			yyerror("import path contains space character: %q", path)
+			base.Errorf("import path contains space character: %q", path)
 			return true
 		}
 
 		if strings.ContainsRune("!\"#$%&'()*,:;<=>?[]^`{|}", r) {
-			yyerror("import path contains invalid character '%c': %q", r, path)
+			base.Errorf("import path contains invalid character '%c': %q", r, path)
 			return true
 		}
 	}
@@ -1709,7 +1710,7 @@ func itabType(itab *Node) *Node {
 // It follows the pointer if !isdirectiface(t).
 func ifaceData(pos src.XPos, n *Node, t *types.Type) *Node {
 	if t.IsInterface() {
-		Fatalf("ifaceData interface: %v", t)
+		base.Fatalf("ifaceData interface: %v", t)
 	}
 	ptr := nodlSym(pos, OIDATA, n, nil)
 	if isdirectiface(t) {
@@ -1731,7 +1732,7 @@ func ifaceData(pos src.XPos, n *Node, t *types.Type) *Node {
 func typePos(t *types.Type) src.XPos {
 	n := asNode(t.Nod)
 	if n == nil || !n.Pos.IsKnown() {
-		Fatalf("bad type: %v", t)
+		base.Fatalf("bad type: %v", t)
 	}
 	return n.Pos
 }
diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index c249a85b64..7befbdf06c 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"go/constant"
@@ -26,7 +27,7 @@ func typecheckTypeSwitch(n *Node) {
 	n.Left.Right = typecheck(n.Left.Right, ctxExpr)
 	t := n.Left.Right.Type
 	if t != nil && !t.IsInterface() {
-		yyerrorl(n.Pos, "cannot type switch on non-interface value %L", n.Left.Right)
+		base.ErrorfAt(n.Pos, "cannot type switch on non-interface value %L", n.Left.Right)
 		t = nil
 	}
 
@@ -34,7 +35,7 @@ func typecheckTypeSwitch(n *Node) {
 	// declaration itself. So if there are no cases, we won't
 	// notice that it went unused.
 	if v := n.Left.Left; v != nil && !v.isBlank() && n.List.Len() == 0 {
-		yyerrorl(v.Pos, "%v declared but not used", v.Sym)
+		base.ErrorfAt(v.Pos, "%v declared but not used", v.Sym)
 	}
 
 	var defCase, nilCase *Node
@@ -43,7 +44,7 @@ func typecheckTypeSwitch(n *Node) {
 		ls := ncase.List.Slice()
 		if len(ls) == 0 { // default:
 			if defCase != nil {
-				yyerrorl(ncase.Pos, "multiple defaults in switch (first at %v)", defCase.Line())
+				base.ErrorfAt(ncase.Pos, "multiple defaults in switch (first at %v)", defCase.Line())
 			} else {
 				defCase = ncase
 			}
@@ -61,21 +62,21 @@ func typecheckTypeSwitch(n *Node) {
 			switch {
 			case n1.isNil(): // case nil:
 				if nilCase != nil {
-					yyerrorl(ncase.Pos, "multiple nil cases in type switch (first at %v)", nilCase.Line())
+					base.ErrorfAt(ncase.Pos, "multiple nil cases in type switch (first at %v)", nilCase.Line())
 				} else {
 					nilCase = ncase
 				}
 			case n1.Op != OTYPE:
-				yyerrorl(ncase.Pos, "%L is not a type", n1)
+				base.ErrorfAt(ncase.Pos, "%L is not a type", n1)
 			case !n1.Type.IsInterface() && !implements(n1.Type, t, &missing, &have, &ptr) && !missing.Broke():
 				if have != nil && !have.Broke() {
-					yyerrorl(ncase.Pos, "impossible type switch case: %L cannot have dynamic type %v"+
+					base.ErrorfAt(ncase.Pos, "impossible type switch case: %L cannot have dynamic type %v"+
 						" (wrong type for %v method)\n\thave %v%S\n\twant %v%S", n.Left.Right, n1.Type, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
 				} else if ptr != 0 {
-					yyerrorl(ncase.Pos, "impossible type switch case: %L cannot have dynamic type %v"+
+					base.ErrorfAt(ncase.Pos, "impossible type switch case: %L cannot have dynamic type %v"+
 						" (%v method has pointer receiver)", n.Left.Right, n1.Type, missing.Sym)
 				} else {
-					yyerrorl(ncase.Pos, "impossible type switch case: %L cannot have dynamic type %v"+
+					base.ErrorfAt(ncase.Pos, "impossible type switch case: %L cannot have dynamic type %v"+
 						" (missing %v method)", n.Left.Right, n1.Type, missing.Sym)
 				}
 			}
@@ -135,7 +136,7 @@ func (s *typeSet) add(pos src.XPos, typ *types.Type) {
 	prevs := s.m[ls]
 	for _, prev := range prevs {
 		if types.Identical(typ, prev.typ) {
-			yyerrorl(pos, "duplicate case %v in type switch\n\tprevious case at %s", typ, linestr(prev.pos))
+			base.ErrorfAt(pos, "duplicate case %v in type switch\n\tprevious case at %s", typ, base.FmtPos(prev.pos))
 			return
 		}
 	}
@@ -162,9 +163,9 @@ func typecheckExprSwitch(n *Node) {
 
 		case !IsComparable(t):
 			if t.IsStruct() {
-				yyerrorl(n.Pos, "cannot switch on %L (struct containing %v cannot be compared)", n.Left, IncomparableField(t).Type)
+				base.ErrorfAt(n.Pos, "cannot switch on %L (struct containing %v cannot be compared)", n.Left, IncomparableField(t).Type)
 			} else {
-				yyerrorl(n.Pos, "cannot switch on %L", n.Left)
+				base.ErrorfAt(n.Pos, "cannot switch on %L", n.Left)
 			}
 			t = nil
 		}
@@ -176,7 +177,7 @@ func typecheckExprSwitch(n *Node) {
 		ls := ncase.List.Slice()
 		if len(ls) == 0 { // default:
 			if defCase != nil {
-				yyerrorl(ncase.Pos, "multiple defaults in switch (first at %v)", defCase.Line())
+				base.ErrorfAt(ncase.Pos, "multiple defaults in switch (first at %v)", defCase.Line())
 			} else {
 				defCase = ncase
 			}
@@ -192,17 +193,17 @@ func typecheckExprSwitch(n *Node) {
 			}
 
 			if nilonly != "" && !n1.isNil() {
-				yyerrorl(ncase.Pos, "invalid case %v in switch (can only compare %s %v to nil)", n1, nilonly, n.Left)
+				base.ErrorfAt(ncase.Pos, "invalid case %v in switch (can only compare %s %v to nil)", n1, nilonly, n.Left)
 			} else if t.IsInterface() && !n1.Type.IsInterface() && !IsComparable(n1.Type) {
-				yyerrorl(ncase.Pos, "invalid case %L in switch (incomparable type)", n1)
+				base.ErrorfAt(ncase.Pos, "invalid case %L in switch (incomparable type)", n1)
 			} else {
 				op1, _ := assignop(n1.Type, t)
 				op2, _ := assignop(t, n1.Type)
 				if op1 == OXXX && op2 == OXXX {
 					if n.Left != nil {
-						yyerrorl(ncase.Pos, "invalid case %v in switch on %v (mismatched types %v and %v)", n1, n.Left, n1.Type, t)
+						base.ErrorfAt(ncase.Pos, "invalid case %v in switch on %v (mismatched types %v and %v)", n1, n.Left, n1.Type, t)
 					} else {
-						yyerrorl(ncase.Pos, "invalid case %v in switch (mismatched types %v and bool)", n1, n1.Type)
+						base.ErrorfAt(ncase.Pos, "invalid case %v in switch (mismatched types %v and bool)", n1, n1.Type)
 					}
 				}
 			}
@@ -267,7 +268,7 @@ func walkExprSwitch(sw *Node) {
 		cond = copyexpr(cond, cond.Type, &sw.Nbody)
 	}
 
-	lineno = lno
+	base.Pos = lno
 
 	s := exprSwitch{
 		exprname: cond,
@@ -282,7 +283,7 @@ func walkExprSwitch(sw *Node) {
 		// Process case dispatch.
 		if ncase.List.Len() == 0 {
 			if defaultGoto != nil {
-				Fatalf("duplicate default case not detected during typechecking")
+				base.Fatalf("duplicate default case not detected during typechecking")
 			}
 			defaultGoto = jmp
 		}
@@ -464,7 +465,7 @@ func allCaseExprsAreSideEffectFree(sw *Node) bool {
 
 	for _, ncase := range sw.List.Slice() {
 		if ncase.Op != OCASE {
-			Fatalf("switch string(byteslice) bad op: %v", ncase.Op)
+			base.Fatalf("switch string(byteslice) bad op: %v", ncase.Op)
 		}
 		for _, v := range ncase.List.Slice() {
 			if v.Op != OLITERAL {
@@ -517,7 +518,7 @@ func walkTypeSwitch(sw *Node) {
 	// Use a similar strategy for non-empty interfaces.
 	ifNil := nod(OIF, nil, nil)
 	ifNil.Left = nod(OEQ, itab, nodnil())
-	lineno = lineno.WithNotStmt() // disable statement marks after the first check.
+	base.Pos = base.Pos.WithNotStmt() // disable statement marks after the first check.
 	ifNil.Left = typecheck(ifNil.Left, ctxExpr)
 	ifNil.Left = defaultlit(ifNil.Left, nil)
 	// ifNil.Nbody assigned at end.
@@ -558,7 +559,7 @@ func walkTypeSwitch(sw *Node) {
 
 		if ncase.List.Len() == 0 { // default:
 			if defaultGoto != nil {
-				Fatalf("duplicate default case not detected during typechecking")
+				base.Fatalf("duplicate default case not detected during typechecking")
 			}
 			defaultGoto = jmp
 		}
@@ -566,7 +567,7 @@ func walkTypeSwitch(sw *Node) {
 		for _, n1 := range ncase.List.Slice() {
 			if n1.isNil() { // case nil:
 				if nilGoto != nil {
-					Fatalf("duplicate nil case not detected during typechecking")
+					base.Fatalf("duplicate nil case not detected during typechecking")
 				}
 				nilGoto = jmp
 				continue
@@ -586,7 +587,7 @@ func walkTypeSwitch(sw *Node) {
 			if singleType != nil {
 				// We have a single concrete type. Extract the data.
 				if singleType.IsInterface() {
-					Fatalf("singleType interface should have been handled in Add")
+					base.Fatalf("singleType interface should have been handled in Add")
 				}
 				val = ifaceData(ncase.Pos, s.facename, singleType)
 			}
@@ -733,7 +734,7 @@ func binarySearch(n int, out *Nodes, less func(i int) *Node, leaf func(i int, ni
 			for i := lo; i < hi; i++ {
 				nif := nod(OIF, nil, nil)
 				leaf(i, nif)
-				lineno = lineno.WithNotStmt()
+				base.Pos = base.Pos.WithNotStmt()
 				nif.Left = typecheck(nif.Left, ctxExpr)
 				nif.Left = defaultlit(nif.Left, nil)
 				out.Append(nif)
@@ -745,7 +746,7 @@ func binarySearch(n int, out *Nodes, less func(i int) *Node, leaf func(i int, ni
 		half := lo + n/2
 		nif := nod(OIF, nil, nil)
 		nif.Left = less(half)
-		lineno = lineno.WithNotStmt()
+		base.Pos = base.Pos.WithNotStmt()
 		nif.Left = typecheck(nif.Left, ctxExpr)
 		nif.Left = defaultlit(nif.Left, nil)
 		do(lo, half, &nif.Nbody)
diff --git a/src/cmd/compile/internal/gc/syntax.go b/src/cmd/compile/internal/gc/syntax.go
index f771a7184e..11671fc54a 100644
--- a/src/cmd/compile/internal/gc/syntax.go
+++ b/src/cmd/compile/internal/gc/syntax.go
@@ -7,6 +7,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -106,7 +107,7 @@ func (n *Node) SubOp() Op {
 	switch n.Op {
 	case OASOP, ONAME:
 	default:
-		Fatalf("unexpected op: %v", n.Op)
+		base.Fatalf("unexpected op: %v", n.Op)
 	}
 	return Op(n.aux)
 }
@@ -115,21 +116,21 @@ func (n *Node) SetSubOp(op Op) {
 	switch n.Op {
 	case OASOP, ONAME:
 	default:
-		Fatalf("unexpected op: %v", n.Op)
+		base.Fatalf("unexpected op: %v", n.Op)
 	}
 	n.aux = uint8(op)
 }
 
 func (n *Node) IndexMapLValue() bool {
 	if n.Op != OINDEXMAP {
-		Fatalf("unexpected op: %v", n.Op)
+		base.Fatalf("unexpected op: %v", n.Op)
 	}
 	return n.aux != 0
 }
 
 func (n *Node) SetIndexMapLValue(b bool) {
 	if n.Op != OINDEXMAP {
-		Fatalf("unexpected op: %v", n.Op)
+		base.Fatalf("unexpected op: %v", n.Op)
 	}
 	if b {
 		n.aux = 1
@@ -140,14 +141,14 @@ func (n *Node) SetIndexMapLValue(b bool) {
 
 func (n *Node) TChanDir() types.ChanDir {
 	if n.Op != OTCHAN {
-		Fatalf("unexpected op: %v", n.Op)
+		base.Fatalf("unexpected op: %v", n.Op)
 	}
 	return types.ChanDir(n.aux)
 }
 
 func (n *Node) SetTChanDir(dir types.ChanDir) {
 	if n.Op != OTCHAN {
-		Fatalf("unexpected op: %v", n.Op)
+		base.Fatalf("unexpected op: %v", n.Op)
 	}
 	n.aux = uint8(dir)
 }
@@ -236,7 +237,7 @@ func (n *Node) SetEmbedded(b bool)  { n.flags.set(nodeEmbedded, b) }
 // inserted before dereferencing. See state.exprPtr.
 func (n *Node) MarkNonNil() {
 	if !n.Type.IsPtr() && !n.Type.IsUnsafePtr() {
-		Fatalf("MarkNonNil(%v), type %v", n, n.Type)
+		base.Fatalf("MarkNonNil(%v), type %v", n, n.Type)
 	}
 	n.flags.set(nodeNonNil, true)
 }
@@ -255,7 +256,7 @@ func (n *Node) SetBounded(b bool) {
 		// No length and cap checks needed
 		// since new slice and copied over slice data have same length.
 	default:
-		Fatalf("SetBounded(%v)", n)
+		base.Fatalf("SetBounded(%v)", n)
 	}
 	n.flags.set(nodeBounded, b)
 }
@@ -263,7 +264,7 @@ func (n *Node) SetBounded(b bool) {
 // MarkReadonly indicates that n is an ONAME with readonly contents.
 func (n *Node) MarkReadonly() {
 	if n.Op != ONAME {
-		Fatalf("Node.MarkReadonly %v", n.Op)
+		base.Fatalf("Node.MarkReadonly %v", n.Op)
 	}
 	n.Name.SetReadonly(true)
 	// Mark the linksym as readonly immediately
@@ -284,9 +285,9 @@ func (n *Node) Val() constant.Value {
 // which must not have been used with SetOpt.
 func (n *Node) SetVal(v constant.Value) {
 	if n.HasOpt() {
-		Flag.LowerH = 1
+		base.Flag.LowerH = 1
 		Dump("have Opt", n)
-		Fatalf("have Opt")
+		base.Fatalf("have Opt")
 	}
 	if n.Op == OLITERAL {
 		assertRepresents(n.Type, v)
@@ -314,9 +315,9 @@ func (n *Node) SetOpt(x interface{}) {
 		return
 	}
 	if n.HasVal() {
-		Flag.LowerH = 1
+		base.Flag.LowerH = 1
 		Dump("have Val", n)
-		Fatalf("have Val")
+		base.Fatalf("have Val")
 	}
 	n.SetHasOpt(true)
 	n.E = x
@@ -367,7 +368,7 @@ func (n *Node) pkgFuncName() string {
 	}
 	pkg := s.Pkg
 
-	p := Ctxt.Pkgpath
+	p := base.Ctxt.Pkgpath
 	if pkg != nil && pkg.Path != "" {
 		p = pkg.Path
 	}
@@ -764,8 +765,8 @@ func (f *Func) SetInstrumentBody(b bool)           { f.flags.set(funcInstrumentB
 func (f *Func) SetOpenCodedDeferDisallowed(b bool) { f.flags.set(funcOpenCodedDeferDisallowed, b) }
 
 func (f *Func) setWBPos(pos src.XPos) {
-	if Debug.WB != 0 {
-		Warnl(pos, "write barrier")
+	if base.Debug.WB != 0 {
+		base.WarnfAt(pos, "write barrier")
 	}
 	if !f.WBPos.IsKnown() {
 		f.WBPos = pos
diff --git a/src/cmd/compile/internal/gc/trace.go b/src/cmd/compile/internal/gc/trace.go
index ed4b5a268d..c6eb23a090 100644
--- a/src/cmd/compile/internal/gc/trace.go
+++ b/src/cmd/compile/internal/gc/trace.go
@@ -9,6 +9,8 @@ package gc
 import (
 	"os"
 	tracepkg "runtime/trace"
+
+	"cmd/compile/internal/base"
 )
 
 func init() {
@@ -18,10 +20,10 @@ func init() {
 func traceHandlerGo17(traceprofile string) {
 	f, err := os.Create(traceprofile)
 	if err != nil {
-		Fatalf("%v", err)
+		base.Fatalf("%v", err)
 	}
 	if err := tracepkg.Start(f); err != nil {
-		Fatalf("%v", err)
+		base.Fatalf("%v", err)
 	}
-	atExit(tracepkg.Stop)
+	base.AtExit(tracepkg.Stop)
 }
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 7b299e553b..b61b9b0525 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"fmt"
 	"go/constant"
@@ -25,7 +26,7 @@ func tracePrint(title string, n *Node) func(np **Node) {
 	var pos, op string
 	var tc uint8
 	if n != nil {
-		pos = linestr(n.Pos)
+		pos = base.FmtPos(n.Pos)
 		op = n.Op.String()
 		tc = n.Typecheck()
 	}
@@ -48,7 +49,7 @@ func tracePrint(title string, n *Node) func(np **Node) {
 		var tc uint8
 		var typ *types.Type
 		if n != nil {
-			pos = linestr(n.Pos)
+			pos = base.FmtPos(n.Pos)
 			op = n.Op.String()
 			tc = n.Typecheck()
 			typ = n.Type
@@ -84,13 +85,13 @@ func resolve(n *Node) (res *Node) {
 	}
 
 	// only trace if there's work to do
-	if enableTrace && Flag.LowerT {
+	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("resolve", n)(&res)
 	}
 
 	if n.Sym.Pkg != localpkg {
 		if inimport {
-			Fatalf("recursive inimport")
+			base.Fatalf("recursive inimport")
 		}
 		inimport = true
 		expandDecl(n)
@@ -203,7 +204,7 @@ var typecheck_tcstack []*Node
 func typecheck(n *Node, top int) (res *Node) {
 	// cannot type check until all the source has been parsed
 	if !typecheckok {
-		Fatalf("early typecheck")
+		base.Fatalf("early typecheck")
 	}
 
 	if n == nil {
@@ -211,7 +212,7 @@ func typecheck(n *Node, top int) (res *Node) {
 	}
 
 	// only trace if there's work to do
-	if enableTrace && Flag.LowerT {
+	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheck", n)(&res)
 	}
 
@@ -233,7 +234,7 @@ func typecheck(n *Node, top int) (res *Node) {
 			break
 
 		default:
-			lineno = lno
+			base.Pos = lno
 			return n
 		}
 	}
@@ -245,7 +246,7 @@ func typecheck(n *Node, top int) (res *Node) {
 		// We can already diagnose variables used as types.
 		case ONAME:
 			if top&(ctxExpr|ctxType) == ctxType {
-				yyerror("%v is not a type", n)
+				base.Errorf("%v is not a type", n)
 			}
 
 		case OTYPE:
@@ -263,34 +264,34 @@ func typecheck(n *Node, top int) (res *Node) {
 						// with aliases that we can't handle properly yet.
 						// Report an error rather than crashing later.
 						if n.Name != nil && n.Name.Param.Alias() && n.Type == nil {
-							lineno = n.Pos
-							Fatalf("cannot handle alias type declaration (issue #25838): %v", n)
+							base.Pos = n.Pos
+							base.Fatalf("cannot handle alias type declaration (issue #25838): %v", n)
 						}
-						lineno = lno
+						base.Pos = lno
 						return n
 					}
 				}
-				yyerrorl(n.Pos, "invalid recursive type alias %v%s", n, cycleTrace(cycle))
+				base.ErrorfAt(n.Pos, "invalid recursive type alias %v%s", n, cycleTrace(cycle))
 			}
 
 		case OLITERAL:
 			if top&(ctxExpr|ctxType) == ctxType {
-				yyerror("%v is not a type", n)
+				base.Errorf("%v is not a type", n)
 				break
 			}
-			yyerrorl(n.Pos, "constant definition loop%s", cycleTrace(cycleFor(n)))
+			base.ErrorfAt(n.Pos, "constant definition loop%s", cycleTrace(cycleFor(n)))
 		}
 
-		if Errors() == 0 {
+		if base.Errors() == 0 {
 			var trace string
 			for i := len(typecheck_tcstack) - 1; i >= 0; i-- {
 				x := typecheck_tcstack[i]
 				trace += fmt.Sprintf("\n\t%v %v", x.Line(), x)
 			}
-			yyerror("typechecking loop involving %v%s", n, trace)
+			base.Errorf("typechecking loop involving %v%s", n, trace)
 		}
 
-		lineno = lno
+		base.Pos = lno
 		return n
 	}
 
@@ -305,7 +306,7 @@ func typecheck(n *Node, top int) (res *Node) {
 	typecheck_tcstack[last] = nil
 	typecheck_tcstack = typecheck_tcstack[:last]
 
-	lineno = lno
+	base.Pos = lno
 	return n
 }
 
@@ -325,7 +326,7 @@ func indexlit(n *Node) *Node {
 // The result of typecheck1 MUST be assigned back to n, e.g.
 // 	n.Left = typecheck1(n.Left, top)
 func typecheck1(n *Node, top int) (res *Node) {
-	if enableTrace && Flag.LowerT {
+	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheck1", n)(&res)
 	}
 
@@ -336,7 +337,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		}
 
 		if n.Op == ONAME && n.SubOp() != 0 && top&ctxCallee == 0 {
-			yyerror("use of builtin %v not in function call", n.Sym)
+			base.Errorf("use of builtin %v not in function call", n.Sym)
 			n.Type = nil
 			return n
 		}
@@ -354,14 +355,14 @@ func typecheck1(n *Node, top int) (res *Node) {
 	default:
 		Dump("typecheck", n)
 
-		Fatalf("typecheck %v", n.Op)
+		base.Fatalf("typecheck %v", n.Op)
 
 	// names
 	case OLITERAL:
 		ok |= ctxExpr
 
 		if n.Type == nil && n.Val().Kind() == constant.String {
-			Fatalf("string literal missing type")
+			base.Fatalf("string literal missing type")
 		}
 
 	case ONIL, ONONAME:
@@ -379,7 +380,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		if top&ctxAssign == 0 {
 			// not a write to the variable
 			if n.isBlank() {
-				yyerror("cannot use _ as value")
+				base.Errorf("cannot use _ as value")
 				n.Type = nil
 				return n
 			}
@@ -390,7 +391,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		ok |= ctxExpr
 
 	case OPACK:
-		yyerror("use of package %v without selector", n.Sym)
+		base.Errorf("use of package %v without selector", n.Sym)
 		n.Type = nil
 		return n
 
@@ -419,7 +420,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		} else if n.Left.Op == ODDD {
 			if !n.Diag() {
 				n.SetDiag(true)
-				yyerror("use of [...] array outside of array literal")
+				base.Errorf("use of [...] array outside of array literal")
 			}
 			n.Type = nil
 			return n
@@ -431,9 +432,9 @@ func typecheck1(n *Node, top int) (res *Node) {
 				case l.Type == nil:
 					// Error already reported elsewhere.
 				case l.Type.IsInteger() && l.Op != OLITERAL:
-					yyerror("non-constant array bound %v", l)
+					base.Errorf("non-constant array bound %v", l)
 				default:
-					yyerror("invalid array bound %v", l)
+					base.Errorf("invalid array bound %v", l)
 				}
 				n.Type = nil
 				return n
@@ -441,13 +442,13 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 			v := l.Val()
 			if doesoverflow(v, types.Types[TINT]) {
-				yyerror("array bound is too large")
+				base.Errorf("array bound is too large")
 				n.Type = nil
 				return n
 			}
 
 			if constant.Sign(v) < 0 {
-				yyerror("array bound must be non-negative")
+				base.Errorf("array bound must be non-negative")
 				n.Type = nil
 				return n
 			}
@@ -472,10 +473,10 @@ func typecheck1(n *Node, top int) (res *Node) {
 			return n
 		}
 		if l.Type.NotInHeap() {
-			yyerror("incomplete (or unallocatable) map key not allowed")
+			base.Errorf("incomplete (or unallocatable) map key not allowed")
 		}
 		if r.Type.NotInHeap() {
-			yyerror("incomplete (or unallocatable) map value not allowed")
+			base.Errorf("incomplete (or unallocatable) map value not allowed")
 		}
 
 		setTypeNode(n, types.NewMap(l.Type, r.Type))
@@ -492,7 +493,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			return n
 		}
 		if l.Type.NotInHeap() {
-			yyerror("chan of incomplete (or unallocatable) type not allowed")
+			base.Errorf("chan of incomplete (or unallocatable) type not allowed")
 		}
 
 		setTypeNode(n, types.NewChan(l.Type, n.TChanDir()))
@@ -535,7 +536,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 		if !t.IsPtr() {
 			if top&(ctxExpr|ctxStmt) != 0 {
-				yyerror("invalid indirect of %L", n.Left)
+				base.Errorf("invalid indirect of %L", n.Left)
 				n.Type = nil
 				return n
 			}
@@ -582,7 +583,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 				return n
 			}
 			if n.Implicit() && !okforarith[l.Type.Etype] {
-				yyerror("invalid operation: %v (non-numeric type %v)", n, l.Type)
+				base.Errorf("invalid operation: %v (non-numeric type %v)", n, l.Type)
 				n.Type = nil
 				return n
 			}
@@ -605,18 +606,18 @@ func typecheck1(n *Node, top int) (res *Node) {
 			n.Right = r
 			t := r.Type
 			if !t.IsInteger() {
-				yyerror("invalid operation: %v (shift count type %v, must be integer)", n, r.Type)
+				base.Errorf("invalid operation: %v (shift count type %v, must be integer)", n, r.Type)
 				n.Type = nil
 				return n
 			}
 			if t.IsSigned() && !langSupported(1, 13, curpkg()) {
-				yyerrorv("go1.13", "invalid operation: %v (signed shift count type %v)", n, r.Type)
+				base.ErrorfVers("go1.13", "invalid operation: %v (signed shift count type %v)", n, r.Type)
 				n.Type = nil
 				return n
 			}
 			t = l.Type
 			if t != nil && t.Etype != TIDEAL && !t.IsInteger() {
-				yyerror("invalid operation: %v (shift of type %v)", n, t)
+				base.Errorf("invalid operation: %v (shift of type %v)", n, t)
 				n.Type = nil
 				return n
 			}
@@ -636,12 +637,12 @@ func typecheck1(n *Node, top int) (res *Node) {
 		// can't be converted to int (see issue #41500).
 		if n.Op == OANDAND || n.Op == OOROR {
 			if !n.Left.Type.IsBoolean() {
-				yyerror("invalid operation: %v (operator %v not defined on %s)", n, n.Op, typekind(n.Left.Type))
+				base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op, typekind(n.Left.Type))
 				n.Type = nil
 				return n
 			}
 			if !n.Right.Type.IsBoolean() {
-				yyerror("invalid operation: %v (operator %v not defined on %s)", n, n.Op, typekind(n.Right.Type))
+				base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op, typekind(n.Right.Type))
 				n.Type = nil
 				return n
 			}
@@ -678,7 +679,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 				aop, _ = assignop(l.Type, r.Type)
 				if aop != OXXX {
 					if r.Type.IsInterface() && !l.Type.IsInterface() && !IsComparable(l.Type) {
-						yyerror("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(l.Type))
+						base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(l.Type))
 						n.Type = nil
 						return n
 					}
@@ -700,7 +701,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 				aop, _ = assignop(r.Type, l.Type)
 				if aop != OXXX {
 					if l.Type.IsInterface() && !r.Type.IsInterface() && !IsComparable(r.Type) {
-						yyerror("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(r.Type))
+						base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(r.Type))
 						n.Type = nil
 						return n
 					}
@@ -727,7 +728,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 				return n
 			}
 			if l.Type.IsInterface() == r.Type.IsInterface() || aop == 0 {
-				yyerror("invalid operation: %v (mismatched types %v and %v)", n, l.Type, r.Type)
+				base.Errorf("invalid operation: %v (mismatched types %v and %v)", n, l.Type, r.Type)
 				n.Type = nil
 				return n
 			}
@@ -737,7 +738,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			t = mixUntyped(l.Type, r.Type)
 		}
 		if dt := defaultType(t); !okfor[op][dt.Etype] {
-			yyerror("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(t))
+			base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(t))
 			n.Type = nil
 			return n
 		}
@@ -745,32 +746,32 @@ func typecheck1(n *Node, top int) (res *Node) {
 		// okfor allows any array == array, map == map, func == func.
 		// restrict to slice/map/func == nil and nil == slice/map/func.
 		if l.Type.IsArray() && !IsComparable(l.Type) {
-			yyerror("invalid operation: %v (%v cannot be compared)", n, l.Type)
+			base.Errorf("invalid operation: %v (%v cannot be compared)", n, l.Type)
 			n.Type = nil
 			return n
 		}
 
 		if l.Type.IsSlice() && !l.isNil() && !r.isNil() {
-			yyerror("invalid operation: %v (slice can only be compared to nil)", n)
+			base.Errorf("invalid operation: %v (slice can only be compared to nil)", n)
 			n.Type = nil
 			return n
 		}
 
 		if l.Type.IsMap() && !l.isNil() && !r.isNil() {
-			yyerror("invalid operation: %v (map can only be compared to nil)", n)
+			base.Errorf("invalid operation: %v (map can only be compared to nil)", n)
 			n.Type = nil
 			return n
 		}
 
 		if l.Type.Etype == TFUNC && !l.isNil() && !r.isNil() {
-			yyerror("invalid operation: %v (func can only be compared to nil)", n)
+			base.Errorf("invalid operation: %v (func can only be compared to nil)", n)
 			n.Type = nil
 			return n
 		}
 
 		if l.Type.IsStruct() {
 			if f := IncomparableField(l.Type); f != nil {
-				yyerror("invalid operation: %v (struct containing %v cannot be compared)", n, f.Type)
+				base.Errorf("invalid operation: %v (struct containing %v cannot be compared)", n, f.Type)
 				n.Type = nil
 				return n
 			}
@@ -806,7 +807,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 		if (op == ODIV || op == OMOD) && Isconst(r, constant.Int) {
 			if constant.Sign(r.Val()) == 0 {
-				yyerror("division by zero")
+				base.Errorf("division by zero")
 				n.Type = nil
 				return n
 			}
@@ -824,7 +825,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			return n
 		}
 		if !okfor[n.Op][defaultType(t).Etype] {
-			yyerror("invalid operation: %v (operator %v not defined on %s)", n, n.Op, typekind(t))
+			base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op, typekind(t))
 			n.Type = nil
 			return n
 		}
@@ -850,7 +851,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			r := outervalue(n.Left)
 			if r.Op == ONAME {
 				if r.Orig != r {
-					Fatalf("found non-orig name node %v", r) // TODO(mdempsky): What does this mean?
+					base.Fatalf("found non-orig name node %v", r) // TODO(mdempsky): What does this mean?
 				}
 				r.Name.SetAddrtaken(true)
 				if r.Name.IsClosureVar() && !capturevarscomplete {
@@ -893,7 +894,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 		t := n.Left.Type
 		if t == nil {
-			UpdateErrorDot(n.Line(), n.Left.String(), n.String())
+			base.UpdateErrorDot(n.Line(), n.Left.String(), n.String())
 			n.Type = nil
 			return n
 		}
@@ -920,7 +921,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		}
 
 		if n.Sym.IsBlank() {
-			yyerror("cannot refer to blank field or method")
+			base.Errorf("cannot refer to blank field or method")
 			n.Type = nil
 			return n
 		}
@@ -929,21 +930,21 @@ func typecheck1(n *Node, top int) (res *Node) {
 			// Legitimate field or method lookup failed, try to explain the error
 			switch {
 			case t.IsEmptyInterface():
-				yyerror("%v undefined (type %v is interface with no methods)", n, n.Left.Type)
+				base.Errorf("%v undefined (type %v is interface with no methods)", n, n.Left.Type)
 
 			case t.IsPtr() && t.Elem().IsInterface():
 				// Pointer to interface is almost always a mistake.
-				yyerror("%v undefined (type %v is pointer to interface, not interface)", n, n.Left.Type)
+				base.Errorf("%v undefined (type %v is pointer to interface, not interface)", n, n.Left.Type)
 
 			case lookdot(n, t, 1) != nil:
 				// Field or method matches by name, but it is not exported.
-				yyerror("%v undefined (cannot refer to unexported field or method %v)", n, n.Sym)
+				base.Errorf("%v undefined (cannot refer to unexported field or method %v)", n, n.Sym)
 
 			default:
 				if mt := lookdot(n, t, 2); mt != nil && visible(mt.Sym) { // Case-insensitive lookup.
-					yyerror("%v undefined (type %v has no field or method %v, but does have %v)", n, n.Left.Type, n.Sym, mt.Sym)
+					base.Errorf("%v undefined (type %v has no field or method %v, but does have %v)", n, n.Left.Type, n.Sym, mt.Sym)
 				} else {
-					yyerror("%v undefined (type %v has no field or method %v)", n, n.Left.Type, n.Sym)
+					base.Errorf("%v undefined (type %v has no field or method %v)", n, n.Left.Type, n.Sym)
 				}
 			}
 			n.Type = nil
@@ -974,7 +975,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			return n
 		}
 		if !t.IsInterface() {
-			yyerror("invalid type assertion: %v (non-interface type %v on left)", n, t)
+			base.Errorf("invalid type assertion: %v (non-interface type %v on left)", n, t)
 			n.Type = nil
 			return n
 		}
@@ -993,15 +994,15 @@ func typecheck1(n *Node, top int) (res *Node) {
 			var ptr int
 			if !implements(n.Type, t, &missing, &have, &ptr) {
 				if have != nil && have.Sym == missing.Sym {
-					yyerror("impossible type assertion:\n\t%v does not implement %v (wrong type for %v method)\n"+
+					base.Errorf("impossible type assertion:\n\t%v does not implement %v (wrong type for %v method)\n"+
 						"\t\thave %v%0S\n\t\twant %v%0S", n.Type, t, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
 				} else if ptr != 0 {
-					yyerror("impossible type assertion:\n\t%v does not implement %v (%v method has pointer receiver)", n.Type, t, missing.Sym)
+					base.Errorf("impossible type assertion:\n\t%v does not implement %v (%v method has pointer receiver)", n.Type, t, missing.Sym)
 				} else if have != nil {
-					yyerror("impossible type assertion:\n\t%v does not implement %v (missing %v method)\n"+
+					base.Errorf("impossible type assertion:\n\t%v does not implement %v (missing %v method)\n"+
 						"\t\thave %v%0S\n\t\twant %v%0S", n.Type, t, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
 				} else {
-					yyerror("impossible type assertion:\n\t%v does not implement %v (missing %v method)", n.Type, t, missing.Sym)
+					base.Errorf("impossible type assertion:\n\t%v does not implement %v (missing %v method)", n.Type, t, missing.Sym)
 				}
 				n.Type = nil
 				return n
@@ -1023,7 +1024,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		}
 		switch t.Etype {
 		default:
-			yyerror("invalid operation: %v (type %v does not support indexing)", n, t)
+			base.Errorf("invalid operation: %v (type %v does not support indexing)", n, t)
 			n.Type = nil
 			return n
 
@@ -1042,20 +1043,20 @@ func typecheck1(n *Node, top int) (res *Node) {
 			}
 
 			if n.Right.Type != nil && !n.Right.Type.IsInteger() {
-				yyerror("non-integer %s index %v", why, n.Right)
+				base.Errorf("non-integer %s index %v", why, n.Right)
 				break
 			}
 
 			if !n.Bounded() && Isconst(n.Right, constant.Int) {
 				x := n.Right.Val()
 				if constant.Sign(x) < 0 {
-					yyerror("invalid %s index %v (index must be non-negative)", why, n.Right)
+					base.Errorf("invalid %s index %v (index must be non-negative)", why, n.Right)
 				} else if t.IsArray() && constant.Compare(x, token.GEQ, constant.MakeInt64(t.NumElem())) {
-					yyerror("invalid array index %v (out of bounds for %d-element array)", n.Right, t.NumElem())
+					base.Errorf("invalid array index %v (out of bounds for %d-element array)", n.Right, t.NumElem())
 				} else if Isconst(n.Left, constant.String) && constant.Compare(x, token.GEQ, constant.MakeInt64(int64(len(n.Left.StringVal())))) {
-					yyerror("invalid string index %v (out of bounds for %d-byte string)", n.Right, len(n.Left.StringVal()))
+					base.Errorf("invalid string index %v (out of bounds for %d-byte string)", n.Right, len(n.Left.StringVal()))
 				} else if doesoverflow(x, types.Types[TINT]) {
-					yyerror("invalid %s index %v (index too large)", why, n.Right)
+					base.Errorf("invalid %s index %v (index too large)", why, n.Right)
 				}
 			}
 
@@ -1077,13 +1078,13 @@ func typecheck1(n *Node, top int) (res *Node) {
 			return n
 		}
 		if !t.IsChan() {
-			yyerror("invalid operation: %v (receive from non-chan type %v)", n, t)
+			base.Errorf("invalid operation: %v (receive from non-chan type %v)", n, t)
 			n.Type = nil
 			return n
 		}
 
 		if !t.ChanDir().CanRecv() {
-			yyerror("invalid operation: %v (receive from send-only type %v)", n, t)
+			base.Errorf("invalid operation: %v (receive from send-only type %v)", n, t)
 			n.Type = nil
 			return n
 		}
@@ -1101,13 +1102,13 @@ func typecheck1(n *Node, top int) (res *Node) {
 			return n
 		}
 		if !t.IsChan() {
-			yyerror("invalid operation: %v (send to non-chan type %v)", n, t)
+			base.Errorf("invalid operation: %v (send to non-chan type %v)", n, t)
 			n.Type = nil
 			return n
 		}
 
 		if !t.ChanDir().CanSend() {
-			yyerror("invalid operation: %v (send to receive-only type %v)", n, t)
+			base.Errorf("invalid operation: %v (send to receive-only type %v)", n, t)
 			n.Type = nil
 			return n
 		}
@@ -1120,7 +1121,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		n.Type = nil
 
 	case OSLICEHEADER:
-		// Errors here are Fatalf instead of yyerror because only the compiler
+		// Errors here are Fatalf instead of Errorf because only the compiler
 		// can construct an OSLICEHEADER node.
 		// Components used in OSLICEHEADER that are supplied by parsed source code
 		// have already been typechecked in e.g. OMAKESLICE earlier.
@@ -1128,19 +1129,19 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 		t := n.Type
 		if t == nil {
-			Fatalf("no type specified for OSLICEHEADER")
+			base.Fatalf("no type specified for OSLICEHEADER")
 		}
 
 		if !t.IsSlice() {
-			Fatalf("invalid type %v for OSLICEHEADER", n.Type)
+			base.Fatalf("invalid type %v for OSLICEHEADER", n.Type)
 		}
 
 		if n.Left == nil || n.Left.Type == nil || !n.Left.Type.IsUnsafePtr() {
-			Fatalf("need unsafe.Pointer for OSLICEHEADER")
+			base.Fatalf("need unsafe.Pointer for OSLICEHEADER")
 		}
 
 		if x := n.List.Len(); x != 2 {
-			Fatalf("expected 2 params (len, cap) for OSLICEHEADER, got %d", x)
+			base.Fatalf("expected 2 params (len, cap) for OSLICEHEADER, got %d", x)
 		}
 
 		n.Left = typecheck(n.Left, ctxExpr)
@@ -1150,22 +1151,22 @@ func typecheck1(n *Node, top int) (res *Node) {
 		c = defaultlit(c, types.Types[TINT])
 
 		if Isconst(l, constant.Int) && l.Int64Val() < 0 {
-			Fatalf("len for OSLICEHEADER must be non-negative")
+			base.Fatalf("len for OSLICEHEADER must be non-negative")
 		}
 
 		if Isconst(c, constant.Int) && c.Int64Val() < 0 {
-			Fatalf("cap for OSLICEHEADER must be non-negative")
+			base.Fatalf("cap for OSLICEHEADER must be non-negative")
 		}
 
 		if Isconst(l, constant.Int) && Isconst(c, constant.Int) && constant.Compare(l.Val(), token.GTR, c.Val()) {
-			Fatalf("len larger than cap for OSLICEHEADER")
+			base.Fatalf("len larger than cap for OSLICEHEADER")
 		}
 
 		n.List.SetFirst(l)
 		n.List.SetSecond(c)
 
 	case OMAKESLICECOPY:
-		// Errors here are Fatalf instead of yyerror because only the compiler
+		// Errors here are Fatalf instead of Errorf because only the compiler
 		// can construct an OMAKESLICECOPY node.
 		// Components used in OMAKESCLICECOPY that are supplied by parsed source code
 		// have already been typechecked in OMAKE and OCOPY earlier.
@@ -1174,19 +1175,19 @@ func typecheck1(n *Node, top int) (res *Node) {
 		t := n.Type
 
 		if t == nil {
-			Fatalf("no type specified for OMAKESLICECOPY")
+			base.Fatalf("no type specified for OMAKESLICECOPY")
 		}
 
 		if !t.IsSlice() {
-			Fatalf("invalid type %v for OMAKESLICECOPY", n.Type)
+			base.Fatalf("invalid type %v for OMAKESLICECOPY", n.Type)
 		}
 
 		if n.Left == nil {
-			Fatalf("missing len argument for OMAKESLICECOPY")
+			base.Fatalf("missing len argument for OMAKESLICECOPY")
 		}
 
 		if n.Right == nil {
-			Fatalf("missing slice argument to copy for OMAKESLICECOPY")
+			base.Fatalf("missing slice argument to copy for OMAKESLICECOPY")
 		}
 
 		n.Left = typecheck(n.Left, ctxExpr)
@@ -1195,15 +1196,15 @@ func typecheck1(n *Node, top int) (res *Node) {
 		n.Left = defaultlit(n.Left, types.Types[TINT])
 
 		if !n.Left.Type.IsInteger() && n.Type.Etype != TIDEAL {
-			yyerror("non-integer len argument in OMAKESLICECOPY")
+			base.Errorf("non-integer len argument in OMAKESLICECOPY")
 		}
 
 		if Isconst(n.Left, constant.Int) {
 			if doesoverflow(n.Left.Val(), types.Types[TINT]) {
-				Fatalf("len for OMAKESLICECOPY too large")
+				base.Fatalf("len for OMAKESLICECOPY too large")
 			}
 			if constant.Sign(n.Left.Val()) < 0 {
-				Fatalf("len for OMAKESLICECOPY must be non-negative")
+				base.Fatalf("len for OMAKESLICECOPY must be non-negative")
 			}
 		}
 
@@ -1227,7 +1228,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		}
 		if l.Type.IsArray() {
 			if !islvalue(n.Left) {
-				yyerror("invalid operation %v (slice of unaddressable value)", n)
+				base.Errorf("invalid operation %v (slice of unaddressable value)", n)
 				n.Type = nil
 				return n
 			}
@@ -1241,7 +1242,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		var tp *types.Type
 		if t.IsString() {
 			if hasmax {
-				yyerror("invalid operation %v (3-index slice of string)", n)
+				base.Errorf("invalid operation %v (3-index slice of string)", n)
 				n.Type = nil
 				return n
 			}
@@ -1259,7 +1260,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		} else if t.IsSlice() {
 			n.Type = t
 		} else {
-			yyerror("cannot slice %v (type %v)", l, t)
+			base.Errorf("cannot slice %v (type %v)", l, t)
 			n.Type = nil
 			return n
 		}
@@ -1293,7 +1294,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 		if l.Op == ONAME && l.SubOp() != 0 {
 			if n.IsDDD() && l.SubOp() != OAPPEND {
-				yyerror("invalid use of ... with builtin %v", l)
+				base.Errorf("invalid use of ... with builtin %v", l)
 			}
 
 			// builtin: OLEN, OCAP, etc.
@@ -1309,7 +1310,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		if l.Op == OTYPE {
 			if n.IsDDD() {
 				if !l.Type.Broke() {
-					yyerror("invalid use of ... in type conversion to %v", l.Type)
+					base.Errorf("invalid use of ... in type conversion to %v", l.Type)
 				}
 				n.SetDiag(true)
 			}
@@ -1352,7 +1353,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			tp := t.Recv().Type
 
 			if l.Left == nil || !types.Identical(l.Left.Type, tp) {
-				Fatalf("method receiver")
+				base.Fatalf("method receiver")
 			}
 
 		default:
@@ -1362,10 +1363,10 @@ func typecheck1(n *Node, top int) (res *Node) {
 				if isBuiltinFuncName(name) && l.Name.Defn != nil {
 					// be more specific when the function
 					// name matches a predeclared function
-					yyerror("cannot call non-function %s (type %v), declared at %s",
-						name, t, linestr(l.Name.Defn.Pos))
+					base.Errorf("cannot call non-function %s (type %v), declared at %s",
+						name, t, base.FmtPos(l.Name.Defn.Pos))
 				} else {
-					yyerror("cannot call non-function %s (type %v)", name, t)
+					base.Errorf("cannot call non-function %s (type %v)", name, t)
 				}
 				n.Type = nil
 				return n
@@ -1396,7 +1397,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 		// multiple return
 		if top&(ctxMultiOK|ctxStmt) == 0 {
-			yyerror("multiple-value %v() in single-value context", l)
+			base.Errorf("multiple-value %v() in single-value context", l)
 			break
 		}
 
@@ -1434,7 +1435,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			ok = okforcap[t.Etype]
 		}
 		if !ok {
-			yyerror("invalid argument %L for %v", l, n.Op)
+			base.Errorf("invalid argument %L for %v", l, n.Op)
 			n.Type = nil
 			return n
 		}
@@ -1465,7 +1466,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		case TCOMPLEX128:
 			n.Type = types.Types[TFLOAT64]
 		default:
-			yyerror("invalid argument %L for %v", l, n.Op)
+			base.Errorf("invalid argument %L for %v", l, n.Op)
 			n.Type = nil
 			return n
 		}
@@ -1492,7 +1493,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		n.Right = r
 
 		if !types.Identical(l.Type, r.Type) {
-			yyerror("invalid operation: %v (mismatched types %v and %v)", n, l.Type, r.Type)
+			base.Errorf("invalid operation: %v (mismatched types %v and %v)", n, l.Type, r.Type)
 			n.Type = nil
 			return n
 		}
@@ -1500,7 +1501,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		var t *types.Type
 		switch l.Type.Etype {
 		default:
-			yyerror("invalid operation: %v (arguments have type %v, expected floating-point)", n, l.Type)
+			base.Errorf("invalid operation: %v (arguments have type %v, expected floating-point)", n, l.Type)
 			n.Type = nil
 			return n
 
@@ -1529,13 +1530,13 @@ func typecheck1(n *Node, top int) (res *Node) {
 			return n
 		}
 		if !t.IsChan() {
-			yyerror("invalid operation: %v (non-chan type %v)", n, t)
+			base.Errorf("invalid operation: %v (non-chan type %v)", n, t)
 			n.Type = nil
 			return n
 		}
 
 		if !t.ChanDir().CanSend() {
-			yyerror("invalid operation: %v (cannot close receive-only channel)", n)
+			base.Errorf("invalid operation: %v (cannot close receive-only channel)", n)
 			n.Type = nil
 			return n
 		}
@@ -1547,19 +1548,19 @@ func typecheck1(n *Node, top int) (res *Node) {
 		typecheckargs(n)
 		args := n.List
 		if args.Len() == 0 {
-			yyerror("missing arguments to delete")
+			base.Errorf("missing arguments to delete")
 			n.Type = nil
 			return n
 		}
 
 		if args.Len() == 1 {
-			yyerror("missing second (key) argument to delete")
+			base.Errorf("missing second (key) argument to delete")
 			n.Type = nil
 			return n
 		}
 
 		if args.Len() != 2 {
-			yyerror("too many arguments to delete")
+			base.Errorf("too many arguments to delete")
 			n.Type = nil
 			return n
 		}
@@ -1567,7 +1568,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		l := args.First()
 		r := args.Second()
 		if l.Type != nil && !l.Type.IsMap() {
-			yyerror("first argument to delete must be map; have %L", l.Type)
+			base.Errorf("first argument to delete must be map; have %L", l.Type)
 			n.Type = nil
 			return n
 		}
@@ -1579,7 +1580,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		typecheckargs(n)
 		args := n.List
 		if args.Len() == 0 {
-			yyerror("missing arguments to append")
+			base.Errorf("missing arguments to append")
 			n.Type = nil
 			return n
 		}
@@ -1593,25 +1594,25 @@ func typecheck1(n *Node, top int) (res *Node) {
 		n.Type = t
 		if !t.IsSlice() {
 			if args.First().isNil() {
-				yyerror("first argument to append must be typed slice; have untyped nil")
+				base.Errorf("first argument to append must be typed slice; have untyped nil")
 				n.Type = nil
 				return n
 			}
 
-			yyerror("first argument to append must be slice; have %L", t)
+			base.Errorf("first argument to append must be slice; have %L", t)
 			n.Type = nil
 			return n
 		}
 
 		if n.IsDDD() {
 			if args.Len() == 1 {
-				yyerror("cannot use ... on first argument to append")
+				base.Errorf("cannot use ... on first argument to append")
 				n.Type = nil
 				return n
 			}
 
 			if args.Len() != 2 {
-				yyerror("too many arguments to append")
+				base.Errorf("too many arguments to append")
 				n.Type = nil
 				return n
 			}
@@ -1658,25 +1659,25 @@ func typecheck1(n *Node, top int) (res *Node) {
 			if types.Identical(n.Left.Type.Elem(), types.Bytetype) {
 				break
 			}
-			yyerror("arguments to copy have different element types: %L and string", n.Left.Type)
+			base.Errorf("arguments to copy have different element types: %L and string", n.Left.Type)
 			n.Type = nil
 			return n
 		}
 
 		if !n.Left.Type.IsSlice() || !n.Right.Type.IsSlice() {
 			if !n.Left.Type.IsSlice() && !n.Right.Type.IsSlice() {
-				yyerror("arguments to copy must be slices; have %L, %L", n.Left.Type, n.Right.Type)
+				base.Errorf("arguments to copy must be slices; have %L, %L", n.Left.Type, n.Right.Type)
 			} else if !n.Left.Type.IsSlice() {
-				yyerror("first argument to copy should be slice; have %L", n.Left.Type)
+				base.Errorf("first argument to copy should be slice; have %L", n.Left.Type)
 			} else {
-				yyerror("second argument to copy should be slice or string; have %L", n.Right.Type)
+				base.Errorf("second argument to copy should be slice or string; have %L", n.Right.Type)
 			}
 			n.Type = nil
 			return n
 		}
 
 		if !types.Identical(n.Left.Type.Elem(), n.Right.Type.Elem()) {
-			yyerror("arguments to copy have different element types: %L and %L", n.Left.Type, n.Right.Type)
+			base.Errorf("arguments to copy have different element types: %L and %L", n.Left.Type, n.Right.Type)
 			n.Type = nil
 			return n
 		}
@@ -1695,7 +1696,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		n.Op = op
 		if n.Op == OXXX {
 			if !n.Diag() && !n.Type.Broke() && !n.Left.Diag() {
-				yyerror("cannot convert %L to type %v%s", n.Left, n.Type, why)
+				base.Errorf("cannot convert %L to type %v%s", n.Left, n.Type, why)
 				n.SetDiag(true)
 			}
 			n.Op = OCONV
@@ -1729,7 +1730,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		ok |= ctxExpr
 		args := n.List.Slice()
 		if len(args) == 0 {
-			yyerror("missing argument to make")
+			base.Errorf("missing argument to make")
 			n.Type = nil
 			return n
 		}
@@ -1746,13 +1747,13 @@ func typecheck1(n *Node, top int) (res *Node) {
 		i := 1
 		switch t.Etype {
 		default:
-			yyerror("cannot make type %v", t)
+			base.Errorf("cannot make type %v", t)
 			n.Type = nil
 			return n
 
 		case TSLICE:
 			if i >= len(args) {
-				yyerror("missing len argument to make(%v)", t)
+				base.Errorf("missing len argument to make(%v)", t)
 				n.Type = nil
 				return n
 			}
@@ -1776,7 +1777,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 				return n
 			}
 			if Isconst(l, constant.Int) && r != nil && Isconst(r, constant.Int) && constant.Compare(l.Val(), token.GTR, r.Val()) {
-				yyerror("len larger than cap in make(%v)", t)
+				base.Errorf("len larger than cap in make(%v)", t)
 				n.Type = nil
 				return n
 			}
@@ -1828,7 +1829,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		}
 
 		if i < len(args) {
-			yyerror("too many arguments to make(%v)", t)
+			base.Errorf("too many arguments to make(%v)", t)
 			n.Op = OMAKE
 			n.Type = nil
 			return n
@@ -1840,7 +1841,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		ok |= ctxExpr
 		args := n.List
 		if args.Len() == 0 {
-			yyerror("missing argument to new")
+			base.Errorf("missing argument to new")
 			n.Type = nil
 			return n
 		}
@@ -1853,7 +1854,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			return n
 		}
 		if args.Len() > 1 {
-			yyerror("too many arguments to new(%v)", t)
+			base.Errorf("too many arguments to new(%v)", t)
 			n.Type = nil
 			return n
 		}
@@ -1890,7 +1891,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 	case ORECOVER:
 		ok |= ctxExpr | ctxStmt
 		if n.List.Len() != 0 {
-			yyerror("too many arguments to recover")
+			base.Errorf("too many arguments to recover")
 			n.Type = nil
 			return n
 		}
@@ -1913,14 +1914,14 @@ func typecheck1(n *Node, top int) (res *Node) {
 			return n
 		}
 		if !t.IsInterface() {
-			Fatalf("OITAB of %v", t)
+			base.Fatalf("OITAB of %v", t)
 		}
 		n.Type = types.NewPtr(types.Types[TUINTPTR])
 
 	case OIDATA:
 		// Whoever creates the OIDATA node must know a priori the concrete type at that moment,
 		// usually by just having checked the OITAB.
-		Fatalf("cannot typecheck interface data %v", n)
+		base.Fatalf("cannot typecheck interface data %v", n)
 
 	case OSPTR:
 		ok |= ctxExpr
@@ -1931,7 +1932,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			return n
 		}
 		if !t.IsSlice() && !t.IsString() {
-			Fatalf("OSPTR of %v", t)
+			base.Fatalf("OSPTR of %v", t)
 		}
 		if t.IsString() {
 			n.Type = types.NewPtr(types.Types[TUINT8])
@@ -2008,7 +2009,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		if n.Left != nil {
 			t := n.Left.Type
 			if t != nil && !t.IsBoolean() {
-				yyerror("non-bool %L used as for condition", n.Left)
+				base.Errorf("non-bool %L used as for condition", n.Left)
 			}
 		}
 		n.Right = typecheck(n.Right, ctxStmt)
@@ -2026,7 +2027,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		if n.Left != nil {
 			t := n.Left.Type
 			if t != nil && !t.IsBoolean() {
-				yyerror("non-bool %L used as if condition", n.Left)
+				base.Errorf("non-bool %L used as if condition", n.Left)
 			}
 		}
 		typecheckslice(n.Nbody.Slice(), ctxStmt)
@@ -2036,7 +2037,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		ok |= ctxStmt
 		typecheckargs(n)
 		if Curfn == nil {
-			yyerror("return outside function")
+			base.Errorf("return outside function")
 			n.Type = nil
 			return n
 		}
@@ -2062,7 +2063,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		typecheckrange(n)
 
 	case OTYPESW:
-		yyerror("use of .(type) outside type switch")
+		base.Errorf("use of .(type) outside type switch")
 		n.Type = nil
 		return n
 
@@ -2095,28 +2096,28 @@ func typecheck1(n *Node, top int) (res *Node) {
 	n = evalConst(n)
 	if n.Op == OTYPE && top&ctxType == 0 {
 		if !n.Type.Broke() {
-			yyerror("type %v is not an expression", n.Type)
+			base.Errorf("type %v is not an expression", n.Type)
 		}
 		n.Type = nil
 		return n
 	}
 
 	if top&(ctxExpr|ctxType) == ctxType && n.Op != OTYPE {
-		yyerror("%v is not a type", n)
+		base.Errorf("%v is not a type", n)
 		n.Type = nil
 		return n
 	}
 
 	// TODO(rsc): simplify
 	if (top&(ctxCallee|ctxExpr|ctxType) != 0) && top&ctxStmt == 0 && ok&(ctxExpr|ctxType|ctxCallee) == 0 {
-		yyerror("%v used as value", n)
+		base.Errorf("%v used as value", n)
 		n.Type = nil
 		return n
 	}
 
 	if (top&ctxStmt != 0) && top&(ctxCallee|ctxExpr|ctxType) == 0 && ok&ctxStmt == 0 {
 		if !n.Diag() {
-			yyerror("%v evaluated but not used", n)
+			base.Errorf("%v evaluated but not used", n)
 			n.SetDiag(true)
 		}
 
@@ -2178,23 +2179,23 @@ func checksliceindex(l *Node, r *Node, tp *types.Type) bool {
 		return false
 	}
 	if !t.IsInteger() {
-		yyerror("invalid slice index %v (type %v)", r, t)
+		base.Errorf("invalid slice index %v (type %v)", r, t)
 		return false
 	}
 
 	if r.Op == OLITERAL {
 		x := r.Val()
 		if constant.Sign(x) < 0 {
-			yyerror("invalid slice index %v (index must be non-negative)", r)
+			base.Errorf("invalid slice index %v (index must be non-negative)", r)
 			return false
 		} else if tp != nil && tp.NumElem() >= 0 && constant.Compare(x, token.GTR, constant.MakeInt64(tp.NumElem())) {
-			yyerror("invalid slice index %v (out of bounds for %d-element array)", r, tp.NumElem())
+			base.Errorf("invalid slice index %v (out of bounds for %d-element array)", r, tp.NumElem())
 			return false
 		} else if Isconst(l, constant.String) && constant.Compare(x, token.GTR, constant.MakeInt64(int64(len(l.StringVal())))) {
-			yyerror("invalid slice index %v (out of bounds for %d-byte string)", r, len(l.StringVal()))
+			base.Errorf("invalid slice index %v (out of bounds for %d-byte string)", r, len(l.StringVal()))
 			return false
 		} else if doesoverflow(x, types.Types[TINT]) {
-			yyerror("invalid slice index %v (index too large)", r)
+			base.Errorf("invalid slice index %v (index too large)", r)
 			return false
 		}
 	}
@@ -2204,7 +2205,7 @@ func checksliceindex(l *Node, r *Node, tp *types.Type) bool {
 
 func checksliceconst(lo *Node, hi *Node) bool {
 	if lo != nil && hi != nil && lo.Op == OLITERAL && hi.Op == OLITERAL && constant.Compare(lo.Val(), token.GTR, hi.Val()) {
-		yyerror("invalid slice index: %v > %v", lo, hi)
+		base.Errorf("invalid slice index: %v > %v", lo, hi)
 		return false
 	}
 
@@ -2246,7 +2247,7 @@ func checkdefergo(n *Node) {
 		if n.Left.Orig != nil && n.Left.Orig.Op == OCONV {
 			break
 		}
-		yyerrorl(n.Pos, "%s discards result of %v", what, n.Left)
+		base.ErrorfAt(n.Pos, "%s discards result of %v", what, n.Left)
 		return
 	}
 
@@ -2260,7 +2261,7 @@ func checkdefergo(n *Node) {
 		// The syntax made sure it was a call, so this must be
 		// a conversion.
 		n.SetDiag(true)
-		yyerrorl(n.Pos, "%s requires function call, not conversion", what)
+		base.ErrorfAt(n.Pos, "%s requires function call, not conversion", what)
 	}
 }
 
@@ -2291,13 +2292,13 @@ func onearg(n *Node, f string, args ...interface{}) bool {
 	}
 	if n.List.Len() == 0 {
 		p := fmt.Sprintf(f, args...)
-		yyerror("missing argument to %s: %v", p, n)
+		base.Errorf("missing argument to %s: %v", p, n)
 		return false
 	}
 
 	if n.List.Len() > 1 {
 		p := fmt.Sprintf(f, args...)
-		yyerror("too many arguments to %s: %v", p, n)
+		base.Errorf("too many arguments to %s: %v", p, n)
 		n.Left = n.List.First()
 		n.List.Set(nil)
 		return false
@@ -2314,9 +2315,9 @@ func twoarg(n *Node) bool {
 	}
 	if n.List.Len() != 2 {
 		if n.List.Len() < 2 {
-			yyerror("not enough arguments in call to %v", n)
+			base.Errorf("not enough arguments in call to %v", n)
 		} else {
-			yyerror("too many arguments in call to %v", n)
+			base.Errorf("too many arguments in call to %v", n)
 		}
 		return false
 	}
@@ -2340,11 +2341,11 @@ func lookdot1(errnode *Node, s *types.Sym, t *types.Type, fs *types.Fields, dost
 		}
 		if r != nil {
 			if errnode != nil {
-				yyerror("ambiguous selector %v", errnode)
+				base.Errorf("ambiguous selector %v", errnode)
 			} else if t.IsPtr() {
-				yyerror("ambiguous selector (%v).%v", t, s)
+				base.Errorf("ambiguous selector (%v).%v", t, s)
 			} else {
-				yyerror("ambiguous selector %v.%v", t, s)
+				base.Errorf("ambiguous selector %v.%v", t, s)
 			}
 			break
 		}
@@ -2358,7 +2359,7 @@ func lookdot1(errnode *Node, s *types.Sym, t *types.Type, fs *types.Fields, dost
 // typecheckMethodExpr checks selector expressions (ODOT) where the
 // base expression is a type expression (OTYPE).
 func typecheckMethodExpr(n *Node) (res *Node) {
-	if enableTrace && Flag.LowerT {
+	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckMethodExpr", n)(&res)
 	}
 
@@ -2371,7 +2372,7 @@ func typecheckMethodExpr(n *Node) (res *Node) {
 	} else {
 		mt := methtype(t)
 		if mt == nil {
-			yyerror("%v undefined (type %v has no method %v)", n, t, n.Sym)
+			base.Errorf("%v undefined (type %v has no method %v)", n, t, n.Sym)
 			n.Type = nil
 			return n
 		}
@@ -2394,18 +2395,18 @@ func typecheckMethodExpr(n *Node) (res *Node) {
 	m := lookdot1(n, s, t, ms, 0)
 	if m == nil {
 		if lookdot1(n, s, t, ms, 1) != nil {
-			yyerror("%v undefined (cannot refer to unexported method %v)", n, s)
+			base.Errorf("%v undefined (cannot refer to unexported method %v)", n, s)
 		} else if _, ambig := dotpath(s, t, nil, false); ambig {
-			yyerror("%v undefined (ambiguous selector)", n) // method or field
+			base.Errorf("%v undefined (ambiguous selector)", n) // method or field
 		} else {
-			yyerror("%v undefined (type %v has no method %v)", n, t, s)
+			base.Errorf("%v undefined (type %v has no method %v)", n, t, s)
 		}
 		n.Type = nil
 		return n
 	}
 
 	if !isMethodApplicable(t, m) {
-		yyerror("invalid method expression %v (needs pointer receiver: (*%v).%S)", n, t, s)
+		base.Errorf("invalid method expression %v (needs pointer receiver: (*%v).%S)", n, t, s)
 		n.Type = nil
 		return n
 	}
@@ -2423,7 +2424,7 @@ func typecheckMethodExpr(n *Node) (res *Node) {
 	// methodSym already marked n.Sym as a function.
 
 	// Issue 25065. Make sure that we emit the symbol for a local method.
-	if Ctxt.Flag_dynlink && !inimport && (t.Sym == nil || t.Sym.Pkg == localpkg) {
+	if base.Ctxt.Flag_dynlink && !inimport && (t.Sym == nil || t.Sym.Pkg == localpkg) {
 		makefuncsym(n.Sym)
 	}
 
@@ -2468,10 +2469,10 @@ func lookdot(n *Node, t *types.Type, dostrcmp int) *types.Field {
 			return f1
 		}
 		if f2 != nil {
-			yyerror("%v is both field and method", n.Sym)
+			base.Errorf("%v is both field and method", n.Sym)
 		}
 		if f1.Offset == BADWIDTH {
-			Fatalf("lookdot badwidth %v %p", f1, f1)
+			base.Fatalf("lookdot badwidth %v %p", f1, f1)
 		}
 		n.Xoffset = f1.Offset
 		n.Type = f1.Type
@@ -2509,7 +2510,7 @@ func lookdot(n *Node, t *types.Type, dostrcmp int) *types.Field {
 				n.Left.SetImplicit(true)
 				n.Left = typecheck(n.Left, ctxType|ctxExpr)
 			} else if tt.IsPtr() && tt.Elem().IsPtr() && types.Identical(derefall(tt), derefall(rcvr)) {
-				yyerror("calling method %v with receiver %L requires explicit dereference", n.Sym, n.Left)
+				base.Errorf("calling method %v with receiver %L requires explicit dereference", n.Sym, n.Left)
 				for tt.IsPtr() {
 					// Stop one level early for method with pointer receiver.
 					if rcvr.IsPtr() && !tt.Elem().IsPtr() {
@@ -2521,7 +2522,7 @@ func lookdot(n *Node, t *types.Type, dostrcmp int) *types.Field {
 					tt = tt.Elem()
 				}
 			} else {
-				Fatalf("method mismatch: %v for %v", rcvr, tt)
+				base.Fatalf("method mismatch: %v for %v", rcvr, tt)
 			}
 		}
 
@@ -2574,8 +2575,8 @@ func typecheckaste(op Op, call *Node, isddd bool, tstruct *types.Type, nl Nodes,
 	var t *types.Type
 	var i int
 
-	lno := lineno
-	defer func() { lineno = lno }()
+	lno := base.Pos
+	defer func() { base.Pos = lno }()
 
 	if tstruct.Broke() {
 		return
@@ -2656,9 +2657,9 @@ func typecheckaste(op Op, call *Node, isddd bool, tstruct *types.Type, nl Nodes,
 	}
 	if isddd {
 		if call != nil {
-			yyerror("invalid use of ... in call to %v", call)
+			base.Errorf("invalid use of ... in call to %v", call)
 		} else {
-			yyerror("invalid use of ... in %v", op)
+			base.Errorf("invalid use of ... in %v", op)
 		}
 	}
 	return
@@ -2671,12 +2672,12 @@ notenough:
 			// Method expressions have the form T.M, and the compiler has
 			// rewritten those to ONAME nodes but left T in Left.
 			if call.Op == OMETHEXPR {
-				yyerror("not enough arguments in call to method expression %v%s", call, details)
+				base.Errorf("not enough arguments in call to method expression %v%s", call, details)
 			} else {
-				yyerror("not enough arguments in call to %v%s", call, details)
+				base.Errorf("not enough arguments in call to %v%s", call, details)
 			}
 		} else {
-			yyerror("not enough arguments to %v%s", op, details)
+			base.Errorf("not enough arguments to %v%s", op, details)
 		}
 		if n != nil {
 			n.SetDiag(true)
@@ -2687,9 +2688,9 @@ notenough:
 toomany:
 	details := errorDetails(nl, tstruct, isddd)
 	if call != nil {
-		yyerror("too many arguments in call to %v%s", call, details)
+		base.Errorf("too many arguments in call to %v%s", call, details)
 	} else {
-		yyerror("too many arguments to %v%s", op, details)
+		base.Errorf("too many arguments to %v%s", op, details)
 	}
 }
 
@@ -2729,7 +2730,7 @@ func sigrepr(t *types.Type, isddd bool) string {
 	// Turn []T... argument to ...T for clearer error message.
 	if isddd {
 		if !t.IsSlice() {
-			Fatalf("bad type for ... argument: %v", t)
+			base.Fatalf("bad type for ... argument: %v", t)
 		}
 		return "..." + t.Elem().String()
 	}
@@ -2754,7 +2755,7 @@ func (nl Nodes) sigerr(isddd bool) string {
 // type check composite
 func fielddup(name string, hash map[string]bool) {
 	if hash[name] {
-		yyerror("duplicate field name in struct literal: %s", name)
+		base.Errorf("duplicate field name in struct literal: %s", name)
 		return
 	}
 	hash[name] = true
@@ -2796,17 +2797,17 @@ func pushtype(n *Node, t *types.Type) *Node {
 // The result of typecheckcomplit MUST be assigned back to n, e.g.
 // 	n.Left = typecheckcomplit(n.Left)
 func typecheckcomplit(n *Node) (res *Node) {
-	if enableTrace && Flag.LowerT {
+	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckcomplit", n)(&res)
 	}
 
-	lno := lineno
+	lno := base.Pos
 	defer func() {
-		lineno = lno
+		base.Pos = lno
 	}()
 
 	if n.Right == nil {
-		yyerrorl(n.Pos, "missing type in composite literal")
+		base.ErrorfAt(n.Pos, "missing type in composite literal")
 		n.Type = nil
 		return n
 	}
@@ -2843,7 +2844,7 @@ func typecheckcomplit(n *Node) (res *Node) {
 
 	switch t.Etype {
 	default:
-		yyerror("invalid composite literal type %v", t)
+		base.Errorf("invalid composite literal type %v", t)
 		n.Type = nil
 
 	case TARRAY:
@@ -2862,7 +2863,7 @@ func typecheckcomplit(n *Node) (res *Node) {
 			setlineno(l)
 			if l.Op != OKEY {
 				n.List.SetIndex(i3, typecheck(l, ctxExpr))
-				yyerror("missing key in map literal")
+				base.Errorf("missing key in map literal")
 				continue
 			}
 
@@ -2870,7 +2871,7 @@ func typecheckcomplit(n *Node) (res *Node) {
 			r = pushtype(r, t.Key())
 			r = typecheck(r, ctxExpr)
 			l.Left = assignconv(r, t.Key(), "map key")
-			cs.add(lineno, l.Left, "key", "map literal")
+			cs.add(base.Pos, l.Left, "key", "map literal")
 
 			r = l.Right
 			r = pushtype(r, t.Elem())
@@ -2895,7 +2896,7 @@ func typecheckcomplit(n *Node) (res *Node) {
 				ls[i] = n1
 				if i >= t.NumFields() {
 					if !errored {
-						yyerror("too many values in %v", n)
+						base.Errorf("too many values in %v", n)
 						errored = true
 					}
 					continue
@@ -2904,7 +2905,7 @@ func typecheckcomplit(n *Node) (res *Node) {
 				f := t.Field(i)
 				s := f.Sym
 				if s != nil && !types.IsExported(s.Name) && s.Pkg != localpkg {
-					yyerror("implicit assignment of unexported field '%s' in %v literal", s.Name, t)
+					base.Errorf("implicit assignment of unexported field '%s' in %v literal", s.Name, t)
 				}
 				// No pushtype allowed here. Must name fields for that.
 				n1 = assignconv(n1, f.Type, "field value")
@@ -2913,7 +2914,7 @@ func typecheckcomplit(n *Node) (res *Node) {
 				ls[i] = n1
 			}
 			if len(ls) < t.NumFields() {
-				yyerror("too few values in %v", n)
+				base.Errorf("too few values in %v", n)
 			}
 		} else {
 			hash := make(map[string]bool)
@@ -2935,7 +2936,7 @@ func typecheckcomplit(n *Node) (res *Node) {
 					// so s will be non-nil, but an OXDOT
 					// is never a valid struct literal key.
 					if key.Sym == nil || key.Op == OXDOT || key.Sym.IsBlank() {
-						yyerror("invalid field name %v in struct initializer", key)
+						base.Errorf("invalid field name %v in struct initializer", key)
 						l.Left = typecheck(l.Left, ctxExpr)
 						continue
 					}
@@ -2955,7 +2956,7 @@ func typecheckcomplit(n *Node) (res *Node) {
 
 				if l.Op != OSTRUCTKEY {
 					if !errored {
-						yyerror("mixture of field:value and value initializers")
+						base.Errorf("mixture of field:value and value initializers")
 						errored = true
 					}
 					ls[i] = typecheck(ls[i], ctxExpr)
@@ -2966,18 +2967,18 @@ func typecheckcomplit(n *Node) (res *Node) {
 				if f == nil {
 					if ci := lookdot1(nil, l.Sym, t, t.Fields(), 2); ci != nil { // Case-insensitive lookup.
 						if visible(ci.Sym) {
-							yyerror("unknown field '%v' in struct literal of type %v (but does have %v)", l.Sym, t, ci.Sym)
+							base.Errorf("unknown field '%v' in struct literal of type %v (but does have %v)", l.Sym, t, ci.Sym)
 						} else if nonexported(l.Sym) && l.Sym.Name == ci.Sym.Name { // Ensure exactness before the suggestion.
-							yyerror("cannot refer to unexported field '%v' in struct literal of type %v", l.Sym, t)
+							base.Errorf("cannot refer to unexported field '%v' in struct literal of type %v", l.Sym, t)
 						} else {
-							yyerror("unknown field '%v' in struct literal of type %v", l.Sym, t)
+							base.Errorf("unknown field '%v' in struct literal of type %v", l.Sym, t)
 						}
 						continue
 					}
 					var f *types.Field
 					p, _ := dotpath(l.Sym, t, &f, true)
 					if p == nil || f.IsMethod() {
-						yyerror("unknown field '%v' in struct literal of type %v", l.Sym, t)
+						base.Errorf("unknown field '%v' in struct literal of type %v", l.Sym, t)
 						continue
 					}
 					// dotpath returns the parent embedded types in reverse order.
@@ -2986,7 +2987,7 @@ func typecheckcomplit(n *Node) (res *Node) {
 						ep = append(ep, p[ei].field.Sym.Name)
 					}
 					ep = append(ep, l.Sym.Name)
-					yyerror("cannot use promoted field %v in struct literal of type %v", strings.Join(ep, "."), t)
+					base.Errorf("cannot use promoted field %v in struct literal of type %v", strings.Join(ep, "."), t)
 					continue
 				}
 				fielddup(f.Sym.Name, hash)
@@ -3028,9 +3029,9 @@ func typecheckarraylit(elemType *types.Type, bound int64, elts []*Node, ctx stri
 			if key < 0 {
 				if !elt.Left.Diag() {
 					if key == -2 {
-						yyerror("index too large")
+						base.Errorf("index too large")
 					} else {
-						yyerror("index must be non-negative integer constant")
+						base.Errorf("index must be non-negative integer constant")
 					}
 					elt.Left.SetDiag(true)
 				}
@@ -3052,14 +3053,14 @@ func typecheckarraylit(elemType *types.Type, bound int64, elts []*Node, ctx stri
 		if key >= 0 {
 			if indices != nil {
 				if indices[key] {
-					yyerror("duplicate index in %s: %d", ctx, key)
+					base.Errorf("duplicate index in %s: %d", ctx, key)
 				} else {
 					indices[key] = true
 				}
 			}
 
 			if bound >= 0 && key >= bound {
-				yyerror("array index %d out of bounds [0:%d]", key, bound)
+				base.Errorf("array index %d out of bounds [0:%d]", key, bound)
 				bound = -1
 			}
 		}
@@ -3112,7 +3113,7 @@ func islvalue(n *Node) bool {
 
 func checklvalue(n *Node, verb string) {
 	if !islvalue(n) {
-		yyerror("cannot %s %v", verb, n)
+		base.Errorf("cannot %s %v", verb, n)
 	}
 }
 
@@ -3143,13 +3144,13 @@ func checkassign(stmt *Node, n *Node) {
 
 	switch {
 	case n.Op == ODOT && n.Left.Op == OINDEXMAP:
-		yyerror("cannot assign to struct field %v in map", n)
+		base.Errorf("cannot assign to struct field %v in map", n)
 	case (n.Op == OINDEX && n.Left.Type.IsString()) || n.Op == OSLICESTR:
-		yyerror("cannot assign to %v (strings are immutable)", n)
+		base.Errorf("cannot assign to %v (strings are immutable)", n)
 	case n.Op == OLITERAL && n.Sym != nil && n.isGoConst():
-		yyerror("cannot assign to %v (declared const)", n)
+		base.Errorf("cannot assign to %v (declared const)", n)
 	default:
-		yyerror("cannot assign to %v", n)
+		base.Errorf("cannot assign to %v", n)
 	}
 	n.Type = nil
 }
@@ -3214,7 +3215,7 @@ func samesafeexpr(l *Node, r *Node) bool {
 // if this assignment is the definition of a var on the left side,
 // fill in the var's type.
 func typecheckas(n *Node) {
-	if enableTrace && Flag.LowerT {
+	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckas", n)(nil)
 	}
 
@@ -3237,7 +3238,7 @@ func typecheckas(n *Node) {
 	checkassign(n, n.Left)
 	if n.Right != nil && n.Right.Type != nil {
 		if n.Right.Type.IsFuncArgStruct() {
-			yyerror("assignment mismatch: 1 variable but %v returns %d values", n.Right.Left, n.Right.Type.NumFields())
+			base.Errorf("assignment mismatch: 1 variable but %v returns %d values", n.Right.Left, n.Right.Type.NumFields())
 			// Multi-value RHS isn't actually valid for OAS; nil out
 			// to indicate failed typechecking.
 			n.Right.Type = nil
@@ -3266,13 +3267,13 @@ func typecheckas(n *Node) {
 
 func checkassignto(src *types.Type, dst *Node) {
 	if op, why := assignop(src, dst.Type); op == OXXX {
-		yyerror("cannot assign %v to %L in multiple assignment%s", src, dst, why)
+		base.Errorf("cannot assign %v to %L in multiple assignment%s", src, dst, why)
 		return
 	}
 }
 
 func typecheckas2(n *Node) {
-	if enableTrace && Flag.LowerT {
+	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckas2", n)(nil)
 	}
 
@@ -3387,9 +3388,9 @@ func typecheckas2(n *Node) {
 mismatch:
 	switch r.Op {
 	default:
-		yyerror("assignment mismatch: %d variables but %d values", cl, cr)
+		base.Errorf("assignment mismatch: %d variables but %d values", cl, cr)
 	case OCALLFUNC, OCALLMETH, OCALLINTER:
-		yyerror("assignment mismatch: %d variables but %v returns %d values", cl, r.Left, cr)
+		base.Errorf("assignment mismatch: %d variables but %v returns %d values", cl, r.Left, cr)
 	}
 
 	// second half of dance
@@ -3405,7 +3406,7 @@ out:
 
 // type check function definition
 func typecheckfunc(n *Node) {
-	if enableTrace && Flag.LowerT {
+	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckfunc", n)(nil)
 	}
 
@@ -3432,7 +3433,7 @@ func typecheckfunc(n *Node) {
 		declare(n.Func.Nname, PFUNC)
 	}
 
-	if Ctxt.Flag_dynlink && !inimport && n.Func.Nname != nil {
+	if base.Ctxt.Flag_dynlink && !inimport && n.Func.Nname != nil {
 		makefuncsym(n.Func.Nname.Sym)
 	}
 }
@@ -3441,7 +3442,7 @@ func typecheckfunc(n *Node) {
 // 	n.Left = stringtoruneslit(n.Left)
 func stringtoruneslit(n *Node) *Node {
 	if n.Left.Op != OLITERAL || n.Left.Val().Kind() != constant.String {
-		Fatalf("stringtoarraylit %v", n)
+		base.Fatalf("stringtoarraylit %v", n)
 	}
 
 	var l []*Node
@@ -3463,7 +3464,7 @@ func checkMapKeys() {
 	for _, n := range mapqueue {
 		k := n.Type.MapType().Key
 		if !k.Broke() && !IsComparable(k) {
-			yyerrorl(n.Pos, "invalid map key type %v", k)
+			base.ErrorfAt(n.Pos, "invalid map key type %v", k)
 		}
 	}
 	mapqueue = nil
@@ -3513,13 +3514,13 @@ func setUnderlying(t, underlying *types.Type) {
 	// Double-check use of type as embedded type.
 	if ft.Embedlineno.IsKnown() {
 		if t.IsPtr() || t.IsUnsafePtr() {
-			yyerrorl(ft.Embedlineno, "embedded type cannot be a pointer")
+			base.ErrorfAt(ft.Embedlineno, "embedded type cannot be a pointer")
 		}
 	}
 }
 
 func typecheckdeftype(n *Node) {
-	if enableTrace && Flag.LowerT {
+	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckdeftype", n)(nil)
 	}
 
@@ -3539,7 +3540,7 @@ func typecheckdeftype(n *Node) {
 }
 
 func typecheckdef(n *Node) {
-	if enableTrace && Flag.LowerT {
+	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckdef", n)(nil)
 	}
 
@@ -3551,27 +3552,27 @@ func typecheckdef(n *Node) {
 
 			// Note: adderrorname looks for this string and
 			// adds context about the outer expression
-			yyerrorl(lineno, "undefined: %v", n.Sym)
+			base.ErrorfAt(base.Pos, "undefined: %v", n.Sym)
 		}
-		lineno = lno
+		base.Pos = lno
 		return
 	}
 
 	if n.Walkdef() == 1 {
-		lineno = lno
+		base.Pos = lno
 		return
 	}
 
 	typecheckdefstack = append(typecheckdefstack, n)
 	if n.Walkdef() == 2 {
-		flusherrors()
+		base.FlushErrors()
 		fmt.Printf("typecheckdef loop:")
 		for i := len(typecheckdefstack) - 1; i >= 0; i-- {
 			n := typecheckdefstack[i]
 			fmt.Printf(" %v", n.Sym)
 		}
 		fmt.Printf("\n")
-		Fatalf("typecheckdef loop")
+		base.Fatalf("typecheckdef loop")
 	}
 
 	n.SetWalkdef(2)
@@ -3582,7 +3583,7 @@ func typecheckdef(n *Node) {
 
 	switch n.Op {
 	default:
-		Fatalf("typecheckdef %v", n.Op)
+		base.Fatalf("typecheckdef %v", n.Op)
 
 	case OLITERAL:
 		if n.Name.Param.Ntype != nil {
@@ -3599,7 +3600,7 @@ func typecheckdef(n *Node) {
 		n.Name.Defn = nil
 		if e == nil {
 			Dump("typecheckdef nil defn", n)
-			yyerrorl(n.Pos, "xxx")
+			base.ErrorfAt(n.Pos, "xxx")
 		}
 
 		e = typecheck(e, ctxExpr)
@@ -3609,9 +3610,9 @@ func typecheckdef(n *Node) {
 		if !e.isGoConst() {
 			if !e.Diag() {
 				if e.Op == ONIL {
-					yyerrorl(n.Pos, "const initializer cannot be nil")
+					base.ErrorfAt(n.Pos, "const initializer cannot be nil")
 				} else {
-					yyerrorl(n.Pos, "const initializer %v is not a constant", e)
+					base.ErrorfAt(n.Pos, "const initializer %v is not a constant", e)
 				}
 				e.SetDiag(true)
 			}
@@ -3621,12 +3622,12 @@ func typecheckdef(n *Node) {
 		t := n.Type
 		if t != nil {
 			if !okforconst[t.Etype] {
-				yyerrorl(n.Pos, "invalid constant type %v", t)
+				base.ErrorfAt(n.Pos, "invalid constant type %v", t)
 				goto ret
 			}
 
 			if !e.Type.IsUntyped() && !types.Identical(t, e.Type) {
-				yyerrorl(n.Pos, "cannot use %L as type %v in const initializer", e, t)
+				base.ErrorfAt(n.Pos, "cannot use %L as type %v in const initializer", e, t)
 				goto ret
 			}
 
@@ -3655,7 +3656,7 @@ func typecheckdef(n *Node) {
 			if n.SubOp() != 0 { // like OPRINTN
 				break
 			}
-			if Errors() > 0 {
+			if base.Errors() > 0 {
 				// Can have undefined variables in x := foo
 				// that make x have an n.name.Defn == nil.
 				// If there are other errors anyway, don't
@@ -3663,7 +3664,7 @@ func typecheckdef(n *Node) {
 				break
 			}
 
-			Fatalf("var without type, init: %v", n.Sym)
+			base.Fatalf("var without type, init: %v", n.Sym)
 		}
 
 		if n.Name.Defn.Op == ONAME {
@@ -3700,9 +3701,9 @@ func typecheckdef(n *Node) {
 		n.SetWalkdef(1)
 		setTypeNode(n, types.New(TFORW))
 		n.Type.Sym = n.Sym
-		errorsBefore := Errors()
+		errorsBefore := base.Errors()
 		typecheckdeftype(n)
-		if n.Type.Etype == TFORW && Errors() > errorsBefore {
+		if n.Type.Etype == TFORW && base.Errors() > errorsBefore {
 			// Something went wrong during type-checking,
 			// but it was reported. Silence future errors.
 			n.Type.SetBroke(true)
@@ -3712,23 +3713,23 @@ func typecheckdef(n *Node) {
 
 ret:
 	if n.Op != OLITERAL && n.Type != nil && n.Type.IsUntyped() {
-		Fatalf("got %v for %v", n.Type, n)
+		base.Fatalf("got %v for %v", n.Type, n)
 	}
 	last := len(typecheckdefstack) - 1
 	if typecheckdefstack[last] != n {
-		Fatalf("typecheckdefstack mismatch")
+		base.Fatalf("typecheckdefstack mismatch")
 	}
 	typecheckdefstack[last] = nil
 	typecheckdefstack = typecheckdefstack[:last]
 
-	lineno = lno
+	base.Pos = lno
 	n.SetWalkdef(1)
 }
 
 func checkmake(t *types.Type, arg string, np **Node) bool {
 	n := *np
 	if !n.Type.IsInteger() && n.Type.Etype != TIDEAL {
-		yyerror("non-integer %s argument in make(%v) - %v", arg, t, n.Type)
+		base.Errorf("non-integer %s argument in make(%v) - %v", arg, t, n.Type)
 		return false
 	}
 
@@ -3737,11 +3738,11 @@ func checkmake(t *types.Type, arg string, np **Node) bool {
 	if n.Op == OLITERAL {
 		v := toint(n.Val())
 		if constant.Sign(v) < 0 {
-			yyerror("negative %s argument in make(%v)", arg, t)
+			base.Errorf("negative %s argument in make(%v)", arg, t)
 			return false
 		}
 		if doesoverflow(v, types.Types[TINT]) {
-			yyerror("%s argument too large in make(%v)", arg, t)
+			base.Errorf("%s argument too large in make(%v)", arg, t)
 			return false
 		}
 	}
@@ -3874,7 +3875,7 @@ func checkreturn(fn *Node) {
 	if fn.Type.NumResults() != 0 && fn.Nbody.Len() != 0 {
 		markbreaklist(fn.Nbody, nil)
 		if !fn.Nbody.isterminating() {
-			yyerrorl(fn.Func.Endlineno, "missing return at end of function")
+			base.ErrorfAt(fn.Func.Endlineno, "missing return at end of function")
 		}
 	}
 }
@@ -4047,6 +4048,6 @@ func (n *Node) MethodFunc() *types.Field {
 	case OCALLPART:
 		return callpartMethod(n)
 	}
-	Fatalf("unexpected node: %v (%v)", n, n.Op)
+	base.Fatalf("unexpected node: %v (%v)", n, n.Op)
 	panic("unreachable")
 }
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index 8c32f2f6d2..aa0ee4075d 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -7,6 +7,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 )
@@ -98,7 +99,7 @@ func lexinit() {
 	for _, s := range &basicTypes {
 		etype := s.etype
 		if int(etype) >= len(types.Types) {
-			Fatalf("lexinit: %s bad etype", s.name)
+			base.Fatalf("lexinit: %s bad etype", s.name)
 		}
 		s2 := builtinpkg.Lookup(s.name)
 		t := types.Types[etype]
@@ -169,7 +170,7 @@ func lexinit() {
 
 func typeinit() {
 	if Widthptr == 0 {
-		Fatalf("typeinit before betypeinit")
+		base.Fatalf("typeinit before betypeinit")
 	}
 
 	for et := types.EType(0); et < NTYPE; et++ {
diff --git a/src/cmd/compile/internal/gc/unsafe.go b/src/cmd/compile/internal/gc/unsafe.go
index a3151e83bf..a1c1c1bf6e 100644
--- a/src/cmd/compile/internal/gc/unsafe.go
+++ b/src/cmd/compile/internal/gc/unsafe.go
@@ -4,6 +4,8 @@
 
 package gc
 
+import "cmd/compile/internal/base"
+
 // evalunsafe evaluates a package unsafe operation and returns the result.
 func evalunsafe(n *Node) int64 {
 	switch n.Op {
@@ -23,7 +25,7 @@ func evalunsafe(n *Node) int64 {
 	case OOFFSETOF:
 		// must be a selector.
 		if n.Left.Op != OXDOT {
-			yyerror("invalid expression %v", n)
+			base.Errorf("invalid expression %v", n)
 			return 0
 		}
 
@@ -41,10 +43,10 @@ func evalunsafe(n *Node) int64 {
 		case ODOT, ODOTPTR:
 			break
 		case OCALLPART:
-			yyerror("invalid expression %v: argument is a method value", n)
+			base.Errorf("invalid expression %v: argument is a method value", n)
 			return 0
 		default:
-			yyerror("invalid expression %v", n)
+			base.Errorf("invalid expression %v", n)
 			return 0
 		}
 
@@ -57,7 +59,7 @@ func evalunsafe(n *Node) int64 {
 				// but accessing f must not otherwise involve
 				// indirection via embedded pointer types.
 				if r.Left != sbase {
-					yyerror("invalid expression %v: selector implies indirection of embedded %v", n, r.Left)
+					base.Errorf("invalid expression %v: selector implies indirection of embedded %v", n, r.Left)
 					return 0
 				}
 				fallthrough
@@ -65,12 +67,12 @@ func evalunsafe(n *Node) int64 {
 				v += r.Xoffset
 			default:
 				Dump("unsafenmagic", n.Left)
-				Fatalf("impossible %#v node after dot insertion", r.Op)
+				base.Fatalf("impossible %#v node after dot insertion", r.Op)
 			}
 		}
 		return v
 	}
 
-	Fatalf("unexpected op %v", n.Op)
+	base.Fatalf("unexpected op %v", n.Op)
 	return 0
 }
diff --git a/src/cmd/compile/internal/gc/util.go b/src/cmd/compile/internal/gc/util.go
index d1a5993daf..597a29a940 100644
--- a/src/cmd/compile/internal/gc/util.go
+++ b/src/cmd/compile/internal/gc/util.go
@@ -8,27 +8,14 @@ import (
 	"os"
 	"runtime"
 	"runtime/pprof"
+
+	"cmd/compile/internal/base"
 )
 
 // Line returns n's position as a string. If n has been inlined,
 // it uses the outermost position where n has been inlined.
 func (n *Node) Line() string {
-	return linestr(n.Pos)
-}
-
-var atExitFuncs []func()
-
-func atExit(f func()) {
-	atExitFuncs = append(atExitFuncs, f)
-}
-
-func Exit(code int) {
-	for i := len(atExitFuncs) - 1; i >= 0; i-- {
-		f := atExitFuncs[i]
-		atExitFuncs = atExitFuncs[:i]
-		f()
-	}
-	os.Exit(code)
+	return base.FmtPos(n.Pos)
 }
 
 var (
@@ -37,25 +24,25 @@ var (
 )
 
 func startProfile() {
-	if Flag.CPUProfile != "" {
-		f, err := os.Create(Flag.CPUProfile)
+	if base.Flag.CPUProfile != "" {
+		f, err := os.Create(base.Flag.CPUProfile)
 		if err != nil {
-			Fatalf("%v", err)
+			base.Fatalf("%v", err)
 		}
 		if err := pprof.StartCPUProfile(f); err != nil {
-			Fatalf("%v", err)
+			base.Fatalf("%v", err)
 		}
-		atExit(pprof.StopCPUProfile)
+		base.AtExit(pprof.StopCPUProfile)
 	}
-	if Flag.MemProfile != "" {
+	if base.Flag.MemProfile != "" {
 		if memprofilerate != 0 {
 			runtime.MemProfileRate = int(memprofilerate)
 		}
-		f, err := os.Create(Flag.MemProfile)
+		f, err := os.Create(base.Flag.MemProfile)
 		if err != nil {
-			Fatalf("%v", err)
+			base.Fatalf("%v", err)
 		}
-		atExit(func() {
+		base.AtExit(func() {
 			// Profile all outstanding allocations.
 			runtime.GC()
 			// compilebench parses the memory profile to extract memstats,
@@ -63,36 +50,36 @@ func startProfile() {
 			// See golang.org/issue/18641 and runtime/pprof/pprof.go:writeHeap.
 			const writeLegacyFormat = 1
 			if err := pprof.Lookup("heap").WriteTo(f, writeLegacyFormat); err != nil {
-				Fatalf("%v", err)
+				base.Fatalf("%v", err)
 			}
 		})
 	} else {
 		// Not doing memory profiling; disable it entirely.
 		runtime.MemProfileRate = 0
 	}
-	if Flag.BlockProfile != "" {
-		f, err := os.Create(Flag.BlockProfile)
+	if base.Flag.BlockProfile != "" {
+		f, err := os.Create(base.Flag.BlockProfile)
 		if err != nil {
-			Fatalf("%v", err)
+			base.Fatalf("%v", err)
 		}
 		runtime.SetBlockProfileRate(1)
-		atExit(func() {
+		base.AtExit(func() {
 			pprof.Lookup("block").WriteTo(f, 0)
 			f.Close()
 		})
 	}
-	if Flag.MutexProfile != "" {
-		f, err := os.Create(Flag.MutexProfile)
+	if base.Flag.MutexProfile != "" {
+		f, err := os.Create(base.Flag.MutexProfile)
 		if err != nil {
-			Fatalf("%v", err)
+			base.Fatalf("%v", err)
 		}
 		startMutexProfiling()
-		atExit(func() {
+		base.AtExit(func() {
 			pprof.Lookup("mutex").WriteTo(f, 0)
 			f.Close()
 		})
 	}
-	if Flag.TraceProfile != "" && traceHandler != nil {
-		traceHandler(Flag.TraceProfile)
+	if base.Flag.TraceProfile != "" && traceHandler != nil {
+		traceHandler(base.Flag.TraceProfile)
 	}
 }
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index de2733909e..d7cd7ddf27 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
@@ -22,14 +23,14 @@ const zeroValSize = 1024 // must match value of runtime/map.go:maxZero
 
 func walk(fn *Node) {
 	Curfn = fn
-	errorsBefore := Errors()
+	errorsBefore := base.Errors()
 
-	if Flag.W != 0 {
+	if base.Flag.W != 0 {
 		s := fmt.Sprintf("\nbefore walk %v", Curfn.Func.Nname.Sym)
 		dumplist(s, Curfn.Nbody)
 	}
 
-	lno := lineno
+	lno := base.Pos
 
 	// Final typecheck for any unused variables.
 	for i, ln := range fn.Func.Dcl {
@@ -54,26 +55,26 @@ func walk(fn *Node) {
 			if defn.Left.Name.Used() {
 				continue
 			}
-			yyerrorl(defn.Left.Pos, "%v declared but not used", ln.Sym)
+			base.ErrorfAt(defn.Left.Pos, "%v declared but not used", ln.Sym)
 			defn.Left.Name.SetUsed(true) // suppress repeats
 		} else {
-			yyerrorl(ln.Pos, "%v declared but not used", ln.Sym)
+			base.ErrorfAt(ln.Pos, "%v declared but not used", ln.Sym)
 		}
 	}
 
-	lineno = lno
-	if Errors() > errorsBefore {
+	base.Pos = lno
+	if base.Errors() > errorsBefore {
 		return
 	}
 	walkstmtlist(Curfn.Nbody.Slice())
-	if Flag.W != 0 {
+	if base.Flag.W != 0 {
 		s := fmt.Sprintf("after walk %v", Curfn.Func.Nname.Sym)
 		dumplist(s, Curfn.Nbody)
 	}
 
 	zeroResults()
 	heapmoves()
-	if Flag.W != 0 && Curfn.Func.Enter.Len() > 0 {
+	if base.Flag.W != 0 && Curfn.Func.Enter.Len() > 0 {
 		s := fmt.Sprintf("enter %v", Curfn.Func.Nname.Sym)
 		dumplist(s, Curfn.Func.Enter)
 	}
@@ -116,9 +117,9 @@ func walkstmt(n *Node) *Node {
 	switch n.Op {
 	default:
 		if n.Op == ONAME {
-			yyerror("%v is not a top level statement", n.Sym)
+			base.Errorf("%v is not a top level statement", n.Sym)
 		} else {
-			yyerror("%v is not a top level statement", n.Op)
+			base.Errorf("%v is not a top level statement", n.Op)
 		}
 		Dump("nottop", n)
 
@@ -144,7 +145,7 @@ func walkstmt(n *Node) *Node {
 		ORECOVER,
 		OGETG:
 		if n.Typecheck() == 0 {
-			Fatalf("missing typecheck: %+v", n)
+			base.Fatalf("missing typecheck: %+v", n)
 		}
 		wascopy := n.Op == OCOPY
 		init := n.Ninit
@@ -159,7 +160,7 @@ func walkstmt(n *Node) *Node {
 	// the value received.
 	case ORECV:
 		if n.Typecheck() == 0 {
-			Fatalf("missing typecheck: %+v", n)
+			base.Fatalf("missing typecheck: %+v", n)
 		}
 		init := n.Ninit
 		n.Ninit.Set(nil)
@@ -186,8 +187,8 @@ func walkstmt(n *Node) *Node {
 	case ODCL:
 		v := n.Left
 		if v.Class() == PAUTOHEAP {
-			if Flag.CompilingRuntime {
-				yyerror("%v escapes to heap, not allowed in runtime", v)
+			if base.Flag.CompilingRuntime {
+				base.Errorf("%v escapes to heap, not allowed in runtime", v)
 			}
 			if prealloc[v] == nil {
 				prealloc[v] = callnew(v.Type)
@@ -202,7 +203,7 @@ func walkstmt(n *Node) *Node {
 		walkstmtlist(n.List.Slice())
 
 	case OCASE:
-		yyerror("case statement out of place")
+		base.Errorf("case statement out of place")
 
 	case ODEFER:
 		Curfn.Func.SetHasDefer(true)
@@ -291,7 +292,7 @@ func walkstmt(n *Node) *Node {
 			if got, want := n.List.Len(), len(rl); got != want {
 				// order should have rewritten multi-value function calls
 				// with explicit OAS2FUNC nodes.
-				Fatalf("expected %v return arguments, have %v", want, got)
+				base.Fatalf("expected %v return arguments, have %v", want, got)
 			}
 
 			// move function calls out, to make reorder3's job easier.
@@ -334,7 +335,7 @@ func walkstmt(n *Node) *Node {
 	}
 
 	if n.Op == ONAME {
-		Fatalf("walkstmt ended up with name: %+v", n)
+		base.Fatalf("walkstmt ended up with name: %+v", n)
 	}
 	return n
 }
@@ -405,7 +406,7 @@ func convFuncName(from, to *types.Type) (fnname string, needsaddr bool) {
 			return "convT2I", true
 		}
 	}
-	Fatalf("unknown conv func %c2%c", from.Tie(), to.Tie())
+	base.Fatalf("unknown conv func %c2%c", from.Tie(), to.Tie())
 	panic("unreachable")
 }
 
@@ -429,7 +430,7 @@ func walkexpr(n *Node, init *Nodes) *Node {
 		// not okay to use n->ninit when walking n,
 		// because we might replace n with some other node
 		// and would lose the init list.
-		Fatalf("walkexpr init == &n->ninit")
+		base.Fatalf("walkexpr init == &n->ninit")
 	}
 
 	if n.Ninit.Len() != 0 {
@@ -439,16 +440,16 @@ func walkexpr(n *Node, init *Nodes) *Node {
 
 	lno := setlineno(n)
 
-	if Flag.LowerW > 1 {
+	if base.Flag.LowerW > 1 {
 		Dump("before walk expr", n)
 	}
 
 	if n.Typecheck() != 1 {
-		Fatalf("missed typecheck: %+v", n)
+		base.Fatalf("missed typecheck: %+v", n)
 	}
 
 	if n.Type.IsUntyped() {
-		Fatalf("expression has untyped type: %+v", n)
+		base.Fatalf("expression has untyped type: %+v", n)
 	}
 
 	if n.Op == ONAME && n.Class() == PAUTOHEAP {
@@ -463,7 +464,7 @@ opswitch:
 	switch n.Op {
 	default:
 		Dump("walk", n)
-		Fatalf("walkexpr: switch 1 unknown op %+S", n)
+		base.Fatalf("walkexpr: switch 1 unknown op %+S", n)
 
 	case ONONAME, OEMPTY, OGETG, ONEWOBJ, OMETHEXPR:
 
@@ -587,7 +588,7 @@ opswitch:
 		// the mapassign call.
 		mapAppend := n.Left.Op == OINDEXMAP && n.Right.Op == OAPPEND
 		if mapAppend && !samesafeexpr(n.Left, n.Right.List.First()) {
-			Fatalf("not same expressions: %v != %v", n.Left, n.Right.List.First())
+			base.Fatalf("not same expressions: %v != %v", n.Left, n.Right.List.First())
 		}
 
 		n.Left = walkexpr(n.Left, init)
@@ -638,7 +639,7 @@ opswitch:
 			// x = append(...)
 			r := n.Right
 			if r.Type.Elem().NotInHeap() {
-				yyerror("%v can't be allocated in Go; it is incomplete (or unallocatable)", r.Type.Elem())
+				base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", r.Type.Elem())
 			}
 			switch {
 			case isAppendOfMake(r):
@@ -1046,25 +1047,25 @@ opswitch:
 		}
 		if t.IsArray() {
 			n.SetBounded(bounded(r, t.NumElem()))
-			if Flag.LowerM != 0 && n.Bounded() && !Isconst(n.Right, constant.Int) {
-				Warn("index bounds check elided")
+			if base.Flag.LowerM != 0 && n.Bounded() && !Isconst(n.Right, constant.Int) {
+				base.Warn("index bounds check elided")
 			}
 			if smallintconst(n.Right) && !n.Bounded() {
-				yyerror("index out of bounds")
+				base.Errorf("index out of bounds")
 			}
 		} else if Isconst(n.Left, constant.String) {
 			n.SetBounded(bounded(r, int64(len(n.Left.StringVal()))))
-			if Flag.LowerM != 0 && n.Bounded() && !Isconst(n.Right, constant.Int) {
-				Warn("index bounds check elided")
+			if base.Flag.LowerM != 0 && n.Bounded() && !Isconst(n.Right, constant.Int) {
+				base.Warn("index bounds check elided")
 			}
 			if smallintconst(n.Right) && !n.Bounded() {
-				yyerror("index out of bounds")
+				base.Errorf("index out of bounds")
 			}
 		}
 
 		if Isconst(n.Right, constant.Int) {
 			if v := n.Right.Val(); constant.Sign(v) < 0 || doesoverflow(v, types.Types[TINT]) {
-				yyerror("index out of bounds")
+				base.Errorf("index out of bounds")
 			}
 		}
 
@@ -1107,7 +1108,7 @@ opswitch:
 		n.SetTypecheck(1)
 
 	case ORECV:
-		Fatalf("walkexpr ORECV") // should see inside OAS only
+		base.Fatalf("walkexpr ORECV") // should see inside OAS only
 
 	case OSLICEHEADER:
 		n.Left = walkexpr(n.Left, init)
@@ -1149,11 +1150,11 @@ opswitch:
 
 	case ONEW:
 		if n.Type.Elem().NotInHeap() {
-			yyerror("%v can't be allocated in Go; it is incomplete (or unallocatable)", n.Type.Elem())
+			base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", n.Type.Elem())
 		}
 		if n.Esc == EscNone {
 			if n.Type.Elem().Width >= maxImplicitStackVarSize {
-				Fatalf("large ONEW with EscNone: %v", n)
+				base.Fatalf("large ONEW with EscNone: %v", n)
 			}
 			r := temp(n.Type.Elem())
 			r = nod(OAS, r, nil) // zero temp
@@ -1171,10 +1172,10 @@ opswitch:
 
 	case OAPPEND:
 		// order should make sure we only see OAS(node, OAPPEND), which we handle above.
-		Fatalf("append outside assignment")
+		base.Fatalf("append outside assignment")
 
 	case OCOPY:
-		n = copyany(n, init, instrumenting && !Flag.CompilingRuntime)
+		n = copyany(n, init, instrumenting && !base.Flag.CompilingRuntime)
 
 		// cannot use chanfn - closechan takes any, not chan any
 	case OCLOSE:
@@ -1320,17 +1321,17 @@ opswitch:
 		}
 		t := n.Type
 		if t.Elem().NotInHeap() {
-			yyerror("%v can't be allocated in Go; it is incomplete (or unallocatable)", t.Elem())
+			base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", t.Elem())
 		}
 		if n.Esc == EscNone {
 			if why := heapAllocReason(n); why != "" {
-				Fatalf("%v has EscNone, but %v", n, why)
+				base.Fatalf("%v has EscNone, but %v", n, why)
 			}
 			// var arr [r]T
 			// n = arr[:l]
 			i := indexconst(r)
 			if i < 0 {
-				Fatalf("walkexpr: invalid index %v", r)
+				base.Fatalf("walkexpr: invalid index %v", r)
 			}
 
 			// cap is constrained to [0,2^31) or [0,2^63) depending on whether
@@ -1392,12 +1393,12 @@ opswitch:
 
 	case OMAKESLICECOPY:
 		if n.Esc == EscNone {
-			Fatalf("OMAKESLICECOPY with EscNone: %v", n)
+			base.Fatalf("OMAKESLICECOPY with EscNone: %v", n)
 		}
 
 		t := n.Type
 		if t.Elem().NotInHeap() {
-			yyerror("%v can't be allocated in Go; it is incomplete (or unallocatable)", t.Elem())
+			base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", t.Elem())
 		}
 
 		length := conv(n.Left, types.Types[TINT])
@@ -1583,7 +1584,7 @@ opswitch:
 	t := n.Type
 	n = evalConst(n)
 	if n.Type != t {
-		Fatalf("evconst changed Type: %v had type %v, now %v", n, t, n.Type)
+		base.Fatalf("evconst changed Type: %v had type %v, now %v", n, t, n.Type)
 	}
 	if n.Op == OLITERAL {
 		n = typecheck(n, ctxExpr)
@@ -1596,11 +1597,11 @@ opswitch:
 
 	updateHasCall(n)
 
-	if Flag.LowerW != 0 && n != nil {
+	if base.Flag.LowerW != 0 && n != nil {
 		Dump("after walk expr", n)
 	}
 
-	lineno = lno
+	base.Pos = lno
 	return n
 }
 
@@ -1685,8 +1686,8 @@ func reduceSlice(n *Node) *Node {
 	n.SetSliceBounds(low, high, max)
 	if (n.Op == OSLICE || n.Op == OSLICESTR) && low == nil && high == nil {
 		// Reduce x[:] to x.
-		if Debug.Slice > 0 {
-			Warn("slice: omit slice operation")
+		if base.Debug.Slice > 0 {
+			base.Warn("slice: omit slice operation")
 		}
 		return n.Left
 	}
@@ -1736,7 +1737,7 @@ func ascompatee(op Op, nl, nr []*Node, init *Nodes) []*Node {
 		var nln, nrn Nodes
 		nln.Set(nl)
 		nrn.Set(nr)
-		Fatalf("error in shape across %+v %v %+v / %d %d [%s]", nln, op, nrn, len(nl), len(nr), Curfn.funcname())
+		base.Fatalf("error in shape across %+v %v %+v / %d %d [%s]", nln, op, nrn, len(nl), len(nr), Curfn.funcname())
 	}
 	return nn
 }
@@ -1758,7 +1759,7 @@ func fncall(l *Node, rt *types.Type) bool {
 //	expr-list = func()
 func ascompatet(nl Nodes, nr *types.Type) []*Node {
 	if nl.Len() != nr.NumFields() {
-		Fatalf("ascompatet: assignment count mismatch: %d = %d", nl.Len(), nr.NumFields())
+		base.Fatalf("ascompatet: assignment count mismatch: %d = %d", nl.Len(), nr.NumFields())
 	}
 
 	var nn, mm Nodes
@@ -1780,7 +1781,7 @@ func ascompatet(nl Nodes, nr *types.Type) []*Node {
 		}
 
 		res := nod(ORESULT, nil, nil)
-		res.Xoffset = Ctxt.FixedFrameSize() + r.Offset
+		res.Xoffset = base.Ctxt.FixedFrameSize() + r.Offset
 		res.Type = r.Type
 		res.SetTypecheck(1)
 
@@ -1789,7 +1790,7 @@ func ascompatet(nl Nodes, nr *types.Type) []*Node {
 		updateHasCall(a)
 		if a.HasCall() {
 			Dump("ascompatet ucount", a)
-			Fatalf("ascompatet: too many function calls evaluating parameters")
+			base.Fatalf("ascompatet: too many function calls evaluating parameters")
 		}
 
 		nn.Append(a)
@@ -1811,7 +1812,7 @@ func mkdotargslice(typ *types.Type, args []*Node) *Node {
 
 	n = typecheck(n, ctxExpr)
 	if n.Type == nil {
-		Fatalf("mkdotargslice: typecheck failed")
+		base.Fatalf("mkdotargslice: typecheck failed")
 	}
 	return n
 }
@@ -2069,7 +2070,7 @@ func isReflectHeaderDataField(l *Node) bool {
 
 func convas(n *Node, init *Nodes) *Node {
 	if n.Op != OAS {
-		Fatalf("convas: not OAS %v", n.Op)
+		base.Fatalf("convas: not OAS %v", n.Op)
 	}
 	defer updateHasCall(n)
 
@@ -2134,7 +2135,7 @@ func reorder3(all []*Node) []*Node {
 
 		switch l.Op {
 		default:
-			Fatalf("reorder3 unexpected lvalue %#v", l.Op)
+			base.Fatalf("reorder3 unexpected lvalue %#v", l.Op)
 
 		case ONAME:
 			break
@@ -2182,7 +2183,7 @@ func outervalue(n *Node) *Node {
 	for {
 		switch n.Op {
 		case OXDOT:
-			Fatalf("OXDOT in walk")
+			base.Fatalf("OXDOT in walk")
 		case ODOT, OPAREN, OCONVNOP:
 			n = n.Left
 			continue
@@ -2230,7 +2231,7 @@ func aliased(r *Node, all []*Node) bool {
 
 		switch l.Class() {
 		default:
-			Fatalf("unexpected class: %v, %v", l, l.Class())
+			base.Fatalf("unexpected class: %v, %v", l, l.Class())
 
 		case PAUTOHEAP, PEXTERN:
 			memwrite = true
@@ -2317,7 +2318,7 @@ func varexpr(n *Node) bool {
 
 	case ODOT: // but not ODOTPTR
 		// Should have been handled in aliased.
-		Fatalf("varexpr unexpected ODOT")
+		base.Fatalf("varexpr unexpected ODOT")
 	}
 
 	// Be conservative.
@@ -2468,25 +2469,25 @@ func returnsfromheap(params *types.Type) []*Node {
 // between the stack and the heap. The generated code is added to Curfn's
 // Enter and Exit lists.
 func heapmoves() {
-	lno := lineno
-	lineno = Curfn.Pos
+	lno := base.Pos
+	base.Pos = Curfn.Pos
 	nn := paramstoheap(Curfn.Type.Recvs())
 	nn = append(nn, paramstoheap(Curfn.Type.Params())...)
 	nn = append(nn, paramstoheap(Curfn.Type.Results())...)
 	Curfn.Func.Enter.Append(nn...)
-	lineno = Curfn.Func.Endlineno
+	base.Pos = Curfn.Func.Endlineno
 	Curfn.Func.Exit.Append(returnsfromheap(Curfn.Type.Results())...)
-	lineno = lno
+	base.Pos = lno
 }
 
 func vmkcall(fn *Node, t *types.Type, init *Nodes, va []*Node) *Node {
 	if fn.Type == nil || fn.Type.Etype != TFUNC {
-		Fatalf("mkcall %v %v", fn, fn.Type)
+		base.Fatalf("mkcall %v %v", fn, fn.Type)
 	}
 
 	n := fn.Type.NumParams()
 	if n != len(va) {
-		Fatalf("vmkcall %v needs %v args got %v", fn, n, len(va))
+		base.Fatalf("vmkcall %v needs %v args got %v", fn, n, len(va))
 	}
 
 	r := nod(OCALL, fn, nil)
@@ -2552,12 +2553,12 @@ func byteindex(n *Node) *Node {
 
 func chanfn(name string, n int, t *types.Type) *Node {
 	if !t.IsChan() {
-		Fatalf("chanfn %v", t)
+		base.Fatalf("chanfn %v", t)
 	}
 	fn := syslook(name)
 	switch n {
 	default:
-		Fatalf("chanfn %d", n)
+		base.Fatalf("chanfn %d", n)
 	case 1:
 		fn = substArgTypes(fn, t.Elem())
 	case 2:
@@ -2568,7 +2569,7 @@ func chanfn(name string, n int, t *types.Type) *Node {
 
 func mapfn(name string, t *types.Type) *Node {
 	if !t.IsMap() {
-		Fatalf("mapfn %v", t)
+		base.Fatalf("mapfn %v", t)
 	}
 	fn := syslook(name)
 	fn = substArgTypes(fn, t.Key(), t.Elem(), t.Key(), t.Elem())
@@ -2577,7 +2578,7 @@ func mapfn(name string, t *types.Type) *Node {
 
 func mapfndel(name string, t *types.Type) *Node {
 	if !t.IsMap() {
-		Fatalf("mapfn %v", t)
+		base.Fatalf("mapfn %v", t)
 	}
 	fn := syslook(name)
 	fn = substArgTypes(fn, t.Key(), t.Elem(), t.Key())
@@ -2618,7 +2619,7 @@ func mapfast(t *types.Type) int {
 		if Widthptr == 4 {
 			return mapfast32ptr
 		}
-		Fatalf("small pointer %v", t.Key())
+		base.Fatalf("small pointer %v", t.Key())
 	case AMEM64:
 		if !t.Key().HasPointers() {
 			return mapfast64
@@ -2645,7 +2646,7 @@ func addstr(n *Node, init *Nodes) *Node {
 	c := n.List.Len()
 
 	if c < 2 {
-		Fatalf("addstr count %d too small", c)
+		base.Fatalf("addstr count %d too small", c)
 	}
 
 	buf := nodnil()
@@ -2784,7 +2785,7 @@ func appendslice(n *Node, init *Nodes) *Node {
 		ptr1, len1 := nptr1.backingArrayPtrLen()
 		ptr2, len2 := nptr2.backingArrayPtrLen()
 		ncopy = mkcall1(fn, types.Types[TINT], &nodes, typename(elemtype), ptr1, len1, ptr2, len2)
-	} else if instrumenting && !Flag.CompilingRuntime {
+	} else if instrumenting && !base.Flag.CompilingRuntime {
 		// rely on runtime to instrument:
 		//  copy(s[len(l1):], l2)
 		// l2 can be a slice or string.
@@ -2827,12 +2828,12 @@ func appendslice(n *Node, init *Nodes) *Node {
 // isAppendOfMake reports whether n is of the form append(x , make([]T, y)...).
 // isAppendOfMake assumes n has already been typechecked.
 func isAppendOfMake(n *Node) bool {
-	if Flag.N != 0 || instrumenting {
+	if base.Flag.N != 0 || instrumenting {
 		return false
 	}
 
 	if n.Typecheck() == 0 {
-		Fatalf("missing typecheck: %+v", n)
+		base.Fatalf("missing typecheck: %+v", n)
 	}
 
 	if n.Op != OAPPEND || !n.IsDDD() || n.List.Len() != 2 {
@@ -3036,7 +3037,7 @@ func walkappend(n *Node, init *Nodes, dst *Node) *Node {
 
 	// General case, with no function calls left as arguments.
 	// Leave for gen, except that instrumentation requires old form.
-	if !instrumenting || Flag.CompilingRuntime {
+	if !instrumenting || base.Flag.CompilingRuntime {
 		return n
 	}
 
@@ -3185,7 +3186,7 @@ func eqfor(t *types.Type) (n *Node, needsize bool) {
 		})
 		return n, false
 	}
-	Fatalf("eqfor %v", t)
+	base.Fatalf("eqfor %v", t)
 	return nil, false
 }
 
@@ -3262,7 +3263,7 @@ func walkcompare(n *Node, init *Nodes) *Node {
 
 	switch t.Etype {
 	default:
-		if Debug.Libfuzzer != 0 && t.IsInteger() {
+		if base.Debug.Libfuzzer != 0 && t.IsInteger() {
 			n.Left = cheapexpr(n.Left, init)
 			n.Right = cheapexpr(n.Right, init)
 
@@ -3304,7 +3305,7 @@ func walkcompare(n *Node, init *Nodes) *Node {
 				}
 				paramType = types.Types[TUINT64]
 			default:
-				Fatalf("unexpected integer size %d for %v", t.Size(), t)
+				base.Fatalf("unexpected integer size %d for %v", t.Size(), t)
 			}
 			init.Append(mkcall(fn, nil, init, tracecmpArg(l, paramType, init), tracecmpArg(r, paramType, init)))
 		}
@@ -3329,7 +3330,7 @@ func walkcompare(n *Node, init *Nodes) *Node {
 	if !inline {
 		// eq algs take pointers; cmpl and cmpr must be addressable
 		if !islvalue(cmpl) || !islvalue(cmpr) {
-			Fatalf("arguments of comparison must be lvalues - %v %v", cmpl, cmpr)
+			base.Fatalf("arguments of comparison must be lvalues - %v %v", cmpl, cmpr)
 		}
 
 		fn, needsize := eqfor(t)
@@ -3722,7 +3723,7 @@ func usefield(n *Node) {
 
 	switch n.Op {
 	default:
-		Fatalf("usefield %v", n.Op)
+		base.Fatalf("usefield %v", n.Op)
 
 	case ODOT, ODOTPTR:
 		break
@@ -3739,10 +3740,10 @@ func usefield(n *Node) {
 	}
 	field := n.Opt().(*types.Field)
 	if field == nil {
-		Fatalf("usefield %v %v without paramfld", n.Left.Type, n.Sym)
+		base.Fatalf("usefield %v %v without paramfld", n.Left.Type, n.Sym)
 	}
 	if field.Sym != n.Sym || field.Offset != n.Xoffset {
-		Fatalf("field inconsistency: %v,%v != %v,%v", field.Sym, field.Offset, n.Sym, n.Xoffset)
+		base.Fatalf("field inconsistency: %v,%v != %v,%v", field.Sym, field.Offset, n.Sym, n.Xoffset)
 	}
 	if !strings.Contains(field.Note, "go:\"track\"") {
 		return
@@ -3753,10 +3754,10 @@ func usefield(n *Node) {
 		outer = outer.Elem()
 	}
 	if outer.Sym == nil {
-		yyerror("tracked field must be in named struct type")
+		base.Errorf("tracked field must be in named struct type")
 	}
 	if !types.IsExported(field.Sym.Name) {
-		yyerror("tracked field must be exported (upper case)")
+		base.Errorf("tracked field must be exported (upper case)")
 	}
 
 	sym := tracksym(outer, field)
@@ -3968,7 +3969,7 @@ func substArgTypes(old *Node, types_ ...*types.Type) *Node {
 	}
 	n.Type = types.SubstAny(n.Type, &types_)
 	if len(types_) > 0 {
-		Fatalf("substArgTypes: too many argument types")
+		base.Fatalf("substArgTypes: too many argument types")
 	}
 	return n
 }
@@ -3991,17 +3992,17 @@ func canMergeLoads() bool {
 // isRuneCount reports whether n is of the form len([]rune(string)).
 // These are optimized into a call to runtime.countrunes.
 func isRuneCount(n *Node) bool {
-	return Flag.N == 0 && !instrumenting && n.Op == OLEN && n.Left.Op == OSTR2RUNES
+	return base.Flag.N == 0 && !instrumenting && n.Op == OLEN && n.Left.Op == OSTR2RUNES
 }
 
 func walkCheckPtrAlignment(n *Node, init *Nodes, count *Node) *Node {
 	if !n.Type.IsPtr() {
-		Fatalf("expected pointer type: %v", n.Type)
+		base.Fatalf("expected pointer type: %v", n.Type)
 	}
 	elem := n.Type.Elem()
 	if count != nil {
 		if !elem.IsArray() {
-			Fatalf("expected array type: %v", elem)
+			base.Fatalf("expected array type: %v", elem)
 		}
 		elem = elem.Elem()
 	}
@@ -4031,7 +4032,7 @@ func walkCheckPtrArithmetic(n *Node, init *Nodes) *Node {
 	} else if opt != nil {
 		// We use n.Opt() here because today it's not used for OCONVNOP. If that changes,
 		// there's no guarantee that temporarily replacing it is safe, so just hard fail here.
-		Fatalf("unexpected Opt: %v", opt)
+		base.Fatalf("unexpected Opt: %v", opt)
 	}
 	n.SetOpt(&walkCheckPtrArithmeticMarker)
 	defer n.SetOpt(nil)
@@ -4087,5 +4088,5 @@ func walkCheckPtrArithmetic(n *Node, init *Nodes) *Node {
 // function fn at a given level. See debugHelpFooter for defined
 // levels.
 func checkPtr(fn *Node, level int) bool {
-	return Debug.Checkptr >= level && fn.Func.Pragma&NoCheckPtr == 0
+	return base.Debug.Checkptr >= level && fn.Func.Pragma&NoCheckPtr == 0
 }
diff --git a/src/cmd/compile/internal/mips/ggen.go b/src/cmd/compile/internal/mips/ggen.go
index 5e867721c3..2356267df7 100644
--- a/src/cmd/compile/internal/mips/ggen.go
+++ b/src/cmd/compile/internal/mips/ggen.go
@@ -5,6 +5,7 @@
 package mips
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
 	"cmd/internal/obj"
 	"cmd/internal/obj/mips"
@@ -18,7 +19,7 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 	}
 	if cnt < int64(4*gc.Widthptr) {
 		for i := int64(0); i < cnt; i += int64(gc.Widthptr) {
-			p = pp.Appendpp(p, mips.AMOVW, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGSP, gc.Ctxt.FixedFrameSize()+off+i)
+			p = pp.Appendpp(p, mips.AMOVW, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGSP, base.Ctxt.FixedFrameSize()+off+i)
 		}
 	} else {
 		//fmt.Printf("zerorange frame:%v, lo: %v, hi:%v \n", frame ,lo, hi)
@@ -28,7 +29,7 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 		//	MOVW	R0, (Widthptr)r1
 		//	ADD 	$Widthptr, r1
 		//	BNE		r1, r2, loop
-		p = pp.Appendpp(p, mips.AADD, obj.TYPE_CONST, 0, gc.Ctxt.FixedFrameSize()+off-4, obj.TYPE_REG, mips.REGRT1, 0)
+		p = pp.Appendpp(p, mips.AADD, obj.TYPE_CONST, 0, base.Ctxt.FixedFrameSize()+off-4, obj.TYPE_REG, mips.REGRT1, 0)
 		p.Reg = mips.REGSP
 		p = pp.Appendpp(p, mips.AADD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, mips.REGRT2, 0)
 		p.Reg = mips.REGRT1
diff --git a/src/cmd/compile/internal/mips/ssa.go b/src/cmd/compile/internal/mips/ssa.go
index 1d2e2c79e6..c37a2e0714 100644
--- a/src/cmd/compile/internal/mips/ssa.go
+++ b/src/cmd/compile/internal/mips/ssa.go
@@ -7,6 +7,7 @@ package mips
 import (
 	"math"
 
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
@@ -766,8 +767,8 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		if logopt.Enabled() {
 			logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
 		}
-		if gc.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
-			gc.Warnl(v.Pos, "generated nil check")
+		if base.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
+			base.WarnfAt(v.Pos, "generated nil check")
 		}
 	case ssa.OpMIPSFPFlagTrue,
 		ssa.OpMIPSFPFlagFalse:
@@ -796,7 +797,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		// caller's SP is FixedFrameSize below the address of the first arg
 		p := s.Prog(mips.AMOVW)
 		p.From.Type = obj.TYPE_ADDR
-		p.From.Offset = -gc.Ctxt.FixedFrameSize()
+		p.From.Offset = -base.Ctxt.FixedFrameSize()
 		p.From.Name = obj.NAME_PARAM
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
diff --git a/src/cmd/compile/internal/mips64/ssa.go b/src/cmd/compile/internal/mips64/ssa.go
index 067b8158c9..a7c10d8869 100644
--- a/src/cmd/compile/internal/mips64/ssa.go
+++ b/src/cmd/compile/internal/mips64/ssa.go
@@ -7,6 +7,7 @@ package mips64
 import (
 	"math"
 
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
@@ -724,8 +725,8 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		if logopt.Enabled() {
 			logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
 		}
-		if gc.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
-			gc.Warnl(v.Pos, "generated nil check")
+		if base.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
+			base.WarnfAt(v.Pos, "generated nil check")
 		}
 	case ssa.OpMIPS64FPFlagTrue,
 		ssa.OpMIPS64FPFlagFalse:
@@ -757,7 +758,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		// caller's SP is FixedFrameSize below the address of the first arg
 		p := s.Prog(mips.AMOVV)
 		p.From.Type = obj.TYPE_ADDR
-		p.From.Offset = -gc.Ctxt.FixedFrameSize()
+		p.From.Offset = -base.Ctxt.FixedFrameSize()
 		p.From.Name = obj.NAME_PARAM
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
diff --git a/src/cmd/compile/internal/ppc64/ggen.go b/src/cmd/compile/internal/ppc64/ggen.go
index a5a772b491..8f5caf5f99 100644
--- a/src/cmd/compile/internal/ppc64/ggen.go
+++ b/src/cmd/compile/internal/ppc64/ggen.go
@@ -5,6 +5,7 @@
 package ppc64
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
 	"cmd/internal/obj"
 	"cmd/internal/obj/ppc64"
@@ -16,17 +17,17 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 	}
 	if cnt < int64(4*gc.Widthptr) {
 		for i := int64(0); i < cnt; i += int64(gc.Widthptr) {
-			p = pp.Appendpp(p, ppc64.AMOVD, obj.TYPE_REG, ppc64.REGZERO, 0, obj.TYPE_MEM, ppc64.REGSP, gc.Ctxt.FixedFrameSize()+off+i)
+			p = pp.Appendpp(p, ppc64.AMOVD, obj.TYPE_REG, ppc64.REGZERO, 0, obj.TYPE_MEM, ppc64.REGSP, base.Ctxt.FixedFrameSize()+off+i)
 		}
 	} else if cnt <= int64(128*gc.Widthptr) {
-		p = pp.Appendpp(p, ppc64.AADD, obj.TYPE_CONST, 0, gc.Ctxt.FixedFrameSize()+off-8, obj.TYPE_REG, ppc64.REGRT1, 0)
+		p = pp.Appendpp(p, ppc64.AADD, obj.TYPE_CONST, 0, base.Ctxt.FixedFrameSize()+off-8, obj.TYPE_REG, ppc64.REGRT1, 0)
 		p.Reg = ppc64.REGSP
 		p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
 		p.To.Name = obj.NAME_EXTERN
 		p.To.Sym = gc.Duffzero
 		p.To.Offset = 4 * (128 - cnt/int64(gc.Widthptr))
 	} else {
-		p = pp.Appendpp(p, ppc64.AMOVD, obj.TYPE_CONST, 0, gc.Ctxt.FixedFrameSize()+off-8, obj.TYPE_REG, ppc64.REGTMP, 0)
+		p = pp.Appendpp(p, ppc64.AMOVD, obj.TYPE_CONST, 0, base.Ctxt.FixedFrameSize()+off-8, obj.TYPE_REG, ppc64.REGTMP, 0)
 		p = pp.Appendpp(p, ppc64.AADD, obj.TYPE_REG, ppc64.REGTMP, 0, obj.TYPE_REG, ppc64.REGRT1, 0)
 		p.Reg = ppc64.REGSP
 		p = pp.Appendpp(p, ppc64.AMOVD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, ppc64.REGTMP, 0)
@@ -66,7 +67,7 @@ func ginsnopdefer(pp *gc.Progs) *obj.Prog {
 	// on ppc64 in both shared and non-shared modes.
 
 	ginsnop(pp)
-	if gc.Ctxt.Flag_shared {
+	if base.Ctxt.Flag_shared {
 		p := pp.Prog(ppc64.AMOVD)
 		p.From.Type = obj.TYPE_MEM
 		p.From.Offset = 24
diff --git a/src/cmd/compile/internal/ppc64/ssa.go b/src/cmd/compile/internal/ppc64/ssa.go
index f0e7c41923..e3f0ee1a93 100644
--- a/src/cmd/compile/internal/ppc64/ssa.go
+++ b/src/cmd/compile/internal/ppc64/ssa.go
@@ -5,6 +5,7 @@
 package ppc64
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
@@ -473,7 +474,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		// caller's SP is FixedFrameSize below the address of the first arg
 		p := s.Prog(ppc64.AMOVD)
 		p.From.Type = obj.TYPE_ADDR
-		p.From.Offset = -gc.Ctxt.FixedFrameSize()
+		p.From.Offset = -base.Ctxt.FixedFrameSize()
 		p.From.Name = obj.NAME_PARAM
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
@@ -1784,7 +1785,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		// Insert a hint this is not a subroutine return.
 		pp.SetFrom3(obj.Addr{Type: obj.TYPE_CONST, Offset: 1})
 
-		if gc.Ctxt.Flag_shared {
+		if base.Ctxt.Flag_shared {
 			// When compiling Go into PIC, the function we just
 			// called via pointer might have been implemented in
 			// a separate module and so overwritten the TOC
@@ -1852,8 +1853,8 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		if logopt.Enabled() {
 			logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
 		}
-		if gc.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
-			gc.Warnl(v.Pos, "generated nil check")
+		if base.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
+			base.WarnfAt(v.Pos, "generated nil check")
 		}
 
 	// These should be resolved by rules and not make it here.
diff --git a/src/cmd/compile/internal/riscv64/ggen.go b/src/cmd/compile/internal/riscv64/ggen.go
index f7c03fe7c2..18905a4aea 100644
--- a/src/cmd/compile/internal/riscv64/ggen.go
+++ b/src/cmd/compile/internal/riscv64/ggen.go
@@ -5,6 +5,7 @@
 package riscv64
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
 	"cmd/internal/obj"
 	"cmd/internal/obj/riscv"
@@ -16,7 +17,7 @@ func zeroRange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 	}
 
 	// Adjust the frame to account for LR.
-	off += gc.Ctxt.FixedFrameSize()
+	off += base.Ctxt.FixedFrameSize()
 
 	if cnt < int64(4*gc.Widthptr) {
 		for i := int64(0); i < cnt; i += int64(gc.Widthptr) {
diff --git a/src/cmd/compile/internal/riscv64/ssa.go b/src/cmd/compile/internal/riscv64/ssa.go
index d49927ee04..5a71b33c00 100644
--- a/src/cmd/compile/internal/riscv64/ssa.go
+++ b/src/cmd/compile/internal/riscv64/ssa.go
@@ -5,6 +5,7 @@
 package riscv64
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
@@ -91,7 +92,7 @@ func loadByType(t *types.Type) obj.As {
 		case 8:
 			return riscv.AMOVD
 		default:
-			gc.Fatalf("unknown float width for load %d in type %v", width, t)
+			base.Fatalf("unknown float width for load %d in type %v", width, t)
 			return 0
 		}
 	}
@@ -118,7 +119,7 @@ func loadByType(t *types.Type) obj.As {
 	case 8:
 		return riscv.AMOV
 	default:
-		gc.Fatalf("unknown width for load %d in type %v", width, t)
+		base.Fatalf("unknown width for load %d in type %v", width, t)
 		return 0
 	}
 }
@@ -134,7 +135,7 @@ func storeByType(t *types.Type) obj.As {
 		case 8:
 			return riscv.AMOVD
 		default:
-			gc.Fatalf("unknown float width for store %d in type %v", width, t)
+			base.Fatalf("unknown float width for store %d in type %v", width, t)
 			return 0
 		}
 	}
@@ -149,7 +150,7 @@ func storeByType(t *types.Type) obj.As {
 	case 8:
 		return riscv.AMOV
 	default:
-		gc.Fatalf("unknown width for store %d in type %v", width, t)
+		base.Fatalf("unknown width for store %d in type %v", width, t)
 		return 0
 	}
 }
@@ -586,8 +587,8 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		gc.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = riscv.REG_ZERO
-		if gc.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos == 1 in generated wrappers
-			gc.Warnl(v.Pos, "generated nil check")
+		if base.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos == 1 in generated wrappers
+			base.WarnfAt(v.Pos, "generated nil check")
 		}
 
 	case ssa.OpRISCV64LoweredGetClosurePtr:
@@ -598,7 +599,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		// caller's SP is FixedFrameSize below the address of the first arg
 		p := s.Prog(riscv.AMOV)
 		p.From.Type = obj.TYPE_ADDR
-		p.From.Offset = -gc.Ctxt.FixedFrameSize()
+		p.From.Offset = -base.Ctxt.FixedFrameSize()
 		p.From.Name = obj.NAME_PARAM
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
diff --git a/src/cmd/compile/internal/s390x/ggen.go b/src/cmd/compile/internal/s390x/ggen.go
index 5a837d8574..0e2f48bf4c 100644
--- a/src/cmd/compile/internal/s390x/ggen.go
+++ b/src/cmd/compile/internal/s390x/ggen.go
@@ -5,6 +5,7 @@
 package s390x
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
 	"cmd/internal/obj"
 	"cmd/internal/obj/s390x"
@@ -23,7 +24,7 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 	}
 
 	// Adjust the frame to account for LR.
-	off += gc.Ctxt.FixedFrameSize()
+	off += base.Ctxt.FixedFrameSize()
 	reg := int16(s390x.REGSP)
 
 	// If the off cannot fit in a 12-bit unsigned displacement then we
diff --git a/src/cmd/compile/internal/s390x/ssa.go b/src/cmd/compile/internal/s390x/ssa.go
index cb13f8d3c0..366adffd98 100644
--- a/src/cmd/compile/internal/s390x/ssa.go
+++ b/src/cmd/compile/internal/s390x/ssa.go
@@ -7,6 +7,7 @@ package s390x
 import (
 	"math"
 
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
@@ -573,7 +574,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		// caller's SP is FixedFrameSize below the address of the first arg
 		p := s.Prog(s390x.AMOVD)
 		p.From.Type = obj.TYPE_ADDR
-		p.From.Offset = -gc.Ctxt.FixedFrameSize()
+		p.From.Offset = -base.Ctxt.FixedFrameSize()
 		p.From.Name = obj.NAME_PARAM
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
@@ -642,8 +643,8 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		if logopt.Enabled() {
 			logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
 		}
-		if gc.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
-			gc.Warnl(v.Pos, "generated nil check")
+		if base.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
+			base.WarnfAt(v.Pos, "generated nil check")
 		}
 	case ssa.OpS390XMVC:
 		vo := v.AuxValAndOff()
diff --git a/src/cmd/compile/internal/wasm/ssa.go b/src/cmd/compile/internal/wasm/ssa.go
index 3f05515b9a..373dc431e5 100644
--- a/src/cmd/compile/internal/wasm/ssa.go
+++ b/src/cmd/compile/internal/wasm/ssa.go
@@ -5,6 +5,7 @@
 package wasm
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
@@ -33,7 +34,7 @@ func zeroRange(pp *gc.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.Pr
 		return p
 	}
 	if cnt%8 != 0 {
-		gc.Fatalf("zerorange count not a multiple of widthptr %d", cnt)
+		base.Fatalf("zerorange count not a multiple of widthptr %d", cnt)
 	}
 
 	for i := int64(0); i < cnt; i += 8 {
@@ -165,8 +166,8 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		if logopt.Enabled() {
 			logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
 		}
-		if gc.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
-			gc.Warnl(v.Pos, "generated nil check")
+		if base.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
+			base.WarnfAt(v.Pos, "generated nil check")
 		}
 
 	case ssa.OpWasmLoweredWB:
diff --git a/src/cmd/compile/internal/x86/galign.go b/src/cmd/compile/internal/x86/galign.go
index e137daa3fc..7d628f9b7c 100644
--- a/src/cmd/compile/internal/x86/galign.go
+++ b/src/cmd/compile/internal/x86/galign.go
@@ -5,6 +5,7 @@
 package x86
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
 	"cmd/internal/obj/x86"
 	"cmd/internal/objabi"
@@ -24,10 +25,10 @@ func Init(arch *gc.Arch) {
 		arch.SoftFloat = true
 	case "387":
 		fmt.Fprintf(os.Stderr, "unsupported setting GO386=387. Consider using GO386=softfloat instead.\n")
-		gc.Exit(1)
+		base.Exit(1)
 	default:
 		fmt.Fprintf(os.Stderr, "unsupported setting GO386=%s\n", v)
-		gc.Exit(1)
+		base.Exit(1)
 
 	}
 
diff --git a/src/cmd/compile/internal/x86/ssa.go b/src/cmd/compile/internal/x86/ssa.go
index 65d7e75a53..a3aaf03c95 100644
--- a/src/cmd/compile/internal/x86/ssa.go
+++ b/src/cmd/compile/internal/x86/ssa.go
@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"math"
 
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
@@ -480,9 +481,9 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Name = obj.NAME_EXTERN
 		f := math.Float64frombits(uint64(v.AuxInt))
 		if v.Op == ssa.Op386MOVSDconst1 {
-			p.From.Sym = gc.Ctxt.Float64Sym(f)
+			p.From.Sym = base.Ctxt.Float64Sym(f)
 		} else {
-			p.From.Sym = gc.Ctxt.Float32Sym(float32(f))
+			p.From.Sym = base.Ctxt.Float32Sym(float32(f))
 		}
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
@@ -713,7 +714,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		r := v.Reg()
 		// See the comments in cmd/internal/obj/x86/obj6.go
 		// near CanUse1InsnTLS for a detailed explanation of these instructions.
-		if x86.CanUse1InsnTLS(gc.Ctxt) {
+		if x86.CanUse1InsnTLS(base.Ctxt) {
 			// MOVL (TLS), r
 			p := s.Prog(x86.AMOVL)
 			p.From.Type = obj.TYPE_MEM
@@ -749,7 +750,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		// caller's SP is the address of the first arg
 		p := s.Prog(x86.AMOVL)
 		p.From.Type = obj.TYPE_ADDR
-		p.From.Offset = -gc.Ctxt.FixedFrameSize() // 0 on 386, just to be consistent with other architectures
+		p.From.Offset = -base.Ctxt.FixedFrameSize() // 0 on 386, just to be consistent with other architectures
 		p.From.Name = obj.NAME_PARAM
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
@@ -850,8 +851,8 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		if logopt.Enabled() {
 			logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
 		}
-		if gc.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
-			gc.Warnl(v.Pos, "generated nil check")
+		if base.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
+			base.WarnfAt(v.Pos, "generated nil check")
 		}
 	case ssa.OpClobber:
 		p := s.Prog(x86.AMOVL)
diff --git a/src/cmd/compile/main.go b/src/cmd/compile/main.go
index 3aa64a5ce2..5a33719d87 100644
--- a/src/cmd/compile/main.go
+++ b/src/cmd/compile/main.go
@@ -8,6 +8,7 @@ import (
 	"cmd/compile/internal/amd64"
 	"cmd/compile/internal/arm"
 	"cmd/compile/internal/arm64"
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
 	"cmd/compile/internal/mips"
 	"cmd/compile/internal/mips64"
@@ -50,5 +51,5 @@ func main() {
 	}
 
 	gc.Main(archInit)
-	gc.Exit(0)
+	base.Exit(0)
 }
diff --git a/src/cmd/dist/buildtool.go b/src/cmd/dist/buildtool.go
index e39f284db5..f8e1f2f951 100644
--- a/src/cmd/dist/buildtool.go
+++ b/src/cmd/dist/buildtool.go
@@ -38,6 +38,7 @@ var bootstrapDirs = []string{
 	"cmd/cgo",
 	"cmd/compile",
 	"cmd/compile/internal/amd64",
+	"cmd/compile/internal/base",
 	"cmd/compile/internal/arm",
 	"cmd/compile/internal/arm64",
 	"cmd/compile/internal/gc",
@@ -72,6 +73,7 @@ var bootstrapDirs = []string{
 	"cmd/internal/sys",
 	"cmd/link",
 	"cmd/link/internal/amd64",
+	"cmd/compile/internal/base",
 	"cmd/link/internal/arm",
 	"cmd/link/internal/arm64",
 	"cmd/link/internal/benchmark",
-- 
GitLab


From 331b8b4797bc4e134a8d8b78bf1c060689144145 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 24 Nov 2020 22:52:37 -0500
Subject: [PATCH 0068/2400] [dev.regabi] cmd/compile: move okforconst into its
 own declaration

It needs to move into package ir, and we do not want all the rest.

Change-Id: Ibcfa1ebc0e63fe3659267bf2fa7069e8a93de4e9
Reviewed-on: https://go-review.googlesource.com/c/go/+/272930
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/go.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index e9ff5aeb13..d9b8f704a9 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -145,9 +145,10 @@ var (
 	okforcap   [NTYPE]bool
 	okforlen   [NTYPE]bool
 	okforarith [NTYPE]bool
-	okforconst [NTYPE]bool
 )
 
+var okforconst [NTYPE]bool
+
 var (
 	okfor [OEND][]bool
 	iscmp [OEND]bool
-- 
GitLab


From 84e2bd611f9b62ec3b581f8a0d932dc4252ceb67 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 19 Nov 2020 21:09:22 -0500
Subject: [PATCH 0069/2400] [dev.regabi] cmd/compile: introduce
 cmd/compile/internal/ir [generated]

If we want to break up package gc at all, we will need to move
the compiler IR it defines into a separate package that can be
imported by packages that gc itself imports. This CL does that.
It also removes the TINT8 etc aliases so that all code is clear
about which package things are coming from.

This CL is automatically generated by the script below.
See the comments in the script for details about the changes.

[git-generate]
cd src/cmd/compile/internal/gc

rf '
        # These names were never fully qualified
        # when the types package was added.
        # Do it now, to avoid confusion about where they live.
        inline -rm \
                Txxx \
                TINT8 \
                TUINT8 \
                TINT16 \
                TUINT16 \
                TINT32 \
                TUINT32 \
                TINT64 \
                TUINT64 \
                TINT \
                TUINT \
                TUINTPTR \
                TCOMPLEX64 \
                TCOMPLEX128 \
                TFLOAT32 \
                TFLOAT64 \
                TBOOL \
                TPTR \
                TFUNC \
                TSLICE \
                TARRAY \
                TSTRUCT \
                TCHAN \
                TMAP \
                TINTER \
                TFORW \
                TANY \
                TSTRING \
                TUNSAFEPTR \
                TIDEAL \
                TNIL \
                TBLANK \
                TFUNCARGS \
                TCHANARGS \
                NTYPE \
                BADWIDTH

        # esc.go and escape.go do not need to be split.
        # Append esc.go onto the end of escape.go.
        mv esc.go escape.go

        # Pull out the type format installation from func Main,
        # so it can be carried into package ir.
        mv Main:/Sconv.=/-0,/TypeLinkSym/-1 InstallTypeFormats

        # Names that need to be exported for use by code left in gc.
        mv Isconst IsConst
        mv asNode AsNode
        mv asNodes AsNodes
        mv asTypesNode AsTypesNode
        mv basicnames BasicTypeNames
        mv builtinpkg BuiltinPkg
        mv consttype ConstType
        mv dumplist DumpList
        mv fdumplist FDumpList
        mv fmtMode FmtMode
        mv goopnames OpNames
        mv inspect Inspect
        mv inspectList InspectList
        mv localpkg LocalPkg
        mv nblank BlankNode
        mv numImport NumImport
        mv opprec OpPrec
        mv origSym OrigSym
        mv stmtwithinit StmtWithInit
        mv dump DumpAny
        mv fdump FDumpAny
        mv nod Nod
        mv nodl NodAt
        mv newname NewName
        mv newnamel NewNameAt
        mv assertRepresents AssertValidTypeForConst
        mv represents ValidTypeForConst
        mv nodlit NewLiteral

        # Types and fields that need to be exported for use by gc.
        mv nowritebarrierrecCallSym SymAndPos
        mv SymAndPos.lineno SymAndPos.Pos
        mv SymAndPos.target SymAndPos.Sym

        mv Func.lsym Func.LSym
        mv Func.setWBPos Func.SetWBPos
        mv Func.numReturns Func.NumReturns
        mv Func.numDefers Func.NumDefers
        mv Func.nwbrCalls Func.NWBRCalls

        # initLSym is an algorithm left behind in gc,
        # not an operation on Func itself.
        mv Func.initLSym initLSym

        mv nodeQueue NodeQueue
        mv NodeQueue.empty NodeQueue.Empty
        mv NodeQueue.popLeft NodeQueue.PopLeft
        mv NodeQueue.pushRight NodeQueue.PushRight

        # Many methods on Node are actually algorithms that
        # would apply to any node implementation.
        # Those become plain functions.
        mv Node.funcname FuncName
        mv Node.isBlank IsBlank
        mv Node.isGoConst isGoConst
        mv Node.isNil IsNil
        mv Node.isParamHeapCopy isParamHeapCopy
        mv Node.isParamStackCopy isParamStackCopy
        mv Node.isSimpleName isSimpleName
        mv Node.mayBeShared MayBeShared
        mv Node.pkgFuncName PkgFuncName
        mv Node.backingArrayPtrLen backingArrayPtrLen
        mv Node.isterminating isTermNode
        mv Node.labeledControl labeledControl
        mv Nodes.isterminating isTermNodes
        mv Nodes.sigerr fmtSignature
        mv Node.MethodName methodExprName
        mv Node.MethodFunc methodExprFunc
        mv Node.IsMethod IsMethod

        # Every node will need to implement RawCopy;
        # Copy and SepCopy algorithms will use it.
        mv Node.rawcopy Node.RawCopy
        mv Node.copy Copy
        mv Node.sepcopy SepCopy

        # Extract Node.Format method body into func FmtNode,
        # but leave method wrapper behind.
        mv Node.Format:0,$ FmtNode

        # Formatting helpers that will apply to all node implementations.
        mv Node.Line Line
        mv Node.exprfmt exprFmt
        mv Node.jconv jconvFmt
        mv Node.modeString modeString
        mv Node.nconv nconvFmt
        mv Node.nodedump nodeDumpFmt
        mv Node.nodefmt nodeFmt
        mv Node.stmtfmt stmtFmt

	# Constant support needed for code moving to ir.
        mv okforconst OKForConst
        mv vconv FmtConst
        mv int64Val Int64Val
        mv float64Val Float64Val
        mv Node.ValueInterface ConstValue

        # Organize code into files.
        mv LocalPkg BuiltinPkg ir.go
        mv NumImport InstallTypeFormats Line fmt.go
        mv syntax.go Nod NodAt NewNameAt Class Pxxx PragmaFlag Nointerface SymAndPos \
                AsNode AsTypesNode BlankNode OrigSym \
                Node.SliceBounds Node.SetSliceBounds Op.IsSlice3 \
                IsConst Node.Int64Val Node.CanInt64 Node.Uint64Val Node.BoolVal Node.StringVal \
                Node.RawCopy SepCopy Copy \
                IsNil IsBlank IsMethod \
                Node.Typ Node.StorageClass node.go
        mv ConstType ConstValue Int64Val Float64Val AssertValidTypeForConst ValidTypeForConst NewLiteral idealType OKForConst val.go

        # Move files to new ir package.
        mv bitset.go class_string.go dump.go fmt.go \
                ir.go node.go op_string.go val.go \
                sizeof_test.go cmd/compile/internal/ir
'

: # fix mkbuiltin.go to generate the changes made to builtin.go during rf
sed -i '' '
        s/\[T/[types.T/g
        s/\*Node/*ir.Node/g
        /internal\/types/c \
                fmt.Fprintln(&b, `import (`) \
                fmt.Fprintln(&b, `      "cmd/compile/internal/ir"`) \
                fmt.Fprintln(&b, `      "cmd/compile/internal/types"`) \
                fmt.Fprintln(&b, `)`)
' mkbuiltin.go
gofmt -w mkbuiltin.go

: # update cmd/dist to add internal/ir
cd ../../../dist
sed -i '' '/compile.internal.gc/a\
        "cmd/compile/internal/ir",
' buildtool.go
gofmt -w buildtool.go

: # update cmd/compile TestFormats
cd ../..
go install std cmd
cd cmd/compile
go test -u || go test  # first one updates but fails; second passes

Change-Id: I5f7caf6b20629b51970279e81231a3574d5b51db
Reviewed-on: https://go-review.googlesource.com/c/go/+/273008
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/fmtmap_test.go                |   40 +-
 src/cmd/compile/internal/arm/ssa.go           |    3 +-
 src/cmd/compile/internal/arm64/ssa.go         |    3 +-
 src/cmd/compile/internal/gc/alg.go            |  271 +--
 src/cmd/compile/internal/gc/align.go          |   57 +-
 src/cmd/compile/internal/gc/bexport.go        |   63 +-
 src/cmd/compile/internal/gc/bimport.go        |   13 +-
 src/cmd/compile/internal/gc/builtin.go        |  219 +-
 src/cmd/compile/internal/gc/closure.go        |  121 +-
 src/cmd/compile/internal/gc/const.go          |  432 ++--
 src/cmd/compile/internal/gc/dcl.go            |  329 ++-
 src/cmd/compile/internal/gc/embed.go          |   29 +-
 src/cmd/compile/internal/gc/esc.go            |  474 ----
 src/cmd/compile/internal/gc/escape.go         |  778 +++++--
 src/cmd/compile/internal/gc/export.go         |   55 +-
 src/cmd/compile/internal/gc/gen.go            |   25 +-
 src/cmd/compile/internal/gc/go.go             |   80 +-
 src/cmd/compile/internal/gc/gsubr.go          |   45 +-
 src/cmd/compile/internal/gc/iexport.go        |  297 +--
 src/cmd/compile/internal/gc/iimport.go        |  225 +-
 src/cmd/compile/internal/gc/init.go           |   21 +-
 src/cmd/compile/internal/gc/initorder.go      |   90 +-
 src/cmd/compile/internal/gc/inl.go            |  413 ++--
 src/cmd/compile/internal/gc/lex.go            |   86 +-
 src/cmd/compile/internal/gc/main.go           |   76 +-
 src/cmd/compile/internal/gc/mkbuiltin.go      |   13 +-
 src/cmd/compile/internal/gc/noder.go          |  387 ++--
 src/cmd/compile/internal/gc/obj.go            |   81 +-
 src/cmd/compile/internal/gc/order.go          |  429 ++--
 src/cmd/compile/internal/gc/pgen.go           |  147 +-
 src/cmd/compile/internal/gc/pgen_test.go      |  151 +-
 src/cmd/compile/internal/gc/phi.go            |   35 +-
 src/cmd/compile/internal/gc/plive.go          |   77 +-
 src/cmd/compile/internal/gc/racewalk.go       |    9 +-
 src/cmd/compile/internal/gc/range.go          |  199 +-
 src/cmd/compile/internal/gc/reflect.go        |  321 +--
 src/cmd/compile/internal/gc/scc.go            |   40 +-
 src/cmd/compile/internal/gc/scope.go          |   11 +-
 src/cmd/compile/internal/gc/select.go         |  153 +-
 src/cmd/compile/internal/gc/sinit.go          |  393 ++--
 src/cmd/compile/internal/gc/ssa.go            | 1976 ++++++++---------
 src/cmd/compile/internal/gc/subr.go           |  594 ++---
 src/cmd/compile/internal/gc/swt.go            |  203 +-
 src/cmd/compile/internal/gc/typecheck.go      | 1009 ++++-----
 src/cmd/compile/internal/gc/types.go          |   53 -
 src/cmd/compile/internal/gc/types_acc.go      |    8 -
 src/cmd/compile/internal/gc/universe.go       |  366 ++-
 src/cmd/compile/internal/gc/unsafe.go         |   25 +-
 src/cmd/compile/internal/gc/util.go           |    6 -
 src/cmd/compile/internal/gc/walk.go           | 1539 ++++++-------
 src/cmd/compile/internal/{gc => ir}/bitset.go |    2 +-
 .../internal/{gc => ir}/class_string.go       |    2 +-
 src/cmd/compile/internal/{gc => ir}/dump.go   |   17 +-
 src/cmd/compile/internal/{gc => ir}/fmt.go    |  269 ++-
 src/cmd/compile/internal/ir/ir.go             |   12 +
 .../internal/{gc/syntax.go => ir/node.go}     |  396 +++-
 .../compile/internal/{gc => ir}/op_string.go  |    2 +-
 .../internal/{gc => ir}/sizeof_test.go        |    2 +-
 src/cmd/compile/internal/ir/val.go            |  120 +
 src/cmd/compile/internal/mips/ssa.go          |    3 +-
 src/cmd/compile/internal/mips64/ssa.go        |    3 +-
 src/cmd/compile/internal/ppc64/ssa.go         |    3 +-
 src/cmd/compile/internal/riscv64/ssa.go       |    3 +-
 src/cmd/compile/internal/wasm/ssa.go          |    3 +-
 src/cmd/dist/buildtool.go                     |    1 +
 65 files changed, 6666 insertions(+), 6642 deletions(-)
 delete mode 100644 src/cmd/compile/internal/gc/esc.go
 rename src/cmd/compile/internal/{gc => ir}/bitset.go (99%)
 rename src/cmd/compile/internal/{gc => ir}/class_string.go (98%)
 rename src/cmd/compile/internal/{gc => ir}/dump.go (96%)
 rename src/cmd/compile/internal/{gc => ir}/fmt.go (87%)
 create mode 100644 src/cmd/compile/internal/ir/ir.go
 rename src/cmd/compile/internal/{gc/syntax.go => ir/node.go} (82%)
 rename src/cmd/compile/internal/{gc => ir}/op_string.go (99%)
 rename src/cmd/compile/internal/{gc => ir}/sizeof_test.go (98%)
 create mode 100644 src/cmd/compile/internal/ir/val.go

diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
index e32233bcaf..404e89d0f2 100644
--- a/src/cmd/compile/fmtmap_test.go
+++ b/src/cmd/compile/fmtmap_test.go
@@ -22,14 +22,14 @@ package main_test
 var knownFormats = map[string]string{
 	"*bytes.Buffer %s":                                "",
 	"*cmd/compile/internal/gc.EscLocation %v":         "",
-	"*cmd/compile/internal/gc.Node %#v":               "",
-	"*cmd/compile/internal/gc.Node %+S":               "",
-	"*cmd/compile/internal/gc.Node %+v":               "",
-	"*cmd/compile/internal/gc.Node %L":                "",
-	"*cmd/compile/internal/gc.Node %S":                "",
-	"*cmd/compile/internal/gc.Node %j":                "",
-	"*cmd/compile/internal/gc.Node %p":                "",
-	"*cmd/compile/internal/gc.Node %v":                "",
+	"*cmd/compile/internal/ir.Node %#v":               "",
+	"*cmd/compile/internal/ir.Node %+S":               "",
+	"*cmd/compile/internal/ir.Node %+v":               "",
+	"*cmd/compile/internal/ir.Node %L":                "",
+	"*cmd/compile/internal/ir.Node %S":                "",
+	"*cmd/compile/internal/ir.Node %j":                "",
+	"*cmd/compile/internal/ir.Node %p":                "",
+	"*cmd/compile/internal/ir.Node %v":                "",
 	"*cmd/compile/internal/ssa.Block %s":              "",
 	"*cmd/compile/internal/ssa.Block %v":              "",
 	"*cmd/compile/internal/ssa.Func %s":               "",
@@ -78,18 +78,18 @@ var knownFormats = map[string]string{
 	"byte %q":                                         "",
 	"byte %v":                                         "",
 	"cmd/compile/internal/arm.shift %d":               "",
-	"cmd/compile/internal/gc.Class %d":                "",
-	"cmd/compile/internal/gc.Class %s":                "",
-	"cmd/compile/internal/gc.Class %v":                "",
-	"cmd/compile/internal/gc.Nodes %#v":               "",
-	"cmd/compile/internal/gc.Nodes %+v":               "",
-	"cmd/compile/internal/gc.Nodes %.v":               "",
-	"cmd/compile/internal/gc.Nodes %v":                "",
-	"cmd/compile/internal/gc.Op %#v":                  "",
-	"cmd/compile/internal/gc.Op %v":                   "",
-	"cmd/compile/internal/gc.fmtMode %d":              "",
 	"cmd/compile/internal/gc.initKind %d":             "",
 	"cmd/compile/internal/gc.itag %v":                 "",
+	"cmd/compile/internal/ir.Class %d":                "",
+	"cmd/compile/internal/ir.Class %s":                "",
+	"cmd/compile/internal/ir.Class %v":                "",
+	"cmd/compile/internal/ir.FmtMode %d":              "",
+	"cmd/compile/internal/ir.Nodes %#v":               "",
+	"cmd/compile/internal/ir.Nodes %+v":               "",
+	"cmd/compile/internal/ir.Nodes %.v":               "",
+	"cmd/compile/internal/ir.Nodes %v":                "",
+	"cmd/compile/internal/ir.Op %#v":                  "",
+	"cmd/compile/internal/ir.Op %v":                   "",
 	"cmd/compile/internal/ssa.BranchPrediction %d":    "",
 	"cmd/compile/internal/ssa.Edge %v":                "",
 	"cmd/compile/internal/ssa.GCNode %v":              "",
@@ -162,8 +162,8 @@ var knownFormats = map[string]string{
 	"interface{} %q":                                  "",
 	"interface{} %s":                                  "",
 	"interface{} %v":                                  "",
-	"map[*cmd/compile/internal/gc.Node]*cmd/compile/internal/ssa.Value %v": "",
-	"map[*cmd/compile/internal/gc.Node][]*cmd/compile/internal/gc.Node %v": "",
+	"map[*cmd/compile/internal/ir.Node]*cmd/compile/internal/ssa.Value %v": "",
+	"map[*cmd/compile/internal/ir.Node][]*cmd/compile/internal/ir.Node %v": "",
 	"map[cmd/compile/internal/ssa.ID]uint32 %v":                            "",
 	"map[int64]uint32 %v":  "",
 	"math/big.Accuracy %s": "",
diff --git a/src/cmd/compile/internal/arm/ssa.go b/src/cmd/compile/internal/arm/ssa.go
index 7d34cc5170..ff1dd8869e 100644
--- a/src/cmd/compile/internal/arm/ssa.go
+++ b/src/cmd/compile/internal/arm/ssa.go
@@ -11,6 +11,7 @@ import (
 
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
@@ -545,7 +546,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		case *obj.LSym:
 			wantreg = "SB"
 			gc.AddAux(&p.From, v)
-		case *gc.Node:
+		case *ir.Node:
 			wantreg = "SP"
 			gc.AddAux(&p.From, v)
 		case nil:
diff --git a/src/cmd/compile/internal/arm64/ssa.go b/src/cmd/compile/internal/arm64/ssa.go
index 5e6f607708..58c00dc3bd 100644
--- a/src/cmd/compile/internal/arm64/ssa.go
+++ b/src/cmd/compile/internal/arm64/ssa.go
@@ -9,6 +9,7 @@ import (
 
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
@@ -395,7 +396,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		case *obj.LSym:
 			wantreg = "SB"
 			gc.AddAux(&p.From, v)
-		case *gc.Node:
+		case *ir.Node:
 			wantreg = "SP"
 			gc.AddAux(&p.From, v)
 		case nil:
diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index 517aaa4b81..cf82b9d591 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"fmt"
@@ -70,11 +71,11 @@ func EqCanPanic(t *types.Type) bool {
 	switch t.Etype {
 	default:
 		return false
-	case TINTER:
+	case types.TINTER:
 		return true
-	case TARRAY:
+	case types.TARRAY:
 		return EqCanPanic(t.Elem())
-	case TSTRUCT:
+	case types.TSTRUCT:
 		for _, f := range t.FieldSlice() {
 			if !f.Sym.IsBlank() && EqCanPanic(f.Type) {
 				return true
@@ -120,45 +121,45 @@ func algtype1(t *types.Type) (AlgKind, *types.Type) {
 	}
 
 	switch t.Etype {
-	case TANY, TFORW:
+	case types.TANY, types.TFORW:
 		// will be defined later.
 		return ANOEQ, t
 
-	case TINT8, TUINT8, TINT16, TUINT16,
-		TINT32, TUINT32, TINT64, TUINT64,
-		TINT, TUINT, TUINTPTR,
-		TBOOL, TPTR,
-		TCHAN, TUNSAFEPTR:
+	case types.TINT8, types.TUINT8, types.TINT16, types.TUINT16,
+		types.TINT32, types.TUINT32, types.TINT64, types.TUINT64,
+		types.TINT, types.TUINT, types.TUINTPTR,
+		types.TBOOL, types.TPTR,
+		types.TCHAN, types.TUNSAFEPTR:
 		return AMEM, nil
 
-	case TFUNC, TMAP:
+	case types.TFUNC, types.TMAP:
 		return ANOEQ, t
 
-	case TFLOAT32:
+	case types.TFLOAT32:
 		return AFLOAT32, nil
 
-	case TFLOAT64:
+	case types.TFLOAT64:
 		return AFLOAT64, nil
 
-	case TCOMPLEX64:
+	case types.TCOMPLEX64:
 		return ACPLX64, nil
 
-	case TCOMPLEX128:
+	case types.TCOMPLEX128:
 		return ACPLX128, nil
 
-	case TSTRING:
+	case types.TSTRING:
 		return ASTRING, nil
 
-	case TINTER:
+	case types.TINTER:
 		if t.IsEmptyInterface() {
 			return ANILINTER, nil
 		}
 		return AINTER, nil
 
-	case TSLICE:
+	case types.TSLICE:
 		return ANOEQ, t
 
-	case TARRAY:
+	case types.TARRAY:
 		a, bad := algtype1(t.Elem())
 		switch a {
 		case AMEM:
@@ -178,7 +179,7 @@ func algtype1(t *types.Type) (AlgKind, *types.Type) {
 
 		return ASPECIAL, nil
 
-	case TSTRUCT:
+	case types.TSTRUCT:
 		fields := t.FieldSlice()
 
 		// One-field struct is same as that one field alone.
@@ -288,19 +289,19 @@ func genhash(t *types.Type) *obj.LSym {
 	}
 
 	base.Pos = autogeneratedPos // less confusing than end of input
-	dclcontext = PEXTERN
+	dclcontext = ir.PEXTERN
 
 	// func sym(p *T, h uintptr) uintptr
-	tfn := nod(OTFUNC, nil, nil)
+	tfn := ir.Nod(ir.OTFUNC, nil, nil)
 	tfn.List.Set2(
 		namedfield("p", types.NewPtr(t)),
-		namedfield("h", types.Types[TUINTPTR]),
+		namedfield("h", types.Types[types.TUINTPTR]),
 	)
-	tfn.Rlist.Set1(anonfield(types.Types[TUINTPTR]))
+	tfn.Rlist.Set1(anonfield(types.Types[types.TUINTPTR]))
 
 	fn := dclfunc(sym, tfn)
-	np := asNode(tfn.Type.Params().Field(0).Nname)
-	nh := asNode(tfn.Type.Params().Field(1).Nname)
+	np := ir.AsNode(tfn.Type.Params().Field(0).Nname)
+	nh := ir.AsNode(tfn.Type.Params().Field(1).Nname)
 
 	switch t.Etype {
 	case types.TARRAY:
@@ -309,23 +310,23 @@ func genhash(t *types.Type) *obj.LSym {
 		// pure memory.
 		hashel := hashfor(t.Elem())
 
-		n := nod(ORANGE, nil, nod(ODEREF, np, nil))
-		ni := newname(lookup("i"))
-		ni.Type = types.Types[TINT]
+		n := ir.Nod(ir.ORANGE, nil, ir.Nod(ir.ODEREF, np, nil))
+		ni := NewName(lookup("i"))
+		ni.Type = types.Types[types.TINT]
 		n.List.Set1(ni)
 		n.SetColas(true)
 		colasdefn(n.List.Slice(), n)
 		ni = n.List.First()
 
 		// h = hashel(&p[i], h)
-		call := nod(OCALL, hashel, nil)
+		call := ir.Nod(ir.OCALL, hashel, nil)
 
-		nx := nod(OINDEX, np, ni)
+		nx := ir.Nod(ir.OINDEX, np, ni)
 		nx.SetBounded(true)
-		na := nod(OADDR, nx, nil)
+		na := ir.Nod(ir.OADDR, nx, nil)
 		call.List.Append(na)
 		call.List.Append(nh)
-		n.Nbody.Append(nod(OAS, nh, call))
+		n.Nbody.Append(ir.Nod(ir.OAS, nh, call))
 
 		fn.Nbody.Append(n)
 
@@ -344,12 +345,12 @@ func genhash(t *types.Type) *obj.LSym {
 			// Hash non-memory fields with appropriate hash function.
 			if !IsRegularMemory(f.Type) {
 				hashel := hashfor(f.Type)
-				call := nod(OCALL, hashel, nil)
-				nx := nodSym(OXDOT, np, f.Sym) // TODO: fields from other packages?
-				na := nod(OADDR, nx, nil)
+				call := ir.Nod(ir.OCALL, hashel, nil)
+				nx := nodSym(ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
+				na := ir.Nod(ir.OADDR, nx, nil)
 				call.List.Append(na)
 				call.List.Append(nh)
-				fn.Nbody.Append(nod(OAS, nh, call))
+				fn.Nbody.Append(ir.Nod(ir.OAS, nh, call))
 				i++
 				continue
 			}
@@ -359,24 +360,24 @@ func genhash(t *types.Type) *obj.LSym {
 
 			// h = hashel(&p.first, size, h)
 			hashel := hashmem(f.Type)
-			call := nod(OCALL, hashel, nil)
-			nx := nodSym(OXDOT, np, f.Sym) // TODO: fields from other packages?
-			na := nod(OADDR, nx, nil)
+			call := ir.Nod(ir.OCALL, hashel, nil)
+			nx := nodSym(ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
+			na := ir.Nod(ir.OADDR, nx, nil)
 			call.List.Append(na)
 			call.List.Append(nh)
 			call.List.Append(nodintconst(size))
-			fn.Nbody.Append(nod(OAS, nh, call))
+			fn.Nbody.Append(ir.Nod(ir.OAS, nh, call))
 
 			i = next
 		}
 	}
 
-	r := nod(ORETURN, nil, nil)
+	r := ir.Nod(ir.ORETURN, nil, nil)
 	r.List.Append(nh)
 	fn.Nbody.Append(r)
 
 	if base.Flag.LowerR != 0 {
-		dumplist("genhash body", fn.Nbody)
+		ir.DumpList("genhash body", fn.Nbody)
 	}
 
 	funcbody()
@@ -403,7 +404,7 @@ func genhash(t *types.Type) *obj.LSym {
 	return closure
 }
 
-func hashfor(t *types.Type) *Node {
+func hashfor(t *types.Type) *ir.Node {
 	var sym *types.Sym
 
 	switch a, _ := algtype1(t); a {
@@ -429,13 +430,13 @@ func hashfor(t *types.Type) *Node {
 		sym = typesymprefix(".hash", t)
 	}
 
-	n := newname(sym)
+	n := NewName(sym)
 	setNodeNameFunc(n)
-	n.Type = functype(nil, []*Node{
+	n.Type = functype(nil, []*ir.Node{
 		anonfield(types.NewPtr(t)),
-		anonfield(types.Types[TUINTPTR]),
-	}, []*Node{
-		anonfield(types.Types[TUINTPTR]),
+		anonfield(types.Types[types.TUINTPTR]),
+	}, []*ir.Node{
+		anonfield(types.Types[types.TUINTPTR]),
 	})
 	return n
 }
@@ -517,20 +518,20 @@ func geneq(t *types.Type) *obj.LSym {
 	// Autogenerate code for equality of structs and arrays.
 
 	base.Pos = autogeneratedPos // less confusing than end of input
-	dclcontext = PEXTERN
+	dclcontext = ir.PEXTERN
 
 	// func sym(p, q *T) bool
-	tfn := nod(OTFUNC, nil, nil)
+	tfn := ir.Nod(ir.OTFUNC, nil, nil)
 	tfn.List.Set2(
 		namedfield("p", types.NewPtr(t)),
 		namedfield("q", types.NewPtr(t)),
 	)
-	tfn.Rlist.Set1(namedfield("r", types.Types[TBOOL]))
+	tfn.Rlist.Set1(namedfield("r", types.Types[types.TBOOL]))
 
 	fn := dclfunc(sym, tfn)
-	np := asNode(tfn.Type.Params().Field(0).Nname)
-	nq := asNode(tfn.Type.Params().Field(1).Nname)
-	nr := asNode(tfn.Type.Results().Field(0).Nname)
+	np := ir.AsNode(tfn.Type.Params().Field(0).Nname)
+	nq := ir.AsNode(tfn.Type.Params().Field(1).Nname)
+	nr := ir.AsNode(tfn.Type.Results().Field(0).Nname)
 
 	// Label to jump to if an equality test fails.
 	neq := autolabel(".neq")
@@ -542,7 +543,7 @@ func geneq(t *types.Type) *obj.LSym {
 	default:
 		base.Fatalf("geneq %v", t)
 
-	case TARRAY:
+	case types.TARRAY:
 		nelem := t.NumElem()
 
 		// checkAll generates code to check the equality of all array elements.
@@ -566,15 +567,15 @@ func geneq(t *types.Type) *obj.LSym {
 		//
 		// TODO(josharian): consider doing some loop unrolling
 		// for larger nelem as well, processing a few elements at a time in a loop.
-		checkAll := func(unroll int64, last bool, eq func(pi, qi *Node) *Node) {
+		checkAll := func(unroll int64, last bool, eq func(pi, qi *ir.Node) *ir.Node) {
 			// checkIdx generates a node to check for equality at index i.
-			checkIdx := func(i *Node) *Node {
+			checkIdx := func(i *ir.Node) *ir.Node {
 				// pi := p[i]
-				pi := nod(OINDEX, np, i)
+				pi := ir.Nod(ir.OINDEX, np, i)
 				pi.SetBounded(true)
 				pi.Type = t.Elem()
 				// qi := q[i]
-				qi := nod(OINDEX, nq, i)
+				qi := ir.Nod(ir.OINDEX, nq, i)
 				qi.SetBounded(true)
 				qi.Type = t.Elem()
 				return eq(pi, qi)
@@ -588,68 +589,68 @@ func geneq(t *types.Type) *obj.LSym {
 				// Generate a series of checks.
 				for i := int64(0); i < nelem; i++ {
 					// if check {} else { goto neq }
-					nif := nod(OIF, checkIdx(nodintconst(i)), nil)
-					nif.Rlist.Append(nodSym(OGOTO, nil, neq))
+					nif := ir.Nod(ir.OIF, checkIdx(nodintconst(i)), nil)
+					nif.Rlist.Append(nodSym(ir.OGOTO, nil, neq))
 					fn.Nbody.Append(nif)
 				}
 				if last {
-					fn.Nbody.Append(nod(OAS, nr, checkIdx(nodintconst(nelem))))
+					fn.Nbody.Append(ir.Nod(ir.OAS, nr, checkIdx(nodintconst(nelem))))
 				}
 			} else {
 				// Generate a for loop.
 				// for i := 0; i < nelem; i++
-				i := temp(types.Types[TINT])
-				init := nod(OAS, i, nodintconst(0))
-				cond := nod(OLT, i, nodintconst(nelem))
-				post := nod(OAS, i, nod(OADD, i, nodintconst(1)))
-				loop := nod(OFOR, cond, post)
+				i := temp(types.Types[types.TINT])
+				init := ir.Nod(ir.OAS, i, nodintconst(0))
+				cond := ir.Nod(ir.OLT, i, nodintconst(nelem))
+				post := ir.Nod(ir.OAS, i, ir.Nod(ir.OADD, i, nodintconst(1)))
+				loop := ir.Nod(ir.OFOR, cond, post)
 				loop.Ninit.Append(init)
 				// if eq(pi, qi) {} else { goto neq }
-				nif := nod(OIF, checkIdx(i), nil)
-				nif.Rlist.Append(nodSym(OGOTO, nil, neq))
+				nif := ir.Nod(ir.OIF, checkIdx(i), nil)
+				nif.Rlist.Append(nodSym(ir.OGOTO, nil, neq))
 				loop.Nbody.Append(nif)
 				fn.Nbody.Append(loop)
 				if last {
-					fn.Nbody.Append(nod(OAS, nr, nodbool(true)))
+					fn.Nbody.Append(ir.Nod(ir.OAS, nr, nodbool(true)))
 				}
 			}
 		}
 
 		switch t.Elem().Etype {
-		case TSTRING:
+		case types.TSTRING:
 			// Do two loops. First, check that all the lengths match (cheap).
 			// Second, check that all the contents match (expensive).
 			// TODO: when the array size is small, unroll the length match checks.
-			checkAll(3, false, func(pi, qi *Node) *Node {
+			checkAll(3, false, func(pi, qi *ir.Node) *ir.Node {
 				// Compare lengths.
 				eqlen, _ := eqstring(pi, qi)
 				return eqlen
 			})
-			checkAll(1, true, func(pi, qi *Node) *Node {
+			checkAll(1, true, func(pi, qi *ir.Node) *ir.Node {
 				// Compare contents.
 				_, eqmem := eqstring(pi, qi)
 				return eqmem
 			})
-		case TFLOAT32, TFLOAT64:
-			checkAll(2, true, func(pi, qi *Node) *Node {
+		case types.TFLOAT32, types.TFLOAT64:
+			checkAll(2, true, func(pi, qi *ir.Node) *ir.Node {
 				// p[i] == q[i]
-				return nod(OEQ, pi, qi)
+				return ir.Nod(ir.OEQ, pi, qi)
 			})
 		// TODO: pick apart structs, do them piecemeal too
 		default:
-			checkAll(1, true, func(pi, qi *Node) *Node {
+			checkAll(1, true, func(pi, qi *ir.Node) *ir.Node {
 				// p[i] == q[i]
-				return nod(OEQ, pi, qi)
+				return ir.Nod(ir.OEQ, pi, qi)
 			})
 		}
 
-	case TSTRUCT:
+	case types.TSTRUCT:
 		// Build a list of conditions to satisfy.
 		// The conditions are a list-of-lists. Conditions are reorderable
 		// within each inner list. The outer lists must be evaluated in order.
-		var conds [][]*Node
-		conds = append(conds, []*Node{})
-		and := func(n *Node) {
+		var conds [][]*ir.Node
+		conds = append(conds, []*ir.Node{})
+		and := func(n *ir.Node) {
 			i := len(conds) - 1
 			conds[i] = append(conds[i], n)
 		}
@@ -669,21 +670,21 @@ func geneq(t *types.Type) *obj.LSym {
 			if !IsRegularMemory(f.Type) {
 				if EqCanPanic(f.Type) {
 					// Enforce ordering by starting a new set of reorderable conditions.
-					conds = append(conds, []*Node{})
+					conds = append(conds, []*ir.Node{})
 				}
-				p := nodSym(OXDOT, np, f.Sym)
-				q := nodSym(OXDOT, nq, f.Sym)
+				p := nodSym(ir.OXDOT, np, f.Sym)
+				q := nodSym(ir.OXDOT, nq, f.Sym)
 				switch {
 				case f.Type.IsString():
 					eqlen, eqmem := eqstring(p, q)
 					and(eqlen)
 					and(eqmem)
 				default:
-					and(nod(OEQ, p, q))
+					and(ir.Nod(ir.OEQ, p, q))
 				}
 				if EqCanPanic(f.Type) {
 					// Also enforce ordering after something that can panic.
-					conds = append(conds, []*Node{})
+					conds = append(conds, []*ir.Node{})
 				}
 				i++
 				continue
@@ -708,10 +709,10 @@ func geneq(t *types.Type) *obj.LSym {
 
 		// Sort conditions to put runtime calls last.
 		// Preserve the rest of the ordering.
-		var flatConds []*Node
+		var flatConds []*ir.Node
 		for _, c := range conds {
-			isCall := func(n *Node) bool {
-				return n.Op == OCALL || n.Op == OCALLFUNC
+			isCall := func(n *ir.Node) bool {
+				return n.Op == ir.OCALL || n.Op == ir.OCALLFUNC
 			}
 			sort.SliceStable(c, func(i, j int) bool {
 				return !isCall(c[i]) && isCall(c[j])
@@ -720,42 +721,42 @@ func geneq(t *types.Type) *obj.LSym {
 		}
 
 		if len(flatConds) == 0 {
-			fn.Nbody.Append(nod(OAS, nr, nodbool(true)))
+			fn.Nbody.Append(ir.Nod(ir.OAS, nr, nodbool(true)))
 		} else {
 			for _, c := range flatConds[:len(flatConds)-1] {
 				// if cond {} else { goto neq }
-				n := nod(OIF, c, nil)
-				n.Rlist.Append(nodSym(OGOTO, nil, neq))
+				n := ir.Nod(ir.OIF, c, nil)
+				n.Rlist.Append(nodSym(ir.OGOTO, nil, neq))
 				fn.Nbody.Append(n)
 			}
-			fn.Nbody.Append(nod(OAS, nr, flatConds[len(flatConds)-1]))
+			fn.Nbody.Append(ir.Nod(ir.OAS, nr, flatConds[len(flatConds)-1]))
 		}
 	}
 
 	// ret:
 	//   return
 	ret := autolabel(".ret")
-	fn.Nbody.Append(nodSym(OLABEL, nil, ret))
-	fn.Nbody.Append(nod(ORETURN, nil, nil))
+	fn.Nbody.Append(nodSym(ir.OLABEL, nil, ret))
+	fn.Nbody.Append(ir.Nod(ir.ORETURN, nil, nil))
 
 	// neq:
 	//   r = false
 	//   return (or goto ret)
-	fn.Nbody.Append(nodSym(OLABEL, nil, neq))
-	fn.Nbody.Append(nod(OAS, nr, nodbool(false)))
+	fn.Nbody.Append(nodSym(ir.OLABEL, nil, neq))
+	fn.Nbody.Append(ir.Nod(ir.OAS, nr, nodbool(false)))
 	if EqCanPanic(t) || hasCall(fn) {
 		// Epilogue is large, so share it with the equal case.
-		fn.Nbody.Append(nodSym(OGOTO, nil, ret))
+		fn.Nbody.Append(nodSym(ir.OGOTO, nil, ret))
 	} else {
 		// Epilogue is small, so don't bother sharing.
-		fn.Nbody.Append(nod(ORETURN, nil, nil))
+		fn.Nbody.Append(ir.Nod(ir.ORETURN, nil, nil))
 	}
 	// TODO(khr): the epilogue size detection condition above isn't perfect.
 	// We should really do a generic CL that shares epilogues across
 	// the board. See #24936.
 
 	if base.Flag.LowerR != 0 {
-		dumplist("geneq body", fn.Nbody)
+		ir.DumpList("geneq body", fn.Nbody)
 	}
 
 	funcbody()
@@ -784,8 +785,8 @@ func geneq(t *types.Type) *obj.LSym {
 	return closure
 }
 
-func hasCall(n *Node) bool {
-	if n.Op == OCALL || n.Op == OCALLFUNC {
+func hasCall(n *ir.Node) bool {
+	if n.Op == ir.OCALL || n.Op == ir.OCALLFUNC {
 		return true
 	}
 	if n.Left != nil && hasCall(n.Left) {
@@ -819,10 +820,10 @@ func hasCall(n *Node) bool {
 
 // eqfield returns the node
 // 	p.field == q.field
-func eqfield(p *Node, q *Node, field *types.Sym) *Node {
-	nx := nodSym(OXDOT, p, field)
-	ny := nodSym(OXDOT, q, field)
-	ne := nod(OEQ, nx, ny)
+func eqfield(p *ir.Node, q *ir.Node, field *types.Sym) *ir.Node {
+	nx := nodSym(ir.OXDOT, p, field)
+	ny := nodSym(ir.OXDOT, q, field)
+	ne := ir.Nod(ir.OEQ, nx, ny)
 	return ne
 }
 
@@ -832,23 +833,23 @@ func eqfield(p *Node, q *Node, field *types.Sym) *Node {
 //   memequal(s.ptr, t.ptr, len(s))
 // which can be used to construct string equality comparison.
 // eqlen must be evaluated before eqmem, and shortcircuiting is required.
-func eqstring(s, t *Node) (eqlen, eqmem *Node) {
-	s = conv(s, types.Types[TSTRING])
-	t = conv(t, types.Types[TSTRING])
-	sptr := nod(OSPTR, s, nil)
-	tptr := nod(OSPTR, t, nil)
-	slen := conv(nod(OLEN, s, nil), types.Types[TUINTPTR])
-	tlen := conv(nod(OLEN, t, nil), types.Types[TUINTPTR])
+func eqstring(s, t *ir.Node) (eqlen, eqmem *ir.Node) {
+	s = conv(s, types.Types[types.TSTRING])
+	t = conv(t, types.Types[types.TSTRING])
+	sptr := ir.Nod(ir.OSPTR, s, nil)
+	tptr := ir.Nod(ir.OSPTR, t, nil)
+	slen := conv(ir.Nod(ir.OLEN, s, nil), types.Types[types.TUINTPTR])
+	tlen := conv(ir.Nod(ir.OLEN, t, nil), types.Types[types.TUINTPTR])
 
 	fn := syslook("memequal")
-	fn = substArgTypes(fn, types.Types[TUINT8], types.Types[TUINT8])
-	call := nod(OCALL, fn, nil)
-	call.List.Append(sptr, tptr, slen.copy())
+	fn = substArgTypes(fn, types.Types[types.TUINT8], types.Types[types.TUINT8])
+	call := ir.Nod(ir.OCALL, fn, nil)
+	call.List.Append(sptr, tptr, ir.Copy(slen))
 	call = typecheck(call, ctxExpr|ctxMultiOK)
 
-	cmp := nod(OEQ, slen, tlen)
+	cmp := ir.Nod(ir.OEQ, slen, tlen)
 	cmp = typecheck(cmp, ctxExpr)
-	cmp.Type = types.Types[TBOOL]
+	cmp.Type = types.Types[types.TBOOL]
 	return cmp, call
 }
 
@@ -858,48 +859,48 @@ func eqstring(s, t *Node) (eqlen, eqmem *Node) {
 //   ifaceeq(s.tab, s.data, t.data) (or efaceeq(s.typ, s.data, t.data), as appropriate)
 // which can be used to construct interface equality comparison.
 // eqtab must be evaluated before eqdata, and shortcircuiting is required.
-func eqinterface(s, t *Node) (eqtab, eqdata *Node) {
+func eqinterface(s, t *ir.Node) (eqtab, eqdata *ir.Node) {
 	if !types.Identical(s.Type, t.Type) {
 		base.Fatalf("eqinterface %v %v", s.Type, t.Type)
 	}
 	// func ifaceeq(tab *uintptr, x, y unsafe.Pointer) (ret bool)
 	// func efaceeq(typ *uintptr, x, y unsafe.Pointer) (ret bool)
-	var fn *Node
+	var fn *ir.Node
 	if s.Type.IsEmptyInterface() {
 		fn = syslook("efaceeq")
 	} else {
 		fn = syslook("ifaceeq")
 	}
 
-	stab := nod(OITAB, s, nil)
-	ttab := nod(OITAB, t, nil)
-	sdata := nod(OIDATA, s, nil)
-	tdata := nod(OIDATA, t, nil)
-	sdata.Type = types.Types[TUNSAFEPTR]
-	tdata.Type = types.Types[TUNSAFEPTR]
+	stab := ir.Nod(ir.OITAB, s, nil)
+	ttab := ir.Nod(ir.OITAB, t, nil)
+	sdata := ir.Nod(ir.OIDATA, s, nil)
+	tdata := ir.Nod(ir.OIDATA, t, nil)
+	sdata.Type = types.Types[types.TUNSAFEPTR]
+	tdata.Type = types.Types[types.TUNSAFEPTR]
 	sdata.SetTypecheck(1)
 	tdata.SetTypecheck(1)
 
-	call := nod(OCALL, fn, nil)
+	call := ir.Nod(ir.OCALL, fn, nil)
 	call.List.Append(stab, sdata, tdata)
 	call = typecheck(call, ctxExpr|ctxMultiOK)
 
-	cmp := nod(OEQ, stab, ttab)
+	cmp := ir.Nod(ir.OEQ, stab, ttab)
 	cmp = typecheck(cmp, ctxExpr)
-	cmp.Type = types.Types[TBOOL]
+	cmp.Type = types.Types[types.TBOOL]
 	return cmp, call
 }
 
 // eqmem returns the node
 // 	memequal(&p.field, &q.field [, size])
-func eqmem(p *Node, q *Node, field *types.Sym, size int64) *Node {
-	nx := nod(OADDR, nodSym(OXDOT, p, field), nil)
-	ny := nod(OADDR, nodSym(OXDOT, q, field), nil)
+func eqmem(p *ir.Node, q *ir.Node, field *types.Sym, size int64) *ir.Node {
+	nx := ir.Nod(ir.OADDR, nodSym(ir.OXDOT, p, field), nil)
+	ny := ir.Nod(ir.OADDR, nodSym(ir.OXDOT, q, field), nil)
 	nx = typecheck(nx, ctxExpr)
 	ny = typecheck(ny, ctxExpr)
 
 	fn, needsize := eqmemfunc(size, nx.Type.Elem())
-	call := nod(OCALL, fn, nil)
+	call := ir.Nod(ir.OCALL, fn, nil)
 	call.List.Append(nx)
 	call.List.Append(ny)
 	if needsize {
@@ -909,7 +910,7 @@ func eqmem(p *Node, q *Node, field *types.Sym, size int64) *Node {
 	return call
 }
 
-func eqmemfunc(size int64, t *types.Type) (fn *Node, needsize bool) {
+func eqmemfunc(size int64, t *types.Type) (fn *ir.Node, needsize bool) {
 	switch size {
 	default:
 		fn = syslook("memequal")
diff --git a/src/cmd/compile/internal/gc/align.go b/src/cmd/compile/internal/gc/align.go
index a8cbbfd322..1bc8bf238f 100644
--- a/src/cmd/compile/internal/gc/align.go
+++ b/src/cmd/compile/internal/gc/align.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"bytes"
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"fmt"
 	"sort"
@@ -117,7 +118,7 @@ func widstruct(errtype *types.Type, t *types.Type, o int64, flag int) int64 {
 			o = Rnd(o, int64(f.Type.Align))
 		}
 		f.Offset = o
-		if n := asNode(f.Nname); n != nil {
+		if n := ir.AsNode(f.Nname); n != nil {
 			// addrescapes has similar code to update these offsets.
 			// Usually addrescapes runs after widstruct,
 			// in which case we could drop this,
@@ -197,7 +198,7 @@ func findTypeLoop(t *types.Type, path *[]*types.Type) bool {
 		}
 
 		*path = append(*path, t)
-		if p := asNode(t.Nod).Name.Param; p != nil && findTypeLoop(p.Ntype.Type, path) {
+		if p := ir.AsNode(t.Nod).Name.Param; p != nil && findTypeLoop(p.Ntype.Type, path) {
 			return true
 		}
 		*path = (*path)[:len(*path)-1]
@@ -205,17 +206,17 @@ func findTypeLoop(t *types.Type, path *[]*types.Type) bool {
 		// Anonymous type. Recurse on contained types.
 
 		switch t.Etype {
-		case TARRAY:
+		case types.TARRAY:
 			if findTypeLoop(t.Elem(), path) {
 				return true
 			}
-		case TSTRUCT:
+		case types.TSTRUCT:
 			for _, f := range t.Fields().Slice() {
 				if findTypeLoop(f.Type, path) {
 					return true
 				}
 			}
-		case TINTER:
+		case types.TINTER:
 			for _, m := range t.Methods().Slice() {
 				if m.Type.IsInterface() { // embedded interface
 					if findTypeLoop(m.Type, path) {
@@ -306,8 +307,8 @@ func dowidth(t *types.Type) {
 	defercheckwidth()
 
 	lno := base.Pos
-	if asNode(t.Nod) != nil {
-		base.Pos = asNode(t.Nod).Pos
+	if ir.AsNode(t.Nod) != nil {
+		base.Pos = ir.AsNode(t.Nod).Pos
 	}
 
 	t.Width = -2
@@ -315,7 +316,7 @@ func dowidth(t *types.Type) {
 
 	et := t.Etype
 	switch et {
-	case TFUNC, TCHAN, TMAP, TSTRING:
+	case types.TFUNC, types.TCHAN, types.TMAP, types.TSTRING:
 		break
 
 	// simtype == 0 during bootstrap
@@ -331,41 +332,41 @@ func dowidth(t *types.Type) {
 		base.Fatalf("dowidth: unknown type: %v", t)
 
 	// compiler-specific stuff
-	case TINT8, TUINT8, TBOOL:
+	case types.TINT8, types.TUINT8, types.TBOOL:
 		// bool is int8
 		w = 1
 
-	case TINT16, TUINT16:
+	case types.TINT16, types.TUINT16:
 		w = 2
 
-	case TINT32, TUINT32, TFLOAT32:
+	case types.TINT32, types.TUINT32, types.TFLOAT32:
 		w = 4
 
-	case TINT64, TUINT64, TFLOAT64:
+	case types.TINT64, types.TUINT64, types.TFLOAT64:
 		w = 8
 		t.Align = uint8(Widthreg)
 
-	case TCOMPLEX64:
+	case types.TCOMPLEX64:
 		w = 8
 		t.Align = 4
 
-	case TCOMPLEX128:
+	case types.TCOMPLEX128:
 		w = 16
 		t.Align = uint8(Widthreg)
 
-	case TPTR:
+	case types.TPTR:
 		w = int64(Widthptr)
 		checkwidth(t.Elem())
 
-	case TUNSAFEPTR:
+	case types.TUNSAFEPTR:
 		w = int64(Widthptr)
 
-	case TINTER: // implemented as 2 pointers
+	case types.TINTER: // implemented as 2 pointers
 		w = 2 * int64(Widthptr)
 		t.Align = uint8(Widthptr)
 		expandiface(t)
 
-	case TCHAN: // implemented as pointer
+	case types.TCHAN: // implemented as pointer
 		w = int64(Widthptr)
 
 		checkwidth(t.Elem())
@@ -375,7 +376,7 @@ func dowidth(t *types.Type) {
 		t1 := types.NewChanArgs(t)
 		checkwidth(t1)
 
-	case TCHANARGS:
+	case types.TCHANARGS:
 		t1 := t.ChanArgs()
 		dowidth(t1) // just in case
 		if t1.Elem().Width >= 1<<16 {
@@ -383,27 +384,27 @@ func dowidth(t *types.Type) {
 		}
 		w = 1 // anything will do
 
-	case TMAP: // implemented as pointer
+	case types.TMAP: // implemented as pointer
 		w = int64(Widthptr)
 		checkwidth(t.Elem())
 		checkwidth(t.Key())
 
-	case TFORW: // should have been filled in
+	case types.TFORW: // should have been filled in
 		reportTypeLoop(t)
 		w = 1 // anything will do
 
-	case TANY:
+	case types.TANY:
 		// not a real type; should be replaced before use.
 		base.Fatalf("dowidth any")
 
-	case TSTRING:
+	case types.TSTRING:
 		if sizeofString == 0 {
 			base.Fatalf("early dowidth string")
 		}
 		w = sizeofString
 		t.Align = uint8(Widthptr)
 
-	case TARRAY:
+	case types.TARRAY:
 		if t.Elem() == nil {
 			break
 		}
@@ -418,7 +419,7 @@ func dowidth(t *types.Type) {
 		w = t.NumElem() * t.Elem().Width
 		t.Align = t.Elem().Align
 
-	case TSLICE:
+	case types.TSLICE:
 		if t.Elem() == nil {
 			break
 		}
@@ -426,7 +427,7 @@ func dowidth(t *types.Type) {
 		checkwidth(t.Elem())
 		t.Align = uint8(Widthptr)
 
-	case TSTRUCT:
+	case types.TSTRUCT:
 		if t.IsFuncArgStruct() {
 			base.Fatalf("dowidth fn struct %v", t)
 		}
@@ -434,14 +435,14 @@ func dowidth(t *types.Type) {
 
 	// make fake type to check later to
 	// trigger function argument computation.
-	case TFUNC:
+	case types.TFUNC:
 		t1 := types.NewFuncArgs(t)
 		checkwidth(t1)
 		w = int64(Widthptr) // width of func type is pointer
 
 	// function is 3 cated structures;
 	// compute their widths as side-effect.
-	case TFUNCARGS:
+	case types.TFUNCARGS:
 		t1 := t.FuncArgs()
 		w = widstruct(t1, t1.Recvs(), 0, 0)
 		w = widstruct(t1, t1.Params(), w, Widthreg)
diff --git a/src/cmd/compile/internal/gc/bexport.go b/src/cmd/compile/internal/gc/bexport.go
index 6564024a0c..ff33c6b5fc 100644
--- a/src/cmd/compile/internal/gc/bexport.go
+++ b/src/cmd/compile/internal/gc/bexport.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 )
 
@@ -13,8 +14,8 @@ type exporter struct {
 }
 
 // markObject visits a reachable object.
-func (p *exporter) markObject(n *Node) {
-	if n.Op == ONAME && n.Class() == PFUNC {
+func (p *exporter) markObject(n *ir.Node) {
+	if n.Op == ir.ONAME && n.Class() == ir.PFUNC {
 		inlFlood(n)
 	}
 
@@ -34,10 +35,10 @@ func (p *exporter) markType(t *types.Type) {
 	// only their unexpanded method set (i.e., exclusive of
 	// interface embeddings), and the switch statement below
 	// handles their full method set.
-	if t.Sym != nil && t.Etype != TINTER {
+	if t.Sym != nil && t.Etype != types.TINTER {
 		for _, m := range t.Methods().Slice() {
 			if types.IsExported(m.Sym.Name) {
-				p.markObject(asNode(m.Nname))
+				p.markObject(ir.AsNode(m.Nname))
 			}
 		}
 	}
@@ -52,31 +53,31 @@ func (p *exporter) markType(t *types.Type) {
 	// the user already needs some way to construct values of
 	// those types.
 	switch t.Etype {
-	case TPTR, TARRAY, TSLICE:
+	case types.TPTR, types.TARRAY, types.TSLICE:
 		p.markType(t.Elem())
 
-	case TCHAN:
+	case types.TCHAN:
 		if t.ChanDir().CanRecv() {
 			p.markType(t.Elem())
 		}
 
-	case TMAP:
+	case types.TMAP:
 		p.markType(t.Key())
 		p.markType(t.Elem())
 
-	case TSTRUCT:
+	case types.TSTRUCT:
 		for _, f := range t.FieldSlice() {
 			if types.IsExported(f.Sym.Name) || f.Embedded != 0 {
 				p.markType(f.Type)
 			}
 		}
 
-	case TFUNC:
+	case types.TFUNC:
 		for _, f := range t.Results().FieldSlice() {
 			p.markType(f.Type)
 		}
 
-	case TINTER:
+	case types.TINTER:
 		for _, f := range t.FieldSlice() {
 			if types.IsExported(f.Sym.Name) {
 				p.markType(f.Type)
@@ -133,23 +134,23 @@ func predeclared() []*types.Type {
 		// elements have been initialized before
 		predecl = []*types.Type{
 			// basic types
-			types.Types[TBOOL],
-			types.Types[TINT],
-			types.Types[TINT8],
-			types.Types[TINT16],
-			types.Types[TINT32],
-			types.Types[TINT64],
-			types.Types[TUINT],
-			types.Types[TUINT8],
-			types.Types[TUINT16],
-			types.Types[TUINT32],
-			types.Types[TUINT64],
-			types.Types[TUINTPTR],
-			types.Types[TFLOAT32],
-			types.Types[TFLOAT64],
-			types.Types[TCOMPLEX64],
-			types.Types[TCOMPLEX128],
-			types.Types[TSTRING],
+			types.Types[types.TBOOL],
+			types.Types[types.TINT],
+			types.Types[types.TINT8],
+			types.Types[types.TINT16],
+			types.Types[types.TINT32],
+			types.Types[types.TINT64],
+			types.Types[types.TUINT],
+			types.Types[types.TUINT8],
+			types.Types[types.TUINT16],
+			types.Types[types.TUINT32],
+			types.Types[types.TUINT64],
+			types.Types[types.TUINTPTR],
+			types.Types[types.TFLOAT32],
+			types.Types[types.TFLOAT64],
+			types.Types[types.TCOMPLEX64],
+			types.Types[types.TCOMPLEX128],
+			types.Types[types.TSTRING],
 
 			// basic type aliases
 			types.Bytetype,
@@ -165,16 +166,16 @@ func predeclared() []*types.Type {
 			types.UntypedFloat,
 			types.UntypedComplex,
 			types.UntypedString,
-			types.Types[TNIL],
+			types.Types[types.TNIL],
 
 			// package unsafe
-			types.Types[TUNSAFEPTR],
+			types.Types[types.TUNSAFEPTR],
 
 			// invalid type (package contains errors)
-			types.Types[Txxx],
+			types.Types[types.Txxx],
 
 			// any type, for builtin export data
-			types.Types[TANY],
+			types.Types[types.TANY],
 		}
 	}
 	return predecl
diff --git a/src/cmd/compile/internal/gc/bimport.go b/src/cmd/compile/internal/gc/bimport.go
index 911ac4c0dc..e2dd276f46 100644
--- a/src/cmd/compile/internal/gc/bimport.go
+++ b/src/cmd/compile/internal/gc/bimport.go
@@ -5,20 +5,15 @@
 package gc
 
 import (
+	"cmd/compile/internal/ir"
 	"cmd/internal/src"
 )
 
-// numImport tracks how often a package with a given name is imported.
-// It is used to provide a better error message (by using the package
-// path to disambiguate) if a package that appears multiple times with
-// the same name appears in an error message.
-var numImport = make(map[string]int)
-
-func npos(pos src.XPos, n *Node) *Node {
+func npos(pos src.XPos, n *ir.Node) *ir.Node {
 	n.Pos = pos
 	return n
 }
 
-func builtinCall(op Op) *Node {
-	return nod(OCALL, mkname(builtinpkg.Lookup(goopnames[op])), nil)
+func builtinCall(op ir.Op) *ir.Node {
+	return ir.Nod(ir.OCALL, mkname(ir.BuiltinPkg.Lookup(ir.OpNames[op])), nil)
 }
diff --git a/src/cmd/compile/internal/gc/builtin.go b/src/cmd/compile/internal/gc/builtin.go
index fd95b657b2..5016905f22 100644
--- a/src/cmd/compile/internal/gc/builtin.go
+++ b/src/cmd/compile/internal/gc/builtin.go
@@ -2,7 +2,10 @@
 
 package gc
 
-import "cmd/compile/internal/types"
+import (
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
+)
 
 var runtimeDecls = [...]struct {
 	name string
@@ -205,134 +208,134 @@ func runtimeTypes() []*types.Type {
 	var typs [131]*types.Type
 	typs[0] = types.Bytetype
 	typs[1] = types.NewPtr(typs[0])
-	typs[2] = types.Types[TANY]
+	typs[2] = types.Types[types.TANY]
 	typs[3] = types.NewPtr(typs[2])
-	typs[4] = functype(nil, []*Node{anonfield(typs[1])}, []*Node{anonfield(typs[3])})
-	typs[5] = types.Types[TUINTPTR]
-	typs[6] = types.Types[TBOOL]
-	typs[7] = types.Types[TUNSAFEPTR]
-	typs[8] = functype(nil, []*Node{anonfield(typs[5]), anonfield(typs[1]), anonfield(typs[6])}, []*Node{anonfield(typs[7])})
+	typs[4] = functype(nil, []*ir.Node{anonfield(typs[1])}, []*ir.Node{anonfield(typs[3])})
+	typs[5] = types.Types[types.TUINTPTR]
+	typs[6] = types.Types[types.TBOOL]
+	typs[7] = types.Types[types.TUNSAFEPTR]
+	typs[8] = functype(nil, []*ir.Node{anonfield(typs[5]), anonfield(typs[1]), anonfield(typs[6])}, []*ir.Node{anonfield(typs[7])})
 	typs[9] = functype(nil, nil, nil)
-	typs[10] = types.Types[TINTER]
-	typs[11] = functype(nil, []*Node{anonfield(typs[10])}, nil)
-	typs[12] = types.Types[TINT32]
+	typs[10] = types.Types[types.TINTER]
+	typs[11] = functype(nil, []*ir.Node{anonfield(typs[10])}, nil)
+	typs[12] = types.Types[types.TINT32]
 	typs[13] = types.NewPtr(typs[12])
-	typs[14] = functype(nil, []*Node{anonfield(typs[13])}, []*Node{anonfield(typs[10])})
-	typs[15] = types.Types[TINT]
-	typs[16] = functype(nil, []*Node{anonfield(typs[15]), anonfield(typs[15])}, nil)
-	typs[17] = types.Types[TUINT]
-	typs[18] = functype(nil, []*Node{anonfield(typs[17]), anonfield(typs[15])}, nil)
-	typs[19] = functype(nil, []*Node{anonfield(typs[6])}, nil)
-	typs[20] = types.Types[TFLOAT64]
-	typs[21] = functype(nil, []*Node{anonfield(typs[20])}, nil)
-	typs[22] = types.Types[TINT64]
-	typs[23] = functype(nil, []*Node{anonfield(typs[22])}, nil)
-	typs[24] = types.Types[TUINT64]
-	typs[25] = functype(nil, []*Node{anonfield(typs[24])}, nil)
-	typs[26] = types.Types[TCOMPLEX128]
-	typs[27] = functype(nil, []*Node{anonfield(typs[26])}, nil)
-	typs[28] = types.Types[TSTRING]
-	typs[29] = functype(nil, []*Node{anonfield(typs[28])}, nil)
-	typs[30] = functype(nil, []*Node{anonfield(typs[2])}, nil)
-	typs[31] = functype(nil, []*Node{anonfield(typs[5])}, nil)
+	typs[14] = functype(nil, []*ir.Node{anonfield(typs[13])}, []*ir.Node{anonfield(typs[10])})
+	typs[15] = types.Types[types.TINT]
+	typs[16] = functype(nil, []*ir.Node{anonfield(typs[15]), anonfield(typs[15])}, nil)
+	typs[17] = types.Types[types.TUINT]
+	typs[18] = functype(nil, []*ir.Node{anonfield(typs[17]), anonfield(typs[15])}, nil)
+	typs[19] = functype(nil, []*ir.Node{anonfield(typs[6])}, nil)
+	typs[20] = types.Types[types.TFLOAT64]
+	typs[21] = functype(nil, []*ir.Node{anonfield(typs[20])}, nil)
+	typs[22] = types.Types[types.TINT64]
+	typs[23] = functype(nil, []*ir.Node{anonfield(typs[22])}, nil)
+	typs[24] = types.Types[types.TUINT64]
+	typs[25] = functype(nil, []*ir.Node{anonfield(typs[24])}, nil)
+	typs[26] = types.Types[types.TCOMPLEX128]
+	typs[27] = functype(nil, []*ir.Node{anonfield(typs[26])}, nil)
+	typs[28] = types.Types[types.TSTRING]
+	typs[29] = functype(nil, []*ir.Node{anonfield(typs[28])}, nil)
+	typs[30] = functype(nil, []*ir.Node{anonfield(typs[2])}, nil)
+	typs[31] = functype(nil, []*ir.Node{anonfield(typs[5])}, nil)
 	typs[32] = types.NewArray(typs[0], 32)
 	typs[33] = types.NewPtr(typs[32])
-	typs[34] = functype(nil, []*Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28])}, []*Node{anonfield(typs[28])})
-	typs[35] = functype(nil, []*Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []*Node{anonfield(typs[28])})
-	typs[36] = functype(nil, []*Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []*Node{anonfield(typs[28])})
-	typs[37] = functype(nil, []*Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []*Node{anonfield(typs[28])})
+	typs[34] = functype(nil, []*ir.Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28])}, []*ir.Node{anonfield(typs[28])})
+	typs[35] = functype(nil, []*ir.Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []*ir.Node{anonfield(typs[28])})
+	typs[36] = functype(nil, []*ir.Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []*ir.Node{anonfield(typs[28])})
+	typs[37] = functype(nil, []*ir.Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []*ir.Node{anonfield(typs[28])})
 	typs[38] = types.NewSlice(typs[28])
-	typs[39] = functype(nil, []*Node{anonfield(typs[33]), anonfield(typs[38])}, []*Node{anonfield(typs[28])})
-	typs[40] = functype(nil, []*Node{anonfield(typs[28]), anonfield(typs[28])}, []*Node{anonfield(typs[15])})
+	typs[39] = functype(nil, []*ir.Node{anonfield(typs[33]), anonfield(typs[38])}, []*ir.Node{anonfield(typs[28])})
+	typs[40] = functype(nil, []*ir.Node{anonfield(typs[28]), anonfield(typs[28])}, []*ir.Node{anonfield(typs[15])})
 	typs[41] = types.NewArray(typs[0], 4)
 	typs[42] = types.NewPtr(typs[41])
-	typs[43] = functype(nil, []*Node{anonfield(typs[42]), anonfield(typs[22])}, []*Node{anonfield(typs[28])})
-	typs[44] = functype(nil, []*Node{anonfield(typs[33]), anonfield(typs[1]), anonfield(typs[15])}, []*Node{anonfield(typs[28])})
-	typs[45] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[15])}, []*Node{anonfield(typs[28])})
+	typs[43] = functype(nil, []*ir.Node{anonfield(typs[42]), anonfield(typs[22])}, []*ir.Node{anonfield(typs[28])})
+	typs[44] = functype(nil, []*ir.Node{anonfield(typs[33]), anonfield(typs[1]), anonfield(typs[15])}, []*ir.Node{anonfield(typs[28])})
+	typs[45] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[15])}, []*ir.Node{anonfield(typs[28])})
 	typs[46] = types.Runetype
 	typs[47] = types.NewSlice(typs[46])
-	typs[48] = functype(nil, []*Node{anonfield(typs[33]), anonfield(typs[47])}, []*Node{anonfield(typs[28])})
+	typs[48] = functype(nil, []*ir.Node{anonfield(typs[33]), anonfield(typs[47])}, []*ir.Node{anonfield(typs[28])})
 	typs[49] = types.NewSlice(typs[0])
-	typs[50] = functype(nil, []*Node{anonfield(typs[33]), anonfield(typs[28])}, []*Node{anonfield(typs[49])})
+	typs[50] = functype(nil, []*ir.Node{anonfield(typs[33]), anonfield(typs[28])}, []*ir.Node{anonfield(typs[49])})
 	typs[51] = types.NewArray(typs[46], 32)
 	typs[52] = types.NewPtr(typs[51])
-	typs[53] = functype(nil, []*Node{anonfield(typs[52]), anonfield(typs[28])}, []*Node{anonfield(typs[47])})
-	typs[54] = functype(nil, []*Node{anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[5])}, []*Node{anonfield(typs[15])})
-	typs[55] = functype(nil, []*Node{anonfield(typs[28]), anonfield(typs[15])}, []*Node{anonfield(typs[46]), anonfield(typs[15])})
-	typs[56] = functype(nil, []*Node{anonfield(typs[28])}, []*Node{anonfield(typs[15])})
-	typs[57] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[2])}, []*Node{anonfield(typs[2])})
-	typs[58] = functype(nil, []*Node{anonfield(typs[2])}, []*Node{anonfield(typs[7])})
-	typs[59] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[3])}, []*Node{anonfield(typs[2])})
-	typs[60] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[2])}, []*Node{anonfield(typs[2]), anonfield(typs[6])})
-	typs[61] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[1]), anonfield(typs[1])}, nil)
-	typs[62] = functype(nil, []*Node{anonfield(typs[1])}, nil)
+	typs[53] = functype(nil, []*ir.Node{anonfield(typs[52]), anonfield(typs[28])}, []*ir.Node{anonfield(typs[47])})
+	typs[54] = functype(nil, []*ir.Node{anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[5])}, []*ir.Node{anonfield(typs[15])})
+	typs[55] = functype(nil, []*ir.Node{anonfield(typs[28]), anonfield(typs[15])}, []*ir.Node{anonfield(typs[46]), anonfield(typs[15])})
+	typs[56] = functype(nil, []*ir.Node{anonfield(typs[28])}, []*ir.Node{anonfield(typs[15])})
+	typs[57] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[2])}, []*ir.Node{anonfield(typs[2])})
+	typs[58] = functype(nil, []*ir.Node{anonfield(typs[2])}, []*ir.Node{anonfield(typs[7])})
+	typs[59] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[3])}, []*ir.Node{anonfield(typs[2])})
+	typs[60] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[2])}, []*ir.Node{anonfield(typs[2]), anonfield(typs[6])})
+	typs[61] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[1]), anonfield(typs[1])}, nil)
+	typs[62] = functype(nil, []*ir.Node{anonfield(typs[1])}, nil)
 	typs[63] = types.NewPtr(typs[5])
-	typs[64] = functype(nil, []*Node{anonfield(typs[63]), anonfield(typs[7]), anonfield(typs[7])}, []*Node{anonfield(typs[6])})
-	typs[65] = types.Types[TUINT32]
-	typs[66] = functype(nil, nil, []*Node{anonfield(typs[65])})
+	typs[64] = functype(nil, []*ir.Node{anonfield(typs[63]), anonfield(typs[7]), anonfield(typs[7])}, []*ir.Node{anonfield(typs[6])})
+	typs[65] = types.Types[types.TUINT32]
+	typs[66] = functype(nil, nil, []*ir.Node{anonfield(typs[65])})
 	typs[67] = types.NewMap(typs[2], typs[2])
-	typs[68] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[22]), anonfield(typs[3])}, []*Node{anonfield(typs[67])})
-	typs[69] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[3])}, []*Node{anonfield(typs[67])})
-	typs[70] = functype(nil, nil, []*Node{anonfield(typs[67])})
-	typs[71] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, []*Node{anonfield(typs[3])})
-	typs[72] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, []*Node{anonfield(typs[3])})
-	typs[73] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3]), anonfield(typs[1])}, []*Node{anonfield(typs[3])})
-	typs[74] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, []*Node{anonfield(typs[3]), anonfield(typs[6])})
-	typs[75] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, []*Node{anonfield(typs[3]), anonfield(typs[6])})
-	typs[76] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3]), anonfield(typs[1])}, []*Node{anonfield(typs[3]), anonfield(typs[6])})
-	typs[77] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, nil)
-	typs[78] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, nil)
-	typs[79] = functype(nil, []*Node{anonfield(typs[3])}, nil)
-	typs[80] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67])}, nil)
+	typs[68] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[22]), anonfield(typs[3])}, []*ir.Node{anonfield(typs[67])})
+	typs[69] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[3])}, []*ir.Node{anonfield(typs[67])})
+	typs[70] = functype(nil, nil, []*ir.Node{anonfield(typs[67])})
+	typs[71] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, []*ir.Node{anonfield(typs[3])})
+	typs[72] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, []*ir.Node{anonfield(typs[3])})
+	typs[73] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3]), anonfield(typs[1])}, []*ir.Node{anonfield(typs[3])})
+	typs[74] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, []*ir.Node{anonfield(typs[3]), anonfield(typs[6])})
+	typs[75] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, []*ir.Node{anonfield(typs[3]), anonfield(typs[6])})
+	typs[76] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3]), anonfield(typs[1])}, []*ir.Node{anonfield(typs[3]), anonfield(typs[6])})
+	typs[77] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, nil)
+	typs[78] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, nil)
+	typs[79] = functype(nil, []*ir.Node{anonfield(typs[3])}, nil)
+	typs[80] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[67])}, nil)
 	typs[81] = types.NewChan(typs[2], types.Cboth)
-	typs[82] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[22])}, []*Node{anonfield(typs[81])})
-	typs[83] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[15])}, []*Node{anonfield(typs[81])})
+	typs[82] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[22])}, []*ir.Node{anonfield(typs[81])})
+	typs[83] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[15])}, []*ir.Node{anonfield(typs[81])})
 	typs[84] = types.NewChan(typs[2], types.Crecv)
-	typs[85] = functype(nil, []*Node{anonfield(typs[84]), anonfield(typs[3])}, nil)
-	typs[86] = functype(nil, []*Node{anonfield(typs[84]), anonfield(typs[3])}, []*Node{anonfield(typs[6])})
+	typs[85] = functype(nil, []*ir.Node{anonfield(typs[84]), anonfield(typs[3])}, nil)
+	typs[86] = functype(nil, []*ir.Node{anonfield(typs[84]), anonfield(typs[3])}, []*ir.Node{anonfield(typs[6])})
 	typs[87] = types.NewChan(typs[2], types.Csend)
-	typs[88] = functype(nil, []*Node{anonfield(typs[87]), anonfield(typs[3])}, nil)
+	typs[88] = functype(nil, []*ir.Node{anonfield(typs[87]), anonfield(typs[3])}, nil)
 	typs[89] = types.NewArray(typs[0], 3)
-	typs[90] = tostruct([]*Node{namedfield("enabled", typs[6]), namedfield("pad", typs[89]), namedfield("needed", typs[6]), namedfield("cgo", typs[6]), namedfield("alignme", typs[24])})
-	typs[91] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[3]), anonfield(typs[3])}, nil)
-	typs[92] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[3])}, nil)
-	typs[93] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[3]), anonfield(typs[15])}, []*Node{anonfield(typs[15])})
-	typs[94] = functype(nil, []*Node{anonfield(typs[87]), anonfield(typs[3])}, []*Node{anonfield(typs[6])})
-	typs[95] = functype(nil, []*Node{anonfield(typs[3]), anonfield(typs[84])}, []*Node{anonfield(typs[6])})
+	typs[90] = tostruct([]*ir.Node{namedfield("enabled", typs[6]), namedfield("pad", typs[89]), namedfield("needed", typs[6]), namedfield("cgo", typs[6]), namedfield("alignme", typs[24])})
+	typs[91] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[3]), anonfield(typs[3])}, nil)
+	typs[92] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[3])}, nil)
+	typs[93] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[3]), anonfield(typs[15])}, []*ir.Node{anonfield(typs[15])})
+	typs[94] = functype(nil, []*ir.Node{anonfield(typs[87]), anonfield(typs[3])}, []*ir.Node{anonfield(typs[6])})
+	typs[95] = functype(nil, []*ir.Node{anonfield(typs[3]), anonfield(typs[84])}, []*ir.Node{anonfield(typs[6])})
 	typs[96] = types.NewPtr(typs[6])
-	typs[97] = functype(nil, []*Node{anonfield(typs[3]), anonfield(typs[96]), anonfield(typs[84])}, []*Node{anonfield(typs[6])})
-	typs[98] = functype(nil, []*Node{anonfield(typs[63])}, nil)
-	typs[99] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[1]), anonfield(typs[63]), anonfield(typs[15]), anonfield(typs[15]), anonfield(typs[6])}, []*Node{anonfield(typs[15]), anonfield(typs[6])})
-	typs[100] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[15])}, []*Node{anonfield(typs[7])})
-	typs[101] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[22]), anonfield(typs[22])}, []*Node{anonfield(typs[7])})
-	typs[102] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[15]), anonfield(typs[7])}, []*Node{anonfield(typs[7])})
+	typs[97] = functype(nil, []*ir.Node{anonfield(typs[3]), anonfield(typs[96]), anonfield(typs[84])}, []*ir.Node{anonfield(typs[6])})
+	typs[98] = functype(nil, []*ir.Node{anonfield(typs[63])}, nil)
+	typs[99] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[1]), anonfield(typs[63]), anonfield(typs[15]), anonfield(typs[15]), anonfield(typs[6])}, []*ir.Node{anonfield(typs[15]), anonfield(typs[6])})
+	typs[100] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[15])}, []*ir.Node{anonfield(typs[7])})
+	typs[101] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[22]), anonfield(typs[22])}, []*ir.Node{anonfield(typs[7])})
+	typs[102] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[15]), anonfield(typs[7])}, []*ir.Node{anonfield(typs[7])})
 	typs[103] = types.NewSlice(typs[2])
-	typs[104] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[103]), anonfield(typs[15])}, []*Node{anonfield(typs[103])})
-	typs[105] = functype(nil, []*Node{anonfield(typs[3]), anonfield(typs[3]), anonfield(typs[5])}, nil)
-	typs[106] = functype(nil, []*Node{anonfield(typs[7]), anonfield(typs[5])}, nil)
-	typs[107] = functype(nil, []*Node{anonfield(typs[3]), anonfield(typs[3]), anonfield(typs[5])}, []*Node{anonfield(typs[6])})
-	typs[108] = functype(nil, []*Node{anonfield(typs[3]), anonfield(typs[3])}, []*Node{anonfield(typs[6])})
-	typs[109] = functype(nil, []*Node{anonfield(typs[7]), anonfield(typs[7])}, []*Node{anonfield(typs[6])})
-	typs[110] = functype(nil, []*Node{anonfield(typs[7]), anonfield(typs[5]), anonfield(typs[5])}, []*Node{anonfield(typs[5])})
-	typs[111] = functype(nil, []*Node{anonfield(typs[7]), anonfield(typs[5])}, []*Node{anonfield(typs[5])})
-	typs[112] = functype(nil, []*Node{anonfield(typs[22]), anonfield(typs[22])}, []*Node{anonfield(typs[22])})
-	typs[113] = functype(nil, []*Node{anonfield(typs[24]), anonfield(typs[24])}, []*Node{anonfield(typs[24])})
-	typs[114] = functype(nil, []*Node{anonfield(typs[20])}, []*Node{anonfield(typs[22])})
-	typs[115] = functype(nil, []*Node{anonfield(typs[20])}, []*Node{anonfield(typs[24])})
-	typs[116] = functype(nil, []*Node{anonfield(typs[20])}, []*Node{anonfield(typs[65])})
-	typs[117] = functype(nil, []*Node{anonfield(typs[22])}, []*Node{anonfield(typs[20])})
-	typs[118] = functype(nil, []*Node{anonfield(typs[24])}, []*Node{anonfield(typs[20])})
-	typs[119] = functype(nil, []*Node{anonfield(typs[65])}, []*Node{anonfield(typs[20])})
-	typs[120] = functype(nil, []*Node{anonfield(typs[26]), anonfield(typs[26])}, []*Node{anonfield(typs[26])})
-	typs[121] = functype(nil, []*Node{anonfield(typs[5]), anonfield(typs[5])}, nil)
-	typs[122] = functype(nil, []*Node{anonfield(typs[7]), anonfield(typs[1]), anonfield(typs[5])}, nil)
+	typs[104] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[103]), anonfield(typs[15])}, []*ir.Node{anonfield(typs[103])})
+	typs[105] = functype(nil, []*ir.Node{anonfield(typs[3]), anonfield(typs[3]), anonfield(typs[5])}, nil)
+	typs[106] = functype(nil, []*ir.Node{anonfield(typs[7]), anonfield(typs[5])}, nil)
+	typs[107] = functype(nil, []*ir.Node{anonfield(typs[3]), anonfield(typs[3]), anonfield(typs[5])}, []*ir.Node{anonfield(typs[6])})
+	typs[108] = functype(nil, []*ir.Node{anonfield(typs[3]), anonfield(typs[3])}, []*ir.Node{anonfield(typs[6])})
+	typs[109] = functype(nil, []*ir.Node{anonfield(typs[7]), anonfield(typs[7])}, []*ir.Node{anonfield(typs[6])})
+	typs[110] = functype(nil, []*ir.Node{anonfield(typs[7]), anonfield(typs[5]), anonfield(typs[5])}, []*ir.Node{anonfield(typs[5])})
+	typs[111] = functype(nil, []*ir.Node{anonfield(typs[7]), anonfield(typs[5])}, []*ir.Node{anonfield(typs[5])})
+	typs[112] = functype(nil, []*ir.Node{anonfield(typs[22]), anonfield(typs[22])}, []*ir.Node{anonfield(typs[22])})
+	typs[113] = functype(nil, []*ir.Node{anonfield(typs[24]), anonfield(typs[24])}, []*ir.Node{anonfield(typs[24])})
+	typs[114] = functype(nil, []*ir.Node{anonfield(typs[20])}, []*ir.Node{anonfield(typs[22])})
+	typs[115] = functype(nil, []*ir.Node{anonfield(typs[20])}, []*ir.Node{anonfield(typs[24])})
+	typs[116] = functype(nil, []*ir.Node{anonfield(typs[20])}, []*ir.Node{anonfield(typs[65])})
+	typs[117] = functype(nil, []*ir.Node{anonfield(typs[22])}, []*ir.Node{anonfield(typs[20])})
+	typs[118] = functype(nil, []*ir.Node{anonfield(typs[24])}, []*ir.Node{anonfield(typs[20])})
+	typs[119] = functype(nil, []*ir.Node{anonfield(typs[65])}, []*ir.Node{anonfield(typs[20])})
+	typs[120] = functype(nil, []*ir.Node{anonfield(typs[26]), anonfield(typs[26])}, []*ir.Node{anonfield(typs[26])})
+	typs[121] = functype(nil, []*ir.Node{anonfield(typs[5]), anonfield(typs[5])}, nil)
+	typs[122] = functype(nil, []*ir.Node{anonfield(typs[7]), anonfield(typs[1]), anonfield(typs[5])}, nil)
 	typs[123] = types.NewSlice(typs[7])
-	typs[124] = functype(nil, []*Node{anonfield(typs[7]), anonfield(typs[123])}, nil)
-	typs[125] = types.Types[TUINT8]
-	typs[126] = functype(nil, []*Node{anonfield(typs[125]), anonfield(typs[125])}, nil)
-	typs[127] = types.Types[TUINT16]
-	typs[128] = functype(nil, []*Node{anonfield(typs[127]), anonfield(typs[127])}, nil)
-	typs[129] = functype(nil, []*Node{anonfield(typs[65]), anonfield(typs[65])}, nil)
-	typs[130] = functype(nil, []*Node{anonfield(typs[24]), anonfield(typs[24])}, nil)
+	typs[124] = functype(nil, []*ir.Node{anonfield(typs[7]), anonfield(typs[123])}, nil)
+	typs[125] = types.Types[types.TUINT8]
+	typs[126] = functype(nil, []*ir.Node{anonfield(typs[125]), anonfield(typs[125])}, nil)
+	typs[127] = types.Types[types.TUINT16]
+	typs[128] = functype(nil, []*ir.Node{anonfield(typs[127]), anonfield(typs[127])}, nil)
+	typs[129] = functype(nil, []*ir.Node{anonfield(typs[65]), anonfield(typs[65])}, nil)
+	typs[130] = functype(nil, []*ir.Node{anonfield(typs[24]), anonfield(typs[24])}, nil)
 	return typs[:]
 }
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index ad255c9c06..e68d710363 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -6,24 +6,25 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/syntax"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"fmt"
 )
 
-func (p *noder) funcLit(expr *syntax.FuncLit) *Node {
+func (p *noder) funcLit(expr *syntax.FuncLit) *ir.Node {
 	xtype := p.typeExpr(expr.Type)
 	ntype := p.typeExpr(expr.Type)
 
-	dcl := p.nod(expr, ODCLFUNC, nil, nil)
+	dcl := p.nod(expr, ir.ODCLFUNC, nil, nil)
 	fn := dcl.Func
 	fn.SetIsHiddenClosure(Curfn != nil)
-	fn.Nname = newfuncnamel(p.pos(expr), nblank.Sym, fn) // filled in by typecheckclosure
+	fn.Nname = newfuncnamel(p.pos(expr), ir.BlankNode.Sym, fn) // filled in by typecheckclosure
 	fn.Nname.Name.Param.Ntype = xtype
 	fn.Nname.Name.Defn = dcl
 
-	clo := p.nod(expr, OCLOSURE, nil, nil)
+	clo := p.nod(expr, ir.OCLOSURE, nil, nil)
 	clo.Func = fn
 	fn.ClosureType = ntype
 	fn.OClosure = clo
@@ -77,7 +78,7 @@ func (p *noder) funcLit(expr *syntax.FuncLit) *Node {
 // function associated with the closure.
 // TODO: This creation of the named function should probably really be done in a
 // separate pass from type-checking.
-func typecheckclosure(clo *Node, top int) {
+func typecheckclosure(clo *ir.Node, top int) {
 	fn := clo.Func
 	dcl := fn.Decl
 	// Set current associated iota value, so iota can be used inside
@@ -139,7 +140,7 @@ var globClosgen int
 
 // closurename generates a new unique name for a closure within
 // outerfunc.
-func closurename(outerfunc *Node) *types.Sym {
+func closurename(outerfunc *ir.Node) *types.Sym {
 	outer := "glob."
 	prefix := "func"
 	gen := &globClosgen
@@ -149,12 +150,12 @@ func closurename(outerfunc *Node) *types.Sym {
 			prefix = ""
 		}
 
-		outer = outerfunc.funcname()
+		outer = ir.FuncName(outerfunc)
 
 		// There may be multiple functions named "_". In those
 		// cases, we can't use their individual Closgens as it
 		// would lead to name clashes.
-		if !outerfunc.Func.Nname.isBlank() {
+		if !ir.IsBlank(outerfunc.Func.Nname) {
 			gen = &outerfunc.Func.Closgen
 		}
 	}
@@ -171,7 +172,7 @@ var capturevarscomplete bool
 // by value or by reference.
 // We use value capturing for values <= 128 bytes that are never reassigned
 // after capturing (effectively constant).
-func capturevars(dcl *Node) {
+func capturevars(dcl *ir.Node) {
 	lno := base.Pos
 	base.Pos = dcl.Pos
 	fn := dcl.Func
@@ -197,11 +198,11 @@ func capturevars(dcl *Node) {
 		outermost := v.Name.Defn
 
 		// out parameters will be assigned to implicitly upon return.
-		if outermost.Class() != PPARAMOUT && !outermost.Name.Addrtaken() && !outermost.Name.Assigned() && v.Type.Width <= 128 {
+		if outermost.Class() != ir.PPARAMOUT && !outermost.Name.Addrtaken() && !outermost.Name.Assigned() && v.Type.Width <= 128 {
 			v.Name.SetByval(true)
 		} else {
 			outermost.Name.SetAddrtaken(true)
-			outer = nod(OADDR, outer, nil)
+			outer = ir.Nod(ir.OADDR, outer, nil)
 		}
 
 		if base.Flag.LowerM > 1 {
@@ -226,7 +227,7 @@ func capturevars(dcl *Node) {
 
 // transformclosure is called in a separate phase after escape analysis.
 // It transform closure bodies to properly reference captured variables.
-func transformclosure(dcl *Node) {
+func transformclosure(dcl *ir.Node) {
 	lno := base.Pos
 	base.Pos = dcl.Pos
 	fn := dcl.Func
@@ -252,24 +253,24 @@ func transformclosure(dcl *Node) {
 
 		// We are going to insert captured variables before input args.
 		var params []*types.Field
-		var decls []*Node
+		var decls []*ir.Node
 		for _, v := range fn.ClosureVars.Slice() {
 			if !v.Name.Byval() {
 				// If v of type T is captured by reference,
 				// we introduce function param &v *T
 				// and v remains PAUTOHEAP with &v heapaddr
 				// (accesses will implicitly deref &v).
-				addr := newname(lookup("&" + v.Sym.Name))
+				addr := NewName(lookup("&" + v.Sym.Name))
 				addr.Type = types.NewPtr(v.Type)
 				v.Name.Param.Heapaddr = addr
 				v = addr
 			}
 
-			v.SetClass(PPARAM)
+			v.SetClass(ir.PPARAM)
 			decls = append(decls, v)
 
 			fld := types.NewField(src.NoXPos, v.Sym, v.Type)
-			fld.Nname = asTypesNode(v)
+			fld.Nname = ir.AsTypesNode(v)
 			params = append(params, fld)
 		}
 
@@ -283,11 +284,11 @@ func transformclosure(dcl *Node) {
 		dcl.Type = f.Type // update type of ODCLFUNC
 	} else {
 		// The closure is not called, so it is going to stay as closure.
-		var body []*Node
+		var body []*ir.Node
 		offset := int64(Widthptr)
 		for _, v := range fn.ClosureVars.Slice() {
 			// cv refers to the field inside of closure OSTRUCTLIT.
-			cv := nod(OCLOSUREVAR, nil, nil)
+			cv := ir.Nod(ir.OCLOSUREVAR, nil, nil)
 
 			cv.Type = v.Type
 			if !v.Name.Byval() {
@@ -299,23 +300,23 @@ func transformclosure(dcl *Node) {
 
 			if v.Name.Byval() && v.Type.Width <= int64(2*Widthptr) {
 				// If it is a small variable captured by value, downgrade it to PAUTO.
-				v.SetClass(PAUTO)
+				v.SetClass(ir.PAUTO)
 				fn.Dcl = append(fn.Dcl, v)
-				body = append(body, nod(OAS, v, cv))
+				body = append(body, ir.Nod(ir.OAS, v, cv))
 			} else {
 				// Declare variable holding addresses taken from closure
 				// and initialize in entry prologue.
-				addr := newname(lookup("&" + v.Sym.Name))
+				addr := NewName(lookup("&" + v.Sym.Name))
 				addr.Type = types.NewPtr(v.Type)
-				addr.SetClass(PAUTO)
+				addr.SetClass(ir.PAUTO)
 				addr.Name.SetUsed(true)
 				addr.Name.Curfn = dcl
 				fn.Dcl = append(fn.Dcl, addr)
 				v.Name.Param.Heapaddr = addr
 				if v.Name.Byval() {
-					cv = nod(OADDR, cv, nil)
+					cv = ir.Nod(ir.OADDR, cv, nil)
 				}
-				body = append(body, nod(OAS, addr, cv))
+				body = append(body, ir.Nod(ir.OAS, addr, cv))
 			}
 		}
 
@@ -331,13 +332,13 @@ func transformclosure(dcl *Node) {
 
 // hasemptycvars reports whether closure clo has an
 // empty list of captured vars.
-func hasemptycvars(clo *Node) bool {
+func hasemptycvars(clo *ir.Node) bool {
 	return clo.Func.ClosureVars.Len() == 0
 }
 
 // closuredebugruntimecheck applies boilerplate checks for debug flags
 // and compiling runtime
-func closuredebugruntimecheck(clo *Node) {
+func closuredebugruntimecheck(clo *ir.Node) {
 	if base.Debug.Closure > 0 {
 		if clo.Esc == EscHeap {
 			base.WarnfAt(clo.Pos, "heap closure, captured vars = %v", clo.Func.ClosureVars)
@@ -353,7 +354,7 @@ func closuredebugruntimecheck(clo *Node) {
 // closureType returns the struct type used to hold all the information
 // needed in the closure for clo (clo must be a OCLOSURE node).
 // The address of a variable of the returned type can be cast to a func.
-func closureType(clo *Node) *types.Type {
+func closureType(clo *ir.Node) *types.Type {
 	// Create closure in the form of a composite literal.
 	// supposing the closure captures an int i and a string s
 	// and has one float64 argument and no results,
@@ -367,8 +368,8 @@ func closureType(clo *Node) *types.Type {
 	// The information appears in the binary in the form of type descriptors;
 	// the struct is unnamed so that closures in multiple packages with the
 	// same struct type can share the descriptor.
-	fields := []*Node{
-		namedfield(".F", types.Types[TUINTPTR]),
+	fields := []*ir.Node{
+		namedfield(".F", types.Types[types.TUINTPTR]),
 	}
 	for _, v := range clo.Func.ClosureVars.Slice() {
 		typ := v.Type
@@ -382,7 +383,7 @@ func closureType(clo *Node) *types.Type {
 	return typ
 }
 
-func walkclosure(clo *Node, init *Nodes) *Node {
+func walkclosure(clo *ir.Node, init *ir.Nodes) *ir.Node {
 	fn := clo.Func
 
 	// If no closure vars, don't bother wrapping.
@@ -396,11 +397,11 @@ func walkclosure(clo *Node, init *Nodes) *Node {
 
 	typ := closureType(clo)
 
-	clos := nod(OCOMPLIT, nil, typenod(typ))
+	clos := ir.Nod(ir.OCOMPLIT, nil, typenod(typ))
 	clos.Esc = clo.Esc
-	clos.List.Set(append([]*Node{nod(OCFUNC, fn.Nname, nil)}, fn.ClosureEnter.Slice()...))
+	clos.List.Set(append([]*ir.Node{ir.Nod(ir.OCFUNC, fn.Nname, nil)}, fn.ClosureEnter.Slice()...))
 
-	clos = nod(OADDR, clos, nil)
+	clos = ir.Nod(ir.OADDR, clos, nil)
 	clos.Esc = clo.Esc
 
 	// Force type conversion from *struct to the func type.
@@ -418,9 +419,9 @@ func walkclosure(clo *Node, init *Nodes) *Node {
 	return walkexpr(clos, init)
 }
 
-func typecheckpartialcall(dot *Node, sym *types.Sym) {
+func typecheckpartialcall(dot *ir.Node, sym *types.Sym) {
 	switch dot.Op {
-	case ODOTINTER, ODOTMETH:
+	case ir.ODOTINTER, ir.ODOTMETH:
 		break
 
 	default:
@@ -430,8 +431,8 @@ func typecheckpartialcall(dot *Node, sym *types.Sym) {
 	// Create top-level function.
 	dcl := makepartialcall(dot, dot.Type, sym)
 	dcl.Func.SetWrapper(true)
-	dot.Op = OCALLPART
-	dot.Right = newname(sym)
+	dot.Op = ir.OCALLPART
+	dot.Right = NewName(sym)
 	dot.Type = dcl.Type
 	dot.Func = dcl.Func
 	dot.SetOpt(nil) // clear types.Field from ODOTMETH
@@ -439,12 +440,12 @@ func typecheckpartialcall(dot *Node, sym *types.Sym) {
 
 // makepartialcall returns a DCLFUNC node representing the wrapper function (*-fm) needed
 // for partial calls.
-func makepartialcall(dot *Node, t0 *types.Type, meth *types.Sym) *Node {
+func makepartialcall(dot *ir.Node, t0 *types.Type, meth *types.Sym) *ir.Node {
 	rcvrtype := dot.Left.Type
 	sym := methodSymSuffix(rcvrtype, meth, "-fm")
 
 	if sym.Uniq() {
-		return asNode(sym.Def)
+		return ir.AsNode(sym.Def)
 	}
 	sym.SetUniq(true)
 
@@ -463,7 +464,7 @@ func makepartialcall(dot *Node, t0 *types.Type, meth *types.Sym) *Node {
 	// number at the use of the method expression in this
 	// case. See issue 29389.
 
-	tfn := nod(OTFUNC, nil, nil)
+	tfn := ir.Nod(ir.OTFUNC, nil, nil)
 	tfn.List.Set(structargs(t0.Params(), true))
 	tfn.Rlist.Set(structargs(t0.Results(), false))
 
@@ -476,27 +477,27 @@ func makepartialcall(dot *Node, t0 *types.Type, meth *types.Sym) *Node {
 
 	// Declare and initialize variable holding receiver.
 
-	cv := nod(OCLOSUREVAR, nil, nil)
+	cv := ir.Nod(ir.OCLOSUREVAR, nil, nil)
 	cv.Type = rcvrtype
 	cv.Xoffset = Rnd(int64(Widthptr), int64(cv.Type.Align))
 
-	ptr := newname(lookup(".this"))
-	declare(ptr, PAUTO)
+	ptr := NewName(lookup(".this"))
+	declare(ptr, ir.PAUTO)
 	ptr.Name.SetUsed(true)
-	var body []*Node
+	var body []*ir.Node
 	if rcvrtype.IsPtr() || rcvrtype.IsInterface() {
 		ptr.Type = rcvrtype
-		body = append(body, nod(OAS, ptr, cv))
+		body = append(body, ir.Nod(ir.OAS, ptr, cv))
 	} else {
 		ptr.Type = types.NewPtr(rcvrtype)
-		body = append(body, nod(OAS, ptr, nod(OADDR, cv, nil)))
+		body = append(body, ir.Nod(ir.OAS, ptr, ir.Nod(ir.OADDR, cv, nil)))
 	}
 
-	call := nod(OCALL, nodSym(OXDOT, ptr, meth), nil)
+	call := ir.Nod(ir.OCALL, nodSym(ir.OXDOT, ptr, meth), nil)
 	call.List.Set(paramNnames(tfn.Type))
 	call.SetIsDDD(tfn.Type.IsVariadic())
 	if t0.NumResults() != 0 {
-		n := nod(ORETURN, nil, nil)
+		n := ir.Nod(ir.ORETURN, nil, nil)
 		n.List.Set1(call)
 		call = n
 	}
@@ -510,7 +511,7 @@ func makepartialcall(dot *Node, t0 *types.Type, meth *types.Sym) *Node {
 	// typecheckslice() requires that Curfn is set when processing an ORETURN.
 	Curfn = dcl
 	typecheckslice(dcl.Nbody.Slice(), ctxStmt)
-	sym.Def = asTypesNode(dcl)
+	sym.Def = ir.AsTypesNode(dcl)
 	xtop = append(xtop, dcl)
 	Curfn = savecurfn
 	base.Pos = saveLineNo
@@ -521,16 +522,16 @@ func makepartialcall(dot *Node, t0 *types.Type, meth *types.Sym) *Node {
 // partialCallType returns the struct type used to hold all the information
 // needed in the closure for n (n must be a OCALLPART node).
 // The address of a variable of the returned type can be cast to a func.
-func partialCallType(n *Node) *types.Type {
-	t := tostruct([]*Node{
-		namedfield("F", types.Types[TUINTPTR]),
+func partialCallType(n *ir.Node) *types.Type {
+	t := tostruct([]*ir.Node{
+		namedfield("F", types.Types[types.TUINTPTR]),
 		namedfield("R", n.Left.Type),
 	})
 	t.SetNoalg(true)
 	return t
 }
 
-func walkpartialcall(n *Node, init *Nodes) *Node {
+func walkpartialcall(n *ir.Node, init *ir.Nodes) *ir.Node {
 	// Create closure in the form of a composite literal.
 	// For x.M with receiver (x) type T, the generated code looks like:
 	//
@@ -544,21 +545,21 @@ func walkpartialcall(n *Node, init *Nodes) *Node {
 		n.Left = cheapexpr(n.Left, init)
 		n.Left = walkexpr(n.Left, nil)
 
-		tab := nod(OITAB, n.Left, nil)
+		tab := ir.Nod(ir.OITAB, n.Left, nil)
 		tab = typecheck(tab, ctxExpr)
 
-		c := nod(OCHECKNIL, tab, nil)
+		c := ir.Nod(ir.OCHECKNIL, tab, nil)
 		c.SetTypecheck(1)
 		init.Append(c)
 	}
 
 	typ := partialCallType(n)
 
-	clos := nod(OCOMPLIT, nil, typenod(typ))
+	clos := ir.Nod(ir.OCOMPLIT, nil, typenod(typ))
 	clos.Esc = n.Esc
-	clos.List.Set2(nod(OCFUNC, n.Func.Nname, nil), n.Left)
+	clos.List.Set2(ir.Nod(ir.OCFUNC, n.Func.Nname, nil), n.Left)
 
-	clos = nod(OADDR, clos, nil)
+	clos = ir.Nod(ir.OADDR, clos, nil)
 	clos.Esc = n.Esc
 
 	// Force type conversion from *struct to the func type.
@@ -578,8 +579,8 @@ func walkpartialcall(n *Node, init *Nodes) *Node {
 
 // callpartMethod returns the *types.Field representing the method
 // referenced by method value n.
-func callpartMethod(n *Node) *types.Field {
-	if n.Op != OCALLPART {
+func callpartMethod(n *ir.Node) *types.Field {
+	if n.Op != ir.OCALLPART {
 		base.Fatalf("expected OCALLPART, got %v", n)
 	}
 
diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 98473b4cfb..a557e20d46 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"fmt"
@@ -23,51 +24,6 @@ const (
 	Mpprec = 512
 )
 
-// ValueInterface returns the constant value stored in n as an interface{}.
-// It returns int64s for ints and runes, float64s for floats,
-// and complex128s for complex values.
-func (n *Node) ValueInterface() interface{} {
-	switch v := n.Val(); v.Kind() {
-	default:
-		base.Fatalf("unexpected constant: %v", v)
-		panic("unreachable")
-	case constant.Bool:
-		return constant.BoolVal(v)
-	case constant.String:
-		return constant.StringVal(v)
-	case constant.Int:
-		return int64Val(n.Type, v)
-	case constant.Float:
-		return float64Val(v)
-	case constant.Complex:
-		return complex(float64Val(constant.Real(v)), float64Val(constant.Imag(v)))
-	}
-}
-
-// int64Val returns v converted to int64.
-// Note: if t is uint64, very large values will be converted to negative int64.
-func int64Val(t *types.Type, v constant.Value) int64 {
-	if t.IsUnsigned() {
-		if x, ok := constant.Uint64Val(v); ok {
-			return int64(x)
-		}
-	} else {
-		if x, ok := constant.Int64Val(v); ok {
-			return x
-		}
-	}
-	base.Fatalf("%v out of range for %v", v, t)
-	panic("unreachable")
-}
-
-func float64Val(v constant.Value) float64 {
-	if x, _ := constant.Float64Val(v); !math.IsInf(x, 0) {
-		return x + 0 // avoid -0 (should not be needed, but be conservative)
-	}
-	base.Fatalf("bad float64 value: %v", v)
-	panic("unreachable")
-}
-
 func bigFloatVal(v constant.Value) *big.Float {
 	f := new(big.Float)
 	f.SetPrec(Mpprec)
@@ -86,62 +42,6 @@ func bigFloatVal(v constant.Value) *big.Float {
 	return f
 }
 
-// Int64Val returns n as an int64.
-// n must be an integer or rune constant.
-func (n *Node) Int64Val() int64 {
-	if !Isconst(n, constant.Int) {
-		base.Fatalf("Int64Val(%v)", n)
-	}
-	x, ok := constant.Int64Val(n.Val())
-	if !ok {
-		base.Fatalf("Int64Val(%v)", n)
-	}
-	return x
-}
-
-// CanInt64 reports whether it is safe to call Int64Val() on n.
-func (n *Node) CanInt64() bool {
-	if !Isconst(n, constant.Int) {
-		return false
-	}
-
-	// if the value inside n cannot be represented as an int64, the
-	// return value of Int64 is undefined
-	_, ok := constant.Int64Val(n.Val())
-	return ok
-}
-
-// Uint64Val returns n as an uint64.
-// n must be an integer or rune constant.
-func (n *Node) Uint64Val() uint64 {
-	if !Isconst(n, constant.Int) {
-		base.Fatalf("Uint64Val(%v)", n)
-	}
-	x, ok := constant.Uint64Val(n.Val())
-	if !ok {
-		base.Fatalf("Uint64Val(%v)", n)
-	}
-	return x
-}
-
-// BoolVal returns n as a bool.
-// n must be a boolean constant.
-func (n *Node) BoolVal() bool {
-	if !Isconst(n, constant.Bool) {
-		base.Fatalf("BoolVal(%v)", n)
-	}
-	return constant.BoolVal(n.Val())
-}
-
-// StringVal returns the value of a literal string Node as a string.
-// n must be a string constant.
-func (n *Node) StringVal() string {
-	if !Isconst(n, constant.String) {
-		base.Fatalf("StringVal(%v)", n)
-	}
-	return constant.StringVal(n.Val())
-}
-
 func roundFloat(v constant.Value, sz int64) constant.Value {
 	switch sz {
 	case 4:
@@ -184,8 +84,8 @@ func trunccmplxlit(v constant.Value, t *types.Type) constant.Value {
 }
 
 // TODO(mdempsky): Replace these with better APIs.
-func convlit(n *Node, t *types.Type) *Node    { return convlit1(n, t, false, nil) }
-func defaultlit(n *Node, t *types.Type) *Node { return convlit1(n, t, false, nil) }
+func convlit(n *ir.Node, t *types.Type) *ir.Node    { return convlit1(n, t, false, nil) }
+func defaultlit(n *ir.Node, t *types.Type) *ir.Node { return convlit1(n, t, false, nil) }
 
 // convlit1 converts an untyped expression n to type t. If n already
 // has a type, convlit1 has no effect.
@@ -198,7 +98,7 @@ func defaultlit(n *Node, t *types.Type) *Node { return convlit1(n, t, false, nil
 //
 // If there's an error converting n to t, context is used in the error
 // message.
-func convlit1(n *Node, t *types.Type, explicit bool, context func() string) *Node {
+func convlit1(n *ir.Node, t *types.Type, explicit bool, context func() string) *ir.Node {
 	if explicit && t == nil {
 		base.Fatalf("explicit conversion missing type")
 	}
@@ -215,15 +115,15 @@ func convlit1(n *Node, t *types.Type, explicit bool, context func() string) *Nod
 		return n
 	}
 
-	if n.Op == OLITERAL || n.Op == ONIL {
+	if n.Op == ir.OLITERAL || n.Op == ir.ONIL {
 		// Can't always set n.Type directly on OLITERAL nodes.
 		// See discussion on CL 20813.
-		n = n.rawcopy()
+		n = n.RawCopy()
 	}
 
 	// Nil is technically not a constant, so handle it specially.
-	if n.Type.Etype == TNIL {
-		if n.Op != ONIL {
+	if n.Type.Etype == types.TNIL {
+		if n.Op != ir.ONIL {
 			base.Fatalf("unexpected op: %v (%v)", n, n.Op)
 		}
 		if t == nil {
@@ -242,7 +142,7 @@ func convlit1(n *Node, t *types.Type, explicit bool, context func() string) *Nod
 		return n
 	}
 
-	if t == nil || !okforconst[t.Etype] {
+	if t == nil || !ir.OKForConst[t.Etype] {
 		t = defaultType(n.Type)
 	}
 
@@ -250,7 +150,7 @@ func convlit1(n *Node, t *types.Type, explicit bool, context func() string) *Nod
 	default:
 		base.Fatalf("unexpected untyped expression: %v", n)
 
-	case OLITERAL:
+	case ir.OLITERAL:
 		v := convertVal(n.Val(), t, explicit)
 		if v.Kind() == constant.Unknown {
 			break
@@ -259,7 +159,7 @@ func convlit1(n *Node, t *types.Type, explicit bool, context func() string) *Nod
 		n.SetVal(v)
 		return n
 
-	case OPLUS, ONEG, OBITNOT, ONOT, OREAL, OIMAG:
+	case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT, ir.OREAL, ir.OIMAG:
 		ot := operandType(n.Op, t)
 		if ot == nil {
 			n = defaultlit(n, nil)
@@ -274,7 +174,7 @@ func convlit1(n *Node, t *types.Type, explicit bool, context func() string) *Nod
 		n.Type = t
 		return n
 
-	case OADD, OSUB, OMUL, ODIV, OMOD, OOR, OXOR, OAND, OANDNOT, OOROR, OANDAND, OCOMPLEX:
+	case ir.OADD, ir.OSUB, ir.OMUL, ir.ODIV, ir.OMOD, ir.OOR, ir.OXOR, ir.OAND, ir.OANDNOT, ir.OOROR, ir.OANDAND, ir.OCOMPLEX:
 		ot := operandType(n.Op, t)
 		if ot == nil {
 			n = defaultlit(n, nil)
@@ -296,14 +196,14 @@ func convlit1(n *Node, t *types.Type, explicit bool, context func() string) *Nod
 		n.Type = t
 		return n
 
-	case OEQ, ONE, OLT, OLE, OGT, OGE:
+	case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
 		if !t.IsBoolean() {
 			break
 		}
 		n.Type = t
 		return n
 
-	case OLSH, ORSH:
+	case ir.OLSH, ir.ORSH:
 		n.Left = convlit1(n.Left, t, explicit, nil)
 		n.Type = n.Left.Type
 		if n.Type != nil && !n.Type.IsInteger() {
@@ -329,13 +229,13 @@ func convlit1(n *Node, t *types.Type, explicit bool, context func() string) *Nod
 	return n
 }
 
-func operandType(op Op, t *types.Type) *types.Type {
+func operandType(op ir.Op, t *types.Type) *types.Type {
 	switch op {
-	case OCOMPLEX:
+	case ir.OCOMPLEX:
 		if t.IsComplex() {
 			return floatForComplex(t)
 		}
-	case OREAL, OIMAG:
+	case ir.OREAL, ir.OIMAG:
 		if t.IsFloat() {
 			return complexForFloat(t)
 		}
@@ -488,7 +388,7 @@ func overflow(v constant.Value, t *types.Type) bool {
 		return true
 	}
 	if doesoverflow(v, t) {
-		base.Errorf("constant %v overflows %v", vconv(v, 0), t)
+		base.Errorf("constant %v overflows %v", ir.FmtConst(v, 0), t)
 		return true
 	}
 	return false
@@ -505,57 +405,46 @@ func tostr(v constant.Value) constant.Value {
 	return v
 }
 
-func consttype(n *Node) constant.Kind {
-	if n == nil || n.Op != OLITERAL {
-		return constant.Unknown
-	}
-	return n.Val().Kind()
-}
-
-func Isconst(n *Node, ct constant.Kind) bool {
-	return consttype(n) == ct
-}
-
 var tokenForOp = [...]token.Token{
-	OPLUS:   token.ADD,
-	ONEG:    token.SUB,
-	ONOT:    token.NOT,
-	OBITNOT: token.XOR,
-
-	OADD:    token.ADD,
-	OSUB:    token.SUB,
-	OMUL:    token.MUL,
-	ODIV:    token.QUO,
-	OMOD:    token.REM,
-	OOR:     token.OR,
-	OXOR:    token.XOR,
-	OAND:    token.AND,
-	OANDNOT: token.AND_NOT,
-	OOROR:   token.LOR,
-	OANDAND: token.LAND,
-
-	OEQ: token.EQL,
-	ONE: token.NEQ,
-	OLT: token.LSS,
-	OLE: token.LEQ,
-	OGT: token.GTR,
-	OGE: token.GEQ,
-
-	OLSH: token.SHL,
-	ORSH: token.SHR,
+	ir.OPLUS:   token.ADD,
+	ir.ONEG:    token.SUB,
+	ir.ONOT:    token.NOT,
+	ir.OBITNOT: token.XOR,
+
+	ir.OADD:    token.ADD,
+	ir.OSUB:    token.SUB,
+	ir.OMUL:    token.MUL,
+	ir.ODIV:    token.QUO,
+	ir.OMOD:    token.REM,
+	ir.OOR:     token.OR,
+	ir.OXOR:    token.XOR,
+	ir.OAND:    token.AND,
+	ir.OANDNOT: token.AND_NOT,
+	ir.OOROR:   token.LOR,
+	ir.OANDAND: token.LAND,
+
+	ir.OEQ: token.EQL,
+	ir.ONE: token.NEQ,
+	ir.OLT: token.LSS,
+	ir.OLE: token.LEQ,
+	ir.OGT: token.GTR,
+	ir.OGE: token.GEQ,
+
+	ir.OLSH: token.SHL,
+	ir.ORSH: token.SHR,
 }
 
 // evalConst returns a constant-evaluated expression equivalent to n.
 // If n is not a constant, evalConst returns n.
 // Otherwise, evalConst returns a new OLITERAL with the same value as n,
 // and with .Orig pointing back to n.
-func evalConst(n *Node) *Node {
+func evalConst(n *ir.Node) *ir.Node {
 	nl, nr := n.Left, n.Right
 
 	// Pick off just the opcodes that can be constant evaluated.
 	switch op := n.Op; op {
-	case OPLUS, ONEG, OBITNOT, ONOT:
-		if nl.Op == OLITERAL {
+	case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT:
+		if nl.Op == ir.OLITERAL {
 			var prec uint
 			if n.Type.IsUnsigned() {
 				prec = uint(n.Type.Size() * 8)
@@ -563,36 +452,36 @@ func evalConst(n *Node) *Node {
 			return origConst(n, constant.UnaryOp(tokenForOp[op], nl.Val(), prec))
 		}
 
-	case OADD, OSUB, OMUL, ODIV, OMOD, OOR, OXOR, OAND, OANDNOT, OOROR, OANDAND:
-		if nl.Op == OLITERAL && nr.Op == OLITERAL {
+	case ir.OADD, ir.OSUB, ir.OMUL, ir.ODIV, ir.OMOD, ir.OOR, ir.OXOR, ir.OAND, ir.OANDNOT, ir.OOROR, ir.OANDAND:
+		if nl.Op == ir.OLITERAL && nr.Op == ir.OLITERAL {
 			rval := nr.Val()
 
 			// check for divisor underflow in complex division (see issue 20227)
-			if op == ODIV && n.Type.IsComplex() && constant.Sign(square(constant.Real(rval))) == 0 && constant.Sign(square(constant.Imag(rval))) == 0 {
+			if op == ir.ODIV && n.Type.IsComplex() && constant.Sign(square(constant.Real(rval))) == 0 && constant.Sign(square(constant.Imag(rval))) == 0 {
 				base.Errorf("complex division by zero")
 				n.Type = nil
 				return n
 			}
-			if (op == ODIV || op == OMOD) && constant.Sign(rval) == 0 {
+			if (op == ir.ODIV || op == ir.OMOD) && constant.Sign(rval) == 0 {
 				base.Errorf("division by zero")
 				n.Type = nil
 				return n
 			}
 
 			tok := tokenForOp[op]
-			if op == ODIV && n.Type.IsInteger() {
+			if op == ir.ODIV && n.Type.IsInteger() {
 				tok = token.QUO_ASSIGN // integer division
 			}
 			return origConst(n, constant.BinaryOp(nl.Val(), tok, rval))
 		}
 
-	case OEQ, ONE, OLT, OLE, OGT, OGE:
-		if nl.Op == OLITERAL && nr.Op == OLITERAL {
+	case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
+		if nl.Op == ir.OLITERAL && nr.Op == ir.OLITERAL {
 			return origBoolConst(n, constant.Compare(nl.Val(), tokenForOp[op], nr.Val()))
 		}
 
-	case OLSH, ORSH:
-		if nl.Op == OLITERAL && nr.Op == OLITERAL {
+	case ir.OLSH, ir.ORSH:
+		if nl.Op == ir.OLITERAL && nr.Op == ir.OLITERAL {
 			// shiftBound from go/types; "so we can express smallestFloat64"
 			const shiftBound = 1023 - 1 + 52
 			s, ok := constant.Uint64Val(nr.Val())
@@ -604,24 +493,24 @@ func evalConst(n *Node) *Node {
 			return origConst(n, constant.Shift(toint(nl.Val()), tokenForOp[op], uint(s)))
 		}
 
-	case OCONV, ORUNESTR:
-		if okforconst[n.Type.Etype] && nl.Op == OLITERAL {
+	case ir.OCONV, ir.ORUNESTR:
+		if ir.OKForConst[n.Type.Etype] && nl.Op == ir.OLITERAL {
 			return origConst(n, convertVal(nl.Val(), n.Type, true))
 		}
 
-	case OCONVNOP:
-		if okforconst[n.Type.Etype] && nl.Op == OLITERAL {
+	case ir.OCONVNOP:
+		if ir.OKForConst[n.Type.Etype] && nl.Op == ir.OLITERAL {
 			// set so n.Orig gets OCONV instead of OCONVNOP
-			n.Op = OCONV
+			n.Op = ir.OCONV
 			return origConst(n, nl.Val())
 		}
 
-	case OADDSTR:
+	case ir.OADDSTR:
 		// Merge adjacent constants in the argument list.
 		s := n.List.Slice()
 		need := 0
 		for i := 0; i < len(s); i++ {
-			if i == 0 || !Isconst(s[i-1], constant.String) || !Isconst(s[i], constant.String) {
+			if i == 0 || !ir.IsConst(s[i-1], constant.String) || !ir.IsConst(s[i], constant.String) {
 				// Can't merge s[i] into s[i-1]; need a slot in the list.
 				need++
 			}
@@ -636,13 +525,13 @@ func evalConst(n *Node) *Node {
 			}
 			return origConst(n, constant.MakeString(strings.Join(strs, "")))
 		}
-		newList := make([]*Node, 0, need)
+		newList := make([]*ir.Node, 0, need)
 		for i := 0; i < len(s); i++ {
-			if Isconst(s[i], constant.String) && i+1 < len(s) && Isconst(s[i+1], constant.String) {
+			if ir.IsConst(s[i], constant.String) && i+1 < len(s) && ir.IsConst(s[i+1], constant.String) {
 				// merge from i up to but not including i2
 				var strs []string
 				i2 := i
-				for i2 < len(s) && Isconst(s[i2], constant.String) {
+				for i2 < len(s) && ir.IsConst(s[i2], constant.String) {
 					strs = append(strs, s[i2].StringVal())
 					i2++
 				}
@@ -656,37 +545,37 @@ func evalConst(n *Node) *Node {
 			}
 		}
 
-		n = n.copy()
+		n = ir.Copy(n)
 		n.List.Set(newList)
 		return n
 
-	case OCAP, OLEN:
+	case ir.OCAP, ir.OLEN:
 		switch nl.Type.Etype {
-		case TSTRING:
-			if Isconst(nl, constant.String) {
+		case types.TSTRING:
+			if ir.IsConst(nl, constant.String) {
 				return origIntConst(n, int64(len(nl.StringVal())))
 			}
-		case TARRAY:
+		case types.TARRAY:
 			if !hascallchan(nl) {
 				return origIntConst(n, nl.Type.NumElem())
 			}
 		}
 
-	case OALIGNOF, OOFFSETOF, OSIZEOF:
+	case ir.OALIGNOF, ir.OOFFSETOF, ir.OSIZEOF:
 		return origIntConst(n, evalunsafe(n))
 
-	case OREAL:
-		if nl.Op == OLITERAL {
+	case ir.OREAL:
+		if nl.Op == ir.OLITERAL {
 			return origConst(n, constant.Real(nl.Val()))
 		}
 
-	case OIMAG:
-		if nl.Op == OLITERAL {
+	case ir.OIMAG:
+		if nl.Op == ir.OLITERAL {
 			return origConst(n, constant.Imag(nl.Val()))
 		}
 
-	case OCOMPLEX:
-		if nl.Op == OLITERAL && nr.Op == OLITERAL {
+	case ir.OCOMPLEX:
+		if nl.Op == ir.OLITERAL && nr.Op == ir.OLITERAL {
 			return origConst(n, makeComplex(nl.Val(), nr.Val()))
 		}
 	}
@@ -721,16 +610,16 @@ func square(x constant.Value) constant.Value {
 // For matching historical "constant OP overflow" error messages.
 // TODO(mdempsky): Replace with error messages like go/types uses.
 var overflowNames = [...]string{
-	OADD:    "addition",
-	OSUB:    "subtraction",
-	OMUL:    "multiplication",
-	OLSH:    "shift",
-	OXOR:    "bitwise XOR",
-	OBITNOT: "bitwise complement",
+	ir.OADD:    "addition",
+	ir.OSUB:    "subtraction",
+	ir.OMUL:    "multiplication",
+	ir.OLSH:    "shift",
+	ir.OXOR:    "bitwise XOR",
+	ir.OBITNOT: "bitwise complement",
 }
 
 // origConst returns an OLITERAL with orig n and value v.
-func origConst(n *Node, v constant.Value) *Node {
+func origConst(n *ir.Node, v constant.Value) *ir.Node {
 	lno := setlineno(n)
 	v = convertVal(v, n.Type, false)
 	base.Pos = lno
@@ -752,81 +641,28 @@ func origConst(n *Node, v constant.Value) *Node {
 	}
 
 	orig := n
-	n = nodl(orig.Pos, OLITERAL, nil, nil)
+	n = ir.NodAt(orig.Pos, ir.OLITERAL, nil, nil)
 	n.Orig = orig
 	n.Type = orig.Type
 	n.SetVal(v)
 	return n
 }
 
-func assertRepresents(t *types.Type, v constant.Value) {
-	if !represents(t, v) {
-		base.Fatalf("%v does not represent %v", t, v)
-	}
-}
-
-func represents(t *types.Type, v constant.Value) bool {
-	switch v.Kind() {
-	case constant.Unknown:
-		return okforconst[t.Etype]
-	case constant.Bool:
-		return t.IsBoolean()
-	case constant.String:
-		return t.IsString()
-	case constant.Int:
-		return t.IsInteger()
-	case constant.Float:
-		return t.IsFloat()
-	case constant.Complex:
-		return t.IsComplex()
-	}
-
-	base.Fatalf("unexpected constant kind: %v", v)
-	panic("unreachable")
-}
-
-func origBoolConst(n *Node, v bool) *Node {
+func origBoolConst(n *ir.Node, v bool) *ir.Node {
 	return origConst(n, constant.MakeBool(v))
 }
 
-func origIntConst(n *Node, v int64) *Node {
+func origIntConst(n *ir.Node, v int64) *ir.Node {
 	return origConst(n, constant.MakeInt64(v))
 }
 
-// nodlit returns a new untyped constant with value v.
-func nodlit(v constant.Value) *Node {
-	n := nod(OLITERAL, nil, nil)
-	if k := v.Kind(); k != constant.Unknown {
-		n.Type = idealType(k)
-		n.SetVal(v)
-	}
-	return n
-}
-
-func idealType(ct constant.Kind) *types.Type {
-	switch ct {
-	case constant.String:
-		return types.UntypedString
-	case constant.Bool:
-		return types.UntypedBool
-	case constant.Int:
-		return types.UntypedInt
-	case constant.Float:
-		return types.UntypedFloat
-	case constant.Complex:
-		return types.UntypedComplex
-	}
-	base.Fatalf("unexpected Ctype: %v", ct)
-	return nil
-}
-
 // defaultlit on both nodes simultaneously;
 // if they're both ideal going in they better
 // get the same type going out.
 // force means must assign concrete (non-ideal) type.
 // The results of defaultlit2 MUST be assigned back to l and r, e.g.
 // 	n.Left, n.Right = defaultlit2(n.Left, n.Right, force)
-func defaultlit2(l *Node, r *Node, force bool) (*Node, *Node) {
+func defaultlit2(l *ir.Node, r *ir.Node, force bool) (*ir.Node, *ir.Node) {
 	if l.Type == nil || r.Type == nil {
 		return l, r
 	}
@@ -851,7 +687,7 @@ func defaultlit2(l *Node, r *Node, force bool) (*Node, *Node) {
 	if l.Type.IsString() != r.Type.IsString() {
 		return l, r
 	}
-	if l.isNil() || r.isNil() {
+	if ir.IsNil(l) || ir.IsNil(r) {
 		return l, r
 	}
 
@@ -888,31 +724,31 @@ func mixUntyped(t1, t2 *types.Type) *types.Type {
 }
 
 func defaultType(t *types.Type) *types.Type {
-	if !t.IsUntyped() || t.Etype == TNIL {
+	if !t.IsUntyped() || t.Etype == types.TNIL {
 		return t
 	}
 
 	switch t {
 	case types.UntypedBool:
-		return types.Types[TBOOL]
+		return types.Types[types.TBOOL]
 	case types.UntypedString:
-		return types.Types[TSTRING]
+		return types.Types[types.TSTRING]
 	case types.UntypedInt:
-		return types.Types[TINT]
+		return types.Types[types.TINT]
 	case types.UntypedRune:
 		return types.Runetype
 	case types.UntypedFloat:
-		return types.Types[TFLOAT64]
+		return types.Types[types.TFLOAT64]
 	case types.UntypedComplex:
-		return types.Types[TCOMPLEX128]
+		return types.Types[types.TCOMPLEX128]
 	}
 
 	base.Fatalf("bad type %v", t)
 	return nil
 }
 
-func smallintconst(n *Node) bool {
-	if n.Op == OLITERAL {
+func smallintconst(n *ir.Node) bool {
+	if n.Op == ir.OLITERAL {
 		v, ok := constant.Int64Val(n.Val())
 		return ok && int64(int32(v)) == v
 	}
@@ -924,11 +760,11 @@ func smallintconst(n *Node) bool {
 // If n is not a constant expression, not representable as an
 // integer, or negative, it returns -1. If n is too large, it
 // returns -2.
-func indexconst(n *Node) int64 {
-	if n.Op != OLITERAL {
+func indexconst(n *ir.Node) int64 {
+	if n.Op != ir.OLITERAL {
 		return -1
 	}
-	if !n.Type.IsInteger() && n.Type.Etype != TIDEAL {
+	if !n.Type.IsInteger() && n.Type.Etype != types.TIDEAL {
 		return -1
 	}
 
@@ -936,10 +772,10 @@ func indexconst(n *Node) int64 {
 	if v.Kind() != constant.Int || constant.Sign(v) < 0 {
 		return -1
 	}
-	if doesoverflow(v, types.Types[TINT]) {
+	if doesoverflow(v, types.Types[types.TINT]) {
 		return -2
 	}
-	return int64Val(types.Types[TINT], v)
+	return ir.Int64Val(types.Types[types.TINT], v)
 }
 
 // isGoConst reports whether n is a Go language constant (as opposed to a
@@ -947,35 +783,35 @@ func indexconst(n *Node) int64 {
 //
 // Expressions derived from nil, like string([]byte(nil)), while they
 // may be known at compile time, are not Go language constants.
-func (n *Node) isGoConst() bool {
-	return n.Op == OLITERAL
+func isGoConst(n *ir.Node) bool {
+	return n.Op == ir.OLITERAL
 }
 
-func hascallchan(n *Node) bool {
+func hascallchan(n *ir.Node) bool {
 	if n == nil {
 		return false
 	}
 	switch n.Op {
-	case OAPPEND,
-		OCALL,
-		OCALLFUNC,
-		OCALLINTER,
-		OCALLMETH,
-		OCAP,
-		OCLOSE,
-		OCOMPLEX,
-		OCOPY,
-		ODELETE,
-		OIMAG,
-		OLEN,
-		OMAKE,
-		ONEW,
-		OPANIC,
-		OPRINT,
-		OPRINTN,
-		OREAL,
-		ORECOVER,
-		ORECV:
+	case ir.OAPPEND,
+		ir.OCALL,
+		ir.OCALLFUNC,
+		ir.OCALLINTER,
+		ir.OCALLMETH,
+		ir.OCAP,
+		ir.OCLOSE,
+		ir.OCOMPLEX,
+		ir.OCOPY,
+		ir.ODELETE,
+		ir.OIMAG,
+		ir.OLEN,
+		ir.OMAKE,
+		ir.ONEW,
+		ir.OPANIC,
+		ir.OPRINT,
+		ir.OPRINTN,
+		ir.OREAL,
+		ir.ORECOVER,
+		ir.ORECV:
 		return true
 	}
 
@@ -1015,12 +851,12 @@ type constSetKey struct {
 // where are used in the error message.
 //
 // n must not be an untyped constant.
-func (s *constSet) add(pos src.XPos, n *Node, what, where string) {
-	if n.Op == OCONVIFACE && n.Implicit() {
+func (s *constSet) add(pos src.XPos, n *ir.Node, what, where string) {
+	if n.Op == ir.OCONVIFACE && n.Implicit() {
 		n = n.Left
 	}
 
-	if !n.isGoConst() {
+	if !isGoConst(n) {
 		return
 	}
 	if n.Type.IsUntyped() {
@@ -1045,11 +881,11 @@ func (s *constSet) add(pos src.XPos, n *Node, what, where string) {
 	typ := n.Type
 	switch typ {
 	case types.Bytetype:
-		typ = types.Types[TUINT8]
+		typ = types.Types[types.TUINT8]
 	case types.Runetype:
-		typ = types.Types[TINT32]
+		typ = types.Types[types.TINT32]
 	}
-	k := constSetKey{typ, n.ValueInterface()}
+	k := constSetKey{typ, ir.ConstValue(n)}
 
 	if hasUniquePos(n) {
 		pos = n.Pos
@@ -1072,9 +908,9 @@ func (s *constSet) add(pos src.XPos, n *Node, what, where string) {
 // the latter is non-obvious.
 //
 // TODO(mdempsky): This could probably be a fmt.go flag.
-func nodeAndVal(n *Node) string {
+func nodeAndVal(n *ir.Node) string {
 	show := n.String()
-	val := n.ValueInterface()
+	val := ir.ConstValue(n)
 	if s := fmt.Sprintf("%#v", val); show != s {
 		show += " (value " + s + ")"
 	}
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 63a52a9f36..6fee872fd2 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"bytes"
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/src"
@@ -17,7 +18,7 @@ import (
 
 // Declaration stack & operations
 
-var externdcl []*Node
+var externdcl []*ir.Node
 
 func testdclstack() {
 	if !types.IsDclstackValid() {
@@ -58,25 +59,25 @@ var declare_typegen int
 
 // declare records that Node n declares symbol n.Sym in the specified
 // declaration context.
-func declare(n *Node, ctxt Class) {
-	if n.isBlank() {
+func declare(n *ir.Node, ctxt ir.Class) {
+	if ir.IsBlank(n) {
 		return
 	}
 
 	if n.Name == nil {
 		// named OLITERAL needs Name; most OLITERALs don't.
-		n.Name = new(Name)
+		n.Name = new(ir.Name)
 	}
 
 	s := n.Sym
 
 	// kludgy: typecheckok means we're past parsing. Eg genwrapper may declare out of package names later.
-	if !inimport && !typecheckok && s.Pkg != localpkg {
+	if !inimport && !typecheckok && s.Pkg != ir.LocalPkg {
 		base.ErrorfAt(n.Pos, "cannot declare name %v", s)
 	}
 
 	gen := 0
-	if ctxt == PEXTERN {
+	if ctxt == ir.PEXTERN {
 		if s.Name == "init" {
 			base.ErrorfAt(n.Pos, "cannot declare init - must be func")
 		}
@@ -85,17 +86,17 @@ func declare(n *Node, ctxt Class) {
 		}
 		externdcl = append(externdcl, n)
 	} else {
-		if Curfn == nil && ctxt == PAUTO {
+		if Curfn == nil && ctxt == ir.PAUTO {
 			base.Pos = n.Pos
 			base.Fatalf("automatic outside function")
 		}
-		if Curfn != nil && ctxt != PFUNC {
+		if Curfn != nil && ctxt != ir.PFUNC {
 			Curfn.Func.Dcl = append(Curfn.Func.Dcl, n)
 		}
-		if n.Op == OTYPE {
+		if n.Op == ir.OTYPE {
 			declare_typegen++
 			gen = declare_typegen
-		} else if n.Op == ONAME && ctxt == PAUTO && !strings.Contains(s.Name, "·") {
+		} else if n.Op == ir.ONAME && ctxt == ir.PAUTO && !strings.Contains(s.Name, "·") {
 			vargen++
 			gen = vargen
 		}
@@ -103,58 +104,58 @@ func declare(n *Node, ctxt Class) {
 		n.Name.Curfn = Curfn
 	}
 
-	if ctxt == PAUTO {
+	if ctxt == ir.PAUTO {
 		n.Xoffset = 0
 	}
 
 	if s.Block == types.Block {
 		// functype will print errors about duplicate function arguments.
 		// Don't repeat the error here.
-		if ctxt != PPARAM && ctxt != PPARAMOUT {
+		if ctxt != ir.PPARAM && ctxt != ir.PPARAMOUT {
 			redeclare(n.Pos, s, "in this block")
 		}
 	}
 
 	s.Block = types.Block
 	s.Lastlineno = base.Pos
-	s.Def = asTypesNode(n)
+	s.Def = ir.AsTypesNode(n)
 	n.Name.Vargen = int32(gen)
 	n.SetClass(ctxt)
-	if ctxt == PFUNC {
+	if ctxt == ir.PFUNC {
 		n.Sym.SetFunc(true)
 	}
 
 	autoexport(n, ctxt)
 }
 
-func addvar(n *Node, t *types.Type, ctxt Class) {
-	if n == nil || n.Sym == nil || (n.Op != ONAME && n.Op != ONONAME) || t == nil {
+func addvar(n *ir.Node, t *types.Type, ctxt ir.Class) {
+	if n == nil || n.Sym == nil || (n.Op != ir.ONAME && n.Op != ir.ONONAME) || t == nil {
 		base.Fatalf("addvar: n=%v t=%v nil", n, t)
 	}
 
-	n.Op = ONAME
+	n.Op = ir.ONAME
 	declare(n, ctxt)
 	n.Type = t
 }
 
 // declare variables from grammar
 // new_name_list (type | [type] = expr_list)
-func variter(vl []*Node, t *Node, el []*Node) []*Node {
-	var init []*Node
+func variter(vl []*ir.Node, t *ir.Node, el []*ir.Node) []*ir.Node {
+	var init []*ir.Node
 	doexpr := len(el) > 0
 
 	if len(el) == 1 && len(vl) > 1 {
 		e := el[0]
-		as2 := nod(OAS2, nil, nil)
+		as2 := ir.Nod(ir.OAS2, nil, nil)
 		as2.List.Set(vl)
 		as2.Rlist.Set1(e)
 		for _, v := range vl {
-			v.Op = ONAME
+			v.Op = ir.ONAME
 			declare(v, dclcontext)
 			v.Name.Param.Ntype = t
 			v.Name.Defn = as2
 			if Curfn != nil {
-				init = append(init, nod(ODCL, v, nil))
+				init = append(init, ir.Nod(ir.ODCL, v, nil))
 			}
 		}
 
@@ -163,7 +164,7 @@ func variter(vl []*Node, t *Node, el []*Node) []*Node {
 
 	nel := len(el)
 	for _, v := range vl {
-		var e *Node
+		var e *ir.Node
 		if doexpr {
 			if len(el) == 0 {
 				base.Errorf("assignment mismatch: %d variables but %d values", len(vl), nel)
@@ -173,15 +174,15 @@ func variter(vl []*Node, t *Node, el []*Node) []*Node {
 			el = el[1:]
 		}
 
-		v.Op = ONAME
+		v.Op = ir.ONAME
 		declare(v, dclcontext)
 		v.Name.Param.Ntype = t
 
-		if e != nil || Curfn != nil || v.isBlank() {
+		if e != nil || Curfn != nil || ir.IsBlank(v) {
 			if Curfn != nil {
-				init = append(init, nod(ODCL, v, nil))
+				init = append(init, ir.Nod(ir.ODCL, v, nil))
 			}
-			e = nod(OAS, v, e)
+			e = ir.Nod(ir.OAS, v, e)
 			init = append(init, e)
 			if e.Right != nil {
 				v.Name.Defn = e
@@ -196,22 +197,22 @@ func variter(vl []*Node, t *Node, el []*Node) []*Node {
 }
 
 // newnoname returns a new ONONAME Node associated with symbol s.
-func newnoname(s *types.Sym) *Node {
+func newnoname(s *types.Sym) *ir.Node {
 	if s == nil {
 		base.Fatalf("newnoname nil")
 	}
-	n := nod(ONONAME, nil, nil)
+	n := ir.Nod(ir.ONONAME, nil, nil)
 	n.Sym = s
 	n.Xoffset = 0
 	return n
 }
 
 // newfuncnamel generates a new name node for a function or method.
-func newfuncnamel(pos src.XPos, s *types.Sym, fn *Func) *Node {
+func newfuncnamel(pos src.XPos, s *types.Sym, fn *ir.Func) *ir.Node {
 	if fn.Nname != nil {
 		base.Fatalf("newfuncnamel - already have name")
 	}
-	n := newnamel(pos, s)
+	n := ir.NewNameAt(pos, s)
 	n.Func = fn
 	fn.Nname = n
 	return n
@@ -219,39 +220,39 @@ func newfuncnamel(pos src.XPos, s *types.Sym, fn *Func) *Node {
 
 // this generates a new name node for a name
 // being declared.
-func dclname(s *types.Sym) *Node {
-	n := newname(s)
-	n.Op = ONONAME // caller will correct it
+func dclname(s *types.Sym) *ir.Node {
+	n := NewName(s)
+	n.Op = ir.ONONAME // caller will correct it
 	return n
 }
 
-func typenod(t *types.Type) *Node {
+func typenod(t *types.Type) *ir.Node {
 	return typenodl(src.NoXPos, t)
 }
 
-func typenodl(pos src.XPos, t *types.Type) *Node {
+func typenodl(pos src.XPos, t *types.Type) *ir.Node {
 	// if we copied another type with *t = *u
 	// then t->nod might be out of date, so
 	// check t->nod->type too
-	if asNode(t.Nod) == nil || asNode(t.Nod).Type != t {
-		t.Nod = asTypesNode(nodl(pos, OTYPE, nil, nil))
-		asNode(t.Nod).Type = t
-		asNode(t.Nod).Sym = t.Sym
+	if ir.AsNode(t.Nod) == nil || ir.AsNode(t.Nod).Type != t {
+		t.Nod = ir.AsTypesNode(ir.NodAt(pos, ir.OTYPE, nil, nil))
+		ir.AsNode(t.Nod).Type = t
+		ir.AsNode(t.Nod).Sym = t.Sym
 	}
 
-	return asNode(t.Nod)
+	return ir.AsNode(t.Nod)
 }
 
-func anonfield(typ *types.Type) *Node {
+func anonfield(typ *types.Type) *ir.Node {
 	return symfield(nil, typ)
 }
 
-func namedfield(s string, typ *types.Type) *Node {
+func namedfield(s string, typ *types.Type) *ir.Node {
 	return symfield(lookup(s), typ)
 }
 
-func symfield(s *types.Sym, typ *types.Type) *Node {
-	n := nodSym(ODCLFIELD, nil, s)
+func symfield(s *types.Sym, typ *types.Type) *ir.Node {
+	n := nodSym(ir.ODCLFIELD, nil, s)
 	n.Type = typ
 	return n
 }
@@ -260,8 +261,8 @@ func symfield(s *types.Sym, typ *types.Type) *Node {
 // If no such Node currently exists, an ONONAME Node is returned instead.
 // Automatically creates a new closure variable if the referenced symbol was
 // declared in a different (containing) function.
-func oldname(s *types.Sym) *Node {
-	n := asNode(s.Def)
+func oldname(s *types.Sym) *ir.Node {
+	n := ir.AsNode(s.Def)
 	if n == nil {
 		// Maybe a top-level declaration will come along later to
 		// define s. resolve will check s.Def again once all input
@@ -269,7 +270,7 @@ func oldname(s *types.Sym) *Node {
 		return newnoname(s)
 	}
 
-	if Curfn != nil && n.Op == ONAME && n.Name.Curfn != nil && n.Name.Curfn != Curfn {
+	if Curfn != nil && n.Op == ir.ONAME && n.Name.Curfn != nil && n.Name.Curfn != Curfn {
 		// Inner func is referring to var in outer func.
 		//
 		// TODO(rsc): If there is an outer variable x and we
@@ -279,8 +280,8 @@ func oldname(s *types.Sym) *Node {
 		c := n.Name.Param.Innermost
 		if c == nil || c.Name.Curfn != Curfn {
 			// Do not have a closure var for the active closure yet; make one.
-			c = newname(s)
-			c.SetClass(PAUTOHEAP)
+			c = NewName(s)
+			c.SetClass(ir.PAUTOHEAP)
 			c.Name.SetIsClosureVar(true)
 			c.SetIsDDD(n.IsDDD())
 			c.Name.Defn = n
@@ -301,9 +302,9 @@ func oldname(s *types.Sym) *Node {
 }
 
 // importName is like oldname, but it reports an error if sym is from another package and not exported.
-func importName(sym *types.Sym) *Node {
+func importName(sym *types.Sym) *ir.Node {
 	n := oldname(sym)
-	if !types.IsExported(sym.Name) && sym.Pkg != localpkg {
+	if !types.IsExported(sym.Name) && sym.Pkg != ir.LocalPkg {
 		n.SetDiag(true)
 		base.Errorf("cannot refer to unexported name %s.%s", sym.Pkg.Name, sym.Name)
 	}
@@ -311,20 +312,20 @@ func importName(sym *types.Sym) *Node {
 }
 
 // := declarations
-func colasname(n *Node) bool {
+func colasname(n *ir.Node) bool {
 	switch n.Op {
-	case ONAME,
-		ONONAME,
-		OPACK,
-		OTYPE,
-		OLITERAL:
+	case ir.ONAME,
+		ir.ONONAME,
+		ir.OPACK,
+		ir.OTYPE,
+		ir.OLITERAL:
 		return n.Sym != nil
 	}
 
 	return false
 }
 
-func colasdefn(left []*Node, defn *Node) {
+func colasdefn(left []*ir.Node, defn *ir.Node) {
 	for _, n := range left {
 		if n.Sym != nil {
 			n.Sym.SetUniq(true)
@@ -333,7 +334,7 @@ func colasdefn(left []*Node, defn *Node) {
 
 	var nnew, nerr int
 	for i, n := range left {
-		if n.isBlank() {
+		if ir.IsBlank(n) {
 			continue
 		}
 		if !colasname(n) {
@@ -355,10 +356,10 @@ func colasdefn(left []*Node, defn *Node) {
 		}
 
 		nnew++
-		n = newname(n.Sym)
+		n = NewName(n.Sym)
 		declare(n, dclcontext)
 		n.Name.Defn = defn
-		defn.Ninit.Append(nod(ODCL, n, nil))
+		defn.Ninit.Append(ir.Nod(ir.ODCL, n, nil))
 		left[i] = n
 	}
 
@@ -369,8 +370,8 @@ func colasdefn(left []*Node, defn *Node) {
 
 // declare the arguments in an
 // interface field declaration.
-func ifacedcl(n *Node) {
-	if n.Op != ODCLFIELD || n.Left == nil {
+func ifacedcl(n *ir.Node) {
+	if n.Op != ir.ODCLFIELD || n.Left == nil {
 		base.Fatalf("ifacedcl")
 	}
 
@@ -383,11 +384,11 @@ func ifacedcl(n *Node) {
 // and declare the arguments.
 // called in extern-declaration context
 // returns in auto-declaration context.
-func funchdr(n *Node) {
+func funchdr(n *ir.Node) {
 	// change the declaration context from extern to auto
 	funcStack = append(funcStack, funcStackEnt{Curfn, dclcontext})
 	Curfn = n
-	dclcontext = PAUTO
+	dclcontext = ir.PAUTO
 
 	types.Markdcl()
 
@@ -398,8 +399,8 @@ func funchdr(n *Node) {
 	}
 }
 
-func funcargs(nt *Node) {
-	if nt.Op != OTFUNC {
+func funcargs(nt *ir.Node) {
+	if nt.Op != ir.OTFUNC {
 		base.Fatalf("funcargs %v", nt.Op)
 	}
 
@@ -414,10 +415,10 @@ func funcargs(nt *Node) {
 
 	// declare the receiver and in arguments.
 	if nt.Left != nil {
-		funcarg(nt.Left, PPARAM)
+		funcarg(nt.Left, ir.PPARAM)
 	}
 	for _, n := range nt.List.Slice() {
-		funcarg(n, PPARAM)
+		funcarg(n, ir.PPARAM)
 	}
 
 	oldvargen := vargen
@@ -442,21 +443,21 @@ func funcargs(nt *Node) {
 			gen++
 		}
 
-		funcarg(n, PPARAMOUT)
+		funcarg(n, ir.PPARAMOUT)
 	}
 
 	vargen = oldvargen
 }
 
-func funcarg(n *Node, ctxt Class) {
-	if n.Op != ODCLFIELD {
+func funcarg(n *ir.Node, ctxt ir.Class) {
+	if n.Op != ir.ODCLFIELD {
 		base.Fatalf("funcarg %v", n.Op)
 	}
 	if n.Sym == nil {
 		return
 	}
 
-	n.Right = newnamel(n.Pos, n.Sym)
+	n.Right = ir.NewNameAt(n.Pos, n.Sym)
 	n.Right.Name.Param.Ntype = n.Left
 	n.Right.SetIsDDD(n.IsDDD())
 	declare(n.Right, ctxt)
@@ -469,27 +470,27 @@ func funcarg(n *Node, ctxt Class) {
 // This happens during import, where the hidden_fndcl rule has
 // used functype directly to parse the function's type.
 func funcargs2(t *types.Type) {
-	if t.Etype != TFUNC {
+	if t.Etype != types.TFUNC {
 		base.Fatalf("funcargs2 %v", t)
 	}
 
 	for _, f := range t.Recvs().Fields().Slice() {
-		funcarg2(f, PPARAM)
+		funcarg2(f, ir.PPARAM)
 	}
 	for _, f := range t.Params().Fields().Slice() {
-		funcarg2(f, PPARAM)
+		funcarg2(f, ir.PPARAM)
 	}
 	for _, f := range t.Results().Fields().Slice() {
-		funcarg2(f, PPARAMOUT)
+		funcarg2(f, ir.PPARAMOUT)
 	}
 }
 
-func funcarg2(f *types.Field, ctxt Class) {
+func funcarg2(f *types.Field, ctxt ir.Class) {
 	if f.Sym == nil {
 		return
 	}
-	n := newnamel(f.Pos, f.Sym)
-	f.Nname = asTypesNode(n)
+	n := ir.NewNameAt(f.Pos, f.Sym)
+	f.Nname = ir.AsTypesNode(n)
 	n.Type = f.Type
 	n.SetIsDDD(f.IsDDD())
 	declare(n, ctxt)
@@ -498,8 +499,8 @@ func funcarg2(f *types.Field, ctxt Class) {
 var funcStack []funcStackEnt // stack of previous values of Curfn/dclcontext
 
 type funcStackEnt struct {
-	curfn      *Node
-	dclcontext Class
+	curfn      *ir.Node
+	dclcontext ir.Class
 }
 
 // finish the body.
@@ -529,16 +530,16 @@ func checkembeddedtype(t *types.Type) {
 
 	if t.IsPtr() || t.IsUnsafePtr() {
 		base.Errorf("embedded type cannot be a pointer")
-	} else if t.Etype == TFORW && !t.ForwardType().Embedlineno.IsKnown() {
+	} else if t.Etype == types.TFORW && !t.ForwardType().Embedlineno.IsKnown() {
 		t.ForwardType().Embedlineno = base.Pos
 	}
 }
 
-func structfield(n *Node) *types.Field {
+func structfield(n *ir.Node) *types.Field {
 	lno := base.Pos
 	base.Pos = n.Pos
 
-	if n.Op != ODCLFIELD {
+	if n.Op != ir.ODCLFIELD {
 		base.Fatalf("structfield: oops %v\n", n)
 	}
 
@@ -581,8 +582,8 @@ func checkdupfields(what string, fss ...[]*types.Field) {
 
 // convert a parsed id/type list into
 // a type for struct/interface/arglist
-func tostruct(l []*Node) *types.Type {
-	t := types.New(TSTRUCT)
+func tostruct(l []*ir.Node) *types.Type {
+	t := types.New(types.TSTRUCT)
 
 	fields := make([]*types.Field, len(l))
 	for i, n := range l {
@@ -603,8 +604,8 @@ func tostruct(l []*Node) *types.Type {
 	return t
 }
 
-func tofunargs(l []*Node, funarg types.Funarg) *types.Type {
-	t := types.New(TSTRUCT)
+func tofunargs(l []*ir.Node, funarg types.Funarg) *types.Type {
+	t := types.New(types.TSTRUCT)
 	t.StructType().Funarg = funarg
 
 	fields := make([]*types.Field, len(l))
@@ -613,7 +614,7 @@ func tofunargs(l []*Node, funarg types.Funarg) *types.Type {
 		f.SetIsDDD(n.IsDDD())
 		if n.Right != nil {
 			n.Right.Type = f.Type
-			f.Nname = asTypesNode(n.Right)
+			f.Nname = ir.AsTypesNode(n.Right)
 		}
 		if f.Broke() {
 			t.SetBroke(true)
@@ -625,17 +626,17 @@ func tofunargs(l []*Node, funarg types.Funarg) *types.Type {
 }
 
 func tofunargsfield(fields []*types.Field, funarg types.Funarg) *types.Type {
-	t := types.New(TSTRUCT)
+	t := types.New(types.TSTRUCT)
 	t.StructType().Funarg = funarg
 	t.SetFields(fields)
 	return t
 }
 
-func interfacefield(n *Node) *types.Field {
+func interfacefield(n *ir.Node) *types.Field {
 	lno := base.Pos
 	base.Pos = n.Pos
 
-	if n.Op != ODCLFIELD {
+	if n.Op != ir.ODCLFIELD {
 		base.Fatalf("interfacefield: oops %v\n", n)
 	}
 
@@ -660,11 +661,11 @@ func interfacefield(n *Node) *types.Field {
 	return f
 }
 
-func tointerface(l []*Node) *types.Type {
+func tointerface(l []*ir.Node) *types.Type {
 	if len(l) == 0 {
-		return types.Types[TINTER]
+		return types.Types[types.TINTER]
 	}
-	t := types.New(TINTER)
+	t := types.New(types.TINTER)
 	var fields []*types.Field
 	for _, n := range l {
 		f := interfacefield(n)
@@ -677,7 +678,7 @@ func tointerface(l []*Node) *types.Type {
 	return t
 }
 
-func fakeRecv() *Node {
+func fakeRecv() *ir.Node {
 	return anonfield(types.FakeRecvType())
 }
 
@@ -693,12 +694,12 @@ func isifacemethod(f *types.Type) bool {
 }
 
 // turn a parsed function declaration into a type
-func functype(this *Node, in, out []*Node) *types.Type {
-	t := types.New(TFUNC)
+func functype(this *ir.Node, in, out []*ir.Node) *types.Type {
+	t := types.New(types.TFUNC)
 
-	var rcvr []*Node
+	var rcvr []*ir.Node
 	if this != nil {
-		rcvr = []*Node{this}
+		rcvr = []*ir.Node{this}
 	}
 	t.FuncType().Receiver = tofunargs(rcvr, types.FunargRcvr)
 	t.FuncType().Params = tofunargs(in, types.FunargParams)
@@ -710,13 +711,13 @@ func functype(this *Node, in, out []*Node) *types.Type {
 		t.SetBroke(true)
 	}
 
-	t.FuncType().Outnamed = t.NumResults() > 0 && origSym(t.Results().Field(0).Sym) != nil
+	t.FuncType().Outnamed = t.NumResults() > 0 && ir.OrigSym(t.Results().Field(0).Sym) != nil
 
 	return t
 }
 
 func functypefield(this *types.Field, in, out []*types.Field) *types.Type {
-	t := types.New(TFUNC)
+	t := types.New(types.TFUNC)
 
 	var rcvr []*types.Field
 	if this != nil {
@@ -726,36 +727,11 @@ func functypefield(this *types.Field, in, out []*types.Field) *types.Type {
 	t.FuncType().Params = tofunargsfield(in, types.FunargParams)
 	t.FuncType().Results = tofunargsfield(out, types.FunargResults)
 
-	t.FuncType().Outnamed = t.NumResults() > 0 && origSym(t.Results().Field(0).Sym) != nil
+	t.FuncType().Outnamed = t.NumResults() > 0 && ir.OrigSym(t.Results().Field(0).Sym) != nil
 
 	return t
 }
 
-// origSym returns the original symbol written by the user.
-func origSym(s *types.Sym) *types.Sym {
-	if s == nil {
-		return nil
-	}
-
-	if len(s.Name) > 1 && s.Name[0] == '~' {
-		switch s.Name[1] {
-		case 'r': // originally an unnamed result
-			return nil
-		case 'b': // originally the blank identifier _
-			// TODO(mdempsky): Does s.Pkg matter here?
-			return nblank.Sym
-		}
-		return s
-	}
-
-	if strings.HasPrefix(s.Name, ".anon") {
-		// originally an unnamed or _ name (see subr.go: structargs)
-		return nil
-	}
-
-	return s
-}
-
 // methodSym returns the method symbol representing a method name
 // associated with a specific receiver type.
 //
@@ -823,7 +799,7 @@ func methodSymSuffix(recv *types.Type, msym *types.Sym, suffix string) *types.Sy
 // - msym is the method symbol
 // - t is function type (with receiver)
 // Returns a pointer to the existing or added Field; or nil if there's an error.
-func addmethod(n *Node, msym *types.Sym, t *types.Type, local, nointerface bool) *types.Field {
+func addmethod(n *ir.Node, msym *types.Sym, t *types.Type, local, nointerface bool) *types.Field {
 	if msym == nil {
 		base.Fatalf("no method symbol")
 	}
@@ -864,7 +840,7 @@ func addmethod(n *Node, msym *types.Sym, t *types.Type, local, nointerface bool)
 		return nil
 	}
 
-	if local && mt.Sym.Pkg != localpkg {
+	if local && mt.Sym.Pkg != ir.LocalPkg {
 		base.Errorf("cannot define new methods on non-local type %v", mt)
 		return nil
 	}
@@ -896,7 +872,7 @@ func addmethod(n *Node, msym *types.Sym, t *types.Type, local, nointerface bool)
 	}
 
 	f := types.NewField(base.Pos, msym, t)
-	f.Nname = asTypesNode(n.Func.Nname)
+	f.Nname = ir.AsTypesNode(n.Func.Nname)
 	f.SetNointerface(nointerface)
 
 	mt.Methods().Append(f)
@@ -959,21 +935,21 @@ func makefuncsym(s *types.Sym) {
 }
 
 // setNodeNameFunc marks a node as a function.
-func setNodeNameFunc(n *Node) {
-	if n.Op != ONAME || n.Class() != Pxxx {
+func setNodeNameFunc(n *ir.Node) {
+	if n.Op != ir.ONAME || n.Class() != ir.Pxxx {
 		base.Fatalf("expected ONAME/Pxxx node, got %v", n)
 	}
 
-	n.SetClass(PFUNC)
+	n.SetClass(ir.PFUNC)
 	n.Sym.SetFunc(true)
 }
 
-func dclfunc(sym *types.Sym, tfn *Node) *Node {
-	if tfn.Op != OTFUNC {
+func dclfunc(sym *types.Sym, tfn *ir.Node) *ir.Node {
+	if tfn.Op != ir.OTFUNC {
 		base.Fatalf("expected OTFUNC node, got %v", tfn)
 	}
 
-	fn := nod(ODCLFUNC, nil, nil)
+	fn := ir.Nod(ir.ODCLFUNC, nil, nil)
 	fn.Func.Nname = newfuncnamel(base.Pos, sym, fn.Func)
 	fn.Func.Nname.Name.Defn = fn
 	fn.Func.Nname.Name.Param.Ntype = tfn
@@ -987,27 +963,22 @@ type nowritebarrierrecChecker struct {
 	// extraCalls contains extra function calls that may not be
 	// visible during later analysis. It maps from the ODCLFUNC of
 	// the caller to a list of callees.
-	extraCalls map[*Node][]nowritebarrierrecCall
+	extraCalls map[*ir.Node][]nowritebarrierrecCall
 
 	// curfn is the current function during AST walks.
-	curfn *Node
+	curfn *ir.Node
 }
 
 type nowritebarrierrecCall struct {
-	target *Node    // ODCLFUNC of caller or callee
+	target *ir.Node // ODCLFUNC of caller or callee
 	lineno src.XPos // line of call
 }
 
-type nowritebarrierrecCallSym struct {
-	target *obj.LSym // LSym of callee
-	lineno src.XPos  // line of call
-}
-
 // newNowritebarrierrecChecker creates a nowritebarrierrecChecker. It
 // must be called before transformclosure and walk.
 func newNowritebarrierrecChecker() *nowritebarrierrecChecker {
 	c := &nowritebarrierrecChecker{
-		extraCalls: make(map[*Node][]nowritebarrierrecCall),
+		extraCalls: make(map[*ir.Node][]nowritebarrierrecCall),
 	}
 
 	// Find all systemstack calls and record their targets. In
@@ -1016,39 +987,39 @@ func newNowritebarrierrecChecker() *nowritebarrierrecChecker {
 	// directly. This has to happen before transformclosure since
 	// it's a lot harder to work out the argument after.
 	for _, n := range xtop {
-		if n.Op != ODCLFUNC {
+		if n.Op != ir.ODCLFUNC {
 			continue
 		}
 		c.curfn = n
-		inspect(n, c.findExtraCalls)
+		ir.Inspect(n, c.findExtraCalls)
 	}
 	c.curfn = nil
 	return c
 }
 
-func (c *nowritebarrierrecChecker) findExtraCalls(n *Node) bool {
-	if n.Op != OCALLFUNC {
+func (c *nowritebarrierrecChecker) findExtraCalls(n *ir.Node) bool {
+	if n.Op != ir.OCALLFUNC {
 		return true
 	}
 	fn := n.Left
-	if fn == nil || fn.Op != ONAME || fn.Class() != PFUNC || fn.Name.Defn == nil {
+	if fn == nil || fn.Op != ir.ONAME || fn.Class() != ir.PFUNC || fn.Name.Defn == nil {
 		return true
 	}
 	if !isRuntimePkg(fn.Sym.Pkg) || fn.Sym.Name != "systemstack" {
 		return true
 	}
 
-	var callee *Node
+	var callee *ir.Node
 	arg := n.List.First()
 	switch arg.Op {
-	case ONAME:
+	case ir.ONAME:
 		callee = arg.Name.Defn
-	case OCLOSURE:
+	case ir.OCLOSURE:
 		callee = arg.Func.Decl
 	default:
 		base.Fatalf("expected ONAME or OCLOSURE node, got %+v", arg)
 	}
-	if callee.Op != ODCLFUNC {
+	if callee.Op != ir.ODCLFUNC {
 		base.Fatalf("expected ODCLFUNC node, got %+v", callee)
 	}
 	c.extraCalls[c.curfn] = append(c.extraCalls[c.curfn], nowritebarrierrecCall{callee, n.Pos})
@@ -1063,17 +1034,17 @@ func (c *nowritebarrierrecChecker) findExtraCalls(n *Node) bool {
 // because that's all we know after we start SSA.
 //
 // This can be called concurrently for different from Nodes.
-func (c *nowritebarrierrecChecker) recordCall(from *Node, to *obj.LSym, pos src.XPos) {
-	if from.Op != ODCLFUNC {
+func (c *nowritebarrierrecChecker) recordCall(from *ir.Node, to *obj.LSym, pos src.XPos) {
+	if from.Op != ir.ODCLFUNC {
 		base.Fatalf("expected ODCLFUNC, got %v", from)
 	}
 	// We record this information on the *Func so this is
 	// concurrent-safe.
 	fn := from.Func
-	if fn.nwbrCalls == nil {
-		fn.nwbrCalls = new([]nowritebarrierrecCallSym)
+	if fn.NWBRCalls == nil {
+		fn.NWBRCalls = new([]ir.SymAndPos)
 	}
-	*fn.nwbrCalls = append(*fn.nwbrCalls, nowritebarrierrecCallSym{to, pos})
+	*fn.NWBRCalls = append(*fn.NWBRCalls, ir.SymAndPos{Sym: to, Pos: pos})
 }
 
 func (c *nowritebarrierrecChecker) check() {
@@ -1081,39 +1052,39 @@ func (c *nowritebarrierrecChecker) check() {
 	// capture all calls created by lowering, but this means we
 	// only get to see the obj.LSyms of calls. symToFunc lets us
 	// get back to the ODCLFUNCs.
-	symToFunc := make(map[*obj.LSym]*Node)
+	symToFunc := make(map[*obj.LSym]*ir.Node)
 	// funcs records the back-edges of the BFS call graph walk. It
 	// maps from the ODCLFUNC of each function that must not have
 	// write barriers to the call that inhibits them. Functions
 	// that are directly marked go:nowritebarrierrec are in this
 	// map with a zero-valued nowritebarrierrecCall. This also
 	// acts as the set of marks for the BFS of the call graph.
-	funcs := make(map[*Node]nowritebarrierrecCall)
+	funcs := make(map[*ir.Node]nowritebarrierrecCall)
 	// q is the queue of ODCLFUNC Nodes to visit in BFS order.
-	var q nodeQueue
+	var q ir.NodeQueue
 
 	for _, n := range xtop {
-		if n.Op != ODCLFUNC {
+		if n.Op != ir.ODCLFUNC {
 			continue
 		}
 
-		symToFunc[n.Func.lsym] = n
+		symToFunc[n.Func.LSym] = n
 
 		// Make nowritebarrierrec functions BFS roots.
-		if n.Func.Pragma&Nowritebarrierrec != 0 {
+		if n.Func.Pragma&ir.Nowritebarrierrec != 0 {
 			funcs[n] = nowritebarrierrecCall{}
-			q.pushRight(n)
+			q.PushRight(n)
 		}
 		// Check go:nowritebarrier functions.
-		if n.Func.Pragma&Nowritebarrier != 0 && n.Func.WBPos.IsKnown() {
+		if n.Func.Pragma&ir.Nowritebarrier != 0 && n.Func.WBPos.IsKnown() {
 			base.ErrorfAt(n.Func.WBPos, "write barrier prohibited")
 		}
 	}
 
 	// Perform a BFS of the call graph from all
 	// go:nowritebarrierrec functions.
-	enqueue := func(src, target *Node, pos src.XPos) {
-		if target.Func.Pragma&Yeswritebarrierrec != 0 {
+	enqueue := func(src, target *ir.Node, pos src.XPos) {
+		if target.Func.Pragma&ir.Yeswritebarrierrec != 0 {
 			// Don't flow into this function.
 			return
 		}
@@ -1124,10 +1095,10 @@ func (c *nowritebarrierrecChecker) check() {
 
 		// Record the path.
 		funcs[target] = nowritebarrierrecCall{target: src, lineno: pos}
-		q.pushRight(target)
+		q.PushRight(target)
 	}
-	for !q.empty() {
-		fn := q.popLeft()
+	for !q.Empty() {
+		fn := q.PopLeft()
 
 		// Check fn.
 		if fn.Func.WBPos.IsKnown() {
@@ -1145,13 +1116,13 @@ func (c *nowritebarrierrecChecker) check() {
 		for _, callee := range c.extraCalls[fn] {
 			enqueue(fn, callee.target, callee.lineno)
 		}
-		if fn.Func.nwbrCalls == nil {
+		if fn.Func.NWBRCalls == nil {
 			continue
 		}
-		for _, callee := range *fn.Func.nwbrCalls {
-			target := symToFunc[callee.target]
+		for _, callee := range *fn.Func.NWBRCalls {
+			target := symToFunc[callee.Sym]
 			if target != nil {
-				enqueue(fn, target, callee.lineno)
+				enqueue(fn, target, callee.Pos)
 			}
 		}
 	}
diff --git a/src/cmd/compile/internal/gc/embed.go b/src/cmd/compile/internal/gc/embed.go
index f6c1b7cdcc..636aa4a70e 100644
--- a/src/cmd/compile/internal/gc/embed.go
+++ b/src/cmd/compile/internal/gc/embed.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/syntax"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -16,7 +17,7 @@ import (
 	"strings"
 )
 
-var embedlist []*Node
+var embedlist []*ir.Node
 
 const (
 	embedUnknown = iota
@@ -27,7 +28,7 @@ const (
 
 var numLocalEmbed int
 
-func varEmbed(p *noder, names []*Node, typ *Node, exprs []*Node, embeds []PragmaEmbed) (newExprs []*Node) {
+func varEmbed(p *noder, names []*ir.Node, typ *ir.Node, exprs []*ir.Node, embeds []PragmaEmbed) (newExprs []*ir.Node) {
 	haveEmbed := false
 	for _, decl := range p.file.DeclList {
 		imp, ok := decl.(*syntax.ImportDecl)
@@ -110,14 +111,14 @@ func varEmbed(p *noder, names []*Node, typ *Node, exprs []*Node, embeds []Pragma
 	}
 
 	v := names[0]
-	if dclcontext != PEXTERN {
+	if dclcontext != ir.PEXTERN {
 		numLocalEmbed++
-		v = newnamel(v.Pos, lookupN("embed.", numLocalEmbed))
-		v.Sym.Def = asTypesNode(v)
+		v = ir.NewNameAt(v.Pos, lookupN("embed.", numLocalEmbed))
+		v.Sym.Def = ir.AsTypesNode(v)
 		v.Name.Param.Ntype = typ
-		v.SetClass(PEXTERN)
+		v.SetClass(ir.PEXTERN)
 		externdcl = append(externdcl, v)
-		exprs = []*Node{v}
+		exprs = []*ir.Node{v}
 	}
 
 	v.Name.Param.SetEmbedFiles(list)
@@ -129,18 +130,18 @@ func varEmbed(p *noder, names []*Node, typ *Node, exprs []*Node, embeds []Pragma
 // The match is approximate because we haven't done scope resolution yet and
 // can't tell whether "string" and "byte" really mean "string" and "byte".
 // The result must be confirmed later, after type checking, using embedKind.
-func embedKindApprox(typ *Node) int {
-	if typ.Sym != nil && typ.Sym.Name == "FS" && (typ.Sym.Pkg.Path == "embed" || (typ.Sym.Pkg == localpkg && base.Ctxt.Pkgpath == "embed")) {
+func embedKindApprox(typ *ir.Node) int {
+	if typ.Sym != nil && typ.Sym.Name == "FS" && (typ.Sym.Pkg.Path == "embed" || (typ.Sym.Pkg == ir.LocalPkg && base.Ctxt.Pkgpath == "embed")) {
 		return embedFiles
 	}
 	// These are not guaranteed to match only string and []byte -
 	// maybe the local package has redefined one of those words.
 	// But it's the best we can do now during the noder.
 	// The stricter check happens later, in initEmbed calling embedKind.
-	if typ.Sym != nil && typ.Sym.Name == "string" && typ.Sym.Pkg == localpkg {
+	if typ.Sym != nil && typ.Sym.Name == "string" && typ.Sym.Pkg == ir.LocalPkg {
 		return embedString
 	}
-	if typ.Op == OTARRAY && typ.Left == nil && typ.Right.Sym != nil && typ.Right.Sym.Name == "byte" && typ.Right.Sym.Pkg == localpkg {
+	if typ.Op == ir.OTARRAY && typ.Left == nil && typ.Right.Sym != nil && typ.Right.Sym.Name == "byte" && typ.Right.Sym.Pkg == ir.LocalPkg {
 		return embedBytes
 	}
 	return embedUnknown
@@ -148,10 +149,10 @@ func embedKindApprox(typ *Node) int {
 
 // embedKind determines the kind of embedding variable.
 func embedKind(typ *types.Type) int {
-	if typ.Sym != nil && typ.Sym.Name == "FS" && (typ.Sym.Pkg.Path == "embed" || (typ.Sym.Pkg == localpkg && base.Ctxt.Pkgpath == "embed")) {
+	if typ.Sym != nil && typ.Sym.Name == "FS" && (typ.Sym.Pkg.Path == "embed" || (typ.Sym.Pkg == ir.LocalPkg && base.Ctxt.Pkgpath == "embed")) {
 		return embedFiles
 	}
-	if typ == types.Types[TSTRING] {
+	if typ == types.Types[types.TSTRING] {
 		return embedString
 	}
 	if typ.Sym == nil && typ.IsSlice() && typ.Elem() == types.Bytetype {
@@ -191,7 +192,7 @@ func dumpembeds() {
 
 // initEmbed emits the init data for a //go:embed variable,
 // which is either a string, a []byte, or an embed.FS.
-func initEmbed(v *Node) {
+func initEmbed(v *ir.Node) {
 	files := v.Name.Param.EmbedFiles()
 	switch kind := embedKind(v.Type); kind {
 	case embedUnknown:
diff --git a/src/cmd/compile/internal/gc/esc.go b/src/cmd/compile/internal/gc/esc.go
deleted file mode 100644
index 5cf8c4a1c6..0000000000
--- a/src/cmd/compile/internal/gc/esc.go
+++ /dev/null
@@ -1,474 +0,0 @@
-// Copyright 2011 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 gc
-
-import (
-	"cmd/compile/internal/base"
-	"cmd/compile/internal/types"
-	"fmt"
-)
-
-func escapes(all []*Node) {
-	visitBottomUp(all, escapeFuncs)
-}
-
-const (
-	EscFuncUnknown = 0 + iota
-	EscFuncPlanned
-	EscFuncStarted
-	EscFuncTagged
-)
-
-func min8(a, b int8) int8 {
-	if a < b {
-		return a
-	}
-	return b
-}
-
-func max8(a, b int8) int8 {
-	if a > b {
-		return a
-	}
-	return b
-}
-
-const (
-	EscUnknown = iota
-	EscNone    // Does not escape to heap, result, or parameters.
-	EscHeap    // Reachable from the heap
-	EscNever   // By construction will not escape.
-)
-
-// funcSym returns fn.Func.Nname.Sym if no nils are encountered along the way.
-func funcSym(fn *Node) *types.Sym {
-	if fn == nil || fn.Func.Nname == nil {
-		return nil
-	}
-	return fn.Func.Nname.Sym
-}
-
-// Mark labels that have no backjumps to them as not increasing e.loopdepth.
-// Walk hasn't generated (goto|label).Left.Sym.Label yet, so we'll cheat
-// and set it to one of the following two. Then in esc we'll clear it again.
-var (
-	looping    = nod(OXXX, nil, nil)
-	nonlooping = nod(OXXX, nil, nil)
-)
-
-func isSliceSelfAssign(dst, src *Node) bool {
-	// Detect the following special case.
-	//
-	//	func (b *Buffer) Foo() {
-	//		n, m := ...
-	//		b.buf = b.buf[n:m]
-	//	}
-	//
-	// This assignment is a no-op for escape analysis,
-	// it does not store any new pointers into b that were not already there.
-	// However, without this special case b will escape, because we assign to OIND/ODOTPTR.
-	// Here we assume that the statement will not contain calls,
-	// that is, that order will move any calls to init.
-	// Otherwise base ONAME value could change between the moments
-	// when we evaluate it for dst and for src.
-
-	// dst is ONAME dereference.
-	if dst.Op != ODEREF && dst.Op != ODOTPTR || dst.Left.Op != ONAME {
-		return false
-	}
-	// src is a slice operation.
-	switch src.Op {
-	case OSLICE, OSLICE3, OSLICESTR:
-		// OK.
-	case OSLICEARR, OSLICE3ARR:
-		// Since arrays are embedded into containing object,
-		// slice of non-pointer array will introduce a new pointer into b that was not already there
-		// (pointer to b itself). After such assignment, if b contents escape,
-		// b escapes as well. If we ignore such OSLICEARR, we will conclude
-		// that b does not escape when b contents do.
-		//
-		// Pointer to an array is OK since it's not stored inside b directly.
-		// For slicing an array (not pointer to array), there is an implicit OADDR.
-		// We check that to determine non-pointer array slicing.
-		if src.Left.Op == OADDR {
-			return false
-		}
-	default:
-		return false
-	}
-	// slice is applied to ONAME dereference.
-	if src.Left.Op != ODEREF && src.Left.Op != ODOTPTR || src.Left.Left.Op != ONAME {
-		return false
-	}
-	// dst and src reference the same base ONAME.
-	return dst.Left == src.Left.Left
-}
-
-// isSelfAssign reports whether assignment from src to dst can
-// be ignored by the escape analysis as it's effectively a self-assignment.
-func isSelfAssign(dst, src *Node) bool {
-	if isSliceSelfAssign(dst, src) {
-		return true
-	}
-
-	// Detect trivial assignments that assign back to the same object.
-	//
-	// It covers these cases:
-	//	val.x = val.y
-	//	val.x[i] = val.y[j]
-	//	val.x1.x2 = val.x1.y2
-	//	... etc
-	//
-	// These assignments do not change assigned object lifetime.
-
-	if dst == nil || src == nil || dst.Op != src.Op {
-		return false
-	}
-
-	switch dst.Op {
-	case ODOT, ODOTPTR:
-		// Safe trailing accessors that are permitted to differ.
-	case OINDEX:
-		if mayAffectMemory(dst.Right) || mayAffectMemory(src.Right) {
-			return false
-		}
-	default:
-		return false
-	}
-
-	// The expression prefix must be both "safe" and identical.
-	return samesafeexpr(dst.Left, src.Left)
-}
-
-// mayAffectMemory reports whether evaluation of n may affect the program's
-// memory state. If the expression can't affect memory state, then it can be
-// safely ignored by the escape analysis.
-func mayAffectMemory(n *Node) bool {
-	// We may want to use a list of "memory safe" ops instead of generally
-	// "side-effect free", which would include all calls and other ops that can
-	// allocate or change global state. For now, it's safer to start with the latter.
-	//
-	// We're ignoring things like division by zero, index out of range,
-	// and nil pointer dereference here.
-	switch n.Op {
-	case ONAME, OCLOSUREVAR, OLITERAL, ONIL:
-		return false
-
-	// Left+Right group.
-	case OINDEX, OADD, OSUB, OOR, OXOR, OMUL, OLSH, ORSH, OAND, OANDNOT, ODIV, OMOD:
-		return mayAffectMemory(n.Left) || mayAffectMemory(n.Right)
-
-	// Left group.
-	case ODOT, ODOTPTR, ODEREF, OCONVNOP, OCONV, OLEN, OCAP,
-		ONOT, OBITNOT, OPLUS, ONEG, OALIGNOF, OOFFSETOF, OSIZEOF:
-		return mayAffectMemory(n.Left)
-
-	default:
-		return true
-	}
-}
-
-// heapAllocReason returns the reason the given Node must be heap
-// allocated, or the empty string if it doesn't.
-func heapAllocReason(n *Node) string {
-	if n.Type == nil {
-		return ""
-	}
-
-	// Parameters are always passed via the stack.
-	if n.Op == ONAME && (n.Class() == PPARAM || n.Class() == PPARAMOUT) {
-		return ""
-	}
-
-	if n.Type.Width > maxStackVarSize {
-		return "too large for stack"
-	}
-
-	if (n.Op == ONEW || n.Op == OPTRLIT) && n.Type.Elem().Width >= maxImplicitStackVarSize {
-		return "too large for stack"
-	}
-
-	if n.Op == OCLOSURE && closureType(n).Size() >= maxImplicitStackVarSize {
-		return "too large for stack"
-	}
-	if n.Op == OCALLPART && partialCallType(n).Size() >= maxImplicitStackVarSize {
-		return "too large for stack"
-	}
-
-	if n.Op == OMAKESLICE {
-		r := n.Right
-		if r == nil {
-			r = n.Left
-		}
-		if !smallintconst(r) {
-			return "non-constant size"
-		}
-		if t := n.Type; t.Elem().Width != 0 && r.Int64Val() >= maxImplicitStackVarSize/t.Elem().Width {
-			return "too large for stack"
-		}
-	}
-
-	return ""
-}
-
-// addrescapes tags node n as having had its address taken
-// by "increasing" the "value" of n.Esc to EscHeap.
-// Storage is allocated as necessary to allow the address
-// to be taken.
-func addrescapes(n *Node) {
-	switch n.Op {
-	default:
-		// Unexpected Op, probably due to a previous type error. Ignore.
-
-	case ODEREF, ODOTPTR:
-		// Nothing to do.
-
-	case ONAME:
-		if n == nodfp {
-			break
-		}
-
-		// if this is a tmpname (PAUTO), it was tagged by tmpname as not escaping.
-		// on PPARAM it means something different.
-		if n.Class() == PAUTO && n.Esc == EscNever {
-			break
-		}
-
-		// If a closure reference escapes, mark the outer variable as escaping.
-		if n.Name.IsClosureVar() {
-			addrescapes(n.Name.Defn)
-			break
-		}
-
-		if n.Class() != PPARAM && n.Class() != PPARAMOUT && n.Class() != PAUTO {
-			break
-		}
-
-		// This is a plain parameter or local variable that needs to move to the heap,
-		// but possibly for the function outside the one we're compiling.
-		// That is, if we have:
-		//
-		//	func f(x int) {
-		//		func() {
-		//			global = &x
-		//		}
-		//	}
-		//
-		// then we're analyzing the inner closure but we need to move x to the
-		// heap in f, not in the inner closure. Flip over to f before calling moveToHeap.
-		oldfn := Curfn
-		Curfn = n.Name.Curfn
-		if Curfn.Op == OCLOSURE {
-			Curfn = Curfn.Func.Decl
-			panic("can't happen")
-		}
-		ln := base.Pos
-		base.Pos = Curfn.Pos
-		moveToHeap(n)
-		Curfn = oldfn
-		base.Pos = ln
-
-	// ODOTPTR has already been introduced,
-	// so these are the non-pointer ODOT and OINDEX.
-	// In &x[0], if x is a slice, then x does not
-	// escape--the pointer inside x does, but that
-	// is always a heap pointer anyway.
-	case ODOT, OINDEX, OPAREN, OCONVNOP:
-		if !n.Left.Type.IsSlice() {
-			addrescapes(n.Left)
-		}
-	}
-}
-
-// moveToHeap records the parameter or local variable n as moved to the heap.
-func moveToHeap(n *Node) {
-	if base.Flag.LowerR != 0 {
-		Dump("MOVE", n)
-	}
-	if base.Flag.CompilingRuntime {
-		base.Errorf("%v escapes to heap, not allowed in runtime", n)
-	}
-	if n.Class() == PAUTOHEAP {
-		Dump("n", n)
-		base.Fatalf("double move to heap")
-	}
-
-	// Allocate a local stack variable to hold the pointer to the heap copy.
-	// temp will add it to the function declaration list automatically.
-	heapaddr := temp(types.NewPtr(n.Type))
-	heapaddr.Sym = lookup("&" + n.Sym.Name)
-	heapaddr.Orig.Sym = heapaddr.Sym
-	heapaddr.Pos = n.Pos
-
-	// Unset AutoTemp to persist the &foo variable name through SSA to
-	// liveness analysis.
-	// TODO(mdempsky/drchase): Cleaner solution?
-	heapaddr.Name.SetAutoTemp(false)
-
-	// Parameters have a local stack copy used at function start/end
-	// in addition to the copy in the heap that may live longer than
-	// the function.
-	if n.Class() == PPARAM || n.Class() == PPARAMOUT {
-		if n.Xoffset == BADWIDTH {
-			base.Fatalf("addrescapes before param assignment")
-		}
-
-		// We rewrite n below to be a heap variable (indirection of heapaddr).
-		// Preserve a copy so we can still write code referring to the original,
-		// and substitute that copy into the function declaration list
-		// so that analyses of the local (on-stack) variables use it.
-		stackcopy := newname(n.Sym)
-		stackcopy.Type = n.Type
-		stackcopy.Xoffset = n.Xoffset
-		stackcopy.SetClass(n.Class())
-		stackcopy.Name.Param.Heapaddr = heapaddr
-		if n.Class() == PPARAMOUT {
-			// Make sure the pointer to the heap copy is kept live throughout the function.
-			// The function could panic at any point, and then a defer could recover.
-			// Thus, we need the pointer to the heap copy always available so the
-			// post-deferreturn code can copy the return value back to the stack.
-			// See issue 16095.
-			heapaddr.Name.SetIsOutputParamHeapAddr(true)
-		}
-		n.Name.Param.Stackcopy = stackcopy
-
-		// Substitute the stackcopy into the function variable list so that
-		// liveness and other analyses use the underlying stack slot
-		// and not the now-pseudo-variable n.
-		found := false
-		for i, d := range Curfn.Func.Dcl {
-			if d == n {
-				Curfn.Func.Dcl[i] = stackcopy
-				found = true
-				break
-			}
-			// Parameters are before locals, so can stop early.
-			// This limits the search even in functions with many local variables.
-			if d.Class() == PAUTO {
-				break
-			}
-		}
-		if !found {
-			base.Fatalf("cannot find %v in local variable list", n)
-		}
-		Curfn.Func.Dcl = append(Curfn.Func.Dcl, n)
-	}
-
-	// Modify n in place so that uses of n now mean indirection of the heapaddr.
-	n.SetClass(PAUTOHEAP)
-	n.Xoffset = 0
-	n.Name.Param.Heapaddr = heapaddr
-	n.Esc = EscHeap
-	if base.Flag.LowerM != 0 {
-		base.WarnfAt(n.Pos, "moved to heap: %v", n)
-	}
-}
-
-// This special tag is applied to uintptr variables
-// that we believe may hold unsafe.Pointers for
-// calls into assembly functions.
-const unsafeUintptrTag = "unsafe-uintptr"
-
-// This special tag is applied to uintptr parameters of functions
-// marked go:uintptrescapes.
-const uintptrEscapesTag = "uintptr-escapes"
-
-func (e *Escape) paramTag(fn *Node, narg int, f *types.Field) string {
-	name := func() string {
-		if f.Sym != nil {
-			return f.Sym.Name
-		}
-		return fmt.Sprintf("arg#%d", narg)
-	}
-
-	if fn.Nbody.Len() == 0 {
-		// Assume that uintptr arguments must be held live across the call.
-		// This is most important for syscall.Syscall.
-		// See golang.org/issue/13372.
-		// This really doesn't have much to do with escape analysis per se,
-		// but we are reusing the ability to annotate an individual function
-		// argument and pass those annotations along to importing code.
-		if f.Type.IsUintptr() {
-			if base.Flag.LowerM != 0 {
-				base.WarnfAt(f.Pos, "assuming %v is unsafe uintptr", name())
-			}
-			return unsafeUintptrTag
-		}
-
-		if !f.Type.HasPointers() { // don't bother tagging for scalars
-			return ""
-		}
-
-		var esc EscLeaks
-
-		// External functions are assumed unsafe, unless
-		// //go:noescape is given before the declaration.
-		if fn.Func.Pragma&Noescape != 0 {
-			if base.Flag.LowerM != 0 && f.Sym != nil {
-				base.WarnfAt(f.Pos, "%v does not escape", name())
-			}
-		} else {
-			if base.Flag.LowerM != 0 && f.Sym != nil {
-				base.WarnfAt(f.Pos, "leaking param: %v", name())
-			}
-			esc.AddHeap(0)
-		}
-
-		return esc.Encode()
-	}
-
-	if fn.Func.Pragma&UintptrEscapes != 0 {
-		if f.Type.IsUintptr() {
-			if base.Flag.LowerM != 0 {
-				base.WarnfAt(f.Pos, "marking %v as escaping uintptr", name())
-			}
-			return uintptrEscapesTag
-		}
-		if f.IsDDD() && f.Type.Elem().IsUintptr() {
-			// final argument is ...uintptr.
-			if base.Flag.LowerM != 0 {
-				base.WarnfAt(f.Pos, "marking %v as escaping ...uintptr", name())
-			}
-			return uintptrEscapesTag
-		}
-	}
-
-	if !f.Type.HasPointers() { // don't bother tagging for scalars
-		return ""
-	}
-
-	// Unnamed parameters are unused and therefore do not escape.
-	if f.Sym == nil || f.Sym.IsBlank() {
-		var esc EscLeaks
-		return esc.Encode()
-	}
-
-	n := asNode(f.Nname)
-	loc := e.oldLoc(n)
-	esc := loc.paramEsc
-	esc.Optimize()
-
-	if base.Flag.LowerM != 0 && !loc.escapes {
-		if esc.Empty() {
-			base.WarnfAt(f.Pos, "%v does not escape", name())
-		}
-		if x := esc.Heap(); x >= 0 {
-			if x == 0 {
-				base.WarnfAt(f.Pos, "leaking param: %v", name())
-			} else {
-				// TODO(mdempsky): Mention level=x like below?
-				base.WarnfAt(f.Pos, "leaking param content: %v", name())
-			}
-		}
-		for i := 0; i < numEscResults; i++ {
-			if x := esc.Result(i); x >= 0 {
-				res := fn.Type.Results().Field(i).Sym
-				base.WarnfAt(f.Pos, "leaking param: %v to result %v level=%d", name(), res, x)
-			}
-		}
-	}
-
-	return esc.Encode()
-}
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index aaf768d85a..a0aa516d9a 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
@@ -85,7 +86,7 @@ import (
 type Escape struct {
 	allLocs []*EscLocation
 
-	curfn *Node
+	curfn *ir.Node
 
 	// loopDepth counts the current loop nesting depth within
 	// curfn. It increments within each "for" loop and at each
@@ -100,8 +101,8 @@ type Escape struct {
 // An EscLocation represents an abstract location that stores a Go
 // variable.
 type EscLocation struct {
-	n         *Node     // represented variable or expression, if any
-	curfn     *Node     // enclosing function
+	n         *ir.Node  // represented variable or expression, if any
+	curfn     *ir.Node  // enclosing function
 	edges     []EscEdge // incoming edges
 	loopDepth int       // loopDepth at declaration
 
@@ -142,11 +143,11 @@ type EscEdge struct {
 }
 
 func init() {
-	EscFmt = escFmt
+	ir.EscFmt = escFmt
 }
 
 // escFmt is called from node printing to print information about escape analysis results.
-func escFmt(n *Node, short bool) string {
+func escFmt(n *ir.Node, short bool) string {
 	text := ""
 	switch n.Esc {
 	case EscUnknown:
@@ -178,9 +179,9 @@ func escFmt(n *Node, short bool) string {
 
 // escapeFuncs performs escape analysis on a minimal batch of
 // functions.
-func escapeFuncs(fns []*Node, recursive bool) {
+func escapeFuncs(fns []*ir.Node, recursive bool) {
 	for _, fn := range fns {
-		if fn.Op != ODCLFUNC {
+		if fn.Op != ir.ODCLFUNC {
 			base.Fatalf("unexpected node: %v", fn)
 		}
 	}
@@ -201,13 +202,13 @@ func escapeFuncs(fns []*Node, recursive bool) {
 	e.finish(fns)
 }
 
-func (e *Escape) initFunc(fn *Node) {
-	if fn.Op != ODCLFUNC || fn.Esc != EscFuncUnknown {
+func (e *Escape) initFunc(fn *ir.Node) {
+	if fn.Op != ir.ODCLFUNC || fn.Esc != EscFuncUnknown {
 		base.Fatalf("unexpected node: %v", fn)
 	}
 	fn.Esc = EscFuncPlanned
 	if base.Flag.LowerM > 3 {
-		Dump("escAnalyze", fn)
+		ir.Dump("escAnalyze", fn)
 	}
 
 	e.curfn = fn
@@ -215,26 +216,26 @@ func (e *Escape) initFunc(fn *Node) {
 
 	// Allocate locations for local variables.
 	for _, dcl := range fn.Func.Dcl {
-		if dcl.Op == ONAME {
+		if dcl.Op == ir.ONAME {
 			e.newLoc(dcl, false)
 		}
 	}
 }
 
-func (e *Escape) walkFunc(fn *Node) {
+func (e *Escape) walkFunc(fn *ir.Node) {
 	fn.Esc = EscFuncStarted
 
 	// Identify labels that mark the head of an unstructured loop.
-	inspectList(fn.Nbody, func(n *Node) bool {
+	ir.InspectList(fn.Nbody, func(n *ir.Node) bool {
 		switch n.Op {
-		case OLABEL:
-			n.Sym.Label = asTypesNode(nonlooping)
+		case ir.OLABEL:
+			n.Sym.Label = ir.AsTypesNode(nonlooping)
 
-		case OGOTO:
+		case ir.OGOTO:
 			// If we visited the label before the goto,
 			// then this is a looping label.
-			if n.Sym.Label == asTypesNode(nonlooping) {
-				n.Sym.Label = asTypesNode(looping)
+			if n.Sym.Label == ir.AsTypesNode(nonlooping) {
+				n.Sym.Label = ir.AsTypesNode(looping)
 			}
 		}
 
@@ -273,7 +274,7 @@ func (e *Escape) walkFunc(fn *Node) {
 //    }
 
 // stmt evaluates a single Go statement.
-func (e *Escape) stmt(n *Node) {
+func (e *Escape) stmt(n *ir.Node) {
 	if n == nil {
 		return
 	}
@@ -293,23 +294,23 @@ func (e *Escape) stmt(n *Node) {
 	default:
 		base.Fatalf("unexpected stmt: %v", n)
 
-	case ODCLCONST, ODCLTYPE, OEMPTY, OFALL, OINLMARK:
+	case ir.ODCLCONST, ir.ODCLTYPE, ir.OEMPTY, ir.OFALL, ir.OINLMARK:
 		// nop
 
-	case OBREAK, OCONTINUE, OGOTO:
+	case ir.OBREAK, ir.OCONTINUE, ir.OGOTO:
 		// TODO(mdempsky): Handle dead code?
 
-	case OBLOCK:
+	case ir.OBLOCK:
 		e.stmts(n.List)
 
-	case ODCL:
+	case ir.ODCL:
 		// Record loop depth at declaration.
-		if !n.Left.isBlank() {
+		if !ir.IsBlank(n.Left) {
 			e.dcl(n.Left)
 		}
 
-	case OLABEL:
-		switch asNode(n.Sym.Label) {
+	case ir.OLABEL:
+		switch ir.AsNode(n.Sym.Label) {
 		case nonlooping:
 			if base.Flag.LowerM > 2 {
 				fmt.Printf("%v:%v non-looping label\n", base.FmtPos(base.Pos), n)
@@ -324,19 +325,19 @@ func (e *Escape) stmt(n *Node) {
 		}
 		n.Sym.Label = nil
 
-	case OIF:
+	case ir.OIF:
 		e.discard(n.Left)
 		e.block(n.Nbody)
 		e.block(n.Rlist)
 
-	case OFOR, OFORUNTIL:
+	case ir.OFOR, ir.OFORUNTIL:
 		e.loopDepth++
 		e.discard(n.Left)
 		e.stmt(n.Right)
 		e.block(n.Nbody)
 		e.loopDepth--
 
-	case ORANGE:
+	case ir.ORANGE:
 		// for List = range Right { Nbody }
 		e.loopDepth++
 		ks := e.addrs(n.List)
@@ -354,8 +355,8 @@ func (e *Escape) stmt(n *Node) {
 		}
 		e.expr(e.later(k), n.Right)
 
-	case OSWITCH:
-		typesw := n.Left != nil && n.Left.Op == OTYPESW
+	case ir.OSWITCH:
+		typesw := n.Left != nil && n.Left.Op == ir.OTYPESW
 
 		var ks []EscHole
 		for _, cas := range n.List.Slice() { // cases
@@ -377,68 +378,68 @@ func (e *Escape) stmt(n *Node) {
 			e.discard(n.Left)
 		}
 
-	case OSELECT:
+	case ir.OSELECT:
 		for _, cas := range n.List.Slice() {
 			e.stmt(cas.Left)
 			e.block(cas.Nbody)
 		}
-	case OSELRECV:
+	case ir.OSELRECV:
 		e.assign(n.Left, n.Right, "selrecv", n)
-	case OSELRECV2:
+	case ir.OSELRECV2:
 		e.assign(n.Left, n.Right, "selrecv", n)
 		e.assign(n.List.First(), nil, "selrecv", n)
-	case ORECV:
+	case ir.ORECV:
 		// TODO(mdempsky): Consider e.discard(n.Left).
 		e.exprSkipInit(e.discardHole(), n) // already visited n.Ninit
-	case OSEND:
+	case ir.OSEND:
 		e.discard(n.Left)
 		e.assignHeap(n.Right, "send", n)
 
-	case OAS, OASOP:
+	case ir.OAS, ir.OASOP:
 		e.assign(n.Left, n.Right, "assign", n)
 
-	case OAS2:
+	case ir.OAS2:
 		for i, nl := range n.List.Slice() {
 			e.assign(nl, n.Rlist.Index(i), "assign-pair", n)
 		}
 
-	case OAS2DOTTYPE: // v, ok = x.(type)
+	case ir.OAS2DOTTYPE: // v, ok = x.(type)
 		e.assign(n.List.First(), n.Right, "assign-pair-dot-type", n)
 		e.assign(n.List.Second(), nil, "assign-pair-dot-type", n)
-	case OAS2MAPR: // v, ok = m[k]
+	case ir.OAS2MAPR: // v, ok = m[k]
 		e.assign(n.List.First(), n.Right, "assign-pair-mapr", n)
 		e.assign(n.List.Second(), nil, "assign-pair-mapr", n)
-	case OAS2RECV: // v, ok = <-ch
+	case ir.OAS2RECV: // v, ok = <-ch
 		e.assign(n.List.First(), n.Right, "assign-pair-receive", n)
 		e.assign(n.List.Second(), nil, "assign-pair-receive", n)
 
-	case OAS2FUNC:
+	case ir.OAS2FUNC:
 		e.stmts(n.Right.Ninit)
 		e.call(e.addrs(n.List), n.Right, nil)
-	case ORETURN:
+	case ir.ORETURN:
 		results := e.curfn.Type.Results().FieldSlice()
 		for i, v := range n.List.Slice() {
-			e.assign(asNode(results[i].Nname), v, "return", n)
+			e.assign(ir.AsNode(results[i].Nname), v, "return", n)
 		}
-	case OCALLFUNC, OCALLMETH, OCALLINTER, OCLOSE, OCOPY, ODELETE, OPANIC, OPRINT, OPRINTN, ORECOVER:
+	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER, ir.OCLOSE, ir.OCOPY, ir.ODELETE, ir.OPANIC, ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
 		e.call(nil, n, nil)
-	case OGO, ODEFER:
+	case ir.OGO, ir.ODEFER:
 		e.stmts(n.Left.Ninit)
 		e.call(nil, n.Left, n)
 
-	case ORETJMP:
+	case ir.ORETJMP:
 		// TODO(mdempsky): What do? esc.go just ignores it.
 	}
 }
 
-func (e *Escape) stmts(l Nodes) {
+func (e *Escape) stmts(l ir.Nodes) {
 	for _, n := range l.Slice() {
 		e.stmt(n)
 	}
 }
 
 // block is like stmts, but preserves loopDepth.
-func (e *Escape) block(l Nodes) {
+func (e *Escape) block(l ir.Nodes) {
 	old := e.loopDepth
 	e.stmts(l)
 	e.loopDepth = old
@@ -446,7 +447,7 @@ func (e *Escape) block(l Nodes) {
 
 // expr models evaluating an expression n and flowing the result into
 // hole k.
-func (e *Escape) expr(k EscHole, n *Node) {
+func (e *Escape) expr(k EscHole, n *ir.Node) {
 	if n == nil {
 		return
 	}
@@ -454,7 +455,7 @@ func (e *Escape) expr(k EscHole, n *Node) {
 	e.exprSkipInit(k, n)
 }
 
-func (e *Escape) exprSkipInit(k EscHole, n *Node) {
+func (e *Escape) exprSkipInit(k EscHole, n *ir.Node) {
 	if n == nil {
 		return
 	}
@@ -467,7 +468,7 @@ func (e *Escape) exprSkipInit(k EscHole, n *Node) {
 	uintptrEscapesHack := k.uintptrEscapesHack
 	k.uintptrEscapesHack = false
 
-	if uintptrEscapesHack && n.Op == OCONVNOP && n.Left.Type.IsUnsafePtr() {
+	if uintptrEscapesHack && n.Op == ir.OCONVNOP && n.Left.Type.IsUnsafePtr() {
 		// nop
 	} else if k.derefs >= 0 && !n.Type.HasPointers() {
 		k = e.discardHole()
@@ -477,32 +478,32 @@ func (e *Escape) exprSkipInit(k EscHole, n *Node) {
 	default:
 		base.Fatalf("unexpected expr: %v", n)
 
-	case OLITERAL, ONIL, OGETG, OCLOSUREVAR, OTYPE, OMETHEXPR:
+	case ir.OLITERAL, ir.ONIL, ir.OGETG, ir.OCLOSUREVAR, ir.OTYPE, ir.OMETHEXPR:
 		// nop
 
-	case ONAME:
-		if n.Class() == PFUNC || n.Class() == PEXTERN {
+	case ir.ONAME:
+		if n.Class() == ir.PFUNC || n.Class() == ir.PEXTERN {
 			return
 		}
 		e.flow(k, e.oldLoc(n))
 
-	case OPLUS, ONEG, OBITNOT, ONOT:
+	case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT:
 		e.discard(n.Left)
-	case OADD, OSUB, OOR, OXOR, OMUL, ODIV, OMOD, OLSH, ORSH, OAND, OANDNOT, OEQ, ONE, OLT, OLE, OGT, OGE, OANDAND, OOROR:
+	case ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.ODIV, ir.OMOD, ir.OLSH, ir.ORSH, ir.OAND, ir.OANDNOT, ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE, ir.OANDAND, ir.OOROR:
 		e.discard(n.Left)
 		e.discard(n.Right)
 
-	case OADDR:
+	case ir.OADDR:
 		e.expr(k.addr(n, "address-of"), n.Left) // "address-of"
-	case ODEREF:
+	case ir.ODEREF:
 		e.expr(k.deref(n, "indirection"), n.Left) // "indirection"
-	case ODOT, ODOTMETH, ODOTINTER:
+	case ir.ODOT, ir.ODOTMETH, ir.ODOTINTER:
 		e.expr(k.note(n, "dot"), n.Left)
-	case ODOTPTR:
+	case ir.ODOTPTR:
 		e.expr(k.deref(n, "dot of pointer"), n.Left) // "dot of pointer"
-	case ODOTTYPE, ODOTTYPE2:
+	case ir.ODOTTYPE, ir.ODOTTYPE2:
 		e.expr(k.dotType(n.Type, n, "dot"), n.Left)
-	case OINDEX:
+	case ir.OINDEX:
 		if n.Left.Type.IsArray() {
 			e.expr(k.note(n, "fixed-array-index-of"), n.Left)
 		} else {
@@ -510,17 +511,17 @@ func (e *Escape) exprSkipInit(k EscHole, n *Node) {
 			e.expr(k.deref(n, "dot of pointer"), n.Left)
 		}
 		e.discard(n.Right)
-	case OINDEXMAP:
+	case ir.OINDEXMAP:
 		e.discard(n.Left)
 		e.discard(n.Right)
-	case OSLICE, OSLICEARR, OSLICE3, OSLICE3ARR, OSLICESTR:
+	case ir.OSLICE, ir.OSLICEARR, ir.OSLICE3, ir.OSLICE3ARR, ir.OSLICESTR:
 		e.expr(k.note(n, "slice"), n.Left)
 		low, high, max := n.SliceBounds()
 		e.discard(low)
 		e.discard(high)
 		e.discard(max)
 
-	case OCONV, OCONVNOP:
+	case ir.OCONV, ir.OCONVNOP:
 		if checkPtr(e.curfn, 2) && n.Type.IsUnsafePtr() && n.Left.Type.IsPtr() {
 			// When -d=checkptr=2 is enabled, treat
 			// conversions to unsafe.Pointer as an
@@ -534,35 +535,35 @@ func (e *Escape) exprSkipInit(k EscHole, n *Node) {
 		} else {
 			e.expr(k, n.Left)
 		}
-	case OCONVIFACE:
+	case ir.OCONVIFACE:
 		if !n.Left.Type.IsInterface() && !isdirectiface(n.Left.Type) {
 			k = e.spill(k, n)
 		}
 		e.expr(k.note(n, "interface-converted"), n.Left)
 
-	case ORECV:
+	case ir.ORECV:
 		e.discard(n.Left)
 
-	case OCALLMETH, OCALLFUNC, OCALLINTER, OLEN, OCAP, OCOMPLEX, OREAL, OIMAG, OAPPEND, OCOPY:
+	case ir.OCALLMETH, ir.OCALLFUNC, ir.OCALLINTER, ir.OLEN, ir.OCAP, ir.OCOMPLEX, ir.OREAL, ir.OIMAG, ir.OAPPEND, ir.OCOPY:
 		e.call([]EscHole{k}, n, nil)
 
-	case ONEW:
+	case ir.ONEW:
 		e.spill(k, n)
 
-	case OMAKESLICE:
+	case ir.OMAKESLICE:
 		e.spill(k, n)
 		e.discard(n.Left)
 		e.discard(n.Right)
-	case OMAKECHAN:
+	case ir.OMAKECHAN:
 		e.discard(n.Left)
-	case OMAKEMAP:
+	case ir.OMAKEMAP:
 		e.spill(k, n)
 		e.discard(n.Left)
 
-	case ORECOVER:
+	case ir.ORECOVER:
 		// nop
 
-	case OCALLPART:
+	case ir.OCALLPART:
 		// Flow the receiver argument to both the closure and
 		// to the receiver parameter.
 
@@ -580,38 +581,38 @@ func (e *Escape) exprSkipInit(k EscHole, n *Node) {
 		for i := m.Type.NumResults(); i > 0; i-- {
 			ks = append(ks, e.heapHole())
 		}
-		paramK := e.tagHole(ks, asNode(m.Nname), m.Type.Recv())
+		paramK := e.tagHole(ks, ir.AsNode(m.Nname), m.Type.Recv())
 
 		e.expr(e.teeHole(paramK, closureK), n.Left)
 
-	case OPTRLIT:
+	case ir.OPTRLIT:
 		e.expr(e.spill(k, n), n.Left)
 
-	case OARRAYLIT:
+	case ir.OARRAYLIT:
 		for _, elt := range n.List.Slice() {
-			if elt.Op == OKEY {
+			if elt.Op == ir.OKEY {
 				elt = elt.Right
 			}
 			e.expr(k.note(n, "array literal element"), elt)
 		}
 
-	case OSLICELIT:
+	case ir.OSLICELIT:
 		k = e.spill(k, n)
 		k.uintptrEscapesHack = uintptrEscapesHack // for ...uintptr parameters
 
 		for _, elt := range n.List.Slice() {
-			if elt.Op == OKEY {
+			if elt.Op == ir.OKEY {
 				elt = elt.Right
 			}
 			e.expr(k.note(n, "slice-literal-element"), elt)
 		}
 
-	case OSTRUCTLIT:
+	case ir.OSTRUCTLIT:
 		for _, elt := range n.List.Slice() {
 			e.expr(k.note(n, "struct literal element"), elt.Left)
 		}
 
-	case OMAPLIT:
+	case ir.OMAPLIT:
 		e.spill(k, n)
 
 		// Map keys and values are always stored in the heap.
@@ -620,12 +621,12 @@ func (e *Escape) exprSkipInit(k EscHole, n *Node) {
 			e.assignHeap(elt.Right, "map literal value", n)
 		}
 
-	case OCLOSURE:
+	case ir.OCLOSURE:
 		k = e.spill(k, n)
 
 		// Link addresses of captured variables to closure.
 		for _, v := range n.Func.ClosureVars.Slice() {
-			if v.Op == OXXX { // unnamed out argument; see dcl.go:/^funcargs
+			if v.Op == ir.OXXX { // unnamed out argument; see dcl.go:/^funcargs
 				continue
 			}
 
@@ -637,11 +638,11 @@ func (e *Escape) exprSkipInit(k EscHole, n *Node) {
 			e.expr(k.note(n, "captured by a closure"), v.Name.Defn)
 		}
 
-	case ORUNES2STR, OBYTES2STR, OSTR2RUNES, OSTR2BYTES, ORUNESTR:
+	case ir.ORUNES2STR, ir.OBYTES2STR, ir.OSTR2RUNES, ir.OSTR2BYTES, ir.ORUNESTR:
 		e.spill(k, n)
 		e.discard(n.Left)
 
-	case OADDSTR:
+	case ir.OADDSTR:
 		e.spill(k, n)
 
 		// Arguments of OADDSTR never escape;
@@ -652,32 +653,32 @@ func (e *Escape) exprSkipInit(k EscHole, n *Node) {
 
 // unsafeValue evaluates a uintptr-typed arithmetic expression looking
 // for conversions from an unsafe.Pointer.
-func (e *Escape) unsafeValue(k EscHole, n *Node) {
-	if n.Type.Etype != TUINTPTR {
+func (e *Escape) unsafeValue(k EscHole, n *ir.Node) {
+	if n.Type.Etype != types.TUINTPTR {
 		base.Fatalf("unexpected type %v for %v", n.Type, n)
 	}
 
 	e.stmts(n.Ninit)
 
 	switch n.Op {
-	case OCONV, OCONVNOP:
+	case ir.OCONV, ir.OCONVNOP:
 		if n.Left.Type.IsUnsafePtr() {
 			e.expr(k, n.Left)
 		} else {
 			e.discard(n.Left)
 		}
-	case ODOTPTR:
+	case ir.ODOTPTR:
 		if isReflectHeaderDataField(n) {
 			e.expr(k.deref(n, "reflect.Header.Data"), n.Left)
 		} else {
 			e.discard(n.Left)
 		}
-	case OPLUS, ONEG, OBITNOT:
+	case ir.OPLUS, ir.ONEG, ir.OBITNOT:
 		e.unsafeValue(k, n.Left)
-	case OADD, OSUB, OOR, OXOR, OMUL, ODIV, OMOD, OAND, OANDNOT:
+	case ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.ODIV, ir.OMOD, ir.OAND, ir.OANDNOT:
 		e.unsafeValue(k, n.Left)
 		e.unsafeValue(k, n.Right)
-	case OLSH, ORSH:
+	case ir.OLSH, ir.ORSH:
 		e.unsafeValue(k, n.Left)
 		// RHS need not be uintptr-typed (#32959) and can't meaningfully
 		// flow pointers anyway.
@@ -689,11 +690,11 @@ func (e *Escape) unsafeValue(k EscHole, n *Node) {
 
 // discard evaluates an expression n for side-effects, but discards
 // its value.
-func (e *Escape) discard(n *Node) {
+func (e *Escape) discard(n *ir.Node) {
 	e.expr(e.discardHole(), n)
 }
 
-func (e *Escape) discards(l Nodes) {
+func (e *Escape) discards(l ir.Nodes) {
 	for _, n := range l.Slice() {
 		e.discard(n)
 	}
@@ -701,8 +702,8 @@ func (e *Escape) discards(l Nodes) {
 
 // addr evaluates an addressable expression n and returns an EscHole
 // that represents storing into the represented location.
-func (e *Escape) addr(n *Node) EscHole {
-	if n == nil || n.isBlank() {
+func (e *Escape) addr(n *ir.Node) EscHole {
+	if n == nil || ir.IsBlank(n) {
 		// Can happen at least in OSELRECV.
 		// TODO(mdempsky): Anywhere else?
 		return e.discardHole()
@@ -713,23 +714,23 @@ func (e *Escape) addr(n *Node) EscHole {
 	switch n.Op {
 	default:
 		base.Fatalf("unexpected addr: %v", n)
-	case ONAME:
-		if n.Class() == PEXTERN {
+	case ir.ONAME:
+		if n.Class() == ir.PEXTERN {
 			break
 		}
 		k = e.oldLoc(n).asHole()
-	case ODOT:
+	case ir.ODOT:
 		k = e.addr(n.Left)
-	case OINDEX:
+	case ir.OINDEX:
 		e.discard(n.Right)
 		if n.Left.Type.IsArray() {
 			k = e.addr(n.Left)
 		} else {
 			e.discard(n.Left)
 		}
-	case ODEREF, ODOTPTR:
+	case ir.ODEREF, ir.ODOTPTR:
 		e.discard(n)
-	case OINDEXMAP:
+	case ir.OINDEXMAP:
 		e.discard(n.Left)
 		e.assignHeap(n.Right, "key of map put", n)
 	}
@@ -741,7 +742,7 @@ func (e *Escape) addr(n *Node) EscHole {
 	return k
 }
 
-func (e *Escape) addrs(l Nodes) []EscHole {
+func (e *Escape) addrs(l ir.Nodes) []EscHole {
 	var ks []EscHole
 	for _, n := range l.Slice() {
 		ks = append(ks, e.addr(n))
@@ -750,7 +751,7 @@ func (e *Escape) addrs(l Nodes) []EscHole {
 }
 
 // assign evaluates the assignment dst = src.
-func (e *Escape) assign(dst, src *Node, why string, where *Node) {
+func (e *Escape) assign(dst, src *ir.Node, why string, where *ir.Node) {
 	// Filter out some no-op assignments for escape analysis.
 	ignore := dst != nil && src != nil && isSelfAssign(dst, src)
 	if ignore && base.Flag.LowerM != 0 {
@@ -758,7 +759,7 @@ func (e *Escape) assign(dst, src *Node, why string, where *Node) {
 	}
 
 	k := e.addr(dst)
-	if dst != nil && dst.Op == ODOTPTR && isReflectHeaderDataField(dst) {
+	if dst != nil && dst.Op == ir.ODOTPTR && isReflectHeaderDataField(dst) {
 		e.unsafeValue(e.heapHole().note(where, why), src)
 	} else {
 		if ignore {
@@ -768,22 +769,22 @@ func (e *Escape) assign(dst, src *Node, why string, where *Node) {
 	}
 }
 
-func (e *Escape) assignHeap(src *Node, why string, where *Node) {
+func (e *Escape) assignHeap(src *ir.Node, why string, where *ir.Node) {
 	e.expr(e.heapHole().note(where, why), src)
 }
 
 // call evaluates a call expressions, including builtin calls. ks
 // should contain the holes representing where the function callee's
 // results flows; where is the OGO/ODEFER context of the call, if any.
-func (e *Escape) call(ks []EscHole, call, where *Node) {
-	topLevelDefer := where != nil && where.Op == ODEFER && e.loopDepth == 1
+func (e *Escape) call(ks []EscHole, call, where *ir.Node) {
+	topLevelDefer := where != nil && where.Op == ir.ODEFER && e.loopDepth == 1
 	if topLevelDefer {
 		// force stack allocation of defer record, unless
 		// open-coded defers are used (see ssa.go)
 		where.Esc = EscNever
 	}
 
-	argument := func(k EscHole, arg *Node) {
+	argument := func(k EscHole, arg *ir.Node) {
 		if topLevelDefer {
 			// Top level defers arguments don't escape to
 			// heap, but they do need to last until end of
@@ -800,21 +801,21 @@ func (e *Escape) call(ks []EscHole, call, where *Node) {
 	default:
 		base.Fatalf("unexpected call op: %v", call.Op)
 
-	case OCALLFUNC, OCALLMETH, OCALLINTER:
+	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
 		fixVariadicCall(call)
 
 		// Pick out the function callee, if statically known.
-		var fn *Node
+		var fn *ir.Node
 		switch call.Op {
-		case OCALLFUNC:
+		case ir.OCALLFUNC:
 			switch v := staticValue(call.Left); {
-			case v.Op == ONAME && v.Class() == PFUNC:
+			case v.Op == ir.ONAME && v.Class() == ir.PFUNC:
 				fn = v
-			case v.Op == OCLOSURE:
+			case v.Op == ir.OCLOSURE:
 				fn = v.Func.Nname
 			}
-		case OCALLMETH:
-			fn = call.Left.MethodName()
+		case ir.OCALLMETH:
+			fn = methodExprName(call.Left)
 		}
 
 		fntype := call.Left.Type
@@ -824,7 +825,7 @@ func (e *Escape) call(ks []EscHole, call, where *Node) {
 
 		if ks != nil && fn != nil && e.inMutualBatch(fn) {
 			for i, result := range fn.Type.Results().FieldSlice() {
-				e.expr(ks[i], asNode(result.Nname))
+				e.expr(ks[i], ir.AsNode(result.Nname))
 			}
 		}
 
@@ -840,7 +841,7 @@ func (e *Escape) call(ks []EscHole, call, where *Node) {
 			argument(e.tagHole(ks, fn, param), args[i])
 		}
 
-	case OAPPEND:
+	case ir.OAPPEND:
 		args := call.List.Slice()
 
 		// Appendee slice may flow directly to the result, if
@@ -865,7 +866,7 @@ func (e *Escape) call(ks []EscHole, call, where *Node) {
 			}
 		}
 
-	case OCOPY:
+	case ir.OCOPY:
 		argument(e.discardHole(), call.Left)
 
 		copiedK := e.discardHole()
@@ -874,17 +875,17 @@ func (e *Escape) call(ks []EscHole, call, where *Node) {
 		}
 		argument(copiedK, call.Right)
 
-	case OPANIC:
+	case ir.OPANIC:
 		argument(e.heapHole(), call.Left)
 
-	case OCOMPLEX:
+	case ir.OCOMPLEX:
 		argument(e.discardHole(), call.Left)
 		argument(e.discardHole(), call.Right)
-	case ODELETE, OPRINT, OPRINTN, ORECOVER:
+	case ir.ODELETE, ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
 		for _, arg := range call.List.Slice() {
 			argument(e.discardHole(), arg)
 		}
-	case OLEN, OCAP, OREAL, OIMAG, OCLOSE:
+	case ir.OLEN, ir.OCAP, ir.OREAL, ir.OIMAG, ir.OCLOSE:
 		argument(e.discardHole(), call.Left)
 	}
 }
@@ -893,14 +894,14 @@ func (e *Escape) call(ks []EscHole, call, where *Node) {
 // ks should contain the holes representing where the function
 // callee's results flows. fn is the statically-known callee function,
 // if any.
-func (e *Escape) tagHole(ks []EscHole, fn *Node, param *types.Field) EscHole {
+func (e *Escape) tagHole(ks []EscHole, fn *ir.Node, param *types.Field) EscHole {
 	// If this is a dynamic call, we can't rely on param.Note.
 	if fn == nil {
 		return e.heapHole()
 	}
 
 	if e.inMutualBatch(fn) {
-		return e.addr(asNode(param.Nname))
+		return e.addr(ir.AsNode(param.Nname))
 	}
 
 	// Call to previously tagged function.
@@ -934,7 +935,7 @@ func (e *Escape) tagHole(ks []EscHole, fn *Node, param *types.Field) EscHole {
 // fn has not yet been analyzed, so its parameters and results
 // should be incorporated directly into the flow graph instead of
 // relying on its escape analysis tagging.
-func (e *Escape) inMutualBatch(fn *Node) bool {
+func (e *Escape) inMutualBatch(fn *ir.Node) bool {
 	if fn.Name.Defn != nil && fn.Name.Defn.Esc < EscFuncTagged {
 		if fn.Name.Defn.Esc == EscFuncUnknown {
 			base.Fatalf("graph inconsistency")
@@ -959,11 +960,11 @@ type EscHole struct {
 
 type EscNote struct {
 	next  *EscNote
-	where *Node
+	where *ir.Node
 	why   string
 }
 
-func (k EscHole) note(where *Node, why string) EscHole {
+func (k EscHole) note(where *ir.Node, why string) EscHole {
 	if where == nil || why == "" {
 		base.Fatalf("note: missing where/why")
 	}
@@ -985,10 +986,10 @@ func (k EscHole) shift(delta int) EscHole {
 	return k
 }
 
-func (k EscHole) deref(where *Node, why string) EscHole { return k.shift(1).note(where, why) }
-func (k EscHole) addr(where *Node, why string) EscHole  { return k.shift(-1).note(where, why) }
+func (k EscHole) deref(where *ir.Node, why string) EscHole { return k.shift(1).note(where, why) }
+func (k EscHole) addr(where *ir.Node, why string) EscHole  { return k.shift(-1).note(where, why) }
 
-func (k EscHole) dotType(t *types.Type, where *Node, why string) EscHole {
+func (k EscHole) dotType(t *types.Type, where *ir.Node, why string) EscHole {
 	if !t.IsInterface() && !isdirectiface(t) {
 		k = k.shift(1)
 	}
@@ -1025,7 +1026,7 @@ func (e *Escape) teeHole(ks ...EscHole) EscHole {
 	return loc.asHole()
 }
 
-func (e *Escape) dcl(n *Node) EscHole {
+func (e *Escape) dcl(n *ir.Node) EscHole {
 	loc := e.oldLoc(n)
 	loc.loopDepth = e.loopDepth
 	return loc.asHole()
@@ -1034,7 +1035,7 @@ func (e *Escape) dcl(n *Node) EscHole {
 // spill allocates a new location associated with expression n, flows
 // its address to k, and returns a hole that flows values to it. It's
 // intended for use with most expressions that allocate storage.
-func (e *Escape) spill(k EscHole, n *Node) EscHole {
+func (e *Escape) spill(k EscHole, n *ir.Node) EscHole {
 	loc := e.newLoc(n, true)
 	e.flow(k.addr(n, "spill"), loc)
 	return loc.asHole()
@@ -1051,8 +1052,8 @@ func (e *Escape) later(k EscHole) EscHole {
 
 // canonicalNode returns the canonical *Node that n logically
 // represents.
-func canonicalNode(n *Node) *Node {
-	if n != nil && n.Op == ONAME && n.Name.IsClosureVar() {
+func canonicalNode(n *ir.Node) *ir.Node {
+	if n != nil && n.Op == ir.ONAME && n.Name.IsClosureVar() {
 		n = n.Name.Defn
 		if n.Name.IsClosureVar() {
 			base.Fatalf("still closure var")
@@ -1062,7 +1063,7 @@ func canonicalNode(n *Node) *Node {
 	return n
 }
 
-func (e *Escape) newLoc(n *Node, transient bool) *EscLocation {
+func (e *Escape) newLoc(n *ir.Node, transient bool) *EscLocation {
 	if e.curfn == nil {
 		base.Fatalf("e.curfn isn't set")
 	}
@@ -1079,7 +1080,7 @@ func (e *Escape) newLoc(n *Node, transient bool) *EscLocation {
 	}
 	e.allLocs = append(e.allLocs, loc)
 	if n != nil {
-		if n.Op == ONAME && n.Name.Curfn != e.curfn {
+		if n.Op == ir.ONAME && n.Name.Curfn != e.curfn {
 			base.Fatalf("curfn mismatch: %v != %v", n.Name.Curfn, e.curfn)
 		}
 
@@ -1095,7 +1096,7 @@ func (e *Escape) newLoc(n *Node, transient bool) *EscLocation {
 	return loc
 }
 
-func (e *Escape) oldLoc(n *Node) *EscLocation {
+func (e *Escape) oldLoc(n *ir.Node) *EscLocation {
 	n = canonicalNode(n)
 	return n.Opt().(*EscLocation)
 }
@@ -1120,7 +1121,7 @@ func (e *Escape) flow(k EscHole, src *EscLocation) {
 			}
 			explanation := e.explainFlow(pos, dst, src, k.derefs, k.notes, []*logopt.LoggedOpt{})
 			if logopt.Enabled() {
-				logopt.LogOpt(src.n.Pos, "escapes", "escape", e.curfn.funcname(), fmt.Sprintf("%v escapes to heap", src.n), explanation)
+				logopt.LogOpt(src.n.Pos, "escapes", "escape", ir.FuncName(e.curfn), fmt.Sprintf("%v escapes to heap", src.n), explanation)
 			}
 
 		}
@@ -1214,14 +1215,14 @@ func (e *Escape) walkOne(root *EscLocation, walkgen uint32, enqueue func(*EscLoc
 			// corresponding result parameter, then record
 			// that value flow for tagging the function
 			// later.
-			if l.isName(PPARAM) {
+			if l.isName(ir.PPARAM) {
 				if (logopt.Enabled() || base.Flag.LowerM >= 2) && !l.escapes {
 					if base.Flag.LowerM >= 2 {
 						fmt.Printf("%s: parameter %v leaks to %s with derefs=%d:\n", base.FmtPos(l.n.Pos), l.n, e.explainLoc(root), derefs)
 					}
 					explanation := e.explainPath(root, l)
 					if logopt.Enabled() {
-						logopt.LogOpt(l.n.Pos, "leak", "escape", e.curfn.funcname(),
+						logopt.LogOpt(l.n.Pos, "leak", "escape", ir.FuncName(e.curfn),
 							fmt.Sprintf("parameter %v leaks to %s with derefs=%d", l.n, e.explainLoc(root), derefs), explanation)
 					}
 				}
@@ -1238,7 +1239,7 @@ func (e *Escape) walkOne(root *EscLocation, walkgen uint32, enqueue func(*EscLoc
 					}
 					explanation := e.explainPath(root, l)
 					if logopt.Enabled() {
-						logopt.LogOpt(l.n.Pos, "escape", "escape", e.curfn.funcname(), fmt.Sprintf("%v escapes to heap", l.n), explanation)
+						logopt.LogOpt(l.n.Pos, "escape", "escape", ir.FuncName(e.curfn), fmt.Sprintf("%v escapes to heap", l.n), explanation)
 					}
 				}
 				l.escapes = true
@@ -1312,7 +1313,7 @@ func (e *Escape) explainFlow(pos string, dst, srcloc *EscLocation, derefs int, n
 		} else if srcloc != nil && srcloc.n != nil {
 			epos = srcloc.n.Pos
 		}
-		explanation = append(explanation, logopt.NewLoggedOpt(epos, "escflow", "escape", e.curfn.funcname(), flow))
+		explanation = append(explanation, logopt.NewLoggedOpt(epos, "escflow", "escape", ir.FuncName(e.curfn), flow))
 	}
 
 	for note := notes; note != nil; note = note.next {
@@ -1320,7 +1321,7 @@ func (e *Escape) explainFlow(pos string, dst, srcloc *EscLocation, derefs int, n
 			fmt.Printf("%s:     from %v (%v) at %s\n", pos, note.where, note.why, base.FmtPos(note.where.Pos))
 		}
 		if logopt.Enabled() {
-			explanation = append(explanation, logopt.NewLoggedOpt(note.where.Pos, "escflow", "escape", e.curfn.funcname(),
+			explanation = append(explanation, logopt.NewLoggedOpt(note.where.Pos, "escflow", "escape", ir.FuncName(e.curfn),
 				fmt.Sprintf("     from %v (%v)", note.where, note.why)))
 		}
 	}
@@ -1335,7 +1336,7 @@ func (e *Escape) explainLoc(l *EscLocation) string {
 		// TODO(mdempsky): Omit entirely.
 		return "{temp}"
 	}
-	if l.n.Op == ONAME {
+	if l.n.Op == ir.ONAME {
 		return fmt.Sprintf("%v", l.n)
 	}
 	return fmt.Sprintf("{storage for %v}", l.n)
@@ -1352,7 +1353,7 @@ func (e *Escape) outlives(l, other *EscLocation) bool {
 	// We don't know what callers do with returned values, so
 	// pessimistically we need to assume they flow to the heap and
 	// outlive everything too.
-	if l.isName(PPARAMOUT) {
+	if l.isName(ir.PPARAMOUT) {
 		// Exception: Directly called closures can return
 		// locations allocated outside of them without forcing
 		// them to the heap. For example:
@@ -1393,8 +1394,8 @@ func (e *Escape) outlives(l, other *EscLocation) bool {
 }
 
 // containsClosure reports whether c is a closure contained within f.
-func containsClosure(f, c *Node) bool {
-	if f.Op != ODCLFUNC || c.Op != ODCLFUNC {
+func containsClosure(f, c *ir.Node) bool {
+	if f.Op != ir.ODCLFUNC || c.Op != ir.ODCLFUNC {
 		base.Fatalf("bad containsClosure: %v, %v", f, c)
 	}
 
@@ -1414,7 +1415,7 @@ func containsClosure(f, c *Node) bool {
 func (l *EscLocation) leakTo(sink *EscLocation, derefs int) {
 	// If sink is a result parameter and we can fit return bits
 	// into the escape analysis tag, then record a return leak.
-	if sink.isName(PPARAMOUT) && sink.curfn == l.curfn {
+	if sink.isName(ir.PPARAMOUT) && sink.curfn == l.curfn {
 		// TODO(mdempsky): Eliminate dependency on Vargen here.
 		ri := int(sink.n.Name.Vargen) - 1
 		if ri < numEscResults {
@@ -1428,7 +1429,7 @@ func (l *EscLocation) leakTo(sink *EscLocation, derefs int) {
 	l.paramEsc.AddHeap(derefs)
 }
 
-func (e *Escape) finish(fns []*Node) {
+func (e *Escape) finish(fns []*ir.Node) {
 	// Record parameter tags for package export data.
 	for _, fn := range fns {
 		fn.Esc = EscFuncTagged
@@ -1452,18 +1453,18 @@ func (e *Escape) finish(fns []*Node) {
 		// Update n.Esc based on escape analysis results.
 
 		if loc.escapes {
-			if n.Op != ONAME {
+			if n.Op != ir.ONAME {
 				if base.Flag.LowerM != 0 {
 					base.WarnfAt(n.Pos, "%S escapes to heap", n)
 				}
 				if logopt.Enabled() {
-					logopt.LogOpt(n.Pos, "escape", "escape", e.curfn.funcname())
+					logopt.LogOpt(n.Pos, "escape", "escape", ir.FuncName(e.curfn))
 				}
 			}
 			n.Esc = EscHeap
 			addrescapes(n)
 		} else {
-			if base.Flag.LowerM != 0 && n.Op != ONAME {
+			if base.Flag.LowerM != 0 && n.Op != ir.ONAME {
 				base.WarnfAt(n.Pos, "%S does not escape", n)
 			}
 			n.Esc = EscNone
@@ -1474,8 +1475,8 @@ func (e *Escape) finish(fns []*Node) {
 	}
 }
 
-func (l *EscLocation) isName(c Class) bool {
-	return l.n != nil && l.n.Op == ONAME && l.n.Class() == c
+func (l *EscLocation) isName(c ir.Class) bool {
+	return l.n != nil && l.n.Op == ir.ONAME && l.n.Class() == c
 }
 
 const numEscResults = 7
@@ -1572,3 +1573,466 @@ func ParseLeaks(s string) EscLeaks {
 	copy(l[:], s[4:])
 	return l
 }
+
+func escapes(all []*ir.Node) {
+	visitBottomUp(all, escapeFuncs)
+}
+
+const (
+	EscFuncUnknown = 0 + iota
+	EscFuncPlanned
+	EscFuncStarted
+	EscFuncTagged
+)
+
+func min8(a, b int8) int8 {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func max8(a, b int8) int8 {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+const (
+	EscUnknown = iota
+	EscNone    // Does not escape to heap, result, or parameters.
+	EscHeap    // Reachable from the heap
+	EscNever   // By construction will not escape.
+)
+
+// funcSym returns fn.Func.Nname.Sym if no nils are encountered along the way.
+func funcSym(fn *ir.Node) *types.Sym {
+	if fn == nil || fn.Func.Nname == nil {
+		return nil
+	}
+	return fn.Func.Nname.Sym
+}
+
+// Mark labels that have no backjumps to them as not increasing e.loopdepth.
+// Walk hasn't generated (goto|label).Left.Sym.Label yet, so we'll cheat
+// and set it to one of the following two. Then in esc we'll clear it again.
+var (
+	looping    = ir.Nod(ir.OXXX, nil, nil)
+	nonlooping = ir.Nod(ir.OXXX, nil, nil)
+)
+
+func isSliceSelfAssign(dst, src *ir.Node) bool {
+	// Detect the following special case.
+	//
+	//	func (b *Buffer) Foo() {
+	//		n, m := ...
+	//		b.buf = b.buf[n:m]
+	//	}
+	//
+	// This assignment is a no-op for escape analysis,
+	// it does not store any new pointers into b that were not already there.
+	// However, without this special case b will escape, because we assign to OIND/ODOTPTR.
+	// Here we assume that the statement will not contain calls,
+	// that is, that order will move any calls to init.
+	// Otherwise base ONAME value could change between the moments
+	// when we evaluate it for dst and for src.
+
+	// dst is ONAME dereference.
+	if dst.Op != ir.ODEREF && dst.Op != ir.ODOTPTR || dst.Left.Op != ir.ONAME {
+		return false
+	}
+	// src is a slice operation.
+	switch src.Op {
+	case ir.OSLICE, ir.OSLICE3, ir.OSLICESTR:
+		// OK.
+	case ir.OSLICEARR, ir.OSLICE3ARR:
+		// Since arrays are embedded into containing object,
+		// slice of non-pointer array will introduce a new pointer into b that was not already there
+		// (pointer to b itself). After such assignment, if b contents escape,
+		// b escapes as well. If we ignore such OSLICEARR, we will conclude
+		// that b does not escape when b contents do.
+		//
+		// Pointer to an array is OK since it's not stored inside b directly.
+		// For slicing an array (not pointer to array), there is an implicit OADDR.
+		// We check that to determine non-pointer array slicing.
+		if src.Left.Op == ir.OADDR {
+			return false
+		}
+	default:
+		return false
+	}
+	// slice is applied to ONAME dereference.
+	if src.Left.Op != ir.ODEREF && src.Left.Op != ir.ODOTPTR || src.Left.Left.Op != ir.ONAME {
+		return false
+	}
+	// dst and src reference the same base ONAME.
+	return dst.Left == src.Left.Left
+}
+
+// isSelfAssign reports whether assignment from src to dst can
+// be ignored by the escape analysis as it's effectively a self-assignment.
+func isSelfAssign(dst, src *ir.Node) bool {
+	if isSliceSelfAssign(dst, src) {
+		return true
+	}
+
+	// Detect trivial assignments that assign back to the same object.
+	//
+	// It covers these cases:
+	//	val.x = val.y
+	//	val.x[i] = val.y[j]
+	//	val.x1.x2 = val.x1.y2
+	//	... etc
+	//
+	// These assignments do not change assigned object lifetime.
+
+	if dst == nil || src == nil || dst.Op != src.Op {
+		return false
+	}
+
+	switch dst.Op {
+	case ir.ODOT, ir.ODOTPTR:
+		// Safe trailing accessors that are permitted to differ.
+	case ir.OINDEX:
+		if mayAffectMemory(dst.Right) || mayAffectMemory(src.Right) {
+			return false
+		}
+	default:
+		return false
+	}
+
+	// The expression prefix must be both "safe" and identical.
+	return samesafeexpr(dst.Left, src.Left)
+}
+
+// mayAffectMemory reports whether evaluation of n may affect the program's
+// memory state. If the expression can't affect memory state, then it can be
+// safely ignored by the escape analysis.
+func mayAffectMemory(n *ir.Node) bool {
+	// We may want to use a list of "memory safe" ops instead of generally
+	// "side-effect free", which would include all calls and other ops that can
+	// allocate or change global state. For now, it's safer to start with the latter.
+	//
+	// We're ignoring things like division by zero, index out of range,
+	// and nil pointer dereference here.
+	switch n.Op {
+	case ir.ONAME, ir.OCLOSUREVAR, ir.OLITERAL, ir.ONIL:
+		return false
+
+	// Left+Right group.
+	case ir.OINDEX, ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.OLSH, ir.ORSH, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OMOD:
+		return mayAffectMemory(n.Left) || mayAffectMemory(n.Right)
+
+	// Left group.
+	case ir.ODOT, ir.ODOTPTR, ir.ODEREF, ir.OCONVNOP, ir.OCONV, ir.OLEN, ir.OCAP,
+		ir.ONOT, ir.OBITNOT, ir.OPLUS, ir.ONEG, ir.OALIGNOF, ir.OOFFSETOF, ir.OSIZEOF:
+		return mayAffectMemory(n.Left)
+
+	default:
+		return true
+	}
+}
+
+// heapAllocReason returns the reason the given Node must be heap
+// allocated, or the empty string if it doesn't.
+func heapAllocReason(n *ir.Node) string {
+	if n.Type == nil {
+		return ""
+	}
+
+	// Parameters are always passed via the stack.
+	if n.Op == ir.ONAME && (n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT) {
+		return ""
+	}
+
+	if n.Type.Width > maxStackVarSize {
+		return "too large for stack"
+	}
+
+	if (n.Op == ir.ONEW || n.Op == ir.OPTRLIT) && n.Type.Elem().Width >= maxImplicitStackVarSize {
+		return "too large for stack"
+	}
+
+	if n.Op == ir.OCLOSURE && closureType(n).Size() >= maxImplicitStackVarSize {
+		return "too large for stack"
+	}
+	if n.Op == ir.OCALLPART && partialCallType(n).Size() >= maxImplicitStackVarSize {
+		return "too large for stack"
+	}
+
+	if n.Op == ir.OMAKESLICE {
+		r := n.Right
+		if r == nil {
+			r = n.Left
+		}
+		if !smallintconst(r) {
+			return "non-constant size"
+		}
+		if t := n.Type; t.Elem().Width != 0 && r.Int64Val() >= maxImplicitStackVarSize/t.Elem().Width {
+			return "too large for stack"
+		}
+	}
+
+	return ""
+}
+
+// addrescapes tags node n as having had its address taken
+// by "increasing" the "value" of n.Esc to EscHeap.
+// Storage is allocated as necessary to allow the address
+// to be taken.
+func addrescapes(n *ir.Node) {
+	switch n.Op {
+	default:
+		// Unexpected Op, probably due to a previous type error. Ignore.
+
+	case ir.ODEREF, ir.ODOTPTR:
+		// Nothing to do.
+
+	case ir.ONAME:
+		if n == nodfp {
+			break
+		}
+
+		// if this is a tmpname (PAUTO), it was tagged by tmpname as not escaping.
+		// on PPARAM it means something different.
+		if n.Class() == ir.PAUTO && n.Esc == EscNever {
+			break
+		}
+
+		// If a closure reference escapes, mark the outer variable as escaping.
+		if n.Name.IsClosureVar() {
+			addrescapes(n.Name.Defn)
+			break
+		}
+
+		if n.Class() != ir.PPARAM && n.Class() != ir.PPARAMOUT && n.Class() != ir.PAUTO {
+			break
+		}
+
+		// This is a plain parameter or local variable that needs to move to the heap,
+		// but possibly for the function outside the one we're compiling.
+		// That is, if we have:
+		//
+		//	func f(x int) {
+		//		func() {
+		//			global = &x
+		//		}
+		//	}
+		//
+		// then we're analyzing the inner closure but we need to move x to the
+		// heap in f, not in the inner closure. Flip over to f before calling moveToHeap.
+		oldfn := Curfn
+		Curfn = n.Name.Curfn
+		if Curfn.Op == ir.OCLOSURE {
+			Curfn = Curfn.Func.Decl
+			panic("can't happen")
+		}
+		ln := base.Pos
+		base.Pos = Curfn.Pos
+		moveToHeap(n)
+		Curfn = oldfn
+		base.Pos = ln
+
+	// ODOTPTR has already been introduced,
+	// so these are the non-pointer ODOT and OINDEX.
+	// In &x[0], if x is a slice, then x does not
+	// escape--the pointer inside x does, but that
+	// is always a heap pointer anyway.
+	case ir.ODOT, ir.OINDEX, ir.OPAREN, ir.OCONVNOP:
+		if !n.Left.Type.IsSlice() {
+			addrescapes(n.Left)
+		}
+	}
+}
+
+// moveToHeap records the parameter or local variable n as moved to the heap.
+func moveToHeap(n *ir.Node) {
+	if base.Flag.LowerR != 0 {
+		ir.Dump("MOVE", n)
+	}
+	if base.Flag.CompilingRuntime {
+		base.Errorf("%v escapes to heap, not allowed in runtime", n)
+	}
+	if n.Class() == ir.PAUTOHEAP {
+		ir.Dump("n", n)
+		base.Fatalf("double move to heap")
+	}
+
+	// Allocate a local stack variable to hold the pointer to the heap copy.
+	// temp will add it to the function declaration list automatically.
+	heapaddr := temp(types.NewPtr(n.Type))
+	heapaddr.Sym = lookup("&" + n.Sym.Name)
+	heapaddr.Orig.Sym = heapaddr.Sym
+	heapaddr.Pos = n.Pos
+
+	// Unset AutoTemp to persist the &foo variable name through SSA to
+	// liveness analysis.
+	// TODO(mdempsky/drchase): Cleaner solution?
+	heapaddr.Name.SetAutoTemp(false)
+
+	// Parameters have a local stack copy used at function start/end
+	// in addition to the copy in the heap that may live longer than
+	// the function.
+	if n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT {
+		if n.Xoffset == types.BADWIDTH {
+			base.Fatalf("addrescapes before param assignment")
+		}
+
+		// We rewrite n below to be a heap variable (indirection of heapaddr).
+		// Preserve a copy so we can still write code referring to the original,
+		// and substitute that copy into the function declaration list
+		// so that analyses of the local (on-stack) variables use it.
+		stackcopy := NewName(n.Sym)
+		stackcopy.Type = n.Type
+		stackcopy.Xoffset = n.Xoffset
+		stackcopy.SetClass(n.Class())
+		stackcopy.Name.Param.Heapaddr = heapaddr
+		if n.Class() == ir.PPARAMOUT {
+			// Make sure the pointer to the heap copy is kept live throughout the function.
+			// The function could panic at any point, and then a defer could recover.
+			// Thus, we need the pointer to the heap copy always available so the
+			// post-deferreturn code can copy the return value back to the stack.
+			// See issue 16095.
+			heapaddr.Name.SetIsOutputParamHeapAddr(true)
+		}
+		n.Name.Param.Stackcopy = stackcopy
+
+		// Substitute the stackcopy into the function variable list so that
+		// liveness and other analyses use the underlying stack slot
+		// and not the now-pseudo-variable n.
+		found := false
+		for i, d := range Curfn.Func.Dcl {
+			if d == n {
+				Curfn.Func.Dcl[i] = stackcopy
+				found = true
+				break
+			}
+			// Parameters are before locals, so can stop early.
+			// This limits the search even in functions with many local variables.
+			if d.Class() == ir.PAUTO {
+				break
+			}
+		}
+		if !found {
+			base.Fatalf("cannot find %v in local variable list", n)
+		}
+		Curfn.Func.Dcl = append(Curfn.Func.Dcl, n)
+	}
+
+	// Modify n in place so that uses of n now mean indirection of the heapaddr.
+	n.SetClass(ir.PAUTOHEAP)
+	n.Xoffset = 0
+	n.Name.Param.Heapaddr = heapaddr
+	n.Esc = EscHeap
+	if base.Flag.LowerM != 0 {
+		base.WarnfAt(n.Pos, "moved to heap: %v", n)
+	}
+}
+
+// This special tag is applied to uintptr variables
+// that we believe may hold unsafe.Pointers for
+// calls into assembly functions.
+const unsafeUintptrTag = "unsafe-uintptr"
+
+// This special tag is applied to uintptr parameters of functions
+// marked go:uintptrescapes.
+const uintptrEscapesTag = "uintptr-escapes"
+
+func (e *Escape) paramTag(fn *ir.Node, narg int, f *types.Field) string {
+	name := func() string {
+		if f.Sym != nil {
+			return f.Sym.Name
+		}
+		return fmt.Sprintf("arg#%d", narg)
+	}
+
+	if fn.Nbody.Len() == 0 {
+		// Assume that uintptr arguments must be held live across the call.
+		// This is most important for syscall.Syscall.
+		// See golang.org/issue/13372.
+		// This really doesn't have much to do with escape analysis per se,
+		// but we are reusing the ability to annotate an individual function
+		// argument and pass those annotations along to importing code.
+		if f.Type.IsUintptr() {
+			if base.Flag.LowerM != 0 {
+				base.WarnfAt(f.Pos, "assuming %v is unsafe uintptr", name())
+			}
+			return unsafeUintptrTag
+		}
+
+		if !f.Type.HasPointers() { // don't bother tagging for scalars
+			return ""
+		}
+
+		var esc EscLeaks
+
+		// External functions are assumed unsafe, unless
+		// //go:noescape is given before the declaration.
+		if fn.Func.Pragma&ir.Noescape != 0 {
+			if base.Flag.LowerM != 0 && f.Sym != nil {
+				base.WarnfAt(f.Pos, "%v does not escape", name())
+			}
+		} else {
+			if base.Flag.LowerM != 0 && f.Sym != nil {
+				base.WarnfAt(f.Pos, "leaking param: %v", name())
+			}
+			esc.AddHeap(0)
+		}
+
+		return esc.Encode()
+	}
+
+	if fn.Func.Pragma&ir.UintptrEscapes != 0 {
+		if f.Type.IsUintptr() {
+			if base.Flag.LowerM != 0 {
+				base.WarnfAt(f.Pos, "marking %v as escaping uintptr", name())
+			}
+			return uintptrEscapesTag
+		}
+		if f.IsDDD() && f.Type.Elem().IsUintptr() {
+			// final argument is ...uintptr.
+			if base.Flag.LowerM != 0 {
+				base.WarnfAt(f.Pos, "marking %v as escaping ...uintptr", name())
+			}
+			return uintptrEscapesTag
+		}
+	}
+
+	if !f.Type.HasPointers() { // don't bother tagging for scalars
+		return ""
+	}
+
+	// Unnamed parameters are unused and therefore do not escape.
+	if f.Sym == nil || f.Sym.IsBlank() {
+		var esc EscLeaks
+		return esc.Encode()
+	}
+
+	n := ir.AsNode(f.Nname)
+	loc := e.oldLoc(n)
+	esc := loc.paramEsc
+	esc.Optimize()
+
+	if base.Flag.LowerM != 0 && !loc.escapes {
+		if esc.Empty() {
+			base.WarnfAt(f.Pos, "%v does not escape", name())
+		}
+		if x := esc.Heap(); x >= 0 {
+			if x == 0 {
+				base.WarnfAt(f.Pos, "leaking param: %v", name())
+			} else {
+				// TODO(mdempsky): Mention level=x like below?
+				base.WarnfAt(f.Pos, "leaking param content: %v", name())
+			}
+		}
+		for i := 0; i < numEscResults; i++ {
+			if x := esc.Result(i); x >= 0 {
+				res := fn.Type.Results().Field(i).Sym
+				base.WarnfAt(f.Pos, "leaking param: %v to result %v level=%d", name(), res, x)
+			}
+		}
+	}
+
+	return esc.Encode()
+}
diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index 1fa64fbe44..36bbb75050 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/bio"
 	"cmd/internal/src"
@@ -20,10 +21,10 @@ func exportf(bout *bio.Writer, format string, args ...interface{}) {
 	}
 }
 
-var asmlist []*Node
+var asmlist []*ir.Node
 
 // exportsym marks n for export (or reexport).
-func exportsym(n *Node) {
+func exportsym(n *ir.Node) {
 	if n.Sym.OnExportList() {
 		return
 	}
@@ -40,14 +41,14 @@ func initname(s string) bool {
 	return s == "init"
 }
 
-func autoexport(n *Node, ctxt Class) {
-	if n.Sym.Pkg != localpkg {
+func autoexport(n *ir.Node, ctxt ir.Class) {
+	if n.Sym.Pkg != ir.LocalPkg {
 		return
 	}
-	if (ctxt != PEXTERN && ctxt != PFUNC) || dclcontext != PEXTERN {
+	if (ctxt != ir.PEXTERN && ctxt != ir.PFUNC) || dclcontext != ir.PEXTERN {
 		return
 	}
-	if n.Type != nil && n.Type.IsKind(TFUNC) && n.IsMethod() {
+	if n.Type != nil && n.Type.IsKind(types.TFUNC) && ir.IsMethod(n) {
 		return
 	}
 
@@ -73,8 +74,8 @@ func dumpexport(bout *bio.Writer) {
 	}
 }
 
-func importsym(ipkg *types.Pkg, s *types.Sym, op Op) *Node {
-	n := asNode(s.PkgDef())
+func importsym(ipkg *types.Pkg, s *types.Sym, op ir.Op) *ir.Node {
+	n := ir.AsNode(s.PkgDef())
 	if n == nil {
 		// iimport should have created a stub ONONAME
 		// declaration for all imported symbols. The exception
@@ -85,10 +86,10 @@ func importsym(ipkg *types.Pkg, s *types.Sym, op Op) *Node {
 		}
 
 		n = dclname(s)
-		s.SetPkgDef(asTypesNode(n))
+		s.SetPkgDef(ir.AsTypesNode(n))
 		s.Importdef = ipkg
 	}
-	if n.Op != ONONAME && n.Op != op {
+	if n.Op != ir.ONONAME && n.Op != op {
 		redeclare(base.Pos, s, fmt.Sprintf("during import %q", ipkg.Path))
 	}
 	return n
@@ -98,16 +99,16 @@ func importsym(ipkg *types.Pkg, s *types.Sym, op Op) *Node {
 // If no such type has been declared yet, a forward declaration is returned.
 // ipkg is the package being imported
 func importtype(ipkg *types.Pkg, pos src.XPos, s *types.Sym) *types.Type {
-	n := importsym(ipkg, s, OTYPE)
-	if n.Op != OTYPE {
-		t := types.New(TFORW)
+	n := importsym(ipkg, s, ir.OTYPE)
+	if n.Op != ir.OTYPE {
+		t := types.New(types.TFORW)
 		t.Sym = s
-		t.Nod = asTypesNode(n)
+		t.Nod = ir.AsTypesNode(n)
 
-		n.Op = OTYPE
+		n.Op = ir.OTYPE
 		n.Pos = pos
 		n.Type = t
-		n.SetClass(PEXTERN)
+		n.SetClass(ir.PEXTERN)
 	}
 
 	t := n.Type
@@ -119,9 +120,9 @@ func importtype(ipkg *types.Pkg, pos src.XPos, s *types.Sym) *types.Type {
 
 // importobj declares symbol s as an imported object representable by op.
 // ipkg is the package being imported
-func importobj(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op Op, ctxt Class, t *types.Type) *Node {
+func importobj(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op ir.Op, ctxt ir.Class, t *types.Type) *ir.Node {
 	n := importsym(ipkg, s, op)
-	if n.Op != ONONAME {
+	if n.Op != ir.ONONAME {
 		if n.Op == op && (n.Class() != ctxt || !types.Identical(n.Type, t)) {
 			redeclare(base.Pos, s, fmt.Sprintf("during import %q", ipkg.Path))
 		}
@@ -131,7 +132,7 @@ func importobj(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op Op, ctxt Class, t
 	n.Op = op
 	n.Pos = pos
 	n.SetClass(ctxt)
-	if ctxt == PFUNC {
+	if ctxt == ir.PFUNC {
 		n.Sym.SetFunc(true)
 	}
 	n.Type = t
@@ -141,7 +142,7 @@ func importobj(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op Op, ctxt Class, t
 // importconst declares symbol s as an imported constant with type t and value val.
 // ipkg is the package being imported
 func importconst(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type, val constant.Value) {
-	n := importobj(ipkg, pos, s, OLITERAL, PEXTERN, t)
+	n := importobj(ipkg, pos, s, ir.OLITERAL, ir.PEXTERN, t)
 	if n == nil { // TODO: Check that value matches.
 		return
 	}
@@ -156,12 +157,12 @@ func importconst(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type, val
 // importfunc declares symbol s as an imported function with type t.
 // ipkg is the package being imported
 func importfunc(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) {
-	n := importobj(ipkg, pos, s, ONAME, PFUNC, t)
+	n := importobj(ipkg, pos, s, ir.ONAME, ir.PFUNC, t)
 	if n == nil {
 		return
 	}
 
-	n.Func = new(Func)
+	n.Func = new(ir.Func)
 
 	if base.Flag.E != 0 {
 		fmt.Printf("import func %v%S\n", s, t)
@@ -171,7 +172,7 @@ func importfunc(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) {
 // importvar declares symbol s as an imported variable with type t.
 // ipkg is the package being imported
 func importvar(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) {
-	n := importobj(ipkg, pos, s, ONAME, PEXTERN, t)
+	n := importobj(ipkg, pos, s, ir.ONAME, ir.PEXTERN, t)
 	if n == nil {
 		return
 	}
@@ -184,7 +185,7 @@ func importvar(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) {
 // importalias declares symbol s as an imported type alias with type t.
 // ipkg is the package being imported
 func importalias(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) {
-	n := importobj(ipkg, pos, s, OTYPE, PEXTERN, t)
+	n := importobj(ipkg, pos, s, ir.OTYPE, ir.PEXTERN, t)
 	if n == nil {
 		return
 	}
@@ -199,20 +200,20 @@ func dumpasmhdr() {
 	if err != nil {
 		base.Fatalf("%v", err)
 	}
-	fmt.Fprintf(b, "// generated by compile -asmhdr from package %s\n\n", localpkg.Name)
+	fmt.Fprintf(b, "// generated by compile -asmhdr from package %s\n\n", ir.LocalPkg.Name)
 	for _, n := range asmlist {
 		if n.Sym.IsBlank() {
 			continue
 		}
 		switch n.Op {
-		case OLITERAL:
+		case ir.OLITERAL:
 			t := n.Val().Kind()
 			if t == constant.Float || t == constant.Complex {
 				break
 			}
 			fmt.Fprintf(b, "#define const_%s %#v\n", n.Sym.Name, n.Val())
 
-		case OTYPE:
+		case ir.OTYPE:
 			t := n.Type
 			if !t.IsStruct() || t.StructType().Map != nil || t.IsFuncArgStruct() {
 				break
diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
index a70bddca81..0f5294b17d 100644
--- a/src/cmd/compile/internal/gc/gen.go
+++ b/src/cmd/compile/internal/gc/gen.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/src"
@@ -29,14 +30,14 @@ func sysvar(name string) *obj.LSym {
 
 // isParamStackCopy reports whether this is the on-stack copy of a
 // function parameter that moved to the heap.
-func (n *Node) isParamStackCopy() bool {
-	return n.Op == ONAME && (n.Class() == PPARAM || n.Class() == PPARAMOUT) && n.Name.Param.Heapaddr != nil
+func isParamStackCopy(n *ir.Node) bool {
+	return n.Op == ir.ONAME && (n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT) && n.Name.Param.Heapaddr != nil
 }
 
 // isParamHeapCopy reports whether this is the on-heap copy of
 // a function parameter that moved to the heap.
-func (n *Node) isParamHeapCopy() bool {
-	return n.Op == ONAME && n.Class() == PAUTOHEAP && n.Name.Param.Stackcopy != nil
+func isParamHeapCopy(n *ir.Node) bool {
+	return n.Op == ir.ONAME && n.Class() == ir.PAUTOHEAP && n.Name.Param.Stackcopy != nil
 }
 
 // autotmpname returns the name for an autotmp variable numbered n.
@@ -51,12 +52,12 @@ func autotmpname(n int) string {
 }
 
 // make a new Node off the books
-func tempAt(pos src.XPos, curfn *Node, t *types.Type) *Node {
+func tempAt(pos src.XPos, curfn *ir.Node, t *types.Type) *ir.Node {
 	if curfn == nil {
 		base.Fatalf("no curfn for tempAt")
 	}
-	if curfn.Op == OCLOSURE {
-		Dump("tempAt", curfn)
+	if curfn.Op == ir.OCLOSURE {
+		ir.Dump("tempAt", curfn)
 		base.Fatalf("adding tempAt to wrong closure function")
 	}
 	if t == nil {
@@ -65,12 +66,12 @@ func tempAt(pos src.XPos, curfn *Node, t *types.Type) *Node {
 
 	s := &types.Sym{
 		Name: autotmpname(len(curfn.Func.Dcl)),
-		Pkg:  localpkg,
+		Pkg:  ir.LocalPkg,
 	}
-	n := newnamel(pos, s)
-	s.Def = asTypesNode(n)
+	n := ir.NewNameAt(pos, s)
+	s.Def = ir.AsTypesNode(n)
 	n.Type = t
-	n.SetClass(PAUTO)
+	n.SetClass(ir.PAUTO)
 	n.Esc = EscNever
 	n.Name.Curfn = curfn
 	n.Name.SetUsed(true)
@@ -82,6 +83,6 @@ func tempAt(pos src.XPos, curfn *Node, t *types.Type) *Node {
 	return n.Orig
 }
 
-func temp(t *types.Type) *Node {
+func temp(t *types.Type) *ir.Node {
 	return tempAt(base.Pos, Curfn, t)
 }
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index d9b8f704a9..8642cc4a30 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -13,10 +14,6 @@ import (
 	"sync"
 )
 
-const (
-	BADWIDTH = types.BADWIDTH
-)
-
 var (
 	// maximum size variable which we will allocate on the stack.
 	// This limit is for explicit variable declarations like "var x T" or "x := ...".
@@ -40,7 +37,7 @@ var (
 
 // isRuntimePkg reports whether p is package runtime.
 func isRuntimePkg(p *types.Pkg) bool {
-	if base.Flag.CompilingRuntime && p == localpkg {
+	if base.Flag.CompilingRuntime && p == ir.LocalPkg {
 		return true
 	}
 	return p.Path == "runtime"
@@ -48,31 +45,12 @@ func isRuntimePkg(p *types.Pkg) bool {
 
 // isReflectPkg reports whether p is package reflect.
 func isReflectPkg(p *types.Pkg) bool {
-	if p == localpkg {
+	if p == ir.LocalPkg {
 		return base.Ctxt.Pkgpath == "reflect"
 	}
 	return p.Path == "reflect"
 }
 
-// The Class of a variable/function describes the "storage class"
-// of a variable or function. During parsing, storage classes are
-// called declaration contexts.
-type Class uint8
-
-//go:generate stringer -type=Class
-const (
-	Pxxx      Class = iota // no class; used during ssa conversion to indicate pseudo-variables
-	PEXTERN                // global variables
-	PAUTO                  // local variables
-	PAUTOHEAP              // local variables or parameters moved to heap
-	PPARAM                 // input arguments
-	PPARAMOUT              // output results
-	PFUNC                  // global functions
-
-	// Careful: Class is stored in three bits in Node.flags.
-	_ = uint((1 << 3) - iota) // static assert for iota <= (1 << 3)
-)
-
 // Slices in the runtime are represented by three components:
 //
 // type slice struct {
@@ -102,8 +80,6 @@ var pragcgobuf [][]string
 
 var decldepth int32
 
-var localpkg *types.Pkg // package being compiled
-
 var inimport bool // set during import
 
 var itabpkg *types.Pkg // fake pkg for itab entries
@@ -126,55 +102,51 @@ var gopkg *types.Pkg // pseudo-package for method symbols on anonymous receiver
 
 var zerosize int64
 
-var simtype [NTYPE]types.EType
+var simtype [types.NTYPE]types.EType
 
 var (
-	isInt     [NTYPE]bool
-	isFloat   [NTYPE]bool
-	isComplex [NTYPE]bool
-	issimple  [NTYPE]bool
+	isInt     [types.NTYPE]bool
+	isFloat   [types.NTYPE]bool
+	isComplex [types.NTYPE]bool
+	issimple  [types.NTYPE]bool
 )
 
 var (
-	okforeq    [NTYPE]bool
-	okforadd   [NTYPE]bool
-	okforand   [NTYPE]bool
-	okfornone  [NTYPE]bool
-	okforcmp   [NTYPE]bool
-	okforbool  [NTYPE]bool
-	okforcap   [NTYPE]bool
-	okforlen   [NTYPE]bool
-	okforarith [NTYPE]bool
+	okforeq    [types.NTYPE]bool
+	okforadd   [types.NTYPE]bool
+	okforand   [types.NTYPE]bool
+	okfornone  [types.NTYPE]bool
+	okforcmp   [types.NTYPE]bool
+	okforbool  [types.NTYPE]bool
+	okforcap   [types.NTYPE]bool
+	okforlen   [types.NTYPE]bool
+	okforarith [types.NTYPE]bool
 )
 
-var okforconst [NTYPE]bool
-
 var (
-	okfor [OEND][]bool
-	iscmp [OEND]bool
+	okfor [ir.OEND][]bool
+	iscmp [ir.OEND]bool
 )
 
-var xtop []*Node
+var xtop []*ir.Node
 
-var exportlist []*Node
+var exportlist []*ir.Node
 
-var importlist []*Node // imported functions and methods with inlinable bodies
+var importlist []*ir.Node // imported functions and methods with inlinable bodies
 
 var (
 	funcsymsmu sync.Mutex // protects funcsyms and associated package lookups (see func funcsym)
 	funcsyms   []*types.Sym
 )
 
-var dclcontext Class // PEXTERN/PAUTO
+var dclcontext ir.Class // PEXTERN/PAUTO
 
-var Curfn *Node
+var Curfn *ir.Node
 
 var Widthptr int
 
 var Widthreg int
 
-var nblank *Node
-
 var typecheckok bool
 
 // Whether we are adding any sort of code instrumentation, such as
@@ -184,7 +156,7 @@ var instrumenting bool
 // Whether we are tracking lexical scopes for DWARF.
 var trackScopes bool
 
-var nodfp *Node
+var nodfp *ir.Node
 
 var autogeneratedPos src.XPos
 
@@ -221,7 +193,7 @@ var thearch Arch
 
 var (
 	staticuint64s,
-	zerobase *Node
+	zerobase *ir.Node
 
 	assertE2I,
 	assertE2I2,
diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go
index 92a3611cb7..cf1c85ce29 100644
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ b/src/cmd/compile/internal/gc/gsubr.go
@@ -32,6 +32,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/ssa"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
@@ -46,7 +47,7 @@ type Progs struct {
 	next      *obj.Prog  // next Prog
 	pc        int64      // virtual PC; count of Progs
 	pos       src.XPos   // position to use for new Progs
-	curfn     *Node      // fn these Progs are for
+	curfn     *ir.Node   // fn these Progs are for
 	progcache []obj.Prog // local progcache
 	cacheidx  int        // first free element of progcache
 
@@ -56,7 +57,7 @@ type Progs struct {
 
 // newProgs returns a new Progs for fn.
 // worker indicates which of the backend workers will use the Progs.
-func newProgs(fn *Node, worker int) *Progs {
+func newProgs(fn *ir.Node, worker int) *Progs {
 	pp := new(Progs)
 	if base.Ctxt.CanReuseProgs() {
 		sz := len(sharedProgArray) / base.Flag.LowerC
@@ -173,17 +174,17 @@ func (pp *Progs) Appendpp(p *obj.Prog, as obj.As, ftype obj.AddrType, freg int16
 	return q
 }
 
-func (pp *Progs) settext(fn *Node) {
+func (pp *Progs) settext(fn *ir.Node) {
 	if pp.Text != nil {
 		base.Fatalf("Progs.settext called twice")
 	}
 	ptxt := pp.Prog(obj.ATEXT)
 	pp.Text = ptxt
 
-	fn.Func.lsym.Func().Text = ptxt
+	fn.Func.LSym.Func().Text = ptxt
 	ptxt.From.Type = obj.TYPE_MEM
 	ptxt.From.Name = obj.NAME_EXTERN
-	ptxt.From.Sym = fn.Func.lsym
+	ptxt.From.Sym = fn.Func.LSym
 }
 
 // initLSym defines f's obj.LSym and initializes it based on the
@@ -192,36 +193,36 @@ func (pp *Progs) settext(fn *Node) {
 //
 // initLSym must be called exactly once per function and must be
 // called for both functions with bodies and functions without bodies.
-func (f *Func) initLSym(hasBody bool) {
-	if f.lsym != nil {
+func initLSym(f *ir.Func, hasBody bool) {
+	if f.LSym != nil {
 		base.Fatalf("Func.initLSym called twice")
 	}
 
-	if nam := f.Nname; !nam.isBlank() {
-		f.lsym = nam.Sym.Linksym()
-		if f.Pragma&Systemstack != 0 {
-			f.lsym.Set(obj.AttrCFunc, true)
+	if nam := f.Nname; !ir.IsBlank(nam) {
+		f.LSym = nam.Sym.Linksym()
+		if f.Pragma&ir.Systemstack != 0 {
+			f.LSym.Set(obj.AttrCFunc, true)
 		}
 
 		var aliasABI obj.ABI
 		needABIAlias := false
-		defABI, hasDefABI := symabiDefs[f.lsym.Name]
+		defABI, hasDefABI := symabiDefs[f.LSym.Name]
 		if hasDefABI && defABI == obj.ABI0 {
 			// Symbol is defined as ABI0. Create an
 			// Internal -> ABI0 wrapper.
-			f.lsym.SetABI(obj.ABI0)
+			f.LSym.SetABI(obj.ABI0)
 			needABIAlias, aliasABI = true, obj.ABIInternal
 		} else {
 			// No ABI override. Check that the symbol is
 			// using the expected ABI.
 			want := obj.ABIInternal
-			if f.lsym.ABI() != want {
-				base.Fatalf("function symbol %s has the wrong ABI %v, expected %v", f.lsym.Name, f.lsym.ABI(), want)
+			if f.LSym.ABI() != want {
+				base.Fatalf("function symbol %s has the wrong ABI %v, expected %v", f.LSym.Name, f.LSym.ABI(), want)
 			}
 		}
 
 		isLinknameExported := nam.Sym.Linkname != "" && (hasBody || hasDefABI)
-		if abi, ok := symabiRefs[f.lsym.Name]; (ok && abi == obj.ABI0) || isLinknameExported {
+		if abi, ok := symabiRefs[f.LSym.Name]; (ok && abi == obj.ABI0) || isLinknameExported {
 			// Either 1) this symbol is definitely
 			// referenced as ABI0 from this package; or 2)
 			// this symbol is defined in this package but
@@ -233,7 +234,7 @@ func (f *Func) initLSym(hasBody bool) {
 			// since other packages may "pull" symbols
 			// using linkname and we don't want to create
 			// duplicate ABI wrappers.
-			if f.lsym.ABI() != obj.ABI0 {
+			if f.LSym.ABI() != obj.ABI0 {
 				needABIAlias, aliasABI = true, obj.ABI0
 			}
 		}
@@ -244,9 +245,9 @@ func (f *Func) initLSym(hasBody bool) {
 			// rather than looking them up. The uniqueness
 			// of f.lsym ensures uniqueness of asym.
 			asym := &obj.LSym{
-				Name: f.lsym.Name,
+				Name: f.LSym.Name,
 				Type: objabi.SABIALIAS,
-				R:    []obj.Reloc{{Sym: f.lsym}}, // 0 size, so "informational"
+				R:    []obj.Reloc{{Sym: f.LSym}}, // 0 size, so "informational"
 			}
 			asym.SetABI(aliasABI)
 			asym.Set(obj.AttrDuplicateOK, true)
@@ -269,7 +270,7 @@ func (f *Func) initLSym(hasBody bool) {
 	if f.Needctxt() {
 		flag |= obj.NEEDCTXT
 	}
-	if f.Pragma&Nosplit != 0 {
+	if f.Pragma&ir.Nosplit != 0 {
 		flag |= obj.NOSPLIT
 	}
 	if f.ReflectMethod() {
@@ -286,10 +287,10 @@ func (f *Func) initLSym(hasBody bool) {
 		}
 	}
 
-	base.Ctxt.InitTextSym(f.lsym, flag)
+	base.Ctxt.InitTextSym(f.LSym, flag)
 }
 
-func ggloblnod(nam *Node) {
+func ggloblnod(nam *ir.Node) {
 	s := nam.Sym.Linksym()
 	s.Gotype = ngotype(nam).Linksym()
 	flags := 0
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index 246a057ade..212db2184e 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -205,6 +205,7 @@ import (
 	"bufio"
 	"bytes"
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/goobj"
 	"cmd/internal/src"
@@ -258,8 +259,8 @@ func iexport(out *bufio.Writer) {
 	p := iexporter{
 		allPkgs:     map[*types.Pkg]bool{},
 		stringIndex: map[string]uint64{},
-		declIndex:   map[*Node]uint64{},
-		inlineIndex: map[*Node]uint64{},
+		declIndex:   map[*ir.Node]uint64{},
+		inlineIndex: map[*ir.Node]uint64{},
 		typIndex:    map[*types.Type]uint64{},
 	}
 
@@ -278,8 +279,8 @@ func iexport(out *bufio.Writer) {
 	// Loop until no more work. We use a queue because while
 	// writing out inline bodies, we may discover additional
 	// declarations that are needed.
-	for !p.declTodo.empty() {
-		p.doDecl(p.declTodo.popLeft())
+	for !p.declTodo.Empty() {
+		p.doDecl(p.declTodo.PopLeft())
 	}
 
 	// Append indices to data0 section.
@@ -313,15 +314,15 @@ func iexport(out *bufio.Writer) {
 // we're writing out the main index, which is also read by
 // non-compiler tools and includes a complete package description
 // (i.e., name and height).
-func (w *exportWriter) writeIndex(index map[*Node]uint64, mainIndex bool) {
+func (w *exportWriter) writeIndex(index map[*ir.Node]uint64, mainIndex bool) {
 	// Build a map from packages to objects from that package.
-	pkgObjs := map[*types.Pkg][]*Node{}
+	pkgObjs := map[*types.Pkg][]*ir.Node{}
 
 	// For the main index, make sure to include every package that
 	// we reference, even if we're not exporting (or reexporting)
 	// any symbols from it.
 	if mainIndex {
-		pkgObjs[localpkg] = nil
+		pkgObjs[ir.LocalPkg] = nil
 		for pkg := range w.p.allPkgs {
 			pkgObjs[pkg] = nil
 		}
@@ -367,14 +368,14 @@ type iexporter struct {
 	// main index.
 	allPkgs map[*types.Pkg]bool
 
-	declTodo nodeQueue
+	declTodo ir.NodeQueue
 
 	strings     intWriter
 	stringIndex map[string]uint64
 
 	data0       intWriter
-	declIndex   map[*Node]uint64
-	inlineIndex map[*Node]uint64
+	declIndex   map[*ir.Node]uint64
+	inlineIndex map[*ir.Node]uint64
 	typIndex    map[*types.Type]uint64
 }
 
@@ -393,13 +394,13 @@ func (p *iexporter) stringOff(s string) uint64 {
 }
 
 // pushDecl adds n to the declaration work queue, if not already present.
-func (p *iexporter) pushDecl(n *Node) {
-	if n.Sym == nil || asNode(n.Sym.Def) != n && n.Op != OTYPE {
+func (p *iexporter) pushDecl(n *ir.Node) {
+	if n.Sym == nil || ir.AsNode(n.Sym.Def) != n && n.Op != ir.OTYPE {
 		base.Fatalf("weird Sym: %v, %v", n, n.Sym)
 	}
 
 	// Don't export predeclared declarations.
-	if n.Sym.Pkg == builtinpkg || n.Sym.Pkg == unsafepkg {
+	if n.Sym.Pkg == ir.BuiltinPkg || n.Sym.Pkg == unsafepkg {
 		return
 	}
 
@@ -408,7 +409,7 @@ func (p *iexporter) pushDecl(n *Node) {
 	}
 
 	p.declIndex[n] = ^uint64(0) // mark n present in work queue
-	p.declTodo.pushRight(n)
+	p.declTodo.PushRight(n)
 }
 
 // exportWriter handles writing out individual data section chunks.
@@ -422,22 +423,22 @@ type exportWriter struct {
 	prevColumn int64
 }
 
-func (p *iexporter) doDecl(n *Node) {
+func (p *iexporter) doDecl(n *ir.Node) {
 	w := p.newWriter()
 	w.setPkg(n.Sym.Pkg, false)
 
 	switch n.Op {
-	case ONAME:
+	case ir.ONAME:
 		switch n.Class() {
-		case PEXTERN:
+		case ir.PEXTERN:
 			// Variable.
 			w.tag('V')
 			w.pos(n.Pos)
 			w.typ(n.Type)
 			w.varExt(n)
 
-		case PFUNC:
-			if n.IsMethod() {
+		case ir.PFUNC:
+			if ir.IsMethod(n) {
 				base.Fatalf("unexpected method: %v", n)
 			}
 
@@ -451,14 +452,14 @@ func (p *iexporter) doDecl(n *Node) {
 			base.Fatalf("unexpected class: %v, %v", n, n.Class())
 		}
 
-	case OLITERAL:
+	case ir.OLITERAL:
 		// Constant.
 		n = typecheck(n, ctxExpr)
 		w.tag('C')
 		w.pos(n.Pos)
 		w.value(n.Type, n.Val())
 
-	case OTYPE:
+	case ir.OTYPE:
 		if IsAlias(n.Sym) {
 			// Alias.
 			w.tag('A')
@@ -514,11 +515,11 @@ func (w *exportWriter) tag(tag byte) {
 	w.data.WriteByte(tag)
 }
 
-func (p *iexporter) doInline(f *Node) {
+func (p *iexporter) doInline(f *ir.Node) {
 	w := p.newWriter()
 	w.setPkg(fnpkg(f), false)
 
-	w.stmtList(asNodes(f.Func.Inl.Body))
+	w.stmtList(ir.AsNodes(f.Func.Inl.Body))
 
 	p.inlineIndex[f] = w.flush()
 }
@@ -569,7 +570,7 @@ func (w *exportWriter) pkg(pkg *types.Pkg) {
 	w.string(pkg.Path)
 }
 
-func (w *exportWriter) qualifiedIdent(n *Node) {
+func (w *exportWriter) qualifiedIdent(n *ir.Node) {
 	// Ensure any referenced declarations are written out too.
 	w.p.pushDecl(n)
 
@@ -592,7 +593,7 @@ func (w *exportWriter) selector(s *types.Sym) {
 	} else {
 		pkg := w.currPkg
 		if types.IsExported(name) {
-			pkg = localpkg
+			pkg = ir.LocalPkg
 		}
 		if s.Pkg != pkg {
 			base.Fatalf("package mismatch in selector: %v in package %q, but want %q", s, s.Pkg.Path, pkg.Path)
@@ -633,7 +634,7 @@ func (w *exportWriter) startType(k itag) {
 
 func (w *exportWriter) doTyp(t *types.Type) {
 	if t.Sym != nil {
-		if t.Sym.Pkg == builtinpkg || t.Sym.Pkg == unsafepkg {
+		if t.Sym.Pkg == ir.BuiltinPkg || t.Sym.Pkg == unsafepkg {
 			base.Fatalf("builtin type missing from typIndex: %v", t)
 		}
 
@@ -643,35 +644,35 @@ func (w *exportWriter) doTyp(t *types.Type) {
 	}
 
 	switch t.Etype {
-	case TPTR:
+	case types.TPTR:
 		w.startType(pointerType)
 		w.typ(t.Elem())
 
-	case TSLICE:
+	case types.TSLICE:
 		w.startType(sliceType)
 		w.typ(t.Elem())
 
-	case TARRAY:
+	case types.TARRAY:
 		w.startType(arrayType)
 		w.uint64(uint64(t.NumElem()))
 		w.typ(t.Elem())
 
-	case TCHAN:
+	case types.TCHAN:
 		w.startType(chanType)
 		w.uint64(uint64(t.ChanDir()))
 		w.typ(t.Elem())
 
-	case TMAP:
+	case types.TMAP:
 		w.startType(mapType)
 		w.typ(t.Key())
 		w.typ(t.Elem())
 
-	case TFUNC:
+	case types.TFUNC:
 		w.startType(signatureType)
 		w.setPkg(t.Pkg(), true)
 		w.signature(t)
 
-	case TSTRUCT:
+	case types.TSTRUCT:
 		w.startType(structType)
 		w.setPkg(t.Pkg(), true)
 
@@ -684,7 +685,7 @@ func (w *exportWriter) doTyp(t *types.Type) {
 			w.string(f.Note)
 		}
 
-	case TINTER:
+	case types.TINTER:
 		var embeddeds, methods []*types.Field
 		for _, m := range t.Methods().Slice() {
 			if m.Sym != nil {
@@ -719,7 +720,7 @@ func (w *exportWriter) setPkg(pkg *types.Pkg, write bool) {
 	if pkg == nil {
 		// TODO(mdempsky): Proactively set Pkg for types and
 		// remove this fallback logic.
-		pkg = localpkg
+		pkg = ir.LocalPkg
 	}
 
 	if write {
@@ -746,7 +747,7 @@ func (w *exportWriter) paramList(fs []*types.Field) {
 
 func (w *exportWriter) param(f *types.Field) {
 	w.pos(f.Pos)
-	w.localIdent(origSym(f.Sym), 0)
+	w.localIdent(ir.OrigSym(f.Sym), 0)
 	w.typ(f.Type)
 }
 
@@ -761,16 +762,16 @@ func constTypeOf(typ *types.Type) constant.Kind {
 	}
 
 	switch typ.Etype {
-	case TBOOL:
+	case types.TBOOL:
 		return constant.Bool
-	case TSTRING:
+	case types.TSTRING:
 		return constant.String
-	case TINT, TINT8, TINT16, TINT32, TINT64,
-		TUINT, TUINT8, TUINT16, TUINT32, TUINT64, TUINTPTR:
+	case types.TINT, types.TINT8, types.TINT16, types.TINT32, types.TINT64,
+		types.TUINT, types.TUINT8, types.TUINT16, types.TUINT32, types.TUINT64, types.TUINTPTR:
 		return constant.Int
-	case TFLOAT32, TFLOAT64:
+	case types.TFLOAT32, types.TFLOAT64:
 		return constant.Float
-	case TCOMPLEX64, TCOMPLEX128:
+	case types.TCOMPLEX64, types.TCOMPLEX128:
 		return constant.Complex
 	}
 
@@ -779,7 +780,7 @@ func constTypeOf(typ *types.Type) constant.Kind {
 }
 
 func (w *exportWriter) value(typ *types.Type, v constant.Value) {
-	assertRepresents(typ, v)
+	ir.AssertValidTypeForConst(typ, v)
 	w.typ(typ)
 
 	// Each type has only one admissible constant representation,
@@ -808,9 +809,9 @@ func intSize(typ *types.Type) (signed bool, maxBytes uint) {
 	}
 
 	switch typ.Etype {
-	case TFLOAT32, TCOMPLEX64:
+	case types.TFLOAT32, types.TCOMPLEX64:
 		return true, 3
-	case TFLOAT64, TCOMPLEX128:
+	case types.TFLOAT64, types.TCOMPLEX128:
 		return true, 7
 	}
 
@@ -820,7 +821,7 @@ func intSize(typ *types.Type) (signed bool, maxBytes uint) {
 	// The go/types API doesn't expose sizes to importers, so they
 	// don't know how big these types are.
 	switch typ.Etype {
-	case TINT, TUINT, TUINTPTR:
+	case types.TINT, types.TUINT, types.TUINTPTR:
 		maxBytes = 8
 	}
 
@@ -954,12 +955,12 @@ func (w *exportWriter) string(s string) { w.uint64(w.p.stringOff(s)) }
 
 // Compiler-specific extensions.
 
-func (w *exportWriter) varExt(n *Node) {
+func (w *exportWriter) varExt(n *ir.Node) {
 	w.linkname(n.Sym)
 	w.symIdx(n.Sym)
 }
 
-func (w *exportWriter) funcExt(n *Node) {
+func (w *exportWriter) funcExt(n *ir.Node) {
 	w.linkname(n.Sym)
 	w.symIdx(n.Sym)
 
@@ -993,7 +994,7 @@ func (w *exportWriter) funcExt(n *Node) {
 
 func (w *exportWriter) methExt(m *types.Field) {
 	w.bool(m.Nointerface())
-	w.funcExt(asNode(m.Nname))
+	w.funcExt(ir.AsNode(m.Nname))
 }
 
 func (w *exportWriter) linkname(s *types.Sym) {
@@ -1029,15 +1030,15 @@ func (w *exportWriter) typeExt(t *types.Type) {
 
 // Inline bodies.
 
-func (w *exportWriter) stmtList(list Nodes) {
+func (w *exportWriter) stmtList(list ir.Nodes) {
 	for _, n := range list.Slice() {
 		w.node(n)
 	}
-	w.op(OEND)
+	w.op(ir.OEND)
 }
 
-func (w *exportWriter) node(n *Node) {
-	if opprec[n.Op] < 0 {
+func (w *exportWriter) node(n *ir.Node) {
+	if ir.OpPrec[n.Op] < 0 {
 		w.stmt(n)
 	} else {
 		w.expr(n)
@@ -1046,8 +1047,8 @@ func (w *exportWriter) node(n *Node) {
 
 // Caution: stmt will emit more than one node for statement nodes n that have a non-empty
 // n.Ninit and where n cannot have a natural init section (such as in "if", "for", etc.).
-func (w *exportWriter) stmt(n *Node) {
-	if n.Ninit.Len() > 0 && !stmtwithinit(n.Op) {
+func (w *exportWriter) stmt(n *ir.Node) {
+	if n.Ninit.Len() > 0 && !ir.StmtWithInit(n.Op) {
 		// can't use stmtList here since we don't want the final OEND
 		for _, n := range n.Ninit.Slice() {
 			w.stmt(n)
@@ -1055,8 +1056,8 @@ func (w *exportWriter) stmt(n *Node) {
 	}
 
 	switch op := n.Op; op {
-	case ODCL:
-		w.op(ODCL)
+	case ir.ODCL:
+		w.op(ir.ODCL)
 		w.pos(n.Left.Pos)
 		w.localName(n.Left)
 		w.typ(n.Left.Type)
@@ -1064,19 +1065,19 @@ func (w *exportWriter) stmt(n *Node) {
 	// case ODCLFIELD:
 	//	unimplemented - handled by default case
 
-	case OAS:
+	case ir.OAS:
 		// Don't export "v = <N>" initializing statements, hope they're always
 		// preceded by the DCL which will be re-parsed and typecheck to reproduce
 		// the "v = <N>" again.
 		if n.Right != nil {
-			w.op(OAS)
+			w.op(ir.OAS)
 			w.pos(n.Pos)
 			w.expr(n.Left)
 			w.expr(n.Right)
 		}
 
-	case OASOP:
-		w.op(OASOP)
+	case ir.OASOP:
+		w.op(ir.OASOP)
 		w.pos(n.Pos)
 		w.op(n.SubOp())
 		w.expr(n.Left)
@@ -1084,54 +1085,54 @@ func (w *exportWriter) stmt(n *Node) {
 			w.expr(n.Right)
 		}
 
-	case OAS2:
-		w.op(OAS2)
+	case ir.OAS2:
+		w.op(ir.OAS2)
 		w.pos(n.Pos)
 		w.exprList(n.List)
 		w.exprList(n.Rlist)
 
-	case OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV:
-		w.op(OAS2)
+	case ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV:
+		w.op(ir.OAS2)
 		w.pos(n.Pos)
 		w.exprList(n.List)
-		w.exprList(asNodes([]*Node{n.Right}))
+		w.exprList(ir.AsNodes([]*ir.Node{n.Right}))
 
-	case ORETURN:
-		w.op(ORETURN)
+	case ir.ORETURN:
+		w.op(ir.ORETURN)
 		w.pos(n.Pos)
 		w.exprList(n.List)
 
 	// case ORETJMP:
 	// 	unreachable - generated by compiler for trampolin routines
 
-	case OGO, ODEFER:
+	case ir.OGO, ir.ODEFER:
 		w.op(op)
 		w.pos(n.Pos)
 		w.expr(n.Left)
 
-	case OIF:
-		w.op(OIF)
+	case ir.OIF:
+		w.op(ir.OIF)
 		w.pos(n.Pos)
 		w.stmtList(n.Ninit)
 		w.expr(n.Left)
 		w.stmtList(n.Nbody)
 		w.stmtList(n.Rlist)
 
-	case OFOR:
-		w.op(OFOR)
+	case ir.OFOR:
+		w.op(ir.OFOR)
 		w.pos(n.Pos)
 		w.stmtList(n.Ninit)
 		w.exprsOrNil(n.Left, n.Right)
 		w.stmtList(n.Nbody)
 
-	case ORANGE:
-		w.op(ORANGE)
+	case ir.ORANGE:
+		w.op(ir.ORANGE)
 		w.pos(n.Pos)
 		w.stmtList(n.List)
 		w.expr(n.Right)
 		w.stmtList(n.Nbody)
 
-	case OSELECT, OSWITCH:
+	case ir.OSELECT, ir.OSWITCH:
 		w.op(op)
 		w.pos(n.Pos)
 		w.stmtList(n.Ninit)
@@ -1141,19 +1142,19 @@ func (w *exportWriter) stmt(n *Node) {
 	// case OCASE:
 	//	handled by caseList
 
-	case OFALL:
-		w.op(OFALL)
+	case ir.OFALL:
+		w.op(ir.OFALL)
 		w.pos(n.Pos)
 
-	case OBREAK, OCONTINUE:
+	case ir.OBREAK, ir.OCONTINUE:
 		w.op(op)
 		w.pos(n.Pos)
 		w.exprsOrNil(n.Left, nil)
 
-	case OEMPTY:
+	case ir.OEMPTY:
 		// nothing to emit
 
-	case OGOTO, OLABEL:
+	case ir.OGOTO, ir.OLABEL:
 		w.op(op)
 		w.pos(n.Pos)
 		w.string(n.Sym.Name)
@@ -1163,13 +1164,13 @@ func (w *exportWriter) stmt(n *Node) {
 	}
 }
 
-func (w *exportWriter) caseList(sw *Node) {
-	namedTypeSwitch := sw.Op == OSWITCH && sw.Left != nil && sw.Left.Op == OTYPESW && sw.Left.Left != nil
+func (w *exportWriter) caseList(sw *ir.Node) {
+	namedTypeSwitch := sw.Op == ir.OSWITCH && sw.Left != nil && sw.Left.Op == ir.OTYPESW && sw.Left.Left != nil
 
 	cases := sw.List.Slice()
 	w.uint64(uint64(len(cases)))
 	for _, cas := range cases {
-		if cas.Op != OCASE {
+		if cas.Op != ir.OCASE {
 			base.Fatalf("expected OCASE, got %v", cas)
 		}
 		w.pos(cas.Pos)
@@ -1181,14 +1182,14 @@ func (w *exportWriter) caseList(sw *Node) {
 	}
 }
 
-func (w *exportWriter) exprList(list Nodes) {
+func (w *exportWriter) exprList(list ir.Nodes) {
 	for _, n := range list.Slice() {
 		w.expr(n)
 	}
-	w.op(OEND)
+	w.op(ir.OEND)
 }
 
-func (w *exportWriter) expr(n *Node) {
+func (w *exportWriter) expr(n *ir.Node) {
 	// from nodefmt (fmt.go)
 	//
 	// nodefmt reverts nodes back to their original - we don't need to do
@@ -1199,14 +1200,14 @@ func (w *exportWriter) expr(n *Node) {
 	// }
 
 	// from exprfmt (fmt.go)
-	for n.Op == OPAREN || n.Implicit() && (n.Op == ODEREF || n.Op == OADDR || n.Op == ODOT || n.Op == ODOTPTR) {
+	for n.Op == ir.OPAREN || n.Implicit() && (n.Op == ir.ODEREF || n.Op == ir.OADDR || n.Op == ir.ODOT || n.Op == ir.ODOTPTR) {
 		n = n.Left
 	}
 
 	switch op := n.Op; op {
 	// expressions
 	// (somewhat closely following the structure of exprfmt in fmt.go)
-	case ONIL:
+	case ir.ONIL:
 		if !n.Type.HasNil() {
 			base.Fatalf("unexpected type for nil: %v", n.Type)
 		}
@@ -1214,49 +1215,49 @@ func (w *exportWriter) expr(n *Node) {
 			w.expr(n.Orig)
 			break
 		}
-		w.op(OLITERAL)
+		w.op(ir.OLITERAL)
 		w.pos(n.Pos)
 		w.typ(n.Type)
 
-	case OLITERAL:
-		w.op(OLITERAL)
+	case ir.OLITERAL:
+		w.op(ir.OLITERAL)
 		w.pos(n.Pos)
 		w.value(n.Type, n.Val())
 
-	case OMETHEXPR:
+	case ir.OMETHEXPR:
 		// Special case: explicit name of func (*T) method(...) is turned into pkg.(*T).method,
 		// but for export, this should be rendered as (*pkg.T).meth.
 		// These nodes have the special property that they are names with a left OTYPE and a right ONAME.
-		w.op(OXDOT)
+		w.op(ir.OXDOT)
 		w.pos(n.Pos)
 		w.expr(n.Left) // n.Left.Op == OTYPE
 		w.selector(n.Right.Sym)
 
-	case ONAME:
+	case ir.ONAME:
 		// Package scope name.
-		if (n.Class() == PEXTERN || n.Class() == PFUNC) && !n.isBlank() {
-			w.op(ONONAME)
+		if (n.Class() == ir.PEXTERN || n.Class() == ir.PFUNC) && !ir.IsBlank(n) {
+			w.op(ir.ONONAME)
 			w.qualifiedIdent(n)
 			break
 		}
 
 		// Function scope name.
-		w.op(ONAME)
+		w.op(ir.ONAME)
 		w.localName(n)
 
 	// case OPACK, ONONAME:
 	// 	should have been resolved by typechecking - handled by default case
 
-	case OTYPE:
-		w.op(OTYPE)
+	case ir.OTYPE:
+		w.op(ir.OTYPE)
 		w.typ(n.Type)
 
-	case OTYPESW:
-		w.op(OTYPESW)
+	case ir.OTYPESW:
+		w.op(ir.OTYPESW)
 		w.pos(n.Pos)
 		var s *types.Sym
 		if n.Left != nil {
-			if n.Left.Op != ONONAME {
+			if n.Left.Op != ir.ONONAME {
 				base.Fatalf("expected ONONAME, got %v", n.Left)
 			}
 			s = n.Left.Sym
@@ -1273,149 +1274,149 @@ func (w *exportWriter) expr(n *Node) {
 	// case OCOMPLIT:
 	// 	should have been resolved by typechecking - handled by default case
 
-	case OPTRLIT:
-		w.op(OADDR)
+	case ir.OPTRLIT:
+		w.op(ir.OADDR)
 		w.pos(n.Pos)
 		w.expr(n.Left)
 
-	case OSTRUCTLIT:
-		w.op(OSTRUCTLIT)
+	case ir.OSTRUCTLIT:
+		w.op(ir.OSTRUCTLIT)
 		w.pos(n.Pos)
 		w.typ(n.Type)
 		w.elemList(n.List) // special handling of field names
 
-	case OARRAYLIT, OSLICELIT, OMAPLIT:
-		w.op(OCOMPLIT)
+	case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT:
+		w.op(ir.OCOMPLIT)
 		w.pos(n.Pos)
 		w.typ(n.Type)
 		w.exprList(n.List)
 
-	case OKEY:
-		w.op(OKEY)
+	case ir.OKEY:
+		w.op(ir.OKEY)
 		w.pos(n.Pos)
 		w.exprsOrNil(n.Left, n.Right)
 
 	// case OSTRUCTKEY:
 	//	unreachable - handled in case OSTRUCTLIT by elemList
 
-	case OCALLPART:
+	case ir.OCALLPART:
 		// An OCALLPART is an OXDOT before type checking.
-		w.op(OXDOT)
+		w.op(ir.OXDOT)
 		w.pos(n.Pos)
 		w.expr(n.Left)
 		// Right node should be ONAME
 		w.selector(n.Right.Sym)
 
-	case OXDOT, ODOT, ODOTPTR, ODOTINTER, ODOTMETH:
-		w.op(OXDOT)
+	case ir.OXDOT, ir.ODOT, ir.ODOTPTR, ir.ODOTINTER, ir.ODOTMETH:
+		w.op(ir.OXDOT)
 		w.pos(n.Pos)
 		w.expr(n.Left)
 		w.selector(n.Sym)
 
-	case ODOTTYPE, ODOTTYPE2:
-		w.op(ODOTTYPE)
+	case ir.ODOTTYPE, ir.ODOTTYPE2:
+		w.op(ir.ODOTTYPE)
 		w.pos(n.Pos)
 		w.expr(n.Left)
 		w.typ(n.Type)
 
-	case OINDEX, OINDEXMAP:
-		w.op(OINDEX)
+	case ir.OINDEX, ir.OINDEXMAP:
+		w.op(ir.OINDEX)
 		w.pos(n.Pos)
 		w.expr(n.Left)
 		w.expr(n.Right)
 
-	case OSLICE, OSLICESTR, OSLICEARR:
-		w.op(OSLICE)
+	case ir.OSLICE, ir.OSLICESTR, ir.OSLICEARR:
+		w.op(ir.OSLICE)
 		w.pos(n.Pos)
 		w.expr(n.Left)
 		low, high, _ := n.SliceBounds()
 		w.exprsOrNil(low, high)
 
-	case OSLICE3, OSLICE3ARR:
-		w.op(OSLICE3)
+	case ir.OSLICE3, ir.OSLICE3ARR:
+		w.op(ir.OSLICE3)
 		w.pos(n.Pos)
 		w.expr(n.Left)
 		low, high, max := n.SliceBounds()
 		w.exprsOrNil(low, high)
 		w.expr(max)
 
-	case OCOPY, OCOMPLEX:
+	case ir.OCOPY, ir.OCOMPLEX:
 		// treated like other builtin calls (see e.g., OREAL)
 		w.op(op)
 		w.pos(n.Pos)
 		w.expr(n.Left)
 		w.expr(n.Right)
-		w.op(OEND)
+		w.op(ir.OEND)
 
-	case OCONV, OCONVIFACE, OCONVNOP, OBYTES2STR, ORUNES2STR, OSTR2BYTES, OSTR2RUNES, ORUNESTR:
-		w.op(OCONV)
+	case ir.OCONV, ir.OCONVIFACE, ir.OCONVNOP, ir.OBYTES2STR, ir.ORUNES2STR, ir.OSTR2BYTES, ir.OSTR2RUNES, ir.ORUNESTR:
+		w.op(ir.OCONV)
 		w.pos(n.Pos)
 		w.expr(n.Left)
 		w.typ(n.Type)
 
-	case OREAL, OIMAG, OAPPEND, OCAP, OCLOSE, ODELETE, OLEN, OMAKE, ONEW, OPANIC, ORECOVER, OPRINT, OPRINTN:
+	case ir.OREAL, ir.OIMAG, ir.OAPPEND, ir.OCAP, ir.OCLOSE, ir.ODELETE, ir.OLEN, ir.OMAKE, ir.ONEW, ir.OPANIC, ir.ORECOVER, ir.OPRINT, ir.OPRINTN:
 		w.op(op)
 		w.pos(n.Pos)
 		if n.Left != nil {
 			w.expr(n.Left)
-			w.op(OEND)
+			w.op(ir.OEND)
 		} else {
 			w.exprList(n.List) // emits terminating OEND
 		}
 		// only append() calls may contain '...' arguments
-		if op == OAPPEND {
+		if op == ir.OAPPEND {
 			w.bool(n.IsDDD())
 		} else if n.IsDDD() {
 			base.Fatalf("exporter: unexpected '...' with %v call", op)
 		}
 
-	case OCALL, OCALLFUNC, OCALLMETH, OCALLINTER, OGETG:
-		w.op(OCALL)
+	case ir.OCALL, ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER, ir.OGETG:
+		w.op(ir.OCALL)
 		w.pos(n.Pos)
 		w.stmtList(n.Ninit)
 		w.expr(n.Left)
 		w.exprList(n.List)
 		w.bool(n.IsDDD())
 
-	case OMAKEMAP, OMAKECHAN, OMAKESLICE:
+	case ir.OMAKEMAP, ir.OMAKECHAN, ir.OMAKESLICE:
 		w.op(op) // must keep separate from OMAKE for importer
 		w.pos(n.Pos)
 		w.typ(n.Type)
 		switch {
 		default:
 			// empty list
-			w.op(OEND)
+			w.op(ir.OEND)
 		case n.List.Len() != 0: // pre-typecheck
 			w.exprList(n.List) // emits terminating OEND
 		case n.Right != nil:
 			w.expr(n.Left)
 			w.expr(n.Right)
-			w.op(OEND)
-		case n.Left != nil && (n.Op == OMAKESLICE || !n.Left.Type.IsUntyped()):
+			w.op(ir.OEND)
+		case n.Left != nil && (n.Op == ir.OMAKESLICE || !n.Left.Type.IsUntyped()):
 			w.expr(n.Left)
-			w.op(OEND)
+			w.op(ir.OEND)
 		}
 
 	// unary expressions
-	case OPLUS, ONEG, OADDR, OBITNOT, ODEREF, ONOT, ORECV:
+	case ir.OPLUS, ir.ONEG, ir.OADDR, ir.OBITNOT, ir.ODEREF, ir.ONOT, ir.ORECV:
 		w.op(op)
 		w.pos(n.Pos)
 		w.expr(n.Left)
 
 	// binary expressions
-	case OADD, OAND, OANDAND, OANDNOT, ODIV, OEQ, OGE, OGT, OLE, OLT,
-		OLSH, OMOD, OMUL, ONE, OOR, OOROR, ORSH, OSEND, OSUB, OXOR:
+	case ir.OADD, ir.OAND, ir.OANDAND, ir.OANDNOT, ir.ODIV, ir.OEQ, ir.OGE, ir.OGT, ir.OLE, ir.OLT,
+		ir.OLSH, ir.OMOD, ir.OMUL, ir.ONE, ir.OOR, ir.OOROR, ir.ORSH, ir.OSEND, ir.OSUB, ir.OXOR:
 		w.op(op)
 		w.pos(n.Pos)
 		w.expr(n.Left)
 		w.expr(n.Right)
 
-	case OADDSTR:
-		w.op(OADDSTR)
+	case ir.OADDSTR:
+		w.op(ir.OADDSTR)
 		w.pos(n.Pos)
 		w.exprList(n.List)
 
-	case ODCLCONST:
+	case ir.ODCLCONST:
 		// if exporting, DCLCONST should just be removed as its usage
 		// has already been replaced with literals
 
@@ -1425,11 +1426,11 @@ func (w *exportWriter) expr(n *Node) {
 	}
 }
 
-func (w *exportWriter) op(op Op) {
+func (w *exportWriter) op(op ir.Op) {
 	w.uint64(uint64(op))
 }
 
-func (w *exportWriter) exprsOrNil(a, b *Node) {
+func (w *exportWriter) exprsOrNil(a, b *ir.Node) {
 	ab := 0
 	if a != nil {
 		ab |= 1
@@ -1446,7 +1447,7 @@ func (w *exportWriter) exprsOrNil(a, b *Node) {
 	}
 }
 
-func (w *exportWriter) elemList(list Nodes) {
+func (w *exportWriter) elemList(list ir.Nodes) {
 	w.uint64(uint64(list.Len()))
 	for _, n := range list.Slice() {
 		w.selector(n.Sym)
@@ -1454,7 +1455,7 @@ func (w *exportWriter) elemList(list Nodes) {
 	}
 }
 
-func (w *exportWriter) localName(n *Node) {
+func (w *exportWriter) localName(n *ir.Node) {
 	// Escape analysis happens after inline bodies are saved, but
 	// we're using the same ONAME nodes, so we might still see
 	// PAUTOHEAP here.
@@ -1463,7 +1464,7 @@ func (w *exportWriter) localName(n *Node) {
 	// PPARAM/PPARAMOUT, because we only want to include vargen in
 	// non-param names.
 	var v int32
-	if n.Class() == PAUTO || (n.Class() == PAUTOHEAP && n.Name.Param.Stackcopy == nil) {
+	if n.Class() == ir.PAUTO || (n.Class() == ir.PAUTOHEAP && n.Name.Param.Stackcopy == nil) {
 		v = n.Name.Vargen
 	}
 
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index cc0209ed03..84386140bb 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -9,6 +9,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/bio"
 	"cmd/internal/goobj"
@@ -40,8 +41,8 @@ var (
 	inlineImporter = map[*types.Sym]iimporterAndOffset{}
 )
 
-func expandDecl(n *Node) {
-	if n.Op != ONONAME {
+func expandDecl(n *ir.Node) {
+	if n.Op != ir.ONONAME {
 		return
 	}
 
@@ -54,7 +55,7 @@ func expandDecl(n *Node) {
 	r.doDecl(n)
 }
 
-func expandInline(fn *Node) {
+func expandInline(fn *ir.Node) {
 	if fn.Func.Inl.Body != nil {
 		return
 	}
@@ -67,7 +68,7 @@ func expandInline(fn *Node) {
 	r.doInline(fn)
 }
 
-func importReaderFor(n *Node, importers map[*types.Sym]iimporterAndOffset) *importReader {
+func importReaderFor(n *ir.Node, importers map[*types.Sym]iimporterAndOffset) *importReader {
 	x, ok := importers[n.Sym]
 	if !ok {
 		return nil
@@ -147,10 +148,10 @@ func iimport(pkg *types.Pkg, in *bio.Reader) (fingerprint goobj.FingerprintType)
 		if pkg.Name == "" {
 			pkg.Name = pkgName
 			pkg.Height = pkgHeight
-			numImport[pkgName]++
+			ir.NumImport[pkgName]++
 
 			// TODO(mdempsky): This belongs somewhere else.
-			pkg.Lookup("_").Def = asTypesNode(nblank)
+			pkg.Lookup("_").Def = ir.AsTypesNode(ir.BlankNode)
 		} else {
 			if pkg.Name != pkgName {
 				base.Fatalf("conflicting package names %v and %v for path %q", pkg.Name, pkgName, pkg.Path)
@@ -172,9 +173,9 @@ func iimport(pkg *types.Pkg, in *bio.Reader) (fingerprint goobj.FingerprintType)
 			// Create stub declaration. If used, this will
 			// be overwritten by expandDecl.
 			if s.Def != nil {
-				base.Fatalf("unexpected definition for %v: %v", s, asNode(s.Def))
+				base.Fatalf("unexpected definition for %v: %v", s, ir.AsNode(s.Def))
 			}
-			s.Def = asTypesNode(npos(src.NoXPos, dclname(s)))
+			s.Def = ir.AsTypesNode(npos(src.NoXPos, dclname(s)))
 		}
 	}
 
@@ -280,8 +281,8 @@ func (r *importReader) setPkg() {
 	r.currPkg = r.pkg()
 }
 
-func (r *importReader) doDecl(n *Node) {
-	if n.Op != ONONAME {
+func (r *importReader) doDecl(n *ir.Node) {
+	if n.Op != ir.ONONAME {
 		base.Fatalf("doDecl: unexpected Op for %v: %v", n.Sym, n.Op)
 	}
 
@@ -330,13 +331,13 @@ func (r *importReader) doDecl(n *Node) {
 			recv := r.param()
 			mtyp := r.signature(recv)
 
-			m := newfuncnamel(mpos, methodSym(recv.Type, msym), new(Func))
+			m := newfuncnamel(mpos, methodSym(recv.Type, msym), new(ir.Func))
 			m.Type = mtyp
-			m.SetClass(PFUNC)
+			m.SetClass(ir.PFUNC)
 			// methodSym already marked m.Sym as a function.
 
 			f := types.NewField(mpos, msym, mtyp)
-			f.Nname = asTypesNode(m)
+			f.Nname = ir.AsTypesNode(m)
 			ms[i] = f
 		}
 		t.Methods().Set(ms)
@@ -434,7 +435,7 @@ func (r *importReader) ident() *types.Sym {
 	}
 	pkg := r.currPkg
 	if types.IsExported(name) {
-		pkg = localpkg
+		pkg = ir.LocalPkg
 	}
 	return pkg.Lookup(name)
 }
@@ -498,11 +499,11 @@ func (r *importReader) typ1() *types.Type {
 		// support inlining functions with local defined
 		// types. Therefore, this must be a package-scope
 		// type.
-		n := asNode(r.qualifiedIdent().PkgDef())
-		if n.Op == ONONAME {
+		n := ir.AsNode(r.qualifiedIdent().PkgDef())
+		if n.Op == ir.ONONAME {
 			expandDecl(n)
 		}
-		if n.Op != OTYPE {
+		if n.Op != ir.OTYPE {
 			base.Fatalf("expected OTYPE, got %v: %v, %v", n.Op, n.Sym, n)
 		}
 		return n.Type
@@ -542,7 +543,7 @@ func (r *importReader) typ1() *types.Type {
 			fs[i] = f
 		}
 
-		t := types.New(TSTRUCT)
+		t := types.New(types.TSTRUCT)
 		t.SetPkg(r.currPkg)
 		t.SetFields(fs)
 		return t
@@ -567,7 +568,7 @@ func (r *importReader) typ1() *types.Type {
 			methods[i] = types.NewField(pos, sym, typ)
 		}
 
-		t := types.New(TINTER)
+		t := types.New(types.TINTER)
 		t.SetPkg(r.currPkg)
 		t.SetInterface(append(embeddeds, methods...))
 
@@ -634,12 +635,12 @@ func (r *importReader) byte() byte {
 
 // Compiler-specific extensions.
 
-func (r *importReader) varExt(n *Node) {
+func (r *importReader) varExt(n *ir.Node) {
 	r.linkname(n.Sym)
 	r.symIdx(n.Sym)
 }
 
-func (r *importReader) funcExt(n *Node) {
+func (r *importReader) funcExt(n *ir.Node) {
 	r.linkname(n.Sym)
 	r.symIdx(n.Sym)
 
@@ -652,7 +653,7 @@ func (r *importReader) funcExt(n *Node) {
 
 	// Inline body.
 	if u := r.uint64(); u > 0 {
-		n.Func.Inl = &Inline{
+		n.Func.Inl = &ir.Inline{
 			Cost: int32(u - 1),
 		}
 		n.Func.Endlineno = r.pos()
@@ -663,7 +664,7 @@ func (r *importReader) methExt(m *types.Field) {
 	if r.bool() {
 		m.SetNointerface(true)
 	}
-	r.funcExt(asNode(m.Nname))
+	r.funcExt(ir.AsNode(m.Nname))
 }
 
 func (r *importReader) linkname(s *types.Sym) {
@@ -694,7 +695,7 @@ func (r *importReader) typeExt(t *types.Type) {
 // so we can use index to reference the symbol.
 var typeSymIdx = make(map[*types.Type][2]int64)
 
-func (r *importReader) doInline(n *Node) {
+func (r *importReader) doInline(n *ir.Node) {
 	if len(n.Func.Inl.Body) != 0 {
 		base.Fatalf("%v already has inline body", n)
 	}
@@ -709,7 +710,7 @@ func (r *importReader) doInline(n *Node) {
 		// (not doing so can cause significant performance
 		// degradation due to unnecessary calls to empty
 		// functions).
-		body = []*Node{}
+		body = []*ir.Node{}
 	}
 	n.Func.Inl.Body = body
 
@@ -717,9 +718,9 @@ func (r *importReader) doInline(n *Node) {
 
 	if base.Flag.E > 0 && base.Flag.LowerM > 2 {
 		if base.Flag.LowerM > 3 {
-			fmt.Printf("inl body for %v %#v: %+v\n", n, n.Type, asNodes(n.Func.Inl.Body))
+			fmt.Printf("inl body for %v %#v: %+v\n", n, n.Type, ir.AsNodes(n.Func.Inl.Body))
 		} else {
-			fmt.Printf("inl body for %v %#v: %v\n", n, n.Type, asNodes(n.Func.Inl.Body))
+			fmt.Printf("inl body for %v %#v: %v\n", n, n.Type, ir.AsNodes(n.Func.Inl.Body))
 		}
 	}
 }
@@ -739,15 +740,15 @@ func (r *importReader) doInline(n *Node) {
 // unrefined nodes (since this is what the importer uses). The respective case
 // entries are unreachable in the importer.
 
-func (r *importReader) stmtList() []*Node {
-	var list []*Node
+func (r *importReader) stmtList() []*ir.Node {
+	var list []*ir.Node
 	for {
 		n := r.node()
 		if n == nil {
 			break
 		}
 		// OBLOCK nodes may be created when importing ODCL nodes - unpack them
-		if n.Op == OBLOCK {
+		if n.Op == ir.OBLOCK {
 			list = append(list, n.List.Slice()...)
 		} else {
 			list = append(list, n)
@@ -757,18 +758,18 @@ func (r *importReader) stmtList() []*Node {
 	return list
 }
 
-func (r *importReader) caseList(sw *Node) []*Node {
-	namedTypeSwitch := sw.Op == OSWITCH && sw.Left != nil && sw.Left.Op == OTYPESW && sw.Left.Left != nil
+func (r *importReader) caseList(sw *ir.Node) []*ir.Node {
+	namedTypeSwitch := sw.Op == ir.OSWITCH && sw.Left != nil && sw.Left.Op == ir.OTYPESW && sw.Left.Left != nil
 
-	cases := make([]*Node, r.uint64())
+	cases := make([]*ir.Node, r.uint64())
 	for i := range cases {
-		cas := nodl(r.pos(), OCASE, nil, nil)
+		cas := ir.NodAt(r.pos(), ir.OCASE, nil, nil)
 		cas.List.Set(r.stmtList())
 		if namedTypeSwitch {
 			// Note: per-case variables will have distinct, dotted
 			// names after import. That's okay: swt.go only needs
 			// Sym for diagnostics anyway.
-			caseVar := newnamel(cas.Pos, r.ident())
+			caseVar := ir.NewNameAt(cas.Pos, r.ident())
 			declare(caseVar, dclcontext)
 			cas.Rlist.Set1(caseVar)
 			caseVar.Name.Defn = sw.Left
@@ -779,8 +780,8 @@ func (r *importReader) caseList(sw *Node) []*Node {
 	return cases
 }
 
-func (r *importReader) exprList() []*Node {
-	var list []*Node
+func (r *importReader) exprList() []*ir.Node {
+	var list []*ir.Node
 	for {
 		n := r.expr()
 		if n == nil {
@@ -791,16 +792,16 @@ func (r *importReader) exprList() []*Node {
 	return list
 }
 
-func (r *importReader) expr() *Node {
+func (r *importReader) expr() *ir.Node {
 	n := r.node()
-	if n != nil && n.Op == OBLOCK {
+	if n != nil && n.Op == ir.OBLOCK {
 		base.Fatalf("unexpected block node: %v", n)
 	}
 	return n
 }
 
 // TODO(gri) split into expr and stmt
-func (r *importReader) node() *Node {
+func (r *importReader) node() *ir.Node {
 	switch op := r.op(); op {
 	// expressions
 	// case OPAREN:
@@ -809,34 +810,34 @@ func (r *importReader) node() *Node {
 	// case ONIL:
 	//	unreachable - mapped to OLITERAL
 
-	case OLITERAL:
+	case ir.OLITERAL:
 		pos := r.pos()
 		typ := r.typ()
 
-		var n *Node
+		var n *ir.Node
 		if typ.HasNil() {
 			n = nodnil()
 		} else {
-			n = nodlit(r.value(typ))
+			n = ir.NewLiteral(r.value(typ))
 		}
 		n = npos(pos, n)
 		n.Type = typ
 		return n
 
-	case ONONAME:
+	case ir.ONONAME:
 		return mkname(r.qualifiedIdent())
 
-	case ONAME:
+	case ir.ONAME:
 		return mkname(r.ident())
 
 	// case OPACK, ONONAME:
 	// 	unreachable - should have been resolved by typechecking
 
-	case OTYPE:
+	case ir.OTYPE:
 		return typenod(r.typ())
 
-	case OTYPESW:
-		n := nodl(r.pos(), OTYPESW, nil, nil)
+	case ir.OTYPESW:
+		n := ir.NodAt(r.pos(), ir.OTYPESW, nil, nil)
 		if s := r.ident(); s != nil {
 			n.Left = npos(n.Pos, newnoname(s))
 		}
@@ -853,11 +854,11 @@ func (r *importReader) node() *Node {
 	// case OPTRLIT:
 	//	unreachable - mapped to case OADDR below by exporter
 
-	case OSTRUCTLIT:
+	case ir.OSTRUCTLIT:
 		// TODO(mdempsky): Export position information for OSTRUCTKEY nodes.
 		savedlineno := base.Pos
 		base.Pos = r.pos()
-		n := nodl(base.Pos, OCOMPLIT, nil, typenod(r.typ()))
+		n := ir.NodAt(base.Pos, ir.OCOMPLIT, nil, typenod(r.typ()))
 		n.List.Set(r.elemList()) // special handling of field names
 		base.Pos = savedlineno
 		return n
@@ -865,15 +866,15 @@ func (r *importReader) node() *Node {
 	// case OARRAYLIT, OSLICELIT, OMAPLIT:
 	// 	unreachable - mapped to case OCOMPLIT below by exporter
 
-	case OCOMPLIT:
-		n := nodl(r.pos(), OCOMPLIT, nil, typenod(r.typ()))
+	case ir.OCOMPLIT:
+		n := ir.NodAt(r.pos(), ir.OCOMPLIT, nil, typenod(r.typ()))
 		n.List.Set(r.exprList())
 		return n
 
-	case OKEY:
+	case ir.OKEY:
 		pos := r.pos()
 		left, right := r.exprsOrNil()
-		return nodl(pos, OKEY, left, right)
+		return ir.NodAt(pos, ir.OKEY, left, right)
 
 	// case OSTRUCTKEY:
 	//	unreachable - handled in case OSTRUCTLIT by elemList
@@ -884,28 +885,28 @@ func (r *importReader) node() *Node {
 	// case OXDOT, ODOT, ODOTPTR, ODOTINTER, ODOTMETH:
 	// 	unreachable - mapped to case OXDOT below by exporter
 
-	case OXDOT:
+	case ir.OXDOT:
 		// see parser.new_dotname
-		return npos(r.pos(), nodSym(OXDOT, r.expr(), r.ident()))
+		return npos(r.pos(), nodSym(ir.OXDOT, r.expr(), r.ident()))
 
 	// case ODOTTYPE, ODOTTYPE2:
 	// 	unreachable - mapped to case ODOTTYPE below by exporter
 
-	case ODOTTYPE:
-		n := nodl(r.pos(), ODOTTYPE, r.expr(), nil)
+	case ir.ODOTTYPE:
+		n := ir.NodAt(r.pos(), ir.ODOTTYPE, r.expr(), nil)
 		n.Type = r.typ()
 		return n
 
 	// case OINDEX, OINDEXMAP, OSLICE, OSLICESTR, OSLICEARR, OSLICE3, OSLICE3ARR:
 	// 	unreachable - mapped to cases below by exporter
 
-	case OINDEX:
-		return nodl(r.pos(), op, r.expr(), r.expr())
+	case ir.OINDEX:
+		return ir.NodAt(r.pos(), op, r.expr(), r.expr())
 
-	case OSLICE, OSLICE3:
-		n := nodl(r.pos(), op, r.expr(), nil)
+	case ir.OSLICE, ir.OSLICE3:
+		n := ir.NodAt(r.pos(), op, r.expr(), nil)
 		low, high := r.exprsOrNil()
-		var max *Node
+		var max *ir.Node
 		if n.Op.IsSlice3() {
 			max = r.expr()
 		}
@@ -915,15 +916,15 @@ func (r *importReader) node() *Node {
 	// case OCONV, OCONVIFACE, OCONVNOP, OBYTES2STR, ORUNES2STR, OSTR2BYTES, OSTR2RUNES, ORUNESTR:
 	// 	unreachable - mapped to OCONV case below by exporter
 
-	case OCONV:
-		n := nodl(r.pos(), OCONV, r.expr(), nil)
+	case ir.OCONV:
+		n := ir.NodAt(r.pos(), ir.OCONV, r.expr(), nil)
 		n.Type = r.typ()
 		return n
 
-	case OCOPY, OCOMPLEX, OREAL, OIMAG, OAPPEND, OCAP, OCLOSE, ODELETE, OLEN, OMAKE, ONEW, OPANIC, ORECOVER, OPRINT, OPRINTN:
+	case ir.OCOPY, ir.OCOMPLEX, ir.OREAL, ir.OIMAG, ir.OAPPEND, ir.OCAP, ir.OCLOSE, ir.ODELETE, ir.OLEN, ir.OMAKE, ir.ONEW, ir.OPANIC, ir.ORECOVER, ir.OPRINT, ir.OPRINTN:
 		n := npos(r.pos(), builtinCall(op))
 		n.List.Set(r.exprList())
-		if op == OAPPEND {
+		if op == ir.OAPPEND {
 			n.SetIsDDD(r.bool())
 		}
 		return n
@@ -931,45 +932,45 @@ func (r *importReader) node() *Node {
 	// case OCALL, OCALLFUNC, OCALLMETH, OCALLINTER, OGETG:
 	// 	unreachable - mapped to OCALL case below by exporter
 
-	case OCALL:
-		n := nodl(r.pos(), OCALL, nil, nil)
+	case ir.OCALL:
+		n := ir.NodAt(r.pos(), ir.OCALL, nil, nil)
 		n.Ninit.Set(r.stmtList())
 		n.Left = r.expr()
 		n.List.Set(r.exprList())
 		n.SetIsDDD(r.bool())
 		return n
 
-	case OMAKEMAP, OMAKECHAN, OMAKESLICE:
-		n := npos(r.pos(), builtinCall(OMAKE))
+	case ir.OMAKEMAP, ir.OMAKECHAN, ir.OMAKESLICE:
+		n := npos(r.pos(), builtinCall(ir.OMAKE))
 		n.List.Append(typenod(r.typ()))
 		n.List.Append(r.exprList()...)
 		return n
 
 	// unary expressions
-	case OPLUS, ONEG, OADDR, OBITNOT, ODEREF, ONOT, ORECV:
-		return nodl(r.pos(), op, r.expr(), nil)
+	case ir.OPLUS, ir.ONEG, ir.OADDR, ir.OBITNOT, ir.ODEREF, ir.ONOT, ir.ORECV:
+		return ir.NodAt(r.pos(), op, r.expr(), nil)
 
 	// binary expressions
-	case OADD, OAND, OANDAND, OANDNOT, ODIV, OEQ, OGE, OGT, OLE, OLT,
-		OLSH, OMOD, OMUL, ONE, OOR, OOROR, ORSH, OSEND, OSUB, OXOR:
-		return nodl(r.pos(), op, r.expr(), r.expr())
+	case ir.OADD, ir.OAND, ir.OANDAND, ir.OANDNOT, ir.ODIV, ir.OEQ, ir.OGE, ir.OGT, ir.OLE, ir.OLT,
+		ir.OLSH, ir.OMOD, ir.OMUL, ir.ONE, ir.OOR, ir.OOROR, ir.ORSH, ir.OSEND, ir.OSUB, ir.OXOR:
+		return ir.NodAt(r.pos(), op, r.expr(), r.expr())
 
-	case OADDSTR:
+	case ir.OADDSTR:
 		pos := r.pos()
 		list := r.exprList()
 		x := npos(pos, list[0])
 		for _, y := range list[1:] {
-			x = nodl(pos, OADD, x, y)
+			x = ir.NodAt(pos, ir.OADD, x, y)
 		}
 		return x
 
 	// --------------------------------------------------------------------
 	// statements
-	case ODCL:
+	case ir.ODCL:
 		pos := r.pos()
 		lhs := npos(pos, dclname(r.ident()))
 		typ := typenod(r.typ())
-		return npos(pos, liststmt(variter([]*Node{lhs}, typ, nil))) // TODO(gri) avoid list creation
+		return npos(pos, liststmt(variter([]*ir.Node{lhs}, typ, nil))) // TODO(gri) avoid list creation
 
 	// case ODCLFIELD:
 	//	unimplemented
@@ -977,11 +978,11 @@ func (r *importReader) node() *Node {
 	// case OAS, OASWB:
 	// 	unreachable - mapped to OAS case below by exporter
 
-	case OAS:
-		return nodl(r.pos(), OAS, r.expr(), r.expr())
+	case ir.OAS:
+		return ir.NodAt(r.pos(), ir.OAS, r.expr(), r.expr())
 
-	case OASOP:
-		n := nodl(r.pos(), OASOP, nil, nil)
+	case ir.OASOP:
+		n := ir.NodAt(r.pos(), ir.OASOP, nil, nil)
 		n.SetSubOp(r.op())
 		n.Left = r.expr()
 		if !r.bool() {
@@ -995,33 +996,33 @@ func (r *importReader) node() *Node {
 	// case OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV:
 	// 	unreachable - mapped to OAS2 case below by exporter
 
-	case OAS2:
-		n := nodl(r.pos(), OAS2, nil, nil)
+	case ir.OAS2:
+		n := ir.NodAt(r.pos(), ir.OAS2, nil, nil)
 		n.List.Set(r.exprList())
 		n.Rlist.Set(r.exprList())
 		return n
 
-	case ORETURN:
-		n := nodl(r.pos(), ORETURN, nil, nil)
+	case ir.ORETURN:
+		n := ir.NodAt(r.pos(), ir.ORETURN, nil, nil)
 		n.List.Set(r.exprList())
 		return n
 
 	// case ORETJMP:
 	// 	unreachable - generated by compiler for trampolin routines (not exported)
 
-	case OGO, ODEFER:
-		return nodl(r.pos(), op, r.expr(), nil)
+	case ir.OGO, ir.ODEFER:
+		return ir.NodAt(r.pos(), op, r.expr(), nil)
 
-	case OIF:
-		n := nodl(r.pos(), OIF, nil, nil)
+	case ir.OIF:
+		n := ir.NodAt(r.pos(), ir.OIF, nil, nil)
 		n.Ninit.Set(r.stmtList())
 		n.Left = r.expr()
 		n.Nbody.Set(r.stmtList())
 		n.Rlist.Set(r.stmtList())
 		return n
 
-	case OFOR:
-		n := nodl(r.pos(), OFOR, nil, nil)
+	case ir.OFOR:
+		n := ir.NodAt(r.pos(), ir.OFOR, nil, nil)
 		n.Ninit.Set(r.stmtList())
 		left, right := r.exprsOrNil()
 		n.Left = left
@@ -1029,15 +1030,15 @@ func (r *importReader) node() *Node {
 		n.Nbody.Set(r.stmtList())
 		return n
 
-	case ORANGE:
-		n := nodl(r.pos(), ORANGE, nil, nil)
+	case ir.ORANGE:
+		n := ir.NodAt(r.pos(), ir.ORANGE, nil, nil)
 		n.List.Set(r.stmtList())
 		n.Right = r.expr()
 		n.Nbody.Set(r.stmtList())
 		return n
 
-	case OSELECT, OSWITCH:
-		n := nodl(r.pos(), op, nil, nil)
+	case ir.OSELECT, ir.OSWITCH:
+		n := ir.NodAt(r.pos(), op, nil, nil)
 		n.Ninit.Set(r.stmtList())
 		left, _ := r.exprsOrNil()
 		n.Left = left
@@ -1047,27 +1048,27 @@ func (r *importReader) node() *Node {
 	// case OCASE:
 	//	handled by caseList
 
-	case OFALL:
-		n := nodl(r.pos(), OFALL, nil, nil)
+	case ir.OFALL:
+		n := ir.NodAt(r.pos(), ir.OFALL, nil, nil)
 		return n
 
-	case OBREAK, OCONTINUE:
+	case ir.OBREAK, ir.OCONTINUE:
 		pos := r.pos()
 		left, _ := r.exprsOrNil()
 		if left != nil {
-			left = newname(left.Sym)
+			left = NewName(left.Sym)
 		}
-		return nodl(pos, op, left, nil)
+		return ir.NodAt(pos, op, left, nil)
 
 	// case OEMPTY:
 	// 	unreachable - not emitted by exporter
 
-	case OGOTO, OLABEL:
-		n := nodl(r.pos(), op, nil, nil)
+	case ir.OGOTO, ir.OLABEL:
+		n := ir.NodAt(r.pos(), op, nil, nil)
 		n.Sym = lookup(r.string())
 		return n
 
-	case OEND:
+	case ir.OEND:
 		return nil
 
 	default:
@@ -1077,21 +1078,21 @@ func (r *importReader) node() *Node {
 	}
 }
 
-func (r *importReader) op() Op {
-	return Op(r.uint64())
+func (r *importReader) op() ir.Op {
+	return ir.Op(r.uint64())
 }
 
-func (r *importReader) elemList() []*Node {
+func (r *importReader) elemList() []*ir.Node {
 	c := r.uint64()
-	list := make([]*Node, c)
+	list := make([]*ir.Node, c)
 	for i := range list {
 		s := r.ident()
-		list[i] = nodSym(OSTRUCTKEY, r.expr(), s)
+		list[i] = nodSym(ir.OSTRUCTKEY, r.expr(), s)
 	}
 	return list
 }
 
-func (r *importReader) exprsOrNil() (a, b *Node) {
+func (r *importReader) exprsOrNil() (a, b *ir.Node) {
 	ab := r.uint64()
 	if ab&1 != 0 {
 		a = r.expr()
diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index 9319faf6a0..f3c302f6be 100644
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 )
@@ -18,7 +19,7 @@ var renameinitgen int
 
 // Function collecting autotmps generated during typechecking,
 // to be included in the package-level init function.
-var initTodo = nod(ODCLFUNC, nil, nil)
+var initTodo = ir.Nod(ir.ODCLFUNC, nil, nil)
 
 func renameinit() *types.Sym {
 	s := lookupN("init.", renameinitgen)
@@ -32,7 +33,7 @@ func renameinit() *types.Sym {
 //   1) Initialize all of the packages the current package depends on.
 //   2) Initialize all the variables that have initializers.
 //   3) Run any init functions.
-func fninit(n []*Node) {
+func fninit(n []*ir.Node) {
 	nf := initOrder(n)
 
 	var deps []*obj.LSym // initTask records for packages the current package depends on
@@ -47,7 +48,7 @@ func fninit(n []*Node) {
 	if len(nf) > 0 {
 		base.Pos = nf[0].Pos // prolog/epilog gets line number of first init stmt
 		initializers := lookup("init")
-		fn := dclfunc(initializers, nod(OTFUNC, nil, nil))
+		fn := dclfunc(initializers, ir.Nod(ir.OTFUNC, nil, nil))
 		for _, dcl := range initTodo.Func.Dcl {
 			dcl.Name.Curfn = fn
 		}
@@ -75,24 +76,24 @@ func fninit(n []*Node) {
 	// Record user init functions.
 	for i := 0; i < renameinitgen; i++ {
 		s := lookupN("init.", i)
-		fn := asNode(s.Def).Name.Defn
+		fn := ir.AsNode(s.Def).Name.Defn
 		// Skip init functions with empty bodies.
-		if fn.Nbody.Len() == 1 && fn.Nbody.First().Op == OEMPTY {
+		if fn.Nbody.Len() == 1 && fn.Nbody.First().Op == ir.OEMPTY {
 			continue
 		}
 		fns = append(fns, s.Linksym())
 	}
 
-	if len(deps) == 0 && len(fns) == 0 && localpkg.Name != "main" && localpkg.Name != "runtime" {
+	if len(deps) == 0 && len(fns) == 0 && ir.LocalPkg.Name != "main" && ir.LocalPkg.Name != "runtime" {
 		return // nothing to initialize
 	}
 
 	// Make an .inittask structure.
 	sym := lookup(".inittask")
-	nn := newname(sym)
-	nn.Type = types.Types[TUINT8] // fake type
-	nn.SetClass(PEXTERN)
-	sym.Def = asTypesNode(nn)
+	nn := NewName(sym)
+	nn.Type = types.Types[types.TUINT8] // fake type
+	nn.SetClass(ir.PEXTERN)
+	sym.Def = ir.AsTypesNode(nn)
 	exportsym(nn)
 	lsym := sym.Linksym()
 	ot := 0
diff --git a/src/cmd/compile/internal/gc/initorder.go b/src/cmd/compile/internal/gc/initorder.go
index f553a3f057..942cb95f20 100644
--- a/src/cmd/compile/internal/gc/initorder.go
+++ b/src/cmd/compile/internal/gc/initorder.go
@@ -10,6 +10,8 @@ import (
 	"fmt"
 
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
 )
 
 // Package initialization
@@ -62,7 +64,7 @@ const (
 type InitOrder struct {
 	// blocking maps initialization assignments to the assignments
 	// that depend on it.
-	blocking map[*Node][]*Node
+	blocking map[*ir.Node][]*ir.Node
 
 	// ready is the queue of Pending initialization assignments
 	// that are ready for initialization.
@@ -73,22 +75,22 @@ type InitOrder struct {
 // package-level declarations (in declaration order) and outputs the
 // corresponding list of statements to include in the init() function
 // body.
-func initOrder(l []*Node) []*Node {
+func initOrder(l []*ir.Node) []*ir.Node {
 	s := InitSchedule{
-		initplans: make(map[*Node]*InitPlan),
-		inittemps: make(map[*Node]*Node),
+		initplans: make(map[*ir.Node]*InitPlan),
+		inittemps: make(map[*ir.Node]*ir.Node),
 	}
 	o := InitOrder{
-		blocking: make(map[*Node][]*Node),
+		blocking: make(map[*ir.Node][]*ir.Node),
 	}
 
 	// Process all package-level assignment in declaration order.
 	for _, n := range l {
 		switch n.Op {
-		case OAS, OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV:
+		case ir.OAS, ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV:
 			o.processAssign(n)
 			o.flushReady(s.staticInit)
-		case ODCLCONST, ODCLFUNC, ODCLTYPE:
+		case ir.ODCLCONST, ir.ODCLFUNC, ir.ODCLTYPE:
 			// nop
 		default:
 			base.Fatalf("unexpected package-level statement: %v", n)
@@ -99,7 +101,7 @@ func initOrder(l []*Node) []*Node {
 	// have been a dependency cycle.
 	for _, n := range l {
 		switch n.Op {
-		case OAS, OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV:
+		case ir.OAS, ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV:
 			if n.Initorder() != InitDone {
 				// If there have already been errors
 				// printed, those errors may have
@@ -108,7 +110,7 @@ func initOrder(l []*Node) []*Node {
 				// first.
 				base.ExitIfErrors()
 
-				findInitLoopAndExit(firstLHS(n), new([]*Node))
+				findInitLoopAndExit(firstLHS(n), new([]*ir.Node))
 				base.Fatalf("initialization unfinished, but failed to identify loop")
 			}
 		}
@@ -123,8 +125,8 @@ func initOrder(l []*Node) []*Node {
 	return s.out
 }
 
-func (o *InitOrder) processAssign(n *Node) {
-	if n.Initorder() != InitNotStarted || n.Xoffset != BADWIDTH {
+func (o *InitOrder) processAssign(n *ir.Node) {
+	if n.Initorder() != InitNotStarted || n.Xoffset != types.BADWIDTH {
 		base.Fatalf("unexpected state: %v, %v, %v", n, n.Initorder(), n.Xoffset)
 	}
 
@@ -137,7 +139,7 @@ func (o *InitOrder) processAssign(n *Node) {
 		defn := dep.Name.Defn
 		// Skip dependencies on functions (PFUNC) and
 		// variables already initialized (InitDone).
-		if dep.Class() != PEXTERN || defn.Initorder() == InitDone {
+		if dep.Class() != ir.PEXTERN || defn.Initorder() == InitDone {
 			continue
 		}
 		n.Xoffset++
@@ -152,16 +154,16 @@ func (o *InitOrder) processAssign(n *Node) {
 // flushReady repeatedly applies initialize to the earliest (in
 // declaration order) assignment ready for initialization and updates
 // the inverse dependency ("blocking") graph.
-func (o *InitOrder) flushReady(initialize func(*Node)) {
+func (o *InitOrder) flushReady(initialize func(*ir.Node)) {
 	for o.ready.Len() != 0 {
-		n := heap.Pop(&o.ready).(*Node)
+		n := heap.Pop(&o.ready).(*ir.Node)
 		if n.Initorder() != InitPending || n.Xoffset != 0 {
 			base.Fatalf("unexpected state: %v, %v, %v", n, n.Initorder(), n.Xoffset)
 		}
 
 		initialize(n)
 		n.SetInitorder(InitDone)
-		n.Xoffset = BADWIDTH
+		n.Xoffset = types.BADWIDTH
 
 		blocked := o.blocking[n]
 		delete(o.blocking, n)
@@ -181,7 +183,7 @@ func (o *InitOrder) flushReady(initialize func(*Node)) {
 // path points to a slice used for tracking the sequence of
 // variables/functions visited. Using a pointer to a slice allows the
 // slice capacity to grow and limit reallocations.
-func findInitLoopAndExit(n *Node, path *[]*Node) {
+func findInitLoopAndExit(n *ir.Node, path *[]*ir.Node) {
 	// We implement a simple DFS loop-finding algorithm. This
 	// could be faster, but initialization cycles are rare.
 
@@ -194,14 +196,14 @@ func findInitLoopAndExit(n *Node, path *[]*Node) {
 
 	// There might be multiple loops involving n; by sorting
 	// references, we deterministically pick the one reported.
-	refers := collectDeps(n.Name.Defn, false).Sorted(func(ni, nj *Node) bool {
+	refers := collectDeps(n.Name.Defn, false).Sorted(func(ni, nj *ir.Node) bool {
 		return ni.Pos.Before(nj.Pos)
 	})
 
 	*path = append(*path, n)
 	for _, ref := range refers {
 		// Short-circuit variables that were initialized.
-		if ref.Class() == PEXTERN && ref.Name.Defn.Initorder() == InitDone {
+		if ref.Class() == ir.PEXTERN && ref.Name.Defn.Initorder() == InitDone {
 			continue
 		}
 
@@ -213,12 +215,12 @@ func findInitLoopAndExit(n *Node, path *[]*Node) {
 // reportInitLoopAndExit reports and initialization loop as an error
 // and exits. However, if l is not actually an initialization loop, it
 // simply returns instead.
-func reportInitLoopAndExit(l []*Node) {
+func reportInitLoopAndExit(l []*ir.Node) {
 	// Rotate loop so that the earliest variable declaration is at
 	// the start.
 	i := -1
 	for j, n := range l {
-		if n.Class() == PEXTERN && (i == -1 || n.Pos.Before(l[i].Pos)) {
+		if n.Class() == ir.PEXTERN && (i == -1 || n.Pos.Before(l[i].Pos)) {
 			i = j
 		}
 	}
@@ -236,9 +238,9 @@ func reportInitLoopAndExit(l []*Node) {
 	var msg bytes.Buffer
 	fmt.Fprintf(&msg, "initialization loop:\n")
 	for _, n := range l {
-		fmt.Fprintf(&msg, "\t%v: %v refers to\n", n.Line(), n)
+		fmt.Fprintf(&msg, "\t%v: %v refers to\n", ir.Line(n), n)
 	}
-	fmt.Fprintf(&msg, "\t%v: %v", l[0].Line(), l[0])
+	fmt.Fprintf(&msg, "\t%v: %v", ir.Line(l[0]), l[0])
 
 	base.ErrorfAt(l[0].Pos, msg.String())
 	base.ErrorExit()
@@ -248,14 +250,14 @@ func reportInitLoopAndExit(l []*Node) {
 // variables that declaration n depends on. If transitive is true,
 // then it also includes the transitive dependencies of any depended
 // upon functions (but not variables).
-func collectDeps(n *Node, transitive bool) NodeSet {
+func collectDeps(n *ir.Node, transitive bool) ir.NodeSet {
 	d := initDeps{transitive: transitive}
 	switch n.Op {
-	case OAS:
+	case ir.OAS:
 		d.inspect(n.Right)
-	case OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV:
+	case ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV:
 		d.inspect(n.Right)
-	case ODCLFUNC:
+	case ir.ODCLFUNC:
 		d.inspectList(n.Nbody)
 	default:
 		base.Fatalf("unexpected Op: %v", n.Op)
@@ -265,31 +267,31 @@ func collectDeps(n *Node, transitive bool) NodeSet {
 
 type initDeps struct {
 	transitive bool
-	seen       NodeSet
+	seen       ir.NodeSet
 }
 
-func (d *initDeps) inspect(n *Node)     { inspect(n, d.visit) }
-func (d *initDeps) inspectList(l Nodes) { inspectList(l, d.visit) }
+func (d *initDeps) inspect(n *ir.Node)     { ir.Inspect(n, d.visit) }
+func (d *initDeps) inspectList(l ir.Nodes) { ir.InspectList(l, d.visit) }
 
 // visit calls foundDep on any package-level functions or variables
 // referenced by n, if any.
-func (d *initDeps) visit(n *Node) bool {
+func (d *initDeps) visit(n *ir.Node) bool {
 	switch n.Op {
-	case OMETHEXPR:
-		d.foundDep(n.MethodName())
+	case ir.OMETHEXPR:
+		d.foundDep(methodExprName(n))
 		return false
 
-	case ONAME:
+	case ir.ONAME:
 		switch n.Class() {
-		case PEXTERN, PFUNC:
+		case ir.PEXTERN, ir.PFUNC:
 			d.foundDep(n)
 		}
 
-	case OCLOSURE:
+	case ir.OCLOSURE:
 		d.inspectList(n.Func.Decl.Nbody)
 
-	case ODOTMETH, OCALLPART:
-		d.foundDep(n.MethodName())
+	case ir.ODOTMETH, ir.OCALLPART:
+		d.foundDep(methodExprName(n))
 	}
 
 	return true
@@ -297,7 +299,7 @@ func (d *initDeps) visit(n *Node) bool {
 
 // foundDep records that we've found a dependency on n by adding it to
 // seen.
-func (d *initDeps) foundDep(n *Node) {
+func (d *initDeps) foundDep(n *ir.Node) {
 	// Can happen with method expressions involving interface
 	// types; e.g., fixedbugs/issue4495.go.
 	if n == nil {
@@ -314,7 +316,7 @@ func (d *initDeps) foundDep(n *Node) {
 		return
 	}
 	d.seen.Add(n)
-	if d.transitive && n.Class() == PFUNC {
+	if d.transitive && n.Class() == ir.PFUNC {
 		d.inspectList(n.Name.Defn.Nbody)
 	}
 }
@@ -326,13 +328,13 @@ func (d *initDeps) foundDep(n *Node) {
 // an OAS node's Pos may not be unique. For example, given the
 // declaration "var a, b = f(), g()", "a" must be ordered before "b",
 // but both OAS nodes use the "=" token's position as their Pos.
-type declOrder []*Node
+type declOrder []*ir.Node
 
 func (s declOrder) Len() int           { return len(s) }
 func (s declOrder) Less(i, j int) bool { return firstLHS(s[i]).Pos.Before(firstLHS(s[j]).Pos) }
 func (s declOrder) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 
-func (s *declOrder) Push(x interface{}) { *s = append(*s, x.(*Node)) }
+func (s *declOrder) Push(x interface{}) { *s = append(*s, x.(*ir.Node)) }
 func (s *declOrder) Pop() interface{} {
 	n := (*s)[len(*s)-1]
 	*s = (*s)[:len(*s)-1]
@@ -341,11 +343,11 @@ func (s *declOrder) Pop() interface{} {
 
 // firstLHS returns the first expression on the left-hand side of
 // assignment n.
-func firstLHS(n *Node) *Node {
+func firstLHS(n *ir.Node) *ir.Node {
 	switch n.Op {
-	case OAS:
+	case ir.OAS:
 		return n.Left
-	case OAS2DOTTYPE, OAS2FUNC, OAS2RECV, OAS2MAPR:
+	case ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2RECV, ir.OAS2MAPR:
 		return n.List.First()
 	}
 
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index d71ea9b5ed..f982b43fb9 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -28,6 +28,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -52,8 +53,8 @@ const (
 
 // Get the function's package. For ordinary functions it's on the ->sym, but for imported methods
 // the ->sym can be re-used in the local package, so peel it off the receiver's type.
-func fnpkg(fn *Node) *types.Pkg {
-	if fn.IsMethod() {
+func fnpkg(fn *ir.Node) *types.Pkg {
+	if ir.IsMethod(fn) {
 		// method
 		rcvr := fn.Type.Recv().Type
 
@@ -72,7 +73,7 @@ func fnpkg(fn *Node) *types.Pkg {
 
 // Lazy typechecking of imported bodies. For local functions, caninl will set ->typecheck
 // because they're a copy of an already checked body.
-func typecheckinl(fn *Node) {
+func typecheckinl(fn *ir.Node) {
 	lno := setlineno(fn)
 
 	expandInline(fn)
@@ -83,12 +84,12 @@ func typecheckinl(fn *Node) {
 	// the ->inl of a local function has been typechecked before caninl copied it.
 	pkg := fnpkg(fn)
 
-	if pkg == localpkg || pkg == nil {
+	if pkg == ir.LocalPkg || pkg == nil {
 		return // typecheckinl on local function
 	}
 
 	if base.Flag.LowerM > 2 || base.Debug.Export != 0 {
-		fmt.Printf("typecheck import [%v] %L { %#v }\n", fn.Sym, fn, asNodes(fn.Func.Inl.Body))
+		fmt.Printf("typecheck import [%v] %L { %#v }\n", fn.Sym, fn, ir.AsNodes(fn.Func.Inl.Body))
 	}
 
 	savefn := Curfn
@@ -110,8 +111,8 @@ func typecheckinl(fn *Node) {
 // Caninl determines whether fn is inlineable.
 // If so, caninl saves fn->nbody in fn->inl and substitutes it with a copy.
 // fn and ->nbody will already have been typechecked.
-func caninl(fn *Node) {
-	if fn.Op != ODCLFUNC {
+func caninl(fn *ir.Node) {
+	if fn.Op != ir.ODCLFUNC {
 		base.Fatalf("caninl %v", fn)
 	}
 	if fn.Func.Nname == nil {
@@ -123,43 +124,43 @@ func caninl(fn *Node) {
 		defer func() {
 			if reason != "" {
 				if base.Flag.LowerM > 1 {
-					fmt.Printf("%v: cannot inline %v: %s\n", fn.Line(), fn.Func.Nname, reason)
+					fmt.Printf("%v: cannot inline %v: %s\n", ir.Line(fn), fn.Func.Nname, reason)
 				}
 				if logopt.Enabled() {
-					logopt.LogOpt(fn.Pos, "cannotInlineFunction", "inline", fn.funcname(), reason)
+					logopt.LogOpt(fn.Pos, "cannotInlineFunction", "inline", ir.FuncName(fn), reason)
 				}
 			}
 		}()
 	}
 
 	// If marked "go:noinline", don't inline
-	if fn.Func.Pragma&Noinline != 0 {
+	if fn.Func.Pragma&ir.Noinline != 0 {
 		reason = "marked go:noinline"
 		return
 	}
 
 	// If marked "go:norace" and -race compilation, don't inline.
-	if base.Flag.Race && fn.Func.Pragma&Norace != 0 {
+	if base.Flag.Race && fn.Func.Pragma&ir.Norace != 0 {
 		reason = "marked go:norace with -race compilation"
 		return
 	}
 
 	// If marked "go:nocheckptr" and -d checkptr compilation, don't inline.
-	if base.Debug.Checkptr != 0 && fn.Func.Pragma&NoCheckPtr != 0 {
+	if base.Debug.Checkptr != 0 && fn.Func.Pragma&ir.NoCheckPtr != 0 {
 		reason = "marked go:nocheckptr"
 		return
 	}
 
 	// If marked "go:cgo_unsafe_args", don't inline, since the
 	// function makes assumptions about its argument frame layout.
-	if fn.Func.Pragma&CgoUnsafeArgs != 0 {
+	if fn.Func.Pragma&ir.CgoUnsafeArgs != 0 {
 		reason = "marked go:cgo_unsafe_args"
 		return
 	}
 
 	// If marked as "go:uintptrescapes", don't inline, since the
 	// escape information is lost during inlining.
-	if fn.Func.Pragma&UintptrEscapes != 0 {
+	if fn.Func.Pragma&ir.UintptrEscapes != 0 {
 		reason = "marked as having an escaping uintptr argument"
 		return
 	}
@@ -168,7 +169,7 @@ func caninl(fn *Node) {
 	// granularity, so inlining yeswritebarrierrec functions can
 	// confuse it (#22342). As a workaround, disallow inlining
 	// them for now.
-	if fn.Func.Pragma&Yeswritebarrierrec != 0 {
+	if fn.Func.Pragma&ir.Yeswritebarrierrec != 0 {
 		reason = "marked go:yeswritebarrierrec"
 		return
 	}
@@ -206,7 +207,7 @@ func caninl(fn *Node) {
 	visitor := hairyVisitor{
 		budget:        inlineMaxBudget,
 		extraCallCost: cc,
-		usedLocals:    make(map[*Node]bool),
+		usedLocals:    make(map[*ir.Node]bool),
 	}
 	if visitor.visitList(fn.Nbody) {
 		reason = visitor.reason
@@ -217,29 +218,29 @@ func caninl(fn *Node) {
 		return
 	}
 
-	n.Func.Inl = &Inline{
+	n.Func.Inl = &ir.Inline{
 		Cost: inlineMaxBudget - visitor.budget,
 		Dcl:  inlcopylist(pruneUnusedAutos(n.Name.Defn.Func.Dcl, &visitor)),
 		Body: inlcopylist(fn.Nbody.Slice()),
 	}
 
 	if base.Flag.LowerM > 1 {
-		fmt.Printf("%v: can inline %#v with cost %d as: %#v { %#v }\n", fn.Line(), n, inlineMaxBudget-visitor.budget, fn.Type, asNodes(n.Func.Inl.Body))
+		fmt.Printf("%v: can inline %#v with cost %d as: %#v { %#v }\n", ir.Line(fn), n, inlineMaxBudget-visitor.budget, fn.Type, ir.AsNodes(n.Func.Inl.Body))
 	} else if base.Flag.LowerM != 0 {
-		fmt.Printf("%v: can inline %v\n", fn.Line(), n)
+		fmt.Printf("%v: can inline %v\n", ir.Line(fn), n)
 	}
 	if logopt.Enabled() {
-		logopt.LogOpt(fn.Pos, "canInlineFunction", "inline", fn.funcname(), fmt.Sprintf("cost: %d", inlineMaxBudget-visitor.budget))
+		logopt.LogOpt(fn.Pos, "canInlineFunction", "inline", ir.FuncName(fn), fmt.Sprintf("cost: %d", inlineMaxBudget-visitor.budget))
 	}
 }
 
 // inlFlood marks n's inline body for export and recursively ensures
 // all called functions are marked too.
-func inlFlood(n *Node) {
+func inlFlood(n *ir.Node) {
 	if n == nil {
 		return
 	}
-	if n.Op != ONAME || n.Class() != PFUNC {
+	if n.Op != ir.ONAME || n.Class() != ir.PFUNC {
 		base.Fatalf("inlFlood: unexpected %v, %v, %v", n, n.Op, n.Class())
 	}
 	if n.Func == nil {
@@ -259,28 +260,28 @@ func inlFlood(n *Node) {
 	// Recursively identify all referenced functions for
 	// reexport. We want to include even non-called functions,
 	// because after inlining they might be callable.
-	inspectList(asNodes(n.Func.Inl.Body), func(n *Node) bool {
+	ir.InspectList(ir.AsNodes(n.Func.Inl.Body), func(n *ir.Node) bool {
 		switch n.Op {
-		case OMETHEXPR:
-			inlFlood(n.MethodName())
+		case ir.OMETHEXPR:
+			inlFlood(methodExprName(n))
 
-		case ONAME:
+		case ir.ONAME:
 			switch n.Class() {
-			case PFUNC:
+			case ir.PFUNC:
 				inlFlood(n)
 				exportsym(n)
-			case PEXTERN:
+			case ir.PEXTERN:
 				exportsym(n)
 			}
 
-		case ODOTMETH:
-			fn := n.MethodName()
+		case ir.ODOTMETH:
+			fn := methodExprName(n)
 			inlFlood(fn)
 
-		case OCALLPART:
+		case ir.OCALLPART:
 			// Okay, because we don't yet inline indirect
 			// calls to method values.
-		case OCLOSURE:
+		case ir.OCLOSURE:
 			// If the closure is inlinable, we'll need to
 			// flood it too. But today we don't support
 			// inlining functions that contain closures.
@@ -299,11 +300,11 @@ type hairyVisitor struct {
 	budget        int32
 	reason        string
 	extraCallCost int32
-	usedLocals    map[*Node]bool
+	usedLocals    map[*ir.Node]bool
 }
 
 // Look for anything we want to punt on.
-func (v *hairyVisitor) visitList(ll Nodes) bool {
+func (v *hairyVisitor) visitList(ll ir.Nodes) bool {
 	for _, n := range ll.Slice() {
 		if v.visit(n) {
 			return true
@@ -312,19 +313,19 @@ func (v *hairyVisitor) visitList(ll Nodes) bool {
 	return false
 }
 
-func (v *hairyVisitor) visit(n *Node) bool {
+func (v *hairyVisitor) visit(n *ir.Node) bool {
 	if n == nil {
 		return false
 	}
 
 	switch n.Op {
 	// Call is okay if inlinable and we have the budget for the body.
-	case OCALLFUNC:
+	case ir.OCALLFUNC:
 		// Functions that call runtime.getcaller{pc,sp} can not be inlined
 		// because getcaller{pc,sp} expect a pointer to the caller's first argument.
 		//
 		// runtime.throw is a "cheap call" like panic in normal code.
-		if n.Left.Op == ONAME && n.Left.Class() == PFUNC && isRuntimePkg(n.Left.Sym.Pkg) {
+		if n.Left.Op == ir.ONAME && n.Left.Class() == ir.PFUNC && isRuntimePkg(n.Left.Sym.Pkg) {
 			fn := n.Left.Sym.Name
 			if fn == "getcallerpc" || fn == "getcallersp" {
 				v.reason = "call to " + fn
@@ -350,7 +351,7 @@ func (v *hairyVisitor) visit(n *Node) bool {
 		v.budget -= v.extraCallCost
 
 	// Call is okay if inlinable and we have the budget for the body.
-	case OCALLMETH:
+	case ir.OCALLMETH:
 		t := n.Left.Type
 		if t == nil {
 			base.Fatalf("no function type for [%p] %+v\n", n.Left, n.Left)
@@ -366,7 +367,7 @@ func (v *hairyVisitor) visit(n *Node) bool {
 				break
 			}
 		}
-		if inlfn := n.Left.MethodName().Func; inlfn.Inl != nil {
+		if inlfn := methodExprName(n.Left).Func; inlfn.Inl != nil {
 			v.budget -= inlfn.Inl.Cost
 			break
 		}
@@ -374,58 +375,58 @@ func (v *hairyVisitor) visit(n *Node) bool {
 		v.budget -= v.extraCallCost
 
 	// Things that are too hairy, irrespective of the budget
-	case OCALL, OCALLINTER:
+	case ir.OCALL, ir.OCALLINTER:
 		// Call cost for non-leaf inlining.
 		v.budget -= v.extraCallCost
 
-	case OPANIC:
+	case ir.OPANIC:
 		v.budget -= inlineExtraPanicCost
 
-	case ORECOVER:
+	case ir.ORECOVER:
 		// recover matches the argument frame pointer to find
 		// the right panic value, so it needs an argument frame.
 		v.reason = "call to recover"
 		return true
 
-	case OCLOSURE,
-		ORANGE,
-		OSELECT,
-		OGO,
-		ODEFER,
-		ODCLTYPE, // can't print yet
-		ORETJMP:
+	case ir.OCLOSURE,
+		ir.ORANGE,
+		ir.OSELECT,
+		ir.OGO,
+		ir.ODEFER,
+		ir.ODCLTYPE, // can't print yet
+		ir.ORETJMP:
 		v.reason = "unhandled op " + n.Op.String()
 		return true
 
-	case OAPPEND:
+	case ir.OAPPEND:
 		v.budget -= inlineExtraAppendCost
 
-	case ODCLCONST, OEMPTY, OFALL:
+	case ir.ODCLCONST, ir.OEMPTY, ir.OFALL:
 		// These nodes don't produce code; omit from inlining budget.
 		return false
 
-	case OLABEL:
+	case ir.OLABEL:
 		// TODO(mdempsky): Add support for inlining labeled control statements.
-		if n.labeledControl() != nil {
+		if labeledControl(n) != nil {
 			v.reason = "labeled control"
 			return true
 		}
 
-	case OBREAK, OCONTINUE:
+	case ir.OBREAK, ir.OCONTINUE:
 		if n.Sym != nil {
 			// Should have short-circuited due to labeledControl above.
 			base.Fatalf("unexpected labeled break/continue: %v", n)
 		}
 
-	case OIF:
-		if Isconst(n.Left, constant.Bool) {
+	case ir.OIF:
+		if ir.IsConst(n.Left, constant.Bool) {
 			// This if and the condition cost nothing.
 			return v.visitList(n.Ninit) || v.visitList(n.Nbody) ||
 				v.visitList(n.Rlist)
 		}
 
-	case ONAME:
-		if n.Class() == PAUTO {
+	case ir.ONAME:
+		if n.Class() == ir.PAUTO {
 			v.usedLocals[n] = true
 		}
 
@@ -446,26 +447,26 @@ func (v *hairyVisitor) visit(n *Node) bool {
 // inlcopylist (together with inlcopy) recursively copies a list of nodes, except
 // that it keeps the same ONAME, OTYPE, and OLITERAL nodes. It is used for copying
 // the body and dcls of an inlineable function.
-func inlcopylist(ll []*Node) []*Node {
-	s := make([]*Node, 0, len(ll))
+func inlcopylist(ll []*ir.Node) []*ir.Node {
+	s := make([]*ir.Node, 0, len(ll))
 	for _, n := range ll {
 		s = append(s, inlcopy(n))
 	}
 	return s
 }
 
-func inlcopy(n *Node) *Node {
+func inlcopy(n *ir.Node) *ir.Node {
 	if n == nil {
 		return nil
 	}
 
 	switch n.Op {
-	case ONAME, OTYPE, OLITERAL, ONIL:
+	case ir.ONAME, ir.OTYPE, ir.OLITERAL, ir.ONIL:
 		return n
 	}
 
-	m := n.copy()
-	if n.Op != OCALLPART && m.Func != nil {
+	m := ir.Copy(n)
+	if n.Op != ir.OCALLPART && m.Func != nil {
 		base.Fatalf("unexpected Func: %v", m)
 	}
 	m.Left = inlcopy(n.Left)
@@ -478,7 +479,7 @@ func inlcopy(n *Node) *Node {
 	return m
 }
 
-func countNodes(n *Node) int {
+func countNodes(n *ir.Node) int {
 	if n == nil {
 		return 0
 	}
@@ -502,7 +503,7 @@ func countNodes(n *Node) int {
 
 // Inlcalls/nodelist/node walks fn's statements and expressions and substitutes any
 // calls made to inlineable functions. This is the external entry point.
-func inlcalls(fn *Node) {
+func inlcalls(fn *ir.Node) {
 	savefn := Curfn
 	Curfn = fn
 	maxCost := int32(inlineMaxBudget)
@@ -515,7 +516,7 @@ func inlcalls(fn *Node) {
 	// but allow inlining if there is a recursion cycle of many functions.
 	// Most likely, the inlining will stop before we even hit the beginning of
 	// the cycle again, but the map catches the unusual case.
-	inlMap := make(map[*Node]bool)
+	inlMap := make(map[*ir.Node]bool)
 	fn = inlnode(fn, maxCost, inlMap)
 	if fn != Curfn {
 		base.Fatalf("inlnode replaced curfn")
@@ -524,8 +525,8 @@ func inlcalls(fn *Node) {
 }
 
 // Turn an OINLCALL into a statement.
-func inlconv2stmt(n *Node) {
-	n.Op = OBLOCK
+func inlconv2stmt(n *ir.Node) {
+	n.Op = ir.OBLOCK
 
 	// n->ninit stays
 	n.List.Set(n.Nbody.Slice())
@@ -537,7 +538,7 @@ func inlconv2stmt(n *Node) {
 // Turn an OINLCALL into a single valued expression.
 // The result of inlconv2expr MUST be assigned back to n, e.g.
 // 	n.Left = inlconv2expr(n.Left)
-func inlconv2expr(n *Node) *Node {
+func inlconv2expr(n *ir.Node) *ir.Node {
 	r := n.Rlist.First()
 	return addinit(r, append(n.Ninit.Slice(), n.Nbody.Slice()...))
 }
@@ -547,8 +548,8 @@ func inlconv2expr(n *Node) *Node {
 // containing the inlined statements on the first list element so
 // order will be preserved Used in return, oas2func and call
 // statements.
-func inlconv2list(n *Node) []*Node {
-	if n.Op != OINLCALL || n.Rlist.Len() == 0 {
+func inlconv2list(n *ir.Node) []*ir.Node {
+	if n.Op != ir.OINLCALL || n.Rlist.Len() == 0 {
 		base.Fatalf("inlconv2list %+v\n", n)
 	}
 
@@ -557,7 +558,7 @@ func inlconv2list(n *Node) []*Node {
 	return s
 }
 
-func inlnodelist(l Nodes, maxCost int32, inlMap map[*Node]bool) {
+func inlnodelist(l ir.Nodes, maxCost int32, inlMap map[*ir.Node]bool) {
 	s := l.Slice()
 	for i := range s {
 		s[i] = inlnode(s[i], maxCost, inlMap)
@@ -577,23 +578,23 @@ func inlnodelist(l Nodes, maxCost int32, inlMap map[*Node]bool) {
 // shorter and less complicated.
 // The result of inlnode MUST be assigned back to n, e.g.
 // 	n.Left = inlnode(n.Left)
-func inlnode(n *Node, maxCost int32, inlMap map[*Node]bool) *Node {
+func inlnode(n *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node {
 	if n == nil {
 		return n
 	}
 
 	switch n.Op {
-	case ODEFER, OGO:
+	case ir.ODEFER, ir.OGO:
 		switch n.Left.Op {
-		case OCALLFUNC, OCALLMETH:
+		case ir.OCALLFUNC, ir.OCALLMETH:
 			n.Left.SetNoInline(true)
 		}
 
 	// TODO do them here (or earlier),
 	// so escape analysis can avoid more heapmoves.
-	case OCLOSURE:
+	case ir.OCLOSURE:
 		return n
-	case OCALLMETH:
+	case ir.OCALLMETH:
 		// Prevent inlining some reflect.Value methods when using checkptr,
 		// even when package reflect was compiled without it (#35073).
 		if s := n.Left.Sym; base.Debug.Checkptr != 0 && isReflectPkg(s.Pkg) && (s.Name == "Value.UnsafeAddr" || s.Name == "Value.Pointer") {
@@ -605,24 +606,24 @@ func inlnode(n *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 
 	inlnodelist(n.Ninit, maxCost, inlMap)
 	for _, n1 := range n.Ninit.Slice() {
-		if n1.Op == OINLCALL {
+		if n1.Op == ir.OINLCALL {
 			inlconv2stmt(n1)
 		}
 	}
 
 	n.Left = inlnode(n.Left, maxCost, inlMap)
-	if n.Left != nil && n.Left.Op == OINLCALL {
+	if n.Left != nil && n.Left.Op == ir.OINLCALL {
 		n.Left = inlconv2expr(n.Left)
 	}
 
 	n.Right = inlnode(n.Right, maxCost, inlMap)
-	if n.Right != nil && n.Right.Op == OINLCALL {
-		if n.Op == OFOR || n.Op == OFORUNTIL {
+	if n.Right != nil && n.Right.Op == ir.OINLCALL {
+		if n.Op == ir.OFOR || n.Op == ir.OFORUNTIL {
 			inlconv2stmt(n.Right)
-		} else if n.Op == OAS2FUNC {
+		} else if n.Op == ir.OAS2FUNC {
 			n.Rlist.Set(inlconv2list(n.Right))
 			n.Right = nil
-			n.Op = OAS2
+			n.Op = ir.OAS2
 			n.SetTypecheck(0)
 			n = typecheck(n, ctxStmt)
 		} else {
@@ -631,16 +632,16 @@ func inlnode(n *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	}
 
 	inlnodelist(n.List, maxCost, inlMap)
-	if n.Op == OBLOCK {
+	if n.Op == ir.OBLOCK {
 		for _, n2 := range n.List.Slice() {
-			if n2.Op == OINLCALL {
+			if n2.Op == ir.OINLCALL {
 				inlconv2stmt(n2)
 			}
 		}
 	} else {
 		s := n.List.Slice()
 		for i1, n1 := range s {
-			if n1 != nil && n1.Op == OINLCALL {
+			if n1 != nil && n1.Op == ir.OINLCALL {
 				s[i1] = inlconv2expr(s[i1])
 			}
 		}
@@ -649,8 +650,8 @@ func inlnode(n *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	inlnodelist(n.Rlist, maxCost, inlMap)
 	s := n.Rlist.Slice()
 	for i1, n1 := range s {
-		if n1.Op == OINLCALL {
-			if n.Op == OIF {
+		if n1.Op == ir.OINLCALL {
+			if n.Op == ir.OIF {
 				inlconv2stmt(n1)
 			} else {
 				s[i1] = inlconv2expr(s[i1])
@@ -660,7 +661,7 @@ func inlnode(n *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 
 	inlnodelist(n.Nbody, maxCost, inlMap)
 	for _, n := range n.Nbody.Slice() {
-		if n.Op == OINLCALL {
+		if n.Op == ir.OINLCALL {
 			inlconv2stmt(n)
 		}
 	}
@@ -669,16 +670,16 @@ func inlnode(n *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	// transmogrify this node itself unless inhibited by the
 	// switch at the top of this function.
 	switch n.Op {
-	case OCALLFUNC, OCALLMETH:
+	case ir.OCALLFUNC, ir.OCALLMETH:
 		if n.NoInline() {
 			return n
 		}
 	}
 
 	switch n.Op {
-	case OCALLFUNC:
+	case ir.OCALLFUNC:
 		if base.Flag.LowerM > 3 {
-			fmt.Printf("%v:call to func %+v\n", n.Line(), n.Left)
+			fmt.Printf("%v:call to func %+v\n", ir.Line(n), n.Left)
 		}
 		if isIntrinsicCall(n) {
 			break
@@ -687,9 +688,9 @@ func inlnode(n *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 			n = mkinlcall(n, fn, maxCost, inlMap)
 		}
 
-	case OCALLMETH:
+	case ir.OCALLMETH:
 		if base.Flag.LowerM > 3 {
-			fmt.Printf("%v:call to meth %L\n", n.Line(), n.Left.Right)
+			fmt.Printf("%v:call to meth %L\n", ir.Line(n), n.Left.Right)
 		}
 
 		// typecheck should have resolved ODOTMETH->type, whose nname points to the actual function.
@@ -697,7 +698,7 @@ func inlnode(n *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 			base.Fatalf("no function type for [%p] %+v\n", n.Left, n.Left)
 		}
 
-		n = mkinlcall(n, n.Left.MethodName(), maxCost, inlMap)
+		n = mkinlcall(n, methodExprName(n.Left), maxCost, inlMap)
 	}
 
 	base.Pos = lno
@@ -706,11 +707,11 @@ func inlnode(n *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 
 // inlCallee takes a function-typed expression and returns the underlying function ONAME
 // that it refers to if statically known. Otherwise, it returns nil.
-func inlCallee(fn *Node) *Node {
+func inlCallee(fn *ir.Node) *ir.Node {
 	fn = staticValue(fn)
 	switch {
-	case fn.Op == OMETHEXPR:
-		n := fn.MethodName()
+	case fn.Op == ir.OMETHEXPR:
+		n := methodExprName(fn)
 		// Check that receiver type matches fn.Left.
 		// TODO(mdempsky): Handle implicit dereference
 		// of pointer receiver argument?
@@ -718,9 +719,9 @@ func inlCallee(fn *Node) *Node {
 			return nil
 		}
 		return n
-	case fn.Op == ONAME && fn.Class() == PFUNC:
+	case fn.Op == ir.ONAME && fn.Class() == ir.PFUNC:
 		return fn
-	case fn.Op == OCLOSURE:
+	case fn.Op == ir.OCLOSURE:
 		c := fn.Func.Decl
 		caninl(c)
 		return c.Func.Nname
@@ -728,9 +729,9 @@ func inlCallee(fn *Node) *Node {
 	return nil
 }
 
-func staticValue(n *Node) *Node {
+func staticValue(n *ir.Node) *ir.Node {
 	for {
-		if n.Op == OCONVNOP {
+		if n.Op == ir.OCONVNOP {
 			n = n.Left
 			continue
 		}
@@ -746,8 +747,8 @@ func staticValue(n *Node) *Node {
 // staticValue1 implements a simple SSA-like optimization. If n is a local variable
 // that is initialized and never reassigned, staticValue1 returns the initializer
 // expression. Otherwise, it returns nil.
-func staticValue1(n *Node) *Node {
-	if n.Op != ONAME || n.Class() != PAUTO || n.Name.Addrtaken() {
+func staticValue1(n *ir.Node) *ir.Node {
+	if n.Op != ir.ONAME || n.Class() != ir.PAUTO || n.Name.Addrtaken() {
 		return nil
 	}
 
@@ -756,12 +757,12 @@ func staticValue1(n *Node) *Node {
 		return nil
 	}
 
-	var rhs *Node
+	var rhs *ir.Node
 FindRHS:
 	switch defn.Op {
-	case OAS:
+	case ir.OAS:
 		rhs = defn.Right
-	case OAS2:
+	case ir.OAS2:
 		for i, lhs := range defn.List.Slice() {
 			if lhs == n {
 				rhs = defn.Rlist.Index(i)
@@ -790,8 +791,8 @@ FindRHS:
 // useful for -m output documenting the reason for inhibited optimizations.
 // NB: global variables are always considered to be re-assigned.
 // TODO: handle initial declaration not including an assignment and followed by a single assignment?
-func reassigned(n *Node) (bool, *Node) {
-	if n.Op != ONAME {
+func reassigned(n *ir.Node) (bool, *ir.Node) {
+	if n.Op != ir.ONAME {
 		base.Fatalf("reassigned %v", n)
 	}
 	// no way to reliably check for no-reassignment of globals, assume it can be
@@ -804,7 +805,7 @@ func reassigned(n *Node) (bool, *Node) {
 	// of the corresponding ODCLFUNC.
 	// We need to walk the function body to check for reassignments so we follow the
 	// linkage to the ODCLFUNC node as that is where body is held.
-	if f.Op == OCLOSURE {
+	if f.Op == ir.OCLOSURE {
 		f = f.Func.Decl
 	}
 	v := reassignVisitor{name: n}
@@ -813,19 +814,19 @@ func reassigned(n *Node) (bool, *Node) {
 }
 
 type reassignVisitor struct {
-	name *Node
+	name *ir.Node
 }
 
-func (v *reassignVisitor) visit(n *Node) *Node {
+func (v *reassignVisitor) visit(n *ir.Node) *ir.Node {
 	if n == nil {
 		return nil
 	}
 	switch n.Op {
-	case OAS:
+	case ir.OAS:
 		if n.Left == v.name && n != v.name.Name.Defn {
 			return n
 		}
-	case OAS2, OAS2FUNC, OAS2MAPR, OAS2DOTTYPE:
+	case ir.OAS2, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2DOTTYPE:
 		for _, p := range n.List.Slice() {
 			if p == v.name && n != v.name.Name.Defn {
 				return n
@@ -853,7 +854,7 @@ func (v *reassignVisitor) visit(n *Node) *Node {
 	return nil
 }
 
-func (v *reassignVisitor) visitList(l Nodes) *Node {
+func (v *reassignVisitor) visitList(l ir.Nodes) *ir.Node {
 	for _, n := range l.Slice() {
 		if a := v.visit(n); a != nil {
 			return a
@@ -862,17 +863,17 @@ func (v *reassignVisitor) visitList(l Nodes) *Node {
 	return nil
 }
 
-func inlParam(t *types.Field, as *Node, inlvars map[*Node]*Node) *Node {
-	n := asNode(t.Nname)
-	if n == nil || n.isBlank() {
-		return nblank
+func inlParam(t *types.Field, as *ir.Node, inlvars map[*ir.Node]*ir.Node) *ir.Node {
+	n := ir.AsNode(t.Nname)
+	if n == nil || ir.IsBlank(n) {
+		return ir.BlankNode
 	}
 
 	inlvar := inlvars[n]
 	if inlvar == nil {
 		base.Fatalf("missing inlvar for %v", n)
 	}
-	as.Ninit.Append(nod(ODCL, inlvar, nil))
+	as.Ninit.Append(ir.Nod(ir.ODCL, inlvar, nil))
 	inlvar.Name.Defn = as
 	return inlvar
 }
@@ -886,11 +887,11 @@ var inlgen int
 // parameters.
 // The result of mkinlcall MUST be assigned back to n, e.g.
 // 	n.Left = mkinlcall(n.Left, fn, isddd)
-func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
+func mkinlcall(n, fn *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node {
 	if fn.Func.Inl == nil {
 		if logopt.Enabled() {
-			logopt.LogOpt(n.Pos, "cannotInlineCall", "inline", Curfn.funcname(),
-				fmt.Sprintf("%s cannot be inlined", fn.pkgFuncName()))
+			logopt.LogOpt(n.Pos, "cannotInlineCall", "inline", ir.FuncName(Curfn),
+				fmt.Sprintf("%s cannot be inlined", ir.PkgFuncName(fn)))
 		}
 		return n
 	}
@@ -898,8 +899,8 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 		// The inlined function body is too big. Typically we use this check to restrict
 		// inlining into very big functions.  See issue 26546 and 17566.
 		if logopt.Enabled() {
-			logopt.LogOpt(n.Pos, "cannotInlineCall", "inline", Curfn.funcname(),
-				fmt.Sprintf("cost %d of %s exceeds max large caller cost %d", fn.Func.Inl.Cost, fn.pkgFuncName(), maxCost))
+			logopt.LogOpt(n.Pos, "cannotInlineCall", "inline", ir.FuncName(Curfn),
+				fmt.Sprintf("cost %d of %s exceeds max large caller cost %d", fn.Func.Inl.Cost, ir.PkgFuncName(fn), maxCost))
 		}
 		return n
 	}
@@ -907,7 +908,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	if fn == Curfn || fn.Name.Defn == Curfn {
 		// Can't recursively inline a function into itself.
 		if logopt.Enabled() {
-			logopt.LogOpt(n.Pos, "cannotInlineCall", "inline", fmt.Sprintf("recursive call to %s", Curfn.funcname()))
+			logopt.LogOpt(n.Pos, "cannotInlineCall", "inline", fmt.Sprintf("recursive call to %s", ir.FuncName(Curfn)))
 		}
 		return n
 	}
@@ -924,7 +925,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 
 	if inlMap[fn] {
 		if base.Flag.LowerM > 1 {
-			fmt.Printf("%v: cannot inline %v into %v: repeated recursive cycle\n", n.Line(), fn, Curfn.funcname())
+			fmt.Printf("%v: cannot inline %v into %v: repeated recursive cycle\n", ir.Line(n), fn, ir.FuncName(Curfn))
 		}
 		return n
 	}
@@ -938,15 +939,15 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 
 	// We have a function node, and it has an inlineable body.
 	if base.Flag.LowerM > 1 {
-		fmt.Printf("%v: inlining call to %v %#v { %#v }\n", n.Line(), fn.Sym, fn.Type, asNodes(fn.Func.Inl.Body))
+		fmt.Printf("%v: inlining call to %v %#v { %#v }\n", ir.Line(n), fn.Sym, fn.Type, ir.AsNodes(fn.Func.Inl.Body))
 	} else if base.Flag.LowerM != 0 {
-		fmt.Printf("%v: inlining call to %v\n", n.Line(), fn)
+		fmt.Printf("%v: inlining call to %v\n", ir.Line(n), fn)
 	}
 	if base.Flag.LowerM > 2 {
-		fmt.Printf("%v: Before inlining: %+v\n", n.Line(), n)
+		fmt.Printf("%v: Before inlining: %+v\n", ir.Line(n), n)
 	}
 
-	if ssaDump != "" && ssaDump == Curfn.funcname() {
+	if ssaDump != "" && ssaDump == ir.FuncName(Curfn) {
 		ssaDumpInlined = append(ssaDumpInlined, fn)
 	}
 
@@ -956,28 +957,28 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	// may contain side effects (e.g., added by addinit during
 	// inlconv2expr or inlconv2list). Make sure to preserve these,
 	// if necessary (#42703).
-	if n.Op == OCALLFUNC {
+	if n.Op == ir.OCALLFUNC {
 		callee := n.Left
-		for callee.Op == OCONVNOP {
+		for callee.Op == ir.OCONVNOP {
 			ninit.AppendNodes(&callee.Ninit)
 			callee = callee.Left
 		}
-		if callee.Op != ONAME && callee.Op != OCLOSURE && callee.Op != OMETHEXPR {
+		if callee.Op != ir.ONAME && callee.Op != ir.OCLOSURE && callee.Op != ir.OMETHEXPR {
 			base.Fatalf("unexpected callee expression: %v", callee)
 		}
 	}
 
 	// Make temp names to use instead of the originals.
-	inlvars := make(map[*Node]*Node)
+	inlvars := make(map[*ir.Node]*ir.Node)
 
 	// record formals/locals for later post-processing
-	var inlfvars []*Node
+	var inlfvars []*ir.Node
 
 	// Handle captured variables when inlining closures.
 	if fn.Name.Defn != nil {
 		if c := fn.Name.Defn.Func.OClosure; c != nil {
 			for _, v := range c.Func.ClosureVars.Slice() {
-				if v.Op == OXXX {
+				if v.Op == ir.OXXX {
 					continue
 				}
 
@@ -987,38 +988,38 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 				// the reassigned check via some sort of copy propagation this would most
 				// likely need to be changed to a loop to walk up to the correct Param
 				if o == nil || (o.Name.Curfn != Curfn && o.Name.Curfn.Func.OClosure != Curfn) {
-					base.Fatalf("%v: unresolvable capture %v %v\n", n.Line(), fn, v)
+					base.Fatalf("%v: unresolvable capture %v %v\n", ir.Line(n), fn, v)
 				}
 
 				if v.Name.Byval() {
 					iv := typecheck(inlvar(v), ctxExpr)
-					ninit.Append(nod(ODCL, iv, nil))
-					ninit.Append(typecheck(nod(OAS, iv, o), ctxStmt))
+					ninit.Append(ir.Nod(ir.ODCL, iv, nil))
+					ninit.Append(typecheck(ir.Nod(ir.OAS, iv, o), ctxStmt))
 					inlvars[v] = iv
 				} else {
-					addr := newname(lookup("&" + v.Sym.Name))
+					addr := NewName(lookup("&" + v.Sym.Name))
 					addr.Type = types.NewPtr(v.Type)
 					ia := typecheck(inlvar(addr), ctxExpr)
-					ninit.Append(nod(ODCL, ia, nil))
-					ninit.Append(typecheck(nod(OAS, ia, nod(OADDR, o, nil)), ctxStmt))
+					ninit.Append(ir.Nod(ir.ODCL, ia, nil))
+					ninit.Append(typecheck(ir.Nod(ir.OAS, ia, ir.Nod(ir.OADDR, o, nil)), ctxStmt))
 					inlvars[addr] = ia
 
 					// When capturing by reference, all occurrence of the captured var
 					// must be substituted with dereference of the temporary address
-					inlvars[v] = typecheck(nod(ODEREF, ia, nil), ctxExpr)
+					inlvars[v] = typecheck(ir.Nod(ir.ODEREF, ia, nil), ctxExpr)
 				}
 			}
 		}
 	}
 
 	for _, ln := range fn.Func.Inl.Dcl {
-		if ln.Op != ONAME {
+		if ln.Op != ir.ONAME {
 			continue
 		}
-		if ln.Class() == PPARAMOUT { // return values handled below.
+		if ln.Class() == ir.PPARAMOUT { // return values handled below.
 			continue
 		}
-		if ln.isParamStackCopy() { // ignore the on-stack copy of a parameter that moved to the heap
+		if isParamStackCopy(ln) { // ignore the on-stack copy of a parameter that moved to the heap
 			// TODO(mdempsky): Remove once I'm confident
 			// this never actually happens. We currently
 			// perform inlining before escape analysis, so
@@ -1028,7 +1029,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 		inlf := typecheck(inlvar(ln), ctxExpr)
 		inlvars[ln] = inlf
 		if base.Flag.GenDwarfInl > 0 {
-			if ln.Class() == PPARAM {
+			if ln.Class() == ir.PPARAM {
 				inlf.Name.SetInlFormal(true)
 			} else {
 				inlf.Name.SetInlLocal(true)
@@ -1039,8 +1040,8 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	}
 
 	nreturns := 0
-	inspectList(asNodes(fn.Func.Inl.Body), func(n *Node) bool {
-		if n != nil && n.Op == ORETURN {
+	ir.InspectList(ir.AsNodes(fn.Func.Inl.Body), func(n *ir.Node) bool {
+		if n != nil && n.Op == ir.ORETURN {
 			nreturns++
 		}
 		return true
@@ -1052,10 +1053,10 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	delayretvars := nreturns == 1
 
 	// temporaries for return values.
-	var retvars []*Node
+	var retvars []*ir.Node
 	for i, t := range fn.Type.Results().Fields().Slice() {
-		var m *Node
-		if n := asNode(t.Nname); n != nil && !n.isBlank() && !strings.HasPrefix(n.Sym.Name, "~r") {
+		var m *ir.Node
+		if n := ir.AsNode(t.Nname); n != nil && !ir.IsBlank(n) && !strings.HasPrefix(n.Sym.Name, "~r") {
 			m = inlvar(n)
 			m = typecheck(m, ctxExpr)
 			inlvars[n] = m
@@ -1080,9 +1081,9 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	}
 
 	// Assign arguments to the parameters' temp names.
-	as := nod(OAS2, nil, nil)
+	as := ir.Nod(ir.OAS2, nil, nil)
 	as.SetColas(true)
-	if n.Op == OCALLMETH {
+	if n.Op == ir.OCALLMETH {
 		if n.Left.Left == nil {
 			base.Fatalf("method call without receiver: %+v", n)
 		}
@@ -1092,7 +1093,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 
 	// For non-dotted calls to variadic functions, we assign the
 	// variadic parameter's temp name separately.
-	var vas *Node
+	var vas *ir.Node
 
 	if recv := fn.Type.Recv(); recv != nil {
 		as.List.Append(inlParam(recv, as, inlvars))
@@ -1115,13 +1116,13 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 		}
 		varargs := as.List.Slice()[x:]
 
-		vas = nod(OAS, nil, nil)
+		vas = ir.Nod(ir.OAS, nil, nil)
 		vas.Left = inlParam(param, vas, inlvars)
 		if len(varargs) == 0 {
 			vas.Right = nodnil()
 			vas.Right.Type = param.Type
 		} else {
-			vas.Right = nod(OCOMPLIT, nil, typenod(param.Type))
+			vas.Right = ir.Nod(ir.OCOMPLIT, nil, typenod(param.Type))
 			vas.Right.List.Set(varargs)
 		}
 	}
@@ -1139,8 +1140,8 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	if !delayretvars {
 		// Zero the return parameters.
 		for _, n := range retvars {
-			ninit.Append(nod(ODCL, n, nil))
-			ras := nod(OAS, n, nil)
+			ninit.Append(ir.Nod(ir.ODCL, n, nil))
+			ras := ir.Nod(ir.OAS, n, nil)
 			ras = typecheck(ras, ctxStmt)
 			ninit.Append(ras)
 		}
@@ -1161,7 +1162,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	// to put a breakpoint. Not sure if that's really necessary or not
 	// (in which case it could go at the end of the function instead).
 	// Note issue 28603.
-	inlMark := nod(OINLMARK, nil, nil)
+	inlMark := ir.Nod(ir.OINLMARK, nil, nil)
 	inlMark.Pos = n.Pos.WithIsStmt()
 	inlMark.Xoffset = int64(newIndex)
 	ninit.Append(inlMark)
@@ -1182,9 +1183,9 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 		newInlIndex:  newIndex,
 	}
 
-	body := subst.list(asNodes(fn.Func.Inl.Body))
+	body := subst.list(ir.AsNodes(fn.Func.Inl.Body))
 
-	lab := nodSym(OLABEL, nil, retlabel)
+	lab := nodSym(ir.OLABEL, nil, retlabel)
 	body = append(body, lab)
 
 	typecheckslice(body, ctxStmt)
@@ -1197,7 +1198,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 
 	//dumplist("ninit post", ninit);
 
-	call := nod(OINLCALL, nil, nil)
+	call := ir.Nod(ir.OINLCALL, nil, nil)
 	call.Ninit.Set(ninit.Slice())
 	call.Nbody.Set(body)
 	call.Rlist.Set(retvars)
@@ -1212,13 +1213,13 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	// luckily these are small.
 	inlnodelist(call.Nbody, maxCost, inlMap)
 	for _, n := range call.Nbody.Slice() {
-		if n.Op == OINLCALL {
+		if n.Op == ir.OINLCALL {
 			inlconv2stmt(n)
 		}
 	}
 
 	if base.Flag.LowerM > 2 {
-		fmt.Printf("%v: After inlining %+v\n\n", call.Line(), call)
+		fmt.Printf("%v: After inlining %+v\n\n", ir.Line(call), call)
 	}
 
 	return call
@@ -1227,14 +1228,14 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 // Every time we expand a function we generate a new set of tmpnames,
 // PAUTO's in the calling functions, and link them off of the
 // PPARAM's, PAUTOS and PPARAMOUTs of the called function.
-func inlvar(var_ *Node) *Node {
+func inlvar(var_ *ir.Node) *ir.Node {
 	if base.Flag.LowerM > 3 {
 		fmt.Printf("inlvar %+v\n", var_)
 	}
 
-	n := newname(var_.Sym)
+	n := NewName(var_.Sym)
 	n.Type = var_.Type
-	n.SetClass(PAUTO)
+	n.SetClass(ir.PAUTO)
 	n.Name.SetUsed(true)
 	n.Name.Curfn = Curfn // the calling function, not the called one
 	n.Name.SetAddrtaken(var_.Name.Addrtaken())
@@ -1244,10 +1245,10 @@ func inlvar(var_ *Node) *Node {
 }
 
 // Synthesize a variable to store the inlined function's results in.
-func retvar(t *types.Field, i int) *Node {
-	n := newname(lookupN("~R", i))
+func retvar(t *types.Field, i int) *ir.Node {
+	n := NewName(lookupN("~R", i))
 	n.Type = t.Type
-	n.SetClass(PAUTO)
+	n.SetClass(ir.PAUTO)
 	n.Name.SetUsed(true)
 	n.Name.Curfn = Curfn // the calling function, not the called one
 	Curfn.Func.Dcl = append(Curfn.Func.Dcl, n)
@@ -1256,10 +1257,10 @@ func retvar(t *types.Field, i int) *Node {
 
 // Synthesize a variable to store the inlined function's arguments
 // when they come from a multiple return call.
-func argvar(t *types.Type, i int) *Node {
-	n := newname(lookupN("~arg", i))
+func argvar(t *types.Type, i int) *ir.Node {
+	n := NewName(lookupN("~arg", i))
 	n.Type = t.Elem()
-	n.SetClass(PAUTO)
+	n.SetClass(ir.PAUTO)
 	n.Name.SetUsed(true)
 	n.Name.Curfn = Curfn // the calling function, not the called one
 	Curfn.Func.Dcl = append(Curfn.Func.Dcl, n)
@@ -1273,13 +1274,13 @@ type inlsubst struct {
 	retlabel *types.Sym
 
 	// Temporary result variables.
-	retvars []*Node
+	retvars []*ir.Node
 
 	// Whether result variables should be initialized at the
 	// "return" statement.
 	delayretvars bool
 
-	inlvars map[*Node]*Node
+	inlvars map[*ir.Node]*ir.Node
 
 	// bases maps from original PosBase to PosBase with an extra
 	// inlined call frame.
@@ -1291,8 +1292,8 @@ type inlsubst struct {
 }
 
 // list inlines a list of nodes.
-func (subst *inlsubst) list(ll Nodes) []*Node {
-	s := make([]*Node, 0, ll.Len())
+func (subst *inlsubst) list(ll ir.Nodes) []*ir.Node {
+	s := make([]*ir.Node, 0, ll.Len())
 	for _, n := range ll.Slice() {
 		s = append(s, subst.node(n))
 	}
@@ -1303,13 +1304,13 @@ func (subst *inlsubst) list(ll Nodes) []*Node {
 // inlined function, substituting references to input/output
 // parameters with ones to the tmpnames, and substituting returns with
 // assignments to the output.
-func (subst *inlsubst) node(n *Node) *Node {
+func (subst *inlsubst) node(n *ir.Node) *ir.Node {
 	if n == nil {
 		return nil
 	}
 
 	switch n.Op {
-	case ONAME:
+	case ir.ONAME:
 		if inlvar := subst.inlvars[n]; inlvar != nil { // These will be set during inlnode
 			if base.Flag.LowerM > 2 {
 				fmt.Printf("substituting name %+v  ->  %+v\n", n, inlvar)
@@ -1322,10 +1323,10 @@ func (subst *inlsubst) node(n *Node) *Node {
 		}
 		return n
 
-	case OMETHEXPR:
+	case ir.OMETHEXPR:
 		return n
 
-	case OLITERAL, ONIL, OTYPE:
+	case ir.OLITERAL, ir.ONIL, ir.OTYPE:
 		// If n is a named constant or type, we can continue
 		// using it in the inline copy. Otherwise, make a copy
 		// so we can update the line number.
@@ -1336,12 +1337,12 @@ func (subst *inlsubst) node(n *Node) *Node {
 		// Since we don't handle bodies with closures, this return is guaranteed to belong to the current inlined function.
 
 	//		dump("Return before substitution", n);
-	case ORETURN:
-		m := nodSym(OGOTO, nil, subst.retlabel)
+	case ir.ORETURN:
+		m := nodSym(ir.OGOTO, nil, subst.retlabel)
 		m.Ninit.Set(subst.list(n.Ninit))
 
 		if len(subst.retvars) != 0 && n.List.Len() != 0 {
-			as := nod(OAS2, nil, nil)
+			as := ir.Nod(ir.OAS2, nil, nil)
 
 			// Make a shallow copy of retvars.
 			// Otherwise OINLCALL.Rlist will be the same list,
@@ -1353,7 +1354,7 @@ func (subst *inlsubst) node(n *Node) *Node {
 
 			if subst.delayretvars {
 				for _, n := range as.List.Slice() {
-					as.Ninit.Append(nod(ODCL, n, nil))
+					as.Ninit.Append(ir.Nod(ir.ODCL, n, nil))
 					n.Name.Defn = as
 				}
 			}
@@ -1368,8 +1369,8 @@ func (subst *inlsubst) node(n *Node) *Node {
 		//		dump("Return after substitution", m);
 		return m
 
-	case OGOTO, OLABEL:
-		m := n.copy()
+	case ir.OGOTO, ir.OLABEL:
+		m := ir.Copy(n)
 		m.Pos = subst.updatedPos(m.Pos)
 		m.Ninit.Set(nil)
 		p := fmt.Sprintf("%s·%d", n.Sym.Name, inlgen)
@@ -1378,11 +1379,11 @@ func (subst *inlsubst) node(n *Node) *Node {
 		return m
 	}
 
-	m := n.copy()
+	m := ir.Copy(n)
 	m.Pos = subst.updatedPos(m.Pos)
 	m.Ninit.Set(nil)
 
-	if n.Op == OCLOSURE {
+	if n.Op == ir.OCLOSURE {
 		base.Fatalf("cannot inline function containing closure: %+v", n)
 	}
 
@@ -1408,10 +1409,10 @@ func (subst *inlsubst) updatedPos(xpos src.XPos) src.XPos {
 	return base.Ctxt.PosTable.XPos(pos)
 }
 
-func pruneUnusedAutos(ll []*Node, vis *hairyVisitor) []*Node {
-	s := make([]*Node, 0, len(ll))
+func pruneUnusedAutos(ll []*ir.Node, vis *hairyVisitor) []*ir.Node {
+	s := make([]*ir.Node, 0, len(ll))
 	for _, n := range ll {
-		if n.Class() == PAUTO {
+		if n.Class() == ir.PAUTO {
 			if _, found := vis.usedLocals[n]; !found {
 				continue
 			}
@@ -1423,19 +1424,19 @@ func pruneUnusedAutos(ll []*Node, vis *hairyVisitor) []*Node {
 
 // devirtualize replaces interface method calls within fn with direct
 // concrete-type method calls where applicable.
-func devirtualize(fn *Node) {
+func devirtualize(fn *ir.Node) {
 	Curfn = fn
-	inspectList(fn.Nbody, func(n *Node) bool {
-		if n.Op == OCALLINTER {
+	ir.InspectList(fn.Nbody, func(n *ir.Node) bool {
+		if n.Op == ir.OCALLINTER {
 			devirtualizeCall(n)
 		}
 		return true
 	})
 }
 
-func devirtualizeCall(call *Node) {
+func devirtualizeCall(call *ir.Node) {
 	recv := staticValue(call.Left.Left)
-	if recv.Op != OCONVIFACE {
+	if recv.Op != ir.OCONVIFACE {
 		return
 	}
 
@@ -1444,23 +1445,23 @@ func devirtualizeCall(call *Node) {
 		return
 	}
 
-	x := nodl(call.Left.Pos, ODOTTYPE, call.Left.Left, nil)
+	x := ir.NodAt(call.Left.Pos, ir.ODOTTYPE, call.Left.Left, nil)
 	x.Type = typ
-	x = nodlSym(call.Left.Pos, OXDOT, x, call.Left.Sym)
+	x = nodlSym(call.Left.Pos, ir.OXDOT, x, call.Left.Sym)
 	x = typecheck(x, ctxExpr|ctxCallee)
 	switch x.Op {
-	case ODOTMETH:
+	case ir.ODOTMETH:
 		if base.Flag.LowerM != 0 {
 			base.WarnfAt(call.Pos, "devirtualizing %v to %v", call.Left, typ)
 		}
-		call.Op = OCALLMETH
+		call.Op = ir.OCALLMETH
 		call.Left = x
-	case ODOTINTER:
+	case ir.ODOTINTER:
 		// Promoted method from embedded interface-typed field (#42279).
 		if base.Flag.LowerM != 0 {
 			base.WarnfAt(call.Pos, "partially devirtualizing %v to %v", call.Left, typ)
 		}
-		call.Op = OCALLINTER
+		call.Op = ir.OCALLINTER
 		call.Left = x
 	default:
 		// TODO(mdempsky): Turn back into Fatalf after more testing.
diff --git a/src/cmd/compile/internal/gc/lex.go b/src/cmd/compile/internal/gc/lex.go
index 30ef4d0eb2..39d73867e4 100644
--- a/src/cmd/compile/internal/gc/lex.go
+++ b/src/cmd/compile/internal/gc/lex.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/syntax"
 	"cmd/internal/objabi"
 	"cmd/internal/src"
@@ -25,78 +26,51 @@ func isQuoted(s string) bool {
 	return len(s) >= 2 && s[0] == '"' && s[len(s)-1] == '"'
 }
 
-type PragmaFlag int16
-
-const (
-	// Func pragmas.
-	Nointerface    PragmaFlag = 1 << iota
-	Noescape                  // func parameters don't escape
-	Norace                    // func must not have race detector annotations
-	Nosplit                   // func should not execute on separate stack
-	Noinline                  // func should not be inlined
-	NoCheckPtr                // func should not be instrumented by checkptr
-	CgoUnsafeArgs             // treat a pointer to one arg as a pointer to them all
-	UintptrEscapes            // pointers converted to uintptr escape
-
-	// Runtime-only func pragmas.
-	// See ../../../../runtime/README.md for detailed descriptions.
-	Systemstack        // func must run on system stack
-	Nowritebarrier     // emit compiler error instead of write barrier
-	Nowritebarrierrec  // error on write barrier in this or recursive callees
-	Yeswritebarrierrec // cancels Nowritebarrierrec in this function and callees
-
-	// Runtime and cgo type pragmas
-	NotInHeap // values of this type must not be heap allocated
-
-	// Go command pragmas
-	GoBuildPragma
-)
-
 const (
-	FuncPragmas = Nointerface |
-		Noescape |
-		Norace |
-		Nosplit |
-		Noinline |
-		NoCheckPtr |
-		CgoUnsafeArgs |
-		UintptrEscapes |
-		Systemstack |
-		Nowritebarrier |
-		Nowritebarrierrec |
-		Yeswritebarrierrec
-
-	TypePragmas = NotInHeap
+	FuncPragmas = ir.Nointerface |
+		ir.Noescape |
+		ir.Norace |
+		ir.Nosplit |
+		ir.Noinline |
+		ir.NoCheckPtr |
+		ir.CgoUnsafeArgs |
+		ir.UintptrEscapes |
+		ir.Systemstack |
+		ir.Nowritebarrier |
+		ir.Nowritebarrierrec |
+		ir.Yeswritebarrierrec
+
+	TypePragmas = ir.NotInHeap
 )
 
-func pragmaFlag(verb string) PragmaFlag {
+func pragmaFlag(verb string) ir.PragmaFlag {
 	switch verb {
 	case "go:build":
-		return GoBuildPragma
+		return ir.GoBuildPragma
 	case "go:nointerface":
 		if objabi.Fieldtrack_enabled != 0 {
-			return Nointerface
+			return ir.Nointerface
 		}
 	case "go:noescape":
-		return Noescape
+		return ir.Noescape
 	case "go:norace":
-		return Norace
+		return ir.Norace
 	case "go:nosplit":
-		return Nosplit | NoCheckPtr // implies NoCheckPtr (see #34972)
+		return ir.Nosplit | ir.NoCheckPtr // implies NoCheckPtr (see #34972)
 	case "go:noinline":
-		return Noinline
+		return ir.Noinline
 	case "go:nocheckptr":
-		return NoCheckPtr
+		return ir.NoCheckPtr
 	case "go:systemstack":
-		return Systemstack
+		return ir.Systemstack
 	case "go:nowritebarrier":
-		return Nowritebarrier
+		return ir.Nowritebarrier
 	case "go:nowritebarrierrec":
-		return Nowritebarrierrec | Nowritebarrier // implies Nowritebarrier
+		return ir.Nowritebarrierrec | ir.Nowritebarrier // implies Nowritebarrier
 	case "go:yeswritebarrierrec":
-		return Yeswritebarrierrec
+		return ir.Yeswritebarrierrec
 	case "go:cgo_unsafe_args":
-		return CgoUnsafeArgs | NoCheckPtr // implies NoCheckPtr (see #34968)
+		return ir.CgoUnsafeArgs | ir.NoCheckPtr // implies NoCheckPtr (see #34968)
 	case "go:uintptrescapes":
 		// For the next function declared in the file
 		// any uintptr arguments may be pointer values
@@ -109,9 +83,9 @@ func pragmaFlag(verb string) PragmaFlag {
 		// call. The conversion to uintptr must appear
 		// in the argument list.
 		// Used in syscall/dll_windows.go.
-		return UintptrEscapes
+		return ir.UintptrEscapes
 	case "go:notinheap":
-		return NotInHeap
+		return ir.NotInHeap
 	}
 	return 0
 }
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index c66139027a..24e926602b 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -10,6 +10,7 @@ import (
 	"bufio"
 	"bytes"
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
@@ -73,17 +74,17 @@ func Main(archInit func(*Arch)) {
 	// See bugs 31188 and 21945 (CLs 170638, 98075, 72371).
 	base.Ctxt.UseBASEntries = base.Ctxt.Headtype != objabi.Hdarwin
 
-	localpkg = types.NewPkg("", "")
-	localpkg.Prefix = "\"\""
+	ir.LocalPkg = types.NewPkg("", "")
+	ir.LocalPkg.Prefix = "\"\""
 
 	// We won't know localpkg's height until after import
 	// processing. In the mean time, set to MaxPkgHeight to ensure
 	// height comparisons at least work until then.
-	localpkg.Height = types.MaxPkgHeight
+	ir.LocalPkg.Height = types.MaxPkgHeight
 
 	// pseudo-package, for scoping
-	builtinpkg = types.NewPkg("go.builtin", "") // TODO(gri) name this package go.builtin?
-	builtinpkg.Prefix = "go.builtin"            // not go%2ebuiltin
+	ir.BuiltinPkg = types.NewPkg("go.builtin", "") // TODO(gri) name this package go.builtin?
+	ir.BuiltinPkg.Prefix = "go.builtin"            // not go%2ebuiltin
 
 	// pseudo-package, accessed by import "unsafe"
 	unsafepkg = types.NewPkg("unsafe", "unsafe")
@@ -209,29 +210,18 @@ func Main(archInit func(*Arch)) {
 	types.Widthptr = Widthptr
 	types.Dowidth = dowidth
 	types.Fatalf = base.Fatalf
-	types.Sconv = func(s *types.Sym, flag, mode int) string {
-		return sconv(s, FmtFlag(flag), fmtMode(mode))
-	}
-	types.Tconv = func(t *types.Type, flag, mode int) string {
-		return tconv(t, FmtFlag(flag), fmtMode(mode))
-	}
-	types.FormatSym = func(sym *types.Sym, s fmt.State, verb rune, mode int) {
-		symFormat(sym, s, verb, fmtMode(mode))
-	}
-	types.FormatType = func(t *types.Type, s fmt.State, verb rune, mode int) {
-		typeFormat(t, s, verb, fmtMode(mode))
-	}
+	ir.InstallTypeFormats()
 	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
 		return typenamesym(t).Linksym()
 	}
-	types.FmtLeft = int(FmtLeft)
-	types.FmtUnsigned = int(FmtUnsigned)
-	types.FErr = int(FErr)
+	types.FmtLeft = int(ir.FmtLeft)
+	types.FmtUnsigned = int(ir.FmtUnsigned)
+	types.FErr = int(ir.FErr)
 	types.Ctxt = base.Ctxt
 
 	initUniverse()
 
-	dclcontext = PEXTERN
+	dclcontext = ir.PEXTERN
 
 	autogeneratedPos = makePos(src.NewFileBase("<autogenerated>", "<autogenerated>"), 1, 0)
 
@@ -263,7 +253,7 @@ func Main(archInit func(*Arch)) {
 	timings.Start("fe", "typecheck", "top1")
 	for i := 0; i < len(xtop); i++ {
 		n := xtop[i]
-		if op := n.Op; op != ODCL && op != OAS && op != OAS2 && (op != ODCLTYPE || !n.Left.Name.Param.Alias()) {
+		if op := n.Op; op != ir.ODCL && op != ir.OAS && op != ir.OAS2 && (op != ir.ODCLTYPE || !n.Left.Name.Param.Alias()) {
 			xtop[i] = typecheck(n, ctxStmt)
 		}
 	}
@@ -275,7 +265,7 @@ func Main(archInit func(*Arch)) {
 	timings.Start("fe", "typecheck", "top2")
 	for i := 0; i < len(xtop); i++ {
 		n := xtop[i]
-		if op := n.Op; op == ODCL || op == OAS || op == OAS2 || op == ODCLTYPE && n.Left.Name.Param.Alias() {
+		if op := n.Op; op == ir.ODCL || op == ir.OAS || op == ir.OAS2 || op == ir.ODCLTYPE && n.Left.Name.Param.Alias() {
 			xtop[i] = typecheck(n, ctxStmt)
 		}
 	}
@@ -286,7 +276,7 @@ func Main(archInit func(*Arch)) {
 	var fcount int64
 	for i := 0; i < len(xtop); i++ {
 		n := xtop[i]
-		if n.Op == ODCLFUNC {
+		if n.Op == ir.ODCLFUNC {
 			Curfn = n
 			decldepth = 1
 			errorsBefore := base.Errors()
@@ -316,7 +306,7 @@ func Main(archInit func(*Arch)) {
 	// because variables captured by value do not escape.
 	timings.Start("fe", "capturevars")
 	for _, n := range xtop {
-		if n.Op == ODCLFUNC && n.Func.OClosure != nil {
+		if n.Op == ir.ODCLFUNC && n.Func.OClosure != nil {
 			Curfn = n
 			capturevars(n)
 		}
@@ -340,7 +330,7 @@ func Main(archInit func(*Arch)) {
 
 	if base.Flag.LowerL != 0 {
 		// Find functions that can be inlined and clone them before walk expands them.
-		visitBottomUp(xtop, func(list []*Node, recursive bool) {
+		visitBottomUp(xtop, func(list []*ir.Node, recursive bool) {
 			numfns := numNonClosures(list)
 			for _, n := range list {
 				if !recursive || numfns > 1 {
@@ -350,7 +340,7 @@ func Main(archInit func(*Arch)) {
 					caninl(n)
 				} else {
 					if base.Flag.LowerM > 1 {
-						fmt.Printf("%v: cannot inline %v: recursive\n", n.Line(), n.Func.Nname)
+						fmt.Printf("%v: cannot inline %v: recursive\n", ir.Line(n), n.Func.Nname)
 					}
 				}
 				inlcalls(n)
@@ -359,7 +349,7 @@ func Main(archInit func(*Arch)) {
 	}
 
 	for _, n := range xtop {
-		if n.Op == ODCLFUNC {
+		if n.Op == ir.ODCLFUNC {
 			devirtualize(n)
 		}
 	}
@@ -389,7 +379,7 @@ func Main(archInit func(*Arch)) {
 	// before walk reaches a call of a closure.
 	timings.Start("fe", "xclosures")
 	for _, n := range xtop {
-		if n.Op == ODCLFUNC && n.Func.OClosure != nil {
+		if n.Op == ir.ODCLFUNC && n.Func.OClosure != nil {
 			Curfn = n
 			transformclosure(n)
 		}
@@ -412,7 +402,7 @@ func Main(archInit func(*Arch)) {
 	fcount = 0
 	for i := 0; i < len(xtop); i++ {
 		n := xtop[i]
-		if n.Op == ODCLFUNC {
+		if n.Op == ir.ODCLFUNC {
 			funccompile(n)
 			fcount++
 		}
@@ -440,7 +430,7 @@ func Main(archInit func(*Arch)) {
 	// Phase 9: Check external declarations.
 	timings.Start("be", "externaldcls")
 	for i, n := range externdcl {
-		if n.Op == ONAME {
+		if n.Op == ir.ONAME {
 			externdcl[i] = typecheck(externdcl[i], ctxExpr)
 		}
 	}
@@ -491,7 +481,7 @@ func Main(archInit func(*Arch)) {
 }
 
 // numNonClosures returns the number of functions in list which are not closures.
-func numNonClosures(list []*Node) int {
+func numNonClosures(list []*ir.Node) int {
 	count := 0
 	for _, n := range list {
 		if n.Func.OClosure == nil {
@@ -934,14 +924,14 @@ func pkgnotused(lineno src.XPos, path string, name string) {
 }
 
 func mkpackage(pkgname string) {
-	if localpkg.Name == "" {
+	if ir.LocalPkg.Name == "" {
 		if pkgname == "_" {
 			base.Errorf("invalid package name _")
 		}
-		localpkg.Name = pkgname
+		ir.LocalPkg.Name = pkgname
 	} else {
-		if pkgname != localpkg.Name {
-			base.Errorf("package %s; expected %s", pkgname, localpkg.Name)
+		if pkgname != ir.LocalPkg.Name {
+			base.Errorf("package %s; expected %s", pkgname, ir.LocalPkg.Name)
 		}
 	}
 }
@@ -954,12 +944,12 @@ func clearImports() {
 	}
 	var unused []importedPkg
 
-	for _, s := range localpkg.Syms {
-		n := asNode(s.Def)
+	for _, s := range ir.LocalPkg.Syms {
+		n := ir.AsNode(s.Def)
 		if n == nil {
 			continue
 		}
-		if n.Op == OPACK {
+		if n.Op == ir.OPACK {
 			// throw away top-level package name left over
 			// from previous file.
 			// leave s->block set to cause redeclaration
@@ -990,7 +980,7 @@ func clearImports() {
 }
 
 func IsAlias(sym *types.Sym) bool {
-	return sym.Def != nil && asNode(sym.Def).Sym != sym
+	return sym.Def != nil && ir.AsNode(sym.Def).Sym != sym
 }
 
 // recordFlags records the specified command-line flags to be placed
@@ -1057,7 +1047,7 @@ func recordPackageName() {
 	// together two package main archives. So allow dups.
 	s.Set(obj.AttrDuplicateOK, true)
 	base.Ctxt.Data = append(base.Ctxt.Data, s)
-	s.P = []byte(localpkg.Name)
+	s.P = []byte(ir.LocalPkg.Name)
 }
 
 // currentLang returns the current language version.
@@ -1084,9 +1074,9 @@ var langWant lang
 func langSupported(major, minor int, pkg *types.Pkg) bool {
 	if pkg == nil {
 		// TODO(mdempsky): Set Pkg for local types earlier.
-		pkg = localpkg
+		pkg = ir.LocalPkg
 	}
-	if pkg != localpkg {
+	if pkg != ir.LocalPkg {
 		// Assume imported packages passed type-checking.
 		return true
 	}
diff --git a/src/cmd/compile/internal/gc/mkbuiltin.go b/src/cmd/compile/internal/gc/mkbuiltin.go
index 63d2a12c07..8fa6d02f2c 100644
--- a/src/cmd/compile/internal/gc/mkbuiltin.go
+++ b/src/cmd/compile/internal/gc/mkbuiltin.go
@@ -35,7 +35,10 @@ func main() {
 	fmt.Fprintln(&b)
 	fmt.Fprintln(&b, "package gc")
 	fmt.Fprintln(&b)
-	fmt.Fprintln(&b, `import "cmd/compile/internal/types"`)
+	fmt.Fprintln(&b, `import (`)
+	fmt.Fprintln(&b, `      "cmd/compile/internal/ir"`)
+	fmt.Fprintln(&b, `      "cmd/compile/internal/types"`)
+	fmt.Fprintln(&b, `)`)
 
 	mkbuiltin(&b, "runtime")
 
@@ -144,12 +147,12 @@ func (i *typeInterner) mktype(t ast.Expr) string {
 		case "rune":
 			return "types.Runetype"
 		}
-		return fmt.Sprintf("types.Types[T%s]", strings.ToUpper(t.Name))
+		return fmt.Sprintf("types.Types[types.T%s]", strings.ToUpper(t.Name))
 	case *ast.SelectorExpr:
 		if t.X.(*ast.Ident).Name != "unsafe" || t.Sel.Name != "Pointer" {
 			log.Fatalf("unhandled type: %#v", t)
 		}
-		return "types.Types[TUNSAFEPTR]"
+		return "types.Types[types.TUNSAFEPTR]"
 
 	case *ast.ArrayType:
 		if t.Len == nil {
@@ -171,7 +174,7 @@ func (i *typeInterner) mktype(t ast.Expr) string {
 		if len(t.Methods.List) != 0 {
 			log.Fatal("non-empty interfaces unsupported")
 		}
-		return "types.Types[TINTER]"
+		return "types.Types[types.TINTER]"
 	case *ast.MapType:
 		return fmt.Sprintf("types.NewMap(%s, %s)", i.subtype(t.Key), i.subtype(t.Value))
 	case *ast.StarExpr:
@@ -204,7 +207,7 @@ func (i *typeInterner) fields(fl *ast.FieldList, keepNames bool) string {
 			}
 		}
 	}
-	return fmt.Sprintf("[]*Node{%s}", strings.Join(res, ", "))
+	return fmt.Sprintf("[]*ir.Node{%s}", strings.Join(res, ", "))
 }
 
 func intconst(e ast.Expr) int64 {
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 6dae2cd0a4..eeed3740f0 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -17,6 +17,7 @@ import (
 	"unicode/utf8"
 
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/syntax"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -74,7 +75,7 @@ func parseFiles(filenames []string) uint {
 		testdclstack()
 	}
 
-	localpkg.Height = myheight
+	ir.LocalPkg.Height = myheight
 
 	return lines
 }
@@ -140,7 +141,7 @@ type noder struct {
 	linknames      []linkname
 	pragcgobuf     [][]string
 	err            chan syntax.Error
-	scope          ScopeID
+	scope          ir.ScopeID
 	importedUnsafe bool
 	importedEmbed  bool
 
@@ -151,7 +152,7 @@ type noder struct {
 	lastCloseScopePos syntax.Pos
 }
 
-func (p *noder) funcBody(fn *Node, block *syntax.BlockStmt) {
+func (p *noder) funcBody(fn *ir.Node, block *syntax.BlockStmt) {
 	oldScope := p.scope
 	p.scope = 0
 	funchdr(fn)
@@ -159,7 +160,7 @@ func (p *noder) funcBody(fn *Node, block *syntax.BlockStmt) {
 	if block != nil {
 		body := p.stmts(block.List)
 		if body == nil {
-			body = []*Node{nod(OEMPTY, nil, nil)}
+			body = []*ir.Node{ir.Nod(ir.OEMPTY, nil, nil)}
 		}
 		fn.Nbody.Set(body)
 
@@ -177,7 +178,7 @@ func (p *noder) openScope(pos syntax.Pos) {
 	if trackScopes {
 		Curfn.Func.Parents = append(Curfn.Func.Parents, p.scope)
 		p.scopeVars = append(p.scopeVars, len(Curfn.Func.Dcl))
-		p.scope = ScopeID(len(Curfn.Func.Parents))
+		p.scope = ir.ScopeID(len(Curfn.Func.Parents))
 
 		p.markScope(pos)
 	}
@@ -202,7 +203,7 @@ func (p *noder) closeScope(pos syntax.Pos) {
 
 			nmarks := len(Curfn.Func.Marks)
 			Curfn.Func.Marks[nmarks-1].Scope = p.scope
-			prevScope := ScopeID(0)
+			prevScope := ir.ScopeID(0)
 			if nmarks >= 2 {
 				prevScope = Curfn.Func.Marks[nmarks-2].Scope
 			}
@@ -223,7 +224,7 @@ func (p *noder) markScope(pos syntax.Pos) {
 	if i := len(Curfn.Func.Marks); i > 0 && Curfn.Func.Marks[i-1].Pos == xpos {
 		Curfn.Func.Marks[i-1].Scope = p.scope
 	} else {
-		Curfn.Func.Marks = append(Curfn.Func.Marks, Mark{xpos, p.scope})
+		Curfn.Func.Marks = append(Curfn.Func.Marks, ir.Mark{Pos: xpos, Scope: p.scope})
 	}
 }
 
@@ -251,7 +252,7 @@ func (p *noder) node() {
 	mkpackage(p.file.PkgName.Value)
 
 	if pragma, ok := p.file.Pragma.(*Pragma); ok {
-		pragma.Flag &^= GoBuildPragma
+		pragma.Flag &^= ir.GoBuildPragma
 		p.checkUnused(pragma)
 	}
 
@@ -293,7 +294,7 @@ func (p *noder) node() {
 	clearImports()
 }
 
-func (p *noder) decls(decls []syntax.Decl) (l []*Node) {
+func (p *noder) decls(decls []syntax.Decl) (l []*ir.Node) {
 	var cs constState
 
 	for _, decl := range decls {
@@ -355,7 +356,7 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
 		my = lookup(ipkg.Name)
 	}
 
-	pack := p.nod(imp, OPACK, nil, nil)
+	pack := p.nod(imp, ir.OPACK, nil, nil)
 	pack.Sym = my
 	pack.Name.Pkg = ipkg
 
@@ -372,16 +373,16 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
 	if my.Def != nil {
 		redeclare(pack.Pos, my, "as imported package name")
 	}
-	my.Def = asTypesNode(pack)
+	my.Def = ir.AsTypesNode(pack)
 	my.Lastlineno = pack.Pos
 	my.Block = 1 // at top level
 }
 
-func (p *noder) varDecl(decl *syntax.VarDecl) []*Node {
+func (p *noder) varDecl(decl *syntax.VarDecl) []*ir.Node {
 	names := p.declNames(decl.NameList)
 	typ := p.typeExprOrNil(decl.Type)
 
-	var exprs []*Node
+	var exprs []*ir.Node
 	if decl.Values != nil {
 		exprs = p.exprList(decl.Values)
 	}
@@ -413,12 +414,12 @@ func (p *noder) varDecl(decl *syntax.VarDecl) []*Node {
 // constant declarations are handled correctly (e.g., issue 15550).
 type constState struct {
 	group  *syntax.Group
-	typ    *Node
-	values []*Node
+	typ    *ir.Node
+	values []*ir.Node
 	iota   int64
 }
 
-func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []*Node {
+func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []*ir.Node {
 	if decl.Group == nil || decl.Group != cs.group {
 		*cs = constState{
 			group: decl.Group,
@@ -432,7 +433,7 @@ func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []*Node {
 	names := p.declNames(decl.NameList)
 	typ := p.typeExprOrNil(decl.Type)
 
-	var values []*Node
+	var values []*ir.Node
 	if decl.Values != nil {
 		values = p.exprList(decl.Values)
 		cs.typ, cs.values = typ, values
@@ -443,7 +444,7 @@ func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []*Node {
 		typ, values = cs.typ, cs.values
 	}
 
-	nn := make([]*Node, 0, len(names))
+	nn := make([]*ir.Node, 0, len(names))
 	for i, n := range names {
 		if i >= len(values) {
 			base.Errorf("missing value in const declaration")
@@ -454,14 +455,14 @@ func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []*Node {
 			v = treecopy(v, n.Pos)
 		}
 
-		n.Op = OLITERAL
+		n.Op = ir.OLITERAL
 		declare(n, dclcontext)
 
 		n.Name.Param.Ntype = typ
 		n.Name.Defn = v
 		n.SetIota(cs.iota)
 
-		nn = append(nn, p.nod(decl, ODCLCONST, n, nil))
+		nn = append(nn, p.nod(decl, ir.ODCLCONST, n, nil))
 	}
 
 	if len(values) > len(names) {
@@ -473,9 +474,9 @@ func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []*Node {
 	return nn
 }
 
-func (p *noder) typeDecl(decl *syntax.TypeDecl) *Node {
+func (p *noder) typeDecl(decl *syntax.TypeDecl) *ir.Node {
 	n := p.declName(decl.Name)
-	n.Op = OTYPE
+	n.Op = ir.OTYPE
 	declare(n, dclcontext)
 
 	// decl.Type may be nil but in that case we got a syntax error during parsing
@@ -492,31 +493,31 @@ func (p *noder) typeDecl(decl *syntax.TypeDecl) *Node {
 		p.checkUnused(pragma)
 	}
 
-	nod := p.nod(decl, ODCLTYPE, n, nil)
-	if param.Alias() && !langSupported(1, 9, localpkg) {
+	nod := p.nod(decl, ir.ODCLTYPE, n, nil)
+	if param.Alias() && !langSupported(1, 9, ir.LocalPkg) {
 		base.ErrorfAt(nod.Pos, "type aliases only supported as of -lang=go1.9")
 	}
 	return nod
 }
 
-func (p *noder) declNames(names []*syntax.Name) []*Node {
-	nodes := make([]*Node, 0, len(names))
+func (p *noder) declNames(names []*syntax.Name) []*ir.Node {
+	nodes := make([]*ir.Node, 0, len(names))
 	for _, name := range names {
 		nodes = append(nodes, p.declName(name))
 	}
 	return nodes
 }
 
-func (p *noder) declName(name *syntax.Name) *Node {
+func (p *noder) declName(name *syntax.Name) *ir.Node {
 	n := dclname(p.name(name))
 	n.Pos = p.pos(name)
 	return n
 }
 
-func (p *noder) funcDecl(fun *syntax.FuncDecl) *Node {
+func (p *noder) funcDecl(fun *syntax.FuncDecl) *ir.Node {
 	name := p.name(fun.Name)
 	t := p.signature(fun.Recv, fun.Type)
-	f := p.nod(fun, ODCLFUNC, nil, nil)
+	f := p.nod(fun, ir.ODCLFUNC, nil, nil)
 
 	if fun.Recv == nil {
 		if name.Name == "init" {
@@ -526,14 +527,14 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) *Node {
 			}
 		}
 
-		if localpkg.Name == "main" && name.Name == "main" {
+		if ir.LocalPkg.Name == "main" && name.Name == "main" {
 			if t.List.Len() > 0 || t.Rlist.Len() > 0 {
 				base.ErrorfAt(f.Pos, "func main must have no arguments and no return values")
 			}
 		}
 	} else {
 		f.Func.Shortname = name
-		name = nblank.Sym // filled in by typecheckfunc
+		name = ir.BlankNode.Sym // filled in by typecheckfunc
 	}
 
 	f.Func.Nname = newfuncnamel(p.pos(fun.Name), name, f.Func)
@@ -542,7 +543,7 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) *Node {
 
 	if pragma, ok := fun.Pragma.(*Pragma); ok {
 		f.Func.Pragma = pragma.Flag & FuncPragmas
-		if pragma.Flag&Systemstack != 0 && pragma.Flag&Nosplit != 0 {
+		if pragma.Flag&ir.Systemstack != 0 && pragma.Flag&ir.Nosplit != 0 {
 			base.ErrorfAt(f.Pos, "go:nosplit and go:systemstack cannot be combined")
 		}
 		pragma.Flag &^= FuncPragmas
@@ -550,22 +551,22 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) *Node {
 	}
 
 	if fun.Recv == nil {
-		declare(f.Func.Nname, PFUNC)
+		declare(f.Func.Nname, ir.PFUNC)
 	}
 
 	p.funcBody(f, fun.Body)
 
 	if fun.Body != nil {
-		if f.Func.Pragma&Noescape != 0 {
+		if f.Func.Pragma&ir.Noescape != 0 {
 			base.ErrorfAt(f.Pos, "can only use //go:noescape with external func implementations")
 		}
 	} else {
-		if base.Flag.Complete || strings.HasPrefix(f.funcname(), "init.") {
+		if base.Flag.Complete || strings.HasPrefix(ir.FuncName(f), "init.") {
 			// Linknamed functions are allowed to have no body. Hopefully
 			// the linkname target has a body. See issue 23311.
 			isLinknamed := false
 			for _, n := range p.linknames {
-				if f.funcname() == n.local {
+				if ir.FuncName(f) == n.local {
 					isLinknamed = true
 					break
 				}
@@ -579,8 +580,8 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) *Node {
 	return f
 }
 
-func (p *noder) signature(recv *syntax.Field, typ *syntax.FuncType) *Node {
-	n := p.nod(typ, OTFUNC, nil, nil)
+func (p *noder) signature(recv *syntax.Field, typ *syntax.FuncType) *ir.Node {
+	n := p.nod(typ, ir.OTFUNC, nil, nil)
 	if recv != nil {
 		n.Left = p.param(recv, false, false)
 	}
@@ -589,8 +590,8 @@ func (p *noder) signature(recv *syntax.Field, typ *syntax.FuncType) *Node {
 	return n
 }
 
-func (p *noder) params(params []*syntax.Field, dddOk bool) []*Node {
-	nodes := make([]*Node, 0, len(params))
+func (p *noder) params(params []*syntax.Field, dddOk bool) []*ir.Node {
+	nodes := make([]*ir.Node, 0, len(params))
 	for i, param := range params {
 		p.setlineno(param)
 		nodes = append(nodes, p.param(param, dddOk, i+1 == len(params)))
@@ -598,17 +599,17 @@ func (p *noder) params(params []*syntax.Field, dddOk bool) []*Node {
 	return nodes
 }
 
-func (p *noder) param(param *syntax.Field, dddOk, final bool) *Node {
+func (p *noder) param(param *syntax.Field, dddOk, final bool) *ir.Node {
 	var name *types.Sym
 	if param.Name != nil {
 		name = p.name(param.Name)
 	}
 
 	typ := p.typeExpr(param.Type)
-	n := p.nodSym(param, ODCLFIELD, typ, name)
+	n := p.nodSym(param, ir.ODCLFIELD, typ, name)
 
 	// rewrite ...T parameter
-	if typ.Op == ODDD {
+	if typ.Op == ir.ODDD {
 		if !dddOk {
 			// We mark these as syntax errors to get automatic elimination
 			// of multiple such errors per line (see ErrorfAt in subr.go).
@@ -620,7 +621,7 @@ func (p *noder) param(param *syntax.Field, dddOk, final bool) *Node {
 				p.errorAt(param.Name.Pos(), "syntax error: cannot use ... with non-final parameter %s", param.Name.Value)
 			}
 		}
-		typ.Op = OTARRAY
+		typ.Op = ir.OTARRAY
 		typ.Right = typ.Left
 		typ.Left = nil
 		n.SetIsDDD(true)
@@ -632,22 +633,22 @@ func (p *noder) param(param *syntax.Field, dddOk, final bool) *Node {
 	return n
 }
 
-func (p *noder) exprList(expr syntax.Expr) []*Node {
+func (p *noder) exprList(expr syntax.Expr) []*ir.Node {
 	if list, ok := expr.(*syntax.ListExpr); ok {
 		return p.exprs(list.ElemList)
 	}
-	return []*Node{p.expr(expr)}
+	return []*ir.Node{p.expr(expr)}
 }
 
-func (p *noder) exprs(exprs []syntax.Expr) []*Node {
-	nodes := make([]*Node, 0, len(exprs))
+func (p *noder) exprs(exprs []syntax.Expr) []*ir.Node {
+	nodes := make([]*ir.Node, 0, len(exprs))
 	for _, expr := range exprs {
 		nodes = append(nodes, p.expr(expr))
 	}
 	return nodes
 }
 
-func (p *noder) expr(expr syntax.Expr) *Node {
+func (p *noder) expr(expr syntax.Expr) *ir.Node {
 	p.setlineno(expr)
 	switch expr := expr.(type) {
 	case nil, *syntax.BadExpr:
@@ -655,14 +656,14 @@ func (p *noder) expr(expr syntax.Expr) *Node {
 	case *syntax.Name:
 		return p.mkname(expr)
 	case *syntax.BasicLit:
-		n := nodlit(p.basicLit(expr))
+		n := ir.NewLiteral(p.basicLit(expr))
 		if expr.Kind == syntax.RuneLit {
 			n.Type = types.UntypedRune
 		}
 		n.SetDiag(expr.Bad) // avoid follow-on errors if there was a syntax error
 		return n
 	case *syntax.CompositeLit:
-		n := p.nod(expr, OCOMPLIT, nil, nil)
+		n := p.nod(expr, ir.OCOMPLIT, nil, nil)
 		if expr.Type != nil {
 			n.Right = p.expr(expr.Type)
 		}
@@ -675,30 +676,30 @@ func (p *noder) expr(expr syntax.Expr) *Node {
 		return n
 	case *syntax.KeyValueExpr:
 		// use position of expr.Key rather than of expr (which has position of ':')
-		return p.nod(expr.Key, OKEY, p.expr(expr.Key), p.wrapname(expr.Value, p.expr(expr.Value)))
+		return p.nod(expr.Key, ir.OKEY, p.expr(expr.Key), p.wrapname(expr.Value, p.expr(expr.Value)))
 	case *syntax.FuncLit:
 		return p.funcLit(expr)
 	case *syntax.ParenExpr:
-		return p.nod(expr, OPAREN, p.expr(expr.X), nil)
+		return p.nod(expr, ir.OPAREN, p.expr(expr.X), nil)
 	case *syntax.SelectorExpr:
 		// parser.new_dotname
 		obj := p.expr(expr.X)
-		if obj.Op == OPACK {
+		if obj.Op == ir.OPACK {
 			obj.Name.SetUsed(true)
 			return importName(obj.Name.Pkg.Lookup(expr.Sel.Value))
 		}
-		n := nodSym(OXDOT, obj, p.name(expr.Sel))
+		n := nodSym(ir.OXDOT, obj, p.name(expr.Sel))
 		n.Pos = p.pos(expr) // lineno may have been changed by p.expr(expr.X)
 		return n
 	case *syntax.IndexExpr:
-		return p.nod(expr, OINDEX, p.expr(expr.X), p.expr(expr.Index))
+		return p.nod(expr, ir.OINDEX, p.expr(expr.X), p.expr(expr.Index))
 	case *syntax.SliceExpr:
-		op := OSLICE
+		op := ir.OSLICE
 		if expr.Full {
-			op = OSLICE3
+			op = ir.OSLICE3
 		}
 		n := p.nod(expr, op, p.expr(expr.X), nil)
-		var index [3]*Node
+		var index [3]*ir.Node
 		for i, x := range &expr.Index {
 			if x != nil {
 				index[i] = p.expr(x)
@@ -707,7 +708,7 @@ func (p *noder) expr(expr syntax.Expr) *Node {
 		n.SetSliceBounds(index[0], index[1], index[2])
 		return n
 	case *syntax.AssertExpr:
-		return p.nod(expr, ODOTTYPE, p.expr(expr.X), p.typeExpr(expr.Type))
+		return p.nod(expr, ir.ODOTTYPE, p.expr(expr.X), p.typeExpr(expr.Type))
 	case *syntax.Operation:
 		if expr.Op == syntax.Add && expr.Y != nil {
 			return p.sum(expr)
@@ -718,23 +719,23 @@ func (p *noder) expr(expr syntax.Expr) *Node {
 		}
 		return p.nod(expr, p.binOp(expr.Op), x, p.expr(expr.Y))
 	case *syntax.CallExpr:
-		n := p.nod(expr, OCALL, p.expr(expr.Fun), nil)
+		n := p.nod(expr, ir.OCALL, p.expr(expr.Fun), nil)
 		n.List.Set(p.exprs(expr.ArgList))
 		n.SetIsDDD(expr.HasDots)
 		return n
 
 	case *syntax.ArrayType:
-		var len *Node
+		var len *ir.Node
 		if expr.Len != nil {
 			len = p.expr(expr.Len)
 		} else {
-			len = p.nod(expr, ODDD, nil, nil)
+			len = p.nod(expr, ir.ODDD, nil, nil)
 		}
-		return p.nod(expr, OTARRAY, len, p.typeExpr(expr.Elem))
+		return p.nod(expr, ir.OTARRAY, len, p.typeExpr(expr.Elem))
 	case *syntax.SliceType:
-		return p.nod(expr, OTARRAY, nil, p.typeExpr(expr.Elem))
+		return p.nod(expr, ir.OTARRAY, nil, p.typeExpr(expr.Elem))
 	case *syntax.DotsType:
-		return p.nod(expr, ODDD, p.typeExpr(expr.Elem), nil)
+		return p.nod(expr, ir.ODDD, p.typeExpr(expr.Elem), nil)
 	case *syntax.StructType:
 		return p.structType(expr)
 	case *syntax.InterfaceType:
@@ -742,17 +743,17 @@ func (p *noder) expr(expr syntax.Expr) *Node {
 	case *syntax.FuncType:
 		return p.signature(nil, expr)
 	case *syntax.MapType:
-		return p.nod(expr, OTMAP, p.typeExpr(expr.Key), p.typeExpr(expr.Value))
+		return p.nod(expr, ir.OTMAP, p.typeExpr(expr.Key), p.typeExpr(expr.Value))
 	case *syntax.ChanType:
-		n := p.nod(expr, OTCHAN, p.typeExpr(expr.Elem), nil)
+		n := p.nod(expr, ir.OTCHAN, p.typeExpr(expr.Elem), nil)
 		n.SetTChanDir(p.chanDir(expr.Dir))
 		return n
 
 	case *syntax.TypeSwitchGuard:
-		n := p.nod(expr, OTYPESW, nil, p.expr(expr.X))
+		n := p.nod(expr, ir.OTYPESW, nil, p.expr(expr.X))
 		if expr.Lhs != nil {
 			n.Left = p.declName(expr.Lhs)
-			if n.Left.isBlank() {
+			if ir.IsBlank(n.Left) {
 				base.Errorf("invalid variable name %v in type switch", n.Left)
 			}
 		}
@@ -764,7 +765,7 @@ func (p *noder) expr(expr syntax.Expr) *Node {
 // sum efficiently handles very large summation expressions (such as
 // in issue #16394). In particular, it avoids left recursion and
 // collapses string literals.
-func (p *noder) sum(x syntax.Expr) *Node {
+func (p *noder) sum(x syntax.Expr) *ir.Node {
 	// While we need to handle long sums with asymptotic
 	// efficiency, the vast majority of sums are very small: ~95%
 	// have only 2 or 3 operands, and ~99% of string literals are
@@ -799,11 +800,11 @@ func (p *noder) sum(x syntax.Expr) *Node {
 	// handle correctly. For now, we avoid these problems by
 	// treating named string constants the same as non-constant
 	// operands.
-	var nstr *Node
+	var nstr *ir.Node
 	chunks := make([]string, 0, 1)
 
 	n := p.expr(x)
-	if Isconst(n, constant.String) && n.Sym == nil {
+	if ir.IsConst(n, constant.String) && n.Sym == nil {
 		nstr = n
 		chunks = append(chunks, nstr.StringVal())
 	}
@@ -812,7 +813,7 @@ func (p *noder) sum(x syntax.Expr) *Node {
 		add := adds[i]
 
 		r := p.expr(add.Y)
-		if Isconst(r, constant.String) && r.Sym == nil {
+		if ir.IsConst(r, constant.String) && r.Sym == nil {
 			if nstr != nil {
 				// Collapse r into nstr instead of adding to n.
 				chunks = append(chunks, r.StringVal())
@@ -828,7 +829,7 @@ func (p *noder) sum(x syntax.Expr) *Node {
 			nstr = nil
 			chunks = chunks[:0]
 		}
-		n = p.nod(add, OADD, n, r)
+		n = p.nod(add, ir.OADD, n, r)
 	}
 	if len(chunks) > 1 {
 		nstr.SetVal(constant.MakeString(strings.Join(chunks, "")))
@@ -837,12 +838,12 @@ func (p *noder) sum(x syntax.Expr) *Node {
 	return n
 }
 
-func (p *noder) typeExpr(typ syntax.Expr) *Node {
+func (p *noder) typeExpr(typ syntax.Expr) *ir.Node {
 	// TODO(mdempsky): Be stricter? typecheck should handle errors anyway.
 	return p.expr(typ)
 }
 
-func (p *noder) typeExprOrNil(typ syntax.Expr) *Node {
+func (p *noder) typeExprOrNil(typ syntax.Expr) *ir.Node {
 	if typ != nil {
 		return p.expr(typ)
 	}
@@ -861,15 +862,15 @@ func (p *noder) chanDir(dir syntax.ChanDir) types.ChanDir {
 	panic("unhandled ChanDir")
 }
 
-func (p *noder) structType(expr *syntax.StructType) *Node {
-	l := make([]*Node, 0, len(expr.FieldList))
+func (p *noder) structType(expr *syntax.StructType) *ir.Node {
+	l := make([]*ir.Node, 0, len(expr.FieldList))
 	for i, field := range expr.FieldList {
 		p.setlineno(field)
-		var n *Node
+		var n *ir.Node
 		if field.Name == nil {
 			n = p.embedded(field.Type)
 		} else {
-			n = p.nodSym(field, ODCLFIELD, p.typeExpr(field.Type), p.name(field.Name))
+			n = p.nodSym(field, ir.ODCLFIELD, p.typeExpr(field.Type), p.name(field.Name))
 		}
 		if i < len(expr.TagList) && expr.TagList[i] != nil {
 			n.SetVal(p.basicLit(expr.TagList[i]))
@@ -878,29 +879,29 @@ func (p *noder) structType(expr *syntax.StructType) *Node {
 	}
 
 	p.setlineno(expr)
-	n := p.nod(expr, OTSTRUCT, nil, nil)
+	n := p.nod(expr, ir.OTSTRUCT, nil, nil)
 	n.List.Set(l)
 	return n
 }
 
-func (p *noder) interfaceType(expr *syntax.InterfaceType) *Node {
-	l := make([]*Node, 0, len(expr.MethodList))
+func (p *noder) interfaceType(expr *syntax.InterfaceType) *ir.Node {
+	l := make([]*ir.Node, 0, len(expr.MethodList))
 	for _, method := range expr.MethodList {
 		p.setlineno(method)
-		var n *Node
+		var n *ir.Node
 		if method.Name == nil {
-			n = p.nodSym(method, ODCLFIELD, importName(p.packname(method.Type)), nil)
+			n = p.nodSym(method, ir.ODCLFIELD, importName(p.packname(method.Type)), nil)
 		} else {
 			mname := p.name(method.Name)
 			sig := p.typeExpr(method.Type)
 			sig.Left = fakeRecv()
-			n = p.nodSym(method, ODCLFIELD, sig, mname)
+			n = p.nodSym(method, ir.ODCLFIELD, sig, mname)
 			ifacedcl(n)
 		}
 		l = append(l, n)
 	}
 
-	n := p.nod(expr, OTINTER, nil, nil)
+	n := p.nod(expr, ir.OTINTER, nil, nil)
 	n.List.Set(l)
 	return n
 }
@@ -915,15 +916,15 @@ func (p *noder) packname(expr syntax.Expr) *types.Sym {
 		return name
 	case *syntax.SelectorExpr:
 		name := p.name(expr.X.(*syntax.Name))
-		def := asNode(name.Def)
+		def := ir.AsNode(name.Def)
 		if def == nil {
 			base.Errorf("undefined: %v", name)
 			return name
 		}
 		var pkg *types.Pkg
-		if def.Op != OPACK {
+		if def.Op != ir.OPACK {
 			base.Errorf("%v is not a package", name)
-			pkg = localpkg
+			pkg = ir.LocalPkg
 		} else {
 			def.Name.SetUsed(true)
 			pkg = def.Name.Pkg
@@ -933,7 +934,7 @@ func (p *noder) packname(expr syntax.Expr) *types.Sym {
 	panic(fmt.Sprintf("unexpected packname: %#v", expr))
 }
 
-func (p *noder) embedded(typ syntax.Expr) *Node {
+func (p *noder) embedded(typ syntax.Expr) *ir.Node {
 	op, isStar := typ.(*syntax.Operation)
 	if isStar {
 		if op.Op != syntax.Mul || op.Y != nil {
@@ -943,25 +944,25 @@ func (p *noder) embedded(typ syntax.Expr) *Node {
 	}
 
 	sym := p.packname(typ)
-	n := p.nodSym(typ, ODCLFIELD, importName(sym), lookup(sym.Name))
+	n := p.nodSym(typ, ir.ODCLFIELD, importName(sym), lookup(sym.Name))
 	n.SetEmbedded(true)
 
 	if isStar {
-		n.Left = p.nod(op, ODEREF, n.Left, nil)
+		n.Left = p.nod(op, ir.ODEREF, n.Left, nil)
 	}
 	return n
 }
 
-func (p *noder) stmts(stmts []syntax.Stmt) []*Node {
+func (p *noder) stmts(stmts []syntax.Stmt) []*ir.Node {
 	return p.stmtsFall(stmts, false)
 }
 
-func (p *noder) stmtsFall(stmts []syntax.Stmt, fallOK bool) []*Node {
-	var nodes []*Node
+func (p *noder) stmtsFall(stmts []syntax.Stmt, fallOK bool) []*ir.Node {
+	var nodes []*ir.Node
 	for i, stmt := range stmts {
 		s := p.stmtFall(stmt, fallOK && i+1 == len(stmts))
 		if s == nil {
-		} else if s.Op == OBLOCK && s.Ninit.Len() == 0 {
+		} else if s.Op == ir.OBLOCK && s.Ninit.Len() == 0 {
 			nodes = append(nodes, s.List.Slice()...)
 		} else {
 			nodes = append(nodes, s)
@@ -970,11 +971,11 @@ func (p *noder) stmtsFall(stmts []syntax.Stmt, fallOK bool) []*Node {
 	return nodes
 }
 
-func (p *noder) stmt(stmt syntax.Stmt) *Node {
+func (p *noder) stmt(stmt syntax.Stmt) *ir.Node {
 	return p.stmtFall(stmt, false)
 }
 
-func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) *Node {
+func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) *ir.Node {
 	p.setlineno(stmt)
 	switch stmt := stmt.(type) {
 	case *syntax.EmptyStmt:
@@ -985,24 +986,24 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) *Node {
 		l := p.blockStmt(stmt)
 		if len(l) == 0 {
 			// TODO(mdempsky): Line number?
-			return nod(OEMPTY, nil, nil)
+			return ir.Nod(ir.OEMPTY, nil, nil)
 		}
 		return liststmt(l)
 	case *syntax.ExprStmt:
 		return p.wrapname(stmt, p.expr(stmt.X))
 	case *syntax.SendStmt:
-		return p.nod(stmt, OSEND, p.expr(stmt.Chan), p.expr(stmt.Value))
+		return p.nod(stmt, ir.OSEND, p.expr(stmt.Chan), p.expr(stmt.Value))
 	case *syntax.DeclStmt:
 		return liststmt(p.decls(stmt.DeclList))
 	case *syntax.AssignStmt:
 		if stmt.Op != 0 && stmt.Op != syntax.Def {
-			n := p.nod(stmt, OASOP, p.expr(stmt.Lhs), p.expr(stmt.Rhs))
+			n := p.nod(stmt, ir.OASOP, p.expr(stmt.Lhs), p.expr(stmt.Rhs))
 			n.SetImplicit(stmt.Rhs == syntax.ImplicitOne)
 			n.SetSubOp(p.binOp(stmt.Op))
 			return n
 		}
 
-		n := p.nod(stmt, OAS, nil, nil) // assume common case
+		n := p.nod(stmt, ir.OAS, nil, nil) // assume common case
 
 		rhs := p.exprList(stmt.Rhs)
 		lhs := p.assignList(stmt.Lhs, n, stmt.Op == syntax.Def)
@@ -1012,26 +1013,26 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) *Node {
 			n.Left = lhs[0]
 			n.Right = rhs[0]
 		} else {
-			n.Op = OAS2
+			n.Op = ir.OAS2
 			n.List.Set(lhs)
 			n.Rlist.Set(rhs)
 		}
 		return n
 
 	case *syntax.BranchStmt:
-		var op Op
+		var op ir.Op
 		switch stmt.Tok {
 		case syntax.Break:
-			op = OBREAK
+			op = ir.OBREAK
 		case syntax.Continue:
-			op = OCONTINUE
+			op = ir.OCONTINUE
 		case syntax.Fallthrough:
 			if !fallOK {
 				base.Errorf("fallthrough statement out of place")
 			}
-			op = OFALL
+			op = ir.OFALL
 		case syntax.Goto:
-			op = OGOTO
+			op = ir.OGOTO
 		default:
 			panic("unhandled BranchStmt")
 		}
@@ -1041,32 +1042,32 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) *Node {
 		}
 		return n
 	case *syntax.CallStmt:
-		var op Op
+		var op ir.Op
 		switch stmt.Tok {
 		case syntax.Defer:
-			op = ODEFER
+			op = ir.ODEFER
 		case syntax.Go:
-			op = OGO
+			op = ir.OGO
 		default:
 			panic("unhandled CallStmt")
 		}
 		return p.nod(stmt, op, p.expr(stmt.Call), nil)
 	case *syntax.ReturnStmt:
-		var results []*Node
+		var results []*ir.Node
 		if stmt.Results != nil {
 			results = p.exprList(stmt.Results)
 		}
-		n := p.nod(stmt, ORETURN, nil, nil)
+		n := p.nod(stmt, ir.ORETURN, nil, nil)
 		n.List.Set(results)
 		if n.List.Len() == 0 && Curfn != nil {
 			for _, ln := range Curfn.Func.Dcl {
-				if ln.Class() == PPARAM {
+				if ln.Class() == ir.PPARAM {
 					continue
 				}
-				if ln.Class() != PPARAMOUT {
+				if ln.Class() != ir.PPARAMOUT {
 					break
 				}
-				if asNode(ln.Sym.Def) != ln {
+				if ir.AsNode(ln.Sym.Def) != ln {
 					base.Errorf("%s is shadowed during return", ln.Sym.Name)
 				}
 			}
@@ -1084,7 +1085,7 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) *Node {
 	panic("unhandled Stmt")
 }
 
-func (p *noder) assignList(expr syntax.Expr, defn *Node, colas bool) []*Node {
+func (p *noder) assignList(expr syntax.Expr, defn *ir.Node, colas bool) []*ir.Node {
 	if !colas {
 		return p.exprList(expr)
 	}
@@ -1098,13 +1099,13 @@ func (p *noder) assignList(expr syntax.Expr, defn *Node, colas bool) []*Node {
 		exprs = []syntax.Expr{expr}
 	}
 
-	res := make([]*Node, len(exprs))
+	res := make([]*ir.Node, len(exprs))
 	seen := make(map[*types.Sym]bool, len(exprs))
 
 	newOrErr := false
 	for i, expr := range exprs {
 		p.setlineno(expr)
-		res[i] = nblank
+		res[i] = ir.BlankNode
 
 		name, ok := expr.(*syntax.Name)
 		if !ok {
@@ -1131,10 +1132,10 @@ func (p *noder) assignList(expr syntax.Expr, defn *Node, colas bool) []*Node {
 		}
 
 		newOrErr = true
-		n := newname(sym)
+		n := NewName(sym)
 		declare(n, dclcontext)
 		n.Name.Defn = defn
-		defn.Ninit.Append(nod(ODCL, n, nil))
+		defn.Ninit.Append(ir.Nod(ir.ODCL, n, nil))
 		res[i] = n
 	}
 
@@ -1144,16 +1145,16 @@ func (p *noder) assignList(expr syntax.Expr, defn *Node, colas bool) []*Node {
 	return res
 }
 
-func (p *noder) blockStmt(stmt *syntax.BlockStmt) []*Node {
+func (p *noder) blockStmt(stmt *syntax.BlockStmt) []*ir.Node {
 	p.openScope(stmt.Pos())
 	nodes := p.stmts(stmt.List)
 	p.closeScope(stmt.Rbrace)
 	return nodes
 }
 
-func (p *noder) ifStmt(stmt *syntax.IfStmt) *Node {
+func (p *noder) ifStmt(stmt *syntax.IfStmt) *ir.Node {
 	p.openScope(stmt.Pos())
-	n := p.nod(stmt, OIF, nil, nil)
+	n := p.nod(stmt, ir.OIF, nil, nil)
 	if stmt.Init != nil {
 		n.Ninit.Set1(p.stmt(stmt.Init))
 	}
@@ -1163,7 +1164,7 @@ func (p *noder) ifStmt(stmt *syntax.IfStmt) *Node {
 	n.Nbody.Set(p.blockStmt(stmt.Then))
 	if stmt.Else != nil {
 		e := p.stmt(stmt.Else)
-		if e.Op == OBLOCK && e.Ninit.Len() == 0 {
+		if e.Op == ir.OBLOCK && e.Ninit.Len() == 0 {
 			n.Rlist.Set(e.List.Slice())
 		} else {
 			n.Rlist.Set1(e)
@@ -1173,20 +1174,20 @@ func (p *noder) ifStmt(stmt *syntax.IfStmt) *Node {
 	return n
 }
 
-func (p *noder) forStmt(stmt *syntax.ForStmt) *Node {
+func (p *noder) forStmt(stmt *syntax.ForStmt) *ir.Node {
 	p.openScope(stmt.Pos())
-	var n *Node
+	var n *ir.Node
 	if r, ok := stmt.Init.(*syntax.RangeClause); ok {
 		if stmt.Cond != nil || stmt.Post != nil {
 			panic("unexpected RangeClause")
 		}
 
-		n = p.nod(r, ORANGE, nil, p.expr(r.X))
+		n = p.nod(r, ir.ORANGE, nil, p.expr(r.X))
 		if r.Lhs != nil {
 			n.List.Set(p.assignList(r.Lhs, n, r.Def))
 		}
 	} else {
-		n = p.nod(stmt, OFOR, nil, nil)
+		n = p.nod(stmt, ir.OFOR, nil, nil)
 		if stmt.Init != nil {
 			n.Ninit.Set1(p.stmt(stmt.Init))
 		}
@@ -1202,9 +1203,9 @@ func (p *noder) forStmt(stmt *syntax.ForStmt) *Node {
 	return n
 }
 
-func (p *noder) switchStmt(stmt *syntax.SwitchStmt) *Node {
+func (p *noder) switchStmt(stmt *syntax.SwitchStmt) *ir.Node {
 	p.openScope(stmt.Pos())
-	n := p.nod(stmt, OSWITCH, nil, nil)
+	n := p.nod(stmt, ir.OSWITCH, nil, nil)
 	if stmt.Init != nil {
 		n.Ninit.Set1(p.stmt(stmt.Init))
 	}
@@ -1213,7 +1214,7 @@ func (p *noder) switchStmt(stmt *syntax.SwitchStmt) *Node {
 	}
 
 	tswitch := n.Left
-	if tswitch != nil && tswitch.Op != OTYPESW {
+	if tswitch != nil && tswitch.Op != ir.OTYPESW {
 		tswitch = nil
 	}
 	n.List.Set(p.caseClauses(stmt.Body, tswitch, stmt.Rbrace))
@@ -1222,8 +1223,8 @@ func (p *noder) switchStmt(stmt *syntax.SwitchStmt) *Node {
 	return n
 }
 
-func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *Node, rbrace syntax.Pos) []*Node {
-	nodes := make([]*Node, 0, len(clauses))
+func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *ir.Node, rbrace syntax.Pos) []*ir.Node {
+	nodes := make([]*ir.Node, 0, len(clauses))
 	for i, clause := range clauses {
 		p.setlineno(clause)
 		if i > 0 {
@@ -1231,12 +1232,12 @@ func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *Node, rbrace
 		}
 		p.openScope(clause.Pos())
 
-		n := p.nod(clause, OCASE, nil, nil)
+		n := p.nod(clause, ir.OCASE, nil, nil)
 		if clause.Cases != nil {
 			n.List.Set(p.exprList(clause.Cases))
 		}
 		if tswitch != nil && tswitch.Left != nil {
-			nn := newname(tswitch.Left.Sym)
+			nn := NewName(tswitch.Left.Sym)
 			declare(nn, dclcontext)
 			n.Rlist.Set1(nn)
 			// keep track of the instances for reporting unused
@@ -1255,7 +1256,7 @@ func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *Node, rbrace
 		}
 
 		n.Nbody.Set(p.stmtsFall(body, true))
-		if l := n.Nbody.Len(); l > 0 && n.Nbody.Index(l-1).Op == OFALL {
+		if l := n.Nbody.Len(); l > 0 && n.Nbody.Index(l-1).Op == ir.OFALL {
 			if tswitch != nil {
 				base.Errorf("cannot fallthrough in type switch")
 			}
@@ -1272,14 +1273,14 @@ func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *Node, rbrace
 	return nodes
 }
 
-func (p *noder) selectStmt(stmt *syntax.SelectStmt) *Node {
-	n := p.nod(stmt, OSELECT, nil, nil)
+func (p *noder) selectStmt(stmt *syntax.SelectStmt) *ir.Node {
+	n := p.nod(stmt, ir.OSELECT, nil, nil)
 	n.List.Set(p.commClauses(stmt.Body, stmt.Rbrace))
 	return n
 }
 
-func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []*Node {
-	nodes := make([]*Node, 0, len(clauses))
+func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []*ir.Node {
+	nodes := make([]*ir.Node, 0, len(clauses))
 	for i, clause := range clauses {
 		p.setlineno(clause)
 		if i > 0 {
@@ -1287,7 +1288,7 @@ func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []*
 		}
 		p.openScope(clause.Pos())
 
-		n := p.nod(clause, OCASE, nil, nil)
+		n := p.nod(clause, ir.OCASE, nil, nil)
 		if clause.Comm != nil {
 			n.List.Set1(p.stmt(clause.Comm))
 		}
@@ -1300,18 +1301,18 @@ func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []*
 	return nodes
 }
 
-func (p *noder) labeledStmt(label *syntax.LabeledStmt, fallOK bool) *Node {
-	lhs := p.nodSym(label, OLABEL, nil, p.name(label.Label))
+func (p *noder) labeledStmt(label *syntax.LabeledStmt, fallOK bool) *ir.Node {
+	lhs := p.nodSym(label, ir.OLABEL, nil, p.name(label.Label))
 
-	var ls *Node
+	var ls *ir.Node
 	if label.Stmt != nil { // TODO(mdempsky): Should always be present.
 		ls = p.stmtFall(label.Stmt, fallOK)
 	}
 
 	lhs.Name.Defn = ls
-	l := []*Node{lhs}
+	l := []*ir.Node{lhs}
 	if ls != nil {
-		if ls.Op == OBLOCK && ls.Ninit.Len() == 0 {
+		if ls.Op == ir.OBLOCK && ls.Ninit.Len() == 0 {
 			l = append(l, ls.List.Slice()...)
 		} else {
 			l = append(l, ls)
@@ -1320,50 +1321,50 @@ func (p *noder) labeledStmt(label *syntax.LabeledStmt, fallOK bool) *Node {
 	return liststmt(l)
 }
 
-var unOps = [...]Op{
-	syntax.Recv: ORECV,
-	syntax.Mul:  ODEREF,
-	syntax.And:  OADDR,
+var unOps = [...]ir.Op{
+	syntax.Recv: ir.ORECV,
+	syntax.Mul:  ir.ODEREF,
+	syntax.And:  ir.OADDR,
 
-	syntax.Not: ONOT,
-	syntax.Xor: OBITNOT,
-	syntax.Add: OPLUS,
-	syntax.Sub: ONEG,
+	syntax.Not: ir.ONOT,
+	syntax.Xor: ir.OBITNOT,
+	syntax.Add: ir.OPLUS,
+	syntax.Sub: ir.ONEG,
 }
 
-func (p *noder) unOp(op syntax.Operator) Op {
+func (p *noder) unOp(op syntax.Operator) ir.Op {
 	if uint64(op) >= uint64(len(unOps)) || unOps[op] == 0 {
 		panic("invalid Operator")
 	}
 	return unOps[op]
 }
 
-var binOps = [...]Op{
-	syntax.OrOr:   OOROR,
-	syntax.AndAnd: OANDAND,
+var binOps = [...]ir.Op{
+	syntax.OrOr:   ir.OOROR,
+	syntax.AndAnd: ir.OANDAND,
 
-	syntax.Eql: OEQ,
-	syntax.Neq: ONE,
-	syntax.Lss: OLT,
-	syntax.Leq: OLE,
-	syntax.Gtr: OGT,
-	syntax.Geq: OGE,
+	syntax.Eql: ir.OEQ,
+	syntax.Neq: ir.ONE,
+	syntax.Lss: ir.OLT,
+	syntax.Leq: ir.OLE,
+	syntax.Gtr: ir.OGT,
+	syntax.Geq: ir.OGE,
 
-	syntax.Add: OADD,
-	syntax.Sub: OSUB,
-	syntax.Or:  OOR,
-	syntax.Xor: OXOR,
+	syntax.Add: ir.OADD,
+	syntax.Sub: ir.OSUB,
+	syntax.Or:  ir.OOR,
+	syntax.Xor: ir.OXOR,
 
-	syntax.Mul:    OMUL,
-	syntax.Div:    ODIV,
-	syntax.Rem:    OMOD,
-	syntax.And:    OAND,
-	syntax.AndNot: OANDNOT,
-	syntax.Shl:    OLSH,
-	syntax.Shr:    ORSH,
+	syntax.Mul:    ir.OMUL,
+	syntax.Div:    ir.ODIV,
+	syntax.Rem:    ir.OMOD,
+	syntax.And:    ir.OAND,
+	syntax.AndNot: ir.OANDNOT,
+	syntax.Shl:    ir.OLSH,
+	syntax.Shr:    ir.ORSH,
 }
 
-func (p *noder) binOp(op syntax.Operator) Op {
+func (p *noder) binOp(op syntax.Operator) ir.Op {
 	if uint64(op) >= uint64(len(binOps)) || binOps[op] == 0 {
 		panic("invalid Operator")
 	}
@@ -1374,7 +1375,7 @@ func (p *noder) binOp(op syntax.Operator) Op {
 // literal is not compatible with the current language version.
 func checkLangCompat(lit *syntax.BasicLit) {
 	s := lit.Value
-	if len(s) <= 2 || langSupported(1, 13, localpkg) {
+	if len(s) <= 2 || langSupported(1, 13, ir.LocalPkg) {
 		return
 	}
 	// len(s) > 2
@@ -1442,32 +1443,32 @@ func (p *noder) name(name *syntax.Name) *types.Sym {
 	return lookup(name.Value)
 }
 
-func (p *noder) mkname(name *syntax.Name) *Node {
+func (p *noder) mkname(name *syntax.Name) *ir.Node {
 	// TODO(mdempsky): Set line number?
 	return mkname(p.name(name))
 }
 
-func (p *noder) wrapname(n syntax.Node, x *Node) *Node {
+func (p *noder) wrapname(n syntax.Node, x *ir.Node) *ir.Node {
 	// These nodes do not carry line numbers.
 	// Introduce a wrapper node to give them the correct line.
 	switch x.Op {
-	case OTYPE, OLITERAL:
+	case ir.OTYPE, ir.OLITERAL:
 		if x.Sym == nil {
 			break
 		}
 		fallthrough
-	case ONAME, ONONAME, OPACK:
-		x = p.nod(n, OPAREN, x, nil)
+	case ir.ONAME, ir.ONONAME, ir.OPACK:
+		x = p.nod(n, ir.OPAREN, x, nil)
 		x.SetImplicit(true)
 	}
 	return x
 }
 
-func (p *noder) nod(orig syntax.Node, op Op, left, right *Node) *Node {
-	return nodl(p.pos(orig), op, left, right)
+func (p *noder) nod(orig syntax.Node, op ir.Op, left, right *ir.Node) *ir.Node {
+	return ir.NodAt(p.pos(orig), op, left, right)
 }
 
-func (p *noder) nodSym(orig syntax.Node, op Op, left *Node, sym *types.Sym) *Node {
+func (p *noder) nodSym(orig syntax.Node, op ir.Op, left *ir.Node, sym *types.Sym) *ir.Node {
 	n := nodSym(op, left, sym)
 	n.Pos = p.pos(orig)
 	return n
@@ -1508,13 +1509,13 @@ var allowedStdPragmas = map[string]bool{
 
 // *Pragma is the value stored in a syntax.Pragma during parsing.
 type Pragma struct {
-	Flag   PragmaFlag  // collected bits
-	Pos    []PragmaPos // position of each individual flag
+	Flag   ir.PragmaFlag // collected bits
+	Pos    []PragmaPos   // position of each individual flag
 	Embeds []PragmaEmbed
 }
 
 type PragmaPos struct {
-	Flag PragmaFlag
+	Flag ir.PragmaFlag
 	Pos  syntax.Pos
 }
 
@@ -1631,7 +1632,7 @@ func (p *noder) pragma(pos syntax.Pos, blankLine bool, text string, old syntax.P
 			verb = verb[:i]
 		}
 		flag := pragmaFlag(verb)
-		const runtimePragmas = Systemstack | Nowritebarrier | Nowritebarrierrec | Yeswritebarrierrec
+		const runtimePragmas = ir.Systemstack | ir.Nowritebarrier | ir.Nowritebarrierrec | ir.Yeswritebarrierrec
 		if !base.Flag.CompilingRuntime && flag&runtimePragmas != 0 {
 			p.error(syntax.Error{Pos: pos, Msg: fmt.Sprintf("//%s only allowed in runtime", verb)})
 		}
@@ -1667,7 +1668,7 @@ func safeArg(name string) bool {
 	return '0' <= c && c <= '9' || 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || c == '.' || c == '_' || c == '/' || c >= utf8.RuneSelf
 }
 
-func mkname(sym *types.Sym) *Node {
+func mkname(sym *types.Sym) *ir.Node {
 	n := oldname(sym)
 	if n.Name != nil && n.Name.Pack != nil {
 		n.Name.Pack.Name.SetUsed(true)
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 6c659c91c7..2961dbf636 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/bio"
 	"cmd/internal/obj"
@@ -83,7 +84,7 @@ func printObjHeader(bout *bio.Writer) {
 	if base.Flag.BuildID != "" {
 		fmt.Fprintf(bout, "build id %q\n", base.Flag.BuildID)
 	}
-	if localpkg.Name == "main" {
+	if ir.LocalPkg.Name == "main" {
 		fmt.Fprintf(bout, "main\n")
 	}
 	fmt.Fprintf(bout, "\n") // header ends with blank line
@@ -141,7 +142,7 @@ func dumpdata() {
 	for {
 		for i := xtops; i < len(xtop); i++ {
 			n := xtop[i]
-			if n.Op == ODCLFUNC {
+			if n.Op == ir.ODCLFUNC {
 				funccompile(n)
 			}
 		}
@@ -199,16 +200,16 @@ func dumpLinkerObj(bout *bio.Writer) {
 }
 
 func addptabs() {
-	if !base.Ctxt.Flag_dynlink || localpkg.Name != "main" {
+	if !base.Ctxt.Flag_dynlink || ir.LocalPkg.Name != "main" {
 		return
 	}
 	for _, exportn := range exportlist {
 		s := exportn.Sym
-		n := asNode(s.Def)
+		n := ir.AsNode(s.Def)
 		if n == nil {
 			continue
 		}
-		if n.Op != ONAME {
+		if n.Op != ir.ONAME {
 			continue
 		}
 		if !types.IsExported(s.Name) {
@@ -217,37 +218,37 @@ func addptabs() {
 		if s.Pkg.Name != "main" {
 			continue
 		}
-		if n.Type.Etype == TFUNC && n.Class() == PFUNC {
+		if n.Type.Etype == types.TFUNC && n.Class() == ir.PFUNC {
 			// function
-			ptabs = append(ptabs, ptabEntry{s: s, t: asNode(s.Def).Type})
+			ptabs = append(ptabs, ptabEntry{s: s, t: ir.AsNode(s.Def).Type})
 		} else {
 			// variable
-			ptabs = append(ptabs, ptabEntry{s: s, t: types.NewPtr(asNode(s.Def).Type)})
+			ptabs = append(ptabs, ptabEntry{s: s, t: types.NewPtr(ir.AsNode(s.Def).Type)})
 		}
 	}
 }
 
-func dumpGlobal(n *Node) {
+func dumpGlobal(n *ir.Node) {
 	if n.Type == nil {
 		base.Fatalf("external %v nil type\n", n)
 	}
-	if n.Class() == PFUNC {
+	if n.Class() == ir.PFUNC {
 		return
 	}
-	if n.Sym.Pkg != localpkg {
+	if n.Sym.Pkg != ir.LocalPkg {
 		return
 	}
 	dowidth(n.Type)
 	ggloblnod(n)
 }
 
-func dumpGlobalConst(n *Node) {
+func dumpGlobalConst(n *ir.Node) {
 	// only export typed constants
 	t := n.Type
 	if t == nil {
 		return
 	}
-	if n.Sym.Pkg != localpkg {
+	if n.Sym.Pkg != ir.LocalPkg {
 		return
 	}
 	// only export integer constants for now
@@ -257,21 +258,21 @@ func dumpGlobalConst(n *Node) {
 	v := n.Val()
 	if t.IsUntyped() {
 		// Export untyped integers as int (if they fit).
-		t = types.Types[TINT]
+		t = types.Types[types.TINT]
 		if doesoverflow(v, t) {
 			return
 		}
 	}
-	base.Ctxt.DwarfIntConst(base.Ctxt.Pkgpath, n.Sym.Name, typesymname(t), int64Val(t, v))
+	base.Ctxt.DwarfIntConst(base.Ctxt.Pkgpath, n.Sym.Name, typesymname(t), ir.Int64Val(t, v))
 }
 
 func dumpglobls() {
 	// add globals
 	for _, n := range externdcl {
 		switch n.Op {
-		case ONAME:
+		case ir.ONAME:
 			dumpGlobal(n)
-		case OLITERAL:
+		case ir.OLITERAL:
 			dumpGlobalConst(n)
 		}
 	}
@@ -474,12 +475,12 @@ func fileStringSym(pos src.XPos, file string, readonly bool, hash []byte) (*obj.
 
 var slicedataGen int
 
-func slicedata(pos src.XPos, s string) *Node {
+func slicedata(pos src.XPos, s string) *ir.Node {
 	slicedataGen++
 	symname := fmt.Sprintf(".gobytes.%d", slicedataGen)
-	sym := localpkg.Lookup(symname)
-	symnode := newname(sym)
-	sym.Def = asTypesNode(symnode)
+	sym := ir.LocalPkg.Lookup(symname)
+	symnode := NewName(sym)
+	sym.Def = ir.AsTypesNode(symnode)
 
 	lsym := sym.Linksym()
 	off := dstringdata(lsym, 0, s, pos, "slice")
@@ -488,8 +489,8 @@ func slicedata(pos src.XPos, s string) *Node {
 	return symnode
 }
 
-func slicebytes(nam *Node, s string) {
-	if nam.Op != ONAME {
+func slicebytes(nam *ir.Node, s string) {
+	if nam.Op != ir.ONAME {
 		base.Fatalf("slicebytes %v", nam)
 	}
 	slicesym(nam, slicedata(nam.Pos, s), int64(len(s)))
@@ -529,10 +530,10 @@ func dsymptrWeakOff(s *obj.LSym, off int, x *obj.LSym) int {
 
 // slicesym writes a static slice symbol {&arr, lencap, lencap} to n.
 // arr must be an ONAME. slicesym does not modify n.
-func slicesym(n, arr *Node, lencap int64) {
+func slicesym(n, arr *ir.Node, lencap int64) {
 	s := n.Sym.Linksym()
 	off := n.Xoffset
-	if arr.Op != ONAME {
+	if arr.Op != ir.ONAME {
 		base.Fatalf("slicesym non-name arr %v", arr)
 	}
 	s.WriteAddr(base.Ctxt, off, Widthptr, arr.Sym.Linksym(), arr.Xoffset)
@@ -542,14 +543,14 @@ func slicesym(n, arr *Node, lencap int64) {
 
 // addrsym writes the static address of a to n. a must be an ONAME.
 // Neither n nor a is modified.
-func addrsym(n, a *Node) {
-	if n.Op != ONAME {
+func addrsym(n, a *ir.Node) {
+	if n.Op != ir.ONAME {
 		base.Fatalf("addrsym n op %v", n.Op)
 	}
 	if n.Sym == nil {
 		base.Fatalf("addrsym nil n sym")
 	}
-	if a.Op != ONAME {
+	if a.Op != ir.ONAME {
 		base.Fatalf("addrsym a op %v", a.Op)
 	}
 	s := n.Sym.Linksym()
@@ -558,14 +559,14 @@ func addrsym(n, a *Node) {
 
 // pfuncsym writes the static address of f to n. f must be a global function.
 // Neither n nor f is modified.
-func pfuncsym(n, f *Node) {
-	if n.Op != ONAME {
+func pfuncsym(n, f *ir.Node) {
+	if n.Op != ir.ONAME {
 		base.Fatalf("pfuncsym n op %v", n.Op)
 	}
 	if n.Sym == nil {
 		base.Fatalf("pfuncsym nil n sym")
 	}
-	if f.Class() != PFUNC {
+	if f.Class() != ir.PFUNC {
 		base.Fatalf("pfuncsym class not PFUNC %d", f.Class())
 	}
 	s := n.Sym.Linksym()
@@ -574,8 +575,8 @@ func pfuncsym(n, f *Node) {
 
 // litsym writes the static literal c to n.
 // Neither n nor c is modified.
-func litsym(n, c *Node, wid int) {
-	if n.Op != ONAME {
+func litsym(n, c *ir.Node, wid int) {
+	if n.Op != ir.ONAME {
 		base.Fatalf("litsym n op %v", n.Op)
 	}
 	if n.Sym == nil {
@@ -584,10 +585,10 @@ func litsym(n, c *Node, wid int) {
 	if !types.Identical(n.Type, c.Type) {
 		base.Fatalf("litsym: type mismatch: %v has type %v, but %v has type %v", n, n.Type, c, c.Type)
 	}
-	if c.Op == ONIL {
+	if c.Op == ir.ONIL {
 		return
 	}
-	if c.Op != OLITERAL {
+	if c.Op != ir.OLITERAL {
 		base.Fatalf("litsym c op %v", c.Op)
 	}
 	s := n.Sym.Linksym()
@@ -597,14 +598,14 @@ func litsym(n, c *Node, wid int) {
 		s.WriteInt(base.Ctxt, n.Xoffset, wid, i)
 
 	case constant.Int:
-		s.WriteInt(base.Ctxt, n.Xoffset, wid, int64Val(n.Type, u))
+		s.WriteInt(base.Ctxt, n.Xoffset, wid, ir.Int64Val(n.Type, u))
 
 	case constant.Float:
 		f, _ := constant.Float64Val(u)
 		switch n.Type.Etype {
-		case TFLOAT32:
+		case types.TFLOAT32:
 			s.WriteFloat32(base.Ctxt, n.Xoffset, float32(f))
-		case TFLOAT64:
+		case types.TFLOAT64:
 			s.WriteFloat64(base.Ctxt, n.Xoffset, f)
 		}
 
@@ -612,10 +613,10 @@ func litsym(n, c *Node, wid int) {
 		re, _ := constant.Float64Val(constant.Real(u))
 		im, _ := constant.Float64Val(constant.Imag(u))
 		switch n.Type.Etype {
-		case TCOMPLEX64:
+		case types.TCOMPLEX64:
 			s.WriteFloat32(base.Ctxt, n.Xoffset, float32(re))
 			s.WriteFloat32(base.Ctxt, n.Xoffset+4, float32(im))
-		case TCOMPLEX128:
+		case types.TCOMPLEX128:
 			s.WriteFloat64(base.Ctxt, n.Xoffset, re)
 			s.WriteFloat64(base.Ctxt, n.Xoffset+8, im)
 		}
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 3b0f316696..25bdbd5a41 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"fmt"
@@ -43,27 +44,27 @@ import (
 
 // Order holds state during the ordering process.
 type Order struct {
-	out  []*Node            // list of generated statements
-	temp []*Node            // stack of temporary variables
-	free map[string][]*Node // free list of unused temporaries, by type.LongString().
+	out  []*ir.Node            // list of generated statements
+	temp []*ir.Node            // stack of temporary variables
+	free map[string][]*ir.Node // free list of unused temporaries, by type.LongString().
 }
 
 // Order rewrites fn.Nbody to apply the ordering constraints
 // described in the comment at the top of the file.
-func order(fn *Node) {
+func order(fn *ir.Node) {
 	if base.Flag.W > 1 {
 		s := fmt.Sprintf("\nbefore order %v", fn.Func.Nname.Sym)
-		dumplist(s, fn.Nbody)
+		ir.DumpList(s, fn.Nbody)
 	}
 
-	orderBlock(&fn.Nbody, map[string][]*Node{})
+	orderBlock(&fn.Nbody, map[string][]*ir.Node{})
 }
 
 // newTemp allocates a new temporary with the given type,
 // pushes it onto the temp stack, and returns it.
 // If clear is true, newTemp emits code to zero the temporary.
-func (o *Order) newTemp(t *types.Type, clear bool) *Node {
-	var v *Node
+func (o *Order) newTemp(t *types.Type, clear bool) *ir.Node {
+	var v *ir.Node
 	// Note: LongString is close to the type equality we want,
 	// but not exactly. We still need to double-check with types.Identical.
 	key := t.LongString()
@@ -81,7 +82,7 @@ func (o *Order) newTemp(t *types.Type, clear bool) *Node {
 		v = temp(t)
 	}
 	if clear {
-		a := nod(OAS, v, nil)
+		a := ir.Nod(ir.OAS, v, nil)
 		a = typecheck(a, ctxStmt)
 		o.out = append(o.out, a)
 	}
@@ -102,9 +103,9 @@ func (o *Order) newTemp(t *types.Type, clear bool) *Node {
 // (The other candidate would be map access, but map access
 // returns a pointer to the result data instead of taking a pointer
 // to be filled in.)
-func (o *Order) copyExpr(n *Node, t *types.Type, clear bool) *Node {
+func (o *Order) copyExpr(n *ir.Node, t *types.Type, clear bool) *ir.Node {
 	v := o.newTemp(t, clear)
-	a := nod(OAS, v, n)
+	a := ir.Nod(ir.OAS, v, n)
 	a = typecheck(a, ctxStmt)
 	o.out = append(o.out, a)
 	return v
@@ -114,20 +115,20 @@ func (o *Order) copyExpr(n *Node, t *types.Type, clear bool) *Node {
 // The definition of cheap is that n is a variable or constant.
 // If not, cheapExpr allocates a new tmp, emits tmp = n,
 // and then returns tmp.
-func (o *Order) cheapExpr(n *Node) *Node {
+func (o *Order) cheapExpr(n *ir.Node) *ir.Node {
 	if n == nil {
 		return nil
 	}
 
 	switch n.Op {
-	case ONAME, OLITERAL, ONIL:
+	case ir.ONAME, ir.OLITERAL, ir.ONIL:
 		return n
-	case OLEN, OCAP:
+	case ir.OLEN, ir.OCAP:
 		l := o.cheapExpr(n.Left)
 		if l == n.Left {
 			return n
 		}
-		a := n.sepcopy()
+		a := ir.SepCopy(n)
 		a.Left = l
 		return typecheck(a, ctxExpr)
 	}
@@ -142,31 +143,31 @@ func (o *Order) cheapExpr(n *Node) *Node {
 // as assigning to the original n.
 //
 // The intended use is to apply to x when rewriting x += y into x = x + y.
-func (o *Order) safeExpr(n *Node) *Node {
+func (o *Order) safeExpr(n *ir.Node) *ir.Node {
 	switch n.Op {
-	case ONAME, OLITERAL, ONIL:
+	case ir.ONAME, ir.OLITERAL, ir.ONIL:
 		return n
 
-	case ODOT, OLEN, OCAP:
+	case ir.ODOT, ir.OLEN, ir.OCAP:
 		l := o.safeExpr(n.Left)
 		if l == n.Left {
 			return n
 		}
-		a := n.sepcopy()
+		a := ir.SepCopy(n)
 		a.Left = l
 		return typecheck(a, ctxExpr)
 
-	case ODOTPTR, ODEREF:
+	case ir.ODOTPTR, ir.ODEREF:
 		l := o.cheapExpr(n.Left)
 		if l == n.Left {
 			return n
 		}
-		a := n.sepcopy()
+		a := ir.SepCopy(n)
 		a.Left = l
 		return typecheck(a, ctxExpr)
 
-	case OINDEX, OINDEXMAP:
-		var l *Node
+	case ir.OINDEX, ir.OINDEXMAP:
+		var l *ir.Node
 		if n.Left.Type.IsArray() {
 			l = o.safeExpr(n.Left)
 		} else {
@@ -176,7 +177,7 @@ func (o *Order) safeExpr(n *Node) *Node {
 		if l == n.Left && r == n.Right {
 			return n
 		}
-		a := n.sepcopy()
+		a := ir.SepCopy(n)
 		a.Left = l
 		a.Right = r
 		return typecheck(a, ctxExpr)
@@ -193,8 +194,8 @@ func (o *Order) safeExpr(n *Node) *Node {
 // of ordinary stack variables, those are not 'isaddrokay'. Temporaries are okay,
 // because we emit explicit VARKILL instructions marking the end of those
 // temporaries' lifetimes.
-func isaddrokay(n *Node) bool {
-	return islvalue(n) && (n.Op != ONAME || n.Class() == PEXTERN || n.IsAutoTmp())
+func isaddrokay(n *ir.Node) bool {
+	return islvalue(n) && (n.Op != ir.ONAME || n.Class() == ir.PEXTERN || n.IsAutoTmp())
 }
 
 // addrTemp ensures that n is okay to pass by address to runtime routines.
@@ -202,8 +203,8 @@ func isaddrokay(n *Node) bool {
 // tmp = n, and then returns tmp.
 // The result of addrTemp MUST be assigned back to n, e.g.
 // 	n.Left = o.addrTemp(n.Left)
-func (o *Order) addrTemp(n *Node) *Node {
-	if n.Op == OLITERAL || n.Op == ONIL {
+func (o *Order) addrTemp(n *ir.Node) *ir.Node {
+	if n.Op == ir.OLITERAL || n.Op == ir.ONIL {
 		// TODO: expand this to all static composite literal nodes?
 		n = defaultlit(n, nil)
 		dowidth(n.Type)
@@ -224,7 +225,7 @@ func (o *Order) addrTemp(n *Node) *Node {
 
 // mapKeyTemp prepares n to be a key in a map runtime call and returns n.
 // It should only be used for map runtime calls which have *_fast* versions.
-func (o *Order) mapKeyTemp(t *types.Type, n *Node) *Node {
+func (o *Order) mapKeyTemp(t *types.Type, n *ir.Node) *ir.Node {
 	// Most map calls need to take the address of the key.
 	// Exception: map*_fast* calls. See golang.org/issue/19015.
 	if mapfast(t) == mapslow {
@@ -247,21 +248,21 @@ func (o *Order) mapKeyTemp(t *types.Type, n *Node) *Node {
 // It would be nice to handle these generally, but because
 // []byte keys are not allowed in maps, the use of string(k)
 // comes up in important cases in practice. See issue 3512.
-func mapKeyReplaceStrConv(n *Node) bool {
+func mapKeyReplaceStrConv(n *ir.Node) bool {
 	var replaced bool
 	switch n.Op {
-	case OBYTES2STR:
-		n.Op = OBYTES2STRTMP
+	case ir.OBYTES2STR:
+		n.Op = ir.OBYTES2STRTMP
 		replaced = true
-	case OSTRUCTLIT:
+	case ir.OSTRUCTLIT:
 		for _, elem := range n.List.Slice() {
 			if mapKeyReplaceStrConv(elem.Left) {
 				replaced = true
 			}
 		}
-	case OARRAYLIT:
+	case ir.OARRAYLIT:
 		for _, elem := range n.List.Slice() {
-			if elem.Op == OKEY {
+			if elem.Op == ir.OKEY {
 				elem = elem.Right
 			}
 			if mapKeyReplaceStrConv(elem) {
@@ -292,11 +293,11 @@ func (o *Order) popTemp(mark ordermarker) {
 // cleanTempNoPop emits VARKILL instructions to *out
 // for each temporary above the mark on the temporary stack.
 // It does not pop the temporaries from the stack.
-func (o *Order) cleanTempNoPop(mark ordermarker) []*Node {
-	var out []*Node
+func (o *Order) cleanTempNoPop(mark ordermarker) []*ir.Node {
+	var out []*ir.Node
 	for i := len(o.temp) - 1; i >= int(mark); i-- {
 		n := o.temp[i]
-		kill := nod(OVARKILL, n, nil)
+		kill := ir.Nod(ir.OVARKILL, n, nil)
 		kill = typecheck(kill, ctxStmt)
 		out = append(out, kill)
 	}
@@ -311,7 +312,7 @@ func (o *Order) cleanTemp(top ordermarker) {
 }
 
 // stmtList orders each of the statements in the list.
-func (o *Order) stmtList(l Nodes) {
+func (o *Order) stmtList(l ir.Nodes) {
 	s := l.Slice()
 	for i := range s {
 		orderMakeSliceCopy(s[i:])
@@ -323,7 +324,7 @@ func (o *Order) stmtList(l Nodes) {
 //  m = OMAKESLICE([]T, x); OCOPY(m, s)
 // and rewrites it to:
 //  m = OMAKESLICECOPY([]T, x, s); nil
-func orderMakeSliceCopy(s []*Node) {
+func orderMakeSliceCopy(s []*ir.Node) {
 	if base.Flag.N != 0 || instrumenting {
 		return
 	}
@@ -335,17 +336,17 @@ func orderMakeSliceCopy(s []*Node) {
 	asn := s[0]
 	copyn := s[1]
 
-	if asn == nil || asn.Op != OAS {
+	if asn == nil || asn.Op != ir.OAS {
 		return
 	}
-	if asn.Left.Op != ONAME {
+	if asn.Left.Op != ir.ONAME {
 		return
 	}
-	if asn.Left.isBlank() {
+	if ir.IsBlank(asn.Left) {
 		return
 	}
 	maken := asn.Right
-	if maken == nil || maken.Op != OMAKESLICE {
+	if maken == nil || maken.Op != ir.OMAKESLICE {
 		return
 	}
 	if maken.Esc == EscNone {
@@ -354,16 +355,16 @@ func orderMakeSliceCopy(s []*Node) {
 	if maken.Left == nil || maken.Right != nil {
 		return
 	}
-	if copyn.Op != OCOPY {
+	if copyn.Op != ir.OCOPY {
 		return
 	}
-	if copyn.Left.Op != ONAME {
+	if copyn.Left.Op != ir.ONAME {
 		return
 	}
 	if asn.Left.Sym != copyn.Left.Sym {
 		return
 	}
-	if copyn.Right.Op != ONAME {
+	if copyn.Right.Op != ir.ONAME {
 		return
 	}
 
@@ -371,10 +372,10 @@ func orderMakeSliceCopy(s []*Node) {
 		return
 	}
 
-	maken.Op = OMAKESLICECOPY
+	maken.Op = ir.OMAKESLICECOPY
 	maken.Right = copyn.Right
 	// Set bounded when m = OMAKESLICE([]T, len(s)); OCOPY(m, s)
-	maken.SetBounded(maken.Left.Op == OLEN && samesafeexpr(maken.Left.Left, copyn.Right))
+	maken.SetBounded(maken.Left.Op == ir.OLEN && samesafeexpr(maken.Left.Left, copyn.Right))
 
 	maken = typecheck(maken, ctxExpr)
 
@@ -391,12 +392,12 @@ func (o *Order) edge() {
 
 	// Create a new uint8 counter to be allocated in section
 	// __libfuzzer_extra_counters.
-	counter := staticname(types.Types[TUINT8])
+	counter := staticname(types.Types[types.TUINT8])
 	counter.Name.SetLibfuzzerExtraCounter(true)
 
 	// counter += 1
-	incr := nod(OASOP, counter, nodintconst(1))
-	incr.SetSubOp(OADD)
+	incr := ir.Nod(ir.OASOP, counter, nodintconst(1))
+	incr.SetSubOp(ir.OADD)
 	incr = typecheck(incr, ctxStmt)
 
 	o.out = append(o.out, incr)
@@ -405,7 +406,7 @@ func (o *Order) edge() {
 // orderBlock orders the block of statements in n into a new slice,
 // and then replaces the old slice in n with the new slice.
 // free is a map that can be used to obtain temporary variables by type.
-func orderBlock(n *Nodes, free map[string][]*Node) {
+func orderBlock(n *ir.Nodes, free map[string][]*ir.Node) {
 	var order Order
 	order.free = free
 	mark := order.markTemp()
@@ -419,7 +420,7 @@ func orderBlock(n *Nodes, free map[string][]*Node) {
 // leaves them as the init list of the final *np.
 // The result of exprInPlace MUST be assigned back to n, e.g.
 // 	n.Left = o.exprInPlace(n.Left)
-func (o *Order) exprInPlace(n *Node) *Node {
+func (o *Order) exprInPlace(n *ir.Node) *ir.Node {
 	var order Order
 	order.free = o.free
 	n = order.expr(n, nil)
@@ -436,7 +437,7 @@ func (o *Order) exprInPlace(n *Node) *Node {
 // The result of orderStmtInPlace MUST be assigned back to n, e.g.
 // 	n.Left = orderStmtInPlace(n.Left)
 // free is a map that can be used to obtain temporary variables by type.
-func orderStmtInPlace(n *Node, free map[string][]*Node) *Node {
+func orderStmtInPlace(n *ir.Node, free map[string][]*ir.Node) *ir.Node {
 	var order Order
 	order.free = free
 	mark := order.markTemp()
@@ -446,8 +447,8 @@ func orderStmtInPlace(n *Node, free map[string][]*Node) *Node {
 }
 
 // init moves n's init list to o.out.
-func (o *Order) init(n *Node) {
-	if n.mayBeShared() {
+func (o *Order) init(n *ir.Node) {
+	if ir.MayBeShared(n) {
 		// For concurrency safety, don't mutate potentially shared nodes.
 		// First, ensure that no work is required here.
 		if n.Ninit.Len() > 0 {
@@ -461,14 +462,14 @@ func (o *Order) init(n *Node) {
 
 // call orders the call expression n.
 // n.Op is OCALLMETH/OCALLFUNC/OCALLINTER or a builtin like OCOPY.
-func (o *Order) call(n *Node) {
+func (o *Order) call(n *ir.Node) {
 	if n.Ninit.Len() > 0 {
 		// Caller should have already called o.init(n).
 		base.Fatalf("%v with unexpected ninit", n.Op)
 	}
 
 	// Builtin functions.
-	if n.Op != OCALLFUNC && n.Op != OCALLMETH && n.Op != OCALLINTER {
+	if n.Op != ir.OCALLFUNC && n.Op != ir.OCALLMETH && n.Op != ir.OCALLINTER {
 		n.Left = o.expr(n.Left, nil)
 		n.Right = o.expr(n.Right, nil)
 		o.exprList(n.List)
@@ -479,26 +480,26 @@ func (o *Order) call(n *Node) {
 	n.Left = o.expr(n.Left, nil)
 	o.exprList(n.List)
 
-	if n.Op == OCALLINTER {
+	if n.Op == ir.OCALLINTER {
 		return
 	}
-	keepAlive := func(arg *Node) {
+	keepAlive := func(arg *ir.Node) {
 		// If the argument is really a pointer being converted to uintptr,
 		// arrange for the pointer to be kept alive until the call returns,
 		// by copying it into a temp and marking that temp
 		// still alive when we pop the temp stack.
-		if arg.Op == OCONVNOP && arg.Left.Type.IsUnsafePtr() {
+		if arg.Op == ir.OCONVNOP && arg.Left.Type.IsUnsafePtr() {
 			x := o.copyExpr(arg.Left, arg.Left.Type, false)
 			arg.Left = x
 			x.Name.SetAddrtaken(true) // ensure SSA keeps the x variable
-			n.Nbody.Append(typecheck(nod(OVARLIVE, x, nil), ctxStmt))
+			n.Nbody.Append(typecheck(ir.Nod(ir.OVARLIVE, x, nil), ctxStmt))
 		}
 	}
 
 	// Check for "unsafe-uintptr" tag provided by escape analysis.
 	for i, param := range n.Left.Type.Params().FieldSlice() {
 		if param.Note == unsafeUintptrTag || param.Note == uintptrEscapesTag {
-			if arg := n.List.Index(i); arg.Op == OSLICELIT {
+			if arg := n.List.Index(i); arg.Op == ir.OSLICELIT {
 				for _, elt := range arg.List.Slice() {
 					keepAlive(elt)
 				}
@@ -524,16 +525,16 @@ func (o *Order) call(n *Node) {
 // cases they are also typically registerizable, so not much harm done.
 // And this only applies to the multiple-assignment form.
 // We could do a more precise analysis if needed, like in walk.go.
-func (o *Order) mapAssign(n *Node) {
+func (o *Order) mapAssign(n *ir.Node) {
 	switch n.Op {
 	default:
 		base.Fatalf("order.mapAssign %v", n.Op)
 
-	case OAS, OASOP:
-		if n.Left.Op == OINDEXMAP {
+	case ir.OAS, ir.OASOP:
+		if n.Left.Op == ir.OINDEXMAP {
 			// Make sure we evaluate the RHS before starting the map insert.
 			// We need to make sure the RHS won't panic.  See issue 22881.
-			if n.Right.Op == OAPPEND {
+			if n.Right.Op == ir.OAPPEND {
 				s := n.Right.List.Slice()[1:]
 				for i, n := range s {
 					s[i] = o.cheapExpr(n)
@@ -544,11 +545,11 @@ func (o *Order) mapAssign(n *Node) {
 		}
 		o.out = append(o.out, n)
 
-	case OAS2, OAS2DOTTYPE, OAS2MAPR, OAS2FUNC:
-		var post []*Node
+	case ir.OAS2, ir.OAS2DOTTYPE, ir.OAS2MAPR, ir.OAS2FUNC:
+		var post []*ir.Node
 		for i, m := range n.List.Slice() {
 			switch {
-			case m.Op == OINDEXMAP:
+			case m.Op == ir.OINDEXMAP:
 				if !m.Left.IsAutoTmp() {
 					m.Left = o.copyExpr(m.Left, m.Left.Type, false)
 				}
@@ -556,10 +557,10 @@ func (o *Order) mapAssign(n *Node) {
 					m.Right = o.copyExpr(m.Right, m.Right.Type, false)
 				}
 				fallthrough
-			case instrumenting && n.Op == OAS2FUNC && !m.isBlank():
+			case instrumenting && n.Op == ir.OAS2FUNC && !ir.IsBlank(m):
 				t := o.newTemp(m.Type, false)
 				n.List.SetIndex(i, t)
-				a := nod(OAS, m, t)
+				a := ir.Nod(ir.OAS, m, t)
 				a = typecheck(a, ctxStmt)
 				post = append(post, a)
 			}
@@ -573,7 +574,7 @@ func (o *Order) mapAssign(n *Node) {
 // stmt orders the statement n, appending to o.out.
 // Temporaries created during the statement are cleaned
 // up using VARKILL instructions as possible.
-func (o *Order) stmt(n *Node) {
+func (o *Order) stmt(n *ir.Node) {
 	if n == nil {
 		return
 	}
@@ -585,22 +586,22 @@ func (o *Order) stmt(n *Node) {
 	default:
 		base.Fatalf("order.stmt %v", n.Op)
 
-	case OVARKILL, OVARLIVE, OINLMARK:
+	case ir.OVARKILL, ir.OVARLIVE, ir.OINLMARK:
 		o.out = append(o.out, n)
 
-	case OAS:
+	case ir.OAS:
 		t := o.markTemp()
 		n.Left = o.expr(n.Left, nil)
 		n.Right = o.expr(n.Right, n.Left)
 		o.mapAssign(n)
 		o.cleanTemp(t)
 
-	case OASOP:
+	case ir.OASOP:
 		t := o.markTemp()
 		n.Left = o.expr(n.Left, nil)
 		n.Right = o.expr(n.Right, nil)
 
-		if instrumenting || n.Left.Op == OINDEXMAP && (n.SubOp() == ODIV || n.SubOp() == OMOD) {
+		if instrumenting || n.Left.Op == ir.OINDEXMAP && (n.SubOp() == ir.ODIV || n.SubOp() == ir.OMOD) {
 			// Rewrite m[k] op= r into m[k] = m[k] op r so
 			// that we can ensure that if op panics
 			// because r is zero, the panic happens before
@@ -609,22 +610,22 @@ func (o *Order) stmt(n *Node) {
 			n.Left = o.safeExpr(n.Left)
 
 			l := treecopy(n.Left, src.NoXPos)
-			if l.Op == OINDEXMAP {
+			if l.Op == ir.OINDEXMAP {
 				l.SetIndexMapLValue(false)
 			}
 			l = o.copyExpr(l, n.Left.Type, false)
-			n.Right = nod(n.SubOp(), l, n.Right)
+			n.Right = ir.Nod(n.SubOp(), l, n.Right)
 			n.Right = typecheck(n.Right, ctxExpr)
 			n.Right = o.expr(n.Right, nil)
 
-			n.Op = OAS
+			n.Op = ir.OAS
 			n.ResetAux()
 		}
 
 		o.mapAssign(n)
 		o.cleanTemp(t)
 
-	case OAS2:
+	case ir.OAS2:
 		t := o.markTemp()
 		o.exprList(n.List)
 		o.exprList(n.Rlist)
@@ -632,7 +633,7 @@ func (o *Order) stmt(n *Node) {
 		o.cleanTemp(t)
 
 	// Special: avoid copy of func call n.Right
-	case OAS2FUNC:
+	case ir.OAS2FUNC:
 		t := o.markTemp()
 		o.exprList(n.List)
 		o.init(n.Right)
@@ -646,14 +647,14 @@ func (o *Order) stmt(n *Node) {
 	//
 	// OAS2MAPR: make sure key is addressable if needed,
 	//           and make sure OINDEXMAP is not copied out.
-	case OAS2DOTTYPE, OAS2RECV, OAS2MAPR:
+	case ir.OAS2DOTTYPE, ir.OAS2RECV, ir.OAS2MAPR:
 		t := o.markTemp()
 		o.exprList(n.List)
 
 		switch r := n.Right; r.Op {
-		case ODOTTYPE2, ORECV:
+		case ir.ODOTTYPE2, ir.ORECV:
 			r.Left = o.expr(r.Left, nil)
-		case OINDEXMAP:
+		case ir.OINDEXMAP:
 			r.Left = o.expr(r.Left, nil)
 			r.Right = o.expr(r.Right, nil)
 			// See similar conversion for OINDEXMAP below.
@@ -667,34 +668,34 @@ func (o *Order) stmt(n *Node) {
 		o.cleanTemp(t)
 
 	// Special: does not save n onto out.
-	case OBLOCK, OEMPTY:
+	case ir.OBLOCK, ir.OEMPTY:
 		o.stmtList(n.List)
 
 	// Special: n->left is not an expression; save as is.
-	case OBREAK,
-		OCONTINUE,
-		ODCL,
-		ODCLCONST,
-		ODCLTYPE,
-		OFALL,
-		OGOTO,
-		OLABEL,
-		ORETJMP:
+	case ir.OBREAK,
+		ir.OCONTINUE,
+		ir.ODCL,
+		ir.ODCLCONST,
+		ir.ODCLTYPE,
+		ir.OFALL,
+		ir.OGOTO,
+		ir.OLABEL,
+		ir.ORETJMP:
 		o.out = append(o.out, n)
 
 	// Special: handle call arguments.
-	case OCALLFUNC, OCALLINTER, OCALLMETH:
+	case ir.OCALLFUNC, ir.OCALLINTER, ir.OCALLMETH:
 		t := o.markTemp()
 		o.call(n)
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
 
-	case OCLOSE,
-		OCOPY,
-		OPRINT,
-		OPRINTN,
-		ORECOVER,
-		ORECV:
+	case ir.OCLOSE,
+		ir.OCOPY,
+		ir.OPRINT,
+		ir.OPRINTN,
+		ir.ORECOVER,
+		ir.ORECV:
 		t := o.markTemp()
 		n.Left = o.expr(n.Left, nil)
 		n.Right = o.expr(n.Right, nil)
@@ -704,14 +705,14 @@ func (o *Order) stmt(n *Node) {
 		o.cleanTemp(t)
 
 	// Special: order arguments to inner call but not call itself.
-	case ODEFER, OGO:
+	case ir.ODEFER, ir.OGO:
 		t := o.markTemp()
 		o.init(n.Left)
 		o.call(n.Left)
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
 
-	case ODELETE:
+	case ir.ODELETE:
 		t := o.markTemp()
 		n.List.SetFirst(o.expr(n.List.First(), nil))
 		n.List.SetSecond(o.expr(n.List.Second(), nil))
@@ -721,7 +722,7 @@ func (o *Order) stmt(n *Node) {
 
 	// Clean temporaries from condition evaluation at
 	// beginning of loop body and after for statement.
-	case OFOR:
+	case ir.OFOR:
 		t := o.markTemp()
 		n.Left = o.exprInPlace(n.Left)
 		n.Nbody.Prepend(o.cleanTempNoPop(t)...)
@@ -732,7 +733,7 @@ func (o *Order) stmt(n *Node) {
 
 	// Clean temporaries from condition at
 	// beginning of both branches.
-	case OIF:
+	case ir.OIF:
 		t := o.markTemp()
 		n.Left = o.exprInPlace(n.Left)
 		n.Nbody.Prepend(o.cleanTempNoPop(t)...)
@@ -744,7 +745,7 @@ func (o *Order) stmt(n *Node) {
 
 	// Special: argument will be converted to interface using convT2E
 	// so make sure it is an addressable temporary.
-	case OPANIC:
+	case ir.OPANIC:
 		t := o.markTemp()
 		n.Left = o.expr(n.Left, nil)
 		if !n.Left.Type.IsInterface() {
@@ -753,7 +754,7 @@ func (o *Order) stmt(n *Node) {
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
 
-	case ORANGE:
+	case ir.ORANGE:
 		// n.Right is the expression being ranged over.
 		// order it, and then make a copy if we need one.
 		// We almost always do, to ensure that we don't
@@ -767,8 +768,8 @@ func (o *Order) stmt(n *Node) {
 
 		// Mark []byte(str) range expression to reuse string backing storage.
 		// It is safe because the storage cannot be mutated.
-		if n.Right.Op == OSTR2BYTES {
-			n.Right.Op = OSTR2BYTESTMP
+		if n.Right.Op == ir.OSTR2BYTES {
+			n.Right.Op = ir.OSTR2BYTESTMP
 		}
 
 		t := o.markTemp()
@@ -779,28 +780,28 @@ func (o *Order) stmt(n *Node) {
 		default:
 			base.Fatalf("order.stmt range %v", n.Type)
 
-		case TARRAY, TSLICE:
-			if n.List.Len() < 2 || n.List.Second().isBlank() {
+		case types.TARRAY, types.TSLICE:
+			if n.List.Len() < 2 || ir.IsBlank(n.List.Second()) {
 				// for i := range x will only use x once, to compute len(x).
 				// No need to copy it.
 				break
 			}
 			fallthrough
 
-		case TCHAN, TSTRING:
+		case types.TCHAN, types.TSTRING:
 			// chan, string, slice, array ranges use value multiple times.
 			// make copy.
 			r := n.Right
 
-			if r.Type.IsString() && r.Type != types.Types[TSTRING] {
-				r = nod(OCONV, r, nil)
-				r.Type = types.Types[TSTRING]
+			if r.Type.IsString() && r.Type != types.Types[types.TSTRING] {
+				r = ir.Nod(ir.OCONV, r, nil)
+				r.Type = types.Types[types.TSTRING]
 				r = typecheck(r, ctxExpr)
 			}
 
 			n.Right = o.copyExpr(r, r.Type, false)
 
-		case TMAP:
+		case types.TMAP:
 			if isMapClear(n) {
 				// Preserve the body of the map clear pattern so it can
 				// be detected during walk. The loop body will not be used
@@ -826,7 +827,7 @@ func (o *Order) stmt(n *Node) {
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
 
-	case ORETURN:
+	case ir.ORETURN:
 		o.exprList(n.List)
 		o.out = append(o.out, n)
 
@@ -839,11 +840,11 @@ func (o *Order) stmt(n *Node) {
 	// reordered after the channel evaluation for a different
 	// case (if p were nil, then the timing of the fault would
 	// give this away).
-	case OSELECT:
+	case ir.OSELECT:
 		t := o.markTemp()
 
 		for _, n2 := range n.List.Slice() {
-			if n2.Op != OCASE {
+			if n2.Op != ir.OCASE {
 				base.Fatalf("order select case %v", n2.Op)
 			}
 			r := n2.Left
@@ -859,20 +860,20 @@ func (o *Order) stmt(n *Node) {
 			}
 			switch r.Op {
 			default:
-				Dump("select case", r)
+				ir.Dump("select case", r)
 				base.Fatalf("unknown op in select %v", r.Op)
 
 			// If this is case x := <-ch or case x, y := <-ch, the case has
 			// the ODCL nodes to declare x and y. We want to delay that
 			// declaration (and possible allocation) until inside the case body.
 			// Delete the ODCL nodes here and recreate them inside the body below.
-			case OSELRECV, OSELRECV2:
+			case ir.OSELRECV, ir.OSELRECV2:
 				if r.Colas() {
 					i := 0
-					if r.Ninit.Len() != 0 && r.Ninit.First().Op == ODCL && r.Ninit.First().Left == r.Left {
+					if r.Ninit.Len() != 0 && r.Ninit.First().Op == ir.ODCL && r.Ninit.First().Left == r.Left {
 						i++
 					}
-					if i < r.Ninit.Len() && r.Ninit.Index(i).Op == ODCL && r.List.Len() != 0 && r.Ninit.Index(i).Left == r.List.First() {
+					if i < r.Ninit.Len() && r.Ninit.Index(i).Op == ir.ODCL && r.List.Len() != 0 && r.Ninit.Index(i).Left == r.List.First() {
 						i++
 					}
 					if i >= r.Ninit.Len() {
@@ -881,7 +882,7 @@ func (o *Order) stmt(n *Node) {
 				}
 
 				if r.Ninit.Len() != 0 {
-					dumplist("ninit", r.Ninit)
+					ir.DumpList("ninit", r.Ninit)
 					base.Fatalf("ninit on select recv")
 				}
 
@@ -892,7 +893,7 @@ func (o *Order) stmt(n *Node) {
 				// c is always evaluated; x and ok are only evaluated when assigned.
 				r.Right.Left = o.expr(r.Right.Left, nil)
 
-				if r.Right.Left.Op != ONAME {
+				if r.Right.Left.Op != ir.ONAME {
 					r.Right.Left = o.copyExpr(r.Right.Left, r.Right.Left.Type, false)
 				}
 
@@ -902,7 +903,7 @@ func (o *Order) stmt(n *Node) {
 				// temporary per distinct type, sharing the temp among all receives
 				// with that temp. Similarly one ok bool could be shared among all
 				// the x,ok receives. Not worth doing until there's a clear need.
-				if r.Left != nil && r.Left.isBlank() {
+				if r.Left != nil && ir.IsBlank(r.Left) {
 					r.Left = nil
 				}
 				if r.Left != nil {
@@ -912,38 +913,38 @@ func (o *Order) stmt(n *Node) {
 					tmp1 := r.Left
 
 					if r.Colas() {
-						tmp2 := nod(ODCL, tmp1, nil)
+						tmp2 := ir.Nod(ir.ODCL, tmp1, nil)
 						tmp2 = typecheck(tmp2, ctxStmt)
 						n2.Ninit.Append(tmp2)
 					}
 
 					r.Left = o.newTemp(r.Right.Left.Type.Elem(), r.Right.Left.Type.Elem().HasPointers())
-					tmp2 := nod(OAS, tmp1, r.Left)
+					tmp2 := ir.Nod(ir.OAS, tmp1, r.Left)
 					tmp2 = typecheck(tmp2, ctxStmt)
 					n2.Ninit.Append(tmp2)
 				}
 
-				if r.List.Len() != 0 && r.List.First().isBlank() {
+				if r.List.Len() != 0 && ir.IsBlank(r.List.First()) {
 					r.List.Set(nil)
 				}
 				if r.List.Len() != 0 {
 					tmp1 := r.List.First()
 					if r.Colas() {
-						tmp2 := nod(ODCL, tmp1, nil)
+						tmp2 := ir.Nod(ir.ODCL, tmp1, nil)
 						tmp2 = typecheck(tmp2, ctxStmt)
 						n2.Ninit.Append(tmp2)
 					}
 
-					r.List.Set1(o.newTemp(types.Types[TBOOL], false))
+					r.List.Set1(o.newTemp(types.Types[types.TBOOL], false))
 					tmp2 := okas(tmp1, r.List.First())
 					tmp2 = typecheck(tmp2, ctxStmt)
 					n2.Ninit.Append(tmp2)
 				}
 				orderBlock(&n2.Ninit, o.free)
 
-			case OSEND:
+			case ir.OSEND:
 				if r.Ninit.Len() != 0 {
-					dumplist("ninit", r.Ninit)
+					ir.DumpList("ninit", r.Ninit)
 					base.Fatalf("ninit on select send")
 				}
 
@@ -977,7 +978,7 @@ func (o *Order) stmt(n *Node) {
 		o.popTemp(t)
 
 	// Special: value being sent is passed as a pointer; make it addressable.
-	case OSEND:
+	case ir.OSEND:
 		t := o.markTemp()
 		n.Left = o.expr(n.Left, nil)
 		n.Right = o.expr(n.Right, nil)
@@ -998,16 +999,16 @@ func (o *Order) stmt(n *Node) {
 	// the if-else chain instead.)
 	// For now just clean all the temporaries at the end.
 	// In practice that's fine.
-	case OSWITCH:
+	case ir.OSWITCH:
 		if base.Debug.Libfuzzer != 0 && !hasDefaultCase(n) {
 			// Add empty "default:" case for instrumentation.
-			n.List.Append(nod(OCASE, nil, nil))
+			n.List.Append(ir.Nod(ir.OCASE, nil, nil))
 		}
 
 		t := o.markTemp()
 		n.Left = o.expr(n.Left, nil)
 		for _, ncas := range n.List.Slice() {
-			if ncas.Op != OCASE {
+			if ncas.Op != ir.OCASE {
 				base.Fatalf("order switch case %v", ncas.Op)
 			}
 			o.exprListInPlace(ncas.List)
@@ -1021,9 +1022,9 @@ func (o *Order) stmt(n *Node) {
 	base.Pos = lno
 }
 
-func hasDefaultCase(n *Node) bool {
+func hasDefaultCase(n *ir.Node) bool {
 	for _, ncas := range n.List.Slice() {
-		if ncas.Op != OCASE {
+		if ncas.Op != ir.OCASE {
 			base.Fatalf("expected case, found %v", ncas.Op)
 		}
 		if ncas.List.Len() == 0 {
@@ -1034,7 +1035,7 @@ func hasDefaultCase(n *Node) bool {
 }
 
 // exprList orders the expression list l into o.
-func (o *Order) exprList(l Nodes) {
+func (o *Order) exprList(l ir.Nodes) {
 	s := l.Slice()
 	for i := range s {
 		s[i] = o.expr(s[i], nil)
@@ -1043,7 +1044,7 @@ func (o *Order) exprList(l Nodes) {
 
 // exprListInPlace orders the expression list l but saves
 // the side effects on the individual expression ninit lists.
-func (o *Order) exprListInPlace(l Nodes) {
+func (o *Order) exprListInPlace(l ir.Nodes) {
 	s := l.Slice()
 	for i := range s {
 		s[i] = o.exprInPlace(s[i])
@@ -1051,7 +1052,7 @@ func (o *Order) exprListInPlace(l Nodes) {
 }
 
 // prealloc[x] records the allocation to use for x.
-var prealloc = map[*Node]*Node{}
+var prealloc = map[*ir.Node]*ir.Node{}
 
 // expr orders a single expression, appending side
 // effects to o.out as needed.
@@ -1060,7 +1061,7 @@ var prealloc = map[*Node]*Node{}
 // to avoid copying the result of the expression to a temporary.)
 // The result of expr MUST be assigned back to n, e.g.
 // 	n.Left = o.expr(n.Left, lhs)
-func (o *Order) expr(n, lhs *Node) *Node {
+func (o *Order) expr(n, lhs *ir.Node) *ir.Node {
 	if n == nil {
 		return n
 	}
@@ -1078,11 +1079,11 @@ func (o *Order) expr(n, lhs *Node) *Node {
 	// Addition of strings turns into a function call.
 	// Allocate a temporary to hold the strings.
 	// Fewer than 5 strings use direct runtime helpers.
-	case OADDSTR:
+	case ir.OADDSTR:
 		o.exprList(n.List)
 
 		if n.List.Len() > 5 {
-			t := types.NewArray(types.Types[TSTRING], int64(n.List.Len()))
+			t := types.NewArray(types.Types[types.TSTRING], int64(n.List.Len()))
 			prealloc[n] = o.newTemp(t, false)
 		}
 
@@ -1097,19 +1098,19 @@ func (o *Order) expr(n, lhs *Node) *Node {
 
 		haslit := false
 		for _, n1 := range n.List.Slice() {
-			hasbyte = hasbyte || n1.Op == OBYTES2STR
-			haslit = haslit || n1.Op == OLITERAL && len(n1.StringVal()) != 0
+			hasbyte = hasbyte || n1.Op == ir.OBYTES2STR
+			haslit = haslit || n1.Op == ir.OLITERAL && len(n1.StringVal()) != 0
 		}
 
 		if haslit && hasbyte {
 			for _, n2 := range n.List.Slice() {
-				if n2.Op == OBYTES2STR {
-					n2.Op = OBYTES2STRTMP
+				if n2.Op == ir.OBYTES2STR {
+					n2.Op = ir.OBYTES2STRTMP
 				}
 			}
 		}
 
-	case OINDEXMAP:
+	case ir.OINDEXMAP:
 		n.Left = o.expr(n.Left, nil)
 		n.Right = o.expr(n.Right, nil)
 		needCopy := false
@@ -1136,7 +1137,7 @@ func (o *Order) expr(n, lhs *Node) *Node {
 
 	// concrete type (not interface) argument might need an addressable
 	// temporary to pass to the runtime conversion routine.
-	case OCONVIFACE:
+	case ir.OCONVIFACE:
 		n.Left = o.expr(n.Left, nil)
 		if n.Left.Type.IsInterface() {
 			break
@@ -1148,21 +1149,21 @@ func (o *Order) expr(n, lhs *Node) *Node {
 			n.Left = o.addrTemp(n.Left)
 		}
 
-	case OCONVNOP:
-		if n.Type.IsKind(TUNSAFEPTR) && n.Left.Type.IsKind(TUINTPTR) && (n.Left.Op == OCALLFUNC || n.Left.Op == OCALLINTER || n.Left.Op == OCALLMETH) {
+	case ir.OCONVNOP:
+		if n.Type.IsKind(types.TUNSAFEPTR) && n.Left.Type.IsKind(types.TUINTPTR) && (n.Left.Op == ir.OCALLFUNC || n.Left.Op == ir.OCALLINTER || n.Left.Op == ir.OCALLMETH) {
 			// When reordering unsafe.Pointer(f()) into a separate
 			// statement, the conversion and function call must stay
 			// together. See golang.org/issue/15329.
 			o.init(n.Left)
 			o.call(n.Left)
-			if lhs == nil || lhs.Op != ONAME || instrumenting {
+			if lhs == nil || lhs.Op != ir.ONAME || instrumenting {
 				n = o.copyExpr(n, n.Type, false)
 			}
 		} else {
 			n.Left = o.expr(n.Left, nil)
 		}
 
-	case OANDAND, OOROR:
+	case ir.OANDAND, ir.OOROR:
 		// ... = LHS && RHS
 		//
 		// var r bool
@@ -1176,7 +1177,7 @@ func (o *Order) expr(n, lhs *Node) *Node {
 
 		// Evaluate left-hand side.
 		lhs := o.expr(n.Left, nil)
-		o.out = append(o.out, typecheck(nod(OAS, r, lhs), ctxStmt))
+		o.out = append(o.out, typecheck(ir.Nod(ir.OAS, r, lhs), ctxStmt))
 
 		// Evaluate right-hand side, save generated code.
 		saveout := o.out
@@ -1184,14 +1185,14 @@ func (o *Order) expr(n, lhs *Node) *Node {
 		t := o.markTemp()
 		o.edge()
 		rhs := o.expr(n.Right, nil)
-		o.out = append(o.out, typecheck(nod(OAS, r, rhs), ctxStmt))
+		o.out = append(o.out, typecheck(ir.Nod(ir.OAS, r, rhs), ctxStmt))
 		o.cleanTemp(t)
 		gen := o.out
 		o.out = saveout
 
 		// If left-hand side doesn't cause a short-circuit, issue right-hand side.
-		nif := nod(OIF, r, nil)
-		if n.Op == OANDAND {
+		nif := ir.Nod(ir.OIF, r, nil)
+		if n.Op == ir.OANDAND {
 			nif.Nbody.Set(gen)
 		} else {
 			nif.Rlist.Set(gen)
@@ -1199,24 +1200,24 @@ func (o *Order) expr(n, lhs *Node) *Node {
 		o.out = append(o.out, nif)
 		n = r
 
-	case OCALLFUNC,
-		OCALLINTER,
-		OCALLMETH,
-		OCAP,
-		OCOMPLEX,
-		OCOPY,
-		OIMAG,
-		OLEN,
-		OMAKECHAN,
-		OMAKEMAP,
-		OMAKESLICE,
-		OMAKESLICECOPY,
-		ONEW,
-		OREAL,
-		ORECOVER,
-		OSTR2BYTES,
-		OSTR2BYTESTMP,
-		OSTR2RUNES:
+	case ir.OCALLFUNC,
+		ir.OCALLINTER,
+		ir.OCALLMETH,
+		ir.OCAP,
+		ir.OCOMPLEX,
+		ir.OCOPY,
+		ir.OIMAG,
+		ir.OLEN,
+		ir.OMAKECHAN,
+		ir.OMAKEMAP,
+		ir.OMAKESLICE,
+		ir.OMAKESLICECOPY,
+		ir.ONEW,
+		ir.OREAL,
+		ir.ORECOVER,
+		ir.OSTR2BYTES,
+		ir.OSTR2BYTESTMP,
+		ir.OSTR2RUNES:
 
 		if isRuneCount(n) {
 			// len([]rune(s)) is rewritten to runtime.countrunes(s) later.
@@ -1225,11 +1226,11 @@ func (o *Order) expr(n, lhs *Node) *Node {
 			o.call(n)
 		}
 
-		if lhs == nil || lhs.Op != ONAME || instrumenting {
+		if lhs == nil || lhs.Op != ir.ONAME || instrumenting {
 			n = o.copyExpr(n, n.Type, false)
 		}
 
-	case OAPPEND:
+	case ir.OAPPEND:
 		// Check for append(x, make([]T, y)...) .
 		if isAppendOfMake(n) {
 			n.List.SetFirst(o.expr(n.List.First(), nil))             // order x
@@ -1238,11 +1239,11 @@ func (o *Order) expr(n, lhs *Node) *Node {
 			o.exprList(n.List)
 		}
 
-		if lhs == nil || lhs.Op != ONAME && !samesafeexpr(lhs, n.List.First()) {
+		if lhs == nil || lhs.Op != ir.ONAME && !samesafeexpr(lhs, n.List.First()) {
 			n = o.copyExpr(n, n.Type, false)
 		}
 
-	case OSLICE, OSLICEARR, OSLICESTR, OSLICE3, OSLICE3ARR:
+	case ir.OSLICE, ir.OSLICEARR, ir.OSLICESTR, ir.OSLICE3, ir.OSLICE3ARR:
 		n.Left = o.expr(n.Left, nil)
 		low, high, max := n.SliceBounds()
 		low = o.expr(low, nil)
@@ -1252,16 +1253,16 @@ func (o *Order) expr(n, lhs *Node) *Node {
 		max = o.expr(max, nil)
 		max = o.cheapExpr(max)
 		n.SetSliceBounds(low, high, max)
-		if lhs == nil || lhs.Op != ONAME && !samesafeexpr(lhs, n.Left) {
+		if lhs == nil || lhs.Op != ir.ONAME && !samesafeexpr(lhs, n.Left) {
 			n = o.copyExpr(n, n.Type, false)
 		}
 
-	case OCLOSURE:
+	case ir.OCLOSURE:
 		if n.Transient() && n.Func.ClosureVars.Len() > 0 {
 			prealloc[n] = o.newTemp(closureType(n), false)
 		}
 
-	case OSLICELIT, OCALLPART:
+	case ir.OSLICELIT, ir.OCALLPART:
 		n.Left = o.expr(n.Left, nil)
 		n.Right = o.expr(n.Right, nil)
 		o.exprList(n.List)
@@ -1269,25 +1270,25 @@ func (o *Order) expr(n, lhs *Node) *Node {
 		if n.Transient() {
 			var t *types.Type
 			switch n.Op {
-			case OSLICELIT:
+			case ir.OSLICELIT:
 				t = types.NewArray(n.Type.Elem(), n.Right.Int64Val())
-			case OCALLPART:
+			case ir.OCALLPART:
 				t = partialCallType(n)
 			}
 			prealloc[n] = o.newTemp(t, false)
 		}
 
-	case ODOTTYPE, ODOTTYPE2:
+	case ir.ODOTTYPE, ir.ODOTTYPE2:
 		n.Left = o.expr(n.Left, nil)
 		if !isdirectiface(n.Type) || instrumenting {
 			n = o.copyExpr(n, n.Type, true)
 		}
 
-	case ORECV:
+	case ir.ORECV:
 		n.Left = o.expr(n.Left, nil)
 		n = o.copyExpr(n, n.Type, true)
 
-	case OEQ, ONE, OLT, OLE, OGT, OGE:
+	case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
 		n.Left = o.expr(n.Left, nil)
 		n.Right = o.expr(n.Right, nil)
 
@@ -1297,11 +1298,11 @@ func (o *Order) expr(n, lhs *Node) *Node {
 			// Mark string(byteSlice) arguments to reuse byteSlice backing
 			// buffer during conversion. String comparison does not
 			// memorize the strings for later use, so it is safe.
-			if n.Left.Op == OBYTES2STR {
-				n.Left.Op = OBYTES2STRTMP
+			if n.Left.Op == ir.OBYTES2STR {
+				n.Left.Op = ir.OBYTES2STRTMP
 			}
-			if n.Right.Op == OBYTES2STR {
-				n.Right.Op = OBYTES2STRTMP
+			if n.Right.Op == ir.OBYTES2STR {
+				n.Right.Op = ir.OBYTES2STRTMP
 			}
 
 		case t.IsStruct() || t.IsArray():
@@ -1310,7 +1311,7 @@ func (o *Order) expr(n, lhs *Node) *Node {
 			n.Left = o.addrTemp(n.Left)
 			n.Right = o.addrTemp(n.Right)
 		}
-	case OMAPLIT:
+	case ir.OMAPLIT:
 		// Order map by converting:
 		//   map[int]int{
 		//     a(): b(),
@@ -1328,9 +1329,9 @@ func (o *Order) expr(n, lhs *Node) *Node {
 		// See issue 26552.
 		entries := n.List.Slice()
 		statics := entries[:0]
-		var dynamics []*Node
+		var dynamics []*ir.Node
 		for _, r := range entries {
-			if r.Op != OKEY {
+			if r.Op != ir.OKEY {
 				base.Fatalf("OMAPLIT entry not OKEY: %v\n", r)
 			}
 
@@ -1357,14 +1358,14 @@ func (o *Order) expr(n, lhs *Node) *Node {
 
 		// Emit the creation of the map (with all its static entries).
 		m := o.newTemp(n.Type, false)
-		as := nod(OAS, m, n)
+		as := ir.Nod(ir.OAS, m, n)
 		typecheck(as, ctxStmt)
 		o.stmt(as)
 		n = m
 
 		// Emit eval+insert of dynamic entries, one at a time.
 		for _, r := range dynamics {
-			as := nod(OAS, nod(OINDEX, n, r.Left), r.Right)
+			as := ir.Nod(ir.OAS, ir.Nod(ir.OINDEX, n, r.Left), r.Right)
 			typecheck(as, ctxStmt) // Note: this converts the OINDEX to an OINDEXMAP
 			o.stmt(as)
 		}
@@ -1376,11 +1377,11 @@ func (o *Order) expr(n, lhs *Node) *Node {
 
 // okas creates and returns an assignment of val to ok,
 // including an explicit conversion if necessary.
-func okas(ok, val *Node) *Node {
-	if !ok.isBlank() {
+func okas(ok, val *ir.Node) *ir.Node {
+	if !ir.IsBlank(ok) {
 		val = conv(val, ok.Type)
 	}
-	return nod(OAS, ok, val)
+	return ir.Nod(ir.OAS, ok, val)
 }
 
 // as2 orders OAS2XXXX nodes. It creates temporaries to ensure left-to-right assignment.
@@ -1391,11 +1392,11 @@ func okas(ok, val *Node) *Node {
 //	tmp1, tmp2, tmp3 = ...
 // 	a, b, a = tmp1, tmp2, tmp3
 // This is necessary to ensure left to right assignment order.
-func (o *Order) as2(n *Node) {
-	tmplist := []*Node{}
-	left := []*Node{}
+func (o *Order) as2(n *ir.Node) {
+	tmplist := []*ir.Node{}
+	left := []*ir.Node{}
 	for ni, l := range n.List.Slice() {
-		if !l.isBlank() {
+		if !ir.IsBlank(l) {
 			tmp := o.newTemp(l.Type, l.Type.HasPointers())
 			n.List.SetIndex(ni, tmp)
 			tmplist = append(tmplist, tmp)
@@ -1405,7 +1406,7 @@ func (o *Order) as2(n *Node) {
 
 	o.out = append(o.out, n)
 
-	as := nod(OAS2, nil, nil)
+	as := ir.Nod(ir.OAS2, nil, nil)
 	as.List.Set(left)
 	as.Rlist.Set(tmplist)
 	as = typecheck(as, ctxStmt)
@@ -1414,21 +1415,21 @@ func (o *Order) as2(n *Node) {
 
 // okAs2 orders OAS2XXX with ok.
 // Just like as2, this also adds temporaries to ensure left-to-right assignment.
-func (o *Order) okAs2(n *Node) {
-	var tmp1, tmp2 *Node
-	if !n.List.First().isBlank() {
+func (o *Order) okAs2(n *ir.Node) {
+	var tmp1, tmp2 *ir.Node
+	if !ir.IsBlank(n.List.First()) {
 		typ := n.Right.Type
 		tmp1 = o.newTemp(typ, typ.HasPointers())
 	}
 
-	if !n.List.Second().isBlank() {
-		tmp2 = o.newTemp(types.Types[TBOOL], false)
+	if !ir.IsBlank(n.List.Second()) {
+		tmp2 = o.newTemp(types.Types[types.TBOOL], false)
 	}
 
 	o.out = append(o.out, n)
 
 	if tmp1 != nil {
-		r := nod(OAS, n.List.First(), tmp1)
+		r := ir.Nod(ir.OAS, n.List.First(), tmp1)
 		r = typecheck(r, ctxStmt)
 		o.mapAssign(r)
 		n.List.SetFirst(tmp1)
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index f10599dc28..38f416c1c3 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
 	"cmd/internal/dwarf"
@@ -23,14 +24,14 @@ import (
 // "Portable" code generation.
 
 var (
-	compilequeue []*Node // functions waiting to be compiled
+	compilequeue []*ir.Node // functions waiting to be compiled
 )
 
-func emitptrargsmap(fn *Node) {
-	if fn.funcname() == "_" || fn.Func.Nname.Sym.Linkname != "" {
+func emitptrargsmap(fn *ir.Node) {
+	if ir.FuncName(fn) == "_" || fn.Func.Nname.Sym.Linkname != "" {
 		return
 	}
-	lsym := base.Ctxt.Lookup(fn.Func.lsym.Name + ".args_stackmap")
+	lsym := base.Ctxt.Lookup(fn.Func.LSym.Name + ".args_stackmap")
 
 	nptr := int(fn.Type.ArgWidth() / int64(Widthptr))
 	bv := bvalloc(int32(nptr) * 2)
@@ -41,7 +42,7 @@ func emitptrargsmap(fn *Node) {
 	off := duint32(lsym, 0, uint32(nbitmap))
 	off = duint32(lsym, off, uint32(bv.n))
 
-	if fn.IsMethod() {
+	if ir.IsMethod(fn) {
 		onebitwalktype1(fn.Type.Recvs(), 0, bv)
 	}
 	if fn.Type.NumParams() > 0 {
@@ -67,12 +68,12 @@ func emitptrargsmap(fn *Node) {
 // really means, in memory, things with pointers needing zeroing at
 // the top of the stack and increasing in size.
 // Non-autos sort on offset.
-func cmpstackvarlt(a, b *Node) bool {
-	if (a.Class() == PAUTO) != (b.Class() == PAUTO) {
-		return b.Class() == PAUTO
+func cmpstackvarlt(a, b *ir.Node) bool {
+	if (a.Class() == ir.PAUTO) != (b.Class() == ir.PAUTO) {
+		return b.Class() == ir.PAUTO
 	}
 
-	if a.Class() != PAUTO {
+	if a.Class() != ir.PAUTO {
 		return a.Xoffset < b.Xoffset
 	}
 
@@ -100,7 +101,7 @@ func cmpstackvarlt(a, b *Node) bool {
 }
 
 // byStackvar implements sort.Interface for []*Node using cmpstackvarlt.
-type byStackVar []*Node
+type byStackVar []*ir.Node
 
 func (s byStackVar) Len() int           { return len(s) }
 func (s byStackVar) Less(i, j int) bool { return cmpstackvarlt(s[i], s[j]) }
@@ -113,28 +114,28 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 
 	// Mark the PAUTO's unused.
 	for _, ln := range fn.Dcl {
-		if ln.Class() == PAUTO {
+		if ln.Class() == ir.PAUTO {
 			ln.Name.SetUsed(false)
 		}
 	}
 
 	for _, l := range f.RegAlloc {
 		if ls, ok := l.(ssa.LocalSlot); ok {
-			ls.N.(*Node).Name.SetUsed(true)
+			ls.N.(*ir.Node).Name.SetUsed(true)
 		}
 	}
 
 	scratchUsed := false
 	for _, b := range f.Blocks {
 		for _, v := range b.Values {
-			if n, ok := v.Aux.(*Node); ok {
+			if n, ok := v.Aux.(*ir.Node); ok {
 				switch n.Class() {
-				case PPARAM, PPARAMOUT:
+				case ir.PPARAM, ir.PPARAMOUT:
 					// Don't modify nodfp; it is a global.
 					if n != nodfp {
 						n.Name.SetUsed(true)
 					}
-				case PAUTO:
+				case ir.PAUTO:
 					n.Name.SetUsed(true)
 				}
 			}
@@ -146,7 +147,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 	}
 
 	if f.Config.NeedsFpScratch && scratchUsed {
-		s.scratchFpMem = tempAt(src.NoXPos, s.curfn, types.Types[TUINT64])
+		s.scratchFpMem = tempAt(src.NoXPos, s.curfn, types.Types[types.TUINT64])
 	}
 
 	sort.Sort(byStackVar(fn.Dcl))
@@ -154,7 +155,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 	// Reassign stack offsets of the locals that are used.
 	lastHasPtr := false
 	for i, n := range fn.Dcl {
-		if n.Op != ONAME || n.Class() != PAUTO {
+		if n.Op != ir.ONAME || n.Class() != ir.PAUTO {
 			continue
 		}
 		if !n.Name.Used() {
@@ -192,7 +193,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 	s.stkptrsize = Rnd(s.stkptrsize, int64(Widthreg))
 }
 
-func funccompile(fn *Node) {
+func funccompile(fn *ir.Node) {
 	if Curfn != nil {
 		base.Fatalf("funccompile %v inside %v", fn.Func.Nname.Sym, Curfn.Func.Nname.Sym)
 	}
@@ -209,21 +210,21 @@ func funccompile(fn *Node) {
 
 	if fn.Nbody.Len() == 0 {
 		// Initialize ABI wrappers if necessary.
-		fn.Func.initLSym(false)
+		initLSym(fn.Func, false)
 		emitptrargsmap(fn)
 		return
 	}
 
-	dclcontext = PAUTO
+	dclcontext = ir.PAUTO
 	Curfn = fn
 
 	compile(fn)
 
 	Curfn = nil
-	dclcontext = PEXTERN
+	dclcontext = ir.PEXTERN
 }
 
-func compile(fn *Node) {
+func compile(fn *ir.Node) {
 	errorsBefore := base.Errors()
 	order(fn)
 	if base.Errors() > errorsBefore {
@@ -233,7 +234,7 @@ func compile(fn *Node) {
 	// Set up the function's LSym early to avoid data races with the assemblers.
 	// Do this before walk, as walk needs the LSym to set attributes/relocations
 	// (e.g. in markTypeUsedInInterface).
-	fn.Func.initLSym(true)
+	initLSym(fn.Func, true)
 
 	walk(fn)
 	if base.Errors() > errorsBefore {
@@ -246,7 +247,7 @@ func compile(fn *Node) {
 	// From this point, there should be no uses of Curfn. Enforce that.
 	Curfn = nil
 
-	if fn.funcname() == "_" {
+	if ir.FuncName(fn) == "_" {
 		// We don't need to generate code for this function, just report errors in its body.
 		// At this point we've generated any errors needed.
 		// (Beyond here we generate only non-spec errors, like "stack frame too large".)
@@ -260,13 +261,13 @@ func compile(fn *Node) {
 	// phase of the compiler.
 	for _, n := range fn.Func.Dcl {
 		switch n.Class() {
-		case PPARAM, PPARAMOUT, PAUTO:
+		case ir.PPARAM, ir.PPARAMOUT, ir.PAUTO:
 			if livenessShouldTrack(n) && n.Name.Addrtaken() {
 				dtypesym(n.Type)
 				// Also make sure we allocate a linker symbol
 				// for the stack object data, for the same reason.
-				if fn.Func.lsym.Func().StackObjects == nil {
-					fn.Func.lsym.Func().StackObjects = base.Ctxt.Lookup(fn.Func.lsym.Name + ".stkobj")
+				if fn.Func.LSym.Func().StackObjects == nil {
+					fn.Func.LSym.Func().StackObjects = base.Ctxt.Lookup(fn.Func.LSym.Name + ".stkobj")
 				}
 			}
 		}
@@ -283,13 +284,13 @@ func compile(fn *Node) {
 // If functions are not compiled immediately,
 // they are enqueued in compilequeue,
 // which is drained by compileFunctions.
-func compilenow(fn *Node) bool {
+func compilenow(fn *ir.Node) bool {
 	// Issue 38068: if this function is a method AND an inline
 	// candidate AND was not inlined (yet), put it onto the compile
 	// queue instead of compiling it immediately. This is in case we
 	// wind up inlining it into a method wrapper that is generated by
 	// compiling a function later on in the xtop list.
-	if fn.IsMethod() && isInlinableButNotInlined(fn) {
+	if ir.IsMethod(fn) && isInlinableButNotInlined(fn) {
 		return false
 	}
 	return base.Flag.LowerC == 1 && base.Debug.CompileLater == 0
@@ -298,7 +299,7 @@ func compilenow(fn *Node) bool {
 // isInlinableButNotInlined returns true if 'fn' was marked as an
 // inline candidate but then never inlined (presumably because we
 // found no call sites).
-func isInlinableButNotInlined(fn *Node) bool {
+func isInlinableButNotInlined(fn *ir.Node) bool {
 	if fn.Func.Nname.Func.Inl == nil {
 		return false
 	}
@@ -314,7 +315,7 @@ const maxStackSize = 1 << 30
 // uses it to generate a plist,
 // and flushes that plist to machine code.
 // worker indicates which of the backend workers is doing the processing.
-func compileSSA(fn *Node, worker int) {
+func compileSSA(fn *ir.Node, worker int) {
 	f := buildssa(fn, worker)
 	// Note: check arg size to fix issue 25507.
 	if f.Frontend().(*ssafn).stksize >= maxStackSize || fn.Type.ArgWidth() >= maxStackSize {
@@ -359,7 +360,7 @@ func compileFunctions() {
 		sizeCalculationDisabled = true // not safe to calculate sizes concurrently
 		if race.Enabled {
 			// Randomize compilation order to try to shake out races.
-			tmp := make([]*Node, len(compilequeue))
+			tmp := make([]*ir.Node, len(compilequeue))
 			perm := rand.Perm(len(compilequeue))
 			for i, v := range perm {
 				tmp[v] = compilequeue[i]
@@ -375,7 +376,7 @@ func compileFunctions() {
 		}
 		var wg sync.WaitGroup
 		base.Ctxt.InParallel = true
-		c := make(chan *Node, base.Flag.LowerC)
+		c := make(chan *ir.Node, base.Flag.LowerC)
 		for i := 0; i < base.Flag.LowerC; i++ {
 			wg.Add(1)
 			go func(worker int) {
@@ -397,7 +398,7 @@ func compileFunctions() {
 }
 
 func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.Scope, dwarf.InlCalls) {
-	fn := curfn.(*Node)
+	fn := curfn.(*ir.Node)
 	if fn.Func.Nname != nil {
 		if expect := fn.Func.Nname.Sym.Linksym(); fnsym != expect {
 			base.Fatalf("unexpected fnsym: %v != %v", fnsym, expect)
@@ -429,17 +430,17 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 	//
 	// These two adjustments keep toolstash -cmp working for now.
 	// Deciding the right answer is, as they say, future work.
-	isODCLFUNC := fn.Op == ODCLFUNC
+	isODCLFUNC := fn.Op == ir.ODCLFUNC
 
-	var apdecls []*Node
+	var apdecls []*ir.Node
 	// Populate decls for fn.
 	if isODCLFUNC {
 		for _, n := range fn.Func.Dcl {
-			if n.Op != ONAME { // might be OTYPE or OLITERAL
+			if n.Op != ir.ONAME { // might be OTYPE or OLITERAL
 				continue
 			}
 			switch n.Class() {
-			case PAUTO:
+			case ir.PAUTO:
 				if !n.Name.Used() {
 					// Text == nil -> generating abstract function
 					if fnsym.Func().Text != nil {
@@ -447,7 +448,7 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 					}
 					continue
 				}
-			case PPARAM, PPARAMOUT:
+			case ir.PPARAM, ir.PPARAMOUT:
 			default:
 				continue
 			}
@@ -474,7 +475,7 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 	}
 	fnsym.Func().Autot = nil
 
-	var varScopes []ScopeID
+	var varScopes []ir.ScopeID
 	for _, decl := range decls {
 		pos := declPos(decl)
 		varScopes = append(varScopes, findScope(fn.Func.Marks, pos))
@@ -488,7 +489,7 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 	return scopes, inlcalls
 }
 
-func declPos(decl *Node) src.XPos {
+func declPos(decl *ir.Node) src.XPos {
 	if decl.Name.Defn != nil && (decl.Name.Captured() || decl.Name.Byval()) {
 		// It's not clear which position is correct for captured variables here:
 		// * decl.Pos is the wrong position for captured variables, in the inner
@@ -511,10 +512,10 @@ func declPos(decl *Node) src.XPos {
 
 // createSimpleVars creates a DWARF entry for every variable declared in the
 // function, claiming that they are permanently on the stack.
-func createSimpleVars(fnsym *obj.LSym, apDecls []*Node) ([]*Node, []*dwarf.Var, map[*Node]bool) {
+func createSimpleVars(fnsym *obj.LSym, apDecls []*ir.Node) ([]*ir.Node, []*dwarf.Var, map[*ir.Node]bool) {
 	var vars []*dwarf.Var
-	var decls []*Node
-	selected := make(map[*Node]bool)
+	var decls []*ir.Node
+	selected := make(map[*ir.Node]bool)
 	for _, n := range apDecls {
 		if n.IsAutoTmp() {
 			continue
@@ -527,12 +528,12 @@ func createSimpleVars(fnsym *obj.LSym, apDecls []*Node) ([]*Node, []*dwarf.Var,
 	return decls, vars, selected
 }
 
-func createSimpleVar(fnsym *obj.LSym, n *Node) *dwarf.Var {
+func createSimpleVar(fnsym *obj.LSym, n *ir.Node) *dwarf.Var {
 	var abbrev int
 	offs := n.Xoffset
 
 	switch n.Class() {
-	case PAUTO:
+	case ir.PAUTO:
 		abbrev = dwarf.DW_ABRV_AUTO
 		if base.Ctxt.FixedFrameSize() == 0 {
 			offs -= int64(Widthptr)
@@ -542,7 +543,7 @@ func createSimpleVar(fnsym *obj.LSym, n *Node) *dwarf.Var {
 			offs -= int64(Widthptr)
 		}
 
-	case PPARAM, PPARAMOUT:
+	case ir.PPARAM, ir.PPARAMOUT:
 		abbrev = dwarf.DW_ABRV_PARAM
 		offs += base.Ctxt.FixedFrameSize()
 	default:
@@ -563,7 +564,7 @@ func createSimpleVar(fnsym *obj.LSym, n *Node) *dwarf.Var {
 	declpos := base.Ctxt.InnermostPos(declPos(n))
 	return &dwarf.Var{
 		Name:          n.Sym.Name,
-		IsReturnValue: n.Class() == PPARAMOUT,
+		IsReturnValue: n.Class() == ir.PPARAMOUT,
 		IsInlFormal:   n.Name.InlFormal(),
 		Abbrev:        abbrev,
 		StackOffset:   int32(offs),
@@ -578,19 +579,19 @@ func createSimpleVar(fnsym *obj.LSym, n *Node) *dwarf.Var {
 
 // createComplexVars creates recomposed DWARF vars with location lists,
 // suitable for describing optimized code.
-func createComplexVars(fnsym *obj.LSym, fn *Func) ([]*Node, []*dwarf.Var, map[*Node]bool) {
+func createComplexVars(fnsym *obj.LSym, fn *ir.Func) ([]*ir.Node, []*dwarf.Var, map[*ir.Node]bool) {
 	debugInfo := fn.DebugInfo
 
 	// Produce a DWARF variable entry for each user variable.
-	var decls []*Node
+	var decls []*ir.Node
 	var vars []*dwarf.Var
-	ssaVars := make(map[*Node]bool)
+	ssaVars := make(map[*ir.Node]bool)
 
 	for varID, dvar := range debugInfo.Vars {
-		n := dvar.(*Node)
+		n := dvar.(*ir.Node)
 		ssaVars[n] = true
 		for _, slot := range debugInfo.VarSlots[varID] {
-			ssaVars[debugInfo.Slots[slot].N.(*Node)] = true
+			ssaVars[debugInfo.Slots[slot].N.(*ir.Node)] = true
 		}
 
 		if dvar := createComplexVar(fnsym, fn, ssa.VarID(varID)); dvar != nil {
@@ -604,11 +605,11 @@ func createComplexVars(fnsym *obj.LSym, fn *Func) ([]*Node, []*dwarf.Var, map[*N
 
 // createDwarfVars process fn, returning a list of DWARF variables and the
 // Nodes they represent.
-func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *Func, apDecls []*Node) ([]*Node, []*dwarf.Var) {
+func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir.Node) ([]*ir.Node, []*dwarf.Var) {
 	// Collect a raw list of DWARF vars.
 	var vars []*dwarf.Var
-	var decls []*Node
-	var selected map[*Node]bool
+	var decls []*ir.Node
+	var selected map[*ir.Node]bool
 	if base.Ctxt.Flag_locationlists && base.Ctxt.Flag_optimize && fn.DebugInfo != nil && complexOK {
 		decls, vars, selected = createComplexVars(fnsym, fn)
 	} else {
@@ -640,7 +641,7 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *Func, apDecls []*Node)
 		if c == '.' || n.Type.IsUntyped() {
 			continue
 		}
-		if n.Class() == PPARAM && !canSSAType(n.Type) {
+		if n.Class() == ir.PPARAM && !canSSAType(n.Type) {
 			// SSA-able args get location lists, and may move in and
 			// out of registers, so those are handled elsewhere.
 			// Autos and named output params seem to get handled
@@ -655,10 +656,10 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *Func, apDecls []*Node)
 		typename := dwarf.InfoPrefix + typesymname(n.Type)
 		decls = append(decls, n)
 		abbrev := dwarf.DW_ABRV_AUTO_LOCLIST
-		isReturnValue := (n.Class() == PPARAMOUT)
-		if n.Class() == PPARAM || n.Class() == PPARAMOUT {
+		isReturnValue := (n.Class() == ir.PPARAMOUT)
+		if n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT {
 			abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
-		} else if n.Class() == PAUTOHEAP {
+		} else if n.Class() == ir.PAUTOHEAP {
 			// If dcl in question has been promoted to heap, do a bit
 			// of extra work to recover original class (auto or param);
 			// see issue 30908. This insures that we get the proper
@@ -667,9 +668,9 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *Func, apDecls []*Node)
 			// and not stack).
 			// TODO(thanm): generate a better location expression
 			stackcopy := n.Name.Param.Stackcopy
-			if stackcopy != nil && (stackcopy.Class() == PPARAM || stackcopy.Class() == PPARAMOUT) {
+			if stackcopy != nil && (stackcopy.Class() == ir.PPARAM || stackcopy.Class() == ir.PPARAMOUT) {
 				abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
-				isReturnValue = (stackcopy.Class() == PPARAMOUT)
+				isReturnValue = (stackcopy.Class() == ir.PPARAMOUT)
 			}
 		}
 		inlIndex := 0
@@ -707,9 +708,9 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *Func, apDecls []*Node)
 // function that is not local to the package being compiled, then the
 // names of the variables may have been "versioned" to avoid conflicts
 // with local vars; disregard this versioning when sorting.
-func preInliningDcls(fnsym *obj.LSym) []*Node {
-	fn := base.Ctxt.DwFixups.GetPrecursorFunc(fnsym).(*Node)
-	var rdcl []*Node
+func preInliningDcls(fnsym *obj.LSym) []*ir.Node {
+	fn := base.Ctxt.DwFixups.GetPrecursorFunc(fnsym).(*ir.Node)
+	var rdcl []*ir.Node
 	for _, n := range fn.Func.Inl.Dcl {
 		c := n.Sym.Name[0]
 		// Avoid reporting "_" parameters, since if there are more than
@@ -726,10 +727,10 @@ func preInliningDcls(fnsym *obj.LSym) []*Node {
 // stack pointer, suitable for use in a DWARF location entry. This has nothing
 // to do with its offset in the user variable.
 func stackOffset(slot ssa.LocalSlot) int32 {
-	n := slot.N.(*Node)
+	n := slot.N.(*ir.Node)
 	var off int64
 	switch n.Class() {
-	case PAUTO:
+	case ir.PAUTO:
 		if base.Ctxt.FixedFrameSize() == 0 {
 			off -= int64(Widthptr)
 		}
@@ -737,22 +738,22 @@ func stackOffset(slot ssa.LocalSlot) int32 {
 			// There is a word space for FP on ARM64 even if the frame pointer is disabled
 			off -= int64(Widthptr)
 		}
-	case PPARAM, PPARAMOUT:
+	case ir.PPARAM, ir.PPARAMOUT:
 		off += base.Ctxt.FixedFrameSize()
 	}
 	return int32(off + n.Xoffset + slot.Off)
 }
 
 // createComplexVar builds a single DWARF variable entry and location list.
-func createComplexVar(fnsym *obj.LSym, fn *Func, varID ssa.VarID) *dwarf.Var {
+func createComplexVar(fnsym *obj.LSym, fn *ir.Func, varID ssa.VarID) *dwarf.Var {
 	debug := fn.DebugInfo
-	n := debug.Vars[varID].(*Node)
+	n := debug.Vars[varID].(*ir.Node)
 
 	var abbrev int
 	switch n.Class() {
-	case PAUTO:
+	case ir.PAUTO:
 		abbrev = dwarf.DW_ABRV_AUTO_LOCLIST
-	case PPARAM, PPARAMOUT:
+	case ir.PPARAM, ir.PPARAMOUT:
 		abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
 	default:
 		return nil
@@ -773,7 +774,7 @@ func createComplexVar(fnsym *obj.LSym, fn *Func, varID ssa.VarID) *dwarf.Var {
 	declpos := base.Ctxt.InnermostPos(n.Pos)
 	dvar := &dwarf.Var{
 		Name:          n.Sym.Name,
-		IsReturnValue: n.Class() == PPARAMOUT,
+		IsReturnValue: n.Class() == ir.PPARAMOUT,
 		IsInlFormal:   n.Name.InlFormal(),
 		Abbrev:        abbrev,
 		Type:          base.Ctxt.Lookup(typename),
diff --git a/src/cmd/compile/internal/gc/pgen_test.go b/src/cmd/compile/internal/gc/pgen_test.go
index 932ab47d02..9f1f00d46a 100644
--- a/src/cmd/compile/internal/gc/pgen_test.go
+++ b/src/cmd/compile/internal/gc/pgen_test.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"reflect"
 	"sort"
@@ -12,133 +13,133 @@ import (
 )
 
 func typeWithoutPointers() *types.Type {
-	t := types.New(TSTRUCT)
-	f := &types.Field{Type: types.New(TINT)}
+	t := types.New(types.TSTRUCT)
+	f := &types.Field{Type: types.New(types.TINT)}
 	t.SetFields([]*types.Field{f})
 	return t
 }
 
 func typeWithPointers() *types.Type {
-	t := types.New(TSTRUCT)
-	f := &types.Field{Type: types.NewPtr(types.New(TINT))}
+	t := types.New(types.TSTRUCT)
+	f := &types.Field{Type: types.NewPtr(types.New(types.TINT))}
 	t.SetFields([]*types.Field{f})
 	return t
 }
 
-func markUsed(n *Node) *Node {
+func markUsed(n *ir.Node) *ir.Node {
 	n.Name.SetUsed(true)
 	return n
 }
 
-func markNeedZero(n *Node) *Node {
+func markNeedZero(n *ir.Node) *ir.Node {
 	n.Name.SetNeedzero(true)
 	return n
 }
 
 // Test all code paths for cmpstackvarlt.
 func TestCmpstackvar(t *testing.T) {
-	nod := func(xoffset int64, t *types.Type, s *types.Sym, cl Class) *Node {
+	nod := func(xoffset int64, t *types.Type, s *types.Sym, cl ir.Class) *ir.Node {
 		if s == nil {
 			s = &types.Sym{Name: "."}
 		}
-		n := newname(s)
+		n := NewName(s)
 		n.Type = t
 		n.Xoffset = xoffset
 		n.SetClass(cl)
 		return n
 	}
 	testdata := []struct {
-		a, b *Node
+		a, b *ir.Node
 		lt   bool
 	}{
 		{
-			nod(0, nil, nil, PAUTO),
-			nod(0, nil, nil, PFUNC),
+			nod(0, nil, nil, ir.PAUTO),
+			nod(0, nil, nil, ir.PFUNC),
 			false,
 		},
 		{
-			nod(0, nil, nil, PFUNC),
-			nod(0, nil, nil, PAUTO),
+			nod(0, nil, nil, ir.PFUNC),
+			nod(0, nil, nil, ir.PAUTO),
 			true,
 		},
 		{
-			nod(0, nil, nil, PFUNC),
-			nod(10, nil, nil, PFUNC),
+			nod(0, nil, nil, ir.PFUNC),
+			nod(10, nil, nil, ir.PFUNC),
 			true,
 		},
 		{
-			nod(20, nil, nil, PFUNC),
-			nod(10, nil, nil, PFUNC),
+			nod(20, nil, nil, ir.PFUNC),
+			nod(10, nil, nil, ir.PFUNC),
 			false,
 		},
 		{
-			nod(10, nil, nil, PFUNC),
-			nod(10, nil, nil, PFUNC),
+			nod(10, nil, nil, ir.PFUNC),
+			nod(10, nil, nil, ir.PFUNC),
 			false,
 		},
 		{
-			nod(10, nil, nil, PPARAM),
-			nod(20, nil, nil, PPARAMOUT),
+			nod(10, nil, nil, ir.PPARAM),
+			nod(20, nil, nil, ir.PPARAMOUT),
 			true,
 		},
 		{
-			nod(10, nil, nil, PPARAMOUT),
-			nod(20, nil, nil, PPARAM),
+			nod(10, nil, nil, ir.PPARAMOUT),
+			nod(20, nil, nil, ir.PPARAM),
 			true,
 		},
 		{
-			markUsed(nod(0, nil, nil, PAUTO)),
-			nod(0, nil, nil, PAUTO),
+			markUsed(nod(0, nil, nil, ir.PAUTO)),
+			nod(0, nil, nil, ir.PAUTO),
 			true,
 		},
 		{
-			nod(0, nil, nil, PAUTO),
-			markUsed(nod(0, nil, nil, PAUTO)),
+			nod(0, nil, nil, ir.PAUTO),
+			markUsed(nod(0, nil, nil, ir.PAUTO)),
 			false,
 		},
 		{
-			nod(0, typeWithoutPointers(), nil, PAUTO),
-			nod(0, typeWithPointers(), nil, PAUTO),
+			nod(0, typeWithoutPointers(), nil, ir.PAUTO),
+			nod(0, typeWithPointers(), nil, ir.PAUTO),
 			false,
 		},
 		{
-			nod(0, typeWithPointers(), nil, PAUTO),
-			nod(0, typeWithoutPointers(), nil, PAUTO),
+			nod(0, typeWithPointers(), nil, ir.PAUTO),
+			nod(0, typeWithoutPointers(), nil, ir.PAUTO),
 			true,
 		},
 		{
-			markNeedZero(nod(0, &types.Type{}, nil, PAUTO)),
-			nod(0, &types.Type{}, nil, PAUTO),
+			markNeedZero(nod(0, &types.Type{}, nil, ir.PAUTO)),
+			nod(0, &types.Type{}, nil, ir.PAUTO),
 			true,
 		},
 		{
-			nod(0, &types.Type{}, nil, PAUTO),
-			markNeedZero(nod(0, &types.Type{}, nil, PAUTO)),
+			nod(0, &types.Type{}, nil, ir.PAUTO),
+			markNeedZero(nod(0, &types.Type{}, nil, ir.PAUTO)),
 			false,
 		},
 		{
-			nod(0, &types.Type{Width: 1}, nil, PAUTO),
-			nod(0, &types.Type{Width: 2}, nil, PAUTO),
+			nod(0, &types.Type{Width: 1}, nil, ir.PAUTO),
+			nod(0, &types.Type{Width: 2}, nil, ir.PAUTO),
 			false,
 		},
 		{
-			nod(0, &types.Type{Width: 2}, nil, PAUTO),
-			nod(0, &types.Type{Width: 1}, nil, PAUTO),
+			nod(0, &types.Type{Width: 2}, nil, ir.PAUTO),
+			nod(0, &types.Type{Width: 1}, nil, ir.PAUTO),
 			true,
 		},
 		{
-			nod(0, &types.Type{}, &types.Sym{Name: "abc"}, PAUTO),
-			nod(0, &types.Type{}, &types.Sym{Name: "xyz"}, PAUTO),
+			nod(0, &types.Type{}, &types.Sym{Name: "abc"}, ir.PAUTO),
+			nod(0, &types.Type{}, &types.Sym{Name: "xyz"}, ir.PAUTO),
 			true,
 		},
 		{
-			nod(0, &types.Type{}, &types.Sym{Name: "abc"}, PAUTO),
-			nod(0, &types.Type{}, &types.Sym{Name: "abc"}, PAUTO),
+			nod(0, &types.Type{}, &types.Sym{Name: "abc"}, ir.PAUTO),
+			nod(0, &types.Type{}, &types.Sym{Name: "abc"}, ir.PAUTO),
 			false,
 		},
 		{
-			nod(0, &types.Type{}, &types.Sym{Name: "xyz"}, PAUTO),
-			nod(0, &types.Type{}, &types.Sym{Name: "abc"}, PAUTO),
+			nod(0, &types.Type{}, &types.Sym{Name: "xyz"}, ir.PAUTO),
+			nod(0, &types.Type{}, &types.Sym{Name: "abc"}, ir.PAUTO),
 			false,
 		},
 	}
@@ -155,42 +156,42 @@ func TestCmpstackvar(t *testing.T) {
 }
 
 func TestStackvarSort(t *testing.T) {
-	nod := func(xoffset int64, t *types.Type, s *types.Sym, cl Class) *Node {
-		n := newname(s)
+	nod := func(xoffset int64, t *types.Type, s *types.Sym, cl ir.Class) *ir.Node {
+		n := NewName(s)
 		n.Type = t
 		n.Xoffset = xoffset
 		n.SetClass(cl)
 		return n
 	}
-	inp := []*Node{
-		nod(0, &types.Type{}, &types.Sym{}, PFUNC),
-		nod(0, &types.Type{}, &types.Sym{}, PAUTO),
-		nod(0, &types.Type{}, &types.Sym{}, PFUNC),
-		nod(10, &types.Type{}, &types.Sym{}, PFUNC),
-		nod(20, &types.Type{}, &types.Sym{}, PFUNC),
-		markUsed(nod(0, &types.Type{}, &types.Sym{}, PAUTO)),
-		nod(0, typeWithoutPointers(), &types.Sym{}, PAUTO),
-		nod(0, &types.Type{}, &types.Sym{}, PAUTO),
-		markNeedZero(nod(0, &types.Type{}, &types.Sym{}, PAUTO)),
-		nod(0, &types.Type{Width: 1}, &types.Sym{}, PAUTO),
-		nod(0, &types.Type{Width: 2}, &types.Sym{}, PAUTO),
-		nod(0, &types.Type{}, &types.Sym{Name: "abc"}, PAUTO),
-		nod(0, &types.Type{}, &types.Sym{Name: "xyz"}, PAUTO),
+	inp := []*ir.Node{
+		nod(0, &types.Type{}, &types.Sym{}, ir.PFUNC),
+		nod(0, &types.Type{}, &types.Sym{}, ir.PAUTO),
+		nod(0, &types.Type{}, &types.Sym{}, ir.PFUNC),
+		nod(10, &types.Type{}, &types.Sym{}, ir.PFUNC),
+		nod(20, &types.Type{}, &types.Sym{}, ir.PFUNC),
+		markUsed(nod(0, &types.Type{}, &types.Sym{}, ir.PAUTO)),
+		nod(0, typeWithoutPointers(), &types.Sym{}, ir.PAUTO),
+		nod(0, &types.Type{}, &types.Sym{}, ir.PAUTO),
+		markNeedZero(nod(0, &types.Type{}, &types.Sym{}, ir.PAUTO)),
+		nod(0, &types.Type{Width: 1}, &types.Sym{}, ir.PAUTO),
+		nod(0, &types.Type{Width: 2}, &types.Sym{}, ir.PAUTO),
+		nod(0, &types.Type{}, &types.Sym{Name: "abc"}, ir.PAUTO),
+		nod(0, &types.Type{}, &types.Sym{Name: "xyz"}, ir.PAUTO),
 	}
-	want := []*Node{
-		nod(0, &types.Type{}, &types.Sym{}, PFUNC),
-		nod(0, &types.Type{}, &types.Sym{}, PFUNC),
-		nod(10, &types.Type{}, &types.Sym{}, PFUNC),
-		nod(20, &types.Type{}, &types.Sym{}, PFUNC),
-		markUsed(nod(0, &types.Type{}, &types.Sym{}, PAUTO)),
-		markNeedZero(nod(0, &types.Type{}, &types.Sym{}, PAUTO)),
-		nod(0, &types.Type{Width: 2}, &types.Sym{}, PAUTO),
-		nod(0, &types.Type{Width: 1}, &types.Sym{}, PAUTO),
-		nod(0, &types.Type{}, &types.Sym{}, PAUTO),
-		nod(0, &types.Type{}, &types.Sym{}, PAUTO),
-		nod(0, &types.Type{}, &types.Sym{Name: "abc"}, PAUTO),
-		nod(0, &types.Type{}, &types.Sym{Name: "xyz"}, PAUTO),
-		nod(0, typeWithoutPointers(), &types.Sym{}, PAUTO),
+	want := []*ir.Node{
+		nod(0, &types.Type{}, &types.Sym{}, ir.PFUNC),
+		nod(0, &types.Type{}, &types.Sym{}, ir.PFUNC),
+		nod(10, &types.Type{}, &types.Sym{}, ir.PFUNC),
+		nod(20, &types.Type{}, &types.Sym{}, ir.PFUNC),
+		markUsed(nod(0, &types.Type{}, &types.Sym{}, ir.PAUTO)),
+		markNeedZero(nod(0, &types.Type{}, &types.Sym{}, ir.PAUTO)),
+		nod(0, &types.Type{Width: 2}, &types.Sym{}, ir.PAUTO),
+		nod(0, &types.Type{Width: 1}, &types.Sym{}, ir.PAUTO),
+		nod(0, &types.Type{}, &types.Sym{}, ir.PAUTO),
+		nod(0, &types.Type{}, &types.Sym{}, ir.PAUTO),
+		nod(0, &types.Type{}, &types.Sym{Name: "abc"}, ir.PAUTO),
+		nod(0, &types.Type{}, &types.Sym{Name: "xyz"}, ir.PAUTO),
+		nod(0, typeWithoutPointers(), &types.Sym{}, ir.PAUTO),
 	}
 	sort.Sort(byStackVar(inp))
 	if !reflect.DeepEqual(want, inp) {
diff --git a/src/cmd/compile/internal/gc/phi.go b/src/cmd/compile/internal/gc/phi.go
index 4beaa11a7e..2a88d4a5b4 100644
--- a/src/cmd/compile/internal/gc/phi.go
+++ b/src/cmd/compile/internal/gc/phi.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
@@ -40,11 +41,11 @@ func (s *state) insertPhis() {
 }
 
 type phiState struct {
-	s       *state                 // SSA state
-	f       *ssa.Func              // function to work on
-	defvars []map[*Node]*ssa.Value // defined variables at end of each block
+	s       *state                    // SSA state
+	f       *ssa.Func                 // function to work on
+	defvars []map[*ir.Node]*ssa.Value // defined variables at end of each block
 
-	varnum map[*Node]int32 // variable numbering
+	varnum map[*ir.Node]int32 // variable numbering
 
 	// properties of the dominator tree
 	idom  []*ssa.Block // dominator parents
@@ -70,15 +71,15 @@ func (s *phiState) insertPhis() {
 	// Find all the variables for which we need to match up reads & writes.
 	// This step prunes any basic-block-only variables from consideration.
 	// Generate a numbering for these variables.
-	s.varnum = map[*Node]int32{}
-	var vars []*Node
+	s.varnum = map[*ir.Node]int32{}
+	var vars []*ir.Node
 	var vartypes []*types.Type
 	for _, b := range s.f.Blocks {
 		for _, v := range b.Values {
 			if v.Op != ssa.OpFwdRef {
 				continue
 			}
-			var_ := v.Aux.(*Node)
+			var_ := v.Aux.(*ir.Node)
 
 			// Optimization: look back 1 block for the definition.
 			if len(b.Preds) == 1 {
@@ -183,7 +184,7 @@ levels:
 	}
 }
 
-func (s *phiState) insertVarPhis(n int, var_ *Node, defs []*ssa.Block, typ *types.Type) {
+func (s *phiState) insertVarPhis(n int, var_ *ir.Node, defs []*ssa.Block, typ *types.Type) {
 	priq := &s.priq
 	q := s.q
 	queued := s.queued
@@ -318,7 +319,7 @@ func (s *phiState) resolveFwdRefs() {
 			if v.Op != ssa.OpFwdRef {
 				continue
 			}
-			n := s.varnum[v.Aux.(*Node)]
+			n := s.varnum[v.Aux.(*ir.Node)]
 			v.Op = ssa.OpCopy
 			v.Aux = nil
 			v.AddArg(values[n])
@@ -432,11 +433,11 @@ func (s *sparseSet) clear() {
 
 // Variant to use for small functions.
 type simplePhiState struct {
-	s         *state                 // SSA state
-	f         *ssa.Func              // function to work on
-	fwdrefs   []*ssa.Value           // list of FwdRefs to be processed
-	defvars   []map[*Node]*ssa.Value // defined variables at end of each block
-	reachable []bool                 // which blocks are reachable
+	s         *state                    // SSA state
+	f         *ssa.Func                 // function to work on
+	fwdrefs   []*ssa.Value              // list of FwdRefs to be processed
+	defvars   []map[*ir.Node]*ssa.Value // defined variables at end of each block
+	reachable []bool                    // which blocks are reachable
 }
 
 func (s *simplePhiState) insertPhis() {
@@ -449,7 +450,7 @@ func (s *simplePhiState) insertPhis() {
 				continue
 			}
 			s.fwdrefs = append(s.fwdrefs, v)
-			var_ := v.Aux.(*Node)
+			var_ := v.Aux.(*ir.Node)
 			if _, ok := s.defvars[b.ID][var_]; !ok {
 				s.defvars[b.ID][var_] = v // treat FwdDefs as definitions.
 			}
@@ -463,7 +464,7 @@ loop:
 		v := s.fwdrefs[len(s.fwdrefs)-1]
 		s.fwdrefs = s.fwdrefs[:len(s.fwdrefs)-1]
 		b := v.Block
-		var_ := v.Aux.(*Node)
+		var_ := v.Aux.(*ir.Node)
 		if b == s.f.Entry {
 			// No variable should be live at entry.
 			s.s.Fatalf("Value live at entry. It shouldn't be. func %s, node %v, value %v", s.f.Name, var_, v)
@@ -511,7 +512,7 @@ loop:
 }
 
 // lookupVarOutgoing finds the variable's value at the end of block b.
-func (s *simplePhiState) lookupVarOutgoing(b *ssa.Block, t *types.Type, var_ *Node, line src.XPos) *ssa.Value {
+func (s *simplePhiState) lookupVarOutgoing(b *ssa.Block, t *types.Type, var_ *ir.Node, line src.XPos) *ssa.Value {
 	for {
 		if v := s.defvars[b.ID][var_]; v != nil {
 			return v
diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/gc/plive.go
index da2298480a..f089588466 100644
--- a/src/cmd/compile/internal/gc/plive.go
+++ b/src/cmd/compile/internal/gc/plive.go
@@ -16,6 +16,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -100,10 +101,10 @@ type BlockEffects struct {
 
 // A collection of global state used by liveness analysis.
 type Liveness struct {
-	fn         *Node
+	fn         *ir.Node
 	f          *ssa.Func
-	vars       []*Node
-	idx        map[*Node]int32
+	vars       []*ir.Node
+	idx        map[*ir.Node]int32
 	stkptrsize int64
 
 	be []BlockEffects
@@ -205,20 +206,20 @@ type progeffectscache struct {
 // nor do we care about non-local variables,
 // nor do we care about empty structs (handled by the pointer check),
 // nor do we care about the fake PAUTOHEAP variables.
-func livenessShouldTrack(n *Node) bool {
-	return n.Op == ONAME && (n.Class() == PAUTO || n.Class() == PPARAM || n.Class() == PPARAMOUT) && n.Type.HasPointers()
+func livenessShouldTrack(n *ir.Node) bool {
+	return n.Op == ir.ONAME && (n.Class() == ir.PAUTO || n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT) && n.Type.HasPointers()
 }
 
 // getvariables returns the list of on-stack variables that we need to track
 // and a map for looking up indices by *Node.
-func getvariables(fn *Node) ([]*Node, map[*Node]int32) {
-	var vars []*Node
+func getvariables(fn *ir.Node) ([]*ir.Node, map[*ir.Node]int32) {
+	var vars []*ir.Node
 	for _, n := range fn.Func.Dcl {
 		if livenessShouldTrack(n) {
 			vars = append(vars, n)
 		}
 	}
-	idx := make(map[*Node]int32, len(vars))
+	idx := make(map[*ir.Node]int32, len(vars))
 	for i, n := range vars {
 		idx[n] = int32(i)
 	}
@@ -234,7 +235,7 @@ func (lv *Liveness) initcache() {
 
 	for i, node := range lv.vars {
 		switch node.Class() {
-		case PPARAM:
+		case ir.PPARAM:
 			// A return instruction with a p.to is a tail return, which brings
 			// the stack pointer back up (if it ever went down) and then jumps
 			// to a new function entirely. That form of instruction must read
@@ -243,7 +244,7 @@ func (lv *Liveness) initcache() {
 			// function runs.
 			lv.cache.tailuevar = append(lv.cache.tailuevar, int32(i))
 
-		case PPARAMOUT:
+		case ir.PPARAMOUT:
 			// All results are live at every return point.
 			// Note that this point is after escaping return values
 			// are copied back to the stack using their PAUTOHEAP references.
@@ -271,7 +272,7 @@ const (
 // If v does not affect any tracked variables, it returns -1, 0.
 func (lv *Liveness) valueEffects(v *ssa.Value) (int32, liveEffect) {
 	n, e := affectedNode(v)
-	if e == 0 || n == nil || n.Op != ONAME { // cheapest checks first
+	if e == 0 || n == nil || n.Op != ir.ONAME { // cheapest checks first
 		return -1, 0
 	}
 
@@ -311,7 +312,7 @@ func (lv *Liveness) valueEffects(v *ssa.Value) (int32, liveEffect) {
 }
 
 // affectedNode returns the *Node affected by v
-func affectedNode(v *ssa.Value) (*Node, ssa.SymEffect) {
+func affectedNode(v *ssa.Value) (*ir.Node, ssa.SymEffect) {
 	// Special cases.
 	switch v.Op {
 	case ssa.OpLoadReg:
@@ -322,9 +323,9 @@ func affectedNode(v *ssa.Value) (*Node, ssa.SymEffect) {
 		return n, ssa.SymWrite
 
 	case ssa.OpVarLive:
-		return v.Aux.(*Node), ssa.SymRead
+		return v.Aux.(*ir.Node), ssa.SymRead
 	case ssa.OpVarDef, ssa.OpVarKill:
-		return v.Aux.(*Node), ssa.SymWrite
+		return v.Aux.(*ir.Node), ssa.SymWrite
 	case ssa.OpKeepAlive:
 		n, _ := AutoVar(v.Args[0])
 		return n, ssa.SymRead
@@ -339,7 +340,7 @@ func affectedNode(v *ssa.Value) (*Node, ssa.SymEffect) {
 	case nil, *obj.LSym:
 		// ok, but no node
 		return nil, e
-	case *Node:
+	case *ir.Node:
 		return a, e
 	default:
 		base.Fatalf("weird aux: %s", v.LongString())
@@ -355,7 +356,7 @@ type livenessFuncCache struct {
 // Constructs a new liveness structure used to hold the global state of the
 // liveness computation. The cfg argument is a slice of *BasicBlocks and the
 // vars argument is a slice of *Nodes.
-func newliveness(fn *Node, f *ssa.Func, vars []*Node, idx map[*Node]int32, stkptrsize int64) *Liveness {
+func newliveness(fn *ir.Node, f *ssa.Func, vars []*ir.Node, idx map[*ir.Node]int32, stkptrsize int64) *Liveness {
 	lv := &Liveness{
 		fn:         fn,
 		f:          f,
@@ -416,20 +417,20 @@ func onebitwalktype1(t *types.Type, off int64, bv bvec) {
 	}
 
 	switch t.Etype {
-	case TPTR, TUNSAFEPTR, TFUNC, TCHAN, TMAP:
+	case types.TPTR, types.TUNSAFEPTR, types.TFUNC, types.TCHAN, types.TMAP:
 		if off&int64(Widthptr-1) != 0 {
 			base.Fatalf("onebitwalktype1: invalid alignment, %v", t)
 		}
 		bv.Set(int32(off / int64(Widthptr))) // pointer
 
-	case TSTRING:
+	case types.TSTRING:
 		// struct { byte *str; intgo len; }
 		if off&int64(Widthptr-1) != 0 {
 			base.Fatalf("onebitwalktype1: invalid alignment, %v", t)
 		}
 		bv.Set(int32(off / int64(Widthptr))) //pointer in first slot
 
-	case TINTER:
+	case types.TINTER:
 		// struct { Itab *tab;	void *data; }
 		// or, when isnilinter(t)==true:
 		// struct { Type *type; void *data; }
@@ -450,14 +451,14 @@ func onebitwalktype1(t *types.Type, off int64, bv bvec) {
 		// well as scan itabs to update their itab._type fields).
 		bv.Set(int32(off/int64(Widthptr) + 1)) // pointer in second slot
 
-	case TSLICE:
+	case types.TSLICE:
 		// struct { byte *array; uintgo len; uintgo cap; }
 		if off&int64(Widthptr-1) != 0 {
 			base.Fatalf("onebitwalktype1: invalid TARRAY alignment, %v", t)
 		}
 		bv.Set(int32(off / int64(Widthptr))) // pointer in first slot (BitsPointer)
 
-	case TARRAY:
+	case types.TARRAY:
 		elt := t.Elem()
 		if elt.Width == 0 {
 			// Short-circuit for #20739.
@@ -468,7 +469,7 @@ func onebitwalktype1(t *types.Type, off int64, bv bvec) {
 			off += elt.Width
 		}
 
-	case TSTRUCT:
+	case types.TSTRUCT:
 		for _, f := range t.Fields().Slice() {
 			onebitwalktype1(f.Type, off+f.Offset, bv)
 		}
@@ -481,7 +482,7 @@ func onebitwalktype1(t *types.Type, off int64, bv bvec) {
 // Generates live pointer value maps for arguments and local variables. The
 // this argument and the in arguments are always assumed live. The vars
 // argument is a slice of *Nodes.
-func (lv *Liveness) pointerMap(liveout bvec, vars []*Node, args, locals bvec) {
+func (lv *Liveness) pointerMap(liveout bvec, vars []*ir.Node, args, locals bvec) {
 	for i := int32(0); ; i++ {
 		i = liveout.Next(i)
 		if i < 0 {
@@ -489,10 +490,10 @@ func (lv *Liveness) pointerMap(liveout bvec, vars []*Node, args, locals bvec) {
 		}
 		node := vars[i]
 		switch node.Class() {
-		case PAUTO:
+		case ir.PAUTO:
 			onebitwalktype1(node.Type, node.Xoffset+lv.stkptrsize, locals)
 
-		case PPARAM, PPARAMOUT:
+		case ir.PPARAM, ir.PPARAMOUT:
 			onebitwalktype1(node.Type, node.Xoffset, args)
 		}
 	}
@@ -789,7 +790,7 @@ func (lv *Liveness) epilogue() {
 	// don't need to keep the stack copy live?
 	if lv.fn.Func.HasDefer() {
 		for i, n := range lv.vars {
-			if n.Class() == PPARAMOUT {
+			if n.Class() == ir.PPARAMOUT {
 				if n.Name.IsOutputParamHeapAddr() {
 					// Just to be paranoid.  Heap addresses are PAUTOs.
 					base.Fatalf("variable %v both output param and heap output param", n)
@@ -887,7 +888,7 @@ func (lv *Liveness) epilogue() {
 				if !liveout.Get(int32(i)) {
 					continue
 				}
-				if n.Class() == PPARAM {
+				if n.Class() == ir.PPARAM {
 					continue // ok
 				}
 				base.Fatalf("bad live variable at entry of %v: %L", lv.fn.Func.Nname, n)
@@ -920,7 +921,7 @@ func (lv *Liveness) epilogue() {
 	// the only things that can possibly be live are the
 	// input parameters.
 	for j, n := range lv.vars {
-		if n.Class() != PPARAM && lv.stackMaps[0].Get(int32(j)) {
+		if n.Class() != ir.PPARAM && lv.stackMaps[0].Get(int32(j)) {
 			lv.f.Fatalf("%v %L recorded as live on entry", lv.fn.Func.Nname, n)
 		}
 	}
@@ -967,7 +968,7 @@ func (lv *Liveness) compact(b *ssa.Block) {
 }
 
 func (lv *Liveness) showlive(v *ssa.Value, live bvec) {
-	if base.Flag.Live == 0 || lv.fn.funcname() == "init" || strings.HasPrefix(lv.fn.funcname(), ".") {
+	if base.Flag.Live == 0 || ir.FuncName(lv.fn) == "init" || strings.HasPrefix(ir.FuncName(lv.fn), ".") {
 		return
 	}
 	if !(v == nil || v.Op.IsCall()) {
@@ -986,7 +987,7 @@ func (lv *Liveness) showlive(v *ssa.Value, live bvec) {
 
 	s := "live at "
 	if v == nil {
-		s += fmt.Sprintf("entry to %s:", lv.fn.funcname())
+		s += fmt.Sprintf("entry to %s:", ir.FuncName(lv.fn))
 	} else if sym, ok := v.Aux.(*ssa.AuxCall); ok && sym.Fn != nil {
 		fn := sym.Fn.Name
 		if pos := strings.Index(fn, "."); pos >= 0 {
@@ -1051,7 +1052,7 @@ func (lv *Liveness) printeffect(printed bool, name string, pos int32, x bool) bo
 // This format synthesizes the information used during the multiple passes
 // into a single presentation.
 func (lv *Liveness) printDebug() {
-	fmt.Printf("liveness: %s\n", lv.fn.funcname())
+	fmt.Printf("liveness: %s\n", ir.FuncName(lv.fn))
 
 	for i, b := range lv.f.Blocks {
 		if i > 0 {
@@ -1163,10 +1164,10 @@ func (lv *Liveness) emit() (argsSym, liveSym *obj.LSym) {
 	// Size args bitmaps to be just large enough to hold the largest pointer.
 	// First, find the largest Xoffset node we care about.
 	// (Nodes without pointers aren't in lv.vars; see livenessShouldTrack.)
-	var maxArgNode *Node
+	var maxArgNode *ir.Node
 	for _, n := range lv.vars {
 		switch n.Class() {
-		case PPARAM, PPARAMOUT:
+		case ir.PPARAM, ir.PPARAMOUT:
 			if maxArgNode == nil || n.Xoffset > maxArgNode.Xoffset {
 				maxArgNode = n
 			}
@@ -1265,7 +1266,7 @@ func liveness(e *ssafn, f *ssa.Func, pp *Progs) LivenessMap {
 	}
 
 	// Emit the live pointer map data structures
-	ls := e.curfn.Func.lsym
+	ls := e.curfn.Func.LSym
 	fninfo := ls.Func()
 	fninfo.GCArgs, fninfo.GCLocals = lv.emit()
 
@@ -1300,16 +1301,16 @@ func liveness(e *ssafn, f *ssa.Func, pp *Progs) LivenessMap {
 func isfat(t *types.Type) bool {
 	if t != nil {
 		switch t.Etype {
-		case TSLICE, TSTRING,
-			TINTER: // maybe remove later
+		case types.TSLICE, types.TSTRING,
+			types.TINTER: // maybe remove later
 			return true
-		case TARRAY:
+		case types.TARRAY:
 			// Array of 1 element, check if element is fat
 			if t.NumElem() == 1 {
 				return isfat(t.Elem())
 			}
 			return true
-		case TSTRUCT:
+		case types.TSTRUCT:
 			// Struct with 1 field, check if field is fat
 			if t.NumFields() == 1 {
 				return isfat(t.Field(0).Type)
diff --git a/src/cmd/compile/internal/gc/racewalk.go b/src/cmd/compile/internal/gc/racewalk.go
index 20b4bc583b..d92749589f 100644
--- a/src/cmd/compile/internal/gc/racewalk.go
+++ b/src/cmd/compile/internal/gc/racewalk.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"cmd/internal/sys"
@@ -59,8 +60,8 @@ func ispkgin(pkgs []string) bool {
 	return false
 }
 
-func instrument(fn *Node) {
-	if fn.Func.Pragma&Norace != 0 {
+func instrument(fn *ir.Node) {
+	if fn.Func.Pragma&ir.Norace != 0 {
 		return
 	}
 
@@ -82,8 +83,8 @@ func instrument(fn *Node) {
 			// This only works for amd64. This will not
 			// work on arm or others that might support
 			// race in the future.
-			nodpc := nodfp.copy()
-			nodpc.Type = types.Types[TUINTPTR]
+			nodpc := ir.Copy(nodfp)
+			nodpc.Type = types.Types[types.TUINTPTR]
 			nodpc.Xoffset = int64(-Widthptr)
 			fn.Func.Dcl = append(fn.Func.Dcl, nodpc)
 			fn.Func.Enter.Prepend(mkcall("racefuncenter", nil, nil, nodpc))
diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index 568c5138ec..edaec21f92 100644
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -6,13 +6,14 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/sys"
 	"unicode/utf8"
 )
 
 // range
-func typecheckrange(n *Node) {
+func typecheckrange(n *ir.Node) {
 	// Typechecking order is important here:
 	// 0. first typecheck range expression (slice/map/chan),
 	//	it is evaluated only once and so logically it is not part of the loop.
@@ -38,7 +39,7 @@ func typecheckrange(n *Node) {
 	decldepth--
 }
 
-func typecheckrangeExpr(n *Node) {
+func typecheckrangeExpr(n *ir.Node) {
 	n.Right = typecheck(n.Right, ctxExpr)
 
 	t := n.Right.Type
@@ -65,15 +66,15 @@ func typecheckrangeExpr(n *Node) {
 		base.ErrorfAt(n.Pos, "cannot range over %L", n.Right)
 		return
 
-	case TARRAY, TSLICE:
-		t1 = types.Types[TINT]
+	case types.TARRAY, types.TSLICE:
+		t1 = types.Types[types.TINT]
 		t2 = t.Elem()
 
-	case TMAP:
+	case types.TMAP:
 		t1 = t.Key()
 		t2 = t.Elem()
 
-	case TCHAN:
+	case types.TCHAN:
 		if !t.ChanDir().CanRecv() {
 			base.ErrorfAt(n.Pos, "invalid operation: range %v (receive from send-only type %v)", n.Right, n.Right.Type)
 			return
@@ -85,8 +86,8 @@ func typecheckrangeExpr(n *Node) {
 			toomany = true
 		}
 
-	case TSTRING:
-		t1 = types.Types[TINT]
+	case types.TSTRING:
+		t1 = types.Types[types.TINT]
 		t2 = types.Runetype
 	}
 
@@ -94,7 +95,7 @@ func typecheckrangeExpr(n *Node) {
 		base.ErrorfAt(n.Pos, "too many variables in range")
 	}
 
-	var v1, v2 *Node
+	var v1, v2 *ir.Node
 	if n.List.Len() != 0 {
 		v1 = n.List.First()
 	}
@@ -106,7 +107,7 @@ func typecheckrangeExpr(n *Node) {
 	// "if the second iteration variable is the blank identifier, the range
 	// clause is equivalent to the same clause with only the first variable
 	// present."
-	if v2.isBlank() {
+	if ir.IsBlank(v2) {
 		if v1 != nil {
 			n.List.Set1(v1)
 		}
@@ -117,7 +118,7 @@ func typecheckrangeExpr(n *Node) {
 		if v1.Name != nil && v1.Name.Defn == n {
 			v1.Type = t1
 		} else if v1.Type != nil {
-			if op, why := assignop(t1, v1.Type); op == OXXX {
+			if op, why := assignop(t1, v1.Type); op == ir.OXXX {
 				base.ErrorfAt(n.Pos, "cannot assign type %v to %L in range%s", t1, v1, why)
 			}
 		}
@@ -128,7 +129,7 @@ func typecheckrangeExpr(n *Node) {
 		if v2.Name != nil && v2.Name.Defn == n {
 			v2.Type = t2
 		} else if v2.Type != nil {
-			if op, why := assignop(t2, v2.Type); op == OXXX {
+			if op, why := assignop(t2, v2.Type); op == ir.OXXX {
 				base.ErrorfAt(n.Pos, "cannot assign type %v to %L in range%s", t2, v2, why)
 			}
 		}
@@ -156,7 +157,7 @@ func cheapComputableIndex(width int64) bool {
 // simpler forms.  The result must be assigned back to n.
 // Node n may also be modified in place, and may also be
 // the returned node.
-func walkrange(n *Node) *Node {
+func walkrange(n *ir.Node) *ir.Node {
 	if isMapClear(n) {
 		m := n.Right
 		lno := setlineno(m)
@@ -178,7 +179,7 @@ func walkrange(n *Node) *Node {
 	lno := setlineno(a)
 	n.Right = nil
 
-	var v1, v2 *Node
+	var v1, v2 *ir.Node
 	l := n.List.Len()
 	if l > 0 {
 		v1 = n.List.First()
@@ -188,11 +189,11 @@ func walkrange(n *Node) *Node {
 		v2 = n.List.Second()
 	}
 
-	if v2.isBlank() {
+	if ir.IsBlank(v2) {
 		v2 = nil
 	}
 
-	if v1.isBlank() && v2 == nil {
+	if ir.IsBlank(v1) && v2 == nil {
 		v1 = nil
 	}
 
@@ -204,17 +205,17 @@ func walkrange(n *Node) *Node {
 	// to avoid erroneous processing by racewalk.
 	n.List.Set(nil)
 
-	var ifGuard *Node
+	var ifGuard *ir.Node
 
-	translatedLoopOp := OFOR
+	translatedLoopOp := ir.OFOR
 
-	var body []*Node
-	var init []*Node
+	var body []*ir.Node
+	var init []*ir.Node
 	switch t.Etype {
 	default:
 		base.Fatalf("walkrange")
 
-	case TARRAY, TSLICE:
+	case types.TARRAY, types.TSLICE:
 		if arrayClear(n, v1, v2, a) {
 			base.Pos = lno
 			return n
@@ -223,14 +224,14 @@ func walkrange(n *Node) *Node {
 		// order.stmt arranged for a copy of the array/slice variable if needed.
 		ha := a
 
-		hv1 := temp(types.Types[TINT])
-		hn := temp(types.Types[TINT])
+		hv1 := temp(types.Types[types.TINT])
+		hn := temp(types.Types[types.TINT])
 
-		init = append(init, nod(OAS, hv1, nil))
-		init = append(init, nod(OAS, hn, nod(OLEN, ha, nil)))
+		init = append(init, ir.Nod(ir.OAS, hv1, nil))
+		init = append(init, ir.Nod(ir.OAS, hn, ir.Nod(ir.OLEN, ha, nil)))
 
-		n.Left = nod(OLT, hv1, hn)
-		n.Right = nod(OAS, hv1, nod(OADD, hv1, nodintconst(1)))
+		n.Left = ir.Nod(ir.OLT, hv1, hn)
+		n.Right = ir.Nod(ir.OAS, hv1, ir.Nod(ir.OADD, hv1, nodintconst(1)))
 
 		// for range ha { body }
 		if v1 == nil {
@@ -239,21 +240,21 @@ func walkrange(n *Node) *Node {
 
 		// for v1 := range ha { body }
 		if v2 == nil {
-			body = []*Node{nod(OAS, v1, hv1)}
+			body = []*ir.Node{ir.Nod(ir.OAS, v1, hv1)}
 			break
 		}
 
 		// for v1, v2 := range ha { body }
 		if cheapComputableIndex(n.Type.Elem().Width) {
 			// v1, v2 = hv1, ha[hv1]
-			tmp := nod(OINDEX, ha, hv1)
+			tmp := ir.Nod(ir.OINDEX, ha, hv1)
 			tmp.SetBounded(true)
 			// Use OAS2 to correctly handle assignments
 			// of the form "v1, a[v1] := range".
-			a := nod(OAS2, nil, nil)
+			a := ir.Nod(ir.OAS2, nil, nil)
 			a.List.Set2(v1, v2)
 			a.Rlist.Set2(hv1, tmp)
-			body = []*Node{a}
+			body = []*ir.Node{a}
 			break
 		}
 
@@ -269,20 +270,20 @@ func walkrange(n *Node) *Node {
 		// TODO(austin): OFORUNTIL inhibits bounds-check
 		// elimination on the index variable (see #20711).
 		// Enhance the prove pass to understand this.
-		ifGuard = nod(OIF, nil, nil)
-		ifGuard.Left = nod(OLT, hv1, hn)
-		translatedLoopOp = OFORUNTIL
+		ifGuard = ir.Nod(ir.OIF, nil, nil)
+		ifGuard.Left = ir.Nod(ir.OLT, hv1, hn)
+		translatedLoopOp = ir.OFORUNTIL
 
 		hp := temp(types.NewPtr(n.Type.Elem()))
-		tmp := nod(OINDEX, ha, nodintconst(0))
+		tmp := ir.Nod(ir.OINDEX, ha, nodintconst(0))
 		tmp.SetBounded(true)
-		init = append(init, nod(OAS, hp, nod(OADDR, tmp, nil)))
+		init = append(init, ir.Nod(ir.OAS, hp, ir.Nod(ir.OADDR, tmp, nil)))
 
 		// Use OAS2 to correctly handle assignments
 		// of the form "v1, a[v1] := range".
-		a := nod(OAS2, nil, nil)
+		a := ir.Nod(ir.OAS2, nil, nil)
 		a.List.Set2(v1, v2)
-		a.Rlist.Set2(hv1, nod(ODEREF, hp, nil))
+		a.Rlist.Set2(hv1, ir.Nod(ir.ODEREF, hp, nil))
 		body = append(body, a)
 
 		// Advance pointer as part of the late increment.
@@ -290,11 +291,11 @@ func walkrange(n *Node) *Node {
 		// This runs *after* the condition check, so we know
 		// advancing the pointer is safe and won't go past the
 		// end of the allocation.
-		a = nod(OAS, hp, addptr(hp, t.Elem().Width))
+		a = ir.Nod(ir.OAS, hp, addptr(hp, t.Elem().Width))
 		a = typecheck(a, ctxStmt)
 		n.List.Set1(a)
 
-	case TMAP:
+	case types.TMAP:
 		// order.stmt allocated the iterator for us.
 		// we only use a once, so no copy needed.
 		ha := a
@@ -308,29 +309,29 @@ func walkrange(n *Node) *Node {
 		fn := syslook("mapiterinit")
 
 		fn = substArgTypes(fn, t.Key(), t.Elem(), th)
-		init = append(init, mkcall1(fn, nil, nil, typename(t), ha, nod(OADDR, hit, nil)))
-		n.Left = nod(ONE, nodSym(ODOT, hit, keysym), nodnil())
+		init = append(init, mkcall1(fn, nil, nil, typename(t), ha, ir.Nod(ir.OADDR, hit, nil)))
+		n.Left = ir.Nod(ir.ONE, nodSym(ir.ODOT, hit, keysym), nodnil())
 
 		fn = syslook("mapiternext")
 		fn = substArgTypes(fn, th)
-		n.Right = mkcall1(fn, nil, nil, nod(OADDR, hit, nil))
+		n.Right = mkcall1(fn, nil, nil, ir.Nod(ir.OADDR, hit, nil))
 
-		key := nodSym(ODOT, hit, keysym)
-		key = nod(ODEREF, key, nil)
+		key := nodSym(ir.ODOT, hit, keysym)
+		key = ir.Nod(ir.ODEREF, key, nil)
 		if v1 == nil {
 			body = nil
 		} else if v2 == nil {
-			body = []*Node{nod(OAS, v1, key)}
+			body = []*ir.Node{ir.Nod(ir.OAS, v1, key)}
 		} else {
-			elem := nodSym(ODOT, hit, elemsym)
-			elem = nod(ODEREF, elem, nil)
-			a := nod(OAS2, nil, nil)
+			elem := nodSym(ir.ODOT, hit, elemsym)
+			elem = ir.Nod(ir.ODEREF, elem, nil)
+			a := ir.Nod(ir.OAS2, nil, nil)
 			a.List.Set2(v1, v2)
 			a.Rlist.Set2(key, elem)
-			body = []*Node{a}
+			body = []*ir.Node{a}
 		}
 
-	case TCHAN:
+	case types.TCHAN:
 		// order.stmt arranged for a copy of the channel variable.
 		ha := a
 
@@ -339,27 +340,27 @@ func walkrange(n *Node) *Node {
 		hv1 := temp(t.Elem())
 		hv1.SetTypecheck(1)
 		if t.Elem().HasPointers() {
-			init = append(init, nod(OAS, hv1, nil))
+			init = append(init, ir.Nod(ir.OAS, hv1, nil))
 		}
-		hb := temp(types.Types[TBOOL])
+		hb := temp(types.Types[types.TBOOL])
 
-		n.Left = nod(ONE, hb, nodbool(false))
-		a := nod(OAS2RECV, nil, nil)
+		n.Left = ir.Nod(ir.ONE, hb, nodbool(false))
+		a := ir.Nod(ir.OAS2RECV, nil, nil)
 		a.SetTypecheck(1)
 		a.List.Set2(hv1, hb)
-		a.Right = nod(ORECV, ha, nil)
+		a.Right = ir.Nod(ir.ORECV, ha, nil)
 		n.Left.Ninit.Set1(a)
 		if v1 == nil {
 			body = nil
 		} else {
-			body = []*Node{nod(OAS, v1, hv1)}
+			body = []*ir.Node{ir.Nod(ir.OAS, v1, hv1)}
 		}
 		// Zero hv1. This prevents hv1 from being the sole, inaccessible
 		// reference to an otherwise GC-able value during the next channel receive.
 		// See issue 15281.
-		body = append(body, nod(OAS, hv1, nil))
+		body = append(body, ir.Nod(ir.OAS, hv1, nil))
 
-	case TSTRING:
+	case types.TSTRING:
 		// Transform string range statements like "for v1, v2 = range a" into
 		//
 		// ha := a
@@ -378,35 +379,35 @@ func walkrange(n *Node) *Node {
 		// order.stmt arranged for a copy of the string variable.
 		ha := a
 
-		hv1 := temp(types.Types[TINT])
-		hv1t := temp(types.Types[TINT])
+		hv1 := temp(types.Types[types.TINT])
+		hv1t := temp(types.Types[types.TINT])
 		hv2 := temp(types.Runetype)
 
 		// hv1 := 0
-		init = append(init, nod(OAS, hv1, nil))
+		init = append(init, ir.Nod(ir.OAS, hv1, nil))
 
 		// hv1 < len(ha)
-		n.Left = nod(OLT, hv1, nod(OLEN, ha, nil))
+		n.Left = ir.Nod(ir.OLT, hv1, ir.Nod(ir.OLEN, ha, nil))
 
 		if v1 != nil {
 			// hv1t = hv1
-			body = append(body, nod(OAS, hv1t, hv1))
+			body = append(body, ir.Nod(ir.OAS, hv1t, hv1))
 		}
 
 		// hv2 := rune(ha[hv1])
-		nind := nod(OINDEX, ha, hv1)
+		nind := ir.Nod(ir.OINDEX, ha, hv1)
 		nind.SetBounded(true)
-		body = append(body, nod(OAS, hv2, conv(nind, types.Runetype)))
+		body = append(body, ir.Nod(ir.OAS, hv2, conv(nind, types.Runetype)))
 
 		// if hv2 < utf8.RuneSelf
-		nif := nod(OIF, nil, nil)
-		nif.Left = nod(OLT, hv2, nodintconst(utf8.RuneSelf))
+		nif := ir.Nod(ir.OIF, nil, nil)
+		nif.Left = ir.Nod(ir.OLT, hv2, nodintconst(utf8.RuneSelf))
 
 		// hv1++
-		nif.Nbody.Set1(nod(OAS, hv1, nod(OADD, hv1, nodintconst(1))))
+		nif.Nbody.Set1(ir.Nod(ir.OAS, hv1, ir.Nod(ir.OADD, hv1, nodintconst(1))))
 
 		// } else {
-		eif := nod(OAS2, nil, nil)
+		eif := ir.Nod(ir.OAS2, nil, nil)
 		nif.Rlist.Set1(eif)
 
 		// hv2, hv1 = decoderune(ha, hv1)
@@ -419,13 +420,13 @@ func walkrange(n *Node) *Node {
 		if v1 != nil {
 			if v2 != nil {
 				// v1, v2 = hv1t, hv2
-				a := nod(OAS2, nil, nil)
+				a := ir.Nod(ir.OAS2, nil, nil)
 				a.List.Set2(v1, v2)
 				a.Rlist.Set2(hv1t, hv2)
 				body = append(body, a)
 			} else {
 				// v1 = hv1t
-				body = append(body, nod(OAS, v1, hv1t))
+				body = append(body, ir.Nod(ir.OAS, v1, hv1t))
 			}
 		}
 	}
@@ -466,17 +467,17 @@ func walkrange(n *Node) *Node {
 // }
 //
 // where == for keys of map m is reflexive.
-func isMapClear(n *Node) bool {
+func isMapClear(n *ir.Node) bool {
 	if base.Flag.N != 0 || instrumenting {
 		return false
 	}
 
-	if n.Op != ORANGE || n.Type.Etype != TMAP || n.List.Len() != 1 {
+	if n.Op != ir.ORANGE || n.Type.Etype != types.TMAP || n.List.Len() != 1 {
 		return false
 	}
 
 	k := n.List.First()
-	if k == nil || k.isBlank() {
+	if k == nil || ir.IsBlank(k) {
 		return false
 	}
 
@@ -490,7 +491,7 @@ func isMapClear(n *Node) bool {
 	}
 
 	stmt := n.Nbody.First() // only stmt in body
-	if stmt == nil || stmt.Op != ODELETE {
+	if stmt == nil || stmt.Op != ir.ODELETE {
 		return false
 	}
 
@@ -508,7 +509,7 @@ func isMapClear(n *Node) bool {
 }
 
 // mapClear constructs a call to runtime.mapclear for the map m.
-func mapClear(m *Node) *Node {
+func mapClear(m *ir.Node) *ir.Node {
 	t := m.Type
 
 	// instantiate mapclear(typ *type, hmap map[any]any)
@@ -533,7 +534,7 @@ func mapClear(m *Node) *Node {
 // in which the evaluation of a is side-effect-free.
 //
 // Parameters are as in walkrange: "for v1, v2 = range a".
-func arrayClear(n, v1, v2, a *Node) bool {
+func arrayClear(n, v1, v2, a *ir.Node) bool {
 	if base.Flag.N != 0 || instrumenting {
 		return false
 	}
@@ -547,7 +548,7 @@ func arrayClear(n, v1, v2, a *Node) bool {
 	}
 
 	stmt := n.Nbody.First() // only stmt in body
-	if stmt.Op != OAS || stmt.Left.Op != OINDEX {
+	if stmt.Op != ir.OAS || stmt.Left.Op != ir.OINDEX {
 		return false
 	}
 
@@ -567,32 +568,32 @@ func arrayClear(n, v1, v2, a *Node) bool {
 	// 	memclr{NoHeap,Has}Pointers(hp, hn)
 	// 	i = len(a) - 1
 	// }
-	n.Op = OIF
+	n.Op = ir.OIF
 
 	n.Nbody.Set(nil)
-	n.Left = nod(ONE, nod(OLEN, a, nil), nodintconst(0))
+	n.Left = ir.Nod(ir.ONE, ir.Nod(ir.OLEN, a, nil), nodintconst(0))
 
 	// hp = &a[0]
-	hp := temp(types.Types[TUNSAFEPTR])
+	hp := temp(types.Types[types.TUNSAFEPTR])
 
-	tmp := nod(OINDEX, a, nodintconst(0))
+	tmp := ir.Nod(ir.OINDEX, a, nodintconst(0))
 	tmp.SetBounded(true)
-	tmp = nod(OADDR, tmp, nil)
-	tmp = convnop(tmp, types.Types[TUNSAFEPTR])
-	n.Nbody.Append(nod(OAS, hp, tmp))
+	tmp = ir.Nod(ir.OADDR, tmp, nil)
+	tmp = convnop(tmp, types.Types[types.TUNSAFEPTR])
+	n.Nbody.Append(ir.Nod(ir.OAS, hp, tmp))
 
 	// hn = len(a) * sizeof(elem(a))
-	hn := temp(types.Types[TUINTPTR])
+	hn := temp(types.Types[types.TUINTPTR])
 
-	tmp = nod(OLEN, a, nil)
-	tmp = nod(OMUL, tmp, nodintconst(elemsize))
-	tmp = conv(tmp, types.Types[TUINTPTR])
-	n.Nbody.Append(nod(OAS, hn, tmp))
+	tmp = ir.Nod(ir.OLEN, a, nil)
+	tmp = ir.Nod(ir.OMUL, tmp, nodintconst(elemsize))
+	tmp = conv(tmp, types.Types[types.TUINTPTR])
+	n.Nbody.Append(ir.Nod(ir.OAS, hn, tmp))
 
-	var fn *Node
+	var fn *ir.Node
 	if a.Type.Elem().HasPointers() {
 		// memclrHasPointers(hp, hn)
-		Curfn.Func.setWBPos(stmt.Pos)
+		Curfn.Func.SetWBPos(stmt.Pos)
 		fn = mkcall("memclrHasPointers", nil, nil, hp, hn)
 	} else {
 		// memclrNoHeapPointers(hp, hn)
@@ -602,7 +603,7 @@ func arrayClear(n, v1, v2, a *Node) bool {
 	n.Nbody.Append(fn)
 
 	// i = len(a) - 1
-	v1 = nod(OAS, v1, nod(OSUB, nod(OLEN, a, nil), nodintconst(1)))
+	v1 = ir.Nod(ir.OAS, v1, ir.Nod(ir.OSUB, ir.Nod(ir.OLEN, a, nil), nodintconst(1)))
 
 	n.Nbody.Append(v1)
 
@@ -614,15 +615,15 @@ func arrayClear(n, v1, v2, a *Node) bool {
 }
 
 // addptr returns (*T)(uintptr(p) + n).
-func addptr(p *Node, n int64) *Node {
+func addptr(p *ir.Node, n int64) *ir.Node {
 	t := p.Type
 
-	p = nod(OCONVNOP, p, nil)
-	p.Type = types.Types[TUINTPTR]
+	p = ir.Nod(ir.OCONVNOP, p, nil)
+	p.Type = types.Types[types.TUINTPTR]
 
-	p = nod(OADD, p, nodintconst(n))
+	p = ir.Nod(ir.OADD, p, nodintconst(n))
 
-	p = nod(OCONVNOP, p, nil)
+	p = ir.Nod(ir.OCONVNOP, p, nil)
 	p.Type = t
 
 	return p
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 456903e7d7..34047bfefa 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/gcprog"
 	"cmd/internal/obj"
@@ -84,7 +85,7 @@ func bmap(t *types.Type) *types.Type {
 		return t.MapType().Bucket
 	}
 
-	bucket := types.New(TSTRUCT)
+	bucket := types.New(types.TSTRUCT)
 	keytype := t.Key()
 	elemtype := t.Elem()
 	dowidth(keytype)
@@ -99,7 +100,7 @@ func bmap(t *types.Type) *types.Type {
 	field := make([]*types.Field, 0, 5)
 
 	// The first field is: uint8 topbits[BUCKETSIZE].
-	arr := types.NewArray(types.Types[TUINT8], BUCKETSIZE)
+	arr := types.NewArray(types.Types[types.TUINT8], BUCKETSIZE)
 	field = append(field, makefield("topbits", arr))
 
 	arr = types.NewArray(keytype, BUCKETSIZE)
@@ -120,7 +121,7 @@ func bmap(t *types.Type) *types.Type {
 	// See comment on hmap.overflow in runtime/map.go.
 	otyp := types.NewPtr(bucket)
 	if !elemtype.HasPointers() && !keytype.HasPointers() {
-		otyp = types.Types[TUINTPTR]
+		otyp = types.Types[types.TUINTPTR]
 	}
 	overflow := makefield("overflow", otyp)
 	field = append(field, overflow)
@@ -209,18 +210,18 @@ func hmap(t *types.Type) *types.Type {
 	// }
 	// must match runtime/map.go:hmap.
 	fields := []*types.Field{
-		makefield("count", types.Types[TINT]),
-		makefield("flags", types.Types[TUINT8]),
-		makefield("B", types.Types[TUINT8]),
-		makefield("noverflow", types.Types[TUINT16]),
-		makefield("hash0", types.Types[TUINT32]), // Used in walk.go for OMAKEMAP.
-		makefield("buckets", types.NewPtr(bmap)), // Used in walk.go for OMAKEMAP.
+		makefield("count", types.Types[types.TINT]),
+		makefield("flags", types.Types[types.TUINT8]),
+		makefield("B", types.Types[types.TUINT8]),
+		makefield("noverflow", types.Types[types.TUINT16]),
+		makefield("hash0", types.Types[types.TUINT32]), // Used in walk.go for OMAKEMAP.
+		makefield("buckets", types.NewPtr(bmap)),       // Used in walk.go for OMAKEMAP.
 		makefield("oldbuckets", types.NewPtr(bmap)),
-		makefield("nevacuate", types.Types[TUINTPTR]),
-		makefield("extra", types.Types[TUNSAFEPTR]),
+		makefield("nevacuate", types.Types[types.TUINTPTR]),
+		makefield("extra", types.Types[types.TUNSAFEPTR]),
 	}
 
-	hmap := types.New(TSTRUCT)
+	hmap := types.New(types.TSTRUCT)
 	hmap.SetNoalg(true)
 	hmap.SetFields(fields)
 	dowidth(hmap)
@@ -268,23 +269,23 @@ func hiter(t *types.Type) *types.Type {
 	fields := []*types.Field{
 		makefield("key", types.NewPtr(t.Key())),   // Used in range.go for TMAP.
 		makefield("elem", types.NewPtr(t.Elem())), // Used in range.go for TMAP.
-		makefield("t", types.Types[TUNSAFEPTR]),
+		makefield("t", types.Types[types.TUNSAFEPTR]),
 		makefield("h", types.NewPtr(hmap)),
 		makefield("buckets", types.NewPtr(bmap)),
 		makefield("bptr", types.NewPtr(bmap)),
-		makefield("overflow", types.Types[TUNSAFEPTR]),
-		makefield("oldoverflow", types.Types[TUNSAFEPTR]),
-		makefield("startBucket", types.Types[TUINTPTR]),
-		makefield("offset", types.Types[TUINT8]),
-		makefield("wrapped", types.Types[TBOOL]),
-		makefield("B", types.Types[TUINT8]),
-		makefield("i", types.Types[TUINT8]),
-		makefield("bucket", types.Types[TUINTPTR]),
-		makefield("checkBucket", types.Types[TUINTPTR]),
+		makefield("overflow", types.Types[types.TUNSAFEPTR]),
+		makefield("oldoverflow", types.Types[types.TUNSAFEPTR]),
+		makefield("startBucket", types.Types[types.TUINTPTR]),
+		makefield("offset", types.Types[types.TUINT8]),
+		makefield("wrapped", types.Types[types.TBOOL]),
+		makefield("B", types.Types[types.TUINT8]),
+		makefield("i", types.Types[types.TUINT8]),
+		makefield("bucket", types.Types[types.TUINTPTR]),
+		makefield("checkBucket", types.Types[types.TUINTPTR]),
 	}
 
 	// build iterator struct holding the above fields
-	hiter := types.New(TSTRUCT)
+	hiter := types.New(types.TSTRUCT)
 	hiter.SetNoalg(true)
 	hiter.SetFields(fields)
 	dowidth(hiter)
@@ -303,35 +304,35 @@ func deferstruct(stksize int64) *types.Type {
 		// Unlike the global makefield function, this one needs to set Pkg
 		// because these types might be compared (in SSA CSE sorting).
 		// TODO: unify this makefield and the global one above.
-		sym := &types.Sym{Name: name, Pkg: localpkg}
+		sym := &types.Sym{Name: name, Pkg: ir.LocalPkg}
 		return types.NewField(src.NoXPos, sym, typ)
 	}
-	argtype := types.NewArray(types.Types[TUINT8], stksize)
+	argtype := types.NewArray(types.Types[types.TUINT8], stksize)
 	argtype.Width = stksize
 	argtype.Align = 1
 	// These fields must match the ones in runtime/runtime2.go:_defer and
 	// cmd/compile/internal/gc/ssa.go:(*state).call.
 	fields := []*types.Field{
-		makefield("siz", types.Types[TUINT32]),
-		makefield("started", types.Types[TBOOL]),
-		makefield("heap", types.Types[TBOOL]),
-		makefield("openDefer", types.Types[TBOOL]),
-		makefield("sp", types.Types[TUINTPTR]),
-		makefield("pc", types.Types[TUINTPTR]),
+		makefield("siz", types.Types[types.TUINT32]),
+		makefield("started", types.Types[types.TBOOL]),
+		makefield("heap", types.Types[types.TBOOL]),
+		makefield("openDefer", types.Types[types.TBOOL]),
+		makefield("sp", types.Types[types.TUINTPTR]),
+		makefield("pc", types.Types[types.TUINTPTR]),
 		// Note: the types here don't really matter. Defer structures
 		// are always scanned explicitly during stack copying and GC,
 		// so we make them uintptr type even though they are real pointers.
-		makefield("fn", types.Types[TUINTPTR]),
-		makefield("_panic", types.Types[TUINTPTR]),
-		makefield("link", types.Types[TUINTPTR]),
-		makefield("framepc", types.Types[TUINTPTR]),
-		makefield("varp", types.Types[TUINTPTR]),
-		makefield("fd", types.Types[TUINTPTR]),
+		makefield("fn", types.Types[types.TUINTPTR]),
+		makefield("_panic", types.Types[types.TUINTPTR]),
+		makefield("link", types.Types[types.TUINTPTR]),
+		makefield("framepc", types.Types[types.TUINTPTR]),
+		makefield("varp", types.Types[types.TUINTPTR]),
+		makefield("fd", types.Types[types.TUINTPTR]),
 		makefield("args", argtype),
 	}
 
 	// build struct holding the above fields
-	s := types.New(TSTRUCT)
+	s := types.New(types.TSTRUCT)
 	s.SetNoalg(true)
 	s.SetFields(fields)
 	s.Width = widstruct(s, s, 0, 1)
@@ -346,7 +347,7 @@ func methodfunc(f *types.Type, receiver *types.Type) *types.Type {
 	if receiver != nil {
 		inLen++
 	}
-	in := make([]*Node, 0, inLen)
+	in := make([]*ir.Node, 0, inLen)
 
 	if receiver != nil {
 		d := anonfield(receiver)
@@ -360,7 +361,7 @@ func methodfunc(f *types.Type, receiver *types.Type) *types.Type {
 	}
 
 	outLen := f.Results().Fields().Len()
-	out := make([]*Node, 0, outLen)
+	out := make([]*ir.Node, 0, outLen)
 	for _, t := range f.Results().Fields().Slice() {
 		d := anonfield(t.Type)
 		out = append(out, d)
@@ -447,7 +448,7 @@ func methods(t *types.Type) []*Sig {
 func imethods(t *types.Type) []*Sig {
 	var methods []*Sig
 	for _, f := range t.Fields().Slice() {
-		if f.Type.Etype != TFUNC || f.Sym == nil {
+		if f.Type.Etype != types.TFUNC || f.Sym == nil {
 			continue
 		}
 		if f.Sym.IsBlank() {
@@ -494,7 +495,7 @@ func dimportpath(p *types.Pkg) {
 	}
 
 	str := p.Path
-	if p == localpkg {
+	if p == ir.LocalPkg {
 		// Note: myimportpath != "", or else dgopkgpath won't call dimportpath.
 		str = base.Ctxt.Pkgpath
 	}
@@ -511,7 +512,7 @@ func dgopkgpath(s *obj.LSym, ot int, pkg *types.Pkg) int {
 		return duintptr(s, ot, 0)
 	}
 
-	if pkg == localpkg && base.Ctxt.Pkgpath == "" {
+	if pkg == ir.LocalPkg && base.Ctxt.Pkgpath == "" {
 		// If we don't know the full import path of the package being compiled
 		// (i.e. -p was not passed on the compiler command line), emit a reference to
 		// type..importpath.""., which the linker will rewrite using the correct import path.
@@ -530,7 +531,7 @@ func dgopkgpathOff(s *obj.LSym, ot int, pkg *types.Pkg) int {
 	if pkg == nil {
 		return duint32(s, ot, 0)
 	}
-	if pkg == localpkg && base.Ctxt.Pkgpath == "" {
+	if pkg == ir.LocalPkg && base.Ctxt.Pkgpath == "" {
 		// If we don't know the full import path of the package being compiled
 		// (i.e. -p was not passed on the compiler command line), emit a reference to
 		// type..importpath.""., which the linker will rewrite using the correct import path.
@@ -674,7 +675,7 @@ func typePkg(t *types.Type) *types.Pkg {
 	tsym := t.Sym
 	if tsym == nil {
 		switch t.Etype {
-		case TARRAY, TSLICE, TPTR, TCHAN:
+		case types.TARRAY, types.TSLICE, types.TPTR, types.TCHAN:
 			if t.Elem() != nil {
 				tsym = t.Elem().Sym
 			}
@@ -717,32 +718,32 @@ func dmethodptrOff(s *obj.LSym, ot int, x *obj.LSym) int {
 }
 
 var kinds = []int{
-	TINT:        objabi.KindInt,
-	TUINT:       objabi.KindUint,
-	TINT8:       objabi.KindInt8,
-	TUINT8:      objabi.KindUint8,
-	TINT16:      objabi.KindInt16,
-	TUINT16:     objabi.KindUint16,
-	TINT32:      objabi.KindInt32,
-	TUINT32:     objabi.KindUint32,
-	TINT64:      objabi.KindInt64,
-	TUINT64:     objabi.KindUint64,
-	TUINTPTR:    objabi.KindUintptr,
-	TFLOAT32:    objabi.KindFloat32,
-	TFLOAT64:    objabi.KindFloat64,
-	TBOOL:       objabi.KindBool,
-	TSTRING:     objabi.KindString,
-	TPTR:        objabi.KindPtr,
-	TSTRUCT:     objabi.KindStruct,
-	TINTER:      objabi.KindInterface,
-	TCHAN:       objabi.KindChan,
-	TMAP:        objabi.KindMap,
-	TARRAY:      objabi.KindArray,
-	TSLICE:      objabi.KindSlice,
-	TFUNC:       objabi.KindFunc,
-	TCOMPLEX64:  objabi.KindComplex64,
-	TCOMPLEX128: objabi.KindComplex128,
-	TUNSAFEPTR:  objabi.KindUnsafePointer,
+	types.TINT:        objabi.KindInt,
+	types.TUINT:       objabi.KindUint,
+	types.TINT8:       objabi.KindInt8,
+	types.TUINT8:      objabi.KindUint8,
+	types.TINT16:      objabi.KindInt16,
+	types.TUINT16:     objabi.KindUint16,
+	types.TINT32:      objabi.KindInt32,
+	types.TUINT32:     objabi.KindUint32,
+	types.TINT64:      objabi.KindInt64,
+	types.TUINT64:     objabi.KindUint64,
+	types.TUINTPTR:    objabi.KindUintptr,
+	types.TFLOAT32:    objabi.KindFloat32,
+	types.TFLOAT64:    objabi.KindFloat64,
+	types.TBOOL:       objabi.KindBool,
+	types.TSTRING:     objabi.KindString,
+	types.TPTR:        objabi.KindPtr,
+	types.TSTRUCT:     objabi.KindStruct,
+	types.TINTER:      objabi.KindInterface,
+	types.TCHAN:       objabi.KindChan,
+	types.TMAP:        objabi.KindMap,
+	types.TARRAY:      objabi.KindArray,
+	types.TSLICE:      objabi.KindSlice,
+	types.TFUNC:       objabi.KindFunc,
+	types.TCOMPLEX64:  objabi.KindComplex64,
+	types.TCOMPLEX128: objabi.KindComplex128,
+	types.TUNSAFEPTR:  objabi.KindUnsafePointer,
 }
 
 // typeptrdata returns the length in bytes of the prefix of t
@@ -753,32 +754,32 @@ func typeptrdata(t *types.Type) int64 {
 	}
 
 	switch t.Etype {
-	case TPTR,
-		TUNSAFEPTR,
-		TFUNC,
-		TCHAN,
-		TMAP:
+	case types.TPTR,
+		types.TUNSAFEPTR,
+		types.TFUNC,
+		types.TCHAN,
+		types.TMAP:
 		return int64(Widthptr)
 
-	case TSTRING:
+	case types.TSTRING:
 		// struct { byte *str; intgo len; }
 		return int64(Widthptr)
 
-	case TINTER:
+	case types.TINTER:
 		// struct { Itab *tab;	void *data; } or
 		// struct { Type *type; void *data; }
 		// Note: see comment in plive.go:onebitwalktype1.
 		return 2 * int64(Widthptr)
 
-	case TSLICE:
+	case types.TSLICE:
 		// struct { byte *array; uintgo len; uintgo cap; }
 		return int64(Widthptr)
 
-	case TARRAY:
+	case types.TARRAY:
 		// haspointers already eliminated t.NumElem() == 0.
 		return (t.NumElem()-1)*t.Elem().Width + typeptrdata(t.Elem())
 
-	case TSTRUCT:
+	case types.TSTRUCT:
 		// Find the last field that has pointers.
 		var lastPtrField *types.Field
 		for _, t1 := range t.Fields().Slice() {
@@ -989,38 +990,38 @@ func typenamesym(t *types.Type) *types.Sym {
 	return s
 }
 
-func typename(t *types.Type) *Node {
+func typename(t *types.Type) *ir.Node {
 	s := typenamesym(t)
 	if s.Def == nil {
-		n := newnamel(src.NoXPos, s)
-		n.Type = types.Types[TUINT8]
-		n.SetClass(PEXTERN)
+		n := ir.NewNameAt(src.NoXPos, s)
+		n.Type = types.Types[types.TUINT8]
+		n.SetClass(ir.PEXTERN)
 		n.SetTypecheck(1)
-		s.Def = asTypesNode(n)
+		s.Def = ir.AsTypesNode(n)
 	}
 
-	n := nod(OADDR, asNode(s.Def), nil)
-	n.Type = types.NewPtr(asNode(s.Def).Type)
+	n := ir.Nod(ir.OADDR, ir.AsNode(s.Def), nil)
+	n.Type = types.NewPtr(ir.AsNode(s.Def).Type)
 	n.SetTypecheck(1)
 	return n
 }
 
-func itabname(t, itype *types.Type) *Node {
+func itabname(t, itype *types.Type) *ir.Node {
 	if t == nil || (t.IsPtr() && t.Elem() == nil) || t.IsUntyped() || !itype.IsInterface() || itype.IsEmptyInterface() {
 		base.Fatalf("itabname(%v, %v)", t, itype)
 	}
 	s := itabpkg.Lookup(t.ShortString() + "," + itype.ShortString())
 	if s.Def == nil {
-		n := newname(s)
-		n.Type = types.Types[TUINT8]
-		n.SetClass(PEXTERN)
+		n := NewName(s)
+		n.Type = types.Types[types.TUINT8]
+		n.SetClass(ir.PEXTERN)
 		n.SetTypecheck(1)
-		s.Def = asTypesNode(n)
+		s.Def = ir.AsTypesNode(n)
 		itabs = append(itabs, itabEntry{t: t, itype: itype, lsym: s.Linksym()})
 	}
 
-	n := nod(OADDR, asNode(s.Def), nil)
-	n.Type = types.NewPtr(asNode(s.Def).Type)
+	n := ir.Nod(ir.OADDR, ir.AsNode(s.Def), nil)
+	n.Type = types.NewPtr(ir.AsNode(s.Def).Type)
 	n.SetTypecheck(1)
 	return n
 }
@@ -1029,35 +1030,35 @@ func itabname(t, itype *types.Type) *Node {
 // That is, if x==x for all x of type t.
 func isreflexive(t *types.Type) bool {
 	switch t.Etype {
-	case TBOOL,
-		TINT,
-		TUINT,
-		TINT8,
-		TUINT8,
-		TINT16,
-		TUINT16,
-		TINT32,
-		TUINT32,
-		TINT64,
-		TUINT64,
-		TUINTPTR,
-		TPTR,
-		TUNSAFEPTR,
-		TSTRING,
-		TCHAN:
+	case types.TBOOL,
+		types.TINT,
+		types.TUINT,
+		types.TINT8,
+		types.TUINT8,
+		types.TINT16,
+		types.TUINT16,
+		types.TINT32,
+		types.TUINT32,
+		types.TINT64,
+		types.TUINT64,
+		types.TUINTPTR,
+		types.TPTR,
+		types.TUNSAFEPTR,
+		types.TSTRING,
+		types.TCHAN:
 		return true
 
-	case TFLOAT32,
-		TFLOAT64,
-		TCOMPLEX64,
-		TCOMPLEX128,
-		TINTER:
+	case types.TFLOAT32,
+		types.TFLOAT64,
+		types.TCOMPLEX64,
+		types.TCOMPLEX128,
+		types.TINTER:
 		return false
 
-	case TARRAY:
+	case types.TARRAY:
 		return isreflexive(t.Elem())
 
-	case TSTRUCT:
+	case types.TSTRUCT:
 		for _, t1 := range t.Fields().Slice() {
 			if !isreflexive(t1.Type) {
 				return false
@@ -1075,19 +1076,19 @@ func isreflexive(t *types.Type) bool {
 // need the key to be updated.
 func needkeyupdate(t *types.Type) bool {
 	switch t.Etype {
-	case TBOOL, TINT, TUINT, TINT8, TUINT8, TINT16, TUINT16, TINT32, TUINT32,
-		TINT64, TUINT64, TUINTPTR, TPTR, TUNSAFEPTR, TCHAN:
+	case types.TBOOL, types.TINT, types.TUINT, types.TINT8, types.TUINT8, types.TINT16, types.TUINT16, types.TINT32, types.TUINT32,
+		types.TINT64, types.TUINT64, types.TUINTPTR, types.TPTR, types.TUNSAFEPTR, types.TCHAN:
 		return false
 
-	case TFLOAT32, TFLOAT64, TCOMPLEX64, TCOMPLEX128, // floats and complex can be +0/-0
-		TINTER,
-		TSTRING: // strings might have smaller backing stores
+	case types.TFLOAT32, types.TFLOAT64, types.TCOMPLEX64, types.TCOMPLEX128, // floats and complex can be +0/-0
+		types.TINTER,
+		types.TSTRING: // strings might have smaller backing stores
 		return true
 
-	case TARRAY:
+	case types.TARRAY:
 		return needkeyupdate(t.Elem())
 
-	case TSTRUCT:
+	case types.TSTRUCT:
 		for _, t1 := range t.Fields().Slice() {
 			if needkeyupdate(t1.Type) {
 				return true
@@ -1104,13 +1105,13 @@ func needkeyupdate(t *types.Type) bool {
 // hashMightPanic reports whether the hash of a map key of type t might panic.
 func hashMightPanic(t *types.Type) bool {
 	switch t.Etype {
-	case TINTER:
+	case types.TINTER:
 		return true
 
-	case TARRAY:
+	case types.TARRAY:
 		return hashMightPanic(t.Elem())
 
-	case TSTRUCT:
+	case types.TSTRUCT:
 		for _, t1 := range t.Fields().Slice() {
 			if hashMightPanic(t1.Type) {
 				return true
@@ -1161,7 +1162,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 
 	if base.Ctxt.Pkgpath != "runtime" || (tbase != types.Types[tbase.Etype] && tbase != types.Bytetype && tbase != types.Runetype && tbase != types.Errortype) { // int, float, etc
 		// named types from other files are defined only by those files
-		if tbase.Sym != nil && tbase.Sym.Pkg != localpkg {
+		if tbase.Sym != nil && tbase.Sym.Pkg != ir.LocalPkg {
 			if i, ok := typeSymIdx[tbase]; ok {
 				lsym.Pkg = tbase.Sym.Pkg.Prefix
 				if t != tbase {
@@ -1174,7 +1175,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 			return lsym
 		}
 		// TODO(mdempsky): Investigate whether this can happen.
-		if tbase.Etype == TFORW {
+		if tbase.Etype == types.TFORW {
 			return lsym
 		}
 	}
@@ -1185,7 +1186,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 		ot = dcommontype(lsym, t)
 		ot = dextratype(lsym, ot, t, 0)
 
-	case TARRAY:
+	case types.TARRAY:
 		// ../../../../runtime/type.go:/arrayType
 		s1 := dtypesym(t.Elem())
 		t2 := types.NewSlice(t.Elem())
@@ -1196,14 +1197,14 @@ func dtypesym(t *types.Type) *obj.LSym {
 		ot = duintptr(lsym, ot, uint64(t.NumElem()))
 		ot = dextratype(lsym, ot, t, 0)
 
-	case TSLICE:
+	case types.TSLICE:
 		// ../../../../runtime/type.go:/sliceType
 		s1 := dtypesym(t.Elem())
 		ot = dcommontype(lsym, t)
 		ot = dsymptr(lsym, ot, s1, 0)
 		ot = dextratype(lsym, ot, t, 0)
 
-	case TCHAN:
+	case types.TCHAN:
 		// ../../../../runtime/type.go:/chanType
 		s1 := dtypesym(t.Elem())
 		ot = dcommontype(lsym, t)
@@ -1211,7 +1212,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 		ot = duintptr(lsym, ot, uint64(t.ChanDir()))
 		ot = dextratype(lsym, ot, t, 0)
 
-	case TFUNC:
+	case types.TFUNC:
 		for _, t1 := range t.Recvs().Fields().Slice() {
 			dtypesym(t1.Type)
 		}
@@ -1250,7 +1251,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 			ot = dsymptr(lsym, ot, dtypesym(t1.Type), 0)
 		}
 
-	case TINTER:
+	case types.TINTER:
 		m := imethods(t)
 		n := len(m)
 		for _, a := range m {
@@ -1286,7 +1287,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 		}
 
 	// ../../../../runtime/type.go:/mapType
-	case TMAP:
+	case types.TMAP:
 		s1 := dtypesym(t.Key())
 		s2 := dtypesym(t.Elem())
 		s3 := dtypesym(bmap(t))
@@ -1326,8 +1327,8 @@ func dtypesym(t *types.Type) *obj.LSym {
 		ot = duint32(lsym, ot, flags)
 		ot = dextratype(lsym, ot, t, 0)
 
-	case TPTR:
-		if t.Elem().Etype == TANY {
+	case types.TPTR:
+		if t.Elem().Etype == types.TANY {
 			// ../../../../runtime/type.go:/UnsafePointerType
 			ot = dcommontype(lsym, t)
 			ot = dextratype(lsym, ot, t, 0)
@@ -1344,7 +1345,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 
 	// ../../../../runtime/type.go:/structType
 	// for security, only the exported fields.
-	case TSTRUCT:
+	case types.TSTRUCT:
 		fields := t.Fields().Slice()
 		for _, t1 := range fields {
 			dtypesym(t1.Type)
@@ -1403,7 +1404,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 		// functions must return the existing type structure rather
 		// than creating a new one.
 		switch t.Etype {
-		case TPTR, TARRAY, TCHAN, TFUNC, TMAP, TSLICE, TSTRUCT:
+		case types.TPTR, types.TARRAY, types.TCHAN, types.TFUNC, types.TMAP, types.TSLICE, types.TSTRUCT:
 			keep = true
 		}
 	}
@@ -1515,10 +1516,10 @@ func addsignat(t *types.Type) {
 	}
 }
 
-func addsignats(dcls []*Node) {
+func addsignats(dcls []*ir.Node) {
 	// copy types from dcl list to signatset
 	for _, n := range dcls {
-		if n.Op == OTYPE {
+		if n.Op == ir.OTYPE {
 			addsignat(n.Type)
 		}
 	}
@@ -1571,7 +1572,7 @@ func dumptabs() {
 	}
 
 	// process ptabs
-	if localpkg.Name == "main" && len(ptabs) > 0 {
+	if ir.LocalPkg.Name == "main" && len(ptabs) > 0 {
 		ot := 0
 		s := base.Ctxt.Lookup("go.plugin.tabs")
 		for _, p := range ptabs {
@@ -1615,17 +1616,17 @@ func dumpbasictypes() {
 	// another possible choice would be package main,
 	// but using runtime means fewer copies in object files.
 	if base.Ctxt.Pkgpath == "runtime" {
-		for i := types.EType(1); i <= TBOOL; i++ {
+		for i := types.EType(1); i <= types.TBOOL; i++ {
 			dtypesym(types.NewPtr(types.Types[i]))
 		}
-		dtypesym(types.NewPtr(types.Types[TSTRING]))
-		dtypesym(types.NewPtr(types.Types[TUNSAFEPTR]))
+		dtypesym(types.NewPtr(types.Types[types.TSTRING]))
+		dtypesym(types.NewPtr(types.Types[types.TUNSAFEPTR]))
 
 		// emit type structs for error and func(error) string.
 		// The latter is the type of an auto-generated wrapper.
 		dtypesym(types.NewPtr(types.Errortype))
 
-		dtypesym(functype(nil, []*Node{anonfield(types.Errortype)}, []*Node{anonfield(types.Types[TSTRING])}))
+		dtypesym(functype(nil, []*ir.Node{anonfield(types.Errortype)}, []*ir.Node{anonfield(types.Types[types.TSTRING])}))
 
 		// add paths for runtime and main, which 6l imports implicitly.
 		dimportpath(Runtimepkg)
@@ -1767,7 +1768,7 @@ func fillptrmask(t *types.Type, ptrmask []byte) {
 // For non-trivial arrays, the program describes the full t.Width size.
 func dgcprog(t *types.Type) (*obj.LSym, int64) {
 	dowidth(t)
-	if t.Width == BADWIDTH {
+	if t.Width == types.BADWIDTH {
 		base.Fatalf("dgcprog: %v badwidth", t)
 	}
 	lsym := typesymprefix(".gcprog", t).Linksym()
@@ -1824,17 +1825,17 @@ func (p *GCProg) emit(t *types.Type, offset int64) {
 	default:
 		base.Fatalf("GCProg.emit: unexpected type %v", t)
 
-	case TSTRING:
+	case types.TSTRING:
 		p.w.Ptr(offset / int64(Widthptr))
 
-	case TINTER:
+	case types.TINTER:
 		// Note: the first word isn't a pointer. See comment in plive.go:onebitwalktype1.
 		p.w.Ptr(offset/int64(Widthptr) + 1)
 
-	case TSLICE:
+	case types.TSLICE:
 		p.w.Ptr(offset / int64(Widthptr))
 
-	case TARRAY:
+	case types.TARRAY:
 		if t.NumElem() == 0 {
 			// should have been handled by haspointers check above
 			base.Fatalf("GCProg.emit: empty array")
@@ -1859,7 +1860,7 @@ func (p *GCProg) emit(t *types.Type, offset int64) {
 		p.w.ZeroUntil((offset + elem.Width) / int64(Widthptr))
 		p.w.Repeat(elem.Width/int64(Widthptr), count-1)
 
-	case TSTRUCT:
+	case types.TSTRUCT:
 		for _, t1 := range t.Fields().Slice() {
 			p.emit(t1.Type, offset+t1.Offset)
 		}
@@ -1868,7 +1869,7 @@ func (p *GCProg) emit(t *types.Type, offset int64) {
 
 // zeroaddr returns the address of a symbol with at least
 // size bytes of zeros.
-func zeroaddr(size int64) *Node {
+func zeroaddr(size int64) *ir.Node {
 	if size >= 1<<31 {
 		base.Fatalf("map elem too big %d", size)
 	}
@@ -1877,14 +1878,14 @@ func zeroaddr(size int64) *Node {
 	}
 	s := mappkg.Lookup("zero")
 	if s.Def == nil {
-		x := newname(s)
-		x.Type = types.Types[TUINT8]
-		x.SetClass(PEXTERN)
+		x := NewName(s)
+		x.Type = types.Types[types.TUINT8]
+		x.SetClass(ir.PEXTERN)
 		x.SetTypecheck(1)
-		s.Def = asTypesNode(x)
+		s.Def = ir.AsTypesNode(x)
 	}
-	z := nod(OADDR, asNode(s.Def), nil)
-	z.Type = types.NewPtr(types.Types[TUINT8])
+	z := ir.Nod(ir.OADDR, ir.AsNode(s.Def), nil)
+	z.Type = types.NewPtr(types.Types[types.TUINT8])
 	z.SetTypecheck(1)
 	return z
 }
diff --git a/src/cmd/compile/internal/gc/scc.go b/src/cmd/compile/internal/gc/scc.go
index 891012cbc9..ddde18e505 100644
--- a/src/cmd/compile/internal/gc/scc.go
+++ b/src/cmd/compile/internal/gc/scc.go
@@ -4,6 +4,8 @@
 
 package gc
 
+import "cmd/compile/internal/ir"
+
 // Strongly connected components.
 //
 // Run analysis on minimal sets of mutually recursive functions
@@ -30,10 +32,10 @@ package gc
 // when analyzing a set of mutually recursive functions.
 
 type bottomUpVisitor struct {
-	analyze  func([]*Node, bool)
+	analyze  func([]*ir.Node, bool)
 	visitgen uint32
-	nodeID   map[*Node]uint32
-	stack    []*Node
+	nodeID   map[*ir.Node]uint32
+	stack    []*ir.Node
 }
 
 // visitBottomUp invokes analyze on the ODCLFUNC nodes listed in list.
@@ -49,18 +51,18 @@ type bottomUpVisitor struct {
 // If recursive is false, the list consists of only a single function and its closures.
 // If recursive is true, the list may still contain only a single function,
 // if that function is itself recursive.
-func visitBottomUp(list []*Node, analyze func(list []*Node, recursive bool)) {
+func visitBottomUp(list []*ir.Node, analyze func(list []*ir.Node, recursive bool)) {
 	var v bottomUpVisitor
 	v.analyze = analyze
-	v.nodeID = make(map[*Node]uint32)
+	v.nodeID = make(map[*ir.Node]uint32)
 	for _, n := range list {
-		if n.Op == ODCLFUNC && !n.Func.IsHiddenClosure() {
+		if n.Op == ir.ODCLFUNC && !n.Func.IsHiddenClosure() {
 			v.visit(n)
 		}
 	}
 }
 
-func (v *bottomUpVisitor) visit(n *Node) uint32 {
+func (v *bottomUpVisitor) visit(n *ir.Node) uint32 {
 	if id := v.nodeID[n]; id > 0 {
 		// already visited
 		return id
@@ -73,38 +75,38 @@ func (v *bottomUpVisitor) visit(n *Node) uint32 {
 	min := v.visitgen
 	v.stack = append(v.stack, n)
 
-	inspectList(n.Nbody, func(n *Node) bool {
+	ir.InspectList(n.Nbody, func(n *ir.Node) bool {
 		switch n.Op {
-		case ONAME:
-			if n.Class() == PFUNC {
+		case ir.ONAME:
+			if n.Class() == ir.PFUNC {
 				if n != nil && n.Name.Defn != nil {
 					if m := v.visit(n.Name.Defn); m < min {
 						min = m
 					}
 				}
 			}
-		case OMETHEXPR:
-			fn := n.MethodName()
+		case ir.OMETHEXPR:
+			fn := methodExprName(n)
 			if fn != nil && fn.Name.Defn != nil {
 				if m := v.visit(fn.Name.Defn); m < min {
 					min = m
 				}
 			}
-		case ODOTMETH:
-			fn := n.MethodName()
-			if fn != nil && fn.Op == ONAME && fn.Class() == PFUNC && fn.Name.Defn != nil {
+		case ir.ODOTMETH:
+			fn := methodExprName(n)
+			if fn != nil && fn.Op == ir.ONAME && fn.Class() == ir.PFUNC && fn.Name.Defn != nil {
 				if m := v.visit(fn.Name.Defn); m < min {
 					min = m
 				}
 			}
-		case OCALLPART:
-			fn := asNode(callpartMethod(n).Nname)
-			if fn != nil && fn.Op == ONAME && fn.Class() == PFUNC && fn.Name.Defn != nil {
+		case ir.OCALLPART:
+			fn := ir.AsNode(callpartMethod(n).Nname)
+			if fn != nil && fn.Op == ir.ONAME && fn.Class() == ir.PFUNC && fn.Name.Defn != nil {
 				if m := v.visit(fn.Name.Defn); m < min {
 					min = m
 				}
 			}
-		case OCLOSURE:
+		case ir.OCLOSURE:
 			if m := v.visit(n.Func.Decl); m < min {
 				min = m
 			}
diff --git a/src/cmd/compile/internal/gc/scope.go b/src/cmd/compile/internal/gc/scope.go
index ace1d6bd9c..b5ebce04be 100644
--- a/src/cmd/compile/internal/gc/scope.go
+++ b/src/cmd/compile/internal/gc/scope.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/internal/dwarf"
 	"cmd/internal/obj"
 	"cmd/internal/src"
@@ -17,7 +18,7 @@ func xposBefore(p, q src.XPos) bool {
 	return base.Ctxt.PosTable.Pos(p).Before(base.Ctxt.PosTable.Pos(q))
 }
 
-func findScope(marks []Mark, pos src.XPos) ScopeID {
+func findScope(marks []ir.Mark, pos src.XPos) ir.ScopeID {
 	i := sort.Search(len(marks), func(i int) bool {
 		return xposBefore(pos, marks[i].Pos)
 	})
@@ -27,7 +28,7 @@ func findScope(marks []Mark, pos src.XPos) ScopeID {
 	return marks[i-1].Scope
 }
 
-func assembleScopes(fnsym *obj.LSym, fn *Node, dwarfVars []*dwarf.Var, varScopes []ScopeID) []dwarf.Scope {
+func assembleScopes(fnsym *obj.LSym, fn *ir.Node, dwarfVars []*dwarf.Var, varScopes []ir.ScopeID) []dwarf.Scope {
 	// Initialize the DWARF scope tree based on lexical scopes.
 	dwarfScopes := make([]dwarf.Scope, 1+len(fn.Func.Parents))
 	for i, parent := range fn.Func.Parents {
@@ -40,7 +41,7 @@ func assembleScopes(fnsym *obj.LSym, fn *Node, dwarfVars []*dwarf.Var, varScopes
 }
 
 // scopeVariables assigns DWARF variable records to their scopes.
-func scopeVariables(dwarfVars []*dwarf.Var, varScopes []ScopeID, dwarfScopes []dwarf.Scope) {
+func scopeVariables(dwarfVars []*dwarf.Var, varScopes []ir.ScopeID, dwarfScopes []dwarf.Scope) {
 	sort.Stable(varsByScopeAndOffset{dwarfVars, varScopes})
 
 	i0 := 0
@@ -57,7 +58,7 @@ func scopeVariables(dwarfVars []*dwarf.Var, varScopes []ScopeID, dwarfScopes []d
 }
 
 // scopePCs assigns PC ranges to their scopes.
-func scopePCs(fnsym *obj.LSym, marks []Mark, dwarfScopes []dwarf.Scope) {
+func scopePCs(fnsym *obj.LSym, marks []ir.Mark, dwarfScopes []dwarf.Scope) {
 	// If there aren't any child scopes (in particular, when scope
 	// tracking is disabled), we can skip a whole lot of work.
 	if len(marks) == 0 {
@@ -90,7 +91,7 @@ func compactScopes(dwarfScopes []dwarf.Scope) []dwarf.Scope {
 
 type varsByScopeAndOffset struct {
 	vars   []*dwarf.Var
-	scopes []ScopeID
+	scopes []ir.ScopeID
 }
 
 func (v varsByScopeAndOffset) Len() int {
diff --git a/src/cmd/compile/internal/gc/select.go b/src/cmd/compile/internal/gc/select.go
index 8d4c8d2be1..ed7db0aaf7 100644
--- a/src/cmd/compile/internal/gc/select.go
+++ b/src/cmd/compile/internal/gc/select.go
@@ -6,16 +6,17 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 )
 
 // select
-func typecheckselect(sel *Node) {
-	var def *Node
+func typecheckselect(sel *ir.Node) {
+	var def *ir.Node
 	lno := setlineno(sel)
 	typecheckslice(sel.Ninit.Slice(), ctxStmt)
 	for _, ncase := range sel.List.Slice() {
-		if ncase.Op != OCASE {
+		if ncase.Op != ir.OCASE {
 			setlineno(ncase)
 			base.Fatalf("typecheckselect %v", ncase.Op)
 		}
@@ -23,7 +24,7 @@ func typecheckselect(sel *Node) {
 		if ncase.List.Len() == 0 {
 			// default
 			if def != nil {
-				base.ErrorfAt(ncase.Pos, "multiple defaults in select (first at %v)", def.Line())
+				base.ErrorfAt(ncase.Pos, "multiple defaults in select (first at %v)", ir.Line(def))
 			} else {
 				def = ncase
 			}
@@ -37,7 +38,7 @@ func typecheckselect(sel *Node) {
 			switch n.Op {
 			default:
 				pos := n.Pos
-				if n.Op == ONAME {
+				if n.Op == ir.ONAME {
 					// We don't have the right position for ONAME nodes (see #15459 and
 					// others). Using ncase.Pos for now as it will provide the correct
 					// line number (assuming the expression follows the "case" keyword
@@ -49,37 +50,37 @@ func typecheckselect(sel *Node) {
 			// convert x = <-c into OSELRECV(x, <-c).
 			// remove implicit conversions; the eventual assignment
 			// will reintroduce them.
-			case OAS:
-				if (n.Right.Op == OCONVNOP || n.Right.Op == OCONVIFACE) && n.Right.Implicit() {
+			case ir.OAS:
+				if (n.Right.Op == ir.OCONVNOP || n.Right.Op == ir.OCONVIFACE) && n.Right.Implicit() {
 					n.Right = n.Right.Left
 				}
 
-				if n.Right.Op != ORECV {
+				if n.Right.Op != ir.ORECV {
 					base.ErrorfAt(n.Pos, "select assignment must have receive on right hand side")
 					break
 				}
 
-				n.Op = OSELRECV
+				n.Op = ir.OSELRECV
 
 				// convert x, ok = <-c into OSELRECV2(x, <-c) with ntest=ok
-			case OAS2RECV:
-				if n.Right.Op != ORECV {
+			case ir.OAS2RECV:
+				if n.Right.Op != ir.ORECV {
 					base.ErrorfAt(n.Pos, "select assignment must have receive on right hand side")
 					break
 				}
 
-				n.Op = OSELRECV2
+				n.Op = ir.OSELRECV2
 				n.Left = n.List.First()
 				n.List.Set1(n.List.Second())
 
 				// convert <-c into OSELRECV(N, <-c)
-			case ORECV:
-				n = nodl(n.Pos, OSELRECV, nil, n)
+			case ir.ORECV:
+				n = ir.NodAt(n.Pos, ir.OSELRECV, nil, n)
 
 				n.SetTypecheck(1)
 				ncase.Left = n
 
-			case OSEND:
+			case ir.OSEND:
 				break
 			}
 		}
@@ -90,7 +91,7 @@ func typecheckselect(sel *Node) {
 	base.Pos = lno
 }
 
-func walkselect(sel *Node) {
+func walkselect(sel *ir.Node) {
 	lno := setlineno(sel)
 	if sel.Nbody.Len() != 0 {
 		base.Fatalf("double walkselect")
@@ -108,13 +109,13 @@ func walkselect(sel *Node) {
 	base.Pos = lno
 }
 
-func walkselectcases(cases *Nodes) []*Node {
+func walkselectcases(cases *ir.Nodes) []*ir.Node {
 	ncas := cases.Len()
 	sellineno := base.Pos
 
 	// optimization: zero-case select
 	if ncas == 0 {
-		return []*Node{mkcall("block", nil, nil)}
+		return []*ir.Node{mkcall("block", nil, nil)}
 	}
 
 	// optimization: one-case select: single op.
@@ -130,25 +131,25 @@ func walkselectcases(cases *Nodes) []*Node {
 			default:
 				base.Fatalf("select %v", n.Op)
 
-			case OSEND:
+			case ir.OSEND:
 				// already ok
 
-			case OSELRECV, OSELRECV2:
-				if n.Op == OSELRECV || n.List.Len() == 0 {
+			case ir.OSELRECV, ir.OSELRECV2:
+				if n.Op == ir.OSELRECV || n.List.Len() == 0 {
 					if n.Left == nil {
 						n = n.Right
 					} else {
-						n.Op = OAS
+						n.Op = ir.OAS
 					}
 					break
 				}
 
 				if n.Left == nil {
-					nblank = typecheck(nblank, ctxExpr|ctxAssign)
-					n.Left = nblank
+					ir.BlankNode = typecheck(ir.BlankNode, ctxExpr|ctxAssign)
+					n.Left = ir.BlankNode
 				}
 
-				n.Op = OAS2
+				n.Op = ir.OAS2
 				n.List.Prepend(n.Left)
 				n.Rlist.Set1(n.Right)
 				n.Right = nil
@@ -161,13 +162,13 @@ func walkselectcases(cases *Nodes) []*Node {
 		}
 
 		l = append(l, cas.Nbody.Slice()...)
-		l = append(l, nod(OBREAK, nil, nil))
+		l = append(l, ir.Nod(ir.OBREAK, nil, nil))
 		return l
 	}
 
 	// convert case value arguments to addresses.
 	// this rewrite is used by both the general code and the next optimization.
-	var dflt *Node
+	var dflt *ir.Node
 	for _, cas := range cases.Slice() {
 		setlineno(cas)
 		n := cas.Left
@@ -176,17 +177,17 @@ func walkselectcases(cases *Nodes) []*Node {
 			continue
 		}
 		switch n.Op {
-		case OSEND:
-			n.Right = nod(OADDR, n.Right, nil)
+		case ir.OSEND:
+			n.Right = ir.Nod(ir.OADDR, n.Right, nil)
 			n.Right = typecheck(n.Right, ctxExpr)
 
-		case OSELRECV, OSELRECV2:
-			if n.Op == OSELRECV2 && n.List.Len() == 0 {
-				n.Op = OSELRECV
+		case ir.OSELRECV, ir.OSELRECV2:
+			if n.Op == ir.OSELRECV2 && n.List.Len() == 0 {
+				n.Op = ir.OSELRECV
 			}
 
 			if n.Left != nil {
-				n.Left = nod(OADDR, n.Left, nil)
+				n.Left = ir.Nod(ir.OADDR, n.Left, nil)
 				n.Left = typecheck(n.Left, ctxExpr)
 			}
 		}
@@ -201,66 +202,66 @@ func walkselectcases(cases *Nodes) []*Node {
 
 		n := cas.Left
 		setlineno(n)
-		r := nod(OIF, nil, nil)
+		r := ir.Nod(ir.OIF, nil, nil)
 		r.Ninit.Set(cas.Ninit.Slice())
 		switch n.Op {
 		default:
 			base.Fatalf("select %v", n.Op)
 
-		case OSEND:
+		case ir.OSEND:
 			// if selectnbsend(c, v) { body } else { default body }
 			ch := n.Left
-			r.Left = mkcall1(chanfn("selectnbsend", 2, ch.Type), types.Types[TBOOL], &r.Ninit, ch, n.Right)
+			r.Left = mkcall1(chanfn("selectnbsend", 2, ch.Type), types.Types[types.TBOOL], &r.Ninit, ch, n.Right)
 
-		case OSELRECV:
+		case ir.OSELRECV:
 			// if selectnbrecv(&v, c) { body } else { default body }
 			ch := n.Right.Left
 			elem := n.Left
 			if elem == nil {
 				elem = nodnil()
 			}
-			r.Left = mkcall1(chanfn("selectnbrecv", 2, ch.Type), types.Types[TBOOL], &r.Ninit, elem, ch)
+			r.Left = mkcall1(chanfn("selectnbrecv", 2, ch.Type), types.Types[types.TBOOL], &r.Ninit, elem, ch)
 
-		case OSELRECV2:
+		case ir.OSELRECV2:
 			// if selectnbrecv2(&v, &received, c) { body } else { default body }
 			ch := n.Right.Left
 			elem := n.Left
 			if elem == nil {
 				elem = nodnil()
 			}
-			receivedp := nod(OADDR, n.List.First(), nil)
+			receivedp := ir.Nod(ir.OADDR, n.List.First(), nil)
 			receivedp = typecheck(receivedp, ctxExpr)
-			r.Left = mkcall1(chanfn("selectnbrecv2", 2, ch.Type), types.Types[TBOOL], &r.Ninit, elem, receivedp, ch)
+			r.Left = mkcall1(chanfn("selectnbrecv2", 2, ch.Type), types.Types[types.TBOOL], &r.Ninit, elem, receivedp, ch)
 		}
 
 		r.Left = typecheck(r.Left, ctxExpr)
 		r.Nbody.Set(cas.Nbody.Slice())
 		r.Rlist.Set(append(dflt.Ninit.Slice(), dflt.Nbody.Slice()...))
-		return []*Node{r, nod(OBREAK, nil, nil)}
+		return []*ir.Node{r, ir.Nod(ir.OBREAK, nil, nil)}
 	}
 
 	if dflt != nil {
 		ncas--
 	}
-	casorder := make([]*Node, ncas)
+	casorder := make([]*ir.Node, ncas)
 	nsends, nrecvs := 0, 0
 
-	var init []*Node
+	var init []*ir.Node
 
 	// generate sel-struct
 	base.Pos = sellineno
 	selv := temp(types.NewArray(scasetype(), int64(ncas)))
-	r := nod(OAS, selv, nil)
+	r := ir.Nod(ir.OAS, selv, nil)
 	r = typecheck(r, ctxStmt)
 	init = append(init, r)
 
 	// No initialization for order; runtime.selectgo is responsible for that.
-	order := temp(types.NewArray(types.Types[TUINT16], 2*int64(ncas)))
+	order := temp(types.NewArray(types.Types[types.TUINT16], 2*int64(ncas)))
 
-	var pc0, pcs *Node
+	var pc0, pcs *ir.Node
 	if base.Flag.Race {
-		pcs = temp(types.NewArray(types.Types[TUINTPTR], int64(ncas)))
-		pc0 = typecheck(nod(OADDR, nod(OINDEX, pcs, nodintconst(0)), nil), ctxExpr)
+		pcs = temp(types.NewArray(types.Types[types.TUINTPTR], int64(ncas)))
+		pc0 = typecheck(ir.Nod(ir.OADDR, ir.Nod(ir.OINDEX, pcs, nodintconst(0)), nil), ctxExpr)
 	} else {
 		pc0 = nodnil()
 	}
@@ -278,16 +279,16 @@ func walkselectcases(cases *Nodes) []*Node {
 		}
 
 		var i int
-		var c, elem *Node
+		var c, elem *ir.Node
 		switch n.Op {
 		default:
 			base.Fatalf("select %v", n.Op)
-		case OSEND:
+		case ir.OSEND:
 			i = nsends
 			nsends++
 			c = n.Left
 			elem = n.Right
-		case OSELRECV, OSELRECV2:
+		case ir.OSELRECV, ir.OSELRECV2:
 			nrecvs++
 			i = ncas - nrecvs
 			c = n.Right.Left
@@ -296,23 +297,23 @@ func walkselectcases(cases *Nodes) []*Node {
 
 		casorder[i] = cas
 
-		setField := func(f string, val *Node) {
-			r := nod(OAS, nodSym(ODOT, nod(OINDEX, selv, nodintconst(int64(i))), lookup(f)), val)
+		setField := func(f string, val *ir.Node) {
+			r := ir.Nod(ir.OAS, nodSym(ir.ODOT, ir.Nod(ir.OINDEX, selv, nodintconst(int64(i))), lookup(f)), val)
 			r = typecheck(r, ctxStmt)
 			init = append(init, r)
 		}
 
-		c = convnop(c, types.Types[TUNSAFEPTR])
+		c = convnop(c, types.Types[types.TUNSAFEPTR])
 		setField("c", c)
 		if elem != nil {
-			elem = convnop(elem, types.Types[TUNSAFEPTR])
+			elem = convnop(elem, types.Types[types.TUNSAFEPTR])
 			setField("elem", elem)
 		}
 
 		// TODO(mdempsky): There should be a cleaner way to
 		// handle this.
 		if base.Flag.Race {
-			r = mkcall("selectsetpc", nil, nil, nod(OADDR, nod(OINDEX, pcs, nodintconst(int64(i))), nil))
+			r = mkcall("selectsetpc", nil, nil, ir.Nod(ir.OADDR, ir.Nod(ir.OINDEX, pcs, nodintconst(int64(i))), nil))
 			init = append(init, r)
 		}
 	}
@@ -322,9 +323,9 @@ func walkselectcases(cases *Nodes) []*Node {
 
 	// run the select
 	base.Pos = sellineno
-	chosen := temp(types.Types[TINT])
-	recvOK := temp(types.Types[TBOOL])
-	r = nod(OAS2, nil, nil)
+	chosen := temp(types.Types[types.TINT])
+	recvOK := temp(types.Types[types.TBOOL])
+	r = ir.Nod(ir.OAS2, nil, nil)
 	r.List.Set2(chosen, recvOK)
 	fn := syslook("selectgo")
 	r.Rlist.Set1(mkcall1(fn, fn.Type.Results(), nil, bytePtrToIndex(selv, 0), bytePtrToIndex(order, 0), pc0, nodintconst(int64(nsends)), nodintconst(int64(nrecvs)), nodbool(dflt == nil)))
@@ -332,46 +333,46 @@ func walkselectcases(cases *Nodes) []*Node {
 	init = append(init, r)
 
 	// selv and order are no longer alive after selectgo.
-	init = append(init, nod(OVARKILL, selv, nil))
-	init = append(init, nod(OVARKILL, order, nil))
+	init = append(init, ir.Nod(ir.OVARKILL, selv, nil))
+	init = append(init, ir.Nod(ir.OVARKILL, order, nil))
 	if base.Flag.Race {
-		init = append(init, nod(OVARKILL, pcs, nil))
+		init = append(init, ir.Nod(ir.OVARKILL, pcs, nil))
 	}
 
 	// dispatch cases
-	dispatch := func(cond, cas *Node) {
+	dispatch := func(cond, cas *ir.Node) {
 		cond = typecheck(cond, ctxExpr)
 		cond = defaultlit(cond, nil)
 
-		r := nod(OIF, cond, nil)
+		r := ir.Nod(ir.OIF, cond, nil)
 
-		if n := cas.Left; n != nil && n.Op == OSELRECV2 {
-			x := nod(OAS, n.List.First(), recvOK)
+		if n := cas.Left; n != nil && n.Op == ir.OSELRECV2 {
+			x := ir.Nod(ir.OAS, n.List.First(), recvOK)
 			x = typecheck(x, ctxStmt)
 			r.Nbody.Append(x)
 		}
 
 		r.Nbody.AppendNodes(&cas.Nbody)
-		r.Nbody.Append(nod(OBREAK, nil, nil))
+		r.Nbody.Append(ir.Nod(ir.OBREAK, nil, nil))
 		init = append(init, r)
 	}
 
 	if dflt != nil {
 		setlineno(dflt)
-		dispatch(nod(OLT, chosen, nodintconst(0)), dflt)
+		dispatch(ir.Nod(ir.OLT, chosen, nodintconst(0)), dflt)
 	}
 	for i, cas := range casorder {
 		setlineno(cas)
-		dispatch(nod(OEQ, chosen, nodintconst(int64(i))), cas)
+		dispatch(ir.Nod(ir.OEQ, chosen, nodintconst(int64(i))), cas)
 	}
 
 	return init
 }
 
 // bytePtrToIndex returns a Node representing "(*byte)(&n[i])".
-func bytePtrToIndex(n *Node, i int64) *Node {
-	s := nod(OADDR, nod(OINDEX, n, nodintconst(i)), nil)
-	t := types.NewPtr(types.Types[TUINT8])
+func bytePtrToIndex(n *ir.Node, i int64) *ir.Node {
+	s := ir.Nod(ir.OADDR, ir.Nod(ir.OINDEX, n, nodintconst(i)), nil)
+	t := types.NewPtr(types.Types[types.TUINT8])
 	return convnop(s, t)
 }
 
@@ -380,9 +381,9 @@ var scase *types.Type
 // Keep in sync with src/runtime/select.go.
 func scasetype() *types.Type {
 	if scase == nil {
-		scase = tostruct([]*Node{
-			namedfield("c", types.Types[TUNSAFEPTR]),
-			namedfield("elem", types.Types[TUNSAFEPTR]),
+		scase = tostruct([]*ir.Node{
+			namedfield("c", types.Types[types.TUNSAFEPTR]),
+			namedfield("elem", types.Types[types.TUNSAFEPTR]),
 		})
 		scase.SetNoalg(true)
 	}
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 219435d6de..d78b509127 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"fmt"
@@ -13,8 +14,8 @@ import (
 )
 
 type InitEntry struct {
-	Xoffset int64 // struct, array only
-	Expr    *Node // bytes of run-time computed expressions
+	Xoffset int64    // struct, array only
+	Expr    *ir.Node // bytes of run-time computed expressions
 }
 
 type InitPlan struct {
@@ -28,21 +29,21 @@ type InitPlan struct {
 type InitSchedule struct {
 	// out is the ordered list of dynamic initialization
 	// statements.
-	out []*Node
+	out []*ir.Node
 
-	initplans map[*Node]*InitPlan
-	inittemps map[*Node]*Node
+	initplans map[*ir.Node]*InitPlan
+	inittemps map[*ir.Node]*ir.Node
 }
 
-func (s *InitSchedule) append(n *Node) {
+func (s *InitSchedule) append(n *ir.Node) {
 	s.out = append(s.out, n)
 }
 
 // staticInit adds an initialization statement n to the schedule.
-func (s *InitSchedule) staticInit(n *Node) {
+func (s *InitSchedule) staticInit(n *ir.Node) {
 	if !s.tryStaticInit(n) {
 		if base.Flag.Percent != 0 {
-			Dump("nonstatic", n)
+			ir.Dump("nonstatic", n)
 		}
 		s.append(n)
 	}
@@ -50,16 +51,16 @@ func (s *InitSchedule) staticInit(n *Node) {
 
 // tryStaticInit attempts to statically execute an initialization
 // statement and reports whether it succeeded.
-func (s *InitSchedule) tryStaticInit(n *Node) bool {
+func (s *InitSchedule) tryStaticInit(n *ir.Node) bool {
 	// Only worry about simple "l = r" assignments. Multiple
 	// variable/expression OAS2 assignments have already been
 	// replaced by multiple simple OAS assignments, and the other
 	// OAS2* assignments mostly necessitate dynamic execution
 	// anyway.
-	if n.Op != OAS {
+	if n.Op != ir.OAS {
 		return false
 	}
-	if n.Left.isBlank() && candiscard(n.Right) {
+	if ir.IsBlank(n.Left) && candiscard(n.Right) {
 		return true
 	}
 	lno := setlineno(n)
@@ -69,21 +70,21 @@ func (s *InitSchedule) tryStaticInit(n *Node) bool {
 
 // like staticassign but we are copying an already
 // initialized value r.
-func (s *InitSchedule) staticcopy(l *Node, r *Node) bool {
-	if r.Op != ONAME && r.Op != OMETHEXPR {
+func (s *InitSchedule) staticcopy(l *ir.Node, r *ir.Node) bool {
+	if r.Op != ir.ONAME && r.Op != ir.OMETHEXPR {
 		return false
 	}
-	if r.Class() == PFUNC {
+	if r.Class() == ir.PFUNC {
 		pfuncsym(l, r)
 		return true
 	}
-	if r.Class() != PEXTERN || r.Sym.Pkg != localpkg {
+	if r.Class() != ir.PEXTERN || r.Sym.Pkg != ir.LocalPkg {
 		return false
 	}
 	if r.Name.Defn == nil { // probably zeroed but perhaps supplied externally and of unknown value
 		return false
 	}
-	if r.Name.Defn.Op != OAS {
+	if r.Name.Defn.Op != ir.OAS {
 		return false
 	}
 	if r.Type.IsString() { // perhaps overwritten by cmd/link -X (#34675)
@@ -92,73 +93,73 @@ func (s *InitSchedule) staticcopy(l *Node, r *Node) bool {
 	orig := r
 	r = r.Name.Defn.Right
 
-	for r.Op == OCONVNOP && !types.Identical(r.Type, l.Type) {
+	for r.Op == ir.OCONVNOP && !types.Identical(r.Type, l.Type) {
 		r = r.Left
 	}
 
 	switch r.Op {
-	case ONAME, OMETHEXPR:
+	case ir.ONAME, ir.OMETHEXPR:
 		if s.staticcopy(l, r) {
 			return true
 		}
 		// We may have skipped past one or more OCONVNOPs, so
 		// use conv to ensure r is assignable to l (#13263).
-		s.append(nod(OAS, l, conv(r, l.Type)))
+		s.append(ir.Nod(ir.OAS, l, conv(r, l.Type)))
 		return true
 
-	case ONIL:
+	case ir.ONIL:
 		return true
 
-	case OLITERAL:
+	case ir.OLITERAL:
 		if isZero(r) {
 			return true
 		}
 		litsym(l, r, int(l.Type.Width))
 		return true
 
-	case OADDR:
-		if a := r.Left; a.Op == ONAME {
+	case ir.OADDR:
+		if a := r.Left; a.Op == ir.ONAME {
 			addrsym(l, a)
 			return true
 		}
 
-	case OPTRLIT:
+	case ir.OPTRLIT:
 		switch r.Left.Op {
-		case OARRAYLIT, OSLICELIT, OSTRUCTLIT, OMAPLIT:
+		case ir.OARRAYLIT, ir.OSLICELIT, ir.OSTRUCTLIT, ir.OMAPLIT:
 			// copy pointer
 			addrsym(l, s.inittemps[r])
 			return true
 		}
 
-	case OSLICELIT:
+	case ir.OSLICELIT:
 		// copy slice
 		a := s.inittemps[r]
 		slicesym(l, a, r.Right.Int64Val())
 		return true
 
-	case OARRAYLIT, OSTRUCTLIT:
+	case ir.OARRAYLIT, ir.OSTRUCTLIT:
 		p := s.initplans[r]
 
-		n := l.copy()
+		n := ir.Copy(l)
 		for i := range p.E {
 			e := &p.E[i]
 			n.Xoffset = l.Xoffset + e.Xoffset
 			n.Type = e.Expr.Type
-			if e.Expr.Op == OLITERAL || e.Expr.Op == ONIL {
+			if e.Expr.Op == ir.OLITERAL || e.Expr.Op == ir.ONIL {
 				litsym(n, e.Expr, int(n.Type.Width))
 				continue
 			}
-			ll := n.sepcopy()
+			ll := ir.SepCopy(n)
 			if s.staticcopy(ll, e.Expr) {
 				continue
 			}
 			// Requires computation, but we're
 			// copying someone else's computation.
-			rr := orig.sepcopy()
+			rr := ir.SepCopy(orig)
 			rr.Type = ll.Type
 			rr.Xoffset += e.Xoffset
 			setlineno(rr)
-			s.append(nod(OAS, ll, rr))
+			s.append(ir.Nod(ir.OAS, ll, rr))
 		}
 
 		return true
@@ -167,35 +168,35 @@ func (s *InitSchedule) staticcopy(l *Node, r *Node) bool {
 	return false
 }
 
-func (s *InitSchedule) staticassign(l *Node, r *Node) bool {
-	for r.Op == OCONVNOP {
+func (s *InitSchedule) staticassign(l *ir.Node, r *ir.Node) bool {
+	for r.Op == ir.OCONVNOP {
 		r = r.Left
 	}
 
 	switch r.Op {
-	case ONAME, OMETHEXPR:
+	case ir.ONAME, ir.OMETHEXPR:
 		return s.staticcopy(l, r)
 
-	case ONIL:
+	case ir.ONIL:
 		return true
 
-	case OLITERAL:
+	case ir.OLITERAL:
 		if isZero(r) {
 			return true
 		}
 		litsym(l, r, int(l.Type.Width))
 		return true
 
-	case OADDR:
+	case ir.OADDR:
 		if nam := stataddr(r.Left); nam != nil {
 			addrsym(l, nam)
 			return true
 		}
 		fallthrough
 
-	case OPTRLIT:
+	case ir.OPTRLIT:
 		switch r.Left.Op {
-		case OARRAYLIT, OSLICELIT, OMAPLIT, OSTRUCTLIT:
+		case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT, ir.OSTRUCTLIT:
 			// Init pointer.
 			a := staticname(r.Left.Type)
 
@@ -204,20 +205,20 @@ func (s *InitSchedule) staticassign(l *Node, r *Node) bool {
 
 			// Init underlying literal.
 			if !s.staticassign(a, r.Left) {
-				s.append(nod(OAS, a, r.Left))
+				s.append(ir.Nod(ir.OAS, a, r.Left))
 			}
 			return true
 		}
 		//dump("not static ptrlit", r);
 
-	case OSTR2BYTES:
-		if l.Class() == PEXTERN && r.Left.Op == OLITERAL {
+	case ir.OSTR2BYTES:
+		if l.Class() == ir.PEXTERN && r.Left.Op == ir.OLITERAL {
 			sval := r.Left.StringVal()
 			slicebytes(l, sval)
 			return true
 		}
 
-	case OSLICELIT:
+	case ir.OSLICELIT:
 		s.initplan(r)
 		// Init slice.
 		bound := r.Right.Int64Val()
@@ -230,32 +231,32 @@ func (s *InitSchedule) staticassign(l *Node, r *Node) bool {
 		l = a
 		fallthrough
 
-	case OARRAYLIT, OSTRUCTLIT:
+	case ir.OARRAYLIT, ir.OSTRUCTLIT:
 		s.initplan(r)
 
 		p := s.initplans[r]
-		n := l.copy()
+		n := ir.Copy(l)
 		for i := range p.E {
 			e := &p.E[i]
 			n.Xoffset = l.Xoffset + e.Xoffset
 			n.Type = e.Expr.Type
-			if e.Expr.Op == OLITERAL || e.Expr.Op == ONIL {
+			if e.Expr.Op == ir.OLITERAL || e.Expr.Op == ir.ONIL {
 				litsym(n, e.Expr, int(n.Type.Width))
 				continue
 			}
 			setlineno(e.Expr)
-			a := n.sepcopy()
+			a := ir.SepCopy(n)
 			if !s.staticassign(a, e.Expr) {
-				s.append(nod(OAS, a, e.Expr))
+				s.append(ir.Nod(ir.OAS, a, e.Expr))
 			}
 		}
 
 		return true
 
-	case OMAPLIT:
+	case ir.OMAPLIT:
 		break
 
-	case OCLOSURE:
+	case ir.OCLOSURE:
 		if hasemptycvars(r) {
 			if base.Debug.Closure > 0 {
 				base.WarnfAt(r.Pos, "closure converted to global")
@@ -267,13 +268,13 @@ func (s *InitSchedule) staticassign(l *Node, r *Node) bool {
 		}
 		closuredebugruntimecheck(r)
 
-	case OCONVIFACE:
+	case ir.OCONVIFACE:
 		// This logic is mirrored in isStaticCompositeLiteral.
 		// If you change something here, change it there, and vice versa.
 
 		// Determine the underlying concrete type and value we are converting from.
 		val := r
-		for val.Op == OCONVIFACE {
+		for val.Op == ir.OCONVIFACE {
 			val = val.Left
 		}
 
@@ -283,12 +284,12 @@ func (s *InitSchedule) staticassign(l *Node, r *Node) bool {
 			// both words are zero and so there no work to do, so report success.
 			// If val is non-nil, we have no concrete type to record,
 			// and we won't be able to statically initialize its value, so report failure.
-			return val.Op == ONIL
+			return val.Op == ir.ONIL
 		}
 
 		markTypeUsedInInterface(val.Type, l.Sym.Linksym())
 
-		var itab *Node
+		var itab *ir.Node
 		if l.Type.IsEmptyInterface() {
 			itab = typename(val.Type)
 		} else {
@@ -296,7 +297,7 @@ func (s *InitSchedule) staticassign(l *Node, r *Node) bool {
 		}
 
 		// Create a copy of l to modify while we emit data.
-		n := l.copy()
+		n := ir.Copy(l)
 
 		// Emit itab, advance offset.
 		addrsym(n, itab.Left) // itab is an OADDR node
@@ -304,23 +305,23 @@ func (s *InitSchedule) staticassign(l *Node, r *Node) bool {
 
 		// Emit data.
 		if isdirectiface(val.Type) {
-			if val.Op == ONIL {
+			if val.Op == ir.ONIL {
 				// Nil is zero, nothing to do.
 				return true
 			}
 			// Copy val directly into n.
 			n.Type = val.Type
 			setlineno(val)
-			a := n.sepcopy()
+			a := ir.SepCopy(n)
 			if !s.staticassign(a, val) {
-				s.append(nod(OAS, a, val))
+				s.append(ir.Nod(ir.OAS, a, val))
 			}
 		} else {
 			// Construct temp to hold val, write pointer to temp into n.
 			a := staticname(val.Type)
 			s.inittemps[val] = a
 			if !s.staticassign(a, val) {
-				s.append(nod(OAS, a, val))
+				s.append(ir.Nod(ir.OAS, a, val))
 			}
 			addrsym(n, a)
 		}
@@ -366,29 +367,29 @@ var statuniqgen int // name generator for static temps
 
 // staticname returns a name backed by a (writable) static data symbol.
 // Use readonlystaticname for read-only node.
-func staticname(t *types.Type) *Node {
+func staticname(t *types.Type) *ir.Node {
 	// Don't use lookupN; it interns the resulting string, but these are all unique.
-	n := newname(lookup(fmt.Sprintf("%s%d", obj.StaticNamePref, statuniqgen)))
+	n := NewName(lookup(fmt.Sprintf("%s%d", obj.StaticNamePref, statuniqgen)))
 	statuniqgen++
-	addvar(n, t, PEXTERN)
+	addvar(n, t, ir.PEXTERN)
 	n.Sym.Linksym().Set(obj.AttrLocal, true)
 	return n
 }
 
 // readonlystaticname returns a name backed by a (writable) static data symbol.
-func readonlystaticname(t *types.Type) *Node {
+func readonlystaticname(t *types.Type) *ir.Node {
 	n := staticname(t)
 	n.MarkReadonly()
 	n.Sym.Linksym().Set(obj.AttrContentAddressable, true)
 	return n
 }
 
-func (n *Node) isSimpleName() bool {
-	return (n.Op == ONAME || n.Op == OMETHEXPR) && n.Class() != PAUTOHEAP && n.Class() != PEXTERN
+func isSimpleName(n *ir.Node) bool {
+	return (n.Op == ir.ONAME || n.Op == ir.OMETHEXPR) && n.Class() != ir.PAUTOHEAP && n.Class() != ir.PEXTERN
 }
 
-func litas(l *Node, r *Node, init *Nodes) {
-	a := nod(OAS, l, r)
+func litas(l *ir.Node, r *ir.Node, init *ir.Nodes) {
+	a := ir.Nod(ir.OAS, l, r)
 	a = typecheck(a, ctxStmt)
 	a = walkexpr(a, init)
 	init.Append(a)
@@ -404,15 +405,15 @@ const (
 
 // getdyn calculates the initGenType for n.
 // If top is false, getdyn is recursing.
-func getdyn(n *Node, top bool) initGenType {
+func getdyn(n *ir.Node, top bool) initGenType {
 	switch n.Op {
 	default:
-		if n.isGoConst() {
+		if isGoConst(n) {
 			return initConst
 		}
 		return initDynamic
 
-	case OSLICELIT:
+	case ir.OSLICELIT:
 		if !top {
 			return initDynamic
 		}
@@ -426,15 +427,15 @@ func getdyn(n *Node, top bool) initGenType {
 			return initDynamic
 		}
 
-	case OARRAYLIT, OSTRUCTLIT:
+	case ir.OARRAYLIT, ir.OSTRUCTLIT:
 	}
 
 	var mode initGenType
 	for _, n1 := range n.List.Slice() {
 		switch n1.Op {
-		case OKEY:
+		case ir.OKEY:
 			n1 = n1.Right
-		case OSTRUCTKEY:
+		case ir.OSTRUCTKEY:
 			n1 = n1.Left
 		}
 		mode |= getdyn(n1, false)
@@ -446,13 +447,13 @@ func getdyn(n *Node, top bool) initGenType {
 }
 
 // isStaticCompositeLiteral reports whether n is a compile-time constant.
-func isStaticCompositeLiteral(n *Node) bool {
+func isStaticCompositeLiteral(n *ir.Node) bool {
 	switch n.Op {
-	case OSLICELIT:
+	case ir.OSLICELIT:
 		return false
-	case OARRAYLIT:
+	case ir.OARRAYLIT:
 		for _, r := range n.List.Slice() {
-			if r.Op == OKEY {
+			if r.Op == ir.OKEY {
 				r = r.Right
 			}
 			if !isStaticCompositeLiteral(r) {
@@ -460,9 +461,9 @@ func isStaticCompositeLiteral(n *Node) bool {
 			}
 		}
 		return true
-	case OSTRUCTLIT:
+	case ir.OSTRUCTLIT:
 		for _, r := range n.List.Slice() {
-			if r.Op != OSTRUCTKEY {
+			if r.Op != ir.OSTRUCTKEY {
 				base.Fatalf("isStaticCompositeLiteral: rhs not OSTRUCTKEY: %v", r)
 			}
 			if !isStaticCompositeLiteral(r.Left) {
@@ -470,18 +471,18 @@ func isStaticCompositeLiteral(n *Node) bool {
 			}
 		}
 		return true
-	case OLITERAL, ONIL:
+	case ir.OLITERAL, ir.ONIL:
 		return true
-	case OCONVIFACE:
+	case ir.OCONVIFACE:
 		// See staticassign's OCONVIFACE case for comments.
 		val := n
-		for val.Op == OCONVIFACE {
+		for val.Op == ir.OCONVIFACE {
 			val = val.Left
 		}
 		if val.Type.IsInterface() {
-			return val.Op == ONIL
+			return val.Op == ir.ONIL
 		}
-		if isdirectiface(val.Type) && val.Op == ONIL {
+		if isdirectiface(val.Type) && val.Op == ir.ONIL {
 			return true
 		}
 		return isStaticCompositeLiteral(val)
@@ -508,37 +509,37 @@ const (
 
 // fixedlit handles struct, array, and slice literals.
 // TODO: expand documentation.
-func fixedlit(ctxt initContext, kind initKind, n *Node, var_ *Node, init *Nodes) {
-	isBlank := var_ == nblank
-	var splitnode func(*Node) (a *Node, value *Node)
+func fixedlit(ctxt initContext, kind initKind, n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
+	isBlank := var_ == ir.BlankNode
+	var splitnode func(*ir.Node) (a *ir.Node, value *ir.Node)
 	switch n.Op {
-	case OARRAYLIT, OSLICELIT:
+	case ir.OARRAYLIT, ir.OSLICELIT:
 		var k int64
-		splitnode = func(r *Node) (*Node, *Node) {
-			if r.Op == OKEY {
+		splitnode = func(r *ir.Node) (*ir.Node, *ir.Node) {
+			if r.Op == ir.OKEY {
 				k = indexconst(r.Left)
 				if k < 0 {
 					base.Fatalf("fixedlit: invalid index %v", r.Left)
 				}
 				r = r.Right
 			}
-			a := nod(OINDEX, var_, nodintconst(k))
+			a := ir.Nod(ir.OINDEX, var_, nodintconst(k))
 			k++
 			if isBlank {
-				a = nblank
+				a = ir.BlankNode
 			}
 			return a, r
 		}
-	case OSTRUCTLIT:
-		splitnode = func(r *Node) (*Node, *Node) {
-			if r.Op != OSTRUCTKEY {
+	case ir.OSTRUCTLIT:
+		splitnode = func(r *ir.Node) (*ir.Node, *ir.Node) {
+			if r.Op != ir.OSTRUCTKEY {
 				base.Fatalf("fixedlit: rhs not OSTRUCTKEY: %v", r)
 			}
 			if r.Sym.IsBlank() || isBlank {
-				return nblank, r.Left
+				return ir.BlankNode, r.Left
 			}
 			setlineno(r)
-			return nodSym(ODOT, var_, r.Sym), r.Left
+			return nodSym(ir.ODOT, var_, r.Sym), r.Left
 		}
 	default:
 		base.Fatalf("fixedlit bad op: %v", n.Op)
@@ -546,36 +547,36 @@ func fixedlit(ctxt initContext, kind initKind, n *Node, var_ *Node, init *Nodes)
 
 	for _, r := range n.List.Slice() {
 		a, value := splitnode(r)
-		if a == nblank && candiscard(value) {
+		if a == ir.BlankNode && candiscard(value) {
 			continue
 		}
 
 		switch value.Op {
-		case OSLICELIT:
+		case ir.OSLICELIT:
 			if (kind == initKindStatic && ctxt == inNonInitFunction) || (kind == initKindDynamic && ctxt == inInitFunction) {
 				slicelit(ctxt, value, a, init)
 				continue
 			}
 
-		case OARRAYLIT, OSTRUCTLIT:
+		case ir.OARRAYLIT, ir.OSTRUCTLIT:
 			fixedlit(ctxt, kind, value, a, init)
 			continue
 		}
 
-		islit := value.isGoConst()
+		islit := isGoConst(value)
 		if (kind == initKindStatic && !islit) || (kind == initKindDynamic && islit) {
 			continue
 		}
 
 		// build list of assignments: var[index] = expr
 		setlineno(a)
-		a = nod(OAS, a, value)
+		a = ir.Nod(ir.OAS, a, value)
 		a = typecheck(a, ctxStmt)
 		switch kind {
 		case initKindStatic:
 			genAsStatic(a)
 		case initKindDynamic, initKindLocalCode:
-			a = orderStmtInPlace(a, map[string][]*Node{})
+			a = orderStmtInPlace(a, map[string][]*ir.Node{})
 			a = walkstmt(a)
 			init.Append(a)
 		default:
@@ -585,8 +586,8 @@ func fixedlit(ctxt initContext, kind initKind, n *Node, var_ *Node, init *Nodes)
 	}
 }
 
-func isSmallSliceLit(n *Node) bool {
-	if n.Op != OSLICELIT {
+func isSmallSliceLit(n *ir.Node) bool {
+	if n.Op != ir.OSLICELIT {
 		return false
 	}
 
@@ -595,7 +596,7 @@ func isSmallSliceLit(n *Node) bool {
 	return smallintconst(r) && (n.Type.Elem().Width == 0 || r.Int64Val() <= smallArrayBytes/n.Type.Elem().Width)
 }
 
-func slicelit(ctxt initContext, n *Node, var_ *Node, init *Nodes) {
+func slicelit(ctxt initContext, n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
 	// make an array type corresponding the number of elements we have
 	t := types.NewArray(n.Type.Elem(), n.Right.Int64Val())
 	dowidth(t)
@@ -610,7 +611,7 @@ func slicelit(ctxt initContext, n *Node, var_ *Node, init *Nodes) {
 		// copy static to slice
 		var_ = typecheck(var_, ctxExpr|ctxAssign)
 		nam := stataddr(var_)
-		if nam == nil || nam.Class() != PEXTERN {
+		if nam == nil || nam.Class() != ir.PEXTERN {
 			base.Fatalf("slicelit: %v", var_)
 		}
 		slicesym(nam, vstat, t.NumElem())
@@ -638,7 +639,7 @@ func slicelit(ctxt initContext, n *Node, var_ *Node, init *Nodes) {
 
 	// if the literal contains constants,
 	// make static initialized array (1),(2)
-	var vstat *Node
+	var vstat *ir.Node
 
 	mode := getdyn(n, true)
 	if mode&initConst != 0 && !isSmallSliceLit(n) {
@@ -654,7 +655,7 @@ func slicelit(ctxt initContext, n *Node, var_ *Node, init *Nodes) {
 	vauto := temp(types.NewPtr(t))
 
 	// set auto to point at new temp or heap (3 assign)
-	var a *Node
+	var a *ir.Node
 	if x := prealloc[n]; x != nil {
 		// temp allocated during order.go for dddarg
 		if !types.Identical(t, x.Type) {
@@ -662,43 +663,43 @@ func slicelit(ctxt initContext, n *Node, var_ *Node, init *Nodes) {
 		}
 
 		if vstat == nil {
-			a = nod(OAS, x, nil)
+			a = ir.Nod(ir.OAS, x, nil)
 			a = typecheck(a, ctxStmt)
 			init.Append(a) // zero new temp
 		} else {
 			// Declare that we're about to initialize all of x.
 			// (Which happens at the *vauto = vstat below.)
-			init.Append(nod(OVARDEF, x, nil))
+			init.Append(ir.Nod(ir.OVARDEF, x, nil))
 		}
 
-		a = nod(OADDR, x, nil)
+		a = ir.Nod(ir.OADDR, x, nil)
 	} else if n.Esc == EscNone {
 		a = temp(t)
 		if vstat == nil {
-			a = nod(OAS, temp(t), nil)
+			a = ir.Nod(ir.OAS, temp(t), nil)
 			a = typecheck(a, ctxStmt)
 			init.Append(a) // zero new temp
 			a = a.Left
 		} else {
-			init.Append(nod(OVARDEF, a, nil))
+			init.Append(ir.Nod(ir.OVARDEF, a, nil))
 		}
 
-		a = nod(OADDR, a, nil)
+		a = ir.Nod(ir.OADDR, a, nil)
 	} else {
-		a = nod(ONEW, nil, nil)
+		a = ir.Nod(ir.ONEW, nil, nil)
 		a.List.Set1(typenod(t))
 	}
 
-	a = nod(OAS, vauto, a)
+	a = ir.Nod(ir.OAS, vauto, a)
 	a = typecheck(a, ctxStmt)
 	a = walkexpr(a, init)
 	init.Append(a)
 
 	if vstat != nil {
 		// copy static to heap (4)
-		a = nod(ODEREF, vauto, nil)
+		a = ir.Nod(ir.ODEREF, vauto, nil)
 
-		a = nod(OAS, a, vstat)
+		a = ir.Nod(ir.OAS, a, vstat)
 		a = typecheck(a, ctxStmt)
 		a = walkexpr(a, init)
 		init.Append(a)
@@ -707,24 +708,24 @@ func slicelit(ctxt initContext, n *Node, var_ *Node, init *Nodes) {
 	// put dynamics into array (5)
 	var index int64
 	for _, value := range n.List.Slice() {
-		if value.Op == OKEY {
+		if value.Op == ir.OKEY {
 			index = indexconst(value.Left)
 			if index < 0 {
 				base.Fatalf("slicelit: invalid index %v", value.Left)
 			}
 			value = value.Right
 		}
-		a := nod(OINDEX, vauto, nodintconst(index))
+		a := ir.Nod(ir.OINDEX, vauto, nodintconst(index))
 		a.SetBounded(true)
 		index++
 
 		// TODO need to check bounds?
 
 		switch value.Op {
-		case OSLICELIT:
+		case ir.OSLICELIT:
 			break
 
-		case OARRAYLIT, OSTRUCTLIT:
+		case ir.OARRAYLIT, ir.OSTRUCTLIT:
 			k := initKindDynamic
 			if vstat == nil {
 				// Generate both static and dynamic initializations.
@@ -735,32 +736,32 @@ func slicelit(ctxt initContext, n *Node, var_ *Node, init *Nodes) {
 			continue
 		}
 
-		if vstat != nil && value.isGoConst() { // already set by copy from static value
+		if vstat != nil && isGoConst(value) { // already set by copy from static value
 			continue
 		}
 
 		// build list of vauto[c] = expr
 		setlineno(value)
-		a = nod(OAS, a, value)
+		a = ir.Nod(ir.OAS, a, value)
 
 		a = typecheck(a, ctxStmt)
-		a = orderStmtInPlace(a, map[string][]*Node{})
+		a = orderStmtInPlace(a, map[string][]*ir.Node{})
 		a = walkstmt(a)
 		init.Append(a)
 	}
 
 	// make slice out of heap (6)
-	a = nod(OAS, var_, nod(OSLICE, vauto, nil))
+	a = ir.Nod(ir.OAS, var_, ir.Nod(ir.OSLICE, vauto, nil))
 
 	a = typecheck(a, ctxStmt)
-	a = orderStmtInPlace(a, map[string][]*Node{})
+	a = orderStmtInPlace(a, map[string][]*ir.Node{})
 	a = walkstmt(a)
 	init.Append(a)
 }
 
-func maplit(n *Node, m *Node, init *Nodes) {
+func maplit(n *ir.Node, m *ir.Node, init *ir.Nodes) {
 	// make the map var
-	a := nod(OMAKE, nil, nil)
+	a := ir.Nod(ir.OMAKE, nil, nil)
 	a.Esc = n.Esc
 	a.List.Set2(typenod(n.Type), nodintconst(int64(n.List.Len())))
 	litas(m, a, init)
@@ -792,8 +793,8 @@ func maplit(n *Node, m *Node, init *Nodes) {
 		vstatk := readonlystaticname(tk)
 		vstate := readonlystaticname(te)
 
-		datak := nod(OARRAYLIT, nil, nil)
-		datae := nod(OARRAYLIT, nil, nil)
+		datak := ir.Nod(ir.OARRAYLIT, nil, nil)
+		datae := ir.Nod(ir.OARRAYLIT, nil, nil)
 		for _, r := range entries {
 			datak.List.Append(r.Left)
 			datae.List.Append(r.Right)
@@ -805,20 +806,20 @@ func maplit(n *Node, m *Node, init *Nodes) {
 		// for i = 0; i < len(vstatk); i++ {
 		//	map[vstatk[i]] = vstate[i]
 		// }
-		i := temp(types.Types[TINT])
-		rhs := nod(OINDEX, vstate, i)
+		i := temp(types.Types[types.TINT])
+		rhs := ir.Nod(ir.OINDEX, vstate, i)
 		rhs.SetBounded(true)
 
-		kidx := nod(OINDEX, vstatk, i)
+		kidx := ir.Nod(ir.OINDEX, vstatk, i)
 		kidx.SetBounded(true)
-		lhs := nod(OINDEX, m, kidx)
+		lhs := ir.Nod(ir.OINDEX, m, kidx)
 
-		zero := nod(OAS, i, nodintconst(0))
-		cond := nod(OLT, i, nodintconst(tk.NumElem()))
-		incr := nod(OAS, i, nod(OADD, i, nodintconst(1)))
-		body := nod(OAS, lhs, rhs)
+		zero := ir.Nod(ir.OAS, i, nodintconst(0))
+		cond := ir.Nod(ir.OLT, i, nodintconst(tk.NumElem()))
+		incr := ir.Nod(ir.OAS, i, ir.Nod(ir.OADD, i, nodintconst(1)))
+		body := ir.Nod(ir.OAS, lhs, rhs)
 
-		loop := nod(OFOR, cond, incr)
+		loop := ir.Nod(ir.OFOR, cond, incr)
 		loop.Nbody.Set1(body)
 		loop.Ninit.Set1(zero)
 
@@ -839,88 +840,88 @@ func maplit(n *Node, m *Node, init *Nodes) {
 		index, elem := r.Left, r.Right
 
 		setlineno(index)
-		a := nod(OAS, tmpkey, index)
+		a := ir.Nod(ir.OAS, tmpkey, index)
 		a = typecheck(a, ctxStmt)
 		a = walkstmt(a)
 		init.Append(a)
 
 		setlineno(elem)
-		a = nod(OAS, tmpelem, elem)
+		a = ir.Nod(ir.OAS, tmpelem, elem)
 		a = typecheck(a, ctxStmt)
 		a = walkstmt(a)
 		init.Append(a)
 
 		setlineno(tmpelem)
-		a = nod(OAS, nod(OINDEX, m, tmpkey), tmpelem)
+		a = ir.Nod(ir.OAS, ir.Nod(ir.OINDEX, m, tmpkey), tmpelem)
 		a = typecheck(a, ctxStmt)
 		a = walkstmt(a)
 		init.Append(a)
 	}
 
-	a = nod(OVARKILL, tmpkey, nil)
+	a = ir.Nod(ir.OVARKILL, tmpkey, nil)
 	a = typecheck(a, ctxStmt)
 	init.Append(a)
-	a = nod(OVARKILL, tmpelem, nil)
+	a = ir.Nod(ir.OVARKILL, tmpelem, nil)
 	a = typecheck(a, ctxStmt)
 	init.Append(a)
 }
 
-func anylit(n *Node, var_ *Node, init *Nodes) {
+func anylit(n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
 	t := n.Type
 	switch n.Op {
 	default:
 		base.Fatalf("anylit: not lit, op=%v node=%v", n.Op, n)
 
-	case ONAME, OMETHEXPR:
-		a := nod(OAS, var_, n)
+	case ir.ONAME, ir.OMETHEXPR:
+		a := ir.Nod(ir.OAS, var_, n)
 		a = typecheck(a, ctxStmt)
 		init.Append(a)
 
-	case OPTRLIT:
+	case ir.OPTRLIT:
 		if !t.IsPtr() {
 			base.Fatalf("anylit: not ptr")
 		}
 
-		var r *Node
+		var r *ir.Node
 		if n.Right != nil {
 			// n.Right is stack temporary used as backing store.
-			init.Append(nod(OAS, n.Right, nil)) // zero backing store, just in case (#18410)
-			r = nod(OADDR, n.Right, nil)
+			init.Append(ir.Nod(ir.OAS, n.Right, nil)) // zero backing store, just in case (#18410)
+			r = ir.Nod(ir.OADDR, n.Right, nil)
 			r = typecheck(r, ctxExpr)
 		} else {
-			r = nod(ONEW, nil, nil)
+			r = ir.Nod(ir.ONEW, nil, nil)
 			r.SetTypecheck(1)
 			r.Type = t
 			r.Esc = n.Esc
 		}
 
 		r = walkexpr(r, init)
-		a := nod(OAS, var_, r)
+		a := ir.Nod(ir.OAS, var_, r)
 
 		a = typecheck(a, ctxStmt)
 		init.Append(a)
 
-		var_ = nod(ODEREF, var_, nil)
+		var_ = ir.Nod(ir.ODEREF, var_, nil)
 		var_ = typecheck(var_, ctxExpr|ctxAssign)
 		anylit(n.Left, var_, init)
 
-	case OSTRUCTLIT, OARRAYLIT:
+	case ir.OSTRUCTLIT, ir.OARRAYLIT:
 		if !t.IsStruct() && !t.IsArray() {
 			base.Fatalf("anylit: not struct/array")
 		}
 
-		if var_.isSimpleName() && n.List.Len() > 4 {
+		if isSimpleName(var_) && n.List.Len() > 4 {
 			// lay out static data
 			vstat := readonlystaticname(t)
 
 			ctxt := inInitFunction
-			if n.Op == OARRAYLIT {
+			if n.Op == ir.OARRAYLIT {
 				ctxt = inNonInitFunction
 			}
 			fixedlit(ctxt, initKindStatic, n, vstat, init)
 
 			// copy static to var
-			a := nod(OAS, var_, vstat)
+			a := ir.Nod(ir.OAS, var_, vstat)
 
 			a = typecheck(a, ctxStmt)
 			a = walkexpr(a, init)
@@ -932,14 +933,14 @@ func anylit(n *Node, var_ *Node, init *Nodes) {
 		}
 
 		var components int64
-		if n.Op == OARRAYLIT {
+		if n.Op == ir.OARRAYLIT {
 			components = t.NumElem()
 		} else {
 			components = int64(t.NumFields())
 		}
 		// initialization of an array or struct with unspecified components (missing fields or arrays)
-		if var_.isSimpleName() || int64(n.List.Len()) < components {
-			a := nod(OAS, var_, nil)
+		if isSimpleName(var_) || int64(n.List.Len()) < components {
+			a := ir.Nod(ir.OAS, var_, nil)
 			a = typecheck(a, ctxStmt)
 			a = walkexpr(a, init)
 			init.Append(a)
@@ -947,10 +948,10 @@ func anylit(n *Node, var_ *Node, init *Nodes) {
 
 		fixedlit(inInitFunction, initKindLocalCode, n, var_, init)
 
-	case OSLICELIT:
+	case ir.OSLICELIT:
 		slicelit(inInitFunction, n, var_, init)
 
-	case OMAPLIT:
+	case ir.OMAPLIT:
 		if !t.IsMap() {
 			base.Fatalf("anylit: not map")
 		}
@@ -958,7 +959,7 @@ func anylit(n *Node, var_ *Node, init *Nodes) {
 	}
 }
 
-func oaslit(n *Node, init *Nodes) bool {
+func oaslit(n *ir.Node, init *ir.Nodes) bool {
 	if n.Left == nil || n.Right == nil {
 		// not a special composite literal assignment
 		return false
@@ -967,7 +968,7 @@ func oaslit(n *Node, init *Nodes) bool {
 		// not a special composite literal assignment
 		return false
 	}
-	if !n.Left.isSimpleName() {
+	if !isSimpleName(n.Left) {
 		// not a special composite literal assignment
 		return false
 	}
@@ -981,7 +982,7 @@ func oaslit(n *Node, init *Nodes) bool {
 		// not a special composite literal assignment
 		return false
 
-	case OSTRUCTLIT, OARRAYLIT, OSLICELIT, OMAPLIT:
+	case ir.OSTRUCTLIT, ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT:
 		if vmatch1(n.Left, n.Right) {
 			// not a special composite literal assignment
 			return false
@@ -989,12 +990,12 @@ func oaslit(n *Node, init *Nodes) bool {
 		anylit(n.Right, n.Left, init)
 	}
 
-	n.Op = OEMPTY
+	n.Op = ir.OEMPTY
 	n.Right = nil
 	return true
 }
 
-func getlit(lit *Node) int {
+func getlit(lit *ir.Node) int {
 	if smallintconst(lit) {
 		return int(lit.Int64Val())
 	}
@@ -1002,16 +1003,16 @@ func getlit(lit *Node) int {
 }
 
 // stataddr returns the static address of n, if n has one, or else nil.
-func stataddr(n *Node) *Node {
+func stataddr(n *ir.Node) *ir.Node {
 	if n == nil {
 		return nil
 	}
 
 	switch n.Op {
-	case ONAME, OMETHEXPR:
-		return n.sepcopy()
+	case ir.ONAME, ir.OMETHEXPR:
+		return ir.SepCopy(n)
 
-	case ODOT:
+	case ir.ODOT:
 		nam := stataddr(n.Left)
 		if nam == nil {
 			break
@@ -1020,7 +1021,7 @@ func stataddr(n *Node) *Node {
 		nam.Type = n.Type
 		return nam
 
-	case OINDEX:
+	case ir.OINDEX:
 		if n.Left.Type.IsSlice() {
 			break
 		}
@@ -1045,7 +1046,7 @@ func stataddr(n *Node) *Node {
 	return nil
 }
 
-func (s *InitSchedule) initplan(n *Node) {
+func (s *InitSchedule) initplan(n *ir.Node) {
 	if s.initplans[n] != nil {
 		return
 	}
@@ -1055,10 +1056,10 @@ func (s *InitSchedule) initplan(n *Node) {
 	default:
 		base.Fatalf("initplan")
 
-	case OARRAYLIT, OSLICELIT:
+	case ir.OARRAYLIT, ir.OSLICELIT:
 		var k int64
 		for _, a := range n.List.Slice() {
-			if a.Op == OKEY {
+			if a.Op == ir.OKEY {
 				k = indexconst(a.Left)
 				if k < 0 {
 					base.Fatalf("initplan arraylit: invalid index %v", a.Left)
@@ -1069,9 +1070,9 @@ func (s *InitSchedule) initplan(n *Node) {
 			k++
 		}
 
-	case OSTRUCTLIT:
+	case ir.OSTRUCTLIT:
 		for _, a := range n.List.Slice() {
-			if a.Op != OSTRUCTKEY {
+			if a.Op != ir.OSTRUCTKEY {
 				base.Fatalf("initplan structlit")
 			}
 			if a.Sym.IsBlank() {
@@ -1080,9 +1081,9 @@ func (s *InitSchedule) initplan(n *Node) {
 			s.addvalue(p, a.Xoffset, a.Left)
 		}
 
-	case OMAPLIT:
+	case ir.OMAPLIT:
 		for _, a := range n.List.Slice() {
-			if a.Op != OKEY {
+			if a.Op != ir.OKEY {
 				base.Fatalf("initplan maplit")
 			}
 			s.addvalue(p, -1, a.Right)
@@ -1090,7 +1091,7 @@ func (s *InitSchedule) initplan(n *Node) {
 	}
 }
 
-func (s *InitSchedule) addvalue(p *InitPlan, xoffset int64, n *Node) {
+func (s *InitSchedule) addvalue(p *InitPlan, xoffset int64, n *ir.Node) {
 	// special case: zero can be dropped entirely
 	if isZero(n) {
 		return
@@ -1112,12 +1113,12 @@ func (s *InitSchedule) addvalue(p *InitPlan, xoffset int64, n *Node) {
 	p.E = append(p.E, InitEntry{Xoffset: xoffset, Expr: n})
 }
 
-func isZero(n *Node) bool {
+func isZero(n *ir.Node) bool {
 	switch n.Op {
-	case ONIL:
+	case ir.ONIL:
 		return true
 
-	case OLITERAL:
+	case ir.OLITERAL:
 		switch u := n.Val(); u.Kind() {
 		case constant.String:
 			return constant.StringVal(u) == ""
@@ -1127,9 +1128,9 @@ func isZero(n *Node) bool {
 			return constant.Sign(u) == 0
 		}
 
-	case OARRAYLIT:
+	case ir.OARRAYLIT:
 		for _, n1 := range n.List.Slice() {
-			if n1.Op == OKEY {
+			if n1.Op == ir.OKEY {
 				n1 = n1.Right
 			}
 			if !isZero(n1) {
@@ -1138,7 +1139,7 @@ func isZero(n *Node) bool {
 		}
 		return true
 
-	case OSTRUCTLIT:
+	case ir.OSTRUCTLIT:
 		for _, n1 := range n.List.Slice() {
 			if !isZero(n1.Left) {
 				return false
@@ -1150,24 +1151,24 @@ func isZero(n *Node) bool {
 	return false
 }
 
-func isvaluelit(n *Node) bool {
-	return n.Op == OARRAYLIT || n.Op == OSTRUCTLIT
+func isvaluelit(n *ir.Node) bool {
+	return n.Op == ir.OARRAYLIT || n.Op == ir.OSTRUCTLIT
 }
 
-func genAsStatic(as *Node) {
+func genAsStatic(as *ir.Node) {
 	if as.Left.Type == nil {
 		base.Fatalf("genAsStatic as.Left not typechecked")
 	}
 
 	nam := stataddr(as.Left)
-	if nam == nil || (nam.Class() != PEXTERN && as.Left != nblank) {
+	if nam == nil || (nam.Class() != ir.PEXTERN && as.Left != ir.BlankNode) {
 		base.Fatalf("genAsStatic: lhs %v", as.Left)
 	}
 
 	switch {
-	case as.Right.Op == OLITERAL:
+	case as.Right.Op == ir.OLITERAL:
 		litsym(nam, as.Right, int(as.Right.Type.Width))
-	case (as.Right.Op == ONAME || as.Right.Op == OMETHEXPR) && as.Right.Class() == PFUNC:
+	case (as.Right.Op == ir.ONAME || as.Right.Op == ir.OMETHEXPR) && as.Right.Class() == ir.PFUNC:
 		pfuncsym(nam, as.Right)
 	default:
 		base.Fatalf("genAsStatic: rhs %v", as.Right)
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index e892a01da0..658ea28fbe 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -16,6 +16,7 @@ import (
 	"bufio"
 	"bytes"
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -39,7 +40,7 @@ const ssaDumpFile = "ssa.html"
 const maxOpenDefers = 8
 
 // ssaDumpInlined holds all inlined functions when ssaDump contains a function name.
-var ssaDumpInlined []*Node
+var ssaDumpInlined []*ir.Node
 
 func initssaconfig() {
 	types_ := ssa.NewTypes()
@@ -50,16 +51,16 @@ func initssaconfig() {
 
 	// Generate a few pointer types that are uncommon in the frontend but common in the backend.
 	// Caching is disabled in the backend, so generating these here avoids allocations.
-	_ = types.NewPtr(types.Types[TINTER])                             // *interface{}
-	_ = types.NewPtr(types.NewPtr(types.Types[TSTRING]))              // **string
-	_ = types.NewPtr(types.NewSlice(types.Types[TINTER]))             // *[]interface{}
-	_ = types.NewPtr(types.NewPtr(types.Bytetype))                    // **byte
-	_ = types.NewPtr(types.NewSlice(types.Bytetype))                  // *[]byte
-	_ = types.NewPtr(types.NewSlice(types.Types[TSTRING]))            // *[]string
-	_ = types.NewPtr(types.NewPtr(types.NewPtr(types.Types[TUINT8]))) // ***uint8
-	_ = types.NewPtr(types.Types[TINT16])                             // *int16
-	_ = types.NewPtr(types.Types[TINT64])                             // *int64
-	_ = types.NewPtr(types.Errortype)                                 // *error
+	_ = types.NewPtr(types.Types[types.TINTER])                             // *interface{}
+	_ = types.NewPtr(types.NewPtr(types.Types[types.TSTRING]))              // **string
+	_ = types.NewPtr(types.NewSlice(types.Types[types.TINTER]))             // *[]interface{}
+	_ = types.NewPtr(types.NewPtr(types.Bytetype))                          // **byte
+	_ = types.NewPtr(types.NewSlice(types.Bytetype))                        // *[]byte
+	_ = types.NewPtr(types.NewSlice(types.Types[types.TSTRING]))            // *[]string
+	_ = types.NewPtr(types.NewPtr(types.NewPtr(types.Types[types.TUINT8]))) // ***uint8
+	_ = types.NewPtr(types.Types[types.TINT16])                             // *int16
+	_ = types.NewPtr(types.Types[types.TINT64])                             // *int64
+	_ = types.NewPtr(types.Errortype)                                       // *error
 	types.NewPtrCacheEnabled = false
 	ssaConfig = ssa.NewConfig(thearch.LinkArch.Name, *types_, base.Ctxt, base.Flag.N == 0)
 	ssaConfig.SoftFloat = thearch.SoftFloat
@@ -185,9 +186,9 @@ func initssaconfig() {
 // function/method/interface call), where the receiver of a method call is
 // considered as the 0th parameter. This does not include the receiver of an
 // interface call.
-func getParam(n *Node, i int) *types.Field {
+func getParam(n *ir.Node, i int) *types.Field {
 	t := n.Left.Type
-	if n.Op == OCALLMETH {
+	if n.Op == ir.OCALLMETH {
 		if i == 0 {
 			return t.Recv()
 		}
@@ -241,8 +242,8 @@ func dvarint(x *obj.LSym, off int, v int64) int {
 //      - Size of the argument
 //      - Offset of where argument should be placed in the args frame when making call
 func (s *state) emitOpenDeferInfo() {
-	x := base.Ctxt.Lookup(s.curfn.Func.lsym.Name + ".opendefer")
-	s.curfn.Func.lsym.Func().OpenCodedDeferInfo = x
+	x := base.Ctxt.Lookup(s.curfn.Func.LSym.Name + ".opendefer")
+	s.curfn.Func.LSym.Func().OpenCodedDeferInfo = x
 	off := 0
 
 	// Compute maxargsize (max size of arguments for all defers)
@@ -288,8 +289,8 @@ func (s *state) emitOpenDeferInfo() {
 
 // buildssa builds an SSA function for fn.
 // worker indicates which of the backend workers is doing the processing.
-func buildssa(fn *Node, worker int) *ssa.Func {
-	name := fn.funcname()
+func buildssa(fn *ir.Node, worker int) *ssa.Func {
+	name := ir.FuncName(fn)
 	printssa := false
 	if ssaDump != "" { // match either a simple name e.g. "(*Reader).Reset", or a package.name e.g. "compress/gzip.(*Reader).Reset"
 		printssa = name == ssaDump || base.Ctxt.Pkgpath+"."+name == ssaDump
@@ -297,9 +298,9 @@ func buildssa(fn *Node, worker int) *ssa.Func {
 	var astBuf *bytes.Buffer
 	if printssa {
 		astBuf = &bytes.Buffer{}
-		fdumplist(astBuf, "buildssa-enter", fn.Func.Enter)
-		fdumplist(astBuf, "buildssa-body", fn.Nbody)
-		fdumplist(astBuf, "buildssa-exit", fn.Func.Exit)
+		ir.FDumpList(astBuf, "buildssa-enter", fn.Func.Enter)
+		ir.FDumpList(astBuf, "buildssa-body", fn.Nbody)
+		ir.FDumpList(astBuf, "buildssa-exit", fn.Func.Exit)
 		if ssaDumpStdout {
 			fmt.Println("generating SSA for", name)
 			fmt.Print(astBuf.String())
@@ -311,7 +312,7 @@ func buildssa(fn *Node, worker int) *ssa.Func {
 	defer s.popLine()
 
 	s.hasdefer = fn.Func.HasDefer()
-	if fn.Func.Pragma&CgoUnsafeArgs != 0 {
+	if fn.Func.Pragma&ir.CgoUnsafeArgs != 0 {
 		s.cgoUnsafeArgs = true
 	}
 
@@ -330,7 +331,7 @@ func buildssa(fn *Node, worker int) *ssa.Func {
 	s.f.Name = name
 	s.f.DebugTest = s.f.DebugHashMatch("GOSSAHASH")
 	s.f.PrintOrHtmlSSA = printssa
-	if fn.Func.Pragma&Nosplit != 0 {
+	if fn.Func.Pragma&ir.Nosplit != 0 {
 		s.f.NoSplit = true
 	}
 	s.panics = map[funcLine]*ssa.Block{}
@@ -355,8 +356,8 @@ func buildssa(fn *Node, worker int) *ssa.Func {
 
 	// Allocate starting values
 	s.labels = map[string]*ssaLabel{}
-	s.labeledNodes = map[*Node]*ssaLabel{}
-	s.fwdVars = map[*Node]*ssa.Value{}
+	s.labeledNodes = map[*ir.Node]*ssaLabel{}
+	s.fwdVars = map[*ir.Node]*ssa.Value{}
 	s.startmem = s.entryNewValue0(ssa.OpInitMem, types.TypeMem)
 
 	s.hasOpenDefers = base.Flag.N == 0 && s.hasdefer && !s.curfn.Func.OpenCodedDeferDisallowed()
@@ -376,7 +377,7 @@ func buildssa(fn *Node, worker int) *ssa.Func {
 		s.hasOpenDefers = false
 	}
 	if s.hasOpenDefers &&
-		s.curfn.Func.numReturns*s.curfn.Func.numDefers > 15 {
+		s.curfn.Func.NumReturns*s.curfn.Func.NumDefers > 15 {
 		// Since we are generating defer calls at every exit for
 		// open-coded defers, skip doing open-coded defers if there are
 		// too many returns (especially if there are multiple defers).
@@ -385,8 +386,8 @@ func buildssa(fn *Node, worker int) *ssa.Func {
 		s.hasOpenDefers = false
 	}
 
-	s.sp = s.entryNewValue0(ssa.OpSP, types.Types[TUINTPTR]) // TODO: use generic pointer type (unsafe.Pointer?) instead
-	s.sb = s.entryNewValue0(ssa.OpSB, types.Types[TUINTPTR])
+	s.sp = s.entryNewValue0(ssa.OpSP, types.Types[types.TUINTPTR]) // TODO: use generic pointer type (unsafe.Pointer?) instead
+	s.sb = s.entryNewValue0(ssa.OpSB, types.Types[types.TUINTPTR])
 
 	s.startBlock(s.f.Entry)
 	s.vars[memVar] = s.startmem
@@ -394,13 +395,13 @@ func buildssa(fn *Node, worker int) *ssa.Func {
 		// Create the deferBits variable and stack slot.  deferBits is a
 		// bitmask showing which of the open-coded defers in this function
 		// have been activated.
-		deferBitsTemp := tempAt(src.NoXPos, s.curfn, types.Types[TUINT8])
+		deferBitsTemp := tempAt(src.NoXPos, s.curfn, types.Types[types.TUINT8])
 		s.deferBitsTemp = deferBitsTemp
 		// For this value, AuxInt is initialized to zero by default
-		startDeferBits := s.entryNewValue0(ssa.OpConst8, types.Types[TUINT8])
+		startDeferBits := s.entryNewValue0(ssa.OpConst8, types.Types[types.TUINT8])
 		s.vars[deferBitsVar] = startDeferBits
 		s.deferBitsAddr = s.addr(deferBitsTemp)
-		s.store(types.Types[TUINT8], s.deferBitsAddr, startDeferBits)
+		s.store(types.Types[types.TUINT8], s.deferBitsAddr, startDeferBits)
 		// Make sure that the deferBits stack slot is kept alive (for use
 		// by panics) and stores to deferBits are not eliminated, even if
 		// all checking code on deferBits in the function exit can be
@@ -410,15 +411,15 @@ func buildssa(fn *Node, worker int) *ssa.Func {
 	}
 
 	// Generate addresses of local declarations
-	s.decladdrs = map[*Node]*ssa.Value{}
+	s.decladdrs = map[*ir.Node]*ssa.Value{}
 	var args []ssa.Param
 	var results []ssa.Param
 	for _, n := range fn.Func.Dcl {
 		switch n.Class() {
-		case PPARAM:
+		case ir.PPARAM:
 			s.decladdrs[n] = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(n.Type), n, s.sp, s.startmem)
 			args = append(args, ssa.Param{Type: n.Type, Offset: int32(n.Xoffset)})
-		case PPARAMOUT:
+		case ir.PPARAMOUT:
 			s.decladdrs[n] = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(n.Type), n, s.sp, s.startmem)
 			results = append(results, ssa.Param{Type: n.Type, Offset: int32(n.Xoffset)})
 			if s.canSSA(n) {
@@ -427,12 +428,12 @@ func buildssa(fn *Node, worker int) *ssa.Func {
 				// the function.
 				s.returns = append(s.returns, n)
 			}
-		case PAUTO:
+		case ir.PAUTO:
 			// processed at each use, to prevent Addr coming
 			// before the decl.
-		case PAUTOHEAP:
+		case ir.PAUTOHEAP:
 			// moved to heap - already handled by frontend
-		case PFUNC:
+		case ir.PFUNC:
 			// local function - already handled by frontend
 		default:
 			s.Fatalf("local variable with class %v unimplemented", n.Class())
@@ -441,7 +442,7 @@ func buildssa(fn *Node, worker int) *ssa.Func {
 
 	// Populate SSAable arguments.
 	for _, n := range fn.Func.Dcl {
-		if n.Class() == PPARAM && s.canSSA(n) {
+		if n.Class() == ir.PPARAM && s.canSSA(n) {
 			v := s.newValue0A(ssa.OpArg, n.Type, n)
 			s.vars[n] = v
 			s.addNamedValue(n, v) // This helps with debugging information, not needed for compilation itself.
@@ -477,7 +478,7 @@ func buildssa(fn *Node, worker int) *ssa.Func {
 	return s.f
 }
 
-func dumpSourcesColumn(writer *ssa.HTMLWriter, fn *Node) {
+func dumpSourcesColumn(writer *ssa.HTMLWriter, fn *ir.Node) {
 	// Read sources of target function fn.
 	fname := base.Ctxt.PosTable.Pos(fn.Pos).Filename()
 	targetFn, err := readFuncLines(fname, fn.Pos.Line(), fn.Func.Endlineno.Line())
@@ -565,24 +566,24 @@ func (s *state) updateUnsetPredPos(b *ssa.Block) {
 // Information about each open-coded defer.
 type openDeferInfo struct {
 	// The ODEFER node representing the function call of the defer
-	n *Node
+	n *ir.Node
 	// If defer call is closure call, the address of the argtmp where the
 	// closure is stored.
 	closure *ssa.Value
 	// The node representing the argtmp where the closure is stored - used for
 	// function, method, or interface call, to store a closure that panic
 	// processing can use for this defer.
-	closureNode *Node
+	closureNode *ir.Node
 	// If defer call is interface call, the address of the argtmp where the
 	// receiver is stored
 	rcvr *ssa.Value
 	// The node representing the argtmp where the receiver is stored
-	rcvrNode *Node
+	rcvrNode *ir.Node
 	// The addresses of the argtmps where the evaluated arguments of the defer
 	// function call are stored.
 	argVals []*ssa.Value
 	// The nodes representing the argtmps where the args of the defer are stored
-	argNodes []*Node
+	argNodes []*ir.Node
 }
 
 type state struct {
@@ -593,11 +594,11 @@ type state struct {
 	f *ssa.Func
 
 	// Node for function
-	curfn *Node
+	curfn *ir.Node
 
 	// labels and labeled control flow nodes (OFOR, OFORUNTIL, OSWITCH, OSELECT) in f
 	labels       map[string]*ssaLabel
-	labeledNodes map[*Node]*ssaLabel
+	labeledNodes map[*ir.Node]*ssaLabel
 
 	// unlabeled break and continue statement tracking
 	breakTo    *ssa.Block // current target for plain break statement
@@ -609,18 +610,18 @@ type state struct {
 	// variable assignments in the current block (map from variable symbol to ssa value)
 	// *Node is the unique identifier (an ONAME Node) for the variable.
 	// TODO: keep a single varnum map, then make all of these maps slices instead?
-	vars map[*Node]*ssa.Value
+	vars map[*ir.Node]*ssa.Value
 
 	// fwdVars are variables that are used before they are defined in the current block.
 	// This map exists just to coalesce multiple references into a single FwdRef op.
 	// *Node is the unique identifier (an ONAME Node) for the variable.
-	fwdVars map[*Node]*ssa.Value
+	fwdVars map[*ir.Node]*ssa.Value
 
 	// all defined variables at the end of each block. Indexed by block ID.
-	defvars []map[*Node]*ssa.Value
+	defvars []map[*ir.Node]*ssa.Value
 
 	// addresses of PPARAM and PPARAMOUT variables.
-	decladdrs map[*Node]*ssa.Value
+	decladdrs map[*ir.Node]*ssa.Value
 
 	// starting values. Memory, stack pointer, and globals pointer
 	startmem *ssa.Value
@@ -628,7 +629,7 @@ type state struct {
 	sb       *ssa.Value
 	// value representing address of where deferBits autotmp is stored
 	deferBitsAddr *ssa.Value
-	deferBitsTemp *Node
+	deferBitsTemp *ir.Node
 
 	// line number stack. The current line number is top of stack
 	line []src.XPos
@@ -640,7 +641,7 @@ type state struct {
 	panics map[funcLine]*ssa.Block
 
 	// list of PPARAMOUT (return) variables.
-	returns []*Node
+	returns []*ir.Node
 
 	cgoUnsafeArgs bool
 	hasdefer      bool // whether the function contains a defer statement
@@ -692,8 +693,8 @@ func (s *state) Fatalf(msg string, args ...interface{}) {
 func (s *state) Warnl(pos src.XPos, msg string, args ...interface{}) { s.f.Warnl(pos, msg, args...) }
 func (s *state) Debug_checknil() bool                                { return s.f.Frontend().Debug_checknil() }
 
-func ssaMarker(name string) *Node {
-	return newname(&types.Sym{Name: name})
+func ssaMarker(name string) *ir.Node {
+	return NewName(&types.Sym{Name: name})
 }
 
 var (
@@ -716,7 +717,7 @@ func (s *state) startBlock(b *ssa.Block) {
 		s.Fatalf("starting block %v when block %v has not ended", b, s.curBlock)
 	}
 	s.curBlock = b
-	s.vars = map[*Node]*ssa.Value{}
+	s.vars = map[*ir.Node]*ssa.Value{}
 	for n := range s.fwdVars {
 		delete(s.fwdVars, n)
 	}
@@ -920,7 +921,7 @@ func (s *state) constEmptyString(t *types.Type) *ssa.Value {
 	return s.f.ConstEmptyString(t)
 }
 func (s *state) constBool(c bool) *ssa.Value {
-	return s.f.ConstBool(types.Types[TBOOL], c)
+	return s.f.ConstBool(types.Types[types.TBOOL], c)
 }
 func (s *state) constInt8(t *types.Type, c int8) *ssa.Value {
 	return s.f.ConstInt8(t, c)
@@ -1017,7 +1018,7 @@ func (s *state) instrument(t *types.Type, addr *ssa.Value, wr bool) {
 
 	args := []*ssa.Value{addr}
 	if needWidth {
-		args = append(args, s.constInt(types.Types[TUINTPTR], w))
+		args = append(args, s.constInt(types.Types[types.TUINTPTR], w))
 	}
 	s.rtcall(fn, true, nil, args...)
 }
@@ -1051,15 +1052,15 @@ func (s *state) move(t *types.Type, dst, src *ssa.Value) {
 }
 
 // stmtList converts the statement list n to SSA and adds it to s.
-func (s *state) stmtList(l Nodes) {
+func (s *state) stmtList(l ir.Nodes) {
 	for _, n := range l.Slice() {
 		s.stmt(n)
 	}
 }
 
 // stmt converts the statement n to SSA and adds it to s.
-func (s *state) stmt(n *Node) {
-	if !(n.Op == OVARKILL || n.Op == OVARLIVE || n.Op == OVARDEF) {
+func (s *state) stmt(n *ir.Node) {
+	if !(n.Op == ir.OVARKILL || n.Op == ir.OVARLIVE || n.Op == ir.OVARDEF) {
 		// OVARKILL, OVARLIVE, and OVARDEF are invisible to the programmer, so we don't use their line numbers to avoid confusion in debugging.
 		s.pushLine(n.Pos)
 		defer s.popLine()
@@ -1067,30 +1068,30 @@ func (s *state) stmt(n *Node) {
 
 	// If s.curBlock is nil, and n isn't a label (which might have an associated goto somewhere),
 	// then this code is dead. Stop here.
-	if s.curBlock == nil && n.Op != OLABEL {
+	if s.curBlock == nil && n.Op != ir.OLABEL {
 		return
 	}
 
 	s.stmtList(n.Ninit)
 	switch n.Op {
 
-	case OBLOCK:
+	case ir.OBLOCK:
 		s.stmtList(n.List)
 
 	// No-ops
-	case OEMPTY, ODCLCONST, ODCLTYPE, OFALL:
+	case ir.OEMPTY, ir.ODCLCONST, ir.ODCLTYPE, ir.OFALL:
 
 	// Expression statements
-	case OCALLFUNC:
+	case ir.OCALLFUNC:
 		if isIntrinsicCall(n) {
 			s.intrinsicCall(n)
 			return
 		}
 		fallthrough
 
-	case OCALLMETH, OCALLINTER:
+	case ir.OCALLMETH, ir.OCALLINTER:
 		s.callResult(n, callNormal)
-		if n.Op == OCALLFUNC && n.Left.Op == ONAME && n.Left.Class() == PFUNC {
+		if n.Op == ir.OCALLFUNC && n.Left.Op == ir.ONAME && n.Left.Class() == ir.PFUNC {
 			if fn := n.Left.Sym.Name; base.Flag.CompilingRuntime && fn == "throw" ||
 				n.Left.Sym.Pkg == Runtimepkg && (fn == "throwinit" || fn == "gopanic" || fn == "panicwrap" || fn == "block" || fn == "panicmakeslicelen" || fn == "panicmakeslicecap") {
 				m := s.mem()
@@ -1102,7 +1103,7 @@ func (s *state) stmt(n *Node) {
 				// go through SSA.
 			}
 		}
-	case ODEFER:
+	case ir.ODEFER:
 		if base.Debug.Defer > 0 {
 			var defertype string
 			if s.hasOpenDefers {
@@ -1123,10 +1124,10 @@ func (s *state) stmt(n *Node) {
 			}
 			s.callResult(n.Left, d)
 		}
-	case OGO:
+	case ir.OGO:
 		s.callResult(n.Left, callGo)
 
-	case OAS2DOTTYPE:
+	case ir.OAS2DOTTYPE:
 		res, resok := s.dottype(n.Right, true)
 		deref := false
 		if !canSSAType(n.Right.Type) {
@@ -1147,7 +1148,7 @@ func (s *state) stmt(n *Node) {
 		s.assign(n.List.Second(), resok, false, 0)
 		return
 
-	case OAS2FUNC:
+	case ir.OAS2FUNC:
 		// We come here only when it is an intrinsic call returning two values.
 		if !isIntrinsicCall(n.Right) {
 			s.Fatalf("non-intrinsic AS2FUNC not expanded %v", n.Right)
@@ -1159,17 +1160,17 @@ func (s *state) stmt(n *Node) {
 		s.assign(n.List.Second(), v2, false, 0)
 		return
 
-	case ODCL:
-		if n.Left.Class() == PAUTOHEAP {
+	case ir.ODCL:
+		if n.Left.Class() == ir.PAUTOHEAP {
 			s.Fatalf("DCL %v", n)
 		}
 
-	case OLABEL:
+	case ir.OLABEL:
 		sym := n.Sym
 		lab := s.label(sym)
 
 		// Associate label with its control flow node, if any
-		if ctl := n.labeledControl(); ctl != nil {
+		if ctl := labeledControl(n); ctl != nil {
 			s.labeledNodes[ctl] = lab
 		}
 
@@ -1186,7 +1187,7 @@ func (s *state) stmt(n *Node) {
 		}
 		s.startBlock(lab.target)
 
-	case OGOTO:
+	case ir.OGOTO:
 		sym := n.Sym
 
 		lab := s.label(sym)
@@ -1198,8 +1199,8 @@ func (s *state) stmt(n *Node) {
 		b.Pos = s.lastPos.WithIsStmt() // Do this even if b is an empty block.
 		b.AddEdgeTo(lab.target)
 
-	case OAS:
-		if n.Left == n.Right && n.Left.Op == ONAME {
+	case ir.OAS:
+		if n.Left == n.Right && n.Left.Op == ir.ONAME {
 			// An x=x assignment. No point in doing anything
 			// here. In addition, skipping this assignment
 			// prevents generating:
@@ -1214,7 +1215,7 @@ func (s *state) stmt(n *Node) {
 		rhs := n.Right
 		if rhs != nil {
 			switch rhs.Op {
-			case OSTRUCTLIT, OARRAYLIT, OSLICELIT:
+			case ir.OSTRUCTLIT, ir.OARRAYLIT, ir.OSLICELIT:
 				// All literals with nonzero fields have already been
 				// rewritten during walk. Any that remain are just T{}
 				// or equivalents. Use the zero value.
@@ -1222,7 +1223,7 @@ func (s *state) stmt(n *Node) {
 					s.Fatalf("literal with nonzero value in SSA: %v", rhs)
 				}
 				rhs = nil
-			case OAPPEND:
+			case ir.OAPPEND:
 				// Check whether we're writing the result of an append back to the same slice.
 				// If so, we handle it specially to avoid write barriers on the fast
 				// (non-growth) path.
@@ -1246,7 +1247,7 @@ func (s *state) stmt(n *Node) {
 			}
 		}
 
-		if n.Left.isBlank() {
+		if ir.IsBlank(n.Left) {
 			// _ = rhs
 			// Just evaluate rhs for side-effects.
 			if rhs != nil {
@@ -1279,11 +1280,11 @@ func (s *state) stmt(n *Node) {
 		}
 
 		var skip skipMask
-		if rhs != nil && (rhs.Op == OSLICE || rhs.Op == OSLICE3 || rhs.Op == OSLICESTR) && samesafeexpr(rhs.Left, n.Left) {
+		if rhs != nil && (rhs.Op == ir.OSLICE || rhs.Op == ir.OSLICE3 || rhs.Op == ir.OSLICESTR) && samesafeexpr(rhs.Left, n.Left) {
 			// We're assigning a slicing operation back to its source.
 			// Don't write back fields we aren't changing. See issue #14855.
 			i, j, k := rhs.SliceBounds()
-			if i != nil && (i.Op == OLITERAL && i.Val().Kind() == constant.Int && i.Int64Val() == 0) {
+			if i != nil && (i.Op == ir.OLITERAL && i.Val().Kind() == constant.Int && i.Int64Val() == 0) {
 				// [0:...] is the same as [:...]
 				i = nil
 			}
@@ -1310,8 +1311,8 @@ func (s *state) stmt(n *Node) {
 
 		s.assign(n.Left, r, deref, skip)
 
-	case OIF:
-		if Isconst(n.Left, constant.Bool) {
+	case ir.OIF:
+		if ir.IsConst(n.Left, constant.Bool) {
 			s.stmtList(n.Left.Ninit)
 			if n.Left.BoolVal() {
 				s.stmtList(n.Nbody)
@@ -1356,25 +1357,25 @@ func (s *state) stmt(n *Node) {
 		}
 		s.startBlock(bEnd)
 
-	case ORETURN:
+	case ir.ORETURN:
 		s.stmtList(n.List)
 		b := s.exit()
 		b.Pos = s.lastPos.WithIsStmt()
 
-	case ORETJMP:
+	case ir.ORETJMP:
 		s.stmtList(n.List)
 		b := s.exit()
 		b.Kind = ssa.BlockRetJmp // override BlockRet
 		b.Aux = n.Sym.Linksym()
 
-	case OCONTINUE, OBREAK:
+	case ir.OCONTINUE, ir.OBREAK:
 		var to *ssa.Block
 		if n.Sym == nil {
 			// plain break/continue
 			switch n.Op {
-			case OCONTINUE:
+			case ir.OCONTINUE:
 				to = s.continueTo
-			case OBREAK:
+			case ir.OBREAK:
 				to = s.breakTo
 			}
 		} else {
@@ -1382,9 +1383,9 @@ func (s *state) stmt(n *Node) {
 			sym := n.Sym
 			lab := s.label(sym)
 			switch n.Op {
-			case OCONTINUE:
+			case ir.OCONTINUE:
 				to = lab.continueTarget
-			case OBREAK:
+			case ir.OBREAK:
 				to = lab.breakTarget
 			}
 		}
@@ -1393,7 +1394,7 @@ func (s *state) stmt(n *Node) {
 		b.Pos = s.lastPos.WithIsStmt() // Do this even if b is an empty block.
 		b.AddEdgeTo(to)
 
-	case OFOR, OFORUNTIL:
+	case ir.OFOR, ir.OFORUNTIL:
 		// OFOR: for Ninit; Left; Right { Nbody }
 		// cond (Left); body (Nbody); incr (Right)
 		//
@@ -1409,7 +1410,7 @@ func (s *state) stmt(n *Node) {
 
 		// first, jump to condition test (OFOR) or body (OFORUNTIL)
 		b := s.endBlock()
-		if n.Op == OFOR {
+		if n.Op == ir.OFOR {
 			b.AddEdgeTo(bCond)
 			// generate code to test condition
 			s.startBlock(bCond)
@@ -1459,12 +1460,12 @@ func (s *state) stmt(n *Node) {
 		if n.Right != nil {
 			s.stmt(n.Right)
 		}
-		if n.Op == OFOR {
+		if n.Op == ir.OFOR {
 			if b := s.endBlock(); b != nil {
 				b.AddEdgeTo(bCond)
 				// It can happen that bIncr ends in a block containing only VARKILL,
 				// and that muddles the debugging experience.
-				if n.Op != OFORUNTIL && b.Pos == src.NoXPos {
+				if n.Op != ir.OFORUNTIL && b.Pos == src.NoXPos {
 					b.Pos = bCond.Pos
 				}
 			}
@@ -1481,7 +1482,7 @@ func (s *state) stmt(n *Node) {
 
 		s.startBlock(bEnd)
 
-	case OSWITCH, OSELECT:
+	case ir.OSWITCH, ir.OSELECT:
 		// These have been mostly rewritten by the front end into their Nbody fields.
 		// Our main task is to correctly hook up any break statements.
 		bEnd := s.f.NewBlock(ssa.BlockPlain)
@@ -1512,11 +1513,11 @@ func (s *state) stmt(n *Node) {
 		}
 		s.startBlock(bEnd)
 
-	case OVARDEF:
+	case ir.OVARDEF:
 		if !s.canSSA(n.Left) {
 			s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, n.Left, s.mem(), false)
 		}
-	case OVARKILL:
+	case ir.OVARKILL:
 		// Insert a varkill op to record that a variable is no longer live.
 		// We only care about liveness info at call sites, so putting the
 		// varkill in the store chain is enough to keep it correctly ordered
@@ -1525,23 +1526,23 @@ func (s *state) stmt(n *Node) {
 			s.vars[memVar] = s.newValue1Apos(ssa.OpVarKill, types.TypeMem, n.Left, s.mem(), false)
 		}
 
-	case OVARLIVE:
+	case ir.OVARLIVE:
 		// Insert a varlive op to record that a variable is still live.
 		if !n.Left.Name.Addrtaken() {
 			s.Fatalf("VARLIVE variable %v must have Addrtaken set", n.Left)
 		}
 		switch n.Left.Class() {
-		case PAUTO, PPARAM, PPARAMOUT:
+		case ir.PAUTO, ir.PPARAM, ir.PPARAMOUT:
 		default:
 			s.Fatalf("VARLIVE variable %v must be Auto or Arg", n.Left)
 		}
 		s.vars[memVar] = s.newValue1A(ssa.OpVarLive, types.TypeMem, n.Left, s.mem())
 
-	case OCHECKNIL:
+	case ir.OCHECKNIL:
 		p := s.expr(n.Left)
 		s.nilCheck(p)
 
-	case OINLMARK:
+	case ir.OINLMARK:
 		s.newValue1I(ssa.OpInlMark, types.TypeVoid, n.Xoffset, s.mem())
 
 	default:
@@ -1600,180 +1601,180 @@ func (s *state) exit() *ssa.Block {
 }
 
 type opAndType struct {
-	op    Op
+	op    ir.Op
 	etype types.EType
 }
 
 var opToSSA = map[opAndType]ssa.Op{
-	opAndType{OADD, TINT8}:    ssa.OpAdd8,
-	opAndType{OADD, TUINT8}:   ssa.OpAdd8,
-	opAndType{OADD, TINT16}:   ssa.OpAdd16,
-	opAndType{OADD, TUINT16}:  ssa.OpAdd16,
-	opAndType{OADD, TINT32}:   ssa.OpAdd32,
-	opAndType{OADD, TUINT32}:  ssa.OpAdd32,
-	opAndType{OADD, TINT64}:   ssa.OpAdd64,
-	opAndType{OADD, TUINT64}:  ssa.OpAdd64,
-	opAndType{OADD, TFLOAT32}: ssa.OpAdd32F,
-	opAndType{OADD, TFLOAT64}: ssa.OpAdd64F,
-
-	opAndType{OSUB, TINT8}:    ssa.OpSub8,
-	opAndType{OSUB, TUINT8}:   ssa.OpSub8,
-	opAndType{OSUB, TINT16}:   ssa.OpSub16,
-	opAndType{OSUB, TUINT16}:  ssa.OpSub16,
-	opAndType{OSUB, TINT32}:   ssa.OpSub32,
-	opAndType{OSUB, TUINT32}:  ssa.OpSub32,
-	opAndType{OSUB, TINT64}:   ssa.OpSub64,
-	opAndType{OSUB, TUINT64}:  ssa.OpSub64,
-	opAndType{OSUB, TFLOAT32}: ssa.OpSub32F,
-	opAndType{OSUB, TFLOAT64}: ssa.OpSub64F,
-
-	opAndType{ONOT, TBOOL}: ssa.OpNot,
-
-	opAndType{ONEG, TINT8}:    ssa.OpNeg8,
-	opAndType{ONEG, TUINT8}:   ssa.OpNeg8,
-	opAndType{ONEG, TINT16}:   ssa.OpNeg16,
-	opAndType{ONEG, TUINT16}:  ssa.OpNeg16,
-	opAndType{ONEG, TINT32}:   ssa.OpNeg32,
-	opAndType{ONEG, TUINT32}:  ssa.OpNeg32,
-	opAndType{ONEG, TINT64}:   ssa.OpNeg64,
-	opAndType{ONEG, TUINT64}:  ssa.OpNeg64,
-	opAndType{ONEG, TFLOAT32}: ssa.OpNeg32F,
-	opAndType{ONEG, TFLOAT64}: ssa.OpNeg64F,
-
-	opAndType{OBITNOT, TINT8}:   ssa.OpCom8,
-	opAndType{OBITNOT, TUINT8}:  ssa.OpCom8,
-	opAndType{OBITNOT, TINT16}:  ssa.OpCom16,
-	opAndType{OBITNOT, TUINT16}: ssa.OpCom16,
-	opAndType{OBITNOT, TINT32}:  ssa.OpCom32,
-	opAndType{OBITNOT, TUINT32}: ssa.OpCom32,
-	opAndType{OBITNOT, TINT64}:  ssa.OpCom64,
-	opAndType{OBITNOT, TUINT64}: ssa.OpCom64,
-
-	opAndType{OIMAG, TCOMPLEX64}:  ssa.OpComplexImag,
-	opAndType{OIMAG, TCOMPLEX128}: ssa.OpComplexImag,
-	opAndType{OREAL, TCOMPLEX64}:  ssa.OpComplexReal,
-	opAndType{OREAL, TCOMPLEX128}: ssa.OpComplexReal,
-
-	opAndType{OMUL, TINT8}:    ssa.OpMul8,
-	opAndType{OMUL, TUINT8}:   ssa.OpMul8,
-	opAndType{OMUL, TINT16}:   ssa.OpMul16,
-	opAndType{OMUL, TUINT16}:  ssa.OpMul16,
-	opAndType{OMUL, TINT32}:   ssa.OpMul32,
-	opAndType{OMUL, TUINT32}:  ssa.OpMul32,
-	opAndType{OMUL, TINT64}:   ssa.OpMul64,
-	opAndType{OMUL, TUINT64}:  ssa.OpMul64,
-	opAndType{OMUL, TFLOAT32}: ssa.OpMul32F,
-	opAndType{OMUL, TFLOAT64}: ssa.OpMul64F,
-
-	opAndType{ODIV, TFLOAT32}: ssa.OpDiv32F,
-	opAndType{ODIV, TFLOAT64}: ssa.OpDiv64F,
-
-	opAndType{ODIV, TINT8}:   ssa.OpDiv8,
-	opAndType{ODIV, TUINT8}:  ssa.OpDiv8u,
-	opAndType{ODIV, TINT16}:  ssa.OpDiv16,
-	opAndType{ODIV, TUINT16}: ssa.OpDiv16u,
-	opAndType{ODIV, TINT32}:  ssa.OpDiv32,
-	opAndType{ODIV, TUINT32}: ssa.OpDiv32u,
-	opAndType{ODIV, TINT64}:  ssa.OpDiv64,
-	opAndType{ODIV, TUINT64}: ssa.OpDiv64u,
-
-	opAndType{OMOD, TINT8}:   ssa.OpMod8,
-	opAndType{OMOD, TUINT8}:  ssa.OpMod8u,
-	opAndType{OMOD, TINT16}:  ssa.OpMod16,
-	opAndType{OMOD, TUINT16}: ssa.OpMod16u,
-	opAndType{OMOD, TINT32}:  ssa.OpMod32,
-	opAndType{OMOD, TUINT32}: ssa.OpMod32u,
-	opAndType{OMOD, TINT64}:  ssa.OpMod64,
-	opAndType{OMOD, TUINT64}: ssa.OpMod64u,
-
-	opAndType{OAND, TINT8}:   ssa.OpAnd8,
-	opAndType{OAND, TUINT8}:  ssa.OpAnd8,
-	opAndType{OAND, TINT16}:  ssa.OpAnd16,
-	opAndType{OAND, TUINT16}: ssa.OpAnd16,
-	opAndType{OAND, TINT32}:  ssa.OpAnd32,
-	opAndType{OAND, TUINT32}: ssa.OpAnd32,
-	opAndType{OAND, TINT64}:  ssa.OpAnd64,
-	opAndType{OAND, TUINT64}: ssa.OpAnd64,
-
-	opAndType{OOR, TINT8}:   ssa.OpOr8,
-	opAndType{OOR, TUINT8}:  ssa.OpOr8,
-	opAndType{OOR, TINT16}:  ssa.OpOr16,
-	opAndType{OOR, TUINT16}: ssa.OpOr16,
-	opAndType{OOR, TINT32}:  ssa.OpOr32,
-	opAndType{OOR, TUINT32}: ssa.OpOr32,
-	opAndType{OOR, TINT64}:  ssa.OpOr64,
-	opAndType{OOR, TUINT64}: ssa.OpOr64,
-
-	opAndType{OXOR, TINT8}:   ssa.OpXor8,
-	opAndType{OXOR, TUINT8}:  ssa.OpXor8,
-	opAndType{OXOR, TINT16}:  ssa.OpXor16,
-	opAndType{OXOR, TUINT16}: ssa.OpXor16,
-	opAndType{OXOR, TINT32}:  ssa.OpXor32,
-	opAndType{OXOR, TUINT32}: ssa.OpXor32,
-	opAndType{OXOR, TINT64}:  ssa.OpXor64,
-	opAndType{OXOR, TUINT64}: ssa.OpXor64,
-
-	opAndType{OEQ, TBOOL}:      ssa.OpEqB,
-	opAndType{OEQ, TINT8}:      ssa.OpEq8,
-	opAndType{OEQ, TUINT8}:     ssa.OpEq8,
-	opAndType{OEQ, TINT16}:     ssa.OpEq16,
-	opAndType{OEQ, TUINT16}:    ssa.OpEq16,
-	opAndType{OEQ, TINT32}:     ssa.OpEq32,
-	opAndType{OEQ, TUINT32}:    ssa.OpEq32,
-	opAndType{OEQ, TINT64}:     ssa.OpEq64,
-	opAndType{OEQ, TUINT64}:    ssa.OpEq64,
-	opAndType{OEQ, TINTER}:     ssa.OpEqInter,
-	opAndType{OEQ, TSLICE}:     ssa.OpEqSlice,
-	opAndType{OEQ, TFUNC}:      ssa.OpEqPtr,
-	opAndType{OEQ, TMAP}:       ssa.OpEqPtr,
-	opAndType{OEQ, TCHAN}:      ssa.OpEqPtr,
-	opAndType{OEQ, TPTR}:       ssa.OpEqPtr,
-	opAndType{OEQ, TUINTPTR}:   ssa.OpEqPtr,
-	opAndType{OEQ, TUNSAFEPTR}: ssa.OpEqPtr,
-	opAndType{OEQ, TFLOAT64}:   ssa.OpEq64F,
-	opAndType{OEQ, TFLOAT32}:   ssa.OpEq32F,
-
-	opAndType{ONE, TBOOL}:      ssa.OpNeqB,
-	opAndType{ONE, TINT8}:      ssa.OpNeq8,
-	opAndType{ONE, TUINT8}:     ssa.OpNeq8,
-	opAndType{ONE, TINT16}:     ssa.OpNeq16,
-	opAndType{ONE, TUINT16}:    ssa.OpNeq16,
-	opAndType{ONE, TINT32}:     ssa.OpNeq32,
-	opAndType{ONE, TUINT32}:    ssa.OpNeq32,
-	opAndType{ONE, TINT64}:     ssa.OpNeq64,
-	opAndType{ONE, TUINT64}:    ssa.OpNeq64,
-	opAndType{ONE, TINTER}:     ssa.OpNeqInter,
-	opAndType{ONE, TSLICE}:     ssa.OpNeqSlice,
-	opAndType{ONE, TFUNC}:      ssa.OpNeqPtr,
-	opAndType{ONE, TMAP}:       ssa.OpNeqPtr,
-	opAndType{ONE, TCHAN}:      ssa.OpNeqPtr,
-	opAndType{ONE, TPTR}:       ssa.OpNeqPtr,
-	opAndType{ONE, TUINTPTR}:   ssa.OpNeqPtr,
-	opAndType{ONE, TUNSAFEPTR}: ssa.OpNeqPtr,
-	opAndType{ONE, TFLOAT64}:   ssa.OpNeq64F,
-	opAndType{ONE, TFLOAT32}:   ssa.OpNeq32F,
-
-	opAndType{OLT, TINT8}:    ssa.OpLess8,
-	opAndType{OLT, TUINT8}:   ssa.OpLess8U,
-	opAndType{OLT, TINT16}:   ssa.OpLess16,
-	opAndType{OLT, TUINT16}:  ssa.OpLess16U,
-	opAndType{OLT, TINT32}:   ssa.OpLess32,
-	opAndType{OLT, TUINT32}:  ssa.OpLess32U,
-	opAndType{OLT, TINT64}:   ssa.OpLess64,
-	opAndType{OLT, TUINT64}:  ssa.OpLess64U,
-	opAndType{OLT, TFLOAT64}: ssa.OpLess64F,
-	opAndType{OLT, TFLOAT32}: ssa.OpLess32F,
-
-	opAndType{OLE, TINT8}:    ssa.OpLeq8,
-	opAndType{OLE, TUINT8}:   ssa.OpLeq8U,
-	opAndType{OLE, TINT16}:   ssa.OpLeq16,
-	opAndType{OLE, TUINT16}:  ssa.OpLeq16U,
-	opAndType{OLE, TINT32}:   ssa.OpLeq32,
-	opAndType{OLE, TUINT32}:  ssa.OpLeq32U,
-	opAndType{OLE, TINT64}:   ssa.OpLeq64,
-	opAndType{OLE, TUINT64}:  ssa.OpLeq64U,
-	opAndType{OLE, TFLOAT64}: ssa.OpLeq64F,
-	opAndType{OLE, TFLOAT32}: ssa.OpLeq32F,
+	opAndType{ir.OADD, types.TINT8}:    ssa.OpAdd8,
+	opAndType{ir.OADD, types.TUINT8}:   ssa.OpAdd8,
+	opAndType{ir.OADD, types.TINT16}:   ssa.OpAdd16,
+	opAndType{ir.OADD, types.TUINT16}:  ssa.OpAdd16,
+	opAndType{ir.OADD, types.TINT32}:   ssa.OpAdd32,
+	opAndType{ir.OADD, types.TUINT32}:  ssa.OpAdd32,
+	opAndType{ir.OADD, types.TINT64}:   ssa.OpAdd64,
+	opAndType{ir.OADD, types.TUINT64}:  ssa.OpAdd64,
+	opAndType{ir.OADD, types.TFLOAT32}: ssa.OpAdd32F,
+	opAndType{ir.OADD, types.TFLOAT64}: ssa.OpAdd64F,
+
+	opAndType{ir.OSUB, types.TINT8}:    ssa.OpSub8,
+	opAndType{ir.OSUB, types.TUINT8}:   ssa.OpSub8,
+	opAndType{ir.OSUB, types.TINT16}:   ssa.OpSub16,
+	opAndType{ir.OSUB, types.TUINT16}:  ssa.OpSub16,
+	opAndType{ir.OSUB, types.TINT32}:   ssa.OpSub32,
+	opAndType{ir.OSUB, types.TUINT32}:  ssa.OpSub32,
+	opAndType{ir.OSUB, types.TINT64}:   ssa.OpSub64,
+	opAndType{ir.OSUB, types.TUINT64}:  ssa.OpSub64,
+	opAndType{ir.OSUB, types.TFLOAT32}: ssa.OpSub32F,
+	opAndType{ir.OSUB, types.TFLOAT64}: ssa.OpSub64F,
+
+	opAndType{ir.ONOT, types.TBOOL}: ssa.OpNot,
+
+	opAndType{ir.ONEG, types.TINT8}:    ssa.OpNeg8,
+	opAndType{ir.ONEG, types.TUINT8}:   ssa.OpNeg8,
+	opAndType{ir.ONEG, types.TINT16}:   ssa.OpNeg16,
+	opAndType{ir.ONEG, types.TUINT16}:  ssa.OpNeg16,
+	opAndType{ir.ONEG, types.TINT32}:   ssa.OpNeg32,
+	opAndType{ir.ONEG, types.TUINT32}:  ssa.OpNeg32,
+	opAndType{ir.ONEG, types.TINT64}:   ssa.OpNeg64,
+	opAndType{ir.ONEG, types.TUINT64}:  ssa.OpNeg64,
+	opAndType{ir.ONEG, types.TFLOAT32}: ssa.OpNeg32F,
+	opAndType{ir.ONEG, types.TFLOAT64}: ssa.OpNeg64F,
+
+	opAndType{ir.OBITNOT, types.TINT8}:   ssa.OpCom8,
+	opAndType{ir.OBITNOT, types.TUINT8}:  ssa.OpCom8,
+	opAndType{ir.OBITNOT, types.TINT16}:  ssa.OpCom16,
+	opAndType{ir.OBITNOT, types.TUINT16}: ssa.OpCom16,
+	opAndType{ir.OBITNOT, types.TINT32}:  ssa.OpCom32,
+	opAndType{ir.OBITNOT, types.TUINT32}: ssa.OpCom32,
+	opAndType{ir.OBITNOT, types.TINT64}:  ssa.OpCom64,
+	opAndType{ir.OBITNOT, types.TUINT64}: ssa.OpCom64,
+
+	opAndType{ir.OIMAG, types.TCOMPLEX64}:  ssa.OpComplexImag,
+	opAndType{ir.OIMAG, types.TCOMPLEX128}: ssa.OpComplexImag,
+	opAndType{ir.OREAL, types.TCOMPLEX64}:  ssa.OpComplexReal,
+	opAndType{ir.OREAL, types.TCOMPLEX128}: ssa.OpComplexReal,
+
+	opAndType{ir.OMUL, types.TINT8}:    ssa.OpMul8,
+	opAndType{ir.OMUL, types.TUINT8}:   ssa.OpMul8,
+	opAndType{ir.OMUL, types.TINT16}:   ssa.OpMul16,
+	opAndType{ir.OMUL, types.TUINT16}:  ssa.OpMul16,
+	opAndType{ir.OMUL, types.TINT32}:   ssa.OpMul32,
+	opAndType{ir.OMUL, types.TUINT32}:  ssa.OpMul32,
+	opAndType{ir.OMUL, types.TINT64}:   ssa.OpMul64,
+	opAndType{ir.OMUL, types.TUINT64}:  ssa.OpMul64,
+	opAndType{ir.OMUL, types.TFLOAT32}: ssa.OpMul32F,
+	opAndType{ir.OMUL, types.TFLOAT64}: ssa.OpMul64F,
+
+	opAndType{ir.ODIV, types.TFLOAT32}: ssa.OpDiv32F,
+	opAndType{ir.ODIV, types.TFLOAT64}: ssa.OpDiv64F,
+
+	opAndType{ir.ODIV, types.TINT8}:   ssa.OpDiv8,
+	opAndType{ir.ODIV, types.TUINT8}:  ssa.OpDiv8u,
+	opAndType{ir.ODIV, types.TINT16}:  ssa.OpDiv16,
+	opAndType{ir.ODIV, types.TUINT16}: ssa.OpDiv16u,
+	opAndType{ir.ODIV, types.TINT32}:  ssa.OpDiv32,
+	opAndType{ir.ODIV, types.TUINT32}: ssa.OpDiv32u,
+	opAndType{ir.ODIV, types.TINT64}:  ssa.OpDiv64,
+	opAndType{ir.ODIV, types.TUINT64}: ssa.OpDiv64u,
+
+	opAndType{ir.OMOD, types.TINT8}:   ssa.OpMod8,
+	opAndType{ir.OMOD, types.TUINT8}:  ssa.OpMod8u,
+	opAndType{ir.OMOD, types.TINT16}:  ssa.OpMod16,
+	opAndType{ir.OMOD, types.TUINT16}: ssa.OpMod16u,
+	opAndType{ir.OMOD, types.TINT32}:  ssa.OpMod32,
+	opAndType{ir.OMOD, types.TUINT32}: ssa.OpMod32u,
+	opAndType{ir.OMOD, types.TINT64}:  ssa.OpMod64,
+	opAndType{ir.OMOD, types.TUINT64}: ssa.OpMod64u,
+
+	opAndType{ir.OAND, types.TINT8}:   ssa.OpAnd8,
+	opAndType{ir.OAND, types.TUINT8}:  ssa.OpAnd8,
+	opAndType{ir.OAND, types.TINT16}:  ssa.OpAnd16,
+	opAndType{ir.OAND, types.TUINT16}: ssa.OpAnd16,
+	opAndType{ir.OAND, types.TINT32}:  ssa.OpAnd32,
+	opAndType{ir.OAND, types.TUINT32}: ssa.OpAnd32,
+	opAndType{ir.OAND, types.TINT64}:  ssa.OpAnd64,
+	opAndType{ir.OAND, types.TUINT64}: ssa.OpAnd64,
+
+	opAndType{ir.OOR, types.TINT8}:   ssa.OpOr8,
+	opAndType{ir.OOR, types.TUINT8}:  ssa.OpOr8,
+	opAndType{ir.OOR, types.TINT16}:  ssa.OpOr16,
+	opAndType{ir.OOR, types.TUINT16}: ssa.OpOr16,
+	opAndType{ir.OOR, types.TINT32}:  ssa.OpOr32,
+	opAndType{ir.OOR, types.TUINT32}: ssa.OpOr32,
+	opAndType{ir.OOR, types.TINT64}:  ssa.OpOr64,
+	opAndType{ir.OOR, types.TUINT64}: ssa.OpOr64,
+
+	opAndType{ir.OXOR, types.TINT8}:   ssa.OpXor8,
+	opAndType{ir.OXOR, types.TUINT8}:  ssa.OpXor8,
+	opAndType{ir.OXOR, types.TINT16}:  ssa.OpXor16,
+	opAndType{ir.OXOR, types.TUINT16}: ssa.OpXor16,
+	opAndType{ir.OXOR, types.TINT32}:  ssa.OpXor32,
+	opAndType{ir.OXOR, types.TUINT32}: ssa.OpXor32,
+	opAndType{ir.OXOR, types.TINT64}:  ssa.OpXor64,
+	opAndType{ir.OXOR, types.TUINT64}: ssa.OpXor64,
+
+	opAndType{ir.OEQ, types.TBOOL}:      ssa.OpEqB,
+	opAndType{ir.OEQ, types.TINT8}:      ssa.OpEq8,
+	opAndType{ir.OEQ, types.TUINT8}:     ssa.OpEq8,
+	opAndType{ir.OEQ, types.TINT16}:     ssa.OpEq16,
+	opAndType{ir.OEQ, types.TUINT16}:    ssa.OpEq16,
+	opAndType{ir.OEQ, types.TINT32}:     ssa.OpEq32,
+	opAndType{ir.OEQ, types.TUINT32}:    ssa.OpEq32,
+	opAndType{ir.OEQ, types.TINT64}:     ssa.OpEq64,
+	opAndType{ir.OEQ, types.TUINT64}:    ssa.OpEq64,
+	opAndType{ir.OEQ, types.TINTER}:     ssa.OpEqInter,
+	opAndType{ir.OEQ, types.TSLICE}:     ssa.OpEqSlice,
+	opAndType{ir.OEQ, types.TFUNC}:      ssa.OpEqPtr,
+	opAndType{ir.OEQ, types.TMAP}:       ssa.OpEqPtr,
+	opAndType{ir.OEQ, types.TCHAN}:      ssa.OpEqPtr,
+	opAndType{ir.OEQ, types.TPTR}:       ssa.OpEqPtr,
+	opAndType{ir.OEQ, types.TUINTPTR}:   ssa.OpEqPtr,
+	opAndType{ir.OEQ, types.TUNSAFEPTR}: ssa.OpEqPtr,
+	opAndType{ir.OEQ, types.TFLOAT64}:   ssa.OpEq64F,
+	opAndType{ir.OEQ, types.TFLOAT32}:   ssa.OpEq32F,
+
+	opAndType{ir.ONE, types.TBOOL}:      ssa.OpNeqB,
+	opAndType{ir.ONE, types.TINT8}:      ssa.OpNeq8,
+	opAndType{ir.ONE, types.TUINT8}:     ssa.OpNeq8,
+	opAndType{ir.ONE, types.TINT16}:     ssa.OpNeq16,
+	opAndType{ir.ONE, types.TUINT16}:    ssa.OpNeq16,
+	opAndType{ir.ONE, types.TINT32}:     ssa.OpNeq32,
+	opAndType{ir.ONE, types.TUINT32}:    ssa.OpNeq32,
+	opAndType{ir.ONE, types.TINT64}:     ssa.OpNeq64,
+	opAndType{ir.ONE, types.TUINT64}:    ssa.OpNeq64,
+	opAndType{ir.ONE, types.TINTER}:     ssa.OpNeqInter,
+	opAndType{ir.ONE, types.TSLICE}:     ssa.OpNeqSlice,
+	opAndType{ir.ONE, types.TFUNC}:      ssa.OpNeqPtr,
+	opAndType{ir.ONE, types.TMAP}:       ssa.OpNeqPtr,
+	opAndType{ir.ONE, types.TCHAN}:      ssa.OpNeqPtr,
+	opAndType{ir.ONE, types.TPTR}:       ssa.OpNeqPtr,
+	opAndType{ir.ONE, types.TUINTPTR}:   ssa.OpNeqPtr,
+	opAndType{ir.ONE, types.TUNSAFEPTR}: ssa.OpNeqPtr,
+	opAndType{ir.ONE, types.TFLOAT64}:   ssa.OpNeq64F,
+	opAndType{ir.ONE, types.TFLOAT32}:   ssa.OpNeq32F,
+
+	opAndType{ir.OLT, types.TINT8}:    ssa.OpLess8,
+	opAndType{ir.OLT, types.TUINT8}:   ssa.OpLess8U,
+	opAndType{ir.OLT, types.TINT16}:   ssa.OpLess16,
+	opAndType{ir.OLT, types.TUINT16}:  ssa.OpLess16U,
+	opAndType{ir.OLT, types.TINT32}:   ssa.OpLess32,
+	opAndType{ir.OLT, types.TUINT32}:  ssa.OpLess32U,
+	opAndType{ir.OLT, types.TINT64}:   ssa.OpLess64,
+	opAndType{ir.OLT, types.TUINT64}:  ssa.OpLess64U,
+	opAndType{ir.OLT, types.TFLOAT64}: ssa.OpLess64F,
+	opAndType{ir.OLT, types.TFLOAT32}: ssa.OpLess32F,
+
+	opAndType{ir.OLE, types.TINT8}:    ssa.OpLeq8,
+	opAndType{ir.OLE, types.TUINT8}:   ssa.OpLeq8U,
+	opAndType{ir.OLE, types.TINT16}:   ssa.OpLeq16,
+	opAndType{ir.OLE, types.TUINT16}:  ssa.OpLeq16U,
+	opAndType{ir.OLE, types.TINT32}:   ssa.OpLeq32,
+	opAndType{ir.OLE, types.TUINT32}:  ssa.OpLeq32U,
+	opAndType{ir.OLE, types.TINT64}:   ssa.OpLeq64,
+	opAndType{ir.OLE, types.TUINT64}:  ssa.OpLeq64U,
+	opAndType{ir.OLE, types.TFLOAT64}: ssa.OpLeq64F,
+	opAndType{ir.OLE, types.TFLOAT32}: ssa.OpLeq32F,
 }
 
 func (s *state) concreteEtype(t *types.Type) types.EType {
@@ -1781,25 +1782,25 @@ func (s *state) concreteEtype(t *types.Type) types.EType {
 	switch e {
 	default:
 		return e
-	case TINT:
+	case types.TINT:
 		if s.config.PtrSize == 8 {
-			return TINT64
+			return types.TINT64
 		}
-		return TINT32
-	case TUINT:
+		return types.TINT32
+	case types.TUINT:
 		if s.config.PtrSize == 8 {
-			return TUINT64
+			return types.TUINT64
 		}
-		return TUINT32
-	case TUINTPTR:
+		return types.TUINT32
+	case types.TUINTPTR:
 		if s.config.PtrSize == 8 {
-			return TUINT64
+			return types.TUINT64
 		}
-		return TUINT32
+		return types.TUINT32
 	}
 }
 
-func (s *state) ssaOp(op Op, t *types.Type) ssa.Op {
+func (s *state) ssaOp(op ir.Op, t *types.Type) ssa.Op {
 	etype := s.concreteEtype(t)
 	x, ok := opToSSA[opAndType{op, etype}]
 	if !ok {
@@ -1810,10 +1811,10 @@ func (s *state) ssaOp(op Op, t *types.Type) ssa.Op {
 
 func floatForComplex(t *types.Type) *types.Type {
 	switch t.Etype {
-	case TCOMPLEX64:
-		return types.Types[TFLOAT32]
-	case TCOMPLEX128:
-		return types.Types[TFLOAT64]
+	case types.TCOMPLEX64:
+		return types.Types[types.TFLOAT32]
+	case types.TCOMPLEX128:
+		return types.Types[types.TFLOAT64]
 	}
 	base.Fatalf("unexpected type: %v", t)
 	return nil
@@ -1821,17 +1822,17 @@ func floatForComplex(t *types.Type) *types.Type {
 
 func complexForFloat(t *types.Type) *types.Type {
 	switch t.Etype {
-	case TFLOAT32:
-		return types.Types[TCOMPLEX64]
-	case TFLOAT64:
-		return types.Types[TCOMPLEX128]
+	case types.TFLOAT32:
+		return types.Types[types.TCOMPLEX64]
+	case types.TFLOAT64:
+		return types.Types[types.TCOMPLEX128]
 	}
 	base.Fatalf("unexpected type: %v", t)
 	return nil
 }
 
 type opAndTwoTypes struct {
-	op     Op
+	op     ir.Op
 	etype1 types.EType
 	etype2 types.EType
 }
@@ -1849,145 +1850,145 @@ type twoOpsAndType struct {
 
 var fpConvOpToSSA = map[twoTypes]twoOpsAndType{
 
-	twoTypes{TINT8, TFLOAT32}:  twoOpsAndType{ssa.OpSignExt8to32, ssa.OpCvt32to32F, TINT32},
-	twoTypes{TINT16, TFLOAT32}: twoOpsAndType{ssa.OpSignExt16to32, ssa.OpCvt32to32F, TINT32},
-	twoTypes{TINT32, TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt32to32F, TINT32},
-	twoTypes{TINT64, TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt64to32F, TINT64},
-
-	twoTypes{TINT8, TFLOAT64}:  twoOpsAndType{ssa.OpSignExt8to32, ssa.OpCvt32to64F, TINT32},
-	twoTypes{TINT16, TFLOAT64}: twoOpsAndType{ssa.OpSignExt16to32, ssa.OpCvt32to64F, TINT32},
-	twoTypes{TINT32, TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt32to64F, TINT32},
-	twoTypes{TINT64, TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt64to64F, TINT64},
-
-	twoTypes{TFLOAT32, TINT8}:  twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpTrunc32to8, TINT32},
-	twoTypes{TFLOAT32, TINT16}: twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpTrunc32to16, TINT32},
-	twoTypes{TFLOAT32, TINT32}: twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpCopy, TINT32},
-	twoTypes{TFLOAT32, TINT64}: twoOpsAndType{ssa.OpCvt32Fto64, ssa.OpCopy, TINT64},
-
-	twoTypes{TFLOAT64, TINT8}:  twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpTrunc32to8, TINT32},
-	twoTypes{TFLOAT64, TINT16}: twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpTrunc32to16, TINT32},
-	twoTypes{TFLOAT64, TINT32}: twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpCopy, TINT32},
-	twoTypes{TFLOAT64, TINT64}: twoOpsAndType{ssa.OpCvt64Fto64, ssa.OpCopy, TINT64},
+	twoTypes{types.TINT8, types.TFLOAT32}:  twoOpsAndType{ssa.OpSignExt8to32, ssa.OpCvt32to32F, types.TINT32},
+	twoTypes{types.TINT16, types.TFLOAT32}: twoOpsAndType{ssa.OpSignExt16to32, ssa.OpCvt32to32F, types.TINT32},
+	twoTypes{types.TINT32, types.TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt32to32F, types.TINT32},
+	twoTypes{types.TINT64, types.TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt64to32F, types.TINT64},
+
+	twoTypes{types.TINT8, types.TFLOAT64}:  twoOpsAndType{ssa.OpSignExt8to32, ssa.OpCvt32to64F, types.TINT32},
+	twoTypes{types.TINT16, types.TFLOAT64}: twoOpsAndType{ssa.OpSignExt16to32, ssa.OpCvt32to64F, types.TINT32},
+	twoTypes{types.TINT32, types.TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt32to64F, types.TINT32},
+	twoTypes{types.TINT64, types.TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt64to64F, types.TINT64},
+
+	twoTypes{types.TFLOAT32, types.TINT8}:  twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpTrunc32to8, types.TINT32},
+	twoTypes{types.TFLOAT32, types.TINT16}: twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpTrunc32to16, types.TINT32},
+	twoTypes{types.TFLOAT32, types.TINT32}: twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpCopy, types.TINT32},
+	twoTypes{types.TFLOAT32, types.TINT64}: twoOpsAndType{ssa.OpCvt32Fto64, ssa.OpCopy, types.TINT64},
+
+	twoTypes{types.TFLOAT64, types.TINT8}:  twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpTrunc32to8, types.TINT32},
+	twoTypes{types.TFLOAT64, types.TINT16}: twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpTrunc32to16, types.TINT32},
+	twoTypes{types.TFLOAT64, types.TINT32}: twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpCopy, types.TINT32},
+	twoTypes{types.TFLOAT64, types.TINT64}: twoOpsAndType{ssa.OpCvt64Fto64, ssa.OpCopy, types.TINT64},
 	// unsigned
-	twoTypes{TUINT8, TFLOAT32}:  twoOpsAndType{ssa.OpZeroExt8to32, ssa.OpCvt32to32F, TINT32},
-	twoTypes{TUINT16, TFLOAT32}: twoOpsAndType{ssa.OpZeroExt16to32, ssa.OpCvt32to32F, TINT32},
-	twoTypes{TUINT32, TFLOAT32}: twoOpsAndType{ssa.OpZeroExt32to64, ssa.OpCvt64to32F, TINT64}, // go wide to dodge unsigned
-	twoTypes{TUINT64, TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpInvalid, TUINT64},            // Cvt64Uto32F, branchy code expansion instead
-
-	twoTypes{TUINT8, TFLOAT64}:  twoOpsAndType{ssa.OpZeroExt8to32, ssa.OpCvt32to64F, TINT32},
-	twoTypes{TUINT16, TFLOAT64}: twoOpsAndType{ssa.OpZeroExt16to32, ssa.OpCvt32to64F, TINT32},
-	twoTypes{TUINT32, TFLOAT64}: twoOpsAndType{ssa.OpZeroExt32to64, ssa.OpCvt64to64F, TINT64}, // go wide to dodge unsigned
-	twoTypes{TUINT64, TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpInvalid, TUINT64},            // Cvt64Uto64F, branchy code expansion instead
-
-	twoTypes{TFLOAT32, TUINT8}:  twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpTrunc32to8, TINT32},
-	twoTypes{TFLOAT32, TUINT16}: twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpTrunc32to16, TINT32},
-	twoTypes{TFLOAT32, TUINT32}: twoOpsAndType{ssa.OpCvt32Fto64, ssa.OpTrunc64to32, TINT64}, // go wide to dodge unsigned
-	twoTypes{TFLOAT32, TUINT64}: twoOpsAndType{ssa.OpInvalid, ssa.OpCopy, TUINT64},          // Cvt32Fto64U, branchy code expansion instead
-
-	twoTypes{TFLOAT64, TUINT8}:  twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpTrunc32to8, TINT32},
-	twoTypes{TFLOAT64, TUINT16}: twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpTrunc32to16, TINT32},
-	twoTypes{TFLOAT64, TUINT32}: twoOpsAndType{ssa.OpCvt64Fto64, ssa.OpTrunc64to32, TINT64}, // go wide to dodge unsigned
-	twoTypes{TFLOAT64, TUINT64}: twoOpsAndType{ssa.OpInvalid, ssa.OpCopy, TUINT64},          // Cvt64Fto64U, branchy code expansion instead
+	twoTypes{types.TUINT8, types.TFLOAT32}:  twoOpsAndType{ssa.OpZeroExt8to32, ssa.OpCvt32to32F, types.TINT32},
+	twoTypes{types.TUINT16, types.TFLOAT32}: twoOpsAndType{ssa.OpZeroExt16to32, ssa.OpCvt32to32F, types.TINT32},
+	twoTypes{types.TUINT32, types.TFLOAT32}: twoOpsAndType{ssa.OpZeroExt32to64, ssa.OpCvt64to32F, types.TINT64}, // go wide to dodge unsigned
+	twoTypes{types.TUINT64, types.TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpInvalid, types.TUINT64},            // Cvt64Uto32F, branchy code expansion instead
+
+	twoTypes{types.TUINT8, types.TFLOAT64}:  twoOpsAndType{ssa.OpZeroExt8to32, ssa.OpCvt32to64F, types.TINT32},
+	twoTypes{types.TUINT16, types.TFLOAT64}: twoOpsAndType{ssa.OpZeroExt16to32, ssa.OpCvt32to64F, types.TINT32},
+	twoTypes{types.TUINT32, types.TFLOAT64}: twoOpsAndType{ssa.OpZeroExt32to64, ssa.OpCvt64to64F, types.TINT64}, // go wide to dodge unsigned
+	twoTypes{types.TUINT64, types.TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpInvalid, types.TUINT64},            // Cvt64Uto64F, branchy code expansion instead
+
+	twoTypes{types.TFLOAT32, types.TUINT8}:  twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpTrunc32to8, types.TINT32},
+	twoTypes{types.TFLOAT32, types.TUINT16}: twoOpsAndType{ssa.OpCvt32Fto32, ssa.OpTrunc32to16, types.TINT32},
+	twoTypes{types.TFLOAT32, types.TUINT32}: twoOpsAndType{ssa.OpCvt32Fto64, ssa.OpTrunc64to32, types.TINT64}, // go wide to dodge unsigned
+	twoTypes{types.TFLOAT32, types.TUINT64}: twoOpsAndType{ssa.OpInvalid, ssa.OpCopy, types.TUINT64},          // Cvt32Fto64U, branchy code expansion instead
+
+	twoTypes{types.TFLOAT64, types.TUINT8}:  twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpTrunc32to8, types.TINT32},
+	twoTypes{types.TFLOAT64, types.TUINT16}: twoOpsAndType{ssa.OpCvt64Fto32, ssa.OpTrunc32to16, types.TINT32},
+	twoTypes{types.TFLOAT64, types.TUINT32}: twoOpsAndType{ssa.OpCvt64Fto64, ssa.OpTrunc64to32, types.TINT64}, // go wide to dodge unsigned
+	twoTypes{types.TFLOAT64, types.TUINT64}: twoOpsAndType{ssa.OpInvalid, ssa.OpCopy, types.TUINT64},          // Cvt64Fto64U, branchy code expansion instead
 
 	// float
-	twoTypes{TFLOAT64, TFLOAT32}: twoOpsAndType{ssa.OpCvt64Fto32F, ssa.OpCopy, TFLOAT32},
-	twoTypes{TFLOAT64, TFLOAT64}: twoOpsAndType{ssa.OpRound64F, ssa.OpCopy, TFLOAT64},
-	twoTypes{TFLOAT32, TFLOAT32}: twoOpsAndType{ssa.OpRound32F, ssa.OpCopy, TFLOAT32},
-	twoTypes{TFLOAT32, TFLOAT64}: twoOpsAndType{ssa.OpCvt32Fto64F, ssa.OpCopy, TFLOAT64},
+	twoTypes{types.TFLOAT64, types.TFLOAT32}: twoOpsAndType{ssa.OpCvt64Fto32F, ssa.OpCopy, types.TFLOAT32},
+	twoTypes{types.TFLOAT64, types.TFLOAT64}: twoOpsAndType{ssa.OpRound64F, ssa.OpCopy, types.TFLOAT64},
+	twoTypes{types.TFLOAT32, types.TFLOAT32}: twoOpsAndType{ssa.OpRound32F, ssa.OpCopy, types.TFLOAT32},
+	twoTypes{types.TFLOAT32, types.TFLOAT64}: twoOpsAndType{ssa.OpCvt32Fto64F, ssa.OpCopy, types.TFLOAT64},
 }
 
 // this map is used only for 32-bit arch, and only includes the difference
 // on 32-bit arch, don't use int64<->float conversion for uint32
 var fpConvOpToSSA32 = map[twoTypes]twoOpsAndType{
-	twoTypes{TUINT32, TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt32Uto32F, TUINT32},
-	twoTypes{TUINT32, TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt32Uto64F, TUINT32},
-	twoTypes{TFLOAT32, TUINT32}: twoOpsAndType{ssa.OpCvt32Fto32U, ssa.OpCopy, TUINT32},
-	twoTypes{TFLOAT64, TUINT32}: twoOpsAndType{ssa.OpCvt64Fto32U, ssa.OpCopy, TUINT32},
+	twoTypes{types.TUINT32, types.TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt32Uto32F, types.TUINT32},
+	twoTypes{types.TUINT32, types.TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt32Uto64F, types.TUINT32},
+	twoTypes{types.TFLOAT32, types.TUINT32}: twoOpsAndType{ssa.OpCvt32Fto32U, ssa.OpCopy, types.TUINT32},
+	twoTypes{types.TFLOAT64, types.TUINT32}: twoOpsAndType{ssa.OpCvt64Fto32U, ssa.OpCopy, types.TUINT32},
 }
 
 // uint64<->float conversions, only on machines that have instructions for that
 var uint64fpConvOpToSSA = map[twoTypes]twoOpsAndType{
-	twoTypes{TUINT64, TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt64Uto32F, TUINT64},
-	twoTypes{TUINT64, TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt64Uto64F, TUINT64},
-	twoTypes{TFLOAT32, TUINT64}: twoOpsAndType{ssa.OpCvt32Fto64U, ssa.OpCopy, TUINT64},
-	twoTypes{TFLOAT64, TUINT64}: twoOpsAndType{ssa.OpCvt64Fto64U, ssa.OpCopy, TUINT64},
+	twoTypes{types.TUINT64, types.TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt64Uto32F, types.TUINT64},
+	twoTypes{types.TUINT64, types.TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt64Uto64F, types.TUINT64},
+	twoTypes{types.TFLOAT32, types.TUINT64}: twoOpsAndType{ssa.OpCvt32Fto64U, ssa.OpCopy, types.TUINT64},
+	twoTypes{types.TFLOAT64, types.TUINT64}: twoOpsAndType{ssa.OpCvt64Fto64U, ssa.OpCopy, types.TUINT64},
 }
 
 var shiftOpToSSA = map[opAndTwoTypes]ssa.Op{
-	opAndTwoTypes{OLSH, TINT8, TUINT8}:   ssa.OpLsh8x8,
-	opAndTwoTypes{OLSH, TUINT8, TUINT8}:  ssa.OpLsh8x8,
-	opAndTwoTypes{OLSH, TINT8, TUINT16}:  ssa.OpLsh8x16,
-	opAndTwoTypes{OLSH, TUINT8, TUINT16}: ssa.OpLsh8x16,
-	opAndTwoTypes{OLSH, TINT8, TUINT32}:  ssa.OpLsh8x32,
-	opAndTwoTypes{OLSH, TUINT8, TUINT32}: ssa.OpLsh8x32,
-	opAndTwoTypes{OLSH, TINT8, TUINT64}:  ssa.OpLsh8x64,
-	opAndTwoTypes{OLSH, TUINT8, TUINT64}: ssa.OpLsh8x64,
-
-	opAndTwoTypes{OLSH, TINT16, TUINT8}:   ssa.OpLsh16x8,
-	opAndTwoTypes{OLSH, TUINT16, TUINT8}:  ssa.OpLsh16x8,
-	opAndTwoTypes{OLSH, TINT16, TUINT16}:  ssa.OpLsh16x16,
-	opAndTwoTypes{OLSH, TUINT16, TUINT16}: ssa.OpLsh16x16,
-	opAndTwoTypes{OLSH, TINT16, TUINT32}:  ssa.OpLsh16x32,
-	opAndTwoTypes{OLSH, TUINT16, TUINT32}: ssa.OpLsh16x32,
-	opAndTwoTypes{OLSH, TINT16, TUINT64}:  ssa.OpLsh16x64,
-	opAndTwoTypes{OLSH, TUINT16, TUINT64}: ssa.OpLsh16x64,
-
-	opAndTwoTypes{OLSH, TINT32, TUINT8}:   ssa.OpLsh32x8,
-	opAndTwoTypes{OLSH, TUINT32, TUINT8}:  ssa.OpLsh32x8,
-	opAndTwoTypes{OLSH, TINT32, TUINT16}:  ssa.OpLsh32x16,
-	opAndTwoTypes{OLSH, TUINT32, TUINT16}: ssa.OpLsh32x16,
-	opAndTwoTypes{OLSH, TINT32, TUINT32}:  ssa.OpLsh32x32,
-	opAndTwoTypes{OLSH, TUINT32, TUINT32}: ssa.OpLsh32x32,
-	opAndTwoTypes{OLSH, TINT32, TUINT64}:  ssa.OpLsh32x64,
-	opAndTwoTypes{OLSH, TUINT32, TUINT64}: ssa.OpLsh32x64,
-
-	opAndTwoTypes{OLSH, TINT64, TUINT8}:   ssa.OpLsh64x8,
-	opAndTwoTypes{OLSH, TUINT64, TUINT8}:  ssa.OpLsh64x8,
-	opAndTwoTypes{OLSH, TINT64, TUINT16}:  ssa.OpLsh64x16,
-	opAndTwoTypes{OLSH, TUINT64, TUINT16}: ssa.OpLsh64x16,
-	opAndTwoTypes{OLSH, TINT64, TUINT32}:  ssa.OpLsh64x32,
-	opAndTwoTypes{OLSH, TUINT64, TUINT32}: ssa.OpLsh64x32,
-	opAndTwoTypes{OLSH, TINT64, TUINT64}:  ssa.OpLsh64x64,
-	opAndTwoTypes{OLSH, TUINT64, TUINT64}: ssa.OpLsh64x64,
-
-	opAndTwoTypes{ORSH, TINT8, TUINT8}:   ssa.OpRsh8x8,
-	opAndTwoTypes{ORSH, TUINT8, TUINT8}:  ssa.OpRsh8Ux8,
-	opAndTwoTypes{ORSH, TINT8, TUINT16}:  ssa.OpRsh8x16,
-	opAndTwoTypes{ORSH, TUINT8, TUINT16}: ssa.OpRsh8Ux16,
-	opAndTwoTypes{ORSH, TINT8, TUINT32}:  ssa.OpRsh8x32,
-	opAndTwoTypes{ORSH, TUINT8, TUINT32}: ssa.OpRsh8Ux32,
-	opAndTwoTypes{ORSH, TINT8, TUINT64}:  ssa.OpRsh8x64,
-	opAndTwoTypes{ORSH, TUINT8, TUINT64}: ssa.OpRsh8Ux64,
-
-	opAndTwoTypes{ORSH, TINT16, TUINT8}:   ssa.OpRsh16x8,
-	opAndTwoTypes{ORSH, TUINT16, TUINT8}:  ssa.OpRsh16Ux8,
-	opAndTwoTypes{ORSH, TINT16, TUINT16}:  ssa.OpRsh16x16,
-	opAndTwoTypes{ORSH, TUINT16, TUINT16}: ssa.OpRsh16Ux16,
-	opAndTwoTypes{ORSH, TINT16, TUINT32}:  ssa.OpRsh16x32,
-	opAndTwoTypes{ORSH, TUINT16, TUINT32}: ssa.OpRsh16Ux32,
-	opAndTwoTypes{ORSH, TINT16, TUINT64}:  ssa.OpRsh16x64,
-	opAndTwoTypes{ORSH, TUINT16, TUINT64}: ssa.OpRsh16Ux64,
-
-	opAndTwoTypes{ORSH, TINT32, TUINT8}:   ssa.OpRsh32x8,
-	opAndTwoTypes{ORSH, TUINT32, TUINT8}:  ssa.OpRsh32Ux8,
-	opAndTwoTypes{ORSH, TINT32, TUINT16}:  ssa.OpRsh32x16,
-	opAndTwoTypes{ORSH, TUINT32, TUINT16}: ssa.OpRsh32Ux16,
-	opAndTwoTypes{ORSH, TINT32, TUINT32}:  ssa.OpRsh32x32,
-	opAndTwoTypes{ORSH, TUINT32, TUINT32}: ssa.OpRsh32Ux32,
-	opAndTwoTypes{ORSH, TINT32, TUINT64}:  ssa.OpRsh32x64,
-	opAndTwoTypes{ORSH, TUINT32, TUINT64}: ssa.OpRsh32Ux64,
-
-	opAndTwoTypes{ORSH, TINT64, TUINT8}:   ssa.OpRsh64x8,
-	opAndTwoTypes{ORSH, TUINT64, TUINT8}:  ssa.OpRsh64Ux8,
-	opAndTwoTypes{ORSH, TINT64, TUINT16}:  ssa.OpRsh64x16,
-	opAndTwoTypes{ORSH, TUINT64, TUINT16}: ssa.OpRsh64Ux16,
-	opAndTwoTypes{ORSH, TINT64, TUINT32}:  ssa.OpRsh64x32,
-	opAndTwoTypes{ORSH, TUINT64, TUINT32}: ssa.OpRsh64Ux32,
-	opAndTwoTypes{ORSH, TINT64, TUINT64}:  ssa.OpRsh64x64,
-	opAndTwoTypes{ORSH, TUINT64, TUINT64}: ssa.OpRsh64Ux64,
-}
-
-func (s *state) ssaShiftOp(op Op, t *types.Type, u *types.Type) ssa.Op {
+	opAndTwoTypes{ir.OLSH, types.TINT8, types.TUINT8}:   ssa.OpLsh8x8,
+	opAndTwoTypes{ir.OLSH, types.TUINT8, types.TUINT8}:  ssa.OpLsh8x8,
+	opAndTwoTypes{ir.OLSH, types.TINT8, types.TUINT16}:  ssa.OpLsh8x16,
+	opAndTwoTypes{ir.OLSH, types.TUINT8, types.TUINT16}: ssa.OpLsh8x16,
+	opAndTwoTypes{ir.OLSH, types.TINT8, types.TUINT32}:  ssa.OpLsh8x32,
+	opAndTwoTypes{ir.OLSH, types.TUINT8, types.TUINT32}: ssa.OpLsh8x32,
+	opAndTwoTypes{ir.OLSH, types.TINT8, types.TUINT64}:  ssa.OpLsh8x64,
+	opAndTwoTypes{ir.OLSH, types.TUINT8, types.TUINT64}: ssa.OpLsh8x64,
+
+	opAndTwoTypes{ir.OLSH, types.TINT16, types.TUINT8}:   ssa.OpLsh16x8,
+	opAndTwoTypes{ir.OLSH, types.TUINT16, types.TUINT8}:  ssa.OpLsh16x8,
+	opAndTwoTypes{ir.OLSH, types.TINT16, types.TUINT16}:  ssa.OpLsh16x16,
+	opAndTwoTypes{ir.OLSH, types.TUINT16, types.TUINT16}: ssa.OpLsh16x16,
+	opAndTwoTypes{ir.OLSH, types.TINT16, types.TUINT32}:  ssa.OpLsh16x32,
+	opAndTwoTypes{ir.OLSH, types.TUINT16, types.TUINT32}: ssa.OpLsh16x32,
+	opAndTwoTypes{ir.OLSH, types.TINT16, types.TUINT64}:  ssa.OpLsh16x64,
+	opAndTwoTypes{ir.OLSH, types.TUINT16, types.TUINT64}: ssa.OpLsh16x64,
+
+	opAndTwoTypes{ir.OLSH, types.TINT32, types.TUINT8}:   ssa.OpLsh32x8,
+	opAndTwoTypes{ir.OLSH, types.TUINT32, types.TUINT8}:  ssa.OpLsh32x8,
+	opAndTwoTypes{ir.OLSH, types.TINT32, types.TUINT16}:  ssa.OpLsh32x16,
+	opAndTwoTypes{ir.OLSH, types.TUINT32, types.TUINT16}: ssa.OpLsh32x16,
+	opAndTwoTypes{ir.OLSH, types.TINT32, types.TUINT32}:  ssa.OpLsh32x32,
+	opAndTwoTypes{ir.OLSH, types.TUINT32, types.TUINT32}: ssa.OpLsh32x32,
+	opAndTwoTypes{ir.OLSH, types.TINT32, types.TUINT64}:  ssa.OpLsh32x64,
+	opAndTwoTypes{ir.OLSH, types.TUINT32, types.TUINT64}: ssa.OpLsh32x64,
+
+	opAndTwoTypes{ir.OLSH, types.TINT64, types.TUINT8}:   ssa.OpLsh64x8,
+	opAndTwoTypes{ir.OLSH, types.TUINT64, types.TUINT8}:  ssa.OpLsh64x8,
+	opAndTwoTypes{ir.OLSH, types.TINT64, types.TUINT16}:  ssa.OpLsh64x16,
+	opAndTwoTypes{ir.OLSH, types.TUINT64, types.TUINT16}: ssa.OpLsh64x16,
+	opAndTwoTypes{ir.OLSH, types.TINT64, types.TUINT32}:  ssa.OpLsh64x32,
+	opAndTwoTypes{ir.OLSH, types.TUINT64, types.TUINT32}: ssa.OpLsh64x32,
+	opAndTwoTypes{ir.OLSH, types.TINT64, types.TUINT64}:  ssa.OpLsh64x64,
+	opAndTwoTypes{ir.OLSH, types.TUINT64, types.TUINT64}: ssa.OpLsh64x64,
+
+	opAndTwoTypes{ir.ORSH, types.TINT8, types.TUINT8}:   ssa.OpRsh8x8,
+	opAndTwoTypes{ir.ORSH, types.TUINT8, types.TUINT8}:  ssa.OpRsh8Ux8,
+	opAndTwoTypes{ir.ORSH, types.TINT8, types.TUINT16}:  ssa.OpRsh8x16,
+	opAndTwoTypes{ir.ORSH, types.TUINT8, types.TUINT16}: ssa.OpRsh8Ux16,
+	opAndTwoTypes{ir.ORSH, types.TINT8, types.TUINT32}:  ssa.OpRsh8x32,
+	opAndTwoTypes{ir.ORSH, types.TUINT8, types.TUINT32}: ssa.OpRsh8Ux32,
+	opAndTwoTypes{ir.ORSH, types.TINT8, types.TUINT64}:  ssa.OpRsh8x64,
+	opAndTwoTypes{ir.ORSH, types.TUINT8, types.TUINT64}: ssa.OpRsh8Ux64,
+
+	opAndTwoTypes{ir.ORSH, types.TINT16, types.TUINT8}:   ssa.OpRsh16x8,
+	opAndTwoTypes{ir.ORSH, types.TUINT16, types.TUINT8}:  ssa.OpRsh16Ux8,
+	opAndTwoTypes{ir.ORSH, types.TINT16, types.TUINT16}:  ssa.OpRsh16x16,
+	opAndTwoTypes{ir.ORSH, types.TUINT16, types.TUINT16}: ssa.OpRsh16Ux16,
+	opAndTwoTypes{ir.ORSH, types.TINT16, types.TUINT32}:  ssa.OpRsh16x32,
+	opAndTwoTypes{ir.ORSH, types.TUINT16, types.TUINT32}: ssa.OpRsh16Ux32,
+	opAndTwoTypes{ir.ORSH, types.TINT16, types.TUINT64}:  ssa.OpRsh16x64,
+	opAndTwoTypes{ir.ORSH, types.TUINT16, types.TUINT64}: ssa.OpRsh16Ux64,
+
+	opAndTwoTypes{ir.ORSH, types.TINT32, types.TUINT8}:   ssa.OpRsh32x8,
+	opAndTwoTypes{ir.ORSH, types.TUINT32, types.TUINT8}:  ssa.OpRsh32Ux8,
+	opAndTwoTypes{ir.ORSH, types.TINT32, types.TUINT16}:  ssa.OpRsh32x16,
+	opAndTwoTypes{ir.ORSH, types.TUINT32, types.TUINT16}: ssa.OpRsh32Ux16,
+	opAndTwoTypes{ir.ORSH, types.TINT32, types.TUINT32}:  ssa.OpRsh32x32,
+	opAndTwoTypes{ir.ORSH, types.TUINT32, types.TUINT32}: ssa.OpRsh32Ux32,
+	opAndTwoTypes{ir.ORSH, types.TINT32, types.TUINT64}:  ssa.OpRsh32x64,
+	opAndTwoTypes{ir.ORSH, types.TUINT32, types.TUINT64}: ssa.OpRsh32Ux64,
+
+	opAndTwoTypes{ir.ORSH, types.TINT64, types.TUINT8}:   ssa.OpRsh64x8,
+	opAndTwoTypes{ir.ORSH, types.TUINT64, types.TUINT8}:  ssa.OpRsh64Ux8,
+	opAndTwoTypes{ir.ORSH, types.TINT64, types.TUINT16}:  ssa.OpRsh64x16,
+	opAndTwoTypes{ir.ORSH, types.TUINT64, types.TUINT16}: ssa.OpRsh64Ux16,
+	opAndTwoTypes{ir.ORSH, types.TINT64, types.TUINT32}:  ssa.OpRsh64x32,
+	opAndTwoTypes{ir.ORSH, types.TUINT64, types.TUINT32}: ssa.OpRsh64Ux32,
+	opAndTwoTypes{ir.ORSH, types.TINT64, types.TUINT64}:  ssa.OpRsh64x64,
+	opAndTwoTypes{ir.ORSH, types.TUINT64, types.TUINT64}: ssa.OpRsh64Ux64,
+}
+
+func (s *state) ssaShiftOp(op ir.Op, t *types.Type, u *types.Type) ssa.Op {
 	etype1 := s.concreteEtype(t)
 	etype2 := s.concreteEtype(u)
 	x, ok := shiftOpToSSA[opAndTwoTypes{op, etype1, etype2}]
@@ -1998,7 +1999,7 @@ func (s *state) ssaShiftOp(op Op, t *types.Type, u *types.Type) ssa.Op {
 }
 
 // expr converts the expression n to ssa, adds it to s and returns the ssa result.
-func (s *state) expr(n *Node) *ssa.Value {
+func (s *state) expr(n *ir.Node) *ssa.Value {
 	if hasUniquePos(n) {
 		// ONAMEs and named OLITERALs have the line number
 		// of the decl, not the use. See issue 14742.
@@ -2008,24 +2009,24 @@ func (s *state) expr(n *Node) *ssa.Value {
 
 	s.stmtList(n.Ninit)
 	switch n.Op {
-	case OBYTES2STRTMP:
+	case ir.OBYTES2STRTMP:
 		slice := s.expr(n.Left)
 		ptr := s.newValue1(ssa.OpSlicePtr, s.f.Config.Types.BytePtr, slice)
-		len := s.newValue1(ssa.OpSliceLen, types.Types[TINT], slice)
+		len := s.newValue1(ssa.OpSliceLen, types.Types[types.TINT], slice)
 		return s.newValue2(ssa.OpStringMake, n.Type, ptr, len)
-	case OSTR2BYTESTMP:
+	case ir.OSTR2BYTESTMP:
 		str := s.expr(n.Left)
 		ptr := s.newValue1(ssa.OpStringPtr, s.f.Config.Types.BytePtr, str)
-		len := s.newValue1(ssa.OpStringLen, types.Types[TINT], str)
+		len := s.newValue1(ssa.OpStringLen, types.Types[types.TINT], str)
 		return s.newValue3(ssa.OpSliceMake, n.Type, ptr, len, len)
-	case OCFUNC:
+	case ir.OCFUNC:
 		aux := n.Left.Sym.Linksym()
 		return s.entryNewValue1A(ssa.OpAddr, n.Type, aux, s.sb)
-	case OMETHEXPR:
+	case ir.OMETHEXPR:
 		sym := funcsym(n.Sym).Linksym()
 		return s.entryNewValue1A(ssa.OpAddr, types.NewPtr(n.Type), sym, s.sb)
-	case ONAME:
-		if n.Class() == PFUNC {
+	case ir.ONAME:
+		if n.Class() == ir.PFUNC {
 			// "value" of a function is the address of the function's closure
 			sym := funcsym(n.Sym).Linksym()
 			return s.entryNewValue1A(ssa.OpAddr, types.NewPtr(n.Type), sym, s.sb)
@@ -2035,10 +2036,10 @@ func (s *state) expr(n *Node) *ssa.Value {
 		}
 		addr := s.addr(n)
 		return s.load(n.Type, addr)
-	case OCLOSUREVAR:
+	case ir.OCLOSUREVAR:
 		addr := s.addr(n)
 		return s.load(n.Type, addr)
-	case ONIL:
+	case ir.ONIL:
 		t := n.Type
 		switch {
 		case t.IsSlice():
@@ -2048,10 +2049,10 @@ func (s *state) expr(n *Node) *ssa.Value {
 		default:
 			return s.constNil(t)
 		}
-	case OLITERAL:
+	case ir.OLITERAL:
 		switch u := n.Val(); u.Kind() {
 		case constant.Int:
-			i := int64Val(n.Type, u)
+			i := ir.Int64Val(n.Type, u)
 			switch n.Type.Size() {
 			case 1:
 				return s.constInt8(n.Type, int8(i))
@@ -2089,12 +2090,12 @@ func (s *state) expr(n *Node) *ssa.Value {
 			im, _ := constant.Float64Val(constant.Imag(u))
 			switch n.Type.Size() {
 			case 8:
-				pt := types.Types[TFLOAT32]
+				pt := types.Types[types.TFLOAT32]
 				return s.newValue2(ssa.OpComplexMake, n.Type,
 					s.constFloat32(pt, re),
 					s.constFloat32(pt, im))
 			case 16:
-				pt := types.Types[TFLOAT64]
+				pt := types.Types[types.TFLOAT64]
 				return s.newValue2(ssa.OpComplexMake, n.Type,
 					s.constFloat64(pt, re),
 					s.constFloat64(pt, im))
@@ -2106,7 +2107,7 @@ func (s *state) expr(n *Node) *ssa.Value {
 			s.Fatalf("unhandled OLITERAL %v", u.Kind())
 			return nil
 		}
-	case OCONVNOP:
+	case ir.OCONVNOP:
 		to := n.Type
 		from := n.Left.Type
 
@@ -2125,7 +2126,7 @@ func (s *state) expr(n *Node) *ssa.Value {
 		v := s.newValue1(ssa.OpCopy, to, x) // ensure that v has the right type
 
 		// CONVNOP closure
-		if to.Etype == TFUNC && from.IsPtrShaped() {
+		if to.Etype == types.TFUNC && from.IsPtrShaped() {
 			return v
 		}
 
@@ -2140,7 +2141,7 @@ func (s *state) expr(n *Node) *ssa.Value {
 		}
 
 		// map <--> *hmap
-		if to.Etype == TMAP && from.IsPtr() &&
+		if to.Etype == types.TMAP && from.IsPtr() &&
 			to.MapType().Hmap == from.Elem() {
 			return v
 		}
@@ -2171,11 +2172,11 @@ func (s *state) expr(n *Node) *ssa.Value {
 		// integer, same width, same sign
 		return v
 
-	case OCONV:
+	case ir.OCONV:
 		x := s.expr(n.Left)
 		ft := n.Left.Type // from type
 		tt := n.Type      // to type
-		if ft.IsBoolean() && tt.IsKind(TUINT8) {
+		if ft.IsBoolean() && tt.IsKind(types.TUINT8) {
 			// Bool -> uint8 is generated internally when indexing into runtime.staticbyte.
 			return s.newValue1(ssa.OpCopy, n.Type, x)
 		}
@@ -2342,25 +2343,25 @@ func (s *state) expr(n *Node) *ssa.Value {
 		s.Fatalf("unhandled OCONV %s -> %s", n.Left.Type.Etype, n.Type.Etype)
 		return nil
 
-	case ODOTTYPE:
+	case ir.ODOTTYPE:
 		res, _ := s.dottype(n, false)
 		return res
 
 	// binary ops
-	case OLT, OEQ, ONE, OLE, OGE, OGT:
+	case ir.OLT, ir.OEQ, ir.ONE, ir.OLE, ir.OGE, ir.OGT:
 		a := s.expr(n.Left)
 		b := s.expr(n.Right)
 		if n.Left.Type.IsComplex() {
 			pt := floatForComplex(n.Left.Type)
-			op := s.ssaOp(OEQ, pt)
-			r := s.newValueOrSfCall2(op, types.Types[TBOOL], s.newValue1(ssa.OpComplexReal, pt, a), s.newValue1(ssa.OpComplexReal, pt, b))
-			i := s.newValueOrSfCall2(op, types.Types[TBOOL], s.newValue1(ssa.OpComplexImag, pt, a), s.newValue1(ssa.OpComplexImag, pt, b))
-			c := s.newValue2(ssa.OpAndB, types.Types[TBOOL], r, i)
+			op := s.ssaOp(ir.OEQ, pt)
+			r := s.newValueOrSfCall2(op, types.Types[types.TBOOL], s.newValue1(ssa.OpComplexReal, pt, a), s.newValue1(ssa.OpComplexReal, pt, b))
+			i := s.newValueOrSfCall2(op, types.Types[types.TBOOL], s.newValue1(ssa.OpComplexImag, pt, a), s.newValue1(ssa.OpComplexImag, pt, b))
+			c := s.newValue2(ssa.OpAndB, types.Types[types.TBOOL], r, i)
 			switch n.Op {
-			case OEQ:
+			case ir.OEQ:
 				return c
-			case ONE:
-				return s.newValue1(ssa.OpNot, types.Types[TBOOL], c)
+			case ir.ONE:
+				return s.newValue1(ssa.OpNot, types.Types[types.TBOOL], c)
 			default:
 				s.Fatalf("ordered complex compare %v", n.Op)
 			}
@@ -2369,26 +2370,26 @@ func (s *state) expr(n *Node) *ssa.Value {
 		// Convert OGE and OGT into OLE and OLT.
 		op := n.Op
 		switch op {
-		case OGE:
-			op, a, b = OLE, b, a
-		case OGT:
-			op, a, b = OLT, b, a
+		case ir.OGE:
+			op, a, b = ir.OLE, b, a
+		case ir.OGT:
+			op, a, b = ir.OLT, b, a
 		}
 		if n.Left.Type.IsFloat() {
 			// float comparison
-			return s.newValueOrSfCall2(s.ssaOp(op, n.Left.Type), types.Types[TBOOL], a, b)
+			return s.newValueOrSfCall2(s.ssaOp(op, n.Left.Type), types.Types[types.TBOOL], a, b)
 		}
 		// integer comparison
-		return s.newValue2(s.ssaOp(op, n.Left.Type), types.Types[TBOOL], a, b)
-	case OMUL:
+		return s.newValue2(s.ssaOp(op, n.Left.Type), types.Types[types.TBOOL], a, b)
+	case ir.OMUL:
 		a := s.expr(n.Left)
 		b := s.expr(n.Right)
 		if n.Type.IsComplex() {
 			mulop := ssa.OpMul64F
 			addop := ssa.OpAdd64F
 			subop := ssa.OpSub64F
-			pt := floatForComplex(n.Type) // Could be Float32 or Float64
-			wt := types.Types[TFLOAT64]   // Compute in Float64 to minimize cancellation error
+			pt := floatForComplex(n.Type)     // Could be Float32 or Float64
+			wt := types.Types[types.TFLOAT64] // Compute in Float64 to minimize cancellation error
 
 			areal := s.newValue1(ssa.OpComplexReal, pt, a)
 			breal := s.newValue1(ssa.OpComplexReal, pt, b)
@@ -2419,7 +2420,7 @@ func (s *state) expr(n *Node) *ssa.Value {
 
 		return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
 
-	case ODIV:
+	case ir.ODIV:
 		a := s.expr(n.Left)
 		b := s.expr(n.Right)
 		if n.Type.IsComplex() {
@@ -2430,8 +2431,8 @@ func (s *state) expr(n *Node) *ssa.Value {
 			addop := ssa.OpAdd64F
 			subop := ssa.OpSub64F
 			divop := ssa.OpDiv64F
-			pt := floatForComplex(n.Type) // Could be Float32 or Float64
-			wt := types.Types[TFLOAT64]   // Compute in Float64 to minimize cancellation error
+			pt := floatForComplex(n.Type)     // Could be Float32 or Float64
+			wt := types.Types[types.TFLOAT64] // Compute in Float64 to minimize cancellation error
 
 			areal := s.newValue1(ssa.OpComplexReal, pt, a)
 			breal := s.newValue1(ssa.OpComplexReal, pt, b)
@@ -2466,11 +2467,11 @@ func (s *state) expr(n *Node) *ssa.Value {
 			return s.newValueOrSfCall2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
 		}
 		return s.intDivide(n, a, b)
-	case OMOD:
+	case ir.OMOD:
 		a := s.expr(n.Left)
 		b := s.expr(n.Right)
 		return s.intDivide(n, a, b)
-	case OADD, OSUB:
+	case ir.OADD, ir.OSUB:
 		a := s.expr(n.Left)
 		b := s.expr(n.Right)
 		if n.Type.IsComplex() {
@@ -2484,26 +2485,26 @@ func (s *state) expr(n *Node) *ssa.Value {
 			return s.newValueOrSfCall2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
 		}
 		return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
-	case OAND, OOR, OXOR:
+	case ir.OAND, ir.OOR, ir.OXOR:
 		a := s.expr(n.Left)
 		b := s.expr(n.Right)
 		return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
-	case OANDNOT:
+	case ir.OANDNOT:
 		a := s.expr(n.Left)
 		b := s.expr(n.Right)
-		b = s.newValue1(s.ssaOp(OBITNOT, b.Type), b.Type, b)
-		return s.newValue2(s.ssaOp(OAND, n.Type), a.Type, a, b)
-	case OLSH, ORSH:
+		b = s.newValue1(s.ssaOp(ir.OBITNOT, b.Type), b.Type, b)
+		return s.newValue2(s.ssaOp(ir.OAND, n.Type), a.Type, a, b)
+	case ir.OLSH, ir.ORSH:
 		a := s.expr(n.Left)
 		b := s.expr(n.Right)
 		bt := b.Type
 		if bt.IsSigned() {
-			cmp := s.newValue2(s.ssaOp(OLE, bt), types.Types[TBOOL], s.zeroVal(bt), b)
+			cmp := s.newValue2(s.ssaOp(ir.OLE, bt), types.Types[types.TBOOL], s.zeroVal(bt), b)
 			s.check(cmp, panicshift)
 			bt = bt.ToUnsigned()
 		}
 		return s.newValue2(s.ssaShiftOp(n.Op, n.Type, bt), a.Type, a, b)
-	case OANDAND, OOROR:
+	case ir.OANDAND, ir.OOROR:
 		// To implement OANDAND (and OOROR), we introduce a
 		// new temporary variable to hold the result. The
 		// variable is associated with the OANDAND node in the
@@ -2530,10 +2531,10 @@ func (s *state) expr(n *Node) *ssa.Value {
 
 		bRight := s.f.NewBlock(ssa.BlockPlain)
 		bResult := s.f.NewBlock(ssa.BlockPlain)
-		if n.Op == OANDAND {
+		if n.Op == ir.OANDAND {
 			b.AddEdgeTo(bRight)
 			b.AddEdgeTo(bResult)
-		} else if n.Op == OOROR {
+		} else if n.Op == ir.OOROR {
 			b.AddEdgeTo(bResult)
 			b.AddEdgeTo(bRight)
 		}
@@ -2546,14 +2547,14 @@ func (s *state) expr(n *Node) *ssa.Value {
 		b.AddEdgeTo(bResult)
 
 		s.startBlock(bResult)
-		return s.variable(n, types.Types[TBOOL])
-	case OCOMPLEX:
+		return s.variable(n, types.Types[types.TBOOL])
+	case ir.OCOMPLEX:
 		r := s.expr(n.Left)
 		i := s.expr(n.Right)
 		return s.newValue2(ssa.OpComplexMake, n.Type, r, i)
 
 	// unary ops
-	case ONEG:
+	case ir.ONEG:
 		a := s.expr(n.Left)
 		if n.Type.IsComplex() {
 			tp := floatForComplex(n.Type)
@@ -2563,19 +2564,19 @@ func (s *state) expr(n *Node) *ssa.Value {
 				s.newValue1(negop, tp, s.newValue1(ssa.OpComplexImag, tp, a)))
 		}
 		return s.newValue1(s.ssaOp(n.Op, n.Type), a.Type, a)
-	case ONOT, OBITNOT:
+	case ir.ONOT, ir.OBITNOT:
 		a := s.expr(n.Left)
 		return s.newValue1(s.ssaOp(n.Op, n.Type), a.Type, a)
-	case OIMAG, OREAL:
+	case ir.OIMAG, ir.OREAL:
 		a := s.expr(n.Left)
 		return s.newValue1(s.ssaOp(n.Op, n.Left.Type), n.Type, a)
-	case OPLUS:
+	case ir.OPLUS:
 		return s.expr(n.Left)
 
-	case OADDR:
+	case ir.OADDR:
 		return s.addr(n.Left)
 
-	case ORESULT:
+	case ir.ORESULT:
 		if s.prevCall == nil || s.prevCall.Op != ssa.OpStaticLECall && s.prevCall.Op != ssa.OpInterLECall && s.prevCall.Op != ssa.OpClosureLECall {
 			// Do the old thing
 			addr := s.constOffPtrSP(types.NewPtr(n.Type), n.Xoffset)
@@ -2594,12 +2595,12 @@ func (s *state) expr(n *Node) *ssa.Value {
 			return s.rawLoad(n.Type, addr)
 		}
 
-	case ODEREF:
+	case ir.ODEREF:
 		p := s.exprPtr(n.Left, n.Bounded(), n.Pos)
 		return s.load(n.Type, p)
 
-	case ODOT:
-		if n.Left.Op == OSTRUCTLIT {
+	case ir.ODOT:
+		if n.Left.Op == ir.OSTRUCTLIT {
 			// All literals with nonzero fields have already been
 			// rewritten during walk. Any that remain are just T{}
 			// or equivalents. Use the zero value.
@@ -2619,32 +2620,32 @@ func (s *state) expr(n *Node) *ssa.Value {
 		v := s.expr(n.Left)
 		return s.newValue1I(ssa.OpStructSelect, n.Type, int64(fieldIdx(n)), v)
 
-	case ODOTPTR:
+	case ir.ODOTPTR:
 		p := s.exprPtr(n.Left, n.Bounded(), n.Pos)
 		p = s.newValue1I(ssa.OpOffPtr, types.NewPtr(n.Type), n.Xoffset, p)
 		return s.load(n.Type, p)
 
-	case OINDEX:
+	case ir.OINDEX:
 		switch {
 		case n.Left.Type.IsString():
-			if n.Bounded() && Isconst(n.Left, constant.String) && Isconst(n.Right, constant.Int) {
+			if n.Bounded() && ir.IsConst(n.Left, constant.String) && ir.IsConst(n.Right, constant.Int) {
 				// Replace "abc"[1] with 'b'.
 				// Delayed until now because "abc"[1] is not an ideal constant.
 				// See test/fixedbugs/issue11370.go.
-				return s.newValue0I(ssa.OpConst8, types.Types[TUINT8], int64(int8(n.Left.StringVal()[n.Right.Int64Val()])))
+				return s.newValue0I(ssa.OpConst8, types.Types[types.TUINT8], int64(int8(n.Left.StringVal()[n.Right.Int64Val()])))
 			}
 			a := s.expr(n.Left)
 			i := s.expr(n.Right)
-			len := s.newValue1(ssa.OpStringLen, types.Types[TINT], a)
+			len := s.newValue1(ssa.OpStringLen, types.Types[types.TINT], a)
 			i = s.boundsCheck(i, len, ssa.BoundsIndex, n.Bounded())
 			ptrtyp := s.f.Config.Types.BytePtr
 			ptr := s.newValue1(ssa.OpStringPtr, ptrtyp, a)
-			if Isconst(n.Right, constant.Int) {
+			if ir.IsConst(n.Right, constant.Int) {
 				ptr = s.newValue1I(ssa.OpOffPtr, ptrtyp, n.Right.Int64Val(), ptr)
 			} else {
 				ptr = s.newValue2(ssa.OpAddPtr, ptrtyp, ptr, i)
 			}
-			return s.load(types.Types[TUINT8], ptr)
+			return s.load(types.Types[types.TUINT8], ptr)
 		case n.Left.Type.IsSlice():
 			p := s.addr(n)
 			return s.load(n.Left.Type.Elem(), p)
@@ -2657,12 +2658,12 @@ func (s *state) expr(n *Node) *ssa.Value {
 				if bound == 0 {
 					// Bounds check will never succeed.  Might as well
 					// use constants for the bounds check.
-					z := s.constInt(types.Types[TINT], 0)
+					z := s.constInt(types.Types[types.TINT], 0)
 					s.boundsCheck(z, z, ssa.BoundsIndex, false)
 					// The return value won't be live, return junk.
 					return s.newValue0(ssa.OpUnknown, n.Type)
 				}
-				len := s.constInt(types.Types[TINT], bound)
+				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)
 			}
@@ -2673,23 +2674,23 @@ func (s *state) expr(n *Node) *ssa.Value {
 			return nil
 		}
 
-	case OLEN, OCAP:
+	case ir.OLEN, ir.OCAP:
 		switch {
 		case n.Left.Type.IsSlice():
 			op := ssa.OpSliceLen
-			if n.Op == OCAP {
+			if n.Op == ir.OCAP {
 				op = ssa.OpSliceCap
 			}
-			return s.newValue1(op, types.Types[TINT], s.expr(n.Left))
+			return s.newValue1(op, types.Types[types.TINT], s.expr(n.Left))
 		case n.Left.Type.IsString(): // string; not reachable for OCAP
-			return s.newValue1(ssa.OpStringLen, types.Types[TINT], s.expr(n.Left))
+			return s.newValue1(ssa.OpStringLen, types.Types[types.TINT], s.expr(n.Left))
 		case n.Left.Type.IsMap(), n.Left.Type.IsChan():
 			return s.referenceTypeBuiltin(n, s.expr(n.Left))
 		default: // array
-			return s.constInt(types.Types[TINT], n.Left.Type.NumElem())
+			return s.constInt(types.Types[types.TINT], n.Left.Type.NumElem())
 		}
 
-	case OSPTR:
+	case ir.OSPTR:
 		a := s.expr(n.Left)
 		if n.Left.Type.IsSlice() {
 			return s.newValue1(ssa.OpSlicePtr, n.Type, a)
@@ -2697,26 +2698,26 @@ func (s *state) expr(n *Node) *ssa.Value {
 			return s.newValue1(ssa.OpStringPtr, n.Type, a)
 		}
 
-	case OITAB:
+	case ir.OITAB:
 		a := s.expr(n.Left)
 		return s.newValue1(ssa.OpITab, n.Type, a)
 
-	case OIDATA:
+	case ir.OIDATA:
 		a := s.expr(n.Left)
 		return s.newValue1(ssa.OpIData, n.Type, a)
 
-	case OEFACE:
+	case ir.OEFACE:
 		tab := s.expr(n.Left)
 		data := s.expr(n.Right)
 		return s.newValue2(ssa.OpIMake, n.Type, tab, data)
 
-	case OSLICEHEADER:
+	case ir.OSLICEHEADER:
 		p := s.expr(n.Left)
 		l := s.expr(n.List.First())
 		c := s.expr(n.List.Second())
 		return s.newValue3(ssa.OpSliceMake, n.Type, p, l, c)
 
-	case OSLICE, OSLICEARR, OSLICE3, OSLICE3ARR:
+	case ir.OSLICE, ir.OSLICEARR, ir.OSLICE3, ir.OSLICE3ARR:
 		v := s.expr(n.Left)
 		var i, j, k *ssa.Value
 		low, high, max := n.SliceBounds()
@@ -2732,7 +2733,7 @@ func (s *state) expr(n *Node) *ssa.Value {
 		p, l, c := s.slice(v, i, j, k, n.Bounded())
 		return s.newValue3(ssa.OpSliceMake, n.Type, p, l, c)
 
-	case OSLICESTR:
+	case ir.OSLICESTR:
 		v := s.expr(n.Left)
 		var i, j *ssa.Value
 		low, high, _ := n.SliceBounds()
@@ -2745,22 +2746,22 @@ func (s *state) expr(n *Node) *ssa.Value {
 		p, l, _ := s.slice(v, i, j, nil, n.Bounded())
 		return s.newValue2(ssa.OpStringMake, n.Type, p, l)
 
-	case OCALLFUNC:
+	case ir.OCALLFUNC:
 		if isIntrinsicCall(n) {
 			return s.intrinsicCall(n)
 		}
 		fallthrough
 
-	case OCALLINTER, OCALLMETH:
+	case ir.OCALLINTER, ir.OCALLMETH:
 		return s.callResult(n, callNormal)
 
-	case OGETG:
+	case ir.OGETG:
 		return s.newValue1(ssa.OpGetG, n.Type, s.mem())
 
-	case OAPPEND:
+	case ir.OAPPEND:
 		return s.append(n, false)
 
-	case OSTRUCTLIT, OARRAYLIT:
+	case ir.OSTRUCTLIT, ir.OARRAYLIT:
 		// All literals with nonzero fields have already been
 		// rewritten during walk. Any that remain are just T{}
 		// or equivalents. Use the zero value.
@@ -2769,7 +2770,7 @@ func (s *state) expr(n *Node) *ssa.Value {
 		}
 		return s.zeroVal(n.Type)
 
-	case ONEWOBJ:
+	case ir.ONEWOBJ:
 		if n.Type.Elem().Size() == 0 {
 			return s.newValue1A(ssa.OpAddr, n.Type, zerobaseSym, s.sb)
 		}
@@ -2789,7 +2790,7 @@ func (s *state) expr(n *Node) *ssa.Value {
 // If inplace is true, it writes the result of the OAPPEND expression n
 // back to the slice being appended to, and returns nil.
 // inplace MUST be set to false if the slice can be SSA'd.
-func (s *state) append(n *Node, inplace bool) *ssa.Value {
+func (s *state) append(n *ir.Node, inplace bool) *ssa.Value {
 	// If inplace is false, process as expression "append(s, e1, e2, e3)":
 	//
 	// ptr, len, cap := s
@@ -2844,11 +2845,11 @@ func (s *state) append(n *Node, inplace bool) *ssa.Value {
 	// Decide if we need to grow
 	nargs := int64(n.List.Len() - 1)
 	p := s.newValue1(ssa.OpSlicePtr, pt, slice)
-	l := s.newValue1(ssa.OpSliceLen, types.Types[TINT], slice)
-	c := s.newValue1(ssa.OpSliceCap, types.Types[TINT], slice)
-	nl := s.newValue2(s.ssaOp(OADD, types.Types[TINT]), types.Types[TINT], l, s.constInt(types.Types[TINT], nargs))
+	l := s.newValue1(ssa.OpSliceLen, types.Types[types.TINT], slice)
+	c := s.newValue1(ssa.OpSliceCap, types.Types[types.TINT], slice)
+	nl := s.newValue2(s.ssaOp(ir.OADD, types.Types[types.TINT]), types.Types[types.TINT], l, s.constInt(types.Types[types.TINT], nargs))
 
-	cmp := s.newValue2(s.ssaOp(OLT, types.Types[TUINT]), types.Types[types.TBOOL], c, nl)
+	cmp := s.newValue2(s.ssaOp(ir.OLT, types.Types[types.TUINT]), types.Types[types.TBOOL], c, nl)
 	s.vars[ptrVar] = p
 
 	if !inplace {
@@ -2868,22 +2869,22 @@ func (s *state) append(n *Node, inplace bool) *ssa.Value {
 	// Call growslice
 	s.startBlock(grow)
 	taddr := s.expr(n.Left)
-	r := s.rtcall(growslice, true, []*types.Type{pt, types.Types[TINT], types.Types[TINT]}, taddr, p, l, c, nl)
+	r := s.rtcall(growslice, true, []*types.Type{pt, types.Types[types.TINT], types.Types[types.TINT]}, taddr, p, l, c, nl)
 
 	if inplace {
-		if sn.Op == ONAME && sn.Class() != PEXTERN {
+		if sn.Op == ir.ONAME && sn.Class() != ir.PEXTERN {
 			// Tell liveness we're about to build a new slice
 			s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, sn, s.mem())
 		}
 		capaddr := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.IntPtr, sliceCapOffset, addr)
-		s.store(types.Types[TINT], capaddr, r[2])
+		s.store(types.Types[types.TINT], capaddr, r[2])
 		s.store(pt, addr, r[0])
 		// load the value we just stored to avoid having to spill it
 		s.vars[ptrVar] = s.load(pt, addr)
 		s.vars[lenVar] = r[1] // avoid a spill in the fast path
 	} else {
 		s.vars[ptrVar] = r[0]
-		s.vars[newlenVar] = s.newValue2(s.ssaOp(OADD, types.Types[TINT]), types.Types[TINT], r[1], s.constInt(types.Types[TINT], nargs))
+		s.vars[newlenVar] = s.newValue2(s.ssaOp(ir.OADD, types.Types[types.TINT]), types.Types[types.TINT], r[1], s.constInt(types.Types[types.TINT], nargs))
 		s.vars[capVar] = r[2]
 	}
 
@@ -2894,10 +2895,10 @@ func (s *state) append(n *Node, inplace bool) *ssa.Value {
 	s.startBlock(assign)
 
 	if inplace {
-		l = s.variable(lenVar, types.Types[TINT]) // generates phi for len
-		nl = s.newValue2(s.ssaOp(OADD, types.Types[TINT]), types.Types[TINT], l, s.constInt(types.Types[TINT], nargs))
+		l = s.variable(lenVar, types.Types[types.TINT]) // generates phi for len
+		nl = s.newValue2(s.ssaOp(ir.OADD, types.Types[types.TINT]), types.Types[types.TINT], l, s.constInt(types.Types[types.TINT], nargs))
 		lenaddr := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.IntPtr, sliceLenOffset, addr)
-		s.store(types.Types[TINT], lenaddr, nl)
+		s.store(types.Types[types.TINT], lenaddr, nl)
 	}
 
 	// Evaluate args
@@ -2919,12 +2920,12 @@ func (s *state) append(n *Node, inplace bool) *ssa.Value {
 
 	p = s.variable(ptrVar, pt) // generates phi for ptr
 	if !inplace {
-		nl = s.variable(newlenVar, types.Types[TINT]) // generates phi for nl
-		c = s.variable(capVar, types.Types[TINT])     // generates phi for cap
+		nl = s.variable(newlenVar, types.Types[types.TINT]) // generates phi for nl
+		c = s.variable(capVar, types.Types[types.TINT])     // generates phi for cap
 	}
 	p2 := s.newValue2(ssa.OpPtrIndex, pt, p, l)
 	for i, arg := range args {
-		addr := s.newValue2(ssa.OpPtrIndex, pt, p2, s.constInt(types.Types[TINT], int64(i)))
+		addr := s.newValue2(ssa.OpPtrIndex, pt, p2, s.constInt(types.Types[types.TINT], int64(i)))
 		if arg.store {
 			s.storeType(et, addr, arg.v, 0, true)
 		} else {
@@ -2947,9 +2948,9 @@ func (s *state) append(n *Node, inplace bool) *ssa.Value {
 // if cond is true and no if cond is false.
 // This function is intended to handle && and || better than just calling
 // s.expr(cond) and branching on the result.
-func (s *state) condBranch(cond *Node, yes, no *ssa.Block, likely int8) {
+func (s *state) condBranch(cond *ir.Node, yes, no *ssa.Block, likely int8) {
 	switch cond.Op {
-	case OANDAND:
+	case ir.OANDAND:
 		mid := s.f.NewBlock(ssa.BlockPlain)
 		s.stmtList(cond.Ninit)
 		s.condBranch(cond.Left, mid, no, max8(likely, 0))
@@ -2962,7 +2963,7 @@ func (s *state) condBranch(cond *Node, yes, no *ssa.Block, likely int8) {
 		// the likeliness of the first branch.
 		// TODO: have the frontend give us branch prediction hints for
 		// OANDAND and OOROR nodes (if it ever has such info).
-	case OOROR:
+	case ir.OOROR:
 		mid := s.f.NewBlock(ssa.BlockPlain)
 		s.stmtList(cond.Ninit)
 		s.condBranch(cond.Left, yes, mid, min8(likely, 0))
@@ -2972,7 +2973,7 @@ func (s *state) condBranch(cond *Node, yes, no *ssa.Block, likely int8) {
 		// Note: if likely==-1, then both recursive calls pass -1.
 		// If likely==1, then we don't have enough info to decide
 		// the likelihood of the first branch.
-	case ONOT:
+	case ir.ONOT:
 		s.stmtList(cond.Ninit)
 		s.condBranch(cond.Left, no, yes, -likely)
 		return
@@ -2999,8 +3000,8 @@ const (
 // If deref is true, then we do left = *right instead (and right has already been nil-checked).
 // If deref is true and right == nil, just do left = 0.
 // skip indicates assignments (at the top level) that can be avoided.
-func (s *state) assign(left *Node, right *ssa.Value, deref bool, skip skipMask) {
-	if left.Op == ONAME && left.isBlank() {
+func (s *state) assign(left *ir.Node, right *ssa.Value, deref bool, skip skipMask) {
+	if left.Op == ir.ONAME && ir.IsBlank(left) {
 		return
 	}
 	t := left.Type
@@ -3009,7 +3010,7 @@ func (s *state) assign(left *Node, right *ssa.Value, deref bool, skip skipMask)
 		if deref {
 			s.Fatalf("can SSA LHS %v but not RHS %s", left, right)
 		}
-		if left.Op == ODOT {
+		if left.Op == ir.ODOT {
 			// We're assigning to a field of an ssa-able value.
 			// We need to build a new structure with the new value for the
 			// field we're assigning and the old values for the other fields.
@@ -3044,7 +3045,7 @@ func (s *state) assign(left *Node, right *ssa.Value, deref bool, skip skipMask)
 			// TODO: do we need to update named values here?
 			return
 		}
-		if left.Op == OINDEX && left.Left.Type.IsArray() {
+		if left.Op == ir.OINDEX && left.Left.Type.IsArray() {
 			s.pushLine(left.Pos)
 			defer s.popLine()
 			// We're assigning to an element of an ssa-able array.
@@ -3056,7 +3057,7 @@ func (s *state) assign(left *Node, right *ssa.Value, deref bool, skip skipMask)
 			if n == 0 {
 				// The bounds check must fail.  Might as well
 				// ignore the actual index and just use zeros.
-				z := s.constInt(types.Types[TINT], 0)
+				z := s.constInt(types.Types[types.TINT], 0)
 				s.boundsCheck(z, z, ssa.BoundsIndex, false)
 				return
 			}
@@ -3064,7 +3065,7 @@ func (s *state) assign(left *Node, right *ssa.Value, deref bool, skip skipMask)
 				s.Fatalf("assigning to non-1-length array")
 			}
 			// Rewrite to a = [1]{v}
-			len := s.constInt(types.Types[TINT], 1)
+			len := s.constInt(types.Types[types.TINT], 1)
 			s.boundsCheck(i, len, ssa.BoundsIndex, false) // checks i == 0
 			v := s.newValue1(ssa.OpArrayMake1, t, right)
 			s.assign(left.Left, v, false, 0)
@@ -3078,7 +3079,7 @@ func (s *state) assign(left *Node, right *ssa.Value, deref bool, skip skipMask)
 
 	// If this assignment clobbers an entire local variable, then emit
 	// OpVarDef so liveness analysis knows the variable is redefined.
-	if base := clobberBase(left); base.Op == ONAME && base.Class() != PEXTERN && skip == 0 {
+	if base := clobberBase(left); base.Op == ir.ONAME && base.Class() != ir.PEXTERN && skip == 0 {
 		s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, base, s.mem(), !base.IsAutoTmp())
 	}
 
@@ -3090,7 +3091,7 @@ func (s *state) assign(left *Node, right *ssa.Value, deref bool, skip skipMask)
 		// is valid, even though they have type uintptr (#19168).
 		// Mark it pointer type to signal the writebarrier pass to
 		// insert a write barrier.
-		t = types.Types[TUNSAFEPTR]
+		t = types.Types[types.TUNSAFEPTR]
 	}
 	if deref {
 		// Treat as a mem->mem move.
@@ -3133,10 +3134,10 @@ func (s *state) zeroVal(t *types.Type) *ssa.Value {
 	case t.IsComplex():
 		switch t.Size() {
 		case 8:
-			z := s.constFloat32(types.Types[TFLOAT32], 0)
+			z := s.constFloat32(types.Types[types.TFLOAT32], 0)
 			return s.entryNewValue2(ssa.OpComplexMake, t, z, z)
 		case 16:
-			z := s.constFloat64(types.Types[TFLOAT64], 0)
+			z := s.constFloat64(types.Types[types.TFLOAT64], 0)
 			return s.entryNewValue2(ssa.OpComplexMake, t, z, z)
 		default:
 			s.Fatalf("bad sized complex type %v", t)
@@ -3190,38 +3191,38 @@ var softFloatOps map[ssa.Op]sfRtCallDef
 func softfloatInit() {
 	// Some of these operations get transformed by sfcall.
 	softFloatOps = map[ssa.Op]sfRtCallDef{
-		ssa.OpAdd32F: sfRtCallDef{sysfunc("fadd32"), TFLOAT32},
-		ssa.OpAdd64F: sfRtCallDef{sysfunc("fadd64"), TFLOAT64},
-		ssa.OpSub32F: sfRtCallDef{sysfunc("fadd32"), TFLOAT32},
-		ssa.OpSub64F: sfRtCallDef{sysfunc("fadd64"), TFLOAT64},
-		ssa.OpMul32F: sfRtCallDef{sysfunc("fmul32"), TFLOAT32},
-		ssa.OpMul64F: sfRtCallDef{sysfunc("fmul64"), TFLOAT64},
-		ssa.OpDiv32F: sfRtCallDef{sysfunc("fdiv32"), TFLOAT32},
-		ssa.OpDiv64F: sfRtCallDef{sysfunc("fdiv64"), TFLOAT64},
-
-		ssa.OpEq64F:   sfRtCallDef{sysfunc("feq64"), TBOOL},
-		ssa.OpEq32F:   sfRtCallDef{sysfunc("feq32"), TBOOL},
-		ssa.OpNeq64F:  sfRtCallDef{sysfunc("feq64"), TBOOL},
-		ssa.OpNeq32F:  sfRtCallDef{sysfunc("feq32"), TBOOL},
-		ssa.OpLess64F: sfRtCallDef{sysfunc("fgt64"), TBOOL},
-		ssa.OpLess32F: sfRtCallDef{sysfunc("fgt32"), TBOOL},
-		ssa.OpLeq64F:  sfRtCallDef{sysfunc("fge64"), TBOOL},
-		ssa.OpLeq32F:  sfRtCallDef{sysfunc("fge32"), TBOOL},
-
-		ssa.OpCvt32to32F:  sfRtCallDef{sysfunc("fint32to32"), TFLOAT32},
-		ssa.OpCvt32Fto32:  sfRtCallDef{sysfunc("f32toint32"), TINT32},
-		ssa.OpCvt64to32F:  sfRtCallDef{sysfunc("fint64to32"), TFLOAT32},
-		ssa.OpCvt32Fto64:  sfRtCallDef{sysfunc("f32toint64"), TINT64},
-		ssa.OpCvt64Uto32F: sfRtCallDef{sysfunc("fuint64to32"), TFLOAT32},
-		ssa.OpCvt32Fto64U: sfRtCallDef{sysfunc("f32touint64"), TUINT64},
-		ssa.OpCvt32to64F:  sfRtCallDef{sysfunc("fint32to64"), TFLOAT64},
-		ssa.OpCvt64Fto32:  sfRtCallDef{sysfunc("f64toint32"), TINT32},
-		ssa.OpCvt64to64F:  sfRtCallDef{sysfunc("fint64to64"), TFLOAT64},
-		ssa.OpCvt64Fto64:  sfRtCallDef{sysfunc("f64toint64"), TINT64},
-		ssa.OpCvt64Uto64F: sfRtCallDef{sysfunc("fuint64to64"), TFLOAT64},
-		ssa.OpCvt64Fto64U: sfRtCallDef{sysfunc("f64touint64"), TUINT64},
-		ssa.OpCvt32Fto64F: sfRtCallDef{sysfunc("f32to64"), TFLOAT64},
-		ssa.OpCvt64Fto32F: sfRtCallDef{sysfunc("f64to32"), TFLOAT32},
+		ssa.OpAdd32F: sfRtCallDef{sysfunc("fadd32"), types.TFLOAT32},
+		ssa.OpAdd64F: sfRtCallDef{sysfunc("fadd64"), types.TFLOAT64},
+		ssa.OpSub32F: sfRtCallDef{sysfunc("fadd32"), types.TFLOAT32},
+		ssa.OpSub64F: sfRtCallDef{sysfunc("fadd64"), types.TFLOAT64},
+		ssa.OpMul32F: sfRtCallDef{sysfunc("fmul32"), types.TFLOAT32},
+		ssa.OpMul64F: sfRtCallDef{sysfunc("fmul64"), types.TFLOAT64},
+		ssa.OpDiv32F: sfRtCallDef{sysfunc("fdiv32"), types.TFLOAT32},
+		ssa.OpDiv64F: sfRtCallDef{sysfunc("fdiv64"), types.TFLOAT64},
+
+		ssa.OpEq64F:   sfRtCallDef{sysfunc("feq64"), types.TBOOL},
+		ssa.OpEq32F:   sfRtCallDef{sysfunc("feq32"), types.TBOOL},
+		ssa.OpNeq64F:  sfRtCallDef{sysfunc("feq64"), types.TBOOL},
+		ssa.OpNeq32F:  sfRtCallDef{sysfunc("feq32"), types.TBOOL},
+		ssa.OpLess64F: sfRtCallDef{sysfunc("fgt64"), types.TBOOL},
+		ssa.OpLess32F: sfRtCallDef{sysfunc("fgt32"), types.TBOOL},
+		ssa.OpLeq64F:  sfRtCallDef{sysfunc("fge64"), types.TBOOL},
+		ssa.OpLeq32F:  sfRtCallDef{sysfunc("fge32"), types.TBOOL},
+
+		ssa.OpCvt32to32F:  sfRtCallDef{sysfunc("fint32to32"), types.TFLOAT32},
+		ssa.OpCvt32Fto32:  sfRtCallDef{sysfunc("f32toint32"), types.TINT32},
+		ssa.OpCvt64to32F:  sfRtCallDef{sysfunc("fint64to32"), types.TFLOAT32},
+		ssa.OpCvt32Fto64:  sfRtCallDef{sysfunc("f32toint64"), types.TINT64},
+		ssa.OpCvt64Uto32F: sfRtCallDef{sysfunc("fuint64to32"), types.TFLOAT32},
+		ssa.OpCvt32Fto64U: sfRtCallDef{sysfunc("f32touint64"), types.TUINT64},
+		ssa.OpCvt32to64F:  sfRtCallDef{sysfunc("fint32to64"), types.TFLOAT64},
+		ssa.OpCvt64Fto32:  sfRtCallDef{sysfunc("f64toint32"), types.TINT32},
+		ssa.OpCvt64to64F:  sfRtCallDef{sysfunc("fint64to64"), types.TFLOAT64},
+		ssa.OpCvt64Fto64:  sfRtCallDef{sysfunc("f64toint64"), types.TINT64},
+		ssa.OpCvt64Uto64F: sfRtCallDef{sysfunc("fuint64to64"), types.TFLOAT64},
+		ssa.OpCvt64Fto64U: sfRtCallDef{sysfunc("f64touint64"), types.TUINT64},
+		ssa.OpCvt32Fto64F: sfRtCallDef{sysfunc("f32to64"), types.TFLOAT64},
+		ssa.OpCvt64Fto32F: sfRtCallDef{sysfunc("f64to32"), types.TFLOAT32},
 	}
 }
 
@@ -3237,7 +3238,7 @@ func (s *state) sfcall(op ssa.Op, args ...*ssa.Value) (*ssa.Value, bool) {
 			args[0], args[1] = args[1], args[0]
 		case ssa.OpSub32F,
 			ssa.OpSub64F:
-			args[1] = s.newValue1(s.ssaOp(ONEG, types.Types[callDef.rtype]), args[1].Type, args[1])
+			args[1] = s.newValue1(s.ssaOp(ir.ONEG, types.Types[callDef.rtype]), args[1].Type, args[1])
 		}
 
 		result := s.rtcall(callDef.rtfn, true, []*types.Type{types.Types[callDef.rtype]}, args...)[0]
@@ -3253,7 +3254,7 @@ var intrinsics map[intrinsicKey]intrinsicBuilder
 
 // An intrinsicBuilder converts a call node n into an ssa value that
 // implements that call as an intrinsic. args is a list of arguments to the func.
-type intrinsicBuilder func(s *state, n *Node, args []*ssa.Value) *ssa.Value
+type intrinsicBuilder func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value
 
 type intrinsicKey struct {
 	arch *sys.Arch
@@ -3318,7 +3319,7 @@ func init() {
 	/******** runtime ********/
 	if !instrumenting {
 		add("runtime", "slicebytetostringtmp",
-			func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+			func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 				// Compiler frontend optimizations emit OBYTES2STRTMP nodes
 				// for the backend instead of slicebytetostringtmp calls
 				// when not instrumenting.
@@ -3327,98 +3328,98 @@ func init() {
 			all...)
 	}
 	addF("runtime/internal/math", "MulUintptr",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			if s.config.PtrSize == 4 {
-				return s.newValue2(ssa.OpMul32uover, types.NewTuple(types.Types[TUINT], types.Types[TUINT]), args[0], args[1])
+				return s.newValue2(ssa.OpMul32uover, types.NewTuple(types.Types[types.TUINT], types.Types[types.TUINT]), args[0], args[1])
 			}
-			return s.newValue2(ssa.OpMul64uover, types.NewTuple(types.Types[TUINT], types.Types[TUINT]), args[0], args[1])
+			return s.newValue2(ssa.OpMul64uover, types.NewTuple(types.Types[types.TUINT], types.Types[types.TUINT]), args[0], args[1])
 		},
 		sys.AMD64, sys.I386, sys.MIPS64)
 	add("runtime", "KeepAlive",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			data := s.newValue1(ssa.OpIData, s.f.Config.Types.BytePtr, args[0])
 			s.vars[memVar] = s.newValue2(ssa.OpKeepAlive, types.TypeMem, data, s.mem())
 			return nil
 		},
 		all...)
 	add("runtime", "getclosureptr",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue0(ssa.OpGetClosurePtr, s.f.Config.Types.Uintptr)
 		},
 		all...)
 
 	add("runtime", "getcallerpc",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue0(ssa.OpGetCallerPC, s.f.Config.Types.Uintptr)
 		},
 		all...)
 
 	add("runtime", "getcallersp",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue0(ssa.OpGetCallerSP, s.f.Config.Types.Uintptr)
 		},
 		all...)
 
 	/******** runtime/internal/sys ********/
 	addF("runtime/internal/sys", "Ctz32",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpCtz32, types.Types[TINT], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpCtz32, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64)
 	addF("runtime/internal/sys", "Ctz64",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpCtz64, types.Types[TINT], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpCtz64, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64)
 	addF("runtime/internal/sys", "Bswap32",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpBswap32, types.Types[TUINT32], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpBswap32, types.Types[types.TUINT32], args[0])
 		},
 		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X)
 	addF("runtime/internal/sys", "Bswap64",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpBswap64, types.Types[TUINT64], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpBswap64, types.Types[types.TUINT64], args[0])
 		},
 		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X)
 
 	/******** runtime/internal/atomic ********/
 	addF("runtime/internal/atomic", "Load",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			v := s.newValue2(ssa.OpAtomicLoad32, types.NewTuple(types.Types[TUINT32], types.TypeMem), args[0], s.mem())
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			v := s.newValue2(ssa.OpAtomicLoad32, types.NewTuple(types.Types[types.TUINT32], types.TypeMem), args[0], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
-			return s.newValue1(ssa.OpSelect0, types.Types[TUINT32], v)
+			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT32], v)
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Load8",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			v := s.newValue2(ssa.OpAtomicLoad8, types.NewTuple(types.Types[TUINT8], types.TypeMem), args[0], s.mem())
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			v := s.newValue2(ssa.OpAtomicLoad8, types.NewTuple(types.Types[types.TUINT8], types.TypeMem), args[0], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
-			return s.newValue1(ssa.OpSelect0, types.Types[TUINT8], v)
+			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT8], v)
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Load64",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			v := s.newValue2(ssa.OpAtomicLoad64, types.NewTuple(types.Types[TUINT64], types.TypeMem), args[0], s.mem())
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			v := s.newValue2(ssa.OpAtomicLoad64, types.NewTuple(types.Types[types.TUINT64], types.TypeMem), args[0], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
-			return s.newValue1(ssa.OpSelect0, types.Types[TUINT64], v)
+			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT64], v)
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "LoadAcq",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			v := s.newValue2(ssa.OpAtomicLoadAcq32, types.NewTuple(types.Types[TUINT32], types.TypeMem), args[0], s.mem())
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			v := s.newValue2(ssa.OpAtomicLoadAcq32, types.NewTuple(types.Types[types.TUINT32], types.TypeMem), args[0], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
-			return s.newValue1(ssa.OpSelect0, types.Types[TUINT32], v)
+			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT32], v)
 		},
 		sys.PPC64, sys.S390X)
 	addF("runtime/internal/atomic", "LoadAcq64",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			v := s.newValue2(ssa.OpAtomicLoadAcq64, types.NewTuple(types.Types[TUINT64], types.TypeMem), args[0], s.mem())
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			v := s.newValue2(ssa.OpAtomicLoadAcq64, types.NewTuple(types.Types[types.TUINT64], types.TypeMem), args[0], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
-			return s.newValue1(ssa.OpSelect0, types.Types[TUINT64], v)
+			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT64], v)
 		},
 		sys.PPC64)
 	addF("runtime/internal/atomic", "Loadp",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue2(ssa.OpAtomicLoadPtr, types.NewTuple(s.f.Config.Types.BytePtr, types.TypeMem), args[0], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, s.f.Config.Types.BytePtr, v)
@@ -3426,65 +3427,65 @@ func init() {
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 
 	addF("runtime/internal/atomic", "Store",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicStore32, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Store8",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicStore8, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Store64",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicStore64, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "StorepNoWB",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicStorePtrNoWB, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "StoreRel",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicStoreRel32, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.PPC64, sys.S390X)
 	addF("runtime/internal/atomic", "StoreRel64",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicStoreRel64, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.PPC64)
 
 	addF("runtime/internal/atomic", "Xchg",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			v := s.newValue3(ssa.OpAtomicExchange32, types.NewTuple(types.Types[TUINT32], types.TypeMem), args[0], args[1], s.mem())
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			v := s.newValue3(ssa.OpAtomicExchange32, types.NewTuple(types.Types[types.TUINT32], types.TypeMem), args[0], args[1], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
-			return s.newValue1(ssa.OpSelect0, types.Types[TUINT32], v)
+			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT32], v)
 		},
 		sys.AMD64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Xchg64",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			v := s.newValue3(ssa.OpAtomicExchange64, types.NewTuple(types.Types[TUINT64], types.TypeMem), args[0], args[1], s.mem())
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			v := s.newValue3(ssa.OpAtomicExchange64, types.NewTuple(types.Types[types.TUINT64], types.TypeMem), args[0], args[1], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
-			return s.newValue1(ssa.OpSelect0, types.Types[TUINT64], v)
+			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT64], v)
 		},
 		sys.AMD64, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 
-	type atomicOpEmitter func(s *state, n *Node, args []*ssa.Value, op ssa.Op, typ types.EType)
+	type atomicOpEmitter func(s *state, n *ir.Node, args []*ssa.Value, op ssa.Op, typ types.EType)
 
 	makeAtomicGuardedIntrinsicARM64 := func(op0, op1 ssa.Op, typ, rtyp types.EType, emit atomicOpEmitter) intrinsicBuilder {
 
-		return func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		return func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			// Target Atomic feature is identified by dynamic detection
-			addr := s.entryNewValue1A(ssa.OpAddr, types.Types[TBOOL].PtrTo(), arm64HasATOMICS, s.sb)
-			v := s.load(types.Types[TBOOL], addr)
+			addr := s.entryNewValue1A(ssa.OpAddr, types.Types[types.TBOOL].PtrTo(), arm64HasATOMICS, s.sb)
+			v := s.load(types.Types[types.TBOOL], addr)
 			b := s.endBlock()
 			b.Kind = ssa.BlockIf
 			b.SetControl(v)
@@ -3507,7 +3508,7 @@ func init() {
 
 			// Merge results.
 			s.startBlock(bEnd)
-			if rtyp == TNIL {
+			if rtyp == types.TNIL {
 				return nil
 			} else {
 				return s.variable(n, types.Types[rtyp])
@@ -3515,115 +3516,115 @@ func init() {
 		}
 	}
 
-	atomicXchgXaddEmitterARM64 := func(s *state, n *Node, args []*ssa.Value, op ssa.Op, typ types.EType) {
+	atomicXchgXaddEmitterARM64 := func(s *state, n *ir.Node, args []*ssa.Value, op ssa.Op, typ types.EType) {
 		v := s.newValue3(op, types.NewTuple(types.Types[typ], types.TypeMem), args[0], args[1], s.mem())
 		s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 		s.vars[n] = s.newValue1(ssa.OpSelect0, types.Types[typ], v)
 	}
 	addF("runtime/internal/atomic", "Xchg",
-		makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicExchange32, ssa.OpAtomicExchange32Variant, TUINT32, TUINT32, atomicXchgXaddEmitterARM64),
+		makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicExchange32, ssa.OpAtomicExchange32Variant, types.TUINT32, types.TUINT32, atomicXchgXaddEmitterARM64),
 		sys.ARM64)
 	addF("runtime/internal/atomic", "Xchg64",
-		makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicExchange64, ssa.OpAtomicExchange64Variant, TUINT64, TUINT64, atomicXchgXaddEmitterARM64),
+		makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicExchange64, ssa.OpAtomicExchange64Variant, types.TUINT64, types.TUINT64, atomicXchgXaddEmitterARM64),
 		sys.ARM64)
 
 	addF("runtime/internal/atomic", "Xadd",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			v := s.newValue3(ssa.OpAtomicAdd32, types.NewTuple(types.Types[TUINT32], types.TypeMem), args[0], args[1], s.mem())
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			v := s.newValue3(ssa.OpAtomicAdd32, types.NewTuple(types.Types[types.TUINT32], types.TypeMem), args[0], args[1], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
-			return s.newValue1(ssa.OpSelect0, types.Types[TUINT32], v)
+			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT32], v)
 		},
 		sys.AMD64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Xadd64",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			v := s.newValue3(ssa.OpAtomicAdd64, types.NewTuple(types.Types[TUINT64], types.TypeMem), args[0], args[1], s.mem())
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			v := s.newValue3(ssa.OpAtomicAdd64, types.NewTuple(types.Types[types.TUINT64], types.TypeMem), args[0], args[1], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
-			return s.newValue1(ssa.OpSelect0, types.Types[TUINT64], v)
+			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT64], v)
 		},
 		sys.AMD64, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 
 	addF("runtime/internal/atomic", "Xadd",
-		makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicAdd32, ssa.OpAtomicAdd32Variant, TUINT32, TUINT32, atomicXchgXaddEmitterARM64),
+		makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicAdd32, ssa.OpAtomicAdd32Variant, types.TUINT32, types.TUINT32, atomicXchgXaddEmitterARM64),
 		sys.ARM64)
 	addF("runtime/internal/atomic", "Xadd64",
-		makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicAdd64, ssa.OpAtomicAdd64Variant, TUINT64, TUINT64, atomicXchgXaddEmitterARM64),
+		makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicAdd64, ssa.OpAtomicAdd64Variant, types.TUINT64, types.TUINT64, atomicXchgXaddEmitterARM64),
 		sys.ARM64)
 
 	addF("runtime/internal/atomic", "Cas",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue4(ssa.OpAtomicCompareAndSwap32, types.NewTuple(types.Types[types.TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TBOOL], v)
 		},
 		sys.AMD64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Cas64",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue4(ssa.OpAtomicCompareAndSwap64, types.NewTuple(types.Types[types.TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TBOOL], v)
 		},
 		sys.AMD64, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "CasRel",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue4(ssa.OpAtomicCompareAndSwap32, types.NewTuple(types.Types[types.TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TBOOL], v)
 		},
 		sys.PPC64)
 
-	atomicCasEmitterARM64 := func(s *state, n *Node, args []*ssa.Value, op ssa.Op, typ types.EType) {
+	atomicCasEmitterARM64 := func(s *state, n *ir.Node, args []*ssa.Value, op ssa.Op, typ types.EType) {
 		v := s.newValue4(op, types.NewTuple(types.Types[types.TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
 		s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 		s.vars[n] = s.newValue1(ssa.OpSelect0, types.Types[typ], v)
 	}
 
 	addF("runtime/internal/atomic", "Cas",
-		makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicCompareAndSwap32, ssa.OpAtomicCompareAndSwap32Variant, TUINT32, TBOOL, atomicCasEmitterARM64),
+		makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicCompareAndSwap32, ssa.OpAtomicCompareAndSwap32Variant, types.TUINT32, types.TBOOL, atomicCasEmitterARM64),
 		sys.ARM64)
 	addF("runtime/internal/atomic", "Cas64",
-		makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicCompareAndSwap64, ssa.OpAtomicCompareAndSwap64Variant, TUINT64, TBOOL, atomicCasEmitterARM64),
+		makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicCompareAndSwap64, ssa.OpAtomicCompareAndSwap64Variant, types.TUINT64, types.TBOOL, atomicCasEmitterARM64),
 		sys.ARM64)
 
 	addF("runtime/internal/atomic", "And8",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicAnd8, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.MIPS, sys.PPC64, sys.S390X)
 	addF("runtime/internal/atomic", "And",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicAnd32, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.MIPS, sys.PPC64, sys.S390X)
 	addF("runtime/internal/atomic", "Or8",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicOr8, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.PPC64, sys.S390X)
 	addF("runtime/internal/atomic", "Or",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicOr32, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.MIPS, sys.PPC64, sys.S390X)
 
-	atomicAndOrEmitterARM64 := func(s *state, n *Node, args []*ssa.Value, op ssa.Op, typ types.EType) {
+	atomicAndOrEmitterARM64 := func(s *state, n *ir.Node, args []*ssa.Value, op ssa.Op, typ types.EType) {
 		s.vars[memVar] = s.newValue3(op, types.TypeMem, args[0], args[1], s.mem())
 	}
 
 	addF("runtime/internal/atomic", "And8",
-		makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicAnd8, ssa.OpAtomicAnd8Variant, TNIL, TNIL, atomicAndOrEmitterARM64),
+		makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicAnd8, ssa.OpAtomicAnd8Variant, types.TNIL, types.TNIL, atomicAndOrEmitterARM64),
 		sys.ARM64)
 	addF("runtime/internal/atomic", "And",
-		makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicAnd32, ssa.OpAtomicAnd32Variant, TNIL, TNIL, atomicAndOrEmitterARM64),
+		makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicAnd32, ssa.OpAtomicAnd32Variant, types.TNIL, types.TNIL, atomicAndOrEmitterARM64),
 		sys.ARM64)
 	addF("runtime/internal/atomic", "Or8",
-		makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicOr8, ssa.OpAtomicOr8Variant, TNIL, TNIL, atomicAndOrEmitterARM64),
+		makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicOr8, ssa.OpAtomicOr8Variant, types.TNIL, types.TNIL, atomicAndOrEmitterARM64),
 		sys.ARM64)
 	addF("runtime/internal/atomic", "Or",
-		makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicOr32, ssa.OpAtomicOr32Variant, TNIL, TNIL, atomicAndOrEmitterARM64),
+		makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicOr32, ssa.OpAtomicOr32Variant, types.TNIL, types.TNIL, atomicAndOrEmitterARM64),
 		sys.ARM64)
 
 	alias("runtime/internal/atomic", "Loadint64", "runtime/internal/atomic", "Load64", all...)
@@ -3658,57 +3659,57 @@ func init() {
 
 	/******** math ********/
 	addF("math", "Sqrt",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpSqrt, types.Types[TFLOAT64], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpSqrt, types.Types[types.TFLOAT64], args[0])
 		},
 		sys.I386, sys.AMD64, sys.ARM, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X, sys.Wasm)
 	addF("math", "Trunc",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpTrunc, types.Types[TFLOAT64], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpTrunc, types.Types[types.TFLOAT64], args[0])
 		},
 		sys.ARM64, sys.PPC64, sys.S390X, sys.Wasm)
 	addF("math", "Ceil",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpCeil, types.Types[TFLOAT64], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpCeil, types.Types[types.TFLOAT64], args[0])
 		},
 		sys.ARM64, sys.PPC64, sys.S390X, sys.Wasm)
 	addF("math", "Floor",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpFloor, types.Types[TFLOAT64], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpFloor, types.Types[types.TFLOAT64], args[0])
 		},
 		sys.ARM64, sys.PPC64, sys.S390X, sys.Wasm)
 	addF("math", "Round",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpRound, types.Types[TFLOAT64], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpRound, types.Types[types.TFLOAT64], args[0])
 		},
 		sys.ARM64, sys.PPC64, sys.S390X)
 	addF("math", "RoundToEven",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpRoundToEven, types.Types[TFLOAT64], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpRoundToEven, types.Types[types.TFLOAT64], args[0])
 		},
 		sys.ARM64, sys.S390X, sys.Wasm)
 	addF("math", "Abs",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpAbs, types.Types[TFLOAT64], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpAbs, types.Types[types.TFLOAT64], args[0])
 		},
 		sys.ARM64, sys.ARM, sys.PPC64, sys.Wasm)
 	addF("math", "Copysign",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue2(ssa.OpCopysign, types.Types[TFLOAT64], args[0], args[1])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue2(ssa.OpCopysign, types.Types[types.TFLOAT64], args[0], args[1])
 		},
 		sys.PPC64, sys.Wasm)
 	addF("math", "FMA",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue3(ssa.OpFMA, types.Types[TFLOAT64], args[0], args[1], args[2])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue3(ssa.OpFMA, types.Types[types.TFLOAT64], args[0], args[1], args[2])
 		},
 		sys.ARM64, sys.PPC64, sys.S390X)
 	addF("math", "FMA",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			if !s.config.UseFMA {
 				s.vars[n] = s.callResult(n, callNormal) // types.Types[TFLOAT64]
-				return s.variable(n, types.Types[TFLOAT64])
+				return s.variable(n, types.Types[types.TFLOAT64])
 			}
-			v := s.entryNewValue0A(ssa.OpHasCPUFeature, types.Types[TBOOL], x86HasFMA)
+			v := s.entryNewValue0A(ssa.OpHasCPUFeature, types.Types[types.TBOOL], x86HasFMA)
 			b := s.endBlock()
 			b.Kind = ssa.BlockIf
 			b.SetControl(v)
@@ -3721,7 +3722,7 @@ func init() {
 
 			// We have the intrinsic - use it directly.
 			s.startBlock(bTrue)
-			s.vars[n] = s.newValue3(ssa.OpFMA, types.Types[TFLOAT64], args[0], args[1], args[2])
+			s.vars[n] = s.newValue3(ssa.OpFMA, types.Types[types.TFLOAT64], args[0], args[1], args[2])
 			s.endBlock().AddEdgeTo(bEnd)
 
 			// Call the pure Go version.
@@ -3731,17 +3732,17 @@ func init() {
 
 			// Merge results.
 			s.startBlock(bEnd)
-			return s.variable(n, types.Types[TFLOAT64])
+			return s.variable(n, types.Types[types.TFLOAT64])
 		},
 		sys.AMD64)
 	addF("math", "FMA",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			if !s.config.UseFMA {
 				s.vars[n] = s.callResult(n, callNormal) // types.Types[TFLOAT64]
-				return s.variable(n, types.Types[TFLOAT64])
+				return s.variable(n, types.Types[types.TFLOAT64])
 			}
-			addr := s.entryNewValue1A(ssa.OpAddr, types.Types[TBOOL].PtrTo(), armHasVFPv4, s.sb)
-			v := s.load(types.Types[TBOOL], addr)
+			addr := s.entryNewValue1A(ssa.OpAddr, types.Types[types.TBOOL].PtrTo(), armHasVFPv4, s.sb)
+			v := s.load(types.Types[types.TBOOL], addr)
 			b := s.endBlock()
 			b.Kind = ssa.BlockIf
 			b.SetControl(v)
@@ -3754,7 +3755,7 @@ func init() {
 
 			// We have the intrinsic - use it directly.
 			s.startBlock(bTrue)
-			s.vars[n] = s.newValue3(ssa.OpFMA, types.Types[TFLOAT64], args[0], args[1], args[2])
+			s.vars[n] = s.newValue3(ssa.OpFMA, types.Types[types.TFLOAT64], args[0], args[1], args[2])
 			s.endBlock().AddEdgeTo(bEnd)
 
 			// Call the pure Go version.
@@ -3764,13 +3765,13 @@ func init() {
 
 			// Merge results.
 			s.startBlock(bEnd)
-			return s.variable(n, types.Types[TFLOAT64])
+			return s.variable(n, types.Types[types.TFLOAT64])
 		},
 		sys.ARM)
 
-	makeRoundAMD64 := func(op ssa.Op) func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-		return func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			v := s.entryNewValue0A(ssa.OpHasCPUFeature, types.Types[TBOOL], x86HasSSE41)
+	makeRoundAMD64 := func(op ssa.Op) func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		return func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			v := s.entryNewValue0A(ssa.OpHasCPUFeature, types.Types[types.TBOOL], x86HasSSE41)
 			b := s.endBlock()
 			b.Kind = ssa.BlockIf
 			b.SetControl(v)
@@ -3783,7 +3784,7 @@ func init() {
 
 			// We have the intrinsic - use it directly.
 			s.startBlock(bTrue)
-			s.vars[n] = s.newValue1(op, types.Types[TFLOAT64], args[0])
+			s.vars[n] = s.newValue1(op, types.Types[types.TFLOAT64], args[0])
 			s.endBlock().AddEdgeTo(bEnd)
 
 			// Call the pure Go version.
@@ -3793,7 +3794,7 @@ func init() {
 
 			// Merge results.
 			s.startBlock(bEnd)
-			return s.variable(n, types.Types[TFLOAT64])
+			return s.variable(n, types.Types[types.TFLOAT64])
 		}
 	}
 	addF("math", "RoundToEven",
@@ -3811,55 +3812,55 @@ func init() {
 
 	/******** math/bits ********/
 	addF("math/bits", "TrailingZeros64",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpCtz64, types.Types[TINT], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpCtz64, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
 	addF("math/bits", "TrailingZeros32",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpCtz32, types.Types[TINT], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpCtz32, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
 	addF("math/bits", "TrailingZeros16",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			x := s.newValue1(ssa.OpZeroExt16to32, types.Types[TUINT32], args[0])
-			c := s.constInt32(types.Types[TUINT32], 1<<16)
-			y := s.newValue2(ssa.OpOr32, types.Types[TUINT32], x, c)
-			return s.newValue1(ssa.OpCtz32, types.Types[TINT], y)
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			x := s.newValue1(ssa.OpZeroExt16to32, types.Types[types.TUINT32], args[0])
+			c := s.constInt32(types.Types[types.TUINT32], 1<<16)
+			y := s.newValue2(ssa.OpOr32, types.Types[types.TUINT32], x, c)
+			return s.newValue1(ssa.OpCtz32, types.Types[types.TINT], y)
 		},
 		sys.MIPS)
 	addF("math/bits", "TrailingZeros16",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpCtz16, types.Types[TINT], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpCtz16, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.I386, sys.ARM, sys.ARM64, sys.Wasm)
 	addF("math/bits", "TrailingZeros16",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			x := s.newValue1(ssa.OpZeroExt16to64, types.Types[TUINT64], args[0])
-			c := s.constInt64(types.Types[TUINT64], 1<<16)
-			y := s.newValue2(ssa.OpOr64, types.Types[TUINT64], x, c)
-			return s.newValue1(ssa.OpCtz64, types.Types[TINT], y)
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			x := s.newValue1(ssa.OpZeroExt16to64, types.Types[types.TUINT64], args[0])
+			c := s.constInt64(types.Types[types.TUINT64], 1<<16)
+			y := s.newValue2(ssa.OpOr64, types.Types[types.TUINT64], x, c)
+			return s.newValue1(ssa.OpCtz64, types.Types[types.TINT], y)
 		},
 		sys.S390X, sys.PPC64)
 	addF("math/bits", "TrailingZeros8",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			x := s.newValue1(ssa.OpZeroExt8to32, types.Types[TUINT32], args[0])
-			c := s.constInt32(types.Types[TUINT32], 1<<8)
-			y := s.newValue2(ssa.OpOr32, types.Types[TUINT32], x, c)
-			return s.newValue1(ssa.OpCtz32, types.Types[TINT], y)
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			x := s.newValue1(ssa.OpZeroExt8to32, types.Types[types.TUINT32], args[0])
+			c := s.constInt32(types.Types[types.TUINT32], 1<<8)
+			y := s.newValue2(ssa.OpOr32, types.Types[types.TUINT32], x, c)
+			return s.newValue1(ssa.OpCtz32, types.Types[types.TINT], y)
 		},
 		sys.MIPS)
 	addF("math/bits", "TrailingZeros8",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpCtz8, types.Types[TINT], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpCtz8, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.ARM, sys.ARM64, sys.Wasm)
 	addF("math/bits", "TrailingZeros8",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			x := s.newValue1(ssa.OpZeroExt8to64, types.Types[TUINT64], args[0])
-			c := s.constInt64(types.Types[TUINT64], 1<<8)
-			y := s.newValue2(ssa.OpOr64, types.Types[TUINT64], x, c)
-			return s.newValue1(ssa.OpCtz64, types.Types[TINT], y)
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			x := s.newValue1(ssa.OpZeroExt8to64, types.Types[types.TUINT64], args[0])
+			c := s.constInt64(types.Types[types.TUINT64], 1<<8)
+			y := s.newValue2(ssa.OpOr64, types.Types[types.TUINT64], x, c)
+			return s.newValue1(ssa.OpCtz64, types.Types[types.TINT], y)
 		},
 		sys.S390X)
 	alias("math/bits", "ReverseBytes64", "runtime/internal/sys", "Bswap64", all...)
@@ -3867,116 +3868,116 @@ func init() {
 	// ReverseBytes inlines correctly, no need to intrinsify it.
 	// ReverseBytes16 lowers to a rotate, no need for anything special here.
 	addF("math/bits", "Len64",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpBitLen64, types.Types[TINT], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpBitLen64, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
 	addF("math/bits", "Len32",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpBitLen32, types.Types[TINT], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpBitLen32, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.ARM64)
 	addF("math/bits", "Len32",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			if s.config.PtrSize == 4 {
-				return s.newValue1(ssa.OpBitLen32, types.Types[TINT], args[0])
+				return s.newValue1(ssa.OpBitLen32, types.Types[types.TINT], args[0])
 			}
-			x := s.newValue1(ssa.OpZeroExt32to64, types.Types[TUINT64], args[0])
-			return s.newValue1(ssa.OpBitLen64, types.Types[TINT], x)
+			x := s.newValue1(ssa.OpZeroExt32to64, types.Types[types.TUINT64], args[0])
+			return s.newValue1(ssa.OpBitLen64, types.Types[types.TINT], x)
 		},
 		sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
 	addF("math/bits", "Len16",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			if s.config.PtrSize == 4 {
-				x := s.newValue1(ssa.OpZeroExt16to32, types.Types[TUINT32], args[0])
-				return s.newValue1(ssa.OpBitLen32, types.Types[TINT], x)
+				x := s.newValue1(ssa.OpZeroExt16to32, types.Types[types.TUINT32], args[0])
+				return s.newValue1(ssa.OpBitLen32, types.Types[types.TINT], x)
 			}
-			x := s.newValue1(ssa.OpZeroExt16to64, types.Types[TUINT64], args[0])
-			return s.newValue1(ssa.OpBitLen64, types.Types[TINT], x)
+			x := s.newValue1(ssa.OpZeroExt16to64, types.Types[types.TUINT64], args[0])
+			return s.newValue1(ssa.OpBitLen64, types.Types[types.TINT], x)
 		},
 		sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
 	addF("math/bits", "Len16",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpBitLen16, types.Types[TINT], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpBitLen16, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64)
 	addF("math/bits", "Len8",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			if s.config.PtrSize == 4 {
-				x := s.newValue1(ssa.OpZeroExt8to32, types.Types[TUINT32], args[0])
-				return s.newValue1(ssa.OpBitLen32, types.Types[TINT], x)
+				x := s.newValue1(ssa.OpZeroExt8to32, types.Types[types.TUINT32], args[0])
+				return s.newValue1(ssa.OpBitLen32, types.Types[types.TINT], x)
 			}
-			x := s.newValue1(ssa.OpZeroExt8to64, types.Types[TUINT64], args[0])
-			return s.newValue1(ssa.OpBitLen64, types.Types[TINT], x)
+			x := s.newValue1(ssa.OpZeroExt8to64, types.Types[types.TUINT64], args[0])
+			return s.newValue1(ssa.OpBitLen64, types.Types[types.TINT], x)
 		},
 		sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
 	addF("math/bits", "Len8",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpBitLen8, types.Types[TINT], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpBitLen8, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64)
 	addF("math/bits", "Len",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			if s.config.PtrSize == 4 {
-				return s.newValue1(ssa.OpBitLen32, types.Types[TINT], args[0])
+				return s.newValue1(ssa.OpBitLen32, types.Types[types.TINT], args[0])
 			}
-			return s.newValue1(ssa.OpBitLen64, types.Types[TINT], args[0])
+			return s.newValue1(ssa.OpBitLen64, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
 	// LeadingZeros is handled because it trivially calls Len.
 	addF("math/bits", "Reverse64",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpBitRev64, types.Types[TINT], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpBitRev64, types.Types[types.TINT], args[0])
 		},
 		sys.ARM64)
 	addF("math/bits", "Reverse32",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpBitRev32, types.Types[TINT], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpBitRev32, types.Types[types.TINT], args[0])
 		},
 		sys.ARM64)
 	addF("math/bits", "Reverse16",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpBitRev16, types.Types[TINT], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpBitRev16, types.Types[types.TINT], args[0])
 		},
 		sys.ARM64)
 	addF("math/bits", "Reverse8",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpBitRev8, types.Types[TINT], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpBitRev8, types.Types[types.TINT], args[0])
 		},
 		sys.ARM64)
 	addF("math/bits", "Reverse",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			if s.config.PtrSize == 4 {
-				return s.newValue1(ssa.OpBitRev32, types.Types[TINT], args[0])
+				return s.newValue1(ssa.OpBitRev32, types.Types[types.TINT], args[0])
 			}
-			return s.newValue1(ssa.OpBitRev64, types.Types[TINT], args[0])
+			return s.newValue1(ssa.OpBitRev64, types.Types[types.TINT], args[0])
 		},
 		sys.ARM64)
 	addF("math/bits", "RotateLeft8",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue2(ssa.OpRotateLeft8, types.Types[TUINT8], args[0], args[1])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue2(ssa.OpRotateLeft8, types.Types[types.TUINT8], args[0], args[1])
 		},
 		sys.AMD64)
 	addF("math/bits", "RotateLeft16",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue2(ssa.OpRotateLeft16, types.Types[TUINT16], args[0], args[1])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue2(ssa.OpRotateLeft16, types.Types[types.TUINT16], args[0], args[1])
 		},
 		sys.AMD64)
 	addF("math/bits", "RotateLeft32",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue2(ssa.OpRotateLeft32, types.Types[TUINT32], args[0], args[1])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue2(ssa.OpRotateLeft32, types.Types[types.TUINT32], args[0], args[1])
 		},
 		sys.AMD64, sys.ARM, sys.ARM64, sys.S390X, sys.PPC64, sys.Wasm)
 	addF("math/bits", "RotateLeft64",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue2(ssa.OpRotateLeft64, types.Types[TUINT64], args[0], args[1])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue2(ssa.OpRotateLeft64, types.Types[types.TUINT64], args[0], args[1])
 		},
 		sys.AMD64, sys.ARM64, sys.S390X, sys.PPC64, sys.Wasm)
 	alias("math/bits", "RotateLeft", "math/bits", "RotateLeft64", p8...)
 
-	makeOnesCountAMD64 := func(op64 ssa.Op, op32 ssa.Op) func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-		return func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			v := s.entryNewValue0A(ssa.OpHasCPUFeature, types.Types[TBOOL], x86HasPOPCNT)
+	makeOnesCountAMD64 := func(op64 ssa.Op, op32 ssa.Op) func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		return func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			v := s.entryNewValue0A(ssa.OpHasCPUFeature, types.Types[types.TBOOL], x86HasPOPCNT)
 			b := s.endBlock()
 			b.Kind = ssa.BlockIf
 			b.SetControl(v)
@@ -3993,7 +3994,7 @@ func init() {
 			if s.config.PtrSize == 4 {
 				op = op32
 			}
-			s.vars[n] = s.newValue1(op, types.Types[TINT], args[0])
+			s.vars[n] = s.newValue1(op, types.Types[types.TINT], args[0])
 			s.endBlock().AddEdgeTo(bEnd)
 
 			// Call the pure Go version.
@@ -4003,67 +4004,67 @@ func init() {
 
 			// Merge results.
 			s.startBlock(bEnd)
-			return s.variable(n, types.Types[TINT])
+			return s.variable(n, types.Types[types.TINT])
 		}
 	}
 	addF("math/bits", "OnesCount64",
 		makeOnesCountAMD64(ssa.OpPopCount64, ssa.OpPopCount64),
 		sys.AMD64)
 	addF("math/bits", "OnesCount64",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpPopCount64, types.Types[TINT], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpPopCount64, types.Types[types.TINT], args[0])
 		},
 		sys.PPC64, sys.ARM64, sys.S390X, sys.Wasm)
 	addF("math/bits", "OnesCount32",
 		makeOnesCountAMD64(ssa.OpPopCount32, ssa.OpPopCount32),
 		sys.AMD64)
 	addF("math/bits", "OnesCount32",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpPopCount32, types.Types[TINT], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpPopCount32, types.Types[types.TINT], args[0])
 		},
 		sys.PPC64, sys.ARM64, sys.S390X, sys.Wasm)
 	addF("math/bits", "OnesCount16",
 		makeOnesCountAMD64(ssa.OpPopCount16, ssa.OpPopCount16),
 		sys.AMD64)
 	addF("math/bits", "OnesCount16",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpPopCount16, types.Types[TINT], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpPopCount16, types.Types[types.TINT], args[0])
 		},
 		sys.ARM64, sys.S390X, sys.PPC64, sys.Wasm)
 	addF("math/bits", "OnesCount8",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue1(ssa.OpPopCount8, types.Types[TINT], args[0])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue1(ssa.OpPopCount8, types.Types[types.TINT], args[0])
 		},
 		sys.S390X, sys.PPC64, sys.Wasm)
 	addF("math/bits", "OnesCount",
 		makeOnesCountAMD64(ssa.OpPopCount64, ssa.OpPopCount32),
 		sys.AMD64)
 	addF("math/bits", "Mul64",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue2(ssa.OpMul64uhilo, types.NewTuple(types.Types[TUINT64], types.Types[TUINT64]), args[0], args[1])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue2(ssa.OpMul64uhilo, types.NewTuple(types.Types[types.TUINT64], types.Types[types.TUINT64]), args[0], args[1])
 		},
 		sys.AMD64, sys.ARM64, sys.PPC64, sys.S390X, sys.MIPS64)
 	alias("math/bits", "Mul", "math/bits", "Mul64", sys.ArchAMD64, sys.ArchARM64, sys.ArchPPC64, sys.ArchS390X, sys.ArchMIPS64, sys.ArchMIPS64LE)
 	addF("math/bits", "Add64",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue3(ssa.OpAdd64carry, types.NewTuple(types.Types[TUINT64], types.Types[TUINT64]), args[0], args[1], args[2])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue3(ssa.OpAdd64carry, types.NewTuple(types.Types[types.TUINT64], types.Types[types.TUINT64]), args[0], args[1], args[2])
 		},
 		sys.AMD64, sys.ARM64, sys.PPC64, sys.S390X)
 	alias("math/bits", "Add", "math/bits", "Add64", sys.ArchAMD64, sys.ArchARM64, sys.ArchPPC64, sys.ArchS390X)
 	addF("math/bits", "Sub64",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue3(ssa.OpSub64borrow, types.NewTuple(types.Types[TUINT64], types.Types[TUINT64]), args[0], args[1], args[2])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue3(ssa.OpSub64borrow, types.NewTuple(types.Types[types.TUINT64], types.Types[types.TUINT64]), args[0], args[1], args[2])
 		},
 		sys.AMD64, sys.ARM64, sys.S390X)
 	alias("math/bits", "Sub", "math/bits", "Sub64", sys.ArchAMD64, sys.ArchARM64, sys.ArchS390X)
 	addF("math/bits", "Div64",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
 			// check for divide-by-zero/overflow and panic with appropriate message
-			cmpZero := s.newValue2(s.ssaOp(ONE, types.Types[TUINT64]), types.Types[TBOOL], args[2], s.zeroVal(types.Types[TUINT64]))
+			cmpZero := s.newValue2(s.ssaOp(ir.ONE, types.Types[types.TUINT64]), types.Types[types.TBOOL], args[2], s.zeroVal(types.Types[types.TUINT64]))
 			s.check(cmpZero, panicdivide)
-			cmpOverflow := s.newValue2(s.ssaOp(OLT, types.Types[TUINT64]), types.Types[TBOOL], args[0], args[2])
+			cmpOverflow := s.newValue2(s.ssaOp(ir.OLT, types.Types[types.TUINT64]), types.Types[types.TBOOL], args[0], args[2])
 			s.check(cmpOverflow, panicoverflow)
-			return s.newValue3(ssa.OpDiv128u, types.NewTuple(types.Types[TUINT64], types.Types[TUINT64]), args[0], args[1], args[2])
+			return s.newValue3(ssa.OpDiv128u, types.NewTuple(types.Types[types.TUINT64], types.Types[types.TUINT64]), args[0], args[1], args[2])
 		},
 		sys.AMD64)
 	alias("math/bits", "Div", "math/bits", "Div64", sys.ArchAMD64)
@@ -4117,8 +4118,8 @@ func init() {
 
 	/******** math/big ********/
 	add("math/big", "mulWW",
-		func(s *state, n *Node, args []*ssa.Value) *ssa.Value {
-			return s.newValue2(ssa.OpMul64uhilo, types.NewTuple(types.Types[TUINT64], types.Types[TUINT64]), args[0], args[1])
+		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			return s.newValue2(ssa.OpMul64uhilo, types.NewTuple(types.Types[types.TUINT64], types.Types[types.TUINT64]), args[0], args[1])
 		},
 		sys.ArchAMD64, sys.ArchARM64, sys.ArchPPC64LE, sys.ArchPPC64, sys.ArchS390X)
 }
@@ -4130,7 +4131,7 @@ func findIntrinsic(sym *types.Sym) intrinsicBuilder {
 		return nil
 	}
 	pkg := sym.Pkg.Path
-	if sym.Pkg == localpkg {
+	if sym.Pkg == ir.LocalPkg {
 		pkg = base.Ctxt.Pkgpath
 	}
 	if base.Flag.Race && pkg == "sync/atomic" {
@@ -4155,7 +4156,7 @@ func findIntrinsic(sym *types.Sym) intrinsicBuilder {
 	return intrinsics[intrinsicKey{thearch.LinkArch.Arch, pkg, fn}]
 }
 
-func isIntrinsicCall(n *Node) bool {
+func isIntrinsicCall(n *ir.Node) bool {
 	if n == nil || n.Left == nil {
 		return false
 	}
@@ -4163,7 +4164,7 @@ func isIntrinsicCall(n *Node) bool {
 }
 
 // intrinsicCall converts a call to a recognized intrinsic function into the intrinsic SSA operation.
-func (s *state) intrinsicCall(n *Node) *ssa.Value {
+func (s *state) intrinsicCall(n *ir.Node) *ssa.Value {
 	v := findIntrinsic(n.Left.Sym)(s, n, s.intrinsicArgs(n))
 	if ssa.IntrinsicsDebug > 0 {
 		x := v
@@ -4179,15 +4180,15 @@ func (s *state) intrinsicCall(n *Node) *ssa.Value {
 }
 
 // intrinsicArgs extracts args from n, evaluates them to SSA values, and returns them.
-func (s *state) intrinsicArgs(n *Node) []*ssa.Value {
+func (s *state) intrinsicArgs(n *ir.Node) []*ssa.Value {
 	// Construct map of temps; see comments in s.call about the structure of n.
-	temps := map[*Node]*ssa.Value{}
+	temps := map[*ir.Node]*ssa.Value{}
 	for _, a := range n.List.Slice() {
-		if a.Op != OAS {
+		if a.Op != ir.OAS {
 			s.Fatalf("non-assignment as a temp function argument %v", a.Op)
 		}
 		l, r := a.Left, a.Right
-		if l.Op != ONAME {
+		if l.Op != ir.ONAME {
 			s.Fatalf("non-ONAME temp function argument %v", a.Op)
 		}
 		// Evaluate and store to "temporary".
@@ -4214,7 +4215,7 @@ func (s *state) intrinsicArgs(n *Node) []*ssa.Value {
 // call. We will also record funcdata information on where the args are stored
 // (as well as the deferBits variable), and this will enable us to run the proper
 // defer calls during panics.
-func (s *state) openDeferRecord(n *Node) {
+func (s *state) openDeferRecord(n *ir.Node) {
 	// Do any needed expression evaluation for the args (including the
 	// receiver, if any). This may be evaluating something like 'autotmp_3 =
 	// once.mutex'. Such a statement will create a mapping in s.vars[] from
@@ -4223,24 +4224,24 @@ func (s *state) openDeferRecord(n *Node) {
 	s.stmtList(n.List)
 
 	var args []*ssa.Value
-	var argNodes []*Node
+	var argNodes []*ir.Node
 
 	opendefer := &openDeferInfo{
 		n: n,
 	}
 	fn := n.Left
-	if n.Op == OCALLFUNC {
+	if n.Op == ir.OCALLFUNC {
 		// We must always store the function value in a stack slot for the
 		// runtime panic code to use. But in the defer exit code, we will
 		// call the function directly if it is a static function.
 		closureVal := s.expr(fn)
 		closure := s.openDeferSave(nil, fn.Type, closureVal)
-		opendefer.closureNode = closure.Aux.(*Node)
-		if !(fn.Op == ONAME && fn.Class() == PFUNC) {
+		opendefer.closureNode = closure.Aux.(*ir.Node)
+		if !(fn.Op == ir.ONAME && fn.Class() == ir.PFUNC) {
 			opendefer.closure = closure
 		}
-	} else if n.Op == OCALLMETH {
-		if fn.Op != ODOTMETH {
+	} else if n.Op == ir.OCALLMETH {
+		if fn.Op != ir.ODOTMETH {
 			base.Fatalf("OCALLMETH: n.Left not an ODOTMETH: %v", fn)
 		}
 		closureVal := s.getMethodClosure(fn)
@@ -4248,9 +4249,9 @@ func (s *state) openDeferRecord(n *Node) {
 		// runtime panic code to use. But in the defer exit code, we will
 		// call the method directly.
 		closure := s.openDeferSave(nil, fn.Type, closureVal)
-		opendefer.closureNode = closure.Aux.(*Node)
+		opendefer.closureNode = closure.Aux.(*ir.Node)
 	} else {
-		if fn.Op != ODOTINTER {
+		if fn.Op != ir.ODOTINTER {
 			base.Fatalf("OCALLINTER: n.Left not an ODOTINTER: %v", fn.Op)
 		}
 		closure, rcvr := s.getClosureAndRcvr(fn)
@@ -4258,8 +4259,8 @@ func (s *state) openDeferRecord(n *Node) {
 		// Important to get the receiver type correct, so it is recognized
 		// as a pointer for GC purposes.
 		opendefer.rcvr = s.openDeferSave(nil, fn.Type.Recv().Type, rcvr)
-		opendefer.closureNode = opendefer.closure.Aux.(*Node)
-		opendefer.rcvrNode = opendefer.rcvr.Aux.(*Node)
+		opendefer.closureNode = opendefer.closure.Aux.(*ir.Node)
+		opendefer.rcvrNode = opendefer.rcvr.Aux.(*ir.Node)
 	}
 	for _, argn := range n.Rlist.Slice() {
 		var v *ssa.Value
@@ -4269,7 +4270,7 @@ func (s *state) openDeferRecord(n *Node) {
 			v = s.openDeferSave(argn, argn.Type, nil)
 		}
 		args = append(args, v)
-		argNodes = append(argNodes, v.Aux.(*Node))
+		argNodes = append(argNodes, v.Aux.(*ir.Node))
 	}
 	opendefer.argVals = args
 	opendefer.argNodes = argNodes
@@ -4278,10 +4279,10 @@ func (s *state) openDeferRecord(n *Node) {
 
 	// Update deferBits only after evaluation and storage to stack of
 	// args/receiver/interface is successful.
-	bitvalue := s.constInt8(types.Types[TUINT8], 1<<uint(index))
-	newDeferBits := s.newValue2(ssa.OpOr8, types.Types[TUINT8], s.variable(deferBitsVar, types.Types[TUINT8]), bitvalue)
+	bitvalue := s.constInt8(types.Types[types.TUINT8], 1<<uint(index))
+	newDeferBits := s.newValue2(ssa.OpOr8, types.Types[types.TUINT8], s.variable(deferBitsVar, types.Types[types.TUINT8]), bitvalue)
 	s.vars[deferBitsVar] = newDeferBits
-	s.store(types.Types[TUINT8], s.deferBitsAddr, newDeferBits)
+	s.store(types.Types[types.TUINT8], s.deferBitsAddr, newDeferBits)
 }
 
 // openDeferSave generates SSA nodes to store a value (with type t) for an
@@ -4291,7 +4292,7 @@ func (s *state) openDeferRecord(n *Node) {
 // type t is non-SSAable, then n must be non-nil (and val should be nil) and n is
 // evaluated (via s.addr() below) to get the value that is to be stored. The
 // function returns an SSA value representing a pointer to the autotmp location.
-func (s *state) openDeferSave(n *Node, t *types.Type, val *ssa.Value) *ssa.Value {
+func (s *state) openDeferSave(n *ir.Node, t *types.Type, val *ssa.Value) *ssa.Value {
 	canSSA := canSSAType(t)
 	var pos src.XPos
 	if canSSA {
@@ -4349,7 +4350,7 @@ func (s *state) openDeferExit() {
 	s.startBlock(deferExit)
 	s.lastDeferExit = deferExit
 	s.lastDeferCount = len(s.openDefers)
-	zeroval := s.constInt8(types.Types[TUINT8], 0)
+	zeroval := s.constInt8(types.Types[types.TUINT8], 0)
 	testLateExpansion := ssa.LateCallExpansionEnabledWithin(s.f)
 	// Test for and run defers in reverse order
 	for i := len(s.openDefers) - 1; i >= 0; i-- {
@@ -4357,12 +4358,12 @@ func (s *state) openDeferExit() {
 		bCond := s.f.NewBlock(ssa.BlockPlain)
 		bEnd := s.f.NewBlock(ssa.BlockPlain)
 
-		deferBits := s.variable(deferBitsVar, types.Types[TUINT8])
+		deferBits := s.variable(deferBitsVar, types.Types[types.TUINT8])
 		// Generate code to check if the bit associated with the current
 		// defer is set.
-		bitval := s.constInt8(types.Types[TUINT8], 1<<uint(i))
-		andval := s.newValue2(ssa.OpAnd8, types.Types[TUINT8], deferBits, bitval)
-		eqVal := s.newValue2(ssa.OpEq8, types.Types[TBOOL], andval, zeroval)
+		bitval := s.constInt8(types.Types[types.TUINT8], 1<<uint(i))
+		andval := s.newValue2(ssa.OpAnd8, types.Types[types.TUINT8], deferBits, bitval)
+		eqVal := s.newValue2(ssa.OpEq8, types.Types[types.TBOOL], andval, zeroval)
 		b := s.endBlock()
 		b.Kind = ssa.BlockIf
 		b.SetControl(eqVal)
@@ -4373,9 +4374,9 @@ func (s *state) openDeferExit() {
 
 		// Clear this bit in deferBits and force store back to stack, so
 		// we will not try to re-run this defer call if this defer call panics.
-		nbitval := s.newValue1(ssa.OpCom8, types.Types[TUINT8], bitval)
-		maskedval := s.newValue2(ssa.OpAnd8, types.Types[TUINT8], deferBits, nbitval)
-		s.store(types.Types[TUINT8], s.deferBitsAddr, maskedval)
+		nbitval := s.newValue1(ssa.OpCom8, types.Types[types.TUINT8], bitval)
+		maskedval := s.newValue2(ssa.OpAnd8, types.Types[types.TUINT8], deferBits, nbitval)
+		s.store(types.Types[types.TUINT8], s.deferBitsAddr, maskedval)
 		// Use this value for following tests, so we keep previous
 		// bits cleared.
 		s.vars[deferBitsVar] = maskedval
@@ -4393,11 +4394,11 @@ func (s *state) openDeferExit() {
 			// rcvr in case of OCALLINTER
 			v := s.load(r.rcvr.Type.Elem(), r.rcvr)
 			addr := s.constOffPtrSP(s.f.Config.Types.UintptrPtr, argStart)
-			ACArgs = append(ACArgs, ssa.Param{Type: types.Types[TUINTPTR], Offset: int32(argStart)})
+			ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(argStart)})
 			if testLateExpansion {
 				callArgs = append(callArgs, v)
 			} else {
-				s.store(types.Types[TUINTPTR], addr, v)
+				s.store(types.Types[types.TUINTPTR], addr, v)
 			}
 		}
 		for j, argAddrVal := range r.argVals {
@@ -4426,7 +4427,7 @@ func (s *state) openDeferExit() {
 		if r.closure != nil {
 			v := s.load(r.closure.Type.Elem(), r.closure)
 			s.maybeNilCheckClosure(v, callDefer)
-			codeptr := s.rawLoad(types.Types[TUINTPTR], v)
+			codeptr := s.rawLoad(types.Types[types.TUINTPTR], v)
 			aux := ssa.ClosureAuxCall(ACArgs, ACResults)
 			if testLateExpansion {
 				callArgs = append(callArgs, s.mem())
@@ -4475,17 +4476,17 @@ func (s *state) openDeferExit() {
 	}
 }
 
-func (s *state) callResult(n *Node, k callKind) *ssa.Value {
+func (s *state) callResult(n *ir.Node, k callKind) *ssa.Value {
 	return s.call(n, k, false)
 }
 
-func (s *state) callAddr(n *Node, k callKind) *ssa.Value {
+func (s *state) callAddr(n *ir.Node, k callKind) *ssa.Value {
 	return s.call(n, k, true)
 }
 
 // Calls the function n using the specified call type.
 // Returns the address of the return value (or nil if none).
-func (s *state) call(n *Node, k callKind, returnResultAddr bool) *ssa.Value {
+func (s *state) call(n *ir.Node, k callKind, returnResultAddr bool) *ssa.Value {
 	s.prevCall = nil
 	var sym *types.Sym     // target symbol (if static)
 	var closure *ssa.Value // ptr to closure to run (if dynamic)
@@ -4507,9 +4508,9 @@ func (s *state) call(n *Node, k callKind, returnResultAddr bool) *ssa.Value {
 	testLateExpansion := false
 
 	switch n.Op {
-	case OCALLFUNC:
+	case ir.OCALLFUNC:
 		testLateExpansion = k != callDeferStack && ssa.LateCallExpansionEnabledWithin(s.f)
-		if k == callNormal && fn.Op == ONAME && fn.Class() == PFUNC {
+		if k == callNormal && fn.Op == ir.ONAME && fn.Class() == ir.PFUNC {
 			sym = fn.Sym
 			break
 		}
@@ -4519,8 +4520,8 @@ func (s *state) call(n *Node, k callKind, returnResultAddr bool) *ssa.Value {
 			// not the point of defer statement.
 			s.maybeNilCheckClosure(closure, k)
 		}
-	case OCALLMETH:
-		if fn.Op != ODOTMETH {
+	case ir.OCALLMETH:
+		if fn.Op != ir.ODOTMETH {
 			s.Fatalf("OCALLMETH: n.Left not an ODOTMETH: %v", fn)
 		}
 		testLateExpansion = k != callDeferStack && ssa.LateCallExpansionEnabledWithin(s.f)
@@ -4531,15 +4532,15 @@ func (s *state) call(n *Node, k callKind, returnResultAddr bool) *ssa.Value {
 		closure = s.getMethodClosure(fn)
 		// Note: receiver is already present in n.Rlist, so we don't
 		// want to set it here.
-	case OCALLINTER:
-		if fn.Op != ODOTINTER {
+	case ir.OCALLINTER:
+		if fn.Op != ir.ODOTINTER {
 			s.Fatalf("OCALLINTER: n.Left not an ODOTINTER: %v", fn.Op)
 		}
 		testLateExpansion = k != callDeferStack && ssa.LateCallExpansionEnabledWithin(s.f)
 		var iclosure *ssa.Value
 		iclosure, rcvr = s.getClosureAndRcvr(fn)
 		if k == callNormal {
-			codeptr = s.load(types.Types[TUINTPTR], iclosure)
+			codeptr = s.load(types.Types[types.TUINTPTR], iclosure)
 		} else {
 			closure = iclosure
 		}
@@ -4564,9 +4565,9 @@ func (s *state) call(n *Node, k callKind, returnResultAddr bool) *ssa.Value {
 
 		// Must match reflect.go:deferstruct and src/runtime/runtime2.go:_defer.
 		// 0: siz
-		s.store(types.Types[TUINT32],
-			s.newValue1I(ssa.OpOffPtr, types.Types[TUINT32].PtrTo(), t.FieldOff(0), addr),
-			s.constInt32(types.Types[TUINT32], int32(stksize)))
+		s.store(types.Types[types.TUINT32],
+			s.newValue1I(ssa.OpOffPtr, types.Types[types.TUINT32].PtrTo(), t.FieldOff(0), addr),
+			s.constInt32(types.Types[types.TUINT32], int32(stksize)))
 		// 1: started, set in deferprocStack
 		// 2: heap, set in deferprocStack
 		// 3: openDefer
@@ -4590,10 +4591,10 @@ func (s *state) call(n *Node, k callKind, returnResultAddr bool) *ssa.Value {
 		// Set receiver (for interface calls). Always a pointer.
 		if rcvr != nil {
 			p := s.newValue1I(ssa.OpOffPtr, ft.Recv().Type.PtrTo(), off, addr)
-			s.store(types.Types[TUINTPTR], p, rcvr)
+			s.store(types.Types[types.TUINTPTR], p, rcvr)
 		}
 		// Set receiver (for method calls).
-		if n.Op == OCALLMETH {
+		if n.Op == ir.OCALLMETH {
 			f := ft.Recv()
 			s.storeArgWithBase(args[0], f.Type, addr, off+f.Offset)
 			args = args[1:]
@@ -4605,15 +4606,15 @@ func (s *state) call(n *Node, k callKind, returnResultAddr bool) *ssa.Value {
 		}
 
 		// Call runtime.deferprocStack with pointer to _defer record.
-		ACArgs = append(ACArgs, ssa.Param{Type: types.Types[TUINTPTR], Offset: int32(base.Ctxt.FixedFrameSize())})
+		ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(base.Ctxt.FixedFrameSize())})
 		aux := ssa.StaticAuxCall(deferprocStack, ACArgs, ACResults)
 		if testLateExpansion {
 			callArgs = append(callArgs, addr, s.mem())
 			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 			call.AddArgs(callArgs...)
 		} else {
-			arg0 := s.constOffPtrSP(types.Types[TUINTPTR], base.Ctxt.FixedFrameSize())
-			s.store(types.Types[TUINTPTR], arg0, addr)
+			arg0 := s.constOffPtrSP(types.Types[types.TUINTPTR], base.Ctxt.FixedFrameSize())
+			s.store(types.Types[types.TUINTPTR], arg0, addr)
 			call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, aux, s.mem())
 		}
 		if stksize < int64(Widthptr) {
@@ -4630,20 +4631,20 @@ func (s *state) call(n *Node, k callKind, returnResultAddr bool) *ssa.Value {
 		// Defer/go args.
 		if k != callNormal {
 			// Write argsize and closure (args to newproc/deferproc).
-			argsize := s.constInt32(types.Types[TUINT32], int32(stksize))
-			ACArgs = append(ACArgs, ssa.Param{Type: types.Types[TUINT32], Offset: int32(argStart)})
+			argsize := s.constInt32(types.Types[types.TUINT32], int32(stksize))
+			ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINT32], Offset: int32(argStart)})
 			if testLateExpansion {
 				callArgs = append(callArgs, argsize)
 			} else {
 				addr := s.constOffPtrSP(s.f.Config.Types.UInt32Ptr, argStart)
-				s.store(types.Types[TUINT32], addr, argsize)
+				s.store(types.Types[types.TUINT32], addr, argsize)
 			}
-			ACArgs = append(ACArgs, ssa.Param{Type: types.Types[TUINTPTR], Offset: int32(argStart) + int32(Widthptr)})
+			ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(argStart) + int32(Widthptr)})
 			if testLateExpansion {
 				callArgs = append(callArgs, closure)
 			} else {
 				addr := s.constOffPtrSP(s.f.Config.Types.UintptrPtr, argStart+int64(Widthptr))
-				s.store(types.Types[TUINTPTR], addr, closure)
+				s.store(types.Types[types.TUINTPTR], addr, closure)
 			}
 			stksize += 2 * int64(Widthptr)
 			argStart += 2 * int64(Widthptr)
@@ -4652,18 +4653,18 @@ func (s *state) call(n *Node, k callKind, returnResultAddr bool) *ssa.Value {
 		// Set receiver (for interface calls).
 		if rcvr != nil {
 			addr := s.constOffPtrSP(s.f.Config.Types.UintptrPtr, argStart)
-			ACArgs = append(ACArgs, ssa.Param{Type: types.Types[TUINTPTR], Offset: int32(argStart)})
+			ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(argStart)})
 			if testLateExpansion {
 				callArgs = append(callArgs, rcvr)
 			} else {
-				s.store(types.Types[TUINTPTR], addr, rcvr)
+				s.store(types.Types[types.TUINTPTR], addr, rcvr)
 			}
 		}
 
 		// Write args.
 		t := n.Left.Type
 		args := n.Rlist.Slice()
-		if n.Op == OCALLMETH {
+		if n.Op == ir.OCALLMETH {
 			f := t.Recv()
 			ACArg, arg := s.putArg(args[0], f.Type, argStart+f.Offset, testLateExpansion)
 			ACArgs = append(ACArgs, ACArg)
@@ -4703,7 +4704,7 @@ func (s *state) call(n *Node, k callKind, returnResultAddr bool) *ssa.Value {
 			// can't always figure that out currently, and it's
 			// critical that we not clobber any arguments already
 			// stored onto the stack.
-			codeptr = s.rawLoad(types.Types[TUINTPTR], closure)
+			codeptr = s.rawLoad(types.Types[types.TUINTPTR], closure)
 			if testLateExpansion {
 				aux := ssa.ClosureAuxCall(ACArgs, ACResults)
 				call = s.newValue2A(ssa.OpClosureLECall, aux.LateExpansionResultType(), aux, codeptr, closure)
@@ -4787,26 +4788,26 @@ func (s *state) maybeNilCheckClosure(closure *ssa.Value, k callKind) {
 }
 
 // getMethodClosure returns a value representing the closure for a method call
-func (s *state) getMethodClosure(fn *Node) *ssa.Value {
+func (s *state) getMethodClosure(fn *ir.Node) *ssa.Value {
 	// Make a name n2 for the function.
 	// fn.Sym might be sync.(*Mutex).Unlock.
 	// Make a PFUNC node out of that, then evaluate it.
 	// We get back an SSA value representing &sync.(*Mutex).Unlock·f.
 	// We can then pass that to defer or go.
-	n2 := newnamel(fn.Pos, fn.Sym)
+	n2 := ir.NewNameAt(fn.Pos, fn.Sym)
 	n2.Name.Curfn = s.curfn
-	n2.SetClass(PFUNC)
+	n2.SetClass(ir.PFUNC)
 	// n2.Sym already existed, so it's already marked as a function.
 	n2.Pos = fn.Pos
-	n2.Type = types.Types[TUINT8] // fake type for a static closure. Could use runtime.funcval if we had it.
+	n2.Type = types.Types[types.TUINT8] // fake type for a static closure. Could use runtime.funcval if we had it.
 	return s.expr(n2)
 }
 
 // getClosureAndRcvr returns values for the appropriate closure and receiver of an
 // interface call
-func (s *state) getClosureAndRcvr(fn *Node) (*ssa.Value, *ssa.Value) {
+func (s *state) getClosureAndRcvr(fn *ir.Node) (*ssa.Value, *ssa.Value) {
 	i := s.expr(fn.Left)
-	itab := s.newValue1(ssa.OpITab, types.Types[TUINTPTR], i)
+	itab := s.newValue1(ssa.OpITab, types.Types[types.TUINTPTR], i)
 	s.nilCheck(itab)
 	itabidx := fn.Xoffset + 2*int64(Widthptr) + 8 // offset of fun field in runtime.itab
 	closure := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.UintptrPtr, itabidx, itab)
@@ -4818,9 +4819,9 @@ func (s *state) getClosureAndRcvr(fn *Node) (*ssa.Value, *ssa.Value) {
 // -1 means signed, +1 means unsigned, 0 means non-integer/non-pointer.
 func etypesign(e types.EType) int8 {
 	switch e {
-	case TINT8, TINT16, TINT32, TINT64, TINT:
+	case types.TINT8, types.TINT16, types.TINT32, types.TINT64, types.TINT:
 		return -1
-	case TUINT8, TUINT16, TUINT32, TUINT64, TUINT, TUINTPTR, TUNSAFEPTR:
+	case types.TUINT8, types.TUINT16, types.TUINT32, types.TUINT64, types.TUINT, types.TUINTPTR, types.TUNSAFEPTR:
 		return +1
 	}
 	return 0
@@ -4828,17 +4829,17 @@ func etypesign(e types.EType) int8 {
 
 // addr converts the address of the expression n to SSA, adds it to s and returns the SSA result.
 // The value that the returned Value represents is guaranteed to be non-nil.
-func (s *state) addr(n *Node) *ssa.Value {
-	if n.Op != ONAME {
+func (s *state) addr(n *ir.Node) *ssa.Value {
+	if n.Op != ir.ONAME {
 		s.pushLine(n.Pos)
 		defer s.popLine()
 	}
 
 	t := types.NewPtr(n.Type)
 	switch n.Op {
-	case ONAME:
+	case ir.ONAME:
 		switch n.Class() {
-		case PEXTERN:
+		case ir.PEXTERN:
 			// global variable
 			v := s.entryNewValue1A(ssa.OpAddr, t, n.Sym.Linksym(), s.sb)
 			// TODO: Make OpAddr use AuxInt as well as Aux.
@@ -4846,7 +4847,7 @@ func (s *state) addr(n *Node) *ssa.Value {
 				v = s.entryNewValue1I(ssa.OpOffPtr, v.Type, n.Xoffset, v)
 			}
 			return v
-		case PPARAM:
+		case ir.PPARAM:
 			// parameter slot
 			v := s.decladdrs[n]
 			if v != nil {
@@ -4858,10 +4859,10 @@ func (s *state) addr(n *Node) *ssa.Value {
 			}
 			s.Fatalf("addr of undeclared ONAME %v. declared: %v", n, s.decladdrs)
 			return nil
-		case PAUTO:
+		case ir.PAUTO:
 			return s.newValue2Apos(ssa.OpLocalAddr, t, n, s.sp, s.mem(), !n.IsAutoTmp())
 
-		case PPARAMOUT: // Same as PAUTO -- cannot generate LEA early.
+		case ir.PPARAMOUT: // Same as PAUTO -- cannot generate LEA early.
 			// ensure that we reuse symbols for out parameters so
 			// that cse works on their addresses
 			return s.newValue2Apos(ssa.OpLocalAddr, t, n, s.sp, s.mem(), true)
@@ -4869,7 +4870,7 @@ func (s *state) addr(n *Node) *ssa.Value {
 			s.Fatalf("variable address class %v not implemented", n.Class())
 			return nil
 		}
-	case ORESULT:
+	case ir.ORESULT:
 		// load return from callee
 		if s.prevCall == nil || s.prevCall.Op != ssa.OpStaticLECall && s.prevCall.Op != ssa.OpInterLECall && s.prevCall.Op != ssa.OpClosureLECall {
 			return s.constOffPtrSP(t, n.Xoffset)
@@ -4882,38 +4883,38 @@ func (s *state) addr(n *Node) *ssa.Value {
 		x := s.newValue1I(ssa.OpSelectNAddr, t, which, s.prevCall)
 		return x
 
-	case OINDEX:
+	case ir.OINDEX:
 		if n.Left.Type.IsSlice() {
 			a := s.expr(n.Left)
 			i := s.expr(n.Right)
-			len := s.newValue1(ssa.OpSliceLen, types.Types[TINT], a)
+			len := s.newValue1(ssa.OpSliceLen, types.Types[types.TINT], a)
 			i = s.boundsCheck(i, len, ssa.BoundsIndex, n.Bounded())
 			p := s.newValue1(ssa.OpSlicePtr, t, a)
 			return s.newValue2(ssa.OpPtrIndex, t, p, i)
 		} else { // array
 			a := s.addr(n.Left)
 			i := s.expr(n.Right)
-			len := s.constInt(types.Types[TINT], n.Left.Type.NumElem())
+			len := s.constInt(types.Types[types.TINT], n.Left.Type.NumElem())
 			i = s.boundsCheck(i, len, ssa.BoundsIndex, n.Bounded())
 			return s.newValue2(ssa.OpPtrIndex, types.NewPtr(n.Left.Type.Elem()), a, i)
 		}
-	case ODEREF:
+	case ir.ODEREF:
 		return s.exprPtr(n.Left, n.Bounded(), n.Pos)
-	case ODOT:
+	case ir.ODOT:
 		p := s.addr(n.Left)
 		return s.newValue1I(ssa.OpOffPtr, t, n.Xoffset, p)
-	case ODOTPTR:
+	case ir.ODOTPTR:
 		p := s.exprPtr(n.Left, n.Bounded(), n.Pos)
 		return s.newValue1I(ssa.OpOffPtr, t, n.Xoffset, p)
-	case OCLOSUREVAR:
+	case ir.OCLOSUREVAR:
 		return s.newValue1I(ssa.OpOffPtr, t, n.Xoffset,
 			s.entryNewValue0(ssa.OpGetClosurePtr, s.f.Config.Types.BytePtr))
-	case OCONVNOP:
+	case ir.OCONVNOP:
 		addr := s.addr(n.Left)
 		return s.newValue1(ssa.OpCopy, t, addr) // ensure that addr has the right type
-	case OCALLFUNC, OCALLINTER, OCALLMETH:
+	case ir.OCALLFUNC, ir.OCALLINTER, ir.OCALLMETH:
 		return s.callAddr(n, callNormal)
-	case ODOTTYPE:
+	case ir.ODOTTYPE:
 		v, _ := s.dottype(n, false)
 		if v.Op != ssa.OpLoad {
 			s.Fatalf("dottype of non-load")
@@ -4930,29 +4931,29 @@ func (s *state) addr(n *Node) *ssa.Value {
 
 // canSSA reports whether n is SSA-able.
 // n must be an ONAME (or an ODOT sequence with an ONAME base).
-func (s *state) canSSA(n *Node) bool {
+func (s *state) canSSA(n *ir.Node) bool {
 	if base.Flag.N != 0 {
 		return false
 	}
-	for n.Op == ODOT || (n.Op == OINDEX && n.Left.Type.IsArray()) {
+	for n.Op == ir.ODOT || (n.Op == ir.OINDEX && n.Left.Type.IsArray()) {
 		n = n.Left
 	}
-	if n.Op != ONAME {
+	if n.Op != ir.ONAME {
 		return false
 	}
 	if n.Name.Addrtaken() {
 		return false
 	}
-	if n.isParamHeapCopy() {
+	if isParamHeapCopy(n) {
 		return false
 	}
-	if n.Class() == PAUTOHEAP {
+	if n.Class() == ir.PAUTOHEAP {
 		s.Fatalf("canSSA of PAUTOHEAP %v", n)
 	}
 	switch n.Class() {
-	case PEXTERN:
+	case ir.PEXTERN:
 		return false
-	case PPARAMOUT:
+	case ir.PPARAMOUT:
 		if s.hasdefer {
 			// TODO: handle this case? Named return values must be
 			// in memory so that the deferred function can see them.
@@ -4967,7 +4968,7 @@ func (s *state) canSSA(n *Node) bool {
 			return false
 		}
 	}
-	if n.Class() == PPARAM && n.Sym != nil && n.Sym.Name == ".this" {
+	if n.Class() == ir.PPARAM && n.Sym != nil && n.Sym.Name == ".this" {
 		// wrappers generated by genwrapper need to update
 		// the .this pointer in place.
 		// TODO: treat as a PPARAMOUT?
@@ -4987,7 +4988,7 @@ func canSSAType(t *types.Type) bool {
 		return false
 	}
 	switch t.Etype {
-	case TARRAY:
+	case types.TARRAY:
 		// We can't do larger arrays because dynamic indexing is
 		// not supported on SSA variables.
 		// TODO: allow if all indexes are constant.
@@ -4995,7 +4996,7 @@ func canSSAType(t *types.Type) bool {
 			return canSSAType(t.Elem())
 		}
 		return false
-	case TSTRUCT:
+	case types.TSTRUCT:
 		if t.NumFields() > ssa.MaxStruct {
 			return false
 		}
@@ -5011,7 +5012,7 @@ func canSSAType(t *types.Type) bool {
 }
 
 // exprPtr evaluates n to a pointer and nil-checks it.
-func (s *state) exprPtr(n *Node, bounded bool, lineno src.XPos) *ssa.Value {
+func (s *state) exprPtr(n *ir.Node, bounded bool, lineno src.XPos) *ssa.Value {
 	p := s.expr(n)
 	if bounded || n.NonNil() {
 		if s.f.Frontend().Debug_checknil() && lineno.Line() > 1 {
@@ -5092,9 +5093,9 @@ func (s *state) boundsCheck(idx, len *ssa.Value, kind ssa.BoundsKind, bounded bo
 
 	var cmp *ssa.Value
 	if kind == ssa.BoundsIndex || kind == ssa.BoundsIndexU {
-		cmp = s.newValue2(ssa.OpIsInBounds, types.Types[TBOOL], idx, len)
+		cmp = s.newValue2(ssa.OpIsInBounds, types.Types[types.TBOOL], idx, len)
 	} else {
-		cmp = s.newValue2(ssa.OpIsSliceInBounds, types.Types[TBOOL], idx, len)
+		cmp = s.newValue2(ssa.OpIsSliceInBounds, types.Types[types.TBOOL], idx, len)
 	}
 	b := s.endBlock()
 	b.Kind = ssa.BlockIf
@@ -5120,7 +5121,7 @@ func (s *state) boundsCheck(idx, len *ssa.Value, kind ssa.BoundsKind, bounded bo
 		if kind != ssa.BoundsIndex && kind != ssa.BoundsIndexU {
 			op = ssa.OpSpectreSliceIndex
 		}
-		idx = s.newValue2(op, types.Types[TINT], idx, len)
+		idx = s.newValue2(op, types.Types[types.TINT], idx, len)
 	}
 
 	return idx
@@ -5150,7 +5151,7 @@ func (s *state) check(cmp *ssa.Value, fn *obj.LSym) {
 	s.startBlock(bNext)
 }
 
-func (s *state) intDivide(n *Node, a, b *ssa.Value) *ssa.Value {
+func (s *state) intDivide(n *ir.Node, a, b *ssa.Value) *ssa.Value {
 	needcheck := true
 	switch b.Op {
 	case ssa.OpConst8, ssa.OpConst16, ssa.OpConst32, ssa.OpConst64:
@@ -5160,7 +5161,7 @@ func (s *state) intDivide(n *Node, a, b *ssa.Value) *ssa.Value {
 	}
 	if needcheck {
 		// do a size-appropriate check for zero
-		cmp := s.newValue2(s.ssaOp(ONE, n.Type), types.Types[TBOOL], b, s.zeroVal(n.Type))
+		cmp := s.newValue2(s.ssaOp(ir.ONE, n.Type), types.Types[types.TBOOL], b, s.zeroVal(n.Type))
 		s.check(cmp, panicdivide)
 	}
 	return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
@@ -5291,24 +5292,24 @@ func (s *state) storeTypeScalars(t *types.Type, left, right *ssa.Value, skip ski
 		if skip&skipLen != 0 {
 			return
 		}
-		len := s.newValue1(ssa.OpStringLen, types.Types[TINT], right)
+		len := s.newValue1(ssa.OpStringLen, types.Types[types.TINT], right)
 		lenAddr := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.IntPtr, s.config.PtrSize, left)
-		s.store(types.Types[TINT], lenAddr, len)
+		s.store(types.Types[types.TINT], lenAddr, len)
 	case t.IsSlice():
 		if skip&skipLen == 0 {
-			len := s.newValue1(ssa.OpSliceLen, types.Types[TINT], right)
+			len := s.newValue1(ssa.OpSliceLen, types.Types[types.TINT], right)
 			lenAddr := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.IntPtr, s.config.PtrSize, left)
-			s.store(types.Types[TINT], lenAddr, len)
+			s.store(types.Types[types.TINT], lenAddr, len)
 		}
 		if skip&skipCap == 0 {
-			cap := s.newValue1(ssa.OpSliceCap, types.Types[TINT], right)
+			cap := s.newValue1(ssa.OpSliceCap, types.Types[types.TINT], right)
 			capAddr := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.IntPtr, 2*s.config.PtrSize, left)
-			s.store(types.Types[TINT], capAddr, cap)
+			s.store(types.Types[types.TINT], capAddr, cap)
 		}
 	case t.IsInterface():
 		// itab field doesn't need a write barrier (even though it is a pointer).
 		itab := s.newValue1(ssa.OpITab, s.f.Config.Types.BytePtr, right)
-		s.store(types.Types[TUINTPTR], left, itab)
+		s.store(types.Types[types.TUINTPTR], left, itab)
 	case t.IsStruct():
 		n := t.NumFields()
 		for i := 0; i < n; i++ {
@@ -5369,7 +5370,7 @@ func (s *state) storeTypePtrs(t *types.Type, left, right *ssa.Value) {
 // putArg evaluates n for the purpose of passing it as an argument to a function and returns the corresponding Param for the call.
 // If forLateExpandedCall is true, it returns the argument value to pass to the call operation.
 // If forLateExpandedCall is false, then the value is stored at the specified stack offset, and the returned value is nil.
-func (s *state) putArg(n *Node, t *types.Type, off int64, forLateExpandedCall bool) (ssa.Param, *ssa.Value) {
+func (s *state) putArg(n *ir.Node, t *types.Type, off int64, forLateExpandedCall bool) (ssa.Param, *ssa.Value) {
 	var a *ssa.Value
 	if forLateExpandedCall {
 		if !canSSAType(t) {
@@ -5383,7 +5384,7 @@ func (s *state) putArg(n *Node, t *types.Type, off int64, forLateExpandedCall bo
 	return ssa.Param{Type: t, Offset: int32(off)}, a
 }
 
-func (s *state) storeArgWithBase(n *Node, t *types.Type, base *ssa.Value, off int64) {
+func (s *state) storeArgWithBase(n *ir.Node, t *types.Type, base *ssa.Value, off int64) {
 	pt := types.NewPtr(t)
 	var addr *ssa.Value
 	if base == s.sp {
@@ -5412,11 +5413,11 @@ func (s *state) slice(v, i, j, k *ssa.Value, bounded bool) (p, l, c *ssa.Value)
 	switch {
 	case t.IsSlice():
 		ptr = s.newValue1(ssa.OpSlicePtr, types.NewPtr(t.Elem()), v)
-		len = s.newValue1(ssa.OpSliceLen, types.Types[TINT], v)
-		cap = s.newValue1(ssa.OpSliceCap, types.Types[TINT], v)
+		len = s.newValue1(ssa.OpSliceLen, types.Types[types.TINT], v)
+		cap = s.newValue1(ssa.OpSliceCap, types.Types[types.TINT], v)
 	case t.IsString():
-		ptr = s.newValue1(ssa.OpStringPtr, types.NewPtr(types.Types[TUINT8]), v)
-		len = s.newValue1(ssa.OpStringLen, types.Types[TINT], v)
+		ptr = s.newValue1(ssa.OpStringPtr, types.NewPtr(types.Types[types.TUINT8]), v)
+		len = s.newValue1(ssa.OpStringLen, types.Types[types.TINT], v)
 		cap = len
 	case t.IsPtr():
 		if !t.Elem().IsArray() {
@@ -5424,7 +5425,7 @@ func (s *state) slice(v, i, j, k *ssa.Value, bounded bool) (p, l, c *ssa.Value)
 		}
 		s.nilCheck(v)
 		ptr = s.newValue1(ssa.OpCopy, types.NewPtr(t.Elem().Elem()), v)
-		len = s.constInt(types.Types[TINT], t.Elem().NumElem())
+		len = s.constInt(types.Types[types.TINT], t.Elem().NumElem())
 		cap = len
 	default:
 		s.Fatalf("bad type in slice %v\n", t)
@@ -5432,7 +5433,7 @@ func (s *state) slice(v, i, j, k *ssa.Value, bounded bool) (p, l, c *ssa.Value)
 
 	// Set default values
 	if i == nil {
-		i = s.constInt(types.Types[TINT], 0)
+		i = s.constInt(types.Types[types.TINT], 0)
 	}
 	if j == nil {
 		j = len
@@ -5470,18 +5471,18 @@ func (s *state) slice(v, i, j, k *ssa.Value, bounded bool) (p, l, c *ssa.Value)
 	}
 
 	// Word-sized integer operations.
-	subOp := s.ssaOp(OSUB, types.Types[TINT])
-	mulOp := s.ssaOp(OMUL, types.Types[TINT])
-	andOp := s.ssaOp(OAND, types.Types[TINT])
+	subOp := s.ssaOp(ir.OSUB, types.Types[types.TINT])
+	mulOp := s.ssaOp(ir.OMUL, types.Types[types.TINT])
+	andOp := s.ssaOp(ir.OAND, types.Types[types.TINT])
 
 	// Calculate the length (rlen) and capacity (rcap) of the new slice.
 	// For strings the capacity of the result is unimportant. However,
 	// we use rcap to test if we've generated a zero-length slice.
 	// Use length of strings for that.
-	rlen := s.newValue2(subOp, types.Types[TINT], j, i)
+	rlen := s.newValue2(subOp, types.Types[types.TINT], j, i)
 	rcap := rlen
 	if j != k && !t.IsString() {
-		rcap = s.newValue2(subOp, types.Types[TINT], k, i)
+		rcap = s.newValue2(subOp, types.Types[types.TINT], k, i)
 	}
 
 	if (i.Op == ssa.OpConst64 || i.Op == ssa.OpConst32) && i.AuxInt == 0 {
@@ -5503,15 +5504,15 @@ func (s *state) slice(v, i, j, k *ssa.Value, bounded bool) (p, l, c *ssa.Value)
 	//
 	// Where mask(x) is 0 if x==0 and -1 if x>0 and stride is the width
 	// of the element type.
-	stride := s.constInt(types.Types[TINT], ptr.Type.Elem().Width)
+	stride := s.constInt(types.Types[types.TINT], ptr.Type.Elem().Width)
 
 	// The delta is the number of bytes to offset ptr by.
-	delta := s.newValue2(mulOp, types.Types[TINT], i, stride)
+	delta := s.newValue2(mulOp, types.Types[types.TINT], i, stride)
 
 	// If we're slicing to the point where the capacity is zero,
 	// zero out the delta.
-	mask := s.newValue1(ssa.OpSlicemask, types.Types[TINT], rcap)
-	delta = s.newValue2(andOp, types.Types[TINT], delta, mask)
+	mask := s.newValue1(ssa.OpSlicemask, types.Types[types.TINT], rcap)
+	delta = s.newValue2(andOp, types.Types[types.TINT], delta, mask)
 
 	// Compute rptr = ptr + delta.
 	rptr := s.newValue2(ssa.OpAddPtr, ptr.Type, ptr, delta)
@@ -5544,15 +5545,15 @@ var u64_f32 = u642fcvtTab{
 	one:   (*state).constInt64,
 }
 
-func (s *state) uint64Tofloat64(n *Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) uint64Tofloat64(n *ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
 	return s.uint64Tofloat(&u64_f64, n, x, ft, tt)
 }
 
-func (s *state) uint64Tofloat32(n *Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) uint64Tofloat32(n *ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
 	return s.uint64Tofloat(&u64_f32, n, x, ft, tt)
 }
 
-func (s *state) uint64Tofloat(cvttab *u642fcvtTab, n *Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) uint64Tofloat(cvttab *u642fcvtTab, n *ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
 	// if x >= 0 {
 	//    result = (floatY) x
 	// } else {
@@ -5578,7 +5579,7 @@ func (s *state) uint64Tofloat(cvttab *u642fcvtTab, n *Node, x *ssa.Value, ft, tt
 	// equal to 10000000001; that rounds up, and the 1 cannot
 	// be lost else it would round down if the LSB of the
 	// candidate mantissa is 0.
-	cmp := s.newValue2(cvttab.leq, types.Types[TBOOL], s.zeroVal(ft), x)
+	cmp := s.newValue2(cvttab.leq, types.Types[types.TBOOL], s.zeroVal(ft), x)
 	b := s.endBlock()
 	b.Kind = ssa.BlockIf
 	b.SetControl(cmp)
@@ -5625,21 +5626,21 @@ var u32_f32 = u322fcvtTab{
 	cvtF2F: ssa.OpCvt64Fto32F,
 }
 
-func (s *state) uint32Tofloat64(n *Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) uint32Tofloat64(n *ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
 	return s.uint32Tofloat(&u32_f64, n, x, ft, tt)
 }
 
-func (s *state) uint32Tofloat32(n *Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) uint32Tofloat32(n *ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
 	return s.uint32Tofloat(&u32_f32, n, x, ft, tt)
 }
 
-func (s *state) uint32Tofloat(cvttab *u322fcvtTab, n *Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) uint32Tofloat(cvttab *u322fcvtTab, n *ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
 	// if x >= 0 {
 	// 	result = floatY(x)
 	// } else {
 	// 	result = floatY(float64(x) + (1<<32))
 	// }
-	cmp := s.newValue2(ssa.OpLeq32, types.Types[TBOOL], s.zeroVal(ft), x)
+	cmp := s.newValue2(ssa.OpLeq32, types.Types[types.TBOOL], s.zeroVal(ft), x)
 	b := s.endBlock()
 	b.Kind = ssa.BlockIf
 	b.SetControl(cmp)
@@ -5658,9 +5659,9 @@ func (s *state) uint32Tofloat(cvttab *u322fcvtTab, n *Node, x *ssa.Value, ft, tt
 
 	b.AddEdgeTo(bElse)
 	s.startBlock(bElse)
-	a1 := s.newValue1(ssa.OpCvt32to64F, types.Types[TFLOAT64], x)
-	twoToThe32 := s.constFloat64(types.Types[TFLOAT64], float64(1<<32))
-	a2 := s.newValue2(ssa.OpAdd64F, types.Types[TFLOAT64], a1, twoToThe32)
+	a1 := s.newValue1(ssa.OpCvt32to64F, types.Types[types.TFLOAT64], x)
+	twoToThe32 := s.constFloat64(types.Types[types.TFLOAT64], float64(1<<32))
+	a2 := s.newValue2(ssa.OpAdd64F, types.Types[types.TFLOAT64], a1, twoToThe32)
 	a3 := s.newValue1(cvttab.cvtF2F, tt, a2)
 
 	s.vars[n] = a3
@@ -5672,7 +5673,7 @@ func (s *state) uint32Tofloat(cvttab *u322fcvtTab, n *Node, x *ssa.Value, ft, tt
 }
 
 // referenceTypeBuiltin generates code for the len/cap builtins for maps and channels.
-func (s *state) referenceTypeBuiltin(n *Node, x *ssa.Value) *ssa.Value {
+func (s *state) referenceTypeBuiltin(n *ir.Node, x *ssa.Value) *ssa.Value {
 	if !n.Left.Type.IsMap() && !n.Left.Type.IsChan() {
 		s.Fatalf("node must be a map or a channel")
 	}
@@ -5685,8 +5686,8 @@ func (s *state) referenceTypeBuiltin(n *Node, x *ssa.Value) *ssa.Value {
 	//   return *(((*int)n)+1)
 	// }
 	lenType := n.Type
-	nilValue := s.constNil(types.Types[TUINTPTR])
-	cmp := s.newValue2(ssa.OpEqPtr, types.Types[TBOOL], x, nilValue)
+	nilValue := s.constNil(types.Types[types.TUINTPTR])
+	cmp := s.newValue2(ssa.OpEqPtr, types.Types[types.TBOOL], x, nilValue)
 	b := s.endBlock()
 	b.Kind = ssa.BlockIf
 	b.SetControl(cmp)
@@ -5706,10 +5707,10 @@ func (s *state) referenceTypeBuiltin(n *Node, x *ssa.Value) *ssa.Value {
 	b.AddEdgeTo(bElse)
 	s.startBlock(bElse)
 	switch n.Op {
-	case OLEN:
+	case ir.OLEN:
 		// length is stored in the first word for map/chan
 		s.vars[n] = s.load(lenType, x)
-	case OCAP:
+	case ir.OCAP:
 		// capacity is stored in the second word for chan
 		sw := s.newValue1I(ssa.OpOffPtr, lenType.PtrTo(), lenType.Width, x)
 		s.vars[n] = s.load(lenType, sw)
@@ -5770,22 +5771,22 @@ var f64_u32 = f2uCvtTab{
 	cutoff:     1 << 31,
 }
 
-func (s *state) float32ToUint64(n *Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) float32ToUint64(n *ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
 	return s.floatToUint(&f32_u64, n, x, ft, tt)
 }
-func (s *state) float64ToUint64(n *Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) float64ToUint64(n *ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
 	return s.floatToUint(&f64_u64, n, x, ft, tt)
 }
 
-func (s *state) float32ToUint32(n *Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) float32ToUint32(n *ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
 	return s.floatToUint(&f32_u32, n, x, ft, tt)
 }
 
-func (s *state) float64ToUint32(n *Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) float64ToUint32(n *ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
 	return s.floatToUint(&f64_u32, n, x, ft, tt)
 }
 
-func (s *state) floatToUint(cvttab *f2uCvtTab, n *Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) floatToUint(cvttab *f2uCvtTab, n *ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
 	// cutoff:=1<<(intY_Size-1)
 	// if x < floatX(cutoff) {
 	// 	result = uintY(x)
@@ -5795,7 +5796,7 @@ func (s *state) floatToUint(cvttab *f2uCvtTab, n *Node, x *ssa.Value, ft, tt *ty
 	// 	result = z | -(cutoff)
 	// }
 	cutoff := cvttab.floatValue(s, ft, float64(cvttab.cutoff))
-	cmp := s.newValue2(cvttab.ltf, types.Types[TBOOL], x, cutoff)
+	cmp := s.newValue2(cvttab.ltf, types.Types[types.TBOOL], x, cutoff)
 	b := s.endBlock()
 	b.Kind = ssa.BlockIf
 	b.SetControl(cmp)
@@ -5829,7 +5830,7 @@ func (s *state) floatToUint(cvttab *f2uCvtTab, n *Node, x *ssa.Value, ft, tt *ty
 // dottype generates SSA for a type assertion node.
 // commaok indicates whether to panic or return a bool.
 // If commaok is false, resok will be nil.
-func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
+func (s *state) dottype(n *ir.Node, commaok bool) (res, resok *ssa.Value) {
 	iface := s.expr(n.Left)   // input interface
 	target := s.expr(n.Right) // target type
 	byteptr := s.f.Config.Types.BytePtr
@@ -5845,7 +5846,7 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
 			// Get itab/type field from input.
 			itab := s.newValue1(ssa.OpITab, byteptr, iface)
 			// Conversion succeeds iff that field is not nil.
-			cond := s.newValue2(ssa.OpNeqPtr, types.Types[TBOOL], itab, s.constNil(byteptr))
+			cond := s.newValue2(ssa.OpNeqPtr, types.Types[types.TBOOL], itab, s.constNil(byteptr))
 
 			if n.Left.Type.IsEmptyInterface() && commaok {
 				// Converting empty interface to empty interface with ,ok is just a nil check.
@@ -5910,13 +5911,13 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
 		}
 		if n.Left.Type.IsEmptyInterface() {
 			if commaok {
-				call := s.rtcall(assertE2I2, true, []*types.Type{n.Type, types.Types[TBOOL]}, target, iface)
+				call := s.rtcall(assertE2I2, true, []*types.Type{n.Type, types.Types[types.TBOOL]}, target, iface)
 				return call[0], call[1]
 			}
 			return s.rtcall(assertE2I, true, []*types.Type{n.Type}, target, iface)[0], nil
 		}
 		if commaok {
-			call := s.rtcall(assertI2I2, true, []*types.Type{n.Type, types.Types[TBOOL]}, target, iface)
+			call := s.rtcall(assertI2I2, true, []*types.Type{n.Type, types.Types[types.TBOOL]}, target, iface)
 			return call[0], call[1]
 		}
 		return s.rtcall(assertI2I, true, []*types.Type{n.Type}, target, iface)[0], nil
@@ -5941,7 +5942,7 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
 		targetITab = s.expr(n.List.First())
 	}
 
-	var tmp *Node       // temporary for use with large types
+	var tmp *ir.Node    // temporary for use with large types
 	var addr *ssa.Value // address of tmp
 	if commaok && !canSSAType(n.Type) {
 		// unSSAable type, use temporary.
@@ -5951,7 +5952,7 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
 		addr = s.addr(tmp)
 	}
 
-	cond := s.newValue2(ssa.OpEqPtr, types.Types[TBOOL], itab, targetITab)
+	cond := s.newValue2(ssa.OpEqPtr, types.Types[types.TBOOL], itab, targetITab)
 	b := s.endBlock()
 	b.Kind = ssa.BlockIf
 	b.SetControl(cond)
@@ -6031,7 +6032,7 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
 }
 
 // variable returns the value of a variable at the current location.
-func (s *state) variable(name *Node, t *types.Type) *ssa.Value {
+func (s *state) variable(name *ir.Node, t *types.Type) *ssa.Value {
 	v := s.vars[name]
 	if v != nil {
 		return v
@@ -6057,8 +6058,8 @@ func (s *state) mem() *ssa.Value {
 	return s.variable(memVar, types.TypeMem)
 }
 
-func (s *state) addNamedValue(n *Node, v *ssa.Value) {
-	if n.Class() == Pxxx {
+func (s *state) addNamedValue(n *ir.Node, v *ssa.Value) {
+	if n.Class() == ir.Pxxx {
 		// Don't track our marker nodes (memVar etc.).
 		return
 	}
@@ -6066,12 +6067,12 @@ func (s *state) addNamedValue(n *Node, v *ssa.Value) {
 		// Don't track temporary variables.
 		return
 	}
-	if n.Class() == PPARAMOUT {
+	if n.Class() == ir.PPARAMOUT {
 		// Don't track named output values.  This prevents return values
 		// from being assigned too early. See #14591 and #14762. TODO: allow this.
 		return
 	}
-	if n.Class() == PAUTO && n.Xoffset != 0 {
+	if n.Class() == ir.PAUTO && n.Xoffset != 0 {
 		s.Fatalf("AUTO var with offset %v %d", n, n.Xoffset)
 	}
 	loc := ssa.LocalSlot{N: n, Type: n.Type, Off: 0}
@@ -6110,7 +6111,7 @@ type SSAGenState struct {
 	bstart []*obj.Prog
 
 	// Some architectures require a 64-bit temporary for FP-related register shuffling. Examples include PPC and Sparc V8.
-	ScratchFpMem *Node
+	ScratchFpMem *ir.Node
 
 	maxarg int64 // largest frame size for arguments to calls made by the function
 
@@ -6193,14 +6194,14 @@ func (s *SSAGenState) DebugFriendlySetPosFrom(v *ssa.Value) {
 }
 
 // byXoffset implements sort.Interface for []*Node using Xoffset as the ordering.
-type byXoffset []*Node
+type byXoffset []*ir.Node
 
 func (s byXoffset) Len() int           { return len(s) }
 func (s byXoffset) Less(i, j int) bool { return s[i].Xoffset < s[j].Xoffset }
 func (s byXoffset) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 
 func emitStackObjects(e *ssafn, pp *Progs) {
-	var vars []*Node
+	var vars []*ir.Node
 	for _, n := range e.curfn.Func.Dcl {
 		if livenessShouldTrack(n) && n.Name.Addrtaken() {
 			vars = append(vars, n)
@@ -6215,7 +6216,7 @@ func emitStackObjects(e *ssafn, pp *Progs) {
 
 	// Populate the stack object data.
 	// Format must match runtime/stack.go:stackObjectRecord.
-	x := e.curfn.Func.lsym.Func().StackObjects
+	x := e.curfn.Func.LSym.Func().StackObjects
 	off := 0
 	off = duintptr(x, off, uint64(len(vars)))
 	for _, v := range vars {
@@ -6252,7 +6253,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 	s.livenessMap = liveness(e, f, pp)
 	emitStackObjects(e, pp)
 
-	openDeferInfo := e.curfn.Func.lsym.Func().OpenCodedDeferInfo
+	openDeferInfo := e.curfn.Func.LSym.Func().OpenCodedDeferInfo
 	if openDeferInfo != nil {
 		// This function uses open-coded defers -- write out the funcdata
 		// info that we computed at the end of genssa.
@@ -6457,7 +6458,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 				// some of the inline marks.
 				// Use this instruction instead.
 				p.Pos = p.Pos.WithIsStmt() // promote position to a statement
-				pp.curfn.Func.lsym.Func().AddInlMark(p, inlMarks[m])
+				pp.curfn.Func.LSym.Func().AddInlMark(p, inlMarks[m])
 				// Make the inline mark a real nop, so it doesn't generate any code.
 				m.As = obj.ANOP
 				m.Pos = src.NoXPos
@@ -6469,7 +6470,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 		// Any unmatched inline marks now need to be added to the inlining tree (and will generate a nop instruction).
 		for _, p := range inlMarkList {
 			if p.As != obj.ANOP {
-				pp.curfn.Func.lsym.Func().AddInlMark(p, inlMarks[p])
+				pp.curfn.Func.LSym.Func().AddInlMark(p, inlMarks[p])
 			}
 		}
 	}
@@ -6489,7 +6490,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 				}
 				return bstart[b].Pc
 			case ssa.BlockEnd.ID:
-				return e.curfn.Func.lsym.Size
+				return e.curfn.Func.LSym.Size
 			default:
 				return valueToProgAfter[v].Pc
 			}
@@ -6591,7 +6592,7 @@ func defframe(s *SSAGenState, e *ssafn) {
 		if !n.Name.Needzero() {
 			continue
 		}
-		if n.Class() != PAUTO {
+		if n.Class() != ir.PAUTO {
 			e.Fatalf(n.Pos, "needzero class %d", n.Class())
 		}
 		if n.Type.Size()%int64(Widthptr) != 0 || n.Xoffset%int64(Widthptr) != 0 || n.Type.Size() == 0 {
@@ -6675,8 +6676,8 @@ func AddAux2(a *obj.Addr, v *ssa.Value, offset int64) {
 	case *obj.LSym:
 		a.Name = obj.NAME_EXTERN
 		a.Sym = n
-	case *Node:
-		if n.Class() == PPARAM || n.Class() == PPARAMOUT {
+	case *ir.Node:
+		if n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT {
 			a.Name = obj.NAME_PARAM
 			a.Sym = n.Orig.Sym.Linksym()
 			a.Offset += n.Xoffset
@@ -6702,17 +6703,17 @@ func (s *state) extendIndex(idx, len *ssa.Value, kind ssa.BoundsKind, bounded bo
 		// high word and branch to out-of-bounds failure if it is not 0.
 		var lo *ssa.Value
 		if idx.Type.IsSigned() {
-			lo = s.newValue1(ssa.OpInt64Lo, types.Types[TINT], idx)
+			lo = s.newValue1(ssa.OpInt64Lo, types.Types[types.TINT], idx)
 		} else {
-			lo = s.newValue1(ssa.OpInt64Lo, types.Types[TUINT], idx)
+			lo = s.newValue1(ssa.OpInt64Lo, types.Types[types.TUINT], idx)
 		}
 		if bounded || base.Flag.B != 0 {
 			return lo
 		}
 		bNext := s.f.NewBlock(ssa.BlockPlain)
 		bPanic := s.f.NewBlock(ssa.BlockExit)
-		hi := s.newValue1(ssa.OpInt64Hi, types.Types[TUINT32], idx)
-		cmp := s.newValue2(ssa.OpEq32, types.Types[TBOOL], hi, s.constInt32(types.Types[TUINT32], 0))
+		hi := s.newValue1(ssa.OpInt64Hi, types.Types[types.TUINT32], idx)
+		cmp := s.newValue2(ssa.OpEq32, types.Types[types.TBOOL], hi, s.constInt32(types.Types[types.TUINT32], 0))
 		if !idx.Type.IsSigned() {
 			switch kind {
 			case ssa.BoundsIndex:
@@ -6781,7 +6782,7 @@ func (s *state) extendIndex(idx, len *ssa.Value, kind ssa.BoundsKind, bounded bo
 			s.Fatalf("bad unsigned index extension %s", idx.Type)
 		}
 	}
-	return s.newValue1(op, types.Types[TINT], idx)
+	return s.newValue1(op, types.Types[types.TINT], idx)
 }
 
 // CheckLoweredPhi checks that regalloc and stackalloc correctly handled phi values.
@@ -6814,12 +6815,12 @@ func CheckLoweredGetClosurePtr(v *ssa.Value) {
 
 // AutoVar returns a *Node and int64 representing the auto variable and offset within it
 // where v should be spilled.
-func AutoVar(v *ssa.Value) (*Node, int64) {
+func AutoVar(v *ssa.Value) (*ir.Node, int64) {
 	loc := v.Block.Func.RegAlloc[v.ID].(ssa.LocalSlot)
 	if v.Type.Size() > loc.Type.Size() {
 		v.Fatalf("spill/restore type %s doesn't fit in slot type %s", v.Type, loc.Type)
 	}
-	return loc.N.(*Node), loc.Off
+	return loc.N.(*ir.Node), loc.Off
 }
 
 func AddrAuto(a *obj.Addr, v *ssa.Value) {
@@ -6828,7 +6829,7 @@ func AddrAuto(a *obj.Addr, v *ssa.Value) {
 	a.Sym = n.Sym.Linksym()
 	a.Reg = int16(thearch.REGSP)
 	a.Offset = n.Xoffset + off
-	if n.Class() == PPARAM || n.Class() == PPARAMOUT {
+	if n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT {
 		a.Name = obj.NAME_PARAM
 	} else {
 		a.Name = obj.NAME_AUTO
@@ -6925,7 +6926,7 @@ func (s *SSAGenState) UseArgs(n int64) {
 }
 
 // fieldIdx finds the index of the field referred to by the ODOT node n.
-func fieldIdx(n *Node) int {
+func fieldIdx(n *ir.Node) int {
 	t := n.Left.Type
 	f := n.Sym
 	if !t.IsStruct() {
@@ -6952,9 +6953,9 @@ func fieldIdx(n *Node) int {
 // ssafn holds frontend information about a function that the backend is processing.
 // It also exports a bunch of compiler services for the ssa backend.
 type ssafn struct {
-	curfn        *Node
+	curfn        *ir.Node
 	strings      map[string]*obj.LSym // map from constant string to data symbols
-	scratchFpMem *Node                // temp for floating point register / memory moves on some architectures
+	scratchFpMem *ir.Node             // temp for floating point register / memory moves on some architectures
 	stksize      int64                // stack size for current frame
 	stkptrsize   int64                // prefix of stack containing pointers
 	log          bool                 // print ssa debug to the stdout
@@ -6980,8 +6981,8 @@ func (e *ssafn) Auto(pos src.XPos, t *types.Type) ssa.GCNode {
 }
 
 func (e *ssafn) SplitString(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot) {
-	ptrType := types.NewPtr(types.Types[TUINT8])
-	lenType := types.Types[TINT]
+	ptrType := types.NewPtr(types.Types[types.TUINT8])
+	lenType := types.Types[types.TINT]
 	// Split this string up into two separate variables.
 	p := e.SplitSlot(&name, ".ptr", 0, ptrType)
 	l := e.SplitSlot(&name, ".len", ptrType.Size(), lenType)
@@ -6989,9 +6990,9 @@ func (e *ssafn) SplitString(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot) {
 }
 
 func (e *ssafn) SplitInterface(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot) {
-	n := name.N.(*Node)
-	u := types.Types[TUINTPTR]
-	t := types.NewPtr(types.Types[TUINT8])
+	n := name.N.(*ir.Node)
+	u := types.Types[types.TUINTPTR]
+	t := types.NewPtr(types.Types[types.TUINT8])
 	// Split this interface up into two separate variables.
 	f := ".itab"
 	if n.Type.IsEmptyInterface() {
@@ -7004,7 +7005,7 @@ func (e *ssafn) SplitInterface(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot
 
 func (e *ssafn) SplitSlice(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot, ssa.LocalSlot) {
 	ptrType := types.NewPtr(name.Type.Elem())
-	lenType := types.Types[TINT]
+	lenType := types.Types[types.TINT]
 	p := e.SplitSlot(&name, ".ptr", 0, ptrType)
 	l := e.SplitSlot(&name, ".len", ptrType.Size(), lenType)
 	c := e.SplitSlot(&name, ".cap", ptrType.Size()+lenType.Size(), lenType)
@@ -7015,9 +7016,9 @@ func (e *ssafn) SplitComplex(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot)
 	s := name.Type.Size() / 2
 	var t *types.Type
 	if s == 8 {
-		t = types.Types[TFLOAT64]
+		t = types.Types[types.TFLOAT64]
 	} else {
-		t = types.Types[TFLOAT32]
+		t = types.Types[types.TFLOAT32]
 	}
 	r := e.SplitSlot(&name, ".real", 0, t)
 	i := e.SplitSlot(&name, ".imag", t.Size(), t)
@@ -7027,14 +7028,14 @@ func (e *ssafn) SplitComplex(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot)
 func (e *ssafn) SplitInt64(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot) {
 	var t *types.Type
 	if name.Type.IsSigned() {
-		t = types.Types[TINT32]
+		t = types.Types[types.TINT32]
 	} else {
-		t = types.Types[TUINT32]
+		t = types.Types[types.TUINT32]
 	}
 	if thearch.LinkArch.ByteOrder == binary.BigEndian {
-		return e.SplitSlot(&name, ".hi", 0, t), e.SplitSlot(&name, ".lo", t.Size(), types.Types[TUINT32])
+		return e.SplitSlot(&name, ".hi", 0, t), e.SplitSlot(&name, ".lo", t.Size(), types.Types[types.TUINT32])
 	}
-	return e.SplitSlot(&name, ".hi", t.Size(), t), e.SplitSlot(&name, ".lo", 0, types.Types[TUINT32])
+	return e.SplitSlot(&name, ".hi", t.Size(), t), e.SplitSlot(&name, ".lo", 0, types.Types[types.TUINT32])
 }
 
 func (e *ssafn) SplitStruct(name ssa.LocalSlot, i int) ssa.LocalSlot {
@@ -7046,7 +7047,7 @@ func (e *ssafn) SplitStruct(name ssa.LocalSlot, i int) ssa.LocalSlot {
 }
 
 func (e *ssafn) SplitArray(name ssa.LocalSlot) ssa.LocalSlot {
-	n := name.N.(*Node)
+	n := name.N.(*ir.Node)
 	at := name.Type
 	if at.NumElem() != 1 {
 		e.Fatalf(n.Pos, "bad array size")
@@ -7061,19 +7062,19 @@ func (e *ssafn) DerefItab(it *obj.LSym, offset int64) *obj.LSym {
 
 // SplitSlot returns a slot representing the data of parent starting at offset.
 func (e *ssafn) SplitSlot(parent *ssa.LocalSlot, suffix string, offset int64, t *types.Type) ssa.LocalSlot {
-	node := parent.N.(*Node)
+	node := parent.N.(*ir.Node)
 
-	if node.Class() != PAUTO || node.Name.Addrtaken() {
+	if node.Class() != ir.PAUTO || node.Name.Addrtaken() {
 		// addressed things and non-autos retain their parents (i.e., cannot truly be split)
 		return ssa.LocalSlot{N: node, Type: t, Off: parent.Off + offset}
 	}
 
-	s := &types.Sym{Name: node.Sym.Name + suffix, Pkg: localpkg}
-	n := newnamel(parent.N.(*Node).Pos, s)
-	s.Def = asTypesNode(n)
-	asNode(s.Def).Name.SetUsed(true)
+	s := &types.Sym{Name: node.Sym.Name + suffix, Pkg: ir.LocalPkg}
+	n := ir.NewNameAt(parent.N.(*ir.Node).Pos, s)
+	s.Def = ir.AsTypesNode(n)
+	ir.AsNode(s.Def).Name.SetUsed(true)
 	n.Type = t
-	n.SetClass(PAUTO)
+	n.SetClass(ir.PAUTO)
 	n.Esc = EscNever
 	n.Name.Curfn = e.curfn
 	e.curfn.Func.Dcl = append(e.curfn.Func.Dcl, n)
@@ -7103,7 +7104,7 @@ func (e *ssafn) Log() bool {
 // Fatal reports a compiler error and exits.
 func (e *ssafn) Fatalf(pos src.XPos, msg string, args ...interface{}) {
 	base.Pos = pos
-	nargs := append([]interface{}{e.curfn.funcname()}, args...)
+	nargs := append([]interface{}{ir.FuncName(e.curfn)}, args...)
 	base.Fatalf("'%s': "+msg, nargs...)
 }
 
@@ -7139,35 +7140,18 @@ func (e *ssafn) Syslook(name string) *obj.LSym {
 }
 
 func (e *ssafn) SetWBPos(pos src.XPos) {
-	e.curfn.Func.setWBPos(pos)
+	e.curfn.Func.SetWBPos(pos)
 }
 
 func (e *ssafn) MyImportPath() string {
 	return base.Ctxt.Pkgpath
 }
 
-func (n *Node) Typ() *types.Type {
-	return n.Type
-}
-func (n *Node) StorageClass() ssa.StorageClass {
-	switch n.Class() {
-	case PPARAM:
-		return ssa.ClassParam
-	case PPARAMOUT:
-		return ssa.ClassParamOut
-	case PAUTO:
-		return ssa.ClassAuto
-	default:
-		base.Fatalf("untranslatable storage class for %v: %s", n, n.Class())
-		return 0
-	}
-}
-
-func clobberBase(n *Node) *Node {
-	if n.Op == ODOT && n.Left.Type.NumFields() == 1 {
+func clobberBase(n *ir.Node) *ir.Node {
+	if n.Op == ir.ODOT && n.Left.Type.NumFields() == 1 {
 		return clobberBase(n.Left)
 	}
-	if n.Op == OINDEX && n.Left.Type.IsArray() && n.Left.Type.NumElem() == 1 {
+	if n.Op == ir.OINDEX && n.Left.Type.IsArray() && n.Left.Type.NumElem() == 1 {
 		return clobberBase(n.Left)
 	}
 	return n
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 00402a1bee..46f4153fe1 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"crypto/md5"
@@ -39,11 +40,11 @@ var (
 // It's primarily used to distinguish references to named objects,
 // whose Pos will point back to their declaration position rather than
 // their usage position.
-func hasUniquePos(n *Node) bool {
+func hasUniquePos(n *ir.Node) bool {
 	switch n.Op {
-	case ONAME, OPACK:
+	case ir.ONAME, ir.OPACK:
 		return false
-	case OLITERAL, ONIL, OTYPE:
+	case ir.OLITERAL, ir.ONIL, ir.OTYPE:
 		if n.Sym != nil {
 			return false
 		}
@@ -59,7 +60,7 @@ func hasUniquePos(n *Node) bool {
 	return true
 }
 
-func setlineno(n *Node) src.XPos {
+func setlineno(n *ir.Node) src.XPos {
 	lno := base.Pos
 	if n != nil && hasUniquePos(n) {
 		base.Pos = n.Pos
@@ -68,7 +69,7 @@ func setlineno(n *Node) src.XPos {
 }
 
 func lookup(name string) *types.Sym {
-	return localpkg.Lookup(name)
+	return ir.LocalPkg.Lookup(name)
 }
 
 // lookupN looks up the symbol starting with prefix and ending with
@@ -77,7 +78,7 @@ func lookupN(prefix string, n int) *types.Sym {
 	var buf [20]byte // plenty long enough for all current users
 	copy(buf[:], prefix)
 	b := strconv.AppendInt(buf[:len(prefix)], int64(n), 10)
-	return localpkg.LookupBytes(b)
+	return ir.LocalPkg.LookupBytes(b)
 }
 
 // autolabel generates a new Name node for use with
@@ -101,7 +102,7 @@ func autolabel(prefix string) *types.Sym {
 
 // find all the exported symbols in package opkg
 // and make them available in the current package
-func importdot(opkg *types.Pkg, pack *Node) {
+func importdot(opkg *types.Pkg, pack *ir.Node) {
 	n := 0
 	for _, s := range opkg.Syms {
 		if s.Def == nil {
@@ -119,11 +120,11 @@ func importdot(opkg *types.Pkg, pack *Node) {
 
 		s1.Def = s.Def
 		s1.Block = s.Block
-		if asNode(s1.Def).Name == nil {
-			Dump("s1def", asNode(s1.Def))
+		if ir.AsNode(s1.Def).Name == nil {
+			ir.Dump("s1def", ir.AsNode(s1.Def))
 			base.Fatalf("missing Name")
 		}
-		asNode(s1.Def).Name.Pack = pack
+		ir.AsNode(s1.Def).Name.Pack = pack
 		s1.Origpkg = opkg
 		n++
 	}
@@ -134,118 +135,27 @@ func importdot(opkg *types.Pkg, pack *Node) {
 	}
 }
 
-func nod(op Op, nleft, nright *Node) *Node {
-	return nodl(base.Pos, op, nleft, nright)
-}
-
-func nodl(pos src.XPos, op Op, nleft, nright *Node) *Node {
-	var n *Node
-	switch op {
-	case ODCLFUNC:
-		var x struct {
-			n Node
-			f Func
-		}
-		n = &x.n
-		n.Func = &x.f
-		n.Func.Decl = n
-	case ONAME:
-		base.Fatalf("use newname instead")
-	case OLABEL, OPACK:
-		var x struct {
-			n Node
-			m Name
-		}
-		n = &x.n
-		n.Name = &x.m
-	default:
-		n = new(Node)
-	}
-	n.Op = op
-	n.Left = nleft
-	n.Right = nright
-	n.Pos = pos
-	n.Xoffset = BADWIDTH
-	n.Orig = n
-	return n
-}
-
 // newname returns a new ONAME Node associated with symbol s.
-func newname(s *types.Sym) *Node {
-	n := newnamel(base.Pos, s)
+func NewName(s *types.Sym) *ir.Node {
+	n := ir.NewNameAt(base.Pos, s)
 	n.Name.Curfn = Curfn
 	return n
 }
 
-// newnamel returns a new ONAME Node associated with symbol s at position pos.
-// The caller is responsible for setting n.Name.Curfn.
-func newnamel(pos src.XPos, s *types.Sym) *Node {
-	if s == nil {
-		base.Fatalf("newnamel nil")
-	}
-
-	var x struct {
-		n Node
-		m Name
-		p Param
-	}
-	n := &x.n
-	n.Name = &x.m
-	n.Name.Param = &x.p
-
-	n.Op = ONAME
-	n.Pos = pos
-	n.Orig = n
-
-	n.Sym = s
-	return n
-}
-
 // nodSym makes a Node with Op op and with the Left field set to left
 // and the Sym field set to sym. This is for ODOT and friends.
-func nodSym(op Op, left *Node, sym *types.Sym) *Node {
+func nodSym(op ir.Op, left *ir.Node, sym *types.Sym) *ir.Node {
 	return nodlSym(base.Pos, op, left, sym)
 }
 
 // nodlSym makes a Node with position Pos, with Op op, and with the Left field set to left
 // and the Sym field set to sym. This is for ODOT and friends.
-func nodlSym(pos src.XPos, op Op, left *Node, sym *types.Sym) *Node {
-	n := nodl(pos, op, left, nil)
+func nodlSym(pos src.XPos, op ir.Op, left *ir.Node, sym *types.Sym) *ir.Node {
+	n := ir.NodAt(pos, op, left, nil)
 	n.Sym = sym
 	return n
 }
 
-// rawcopy returns a shallow copy of n.
-// Note: copy or sepcopy (rather than rawcopy) is usually the
-//       correct choice (see comment with Node.copy, below).
-func (n *Node) rawcopy() *Node {
-	copy := *n
-	return &copy
-}
-
-// sepcopy returns a separate shallow copy of n, with the copy's
-// Orig pointing to itself.
-func (n *Node) sepcopy() *Node {
-	copy := *n
-	copy.Orig = &copy
-	return &copy
-}
-
-// copy returns shallow copy of n and adjusts the copy's Orig if
-// necessary: In general, if n.Orig points to itself, the copy's
-// Orig should point to itself as well. Otherwise, if n is modified,
-// the copy's Orig node appears modified, too, and then doesn't
-// represent the original node anymore.
-// (This caused the wrong complit Op to be used when printing error
-// messages; see issues #26855, #27765).
-func (n *Node) copy() *Node {
-	copy := *n
-	if n.Orig == n {
-		copy.Orig = &copy
-	}
-	return &copy
-}
-
 // methcmp sorts methods by symbol.
 type methcmp []*types.Field
 
@@ -253,67 +163,60 @@ func (x methcmp) Len() int           { return len(x) }
 func (x methcmp) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
 func (x methcmp) Less(i, j int) bool { return x[i].Sym.Less(x[j].Sym) }
 
-func nodintconst(v int64) *Node {
-	return nodlit(constant.MakeInt64(v))
+func nodintconst(v int64) *ir.Node {
+	return ir.NewLiteral(constant.MakeInt64(v))
 }
 
-func nodnil() *Node {
-	n := nod(ONIL, nil, nil)
-	n.Type = types.Types[TNIL]
+func nodnil() *ir.Node {
+	n := ir.Nod(ir.ONIL, nil, nil)
+	n.Type = types.Types[types.TNIL]
 	return n
 }
 
-func nodbool(b bool) *Node {
-	return nodlit(constant.MakeBool(b))
+func nodbool(b bool) *ir.Node {
+	return ir.NewLiteral(constant.MakeBool(b))
 }
 
-func nodstr(s string) *Node {
-	return nodlit(constant.MakeString(s))
+func nodstr(s string) *ir.Node {
+	return ir.NewLiteral(constant.MakeString(s))
 }
 
 // treecopy recursively copies n, with the exception of
 // ONAME, OLITERAL, OTYPE, and ONONAME leaves.
 // If pos.IsKnown(), it sets the source position of newly
 // allocated nodes to pos.
-func treecopy(n *Node, pos src.XPos) *Node {
+func treecopy(n *ir.Node, pos src.XPos) *ir.Node {
 	if n == nil {
 		return nil
 	}
 
 	switch n.Op {
 	default:
-		m := n.sepcopy()
+		m := ir.SepCopy(n)
 		m.Left = treecopy(n.Left, pos)
 		m.Right = treecopy(n.Right, pos)
 		m.List.Set(listtreecopy(n.List.Slice(), pos))
 		if pos.IsKnown() {
 			m.Pos = pos
 		}
-		if m.Name != nil && n.Op != ODCLFIELD {
-			Dump("treecopy", n)
+		if m.Name != nil && n.Op != ir.ODCLFIELD {
+			ir.Dump("treecopy", n)
 			base.Fatalf("treecopy Name")
 		}
 		return m
 
-	case OPACK:
+	case ir.OPACK:
 		// OPACK nodes are never valid in const value declarations,
 		// but allow them like any other declared symbol to avoid
 		// crashing (golang.org/issue/11361).
 		fallthrough
 
-	case ONAME, ONONAME, OLITERAL, ONIL, OTYPE:
+	case ir.ONAME, ir.ONONAME, ir.OLITERAL, ir.ONIL, ir.OTYPE:
 		return n
 
 	}
 }
 
-// isNil reports whether n represents the universal untyped zero value "nil".
-func (n *Node) isNil() bool {
-	// Check n.Orig because constant propagation may produce typed nil constants,
-	// which don't exist in the Go spec.
-	return n.Orig.Op == ONIL
-}
-
 func isptrto(t *types.Type, et types.EType) bool {
 	if t == nil {
 		return false
@@ -331,13 +234,6 @@ func isptrto(t *types.Type, et types.EType) bool {
 	return true
 }
 
-func (n *Node) isBlank() bool {
-	if n == nil {
-		return false
-	}
-	return n.Sym.IsBlank()
-}
-
 // methtype returns the underlying type, if any,
 // that owns methods with receiver parameter t.
 // The result is either a named type or an anonymous struct.
@@ -367,7 +263,7 @@ func methtype(t *types.Type) *types.Type {
 		return t
 	}
 	switch t.Etype {
-	case TARRAY, TCHAN, TFUNC, TMAP, TSLICE, TSTRING, TSTRUCT:
+	case types.TARRAY, types.TCHAN, types.TFUNC, types.TMAP, types.TSLICE, types.TSTRING, types.TSTRUCT:
 		return t
 	}
 	return nil
@@ -377,17 +273,17 @@ func methtype(t *types.Type) *types.Type {
 // If so, return op code to use in conversion.
 // If not, return OXXX. In this case, the string return parameter may
 // hold a reason why. In all other cases, it'll be the empty string.
-func assignop(src, dst *types.Type) (Op, string) {
+func assignop(src, dst *types.Type) (ir.Op, string) {
 	if src == dst {
-		return OCONVNOP, ""
+		return ir.OCONVNOP, ""
 	}
-	if src == nil || dst == nil || src.Etype == TFORW || dst.Etype == TFORW || src.Orig == nil || dst.Orig == nil {
-		return OXXX, ""
+	if src == nil || dst == nil || src.Etype == types.TFORW || dst.Etype == types.TFORW || src.Orig == nil || dst.Orig == nil {
+		return ir.OXXX, ""
 	}
 
 	// 1. src type is identical to dst.
 	if types.Identical(src, dst) {
-		return OCONVNOP, ""
+		return ir.OCONVNOP, ""
 	}
 
 	// 2. src and dst have identical underlying types
@@ -401,31 +297,31 @@ func assignop(src, dst *types.Type) (Op, string) {
 		if src.IsEmptyInterface() {
 			// Conversion between two empty interfaces
 			// requires no code.
-			return OCONVNOP, ""
+			return ir.OCONVNOP, ""
 		}
 		if (src.Sym == nil || dst.Sym == nil) && !src.IsInterface() {
 			// Conversion between two types, at least one unnamed,
 			// needs no conversion. The exception is nonempty interfaces
 			// which need to have their itab updated.
-			return OCONVNOP, ""
+			return ir.OCONVNOP, ""
 		}
 	}
 
 	// 3. dst is an interface type and src implements dst.
-	if dst.IsInterface() && src.Etype != TNIL {
+	if dst.IsInterface() && src.Etype != types.TNIL {
 		var missing, have *types.Field
 		var ptr int
 		if implements(src, dst, &missing, &have, &ptr) {
-			return OCONVIFACE, ""
+			return ir.OCONVIFACE, ""
 		}
 
 		// we'll have complained about this method anyway, suppress spurious messages.
 		if have != nil && have.Sym == missing.Sym && (have.Type.Broke() || missing.Type.Broke()) {
-			return OCONVIFACE, ""
+			return ir.OCONVIFACE, ""
 		}
 
 		var why string
-		if isptrto(src, TINTER) {
+		if isptrto(src, types.TINTER) {
 			why = fmt.Sprintf(":\n\t%v is pointer to interface, not interface", src)
 		} else if have != nil && have.Sym == missing.Sym && have.Nointerface() {
 			why = fmt.Sprintf(":\n\t%v does not implement %v (%v method is marked 'nointerface')", src, dst, missing.Sym)
@@ -441,22 +337,22 @@ func assignop(src, dst *types.Type) (Op, string) {
 			why = fmt.Sprintf(":\n\t%v does not implement %v (missing %v method)", src, dst, missing.Sym)
 		}
 
-		return OXXX, why
+		return ir.OXXX, why
 	}
 
-	if isptrto(dst, TINTER) {
+	if isptrto(dst, types.TINTER) {
 		why := fmt.Sprintf(":\n\t%v is pointer to interface, not interface", dst)
-		return OXXX, why
+		return ir.OXXX, why
 	}
 
-	if src.IsInterface() && dst.Etype != TBLANK {
+	if src.IsInterface() && dst.Etype != types.TBLANK {
 		var missing, have *types.Field
 		var ptr int
 		var why string
 		if implements(dst, src, &missing, &have, &ptr) {
 			why = ": need type assertion"
 		}
-		return OXXX, why
+		return ir.OXXX, why
 	}
 
 	// 4. src is a bidirectional channel value, dst is a channel type,
@@ -464,31 +360,31 @@ func assignop(src, dst *types.Type) (Op, string) {
 	// either src or dst is not a named type.
 	if src.IsChan() && src.ChanDir() == types.Cboth && dst.IsChan() {
 		if types.Identical(src.Elem(), dst.Elem()) && (src.Sym == nil || dst.Sym == nil) {
-			return OCONVNOP, ""
+			return ir.OCONVNOP, ""
 		}
 	}
 
 	// 5. src is the predeclared identifier nil and dst is a nillable type.
-	if src.Etype == TNIL {
+	if src.Etype == types.TNIL {
 		switch dst.Etype {
-		case TPTR,
-			TFUNC,
-			TMAP,
-			TCHAN,
-			TINTER,
-			TSLICE:
-			return OCONVNOP, ""
+		case types.TPTR,
+			types.TFUNC,
+			types.TMAP,
+			types.TCHAN,
+			types.TINTER,
+			types.TSLICE:
+			return ir.OCONVNOP, ""
 		}
 	}
 
 	// 6. rule about untyped constants - already converted by defaultlit.
 
 	// 7. Any typed value can be assigned to the blank identifier.
-	if dst.Etype == TBLANK {
-		return OCONVNOP, ""
+	if dst.Etype == types.TBLANK {
+		return ir.OCONVNOP, ""
 	}
 
-	return OXXX, ""
+	return ir.OXXX, ""
 }
 
 // Can we convert a value of type src to a value of type dst?
@@ -496,12 +392,12 @@ func assignop(src, dst *types.Type) (Op, string) {
 // If not, return OXXX. In this case, the string return parameter may
 // hold a reason why. In all other cases, it'll be the empty string.
 // srcConstant indicates whether the value of type src is a constant.
-func convertop(srcConstant bool, src, dst *types.Type) (Op, string) {
+func convertop(srcConstant bool, src, dst *types.Type) (ir.Op, string) {
 	if src == dst {
-		return OCONVNOP, ""
+		return ir.OCONVNOP, ""
 	}
 	if src == nil || dst == nil {
-		return OXXX, ""
+		return ir.OXXX, ""
 	}
 
 	// Conversions from regular to go:notinheap are not allowed
@@ -510,17 +406,17 @@ func convertop(srcConstant bool, src, dst *types.Type) (Op, string) {
 	// (a) Disallow (*T) to (*U) where T is go:notinheap but U isn't.
 	if src.IsPtr() && dst.IsPtr() && dst.Elem().NotInHeap() && !src.Elem().NotInHeap() {
 		why := fmt.Sprintf(":\n\t%v is incomplete (or unallocatable), but %v is not", dst.Elem(), src.Elem())
-		return OXXX, why
+		return ir.OXXX, why
 	}
 	// (b) Disallow string to []T where T is go:notinheap.
 	if src.IsString() && dst.IsSlice() && dst.Elem().NotInHeap() && (dst.Elem().Etype == types.Bytetype.Etype || dst.Elem().Etype == types.Runetype.Etype) {
 		why := fmt.Sprintf(":\n\t%v is incomplete (or unallocatable)", dst.Elem())
-		return OXXX, why
+		return ir.OXXX, why
 	}
 
 	// 1. src can be assigned to dst.
 	op, why := assignop(src, dst)
-	if op != OXXX {
+	if op != ir.OXXX {
 		return op, why
 	}
 
@@ -529,57 +425,57 @@ func convertop(srcConstant bool, src, dst *types.Type) (Op, string) {
 	// with the good message from assignop.
 	// Otherwise clear the error.
 	if src.IsInterface() || dst.IsInterface() {
-		return OXXX, why
+		return ir.OXXX, why
 	}
 
 	// 2. Ignoring struct tags, src and dst have identical underlying types.
 	if types.IdenticalIgnoreTags(src.Orig, dst.Orig) {
-		return OCONVNOP, ""
+		return ir.OCONVNOP, ""
 	}
 
 	// 3. src and dst are unnamed pointer types and, ignoring struct tags,
 	// their base types have identical underlying types.
 	if src.IsPtr() && dst.IsPtr() && src.Sym == nil && dst.Sym == nil {
 		if types.IdenticalIgnoreTags(src.Elem().Orig, dst.Elem().Orig) {
-			return OCONVNOP, ""
+			return ir.OCONVNOP, ""
 		}
 	}
 
 	// 4. src and dst are both integer or floating point types.
 	if (src.IsInteger() || src.IsFloat()) && (dst.IsInteger() || dst.IsFloat()) {
 		if simtype[src.Etype] == simtype[dst.Etype] {
-			return OCONVNOP, ""
+			return ir.OCONVNOP, ""
 		}
-		return OCONV, ""
+		return ir.OCONV, ""
 	}
 
 	// 5. src and dst are both complex types.
 	if src.IsComplex() && dst.IsComplex() {
 		if simtype[src.Etype] == simtype[dst.Etype] {
-			return OCONVNOP, ""
+			return ir.OCONVNOP, ""
 		}
-		return OCONV, ""
+		return ir.OCONV, ""
 	}
 
 	// Special case for constant conversions: any numeric
 	// conversion is potentially okay. We'll validate further
 	// within evconst. See #38117.
 	if srcConstant && (src.IsInteger() || src.IsFloat() || src.IsComplex()) && (dst.IsInteger() || dst.IsFloat() || dst.IsComplex()) {
-		return OCONV, ""
+		return ir.OCONV, ""
 	}
 
 	// 6. src is an integer or has type []byte or []rune
 	// and dst is a string type.
 	if src.IsInteger() && dst.IsString() {
-		return ORUNESTR, ""
+		return ir.ORUNESTR, ""
 	}
 
 	if src.IsSlice() && dst.IsString() {
 		if src.Elem().Etype == types.Bytetype.Etype {
-			return OBYTES2STR, ""
+			return ir.OBYTES2STR, ""
 		}
 		if src.Elem().Etype == types.Runetype.Etype {
-			return ORUNES2STR, ""
+			return ir.ORUNES2STR, ""
 		}
 	}
 
@@ -587,45 +483,45 @@ func convertop(srcConstant bool, src, dst *types.Type) (Op, string) {
 	// String to slice.
 	if src.IsString() && dst.IsSlice() {
 		if dst.Elem().Etype == types.Bytetype.Etype {
-			return OSTR2BYTES, ""
+			return ir.OSTR2BYTES, ""
 		}
 		if dst.Elem().Etype == types.Runetype.Etype {
-			return OSTR2RUNES, ""
+			return ir.OSTR2RUNES, ""
 		}
 	}
 
 	// 8. src is a pointer or uintptr and dst is unsafe.Pointer.
 	if (src.IsPtr() || src.IsUintptr()) && dst.IsUnsafePtr() {
-		return OCONVNOP, ""
+		return ir.OCONVNOP, ""
 	}
 
 	// 9. src is unsafe.Pointer and dst is a pointer or uintptr.
 	if src.IsUnsafePtr() && (dst.IsPtr() || dst.IsUintptr()) {
-		return OCONVNOP, ""
+		return ir.OCONVNOP, ""
 	}
 
 	// src is map and dst is a pointer to corresponding hmap.
 	// This rule is needed for the implementation detail that
 	// go gc maps are implemented as a pointer to a hmap struct.
-	if src.Etype == TMAP && dst.IsPtr() &&
+	if src.Etype == types.TMAP && dst.IsPtr() &&
 		src.MapType().Hmap == dst.Elem() {
-		return OCONVNOP, ""
+		return ir.OCONVNOP, ""
 	}
 
-	return OXXX, ""
+	return ir.OXXX, ""
 }
 
-func assignconv(n *Node, t *types.Type, context string) *Node {
+func assignconv(n *ir.Node, t *types.Type, context string) *ir.Node {
 	return assignconvfn(n, t, func() string { return context })
 }
 
 // Convert node n for assignment to type t.
-func assignconvfn(n *Node, t *types.Type, context func() string) *Node {
+func assignconvfn(n *ir.Node, t *types.Type, context func() string) *ir.Node {
 	if n == nil || n.Type == nil || n.Type.Broke() {
 		return n
 	}
 
-	if t.Etype == TBLANK && n.Type.Etype == TNIL {
+	if t.Etype == types.TBLANK && n.Type.Etype == types.TNIL {
 		base.Errorf("use of untyped nil")
 	}
 
@@ -633,16 +529,16 @@ func assignconvfn(n *Node, t *types.Type, context func() string) *Node {
 	if n.Type == nil {
 		return n
 	}
-	if t.Etype == TBLANK {
+	if t.Etype == types.TBLANK {
 		return n
 	}
 
 	// Convert ideal bool from comparison to plain bool
 	// if the next step is non-bool (like interface{}).
 	if n.Type == types.UntypedBool && !t.IsBoolean() {
-		if n.Op == ONAME || n.Op == OLITERAL {
-			r := nod(OCONVNOP, n, nil)
-			r.Type = types.Types[TBOOL]
+		if n.Op == ir.ONAME || n.Op == ir.OLITERAL {
+			r := ir.Nod(ir.OCONVNOP, n, nil)
+			r.Type = types.Types[types.TBOOL]
 			r.SetTypecheck(1)
 			r.SetImplicit(true)
 			n = r
@@ -654,12 +550,12 @@ func assignconvfn(n *Node, t *types.Type, context func() string) *Node {
 	}
 
 	op, why := assignop(n.Type, t)
-	if op == OXXX {
+	if op == ir.OXXX {
 		base.Errorf("cannot use %L as type %v in %s%s", n, t, context(), why)
-		op = OCONV
+		op = ir.OCONV
 	}
 
-	r := nod(op, n, nil)
+	r := ir.Nod(op, n, nil)
 	r.Type = t
 	r.SetTypecheck(1)
 	r.SetImplicit(true)
@@ -667,103 +563,29 @@ func assignconvfn(n *Node, t *types.Type, context func() string) *Node {
 	return r
 }
 
-// IsMethod reports whether n is a method.
-// n must be a function or a method.
-func (n *Node) IsMethod() bool {
-	return n.Type.Recv() != nil
-}
-
-// SliceBounds returns n's slice bounds: low, high, and max in expr[low:high:max].
-// n must be a slice expression. max is nil if n is a simple slice expression.
-func (n *Node) SliceBounds() (low, high, max *Node) {
-	if n.List.Len() == 0 {
-		return nil, nil, nil
-	}
-
-	switch n.Op {
-	case OSLICE, OSLICEARR, OSLICESTR:
-		s := n.List.Slice()
-		return s[0], s[1], nil
-	case OSLICE3, OSLICE3ARR:
-		s := n.List.Slice()
-		return s[0], s[1], s[2]
-	}
-	base.Fatalf("SliceBounds op %v: %v", n.Op, n)
-	return nil, nil, nil
-}
-
-// SetSliceBounds sets n's slice bounds, where n is a slice expression.
-// n must be a slice expression. If max is non-nil, n must be a full slice expression.
-func (n *Node) SetSliceBounds(low, high, max *Node) {
-	switch n.Op {
-	case OSLICE, OSLICEARR, OSLICESTR:
-		if max != nil {
-			base.Fatalf("SetSliceBounds %v given three bounds", n.Op)
-		}
-		s := n.List.Slice()
-		if s == nil {
-			if low == nil && high == nil {
-				return
-			}
-			n.List.Set2(low, high)
-			return
-		}
-		s[0] = low
-		s[1] = high
-		return
-	case OSLICE3, OSLICE3ARR:
-		s := n.List.Slice()
-		if s == nil {
-			if low == nil && high == nil && max == nil {
-				return
-			}
-			n.List.Set3(low, high, max)
-			return
-		}
-		s[0] = low
-		s[1] = high
-		s[2] = max
-		return
-	}
-	base.Fatalf("SetSliceBounds op %v: %v", n.Op, n)
-}
-
-// IsSlice3 reports whether o is a slice3 op (OSLICE3, OSLICE3ARR).
-// o must be a slicing op.
-func (o Op) IsSlice3() bool {
-	switch o {
-	case OSLICE, OSLICEARR, OSLICESTR:
-		return false
-	case OSLICE3, OSLICE3ARR:
-		return true
-	}
-	base.Fatalf("IsSlice3 op %v", o)
-	return false
-}
-
 // backingArrayPtrLen extracts the pointer and length from a slice or string.
 // This constructs two nodes referring to n, so n must be a cheapexpr.
-func (n *Node) backingArrayPtrLen() (ptr, len *Node) {
-	var init Nodes
+func backingArrayPtrLen(n *ir.Node) (ptr, len *ir.Node) {
+	var init ir.Nodes
 	c := cheapexpr(n, &init)
 	if c != n || init.Len() != 0 {
 		base.Fatalf("backingArrayPtrLen not cheap: %v", n)
 	}
-	ptr = nod(OSPTR, n, nil)
+	ptr = ir.Nod(ir.OSPTR, n, nil)
 	if n.Type.IsString() {
-		ptr.Type = types.Types[TUINT8].PtrTo()
+		ptr.Type = types.Types[types.TUINT8].PtrTo()
 	} else {
 		ptr.Type = n.Type.Elem().PtrTo()
 	}
-	len = nod(OLEN, n, nil)
-	len.Type = types.Types[TINT]
+	len = ir.Nod(ir.OLEN, n, nil)
+	len.Type = types.Types[types.TINT]
 	return ptr, len
 }
 
 // labeledControl returns the control flow Node (for, switch, select)
 // associated with the label n, if any.
-func (n *Node) labeledControl() *Node {
-	if n.Op != OLABEL {
+func labeledControl(n *ir.Node) *ir.Node {
+	if n.Op != ir.OLABEL {
 		base.Fatalf("labeledControl %v", n.Op)
 	}
 	ctl := n.Name.Defn
@@ -771,18 +593,18 @@ func (n *Node) labeledControl() *Node {
 		return nil
 	}
 	switch ctl.Op {
-	case OFOR, OFORUNTIL, OSWITCH, OSELECT:
+	case ir.OFOR, ir.OFORUNTIL, ir.OSWITCH, ir.OSELECT:
 		return ctl
 	}
 	return nil
 }
 
-func syslook(name string) *Node {
+func syslook(name string) *ir.Node {
 	s := Runtimepkg.Lookup(name)
 	if s == nil || s.Def == nil {
 		base.Fatalf("syslook: can't find runtime.%s", name)
 	}
-	return asNode(s.Def)
+	return ir.AsNode(s.Def)
 }
 
 // typehash computes a hash value for type t to use in type switch statements.
@@ -796,49 +618,49 @@ func typehash(t *types.Type) uint32 {
 
 // updateHasCall checks whether expression n contains any function
 // calls and sets the n.HasCall flag if so.
-func updateHasCall(n *Node) {
+func updateHasCall(n *ir.Node) {
 	if n == nil {
 		return
 	}
 	n.SetHasCall(calcHasCall(n))
 }
 
-func calcHasCall(n *Node) bool {
+func calcHasCall(n *ir.Node) bool {
 	if n.Ninit.Len() != 0 {
 		// TODO(mdempsky): This seems overly conservative.
 		return true
 	}
 
 	switch n.Op {
-	case OLITERAL, ONIL, ONAME, OTYPE:
+	case ir.OLITERAL, ir.ONIL, ir.ONAME, ir.OTYPE:
 		if n.HasCall() {
 			base.Fatalf("OLITERAL/ONAME/OTYPE should never have calls: %+v", n)
 		}
 		return false
-	case OCALL, OCALLFUNC, OCALLMETH, OCALLINTER:
+	case ir.OCALL, ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
 		return true
-	case OANDAND, OOROR:
+	case ir.OANDAND, ir.OOROR:
 		// hard with instrumented code
 		if instrumenting {
 			return true
 		}
-	case OINDEX, OSLICE, OSLICEARR, OSLICE3, OSLICE3ARR, OSLICESTR,
-		ODEREF, ODOTPTR, ODOTTYPE, ODIV, OMOD:
+	case ir.OINDEX, ir.OSLICE, ir.OSLICEARR, ir.OSLICE3, ir.OSLICE3ARR, ir.OSLICESTR,
+		ir.ODEREF, ir.ODOTPTR, ir.ODOTTYPE, ir.ODIV, ir.OMOD:
 		// These ops might panic, make sure they are done
 		// before we start marshaling args for a call. See issue 16760.
 		return true
 
 	// When using soft-float, these ops might be rewritten to function calls
 	// so we ensure they are evaluated first.
-	case OADD, OSUB, ONEG, OMUL:
+	case ir.OADD, ir.OSUB, ir.ONEG, ir.OMUL:
 		if thearch.SoftFloat && (isFloat[n.Type.Etype] || isComplex[n.Type.Etype]) {
 			return true
 		}
-	case OLT, OEQ, ONE, OLE, OGE, OGT:
+	case ir.OLT, ir.OEQ, ir.ONE, ir.OLE, ir.OGE, ir.OGT:
 		if thearch.SoftFloat && (isFloat[n.Left.Type.Etype] || isComplex[n.Left.Type.Etype]) {
 			return true
 		}
-	case OCONV:
+	case ir.OCONV:
 		if thearch.SoftFloat && ((isFloat[n.Type.Etype] || isComplex[n.Type.Etype]) || (isFloat[n.Left.Type.Etype] || isComplex[n.Left.Type.Etype])) {
 			return true
 		}
@@ -853,7 +675,7 @@ func calcHasCall(n *Node) bool {
 	return false
 }
 
-func badtype(op Op, tl, tr *types.Type) {
+func badtype(op ir.Op, tl, tr *types.Type) {
 	var s string
 	if tl != nil {
 		s += fmt.Sprintf("\n\t%v", tl)
@@ -876,20 +698,20 @@ func badtype(op Op, tl, tr *types.Type) {
 
 // brcom returns !(op).
 // For example, brcom(==) is !=.
-func brcom(op Op) Op {
+func brcom(op ir.Op) ir.Op {
 	switch op {
-	case OEQ:
-		return ONE
-	case ONE:
-		return OEQ
-	case OLT:
-		return OGE
-	case OGT:
-		return OLE
-	case OLE:
-		return OGT
-	case OGE:
-		return OLT
+	case ir.OEQ:
+		return ir.ONE
+	case ir.ONE:
+		return ir.OEQ
+	case ir.OLT:
+		return ir.OGE
+	case ir.OGT:
+		return ir.OLE
+	case ir.OLE:
+		return ir.OGT
+	case ir.OGE:
+		return ir.OLT
 	}
 	base.Fatalf("brcom: no com for %v\n", op)
 	return op
@@ -897,20 +719,20 @@ func brcom(op Op) Op {
 
 // brrev returns reverse(op).
 // For example, Brrev(<) is >.
-func brrev(op Op) Op {
+func brrev(op ir.Op) ir.Op {
 	switch op {
-	case OEQ:
-		return OEQ
-	case ONE:
-		return ONE
-	case OLT:
-		return OGT
-	case OGT:
-		return OLT
-	case OLE:
-		return OGE
-	case OGE:
-		return OLE
+	case ir.OEQ:
+		return ir.OEQ
+	case ir.ONE:
+		return ir.ONE
+	case ir.OLT:
+		return ir.OGT
+	case ir.OGT:
+		return ir.OLT
+	case ir.OLE:
+		return ir.OGE
+	case ir.OGE:
+		return ir.OLE
 	}
 	base.Fatalf("brrev: no rev for %v\n", op)
 	return op
@@ -918,7 +740,7 @@ func brrev(op Op) Op {
 
 // return side effect-free n, appending side effects to init.
 // result is assignable if n is.
-func safeexpr(n *Node, init *Nodes) *Node {
+func safeexpr(n *ir.Node, init *ir.Nodes) *ir.Node {
 	if n == nil {
 		return nil
 	}
@@ -929,43 +751,43 @@ func safeexpr(n *Node, init *Nodes) *Node {
 	}
 
 	switch n.Op {
-	case ONAME, OLITERAL, ONIL:
+	case ir.ONAME, ir.OLITERAL, ir.ONIL:
 		return n
 
-	case ODOT, OLEN, OCAP:
+	case ir.ODOT, ir.OLEN, ir.OCAP:
 		l := safeexpr(n.Left, init)
 		if l == n.Left {
 			return n
 		}
-		r := n.copy()
+		r := ir.Copy(n)
 		r.Left = l
 		r = typecheck(r, ctxExpr)
 		r = walkexpr(r, init)
 		return r
 
-	case ODOTPTR, ODEREF:
+	case ir.ODOTPTR, ir.ODEREF:
 		l := safeexpr(n.Left, init)
 		if l == n.Left {
 			return n
 		}
-		a := n.copy()
+		a := ir.Copy(n)
 		a.Left = l
 		a = walkexpr(a, init)
 		return a
 
-	case OINDEX, OINDEXMAP:
+	case ir.OINDEX, ir.OINDEXMAP:
 		l := safeexpr(n.Left, init)
 		r := safeexpr(n.Right, init)
 		if l == n.Left && r == n.Right {
 			return n
 		}
-		a := n.copy()
+		a := ir.Copy(n)
 		a.Left = l
 		a.Right = r
 		a = walkexpr(a, init)
 		return a
 
-	case OSTRUCTLIT, OARRAYLIT, OSLICELIT:
+	case ir.OSTRUCTLIT, ir.OARRAYLIT, ir.OSLICELIT:
 		if isStaticCompositeLiteral(n) {
 			return n
 		}
@@ -978,9 +800,9 @@ func safeexpr(n *Node, init *Nodes) *Node {
 	return cheapexpr(n, init)
 }
 
-func copyexpr(n *Node, t *types.Type, init *Nodes) *Node {
+func copyexpr(n *ir.Node, t *types.Type, init *ir.Nodes) *ir.Node {
 	l := temp(t)
-	a := nod(OAS, l, n)
+	a := ir.Nod(ir.OAS, l, n)
 	a = typecheck(a, ctxStmt)
 	a = walkexpr(a, init)
 	init.Append(a)
@@ -989,9 +811,9 @@ func copyexpr(n *Node, t *types.Type, init *Nodes) *Node {
 
 // return side-effect free and cheap n, appending side effects to init.
 // result may not be assignable.
-func cheapexpr(n *Node, init *Nodes) *Node {
+func cheapexpr(n *ir.Node, init *ir.Nodes) *ir.Node {
 	switch n.Op {
-	case ONAME, OLITERAL, ONIL:
+	case ir.ONAME, ir.OLITERAL, ir.ONIL:
 		return n
 	}
 
@@ -1135,7 +957,7 @@ func dotpath(s *types.Sym, t *types.Type, save **types.Field, ignorecase bool) (
 // find missing fields that
 // will give shortest unique addressing.
 // modify the tree with missing type names.
-func adddot(n *Node) *Node {
+func adddot(n *ir.Node) *ir.Node {
 	n.Left = typecheck(n.Left, ctxType|ctxExpr)
 	if n.Left.Diag() {
 		n.SetDiag(true)
@@ -1145,7 +967,7 @@ func adddot(n *Node) *Node {
 		return n
 	}
 
-	if n.Left.Op == OTYPE {
+	if n.Left.Op == ir.OTYPE {
 		return n
 	}
 
@@ -1158,7 +980,7 @@ func adddot(n *Node) *Node {
 	case path != nil:
 		// rebuild elided dots
 		for c := len(path) - 1; c >= 0; c-- {
-			n.Left = nodSym(ODOT, n.Left, path[c].field.Sym)
+			n.Left = nodSym(ir.ODOT, n.Left, path[c].field.Sym)
 			n.Left.SetImplicit(true)
 		}
 	case ambig:
@@ -1294,8 +1116,8 @@ func expandmeth(t *types.Type) {
 }
 
 // Given funarg struct list, return list of ODCLFIELD Node fn args.
-func structargs(tl *types.Type, mustname bool) []*Node {
-	var args []*Node
+func structargs(tl *types.Type, mustname bool) []*ir.Node {
+	var args []*ir.Node
 	gen := 0
 	for _, t := range tl.Fields().Slice() {
 		s := t.Sym
@@ -1341,20 +1163,20 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 
 	// Only generate (*T).M wrappers for T.M in T's own package.
 	if rcvr.IsPtr() && rcvr.Elem() == method.Type.Recv().Type &&
-		rcvr.Elem().Sym != nil && rcvr.Elem().Sym.Pkg != localpkg {
+		rcvr.Elem().Sym != nil && rcvr.Elem().Sym.Pkg != ir.LocalPkg {
 		return
 	}
 
 	// Only generate I.M wrappers for I in I's own package
 	// but keep doing it for error.Error (was issue #29304).
-	if rcvr.IsInterface() && rcvr.Sym != nil && rcvr.Sym.Pkg != localpkg && rcvr != types.Errortype {
+	if rcvr.IsInterface() && rcvr.Sym != nil && rcvr.Sym.Pkg != ir.LocalPkg && rcvr != types.Errortype {
 		return
 	}
 
 	base.Pos = autogeneratedPos
-	dclcontext = PEXTERN
+	dclcontext = ir.PEXTERN
 
-	tfn := nod(OTFUNC, nil, nil)
+	tfn := ir.Nod(ir.OTFUNC, nil, nil)
 	tfn.Left = namedfield(".this", rcvr)
 	tfn.List.Set(structargs(method.Type.Params(), true))
 	tfn.Rlist.Set(structargs(method.Type.Results(), false))
@@ -1362,21 +1184,21 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	fn := dclfunc(newnam, tfn)
 	fn.Func.SetDupok(true)
 
-	nthis := asNode(tfn.Type.Recv().Nname)
+	nthis := ir.AsNode(tfn.Type.Recv().Nname)
 
 	methodrcvr := method.Type.Recv().Type
 
 	// generate nil pointer check for better error
 	if rcvr.IsPtr() && rcvr.Elem() == methodrcvr {
 		// generating wrapper from *T to T.
-		n := nod(OIF, nil, nil)
-		n.Left = nod(OEQ, nthis, nodnil())
-		call := nod(OCALL, syslook("panicwrap"), nil)
+		n := ir.Nod(ir.OIF, nil, nil)
+		n.Left = ir.Nod(ir.OEQ, nthis, nodnil())
+		call := ir.Nod(ir.OCALL, syslook("panicwrap"), nil)
 		n.Nbody.Set1(call)
 		fn.Nbody.Append(n)
 	}
 
-	dot := adddot(nodSym(OXDOT, nthis, method.Sym))
+	dot := adddot(nodSym(ir.OXDOT, nthis, method.Sym))
 
 	// generate call
 	// It's not possible to use a tail call when dynamic linking on ppc64le. The
@@ -1390,18 +1212,18 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 		dot = dot.Left // skip final .M
 		// TODO(mdempsky): Remove dependency on dotlist.
 		if !dotlist[0].field.Type.IsPtr() {
-			dot = nod(OADDR, dot, nil)
+			dot = ir.Nod(ir.OADDR, dot, nil)
 		}
-		as := nod(OAS, nthis, convnop(dot, rcvr))
+		as := ir.Nod(ir.OAS, nthis, convnop(dot, rcvr))
 		fn.Nbody.Append(as)
-		fn.Nbody.Append(nodSym(ORETJMP, nil, methodSym(methodrcvr, method.Sym)))
+		fn.Nbody.Append(nodSym(ir.ORETJMP, nil, methodSym(methodrcvr, method.Sym)))
 	} else {
 		fn.Func.SetWrapper(true) // ignore frame for panic+recover matching
-		call := nod(OCALL, dot, nil)
+		call := ir.Nod(ir.OCALL, dot, nil)
 		call.List.Set(paramNnames(tfn.Type))
 		call.SetIsDDD(tfn.Type.IsVariadic())
 		if method.Type.NumResults() > 0 {
-			n := nod(ORETURN, nil, nil)
+			n := ir.Nod(ir.ORETURN, nil, nil)
 			n.List.Set1(call)
 			call = n
 		}
@@ -1409,7 +1231,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	}
 
 	if false && base.Flag.LowerR != 0 {
-		dumplist("genwrapper body", fn.Nbody)
+		ir.DumpList("genwrapper body", fn.Nbody)
 	}
 
 	funcbody()
@@ -1428,31 +1250,31 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	if rcvr.IsPtr() && rcvr.Elem() == method.Type.Recv().Type && rcvr.Elem().Sym != nil {
 		inlcalls(fn)
 	}
-	escapeFuncs([]*Node{fn}, false)
+	escapeFuncs([]*ir.Node{fn}, false)
 
 	Curfn = nil
 	xtop = append(xtop, fn)
 }
 
-func paramNnames(ft *types.Type) []*Node {
-	args := make([]*Node, ft.NumParams())
+func paramNnames(ft *types.Type) []*ir.Node {
+	args := make([]*ir.Node, ft.NumParams())
 	for i, f := range ft.Params().FieldSlice() {
-		args[i] = asNode(f.Nname)
+		args[i] = ir.AsNode(f.Nname)
 	}
 	return args
 }
 
-func hashmem(t *types.Type) *Node {
+func hashmem(t *types.Type) *ir.Node {
 	sym := Runtimepkg.Lookup("memhash")
 
-	n := newname(sym)
+	n := NewName(sym)
 	setNodeNameFunc(n)
-	n.Type = functype(nil, []*Node{
+	n.Type = functype(nil, []*ir.Node{
 		anonfield(types.NewPtr(t)),
-		anonfield(types.Types[TUINTPTR]),
-		anonfield(types.Types[TUINTPTR]),
-	}, []*Node{
-		anonfield(types.Types[TUINTPTR]),
+		anonfield(types.Types[types.TUINTPTR]),
+		anonfield(types.Types[types.TUINTPTR]),
+	}, []*ir.Node{
+		anonfield(types.Types[types.TUINTPTR]),
 	})
 	return n
 }
@@ -1571,16 +1393,16 @@ func implements(t, iface *types.Type, m, samename **types.Field, ptr *int) bool
 	return true
 }
 
-func listtreecopy(l []*Node, pos src.XPos) []*Node {
-	var out []*Node
+func listtreecopy(l []*ir.Node, pos src.XPos) []*ir.Node {
+	var out []*ir.Node
 	for _, n := range l {
 		out = append(out, treecopy(n, pos))
 	}
 	return out
 }
 
-func liststmt(l []*Node) *Node {
-	n := nod(OBLOCK, nil, nil)
+func liststmt(l []*ir.Node) *ir.Node {
+	n := ir.Nod(ir.OBLOCK, nil, nil)
 	n.List.Set(l)
 	if len(l) != 0 {
 		n.Pos = l[0].Pos
@@ -1588,7 +1410,7 @@ func liststmt(l []*Node) *Node {
 	return n
 }
 
-func ngotype(n *Node) *types.Sym {
+func ngotype(n *ir.Node) *types.Sym {
 	if n.Type != nil {
 		return typenamesym(n.Type)
 	}
@@ -1597,13 +1419,13 @@ func ngotype(n *Node) *types.Sym {
 
 // The result of addinit MUST be assigned back to n, e.g.
 // 	n.Left = addinit(n.Left, init)
-func addinit(n *Node, init []*Node) *Node {
+func addinit(n *ir.Node, init []*ir.Node) *ir.Node {
 	if len(init) == 0 {
 		return n
 	}
-	if n.mayBeShared() {
+	if ir.MayBeShared(n) {
 		// Introduce OCONVNOP to hold init list.
-		n = nod(OCONVNOP, n, nil)
+		n = ir.Nod(ir.OCONVNOP, n, nil)
 		n.Type = n.Left.Type
 		n.SetTypecheck(1)
 	}
@@ -1674,20 +1496,20 @@ func isdirectiface(t *types.Type) bool {
 	}
 
 	switch t.Etype {
-	case TPTR:
+	case types.TPTR:
 		// Pointers to notinheap types must be stored indirectly. See issue 42076.
 		return !t.Elem().NotInHeap()
-	case TCHAN,
-		TMAP,
-		TFUNC,
-		TUNSAFEPTR:
+	case types.TCHAN,
+		types.TMAP,
+		types.TFUNC,
+		types.TUNSAFEPTR:
 		return true
 
-	case TARRAY:
+	case types.TARRAY:
 		// Array of 1 direct iface type can be direct.
 		return t.NumElem() == 1 && isdirectiface(t.Elem())
 
-	case TSTRUCT:
+	case types.TSTRUCT:
 		// Struct with 1 field of direct iface type can be direct.
 		return t.NumFields() == 1 && isdirectiface(t.Field(0).Type)
 	}
@@ -1696,9 +1518,9 @@ func isdirectiface(t *types.Type) bool {
 }
 
 // itabType loads the _type field from a runtime.itab struct.
-func itabType(itab *Node) *Node {
-	typ := nodSym(ODOTPTR, itab, nil)
-	typ.Type = types.NewPtr(types.Types[TUINT8])
+func itabType(itab *ir.Node) *ir.Node {
+	typ := nodSym(ir.ODOTPTR, itab, nil)
+	typ.Type = types.NewPtr(types.Types[types.TUINT8])
 	typ.SetTypecheck(1)
 	typ.Xoffset = int64(Widthptr) // offset of _type in runtime.itab
 	typ.SetBounded(true)          // guaranteed not to fault
@@ -1708,11 +1530,11 @@ func itabType(itab *Node) *Node {
 // ifaceData loads the data field from an interface.
 // The concrete type must be known to have type t.
 // It follows the pointer if !isdirectiface(t).
-func ifaceData(pos src.XPos, n *Node, t *types.Type) *Node {
+func ifaceData(pos src.XPos, n *ir.Node, t *types.Type) *ir.Node {
 	if t.IsInterface() {
 		base.Fatalf("ifaceData interface: %v", t)
 	}
-	ptr := nodlSym(pos, OIDATA, n, nil)
+	ptr := nodlSym(pos, ir.OIDATA, n, nil)
 	if isdirectiface(t) {
 		ptr.Type = t
 		ptr.SetTypecheck(1)
@@ -1720,7 +1542,7 @@ func ifaceData(pos src.XPos, n *Node, t *types.Type) *Node {
 	}
 	ptr.Type = types.NewPtr(t)
 	ptr.SetTypecheck(1)
-	ind := nodl(pos, ODEREF, ptr, nil)
+	ind := ir.NodAt(pos, ir.ODEREF, ptr, nil)
 	ind.Type = t
 	ind.SetTypecheck(1)
 	ind.SetBounded(true)
@@ -1730,7 +1552,7 @@ func ifaceData(pos src.XPos, n *Node, t *types.Type) *Node {
 // typePos returns the position associated with t.
 // This is where t was declared or where it appeared as a type expression.
 func typePos(t *types.Type) src.XPos {
-	n := asNode(t.Nod)
+	n := ir.AsNode(t.Nod)
 	if n == nil || !n.Pos.IsKnown() {
 		base.Fatalf("bad type: %v", t)
 	}
diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index 7befbdf06c..f3195df79a 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"go/constant"
@@ -14,16 +15,16 @@ import (
 )
 
 // typecheckswitch typechecks a switch statement.
-func typecheckswitch(n *Node) {
+func typecheckswitch(n *ir.Node) {
 	typecheckslice(n.Ninit.Slice(), ctxStmt)
-	if n.Left != nil && n.Left.Op == OTYPESW {
+	if n.Left != nil && n.Left.Op == ir.OTYPESW {
 		typecheckTypeSwitch(n)
 	} else {
 		typecheckExprSwitch(n)
 	}
 }
 
-func typecheckTypeSwitch(n *Node) {
+func typecheckTypeSwitch(n *ir.Node) {
 	n.Left.Right = typecheck(n.Left.Right, ctxExpr)
 	t := n.Left.Right.Type
 	if t != nil && !t.IsInterface() {
@@ -34,17 +35,17 @@ func typecheckTypeSwitch(n *Node) {
 	// We don't actually declare the type switch's guarded
 	// declaration itself. So if there are no cases, we won't
 	// notice that it went unused.
-	if v := n.Left.Left; v != nil && !v.isBlank() && n.List.Len() == 0 {
+	if v := n.Left.Left; v != nil && !ir.IsBlank(v) && n.List.Len() == 0 {
 		base.ErrorfAt(v.Pos, "%v declared but not used", v.Sym)
 	}
 
-	var defCase, nilCase *Node
+	var defCase, nilCase *ir.Node
 	var ts typeSet
 	for _, ncase := range n.List.Slice() {
 		ls := ncase.List.Slice()
 		if len(ls) == 0 { // default:
 			if defCase != nil {
-				base.ErrorfAt(ncase.Pos, "multiple defaults in switch (first at %v)", defCase.Line())
+				base.ErrorfAt(ncase.Pos, "multiple defaults in switch (first at %v)", ir.Line(defCase))
 			} else {
 				defCase = ncase
 			}
@@ -60,13 +61,13 @@ func typecheckTypeSwitch(n *Node) {
 			var missing, have *types.Field
 			var ptr int
 			switch {
-			case n1.isNil(): // case nil:
+			case ir.IsNil(n1): // case nil:
 				if nilCase != nil {
-					base.ErrorfAt(ncase.Pos, "multiple nil cases in type switch (first at %v)", nilCase.Line())
+					base.ErrorfAt(ncase.Pos, "multiple nil cases in type switch (first at %v)", ir.Line(nilCase))
 				} else {
 					nilCase = ncase
 				}
-			case n1.Op != OTYPE:
+			case n1.Op != ir.OTYPE:
 				base.ErrorfAt(ncase.Pos, "%L is not a type", n1)
 			case !n1.Type.IsInterface() && !implements(n1.Type, t, &missing, &have, &ptr) && !missing.Broke():
 				if have != nil && !have.Broke() {
@@ -81,7 +82,7 @@ func typecheckTypeSwitch(n *Node) {
 				}
 			}
 
-			if n1.Op == OTYPE {
+			if n1.Op == ir.OTYPE {
 				ts.add(ncase.Pos, n1.Type)
 			}
 		}
@@ -90,9 +91,9 @@ func typecheckTypeSwitch(n *Node) {
 			// Assign the clause variable's type.
 			vt := t
 			if len(ls) == 1 {
-				if ls[0].Op == OTYPE {
+				if ls[0].Op == ir.OTYPE {
 					vt = ls[0].Type
-				} else if !ls[0].isNil() {
+				} else if !ir.IsNil(ls[0]) {
 					// Invalid single-type case;
 					// mark variable as broken.
 					vt = nil
@@ -143,8 +144,8 @@ func (s *typeSet) add(pos src.XPos, typ *types.Type) {
 	s.m[ls] = append(prevs, typeSetEntry{pos, typ})
 }
 
-func typecheckExprSwitch(n *Node) {
-	t := types.Types[TBOOL]
+func typecheckExprSwitch(n *ir.Node) {
+	t := types.Types[types.TBOOL]
 	if n.Left != nil {
 		n.Left = typecheck(n.Left, ctxExpr)
 		n.Left = defaultlit(n.Left, nil)
@@ -156,7 +157,7 @@ func typecheckExprSwitch(n *Node) {
 		switch {
 		case t.IsMap():
 			nilonly = "map"
-		case t.Etype == TFUNC:
+		case t.Etype == types.TFUNC:
 			nilonly = "func"
 		case t.IsSlice():
 			nilonly = "slice"
@@ -171,13 +172,13 @@ func typecheckExprSwitch(n *Node) {
 		}
 	}
 
-	var defCase *Node
+	var defCase *ir.Node
 	var cs constSet
 	for _, ncase := range n.List.Slice() {
 		ls := ncase.List.Slice()
 		if len(ls) == 0 { // default:
 			if defCase != nil {
-				base.ErrorfAt(ncase.Pos, "multiple defaults in switch (first at %v)", defCase.Line())
+				base.ErrorfAt(ncase.Pos, "multiple defaults in switch (first at %v)", ir.Line(defCase))
 			} else {
 				defCase = ncase
 			}
@@ -192,14 +193,14 @@ func typecheckExprSwitch(n *Node) {
 				continue
 			}
 
-			if nilonly != "" && !n1.isNil() {
+			if nilonly != "" && !ir.IsNil(n1) {
 				base.ErrorfAt(ncase.Pos, "invalid case %v in switch (can only compare %s %v to nil)", n1, nilonly, n.Left)
 			} else if t.IsInterface() && !n1.Type.IsInterface() && !IsComparable(n1.Type) {
 				base.ErrorfAt(ncase.Pos, "invalid case %L in switch (incomparable type)", n1)
 			} else {
 				op1, _ := assignop(n1.Type, t)
 				op2, _ := assignop(t, n1.Type)
-				if op1 == OXXX && op2 == OXXX {
+				if op1 == ir.OXXX && op2 == ir.OXXX {
 					if n.Left != nil {
 						base.ErrorfAt(ncase.Pos, "invalid case %v in switch on %v (mismatched types %v and %v)", n1, n.Left, n1.Type, t)
 					} else {
@@ -224,13 +225,13 @@ func typecheckExprSwitch(n *Node) {
 }
 
 // walkswitch walks a switch statement.
-func walkswitch(sw *Node) {
+func walkswitch(sw *ir.Node) {
 	// Guard against double walk, see #25776.
 	if sw.List.Len() == 0 && sw.Nbody.Len() > 0 {
 		return // Was fatal, but eliminating every possible source of double-walking is hard
 	}
 
-	if sw.Left != nil && sw.Left.Op == OTYPESW {
+	if sw.Left != nil && sw.Left.Op == ir.OTYPESW {
 		walkTypeSwitch(sw)
 	} else {
 		walkExprSwitch(sw)
@@ -239,7 +240,7 @@ func walkswitch(sw *Node) {
 
 // walkExprSwitch generates an AST implementing sw.  sw is an
 // expression switch.
-func walkExprSwitch(sw *Node) {
+func walkExprSwitch(sw *ir.Node) {
 	lno := setlineno(sw)
 
 	cond := sw.Left
@@ -259,12 +260,12 @@ func walkExprSwitch(sw *Node) {
 	// because walkexpr will lower the string
 	// conversion into a runtime call.
 	// See issue 24937 for more discussion.
-	if cond.Op == OBYTES2STR && allCaseExprsAreSideEffectFree(sw) {
-		cond.Op = OBYTES2STRTMP
+	if cond.Op == ir.OBYTES2STR && allCaseExprsAreSideEffectFree(sw) {
+		cond.Op = ir.OBYTES2STRTMP
 	}
 
 	cond = walkexpr(cond, &sw.Ninit)
-	if cond.Op != OLITERAL && cond.Op != ONIL {
+	if cond.Op != ir.OLITERAL && cond.Op != ir.ONIL {
 		cond = copyexpr(cond, cond.Type, &sw.Nbody)
 	}
 
@@ -274,11 +275,11 @@ func walkExprSwitch(sw *Node) {
 		exprname: cond,
 	}
 
-	var defaultGoto *Node
-	var body Nodes
+	var defaultGoto *ir.Node
+	var body ir.Nodes
 	for _, ncase := range sw.List.Slice() {
 		label := autolabel(".s")
-		jmp := npos(ncase.Pos, nodSym(OGOTO, nil, label))
+		jmp := npos(ncase.Pos, nodSym(ir.OGOTO, nil, label))
 
 		// Process case dispatch.
 		if ncase.List.Len() == 0 {
@@ -293,10 +294,10 @@ func walkExprSwitch(sw *Node) {
 		}
 
 		// Process body.
-		body.Append(npos(ncase.Pos, nodSym(OLABEL, nil, label)))
+		body.Append(npos(ncase.Pos, nodSym(ir.OLABEL, nil, label)))
 		body.Append(ncase.Nbody.Slice()...)
 		if fall, pos := hasFall(ncase.Nbody.Slice()); !fall {
-			br := nod(OBREAK, nil, nil)
+			br := ir.Nod(ir.OBREAK, nil, nil)
 			br.Pos = pos
 			body.Append(br)
 		}
@@ -304,7 +305,7 @@ func walkExprSwitch(sw *Node) {
 	sw.List.Set(nil)
 
 	if defaultGoto == nil {
-		br := nod(OBREAK, nil, nil)
+		br := ir.Nod(ir.OBREAK, nil, nil)
 		br.Pos = br.Pos.WithNotStmt()
 		defaultGoto = br
 	}
@@ -317,21 +318,21 @@ func walkExprSwitch(sw *Node) {
 
 // An exprSwitch walks an expression switch.
 type exprSwitch struct {
-	exprname *Node // value being switched on
+	exprname *ir.Node // value being switched on
 
-	done    Nodes
+	done    ir.Nodes
 	clauses []exprClause
 }
 
 type exprClause struct {
 	pos    src.XPos
-	lo, hi *Node
-	jmp    *Node
+	lo, hi *ir.Node
+	jmp    *ir.Node
 }
 
-func (s *exprSwitch) Add(pos src.XPos, expr, jmp *Node) {
+func (s *exprSwitch) Add(pos src.XPos, expr, jmp *ir.Node) {
 	c := exprClause{pos: pos, lo: expr, hi: expr, jmp: jmp}
-	if okforcmp[s.exprname.Type.Etype] && expr.Op == OLITERAL {
+	if okforcmp[s.exprname.Type.Etype] && expr.Op == ir.OLITERAL {
 		s.clauses = append(s.clauses, c)
 		return
 	}
@@ -341,7 +342,7 @@ func (s *exprSwitch) Add(pos src.XPos, expr, jmp *Node) {
 	s.flush()
 }
 
-func (s *exprSwitch) Emit(out *Nodes) {
+func (s *exprSwitch) Emit(out *ir.Nodes) {
 	s.flush()
 	out.AppendNodes(&s.done)
 }
@@ -389,12 +390,12 @@ func (s *exprSwitch) flush() {
 
 		// Perform two-level binary search.
 		binarySearch(len(runs), &s.done,
-			func(i int) *Node {
-				return nod(OLE, nod(OLEN, s.exprname, nil), nodintconst(runLen(runs[i-1])))
+			func(i int) *ir.Node {
+				return ir.Nod(ir.OLE, ir.Nod(ir.OLEN, s.exprname, nil), nodintconst(runLen(runs[i-1])))
 			},
-			func(i int, nif *Node) {
+			func(i int, nif *ir.Node) {
 				run := runs[i]
-				nif.Left = nod(OEQ, nod(OLEN, s.exprname, nil), nodintconst(runLen(run)))
+				nif.Left = ir.Nod(ir.OEQ, ir.Nod(ir.OLEN, s.exprname, nil), nodintconst(runLen(run)))
 				s.search(run, &nif.Nbody)
 			},
 		)
@@ -422,12 +423,12 @@ func (s *exprSwitch) flush() {
 	s.search(cc, &s.done)
 }
 
-func (s *exprSwitch) search(cc []exprClause, out *Nodes) {
+func (s *exprSwitch) search(cc []exprClause, out *ir.Nodes) {
 	binarySearch(len(cc), out,
-		func(i int) *Node {
-			return nod(OLE, s.exprname, cc[i-1].hi)
+		func(i int) *ir.Node {
+			return ir.Nod(ir.OLE, s.exprname, cc[i-1].hi)
 		},
-		func(i int, nif *Node) {
+		func(i int, nif *ir.Node) {
 			c := &cc[i]
 			nif.Left = c.test(s.exprname)
 			nif.Nbody.Set1(c.jmp)
@@ -435,27 +436,27 @@ func (s *exprSwitch) search(cc []exprClause, out *Nodes) {
 	)
 }
 
-func (c *exprClause) test(exprname *Node) *Node {
+func (c *exprClause) test(exprname *ir.Node) *ir.Node {
 	// Integer range.
 	if c.hi != c.lo {
-		low := nodl(c.pos, OGE, exprname, c.lo)
-		high := nodl(c.pos, OLE, exprname, c.hi)
-		return nodl(c.pos, OANDAND, low, high)
+		low := ir.NodAt(c.pos, ir.OGE, exprname, c.lo)
+		high := ir.NodAt(c.pos, ir.OLE, exprname, c.hi)
+		return ir.NodAt(c.pos, ir.OANDAND, low, high)
 	}
 
 	// Optimize "switch true { ...}" and "switch false { ... }".
-	if Isconst(exprname, constant.Bool) && !c.lo.Type.IsInterface() {
+	if ir.IsConst(exprname, constant.Bool) && !c.lo.Type.IsInterface() {
 		if exprname.BoolVal() {
 			return c.lo
 		} else {
-			return nodl(c.pos, ONOT, c.lo, nil)
+			return ir.NodAt(c.pos, ir.ONOT, c.lo, nil)
 		}
 	}
 
-	return nodl(c.pos, OEQ, exprname, c.lo)
+	return ir.NodAt(c.pos, ir.OEQ, exprname, c.lo)
 }
 
-func allCaseExprsAreSideEffectFree(sw *Node) bool {
+func allCaseExprsAreSideEffectFree(sw *ir.Node) bool {
 	// In theory, we could be more aggressive, allowing any
 	// side-effect-free expressions in cases, but it's a bit
 	// tricky because some of that information is unavailable due
@@ -464,11 +465,11 @@ func allCaseExprsAreSideEffectFree(sw *Node) bool {
 	// enough.
 
 	for _, ncase := range sw.List.Slice() {
-		if ncase.Op != OCASE {
+		if ncase.Op != ir.OCASE {
 			base.Fatalf("switch string(byteslice) bad op: %v", ncase.Op)
 		}
 		for _, v := range ncase.List.Slice() {
-			if v.Op != OLITERAL {
+			if v.Op != ir.OLITERAL {
 				return false
 			}
 		}
@@ -477,7 +478,7 @@ func allCaseExprsAreSideEffectFree(sw *Node) bool {
 }
 
 // hasFall reports whether stmts ends with a "fallthrough" statement.
-func hasFall(stmts []*Node) (bool, src.XPos) {
+func hasFall(stmts []*ir.Node) (bool, src.XPos) {
 	// Search backwards for the index of the fallthrough
 	// statement. Do not assume it'll be in the last
 	// position, since in some cases (e.g. when the statement
@@ -485,30 +486,30 @@ func hasFall(stmts []*Node) (bool, src.XPos) {
 	// nodes will be at the end of the list.
 
 	i := len(stmts) - 1
-	for i >= 0 && stmts[i].Op == OVARKILL {
+	for i >= 0 && stmts[i].Op == ir.OVARKILL {
 		i--
 	}
 	if i < 0 {
 		return false, src.NoXPos
 	}
-	return stmts[i].Op == OFALL, stmts[i].Pos
+	return stmts[i].Op == ir.OFALL, stmts[i].Pos
 }
 
 // walkTypeSwitch generates an AST that implements sw, where sw is a
 // type switch.
-func walkTypeSwitch(sw *Node) {
+func walkTypeSwitch(sw *ir.Node) {
 	var s typeSwitch
 	s.facename = sw.Left.Right
 	sw.Left = nil
 
 	s.facename = walkexpr(s.facename, &sw.Ninit)
 	s.facename = copyexpr(s.facename, s.facename.Type, &sw.Nbody)
-	s.okname = temp(types.Types[TBOOL])
+	s.okname = temp(types.Types[types.TBOOL])
 
 	// Get interface descriptor word.
 	// For empty interfaces this will be the type.
 	// For non-empty interfaces this will be the itab.
-	itab := nod(OITAB, s.facename, nil)
+	itab := ir.Nod(ir.OITAB, s.facename, nil)
 
 	// For empty interfaces, do:
 	//     if e._type == nil {
@@ -516,8 +517,8 @@ func walkTypeSwitch(sw *Node) {
 	//     }
 	//     h := e._type.hash
 	// Use a similar strategy for non-empty interfaces.
-	ifNil := nod(OIF, nil, nil)
-	ifNil.Left = nod(OEQ, itab, nodnil())
+	ifNil := ir.Nod(ir.OIF, nil, nil)
+	ifNil.Left = ir.Nod(ir.OEQ, itab, nodnil())
 	base.Pos = base.Pos.WithNotStmt() // disable statement marks after the first check.
 	ifNil.Left = typecheck(ifNil.Left, ctxExpr)
 	ifNil.Left = defaultlit(ifNil.Left, nil)
@@ -525,8 +526,8 @@ func walkTypeSwitch(sw *Node) {
 	sw.Nbody.Append(ifNil)
 
 	// Load hash from type or itab.
-	dotHash := nodSym(ODOTPTR, itab, nil)
-	dotHash.Type = types.Types[TUINT32]
+	dotHash := nodSym(ir.ODOTPTR, itab, nil)
+	dotHash.Type = types.Types[types.TUINT32]
 	dotHash.SetTypecheck(1)
 	if s.facename.Type.IsEmptyInterface() {
 		dotHash.Xoffset = int64(2 * Widthptr) // offset of hash in runtime._type
@@ -536,11 +537,11 @@ func walkTypeSwitch(sw *Node) {
 	dotHash.SetBounded(true) // guaranteed not to fault
 	s.hashname = copyexpr(dotHash, dotHash.Type, &sw.Nbody)
 
-	br := nod(OBREAK, nil, nil)
-	var defaultGoto, nilGoto *Node
-	var body Nodes
+	br := ir.Nod(ir.OBREAK, nil, nil)
+	var defaultGoto, nilGoto *ir.Node
+	var body ir.Nodes
 	for _, ncase := range sw.List.Slice() {
-		var caseVar *Node
+		var caseVar *ir.Node
 		if ncase.Rlist.Len() != 0 {
 			caseVar = ncase.Rlist.First()
 		}
@@ -549,13 +550,13 @@ func walkTypeSwitch(sw *Node) {
 		// we initialize the case variable as part of the type assertion.
 		// In other cases, we initialize it in the body.
 		var singleType *types.Type
-		if ncase.List.Len() == 1 && ncase.List.First().Op == OTYPE {
+		if ncase.List.Len() == 1 && ncase.List.First().Op == ir.OTYPE {
 			singleType = ncase.List.First().Type
 		}
 		caseVarInitialized := false
 
 		label := autolabel(".s")
-		jmp := npos(ncase.Pos, nodSym(OGOTO, nil, label))
+		jmp := npos(ncase.Pos, nodSym(ir.OGOTO, nil, label))
 
 		if ncase.List.Len() == 0 { // default:
 			if defaultGoto != nil {
@@ -565,7 +566,7 @@ func walkTypeSwitch(sw *Node) {
 		}
 
 		for _, n1 := range ncase.List.Slice() {
-			if n1.isNil() { // case nil:
+			if ir.IsNil(n1) { // case nil:
 				if nilGoto != nil {
 					base.Fatalf("duplicate nil case not detected during typechecking")
 				}
@@ -581,7 +582,7 @@ func walkTypeSwitch(sw *Node) {
 			}
 		}
 
-		body.Append(npos(ncase.Pos, nodSym(OLABEL, nil, label)))
+		body.Append(npos(ncase.Pos, nodSym(ir.OLABEL, nil, label)))
 		if caseVar != nil && !caseVarInitialized {
 			val := s.facename
 			if singleType != nil {
@@ -591,9 +592,9 @@ func walkTypeSwitch(sw *Node) {
 				}
 				val = ifaceData(ncase.Pos, s.facename, singleType)
 			}
-			l := []*Node{
-				nodl(ncase.Pos, ODCL, caseVar, nil),
-				nodl(ncase.Pos, OAS, caseVar, val),
+			l := []*ir.Node{
+				ir.NodAt(ncase.Pos, ir.ODCL, caseVar, nil),
+				ir.NodAt(ncase.Pos, ir.OAS, caseVar, val),
 			}
 			typecheckslice(l, ctxStmt)
 			body.Append(l...)
@@ -621,36 +622,36 @@ func walkTypeSwitch(sw *Node) {
 // A typeSwitch walks a type switch.
 type typeSwitch struct {
 	// Temporary variables (i.e., ONAMEs) used by type switch dispatch logic:
-	facename *Node // value being type-switched on
-	hashname *Node // type hash of the value being type-switched on
-	okname   *Node // boolean used for comma-ok type assertions
+	facename *ir.Node // value being type-switched on
+	hashname *ir.Node // type hash of the value being type-switched on
+	okname   *ir.Node // boolean used for comma-ok type assertions
 
-	done    Nodes
+	done    ir.Nodes
 	clauses []typeClause
 }
 
 type typeClause struct {
 	hash uint32
-	body Nodes
+	body ir.Nodes
 }
 
-func (s *typeSwitch) Add(pos src.XPos, typ *types.Type, caseVar, jmp *Node) {
-	var body Nodes
+func (s *typeSwitch) Add(pos src.XPos, typ *types.Type, caseVar, jmp *ir.Node) {
+	var body ir.Nodes
 	if caseVar != nil {
-		l := []*Node{
-			nodl(pos, ODCL, caseVar, nil),
-			nodl(pos, OAS, caseVar, nil),
+		l := []*ir.Node{
+			ir.NodAt(pos, ir.ODCL, caseVar, nil),
+			ir.NodAt(pos, ir.OAS, caseVar, nil),
 		}
 		typecheckslice(l, ctxStmt)
 		body.Append(l...)
 	} else {
-		caseVar = nblank
+		caseVar = ir.BlankNode
 	}
 
 	// cv, ok = iface.(type)
-	as := nodl(pos, OAS2, nil, nil)
+	as := ir.NodAt(pos, ir.OAS2, nil, nil)
 	as.List.Set2(caseVar, s.okname) // cv, ok =
-	dot := nodl(pos, ODOTTYPE, s.facename, nil)
+	dot := ir.NodAt(pos, ir.ODOTTYPE, s.facename, nil)
 	dot.Type = typ // iface.(type)
 	as.Rlist.Set1(dot)
 	as = typecheck(as, ctxStmt)
@@ -658,7 +659,7 @@ func (s *typeSwitch) Add(pos src.XPos, typ *types.Type, caseVar, jmp *Node) {
 	body.Append(as)
 
 	// if ok { goto label }
-	nif := nodl(pos, OIF, nil, nil)
+	nif := ir.NodAt(pos, ir.OIF, nil, nil)
 	nif.Left = s.okname
 	nif.Nbody.Set1(jmp)
 	body.Append(nif)
@@ -675,7 +676,7 @@ func (s *typeSwitch) Add(pos src.XPos, typ *types.Type, caseVar, jmp *Node) {
 	s.done.AppendNodes(&body)
 }
 
-func (s *typeSwitch) Emit(out *Nodes) {
+func (s *typeSwitch) Emit(out *ir.Nodes) {
 	s.flush()
 	out.AppendNodes(&s.done)
 }
@@ -702,14 +703,14 @@ func (s *typeSwitch) flush() {
 	cc = merged
 
 	binarySearch(len(cc), &s.done,
-		func(i int) *Node {
-			return nod(OLE, s.hashname, nodintconst(int64(cc[i-1].hash)))
+		func(i int) *ir.Node {
+			return ir.Nod(ir.OLE, s.hashname, nodintconst(int64(cc[i-1].hash)))
 		},
-		func(i int, nif *Node) {
+		func(i int, nif *ir.Node) {
 			// TODO(mdempsky): Omit hash equality check if
 			// there's only one type.
 			c := cc[i]
-			nif.Left = nod(OEQ, s.hashname, nodintconst(int64(c.hash)))
+			nif.Left = ir.Nod(ir.OEQ, s.hashname, nodintconst(int64(c.hash)))
 			nif.Nbody.AppendNodes(&c.body)
 		},
 	)
@@ -724,15 +725,15 @@ func (s *typeSwitch) flush() {
 //
 // leaf(i, nif) should setup nif (an OIF node) to test case i. In
 // particular, it should set nif.Left and nif.Nbody.
-func binarySearch(n int, out *Nodes, less func(i int) *Node, leaf func(i int, nif *Node)) {
+func binarySearch(n int, out *ir.Nodes, less func(i int) *ir.Node, leaf func(i int, nif *ir.Node)) {
 	const binarySearchMin = 4 // minimum number of cases for binary search
 
-	var do func(lo, hi int, out *Nodes)
-	do = func(lo, hi int, out *Nodes) {
+	var do func(lo, hi int, out *ir.Nodes)
+	do = func(lo, hi int, out *ir.Nodes) {
 		n := hi - lo
 		if n < binarySearchMin {
 			for i := lo; i < hi; i++ {
-				nif := nod(OIF, nil, nil)
+				nif := ir.Nod(ir.OIF, nil, nil)
 				leaf(i, nif)
 				base.Pos = base.Pos.WithNotStmt()
 				nif.Left = typecheck(nif.Left, ctxExpr)
@@ -744,7 +745,7 @@ func binarySearch(n int, out *Nodes, less func(i int) *Node, leaf func(i int, ni
 		}
 
 		half := lo + n/2
-		nif := nod(OIF, nil, nil)
+		nif := ir.Nod(ir.OIF, nil, nil)
 		nif.Left = less(half)
 		base.Pos = base.Pos.WithNotStmt()
 		nif.Left = typecheck(nif.Left, ctxExpr)
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index b61b9b0525..78fdf100ad 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"fmt"
 	"go/constant"
@@ -19,7 +20,7 @@ const enableTrace = false
 var traceIndent []byte
 var skipDowidthForTracing bool
 
-func tracePrint(title string, n *Node) func(np **Node) {
+func tracePrint(title string, n *ir.Node) func(np **ir.Node) {
 	indent := traceIndent
 
 	// guard against nil
@@ -36,7 +37,7 @@ func tracePrint(title string, n *Node) func(np **Node) {
 	fmt.Printf("%s: %s%s %p %s %v tc=%d\n", pos, indent, title, n, op, n, tc)
 	traceIndent = append(traceIndent, ". "...)
 
-	return func(np **Node) {
+	return func(np **ir.Node) {
 		traceIndent = traceIndent[:len(traceIndent)-2]
 
 		// if we have a result, use that
@@ -76,11 +77,11 @@ const (
 // marks variables that escape the local frame.
 // rewrites n.Op to be more specific in some cases.
 
-var typecheckdefstack []*Node
+var typecheckdefstack []*ir.Node
 
 // resolve ONONAME to definition, if any.
-func resolve(n *Node) (res *Node) {
-	if n == nil || n.Op != ONONAME {
+func resolve(n *ir.Node) (res *ir.Node) {
+	if n == nil || n.Op != ir.ONONAME {
 		return n
 	}
 
@@ -89,7 +90,7 @@ func resolve(n *Node) (res *Node) {
 		defer tracePrint("resolve", n)(&res)
 	}
 
-	if n.Sym.Pkg != localpkg {
+	if n.Sym.Pkg != ir.LocalPkg {
 		if inimport {
 			base.Fatalf("recursive inimport")
 		}
@@ -99,12 +100,12 @@ func resolve(n *Node) (res *Node) {
 		return n
 	}
 
-	r := asNode(n.Sym.Def)
+	r := ir.AsNode(n.Sym.Def)
 	if r == nil {
 		return n
 	}
 
-	if r.Op == OIOTA {
+	if r.Op == ir.OIOTA {
 		if x := getIotaValue(); x >= 0 {
 			return nodintconst(x)
 		}
@@ -114,41 +115,41 @@ func resolve(n *Node) (res *Node) {
 	return r
 }
 
-func typecheckslice(l []*Node, top int) {
+func typecheckslice(l []*ir.Node, top int) {
 	for i := range l {
 		l[i] = typecheck(l[i], top)
 	}
 }
 
 var _typekind = []string{
-	TINT:        "int",
-	TUINT:       "uint",
-	TINT8:       "int8",
-	TUINT8:      "uint8",
-	TINT16:      "int16",
-	TUINT16:     "uint16",
-	TINT32:      "int32",
-	TUINT32:     "uint32",
-	TINT64:      "int64",
-	TUINT64:     "uint64",
-	TUINTPTR:    "uintptr",
-	TCOMPLEX64:  "complex64",
-	TCOMPLEX128: "complex128",
-	TFLOAT32:    "float32",
-	TFLOAT64:    "float64",
-	TBOOL:       "bool",
-	TSTRING:     "string",
-	TPTR:        "pointer",
-	TUNSAFEPTR:  "unsafe.Pointer",
-	TSTRUCT:     "struct",
-	TINTER:      "interface",
-	TCHAN:       "chan",
-	TMAP:        "map",
-	TARRAY:      "array",
-	TSLICE:      "slice",
-	TFUNC:       "func",
-	TNIL:        "nil",
-	TIDEAL:      "untyped number",
+	types.TINT:        "int",
+	types.TUINT:       "uint",
+	types.TINT8:       "int8",
+	types.TUINT8:      "uint8",
+	types.TINT16:      "int16",
+	types.TUINT16:     "uint16",
+	types.TINT32:      "int32",
+	types.TUINT32:     "uint32",
+	types.TINT64:      "int64",
+	types.TUINT64:     "uint64",
+	types.TUINTPTR:    "uintptr",
+	types.TCOMPLEX64:  "complex64",
+	types.TCOMPLEX128: "complex128",
+	types.TFLOAT32:    "float32",
+	types.TFLOAT64:    "float64",
+	types.TBOOL:       "bool",
+	types.TSTRING:     "string",
+	types.TPTR:        "pointer",
+	types.TUNSAFEPTR:  "unsafe.Pointer",
+	types.TSTRUCT:     "struct",
+	types.TINTER:      "interface",
+	types.TCHAN:       "chan",
+	types.TMAP:        "map",
+	types.TARRAY:      "array",
+	types.TSLICE:      "slice",
+	types.TFUNC:       "func",
+	types.TNIL:        "nil",
+	types.TIDEAL:      "untyped number",
 }
 
 func typekind(t *types.Type) string {
@@ -165,7 +166,7 @@ func typekind(t *types.Type) string {
 	return fmt.Sprintf("etype=%d", et)
 }
 
-func cycleFor(start *Node) []*Node {
+func cycleFor(start *ir.Node) []*ir.Node {
 	// Find the start node in typecheck_tcstack.
 	// We know that it must exist because each time we mark
 	// a node with n.SetTypecheck(2) we push it on the stack,
@@ -178,7 +179,7 @@ func cycleFor(start *Node) []*Node {
 	}
 
 	// collect all nodes with same Op
-	var cycle []*Node
+	var cycle []*ir.Node
 	for _, n := range typecheck_tcstack[i:] {
 		if n.Op == start.Op {
 			cycle = append(cycle, n)
@@ -188,20 +189,20 @@ func cycleFor(start *Node) []*Node {
 	return cycle
 }
 
-func cycleTrace(cycle []*Node) string {
+func cycleTrace(cycle []*ir.Node) string {
 	var s string
 	for i, n := range cycle {
-		s += fmt.Sprintf("\n\t%v: %v uses %v", n.Line(), n, cycle[(i+1)%len(cycle)])
+		s += fmt.Sprintf("\n\t%v: %v uses %v", ir.Line(n), n, cycle[(i+1)%len(cycle)])
 	}
 	return s
 }
 
-var typecheck_tcstack []*Node
+var typecheck_tcstack []*ir.Node
 
 // typecheck type checks node n.
 // The result of typecheck MUST be assigned back to n, e.g.
 // 	n.Left = typecheck(n.Left, top)
-func typecheck(n *Node, top int) (res *Node) {
+func typecheck(n *ir.Node, top int) (res *ir.Node) {
 	// cannot type check until all the source has been parsed
 	if !typecheckok {
 		base.Fatalf("early typecheck")
@@ -219,7 +220,7 @@ func typecheck(n *Node, top int) (res *Node) {
 	lno := setlineno(n)
 
 	// Skip over parens.
-	for n.Op == OPAREN {
+	for n.Op == ir.OPAREN {
 		n = n.Left
 	}
 
@@ -230,7 +231,7 @@ func typecheck(n *Node, top int) (res *Node) {
 	// But re-typecheck ONAME/OTYPE/OLITERAL/OPACK node in case context has changed.
 	if n.Typecheck() == 1 {
 		switch n.Op {
-		case ONAME, OTYPE, OLITERAL, OPACK:
+		case ir.ONAME, ir.OTYPE, ir.OLITERAL, ir.OPACK:
 			break
 
 		default:
@@ -244,12 +245,12 @@ func typecheck(n *Node, top int) (res *Node) {
 		// otherwise a stack trace of typechecking.
 		switch n.Op {
 		// We can already diagnose variables used as types.
-		case ONAME:
+		case ir.ONAME:
 			if top&(ctxExpr|ctxType) == ctxType {
 				base.Errorf("%v is not a type", n)
 			}
 
-		case OTYPE:
+		case ir.OTYPE:
 			// Only report a type cycle if we are expecting a type.
 			// Otherwise let other code report an error.
 			if top&ctxType == ctxType {
@@ -274,7 +275,7 @@ func typecheck(n *Node, top int) (res *Node) {
 				base.ErrorfAt(n.Pos, "invalid recursive type alias %v%s", n, cycleTrace(cycle))
 			}
 
-		case OLITERAL:
+		case ir.OLITERAL:
 			if top&(ctxExpr|ctxType) == ctxType {
 				base.Errorf("%v is not a type", n)
 				break
@@ -286,7 +287,7 @@ func typecheck(n *Node, top int) (res *Node) {
 			var trace string
 			for i := len(typecheck_tcstack) - 1; i >= 0; i-- {
 				x := typecheck_tcstack[i]
-				trace += fmt.Sprintf("\n\t%v %v", x.Line(), x)
+				trace += fmt.Sprintf("\n\t%v %v", ir.Line(x), x)
 			}
 			base.Errorf("typechecking loop involving %v%s", n, trace)
 		}
@@ -316,34 +317,34 @@ func typecheck(n *Node, top int) (res *Node) {
 // value of type int (see also checkmake for comparison).
 // The result of indexlit MUST be assigned back to n, e.g.
 // 	n.Left = indexlit(n.Left)
-func indexlit(n *Node) *Node {
-	if n != nil && n.Type != nil && n.Type.Etype == TIDEAL {
-		return defaultlit(n, types.Types[TINT])
+func indexlit(n *ir.Node) *ir.Node {
+	if n != nil && n.Type != nil && n.Type.Etype == types.TIDEAL {
+		return defaultlit(n, types.Types[types.TINT])
 	}
 	return n
 }
 
 // The result of typecheck1 MUST be assigned back to n, e.g.
 // 	n.Left = typecheck1(n.Left, top)
-func typecheck1(n *Node, top int) (res *Node) {
+func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheck1", n)(&res)
 	}
 
 	switch n.Op {
-	case OLITERAL, ONAME, ONONAME, OTYPE:
+	case ir.OLITERAL, ir.ONAME, ir.ONONAME, ir.OTYPE:
 		if n.Sym == nil {
 			break
 		}
 
-		if n.Op == ONAME && n.SubOp() != 0 && top&ctxCallee == 0 {
+		if n.Op == ir.ONAME && n.SubOp() != 0 && top&ctxCallee == 0 {
 			base.Errorf("use of builtin %v not in function call", n.Sym)
 			n.Type = nil
 			return n
 		}
 
 		typecheckdef(n)
-		if n.Op == ONONAME {
+		if n.Op == ir.ONONAME {
 			n.Type = nil
 			return n
 		}
@@ -353,22 +354,22 @@ func typecheck1(n *Node, top int) (res *Node) {
 	switch n.Op {
 	// until typecheck is complete, do nothing.
 	default:
-		Dump("typecheck", n)
+		ir.Dump("typecheck", n)
 
 		base.Fatalf("typecheck %v", n.Op)
 
 	// names
-	case OLITERAL:
+	case ir.OLITERAL:
 		ok |= ctxExpr
 
 		if n.Type == nil && n.Val().Kind() == constant.String {
 			base.Fatalf("string literal missing type")
 		}
 
-	case ONIL, ONONAME:
+	case ir.ONIL, ir.ONONAME:
 		ok |= ctxExpr
 
-	case ONAME:
+	case ir.ONAME:
 		if n.Name.Decldepth == 0 {
 			n.Name.Decldepth = decldepth
 		}
@@ -379,7 +380,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 		if top&ctxAssign == 0 {
 			// not a write to the variable
-			if n.isBlank() {
+			if ir.IsBlank(n) {
 				base.Errorf("cannot use _ as value")
 				n.Type = nil
 				return n
@@ -390,23 +391,23 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 		ok |= ctxExpr
 
-	case OPACK:
+	case ir.OPACK:
 		base.Errorf("use of package %v without selector", n.Sym)
 		n.Type = nil
 		return n
 
-	case ODDD:
+	case ir.ODDD:
 		break
 
 	// types (ODEREF is with exprs)
-	case OTYPE:
+	case ir.OTYPE:
 		ok |= ctxType
 
 		if n.Type == nil {
 			return n
 		}
 
-	case OTARRAY:
+	case ir.OTARRAY:
 		ok |= ctxType
 		r := typecheck(n.Right, ctxType)
 		if r.Type == nil {
@@ -417,7 +418,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		var t *types.Type
 		if n.Left == nil {
 			t = types.NewSlice(r.Type)
-		} else if n.Left.Op == ODDD {
+		} else if n.Left.Op == ir.ODDD {
 			if !n.Diag() {
 				n.SetDiag(true)
 				base.Errorf("use of [...] array outside of array literal")
@@ -427,11 +428,11 @@ func typecheck1(n *Node, top int) (res *Node) {
 		} else {
 			n.Left = indexlit(typecheck(n.Left, ctxExpr))
 			l := n.Left
-			if consttype(l) != constant.Int {
+			if ir.ConstType(l) != constant.Int {
 				switch {
 				case l.Type == nil:
 					// Error already reported elsewhere.
-				case l.Type.IsInteger() && l.Op != OLITERAL:
+				case l.Type.IsInteger() && l.Op != ir.OLITERAL:
 					base.Errorf("non-constant array bound %v", l)
 				default:
 					base.Errorf("invalid array bound %v", l)
@@ -441,7 +442,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			}
 
 			v := l.Val()
-			if doesoverflow(v, types.Types[TINT]) {
+			if doesoverflow(v, types.Types[types.TINT]) {
 				base.Errorf("array bound is too large")
 				n.Type = nil
 				return n
@@ -462,7 +463,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		n.Right = nil
 		checkwidth(t)
 
-	case OTMAP:
+	case ir.OTMAP:
 		ok |= ctxType
 		n.Left = typecheck(n.Left, ctxType)
 		n.Right = typecheck(n.Right, ctxType)
@@ -484,7 +485,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		n.Left = nil
 		n.Right = nil
 
-	case OTCHAN:
+	case ir.OTCHAN:
 		ok |= ctxType
 		n.Left = typecheck(n.Left, ctxType)
 		l := n.Left
@@ -500,16 +501,16 @@ func typecheck1(n *Node, top int) (res *Node) {
 		n.Left = nil
 		n.ResetAux()
 
-	case OTSTRUCT:
+	case ir.OTSTRUCT:
 		ok |= ctxType
 		setTypeNode(n, tostruct(n.List.Slice()))
 		n.List.Set(nil)
 
-	case OTINTER:
+	case ir.OTINTER:
 		ok |= ctxType
 		setTypeNode(n, tointerface(n.List.Slice()))
 
-	case OTFUNC:
+	case ir.OTFUNC:
 		ok |= ctxType
 		setTypeNode(n, functype(n.Left, n.List.Slice(), n.Rlist.Slice()))
 		n.Left = nil
@@ -517,7 +518,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		n.Rlist.Set(nil)
 
 	// type or expr
-	case ODEREF:
+	case ir.ODEREF:
 		n.Left = typecheck(n.Left, ctxExpr|ctxType)
 		l := n.Left
 		t := l.Type
@@ -525,7 +526,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			n.Type = nil
 			return n
 		}
-		if l.Op == OTYPE {
+		if l.Op == ir.OTYPE {
 			ok |= ctxType
 			setTypeNode(n, types.NewPtr(l.Type))
 			n.Left = nil
@@ -548,30 +549,30 @@ func typecheck1(n *Node, top int) (res *Node) {
 		n.Type = t.Elem()
 
 	// arithmetic exprs
-	case OASOP,
-		OADD,
-		OAND,
-		OANDAND,
-		OANDNOT,
-		ODIV,
-		OEQ,
-		OGE,
-		OGT,
-		OLE,
-		OLT,
-		OLSH,
-		ORSH,
-		OMOD,
-		OMUL,
-		ONE,
-		OOR,
-		OOROR,
-		OSUB,
-		OXOR:
-		var l *Node
-		var op Op
-		var r *Node
-		if n.Op == OASOP {
+	case ir.OASOP,
+		ir.OADD,
+		ir.OAND,
+		ir.OANDAND,
+		ir.OANDNOT,
+		ir.ODIV,
+		ir.OEQ,
+		ir.OGE,
+		ir.OGT,
+		ir.OLE,
+		ir.OLT,
+		ir.OLSH,
+		ir.ORSH,
+		ir.OMOD,
+		ir.OMUL,
+		ir.ONE,
+		ir.OOR,
+		ir.OOROR,
+		ir.OSUB,
+		ir.OXOR:
+		var l *ir.Node
+		var op ir.Op
+		var r *ir.Node
+		if n.Op == ir.OASOP {
 			ok |= ctxStmt
 			n.Left = typecheck(n.Left, ctxExpr)
 			n.Right = typecheck(n.Right, ctxExpr)
@@ -601,8 +602,8 @@ func typecheck1(n *Node, top int) (res *Node) {
 			}
 			op = n.Op
 		}
-		if op == OLSH || op == ORSH {
-			r = defaultlit(r, types.Types[TUINT])
+		if op == ir.OLSH || op == ir.ORSH {
+			r = defaultlit(r, types.Types[types.TUINT])
 			n.Right = r
 			t := r.Type
 			if !t.IsInteger() {
@@ -616,7 +617,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 				return n
 			}
 			t = l.Type
-			if t != nil && t.Etype != TIDEAL && !t.IsInteger() {
+			if t != nil && t.Etype != types.TIDEAL && !t.IsInteger() {
 				base.Errorf("invalid operation: %v (shift of type %v)", n, t)
 				n.Type = nil
 				return n
@@ -625,7 +626,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			// no defaultlit for left
 			// the outer context gives the type
 			n.Type = l.Type
-			if (l.Type == types.UntypedFloat || l.Type == types.UntypedComplex) && r.Op == OLITERAL {
+			if (l.Type == types.UntypedFloat || l.Type == types.UntypedComplex) && r.Op == ir.OLITERAL {
 				n.Type = types.UntypedInt
 			}
 
@@ -635,7 +636,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		// For "x == x && len(s)", it's better to report that "len(s)" (type int)
 		// can't be used with "&&" than to report that "x == x" (type untyped bool)
 		// can't be converted to int (see issue #41500).
-		if n.Op == OANDAND || n.Op == OOROR {
+		if n.Op == ir.OANDAND || n.Op == ir.OOROR {
 			if !n.Left.Type.IsBoolean() {
 				base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op, typekind(n.Left.Type))
 				n.Type = nil
@@ -658,15 +659,15 @@ func typecheck1(n *Node, top int) (res *Node) {
 			return n
 		}
 		t := l.Type
-		if t.Etype == TIDEAL {
+		if t.Etype == types.TIDEAL {
 			t = r.Type
 		}
 		et := t.Etype
-		if et == TIDEAL {
-			et = TINT
+		if et == types.TIDEAL {
+			et = types.TINT
 		}
-		aop := OXXX
-		if iscmp[n.Op] && t.Etype != TIDEAL && !types.Identical(l.Type, r.Type) {
+		aop := ir.OXXX
+		if iscmp[n.Op] && t.Etype != types.TIDEAL && !types.Identical(l.Type, r.Type) {
 			// comparison is okay as long as one side is
 			// assignable to the other.  convert so they have
 			// the same type.
@@ -675,9 +676,9 @@ func typecheck1(n *Node, top int) (res *Node) {
 			// in that case, check comparability of the concrete type.
 			// The conversion allocates, so only do it if the concrete type is huge.
 			converted := false
-			if r.Type.Etype != TBLANK {
+			if r.Type.Etype != types.TBLANK {
 				aop, _ = assignop(l.Type, r.Type)
-				if aop != OXXX {
+				if aop != ir.OXXX {
 					if r.Type.IsInterface() && !l.Type.IsInterface() && !IsComparable(l.Type) {
 						base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(l.Type))
 						n.Type = nil
@@ -686,7 +687,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 					dowidth(l.Type)
 					if r.Type.IsInterface() == l.Type.IsInterface() || l.Type.Width >= 1<<16 {
-						l = nod(aop, l, nil)
+						l = ir.Nod(aop, l, nil)
 						l.Type = r.Type
 						l.SetTypecheck(1)
 						n.Left = l
@@ -697,9 +698,9 @@ func typecheck1(n *Node, top int) (res *Node) {
 				}
 			}
 
-			if !converted && l.Type.Etype != TBLANK {
+			if !converted && l.Type.Etype != types.TBLANK {
 				aop, _ = assignop(r.Type, l.Type)
-				if aop != OXXX {
+				if aop != ir.OXXX {
 					if l.Type.IsInterface() && !r.Type.IsInterface() && !IsComparable(r.Type) {
 						base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(r.Type))
 						n.Type = nil
@@ -708,7 +709,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 					dowidth(r.Type)
 					if r.Type.IsInterface() == l.Type.IsInterface() || r.Type.Width >= 1<<16 {
-						r = nod(aop, r, nil)
+						r = ir.Nod(aop, r, nil)
 						r.Type = l.Type
 						r.SetTypecheck(1)
 						n.Right = r
@@ -721,7 +722,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			et = t.Etype
 		}
 
-		if t.Etype != TIDEAL && !types.Identical(l.Type, r.Type) {
+		if t.Etype != types.TIDEAL && !types.Identical(l.Type, r.Type) {
 			l, r = defaultlit2(l, r, true)
 			if l.Type == nil || r.Type == nil {
 				n.Type = nil
@@ -734,7 +735,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			}
 		}
 
-		if t.Etype == TIDEAL {
+		if t.Etype == types.TIDEAL {
 			t = mixUntyped(l.Type, r.Type)
 		}
 		if dt := defaultType(t); !okfor[op][dt.Etype] {
@@ -751,19 +752,19 @@ func typecheck1(n *Node, top int) (res *Node) {
 			return n
 		}
 
-		if l.Type.IsSlice() && !l.isNil() && !r.isNil() {
+		if l.Type.IsSlice() && !ir.IsNil(l) && !ir.IsNil(r) {
 			base.Errorf("invalid operation: %v (slice can only be compared to nil)", n)
 			n.Type = nil
 			return n
 		}
 
-		if l.Type.IsMap() && !l.isNil() && !r.isNil() {
+		if l.Type.IsMap() && !ir.IsNil(l) && !ir.IsNil(r) {
 			base.Errorf("invalid operation: %v (map can only be compared to nil)", n)
 			n.Type = nil
 			return n
 		}
 
-		if l.Type.Etype == TFUNC && !l.isNil() && !r.isNil() {
+		if l.Type.Etype == types.TFUNC && !ir.IsNil(l) && !ir.IsNil(r) {
 			base.Errorf("invalid operation: %v (func can only be compared to nil)", n)
 			n.Type = nil
 			return n
@@ -781,31 +782,31 @@ func typecheck1(n *Node, top int) (res *Node) {
 			t = types.UntypedBool
 			n.Type = t
 			n = evalConst(n)
-			if n.Op != OLITERAL {
+			if n.Op != ir.OLITERAL {
 				l, r = defaultlit2(l, r, true)
 				n.Left = l
 				n.Right = r
 			}
 		}
 
-		if et == TSTRING && n.Op == OADD {
+		if et == types.TSTRING && n.Op == ir.OADD {
 			// create or update OADDSTR node with list of strings in x + y + z + (w + v) + ...
-			if l.Op == OADDSTR {
+			if l.Op == ir.OADDSTR {
 				orig := n
 				n = l
 				n.Pos = orig.Pos
 			} else {
-				n = nodl(n.Pos, OADDSTR, nil, nil)
+				n = ir.NodAt(n.Pos, ir.OADDSTR, nil, nil)
 				n.List.Set1(l)
 			}
-			if r.Op == OADDSTR {
+			if r.Op == ir.OADDSTR {
 				n.List.AppendNodes(&r.List)
 			} else {
 				n.List.Append(r)
 			}
 		}
 
-		if (op == ODIV || op == OMOD) && Isconst(r, constant.Int) {
+		if (op == ir.ODIV || op == ir.OMOD) && ir.IsConst(r, constant.Int) {
 			if constant.Sign(r.Val()) == 0 {
 				base.Errorf("division by zero")
 				n.Type = nil
@@ -815,7 +816,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 		n.Type = t
 
-	case OBITNOT, ONEG, ONOT, OPLUS:
+	case ir.OBITNOT, ir.ONEG, ir.ONOT, ir.OPLUS:
 		ok |= ctxExpr
 		n.Left = typecheck(n.Left, ctxExpr)
 		l := n.Left
@@ -833,7 +834,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		n.Type = t
 
 	// exprs
-	case OADDR:
+	case ir.OADDR:
 		ok |= ctxExpr
 
 		n.Left = typecheck(n.Left, ctxExpr)
@@ -843,13 +844,13 @@ func typecheck1(n *Node, top int) (res *Node) {
 		}
 
 		switch n.Left.Op {
-		case OARRAYLIT, OMAPLIT, OSLICELIT, OSTRUCTLIT:
-			n.Op = OPTRLIT
+		case ir.OARRAYLIT, ir.OMAPLIT, ir.OSLICELIT, ir.OSTRUCTLIT:
+			n.Op = ir.OPTRLIT
 
 		default:
 			checklvalue(n.Left, "take the address of")
 			r := outervalue(n.Left)
-			if r.Op == ONAME {
+			if r.Op == ir.ONAME {
 				if r.Orig != r {
 					base.Fatalf("found non-orig name node %v", r) // TODO(mdempsky): What does this mean?
 				}
@@ -871,17 +872,17 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 		n.Type = types.NewPtr(n.Left.Type)
 
-	case OCOMPLIT:
+	case ir.OCOMPLIT:
 		ok |= ctxExpr
 		n = typecheckcomplit(n)
 		if n.Type == nil {
 			return n
 		}
 
-	case OXDOT, ODOT:
-		if n.Op == OXDOT {
+	case ir.OXDOT, ir.ODOT:
+		if n.Op == ir.OXDOT {
 			n = adddot(n)
-			n.Op = ODOT
+			n.Op = ir.ODOT
 			if n.Left == nil {
 				n.Type = nil
 				return n
@@ -894,14 +895,14 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 		t := n.Left.Type
 		if t == nil {
-			base.UpdateErrorDot(n.Line(), n.Left.String(), n.String())
+			base.UpdateErrorDot(ir.Line(n), n.Left.String(), n.String())
 			n.Type = nil
 			return n
 		}
 
 		s := n.Sym
 
-		if n.Left.Op == OTYPE {
+		if n.Left.Op == ir.OTYPE {
 			n = typecheckMethodExpr(n)
 			if n.Type == nil {
 				return n
@@ -916,7 +917,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 				n.Type = nil
 				return n
 			}
-			n.Op = ODOTPTR
+			n.Op = ir.ODOTPTR
 			checkwidth(t)
 		}
 
@@ -952,7 +953,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		}
 
 		switch n.Op {
-		case ODOTINTER, ODOTMETH:
+		case ir.ODOTINTER, ir.ODOTMETH:
 			if top&ctxCallee != 0 {
 				ok |= ctxCallee
 			} else {
@@ -964,7 +965,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			ok |= ctxExpr
 		}
 
-	case ODOTTYPE:
+	case ir.ODOTTYPE:
 		ok |= ctxExpr
 		n.Left = typecheck(n.Left, ctxExpr)
 		n.Left = defaultlit(n.Left, nil)
@@ -1009,7 +1010,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			}
 		}
 
-	case OINDEX:
+	case ir.OINDEX:
 		ok |= ctxExpr
 		n.Left = typecheck(n.Left, ctxExpr)
 		n.Left = defaultlit(n.Left, nil)
@@ -1028,7 +1029,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			n.Type = nil
 			return n
 
-		case TSTRING, TARRAY, TSLICE:
+		case types.TSTRING, types.TARRAY, types.TSLICE:
 			n.Right = indexlit(n.Right)
 			if t.IsString() {
 				n.Type = types.Bytetype
@@ -1047,27 +1048,27 @@ func typecheck1(n *Node, top int) (res *Node) {
 				break
 			}
 
-			if !n.Bounded() && Isconst(n.Right, constant.Int) {
+			if !n.Bounded() && ir.IsConst(n.Right, constant.Int) {
 				x := n.Right.Val()
 				if constant.Sign(x) < 0 {
 					base.Errorf("invalid %s index %v (index must be non-negative)", why, n.Right)
 				} else if t.IsArray() && constant.Compare(x, token.GEQ, constant.MakeInt64(t.NumElem())) {
 					base.Errorf("invalid array index %v (out of bounds for %d-element array)", n.Right, t.NumElem())
-				} else if Isconst(n.Left, constant.String) && constant.Compare(x, token.GEQ, constant.MakeInt64(int64(len(n.Left.StringVal())))) {
+				} else if ir.IsConst(n.Left, constant.String) && constant.Compare(x, token.GEQ, constant.MakeInt64(int64(len(n.Left.StringVal())))) {
 					base.Errorf("invalid string index %v (out of bounds for %d-byte string)", n.Right, len(n.Left.StringVal()))
-				} else if doesoverflow(x, types.Types[TINT]) {
+				} else if doesoverflow(x, types.Types[types.TINT]) {
 					base.Errorf("invalid %s index %v (index too large)", why, n.Right)
 				}
 			}
 
-		case TMAP:
+		case types.TMAP:
 			n.Right = assignconv(n.Right, t.Key(), "map index")
 			n.Type = t.Elem()
-			n.Op = OINDEXMAP
+			n.Op = ir.OINDEXMAP
 			n.ResetAux()
 		}
 
-	case ORECV:
+	case ir.ORECV:
 		ok |= ctxStmt | ctxExpr
 		n.Left = typecheck(n.Left, ctxExpr)
 		n.Left = defaultlit(n.Left, nil)
@@ -1091,7 +1092,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 		n.Type = t.Elem()
 
-	case OSEND:
+	case ir.OSEND:
 		ok |= ctxStmt
 		n.Left = typecheck(n.Left, ctxExpr)
 		n.Right = typecheck(n.Right, ctxExpr)
@@ -1120,7 +1121,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		}
 		n.Type = nil
 
-	case OSLICEHEADER:
+	case ir.OSLICEHEADER:
 		// Errors here are Fatalf instead of Errorf because only the compiler
 		// can construct an OSLICEHEADER node.
 		// Components used in OSLICEHEADER that are supplied by parsed source code
@@ -1147,25 +1148,25 @@ func typecheck1(n *Node, top int) (res *Node) {
 		n.Left = typecheck(n.Left, ctxExpr)
 		l := typecheck(n.List.First(), ctxExpr)
 		c := typecheck(n.List.Second(), ctxExpr)
-		l = defaultlit(l, types.Types[TINT])
-		c = defaultlit(c, types.Types[TINT])
+		l = defaultlit(l, types.Types[types.TINT])
+		c = defaultlit(c, types.Types[types.TINT])
 
-		if Isconst(l, constant.Int) && l.Int64Val() < 0 {
+		if ir.IsConst(l, constant.Int) && l.Int64Val() < 0 {
 			base.Fatalf("len for OSLICEHEADER must be non-negative")
 		}
 
-		if Isconst(c, constant.Int) && c.Int64Val() < 0 {
+		if ir.IsConst(c, constant.Int) && c.Int64Val() < 0 {
 			base.Fatalf("cap for OSLICEHEADER must be non-negative")
 		}
 
-		if Isconst(l, constant.Int) && Isconst(c, constant.Int) && constant.Compare(l.Val(), token.GTR, c.Val()) {
+		if ir.IsConst(l, constant.Int) && ir.IsConst(c, constant.Int) && constant.Compare(l.Val(), token.GTR, c.Val()) {
 			base.Fatalf("len larger than cap for OSLICEHEADER")
 		}
 
 		n.List.SetFirst(l)
 		n.List.SetSecond(c)
 
-	case OMAKESLICECOPY:
+	case ir.OMAKESLICECOPY:
 		// Errors here are Fatalf instead of Errorf because only the compiler
 		// can construct an OMAKESLICECOPY node.
 		// Components used in OMAKESCLICECOPY that are supplied by parsed source code
@@ -1193,14 +1194,14 @@ func typecheck1(n *Node, top int) (res *Node) {
 		n.Left = typecheck(n.Left, ctxExpr)
 		n.Right = typecheck(n.Right, ctxExpr)
 
-		n.Left = defaultlit(n.Left, types.Types[TINT])
+		n.Left = defaultlit(n.Left, types.Types[types.TINT])
 
-		if !n.Left.Type.IsInteger() && n.Type.Etype != TIDEAL {
+		if !n.Left.Type.IsInteger() && n.Type.Etype != types.TIDEAL {
 			base.Errorf("non-integer len argument in OMAKESLICECOPY")
 		}
 
-		if Isconst(n.Left, constant.Int) {
-			if doesoverflow(n.Left.Val(), types.Types[TINT]) {
+		if ir.IsConst(n.Left, constant.Int) {
+			if doesoverflow(n.Left.Val(), types.Types[types.TINT]) {
 				base.Fatalf("len for OMAKESLICECOPY too large")
 			}
 			if constant.Sign(n.Left.Val()) < 0 {
@@ -1208,7 +1209,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			}
 		}
 
-	case OSLICE, OSLICE3:
+	case ir.OSLICE, ir.OSLICE3:
 		ok |= ctxExpr
 		n.Left = typecheck(n.Left, ctxExpr)
 		low, high, max := n.SliceBounds()
@@ -1233,7 +1234,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 				return n
 			}
 
-			n.Left = nod(OADDR, n.Left, nil)
+			n.Left = ir.Nod(ir.OADDR, n.Left, nil)
 			n.Left.SetImplicit(true)
 			n.Left = typecheck(n.Left, ctxExpr)
 			l = n.Left
@@ -1247,15 +1248,15 @@ func typecheck1(n *Node, top int) (res *Node) {
 				return n
 			}
 			n.Type = t
-			n.Op = OSLICESTR
+			n.Op = ir.OSLICESTR
 		} else if t.IsPtr() && t.Elem().IsArray() {
 			tp = t.Elem()
 			n.Type = types.NewSlice(tp.Elem())
 			dowidth(n.Type)
 			if hasmax {
-				n.Op = OSLICE3ARR
+				n.Op = ir.OSLICE3ARR
 			} else {
-				n.Op = OSLICEARR
+				n.Op = ir.OSLICEARR
 			}
 		} else if t.IsSlice() {
 			n.Type = t
@@ -1283,7 +1284,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		}
 
 	// call and call like
-	case OCALL:
+	case ir.OCALL:
 		typecheckslice(n.Ninit.Slice(), ctxStmt) // imported rewritten f(g()) calls (#30907)
 		n.Left = typecheck(n.Left, ctxExpr|ctxType|ctxCallee)
 		if n.Left.Diag() {
@@ -1292,8 +1293,8 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 		l := n.Left
 
-		if l.Op == ONAME && l.SubOp() != 0 {
-			if n.IsDDD() && l.SubOp() != OAPPEND {
+		if l.Op == ir.ONAME && l.SubOp() != 0 {
+			if n.IsDDD() && l.SubOp() != ir.OAPPEND {
 				base.Errorf("invalid use of ... with builtin %v", l)
 			}
 
@@ -1307,7 +1308,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 		n.Left = defaultlit(n.Left, nil)
 		l = n.Left
-		if l.Op == OTYPE {
+		if l.Op == ir.OTYPE {
 			if n.IsDDD() {
 				if !l.Type.Broke() {
 					base.Errorf("invalid use of ... in type conversion to %v", l.Type)
@@ -1321,7 +1322,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			// turn CALL(type, arg) into CONV(arg) w/ type
 			n.Left = nil
 
-			n.Op = OCONV
+			n.Op = ir.OCONV
 			n.Type = l.Type
 			if !onearg(n, "conversion to %v", l.Type) {
 				n.Type = nil
@@ -1340,11 +1341,11 @@ func typecheck1(n *Node, top int) (res *Node) {
 		checkwidth(t)
 
 		switch l.Op {
-		case ODOTINTER:
-			n.Op = OCALLINTER
+		case ir.ODOTINTER:
+			n.Op = ir.OCALLINTER
 
-		case ODOTMETH:
-			n.Op = OCALLMETH
+		case ir.ODOTMETH:
+			n.Op = ir.OCALLMETH
 
 			// typecheckaste was used here but there wasn't enough
 			// information further down the call chain to know if we
@@ -1357,8 +1358,8 @@ func typecheck1(n *Node, top int) (res *Node) {
 			}
 
 		default:
-			n.Op = OCALLFUNC
-			if t.Etype != TFUNC {
+			n.Op = ir.OCALLFUNC
+			if t.Etype != types.TFUNC {
 				name := l.String()
 				if isBuiltinFuncName(name) && l.Name.Defn != nil {
 					// be more specific when the function
@@ -1373,7 +1374,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			}
 		}
 
-		typecheckaste(OCALL, n.Left, n.IsDDD(), t.Params(), n.List, func() string { return fmt.Sprintf("argument to %v", n.Left) })
+		typecheckaste(ir.OCALL, n.Left, n.IsDDD(), t.Params(), n.List, func() string { return fmt.Sprintf("argument to %v", n.Left) })
 		ok |= ctxStmt
 		if t.NumResults() == 0 {
 			break
@@ -1382,14 +1383,14 @@ func typecheck1(n *Node, top int) (res *Node) {
 		if t.NumResults() == 1 {
 			n.Type = l.Type.Results().Field(0).Type
 
-			if n.Op == OCALLFUNC && n.Left.Op == ONAME && isRuntimePkg(n.Left.Sym.Pkg) && n.Left.Sym.Name == "getg" {
+			if n.Op == ir.OCALLFUNC && n.Left.Op == ir.ONAME && isRuntimePkg(n.Left.Sym.Pkg) && n.Left.Sym.Name == "getg" {
 				// Emit code for runtime.getg() directly instead of calling function.
 				// Most such rewrites (for example the similar one for math.Sqrt) should be done in walk,
 				// so that the ordering pass can make sure to preserve the semantics of the original code
 				// (in particular, the exact time of the function call) by introducing temporaries.
 				// In this case, we know getg() always returns the same result within a given function
 				// and we want to avoid the temporaries, so we do the rewrite earlier than is typical.
-				n.Op = OGETG
+				n.Op = ir.OGETG
 			}
 
 			break
@@ -1403,15 +1404,15 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 		n.Type = l.Type.Results()
 
-	case OALIGNOF, OOFFSETOF, OSIZEOF:
+	case ir.OALIGNOF, ir.OOFFSETOF, ir.OSIZEOF:
 		ok |= ctxExpr
 		if !onearg(n, "%v", n.Op) {
 			n.Type = nil
 			return n
 		}
-		n.Type = types.Types[TUINTPTR]
+		n.Type = types.Types[types.TUINTPTR]
 
-	case OCAP, OLEN:
+	case ir.OCAP, ir.OLEN:
 		ok |= ctxExpr
 		if !onearg(n, "%v", n.Op) {
 			n.Type = nil
@@ -1429,7 +1430,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		}
 
 		var ok bool
-		if n.Op == OLEN {
+		if n.Op == ir.OLEN {
 			ok = okforlen[t.Etype]
 		} else {
 			ok = okforcap[t.Etype]
@@ -1440,9 +1441,9 @@ func typecheck1(n *Node, top int) (res *Node) {
 			return n
 		}
 
-		n.Type = types.Types[TINT]
+		n.Type = types.Types[types.TINT]
 
-	case OREAL, OIMAG:
+	case ir.OREAL, ir.OIMAG:
 		ok |= ctxExpr
 		if !onearg(n, "%v", n.Op) {
 			n.Type = nil
@@ -1459,19 +1460,19 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 		// Determine result type.
 		switch t.Etype {
-		case TIDEAL:
+		case types.TIDEAL:
 			n.Type = types.UntypedFloat
-		case TCOMPLEX64:
-			n.Type = types.Types[TFLOAT32]
-		case TCOMPLEX128:
-			n.Type = types.Types[TFLOAT64]
+		case types.TCOMPLEX64:
+			n.Type = types.Types[types.TFLOAT32]
+		case types.TCOMPLEX128:
+			n.Type = types.Types[types.TFLOAT64]
 		default:
 			base.Errorf("invalid argument %L for %v", l, n.Op)
 			n.Type = nil
 			return n
 		}
 
-	case OCOMPLEX:
+	case ir.OCOMPLEX:
 		ok |= ctxExpr
 		typecheckargs(n)
 		if !twoarg(n) {
@@ -1505,18 +1506,18 @@ func typecheck1(n *Node, top int) (res *Node) {
 			n.Type = nil
 			return n
 
-		case TIDEAL:
+		case types.TIDEAL:
 			t = types.UntypedComplex
 
-		case TFLOAT32:
-			t = types.Types[TCOMPLEX64]
+		case types.TFLOAT32:
+			t = types.Types[types.TCOMPLEX64]
 
-		case TFLOAT64:
-			t = types.Types[TCOMPLEX128]
+		case types.TFLOAT64:
+			t = types.Types[types.TCOMPLEX128]
 		}
 		n.Type = t
 
-	case OCLOSE:
+	case ir.OCLOSE:
 		if !onearg(n, "%v", n.Op) {
 			n.Type = nil
 			return n
@@ -1543,7 +1544,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 		ok |= ctxStmt
 
-	case ODELETE:
+	case ir.ODELETE:
 		ok |= ctxStmt
 		typecheckargs(n)
 		args := n.List
@@ -1575,7 +1576,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 		args.SetSecond(assignconv(r, l.Type.Key(), "delete"))
 
-	case OAPPEND:
+	case ir.OAPPEND:
 		ok |= ctxExpr
 		typecheckargs(n)
 		args := n.List
@@ -1593,7 +1594,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 		n.Type = t
 		if !t.IsSlice() {
-			if args.First().isNil() {
+			if ir.IsNil(args.First()) {
 				base.Errorf("first argument to append must be typed slice; have untyped nil")
 				n.Type = nil
 				return n
@@ -1617,8 +1618,8 @@ func typecheck1(n *Node, top int) (res *Node) {
 				return n
 			}
 
-			if t.Elem().IsKind(TUINT8) && args.Second().Type.IsString() {
-				args.SetSecond(defaultlit(args.Second(), types.Types[TSTRING]))
+			if t.Elem().IsKind(types.TUINT8) && args.Second().Type.IsString() {
+				args.SetSecond(defaultlit(args.Second(), types.Types[types.TSTRING]))
 				break
 			}
 
@@ -1635,14 +1636,14 @@ func typecheck1(n *Node, top int) (res *Node) {
 			checkwidth(as[i].Type) // ensure width is calculated for backend
 		}
 
-	case OCOPY:
+	case ir.OCOPY:
 		ok |= ctxStmt | ctxExpr
 		typecheckargs(n)
 		if !twoarg(n) {
 			n.Type = nil
 			return n
 		}
-		n.Type = types.Types[TINT]
+		n.Type = types.Types[types.TINT]
 		if n.Left.Type == nil || n.Right.Type == nil {
 			n.Type = nil
 			return n
@@ -1682,7 +1683,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			return n
 		}
 
-	case OCONV:
+	case ir.OCONV:
 		ok |= ctxExpr
 		checkwidth(n.Type) // ensure width is calculated for backend
 		n.Left = typecheck(n.Left, ctxExpr)
@@ -1692,41 +1693,41 @@ func typecheck1(n *Node, top int) (res *Node) {
 			n.Type = nil
 			return n
 		}
-		op, why := convertop(n.Left.Op == OLITERAL, t, n.Type)
+		op, why := convertop(n.Left.Op == ir.OLITERAL, t, n.Type)
 		n.Op = op
-		if n.Op == OXXX {
+		if n.Op == ir.OXXX {
 			if !n.Diag() && !n.Type.Broke() && !n.Left.Diag() {
 				base.Errorf("cannot convert %L to type %v%s", n.Left, n.Type, why)
 				n.SetDiag(true)
 			}
-			n.Op = OCONV
+			n.Op = ir.OCONV
 			n.Type = nil
 			return n
 		}
 
 		switch n.Op {
-		case OCONVNOP:
+		case ir.OCONVNOP:
 			if t.Etype == n.Type.Etype {
 				switch t.Etype {
-				case TFLOAT32, TFLOAT64, TCOMPLEX64, TCOMPLEX128:
+				case types.TFLOAT32, types.TFLOAT64, types.TCOMPLEX64, types.TCOMPLEX128:
 					// Floating point casts imply rounding and
 					// so the conversion must be kept.
-					n.Op = OCONV
+					n.Op = ir.OCONV
 				}
 			}
 
 		// do not convert to []byte literal. See CL 125796.
 		// generated code and compiler memory footprint is better without it.
-		case OSTR2BYTES:
+		case ir.OSTR2BYTES:
 			break
 
-		case OSTR2RUNES:
-			if n.Left.Op == OLITERAL {
+		case ir.OSTR2RUNES:
+			if n.Left.Op == ir.OLITERAL {
 				n = stringtoruneslit(n)
 			}
 		}
 
-	case OMAKE:
+	case ir.OMAKE:
 		ok |= ctxExpr
 		args := n.List.Slice()
 		if len(args) == 0 {
@@ -1751,7 +1752,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			n.Type = nil
 			return n
 
-		case TSLICE:
+		case types.TSLICE:
 			if i >= len(args) {
 				base.Errorf("missing len argument to make(%v)", t)
 				n.Type = nil
@@ -1761,7 +1762,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 			l = args[i]
 			i++
 			l = typecheck(l, ctxExpr)
-			var r *Node
+			var r *ir.Node
 			if i < len(args) {
 				r = args[i]
 				i++
@@ -1776,7 +1777,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 				n.Type = nil
 				return n
 			}
-			if Isconst(l, constant.Int) && r != nil && Isconst(r, constant.Int) && constant.Compare(l.Val(), token.GTR, r.Val()) {
+			if ir.IsConst(l, constant.Int) && r != nil && ir.IsConst(r, constant.Int) && constant.Compare(l.Val(), token.GTR, r.Val()) {
 				base.Errorf("len larger than cap in make(%v)", t)
 				n.Type = nil
 				return n
@@ -1784,14 +1785,14 @@ func typecheck1(n *Node, top int) (res *Node) {
 
 			n.Left = l
 			n.Right = r
-			n.Op = OMAKESLICE
+			n.Op = ir.OMAKESLICE
 
-		case TMAP:
+		case types.TMAP:
 			if i < len(args) {
 				l = args[i]
 				i++
 				l = typecheck(l, ctxExpr)
-				l = defaultlit(l, types.Types[TINT])
+				l = defaultlit(l, types.Types[types.TINT])
 				if l.Type == nil {
 					n.Type = nil
 					return n
@@ -1804,15 +1805,15 @@ func typecheck1(n *Node, top int) (res *Node) {
 			} else {
 				n.Left = nodintconst(0)
 			}
-			n.Op = OMAKEMAP
+			n.Op = ir.OMAKEMAP
 
-		case TCHAN:
+		case types.TCHAN:
 			l = nil
 			if i < len(args) {
 				l = args[i]
 				i++
 				l = typecheck(l, ctxExpr)
-				l = defaultlit(l, types.Types[TINT])
+				l = defaultlit(l, types.Types[types.TINT])
 				if l.Type == nil {
 					n.Type = nil
 					return n
@@ -1825,19 +1826,19 @@ func typecheck1(n *Node, top int) (res *Node) {
 			} else {
 				n.Left = nodintconst(0)
 			}
-			n.Op = OMAKECHAN
+			n.Op = ir.OMAKECHAN
 		}
 
 		if i < len(args) {
 			base.Errorf("too many arguments to make(%v)", t)
-			n.Op = OMAKE
+			n.Op = ir.OMAKE
 			n.Type = nil
 			return n
 		}
 
 		n.Type = t
 
-	case ONEW:
+	case ir.ONEW:
 		ok |= ctxExpr
 		args := n.List
 		if args.Len() == 0 {
@@ -1862,33 +1863,33 @@ func typecheck1(n *Node, top int) (res *Node) {
 		n.Left = l
 		n.Type = types.NewPtr(t)
 
-	case OPRINT, OPRINTN:
+	case ir.OPRINT, ir.OPRINTN:
 		ok |= ctxStmt
 		typecheckargs(n)
 		ls := n.List.Slice()
 		for i1, n1 := range ls {
 			// Special case for print: int constant is int64, not int.
-			if Isconst(n1, constant.Int) {
-				ls[i1] = defaultlit(ls[i1], types.Types[TINT64])
+			if ir.IsConst(n1, constant.Int) {
+				ls[i1] = defaultlit(ls[i1], types.Types[types.TINT64])
 			} else {
 				ls[i1] = defaultlit(ls[i1], nil)
 			}
 		}
 
-	case OPANIC:
+	case ir.OPANIC:
 		ok |= ctxStmt
 		if !onearg(n, "panic") {
 			n.Type = nil
 			return n
 		}
 		n.Left = typecheck(n.Left, ctxExpr)
-		n.Left = defaultlit(n.Left, types.Types[TINTER])
+		n.Left = defaultlit(n.Left, types.Types[types.TINTER])
 		if n.Left.Type == nil {
 			n.Type = nil
 			return n
 		}
 
-	case ORECOVER:
+	case ir.ORECOVER:
 		ok |= ctxExpr | ctxStmt
 		if n.List.Len() != 0 {
 			base.Errorf("too many arguments to recover")
@@ -1896,16 +1897,16 @@ func typecheck1(n *Node, top int) (res *Node) {
 			return n
 		}
 
-		n.Type = types.Types[TINTER]
+		n.Type = types.Types[types.TINTER]
 
-	case OCLOSURE:
+	case ir.OCLOSURE:
 		ok |= ctxExpr
 		typecheckclosure(n, top)
 		if n.Type == nil {
 			return n
 		}
 
-	case OITAB:
+	case ir.OITAB:
 		ok |= ctxExpr
 		n.Left = typecheck(n.Left, ctxExpr)
 		t := n.Left.Type
@@ -1916,14 +1917,14 @@ func typecheck1(n *Node, top int) (res *Node) {
 		if !t.IsInterface() {
 			base.Fatalf("OITAB of %v", t)
 		}
-		n.Type = types.NewPtr(types.Types[TUINTPTR])
+		n.Type = types.NewPtr(types.Types[types.TUINTPTR])
 
-	case OIDATA:
+	case ir.OIDATA:
 		// Whoever creates the OIDATA node must know a priori the concrete type at that moment,
 		// usually by just having checked the OITAB.
 		base.Fatalf("cannot typecheck interface data %v", n)
 
-	case OSPTR:
+	case ir.OSPTR:
 		ok |= ctxExpr
 		n.Left = typecheck(n.Left, ctxExpr)
 		t := n.Left.Type
@@ -1935,72 +1936,72 @@ func typecheck1(n *Node, top int) (res *Node) {
 			base.Fatalf("OSPTR of %v", t)
 		}
 		if t.IsString() {
-			n.Type = types.NewPtr(types.Types[TUINT8])
+			n.Type = types.NewPtr(types.Types[types.TUINT8])
 		} else {
 			n.Type = types.NewPtr(t.Elem())
 		}
 
-	case OCLOSUREVAR:
+	case ir.OCLOSUREVAR:
 		ok |= ctxExpr
 
-	case OCFUNC:
+	case ir.OCFUNC:
 		ok |= ctxExpr
 		n.Left = typecheck(n.Left, ctxExpr)
-		n.Type = types.Types[TUINTPTR]
+		n.Type = types.Types[types.TUINTPTR]
 
-	case OCONVNOP:
+	case ir.OCONVNOP:
 		ok |= ctxExpr
 		n.Left = typecheck(n.Left, ctxExpr)
 
 	// statements
-	case OAS:
+	case ir.OAS:
 		ok |= ctxStmt
 
 		typecheckas(n)
 
 		// Code that creates temps does not bother to set defn, so do it here.
-		if n.Left.Op == ONAME && n.Left.IsAutoTmp() {
+		if n.Left.Op == ir.ONAME && n.Left.IsAutoTmp() {
 			n.Left.Name.Defn = n
 		}
 
-	case OAS2:
+	case ir.OAS2:
 		ok |= ctxStmt
 		typecheckas2(n)
 
-	case OBREAK,
-		OCONTINUE,
-		ODCL,
-		OEMPTY,
-		OGOTO,
-		OFALL,
-		OVARKILL,
-		OVARLIVE:
+	case ir.OBREAK,
+		ir.OCONTINUE,
+		ir.ODCL,
+		ir.OEMPTY,
+		ir.OGOTO,
+		ir.OFALL,
+		ir.OVARKILL,
+		ir.OVARLIVE:
 		ok |= ctxStmt
 
-	case OLABEL:
+	case ir.OLABEL:
 		ok |= ctxStmt
 		decldepth++
 		if n.Sym.IsBlank() {
 			// Empty identifier is valid but useless.
 			// Eliminate now to simplify life later.
 			// See issues 7538, 11589, 11593.
-			n.Op = OEMPTY
+			n.Op = ir.OEMPTY
 			n.Left = nil
 		}
 
-	case ODEFER:
+	case ir.ODEFER:
 		ok |= ctxStmt
 		n.Left = typecheck(n.Left, ctxStmt|ctxExpr)
 		if !n.Left.Diag() {
 			checkdefergo(n)
 		}
 
-	case OGO:
+	case ir.OGO:
 		ok |= ctxStmt
 		n.Left = typecheck(n.Left, ctxStmt|ctxExpr)
 		checkdefergo(n)
 
-	case OFOR, OFORUNTIL:
+	case ir.OFOR, ir.OFORUNTIL:
 		ok |= ctxStmt
 		typecheckslice(n.Ninit.Slice(), ctxStmt)
 		decldepth++
@@ -2013,13 +2014,13 @@ func typecheck1(n *Node, top int) (res *Node) {
 			}
 		}
 		n.Right = typecheck(n.Right, ctxStmt)
-		if n.Op == OFORUNTIL {
+		if n.Op == ir.OFORUNTIL {
 			typecheckslice(n.List.Slice(), ctxStmt)
 		}
 		typecheckslice(n.Nbody.Slice(), ctxStmt)
 		decldepth--
 
-	case OIF:
+	case ir.OIF:
 		ok |= ctxStmt
 		typecheckslice(n.Ninit.Slice(), ctxStmt)
 		n.Left = typecheck(n.Left, ctxExpr)
@@ -2033,7 +2034,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		typecheckslice(n.Nbody.Slice(), ctxStmt)
 		typecheckslice(n.Rlist.Slice(), ctxStmt)
 
-	case ORETURN:
+	case ir.ORETURN:
 		ok |= ctxStmt
 		typecheckargs(n)
 		if Curfn == nil {
@@ -2045,47 +2046,47 @@ func typecheck1(n *Node, top int) (res *Node) {
 		if Curfn.Type.FuncType().Outnamed && n.List.Len() == 0 {
 			break
 		}
-		typecheckaste(ORETURN, nil, false, Curfn.Type.Results(), n.List, func() string { return "return argument" })
+		typecheckaste(ir.ORETURN, nil, false, Curfn.Type.Results(), n.List, func() string { return "return argument" })
 
-	case ORETJMP:
+	case ir.ORETJMP:
 		ok |= ctxStmt
 
-	case OSELECT:
+	case ir.OSELECT:
 		ok |= ctxStmt
 		typecheckselect(n)
 
-	case OSWITCH:
+	case ir.OSWITCH:
 		ok |= ctxStmt
 		typecheckswitch(n)
 
-	case ORANGE:
+	case ir.ORANGE:
 		ok |= ctxStmt
 		typecheckrange(n)
 
-	case OTYPESW:
+	case ir.OTYPESW:
 		base.Errorf("use of .(type) outside type switch")
 		n.Type = nil
 		return n
 
-	case ODCLFUNC:
+	case ir.ODCLFUNC:
 		ok |= ctxStmt
 		typecheckfunc(n)
 
-	case ODCLCONST:
+	case ir.ODCLCONST:
 		ok |= ctxStmt
 		n.Left = typecheck(n.Left, ctxExpr)
 
-	case ODCLTYPE:
+	case ir.ODCLTYPE:
 		ok |= ctxStmt
 		n.Left = typecheck(n.Left, ctxType)
 		checkwidth(n.Left.Type)
 	}
 
 	t := n.Type
-	if t != nil && !t.IsFuncArgStruct() && n.Op != OTYPE {
+	if t != nil && !t.IsFuncArgStruct() && n.Op != ir.OTYPE {
 		switch t.Etype {
-		case TFUNC, // might have TANY; wait until it's called
-			TANY, TFORW, TIDEAL, TNIL, TBLANK:
+		case types.TFUNC, // might have TANY; wait until it's called
+			types.TANY, types.TFORW, types.TIDEAL, types.TNIL, types.TBLANK:
 			break
 
 		default:
@@ -2094,7 +2095,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 	}
 
 	n = evalConst(n)
-	if n.Op == OTYPE && top&ctxType == 0 {
+	if n.Op == ir.OTYPE && top&ctxType == 0 {
 		if !n.Type.Broke() {
 			base.Errorf("type %v is not an expression", n.Type)
 		}
@@ -2102,7 +2103,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 		return n
 	}
 
-	if top&(ctxExpr|ctxType) == ctxType && n.Op != OTYPE {
+	if top&(ctxExpr|ctxType) == ctxType && n.Op != ir.OTYPE {
 		base.Errorf("%v is not a type", n)
 		n.Type = nil
 		return n
@@ -2128,7 +2129,7 @@ func typecheck1(n *Node, top int) (res *Node) {
 	return n
 }
 
-func typecheckargs(n *Node) {
+func typecheckargs(n *ir.Node) {
 	if n.List.Len() != 1 || n.IsDDD() {
 		typecheckslice(n.List.Slice(), ctxExpr)
 		return
@@ -2144,10 +2145,10 @@ func typecheckargs(n *Node) {
 
 	// Save n as n.Orig for fmt.go.
 	if n.Orig == n {
-		n.Orig = n.sepcopy()
+		n.Orig = ir.SepCopy(n)
 	}
 
-	as := nod(OAS2, nil, nil)
+	as := ir.Nod(ir.OAS2, nil, nil)
 	as.Rlist.AppendNodes(&n.List)
 
 	// If we're outside of function context, then this call will
@@ -2161,7 +2162,7 @@ func typecheckargs(n *Node) {
 	}
 	for _, f := range t.FieldSlice() {
 		t := temp(f.Type)
-		as.Ninit.Append(nod(ODCL, t, nil))
+		as.Ninit.Append(ir.Nod(ir.ODCL, t, nil))
 		as.List.Append(t)
 		n.List.Append(t)
 	}
@@ -2173,7 +2174,7 @@ func typecheckargs(n *Node) {
 	n.Ninit.Append(as)
 }
 
-func checksliceindex(l *Node, r *Node, tp *types.Type) bool {
+func checksliceindex(l *ir.Node, r *ir.Node, tp *types.Type) bool {
 	t := r.Type
 	if t == nil {
 		return false
@@ -2183,7 +2184,7 @@ func checksliceindex(l *Node, r *Node, tp *types.Type) bool {
 		return false
 	}
 
-	if r.Op == OLITERAL {
+	if r.Op == ir.OLITERAL {
 		x := r.Val()
 		if constant.Sign(x) < 0 {
 			base.Errorf("invalid slice index %v (index must be non-negative)", r)
@@ -2191,10 +2192,10 @@ func checksliceindex(l *Node, r *Node, tp *types.Type) bool {
 		} else if tp != nil && tp.NumElem() >= 0 && constant.Compare(x, token.GTR, constant.MakeInt64(tp.NumElem())) {
 			base.Errorf("invalid slice index %v (out of bounds for %d-element array)", r, tp.NumElem())
 			return false
-		} else if Isconst(l, constant.String) && constant.Compare(x, token.GTR, constant.MakeInt64(int64(len(l.StringVal())))) {
+		} else if ir.IsConst(l, constant.String) && constant.Compare(x, token.GTR, constant.MakeInt64(int64(len(l.StringVal())))) {
 			base.Errorf("invalid slice index %v (out of bounds for %d-byte string)", r, len(l.StringVal()))
 			return false
-		} else if doesoverflow(x, types.Types[TINT]) {
+		} else if doesoverflow(x, types.Types[types.TINT]) {
 			base.Errorf("invalid slice index %v (index too large)", r)
 			return false
 		}
@@ -2203,8 +2204,8 @@ func checksliceindex(l *Node, r *Node, tp *types.Type) bool {
 	return true
 }
 
-func checksliceconst(lo *Node, hi *Node) bool {
-	if lo != nil && hi != nil && lo.Op == OLITERAL && hi.Op == OLITERAL && constant.Compare(lo.Val(), token.GTR, hi.Val()) {
+func checksliceconst(lo *ir.Node, hi *ir.Node) bool {
+	if lo != nil && hi != nil && lo.Op == ir.OLITERAL && hi.Op == ir.OLITERAL && constant.Compare(lo.Val(), token.GTR, hi.Val()) {
 		base.Errorf("invalid slice index: %v > %v", lo, hi)
 		return false
 	}
@@ -2212,39 +2213,39 @@ func checksliceconst(lo *Node, hi *Node) bool {
 	return true
 }
 
-func checkdefergo(n *Node) {
+func checkdefergo(n *ir.Node) {
 	what := "defer"
-	if n.Op == OGO {
+	if n.Op == ir.OGO {
 		what = "go"
 	}
 
 	switch n.Left.Op {
 	// ok
-	case OCALLINTER,
-		OCALLMETH,
-		OCALLFUNC,
-		OCLOSE,
-		OCOPY,
-		ODELETE,
-		OPANIC,
-		OPRINT,
-		OPRINTN,
-		ORECOVER:
+	case ir.OCALLINTER,
+		ir.OCALLMETH,
+		ir.OCALLFUNC,
+		ir.OCLOSE,
+		ir.OCOPY,
+		ir.ODELETE,
+		ir.OPANIC,
+		ir.OPRINT,
+		ir.OPRINTN,
+		ir.ORECOVER:
 		return
 
-	case OAPPEND,
-		OCAP,
-		OCOMPLEX,
-		OIMAG,
-		OLEN,
-		OMAKE,
-		OMAKESLICE,
-		OMAKECHAN,
-		OMAKEMAP,
-		ONEW,
-		OREAL,
-		OLITERAL: // conversion or unsafe.Alignof, Offsetof, Sizeof
-		if n.Left.Orig != nil && n.Left.Orig.Op == OCONV {
+	case ir.OAPPEND,
+		ir.OCAP,
+		ir.OCOMPLEX,
+		ir.OIMAG,
+		ir.OLEN,
+		ir.OMAKE,
+		ir.OMAKESLICE,
+		ir.OMAKECHAN,
+		ir.OMAKEMAP,
+		ir.ONEW,
+		ir.OREAL,
+		ir.OLITERAL: // conversion or unsafe.Alignof, Offsetof, Sizeof
+		if n.Left.Orig != nil && n.Left.Orig.Op == ir.OCONV {
 			break
 		}
 		base.ErrorfAt(n.Pos, "%s discards result of %v", what, n.Left)
@@ -2267,7 +2268,7 @@ func checkdefergo(n *Node) {
 
 // The result of implicitstar MUST be assigned back to n, e.g.
 // 	n.Left = implicitstar(n.Left)
-func implicitstar(n *Node) *Node {
+func implicitstar(n *ir.Node) *ir.Node {
 	// insert implicit * if needed for fixed array
 	t := n.Type
 	if t == nil || !t.IsPtr() {
@@ -2280,13 +2281,13 @@ func implicitstar(n *Node) *Node {
 	if !t.IsArray() {
 		return n
 	}
-	n = nod(ODEREF, n, nil)
+	n = ir.Nod(ir.ODEREF, n, nil)
 	n.SetImplicit(true)
 	n = typecheck(n, ctxExpr)
 	return n
 }
 
-func onearg(n *Node, f string, args ...interface{}) bool {
+func onearg(n *ir.Node, f string, args ...interface{}) bool {
 	if n.Left != nil {
 		return true
 	}
@@ -2309,7 +2310,7 @@ func onearg(n *Node, f string, args ...interface{}) bool {
 	return true
 }
 
-func twoarg(n *Node) bool {
+func twoarg(n *ir.Node) bool {
 	if n.Left != nil {
 		return true
 	}
@@ -2327,7 +2328,7 @@ func twoarg(n *Node) bool {
 	return true
 }
 
-func lookdot1(errnode *Node, s *types.Sym, t *types.Type, fs *types.Fields, dostrcmp int) *types.Field {
+func lookdot1(errnode *ir.Node, s *types.Sym, t *types.Type, fs *types.Fields, dostrcmp int) *types.Field {
 	var r *types.Field
 	for _, f := range fs.Slice() {
 		if dostrcmp != 0 && f.Sym.Name == s.Name {
@@ -2358,7 +2359,7 @@ func lookdot1(errnode *Node, s *types.Sym, t *types.Type, fs *types.Fields, dost
 
 // typecheckMethodExpr checks selector expressions (ODOT) where the
 // base expression is a type expression (OTYPE).
-func typecheckMethodExpr(n *Node) (res *Node) {
+func typecheckMethodExpr(n *ir.Node) (res *ir.Node) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckMethodExpr", n)(&res)
 	}
@@ -2411,20 +2412,20 @@ func typecheckMethodExpr(n *Node) (res *Node) {
 		return n
 	}
 
-	n.Op = OMETHEXPR
+	n.Op = ir.OMETHEXPR
 	if n.Name == nil {
-		n.Name = new(Name)
+		n.Name = new(ir.Name)
 	}
-	n.Right = newname(n.Sym)
+	n.Right = NewName(n.Sym)
 	n.Sym = methodSym(t, n.Sym)
 	n.Type = methodfunc(m.Type, n.Left.Type)
 	n.Xoffset = 0
-	n.SetClass(PFUNC)
+	n.SetClass(ir.PFUNC)
 	n.SetOpt(m)
 	// methodSym already marked n.Sym as a function.
 
 	// Issue 25065. Make sure that we emit the symbol for a local method.
-	if base.Ctxt.Flag_dynlink && !inimport && (t.Sym == nil || t.Sym.Pkg == localpkg) {
+	if base.Ctxt.Flag_dynlink && !inimport && (t.Sym == nil || t.Sym.Pkg == ir.LocalPkg) {
 		makefuncsym(n.Sym)
 	}
 
@@ -2446,7 +2447,7 @@ func derefall(t *types.Type) *types.Type {
 	return t
 }
 
-func lookdot(n *Node, t *types.Type, dostrcmp int) *types.Field {
+func lookdot(n *ir.Node, t *types.Type, dostrcmp int) *types.Field {
 	s := n.Sym
 
 	dowidth(t)
@@ -2471,19 +2472,19 @@ func lookdot(n *Node, t *types.Type, dostrcmp int) *types.Field {
 		if f2 != nil {
 			base.Errorf("%v is both field and method", n.Sym)
 		}
-		if f1.Offset == BADWIDTH {
+		if f1.Offset == types.BADWIDTH {
 			base.Fatalf("lookdot badwidth %v %p", f1, f1)
 		}
 		n.Xoffset = f1.Offset
 		n.Type = f1.Type
 		if t.IsInterface() {
 			if n.Left.Type.IsPtr() {
-				n.Left = nod(ODEREF, n.Left, nil) // implicitstar
+				n.Left = ir.Nod(ir.ODEREF, n.Left, nil) // implicitstar
 				n.Left.SetImplicit(true)
 				n.Left = typecheck(n.Left, ctxExpr)
 			}
 
-			n.Op = ODOTINTER
+			n.Op = ir.ODOTINTER
 		} else {
 			n.SetOpt(f1)
 		}
@@ -2502,11 +2503,11 @@ func lookdot(n *Node, t *types.Type, dostrcmp int) *types.Field {
 		if !types.Identical(rcvr, tt) {
 			if rcvr.IsPtr() && types.Identical(rcvr.Elem(), tt) {
 				checklvalue(n.Left, "call pointer method on")
-				n.Left = nod(OADDR, n.Left, nil)
+				n.Left = ir.Nod(ir.OADDR, n.Left, nil)
 				n.Left.SetImplicit(true)
 				n.Left = typecheck(n.Left, ctxType|ctxExpr)
 			} else if tt.IsPtr() && (!rcvr.IsPtr() || rcvr.IsPtr() && rcvr.Elem().NotInHeap()) && types.Identical(tt.Elem(), rcvr) {
-				n.Left = nod(ODEREF, n.Left, nil)
+				n.Left = ir.Nod(ir.ODEREF, n.Left, nil)
 				n.Left.SetImplicit(true)
 				n.Left = typecheck(n.Left, ctxType|ctxExpr)
 			} else if tt.IsPtr() && tt.Elem().IsPtr() && types.Identical(derefall(tt), derefall(rcvr)) {
@@ -2516,7 +2517,7 @@ func lookdot(n *Node, t *types.Type, dostrcmp int) *types.Field {
 					if rcvr.IsPtr() && !tt.Elem().IsPtr() {
 						break
 					}
-					n.Left = nod(ODEREF, n.Left, nil)
+					n.Left = ir.Nod(ir.ODEREF, n.Left, nil)
 					n.Left.SetImplicit(true)
 					n.Left = typecheck(n.Left, ctxType|ctxExpr)
 					tt = tt.Elem()
@@ -2528,11 +2529,11 @@ func lookdot(n *Node, t *types.Type, dostrcmp int) *types.Field {
 
 		pll := n
 		ll := n.Left
-		for ll.Left != nil && (ll.Op == ODOT || ll.Op == ODOTPTR || ll.Op == ODEREF) {
+		for ll.Left != nil && (ll.Op == ir.ODOT || ll.Op == ir.ODOTPTR || ll.Op == ir.ODEREF) {
 			pll = ll
 			ll = ll.Left
 		}
-		if pll.Implicit() && ll.Type.IsPtr() && ll.Type.Sym != nil && asNode(ll.Type.Sym.Def) != nil && asNode(ll.Type.Sym.Def).Op == OTYPE {
+		if pll.Implicit() && ll.Type.IsPtr() && ll.Type.Sym != nil && ir.AsNode(ll.Type.Sym.Def) != nil && ir.AsNode(ll.Type.Sym.Def).Op == ir.OTYPE {
 			// It is invalid to automatically dereference a named pointer type when selecting a method.
 			// Make n.Left == ll to clarify error message.
 			n.Left = ll
@@ -2542,7 +2543,7 @@ func lookdot(n *Node, t *types.Type, dostrcmp int) *types.Field {
 		n.Sym = methodSym(n.Left.Type, f2.Sym)
 		n.Xoffset = f2.Offset
 		n.Type = f2.Type
-		n.Op = ODOTMETH
+		n.Op = ir.ODOTMETH
 		n.SetOpt(f2)
 
 		return f2
@@ -2551,9 +2552,9 @@ func lookdot(n *Node, t *types.Type, dostrcmp int) *types.Field {
 	return nil
 }
 
-func nokeys(l Nodes) bool {
+func nokeys(l ir.Nodes) bool {
 	for _, n := range l.Slice() {
-		if n.Op == OKEY || n.Op == OSTRUCTKEY {
+		if n.Op == ir.OKEY || n.Op == ir.OSTRUCTKEY {
 			return false
 		}
 	}
@@ -2571,7 +2572,7 @@ func hasddd(t *types.Type) bool {
 }
 
 // typecheck assignment: type list = expression list
-func typecheckaste(op Op, call *Node, isddd bool, tstruct *types.Type, nl Nodes, desc func() string) {
+func typecheckaste(op ir.Op, call *ir.Node, isddd bool, tstruct *types.Type, nl ir.Nodes, desc func() string) {
 	var t *types.Type
 	var i int
 
@@ -2582,7 +2583,7 @@ func typecheckaste(op Op, call *Node, isddd bool, tstruct *types.Type, nl Nodes,
 		return
 	}
 
-	var n *Node
+	var n *ir.Node
 	if nl.Len() == 1 {
 		n = nl.First()
 	}
@@ -2671,7 +2672,7 @@ notenough:
 			// call is the expression being called, not the overall call.
 			// Method expressions have the form T.M, and the compiler has
 			// rewritten those to ONAME nodes but left T in Left.
-			if call.Op == OMETHEXPR {
+			if call.Op == ir.OMETHEXPR {
 				base.Errorf("not enough arguments in call to method expression %v%s", call, details)
 			} else {
 				base.Errorf("not enough arguments in call to %v%s", call, details)
@@ -2694,7 +2695,7 @@ toomany:
 	}
 }
 
-func errorDetails(nl Nodes, tstruct *types.Type, isddd bool) string {
+func errorDetails(nl ir.Nodes, tstruct *types.Type, isddd bool) string {
 	// If we don't know any type at a call site, let's suppress any return
 	// message signatures. See Issue https://golang.org/issues/19012.
 	if tstruct == nil {
@@ -2706,7 +2707,7 @@ func errorDetails(nl Nodes, tstruct *types.Type, isddd bool) string {
 			return ""
 		}
 	}
-	return fmt.Sprintf("\n\thave %s\n\twant %v", nl.sigerr(isddd), tstruct)
+	return fmt.Sprintf("\n\thave %s\n\twant %v", fmtSignature(nl, isddd), tstruct)
 }
 
 // sigrepr is a type's representation to the outside world,
@@ -2720,7 +2721,7 @@ func sigrepr(t *types.Type, isddd bool) string {
 		return "bool"
 	}
 
-	if t.Etype == TIDEAL {
+	if t.Etype == types.TIDEAL {
 		// "untyped number" is not commonly used
 		// outside of the compiler, so let's use "number".
 		// TODO(mdempsky): Revisit this.
@@ -2738,7 +2739,7 @@ func sigrepr(t *types.Type, isddd bool) string {
 }
 
 // sigerr returns the signature of the types at the call or return.
-func (nl Nodes) sigerr(isddd bool) string {
+func fmtSignature(nl ir.Nodes, isddd bool) string {
 	if nl.Len() < 1 {
 		return "()"
 	}
@@ -2764,7 +2765,7 @@ func fielddup(name string, hash map[string]bool) {
 // iscomptype reports whether type t is a composite literal type.
 func iscomptype(t *types.Type) bool {
 	switch t.Etype {
-	case TARRAY, TSLICE, TSTRUCT, TMAP:
+	case types.TARRAY, types.TSLICE, types.TSTRUCT, types.TMAP:
 		return true
 	default:
 		return false
@@ -2773,8 +2774,8 @@ func iscomptype(t *types.Type) bool {
 
 // pushtype adds elided type information for composite literals if
 // appropriate, and returns the resulting expression.
-func pushtype(n *Node, t *types.Type) *Node {
-	if n == nil || n.Op != OCOMPLIT || n.Right != nil {
+func pushtype(n *ir.Node, t *types.Type) *ir.Node {
+	if n == nil || n.Op != ir.OCOMPLIT || n.Right != nil {
 		return n
 	}
 
@@ -2787,7 +2788,7 @@ func pushtype(n *Node, t *types.Type) *Node {
 		// For *T, return &T{...}.
 		n.Right = typenod(t.Elem())
 
-		n = nodl(n.Pos, OADDR, n, nil)
+		n = ir.NodAt(n.Pos, ir.OADDR, n, nil)
 		n.SetImplicit(true)
 	}
 
@@ -2796,7 +2797,7 @@ func pushtype(n *Node, t *types.Type) *Node {
 
 // The result of typecheckcomplit MUST be assigned back to n, e.g.
 // 	n.Left = typecheckcomplit(n.Left)
-func typecheckcomplit(n *Node) (res *Node) {
+func typecheckcomplit(n *ir.Node) (res *ir.Node) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckcomplit", n)(&res)
 	}
@@ -2813,12 +2814,12 @@ func typecheckcomplit(n *Node) (res *Node) {
 	}
 
 	// Save original node (including n.Right)
-	n.Orig = n.copy()
+	n.Orig = ir.Copy(n)
 
 	setlineno(n.Right)
 
 	// Need to handle [...]T arrays specially.
-	if n.Right.Op == OTARRAY && n.Right.Left != nil && n.Right.Left.Op == ODDD {
+	if n.Right.Op == ir.OTARRAY && n.Right.Left != nil && n.Right.Left.Op == ir.ODDD {
 		n.Right.Right = typecheck(n.Right.Right, ctxType)
 		if n.Right.Right.Type == nil {
 			n.Type = nil
@@ -2828,7 +2829,7 @@ func typecheckcomplit(n *Node) (res *Node) {
 
 		length := typecheckarraylit(elemType, -1, n.List.Slice(), "array literal")
 
-		n.Op = OARRAYLIT
+		n.Op = ir.OARRAYLIT
 		n.Type = types.NewArray(elemType, length)
 		n.Right = nil
 		return n
@@ -2847,21 +2848,21 @@ func typecheckcomplit(n *Node) (res *Node) {
 		base.Errorf("invalid composite literal type %v", t)
 		n.Type = nil
 
-	case TARRAY:
+	case types.TARRAY:
 		typecheckarraylit(t.Elem(), t.NumElem(), n.List.Slice(), "array literal")
-		n.Op = OARRAYLIT
+		n.Op = ir.OARRAYLIT
 		n.Right = nil
 
-	case TSLICE:
+	case types.TSLICE:
 		length := typecheckarraylit(t.Elem(), -1, n.List.Slice(), "slice literal")
-		n.Op = OSLICELIT
+		n.Op = ir.OSLICELIT
 		n.Right = nodintconst(length)
 
-	case TMAP:
+	case types.TMAP:
 		var cs constSet
 		for i3, l := range n.List.Slice() {
 			setlineno(l)
-			if l.Op != OKEY {
+			if l.Op != ir.OKEY {
 				n.List.SetIndex(i3, typecheck(l, ctxExpr))
 				base.Errorf("missing key in map literal")
 				continue
@@ -2879,10 +2880,10 @@ func typecheckcomplit(n *Node) (res *Node) {
 			l.Right = assignconv(r, t.Elem(), "map value")
 		}
 
-		n.Op = OMAPLIT
+		n.Op = ir.OMAPLIT
 		n.Right = nil
 
-	case TSTRUCT:
+	case types.TSTRUCT:
 		// Need valid field offsets for Xoffset below.
 		dowidth(t)
 
@@ -2904,12 +2905,12 @@ func typecheckcomplit(n *Node) (res *Node) {
 
 				f := t.Field(i)
 				s := f.Sym
-				if s != nil && !types.IsExported(s.Name) && s.Pkg != localpkg {
+				if s != nil && !types.IsExported(s.Name) && s.Pkg != ir.LocalPkg {
 					base.Errorf("implicit assignment of unexported field '%s' in %v literal", s.Name, t)
 				}
 				// No pushtype allowed here. Must name fields for that.
 				n1 = assignconv(n1, f.Type, "field value")
-				n1 = nodSym(OSTRUCTKEY, n1, f.Sym)
+				n1 = nodSym(ir.OSTRUCTKEY, n1, f.Sym)
 				n1.Xoffset = f.Offset
 				ls[i] = n1
 			}
@@ -2924,10 +2925,10 @@ func typecheckcomplit(n *Node) (res *Node) {
 			for i, l := range ls {
 				setlineno(l)
 
-				if l.Op == OKEY {
+				if l.Op == ir.OKEY {
 					key := l.Left
 
-					l.Op = OSTRUCTKEY
+					l.Op = ir.OSTRUCTKEY
 					l.Left = l.Right
 					l.Right = nil
 
@@ -2935,7 +2936,7 @@ func typecheckcomplit(n *Node) (res *Node) {
 					// the field to the right of the dot,
 					// so s will be non-nil, but an OXDOT
 					// is never a valid struct literal key.
-					if key.Sym == nil || key.Op == OXDOT || key.Sym.IsBlank() {
+					if key.Sym == nil || key.Op == ir.OXDOT || key.Sym.IsBlank() {
 						base.Errorf("invalid field name %v in struct initializer", key)
 						l.Left = typecheck(l.Left, ctxExpr)
 						continue
@@ -2945,7 +2946,7 @@ func typecheckcomplit(n *Node) (res *Node) {
 					// package, because of import dot. Redirect to correct sym
 					// before we do the lookup.
 					s := key.Sym
-					if s.Pkg != localpkg && types.IsExported(s.Name) {
+					if s.Pkg != ir.LocalPkg && types.IsExported(s.Name) {
 						s1 := lookup(s.Name)
 						if s1.Origpkg == s.Pkg {
 							s = s1
@@ -2954,7 +2955,7 @@ func typecheckcomplit(n *Node) (res *Node) {
 					l.Sym = s
 				}
 
-				if l.Op != OSTRUCTKEY {
+				if l.Op != ir.OSTRUCTKEY {
 					if !errored {
 						base.Errorf("mixture of field:value and value initializers")
 						errored = true
@@ -2999,7 +3000,7 @@ func typecheckcomplit(n *Node) (res *Node) {
 			}
 		}
 
-		n.Op = OSTRUCTLIT
+		n.Op = ir.OSTRUCTLIT
 		n.Right = nil
 	}
 
@@ -3007,12 +3008,12 @@ func typecheckcomplit(n *Node) (res *Node) {
 }
 
 // typecheckarraylit type-checks a sequence of slice/array literal elements.
-func typecheckarraylit(elemType *types.Type, bound int64, elts []*Node, ctx string) int64 {
+func typecheckarraylit(elemType *types.Type, bound int64, elts []*ir.Node, ctx string) int64 {
 	// If there are key/value pairs, create a map to keep seen
 	// keys so we can check for duplicate indices.
 	var indices map[int64]bool
 	for _, elt := range elts {
-		if elt.Op == OKEY {
+		if elt.Op == ir.OKEY {
 			indices = make(map[int64]bool)
 			break
 		}
@@ -3022,8 +3023,8 @@ func typecheckarraylit(elemType *types.Type, bound int64, elts []*Node, ctx stri
 	for i, elt := range elts {
 		setlineno(elt)
 		r := elts[i]
-		var kv *Node
-		if elt.Op == OKEY {
+		var kv *ir.Node
+		if elt.Op == ir.OKEY {
 			elt.Left = typecheck(elt.Left, ctxExpr)
 			key = indexconst(elt.Left)
 			if key < 0 {
@@ -3076,7 +3077,7 @@ func typecheckarraylit(elemType *types.Type, bound int64, elts []*Node, ctx stri
 
 // visible reports whether sym is exported or locally defined.
 func visible(sym *types.Sym) bool {
-	return sym != nil && (types.IsExported(sym.Name) || sym.Pkg == localpkg)
+	return sym != nil && (types.IsExported(sym.Name) || sym.Pkg == ir.LocalPkg)
 }
 
 // nonexported reports whether sym is an unexported field.
@@ -3085,9 +3086,9 @@ func nonexported(sym *types.Sym) bool {
 }
 
 // lvalue etc
-func islvalue(n *Node) bool {
+func islvalue(n *ir.Node) bool {
 	switch n.Op {
-	case OINDEX:
+	case ir.OINDEX:
 		if n.Left.Type != nil && n.Left.Type.IsArray() {
 			return islvalue(n.Left)
 		}
@@ -3095,14 +3096,14 @@ func islvalue(n *Node) bool {
 			return false
 		}
 		fallthrough
-	case ODEREF, ODOTPTR, OCLOSUREVAR:
+	case ir.ODEREF, ir.ODOTPTR, ir.OCLOSUREVAR:
 		return true
 
-	case ODOT:
+	case ir.ODOT:
 		return islvalue(n.Left)
 
-	case ONAME:
-		if n.Class() == PFUNC {
+	case ir.ONAME:
+		if n.Class() == ir.PFUNC {
 			return false
 		}
 		return true
@@ -3111,17 +3112,17 @@ func islvalue(n *Node) bool {
 	return false
 }
 
-func checklvalue(n *Node, verb string) {
+func checklvalue(n *ir.Node, verb string) {
 	if !islvalue(n) {
 		base.Errorf("cannot %s %v", verb, n)
 	}
 }
 
-func checkassign(stmt *Node, n *Node) {
+func checkassign(stmt *ir.Node, n *ir.Node) {
 	// Variables declared in ORANGE are assigned on every iteration.
-	if n.Name == nil || n.Name.Defn != stmt || stmt.Op == ORANGE {
+	if n.Name == nil || n.Name.Defn != stmt || stmt.Op == ir.ORANGE {
 		r := outervalue(n)
-		if r.Op == ONAME {
+		if r.Op == ir.ONAME {
 			r.Name.SetAssigned(true)
 			if r.Name.IsClosureVar() {
 				r.Name.Defn.Name.SetAssigned(true)
@@ -3132,7 +3133,7 @@ func checkassign(stmt *Node, n *Node) {
 	if islvalue(n) {
 		return
 	}
-	if n.Op == OINDEXMAP {
+	if n.Op == ir.OINDEXMAP {
 		n.SetIndexMapLValue(true)
 		return
 	}
@@ -3143,11 +3144,11 @@ func checkassign(stmt *Node, n *Node) {
 	}
 
 	switch {
-	case n.Op == ODOT && n.Left.Op == OINDEXMAP:
+	case n.Op == ir.ODOT && n.Left.Op == ir.OINDEXMAP:
 		base.Errorf("cannot assign to struct field %v in map", n)
-	case (n.Op == OINDEX && n.Left.Type.IsString()) || n.Op == OSLICESTR:
+	case (n.Op == ir.OINDEX && n.Left.Type.IsString()) || n.Op == ir.OSLICESTR:
 		base.Errorf("cannot assign to %v (strings are immutable)", n)
-	case n.Op == OLITERAL && n.Sym != nil && n.isGoConst():
+	case n.Op == ir.OLITERAL && n.Sym != nil && isGoConst(n):
 		base.Errorf("cannot assign to %v (declared const)", n)
 	default:
 		base.Errorf("cannot assign to %v", n)
@@ -3155,7 +3156,7 @@ func checkassign(stmt *Node, n *Node) {
 	n.Type = nil
 }
 
-func checkassignlist(stmt *Node, l Nodes) {
+func checkassignlist(stmt *ir.Node, l ir.Nodes) {
 	for _, n := range l.Slice() {
 		checkassign(stmt, n)
 	}
@@ -3176,35 +3177,35 @@ func checkassignlist(stmt *Node, l Nodes) {
 // currently OK, since the only place samesafeexpr gets used on an
 // lvalue expression is for OSLICE and OAPPEND optimizations, and it
 // is correct in those settings.
-func samesafeexpr(l *Node, r *Node) bool {
+func samesafeexpr(l *ir.Node, r *ir.Node) bool {
 	if l.Op != r.Op || !types.Identical(l.Type, r.Type) {
 		return false
 	}
 
 	switch l.Op {
-	case ONAME, OCLOSUREVAR:
+	case ir.ONAME, ir.OCLOSUREVAR:
 		return l == r
 
-	case ODOT, ODOTPTR:
+	case ir.ODOT, ir.ODOTPTR:
 		return l.Sym != nil && r.Sym != nil && l.Sym == r.Sym && samesafeexpr(l.Left, r.Left)
 
-	case ODEREF, OCONVNOP,
-		ONOT, OBITNOT, OPLUS, ONEG:
+	case ir.ODEREF, ir.OCONVNOP,
+		ir.ONOT, ir.OBITNOT, ir.OPLUS, ir.ONEG:
 		return samesafeexpr(l.Left, r.Left)
 
-	case OCONV:
+	case ir.OCONV:
 		// Some conversions can't be reused, such as []byte(str).
 		// Allow only numeric-ish types. This is a bit conservative.
 		return issimple[l.Type.Etype] && samesafeexpr(l.Left, r.Left)
 
-	case OINDEX, OINDEXMAP,
-		OADD, OSUB, OOR, OXOR, OMUL, OLSH, ORSH, OAND, OANDNOT, ODIV, OMOD:
+	case ir.OINDEX, ir.OINDEXMAP,
+		ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.OLSH, ir.ORSH, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OMOD:
 		return samesafeexpr(l.Left, r.Left) && samesafeexpr(l.Right, r.Right)
 
-	case OLITERAL:
+	case ir.OLITERAL:
 		return constant.Compare(l.Val(), token.EQL, r.Val())
 
-	case ONIL:
+	case ir.ONIL:
 		return true
 	}
 
@@ -3214,7 +3215,7 @@ func samesafeexpr(l *Node, r *Node) bool {
 // type check assignment.
 // if this assignment is the definition of a var on the left side,
 // fill in the var's type.
-func typecheckas(n *Node) {
+func typecheckas(n *ir.Node) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckas", n)(nil)
 	}
@@ -3260,19 +3261,19 @@ func typecheckas(n *Node) {
 	if n.Left.Typecheck() == 0 {
 		n.Left = typecheck(n.Left, ctxExpr|ctxAssign)
 	}
-	if !n.Left.isBlank() {
+	if !ir.IsBlank(n.Left) {
 		checkwidth(n.Left.Type) // ensure width is calculated for backend
 	}
 }
 
-func checkassignto(src *types.Type, dst *Node) {
-	if op, why := assignop(src, dst.Type); op == OXXX {
+func checkassignto(src *types.Type, dst *ir.Node) {
+	if op, why := assignop(src, dst.Type); op == ir.OXXX {
 		base.Errorf("cannot assign %v to %L in multiple assignment%s", src, dst, why)
 		return
 	}
 }
 
-func typecheckas2(n *Node) {
+func typecheckas2(n *ir.Node) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckas2", n)(nil)
 	}
@@ -3297,8 +3298,8 @@ func typecheckas2(n *Node) {
 	}
 	checkassignlist(n, n.List)
 
-	var l *Node
-	var r *Node
+	var l *ir.Node
+	var r *ir.Node
 	if cl == cr {
 		// easy
 		ls := n.List.Slice()
@@ -3326,7 +3327,7 @@ func typecheckas2(n *Node) {
 			goto out
 		}
 		switch r.Op {
-		case OCALLMETH, OCALLINTER, OCALLFUNC:
+		case ir.OCALLMETH, ir.OCALLINTER, ir.OCALLFUNC:
 			if !r.Type.IsFuncArgStruct() {
 				break
 			}
@@ -3334,7 +3335,7 @@ func typecheckas2(n *Node) {
 			if cr != cl {
 				goto mismatch
 			}
-			n.Op = OAS2FUNC
+			n.Op = ir.OAS2FUNC
 			n.Right = r
 			n.Rlist.Set(nil)
 			for i, l := range n.List.Slice() {
@@ -3356,15 +3357,15 @@ func typecheckas2(n *Node) {
 			goto out
 		}
 		switch r.Op {
-		case OINDEXMAP, ORECV, ODOTTYPE:
+		case ir.OINDEXMAP, ir.ORECV, ir.ODOTTYPE:
 			switch r.Op {
-			case OINDEXMAP:
-				n.Op = OAS2MAPR
-			case ORECV:
-				n.Op = OAS2RECV
-			case ODOTTYPE:
-				n.Op = OAS2DOTTYPE
-				r.Op = ODOTTYPE2
+			case ir.OINDEXMAP:
+				n.Op = ir.OAS2MAPR
+			case ir.ORECV:
+				n.Op = ir.OAS2RECV
+			case ir.ODOTTYPE:
+				n.Op = ir.OAS2DOTTYPE
+				r.Op = ir.ODOTTYPE2
 			}
 			n.Right = r
 			n.Rlist.Set(nil)
@@ -3376,10 +3377,10 @@ func typecheckas2(n *Node) {
 			}
 			l := n.List.Second()
 			if l.Type != nil && !l.Type.IsBoolean() {
-				checkassignto(types.Types[TBOOL], l)
+				checkassignto(types.Types[types.TBOOL], l)
 			}
 			if l.Name != nil && l.Name.Defn == n && l.Name.Param.Ntype == nil {
-				l.Type = types.Types[TBOOL]
+				l.Type = types.Types[types.TBOOL]
 			}
 			goto out
 		}
@@ -3389,7 +3390,7 @@ mismatch:
 	switch r.Op {
 	default:
 		base.Errorf("assignment mismatch: %d variables but %d values", cl, cr)
-	case OCALLFUNC, OCALLMETH, OCALLINTER:
+	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
 		base.Errorf("assignment mismatch: %d variables but %v returns %d values", cl, r.Left, cr)
 	}
 
@@ -3405,13 +3406,13 @@ out:
 }
 
 // type check function definition
-func typecheckfunc(n *Node) {
+func typecheckfunc(n *ir.Node) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckfunc", n)(nil)
 	}
 
 	for _, ln := range n.Func.Dcl {
-		if ln.Op == ONAME && (ln.Class() == PPARAM || ln.Class() == PPARAMOUT) {
+		if ln.Op == ir.ONAME && (ln.Class() == ir.PPARAM || ln.Class() == ir.PPARAMOUT) {
 			ln.Name.Decldepth = 1
 		}
 	}
@@ -3424,13 +3425,13 @@ func typecheckfunc(n *Node) {
 	n.Type = t
 	rcvr := t.Recv()
 	if rcvr != nil && n.Func.Shortname != nil {
-		m := addmethod(n, n.Func.Shortname, t, true, n.Func.Pragma&Nointerface != 0)
+		m := addmethod(n, n.Func.Shortname, t, true, n.Func.Pragma&ir.Nointerface != 0)
 		if m == nil {
 			return
 		}
 
 		n.Func.Nname.Sym = methodSym(rcvr.Type, n.Func.Shortname)
-		declare(n.Func.Nname, PFUNC)
+		declare(n.Func.Nname, ir.PFUNC)
 	}
 
 	if base.Ctxt.Flag_dynlink && !inimport && n.Func.Nname != nil {
@@ -3440,25 +3441,25 @@ func typecheckfunc(n *Node) {
 
 // The result of stringtoruneslit MUST be assigned back to n, e.g.
 // 	n.Left = stringtoruneslit(n.Left)
-func stringtoruneslit(n *Node) *Node {
-	if n.Left.Op != OLITERAL || n.Left.Val().Kind() != constant.String {
+func stringtoruneslit(n *ir.Node) *ir.Node {
+	if n.Left.Op != ir.OLITERAL || n.Left.Val().Kind() != constant.String {
 		base.Fatalf("stringtoarraylit %v", n)
 	}
 
-	var l []*Node
+	var l []*ir.Node
 	i := 0
 	for _, r := range n.Left.StringVal() {
-		l = append(l, nod(OKEY, nodintconst(int64(i)), nodintconst(int64(r))))
+		l = append(l, ir.Nod(ir.OKEY, nodintconst(int64(i)), nodintconst(int64(r))))
 		i++
 	}
 
-	nn := nod(OCOMPLIT, nil, typenod(n.Type))
+	nn := ir.Nod(ir.OCOMPLIT, nil, typenod(n.Type))
 	nn.List.Set(l)
 	nn = typecheck(nn, ctxExpr)
 	return nn
 }
 
-var mapqueue []*Node
+var mapqueue []*ir.Node
 
 func checkMapKeys() {
 	for _, n := range mapqueue {
@@ -3471,13 +3472,13 @@ func checkMapKeys() {
 }
 
 func setUnderlying(t, underlying *types.Type) {
-	if underlying.Etype == TFORW {
+	if underlying.Etype == types.TFORW {
 		// This type isn't computed yet; when it is, update n.
 		underlying.ForwardType().Copyto = append(underlying.ForwardType().Copyto, t)
 		return
 	}
 
-	n := asNode(t.Nod)
+	n := ir.AsNode(t.Nod)
 	ft := t.ForwardType()
 	cache := t.Cache
 
@@ -3485,7 +3486,7 @@ func setUnderlying(t, underlying *types.Type) {
 	*t = *underlying
 
 	// Restore unnecessarily clobbered attributes.
-	t.Nod = asTypesNode(n)
+	t.Nod = ir.AsTypesNode(n)
 	t.Sym = n.Sym
 	if n.Name != nil {
 		t.Vargen = n.Name.Vargen
@@ -3502,7 +3503,7 @@ func setUnderlying(t, underlying *types.Type) {
 	}
 
 	// Propagate go:notinheap pragma from the Name to the Type.
-	if n.Name != nil && n.Name.Param != nil && n.Name.Param.Pragma()&NotInHeap != 0 {
+	if n.Name != nil && n.Name.Param != nil && n.Name.Param.Pragma()&ir.NotInHeap != 0 {
 		t.SetNotInHeap(true)
 	}
 
@@ -3519,7 +3520,7 @@ func setUnderlying(t, underlying *types.Type) {
 	}
 }
 
-func typecheckdeftype(n *Node) {
+func typecheckdeftype(n *ir.Node) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckdeftype", n)(nil)
 	}
@@ -3539,14 +3540,14 @@ func typecheckdeftype(n *Node) {
 	}
 }
 
-func typecheckdef(n *Node) {
+func typecheckdef(n *ir.Node) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckdef", n)(nil)
 	}
 
 	lno := setlineno(n)
 
-	if n.Op == ONONAME {
+	if n.Op == ir.ONONAME {
 		if !n.Diag() {
 			n.SetDiag(true)
 
@@ -3585,7 +3586,7 @@ func typecheckdef(n *Node) {
 	default:
 		base.Fatalf("typecheckdef %v", n.Op)
 
-	case OLITERAL:
+	case ir.OLITERAL:
 		if n.Name.Param.Ntype != nil {
 			n.Name.Param.Ntype = typecheck(n.Name.Param.Ntype, ctxType)
 			n.Type = n.Name.Param.Ntype.Type
@@ -3599,7 +3600,7 @@ func typecheckdef(n *Node) {
 		e := n.Name.Defn
 		n.Name.Defn = nil
 		if e == nil {
-			Dump("typecheckdef nil defn", n)
+			ir.Dump("typecheckdef nil defn", n)
 			base.ErrorfAt(n.Pos, "xxx")
 		}
 
@@ -3607,9 +3608,9 @@ func typecheckdef(n *Node) {
 		if e.Type == nil {
 			goto ret
 		}
-		if !e.isGoConst() {
+		if !isGoConst(e) {
 			if !e.Diag() {
-				if e.Op == ONIL {
+				if e.Op == ir.ONIL {
 					base.ErrorfAt(n.Pos, "const initializer cannot be nil")
 				} else {
 					base.ErrorfAt(n.Pos, "const initializer %v is not a constant", e)
@@ -3621,7 +3622,7 @@ func typecheckdef(n *Node) {
 
 		t := n.Type
 		if t != nil {
-			if !okforconst[t.Etype] {
+			if !ir.OKForConst[t.Etype] {
 				base.ErrorfAt(n.Pos, "invalid constant type %v", t)
 				goto ret
 			}
@@ -3639,7 +3640,7 @@ func typecheckdef(n *Node) {
 			n.SetVal(e.Val())
 		}
 
-	case ONAME:
+	case ir.ONAME:
 		if n.Name.Param.Ntype != nil {
 			n.Name.Param.Ntype = typecheck(n.Name.Param.Ntype, ctxType)
 			n.Type = n.Name.Param.Ntype.Type
@@ -3667,7 +3668,7 @@ func typecheckdef(n *Node) {
 			base.Fatalf("var without type, init: %v", n.Sym)
 		}
 
-		if n.Name.Defn.Op == ONAME {
+		if n.Name.Defn.Op == ir.ONAME {
 			n.Name.Defn = typecheck(n.Name.Defn, ctxExpr)
 			n.Type = n.Name.Defn.Type
 			break
@@ -3675,7 +3676,7 @@ func typecheckdef(n *Node) {
 
 		n.Name.Defn = typecheck(n.Name.Defn, ctxStmt) // fills in n.Type
 
-	case OTYPE:
+	case ir.OTYPE:
 		if p := n.Name.Param; p.Alias() {
 			// Type alias declaration: Simply use the rhs type - no need
 			// to create a new type.
@@ -3690,7 +3691,7 @@ func typecheckdef(n *Node) {
 				// For package-level type aliases, set n.Sym.Def so we can identify
 				// it as a type alias during export. See also #31959.
 				if n.Name.Curfn == nil {
-					n.Sym.Def = asTypesNode(p.Ntype)
+					n.Sym.Def = ir.AsTypesNode(p.Ntype)
 				}
 			}
 			break
@@ -3699,11 +3700,11 @@ func typecheckdef(n *Node) {
 		// regular type declaration
 		defercheckwidth()
 		n.SetWalkdef(1)
-		setTypeNode(n, types.New(TFORW))
+		setTypeNode(n, types.New(types.TFORW))
 		n.Type.Sym = n.Sym
 		errorsBefore := base.Errors()
 		typecheckdeftype(n)
-		if n.Type.Etype == TFORW && base.Errors() > errorsBefore {
+		if n.Type.Etype == types.TFORW && base.Errors() > errorsBefore {
 			// Something went wrong during type-checking,
 			// but it was reported. Silence future errors.
 			n.Type.SetBroke(true)
@@ -3712,7 +3713,7 @@ func typecheckdef(n *Node) {
 	}
 
 ret:
-	if n.Op != OLITERAL && n.Type != nil && n.Type.IsUntyped() {
+	if n.Op != ir.OLITERAL && n.Type != nil && n.Type.IsUntyped() {
 		base.Fatalf("got %v for %v", n.Type, n)
 	}
 	last := len(typecheckdefstack) - 1
@@ -3726,22 +3727,22 @@ ret:
 	n.SetWalkdef(1)
 }
 
-func checkmake(t *types.Type, arg string, np **Node) bool {
+func checkmake(t *types.Type, arg string, np **ir.Node) bool {
 	n := *np
-	if !n.Type.IsInteger() && n.Type.Etype != TIDEAL {
+	if !n.Type.IsInteger() && n.Type.Etype != types.TIDEAL {
 		base.Errorf("non-integer %s argument in make(%v) - %v", arg, t, n.Type)
 		return false
 	}
 
 	// Do range checks for constants before defaultlit
 	// to avoid redundant "constant NNN overflows int" errors.
-	if n.Op == OLITERAL {
+	if n.Op == ir.OLITERAL {
 		v := toint(n.Val())
 		if constant.Sign(v) < 0 {
 			base.Errorf("negative %s argument in make(%v)", arg, t)
 			return false
 		}
-		if doesoverflow(v, types.Types[TINT]) {
+		if doesoverflow(v, types.Types[types.TINT]) {
 			base.Errorf("%s argument too large in make(%v)", arg, t)
 			return false
 		}
@@ -3752,30 +3753,30 @@ func checkmake(t *types.Type, arg string, np **Node) bool {
 	// are the same as for index expressions. Factor the code better;
 	// for instance, indexlit might be called here and incorporate some
 	// of the bounds checks done for make.
-	n = defaultlit(n, types.Types[TINT])
+	n = defaultlit(n, types.Types[types.TINT])
 	*np = n
 
 	return true
 }
 
-func markbreak(n *Node, implicit *Node) {
+func markbreak(n *ir.Node, implicit *ir.Node) {
 	if n == nil {
 		return
 	}
 
 	switch n.Op {
-	case OBREAK:
+	case ir.OBREAK:
 		if n.Sym == nil {
 			if implicit != nil {
 				implicit.SetHasBreak(true)
 			}
 		} else {
-			lab := asNode(n.Sym.Label)
+			lab := ir.AsNode(n.Sym.Label)
 			if lab != nil {
 				lab.SetHasBreak(true)
 			}
 		}
-	case OFOR, OFORUNTIL, OSWITCH, OTYPESW, OSELECT, ORANGE:
+	case ir.OFOR, ir.OFORUNTIL, ir.OSWITCH, ir.OTYPESW, ir.OSELECT, ir.ORANGE:
 		implicit = n
 		fallthrough
 	default:
@@ -3788,17 +3789,17 @@ func markbreak(n *Node, implicit *Node) {
 	}
 }
 
-func markbreaklist(l Nodes, implicit *Node) {
+func markbreaklist(l ir.Nodes, implicit *ir.Node) {
 	s := l.Slice()
 	for i := 0; i < len(s); i++ {
 		n := s[i]
 		if n == nil {
 			continue
 		}
-		if n.Op == OLABEL && i+1 < len(s) && n.Name.Defn == s[i+1] {
+		if n.Op == ir.OLABEL && i+1 < len(s) && n.Name.Defn == s[i+1] {
 			switch n.Name.Defn.Op {
-			case OFOR, OFORUNTIL, OSWITCH, OTYPESW, OSELECT, ORANGE:
-				n.Sym.Label = asTypesNode(n.Name.Defn)
+			case ir.OFOR, ir.OFORUNTIL, ir.OSWITCH, ir.OTYPESW, ir.OSELECT, ir.ORANGE:
+				n.Sym.Label = ir.AsTypesNode(n.Name.Defn)
 				markbreak(n.Name.Defn, n.Name.Defn)
 				n.Sym.Label = nil
 				i++
@@ -3811,31 +3812,31 @@ func markbreaklist(l Nodes, implicit *Node) {
 }
 
 // isterminating reports whether the Nodes list ends with a terminating statement.
-func (l Nodes) isterminating() bool {
+func isTermNodes(l ir.Nodes) bool {
 	s := l.Slice()
 	c := len(s)
 	if c == 0 {
 		return false
 	}
-	return s[c-1].isterminating()
+	return isTermNode(s[c-1])
 }
 
 // Isterminating reports whether the node n, the last one in a
 // statement list, is a terminating statement.
-func (n *Node) isterminating() bool {
+func isTermNode(n *ir.Node) bool {
 	switch n.Op {
 	// NOTE: OLABEL is treated as a separate statement,
 	// not a separate prefix, so skipping to the last statement
 	// in the block handles the labeled statement case by
 	// skipping over the label. No case OLABEL here.
 
-	case OBLOCK:
-		return n.List.isterminating()
+	case ir.OBLOCK:
+		return isTermNodes(n.List)
 
-	case OGOTO, ORETURN, ORETJMP, OPANIC, OFALL:
+	case ir.OGOTO, ir.ORETURN, ir.ORETJMP, ir.OPANIC, ir.OFALL:
 		return true
 
-	case OFOR, OFORUNTIL:
+	case ir.OFOR, ir.OFORUNTIL:
 		if n.Left != nil {
 			return false
 		}
@@ -3844,16 +3845,16 @@ func (n *Node) isterminating() bool {
 		}
 		return true
 
-	case OIF:
-		return n.Nbody.isterminating() && n.Rlist.isterminating()
+	case ir.OIF:
+		return isTermNodes(n.Nbody) && isTermNodes(n.Rlist)
 
-	case OSWITCH, OTYPESW, OSELECT:
+	case ir.OSWITCH, ir.OTYPESW, ir.OSELECT:
 		if n.HasBreak() {
 			return false
 		}
 		def := false
 		for _, n1 := range n.List.Slice() {
-			if !n1.Nbody.isterminating() {
+			if !isTermNodes(n1.Nbody) {
 				return false
 			}
 			if n1.List.Len() == 0 { // default
@@ -3861,7 +3862,7 @@ func (n *Node) isterminating() bool {
 			}
 		}
 
-		if n.Op != OSELECT && !def {
+		if n.Op != ir.OSELECT && !def {
 			return false
 		}
 		return true
@@ -3871,21 +3872,21 @@ func (n *Node) isterminating() bool {
 }
 
 // checkreturn makes sure that fn terminates appropriately.
-func checkreturn(fn *Node) {
+func checkreturn(fn *ir.Node) {
 	if fn.Type.NumResults() != 0 && fn.Nbody.Len() != 0 {
 		markbreaklist(fn.Nbody, nil)
-		if !fn.Nbody.isterminating() {
+		if !isTermNodes(fn.Nbody) {
 			base.ErrorfAt(fn.Func.Endlineno, "missing return at end of function")
 		}
 	}
 }
 
-func deadcode(fn *Node) {
+func deadcode(fn *ir.Node) {
 	deadcodeslice(&fn.Nbody)
 	deadcodefn(fn)
 }
 
-func deadcodefn(fn *Node) {
+func deadcodefn(fn *ir.Node) {
 	if fn.Nbody.Len() == 0 {
 		return
 	}
@@ -3895,12 +3896,12 @@ func deadcodefn(fn *Node) {
 			return
 		}
 		switch n.Op {
-		case OIF:
-			if !Isconst(n.Left, constant.Bool) || n.Nbody.Len() > 0 || n.Rlist.Len() > 0 {
+		case ir.OIF:
+			if !ir.IsConst(n.Left, constant.Bool) || n.Nbody.Len() > 0 || n.Rlist.Len() > 0 {
 				return
 			}
-		case OFOR:
-			if !Isconst(n.Left, constant.Bool) || n.Left.BoolVal() {
+		case ir.OFOR:
+			if !ir.IsConst(n.Left, constant.Bool) || n.Left.BoolVal() {
 				return
 			}
 		default:
@@ -3908,13 +3909,13 @@ func deadcodefn(fn *Node) {
 		}
 	}
 
-	fn.Nbody.Set([]*Node{nod(OEMPTY, nil, nil)})
+	fn.Nbody.Set([]*ir.Node{ir.Nod(ir.OEMPTY, nil, nil)})
 }
 
-func deadcodeslice(nn *Nodes) {
+func deadcodeslice(nn *ir.Nodes) {
 	var lastLabel = -1
 	for i, n := range nn.Slice() {
-		if n != nil && n.Op == OLABEL {
+		if n != nil && n.Op == ir.OLABEL {
 			lastLabel = i
 		}
 	}
@@ -3926,15 +3927,15 @@ func deadcodeslice(nn *Nodes) {
 		if n == nil {
 			continue
 		}
-		if n.Op == OIF {
+		if n.Op == ir.OIF {
 			n.Left = deadcodeexpr(n.Left)
-			if Isconst(n.Left, constant.Bool) {
-				var body Nodes
+			if ir.IsConst(n.Left, constant.Bool) {
+				var body ir.Nodes
 				if n.Left.BoolVal() {
-					n.Rlist = Nodes{}
+					n.Rlist = ir.Nodes{}
 					body = n.Nbody
 				} else {
-					n.Nbody = Nodes{}
+					n.Nbody = ir.Nodes{}
 					body = n.Rlist
 				}
 				// If "then" or "else" branch ends with panic or return statement,
@@ -3944,7 +3945,7 @@ func deadcodeslice(nn *Nodes) {
 				// might be the target of a goto. See issue 28616.
 				if body := body.Slice(); len(body) != 0 {
 					switch body[(len(body) - 1)].Op {
-					case ORETURN, ORETJMP, OPANIC:
+					case ir.ORETURN, ir.ORETJMP, ir.OPANIC:
 						if i > lastLabel {
 							cut = true
 						}
@@ -3964,25 +3965,25 @@ func deadcodeslice(nn *Nodes) {
 	}
 }
 
-func deadcodeexpr(n *Node) *Node {
+func deadcodeexpr(n *ir.Node) *ir.Node {
 	// Perform dead-code elimination on short-circuited boolean
 	// expressions involving constants with the intent of
 	// producing a constant 'if' condition.
 	switch n.Op {
-	case OANDAND:
+	case ir.OANDAND:
 		n.Left = deadcodeexpr(n.Left)
 		n.Right = deadcodeexpr(n.Right)
-		if Isconst(n.Left, constant.Bool) {
+		if ir.IsConst(n.Left, constant.Bool) {
 			if n.Left.BoolVal() {
 				return n.Right // true && x => x
 			} else {
 				return n.Left // false && x => false
 			}
 		}
-	case OOROR:
+	case ir.OOROR:
 		n.Left = deadcodeexpr(n.Left)
 		n.Right = deadcodeexpr(n.Right)
-		if Isconst(n.Left, constant.Bool) {
+		if ir.IsConst(n.Left, constant.Bool) {
 			if n.Left.BoolVal() {
 				return n.Left // true || x => true
 			} else {
@@ -3994,17 +3995,17 @@ func deadcodeexpr(n *Node) *Node {
 }
 
 // setTypeNode sets n to an OTYPE node representing t.
-func setTypeNode(n *Node, t *types.Type) {
-	n.Op = OTYPE
+func setTypeNode(n *ir.Node, t *types.Type) {
+	n.Op = ir.OTYPE
 	n.Type = t
-	n.Type.Nod = asTypesNode(n)
+	n.Type.Nod = ir.AsTypesNode(n)
 }
 
 // getIotaValue returns the current value for "iota",
 // or -1 if not within a ConstSpec.
 func getIotaValue() int64 {
 	if i := len(typecheckdefstack); i > 0 {
-		if x := typecheckdefstack[i-1]; x.Op == OLITERAL {
+		if x := typecheckdefstack[i-1]; x.Op == ir.OLITERAL {
 			return x.Iota()
 		}
 	}
@@ -4021,12 +4022,12 @@ func curpkg() *types.Pkg {
 	fn := Curfn
 	if fn == nil {
 		// Initialization expressions for package-scope variables.
-		return localpkg
+		return ir.LocalPkg
 	}
 
 	// TODO(mdempsky): Standardize on either ODCLFUNC or ONAME for
 	// Curfn, rather than mixing them.
-	if fn.Op == ODCLFUNC {
+	if fn.Op == ir.ODCLFUNC {
 		fn = fn.Func.Nname
 	}
 
@@ -4036,16 +4037,16 @@ func curpkg() *types.Pkg {
 // MethodName returns the ONAME representing the method
 // referenced by expression n, which must be a method selector,
 // method expression, or method value.
-func (n *Node) MethodName() *Node {
-	return asNode(n.MethodFunc().Nname)
+func methodExprName(n *ir.Node) *ir.Node {
+	return ir.AsNode(methodExprFunc(n).Nname)
 }
 
 // MethodFunc is like MethodName, but returns the types.Field instead.
-func (n *Node) MethodFunc() *types.Field {
+func methodExprFunc(n *ir.Node) *types.Field {
 	switch n.Op {
-	case ODOTMETH, OMETHEXPR:
+	case ir.ODOTMETH, ir.OMETHEXPR:
 		return n.Opt().(*types.Field)
-	case OCALLPART:
+	case ir.OCALLPART:
 		return callpartMethod(n)
 	}
 	base.Fatalf("unexpected node: %v (%v)", n, n.Op)
diff --git a/src/cmd/compile/internal/gc/types.go b/src/cmd/compile/internal/gc/types.go
index 748f8458bd..e46735df28 100644
--- a/src/cmd/compile/internal/gc/types.go
+++ b/src/cmd/compile/internal/gc/types.go
@@ -3,56 +3,3 @@
 // license that can be found in the LICENSE file.
 
 package gc
-
-import (
-	"cmd/compile/internal/types"
-)
-
-// convenience constants
-const (
-	Txxx = types.Txxx
-
-	TINT8    = types.TINT8
-	TUINT8   = types.TUINT8
-	TINT16   = types.TINT16
-	TUINT16  = types.TUINT16
-	TINT32   = types.TINT32
-	TUINT32  = types.TUINT32
-	TINT64   = types.TINT64
-	TUINT64  = types.TUINT64
-	TINT     = types.TINT
-	TUINT    = types.TUINT
-	TUINTPTR = types.TUINTPTR
-
-	TCOMPLEX64  = types.TCOMPLEX64
-	TCOMPLEX128 = types.TCOMPLEX128
-
-	TFLOAT32 = types.TFLOAT32
-	TFLOAT64 = types.TFLOAT64
-
-	TBOOL = types.TBOOL
-
-	TPTR       = types.TPTR
-	TFUNC      = types.TFUNC
-	TSLICE     = types.TSLICE
-	TARRAY     = types.TARRAY
-	TSTRUCT    = types.TSTRUCT
-	TCHAN      = types.TCHAN
-	TMAP       = types.TMAP
-	TINTER     = types.TINTER
-	TFORW      = types.TFORW
-	TANY       = types.TANY
-	TSTRING    = types.TSTRING
-	TUNSAFEPTR = types.TUNSAFEPTR
-
-	// pseudo-types for literals
-	TIDEAL = types.TIDEAL
-	TNIL   = types.TNIL
-	TBLANK = types.TBLANK
-
-	// pseudo-types for frame layout
-	TFUNCARGS = types.TFUNCARGS
-	TCHANARGS = types.TCHANARGS
-
-	NTYPE = types.NTYPE
-)
diff --git a/src/cmd/compile/internal/gc/types_acc.go b/src/cmd/compile/internal/gc/types_acc.go
index 7240f726f6..d6d53f05cc 100644
--- a/src/cmd/compile/internal/gc/types_acc.go
+++ b/src/cmd/compile/internal/gc/types_acc.go
@@ -6,11 +6,3 @@
 // TODO(gri) try to eliminate these soon
 
 package gc
-
-import (
-	"cmd/compile/internal/types"
-	"unsafe"
-)
-
-func asNode(n *types.Node) *Node      { return (*Node)(unsafe.Pointer(n)) }
-func asTypesNode(n *Node) *types.Node { return (*types.Node)(unsafe.Pointer(n)) }
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index aa0ee4075d..bf31055dcc 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -8,31 +8,29 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 )
 
-// builtinpkg is a fake package that declares the universe block.
-var builtinpkg *types.Pkg
-
 var basicTypes = [...]struct {
 	name  string
 	etype types.EType
 }{
-	{"int8", TINT8},
-	{"int16", TINT16},
-	{"int32", TINT32},
-	{"int64", TINT64},
-	{"uint8", TUINT8},
-	{"uint16", TUINT16},
-	{"uint32", TUINT32},
-	{"uint64", TUINT64},
-	{"float32", TFLOAT32},
-	{"float64", TFLOAT64},
-	{"complex64", TCOMPLEX64},
-	{"complex128", TCOMPLEX128},
-	{"bool", TBOOL},
-	{"string", TSTRING},
+	{"int8", types.TINT8},
+	{"int16", types.TINT16},
+	{"int32", types.TINT32},
+	{"int64", types.TINT64},
+	{"uint8", types.TUINT8},
+	{"uint16", types.TUINT16},
+	{"uint32", types.TUINT32},
+	{"uint64", types.TUINT64},
+	{"float32", types.TFLOAT32},
+	{"float64", types.TFLOAT64},
+	{"complex64", types.TCOMPLEX64},
+	{"complex128", types.TCOMPLEX128},
+	{"bool", types.TBOOL},
+	{"string", types.TSTRING},
 }
 
 var typedefs = [...]struct {
@@ -41,30 +39,30 @@ var typedefs = [...]struct {
 	sameas32 types.EType
 	sameas64 types.EType
 }{
-	{"int", TINT, TINT32, TINT64},
-	{"uint", TUINT, TUINT32, TUINT64},
-	{"uintptr", TUINTPTR, TUINT32, TUINT64},
+	{"int", types.TINT, types.TINT32, types.TINT64},
+	{"uint", types.TUINT, types.TUINT32, types.TUINT64},
+	{"uintptr", types.TUINTPTR, types.TUINT32, types.TUINT64},
 }
 
 var builtinFuncs = [...]struct {
 	name string
-	op   Op
+	op   ir.Op
 }{
-	{"append", OAPPEND},
-	{"cap", OCAP},
-	{"close", OCLOSE},
-	{"complex", OCOMPLEX},
-	{"copy", OCOPY},
-	{"delete", ODELETE},
-	{"imag", OIMAG},
-	{"len", OLEN},
-	{"make", OMAKE},
-	{"new", ONEW},
-	{"panic", OPANIC},
-	{"print", OPRINT},
-	{"println", OPRINTN},
-	{"real", OREAL},
-	{"recover", ORECOVER},
+	{"append", ir.OAPPEND},
+	{"cap", ir.OCAP},
+	{"close", ir.OCLOSE},
+	{"complex", ir.OCOMPLEX},
+	{"copy", ir.OCOPY},
+	{"delete", ir.ODELETE},
+	{"imag", ir.OIMAG},
+	{"len", ir.OLEN},
+	{"make", ir.OMAKE},
+	{"new", ir.ONEW},
+	{"panic", ir.OPANIC},
+	{"print", ir.OPRINT},
+	{"println", ir.OPRINTN},
+	{"real", ir.OREAL},
+	{"recover", ir.ORECOVER},
 }
 
 // isBuiltinFuncName reports whether name matches a builtin function
@@ -80,11 +78,11 @@ func isBuiltinFuncName(name string) bool {
 
 var unsafeFuncs = [...]struct {
 	name string
-	op   Op
+	op   ir.Op
 }{
-	{"Alignof", OALIGNOF},
-	{"Offsetof", OOFFSETOF},
-	{"Sizeof", OSIZEOF},
+	{"Alignof", ir.OALIGNOF},
+	{"Offsetof", ir.OOFFSETOF},
+	{"Sizeof", ir.OSIZEOF},
 }
 
 // initUniverse initializes the universe block.
@@ -101,71 +99,71 @@ func lexinit() {
 		if int(etype) >= len(types.Types) {
 			base.Fatalf("lexinit: %s bad etype", s.name)
 		}
-		s2 := builtinpkg.Lookup(s.name)
+		s2 := ir.BuiltinPkg.Lookup(s.name)
 		t := types.Types[etype]
 		if t == nil {
 			t = types.New(etype)
 			t.Sym = s2
-			if etype != TANY && etype != TSTRING {
+			if etype != types.TANY && etype != types.TSTRING {
 				dowidth(t)
 			}
 			types.Types[etype] = t
 		}
-		s2.Def = asTypesNode(typenod(t))
-		asNode(s2.Def).Name = new(Name)
+		s2.Def = ir.AsTypesNode(typenod(t))
+		ir.AsNode(s2.Def).Name = new(ir.Name)
 	}
 
 	for _, s := range &builtinFuncs {
-		s2 := builtinpkg.Lookup(s.name)
-		s2.Def = asTypesNode(newname(s2))
-		asNode(s2.Def).SetSubOp(s.op)
+		s2 := ir.BuiltinPkg.Lookup(s.name)
+		s2.Def = ir.AsTypesNode(NewName(s2))
+		ir.AsNode(s2.Def).SetSubOp(s.op)
 	}
 
 	for _, s := range &unsafeFuncs {
 		s2 := unsafepkg.Lookup(s.name)
-		s2.Def = asTypesNode(newname(s2))
-		asNode(s2.Def).SetSubOp(s.op)
+		s2.Def = ir.AsTypesNode(NewName(s2))
+		ir.AsNode(s2.Def).SetSubOp(s.op)
 	}
 
-	types.UntypedString = types.New(TSTRING)
-	types.UntypedBool = types.New(TBOOL)
-	types.Types[TANY] = types.New(TANY)
+	types.UntypedString = types.New(types.TSTRING)
+	types.UntypedBool = types.New(types.TBOOL)
+	types.Types[types.TANY] = types.New(types.TANY)
 
-	s := builtinpkg.Lookup("true")
-	s.Def = asTypesNode(nodbool(true))
-	asNode(s.Def).Sym = lookup("true")
-	asNode(s.Def).Name = new(Name)
-	asNode(s.Def).Type = types.UntypedBool
+	s := ir.BuiltinPkg.Lookup("true")
+	s.Def = ir.AsTypesNode(nodbool(true))
+	ir.AsNode(s.Def).Sym = lookup("true")
+	ir.AsNode(s.Def).Name = new(ir.Name)
+	ir.AsNode(s.Def).Type = types.UntypedBool
 
-	s = builtinpkg.Lookup("false")
-	s.Def = asTypesNode(nodbool(false))
-	asNode(s.Def).Sym = lookup("false")
-	asNode(s.Def).Name = new(Name)
-	asNode(s.Def).Type = types.UntypedBool
+	s = ir.BuiltinPkg.Lookup("false")
+	s.Def = ir.AsTypesNode(nodbool(false))
+	ir.AsNode(s.Def).Sym = lookup("false")
+	ir.AsNode(s.Def).Name = new(ir.Name)
+	ir.AsNode(s.Def).Type = types.UntypedBool
 
 	s = lookup("_")
 	s.Block = -100
-	s.Def = asTypesNode(newname(s))
-	types.Types[TBLANK] = types.New(TBLANK)
-	asNode(s.Def).Type = types.Types[TBLANK]
-	nblank = asNode(s.Def)
+	s.Def = ir.AsTypesNode(NewName(s))
+	types.Types[types.TBLANK] = types.New(types.TBLANK)
+	ir.AsNode(s.Def).Type = types.Types[types.TBLANK]
+	ir.BlankNode = ir.AsNode(s.Def)
 
-	s = builtinpkg.Lookup("_")
+	s = ir.BuiltinPkg.Lookup("_")
 	s.Block = -100
-	s.Def = asTypesNode(newname(s))
-	types.Types[TBLANK] = types.New(TBLANK)
-	asNode(s.Def).Type = types.Types[TBLANK]
-
-	types.Types[TNIL] = types.New(TNIL)
-	s = builtinpkg.Lookup("nil")
-	s.Def = asTypesNode(nodnil())
-	asNode(s.Def).Sym = s
-	asNode(s.Def).Name = new(Name)
-
-	s = builtinpkg.Lookup("iota")
-	s.Def = asTypesNode(nod(OIOTA, nil, nil))
-	asNode(s.Def).Sym = s
-	asNode(s.Def).Name = new(Name)
+	s.Def = ir.AsTypesNode(NewName(s))
+	types.Types[types.TBLANK] = types.New(types.TBLANK)
+	ir.AsNode(s.Def).Type = types.Types[types.TBLANK]
+
+	types.Types[types.TNIL] = types.New(types.TNIL)
+	s = ir.BuiltinPkg.Lookup("nil")
+	s.Def = ir.AsTypesNode(nodnil())
+	ir.AsNode(s.Def).Sym = s
+	ir.AsNode(s.Def).Name = new(ir.Name)
+
+	s = ir.BuiltinPkg.Lookup("iota")
+	s.Def = ir.AsTypesNode(ir.Nod(ir.OIOTA, nil, nil))
+	ir.AsNode(s.Def).Sym = s
+	ir.AsNode(s.Def).Name = new(ir.Name)
 }
 
 func typeinit() {
@@ -173,42 +171,42 @@ func typeinit() {
 		base.Fatalf("typeinit before betypeinit")
 	}
 
-	for et := types.EType(0); et < NTYPE; et++ {
+	for et := types.EType(0); et < types.NTYPE; et++ {
 		simtype[et] = et
 	}
 
-	types.Types[TPTR] = types.New(TPTR)
-	dowidth(types.Types[TPTR])
+	types.Types[types.TPTR] = types.New(types.TPTR)
+	dowidth(types.Types[types.TPTR])
 
-	t := types.New(TUNSAFEPTR)
-	types.Types[TUNSAFEPTR] = t
+	t := types.New(types.TUNSAFEPTR)
+	types.Types[types.TUNSAFEPTR] = t
 	t.Sym = unsafepkg.Lookup("Pointer")
-	t.Sym.Def = asTypesNode(typenod(t))
-	asNode(t.Sym.Def).Name = new(Name)
-	dowidth(types.Types[TUNSAFEPTR])
+	t.Sym.Def = ir.AsTypesNode(typenod(t))
+	ir.AsNode(t.Sym.Def).Name = new(ir.Name)
+	dowidth(types.Types[types.TUNSAFEPTR])
 
-	for et := TINT8; et <= TUINT64; et++ {
+	for et := types.TINT8; et <= types.TUINT64; et++ {
 		isInt[et] = true
 	}
-	isInt[TINT] = true
-	isInt[TUINT] = true
-	isInt[TUINTPTR] = true
+	isInt[types.TINT] = true
+	isInt[types.TUINT] = true
+	isInt[types.TUINTPTR] = true
 
-	isFloat[TFLOAT32] = true
-	isFloat[TFLOAT64] = true
+	isFloat[types.TFLOAT32] = true
+	isFloat[types.TFLOAT64] = true
 
-	isComplex[TCOMPLEX64] = true
-	isComplex[TCOMPLEX128] = true
+	isComplex[types.TCOMPLEX64] = true
+	isComplex[types.TCOMPLEX128] = true
 
 	// initialize okfor
-	for et := types.EType(0); et < NTYPE; et++ {
-		if isInt[et] || et == TIDEAL {
+	for et := types.EType(0); et < types.NTYPE; et++ {
+		if isInt[et] || et == types.TIDEAL {
 			okforeq[et] = true
 			okforcmp[et] = true
 			okforarith[et] = true
 			okforadd[et] = true
 			okforand[et] = true
-			okforconst[et] = true
+			ir.OKForConst[et] = true
 			issimple[et] = true
 		}
 
@@ -217,7 +215,7 @@ func typeinit() {
 			okforcmp[et] = true
 			okforadd[et] = true
 			okforarith[et] = true
-			okforconst[et] = true
+			ir.OKForConst[et] = true
 			issimple[et] = true
 		}
 
@@ -225,43 +223,43 @@ func typeinit() {
 			okforeq[et] = true
 			okforadd[et] = true
 			okforarith[et] = true
-			okforconst[et] = true
+			ir.OKForConst[et] = true
 			issimple[et] = true
 		}
 	}
 
-	issimple[TBOOL] = true
+	issimple[types.TBOOL] = true
 
-	okforadd[TSTRING] = true
+	okforadd[types.TSTRING] = true
 
-	okforbool[TBOOL] = true
+	okforbool[types.TBOOL] = true
 
-	okforcap[TARRAY] = true
-	okforcap[TCHAN] = true
-	okforcap[TSLICE] = true
+	okforcap[types.TARRAY] = true
+	okforcap[types.TCHAN] = true
+	okforcap[types.TSLICE] = true
 
-	okforconst[TBOOL] = true
-	okforconst[TSTRING] = true
+	ir.OKForConst[types.TBOOL] = true
+	ir.OKForConst[types.TSTRING] = true
 
-	okforlen[TARRAY] = true
-	okforlen[TCHAN] = true
-	okforlen[TMAP] = true
-	okforlen[TSLICE] = true
-	okforlen[TSTRING] = true
+	okforlen[types.TARRAY] = true
+	okforlen[types.TCHAN] = true
+	okforlen[types.TMAP] = true
+	okforlen[types.TSLICE] = true
+	okforlen[types.TSTRING] = true
 
-	okforeq[TPTR] = true
-	okforeq[TUNSAFEPTR] = true
-	okforeq[TINTER] = true
-	okforeq[TCHAN] = true
-	okforeq[TSTRING] = true
-	okforeq[TBOOL] = true
-	okforeq[TMAP] = true    // nil only; refined in typecheck
-	okforeq[TFUNC] = true   // nil only; refined in typecheck
-	okforeq[TSLICE] = true  // nil only; refined in typecheck
-	okforeq[TARRAY] = true  // only if element type is comparable; refined in typecheck
-	okforeq[TSTRUCT] = true // only if all struct fields are comparable; refined in typecheck
+	okforeq[types.TPTR] = true
+	okforeq[types.TUNSAFEPTR] = true
+	okforeq[types.TINTER] = true
+	okforeq[types.TCHAN] = true
+	okforeq[types.TSTRING] = true
+	okforeq[types.TBOOL] = true
+	okforeq[types.TMAP] = true    // nil only; refined in typecheck
+	okforeq[types.TFUNC] = true   // nil only; refined in typecheck
+	okforeq[types.TSLICE] = true  // nil only; refined in typecheck
+	okforeq[types.TARRAY] = true  // only if element type is comparable; refined in typecheck
+	okforeq[types.TSTRUCT] = true // only if all struct fields are comparable; refined in typecheck
 
-	okforcmp[TSTRING] = true
+	okforcmp[types.TSTRING] = true
 
 	var i int
 	for i = 0; i < len(okfor); i++ {
@@ -269,51 +267,51 @@ func typeinit() {
 	}
 
 	// binary
-	okfor[OADD] = okforadd[:]
-	okfor[OAND] = okforand[:]
-	okfor[OANDAND] = okforbool[:]
-	okfor[OANDNOT] = okforand[:]
-	okfor[ODIV] = okforarith[:]
-	okfor[OEQ] = okforeq[:]
-	okfor[OGE] = okforcmp[:]
-	okfor[OGT] = okforcmp[:]
-	okfor[OLE] = okforcmp[:]
-	okfor[OLT] = okforcmp[:]
-	okfor[OMOD] = okforand[:]
-	okfor[OMUL] = okforarith[:]
-	okfor[ONE] = okforeq[:]
-	okfor[OOR] = okforand[:]
-	okfor[OOROR] = okforbool[:]
-	okfor[OSUB] = okforarith[:]
-	okfor[OXOR] = okforand[:]
-	okfor[OLSH] = okforand[:]
-	okfor[ORSH] = okforand[:]
+	okfor[ir.OADD] = okforadd[:]
+	okfor[ir.OAND] = okforand[:]
+	okfor[ir.OANDAND] = okforbool[:]
+	okfor[ir.OANDNOT] = okforand[:]
+	okfor[ir.ODIV] = okforarith[:]
+	okfor[ir.OEQ] = okforeq[:]
+	okfor[ir.OGE] = okforcmp[:]
+	okfor[ir.OGT] = okforcmp[:]
+	okfor[ir.OLE] = okforcmp[:]
+	okfor[ir.OLT] = okforcmp[:]
+	okfor[ir.OMOD] = okforand[:]
+	okfor[ir.OMUL] = okforarith[:]
+	okfor[ir.ONE] = okforeq[:]
+	okfor[ir.OOR] = okforand[:]
+	okfor[ir.OOROR] = okforbool[:]
+	okfor[ir.OSUB] = okforarith[:]
+	okfor[ir.OXOR] = okforand[:]
+	okfor[ir.OLSH] = okforand[:]
+	okfor[ir.ORSH] = okforand[:]
 
 	// unary
-	okfor[OBITNOT] = okforand[:]
-	okfor[ONEG] = okforarith[:]
-	okfor[ONOT] = okforbool[:]
-	okfor[OPLUS] = okforarith[:]
+	okfor[ir.OBITNOT] = okforand[:]
+	okfor[ir.ONEG] = okforarith[:]
+	okfor[ir.ONOT] = okforbool[:]
+	okfor[ir.OPLUS] = okforarith[:]
 
 	// special
-	okfor[OCAP] = okforcap[:]
-	okfor[OLEN] = okforlen[:]
+	okfor[ir.OCAP] = okforcap[:]
+	okfor[ir.OLEN] = okforlen[:]
 
 	// comparison
-	iscmp[OLT] = true
-	iscmp[OGT] = true
-	iscmp[OGE] = true
-	iscmp[OLE] = true
-	iscmp[OEQ] = true
-	iscmp[ONE] = true
+	iscmp[ir.OLT] = true
+	iscmp[ir.OGT] = true
+	iscmp[ir.OGE] = true
+	iscmp[ir.OLE] = true
+	iscmp[ir.OEQ] = true
+	iscmp[ir.ONE] = true
 
-	types.Types[TINTER] = types.New(TINTER) // empty interface
+	types.Types[types.TINTER] = types.New(types.TINTER) // empty interface
 
 	// simple aliases
-	simtype[TMAP] = TPTR
-	simtype[TCHAN] = TPTR
-	simtype[TFUNC] = TPTR
-	simtype[TUNSAFEPTR] = TPTR
+	simtype[types.TMAP] = types.TPTR
+	simtype[types.TCHAN] = types.TPTR
+	simtype[types.TFUNC] = types.TPTR
+	simtype[types.TUNSAFEPTR] = types.TPTR
 
 	slicePtrOffset = 0
 	sliceLenOffset = Rnd(slicePtrOffset+int64(Widthptr), int64(Widthptr))
@@ -323,29 +321,29 @@ func typeinit() {
 	// string is same as slice wo the cap
 	sizeofString = Rnd(sliceLenOffset+int64(Widthptr), int64(Widthptr))
 
-	dowidth(types.Types[TSTRING])
+	dowidth(types.Types[types.TSTRING])
 	dowidth(types.UntypedString)
 }
 
 func makeErrorInterface() *types.Type {
 	sig := functypefield(fakeRecvField(), nil, []*types.Field{
-		types.NewField(src.NoXPos, nil, types.Types[TSTRING]),
+		types.NewField(src.NoXPos, nil, types.Types[types.TSTRING]),
 	})
 
 	method := types.NewField(src.NoXPos, lookup("Error"), sig)
 
-	t := types.New(TINTER)
+	t := types.New(types.TINTER)
 	t.SetInterface([]*types.Field{method})
 	return t
 }
 
 func lexinit1() {
 	// error type
-	s := builtinpkg.Lookup("error")
+	s := ir.BuiltinPkg.Lookup("error")
 	types.Errortype = makeErrorInterface()
 	types.Errortype.Sym = s
 	types.Errortype.Orig = makeErrorInterface()
-	s.Def = asTypesNode(typenod(types.Errortype))
+	s.Def = ir.AsTypesNode(typenod(types.Errortype))
 	dowidth(types.Errortype)
 
 	// We create separate byte and rune types for better error messages
@@ -357,24 +355,24 @@ func lexinit1() {
 	// type aliases, albeit at the cost of having to deal with it everywhere).
 
 	// byte alias
-	s = builtinpkg.Lookup("byte")
-	types.Bytetype = types.New(TUINT8)
+	s = ir.BuiltinPkg.Lookup("byte")
+	types.Bytetype = types.New(types.TUINT8)
 	types.Bytetype.Sym = s
-	s.Def = asTypesNode(typenod(types.Bytetype))
-	asNode(s.Def).Name = new(Name)
+	s.Def = ir.AsTypesNode(typenod(types.Bytetype))
+	ir.AsNode(s.Def).Name = new(ir.Name)
 	dowidth(types.Bytetype)
 
 	// rune alias
-	s = builtinpkg.Lookup("rune")
-	types.Runetype = types.New(TINT32)
+	s = ir.BuiltinPkg.Lookup("rune")
+	types.Runetype = types.New(types.TINT32)
 	types.Runetype.Sym = s
-	s.Def = asTypesNode(typenod(types.Runetype))
-	asNode(s.Def).Name = new(Name)
+	s.Def = ir.AsTypesNode(typenod(types.Runetype))
+	ir.AsNode(s.Def).Name = new(ir.Name)
 	dowidth(types.Runetype)
 
 	// backend-dependent builtin types (e.g. int).
 	for _, s := range &typedefs {
-		s1 := builtinpkg.Lookup(s.name)
+		s1 := ir.BuiltinPkg.Lookup(s.name)
 
 		sameas := s.sameas32
 		if Widthptr == 8 {
@@ -386,9 +384,9 @@ func lexinit1() {
 		t := types.New(s.etype)
 		t.Sym = s1
 		types.Types[s.etype] = t
-		s1.Def = asTypesNode(typenod(t))
-		asNode(s1.Def).Name = new(Name)
-		s1.Origpkg = builtinpkg
+		s1.Def = ir.AsTypesNode(typenod(t))
+		ir.AsNode(s1.Def).Name = new(ir.Name)
+		s1.Origpkg = ir.BuiltinPkg
 
 		dowidth(t)
 	}
@@ -400,7 +398,7 @@ func finishUniverse() {
 	// that we silently skip symbols that are already declared in the
 	// package block rather than emitting a redeclared symbol error.
 
-	for _, s := range builtinpkg.Syms {
+	for _, s := range ir.BuiltinPkg.Syms {
 		if s.Def == nil {
 			continue
 		}
@@ -413,8 +411,8 @@ func finishUniverse() {
 		s1.Block = s.Block
 	}
 
-	nodfp = newname(lookup(".fp"))
-	nodfp.Type = types.Types[TINT32]
-	nodfp.SetClass(PPARAM)
+	nodfp = NewName(lookup(".fp"))
+	nodfp.Type = types.Types[types.TINT32]
+	nodfp.SetClass(ir.PPARAM)
 	nodfp.Name.SetUsed(true)
 }
diff --git a/src/cmd/compile/internal/gc/unsafe.go b/src/cmd/compile/internal/gc/unsafe.go
index a1c1c1bf6e..fce79a6319 100644
--- a/src/cmd/compile/internal/gc/unsafe.go
+++ b/src/cmd/compile/internal/gc/unsafe.go
@@ -4,12 +4,15 @@
 
 package gc
 
-import "cmd/compile/internal/base"
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+)
 
 // evalunsafe evaluates a package unsafe operation and returns the result.
-func evalunsafe(n *Node) int64 {
+func evalunsafe(n *ir.Node) int64 {
 	switch n.Op {
-	case OALIGNOF, OSIZEOF:
+	case ir.OALIGNOF, ir.OSIZEOF:
 		n.Left = typecheck(n.Left, ctxExpr)
 		n.Left = defaultlit(n.Left, nil)
 		tr := n.Left.Type
@@ -17,14 +20,14 @@ func evalunsafe(n *Node) int64 {
 			return 0
 		}
 		dowidth(tr)
-		if n.Op == OALIGNOF {
+		if n.Op == ir.OALIGNOF {
 			return int64(tr.Align)
 		}
 		return tr.Width
 
-	case OOFFSETOF:
+	case ir.OOFFSETOF:
 		// must be a selector.
-		if n.Left.Op != OXDOT {
+		if n.Left.Op != ir.OXDOT {
 			base.Errorf("invalid expression %v", n)
 			return 0
 		}
@@ -40,9 +43,9 @@ func evalunsafe(n *Node) int64 {
 			return 0
 		}
 		switch n.Left.Op {
-		case ODOT, ODOTPTR:
+		case ir.ODOT, ir.ODOTPTR:
 			break
-		case OCALLPART:
+		case ir.OCALLPART:
 			base.Errorf("invalid expression %v: argument is a method value", n)
 			return 0
 		default:
@@ -54,7 +57,7 @@ func evalunsafe(n *Node) int64 {
 		var v int64
 		for r := n.Left; r != sbase; r = r.Left {
 			switch r.Op {
-			case ODOTPTR:
+			case ir.ODOTPTR:
 				// For Offsetof(s.f), s may itself be a pointer,
 				// but accessing f must not otherwise involve
 				// indirection via embedded pointer types.
@@ -63,10 +66,10 @@ func evalunsafe(n *Node) int64 {
 					return 0
 				}
 				fallthrough
-			case ODOT:
+			case ir.ODOT:
 				v += r.Xoffset
 			default:
-				Dump("unsafenmagic", n.Left)
+				ir.Dump("unsafenmagic", n.Left)
 				base.Fatalf("impossible %#v node after dot insertion", r.Op)
 			}
 		}
diff --git a/src/cmd/compile/internal/gc/util.go b/src/cmd/compile/internal/gc/util.go
index 597a29a940..4baddbc029 100644
--- a/src/cmd/compile/internal/gc/util.go
+++ b/src/cmd/compile/internal/gc/util.go
@@ -12,12 +12,6 @@ import (
 	"cmd/compile/internal/base"
 )
 
-// Line returns n's position as a string. If n has been inlined,
-// it uses the outermost position where n has been inlined.
-func (n *Node) Line() string {
-	return base.FmtPos(n.Pos)
-}
-
 var (
 	memprofilerate int64
 	traceHandler   func(string)
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index d7cd7ddf27..619a413b9e 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
@@ -21,20 +22,20 @@ import (
 const tmpstringbufsize = 32
 const zeroValSize = 1024 // must match value of runtime/map.go:maxZero
 
-func walk(fn *Node) {
+func walk(fn *ir.Node) {
 	Curfn = fn
 	errorsBefore := base.Errors()
 
 	if base.Flag.W != 0 {
 		s := fmt.Sprintf("\nbefore walk %v", Curfn.Func.Nname.Sym)
-		dumplist(s, Curfn.Nbody)
+		ir.DumpList(s, Curfn.Nbody)
 	}
 
 	lno := base.Pos
 
 	// Final typecheck for any unused variables.
 	for i, ln := range fn.Func.Dcl {
-		if ln.Op == ONAME && (ln.Class() == PAUTO || ln.Class() == PAUTOHEAP) {
+		if ln.Op == ir.ONAME && (ln.Class() == ir.PAUTO || ln.Class() == ir.PAUTOHEAP) {
 			ln = typecheck(ln, ctxExpr|ctxAssign)
 			fn.Func.Dcl[i] = ln
 		}
@@ -42,16 +43,16 @@ func walk(fn *Node) {
 
 	// Propagate the used flag for typeswitch variables up to the NONAME in its definition.
 	for _, ln := range fn.Func.Dcl {
-		if ln.Op == ONAME && (ln.Class() == PAUTO || ln.Class() == PAUTOHEAP) && ln.Name.Defn != nil && ln.Name.Defn.Op == OTYPESW && ln.Name.Used() {
+		if ln.Op == ir.ONAME && (ln.Class() == ir.PAUTO || ln.Class() == ir.PAUTOHEAP) && ln.Name.Defn != nil && ln.Name.Defn.Op == ir.OTYPESW && ln.Name.Used() {
 			ln.Name.Defn.Left.Name.SetUsed(true)
 		}
 	}
 
 	for _, ln := range fn.Func.Dcl {
-		if ln.Op != ONAME || (ln.Class() != PAUTO && ln.Class() != PAUTOHEAP) || ln.Sym.Name[0] == '&' || ln.Name.Used() {
+		if ln.Op != ir.ONAME || (ln.Class() != ir.PAUTO && ln.Class() != ir.PAUTOHEAP) || ln.Sym.Name[0] == '&' || ln.Name.Used() {
 			continue
 		}
-		if defn := ln.Name.Defn; defn != nil && defn.Op == OTYPESW {
+		if defn := ln.Name.Defn; defn != nil && defn.Op == ir.OTYPESW {
 			if defn.Left.Name.Used() {
 				continue
 			}
@@ -69,32 +70,32 @@ func walk(fn *Node) {
 	walkstmtlist(Curfn.Nbody.Slice())
 	if base.Flag.W != 0 {
 		s := fmt.Sprintf("after walk %v", Curfn.Func.Nname.Sym)
-		dumplist(s, Curfn.Nbody)
+		ir.DumpList(s, Curfn.Nbody)
 	}
 
 	zeroResults()
 	heapmoves()
 	if base.Flag.W != 0 && Curfn.Func.Enter.Len() > 0 {
 		s := fmt.Sprintf("enter %v", Curfn.Func.Nname.Sym)
-		dumplist(s, Curfn.Func.Enter)
+		ir.DumpList(s, Curfn.Func.Enter)
 	}
 }
 
-func walkstmtlist(s []*Node) {
+func walkstmtlist(s []*ir.Node) {
 	for i := range s {
 		s[i] = walkstmt(s[i])
 	}
 }
 
-func paramoutheap(fn *Node) bool {
+func paramoutheap(fn *ir.Node) bool {
 	for _, ln := range fn.Func.Dcl {
 		switch ln.Class() {
-		case PPARAMOUT:
-			if ln.isParamStackCopy() || ln.Name.Addrtaken() {
+		case ir.PPARAMOUT:
+			if isParamStackCopy(ln) || ln.Name.Addrtaken() {
 				return true
 			}
 
-		case PAUTO:
+		case ir.PAUTO:
 			// stop early - parameters are over
 			return false
 		}
@@ -105,7 +106,7 @@ func paramoutheap(fn *Node) bool {
 
 // The result of walkstmt MUST be assigned back to n, e.g.
 // 	n.Left = walkstmt(n.Left)
-func walkstmt(n *Node) *Node {
+func walkstmt(n *ir.Node) *ir.Node {
 	if n == nil {
 		return n
 	}
@@ -116,49 +117,49 @@ func walkstmt(n *Node) *Node {
 
 	switch n.Op {
 	default:
-		if n.Op == ONAME {
+		if n.Op == ir.ONAME {
 			base.Errorf("%v is not a top level statement", n.Sym)
 		} else {
 			base.Errorf("%v is not a top level statement", n.Op)
 		}
-		Dump("nottop", n)
-
-	case OAS,
-		OASOP,
-		OAS2,
-		OAS2DOTTYPE,
-		OAS2RECV,
-		OAS2FUNC,
-		OAS2MAPR,
-		OCLOSE,
-		OCOPY,
-		OCALLMETH,
-		OCALLINTER,
-		OCALL,
-		OCALLFUNC,
-		ODELETE,
-		OSEND,
-		OPRINT,
-		OPRINTN,
-		OPANIC,
-		OEMPTY,
-		ORECOVER,
-		OGETG:
+		ir.Dump("nottop", n)
+
+	case ir.OAS,
+		ir.OASOP,
+		ir.OAS2,
+		ir.OAS2DOTTYPE,
+		ir.OAS2RECV,
+		ir.OAS2FUNC,
+		ir.OAS2MAPR,
+		ir.OCLOSE,
+		ir.OCOPY,
+		ir.OCALLMETH,
+		ir.OCALLINTER,
+		ir.OCALL,
+		ir.OCALLFUNC,
+		ir.ODELETE,
+		ir.OSEND,
+		ir.OPRINT,
+		ir.OPRINTN,
+		ir.OPANIC,
+		ir.OEMPTY,
+		ir.ORECOVER,
+		ir.OGETG:
 		if n.Typecheck() == 0 {
 			base.Fatalf("missing typecheck: %+v", n)
 		}
-		wascopy := n.Op == OCOPY
+		wascopy := n.Op == ir.OCOPY
 		init := n.Ninit
 		n.Ninit.Set(nil)
 		n = walkexpr(n, &init)
 		n = addinit(n, init.Slice())
-		if wascopy && n.Op == OCONVNOP {
-			n.Op = OEMPTY // don't leave plain values as statements.
+		if wascopy && n.Op == ir.OCONVNOP {
+			n.Op = ir.OEMPTY // don't leave plain values as statements.
 		}
 
 	// special case for a receive where we throw away
 	// the value received.
-	case ORECV:
+	case ir.ORECV:
 		if n.Typecheck() == 0 {
 			base.Fatalf("missing typecheck: %+v", n)
 		}
@@ -171,44 +172,44 @@ func walkstmt(n *Node) *Node {
 
 		n = addinit(n, init.Slice())
 
-	case OBREAK,
-		OCONTINUE,
-		OFALL,
-		OGOTO,
-		OLABEL,
-		ODCLCONST,
-		ODCLTYPE,
-		OCHECKNIL,
-		OVARDEF,
-		OVARKILL,
-		OVARLIVE:
+	case ir.OBREAK,
+		ir.OCONTINUE,
+		ir.OFALL,
+		ir.OGOTO,
+		ir.OLABEL,
+		ir.ODCLCONST,
+		ir.ODCLTYPE,
+		ir.OCHECKNIL,
+		ir.OVARDEF,
+		ir.OVARKILL,
+		ir.OVARLIVE:
 		break
 
-	case ODCL:
+	case ir.ODCL:
 		v := n.Left
-		if v.Class() == PAUTOHEAP {
+		if v.Class() == ir.PAUTOHEAP {
 			if base.Flag.CompilingRuntime {
 				base.Errorf("%v escapes to heap, not allowed in runtime", v)
 			}
 			if prealloc[v] == nil {
 				prealloc[v] = callnew(v.Type)
 			}
-			nn := nod(OAS, v.Name.Param.Heapaddr, prealloc[v])
+			nn := ir.Nod(ir.OAS, v.Name.Param.Heapaddr, prealloc[v])
 			nn.SetColas(true)
 			nn = typecheck(nn, ctxStmt)
 			return walkstmt(nn)
 		}
 
-	case OBLOCK:
+	case ir.OBLOCK:
 		walkstmtlist(n.List.Slice())
 
-	case OCASE:
+	case ir.OCASE:
 		base.Errorf("case statement out of place")
 
-	case ODEFER:
+	case ir.ODEFER:
 		Curfn.Func.SetHasDefer(true)
-		Curfn.Func.numDefers++
-		if Curfn.Func.numDefers > maxOpenDefers {
+		Curfn.Func.NumDefers++
+		if Curfn.Func.NumDefers > maxOpenDefers {
 			// Don't allow open-coded defers if there are more than
 			// 8 defers in the function, since we use a single
 			// byte to record active defers.
@@ -220,22 +221,22 @@ func walkstmt(n *Node) *Node {
 			Curfn.Func.SetOpenCodedDeferDisallowed(true)
 		}
 		fallthrough
-	case OGO:
+	case ir.OGO:
 		switch n.Left.Op {
-		case OPRINT, OPRINTN:
+		case ir.OPRINT, ir.OPRINTN:
 			n.Left = wrapCall(n.Left, &n.Ninit)
 
-		case ODELETE:
+		case ir.ODELETE:
 			if mapfast(n.Left.List.First().Type) == mapslow {
 				n.Left = wrapCall(n.Left, &n.Ninit)
 			} else {
 				n.Left = walkexpr(n.Left, &n.Ninit)
 			}
 
-		case OCOPY:
+		case ir.OCOPY:
 			n.Left = copyany(n.Left, &n.Ninit, true)
 
-		case OCALLFUNC, OCALLMETH, OCALLINTER:
+		case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
 			if n.Left.Nbody.Len() > 0 {
 				n.Left = wrapCall(n.Left, &n.Ninit)
 			} else {
@@ -246,7 +247,7 @@ func walkstmt(n *Node) *Node {
 			n.Left = walkexpr(n.Left, &n.Ninit)
 		}
 
-	case OFOR, OFORUNTIL:
+	case ir.OFOR, ir.OFORUNTIL:
 		if n.Left != nil {
 			walkstmtlist(n.Left.Ninit.Slice())
 			init := n.Left.Ninit
@@ -256,34 +257,34 @@ func walkstmt(n *Node) *Node {
 		}
 
 		n.Right = walkstmt(n.Right)
-		if n.Op == OFORUNTIL {
+		if n.Op == ir.OFORUNTIL {
 			walkstmtlist(n.List.Slice())
 		}
 		walkstmtlist(n.Nbody.Slice())
 
-	case OIF:
+	case ir.OIF:
 		n.Left = walkexpr(n.Left, &n.Ninit)
 		walkstmtlist(n.Nbody.Slice())
 		walkstmtlist(n.Rlist.Slice())
 
-	case ORETURN:
-		Curfn.Func.numReturns++
+	case ir.ORETURN:
+		Curfn.Func.NumReturns++
 		if n.List.Len() == 0 {
 			break
 		}
 		if (Curfn.Type.FuncType().Outnamed && n.List.Len() > 1) || paramoutheap(Curfn) {
 			// assign to the function out parameters,
 			// so that reorder3 can fix up conflicts
-			var rl []*Node
+			var rl []*ir.Node
 
 			for _, ln := range Curfn.Func.Dcl {
 				cl := ln.Class()
-				if cl == PAUTO || cl == PAUTOHEAP {
+				if cl == ir.PAUTO || cl == ir.PAUTOHEAP {
 					break
 				}
-				if cl == PPARAMOUT {
-					if ln.isParamStackCopy() {
-						ln = walkexpr(typecheck(nod(ODEREF, ln.Name.Param.Heapaddr, nil), ctxExpr), nil)
+				if cl == ir.PPARAMOUT {
+					if isParamStackCopy(ln) {
+						ln = walkexpr(typecheck(ir.Nod(ir.ODEREF, ln.Name.Param.Heapaddr, nil), ctxExpr), nil)
 					}
 					rl = append(rl, ln)
 				}
@@ -307,34 +308,34 @@ func walkstmt(n *Node) *Node {
 		// For each return parameter (lhs), assign the corresponding result (rhs).
 		lhs := Curfn.Type.Results()
 		rhs := n.List.Slice()
-		res := make([]*Node, lhs.NumFields())
+		res := make([]*ir.Node, lhs.NumFields())
 		for i, nl := range lhs.FieldSlice() {
-			nname := asNode(nl.Nname)
-			if nname.isParamHeapCopy() {
+			nname := ir.AsNode(nl.Nname)
+			if isParamHeapCopy(nname) {
 				nname = nname.Name.Param.Stackcopy
 			}
-			a := nod(OAS, nname, rhs[i])
+			a := ir.Nod(ir.OAS, nname, rhs[i])
 			res[i] = convas(a, &n.Ninit)
 		}
 		n.List.Set(res)
 
-	case ORETJMP:
+	case ir.ORETJMP:
 		break
 
-	case OINLMARK:
+	case ir.OINLMARK:
 		break
 
-	case OSELECT:
+	case ir.OSELECT:
 		walkselect(n)
 
-	case OSWITCH:
+	case ir.OSWITCH:
 		walkswitch(n)
 
-	case ORANGE:
+	case ir.ORANGE:
 		n = walkrange(n)
 	}
 
-	if n.Op == ONAME {
+	if n.Op == ir.ONAME {
 		base.Fatalf("walkstmt ended up with name: %+v", n)
 	}
 	return n
@@ -345,20 +346,20 @@ func walkstmt(n *Node) *Node {
 // the types expressions are calculated.
 // compile-time constants are evaluated.
 // complex side effects like statements are appended to init
-func walkexprlist(s []*Node, init *Nodes) {
+func walkexprlist(s []*ir.Node, init *ir.Nodes) {
 	for i := range s {
 		s[i] = walkexpr(s[i], init)
 	}
 }
 
-func walkexprlistsafe(s []*Node, init *Nodes) {
+func walkexprlistsafe(s []*ir.Node, init *ir.Nodes) {
 	for i, n := range s {
 		s[i] = safeexpr(n, init)
 		s[i] = walkexpr(s[i], init)
 	}
 }
 
-func walkexprlistcheap(s []*Node, init *Nodes) {
+func walkexprlistcheap(s []*ir.Node, init *ir.Nodes) {
 	for i, n := range s {
 		s[i] = cheapexpr(n, init)
 		s[i] = walkexpr(s[i], init)
@@ -381,7 +382,7 @@ func convFuncName(from, to *types.Type) (fnname string, needsaddr bool) {
 			return "convT16", false
 		case from.Size() == 4 && from.Align == 4 && !from.HasPointers():
 			return "convT32", false
-		case from.Size() == 8 && from.Align == types.Types[TUINT64].Align && !from.HasPointers():
+		case from.Size() == 8 && from.Align == types.Types[types.TUINT64].Align && !from.HasPointers():
 			return "convT64", false
 		}
 		if sc := from.SoleComponent(); sc != nil {
@@ -412,7 +413,7 @@ func convFuncName(from, to *types.Type) (fnname string, needsaddr bool) {
 
 // The result of walkexpr MUST be assigned back to n, e.g.
 // 	n.Left = walkexpr(n.Left, init)
-func walkexpr(n *Node, init *Nodes) *Node {
+func walkexpr(n *ir.Node, init *ir.Nodes) *ir.Node {
 	if n == nil {
 		return n
 	}
@@ -420,7 +421,7 @@ func walkexpr(n *Node, init *Nodes) *Node {
 	// Eagerly checkwidth all expressions for the back end.
 	if n.Type != nil && !n.Type.WidthCalculated() {
 		switch n.Type.Etype {
-		case TBLANK, TNIL, TIDEAL:
+		case types.TBLANK, types.TNIL, types.TIDEAL:
 		default:
 			checkwidth(n.Type)
 		}
@@ -441,7 +442,7 @@ func walkexpr(n *Node, init *Nodes) *Node {
 	lno := setlineno(n)
 
 	if base.Flag.LowerW > 1 {
-		Dump("before walk expr", n)
+		ir.Dump("before walk expr", n)
 	}
 
 	if n.Typecheck() != 1 {
@@ -452,8 +453,8 @@ func walkexpr(n *Node, init *Nodes) *Node {
 		base.Fatalf("expression has untyped type: %+v", n)
 	}
 
-	if n.Op == ONAME && n.Class() == PAUTOHEAP {
-		nn := nod(ODEREF, n.Name.Param.Heapaddr, nil)
+	if n.Op == ir.ONAME && n.Class() == ir.PAUTOHEAP {
+		nn := ir.Nod(ir.ODEREF, n.Name.Param.Heapaddr, nil)
 		nn = typecheck(nn, ctxExpr)
 		nn = walkexpr(nn, init)
 		nn.Left.MarkNonNil()
@@ -463,44 +464,44 @@ func walkexpr(n *Node, init *Nodes) *Node {
 opswitch:
 	switch n.Op {
 	default:
-		Dump("walk", n)
+		ir.Dump("walk", n)
 		base.Fatalf("walkexpr: switch 1 unknown op %+S", n)
 
-	case ONONAME, OEMPTY, OGETG, ONEWOBJ, OMETHEXPR:
+	case ir.ONONAME, ir.OEMPTY, ir.OGETG, ir.ONEWOBJ, ir.OMETHEXPR:
 
-	case OTYPE, ONAME, OLITERAL, ONIL:
+	case ir.OTYPE, ir.ONAME, ir.OLITERAL, ir.ONIL:
 		// TODO(mdempsky): Just return n; see discussion on CL 38655.
 		// Perhaps refactor to use Node.mayBeShared for these instead.
 		// If these return early, make sure to still call
 		// stringsym for constant strings.
 
-	case ONOT, ONEG, OPLUS, OBITNOT, OREAL, OIMAG, ODOTMETH, ODOTINTER,
-		ODEREF, OSPTR, OITAB, OIDATA, OADDR:
+	case ir.ONOT, ir.ONEG, ir.OPLUS, ir.OBITNOT, ir.OREAL, ir.OIMAG, ir.ODOTMETH, ir.ODOTINTER,
+		ir.ODEREF, ir.OSPTR, ir.OITAB, ir.OIDATA, ir.OADDR:
 		n.Left = walkexpr(n.Left, init)
 
-	case OEFACE, OAND, OANDNOT, OSUB, OMUL, OADD, OOR, OXOR, OLSH, ORSH:
+	case ir.OEFACE, ir.OAND, ir.OANDNOT, ir.OSUB, ir.OMUL, ir.OADD, ir.OOR, ir.OXOR, ir.OLSH, ir.ORSH:
 		n.Left = walkexpr(n.Left, init)
 		n.Right = walkexpr(n.Right, init)
 
-	case ODOT, ODOTPTR:
+	case ir.ODOT, ir.ODOTPTR:
 		usefield(n)
 		n.Left = walkexpr(n.Left, init)
 
-	case ODOTTYPE, ODOTTYPE2:
+	case ir.ODOTTYPE, ir.ODOTTYPE2:
 		n.Left = walkexpr(n.Left, init)
 		// Set up interface type addresses for back end.
 		n.Right = typename(n.Type)
-		if n.Op == ODOTTYPE {
+		if n.Op == ir.ODOTTYPE {
 			n.Right.Right = typename(n.Left.Type)
 		}
 		if !n.Type.IsInterface() && !n.Left.Type.IsEmptyInterface() {
 			n.List.Set1(itabname(n.Type, n.Left.Type))
 		}
 
-	case OLEN, OCAP:
+	case ir.OLEN, ir.OCAP:
 		if isRuneCount(n) {
 			// Replace len([]rune(string)) with runtime.countrunes(string).
-			n = mkcall("countrunes", n.Type, init, conv(n.Left.Left, types.Types[TSTRING]))
+			n = mkcall("countrunes", n.Type, init, conv(n.Left.Left, types.Types[types.TSTRING]))
 			break
 		}
 
@@ -519,7 +520,7 @@ opswitch:
 			n.SetTypecheck(1)
 		}
 
-	case OCOMPLEX:
+	case ir.OCOMPLEX:
 		// Use results from call expression as arguments for complex.
 		if n.Left == nil && n.Right == nil {
 			n.Left = n.List.First()
@@ -528,38 +529,38 @@ opswitch:
 		n.Left = walkexpr(n.Left, init)
 		n.Right = walkexpr(n.Right, init)
 
-	case OEQ, ONE, OLT, OLE, OGT, OGE:
+	case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
 		n = walkcompare(n, init)
 
-	case OANDAND, OOROR:
+	case ir.OANDAND, ir.OOROR:
 		n.Left = walkexpr(n.Left, init)
 
 		// cannot put side effects from n.Right on init,
 		// because they cannot run before n.Left is checked.
 		// save elsewhere and store on the eventual n.Right.
-		var ll Nodes
+		var ll ir.Nodes
 
 		n.Right = walkexpr(n.Right, &ll)
 		n.Right = addinit(n.Right, ll.Slice())
 
-	case OPRINT, OPRINTN:
+	case ir.OPRINT, ir.OPRINTN:
 		n = walkprint(n, init)
 
-	case OPANIC:
+	case ir.OPANIC:
 		n = mkcall("gopanic", nil, init, n.Left)
 
-	case ORECOVER:
-		n = mkcall("gorecover", n.Type, init, nod(OADDR, nodfp, nil))
+	case ir.ORECOVER:
+		n = mkcall("gorecover", n.Type, init, ir.Nod(ir.OADDR, nodfp, nil))
 
-	case OCLOSUREVAR, OCFUNC:
+	case ir.OCLOSUREVAR, ir.OCFUNC:
 
-	case OCALLINTER, OCALLFUNC, OCALLMETH:
-		if n.Op == OCALLINTER {
+	case ir.OCALLINTER, ir.OCALLFUNC, ir.OCALLMETH:
+		if n.Op == ir.OCALLINTER {
 			usemethod(n)
 			markUsedIfaceMethod(n)
 		}
 
-		if n.Op == OCALLFUNC && n.Left.Op == OCLOSURE {
+		if n.Op == ir.OCALLFUNC && n.Left.Op == ir.OCLOSURE {
 			// Transform direct call of a closure to call of a normal function.
 			// transformclosure already did all preparation work.
 
@@ -581,12 +582,12 @@ opswitch:
 
 		walkCall(n, init)
 
-	case OAS, OASOP:
+	case ir.OAS, ir.OASOP:
 		init.AppendNodes(&n.Ninit)
 
 		// Recognize m[k] = append(m[k], ...) so we can reuse
 		// the mapassign call.
-		mapAppend := n.Left.Op == OINDEXMAP && n.Right.Op == OAPPEND
+		mapAppend := n.Left.Op == ir.OINDEXMAP && n.Right.Op == ir.OAPPEND
 		if mapAppend && !samesafeexpr(n.Left, n.Right.List.First()) {
 			base.Fatalf("not same expressions: %v != %v", n.Left, n.Right.List.First())
 		}
@@ -598,12 +599,12 @@ opswitch:
 			n.Right.List.SetFirst(n.Left)
 		}
 
-		if n.Op == OASOP {
+		if n.Op == ir.OASOP {
 			// Rewrite x op= y into x = x op y.
-			n.Right = nod(n.SubOp(), n.Left, n.Right)
+			n.Right = ir.Nod(n.SubOp(), n.Left, n.Right)
 			n.Right = typecheck(n.Right, ctxExpr)
 
-			n.Op = OAS
+			n.Op = ir.OAS
 			n.ResetAux()
 		}
 
@@ -624,18 +625,18 @@ opswitch:
 		default:
 			n.Right = walkexpr(n.Right, init)
 
-		case ORECV:
+		case ir.ORECV:
 			// x = <-c; n.Left is x, n.Right.Left is c.
 			// order.stmt made sure x is addressable.
 			n.Right.Left = walkexpr(n.Right.Left, init)
 
-			n1 := nod(OADDR, n.Left, nil)
+			n1 := ir.Nod(ir.OADDR, n.Left, nil)
 			r := n.Right.Left // the channel
 			n = mkcall1(chanfn("chanrecv1", 2, r.Type), nil, init, r, n1)
 			n = walkexpr(n, init)
 			break opswitch
 
-		case OAPPEND:
+		case ir.OAPPEND:
 			// x = append(...)
 			r := n.Right
 			if r.Type.Elem().NotInHeap() {
@@ -651,7 +652,7 @@ opswitch:
 				r = walkappend(r, init, n)
 			}
 			n.Right = r
-			if r.Op == OAPPEND {
+			if r.Op == ir.OAPPEND {
 				// Left in place for back end.
 				// Do not add a new write barrier.
 				// Set up address of type for back end.
@@ -666,16 +667,16 @@ opswitch:
 			n = convas(n, init)
 		}
 
-	case OAS2:
+	case ir.OAS2:
 		init.AppendNodes(&n.Ninit)
 		walkexprlistsafe(n.List.Slice(), init)
 		walkexprlistsafe(n.Rlist.Slice(), init)
-		ll := ascompatee(OAS, n.List.Slice(), n.Rlist.Slice(), init)
+		ll := ascompatee(ir.OAS, n.List.Slice(), n.Rlist.Slice(), init)
 		ll = reorder3(ll)
 		n = liststmt(ll)
 
 	// a,b,... = fn()
-	case OAS2FUNC:
+	case ir.OAS2FUNC:
 		init.AppendNodes(&n.Ninit)
 
 		r := n.Right
@@ -693,26 +694,26 @@ opswitch:
 
 	// x, y = <-c
 	// order.stmt made sure x is addressable or blank.
-	case OAS2RECV:
+	case ir.OAS2RECV:
 		init.AppendNodes(&n.Ninit)
 
 		r := n.Right
 		walkexprlistsafe(n.List.Slice(), init)
 		r.Left = walkexpr(r.Left, init)
-		var n1 *Node
-		if n.List.First().isBlank() {
+		var n1 *ir.Node
+		if ir.IsBlank(n.List.First()) {
 			n1 = nodnil()
 		} else {
-			n1 = nod(OADDR, n.List.First(), nil)
+			n1 = ir.Nod(ir.OADDR, n.List.First(), nil)
 		}
 		fn := chanfn("chanrecv2", 2, r.Left.Type)
 		ok := n.List.Second()
-		call := mkcall1(fn, types.Types[TBOOL], init, r.Left, n1)
-		n = nod(OAS, ok, call)
+		call := mkcall1(fn, types.Types[types.TBOOL], init, r.Left, n1)
+		n = ir.Nod(ir.OAS, ok, call)
 		n = typecheck(n, ctxStmt)
 
 	// a,b = m[i]
-	case OAS2MAPR:
+	case ir.OAS2MAPR:
 		init.AppendNodes(&n.Ninit)
 
 		r := n.Right
@@ -722,14 +723,14 @@ opswitch:
 		t := r.Left.Type
 
 		fast := mapfast(t)
-		var key *Node
+		var key *ir.Node
 		if fast != mapslow {
 			// fast versions take key by value
 			key = r.Right
 		} else {
 			// standard version takes key by reference
 			// order.expr made sure key is addressable.
-			key = nod(OADDR, r.Right, nil)
+			key = ir.Nod(ir.OADDR, r.Right, nil)
 		}
 
 		// from:
@@ -751,27 +752,27 @@ opswitch:
 		// mapaccess2* returns a typed bool, but due to spec changes,
 		// the boolean result of i.(T) is now untyped so we make it the
 		// same type as the variable on the lhs.
-		if ok := n.List.Second(); !ok.isBlank() && ok.Type.IsBoolean() {
+		if ok := n.List.Second(); !ir.IsBlank(ok) && ok.Type.IsBoolean() {
 			r.Type.Field(1).Type = ok.Type
 		}
 		n.Right = r
-		n.Op = OAS2FUNC
+		n.Op = ir.OAS2FUNC
 
 		// don't generate a = *var if a is _
-		if !a.isBlank() {
+		if !ir.IsBlank(a) {
 			var_ := temp(types.NewPtr(t.Elem()))
 			var_.SetTypecheck(1)
 			var_.MarkNonNil() // mapaccess always returns a non-nil pointer
 			n.List.SetFirst(var_)
 			n = walkexpr(n, init)
 			init.Append(n)
-			n = nod(OAS, a, nod(ODEREF, var_, nil))
+			n = ir.Nod(ir.OAS, a, ir.Nod(ir.ODEREF, var_, nil))
 		}
 
 		n = typecheck(n, ctxStmt)
 		n = walkexpr(n, init)
 
-	case ODELETE:
+	case ir.ODELETE:
 		init.AppendNodes(&n.Ninit)
 		map_ := n.List.First()
 		key := n.List.Second()
@@ -782,26 +783,26 @@ opswitch:
 		fast := mapfast(t)
 		if fast == mapslow {
 			// order.stmt made sure key is addressable.
-			key = nod(OADDR, key, nil)
+			key = ir.Nod(ir.OADDR, key, nil)
 		}
 		n = mkcall1(mapfndel(mapdelete[fast], t), nil, init, typename(t), map_, key)
 
-	case OAS2DOTTYPE:
+	case ir.OAS2DOTTYPE:
 		walkexprlistsafe(n.List.Slice(), init)
 		n.Right = walkexpr(n.Right, init)
 
-	case OCONVIFACE:
+	case ir.OCONVIFACE:
 		n.Left = walkexpr(n.Left, init)
 
 		fromType := n.Left.Type
 		toType := n.Type
 
-		if !fromType.IsInterface() && !Curfn.Func.Nname.isBlank() { // skip unnamed functions (func _())
-			markTypeUsedInInterface(fromType, Curfn.Func.lsym)
+		if !fromType.IsInterface() && !ir.IsBlank(Curfn.Func.Nname) { // skip unnamed functions (func _())
+			markTypeUsedInInterface(fromType, Curfn.Func.LSym)
 		}
 
 		// typeword generates the type word of the interface value.
-		typeword := func() *Node {
+		typeword := func() *ir.Node {
 			if toType.IsEmptyInterface() {
 				return typename(fromType)
 			}
@@ -810,7 +811,7 @@ opswitch:
 
 		// Optimize convT2E or convT2I as a two-word copy when T is pointer-shaped.
 		if isdirectiface(fromType) {
-			l := nod(OEFACE, typeword(), n.Left)
+			l := ir.Nod(ir.OEFACE, typeword(), n.Left)
 			l.Type = toType
 			l.SetTypecheck(n.Typecheck())
 			n = l
@@ -818,20 +819,20 @@ opswitch:
 		}
 
 		if staticuint64s == nil {
-			staticuint64s = newname(Runtimepkg.Lookup("staticuint64s"))
-			staticuint64s.SetClass(PEXTERN)
+			staticuint64s = NewName(Runtimepkg.Lookup("staticuint64s"))
+			staticuint64s.SetClass(ir.PEXTERN)
 			// The actual type is [256]uint64, but we use [256*8]uint8 so we can address
 			// individual bytes.
-			staticuint64s.Type = types.NewArray(types.Types[TUINT8], 256*8)
-			zerobase = newname(Runtimepkg.Lookup("zerobase"))
-			zerobase.SetClass(PEXTERN)
-			zerobase.Type = types.Types[TUINTPTR]
+			staticuint64s.Type = types.NewArray(types.Types[types.TUINT8], 256*8)
+			zerobase = NewName(Runtimepkg.Lookup("zerobase"))
+			zerobase.SetClass(ir.PEXTERN)
+			zerobase.Type = types.Types[types.TUINTPTR]
 		}
 
 		// Optimize convT2{E,I} for many cases in which T is not pointer-shaped,
 		// by using an existing addressable value identical to n.Left
 		// or creating one on the stack.
-		var value *Node
+		var value *ir.Node
 		switch {
 		case fromType.Size() == 0:
 			// n.Left is zero-sized. Use zerobase.
@@ -842,25 +843,25 @@ opswitch:
 			// and staticuint64s[n.Left * 8 + 7] on big-endian.
 			n.Left = cheapexpr(n.Left, init)
 			// byteindex widens n.Left so that the multiplication doesn't overflow.
-			index := nod(OLSH, byteindex(n.Left), nodintconst(3))
+			index := ir.Nod(ir.OLSH, byteindex(n.Left), nodintconst(3))
 			if thearch.LinkArch.ByteOrder == binary.BigEndian {
-				index = nod(OADD, index, nodintconst(7))
+				index = ir.Nod(ir.OADD, index, nodintconst(7))
 			}
-			value = nod(OINDEX, staticuint64s, index)
+			value = ir.Nod(ir.OINDEX, staticuint64s, index)
 			value.SetBounded(true)
-		case n.Left.Class() == PEXTERN && n.Left.Name != nil && n.Left.Name.Readonly():
+		case n.Left.Class() == ir.PEXTERN && n.Left.Name != nil && n.Left.Name.Readonly():
 			// n.Left is a readonly global; use it directly.
 			value = n.Left
 		case !fromType.IsInterface() && n.Esc == EscNone && fromType.Width <= 1024:
 			// n.Left does not escape. Use a stack temporary initialized to n.Left.
 			value = temp(fromType)
-			init.Append(typecheck(nod(OAS, value, n.Left), ctxStmt))
+			init.Append(typecheck(ir.Nod(ir.OAS, value, n.Left), ctxStmt))
 		}
 
 		if value != nil {
 			// Value is identical to n.Left.
 			// Construct the interface directly: {type/itab, &value}.
-			l := nod(OEFACE, typeword(), typecheck(nod(OADDR, value, nil), ctxExpr))
+			l := ir.Nod(ir.OEFACE, typeword(), typecheck(ir.Nod(ir.OADDR, value, nil), ctxExpr))
 			l.Type = toType
 			l.SetTypecheck(n.Typecheck())
 			n = l
@@ -876,19 +877,19 @@ opswitch:
 		if toType.IsEmptyInterface() && fromType.IsInterface() && !fromType.IsEmptyInterface() {
 			// Evaluate the input interface.
 			c := temp(fromType)
-			init.Append(nod(OAS, c, n.Left))
+			init.Append(ir.Nod(ir.OAS, c, n.Left))
 
 			// Get the itab out of the interface.
-			tmp := temp(types.NewPtr(types.Types[TUINT8]))
-			init.Append(nod(OAS, tmp, typecheck(nod(OITAB, c, nil), ctxExpr)))
+			tmp := temp(types.NewPtr(types.Types[types.TUINT8]))
+			init.Append(ir.Nod(ir.OAS, tmp, typecheck(ir.Nod(ir.OITAB, c, nil), ctxExpr)))
 
 			// Get the type out of the itab.
-			nif := nod(OIF, typecheck(nod(ONE, tmp, nodnil()), ctxExpr), nil)
-			nif.Nbody.Set1(nod(OAS, tmp, itabType(tmp)))
+			nif := ir.Nod(ir.OIF, typecheck(ir.Nod(ir.ONE, tmp, nodnil()), ctxExpr), nil)
+			nif.Nbody.Set1(ir.Nod(ir.OAS, tmp, itabType(tmp)))
 			init.Append(nif)
 
 			// Build the result.
-			e := nod(OEFACE, tmp, ifaceData(n.Pos, c, types.NewPtr(types.Types[TUINT8])))
+			e := ir.Nod(ir.OEFACE, tmp, ifaceData(n.Pos, c, types.NewPtr(types.Types[types.TUINT8])))
 			e.Type = toType // assign type manually, typecheck doesn't understand OEFACE.
 			e.SetTypecheck(1)
 			n = e
@@ -905,19 +906,19 @@ opswitch:
 			dowidth(fromType)
 			fn = substArgTypes(fn, fromType)
 			dowidth(fn.Type)
-			call := nod(OCALL, fn, nil)
+			call := ir.Nod(ir.OCALL, fn, nil)
 			call.List.Set1(n.Left)
 			call = typecheck(call, ctxExpr)
 			call = walkexpr(call, init)
 			call = safeexpr(call, init)
-			e := nod(OEFACE, typeword(), call)
+			e := ir.Nod(ir.OEFACE, typeword(), call)
 			e.Type = toType
 			e.SetTypecheck(1)
 			n = e
 			break
 		}
 
-		var tab *Node
+		var tab *ir.Node
 		if fromType.IsInterface() {
 			// convI2I
 			tab = typename(toType)
@@ -937,21 +938,21 @@ opswitch:
 			if !islvalue(v) {
 				v = copyexpr(v, v.Type, init)
 			}
-			v = nod(OADDR, v, nil)
+			v = ir.Nod(ir.OADDR, v, nil)
 		}
 
 		dowidth(fromType)
 		fn := syslook(fnname)
 		fn = substArgTypes(fn, fromType, toType)
 		dowidth(fn.Type)
-		n = nod(OCALL, fn, nil)
+		n = ir.Nod(ir.OCALL, fn, nil)
 		n.List.Set2(tab, v)
 		n = typecheck(n, ctxExpr)
 		n = walkexpr(n, init)
 
-	case OCONV, OCONVNOP:
+	case ir.OCONV, ir.OCONVNOP:
 		n.Left = walkexpr(n.Left, init)
-		if n.Op == OCONVNOP && checkPtr(Curfn, 1) {
+		if n.Op == ir.OCONVNOP && checkPtr(Curfn, 1) {
 			if n.Type.IsPtr() && n.Left.Type.IsUnsafePtr() { // unsafe.Pointer to *T
 				n = walkCheckPtrAlignment(n, init, nil)
 				break
@@ -962,22 +963,22 @@ opswitch:
 			}
 		}
 		param, result := rtconvfn(n.Left.Type, n.Type)
-		if param == Txxx {
+		if param == types.Txxx {
 			break
 		}
-		fn := basicnames[param] + "to" + basicnames[result]
+		fn := ir.BasicTypeNames[param] + "to" + ir.BasicTypeNames[result]
 		n = conv(mkcall(fn, types.Types[result], init, conv(n.Left, types.Types[param])), n.Type)
 
-	case ODIV, OMOD:
+	case ir.ODIV, ir.OMOD:
 		n.Left = walkexpr(n.Left, init)
 		n.Right = walkexpr(n.Right, init)
 
 		// rewrite complex div into function call.
 		et := n.Left.Type.Etype
 
-		if isComplex[et] && n.Op == ODIV {
+		if isComplex[et] && n.Op == ir.ODIV {
 			t := n.Type
-			n = mkcall("complex128div", types.Types[TCOMPLEX128], init, conv(n.Left, types.Types[TCOMPLEX128]), conv(n.Right, types.Types[TCOMPLEX128]))
+			n = mkcall("complex128div", types.Types[types.TCOMPLEX128], init, conv(n.Left, types.Types[types.TCOMPLEX128]), conv(n.Right, types.Types[types.TCOMPLEX128]))
 			n = conv(n, t)
 			break
 		}
@@ -990,12 +991,12 @@ opswitch:
 		// rewrite 64-bit div and mod on 32-bit architectures.
 		// TODO: Remove this code once we can introduce
 		// runtime calls late in SSA processing.
-		if Widthreg < 8 && (et == TINT64 || et == TUINT64) {
-			if n.Right.Op == OLITERAL {
+		if Widthreg < 8 && (et == types.TINT64 || et == types.TUINT64) {
+			if n.Right.Op == ir.OLITERAL {
 				// Leave div/mod by constant powers of 2 or small 16-bit constants.
 				// The SSA backend will handle those.
 				switch et {
-				case TINT64:
+				case types.TINT64:
 					c := n.Right.Int64Val()
 					if c < 0 {
 						c = -c
@@ -1003,7 +1004,7 @@ opswitch:
 					if c != 0 && c&(c-1) == 0 {
 						break opswitch
 					}
-				case TUINT64:
+				case types.TUINT64:
 					c := n.Right.Uint64Val()
 					if c < 1<<16 {
 						break opswitch
@@ -1014,12 +1015,12 @@ opswitch:
 				}
 			}
 			var fn string
-			if et == TINT64 {
+			if et == types.TINT64 {
 				fn = "int64"
 			} else {
 				fn = "uint64"
 			}
-			if n.Op == ODIV {
+			if n.Op == ir.ODIV {
 				fn += "div"
 			} else {
 				fn += "mod"
@@ -1027,7 +1028,7 @@ opswitch:
 			n = mkcall(fn, n.Type, init, conv(n.Left, types.Types[et]), conv(n.Right, types.Types[et]))
 		}
 
-	case OINDEX:
+	case ir.OINDEX:
 		n.Left = walkexpr(n.Left, init)
 
 		// save the original node for bounds checking elision.
@@ -1047,15 +1048,15 @@ opswitch:
 		}
 		if t.IsArray() {
 			n.SetBounded(bounded(r, t.NumElem()))
-			if base.Flag.LowerM != 0 && n.Bounded() && !Isconst(n.Right, constant.Int) {
+			if base.Flag.LowerM != 0 && n.Bounded() && !ir.IsConst(n.Right, constant.Int) {
 				base.Warn("index bounds check elided")
 			}
 			if smallintconst(n.Right) && !n.Bounded() {
 				base.Errorf("index out of bounds")
 			}
-		} else if Isconst(n.Left, constant.String) {
+		} else if ir.IsConst(n.Left, constant.String) {
 			n.SetBounded(bounded(r, int64(len(n.Left.StringVal()))))
-			if base.Flag.LowerM != 0 && n.Bounded() && !Isconst(n.Right, constant.Int) {
+			if base.Flag.LowerM != 0 && n.Bounded() && !ir.IsConst(n.Right, constant.Int) {
 				base.Warn("index bounds check elided")
 			}
 			if smallintconst(n.Right) && !n.Bounded() {
@@ -1063,13 +1064,13 @@ opswitch:
 			}
 		}
 
-		if Isconst(n.Right, constant.Int) {
-			if v := n.Right.Val(); constant.Sign(v) < 0 || doesoverflow(v, types.Types[TINT]) {
+		if ir.IsConst(n.Right, constant.Int) {
+			if v := n.Right.Val(); constant.Sign(v) < 0 || doesoverflow(v, types.Types[types.TINT]) {
 				base.Errorf("index out of bounds")
 			}
 		}
 
-	case OINDEXMAP:
+	case ir.OINDEXMAP:
 		// Replace m[k] with *map{access1,assign}(maptype, m, &k)
 		n.Left = walkexpr(n.Left, init)
 		n.Right = walkexpr(n.Right, init)
@@ -1082,7 +1083,7 @@ opswitch:
 			if fast == mapslow {
 				// standard version takes key by reference.
 				// order.expr made sure key is addressable.
-				key = nod(OADDR, key, nil)
+				key = ir.Nod(ir.OADDR, key, nil)
 			}
 			n = mkcall1(mapfn(mapassign[fast], t), nil, init, typename(t), map_, key)
 		} else {
@@ -1091,7 +1092,7 @@ opswitch:
 			if fast == mapslow {
 				// standard version takes key by reference.
 				// order.expr made sure key is addressable.
-				key = nod(OADDR, key, nil)
+				key = ir.Nod(ir.OADDR, key, nil)
 			}
 
 			if w := t.Elem().Width; w <= zeroValSize {
@@ -1103,20 +1104,20 @@ opswitch:
 		}
 		n.Type = types.NewPtr(t.Elem())
 		n.MarkNonNil() // mapaccess1* and mapassign always return non-nil pointers.
-		n = nod(ODEREF, n, nil)
+		n = ir.Nod(ir.ODEREF, n, nil)
 		n.Type = t.Elem()
 		n.SetTypecheck(1)
 
-	case ORECV:
+	case ir.ORECV:
 		base.Fatalf("walkexpr ORECV") // should see inside OAS only
 
-	case OSLICEHEADER:
+	case ir.OSLICEHEADER:
 		n.Left = walkexpr(n.Left, init)
 		n.List.SetFirst(walkexpr(n.List.First(), init))
 		n.List.SetSecond(walkexpr(n.List.Second(), init))
 
-	case OSLICE, OSLICEARR, OSLICESTR, OSLICE3, OSLICE3ARR:
-		checkSlice := checkPtr(Curfn, 1) && n.Op == OSLICE3ARR && n.Left.Op == OCONVNOP && n.Left.Left.Type.IsUnsafePtr()
+	case ir.OSLICE, ir.OSLICEARR, ir.OSLICESTR, ir.OSLICE3, ir.OSLICE3ARR:
+		checkSlice := checkPtr(Curfn, 1) && n.Op == ir.OSLICE3ARR && n.Left.Op == ir.OCONVNOP && n.Left.Left.Type.IsUnsafePtr()
 		if checkSlice {
 			n.Left.Left = walkexpr(n.Left.Left, init)
 		} else {
@@ -1135,12 +1136,12 @@ opswitch:
 			n.Left = walkCheckPtrAlignment(n.Left, init, max)
 		}
 		if n.Op.IsSlice3() {
-			if max != nil && max.Op == OCAP && samesafeexpr(n.Left, max.Left) {
+			if max != nil && max.Op == ir.OCAP && samesafeexpr(n.Left, max.Left) {
 				// Reduce x[i:j:cap(x)] to x[i:j].
-				if n.Op == OSLICE3 {
-					n.Op = OSLICE
+				if n.Op == ir.OSLICE3 {
+					n.Op = ir.OSLICE
 				} else {
-					n.Op = OSLICEARR
+					n.Op = ir.OSLICEARR
 				}
 				n = reduceSlice(n)
 			}
@@ -1148,7 +1149,7 @@ opswitch:
 			n = reduceSlice(n)
 		}
 
-	case ONEW:
+	case ir.ONEW:
 		if n.Type.Elem().NotInHeap() {
 			base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", n.Type.Elem())
 		}
@@ -1157,74 +1158,74 @@ opswitch:
 				base.Fatalf("large ONEW with EscNone: %v", n)
 			}
 			r := temp(n.Type.Elem())
-			r = nod(OAS, r, nil) // zero temp
+			r = ir.Nod(ir.OAS, r, nil) // zero temp
 			r = typecheck(r, ctxStmt)
 			init.Append(r)
-			r = nod(OADDR, r.Left, nil)
+			r = ir.Nod(ir.OADDR, r.Left, nil)
 			r = typecheck(r, ctxExpr)
 			n = r
 		} else {
 			n = callnew(n.Type.Elem())
 		}
 
-	case OADDSTR:
+	case ir.OADDSTR:
 		n = addstr(n, init)
 
-	case OAPPEND:
+	case ir.OAPPEND:
 		// order should make sure we only see OAS(node, OAPPEND), which we handle above.
 		base.Fatalf("append outside assignment")
 
-	case OCOPY:
+	case ir.OCOPY:
 		n = copyany(n, init, instrumenting && !base.Flag.CompilingRuntime)
 
 		// cannot use chanfn - closechan takes any, not chan any
-	case OCLOSE:
+	case ir.OCLOSE:
 		fn := syslook("closechan")
 
 		fn = substArgTypes(fn, n.Left.Type)
 		n = mkcall1(fn, nil, init, n.Left)
 
-	case OMAKECHAN:
+	case ir.OMAKECHAN:
 		// When size fits into int, use makechan instead of
 		// makechan64, which is faster and shorter on 32 bit platforms.
 		size := n.Left
 		fnname := "makechan64"
-		argtype := types.Types[TINT64]
+		argtype := types.Types[types.TINT64]
 
 		// Type checking guarantees that TIDEAL size is positive and fits in an int.
 		// The case of size overflow when converting TUINT or TUINTPTR to TINT
 		// will be handled by the negative range checks in makechan during runtime.
-		if size.Type.IsKind(TIDEAL) || size.Type.Size() <= types.Types[TUINT].Size() {
+		if size.Type.IsKind(types.TIDEAL) || size.Type.Size() <= types.Types[types.TUINT].Size() {
 			fnname = "makechan"
-			argtype = types.Types[TINT]
+			argtype = types.Types[types.TINT]
 		}
 
 		n = mkcall1(chanfn(fnname, 1, n.Type), n.Type, init, typename(n.Type), conv(size, argtype))
 
-	case OMAKEMAP:
+	case ir.OMAKEMAP:
 		t := n.Type
 		hmapType := hmap(t)
 		hint := n.Left
 
 		// var h *hmap
-		var h *Node
+		var h *ir.Node
 		if n.Esc == EscNone {
 			// Allocate hmap on stack.
 
 			// var hv hmap
 			hv := temp(hmapType)
-			zero := nod(OAS, hv, nil)
+			zero := ir.Nod(ir.OAS, hv, nil)
 			zero = typecheck(zero, ctxStmt)
 			init.Append(zero)
 			// h = &hv
-			h = nod(OADDR, hv, nil)
+			h = ir.Nod(ir.OADDR, hv, nil)
 
 			// Allocate one bucket pointed to by hmap.buckets on stack if hint
 			// is not larger than BUCKETSIZE. In case hint is larger than
 			// BUCKETSIZE runtime.makemap will allocate the buckets on the heap.
 			// Maximum key and elem size is 128 bytes, larger objects
 			// are stored with an indirection. So max bucket size is 2048+eps.
-			if !Isconst(hint, constant.Int) ||
+			if !ir.IsConst(hint, constant.Int) ||
 				constant.Compare(hint.Val(), token.LEQ, constant.MakeInt64(BUCKETSIZE)) {
 
 				// In case hint is larger than BUCKETSIZE runtime.makemap
@@ -1236,20 +1237,20 @@ opswitch:
 				//     h.buckets = b
 				// }
 
-				nif := nod(OIF, nod(OLE, hint, nodintconst(BUCKETSIZE)), nil)
+				nif := ir.Nod(ir.OIF, ir.Nod(ir.OLE, hint, nodintconst(BUCKETSIZE)), nil)
 				nif.SetLikely(true)
 
 				// var bv bmap
 				bv := temp(bmap(t))
-				zero = nod(OAS, bv, nil)
+				zero = ir.Nod(ir.OAS, bv, nil)
 				nif.Nbody.Append(zero)
 
 				// b = &bv
-				b := nod(OADDR, bv, nil)
+				b := ir.Nod(ir.OADDR, bv, nil)
 
 				// h.buckets = b
 				bsym := hmapType.Field(5).Sym // hmap.buckets see reflect.go:hmap
-				na := nod(OAS, nodSym(ODOT, h, bsym), b)
+				na := ir.Nod(ir.OAS, nodSym(ir.ODOT, h, bsym), b)
 				nif.Nbody.Append(na)
 
 				nif = typecheck(nif, ctxStmt)
@@ -1258,7 +1259,7 @@ opswitch:
 			}
 		}
 
-		if Isconst(hint, constant.Int) && constant.Compare(hint.Val(), token.LEQ, constant.MakeInt64(BUCKETSIZE)) {
+		if ir.IsConst(hint, constant.Int) && constant.Compare(hint.Val(), token.LEQ, constant.MakeInt64(BUCKETSIZE)) {
 			// Handling make(map[any]any) and
 			// make(map[any]any, hint) where hint <= BUCKETSIZE
 			// special allows for faster map initialization and
@@ -1270,9 +1271,9 @@ opswitch:
 				// Only need to initialize h.hash0 since
 				// hmap h has been allocated on the stack already.
 				// h.hash0 = fastrand()
-				rand := mkcall("fastrand", types.Types[TUINT32], init)
+				rand := mkcall("fastrand", types.Types[types.TUINT32], init)
 				hashsym := hmapType.Field(4).Sym // hmap.hash0 see reflect.go:hmap
-				a := nod(OAS, nodSym(ODOT, h, hashsym), rand)
+				a := ir.Nod(ir.OAS, nodSym(ir.ODOT, h, hashsym), rand)
 				a = typecheck(a, ctxStmt)
 				a = walkexpr(a, init)
 				init.Append(a)
@@ -1296,15 +1297,15 @@ opswitch:
 			// When hint fits into int, use makemap instead of
 			// makemap64, which is faster and shorter on 32 bit platforms.
 			fnname := "makemap64"
-			argtype := types.Types[TINT64]
+			argtype := types.Types[types.TINT64]
 
 			// Type checking guarantees that TIDEAL hint is positive and fits in an int.
 			// See checkmake call in TMAP case of OMAKE case in OpSwitch in typecheck1 function.
 			// The case of hint overflow when converting TUINT or TUINTPTR to TINT
 			// will be handled by the negative range checks in makemap during runtime.
-			if hint.Type.IsKind(TIDEAL) || hint.Type.Size() <= types.Types[TUINT].Size() {
+			if hint.Type.IsKind(types.TIDEAL) || hint.Type.Size() <= types.Types[types.TUINT].Size() {
 				fnname = "makemap"
-				argtype = types.Types[TINT]
+				argtype = types.Types[types.TINT]
 			}
 
 			fn := syslook(fnname)
@@ -1312,7 +1313,7 @@ opswitch:
 			n = mkcall1(fn, n.Type, init, typename(n.Type), conv(hint, argtype), h)
 		}
 
-	case OMAKESLICE:
+	case ir.OMAKESLICE:
 		l := n.Left
 		r := n.Right
 		if r == nil {
@@ -1341,8 +1342,8 @@ opswitch:
 			//     if len < 0 { panicmakeslicelen() }
 			//     panicmakeslicecap()
 			// }
-			nif := nod(OIF, nod(OGT, conv(l, types.Types[TUINT64]), nodintconst(i)), nil)
-			niflen := nod(OIF, nod(OLT, l, nodintconst(0)), nil)
+			nif := ir.Nod(ir.OIF, ir.Nod(ir.OGT, conv(l, types.Types[types.TUINT64]), nodintconst(i)), nil)
+			niflen := ir.Nod(ir.OIF, ir.Nod(ir.OLT, l, nodintconst(0)), nil)
 			niflen.Nbody.Set1(mkcall("panicmakeslicelen", nil, init))
 			nif.Nbody.Append(niflen, mkcall("panicmakeslicecap", nil, init))
 			nif = typecheck(nif, ctxStmt)
@@ -1350,10 +1351,10 @@ opswitch:
 
 			t = types.NewArray(t.Elem(), i) // [r]T
 			var_ := temp(t)
-			a := nod(OAS, var_, nil) // zero temp
+			a := ir.Nod(ir.OAS, var_, nil) // zero temp
 			a = typecheck(a, ctxStmt)
 			init.Append(a)
-			r := nod(OSLICE, var_, nil) // arr[:l]
+			r := ir.Nod(ir.OSLICE, var_, nil) // arr[:l]
 			r.SetSliceBounds(nil, l, nil)
 			r = conv(r, n.Type) // in case n.Type is named.
 			r = typecheck(r, ctxExpr)
@@ -1367,31 +1368,31 @@ opswitch:
 			len, cap := l, r
 
 			fnname := "makeslice64"
-			argtype := types.Types[TINT64]
+			argtype := types.Types[types.TINT64]
 
 			// Type checking guarantees that TIDEAL len/cap are positive and fit in an int.
 			// The case of len or cap overflow when converting TUINT or TUINTPTR to TINT
 			// will be handled by the negative range checks in makeslice during runtime.
-			if (len.Type.IsKind(TIDEAL) || len.Type.Size() <= types.Types[TUINT].Size()) &&
-				(cap.Type.IsKind(TIDEAL) || cap.Type.Size() <= types.Types[TUINT].Size()) {
+			if (len.Type.IsKind(types.TIDEAL) || len.Type.Size() <= types.Types[types.TUINT].Size()) &&
+				(cap.Type.IsKind(types.TIDEAL) || cap.Type.Size() <= types.Types[types.TUINT].Size()) {
 				fnname = "makeslice"
-				argtype = types.Types[TINT]
+				argtype = types.Types[types.TINT]
 			}
 
-			m := nod(OSLICEHEADER, nil, nil)
+			m := ir.Nod(ir.OSLICEHEADER, nil, nil)
 			m.Type = t
 
 			fn := syslook(fnname)
-			m.Left = mkcall1(fn, types.Types[TUNSAFEPTR], init, typename(t.Elem()), conv(len, argtype), conv(cap, argtype))
+			m.Left = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), conv(len, argtype), conv(cap, argtype))
 			m.Left.MarkNonNil()
-			m.List.Set2(conv(len, types.Types[TINT]), conv(cap, types.Types[TINT]))
+			m.List.Set2(conv(len, types.Types[types.TINT]), conv(cap, types.Types[types.TINT]))
 
 			m = typecheck(m, ctxExpr)
 			m = walkexpr(m, init)
 			n = m
 		}
 
-	case OMAKESLICECOPY:
+	case ir.OMAKESLICECOPY:
 		if n.Esc == EscNone {
 			base.Fatalf("OMAKESLICECOPY with EscNone: %v", n)
 		}
@@ -1401,9 +1402,9 @@ opswitch:
 			base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", t.Elem())
 		}
 
-		length := conv(n.Left, types.Types[TINT])
-		copylen := nod(OLEN, n.Right, nil)
-		copyptr := nod(OSPTR, n.Right, nil)
+		length := conv(n.Left, types.Types[types.TINT])
+		copylen := ir.Nod(ir.OLEN, n.Right, nil)
+		copyptr := ir.Nod(ir.OSPTR, n.Right, nil)
 
 		if !t.Elem().HasPointers() && n.Bounded() {
 			// When len(to)==len(from) and elements have no pointers:
@@ -1412,25 +1413,25 @@ opswitch:
 			// We do not check for overflow of len(to)*elem.Width here
 			// since len(from) is an existing checked slice capacity
 			// with same elem.Width for the from slice.
-			size := nod(OMUL, conv(length, types.Types[TUINTPTR]), conv(nodintconst(t.Elem().Width), types.Types[TUINTPTR]))
+			size := ir.Nod(ir.OMUL, conv(length, types.Types[types.TUINTPTR]), conv(nodintconst(t.Elem().Width), types.Types[types.TUINTPTR]))
 
 			// instantiate mallocgc(size uintptr, typ *byte, needszero bool) unsafe.Pointer
 			fn := syslook("mallocgc")
-			sh := nod(OSLICEHEADER, nil, nil)
-			sh.Left = mkcall1(fn, types.Types[TUNSAFEPTR], init, size, nodnil(), nodbool(false))
+			sh := ir.Nod(ir.OSLICEHEADER, nil, nil)
+			sh.Left = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, size, nodnil(), nodbool(false))
 			sh.Left.MarkNonNil()
 			sh.List.Set2(length, length)
 			sh.Type = t
 
 			s := temp(t)
-			r := typecheck(nod(OAS, s, sh), ctxStmt)
+			r := typecheck(ir.Nod(ir.OAS, s, sh), ctxStmt)
 			r = walkexpr(r, init)
 			init.Append(r)
 
 			// instantiate memmove(to *any, frm *any, size uintptr)
 			fn = syslook("memmove")
 			fn = substArgTypes(fn, t.Elem(), t.Elem())
-			ncopy := mkcall1(fn, nil, init, nod(OSPTR, s, nil), copyptr, size)
+			ncopy := mkcall1(fn, nil, init, ir.Nod(ir.OSPTR, s, nil), copyptr, size)
 			ncopy = typecheck(ncopy, ctxStmt)
 			ncopy = walkexpr(ncopy, init)
 			init.Append(ncopy)
@@ -1439,8 +1440,8 @@ opswitch:
 		} else { // Replace make+copy with runtime.makeslicecopy.
 			// instantiate makeslicecopy(typ *byte, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointer
 			fn := syslook("makeslicecopy")
-			s := nod(OSLICEHEADER, nil, nil)
-			s.Left = mkcall1(fn, types.Types[TUNSAFEPTR], init, typename(t.Elem()), length, copylen, conv(copyptr, types.Types[TUNSAFEPTR]))
+			s := ir.Nod(ir.OSLICEHEADER, nil, nil)
+			s.Left = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), length, copylen, conv(copyptr, types.Types[types.TUNSAFEPTR]))
 			s.Left.MarkNonNil()
 			s.List.Set2(length, length)
 			s.Type = t
@@ -1448,33 +1449,33 @@ opswitch:
 			n = walkexpr(n, init)
 		}
 
-	case ORUNESTR:
+	case ir.ORUNESTR:
 		a := nodnil()
 		if n.Esc == EscNone {
-			t := types.NewArray(types.Types[TUINT8], 4)
-			a = nod(OADDR, temp(t), nil)
+			t := types.NewArray(types.Types[types.TUINT8], 4)
+			a = ir.Nod(ir.OADDR, temp(t), nil)
 		}
 		// intstring(*[4]byte, rune)
-		n = mkcall("intstring", n.Type, init, a, conv(n.Left, types.Types[TINT64]))
+		n = mkcall("intstring", n.Type, init, a, conv(n.Left, types.Types[types.TINT64]))
 
-	case OBYTES2STR, ORUNES2STR:
+	case ir.OBYTES2STR, ir.ORUNES2STR:
 		a := nodnil()
 		if n.Esc == EscNone {
 			// Create temporary buffer for string on stack.
-			t := types.NewArray(types.Types[TUINT8], tmpstringbufsize)
-			a = nod(OADDR, temp(t), nil)
+			t := types.NewArray(types.Types[types.TUINT8], tmpstringbufsize)
+			a = ir.Nod(ir.OADDR, temp(t), nil)
 		}
-		if n.Op == ORUNES2STR {
+		if n.Op == ir.ORUNES2STR {
 			// slicerunetostring(*[32]byte, []rune) string
 			n = mkcall("slicerunetostring", n.Type, init, a, n.Left)
 		} else {
 			// slicebytetostring(*[32]byte, ptr *byte, n int) string
 			n.Left = cheapexpr(n.Left, init)
-			ptr, len := n.Left.backingArrayPtrLen()
+			ptr, len := backingArrayPtrLen(n.Left)
 			n = mkcall("slicebytetostring", n.Type, init, a, ptr, len)
 		}
 
-	case OBYTES2STRTMP:
+	case ir.OBYTES2STRTMP:
 		n.Left = walkexpr(n.Left, init)
 		if !instrumenting {
 			// Let the backend handle OBYTES2STRTMP directly
@@ -1483,37 +1484,37 @@ opswitch:
 		}
 		// slicebytetostringtmp(ptr *byte, n int) string
 		n.Left = cheapexpr(n.Left, init)
-		ptr, len := n.Left.backingArrayPtrLen()
+		ptr, len := backingArrayPtrLen(n.Left)
 		n = mkcall("slicebytetostringtmp", n.Type, init, ptr, len)
 
-	case OSTR2BYTES:
+	case ir.OSTR2BYTES:
 		s := n.Left
-		if Isconst(s, constant.String) {
+		if ir.IsConst(s, constant.String) {
 			sc := s.StringVal()
 
 			// Allocate a [n]byte of the right size.
-			t := types.NewArray(types.Types[TUINT8], int64(len(sc)))
-			var a *Node
+			t := types.NewArray(types.Types[types.TUINT8], int64(len(sc)))
+			var a *ir.Node
 			if n.Esc == EscNone && len(sc) <= int(maxImplicitStackVarSize) {
-				a = nod(OADDR, temp(t), nil)
+				a = ir.Nod(ir.OADDR, temp(t), nil)
 			} else {
 				a = callnew(t)
 			}
 			p := temp(t.PtrTo()) // *[n]byte
-			init.Append(typecheck(nod(OAS, p, a), ctxStmt))
+			init.Append(typecheck(ir.Nod(ir.OAS, p, a), ctxStmt))
 
 			// Copy from the static string data to the [n]byte.
 			if len(sc) > 0 {
-				as := nod(OAS,
-					nod(ODEREF, p, nil),
-					nod(ODEREF, convnop(nod(OSPTR, s, nil), t.PtrTo()), nil))
+				as := ir.Nod(ir.OAS,
+					ir.Nod(ir.ODEREF, p, nil),
+					ir.Nod(ir.ODEREF, convnop(ir.Nod(ir.OSPTR, s, nil), t.PtrTo()), nil))
 				as = typecheck(as, ctxStmt)
 				as = walkstmt(as)
 				init.Append(as)
 			}
 
 			// Slice the [n]byte to a []byte.
-			n.Op = OSLICEARR
+			n.Op = ir.OSLICEARR
 			n.Left = p
 			n = walkexpr(n, init)
 			break
@@ -1522,13 +1523,13 @@ opswitch:
 		a := nodnil()
 		if n.Esc == EscNone {
 			// Create temporary buffer for slice on stack.
-			t := types.NewArray(types.Types[TUINT8], tmpstringbufsize)
-			a = nod(OADDR, temp(t), nil)
+			t := types.NewArray(types.Types[types.TUINT8], tmpstringbufsize)
+			a = ir.Nod(ir.OADDR, temp(t), nil)
 		}
 		// stringtoslicebyte(*32[byte], string) []byte
-		n = mkcall("stringtoslicebyte", n.Type, init, a, conv(s, types.Types[TSTRING]))
+		n = mkcall("stringtoslicebyte", n.Type, init, a, conv(s, types.Types[types.TSTRING]))
 
-	case OSTR2BYTESTMP:
+	case ir.OSTR2BYTESTMP:
 		// []byte(string) conversion that creates a slice
 		// referring to the actual string bytes.
 		// This conversion is handled later by the backend and
@@ -1538,17 +1539,17 @@ opswitch:
 		// for i, c := range []byte(string)
 		n.Left = walkexpr(n.Left, init)
 
-	case OSTR2RUNES:
+	case ir.OSTR2RUNES:
 		a := nodnil()
 		if n.Esc == EscNone {
 			// Create temporary buffer for slice on stack.
-			t := types.NewArray(types.Types[TINT32], tmpstringbufsize)
-			a = nod(OADDR, temp(t), nil)
+			t := types.NewArray(types.Types[types.TINT32], tmpstringbufsize)
+			a = ir.Nod(ir.OADDR, temp(t), nil)
 		}
 		// stringtoslicerune(*[32]rune, string) []rune
-		n = mkcall("stringtoslicerune", n.Type, init, a, conv(n.Left, types.Types[TSTRING]))
+		n = mkcall("stringtoslicerune", n.Type, init, a, conv(n.Left, types.Types[types.TSTRING]))
 
-	case OARRAYLIT, OSLICELIT, OMAPLIT, OSTRUCTLIT, OPTRLIT:
+	case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT, ir.OSTRUCTLIT, ir.OPTRLIT:
 		if isStaticCompositeLiteral(n) && !canSSAType(n.Type) {
 			// n can be directly represented in the read-only data section.
 			// Make direct reference to the static data. See issue 12841.
@@ -1562,17 +1563,17 @@ opswitch:
 		anylit(n, var_, init)
 		n = var_
 
-	case OSEND:
+	case ir.OSEND:
 		n1 := n.Right
 		n1 = assignconv(n1, n.Left.Type.Elem(), "chan send")
 		n1 = walkexpr(n1, init)
-		n1 = nod(OADDR, n1, nil)
+		n1 = ir.Nod(ir.OADDR, n1, nil)
 		n = mkcall1(chanfn("chansend1", 2, n.Left.Type), nil, init, n.Left, n1)
 
-	case OCLOSURE:
+	case ir.OCLOSURE:
 		n = walkclosure(n, init)
 
-	case OCALLPART:
+	case ir.OCALLPART:
 		n = walkpartialcall(n, init)
 	}
 
@@ -1586,7 +1587,7 @@ opswitch:
 	if n.Type != t {
 		base.Fatalf("evconst changed Type: %v had type %v, now %v", n, t, n.Type)
 	}
-	if n.Op == OLITERAL {
+	if n.Op == ir.OLITERAL {
 		n = typecheck(n, ctxExpr)
 		// Emit string symbol now to avoid emitting
 		// any concurrently during the backend.
@@ -1598,7 +1599,7 @@ opswitch:
 	updateHasCall(n)
 
 	if base.Flag.LowerW != 0 && n != nil {
-		Dump("after walk expr", n)
+		ir.Dump("after walk expr", n)
 	}
 
 	base.Pos = lno
@@ -1618,10 +1619,10 @@ func markTypeUsedInInterface(t *types.Type, from *obj.LSym) {
 
 // markUsedIfaceMethod marks that an interface method is used in the current
 // function. n is OCALLINTER node.
-func markUsedIfaceMethod(n *Node) {
+func markUsedIfaceMethod(n *ir.Node) {
 	ityp := n.Left.Left.Type
 	tsym := typenamesym(ityp).Linksym()
-	r := obj.Addrel(Curfn.Func.lsym)
+	r := obj.Addrel(Curfn.Func.LSym)
 	r.Sym = tsym
 	// n.Left.Xoffset is the method index * Widthptr (the offset of code pointer
 	// in itab).
@@ -1637,54 +1638,54 @@ func markUsedIfaceMethod(n *Node) {
 // If no such function is necessary, it returns (Txxx, Txxx).
 func rtconvfn(src, dst *types.Type) (param, result types.EType) {
 	if thearch.SoftFloat {
-		return Txxx, Txxx
+		return types.Txxx, types.Txxx
 	}
 
 	switch thearch.LinkArch.Family {
 	case sys.ARM, sys.MIPS:
 		if src.IsFloat() {
 			switch dst.Etype {
-			case TINT64, TUINT64:
-				return TFLOAT64, dst.Etype
+			case types.TINT64, types.TUINT64:
+				return types.TFLOAT64, dst.Etype
 			}
 		}
 		if dst.IsFloat() {
 			switch src.Etype {
-			case TINT64, TUINT64:
-				return src.Etype, TFLOAT64
+			case types.TINT64, types.TUINT64:
+				return src.Etype, types.TFLOAT64
 			}
 		}
 
 	case sys.I386:
 		if src.IsFloat() {
 			switch dst.Etype {
-			case TINT64, TUINT64:
-				return TFLOAT64, dst.Etype
-			case TUINT32, TUINT, TUINTPTR:
-				return TFLOAT64, TUINT32
+			case types.TINT64, types.TUINT64:
+				return types.TFLOAT64, dst.Etype
+			case types.TUINT32, types.TUINT, types.TUINTPTR:
+				return types.TFLOAT64, types.TUINT32
 			}
 		}
 		if dst.IsFloat() {
 			switch src.Etype {
-			case TINT64, TUINT64:
-				return src.Etype, TFLOAT64
-			case TUINT32, TUINT, TUINTPTR:
-				return TUINT32, TFLOAT64
+			case types.TINT64, types.TUINT64:
+				return src.Etype, types.TFLOAT64
+			case types.TUINT32, types.TUINT, types.TUINTPTR:
+				return types.TUINT32, types.TFLOAT64
 			}
 		}
 	}
-	return Txxx, Txxx
+	return types.Txxx, types.Txxx
 }
 
 // TODO(josharian): combine this with its caller and simplify
-func reduceSlice(n *Node) *Node {
+func reduceSlice(n *ir.Node) *ir.Node {
 	low, high, max := n.SliceBounds()
-	if high != nil && high.Op == OLEN && samesafeexpr(n.Left, high.Left) {
+	if high != nil && high.Op == ir.OLEN && samesafeexpr(n.Left, high.Left) {
 		// Reduce x[i:len(x)] to x[i:].
 		high = nil
 	}
 	n.SetSliceBounds(low, high, max)
-	if (n.Op == OSLICE || n.Op == OSLICESTR) && low == nil && high == nil {
+	if (n.Op == ir.OSLICE || n.Op == ir.OSLICESTR) && low == nil && high == nil {
 		// Reduce x[:] to x.
 		if base.Debug.Slice > 0 {
 			base.Warn("slice: omit slice operation")
@@ -1694,19 +1695,19 @@ func reduceSlice(n *Node) *Node {
 	return n
 }
 
-func ascompatee1(l *Node, r *Node, init *Nodes) *Node {
+func ascompatee1(l *ir.Node, r *ir.Node, init *ir.Nodes) *ir.Node {
 	// convas will turn map assigns into function calls,
 	// making it impossible for reorder3 to work.
-	n := nod(OAS, l, r)
+	n := ir.Nod(ir.OAS, l, r)
 
-	if l.Op == OINDEXMAP {
+	if l.Op == ir.OINDEXMAP {
 		return n
 	}
 
 	return convas(n, init)
 }
 
-func ascompatee(op Op, nl, nr []*Node, init *Nodes) []*Node {
+func ascompatee(op ir.Op, nl, nr []*ir.Node, init *ir.Nodes) []*ir.Node {
 	// check assign expression list to
 	// an expression list. called in
 	//	expr-list = expr-list
@@ -1719,14 +1720,14 @@ func ascompatee(op Op, nl, nr []*Node, init *Nodes) []*Node {
 		nr[i1] = safeexpr(nr[i1], init)
 	}
 
-	var nn []*Node
+	var nn []*ir.Node
 	i := 0
 	for ; i < len(nl); i++ {
 		if i >= len(nr) {
 			break
 		}
 		// Do not generate 'x = x' during return. See issue 4014.
-		if op == ORETURN && samesafeexpr(nl[i], nr[i]) {
+		if op == ir.ORETURN && samesafeexpr(nl[i], nr[i]) {
 			continue
 		}
 		nn = append(nn, ascompatee1(nl[i], nr[i], init))
@@ -1734,17 +1735,17 @@ func ascompatee(op Op, nl, nr []*Node, init *Nodes) []*Node {
 
 	// cannot happen: caller checked that lists had same length
 	if i < len(nl) || i < len(nr) {
-		var nln, nrn Nodes
+		var nln, nrn ir.Nodes
 		nln.Set(nl)
 		nrn.Set(nr)
-		base.Fatalf("error in shape across %+v %v %+v / %d %d [%s]", nln, op, nrn, len(nl), len(nr), Curfn.funcname())
+		base.Fatalf("error in shape across %+v %v %+v / %d %d [%s]", nln, op, nrn, len(nl), len(nr), ir.FuncName(Curfn))
 	}
 	return nn
 }
 
 // fncall reports whether assigning an rvalue of type rt to an lvalue l might involve a function call.
-func fncall(l *Node, rt *types.Type) bool {
-	if l.HasCall() || l.Op == OINDEXMAP {
+func fncall(l *ir.Node, rt *types.Type) bool {
+	if l.HasCall() || l.Op == ir.OINDEXMAP {
 		return true
 	}
 	if types.Identical(l.Type, rt) {
@@ -1757,14 +1758,14 @@ func fncall(l *Node, rt *types.Type) bool {
 // check assign type list to
 // an expression list. called in
 //	expr-list = func()
-func ascompatet(nl Nodes, nr *types.Type) []*Node {
+func ascompatet(nl ir.Nodes, nr *types.Type) []*ir.Node {
 	if nl.Len() != nr.NumFields() {
 		base.Fatalf("ascompatet: assignment count mismatch: %d = %d", nl.Len(), nr.NumFields())
 	}
 
-	var nn, mm Nodes
+	var nn, mm ir.Nodes
 	for i, l := range nl.Slice() {
-		if l.isBlank() {
+		if ir.IsBlank(l) {
 			continue
 		}
 		r := nr.Field(i)
@@ -1774,22 +1775,22 @@ func ascompatet(nl Nodes, nr *types.Type) []*Node {
 		if fncall(l, r.Type) {
 			tmp := temp(r.Type)
 			tmp = typecheck(tmp, ctxExpr)
-			a := nod(OAS, l, tmp)
+			a := ir.Nod(ir.OAS, l, tmp)
 			a = convas(a, &mm)
 			mm.Append(a)
 			l = tmp
 		}
 
-		res := nod(ORESULT, nil, nil)
+		res := ir.Nod(ir.ORESULT, nil, nil)
 		res.Xoffset = base.Ctxt.FixedFrameSize() + r.Offset
 		res.Type = r.Type
 		res.SetTypecheck(1)
 
-		a := nod(OAS, l, res)
+		a := ir.Nod(ir.OAS, l, res)
 		a = convas(a, &nn)
 		updateHasCall(a)
 		if a.HasCall() {
-			Dump("ascompatet ucount", a)
+			ir.Dump("ascompatet ucount", a)
 			base.Fatalf("ascompatet: too many function calls evaluating parameters")
 		}
 
@@ -1799,13 +1800,13 @@ func ascompatet(nl Nodes, nr *types.Type) []*Node {
 }
 
 // package all the arguments that match a ... T parameter into a []T.
-func mkdotargslice(typ *types.Type, args []*Node) *Node {
-	var n *Node
+func mkdotargslice(typ *types.Type, args []*ir.Node) *ir.Node {
+	var n *ir.Node
 	if len(args) == 0 {
 		n = nodnil()
 		n.Type = typ
 	} else {
-		n = nod(OCOMPLIT, nil, typenod(typ))
+		n = ir.Nod(ir.OCOMPLIT, nil, typenod(typ))
 		n.List.Append(args...)
 		n.SetImplicit(true)
 	}
@@ -1819,7 +1820,7 @@ func mkdotargslice(typ *types.Type, args []*Node) *Node {
 
 // fixVariadicCall rewrites calls to variadic functions to use an
 // explicit ... argument if one is not already present.
-func fixVariadicCall(call *Node) {
+func fixVariadicCall(call *ir.Node) {
 	fntype := call.Left.Type
 	if !fntype.IsVariadic() || call.IsDDD() {
 		return
@@ -1839,7 +1840,7 @@ func fixVariadicCall(call *Node) {
 	call.SetIsDDD(true)
 }
 
-func walkCall(n *Node, init *Nodes) {
+func walkCall(n *ir.Node, init *ir.Nodes) {
 	if n.Rlist.Len() != 0 {
 		return // already walked
 	}
@@ -1851,8 +1852,8 @@ func walkCall(n *Node, init *Nodes) {
 	walkexprlist(args, init)
 
 	// If this is a method call, add the receiver at the beginning of the args.
-	if n.Op == OCALLMETH {
-		withRecv := make([]*Node, len(args)+1)
+	if n.Op == ir.OCALLMETH {
+		withRecv := make([]*ir.Node, len(args)+1)
 		withRecv[0] = n.Left.Left
 		n.Left.Left = nil
 		copy(withRecv[1:], args)
@@ -1863,12 +1864,12 @@ func walkCall(n *Node, init *Nodes) {
 	// store that argument into a temporary variable,
 	// to prevent that calls from clobbering arguments already on the stack.
 	// When instrumenting, all arguments might require function calls.
-	var tempAssigns []*Node
+	var tempAssigns []*ir.Node
 	for i, arg := range args {
 		updateHasCall(arg)
 		// Determine param type.
 		var t *types.Type
-		if n.Op == OCALLMETH {
+		if n.Op == ir.OCALLMETH {
 			if i == 0 {
 				t = n.Left.Type.Recv().Type
 			} else {
@@ -1880,7 +1881,7 @@ func walkCall(n *Node, init *Nodes) {
 		if instrumenting || fncall(arg, t) {
 			// make assignment of fncall to tempAt
 			tmp := temp(t)
-			a := nod(OAS, tmp, arg)
+			a := ir.Nod(ir.OAS, tmp, arg)
 			a = convas(a, init)
 			tempAssigns = append(tempAssigns, a)
 			// replace arg with temp
@@ -1893,14 +1894,14 @@ func walkCall(n *Node, init *Nodes) {
 }
 
 // generate code for print
-func walkprint(nn *Node, init *Nodes) *Node {
+func walkprint(nn *ir.Node, init *ir.Nodes) *ir.Node {
 	// Hoist all the argument evaluation up before the lock.
 	walkexprlistcheap(nn.List.Slice(), init)
 
 	// For println, add " " between elements and "\n" at the end.
-	if nn.Op == OPRINTN {
+	if nn.Op == ir.OPRINTN {
 		s := nn.List.Slice()
-		t := make([]*Node, 0, len(s)*2)
+		t := make([]*ir.Node, 0, len(s)*2)
 		for i, n := range s {
 			if i != 0 {
 				t = append(t, nodstr(" "))
@@ -1913,10 +1914,10 @@ func walkprint(nn *Node, init *Nodes) *Node {
 
 	// Collapse runs of constant strings.
 	s := nn.List.Slice()
-	t := make([]*Node, 0, len(s))
+	t := make([]*ir.Node, 0, len(s))
 	for i := 0; i < len(s); {
 		var strs []string
-		for i < len(s) && Isconst(s[i], constant.String) {
+		for i < len(s) && ir.IsConst(s[i], constant.String) {
 			strs = append(strs, s[i].StringVal())
 			i++
 		}
@@ -1930,73 +1931,73 @@ func walkprint(nn *Node, init *Nodes) *Node {
 	}
 	nn.List.Set(t)
 
-	calls := []*Node{mkcall("printlock", nil, init)}
+	calls := []*ir.Node{mkcall("printlock", nil, init)}
 	for i, n := range nn.List.Slice() {
-		if n.Op == OLITERAL {
+		if n.Op == ir.OLITERAL {
 			if n.Type == types.UntypedRune {
 				n = defaultlit(n, types.Runetype)
 			}
 
 			switch n.Val().Kind() {
 			case constant.Int:
-				n = defaultlit(n, types.Types[TINT64])
+				n = defaultlit(n, types.Types[types.TINT64])
 
 			case constant.Float:
-				n = defaultlit(n, types.Types[TFLOAT64])
+				n = defaultlit(n, types.Types[types.TFLOAT64])
 			}
 		}
 
-		if n.Op != OLITERAL && n.Type != nil && n.Type.Etype == TIDEAL {
-			n = defaultlit(n, types.Types[TINT64])
+		if n.Op != ir.OLITERAL && n.Type != nil && n.Type.Etype == types.TIDEAL {
+			n = defaultlit(n, types.Types[types.TINT64])
 		}
 		n = defaultlit(n, nil)
 		nn.List.SetIndex(i, n)
-		if n.Type == nil || n.Type.Etype == TFORW {
+		if n.Type == nil || n.Type.Etype == types.TFORW {
 			continue
 		}
 
-		var on *Node
+		var on *ir.Node
 		switch n.Type.Etype {
-		case TINTER:
+		case types.TINTER:
 			if n.Type.IsEmptyInterface() {
 				on = syslook("printeface")
 			} else {
 				on = syslook("printiface")
 			}
 			on = substArgTypes(on, n.Type) // any-1
-		case TPTR:
+		case types.TPTR:
 			if n.Type.Elem().NotInHeap() {
 				on = syslook("printuintptr")
-				n = nod(OCONV, n, nil)
-				n.Type = types.Types[TUNSAFEPTR]
-				n = nod(OCONV, n, nil)
-				n.Type = types.Types[TUINTPTR]
+				n = ir.Nod(ir.OCONV, n, nil)
+				n.Type = types.Types[types.TUNSAFEPTR]
+				n = ir.Nod(ir.OCONV, n, nil)
+				n.Type = types.Types[types.TUINTPTR]
 				break
 			}
 			fallthrough
-		case TCHAN, TMAP, TFUNC, TUNSAFEPTR:
+		case types.TCHAN, types.TMAP, types.TFUNC, types.TUNSAFEPTR:
 			on = syslook("printpointer")
 			on = substArgTypes(on, n.Type) // any-1
-		case TSLICE:
+		case types.TSLICE:
 			on = syslook("printslice")
 			on = substArgTypes(on, n.Type) // any-1
-		case TUINT, TUINT8, TUINT16, TUINT32, TUINT64, TUINTPTR:
+		case types.TUINT, types.TUINT8, types.TUINT16, types.TUINT32, types.TUINT64, types.TUINTPTR:
 			if isRuntimePkg(n.Type.Sym.Pkg) && n.Type.Sym.Name == "hex" {
 				on = syslook("printhex")
 			} else {
 				on = syslook("printuint")
 			}
-		case TINT, TINT8, TINT16, TINT32, TINT64:
+		case types.TINT, types.TINT8, types.TINT16, types.TINT32, types.TINT64:
 			on = syslook("printint")
-		case TFLOAT32, TFLOAT64:
+		case types.TFLOAT32, types.TFLOAT64:
 			on = syslook("printfloat")
-		case TCOMPLEX64, TCOMPLEX128:
+		case types.TCOMPLEX64, types.TCOMPLEX128:
 			on = syslook("printcomplex")
-		case TBOOL:
+		case types.TBOOL:
 			on = syslook("printbool")
-		case TSTRING:
+		case types.TSTRING:
 			cs := ""
-			if Isconst(n, constant.String) {
+			if ir.IsConst(n, constant.String) {
 				cs = n.StringVal()
 			}
 			switch cs {
@@ -2008,15 +2009,15 @@ func walkprint(nn *Node, init *Nodes) *Node {
 				on = syslook("printstring")
 			}
 		default:
-			badtype(OPRINT, n.Type, nil)
+			badtype(ir.OPRINT, n.Type, nil)
 			continue
 		}
 
-		r := nod(OCALL, on, nil)
+		r := ir.Nod(ir.OCALL, on, nil)
 		if params := on.Type.Params().FieldSlice(); len(params) > 0 {
 			t := params[0].Type
 			if !types.Identical(t, n.Type) {
-				n = nod(OCONV, n, nil)
+				n = ir.Nod(ir.OCONV, n, nil)
 				n.Type = t
 			}
 			r.List.Append(n)
@@ -2029,16 +2030,16 @@ func walkprint(nn *Node, init *Nodes) *Node {
 	typecheckslice(calls, ctxStmt)
 	walkexprlist(calls, init)
 
-	r := nod(OEMPTY, nil, nil)
+	r := ir.Nod(ir.OEMPTY, nil, nil)
 	r = typecheck(r, ctxStmt)
 	r = walkexpr(r, init)
 	r.Ninit.Set(calls)
 	return r
 }
 
-func callnew(t *types.Type) *Node {
+func callnew(t *types.Type) *ir.Node {
 	dowidth(t)
-	n := nod(ONEWOBJ, typename(t), nil)
+	n := ir.Nod(ir.ONEWOBJ, typename(t), nil)
 	n.Type = types.NewPtr(t)
 	n.SetTypecheck(1)
 	n.MarkNonNil()
@@ -2047,16 +2048,16 @@ func callnew(t *types.Type) *Node {
 
 // isReflectHeaderDataField reports whether l is an expression p.Data
 // where p has type reflect.SliceHeader or reflect.StringHeader.
-func isReflectHeaderDataField(l *Node) bool {
-	if l.Type != types.Types[TUINTPTR] {
+func isReflectHeaderDataField(l *ir.Node) bool {
+	if l.Type != types.Types[types.TUINTPTR] {
 		return false
 	}
 
 	var tsym *types.Sym
 	switch l.Op {
-	case ODOT:
+	case ir.ODOT:
 		tsym = l.Left.Type.Sym
-	case ODOTPTR:
+	case ir.ODOTPTR:
 		tsym = l.Left.Type.Elem().Sym
 	default:
 		return false
@@ -2068,8 +2069,8 @@ func isReflectHeaderDataField(l *Node) bool {
 	return tsym.Name == "SliceHeader" || tsym.Name == "StringHeader"
 }
 
-func convas(n *Node, init *Nodes) *Node {
-	if n.Op != OAS {
+func convas(n *ir.Node, init *ir.Nodes) *ir.Node {
+	if n.Op != ir.OAS {
 		base.Fatalf("convas: not OAS %v", n.Op)
 	}
 	defer updateHasCall(n)
@@ -2086,7 +2087,7 @@ func convas(n *Node, init *Nodes) *Node {
 		return n
 	}
 
-	if n.Left.isBlank() {
+	if ir.IsBlank(n.Left) {
 		n.Right = defaultlit(n.Right, nil)
 		return n
 	}
@@ -2106,25 +2107,25 @@ func convas(n *Node, init *Nodes) *Node {
 // be later use of an earlier lvalue.
 //
 // function calls have been removed.
-func reorder3(all []*Node) []*Node {
+func reorder3(all []*ir.Node) []*ir.Node {
 	// If a needed expression may be affected by an
 	// earlier assignment, make an early copy of that
 	// expression and use the copy instead.
-	var early []*Node
+	var early []*ir.Node
 
-	var mapinit Nodes
+	var mapinit ir.Nodes
 	for i, n := range all {
 		l := n.Left
 
 		// Save subexpressions needed on left side.
 		// Drill through non-dereferences.
 		for {
-			if l.Op == ODOT || l.Op == OPAREN {
+			if l.Op == ir.ODOT || l.Op == ir.OPAREN {
 				l = l.Left
 				continue
 			}
 
-			if l.Op == OINDEX && l.Left.Type.IsArray() {
+			if l.Op == ir.OINDEX && l.Left.Type.IsArray() {
 				l.Right = reorder3save(l.Right, all, i, &early)
 				l = l.Left
 				continue
@@ -2137,17 +2138,17 @@ func reorder3(all []*Node) []*Node {
 		default:
 			base.Fatalf("reorder3 unexpected lvalue %#v", l.Op)
 
-		case ONAME:
+		case ir.ONAME:
 			break
 
-		case OINDEX, OINDEXMAP:
+		case ir.OINDEX, ir.OINDEXMAP:
 			l.Left = reorder3save(l.Left, all, i, &early)
 			l.Right = reorder3save(l.Right, all, i, &early)
-			if l.Op == OINDEXMAP {
+			if l.Op == ir.OINDEXMAP {
 				all[i] = convas(all[i], &mapinit)
 			}
 
-		case ODEREF, ODOTPTR:
+		case ir.ODEREF, ir.ODOTPTR:
 			l.Left = reorder3save(l.Left, all, i, &early)
 		}
 
@@ -2165,13 +2166,13 @@ func reorder3(all []*Node) []*Node {
 // replace *np with that temp.
 // The result of reorder3save MUST be assigned back to n, e.g.
 // 	n.Left = reorder3save(n.Left, all, i, early)
-func reorder3save(n *Node, all []*Node, i int, early *[]*Node) *Node {
+func reorder3save(n *ir.Node, all []*ir.Node, i int, early *[]*ir.Node) *ir.Node {
 	if !aliased(n, all[:i]) {
 		return n
 	}
 
 	q := temp(n.Type)
-	q = nod(OAS, q, n)
+	q = ir.Nod(ir.OAS, q, n)
 	q = typecheck(q, ctxStmt)
 	*early = append(*early, q)
 	return q.Left
@@ -2179,15 +2180,15 @@ func reorder3save(n *Node, all []*Node, i int, early *[]*Node) *Node {
 
 // what's the outer value that a write to n affects?
 // outer value means containing struct or array.
-func outervalue(n *Node) *Node {
+func outervalue(n *ir.Node) *ir.Node {
 	for {
 		switch n.Op {
-		case OXDOT:
+		case ir.OXDOT:
 			base.Fatalf("OXDOT in walk")
-		case ODOT, OPAREN, OCONVNOP:
+		case ir.ODOT, ir.OPAREN, ir.OCONVNOP:
 			n = n.Left
 			continue
-		case OINDEX:
+		case ir.OINDEX:
 			if n.Left.Type != nil && n.Left.Type.IsArray() {
 				n = n.Left
 				continue
@@ -2200,14 +2201,14 @@ func outervalue(n *Node) *Node {
 
 // Is it possible that the computation of r might be
 // affected by assignments in all?
-func aliased(r *Node, all []*Node) bool {
+func aliased(r *ir.Node, all []*ir.Node) bool {
 	if r == nil {
 		return false
 	}
 
 	// Treat all fields of a struct as referring to the whole struct.
 	// We could do better but we would have to keep track of the fields.
-	for r.Op == ODOT {
+	for r.Op == ir.ODOT {
 		r = r.Left
 	}
 
@@ -2219,12 +2220,12 @@ func aliased(r *Node, all []*Node) bool {
 	memwrite := false
 	for _, as := range all {
 		// We can ignore assignments to blank.
-		if as.Left.isBlank() {
+		if ir.IsBlank(as.Left) {
 			continue
 		}
 
 		l := outervalue(as.Left)
-		if l.Op != ONAME {
+		if l.Op != ir.ONAME {
 			memwrite = true
 			continue
 		}
@@ -2233,11 +2234,11 @@ func aliased(r *Node, all []*Node) bool {
 		default:
 			base.Fatalf("unexpected class: %v, %v", l, l.Class())
 
-		case PAUTOHEAP, PEXTERN:
+		case ir.PAUTOHEAP, ir.PEXTERN:
 			memwrite = true
 			continue
 
-		case PAUTO, PPARAM, PPARAMOUT:
+		case ir.PAUTO, ir.PPARAM, ir.PPARAMOUT:
 			if l.Name.Addrtaken() {
 				memwrite = true
 				continue
@@ -2274,18 +2275,18 @@ func aliased(r *Node, all []*Node) bool {
 // does the evaluation of n only refer to variables
 // whose addresses have not been taken?
 // (and no other memory)
-func varexpr(n *Node) bool {
+func varexpr(n *ir.Node) bool {
 	if n == nil {
 		return true
 	}
 
 	switch n.Op {
-	case OLITERAL, ONIL:
+	case ir.OLITERAL, ir.ONIL:
 		return true
 
-	case ONAME:
+	case ir.ONAME:
 		switch n.Class() {
-		case PAUTO, PPARAM, PPARAMOUT:
+		case ir.PAUTO, ir.PPARAM, ir.PPARAMOUT:
 			if !n.Name.Addrtaken() {
 				return true
 			}
@@ -2293,30 +2294,30 @@ func varexpr(n *Node) bool {
 
 		return false
 
-	case OADD,
-		OSUB,
-		OOR,
-		OXOR,
-		OMUL,
-		ODIV,
-		OMOD,
-		OLSH,
-		ORSH,
-		OAND,
-		OANDNOT,
-		OPLUS,
-		ONEG,
-		OBITNOT,
-		OPAREN,
-		OANDAND,
-		OOROR,
-		OCONV,
-		OCONVNOP,
-		OCONVIFACE,
-		ODOTTYPE:
+	case ir.OADD,
+		ir.OSUB,
+		ir.OOR,
+		ir.OXOR,
+		ir.OMUL,
+		ir.ODIV,
+		ir.OMOD,
+		ir.OLSH,
+		ir.ORSH,
+		ir.OAND,
+		ir.OANDNOT,
+		ir.OPLUS,
+		ir.ONEG,
+		ir.OBITNOT,
+		ir.OPAREN,
+		ir.OANDAND,
+		ir.OOROR,
+		ir.OCONV,
+		ir.OCONVNOP,
+		ir.OCONVIFACE,
+		ir.ODOTTYPE:
 		return varexpr(n.Left) && varexpr(n.Right)
 
-	case ODOT: // but not ODOTPTR
+	case ir.ODOT: // but not ODOTPTR
 		// Should have been handled in aliased.
 		base.Fatalf("varexpr unexpected ODOT")
 	}
@@ -2326,16 +2327,16 @@ func varexpr(n *Node) bool {
 }
 
 // is the name l mentioned in r?
-func vmatch2(l *Node, r *Node) bool {
+func vmatch2(l *ir.Node, r *ir.Node) bool {
 	if r == nil {
 		return false
 	}
 	switch r.Op {
 	// match each right given left
-	case ONAME:
+	case ir.ONAME:
 		return l == r
 
-	case OLITERAL, ONIL:
+	case ir.OLITERAL, ir.ONIL:
 		return false
 	}
 
@@ -2355,15 +2356,15 @@ func vmatch2(l *Node, r *Node) bool {
 
 // is any name mentioned in l also mentioned in r?
 // called by sinit.go
-func vmatch1(l *Node, r *Node) bool {
+func vmatch1(l *ir.Node, r *ir.Node) bool {
 	// isolate all left sides
 	if l == nil || r == nil {
 		return false
 	}
 	switch l.Op {
-	case ONAME:
+	case ir.ONAME:
 		switch l.Class() {
-		case PPARAM, PAUTO:
+		case ir.PPARAM, ir.PAUTO:
 			break
 
 		default:
@@ -2376,7 +2377,7 @@ func vmatch1(l *Node, r *Node) bool {
 
 		return vmatch2(l, r)
 
-	case OLITERAL, ONIL:
+	case ir.OLITERAL, ir.ONIL:
 		return false
 	}
 
@@ -2396,10 +2397,10 @@ func vmatch1(l *Node, r *Node) bool {
 
 // paramstoheap returns code to allocate memory for heap-escaped parameters
 // and to copy non-result parameters' values from the stack.
-func paramstoheap(params *types.Type) []*Node {
-	var nn []*Node
+func paramstoheap(params *types.Type) []*ir.Node {
+	var nn []*ir.Node
 	for _, t := range params.Fields().Slice() {
-		v := asNode(t.Nname)
+		v := ir.AsNode(t.Nname)
 		if v != nil && v.Sym != nil && strings.HasPrefix(v.Sym.Name, "~r") { // unnamed result
 			v = nil
 		}
@@ -2408,9 +2409,9 @@ func paramstoheap(params *types.Type) []*Node {
 		}
 
 		if stackcopy := v.Name.Param.Stackcopy; stackcopy != nil {
-			nn = append(nn, walkstmt(nod(ODCL, v, nil)))
-			if stackcopy.Class() == PPARAM {
-				nn = append(nn, walkstmt(typecheck(nod(OAS, v, stackcopy), ctxStmt)))
+			nn = append(nn, walkstmt(ir.Nod(ir.ODCL, v, nil)))
+			if stackcopy.Class() == ir.PPARAM {
+				nn = append(nn, walkstmt(typecheck(ir.Nod(ir.OAS, v, stackcopy), ctxStmt)))
 			}
 		}
 	}
@@ -2427,14 +2428,14 @@ func paramstoheap(params *types.Type) []*Node {
 // The generated code is added to Curfn's Enter list.
 func zeroResults() {
 	for _, f := range Curfn.Type.Results().Fields().Slice() {
-		v := asNode(f.Nname)
+		v := ir.AsNode(f.Nname)
 		if v != nil && v.Name.Param.Heapaddr != nil {
 			// The local which points to the return value is the
 			// thing that needs zeroing. This is already handled
 			// by a Needzero annotation in plive.go:livenessepilogue.
 			continue
 		}
-		if v.isParamHeapCopy() {
+		if isParamHeapCopy(v) {
 			// TODO(josharian/khr): Investigate whether we can switch to "continue" here,
 			// and document more in either case.
 			// In the review of CL 114797, Keith wrote (roughly):
@@ -2444,21 +2445,21 @@ func zeroResults() {
 			v = v.Name.Param.Stackcopy
 		}
 		// Zero the stack location containing f.
-		Curfn.Func.Enter.Append(nodl(Curfn.Pos, OAS, v, nil))
+		Curfn.Func.Enter.Append(ir.NodAt(Curfn.Pos, ir.OAS, v, nil))
 	}
 }
 
 // returnsfromheap returns code to copy values for heap-escaped parameters
 // back to the stack.
-func returnsfromheap(params *types.Type) []*Node {
-	var nn []*Node
+func returnsfromheap(params *types.Type) []*ir.Node {
+	var nn []*ir.Node
 	for _, t := range params.Fields().Slice() {
-		v := asNode(t.Nname)
+		v := ir.AsNode(t.Nname)
 		if v == nil {
 			continue
 		}
-		if stackcopy := v.Name.Param.Stackcopy; stackcopy != nil && stackcopy.Class() == PPARAMOUT {
-			nn = append(nn, walkstmt(typecheck(nod(OAS, stackcopy, v), ctxStmt)))
+		if stackcopy := v.Name.Param.Stackcopy; stackcopy != nil && stackcopy.Class() == ir.PPARAMOUT {
+			nn = append(nn, walkstmt(typecheck(ir.Nod(ir.OAS, stackcopy, v), ctxStmt)))
 		}
 	}
 
@@ -2480,8 +2481,8 @@ func heapmoves() {
 	base.Pos = lno
 }
 
-func vmkcall(fn *Node, t *types.Type, init *Nodes, va []*Node) *Node {
-	if fn.Type == nil || fn.Type.Etype != TFUNC {
+func vmkcall(fn *ir.Node, t *types.Type, init *ir.Nodes, va []*ir.Node) *ir.Node {
+	if fn.Type == nil || fn.Type.Etype != types.TFUNC {
 		base.Fatalf("mkcall %v %v", fn, fn.Type)
 	}
 
@@ -2490,7 +2491,7 @@ func vmkcall(fn *Node, t *types.Type, init *Nodes, va []*Node) *Node {
 		base.Fatalf("vmkcall %v needs %v args got %v", fn, n, len(va))
 	}
 
-	r := nod(OCALL, fn, nil)
+	r := ir.Nod(ir.OCALL, fn, nil)
 	r.List.Set(va)
 	if fn.Type.NumResults() > 0 {
 		r = typecheck(r, ctxExpr|ctxMultiOK)
@@ -2502,19 +2503,19 @@ func vmkcall(fn *Node, t *types.Type, init *Nodes, va []*Node) *Node {
 	return r
 }
 
-func mkcall(name string, t *types.Type, init *Nodes, args ...*Node) *Node {
+func mkcall(name string, t *types.Type, init *ir.Nodes, args ...*ir.Node) *ir.Node {
 	return vmkcall(syslook(name), t, init, args)
 }
 
-func mkcall1(fn *Node, t *types.Type, init *Nodes, args ...*Node) *Node {
+func mkcall1(fn *ir.Node, t *types.Type, init *ir.Nodes, args ...*ir.Node) *ir.Node {
 	return vmkcall(fn, t, init, args)
 }
 
-func conv(n *Node, t *types.Type) *Node {
+func conv(n *ir.Node, t *types.Type) *ir.Node {
 	if types.Identical(n.Type, t) {
 		return n
 	}
-	n = nod(OCONV, n, nil)
+	n = ir.Nod(ir.OCONV, n, nil)
 	n.Type = t
 	n = typecheck(n, ctxExpr)
 	return n
@@ -2522,11 +2523,11 @@ func conv(n *Node, t *types.Type) *Node {
 
 // convnop converts node n to type t using the OCONVNOP op
 // and typechecks the result with ctxExpr.
-func convnop(n *Node, t *types.Type) *Node {
+func convnop(n *ir.Node, t *types.Type) *ir.Node {
 	if types.Identical(n.Type, t) {
 		return n
 	}
-	n = nod(OCONVNOP, n, nil)
+	n = ir.Nod(ir.OCONVNOP, n, nil)
 	n.Type = t
 	n = typecheck(n, ctxExpr)
 	return n
@@ -2535,23 +2536,23 @@ func convnop(n *Node, t *types.Type) *Node {
 // byteindex converts n, which is byte-sized, to an int used to index into an array.
 // We cannot use conv, because we allow converting bool to int here,
 // which is forbidden in user code.
-func byteindex(n *Node) *Node {
+func byteindex(n *ir.Node) *ir.Node {
 	// We cannot convert from bool to int directly.
 	// While converting from int8 to int is possible, it would yield
 	// the wrong result for negative values.
 	// Reinterpreting the value as an unsigned byte solves both cases.
-	if !types.Identical(n.Type, types.Types[TUINT8]) {
-		n = nod(OCONV, n, nil)
-		n.Type = types.Types[TUINT8]
+	if !types.Identical(n.Type, types.Types[types.TUINT8]) {
+		n = ir.Nod(ir.OCONV, n, nil)
+		n.Type = types.Types[types.TUINT8]
 		n.SetTypecheck(1)
 	}
-	n = nod(OCONV, n, nil)
-	n.Type = types.Types[TINT]
+	n = ir.Nod(ir.OCONV, n, nil)
+	n.Type = types.Types[types.TINT]
 	n.SetTypecheck(1)
 	return n
 }
 
-func chanfn(name string, n int, t *types.Type) *Node {
+func chanfn(name string, n int, t *types.Type) *ir.Node {
 	if !t.IsChan() {
 		base.Fatalf("chanfn %v", t)
 	}
@@ -2567,7 +2568,7 @@ func chanfn(name string, n int, t *types.Type) *Node {
 	return fn
 }
 
-func mapfn(name string, t *types.Type) *Node {
+func mapfn(name string, t *types.Type) *ir.Node {
 	if !t.IsMap() {
 		base.Fatalf("mapfn %v", t)
 	}
@@ -2576,7 +2577,7 @@ func mapfn(name string, t *types.Type) *Node {
 	return fn
 }
 
-func mapfndel(name string, t *types.Type) *Node {
+func mapfndel(name string, t *types.Type) *ir.Node {
 	if !t.IsMap() {
 		base.Fatalf("mapfn %v", t)
 	}
@@ -2635,13 +2636,13 @@ func mapfast(t *types.Type) int {
 	return mapslow
 }
 
-func writebarrierfn(name string, l *types.Type, r *types.Type) *Node {
+func writebarrierfn(name string, l *types.Type, r *types.Type) *ir.Node {
 	fn := syslook(name)
 	fn = substArgTypes(fn, l, r)
 	return fn
 }
 
-func addstr(n *Node, init *Nodes) *Node {
+func addstr(n *ir.Node, init *ir.Nodes) *ir.Node {
 	// order.expr rewrote OADDSTR to have a list of strings.
 	c := n.List.Len()
 
@@ -2653,7 +2654,7 @@ func addstr(n *Node, init *Nodes) *Node {
 	if n.Esc == EscNone {
 		sz := int64(0)
 		for _, n1 := range n.List.Slice() {
-			if n1.Op == OLITERAL {
+			if n1.Op == ir.OLITERAL {
 				sz += int64(len(n1.StringVal()))
 			}
 		}
@@ -2661,15 +2662,15 @@ func addstr(n *Node, init *Nodes) *Node {
 		// Don't allocate the buffer if the result won't fit.
 		if sz < tmpstringbufsize {
 			// Create temporary buffer for result string on stack.
-			t := types.NewArray(types.Types[TUINT8], tmpstringbufsize)
-			buf = nod(OADDR, temp(t), nil)
+			t := types.NewArray(types.Types[types.TUINT8], tmpstringbufsize)
+			buf = ir.Nod(ir.OADDR, temp(t), nil)
 		}
 	}
 
 	// build list of string arguments
-	args := []*Node{buf}
+	args := []*ir.Node{buf}
 	for _, n2 := range n.List.Slice() {
-		args = append(args, conv(n2, types.Types[TSTRING]))
+		args = append(args, conv(n2, types.Types[types.TSTRING]))
 	}
 
 	var fn string
@@ -2681,18 +2682,18 @@ func addstr(n *Node, init *Nodes) *Node {
 		// large numbers of strings are passed to the runtime as a slice.
 		fn = "concatstrings"
 
-		t := types.NewSlice(types.Types[TSTRING])
-		slice := nod(OCOMPLIT, nil, typenod(t))
+		t := types.NewSlice(types.Types[types.TSTRING])
+		slice := ir.Nod(ir.OCOMPLIT, nil, typenod(t))
 		if prealloc[n] != nil {
 			prealloc[slice] = prealloc[n]
 		}
 		slice.List.Set(args[1:]) // skip buf arg
-		args = []*Node{buf, slice}
+		args = []*ir.Node{buf, slice}
 		slice.Esc = EscNone
 	}
 
 	cat := syslook(fn)
-	r := nod(OCALL, cat, nil)
+	r := ir.Nod(ir.OCALL, cat, nil)
 	r.List.Set(args)
 	r = typecheck(r, ctxExpr)
 	r = walkexpr(r, init)
@@ -2701,7 +2702,7 @@ func addstr(n *Node, init *Nodes) *Node {
 	return r
 }
 
-func walkAppendArgs(n *Node, init *Nodes) {
+func walkAppendArgs(n *ir.Node, init *ir.Nodes) {
 	walkexprlistsafe(n.List.Slice(), init)
 
 	// walkexprlistsafe will leave OINDEX (s[n]) alone if both s
@@ -2727,7 +2728,7 @@ func walkAppendArgs(n *Node, init *Nodes) {
 //   s
 //
 // l2 is allowed to be a string.
-func appendslice(n *Node, init *Nodes) *Node {
+func appendslice(n *ir.Node, init *ir.Nodes) *ir.Node {
 	walkAppendArgs(n, init)
 
 	l1 := n.List.First()
@@ -2735,82 +2736,82 @@ func appendslice(n *Node, init *Nodes) *Node {
 	l2 = cheapexpr(l2, init)
 	n.List.SetSecond(l2)
 
-	var nodes Nodes
+	var nodes ir.Nodes
 
 	// var s []T
 	s := temp(l1.Type)
-	nodes.Append(nod(OAS, s, l1)) // s = l1
+	nodes.Append(ir.Nod(ir.OAS, s, l1)) // s = l1
 
 	elemtype := s.Type.Elem()
 
 	// n := len(s) + len(l2)
-	nn := temp(types.Types[TINT])
-	nodes.Append(nod(OAS, nn, nod(OADD, nod(OLEN, s, nil), nod(OLEN, l2, nil))))
+	nn := temp(types.Types[types.TINT])
+	nodes.Append(ir.Nod(ir.OAS, nn, ir.Nod(ir.OADD, ir.Nod(ir.OLEN, s, nil), ir.Nod(ir.OLEN, l2, nil))))
 
 	// if uint(n) > uint(cap(s))
-	nif := nod(OIF, nil, nil)
-	nuint := conv(nn, types.Types[TUINT])
-	scapuint := conv(nod(OCAP, s, nil), types.Types[TUINT])
-	nif.Left = nod(OGT, nuint, scapuint)
+	nif := ir.Nod(ir.OIF, nil, nil)
+	nuint := conv(nn, types.Types[types.TUINT])
+	scapuint := conv(ir.Nod(ir.OCAP, s, nil), types.Types[types.TUINT])
+	nif.Left = ir.Nod(ir.OGT, nuint, scapuint)
 
 	// instantiate growslice(typ *type, []any, int) []any
 	fn := syslook("growslice")
 	fn = substArgTypes(fn, elemtype, elemtype)
 
 	// s = growslice(T, s, n)
-	nif.Nbody.Set1(nod(OAS, s, mkcall1(fn, s.Type, &nif.Ninit, typename(elemtype), s, nn)))
+	nif.Nbody.Set1(ir.Nod(ir.OAS, s, mkcall1(fn, s.Type, &nif.Ninit, typename(elemtype), s, nn)))
 	nodes.Append(nif)
 
 	// s = s[:n]
-	nt := nod(OSLICE, s, nil)
+	nt := ir.Nod(ir.OSLICE, s, nil)
 	nt.SetSliceBounds(nil, nn, nil)
 	nt.SetBounded(true)
-	nodes.Append(nod(OAS, s, nt))
+	nodes.Append(ir.Nod(ir.OAS, s, nt))
 
-	var ncopy *Node
+	var ncopy *ir.Node
 	if elemtype.HasPointers() {
 		// copy(s[len(l1):], l2)
-		nptr1 := nod(OSLICE, s, nil)
+		nptr1 := ir.Nod(ir.OSLICE, s, nil)
 		nptr1.Type = s.Type
-		nptr1.SetSliceBounds(nod(OLEN, l1, nil), nil, nil)
+		nptr1.SetSliceBounds(ir.Nod(ir.OLEN, l1, nil), nil, nil)
 		nptr1 = cheapexpr(nptr1, &nodes)
 
 		nptr2 := l2
 
-		Curfn.Func.setWBPos(n.Pos)
+		Curfn.Func.SetWBPos(n.Pos)
 
 		// instantiate typedslicecopy(typ *type, dstPtr *any, dstLen int, srcPtr *any, srcLen int) int
 		fn := syslook("typedslicecopy")
 		fn = substArgTypes(fn, l1.Type.Elem(), l2.Type.Elem())
-		ptr1, len1 := nptr1.backingArrayPtrLen()
-		ptr2, len2 := nptr2.backingArrayPtrLen()
-		ncopy = mkcall1(fn, types.Types[TINT], &nodes, typename(elemtype), ptr1, len1, ptr2, len2)
+		ptr1, len1 := backingArrayPtrLen(nptr1)
+		ptr2, len2 := backingArrayPtrLen(nptr2)
+		ncopy = mkcall1(fn, types.Types[types.TINT], &nodes, typename(elemtype), ptr1, len1, ptr2, len2)
 	} else if instrumenting && !base.Flag.CompilingRuntime {
 		// rely on runtime to instrument:
 		//  copy(s[len(l1):], l2)
 		// l2 can be a slice or string.
-		nptr1 := nod(OSLICE, s, nil)
+		nptr1 := ir.Nod(ir.OSLICE, s, nil)
 		nptr1.Type = s.Type
-		nptr1.SetSliceBounds(nod(OLEN, l1, nil), nil, nil)
+		nptr1.SetSliceBounds(ir.Nod(ir.OLEN, l1, nil), nil, nil)
 		nptr1 = cheapexpr(nptr1, &nodes)
 		nptr2 := l2
 
-		ptr1, len1 := nptr1.backingArrayPtrLen()
-		ptr2, len2 := nptr2.backingArrayPtrLen()
+		ptr1, len1 := backingArrayPtrLen(nptr1)
+		ptr2, len2 := backingArrayPtrLen(nptr2)
 
 		fn := syslook("slicecopy")
 		fn = substArgTypes(fn, ptr1.Type.Elem(), ptr2.Type.Elem())
-		ncopy = mkcall1(fn, types.Types[TINT], &nodes, ptr1, len1, ptr2, len2, nodintconst(elemtype.Width))
+		ncopy = mkcall1(fn, types.Types[types.TINT], &nodes, ptr1, len1, ptr2, len2, nodintconst(elemtype.Width))
 	} else {
 		// memmove(&s[len(l1)], &l2[0], len(l2)*sizeof(T))
-		nptr1 := nod(OINDEX, s, nod(OLEN, l1, nil))
+		nptr1 := ir.Nod(ir.OINDEX, s, ir.Nod(ir.OLEN, l1, nil))
 		nptr1.SetBounded(true)
-		nptr1 = nod(OADDR, nptr1, nil)
+		nptr1 = ir.Nod(ir.OADDR, nptr1, nil)
 
-		nptr2 := nod(OSPTR, l2, nil)
+		nptr2 := ir.Nod(ir.OSPTR, l2, nil)
 
-		nwid := cheapexpr(conv(nod(OLEN, l2, nil), types.Types[TUINTPTR]), &nodes)
-		nwid = nod(OMUL, nwid, nodintconst(elemtype.Width))
+		nwid := cheapexpr(conv(ir.Nod(ir.OLEN, l2, nil), types.Types[types.TUINTPTR]), &nodes)
+		nwid = ir.Nod(ir.OMUL, nwid, nodintconst(elemtype.Width))
 
 		// instantiate func memmove(to *any, frm *any, length uintptr)
 		fn := syslook("memmove")
@@ -2827,7 +2828,7 @@ func appendslice(n *Node, init *Nodes) *Node {
 
 // isAppendOfMake reports whether n is of the form append(x , make([]T, y)...).
 // isAppendOfMake assumes n has already been typechecked.
-func isAppendOfMake(n *Node) bool {
+func isAppendOfMake(n *ir.Node) bool {
 	if base.Flag.N != 0 || instrumenting {
 		return false
 	}
@@ -2836,12 +2837,12 @@ func isAppendOfMake(n *Node) bool {
 		base.Fatalf("missing typecheck: %+v", n)
 	}
 
-	if n.Op != OAPPEND || !n.IsDDD() || n.List.Len() != 2 {
+	if n.Op != ir.OAPPEND || !n.IsDDD() || n.List.Len() != 2 {
 		return false
 	}
 
 	second := n.List.Second()
-	if second.Op != OMAKESLICE || second.Right != nil {
+	if second.Op != ir.OMAKESLICE || second.Right != nil {
 		return false
 	}
 
@@ -2852,7 +2853,7 @@ func isAppendOfMake(n *Node) bool {
 
 	// The care of overflow of the len argument to make will be handled by an explicit check of int(len) < 0 during runtime.
 	y := second.Left
-	if !Isconst(y, constant.Int) && y.Type.Size() > types.Types[TUINT].Size() {
+	if !ir.IsConst(y, constant.Int) && y.Type.Size() > types.Types[types.TUINT].Size() {
 		return false
 	}
 
@@ -2886,11 +2887,11 @@ func isAppendOfMake(n *Node) bool {
 //     }
 //   }
 //   s
-func extendslice(n *Node, init *Nodes) *Node {
+func extendslice(n *ir.Node, init *ir.Nodes) *ir.Node {
 	// isAppendOfMake made sure all possible positive values of l2 fit into an uint.
 	// The case of l2 overflow when converting from e.g. uint to int is handled by an explicit
 	// check of l2 < 0 at runtime which is generated below.
-	l2 := conv(n.List.Second().Left, types.Types[TINT])
+	l2 := conv(n.List.Second().Left, types.Types[types.TINT])
 	l2 = typecheck(l2, ctxExpr)
 	n.List.SetSecond(l2) // walkAppendArgs expects l2 in n.List.Second().
 
@@ -2899,10 +2900,10 @@ func extendslice(n *Node, init *Nodes) *Node {
 	l1 := n.List.First()
 	l2 = n.List.Second() // re-read l2, as it may have been updated by walkAppendArgs
 
-	var nodes []*Node
+	var nodes []*ir.Node
 
 	// if l2 >= 0 (likely happens), do nothing
-	nifneg := nod(OIF, nod(OGE, l2, nodintconst(0)), nil)
+	nifneg := ir.Nod(ir.OIF, ir.Nod(ir.OGE, l2, nodintconst(0)), nil)
 	nifneg.SetLikely(true)
 
 	// else panicmakeslicelen()
@@ -2911,67 +2912,67 @@ func extendslice(n *Node, init *Nodes) *Node {
 
 	// s := l1
 	s := temp(l1.Type)
-	nodes = append(nodes, nod(OAS, s, l1))
+	nodes = append(nodes, ir.Nod(ir.OAS, s, l1))
 
 	elemtype := s.Type.Elem()
 
 	// n := len(s) + l2
-	nn := temp(types.Types[TINT])
-	nodes = append(nodes, nod(OAS, nn, nod(OADD, nod(OLEN, s, nil), l2)))
+	nn := temp(types.Types[types.TINT])
+	nodes = append(nodes, ir.Nod(ir.OAS, nn, ir.Nod(ir.OADD, ir.Nod(ir.OLEN, s, nil), l2)))
 
 	// if uint(n) > uint(cap(s))
-	nuint := conv(nn, types.Types[TUINT])
-	capuint := conv(nod(OCAP, s, nil), types.Types[TUINT])
-	nif := nod(OIF, nod(OGT, nuint, capuint), nil)
+	nuint := conv(nn, types.Types[types.TUINT])
+	capuint := conv(ir.Nod(ir.OCAP, s, nil), types.Types[types.TUINT])
+	nif := ir.Nod(ir.OIF, ir.Nod(ir.OGT, nuint, capuint), nil)
 
 	// instantiate growslice(typ *type, old []any, newcap int) []any
 	fn := syslook("growslice")
 	fn = substArgTypes(fn, elemtype, elemtype)
 
 	// s = growslice(T, s, n)
-	nif.Nbody.Set1(nod(OAS, s, mkcall1(fn, s.Type, &nif.Ninit, typename(elemtype), s, nn)))
+	nif.Nbody.Set1(ir.Nod(ir.OAS, s, mkcall1(fn, s.Type, &nif.Ninit, typename(elemtype), s, nn)))
 	nodes = append(nodes, nif)
 
 	// s = s[:n]
-	nt := nod(OSLICE, s, nil)
+	nt := ir.Nod(ir.OSLICE, s, nil)
 	nt.SetSliceBounds(nil, nn, nil)
 	nt.SetBounded(true)
-	nodes = append(nodes, nod(OAS, s, nt))
+	nodes = append(nodes, ir.Nod(ir.OAS, s, nt))
 
 	// lptr := &l1[0]
 	l1ptr := temp(l1.Type.Elem().PtrTo())
-	tmp := nod(OSPTR, l1, nil)
-	nodes = append(nodes, nod(OAS, l1ptr, tmp))
+	tmp := ir.Nod(ir.OSPTR, l1, nil)
+	nodes = append(nodes, ir.Nod(ir.OAS, l1ptr, tmp))
 
 	// sptr := &s[0]
 	sptr := temp(elemtype.PtrTo())
-	tmp = nod(OSPTR, s, nil)
-	nodes = append(nodes, nod(OAS, sptr, tmp))
+	tmp = ir.Nod(ir.OSPTR, s, nil)
+	nodes = append(nodes, ir.Nod(ir.OAS, sptr, tmp))
 
 	// hp := &s[len(l1)]
-	hp := nod(OINDEX, s, nod(OLEN, l1, nil))
+	hp := ir.Nod(ir.OINDEX, s, ir.Nod(ir.OLEN, l1, nil))
 	hp.SetBounded(true)
-	hp = nod(OADDR, hp, nil)
-	hp = convnop(hp, types.Types[TUNSAFEPTR])
+	hp = ir.Nod(ir.OADDR, hp, nil)
+	hp = convnop(hp, types.Types[types.TUNSAFEPTR])
 
 	// hn := l2 * sizeof(elem(s))
-	hn := nod(OMUL, l2, nodintconst(elemtype.Width))
-	hn = conv(hn, types.Types[TUINTPTR])
+	hn := ir.Nod(ir.OMUL, l2, nodintconst(elemtype.Width))
+	hn = conv(hn, types.Types[types.TUINTPTR])
 
 	clrname := "memclrNoHeapPointers"
 	hasPointers := elemtype.HasPointers()
 	if hasPointers {
 		clrname = "memclrHasPointers"
-		Curfn.Func.setWBPos(n.Pos)
+		Curfn.Func.SetWBPos(n.Pos)
 	}
 
-	var clr Nodes
+	var clr ir.Nodes
 	clrfn := mkcall(clrname, nil, &clr, hp, hn)
 	clr.Append(clrfn)
 
 	if hasPointers {
 		// if l1ptr == sptr
-		nifclr := nod(OIF, nod(OEQ, l1ptr, sptr), nil)
+		nifclr := ir.Nod(ir.OIF, ir.Nod(ir.OEQ, l1ptr, sptr), nil)
 		nifclr.Nbody = clr
 		nodes = append(nodes, nifclr)
 	} else {
@@ -3005,7 +3006,7 @@ func extendslice(n *Node, init *Nodes) *Node {
 //     ...
 //   }
 //   s
-func walkappend(n *Node, init *Nodes, dst *Node) *Node {
+func walkappend(n *ir.Node, init *ir.Nodes, dst *ir.Node) *ir.Node {
 	if !samesafeexpr(dst, n.List.First()) {
 		n.List.SetFirst(safeexpr(n.List.First(), init))
 		n.List.SetFirst(walkexpr(n.List.First(), init))
@@ -3041,39 +3042,39 @@ func walkappend(n *Node, init *Nodes, dst *Node) *Node {
 		return n
 	}
 
-	var l []*Node
+	var l []*ir.Node
 
 	ns := temp(nsrc.Type)
-	l = append(l, nod(OAS, ns, nsrc)) // s = src
+	l = append(l, ir.Nod(ir.OAS, ns, nsrc)) // s = src
 
 	na := nodintconst(int64(argc)) // const argc
-	nx := nod(OIF, nil, nil)       // if cap(s) - len(s) < argc
-	nx.Left = nod(OLT, nod(OSUB, nod(OCAP, ns, nil), nod(OLEN, ns, nil)), na)
+	nx := ir.Nod(ir.OIF, nil, nil) // if cap(s) - len(s) < argc
+	nx.Left = ir.Nod(ir.OLT, ir.Nod(ir.OSUB, ir.Nod(ir.OCAP, ns, nil), ir.Nod(ir.OLEN, ns, nil)), na)
 
 	fn := syslook("growslice") //   growslice(<type>, old []T, mincap int) (ret []T)
 	fn = substArgTypes(fn, ns.Type.Elem(), ns.Type.Elem())
 
-	nx.Nbody.Set1(nod(OAS, ns,
+	nx.Nbody.Set1(ir.Nod(ir.OAS, ns,
 		mkcall1(fn, ns.Type, &nx.Ninit, typename(ns.Type.Elem()), ns,
-			nod(OADD, nod(OLEN, ns, nil), na))))
+			ir.Nod(ir.OADD, ir.Nod(ir.OLEN, ns, nil), na))))
 
 	l = append(l, nx)
 
-	nn := temp(types.Types[TINT])
-	l = append(l, nod(OAS, nn, nod(OLEN, ns, nil))) // n = len(s)
+	nn := temp(types.Types[types.TINT])
+	l = append(l, ir.Nod(ir.OAS, nn, ir.Nod(ir.OLEN, ns, nil))) // n = len(s)
 
-	nx = nod(OSLICE, ns, nil) // ...s[:n+argc]
-	nx.SetSliceBounds(nil, nod(OADD, nn, na), nil)
+	nx = ir.Nod(ir.OSLICE, ns, nil) // ...s[:n+argc]
+	nx.SetSliceBounds(nil, ir.Nod(ir.OADD, nn, na), nil)
 	nx.SetBounded(true)
-	l = append(l, nod(OAS, ns, nx)) // s = s[:n+argc]
+	l = append(l, ir.Nod(ir.OAS, ns, nx)) // s = s[:n+argc]
 
 	ls = n.List.Slice()[1:]
 	for i, n := range ls {
-		nx = nod(OINDEX, ns, nn) // s[n] ...
+		nx = ir.Nod(ir.OINDEX, ns, nn) // s[n] ...
 		nx.SetBounded(true)
-		l = append(l, nod(OAS, nx, n)) // s[n] = arg
+		l = append(l, ir.Nod(ir.OAS, nx, n)) // s[n] = arg
 		if i+1 < len(ls) {
-			l = append(l, nod(OAS, nn, nod(OADD, nn, nodintconst(1)))) // n = n + 1
+			l = append(l, ir.Nod(ir.OAS, nn, ir.Nod(ir.OADD, nn, nodintconst(1)))) // n = n + 1
 		}
 	}
 
@@ -3094,14 +3095,14 @@ func walkappend(n *Node, init *Nodes, dst *Node) *Node {
 //
 // Also works if b is a string.
 //
-func copyany(n *Node, init *Nodes, runtimecall bool) *Node {
+func copyany(n *ir.Node, init *ir.Nodes, runtimecall bool) *ir.Node {
 	if n.Left.Type.Elem().HasPointers() {
-		Curfn.Func.setWBPos(n.Pos)
+		Curfn.Func.SetWBPos(n.Pos)
 		fn := writebarrierfn("typedslicecopy", n.Left.Type.Elem(), n.Right.Type.Elem())
 		n.Left = cheapexpr(n.Left, init)
-		ptrL, lenL := n.Left.backingArrayPtrLen()
+		ptrL, lenL := backingArrayPtrLen(n.Left)
 		n.Right = cheapexpr(n.Right, init)
-		ptrR, lenR := n.Right.backingArrayPtrLen()
+		ptrR, lenR := backingArrayPtrLen(n.Right)
 		return mkcall1(fn, n.Type, init, typename(n.Left.Type.Elem()), ptrL, lenL, ptrR, lenR)
 	}
 
@@ -3111,9 +3112,9 @@ func copyany(n *Node, init *Nodes, runtimecall bool) *Node {
 		// n.Right can be a slice or string.
 
 		n.Left = cheapexpr(n.Left, init)
-		ptrL, lenL := n.Left.backingArrayPtrLen()
+		ptrL, lenL := backingArrayPtrLen(n.Left)
 		n.Right = cheapexpr(n.Right, init)
-		ptrR, lenR := n.Right.backingArrayPtrLen()
+		ptrR, lenR := backingArrayPtrLen(n.Right)
 
 		fn := syslook("slicecopy")
 		fn = substArgTypes(fn, ptrL.Type.Elem(), ptrR.Type.Elem())
@@ -3125,36 +3126,36 @@ func copyany(n *Node, init *Nodes, runtimecall bool) *Node {
 	n.Right = walkexpr(n.Right, init)
 	nl := temp(n.Left.Type)
 	nr := temp(n.Right.Type)
-	var l []*Node
-	l = append(l, nod(OAS, nl, n.Left))
-	l = append(l, nod(OAS, nr, n.Right))
+	var l []*ir.Node
+	l = append(l, ir.Nod(ir.OAS, nl, n.Left))
+	l = append(l, ir.Nod(ir.OAS, nr, n.Right))
 
-	nfrm := nod(OSPTR, nr, nil)
-	nto := nod(OSPTR, nl, nil)
+	nfrm := ir.Nod(ir.OSPTR, nr, nil)
+	nto := ir.Nod(ir.OSPTR, nl, nil)
 
-	nlen := temp(types.Types[TINT])
+	nlen := temp(types.Types[types.TINT])
 
 	// n = len(to)
-	l = append(l, nod(OAS, nlen, nod(OLEN, nl, nil)))
+	l = append(l, ir.Nod(ir.OAS, nlen, ir.Nod(ir.OLEN, nl, nil)))
 
 	// if n > len(frm) { n = len(frm) }
-	nif := nod(OIF, nil, nil)
+	nif := ir.Nod(ir.OIF, nil, nil)
 
-	nif.Left = nod(OGT, nlen, nod(OLEN, nr, nil))
-	nif.Nbody.Append(nod(OAS, nlen, nod(OLEN, nr, nil)))
+	nif.Left = ir.Nod(ir.OGT, nlen, ir.Nod(ir.OLEN, nr, nil))
+	nif.Nbody.Append(ir.Nod(ir.OAS, nlen, ir.Nod(ir.OLEN, nr, nil)))
 	l = append(l, nif)
 
 	// if to.ptr != frm.ptr { memmove( ... ) }
-	ne := nod(OIF, nod(ONE, nto, nfrm), nil)
+	ne := ir.Nod(ir.OIF, ir.Nod(ir.ONE, nto, nfrm), nil)
 	ne.SetLikely(true)
 	l = append(l, ne)
 
 	fn := syslook("memmove")
 	fn = substArgTypes(fn, nl.Type.Elem(), nl.Type.Elem())
-	nwid := temp(types.Types[TUINTPTR])
-	setwid := nod(OAS, nwid, conv(nlen, types.Types[TUINTPTR]))
+	nwid := temp(types.Types[types.TUINTPTR])
+	setwid := ir.Nod(ir.OAS, nwid, conv(nlen, types.Types[types.TUINTPTR]))
 	ne.Nbody.Append(setwid)
-	nwid = nod(OMUL, nwid, nodintconst(nl.Type.Elem().Width))
+	nwid = ir.Nod(ir.OMUL, nwid, nodintconst(nl.Type.Elem().Width))
 	call := mkcall1(fn, nil, init, nto, nfrm, nwid)
 	ne.Nbody.Append(call)
 
@@ -3164,7 +3165,7 @@ func copyany(n *Node, init *Nodes, runtimecall bool) *Node {
 	return nlen
 }
 
-func eqfor(t *types.Type) (n *Node, needsize bool) {
+func eqfor(t *types.Type) (n *ir.Node, needsize bool) {
 	// Should only arrive here with large memory or
 	// a struct/array containing a non-memory field/element.
 	// Small memory is handled inline, and single non-memory
@@ -3176,13 +3177,13 @@ func eqfor(t *types.Type) (n *Node, needsize bool) {
 		return n, true
 	case ASPECIAL:
 		sym := typesymprefix(".eq", t)
-		n := newname(sym)
+		n := NewName(sym)
 		setNodeNameFunc(n)
-		n.Type = functype(nil, []*Node{
+		n.Type = functype(nil, []*ir.Node{
 			anonfield(types.NewPtr(t)),
 			anonfield(types.NewPtr(t)),
-		}, []*Node{
-			anonfield(types.Types[TBOOL]),
+		}, []*ir.Node{
+			anonfield(types.Types[types.TBOOL]),
 		})
 		return n, false
 	}
@@ -3192,8 +3193,8 @@ func eqfor(t *types.Type) (n *Node, needsize bool) {
 
 // The result of walkcompare MUST be assigned back to n, e.g.
 // 	n.Left = walkcompare(n.Left, init)
-func walkcompare(n *Node, init *Nodes) *Node {
-	if n.Left.Type.IsInterface() && n.Right.Type.IsInterface() && n.Left.Op != ONIL && n.Right.Op != ONIL {
+func walkcompare(n *ir.Node, init *ir.Nodes) *ir.Node {
+	if n.Left.Type.IsInterface() && n.Right.Type.IsInterface() && n.Left.Op != ir.ONIL && n.Right.Op != ir.ONIL {
 		return walkcompareInterface(n, init)
 	}
 
@@ -3218,31 +3219,31 @@ func walkcompare(n *Node, init *Nodes) *Node {
 
 		// Handle both == and !=.
 		eq := n.Op
-		andor := OOROR
-		if eq == OEQ {
-			andor = OANDAND
+		andor := ir.OOROR
+		if eq == ir.OEQ {
+			andor = ir.OANDAND
 		}
 		// Check for types equal.
 		// For empty interface, this is:
 		//   l.tab == type(r)
 		// For non-empty interface, this is:
 		//   l.tab != nil && l.tab._type == type(r)
-		var eqtype *Node
-		tab := nod(OITAB, l, nil)
+		var eqtype *ir.Node
+		tab := ir.Nod(ir.OITAB, l, nil)
 		rtyp := typename(r.Type)
 		if l.Type.IsEmptyInterface() {
-			tab.Type = types.NewPtr(types.Types[TUINT8])
+			tab.Type = types.NewPtr(types.Types[types.TUINT8])
 			tab.SetTypecheck(1)
-			eqtype = nod(eq, tab, rtyp)
+			eqtype = ir.Nod(eq, tab, rtyp)
 		} else {
-			nonnil := nod(brcom(eq), nodnil(), tab)
-			match := nod(eq, itabType(tab), rtyp)
-			eqtype = nod(andor, nonnil, match)
+			nonnil := ir.Nod(brcom(eq), nodnil(), tab)
+			match := ir.Nod(eq, itabType(tab), rtyp)
+			eqtype = ir.Nod(andor, nonnil, match)
 		}
 		// Check for data equal.
-		eqdata := nod(eq, ifaceData(n.Pos, l, r.Type), r)
+		eqdata := ir.Nod(eq, ifaceData(n.Pos, l, r.Type), r)
 		// Put it all together.
-		expr := nod(andor, eqtype, eqdata)
+		expr := ir.Nod(andor, eqtype, eqdata)
 		n = finishcompare(n, expr, init)
 		return n
 	}
@@ -3272,10 +3273,10 @@ func walkcompare(n *Node, init *Nodes) *Node {
 			// instead, and arrange for the constant
 			// operand to be the first argument.
 			l, r := n.Left, n.Right
-			if r.Op == OLITERAL {
+			if r.Op == ir.OLITERAL {
 				l, r = r, l
 			}
-			constcmp := l.Op == OLITERAL && r.Op != OLITERAL
+			constcmp := l.Op == ir.OLITERAL && r.Op != ir.OLITERAL
 
 			var fn string
 			var paramType *types.Type
@@ -3285,44 +3286,44 @@ func walkcompare(n *Node, init *Nodes) *Node {
 				if constcmp {
 					fn = "libfuzzerTraceConstCmp1"
 				}
-				paramType = types.Types[TUINT8]
+				paramType = types.Types[types.TUINT8]
 			case 2:
 				fn = "libfuzzerTraceCmp2"
 				if constcmp {
 					fn = "libfuzzerTraceConstCmp2"
 				}
-				paramType = types.Types[TUINT16]
+				paramType = types.Types[types.TUINT16]
 			case 4:
 				fn = "libfuzzerTraceCmp4"
 				if constcmp {
 					fn = "libfuzzerTraceConstCmp4"
 				}
-				paramType = types.Types[TUINT32]
+				paramType = types.Types[types.TUINT32]
 			case 8:
 				fn = "libfuzzerTraceCmp8"
 				if constcmp {
 					fn = "libfuzzerTraceConstCmp8"
 				}
-				paramType = types.Types[TUINT64]
+				paramType = types.Types[types.TUINT64]
 			default:
 				base.Fatalf("unexpected integer size %d for %v", t.Size(), t)
 			}
 			init.Append(mkcall(fn, nil, init, tracecmpArg(l, paramType, init), tracecmpArg(r, paramType, init)))
 		}
 		return n
-	case TARRAY:
+	case types.TARRAY:
 		// We can compare several elements at once with 2/4/8 byte integer compares
 		inline = t.NumElem() <= 1 || (issimple[t.Elem().Etype] && (t.NumElem() <= 4 || t.Elem().Width*t.NumElem() <= maxcmpsize))
-	case TSTRUCT:
+	case types.TSTRUCT:
 		inline = t.NumComponents(types.IgnoreBlankFields) <= 4
 	}
 
 	cmpl := n.Left
-	for cmpl != nil && cmpl.Op == OCONVNOP {
+	for cmpl != nil && cmpl.Op == ir.OCONVNOP {
 		cmpl = cmpl.Left
 	}
 	cmpr := n.Right
-	for cmpr != nil && cmpr.Op == OCONVNOP {
+	for cmpr != nil && cmpr.Op == ir.OCONVNOP {
 		cmpr = cmpr.Left
 	}
 
@@ -3334,32 +3335,32 @@ func walkcompare(n *Node, init *Nodes) *Node {
 		}
 
 		fn, needsize := eqfor(t)
-		call := nod(OCALL, fn, nil)
-		call.List.Append(nod(OADDR, cmpl, nil))
-		call.List.Append(nod(OADDR, cmpr, nil))
+		call := ir.Nod(ir.OCALL, fn, nil)
+		call.List.Append(ir.Nod(ir.OADDR, cmpl, nil))
+		call.List.Append(ir.Nod(ir.OADDR, cmpr, nil))
 		if needsize {
 			call.List.Append(nodintconst(t.Width))
 		}
 		res := call
-		if n.Op != OEQ {
-			res = nod(ONOT, res, nil)
+		if n.Op != ir.OEQ {
+			res = ir.Nod(ir.ONOT, res, nil)
 		}
 		n = finishcompare(n, res, init)
 		return n
 	}
 
 	// inline: build boolean expression comparing element by element
-	andor := OANDAND
-	if n.Op == ONE {
-		andor = OOROR
+	andor := ir.OANDAND
+	if n.Op == ir.ONE {
+		andor = ir.OOROR
 	}
-	var expr *Node
-	compare := func(el, er *Node) {
-		a := nod(n.Op, el, er)
+	var expr *ir.Node
+	compare := func(el, er *ir.Node) {
+		a := ir.Nod(n.Op, el, er)
 		if expr == nil {
 			expr = a
 		} else {
-			expr = nod(andor, expr, a)
+			expr = ir.Nod(andor, expr, a)
 		}
 	}
 	cmpl = safeexpr(cmpl, init)
@@ -3371,8 +3372,8 @@ func walkcompare(n *Node, init *Nodes) *Node {
 				continue
 			}
 			compare(
-				nodSym(OXDOT, cmpl, sym),
-				nodSym(OXDOT, cmpr, sym),
+				nodSym(ir.OXDOT, cmpl, sym),
+				nodSym(ir.OXDOT, cmpr, sym),
 			)
 		}
 	} else {
@@ -3385,45 +3386,45 @@ func walkcompare(n *Node, init *Nodes) *Node {
 			var convType *types.Type
 			switch {
 			case remains >= 8 && combine64bit:
-				convType = types.Types[TINT64]
+				convType = types.Types[types.TINT64]
 				step = 8 / t.Elem().Width
 			case remains >= 4 && combine32bit:
-				convType = types.Types[TUINT32]
+				convType = types.Types[types.TUINT32]
 				step = 4 / t.Elem().Width
 			case remains >= 2 && combine16bit:
-				convType = types.Types[TUINT16]
+				convType = types.Types[types.TUINT16]
 				step = 2 / t.Elem().Width
 			default:
 				step = 1
 			}
 			if step == 1 {
 				compare(
-					nod(OINDEX, cmpl, nodintconst(i)),
-					nod(OINDEX, cmpr, nodintconst(i)),
+					ir.Nod(ir.OINDEX, cmpl, nodintconst(i)),
+					ir.Nod(ir.OINDEX, cmpr, nodintconst(i)),
 				)
 				i++
 				remains -= t.Elem().Width
 			} else {
 				elemType := t.Elem().ToUnsigned()
-				cmplw := nod(OINDEX, cmpl, nodintconst(i))
+				cmplw := ir.Nod(ir.OINDEX, cmpl, nodintconst(i))
 				cmplw = conv(cmplw, elemType) // convert to unsigned
 				cmplw = conv(cmplw, convType) // widen
-				cmprw := nod(OINDEX, cmpr, nodintconst(i))
+				cmprw := ir.Nod(ir.OINDEX, cmpr, nodintconst(i))
 				cmprw = conv(cmprw, elemType)
 				cmprw = conv(cmprw, convType)
 				// For code like this:  uint32(s[0]) | uint32(s[1])<<8 | uint32(s[2])<<16 ...
 				// ssa will generate a single large load.
 				for offset := int64(1); offset < step; offset++ {
-					lb := nod(OINDEX, cmpl, nodintconst(i+offset))
+					lb := ir.Nod(ir.OINDEX, cmpl, nodintconst(i+offset))
 					lb = conv(lb, elemType)
 					lb = conv(lb, convType)
-					lb = nod(OLSH, lb, nodintconst(8*t.Elem().Width*offset))
-					cmplw = nod(OOR, cmplw, lb)
-					rb := nod(OINDEX, cmpr, nodintconst(i+offset))
+					lb = ir.Nod(ir.OLSH, lb, nodintconst(8*t.Elem().Width*offset))
+					cmplw = ir.Nod(ir.OOR, cmplw, lb)
+					rb := ir.Nod(ir.OINDEX, cmpr, nodintconst(i+offset))
 					rb = conv(rb, elemType)
 					rb = conv(rb, convType)
-					rb = nod(OLSH, rb, nodintconst(8*t.Elem().Width*offset))
-					cmprw = nod(OOR, cmprw, rb)
+					rb = ir.Nod(ir.OLSH, rb, nodintconst(8*t.Elem().Width*offset))
+					cmprw = ir.Nod(ir.OOR, cmprw, rb)
 				}
 				compare(cmplw, cmprw)
 				i += step
@@ -3432,13 +3433,13 @@ func walkcompare(n *Node, init *Nodes) *Node {
 		}
 	}
 	if expr == nil {
-		expr = nodbool(n.Op == OEQ)
+		expr = nodbool(n.Op == ir.OEQ)
 		// We still need to use cmpl and cmpr, in case they contain
 		// an expression which might panic. See issue 23837.
 		t := temp(cmpl.Type)
-		a1 := nod(OAS, t, cmpl)
+		a1 := ir.Nod(ir.OAS, t, cmpl)
 		a1 = typecheck(a1, ctxStmt)
-		a2 := nod(OAS, t, cmpr)
+		a2 := ir.Nod(ir.OAS, t, cmpr)
 		a2 = typecheck(a2, ctxStmt)
 		init.Append(a1, a2)
 	}
@@ -3446,39 +3447,39 @@ func walkcompare(n *Node, init *Nodes) *Node {
 	return n
 }
 
-func tracecmpArg(n *Node, t *types.Type, init *Nodes) *Node {
+func tracecmpArg(n *ir.Node, t *types.Type, init *ir.Nodes) *ir.Node {
 	// Ugly hack to avoid "constant -1 overflows uintptr" errors, etc.
-	if n.Op == OLITERAL && n.Type.IsSigned() && n.Int64Val() < 0 {
+	if n.Op == ir.OLITERAL && n.Type.IsSigned() && n.Int64Val() < 0 {
 		n = copyexpr(n, n.Type, init)
 	}
 
 	return conv(n, t)
 }
 
-func walkcompareInterface(n *Node, init *Nodes) *Node {
+func walkcompareInterface(n *ir.Node, init *ir.Nodes) *ir.Node {
 	n.Right = cheapexpr(n.Right, init)
 	n.Left = cheapexpr(n.Left, init)
 	eqtab, eqdata := eqinterface(n.Left, n.Right)
-	var cmp *Node
-	if n.Op == OEQ {
-		cmp = nod(OANDAND, eqtab, eqdata)
+	var cmp *ir.Node
+	if n.Op == ir.OEQ {
+		cmp = ir.Nod(ir.OANDAND, eqtab, eqdata)
 	} else {
-		eqtab.Op = ONE
-		cmp = nod(OOROR, eqtab, nod(ONOT, eqdata, nil))
+		eqtab.Op = ir.ONE
+		cmp = ir.Nod(ir.OOROR, eqtab, ir.Nod(ir.ONOT, eqdata, nil))
 	}
 	return finishcompare(n, cmp, init)
 }
 
-func walkcompareString(n *Node, init *Nodes) *Node {
+func walkcompareString(n *ir.Node, init *ir.Nodes) *ir.Node {
 	// Rewrite comparisons to short constant strings as length+byte-wise comparisons.
-	var cs, ncs *Node // const string, non-const string
+	var cs, ncs *ir.Node // const string, non-const string
 	switch {
-	case Isconst(n.Left, constant.String) && Isconst(n.Right, constant.String):
+	case ir.IsConst(n.Left, constant.String) && ir.IsConst(n.Right, constant.String):
 		// ignore; will be constant evaluated
-	case Isconst(n.Left, constant.String):
+	case ir.IsConst(n.Left, constant.String):
 		cs = n.Left
 		ncs = n.Right
-	case Isconst(n.Right, constant.String):
+	case ir.IsConst(n.Right, constant.String):
 		cs = n.Right
 		ncs = n.Left
 	}
@@ -3487,7 +3488,7 @@ func walkcompareString(n *Node, init *Nodes) *Node {
 		// Our comparison below assumes that the non-constant string
 		// is on the left hand side, so rewrite "" cmp x to x cmp "".
 		// See issue 24817.
-		if Isconst(n.Left, constant.String) {
+		if ir.IsConst(n.Left, constant.String) {
 			cmp = brrev(cmp)
 		}
 
@@ -3506,12 +3507,12 @@ func walkcompareString(n *Node, init *Nodes) *Node {
 			combine64bit = thearch.LinkArch.RegSize >= 8
 		}
 
-		var and Op
+		var and ir.Op
 		switch cmp {
-		case OEQ:
-			and = OANDAND
-		case ONE:
-			and = OOROR
+		case ir.OEQ:
+			and = ir.OANDAND
+		case ir.ONE:
+			and = ir.OOROR
 		default:
 			// Don't do byte-wise comparisons for <, <=, etc.
 			// They're fairly complicated.
@@ -3522,13 +3523,13 @@ func walkcompareString(n *Node, init *Nodes) *Node {
 			if len(s) > 0 {
 				ncs = safeexpr(ncs, init)
 			}
-			r := nod(cmp, nod(OLEN, ncs, nil), nodintconst(int64(len(s))))
+			r := ir.Nod(cmp, ir.Nod(ir.OLEN, ncs, nil), nodintconst(int64(len(s))))
 			remains := len(s)
 			for i := 0; remains > 0; {
 				if remains == 1 || !canCombineLoads {
 					cb := nodintconst(int64(s[i]))
-					ncb := nod(OINDEX, ncs, nodintconst(int64(i)))
-					r = nod(and, r, nod(cmp, ncb, cb))
+					ncb := ir.Nod(ir.OINDEX, ncs, nodintconst(int64(i)))
+					r = ir.Nod(and, r, ir.Nod(cmp, ncb, cb))
 					remains--
 					i++
 					continue
@@ -3537,31 +3538,31 @@ func walkcompareString(n *Node, init *Nodes) *Node {
 				var convType *types.Type
 				switch {
 				case remains >= 8 && combine64bit:
-					convType = types.Types[TINT64]
+					convType = types.Types[types.TINT64]
 					step = 8
 				case remains >= 4:
-					convType = types.Types[TUINT32]
+					convType = types.Types[types.TUINT32]
 					step = 4
 				case remains >= 2:
-					convType = types.Types[TUINT16]
+					convType = types.Types[types.TUINT16]
 					step = 2
 				}
-				ncsubstr := nod(OINDEX, ncs, nodintconst(int64(i)))
+				ncsubstr := ir.Nod(ir.OINDEX, ncs, nodintconst(int64(i)))
 				ncsubstr = conv(ncsubstr, convType)
 				csubstr := int64(s[i])
 				// Calculate large constant from bytes as sequence of shifts and ors.
 				// Like this:  uint32(s[0]) | uint32(s[1])<<8 | uint32(s[2])<<16 ...
 				// ssa will combine this into a single large load.
 				for offset := 1; offset < step; offset++ {
-					b := nod(OINDEX, ncs, nodintconst(int64(i+offset)))
+					b := ir.Nod(ir.OINDEX, ncs, nodintconst(int64(i+offset)))
 					b = conv(b, convType)
-					b = nod(OLSH, b, nodintconst(int64(8*offset)))
-					ncsubstr = nod(OOR, ncsubstr, b)
+					b = ir.Nod(ir.OLSH, b, nodintconst(int64(8*offset)))
+					ncsubstr = ir.Nod(ir.OOR, ncsubstr, b)
 					csubstr |= int64(s[i+offset]) << uint8(8*offset)
 				}
 				csubstrPart := nodintconst(csubstr)
 				// Compare "step" bytes as once
-				r = nod(and, r, nod(cmp, csubstrPart, ncsubstr))
+				r = ir.Nod(and, r, ir.Nod(cmp, csubstrPart, ncsubstr))
 				remains -= step
 				i += step
 			}
@@ -3569,26 +3570,26 @@ func walkcompareString(n *Node, init *Nodes) *Node {
 		}
 	}
 
-	var r *Node
-	if n.Op == OEQ || n.Op == ONE {
+	var r *ir.Node
+	if n.Op == ir.OEQ || n.Op == ir.ONE {
 		// prepare for rewrite below
 		n.Left = cheapexpr(n.Left, init)
 		n.Right = cheapexpr(n.Right, init)
 		eqlen, eqmem := eqstring(n.Left, n.Right)
 		// quick check of len before full compare for == or !=.
 		// memequal then tests equality up to length len.
-		if n.Op == OEQ {
+		if n.Op == ir.OEQ {
 			// len(left) == len(right) && memequal(left, right, len)
-			r = nod(OANDAND, eqlen, eqmem)
+			r = ir.Nod(ir.OANDAND, eqlen, eqmem)
 		} else {
 			// len(left) != len(right) || !memequal(left, right, len)
-			eqlen.Op = ONE
-			r = nod(OOROR, eqlen, nod(ONOT, eqmem, nil))
+			eqlen.Op = ir.ONE
+			r = ir.Nod(ir.OOROR, eqlen, ir.Nod(ir.ONOT, eqmem, nil))
 		}
 	} else {
 		// sys_cmpstring(s1, s2) :: 0
-		r = mkcall("cmpstring", types.Types[TINT], init, conv(n.Left, types.Types[TSTRING]), conv(n.Right, types.Types[TSTRING]))
-		r = nod(n.Op, r, nodintconst(0))
+		r = mkcall("cmpstring", types.Types[types.TINT], init, conv(n.Left, types.Types[types.TSTRING]), conv(n.Right, types.Types[types.TSTRING]))
+		r = ir.Nod(n.Op, r, nodintconst(0))
 	}
 
 	return finishcompare(n, r, init)
@@ -3596,7 +3597,7 @@ func walkcompareString(n *Node, init *Nodes) *Node {
 
 // The result of finishcompare MUST be assigned back to n, e.g.
 // 	n.Left = finishcompare(n.Left, x, r, init)
-func finishcompare(n, r *Node, init *Nodes) *Node {
+func finishcompare(n, r *ir.Node, init *ir.Nodes) *ir.Node {
 	r = typecheck(r, ctxExpr)
 	r = conv(r, n.Type)
 	r = walkexpr(r, init)
@@ -3604,7 +3605,7 @@ func finishcompare(n, r *Node, init *Nodes) *Node {
 }
 
 // return 1 if integer n must be in range [0, max), 0 otherwise
-func bounded(n *Node, max int64) bool {
+func bounded(n *ir.Node, max int64) bool {
 	if n.Type == nil || !n.Type.IsInteger() {
 		return false
 	}
@@ -3618,14 +3619,14 @@ func bounded(n *Node, max int64) bool {
 	}
 
 	switch n.Op {
-	case OAND, OANDNOT:
+	case ir.OAND, ir.OANDNOT:
 		v := int64(-1)
 		switch {
 		case smallintconst(n.Left):
 			v = n.Left.Int64Val()
 		case smallintconst(n.Right):
 			v = n.Right.Int64Val()
-			if n.Op == OANDNOT {
+			if n.Op == ir.OANDNOT {
 				v = ^v
 				if !sign {
 					v &= 1<<uint(bits) - 1
@@ -3636,7 +3637,7 @@ func bounded(n *Node, max int64) bool {
 			return true
 		}
 
-	case OMOD:
+	case ir.OMOD:
 		if !sign && smallintconst(n.Right) {
 			v := n.Right.Int64Val()
 			if 0 <= v && v <= max {
@@ -3644,7 +3645,7 @@ func bounded(n *Node, max int64) bool {
 			}
 		}
 
-	case ODIV:
+	case ir.ODIV:
 		if !sign && smallintconst(n.Right) {
 			v := n.Right.Int64Val()
 			for bits > 0 && v >= 2 {
@@ -3653,7 +3654,7 @@ func bounded(n *Node, max int64) bool {
 			}
 		}
 
-	case ORSH:
+	case ir.ORSH:
 		if !sign && smallintconst(n.Right) {
 			v := n.Right.Int64Val()
 			if v > int64(bits) {
@@ -3671,7 +3672,7 @@ func bounded(n *Node, max int64) bool {
 }
 
 // usemethod checks interface method calls for uses of reflect.Type.Method.
-func usemethod(n *Node) {
+func usemethod(n *ir.Node) {
 	t := n.Left.Type
 
 	// Looking for either of:
@@ -3694,7 +3695,7 @@ func usemethod(n *Node) {
 	}
 
 	if res1 == nil {
-		if p0.Type.Etype != TINT {
+		if p0.Type.Etype != types.TINT {
 			return
 		}
 	} else {
@@ -3712,11 +3713,11 @@ func usemethod(n *Node) {
 	if s := res0.Type.Sym; s != nil && s.Name == "Method" && isReflectPkg(s.Pkg) {
 		Curfn.Func.SetReflectMethod(true)
 		// The LSym is initialized at this point. We need to set the attribute on the LSym.
-		Curfn.Func.lsym.Set(obj.AttrReflectMethod, true)
+		Curfn.Func.LSym.Set(obj.AttrReflectMethod, true)
 	}
 }
 
-func usefield(n *Node) {
+func usefield(n *ir.Node) {
 	if objabi.Fieldtrack_enabled == 0 {
 		return
 	}
@@ -3725,7 +3726,7 @@ func usefield(n *Node) {
 	default:
 		base.Fatalf("usefield %v", n.Op)
 
-	case ODOT, ODOTPTR:
+	case ir.ODOT, ir.ODOTPTR:
 		break
 	}
 	if n.Sym == nil {
@@ -3767,7 +3768,7 @@ func usefield(n *Node) {
 	Curfn.Func.FieldTrack[sym] = struct{}{}
 }
 
-func candiscardlist(l Nodes) bool {
+func candiscardlist(l ir.Nodes) bool {
 	for _, n := range l.Slice() {
 		if !candiscard(n) {
 			return false
@@ -3776,7 +3777,7 @@ func candiscardlist(l Nodes) bool {
 	return true
 }
 
-func candiscard(n *Node) bool {
+func candiscard(n *ir.Node) bool {
 	if n == nil {
 		return true
 	}
@@ -3786,80 +3787,80 @@ func candiscard(n *Node) bool {
 		return false
 
 		// Discardable as long as the subpieces are.
-	case ONAME,
-		ONONAME,
-		OTYPE,
-		OPACK,
-		OLITERAL,
-		ONIL,
-		OADD,
-		OSUB,
-		OOR,
-		OXOR,
-		OADDSTR,
-		OADDR,
-		OANDAND,
-		OBYTES2STR,
-		ORUNES2STR,
-		OSTR2BYTES,
-		OSTR2RUNES,
-		OCAP,
-		OCOMPLIT,
-		OMAPLIT,
-		OSTRUCTLIT,
-		OARRAYLIT,
-		OSLICELIT,
-		OPTRLIT,
-		OCONV,
-		OCONVIFACE,
-		OCONVNOP,
-		ODOT,
-		OEQ,
-		ONE,
-		OLT,
-		OLE,
-		OGT,
-		OGE,
-		OKEY,
-		OSTRUCTKEY,
-		OLEN,
-		OMUL,
-		OLSH,
-		ORSH,
-		OAND,
-		OANDNOT,
-		ONEW,
-		ONOT,
-		OBITNOT,
-		OPLUS,
-		ONEG,
-		OOROR,
-		OPAREN,
-		ORUNESTR,
-		OREAL,
-		OIMAG,
-		OCOMPLEX:
+	case ir.ONAME,
+		ir.ONONAME,
+		ir.OTYPE,
+		ir.OPACK,
+		ir.OLITERAL,
+		ir.ONIL,
+		ir.OADD,
+		ir.OSUB,
+		ir.OOR,
+		ir.OXOR,
+		ir.OADDSTR,
+		ir.OADDR,
+		ir.OANDAND,
+		ir.OBYTES2STR,
+		ir.ORUNES2STR,
+		ir.OSTR2BYTES,
+		ir.OSTR2RUNES,
+		ir.OCAP,
+		ir.OCOMPLIT,
+		ir.OMAPLIT,
+		ir.OSTRUCTLIT,
+		ir.OARRAYLIT,
+		ir.OSLICELIT,
+		ir.OPTRLIT,
+		ir.OCONV,
+		ir.OCONVIFACE,
+		ir.OCONVNOP,
+		ir.ODOT,
+		ir.OEQ,
+		ir.ONE,
+		ir.OLT,
+		ir.OLE,
+		ir.OGT,
+		ir.OGE,
+		ir.OKEY,
+		ir.OSTRUCTKEY,
+		ir.OLEN,
+		ir.OMUL,
+		ir.OLSH,
+		ir.ORSH,
+		ir.OAND,
+		ir.OANDNOT,
+		ir.ONEW,
+		ir.ONOT,
+		ir.OBITNOT,
+		ir.OPLUS,
+		ir.ONEG,
+		ir.OOROR,
+		ir.OPAREN,
+		ir.ORUNESTR,
+		ir.OREAL,
+		ir.OIMAG,
+		ir.OCOMPLEX:
 		break
 
 		// Discardable as long as we know it's not division by zero.
-	case ODIV, OMOD:
-		if n.Right.Op == OLITERAL && constant.Sign(n.Right.Val()) != 0 {
+	case ir.ODIV, ir.OMOD:
+		if n.Right.Op == ir.OLITERAL && constant.Sign(n.Right.Val()) != 0 {
 			break
 		}
 		return false
 
 		// Discardable as long as we know it won't fail because of a bad size.
-	case OMAKECHAN, OMAKEMAP:
-		if Isconst(n.Left, constant.Int) && constant.Sign(n.Left.Val()) == 0 {
+	case ir.OMAKECHAN, ir.OMAKEMAP:
+		if ir.IsConst(n.Left, constant.Int) && constant.Sign(n.Left.Val()) == 0 {
 			break
 		}
 		return false
 
 		// Difficult to tell what sizes are okay.
-	case OMAKESLICE:
+	case ir.OMAKESLICE:
 		return false
 
-	case OMAKESLICECOPY:
+	case ir.OMAKESLICECOPY:
 		return false
 	}
 
@@ -3890,29 +3891,29 @@ var wrapCall_prgen int
 
 // The result of wrapCall MUST be assigned back to n, e.g.
 // 	n.Left = wrapCall(n.Left, init)
-func wrapCall(n *Node, init *Nodes) *Node {
+func wrapCall(n *ir.Node, init *ir.Nodes) *ir.Node {
 	if n.Ninit.Len() != 0 {
 		walkstmtlist(n.Ninit.Slice())
 		init.AppendNodes(&n.Ninit)
 	}
 
-	isBuiltinCall := n.Op != OCALLFUNC && n.Op != OCALLMETH && n.Op != OCALLINTER
+	isBuiltinCall := n.Op != ir.OCALLFUNC && n.Op != ir.OCALLMETH && n.Op != ir.OCALLINTER
 
 	// Turn f(a, b, []T{c, d, e}...) back into f(a, b, c, d, e).
 	if !isBuiltinCall && n.IsDDD() {
 		last := n.List.Len() - 1
-		if va := n.List.Index(last); va.Op == OSLICELIT {
+		if va := n.List.Index(last); va.Op == ir.OSLICELIT {
 			n.List.Set(append(n.List.Slice()[:last], va.List.Slice()...))
 			n.SetIsDDD(false)
 		}
 	}
 
 	// origArgs keeps track of what argument is uintptr-unsafe/unsafe-uintptr conversion.
-	origArgs := make([]*Node, n.List.Len())
-	t := nod(OTFUNC, nil, nil)
+	origArgs := make([]*ir.Node, n.List.Len())
+	t := ir.Nod(ir.OTFUNC, nil, nil)
 	for i, arg := range n.List.Slice() {
 		s := lookupN("a", i)
-		if !isBuiltinCall && arg.Op == OCONVNOP && arg.Type.IsUintptr() && arg.Left.Type.IsUnsafePtr() {
+		if !isBuiltinCall && arg.Op == ir.OCONVNOP && arg.Type.IsUintptr() && arg.Left.Type.IsUnsafePtr() {
 			origArgs[i] = arg
 			arg = arg.Left
 			n.List.SetIndex(i, arg)
@@ -3929,13 +3930,13 @@ func wrapCall(n *Node, init *Nodes) *Node {
 		if origArg == nil {
 			continue
 		}
-		arg := nod(origArg.Op, args[i], nil)
+		arg := ir.Nod(origArg.Op, args[i], nil)
 		arg.Type = origArg.Type
 		args[i] = arg
 	}
-	call := nod(n.Op, nil, nil)
+	call := ir.Nod(n.Op, nil, nil)
 	if !isBuiltinCall {
-		call.Op = OCALL
+		call.Op = ir.OCALL
 		call.Left = n.Left
 		call.SetIsDDD(n.IsDDD())
 	}
@@ -3948,7 +3949,7 @@ func wrapCall(n *Node, init *Nodes) *Node {
 	typecheckslice(fn.Nbody.Slice(), ctxStmt)
 	xtop = append(xtop, fn)
 
-	call = nod(OCALL, nil, nil)
+	call = ir.Nod(ir.OCALL, nil, nil)
 	call.Left = fn.Func.Nname
 	call.List.Set(n.List.Slice())
 	call = typecheck(call, ctxStmt)
@@ -3961,8 +3962,8 @@ func wrapCall(n *Node, init *Nodes) *Node {
 // type syntax expression n.Type.
 // The result of substArgTypes MUST be assigned back to old, e.g.
 // 	n.Left = substArgTypes(n.Left, t1, t2)
-func substArgTypes(old *Node, types_ ...*types.Type) *Node {
-	n := old.copy()
+func substArgTypes(old *ir.Node, types_ ...*types.Type) *ir.Node {
+	n := ir.Copy(old)
 
 	for _, t := range types_ {
 		dowidth(t)
@@ -3991,11 +3992,11 @@ func canMergeLoads() bool {
 
 // isRuneCount reports whether n is of the form len([]rune(string)).
 // These are optimized into a call to runtime.countrunes.
-func isRuneCount(n *Node) bool {
-	return base.Flag.N == 0 && !instrumenting && n.Op == OLEN && n.Left.Op == OSTR2RUNES
+func isRuneCount(n *ir.Node) bool {
+	return base.Flag.N == 0 && !instrumenting && n.Op == ir.OLEN && n.Left.Op == ir.OSTR2RUNES
 }
 
-func walkCheckPtrAlignment(n *Node, init *Nodes, count *Node) *Node {
+func walkCheckPtrAlignment(n *ir.Node, init *ir.Nodes, count *ir.Node) *ir.Node {
 	if !n.Type.IsPtr() {
 		base.Fatalf("expected pointer type: %v", n.Type)
 	}
@@ -4017,13 +4018,13 @@ func walkCheckPtrAlignment(n *Node, init *Nodes, count *Node) *Node {
 	}
 
 	n.Left = cheapexpr(n.Left, init)
-	init.Append(mkcall("checkptrAlignment", nil, init, convnop(n.Left, types.Types[TUNSAFEPTR]), typename(elem), conv(count, types.Types[TUINTPTR])))
+	init.Append(mkcall("checkptrAlignment", nil, init, convnop(n.Left, types.Types[types.TUNSAFEPTR]), typename(elem), conv(count, types.Types[types.TUINTPTR])))
 	return n
 }
 
 var walkCheckPtrArithmeticMarker byte
 
-func walkCheckPtrArithmetic(n *Node, init *Nodes) *Node {
+func walkCheckPtrArithmetic(n *ir.Node, init *ir.Nodes) *ir.Node {
 	// Calling cheapexpr(n, init) below leads to a recursive call
 	// to walkexpr, which leads us back here again. Use n.Opt to
 	// prevent infinite loops.
@@ -4040,11 +4041,11 @@ func walkCheckPtrArithmetic(n *Node, init *Nodes) *Node {
 	// TODO(mdempsky): Make stricter. We only need to exempt
 	// reflect.Value.Pointer and reflect.Value.UnsafeAddr.
 	switch n.Left.Op {
-	case OCALLFUNC, OCALLMETH, OCALLINTER:
+	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
 		return n
 	}
 
-	if n.Left.Op == ODOTPTR && isReflectHeaderDataField(n.Left) {
+	if n.Left.Op == ir.ODOTPTR && isReflectHeaderDataField(n.Left) {
 		return n
 	}
 
@@ -4054,19 +4055,19 @@ func walkCheckPtrArithmetic(n *Node, init *Nodes) *Node {
 	// "It is valid both to add and to subtract offsets from a
 	// pointer in this way. It is also valid to use &^ to round
 	// pointers, usually for alignment."
-	var originals []*Node
-	var walk func(n *Node)
-	walk = func(n *Node) {
+	var originals []*ir.Node
+	var walk func(n *ir.Node)
+	walk = func(n *ir.Node) {
 		switch n.Op {
-		case OADD:
+		case ir.OADD:
 			walk(n.Left)
 			walk(n.Right)
-		case OSUB, OANDNOT:
+		case ir.OSUB, ir.OANDNOT:
 			walk(n.Left)
-		case OCONVNOP:
+		case ir.OCONVNOP:
 			if n.Left.Type.IsUnsafePtr() {
 				n.Left = cheapexpr(n.Left, init)
-				originals = append(originals, convnop(n.Left, types.Types[TUNSAFEPTR]))
+				originals = append(originals, convnop(n.Left, types.Types[types.TUNSAFEPTR]))
 			}
 		}
 	}
@@ -4074,10 +4075,10 @@ func walkCheckPtrArithmetic(n *Node, init *Nodes) *Node {
 
 	n = cheapexpr(n, init)
 
-	slice := mkdotargslice(types.NewSlice(types.Types[TUNSAFEPTR]), originals)
+	slice := mkdotargslice(types.NewSlice(types.Types[types.TUNSAFEPTR]), originals)
 	slice.Esc = EscNone
 
-	init.Append(mkcall("checkptrArithmetic", nil, init, convnop(n, types.Types[TUNSAFEPTR]), slice))
+	init.Append(mkcall("checkptrArithmetic", nil, init, convnop(n, types.Types[types.TUNSAFEPTR]), slice))
 	// TODO(khr): Mark backing store of slice as dead. This will allow us to reuse
 	// the backing store for multiple calls to checkptrArithmetic.
 
@@ -4087,6 +4088,6 @@ func walkCheckPtrArithmetic(n *Node, init *Nodes) *Node {
 // checkPtr reports whether pointer checking should be enabled for
 // function fn at a given level. See debugHelpFooter for defined
 // levels.
-func checkPtr(fn *Node, level int) bool {
-	return base.Debug.Checkptr >= level && fn.Func.Pragma&NoCheckPtr == 0
+func checkPtr(fn *ir.Node, level int) bool {
+	return base.Debug.Checkptr >= level && fn.Func.Pragma&ir.NoCheckPtr == 0
 }
diff --git a/src/cmd/compile/internal/gc/bitset.go b/src/cmd/compile/internal/ir/bitset.go
similarity index 99%
rename from src/cmd/compile/internal/gc/bitset.go
rename to src/cmd/compile/internal/ir/bitset.go
index ed5eea0a11..29f136296f 100644
--- a/src/cmd/compile/internal/gc/bitset.go
+++ b/src/cmd/compile/internal/ir/bitset.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package ir
 
 type bitset8 uint8
 
diff --git a/src/cmd/compile/internal/gc/class_string.go b/src/cmd/compile/internal/ir/class_string.go
similarity index 98%
rename from src/cmd/compile/internal/gc/class_string.go
rename to src/cmd/compile/internal/ir/class_string.go
index a4084a7535..866bf1a6b5 100644
--- a/src/cmd/compile/internal/gc/class_string.go
+++ b/src/cmd/compile/internal/ir/class_string.go
@@ -1,6 +1,6 @@
 // Code generated by "stringer -type=Class"; DO NOT EDIT.
 
-package gc
+package ir
 
 import "strconv"
 
diff --git a/src/cmd/compile/internal/gc/dump.go b/src/cmd/compile/internal/ir/dump.go
similarity index 96%
rename from src/cmd/compile/internal/gc/dump.go
rename to src/cmd/compile/internal/ir/dump.go
index 56dc474465..9306366e8a 100644
--- a/src/cmd/compile/internal/gc/dump.go
+++ b/src/cmd/compile/internal/ir/dump.go
@@ -6,22 +6,23 @@
 // for debugging purposes. The code is customized for Node graphs
 // and may be used for an alternative view of the node structure.
 
-package gc
+package ir
 
 import (
-	"cmd/compile/internal/base"
-	"cmd/compile/internal/types"
-	"cmd/internal/src"
 	"fmt"
 	"io"
 	"os"
 	"reflect"
 	"regexp"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/types"
+	"cmd/internal/src"
 )
 
 // dump is like fdump but prints to stderr.
-func dump(root interface{}, filter string, depth int) {
-	fdump(os.Stderr, root, filter, depth)
+func DumpAny(root interface{}, filter string, depth int) {
+	FDumpAny(os.Stderr, root, filter, depth)
 }
 
 // fdump prints the structure of a rooted data structure
@@ -41,7 +42,7 @@ func dump(root interface{}, filter string, depth int) {
 // rather than their type; struct fields with zero values or
 // non-matching field names are omitted, and "…" means recursion
 // depth has been reached or struct fields have been omitted.
-func fdump(w io.Writer, root interface{}, filter string, depth int) {
+func FDumpAny(w io.Writer, root interface{}, filter string, depth int) {
 	if root == nil {
 		fmt.Fprintln(w, "nil")
 		return
@@ -151,7 +152,7 @@ func (p *dumper) dump(x reflect.Value, depth int) {
 		return
 
 	case *types.Node:
-		x = reflect.ValueOf(asNode(v))
+		x = reflect.ValueOf(AsNode(v))
 	}
 
 	switch x.Kind() {
diff --git a/src/cmd/compile/internal/gc/fmt.go b/src/cmd/compile/internal/ir/fmt.go
similarity index 87%
rename from src/cmd/compile/internal/gc/fmt.go
rename to src/cmd/compile/internal/ir/fmt.go
index 9248eb22aa..5dea0880fc 100644
--- a/src/cmd/compile/internal/gc/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -2,13 +2,10 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package ir
 
 import (
 	"bytes"
-	"cmd/compile/internal/base"
-	"cmd/compile/internal/types"
-	"cmd/internal/src"
 	"fmt"
 	"go/constant"
 	"io"
@@ -16,6 +13,10 @@ import (
 	"strings"
 	"sync"
 	"unicode/utf8"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/types"
+	"cmd/internal/src"
 )
 
 // A FmtFlag value is a set of flags (or 0).
@@ -98,7 +99,7 @@ func fmtFlag(s fmt.State, verb rune) FmtFlag {
 
 // *types.Sym, *types.Type, and *Node types use the flags below to set the format mode
 const (
-	FErr fmtMode = iota
+	FErr FmtMode = iota
 	FDbg
 	FTypeId
 	FTypeIdName // same as FTypeId, but use package name instead of prefix
@@ -131,7 +132,7 @@ const (
 //   %- v   type identifiers with package name instead of prefix (typesym, dcommontype, typehash)
 
 // update returns the results of applying f to mode.
-func (f FmtFlag) update(mode fmtMode) (FmtFlag, fmtMode) {
+func (f FmtFlag) update(mode FmtMode) (FmtFlag, FmtMode) {
 	switch {
 	case f&FmtSign != 0:
 		mode = FDbg
@@ -147,7 +148,7 @@ func (f FmtFlag) update(mode fmtMode) (FmtFlag, fmtMode) {
 	return f, mode
 }
 
-var goopnames = []string{
+var OpNames = []string{
 	OADDR:     "&",
 	OADD:      "+",
 	OADDSTR:   "+",
@@ -217,7 +218,7 @@ func (o Op) GoString() string {
 	return fmt.Sprintf("%#v", o)
 }
 
-func (o Op) format(s fmt.State, verb rune, mode fmtMode) {
+func (o Op) format(s fmt.State, verb rune, mode FmtMode) {
 	switch verb {
 	case 'v':
 		o.oconv(s, fmtFlag(s, verb), mode)
@@ -227,10 +228,10 @@ func (o Op) format(s fmt.State, verb rune, mode fmtMode) {
 	}
 }
 
-func (o Op) oconv(s fmt.State, flag FmtFlag, mode fmtMode) {
+func (o Op) oconv(s fmt.State, flag FmtFlag, mode FmtMode) {
 	if flag&FmtSharp != 0 || mode != FDbg {
-		if int(o) < len(goopnames) && goopnames[o] != "" {
-			fmt.Fprint(s, goopnames[o])
+		if int(o) < len(OpNames) && OpNames[o] != "" {
+			fmt.Fprint(s, OpNames[o])
 			return
 		}
 	}
@@ -239,66 +240,73 @@ func (o Op) oconv(s fmt.State, flag FmtFlag, mode fmtMode) {
 	fmt.Fprint(s, o.String())
 }
 
-type fmtMode int
+type FmtMode int
 
 type fmtNode struct {
 	x *Node
-	m fmtMode
+	m FmtMode
 }
 
 func (f *fmtNode) Format(s fmt.State, verb rune) { f.x.format(s, verb, f.m) }
 
 type fmtOp struct {
 	x Op
-	m fmtMode
+	m FmtMode
 }
 
 func (f *fmtOp) Format(s fmt.State, verb rune) { f.x.format(s, verb, f.m) }
 
 type fmtType struct {
 	x *types.Type
-	m fmtMode
+	m FmtMode
 }
 
 func (f *fmtType) Format(s fmt.State, verb rune) { typeFormat(f.x, s, verb, f.m) }
 
 type fmtSym struct {
 	x *types.Sym
-	m fmtMode
+	m FmtMode
 }
 
 func (f *fmtSym) Format(s fmt.State, verb rune) { symFormat(f.x, s, verb, f.m) }
 
 type fmtNodes struct {
 	x Nodes
-	m fmtMode
+	m FmtMode
 }
 
 func (f *fmtNodes) Format(s fmt.State, verb rune) { f.x.format(s, verb, f.m) }
 
-func (n *Node) Format(s fmt.State, verb rune) { n.format(s, verb, FErr) }
-func (o Op) Format(s fmt.State, verb rune)    { o.format(s, verb, FErr) }
+func (n *Node) Format(s fmt.State, verb rune) {
+	FmtNode(n, s, verb)
+}
+
+func FmtNode(n *Node, s fmt.State, verb rune) {
+	n.format(s, verb, FErr)
+}
+
+func (o Op) Format(s fmt.State, verb rune) { o.format(s, verb, FErr) }
 
 // func (t *types.Type) Format(s fmt.State, verb rune)     // in package types
 // func (y *types.Sym) Format(s fmt.State, verb rune)            // in package types  { y.format(s, verb, FErr) }
 func (n Nodes) Format(s fmt.State, verb rune) { n.format(s, verb, FErr) }
 
-func (m fmtMode) Fprintf(s fmt.State, format string, args ...interface{}) {
+func (m FmtMode) Fprintf(s fmt.State, format string, args ...interface{}) {
 	m.prepareArgs(args)
 	fmt.Fprintf(s, format, args...)
 }
 
-func (m fmtMode) Sprintf(format string, args ...interface{}) string {
+func (m FmtMode) Sprintf(format string, args ...interface{}) string {
 	m.prepareArgs(args)
 	return fmt.Sprintf(format, args...)
 }
 
-func (m fmtMode) Sprint(args ...interface{}) string {
+func (m FmtMode) Sprint(args ...interface{}) string {
 	m.prepareArgs(args)
 	return fmt.Sprint(args...)
 }
 
-func (m fmtMode) prepareArgs(args []interface{}) {
+func (m FmtMode) prepareArgs(args []interface{}) {
 	for i, arg := range args {
 		switch arg := arg.(type) {
 		case Op:
@@ -319,13 +327,13 @@ func (m fmtMode) prepareArgs(args []interface{}) {
 	}
 }
 
-func (n *Node) format(s fmt.State, verb rune, mode fmtMode) {
+func (n *Node) format(s fmt.State, verb rune, mode FmtMode) {
 	switch verb {
 	case 'v', 'S', 'L':
-		n.nconv(s, fmtFlag(s, verb), mode)
+		nconvFmt(n, s, fmtFlag(s, verb), mode)
 
 	case 'j':
-		n.jconv(s, fmtFlag(s, verb))
+		jconvFmt(n, s, fmtFlag(s, verb))
 
 	default:
 		fmt.Fprintf(s, "%%!%c(*Node=%p)", verb, n)
@@ -336,7 +344,7 @@ func (n *Node) format(s fmt.State, verb rune, mode fmtMode) {
 var EscFmt func(n *Node, short bool) string
 
 // *Node details
-func (n *Node) jconv(s fmt.State, flag FmtFlag) {
+func jconvFmt(n *Node, s fmt.State, flag FmtFlag) {
 	short := flag&FmtShort != 0
 
 	// Useful to see which nodes in an AST printout are actually identical
@@ -363,7 +371,7 @@ func (n *Node) jconv(s fmt.State, flag FmtFlag) {
 		fmt.Fprintf(s, " l(%s%d)", pfx, n.Pos.Line())
 	}
 
-	if !short && n.Xoffset != BADWIDTH {
+	if !short && n.Xoffset != types.BADWIDTH {
 		fmt.Fprintf(s, " x(%d)", n.Xoffset)
 	}
 
@@ -430,7 +438,7 @@ func (n *Node) jconv(s fmt.State, flag FmtFlag) {
 	}
 }
 
-func vconv(v constant.Value, flag FmtFlag) string {
+func FmtConst(v constant.Value, flag FmtFlag) string {
 	if flag&FmtSharp == 0 && v.Kind() == constant.Complex {
 		real, imag := constant.Real(v), constant.Imag(v)
 
@@ -473,17 +481,17 @@ s%^	........*\]%&~%g
 s%~	%%g
 */
 
-func symfmt(b *bytes.Buffer, s *types.Sym, flag FmtFlag, mode fmtMode) {
+func symfmt(b *bytes.Buffer, s *types.Sym, flag FmtFlag, mode FmtMode) {
 	if flag&FmtShort == 0 {
 		switch mode {
 		case FErr: // This is for the user
-			if s.Pkg == builtinpkg || s.Pkg == localpkg {
+			if s.Pkg == BuiltinPkg || s.Pkg == LocalPkg {
 				b.WriteString(s.Name)
 				return
 			}
 
 			// If the name was used by multiple packages, display the full path,
-			if s.Pkg.Name != "" && numImport[s.Pkg.Name] > 1 {
+			if s.Pkg.Name != "" && NumImport[s.Pkg.Name] > 1 {
 				fmt.Fprintf(b, "%q.%s", s.Pkg.Path, s.Name)
 				return
 			}
@@ -534,28 +542,28 @@ func symfmt(b *bytes.Buffer, s *types.Sym, flag FmtFlag, mode fmtMode) {
 	b.WriteString(s.Name)
 }
 
-var basicnames = []string{
-	TINT:        "int",
-	TUINT:       "uint",
-	TINT8:       "int8",
-	TUINT8:      "uint8",
-	TINT16:      "int16",
-	TUINT16:     "uint16",
-	TINT32:      "int32",
-	TUINT32:     "uint32",
-	TINT64:      "int64",
-	TUINT64:     "uint64",
-	TUINTPTR:    "uintptr",
-	TFLOAT32:    "float32",
-	TFLOAT64:    "float64",
-	TCOMPLEX64:  "complex64",
-	TCOMPLEX128: "complex128",
-	TBOOL:       "bool",
-	TANY:        "any",
-	TSTRING:     "string",
-	TNIL:        "nil",
-	TIDEAL:      "untyped number",
-	TBLANK:      "blank",
+var BasicTypeNames = []string{
+	types.TINT:        "int",
+	types.TUINT:       "uint",
+	types.TINT8:       "int8",
+	types.TUINT8:      "uint8",
+	types.TINT16:      "int16",
+	types.TUINT16:     "uint16",
+	types.TINT32:      "int32",
+	types.TUINT32:     "uint32",
+	types.TINT64:      "int64",
+	types.TUINT64:     "uint64",
+	types.TUINTPTR:    "uintptr",
+	types.TFLOAT32:    "float32",
+	types.TFLOAT64:    "float64",
+	types.TCOMPLEX64:  "complex64",
+	types.TCOMPLEX128: "complex128",
+	types.TBOOL:       "bool",
+	types.TANY:        "any",
+	types.TSTRING:     "string",
+	types.TNIL:        "nil",
+	types.TIDEAL:      "untyped number",
+	types.TBLANK:      "blank",
 }
 
 var fmtBufferPool = sync.Pool{
@@ -564,7 +572,7 @@ var fmtBufferPool = sync.Pool{
 	},
 }
 
-func tconv(t *types.Type, flag FmtFlag, mode fmtMode) string {
+func tconv(t *types.Type, flag FmtFlag, mode FmtMode) string {
 	buf := fmtBufferPool.Get().(*bytes.Buffer)
 	buf.Reset()
 	defer fmtBufferPool.Put(buf)
@@ -577,7 +585,7 @@ func tconv(t *types.Type, flag FmtFlag, mode fmtMode) string {
 // flag and mode control exactly what is printed.
 // Any types x that are already in the visited map get printed as @%d where %d=visited[x].
 // See #16897 before changing the implementation of tconv.
-func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode fmtMode, visited map[*types.Type]int) {
+func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode FmtMode, visited map[*types.Type]int) {
 	if off, ok := visited[t]; ok {
 		// We've seen this type before, so we're trying to print it recursively.
 		// Print a reference to it instead.
@@ -648,7 +656,7 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode fmtMode, visited
 				return
 			}
 
-			if t.Sym.Pkg == localpkg && t.Vargen != 0 {
+			if t.Sym.Pkg == LocalPkg && t.Vargen != 0 {
 				b.WriteString(mode.Sprintf("%v·%d", t.Sym, t.Vargen))
 				return
 			}
@@ -658,7 +666,7 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode fmtMode, visited
 		return
 	}
 
-	if int(t.Etype) < len(basicnames) && basicnames[t.Etype] != "" {
+	if int(t.Etype) < len(BasicTypeNames) && BasicTypeNames[t.Etype] != "" {
 		var name string
 		switch t {
 		case types.UntypedBool:
@@ -674,7 +682,7 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode fmtMode, visited
 		case types.UntypedComplex:
 			name = "untyped complex"
 		default:
-			name = basicnames[t.Etype]
+			name = BasicTypeNames[t.Etype]
 		}
 		b.WriteString(name)
 		return
@@ -701,7 +709,7 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode fmtMode, visited
 	defer delete(visited, t)
 
 	switch t.Etype {
-	case TPTR:
+	case types.TPTR:
 		b.WriteByte('*')
 		switch mode {
 		case FTypeId, FTypeIdName:
@@ -712,17 +720,17 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode fmtMode, visited
 		}
 		tconv2(b, t.Elem(), 0, mode, visited)
 
-	case TARRAY:
+	case types.TARRAY:
 		b.WriteByte('[')
 		b.WriteString(strconv.FormatInt(t.NumElem(), 10))
 		b.WriteByte(']')
 		tconv2(b, t.Elem(), 0, mode, visited)
 
-	case TSLICE:
+	case types.TSLICE:
 		b.WriteString("[]")
 		tconv2(b, t.Elem(), 0, mode, visited)
 
-	case TCHAN:
+	case types.TCHAN:
 		switch t.ChanDir() {
 		case types.Crecv:
 			b.WriteString("<-chan ")
@@ -741,13 +749,13 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode fmtMode, visited
 			}
 		}
 
-	case TMAP:
+	case types.TMAP:
 		b.WriteString("map[")
 		tconv2(b, t.Key(), 0, mode, visited)
 		b.WriteByte(']')
 		tconv2(b, t.Elem(), 0, mode, visited)
 
-	case TINTER:
+	case types.TINTER:
 		if t.IsEmptyInterface() {
 			b.WriteString("interface {}")
 			break
@@ -779,7 +787,7 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode fmtMode, visited
 		}
 		b.WriteByte('}')
 
-	case TFUNC:
+	case types.TFUNC:
 		if flag&FmtShort != 0 {
 			// no leading func
 		} else {
@@ -805,7 +813,7 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode fmtMode, visited
 			tconv2(b, t.Results(), 0, mode, visited)
 		}
 
-	case TSTRUCT:
+	case types.TSTRUCT:
 		if m := t.StructType().Map; m != nil {
 			mt := m.MapType()
 			// Format the bucket struct for map[x]y as map.bucket[x]y.
@@ -856,17 +864,17 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode fmtMode, visited
 			b.WriteByte('}')
 		}
 
-	case TFORW:
+	case types.TFORW:
 		b.WriteString("undefined")
 		if t.Sym != nil {
 			b.WriteByte(' ')
 			sconv2(b, t.Sym, 0, mode)
 		}
 
-	case TUNSAFEPTR:
+	case types.TUNSAFEPTR:
 		b.WriteString("unsafe.Pointer")
 
-	case Txxx:
+	case types.Txxx:
 		b.WriteString("Txxx")
 	default:
 		// Don't know how to handle - fall back to detailed prints.
@@ -875,7 +883,7 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode fmtMode, visited
 }
 
 // Statements which may be rendered with a simplestmt as init.
-func stmtwithinit(op Op) bool {
+func StmtWithInit(op Op) bool {
 	switch op {
 	case OIF, OFOR, OFORUNTIL, OSWITCH:
 		return true
@@ -884,20 +892,20 @@ func stmtwithinit(op Op) bool {
 	return false
 }
 
-func (n *Node) stmtfmt(s fmt.State, mode fmtMode) {
+func stmtFmt(n *Node, s fmt.State, mode FmtMode) {
 	// some statements allow for an init, but at most one,
 	// but we may have an arbitrary number added, eg by typecheck
 	// and inlining. If it doesn't fit the syntax, emit an enclosing
 	// block starting with the init statements.
 
 	// if we can just say "for" n->ninit; ... then do so
-	simpleinit := n.Ninit.Len() == 1 && n.Ninit.First().Ninit.Len() == 0 && stmtwithinit(n.Op)
+	simpleinit := n.Ninit.Len() == 1 && n.Ninit.First().Ninit.Len() == 0 && StmtWithInit(n.Op)
 
 	// otherwise, print the inits as separate statements
 	complexinit := n.Ninit.Len() != 0 && !simpleinit && (mode != FErr)
 
 	// but if it was for if/for/switch, put in an extra surrounding block to limit the scope
-	extrablock := complexinit && stmtwithinit(n.Op)
+	extrablock := complexinit && StmtWithInit(n.Op)
 
 	if extrablock {
 		fmt.Fprint(s, "{")
@@ -1064,7 +1072,7 @@ func (n *Node) stmtfmt(s fmt.State, mode fmtMode) {
 	}
 }
 
-var opprec = []int{
+var OpPrec = []int{
 	OALIGNOF:       8,
 	OAPPEND:        8,
 	OBYTES2STR:     8,
@@ -1184,7 +1192,7 @@ var opprec = []int{
 	OEND: 0,
 }
 
-func (n *Node) exprfmt(s fmt.State, prec int, mode fmtMode) {
+func exprFmt(n *Node, s fmt.State, prec int, mode FmtMode) {
 	for n != nil && n.Implicit() && (n.Op == ODEREF || n.Op == OADDR) {
 		n = n.Left
 	}
@@ -1194,7 +1202,7 @@ func (n *Node) exprfmt(s fmt.State, prec int, mode fmtMode) {
 		return
 	}
 
-	nprec := opprec[n.Op]
+	nprec := OpPrec[n.Op]
 	if n.Op == OTYPE && n.Sym != nil {
 		nprec = 8
 	}
@@ -1214,7 +1222,7 @@ func (n *Node) exprfmt(s fmt.State, prec int, mode fmtMode) {
 	case OLITERAL: // this is a bit of a mess
 		if mode == FErr {
 			if n.Orig != nil && n.Orig != n {
-				n.Orig.exprfmt(s, prec, mode)
+				exprFmt(n.Orig, s, prec, mode)
 				return
 			}
 			if n.Sym != nil {
@@ -1252,7 +1260,7 @@ func (n *Node) exprfmt(s fmt.State, prec int, mode fmtMode) {
 				fmt.Fprintf(s, "'\\U%08x'", uint64(x))
 			}
 		} else {
-			fmt.Fprint(s, vconv(n.Val(), fmtFlag(s, 'v')))
+			fmt.Fprint(s, FmtConst(n.Val(), fmtFlag(s, 'v')))
 		}
 
 		if needUnparen {
@@ -1369,7 +1377,7 @@ func (n *Node) exprfmt(s fmt.State, prec int, mode fmtMode) {
 		mode.Fprintf(s, "%v:%v", n.Sym, n.Left)
 
 	case OCALLPART:
-		n.Left.exprfmt(s, nprec, mode)
+		exprFmt(n.Left, s, nprec, mode)
 		if n.Right == nil || n.Right.Sym == nil {
 			fmt.Fprint(s, ".<nil>")
 			return
@@ -1377,7 +1385,7 @@ func (n *Node) exprfmt(s fmt.State, prec int, mode fmtMode) {
 		mode.Fprintf(s, ".%0S", n.Right.Sym)
 
 	case OXDOT, ODOT, ODOTPTR, ODOTINTER, ODOTMETH:
-		n.Left.exprfmt(s, nprec, mode)
+		exprFmt(n.Left, s, nprec, mode)
 		if n.Sym == nil {
 			fmt.Fprint(s, ".<nil>")
 			return
@@ -1385,7 +1393,7 @@ func (n *Node) exprfmt(s fmt.State, prec int, mode fmtMode) {
 		mode.Fprintf(s, ".%0S", n.Sym)
 
 	case ODOTTYPE, ODOTTYPE2:
-		n.Left.exprfmt(s, nprec, mode)
+		exprFmt(n.Left, s, nprec, mode)
 		if n.Right != nil {
 			mode.Fprintf(s, ".(%v)", n.Right)
 			return
@@ -1393,24 +1401,24 @@ func (n *Node) exprfmt(s fmt.State, prec int, mode fmtMode) {
 		mode.Fprintf(s, ".(%v)", n.Type)
 
 	case OINDEX, OINDEXMAP:
-		n.Left.exprfmt(s, nprec, mode)
+		exprFmt(n.Left, s, nprec, mode)
 		mode.Fprintf(s, "[%v]", n.Right)
 
 	case OSLICE, OSLICESTR, OSLICEARR, OSLICE3, OSLICE3ARR:
-		n.Left.exprfmt(s, nprec, mode)
+		exprFmt(n.Left, s, nprec, mode)
 		fmt.Fprint(s, "[")
 		low, high, max := n.SliceBounds()
 		if low != nil {
-			fmt.Fprint(s, low.modeString(mode))
+			fmt.Fprint(s, modeString(low, mode))
 		}
 		fmt.Fprint(s, ":")
 		if high != nil {
-			fmt.Fprint(s, high.modeString(mode))
+			fmt.Fprint(s, modeString(high, mode))
 		}
 		if n.Op.IsSlice3() {
 			fmt.Fprint(s, ":")
 			if max != nil {
-				fmt.Fprint(s, max.modeString(mode))
+				fmt.Fprint(s, modeString(max, mode))
 			}
 		}
 		fmt.Fprint(s, "]")
@@ -1474,7 +1482,7 @@ func (n *Node) exprfmt(s fmt.State, prec int, mode fmtMode) {
 		mode.Fprintf(s, "%#v(%.v)", n.Op, n.List)
 
 	case OCALL, OCALLFUNC, OCALLINTER, OCALLMETH, OGETG:
-		n.Left.exprfmt(s, nprec, mode)
+		exprFmt(n.Left, s, nprec, mode)
 		if n.IsDDD() {
 			mode.Fprintf(s, "(%.v...)", n.List)
 			return
@@ -1505,7 +1513,7 @@ func (n *Node) exprfmt(s fmt.State, prec int, mode fmtMode) {
 		if n.Left != nil && n.Left.Op == n.Op {
 			fmt.Fprint(s, " ")
 		}
-		n.Left.exprfmt(s, nprec+1, mode)
+		exprFmt(n.Left, s, nprec+1, mode)
 
 		// Binary
 	case OADD,
@@ -1528,16 +1536,16 @@ func (n *Node) exprfmt(s fmt.State, prec int, mode fmtMode) {
 		OSEND,
 		OSUB,
 		OXOR:
-		n.Left.exprfmt(s, nprec, mode)
+		exprFmt(n.Left, s, nprec, mode)
 		mode.Fprintf(s, " %#v ", n.Op)
-		n.Right.exprfmt(s, nprec+1, mode)
+		exprFmt(n.Right, s, nprec+1, mode)
 
 	case OADDSTR:
 		for i, n1 := range n.List.Slice() {
 			if i != 0 {
 				fmt.Fprint(s, " + ")
 			}
-			n1.exprfmt(s, nprec, mode)
+			exprFmt(n1, s, nprec, mode)
 		}
 	case ODDD:
 		mode.Fprintf(s, "...")
@@ -1546,7 +1554,7 @@ func (n *Node) exprfmt(s fmt.State, prec int, mode fmtMode) {
 	}
 }
 
-func (n *Node) nodefmt(s fmt.State, flag FmtFlag, mode fmtMode) {
+func nodeFmt(n *Node, s fmt.State, flag FmtFlag, mode FmtMode) {
 	t := n.Type
 
 	// We almost always want the original.
@@ -1556,7 +1564,7 @@ func (n *Node) nodefmt(s fmt.State, flag FmtFlag, mode fmtMode) {
 	}
 
 	if flag&FmtLong != 0 && t != nil {
-		if t.Etype == TNIL {
+		if t.Etype == types.TNIL {
 			fmt.Fprint(s, "nil")
 		} else if n.Op == ONAME && n.Name.AutoTemp() {
 			mode.Fprintf(s, "%v value", t)
@@ -1568,15 +1576,15 @@ func (n *Node) nodefmt(s fmt.State, flag FmtFlag, mode fmtMode) {
 
 	// TODO inlining produces expressions with ninits. we can't print these yet.
 
-	if opprec[n.Op] < 0 {
-		n.stmtfmt(s, mode)
+	if OpPrec[n.Op] < 0 {
+		stmtFmt(n, s, mode)
 		return
 	}
 
-	n.exprfmt(s, 0, mode)
+	exprFmt(n, s, 0, mode)
 }
 
-func (n *Node) nodedump(s fmt.State, flag FmtFlag, mode fmtMode) {
+func nodeDumpFmt(n *Node, s fmt.State, flag FmtFlag, mode FmtMode) {
 	recur := flag&FmtShort == 0
 
 	if recur {
@@ -1647,7 +1655,7 @@ func (n *Node) nodedump(s fmt.State, flag FmtFlag, mode fmtMode) {
 		if n.Op == ODCLFUNC && n.Func != nil && n.Func.Dcl != nil && len(n.Func.Dcl) != 0 {
 			indent(s)
 			// The dcls for a func or closure
-			mode.Fprintf(s, "%v-dcl%v", n.Op, asNodes(n.Func.Dcl))
+			mode.Fprintf(s, "%v-dcl%v", n.Op, AsNodes(n.Func.Dcl))
 		}
 		if n.List.Len() != 0 {
 			indent(s)
@@ -1667,7 +1675,7 @@ func (n *Node) nodedump(s fmt.State, flag FmtFlag, mode fmtMode) {
 }
 
 // "%S" suppresses qualifying with package
-func symFormat(s *types.Sym, f fmt.State, verb rune, mode fmtMode) {
+func symFormat(s *types.Sym, f fmt.State, verb rune, mode FmtMode) {
 	switch verb {
 	case 'v', 'S':
 		fmt.Fprint(f, sconv(s, fmtFlag(f, verb), mode))
@@ -1677,10 +1685,10 @@ func symFormat(s *types.Sym, f fmt.State, verb rune, mode fmtMode) {
 	}
 }
 
-func smodeString(s *types.Sym, mode fmtMode) string { return sconv(s, 0, mode) }
+func smodeString(s *types.Sym, mode FmtMode) string { return sconv(s, 0, mode) }
 
 // See #16897 before changing the implementation of sconv.
-func sconv(s *types.Sym, flag FmtFlag, mode fmtMode) string {
+func sconv(s *types.Sym, flag FmtFlag, mode FmtMode) string {
 	if flag&FmtLong != 0 {
 		panic("linksymfmt")
 	}
@@ -1701,7 +1709,7 @@ func sconv(s *types.Sym, flag FmtFlag, mode fmtMode) string {
 	return types.InternString(buf.Bytes())
 }
 
-func sconv2(b *bytes.Buffer, s *types.Sym, flag FmtFlag, mode fmtMode) {
+func sconv2(b *bytes.Buffer, s *types.Sym, flag FmtFlag, mode FmtMode) {
 	if flag&FmtLong != 0 {
 		panic("linksymfmt")
 	}
@@ -1718,7 +1726,7 @@ func sconv2(b *bytes.Buffer, s *types.Sym, flag FmtFlag, mode fmtMode) {
 	symfmt(b, s, flag, mode)
 }
 
-func fldconv(b *bytes.Buffer, f *types.Field, flag FmtFlag, mode fmtMode, visited map[*types.Type]int, funarg types.Funarg) {
+func fldconv(b *bytes.Buffer, f *types.Field, flag FmtFlag, mode FmtMode, visited map[*types.Type]int, funarg types.Funarg) {
 	if f == nil {
 		b.WriteString("<T>")
 		return
@@ -1734,12 +1742,12 @@ func fldconv(b *bytes.Buffer, f *types.Field, flag FmtFlag, mode fmtMode, visite
 
 		// Take the name from the original.
 		if mode == FErr {
-			s = origSym(s)
+			s = OrigSym(s)
 		}
 
 		if s != nil && f.Embedded == 0 {
 			if funarg != types.FunargNone {
-				name = asNode(f.Nname).modeString(mode)
+				name = modeString(AsNode(f.Nname), mode)
 			} else if flag&FmtLong != 0 {
 				name = mode.Sprintf("%0S", s)
 				if !types.IsExported(name) && flag&FmtUnsigned == 0 {
@@ -1775,7 +1783,7 @@ func fldconv(b *bytes.Buffer, f *types.Field, flag FmtFlag, mode fmtMode, visite
 
 // "%L"  print definition, not name
 // "%S"  omit 'func' and receiver from function types, short type names
-func typeFormat(t *types.Type, s fmt.State, verb rune, mode fmtMode) {
+func typeFormat(t *types.Type, s fmt.State, verb rune, mode FmtMode) {
 	switch verb {
 	case 'v', 'S', 'L':
 		fmt.Fprint(s, tconv(t, fmtFlag(s, verb), mode))
@@ -1784,12 +1792,12 @@ func typeFormat(t *types.Type, s fmt.State, verb rune, mode fmtMode) {
 	}
 }
 
-func (n *Node) String() string                 { return fmt.Sprint(n) }
-func (n *Node) modeString(mode fmtMode) string { return mode.Sprint(n) }
+func (n *Node) String() string                { return fmt.Sprint(n) }
+func modeString(n *Node, mode FmtMode) string { return mode.Sprint(n) }
 
 // "%L"  suffix with "(type %T)" where possible
 // "%+S" in debug mode, don't recurse, no multiline output
-func (n *Node) nconv(s fmt.State, flag FmtFlag, mode fmtMode) {
+func nconvFmt(n *Node, s fmt.State, flag FmtFlag, mode FmtMode) {
 	if n == nil {
 		fmt.Fprint(s, "<N>")
 		return
@@ -1799,11 +1807,11 @@ func (n *Node) nconv(s fmt.State, flag FmtFlag, mode fmtMode) {
 
 	switch mode {
 	case FErr:
-		n.nodefmt(s, flag, mode)
+		nodeFmt(n, s, flag, mode)
 
 	case FDbg:
 		dumpdepth++
-		n.nodedump(s, flag, mode)
+		nodeDumpFmt(n, s, flag, mode)
 		dumpdepth--
 
 	default:
@@ -1811,7 +1819,7 @@ func (n *Node) nconv(s fmt.State, flag FmtFlag, mode fmtMode) {
 	}
 }
 
-func (l Nodes) format(s fmt.State, verb rune, mode fmtMode) {
+func (l Nodes) format(s fmt.State, verb rune, mode FmtMode) {
 	switch verb {
 	case 'v':
 		l.hconv(s, fmtFlag(s, verb), mode)
@@ -1826,7 +1834,7 @@ func (n Nodes) String() string {
 }
 
 // Flags: all those of %N plus '.': separate with comma's instead of semicolons.
-func (l Nodes) hconv(s fmt.State, flag FmtFlag, mode fmtMode) {
+func (l Nodes) hconv(s fmt.State, flag FmtFlag, mode FmtMode) {
 	if l.Len() == 0 && mode == FDbg {
 		fmt.Fprint(s, "<nil>")
 		return
@@ -1841,18 +1849,18 @@ func (l Nodes) hconv(s fmt.State, flag FmtFlag, mode fmtMode) {
 	}
 
 	for i, n := range l.Slice() {
-		fmt.Fprint(s, n.modeString(mode))
+		fmt.Fprint(s, modeString(n, mode))
 		if i+1 < l.Len() {
 			fmt.Fprint(s, sep)
 		}
 	}
 }
 
-func dumplist(s string, l Nodes) {
+func DumpList(s string, l Nodes) {
 	fmt.Printf("%s%+v\n", s, l)
 }
 
-func fdumplist(w io.Writer, s string, l Nodes) {
+func FDumpList(w io.Writer, s string, l Nodes) {
 	fmt.Fprintf(w, "%s%+v\n", s, l)
 }
 
@@ -1877,3 +1885,30 @@ func ellipsisIf(b bool) string {
 	}
 	return ""
 }
+
+// numImport tracks how often a package with a given name is imported.
+// It is used to provide a better error message (by using the package
+// path to disambiguate) if a package that appears multiple times with
+// the same name appears in an error message.
+var NumImport = make(map[string]int)
+
+func InstallTypeFormats() {
+	types.Sconv = func(s *types.Sym, flag, mode int) string {
+		return sconv(s, FmtFlag(flag), FmtMode(mode))
+	}
+	types.Tconv = func(t *types.Type, flag, mode int) string {
+		return tconv(t, FmtFlag(flag), FmtMode(mode))
+	}
+	types.FormatSym = func(sym *types.Sym, s fmt.State, verb rune, mode int) {
+		symFormat(sym, s, verb, FmtMode(mode))
+	}
+	types.FormatType = func(t *types.Type, s fmt.State, verb rune, mode int) {
+		typeFormat(t, s, verb, FmtMode(mode))
+	}
+}
+
+// Line returns n's position as a string. If n has been inlined,
+// it uses the outermost position where n has been inlined.
+func Line(n *Node) string {
+	return base.FmtPos(n.Pos)
+}
diff --git a/src/cmd/compile/internal/ir/ir.go b/src/cmd/compile/internal/ir/ir.go
new file mode 100644
index 0000000000..ad7f692b07
--- /dev/null
+++ b/src/cmd/compile/internal/ir/ir.go
@@ -0,0 +1,12 @@
+// Copyright 2009 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 ir
+
+import "cmd/compile/internal/types"
+
+var LocalPkg *types.Pkg // package being compiled
+
+// builtinpkg is a fake package that declares the universe block.
+var BuiltinPkg *types.Pkg
diff --git a/src/cmd/compile/internal/gc/syntax.go b/src/cmd/compile/internal/ir/node.go
similarity index 82%
rename from src/cmd/compile/internal/gc/syntax.go
rename to src/cmd/compile/internal/ir/node.go
index 11671fc54a..e6ed178f49 100644
--- a/src/cmd/compile/internal/gc/syntax.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -4,17 +4,20 @@
 
 // “Abstract” syntax representation.
 
-package gc
+package ir
 
 import (
+	"go/constant"
+	"sort"
+	"strings"
+	"unsafe"
+
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
 	"cmd/internal/src"
-	"go/constant"
-	"sort"
 )
 
 // A Node is a single node in the syntax tree.
@@ -290,7 +293,7 @@ func (n *Node) SetVal(v constant.Value) {
 		base.Fatalf("have Opt")
 	}
 	if n.Op == OLITERAL {
-		assertRepresents(n.Type, v)
+		AssertValidTypeForConst(n.Type, v)
 	}
 	n.SetHasVal(true)
 	n.E = &v
@@ -333,7 +336,7 @@ func (n *Node) SetIota(x int64) {
 
 // mayBeShared reports whether n may occur in multiple places in the AST.
 // Extra care must be taken when mutating such a node.
-func (n *Node) mayBeShared() bool {
+func MayBeShared(n *Node) bool {
 	switch n.Op {
 	case ONAME, OLITERAL, ONIL, OTYPE:
 		return true
@@ -342,7 +345,7 @@ func (n *Node) mayBeShared() bool {
 }
 
 // funcname returns the name (without the package) of the function n.
-func (n *Node) funcname() string {
+func FuncName(n *Node) string {
 	if n == nil || n.Func == nil || n.Func.Nname == nil {
 		return "<nil>"
 	}
@@ -353,7 +356,7 @@ func (n *Node) funcname() string {
 // This differs from the compiler's internal convention where local functions lack a package
 // because the ultimate consumer of this is a human looking at an IDE; package is only empty
 // if the compilation package is actually the empty string.
-func (n *Node) pkgFuncName() string {
+func PkgFuncName(n *Node) string {
 	var s *types.Sym
 	if n == nil {
 		return "<nil>"
@@ -681,7 +684,7 @@ type Func struct {
 
 	FieldTrack map[*types.Sym]struct{}
 	DebugInfo  *ssa.FuncDebug
-	lsym       *obj.LSym
+	LSym       *obj.LSym
 
 	Inl *Inline
 
@@ -693,13 +696,13 @@ type Func struct {
 	Pragma PragmaFlag // go:xxx function annotations
 
 	flags      bitset16
-	numDefers  int // number of defer calls in the function
-	numReturns int // number of explicit returns in the function
+	NumDefers  int // number of defer calls in the function
+	NumReturns int // number of explicit returns in the function
 
 	// nwbrCalls records the LSyms of functions called by this
 	// function for go:nowritebarrierrec analysis. Only filled in
 	// if nowritebarrierrecCheck != nil.
-	nwbrCalls *[]nowritebarrierrecCallSym
+	NWBRCalls *[]SymAndPos
 }
 
 // An Inline holds fields used for function bodies that can be inlined.
@@ -764,7 +767,7 @@ func (f *Func) SetExportInline(b bool)             { f.flags.set(funcExportInlin
 func (f *Func) SetInstrumentBody(b bool)           { f.flags.set(funcInstrumentBody, b) }
 func (f *Func) SetOpenCodedDeferDisallowed(b bool) { f.flags.set(funcOpenCodedDeferDisallowed, b) }
 
-func (f *Func) setWBPos(pos src.XPos) {
+func (f *Func) SetWBPos(pos src.XPos) {
 	if base.Debug.WB != 0 {
 		base.WarnfAt(pos, "write barrier")
 	}
@@ -996,7 +999,7 @@ const (
 type Nodes struct{ slice *[]*Node }
 
 // asNodes returns a slice of *Node as a Nodes value.
-func asNodes(s []*Node) Nodes {
+func AsNodes(s []*Node) Nodes {
 	return Nodes{&s}
 }
 
@@ -1136,38 +1139,38 @@ func (n *Nodes) AppendNodes(n2 *Nodes) {
 
 // inspect invokes f on each node in an AST in depth-first order.
 // If f(n) returns false, inspect skips visiting n's children.
-func inspect(n *Node, f func(*Node) bool) {
+func Inspect(n *Node, f func(*Node) bool) {
 	if n == nil || !f(n) {
 		return
 	}
-	inspectList(n.Ninit, f)
-	inspect(n.Left, f)
-	inspect(n.Right, f)
-	inspectList(n.List, f)
-	inspectList(n.Nbody, f)
-	inspectList(n.Rlist, f)
+	InspectList(n.Ninit, f)
+	Inspect(n.Left, f)
+	Inspect(n.Right, f)
+	InspectList(n.List, f)
+	InspectList(n.Nbody, f)
+	InspectList(n.Rlist, f)
 }
 
-func inspectList(l Nodes, f func(*Node) bool) {
+func InspectList(l Nodes, f func(*Node) bool) {
 	for _, n := range l.Slice() {
-		inspect(n, f)
+		Inspect(n, f)
 	}
 }
 
 // nodeQueue is a FIFO queue of *Node. The zero value of nodeQueue is
 // a ready-to-use empty queue.
-type nodeQueue struct {
+type NodeQueue struct {
 	ring       []*Node
 	head, tail int
 }
 
 // empty reports whether q contains no Nodes.
-func (q *nodeQueue) empty() bool {
+func (q *NodeQueue) Empty() bool {
 	return q.head == q.tail
 }
 
 // pushRight appends n to the right of the queue.
-func (q *nodeQueue) pushRight(n *Node) {
+func (q *NodeQueue) PushRight(n *Node) {
 	if len(q.ring) == 0 {
 		q.ring = make([]*Node, 16)
 	} else if q.head+len(q.ring) == q.tail {
@@ -1191,8 +1194,8 @@ func (q *nodeQueue) pushRight(n *Node) {
 
 // popLeft pops a node from the left of the queue. It panics if q is
 // empty.
-func (q *nodeQueue) popLeft() *Node {
-	if q.empty() {
+func (q *NodeQueue) PopLeft() *Node {
+	if q.Empty() {
 		panic("dequeue empty")
 	}
 	n := q.ring[q.head%len(q.ring)]
@@ -1226,3 +1229,342 @@ func (s NodeSet) Sorted(less func(*Node, *Node) bool) []*Node {
 	sort.Slice(res, func(i, j int) bool { return less(res[i], res[j]) })
 	return res
 }
+
+func Nod(op Op, nleft, nright *Node) *Node {
+	return NodAt(base.Pos, op, nleft, nright)
+}
+
+func NodAt(pos src.XPos, op Op, nleft, nright *Node) *Node {
+	var n *Node
+	switch op {
+	case ODCLFUNC:
+		var x struct {
+			n Node
+			f Func
+		}
+		n = &x.n
+		n.Func = &x.f
+		n.Func.Decl = n
+	case ONAME:
+		base.Fatalf("use newname instead")
+	case OLABEL, OPACK:
+		var x struct {
+			n Node
+			m Name
+		}
+		n = &x.n
+		n.Name = &x.m
+	default:
+		n = new(Node)
+	}
+	n.Op = op
+	n.Left = nleft
+	n.Right = nright
+	n.Pos = pos
+	n.Xoffset = types.BADWIDTH
+	n.Orig = n
+	return n
+}
+
+// newnamel returns a new ONAME Node associated with symbol s at position pos.
+// The caller is responsible for setting n.Name.Curfn.
+func NewNameAt(pos src.XPos, s *types.Sym) *Node {
+	if s == nil {
+		base.Fatalf("newnamel nil")
+	}
+
+	var x struct {
+		n Node
+		m Name
+		p Param
+	}
+	n := &x.n
+	n.Name = &x.m
+	n.Name.Param = &x.p
+
+	n.Op = ONAME
+	n.Pos = pos
+	n.Orig = n
+
+	n.Sym = s
+	return n
+}
+
+// The Class of a variable/function describes the "storage class"
+// of a variable or function. During parsing, storage classes are
+// called declaration contexts.
+type Class uint8
+
+//go:generate stringer -type=Class
+const (
+	Pxxx      Class = iota // no class; used during ssa conversion to indicate pseudo-variables
+	PEXTERN                // global variables
+	PAUTO                  // local variables
+	PAUTOHEAP              // local variables or parameters moved to heap
+	PPARAM                 // input arguments
+	PPARAMOUT              // output results
+	PFUNC                  // global functions
+
+	// Careful: Class is stored in three bits in Node.flags.
+	_ = uint((1 << 3) - iota) // static assert for iota <= (1 << 3)
+)
+
+type PragmaFlag int16
+
+const (
+	// Func pragmas.
+	Nointerface    PragmaFlag = 1 << iota
+	Noescape                  // func parameters don't escape
+	Norace                    // func must not have race detector annotations
+	Nosplit                   // func should not execute on separate stack
+	Noinline                  // func should not be inlined
+	NoCheckPtr                // func should not be instrumented by checkptr
+	CgoUnsafeArgs             // treat a pointer to one arg as a pointer to them all
+	UintptrEscapes            // pointers converted to uintptr escape
+
+	// Runtime-only func pragmas.
+	// See ../../../../runtime/README.md for detailed descriptions.
+	Systemstack        // func must run on system stack
+	Nowritebarrier     // emit compiler error instead of write barrier
+	Nowritebarrierrec  // error on write barrier in this or recursive callees
+	Yeswritebarrierrec // cancels Nowritebarrierrec in this function and callees
+
+	// Runtime and cgo type pragmas
+	NotInHeap // values of this type must not be heap allocated
+
+	// Go command pragmas
+	GoBuildPragma
+)
+
+type SymAndPos struct {
+	Sym *obj.LSym // LSym of callee
+	Pos src.XPos  // line of call
+}
+
+func AsNode(n *types.Node) *Node { return (*Node)(unsafe.Pointer(n)) }
+
+func AsTypesNode(n *Node) *types.Node { return (*types.Node)(unsafe.Pointer(n)) }
+
+var BlankNode *Node
+
+// origSym returns the original symbol written by the user.
+func OrigSym(s *types.Sym) *types.Sym {
+	if s == nil {
+		return nil
+	}
+
+	if len(s.Name) > 1 && s.Name[0] == '~' {
+		switch s.Name[1] {
+		case 'r': // originally an unnamed result
+			return nil
+		case 'b': // originally the blank identifier _
+			// TODO(mdempsky): Does s.Pkg matter here?
+			return BlankNode.Sym
+		}
+		return s
+	}
+
+	if strings.HasPrefix(s.Name, ".anon") {
+		// originally an unnamed or _ name (see subr.go: structargs)
+		return nil
+	}
+
+	return s
+}
+
+// SliceBounds returns n's slice bounds: low, high, and max in expr[low:high:max].
+// n must be a slice expression. max is nil if n is a simple slice expression.
+func (n *Node) SliceBounds() (low, high, max *Node) {
+	if n.List.Len() == 0 {
+		return nil, nil, nil
+	}
+
+	switch n.Op {
+	case OSLICE, OSLICEARR, OSLICESTR:
+		s := n.List.Slice()
+		return s[0], s[1], nil
+	case OSLICE3, OSLICE3ARR:
+		s := n.List.Slice()
+		return s[0], s[1], s[2]
+	}
+	base.Fatalf("SliceBounds op %v: %v", n.Op, n)
+	return nil, nil, nil
+}
+
+// SetSliceBounds sets n's slice bounds, where n is a slice expression.
+// n must be a slice expression. If max is non-nil, n must be a full slice expression.
+func (n *Node) SetSliceBounds(low, high, max *Node) {
+	switch n.Op {
+	case OSLICE, OSLICEARR, OSLICESTR:
+		if max != nil {
+			base.Fatalf("SetSliceBounds %v given three bounds", n.Op)
+		}
+		s := n.List.Slice()
+		if s == nil {
+			if low == nil && high == nil {
+				return
+			}
+			n.List.Set2(low, high)
+			return
+		}
+		s[0] = low
+		s[1] = high
+		return
+	case OSLICE3, OSLICE3ARR:
+		s := n.List.Slice()
+		if s == nil {
+			if low == nil && high == nil && max == nil {
+				return
+			}
+			n.List.Set3(low, high, max)
+			return
+		}
+		s[0] = low
+		s[1] = high
+		s[2] = max
+		return
+	}
+	base.Fatalf("SetSliceBounds op %v: %v", n.Op, n)
+}
+
+// IsSlice3 reports whether o is a slice3 op (OSLICE3, OSLICE3ARR).
+// o must be a slicing op.
+func (o Op) IsSlice3() bool {
+	switch o {
+	case OSLICE, OSLICEARR, OSLICESTR:
+		return false
+	case OSLICE3, OSLICE3ARR:
+		return true
+	}
+	base.Fatalf("IsSlice3 op %v", o)
+	return false
+}
+
+func IsConst(n *Node, ct constant.Kind) bool {
+	return ConstType(n) == ct
+}
+
+// Int64Val returns n as an int64.
+// n must be an integer or rune constant.
+func (n *Node) Int64Val() int64 {
+	if !IsConst(n, constant.Int) {
+		base.Fatalf("Int64Val(%v)", n)
+	}
+	x, ok := constant.Int64Val(n.Val())
+	if !ok {
+		base.Fatalf("Int64Val(%v)", n)
+	}
+	return x
+}
+
+// CanInt64 reports whether it is safe to call Int64Val() on n.
+func (n *Node) CanInt64() bool {
+	if !IsConst(n, constant.Int) {
+		return false
+	}
+
+	// if the value inside n cannot be represented as an int64, the
+	// return value of Int64 is undefined
+	_, ok := constant.Int64Val(n.Val())
+	return ok
+}
+
+// Uint64Val returns n as an uint64.
+// n must be an integer or rune constant.
+func (n *Node) Uint64Val() uint64 {
+	if !IsConst(n, constant.Int) {
+		base.Fatalf("Uint64Val(%v)", n)
+	}
+	x, ok := constant.Uint64Val(n.Val())
+	if !ok {
+		base.Fatalf("Uint64Val(%v)", n)
+	}
+	return x
+}
+
+// BoolVal returns n as a bool.
+// n must be a boolean constant.
+func (n *Node) BoolVal() bool {
+	if !IsConst(n, constant.Bool) {
+		base.Fatalf("BoolVal(%v)", n)
+	}
+	return constant.BoolVal(n.Val())
+}
+
+// StringVal returns the value of a literal string Node as a string.
+// n must be a string constant.
+func (n *Node) StringVal() string {
+	if !IsConst(n, constant.String) {
+		base.Fatalf("StringVal(%v)", n)
+	}
+	return constant.StringVal(n.Val())
+}
+
+// rawcopy returns a shallow copy of n.
+// Note: copy or sepcopy (rather than rawcopy) is usually the
+//       correct choice (see comment with Node.copy, below).
+func (n *Node) RawCopy() *Node {
+	copy := *n
+	return &copy
+}
+
+// sepcopy returns a separate shallow copy of n, with the copy's
+// Orig pointing to itself.
+func SepCopy(n *Node) *Node {
+	copy := *n
+	copy.Orig = &copy
+	return &copy
+}
+
+// copy returns shallow copy of n and adjusts the copy's Orig if
+// necessary: In general, if n.Orig points to itself, the copy's
+// Orig should point to itself as well. Otherwise, if n is modified,
+// the copy's Orig node appears modified, too, and then doesn't
+// represent the original node anymore.
+// (This caused the wrong complit Op to be used when printing error
+// messages; see issues #26855, #27765).
+func Copy(n *Node) *Node {
+	copy := *n
+	if n.Orig == n {
+		copy.Orig = &copy
+	}
+	return &copy
+}
+
+// isNil reports whether n represents the universal untyped zero value "nil".
+func IsNil(n *Node) bool {
+	// Check n.Orig because constant propagation may produce typed nil constants,
+	// which don't exist in the Go spec.
+	return n.Orig.Op == ONIL
+}
+
+func IsBlank(n *Node) bool {
+	if n == nil {
+		return false
+	}
+	return n.Sym.IsBlank()
+}
+
+// IsMethod reports whether n is a method.
+// n must be a function or a method.
+func IsMethod(n *Node) bool {
+	return n.Type.Recv() != nil
+}
+
+func (n *Node) Typ() *types.Type {
+	return n.Type
+}
+
+func (n *Node) StorageClass() ssa.StorageClass {
+	switch n.Class() {
+	case PPARAM:
+		return ssa.ClassParam
+	case PPARAMOUT:
+		return ssa.ClassParamOut
+	case PAUTO:
+		return ssa.ClassAuto
+	default:
+		base.Fatalf("untranslatable storage class for %v: %s", n, n.Class())
+		return 0
+	}
+}
diff --git a/src/cmd/compile/internal/gc/op_string.go b/src/cmd/compile/internal/ir/op_string.go
similarity index 99%
rename from src/cmd/compile/internal/gc/op_string.go
rename to src/cmd/compile/internal/ir/op_string.go
index 16fd79e477..d0d3778357 100644
--- a/src/cmd/compile/internal/gc/op_string.go
+++ b/src/cmd/compile/internal/ir/op_string.go
@@ -1,6 +1,6 @@
 // Code generated by "stringer -type=Op -trimprefix=O"; DO NOT EDIT.
 
-package gc
+package ir
 
 import "strconv"
 
diff --git a/src/cmd/compile/internal/gc/sizeof_test.go b/src/cmd/compile/internal/ir/sizeof_test.go
similarity index 98%
rename from src/cmd/compile/internal/gc/sizeof_test.go
rename to src/cmd/compile/internal/ir/sizeof_test.go
index 2f2eba4c67..c5169b9092 100644
--- a/src/cmd/compile/internal/gc/sizeof_test.go
+++ b/src/cmd/compile/internal/ir/sizeof_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package ir
 
 import (
 	"reflect"
diff --git a/src/cmd/compile/internal/ir/val.go b/src/cmd/compile/internal/ir/val.go
new file mode 100644
index 0000000000..00b5bfd1ad
--- /dev/null
+++ b/src/cmd/compile/internal/ir/val.go
@@ -0,0 +1,120 @@
+// Copyright 2009 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 ir
+
+import (
+	"go/constant"
+	"math"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/types"
+)
+
+func ConstType(n *Node) constant.Kind {
+	if n == nil || n.Op != OLITERAL {
+		return constant.Unknown
+	}
+	return n.Val().Kind()
+}
+
+// ValueInterface returns the constant value stored in n as an interface{}.
+// It returns int64s for ints and runes, float64s for floats,
+// and complex128s for complex values.
+func ConstValue(n *Node) interface{} {
+	switch v := n.Val(); v.Kind() {
+	default:
+		base.Fatalf("unexpected constant: %v", v)
+		panic("unreachable")
+	case constant.Bool:
+		return constant.BoolVal(v)
+	case constant.String:
+		return constant.StringVal(v)
+	case constant.Int:
+		return Int64Val(n.Type, v)
+	case constant.Float:
+		return Float64Val(v)
+	case constant.Complex:
+		return complex(Float64Val(constant.Real(v)), Float64Val(constant.Imag(v)))
+	}
+}
+
+// int64Val returns v converted to int64.
+// Note: if t is uint64, very large values will be converted to negative int64.
+func Int64Val(t *types.Type, v constant.Value) int64 {
+	if t.IsUnsigned() {
+		if x, ok := constant.Uint64Val(v); ok {
+			return int64(x)
+		}
+	} else {
+		if x, ok := constant.Int64Val(v); ok {
+			return x
+		}
+	}
+	base.Fatalf("%v out of range for %v", v, t)
+	panic("unreachable")
+}
+
+func Float64Val(v constant.Value) float64 {
+	if x, _ := constant.Float64Val(v); !math.IsInf(x, 0) {
+		return x + 0 // avoid -0 (should not be needed, but be conservative)
+	}
+	base.Fatalf("bad float64 value: %v", v)
+	panic("unreachable")
+}
+
+func AssertValidTypeForConst(t *types.Type, v constant.Value) {
+	if !ValidTypeForConst(t, v) {
+		base.Fatalf("%v does not represent %v", t, v)
+	}
+}
+
+func ValidTypeForConst(t *types.Type, v constant.Value) bool {
+	switch v.Kind() {
+	case constant.Unknown:
+		return OKForConst[t.Etype]
+	case constant.Bool:
+		return t.IsBoolean()
+	case constant.String:
+		return t.IsString()
+	case constant.Int:
+		return t.IsInteger()
+	case constant.Float:
+		return t.IsFloat()
+	case constant.Complex:
+		return t.IsComplex()
+	}
+
+	base.Fatalf("unexpected constant kind: %v", v)
+	panic("unreachable")
+}
+
+// nodlit returns a new untyped constant with value v.
+func NewLiteral(v constant.Value) *Node {
+	n := Nod(OLITERAL, nil, nil)
+	if k := v.Kind(); k != constant.Unknown {
+		n.Type = idealType(k)
+		n.SetVal(v)
+	}
+	return n
+}
+
+func idealType(ct constant.Kind) *types.Type {
+	switch ct {
+	case constant.String:
+		return types.UntypedString
+	case constant.Bool:
+		return types.UntypedBool
+	case constant.Int:
+		return types.UntypedInt
+	case constant.Float:
+		return types.UntypedFloat
+	case constant.Complex:
+		return types.UntypedComplex
+	}
+	base.Fatalf("unexpected Ctype: %v", ct)
+	return nil
+}
+
+var OKForConst [types.NTYPE]bool
diff --git a/src/cmd/compile/internal/mips/ssa.go b/src/cmd/compile/internal/mips/ssa.go
index c37a2e0714..87e6f5b0c7 100644
--- a/src/cmd/compile/internal/mips/ssa.go
+++ b/src/cmd/compile/internal/mips/ssa.go
@@ -9,6 +9,7 @@ import (
 
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
@@ -288,7 +289,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		case *obj.LSym:
 			wantreg = "SB"
 			gc.AddAux(&p.From, v)
-		case *gc.Node:
+		case *ir.Node:
 			wantreg = "SP"
 			gc.AddAux(&p.From, v)
 		case nil:
diff --git a/src/cmd/compile/internal/mips64/ssa.go b/src/cmd/compile/internal/mips64/ssa.go
index a7c10d8869..ea22c488aa 100644
--- a/src/cmd/compile/internal/mips64/ssa.go
+++ b/src/cmd/compile/internal/mips64/ssa.go
@@ -9,6 +9,7 @@ import (
 
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
@@ -262,7 +263,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		case *obj.LSym:
 			wantreg = "SB"
 			gc.AddAux(&p.From, v)
-		case *gc.Node:
+		case *ir.Node:
 			wantreg = "SP"
 			gc.AddAux(&p.From, v)
 		case nil:
diff --git a/src/cmd/compile/internal/ppc64/ssa.go b/src/cmd/compile/internal/ppc64/ssa.go
index e3f0ee1a93..848f27af84 100644
--- a/src/cmd/compile/internal/ppc64/ssa.go
+++ b/src/cmd/compile/internal/ppc64/ssa.go
@@ -7,6 +7,7 @@ package ppc64
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
@@ -751,7 +752,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 				p.To.Reg = v.Reg()
 			}
 
-		case *obj.LSym, *gc.Node:
+		case *obj.LSym, *ir.Node:
 			p := s.Prog(ppc64.AMOVD)
 			p.From.Type = obj.TYPE_ADDR
 			p.From.Reg = v.Args[0].Reg()
diff --git a/src/cmd/compile/internal/riscv64/ssa.go b/src/cmd/compile/internal/riscv64/ssa.go
index 5a71b33c00..a3dc07fe03 100644
--- a/src/cmd/compile/internal/riscv64/ssa.go
+++ b/src/cmd/compile/internal/riscv64/ssa.go
@@ -7,6 +7,7 @@ package riscv64
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -323,7 +324,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		case *obj.LSym:
 			wantreg = "SB"
 			gc.AddAux(&p.From, v)
-		case *gc.Node:
+		case *ir.Node:
 			wantreg = "SP"
 			gc.AddAux(&p.From, v)
 		case nil:
diff --git a/src/cmd/compile/internal/wasm/ssa.go b/src/cmd/compile/internal/wasm/ssa.go
index 373dc431e5..1a8b5691ef 100644
--- a/src/cmd/compile/internal/wasm/ssa.go
+++ b/src/cmd/compile/internal/wasm/ssa.go
@@ -7,6 +7,7 @@ package wasm
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
@@ -236,7 +237,7 @@ func ssaGenValueOnStack(s *gc.SSAGenState, v *ssa.Value, extend bool) {
 		switch v.Aux.(type) {
 		case *obj.LSym:
 			gc.AddAux(&p.From, v)
-		case *gc.Node:
+		case *ir.Node:
 			p.From.Reg = v.Args[0].Reg()
 			gc.AddAux(&p.From, v)
 		default:
diff --git a/src/cmd/dist/buildtool.go b/src/cmd/dist/buildtool.go
index f8e1f2f951..839579349a 100644
--- a/src/cmd/dist/buildtool.go
+++ b/src/cmd/dist/buildtool.go
@@ -42,6 +42,7 @@ var bootstrapDirs = []string{
 	"cmd/compile/internal/arm",
 	"cmd/compile/internal/arm64",
 	"cmd/compile/internal/gc",
+	"cmd/compile/internal/ir",
 	"cmd/compile/internal/logopt",
 	"cmd/compile/internal/mips",
 	"cmd/compile/internal/mips64",
-- 
GitLab


From 2c25cd5ba7772a97ee63787e3986b6ec231e8c3d Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 24 Nov 2020 22:07:04 -0800
Subject: [PATCH 0070/2400] [dev.typeparams] cmd/compile/internal/types2: a
 type parameter is a valid type case in a type switch

Likewise for type assertions.

This is a port of https://golang.org/cl/273127 to dev.typeparams.

Updates #42758.

Change-Id: If93246371c3555e067b0043f0caefaac99101ebc
Reviewed-on: https://go-review.googlesource.com/c/go/+/273128
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/expr.go       | 20 +++--------
 .../internal/types2/fixedbugs/issue42758.go2  | 33 +++++++++++++++++++
 src/cmd/compile/internal/types2/stmt.go       | 17 +++-------
 3 files changed, 43 insertions(+), 27 deletions(-)
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue42758.go2

diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index e166e9926c..cb92143f93 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -1703,22 +1703,12 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 		if x.mode == invalid {
 			goto Error
 		}
-		var xtyp *Interface
-		var strict bool
-		switch t := optype(x.typ.Under()).(type) {
-		case *Interface:
-			xtyp = t
-		// Disabled for now. It is not clear what the right approach is
-		// here. Also, the implementation below is inconsistent because
-		// the underlying type of a type parameter is either itself or
-		// a sum type if the corresponding type bound contains a type list.
-		// case *TypeParam:
-		// 	xtyp = t.Bound()
-		// 	strict = true
-		default:
-			check.invalidOpf(x, "%s is not an interface type", x)
+		xtyp, _ := x.typ.Under().(*Interface)
+		if xtyp == nil {
+			check.errorf(x, "%s is not an interface type", x)
 			goto Error
 		}
+		check.ordinaryType(x.Pos(), xtyp)
 		// x.(type) expressions are encoded via TypeSwitchGuards
 		if e.Type == nil {
 			check.invalidASTf(e, "invalid use of AssertExpr")
@@ -1728,7 +1718,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 		if T == Typ[Invalid] {
 			goto Error
 		}
-		check.typeAssertion(posFor(x), x, xtyp, T, strict)
+		check.typeAssertion(posFor(x), x, xtyp, T, false)
 		x.mode = commaok
 		x.typ = T
 
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue42758.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue42758.go2
new file mode 100644
index 0000000000..698cb8a16b
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue42758.go2
@@ -0,0 +1,33 @@
+// Copyright 2020 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 p
+
+func _[T any](x interface{}){
+	switch x.(type) {
+	case T: // ok to use a type parameter
+	case int:
+	}
+
+	switch x.(type) {
+	case T:
+	case T /* ERROR duplicate case */ :
+	}
+}
+
+type constraint interface {
+	type int
+}
+
+func _[T constraint](x interface{}){
+	switch x.(type) {
+	case T: // ok to use a type parameter even if type list contains int
+	case int:
+	}
+}
+
+func _(x constraint /* ERROR contains type constraints */ ) {
+	switch x /* ERROR contains type constraints */ .(type) {
+	}
+}
diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go
index d88f65b15e..37aa3c7308 100644
--- a/src/cmd/compile/internal/types2/stmt.go
+++ b/src/cmd/compile/internal/types2/stmt.go
@@ -666,19 +666,12 @@ func (check *Checker) typeSwitchStmt(inner stmtContext, s *syntax.SwitchStmt, gu
 	if x.mode == invalid {
 		return
 	}
-	var xtyp *Interface
-	var strict bool
-	switch t := x.typ.Under().(type) {
-	case *Interface:
-		xtyp = t
-	// Disabled for now. See comment in the implementation of type assertions (expr.go).
-	// case *TypeParam:
-	// 	xtyp = t.Bound()
-	// 	strict = true
-	default:
-		check.errorf(&x, "%s is not an interface or generic type", &x)
+	xtyp, _ := x.typ.Under().(*Interface)
+	if xtyp == nil {
+		check.errorf(&x, "%s is not an interface type", &x)
 		return
 	}
+	check.ordinaryType(x.Pos(), xtyp)
 
 	check.multipleSwitchDefaults(s.Body)
 
@@ -691,7 +684,7 @@ func (check *Checker) typeSwitchStmt(inner stmtContext, s *syntax.SwitchStmt, gu
 		}
 		// Check each type in this type switch case.
 		cases := unpackExpr(clause.Cases)
-		T := check.caseTypes(&x, xtyp, cases, seen, strict)
+		T := check.caseTypes(&x, xtyp, cases, seen, false)
 		check.openScope(clause, "case")
 		// If lhs exists, declare a corresponding variable in the case-local scope.
 		if lhs != nil {
-- 
GitLab


From 048debb2246d17ecd19ccfd603e8544d5e7946a0 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 17 Nov 2020 21:47:56 -0500
Subject: [PATCH 0071/2400] =?UTF-8?q?[dev.regabi]=20cmd/compile:=20remove?=
 =?UTF-8?q?=20gc=20=E2=86=94=20ssa=20cycle=20hacks?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The cycle hacks existed because gc needed to import ssa
which need to know about gc.Node. But now that's ir.Node,
and there's no cycle anymore.

Don't know how much it matters but LocalSlot is now
one word shorter than before, because it holds a pointer
instead of an interface for the *Node. That won't last long.

Now that they're not necessary for interface satisfaction,
IsSynthetic and IsAutoTmp can move to top-level ir functions.

Change-Id: Ie511e93466cfa2b17d9a91afc4bd8d53fdb80453
Reviewed-on: https://go-review.googlesource.com/c/go/+/272931
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/fmtmap_test.go              |  2 --
 src/cmd/compile/internal/gc/order.go        | 10 +++----
 src/cmd/compile/internal/gc/pgen.go         | 16 +++++------
 src/cmd/compile/internal/gc/ssa.go          | 25 ++++++++--------
 src/cmd/compile/internal/gc/typecheck.go    |  2 +-
 src/cmd/compile/internal/ir/node.go         | 25 ++--------------
 src/cmd/compile/internal/ir/sizeof_test.go  |  2 +-
 src/cmd/compile/internal/ssa/config.go      | 21 ++------------
 src/cmd/compile/internal/ssa/deadstore.go   | 29 ++++++++++---------
 src/cmd/compile/internal/ssa/debug.go       | 21 +++++++-------
 src/cmd/compile/internal/ssa/export_test.go | 32 ++++-----------------
 src/cmd/compile/internal/ssa/location.go    |  3 +-
 src/cmd/compile/internal/ssa/nilcheck.go    |  3 +-
 src/cmd/compile/internal/ssa/regalloc.go    |  3 +-
 src/cmd/compile/internal/ssa/sizeof_test.go |  2 +-
 src/cmd/compile/internal/ssa/stackalloc.go  |  3 +-
 16 files changed, 73 insertions(+), 126 deletions(-)

diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
index 404e89d0f2..432d26a7b8 100644
--- a/src/cmd/compile/fmtmap_test.go
+++ b/src/cmd/compile/fmtmap_test.go
@@ -81,7 +81,6 @@ var knownFormats = map[string]string{
 	"cmd/compile/internal/gc.initKind %d":             "",
 	"cmd/compile/internal/gc.itag %v":                 "",
 	"cmd/compile/internal/ir.Class %d":                "",
-	"cmd/compile/internal/ir.Class %s":                "",
 	"cmd/compile/internal/ir.Class %v":                "",
 	"cmd/compile/internal/ir.FmtMode %d":              "",
 	"cmd/compile/internal/ir.Nodes %#v":               "",
@@ -92,7 +91,6 @@ var knownFormats = map[string]string{
 	"cmd/compile/internal/ir.Op %v":                   "",
 	"cmd/compile/internal/ssa.BranchPrediction %d":    "",
 	"cmd/compile/internal/ssa.Edge %v":                "",
-	"cmd/compile/internal/ssa.GCNode %v":              "",
 	"cmd/compile/internal/ssa.ID %d":                  "",
 	"cmd/compile/internal/ssa.ID %v":                  "",
 	"cmd/compile/internal/ssa.LocalSlot %s":           "",
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 25bdbd5a41..3bd49e8094 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -195,7 +195,7 @@ func (o *Order) safeExpr(n *ir.Node) *ir.Node {
 // because we emit explicit VARKILL instructions marking the end of those
 // temporaries' lifetimes.
 func isaddrokay(n *ir.Node) bool {
-	return islvalue(n) && (n.Op != ir.ONAME || n.Class() == ir.PEXTERN || n.IsAutoTmp())
+	return islvalue(n) && (n.Op != ir.ONAME || n.Class() == ir.PEXTERN || ir.IsAutoTmp(n))
 }
 
 // addrTemp ensures that n is okay to pass by address to runtime routines.
@@ -550,10 +550,10 @@ func (o *Order) mapAssign(n *ir.Node) {
 		for i, m := range n.List.Slice() {
 			switch {
 			case m.Op == ir.OINDEXMAP:
-				if !m.Left.IsAutoTmp() {
+				if !ir.IsAutoTmp(m.Left) {
 					m.Left = o.copyExpr(m.Left, m.Left.Type, false)
 				}
-				if !m.Right.IsAutoTmp() {
+				if !ir.IsAutoTmp(m.Right) {
 					m.Right = o.copyExpr(m.Right, m.Right.Type, false)
 				}
 				fallthrough
@@ -952,11 +952,11 @@ func (o *Order) stmt(n *ir.Node) {
 				// r->left is c, r->right is x, both are always evaluated.
 				r.Left = o.expr(r.Left, nil)
 
-				if !r.Left.IsAutoTmp() {
+				if !ir.IsAutoTmp(r.Left) {
 					r.Left = o.copyExpr(r.Left, r.Left.Type, false)
 				}
 				r.Right = o.expr(r.Right, nil)
-				if !r.Right.IsAutoTmp() {
+				if !ir.IsAutoTmp(r.Right) {
 					r.Right = o.copyExpr(r.Right, r.Right.Type, false)
 				}
 			}
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index 38f416c1c3..6e7922ca54 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -121,7 +121,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 
 	for _, l := range f.RegAlloc {
 		if ls, ok := l.(ssa.LocalSlot); ok {
-			ls.N.(*ir.Node).Name.SetUsed(true)
+			ls.N.Name.SetUsed(true)
 		}
 	}
 
@@ -517,7 +517,7 @@ func createSimpleVars(fnsym *obj.LSym, apDecls []*ir.Node) ([]*ir.Node, []*dwarf
 	var decls []*ir.Node
 	selected := make(map[*ir.Node]bool)
 	for _, n := range apDecls {
-		if n.IsAutoTmp() {
+		if ir.IsAutoTmp(n) {
 			continue
 		}
 
@@ -580,7 +580,7 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Node) *dwarf.Var {
 // createComplexVars creates recomposed DWARF vars with location lists,
 // suitable for describing optimized code.
 func createComplexVars(fnsym *obj.LSym, fn *ir.Func) ([]*ir.Node, []*dwarf.Var, map[*ir.Node]bool) {
-	debugInfo := fn.DebugInfo
+	debugInfo := fn.DebugInfo.(*ssa.FuncDebug)
 
 	// Produce a DWARF variable entry for each user variable.
 	var decls []*ir.Node
@@ -588,10 +588,10 @@ func createComplexVars(fnsym *obj.LSym, fn *ir.Func) ([]*ir.Node, []*dwarf.Var,
 	ssaVars := make(map[*ir.Node]bool)
 
 	for varID, dvar := range debugInfo.Vars {
-		n := dvar.(*ir.Node)
+		n := dvar
 		ssaVars[n] = true
 		for _, slot := range debugInfo.VarSlots[varID] {
-			ssaVars[debugInfo.Slots[slot].N.(*ir.Node)] = true
+			ssaVars[debugInfo.Slots[slot].N] = true
 		}
 
 		if dvar := createComplexVar(fnsym, fn, ssa.VarID(varID)); dvar != nil {
@@ -727,7 +727,7 @@ func preInliningDcls(fnsym *obj.LSym) []*ir.Node {
 // stack pointer, suitable for use in a DWARF location entry. This has nothing
 // to do with its offset in the user variable.
 func stackOffset(slot ssa.LocalSlot) int32 {
-	n := slot.N.(*ir.Node)
+	n := slot.N
 	var off int64
 	switch n.Class() {
 	case ir.PAUTO:
@@ -746,8 +746,8 @@ func stackOffset(slot ssa.LocalSlot) int32 {
 
 // createComplexVar builds a single DWARF variable entry and location list.
 func createComplexVar(fnsym *obj.LSym, fn *ir.Func, varID ssa.VarID) *dwarf.Var {
-	debug := fn.DebugInfo
-	n := debug.Vars[varID].(*ir.Node)
+	debug := fn.DebugInfo.(*ssa.FuncDebug)
+	n := debug.Vars[varID]
 
 	var abbrev int
 	switch n.Class() {
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 658ea28fbe..5cee3fab85 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -3080,7 +3080,7 @@ func (s *state) assign(left *ir.Node, right *ssa.Value, deref bool, skip skipMas
 	// If this assignment clobbers an entire local variable, then emit
 	// OpVarDef so liveness analysis knows the variable is redefined.
 	if base := clobberBase(left); base.Op == ir.ONAME && base.Class() != ir.PEXTERN && skip == 0 {
-		s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, base, s.mem(), !base.IsAutoTmp())
+		s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, base, s.mem(), !ir.IsAutoTmp(base))
 	}
 
 	// Left is not ssa-able. Compute its address.
@@ -3103,7 +3103,7 @@ func (s *state) assign(left *ir.Node, right *ssa.Value, deref bool, skip skipMas
 		return
 	}
 	// Treat as a store.
-	s.storeType(t, addr, right, skip, !left.IsAutoTmp())
+	s.storeType(t, addr, right, skip, !ir.IsAutoTmp(left))
 }
 
 // zeroVal returns the zero value for type t.
@@ -4860,7 +4860,7 @@ func (s *state) addr(n *ir.Node) *ssa.Value {
 			s.Fatalf("addr of undeclared ONAME %v. declared: %v", n, s.decladdrs)
 			return nil
 		case ir.PAUTO:
-			return s.newValue2Apos(ssa.OpLocalAddr, t, n, s.sp, s.mem(), !n.IsAutoTmp())
+			return s.newValue2Apos(ssa.OpLocalAddr, t, n, s.sp, s.mem(), !ir.IsAutoTmp(n))
 
 		case ir.PPARAMOUT: // Same as PAUTO -- cannot generate LEA early.
 			// ensure that we reuse symbols for out parameters so
@@ -6063,7 +6063,7 @@ func (s *state) addNamedValue(n *ir.Node, v *ssa.Value) {
 		// Don't track our marker nodes (memVar etc.).
 		return
 	}
-	if n.IsAutoTmp() {
+	if ir.IsAutoTmp(n) {
 		// Don't track temporary variables.
 		return
 	}
@@ -6476,12 +6476,13 @@ func genssa(f *ssa.Func, pp *Progs) {
 	}
 
 	if base.Ctxt.Flag_locationlists {
-		e.curfn.Func.DebugInfo = ssa.BuildFuncDebug(base.Ctxt, f, base.Debug.LocationLists > 1, stackOffset)
+		debugInfo := ssa.BuildFuncDebug(base.Ctxt, f, base.Debug.LocationLists > 1, stackOffset)
+		e.curfn.Func.DebugInfo = debugInfo
 		bstart := s.bstart
 		// Note that at this moment, Prog.Pc is a sequence number; it's
 		// not a real PC until after assembly, so this mapping has to
 		// be done later.
-		e.curfn.Func.DebugInfo.GetPC = func(b, v ssa.ID) int64 {
+		debugInfo.GetPC = func(b, v ssa.ID) int64 {
 			switch v {
 			case ssa.BlockStart.ID:
 				if b == f.Entry.ID {
@@ -6820,7 +6821,7 @@ func AutoVar(v *ssa.Value) (*ir.Node, int64) {
 	if v.Type.Size() > loc.Type.Size() {
 		v.Fatalf("spill/restore type %s doesn't fit in slot type %s", v.Type, loc.Type)
 	}
-	return loc.N.(*ir.Node), loc.Off
+	return loc.N, loc.Off
 }
 
 func AddrAuto(a *obj.Addr, v *ssa.Value) {
@@ -6975,7 +6976,7 @@ func (e *ssafn) StringData(s string) *obj.LSym {
 	return data
 }
 
-func (e *ssafn) Auto(pos src.XPos, t *types.Type) ssa.GCNode {
+func (e *ssafn) Auto(pos src.XPos, t *types.Type) *ir.Node {
 	n := tempAt(pos, e.curfn, t) // Note: adds new auto to e.curfn.Func.Dcl list
 	return n
 }
@@ -6990,7 +6991,7 @@ func (e *ssafn) SplitString(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot) {
 }
 
 func (e *ssafn) SplitInterface(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot) {
-	n := name.N.(*ir.Node)
+	n := name.N
 	u := types.Types[types.TUINTPTR]
 	t := types.NewPtr(types.Types[types.TUINT8])
 	// Split this interface up into two separate variables.
@@ -7047,7 +7048,7 @@ func (e *ssafn) SplitStruct(name ssa.LocalSlot, i int) ssa.LocalSlot {
 }
 
 func (e *ssafn) SplitArray(name ssa.LocalSlot) ssa.LocalSlot {
-	n := name.N.(*ir.Node)
+	n := name.N
 	at := name.Type
 	if at.NumElem() != 1 {
 		e.Fatalf(n.Pos, "bad array size")
@@ -7062,7 +7063,7 @@ func (e *ssafn) DerefItab(it *obj.LSym, offset int64) *obj.LSym {
 
 // SplitSlot returns a slot representing the data of parent starting at offset.
 func (e *ssafn) SplitSlot(parent *ssa.LocalSlot, suffix string, offset int64, t *types.Type) ssa.LocalSlot {
-	node := parent.N.(*ir.Node)
+	node := parent.N
 
 	if node.Class() != ir.PAUTO || node.Name.Addrtaken() {
 		// addressed things and non-autos retain their parents (i.e., cannot truly be split)
@@ -7070,7 +7071,7 @@ func (e *ssafn) SplitSlot(parent *ssa.LocalSlot, suffix string, offset int64, t
 	}
 
 	s := &types.Sym{Name: node.Sym.Name + suffix, Pkg: ir.LocalPkg}
-	n := ir.NewNameAt(parent.N.(*ir.Node).Pos, s)
+	n := ir.NewNameAt(parent.N.Pos, s)
 	s.Def = ir.AsTypesNode(n)
 	ir.AsNode(s.Def).Name.SetUsed(true)
 	n.Type = t
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 78fdf100ad..318f315f16 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -1960,7 +1960,7 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 		typecheckas(n)
 
 		// Code that creates temps does not bother to set defn, so do it here.
-		if n.Left.Op == ir.ONAME && n.Left.IsAutoTmp() {
+		if n.Left.Op == ir.ONAME && ir.IsAutoTmp(n.Left) {
 			n.Left.Name.Defn = n
 		}
 
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index e6ed178f49..cac9e6eb3e 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -13,7 +13,6 @@ import (
 	"unsafe"
 
 	"cmd/compile/internal/base"
-	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
@@ -156,14 +155,14 @@ func (n *Node) SetTChanDir(dir types.ChanDir) {
 	n.aux = uint8(dir)
 }
 
-func (n *Node) IsSynthetic() bool {
+func IsSynthetic(n *Node) bool {
 	name := n.Sym.Name
 	return name[0] == '.' || name[0] == '~'
 }
 
 // IsAutoTmp indicates if n was created by the compiler as a temporary,
 // based on the setting of the .AutoTemp flag in n's Name.
-func (n *Node) IsAutoTmp() bool {
+func IsAutoTmp(n *Node) bool {
 	if n == nil || n.Op != ONAME {
 		return false
 	}
@@ -683,7 +682,7 @@ type Func struct {
 	Closgen int
 
 	FieldTrack map[*types.Sym]struct{}
-	DebugInfo  *ssa.FuncDebug
+	DebugInfo  interface{}
 	LSym       *obj.LSym
 
 	Inl *Inline
@@ -1550,21 +1549,3 @@ func IsBlank(n *Node) bool {
 func IsMethod(n *Node) bool {
 	return n.Type.Recv() != nil
 }
-
-func (n *Node) Typ() *types.Type {
-	return n.Type
-}
-
-func (n *Node) StorageClass() ssa.StorageClass {
-	switch n.Class() {
-	case PPARAM:
-		return ssa.ClassParam
-	case PPARAMOUT:
-		return ssa.ClassParamOut
-	case PAUTO:
-		return ssa.ClassAuto
-	default:
-		base.Fatalf("untranslatable storage class for %v: %s", n, n.Class())
-		return 0
-	}
-}
diff --git a/src/cmd/compile/internal/ir/sizeof_test.go b/src/cmd/compile/internal/ir/sizeof_test.go
index c5169b9092..1ec89c338d 100644
--- a/src/cmd/compile/internal/ir/sizeof_test.go
+++ b/src/cmd/compile/internal/ir/sizeof_test.go
@@ -20,7 +20,7 @@ func TestSizeof(t *testing.T) {
 		_32bit uintptr     // size on 32bit platforms
 		_64bit uintptr     // size on 64bit platforms
 	}{
-		{Func{}, 132, 240},
+		{Func{}, 136, 248},
 		{Name{}, 32, 56},
 		{Param{}, 24, 48},
 		{Node{}, 76, 128},
diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go
index 0fe0337ddf..62abbdc223 100644
--- a/src/cmd/compile/internal/ssa/config.go
+++ b/src/cmd/compile/internal/ssa/config.go
@@ -5,6 +5,7 @@
 package ssa
 
 import (
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
@@ -138,7 +139,7 @@ type Frontend interface {
 
 	// Auto returns a Node for an auto variable of the given type.
 	// The SSA compiler uses this function to allocate space for spills.
-	Auto(src.XPos, *types.Type) GCNode
+	Auto(src.XPos, *types.Type) *ir.Node
 
 	// Given the name for a compound type, returns the name we should use
 	// for the parts of that compound type.
@@ -178,24 +179,6 @@ type Frontend interface {
 	MyImportPath() string
 }
 
-// interface used to hold a *gc.Node (a stack variable).
-// We'd use *gc.Node directly but that would lead to an import cycle.
-type GCNode interface {
-	Typ() *types.Type
-	String() string
-	IsSynthetic() bool
-	IsAutoTmp() bool
-	StorageClass() StorageClass
-}
-
-type StorageClass uint8
-
-const (
-	ClassAuto     StorageClass = iota // local stack variable
-	ClassParam                        // argument
-	ClassParamOut                     // return value
-)
-
 const go116lateCallExpansion = true
 
 // LateCallExpansionEnabledWithin returns true if late call expansion should be tested
diff --git a/src/cmd/compile/internal/ssa/deadstore.go b/src/cmd/compile/internal/ssa/deadstore.go
index 0664013b39..0f1cd4bc9f 100644
--- a/src/cmd/compile/internal/ssa/deadstore.go
+++ b/src/cmd/compile/internal/ssa/deadstore.go
@@ -5,6 +5,7 @@
 package ssa
 
 import (
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 )
@@ -136,9 +137,9 @@ func dse(f *Func) {
 // reaches stores then we delete all the stores. The other operations will then
 // be eliminated by the dead code elimination pass.
 func elimDeadAutosGeneric(f *Func) {
-	addr := make(map[*Value]GCNode) // values that the address of the auto reaches
-	elim := make(map[*Value]GCNode) // values that could be eliminated if the auto is
-	used := make(map[GCNode]bool)   // used autos that must be kept
+	addr := make(map[*Value]*ir.Node) // values that the address of the auto reaches
+	elim := make(map[*Value]*ir.Node) // values that could be eliminated if the auto is
+	used := make(map[*ir.Node]bool)   // used autos that must be kept
 
 	// visit the value and report whether any of the maps are updated
 	visit := func(v *Value) (changed bool) {
@@ -146,8 +147,8 @@ func elimDeadAutosGeneric(f *Func) {
 		switch v.Op {
 		case OpAddr, OpLocalAddr:
 			// Propagate the address if it points to an auto.
-			n, ok := v.Aux.(GCNode)
-			if !ok || n.StorageClass() != ClassAuto {
+			n, ok := v.Aux.(*ir.Node)
+			if !ok || n.Class() != ir.PAUTO {
 				return
 			}
 			if addr[v] == nil {
@@ -157,8 +158,8 @@ func elimDeadAutosGeneric(f *Func) {
 			return
 		case OpVarDef, OpVarKill:
 			// v should be eliminated if we eliminate the auto.
-			n, ok := v.Aux.(GCNode)
-			if !ok || n.StorageClass() != ClassAuto {
+			n, ok := v.Aux.(*ir.Node)
+			if !ok || n.Class() != ir.PAUTO {
 				return
 			}
 			if elim[v] == nil {
@@ -173,8 +174,8 @@ func elimDeadAutosGeneric(f *Func) {
 			// for open-coded defers from being removed (since they
 			// may not be used by the inline code, but will be used by
 			// panic processing).
-			n, ok := v.Aux.(GCNode)
-			if !ok || n.StorageClass() != ClassAuto {
+			n, ok := v.Aux.(*ir.Node)
+			if !ok || n.Class() != ir.PAUTO {
 				return
 			}
 			if !used[n] {
@@ -221,7 +222,7 @@ func elimDeadAutosGeneric(f *Func) {
 		}
 
 		// Propagate any auto addresses through v.
-		node := GCNode(nil)
+		var node *ir.Node
 		for _, a := range args {
 			if n, ok := addr[a]; ok && !used[n] {
 				if node == nil {
@@ -298,15 +299,15 @@ func elimUnreadAutos(f *Func) {
 	// Loop over all ops that affect autos taking note of which
 	// autos we need and also stores that we might be able to
 	// eliminate.
-	seen := make(map[GCNode]bool)
+	seen := make(map[*ir.Node]bool)
 	var stores []*Value
 	for _, b := range f.Blocks {
 		for _, v := range b.Values {
-			n, ok := v.Aux.(GCNode)
+			n, ok := v.Aux.(*ir.Node)
 			if !ok {
 				continue
 			}
-			if n.StorageClass() != ClassAuto {
+			if n.Class() != ir.PAUTO {
 				continue
 			}
 
@@ -334,7 +335,7 @@ func elimUnreadAutos(f *Func) {
 
 	// Eliminate stores to unread autos.
 	for _, store := range stores {
-		n, _ := store.Aux.(GCNode)
+		n, _ := store.Aux.(*ir.Node)
 		if seen[n] {
 			continue
 		}
diff --git a/src/cmd/compile/internal/ssa/debug.go b/src/cmd/compile/internal/ssa/debug.go
index 6353f72897..9de5f427c0 100644
--- a/src/cmd/compile/internal/ssa/debug.go
+++ b/src/cmd/compile/internal/ssa/debug.go
@@ -5,6 +5,7 @@
 package ssa
 
 import (
+	"cmd/compile/internal/ir"
 	"cmd/internal/dwarf"
 	"cmd/internal/obj"
 	"encoding/hex"
@@ -24,7 +25,7 @@ type FuncDebug struct {
 	// Slots is all the slots used in the debug info, indexed by their SlotID.
 	Slots []LocalSlot
 	// The user variables, indexed by VarID.
-	Vars []GCNode
+	Vars []*ir.Node
 	// The slots that make up each variable, indexed by VarID.
 	VarSlots [][]SlotID
 	// The location list data, indexed by VarID. Must be processed by PutLocationList.
@@ -165,7 +166,7 @@ func (s *debugState) logf(msg string, args ...interface{}) {
 type debugState struct {
 	// See FuncDebug.
 	slots    []LocalSlot
-	vars     []GCNode
+	vars     []*ir.Node
 	varSlots [][]SlotID
 	lists    [][]byte
 
@@ -189,7 +190,7 @@ type debugState struct {
 	// The pending location list entry for each user variable, indexed by VarID.
 	pendingEntries []pendingEntry
 
-	varParts           map[GCNode][]SlotID
+	varParts           map[*ir.Node][]SlotID
 	blockDebug         []BlockDebug
 	pendingSlotLocs    []VarLoc
 	liveSlots          []liveSlot
@@ -346,7 +347,7 @@ func BuildFuncDebug(ctxt *obj.Link, f *Func, loggingEnabled bool, stackOffset fu
 	}
 
 	if state.varParts == nil {
-		state.varParts = make(map[GCNode][]SlotID)
+		state.varParts = make(map[*ir.Node][]SlotID)
 	} else {
 		for n := range state.varParts {
 			delete(state.varParts, n)
@@ -360,7 +361,7 @@ func BuildFuncDebug(ctxt *obj.Link, f *Func, loggingEnabled bool, stackOffset fu
 	state.vars = state.vars[:0]
 	for i, slot := range f.Names {
 		state.slots = append(state.slots, slot)
-		if slot.N.IsSynthetic() {
+		if ir.IsSynthetic(slot.N) {
 			continue
 		}
 
@@ -379,8 +380,8 @@ func BuildFuncDebug(ctxt *obj.Link, f *Func, loggingEnabled bool, stackOffset fu
 	for _, b := range f.Blocks {
 		for _, v := range b.Values {
 			if v.Op == OpVarDef || v.Op == OpVarKill {
-				n := v.Aux.(GCNode)
-				if n.IsSynthetic() {
+				n := v.Aux.(*ir.Node)
+				if ir.IsSynthetic(n) {
 					continue
 				}
 
@@ -425,7 +426,7 @@ func BuildFuncDebug(ctxt *obj.Link, f *Func, loggingEnabled bool, stackOffset fu
 	state.initializeCache(f, len(state.varParts), len(state.slots))
 
 	for i, slot := range f.Names {
-		if slot.N.IsSynthetic() {
+		if ir.IsSynthetic(slot.N) {
 			continue
 		}
 		for _, value := range f.NamedValues[slot] {
@@ -717,8 +718,8 @@ func (state *debugState) processValue(v *Value, vSlots []SlotID, vReg *Register)
 
 	switch {
 	case v.Op == OpVarDef, v.Op == OpVarKill:
-		n := v.Aux.(GCNode)
-		if n.IsSynthetic() {
+		n := v.Aux.(*ir.Node)
+		if ir.IsSynthetic(n) {
 			break
 		}
 
diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go
index bfe94ff160..3d142a2272 100644
--- a/src/cmd/compile/internal/ssa/export_test.go
+++ b/src/cmd/compile/internal/ssa/export_test.go
@@ -5,6 +5,7 @@
 package ssa
 
 import (
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/arm64"
@@ -65,36 +66,13 @@ type TestFrontend struct {
 	ctxt *obj.Link
 }
 
-type TestAuto struct {
-	t *types.Type
-	s string
-}
-
-func (d *TestAuto) Typ() *types.Type {
-	return d.t
-}
-
-func (d *TestAuto) String() string {
-	return d.s
-}
-
-func (d *TestAuto) StorageClass() StorageClass {
-	return ClassAuto
-}
-
-func (d *TestAuto) IsSynthetic() bool {
-	return false
-}
-
-func (d *TestAuto) IsAutoTmp() bool {
-	return true
-}
-
 func (TestFrontend) StringData(s string) *obj.LSym {
 	return nil
 }
-func (TestFrontend) Auto(pos src.XPos, t *types.Type) GCNode {
-	return &TestAuto{t: t, s: "aTestAuto"}
+func (TestFrontend) Auto(pos src.XPos, t *types.Type) *ir.Node {
+	n := ir.NewNameAt(pos, &types.Sym{Name: "aFakeAuto"})
+	n.SetClass(ir.PAUTO)
+	return n
 }
 func (d TestFrontend) SplitString(s LocalSlot) (LocalSlot, LocalSlot) {
 	return LocalSlot{N: s.N, Type: testTypes.BytePtr, Off: s.Off}, LocalSlot{N: s.N, Type: testTypes.Int, Off: s.Off + 8}
diff --git a/src/cmd/compile/internal/ssa/location.go b/src/cmd/compile/internal/ssa/location.go
index a333982389..2f456c9f89 100644
--- a/src/cmd/compile/internal/ssa/location.go
+++ b/src/cmd/compile/internal/ssa/location.go
@@ -5,6 +5,7 @@
 package ssa
 
 import (
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"fmt"
 )
@@ -59,7 +60,7 @@ func (r *Register) GCNum() int16 {
 //                           { N: len, Type: int, Off: 0, SplitOf: parent, SplitOffset: 8}
 //                           parent = &{N: s, Type: string}
 type LocalSlot struct {
-	N    GCNode      // an ONAME *gc.Node representing a stack location.
+	N    *ir.Node    // an ONAME *gc.Node representing a stack location.
 	Type *types.Type // type of slot
 	Off  int64       // offset of slot in N
 
diff --git a/src/cmd/compile/internal/ssa/nilcheck.go b/src/cmd/compile/internal/ssa/nilcheck.go
index d1bad529e7..e0ae0454ef 100644
--- a/src/cmd/compile/internal/ssa/nilcheck.go
+++ b/src/cmd/compile/internal/ssa/nilcheck.go
@@ -5,6 +5,7 @@
 package ssa
 
 import (
+	"cmd/compile/internal/ir"
 	"cmd/internal/objabi"
 	"cmd/internal/src"
 )
@@ -235,7 +236,7 @@ func nilcheckelim2(f *Func) {
 				continue
 			}
 			if v.Type.IsMemory() || v.Type.IsTuple() && v.Type.FieldType(1).IsMemory() {
-				if v.Op == OpVarKill || v.Op == OpVarLive || (v.Op == OpVarDef && !v.Aux.(GCNode).Typ().HasPointers()) {
+				if v.Op == OpVarKill || v.Op == OpVarLive || (v.Op == OpVarDef && !v.Aux.(*ir.Node).Type.HasPointers()) {
 					// These ops don't really change memory.
 					continue
 					// Note: OpVarDef requires that the defined variable not have pointers.
diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go
index 4ed884c3e7..9841883939 100644
--- a/src/cmd/compile/internal/ssa/regalloc.go
+++ b/src/cmd/compile/internal/ssa/regalloc.go
@@ -114,6 +114,7 @@
 package ssa
 
 import (
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/objabi"
 	"cmd/internal/src"
@@ -1248,7 +1249,7 @@ func (s *regAllocState) regalloc(f *Func) {
 					// This forces later liveness analysis to make the
 					// value live at this point.
 					v.SetArg(0, s.makeSpill(a, b))
-				} else if _, ok := a.Aux.(GCNode); ok && vi.rematerializeable {
+				} else if _, ok := a.Aux.(*ir.Node); ok && vi.rematerializeable {
 					// Rematerializeable value with a gc.Node. This is the address of
 					// a stack object (e.g. an LEAQ). Keep the object live.
 					// Change it to VarLive, which is what plive expects for locals.
diff --git a/src/cmd/compile/internal/ssa/sizeof_test.go b/src/cmd/compile/internal/ssa/sizeof_test.go
index 60ada011e3..a27002ee3a 100644
--- a/src/cmd/compile/internal/ssa/sizeof_test.go
+++ b/src/cmd/compile/internal/ssa/sizeof_test.go
@@ -22,7 +22,7 @@ func TestSizeof(t *testing.T) {
 	}{
 		{Value{}, 72, 112},
 		{Block{}, 164, 304},
-		{LocalSlot{}, 32, 48},
+		{LocalSlot{}, 28, 40},
 		{valState{}, 28, 40},
 	}
 
diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go
index 406a3c3ea5..eee0a21a66 100644
--- a/src/cmd/compile/internal/ssa/stackalloc.go
+++ b/src/cmd/compile/internal/ssa/stackalloc.go
@@ -7,6 +7,7 @@
 package ssa
 
 import (
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"fmt"
@@ -156,7 +157,7 @@ func (s *stackAllocState) stackalloc() {
 		if v.Aux == nil {
 			f.Fatalf("%s has nil Aux\n", v.LongString())
 		}
-		loc := LocalSlot{N: v.Aux.(GCNode), Type: v.Type, Off: v.AuxInt}
+		loc := LocalSlot{N: v.Aux.(*ir.Node), Type: v.Type, Off: v.AuxInt}
 		if f.pass.debug > stackDebug {
 			fmt.Printf("stackalloc %s to %s\n", v, loc)
 		}
-- 
GitLab


From 41ab6689edb1f51001feab0928e598050e2f6d32 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 24 Nov 2020 20:47:32 -0500
Subject: [PATCH 0072/2400] [dev.regabi] cmd/compile: rewrite a few ++/--/+=/-=
 to prep for getters/setters [generated]

These are trivial rewrites that are only OK because it turns out that n has no side effects.
Separated into a different CL for easy inspection.

[git-generate]
cd src/cmd/compile/internal/gc
rf '
        ex . ../ir ../ssa {
                import "cmd/compile/internal/ir"
                var n *ir.Node
		var i int64

                n.Xoffset++ -> n.Xoffset = n.Xoffset + 1
                n.Xoffset-- -> n.Xoffset = n.Xoffset - 1
                n.Xoffset += i -> n.Xoffset = n.Xoffset + i
                n.Xoffset -= i -> n.Xoffset = n.Xoffset - i
	}
'

Change-Id: If7b4b7f7cbdafeee988e04d03924ef0e1dd867b0
Reviewed-on: https://go-review.googlesource.com/c/go/+/272932
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/initorder.go | 4 ++--
 src/cmd/compile/internal/gc/sinit.go     | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/cmd/compile/internal/gc/initorder.go b/src/cmd/compile/internal/gc/initorder.go
index 942cb95f20..62294b5a90 100644
--- a/src/cmd/compile/internal/gc/initorder.go
+++ b/src/cmd/compile/internal/gc/initorder.go
@@ -142,7 +142,7 @@ func (o *InitOrder) processAssign(n *ir.Node) {
 		if dep.Class() != ir.PEXTERN || defn.Initorder() == InitDone {
 			continue
 		}
-		n.Xoffset++
+		n.Xoffset = n.Xoffset + 1
 		o.blocking[defn] = append(o.blocking[defn], n)
 	}
 
@@ -169,7 +169,7 @@ func (o *InitOrder) flushReady(initialize func(*ir.Node)) {
 		delete(o.blocking, n)
 
 		for _, m := range blocked {
-			m.Xoffset--
+			m.Xoffset = m.Xoffset - 1
 			if m.Xoffset == 0 {
 				heap.Push(&o.ready, m)
 			}
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index d78b509127..0ba7efb95e 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -157,7 +157,7 @@ func (s *InitSchedule) staticcopy(l *ir.Node, r *ir.Node) bool {
 			// copying someone else's computation.
 			rr := ir.SepCopy(orig)
 			rr.Type = ll.Type
-			rr.Xoffset += e.Xoffset
+			rr.Xoffset = rr.Xoffset + e.Xoffset
 			setlineno(rr)
 			s.append(ir.Nod(ir.OAS, ll, rr))
 		}
@@ -301,7 +301,7 @@ func (s *InitSchedule) staticassign(l *ir.Node, r *ir.Node) bool {
 
 		// Emit itab, advance offset.
 		addrsym(n, itab.Left) // itab is an OADDR node
-		n.Xoffset += int64(Widthptr)
+		n.Xoffset = n.Xoffset + int64(Widthptr)
 
 		// Emit data.
 		if isdirectiface(val.Type) {
@@ -1017,7 +1017,7 @@ func stataddr(n *ir.Node) *ir.Node {
 		if nam == nil {
 			break
 		}
-		nam.Xoffset += n.Xoffset
+		nam.Xoffset = nam.Xoffset + n.Xoffset
 		nam.Type = n.Type
 		return nam
 
@@ -1038,7 +1038,7 @@ func stataddr(n *ir.Node) *ir.Node {
 		if n.Type.Width != 0 && thearch.MAXWIDTH/n.Type.Width <= int64(l) {
 			break
 		}
-		nam.Xoffset += int64(l) * n.Type.Width
+		nam.Xoffset = nam.Xoffset + int64(l)*n.Type.Width
 		nam.Type = n.Type
 		return nam
 	}
-- 
GitLab


From acb4d1cef14529585266df1868045f80e37ae081 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 22 Nov 2020 09:59:15 -0500
Subject: [PATCH 0073/2400] [dev.regabi] cmd/compile: use Node getters and
 setters [generated]

Now that we have all the getters and setters defined, use them
and unexport all the actual Node fields. This is the next step
toward replacing Node with an interface.

[git-generate]
cd src/cmd/compile/internal/gc
rf '
        ex . ../ir ../ssa {
                import "cmd/compile/internal/ir"
                import "cmd/compile/internal/types"
                import "cmd/internal/src"
                var n, x *ir.Node
                var op ir.Op
                var t *types.Type
                var f *ir.Func
                var m *ir.Name
                var s *types.Sym
                var p src.XPos
                var i int64
                var e uint16
                var nodes ir.Nodes

                n.Op = op    -> n.SetOp(op)
                n.Left = x   -> n.SetLeft(x)
                n.Right = x  -> n.SetRight(x)
                n.Orig = x -> n.SetOrig(x)
                n.Type = t -> n.SetType(t)
                n.Func = f -> n.SetFunc(f)
                n.Name = m -> n.SetName(m)
                n.Sym = s -> n.SetSym(s)
                n.Pos = p -> n.SetPos(p)
                n.Xoffset = i -> n.SetXoffset(i)
                n.Esc = e -> n.SetEsc(e)

                n.Ninit.Append -> n.PtrNinit().Append
                n.Ninit.AppendNodes -> n.PtrNinit().AppendNodes
                n.Ninit.MoveNodes -> n.PtrNinit().MoveNodes
                n.Ninit.Prepend -> n.PtrNinit().Prepend
                n.Ninit.Set -> n.PtrNinit().Set
                n.Ninit.Set1 -> n.PtrNinit().Set1
                n.Ninit.Set2 -> n.PtrNinit().Set2
                n.Ninit.Set3 -> n.PtrNinit().Set3
                &n.Ninit -> n.PtrNinit()
                n.Ninit = nodes -> n.SetNinit(nodes)

                n.Nbody.Append -> n.PtrNbody().Append
                n.Nbody.AppendNodes -> n.PtrNbody().AppendNodes
                n.Nbody.MoveNodes -> n.PtrNbody().MoveNodes
                n.Nbody.Prepend -> n.PtrNbody().Prepend
                n.Nbody.Set -> n.PtrNbody().Set
                n.Nbody.Set1 -> n.PtrNbody().Set1
                n.Nbody.Set2 -> n.PtrNbody().Set2
                n.Nbody.Set3 -> n.PtrNbody().Set3
                &n.Nbody -> n.PtrNbody()
                n.Nbody = nodes -> n.SetNbody(nodes)

                n.List.Append -> n.PtrList().Append
                n.List.AppendNodes -> n.PtrList().AppendNodes
                n.List.MoveNodes -> n.PtrList().MoveNodes
                n.List.Prepend -> n.PtrList().Prepend
                n.List.Set -> n.PtrList().Set
                n.List.Set1 -> n.PtrList().Set1
                n.List.Set2 -> n.PtrList().Set2
                n.List.Set3 -> n.PtrList().Set3
                &n.List -> n.PtrList()
                n.List = nodes -> n.SetList(nodes)

                n.Rlist.Append -> n.PtrRlist().Append
                n.Rlist.AppendNodes -> n.PtrRlist().AppendNodes
                n.Rlist.MoveNodes -> n.PtrRlist().MoveNodes
                n.Rlist.Prepend -> n.PtrRlist().Prepend
                n.Rlist.Set -> n.PtrRlist().Set
                n.Rlist.Set1 -> n.PtrRlist().Set1
                n.Rlist.Set2 -> n.PtrRlist().Set2
                n.Rlist.Set3 -> n.PtrRlist().Set3
                &n.Rlist -> n.PtrRlist()
                n.Rlist = nodes -> n.SetRlist(nodes)
        }
        ex . ../ir ../ssa {
                import "cmd/compile/internal/ir"

                var n *ir.Node
                n.Op         -> n.GetOp()
                n.Left       -> n.GetLeft()
                n.Right      -> n.GetRight()
                n.Orig -> n.GetOrig()
                n.Type -> n.GetType()
                n.Func -> n.GetFunc()
                n.Name -> n.GetName()
                n.Sym -> n.GetSym()
                n.Pos -> n.GetPos()
                n.Xoffset -> n.GetXoffset()
                n.Esc -> n.GetEsc()

                avoid (*ir.Node).PtrNinit
                avoid (*ir.Node).PtrNbody
                avoid (*ir.Node).PtrList
                avoid (*ir.Node).PtrRlist

                n.Ninit -> n.GetNinit()
                n.Nbody -> n.GetNbody()
                n.List -> n.GetList()
                n.Rlist -> n.GetRlist()
        }
'

cd ../ir
rf '
        mv Node.Op Node.op
        mv Node.GetOp Node.Op

        mv Node.Left Node.left
        mv Node.GetLeft Node.Left

        mv Node.Right Node.right
        mv Node.GetRight Node.Right

        mv Node.Orig Node.orig
        mv Node.GetOrig Node.Orig

        mv Node.Type Node.typ
        mv Node.GetType Node.Type

        mv Node.Func Node.fn
        mv Node.GetFunc Node.Func

        mv Node.Name Node.name
        mv Node.GetName Node.Name

        # All uses are in other Node methods already.
        mv Node.E Node.e

        mv Node.Sym Node.sym
        mv Node.GetSym Node.Sym

        mv Node.Pos Node.pos
        mv Node.GetPos Node.Pos

        mv Node.Esc Node.esc
        mv Node.GetEsc Node.Esc

	# While we are here, rename Xoffset to more idiomatic Offset.
        mv Node.Xoffset Node.offset
        mv Node.GetXoffset Node.Offset
	mv Node.SetXoffset Node.SetOffset

        # While we are here, rename Ninit, Nbody to more idiomatic Init, Body.
        mv Node.Ninit Node.init
        mv Node.GetNinit Node.Init
        mv Node.PtrNinit Node.PtrInit
        mv Node.SetNinit Node.SetInit
        mv Node.Nbody Node.body
        mv Node.GetNbody Node.Body
        mv Node.PtrNbody Node.PtrBody
        mv Node.SetNbody Node.SetBody
        mv Node.List Node.list
        mv Node.GetList Node.List
        mv Node.Rlist Node.rlist
        mv Node.GetRlist Node.Rlist

        # Unexport these
        mv Node.SetHasOpt Node.setHasOpt
        mv Node.SetHasVal Node.setHasVal
'

Change-Id: I9894f633375c5237a29b6d6d7b89ba181b56ca3a
Reviewed-on: https://go-review.googlesource.com/c/go/+/273009
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/alg.go       |  154 +-
 src/cmd/compile/internal/gc/align.go     |   12 +-
 src/cmd/compile/internal/gc/bexport.go   |    4 +-
 src/cmd/compile/internal/gc/bimport.go   |    2 +-
 src/cmd/compile/internal/gc/closure.go   |  222 +--
 src/cmd/compile/internal/gc/const.go     |  172 +-
 src/cmd/compile/internal/gc/dcl.go       |  266 +--
 src/cmd/compile/internal/gc/dwinl.go     |    6 +-
 src/cmd/compile/internal/gc/embed.go     |   36 +-
 src/cmd/compile/internal/gc/escape.go    |  518 +++---
 src/cmd/compile/internal/gc/export.go    |   54 +-
 src/cmd/compile/internal/gc/gen.go       |   22 +-
 src/cmd/compile/internal/gc/gsubr.go     |   24 +-
 src/cmd/compile/internal/gc/iexport.go   |  338 ++--
 src/cmd/compile/internal/gc/iimport.go   |  144 +-
 src/cmd/compile/internal/gc/init.go      |   20 +-
 src/cmd/compile/internal/gc/initorder.go |   70 +-
 src/cmd/compile/internal/gc/inl.go       |  554 +++---
 src/cmd/compile/internal/gc/main.go      |   40 +-
 src/cmd/compile/internal/gc/noder.go     |  254 +--
 src/cmd/compile/internal/gc/obj.go       |  110 +-
 src/cmd/compile/internal/gc/order.go     |  604 +++----
 src/cmd/compile/internal/gc/pgen.go      |  178 +-
 src/cmd/compile/internal/gc/pgen_test.go |   12 +-
 src/cmd/compile/internal/gc/plive.go     |   48 +-
 src/cmd/compile/internal/gc/racewalk.go  |   18 +-
 src/cmd/compile/internal/gc/range.go     |  208 +--
 src/cmd/compile/internal/gc/reflect.go   |   16 +-
 src/cmd/compile/internal/gc/scc.go       |   26 +-
 src/cmd/compile/internal/gc/scope.go     |    6 +-
 src/cmd/compile/internal/gc/select.go    |  192 +--
 src/cmd/compile/internal/gc/sinit.go     |  356 ++--
 src/cmd/compile/internal/gc/ssa.go       | 1082 ++++++------
 src/cmd/compile/internal/gc/subr.go      |  206 +--
 src/cmd/compile/internal/gc/swt.go       |  278 +--
 src/cmd/compile/internal/gc/typecheck.go | 1970 +++++++++++-----------
 src/cmd/compile/internal/gc/universe.go  |   38 +-
 src/cmd/compile/internal/gc/unsafe.go    |   38 +-
 src/cmd/compile/internal/gc/walk.go      | 1404 +++++++--------
 src/cmd/compile/internal/ir/dump.go      |    2 +-
 src/cmd/compile/internal/ir/fmt.go       |  402 ++---
 src/cmd/compile/internal/ir/node.go      |  266 +--
 src/cmd/compile/internal/ir/val.go       |    6 +-
 src/cmd/compile/internal/ssa/nilcheck.go |    2 +-
 44 files changed, 5191 insertions(+), 5189 deletions(-)

diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index cf82b9d591..ffd1682b35 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -293,15 +293,15 @@ func genhash(t *types.Type) *obj.LSym {
 
 	// func sym(p *T, h uintptr) uintptr
 	tfn := ir.Nod(ir.OTFUNC, nil, nil)
-	tfn.List.Set2(
+	tfn.PtrList().Set2(
 		namedfield("p", types.NewPtr(t)),
 		namedfield("h", types.Types[types.TUINTPTR]),
 	)
-	tfn.Rlist.Set1(anonfield(types.Types[types.TUINTPTR]))
+	tfn.PtrRlist().Set1(anonfield(types.Types[types.TUINTPTR]))
 
 	fn := dclfunc(sym, tfn)
-	np := ir.AsNode(tfn.Type.Params().Field(0).Nname)
-	nh := ir.AsNode(tfn.Type.Params().Field(1).Nname)
+	np := ir.AsNode(tfn.Type().Params().Field(0).Nname)
+	nh := ir.AsNode(tfn.Type().Params().Field(1).Nname)
 
 	switch t.Etype {
 	case types.TARRAY:
@@ -312,11 +312,11 @@ func genhash(t *types.Type) *obj.LSym {
 
 		n := ir.Nod(ir.ORANGE, nil, ir.Nod(ir.ODEREF, np, nil))
 		ni := NewName(lookup("i"))
-		ni.Type = types.Types[types.TINT]
-		n.List.Set1(ni)
+		ni.SetType(types.Types[types.TINT])
+		n.PtrList().Set1(ni)
 		n.SetColas(true)
-		colasdefn(n.List.Slice(), n)
-		ni = n.List.First()
+		colasdefn(n.List().Slice(), n)
+		ni = n.List().First()
 
 		// h = hashel(&p[i], h)
 		call := ir.Nod(ir.OCALL, hashel, nil)
@@ -324,11 +324,11 @@ func genhash(t *types.Type) *obj.LSym {
 		nx := ir.Nod(ir.OINDEX, np, ni)
 		nx.SetBounded(true)
 		na := ir.Nod(ir.OADDR, nx, nil)
-		call.List.Append(na)
-		call.List.Append(nh)
-		n.Nbody.Append(ir.Nod(ir.OAS, nh, call))
+		call.PtrList().Append(na)
+		call.PtrList().Append(nh)
+		n.PtrBody().Append(ir.Nod(ir.OAS, nh, call))
 
-		fn.Nbody.Append(n)
+		fn.PtrBody().Append(n)
 
 	case types.TSTRUCT:
 		// Walk the struct using memhash for runs of AMEM
@@ -348,9 +348,9 @@ func genhash(t *types.Type) *obj.LSym {
 				call := ir.Nod(ir.OCALL, hashel, nil)
 				nx := nodSym(ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
 				na := ir.Nod(ir.OADDR, nx, nil)
-				call.List.Append(na)
-				call.List.Append(nh)
-				fn.Nbody.Append(ir.Nod(ir.OAS, nh, call))
+				call.PtrList().Append(na)
+				call.PtrList().Append(nh)
+				fn.PtrBody().Append(ir.Nod(ir.OAS, nh, call))
 				i++
 				continue
 			}
@@ -363,37 +363,37 @@ func genhash(t *types.Type) *obj.LSym {
 			call := ir.Nod(ir.OCALL, hashel, nil)
 			nx := nodSym(ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
 			na := ir.Nod(ir.OADDR, nx, nil)
-			call.List.Append(na)
-			call.List.Append(nh)
-			call.List.Append(nodintconst(size))
-			fn.Nbody.Append(ir.Nod(ir.OAS, nh, call))
+			call.PtrList().Append(na)
+			call.PtrList().Append(nh)
+			call.PtrList().Append(nodintconst(size))
+			fn.PtrBody().Append(ir.Nod(ir.OAS, nh, call))
 
 			i = next
 		}
 	}
 
 	r := ir.Nod(ir.ORETURN, nil, nil)
-	r.List.Append(nh)
-	fn.Nbody.Append(r)
+	r.PtrList().Append(nh)
+	fn.PtrBody().Append(r)
 
 	if base.Flag.LowerR != 0 {
-		ir.DumpList("genhash body", fn.Nbody)
+		ir.DumpList("genhash body", fn.Body())
 	}
 
 	funcbody()
 
-	fn.Func.SetDupok(true)
+	fn.Func().SetDupok(true)
 	fn = typecheck(fn, ctxStmt)
 
 	Curfn = fn
-	typecheckslice(fn.Nbody.Slice(), ctxStmt)
+	typecheckslice(fn.Body().Slice(), ctxStmt)
 	Curfn = nil
 
 	if base.Debug.DclStack != 0 {
 		testdclstack()
 	}
 
-	fn.Func.SetNilCheckDisabled(true)
+	fn.Func().SetNilCheckDisabled(true)
 	xtop = append(xtop, fn)
 
 	// Build closure. It doesn't close over any variables, so
@@ -432,12 +432,12 @@ func hashfor(t *types.Type) *ir.Node {
 
 	n := NewName(sym)
 	setNodeNameFunc(n)
-	n.Type = functype(nil, []*ir.Node{
+	n.SetType(functype(nil, []*ir.Node{
 		anonfield(types.NewPtr(t)),
 		anonfield(types.Types[types.TUINTPTR]),
 	}, []*ir.Node{
 		anonfield(types.Types[types.TUINTPTR]),
-	})
+	}))
 	return n
 }
 
@@ -522,16 +522,16 @@ func geneq(t *types.Type) *obj.LSym {
 
 	// func sym(p, q *T) bool
 	tfn := ir.Nod(ir.OTFUNC, nil, nil)
-	tfn.List.Set2(
+	tfn.PtrList().Set2(
 		namedfield("p", types.NewPtr(t)),
 		namedfield("q", types.NewPtr(t)),
 	)
-	tfn.Rlist.Set1(namedfield("r", types.Types[types.TBOOL]))
+	tfn.PtrRlist().Set1(namedfield("r", types.Types[types.TBOOL]))
 
 	fn := dclfunc(sym, tfn)
-	np := ir.AsNode(tfn.Type.Params().Field(0).Nname)
-	nq := ir.AsNode(tfn.Type.Params().Field(1).Nname)
-	nr := ir.AsNode(tfn.Type.Results().Field(0).Nname)
+	np := ir.AsNode(tfn.Type().Params().Field(0).Nname)
+	nq := ir.AsNode(tfn.Type().Params().Field(1).Nname)
+	nr := ir.AsNode(tfn.Type().Results().Field(0).Nname)
 
 	// Label to jump to if an equality test fails.
 	neq := autolabel(".neq")
@@ -573,11 +573,11 @@ func geneq(t *types.Type) *obj.LSym {
 				// pi := p[i]
 				pi := ir.Nod(ir.OINDEX, np, i)
 				pi.SetBounded(true)
-				pi.Type = t.Elem()
+				pi.SetType(t.Elem())
 				// qi := q[i]
 				qi := ir.Nod(ir.OINDEX, nq, i)
 				qi.SetBounded(true)
-				qi.Type = t.Elem()
+				qi.SetType(t.Elem())
 				return eq(pi, qi)
 			}
 
@@ -590,11 +590,11 @@ func geneq(t *types.Type) *obj.LSym {
 				for i := int64(0); i < nelem; i++ {
 					// if check {} else { goto neq }
 					nif := ir.Nod(ir.OIF, checkIdx(nodintconst(i)), nil)
-					nif.Rlist.Append(nodSym(ir.OGOTO, nil, neq))
-					fn.Nbody.Append(nif)
+					nif.PtrRlist().Append(nodSym(ir.OGOTO, nil, neq))
+					fn.PtrBody().Append(nif)
 				}
 				if last {
-					fn.Nbody.Append(ir.Nod(ir.OAS, nr, checkIdx(nodintconst(nelem))))
+					fn.PtrBody().Append(ir.Nod(ir.OAS, nr, checkIdx(nodintconst(nelem))))
 				}
 			} else {
 				// Generate a for loop.
@@ -604,14 +604,14 @@ func geneq(t *types.Type) *obj.LSym {
 				cond := ir.Nod(ir.OLT, i, nodintconst(nelem))
 				post := ir.Nod(ir.OAS, i, ir.Nod(ir.OADD, i, nodintconst(1)))
 				loop := ir.Nod(ir.OFOR, cond, post)
-				loop.Ninit.Append(init)
+				loop.PtrInit().Append(init)
 				// if eq(pi, qi) {} else { goto neq }
 				nif := ir.Nod(ir.OIF, checkIdx(i), nil)
-				nif.Rlist.Append(nodSym(ir.OGOTO, nil, neq))
-				loop.Nbody.Append(nif)
-				fn.Nbody.Append(loop)
+				nif.PtrRlist().Append(nodSym(ir.OGOTO, nil, neq))
+				loop.PtrBody().Append(nif)
+				fn.PtrBody().Append(loop)
 				if last {
-					fn.Nbody.Append(ir.Nod(ir.OAS, nr, nodbool(true)))
+					fn.PtrBody().Append(ir.Nod(ir.OAS, nr, nodbool(true)))
 				}
 			}
 		}
@@ -712,7 +712,7 @@ func geneq(t *types.Type) *obj.LSym {
 		var flatConds []*ir.Node
 		for _, c := range conds {
 			isCall := func(n *ir.Node) bool {
-				return n.Op == ir.OCALL || n.Op == ir.OCALLFUNC
+				return n.Op() == ir.OCALL || n.Op() == ir.OCALLFUNC
 			}
 			sort.SliceStable(c, func(i, j int) bool {
 				return !isCall(c[i]) && isCall(c[j])
@@ -721,51 +721,51 @@ func geneq(t *types.Type) *obj.LSym {
 		}
 
 		if len(flatConds) == 0 {
-			fn.Nbody.Append(ir.Nod(ir.OAS, nr, nodbool(true)))
+			fn.PtrBody().Append(ir.Nod(ir.OAS, nr, nodbool(true)))
 		} else {
 			for _, c := range flatConds[:len(flatConds)-1] {
 				// if cond {} else { goto neq }
 				n := ir.Nod(ir.OIF, c, nil)
-				n.Rlist.Append(nodSym(ir.OGOTO, nil, neq))
-				fn.Nbody.Append(n)
+				n.PtrRlist().Append(nodSym(ir.OGOTO, nil, neq))
+				fn.PtrBody().Append(n)
 			}
-			fn.Nbody.Append(ir.Nod(ir.OAS, nr, flatConds[len(flatConds)-1]))
+			fn.PtrBody().Append(ir.Nod(ir.OAS, nr, flatConds[len(flatConds)-1]))
 		}
 	}
 
 	// ret:
 	//   return
 	ret := autolabel(".ret")
-	fn.Nbody.Append(nodSym(ir.OLABEL, nil, ret))
-	fn.Nbody.Append(ir.Nod(ir.ORETURN, nil, nil))
+	fn.PtrBody().Append(nodSym(ir.OLABEL, nil, ret))
+	fn.PtrBody().Append(ir.Nod(ir.ORETURN, nil, nil))
 
 	// neq:
 	//   r = false
 	//   return (or goto ret)
-	fn.Nbody.Append(nodSym(ir.OLABEL, nil, neq))
-	fn.Nbody.Append(ir.Nod(ir.OAS, nr, nodbool(false)))
+	fn.PtrBody().Append(nodSym(ir.OLABEL, nil, neq))
+	fn.PtrBody().Append(ir.Nod(ir.OAS, nr, nodbool(false)))
 	if EqCanPanic(t) || hasCall(fn) {
 		// Epilogue is large, so share it with the equal case.
-		fn.Nbody.Append(nodSym(ir.OGOTO, nil, ret))
+		fn.PtrBody().Append(nodSym(ir.OGOTO, nil, ret))
 	} else {
 		// Epilogue is small, so don't bother sharing.
-		fn.Nbody.Append(ir.Nod(ir.ORETURN, nil, nil))
+		fn.PtrBody().Append(ir.Nod(ir.ORETURN, nil, nil))
 	}
 	// TODO(khr): the epilogue size detection condition above isn't perfect.
 	// We should really do a generic CL that shares epilogues across
 	// the board. See #24936.
 
 	if base.Flag.LowerR != 0 {
-		ir.DumpList("geneq body", fn.Nbody)
+		ir.DumpList("geneq body", fn.Body())
 	}
 
 	funcbody()
 
-	fn.Func.SetDupok(true)
+	fn.Func().SetDupok(true)
 	fn = typecheck(fn, ctxStmt)
 
 	Curfn = fn
-	typecheckslice(fn.Nbody.Slice(), ctxStmt)
+	typecheckslice(fn.Body().Slice(), ctxStmt)
 	Curfn = nil
 
 	if base.Debug.DclStack != 0 {
@@ -776,7 +776,7 @@ func geneq(t *types.Type) *obj.LSym {
 	// We are comparing a struct or an array,
 	// neither of which can be nil, and our comparisons
 	// are shallow.
-	fn.Func.SetNilCheckDisabled(true)
+	fn.Func().SetNilCheckDisabled(true)
 	xtop = append(xtop, fn)
 
 	// Generate a closure which points at the function we just generated.
@@ -786,31 +786,31 @@ func geneq(t *types.Type) *obj.LSym {
 }
 
 func hasCall(n *ir.Node) bool {
-	if n.Op == ir.OCALL || n.Op == ir.OCALLFUNC {
+	if n.Op() == ir.OCALL || n.Op() == ir.OCALLFUNC {
 		return true
 	}
-	if n.Left != nil && hasCall(n.Left) {
+	if n.Left() != nil && hasCall(n.Left()) {
 		return true
 	}
-	if n.Right != nil && hasCall(n.Right) {
+	if n.Right() != nil && hasCall(n.Right()) {
 		return true
 	}
-	for _, x := range n.Ninit.Slice() {
+	for _, x := range n.Init().Slice() {
 		if hasCall(x) {
 			return true
 		}
 	}
-	for _, x := range n.Nbody.Slice() {
+	for _, x := range n.Body().Slice() {
 		if hasCall(x) {
 			return true
 		}
 	}
-	for _, x := range n.List.Slice() {
+	for _, x := range n.List().Slice() {
 		if hasCall(x) {
 			return true
 		}
 	}
-	for _, x := range n.Rlist.Slice() {
+	for _, x := range n.Rlist().Slice() {
 		if hasCall(x) {
 			return true
 		}
@@ -844,12 +844,12 @@ func eqstring(s, t *ir.Node) (eqlen, eqmem *ir.Node) {
 	fn := syslook("memequal")
 	fn = substArgTypes(fn, types.Types[types.TUINT8], types.Types[types.TUINT8])
 	call := ir.Nod(ir.OCALL, fn, nil)
-	call.List.Append(sptr, tptr, ir.Copy(slen))
+	call.PtrList().Append(sptr, tptr, ir.Copy(slen))
 	call = typecheck(call, ctxExpr|ctxMultiOK)
 
 	cmp := ir.Nod(ir.OEQ, slen, tlen)
 	cmp = typecheck(cmp, ctxExpr)
-	cmp.Type = types.Types[types.TBOOL]
+	cmp.SetType(types.Types[types.TBOOL])
 	return cmp, call
 }
 
@@ -860,13 +860,13 @@ func eqstring(s, t *ir.Node) (eqlen, eqmem *ir.Node) {
 // which can be used to construct interface equality comparison.
 // eqtab must be evaluated before eqdata, and shortcircuiting is required.
 func eqinterface(s, t *ir.Node) (eqtab, eqdata *ir.Node) {
-	if !types.Identical(s.Type, t.Type) {
-		base.Fatalf("eqinterface %v %v", s.Type, t.Type)
+	if !types.Identical(s.Type(), t.Type()) {
+		base.Fatalf("eqinterface %v %v", s.Type(), t.Type())
 	}
 	// func ifaceeq(tab *uintptr, x, y unsafe.Pointer) (ret bool)
 	// func efaceeq(typ *uintptr, x, y unsafe.Pointer) (ret bool)
 	var fn *ir.Node
-	if s.Type.IsEmptyInterface() {
+	if s.Type().IsEmptyInterface() {
 		fn = syslook("efaceeq")
 	} else {
 		fn = syslook("ifaceeq")
@@ -876,18 +876,18 @@ func eqinterface(s, t *ir.Node) (eqtab, eqdata *ir.Node) {
 	ttab := ir.Nod(ir.OITAB, t, nil)
 	sdata := ir.Nod(ir.OIDATA, s, nil)
 	tdata := ir.Nod(ir.OIDATA, t, nil)
-	sdata.Type = types.Types[types.TUNSAFEPTR]
-	tdata.Type = types.Types[types.TUNSAFEPTR]
+	sdata.SetType(types.Types[types.TUNSAFEPTR])
+	tdata.SetType(types.Types[types.TUNSAFEPTR])
 	sdata.SetTypecheck(1)
 	tdata.SetTypecheck(1)
 
 	call := ir.Nod(ir.OCALL, fn, nil)
-	call.List.Append(stab, sdata, tdata)
+	call.PtrList().Append(stab, sdata, tdata)
 	call = typecheck(call, ctxExpr|ctxMultiOK)
 
 	cmp := ir.Nod(ir.OEQ, stab, ttab)
 	cmp = typecheck(cmp, ctxExpr)
-	cmp.Type = types.Types[types.TBOOL]
+	cmp.SetType(types.Types[types.TBOOL])
 	return cmp, call
 }
 
@@ -899,12 +899,12 @@ func eqmem(p *ir.Node, q *ir.Node, field *types.Sym, size int64) *ir.Node {
 	nx = typecheck(nx, ctxExpr)
 	ny = typecheck(ny, ctxExpr)
 
-	fn, needsize := eqmemfunc(size, nx.Type.Elem())
+	fn, needsize := eqmemfunc(size, nx.Type().Elem())
 	call := ir.Nod(ir.OCALL, fn, nil)
-	call.List.Append(nx)
-	call.List.Append(ny)
+	call.PtrList().Append(nx)
+	call.PtrList().Append(ny)
 	if needsize {
-		call.List.Append(nodintconst(size))
+		call.PtrList().Append(nodintconst(size))
 	}
 
 	return call
diff --git a/src/cmd/compile/internal/gc/align.go b/src/cmd/compile/internal/gc/align.go
index 1bc8bf238f..edf7d263a3 100644
--- a/src/cmd/compile/internal/gc/align.go
+++ b/src/cmd/compile/internal/gc/align.go
@@ -126,11 +126,11 @@ func widstruct(errtype *types.Type, t *types.Type, o int64, flag int) int64 {
 			// NOTE(rsc): This comment may be stale.
 			// It's possible the ordering has changed and this is
 			// now the common case. I'm not sure.
-			if n.Name.Param.Stackcopy != nil {
-				n.Name.Param.Stackcopy.Xoffset = o
-				n.Xoffset = 0
+			if n.Name().Param.Stackcopy != nil {
+				n.Name().Param.Stackcopy.SetOffset(o)
+				n.SetOffset(0)
 			} else {
-				n.Xoffset = o
+				n.SetOffset(o)
 			}
 		}
 
@@ -198,7 +198,7 @@ func findTypeLoop(t *types.Type, path *[]*types.Type) bool {
 		}
 
 		*path = append(*path, t)
-		if p := ir.AsNode(t.Nod).Name.Param; p != nil && findTypeLoop(p.Ntype.Type, path) {
+		if p := ir.AsNode(t.Nod).Name().Param; p != nil && findTypeLoop(p.Ntype.Type(), path) {
 			return true
 		}
 		*path = (*path)[:len(*path)-1]
@@ -308,7 +308,7 @@ func dowidth(t *types.Type) {
 
 	lno := base.Pos
 	if ir.AsNode(t.Nod) != nil {
-		base.Pos = ir.AsNode(t.Nod).Pos
+		base.Pos = ir.AsNode(t.Nod).Pos()
 	}
 
 	t.Width = -2
diff --git a/src/cmd/compile/internal/gc/bexport.go b/src/cmd/compile/internal/gc/bexport.go
index ff33c6b5fc..e36903cbe0 100644
--- a/src/cmd/compile/internal/gc/bexport.go
+++ b/src/cmd/compile/internal/gc/bexport.go
@@ -15,11 +15,11 @@ type exporter struct {
 
 // markObject visits a reachable object.
 func (p *exporter) markObject(n *ir.Node) {
-	if n.Op == ir.ONAME && n.Class() == ir.PFUNC {
+	if n.Op() == ir.ONAME && n.Class() == ir.PFUNC {
 		inlFlood(n)
 	}
 
-	p.markType(n.Type)
+	p.markType(n.Type())
 }
 
 // markType recursively visits types reachable from t to identify
diff --git a/src/cmd/compile/internal/gc/bimport.go b/src/cmd/compile/internal/gc/bimport.go
index e2dd276f46..603710d6b1 100644
--- a/src/cmd/compile/internal/gc/bimport.go
+++ b/src/cmd/compile/internal/gc/bimport.go
@@ -10,7 +10,7 @@ import (
 )
 
 func npos(pos src.XPos, n *ir.Node) *ir.Node {
-	n.Pos = pos
+	n.SetPos(pos)
 	return n
 }
 
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index e68d710363..1b926ec17e 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -18,14 +18,14 @@ func (p *noder) funcLit(expr *syntax.FuncLit) *ir.Node {
 	ntype := p.typeExpr(expr.Type)
 
 	dcl := p.nod(expr, ir.ODCLFUNC, nil, nil)
-	fn := dcl.Func
+	fn := dcl.Func()
 	fn.SetIsHiddenClosure(Curfn != nil)
-	fn.Nname = newfuncnamel(p.pos(expr), ir.BlankNode.Sym, fn) // filled in by typecheckclosure
-	fn.Nname.Name.Param.Ntype = xtype
-	fn.Nname.Name.Defn = dcl
+	fn.Nname = newfuncnamel(p.pos(expr), ir.BlankNode.Sym(), fn) // filled in by typecheckclosure
+	fn.Nname.Name().Param.Ntype = xtype
+	fn.Nname.Name().Defn = dcl
 
 	clo := p.nod(expr, ir.OCLOSURE, nil, nil)
-	clo.Func = fn
+	clo.SetFunc(fn)
 	fn.ClosureType = ntype
 	fn.OClosure = clo
 
@@ -37,8 +37,8 @@ func (p *noder) funcLit(expr *syntax.FuncLit) *ir.Node {
 	// make the list of pointers for the closure call.
 	for _, v := range fn.ClosureVars.Slice() {
 		// Unlink from v1; see comment in syntax.go type Param for these fields.
-		v1 := v.Name.Defn
-		v1.Name.Param.Innermost = v.Name.Param.Outer
+		v1 := v.Name().Defn
+		v1.Name().Param.Innermost = v.Name().Param.Outer
 
 		// If the closure usage of v is not dense,
 		// we need to make it dense; now that we're out
@@ -68,7 +68,7 @@ func (p *noder) funcLit(expr *syntax.FuncLit) *ir.Node {
 		// obtains f3's v, creating it if necessary (as it is in the example).
 		//
 		// capturevars will decide whether to use v directly or &v.
-		v.Name.Param.Outer = oldname(v.Sym)
+		v.Name().Param.Outer = oldname(v.Sym())
 	}
 
 	return clo
@@ -79,7 +79,7 @@ func (p *noder) funcLit(expr *syntax.FuncLit) *ir.Node {
 // TODO: This creation of the named function should probably really be done in a
 // separate pass from type-checking.
 func typecheckclosure(clo *ir.Node, top int) {
-	fn := clo.Func
+	fn := clo.Func()
 	dcl := fn.Decl
 	// Set current associated iota value, so iota can be used inside
 	// function in ConstSpec, see issue #22344
@@ -88,7 +88,7 @@ func typecheckclosure(clo *ir.Node, top int) {
 	}
 
 	fn.ClosureType = typecheck(fn.ClosureType, ctxType)
-	clo.Type = fn.ClosureType.Type
+	clo.SetType(fn.ClosureType.Type())
 	fn.ClosureCalled = top&ctxCallee != 0
 
 	// Do not typecheck dcl twice, otherwise, we will end up pushing
@@ -99,22 +99,22 @@ func typecheckclosure(clo *ir.Node, top int) {
 	}
 
 	for _, ln := range fn.ClosureVars.Slice() {
-		n := ln.Name.Defn
-		if !n.Name.Captured() {
-			n.Name.SetCaptured(true)
-			if n.Name.Decldepth == 0 {
+		n := ln.Name().Defn
+		if !n.Name().Captured() {
+			n.Name().SetCaptured(true)
+			if n.Name().Decldepth == 0 {
 				base.Fatalf("typecheckclosure: var %S does not have decldepth assigned", n)
 			}
 
 			// Ignore assignments to the variable in straightline code
 			// preceding the first capturing by a closure.
-			if n.Name.Decldepth == decldepth {
-				n.Name.SetAssigned(false)
+			if n.Name().Decldepth == decldepth {
+				n.Name().SetAssigned(false)
 			}
 		}
 	}
 
-	fn.Nname.Sym = closurename(Curfn)
+	fn.Nname.SetSym(closurename(Curfn))
 	setNodeNameFunc(fn.Nname)
 	dcl = typecheck(dcl, ctxStmt)
 
@@ -122,12 +122,12 @@ func typecheckclosure(clo *ir.Node, top int) {
 	// At top level (in a variable initialization: curfn==nil) we're not
 	// ready to type check code yet; we'll check it later, because the
 	// underlying closure function we create is added to xtop.
-	if Curfn != nil && clo.Type != nil {
+	if Curfn != nil && clo.Type() != nil {
 		oldfn := Curfn
 		Curfn = dcl
 		olddd := decldepth
 		decldepth = 1
-		typecheckslice(dcl.Nbody.Slice(), ctxStmt)
+		typecheckslice(dcl.Body().Slice(), ctxStmt)
 		decldepth = olddd
 		Curfn = oldfn
 	}
@@ -146,7 +146,7 @@ func closurename(outerfunc *ir.Node) *types.Sym {
 	gen := &globClosgen
 
 	if outerfunc != nil {
-		if outerfunc.Func.OClosure != nil {
+		if outerfunc.Func().OClosure != nil {
 			prefix = ""
 		}
 
@@ -155,8 +155,8 @@ func closurename(outerfunc *ir.Node) *types.Sym {
 		// There may be multiple functions named "_". In those
 		// cases, we can't use their individual Closgens as it
 		// would lead to name clashes.
-		if !ir.IsBlank(outerfunc.Func.Nname) {
-			gen = &outerfunc.Func.Closgen
+		if !ir.IsBlank(outerfunc.Func().Nname) {
+			gen = &outerfunc.Func().Closgen
 		}
 	}
 
@@ -174,12 +174,12 @@ var capturevarscomplete bool
 // after capturing (effectively constant).
 func capturevars(dcl *ir.Node) {
 	lno := base.Pos
-	base.Pos = dcl.Pos
-	fn := dcl.Func
+	base.Pos = dcl.Pos()
+	fn := dcl.Func()
 	cvars := fn.ClosureVars.Slice()
 	out := cvars[:0]
 	for _, v := range cvars {
-		if v.Type == nil {
+		if v.Type() == nil {
 			// If v.Type is nil, it means v looked like it
 			// was going to be used in the closure, but
 			// isn't. This happens in struct literals like
@@ -192,29 +192,29 @@ func capturevars(dcl *ir.Node) {
 
 		// type check the & of closed variables outside the closure,
 		// so that the outer frame also grabs them and knows they escape.
-		dowidth(v.Type)
+		dowidth(v.Type())
 
-		outer := v.Name.Param.Outer
-		outermost := v.Name.Defn
+		outer := v.Name().Param.Outer
+		outermost := v.Name().Defn
 
 		// out parameters will be assigned to implicitly upon return.
-		if outermost.Class() != ir.PPARAMOUT && !outermost.Name.Addrtaken() && !outermost.Name.Assigned() && v.Type.Width <= 128 {
-			v.Name.SetByval(true)
+		if outermost.Class() != ir.PPARAMOUT && !outermost.Name().Addrtaken() && !outermost.Name().Assigned() && v.Type().Width <= 128 {
+			v.Name().SetByval(true)
 		} else {
-			outermost.Name.SetAddrtaken(true)
+			outermost.Name().SetAddrtaken(true)
 			outer = ir.Nod(ir.OADDR, outer, nil)
 		}
 
 		if base.Flag.LowerM > 1 {
 			var name *types.Sym
-			if v.Name.Curfn != nil && v.Name.Curfn.Func.Nname != nil {
-				name = v.Name.Curfn.Func.Nname.Sym
+			if v.Name().Curfn != nil && v.Name().Curfn.Func().Nname != nil {
+				name = v.Name().Curfn.Func().Nname.Sym()
 			}
 			how := "ref"
-			if v.Name.Byval() {
+			if v.Name().Byval() {
 				how = "value"
 			}
-			base.WarnfAt(v.Pos, "%v capturing by %s: %v (addr=%v assign=%v width=%d)", name, how, v.Sym, outermost.Name.Addrtaken(), outermost.Name.Assigned(), int32(v.Type.Width))
+			base.WarnfAt(v.Pos(), "%v capturing by %s: %v (addr=%v assign=%v width=%d)", name, how, v.Sym(), outermost.Name().Addrtaken(), outermost.Name().Assigned(), int32(v.Type().Width))
 		}
 
 		outer = typecheck(outer, ctxExpr)
@@ -229,8 +229,8 @@ func capturevars(dcl *ir.Node) {
 // It transform closure bodies to properly reference captured variables.
 func transformclosure(dcl *ir.Node) {
 	lno := base.Pos
-	base.Pos = dcl.Pos
-	fn := dcl.Func
+	base.Pos = dcl.Pos()
+	fn := dcl.Func()
 
 	if fn.ClosureCalled {
 		// If the closure is directly called, we transform it to a plain function call
@@ -255,33 +255,33 @@ func transformclosure(dcl *ir.Node) {
 		var params []*types.Field
 		var decls []*ir.Node
 		for _, v := range fn.ClosureVars.Slice() {
-			if !v.Name.Byval() {
+			if !v.Name().Byval() {
 				// If v of type T is captured by reference,
 				// we introduce function param &v *T
 				// and v remains PAUTOHEAP with &v heapaddr
 				// (accesses will implicitly deref &v).
-				addr := NewName(lookup("&" + v.Sym.Name))
-				addr.Type = types.NewPtr(v.Type)
-				v.Name.Param.Heapaddr = addr
+				addr := NewName(lookup("&" + v.Sym().Name))
+				addr.SetType(types.NewPtr(v.Type()))
+				v.Name().Param.Heapaddr = addr
 				v = addr
 			}
 
 			v.SetClass(ir.PPARAM)
 			decls = append(decls, v)
 
-			fld := types.NewField(src.NoXPos, v.Sym, v.Type)
+			fld := types.NewField(src.NoXPos, v.Sym(), v.Type())
 			fld.Nname = ir.AsTypesNode(v)
 			params = append(params, fld)
 		}
 
 		if len(params) > 0 {
 			// Prepend params and decls.
-			f.Type.Params().SetFields(append(params, f.Type.Params().FieldSlice()...))
+			f.Type().Params().SetFields(append(params, f.Type().Params().FieldSlice()...))
 			fn.Dcl = append(decls, fn.Dcl...)
 		}
 
-		dowidth(f.Type)
-		dcl.Type = f.Type // update type of ODCLFUNC
+		dowidth(f.Type())
+		dcl.SetType(f.Type()) // update type of ODCLFUNC
 	} else {
 		// The closure is not called, so it is going to stay as closure.
 		var body []*ir.Node
@@ -290,15 +290,15 @@ func transformclosure(dcl *ir.Node) {
 			// cv refers to the field inside of closure OSTRUCTLIT.
 			cv := ir.Nod(ir.OCLOSUREVAR, nil, nil)
 
-			cv.Type = v.Type
-			if !v.Name.Byval() {
-				cv.Type = types.NewPtr(v.Type)
+			cv.SetType(v.Type())
+			if !v.Name().Byval() {
+				cv.SetType(types.NewPtr(v.Type()))
 			}
-			offset = Rnd(offset, int64(cv.Type.Align))
-			cv.Xoffset = offset
-			offset += cv.Type.Width
+			offset = Rnd(offset, int64(cv.Type().Align))
+			cv.SetOffset(offset)
+			offset += cv.Type().Width
 
-			if v.Name.Byval() && v.Type.Width <= int64(2*Widthptr) {
+			if v.Name().Byval() && v.Type().Width <= int64(2*Widthptr) {
 				// If it is a small variable captured by value, downgrade it to PAUTO.
 				v.SetClass(ir.PAUTO)
 				fn.Dcl = append(fn.Dcl, v)
@@ -306,14 +306,14 @@ func transformclosure(dcl *ir.Node) {
 			} else {
 				// Declare variable holding addresses taken from closure
 				// and initialize in entry prologue.
-				addr := NewName(lookup("&" + v.Sym.Name))
-				addr.Type = types.NewPtr(v.Type)
+				addr := NewName(lookup("&" + v.Sym().Name))
+				addr.SetType(types.NewPtr(v.Type()))
 				addr.SetClass(ir.PAUTO)
-				addr.Name.SetUsed(true)
-				addr.Name.Curfn = dcl
+				addr.Name().SetUsed(true)
+				addr.Name().Curfn = dcl
 				fn.Dcl = append(fn.Dcl, addr)
-				v.Name.Param.Heapaddr = addr
-				if v.Name.Byval() {
+				v.Name().Param.Heapaddr = addr
+				if v.Name().Byval() {
 					cv = ir.Nod(ir.OADDR, cv, nil)
 				}
 				body = append(body, ir.Nod(ir.OAS, addr, cv))
@@ -333,21 +333,21 @@ func transformclosure(dcl *ir.Node) {
 // hasemptycvars reports whether closure clo has an
 // empty list of captured vars.
 func hasemptycvars(clo *ir.Node) bool {
-	return clo.Func.ClosureVars.Len() == 0
+	return clo.Func().ClosureVars.Len() == 0
 }
 
 // closuredebugruntimecheck applies boilerplate checks for debug flags
 // and compiling runtime
 func closuredebugruntimecheck(clo *ir.Node) {
 	if base.Debug.Closure > 0 {
-		if clo.Esc == EscHeap {
-			base.WarnfAt(clo.Pos, "heap closure, captured vars = %v", clo.Func.ClosureVars)
+		if clo.Esc() == EscHeap {
+			base.WarnfAt(clo.Pos(), "heap closure, captured vars = %v", clo.Func().ClosureVars)
 		} else {
-			base.WarnfAt(clo.Pos, "stack closure, captured vars = %v", clo.Func.ClosureVars)
+			base.WarnfAt(clo.Pos(), "stack closure, captured vars = %v", clo.Func().ClosureVars)
 		}
 	}
-	if base.Flag.CompilingRuntime && clo.Esc == EscHeap {
-		base.ErrorfAt(clo.Pos, "heap-allocated closure, not allowed in runtime")
+	if base.Flag.CompilingRuntime && clo.Esc() == EscHeap {
+		base.ErrorfAt(clo.Pos(), "heap-allocated closure, not allowed in runtime")
 	}
 }
 
@@ -371,12 +371,12 @@ func closureType(clo *ir.Node) *types.Type {
 	fields := []*ir.Node{
 		namedfield(".F", types.Types[types.TUINTPTR]),
 	}
-	for _, v := range clo.Func.ClosureVars.Slice() {
-		typ := v.Type
-		if !v.Name.Byval() {
+	for _, v := range clo.Func().ClosureVars.Slice() {
+		typ := v.Type()
+		if !v.Name().Byval() {
 			typ = types.NewPtr(typ)
 		}
-		fields = append(fields, symfield(v.Sym, typ))
+		fields = append(fields, symfield(v.Sym(), typ))
 	}
 	typ := tostruct(fields)
 	typ.SetNoalg(true)
@@ -384,12 +384,12 @@ func closureType(clo *ir.Node) *types.Type {
 }
 
 func walkclosure(clo *ir.Node, init *ir.Nodes) *ir.Node {
-	fn := clo.Func
+	fn := clo.Func()
 
 	// If no closure vars, don't bother wrapping.
 	if hasemptycvars(clo) {
 		if base.Debug.Closure > 0 {
-			base.WarnfAt(clo.Pos, "closure converted to global")
+			base.WarnfAt(clo.Pos(), "closure converted to global")
 		}
 		return fn.Nname
 	}
@@ -398,21 +398,21 @@ func walkclosure(clo *ir.Node, init *ir.Nodes) *ir.Node {
 	typ := closureType(clo)
 
 	clos := ir.Nod(ir.OCOMPLIT, nil, typenod(typ))
-	clos.Esc = clo.Esc
-	clos.List.Set(append([]*ir.Node{ir.Nod(ir.OCFUNC, fn.Nname, nil)}, fn.ClosureEnter.Slice()...))
+	clos.SetEsc(clo.Esc())
+	clos.PtrList().Set(append([]*ir.Node{ir.Nod(ir.OCFUNC, fn.Nname, nil)}, fn.ClosureEnter.Slice()...))
 
 	clos = ir.Nod(ir.OADDR, clos, nil)
-	clos.Esc = clo.Esc
+	clos.SetEsc(clo.Esc())
 
 	// Force type conversion from *struct to the func type.
-	clos = convnop(clos, clo.Type)
+	clos = convnop(clos, clo.Type())
 
 	// non-escaping temp to use, if any.
 	if x := prealloc[clo]; x != nil {
-		if !types.Identical(typ, x.Type) {
+		if !types.Identical(typ, x.Type()) {
 			panic("closure type does not match order's assigned type")
 		}
-		clos.Left.Right = x
+		clos.Left().SetRight(x)
 		delete(prealloc, clo)
 	}
 
@@ -420,7 +420,7 @@ func walkclosure(clo *ir.Node, init *ir.Nodes) *ir.Node {
 }
 
 func typecheckpartialcall(dot *ir.Node, sym *types.Sym) {
-	switch dot.Op {
+	switch dot.Op() {
 	case ir.ODOTINTER, ir.ODOTMETH:
 		break
 
@@ -429,19 +429,19 @@ func typecheckpartialcall(dot *ir.Node, sym *types.Sym) {
 	}
 
 	// Create top-level function.
-	dcl := makepartialcall(dot, dot.Type, sym)
-	dcl.Func.SetWrapper(true)
-	dot.Op = ir.OCALLPART
-	dot.Right = NewName(sym)
-	dot.Type = dcl.Type
-	dot.Func = dcl.Func
+	dcl := makepartialcall(dot, dot.Type(), sym)
+	dcl.Func().SetWrapper(true)
+	dot.SetOp(ir.OCALLPART)
+	dot.SetRight(NewName(sym))
+	dot.SetType(dcl.Type())
+	dot.SetFunc(dcl.Func())
 	dot.SetOpt(nil) // clear types.Field from ODOTMETH
 }
 
 // makepartialcall returns a DCLFUNC node representing the wrapper function (*-fm) needed
 // for partial calls.
 func makepartialcall(dot *ir.Node, t0 *types.Type, meth *types.Sym) *ir.Node {
-	rcvrtype := dot.Left.Type
+	rcvrtype := dot.Left().Type()
 	sym := methodSymSuffix(rcvrtype, meth, "-fm")
 
 	if sym.Uniq() {
@@ -465,52 +465,52 @@ func makepartialcall(dot *ir.Node, t0 *types.Type, meth *types.Sym) *ir.Node {
 	// case. See issue 29389.
 
 	tfn := ir.Nod(ir.OTFUNC, nil, nil)
-	tfn.List.Set(structargs(t0.Params(), true))
-	tfn.Rlist.Set(structargs(t0.Results(), false))
+	tfn.PtrList().Set(structargs(t0.Params(), true))
+	tfn.PtrRlist().Set(structargs(t0.Results(), false))
 
 	dcl := dclfunc(sym, tfn)
-	fn := dcl.Func
+	fn := dcl.Func()
 	fn.SetDupok(true)
 	fn.SetNeedctxt(true)
 
-	tfn.Type.SetPkg(t0.Pkg())
+	tfn.Type().SetPkg(t0.Pkg())
 
 	// Declare and initialize variable holding receiver.
 
 	cv := ir.Nod(ir.OCLOSUREVAR, nil, nil)
-	cv.Type = rcvrtype
-	cv.Xoffset = Rnd(int64(Widthptr), int64(cv.Type.Align))
+	cv.SetType(rcvrtype)
+	cv.SetOffset(Rnd(int64(Widthptr), int64(cv.Type().Align)))
 
 	ptr := NewName(lookup(".this"))
 	declare(ptr, ir.PAUTO)
-	ptr.Name.SetUsed(true)
+	ptr.Name().SetUsed(true)
 	var body []*ir.Node
 	if rcvrtype.IsPtr() || rcvrtype.IsInterface() {
-		ptr.Type = rcvrtype
+		ptr.SetType(rcvrtype)
 		body = append(body, ir.Nod(ir.OAS, ptr, cv))
 	} else {
-		ptr.Type = types.NewPtr(rcvrtype)
+		ptr.SetType(types.NewPtr(rcvrtype))
 		body = append(body, ir.Nod(ir.OAS, ptr, ir.Nod(ir.OADDR, cv, nil)))
 	}
 
 	call := ir.Nod(ir.OCALL, nodSym(ir.OXDOT, ptr, meth), nil)
-	call.List.Set(paramNnames(tfn.Type))
-	call.SetIsDDD(tfn.Type.IsVariadic())
+	call.PtrList().Set(paramNnames(tfn.Type()))
+	call.SetIsDDD(tfn.Type().IsVariadic())
 	if t0.NumResults() != 0 {
 		n := ir.Nod(ir.ORETURN, nil, nil)
-		n.List.Set1(call)
+		n.PtrList().Set1(call)
 		call = n
 	}
 	body = append(body, call)
 
-	dcl.Nbody.Set(body)
+	dcl.PtrBody().Set(body)
 	funcbody()
 
 	dcl = typecheck(dcl, ctxStmt)
 	// Need to typecheck the body of the just-generated wrapper.
 	// typecheckslice() requires that Curfn is set when processing an ORETURN.
 	Curfn = dcl
-	typecheckslice(dcl.Nbody.Slice(), ctxStmt)
+	typecheckslice(dcl.Body().Slice(), ctxStmt)
 	sym.Def = ir.AsTypesNode(dcl)
 	xtop = append(xtop, dcl)
 	Curfn = savecurfn
@@ -525,7 +525,7 @@ func makepartialcall(dot *ir.Node, t0 *types.Type, meth *types.Sym) *ir.Node {
 func partialCallType(n *ir.Node) *types.Type {
 	t := tostruct([]*ir.Node{
 		namedfield("F", types.Types[types.TUINTPTR]),
-		namedfield("R", n.Left.Type),
+		namedfield("R", n.Left().Type()),
 	})
 	t.SetNoalg(true)
 	return t
@@ -539,13 +539,13 @@ func walkpartialcall(n *ir.Node, init *ir.Nodes) *ir.Node {
 	//
 	// Like walkclosure above.
 
-	if n.Left.Type.IsInterface() {
+	if n.Left().Type().IsInterface() {
 		// Trigger panic for method on nil interface now.
 		// Otherwise it happens in the wrapper and is confusing.
-		n.Left = cheapexpr(n.Left, init)
-		n.Left = walkexpr(n.Left, nil)
+		n.SetLeft(cheapexpr(n.Left(), init))
+		n.SetLeft(walkexpr(n.Left(), nil))
 
-		tab := ir.Nod(ir.OITAB, n.Left, nil)
+		tab := ir.Nod(ir.OITAB, n.Left(), nil)
 		tab = typecheck(tab, ctxExpr)
 
 		c := ir.Nod(ir.OCHECKNIL, tab, nil)
@@ -556,21 +556,21 @@ func walkpartialcall(n *ir.Node, init *ir.Nodes) *ir.Node {
 	typ := partialCallType(n)
 
 	clos := ir.Nod(ir.OCOMPLIT, nil, typenod(typ))
-	clos.Esc = n.Esc
-	clos.List.Set2(ir.Nod(ir.OCFUNC, n.Func.Nname, nil), n.Left)
+	clos.SetEsc(n.Esc())
+	clos.PtrList().Set2(ir.Nod(ir.OCFUNC, n.Func().Nname, nil), n.Left())
 
 	clos = ir.Nod(ir.OADDR, clos, nil)
-	clos.Esc = n.Esc
+	clos.SetEsc(n.Esc())
 
 	// Force type conversion from *struct to the func type.
-	clos = convnop(clos, n.Type)
+	clos = convnop(clos, n.Type())
 
 	// non-escaping temp to use, if any.
 	if x := prealloc[n]; x != nil {
-		if !types.Identical(typ, x.Type) {
+		if !types.Identical(typ, x.Type()) {
 			panic("partial call type does not match order's assigned type")
 		}
-		clos.Left.Right = x
+		clos.Left().SetRight(x)
 		delete(prealloc, n)
 	}
 
@@ -580,14 +580,14 @@ func walkpartialcall(n *ir.Node, init *ir.Nodes) *ir.Node {
 // callpartMethod returns the *types.Field representing the method
 // referenced by method value n.
 func callpartMethod(n *ir.Node) *types.Field {
-	if n.Op != ir.OCALLPART {
+	if n.Op() != ir.OCALLPART {
 		base.Fatalf("expected OCALLPART, got %v", n)
 	}
 
 	// TODO(mdempsky): Optimize this. If necessary,
 	// makepartialcall could save m for us somewhere.
 	var m *types.Field
-	if lookdot0(n.Right.Sym, n.Left.Type, &m, false) != 1 {
+	if lookdot0(n.Right().Sym(), n.Left().Type(), &m, false) != 1 {
 		base.Fatalf("failed to find field for OCALLPART")
 	}
 
diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index a557e20d46..27e54b46c8 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -106,30 +106,30 @@ func convlit1(n *ir.Node, t *types.Type, explicit bool, context func() string) *
 		base.Fatalf("bad conversion to untyped: %v", t)
 	}
 
-	if n == nil || n.Type == nil {
+	if n == nil || n.Type() == nil {
 		// Allow sloppy callers.
 		return n
 	}
-	if !n.Type.IsUntyped() {
+	if !n.Type().IsUntyped() {
 		// Already typed; nothing to do.
 		return n
 	}
 
-	if n.Op == ir.OLITERAL || n.Op == ir.ONIL {
+	if n.Op() == ir.OLITERAL || n.Op() == ir.ONIL {
 		// Can't always set n.Type directly on OLITERAL nodes.
 		// See discussion on CL 20813.
 		n = n.RawCopy()
 	}
 
 	// Nil is technically not a constant, so handle it specially.
-	if n.Type.Etype == types.TNIL {
-		if n.Op != ir.ONIL {
-			base.Fatalf("unexpected op: %v (%v)", n, n.Op)
+	if n.Type().Etype == types.TNIL {
+		if n.Op() != ir.ONIL {
+			base.Fatalf("unexpected op: %v (%v)", n, n.Op())
 		}
 		if t == nil {
 			base.Errorf("use of untyped nil")
 			n.SetDiag(true)
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
@@ -138,15 +138,15 @@ func convlit1(n *ir.Node, t *types.Type, explicit bool, context func() string) *
 			return n
 		}
 
-		n.Type = t
+		n.SetType(t)
 		return n
 	}
 
 	if t == nil || !ir.OKForConst[t.Etype] {
-		t = defaultType(n.Type)
+		t = defaultType(n.Type())
 	}
 
-	switch n.Op {
+	switch n.Op() {
 	default:
 		base.Fatalf("unexpected untyped expression: %v", n)
 
@@ -155,60 +155,60 @@ func convlit1(n *ir.Node, t *types.Type, explicit bool, context func() string) *
 		if v.Kind() == constant.Unknown {
 			break
 		}
-		n.Type = t
+		n.SetType(t)
 		n.SetVal(v)
 		return n
 
 	case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT, ir.OREAL, ir.OIMAG:
-		ot := operandType(n.Op, t)
+		ot := operandType(n.Op(), t)
 		if ot == nil {
 			n = defaultlit(n, nil)
 			break
 		}
 
-		n.Left = convlit(n.Left, ot)
-		if n.Left.Type == nil {
-			n.Type = nil
+		n.SetLeft(convlit(n.Left(), ot))
+		if n.Left().Type() == nil {
+			n.SetType(nil)
 			return n
 		}
-		n.Type = t
+		n.SetType(t)
 		return n
 
 	case ir.OADD, ir.OSUB, ir.OMUL, ir.ODIV, ir.OMOD, ir.OOR, ir.OXOR, ir.OAND, ir.OANDNOT, ir.OOROR, ir.OANDAND, ir.OCOMPLEX:
-		ot := operandType(n.Op, t)
+		ot := operandType(n.Op(), t)
 		if ot == nil {
 			n = defaultlit(n, nil)
 			break
 		}
 
-		n.Left = convlit(n.Left, ot)
-		n.Right = convlit(n.Right, ot)
-		if n.Left.Type == nil || n.Right.Type == nil {
-			n.Type = nil
+		n.SetLeft(convlit(n.Left(), ot))
+		n.SetRight(convlit(n.Right(), ot))
+		if n.Left().Type() == nil || n.Right().Type() == nil {
+			n.SetType(nil)
 			return n
 		}
-		if !types.Identical(n.Left.Type, n.Right.Type) {
-			base.Errorf("invalid operation: %v (mismatched types %v and %v)", n, n.Left.Type, n.Right.Type)
-			n.Type = nil
+		if !types.Identical(n.Left().Type(), n.Right().Type()) {
+			base.Errorf("invalid operation: %v (mismatched types %v and %v)", n, n.Left().Type(), n.Right().Type())
+			n.SetType(nil)
 			return n
 		}
 
-		n.Type = t
+		n.SetType(t)
 		return n
 
 	case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
 		if !t.IsBoolean() {
 			break
 		}
-		n.Type = t
+		n.SetType(t)
 		return n
 
 	case ir.OLSH, ir.ORSH:
-		n.Left = convlit1(n.Left, t, explicit, nil)
-		n.Type = n.Left.Type
-		if n.Type != nil && !n.Type.IsInteger() {
-			base.Errorf("invalid operation: %v (shift of type %v)", n, n.Type)
-			n.Type = nil
+		n.SetLeft(convlit1(n.Left(), t, explicit, nil))
+		n.SetType(n.Left().Type())
+		if n.Type() != nil && !n.Type().IsInteger() {
+			base.Errorf("invalid operation: %v (shift of type %v)", n, n.Type())
+			n.SetType(nil)
 		}
 		return n
 	}
@@ -225,7 +225,7 @@ func convlit1(n *ir.Node, t *types.Type, explicit bool, context func() string) *
 		}
 		n.SetDiag(true)
 	}
-	n.Type = nil
+	n.SetType(nil)
 	return n
 }
 
@@ -439,75 +439,75 @@ var tokenForOp = [...]token.Token{
 // Otherwise, evalConst returns a new OLITERAL with the same value as n,
 // and with .Orig pointing back to n.
 func evalConst(n *ir.Node) *ir.Node {
-	nl, nr := n.Left, n.Right
+	nl, nr := n.Left(), n.Right()
 
 	// Pick off just the opcodes that can be constant evaluated.
-	switch op := n.Op; op {
+	switch op := n.Op(); op {
 	case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT:
-		if nl.Op == ir.OLITERAL {
+		if nl.Op() == ir.OLITERAL {
 			var prec uint
-			if n.Type.IsUnsigned() {
-				prec = uint(n.Type.Size() * 8)
+			if n.Type().IsUnsigned() {
+				prec = uint(n.Type().Size() * 8)
 			}
 			return origConst(n, constant.UnaryOp(tokenForOp[op], nl.Val(), prec))
 		}
 
 	case ir.OADD, ir.OSUB, ir.OMUL, ir.ODIV, ir.OMOD, ir.OOR, ir.OXOR, ir.OAND, ir.OANDNOT, ir.OOROR, ir.OANDAND:
-		if nl.Op == ir.OLITERAL && nr.Op == ir.OLITERAL {
+		if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
 			rval := nr.Val()
 
 			// check for divisor underflow in complex division (see issue 20227)
-			if op == ir.ODIV && n.Type.IsComplex() && constant.Sign(square(constant.Real(rval))) == 0 && constant.Sign(square(constant.Imag(rval))) == 0 {
+			if op == ir.ODIV && n.Type().IsComplex() && constant.Sign(square(constant.Real(rval))) == 0 && constant.Sign(square(constant.Imag(rval))) == 0 {
 				base.Errorf("complex division by zero")
-				n.Type = nil
+				n.SetType(nil)
 				return n
 			}
 			if (op == ir.ODIV || op == ir.OMOD) && constant.Sign(rval) == 0 {
 				base.Errorf("division by zero")
-				n.Type = nil
+				n.SetType(nil)
 				return n
 			}
 
 			tok := tokenForOp[op]
-			if op == ir.ODIV && n.Type.IsInteger() {
+			if op == ir.ODIV && n.Type().IsInteger() {
 				tok = token.QUO_ASSIGN // integer division
 			}
 			return origConst(n, constant.BinaryOp(nl.Val(), tok, rval))
 		}
 
 	case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
-		if nl.Op == ir.OLITERAL && nr.Op == ir.OLITERAL {
+		if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
 			return origBoolConst(n, constant.Compare(nl.Val(), tokenForOp[op], nr.Val()))
 		}
 
 	case ir.OLSH, ir.ORSH:
-		if nl.Op == ir.OLITERAL && nr.Op == ir.OLITERAL {
+		if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
 			// shiftBound from go/types; "so we can express smallestFloat64"
 			const shiftBound = 1023 - 1 + 52
 			s, ok := constant.Uint64Val(nr.Val())
 			if !ok || s > shiftBound {
 				base.Errorf("invalid shift count %v", nr)
-				n.Type = nil
+				n.SetType(nil)
 				break
 			}
 			return origConst(n, constant.Shift(toint(nl.Val()), tokenForOp[op], uint(s)))
 		}
 
 	case ir.OCONV, ir.ORUNESTR:
-		if ir.OKForConst[n.Type.Etype] && nl.Op == ir.OLITERAL {
-			return origConst(n, convertVal(nl.Val(), n.Type, true))
+		if ir.OKForConst[n.Type().Etype] && nl.Op() == ir.OLITERAL {
+			return origConst(n, convertVal(nl.Val(), n.Type(), true))
 		}
 
 	case ir.OCONVNOP:
-		if ir.OKForConst[n.Type.Etype] && nl.Op == ir.OLITERAL {
+		if ir.OKForConst[n.Type().Etype] && nl.Op() == ir.OLITERAL {
 			// set so n.Orig gets OCONV instead of OCONVNOP
-			n.Op = ir.OCONV
+			n.SetOp(ir.OCONV)
 			return origConst(n, nl.Val())
 		}
 
 	case ir.OADDSTR:
 		// Merge adjacent constants in the argument list.
-		s := n.List.Slice()
+		s := n.List().Slice()
 		need := 0
 		for i := 0; i < len(s); i++ {
 			if i == 0 || !ir.IsConst(s[i-1], constant.String) || !ir.IsConst(s[i], constant.String) {
@@ -537,7 +537,7 @@ func evalConst(n *ir.Node) *ir.Node {
 				}
 
 				nl := origConst(s[i], constant.MakeString(strings.Join(strs, "")))
-				nl.Orig = nl // it's bigger than just s[i]
+				nl.SetOrig(nl) // it's bigger than just s[i]
 				newList = append(newList, nl)
 				i = i2 - 1
 			} else {
@@ -546,18 +546,18 @@ func evalConst(n *ir.Node) *ir.Node {
 		}
 
 		n = ir.Copy(n)
-		n.List.Set(newList)
+		n.PtrList().Set(newList)
 		return n
 
 	case ir.OCAP, ir.OLEN:
-		switch nl.Type.Etype {
+		switch nl.Type().Etype {
 		case types.TSTRING:
 			if ir.IsConst(nl, constant.String) {
 				return origIntConst(n, int64(len(nl.StringVal())))
 			}
 		case types.TARRAY:
 			if !hascallchan(nl) {
-				return origIntConst(n, nl.Type.NumElem())
+				return origIntConst(n, nl.Type().NumElem())
 			}
 		}
 
@@ -565,17 +565,17 @@ func evalConst(n *ir.Node) *ir.Node {
 		return origIntConst(n, evalunsafe(n))
 
 	case ir.OREAL:
-		if nl.Op == ir.OLITERAL {
+		if nl.Op() == ir.OLITERAL {
 			return origConst(n, constant.Real(nl.Val()))
 		}
 
 	case ir.OIMAG:
-		if nl.Op == ir.OLITERAL {
+		if nl.Op() == ir.OLITERAL {
 			return origConst(n, constant.Imag(nl.Val()))
 		}
 
 	case ir.OCOMPLEX:
-		if nl.Op == ir.OLITERAL && nr.Op == ir.OLITERAL {
+		if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
 			return origConst(n, makeComplex(nl.Val(), nr.Val()))
 		}
 	}
@@ -621,7 +621,7 @@ var overflowNames = [...]string{
 // origConst returns an OLITERAL with orig n and value v.
 func origConst(n *ir.Node, v constant.Value) *ir.Node {
 	lno := setlineno(n)
-	v = convertVal(v, n.Type, false)
+	v = convertVal(v, n.Type(), false)
 	base.Pos = lno
 
 	switch v.Kind() {
@@ -631,19 +631,19 @@ func origConst(n *ir.Node, v constant.Value) *ir.Node {
 		}
 		fallthrough
 	case constant.Unknown:
-		what := overflowNames[n.Op]
+		what := overflowNames[n.Op()]
 		if what == "" {
-			base.Fatalf("unexpected overflow: %v", n.Op)
+			base.Fatalf("unexpected overflow: %v", n.Op())
 		}
-		base.ErrorfAt(n.Pos, "constant %v overflow", what)
-		n.Type = nil
+		base.ErrorfAt(n.Pos(), "constant %v overflow", what)
+		n.SetType(nil)
 		return n
 	}
 
 	orig := n
-	n = ir.NodAt(orig.Pos, ir.OLITERAL, nil, nil)
-	n.Orig = orig
-	n.Type = orig.Type
+	n = ir.NodAt(orig.Pos(), ir.OLITERAL, nil, nil)
+	n.SetOrig(orig)
+	n.SetType(orig.Type())
 	n.SetVal(v)
 	return n
 }
@@ -663,16 +663,16 @@ func origIntConst(n *ir.Node, v int64) *ir.Node {
 // The results of defaultlit2 MUST be assigned back to l and r, e.g.
 // 	n.Left, n.Right = defaultlit2(n.Left, n.Right, force)
 func defaultlit2(l *ir.Node, r *ir.Node, force bool) (*ir.Node, *ir.Node) {
-	if l.Type == nil || r.Type == nil {
+	if l.Type() == nil || r.Type() == nil {
 		return l, r
 	}
-	if !l.Type.IsUntyped() {
-		r = convlit(r, l.Type)
+	if !l.Type().IsUntyped() {
+		r = convlit(r, l.Type())
 		return l, r
 	}
 
-	if !r.Type.IsUntyped() {
-		l = convlit(l, r.Type)
+	if !r.Type().IsUntyped() {
+		l = convlit(l, r.Type())
 		return l, r
 	}
 
@@ -681,17 +681,17 @@ func defaultlit2(l *ir.Node, r *ir.Node, force bool) (*ir.Node, *ir.Node) {
 	}
 
 	// Can't mix bool with non-bool, string with non-string, or nil with anything (untyped).
-	if l.Type.IsBoolean() != r.Type.IsBoolean() {
+	if l.Type().IsBoolean() != r.Type().IsBoolean() {
 		return l, r
 	}
-	if l.Type.IsString() != r.Type.IsString() {
+	if l.Type().IsString() != r.Type().IsString() {
 		return l, r
 	}
 	if ir.IsNil(l) || ir.IsNil(r) {
 		return l, r
 	}
 
-	t := defaultType(mixUntyped(l.Type, r.Type))
+	t := defaultType(mixUntyped(l.Type(), r.Type()))
 	l = convlit(l, t)
 	r = convlit(r, t)
 	return l, r
@@ -748,7 +748,7 @@ func defaultType(t *types.Type) *types.Type {
 }
 
 func smallintconst(n *ir.Node) bool {
-	if n.Op == ir.OLITERAL {
+	if n.Op() == ir.OLITERAL {
 		v, ok := constant.Int64Val(n.Val())
 		return ok && int64(int32(v)) == v
 	}
@@ -761,10 +761,10 @@ func smallintconst(n *ir.Node) bool {
 // integer, or negative, it returns -1. If n is too large, it
 // returns -2.
 func indexconst(n *ir.Node) int64 {
-	if n.Op != ir.OLITERAL {
+	if n.Op() != ir.OLITERAL {
 		return -1
 	}
-	if !n.Type.IsInteger() && n.Type.Etype != types.TIDEAL {
+	if !n.Type().IsInteger() && n.Type().Etype != types.TIDEAL {
 		return -1
 	}
 
@@ -784,14 +784,14 @@ func indexconst(n *ir.Node) int64 {
 // Expressions derived from nil, like string([]byte(nil)), while they
 // may be known at compile time, are not Go language constants.
 func isGoConst(n *ir.Node) bool {
-	return n.Op == ir.OLITERAL
+	return n.Op() == ir.OLITERAL
 }
 
 func hascallchan(n *ir.Node) bool {
 	if n == nil {
 		return false
 	}
-	switch n.Op {
+	switch n.Op() {
 	case ir.OAPPEND,
 		ir.OCALL,
 		ir.OCALLFUNC,
@@ -815,15 +815,15 @@ func hascallchan(n *ir.Node) bool {
 		return true
 	}
 
-	if hascallchan(n.Left) || hascallchan(n.Right) {
+	if hascallchan(n.Left()) || hascallchan(n.Right()) {
 		return true
 	}
-	for _, n1 := range n.List.Slice() {
+	for _, n1 := range n.List().Slice() {
 		if hascallchan(n1) {
 			return true
 		}
 	}
-	for _, n2 := range n.Rlist.Slice() {
+	for _, n2 := range n.Rlist().Slice() {
 		if hascallchan(n2) {
 			return true
 		}
@@ -852,14 +852,14 @@ type constSetKey struct {
 //
 // n must not be an untyped constant.
 func (s *constSet) add(pos src.XPos, n *ir.Node, what, where string) {
-	if n.Op == ir.OCONVIFACE && n.Implicit() {
-		n = n.Left
+	if n.Op() == ir.OCONVIFACE && n.Implicit() {
+		n = n.Left()
 	}
 
 	if !isGoConst(n) {
 		return
 	}
-	if n.Type.IsUntyped() {
+	if n.Type().IsUntyped() {
 		base.Fatalf("%v is untyped", n)
 	}
 
@@ -878,7 +878,7 @@ func (s *constSet) add(pos src.XPos, n *ir.Node, what, where string) {
 	// #21866 by treating all type aliases like byte/uint8 and
 	// rune/int32.
 
-	typ := n.Type
+	typ := n.Type()
 	switch typ {
 	case types.Bytetype:
 		typ = types.Types[types.TUINT8]
@@ -888,7 +888,7 @@ func (s *constSet) add(pos src.XPos, n *ir.Node, what, where string) {
 	k := constSetKey{typ, ir.ConstValue(n)}
 
 	if hasUniquePos(n) {
-		pos = n.Pos
+		pos = n.Pos()
 	}
 
 	if s.m == nil {
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 6fee872fd2..8b3274890f 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -64,78 +64,78 @@ func declare(n *ir.Node, ctxt ir.Class) {
 		return
 	}
 
-	if n.Name == nil {
+	if n.Name() == nil {
 		// named OLITERAL needs Name; most OLITERALs don't.
-		n.Name = new(ir.Name)
+		n.SetName(new(ir.Name))
 	}
 
-	s := n.Sym
+	s := n.Sym()
 
 	// kludgy: typecheckok means we're past parsing. Eg genwrapper may declare out of package names later.
 	if !inimport && !typecheckok && s.Pkg != ir.LocalPkg {
-		base.ErrorfAt(n.Pos, "cannot declare name %v", s)
+		base.ErrorfAt(n.Pos(), "cannot declare name %v", s)
 	}
 
 	gen := 0
 	if ctxt == ir.PEXTERN {
 		if s.Name == "init" {
-			base.ErrorfAt(n.Pos, "cannot declare init - must be func")
+			base.ErrorfAt(n.Pos(), "cannot declare init - must be func")
 		}
 		if s.Name == "main" && s.Pkg.Name == "main" {
-			base.ErrorfAt(n.Pos, "cannot declare main - must be func")
+			base.ErrorfAt(n.Pos(), "cannot declare main - must be func")
 		}
 		externdcl = append(externdcl, n)
 	} else {
 		if Curfn == nil && ctxt == ir.PAUTO {
-			base.Pos = n.Pos
+			base.Pos = n.Pos()
 			base.Fatalf("automatic outside function")
 		}
 		if Curfn != nil && ctxt != ir.PFUNC {
-			Curfn.Func.Dcl = append(Curfn.Func.Dcl, n)
+			Curfn.Func().Dcl = append(Curfn.Func().Dcl, n)
 		}
-		if n.Op == ir.OTYPE {
+		if n.Op() == ir.OTYPE {
 			declare_typegen++
 			gen = declare_typegen
-		} else if n.Op == ir.ONAME && ctxt == ir.PAUTO && !strings.Contains(s.Name, "·") {
+		} else if n.Op() == ir.ONAME && ctxt == ir.PAUTO && !strings.Contains(s.Name, "·") {
 			vargen++
 			gen = vargen
 		}
 		types.Pushdcl(s)
-		n.Name.Curfn = Curfn
+		n.Name().Curfn = Curfn
 	}
 
 	if ctxt == ir.PAUTO {
-		n.Xoffset = 0
+		n.SetOffset(0)
 	}
 
 	if s.Block == types.Block {
 		// functype will print errors about duplicate function arguments.
 		// Don't repeat the error here.
 		if ctxt != ir.PPARAM && ctxt != ir.PPARAMOUT {
-			redeclare(n.Pos, s, "in this block")
+			redeclare(n.Pos(), s, "in this block")
 		}
 	}
 
 	s.Block = types.Block
 	s.Lastlineno = base.Pos
 	s.Def = ir.AsTypesNode(n)
-	n.Name.Vargen = int32(gen)
+	n.Name().Vargen = int32(gen)
 	n.SetClass(ctxt)
 	if ctxt == ir.PFUNC {
-		n.Sym.SetFunc(true)
+		n.Sym().SetFunc(true)
 	}
 
 	autoexport(n, ctxt)
 }
 
 func addvar(n *ir.Node, t *types.Type, ctxt ir.Class) {
-	if n == nil || n.Sym == nil || (n.Op != ir.ONAME && n.Op != ir.ONONAME) || t == nil {
+	if n == nil || n.Sym() == nil || (n.Op() != ir.ONAME && n.Op() != ir.ONONAME) || t == nil {
 		base.Fatalf("addvar: n=%v t=%v nil", n, t)
 	}
 
-	n.Op = ir.ONAME
+	n.SetOp(ir.ONAME)
 	declare(n, ctxt)
-	n.Type = t
+	n.SetType(t)
 }
 
 // declare variables from grammar
@@ -147,13 +147,13 @@ func variter(vl []*ir.Node, t *ir.Node, el []*ir.Node) []*ir.Node {
 	if len(el) == 1 && len(vl) > 1 {
 		e := el[0]
 		as2 := ir.Nod(ir.OAS2, nil, nil)
-		as2.List.Set(vl)
-		as2.Rlist.Set1(e)
+		as2.PtrList().Set(vl)
+		as2.PtrRlist().Set1(e)
 		for _, v := range vl {
-			v.Op = ir.ONAME
+			v.SetOp(ir.ONAME)
 			declare(v, dclcontext)
-			v.Name.Param.Ntype = t
-			v.Name.Defn = as2
+			v.Name().Param.Ntype = t
+			v.Name().Defn = as2
 			if Curfn != nil {
 				init = append(init, ir.Nod(ir.ODCL, v, nil))
 			}
@@ -174,9 +174,9 @@ func variter(vl []*ir.Node, t *ir.Node, el []*ir.Node) []*ir.Node {
 			el = el[1:]
 		}
 
-		v.Op = ir.ONAME
+		v.SetOp(ir.ONAME)
 		declare(v, dclcontext)
-		v.Name.Param.Ntype = t
+		v.Name().Param.Ntype = t
 
 		if e != nil || Curfn != nil || ir.IsBlank(v) {
 			if Curfn != nil {
@@ -184,8 +184,8 @@ func variter(vl []*ir.Node, t *ir.Node, el []*ir.Node) []*ir.Node {
 			}
 			e = ir.Nod(ir.OAS, v, e)
 			init = append(init, e)
-			if e.Right != nil {
-				v.Name.Defn = e
+			if e.Right() != nil {
+				v.Name().Defn = e
 			}
 		}
 	}
@@ -202,8 +202,8 @@ func newnoname(s *types.Sym) *ir.Node {
 		base.Fatalf("newnoname nil")
 	}
 	n := ir.Nod(ir.ONONAME, nil, nil)
-	n.Sym = s
-	n.Xoffset = 0
+	n.SetSym(s)
+	n.SetOffset(0)
 	return n
 }
 
@@ -213,7 +213,7 @@ func newfuncnamel(pos src.XPos, s *types.Sym, fn *ir.Func) *ir.Node {
 		base.Fatalf("newfuncnamel - already have name")
 	}
 	n := ir.NewNameAt(pos, s)
-	n.Func = fn
+	n.SetFunc(fn)
 	fn.Nname = n
 	return n
 }
@@ -222,7 +222,7 @@ func newfuncnamel(pos src.XPos, s *types.Sym, fn *ir.Func) *ir.Node {
 // being declared.
 func dclname(s *types.Sym) *ir.Node {
 	n := NewName(s)
-	n.Op = ir.ONONAME // caller will correct it
+	n.SetOp(ir.ONONAME) // caller will correct it
 	return n
 }
 
@@ -234,10 +234,10 @@ func typenodl(pos src.XPos, t *types.Type) *ir.Node {
 	// if we copied another type with *t = *u
 	// then t->nod might be out of date, so
 	// check t->nod->type too
-	if ir.AsNode(t.Nod) == nil || ir.AsNode(t.Nod).Type != t {
+	if ir.AsNode(t.Nod) == nil || ir.AsNode(t.Nod).Type() != t {
 		t.Nod = ir.AsTypesNode(ir.NodAt(pos, ir.OTYPE, nil, nil))
-		ir.AsNode(t.Nod).Type = t
-		ir.AsNode(t.Nod).Sym = t.Sym
+		ir.AsNode(t.Nod).SetType(t)
+		ir.AsNode(t.Nod).SetSym(t.Sym)
 	}
 
 	return ir.AsNode(t.Nod)
@@ -253,7 +253,7 @@ func namedfield(s string, typ *types.Type) *ir.Node {
 
 func symfield(s *types.Sym, typ *types.Type) *ir.Node {
 	n := nodSym(ir.ODCLFIELD, nil, s)
-	n.Type = typ
+	n.SetType(typ)
 	return n
 }
 
@@ -270,28 +270,28 @@ func oldname(s *types.Sym) *ir.Node {
 		return newnoname(s)
 	}
 
-	if Curfn != nil && n.Op == ir.ONAME && n.Name.Curfn != nil && n.Name.Curfn != Curfn {
+	if Curfn != nil && n.Op() == ir.ONAME && n.Name().Curfn != nil && n.Name().Curfn != Curfn {
 		// Inner func is referring to var in outer func.
 		//
 		// TODO(rsc): If there is an outer variable x and we
 		// are parsing x := 5 inside the closure, until we get to
 		// the := it looks like a reference to the outer x so we'll
 		// make x a closure variable unnecessarily.
-		c := n.Name.Param.Innermost
-		if c == nil || c.Name.Curfn != Curfn {
+		c := n.Name().Param.Innermost
+		if c == nil || c.Name().Curfn != Curfn {
 			// Do not have a closure var for the active closure yet; make one.
 			c = NewName(s)
 			c.SetClass(ir.PAUTOHEAP)
-			c.Name.SetIsClosureVar(true)
+			c.Name().SetIsClosureVar(true)
 			c.SetIsDDD(n.IsDDD())
-			c.Name.Defn = n
+			c.Name().Defn = n
 
 			// Link into list of active closure variables.
 			// Popped from list in func funcLit.
-			c.Name.Param.Outer = n.Name.Param.Innermost
-			n.Name.Param.Innermost = c
+			c.Name().Param.Outer = n.Name().Param.Innermost
+			n.Name().Param.Innermost = c
 
-			Curfn.Func.ClosureVars.Append(c)
+			Curfn.Func().ClosureVars.Append(c)
 		}
 
 		// return ref to closure var, not original
@@ -313,13 +313,13 @@ func importName(sym *types.Sym) *ir.Node {
 
 // := declarations
 func colasname(n *ir.Node) bool {
-	switch n.Op {
+	switch n.Op() {
 	case ir.ONAME,
 		ir.ONONAME,
 		ir.OPACK,
 		ir.OTYPE,
 		ir.OLITERAL:
-		return n.Sym != nil
+		return n.Sym() != nil
 	}
 
 	return false
@@ -327,8 +327,8 @@ func colasname(n *ir.Node) bool {
 
 func colasdefn(left []*ir.Node, defn *ir.Node) {
 	for _, n := range left {
-		if n.Sym != nil {
-			n.Sym.SetUniq(true)
+		if n.Sym() != nil {
+			n.Sym().SetUniq(true)
 		}
 	}
 
@@ -338,44 +338,44 @@ func colasdefn(left []*ir.Node, defn *ir.Node) {
 			continue
 		}
 		if !colasname(n) {
-			base.ErrorfAt(defn.Pos, "non-name %v on left side of :=", n)
+			base.ErrorfAt(defn.Pos(), "non-name %v on left side of :=", n)
 			nerr++
 			continue
 		}
 
-		if !n.Sym.Uniq() {
-			base.ErrorfAt(defn.Pos, "%v repeated on left side of :=", n.Sym)
+		if !n.Sym().Uniq() {
+			base.ErrorfAt(defn.Pos(), "%v repeated on left side of :=", n.Sym())
 			n.SetDiag(true)
 			nerr++
 			continue
 		}
 
-		n.Sym.SetUniq(false)
-		if n.Sym.Block == types.Block {
+		n.Sym().SetUniq(false)
+		if n.Sym().Block == types.Block {
 			continue
 		}
 
 		nnew++
-		n = NewName(n.Sym)
+		n = NewName(n.Sym())
 		declare(n, dclcontext)
-		n.Name.Defn = defn
-		defn.Ninit.Append(ir.Nod(ir.ODCL, n, nil))
+		n.Name().Defn = defn
+		defn.PtrInit().Append(ir.Nod(ir.ODCL, n, nil))
 		left[i] = n
 	}
 
 	if nnew == 0 && nerr == 0 {
-		base.ErrorfAt(defn.Pos, "no new variables on left side of :=")
+		base.ErrorfAt(defn.Pos(), "no new variables on left side of :=")
 	}
 }
 
 // declare the arguments in an
 // interface field declaration.
 func ifacedcl(n *ir.Node) {
-	if n.Op != ir.ODCLFIELD || n.Left == nil {
+	if n.Op() != ir.ODCLFIELD || n.Left() == nil {
 		base.Fatalf("ifacedcl")
 	}
 
-	if n.Sym.IsBlank() {
+	if n.Sym().IsBlank() {
 		base.Errorf("methods must have a unique non-blank name")
 	}
 }
@@ -392,16 +392,16 @@ func funchdr(n *ir.Node) {
 
 	types.Markdcl()
 
-	if n.Func.Nname != nil && n.Func.Nname.Name.Param.Ntype != nil {
-		funcargs(n.Func.Nname.Name.Param.Ntype)
+	if n.Func().Nname != nil && n.Func().Nname.Name().Param.Ntype != nil {
+		funcargs(n.Func().Nname.Name().Param.Ntype)
 	} else {
-		funcargs2(n.Type)
+		funcargs2(n.Type())
 	}
 }
 
 func funcargs(nt *ir.Node) {
-	if nt.Op != ir.OTFUNC {
-		base.Fatalf("funcargs %v", nt.Op)
+	if nt.Op() != ir.OTFUNC {
+		base.Fatalf("funcargs %v", nt.Op())
 	}
 
 	// re-start the variable generation number
@@ -411,13 +411,13 @@ func funcargs(nt *ir.Node) {
 	// TODO(mdempsky): This is ugly, and only necessary because
 	// esc.go uses Vargen to figure out result parameters' index
 	// within the result tuple.
-	vargen = nt.Rlist.Len()
+	vargen = nt.Rlist().Len()
 
 	// declare the receiver and in arguments.
-	if nt.Left != nil {
-		funcarg(nt.Left, ir.PPARAM)
+	if nt.Left() != nil {
+		funcarg(nt.Left(), ir.PPARAM)
 	}
-	for _, n := range nt.List.Slice() {
+	for _, n := range nt.List().Slice() {
 		funcarg(n, ir.PPARAM)
 	}
 
@@ -425,21 +425,21 @@ func funcargs(nt *ir.Node) {
 	vargen = 0
 
 	// declare the out arguments.
-	gen := nt.List.Len()
-	for _, n := range nt.Rlist.Slice() {
-		if n.Sym == nil {
+	gen := nt.List().Len()
+	for _, n := range nt.Rlist().Slice() {
+		if n.Sym() == nil {
 			// Name so that escape analysis can track it. ~r stands for 'result'.
-			n.Sym = lookupN("~r", gen)
+			n.SetSym(lookupN("~r", gen))
 			gen++
 		}
-		if n.Sym.IsBlank() {
+		if n.Sym().IsBlank() {
 			// Give it a name so we can assign to it during return. ~b stands for 'blank'.
 			// The name must be different from ~r above because if you have
 			//	func f() (_ int)
 			//	func g() int
 			// f is allowed to use a plain 'return' with no arguments, while g is not.
 			// So the two cases must be distinguished.
-			n.Sym = lookupN("~b", gen)
+			n.SetSym(lookupN("~b", gen))
 			gen++
 		}
 
@@ -450,20 +450,20 @@ func funcargs(nt *ir.Node) {
 }
 
 func funcarg(n *ir.Node, ctxt ir.Class) {
-	if n.Op != ir.ODCLFIELD {
-		base.Fatalf("funcarg %v", n.Op)
+	if n.Op() != ir.ODCLFIELD {
+		base.Fatalf("funcarg %v", n.Op())
 	}
-	if n.Sym == nil {
+	if n.Sym() == nil {
 		return
 	}
 
-	n.Right = ir.NewNameAt(n.Pos, n.Sym)
-	n.Right.Name.Param.Ntype = n.Left
-	n.Right.SetIsDDD(n.IsDDD())
-	declare(n.Right, ctxt)
+	n.SetRight(ir.NewNameAt(n.Pos(), n.Sym()))
+	n.Right().Name().Param.Ntype = n.Left()
+	n.Right().SetIsDDD(n.IsDDD())
+	declare(n.Right(), ctxt)
 
 	vargen++
-	n.Right.Name.Vargen = int32(vargen)
+	n.Right().Name().Vargen = int32(vargen)
 }
 
 // Same as funcargs, except run over an already constructed TFUNC.
@@ -491,7 +491,7 @@ func funcarg2(f *types.Field, ctxt ir.Class) {
 	}
 	n := ir.NewNameAt(f.Pos, f.Sym)
 	f.Nname = ir.AsTypesNode(n)
-	n.Type = f.Type
+	n.SetType(f.Type)
 	n.SetIsDDD(f.IsDDD())
 	declare(n, ctxt)
 }
@@ -537,21 +537,21 @@ func checkembeddedtype(t *types.Type) {
 
 func structfield(n *ir.Node) *types.Field {
 	lno := base.Pos
-	base.Pos = n.Pos
+	base.Pos = n.Pos()
 
-	if n.Op != ir.ODCLFIELD {
+	if n.Op() != ir.ODCLFIELD {
 		base.Fatalf("structfield: oops %v\n", n)
 	}
 
-	if n.Left != nil {
-		n.Left = typecheck(n.Left, ctxType)
-		n.Type = n.Left.Type
-		n.Left = nil
+	if n.Left() != nil {
+		n.SetLeft(typecheck(n.Left(), ctxType))
+		n.SetType(n.Left().Type())
+		n.SetLeft(nil)
 	}
 
-	f := types.NewField(n.Pos, n.Sym, n.Type)
+	f := types.NewField(n.Pos(), n.Sym(), n.Type())
 	if n.Embedded() {
-		checkembeddedtype(n.Type)
+		checkembeddedtype(n.Type())
 		f.Embedded = 1
 	}
 	if n.HasVal() {
@@ -612,9 +612,9 @@ func tofunargs(l []*ir.Node, funarg types.Funarg) *types.Type {
 	for i, n := range l {
 		f := structfield(n)
 		f.SetIsDDD(n.IsDDD())
-		if n.Right != nil {
-			n.Right.Type = f.Type
-			f.Nname = ir.AsTypesNode(n.Right)
+		if n.Right() != nil {
+			n.Right().SetType(f.Type)
+			f.Nname = ir.AsTypesNode(n.Right())
 		}
 		if f.Broke() {
 			t.SetBroke(true)
@@ -634,9 +634,9 @@ func tofunargsfield(fields []*types.Field, funarg types.Funarg) *types.Type {
 
 func interfacefield(n *ir.Node) *types.Field {
 	lno := base.Pos
-	base.Pos = n.Pos
+	base.Pos = n.Pos()
 
-	if n.Op != ir.ODCLFIELD {
+	if n.Op() != ir.ODCLFIELD {
 		base.Fatalf("interfacefield: oops %v\n", n)
 	}
 
@@ -649,13 +649,13 @@ func interfacefield(n *ir.Node) *types.Field {
 	// If Sym != nil, then Sym is MethodName and Left is Signature.
 	// Otherwise, Left is InterfaceTypeName.
 
-	if n.Left != nil {
-		n.Left = typecheck(n.Left, ctxType)
-		n.Type = n.Left.Type
-		n.Left = nil
+	if n.Left() != nil {
+		n.SetLeft(typecheck(n.Left(), ctxType))
+		n.SetType(n.Left().Type())
+		n.SetLeft(nil)
 	}
 
-	f := types.NewField(n.Pos, n.Sym, n.Type)
+	f := types.NewField(n.Pos(), n.Sym(), n.Type())
 
 	base.Pos = lno
 	return f
@@ -872,7 +872,7 @@ func addmethod(n *ir.Node, msym *types.Sym, t *types.Type, local, nointerface bo
 	}
 
 	f := types.NewField(base.Pos, msym, t)
-	f.Nname = ir.AsTypesNode(n.Func.Nname)
+	f.Nname = ir.AsTypesNode(n.Func().Nname)
 	f.SetNointerface(nointerface)
 
 	mt.Methods().Append(f)
@@ -936,26 +936,26 @@ func makefuncsym(s *types.Sym) {
 
 // setNodeNameFunc marks a node as a function.
 func setNodeNameFunc(n *ir.Node) {
-	if n.Op != ir.ONAME || n.Class() != ir.Pxxx {
+	if n.Op() != ir.ONAME || n.Class() != ir.Pxxx {
 		base.Fatalf("expected ONAME/Pxxx node, got %v", n)
 	}
 
 	n.SetClass(ir.PFUNC)
-	n.Sym.SetFunc(true)
+	n.Sym().SetFunc(true)
 }
 
 func dclfunc(sym *types.Sym, tfn *ir.Node) *ir.Node {
-	if tfn.Op != ir.OTFUNC {
+	if tfn.Op() != ir.OTFUNC {
 		base.Fatalf("expected OTFUNC node, got %v", tfn)
 	}
 
 	fn := ir.Nod(ir.ODCLFUNC, nil, nil)
-	fn.Func.Nname = newfuncnamel(base.Pos, sym, fn.Func)
-	fn.Func.Nname.Name.Defn = fn
-	fn.Func.Nname.Name.Param.Ntype = tfn
-	setNodeNameFunc(fn.Func.Nname)
+	fn.Func().Nname = newfuncnamel(base.Pos, sym, fn.Func())
+	fn.Func().Nname.Name().Defn = fn
+	fn.Func().Nname.Name().Param.Ntype = tfn
+	setNodeNameFunc(fn.Func().Nname)
 	funchdr(fn)
-	fn.Func.Nname.Name.Param.Ntype = typecheck(fn.Func.Nname.Name.Param.Ntype, ctxType)
+	fn.Func().Nname.Name().Param.Ntype = typecheck(fn.Func().Nname.Name().Param.Ntype, ctxType)
 	return fn
 }
 
@@ -987,7 +987,7 @@ func newNowritebarrierrecChecker() *nowritebarrierrecChecker {
 	// directly. This has to happen before transformclosure since
 	// it's a lot harder to work out the argument after.
 	for _, n := range xtop {
-		if n.Op != ir.ODCLFUNC {
+		if n.Op() != ir.ODCLFUNC {
 			continue
 		}
 		c.curfn = n
@@ -998,31 +998,31 @@ func newNowritebarrierrecChecker() *nowritebarrierrecChecker {
 }
 
 func (c *nowritebarrierrecChecker) findExtraCalls(n *ir.Node) bool {
-	if n.Op != ir.OCALLFUNC {
+	if n.Op() != ir.OCALLFUNC {
 		return true
 	}
-	fn := n.Left
-	if fn == nil || fn.Op != ir.ONAME || fn.Class() != ir.PFUNC || fn.Name.Defn == nil {
+	fn := n.Left()
+	if fn == nil || fn.Op() != ir.ONAME || fn.Class() != ir.PFUNC || fn.Name().Defn == nil {
 		return true
 	}
-	if !isRuntimePkg(fn.Sym.Pkg) || fn.Sym.Name != "systemstack" {
+	if !isRuntimePkg(fn.Sym().Pkg) || fn.Sym().Name != "systemstack" {
 		return true
 	}
 
 	var callee *ir.Node
-	arg := n.List.First()
-	switch arg.Op {
+	arg := n.List().First()
+	switch arg.Op() {
 	case ir.ONAME:
-		callee = arg.Name.Defn
+		callee = arg.Name().Defn
 	case ir.OCLOSURE:
-		callee = arg.Func.Decl
+		callee = arg.Func().Decl
 	default:
 		base.Fatalf("expected ONAME or OCLOSURE node, got %+v", arg)
 	}
-	if callee.Op != ir.ODCLFUNC {
+	if callee.Op() != ir.ODCLFUNC {
 		base.Fatalf("expected ODCLFUNC node, got %+v", callee)
 	}
-	c.extraCalls[c.curfn] = append(c.extraCalls[c.curfn], nowritebarrierrecCall{callee, n.Pos})
+	c.extraCalls[c.curfn] = append(c.extraCalls[c.curfn], nowritebarrierrecCall{callee, n.Pos()})
 	return true
 }
 
@@ -1035,12 +1035,12 @@ func (c *nowritebarrierrecChecker) findExtraCalls(n *ir.Node) bool {
 //
 // This can be called concurrently for different from Nodes.
 func (c *nowritebarrierrecChecker) recordCall(from *ir.Node, to *obj.LSym, pos src.XPos) {
-	if from.Op != ir.ODCLFUNC {
+	if from.Op() != ir.ODCLFUNC {
 		base.Fatalf("expected ODCLFUNC, got %v", from)
 	}
 	// We record this information on the *Func so this is
 	// concurrent-safe.
-	fn := from.Func
+	fn := from.Func()
 	if fn.NWBRCalls == nil {
 		fn.NWBRCalls = new([]ir.SymAndPos)
 	}
@@ -1064,27 +1064,27 @@ func (c *nowritebarrierrecChecker) check() {
 	var q ir.NodeQueue
 
 	for _, n := range xtop {
-		if n.Op != ir.ODCLFUNC {
+		if n.Op() != ir.ODCLFUNC {
 			continue
 		}
 
-		symToFunc[n.Func.LSym] = n
+		symToFunc[n.Func().LSym] = n
 
 		// Make nowritebarrierrec functions BFS roots.
-		if n.Func.Pragma&ir.Nowritebarrierrec != 0 {
+		if n.Func().Pragma&ir.Nowritebarrierrec != 0 {
 			funcs[n] = nowritebarrierrecCall{}
 			q.PushRight(n)
 		}
 		// Check go:nowritebarrier functions.
-		if n.Func.Pragma&ir.Nowritebarrier != 0 && n.Func.WBPos.IsKnown() {
-			base.ErrorfAt(n.Func.WBPos, "write barrier prohibited")
+		if n.Func().Pragma&ir.Nowritebarrier != 0 && n.Func().WBPos.IsKnown() {
+			base.ErrorfAt(n.Func().WBPos, "write barrier prohibited")
 		}
 	}
 
 	// Perform a BFS of the call graph from all
 	// go:nowritebarrierrec functions.
 	enqueue := func(src, target *ir.Node, pos src.XPos) {
-		if target.Func.Pragma&ir.Yeswritebarrierrec != 0 {
+		if target.Func().Pragma&ir.Yeswritebarrierrec != 0 {
 			// Don't flow into this function.
 			return
 		}
@@ -1101,14 +1101,14 @@ func (c *nowritebarrierrecChecker) check() {
 		fn := q.PopLeft()
 
 		// Check fn.
-		if fn.Func.WBPos.IsKnown() {
+		if fn.Func().WBPos.IsKnown() {
 			var err bytes.Buffer
 			call := funcs[fn]
 			for call.target != nil {
-				fmt.Fprintf(&err, "\n\t%v: called by %v", base.FmtPos(call.lineno), call.target.Func.Nname)
+				fmt.Fprintf(&err, "\n\t%v: called by %v", base.FmtPos(call.lineno), call.target.Func().Nname)
 				call = funcs[call.target]
 			}
-			base.ErrorfAt(fn.Func.WBPos, "write barrier prohibited by caller; %v%s", fn.Func.Nname, err.String())
+			base.ErrorfAt(fn.Func().WBPos, "write barrier prohibited by caller; %v%s", fn.Func().Nname, err.String())
 			continue
 		}
 
@@ -1116,10 +1116,10 @@ func (c *nowritebarrierrecChecker) check() {
 		for _, callee := range c.extraCalls[fn] {
 			enqueue(fn, callee.target, callee.lineno)
 		}
-		if fn.Func.NWBRCalls == nil {
+		if fn.Func().NWBRCalls == nil {
 			continue
 		}
-		for _, callee := range *fn.Func.NWBRCalls {
+		for _, callee := range *fn.Func().NWBRCalls {
 			target := symToFunc[callee.Sym]
 			if target != nil {
 				enqueue(fn, target, callee.Pos)
diff --git a/src/cmd/compile/internal/gc/dwinl.go b/src/cmd/compile/internal/gc/dwinl.go
index 5da2871748..1e4e43caad 100644
--- a/src/cmd/compile/internal/gc/dwinl.go
+++ b/src/cmd/compile/internal/gc/dwinl.go
@@ -236,15 +236,15 @@ func makePreinlineDclMap(fnsym *obj.LSym) map[varPos]int {
 	dcl := preInliningDcls(fnsym)
 	m := make(map[varPos]int)
 	for i, n := range dcl {
-		pos := base.Ctxt.InnermostPos(n.Pos)
+		pos := base.Ctxt.InnermostPos(n.Pos())
 		vp := varPos{
-			DeclName: unversion(n.Sym.Name),
+			DeclName: unversion(n.Sym().Name),
 			DeclFile: pos.RelFilename(),
 			DeclLine: pos.RelLine(),
 			DeclCol:  pos.Col(),
 		}
 		if _, found := m[vp]; found {
-			base.Fatalf("child dcl collision on symbol %s within %v\n", n.Sym.Name, fnsym.Name)
+			base.Fatalf("child dcl collision on symbol %s within %v\n", n.Sym().Name, fnsym.Name)
 		}
 		m[vp] = i
 	}
diff --git a/src/cmd/compile/internal/gc/embed.go b/src/cmd/compile/internal/gc/embed.go
index 636aa4a70e..d515696add 100644
--- a/src/cmd/compile/internal/gc/embed.go
+++ b/src/cmd/compile/internal/gc/embed.go
@@ -113,15 +113,15 @@ func varEmbed(p *noder, names []*ir.Node, typ *ir.Node, exprs []*ir.Node, embeds
 	v := names[0]
 	if dclcontext != ir.PEXTERN {
 		numLocalEmbed++
-		v = ir.NewNameAt(v.Pos, lookupN("embed.", numLocalEmbed))
-		v.Sym.Def = ir.AsTypesNode(v)
-		v.Name.Param.Ntype = typ
+		v = ir.NewNameAt(v.Pos(), lookupN("embed.", numLocalEmbed))
+		v.Sym().Def = ir.AsTypesNode(v)
+		v.Name().Param.Ntype = typ
 		v.SetClass(ir.PEXTERN)
 		externdcl = append(externdcl, v)
 		exprs = []*ir.Node{v}
 	}
 
-	v.Name.Param.SetEmbedFiles(list)
+	v.Name().Param.SetEmbedFiles(list)
 	embedlist = append(embedlist, v)
 	return exprs
 }
@@ -131,17 +131,17 @@ func varEmbed(p *noder, names []*ir.Node, typ *ir.Node, exprs []*ir.Node, embeds
 // can't tell whether "string" and "byte" really mean "string" and "byte".
 // The result must be confirmed later, after type checking, using embedKind.
 func embedKindApprox(typ *ir.Node) int {
-	if typ.Sym != nil && typ.Sym.Name == "FS" && (typ.Sym.Pkg.Path == "embed" || (typ.Sym.Pkg == ir.LocalPkg && base.Ctxt.Pkgpath == "embed")) {
+	if typ.Sym() != nil && typ.Sym().Name == "FS" && (typ.Sym().Pkg.Path == "embed" || (typ.Sym().Pkg == ir.LocalPkg && base.Ctxt.Pkgpath == "embed")) {
 		return embedFiles
 	}
 	// These are not guaranteed to match only string and []byte -
 	// maybe the local package has redefined one of those words.
 	// But it's the best we can do now during the noder.
 	// The stricter check happens later, in initEmbed calling embedKind.
-	if typ.Sym != nil && typ.Sym.Name == "string" && typ.Sym.Pkg == ir.LocalPkg {
+	if typ.Sym() != nil && typ.Sym().Name == "string" && typ.Sym().Pkg == ir.LocalPkg {
 		return embedString
 	}
-	if typ.Op == ir.OTARRAY && typ.Left == nil && typ.Right.Sym != nil && typ.Right.Sym.Name == "byte" && typ.Right.Sym.Pkg == ir.LocalPkg {
+	if typ.Op() == ir.OTARRAY && typ.Left() == nil && typ.Right().Sym() != nil && typ.Right().Sym().Name == "byte" && typ.Right().Sym().Pkg == ir.LocalPkg {
 		return embedBytes
 	}
 	return embedUnknown
@@ -193,18 +193,18 @@ func dumpembeds() {
 // initEmbed emits the init data for a //go:embed variable,
 // which is either a string, a []byte, or an embed.FS.
 func initEmbed(v *ir.Node) {
-	files := v.Name.Param.EmbedFiles()
-	switch kind := embedKind(v.Type); kind {
+	files := v.Name().Param.EmbedFiles()
+	switch kind := embedKind(v.Type()); kind {
 	case embedUnknown:
-		base.ErrorfAt(v.Pos, "go:embed cannot apply to var of type %v", v.Type)
+		base.ErrorfAt(v.Pos(), "go:embed cannot apply to var of type %v", v.Type())
 
 	case embedString, embedBytes:
 		file := files[0]
-		fsym, size, err := fileStringSym(v.Pos, base.Flag.Cfg.Embed.Files[file], kind == embedString, nil)
+		fsym, size, err := fileStringSym(v.Pos(), base.Flag.Cfg.Embed.Files[file], kind == embedString, nil)
 		if err != nil {
-			base.ErrorfAt(v.Pos, "embed %s: %v", file, err)
+			base.ErrorfAt(v.Pos(), "embed %s: %v", file, err)
 		}
-		sym := v.Sym.Linksym()
+		sym := v.Sym().Linksym()
 		off := 0
 		off = dsymptr(sym, off, fsym, 0)       // data string
 		off = duintptr(sym, off, uint64(size)) // len
@@ -213,7 +213,7 @@ func initEmbed(v *ir.Node) {
 		}
 
 	case embedFiles:
-		slicedata := base.Ctxt.Lookup(`"".` + v.Sym.Name + `.files`)
+		slicedata := base.Ctxt.Lookup(`"".` + v.Sym().Name + `.files`)
 		off := 0
 		// []files pointed at by Files
 		off = dsymptr(slicedata, off, slicedata, 3*Widthptr) // []file, pointing just past slice
@@ -228,7 +228,7 @@ func initEmbed(v *ir.Node) {
 		const hashSize = 16
 		hash := make([]byte, hashSize)
 		for _, file := range files {
-			off = dsymptr(slicedata, off, stringsym(v.Pos, file), 0) // file string
+			off = dsymptr(slicedata, off, stringsym(v.Pos(), file), 0) // file string
 			off = duintptr(slicedata, off, uint64(len(file)))
 			if strings.HasSuffix(file, "/") {
 				// entry for directory - no data
@@ -236,9 +236,9 @@ func initEmbed(v *ir.Node) {
 				off = duintptr(slicedata, off, 0)
 				off += hashSize
 			} else {
-				fsym, size, err := fileStringSym(v.Pos, base.Flag.Cfg.Embed.Files[file], true, hash)
+				fsym, size, err := fileStringSym(v.Pos(), base.Flag.Cfg.Embed.Files[file], true, hash)
 				if err != nil {
-					base.ErrorfAt(v.Pos, "embed %s: %v", file, err)
+					base.ErrorfAt(v.Pos(), "embed %s: %v", file, err)
 				}
 				off = dsymptr(slicedata, off, fsym, 0) // data string
 				off = duintptr(slicedata, off, uint64(size))
@@ -246,7 +246,7 @@ func initEmbed(v *ir.Node) {
 			}
 		}
 		ggloblsym(slicedata, int32(off), obj.RODATA|obj.LOCAL)
-		sym := v.Sym.Linksym()
+		sym := v.Sym().Linksym()
 		dsymptr(sym, 0, slicedata, 0)
 	}
 }
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index a0aa516d9a..866bdf8a6f 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -149,7 +149,7 @@ func init() {
 // escFmt is called from node printing to print information about escape analysis results.
 func escFmt(n *ir.Node, short bool) string {
 	text := ""
-	switch n.Esc {
+	switch n.Esc() {
 	case EscUnknown:
 		break
 
@@ -165,7 +165,7 @@ func escFmt(n *ir.Node, short bool) string {
 		}
 
 	default:
-		text = fmt.Sprintf("esc(%d)", n.Esc)
+		text = fmt.Sprintf("esc(%d)", n.Esc())
 	}
 
 	if e, ok := n.Opt().(*EscLocation); ok && e.loopDepth != 0 {
@@ -181,7 +181,7 @@ func escFmt(n *ir.Node, short bool) string {
 // functions.
 func escapeFuncs(fns []*ir.Node, recursive bool) {
 	for _, fn := range fns {
-		if fn.Op != ir.ODCLFUNC {
+		if fn.Op() != ir.ODCLFUNC {
 			base.Fatalf("unexpected node: %v", fn)
 		}
 	}
@@ -203,10 +203,10 @@ func escapeFuncs(fns []*ir.Node, recursive bool) {
 }
 
 func (e *Escape) initFunc(fn *ir.Node) {
-	if fn.Op != ir.ODCLFUNC || fn.Esc != EscFuncUnknown {
+	if fn.Op() != ir.ODCLFUNC || fn.Esc() != EscFuncUnknown {
 		base.Fatalf("unexpected node: %v", fn)
 	}
-	fn.Esc = EscFuncPlanned
+	fn.SetEsc(EscFuncPlanned)
 	if base.Flag.LowerM > 3 {
 		ir.Dump("escAnalyze", fn)
 	}
@@ -215,27 +215,27 @@ func (e *Escape) initFunc(fn *ir.Node) {
 	e.loopDepth = 1
 
 	// Allocate locations for local variables.
-	for _, dcl := range fn.Func.Dcl {
-		if dcl.Op == ir.ONAME {
+	for _, dcl := range fn.Func().Dcl {
+		if dcl.Op() == ir.ONAME {
 			e.newLoc(dcl, false)
 		}
 	}
 }
 
 func (e *Escape) walkFunc(fn *ir.Node) {
-	fn.Esc = EscFuncStarted
+	fn.SetEsc(EscFuncStarted)
 
 	// Identify labels that mark the head of an unstructured loop.
-	ir.InspectList(fn.Nbody, func(n *ir.Node) bool {
-		switch n.Op {
+	ir.InspectList(fn.Body(), func(n *ir.Node) bool {
+		switch n.Op() {
 		case ir.OLABEL:
-			n.Sym.Label = ir.AsTypesNode(nonlooping)
+			n.Sym().Label = ir.AsTypesNode(nonlooping)
 
 		case ir.OGOTO:
 			// If we visited the label before the goto,
 			// then this is a looping label.
-			if n.Sym.Label == ir.AsTypesNode(nonlooping) {
-				n.Sym.Label = ir.AsTypesNode(looping)
+			if n.Sym().Label == ir.AsTypesNode(nonlooping) {
+				n.Sym().Label = ir.AsTypesNode(looping)
 			}
 		}
 
@@ -244,7 +244,7 @@ func (e *Escape) walkFunc(fn *ir.Node) {
 
 	e.curfn = fn
 	e.loopDepth = 1
-	e.block(fn.Nbody)
+	e.block(fn.Body())
 }
 
 // Below we implement the methods for walking the AST and recording
@@ -288,9 +288,9 @@ func (e *Escape) stmt(n *ir.Node) {
 		fmt.Printf("%v:[%d] %v stmt: %v\n", base.FmtPos(base.Pos), e.loopDepth, funcSym(e.curfn), n)
 	}
 
-	e.stmts(n.Ninit)
+	e.stmts(n.Init())
 
-	switch n.Op {
+	switch n.Op() {
 	default:
 		base.Fatalf("unexpected stmt: %v", n)
 
@@ -301,16 +301,16 @@ func (e *Escape) stmt(n *ir.Node) {
 		// TODO(mdempsky): Handle dead code?
 
 	case ir.OBLOCK:
-		e.stmts(n.List)
+		e.stmts(n.List())
 
 	case ir.ODCL:
 		// Record loop depth at declaration.
-		if !ir.IsBlank(n.Left) {
-			e.dcl(n.Left)
+		if !ir.IsBlank(n.Left()) {
+			e.dcl(n.Left())
 		}
 
 	case ir.OLABEL:
-		switch ir.AsNode(n.Sym.Label) {
+		switch ir.AsNode(n.Sym().Label) {
 		case nonlooping:
 			if base.Flag.LowerM > 2 {
 				fmt.Printf("%v:%v non-looping label\n", base.FmtPos(base.Pos), n)
@@ -323,109 +323,109 @@ func (e *Escape) stmt(n *ir.Node) {
 		default:
 			base.Fatalf("label missing tag")
 		}
-		n.Sym.Label = nil
+		n.Sym().Label = nil
 
 	case ir.OIF:
-		e.discard(n.Left)
-		e.block(n.Nbody)
-		e.block(n.Rlist)
+		e.discard(n.Left())
+		e.block(n.Body())
+		e.block(n.Rlist())
 
 	case ir.OFOR, ir.OFORUNTIL:
 		e.loopDepth++
-		e.discard(n.Left)
-		e.stmt(n.Right)
-		e.block(n.Nbody)
+		e.discard(n.Left())
+		e.stmt(n.Right())
+		e.block(n.Body())
 		e.loopDepth--
 
 	case ir.ORANGE:
 		// for List = range Right { Nbody }
 		e.loopDepth++
-		ks := e.addrs(n.List)
-		e.block(n.Nbody)
+		ks := e.addrs(n.List())
+		e.block(n.Body())
 		e.loopDepth--
 
 		// Right is evaluated outside the loop.
 		k := e.discardHole()
 		if len(ks) >= 2 {
-			if n.Right.Type.IsArray() {
+			if n.Right().Type().IsArray() {
 				k = ks[1].note(n, "range")
 			} else {
 				k = ks[1].deref(n, "range-deref")
 			}
 		}
-		e.expr(e.later(k), n.Right)
+		e.expr(e.later(k), n.Right())
 
 	case ir.OSWITCH:
-		typesw := n.Left != nil && n.Left.Op == ir.OTYPESW
+		typesw := n.Left() != nil && n.Left().Op() == ir.OTYPESW
 
 		var ks []EscHole
-		for _, cas := range n.List.Slice() { // cases
-			if typesw && n.Left.Left != nil {
-				cv := cas.Rlist.First()
+		for _, cas := range n.List().Slice() { // cases
+			if typesw && n.Left().Left() != nil {
+				cv := cas.Rlist().First()
 				k := e.dcl(cv) // type switch variables have no ODCL.
-				if cv.Type.HasPointers() {
-					ks = append(ks, k.dotType(cv.Type, cas, "switch case"))
+				if cv.Type().HasPointers() {
+					ks = append(ks, k.dotType(cv.Type(), cas, "switch case"))
 				}
 			}
 
-			e.discards(cas.List)
-			e.block(cas.Nbody)
+			e.discards(cas.List())
+			e.block(cas.Body())
 		}
 
 		if typesw {
-			e.expr(e.teeHole(ks...), n.Left.Right)
+			e.expr(e.teeHole(ks...), n.Left().Right())
 		} else {
-			e.discard(n.Left)
+			e.discard(n.Left())
 		}
 
 	case ir.OSELECT:
-		for _, cas := range n.List.Slice() {
-			e.stmt(cas.Left)
-			e.block(cas.Nbody)
+		for _, cas := range n.List().Slice() {
+			e.stmt(cas.Left())
+			e.block(cas.Body())
 		}
 	case ir.OSELRECV:
-		e.assign(n.Left, n.Right, "selrecv", n)
+		e.assign(n.Left(), n.Right(), "selrecv", n)
 	case ir.OSELRECV2:
-		e.assign(n.Left, n.Right, "selrecv", n)
-		e.assign(n.List.First(), nil, "selrecv", n)
+		e.assign(n.Left(), n.Right(), "selrecv", n)
+		e.assign(n.List().First(), nil, "selrecv", n)
 	case ir.ORECV:
 		// TODO(mdempsky): Consider e.discard(n.Left).
 		e.exprSkipInit(e.discardHole(), n) // already visited n.Ninit
 	case ir.OSEND:
-		e.discard(n.Left)
-		e.assignHeap(n.Right, "send", n)
+		e.discard(n.Left())
+		e.assignHeap(n.Right(), "send", n)
 
 	case ir.OAS, ir.OASOP:
-		e.assign(n.Left, n.Right, "assign", n)
+		e.assign(n.Left(), n.Right(), "assign", n)
 
 	case ir.OAS2:
-		for i, nl := range n.List.Slice() {
-			e.assign(nl, n.Rlist.Index(i), "assign-pair", n)
+		for i, nl := range n.List().Slice() {
+			e.assign(nl, n.Rlist().Index(i), "assign-pair", n)
 		}
 
 	case ir.OAS2DOTTYPE: // v, ok = x.(type)
-		e.assign(n.List.First(), n.Right, "assign-pair-dot-type", n)
-		e.assign(n.List.Second(), nil, "assign-pair-dot-type", n)
+		e.assign(n.List().First(), n.Right(), "assign-pair-dot-type", n)
+		e.assign(n.List().Second(), nil, "assign-pair-dot-type", n)
 	case ir.OAS2MAPR: // v, ok = m[k]
-		e.assign(n.List.First(), n.Right, "assign-pair-mapr", n)
-		e.assign(n.List.Second(), nil, "assign-pair-mapr", n)
+		e.assign(n.List().First(), n.Right(), "assign-pair-mapr", n)
+		e.assign(n.List().Second(), nil, "assign-pair-mapr", n)
 	case ir.OAS2RECV: // v, ok = <-ch
-		e.assign(n.List.First(), n.Right, "assign-pair-receive", n)
-		e.assign(n.List.Second(), nil, "assign-pair-receive", n)
+		e.assign(n.List().First(), n.Right(), "assign-pair-receive", n)
+		e.assign(n.List().Second(), nil, "assign-pair-receive", n)
 
 	case ir.OAS2FUNC:
-		e.stmts(n.Right.Ninit)
-		e.call(e.addrs(n.List), n.Right, nil)
+		e.stmts(n.Right().Init())
+		e.call(e.addrs(n.List()), n.Right(), nil)
 	case ir.ORETURN:
-		results := e.curfn.Type.Results().FieldSlice()
-		for i, v := range n.List.Slice() {
+		results := e.curfn.Type().Results().FieldSlice()
+		for i, v := range n.List().Slice() {
 			e.assign(ir.AsNode(results[i].Nname), v, "return", n)
 		}
 	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER, ir.OCLOSE, ir.OCOPY, ir.ODELETE, ir.OPANIC, ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
 		e.call(nil, n, nil)
 	case ir.OGO, ir.ODEFER:
-		e.stmts(n.Left.Ninit)
-		e.call(nil, n.Left, n)
+		e.stmts(n.Left().Init())
+		e.call(nil, n.Left(), n)
 
 	case ir.ORETJMP:
 		// TODO(mdempsky): What do? esc.go just ignores it.
@@ -451,7 +451,7 @@ func (e *Escape) expr(k EscHole, n *ir.Node) {
 	if n == nil {
 		return
 	}
-	e.stmts(n.Ninit)
+	e.stmts(n.Init())
 	e.exprSkipInit(k, n)
 }
 
@@ -468,13 +468,13 @@ func (e *Escape) exprSkipInit(k EscHole, n *ir.Node) {
 	uintptrEscapesHack := k.uintptrEscapesHack
 	k.uintptrEscapesHack = false
 
-	if uintptrEscapesHack && n.Op == ir.OCONVNOP && n.Left.Type.IsUnsafePtr() {
+	if uintptrEscapesHack && n.Op() == ir.OCONVNOP && n.Left().Type().IsUnsafePtr() {
 		// nop
-	} else if k.derefs >= 0 && !n.Type.HasPointers() {
+	} else if k.derefs >= 0 && !n.Type().HasPointers() {
 		k = e.discardHole()
 	}
 
-	switch n.Op {
+	switch n.Op() {
 	default:
 		base.Fatalf("unexpected expr: %v", n)
 
@@ -488,61 +488,61 @@ func (e *Escape) exprSkipInit(k EscHole, n *ir.Node) {
 		e.flow(k, e.oldLoc(n))
 
 	case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT:
-		e.discard(n.Left)
+		e.discard(n.Left())
 	case ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.ODIV, ir.OMOD, ir.OLSH, ir.ORSH, ir.OAND, ir.OANDNOT, ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE, ir.OANDAND, ir.OOROR:
-		e.discard(n.Left)
-		e.discard(n.Right)
+		e.discard(n.Left())
+		e.discard(n.Right())
 
 	case ir.OADDR:
-		e.expr(k.addr(n, "address-of"), n.Left) // "address-of"
+		e.expr(k.addr(n, "address-of"), n.Left()) // "address-of"
 	case ir.ODEREF:
-		e.expr(k.deref(n, "indirection"), n.Left) // "indirection"
+		e.expr(k.deref(n, "indirection"), n.Left()) // "indirection"
 	case ir.ODOT, ir.ODOTMETH, ir.ODOTINTER:
-		e.expr(k.note(n, "dot"), n.Left)
+		e.expr(k.note(n, "dot"), n.Left())
 	case ir.ODOTPTR:
-		e.expr(k.deref(n, "dot of pointer"), n.Left) // "dot of pointer"
+		e.expr(k.deref(n, "dot of pointer"), n.Left()) // "dot of pointer"
 	case ir.ODOTTYPE, ir.ODOTTYPE2:
-		e.expr(k.dotType(n.Type, n, "dot"), n.Left)
+		e.expr(k.dotType(n.Type(), n, "dot"), n.Left())
 	case ir.OINDEX:
-		if n.Left.Type.IsArray() {
-			e.expr(k.note(n, "fixed-array-index-of"), n.Left)
+		if n.Left().Type().IsArray() {
+			e.expr(k.note(n, "fixed-array-index-of"), n.Left())
 		} else {
 			// TODO(mdempsky): Fix why reason text.
-			e.expr(k.deref(n, "dot of pointer"), n.Left)
+			e.expr(k.deref(n, "dot of pointer"), n.Left())
 		}
-		e.discard(n.Right)
+		e.discard(n.Right())
 	case ir.OINDEXMAP:
-		e.discard(n.Left)
-		e.discard(n.Right)
+		e.discard(n.Left())
+		e.discard(n.Right())
 	case ir.OSLICE, ir.OSLICEARR, ir.OSLICE3, ir.OSLICE3ARR, ir.OSLICESTR:
-		e.expr(k.note(n, "slice"), n.Left)
+		e.expr(k.note(n, "slice"), n.Left())
 		low, high, max := n.SliceBounds()
 		e.discard(low)
 		e.discard(high)
 		e.discard(max)
 
 	case ir.OCONV, ir.OCONVNOP:
-		if checkPtr(e.curfn, 2) && n.Type.IsUnsafePtr() && n.Left.Type.IsPtr() {
+		if checkPtr(e.curfn, 2) && n.Type().IsUnsafePtr() && n.Left().Type().IsPtr() {
 			// When -d=checkptr=2 is enabled, treat
 			// conversions to unsafe.Pointer as an
 			// escaping operation. This allows better
 			// runtime instrumentation, since we can more
 			// easily detect object boundaries on the heap
 			// than the stack.
-			e.assignHeap(n.Left, "conversion to unsafe.Pointer", n)
-		} else if n.Type.IsUnsafePtr() && n.Left.Type.IsUintptr() {
-			e.unsafeValue(k, n.Left)
+			e.assignHeap(n.Left(), "conversion to unsafe.Pointer", n)
+		} else if n.Type().IsUnsafePtr() && n.Left().Type().IsUintptr() {
+			e.unsafeValue(k, n.Left())
 		} else {
-			e.expr(k, n.Left)
+			e.expr(k, n.Left())
 		}
 	case ir.OCONVIFACE:
-		if !n.Left.Type.IsInterface() && !isdirectiface(n.Left.Type) {
+		if !n.Left().Type().IsInterface() && !isdirectiface(n.Left().Type()) {
 			k = e.spill(k, n)
 		}
-		e.expr(k.note(n, "interface-converted"), n.Left)
+		e.expr(k.note(n, "interface-converted"), n.Left())
 
 	case ir.ORECV:
-		e.discard(n.Left)
+		e.discard(n.Left())
 
 	case ir.OCALLMETH, ir.OCALLFUNC, ir.OCALLINTER, ir.OLEN, ir.OCAP, ir.OCOMPLEX, ir.OREAL, ir.OIMAG, ir.OAPPEND, ir.OCOPY:
 		e.call([]EscHole{k}, n, nil)
@@ -552,13 +552,13 @@ func (e *Escape) exprSkipInit(k EscHole, n *ir.Node) {
 
 	case ir.OMAKESLICE:
 		e.spill(k, n)
-		e.discard(n.Left)
-		e.discard(n.Right)
+		e.discard(n.Left())
+		e.discard(n.Right())
 	case ir.OMAKECHAN:
-		e.discard(n.Left)
+		e.discard(n.Left())
 	case ir.OMAKEMAP:
 		e.spill(k, n)
-		e.discard(n.Left)
+		e.discard(n.Left())
 
 	case ir.ORECOVER:
 		// nop
@@ -583,15 +583,15 @@ func (e *Escape) exprSkipInit(k EscHole, n *ir.Node) {
 		}
 		paramK := e.tagHole(ks, ir.AsNode(m.Nname), m.Type.Recv())
 
-		e.expr(e.teeHole(paramK, closureK), n.Left)
+		e.expr(e.teeHole(paramK, closureK), n.Left())
 
 	case ir.OPTRLIT:
-		e.expr(e.spill(k, n), n.Left)
+		e.expr(e.spill(k, n), n.Left())
 
 	case ir.OARRAYLIT:
-		for _, elt := range n.List.Slice() {
-			if elt.Op == ir.OKEY {
-				elt = elt.Right
+		for _, elt := range n.List().Slice() {
+			if elt.Op() == ir.OKEY {
+				elt = elt.Right()
 			}
 			e.expr(k.note(n, "array literal element"), elt)
 		}
@@ -600,89 +600,89 @@ func (e *Escape) exprSkipInit(k EscHole, n *ir.Node) {
 		k = e.spill(k, n)
 		k.uintptrEscapesHack = uintptrEscapesHack // for ...uintptr parameters
 
-		for _, elt := range n.List.Slice() {
-			if elt.Op == ir.OKEY {
-				elt = elt.Right
+		for _, elt := range n.List().Slice() {
+			if elt.Op() == ir.OKEY {
+				elt = elt.Right()
 			}
 			e.expr(k.note(n, "slice-literal-element"), elt)
 		}
 
 	case ir.OSTRUCTLIT:
-		for _, elt := range n.List.Slice() {
-			e.expr(k.note(n, "struct literal element"), elt.Left)
+		for _, elt := range n.List().Slice() {
+			e.expr(k.note(n, "struct literal element"), elt.Left())
 		}
 
 	case ir.OMAPLIT:
 		e.spill(k, n)
 
 		// Map keys and values are always stored in the heap.
-		for _, elt := range n.List.Slice() {
-			e.assignHeap(elt.Left, "map literal key", n)
-			e.assignHeap(elt.Right, "map literal value", n)
+		for _, elt := range n.List().Slice() {
+			e.assignHeap(elt.Left(), "map literal key", n)
+			e.assignHeap(elt.Right(), "map literal value", n)
 		}
 
 	case ir.OCLOSURE:
 		k = e.spill(k, n)
 
 		// Link addresses of captured variables to closure.
-		for _, v := range n.Func.ClosureVars.Slice() {
-			if v.Op == ir.OXXX { // unnamed out argument; see dcl.go:/^funcargs
+		for _, v := range n.Func().ClosureVars.Slice() {
+			if v.Op() == ir.OXXX { // unnamed out argument; see dcl.go:/^funcargs
 				continue
 			}
 
 			k := k
-			if !v.Name.Byval() {
+			if !v.Name().Byval() {
 				k = k.addr(v, "reference")
 			}
 
-			e.expr(k.note(n, "captured by a closure"), v.Name.Defn)
+			e.expr(k.note(n, "captured by a closure"), v.Name().Defn)
 		}
 
 	case ir.ORUNES2STR, ir.OBYTES2STR, ir.OSTR2RUNES, ir.OSTR2BYTES, ir.ORUNESTR:
 		e.spill(k, n)
-		e.discard(n.Left)
+		e.discard(n.Left())
 
 	case ir.OADDSTR:
 		e.spill(k, n)
 
 		// Arguments of OADDSTR never escape;
 		// runtime.concatstrings makes sure of that.
-		e.discards(n.List)
+		e.discards(n.List())
 	}
 }
 
 // unsafeValue evaluates a uintptr-typed arithmetic expression looking
 // for conversions from an unsafe.Pointer.
 func (e *Escape) unsafeValue(k EscHole, n *ir.Node) {
-	if n.Type.Etype != types.TUINTPTR {
-		base.Fatalf("unexpected type %v for %v", n.Type, n)
+	if n.Type().Etype != types.TUINTPTR {
+		base.Fatalf("unexpected type %v for %v", n.Type(), n)
 	}
 
-	e.stmts(n.Ninit)
+	e.stmts(n.Init())
 
-	switch n.Op {
+	switch n.Op() {
 	case ir.OCONV, ir.OCONVNOP:
-		if n.Left.Type.IsUnsafePtr() {
-			e.expr(k, n.Left)
+		if n.Left().Type().IsUnsafePtr() {
+			e.expr(k, n.Left())
 		} else {
-			e.discard(n.Left)
+			e.discard(n.Left())
 		}
 	case ir.ODOTPTR:
 		if isReflectHeaderDataField(n) {
-			e.expr(k.deref(n, "reflect.Header.Data"), n.Left)
+			e.expr(k.deref(n, "reflect.Header.Data"), n.Left())
 		} else {
-			e.discard(n.Left)
+			e.discard(n.Left())
 		}
 	case ir.OPLUS, ir.ONEG, ir.OBITNOT:
-		e.unsafeValue(k, n.Left)
+		e.unsafeValue(k, n.Left())
 	case ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.ODIV, ir.OMOD, ir.OAND, ir.OANDNOT:
-		e.unsafeValue(k, n.Left)
-		e.unsafeValue(k, n.Right)
+		e.unsafeValue(k, n.Left())
+		e.unsafeValue(k, n.Right())
 	case ir.OLSH, ir.ORSH:
-		e.unsafeValue(k, n.Left)
+		e.unsafeValue(k, n.Left())
 		// RHS need not be uintptr-typed (#32959) and can't meaningfully
 		// flow pointers anyway.
-		e.discard(n.Right)
+		e.discard(n.Right())
 	default:
 		e.exprSkipInit(e.discardHole(), n)
 	}
@@ -711,7 +711,7 @@ func (e *Escape) addr(n *ir.Node) EscHole {
 
 	k := e.heapHole()
 
-	switch n.Op {
+	switch n.Op() {
 	default:
 		base.Fatalf("unexpected addr: %v", n)
 	case ir.ONAME:
@@ -720,22 +720,22 @@ func (e *Escape) addr(n *ir.Node) EscHole {
 		}
 		k = e.oldLoc(n).asHole()
 	case ir.ODOT:
-		k = e.addr(n.Left)
+		k = e.addr(n.Left())
 	case ir.OINDEX:
-		e.discard(n.Right)
-		if n.Left.Type.IsArray() {
-			k = e.addr(n.Left)
+		e.discard(n.Right())
+		if n.Left().Type().IsArray() {
+			k = e.addr(n.Left())
 		} else {
-			e.discard(n.Left)
+			e.discard(n.Left())
 		}
 	case ir.ODEREF, ir.ODOTPTR:
 		e.discard(n)
 	case ir.OINDEXMAP:
-		e.discard(n.Left)
-		e.assignHeap(n.Right, "key of map put", n)
+		e.discard(n.Left())
+		e.assignHeap(n.Right(), "key of map put", n)
 	}
 
-	if !n.Type.HasPointers() {
+	if !n.Type().HasPointers() {
 		k = e.discardHole()
 	}
 
@@ -755,11 +755,11 @@ func (e *Escape) assign(dst, src *ir.Node, why string, where *ir.Node) {
 	// Filter out some no-op assignments for escape analysis.
 	ignore := dst != nil && src != nil && isSelfAssign(dst, src)
 	if ignore && base.Flag.LowerM != 0 {
-		base.WarnfAt(where.Pos, "%v ignoring self-assignment in %S", funcSym(e.curfn), where)
+		base.WarnfAt(where.Pos(), "%v ignoring self-assignment in %S", funcSym(e.curfn), where)
 	}
 
 	k := e.addr(dst)
-	if dst != nil && dst.Op == ir.ODOTPTR && isReflectHeaderDataField(dst) {
+	if dst != nil && dst.Op() == ir.ODOTPTR && isReflectHeaderDataField(dst) {
 		e.unsafeValue(e.heapHole().note(where, why), src)
 	} else {
 		if ignore {
@@ -777,11 +777,11 @@ func (e *Escape) assignHeap(src *ir.Node, why string, where *ir.Node) {
 // should contain the holes representing where the function callee's
 // results flows; where is the OGO/ODEFER context of the call, if any.
 func (e *Escape) call(ks []EscHole, call, where *ir.Node) {
-	topLevelDefer := where != nil && where.Op == ir.ODEFER && e.loopDepth == 1
+	topLevelDefer := where != nil && where.Op() == ir.ODEFER && e.loopDepth == 1
 	if topLevelDefer {
 		// force stack allocation of defer record, unless
 		// open-coded defers are used (see ssa.go)
-		where.Esc = EscNever
+		where.SetEsc(EscNever)
 	}
 
 	argument := func(k EscHole, arg *ir.Node) {
@@ -797,66 +797,66 @@ func (e *Escape) call(ks []EscHole, call, where *ir.Node) {
 		e.expr(k.note(call, "call parameter"), arg)
 	}
 
-	switch call.Op {
+	switch call.Op() {
 	default:
-		base.Fatalf("unexpected call op: %v", call.Op)
+		base.Fatalf("unexpected call op: %v", call.Op())
 
 	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
 		fixVariadicCall(call)
 
 		// Pick out the function callee, if statically known.
 		var fn *ir.Node
-		switch call.Op {
+		switch call.Op() {
 		case ir.OCALLFUNC:
-			switch v := staticValue(call.Left); {
-			case v.Op == ir.ONAME && v.Class() == ir.PFUNC:
+			switch v := staticValue(call.Left()); {
+			case v.Op() == ir.ONAME && v.Class() == ir.PFUNC:
 				fn = v
-			case v.Op == ir.OCLOSURE:
-				fn = v.Func.Nname
+			case v.Op() == ir.OCLOSURE:
+				fn = v.Func().Nname
 			}
 		case ir.OCALLMETH:
-			fn = methodExprName(call.Left)
+			fn = methodExprName(call.Left())
 		}
 
-		fntype := call.Left.Type
+		fntype := call.Left().Type()
 		if fn != nil {
-			fntype = fn.Type
+			fntype = fn.Type()
 		}
 
 		if ks != nil && fn != nil && e.inMutualBatch(fn) {
-			for i, result := range fn.Type.Results().FieldSlice() {
+			for i, result := range fn.Type().Results().FieldSlice() {
 				e.expr(ks[i], ir.AsNode(result.Nname))
 			}
 		}
 
 		if r := fntype.Recv(); r != nil {
-			argument(e.tagHole(ks, fn, r), call.Left.Left)
+			argument(e.tagHole(ks, fn, r), call.Left().Left())
 		} else {
 			// Evaluate callee function expression.
-			argument(e.discardHole(), call.Left)
+			argument(e.discardHole(), call.Left())
 		}
 
-		args := call.List.Slice()
+		args := call.List().Slice()
 		for i, param := range fntype.Params().FieldSlice() {
 			argument(e.tagHole(ks, fn, param), args[i])
 		}
 
 	case ir.OAPPEND:
-		args := call.List.Slice()
+		args := call.List().Slice()
 
 		// Appendee slice may flow directly to the result, if
 		// it has enough capacity. Alternatively, a new heap
 		// slice might be allocated, and all slice elements
 		// might flow to heap.
 		appendeeK := ks[0]
-		if args[0].Type.Elem().HasPointers() {
+		if args[0].Type().Elem().HasPointers() {
 			appendeeK = e.teeHole(appendeeK, e.heapHole().deref(call, "appendee slice"))
 		}
 		argument(appendeeK, args[0])
 
 		if call.IsDDD() {
 			appendedK := e.discardHole()
-			if args[1].Type.IsSlice() && args[1].Type.Elem().HasPointers() {
+			if args[1].Type().IsSlice() && args[1].Type().Elem().HasPointers() {
 				appendedK = e.heapHole().deref(call, "appended slice...")
 			}
 			argument(appendedK, args[1])
@@ -867,26 +867,26 @@ func (e *Escape) call(ks []EscHole, call, where *ir.Node) {
 		}
 
 	case ir.OCOPY:
-		argument(e.discardHole(), call.Left)
+		argument(e.discardHole(), call.Left())
 
 		copiedK := e.discardHole()
-		if call.Right.Type.IsSlice() && call.Right.Type.Elem().HasPointers() {
+		if call.Right().Type().IsSlice() && call.Right().Type().Elem().HasPointers() {
 			copiedK = e.heapHole().deref(call, "copied slice")
 		}
-		argument(copiedK, call.Right)
+		argument(copiedK, call.Right())
 
 	case ir.OPANIC:
-		argument(e.heapHole(), call.Left)
+		argument(e.heapHole(), call.Left())
 
 	case ir.OCOMPLEX:
-		argument(e.discardHole(), call.Left)
-		argument(e.discardHole(), call.Right)
+		argument(e.discardHole(), call.Left())
+		argument(e.discardHole(), call.Right())
 	case ir.ODELETE, ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
-		for _, arg := range call.List.Slice() {
+		for _, arg := range call.List().Slice() {
 			argument(e.discardHole(), arg)
 		}
 	case ir.OLEN, ir.OCAP, ir.OREAL, ir.OIMAG, ir.OCLOSE:
-		argument(e.discardHole(), call.Left)
+		argument(e.discardHole(), call.Left())
 	}
 }
 
@@ -936,8 +936,8 @@ func (e *Escape) tagHole(ks []EscHole, fn *ir.Node, param *types.Field) EscHole
 // should be incorporated directly into the flow graph instead of
 // relying on its escape analysis tagging.
 func (e *Escape) inMutualBatch(fn *ir.Node) bool {
-	if fn.Name.Defn != nil && fn.Name.Defn.Esc < EscFuncTagged {
-		if fn.Name.Defn.Esc == EscFuncUnknown {
+	if fn.Name().Defn != nil && fn.Name().Defn.Esc() < EscFuncTagged {
+		if fn.Name().Defn.Esc() == EscFuncUnknown {
 			base.Fatalf("graph inconsistency")
 		}
 		return true
@@ -1053,9 +1053,9 @@ func (e *Escape) later(k EscHole) EscHole {
 // canonicalNode returns the canonical *Node that n logically
 // represents.
 func canonicalNode(n *ir.Node) *ir.Node {
-	if n != nil && n.Op == ir.ONAME && n.Name.IsClosureVar() {
-		n = n.Name.Defn
-		if n.Name.IsClosureVar() {
+	if n != nil && n.Op() == ir.ONAME && n.Name().IsClosureVar() {
+		n = n.Name().Defn
+		if n.Name().IsClosureVar() {
 			base.Fatalf("still closure var")
 		}
 	}
@@ -1067,8 +1067,8 @@ func (e *Escape) newLoc(n *ir.Node, transient bool) *EscLocation {
 	if e.curfn == nil {
 		base.Fatalf("e.curfn isn't set")
 	}
-	if n != nil && n.Type != nil && n.Type.NotInHeap() {
-		base.ErrorfAt(n.Pos, "%v is incomplete (or unallocatable); stack allocation disallowed", n.Type)
+	if n != nil && n.Type() != nil && n.Type().NotInHeap() {
+		base.ErrorfAt(n.Pos(), "%v is incomplete (or unallocatable); stack allocation disallowed", n.Type())
 	}
 
 	n = canonicalNode(n)
@@ -1080,8 +1080,8 @@ func (e *Escape) newLoc(n *ir.Node, transient bool) *EscLocation {
 	}
 	e.allLocs = append(e.allLocs, loc)
 	if n != nil {
-		if n.Op == ir.ONAME && n.Name.Curfn != e.curfn {
-			base.Fatalf("curfn mismatch: %v != %v", n.Name.Curfn, e.curfn)
+		if n.Op() == ir.ONAME && n.Name().Curfn != e.curfn {
+			base.Fatalf("curfn mismatch: %v != %v", n.Name().Curfn, e.curfn)
 		}
 
 		if n.HasOpt() {
@@ -1115,13 +1115,13 @@ func (e *Escape) flow(k EscHole, src *EscLocation) {
 	}
 	if dst.escapes && k.derefs < 0 { // dst = &src
 		if base.Flag.LowerM >= 2 || logopt.Enabled() {
-			pos := base.FmtPos(src.n.Pos)
+			pos := base.FmtPos(src.n.Pos())
 			if base.Flag.LowerM >= 2 {
 				fmt.Printf("%s: %v escapes to heap:\n", pos, src.n)
 			}
 			explanation := e.explainFlow(pos, dst, src, k.derefs, k.notes, []*logopt.LoggedOpt{})
 			if logopt.Enabled() {
-				logopt.LogOpt(src.n.Pos, "escapes", "escape", ir.FuncName(e.curfn), fmt.Sprintf("%v escapes to heap", src.n), explanation)
+				logopt.LogOpt(src.n.Pos(), "escapes", "escape", ir.FuncName(e.curfn), fmt.Sprintf("%v escapes to heap", src.n), explanation)
 			}
 
 		}
@@ -1218,11 +1218,11 @@ func (e *Escape) walkOne(root *EscLocation, walkgen uint32, enqueue func(*EscLoc
 			if l.isName(ir.PPARAM) {
 				if (logopt.Enabled() || base.Flag.LowerM >= 2) && !l.escapes {
 					if base.Flag.LowerM >= 2 {
-						fmt.Printf("%s: parameter %v leaks to %s with derefs=%d:\n", base.FmtPos(l.n.Pos), l.n, e.explainLoc(root), derefs)
+						fmt.Printf("%s: parameter %v leaks to %s with derefs=%d:\n", base.FmtPos(l.n.Pos()), l.n, e.explainLoc(root), derefs)
 					}
 					explanation := e.explainPath(root, l)
 					if logopt.Enabled() {
-						logopt.LogOpt(l.n.Pos, "leak", "escape", ir.FuncName(e.curfn),
+						logopt.LogOpt(l.n.Pos(), "leak", "escape", ir.FuncName(e.curfn),
 							fmt.Sprintf("parameter %v leaks to %s with derefs=%d", l.n, e.explainLoc(root), derefs), explanation)
 					}
 				}
@@ -1235,11 +1235,11 @@ func (e *Escape) walkOne(root *EscLocation, walkgen uint32, enqueue func(*EscLoc
 			if addressOf && !l.escapes {
 				if logopt.Enabled() || base.Flag.LowerM >= 2 {
 					if base.Flag.LowerM >= 2 {
-						fmt.Printf("%s: %v escapes to heap:\n", base.FmtPos(l.n.Pos), l.n)
+						fmt.Printf("%s: %v escapes to heap:\n", base.FmtPos(l.n.Pos()), l.n)
 					}
 					explanation := e.explainPath(root, l)
 					if logopt.Enabled() {
-						logopt.LogOpt(l.n.Pos, "escape", "escape", ir.FuncName(e.curfn), fmt.Sprintf("%v escapes to heap", l.n), explanation)
+						logopt.LogOpt(l.n.Pos(), "escape", "escape", ir.FuncName(e.curfn), fmt.Sprintf("%v escapes to heap", l.n), explanation)
 					}
 				}
 				l.escapes = true
@@ -1267,7 +1267,7 @@ func (e *Escape) walkOne(root *EscLocation, walkgen uint32, enqueue func(*EscLoc
 // explainPath prints an explanation of how src flows to the walk root.
 func (e *Escape) explainPath(root, src *EscLocation) []*logopt.LoggedOpt {
 	visited := make(map[*EscLocation]bool)
-	pos := base.FmtPos(src.n.Pos)
+	pos := base.FmtPos(src.n.Pos())
 	var explanation []*logopt.LoggedOpt
 	for {
 		// Prevent infinite loop.
@@ -1309,19 +1309,19 @@ func (e *Escape) explainFlow(pos string, dst, srcloc *EscLocation, derefs int, n
 	if logopt.Enabled() {
 		var epos src.XPos
 		if notes != nil {
-			epos = notes.where.Pos
+			epos = notes.where.Pos()
 		} else if srcloc != nil && srcloc.n != nil {
-			epos = srcloc.n.Pos
+			epos = srcloc.n.Pos()
 		}
 		explanation = append(explanation, logopt.NewLoggedOpt(epos, "escflow", "escape", ir.FuncName(e.curfn), flow))
 	}
 
 	for note := notes; note != nil; note = note.next {
 		if print {
-			fmt.Printf("%s:     from %v (%v) at %s\n", pos, note.where, note.why, base.FmtPos(note.where.Pos))
+			fmt.Printf("%s:     from %v (%v) at %s\n", pos, note.where, note.why, base.FmtPos(note.where.Pos()))
 		}
 		if logopt.Enabled() {
-			explanation = append(explanation, logopt.NewLoggedOpt(note.where.Pos, "escflow", "escape", ir.FuncName(e.curfn),
+			explanation = append(explanation, logopt.NewLoggedOpt(note.where.Pos(), "escflow", "escape", ir.FuncName(e.curfn),
 				fmt.Sprintf("     from %v (%v)", note.where, note.why)))
 		}
 	}
@@ -1336,7 +1336,7 @@ func (e *Escape) explainLoc(l *EscLocation) string {
 		// TODO(mdempsky): Omit entirely.
 		return "{temp}"
 	}
-	if l.n.Op == ir.ONAME {
+	if l.n.Op() == ir.ONAME {
 		return fmt.Sprintf("%v", l.n)
 	}
 	return fmt.Sprintf("{storage for %v}", l.n)
@@ -1360,7 +1360,7 @@ func (e *Escape) outlives(l, other *EscLocation) bool {
 		//
 		//    var u int  // okay to stack allocate
 		//    *(func() *int { return &u }()) = 42
-		if containsClosure(other.curfn, l.curfn) && l.curfn.Func.ClosureCalled {
+		if containsClosure(other.curfn, l.curfn) && l.curfn.Func().ClosureCalled {
 			return false
 		}
 
@@ -1395,7 +1395,7 @@ func (e *Escape) outlives(l, other *EscLocation) bool {
 
 // containsClosure reports whether c is a closure contained within f.
 func containsClosure(f, c *ir.Node) bool {
-	if f.Op != ir.ODCLFUNC || c.Op != ir.ODCLFUNC {
+	if f.Op() != ir.ODCLFUNC || c.Op() != ir.ODCLFUNC {
 		base.Fatalf("bad containsClosure: %v, %v", f, c)
 	}
 
@@ -1406,8 +1406,8 @@ func containsClosure(f, c *ir.Node) bool {
 
 	// Closures within function Foo are named like "Foo.funcN..."
 	// TODO(mdempsky): Better way to recognize this.
-	fn := f.Func.Nname.Sym.Name
-	cn := c.Func.Nname.Sym.Name
+	fn := f.Func().Nname.Sym().Name
+	cn := c.Func().Nname.Sym().Name
 	return len(cn) > len(fn) && cn[:len(fn)] == fn && cn[len(fn)] == '.'
 }
 
@@ -1417,7 +1417,7 @@ func (l *EscLocation) leakTo(sink *EscLocation, derefs int) {
 	// into the escape analysis tag, then record a return leak.
 	if sink.isName(ir.PPARAMOUT) && sink.curfn == l.curfn {
 		// TODO(mdempsky): Eliminate dependency on Vargen here.
-		ri := int(sink.n.Name.Vargen) - 1
+		ri := int(sink.n.Name().Vargen) - 1
 		if ri < numEscResults {
 			// Leak to result parameter.
 			l.paramEsc.AddResult(ri, derefs)
@@ -1432,11 +1432,11 @@ func (l *EscLocation) leakTo(sink *EscLocation, derefs int) {
 func (e *Escape) finish(fns []*ir.Node) {
 	// Record parameter tags for package export data.
 	for _, fn := range fns {
-		fn.Esc = EscFuncTagged
+		fn.SetEsc(EscFuncTagged)
 
 		narg := 0
 		for _, fs := range &types.RecvsParams {
-			for _, f := range fs(fn.Type).Fields().Slice() {
+			for _, f := range fs(fn.Type()).Fields().Slice() {
 				narg++
 				f.Note = e.paramTag(fn, narg, f)
 			}
@@ -1453,21 +1453,21 @@ func (e *Escape) finish(fns []*ir.Node) {
 		// Update n.Esc based on escape analysis results.
 
 		if loc.escapes {
-			if n.Op != ir.ONAME {
+			if n.Op() != ir.ONAME {
 				if base.Flag.LowerM != 0 {
-					base.WarnfAt(n.Pos, "%S escapes to heap", n)
+					base.WarnfAt(n.Pos(), "%S escapes to heap", n)
 				}
 				if logopt.Enabled() {
-					logopt.LogOpt(n.Pos, "escape", "escape", ir.FuncName(e.curfn))
+					logopt.LogOpt(n.Pos(), "escape", "escape", ir.FuncName(e.curfn))
 				}
 			}
-			n.Esc = EscHeap
+			n.SetEsc(EscHeap)
 			addrescapes(n)
 		} else {
-			if base.Flag.LowerM != 0 && n.Op != ir.ONAME {
-				base.WarnfAt(n.Pos, "%S does not escape", n)
+			if base.Flag.LowerM != 0 && n.Op() != ir.ONAME {
+				base.WarnfAt(n.Pos(), "%S does not escape", n)
 			}
-			n.Esc = EscNone
+			n.SetEsc(EscNone)
 			if loc.transient {
 				n.SetTransient(true)
 			}
@@ -1476,7 +1476,7 @@ func (e *Escape) finish(fns []*ir.Node) {
 }
 
 func (l *EscLocation) isName(c ir.Class) bool {
-	return l.n != nil && l.n.Op == ir.ONAME && l.n.Class() == c
+	return l.n != nil && l.n.Op() == ir.ONAME && l.n.Class() == c
 }
 
 const numEscResults = 7
@@ -1608,10 +1608,10 @@ const (
 
 // funcSym returns fn.Func.Nname.Sym if no nils are encountered along the way.
 func funcSym(fn *ir.Node) *types.Sym {
-	if fn == nil || fn.Func.Nname == nil {
+	if fn == nil || fn.Func().Nname == nil {
 		return nil
 	}
-	return fn.Func.Nname.Sym
+	return fn.Func().Nname.Sym()
 }
 
 // Mark labels that have no backjumps to them as not increasing e.loopdepth.
@@ -1639,11 +1639,11 @@ func isSliceSelfAssign(dst, src *ir.Node) bool {
 	// when we evaluate it for dst and for src.
 
 	// dst is ONAME dereference.
-	if dst.Op != ir.ODEREF && dst.Op != ir.ODOTPTR || dst.Left.Op != ir.ONAME {
+	if dst.Op() != ir.ODEREF && dst.Op() != ir.ODOTPTR || dst.Left().Op() != ir.ONAME {
 		return false
 	}
 	// src is a slice operation.
-	switch src.Op {
+	switch src.Op() {
 	case ir.OSLICE, ir.OSLICE3, ir.OSLICESTR:
 		// OK.
 	case ir.OSLICEARR, ir.OSLICE3ARR:
@@ -1656,18 +1656,18 @@ func isSliceSelfAssign(dst, src *ir.Node) bool {
 		// Pointer to an array is OK since it's not stored inside b directly.
 		// For slicing an array (not pointer to array), there is an implicit OADDR.
 		// We check that to determine non-pointer array slicing.
-		if src.Left.Op == ir.OADDR {
+		if src.Left().Op() == ir.OADDR {
 			return false
 		}
 	default:
 		return false
 	}
 	// slice is applied to ONAME dereference.
-	if src.Left.Op != ir.ODEREF && src.Left.Op != ir.ODOTPTR || src.Left.Left.Op != ir.ONAME {
+	if src.Left().Op() != ir.ODEREF && src.Left().Op() != ir.ODOTPTR || src.Left().Left().Op() != ir.ONAME {
 		return false
 	}
 	// dst and src reference the same base ONAME.
-	return dst.Left == src.Left.Left
+	return dst.Left() == src.Left().Left()
 }
 
 // isSelfAssign reports whether assignment from src to dst can
@@ -1687,15 +1687,15 @@ func isSelfAssign(dst, src *ir.Node) bool {
 	//
 	// These assignments do not change assigned object lifetime.
 
-	if dst == nil || src == nil || dst.Op != src.Op {
+	if dst == nil || src == nil || dst.Op() != src.Op() {
 		return false
 	}
 
-	switch dst.Op {
+	switch dst.Op() {
 	case ir.ODOT, ir.ODOTPTR:
 		// Safe trailing accessors that are permitted to differ.
 	case ir.OINDEX:
-		if mayAffectMemory(dst.Right) || mayAffectMemory(src.Right) {
+		if mayAffectMemory(dst.Right()) || mayAffectMemory(src.Right()) {
 			return false
 		}
 	default:
@@ -1703,7 +1703,7 @@ func isSelfAssign(dst, src *ir.Node) bool {
 	}
 
 	// The expression prefix must be both "safe" and identical.
-	return samesafeexpr(dst.Left, src.Left)
+	return samesafeexpr(dst.Left(), src.Left())
 }
 
 // mayAffectMemory reports whether evaluation of n may affect the program's
@@ -1716,18 +1716,18 @@ func mayAffectMemory(n *ir.Node) bool {
 	//
 	// We're ignoring things like division by zero, index out of range,
 	// and nil pointer dereference here.
-	switch n.Op {
+	switch n.Op() {
 	case ir.ONAME, ir.OCLOSUREVAR, ir.OLITERAL, ir.ONIL:
 		return false
 
 	// Left+Right group.
 	case ir.OINDEX, ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.OLSH, ir.ORSH, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OMOD:
-		return mayAffectMemory(n.Left) || mayAffectMemory(n.Right)
+		return mayAffectMemory(n.Left()) || mayAffectMemory(n.Right())
 
 	// Left group.
 	case ir.ODOT, ir.ODOTPTR, ir.ODEREF, ir.OCONVNOP, ir.OCONV, ir.OLEN, ir.OCAP,
 		ir.ONOT, ir.OBITNOT, ir.OPLUS, ir.ONEG, ir.OALIGNOF, ir.OOFFSETOF, ir.OSIZEOF:
-		return mayAffectMemory(n.Left)
+		return mayAffectMemory(n.Left())
 
 	default:
 		return true
@@ -1737,39 +1737,39 @@ func mayAffectMemory(n *ir.Node) bool {
 // heapAllocReason returns the reason the given Node must be heap
 // allocated, or the empty string if it doesn't.
 func heapAllocReason(n *ir.Node) string {
-	if n.Type == nil {
+	if n.Type() == nil {
 		return ""
 	}
 
 	// Parameters are always passed via the stack.
-	if n.Op == ir.ONAME && (n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT) {
+	if n.Op() == ir.ONAME && (n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT) {
 		return ""
 	}
 
-	if n.Type.Width > maxStackVarSize {
+	if n.Type().Width > maxStackVarSize {
 		return "too large for stack"
 	}
 
-	if (n.Op == ir.ONEW || n.Op == ir.OPTRLIT) && n.Type.Elem().Width >= maxImplicitStackVarSize {
+	if (n.Op() == ir.ONEW || n.Op() == ir.OPTRLIT) && n.Type().Elem().Width >= maxImplicitStackVarSize {
 		return "too large for stack"
 	}
 
-	if n.Op == ir.OCLOSURE && closureType(n).Size() >= maxImplicitStackVarSize {
+	if n.Op() == ir.OCLOSURE && closureType(n).Size() >= maxImplicitStackVarSize {
 		return "too large for stack"
 	}
-	if n.Op == ir.OCALLPART && partialCallType(n).Size() >= maxImplicitStackVarSize {
+	if n.Op() == ir.OCALLPART && partialCallType(n).Size() >= maxImplicitStackVarSize {
 		return "too large for stack"
 	}
 
-	if n.Op == ir.OMAKESLICE {
-		r := n.Right
+	if n.Op() == ir.OMAKESLICE {
+		r := n.Right()
 		if r == nil {
-			r = n.Left
+			r = n.Left()
 		}
 		if !smallintconst(r) {
 			return "non-constant size"
 		}
-		if t := n.Type; t.Elem().Width != 0 && r.Int64Val() >= maxImplicitStackVarSize/t.Elem().Width {
+		if t := n.Type(); t.Elem().Width != 0 && r.Int64Val() >= maxImplicitStackVarSize/t.Elem().Width {
 			return "too large for stack"
 		}
 	}
@@ -1782,7 +1782,7 @@ func heapAllocReason(n *ir.Node) string {
 // Storage is allocated as necessary to allow the address
 // to be taken.
 func addrescapes(n *ir.Node) {
-	switch n.Op {
+	switch n.Op() {
 	default:
 		// Unexpected Op, probably due to a previous type error. Ignore.
 
@@ -1796,13 +1796,13 @@ func addrescapes(n *ir.Node) {
 
 		// if this is a tmpname (PAUTO), it was tagged by tmpname as not escaping.
 		// on PPARAM it means something different.
-		if n.Class() == ir.PAUTO && n.Esc == EscNever {
+		if n.Class() == ir.PAUTO && n.Esc() == EscNever {
 			break
 		}
 
 		// If a closure reference escapes, mark the outer variable as escaping.
-		if n.Name.IsClosureVar() {
-			addrescapes(n.Name.Defn)
+		if n.Name().IsClosureVar() {
+			addrescapes(n.Name().Defn)
 			break
 		}
 
@@ -1823,13 +1823,13 @@ func addrescapes(n *ir.Node) {
 		// then we're analyzing the inner closure but we need to move x to the
 		// heap in f, not in the inner closure. Flip over to f before calling moveToHeap.
 		oldfn := Curfn
-		Curfn = n.Name.Curfn
-		if Curfn.Op == ir.OCLOSURE {
-			Curfn = Curfn.Func.Decl
+		Curfn = n.Name().Curfn
+		if Curfn.Op() == ir.OCLOSURE {
+			Curfn = Curfn.Func().Decl
 			panic("can't happen")
 		}
 		ln := base.Pos
-		base.Pos = Curfn.Pos
+		base.Pos = Curfn.Pos()
 		moveToHeap(n)
 		Curfn = oldfn
 		base.Pos = ln
@@ -1840,8 +1840,8 @@ func addrescapes(n *ir.Node) {
 	// escape--the pointer inside x does, but that
 	// is always a heap pointer anyway.
 	case ir.ODOT, ir.OINDEX, ir.OPAREN, ir.OCONVNOP:
-		if !n.Left.Type.IsSlice() {
-			addrescapes(n.Left)
+		if !n.Left().Type().IsSlice() {
+			addrescapes(n.Left())
 		}
 	}
 }
@@ -1861,21 +1861,21 @@ func moveToHeap(n *ir.Node) {
 
 	// Allocate a local stack variable to hold the pointer to the heap copy.
 	// temp will add it to the function declaration list automatically.
-	heapaddr := temp(types.NewPtr(n.Type))
-	heapaddr.Sym = lookup("&" + n.Sym.Name)
-	heapaddr.Orig.Sym = heapaddr.Sym
-	heapaddr.Pos = n.Pos
+	heapaddr := temp(types.NewPtr(n.Type()))
+	heapaddr.SetSym(lookup("&" + n.Sym().Name))
+	heapaddr.Orig().SetSym(heapaddr.Sym())
+	heapaddr.SetPos(n.Pos())
 
 	// Unset AutoTemp to persist the &foo variable name through SSA to
 	// liveness analysis.
 	// TODO(mdempsky/drchase): Cleaner solution?
-	heapaddr.Name.SetAutoTemp(false)
+	heapaddr.Name().SetAutoTemp(false)
 
 	// Parameters have a local stack copy used at function start/end
 	// in addition to the copy in the heap that may live longer than
 	// the function.
 	if n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT {
-		if n.Xoffset == types.BADWIDTH {
+		if n.Offset() == types.BADWIDTH {
 			base.Fatalf("addrescapes before param assignment")
 		}
 
@@ -1883,28 +1883,28 @@ func moveToHeap(n *ir.Node) {
 		// Preserve a copy so we can still write code referring to the original,
 		// and substitute that copy into the function declaration list
 		// so that analyses of the local (on-stack) variables use it.
-		stackcopy := NewName(n.Sym)
-		stackcopy.Type = n.Type
-		stackcopy.Xoffset = n.Xoffset
+		stackcopy := NewName(n.Sym())
+		stackcopy.SetType(n.Type())
+		stackcopy.SetOffset(n.Offset())
 		stackcopy.SetClass(n.Class())
-		stackcopy.Name.Param.Heapaddr = heapaddr
+		stackcopy.Name().Param.Heapaddr = heapaddr
 		if n.Class() == ir.PPARAMOUT {
 			// Make sure the pointer to the heap copy is kept live throughout the function.
 			// The function could panic at any point, and then a defer could recover.
 			// Thus, we need the pointer to the heap copy always available so the
 			// post-deferreturn code can copy the return value back to the stack.
 			// See issue 16095.
-			heapaddr.Name.SetIsOutputParamHeapAddr(true)
+			heapaddr.Name().SetIsOutputParamHeapAddr(true)
 		}
-		n.Name.Param.Stackcopy = stackcopy
+		n.Name().Param.Stackcopy = stackcopy
 
 		// Substitute the stackcopy into the function variable list so that
 		// liveness and other analyses use the underlying stack slot
 		// and not the now-pseudo-variable n.
 		found := false
-		for i, d := range Curfn.Func.Dcl {
+		for i, d := range Curfn.Func().Dcl {
 			if d == n {
-				Curfn.Func.Dcl[i] = stackcopy
+				Curfn.Func().Dcl[i] = stackcopy
 				found = true
 				break
 			}
@@ -1917,16 +1917,16 @@ func moveToHeap(n *ir.Node) {
 		if !found {
 			base.Fatalf("cannot find %v in local variable list", n)
 		}
-		Curfn.Func.Dcl = append(Curfn.Func.Dcl, n)
+		Curfn.Func().Dcl = append(Curfn.Func().Dcl, n)
 	}
 
 	// Modify n in place so that uses of n now mean indirection of the heapaddr.
 	n.SetClass(ir.PAUTOHEAP)
-	n.Xoffset = 0
-	n.Name.Param.Heapaddr = heapaddr
-	n.Esc = EscHeap
+	n.SetOffset(0)
+	n.Name().Param.Heapaddr = heapaddr
+	n.SetEsc(EscHeap)
 	if base.Flag.LowerM != 0 {
-		base.WarnfAt(n.Pos, "moved to heap: %v", n)
+		base.WarnfAt(n.Pos(), "moved to heap: %v", n)
 	}
 }
 
@@ -1947,7 +1947,7 @@ func (e *Escape) paramTag(fn *ir.Node, narg int, f *types.Field) string {
 		return fmt.Sprintf("arg#%d", narg)
 	}
 
-	if fn.Nbody.Len() == 0 {
+	if fn.Body().Len() == 0 {
 		// Assume that uintptr arguments must be held live across the call.
 		// This is most important for syscall.Syscall.
 		// See golang.org/issue/13372.
@@ -1969,7 +1969,7 @@ func (e *Escape) paramTag(fn *ir.Node, narg int, f *types.Field) string {
 
 		// External functions are assumed unsafe, unless
 		// //go:noescape is given before the declaration.
-		if fn.Func.Pragma&ir.Noescape != 0 {
+		if fn.Func().Pragma&ir.Noescape != 0 {
 			if base.Flag.LowerM != 0 && f.Sym != nil {
 				base.WarnfAt(f.Pos, "%v does not escape", name())
 			}
@@ -1983,7 +1983,7 @@ func (e *Escape) paramTag(fn *ir.Node, narg int, f *types.Field) string {
 		return esc.Encode()
 	}
 
-	if fn.Func.Pragma&ir.UintptrEscapes != 0 {
+	if fn.Func().Pragma&ir.UintptrEscapes != 0 {
 		if f.Type.IsUintptr() {
 			if base.Flag.LowerM != 0 {
 				base.WarnfAt(f.Pos, "marking %v as escaping uintptr", name())
@@ -2028,7 +2028,7 @@ func (e *Escape) paramTag(fn *ir.Node, narg int, f *types.Field) string {
 		}
 		for i := 0; i < numEscResults; i++ {
 			if x := esc.Result(i); x >= 0 {
-				res := fn.Type.Results().Field(i).Sym
+				res := fn.Type().Results().Field(i).Sym
 				base.WarnfAt(f.Pos, "leaking param: %v to result %v level=%d", name(), res, x)
 			}
 		}
diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index 36bbb75050..1f0288a591 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -25,13 +25,13 @@ var asmlist []*ir.Node
 
 // exportsym marks n for export (or reexport).
 func exportsym(n *ir.Node) {
-	if n.Sym.OnExportList() {
+	if n.Sym().OnExportList() {
 		return
 	}
-	n.Sym.SetOnExportList(true)
+	n.Sym().SetOnExportList(true)
 
 	if base.Flag.E != 0 {
-		fmt.Printf("export symbol %v\n", n.Sym)
+		fmt.Printf("export symbol %v\n", n.Sym())
 	}
 
 	exportlist = append(exportlist, n)
@@ -42,21 +42,21 @@ func initname(s string) bool {
 }
 
 func autoexport(n *ir.Node, ctxt ir.Class) {
-	if n.Sym.Pkg != ir.LocalPkg {
+	if n.Sym().Pkg != ir.LocalPkg {
 		return
 	}
 	if (ctxt != ir.PEXTERN && ctxt != ir.PFUNC) || dclcontext != ir.PEXTERN {
 		return
 	}
-	if n.Type != nil && n.Type.IsKind(types.TFUNC) && ir.IsMethod(n) {
+	if n.Type() != nil && n.Type().IsKind(types.TFUNC) && ir.IsMethod(n) {
 		return
 	}
 
-	if types.IsExported(n.Sym.Name) || initname(n.Sym.Name) {
+	if types.IsExported(n.Sym().Name) || initname(n.Sym().Name) {
 		exportsym(n)
 	}
-	if base.Flag.AsmHdr != "" && !n.Sym.Asm() {
-		n.Sym.SetAsm(true)
+	if base.Flag.AsmHdr != "" && !n.Sym().Asm() {
+		n.Sym().SetAsm(true)
 		asmlist = append(asmlist, n)
 	}
 }
@@ -89,7 +89,7 @@ func importsym(ipkg *types.Pkg, s *types.Sym, op ir.Op) *ir.Node {
 		s.SetPkgDef(ir.AsTypesNode(n))
 		s.Importdef = ipkg
 	}
-	if n.Op != ir.ONONAME && n.Op != op {
+	if n.Op() != ir.ONONAME && n.Op() != op {
 		redeclare(base.Pos, s, fmt.Sprintf("during import %q", ipkg.Path))
 	}
 	return n
@@ -100,18 +100,18 @@ func importsym(ipkg *types.Pkg, s *types.Sym, op ir.Op) *ir.Node {
 // ipkg is the package being imported
 func importtype(ipkg *types.Pkg, pos src.XPos, s *types.Sym) *types.Type {
 	n := importsym(ipkg, s, ir.OTYPE)
-	if n.Op != ir.OTYPE {
+	if n.Op() != ir.OTYPE {
 		t := types.New(types.TFORW)
 		t.Sym = s
 		t.Nod = ir.AsTypesNode(n)
 
-		n.Op = ir.OTYPE
-		n.Pos = pos
-		n.Type = t
+		n.SetOp(ir.OTYPE)
+		n.SetPos(pos)
+		n.SetType(t)
 		n.SetClass(ir.PEXTERN)
 	}
 
-	t := n.Type
+	t := n.Type()
 	if t == nil {
 		base.Fatalf("importtype %v", s)
 	}
@@ -122,20 +122,20 @@ func importtype(ipkg *types.Pkg, pos src.XPos, s *types.Sym) *types.Type {
 // ipkg is the package being imported
 func importobj(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op ir.Op, ctxt ir.Class, t *types.Type) *ir.Node {
 	n := importsym(ipkg, s, op)
-	if n.Op != ir.ONONAME {
-		if n.Op == op && (n.Class() != ctxt || !types.Identical(n.Type, t)) {
+	if n.Op() != ir.ONONAME {
+		if n.Op() == op && (n.Class() != ctxt || !types.Identical(n.Type(), t)) {
 			redeclare(base.Pos, s, fmt.Sprintf("during import %q", ipkg.Path))
 		}
 		return nil
 	}
 
-	n.Op = op
-	n.Pos = pos
+	n.SetOp(op)
+	n.SetPos(pos)
 	n.SetClass(ctxt)
 	if ctxt == ir.PFUNC {
-		n.Sym.SetFunc(true)
+		n.Sym().SetFunc(true)
 	}
-	n.Type = t
+	n.SetType(t)
 	return n
 }
 
@@ -162,7 +162,7 @@ func importfunc(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) {
 		return
 	}
 
-	n.Func = new(ir.Func)
+	n.SetFunc(new(ir.Func))
 
 	if base.Flag.E != 0 {
 		fmt.Printf("import func %v%S\n", s, t)
@@ -202,26 +202,26 @@ func dumpasmhdr() {
 	}
 	fmt.Fprintf(b, "// generated by compile -asmhdr from package %s\n\n", ir.LocalPkg.Name)
 	for _, n := range asmlist {
-		if n.Sym.IsBlank() {
+		if n.Sym().IsBlank() {
 			continue
 		}
-		switch n.Op {
+		switch n.Op() {
 		case ir.OLITERAL:
 			t := n.Val().Kind()
 			if t == constant.Float || t == constant.Complex {
 				break
 			}
-			fmt.Fprintf(b, "#define const_%s %#v\n", n.Sym.Name, n.Val())
+			fmt.Fprintf(b, "#define const_%s %#v\n", n.Sym().Name, n.Val())
 
 		case ir.OTYPE:
-			t := n.Type
+			t := n.Type()
 			if !t.IsStruct() || t.StructType().Map != nil || t.IsFuncArgStruct() {
 				break
 			}
-			fmt.Fprintf(b, "#define %s__size %d\n", n.Sym.Name, int(t.Width))
+			fmt.Fprintf(b, "#define %s__size %d\n", n.Sym().Name, int(t.Width))
 			for _, f := range t.Fields().Slice() {
 				if !f.Sym.IsBlank() {
-					fmt.Fprintf(b, "#define %s_%s %d\n", n.Sym.Name, f.Sym.Name, int(f.Offset))
+					fmt.Fprintf(b, "#define %s_%s %d\n", n.Sym().Name, f.Sym.Name, int(f.Offset))
 				}
 			}
 		}
diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
index 0f5294b17d..d7320f3ccc 100644
--- a/src/cmd/compile/internal/gc/gen.go
+++ b/src/cmd/compile/internal/gc/gen.go
@@ -31,13 +31,13 @@ func sysvar(name string) *obj.LSym {
 // isParamStackCopy reports whether this is the on-stack copy of a
 // function parameter that moved to the heap.
 func isParamStackCopy(n *ir.Node) bool {
-	return n.Op == ir.ONAME && (n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT) && n.Name.Param.Heapaddr != nil
+	return n.Op() == ir.ONAME && (n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT) && n.Name().Param.Heapaddr != nil
 }
 
 // isParamHeapCopy reports whether this is the on-heap copy of
 // a function parameter that moved to the heap.
 func isParamHeapCopy(n *ir.Node) bool {
-	return n.Op == ir.ONAME && n.Class() == ir.PAUTOHEAP && n.Name.Param.Stackcopy != nil
+	return n.Op() == ir.ONAME && n.Class() == ir.PAUTOHEAP && n.Name().Param.Stackcopy != nil
 }
 
 // autotmpname returns the name for an autotmp variable numbered n.
@@ -56,7 +56,7 @@ func tempAt(pos src.XPos, curfn *ir.Node, t *types.Type) *ir.Node {
 	if curfn == nil {
 		base.Fatalf("no curfn for tempAt")
 	}
-	if curfn.Op == ir.OCLOSURE {
+	if curfn.Op() == ir.OCLOSURE {
 		ir.Dump("tempAt", curfn)
 		base.Fatalf("adding tempAt to wrong closure function")
 	}
@@ -65,22 +65,22 @@ func tempAt(pos src.XPos, curfn *ir.Node, t *types.Type) *ir.Node {
 	}
 
 	s := &types.Sym{
-		Name: autotmpname(len(curfn.Func.Dcl)),
+		Name: autotmpname(len(curfn.Func().Dcl)),
 		Pkg:  ir.LocalPkg,
 	}
 	n := ir.NewNameAt(pos, s)
 	s.Def = ir.AsTypesNode(n)
-	n.Type = t
+	n.SetType(t)
 	n.SetClass(ir.PAUTO)
-	n.Esc = EscNever
-	n.Name.Curfn = curfn
-	n.Name.SetUsed(true)
-	n.Name.SetAutoTemp(true)
-	curfn.Func.Dcl = append(curfn.Func.Dcl, n)
+	n.SetEsc(EscNever)
+	n.Name().Curfn = curfn
+	n.Name().SetUsed(true)
+	n.Name().SetAutoTemp(true)
+	curfn.Func().Dcl = append(curfn.Func().Dcl, n)
 
 	dowidth(t)
 
-	return n.Orig
+	return n.Orig()
 }
 
 func temp(t *types.Type) *ir.Node {
diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go
index cf1c85ce29..3416a00cd1 100644
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ b/src/cmd/compile/internal/gc/gsubr.go
@@ -69,7 +69,7 @@ func newProgs(fn *ir.Node, worker int) *Progs {
 	pp.next = pp.NewProg()
 	pp.clearp(pp.next)
 
-	pp.pos = fn.Pos
+	pp.pos = fn.Pos()
 	pp.settext(fn)
 	// PCDATA tables implicitly start with index -1.
 	pp.prevLive = LivenessIndex{-1, false}
@@ -181,10 +181,10 @@ func (pp *Progs) settext(fn *ir.Node) {
 	ptxt := pp.Prog(obj.ATEXT)
 	pp.Text = ptxt
 
-	fn.Func.LSym.Func().Text = ptxt
+	fn.Func().LSym.Func().Text = ptxt
 	ptxt.From.Type = obj.TYPE_MEM
 	ptxt.From.Name = obj.NAME_EXTERN
-	ptxt.From.Sym = fn.Func.LSym
+	ptxt.From.Sym = fn.Func().LSym
 }
 
 // initLSym defines f's obj.LSym and initializes it based on the
@@ -199,7 +199,7 @@ func initLSym(f *ir.Func, hasBody bool) {
 	}
 
 	if nam := f.Nname; !ir.IsBlank(nam) {
-		f.LSym = nam.Sym.Linksym()
+		f.LSym = nam.Sym().Linksym()
 		if f.Pragma&ir.Systemstack != 0 {
 			f.LSym.Set(obj.AttrCFunc, true)
 		}
@@ -221,7 +221,7 @@ func initLSym(f *ir.Func, hasBody bool) {
 			}
 		}
 
-		isLinknameExported := nam.Sym.Linkname != "" && (hasBody || hasDefABI)
+		isLinknameExported := nam.Sym().Linkname != "" && (hasBody || hasDefABI)
 		if abi, ok := symabiRefs[f.LSym.Name]; (ok && abi == obj.ABI0) || isLinknameExported {
 			// Either 1) this symbol is definitely
 			// referenced as ABI0 from this package; or 2)
@@ -281,7 +281,7 @@ func initLSym(f *ir.Func, hasBody bool) {
 	// See test/recover.go for test cases and src/reflect/value.go
 	// for the actual functions being considered.
 	if base.Ctxt.Pkgpath == "reflect" {
-		switch f.Nname.Sym.Name {
+		switch f.Nname.Sym().Name {
 		case "callReflect", "callMethod":
 			flag |= obj.WRAPPER
 		}
@@ -291,20 +291,20 @@ func initLSym(f *ir.Func, hasBody bool) {
 }
 
 func ggloblnod(nam *ir.Node) {
-	s := nam.Sym.Linksym()
+	s := nam.Sym().Linksym()
 	s.Gotype = ngotype(nam).Linksym()
 	flags := 0
-	if nam.Name.Readonly() {
+	if nam.Name().Readonly() {
 		flags = obj.RODATA
 	}
-	if nam.Type != nil && !nam.Type.HasPointers() {
+	if nam.Type() != nil && !nam.Type().HasPointers() {
 		flags |= obj.NOPTR
 	}
-	base.Ctxt.Globl(s, nam.Type.Width, flags)
-	if nam.Name.LibfuzzerExtraCounter() {
+	base.Ctxt.Globl(s, nam.Type().Width, flags)
+	if nam.Name().LibfuzzerExtraCounter() {
 		s.Type = objabi.SLIBFUZZER_EXTRA_COUNTER
 	}
-	if nam.Sym.Linkname != "" {
+	if nam.Sym().Linkname != "" {
 		// Make sure linkname'd symbol is non-package. When a symbol is
 		// both imported and linkname'd, s.Pkg may not set to "_" in
 		// types.Sym.Linksym because LSym already exists. Set it here.
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index 212db2184e..281e2de43d 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -329,7 +329,7 @@ func (w *exportWriter) writeIndex(index map[*ir.Node]uint64, mainIndex bool) {
 	}
 
 	for n := range index {
-		pkgObjs[n.Sym.Pkg] = append(pkgObjs[n.Sym.Pkg], n)
+		pkgObjs[n.Sym().Pkg] = append(pkgObjs[n.Sym().Pkg], n)
 	}
 
 	var pkgs []*types.Pkg
@@ -337,7 +337,7 @@ func (w *exportWriter) writeIndex(index map[*ir.Node]uint64, mainIndex bool) {
 		pkgs = append(pkgs, pkg)
 
 		sort.Slice(objs, func(i, j int) bool {
-			return objs[i].Sym.Name < objs[j].Sym.Name
+			return objs[i].Sym().Name < objs[j].Sym().Name
 		})
 	}
 
@@ -356,7 +356,7 @@ func (w *exportWriter) writeIndex(index map[*ir.Node]uint64, mainIndex bool) {
 		objs := pkgObjs[pkg]
 		w.uint64(uint64(len(objs)))
 		for _, n := range objs {
-			w.string(n.Sym.Name)
+			w.string(n.Sym().Name)
 			w.uint64(index[n])
 		}
 	}
@@ -395,12 +395,12 @@ func (p *iexporter) stringOff(s string) uint64 {
 
 // pushDecl adds n to the declaration work queue, if not already present.
 func (p *iexporter) pushDecl(n *ir.Node) {
-	if n.Sym == nil || ir.AsNode(n.Sym.Def) != n && n.Op != ir.OTYPE {
-		base.Fatalf("weird Sym: %v, %v", n, n.Sym)
+	if n.Sym() == nil || ir.AsNode(n.Sym().Def) != n && n.Op() != ir.OTYPE {
+		base.Fatalf("weird Sym: %v, %v", n, n.Sym())
 	}
 
 	// Don't export predeclared declarations.
-	if n.Sym.Pkg == ir.BuiltinPkg || n.Sym.Pkg == unsafepkg {
+	if n.Sym().Pkg == ir.BuiltinPkg || n.Sym().Pkg == unsafepkg {
 		return
 	}
 
@@ -425,16 +425,16 @@ type exportWriter struct {
 
 func (p *iexporter) doDecl(n *ir.Node) {
 	w := p.newWriter()
-	w.setPkg(n.Sym.Pkg, false)
+	w.setPkg(n.Sym().Pkg, false)
 
-	switch n.Op {
+	switch n.Op() {
 	case ir.ONAME:
 		switch n.Class() {
 		case ir.PEXTERN:
 			// Variable.
 			w.tag('V')
-			w.pos(n.Pos)
-			w.typ(n.Type)
+			w.pos(n.Pos())
+			w.typ(n.Type())
 			w.varExt(n)
 
 		case ir.PFUNC:
@@ -444,8 +444,8 @@ func (p *iexporter) doDecl(n *ir.Node) {
 
 			// Function.
 			w.tag('F')
-			w.pos(n.Pos)
-			w.signature(n.Type)
+			w.pos(n.Pos())
+			w.signature(n.Type())
 			w.funcExt(n)
 
 		default:
@@ -456,23 +456,23 @@ func (p *iexporter) doDecl(n *ir.Node) {
 		// Constant.
 		n = typecheck(n, ctxExpr)
 		w.tag('C')
-		w.pos(n.Pos)
-		w.value(n.Type, n.Val())
+		w.pos(n.Pos())
+		w.value(n.Type(), n.Val())
 
 	case ir.OTYPE:
-		if IsAlias(n.Sym) {
+		if IsAlias(n.Sym()) {
 			// Alias.
 			w.tag('A')
-			w.pos(n.Pos)
-			w.typ(n.Type)
+			w.pos(n.Pos())
+			w.typ(n.Type())
 			break
 		}
 
 		// Defined type.
 		w.tag('T')
-		w.pos(n.Pos)
+		w.pos(n.Pos())
 
-		underlying := n.Type.Orig
+		underlying := n.Type().Orig
 		if underlying == types.Errortype.Orig {
 			// For "type T error", use error as the
 			// underlying type instead of error's own
@@ -484,7 +484,7 @@ func (p *iexporter) doDecl(n *ir.Node) {
 		}
 		w.typ(underlying)
 
-		t := n.Type
+		t := n.Type()
 		if t.IsInterface() {
 			w.typeExt(t)
 			break
@@ -519,7 +519,7 @@ func (p *iexporter) doInline(f *ir.Node) {
 	w := p.newWriter()
 	w.setPkg(fnpkg(f), false)
 
-	w.stmtList(ir.AsNodes(f.Func.Inl.Body))
+	w.stmtList(ir.AsNodes(f.Func().Inl.Body))
 
 	p.inlineIndex[f] = w.flush()
 }
@@ -574,7 +574,7 @@ func (w *exportWriter) qualifiedIdent(n *ir.Node) {
 	// Ensure any referenced declarations are written out too.
 	w.p.pushDecl(n)
 
-	s := n.Sym
+	s := n.Sym()
 	w.string(s.Name)
 	w.pkg(s.Pkg)
 }
@@ -956,36 +956,36 @@ func (w *exportWriter) string(s string) { w.uint64(w.p.stringOff(s)) }
 // Compiler-specific extensions.
 
 func (w *exportWriter) varExt(n *ir.Node) {
-	w.linkname(n.Sym)
-	w.symIdx(n.Sym)
+	w.linkname(n.Sym())
+	w.symIdx(n.Sym())
 }
 
 func (w *exportWriter) funcExt(n *ir.Node) {
-	w.linkname(n.Sym)
-	w.symIdx(n.Sym)
+	w.linkname(n.Sym())
+	w.symIdx(n.Sym())
 
 	// Escape analysis.
 	for _, fs := range &types.RecvsParams {
-		for _, f := range fs(n.Type).FieldSlice() {
+		for _, f := range fs(n.Type()).FieldSlice() {
 			w.string(f.Note)
 		}
 	}
 
 	// Inline body.
-	if n.Func.Inl != nil {
-		w.uint64(1 + uint64(n.Func.Inl.Cost))
-		if n.Func.ExportInline() {
+	if n.Func().Inl != nil {
+		w.uint64(1 + uint64(n.Func().Inl.Cost))
+		if n.Func().ExportInline() {
 			w.p.doInline(n)
 		}
 
 		// Endlineno for inlined function.
-		if n.Name.Defn != nil {
-			w.pos(n.Name.Defn.Func.Endlineno)
+		if n.Name().Defn != nil {
+			w.pos(n.Name().Defn.Func().Endlineno)
 		} else {
 			// When the exported node was defined externally,
 			// e.g. io exports atomic.(*Value).Load or bytes exports errors.New.
 			// Keep it as we don't distinguish this case in iimport.go.
-			w.pos(n.Func.Endlineno)
+			w.pos(n.Func().Endlineno)
 		}
 	} else {
 		w.uint64(0)
@@ -1038,7 +1038,7 @@ func (w *exportWriter) stmtList(list ir.Nodes) {
 }
 
 func (w *exportWriter) node(n *ir.Node) {
-	if ir.OpPrec[n.Op] < 0 {
+	if ir.OpPrec[n.Op()] < 0 {
 		w.stmt(n)
 	} else {
 		w.expr(n)
@@ -1048,19 +1048,19 @@ func (w *exportWriter) node(n *ir.Node) {
 // Caution: stmt will emit more than one node for statement nodes n that have a non-empty
 // n.Ninit and where n cannot have a natural init section (such as in "if", "for", etc.).
 func (w *exportWriter) stmt(n *ir.Node) {
-	if n.Ninit.Len() > 0 && !ir.StmtWithInit(n.Op) {
+	if n.Init().Len() > 0 && !ir.StmtWithInit(n.Op()) {
 		// can't use stmtList here since we don't want the final OEND
-		for _, n := range n.Ninit.Slice() {
+		for _, n := range n.Init().Slice() {
 			w.stmt(n)
 		}
 	}
 
-	switch op := n.Op; op {
+	switch op := n.Op(); op {
 	case ir.ODCL:
 		w.op(ir.ODCL)
-		w.pos(n.Left.Pos)
-		w.localName(n.Left)
-		w.typ(n.Left.Type)
+		w.pos(n.Left().Pos())
+		w.localName(n.Left())
+		w.typ(n.Left().Type())
 
 	// case ODCLFIELD:
 	//	unimplemented - handled by default case
@@ -1069,74 +1069,74 @@ func (w *exportWriter) stmt(n *ir.Node) {
 		// Don't export "v = <N>" initializing statements, hope they're always
 		// preceded by the DCL which will be re-parsed and typecheck to reproduce
 		// the "v = <N>" again.
-		if n.Right != nil {
+		if n.Right() != nil {
 			w.op(ir.OAS)
-			w.pos(n.Pos)
-			w.expr(n.Left)
-			w.expr(n.Right)
+			w.pos(n.Pos())
+			w.expr(n.Left())
+			w.expr(n.Right())
 		}
 
 	case ir.OASOP:
 		w.op(ir.OASOP)
-		w.pos(n.Pos)
+		w.pos(n.Pos())
 		w.op(n.SubOp())
-		w.expr(n.Left)
+		w.expr(n.Left())
 		if w.bool(!n.Implicit()) {
-			w.expr(n.Right)
+			w.expr(n.Right())
 		}
 
 	case ir.OAS2:
 		w.op(ir.OAS2)
-		w.pos(n.Pos)
-		w.exprList(n.List)
-		w.exprList(n.Rlist)
+		w.pos(n.Pos())
+		w.exprList(n.List())
+		w.exprList(n.Rlist())
 
 	case ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV:
 		w.op(ir.OAS2)
-		w.pos(n.Pos)
-		w.exprList(n.List)
-		w.exprList(ir.AsNodes([]*ir.Node{n.Right}))
+		w.pos(n.Pos())
+		w.exprList(n.List())
+		w.exprList(ir.AsNodes([]*ir.Node{n.Right()}))
 
 	case ir.ORETURN:
 		w.op(ir.ORETURN)
-		w.pos(n.Pos)
-		w.exprList(n.List)
+		w.pos(n.Pos())
+		w.exprList(n.List())
 
 	// case ORETJMP:
 	// 	unreachable - generated by compiler for trampolin routines
 
 	case ir.OGO, ir.ODEFER:
 		w.op(op)
-		w.pos(n.Pos)
-		w.expr(n.Left)
+		w.pos(n.Pos())
+		w.expr(n.Left())
 
 	case ir.OIF:
 		w.op(ir.OIF)
-		w.pos(n.Pos)
-		w.stmtList(n.Ninit)
-		w.expr(n.Left)
-		w.stmtList(n.Nbody)
-		w.stmtList(n.Rlist)
+		w.pos(n.Pos())
+		w.stmtList(n.Init())
+		w.expr(n.Left())
+		w.stmtList(n.Body())
+		w.stmtList(n.Rlist())
 
 	case ir.OFOR:
 		w.op(ir.OFOR)
-		w.pos(n.Pos)
-		w.stmtList(n.Ninit)
-		w.exprsOrNil(n.Left, n.Right)
-		w.stmtList(n.Nbody)
+		w.pos(n.Pos())
+		w.stmtList(n.Init())
+		w.exprsOrNil(n.Left(), n.Right())
+		w.stmtList(n.Body())
 
 	case ir.ORANGE:
 		w.op(ir.ORANGE)
-		w.pos(n.Pos)
-		w.stmtList(n.List)
-		w.expr(n.Right)
-		w.stmtList(n.Nbody)
+		w.pos(n.Pos())
+		w.stmtList(n.List())
+		w.expr(n.Right())
+		w.stmtList(n.Body())
 
 	case ir.OSELECT, ir.OSWITCH:
 		w.op(op)
-		w.pos(n.Pos)
-		w.stmtList(n.Ninit)
-		w.exprsOrNil(n.Left, nil)
+		w.pos(n.Pos())
+		w.stmtList(n.Init())
+		w.exprsOrNil(n.Left(), nil)
 		w.caseList(n)
 
 	// case OCASE:
@@ -1144,41 +1144,41 @@ func (w *exportWriter) stmt(n *ir.Node) {
 
 	case ir.OFALL:
 		w.op(ir.OFALL)
-		w.pos(n.Pos)
+		w.pos(n.Pos())
 
 	case ir.OBREAK, ir.OCONTINUE:
 		w.op(op)
-		w.pos(n.Pos)
-		w.exprsOrNil(n.Left, nil)
+		w.pos(n.Pos())
+		w.exprsOrNil(n.Left(), nil)
 
 	case ir.OEMPTY:
 		// nothing to emit
 
 	case ir.OGOTO, ir.OLABEL:
 		w.op(op)
-		w.pos(n.Pos)
-		w.string(n.Sym.Name)
+		w.pos(n.Pos())
+		w.string(n.Sym().Name)
 
 	default:
-		base.Fatalf("exporter: CANNOT EXPORT: %v\nPlease notify gri@\n", n.Op)
+		base.Fatalf("exporter: CANNOT EXPORT: %v\nPlease notify gri@\n", n.Op())
 	}
 }
 
 func (w *exportWriter) caseList(sw *ir.Node) {
-	namedTypeSwitch := sw.Op == ir.OSWITCH && sw.Left != nil && sw.Left.Op == ir.OTYPESW && sw.Left.Left != nil
+	namedTypeSwitch := sw.Op() == ir.OSWITCH && sw.Left() != nil && sw.Left().Op() == ir.OTYPESW && sw.Left().Left() != nil
 
-	cases := sw.List.Slice()
+	cases := sw.List().Slice()
 	w.uint64(uint64(len(cases)))
 	for _, cas := range cases {
-		if cas.Op != ir.OCASE {
+		if cas.Op() != ir.OCASE {
 			base.Fatalf("expected OCASE, got %v", cas)
 		}
-		w.pos(cas.Pos)
-		w.stmtList(cas.List)
+		w.pos(cas.Pos())
+		w.stmtList(cas.List())
 		if namedTypeSwitch {
-			w.localName(cas.Rlist.First())
+			w.localName(cas.Rlist().First())
 		}
-		w.stmtList(cas.Nbody)
+		w.stmtList(cas.Body())
 	}
 }
 
@@ -1200,38 +1200,38 @@ func (w *exportWriter) expr(n *ir.Node) {
 	// }
 
 	// from exprfmt (fmt.go)
-	for n.Op == ir.OPAREN || n.Implicit() && (n.Op == ir.ODEREF || n.Op == ir.OADDR || n.Op == ir.ODOT || n.Op == ir.ODOTPTR) {
-		n = n.Left
+	for n.Op() == ir.OPAREN || n.Implicit() && (n.Op() == ir.ODEREF || n.Op() == ir.OADDR || n.Op() == ir.ODOT || n.Op() == ir.ODOTPTR) {
+		n = n.Left()
 	}
 
-	switch op := n.Op; op {
+	switch op := n.Op(); op {
 	// expressions
 	// (somewhat closely following the structure of exprfmt in fmt.go)
 	case ir.ONIL:
-		if !n.Type.HasNil() {
-			base.Fatalf("unexpected type for nil: %v", n.Type)
+		if !n.Type().HasNil() {
+			base.Fatalf("unexpected type for nil: %v", n.Type())
 		}
-		if n.Orig != nil && n.Orig != n {
-			w.expr(n.Orig)
+		if n.Orig() != nil && n.Orig() != n {
+			w.expr(n.Orig())
 			break
 		}
 		w.op(ir.OLITERAL)
-		w.pos(n.Pos)
-		w.typ(n.Type)
+		w.pos(n.Pos())
+		w.typ(n.Type())
 
 	case ir.OLITERAL:
 		w.op(ir.OLITERAL)
-		w.pos(n.Pos)
-		w.value(n.Type, n.Val())
+		w.pos(n.Pos())
+		w.value(n.Type(), n.Val())
 
 	case ir.OMETHEXPR:
 		// Special case: explicit name of func (*T) method(...) is turned into pkg.(*T).method,
 		// but for export, this should be rendered as (*pkg.T).meth.
 		// These nodes have the special property that they are names with a left OTYPE and a right ONAME.
 		w.op(ir.OXDOT)
-		w.pos(n.Pos)
-		w.expr(n.Left) // n.Left.Op == OTYPE
-		w.selector(n.Right.Sym)
+		w.pos(n.Pos())
+		w.expr(n.Left()) // n.Left.Op == OTYPE
+		w.selector(n.Right().Sym())
 
 	case ir.ONAME:
 		// Package scope name.
@@ -1250,20 +1250,20 @@ func (w *exportWriter) expr(n *ir.Node) {
 
 	case ir.OTYPE:
 		w.op(ir.OTYPE)
-		w.typ(n.Type)
+		w.typ(n.Type())
 
 	case ir.OTYPESW:
 		w.op(ir.OTYPESW)
-		w.pos(n.Pos)
+		w.pos(n.Pos())
 		var s *types.Sym
-		if n.Left != nil {
-			if n.Left.Op != ir.ONONAME {
-				base.Fatalf("expected ONONAME, got %v", n.Left)
+		if n.Left() != nil {
+			if n.Left().Op() != ir.ONONAME {
+				base.Fatalf("expected ONONAME, got %v", n.Left())
 			}
-			s = n.Left.Sym
+			s = n.Left().Sym()
 		}
 		w.localIdent(s, 0) // declared pseudo-variable, if any
-		w.exprsOrNil(n.Right, nil)
+		w.exprsOrNil(n.Right(), nil)
 
 	// case OTARRAY, OTMAP, OTCHAN, OTSTRUCT, OTINTER, OTFUNC:
 	// 	should have been resolved by typechecking - handled by default case
@@ -1276,25 +1276,25 @@ func (w *exportWriter) expr(n *ir.Node) {
 
 	case ir.OPTRLIT:
 		w.op(ir.OADDR)
-		w.pos(n.Pos)
-		w.expr(n.Left)
+		w.pos(n.Pos())
+		w.expr(n.Left())
 
 	case ir.OSTRUCTLIT:
 		w.op(ir.OSTRUCTLIT)
-		w.pos(n.Pos)
-		w.typ(n.Type)
-		w.elemList(n.List) // special handling of field names
+		w.pos(n.Pos())
+		w.typ(n.Type())
+		w.elemList(n.List()) // special handling of field names
 
 	case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT:
 		w.op(ir.OCOMPLIT)
-		w.pos(n.Pos)
-		w.typ(n.Type)
-		w.exprList(n.List)
+		w.pos(n.Pos())
+		w.typ(n.Type())
+		w.exprList(n.List())
 
 	case ir.OKEY:
 		w.op(ir.OKEY)
-		w.pos(n.Pos)
-		w.exprsOrNil(n.Left, n.Right)
+		w.pos(n.Pos())
+		w.exprsOrNil(n.Left(), n.Right())
 
 	// case OSTRUCTKEY:
 	//	unreachable - handled in case OSTRUCTLIT by elemList
@@ -1302,40 +1302,40 @@ func (w *exportWriter) expr(n *ir.Node) {
 	case ir.OCALLPART:
 		// An OCALLPART is an OXDOT before type checking.
 		w.op(ir.OXDOT)
-		w.pos(n.Pos)
-		w.expr(n.Left)
+		w.pos(n.Pos())
+		w.expr(n.Left())
 		// Right node should be ONAME
-		w.selector(n.Right.Sym)
+		w.selector(n.Right().Sym())
 
 	case ir.OXDOT, ir.ODOT, ir.ODOTPTR, ir.ODOTINTER, ir.ODOTMETH:
 		w.op(ir.OXDOT)
-		w.pos(n.Pos)
-		w.expr(n.Left)
-		w.selector(n.Sym)
+		w.pos(n.Pos())
+		w.expr(n.Left())
+		w.selector(n.Sym())
 
 	case ir.ODOTTYPE, ir.ODOTTYPE2:
 		w.op(ir.ODOTTYPE)
-		w.pos(n.Pos)
-		w.expr(n.Left)
-		w.typ(n.Type)
+		w.pos(n.Pos())
+		w.expr(n.Left())
+		w.typ(n.Type())
 
 	case ir.OINDEX, ir.OINDEXMAP:
 		w.op(ir.OINDEX)
-		w.pos(n.Pos)
-		w.expr(n.Left)
-		w.expr(n.Right)
+		w.pos(n.Pos())
+		w.expr(n.Left())
+		w.expr(n.Right())
 
 	case ir.OSLICE, ir.OSLICESTR, ir.OSLICEARR:
 		w.op(ir.OSLICE)
-		w.pos(n.Pos)
-		w.expr(n.Left)
+		w.pos(n.Pos())
+		w.expr(n.Left())
 		low, high, _ := n.SliceBounds()
 		w.exprsOrNil(low, high)
 
 	case ir.OSLICE3, ir.OSLICE3ARR:
 		w.op(ir.OSLICE3)
-		w.pos(n.Pos)
-		w.expr(n.Left)
+		w.pos(n.Pos())
+		w.expr(n.Left())
 		low, high, max := n.SliceBounds()
 		w.exprsOrNil(low, high)
 		w.expr(max)
@@ -1343,25 +1343,25 @@ func (w *exportWriter) expr(n *ir.Node) {
 	case ir.OCOPY, ir.OCOMPLEX:
 		// treated like other builtin calls (see e.g., OREAL)
 		w.op(op)
-		w.pos(n.Pos)
-		w.expr(n.Left)
-		w.expr(n.Right)
+		w.pos(n.Pos())
+		w.expr(n.Left())
+		w.expr(n.Right())
 		w.op(ir.OEND)
 
 	case ir.OCONV, ir.OCONVIFACE, ir.OCONVNOP, ir.OBYTES2STR, ir.ORUNES2STR, ir.OSTR2BYTES, ir.OSTR2RUNES, ir.ORUNESTR:
 		w.op(ir.OCONV)
-		w.pos(n.Pos)
-		w.expr(n.Left)
-		w.typ(n.Type)
+		w.pos(n.Pos())
+		w.expr(n.Left())
+		w.typ(n.Type())
 
 	case ir.OREAL, ir.OIMAG, ir.OAPPEND, ir.OCAP, ir.OCLOSE, ir.ODELETE, ir.OLEN, ir.OMAKE, ir.ONEW, ir.OPANIC, ir.ORECOVER, ir.OPRINT, ir.OPRINTN:
 		w.op(op)
-		w.pos(n.Pos)
-		if n.Left != nil {
-			w.expr(n.Left)
+		w.pos(n.Pos())
+		if n.Left() != nil {
+			w.expr(n.Left())
 			w.op(ir.OEND)
 		} else {
-			w.exprList(n.List) // emits terminating OEND
+			w.exprList(n.List()) // emits terminating OEND
 		}
 		// only append() calls may contain '...' arguments
 		if op == ir.OAPPEND {
@@ -1372,49 +1372,49 @@ func (w *exportWriter) expr(n *ir.Node) {
 
 	case ir.OCALL, ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER, ir.OGETG:
 		w.op(ir.OCALL)
-		w.pos(n.Pos)
-		w.stmtList(n.Ninit)
-		w.expr(n.Left)
-		w.exprList(n.List)
+		w.pos(n.Pos())
+		w.stmtList(n.Init())
+		w.expr(n.Left())
+		w.exprList(n.List())
 		w.bool(n.IsDDD())
 
 	case ir.OMAKEMAP, ir.OMAKECHAN, ir.OMAKESLICE:
 		w.op(op) // must keep separate from OMAKE for importer
-		w.pos(n.Pos)
-		w.typ(n.Type)
+		w.pos(n.Pos())
+		w.typ(n.Type())
 		switch {
 		default:
 			// empty list
 			w.op(ir.OEND)
-		case n.List.Len() != 0: // pre-typecheck
-			w.exprList(n.List) // emits terminating OEND
-		case n.Right != nil:
-			w.expr(n.Left)
-			w.expr(n.Right)
+		case n.List().Len() != 0: // pre-typecheck
+			w.exprList(n.List()) // emits terminating OEND
+		case n.Right() != nil:
+			w.expr(n.Left())
+			w.expr(n.Right())
 			w.op(ir.OEND)
-		case n.Left != nil && (n.Op == ir.OMAKESLICE || !n.Left.Type.IsUntyped()):
-			w.expr(n.Left)
+		case n.Left() != nil && (n.Op() == ir.OMAKESLICE || !n.Left().Type().IsUntyped()):
+			w.expr(n.Left())
 			w.op(ir.OEND)
 		}
 
 	// unary expressions
 	case ir.OPLUS, ir.ONEG, ir.OADDR, ir.OBITNOT, ir.ODEREF, ir.ONOT, ir.ORECV:
 		w.op(op)
-		w.pos(n.Pos)
-		w.expr(n.Left)
+		w.pos(n.Pos())
+		w.expr(n.Left())
 
 	// binary expressions
 	case ir.OADD, ir.OAND, ir.OANDAND, ir.OANDNOT, ir.ODIV, ir.OEQ, ir.OGE, ir.OGT, ir.OLE, ir.OLT,
 		ir.OLSH, ir.OMOD, ir.OMUL, ir.ONE, ir.OOR, ir.OOROR, ir.ORSH, ir.OSEND, ir.OSUB, ir.OXOR:
 		w.op(op)
-		w.pos(n.Pos)
-		w.expr(n.Left)
-		w.expr(n.Right)
+		w.pos(n.Pos())
+		w.expr(n.Left())
+		w.expr(n.Right())
 
 	case ir.OADDSTR:
 		w.op(ir.OADDSTR)
-		w.pos(n.Pos)
-		w.exprList(n.List)
+		w.pos(n.Pos())
+		w.exprList(n.List())
 
 	case ir.ODCLCONST:
 		// if exporting, DCLCONST should just be removed as its usage
@@ -1422,7 +1422,7 @@ func (w *exportWriter) expr(n *ir.Node) {
 
 	default:
 		base.Fatalf("cannot export %v (%d) node\n"+
-			"\t==> please file an issue and assign to gri@", n.Op, int(n.Op))
+			"\t==> please file an issue and assign to gri@", n.Op(), int(n.Op()))
 	}
 }
 
@@ -1450,8 +1450,8 @@ func (w *exportWriter) exprsOrNil(a, b *ir.Node) {
 func (w *exportWriter) elemList(list ir.Nodes) {
 	w.uint64(uint64(list.Len()))
 	for _, n := range list.Slice() {
-		w.selector(n.Sym)
-		w.expr(n.Left)
+		w.selector(n.Sym())
+		w.expr(n.Left())
 	}
 }
 
@@ -1464,11 +1464,11 @@ func (w *exportWriter) localName(n *ir.Node) {
 	// PPARAM/PPARAMOUT, because we only want to include vargen in
 	// non-param names.
 	var v int32
-	if n.Class() == ir.PAUTO || (n.Class() == ir.PAUTOHEAP && n.Name.Param.Stackcopy == nil) {
-		v = n.Name.Vargen
+	if n.Class() == ir.PAUTO || (n.Class() == ir.PAUTOHEAP && n.Name().Param.Stackcopy == nil) {
+		v = n.Name().Vargen
 	}
 
-	w.localIdent(n.Sym, v)
+	w.localIdent(n.Sym(), v)
 }
 
 func (w *exportWriter) localIdent(s *types.Sym, v int32) {
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 84386140bb..7106356665 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -42,7 +42,7 @@ var (
 )
 
 func expandDecl(n *ir.Node) {
-	if n.Op != ir.ONONAME {
+	if n.Op() != ir.ONONAME {
 		return
 	}
 
@@ -56,7 +56,7 @@ func expandDecl(n *ir.Node) {
 }
 
 func expandInline(fn *ir.Node) {
-	if fn.Func.Inl.Body != nil {
+	if fn.Func().Inl.Body != nil {
 		return
 	}
 
@@ -69,12 +69,12 @@ func expandInline(fn *ir.Node) {
 }
 
 func importReaderFor(n *ir.Node, importers map[*types.Sym]iimporterAndOffset) *importReader {
-	x, ok := importers[n.Sym]
+	x, ok := importers[n.Sym()]
 	if !ok {
 		return nil
 	}
 
-	return x.p.newReader(x.off, n.Sym.Pkg)
+	return x.p.newReader(x.off, n.Sym().Pkg)
 }
 
 type intReader struct {
@@ -282,8 +282,8 @@ func (r *importReader) setPkg() {
 }
 
 func (r *importReader) doDecl(n *ir.Node) {
-	if n.Op != ir.ONONAME {
-		base.Fatalf("doDecl: unexpected Op for %v: %v", n.Sym, n.Op)
+	if n.Op() != ir.ONONAME {
+		base.Fatalf("doDecl: unexpected Op for %v: %v", n.Sym(), n.Op())
 	}
 
 	tag := r.byte()
@@ -293,24 +293,24 @@ func (r *importReader) doDecl(n *ir.Node) {
 	case 'A':
 		typ := r.typ()
 
-		importalias(r.p.ipkg, pos, n.Sym, typ)
+		importalias(r.p.ipkg, pos, n.Sym(), typ)
 
 	case 'C':
 		typ := r.typ()
 		val := r.value(typ)
 
-		importconst(r.p.ipkg, pos, n.Sym, typ, val)
+		importconst(r.p.ipkg, pos, n.Sym(), typ, val)
 
 	case 'F':
 		typ := r.signature(nil)
 
-		importfunc(r.p.ipkg, pos, n.Sym, typ)
+		importfunc(r.p.ipkg, pos, n.Sym(), typ)
 		r.funcExt(n)
 
 	case 'T':
 		// Types can be recursive. We need to setup a stub
 		// declaration before recursing.
-		t := importtype(r.p.ipkg, pos, n.Sym)
+		t := importtype(r.p.ipkg, pos, n.Sym())
 
 		// We also need to defer width calculations until
 		// after the underlying type has been assigned.
@@ -332,7 +332,7 @@ func (r *importReader) doDecl(n *ir.Node) {
 			mtyp := r.signature(recv)
 
 			m := newfuncnamel(mpos, methodSym(recv.Type, msym), new(ir.Func))
-			m.Type = mtyp
+			m.SetType(mtyp)
 			m.SetClass(ir.PFUNC)
 			// methodSym already marked m.Sym as a function.
 
@@ -350,7 +350,7 @@ func (r *importReader) doDecl(n *ir.Node) {
 	case 'V':
 		typ := r.typ()
 
-		importvar(r.p.ipkg, pos, n.Sym, typ)
+		importvar(r.p.ipkg, pos, n.Sym(), typ)
 		r.varExt(n)
 
 	default:
@@ -500,13 +500,13 @@ func (r *importReader) typ1() *types.Type {
 		// types. Therefore, this must be a package-scope
 		// type.
 		n := ir.AsNode(r.qualifiedIdent().PkgDef())
-		if n.Op == ir.ONONAME {
+		if n.Op() == ir.ONONAME {
 			expandDecl(n)
 		}
-		if n.Op != ir.OTYPE {
-			base.Fatalf("expected OTYPE, got %v: %v, %v", n.Op, n.Sym, n)
+		if n.Op() != ir.OTYPE {
+			base.Fatalf("expected OTYPE, got %v: %v, %v", n.Op(), n.Sym(), n)
 		}
-		return n.Type
+		return n.Type()
 	case pointerType:
 		return types.NewPtr(r.typ())
 	case sliceType:
@@ -636,27 +636,27 @@ func (r *importReader) byte() byte {
 // Compiler-specific extensions.
 
 func (r *importReader) varExt(n *ir.Node) {
-	r.linkname(n.Sym)
-	r.symIdx(n.Sym)
+	r.linkname(n.Sym())
+	r.symIdx(n.Sym())
 }
 
 func (r *importReader) funcExt(n *ir.Node) {
-	r.linkname(n.Sym)
-	r.symIdx(n.Sym)
+	r.linkname(n.Sym())
+	r.symIdx(n.Sym())
 
 	// Escape analysis.
 	for _, fs := range &types.RecvsParams {
-		for _, f := range fs(n.Type).FieldSlice() {
+		for _, f := range fs(n.Type()).FieldSlice() {
 			f.Note = r.string()
 		}
 	}
 
 	// Inline body.
 	if u := r.uint64(); u > 0 {
-		n.Func.Inl = &ir.Inline{
+		n.Func().Inl = &ir.Inline{
 			Cost: int32(u - 1),
 		}
-		n.Func.Endlineno = r.pos()
+		n.Func().Endlineno = r.pos()
 	}
 }
 
@@ -696,7 +696,7 @@ func (r *importReader) typeExt(t *types.Type) {
 var typeSymIdx = make(map[*types.Type][2]int64)
 
 func (r *importReader) doInline(n *ir.Node) {
-	if len(n.Func.Inl.Body) != 0 {
+	if len(n.Func().Inl.Body) != 0 {
 		base.Fatalf("%v already has inline body", n)
 	}
 
@@ -712,15 +712,15 @@ func (r *importReader) doInline(n *ir.Node) {
 		// functions).
 		body = []*ir.Node{}
 	}
-	n.Func.Inl.Body = body
+	n.Func().Inl.Body = body
 
 	importlist = append(importlist, n)
 
 	if base.Flag.E > 0 && base.Flag.LowerM > 2 {
 		if base.Flag.LowerM > 3 {
-			fmt.Printf("inl body for %v %#v: %+v\n", n, n.Type, ir.AsNodes(n.Func.Inl.Body))
+			fmt.Printf("inl body for %v %#v: %+v\n", n, n.Type(), ir.AsNodes(n.Func().Inl.Body))
 		} else {
-			fmt.Printf("inl body for %v %#v: %v\n", n, n.Type, ir.AsNodes(n.Func.Inl.Body))
+			fmt.Printf("inl body for %v %#v: %v\n", n, n.Type(), ir.AsNodes(n.Func().Inl.Body))
 		}
 	}
 }
@@ -748,8 +748,8 @@ func (r *importReader) stmtList() []*ir.Node {
 			break
 		}
 		// OBLOCK nodes may be created when importing ODCL nodes - unpack them
-		if n.Op == ir.OBLOCK {
-			list = append(list, n.List.Slice()...)
+		if n.Op() == ir.OBLOCK {
+			list = append(list, n.List().Slice()...)
 		} else {
 			list = append(list, n)
 		}
@@ -759,22 +759,22 @@ func (r *importReader) stmtList() []*ir.Node {
 }
 
 func (r *importReader) caseList(sw *ir.Node) []*ir.Node {
-	namedTypeSwitch := sw.Op == ir.OSWITCH && sw.Left != nil && sw.Left.Op == ir.OTYPESW && sw.Left.Left != nil
+	namedTypeSwitch := sw.Op() == ir.OSWITCH && sw.Left() != nil && sw.Left().Op() == ir.OTYPESW && sw.Left().Left() != nil
 
 	cases := make([]*ir.Node, r.uint64())
 	for i := range cases {
 		cas := ir.NodAt(r.pos(), ir.OCASE, nil, nil)
-		cas.List.Set(r.stmtList())
+		cas.PtrList().Set(r.stmtList())
 		if namedTypeSwitch {
 			// Note: per-case variables will have distinct, dotted
 			// names after import. That's okay: swt.go only needs
 			// Sym for diagnostics anyway.
-			caseVar := ir.NewNameAt(cas.Pos, r.ident())
+			caseVar := ir.NewNameAt(cas.Pos(), r.ident())
 			declare(caseVar, dclcontext)
-			cas.Rlist.Set1(caseVar)
-			caseVar.Name.Defn = sw.Left
+			cas.PtrRlist().Set1(caseVar)
+			caseVar.Name().Defn = sw.Left()
 		}
-		cas.Nbody.Set(r.stmtList())
+		cas.PtrBody().Set(r.stmtList())
 		cases[i] = cas
 	}
 	return cases
@@ -794,7 +794,7 @@ func (r *importReader) exprList() []*ir.Node {
 
 func (r *importReader) expr() *ir.Node {
 	n := r.node()
-	if n != nil && n.Op == ir.OBLOCK {
+	if n != nil && n.Op() == ir.OBLOCK {
 		base.Fatalf("unexpected block node: %v", n)
 	}
 	return n
@@ -821,7 +821,7 @@ func (r *importReader) node() *ir.Node {
 			n = ir.NewLiteral(r.value(typ))
 		}
 		n = npos(pos, n)
-		n.Type = typ
+		n.SetType(typ)
 		return n
 
 	case ir.ONONAME:
@@ -839,10 +839,10 @@ func (r *importReader) node() *ir.Node {
 	case ir.OTYPESW:
 		n := ir.NodAt(r.pos(), ir.OTYPESW, nil, nil)
 		if s := r.ident(); s != nil {
-			n.Left = npos(n.Pos, newnoname(s))
+			n.SetLeft(npos(n.Pos(), newnoname(s)))
 		}
 		right, _ := r.exprsOrNil()
-		n.Right = right
+		n.SetRight(right)
 		return n
 
 	// case OTARRAY, OTMAP, OTCHAN, OTSTRUCT, OTINTER, OTFUNC:
@@ -859,7 +859,7 @@ func (r *importReader) node() *ir.Node {
 		savedlineno := base.Pos
 		base.Pos = r.pos()
 		n := ir.NodAt(base.Pos, ir.OCOMPLIT, nil, typenod(r.typ()))
-		n.List.Set(r.elemList()) // special handling of field names
+		n.PtrList().Set(r.elemList()) // special handling of field names
 		base.Pos = savedlineno
 		return n
 
@@ -868,7 +868,7 @@ func (r *importReader) node() *ir.Node {
 
 	case ir.OCOMPLIT:
 		n := ir.NodAt(r.pos(), ir.OCOMPLIT, nil, typenod(r.typ()))
-		n.List.Set(r.exprList())
+		n.PtrList().Set(r.exprList())
 		return n
 
 	case ir.OKEY:
@@ -894,7 +894,7 @@ func (r *importReader) node() *ir.Node {
 
 	case ir.ODOTTYPE:
 		n := ir.NodAt(r.pos(), ir.ODOTTYPE, r.expr(), nil)
-		n.Type = r.typ()
+		n.SetType(r.typ())
 		return n
 
 	// case OINDEX, OINDEXMAP, OSLICE, OSLICESTR, OSLICEARR, OSLICE3, OSLICE3ARR:
@@ -907,7 +907,7 @@ func (r *importReader) node() *ir.Node {
 		n := ir.NodAt(r.pos(), op, r.expr(), nil)
 		low, high := r.exprsOrNil()
 		var max *ir.Node
-		if n.Op.IsSlice3() {
+		if n.Op().IsSlice3() {
 			max = r.expr()
 		}
 		n.SetSliceBounds(low, high, max)
@@ -918,12 +918,12 @@ func (r *importReader) node() *ir.Node {
 
 	case ir.OCONV:
 		n := ir.NodAt(r.pos(), ir.OCONV, r.expr(), nil)
-		n.Type = r.typ()
+		n.SetType(r.typ())
 		return n
 
 	case ir.OCOPY, ir.OCOMPLEX, ir.OREAL, ir.OIMAG, ir.OAPPEND, ir.OCAP, ir.OCLOSE, ir.ODELETE, ir.OLEN, ir.OMAKE, ir.ONEW, ir.OPANIC, ir.ORECOVER, ir.OPRINT, ir.OPRINTN:
 		n := npos(r.pos(), builtinCall(op))
-		n.List.Set(r.exprList())
+		n.PtrList().Set(r.exprList())
 		if op == ir.OAPPEND {
 			n.SetIsDDD(r.bool())
 		}
@@ -934,16 +934,16 @@ func (r *importReader) node() *ir.Node {
 
 	case ir.OCALL:
 		n := ir.NodAt(r.pos(), ir.OCALL, nil, nil)
-		n.Ninit.Set(r.stmtList())
-		n.Left = r.expr()
-		n.List.Set(r.exprList())
+		n.PtrInit().Set(r.stmtList())
+		n.SetLeft(r.expr())
+		n.PtrList().Set(r.exprList())
 		n.SetIsDDD(r.bool())
 		return n
 
 	case ir.OMAKEMAP, ir.OMAKECHAN, ir.OMAKESLICE:
 		n := npos(r.pos(), builtinCall(ir.OMAKE))
-		n.List.Append(typenod(r.typ()))
-		n.List.Append(r.exprList()...)
+		n.PtrList().Append(typenod(r.typ()))
+		n.PtrList().Append(r.exprList()...)
 		return n
 
 	// unary expressions
@@ -984,12 +984,12 @@ func (r *importReader) node() *ir.Node {
 	case ir.OASOP:
 		n := ir.NodAt(r.pos(), ir.OASOP, nil, nil)
 		n.SetSubOp(r.op())
-		n.Left = r.expr()
+		n.SetLeft(r.expr())
 		if !r.bool() {
-			n.Right = nodintconst(1)
+			n.SetRight(nodintconst(1))
 			n.SetImplicit(true)
 		} else {
-			n.Right = r.expr()
+			n.SetRight(r.expr())
 		}
 		return n
 
@@ -998,13 +998,13 @@ func (r *importReader) node() *ir.Node {
 
 	case ir.OAS2:
 		n := ir.NodAt(r.pos(), ir.OAS2, nil, nil)
-		n.List.Set(r.exprList())
-		n.Rlist.Set(r.exprList())
+		n.PtrList().Set(r.exprList())
+		n.PtrRlist().Set(r.exprList())
 		return n
 
 	case ir.ORETURN:
 		n := ir.NodAt(r.pos(), ir.ORETURN, nil, nil)
-		n.List.Set(r.exprList())
+		n.PtrList().Set(r.exprList())
 		return n
 
 	// case ORETJMP:
@@ -1015,34 +1015,34 @@ func (r *importReader) node() *ir.Node {
 
 	case ir.OIF:
 		n := ir.NodAt(r.pos(), ir.OIF, nil, nil)
-		n.Ninit.Set(r.stmtList())
-		n.Left = r.expr()
-		n.Nbody.Set(r.stmtList())
-		n.Rlist.Set(r.stmtList())
+		n.PtrInit().Set(r.stmtList())
+		n.SetLeft(r.expr())
+		n.PtrBody().Set(r.stmtList())
+		n.PtrRlist().Set(r.stmtList())
 		return n
 
 	case ir.OFOR:
 		n := ir.NodAt(r.pos(), ir.OFOR, nil, nil)
-		n.Ninit.Set(r.stmtList())
+		n.PtrInit().Set(r.stmtList())
 		left, right := r.exprsOrNil()
-		n.Left = left
-		n.Right = right
-		n.Nbody.Set(r.stmtList())
+		n.SetLeft(left)
+		n.SetRight(right)
+		n.PtrBody().Set(r.stmtList())
 		return n
 
 	case ir.ORANGE:
 		n := ir.NodAt(r.pos(), ir.ORANGE, nil, nil)
-		n.List.Set(r.stmtList())
-		n.Right = r.expr()
-		n.Nbody.Set(r.stmtList())
+		n.PtrList().Set(r.stmtList())
+		n.SetRight(r.expr())
+		n.PtrBody().Set(r.stmtList())
 		return n
 
 	case ir.OSELECT, ir.OSWITCH:
 		n := ir.NodAt(r.pos(), op, nil, nil)
-		n.Ninit.Set(r.stmtList())
+		n.PtrInit().Set(r.stmtList())
 		left, _ := r.exprsOrNil()
-		n.Left = left
-		n.List.Set(r.caseList(n))
+		n.SetLeft(left)
+		n.PtrList().Set(r.caseList(n))
 		return n
 
 	// case OCASE:
@@ -1056,7 +1056,7 @@ func (r *importReader) node() *ir.Node {
 		pos := r.pos()
 		left, _ := r.exprsOrNil()
 		if left != nil {
-			left = NewName(left.Sym)
+			left = NewName(left.Sym())
 		}
 		return ir.NodAt(pos, op, left, nil)
 
@@ -1065,7 +1065,7 @@ func (r *importReader) node() *ir.Node {
 
 	case ir.OGOTO, ir.OLABEL:
 		n := ir.NodAt(r.pos(), op, nil, nil)
-		n.Sym = lookup(r.string())
+		n.SetSym(lookup(r.string()))
 		return n
 
 	case ir.OEND:
diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index f3c302f6be..b66ee6f953 100644
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -46,16 +46,16 @@ func fninit(n []*ir.Node) {
 
 	// Make a function that contains all the initialization statements.
 	if len(nf) > 0 {
-		base.Pos = nf[0].Pos // prolog/epilog gets line number of first init stmt
+		base.Pos = nf[0].Pos() // prolog/epilog gets line number of first init stmt
 		initializers := lookup("init")
 		fn := dclfunc(initializers, ir.Nod(ir.OTFUNC, nil, nil))
-		for _, dcl := range initTodo.Func.Dcl {
-			dcl.Name.Curfn = fn
+		for _, dcl := range initTodo.Func().Dcl {
+			dcl.Name().Curfn = fn
 		}
-		fn.Func.Dcl = append(fn.Func.Dcl, initTodo.Func.Dcl...)
-		initTodo.Func.Dcl = nil
+		fn.Func().Dcl = append(fn.Func().Dcl, initTodo.Func().Dcl...)
+		initTodo.Func().Dcl = nil
 
-		fn.Nbody.Set(nf)
+		fn.PtrBody().Set(nf)
 		funcbody()
 
 		fn = typecheck(fn, ctxStmt)
@@ -65,7 +65,7 @@ func fninit(n []*ir.Node) {
 		xtop = append(xtop, fn)
 		fns = append(fns, initializers.Linksym())
 	}
-	if initTodo.Func.Dcl != nil {
+	if initTodo.Func().Dcl != nil {
 		// We only generate temps using initTodo if there
 		// are package-scope initialization statements, so
 		// something's weird if we get here.
@@ -76,9 +76,9 @@ func fninit(n []*ir.Node) {
 	// Record user init functions.
 	for i := 0; i < renameinitgen; i++ {
 		s := lookupN("init.", i)
-		fn := ir.AsNode(s.Def).Name.Defn
+		fn := ir.AsNode(s.Def).Name().Defn
 		// Skip init functions with empty bodies.
-		if fn.Nbody.Len() == 1 && fn.Nbody.First().Op == ir.OEMPTY {
+		if fn.Body().Len() == 1 && fn.Body().First().Op() == ir.OEMPTY {
 			continue
 		}
 		fns = append(fns, s.Linksym())
@@ -91,7 +91,7 @@ func fninit(n []*ir.Node) {
 	// Make an .inittask structure.
 	sym := lookup(".inittask")
 	nn := NewName(sym)
-	nn.Type = types.Types[types.TUINT8] // fake type
+	nn.SetType(types.Types[types.TUINT8]) // fake type
 	nn.SetClass(ir.PEXTERN)
 	sym.Def = ir.AsTypesNode(nn)
 	exportsym(nn)
diff --git a/src/cmd/compile/internal/gc/initorder.go b/src/cmd/compile/internal/gc/initorder.go
index 62294b5a90..71da72f0cf 100644
--- a/src/cmd/compile/internal/gc/initorder.go
+++ b/src/cmd/compile/internal/gc/initorder.go
@@ -86,7 +86,7 @@ func initOrder(l []*ir.Node) []*ir.Node {
 
 	// Process all package-level assignment in declaration order.
 	for _, n := range l {
-		switch n.Op {
+		switch n.Op() {
 		case ir.OAS, ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV:
 			o.processAssign(n)
 			o.flushReady(s.staticInit)
@@ -100,7 +100,7 @@ func initOrder(l []*ir.Node) []*ir.Node {
 	// Check that all assignments are now Done; if not, there must
 	// have been a dependency cycle.
 	for _, n := range l {
-		switch n.Op {
+		switch n.Op() {
 		case ir.OAS, ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV:
 			if n.Initorder() != InitDone {
 				// If there have already been errors
@@ -126,27 +126,27 @@ func initOrder(l []*ir.Node) []*ir.Node {
 }
 
 func (o *InitOrder) processAssign(n *ir.Node) {
-	if n.Initorder() != InitNotStarted || n.Xoffset != types.BADWIDTH {
-		base.Fatalf("unexpected state: %v, %v, %v", n, n.Initorder(), n.Xoffset)
+	if n.Initorder() != InitNotStarted || n.Offset() != types.BADWIDTH {
+		base.Fatalf("unexpected state: %v, %v, %v", n, n.Initorder(), n.Offset())
 	}
 
 	n.SetInitorder(InitPending)
-	n.Xoffset = 0
+	n.SetOffset(0)
 
 	// Compute number of variable dependencies and build the
 	// inverse dependency ("blocking") graph.
 	for dep := range collectDeps(n, true) {
-		defn := dep.Name.Defn
+		defn := dep.Name().Defn
 		// Skip dependencies on functions (PFUNC) and
 		// variables already initialized (InitDone).
 		if dep.Class() != ir.PEXTERN || defn.Initorder() == InitDone {
 			continue
 		}
-		n.Xoffset = n.Xoffset + 1
+		n.SetOffset(n.Offset() + 1)
 		o.blocking[defn] = append(o.blocking[defn], n)
 	}
 
-	if n.Xoffset == 0 {
+	if n.Offset() == 0 {
 		heap.Push(&o.ready, n)
 	}
 }
@@ -157,20 +157,20 @@ func (o *InitOrder) processAssign(n *ir.Node) {
 func (o *InitOrder) flushReady(initialize func(*ir.Node)) {
 	for o.ready.Len() != 0 {
 		n := heap.Pop(&o.ready).(*ir.Node)
-		if n.Initorder() != InitPending || n.Xoffset != 0 {
-			base.Fatalf("unexpected state: %v, %v, %v", n, n.Initorder(), n.Xoffset)
+		if n.Initorder() != InitPending || n.Offset() != 0 {
+			base.Fatalf("unexpected state: %v, %v, %v", n, n.Initorder(), n.Offset())
 		}
 
 		initialize(n)
 		n.SetInitorder(InitDone)
-		n.Xoffset = types.BADWIDTH
+		n.SetOffset(types.BADWIDTH)
 
 		blocked := o.blocking[n]
 		delete(o.blocking, n)
 
 		for _, m := range blocked {
-			m.Xoffset = m.Xoffset - 1
-			if m.Xoffset == 0 {
+			m.SetOffset(m.Offset() - 1)
+			if m.Offset() == 0 {
 				heap.Push(&o.ready, m)
 			}
 		}
@@ -196,14 +196,14 @@ func findInitLoopAndExit(n *ir.Node, path *[]*ir.Node) {
 
 	// There might be multiple loops involving n; by sorting
 	// references, we deterministically pick the one reported.
-	refers := collectDeps(n.Name.Defn, false).Sorted(func(ni, nj *ir.Node) bool {
-		return ni.Pos.Before(nj.Pos)
+	refers := collectDeps(n.Name().Defn, false).Sorted(func(ni, nj *ir.Node) bool {
+		return ni.Pos().Before(nj.Pos())
 	})
 
 	*path = append(*path, n)
 	for _, ref := range refers {
 		// Short-circuit variables that were initialized.
-		if ref.Class() == ir.PEXTERN && ref.Name.Defn.Initorder() == InitDone {
+		if ref.Class() == ir.PEXTERN && ref.Name().Defn.Initorder() == InitDone {
 			continue
 		}
 
@@ -220,7 +220,7 @@ func reportInitLoopAndExit(l []*ir.Node) {
 	// the start.
 	i := -1
 	for j, n := range l {
-		if n.Class() == ir.PEXTERN && (i == -1 || n.Pos.Before(l[i].Pos)) {
+		if n.Class() == ir.PEXTERN && (i == -1 || n.Pos().Before(l[i].Pos())) {
 			i = j
 		}
 	}
@@ -242,7 +242,7 @@ func reportInitLoopAndExit(l []*ir.Node) {
 	}
 	fmt.Fprintf(&msg, "\t%v: %v", ir.Line(l[0]), l[0])
 
-	base.ErrorfAt(l[0].Pos, msg.String())
+	base.ErrorfAt(l[0].Pos(), msg.String())
 	base.ErrorExit()
 }
 
@@ -252,15 +252,15 @@ func reportInitLoopAndExit(l []*ir.Node) {
 // upon functions (but not variables).
 func collectDeps(n *ir.Node, transitive bool) ir.NodeSet {
 	d := initDeps{transitive: transitive}
-	switch n.Op {
+	switch n.Op() {
 	case ir.OAS:
-		d.inspect(n.Right)
+		d.inspect(n.Right())
 	case ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV:
-		d.inspect(n.Right)
+		d.inspect(n.Right())
 	case ir.ODCLFUNC:
-		d.inspectList(n.Nbody)
+		d.inspectList(n.Body())
 	default:
-		base.Fatalf("unexpected Op: %v", n.Op)
+		base.Fatalf("unexpected Op: %v", n.Op())
 	}
 	return d.seen
 }
@@ -276,7 +276,7 @@ func (d *initDeps) inspectList(l ir.Nodes) { ir.InspectList(l, d.visit) }
 // visit calls foundDep on any package-level functions or variables
 // referenced by n, if any.
 func (d *initDeps) visit(n *ir.Node) bool {
-	switch n.Op {
+	switch n.Op() {
 	case ir.OMETHEXPR:
 		d.foundDep(methodExprName(n))
 		return false
@@ -288,7 +288,7 @@ func (d *initDeps) visit(n *ir.Node) bool {
 		}
 
 	case ir.OCLOSURE:
-		d.inspectList(n.Func.Decl.Nbody)
+		d.inspectList(n.Func().Decl.Body())
 
 	case ir.ODOTMETH, ir.OCALLPART:
 		d.foundDep(methodExprName(n))
@@ -308,7 +308,7 @@ func (d *initDeps) foundDep(n *ir.Node) {
 
 	// Names without definitions aren't interesting as far as
 	// initialization ordering goes.
-	if n.Name.Defn == nil {
+	if n.Name().Defn == nil {
 		return
 	}
 
@@ -317,7 +317,7 @@ func (d *initDeps) foundDep(n *ir.Node) {
 	}
 	d.seen.Add(n)
 	if d.transitive && n.Class() == ir.PFUNC {
-		d.inspectList(n.Name.Defn.Nbody)
+		d.inspectList(n.Name().Defn.Body())
 	}
 }
 
@@ -330,9 +330,11 @@ func (d *initDeps) foundDep(n *ir.Node) {
 // but both OAS nodes use the "=" token's position as their Pos.
 type declOrder []*ir.Node
 
-func (s declOrder) Len() int           { return len(s) }
-func (s declOrder) Less(i, j int) bool { return firstLHS(s[i]).Pos.Before(firstLHS(s[j]).Pos) }
-func (s declOrder) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+func (s declOrder) Len() int { return len(s) }
+func (s declOrder) Less(i, j int) bool {
+	return firstLHS(s[i]).Pos().Before(firstLHS(s[j]).Pos())
+}
+func (s declOrder) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
 
 func (s *declOrder) Push(x interface{}) { *s = append(*s, x.(*ir.Node)) }
 func (s *declOrder) Pop() interface{} {
@@ -344,13 +346,13 @@ func (s *declOrder) Pop() interface{} {
 // firstLHS returns the first expression on the left-hand side of
 // assignment n.
 func firstLHS(n *ir.Node) *ir.Node {
-	switch n.Op {
+	switch n.Op() {
 	case ir.OAS:
-		return n.Left
+		return n.Left()
 	case ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2RECV, ir.OAS2MAPR:
-		return n.List.First()
+		return n.List().First()
 	}
 
-	base.Fatalf("unexpected Op: %v", n.Op)
+	base.Fatalf("unexpected Op: %v", n.Op())
 	return nil
 }
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index f982b43fb9..f82c128265 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -56,19 +56,19 @@ const (
 func fnpkg(fn *ir.Node) *types.Pkg {
 	if ir.IsMethod(fn) {
 		// method
-		rcvr := fn.Type.Recv().Type
+		rcvr := fn.Type().Recv().Type
 
 		if rcvr.IsPtr() {
 			rcvr = rcvr.Elem()
 		}
 		if rcvr.Sym == nil {
-			base.Fatalf("receiver with no sym: [%v] %L  (%v)", fn.Sym, fn, rcvr)
+			base.Fatalf("receiver with no sym: [%v] %L  (%v)", fn.Sym(), fn, rcvr)
 		}
 		return rcvr.Sym.Pkg
 	}
 
 	// non-method
-	return fn.Sym.Pkg
+	return fn.Sym().Pkg
 }
 
 // Lazy typechecking of imported bodies. For local functions, caninl will set ->typecheck
@@ -89,12 +89,12 @@ func typecheckinl(fn *ir.Node) {
 	}
 
 	if base.Flag.LowerM > 2 || base.Debug.Export != 0 {
-		fmt.Printf("typecheck import [%v] %L { %#v }\n", fn.Sym, fn, ir.AsNodes(fn.Func.Inl.Body))
+		fmt.Printf("typecheck import [%v] %L { %#v }\n", fn.Sym(), fn, ir.AsNodes(fn.Func().Inl.Body))
 	}
 
 	savefn := Curfn
 	Curfn = fn
-	typecheckslice(fn.Func.Inl.Body, ctxStmt)
+	typecheckslice(fn.Func().Inl.Body, ctxStmt)
 	Curfn = savefn
 
 	// During expandInline (which imports fn.Func.Inl.Body),
@@ -102,8 +102,8 @@ func typecheckinl(fn *ir.Node) {
 	// to fn.Func.Inl.Dcl for consistency with how local functions
 	// behave. (Append because typecheckinl may be called multiple
 	// times.)
-	fn.Func.Inl.Dcl = append(fn.Func.Inl.Dcl, fn.Func.Dcl...)
-	fn.Func.Dcl = nil
+	fn.Func().Inl.Dcl = append(fn.Func().Inl.Dcl, fn.Func().Dcl...)
+	fn.Func().Dcl = nil
 
 	base.Pos = lno
 }
@@ -112,10 +112,10 @@ func typecheckinl(fn *ir.Node) {
 // If so, caninl saves fn->nbody in fn->inl and substitutes it with a copy.
 // fn and ->nbody will already have been typechecked.
 func caninl(fn *ir.Node) {
-	if fn.Op != ir.ODCLFUNC {
+	if fn.Op() != ir.ODCLFUNC {
 		base.Fatalf("caninl %v", fn)
 	}
-	if fn.Func.Nname == nil {
+	if fn.Func().Nname == nil {
 		base.Fatalf("caninl no nname %+v", fn)
 	}
 
@@ -124,43 +124,43 @@ func caninl(fn *ir.Node) {
 		defer func() {
 			if reason != "" {
 				if base.Flag.LowerM > 1 {
-					fmt.Printf("%v: cannot inline %v: %s\n", ir.Line(fn), fn.Func.Nname, reason)
+					fmt.Printf("%v: cannot inline %v: %s\n", ir.Line(fn), fn.Func().Nname, reason)
 				}
 				if logopt.Enabled() {
-					logopt.LogOpt(fn.Pos, "cannotInlineFunction", "inline", ir.FuncName(fn), reason)
+					logopt.LogOpt(fn.Pos(), "cannotInlineFunction", "inline", ir.FuncName(fn), reason)
 				}
 			}
 		}()
 	}
 
 	// If marked "go:noinline", don't inline
-	if fn.Func.Pragma&ir.Noinline != 0 {
+	if fn.Func().Pragma&ir.Noinline != 0 {
 		reason = "marked go:noinline"
 		return
 	}
 
 	// If marked "go:norace" and -race compilation, don't inline.
-	if base.Flag.Race && fn.Func.Pragma&ir.Norace != 0 {
+	if base.Flag.Race && fn.Func().Pragma&ir.Norace != 0 {
 		reason = "marked go:norace with -race compilation"
 		return
 	}
 
 	// If marked "go:nocheckptr" and -d checkptr compilation, don't inline.
-	if base.Debug.Checkptr != 0 && fn.Func.Pragma&ir.NoCheckPtr != 0 {
+	if base.Debug.Checkptr != 0 && fn.Func().Pragma&ir.NoCheckPtr != 0 {
 		reason = "marked go:nocheckptr"
 		return
 	}
 
 	// If marked "go:cgo_unsafe_args", don't inline, since the
 	// function makes assumptions about its argument frame layout.
-	if fn.Func.Pragma&ir.CgoUnsafeArgs != 0 {
+	if fn.Func().Pragma&ir.CgoUnsafeArgs != 0 {
 		reason = "marked go:cgo_unsafe_args"
 		return
 	}
 
 	// If marked as "go:uintptrescapes", don't inline, since the
 	// escape information is lost during inlining.
-	if fn.Func.Pragma&ir.UintptrEscapes != 0 {
+	if fn.Func().Pragma&ir.UintptrEscapes != 0 {
 		reason = "marked as having an escaping uintptr argument"
 		return
 	}
@@ -169,13 +169,13 @@ func caninl(fn *ir.Node) {
 	// granularity, so inlining yeswritebarrierrec functions can
 	// confuse it (#22342). As a workaround, disallow inlining
 	// them for now.
-	if fn.Func.Pragma&ir.Yeswritebarrierrec != 0 {
+	if fn.Func().Pragma&ir.Yeswritebarrierrec != 0 {
 		reason = "marked go:yeswritebarrierrec"
 		return
 	}
 
 	// If fn has no body (is defined outside of Go), cannot inline it.
-	if fn.Nbody.Len() == 0 {
+	if fn.Body().Len() == 0 {
 		reason = "no function body"
 		return
 	}
@@ -184,11 +184,11 @@ func caninl(fn *ir.Node) {
 		base.Fatalf("caninl on non-typechecked function %v", fn)
 	}
 
-	n := fn.Func.Nname
-	if n.Func.InlinabilityChecked() {
+	n := fn.Func().Nname
+	if n.Func().InlinabilityChecked() {
 		return
 	}
-	defer n.Func.SetInlinabilityChecked(true)
+	defer n.Func().SetInlinabilityChecked(true)
 
 	cc := int32(inlineExtraCallCost)
 	if base.Flag.LowerL == 4 {
@@ -209,7 +209,7 @@ func caninl(fn *ir.Node) {
 		extraCallCost: cc,
 		usedLocals:    make(map[*ir.Node]bool),
 	}
-	if visitor.visitList(fn.Nbody) {
+	if visitor.visitList(fn.Body()) {
 		reason = visitor.reason
 		return
 	}
@@ -218,19 +218,19 @@ func caninl(fn *ir.Node) {
 		return
 	}
 
-	n.Func.Inl = &ir.Inline{
+	n.Func().Inl = &ir.Inline{
 		Cost: inlineMaxBudget - visitor.budget,
-		Dcl:  inlcopylist(pruneUnusedAutos(n.Name.Defn.Func.Dcl, &visitor)),
-		Body: inlcopylist(fn.Nbody.Slice()),
+		Dcl:  inlcopylist(pruneUnusedAutos(n.Name().Defn.Func().Dcl, &visitor)),
+		Body: inlcopylist(fn.Body().Slice()),
 	}
 
 	if base.Flag.LowerM > 1 {
-		fmt.Printf("%v: can inline %#v with cost %d as: %#v { %#v }\n", ir.Line(fn), n, inlineMaxBudget-visitor.budget, fn.Type, ir.AsNodes(n.Func.Inl.Body))
+		fmt.Printf("%v: can inline %#v with cost %d as: %#v { %#v }\n", ir.Line(fn), n, inlineMaxBudget-visitor.budget, fn.Type(), ir.AsNodes(n.Func().Inl.Body))
 	} else if base.Flag.LowerM != 0 {
 		fmt.Printf("%v: can inline %v\n", ir.Line(fn), n)
 	}
 	if logopt.Enabled() {
-		logopt.LogOpt(fn.Pos, "canInlineFunction", "inline", ir.FuncName(fn), fmt.Sprintf("cost: %d", inlineMaxBudget-visitor.budget))
+		logopt.LogOpt(fn.Pos(), "canInlineFunction", "inline", ir.FuncName(fn), fmt.Sprintf("cost: %d", inlineMaxBudget-visitor.budget))
 	}
 }
 
@@ -240,28 +240,28 @@ func inlFlood(n *ir.Node) {
 	if n == nil {
 		return
 	}
-	if n.Op != ir.ONAME || n.Class() != ir.PFUNC {
-		base.Fatalf("inlFlood: unexpected %v, %v, %v", n, n.Op, n.Class())
+	if n.Op() != ir.ONAME || n.Class() != ir.PFUNC {
+		base.Fatalf("inlFlood: unexpected %v, %v, %v", n, n.Op(), n.Class())
 	}
-	if n.Func == nil {
+	if n.Func() == nil {
 		base.Fatalf("inlFlood: missing Func on %v", n)
 	}
-	if n.Func.Inl == nil {
+	if n.Func().Inl == nil {
 		return
 	}
 
-	if n.Func.ExportInline() {
+	if n.Func().ExportInline() {
 		return
 	}
-	n.Func.SetExportInline(true)
+	n.Func().SetExportInline(true)
 
 	typecheckinl(n)
 
 	// Recursively identify all referenced functions for
 	// reexport. We want to include even non-called functions,
 	// because after inlining they might be callable.
-	ir.InspectList(ir.AsNodes(n.Func.Inl.Body), func(n *ir.Node) bool {
-		switch n.Op {
+	ir.InspectList(ir.AsNodes(n.Func().Inl.Body), func(n *ir.Node) bool {
+		switch n.Op() {
 		case ir.OMETHEXPR:
 			inlFlood(methodExprName(n))
 
@@ -318,15 +318,15 @@ func (v *hairyVisitor) visit(n *ir.Node) bool {
 		return false
 	}
 
-	switch n.Op {
+	switch n.Op() {
 	// Call is okay if inlinable and we have the budget for the body.
 	case ir.OCALLFUNC:
 		// Functions that call runtime.getcaller{pc,sp} can not be inlined
 		// because getcaller{pc,sp} expect a pointer to the caller's first argument.
 		//
 		// runtime.throw is a "cheap call" like panic in normal code.
-		if n.Left.Op == ir.ONAME && n.Left.Class() == ir.PFUNC && isRuntimePkg(n.Left.Sym.Pkg) {
-			fn := n.Left.Sym.Name
+		if n.Left().Op() == ir.ONAME && n.Left().Class() == ir.PFUNC && isRuntimePkg(n.Left().Sym().Pkg) {
+			fn := n.Left().Sym().Name
 			if fn == "getcallerpc" || fn == "getcallersp" {
 				v.reason = "call to " + fn
 				return true
@@ -342,8 +342,8 @@ func (v *hairyVisitor) visit(n *ir.Node) bool {
 			break
 		}
 
-		if fn := inlCallee(n.Left); fn != nil && fn.Func.Inl != nil {
-			v.budget -= fn.Func.Inl.Cost
+		if fn := inlCallee(n.Left()); fn != nil && fn.Func().Inl != nil {
+			v.budget -= fn.Func().Inl.Cost
 			break
 		}
 
@@ -352,12 +352,12 @@ func (v *hairyVisitor) visit(n *ir.Node) bool {
 
 	// Call is okay if inlinable and we have the budget for the body.
 	case ir.OCALLMETH:
-		t := n.Left.Type
+		t := n.Left().Type()
 		if t == nil {
-			base.Fatalf("no function type for [%p] %+v\n", n.Left, n.Left)
+			base.Fatalf("no function type for [%p] %+v\n", n.Left(), n.Left())
 		}
-		if isRuntimePkg(n.Left.Sym.Pkg) {
-			fn := n.Left.Sym.Name
+		if isRuntimePkg(n.Left().Sym().Pkg) {
+			fn := n.Left().Sym().Name
 			if fn == "heapBits.nextArena" {
 				// Special case: explicitly allow
 				// mid-stack inlining of
@@ -367,7 +367,7 @@ func (v *hairyVisitor) visit(n *ir.Node) bool {
 				break
 			}
 		}
-		if inlfn := methodExprName(n.Left).Func; inlfn.Inl != nil {
+		if inlfn := methodExprName(n.Left()).Func(); inlfn.Inl != nil {
 			v.budget -= inlfn.Inl.Cost
 			break
 		}
@@ -395,7 +395,7 @@ func (v *hairyVisitor) visit(n *ir.Node) bool {
 		ir.ODEFER,
 		ir.ODCLTYPE, // can't print yet
 		ir.ORETJMP:
-		v.reason = "unhandled op " + n.Op.String()
+		v.reason = "unhandled op " + n.Op().String()
 		return true
 
 	case ir.OAPPEND:
@@ -413,16 +413,16 @@ func (v *hairyVisitor) visit(n *ir.Node) bool {
 		}
 
 	case ir.OBREAK, ir.OCONTINUE:
-		if n.Sym != nil {
+		if n.Sym() != nil {
 			// Should have short-circuited due to labeledControl above.
 			base.Fatalf("unexpected labeled break/continue: %v", n)
 		}
 
 	case ir.OIF:
-		if ir.IsConst(n.Left, constant.Bool) {
+		if ir.IsConst(n.Left(), constant.Bool) {
 			// This if and the condition cost nothing.
-			return v.visitList(n.Ninit) || v.visitList(n.Nbody) ||
-				v.visitList(n.Rlist)
+			return v.visitList(n.Init()) || v.visitList(n.Body()) ||
+				v.visitList(n.Rlist())
 		}
 
 	case ir.ONAME:
@@ -439,9 +439,9 @@ func (v *hairyVisitor) visit(n *ir.Node) bool {
 		return true
 	}
 
-	return v.visit(n.Left) || v.visit(n.Right) ||
-		v.visitList(n.List) || v.visitList(n.Rlist) ||
-		v.visitList(n.Ninit) || v.visitList(n.Nbody)
+	return v.visit(n.Left()) || v.visit(n.Right()) ||
+		v.visitList(n.List()) || v.visitList(n.Rlist()) ||
+		v.visitList(n.Init()) || v.visitList(n.Body())
 }
 
 // inlcopylist (together with inlcopy) recursively copies a list of nodes, except
@@ -460,21 +460,21 @@ func inlcopy(n *ir.Node) *ir.Node {
 		return nil
 	}
 
-	switch n.Op {
+	switch n.Op() {
 	case ir.ONAME, ir.OTYPE, ir.OLITERAL, ir.ONIL:
 		return n
 	}
 
 	m := ir.Copy(n)
-	if n.Op != ir.OCALLPART && m.Func != nil {
+	if n.Op() != ir.OCALLPART && m.Func() != nil {
 		base.Fatalf("unexpected Func: %v", m)
 	}
-	m.Left = inlcopy(n.Left)
-	m.Right = inlcopy(n.Right)
-	m.List.Set(inlcopylist(n.List.Slice()))
-	m.Rlist.Set(inlcopylist(n.Rlist.Slice()))
-	m.Ninit.Set(inlcopylist(n.Ninit.Slice()))
-	m.Nbody.Set(inlcopylist(n.Nbody.Slice()))
+	m.SetLeft(inlcopy(n.Left()))
+	m.SetRight(inlcopy(n.Right()))
+	m.PtrList().Set(inlcopylist(n.List().Slice()))
+	m.PtrRlist().Set(inlcopylist(n.Rlist().Slice()))
+	m.PtrInit().Set(inlcopylist(n.Init().Slice()))
+	m.PtrBody().Set(inlcopylist(n.Body().Slice()))
 
 	return m
 }
@@ -484,18 +484,18 @@ func countNodes(n *ir.Node) int {
 		return 0
 	}
 	cnt := 1
-	cnt += countNodes(n.Left)
-	cnt += countNodes(n.Right)
-	for _, n1 := range n.Ninit.Slice() {
+	cnt += countNodes(n.Left())
+	cnt += countNodes(n.Right())
+	for _, n1 := range n.Init().Slice() {
 		cnt += countNodes(n1)
 	}
-	for _, n1 := range n.Nbody.Slice() {
+	for _, n1 := range n.Body().Slice() {
 		cnt += countNodes(n1)
 	}
-	for _, n1 := range n.List.Slice() {
+	for _, n1 := range n.List().Slice() {
 		cnt += countNodes(n1)
 	}
-	for _, n1 := range n.Rlist.Slice() {
+	for _, n1 := range n.Rlist().Slice() {
 		cnt += countNodes(n1)
 	}
 	return cnt
@@ -526,21 +526,21 @@ func inlcalls(fn *ir.Node) {
 
 // Turn an OINLCALL into a statement.
 func inlconv2stmt(n *ir.Node) {
-	n.Op = ir.OBLOCK
+	n.SetOp(ir.OBLOCK)
 
 	// n->ninit stays
-	n.List.Set(n.Nbody.Slice())
+	n.PtrList().Set(n.Body().Slice())
 
-	n.Nbody.Set(nil)
-	n.Rlist.Set(nil)
+	n.PtrBody().Set(nil)
+	n.PtrRlist().Set(nil)
 }
 
 // Turn an OINLCALL into a single valued expression.
 // The result of inlconv2expr MUST be assigned back to n, e.g.
 // 	n.Left = inlconv2expr(n.Left)
 func inlconv2expr(n *ir.Node) *ir.Node {
-	r := n.Rlist.First()
-	return addinit(r, append(n.Ninit.Slice(), n.Nbody.Slice()...))
+	r := n.Rlist().First()
+	return addinit(r, append(n.Init().Slice(), n.Body().Slice()...))
 }
 
 // Turn the rlist (with the return values) of the OINLCALL in
@@ -549,12 +549,12 @@ func inlconv2expr(n *ir.Node) *ir.Node {
 // order will be preserved Used in return, oas2func and call
 // statements.
 func inlconv2list(n *ir.Node) []*ir.Node {
-	if n.Op != ir.OINLCALL || n.Rlist.Len() == 0 {
+	if n.Op() != ir.OINLCALL || n.Rlist().Len() == 0 {
 		base.Fatalf("inlconv2list %+v\n", n)
 	}
 
-	s := n.Rlist.Slice()
-	s[0] = addinit(s[0], append(n.Ninit.Slice(), n.Nbody.Slice()...))
+	s := n.Rlist().Slice()
+	s[0] = addinit(s[0], append(n.Init().Slice(), n.Body().Slice()...))
 	return s
 }
 
@@ -583,11 +583,11 @@ func inlnode(n *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node {
 		return n
 	}
 
-	switch n.Op {
+	switch n.Op() {
 	case ir.ODEFER, ir.OGO:
-		switch n.Left.Op {
+		switch n.Left().Op() {
 		case ir.OCALLFUNC, ir.OCALLMETH:
-			n.Left.SetNoInline(true)
+			n.Left().SetNoInline(true)
 		}
 
 	// TODO do them here (or earlier),
@@ -597,61 +597,61 @@ func inlnode(n *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node {
 	case ir.OCALLMETH:
 		// Prevent inlining some reflect.Value methods when using checkptr,
 		// even when package reflect was compiled without it (#35073).
-		if s := n.Left.Sym; base.Debug.Checkptr != 0 && isReflectPkg(s.Pkg) && (s.Name == "Value.UnsafeAddr" || s.Name == "Value.Pointer") {
+		if s := n.Left().Sym(); base.Debug.Checkptr != 0 && isReflectPkg(s.Pkg) && (s.Name == "Value.UnsafeAddr" || s.Name == "Value.Pointer") {
 			return n
 		}
 	}
 
 	lno := setlineno(n)
 
-	inlnodelist(n.Ninit, maxCost, inlMap)
-	for _, n1 := range n.Ninit.Slice() {
-		if n1.Op == ir.OINLCALL {
+	inlnodelist(n.Init(), maxCost, inlMap)
+	for _, n1 := range n.Init().Slice() {
+		if n1.Op() == ir.OINLCALL {
 			inlconv2stmt(n1)
 		}
 	}
 
-	n.Left = inlnode(n.Left, maxCost, inlMap)
-	if n.Left != nil && n.Left.Op == ir.OINLCALL {
-		n.Left = inlconv2expr(n.Left)
+	n.SetLeft(inlnode(n.Left(), maxCost, inlMap))
+	if n.Left() != nil && n.Left().Op() == ir.OINLCALL {
+		n.SetLeft(inlconv2expr(n.Left()))
 	}
 
-	n.Right = inlnode(n.Right, maxCost, inlMap)
-	if n.Right != nil && n.Right.Op == ir.OINLCALL {
-		if n.Op == ir.OFOR || n.Op == ir.OFORUNTIL {
-			inlconv2stmt(n.Right)
-		} else if n.Op == ir.OAS2FUNC {
-			n.Rlist.Set(inlconv2list(n.Right))
-			n.Right = nil
-			n.Op = ir.OAS2
+	n.SetRight(inlnode(n.Right(), maxCost, inlMap))
+	if n.Right() != nil && n.Right().Op() == ir.OINLCALL {
+		if n.Op() == ir.OFOR || n.Op() == ir.OFORUNTIL {
+			inlconv2stmt(n.Right())
+		} else if n.Op() == ir.OAS2FUNC {
+			n.PtrRlist().Set(inlconv2list(n.Right()))
+			n.SetRight(nil)
+			n.SetOp(ir.OAS2)
 			n.SetTypecheck(0)
 			n = typecheck(n, ctxStmt)
 		} else {
-			n.Right = inlconv2expr(n.Right)
+			n.SetRight(inlconv2expr(n.Right()))
 		}
 	}
 
-	inlnodelist(n.List, maxCost, inlMap)
-	if n.Op == ir.OBLOCK {
-		for _, n2 := range n.List.Slice() {
-			if n2.Op == ir.OINLCALL {
+	inlnodelist(n.List(), maxCost, inlMap)
+	if n.Op() == ir.OBLOCK {
+		for _, n2 := range n.List().Slice() {
+			if n2.Op() == ir.OINLCALL {
 				inlconv2stmt(n2)
 			}
 		}
 	} else {
-		s := n.List.Slice()
+		s := n.List().Slice()
 		for i1, n1 := range s {
-			if n1 != nil && n1.Op == ir.OINLCALL {
+			if n1 != nil && n1.Op() == ir.OINLCALL {
 				s[i1] = inlconv2expr(s[i1])
 			}
 		}
 	}
 
-	inlnodelist(n.Rlist, maxCost, inlMap)
-	s := n.Rlist.Slice()
+	inlnodelist(n.Rlist(), maxCost, inlMap)
+	s := n.Rlist().Slice()
 	for i1, n1 := range s {
-		if n1.Op == ir.OINLCALL {
-			if n.Op == ir.OIF {
+		if n1.Op() == ir.OINLCALL {
+			if n.Op() == ir.OIF {
 				inlconv2stmt(n1)
 			} else {
 				s[i1] = inlconv2expr(s[i1])
@@ -659,9 +659,9 @@ func inlnode(n *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node {
 		}
 	}
 
-	inlnodelist(n.Nbody, maxCost, inlMap)
-	for _, n := range n.Nbody.Slice() {
-		if n.Op == ir.OINLCALL {
+	inlnodelist(n.Body(), maxCost, inlMap)
+	for _, n := range n.Body().Slice() {
+		if n.Op() == ir.OINLCALL {
 			inlconv2stmt(n)
 		}
 	}
@@ -669,36 +669,36 @@ func inlnode(n *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node {
 	// with all the branches out of the way, it is now time to
 	// transmogrify this node itself unless inhibited by the
 	// switch at the top of this function.
-	switch n.Op {
+	switch n.Op() {
 	case ir.OCALLFUNC, ir.OCALLMETH:
 		if n.NoInline() {
 			return n
 		}
 	}
 
-	switch n.Op {
+	switch n.Op() {
 	case ir.OCALLFUNC:
 		if base.Flag.LowerM > 3 {
-			fmt.Printf("%v:call to func %+v\n", ir.Line(n), n.Left)
+			fmt.Printf("%v:call to func %+v\n", ir.Line(n), n.Left())
 		}
 		if isIntrinsicCall(n) {
 			break
 		}
-		if fn := inlCallee(n.Left); fn != nil && fn.Func.Inl != nil {
+		if fn := inlCallee(n.Left()); fn != nil && fn.Func().Inl != nil {
 			n = mkinlcall(n, fn, maxCost, inlMap)
 		}
 
 	case ir.OCALLMETH:
 		if base.Flag.LowerM > 3 {
-			fmt.Printf("%v:call to meth %L\n", ir.Line(n), n.Left.Right)
+			fmt.Printf("%v:call to meth %L\n", ir.Line(n), n.Left().Right())
 		}
 
 		// typecheck should have resolved ODOTMETH->type, whose nname points to the actual function.
-		if n.Left.Type == nil {
-			base.Fatalf("no function type for [%p] %+v\n", n.Left, n.Left)
+		if n.Left().Type() == nil {
+			base.Fatalf("no function type for [%p] %+v\n", n.Left(), n.Left())
 		}
 
-		n = mkinlcall(n, methodExprName(n.Left), maxCost, inlMap)
+		n = mkinlcall(n, methodExprName(n.Left()), maxCost, inlMap)
 	}
 
 	base.Pos = lno
@@ -710,29 +710,29 @@ func inlnode(n *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node {
 func inlCallee(fn *ir.Node) *ir.Node {
 	fn = staticValue(fn)
 	switch {
-	case fn.Op == ir.OMETHEXPR:
+	case fn.Op() == ir.OMETHEXPR:
 		n := methodExprName(fn)
 		// Check that receiver type matches fn.Left.
 		// TODO(mdempsky): Handle implicit dereference
 		// of pointer receiver argument?
-		if n == nil || !types.Identical(n.Type.Recv().Type, fn.Left.Type) {
+		if n == nil || !types.Identical(n.Type().Recv().Type, fn.Left().Type()) {
 			return nil
 		}
 		return n
-	case fn.Op == ir.ONAME && fn.Class() == ir.PFUNC:
+	case fn.Op() == ir.ONAME && fn.Class() == ir.PFUNC:
 		return fn
-	case fn.Op == ir.OCLOSURE:
-		c := fn.Func.Decl
+	case fn.Op() == ir.OCLOSURE:
+		c := fn.Func().Decl
 		caninl(c)
-		return c.Func.Nname
+		return c.Func().Nname
 	}
 	return nil
 }
 
 func staticValue(n *ir.Node) *ir.Node {
 	for {
-		if n.Op == ir.OCONVNOP {
-			n = n.Left
+		if n.Op() == ir.OCONVNOP {
+			n = n.Left()
 			continue
 		}
 
@@ -748,24 +748,24 @@ func staticValue(n *ir.Node) *ir.Node {
 // that is initialized and never reassigned, staticValue1 returns the initializer
 // expression. Otherwise, it returns nil.
 func staticValue1(n *ir.Node) *ir.Node {
-	if n.Op != ir.ONAME || n.Class() != ir.PAUTO || n.Name.Addrtaken() {
+	if n.Op() != ir.ONAME || n.Class() != ir.PAUTO || n.Name().Addrtaken() {
 		return nil
 	}
 
-	defn := n.Name.Defn
+	defn := n.Name().Defn
 	if defn == nil {
 		return nil
 	}
 
 	var rhs *ir.Node
 FindRHS:
-	switch defn.Op {
+	switch defn.Op() {
 	case ir.OAS:
-		rhs = defn.Right
+		rhs = defn.Right()
 	case ir.OAS2:
-		for i, lhs := range defn.List.Slice() {
+		for i, lhs := range defn.List().Slice() {
 			if lhs == n {
-				rhs = defn.Rlist.Index(i)
+				rhs = defn.Rlist().Index(i)
 				break FindRHS
 			}
 		}
@@ -792,24 +792,24 @@ FindRHS:
 // NB: global variables are always considered to be re-assigned.
 // TODO: handle initial declaration not including an assignment and followed by a single assignment?
 func reassigned(n *ir.Node) (bool, *ir.Node) {
-	if n.Op != ir.ONAME {
+	if n.Op() != ir.ONAME {
 		base.Fatalf("reassigned %v", n)
 	}
 	// no way to reliably check for no-reassignment of globals, assume it can be
-	if n.Name.Curfn == nil {
+	if n.Name().Curfn == nil {
 		return true, nil
 	}
-	f := n.Name.Curfn
+	f := n.Name().Curfn
 	// There just might be a good reason for this although this can be pretty surprising:
 	// local variables inside a closure have Curfn pointing to the OCLOSURE node instead
 	// of the corresponding ODCLFUNC.
 	// We need to walk the function body to check for reassignments so we follow the
 	// linkage to the ODCLFUNC node as that is where body is held.
-	if f.Op == ir.OCLOSURE {
-		f = f.Func.Decl
+	if f.Op() == ir.OCLOSURE {
+		f = f.Func().Decl
 	}
 	v := reassignVisitor{name: n}
-	a := v.visitList(f.Nbody)
+	a := v.visitList(f.Body())
 	return a != nil, a
 }
 
@@ -821,34 +821,34 @@ func (v *reassignVisitor) visit(n *ir.Node) *ir.Node {
 	if n == nil {
 		return nil
 	}
-	switch n.Op {
+	switch n.Op() {
 	case ir.OAS:
-		if n.Left == v.name && n != v.name.Name.Defn {
+		if n.Left() == v.name && n != v.name.Name().Defn {
 			return n
 		}
 	case ir.OAS2, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2DOTTYPE:
-		for _, p := range n.List.Slice() {
-			if p == v.name && n != v.name.Name.Defn {
+		for _, p := range n.List().Slice() {
+			if p == v.name && n != v.name.Name().Defn {
 				return n
 			}
 		}
 	}
-	if a := v.visit(n.Left); a != nil {
+	if a := v.visit(n.Left()); a != nil {
 		return a
 	}
-	if a := v.visit(n.Right); a != nil {
+	if a := v.visit(n.Right()); a != nil {
 		return a
 	}
-	if a := v.visitList(n.List); a != nil {
+	if a := v.visitList(n.List()); a != nil {
 		return a
 	}
-	if a := v.visitList(n.Rlist); a != nil {
+	if a := v.visitList(n.Rlist()); a != nil {
 		return a
 	}
-	if a := v.visitList(n.Ninit); a != nil {
+	if a := v.visitList(n.Init()); a != nil {
 		return a
 	}
-	if a := v.visitList(n.Nbody); a != nil {
+	if a := v.visitList(n.Body()); a != nil {
 		return a
 	}
 	return nil
@@ -873,8 +873,8 @@ func inlParam(t *types.Field, as *ir.Node, inlvars map[*ir.Node]*ir.Node) *ir.No
 	if inlvar == nil {
 		base.Fatalf("missing inlvar for %v", n)
 	}
-	as.Ninit.Append(ir.Nod(ir.ODCL, inlvar, nil))
-	inlvar.Name.Defn = as
+	as.PtrInit().Append(ir.Nod(ir.ODCL, inlvar, nil))
+	inlvar.Name().Defn = as
 	return inlvar
 }
 
@@ -888,32 +888,32 @@ var inlgen int
 // The result of mkinlcall MUST be assigned back to n, e.g.
 // 	n.Left = mkinlcall(n.Left, fn, isddd)
 func mkinlcall(n, fn *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node {
-	if fn.Func.Inl == nil {
+	if fn.Func().Inl == nil {
 		if logopt.Enabled() {
-			logopt.LogOpt(n.Pos, "cannotInlineCall", "inline", ir.FuncName(Curfn),
+			logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", ir.FuncName(Curfn),
 				fmt.Sprintf("%s cannot be inlined", ir.PkgFuncName(fn)))
 		}
 		return n
 	}
-	if fn.Func.Inl.Cost > maxCost {
+	if fn.Func().Inl.Cost > maxCost {
 		// The inlined function body is too big. Typically we use this check to restrict
 		// inlining into very big functions.  See issue 26546 and 17566.
 		if logopt.Enabled() {
-			logopt.LogOpt(n.Pos, "cannotInlineCall", "inline", ir.FuncName(Curfn),
-				fmt.Sprintf("cost %d of %s exceeds max large caller cost %d", fn.Func.Inl.Cost, ir.PkgFuncName(fn), maxCost))
+			logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", ir.FuncName(Curfn),
+				fmt.Sprintf("cost %d of %s exceeds max large caller cost %d", fn.Func().Inl.Cost, ir.PkgFuncName(fn), maxCost))
 		}
 		return n
 	}
 
-	if fn == Curfn || fn.Name.Defn == Curfn {
+	if fn == Curfn || fn.Name().Defn == Curfn {
 		// Can't recursively inline a function into itself.
 		if logopt.Enabled() {
-			logopt.LogOpt(n.Pos, "cannotInlineCall", "inline", fmt.Sprintf("recursive call to %s", ir.FuncName(Curfn)))
+			logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", fmt.Sprintf("recursive call to %s", ir.FuncName(Curfn)))
 		}
 		return n
 	}
 
-	if instrumenting && isRuntimePkg(fn.Sym.Pkg) {
+	if instrumenting && isRuntimePkg(fn.Sym().Pkg) {
 		// Runtime package must not be instrumented.
 		// Instrument skips runtime package. However, some runtime code can be
 		// inlined into other packages and instrumented there. To avoid this,
@@ -939,7 +939,7 @@ func mkinlcall(n, fn *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node
 
 	// We have a function node, and it has an inlineable body.
 	if base.Flag.LowerM > 1 {
-		fmt.Printf("%v: inlining call to %v %#v { %#v }\n", ir.Line(n), fn.Sym, fn.Type, ir.AsNodes(fn.Func.Inl.Body))
+		fmt.Printf("%v: inlining call to %v %#v { %#v }\n", ir.Line(n), fn.Sym(), fn.Type(), ir.AsNodes(fn.Func().Inl.Body))
 	} else if base.Flag.LowerM != 0 {
 		fmt.Printf("%v: inlining call to %v\n", ir.Line(n), fn)
 	}
@@ -951,19 +951,19 @@ func mkinlcall(n, fn *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node
 		ssaDumpInlined = append(ssaDumpInlined, fn)
 	}
 
-	ninit := n.Ninit
+	ninit := n.Init()
 
 	// For normal function calls, the function callee expression
 	// may contain side effects (e.g., added by addinit during
 	// inlconv2expr or inlconv2list). Make sure to preserve these,
 	// if necessary (#42703).
-	if n.Op == ir.OCALLFUNC {
-		callee := n.Left
-		for callee.Op == ir.OCONVNOP {
-			ninit.AppendNodes(&callee.Ninit)
-			callee = callee.Left
+	if n.Op() == ir.OCALLFUNC {
+		callee := n.Left()
+		for callee.Op() == ir.OCONVNOP {
+			ninit.AppendNodes(callee.PtrInit())
+			callee = callee.Left()
 		}
-		if callee.Op != ir.ONAME && callee.Op != ir.OCLOSURE && callee.Op != ir.OMETHEXPR {
+		if callee.Op() != ir.ONAME && callee.Op() != ir.OCLOSURE && callee.Op() != ir.OMETHEXPR {
 			base.Fatalf("unexpected callee expression: %v", callee)
 		}
 	}
@@ -975,30 +975,30 @@ func mkinlcall(n, fn *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node
 	var inlfvars []*ir.Node
 
 	// Handle captured variables when inlining closures.
-	if fn.Name.Defn != nil {
-		if c := fn.Name.Defn.Func.OClosure; c != nil {
-			for _, v := range c.Func.ClosureVars.Slice() {
-				if v.Op == ir.OXXX {
+	if fn.Name().Defn != nil {
+		if c := fn.Name().Defn.Func().OClosure; c != nil {
+			for _, v := range c.Func().ClosureVars.Slice() {
+				if v.Op() == ir.OXXX {
 					continue
 				}
 
-				o := v.Name.Param.Outer
+				o := v.Name().Param.Outer
 				// make sure the outer param matches the inlining location
 				// NB: if we enabled inlining of functions containing OCLOSURE or refined
 				// the reassigned check via some sort of copy propagation this would most
 				// likely need to be changed to a loop to walk up to the correct Param
-				if o == nil || (o.Name.Curfn != Curfn && o.Name.Curfn.Func.OClosure != Curfn) {
+				if o == nil || (o.Name().Curfn != Curfn && o.Name().Curfn.Func().OClosure != Curfn) {
 					base.Fatalf("%v: unresolvable capture %v %v\n", ir.Line(n), fn, v)
 				}
 
-				if v.Name.Byval() {
+				if v.Name().Byval() {
 					iv := typecheck(inlvar(v), ctxExpr)
 					ninit.Append(ir.Nod(ir.ODCL, iv, nil))
 					ninit.Append(typecheck(ir.Nod(ir.OAS, iv, o), ctxStmt))
 					inlvars[v] = iv
 				} else {
-					addr := NewName(lookup("&" + v.Sym.Name))
-					addr.Type = types.NewPtr(v.Type)
+					addr := NewName(lookup("&" + v.Sym().Name))
+					addr.SetType(types.NewPtr(v.Type()))
 					ia := typecheck(inlvar(addr), ctxExpr)
 					ninit.Append(ir.Nod(ir.ODCL, ia, nil))
 					ninit.Append(typecheck(ir.Nod(ir.OAS, ia, ir.Nod(ir.OADDR, o, nil)), ctxStmt))
@@ -1012,8 +1012,8 @@ func mkinlcall(n, fn *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node
 		}
 	}
 
-	for _, ln := range fn.Func.Inl.Dcl {
-		if ln.Op != ir.ONAME {
+	for _, ln := range fn.Func().Inl.Dcl {
+		if ln.Op() != ir.ONAME {
 			continue
 		}
 		if ln.Class() == ir.PPARAMOUT { // return values handled below.
@@ -1030,18 +1030,18 @@ func mkinlcall(n, fn *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node
 		inlvars[ln] = inlf
 		if base.Flag.GenDwarfInl > 0 {
 			if ln.Class() == ir.PPARAM {
-				inlf.Name.SetInlFormal(true)
+				inlf.Name().SetInlFormal(true)
 			} else {
-				inlf.Name.SetInlLocal(true)
+				inlf.Name().SetInlLocal(true)
 			}
-			inlf.Pos = ln.Pos
+			inlf.SetPos(ln.Pos())
 			inlfvars = append(inlfvars, inlf)
 		}
 	}
 
 	nreturns := 0
-	ir.InspectList(ir.AsNodes(fn.Func.Inl.Body), func(n *ir.Node) bool {
-		if n != nil && n.Op == ir.ORETURN {
+	ir.InspectList(ir.AsNodes(fn.Func().Inl.Body), func(n *ir.Node) bool {
+		if n != nil && n.Op() == ir.ORETURN {
 			nreturns++
 		}
 		return true
@@ -1054,9 +1054,9 @@ func mkinlcall(n, fn *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node
 
 	// temporaries for return values.
 	var retvars []*ir.Node
-	for i, t := range fn.Type.Results().Fields().Slice() {
+	for i, t := range fn.Type().Results().Fields().Slice() {
 		var m *ir.Node
-		if n := ir.AsNode(t.Nname); n != nil && !ir.IsBlank(n) && !strings.HasPrefix(n.Sym.Name, "~r") {
+		if n := ir.AsNode(t.Nname); n != nil && !ir.IsBlank(n) && !strings.HasPrefix(n.Sym().Name, "~r") {
 			m = inlvar(n)
 			m = typecheck(m, ctxExpr)
 			inlvars[n] = m
@@ -1070,9 +1070,9 @@ func mkinlcall(n, fn *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node
 			// Don't update the src.Pos on a return variable if it
 			// was manufactured by the inliner (e.g. "~R2"); such vars
 			// were not part of the original callee.
-			if !strings.HasPrefix(m.Sym.Name, "~R") {
-				m.Name.SetInlFormal(true)
-				m.Pos = t.Pos
+			if !strings.HasPrefix(m.Sym().Name, "~R") {
+				m.Name().SetInlFormal(true)
+				m.SetPos(t.Pos)
 				inlfvars = append(inlfvars, m)
 			}
 		}
@@ -1083,51 +1083,51 @@ func mkinlcall(n, fn *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node
 	// Assign arguments to the parameters' temp names.
 	as := ir.Nod(ir.OAS2, nil, nil)
 	as.SetColas(true)
-	if n.Op == ir.OCALLMETH {
-		if n.Left.Left == nil {
+	if n.Op() == ir.OCALLMETH {
+		if n.Left().Left() == nil {
 			base.Fatalf("method call without receiver: %+v", n)
 		}
-		as.Rlist.Append(n.Left.Left)
+		as.PtrRlist().Append(n.Left().Left())
 	}
-	as.Rlist.Append(n.List.Slice()...)
+	as.PtrRlist().Append(n.List().Slice()...)
 
 	// For non-dotted calls to variadic functions, we assign the
 	// variadic parameter's temp name separately.
 	var vas *ir.Node
 
-	if recv := fn.Type.Recv(); recv != nil {
-		as.List.Append(inlParam(recv, as, inlvars))
+	if recv := fn.Type().Recv(); recv != nil {
+		as.PtrList().Append(inlParam(recv, as, inlvars))
 	}
-	for _, param := range fn.Type.Params().Fields().Slice() {
+	for _, param := range fn.Type().Params().Fields().Slice() {
 		// For ordinary parameters or variadic parameters in
 		// dotted calls, just add the variable to the
 		// assignment list, and we're done.
 		if !param.IsDDD() || n.IsDDD() {
-			as.List.Append(inlParam(param, as, inlvars))
+			as.PtrList().Append(inlParam(param, as, inlvars))
 			continue
 		}
 
 		// Otherwise, we need to collect the remaining values
 		// to pass as a slice.
 
-		x := as.List.Len()
-		for as.List.Len() < as.Rlist.Len() {
-			as.List.Append(argvar(param.Type, as.List.Len()))
+		x := as.List().Len()
+		for as.List().Len() < as.Rlist().Len() {
+			as.PtrList().Append(argvar(param.Type, as.List().Len()))
 		}
-		varargs := as.List.Slice()[x:]
+		varargs := as.List().Slice()[x:]
 
 		vas = ir.Nod(ir.OAS, nil, nil)
-		vas.Left = inlParam(param, vas, inlvars)
+		vas.SetLeft(inlParam(param, vas, inlvars))
 		if len(varargs) == 0 {
-			vas.Right = nodnil()
-			vas.Right.Type = param.Type
+			vas.SetRight(nodnil())
+			vas.Right().SetType(param.Type)
 		} else {
-			vas.Right = ir.Nod(ir.OCOMPLIT, nil, typenod(param.Type))
-			vas.Right.List.Set(varargs)
+			vas.SetRight(ir.Nod(ir.OCOMPLIT, nil, typenod(param.Type)))
+			vas.Right().PtrList().Set(varargs)
 		}
 	}
 
-	if as.Rlist.Len() != 0 {
+	if as.Rlist().Len() != 0 {
 		as = typecheck(as, ctxStmt)
 		ninit.Append(as)
 	}
@@ -1152,10 +1152,10 @@ func mkinlcall(n, fn *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node
 	inlgen++
 
 	parent := -1
-	if b := base.Ctxt.PosTable.Pos(n.Pos).Base(); b != nil {
+	if b := base.Ctxt.PosTable.Pos(n.Pos()).Base(); b != nil {
 		parent = b.InliningIndex()
 	}
-	newIndex := base.Ctxt.InlTree.Add(parent, n.Pos, fn.Sym.Linksym())
+	newIndex := base.Ctxt.InlTree.Add(parent, n.Pos(), fn.Sym().Linksym())
 
 	// Add an inline mark just before the inlined body.
 	// This mark is inline in the code so that it's a reasonable spot
@@ -1163,14 +1163,14 @@ func mkinlcall(n, fn *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node
 	// (in which case it could go at the end of the function instead).
 	// Note issue 28603.
 	inlMark := ir.Nod(ir.OINLMARK, nil, nil)
-	inlMark.Pos = n.Pos.WithIsStmt()
-	inlMark.Xoffset = int64(newIndex)
+	inlMark.SetPos(n.Pos().WithIsStmt())
+	inlMark.SetOffset(int64(newIndex))
 	ninit.Append(inlMark)
 
 	if base.Flag.GenDwarfInl > 0 {
-		if !fn.Sym.Linksym().WasInlined() {
-			base.Ctxt.DwFixups.SetPrecursorFunc(fn.Sym.Linksym(), fn)
-			fn.Sym.Linksym().Set(obj.AttrWasInlined, true)
+		if !fn.Sym().Linksym().WasInlined() {
+			base.Ctxt.DwFixups.SetPrecursorFunc(fn.Sym().Linksym(), fn)
+			fn.Sym().Linksym().Set(obj.AttrWasInlined, true)
 		}
 	}
 
@@ -1183,7 +1183,7 @@ func mkinlcall(n, fn *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node
 		newInlIndex:  newIndex,
 	}
 
-	body := subst.list(ir.AsNodes(fn.Func.Inl.Body))
+	body := subst.list(ir.AsNodes(fn.Func().Inl.Body))
 
 	lab := nodSym(ir.OLABEL, nil, retlabel)
 	body = append(body, lab)
@@ -1192,17 +1192,17 @@ func mkinlcall(n, fn *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node
 
 	if base.Flag.GenDwarfInl > 0 {
 		for _, v := range inlfvars {
-			v.Pos = subst.updatedPos(v.Pos)
+			v.SetPos(subst.updatedPos(v.Pos()))
 		}
 	}
 
 	//dumplist("ninit post", ninit);
 
 	call := ir.Nod(ir.OINLCALL, nil, nil)
-	call.Ninit.Set(ninit.Slice())
-	call.Nbody.Set(body)
-	call.Rlist.Set(retvars)
-	call.Type = n.Type
+	call.PtrInit().Set(ninit.Slice())
+	call.PtrBody().Set(body)
+	call.PtrRlist().Set(retvars)
+	call.SetType(n.Type())
 	call.SetTypecheck(1)
 
 	// transitive inlining
@@ -1211,9 +1211,9 @@ func mkinlcall(n, fn *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node
 	// instead we emit the things that the body needs
 	// and each use must redo the inlining.
 	// luckily these are small.
-	inlnodelist(call.Nbody, maxCost, inlMap)
-	for _, n := range call.Nbody.Slice() {
-		if n.Op == ir.OINLCALL {
+	inlnodelist(call.Body(), maxCost, inlMap)
+	for _, n := range call.Body().Slice() {
+		if n.Op() == ir.OINLCALL {
 			inlconv2stmt(n)
 		}
 	}
@@ -1233,25 +1233,25 @@ func inlvar(var_ *ir.Node) *ir.Node {
 		fmt.Printf("inlvar %+v\n", var_)
 	}
 
-	n := NewName(var_.Sym)
-	n.Type = var_.Type
+	n := NewName(var_.Sym())
+	n.SetType(var_.Type())
 	n.SetClass(ir.PAUTO)
-	n.Name.SetUsed(true)
-	n.Name.Curfn = Curfn // the calling function, not the called one
-	n.Name.SetAddrtaken(var_.Name.Addrtaken())
+	n.Name().SetUsed(true)
+	n.Name().Curfn = Curfn // the calling function, not the called one
+	n.Name().SetAddrtaken(var_.Name().Addrtaken())
 
-	Curfn.Func.Dcl = append(Curfn.Func.Dcl, n)
+	Curfn.Func().Dcl = append(Curfn.Func().Dcl, n)
 	return n
 }
 
 // Synthesize a variable to store the inlined function's results in.
 func retvar(t *types.Field, i int) *ir.Node {
 	n := NewName(lookupN("~R", i))
-	n.Type = t.Type
+	n.SetType(t.Type)
 	n.SetClass(ir.PAUTO)
-	n.Name.SetUsed(true)
-	n.Name.Curfn = Curfn // the calling function, not the called one
-	Curfn.Func.Dcl = append(Curfn.Func.Dcl, n)
+	n.Name().SetUsed(true)
+	n.Name().Curfn = Curfn // the calling function, not the called one
+	Curfn.Func().Dcl = append(Curfn.Func().Dcl, n)
 	return n
 }
 
@@ -1259,11 +1259,11 @@ func retvar(t *types.Field, i int) *ir.Node {
 // when they come from a multiple return call.
 func argvar(t *types.Type, i int) *ir.Node {
 	n := NewName(lookupN("~arg", i))
-	n.Type = t.Elem()
+	n.SetType(t.Elem())
 	n.SetClass(ir.PAUTO)
-	n.Name.SetUsed(true)
-	n.Name.Curfn = Curfn // the calling function, not the called one
-	Curfn.Func.Dcl = append(Curfn.Func.Dcl, n)
+	n.Name().SetUsed(true)
+	n.Name().Curfn = Curfn // the calling function, not the called one
+	Curfn.Func().Dcl = append(Curfn.Func().Dcl, n)
 	return n
 }
 
@@ -1309,7 +1309,7 @@ func (subst *inlsubst) node(n *ir.Node) *ir.Node {
 		return nil
 	}
 
-	switch n.Op {
+	switch n.Op() {
 	case ir.ONAME:
 		if inlvar := subst.inlvars[n]; inlvar != nil { // These will be set during inlnode
 			if base.Flag.LowerM > 2 {
@@ -1330,7 +1330,7 @@ func (subst *inlsubst) node(n *ir.Node) *ir.Node {
 		// If n is a named constant or type, we can continue
 		// using it in the inline copy. Otherwise, make a copy
 		// so we can update the line number.
-		if n.Sym != nil {
+		if n.Sym() != nil {
 			return n
 		}
 
@@ -1339,31 +1339,31 @@ func (subst *inlsubst) node(n *ir.Node) *ir.Node {
 	//		dump("Return before substitution", n);
 	case ir.ORETURN:
 		m := nodSym(ir.OGOTO, nil, subst.retlabel)
-		m.Ninit.Set(subst.list(n.Ninit))
+		m.PtrInit().Set(subst.list(n.Init()))
 
-		if len(subst.retvars) != 0 && n.List.Len() != 0 {
+		if len(subst.retvars) != 0 && n.List().Len() != 0 {
 			as := ir.Nod(ir.OAS2, nil, nil)
 
 			// Make a shallow copy of retvars.
 			// Otherwise OINLCALL.Rlist will be the same list,
 			// and later walk and typecheck may clobber it.
 			for _, n := range subst.retvars {
-				as.List.Append(n)
+				as.PtrList().Append(n)
 			}
-			as.Rlist.Set(subst.list(n.List))
+			as.PtrRlist().Set(subst.list(n.List()))
 
 			if subst.delayretvars {
-				for _, n := range as.List.Slice() {
-					as.Ninit.Append(ir.Nod(ir.ODCL, n, nil))
-					n.Name.Defn = as
+				for _, n := range as.List().Slice() {
+					as.PtrInit().Append(ir.Nod(ir.ODCL, n, nil))
+					n.Name().Defn = as
 				}
 			}
 
 			as = typecheck(as, ctxStmt)
-			m.Ninit.Append(as)
+			m.PtrInit().Append(as)
 		}
 
-		typecheckslice(m.Ninit.Slice(), ctxStmt)
+		typecheckslice(m.Init().Slice(), ctxStmt)
 		m = typecheck(m, ctxStmt)
 
 		//		dump("Return after substitution", m);
@@ -1371,28 +1371,28 @@ func (subst *inlsubst) node(n *ir.Node) *ir.Node {
 
 	case ir.OGOTO, ir.OLABEL:
 		m := ir.Copy(n)
-		m.Pos = subst.updatedPos(m.Pos)
-		m.Ninit.Set(nil)
-		p := fmt.Sprintf("%s·%d", n.Sym.Name, inlgen)
-		m.Sym = lookup(p)
+		m.SetPos(subst.updatedPos(m.Pos()))
+		m.PtrInit().Set(nil)
+		p := fmt.Sprintf("%s·%d", n.Sym().Name, inlgen)
+		m.SetSym(lookup(p))
 
 		return m
 	}
 
 	m := ir.Copy(n)
-	m.Pos = subst.updatedPos(m.Pos)
-	m.Ninit.Set(nil)
+	m.SetPos(subst.updatedPos(m.Pos()))
+	m.PtrInit().Set(nil)
 
-	if n.Op == ir.OCLOSURE {
+	if n.Op() == ir.OCLOSURE {
 		base.Fatalf("cannot inline function containing closure: %+v", n)
 	}
 
-	m.Left = subst.node(n.Left)
-	m.Right = subst.node(n.Right)
-	m.List.Set(subst.list(n.List))
-	m.Rlist.Set(subst.list(n.Rlist))
-	m.Ninit.Set(append(m.Ninit.Slice(), subst.list(n.Ninit)...))
-	m.Nbody.Set(subst.list(n.Nbody))
+	m.SetLeft(subst.node(n.Left()))
+	m.SetRight(subst.node(n.Right()))
+	m.PtrList().Set(subst.list(n.List()))
+	m.PtrRlist().Set(subst.list(n.Rlist()))
+	m.PtrInit().Set(append(m.Init().Slice(), subst.list(n.Init())...))
+	m.PtrBody().Set(subst.list(n.Body()))
 
 	return m
 }
@@ -1426,8 +1426,8 @@ func pruneUnusedAutos(ll []*ir.Node, vis *hairyVisitor) []*ir.Node {
 // concrete-type method calls where applicable.
 func devirtualize(fn *ir.Node) {
 	Curfn = fn
-	ir.InspectList(fn.Nbody, func(n *ir.Node) bool {
-		if n.Op == ir.OCALLINTER {
+	ir.InspectList(fn.Body(), func(n *ir.Node) bool {
+		if n.Op() == ir.OCALLINTER {
 			devirtualizeCall(n)
 		}
 		return true
@@ -1435,38 +1435,38 @@ func devirtualize(fn *ir.Node) {
 }
 
 func devirtualizeCall(call *ir.Node) {
-	recv := staticValue(call.Left.Left)
-	if recv.Op != ir.OCONVIFACE {
+	recv := staticValue(call.Left().Left())
+	if recv.Op() != ir.OCONVIFACE {
 		return
 	}
 
-	typ := recv.Left.Type
+	typ := recv.Left().Type()
 	if typ.IsInterface() {
 		return
 	}
 
-	x := ir.NodAt(call.Left.Pos, ir.ODOTTYPE, call.Left.Left, nil)
-	x.Type = typ
-	x = nodlSym(call.Left.Pos, ir.OXDOT, x, call.Left.Sym)
+	x := ir.NodAt(call.Left().Pos(), ir.ODOTTYPE, call.Left().Left(), nil)
+	x.SetType(typ)
+	x = nodlSym(call.Left().Pos(), ir.OXDOT, x, call.Left().Sym())
 	x = typecheck(x, ctxExpr|ctxCallee)
-	switch x.Op {
+	switch x.Op() {
 	case ir.ODOTMETH:
 		if base.Flag.LowerM != 0 {
-			base.WarnfAt(call.Pos, "devirtualizing %v to %v", call.Left, typ)
+			base.WarnfAt(call.Pos(), "devirtualizing %v to %v", call.Left(), typ)
 		}
-		call.Op = ir.OCALLMETH
-		call.Left = x
+		call.SetOp(ir.OCALLMETH)
+		call.SetLeft(x)
 	case ir.ODOTINTER:
 		// Promoted method from embedded interface-typed field (#42279).
 		if base.Flag.LowerM != 0 {
-			base.WarnfAt(call.Pos, "partially devirtualizing %v to %v", call.Left, typ)
+			base.WarnfAt(call.Pos(), "partially devirtualizing %v to %v", call.Left(), typ)
 		}
-		call.Op = ir.OCALLINTER
-		call.Left = x
+		call.SetOp(ir.OCALLINTER)
+		call.SetLeft(x)
 	default:
 		// TODO(mdempsky): Turn back into Fatalf after more testing.
 		if base.Flag.LowerM != 0 {
-			base.WarnfAt(call.Pos, "failed to devirtualize %v (%v)", x, x.Op)
+			base.WarnfAt(call.Pos(), "failed to devirtualize %v (%v)", x, x.Op())
 		}
 		return
 	}
@@ -1477,12 +1477,12 @@ func devirtualizeCall(call *ir.Node) {
 	// Receiver parameter size may have changed; need to update
 	// call.Type to get correct stack offsets for result
 	// parameters.
-	checkwidth(x.Type)
-	switch ft := x.Type; ft.NumResults() {
+	checkwidth(x.Type())
+	switch ft := x.Type(); ft.NumResults() {
 	case 0:
 	case 1:
-		call.Type = ft.Results().Field(0).Type
+		call.SetType(ft.Results().Field(0).Type)
 	default:
-		call.Type = ft.Results()
+		call.SetType(ft.Results())
 	}
 }
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 24e926602b..a7d605f3ba 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -253,7 +253,7 @@ func Main(archInit func(*Arch)) {
 	timings.Start("fe", "typecheck", "top1")
 	for i := 0; i < len(xtop); i++ {
 		n := xtop[i]
-		if op := n.Op; op != ir.ODCL && op != ir.OAS && op != ir.OAS2 && (op != ir.ODCLTYPE || !n.Left.Name.Param.Alias()) {
+		if op := n.Op(); op != ir.ODCL && op != ir.OAS && op != ir.OAS2 && (op != ir.ODCLTYPE || !n.Left().Name().Param.Alias()) {
 			xtop[i] = typecheck(n, ctxStmt)
 		}
 	}
@@ -265,7 +265,7 @@ func Main(archInit func(*Arch)) {
 	timings.Start("fe", "typecheck", "top2")
 	for i := 0; i < len(xtop); i++ {
 		n := xtop[i]
-		if op := n.Op; op == ir.ODCL || op == ir.OAS || op == ir.OAS2 || op == ir.ODCLTYPE && n.Left.Name.Param.Alias() {
+		if op := n.Op(); op == ir.ODCL || op == ir.OAS || op == ir.OAS2 || op == ir.ODCLTYPE && n.Left().Name().Param.Alias() {
 			xtop[i] = typecheck(n, ctxStmt)
 		}
 	}
@@ -276,14 +276,14 @@ func Main(archInit func(*Arch)) {
 	var fcount int64
 	for i := 0; i < len(xtop); i++ {
 		n := xtop[i]
-		if n.Op == ir.ODCLFUNC {
+		if n.Op() == ir.ODCLFUNC {
 			Curfn = n
 			decldepth = 1
 			errorsBefore := base.Errors()
-			typecheckslice(Curfn.Nbody.Slice(), ctxStmt)
+			typecheckslice(Curfn.Body().Slice(), ctxStmt)
 			checkreturn(Curfn)
 			if base.Errors() > errorsBefore {
-				Curfn.Nbody.Set(nil) // type errors; do not compile
+				Curfn.PtrBody().Set(nil) // type errors; do not compile
 			}
 			// Now that we've checked whether n terminates,
 			// we can eliminate some obviously dead code.
@@ -306,7 +306,7 @@ func Main(archInit func(*Arch)) {
 	// because variables captured by value do not escape.
 	timings.Start("fe", "capturevars")
 	for _, n := range xtop {
-		if n.Op == ir.ODCLFUNC && n.Func.OClosure != nil {
+		if n.Op() == ir.ODCLFUNC && n.Func().OClosure != nil {
 			Curfn = n
 			capturevars(n)
 		}
@@ -321,7 +321,7 @@ func Main(archInit func(*Arch)) {
 		// Typecheck imported function bodies if Debug.l > 1,
 		// otherwise lazily when used or re-exported.
 		for _, n := range importlist {
-			if n.Func.Inl != nil {
+			if n.Func().Inl != nil {
 				typecheckinl(n)
 			}
 		}
@@ -340,7 +340,7 @@ func Main(archInit func(*Arch)) {
 					caninl(n)
 				} else {
 					if base.Flag.LowerM > 1 {
-						fmt.Printf("%v: cannot inline %v: recursive\n", ir.Line(n), n.Func.Nname)
+						fmt.Printf("%v: cannot inline %v: recursive\n", ir.Line(n), n.Func().Nname)
 					}
 				}
 				inlcalls(n)
@@ -349,7 +349,7 @@ func Main(archInit func(*Arch)) {
 	}
 
 	for _, n := range xtop {
-		if n.Op == ir.ODCLFUNC {
+		if n.Op() == ir.ODCLFUNC {
 			devirtualize(n)
 		}
 	}
@@ -379,7 +379,7 @@ func Main(archInit func(*Arch)) {
 	// before walk reaches a call of a closure.
 	timings.Start("fe", "xclosures")
 	for _, n := range xtop {
-		if n.Op == ir.ODCLFUNC && n.Func.OClosure != nil {
+		if n.Op() == ir.ODCLFUNC && n.Func().OClosure != nil {
 			Curfn = n
 			transformclosure(n)
 		}
@@ -402,7 +402,7 @@ func Main(archInit func(*Arch)) {
 	fcount = 0
 	for i := 0; i < len(xtop); i++ {
 		n := xtop[i]
-		if n.Op == ir.ODCLFUNC {
+		if n.Op() == ir.ODCLFUNC {
 			funccompile(n)
 			fcount++
 		}
@@ -430,7 +430,7 @@ func Main(archInit func(*Arch)) {
 	// Phase 9: Check external declarations.
 	timings.Start("be", "externaldcls")
 	for i, n := range externdcl {
-		if n.Op == ir.ONAME {
+		if n.Op() == ir.ONAME {
 			externdcl[i] = typecheck(externdcl[i], ctxExpr)
 		}
 	}
@@ -484,7 +484,7 @@ func Main(archInit func(*Arch)) {
 func numNonClosures(list []*ir.Node) int {
 	count := 0
 	for _, n := range list {
-		if n.Func.OClosure == nil {
+		if n.Func().OClosure == nil {
 			count++
 		}
 	}
@@ -949,14 +949,14 @@ func clearImports() {
 		if n == nil {
 			continue
 		}
-		if n.Op == ir.OPACK {
+		if n.Op() == ir.OPACK {
 			// throw away top-level package name left over
 			// from previous file.
 			// leave s->block set to cause redeclaration
 			// errors if a conflicting top-level name is
 			// introduced by a different file.
-			if !n.Name.Used() && base.SyntaxErrors() == 0 {
-				unused = append(unused, importedPkg{n.Pos, n.Name.Pkg.Path, s.Name})
+			if !n.Name().Used() && base.SyntaxErrors() == 0 {
+				unused = append(unused, importedPkg{n.Pos(), n.Name().Pkg.Path, s.Name})
 			}
 			s.Def = nil
 			continue
@@ -964,9 +964,9 @@ func clearImports() {
 		if IsAlias(s) {
 			// throw away top-level name left over
 			// from previous import . "x"
-			if n.Name != nil && n.Name.Pack != nil && !n.Name.Pack.Name.Used() && base.SyntaxErrors() == 0 {
-				unused = append(unused, importedPkg{n.Name.Pack.Pos, n.Name.Pack.Name.Pkg.Path, ""})
-				n.Name.Pack.Name.SetUsed(true)
+			if n.Name() != nil && n.Name().Pack != nil && !n.Name().Pack.Name().Used() && base.SyntaxErrors() == 0 {
+				unused = append(unused, importedPkg{n.Name().Pack.Pos(), n.Name().Pack.Name().Pkg.Path, ""})
+				n.Name().Pack.Name().SetUsed(true)
 			}
 			s.Def = nil
 			continue
@@ -980,7 +980,7 @@ func clearImports() {
 }
 
 func IsAlias(sym *types.Sym) bool {
-	return sym.Def != nil && ir.AsNode(sym.Def).Sym != sym
+	return sym.Def != nil && ir.AsNode(sym.Def).Sym() != sym
 }
 
 // recordFlags records the specified command-line flags to be placed
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index eeed3740f0..98819fadde 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -162,10 +162,10 @@ func (p *noder) funcBody(fn *ir.Node, block *syntax.BlockStmt) {
 		if body == nil {
 			body = []*ir.Node{ir.Nod(ir.OEMPTY, nil, nil)}
 		}
-		fn.Nbody.Set(body)
+		fn.PtrBody().Set(body)
 
 		base.Pos = p.makeXPos(block.Rbrace)
-		fn.Func.Endlineno = base.Pos
+		fn.Func().Endlineno = base.Pos
 	}
 
 	funcbody()
@@ -176,9 +176,9 @@ func (p *noder) openScope(pos syntax.Pos) {
 	types.Markdcl()
 
 	if trackScopes {
-		Curfn.Func.Parents = append(Curfn.Func.Parents, p.scope)
-		p.scopeVars = append(p.scopeVars, len(Curfn.Func.Dcl))
-		p.scope = ir.ScopeID(len(Curfn.Func.Parents))
+		Curfn.Func().Parents = append(Curfn.Func().Parents, p.scope)
+		p.scopeVars = append(p.scopeVars, len(Curfn.Func().Dcl))
+		p.scope = ir.ScopeID(len(Curfn.Func().Parents))
 
 		p.markScope(pos)
 	}
@@ -191,29 +191,29 @@ func (p *noder) closeScope(pos syntax.Pos) {
 	if trackScopes {
 		scopeVars := p.scopeVars[len(p.scopeVars)-1]
 		p.scopeVars = p.scopeVars[:len(p.scopeVars)-1]
-		if scopeVars == len(Curfn.Func.Dcl) {
+		if scopeVars == len(Curfn.Func().Dcl) {
 			// no variables were declared in this scope, so we can retract it.
 
-			if int(p.scope) != len(Curfn.Func.Parents) {
+			if int(p.scope) != len(Curfn.Func().Parents) {
 				base.Fatalf("scope tracking inconsistency, no variables declared but scopes were not retracted")
 			}
 
-			p.scope = Curfn.Func.Parents[p.scope-1]
-			Curfn.Func.Parents = Curfn.Func.Parents[:len(Curfn.Func.Parents)-1]
+			p.scope = Curfn.Func().Parents[p.scope-1]
+			Curfn.Func().Parents = Curfn.Func().Parents[:len(Curfn.Func().Parents)-1]
 
-			nmarks := len(Curfn.Func.Marks)
-			Curfn.Func.Marks[nmarks-1].Scope = p.scope
+			nmarks := len(Curfn.Func().Marks)
+			Curfn.Func().Marks[nmarks-1].Scope = p.scope
 			prevScope := ir.ScopeID(0)
 			if nmarks >= 2 {
-				prevScope = Curfn.Func.Marks[nmarks-2].Scope
+				prevScope = Curfn.Func().Marks[nmarks-2].Scope
 			}
-			if Curfn.Func.Marks[nmarks-1].Scope == prevScope {
-				Curfn.Func.Marks = Curfn.Func.Marks[:nmarks-1]
+			if Curfn.Func().Marks[nmarks-1].Scope == prevScope {
+				Curfn.Func().Marks = Curfn.Func().Marks[:nmarks-1]
 			}
 			return
 		}
 
-		p.scope = Curfn.Func.Parents[p.scope-1]
+		p.scope = Curfn.Func().Parents[p.scope-1]
 
 		p.markScope(pos)
 	}
@@ -221,10 +221,10 @@ func (p *noder) closeScope(pos syntax.Pos) {
 
 func (p *noder) markScope(pos syntax.Pos) {
 	xpos := p.makeXPos(pos)
-	if i := len(Curfn.Func.Marks); i > 0 && Curfn.Func.Marks[i-1].Pos == xpos {
-		Curfn.Func.Marks[i-1].Scope = p.scope
+	if i := len(Curfn.Func().Marks); i > 0 && Curfn.Func().Marks[i-1].Pos == xpos {
+		Curfn.Func().Marks[i-1].Scope = p.scope
 	} else {
-		Curfn.Func.Marks = append(Curfn.Func.Marks, ir.Mark{Pos: xpos, Scope: p.scope})
+		Curfn.Func().Marks = append(Curfn.Func().Marks, ir.Mark{Pos: xpos, Scope: p.scope})
 	}
 }
 
@@ -357,24 +357,24 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
 	}
 
 	pack := p.nod(imp, ir.OPACK, nil, nil)
-	pack.Sym = my
-	pack.Name.Pkg = ipkg
+	pack.SetSym(my)
+	pack.Name().Pkg = ipkg
 
 	switch my.Name {
 	case ".":
 		importdot(ipkg, pack)
 		return
 	case "init":
-		base.ErrorfAt(pack.Pos, "cannot import package as init - init must be a func")
+		base.ErrorfAt(pack.Pos(), "cannot import package as init - init must be a func")
 		return
 	case "_":
 		return
 	}
 	if my.Def != nil {
-		redeclare(pack.Pos, my, "as imported package name")
+		redeclare(pack.Pos(), my, "as imported package name")
 	}
 	my.Def = ir.AsTypesNode(pack)
-	my.Lastlineno = pack.Pos
+	my.Lastlineno = pack.Pos()
 	my.Block = 1 // at top level
 }
 
@@ -452,14 +452,14 @@ func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []*ir.Node {
 		}
 		v := values[i]
 		if decl.Values == nil {
-			v = treecopy(v, n.Pos)
+			v = treecopy(v, n.Pos())
 		}
 
-		n.Op = ir.OLITERAL
+		n.SetOp(ir.OLITERAL)
 		declare(n, dclcontext)
 
-		n.Name.Param.Ntype = typ
-		n.Name.Defn = v
+		n.Name().Param.Ntype = typ
+		n.Name().Defn = v
 		n.SetIota(cs.iota)
 
 		nn = append(nn, p.nod(decl, ir.ODCLCONST, n, nil))
@@ -476,13 +476,13 @@ func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []*ir.Node {
 
 func (p *noder) typeDecl(decl *syntax.TypeDecl) *ir.Node {
 	n := p.declName(decl.Name)
-	n.Op = ir.OTYPE
+	n.SetOp(ir.OTYPE)
 	declare(n, dclcontext)
 
 	// decl.Type may be nil but in that case we got a syntax error during parsing
 	typ := p.typeExprOrNil(decl.Type)
 
-	param := n.Name.Param
+	param := n.Name().Param
 	param.Ntype = typ
 	param.SetAlias(decl.Alias)
 	if pragma, ok := decl.Pragma.(*Pragma); ok {
@@ -495,7 +495,7 @@ func (p *noder) typeDecl(decl *syntax.TypeDecl) *ir.Node {
 
 	nod := p.nod(decl, ir.ODCLTYPE, n, nil)
 	if param.Alias() && !langSupported(1, 9, ir.LocalPkg) {
-		base.ErrorfAt(nod.Pos, "type aliases only supported as of -lang=go1.9")
+		base.ErrorfAt(nod.Pos(), "type aliases only supported as of -lang=go1.9")
 	}
 	return nod
 }
@@ -510,7 +510,7 @@ func (p *noder) declNames(names []*syntax.Name) []*ir.Node {
 
 func (p *noder) declName(name *syntax.Name) *ir.Node {
 	n := dclname(p.name(name))
-	n.Pos = p.pos(name)
+	n.SetPos(p.pos(name))
 	return n
 }
 
@@ -522,43 +522,43 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) *ir.Node {
 	if fun.Recv == nil {
 		if name.Name == "init" {
 			name = renameinit()
-			if t.List.Len() > 0 || t.Rlist.Len() > 0 {
-				base.ErrorfAt(f.Pos, "func init must have no arguments and no return values")
+			if t.List().Len() > 0 || t.Rlist().Len() > 0 {
+				base.ErrorfAt(f.Pos(), "func init must have no arguments and no return values")
 			}
 		}
 
 		if ir.LocalPkg.Name == "main" && name.Name == "main" {
-			if t.List.Len() > 0 || t.Rlist.Len() > 0 {
-				base.ErrorfAt(f.Pos, "func main must have no arguments and no return values")
+			if t.List().Len() > 0 || t.Rlist().Len() > 0 {
+				base.ErrorfAt(f.Pos(), "func main must have no arguments and no return values")
 			}
 		}
 	} else {
-		f.Func.Shortname = name
-		name = ir.BlankNode.Sym // filled in by typecheckfunc
+		f.Func().Shortname = name
+		name = ir.BlankNode.Sym() // filled in by typecheckfunc
 	}
 
-	f.Func.Nname = newfuncnamel(p.pos(fun.Name), name, f.Func)
-	f.Func.Nname.Name.Defn = f
-	f.Func.Nname.Name.Param.Ntype = t
+	f.Func().Nname = newfuncnamel(p.pos(fun.Name), name, f.Func())
+	f.Func().Nname.Name().Defn = f
+	f.Func().Nname.Name().Param.Ntype = t
 
 	if pragma, ok := fun.Pragma.(*Pragma); ok {
-		f.Func.Pragma = pragma.Flag & FuncPragmas
+		f.Func().Pragma = pragma.Flag & FuncPragmas
 		if pragma.Flag&ir.Systemstack != 0 && pragma.Flag&ir.Nosplit != 0 {
-			base.ErrorfAt(f.Pos, "go:nosplit and go:systemstack cannot be combined")
+			base.ErrorfAt(f.Pos(), "go:nosplit and go:systemstack cannot be combined")
 		}
 		pragma.Flag &^= FuncPragmas
 		p.checkUnused(pragma)
 	}
 
 	if fun.Recv == nil {
-		declare(f.Func.Nname, ir.PFUNC)
+		declare(f.Func().Nname, ir.PFUNC)
 	}
 
 	p.funcBody(f, fun.Body)
 
 	if fun.Body != nil {
-		if f.Func.Pragma&ir.Noescape != 0 {
-			base.ErrorfAt(f.Pos, "can only use //go:noescape with external func implementations")
+		if f.Func().Pragma&ir.Noescape != 0 {
+			base.ErrorfAt(f.Pos(), "can only use //go:noescape with external func implementations")
 		}
 	} else {
 		if base.Flag.Complete || strings.HasPrefix(ir.FuncName(f), "init.") {
@@ -572,7 +572,7 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) *ir.Node {
 				}
 			}
 			if !isLinknamed {
-				base.ErrorfAt(f.Pos, "missing function body")
+				base.ErrorfAt(f.Pos(), "missing function body")
 			}
 		}
 	}
@@ -583,10 +583,10 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) *ir.Node {
 func (p *noder) signature(recv *syntax.Field, typ *syntax.FuncType) *ir.Node {
 	n := p.nod(typ, ir.OTFUNC, nil, nil)
 	if recv != nil {
-		n.Left = p.param(recv, false, false)
+		n.SetLeft(p.param(recv, false, false))
 	}
-	n.List.Set(p.params(typ.ParamList, true))
-	n.Rlist.Set(p.params(typ.ResultList, false))
+	n.PtrList().Set(p.params(typ.ParamList, true))
+	n.PtrRlist().Set(p.params(typ.ResultList, false))
 	return n
 }
 
@@ -609,7 +609,7 @@ func (p *noder) param(param *syntax.Field, dddOk, final bool) *ir.Node {
 	n := p.nodSym(param, ir.ODCLFIELD, typ, name)
 
 	// rewrite ...T parameter
-	if typ.Op == ir.ODDD {
+	if typ.Op() == ir.ODDD {
 		if !dddOk {
 			// We mark these as syntax errors to get automatic elimination
 			// of multiple such errors per line (see ErrorfAt in subr.go).
@@ -621,12 +621,12 @@ func (p *noder) param(param *syntax.Field, dddOk, final bool) *ir.Node {
 				p.errorAt(param.Name.Pos(), "syntax error: cannot use ... with non-final parameter %s", param.Name.Value)
 			}
 		}
-		typ.Op = ir.OTARRAY
-		typ.Right = typ.Left
-		typ.Left = nil
+		typ.SetOp(ir.OTARRAY)
+		typ.SetRight(typ.Left())
+		typ.SetLeft(nil)
 		n.SetIsDDD(true)
-		if n.Left != nil {
-			n.Left.SetIsDDD(true)
+		if n.Left() != nil {
+			n.Left().SetIsDDD(true)
 		}
 	}
 
@@ -658,20 +658,20 @@ func (p *noder) expr(expr syntax.Expr) *ir.Node {
 	case *syntax.BasicLit:
 		n := ir.NewLiteral(p.basicLit(expr))
 		if expr.Kind == syntax.RuneLit {
-			n.Type = types.UntypedRune
+			n.SetType(types.UntypedRune)
 		}
 		n.SetDiag(expr.Bad) // avoid follow-on errors if there was a syntax error
 		return n
 	case *syntax.CompositeLit:
 		n := p.nod(expr, ir.OCOMPLIT, nil, nil)
 		if expr.Type != nil {
-			n.Right = p.expr(expr.Type)
+			n.SetRight(p.expr(expr.Type))
 		}
 		l := p.exprs(expr.ElemList)
 		for i, e := range l {
 			l[i] = p.wrapname(expr.ElemList[i], e)
 		}
-		n.List.Set(l)
+		n.PtrList().Set(l)
 		base.Pos = p.makeXPos(expr.Rbrace)
 		return n
 	case *syntax.KeyValueExpr:
@@ -684,12 +684,12 @@ func (p *noder) expr(expr syntax.Expr) *ir.Node {
 	case *syntax.SelectorExpr:
 		// parser.new_dotname
 		obj := p.expr(expr.X)
-		if obj.Op == ir.OPACK {
-			obj.Name.SetUsed(true)
-			return importName(obj.Name.Pkg.Lookup(expr.Sel.Value))
+		if obj.Op() == ir.OPACK {
+			obj.Name().SetUsed(true)
+			return importName(obj.Name().Pkg.Lookup(expr.Sel.Value))
 		}
 		n := nodSym(ir.OXDOT, obj, p.name(expr.Sel))
-		n.Pos = p.pos(expr) // lineno may have been changed by p.expr(expr.X)
+		n.SetPos(p.pos(expr)) // lineno may have been changed by p.expr(expr.X)
 		return n
 	case *syntax.IndexExpr:
 		return p.nod(expr, ir.OINDEX, p.expr(expr.X), p.expr(expr.Index))
@@ -720,7 +720,7 @@ func (p *noder) expr(expr syntax.Expr) *ir.Node {
 		return p.nod(expr, p.binOp(expr.Op), x, p.expr(expr.Y))
 	case *syntax.CallExpr:
 		n := p.nod(expr, ir.OCALL, p.expr(expr.Fun), nil)
-		n.List.Set(p.exprs(expr.ArgList))
+		n.PtrList().Set(p.exprs(expr.ArgList))
 		n.SetIsDDD(expr.HasDots)
 		return n
 
@@ -752,9 +752,9 @@ func (p *noder) expr(expr syntax.Expr) *ir.Node {
 	case *syntax.TypeSwitchGuard:
 		n := p.nod(expr, ir.OTYPESW, nil, p.expr(expr.X))
 		if expr.Lhs != nil {
-			n.Left = p.declName(expr.Lhs)
-			if ir.IsBlank(n.Left) {
-				base.Errorf("invalid variable name %v in type switch", n.Left)
+			n.SetLeft(p.declName(expr.Lhs))
+			if ir.IsBlank(n.Left()) {
+				base.Errorf("invalid variable name %v in type switch", n.Left())
 			}
 		}
 		return n
@@ -804,7 +804,7 @@ func (p *noder) sum(x syntax.Expr) *ir.Node {
 	chunks := make([]string, 0, 1)
 
 	n := p.expr(x)
-	if ir.IsConst(n, constant.String) && n.Sym == nil {
+	if ir.IsConst(n, constant.String) && n.Sym() == nil {
 		nstr = n
 		chunks = append(chunks, nstr.StringVal())
 	}
@@ -813,7 +813,7 @@ func (p *noder) sum(x syntax.Expr) *ir.Node {
 		add := adds[i]
 
 		r := p.expr(add.Y)
-		if ir.IsConst(r, constant.String) && r.Sym == nil {
+		if ir.IsConst(r, constant.String) && r.Sym() == nil {
 			if nstr != nil {
 				// Collapse r into nstr instead of adding to n.
 				chunks = append(chunks, r.StringVal())
@@ -880,7 +880,7 @@ func (p *noder) structType(expr *syntax.StructType) *ir.Node {
 
 	p.setlineno(expr)
 	n := p.nod(expr, ir.OTSTRUCT, nil, nil)
-	n.List.Set(l)
+	n.PtrList().Set(l)
 	return n
 }
 
@@ -894,7 +894,7 @@ func (p *noder) interfaceType(expr *syntax.InterfaceType) *ir.Node {
 		} else {
 			mname := p.name(method.Name)
 			sig := p.typeExpr(method.Type)
-			sig.Left = fakeRecv()
+			sig.SetLeft(fakeRecv())
 			n = p.nodSym(method, ir.ODCLFIELD, sig, mname)
 			ifacedcl(n)
 		}
@@ -902,7 +902,7 @@ func (p *noder) interfaceType(expr *syntax.InterfaceType) *ir.Node {
 	}
 
 	n := p.nod(expr, ir.OTINTER, nil, nil)
-	n.List.Set(l)
+	n.PtrList().Set(l)
 	return n
 }
 
@@ -910,8 +910,8 @@ func (p *noder) packname(expr syntax.Expr) *types.Sym {
 	switch expr := expr.(type) {
 	case *syntax.Name:
 		name := p.name(expr)
-		if n := oldname(name); n.Name != nil && n.Name.Pack != nil {
-			n.Name.Pack.Name.SetUsed(true)
+		if n := oldname(name); n.Name() != nil && n.Name().Pack != nil {
+			n.Name().Pack.Name().SetUsed(true)
 		}
 		return name
 	case *syntax.SelectorExpr:
@@ -922,12 +922,12 @@ func (p *noder) packname(expr syntax.Expr) *types.Sym {
 			return name
 		}
 		var pkg *types.Pkg
-		if def.Op != ir.OPACK {
+		if def.Op() != ir.OPACK {
 			base.Errorf("%v is not a package", name)
 			pkg = ir.LocalPkg
 		} else {
-			def.Name.SetUsed(true)
-			pkg = def.Name.Pkg
+			def.Name().SetUsed(true)
+			pkg = def.Name().Pkg
 		}
 		return pkg.Lookup(expr.Sel.Value)
 	}
@@ -948,7 +948,7 @@ func (p *noder) embedded(typ syntax.Expr) *ir.Node {
 	n.SetEmbedded(true)
 
 	if isStar {
-		n.Left = p.nod(op, ir.ODEREF, n.Left, nil)
+		n.SetLeft(p.nod(op, ir.ODEREF, n.Left(), nil))
 	}
 	return n
 }
@@ -962,8 +962,8 @@ func (p *noder) stmtsFall(stmts []syntax.Stmt, fallOK bool) []*ir.Node {
 	for i, stmt := range stmts {
 		s := p.stmtFall(stmt, fallOK && i+1 == len(stmts))
 		if s == nil {
-		} else if s.Op == ir.OBLOCK && s.Ninit.Len() == 0 {
-			nodes = append(nodes, s.List.Slice()...)
+		} else if s.Op() == ir.OBLOCK && s.Init().Len() == 0 {
+			nodes = append(nodes, s.List().Slice()...)
 		} else {
 			nodes = append(nodes, s)
 		}
@@ -1010,12 +1010,12 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) *ir.Node {
 
 		if len(lhs) == 1 && len(rhs) == 1 {
 			// common case
-			n.Left = lhs[0]
-			n.Right = rhs[0]
+			n.SetLeft(lhs[0])
+			n.SetRight(rhs[0])
 		} else {
-			n.Op = ir.OAS2
-			n.List.Set(lhs)
-			n.Rlist.Set(rhs)
+			n.SetOp(ir.OAS2)
+			n.PtrList().Set(lhs)
+			n.PtrRlist().Set(rhs)
 		}
 		return n
 
@@ -1038,7 +1038,7 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) *ir.Node {
 		}
 		n := p.nod(stmt, op, nil, nil)
 		if stmt.Label != nil {
-			n.Sym = p.name(stmt.Label)
+			n.SetSym(p.name(stmt.Label))
 		}
 		return n
 	case *syntax.CallStmt:
@@ -1058,17 +1058,17 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) *ir.Node {
 			results = p.exprList(stmt.Results)
 		}
 		n := p.nod(stmt, ir.ORETURN, nil, nil)
-		n.List.Set(results)
-		if n.List.Len() == 0 && Curfn != nil {
-			for _, ln := range Curfn.Func.Dcl {
+		n.PtrList().Set(results)
+		if n.List().Len() == 0 && Curfn != nil {
+			for _, ln := range Curfn.Func().Dcl {
 				if ln.Class() == ir.PPARAM {
 					continue
 				}
 				if ln.Class() != ir.PPARAMOUT {
 					break
 				}
-				if ir.AsNode(ln.Sym.Def) != ln {
-					base.Errorf("%s is shadowed during return", ln.Sym.Name)
+				if ir.AsNode(ln.Sym().Def) != ln {
+					base.Errorf("%s is shadowed during return", ln.Sym().Name)
 				}
 			}
 		}
@@ -1134,13 +1134,13 @@ func (p *noder) assignList(expr syntax.Expr, defn *ir.Node, colas bool) []*ir.No
 		newOrErr = true
 		n := NewName(sym)
 		declare(n, dclcontext)
-		n.Name.Defn = defn
-		defn.Ninit.Append(ir.Nod(ir.ODCL, n, nil))
+		n.Name().Defn = defn
+		defn.PtrInit().Append(ir.Nod(ir.ODCL, n, nil))
 		res[i] = n
 	}
 
 	if !newOrErr {
-		base.ErrorfAt(defn.Pos, "no new variables on left side of :=")
+		base.ErrorfAt(defn.Pos(), "no new variables on left side of :=")
 	}
 	return res
 }
@@ -1156,18 +1156,18 @@ func (p *noder) ifStmt(stmt *syntax.IfStmt) *ir.Node {
 	p.openScope(stmt.Pos())
 	n := p.nod(stmt, ir.OIF, nil, nil)
 	if stmt.Init != nil {
-		n.Ninit.Set1(p.stmt(stmt.Init))
+		n.PtrInit().Set1(p.stmt(stmt.Init))
 	}
 	if stmt.Cond != nil {
-		n.Left = p.expr(stmt.Cond)
+		n.SetLeft(p.expr(stmt.Cond))
 	}
-	n.Nbody.Set(p.blockStmt(stmt.Then))
+	n.PtrBody().Set(p.blockStmt(stmt.Then))
 	if stmt.Else != nil {
 		e := p.stmt(stmt.Else)
-		if e.Op == ir.OBLOCK && e.Ninit.Len() == 0 {
-			n.Rlist.Set(e.List.Slice())
+		if e.Op() == ir.OBLOCK && e.Init().Len() == 0 {
+			n.PtrRlist().Set(e.List().Slice())
 		} else {
-			n.Rlist.Set1(e)
+			n.PtrRlist().Set1(e)
 		}
 	}
 	p.closeAnotherScope()
@@ -1184,21 +1184,21 @@ func (p *noder) forStmt(stmt *syntax.ForStmt) *ir.Node {
 
 		n = p.nod(r, ir.ORANGE, nil, p.expr(r.X))
 		if r.Lhs != nil {
-			n.List.Set(p.assignList(r.Lhs, n, r.Def))
+			n.PtrList().Set(p.assignList(r.Lhs, n, r.Def))
 		}
 	} else {
 		n = p.nod(stmt, ir.OFOR, nil, nil)
 		if stmt.Init != nil {
-			n.Ninit.Set1(p.stmt(stmt.Init))
+			n.PtrInit().Set1(p.stmt(stmt.Init))
 		}
 		if stmt.Cond != nil {
-			n.Left = p.expr(stmt.Cond)
+			n.SetLeft(p.expr(stmt.Cond))
 		}
 		if stmt.Post != nil {
-			n.Right = p.stmt(stmt.Post)
+			n.SetRight(p.stmt(stmt.Post))
 		}
 	}
-	n.Nbody.Set(p.blockStmt(stmt.Body))
+	n.PtrBody().Set(p.blockStmt(stmt.Body))
 	p.closeAnotherScope()
 	return n
 }
@@ -1207,17 +1207,17 @@ func (p *noder) switchStmt(stmt *syntax.SwitchStmt) *ir.Node {
 	p.openScope(stmt.Pos())
 	n := p.nod(stmt, ir.OSWITCH, nil, nil)
 	if stmt.Init != nil {
-		n.Ninit.Set1(p.stmt(stmt.Init))
+		n.PtrInit().Set1(p.stmt(stmt.Init))
 	}
 	if stmt.Tag != nil {
-		n.Left = p.expr(stmt.Tag)
+		n.SetLeft(p.expr(stmt.Tag))
 	}
 
-	tswitch := n.Left
-	if tswitch != nil && tswitch.Op != ir.OTYPESW {
+	tswitch := n.Left()
+	if tswitch != nil && tswitch.Op() != ir.OTYPESW {
 		tswitch = nil
 	}
-	n.List.Set(p.caseClauses(stmt.Body, tswitch, stmt.Rbrace))
+	n.PtrList().Set(p.caseClauses(stmt.Body, tswitch, stmt.Rbrace))
 
 	p.closeScope(stmt.Rbrace)
 	return n
@@ -1234,14 +1234,14 @@ func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *ir.Node, rbra
 
 		n := p.nod(clause, ir.OCASE, nil, nil)
 		if clause.Cases != nil {
-			n.List.Set(p.exprList(clause.Cases))
+			n.PtrList().Set(p.exprList(clause.Cases))
 		}
-		if tswitch != nil && tswitch.Left != nil {
-			nn := NewName(tswitch.Left.Sym)
+		if tswitch != nil && tswitch.Left() != nil {
+			nn := NewName(tswitch.Left().Sym())
 			declare(nn, dclcontext)
-			n.Rlist.Set1(nn)
+			n.PtrRlist().Set1(nn)
 			// keep track of the instances for reporting unused
-			nn.Name.Defn = tswitch
+			nn.Name().Defn = tswitch
 		}
 
 		// Trim trailing empty statements. We omit them from
@@ -1255,8 +1255,8 @@ func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *ir.Node, rbra
 			body = body[:len(body)-1]
 		}
 
-		n.Nbody.Set(p.stmtsFall(body, true))
-		if l := n.Nbody.Len(); l > 0 && n.Nbody.Index(l-1).Op == ir.OFALL {
+		n.PtrBody().Set(p.stmtsFall(body, true))
+		if l := n.Body().Len(); l > 0 && n.Body().Index(l-1).Op() == ir.OFALL {
 			if tswitch != nil {
 				base.Errorf("cannot fallthrough in type switch")
 			}
@@ -1275,7 +1275,7 @@ func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *ir.Node, rbra
 
 func (p *noder) selectStmt(stmt *syntax.SelectStmt) *ir.Node {
 	n := p.nod(stmt, ir.OSELECT, nil, nil)
-	n.List.Set(p.commClauses(stmt.Body, stmt.Rbrace))
+	n.PtrList().Set(p.commClauses(stmt.Body, stmt.Rbrace))
 	return n
 }
 
@@ -1290,9 +1290,9 @@ func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []*
 
 		n := p.nod(clause, ir.OCASE, nil, nil)
 		if clause.Comm != nil {
-			n.List.Set1(p.stmt(clause.Comm))
+			n.PtrList().Set1(p.stmt(clause.Comm))
 		}
-		n.Nbody.Set(p.stmts(clause.Body))
+		n.PtrBody().Set(p.stmts(clause.Body))
 		nodes = append(nodes, n)
 	}
 	if len(clauses) > 0 {
@@ -1309,11 +1309,11 @@ func (p *noder) labeledStmt(label *syntax.LabeledStmt, fallOK bool) *ir.Node {
 		ls = p.stmtFall(label.Stmt, fallOK)
 	}
 
-	lhs.Name.Defn = ls
+	lhs.Name().Defn = ls
 	l := []*ir.Node{lhs}
 	if ls != nil {
-		if ls.Op == ir.OBLOCK && ls.Ninit.Len() == 0 {
-			l = append(l, ls.List.Slice()...)
+		if ls.Op() == ir.OBLOCK && ls.Init().Len() == 0 {
+			l = append(l, ls.List().Slice()...)
 		} else {
 			l = append(l, ls)
 		}
@@ -1451,9 +1451,9 @@ func (p *noder) mkname(name *syntax.Name) *ir.Node {
 func (p *noder) wrapname(n syntax.Node, x *ir.Node) *ir.Node {
 	// These nodes do not carry line numbers.
 	// Introduce a wrapper node to give them the correct line.
-	switch x.Op {
+	switch x.Op() {
 	case ir.OTYPE, ir.OLITERAL:
-		if x.Sym == nil {
+		if x.Sym() == nil {
 			break
 		}
 		fallthrough
@@ -1470,7 +1470,7 @@ func (p *noder) nod(orig syntax.Node, op ir.Op, left, right *ir.Node) *ir.Node {
 
 func (p *noder) nodSym(orig syntax.Node, op ir.Op, left *ir.Node, sym *types.Sym) *ir.Node {
 	n := nodSym(op, left, sym)
-	n.Pos = p.pos(orig)
+	n.SetPos(p.pos(orig))
 	return n
 }
 
@@ -1670,8 +1670,8 @@ func safeArg(name string) bool {
 
 func mkname(sym *types.Sym) *ir.Node {
 	n := oldname(sym)
-	if n.Name != nil && n.Name.Pack != nil {
-		n.Name.Pack.Name.SetUsed(true)
+	if n.Name() != nil && n.Name().Pack != nil {
+		n.Name().Pack.Name().SetUsed(true)
 	}
 	return n
 }
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 2961dbf636..9f0cefbd1c 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -142,7 +142,7 @@ func dumpdata() {
 	for {
 		for i := xtops; i < len(xtop); i++ {
 			n := xtop[i]
-			if n.Op == ir.ODCLFUNC {
+			if n.Op() == ir.ODCLFUNC {
 				funccompile(n)
 			}
 		}
@@ -204,12 +204,12 @@ func addptabs() {
 		return
 	}
 	for _, exportn := range exportlist {
-		s := exportn.Sym
+		s := exportn.Sym()
 		n := ir.AsNode(s.Def)
 		if n == nil {
 			continue
 		}
-		if n.Op != ir.ONAME {
+		if n.Op() != ir.ONAME {
 			continue
 		}
 		if !types.IsExported(s.Name) {
@@ -218,37 +218,37 @@ func addptabs() {
 		if s.Pkg.Name != "main" {
 			continue
 		}
-		if n.Type.Etype == types.TFUNC && n.Class() == ir.PFUNC {
+		if n.Type().Etype == types.TFUNC && n.Class() == ir.PFUNC {
 			// function
-			ptabs = append(ptabs, ptabEntry{s: s, t: ir.AsNode(s.Def).Type})
+			ptabs = append(ptabs, ptabEntry{s: s, t: ir.AsNode(s.Def).Type()})
 		} else {
 			// variable
-			ptabs = append(ptabs, ptabEntry{s: s, t: types.NewPtr(ir.AsNode(s.Def).Type)})
+			ptabs = append(ptabs, ptabEntry{s: s, t: types.NewPtr(ir.AsNode(s.Def).Type())})
 		}
 	}
 }
 
 func dumpGlobal(n *ir.Node) {
-	if n.Type == nil {
+	if n.Type() == nil {
 		base.Fatalf("external %v nil type\n", n)
 	}
 	if n.Class() == ir.PFUNC {
 		return
 	}
-	if n.Sym.Pkg != ir.LocalPkg {
+	if n.Sym().Pkg != ir.LocalPkg {
 		return
 	}
-	dowidth(n.Type)
+	dowidth(n.Type())
 	ggloblnod(n)
 }
 
 func dumpGlobalConst(n *ir.Node) {
 	// only export typed constants
-	t := n.Type
+	t := n.Type()
 	if t == nil {
 		return
 	}
-	if n.Sym.Pkg != ir.LocalPkg {
+	if n.Sym().Pkg != ir.LocalPkg {
 		return
 	}
 	// only export integer constants for now
@@ -263,13 +263,13 @@ func dumpGlobalConst(n *ir.Node) {
 			return
 		}
 	}
-	base.Ctxt.DwarfIntConst(base.Ctxt.Pkgpath, n.Sym.Name, typesymname(t), ir.Int64Val(t, v))
+	base.Ctxt.DwarfIntConst(base.Ctxt.Pkgpath, n.Sym().Name, typesymname(t), ir.Int64Val(t, v))
 }
 
 func dumpglobls() {
 	// add globals
 	for _, n := range externdcl {
-		switch n.Op {
+		switch n.Op() {
 		case ir.ONAME:
 			dumpGlobal(n)
 		case ir.OLITERAL:
@@ -414,7 +414,7 @@ func fileStringSym(pos src.XPos, file string, readonly bool, hash []byte) (*obj.
 		if readonly {
 			sym = stringsym(pos, string(data))
 		} else {
-			sym = slicedata(pos, string(data)).Sym.Linksym()
+			sym = slicedata(pos, string(data)).Sym().Linksym()
 		}
 		if len(hash) > 0 {
 			sum := sha256.Sum256(data)
@@ -462,7 +462,7 @@ func fileStringSym(pos src.XPos, file string, readonly bool, hash []byte) (*obj.
 	} else {
 		// Emit a zero-length data symbol
 		// and then fix up length and content to use file.
-		symdata = slicedata(pos, "").Sym.Linksym()
+		symdata = slicedata(pos, "").Sym().Linksym()
 		symdata.Size = size
 		symdata.Type = objabi.SNOPTRDATA
 		info := symdata.NewFileInfo()
@@ -490,10 +490,10 @@ func slicedata(pos src.XPos, s string) *ir.Node {
 }
 
 func slicebytes(nam *ir.Node, s string) {
-	if nam.Op != ir.ONAME {
+	if nam.Op() != ir.ONAME {
 		base.Fatalf("slicebytes %v", nam)
 	}
-	slicesym(nam, slicedata(nam.Pos, s), int64(len(s)))
+	slicesym(nam, slicedata(nam.Pos(), s), int64(len(s)))
 }
 
 func dstringdata(s *obj.LSym, off int, t string, pos src.XPos, what string) int {
@@ -531,12 +531,12 @@ func dsymptrWeakOff(s *obj.LSym, off int, x *obj.LSym) int {
 // slicesym writes a static slice symbol {&arr, lencap, lencap} to n.
 // arr must be an ONAME. slicesym does not modify n.
 func slicesym(n, arr *ir.Node, lencap int64) {
-	s := n.Sym.Linksym()
-	off := n.Xoffset
-	if arr.Op != ir.ONAME {
+	s := n.Sym().Linksym()
+	off := n.Offset()
+	if arr.Op() != ir.ONAME {
 		base.Fatalf("slicesym non-name arr %v", arr)
 	}
-	s.WriteAddr(base.Ctxt, off, Widthptr, arr.Sym.Linksym(), arr.Xoffset)
+	s.WriteAddr(base.Ctxt, off, Widthptr, arr.Sym().Linksym(), arr.Offset())
 	s.WriteInt(base.Ctxt, off+sliceLenOffset, Widthptr, lencap)
 	s.WriteInt(base.Ctxt, off+sliceCapOffset, Widthptr, lencap)
 }
@@ -544,88 +544,88 @@ func slicesym(n, arr *ir.Node, lencap int64) {
 // addrsym writes the static address of a to n. a must be an ONAME.
 // Neither n nor a is modified.
 func addrsym(n, a *ir.Node) {
-	if n.Op != ir.ONAME {
-		base.Fatalf("addrsym n op %v", n.Op)
+	if n.Op() != ir.ONAME {
+		base.Fatalf("addrsym n op %v", n.Op())
 	}
-	if n.Sym == nil {
+	if n.Sym() == nil {
 		base.Fatalf("addrsym nil n sym")
 	}
-	if a.Op != ir.ONAME {
-		base.Fatalf("addrsym a op %v", a.Op)
+	if a.Op() != ir.ONAME {
+		base.Fatalf("addrsym a op %v", a.Op())
 	}
-	s := n.Sym.Linksym()
-	s.WriteAddr(base.Ctxt, n.Xoffset, Widthptr, a.Sym.Linksym(), a.Xoffset)
+	s := n.Sym().Linksym()
+	s.WriteAddr(base.Ctxt, n.Offset(), Widthptr, a.Sym().Linksym(), a.Offset())
 }
 
 // pfuncsym writes the static address of f to n. f must be a global function.
 // Neither n nor f is modified.
 func pfuncsym(n, f *ir.Node) {
-	if n.Op != ir.ONAME {
-		base.Fatalf("pfuncsym n op %v", n.Op)
+	if n.Op() != ir.ONAME {
+		base.Fatalf("pfuncsym n op %v", n.Op())
 	}
-	if n.Sym == nil {
+	if n.Sym() == nil {
 		base.Fatalf("pfuncsym nil n sym")
 	}
 	if f.Class() != ir.PFUNC {
 		base.Fatalf("pfuncsym class not PFUNC %d", f.Class())
 	}
-	s := n.Sym.Linksym()
-	s.WriteAddr(base.Ctxt, n.Xoffset, Widthptr, funcsym(f.Sym).Linksym(), f.Xoffset)
+	s := n.Sym().Linksym()
+	s.WriteAddr(base.Ctxt, n.Offset(), Widthptr, funcsym(f.Sym()).Linksym(), f.Offset())
 }
 
 // litsym writes the static literal c to n.
 // Neither n nor c is modified.
 func litsym(n, c *ir.Node, wid int) {
-	if n.Op != ir.ONAME {
-		base.Fatalf("litsym n op %v", n.Op)
+	if n.Op() != ir.ONAME {
+		base.Fatalf("litsym n op %v", n.Op())
 	}
-	if n.Sym == nil {
+	if n.Sym() == nil {
 		base.Fatalf("litsym nil n sym")
 	}
-	if !types.Identical(n.Type, c.Type) {
-		base.Fatalf("litsym: type mismatch: %v has type %v, but %v has type %v", n, n.Type, c, c.Type)
+	if !types.Identical(n.Type(), c.Type()) {
+		base.Fatalf("litsym: type mismatch: %v has type %v, but %v has type %v", n, n.Type(), c, c.Type())
 	}
-	if c.Op == ir.ONIL {
+	if c.Op() == ir.ONIL {
 		return
 	}
-	if c.Op != ir.OLITERAL {
-		base.Fatalf("litsym c op %v", c.Op)
+	if c.Op() != ir.OLITERAL {
+		base.Fatalf("litsym c op %v", c.Op())
 	}
-	s := n.Sym.Linksym()
+	s := n.Sym().Linksym()
 	switch u := c.Val(); u.Kind() {
 	case constant.Bool:
 		i := int64(obj.Bool2int(constant.BoolVal(u)))
-		s.WriteInt(base.Ctxt, n.Xoffset, wid, i)
+		s.WriteInt(base.Ctxt, n.Offset(), wid, i)
 
 	case constant.Int:
-		s.WriteInt(base.Ctxt, n.Xoffset, wid, ir.Int64Val(n.Type, u))
+		s.WriteInt(base.Ctxt, n.Offset(), wid, ir.Int64Val(n.Type(), u))
 
 	case constant.Float:
 		f, _ := constant.Float64Val(u)
-		switch n.Type.Etype {
+		switch n.Type().Etype {
 		case types.TFLOAT32:
-			s.WriteFloat32(base.Ctxt, n.Xoffset, float32(f))
+			s.WriteFloat32(base.Ctxt, n.Offset(), float32(f))
 		case types.TFLOAT64:
-			s.WriteFloat64(base.Ctxt, n.Xoffset, f)
+			s.WriteFloat64(base.Ctxt, n.Offset(), f)
 		}
 
 	case constant.Complex:
 		re, _ := constant.Float64Val(constant.Real(u))
 		im, _ := constant.Float64Val(constant.Imag(u))
-		switch n.Type.Etype {
+		switch n.Type().Etype {
 		case types.TCOMPLEX64:
-			s.WriteFloat32(base.Ctxt, n.Xoffset, float32(re))
-			s.WriteFloat32(base.Ctxt, n.Xoffset+4, float32(im))
+			s.WriteFloat32(base.Ctxt, n.Offset(), float32(re))
+			s.WriteFloat32(base.Ctxt, n.Offset()+4, float32(im))
 		case types.TCOMPLEX128:
-			s.WriteFloat64(base.Ctxt, n.Xoffset, re)
-			s.WriteFloat64(base.Ctxt, n.Xoffset+8, im)
+			s.WriteFloat64(base.Ctxt, n.Offset(), re)
+			s.WriteFloat64(base.Ctxt, n.Offset()+8, im)
 		}
 
 	case constant.String:
 		i := constant.StringVal(u)
-		symdata := stringsym(n.Pos, i)
-		s.WriteAddr(base.Ctxt, n.Xoffset, Widthptr, symdata, 0)
-		s.WriteInt(base.Ctxt, n.Xoffset+int64(Widthptr), Widthptr, int64(len(i)))
+		symdata := stringsym(n.Pos(), i)
+		s.WriteAddr(base.Ctxt, n.Offset(), Widthptr, symdata, 0)
+		s.WriteInt(base.Ctxt, n.Offset()+int64(Widthptr), Widthptr, int64(len(i)))
 
 	default:
 		base.Fatalf("litsym unhandled OLITERAL %v", c)
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 3bd49e8094..36a4095640 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -53,11 +53,11 @@ type Order struct {
 // described in the comment at the top of the file.
 func order(fn *ir.Node) {
 	if base.Flag.W > 1 {
-		s := fmt.Sprintf("\nbefore order %v", fn.Func.Nname.Sym)
-		ir.DumpList(s, fn.Nbody)
+		s := fmt.Sprintf("\nbefore order %v", fn.Func().Nname.Sym())
+		ir.DumpList(s, fn.Body())
 	}
 
-	orderBlock(&fn.Nbody, map[string][]*ir.Node{})
+	orderBlock(fn.PtrBody(), map[string][]*ir.Node{})
 }
 
 // newTemp allocates a new temporary with the given type,
@@ -70,7 +70,7 @@ func (o *Order) newTemp(t *types.Type, clear bool) *ir.Node {
 	key := t.LongString()
 	a := o.free[key]
 	for i, n := range a {
-		if types.Identical(t, n.Type) {
+		if types.Identical(t, n.Type()) {
 			v = a[i]
 			a[i] = a[len(a)-1]
 			a = a[:len(a)-1]
@@ -120,20 +120,20 @@ func (o *Order) cheapExpr(n *ir.Node) *ir.Node {
 		return nil
 	}
 
-	switch n.Op {
+	switch n.Op() {
 	case ir.ONAME, ir.OLITERAL, ir.ONIL:
 		return n
 	case ir.OLEN, ir.OCAP:
-		l := o.cheapExpr(n.Left)
-		if l == n.Left {
+		l := o.cheapExpr(n.Left())
+		if l == n.Left() {
 			return n
 		}
 		a := ir.SepCopy(n)
-		a.Left = l
+		a.SetLeft(l)
 		return typecheck(a, ctxExpr)
 	}
 
-	return o.copyExpr(n, n.Type, false)
+	return o.copyExpr(n, n.Type(), false)
 }
 
 // safeExpr returns a safe version of n.
@@ -144,46 +144,46 @@ func (o *Order) cheapExpr(n *ir.Node) *ir.Node {
 //
 // The intended use is to apply to x when rewriting x += y into x = x + y.
 func (o *Order) safeExpr(n *ir.Node) *ir.Node {
-	switch n.Op {
+	switch n.Op() {
 	case ir.ONAME, ir.OLITERAL, ir.ONIL:
 		return n
 
 	case ir.ODOT, ir.OLEN, ir.OCAP:
-		l := o.safeExpr(n.Left)
-		if l == n.Left {
+		l := o.safeExpr(n.Left())
+		if l == n.Left() {
 			return n
 		}
 		a := ir.SepCopy(n)
-		a.Left = l
+		a.SetLeft(l)
 		return typecheck(a, ctxExpr)
 
 	case ir.ODOTPTR, ir.ODEREF:
-		l := o.cheapExpr(n.Left)
-		if l == n.Left {
+		l := o.cheapExpr(n.Left())
+		if l == n.Left() {
 			return n
 		}
 		a := ir.SepCopy(n)
-		a.Left = l
+		a.SetLeft(l)
 		return typecheck(a, ctxExpr)
 
 	case ir.OINDEX, ir.OINDEXMAP:
 		var l *ir.Node
-		if n.Left.Type.IsArray() {
-			l = o.safeExpr(n.Left)
+		if n.Left().Type().IsArray() {
+			l = o.safeExpr(n.Left())
 		} else {
-			l = o.cheapExpr(n.Left)
+			l = o.cheapExpr(n.Left())
 		}
-		r := o.cheapExpr(n.Right)
-		if l == n.Left && r == n.Right {
+		r := o.cheapExpr(n.Right())
+		if l == n.Left() && r == n.Right() {
 			return n
 		}
 		a := ir.SepCopy(n)
-		a.Left = l
-		a.Right = r
+		a.SetLeft(l)
+		a.SetRight(r)
 		return typecheck(a, ctxExpr)
 
 	default:
-		base.Fatalf("order.safeExpr %v", n.Op)
+		base.Fatalf("order.safeExpr %v", n.Op())
 		return nil // not reached
 	}
 }
@@ -195,7 +195,7 @@ func (o *Order) safeExpr(n *ir.Node) *ir.Node {
 // because we emit explicit VARKILL instructions marking the end of those
 // temporaries' lifetimes.
 func isaddrokay(n *ir.Node) bool {
-	return islvalue(n) && (n.Op != ir.ONAME || n.Class() == ir.PEXTERN || ir.IsAutoTmp(n))
+	return islvalue(n) && (n.Op() != ir.ONAME || n.Class() == ir.PEXTERN || ir.IsAutoTmp(n))
 }
 
 // addrTemp ensures that n is okay to pass by address to runtime routines.
@@ -204,11 +204,11 @@ func isaddrokay(n *ir.Node) bool {
 // The result of addrTemp MUST be assigned back to n, e.g.
 // 	n.Left = o.addrTemp(n.Left)
 func (o *Order) addrTemp(n *ir.Node) *ir.Node {
-	if n.Op == ir.OLITERAL || n.Op == ir.ONIL {
+	if n.Op() == ir.OLITERAL || n.Op() == ir.ONIL {
 		// TODO: expand this to all static composite literal nodes?
 		n = defaultlit(n, nil)
-		dowidth(n.Type)
-		vstat := readonlystaticname(n.Type)
+		dowidth(n.Type())
+		vstat := readonlystaticname(n.Type())
 		var s InitSchedule
 		s.staticassign(vstat, n)
 		if s.out != nil {
@@ -220,7 +220,7 @@ func (o *Order) addrTemp(n *ir.Node) *ir.Node {
 	if isaddrokay(n) {
 		return n
 	}
-	return o.copyExpr(n, n.Type, false)
+	return o.copyExpr(n, n.Type(), false)
 }
 
 // mapKeyTemp prepares n to be a key in a map runtime call and returns n.
@@ -250,20 +250,20 @@ func (o *Order) mapKeyTemp(t *types.Type, n *ir.Node) *ir.Node {
 // comes up in important cases in practice. See issue 3512.
 func mapKeyReplaceStrConv(n *ir.Node) bool {
 	var replaced bool
-	switch n.Op {
+	switch n.Op() {
 	case ir.OBYTES2STR:
-		n.Op = ir.OBYTES2STRTMP
+		n.SetOp(ir.OBYTES2STRTMP)
 		replaced = true
 	case ir.OSTRUCTLIT:
-		for _, elem := range n.List.Slice() {
-			if mapKeyReplaceStrConv(elem.Left) {
+		for _, elem := range n.List().Slice() {
+			if mapKeyReplaceStrConv(elem.Left()) {
 				replaced = true
 			}
 		}
 	case ir.OARRAYLIT:
-		for _, elem := range n.List.Slice() {
-			if elem.Op == ir.OKEY {
-				elem = elem.Right
+		for _, elem := range n.List().Slice() {
+			if elem.Op() == ir.OKEY {
+				elem = elem.Right()
 			}
 			if mapKeyReplaceStrConv(elem) {
 				replaced = true
@@ -284,7 +284,7 @@ func (o *Order) markTemp() ordermarker {
 // which must have been returned by markTemp.
 func (o *Order) popTemp(mark ordermarker) {
 	for _, n := range o.temp[mark:] {
-		key := n.Type.LongString()
+		key := n.Type().LongString()
 		o.free[key] = append(o.free[key], n)
 	}
 	o.temp = o.temp[:mark]
@@ -336,46 +336,46 @@ func orderMakeSliceCopy(s []*ir.Node) {
 	asn := s[0]
 	copyn := s[1]
 
-	if asn == nil || asn.Op != ir.OAS {
+	if asn == nil || asn.Op() != ir.OAS {
 		return
 	}
-	if asn.Left.Op != ir.ONAME {
+	if asn.Left().Op() != ir.ONAME {
 		return
 	}
-	if ir.IsBlank(asn.Left) {
+	if ir.IsBlank(asn.Left()) {
 		return
 	}
-	maken := asn.Right
-	if maken == nil || maken.Op != ir.OMAKESLICE {
+	maken := asn.Right()
+	if maken == nil || maken.Op() != ir.OMAKESLICE {
 		return
 	}
-	if maken.Esc == EscNone {
+	if maken.Esc() == EscNone {
 		return
 	}
-	if maken.Left == nil || maken.Right != nil {
+	if maken.Left() == nil || maken.Right() != nil {
 		return
 	}
-	if copyn.Op != ir.OCOPY {
+	if copyn.Op() != ir.OCOPY {
 		return
 	}
-	if copyn.Left.Op != ir.ONAME {
+	if copyn.Left().Op() != ir.ONAME {
 		return
 	}
-	if asn.Left.Sym != copyn.Left.Sym {
+	if asn.Left().Sym() != copyn.Left().Sym() {
 		return
 	}
-	if copyn.Right.Op != ir.ONAME {
+	if copyn.Right().Op() != ir.ONAME {
 		return
 	}
 
-	if copyn.Left.Sym == copyn.Right.Sym {
+	if copyn.Left().Sym() == copyn.Right().Sym() {
 		return
 	}
 
-	maken.Op = ir.OMAKESLICECOPY
-	maken.Right = copyn.Right
+	maken.SetOp(ir.OMAKESLICECOPY)
+	maken.SetRight(copyn.Right())
 	// Set bounded when m = OMAKESLICE([]T, len(s)); OCOPY(m, s)
-	maken.SetBounded(maken.Left.Op == ir.OLEN && samesafeexpr(maken.Left.Left, copyn.Right))
+	maken.SetBounded(maken.Left().Op() == ir.OLEN && samesafeexpr(maken.Left().Left(), copyn.Right()))
 
 	maken = typecheck(maken, ctxExpr)
 
@@ -393,7 +393,7 @@ func (o *Order) edge() {
 	// Create a new uint8 counter to be allocated in section
 	// __libfuzzer_extra_counters.
 	counter := staticname(types.Types[types.TUINT8])
-	counter.Name.SetLibfuzzerExtraCounter(true)
+	counter.Name().SetLibfuzzerExtraCounter(true)
 
 	// counter += 1
 	incr := ir.Nod(ir.OASOP, counter, nodintconst(1))
@@ -451,36 +451,36 @@ func (o *Order) init(n *ir.Node) {
 	if ir.MayBeShared(n) {
 		// For concurrency safety, don't mutate potentially shared nodes.
 		// First, ensure that no work is required here.
-		if n.Ninit.Len() > 0 {
+		if n.Init().Len() > 0 {
 			base.Fatalf("order.init shared node with ninit")
 		}
 		return
 	}
-	o.stmtList(n.Ninit)
-	n.Ninit.Set(nil)
+	o.stmtList(n.Init())
+	n.PtrInit().Set(nil)
 }
 
 // call orders the call expression n.
 // n.Op is OCALLMETH/OCALLFUNC/OCALLINTER or a builtin like OCOPY.
 func (o *Order) call(n *ir.Node) {
-	if n.Ninit.Len() > 0 {
+	if n.Init().Len() > 0 {
 		// Caller should have already called o.init(n).
-		base.Fatalf("%v with unexpected ninit", n.Op)
+		base.Fatalf("%v with unexpected ninit", n.Op())
 	}
 
 	// Builtin functions.
-	if n.Op != ir.OCALLFUNC && n.Op != ir.OCALLMETH && n.Op != ir.OCALLINTER {
-		n.Left = o.expr(n.Left, nil)
-		n.Right = o.expr(n.Right, nil)
-		o.exprList(n.List)
+	if n.Op() != ir.OCALLFUNC && n.Op() != ir.OCALLMETH && n.Op() != ir.OCALLINTER {
+		n.SetLeft(o.expr(n.Left(), nil))
+		n.SetRight(o.expr(n.Right(), nil))
+		o.exprList(n.List())
 		return
 	}
 
 	fixVariadicCall(n)
-	n.Left = o.expr(n.Left, nil)
-	o.exprList(n.List)
+	n.SetLeft(o.expr(n.Left(), nil))
+	o.exprList(n.List())
 
-	if n.Op == ir.OCALLINTER {
+	if n.Op() == ir.OCALLINTER {
 		return
 	}
 	keepAlive := func(arg *ir.Node) {
@@ -488,19 +488,19 @@ func (o *Order) call(n *ir.Node) {
 		// arrange for the pointer to be kept alive until the call returns,
 		// by copying it into a temp and marking that temp
 		// still alive when we pop the temp stack.
-		if arg.Op == ir.OCONVNOP && arg.Left.Type.IsUnsafePtr() {
-			x := o.copyExpr(arg.Left, arg.Left.Type, false)
-			arg.Left = x
-			x.Name.SetAddrtaken(true) // ensure SSA keeps the x variable
-			n.Nbody.Append(typecheck(ir.Nod(ir.OVARLIVE, x, nil), ctxStmt))
+		if arg.Op() == ir.OCONVNOP && arg.Left().Type().IsUnsafePtr() {
+			x := o.copyExpr(arg.Left(), arg.Left().Type(), false)
+			arg.SetLeft(x)
+			x.Name().SetAddrtaken(true) // ensure SSA keeps the x variable
+			n.PtrBody().Append(typecheck(ir.Nod(ir.OVARLIVE, x, nil), ctxStmt))
 		}
 	}
 
 	// Check for "unsafe-uintptr" tag provided by escape analysis.
-	for i, param := range n.Left.Type.Params().FieldSlice() {
+	for i, param := range n.Left().Type().Params().FieldSlice() {
 		if param.Note == unsafeUintptrTag || param.Note == uintptrEscapesTag {
-			if arg := n.List.Index(i); arg.Op == ir.OSLICELIT {
-				for _, elt := range arg.List.Slice() {
+			if arg := n.List().Index(i); arg.Op() == ir.OSLICELIT {
+				for _, elt := range arg.List().Slice() {
 					keepAlive(elt)
 				}
 			} else {
@@ -526,40 +526,40 @@ func (o *Order) call(n *ir.Node) {
 // And this only applies to the multiple-assignment form.
 // We could do a more precise analysis if needed, like in walk.go.
 func (o *Order) mapAssign(n *ir.Node) {
-	switch n.Op {
+	switch n.Op() {
 	default:
-		base.Fatalf("order.mapAssign %v", n.Op)
+		base.Fatalf("order.mapAssign %v", n.Op())
 
 	case ir.OAS, ir.OASOP:
-		if n.Left.Op == ir.OINDEXMAP {
+		if n.Left().Op() == ir.OINDEXMAP {
 			// Make sure we evaluate the RHS before starting the map insert.
 			// We need to make sure the RHS won't panic.  See issue 22881.
-			if n.Right.Op == ir.OAPPEND {
-				s := n.Right.List.Slice()[1:]
+			if n.Right().Op() == ir.OAPPEND {
+				s := n.Right().List().Slice()[1:]
 				for i, n := range s {
 					s[i] = o.cheapExpr(n)
 				}
 			} else {
-				n.Right = o.cheapExpr(n.Right)
+				n.SetRight(o.cheapExpr(n.Right()))
 			}
 		}
 		o.out = append(o.out, n)
 
 	case ir.OAS2, ir.OAS2DOTTYPE, ir.OAS2MAPR, ir.OAS2FUNC:
 		var post []*ir.Node
-		for i, m := range n.List.Slice() {
+		for i, m := range n.List().Slice() {
 			switch {
-			case m.Op == ir.OINDEXMAP:
-				if !ir.IsAutoTmp(m.Left) {
-					m.Left = o.copyExpr(m.Left, m.Left.Type, false)
+			case m.Op() == ir.OINDEXMAP:
+				if !ir.IsAutoTmp(m.Left()) {
+					m.SetLeft(o.copyExpr(m.Left(), m.Left().Type(), false))
 				}
-				if !ir.IsAutoTmp(m.Right) {
-					m.Right = o.copyExpr(m.Right, m.Right.Type, false)
+				if !ir.IsAutoTmp(m.Right()) {
+					m.SetRight(o.copyExpr(m.Right(), m.Right().Type(), false))
 				}
 				fallthrough
-			case instrumenting && n.Op == ir.OAS2FUNC && !ir.IsBlank(m):
-				t := o.newTemp(m.Type, false)
-				n.List.SetIndex(i, t)
+			case instrumenting && n.Op() == ir.OAS2FUNC && !ir.IsBlank(m):
+				t := o.newTemp(m.Type(), false)
+				n.List().SetIndex(i, t)
 				a := ir.Nod(ir.OAS, m, t)
 				a = typecheck(a, ctxStmt)
 				post = append(post, a)
@@ -582,43 +582,43 @@ func (o *Order) stmt(n *ir.Node) {
 	lno := setlineno(n)
 	o.init(n)
 
-	switch n.Op {
+	switch n.Op() {
 	default:
-		base.Fatalf("order.stmt %v", n.Op)
+		base.Fatalf("order.stmt %v", n.Op())
 
 	case ir.OVARKILL, ir.OVARLIVE, ir.OINLMARK:
 		o.out = append(o.out, n)
 
 	case ir.OAS:
 		t := o.markTemp()
-		n.Left = o.expr(n.Left, nil)
-		n.Right = o.expr(n.Right, n.Left)
+		n.SetLeft(o.expr(n.Left(), nil))
+		n.SetRight(o.expr(n.Right(), n.Left()))
 		o.mapAssign(n)
 		o.cleanTemp(t)
 
 	case ir.OASOP:
 		t := o.markTemp()
-		n.Left = o.expr(n.Left, nil)
-		n.Right = o.expr(n.Right, nil)
+		n.SetLeft(o.expr(n.Left(), nil))
+		n.SetRight(o.expr(n.Right(), nil))
 
-		if instrumenting || n.Left.Op == ir.OINDEXMAP && (n.SubOp() == ir.ODIV || n.SubOp() == ir.OMOD) {
+		if instrumenting || n.Left().Op() == ir.OINDEXMAP && (n.SubOp() == ir.ODIV || n.SubOp() == ir.OMOD) {
 			// Rewrite m[k] op= r into m[k] = m[k] op r so
 			// that we can ensure that if op panics
 			// because r is zero, the panic happens before
 			// the map assignment.
 
-			n.Left = o.safeExpr(n.Left)
+			n.SetLeft(o.safeExpr(n.Left()))
 
-			l := treecopy(n.Left, src.NoXPos)
-			if l.Op == ir.OINDEXMAP {
+			l := treecopy(n.Left(), src.NoXPos)
+			if l.Op() == ir.OINDEXMAP {
 				l.SetIndexMapLValue(false)
 			}
-			l = o.copyExpr(l, n.Left.Type, false)
-			n.Right = ir.Nod(n.SubOp(), l, n.Right)
-			n.Right = typecheck(n.Right, ctxExpr)
-			n.Right = o.expr(n.Right, nil)
+			l = o.copyExpr(l, n.Left().Type(), false)
+			n.SetRight(ir.Nod(n.SubOp(), l, n.Right()))
+			n.SetRight(typecheck(n.Right(), ctxExpr))
+			n.SetRight(o.expr(n.Right(), nil))
 
-			n.Op = ir.OAS
+			n.SetOp(ir.OAS)
 			n.ResetAux()
 		}
 
@@ -627,17 +627,17 @@ func (o *Order) stmt(n *ir.Node) {
 
 	case ir.OAS2:
 		t := o.markTemp()
-		o.exprList(n.List)
-		o.exprList(n.Rlist)
+		o.exprList(n.List())
+		o.exprList(n.Rlist())
 		o.mapAssign(n)
 		o.cleanTemp(t)
 
 	// Special: avoid copy of func call n.Right
 	case ir.OAS2FUNC:
 		t := o.markTemp()
-		o.exprList(n.List)
-		o.init(n.Right)
-		o.call(n.Right)
+		o.exprList(n.List())
+		o.init(n.Right())
+		o.call(n.Right())
 		o.as2(n)
 		o.cleanTemp(t)
 
@@ -649,19 +649,19 @@ func (o *Order) stmt(n *ir.Node) {
 	//           and make sure OINDEXMAP is not copied out.
 	case ir.OAS2DOTTYPE, ir.OAS2RECV, ir.OAS2MAPR:
 		t := o.markTemp()
-		o.exprList(n.List)
+		o.exprList(n.List())
 
-		switch r := n.Right; r.Op {
+		switch r := n.Right(); r.Op() {
 		case ir.ODOTTYPE2, ir.ORECV:
-			r.Left = o.expr(r.Left, nil)
+			r.SetLeft(o.expr(r.Left(), nil))
 		case ir.OINDEXMAP:
-			r.Left = o.expr(r.Left, nil)
-			r.Right = o.expr(r.Right, nil)
+			r.SetLeft(o.expr(r.Left(), nil))
+			r.SetRight(o.expr(r.Right(), nil))
 			// See similar conversion for OINDEXMAP below.
-			_ = mapKeyReplaceStrConv(r.Right)
-			r.Right = o.mapKeyTemp(r.Left.Type, r.Right)
+			_ = mapKeyReplaceStrConv(r.Right())
+			r.SetRight(o.mapKeyTemp(r.Left().Type(), r.Right()))
 		default:
-			base.Fatalf("order.stmt: %v", r.Op)
+			base.Fatalf("order.stmt: %v", r.Op())
 		}
 
 		o.okAs2(n)
@@ -669,7 +669,7 @@ func (o *Order) stmt(n *ir.Node) {
 
 	// Special: does not save n onto out.
 	case ir.OBLOCK, ir.OEMPTY:
-		o.stmtList(n.List)
+		o.stmtList(n.List())
 
 	// Special: n->left is not an expression; save as is.
 	case ir.OBREAK,
@@ -697,26 +697,26 @@ func (o *Order) stmt(n *ir.Node) {
 		ir.ORECOVER,
 		ir.ORECV:
 		t := o.markTemp()
-		n.Left = o.expr(n.Left, nil)
-		n.Right = o.expr(n.Right, nil)
-		o.exprList(n.List)
-		o.exprList(n.Rlist)
+		n.SetLeft(o.expr(n.Left(), nil))
+		n.SetRight(o.expr(n.Right(), nil))
+		o.exprList(n.List())
+		o.exprList(n.Rlist())
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
 
 	// Special: order arguments to inner call but not call itself.
 	case ir.ODEFER, ir.OGO:
 		t := o.markTemp()
-		o.init(n.Left)
-		o.call(n.Left)
+		o.init(n.Left())
+		o.call(n.Left())
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
 
 	case ir.ODELETE:
 		t := o.markTemp()
-		n.List.SetFirst(o.expr(n.List.First(), nil))
-		n.List.SetSecond(o.expr(n.List.Second(), nil))
-		n.List.SetSecond(o.mapKeyTemp(n.List.First().Type, n.List.Second()))
+		n.List().SetFirst(o.expr(n.List().First(), nil))
+		n.List().SetSecond(o.expr(n.List().Second(), nil))
+		n.List().SetSecond(o.mapKeyTemp(n.List().First().Type(), n.List().Second()))
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
 
@@ -724,10 +724,10 @@ func (o *Order) stmt(n *ir.Node) {
 	// beginning of loop body and after for statement.
 	case ir.OFOR:
 		t := o.markTemp()
-		n.Left = o.exprInPlace(n.Left)
-		n.Nbody.Prepend(o.cleanTempNoPop(t)...)
-		orderBlock(&n.Nbody, o.free)
-		n.Right = orderStmtInPlace(n.Right, o.free)
+		n.SetLeft(o.exprInPlace(n.Left()))
+		n.PtrBody().Prepend(o.cleanTempNoPop(t)...)
+		orderBlock(n.PtrBody(), o.free)
+		n.SetRight(orderStmtInPlace(n.Right(), o.free))
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
 
@@ -735,21 +735,21 @@ func (o *Order) stmt(n *ir.Node) {
 	// beginning of both branches.
 	case ir.OIF:
 		t := o.markTemp()
-		n.Left = o.exprInPlace(n.Left)
-		n.Nbody.Prepend(o.cleanTempNoPop(t)...)
-		n.Rlist.Prepend(o.cleanTempNoPop(t)...)
+		n.SetLeft(o.exprInPlace(n.Left()))
+		n.PtrBody().Prepend(o.cleanTempNoPop(t)...)
+		n.PtrRlist().Prepend(o.cleanTempNoPop(t)...)
 		o.popTemp(t)
-		orderBlock(&n.Nbody, o.free)
-		orderBlock(&n.Rlist, o.free)
+		orderBlock(n.PtrBody(), o.free)
+		orderBlock(n.PtrRlist(), o.free)
 		o.out = append(o.out, n)
 
 	// Special: argument will be converted to interface using convT2E
 	// so make sure it is an addressable temporary.
 	case ir.OPANIC:
 		t := o.markTemp()
-		n.Left = o.expr(n.Left, nil)
-		if !n.Left.Type.IsInterface() {
-			n.Left = o.addrTemp(n.Left)
+		n.SetLeft(o.expr(n.Left(), nil))
+		if !n.Left().Type().IsInterface() {
+			n.SetLeft(o.addrTemp(n.Left()))
 		}
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
@@ -768,20 +768,20 @@ func (o *Order) stmt(n *ir.Node) {
 
 		// Mark []byte(str) range expression to reuse string backing storage.
 		// It is safe because the storage cannot be mutated.
-		if n.Right.Op == ir.OSTR2BYTES {
-			n.Right.Op = ir.OSTR2BYTESTMP
+		if n.Right().Op() == ir.OSTR2BYTES {
+			n.Right().SetOp(ir.OSTR2BYTESTMP)
 		}
 
 		t := o.markTemp()
-		n.Right = o.expr(n.Right, nil)
+		n.SetRight(o.expr(n.Right(), nil))
 
 		orderBody := true
-		switch n.Type.Etype {
+		switch n.Type().Etype {
 		default:
-			base.Fatalf("order.stmt range %v", n.Type)
+			base.Fatalf("order.stmt range %v", n.Type())
 
 		case types.TARRAY, types.TSLICE:
-			if n.List.Len() < 2 || ir.IsBlank(n.List.Second()) {
+			if n.List().Len() < 2 || ir.IsBlank(n.List().Second()) {
 				// for i := range x will only use x once, to compute len(x).
 				// No need to copy it.
 				break
@@ -791,15 +791,15 @@ func (o *Order) stmt(n *ir.Node) {
 		case types.TCHAN, types.TSTRING:
 			// chan, string, slice, array ranges use value multiple times.
 			// make copy.
-			r := n.Right
+			r := n.Right()
 
-			if r.Type.IsString() && r.Type != types.Types[types.TSTRING] {
+			if r.Type().IsString() && r.Type() != types.Types[types.TSTRING] {
 				r = ir.Nod(ir.OCONV, r, nil)
-				r.Type = types.Types[types.TSTRING]
+				r.SetType(types.Types[types.TSTRING])
 				r = typecheck(r, ctxExpr)
 			}
 
-			n.Right = o.copyExpr(r, r.Type, false)
+			n.SetRight(o.copyExpr(r, r.Type(), false))
 
 		case types.TMAP:
 			if isMapClear(n) {
@@ -813,22 +813,22 @@ func (o *Order) stmt(n *ir.Node) {
 			// copy the map value in case it is a map literal.
 			// TODO(rsc): Make tmp = literal expressions reuse tmp.
 			// For maps tmp is just one word so it hardly matters.
-			r := n.Right
-			n.Right = o.copyExpr(r, r.Type, false)
+			r := n.Right()
+			n.SetRight(o.copyExpr(r, r.Type(), false))
 
 			// prealloc[n] is the temp for the iterator.
 			// hiter contains pointers and needs to be zeroed.
-			prealloc[n] = o.newTemp(hiter(n.Type), true)
+			prealloc[n] = o.newTemp(hiter(n.Type()), true)
 		}
-		o.exprListInPlace(n.List)
+		o.exprListInPlace(n.List())
 		if orderBody {
-			orderBlock(&n.Nbody, o.free)
+			orderBlock(n.PtrBody(), o.free)
 		}
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
 
 	case ir.ORETURN:
-		o.exprList(n.List)
+		o.exprList(n.List())
 		o.out = append(o.out, n)
 
 	// Special: clean case temporaries in each block entry.
@@ -843,25 +843,25 @@ func (o *Order) stmt(n *ir.Node) {
 	case ir.OSELECT:
 		t := o.markTemp()
 
-		for _, n2 := range n.List.Slice() {
-			if n2.Op != ir.OCASE {
-				base.Fatalf("order select case %v", n2.Op)
+		for _, n2 := range n.List().Slice() {
+			if n2.Op() != ir.OCASE {
+				base.Fatalf("order select case %v", n2.Op())
 			}
-			r := n2.Left
+			r := n2.Left()
 			setlineno(n2)
 
 			// Append any new body prologue to ninit.
 			// The next loop will insert ninit into nbody.
-			if n2.Ninit.Len() != 0 {
+			if n2.Init().Len() != 0 {
 				base.Fatalf("order select ninit")
 			}
 			if r == nil {
 				continue
 			}
-			switch r.Op {
+			switch r.Op() {
 			default:
 				ir.Dump("select case", r)
-				base.Fatalf("unknown op in select %v", r.Op)
+				base.Fatalf("unknown op in select %v", r.Op())
 
 			// If this is case x := <-ch or case x, y := <-ch, the case has
 			// the ODCL nodes to declare x and y. We want to delay that
@@ -870,19 +870,19 @@ func (o *Order) stmt(n *ir.Node) {
 			case ir.OSELRECV, ir.OSELRECV2:
 				if r.Colas() {
 					i := 0
-					if r.Ninit.Len() != 0 && r.Ninit.First().Op == ir.ODCL && r.Ninit.First().Left == r.Left {
+					if r.Init().Len() != 0 && r.Init().First().Op() == ir.ODCL && r.Init().First().Left() == r.Left() {
 						i++
 					}
-					if i < r.Ninit.Len() && r.Ninit.Index(i).Op == ir.ODCL && r.List.Len() != 0 && r.Ninit.Index(i).Left == r.List.First() {
+					if i < r.Init().Len() && r.Init().Index(i).Op() == ir.ODCL && r.List().Len() != 0 && r.Init().Index(i).Left() == r.List().First() {
 						i++
 					}
-					if i >= r.Ninit.Len() {
-						r.Ninit.Set(nil)
+					if i >= r.Init().Len() {
+						r.PtrInit().Set(nil)
 					}
 				}
 
-				if r.Ninit.Len() != 0 {
-					ir.DumpList("ninit", r.Ninit)
+				if r.Init().Len() != 0 {
+					ir.DumpList("ninit", r.Init())
 					base.Fatalf("ninit on select recv")
 				}
 
@@ -891,10 +891,10 @@ func (o *Order) stmt(n *ir.Node) {
 				// r->left is x, r->ntest is ok, r->right is ORECV, r->right->left is c.
 				// r->left == N means 'case <-c'.
 				// c is always evaluated; x and ok are only evaluated when assigned.
-				r.Right.Left = o.expr(r.Right.Left, nil)
+				r.Right().SetLeft(o.expr(r.Right().Left(), nil))
 
-				if r.Right.Left.Op != ir.ONAME {
-					r.Right.Left = o.copyExpr(r.Right.Left, r.Right.Left.Type, false)
+				if r.Right().Left().Op() != ir.ONAME {
+					r.Right().SetLeft(o.copyExpr(r.Right().Left(), r.Right().Left().Type(), false))
 				}
 
 				// Introduce temporary for receive and move actual copy into case body.
@@ -903,75 +903,75 @@ func (o *Order) stmt(n *ir.Node) {
 				// temporary per distinct type, sharing the temp among all receives
 				// with that temp. Similarly one ok bool could be shared among all
 				// the x,ok receives. Not worth doing until there's a clear need.
-				if r.Left != nil && ir.IsBlank(r.Left) {
-					r.Left = nil
+				if r.Left() != nil && ir.IsBlank(r.Left()) {
+					r.SetLeft(nil)
 				}
-				if r.Left != nil {
+				if r.Left() != nil {
 					// use channel element type for temporary to avoid conversions,
 					// such as in case interfacevalue = <-intchan.
 					// the conversion happens in the OAS instead.
-					tmp1 := r.Left
+					tmp1 := r.Left()
 
 					if r.Colas() {
 						tmp2 := ir.Nod(ir.ODCL, tmp1, nil)
 						tmp2 = typecheck(tmp2, ctxStmt)
-						n2.Ninit.Append(tmp2)
+						n2.PtrInit().Append(tmp2)
 					}
 
-					r.Left = o.newTemp(r.Right.Left.Type.Elem(), r.Right.Left.Type.Elem().HasPointers())
-					tmp2 := ir.Nod(ir.OAS, tmp1, r.Left)
+					r.SetLeft(o.newTemp(r.Right().Left().Type().Elem(), r.Right().Left().Type().Elem().HasPointers()))
+					tmp2 := ir.Nod(ir.OAS, tmp1, r.Left())
 					tmp2 = typecheck(tmp2, ctxStmt)
-					n2.Ninit.Append(tmp2)
+					n2.PtrInit().Append(tmp2)
 				}
 
-				if r.List.Len() != 0 && ir.IsBlank(r.List.First()) {
-					r.List.Set(nil)
+				if r.List().Len() != 0 && ir.IsBlank(r.List().First()) {
+					r.PtrList().Set(nil)
 				}
-				if r.List.Len() != 0 {
-					tmp1 := r.List.First()
+				if r.List().Len() != 0 {
+					tmp1 := r.List().First()
 					if r.Colas() {
 						tmp2 := ir.Nod(ir.ODCL, tmp1, nil)
 						tmp2 = typecheck(tmp2, ctxStmt)
-						n2.Ninit.Append(tmp2)
+						n2.PtrInit().Append(tmp2)
 					}
 
-					r.List.Set1(o.newTemp(types.Types[types.TBOOL], false))
-					tmp2 := okas(tmp1, r.List.First())
+					r.PtrList().Set1(o.newTemp(types.Types[types.TBOOL], false))
+					tmp2 := okas(tmp1, r.List().First())
 					tmp2 = typecheck(tmp2, ctxStmt)
-					n2.Ninit.Append(tmp2)
+					n2.PtrInit().Append(tmp2)
 				}
-				orderBlock(&n2.Ninit, o.free)
+				orderBlock(n2.PtrInit(), o.free)
 
 			case ir.OSEND:
-				if r.Ninit.Len() != 0 {
-					ir.DumpList("ninit", r.Ninit)
+				if r.Init().Len() != 0 {
+					ir.DumpList("ninit", r.Init())
 					base.Fatalf("ninit on select send")
 				}
 
 				// case c <- x
 				// r->left is c, r->right is x, both are always evaluated.
-				r.Left = o.expr(r.Left, nil)
+				r.SetLeft(o.expr(r.Left(), nil))
 
-				if !ir.IsAutoTmp(r.Left) {
-					r.Left = o.copyExpr(r.Left, r.Left.Type, false)
+				if !ir.IsAutoTmp(r.Left()) {
+					r.SetLeft(o.copyExpr(r.Left(), r.Left().Type(), false))
 				}
-				r.Right = o.expr(r.Right, nil)
-				if !ir.IsAutoTmp(r.Right) {
-					r.Right = o.copyExpr(r.Right, r.Right.Type, false)
+				r.SetRight(o.expr(r.Right(), nil))
+				if !ir.IsAutoTmp(r.Right()) {
+					r.SetRight(o.copyExpr(r.Right(), r.Right().Type(), false))
 				}
 			}
 		}
 		// Now that we have accumulated all the temporaries, clean them.
 		// Also insert any ninit queued during the previous loop.
 		// (The temporary cleaning must follow that ninit work.)
-		for _, n3 := range n.List.Slice() {
-			orderBlock(&n3.Nbody, o.free)
-			n3.Nbody.Prepend(o.cleanTempNoPop(t)...)
+		for _, n3 := range n.List().Slice() {
+			orderBlock(n3.PtrBody(), o.free)
+			n3.PtrBody().Prepend(o.cleanTempNoPop(t)...)
 
 			// TODO(mdempsky): Is this actually necessary?
 			// walkselect appears to walk Ninit.
-			n3.Nbody.Prepend(n3.Ninit.Slice()...)
-			n3.Ninit.Set(nil)
+			n3.PtrBody().Prepend(n3.Init().Slice()...)
+			n3.PtrInit().Set(nil)
 		}
 
 		o.out = append(o.out, n)
@@ -980,14 +980,14 @@ func (o *Order) stmt(n *ir.Node) {
 	// Special: value being sent is passed as a pointer; make it addressable.
 	case ir.OSEND:
 		t := o.markTemp()
-		n.Left = o.expr(n.Left, nil)
-		n.Right = o.expr(n.Right, nil)
+		n.SetLeft(o.expr(n.Left(), nil))
+		n.SetRight(o.expr(n.Right(), nil))
 		if instrumenting {
 			// Force copying to the stack so that (chan T)(nil) <- x
 			// is still instrumented as a read of x.
-			n.Right = o.copyExpr(n.Right, n.Right.Type, false)
+			n.SetRight(o.copyExpr(n.Right(), n.Right().Type(), false))
 		} else {
-			n.Right = o.addrTemp(n.Right)
+			n.SetRight(o.addrTemp(n.Right()))
 		}
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
@@ -1002,17 +1002,17 @@ func (o *Order) stmt(n *ir.Node) {
 	case ir.OSWITCH:
 		if base.Debug.Libfuzzer != 0 && !hasDefaultCase(n) {
 			// Add empty "default:" case for instrumentation.
-			n.List.Append(ir.Nod(ir.OCASE, nil, nil))
+			n.PtrList().Append(ir.Nod(ir.OCASE, nil, nil))
 		}
 
 		t := o.markTemp()
-		n.Left = o.expr(n.Left, nil)
-		for _, ncas := range n.List.Slice() {
-			if ncas.Op != ir.OCASE {
-				base.Fatalf("order switch case %v", ncas.Op)
+		n.SetLeft(o.expr(n.Left(), nil))
+		for _, ncas := range n.List().Slice() {
+			if ncas.Op() != ir.OCASE {
+				base.Fatalf("order switch case %v", ncas.Op())
 			}
-			o.exprListInPlace(ncas.List)
-			orderBlock(&ncas.Nbody, o.free)
+			o.exprListInPlace(ncas.List())
+			orderBlock(ncas.PtrBody(), o.free)
 		}
 
 		o.out = append(o.out, n)
@@ -1023,11 +1023,11 @@ func (o *Order) stmt(n *ir.Node) {
 }
 
 func hasDefaultCase(n *ir.Node) bool {
-	for _, ncas := range n.List.Slice() {
-		if ncas.Op != ir.OCASE {
-			base.Fatalf("expected case, found %v", ncas.Op)
+	for _, ncas := range n.List().Slice() {
+		if ncas.Op() != ir.OCASE {
+			base.Fatalf("expected case, found %v", ncas.Op())
 		}
-		if ncas.List.Len() == 0 {
+		if ncas.List().Len() == 0 {
 			return true
 		}
 	}
@@ -1069,21 +1069,21 @@ func (o *Order) expr(n, lhs *ir.Node) *ir.Node {
 	lno := setlineno(n)
 	o.init(n)
 
-	switch n.Op {
+	switch n.Op() {
 	default:
-		n.Left = o.expr(n.Left, nil)
-		n.Right = o.expr(n.Right, nil)
-		o.exprList(n.List)
-		o.exprList(n.Rlist)
+		n.SetLeft(o.expr(n.Left(), nil))
+		n.SetRight(o.expr(n.Right(), nil))
+		o.exprList(n.List())
+		o.exprList(n.Rlist())
 
 	// Addition of strings turns into a function call.
 	// Allocate a temporary to hold the strings.
 	// Fewer than 5 strings use direct runtime helpers.
 	case ir.OADDSTR:
-		o.exprList(n.List)
+		o.exprList(n.List())
 
-		if n.List.Len() > 5 {
-			t := types.NewArray(types.Types[types.TSTRING], int64(n.List.Len()))
+		if n.List().Len() > 5 {
+			t := types.NewArray(types.Types[types.TSTRING], int64(n.List().Len()))
 			prealloc[n] = o.newTemp(t, false)
 		}
 
@@ -1097,22 +1097,22 @@ func (o *Order) expr(n, lhs *ir.Node) *ir.Node {
 		hasbyte := false
 
 		haslit := false
-		for _, n1 := range n.List.Slice() {
-			hasbyte = hasbyte || n1.Op == ir.OBYTES2STR
-			haslit = haslit || n1.Op == ir.OLITERAL && len(n1.StringVal()) != 0
+		for _, n1 := range n.List().Slice() {
+			hasbyte = hasbyte || n1.Op() == ir.OBYTES2STR
+			haslit = haslit || n1.Op() == ir.OLITERAL && len(n1.StringVal()) != 0
 		}
 
 		if haslit && hasbyte {
-			for _, n2 := range n.List.Slice() {
-				if n2.Op == ir.OBYTES2STR {
-					n2.Op = ir.OBYTES2STRTMP
+			for _, n2 := range n.List().Slice() {
+				if n2.Op() == ir.OBYTES2STR {
+					n2.SetOp(ir.OBYTES2STRTMP)
 				}
 			}
 		}
 
 	case ir.OINDEXMAP:
-		n.Left = o.expr(n.Left, nil)
-		n.Right = o.expr(n.Right, nil)
+		n.SetLeft(o.expr(n.Left(), nil))
+		n.SetRight(o.expr(n.Right(), nil))
 		needCopy := false
 
 		if !n.IndexMapLValue() {
@@ -1120,7 +1120,7 @@ func (o *Order) expr(n, lhs *ir.Node) *ir.Node {
 			// can not be changed before the map index by forcing
 			// the map index to happen immediately following the
 			// conversions. See copyExpr a few lines below.
-			needCopy = mapKeyReplaceStrConv(n.Right)
+			needCopy = mapKeyReplaceStrConv(n.Right())
 
 			if instrumenting {
 				// Race detector needs the copy so it can
@@ -1130,37 +1130,37 @@ func (o *Order) expr(n, lhs *ir.Node) *ir.Node {
 		}
 
 		// key must be addressable
-		n.Right = o.mapKeyTemp(n.Left.Type, n.Right)
+		n.SetRight(o.mapKeyTemp(n.Left().Type(), n.Right()))
 		if needCopy {
-			n = o.copyExpr(n, n.Type, false)
+			n = o.copyExpr(n, n.Type(), false)
 		}
 
 	// concrete type (not interface) argument might need an addressable
 	// temporary to pass to the runtime conversion routine.
 	case ir.OCONVIFACE:
-		n.Left = o.expr(n.Left, nil)
-		if n.Left.Type.IsInterface() {
+		n.SetLeft(o.expr(n.Left(), nil))
+		if n.Left().Type().IsInterface() {
 			break
 		}
-		if _, needsaddr := convFuncName(n.Left.Type, n.Type); needsaddr || isStaticCompositeLiteral(n.Left) {
+		if _, needsaddr := convFuncName(n.Left().Type(), n.Type()); needsaddr || isStaticCompositeLiteral(n.Left()) {
 			// Need a temp if we need to pass the address to the conversion function.
 			// We also process static composite literal node here, making a named static global
 			// whose address we can put directly in an interface (see OCONVIFACE case in walk).
-			n.Left = o.addrTemp(n.Left)
+			n.SetLeft(o.addrTemp(n.Left()))
 		}
 
 	case ir.OCONVNOP:
-		if n.Type.IsKind(types.TUNSAFEPTR) && n.Left.Type.IsKind(types.TUINTPTR) && (n.Left.Op == ir.OCALLFUNC || n.Left.Op == ir.OCALLINTER || n.Left.Op == ir.OCALLMETH) {
+		if n.Type().IsKind(types.TUNSAFEPTR) && n.Left().Type().IsKind(types.TUINTPTR) && (n.Left().Op() == ir.OCALLFUNC || n.Left().Op() == ir.OCALLINTER || n.Left().Op() == ir.OCALLMETH) {
 			// When reordering unsafe.Pointer(f()) into a separate
 			// statement, the conversion and function call must stay
 			// together. See golang.org/issue/15329.
-			o.init(n.Left)
-			o.call(n.Left)
-			if lhs == nil || lhs.Op != ir.ONAME || instrumenting {
-				n = o.copyExpr(n, n.Type, false)
+			o.init(n.Left())
+			o.call(n.Left())
+			if lhs == nil || lhs.Op() != ir.ONAME || instrumenting {
+				n = o.copyExpr(n, n.Type(), false)
 			}
 		} else {
-			n.Left = o.expr(n.Left, nil)
+			n.SetLeft(o.expr(n.Left(), nil))
 		}
 
 	case ir.OANDAND, ir.OOROR:
@@ -1173,10 +1173,10 @@ func (o *Order) expr(n, lhs *ir.Node) *ir.Node {
 		// }
 		// ... = r
 
-		r := o.newTemp(n.Type, false)
+		r := o.newTemp(n.Type(), false)
 
 		// Evaluate left-hand side.
-		lhs := o.expr(n.Left, nil)
+		lhs := o.expr(n.Left(), nil)
 		o.out = append(o.out, typecheck(ir.Nod(ir.OAS, r, lhs), ctxStmt))
 
 		// Evaluate right-hand side, save generated code.
@@ -1184,7 +1184,7 @@ func (o *Order) expr(n, lhs *ir.Node) *ir.Node {
 		o.out = nil
 		t := o.markTemp()
 		o.edge()
-		rhs := o.expr(n.Right, nil)
+		rhs := o.expr(n.Right(), nil)
 		o.out = append(o.out, typecheck(ir.Nod(ir.OAS, r, rhs), ctxStmt))
 		o.cleanTemp(t)
 		gen := o.out
@@ -1192,10 +1192,10 @@ func (o *Order) expr(n, lhs *ir.Node) *ir.Node {
 
 		// If left-hand side doesn't cause a short-circuit, issue right-hand side.
 		nif := ir.Nod(ir.OIF, r, nil)
-		if n.Op == ir.OANDAND {
-			nif.Nbody.Set(gen)
+		if n.Op() == ir.OANDAND {
+			nif.PtrBody().Set(gen)
 		} else {
-			nif.Rlist.Set(gen)
+			nif.PtrRlist().Set(gen)
 		}
 		o.out = append(o.out, nif)
 		n = r
@@ -1221,30 +1221,30 @@ func (o *Order) expr(n, lhs *ir.Node) *ir.Node {
 
 		if isRuneCount(n) {
 			// len([]rune(s)) is rewritten to runtime.countrunes(s) later.
-			n.Left.Left = o.expr(n.Left.Left, nil)
+			n.Left().SetLeft(o.expr(n.Left().Left(), nil))
 		} else {
 			o.call(n)
 		}
 
-		if lhs == nil || lhs.Op != ir.ONAME || instrumenting {
-			n = o.copyExpr(n, n.Type, false)
+		if lhs == nil || lhs.Op() != ir.ONAME || instrumenting {
+			n = o.copyExpr(n, n.Type(), false)
 		}
 
 	case ir.OAPPEND:
 		// Check for append(x, make([]T, y)...) .
 		if isAppendOfMake(n) {
-			n.List.SetFirst(o.expr(n.List.First(), nil))             // order x
-			n.List.Second().Left = o.expr(n.List.Second().Left, nil) // order y
+			n.List().SetFirst(o.expr(n.List().First(), nil))                 // order x
+			n.List().Second().SetLeft(o.expr(n.List().Second().Left(), nil)) // order y
 		} else {
-			o.exprList(n.List)
+			o.exprList(n.List())
 		}
 
-		if lhs == nil || lhs.Op != ir.ONAME && !samesafeexpr(lhs, n.List.First()) {
-			n = o.copyExpr(n, n.Type, false)
+		if lhs == nil || lhs.Op() != ir.ONAME && !samesafeexpr(lhs, n.List().First()) {
+			n = o.copyExpr(n, n.Type(), false)
 		}
 
 	case ir.OSLICE, ir.OSLICEARR, ir.OSLICESTR, ir.OSLICE3, ir.OSLICE3ARR:
-		n.Left = o.expr(n.Left, nil)
+		n.SetLeft(o.expr(n.Left(), nil))
 		low, high, max := n.SliceBounds()
 		low = o.expr(low, nil)
 		low = o.cheapExpr(low)
@@ -1253,25 +1253,25 @@ func (o *Order) expr(n, lhs *ir.Node) *ir.Node {
 		max = o.expr(max, nil)
 		max = o.cheapExpr(max)
 		n.SetSliceBounds(low, high, max)
-		if lhs == nil || lhs.Op != ir.ONAME && !samesafeexpr(lhs, n.Left) {
-			n = o.copyExpr(n, n.Type, false)
+		if lhs == nil || lhs.Op() != ir.ONAME && !samesafeexpr(lhs, n.Left()) {
+			n = o.copyExpr(n, n.Type(), false)
 		}
 
 	case ir.OCLOSURE:
-		if n.Transient() && n.Func.ClosureVars.Len() > 0 {
+		if n.Transient() && n.Func().ClosureVars.Len() > 0 {
 			prealloc[n] = o.newTemp(closureType(n), false)
 		}
 
 	case ir.OSLICELIT, ir.OCALLPART:
-		n.Left = o.expr(n.Left, nil)
-		n.Right = o.expr(n.Right, nil)
-		o.exprList(n.List)
-		o.exprList(n.Rlist)
+		n.SetLeft(o.expr(n.Left(), nil))
+		n.SetRight(o.expr(n.Right(), nil))
+		o.exprList(n.List())
+		o.exprList(n.Rlist())
 		if n.Transient() {
 			var t *types.Type
-			switch n.Op {
+			switch n.Op() {
 			case ir.OSLICELIT:
-				t = types.NewArray(n.Type.Elem(), n.Right.Int64Val())
+				t = types.NewArray(n.Type().Elem(), n.Right().Int64Val())
 			case ir.OCALLPART:
 				t = partialCallType(n)
 			}
@@ -1279,37 +1279,37 @@ func (o *Order) expr(n, lhs *ir.Node) *ir.Node {
 		}
 
 	case ir.ODOTTYPE, ir.ODOTTYPE2:
-		n.Left = o.expr(n.Left, nil)
-		if !isdirectiface(n.Type) || instrumenting {
-			n = o.copyExpr(n, n.Type, true)
+		n.SetLeft(o.expr(n.Left(), nil))
+		if !isdirectiface(n.Type()) || instrumenting {
+			n = o.copyExpr(n, n.Type(), true)
 		}
 
 	case ir.ORECV:
-		n.Left = o.expr(n.Left, nil)
-		n = o.copyExpr(n, n.Type, true)
+		n.SetLeft(o.expr(n.Left(), nil))
+		n = o.copyExpr(n, n.Type(), true)
 
 	case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
-		n.Left = o.expr(n.Left, nil)
-		n.Right = o.expr(n.Right, nil)
+		n.SetLeft(o.expr(n.Left(), nil))
+		n.SetRight(o.expr(n.Right(), nil))
 
-		t := n.Left.Type
+		t := n.Left().Type()
 		switch {
 		case t.IsString():
 			// Mark string(byteSlice) arguments to reuse byteSlice backing
 			// buffer during conversion. String comparison does not
 			// memorize the strings for later use, so it is safe.
-			if n.Left.Op == ir.OBYTES2STR {
-				n.Left.Op = ir.OBYTES2STRTMP
+			if n.Left().Op() == ir.OBYTES2STR {
+				n.Left().SetOp(ir.OBYTES2STRTMP)
 			}
-			if n.Right.Op == ir.OBYTES2STR {
-				n.Right.Op = ir.OBYTES2STRTMP
+			if n.Right().Op() == ir.OBYTES2STR {
+				n.Right().SetOp(ir.OBYTES2STRTMP)
 			}
 
 		case t.IsStruct() || t.IsArray():
 			// for complex comparisons, we need both args to be
 			// addressable so we can pass them to the runtime.
-			n.Left = o.addrTemp(n.Left)
-			n.Right = o.addrTemp(n.Right)
+			n.SetLeft(o.addrTemp(n.Left()))
+			n.SetRight(o.addrTemp(n.Right()))
 		}
 	case ir.OMAPLIT:
 		// Order map by converting:
@@ -1327,15 +1327,15 @@ func (o *Order) expr(n, lhs *ir.Node) *ir.Node {
 		// Without this special case, order would otherwise compute all
 		// the keys and values before storing any of them to the map.
 		// See issue 26552.
-		entries := n.List.Slice()
+		entries := n.List().Slice()
 		statics := entries[:0]
 		var dynamics []*ir.Node
 		for _, r := range entries {
-			if r.Op != ir.OKEY {
+			if r.Op() != ir.OKEY {
 				base.Fatalf("OMAPLIT entry not OKEY: %v\n", r)
 			}
 
-			if !isStaticCompositeLiteral(r.Left) || !isStaticCompositeLiteral(r.Right) {
+			if !isStaticCompositeLiteral(r.Left()) || !isStaticCompositeLiteral(r.Right()) {
 				dynamics = append(dynamics, r)
 				continue
 			}
@@ -1343,21 +1343,21 @@ func (o *Order) expr(n, lhs *ir.Node) *ir.Node {
 			// Recursively ordering some static entries can change them to dynamic;
 			// e.g., OCONVIFACE nodes. See #31777.
 			r = o.expr(r, nil)
-			if !isStaticCompositeLiteral(r.Left) || !isStaticCompositeLiteral(r.Right) {
+			if !isStaticCompositeLiteral(r.Left()) || !isStaticCompositeLiteral(r.Right()) {
 				dynamics = append(dynamics, r)
 				continue
 			}
 
 			statics = append(statics, r)
 		}
-		n.List.Set(statics)
+		n.PtrList().Set(statics)
 
 		if len(dynamics) == 0 {
 			break
 		}
 
 		// Emit the creation of the map (with all its static entries).
-		m := o.newTemp(n.Type, false)
+		m := o.newTemp(n.Type(), false)
 		as := ir.Nod(ir.OAS, m, n)
 		typecheck(as, ctxStmt)
 		o.stmt(as)
@@ -1365,7 +1365,7 @@ func (o *Order) expr(n, lhs *ir.Node) *ir.Node {
 
 		// Emit eval+insert of dynamic entries, one at a time.
 		for _, r := range dynamics {
-			as := ir.Nod(ir.OAS, ir.Nod(ir.OINDEX, n, r.Left), r.Right)
+			as := ir.Nod(ir.OAS, ir.Nod(ir.OINDEX, n, r.Left()), r.Right())
 			typecheck(as, ctxStmt) // Note: this converts the OINDEX to an OINDEXMAP
 			o.stmt(as)
 		}
@@ -1379,7 +1379,7 @@ func (o *Order) expr(n, lhs *ir.Node) *ir.Node {
 // including an explicit conversion if necessary.
 func okas(ok, val *ir.Node) *ir.Node {
 	if !ir.IsBlank(ok) {
-		val = conv(val, ok.Type)
+		val = conv(val, ok.Type())
 	}
 	return ir.Nod(ir.OAS, ok, val)
 }
@@ -1395,10 +1395,10 @@ func okas(ok, val *ir.Node) *ir.Node {
 func (o *Order) as2(n *ir.Node) {
 	tmplist := []*ir.Node{}
 	left := []*ir.Node{}
-	for ni, l := range n.List.Slice() {
+	for ni, l := range n.List().Slice() {
 		if !ir.IsBlank(l) {
-			tmp := o.newTemp(l.Type, l.Type.HasPointers())
-			n.List.SetIndex(ni, tmp)
+			tmp := o.newTemp(l.Type(), l.Type().HasPointers())
+			n.List().SetIndex(ni, tmp)
 			tmplist = append(tmplist, tmp)
 			left = append(left, l)
 		}
@@ -1407,8 +1407,8 @@ func (o *Order) as2(n *ir.Node) {
 	o.out = append(o.out, n)
 
 	as := ir.Nod(ir.OAS2, nil, nil)
-	as.List.Set(left)
-	as.Rlist.Set(tmplist)
+	as.PtrList().Set(left)
+	as.PtrRlist().Set(tmplist)
 	as = typecheck(as, ctxStmt)
 	o.stmt(as)
 }
@@ -1417,27 +1417,27 @@ func (o *Order) as2(n *ir.Node) {
 // Just like as2, this also adds temporaries to ensure left-to-right assignment.
 func (o *Order) okAs2(n *ir.Node) {
 	var tmp1, tmp2 *ir.Node
-	if !ir.IsBlank(n.List.First()) {
-		typ := n.Right.Type
+	if !ir.IsBlank(n.List().First()) {
+		typ := n.Right().Type()
 		tmp1 = o.newTemp(typ, typ.HasPointers())
 	}
 
-	if !ir.IsBlank(n.List.Second()) {
+	if !ir.IsBlank(n.List().Second()) {
 		tmp2 = o.newTemp(types.Types[types.TBOOL], false)
 	}
 
 	o.out = append(o.out, n)
 
 	if tmp1 != nil {
-		r := ir.Nod(ir.OAS, n.List.First(), tmp1)
+		r := ir.Nod(ir.OAS, n.List().First(), tmp1)
 		r = typecheck(r, ctxStmt)
 		o.mapAssign(r)
-		n.List.SetFirst(tmp1)
+		n.List().SetFirst(tmp1)
 	}
 	if tmp2 != nil {
-		r := okas(n.List.Second(), tmp2)
+		r := okas(n.List().Second(), tmp2)
 		r = typecheck(r, ctxStmt)
 		o.mapAssign(r)
-		n.List.SetSecond(tmp2)
+		n.List().SetSecond(tmp2)
 	}
 }
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index 6e7922ca54..5827b5a7a6 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -28,30 +28,30 @@ var (
 )
 
 func emitptrargsmap(fn *ir.Node) {
-	if ir.FuncName(fn) == "_" || fn.Func.Nname.Sym.Linkname != "" {
+	if ir.FuncName(fn) == "_" || fn.Func().Nname.Sym().Linkname != "" {
 		return
 	}
-	lsym := base.Ctxt.Lookup(fn.Func.LSym.Name + ".args_stackmap")
+	lsym := base.Ctxt.Lookup(fn.Func().LSym.Name + ".args_stackmap")
 
-	nptr := int(fn.Type.ArgWidth() / int64(Widthptr))
+	nptr := int(fn.Type().ArgWidth() / int64(Widthptr))
 	bv := bvalloc(int32(nptr) * 2)
 	nbitmap := 1
-	if fn.Type.NumResults() > 0 {
+	if fn.Type().NumResults() > 0 {
 		nbitmap = 2
 	}
 	off := duint32(lsym, 0, uint32(nbitmap))
 	off = duint32(lsym, off, uint32(bv.n))
 
 	if ir.IsMethod(fn) {
-		onebitwalktype1(fn.Type.Recvs(), 0, bv)
+		onebitwalktype1(fn.Type().Recvs(), 0, bv)
 	}
-	if fn.Type.NumParams() > 0 {
-		onebitwalktype1(fn.Type.Params(), 0, bv)
+	if fn.Type().NumParams() > 0 {
+		onebitwalktype1(fn.Type().Params(), 0, bv)
 	}
 	off = dbvec(lsym, off, bv)
 
-	if fn.Type.NumResults() > 0 {
-		onebitwalktype1(fn.Type.Results(), 0, bv)
+	if fn.Type().NumResults() > 0 {
+		onebitwalktype1(fn.Type().Results(), 0, bv)
 		off = dbvec(lsym, off, bv)
 	}
 
@@ -74,30 +74,30 @@ func cmpstackvarlt(a, b *ir.Node) bool {
 	}
 
 	if a.Class() != ir.PAUTO {
-		return a.Xoffset < b.Xoffset
+		return a.Offset() < b.Offset()
 	}
 
-	if a.Name.Used() != b.Name.Used() {
-		return a.Name.Used()
+	if a.Name().Used() != b.Name().Used() {
+		return a.Name().Used()
 	}
 
-	ap := a.Type.HasPointers()
-	bp := b.Type.HasPointers()
+	ap := a.Type().HasPointers()
+	bp := b.Type().HasPointers()
 	if ap != bp {
 		return ap
 	}
 
-	ap = a.Name.Needzero()
-	bp = b.Name.Needzero()
+	ap = a.Name().Needzero()
+	bp = b.Name().Needzero()
 	if ap != bp {
 		return ap
 	}
 
-	if a.Type.Width != b.Type.Width {
-		return a.Type.Width > b.Type.Width
+	if a.Type().Width != b.Type().Width {
+		return a.Type().Width > b.Type().Width
 	}
 
-	return a.Sym.Name < b.Sym.Name
+	return a.Sym().Name < b.Sym().Name
 }
 
 // byStackvar implements sort.Interface for []*Node using cmpstackvarlt.
@@ -110,18 +110,18 @@ func (s byStackVar) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 func (s *ssafn) AllocFrame(f *ssa.Func) {
 	s.stksize = 0
 	s.stkptrsize = 0
-	fn := s.curfn.Func
+	fn := s.curfn.Func()
 
 	// Mark the PAUTO's unused.
 	for _, ln := range fn.Dcl {
 		if ln.Class() == ir.PAUTO {
-			ln.Name.SetUsed(false)
+			ln.Name().SetUsed(false)
 		}
 	}
 
 	for _, l := range f.RegAlloc {
 		if ls, ok := l.(ssa.LocalSlot); ok {
-			ls.N.Name.SetUsed(true)
+			ls.N.Name().SetUsed(true)
 		}
 	}
 
@@ -133,10 +133,10 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 				case ir.PPARAM, ir.PPARAMOUT:
 					// Don't modify nodfp; it is a global.
 					if n != nodfp {
-						n.Name.SetUsed(true)
+						n.Name().SetUsed(true)
 					}
 				case ir.PAUTO:
-					n.Name.SetUsed(true)
+					n.Name().SetUsed(true)
 				}
 			}
 			if !scratchUsed {
@@ -155,16 +155,16 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 	// Reassign stack offsets of the locals that are used.
 	lastHasPtr := false
 	for i, n := range fn.Dcl {
-		if n.Op != ir.ONAME || n.Class() != ir.PAUTO {
+		if n.Op() != ir.ONAME || n.Class() != ir.PAUTO {
 			continue
 		}
-		if !n.Name.Used() {
+		if !n.Name().Used() {
 			fn.Dcl = fn.Dcl[:i]
 			break
 		}
 
-		dowidth(n.Type)
-		w := n.Type.Width
+		dowidth(n.Type())
+		w := n.Type().Width
 		if w >= thearch.MAXWIDTH || w < 0 {
 			base.Fatalf("bad width")
 		}
@@ -176,8 +176,8 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 			w = 1
 		}
 		s.stksize += w
-		s.stksize = Rnd(s.stksize, int64(n.Type.Align))
-		if n.Type.HasPointers() {
+		s.stksize = Rnd(s.stksize, int64(n.Type().Align))
+		if n.Type().HasPointers() {
 			s.stkptrsize = s.stksize
 			lastHasPtr = true
 		} else {
@@ -186,7 +186,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 		if thearch.LinkArch.InFamily(sys.MIPS, sys.MIPS64, sys.ARM, sys.ARM64, sys.PPC64, sys.S390X) {
 			s.stksize = Rnd(s.stksize, int64(Widthptr))
 		}
-		n.Xoffset = -s.stksize
+		n.SetOffset(-s.stksize)
 	}
 
 	s.stksize = Rnd(s.stksize, int64(Widthreg))
@@ -195,10 +195,10 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 
 func funccompile(fn *ir.Node) {
 	if Curfn != nil {
-		base.Fatalf("funccompile %v inside %v", fn.Func.Nname.Sym, Curfn.Func.Nname.Sym)
+		base.Fatalf("funccompile %v inside %v", fn.Func().Nname.Sym(), Curfn.Func().Nname.Sym())
 	}
 
-	if fn.Type == nil {
+	if fn.Type() == nil {
 		if base.Errors() == 0 {
 			base.Fatalf("funccompile missing type")
 		}
@@ -206,11 +206,11 @@ func funccompile(fn *ir.Node) {
 	}
 
 	// assign parameter offsets
-	dowidth(fn.Type)
+	dowidth(fn.Type())
 
-	if fn.Nbody.Len() == 0 {
+	if fn.Body().Len() == 0 {
 		// Initialize ABI wrappers if necessary.
-		initLSym(fn.Func, false)
+		initLSym(fn.Func(), false)
 		emitptrargsmap(fn)
 		return
 	}
@@ -234,7 +234,7 @@ func compile(fn *ir.Node) {
 	// Set up the function's LSym early to avoid data races with the assemblers.
 	// Do this before walk, as walk needs the LSym to set attributes/relocations
 	// (e.g. in markTypeUsedInInterface).
-	initLSym(fn.Func, true)
+	initLSym(fn.Func(), true)
 
 	walk(fn)
 	if base.Errors() > errorsBefore {
@@ -259,15 +259,15 @@ func compile(fn *ir.Node) {
 	// be types of stack objects. We need to do this here
 	// because symbols must be allocated before the parallel
 	// phase of the compiler.
-	for _, n := range fn.Func.Dcl {
+	for _, n := range fn.Func().Dcl {
 		switch n.Class() {
 		case ir.PPARAM, ir.PPARAMOUT, ir.PAUTO:
-			if livenessShouldTrack(n) && n.Name.Addrtaken() {
-				dtypesym(n.Type)
+			if livenessShouldTrack(n) && n.Name().Addrtaken() {
+				dtypesym(n.Type())
 				// Also make sure we allocate a linker symbol
 				// for the stack object data, for the same reason.
-				if fn.Func.LSym.Func().StackObjects == nil {
-					fn.Func.LSym.Func().StackObjects = base.Ctxt.Lookup(fn.Func.LSym.Name + ".stkobj")
+				if fn.Func().LSym.Func().StackObjects == nil {
+					fn.Func().LSym.Func().StackObjects = base.Ctxt.Lookup(fn.Func().LSym.Name + ".stkobj")
 				}
 			}
 		}
@@ -300,13 +300,13 @@ func compilenow(fn *ir.Node) bool {
 // inline candidate but then never inlined (presumably because we
 // found no call sites).
 func isInlinableButNotInlined(fn *ir.Node) bool {
-	if fn.Func.Nname.Func.Inl == nil {
+	if fn.Func().Nname.Func().Inl == nil {
 		return false
 	}
-	if fn.Sym == nil {
+	if fn.Sym() == nil {
 		return true
 	}
-	return !fn.Sym.Linksym().WasInlined()
+	return !fn.Sym().Linksym().WasInlined()
 }
 
 const maxStackSize = 1 << 30
@@ -318,9 +318,9 @@ const maxStackSize = 1 << 30
 func compileSSA(fn *ir.Node, worker int) {
 	f := buildssa(fn, worker)
 	// Note: check arg size to fix issue 25507.
-	if f.Frontend().(*ssafn).stksize >= maxStackSize || fn.Type.ArgWidth() >= maxStackSize {
+	if f.Frontend().(*ssafn).stksize >= maxStackSize || fn.Type().ArgWidth() >= maxStackSize {
 		largeStackFramesMu.Lock()
-		largeStackFrames = append(largeStackFrames, largeStack{locals: f.Frontend().(*ssafn).stksize, args: fn.Type.ArgWidth(), pos: fn.Pos})
+		largeStackFrames = append(largeStackFrames, largeStack{locals: f.Frontend().(*ssafn).stksize, args: fn.Type().ArgWidth(), pos: fn.Pos()})
 		largeStackFramesMu.Unlock()
 		return
 	}
@@ -336,14 +336,14 @@ func compileSSA(fn *ir.Node, worker int) {
 	if pp.Text.To.Offset >= maxStackSize {
 		largeStackFramesMu.Lock()
 		locals := f.Frontend().(*ssafn).stksize
-		largeStackFrames = append(largeStackFrames, largeStack{locals: locals, args: fn.Type.ArgWidth(), callee: pp.Text.To.Offset - locals, pos: fn.Pos})
+		largeStackFrames = append(largeStackFrames, largeStack{locals: locals, args: fn.Type().ArgWidth(), callee: pp.Text.To.Offset - locals, pos: fn.Pos()})
 		largeStackFramesMu.Unlock()
 		return
 	}
 
 	pp.Flush() // assemble, fill in boilerplate, etc.
 	// fieldtrack must be called after pp.Flush. See issue 20014.
-	fieldtrack(pp.Text.From.Sym, fn.Func.FieldTrack)
+	fieldtrack(pp.Text.From.Sym, fn.Func().FieldTrack)
 }
 
 func init() {
@@ -371,7 +371,7 @@ func compileFunctions() {
 			// since they're most likely to be the slowest.
 			// This helps avoid stragglers.
 			sort.Slice(compilequeue, func(i, j int) bool {
-				return compilequeue[i].Nbody.Len() > compilequeue[j].Nbody.Len()
+				return compilequeue[i].Body().Len() > compilequeue[j].Body().Len()
 			})
 		}
 		var wg sync.WaitGroup
@@ -399,8 +399,8 @@ func compileFunctions() {
 
 func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.Scope, dwarf.InlCalls) {
 	fn := curfn.(*ir.Node)
-	if fn.Func.Nname != nil {
-		if expect := fn.Func.Nname.Sym.Linksym(); fnsym != expect {
+	if fn.Func().Nname != nil {
+		if expect := fn.Func().Nname.Sym().Linksym(); fnsym != expect {
 			base.Fatalf("unexpected fnsym: %v != %v", fnsym, expect)
 		}
 	}
@@ -430,18 +430,18 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 	//
 	// These two adjustments keep toolstash -cmp working for now.
 	// Deciding the right answer is, as they say, future work.
-	isODCLFUNC := fn.Op == ir.ODCLFUNC
+	isODCLFUNC := fn.Op() == ir.ODCLFUNC
 
 	var apdecls []*ir.Node
 	// Populate decls for fn.
 	if isODCLFUNC {
-		for _, n := range fn.Func.Dcl {
-			if n.Op != ir.ONAME { // might be OTYPE or OLITERAL
+		for _, n := range fn.Func().Dcl {
+			if n.Op() != ir.ONAME { // might be OTYPE or OLITERAL
 				continue
 			}
 			switch n.Class() {
 			case ir.PAUTO:
-				if !n.Name.Used() {
+				if !n.Name().Used() {
 					// Text == nil -> generating abstract function
 					if fnsym.Func().Text != nil {
 						base.Fatalf("debuginfo unused node (AllocFrame should truncate fn.Func.Dcl)")
@@ -457,7 +457,7 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 		}
 	}
 
-	decls, dwarfVars := createDwarfVars(fnsym, isODCLFUNC, fn.Func, apdecls)
+	decls, dwarfVars := createDwarfVars(fnsym, isODCLFUNC, fn.Func(), apdecls)
 
 	// For each type referenced by the functions auto vars but not
 	// already referenced by a dwarf var, attach an R_USETYPE relocation to
@@ -478,7 +478,7 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 	var varScopes []ir.ScopeID
 	for _, decl := range decls {
 		pos := declPos(decl)
-		varScopes = append(varScopes, findScope(fn.Func.Marks, pos))
+		varScopes = append(varScopes, findScope(fn.Func().Marks, pos))
 	}
 
 	scopes := assembleScopes(fnsym, fn, dwarfVars, varScopes)
@@ -490,7 +490,7 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 }
 
 func declPos(decl *ir.Node) src.XPos {
-	if decl.Name.Defn != nil && (decl.Name.Captured() || decl.Name.Byval()) {
+	if decl.Name().Defn != nil && (decl.Name().Captured() || decl.Name().Byval()) {
 		// It's not clear which position is correct for captured variables here:
 		// * decl.Pos is the wrong position for captured variables, in the inner
 		//   function, but it is the right position in the outer function.
@@ -505,9 +505,9 @@ func declPos(decl *ir.Node) src.XPos {
 		//   case statement.
 		// This code is probably wrong for type switch variables that are also
 		// captured.
-		return decl.Name.Defn.Pos
+		return decl.Name().Defn.Pos()
 	}
-	return decl.Pos
+	return decl.Pos()
 }
 
 // createSimpleVars creates a DWARF entry for every variable declared in the
@@ -530,7 +530,7 @@ func createSimpleVars(fnsym *obj.LSym, apDecls []*ir.Node) ([]*ir.Node, []*dwarf
 
 func createSimpleVar(fnsym *obj.LSym, n *ir.Node) *dwarf.Var {
 	var abbrev int
-	offs := n.Xoffset
+	offs := n.Offset()
 
 	switch n.Class() {
 	case ir.PAUTO:
@@ -550,22 +550,22 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Node) *dwarf.Var {
 		base.Fatalf("createSimpleVar unexpected class %v for node %v", n.Class(), n)
 	}
 
-	typename := dwarf.InfoPrefix + typesymname(n.Type)
+	typename := dwarf.InfoPrefix + typesymname(n.Type())
 	delete(fnsym.Func().Autot, ngotype(n).Linksym())
 	inlIndex := 0
 	if base.Flag.GenDwarfInl > 1 {
-		if n.Name.InlFormal() || n.Name.InlLocal() {
-			inlIndex = posInlIndex(n.Pos) + 1
-			if n.Name.InlFormal() {
+		if n.Name().InlFormal() || n.Name().InlLocal() {
+			inlIndex = posInlIndex(n.Pos()) + 1
+			if n.Name().InlFormal() {
 				abbrev = dwarf.DW_ABRV_PARAM
 			}
 		}
 	}
 	declpos := base.Ctxt.InnermostPos(declPos(n))
 	return &dwarf.Var{
-		Name:          n.Sym.Name,
+		Name:          n.Sym().Name,
 		IsReturnValue: n.Class() == ir.PPARAMOUT,
-		IsInlFormal:   n.Name.InlFormal(),
+		IsInlFormal:   n.Name().InlFormal(),
 		Abbrev:        abbrev,
 		StackOffset:   int32(offs),
 		Type:          base.Ctxt.Lookup(typename),
@@ -637,11 +637,11 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 		if _, found := selected[n]; found {
 			continue
 		}
-		c := n.Sym.Name[0]
-		if c == '.' || n.Type.IsUntyped() {
+		c := n.Sym().Name[0]
+		if c == '.' || n.Type().IsUntyped() {
 			continue
 		}
-		if n.Class() == ir.PPARAM && !canSSAType(n.Type) {
+		if n.Class() == ir.PPARAM && !canSSAType(n.Type()) {
 			// SSA-able args get location lists, and may move in and
 			// out of registers, so those are handled elsewhere.
 			// Autos and named output params seem to get handled
@@ -653,7 +653,7 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 			decls = append(decls, n)
 			continue
 		}
-		typename := dwarf.InfoPrefix + typesymname(n.Type)
+		typename := dwarf.InfoPrefix + typesymname(n.Type())
 		decls = append(decls, n)
 		abbrev := dwarf.DW_ABRV_AUTO_LOCLIST
 		isReturnValue := (n.Class() == ir.PPARAMOUT)
@@ -667,7 +667,7 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 			// misleading location for the param (we want pointer-to-heap
 			// and not stack).
 			// TODO(thanm): generate a better location expression
-			stackcopy := n.Name.Param.Stackcopy
+			stackcopy := n.Name().Param.Stackcopy
 			if stackcopy != nil && (stackcopy.Class() == ir.PPARAM || stackcopy.Class() == ir.PPARAMOUT) {
 				abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
 				isReturnValue = (stackcopy.Class() == ir.PPARAMOUT)
@@ -675,19 +675,19 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 		}
 		inlIndex := 0
 		if base.Flag.GenDwarfInl > 1 {
-			if n.Name.InlFormal() || n.Name.InlLocal() {
-				inlIndex = posInlIndex(n.Pos) + 1
-				if n.Name.InlFormal() {
+			if n.Name().InlFormal() || n.Name().InlLocal() {
+				inlIndex = posInlIndex(n.Pos()) + 1
+				if n.Name().InlFormal() {
 					abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
 				}
 			}
 		}
-		declpos := base.Ctxt.InnermostPos(n.Pos)
+		declpos := base.Ctxt.InnermostPos(n.Pos())
 		vars = append(vars, &dwarf.Var{
-			Name:          n.Sym.Name,
+			Name:          n.Sym().Name,
 			IsReturnValue: isReturnValue,
 			Abbrev:        abbrev,
-			StackOffset:   int32(n.Xoffset),
+			StackOffset:   int32(n.Offset()),
 			Type:          base.Ctxt.Lookup(typename),
 			DeclFile:      declpos.RelFilename(),
 			DeclLine:      declpos.RelLine(),
@@ -711,11 +711,11 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 func preInliningDcls(fnsym *obj.LSym) []*ir.Node {
 	fn := base.Ctxt.DwFixups.GetPrecursorFunc(fnsym).(*ir.Node)
 	var rdcl []*ir.Node
-	for _, n := range fn.Func.Inl.Dcl {
-		c := n.Sym.Name[0]
+	for _, n := range fn.Func().Inl.Dcl {
+		c := n.Sym().Name[0]
 		// Avoid reporting "_" parameters, since if there are more than
 		// one, it can result in a collision later on, as in #23179.
-		if unversion(n.Sym.Name) == "_" || c == '.' || n.Type.IsUntyped() {
+		if unversion(n.Sym().Name) == "_" || c == '.' || n.Type().IsUntyped() {
 			continue
 		}
 		rdcl = append(rdcl, n)
@@ -741,7 +741,7 @@ func stackOffset(slot ssa.LocalSlot) int32 {
 	case ir.PPARAM, ir.PPARAMOUT:
 		off += base.Ctxt.FixedFrameSize()
 	}
-	return int32(off + n.Xoffset + slot.Off)
+	return int32(off + n.Offset() + slot.Off)
 }
 
 // createComplexVar builds a single DWARF variable entry and location list.
@@ -764,18 +764,18 @@ func createComplexVar(fnsym *obj.LSym, fn *ir.Func, varID ssa.VarID) *dwarf.Var
 	typename := dwarf.InfoPrefix + gotype.Name[len("type."):]
 	inlIndex := 0
 	if base.Flag.GenDwarfInl > 1 {
-		if n.Name.InlFormal() || n.Name.InlLocal() {
-			inlIndex = posInlIndex(n.Pos) + 1
-			if n.Name.InlFormal() {
+		if n.Name().InlFormal() || n.Name().InlLocal() {
+			inlIndex = posInlIndex(n.Pos()) + 1
+			if n.Name().InlFormal() {
 				abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
 			}
 		}
 	}
-	declpos := base.Ctxt.InnermostPos(n.Pos)
+	declpos := base.Ctxt.InnermostPos(n.Pos())
 	dvar := &dwarf.Var{
-		Name:          n.Sym.Name,
+		Name:          n.Sym().Name,
 		IsReturnValue: n.Class() == ir.PPARAMOUT,
-		IsInlFormal:   n.Name.InlFormal(),
+		IsInlFormal:   n.Name().InlFormal(),
 		Abbrev:        abbrev,
 		Type:          base.Ctxt.Lookup(typename),
 		// The stack offset is used as a sorting key, so for decomposed
diff --git a/src/cmd/compile/internal/gc/pgen_test.go b/src/cmd/compile/internal/gc/pgen_test.go
index 9f1f00d46a..efdffe0256 100644
--- a/src/cmd/compile/internal/gc/pgen_test.go
+++ b/src/cmd/compile/internal/gc/pgen_test.go
@@ -27,12 +27,12 @@ func typeWithPointers() *types.Type {
 }
 
 func markUsed(n *ir.Node) *ir.Node {
-	n.Name.SetUsed(true)
+	n.Name().SetUsed(true)
 	return n
 }
 
 func markNeedZero(n *ir.Node) *ir.Node {
-	n.Name.SetNeedzero(true)
+	n.Name().SetNeedzero(true)
 	return n
 }
 
@@ -43,8 +43,8 @@ func TestCmpstackvar(t *testing.T) {
 			s = &types.Sym{Name: "."}
 		}
 		n := NewName(s)
-		n.Type = t
-		n.Xoffset = xoffset
+		n.SetType(t)
+		n.SetOffset(xoffset)
 		n.SetClass(cl)
 		return n
 	}
@@ -158,8 +158,8 @@ func TestCmpstackvar(t *testing.T) {
 func TestStackvarSort(t *testing.T) {
 	nod := func(xoffset int64, t *types.Type, s *types.Sym, cl ir.Class) *ir.Node {
 		n := NewName(s)
-		n.Type = t
-		n.Xoffset = xoffset
+		n.SetType(t)
+		n.SetOffset(xoffset)
 		n.SetClass(cl)
 		return n
 	}
diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/gc/plive.go
index f089588466..c1e523f7a0 100644
--- a/src/cmd/compile/internal/gc/plive.go
+++ b/src/cmd/compile/internal/gc/plive.go
@@ -207,14 +207,14 @@ type progeffectscache struct {
 // nor do we care about empty structs (handled by the pointer check),
 // nor do we care about the fake PAUTOHEAP variables.
 func livenessShouldTrack(n *ir.Node) bool {
-	return n.Op == ir.ONAME && (n.Class() == ir.PAUTO || n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT) && n.Type.HasPointers()
+	return n.Op() == ir.ONAME && (n.Class() == ir.PAUTO || n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT) && n.Type().HasPointers()
 }
 
 // getvariables returns the list of on-stack variables that we need to track
 // and a map for looking up indices by *Node.
 func getvariables(fn *ir.Node) ([]*ir.Node, map[*ir.Node]int32) {
 	var vars []*ir.Node
-	for _, n := range fn.Func.Dcl {
+	for _, n := range fn.Func().Dcl {
 		if livenessShouldTrack(n) {
 			vars = append(vars, n)
 		}
@@ -272,7 +272,7 @@ const (
 // If v does not affect any tracked variables, it returns -1, 0.
 func (lv *Liveness) valueEffects(v *ssa.Value) (int32, liveEffect) {
 	n, e := affectedNode(v)
-	if e == 0 || n == nil || n.Op != ir.ONAME { // cheapest checks first
+	if e == 0 || n == nil || n.Op() != ir.ONAME { // cheapest checks first
 		return -1, 0
 	}
 
@@ -282,7 +282,7 @@ func (lv *Liveness) valueEffects(v *ssa.Value) (int32, liveEffect) {
 	// variable" ICEs (issue 19632).
 	switch v.Op {
 	case ssa.OpVarDef, ssa.OpVarKill, ssa.OpVarLive, ssa.OpKeepAlive:
-		if !n.Name.Used() {
+		if !n.Name().Used() {
 			return -1, 0
 		}
 	}
@@ -297,7 +297,7 @@ func (lv *Liveness) valueEffects(v *ssa.Value) (int32, liveEffect) {
 	if e&(ssa.SymRead|ssa.SymAddr) != 0 {
 		effect |= uevar
 	}
-	if e&ssa.SymWrite != 0 && (!isfat(n.Type) || v.Op == ssa.OpVarDef) {
+	if e&ssa.SymWrite != 0 && (!isfat(n.Type()) || v.Op == ssa.OpVarDef) {
 		effect |= varkill
 	}
 
@@ -491,10 +491,10 @@ func (lv *Liveness) pointerMap(liveout bvec, vars []*ir.Node, args, locals bvec)
 		node := vars[i]
 		switch node.Class() {
 		case ir.PAUTO:
-			onebitwalktype1(node.Type, node.Xoffset+lv.stkptrsize, locals)
+			onebitwalktype1(node.Type(), node.Offset()+lv.stkptrsize, locals)
 
 		case ir.PPARAM, ir.PPARAMOUT:
-			onebitwalktype1(node.Type, node.Xoffset, args)
+			onebitwalktype1(node.Type(), node.Offset(), args)
 		}
 	}
 }
@@ -788,14 +788,14 @@ func (lv *Liveness) epilogue() {
 	// pointers to copy values back to the stack).
 	// TODO: if the output parameter is heap-allocated, then we
 	// don't need to keep the stack copy live?
-	if lv.fn.Func.HasDefer() {
+	if lv.fn.Func().HasDefer() {
 		for i, n := range lv.vars {
 			if n.Class() == ir.PPARAMOUT {
-				if n.Name.IsOutputParamHeapAddr() {
+				if n.Name().IsOutputParamHeapAddr() {
 					// Just to be paranoid.  Heap addresses are PAUTOs.
 					base.Fatalf("variable %v both output param and heap output param", n)
 				}
-				if n.Name.Param.Heapaddr != nil {
+				if n.Name().Param.Heapaddr != nil {
 					// If this variable moved to the heap, then
 					// its stack copy is not live.
 					continue
@@ -803,21 +803,21 @@ func (lv *Liveness) epilogue() {
 				// Note: zeroing is handled by zeroResults in walk.go.
 				livedefer.Set(int32(i))
 			}
-			if n.Name.IsOutputParamHeapAddr() {
+			if n.Name().IsOutputParamHeapAddr() {
 				// This variable will be overwritten early in the function
 				// prologue (from the result of a mallocgc) but we need to
 				// zero it in case that malloc causes a stack scan.
-				n.Name.SetNeedzero(true)
+				n.Name().SetNeedzero(true)
 				livedefer.Set(int32(i))
 			}
-			if n.Name.OpenDeferSlot() {
+			if n.Name().OpenDeferSlot() {
 				// Open-coded defer args slots must be live
 				// everywhere in a function, since a panic can
 				// occur (almost) anywhere. Because it is live
 				// everywhere, it must be zeroed on entry.
 				livedefer.Set(int32(i))
 				// It was already marked as Needzero when created.
-				if !n.Name.Needzero() {
+				if !n.Name().Needzero() {
 					base.Fatalf("all pointer-containing defer arg slots should have Needzero set")
 				}
 			}
@@ -891,7 +891,7 @@ func (lv *Liveness) epilogue() {
 				if n.Class() == ir.PPARAM {
 					continue // ok
 				}
-				base.Fatalf("bad live variable at entry of %v: %L", lv.fn.Func.Nname, n)
+				base.Fatalf("bad live variable at entry of %v: %L", lv.fn.Func().Nname, n)
 			}
 
 			// Record live variables.
@@ -904,7 +904,7 @@ func (lv *Liveness) epilogue() {
 	}
 
 	// If we have an open-coded deferreturn call, make a liveness map for it.
-	if lv.fn.Func.OpenCodedDeferDisallowed() {
+	if lv.fn.Func().OpenCodedDeferDisallowed() {
 		lv.livenessMap.deferreturn = LivenessDontCare
 	} else {
 		lv.livenessMap.deferreturn = LivenessIndex{
@@ -922,7 +922,7 @@ func (lv *Liveness) epilogue() {
 	// input parameters.
 	for j, n := range lv.vars {
 		if n.Class() != ir.PPARAM && lv.stackMaps[0].Get(int32(j)) {
-			lv.f.Fatalf("%v %L recorded as live on entry", lv.fn.Func.Nname, n)
+			lv.f.Fatalf("%v %L recorded as live on entry", lv.fn.Func().Nname, n)
 		}
 	}
 }
@@ -980,7 +980,7 @@ func (lv *Liveness) showlive(v *ssa.Value, live bvec) {
 		return
 	}
 
-	pos := lv.fn.Func.Nname.Pos
+	pos := lv.fn.Func().Nname.Pos()
 	if v != nil {
 		pos = v.Pos
 	}
@@ -1024,7 +1024,7 @@ func (lv *Liveness) printbvec(printed bool, name string, live bvec) bool {
 		if !live.Get(int32(i)) {
 			continue
 		}
-		fmt.Printf("%s%s", comma, n.Sym.Name)
+		fmt.Printf("%s%s", comma, n.Sym().Name)
 		comma = ","
 	}
 	return true
@@ -1042,7 +1042,7 @@ func (lv *Liveness) printeffect(printed bool, name string, pos int32, x bool) bo
 	}
 	fmt.Printf("%s=", name)
 	if x {
-		fmt.Printf("%s", lv.vars[pos].Sym.Name)
+		fmt.Printf("%s", lv.vars[pos].Sym().Name)
 	}
 
 	return true
@@ -1090,7 +1090,7 @@ func (lv *Liveness) printDebug() {
 
 		if b == lv.f.Entry {
 			live := lv.stackMaps[0]
-			fmt.Printf("(%s) function entry\n", base.FmtPos(lv.fn.Func.Nname.Pos))
+			fmt.Printf("(%s) function entry\n", base.FmtPos(lv.fn.Func().Nname.Pos()))
 			fmt.Printf("\tlive=")
 			printed = false
 			for j, n := range lv.vars {
@@ -1168,7 +1168,7 @@ func (lv *Liveness) emit() (argsSym, liveSym *obj.LSym) {
 	for _, n := range lv.vars {
 		switch n.Class() {
 		case ir.PPARAM, ir.PPARAMOUT:
-			if maxArgNode == nil || n.Xoffset > maxArgNode.Xoffset {
+			if maxArgNode == nil || n.Offset() > maxArgNode.Offset() {
 				maxArgNode = n
 			}
 		}
@@ -1176,7 +1176,7 @@ func (lv *Liveness) emit() (argsSym, liveSym *obj.LSym) {
 	// Next, find the offset of the largest pointer in the largest node.
 	var maxArgs int64
 	if maxArgNode != nil {
-		maxArgs = maxArgNode.Xoffset + typeptrdata(maxArgNode.Type)
+		maxArgs = maxArgNode.Offset() + typeptrdata(maxArgNode.Type())
 	}
 
 	// Size locals bitmaps to be stkptrsize sized.
@@ -1266,7 +1266,7 @@ func liveness(e *ssafn, f *ssa.Func, pp *Progs) LivenessMap {
 	}
 
 	// Emit the live pointer map data structures
-	ls := e.curfn.Func.LSym
+	ls := e.curfn.Func().LSym
 	fninfo := ls.Func()
 	fninfo.GCArgs, fninfo.GCLocals = lv.emit()
 
diff --git a/src/cmd/compile/internal/gc/racewalk.go b/src/cmd/compile/internal/gc/racewalk.go
index d92749589f..5ab2821187 100644
--- a/src/cmd/compile/internal/gc/racewalk.go
+++ b/src/cmd/compile/internal/gc/racewalk.go
@@ -61,12 +61,12 @@ func ispkgin(pkgs []string) bool {
 }
 
 func instrument(fn *ir.Node) {
-	if fn.Func.Pragma&ir.Norace != 0 {
+	if fn.Func().Pragma&ir.Norace != 0 {
 		return
 	}
 
 	if !base.Flag.Race || !ispkgin(norace_inst_pkgs) {
-		fn.Func.SetInstrumentBody(true)
+		fn.Func().SetInstrumentBody(true)
 	}
 
 	if base.Flag.Race {
@@ -74,8 +74,8 @@ func instrument(fn *ir.Node) {
 		base.Pos = src.NoXPos
 
 		if thearch.LinkArch.Arch.Family != sys.AMD64 {
-			fn.Func.Enter.Prepend(mkcall("racefuncenterfp", nil, nil))
-			fn.Func.Exit.Append(mkcall("racefuncexit", nil, nil))
+			fn.Func().Enter.Prepend(mkcall("racefuncenterfp", nil, nil))
+			fn.Func().Exit.Append(mkcall("racefuncexit", nil, nil))
 		} else {
 
 			// nodpc is the PC of the caller as extracted by
@@ -84,11 +84,11 @@ func instrument(fn *ir.Node) {
 			// work on arm or others that might support
 			// race in the future.
 			nodpc := ir.Copy(nodfp)
-			nodpc.Type = types.Types[types.TUINTPTR]
-			nodpc.Xoffset = int64(-Widthptr)
-			fn.Func.Dcl = append(fn.Func.Dcl, nodpc)
-			fn.Func.Enter.Prepend(mkcall("racefuncenter", nil, nil, nodpc))
-			fn.Func.Exit.Append(mkcall("racefuncexit", nil, nil))
+			nodpc.SetType(types.Types[types.TUINTPTR])
+			nodpc.SetOffset(int64(-Widthptr))
+			fn.Func().Dcl = append(fn.Func().Dcl, nodpc)
+			fn.Func().Enter.Prepend(mkcall("racefuncenter", nil, nil, nodpc))
+			fn.Func().Exit.Append(mkcall("racefuncexit", nil, nil))
 		}
 		base.Pos = lno
 	}
diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index edaec21f92..6a2a65c2df 100644
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -27,7 +27,7 @@ func typecheckrange(n *ir.Node) {
 
 	// second half of dance, the first half being typecheckrangeExpr
 	n.SetTypecheck(1)
-	ls := n.List.Slice()
+	ls := n.List().Slice()
 	for i1, n1 := range ls {
 		if n1.Typecheck() == 0 {
 			ls[i1] = typecheck(ls[i1], ctxExpr|ctxAssign)
@@ -35,21 +35,21 @@ func typecheckrange(n *ir.Node) {
 	}
 
 	decldepth++
-	typecheckslice(n.Nbody.Slice(), ctxStmt)
+	typecheckslice(n.Body().Slice(), ctxStmt)
 	decldepth--
 }
 
 func typecheckrangeExpr(n *ir.Node) {
-	n.Right = typecheck(n.Right, ctxExpr)
+	n.SetRight(typecheck(n.Right(), ctxExpr))
 
-	t := n.Right.Type
+	t := n.Right().Type()
 	if t == nil {
 		return
 	}
 	// delicate little dance.  see typecheckas2
-	ls := n.List.Slice()
+	ls := n.List().Slice()
 	for i1, n1 := range ls {
-		if n1.Name == nil || n1.Name.Defn != n {
+		if n1.Name() == nil || n1.Name().Defn != n {
 			ls[i1] = typecheck(ls[i1], ctxExpr|ctxAssign)
 		}
 	}
@@ -57,13 +57,13 @@ func typecheckrangeExpr(n *ir.Node) {
 	if t.IsPtr() && t.Elem().IsArray() {
 		t = t.Elem()
 	}
-	n.Type = t
+	n.SetType(t)
 
 	var t1, t2 *types.Type
 	toomany := false
 	switch t.Etype {
 	default:
-		base.ErrorfAt(n.Pos, "cannot range over %L", n.Right)
+		base.ErrorfAt(n.Pos(), "cannot range over %L", n.Right())
 		return
 
 	case types.TARRAY, types.TSLICE:
@@ -76,13 +76,13 @@ func typecheckrangeExpr(n *ir.Node) {
 
 	case types.TCHAN:
 		if !t.ChanDir().CanRecv() {
-			base.ErrorfAt(n.Pos, "invalid operation: range %v (receive from send-only type %v)", n.Right, n.Right.Type)
+			base.ErrorfAt(n.Pos(), "invalid operation: range %v (receive from send-only type %v)", n.Right(), n.Right().Type())
 			return
 		}
 
 		t1 = t.Elem()
 		t2 = nil
-		if n.List.Len() == 2 {
+		if n.List().Len() == 2 {
 			toomany = true
 		}
 
@@ -91,16 +91,16 @@ func typecheckrangeExpr(n *ir.Node) {
 		t2 = types.Runetype
 	}
 
-	if n.List.Len() > 2 || toomany {
-		base.ErrorfAt(n.Pos, "too many variables in range")
+	if n.List().Len() > 2 || toomany {
+		base.ErrorfAt(n.Pos(), "too many variables in range")
 	}
 
 	var v1, v2 *ir.Node
-	if n.List.Len() != 0 {
-		v1 = n.List.First()
+	if n.List().Len() != 0 {
+		v1 = n.List().First()
 	}
-	if n.List.Len() > 1 {
-		v2 = n.List.Second()
+	if n.List().Len() > 1 {
+		v2 = n.List().Second()
 	}
 
 	// this is not only an optimization but also a requirement in the spec.
@@ -109,28 +109,28 @@ func typecheckrangeExpr(n *ir.Node) {
 	// present."
 	if ir.IsBlank(v2) {
 		if v1 != nil {
-			n.List.Set1(v1)
+			n.PtrList().Set1(v1)
 		}
 		v2 = nil
 	}
 
 	if v1 != nil {
-		if v1.Name != nil && v1.Name.Defn == n {
-			v1.Type = t1
-		} else if v1.Type != nil {
-			if op, why := assignop(t1, v1.Type); op == ir.OXXX {
-				base.ErrorfAt(n.Pos, "cannot assign type %v to %L in range%s", t1, v1, why)
+		if v1.Name() != nil && v1.Name().Defn == n {
+			v1.SetType(t1)
+		} else if v1.Type() != nil {
+			if op, why := assignop(t1, v1.Type()); op == ir.OXXX {
+				base.ErrorfAt(n.Pos(), "cannot assign type %v to %L in range%s", t1, v1, why)
 			}
 		}
 		checkassign(n, v1)
 	}
 
 	if v2 != nil {
-		if v2.Name != nil && v2.Name.Defn == n {
-			v2.Type = t2
-		} else if v2.Type != nil {
-			if op, why := assignop(t2, v2.Type); op == ir.OXXX {
-				base.ErrorfAt(n.Pos, "cannot assign type %v to %L in range%s", t2, v2, why)
+		if v2.Name() != nil && v2.Name().Defn == n {
+			v2.SetType(t2)
+		} else if v2.Type() != nil {
+			if op, why := assignop(t2, v2.Type()); op == ir.OXXX {
+				base.ErrorfAt(n.Pos(), "cannot assign type %v to %L in range%s", t2, v2, why)
 			}
 		}
 		checkassign(n, v2)
@@ -159,7 +159,7 @@ func cheapComputableIndex(width int64) bool {
 // the returned node.
 func walkrange(n *ir.Node) *ir.Node {
 	if isMapClear(n) {
-		m := n.Right
+		m := n.Right()
 		lno := setlineno(m)
 		n = mapClear(m)
 		base.Pos = lno
@@ -173,20 +173,20 @@ func walkrange(n *ir.Node) *ir.Node {
 	//	hb: hidden bool
 	//	a, v1, v2: not hidden aggregate, val 1, 2
 
-	t := n.Type
+	t := n.Type()
 
-	a := n.Right
+	a := n.Right()
 	lno := setlineno(a)
-	n.Right = nil
+	n.SetRight(nil)
 
 	var v1, v2 *ir.Node
-	l := n.List.Len()
+	l := n.List().Len()
 	if l > 0 {
-		v1 = n.List.First()
+		v1 = n.List().First()
 	}
 
 	if l > 1 {
-		v2 = n.List.Second()
+		v2 = n.List().Second()
 	}
 
 	if ir.IsBlank(v2) {
@@ -203,7 +203,7 @@ func walkrange(n *ir.Node) *ir.Node {
 
 	// n.List has no meaning anymore, clear it
 	// to avoid erroneous processing by racewalk.
-	n.List.Set(nil)
+	n.PtrList().Set(nil)
 
 	var ifGuard *ir.Node
 
@@ -230,8 +230,8 @@ func walkrange(n *ir.Node) *ir.Node {
 		init = append(init, ir.Nod(ir.OAS, hv1, nil))
 		init = append(init, ir.Nod(ir.OAS, hn, ir.Nod(ir.OLEN, ha, nil)))
 
-		n.Left = ir.Nod(ir.OLT, hv1, hn)
-		n.Right = ir.Nod(ir.OAS, hv1, ir.Nod(ir.OADD, hv1, nodintconst(1)))
+		n.SetLeft(ir.Nod(ir.OLT, hv1, hn))
+		n.SetRight(ir.Nod(ir.OAS, hv1, ir.Nod(ir.OADD, hv1, nodintconst(1))))
 
 		// for range ha { body }
 		if v1 == nil {
@@ -245,15 +245,15 @@ func walkrange(n *ir.Node) *ir.Node {
 		}
 
 		// for v1, v2 := range ha { body }
-		if cheapComputableIndex(n.Type.Elem().Width) {
+		if cheapComputableIndex(n.Type().Elem().Width) {
 			// v1, v2 = hv1, ha[hv1]
 			tmp := ir.Nod(ir.OINDEX, ha, hv1)
 			tmp.SetBounded(true)
 			// Use OAS2 to correctly handle assignments
 			// of the form "v1, a[v1] := range".
 			a := ir.Nod(ir.OAS2, nil, nil)
-			a.List.Set2(v1, v2)
-			a.Rlist.Set2(hv1, tmp)
+			a.PtrList().Set2(v1, v2)
+			a.PtrRlist().Set2(hv1, tmp)
 			body = []*ir.Node{a}
 			break
 		}
@@ -271,10 +271,10 @@ func walkrange(n *ir.Node) *ir.Node {
 		// elimination on the index variable (see #20711).
 		// Enhance the prove pass to understand this.
 		ifGuard = ir.Nod(ir.OIF, nil, nil)
-		ifGuard.Left = ir.Nod(ir.OLT, hv1, hn)
+		ifGuard.SetLeft(ir.Nod(ir.OLT, hv1, hn))
 		translatedLoopOp = ir.OFORUNTIL
 
-		hp := temp(types.NewPtr(n.Type.Elem()))
+		hp := temp(types.NewPtr(n.Type().Elem()))
 		tmp := ir.Nod(ir.OINDEX, ha, nodintconst(0))
 		tmp.SetBounded(true)
 		init = append(init, ir.Nod(ir.OAS, hp, ir.Nod(ir.OADDR, tmp, nil)))
@@ -282,8 +282,8 @@ func walkrange(n *ir.Node) *ir.Node {
 		// Use OAS2 to correctly handle assignments
 		// of the form "v1, a[v1] := range".
 		a := ir.Nod(ir.OAS2, nil, nil)
-		a.List.Set2(v1, v2)
-		a.Rlist.Set2(hv1, ir.Nod(ir.ODEREF, hp, nil))
+		a.PtrList().Set2(v1, v2)
+		a.PtrRlist().Set2(hv1, ir.Nod(ir.ODEREF, hp, nil))
 		body = append(body, a)
 
 		// Advance pointer as part of the late increment.
@@ -293,7 +293,7 @@ func walkrange(n *ir.Node) *ir.Node {
 		// end of the allocation.
 		a = ir.Nod(ir.OAS, hp, addptr(hp, t.Elem().Width))
 		a = typecheck(a, ctxStmt)
-		n.List.Set1(a)
+		n.PtrList().Set1(a)
 
 	case types.TMAP:
 		// order.stmt allocated the iterator for us.
@@ -301,8 +301,8 @@ func walkrange(n *ir.Node) *ir.Node {
 		ha := a
 
 		hit := prealloc[n]
-		th := hit.Type
-		n.Left = nil
+		th := hit.Type()
+		n.SetLeft(nil)
 		keysym := th.Field(0).Sym  // depends on layout of iterator struct.  See reflect.go:hiter
 		elemsym := th.Field(1).Sym // ditto
 
@@ -310,11 +310,11 @@ func walkrange(n *ir.Node) *ir.Node {
 
 		fn = substArgTypes(fn, t.Key(), t.Elem(), th)
 		init = append(init, mkcall1(fn, nil, nil, typename(t), ha, ir.Nod(ir.OADDR, hit, nil)))
-		n.Left = ir.Nod(ir.ONE, nodSym(ir.ODOT, hit, keysym), nodnil())
+		n.SetLeft(ir.Nod(ir.ONE, nodSym(ir.ODOT, hit, keysym), nodnil()))
 
 		fn = syslook("mapiternext")
 		fn = substArgTypes(fn, th)
-		n.Right = mkcall1(fn, nil, nil, ir.Nod(ir.OADDR, hit, nil))
+		n.SetRight(mkcall1(fn, nil, nil, ir.Nod(ir.OADDR, hit, nil)))
 
 		key := nodSym(ir.ODOT, hit, keysym)
 		key = ir.Nod(ir.ODEREF, key, nil)
@@ -326,8 +326,8 @@ func walkrange(n *ir.Node) *ir.Node {
 			elem := nodSym(ir.ODOT, hit, elemsym)
 			elem = ir.Nod(ir.ODEREF, elem, nil)
 			a := ir.Nod(ir.OAS2, nil, nil)
-			a.List.Set2(v1, v2)
-			a.Rlist.Set2(key, elem)
+			a.PtrList().Set2(v1, v2)
+			a.PtrRlist().Set2(key, elem)
 			body = []*ir.Node{a}
 		}
 
@@ -335,7 +335,7 @@ func walkrange(n *ir.Node) *ir.Node {
 		// order.stmt arranged for a copy of the channel variable.
 		ha := a
 
-		n.Left = nil
+		n.SetLeft(nil)
 
 		hv1 := temp(t.Elem())
 		hv1.SetTypecheck(1)
@@ -344,12 +344,12 @@ func walkrange(n *ir.Node) *ir.Node {
 		}
 		hb := temp(types.Types[types.TBOOL])
 
-		n.Left = ir.Nod(ir.ONE, hb, nodbool(false))
+		n.SetLeft(ir.Nod(ir.ONE, hb, nodbool(false)))
 		a := ir.Nod(ir.OAS2RECV, nil, nil)
 		a.SetTypecheck(1)
-		a.List.Set2(hv1, hb)
-		a.Right = ir.Nod(ir.ORECV, ha, nil)
-		n.Left.Ninit.Set1(a)
+		a.PtrList().Set2(hv1, hb)
+		a.SetRight(ir.Nod(ir.ORECV, ha, nil))
+		n.Left().PtrInit().Set1(a)
 		if v1 == nil {
 			body = nil
 		} else {
@@ -387,7 +387,7 @@ func walkrange(n *ir.Node) *ir.Node {
 		init = append(init, ir.Nod(ir.OAS, hv1, nil))
 
 		// hv1 < len(ha)
-		n.Left = ir.Nod(ir.OLT, hv1, ir.Nod(ir.OLEN, ha, nil))
+		n.SetLeft(ir.Nod(ir.OLT, hv1, ir.Nod(ir.OLEN, ha, nil)))
 
 		if v1 != nil {
 			// hv1t = hv1
@@ -401,19 +401,19 @@ func walkrange(n *ir.Node) *ir.Node {
 
 		// if hv2 < utf8.RuneSelf
 		nif := ir.Nod(ir.OIF, nil, nil)
-		nif.Left = ir.Nod(ir.OLT, hv2, nodintconst(utf8.RuneSelf))
+		nif.SetLeft(ir.Nod(ir.OLT, hv2, nodintconst(utf8.RuneSelf)))
 
 		// hv1++
-		nif.Nbody.Set1(ir.Nod(ir.OAS, hv1, ir.Nod(ir.OADD, hv1, nodintconst(1))))
+		nif.PtrBody().Set1(ir.Nod(ir.OAS, hv1, ir.Nod(ir.OADD, hv1, nodintconst(1))))
 
 		// } else {
 		eif := ir.Nod(ir.OAS2, nil, nil)
-		nif.Rlist.Set1(eif)
+		nif.PtrRlist().Set1(eif)
 
 		// hv2, hv1 = decoderune(ha, hv1)
-		eif.List.Set2(hv2, hv1)
+		eif.PtrList().Set2(hv2, hv1)
 		fn := syslook("decoderune")
-		eif.Rlist.Set1(mkcall1(fn, fn.Type.Results(), nil, ha, hv1))
+		eif.PtrRlist().Set1(mkcall1(fn, fn.Type().Results(), nil, ha, hv1))
 
 		body = append(body, nif)
 
@@ -421,8 +421,8 @@ func walkrange(n *ir.Node) *ir.Node {
 			if v2 != nil {
 				// v1, v2 = hv1t, hv2
 				a := ir.Nod(ir.OAS2, nil, nil)
-				a.List.Set2(v1, v2)
-				a.Rlist.Set2(hv1t, hv2)
+				a.PtrList().Set2(v1, v2)
+				a.PtrRlist().Set2(hv1t, hv2)
 				body = append(body, a)
 			} else {
 				// v1 = hv1t
@@ -431,26 +431,26 @@ func walkrange(n *ir.Node) *ir.Node {
 		}
 	}
 
-	n.Op = translatedLoopOp
+	n.SetOp(translatedLoopOp)
 	typecheckslice(init, ctxStmt)
 
 	if ifGuard != nil {
-		ifGuard.Ninit.Append(init...)
+		ifGuard.PtrInit().Append(init...)
 		ifGuard = typecheck(ifGuard, ctxStmt)
 	} else {
-		n.Ninit.Append(init...)
+		n.PtrInit().Append(init...)
 	}
 
-	typecheckslice(n.Left.Ninit.Slice(), ctxStmt)
+	typecheckslice(n.Left().Init().Slice(), ctxStmt)
 
-	n.Left = typecheck(n.Left, ctxExpr)
-	n.Left = defaultlit(n.Left, nil)
-	n.Right = typecheck(n.Right, ctxStmt)
+	n.SetLeft(typecheck(n.Left(), ctxExpr))
+	n.SetLeft(defaultlit(n.Left(), nil))
+	n.SetRight(typecheck(n.Right(), ctxStmt))
 	typecheckslice(body, ctxStmt)
-	n.Nbody.Prepend(body...)
+	n.PtrBody().Prepend(body...)
 
 	if ifGuard != nil {
-		ifGuard.Nbody.Set1(n)
+		ifGuard.PtrBody().Set1(n)
 		n = ifGuard
 	}
 
@@ -472,36 +472,36 @@ func isMapClear(n *ir.Node) bool {
 		return false
 	}
 
-	if n.Op != ir.ORANGE || n.Type.Etype != types.TMAP || n.List.Len() != 1 {
+	if n.Op() != ir.ORANGE || n.Type().Etype != types.TMAP || n.List().Len() != 1 {
 		return false
 	}
 
-	k := n.List.First()
+	k := n.List().First()
 	if k == nil || ir.IsBlank(k) {
 		return false
 	}
 
 	// Require k to be a new variable name.
-	if k.Name == nil || k.Name.Defn != n {
+	if k.Name() == nil || k.Name().Defn != n {
 		return false
 	}
 
-	if n.Nbody.Len() != 1 {
+	if n.Body().Len() != 1 {
 		return false
 	}
 
-	stmt := n.Nbody.First() // only stmt in body
-	if stmt == nil || stmt.Op != ir.ODELETE {
+	stmt := n.Body().First() // only stmt in body
+	if stmt == nil || stmt.Op() != ir.ODELETE {
 		return false
 	}
 
-	m := n.Right
-	if !samesafeexpr(stmt.List.First(), m) || !samesafeexpr(stmt.List.Second(), k) {
+	m := n.Right()
+	if !samesafeexpr(stmt.List().First(), m) || !samesafeexpr(stmt.List().Second(), k) {
 		return false
 	}
 
 	// Keys where equality is not reflexive can not be deleted from maps.
-	if !isreflexive(m.Type.Key()) {
+	if !isreflexive(m.Type().Key()) {
 		return false
 	}
 
@@ -510,7 +510,7 @@ func isMapClear(n *ir.Node) bool {
 
 // mapClear constructs a call to runtime.mapclear for the map m.
 func mapClear(m *ir.Node) *ir.Node {
-	t := m.Type
+	t := m.Type()
 
 	// instantiate mapclear(typ *type, hmap map[any]any)
 	fn := syslook("mapclear")
@@ -543,21 +543,21 @@ func arrayClear(n, v1, v2, a *ir.Node) bool {
 		return false
 	}
 
-	if n.Nbody.Len() != 1 || n.Nbody.First() == nil {
+	if n.Body().Len() != 1 || n.Body().First() == nil {
 		return false
 	}
 
-	stmt := n.Nbody.First() // only stmt in body
-	if stmt.Op != ir.OAS || stmt.Left.Op != ir.OINDEX {
+	stmt := n.Body().First() // only stmt in body
+	if stmt.Op() != ir.OAS || stmt.Left().Op() != ir.OINDEX {
 		return false
 	}
 
-	if !samesafeexpr(stmt.Left.Left, a) || !samesafeexpr(stmt.Left.Right, v1) {
+	if !samesafeexpr(stmt.Left().Left(), a) || !samesafeexpr(stmt.Left().Right(), v1) {
 		return false
 	}
 
-	elemsize := n.Type.Elem().Width
-	if elemsize <= 0 || !isZero(stmt.Right) {
+	elemsize := n.Type().Elem().Width
+	if elemsize <= 0 || !isZero(stmt.Right()) {
 		return false
 	}
 
@@ -568,10 +568,10 @@ func arrayClear(n, v1, v2, a *ir.Node) bool {
 	// 	memclr{NoHeap,Has}Pointers(hp, hn)
 	// 	i = len(a) - 1
 	// }
-	n.Op = ir.OIF
+	n.SetOp(ir.OIF)
 
-	n.Nbody.Set(nil)
-	n.Left = ir.Nod(ir.ONE, ir.Nod(ir.OLEN, a, nil), nodintconst(0))
+	n.PtrBody().Set(nil)
+	n.SetLeft(ir.Nod(ir.ONE, ir.Nod(ir.OLEN, a, nil), nodintconst(0)))
 
 	// hp = &a[0]
 	hp := temp(types.Types[types.TUNSAFEPTR])
@@ -580,7 +580,7 @@ func arrayClear(n, v1, v2, a *ir.Node) bool {
 	tmp.SetBounded(true)
 	tmp = ir.Nod(ir.OADDR, tmp, nil)
 	tmp = convnop(tmp, types.Types[types.TUNSAFEPTR])
-	n.Nbody.Append(ir.Nod(ir.OAS, hp, tmp))
+	n.PtrBody().Append(ir.Nod(ir.OAS, hp, tmp))
 
 	// hn = len(a) * sizeof(elem(a))
 	hn := temp(types.Types[types.TUINTPTR])
@@ -588,43 +588,43 @@ func arrayClear(n, v1, v2, a *ir.Node) bool {
 	tmp = ir.Nod(ir.OLEN, a, nil)
 	tmp = ir.Nod(ir.OMUL, tmp, nodintconst(elemsize))
 	tmp = conv(tmp, types.Types[types.TUINTPTR])
-	n.Nbody.Append(ir.Nod(ir.OAS, hn, tmp))
+	n.PtrBody().Append(ir.Nod(ir.OAS, hn, tmp))
 
 	var fn *ir.Node
-	if a.Type.Elem().HasPointers() {
+	if a.Type().Elem().HasPointers() {
 		// memclrHasPointers(hp, hn)
-		Curfn.Func.SetWBPos(stmt.Pos)
+		Curfn.Func().SetWBPos(stmt.Pos())
 		fn = mkcall("memclrHasPointers", nil, nil, hp, hn)
 	} else {
 		// memclrNoHeapPointers(hp, hn)
 		fn = mkcall("memclrNoHeapPointers", nil, nil, hp, hn)
 	}
 
-	n.Nbody.Append(fn)
+	n.PtrBody().Append(fn)
 
 	// i = len(a) - 1
 	v1 = ir.Nod(ir.OAS, v1, ir.Nod(ir.OSUB, ir.Nod(ir.OLEN, a, nil), nodintconst(1)))
 
-	n.Nbody.Append(v1)
+	n.PtrBody().Append(v1)
 
-	n.Left = typecheck(n.Left, ctxExpr)
-	n.Left = defaultlit(n.Left, nil)
-	typecheckslice(n.Nbody.Slice(), ctxStmt)
+	n.SetLeft(typecheck(n.Left(), ctxExpr))
+	n.SetLeft(defaultlit(n.Left(), nil))
+	typecheckslice(n.Body().Slice(), ctxStmt)
 	n = walkstmt(n)
 	return true
 }
 
 // addptr returns (*T)(uintptr(p) + n).
 func addptr(p *ir.Node, n int64) *ir.Node {
-	t := p.Type
+	t := p.Type()
 
 	p = ir.Nod(ir.OCONVNOP, p, nil)
-	p.Type = types.Types[types.TUINTPTR]
+	p.SetType(types.Types[types.TUINTPTR])
 
 	p = ir.Nod(ir.OADD, p, nodintconst(n))
 
 	p = ir.Nod(ir.OCONVNOP, p, nil)
-	p.Type = t
+	p.SetType(t)
 
 	return p
 }
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 34047bfefa..4559dd3a21 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -994,14 +994,14 @@ func typename(t *types.Type) *ir.Node {
 	s := typenamesym(t)
 	if s.Def == nil {
 		n := ir.NewNameAt(src.NoXPos, s)
-		n.Type = types.Types[types.TUINT8]
+		n.SetType(types.Types[types.TUINT8])
 		n.SetClass(ir.PEXTERN)
 		n.SetTypecheck(1)
 		s.Def = ir.AsTypesNode(n)
 	}
 
 	n := ir.Nod(ir.OADDR, ir.AsNode(s.Def), nil)
-	n.Type = types.NewPtr(ir.AsNode(s.Def).Type)
+	n.SetType(types.NewPtr(ir.AsNode(s.Def).Type()))
 	n.SetTypecheck(1)
 	return n
 }
@@ -1013,7 +1013,7 @@ func itabname(t, itype *types.Type) *ir.Node {
 	s := itabpkg.Lookup(t.ShortString() + "," + itype.ShortString())
 	if s.Def == nil {
 		n := NewName(s)
-		n.Type = types.Types[types.TUINT8]
+		n.SetType(types.Types[types.TUINT8])
 		n.SetClass(ir.PEXTERN)
 		n.SetTypecheck(1)
 		s.Def = ir.AsTypesNode(n)
@@ -1021,7 +1021,7 @@ func itabname(t, itype *types.Type) *ir.Node {
 	}
 
 	n := ir.Nod(ir.OADDR, ir.AsNode(s.Def), nil)
-	n.Type = types.NewPtr(ir.AsNode(s.Def).Type)
+	n.SetType(types.NewPtr(ir.AsNode(s.Def).Type()))
 	n.SetTypecheck(1)
 	return n
 }
@@ -1519,8 +1519,8 @@ func addsignat(t *types.Type) {
 func addsignats(dcls []*ir.Node) {
 	// copy types from dcl list to signatset
 	for _, n := range dcls {
-		if n.Op == ir.OTYPE {
-			addsignat(n.Type)
+		if n.Op() == ir.OTYPE {
+			addsignat(n.Type())
 		}
 	}
 }
@@ -1879,13 +1879,13 @@ func zeroaddr(size int64) *ir.Node {
 	s := mappkg.Lookup("zero")
 	if s.Def == nil {
 		x := NewName(s)
-		x.Type = types.Types[types.TUINT8]
+		x.SetType(types.Types[types.TUINT8])
 		x.SetClass(ir.PEXTERN)
 		x.SetTypecheck(1)
 		s.Def = ir.AsTypesNode(x)
 	}
 	z := ir.Nod(ir.OADDR, ir.AsNode(s.Def), nil)
-	z.Type = types.NewPtr(types.Types[types.TUINT8])
+	z.SetType(types.NewPtr(types.Types[types.TUINT8]))
 	z.SetTypecheck(1)
 	return z
 }
diff --git a/src/cmd/compile/internal/gc/scc.go b/src/cmd/compile/internal/gc/scc.go
index ddde18e505..880eff7595 100644
--- a/src/cmd/compile/internal/gc/scc.go
+++ b/src/cmd/compile/internal/gc/scc.go
@@ -56,7 +56,7 @@ func visitBottomUp(list []*ir.Node, analyze func(list []*ir.Node, recursive bool
 	v.analyze = analyze
 	v.nodeID = make(map[*ir.Node]uint32)
 	for _, n := range list {
-		if n.Op == ir.ODCLFUNC && !n.Func.IsHiddenClosure() {
+		if n.Op() == ir.ODCLFUNC && !n.Func().IsHiddenClosure() {
 			v.visit(n)
 		}
 	}
@@ -75,46 +75,46 @@ func (v *bottomUpVisitor) visit(n *ir.Node) uint32 {
 	min := v.visitgen
 	v.stack = append(v.stack, n)
 
-	ir.InspectList(n.Nbody, func(n *ir.Node) bool {
-		switch n.Op {
+	ir.InspectList(n.Body(), func(n *ir.Node) bool {
+		switch n.Op() {
 		case ir.ONAME:
 			if n.Class() == ir.PFUNC {
-				if n != nil && n.Name.Defn != nil {
-					if m := v.visit(n.Name.Defn); m < min {
+				if n != nil && n.Name().Defn != nil {
+					if m := v.visit(n.Name().Defn); m < min {
 						min = m
 					}
 				}
 			}
 		case ir.OMETHEXPR:
 			fn := methodExprName(n)
-			if fn != nil && fn.Name.Defn != nil {
-				if m := v.visit(fn.Name.Defn); m < min {
+			if fn != nil && fn.Name().Defn != nil {
+				if m := v.visit(fn.Name().Defn); m < min {
 					min = m
 				}
 			}
 		case ir.ODOTMETH:
 			fn := methodExprName(n)
-			if fn != nil && fn.Op == ir.ONAME && fn.Class() == ir.PFUNC && fn.Name.Defn != nil {
-				if m := v.visit(fn.Name.Defn); m < min {
+			if fn != nil && fn.Op() == ir.ONAME && fn.Class() == ir.PFUNC && fn.Name().Defn != nil {
+				if m := v.visit(fn.Name().Defn); m < min {
 					min = m
 				}
 			}
 		case ir.OCALLPART:
 			fn := ir.AsNode(callpartMethod(n).Nname)
-			if fn != nil && fn.Op == ir.ONAME && fn.Class() == ir.PFUNC && fn.Name.Defn != nil {
-				if m := v.visit(fn.Name.Defn); m < min {
+			if fn != nil && fn.Op() == ir.ONAME && fn.Class() == ir.PFUNC && fn.Name().Defn != nil {
+				if m := v.visit(fn.Name().Defn); m < min {
 					min = m
 				}
 			}
 		case ir.OCLOSURE:
-			if m := v.visit(n.Func.Decl); m < min {
+			if m := v.visit(n.Func().Decl); m < min {
 				min = m
 			}
 		}
 		return true
 	})
 
-	if (min == id || min == id+1) && !n.Func.IsHiddenClosure() {
+	if (min == id || min == id+1) && !n.Func().IsHiddenClosure() {
 		// This node is the root of a strongly connected component.
 
 		// The original min passed to visitcodelist was v.nodeID[n]+1.
diff --git a/src/cmd/compile/internal/gc/scope.go b/src/cmd/compile/internal/gc/scope.go
index b5ebce04be..16e66dee6c 100644
--- a/src/cmd/compile/internal/gc/scope.go
+++ b/src/cmd/compile/internal/gc/scope.go
@@ -30,13 +30,13 @@ func findScope(marks []ir.Mark, pos src.XPos) ir.ScopeID {
 
 func assembleScopes(fnsym *obj.LSym, fn *ir.Node, dwarfVars []*dwarf.Var, varScopes []ir.ScopeID) []dwarf.Scope {
 	// Initialize the DWARF scope tree based on lexical scopes.
-	dwarfScopes := make([]dwarf.Scope, 1+len(fn.Func.Parents))
-	for i, parent := range fn.Func.Parents {
+	dwarfScopes := make([]dwarf.Scope, 1+len(fn.Func().Parents))
+	for i, parent := range fn.Func().Parents {
 		dwarfScopes[i+1].Parent = int32(parent)
 	}
 
 	scopeVariables(dwarfVars, varScopes, dwarfScopes)
-	scopePCs(fnsym, fn.Func.Marks, dwarfScopes)
+	scopePCs(fnsym, fn.Func().Marks, dwarfScopes)
 	return compactScopes(dwarfScopes)
 }
 
diff --git a/src/cmd/compile/internal/gc/select.go b/src/cmd/compile/internal/gc/select.go
index ed7db0aaf7..73b808b815 100644
--- a/src/cmd/compile/internal/gc/select.go
+++ b/src/cmd/compile/internal/gc/select.go
@@ -14,36 +14,36 @@ import (
 func typecheckselect(sel *ir.Node) {
 	var def *ir.Node
 	lno := setlineno(sel)
-	typecheckslice(sel.Ninit.Slice(), ctxStmt)
-	for _, ncase := range sel.List.Slice() {
-		if ncase.Op != ir.OCASE {
+	typecheckslice(sel.Init().Slice(), ctxStmt)
+	for _, ncase := range sel.List().Slice() {
+		if ncase.Op() != ir.OCASE {
 			setlineno(ncase)
-			base.Fatalf("typecheckselect %v", ncase.Op)
+			base.Fatalf("typecheckselect %v", ncase.Op())
 		}
 
-		if ncase.List.Len() == 0 {
+		if ncase.List().Len() == 0 {
 			// default
 			if def != nil {
-				base.ErrorfAt(ncase.Pos, "multiple defaults in select (first at %v)", ir.Line(def))
+				base.ErrorfAt(ncase.Pos(), "multiple defaults in select (first at %v)", ir.Line(def))
 			} else {
 				def = ncase
 			}
-		} else if ncase.List.Len() > 1 {
-			base.ErrorfAt(ncase.Pos, "select cases cannot be lists")
+		} else if ncase.List().Len() > 1 {
+			base.ErrorfAt(ncase.Pos(), "select cases cannot be lists")
 		} else {
-			ncase.List.SetFirst(typecheck(ncase.List.First(), ctxStmt))
-			n := ncase.List.First()
-			ncase.Left = n
-			ncase.List.Set(nil)
-			switch n.Op {
+			ncase.List().SetFirst(typecheck(ncase.List().First(), ctxStmt))
+			n := ncase.List().First()
+			ncase.SetLeft(n)
+			ncase.PtrList().Set(nil)
+			switch n.Op() {
 			default:
-				pos := n.Pos
-				if n.Op == ir.ONAME {
+				pos := n.Pos()
+				if n.Op() == ir.ONAME {
 					// We don't have the right position for ONAME nodes (see #15459 and
 					// others). Using ncase.Pos for now as it will provide the correct
 					// line number (assuming the expression follows the "case" keyword
 					// on the same line). This matches the approach before 1.10.
-					pos = ncase.Pos
+					pos = ncase.Pos()
 				}
 				base.ErrorfAt(pos, "select case must be receive, send or assign recv")
 
@@ -51,41 +51,41 @@ func typecheckselect(sel *ir.Node) {
 			// remove implicit conversions; the eventual assignment
 			// will reintroduce them.
 			case ir.OAS:
-				if (n.Right.Op == ir.OCONVNOP || n.Right.Op == ir.OCONVIFACE) && n.Right.Implicit() {
-					n.Right = n.Right.Left
+				if (n.Right().Op() == ir.OCONVNOP || n.Right().Op() == ir.OCONVIFACE) && n.Right().Implicit() {
+					n.SetRight(n.Right().Left())
 				}
 
-				if n.Right.Op != ir.ORECV {
-					base.ErrorfAt(n.Pos, "select assignment must have receive on right hand side")
+				if n.Right().Op() != ir.ORECV {
+					base.ErrorfAt(n.Pos(), "select assignment must have receive on right hand side")
 					break
 				}
 
-				n.Op = ir.OSELRECV
+				n.SetOp(ir.OSELRECV)
 
 				// convert x, ok = <-c into OSELRECV2(x, <-c) with ntest=ok
 			case ir.OAS2RECV:
-				if n.Right.Op != ir.ORECV {
-					base.ErrorfAt(n.Pos, "select assignment must have receive on right hand side")
+				if n.Right().Op() != ir.ORECV {
+					base.ErrorfAt(n.Pos(), "select assignment must have receive on right hand side")
 					break
 				}
 
-				n.Op = ir.OSELRECV2
-				n.Left = n.List.First()
-				n.List.Set1(n.List.Second())
+				n.SetOp(ir.OSELRECV2)
+				n.SetLeft(n.List().First())
+				n.PtrList().Set1(n.List().Second())
 
 				// convert <-c into OSELRECV(N, <-c)
 			case ir.ORECV:
-				n = ir.NodAt(n.Pos, ir.OSELRECV, nil, n)
+				n = ir.NodAt(n.Pos(), ir.OSELRECV, nil, n)
 
 				n.SetTypecheck(1)
-				ncase.Left = n
+				ncase.SetLeft(n)
 
 			case ir.OSEND:
 				break
 			}
 		}
 
-		typecheckslice(ncase.Nbody.Slice(), ctxStmt)
+		typecheckslice(ncase.Body().Slice(), ctxStmt)
 	}
 
 	base.Pos = lno
@@ -93,18 +93,18 @@ func typecheckselect(sel *ir.Node) {
 
 func walkselect(sel *ir.Node) {
 	lno := setlineno(sel)
-	if sel.Nbody.Len() != 0 {
+	if sel.Body().Len() != 0 {
 		base.Fatalf("double walkselect")
 	}
 
-	init := sel.Ninit.Slice()
-	sel.Ninit.Set(nil)
+	init := sel.Init().Slice()
+	sel.PtrInit().Set(nil)
 
-	init = append(init, walkselectcases(&sel.List)...)
-	sel.List.Set(nil)
+	init = append(init, walkselectcases(sel.PtrList())...)
+	sel.PtrList().Set(nil)
 
-	sel.Nbody.Set(init)
-	walkstmtlist(sel.Nbody.Slice())
+	sel.PtrBody().Set(init)
+	walkstmtlist(sel.Body().Slice())
 
 	base.Pos = lno
 }
@@ -122,38 +122,38 @@ func walkselectcases(cases *ir.Nodes) []*ir.Node {
 	if ncas == 1 {
 		cas := cases.First()
 		setlineno(cas)
-		l := cas.Ninit.Slice()
-		if cas.Left != nil { // not default:
-			n := cas.Left
-			l = append(l, n.Ninit.Slice()...)
-			n.Ninit.Set(nil)
-			switch n.Op {
+		l := cas.Init().Slice()
+		if cas.Left() != nil { // not default:
+			n := cas.Left()
+			l = append(l, n.Init().Slice()...)
+			n.PtrInit().Set(nil)
+			switch n.Op() {
 			default:
-				base.Fatalf("select %v", n.Op)
+				base.Fatalf("select %v", n.Op())
 
 			case ir.OSEND:
 				// already ok
 
 			case ir.OSELRECV, ir.OSELRECV2:
-				if n.Op == ir.OSELRECV || n.List.Len() == 0 {
-					if n.Left == nil {
-						n = n.Right
+				if n.Op() == ir.OSELRECV || n.List().Len() == 0 {
+					if n.Left() == nil {
+						n = n.Right()
 					} else {
-						n.Op = ir.OAS
+						n.SetOp(ir.OAS)
 					}
 					break
 				}
 
-				if n.Left == nil {
+				if n.Left() == nil {
 					ir.BlankNode = typecheck(ir.BlankNode, ctxExpr|ctxAssign)
-					n.Left = ir.BlankNode
+					n.SetLeft(ir.BlankNode)
 				}
 
-				n.Op = ir.OAS2
-				n.List.Prepend(n.Left)
-				n.Rlist.Set1(n.Right)
-				n.Right = nil
-				n.Left = nil
+				n.SetOp(ir.OAS2)
+				n.PtrList().Prepend(n.Left())
+				n.PtrRlist().Set1(n.Right())
+				n.SetRight(nil)
+				n.SetLeft(nil)
 				n.SetTypecheck(0)
 				n = typecheck(n, ctxStmt)
 			}
@@ -161,7 +161,7 @@ func walkselectcases(cases *ir.Nodes) []*ir.Node {
 			l = append(l, n)
 		}
 
-		l = append(l, cas.Nbody.Slice()...)
+		l = append(l, cas.Body().Slice()...)
 		l = append(l, ir.Nod(ir.OBREAK, nil, nil))
 		return l
 	}
@@ -171,24 +171,24 @@ func walkselectcases(cases *ir.Nodes) []*ir.Node {
 	var dflt *ir.Node
 	for _, cas := range cases.Slice() {
 		setlineno(cas)
-		n := cas.Left
+		n := cas.Left()
 		if n == nil {
 			dflt = cas
 			continue
 		}
-		switch n.Op {
+		switch n.Op() {
 		case ir.OSEND:
-			n.Right = ir.Nod(ir.OADDR, n.Right, nil)
-			n.Right = typecheck(n.Right, ctxExpr)
+			n.SetRight(ir.Nod(ir.OADDR, n.Right(), nil))
+			n.SetRight(typecheck(n.Right(), ctxExpr))
 
 		case ir.OSELRECV, ir.OSELRECV2:
-			if n.Op == ir.OSELRECV2 && n.List.Len() == 0 {
-				n.Op = ir.OSELRECV
+			if n.Op() == ir.OSELRECV2 && n.List().Len() == 0 {
+				n.SetOp(ir.OSELRECV)
 			}
 
-			if n.Left != nil {
-				n.Left = ir.Nod(ir.OADDR, n.Left, nil)
-				n.Left = typecheck(n.Left, ctxExpr)
+			if n.Left() != nil {
+				n.SetLeft(ir.Nod(ir.OADDR, n.Left(), nil))
+				n.SetLeft(typecheck(n.Left(), ctxExpr))
 			}
 		}
 	}
@@ -200,43 +200,43 @@ func walkselectcases(cases *ir.Nodes) []*ir.Node {
 			cas = cases.Second()
 		}
 
-		n := cas.Left
+		n := cas.Left()
 		setlineno(n)
 		r := ir.Nod(ir.OIF, nil, nil)
-		r.Ninit.Set(cas.Ninit.Slice())
-		switch n.Op {
+		r.PtrInit().Set(cas.Init().Slice())
+		switch n.Op() {
 		default:
-			base.Fatalf("select %v", n.Op)
+			base.Fatalf("select %v", n.Op())
 
 		case ir.OSEND:
 			// if selectnbsend(c, v) { body } else { default body }
-			ch := n.Left
-			r.Left = mkcall1(chanfn("selectnbsend", 2, ch.Type), types.Types[types.TBOOL], &r.Ninit, ch, n.Right)
+			ch := n.Left()
+			r.SetLeft(mkcall1(chanfn("selectnbsend", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), ch, n.Right()))
 
 		case ir.OSELRECV:
 			// if selectnbrecv(&v, c) { body } else { default body }
-			ch := n.Right.Left
-			elem := n.Left
+			ch := n.Right().Left()
+			elem := n.Left()
 			if elem == nil {
 				elem = nodnil()
 			}
-			r.Left = mkcall1(chanfn("selectnbrecv", 2, ch.Type), types.Types[types.TBOOL], &r.Ninit, elem, ch)
+			r.SetLeft(mkcall1(chanfn("selectnbrecv", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), elem, ch))
 
 		case ir.OSELRECV2:
 			// if selectnbrecv2(&v, &received, c) { body } else { default body }
-			ch := n.Right.Left
-			elem := n.Left
+			ch := n.Right().Left()
+			elem := n.Left()
 			if elem == nil {
 				elem = nodnil()
 			}
-			receivedp := ir.Nod(ir.OADDR, n.List.First(), nil)
+			receivedp := ir.Nod(ir.OADDR, n.List().First(), nil)
 			receivedp = typecheck(receivedp, ctxExpr)
-			r.Left = mkcall1(chanfn("selectnbrecv2", 2, ch.Type), types.Types[types.TBOOL], &r.Ninit, elem, receivedp, ch)
+			r.SetLeft(mkcall1(chanfn("selectnbrecv2", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), elem, receivedp, ch))
 		}
 
-		r.Left = typecheck(r.Left, ctxExpr)
-		r.Nbody.Set(cas.Nbody.Slice())
-		r.Rlist.Set(append(dflt.Ninit.Slice(), dflt.Nbody.Slice()...))
+		r.SetLeft(typecheck(r.Left(), ctxExpr))
+		r.PtrBody().Set(cas.Body().Slice())
+		r.PtrRlist().Set(append(dflt.Init().Slice(), dflt.Body().Slice()...))
 		return []*ir.Node{r, ir.Nod(ir.OBREAK, nil, nil)}
 	}
 
@@ -270,29 +270,29 @@ func walkselectcases(cases *ir.Nodes) []*ir.Node {
 	for _, cas := range cases.Slice() {
 		setlineno(cas)
 
-		init = append(init, cas.Ninit.Slice()...)
-		cas.Ninit.Set(nil)
+		init = append(init, cas.Init().Slice()...)
+		cas.PtrInit().Set(nil)
 
-		n := cas.Left
+		n := cas.Left()
 		if n == nil { // default:
 			continue
 		}
 
 		var i int
 		var c, elem *ir.Node
-		switch n.Op {
+		switch n.Op() {
 		default:
-			base.Fatalf("select %v", n.Op)
+			base.Fatalf("select %v", n.Op())
 		case ir.OSEND:
 			i = nsends
 			nsends++
-			c = n.Left
-			elem = n.Right
+			c = n.Left()
+			elem = n.Right()
 		case ir.OSELRECV, ir.OSELRECV2:
 			nrecvs++
 			i = ncas - nrecvs
-			c = n.Right.Left
-			elem = n.Left
+			c = n.Right().Left()
+			elem = n.Left()
 		}
 
 		casorder[i] = cas
@@ -326,9 +326,9 @@ func walkselectcases(cases *ir.Nodes) []*ir.Node {
 	chosen := temp(types.Types[types.TINT])
 	recvOK := temp(types.Types[types.TBOOL])
 	r = ir.Nod(ir.OAS2, nil, nil)
-	r.List.Set2(chosen, recvOK)
+	r.PtrList().Set2(chosen, recvOK)
 	fn := syslook("selectgo")
-	r.Rlist.Set1(mkcall1(fn, fn.Type.Results(), nil, bytePtrToIndex(selv, 0), bytePtrToIndex(order, 0), pc0, nodintconst(int64(nsends)), nodintconst(int64(nrecvs)), nodbool(dflt == nil)))
+	r.PtrRlist().Set1(mkcall1(fn, fn.Type().Results(), nil, bytePtrToIndex(selv, 0), bytePtrToIndex(order, 0), pc0, nodintconst(int64(nsends)), nodintconst(int64(nrecvs)), nodbool(dflt == nil)))
 	r = typecheck(r, ctxStmt)
 	init = append(init, r)
 
@@ -346,14 +346,14 @@ func walkselectcases(cases *ir.Nodes) []*ir.Node {
 
 		r := ir.Nod(ir.OIF, cond, nil)
 
-		if n := cas.Left; n != nil && n.Op == ir.OSELRECV2 {
-			x := ir.Nod(ir.OAS, n.List.First(), recvOK)
+		if n := cas.Left(); n != nil && n.Op() == ir.OSELRECV2 {
+			x := ir.Nod(ir.OAS, n.List().First(), recvOK)
 			x = typecheck(x, ctxStmt)
-			r.Nbody.Append(x)
+			r.PtrBody().Append(x)
 		}
 
-		r.Nbody.AppendNodes(&cas.Nbody)
-		r.Nbody.Append(ir.Nod(ir.OBREAK, nil, nil))
+		r.PtrBody().AppendNodes(cas.PtrBody())
+		r.PtrBody().Append(ir.Nod(ir.OBREAK, nil, nil))
 		init = append(init, r)
 	}
 
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 0ba7efb95e..c0f85a1e33 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -57,54 +57,54 @@ func (s *InitSchedule) tryStaticInit(n *ir.Node) bool {
 	// replaced by multiple simple OAS assignments, and the other
 	// OAS2* assignments mostly necessitate dynamic execution
 	// anyway.
-	if n.Op != ir.OAS {
+	if n.Op() != ir.OAS {
 		return false
 	}
-	if ir.IsBlank(n.Left) && candiscard(n.Right) {
+	if ir.IsBlank(n.Left()) && candiscard(n.Right()) {
 		return true
 	}
 	lno := setlineno(n)
 	defer func() { base.Pos = lno }()
-	return s.staticassign(n.Left, n.Right)
+	return s.staticassign(n.Left(), n.Right())
 }
 
 // like staticassign but we are copying an already
 // initialized value r.
 func (s *InitSchedule) staticcopy(l *ir.Node, r *ir.Node) bool {
-	if r.Op != ir.ONAME && r.Op != ir.OMETHEXPR {
+	if r.Op() != ir.ONAME && r.Op() != ir.OMETHEXPR {
 		return false
 	}
 	if r.Class() == ir.PFUNC {
 		pfuncsym(l, r)
 		return true
 	}
-	if r.Class() != ir.PEXTERN || r.Sym.Pkg != ir.LocalPkg {
+	if r.Class() != ir.PEXTERN || r.Sym().Pkg != ir.LocalPkg {
 		return false
 	}
-	if r.Name.Defn == nil { // probably zeroed but perhaps supplied externally and of unknown value
+	if r.Name().Defn == nil { // probably zeroed but perhaps supplied externally and of unknown value
 		return false
 	}
-	if r.Name.Defn.Op != ir.OAS {
+	if r.Name().Defn.Op() != ir.OAS {
 		return false
 	}
-	if r.Type.IsString() { // perhaps overwritten by cmd/link -X (#34675)
+	if r.Type().IsString() { // perhaps overwritten by cmd/link -X (#34675)
 		return false
 	}
 	orig := r
-	r = r.Name.Defn.Right
+	r = r.Name().Defn.Right()
 
-	for r.Op == ir.OCONVNOP && !types.Identical(r.Type, l.Type) {
-		r = r.Left
+	for r.Op() == ir.OCONVNOP && !types.Identical(r.Type(), l.Type()) {
+		r = r.Left()
 	}
 
-	switch r.Op {
+	switch r.Op() {
 	case ir.ONAME, ir.OMETHEXPR:
 		if s.staticcopy(l, r) {
 			return true
 		}
 		// We may have skipped past one or more OCONVNOPs, so
 		// use conv to ensure r is assignable to l (#13263).
-		s.append(ir.Nod(ir.OAS, l, conv(r, l.Type)))
+		s.append(ir.Nod(ir.OAS, l, conv(r, l.Type())))
 		return true
 
 	case ir.ONIL:
@@ -114,17 +114,17 @@ func (s *InitSchedule) staticcopy(l *ir.Node, r *ir.Node) bool {
 		if isZero(r) {
 			return true
 		}
-		litsym(l, r, int(l.Type.Width))
+		litsym(l, r, int(l.Type().Width))
 		return true
 
 	case ir.OADDR:
-		if a := r.Left; a.Op == ir.ONAME {
+		if a := r.Left(); a.Op() == ir.ONAME {
 			addrsym(l, a)
 			return true
 		}
 
 	case ir.OPTRLIT:
-		switch r.Left.Op {
+		switch r.Left().Op() {
 		case ir.OARRAYLIT, ir.OSLICELIT, ir.OSTRUCTLIT, ir.OMAPLIT:
 			// copy pointer
 			addrsym(l, s.inittemps[r])
@@ -134,7 +134,7 @@ func (s *InitSchedule) staticcopy(l *ir.Node, r *ir.Node) bool {
 	case ir.OSLICELIT:
 		// copy slice
 		a := s.inittemps[r]
-		slicesym(l, a, r.Right.Int64Val())
+		slicesym(l, a, r.Right().Int64Val())
 		return true
 
 	case ir.OARRAYLIT, ir.OSTRUCTLIT:
@@ -143,10 +143,10 @@ func (s *InitSchedule) staticcopy(l *ir.Node, r *ir.Node) bool {
 		n := ir.Copy(l)
 		for i := range p.E {
 			e := &p.E[i]
-			n.Xoffset = l.Xoffset + e.Xoffset
-			n.Type = e.Expr.Type
-			if e.Expr.Op == ir.OLITERAL || e.Expr.Op == ir.ONIL {
-				litsym(n, e.Expr, int(n.Type.Width))
+			n.SetOffset(l.Offset() + e.Xoffset)
+			n.SetType(e.Expr.Type())
+			if e.Expr.Op() == ir.OLITERAL || e.Expr.Op() == ir.ONIL {
+				litsym(n, e.Expr, int(n.Type().Width))
 				continue
 			}
 			ll := ir.SepCopy(n)
@@ -156,8 +156,8 @@ func (s *InitSchedule) staticcopy(l *ir.Node, r *ir.Node) bool {
 			// Requires computation, but we're
 			// copying someone else's computation.
 			rr := ir.SepCopy(orig)
-			rr.Type = ll.Type
-			rr.Xoffset = rr.Xoffset + e.Xoffset
+			rr.SetType(ll.Type())
+			rr.SetOffset(rr.Offset() + e.Xoffset)
 			setlineno(rr)
 			s.append(ir.Nod(ir.OAS, ll, rr))
 		}
@@ -169,11 +169,11 @@ func (s *InitSchedule) staticcopy(l *ir.Node, r *ir.Node) bool {
 }
 
 func (s *InitSchedule) staticassign(l *ir.Node, r *ir.Node) bool {
-	for r.Op == ir.OCONVNOP {
-		r = r.Left
+	for r.Op() == ir.OCONVNOP {
+		r = r.Left()
 	}
 
-	switch r.Op {
+	switch r.Op() {
 	case ir.ONAME, ir.OMETHEXPR:
 		return s.staticcopy(l, r)
 
@@ -184,36 +184,36 @@ func (s *InitSchedule) staticassign(l *ir.Node, r *ir.Node) bool {
 		if isZero(r) {
 			return true
 		}
-		litsym(l, r, int(l.Type.Width))
+		litsym(l, r, int(l.Type().Width))
 		return true
 
 	case ir.OADDR:
-		if nam := stataddr(r.Left); nam != nil {
+		if nam := stataddr(r.Left()); nam != nil {
 			addrsym(l, nam)
 			return true
 		}
 		fallthrough
 
 	case ir.OPTRLIT:
-		switch r.Left.Op {
+		switch r.Left().Op() {
 		case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT, ir.OSTRUCTLIT:
 			// Init pointer.
-			a := staticname(r.Left.Type)
+			a := staticname(r.Left().Type())
 
 			s.inittemps[r] = a
 			addrsym(l, a)
 
 			// Init underlying literal.
-			if !s.staticassign(a, r.Left) {
-				s.append(ir.Nod(ir.OAS, a, r.Left))
+			if !s.staticassign(a, r.Left()) {
+				s.append(ir.Nod(ir.OAS, a, r.Left()))
 			}
 			return true
 		}
 		//dump("not static ptrlit", r);
 
 	case ir.OSTR2BYTES:
-		if l.Class() == ir.PEXTERN && r.Left.Op == ir.OLITERAL {
-			sval := r.Left.StringVal()
+		if l.Class() == ir.PEXTERN && r.Left().Op() == ir.OLITERAL {
+			sval := r.Left().StringVal()
 			slicebytes(l, sval)
 			return true
 		}
@@ -221,8 +221,8 @@ func (s *InitSchedule) staticassign(l *ir.Node, r *ir.Node) bool {
 	case ir.OSLICELIT:
 		s.initplan(r)
 		// Init slice.
-		bound := r.Right.Int64Val()
-		ta := types.NewArray(r.Type.Elem(), bound)
+		bound := r.Right().Int64Val()
+		ta := types.NewArray(r.Type().Elem(), bound)
 		ta.SetNoalg(true)
 		a := staticname(ta)
 		s.inittemps[r] = a
@@ -238,10 +238,10 @@ func (s *InitSchedule) staticassign(l *ir.Node, r *ir.Node) bool {
 		n := ir.Copy(l)
 		for i := range p.E {
 			e := &p.E[i]
-			n.Xoffset = l.Xoffset + e.Xoffset
-			n.Type = e.Expr.Type
-			if e.Expr.Op == ir.OLITERAL || e.Expr.Op == ir.ONIL {
-				litsym(n, e.Expr, int(n.Type.Width))
+			n.SetOffset(l.Offset() + e.Xoffset)
+			n.SetType(e.Expr.Type())
+			if e.Expr.Op() == ir.OLITERAL || e.Expr.Op() == ir.ONIL {
+				litsym(n, e.Expr, int(n.Type().Width))
 				continue
 			}
 			setlineno(e.Expr)
@@ -259,11 +259,11 @@ func (s *InitSchedule) staticassign(l *ir.Node, r *ir.Node) bool {
 	case ir.OCLOSURE:
 		if hasemptycvars(r) {
 			if base.Debug.Closure > 0 {
-				base.WarnfAt(r.Pos, "closure converted to global")
+				base.WarnfAt(r.Pos(), "closure converted to global")
 			}
 			// Closures with no captured variables are globals,
 			// so the assignment can be done at link time.
-			pfuncsym(l, r.Func.Nname)
+			pfuncsym(l, r.Func().Nname)
 			return true
 		}
 		closuredebugruntimecheck(r)
@@ -274,43 +274,43 @@ func (s *InitSchedule) staticassign(l *ir.Node, r *ir.Node) bool {
 
 		// Determine the underlying concrete type and value we are converting from.
 		val := r
-		for val.Op == ir.OCONVIFACE {
-			val = val.Left
+		for val.Op() == ir.OCONVIFACE {
+			val = val.Left()
 		}
 
-		if val.Type.IsInterface() {
+		if val.Type().IsInterface() {
 			// val is an interface type.
 			// If val is nil, we can statically initialize l;
 			// both words are zero and so there no work to do, so report success.
 			// If val is non-nil, we have no concrete type to record,
 			// and we won't be able to statically initialize its value, so report failure.
-			return val.Op == ir.ONIL
+			return val.Op() == ir.ONIL
 		}
 
-		markTypeUsedInInterface(val.Type, l.Sym.Linksym())
+		markTypeUsedInInterface(val.Type(), l.Sym().Linksym())
 
 		var itab *ir.Node
-		if l.Type.IsEmptyInterface() {
-			itab = typename(val.Type)
+		if l.Type().IsEmptyInterface() {
+			itab = typename(val.Type())
 		} else {
-			itab = itabname(val.Type, l.Type)
+			itab = itabname(val.Type(), l.Type())
 		}
 
 		// Create a copy of l to modify while we emit data.
 		n := ir.Copy(l)
 
 		// Emit itab, advance offset.
-		addrsym(n, itab.Left) // itab is an OADDR node
-		n.Xoffset = n.Xoffset + int64(Widthptr)
+		addrsym(n, itab.Left()) // itab is an OADDR node
+		n.SetOffset(n.Offset() + int64(Widthptr))
 
 		// Emit data.
-		if isdirectiface(val.Type) {
-			if val.Op == ir.ONIL {
+		if isdirectiface(val.Type()) {
+			if val.Op() == ir.ONIL {
 				// Nil is zero, nothing to do.
 				return true
 			}
 			// Copy val directly into n.
-			n.Type = val.Type
+			n.SetType(val.Type())
 			setlineno(val)
 			a := ir.SepCopy(n)
 			if !s.staticassign(a, val) {
@@ -318,7 +318,7 @@ func (s *InitSchedule) staticassign(l *ir.Node, r *ir.Node) bool {
 			}
 		} else {
 			// Construct temp to hold val, write pointer to temp into n.
-			a := staticname(val.Type)
+			a := staticname(val.Type())
 			s.inittemps[val] = a
 			if !s.staticassign(a, val) {
 				s.append(ir.Nod(ir.OAS, a, val))
@@ -372,7 +372,7 @@ func staticname(t *types.Type) *ir.Node {
 	n := NewName(lookup(fmt.Sprintf("%s%d", obj.StaticNamePref, statuniqgen)))
 	statuniqgen++
 	addvar(n, t, ir.PEXTERN)
-	n.Sym.Linksym().Set(obj.AttrLocal, true)
+	n.Sym().Linksym().Set(obj.AttrLocal, true)
 	return n
 }
 
@@ -380,12 +380,12 @@ func staticname(t *types.Type) *ir.Node {
 func readonlystaticname(t *types.Type) *ir.Node {
 	n := staticname(t)
 	n.MarkReadonly()
-	n.Sym.Linksym().Set(obj.AttrContentAddressable, true)
+	n.Sym().Linksym().Set(obj.AttrContentAddressable, true)
 	return n
 }
 
 func isSimpleName(n *ir.Node) bool {
-	return (n.Op == ir.ONAME || n.Op == ir.OMETHEXPR) && n.Class() != ir.PAUTOHEAP && n.Class() != ir.PEXTERN
+	return (n.Op() == ir.ONAME || n.Op() == ir.OMETHEXPR) && n.Class() != ir.PAUTOHEAP && n.Class() != ir.PEXTERN
 }
 
 func litas(l *ir.Node, r *ir.Node, init *ir.Nodes) {
@@ -406,7 +406,7 @@ const (
 // getdyn calculates the initGenType for n.
 // If top is false, getdyn is recursing.
 func getdyn(n *ir.Node, top bool) initGenType {
-	switch n.Op {
+	switch n.Op() {
 	default:
 		if isGoConst(n) {
 			return initConst
@@ -417,7 +417,7 @@ func getdyn(n *ir.Node, top bool) initGenType {
 		if !top {
 			return initDynamic
 		}
-		if n.Right.Int64Val()/4 > int64(n.List.Len()) {
+		if n.Right().Int64Val()/4 > int64(n.List().Len()) {
 			// <25% of entries have explicit values.
 			// Very rough estimation, it takes 4 bytes of instructions
 			// to initialize 1 byte of result. So don't use a static
@@ -431,12 +431,12 @@ func getdyn(n *ir.Node, top bool) initGenType {
 	}
 
 	var mode initGenType
-	for _, n1 := range n.List.Slice() {
-		switch n1.Op {
+	for _, n1 := range n.List().Slice() {
+		switch n1.Op() {
 		case ir.OKEY:
-			n1 = n1.Right
+			n1 = n1.Right()
 		case ir.OSTRUCTKEY:
-			n1 = n1.Left
+			n1 = n1.Left()
 		}
 		mode |= getdyn(n1, false)
 		if mode == initDynamic|initConst {
@@ -448,13 +448,13 @@ func getdyn(n *ir.Node, top bool) initGenType {
 
 // isStaticCompositeLiteral reports whether n is a compile-time constant.
 func isStaticCompositeLiteral(n *ir.Node) bool {
-	switch n.Op {
+	switch n.Op() {
 	case ir.OSLICELIT:
 		return false
 	case ir.OARRAYLIT:
-		for _, r := range n.List.Slice() {
-			if r.Op == ir.OKEY {
-				r = r.Right
+		for _, r := range n.List().Slice() {
+			if r.Op() == ir.OKEY {
+				r = r.Right()
 			}
 			if !isStaticCompositeLiteral(r) {
 				return false
@@ -462,11 +462,11 @@ func isStaticCompositeLiteral(n *ir.Node) bool {
 		}
 		return true
 	case ir.OSTRUCTLIT:
-		for _, r := range n.List.Slice() {
-			if r.Op != ir.OSTRUCTKEY {
+		for _, r := range n.List().Slice() {
+			if r.Op() != ir.OSTRUCTKEY {
 				base.Fatalf("isStaticCompositeLiteral: rhs not OSTRUCTKEY: %v", r)
 			}
-			if !isStaticCompositeLiteral(r.Left) {
+			if !isStaticCompositeLiteral(r.Left()) {
 				return false
 			}
 		}
@@ -476,13 +476,13 @@ func isStaticCompositeLiteral(n *ir.Node) bool {
 	case ir.OCONVIFACE:
 		// See staticassign's OCONVIFACE case for comments.
 		val := n
-		for val.Op == ir.OCONVIFACE {
-			val = val.Left
+		for val.Op() == ir.OCONVIFACE {
+			val = val.Left()
 		}
-		if val.Type.IsInterface() {
-			return val.Op == ir.ONIL
+		if val.Type().IsInterface() {
+			return val.Op() == ir.ONIL
 		}
-		if isdirectiface(val.Type) && val.Op == ir.ONIL {
+		if isdirectiface(val.Type()) && val.Op() == ir.ONIL {
 			return true
 		}
 		return isStaticCompositeLiteral(val)
@@ -512,16 +512,16 @@ const (
 func fixedlit(ctxt initContext, kind initKind, n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
 	isBlank := var_ == ir.BlankNode
 	var splitnode func(*ir.Node) (a *ir.Node, value *ir.Node)
-	switch n.Op {
+	switch n.Op() {
 	case ir.OARRAYLIT, ir.OSLICELIT:
 		var k int64
 		splitnode = func(r *ir.Node) (*ir.Node, *ir.Node) {
-			if r.Op == ir.OKEY {
-				k = indexconst(r.Left)
+			if r.Op() == ir.OKEY {
+				k = indexconst(r.Left())
 				if k < 0 {
-					base.Fatalf("fixedlit: invalid index %v", r.Left)
+					base.Fatalf("fixedlit: invalid index %v", r.Left())
 				}
-				r = r.Right
+				r = r.Right()
 			}
 			a := ir.Nod(ir.OINDEX, var_, nodintconst(k))
 			k++
@@ -532,26 +532,26 @@ func fixedlit(ctxt initContext, kind initKind, n *ir.Node, var_ *ir.Node, init *
 		}
 	case ir.OSTRUCTLIT:
 		splitnode = func(r *ir.Node) (*ir.Node, *ir.Node) {
-			if r.Op != ir.OSTRUCTKEY {
+			if r.Op() != ir.OSTRUCTKEY {
 				base.Fatalf("fixedlit: rhs not OSTRUCTKEY: %v", r)
 			}
-			if r.Sym.IsBlank() || isBlank {
-				return ir.BlankNode, r.Left
+			if r.Sym().IsBlank() || isBlank {
+				return ir.BlankNode, r.Left()
 			}
 			setlineno(r)
-			return nodSym(ir.ODOT, var_, r.Sym), r.Left
+			return nodSym(ir.ODOT, var_, r.Sym()), r.Left()
 		}
 	default:
-		base.Fatalf("fixedlit bad op: %v", n.Op)
+		base.Fatalf("fixedlit bad op: %v", n.Op())
 	}
 
-	for _, r := range n.List.Slice() {
+	for _, r := range n.List().Slice() {
 		a, value := splitnode(r)
 		if a == ir.BlankNode && candiscard(value) {
 			continue
 		}
 
-		switch value.Op {
+		switch value.Op() {
 		case ir.OSLICELIT:
 			if (kind == initKindStatic && ctxt == inNonInitFunction) || (kind == initKindDynamic && ctxt == inInitFunction) {
 				slicelit(ctxt, value, a, init)
@@ -587,18 +587,18 @@ func fixedlit(ctxt initContext, kind initKind, n *ir.Node, var_ *ir.Node, init *
 }
 
 func isSmallSliceLit(n *ir.Node) bool {
-	if n.Op != ir.OSLICELIT {
+	if n.Op() != ir.OSLICELIT {
 		return false
 	}
 
-	r := n.Right
+	r := n.Right()
 
-	return smallintconst(r) && (n.Type.Elem().Width == 0 || r.Int64Val() <= smallArrayBytes/n.Type.Elem().Width)
+	return smallintconst(r) && (n.Type().Elem().Width == 0 || r.Int64Val() <= smallArrayBytes/n.Type().Elem().Width)
 }
 
 func slicelit(ctxt initContext, n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
 	// make an array type corresponding the number of elements we have
-	t := types.NewArray(n.Type.Elem(), n.Right.Int64Val())
+	t := types.NewArray(n.Type().Elem(), n.Right().Int64Val())
 	dowidth(t)
 
 	if ctxt == inNonInitFunction {
@@ -658,7 +658,7 @@ func slicelit(ctxt initContext, n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
 	var a *ir.Node
 	if x := prealloc[n]; x != nil {
 		// temp allocated during order.go for dddarg
-		if !types.Identical(t, x.Type) {
+		if !types.Identical(t, x.Type()) {
 			panic("dotdotdot base type does not match order's assigned type")
 		}
 
@@ -673,13 +673,13 @@ func slicelit(ctxt initContext, n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
 		}
 
 		a = ir.Nod(ir.OADDR, x, nil)
-	} else if n.Esc == EscNone {
+	} else if n.Esc() == EscNone {
 		a = temp(t)
 		if vstat == nil {
 			a = ir.Nod(ir.OAS, temp(t), nil)
 			a = typecheck(a, ctxStmt)
 			init.Append(a) // zero new temp
-			a = a.Left
+			a = a.Left()
 		} else {
 			init.Append(ir.Nod(ir.OVARDEF, a, nil))
 		}
@@ -687,7 +687,7 @@ func slicelit(ctxt initContext, n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
 		a = ir.Nod(ir.OADDR, a, nil)
 	} else {
 		a = ir.Nod(ir.ONEW, nil, nil)
-		a.List.Set1(typenod(t))
+		a.PtrList().Set1(typenod(t))
 	}
 
 	a = ir.Nod(ir.OAS, vauto, a)
@@ -707,13 +707,13 @@ func slicelit(ctxt initContext, n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
 
 	// put dynamics into array (5)
 	var index int64
-	for _, value := range n.List.Slice() {
-		if value.Op == ir.OKEY {
-			index = indexconst(value.Left)
+	for _, value := range n.List().Slice() {
+		if value.Op() == ir.OKEY {
+			index = indexconst(value.Left())
 			if index < 0 {
-				base.Fatalf("slicelit: invalid index %v", value.Left)
+				base.Fatalf("slicelit: invalid index %v", value.Left())
 			}
-			value = value.Right
+			value = value.Right()
 		}
 		a := ir.Nod(ir.OINDEX, vauto, nodintconst(index))
 		a.SetBounded(true)
@@ -721,7 +721,7 @@ func slicelit(ctxt initContext, n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
 
 		// TODO need to check bounds?
 
-		switch value.Op {
+		switch value.Op() {
 		case ir.OSLICELIT:
 			break
 
@@ -762,16 +762,16 @@ func slicelit(ctxt initContext, n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
 func maplit(n *ir.Node, m *ir.Node, init *ir.Nodes) {
 	// make the map var
 	a := ir.Nod(ir.OMAKE, nil, nil)
-	a.Esc = n.Esc
-	a.List.Set2(typenod(n.Type), nodintconst(int64(n.List.Len())))
+	a.SetEsc(n.Esc())
+	a.PtrList().Set2(typenod(n.Type()), nodintconst(int64(n.List().Len())))
 	litas(m, a, init)
 
-	entries := n.List.Slice()
+	entries := n.List().Slice()
 
 	// The order pass already removed any dynamic (runtime-computed) entries.
 	// All remaining entries are static. Double-check that.
 	for _, r := range entries {
-		if !isStaticCompositeLiteral(r.Left) || !isStaticCompositeLiteral(r.Right) {
+		if !isStaticCompositeLiteral(r.Left()) || !isStaticCompositeLiteral(r.Right()) {
 			base.Fatalf("maplit: entry is not a literal: %v", r)
 		}
 	}
@@ -780,8 +780,8 @@ func maplit(n *ir.Node, m *ir.Node, init *ir.Nodes) {
 		// For a large number of entries, put them in an array and loop.
 
 		// build types [count]Tindex and [count]Tvalue
-		tk := types.NewArray(n.Type.Key(), int64(len(entries)))
-		te := types.NewArray(n.Type.Elem(), int64(len(entries)))
+		tk := types.NewArray(n.Type().Key(), int64(len(entries)))
+		te := types.NewArray(n.Type().Elem(), int64(len(entries)))
 
 		tk.SetNoalg(true)
 		te.SetNoalg(true)
@@ -796,8 +796,8 @@ func maplit(n *ir.Node, m *ir.Node, init *ir.Nodes) {
 		datak := ir.Nod(ir.OARRAYLIT, nil, nil)
 		datae := ir.Nod(ir.OARRAYLIT, nil, nil)
 		for _, r := range entries {
-			datak.List.Append(r.Left)
-			datae.List.Append(r.Right)
+			datak.PtrList().Append(r.Left())
+			datae.PtrList().Append(r.Right())
 		}
 		fixedlit(inInitFunction, initKindStatic, datak, vstatk, init)
 		fixedlit(inInitFunction, initKindStatic, datae, vstate, init)
@@ -820,8 +820,8 @@ func maplit(n *ir.Node, m *ir.Node, init *ir.Nodes) {
 		body := ir.Nod(ir.OAS, lhs, rhs)
 
 		loop := ir.Nod(ir.OFOR, cond, incr)
-		loop.Nbody.Set1(body)
-		loop.Ninit.Set1(zero)
+		loop.PtrBody().Set1(body)
+		loop.PtrInit().Set1(zero)
 
 		loop = typecheck(loop, ctxStmt)
 		loop = walkstmt(loop)
@@ -833,11 +833,11 @@ func maplit(n *ir.Node, m *ir.Node, init *ir.Nodes) {
 	// Build list of var[c] = expr.
 	// Use temporaries so that mapassign1 can have addressable key, elem.
 	// TODO(josharian): avoid map key temporaries for mapfast_* assignments with literal keys.
-	tmpkey := temp(m.Type.Key())
-	tmpelem := temp(m.Type.Elem())
+	tmpkey := temp(m.Type().Key())
+	tmpelem := temp(m.Type().Elem())
 
 	for _, r := range entries {
-		index, elem := r.Left, r.Right
+		index, elem := r.Left(), r.Right()
 
 		setlineno(index)
 		a := ir.Nod(ir.OAS, tmpkey, index)
@@ -867,10 +867,10 @@ func maplit(n *ir.Node, m *ir.Node, init *ir.Nodes) {
 }
 
 func anylit(n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
-	t := n.Type
-	switch n.Op {
+	t := n.Type()
+	switch n.Op() {
 	default:
-		base.Fatalf("anylit: not lit, op=%v node=%v", n.Op, n)
+		base.Fatalf("anylit: not lit, op=%v node=%v", n.Op(), n)
 
 	case ir.ONAME, ir.OMETHEXPR:
 		a := ir.Nod(ir.OAS, var_, n)
@@ -883,16 +883,16 @@ func anylit(n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
 		}
 
 		var r *ir.Node
-		if n.Right != nil {
+		if n.Right() != nil {
 			// n.Right is stack temporary used as backing store.
-			init.Append(ir.Nod(ir.OAS, n.Right, nil)) // zero backing store, just in case (#18410)
-			r = ir.Nod(ir.OADDR, n.Right, nil)
+			init.Append(ir.Nod(ir.OAS, n.Right(), nil)) // zero backing store, just in case (#18410)
+			r = ir.Nod(ir.OADDR, n.Right(), nil)
 			r = typecheck(r, ctxExpr)
 		} else {
 			r = ir.Nod(ir.ONEW, nil, nil)
 			r.SetTypecheck(1)
-			r.Type = t
-			r.Esc = n.Esc
+			r.SetType(t)
+			r.SetEsc(n.Esc())
 		}
 
 		r = walkexpr(r, init)
@@ -903,19 +903,19 @@ func anylit(n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
 
 		var_ = ir.Nod(ir.ODEREF, var_, nil)
 		var_ = typecheck(var_, ctxExpr|ctxAssign)
-		anylit(n.Left, var_, init)
+		anylit(n.Left(), var_, init)
 
 	case ir.OSTRUCTLIT, ir.OARRAYLIT:
 		if !t.IsStruct() && !t.IsArray() {
 			base.Fatalf("anylit: not struct/array")
 		}
 
-		if isSimpleName(var_) && n.List.Len() > 4 {
+		if isSimpleName(var_) && n.List().Len() > 4 {
 			// lay out static data
 			vstat := readonlystaticname(t)
 
 			ctxt := inInitFunction
-			if n.Op == ir.OARRAYLIT {
+			if n.Op() == ir.OARRAYLIT {
 				ctxt = inNonInitFunction
 			}
 			fixedlit(ctxt, initKindStatic, n, vstat, init)
@@ -933,13 +933,13 @@ func anylit(n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
 		}
 
 		var components int64
-		if n.Op == ir.OARRAYLIT {
+		if n.Op() == ir.OARRAYLIT {
 			components = t.NumElem()
 		} else {
 			components = int64(t.NumFields())
 		}
 		// initialization of an array or struct with unspecified components (missing fields or arrays)
-		if isSimpleName(var_) || int64(n.List.Len()) < components {
+		if isSimpleName(var_) || int64(n.List().Len()) < components {
 			a := ir.Nod(ir.OAS, var_, nil)
 			a = typecheck(a, ctxStmt)
 			a = walkexpr(a, init)
@@ -960,38 +960,38 @@ func anylit(n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
 }
 
 func oaslit(n *ir.Node, init *ir.Nodes) bool {
-	if n.Left == nil || n.Right == nil {
+	if n.Left() == nil || n.Right() == nil {
 		// not a special composite literal assignment
 		return false
 	}
-	if n.Left.Type == nil || n.Right.Type == nil {
+	if n.Left().Type() == nil || n.Right().Type() == nil {
 		// not a special composite literal assignment
 		return false
 	}
-	if !isSimpleName(n.Left) {
+	if !isSimpleName(n.Left()) {
 		// not a special composite literal assignment
 		return false
 	}
-	if !types.Identical(n.Left.Type, n.Right.Type) {
+	if !types.Identical(n.Left().Type(), n.Right().Type()) {
 		// not a special composite literal assignment
 		return false
 	}
 
-	switch n.Right.Op {
+	switch n.Right().Op() {
 	default:
 		// not a special composite literal assignment
 		return false
 
 	case ir.OSTRUCTLIT, ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT:
-		if vmatch1(n.Left, n.Right) {
+		if vmatch1(n.Left(), n.Right()) {
 			// not a special composite literal assignment
 			return false
 		}
-		anylit(n.Right, n.Left, init)
+		anylit(n.Right(), n.Left(), init)
 	}
 
-	n.Op = ir.OEMPTY
-	n.Right = nil
+	n.SetOp(ir.OEMPTY)
+	n.SetRight(nil)
 	return true
 }
 
@@ -1008,38 +1008,38 @@ func stataddr(n *ir.Node) *ir.Node {
 		return nil
 	}
 
-	switch n.Op {
+	switch n.Op() {
 	case ir.ONAME, ir.OMETHEXPR:
 		return ir.SepCopy(n)
 
 	case ir.ODOT:
-		nam := stataddr(n.Left)
+		nam := stataddr(n.Left())
 		if nam == nil {
 			break
 		}
-		nam.Xoffset = nam.Xoffset + n.Xoffset
-		nam.Type = n.Type
+		nam.SetOffset(nam.Offset() + n.Offset())
+		nam.SetType(n.Type())
 		return nam
 
 	case ir.OINDEX:
-		if n.Left.Type.IsSlice() {
+		if n.Left().Type().IsSlice() {
 			break
 		}
-		nam := stataddr(n.Left)
+		nam := stataddr(n.Left())
 		if nam == nil {
 			break
 		}
-		l := getlit(n.Right)
+		l := getlit(n.Right())
 		if l < 0 {
 			break
 		}
 
 		// Check for overflow.
-		if n.Type.Width != 0 && thearch.MAXWIDTH/n.Type.Width <= int64(l) {
+		if n.Type().Width != 0 && thearch.MAXWIDTH/n.Type().Width <= int64(l) {
 			break
 		}
-		nam.Xoffset = nam.Xoffset + int64(l)*n.Type.Width
-		nam.Type = n.Type
+		nam.SetOffset(nam.Offset() + int64(l)*n.Type().Width)
+		nam.SetType(n.Type())
 		return nam
 	}
 
@@ -1052,41 +1052,41 @@ func (s *InitSchedule) initplan(n *ir.Node) {
 	}
 	p := new(InitPlan)
 	s.initplans[n] = p
-	switch n.Op {
+	switch n.Op() {
 	default:
 		base.Fatalf("initplan")
 
 	case ir.OARRAYLIT, ir.OSLICELIT:
 		var k int64
-		for _, a := range n.List.Slice() {
-			if a.Op == ir.OKEY {
-				k = indexconst(a.Left)
+		for _, a := range n.List().Slice() {
+			if a.Op() == ir.OKEY {
+				k = indexconst(a.Left())
 				if k < 0 {
-					base.Fatalf("initplan arraylit: invalid index %v", a.Left)
+					base.Fatalf("initplan arraylit: invalid index %v", a.Left())
 				}
-				a = a.Right
+				a = a.Right()
 			}
-			s.addvalue(p, k*n.Type.Elem().Width, a)
+			s.addvalue(p, k*n.Type().Elem().Width, a)
 			k++
 		}
 
 	case ir.OSTRUCTLIT:
-		for _, a := range n.List.Slice() {
-			if a.Op != ir.OSTRUCTKEY {
+		for _, a := range n.List().Slice() {
+			if a.Op() != ir.OSTRUCTKEY {
 				base.Fatalf("initplan structlit")
 			}
-			if a.Sym.IsBlank() {
+			if a.Sym().IsBlank() {
 				continue
 			}
-			s.addvalue(p, a.Xoffset, a.Left)
+			s.addvalue(p, a.Offset(), a.Left())
 		}
 
 	case ir.OMAPLIT:
-		for _, a := range n.List.Slice() {
-			if a.Op != ir.OKEY {
+		for _, a := range n.List().Slice() {
+			if a.Op() != ir.OKEY {
 				base.Fatalf("initplan maplit")
 			}
-			s.addvalue(p, -1, a.Right)
+			s.addvalue(p, -1, a.Right())
 		}
 	}
 }
@@ -1114,7 +1114,7 @@ func (s *InitSchedule) addvalue(p *InitPlan, xoffset int64, n *ir.Node) {
 }
 
 func isZero(n *ir.Node) bool {
-	switch n.Op {
+	switch n.Op() {
 	case ir.ONIL:
 		return true
 
@@ -1129,9 +1129,9 @@ func isZero(n *ir.Node) bool {
 		}
 
 	case ir.OARRAYLIT:
-		for _, n1 := range n.List.Slice() {
-			if n1.Op == ir.OKEY {
-				n1 = n1.Right
+		for _, n1 := range n.List().Slice() {
+			if n1.Op() == ir.OKEY {
+				n1 = n1.Right()
 			}
 			if !isZero(n1) {
 				return false
@@ -1140,8 +1140,8 @@ func isZero(n *ir.Node) bool {
 		return true
 
 	case ir.OSTRUCTLIT:
-		for _, n1 := range n.List.Slice() {
-			if !isZero(n1.Left) {
+		for _, n1 := range n.List().Slice() {
+			if !isZero(n1.Left()) {
 				return false
 			}
 		}
@@ -1152,25 +1152,25 @@ func isZero(n *ir.Node) bool {
 }
 
 func isvaluelit(n *ir.Node) bool {
-	return n.Op == ir.OARRAYLIT || n.Op == ir.OSTRUCTLIT
+	return n.Op() == ir.OARRAYLIT || n.Op() == ir.OSTRUCTLIT
 }
 
 func genAsStatic(as *ir.Node) {
-	if as.Left.Type == nil {
+	if as.Left().Type() == nil {
 		base.Fatalf("genAsStatic as.Left not typechecked")
 	}
 
-	nam := stataddr(as.Left)
-	if nam == nil || (nam.Class() != ir.PEXTERN && as.Left != ir.BlankNode) {
-		base.Fatalf("genAsStatic: lhs %v", as.Left)
+	nam := stataddr(as.Left())
+	if nam == nil || (nam.Class() != ir.PEXTERN && as.Left() != ir.BlankNode) {
+		base.Fatalf("genAsStatic: lhs %v", as.Left())
 	}
 
 	switch {
-	case as.Right.Op == ir.OLITERAL:
-		litsym(nam, as.Right, int(as.Right.Type.Width))
-	case (as.Right.Op == ir.ONAME || as.Right.Op == ir.OMETHEXPR) && as.Right.Class() == ir.PFUNC:
-		pfuncsym(nam, as.Right)
+	case as.Right().Op() == ir.OLITERAL:
+		litsym(nam, as.Right(), int(as.Right().Type().Width))
+	case (as.Right().Op() == ir.ONAME || as.Right().Op() == ir.OMETHEXPR) && as.Right().Class() == ir.PFUNC:
+		pfuncsym(nam, as.Right())
 	default:
-		base.Fatalf("genAsStatic: rhs %v", as.Right)
+		base.Fatalf("genAsStatic: rhs %v", as.Right())
 	}
 }
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 5cee3fab85..018b94d9d8 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -187,8 +187,8 @@ func initssaconfig() {
 // considered as the 0th parameter. This does not include the receiver of an
 // interface call.
 func getParam(n *ir.Node, i int) *types.Field {
-	t := n.Left.Type
-	if n.Op == ir.OCALLMETH {
+	t := n.Left().Type()
+	if n.Op() == ir.OCALLMETH {
 		if i == 0 {
 			return t.Recv()
 		}
@@ -242,8 +242,8 @@ func dvarint(x *obj.LSym, off int, v int64) int {
 //      - Size of the argument
 //      - Offset of where argument should be placed in the args frame when making call
 func (s *state) emitOpenDeferInfo() {
-	x := base.Ctxt.Lookup(s.curfn.Func.LSym.Name + ".opendefer")
-	s.curfn.Func.LSym.Func().OpenCodedDeferInfo = x
+	x := base.Ctxt.Lookup(s.curfn.Func().LSym.Name + ".opendefer")
+	s.curfn.Func().LSym.Func().OpenCodedDeferInfo = x
 	off := 0
 
 	// Compute maxargsize (max size of arguments for all defers)
@@ -251,20 +251,20 @@ func (s *state) emitOpenDeferInfo() {
 	var maxargsize int64
 	for i := len(s.openDefers) - 1; i >= 0; i-- {
 		r := s.openDefers[i]
-		argsize := r.n.Left.Type.ArgWidth()
+		argsize := r.n.Left().Type().ArgWidth()
 		if argsize > maxargsize {
 			maxargsize = argsize
 		}
 	}
 	off = dvarint(x, off, maxargsize)
-	off = dvarint(x, off, -s.deferBitsTemp.Xoffset)
+	off = dvarint(x, off, -s.deferBitsTemp.Offset())
 	off = dvarint(x, off, int64(len(s.openDefers)))
 
 	// Write in reverse-order, for ease of running in that order at runtime
 	for i := len(s.openDefers) - 1; i >= 0; i-- {
 		r := s.openDefers[i]
-		off = dvarint(x, off, r.n.Left.Type.ArgWidth())
-		off = dvarint(x, off, -r.closureNode.Xoffset)
+		off = dvarint(x, off, r.n.Left().Type().ArgWidth())
+		off = dvarint(x, off, -r.closureNode.Offset())
 		numArgs := len(r.argNodes)
 		if r.rcvrNode != nil {
 			// If there's an interface receiver, treat/place it as the first
@@ -274,13 +274,13 @@ func (s *state) emitOpenDeferInfo() {
 		}
 		off = dvarint(x, off, int64(numArgs))
 		if r.rcvrNode != nil {
-			off = dvarint(x, off, -r.rcvrNode.Xoffset)
+			off = dvarint(x, off, -r.rcvrNode.Offset())
 			off = dvarint(x, off, s.config.PtrSize)
 			off = dvarint(x, off, 0)
 		}
 		for j, arg := range r.argNodes {
 			f := getParam(r.n, j)
-			off = dvarint(x, off, -arg.Xoffset)
+			off = dvarint(x, off, -arg.Offset())
 			off = dvarint(x, off, f.Type.Size())
 			off = dvarint(x, off, f.Offset)
 		}
@@ -298,9 +298,9 @@ func buildssa(fn *ir.Node, worker int) *ssa.Func {
 	var astBuf *bytes.Buffer
 	if printssa {
 		astBuf = &bytes.Buffer{}
-		ir.FDumpList(astBuf, "buildssa-enter", fn.Func.Enter)
-		ir.FDumpList(astBuf, "buildssa-body", fn.Nbody)
-		ir.FDumpList(astBuf, "buildssa-exit", fn.Func.Exit)
+		ir.FDumpList(astBuf, "buildssa-enter", fn.Func().Enter)
+		ir.FDumpList(astBuf, "buildssa-body", fn.Body())
+		ir.FDumpList(astBuf, "buildssa-exit", fn.Func().Exit)
 		if ssaDumpStdout {
 			fmt.Println("generating SSA for", name)
 			fmt.Print(astBuf.String())
@@ -308,11 +308,11 @@ func buildssa(fn *ir.Node, worker int) *ssa.Func {
 	}
 
 	var s state
-	s.pushLine(fn.Pos)
+	s.pushLine(fn.Pos())
 	defer s.popLine()
 
-	s.hasdefer = fn.Func.HasDefer()
-	if fn.Func.Pragma&ir.CgoUnsafeArgs != 0 {
+	s.hasdefer = fn.Func().HasDefer()
+	if fn.Func().Pragma&ir.CgoUnsafeArgs != 0 {
 		s.cgoUnsafeArgs = true
 	}
 
@@ -324,14 +324,14 @@ func buildssa(fn *ir.Node, worker int) *ssa.Func {
 
 	s.f = ssa.NewFunc(&fe)
 	s.config = ssaConfig
-	s.f.Type = fn.Type
+	s.f.Type = fn.Type()
 	s.f.Config = ssaConfig
 	s.f.Cache = &ssaCaches[worker]
 	s.f.Cache.Reset()
 	s.f.Name = name
 	s.f.DebugTest = s.f.DebugHashMatch("GOSSAHASH")
 	s.f.PrintOrHtmlSSA = printssa
-	if fn.Func.Pragma&ir.Nosplit != 0 {
+	if fn.Func().Pragma&ir.Nosplit != 0 {
 		s.f.NoSplit = true
 	}
 	s.panics = map[funcLine]*ssa.Block{}
@@ -339,7 +339,7 @@ func buildssa(fn *ir.Node, worker int) *ssa.Func {
 
 	// Allocate starting block
 	s.f.Entry = s.f.NewBlock(ssa.BlockPlain)
-	s.f.Entry.Pos = fn.Pos
+	s.f.Entry.Pos = fn.Pos()
 
 	if printssa {
 		ssaDF := ssaDumpFile
@@ -360,7 +360,7 @@ func buildssa(fn *ir.Node, worker int) *ssa.Func {
 	s.fwdVars = map[*ir.Node]*ssa.Value{}
 	s.startmem = s.entryNewValue0(ssa.OpInitMem, types.TypeMem)
 
-	s.hasOpenDefers = base.Flag.N == 0 && s.hasdefer && !s.curfn.Func.OpenCodedDeferDisallowed()
+	s.hasOpenDefers = base.Flag.N == 0 && s.hasdefer && !s.curfn.Func().OpenCodedDeferDisallowed()
 	switch {
 	case s.hasOpenDefers && (base.Ctxt.Flag_shared || base.Ctxt.Flag_dynlink) && thearch.LinkArch.Name == "386":
 		// Don't support open-coded defers for 386 ONLY when using shared
@@ -369,7 +369,7 @@ func buildssa(fn *ir.Node, worker int) *ssa.Func {
 		// that we don't track correctly.
 		s.hasOpenDefers = false
 	}
-	if s.hasOpenDefers && s.curfn.Func.Exit.Len() > 0 {
+	if s.hasOpenDefers && s.curfn.Func().Exit.Len() > 0 {
 		// Skip doing open defers if there is any extra exit code (likely
 		// copying heap-allocated return values or race detection), since
 		// we will not generate that code in the case of the extra
@@ -377,7 +377,7 @@ func buildssa(fn *ir.Node, worker int) *ssa.Func {
 		s.hasOpenDefers = false
 	}
 	if s.hasOpenDefers &&
-		s.curfn.Func.NumReturns*s.curfn.Func.NumDefers > 15 {
+		s.curfn.Func().NumReturns*s.curfn.Func().NumDefers > 15 {
 		// Since we are generating defer calls at every exit for
 		// open-coded defers, skip doing open-coded defers if there are
 		// too many returns (especially if there are multiple defers).
@@ -414,14 +414,14 @@ func buildssa(fn *ir.Node, worker int) *ssa.Func {
 	s.decladdrs = map[*ir.Node]*ssa.Value{}
 	var args []ssa.Param
 	var results []ssa.Param
-	for _, n := range fn.Func.Dcl {
+	for _, n := range fn.Func().Dcl {
 		switch n.Class() {
 		case ir.PPARAM:
-			s.decladdrs[n] = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(n.Type), n, s.sp, s.startmem)
-			args = append(args, ssa.Param{Type: n.Type, Offset: int32(n.Xoffset)})
+			s.decladdrs[n] = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(n.Type()), n, s.sp, s.startmem)
+			args = append(args, ssa.Param{Type: n.Type(), Offset: int32(n.Offset())})
 		case ir.PPARAMOUT:
-			s.decladdrs[n] = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(n.Type), n, s.sp, s.startmem)
-			results = append(results, ssa.Param{Type: n.Type, Offset: int32(n.Xoffset)})
+			s.decladdrs[n] = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(n.Type()), n, s.sp, s.startmem)
+			results = append(results, ssa.Param{Type: n.Type(), Offset: int32(n.Offset())})
 			if s.canSSA(n) {
 				// Save ssa-able PPARAMOUT variables so we can
 				// store them back to the stack at the end of
@@ -441,21 +441,21 @@ func buildssa(fn *ir.Node, worker int) *ssa.Func {
 	}
 
 	// Populate SSAable arguments.
-	for _, n := range fn.Func.Dcl {
+	for _, n := range fn.Func().Dcl {
 		if n.Class() == ir.PPARAM && s.canSSA(n) {
-			v := s.newValue0A(ssa.OpArg, n.Type, n)
+			v := s.newValue0A(ssa.OpArg, n.Type(), n)
 			s.vars[n] = v
 			s.addNamedValue(n, v) // This helps with debugging information, not needed for compilation itself.
 		}
 	}
 
 	// Convert the AST-based IR to the SSA-based IR
-	s.stmtList(fn.Func.Enter)
-	s.stmtList(fn.Nbody)
+	s.stmtList(fn.Func().Enter)
+	s.stmtList(fn.Body())
 
 	// fallthrough to exit
 	if s.curBlock != nil {
-		s.pushLine(fn.Func.Endlineno)
+		s.pushLine(fn.Func().Endlineno)
 		s.exit()
 		s.popLine()
 	}
@@ -480,8 +480,8 @@ func buildssa(fn *ir.Node, worker int) *ssa.Func {
 
 func dumpSourcesColumn(writer *ssa.HTMLWriter, fn *ir.Node) {
 	// Read sources of target function fn.
-	fname := base.Ctxt.PosTable.Pos(fn.Pos).Filename()
-	targetFn, err := readFuncLines(fname, fn.Pos.Line(), fn.Func.Endlineno.Line())
+	fname := base.Ctxt.PosTable.Pos(fn.Pos()).Filename()
+	targetFn, err := readFuncLines(fname, fn.Pos().Line(), fn.Func().Endlineno.Line())
 	if err != nil {
 		writer.Logf("cannot read sources for function %v: %v", fn, err)
 	}
@@ -490,14 +490,14 @@ func dumpSourcesColumn(writer *ssa.HTMLWriter, fn *ir.Node) {
 	var inlFns []*ssa.FuncLines
 	for _, fi := range ssaDumpInlined {
 		var elno src.XPos
-		if fi.Name.Defn == nil {
+		if fi.Name().Defn == nil {
 			// Endlineno is filled from exported data.
-			elno = fi.Func.Endlineno
+			elno = fi.Func().Endlineno
 		} else {
-			elno = fi.Name.Defn.Func.Endlineno
+			elno = fi.Name().Defn.Func().Endlineno
 		}
-		fname := base.Ctxt.PosTable.Pos(fi.Pos).Filename()
-		fnLines, err := readFuncLines(fname, fi.Pos.Line(), elno.Line())
+		fname := base.Ctxt.PosTable.Pos(fi.Pos()).Filename()
+		fnLines, err := readFuncLines(fname, fi.Pos().Line(), elno.Line())
 		if err != nil {
 			writer.Logf("cannot read sources for inlined function %v: %v", fi, err)
 			continue
@@ -974,7 +974,7 @@ func (s *state) newValueOrSfCall2(op ssa.Op, t *types.Type, arg0, arg1 *ssa.Valu
 }
 
 func (s *state) instrument(t *types.Type, addr *ssa.Value, wr bool) {
-	if !s.curfn.Func.InstrumentBody() {
+	if !s.curfn.Func().InstrumentBody() {
 		return
 	}
 
@@ -1060,23 +1060,23 @@ func (s *state) stmtList(l ir.Nodes) {
 
 // stmt converts the statement n to SSA and adds it to s.
 func (s *state) stmt(n *ir.Node) {
-	if !(n.Op == ir.OVARKILL || n.Op == ir.OVARLIVE || n.Op == ir.OVARDEF) {
+	if !(n.Op() == ir.OVARKILL || n.Op() == ir.OVARLIVE || n.Op() == ir.OVARDEF) {
 		// OVARKILL, OVARLIVE, and OVARDEF are invisible to the programmer, so we don't use their line numbers to avoid confusion in debugging.
-		s.pushLine(n.Pos)
+		s.pushLine(n.Pos())
 		defer s.popLine()
 	}
 
 	// If s.curBlock is nil, and n isn't a label (which might have an associated goto somewhere),
 	// then this code is dead. Stop here.
-	if s.curBlock == nil && n.Op != ir.OLABEL {
+	if s.curBlock == nil && n.Op() != ir.OLABEL {
 		return
 	}
 
-	s.stmtList(n.Ninit)
-	switch n.Op {
+	s.stmtList(n.Init())
+	switch n.Op() {
 
 	case ir.OBLOCK:
-		s.stmtList(n.List)
+		s.stmtList(n.List())
 
 	// No-ops
 	case ir.OEMPTY, ir.ODCLCONST, ir.ODCLTYPE, ir.OFALL:
@@ -1091,9 +1091,9 @@ func (s *state) stmt(n *ir.Node) {
 
 	case ir.OCALLMETH, ir.OCALLINTER:
 		s.callResult(n, callNormal)
-		if n.Op == ir.OCALLFUNC && n.Left.Op == ir.ONAME && n.Left.Class() == ir.PFUNC {
-			if fn := n.Left.Sym.Name; base.Flag.CompilingRuntime && fn == "throw" ||
-				n.Left.Sym.Pkg == Runtimepkg && (fn == "throwinit" || fn == "gopanic" || fn == "panicwrap" || fn == "block" || fn == "panicmakeslicelen" || fn == "panicmakeslicecap") {
+		if n.Op() == ir.OCALLFUNC && n.Left().Op() == ir.ONAME && n.Left().Class() == ir.PFUNC {
+			if fn := n.Left().Sym().Name; base.Flag.CompilingRuntime && fn == "throw" ||
+				n.Left().Sym().Pkg == Runtimepkg && (fn == "throwinit" || fn == "gopanic" || fn == "panicwrap" || fn == "block" || fn == "panicmakeslicelen" || fn == "panicmakeslicecap") {
 				m := s.mem()
 				b := s.endBlock()
 				b.Kind = ssa.BlockExit
@@ -1108,29 +1108,29 @@ func (s *state) stmt(n *ir.Node) {
 			var defertype string
 			if s.hasOpenDefers {
 				defertype = "open-coded"
-			} else if n.Esc == EscNever {
+			} else if n.Esc() == EscNever {
 				defertype = "stack-allocated"
 			} else {
 				defertype = "heap-allocated"
 			}
-			base.WarnfAt(n.Pos, "%s defer", defertype)
+			base.WarnfAt(n.Pos(), "%s defer", defertype)
 		}
 		if s.hasOpenDefers {
-			s.openDeferRecord(n.Left)
+			s.openDeferRecord(n.Left())
 		} else {
 			d := callDefer
-			if n.Esc == EscNever {
+			if n.Esc() == EscNever {
 				d = callDeferStack
 			}
-			s.callResult(n.Left, d)
+			s.callResult(n.Left(), d)
 		}
 	case ir.OGO:
-		s.callResult(n.Left, callGo)
+		s.callResult(n.Left(), callGo)
 
 	case ir.OAS2DOTTYPE:
-		res, resok := s.dottype(n.Right, true)
+		res, resok := s.dottype(n.Right(), true)
 		deref := false
-		if !canSSAType(n.Right.Type) {
+		if !canSSAType(n.Right().Type()) {
 			if res.Op != ssa.OpLoad {
 				s.Fatalf("dottype of non-load")
 			}
@@ -1144,29 +1144,29 @@ func (s *state) stmt(n *ir.Node) {
 			deref = true
 			res = res.Args[0]
 		}
-		s.assign(n.List.First(), res, deref, 0)
-		s.assign(n.List.Second(), resok, false, 0)
+		s.assign(n.List().First(), res, deref, 0)
+		s.assign(n.List().Second(), resok, false, 0)
 		return
 
 	case ir.OAS2FUNC:
 		// We come here only when it is an intrinsic call returning two values.
-		if !isIntrinsicCall(n.Right) {
-			s.Fatalf("non-intrinsic AS2FUNC not expanded %v", n.Right)
-		}
-		v := s.intrinsicCall(n.Right)
-		v1 := s.newValue1(ssa.OpSelect0, n.List.First().Type, v)
-		v2 := s.newValue1(ssa.OpSelect1, n.List.Second().Type, v)
-		s.assign(n.List.First(), v1, false, 0)
-		s.assign(n.List.Second(), v2, false, 0)
+		if !isIntrinsicCall(n.Right()) {
+			s.Fatalf("non-intrinsic AS2FUNC not expanded %v", n.Right())
+		}
+		v := s.intrinsicCall(n.Right())
+		v1 := s.newValue1(ssa.OpSelect0, n.List().First().Type(), v)
+		v2 := s.newValue1(ssa.OpSelect1, n.List().Second().Type(), v)
+		s.assign(n.List().First(), v1, false, 0)
+		s.assign(n.List().Second(), v2, false, 0)
 		return
 
 	case ir.ODCL:
-		if n.Left.Class() == ir.PAUTOHEAP {
+		if n.Left().Class() == ir.PAUTOHEAP {
 			s.Fatalf("DCL %v", n)
 		}
 
 	case ir.OLABEL:
-		sym := n.Sym
+		sym := n.Sym()
 		lab := s.label(sym)
 
 		// Associate label with its control flow node, if any
@@ -1188,7 +1188,7 @@ func (s *state) stmt(n *ir.Node) {
 		s.startBlock(lab.target)
 
 	case ir.OGOTO:
-		sym := n.Sym
+		sym := n.Sym()
 
 		lab := s.label(sym)
 		if lab.target == nil {
@@ -1200,7 +1200,7 @@ func (s *state) stmt(n *ir.Node) {
 		b.AddEdgeTo(lab.target)
 
 	case ir.OAS:
-		if n.Left == n.Right && n.Left.Op == ir.ONAME {
+		if n.Left() == n.Right() && n.Left().Op() == ir.ONAME {
 			// An x=x assignment. No point in doing anything
 			// here. In addition, skipping this assignment
 			// prevents generating:
@@ -1212,9 +1212,9 @@ func (s *state) stmt(n *ir.Node) {
 		}
 
 		// Evaluate RHS.
-		rhs := n.Right
+		rhs := n.Right()
 		if rhs != nil {
-			switch rhs.Op {
+			switch rhs.Op() {
 			case ir.OSTRUCTLIT, ir.OARRAYLIT, ir.OSLICELIT:
 				// All literals with nonzero fields have already been
 				// rewritten during walk. Any that remain are just T{}
@@ -1227,27 +1227,27 @@ func (s *state) stmt(n *ir.Node) {
 				// Check whether we're writing the result of an append back to the same slice.
 				// If so, we handle it specially to avoid write barriers on the fast
 				// (non-growth) path.
-				if !samesafeexpr(n.Left, rhs.List.First()) || base.Flag.N != 0 {
+				if !samesafeexpr(n.Left(), rhs.List().First()) || base.Flag.N != 0 {
 					break
 				}
 				// If the slice can be SSA'd, it'll be on the stack,
 				// so there will be no write barriers,
 				// so there's no need to attempt to prevent them.
-				if s.canSSA(n.Left) {
+				if s.canSSA(n.Left()) {
 					if base.Debug.Append > 0 { // replicating old diagnostic message
-						base.WarnfAt(n.Pos, "append: len-only update (in local slice)")
+						base.WarnfAt(n.Pos(), "append: len-only update (in local slice)")
 					}
 					break
 				}
 				if base.Debug.Append > 0 {
-					base.WarnfAt(n.Pos, "append: len-only update")
+					base.WarnfAt(n.Pos(), "append: len-only update")
 				}
 				s.append(rhs, true)
 				return
 			}
 		}
 
-		if ir.IsBlank(n.Left) {
+		if ir.IsBlank(n.Left()) {
 			// _ = rhs
 			// Just evaluate rhs for side-effects.
 			if rhs != nil {
@@ -1257,10 +1257,10 @@ func (s *state) stmt(n *ir.Node) {
 		}
 
 		var t *types.Type
-		if n.Right != nil {
-			t = n.Right.Type
+		if n.Right() != nil {
+			t = n.Right().Type()
 		} else {
-			t = n.Left.Type
+			t = n.Left().Type()
 		}
 
 		var r *ssa.Value
@@ -1280,11 +1280,11 @@ func (s *state) stmt(n *ir.Node) {
 		}
 
 		var skip skipMask
-		if rhs != nil && (rhs.Op == ir.OSLICE || rhs.Op == ir.OSLICE3 || rhs.Op == ir.OSLICESTR) && samesafeexpr(rhs.Left, n.Left) {
+		if rhs != nil && (rhs.Op() == ir.OSLICE || rhs.Op() == ir.OSLICE3 || rhs.Op() == ir.OSLICESTR) && samesafeexpr(rhs.Left(), n.Left()) {
 			// We're assigning a slicing operation back to its source.
 			// Don't write back fields we aren't changing. See issue #14855.
 			i, j, k := rhs.SliceBounds()
-			if i != nil && (i.Op == ir.OLITERAL && i.Val().Kind() == constant.Int && i.Int64Val() == 0) {
+			if i != nil && (i.Op() == ir.OLITERAL && i.Val().Kind() == constant.Int && i.Int64Val() == 0) {
 				// [0:...] is the same as [:...]
 				i = nil
 			}
@@ -1309,15 +1309,15 @@ func (s *state) stmt(n *ir.Node) {
 			}
 		}
 
-		s.assign(n.Left, r, deref, skip)
+		s.assign(n.Left(), r, deref, skip)
 
 	case ir.OIF:
-		if ir.IsConst(n.Left, constant.Bool) {
-			s.stmtList(n.Left.Ninit)
-			if n.Left.BoolVal() {
-				s.stmtList(n.Nbody)
+		if ir.IsConst(n.Left(), constant.Bool) {
+			s.stmtList(n.Left().Init())
+			if n.Left().BoolVal() {
+				s.stmtList(n.Body())
 			} else {
-				s.stmtList(n.Rlist)
+				s.stmtList(n.Rlist())
 			}
 			break
 		}
@@ -1328,29 +1328,29 @@ func (s *state) stmt(n *ir.Node) {
 			likely = 1
 		}
 		var bThen *ssa.Block
-		if n.Nbody.Len() != 0 {
+		if n.Body().Len() != 0 {
 			bThen = s.f.NewBlock(ssa.BlockPlain)
 		} else {
 			bThen = bEnd
 		}
 		var bElse *ssa.Block
-		if n.Rlist.Len() != 0 {
+		if n.Rlist().Len() != 0 {
 			bElse = s.f.NewBlock(ssa.BlockPlain)
 		} else {
 			bElse = bEnd
 		}
-		s.condBranch(n.Left, bThen, bElse, likely)
+		s.condBranch(n.Left(), bThen, bElse, likely)
 
-		if n.Nbody.Len() != 0 {
+		if n.Body().Len() != 0 {
 			s.startBlock(bThen)
-			s.stmtList(n.Nbody)
+			s.stmtList(n.Body())
 			if b := s.endBlock(); b != nil {
 				b.AddEdgeTo(bEnd)
 			}
 		}
-		if n.Rlist.Len() != 0 {
+		if n.Rlist().Len() != 0 {
 			s.startBlock(bElse)
-			s.stmtList(n.Rlist)
+			s.stmtList(n.Rlist())
 			if b := s.endBlock(); b != nil {
 				b.AddEdgeTo(bEnd)
 			}
@@ -1358,21 +1358,21 @@ func (s *state) stmt(n *ir.Node) {
 		s.startBlock(bEnd)
 
 	case ir.ORETURN:
-		s.stmtList(n.List)
+		s.stmtList(n.List())
 		b := s.exit()
 		b.Pos = s.lastPos.WithIsStmt()
 
 	case ir.ORETJMP:
-		s.stmtList(n.List)
+		s.stmtList(n.List())
 		b := s.exit()
 		b.Kind = ssa.BlockRetJmp // override BlockRet
-		b.Aux = n.Sym.Linksym()
+		b.Aux = n.Sym().Linksym()
 
 	case ir.OCONTINUE, ir.OBREAK:
 		var to *ssa.Block
-		if n.Sym == nil {
+		if n.Sym() == nil {
 			// plain break/continue
-			switch n.Op {
+			switch n.Op() {
 			case ir.OCONTINUE:
 				to = s.continueTo
 			case ir.OBREAK:
@@ -1380,9 +1380,9 @@ func (s *state) stmt(n *ir.Node) {
 			}
 		} else {
 			// labeled break/continue; look up the target
-			sym := n.Sym
+			sym := n.Sym()
 			lab := s.label(sym)
-			switch n.Op {
+			switch n.Op() {
 			case ir.OCONTINUE:
 				to = lab.continueTarget
 			case ir.OBREAK:
@@ -1406,16 +1406,16 @@ func (s *state) stmt(n *ir.Node) {
 		bEnd := s.f.NewBlock(ssa.BlockPlain)
 
 		// ensure empty for loops have correct position; issue #30167
-		bBody.Pos = n.Pos
+		bBody.Pos = n.Pos()
 
 		// first, jump to condition test (OFOR) or body (OFORUNTIL)
 		b := s.endBlock()
-		if n.Op == ir.OFOR {
+		if n.Op() == ir.OFOR {
 			b.AddEdgeTo(bCond)
 			// generate code to test condition
 			s.startBlock(bCond)
-			if n.Left != nil {
-				s.condBranch(n.Left, bBody, bEnd, 1)
+			if n.Left() != nil {
+				s.condBranch(n.Left(), bBody, bEnd, 1)
 			} else {
 				b := s.endBlock()
 				b.Kind = ssa.BlockPlain
@@ -1440,7 +1440,7 @@ func (s *state) stmt(n *ir.Node) {
 
 		// generate body
 		s.startBlock(bBody)
-		s.stmtList(n.Nbody)
+		s.stmtList(n.Body())
 
 		// tear down continue/break
 		s.continueTo = prevContinue
@@ -1457,15 +1457,15 @@ func (s *state) stmt(n *ir.Node) {
 
 		// generate incr (and, for OFORUNTIL, condition)
 		s.startBlock(bIncr)
-		if n.Right != nil {
-			s.stmt(n.Right)
+		if n.Right() != nil {
+			s.stmt(n.Right())
 		}
-		if n.Op == ir.OFOR {
+		if n.Op() == ir.OFOR {
 			if b := s.endBlock(); b != nil {
 				b.AddEdgeTo(bCond)
 				// It can happen that bIncr ends in a block containing only VARKILL,
 				// and that muddles the debugging experience.
-				if n.Op != ir.OFORUNTIL && b.Pos == src.NoXPos {
+				if n.Op() != ir.OFORUNTIL && b.Pos == src.NoXPos {
 					b.Pos = bCond.Pos
 				}
 			}
@@ -1473,10 +1473,10 @@ func (s *state) stmt(n *ir.Node) {
 			// bCond is unused in OFORUNTIL, so repurpose it.
 			bLateIncr := bCond
 			// test condition
-			s.condBranch(n.Left, bLateIncr, bEnd, 1)
+			s.condBranch(n.Left(), bLateIncr, bEnd, 1)
 			// generate late increment
 			s.startBlock(bLateIncr)
-			s.stmtList(n.List)
+			s.stmtList(n.List())
 			s.endBlock().AddEdgeTo(bBody)
 		}
 
@@ -1496,7 +1496,7 @@ func (s *state) stmt(n *ir.Node) {
 		}
 
 		// generate body code
-		s.stmtList(n.Nbody)
+		s.stmtList(n.Body())
 
 		s.breakTo = prevBreak
 		if lab != nil {
@@ -1514,39 +1514,39 @@ func (s *state) stmt(n *ir.Node) {
 		s.startBlock(bEnd)
 
 	case ir.OVARDEF:
-		if !s.canSSA(n.Left) {
-			s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, n.Left, s.mem(), false)
+		if !s.canSSA(n.Left()) {
+			s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, n.Left(), s.mem(), false)
 		}
 	case ir.OVARKILL:
 		// Insert a varkill op to record that a variable is no longer live.
 		// We only care about liveness info at call sites, so putting the
 		// varkill in the store chain is enough to keep it correctly ordered
 		// with respect to call ops.
-		if !s.canSSA(n.Left) {
-			s.vars[memVar] = s.newValue1Apos(ssa.OpVarKill, types.TypeMem, n.Left, s.mem(), false)
+		if !s.canSSA(n.Left()) {
+			s.vars[memVar] = s.newValue1Apos(ssa.OpVarKill, types.TypeMem, n.Left(), s.mem(), false)
 		}
 
 	case ir.OVARLIVE:
 		// Insert a varlive op to record that a variable is still live.
-		if !n.Left.Name.Addrtaken() {
-			s.Fatalf("VARLIVE variable %v must have Addrtaken set", n.Left)
+		if !n.Left().Name().Addrtaken() {
+			s.Fatalf("VARLIVE variable %v must have Addrtaken set", n.Left())
 		}
-		switch n.Left.Class() {
+		switch n.Left().Class() {
 		case ir.PAUTO, ir.PPARAM, ir.PPARAMOUT:
 		default:
-			s.Fatalf("VARLIVE variable %v must be Auto or Arg", n.Left)
+			s.Fatalf("VARLIVE variable %v must be Auto or Arg", n.Left())
 		}
-		s.vars[memVar] = s.newValue1A(ssa.OpVarLive, types.TypeMem, n.Left, s.mem())
+		s.vars[memVar] = s.newValue1A(ssa.OpVarLive, types.TypeMem, n.Left(), s.mem())
 
 	case ir.OCHECKNIL:
-		p := s.expr(n.Left)
+		p := s.expr(n.Left())
 		s.nilCheck(p)
 
 	case ir.OINLMARK:
-		s.newValue1I(ssa.OpInlMark, types.TypeVoid, n.Xoffset, s.mem())
+		s.newValue1I(ssa.OpInlMark, types.TypeVoid, n.Offset(), s.mem())
 
 	default:
-		s.Fatalf("unhandled stmt %v", n.Op)
+		s.Fatalf("unhandled stmt %v", n.Op())
 	}
 }
 
@@ -1576,14 +1576,14 @@ func (s *state) exit() *ssa.Block {
 
 	// Run exit code. Typically, this code copies heap-allocated PPARAMOUT
 	// variables back to the stack.
-	s.stmtList(s.curfn.Func.Exit)
+	s.stmtList(s.curfn.Func().Exit)
 
 	// Store SSAable PPARAMOUT variables back to stack locations.
 	for _, n := range s.returns {
 		addr := s.decladdrs[n]
-		val := s.variable(n, n.Type)
+		val := s.variable(n, n.Type())
 		s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
-		s.store(n.Type, addr, val)
+		s.store(n.Type(), addr, val)
 		// TODO: if val is ever spilled, we'd like to use the
 		// PPARAMOUT slot for spilling it. That won't happen
 		// currently.
@@ -2003,44 +2003,44 @@ func (s *state) expr(n *ir.Node) *ssa.Value {
 	if hasUniquePos(n) {
 		// ONAMEs and named OLITERALs have the line number
 		// of the decl, not the use. See issue 14742.
-		s.pushLine(n.Pos)
+		s.pushLine(n.Pos())
 		defer s.popLine()
 	}
 
-	s.stmtList(n.Ninit)
-	switch n.Op {
+	s.stmtList(n.Init())
+	switch n.Op() {
 	case ir.OBYTES2STRTMP:
-		slice := s.expr(n.Left)
+		slice := s.expr(n.Left())
 		ptr := s.newValue1(ssa.OpSlicePtr, s.f.Config.Types.BytePtr, slice)
 		len := s.newValue1(ssa.OpSliceLen, types.Types[types.TINT], slice)
-		return s.newValue2(ssa.OpStringMake, n.Type, ptr, len)
+		return s.newValue2(ssa.OpStringMake, n.Type(), ptr, len)
 	case ir.OSTR2BYTESTMP:
-		str := s.expr(n.Left)
+		str := s.expr(n.Left())
 		ptr := s.newValue1(ssa.OpStringPtr, s.f.Config.Types.BytePtr, str)
 		len := s.newValue1(ssa.OpStringLen, types.Types[types.TINT], str)
-		return s.newValue3(ssa.OpSliceMake, n.Type, ptr, len, len)
+		return s.newValue3(ssa.OpSliceMake, n.Type(), ptr, len, len)
 	case ir.OCFUNC:
-		aux := n.Left.Sym.Linksym()
-		return s.entryNewValue1A(ssa.OpAddr, n.Type, aux, s.sb)
+		aux := n.Left().Sym().Linksym()
+		return s.entryNewValue1A(ssa.OpAddr, n.Type(), aux, s.sb)
 	case ir.OMETHEXPR:
-		sym := funcsym(n.Sym).Linksym()
-		return s.entryNewValue1A(ssa.OpAddr, types.NewPtr(n.Type), sym, s.sb)
+		sym := funcsym(n.Sym()).Linksym()
+		return s.entryNewValue1A(ssa.OpAddr, types.NewPtr(n.Type()), sym, s.sb)
 	case ir.ONAME:
 		if n.Class() == ir.PFUNC {
 			// "value" of a function is the address of the function's closure
-			sym := funcsym(n.Sym).Linksym()
-			return s.entryNewValue1A(ssa.OpAddr, types.NewPtr(n.Type), sym, s.sb)
+			sym := funcsym(n.Sym()).Linksym()
+			return s.entryNewValue1A(ssa.OpAddr, types.NewPtr(n.Type()), sym, s.sb)
 		}
 		if s.canSSA(n) {
-			return s.variable(n, n.Type)
+			return s.variable(n, n.Type())
 		}
 		addr := s.addr(n)
-		return s.load(n.Type, addr)
+		return s.load(n.Type(), addr)
 	case ir.OCLOSUREVAR:
 		addr := s.addr(n)
-		return s.load(n.Type, addr)
+		return s.load(n.Type(), addr)
 	case ir.ONIL:
-		t := n.Type
+		t := n.Type()
 		switch {
 		case t.IsSlice():
 			return s.constSlice(t)
@@ -2052,55 +2052,55 @@ func (s *state) expr(n *ir.Node) *ssa.Value {
 	case ir.OLITERAL:
 		switch u := n.Val(); u.Kind() {
 		case constant.Int:
-			i := ir.Int64Val(n.Type, u)
-			switch n.Type.Size() {
+			i := ir.Int64Val(n.Type(), u)
+			switch n.Type().Size() {
 			case 1:
-				return s.constInt8(n.Type, int8(i))
+				return s.constInt8(n.Type(), int8(i))
 			case 2:
-				return s.constInt16(n.Type, int16(i))
+				return s.constInt16(n.Type(), int16(i))
 			case 4:
-				return s.constInt32(n.Type, int32(i))
+				return s.constInt32(n.Type(), int32(i))
 			case 8:
-				return s.constInt64(n.Type, i)
+				return s.constInt64(n.Type(), i)
 			default:
-				s.Fatalf("bad integer size %d", n.Type.Size())
+				s.Fatalf("bad integer size %d", n.Type().Size())
 				return nil
 			}
 		case constant.String:
 			i := constant.StringVal(u)
 			if i == "" {
-				return s.constEmptyString(n.Type)
+				return s.constEmptyString(n.Type())
 			}
-			return s.entryNewValue0A(ssa.OpConstString, n.Type, i)
+			return s.entryNewValue0A(ssa.OpConstString, n.Type(), i)
 		case constant.Bool:
 			return s.constBool(constant.BoolVal(u))
 		case constant.Float:
 			f, _ := constant.Float64Val(u)
-			switch n.Type.Size() {
+			switch n.Type().Size() {
 			case 4:
-				return s.constFloat32(n.Type, f)
+				return s.constFloat32(n.Type(), f)
 			case 8:
-				return s.constFloat64(n.Type, f)
+				return s.constFloat64(n.Type(), f)
 			default:
-				s.Fatalf("bad float size %d", n.Type.Size())
+				s.Fatalf("bad float size %d", n.Type().Size())
 				return nil
 			}
 		case constant.Complex:
 			re, _ := constant.Float64Val(constant.Real(u))
 			im, _ := constant.Float64Val(constant.Imag(u))
-			switch n.Type.Size() {
+			switch n.Type().Size() {
 			case 8:
 				pt := types.Types[types.TFLOAT32]
-				return s.newValue2(ssa.OpComplexMake, n.Type,
+				return s.newValue2(ssa.OpComplexMake, n.Type(),
 					s.constFloat32(pt, re),
 					s.constFloat32(pt, im))
 			case 16:
 				pt := types.Types[types.TFLOAT64]
-				return s.newValue2(ssa.OpComplexMake, n.Type,
+				return s.newValue2(ssa.OpComplexMake, n.Type(),
 					s.constFloat64(pt, re),
 					s.constFloat64(pt, im))
 			default:
-				s.Fatalf("bad complex size %d", n.Type.Size())
+				s.Fatalf("bad complex size %d", n.Type().Size())
 				return nil
 			}
 		default:
@@ -2108,12 +2108,12 @@ func (s *state) expr(n *ir.Node) *ssa.Value {
 			return nil
 		}
 	case ir.OCONVNOP:
-		to := n.Type
-		from := n.Left.Type
+		to := n.Type()
+		from := n.Left().Type()
 
 		// Assume everything will work out, so set up our return value.
 		// Anything interesting that happens from here is a fatal.
-		x := s.expr(n.Left)
+		x := s.expr(n.Left())
 
 		// Special case for not confusing GC and liveness.
 		// We don't want pointers accidentally classified
@@ -2173,12 +2173,12 @@ func (s *state) expr(n *ir.Node) *ssa.Value {
 		return v
 
 	case ir.OCONV:
-		x := s.expr(n.Left)
-		ft := n.Left.Type // from type
-		tt := n.Type      // to type
+		x := s.expr(n.Left())
+		ft := n.Left().Type() // from type
+		tt := n.Type()        // to type
 		if ft.IsBoolean() && tt.IsKind(types.TUINT8) {
 			// Bool -> uint8 is generated internally when indexing into runtime.staticbyte.
-			return s.newValue1(ssa.OpCopy, n.Type, x)
+			return s.newValue1(ssa.OpCopy, n.Type(), x)
 		}
 		if ft.IsInteger() && tt.IsInteger() {
 			var op ssa.Op
@@ -2239,7 +2239,7 @@ func (s *state) expr(n *ir.Node) *ssa.Value {
 					s.Fatalf("weird integer sign extension %v -> %v", ft, tt)
 				}
 			}
-			return s.newValue1(op, n.Type, x)
+			return s.newValue1(op, n.Type(), x)
 		}
 
 		if ft.IsFloat() || tt.IsFloat() {
@@ -2286,12 +2286,12 @@ func (s *state) expr(n *ir.Node) *ssa.Value {
 					if op2 == ssa.OpCopy {
 						return x
 					}
-					return s.newValueOrSfCall1(op2, n.Type, x)
+					return s.newValueOrSfCall1(op2, n.Type(), x)
 				}
 				if op2 == ssa.OpCopy {
-					return s.newValueOrSfCall1(op1, n.Type, x)
+					return s.newValueOrSfCall1(op1, n.Type(), x)
 				}
-				return s.newValueOrSfCall1(op2, n.Type, s.newValueOrSfCall1(op1, types.Types[it], x))
+				return s.newValueOrSfCall1(op2, n.Type(), s.newValueOrSfCall1(op1, types.Types[it], x))
 			}
 			// Tricky 64-bit unsigned cases.
 			if ft.IsInteger() {
@@ -2340,7 +2340,7 @@ func (s *state) expr(n *ir.Node) *ssa.Value {
 				s.newValueOrSfCall1(op, ttp, s.newValue1(ssa.OpComplexImag, ftp, x)))
 		}
 
-		s.Fatalf("unhandled OCONV %s -> %s", n.Left.Type.Etype, n.Type.Etype)
+		s.Fatalf("unhandled OCONV %s -> %s", n.Left().Type().Etype, n.Type().Etype)
 		return nil
 
 	case ir.ODOTTYPE:
@@ -2349,46 +2349,46 @@ func (s *state) expr(n *ir.Node) *ssa.Value {
 
 	// binary ops
 	case ir.OLT, ir.OEQ, ir.ONE, ir.OLE, ir.OGE, ir.OGT:
-		a := s.expr(n.Left)
-		b := s.expr(n.Right)
-		if n.Left.Type.IsComplex() {
-			pt := floatForComplex(n.Left.Type)
+		a := s.expr(n.Left())
+		b := s.expr(n.Right())
+		if n.Left().Type().IsComplex() {
+			pt := floatForComplex(n.Left().Type())
 			op := s.ssaOp(ir.OEQ, pt)
 			r := s.newValueOrSfCall2(op, types.Types[types.TBOOL], s.newValue1(ssa.OpComplexReal, pt, a), s.newValue1(ssa.OpComplexReal, pt, b))
 			i := s.newValueOrSfCall2(op, types.Types[types.TBOOL], s.newValue1(ssa.OpComplexImag, pt, a), s.newValue1(ssa.OpComplexImag, pt, b))
 			c := s.newValue2(ssa.OpAndB, types.Types[types.TBOOL], r, i)
-			switch n.Op {
+			switch n.Op() {
 			case ir.OEQ:
 				return c
 			case ir.ONE:
 				return s.newValue1(ssa.OpNot, types.Types[types.TBOOL], c)
 			default:
-				s.Fatalf("ordered complex compare %v", n.Op)
+				s.Fatalf("ordered complex compare %v", n.Op())
 			}
 		}
 
 		// Convert OGE and OGT into OLE and OLT.
-		op := n.Op
+		op := n.Op()
 		switch op {
 		case ir.OGE:
 			op, a, b = ir.OLE, b, a
 		case ir.OGT:
 			op, a, b = ir.OLT, b, a
 		}
-		if n.Left.Type.IsFloat() {
+		if n.Left().Type().IsFloat() {
 			// float comparison
-			return s.newValueOrSfCall2(s.ssaOp(op, n.Left.Type), types.Types[types.TBOOL], a, b)
+			return s.newValueOrSfCall2(s.ssaOp(op, n.Left().Type()), types.Types[types.TBOOL], a, b)
 		}
 		// integer comparison
-		return s.newValue2(s.ssaOp(op, n.Left.Type), types.Types[types.TBOOL], a, b)
+		return s.newValue2(s.ssaOp(op, n.Left().Type()), types.Types[types.TBOOL], a, b)
 	case ir.OMUL:
-		a := s.expr(n.Left)
-		b := s.expr(n.Right)
-		if n.Type.IsComplex() {
+		a := s.expr(n.Left())
+		b := s.expr(n.Right())
+		if n.Type().IsComplex() {
 			mulop := ssa.OpMul64F
 			addop := ssa.OpAdd64F
 			subop := ssa.OpSub64F
-			pt := floatForComplex(n.Type)     // Could be Float32 or Float64
+			pt := floatForComplex(n.Type())   // Could be Float32 or Float64
 			wt := types.Types[types.TFLOAT64] // Compute in Float64 to minimize cancellation error
 
 			areal := s.newValue1(ssa.OpComplexReal, pt, a)
@@ -2411,19 +2411,19 @@ func (s *state) expr(n *ir.Node) *ssa.Value {
 				ximag = s.newValueOrSfCall1(ssa.OpCvt64Fto32F, pt, ximag)
 			}
 
-			return s.newValue2(ssa.OpComplexMake, n.Type, xreal, ximag)
+			return s.newValue2(ssa.OpComplexMake, n.Type(), xreal, ximag)
 		}
 
-		if n.Type.IsFloat() {
-			return s.newValueOrSfCall2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
+		if n.Type().IsFloat() {
+			return s.newValueOrSfCall2(s.ssaOp(n.Op(), n.Type()), a.Type, a, b)
 		}
 
-		return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
+		return s.newValue2(s.ssaOp(n.Op(), n.Type()), a.Type, a, b)
 
 	case ir.ODIV:
-		a := s.expr(n.Left)
-		b := s.expr(n.Right)
-		if n.Type.IsComplex() {
+		a := s.expr(n.Left())
+		b := s.expr(n.Right())
+		if n.Type().IsComplex() {
 			// TODO this is not executed because the front-end substitutes a runtime call.
 			// That probably ought to change; with modest optimization the widen/narrow
 			// conversions could all be elided in larger expression trees.
@@ -2431,7 +2431,7 @@ func (s *state) expr(n *ir.Node) *ssa.Value {
 			addop := ssa.OpAdd64F
 			subop := ssa.OpSub64F
 			divop := ssa.OpDiv64F
-			pt := floatForComplex(n.Type)     // Could be Float32 or Float64
+			pt := floatForComplex(n.Type())   // Could be Float32 or Float64
 			wt := types.Types[types.TFLOAT64] // Compute in Float64 to minimize cancellation error
 
 			areal := s.newValue1(ssa.OpComplexReal, pt, a)
@@ -2461,49 +2461,49 @@ func (s *state) expr(n *ir.Node) *ssa.Value {
 				xreal = s.newValueOrSfCall1(ssa.OpCvt64Fto32F, pt, xreal)
 				ximag = s.newValueOrSfCall1(ssa.OpCvt64Fto32F, pt, ximag)
 			}
-			return s.newValue2(ssa.OpComplexMake, n.Type, xreal, ximag)
+			return s.newValue2(ssa.OpComplexMake, n.Type(), xreal, ximag)
 		}
-		if n.Type.IsFloat() {
-			return s.newValueOrSfCall2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
+		if n.Type().IsFloat() {
+			return s.newValueOrSfCall2(s.ssaOp(n.Op(), n.Type()), a.Type, a, b)
 		}
 		return s.intDivide(n, a, b)
 	case ir.OMOD:
-		a := s.expr(n.Left)
-		b := s.expr(n.Right)
+		a := s.expr(n.Left())
+		b := s.expr(n.Right())
 		return s.intDivide(n, a, b)
 	case ir.OADD, ir.OSUB:
-		a := s.expr(n.Left)
-		b := s.expr(n.Right)
-		if n.Type.IsComplex() {
-			pt := floatForComplex(n.Type)
-			op := s.ssaOp(n.Op, pt)
-			return s.newValue2(ssa.OpComplexMake, n.Type,
+		a := s.expr(n.Left())
+		b := s.expr(n.Right())
+		if n.Type().IsComplex() {
+			pt := floatForComplex(n.Type())
+			op := s.ssaOp(n.Op(), pt)
+			return s.newValue2(ssa.OpComplexMake, n.Type(),
 				s.newValueOrSfCall2(op, pt, s.newValue1(ssa.OpComplexReal, pt, a), s.newValue1(ssa.OpComplexReal, pt, b)),
 				s.newValueOrSfCall2(op, pt, s.newValue1(ssa.OpComplexImag, pt, a), s.newValue1(ssa.OpComplexImag, pt, b)))
 		}
-		if n.Type.IsFloat() {
-			return s.newValueOrSfCall2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
+		if n.Type().IsFloat() {
+			return s.newValueOrSfCall2(s.ssaOp(n.Op(), n.Type()), a.Type, a, b)
 		}
-		return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
+		return s.newValue2(s.ssaOp(n.Op(), n.Type()), a.Type, a, b)
 	case ir.OAND, ir.OOR, ir.OXOR:
-		a := s.expr(n.Left)
-		b := s.expr(n.Right)
-		return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
+		a := s.expr(n.Left())
+		b := s.expr(n.Right())
+		return s.newValue2(s.ssaOp(n.Op(), n.Type()), a.Type, a, b)
 	case ir.OANDNOT:
-		a := s.expr(n.Left)
-		b := s.expr(n.Right)
+		a := s.expr(n.Left())
+		b := s.expr(n.Right())
 		b = s.newValue1(s.ssaOp(ir.OBITNOT, b.Type), b.Type, b)
-		return s.newValue2(s.ssaOp(ir.OAND, n.Type), a.Type, a, b)
+		return s.newValue2(s.ssaOp(ir.OAND, n.Type()), a.Type, a, b)
 	case ir.OLSH, ir.ORSH:
-		a := s.expr(n.Left)
-		b := s.expr(n.Right)
+		a := s.expr(n.Left())
+		b := s.expr(n.Right())
 		bt := b.Type
 		if bt.IsSigned() {
 			cmp := s.newValue2(s.ssaOp(ir.OLE, bt), types.Types[types.TBOOL], s.zeroVal(bt), b)
 			s.check(cmp, panicshift)
 			bt = bt.ToUnsigned()
 		}
-		return s.newValue2(s.ssaShiftOp(n.Op, n.Type, bt), a.Type, a, b)
+		return s.newValue2(s.ssaShiftOp(n.Op(), n.Type(), bt), a.Type, a, b)
 	case ir.OANDAND, ir.OOROR:
 		// To implement OANDAND (and OOROR), we introduce a
 		// new temporary variable to hold the result. The
@@ -2518,7 +2518,7 @@ func (s *state) expr(n *ir.Node) *ssa.Value {
 		//     }
 		// Using var in the subsequent block introduces the
 		// necessary phi variable.
-		el := s.expr(n.Left)
+		el := s.expr(n.Left())
 		s.vars[n] = el
 
 		b := s.endBlock()
@@ -2531,16 +2531,16 @@ func (s *state) expr(n *ir.Node) *ssa.Value {
 
 		bRight := s.f.NewBlock(ssa.BlockPlain)
 		bResult := s.f.NewBlock(ssa.BlockPlain)
-		if n.Op == ir.OANDAND {
+		if n.Op() == ir.OANDAND {
 			b.AddEdgeTo(bRight)
 			b.AddEdgeTo(bResult)
-		} else if n.Op == ir.OOROR {
+		} else if n.Op() == ir.OOROR {
 			b.AddEdgeTo(bResult)
 			b.AddEdgeTo(bRight)
 		}
 
 		s.startBlock(bRight)
-		er := s.expr(n.Right)
+		er := s.expr(n.Right())
 		s.vars[n] = er
 
 		b = s.endBlock()
@@ -2549,65 +2549,65 @@ func (s *state) expr(n *ir.Node) *ssa.Value {
 		s.startBlock(bResult)
 		return s.variable(n, types.Types[types.TBOOL])
 	case ir.OCOMPLEX:
-		r := s.expr(n.Left)
-		i := s.expr(n.Right)
-		return s.newValue2(ssa.OpComplexMake, n.Type, r, i)
+		r := s.expr(n.Left())
+		i := s.expr(n.Right())
+		return s.newValue2(ssa.OpComplexMake, n.Type(), r, i)
 
 	// unary ops
 	case ir.ONEG:
-		a := s.expr(n.Left)
-		if n.Type.IsComplex() {
-			tp := floatForComplex(n.Type)
-			negop := s.ssaOp(n.Op, tp)
-			return s.newValue2(ssa.OpComplexMake, n.Type,
+		a := s.expr(n.Left())
+		if n.Type().IsComplex() {
+			tp := floatForComplex(n.Type())
+			negop := s.ssaOp(n.Op(), tp)
+			return s.newValue2(ssa.OpComplexMake, n.Type(),
 				s.newValue1(negop, tp, s.newValue1(ssa.OpComplexReal, tp, a)),
 				s.newValue1(negop, tp, s.newValue1(ssa.OpComplexImag, tp, a)))
 		}
-		return s.newValue1(s.ssaOp(n.Op, n.Type), a.Type, a)
+		return s.newValue1(s.ssaOp(n.Op(), n.Type()), a.Type, a)
 	case ir.ONOT, ir.OBITNOT:
-		a := s.expr(n.Left)
-		return s.newValue1(s.ssaOp(n.Op, n.Type), a.Type, a)
+		a := s.expr(n.Left())
+		return s.newValue1(s.ssaOp(n.Op(), n.Type()), a.Type, a)
 	case ir.OIMAG, ir.OREAL:
-		a := s.expr(n.Left)
-		return s.newValue1(s.ssaOp(n.Op, n.Left.Type), n.Type, a)
+		a := s.expr(n.Left())
+		return s.newValue1(s.ssaOp(n.Op(), n.Left().Type()), n.Type(), a)
 	case ir.OPLUS:
-		return s.expr(n.Left)
+		return s.expr(n.Left())
 
 	case ir.OADDR:
-		return s.addr(n.Left)
+		return s.addr(n.Left())
 
 	case ir.ORESULT:
 		if s.prevCall == nil || s.prevCall.Op != ssa.OpStaticLECall && s.prevCall.Op != ssa.OpInterLECall && s.prevCall.Op != ssa.OpClosureLECall {
 			// Do the old thing
-			addr := s.constOffPtrSP(types.NewPtr(n.Type), n.Xoffset)
-			return s.rawLoad(n.Type, addr)
+			addr := s.constOffPtrSP(types.NewPtr(n.Type()), n.Offset())
+			return s.rawLoad(n.Type(), addr)
 		}
-		which := s.prevCall.Aux.(*ssa.AuxCall).ResultForOffset(n.Xoffset)
+		which := s.prevCall.Aux.(*ssa.AuxCall).ResultForOffset(n.Offset())
 		if which == -1 {
 			// Do the old thing // TODO: Panic instead.
-			addr := s.constOffPtrSP(types.NewPtr(n.Type), n.Xoffset)
-			return s.rawLoad(n.Type, addr)
+			addr := s.constOffPtrSP(types.NewPtr(n.Type()), n.Offset())
+			return s.rawLoad(n.Type(), addr)
 		}
-		if canSSAType(n.Type) {
-			return s.newValue1I(ssa.OpSelectN, n.Type, which, s.prevCall)
+		if canSSAType(n.Type()) {
+			return s.newValue1I(ssa.OpSelectN, n.Type(), which, s.prevCall)
 		} else {
-			addr := s.newValue1I(ssa.OpSelectNAddr, types.NewPtr(n.Type), which, s.prevCall)
-			return s.rawLoad(n.Type, addr)
+			addr := s.newValue1I(ssa.OpSelectNAddr, types.NewPtr(n.Type()), which, s.prevCall)
+			return s.rawLoad(n.Type(), addr)
 		}
 
 	case ir.ODEREF:
-		p := s.exprPtr(n.Left, n.Bounded(), n.Pos)
-		return s.load(n.Type, p)
+		p := s.exprPtr(n.Left(), n.Bounded(), n.Pos())
+		return s.load(n.Type(), p)
 
 	case ir.ODOT:
-		if n.Left.Op == ir.OSTRUCTLIT {
+		if n.Left().Op() == ir.OSTRUCTLIT {
 			// All literals with nonzero fields have already been
 			// rewritten during walk. Any that remain are just T{}
 			// or equivalents. Use the zero value.
-			if !isZero(n.Left) {
-				s.Fatalf("literal with nonzero value in SSA: %v", n.Left)
+			if !isZero(n.Left()) {
+				s.Fatalf("literal with nonzero value in SSA: %v", n.Left())
 			}
-			return s.zeroVal(n.Type)
+			return s.zeroVal(n.Type())
 		}
 		// If n is addressable and can't be represented in
 		// SSA, then load just the selected field. This
@@ -2615,110 +2615,110 @@ func (s *state) expr(n *ir.Node) *ssa.Value {
 		// instrumentation.
 		if islvalue(n) && !s.canSSA(n) {
 			p := s.addr(n)
-			return s.load(n.Type, p)
+			return s.load(n.Type(), p)
 		}
-		v := s.expr(n.Left)
-		return s.newValue1I(ssa.OpStructSelect, n.Type, int64(fieldIdx(n)), v)
+		v := s.expr(n.Left())
+		return s.newValue1I(ssa.OpStructSelect, n.Type(), int64(fieldIdx(n)), v)
 
 	case ir.ODOTPTR:
-		p := s.exprPtr(n.Left, n.Bounded(), n.Pos)
-		p = s.newValue1I(ssa.OpOffPtr, types.NewPtr(n.Type), n.Xoffset, p)
-		return s.load(n.Type, p)
+		p := s.exprPtr(n.Left(), n.Bounded(), n.Pos())
+		p = s.newValue1I(ssa.OpOffPtr, types.NewPtr(n.Type()), n.Offset(), p)
+		return s.load(n.Type(), p)
 
 	case ir.OINDEX:
 		switch {
-		case n.Left.Type.IsString():
-			if n.Bounded() && ir.IsConst(n.Left, constant.String) && ir.IsConst(n.Right, constant.Int) {
+		case n.Left().Type().IsString():
+			if n.Bounded() && ir.IsConst(n.Left(), constant.String) && ir.IsConst(n.Right(), constant.Int) {
 				// Replace "abc"[1] with 'b'.
 				// Delayed until now because "abc"[1] is not an ideal constant.
 				// See test/fixedbugs/issue11370.go.
-				return s.newValue0I(ssa.OpConst8, types.Types[types.TUINT8], int64(int8(n.Left.StringVal()[n.Right.Int64Val()])))
+				return s.newValue0I(ssa.OpConst8, types.Types[types.TUINT8], int64(int8(n.Left().StringVal()[n.Right().Int64Val()])))
 			}
-			a := s.expr(n.Left)
-			i := s.expr(n.Right)
+			a := s.expr(n.Left())
+			i := s.expr(n.Right())
 			len := s.newValue1(ssa.OpStringLen, types.Types[types.TINT], a)
 			i = s.boundsCheck(i, len, ssa.BoundsIndex, n.Bounded())
 			ptrtyp := s.f.Config.Types.BytePtr
 			ptr := s.newValue1(ssa.OpStringPtr, ptrtyp, a)
-			if ir.IsConst(n.Right, constant.Int) {
-				ptr = s.newValue1I(ssa.OpOffPtr, ptrtyp, n.Right.Int64Val(), ptr)
+			if ir.IsConst(n.Right(), constant.Int) {
+				ptr = s.newValue1I(ssa.OpOffPtr, ptrtyp, n.Right().Int64Val(), ptr)
 			} else {
 				ptr = s.newValue2(ssa.OpAddPtr, ptrtyp, ptr, i)
 			}
 			return s.load(types.Types[types.TUINT8], ptr)
-		case n.Left.Type.IsSlice():
+		case n.Left().Type().IsSlice():
 			p := s.addr(n)
-			return s.load(n.Left.Type.Elem(), p)
-		case n.Left.Type.IsArray():
-			if canSSAType(n.Left.Type) {
+			return s.load(n.Left().Type().Elem(), p)
+		case n.Left().Type().IsArray():
+			if canSSAType(n.Left().Type()) {
 				// SSA can handle arrays of length at most 1.
-				bound := n.Left.Type.NumElem()
-				a := s.expr(n.Left)
-				i := s.expr(n.Right)
+				bound := n.Left().Type().NumElem()
+				a := s.expr(n.Left())
+				i := s.expr(n.Right())
 				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)
 					// The return value won't be live, return junk.
-					return s.newValue0(ssa.OpUnknown, n.Type)
+					return s.newValue0(ssa.OpUnknown, n.Type())
 				}
 				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)
+				return s.newValue1I(ssa.OpArraySelect, n.Type(), 0, a)
 			}
 			p := s.addr(n)
-			return s.load(n.Left.Type.Elem(), p)
+			return s.load(n.Left().Type().Elem(), p)
 		default:
-			s.Fatalf("bad type for index %v", n.Left.Type)
+			s.Fatalf("bad type for index %v", n.Left().Type())
 			return nil
 		}
 
 	case ir.OLEN, ir.OCAP:
 		switch {
-		case n.Left.Type.IsSlice():
+		case n.Left().Type().IsSlice():
 			op := ssa.OpSliceLen
-			if n.Op == ir.OCAP {
+			if n.Op() == ir.OCAP {
 				op = ssa.OpSliceCap
 			}
-			return s.newValue1(op, types.Types[types.TINT], s.expr(n.Left))
-		case n.Left.Type.IsString(): // string; not reachable for OCAP
-			return s.newValue1(ssa.OpStringLen, types.Types[types.TINT], s.expr(n.Left))
-		case n.Left.Type.IsMap(), n.Left.Type.IsChan():
-			return s.referenceTypeBuiltin(n, s.expr(n.Left))
+			return s.newValue1(op, types.Types[types.TINT], s.expr(n.Left()))
+		case n.Left().Type().IsString(): // string; not reachable for OCAP
+			return s.newValue1(ssa.OpStringLen, types.Types[types.TINT], s.expr(n.Left()))
+		case n.Left().Type().IsMap(), n.Left().Type().IsChan():
+			return s.referenceTypeBuiltin(n, s.expr(n.Left()))
 		default: // array
-			return s.constInt(types.Types[types.TINT], n.Left.Type.NumElem())
+			return s.constInt(types.Types[types.TINT], n.Left().Type().NumElem())
 		}
 
 	case ir.OSPTR:
-		a := s.expr(n.Left)
-		if n.Left.Type.IsSlice() {
-			return s.newValue1(ssa.OpSlicePtr, n.Type, a)
+		a := s.expr(n.Left())
+		if n.Left().Type().IsSlice() {
+			return s.newValue1(ssa.OpSlicePtr, n.Type(), a)
 		} else {
-			return s.newValue1(ssa.OpStringPtr, n.Type, a)
+			return s.newValue1(ssa.OpStringPtr, n.Type(), a)
 		}
 
 	case ir.OITAB:
-		a := s.expr(n.Left)
-		return s.newValue1(ssa.OpITab, n.Type, a)
+		a := s.expr(n.Left())
+		return s.newValue1(ssa.OpITab, n.Type(), a)
 
 	case ir.OIDATA:
-		a := s.expr(n.Left)
-		return s.newValue1(ssa.OpIData, n.Type, a)
+		a := s.expr(n.Left())
+		return s.newValue1(ssa.OpIData, n.Type(), a)
 
 	case ir.OEFACE:
-		tab := s.expr(n.Left)
-		data := s.expr(n.Right)
-		return s.newValue2(ssa.OpIMake, n.Type, tab, data)
+		tab := s.expr(n.Left())
+		data := s.expr(n.Right())
+		return s.newValue2(ssa.OpIMake, n.Type(), tab, data)
 
 	case ir.OSLICEHEADER:
-		p := s.expr(n.Left)
-		l := s.expr(n.List.First())
-		c := s.expr(n.List.Second())
-		return s.newValue3(ssa.OpSliceMake, n.Type, p, l, c)
+		p := s.expr(n.Left())
+		l := s.expr(n.List().First())
+		c := s.expr(n.List().Second())
+		return s.newValue3(ssa.OpSliceMake, n.Type(), p, l, c)
 
 	case ir.OSLICE, ir.OSLICEARR, ir.OSLICE3, ir.OSLICE3ARR:
-		v := s.expr(n.Left)
+		v := s.expr(n.Left())
 		var i, j, k *ssa.Value
 		low, high, max := n.SliceBounds()
 		if low != nil {
@@ -2731,10 +2731,10 @@ func (s *state) expr(n *ir.Node) *ssa.Value {
 			k = s.expr(max)
 		}
 		p, l, c := s.slice(v, i, j, k, n.Bounded())
-		return s.newValue3(ssa.OpSliceMake, n.Type, p, l, c)
+		return s.newValue3(ssa.OpSliceMake, n.Type(), p, l, c)
 
 	case ir.OSLICESTR:
-		v := s.expr(n.Left)
+		v := s.expr(n.Left())
 		var i, j *ssa.Value
 		low, high, _ := n.SliceBounds()
 		if low != nil {
@@ -2744,7 +2744,7 @@ func (s *state) expr(n *ir.Node) *ssa.Value {
 			j = s.expr(high)
 		}
 		p, l, _ := s.slice(v, i, j, nil, n.Bounded())
-		return s.newValue2(ssa.OpStringMake, n.Type, p, l)
+		return s.newValue2(ssa.OpStringMake, n.Type(), p, l)
 
 	case ir.OCALLFUNC:
 		if isIntrinsicCall(n) {
@@ -2756,7 +2756,7 @@ func (s *state) expr(n *ir.Node) *ssa.Value {
 		return s.callResult(n, callNormal)
 
 	case ir.OGETG:
-		return s.newValue1(ssa.OpGetG, n.Type, s.mem())
+		return s.newValue1(ssa.OpGetG, n.Type(), s.mem())
 
 	case ir.OAPPEND:
 		return s.append(n, false)
@@ -2768,18 +2768,18 @@ func (s *state) expr(n *ir.Node) *ssa.Value {
 		if !isZero(n) {
 			s.Fatalf("literal with nonzero value in SSA: %v", n)
 		}
-		return s.zeroVal(n.Type)
+		return s.zeroVal(n.Type())
 
 	case ir.ONEWOBJ:
-		if n.Type.Elem().Size() == 0 {
-			return s.newValue1A(ssa.OpAddr, n.Type, zerobaseSym, s.sb)
+		if n.Type().Elem().Size() == 0 {
+			return s.newValue1A(ssa.OpAddr, n.Type(), zerobaseSym, s.sb)
 		}
-		typ := s.expr(n.Left)
-		vv := s.rtcall(newobject, true, []*types.Type{n.Type}, typ)
+		typ := s.expr(n.Left())
+		vv := s.rtcall(newobject, true, []*types.Type{n.Type()}, typ)
 		return vv[0]
 
 	default:
-		s.Fatalf("unhandled expr %v", n.Op)
+		s.Fatalf("unhandled expr %v", n.Op())
 		return nil
 	}
 }
@@ -2824,16 +2824,16 @@ func (s *state) append(n *ir.Node, inplace bool) *ssa.Value {
 	// *(ptr+len+1) = e2
 	// *(ptr+len+2) = e3
 
-	et := n.Type.Elem()
+	et := n.Type().Elem()
 	pt := types.NewPtr(et)
 
 	// Evaluate slice
-	sn := n.List.First() // the slice node is the first in the list
+	sn := n.List().First() // the slice node is the first in the list
 
 	var slice, addr *ssa.Value
 	if inplace {
 		addr = s.addr(sn)
-		slice = s.load(n.Type, addr)
+		slice = s.load(n.Type(), addr)
 	} else {
 		slice = s.expr(sn)
 	}
@@ -2843,7 +2843,7 @@ func (s *state) append(n *ir.Node, inplace bool) *ssa.Value {
 	assign := s.f.NewBlock(ssa.BlockPlain)
 
 	// Decide if we need to grow
-	nargs := int64(n.List.Len() - 1)
+	nargs := int64(n.List().Len() - 1)
 	p := s.newValue1(ssa.OpSlicePtr, pt, slice)
 	l := s.newValue1(ssa.OpSliceLen, types.Types[types.TINT], slice)
 	c := s.newValue1(ssa.OpSliceCap, types.Types[types.TINT], slice)
@@ -2868,11 +2868,11 @@ func (s *state) append(n *ir.Node, inplace bool) *ssa.Value {
 
 	// Call growslice
 	s.startBlock(grow)
-	taddr := s.expr(n.Left)
+	taddr := s.expr(n.Left())
 	r := s.rtcall(growslice, true, []*types.Type{pt, types.Types[types.TINT], types.Types[types.TINT]}, taddr, p, l, c, nl)
 
 	if inplace {
-		if sn.Op == ir.ONAME && sn.Class() != ir.PEXTERN {
+		if sn.Op() == ir.ONAME && sn.Class() != ir.PEXTERN {
 			// Tell liveness we're about to build a new slice
 			s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, sn, s.mem())
 		}
@@ -2909,8 +2909,8 @@ func (s *state) append(n *ir.Node, inplace bool) *ssa.Value {
 		store bool
 	}
 	args := make([]argRec, 0, nargs)
-	for _, n := range n.List.Slice()[1:] {
-		if canSSAType(n.Type) {
+	for _, n := range n.List().Slice()[1:] {
+		if canSSAType(n.Type()) {
 			args = append(args, argRec{v: s.expr(n), store: true})
 		} else {
 			v := s.addr(n)
@@ -2941,7 +2941,7 @@ func (s *state) append(n *ir.Node, inplace bool) *ssa.Value {
 	delete(s.vars, newlenVar)
 	delete(s.vars, capVar)
 	// make result
-	return s.newValue3(ssa.OpSliceMake, n.Type, p, nl, c)
+	return s.newValue3(ssa.OpSliceMake, n.Type(), p, nl, c)
 }
 
 // condBranch evaluates the boolean expression cond and branches to yes
@@ -2949,13 +2949,13 @@ func (s *state) append(n *ir.Node, inplace bool) *ssa.Value {
 // This function is intended to handle && and || better than just calling
 // s.expr(cond) and branching on the result.
 func (s *state) condBranch(cond *ir.Node, yes, no *ssa.Block, likely int8) {
-	switch cond.Op {
+	switch cond.Op() {
 	case ir.OANDAND:
 		mid := s.f.NewBlock(ssa.BlockPlain)
-		s.stmtList(cond.Ninit)
-		s.condBranch(cond.Left, mid, no, max8(likely, 0))
+		s.stmtList(cond.Init())
+		s.condBranch(cond.Left(), mid, no, max8(likely, 0))
 		s.startBlock(mid)
-		s.condBranch(cond.Right, yes, no, likely)
+		s.condBranch(cond.Right(), yes, no, likely)
 		return
 		// Note: if likely==1, then both recursive calls pass 1.
 		// If likely==-1, then we don't have enough information to decide
@@ -2965,17 +2965,17 @@ func (s *state) condBranch(cond *ir.Node, yes, no *ssa.Block, likely int8) {
 		// OANDAND and OOROR nodes (if it ever has such info).
 	case ir.OOROR:
 		mid := s.f.NewBlock(ssa.BlockPlain)
-		s.stmtList(cond.Ninit)
-		s.condBranch(cond.Left, yes, mid, min8(likely, 0))
+		s.stmtList(cond.Init())
+		s.condBranch(cond.Left(), yes, mid, min8(likely, 0))
 		s.startBlock(mid)
-		s.condBranch(cond.Right, yes, no, likely)
+		s.condBranch(cond.Right(), yes, no, likely)
 		return
 		// Note: if likely==-1, then both recursive calls pass -1.
 		// If likely==1, then we don't have enough info to decide
 		// the likelihood of the first branch.
 	case ir.ONOT:
-		s.stmtList(cond.Ninit)
-		s.condBranch(cond.Left, no, yes, -likely)
+		s.stmtList(cond.Init())
+		s.condBranch(cond.Left(), no, yes, -likely)
 		return
 	}
 	c := s.expr(cond)
@@ -3001,16 +3001,16 @@ const (
 // If deref is true and right == nil, just do left = 0.
 // skip indicates assignments (at the top level) that can be avoided.
 func (s *state) assign(left *ir.Node, right *ssa.Value, deref bool, skip skipMask) {
-	if left.Op == ir.ONAME && ir.IsBlank(left) {
+	if left.Op() == ir.ONAME && ir.IsBlank(left) {
 		return
 	}
-	t := left.Type
+	t := left.Type()
 	dowidth(t)
 	if s.canSSA(left) {
 		if deref {
 			s.Fatalf("can SSA LHS %v but not RHS %s", left, right)
 		}
-		if left.Op == ir.ODOT {
+		if left.Op() == ir.ODOT {
 			// We're assigning to a field of an ssa-able value.
 			// We need to build a new structure with the new value for the
 			// field we're assigning and the old values for the other fields.
@@ -3021,12 +3021,12 @@ func (s *state) assign(left *ir.Node, right *ssa.Value, deref bool, skip skipMas
 			// For the x.b = 5 assignment we want to generate x = T{x.a, 5, x.c}
 
 			// Grab information about the structure type.
-			t := left.Left.Type
+			t := left.Left().Type()
 			nf := t.NumFields()
 			idx := fieldIdx(left)
 
 			// Grab old value of structure.
-			old := s.expr(left.Left)
+			old := s.expr(left.Left())
 
 			// Make new structure.
 			new := s.newValue0(ssa.StructMakeOp(t.NumFields()), t)
@@ -3041,19 +3041,19 @@ func (s *state) assign(left *ir.Node, right *ssa.Value, deref bool, skip skipMas
 			}
 
 			// Recursively assign the new value we've made to the base of the dot op.
-			s.assign(left.Left, new, false, 0)
+			s.assign(left.Left(), new, false, 0)
 			// TODO: do we need to update named values here?
 			return
 		}
-		if left.Op == ir.OINDEX && left.Left.Type.IsArray() {
-			s.pushLine(left.Pos)
+		if left.Op() == ir.OINDEX && left.Left().Type().IsArray() {
+			s.pushLine(left.Pos())
 			defer s.popLine()
 			// We're assigning to an element of an ssa-able array.
 			// a[i] = v
-			t := left.Left.Type
+			t := left.Left().Type()
 			n := t.NumElem()
 
-			i := s.expr(left.Right) // index
+			i := s.expr(left.Right()) // index
 			if n == 0 {
 				// The bounds check must fail.  Might as well
 				// ignore the actual index and just use zeros.
@@ -3068,7 +3068,7 @@ func (s *state) assign(left *ir.Node, right *ssa.Value, deref bool, skip skipMas
 			len := s.constInt(types.Types[types.TINT], 1)
 			s.boundsCheck(i, len, ssa.BoundsIndex, false) // checks i == 0
 			v := s.newValue1(ssa.OpArrayMake1, t, right)
-			s.assign(left.Left, v, false, 0)
+			s.assign(left.Left(), v, false, 0)
 			return
 		}
 		// Update variable assignment.
@@ -3079,7 +3079,7 @@ func (s *state) assign(left *ir.Node, right *ssa.Value, deref bool, skip skipMas
 
 	// If this assignment clobbers an entire local variable, then emit
 	// OpVarDef so liveness analysis knows the variable is redefined.
-	if base := clobberBase(left); base.Op == ir.ONAME && base.Class() != ir.PEXTERN && skip == 0 {
+	if base := clobberBase(left); base.Op() == ir.ONAME && base.Class() != ir.PEXTERN && skip == 0 {
 		s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, base, s.mem(), !ir.IsAutoTmp(base))
 	}
 
@@ -3323,7 +3323,7 @@ func init() {
 				// Compiler frontend optimizations emit OBYTES2STRTMP nodes
 				// for the backend instead of slicebytetostringtmp calls
 				// when not instrumenting.
-				return s.newValue2(ssa.OpStringMake, n.Type, args[0], args[1])
+				return s.newValue2(ssa.OpStringMake, n.Type(), args[0], args[1])
 			},
 			all...)
 	}
@@ -4157,15 +4157,15 @@ func findIntrinsic(sym *types.Sym) intrinsicBuilder {
 }
 
 func isIntrinsicCall(n *ir.Node) bool {
-	if n == nil || n.Left == nil {
+	if n == nil || n.Left() == nil {
 		return false
 	}
-	return findIntrinsic(n.Left.Sym) != nil
+	return findIntrinsic(n.Left().Sym()) != nil
 }
 
 // intrinsicCall converts a call to a recognized intrinsic function into the intrinsic SSA operation.
 func (s *state) intrinsicCall(n *ir.Node) *ssa.Value {
-	v := findIntrinsic(n.Left.Sym)(s, n, s.intrinsicArgs(n))
+	v := findIntrinsic(n.Left().Sym())(s, n, s.intrinsicArgs(n))
 	if ssa.IntrinsicsDebug > 0 {
 		x := v
 		if x == nil {
@@ -4174,7 +4174,7 @@ func (s *state) intrinsicCall(n *ir.Node) *ssa.Value {
 		if x.Op == ssa.OpSelect0 || x.Op == ssa.OpSelect1 {
 			x = x.Args[0]
 		}
-		base.WarnfAt(n.Pos, "intrinsic substitution for %v with %s", n.Left.Sym.Name, x.LongString())
+		base.WarnfAt(n.Pos(), "intrinsic substitution for %v with %s", n.Left().Sym().Name, x.LongString())
 	}
 	return v
 }
@@ -4183,20 +4183,20 @@ func (s *state) intrinsicCall(n *ir.Node) *ssa.Value {
 func (s *state) intrinsicArgs(n *ir.Node) []*ssa.Value {
 	// Construct map of temps; see comments in s.call about the structure of n.
 	temps := map[*ir.Node]*ssa.Value{}
-	for _, a := range n.List.Slice() {
-		if a.Op != ir.OAS {
-			s.Fatalf("non-assignment as a temp function argument %v", a.Op)
+	for _, a := range n.List().Slice() {
+		if a.Op() != ir.OAS {
+			s.Fatalf("non-assignment as a temp function argument %v", a.Op())
 		}
-		l, r := a.Left, a.Right
-		if l.Op != ir.ONAME {
-			s.Fatalf("non-ONAME temp function argument %v", a.Op)
+		l, r := a.Left(), a.Right()
+		if l.Op() != ir.ONAME {
+			s.Fatalf("non-ONAME temp function argument %v", a.Op())
 		}
 		// Evaluate and store to "temporary".
 		// Walk ensures these temporaries are dead outside of n.
 		temps[l] = s.expr(r)
 	}
-	args := make([]*ssa.Value, n.Rlist.Len())
-	for i, n := range n.Rlist.Slice() {
+	args := make([]*ssa.Value, n.Rlist().Len())
+	for i, n := range n.Rlist().Slice() {
 		// Store a value to an argument slot.
 		if x, ok := temps[n]; ok {
 			// This is a previously computed temporary.
@@ -4221,7 +4221,7 @@ func (s *state) openDeferRecord(n *ir.Node) {
 	// once.mutex'. Such a statement will create a mapping in s.vars[] from
 	// the autotmp name to the evaluated SSA arg value, but won't do any
 	// stores to the stack.
-	s.stmtList(n.List)
+	s.stmtList(n.List())
 
 	var args []*ssa.Value
 	var argNodes []*ir.Node
@@ -4229,45 +4229,45 @@ func (s *state) openDeferRecord(n *ir.Node) {
 	opendefer := &openDeferInfo{
 		n: n,
 	}
-	fn := n.Left
-	if n.Op == ir.OCALLFUNC {
+	fn := n.Left()
+	if n.Op() == ir.OCALLFUNC {
 		// We must always store the function value in a stack slot for the
 		// runtime panic code to use. But in the defer exit code, we will
 		// call the function directly if it is a static function.
 		closureVal := s.expr(fn)
-		closure := s.openDeferSave(nil, fn.Type, closureVal)
+		closure := s.openDeferSave(nil, fn.Type(), closureVal)
 		opendefer.closureNode = closure.Aux.(*ir.Node)
-		if !(fn.Op == ir.ONAME && fn.Class() == ir.PFUNC) {
+		if !(fn.Op() == ir.ONAME && fn.Class() == ir.PFUNC) {
 			opendefer.closure = closure
 		}
-	} else if n.Op == ir.OCALLMETH {
-		if fn.Op != ir.ODOTMETH {
+	} else if n.Op() == ir.OCALLMETH {
+		if fn.Op() != ir.ODOTMETH {
 			base.Fatalf("OCALLMETH: n.Left not an ODOTMETH: %v", fn)
 		}
 		closureVal := s.getMethodClosure(fn)
 		// We must always store the function value in a stack slot for the
 		// runtime panic code to use. But in the defer exit code, we will
 		// call the method directly.
-		closure := s.openDeferSave(nil, fn.Type, closureVal)
+		closure := s.openDeferSave(nil, fn.Type(), closureVal)
 		opendefer.closureNode = closure.Aux.(*ir.Node)
 	} else {
-		if fn.Op != ir.ODOTINTER {
-			base.Fatalf("OCALLINTER: n.Left not an ODOTINTER: %v", fn.Op)
+		if fn.Op() != ir.ODOTINTER {
+			base.Fatalf("OCALLINTER: n.Left not an ODOTINTER: %v", fn.Op())
 		}
 		closure, rcvr := s.getClosureAndRcvr(fn)
 		opendefer.closure = s.openDeferSave(nil, closure.Type, closure)
 		// Important to get the receiver type correct, so it is recognized
 		// as a pointer for GC purposes.
-		opendefer.rcvr = s.openDeferSave(nil, fn.Type.Recv().Type, rcvr)
+		opendefer.rcvr = s.openDeferSave(nil, fn.Type().Recv().Type, rcvr)
 		opendefer.closureNode = opendefer.closure.Aux.(*ir.Node)
 		opendefer.rcvrNode = opendefer.rcvr.Aux.(*ir.Node)
 	}
-	for _, argn := range n.Rlist.Slice() {
+	for _, argn := range n.Rlist().Slice() {
 		var v *ssa.Value
-		if canSSAType(argn.Type) {
-			v = s.openDeferSave(nil, argn.Type, s.expr(argn))
+		if canSSAType(argn.Type()) {
+			v = s.openDeferSave(nil, argn.Type(), s.expr(argn))
 		} else {
-			v = s.openDeferSave(argn, argn.Type, nil)
+			v = s.openDeferSave(argn, argn.Type(), nil)
 		}
 		args = append(args, v)
 		argNodes = append(argNodes, v.Aux.(*ir.Node))
@@ -4298,10 +4298,10 @@ func (s *state) openDeferSave(n *ir.Node, t *types.Type, val *ssa.Value) *ssa.Va
 	if canSSA {
 		pos = val.Pos
 	} else {
-		pos = n.Pos
+		pos = n.Pos()
 	}
 	argTemp := tempAt(pos.WithNotStmt(), s.curfn, t)
-	argTemp.Name.SetOpenDeferSlot(true)
+	argTemp.Name().SetOpenDeferSlot(true)
 	var addrArgTemp *ssa.Value
 	// Use OpVarLive to make sure stack slots for the args, etc. are not
 	// removed by dead-store elimination
@@ -4312,14 +4312,14 @@ func (s *state) openDeferSave(n *ir.Node, t *types.Type, val *ssa.Value) *ssa.Va
 		// associated defer call has been activated).
 		s.defvars[s.f.Entry.ID][memVar] = s.entryNewValue1A(ssa.OpVarDef, types.TypeMem, argTemp, s.defvars[s.f.Entry.ID][memVar])
 		s.defvars[s.f.Entry.ID][memVar] = s.entryNewValue1A(ssa.OpVarLive, types.TypeMem, argTemp, s.defvars[s.f.Entry.ID][memVar])
-		addrArgTemp = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(argTemp.Type), argTemp, s.sp, s.defvars[s.f.Entry.ID][memVar])
+		addrArgTemp = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(argTemp.Type()), argTemp, s.sp, s.defvars[s.f.Entry.ID][memVar])
 	} else {
 		// Special case if we're still in the entry block. We can't use
 		// the above code, since s.defvars[s.f.Entry.ID] isn't defined
 		// until we end the entry block with s.endBlock().
 		s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, argTemp, s.mem(), false)
 		s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, argTemp, s.mem(), false)
-		addrArgTemp = s.newValue2Apos(ssa.OpLocalAddr, types.NewPtr(argTemp.Type), argTemp, s.sp, s.mem(), false)
+		addrArgTemp = s.newValue2Apos(ssa.OpLocalAddr, types.NewPtr(argTemp.Type()), argTemp, s.sp, s.mem(), false)
 	}
 	if t.HasPointers() {
 		// Since we may use this argTemp during exit depending on the
@@ -4327,7 +4327,7 @@ func (s *state) openDeferSave(n *ir.Node, t *types.Type, val *ssa.Value) *ssa.Va
 		// Therefore, we must make sure it is zeroed out in the entry
 		// block if it contains pointers, else GC may wrongly follow an
 		// uninitialized pointer value.
-		argTemp.Name.SetNeedzero(true)
+		argTemp.Name().SetNeedzero(true)
 	}
 	if !canSSA {
 		a := s.addr(n)
@@ -4385,8 +4385,8 @@ func (s *state) openDeferExit() {
 		// closure/receiver/args that were stored in argtmps at the point
 		// of the defer statement.
 		argStart := base.Ctxt.FixedFrameSize()
-		fn := r.n.Left
-		stksize := fn.Type.ArgWidth()
+		fn := r.n.Left()
+		stksize := fn.Type().ArgWidth()
 		var ACArgs []ssa.Param
 		var ACResults []ssa.Param
 		var callArgs []*ssa.Value
@@ -4437,7 +4437,7 @@ func (s *state) openDeferExit() {
 				call = s.newValue3A(ssa.OpClosureCall, types.TypeMem, aux, codeptr, v, s.mem())
 			}
 		} else {
-			aux := ssa.StaticAuxCall(fn.Sym.Linksym(), ACArgs, ACResults)
+			aux := ssa.StaticAuxCall(fn.Sym().Linksym(), ACArgs, ACResults)
 			if testLateExpansion {
 				callArgs = append(callArgs, s.mem())
 				call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
@@ -4461,12 +4461,12 @@ func (s *state) openDeferExit() {
 			s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, r.closureNode, s.mem(), false)
 		}
 		if r.rcvrNode != nil {
-			if r.rcvrNode.Type.HasPointers() {
+			if r.rcvrNode.Type().HasPointers() {
 				s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, r.rcvrNode, s.mem(), false)
 			}
 		}
 		for _, argNode := range r.argNodes {
-			if argNode.Type.HasPointers() {
+			if argNode.Type().HasPointers() {
 				s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, argNode, s.mem(), false)
 			}
 		}
@@ -4492,11 +4492,11 @@ func (s *state) call(n *ir.Node, k callKind, returnResultAddr bool) *ssa.Value {
 	var closure *ssa.Value // ptr to closure to run (if dynamic)
 	var codeptr *ssa.Value // ptr to target code (if dynamic)
 	var rcvr *ssa.Value    // receiver to set
-	fn := n.Left
+	fn := n.Left()
 	var ACArgs []ssa.Param
 	var ACResults []ssa.Param
 	var callArgs []*ssa.Value
-	res := n.Left.Type.Results()
+	res := n.Left().Type().Results()
 	if k == callNormal {
 		nf := res.NumFields()
 		for i := 0; i < nf; i++ {
@@ -4507,11 +4507,11 @@ func (s *state) call(n *ir.Node, k callKind, returnResultAddr bool) *ssa.Value {
 
 	testLateExpansion := false
 
-	switch n.Op {
+	switch n.Op() {
 	case ir.OCALLFUNC:
 		testLateExpansion = k != callDeferStack && ssa.LateCallExpansionEnabledWithin(s.f)
-		if k == callNormal && fn.Op == ir.ONAME && fn.Class() == ir.PFUNC {
-			sym = fn.Sym
+		if k == callNormal && fn.Op() == ir.ONAME && fn.Class() == ir.PFUNC {
+			sym = fn.Sym()
 			break
 		}
 		closure = s.expr(fn)
@@ -4521,20 +4521,20 @@ func (s *state) call(n *ir.Node, k callKind, returnResultAddr bool) *ssa.Value {
 			s.maybeNilCheckClosure(closure, k)
 		}
 	case ir.OCALLMETH:
-		if fn.Op != ir.ODOTMETH {
+		if fn.Op() != ir.ODOTMETH {
 			s.Fatalf("OCALLMETH: n.Left not an ODOTMETH: %v", fn)
 		}
 		testLateExpansion = k != callDeferStack && ssa.LateCallExpansionEnabledWithin(s.f)
 		if k == callNormal {
-			sym = fn.Sym
+			sym = fn.Sym()
 			break
 		}
 		closure = s.getMethodClosure(fn)
 		// Note: receiver is already present in n.Rlist, so we don't
 		// want to set it here.
 	case ir.OCALLINTER:
-		if fn.Op != ir.ODOTINTER {
-			s.Fatalf("OCALLINTER: n.Left not an ODOTINTER: %v", fn.Op)
+		if fn.Op() != ir.ODOTINTER {
+			s.Fatalf("OCALLINTER: n.Left not an ODOTINTER: %v", fn.Op())
 		}
 		testLateExpansion = k != callDeferStack && ssa.LateCallExpansionEnabledWithin(s.f)
 		var iclosure *ssa.Value
@@ -4545,20 +4545,20 @@ func (s *state) call(n *ir.Node, k callKind, returnResultAddr bool) *ssa.Value {
 			closure = iclosure
 		}
 	}
-	dowidth(fn.Type)
-	stksize := fn.Type.ArgWidth() // includes receiver, args, and results
+	dowidth(fn.Type())
+	stksize := fn.Type().ArgWidth() // includes receiver, args, and results
 
 	// Run all assignments of temps.
 	// The temps are introduced to avoid overwriting argument
 	// slots when arguments themselves require function calls.
-	s.stmtList(n.List)
+	s.stmtList(n.List())
 
 	var call *ssa.Value
 	if k == callDeferStack {
 		testLateExpansion = ssa.LateCallExpansionEnabledWithin(s.f)
 		// Make a defer struct d on the stack.
 		t := deferstruct(stksize)
-		d := tempAt(n.Pos, s.curfn, t)
+		d := tempAt(n.Pos(), s.curfn, t)
 
 		s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, d, s.mem())
 		addr := s.addr(d)
@@ -4584,9 +4584,9 @@ func (s *state) call(n *ir.Node, k callKind, returnResultAddr bool) *ssa.Value {
 		// 11: fd
 
 		// Then, store all the arguments of the defer call.
-		ft := fn.Type
+		ft := fn.Type()
 		off := t.FieldOff(12)
-		args := n.Rlist.Slice()
+		args := n.Rlist().Slice()
 
 		// Set receiver (for interface calls). Always a pointer.
 		if rcvr != nil {
@@ -4594,7 +4594,7 @@ func (s *state) call(n *ir.Node, k callKind, returnResultAddr bool) *ssa.Value {
 			s.store(types.Types[types.TUINTPTR], p, rcvr)
 		}
 		// Set receiver (for method calls).
-		if n.Op == ir.OCALLMETH {
+		if n.Op() == ir.OCALLMETH {
 			f := ft.Recv()
 			s.storeArgWithBase(args[0], f.Type, addr, off+f.Offset)
 			args = args[1:]
@@ -4662,9 +4662,9 @@ func (s *state) call(n *ir.Node, k callKind, returnResultAddr bool) *ssa.Value {
 		}
 
 		// Write args.
-		t := n.Left.Type
-		args := n.Rlist.Slice()
-		if n.Op == ir.OCALLMETH {
+		t := n.Left().Type()
+		args := n.Rlist().Slice()
+		if n.Op() == ir.OCALLMETH {
 			f := t.Recv()
 			ACArg, arg := s.putArg(args[0], f.Type, argStart+f.Offset, testLateExpansion)
 			ACArgs = append(ACArgs, ACArg)
@@ -4729,7 +4729,7 @@ func (s *state) call(n *ir.Node, k callKind, returnResultAddr bool) *ssa.Value {
 				call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, ssa.StaticAuxCall(sym.Linksym(), ACArgs, ACResults), s.mem())
 			}
 		default:
-			s.Fatalf("bad call type %v %v", n.Op, n)
+			s.Fatalf("bad call type %v %v", n.Op(), n)
 		}
 		call.AuxInt = stksize // Call operations carry the argsize of the callee along with them
 	}
@@ -4740,7 +4740,7 @@ func (s *state) call(n *ir.Node, k callKind, returnResultAddr bool) *ssa.Value {
 		s.vars[memVar] = call
 	}
 	// Insert OVARLIVE nodes
-	s.stmtList(n.Nbody)
+	s.stmtList(n.Body())
 
 	// Finish block for defers
 	if k == callDefer || k == callDeferStack {
@@ -4774,7 +4774,7 @@ func (s *state) call(n *ir.Node, k callKind, returnResultAddr bool) *ssa.Value {
 	if testLateExpansion {
 		return s.newValue1I(ssa.OpSelectN, fp.Type, 0, call)
 	}
-	return s.load(n.Type, s.constOffPtrSP(types.NewPtr(fp.Type), fp.Offset+base.Ctxt.FixedFrameSize()))
+	return s.load(n.Type(), s.constOffPtrSP(types.NewPtr(fp.Type), fp.Offset+base.Ctxt.FixedFrameSize()))
 }
 
 // maybeNilCheckClosure checks if a nil check of a closure is needed in some
@@ -4794,22 +4794,22 @@ func (s *state) getMethodClosure(fn *ir.Node) *ssa.Value {
 	// Make a PFUNC node out of that, then evaluate it.
 	// We get back an SSA value representing &sync.(*Mutex).Unlock·f.
 	// We can then pass that to defer or go.
-	n2 := ir.NewNameAt(fn.Pos, fn.Sym)
-	n2.Name.Curfn = s.curfn
+	n2 := ir.NewNameAt(fn.Pos(), fn.Sym())
+	n2.Name().Curfn = s.curfn
 	n2.SetClass(ir.PFUNC)
 	// n2.Sym already existed, so it's already marked as a function.
-	n2.Pos = fn.Pos
-	n2.Type = types.Types[types.TUINT8] // fake type for a static closure. Could use runtime.funcval if we had it.
+	n2.SetPos(fn.Pos())
+	n2.SetType(types.Types[types.TUINT8]) // fake type for a static closure. Could use runtime.funcval if we had it.
 	return s.expr(n2)
 }
 
 // getClosureAndRcvr returns values for the appropriate closure and receiver of an
 // interface call
 func (s *state) getClosureAndRcvr(fn *ir.Node) (*ssa.Value, *ssa.Value) {
-	i := s.expr(fn.Left)
+	i := s.expr(fn.Left())
 	itab := s.newValue1(ssa.OpITab, types.Types[types.TUINTPTR], i)
 	s.nilCheck(itab)
-	itabidx := fn.Xoffset + 2*int64(Widthptr) + 8 // offset of fun field in runtime.itab
+	itabidx := fn.Offset() + 2*int64(Widthptr) + 8 // offset of fun field in runtime.itab
 	closure := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.UintptrPtr, itabidx, itab)
 	rcvr := s.newValue1(ssa.OpIData, s.f.Config.Types.BytePtr, i)
 	return closure, rcvr
@@ -4830,21 +4830,21 @@ func etypesign(e types.EType) int8 {
 // addr converts the address of the expression n to SSA, adds it to s and returns the SSA result.
 // The value that the returned Value represents is guaranteed to be non-nil.
 func (s *state) addr(n *ir.Node) *ssa.Value {
-	if n.Op != ir.ONAME {
-		s.pushLine(n.Pos)
+	if n.Op() != ir.ONAME {
+		s.pushLine(n.Pos())
 		defer s.popLine()
 	}
 
-	t := types.NewPtr(n.Type)
-	switch n.Op {
+	t := types.NewPtr(n.Type())
+	switch n.Op() {
 	case ir.ONAME:
 		switch n.Class() {
 		case ir.PEXTERN:
 			// global variable
-			v := s.entryNewValue1A(ssa.OpAddr, t, n.Sym.Linksym(), s.sb)
+			v := s.entryNewValue1A(ssa.OpAddr, t, n.Sym().Linksym(), s.sb)
 			// TODO: Make OpAddr use AuxInt as well as Aux.
-			if n.Xoffset != 0 {
-				v = s.entryNewValue1I(ssa.OpOffPtr, v.Type, n.Xoffset, v)
+			if n.Offset() != 0 {
+				v = s.entryNewValue1I(ssa.OpOffPtr, v.Type, n.Offset(), v)
 			}
 			return v
 		case ir.PPARAM:
@@ -4873,44 +4873,44 @@ func (s *state) addr(n *ir.Node) *ssa.Value {
 	case ir.ORESULT:
 		// load return from callee
 		if s.prevCall == nil || s.prevCall.Op != ssa.OpStaticLECall && s.prevCall.Op != ssa.OpInterLECall && s.prevCall.Op != ssa.OpClosureLECall {
-			return s.constOffPtrSP(t, n.Xoffset)
+			return s.constOffPtrSP(t, n.Offset())
 		}
-		which := s.prevCall.Aux.(*ssa.AuxCall).ResultForOffset(n.Xoffset)
+		which := s.prevCall.Aux.(*ssa.AuxCall).ResultForOffset(n.Offset())
 		if which == -1 {
 			// Do the old thing // TODO: Panic instead.
-			return s.constOffPtrSP(t, n.Xoffset)
+			return s.constOffPtrSP(t, n.Offset())
 		}
 		x := s.newValue1I(ssa.OpSelectNAddr, t, which, s.prevCall)
 		return x
 
 	case ir.OINDEX:
-		if n.Left.Type.IsSlice() {
-			a := s.expr(n.Left)
-			i := s.expr(n.Right)
+		if n.Left().Type().IsSlice() {
+			a := s.expr(n.Left())
+			i := s.expr(n.Right())
 			len := s.newValue1(ssa.OpSliceLen, types.Types[types.TINT], a)
 			i = s.boundsCheck(i, len, ssa.BoundsIndex, n.Bounded())
 			p := s.newValue1(ssa.OpSlicePtr, t, a)
 			return s.newValue2(ssa.OpPtrIndex, t, p, i)
 		} else { // array
-			a := s.addr(n.Left)
-			i := s.expr(n.Right)
-			len := s.constInt(types.Types[types.TINT], n.Left.Type.NumElem())
+			a := s.addr(n.Left())
+			i := s.expr(n.Right())
+			len := s.constInt(types.Types[types.TINT], n.Left().Type().NumElem())
 			i = s.boundsCheck(i, len, ssa.BoundsIndex, n.Bounded())
-			return s.newValue2(ssa.OpPtrIndex, types.NewPtr(n.Left.Type.Elem()), a, i)
+			return s.newValue2(ssa.OpPtrIndex, types.NewPtr(n.Left().Type().Elem()), a, i)
 		}
 	case ir.ODEREF:
-		return s.exprPtr(n.Left, n.Bounded(), n.Pos)
+		return s.exprPtr(n.Left(), n.Bounded(), n.Pos())
 	case ir.ODOT:
-		p := s.addr(n.Left)
-		return s.newValue1I(ssa.OpOffPtr, t, n.Xoffset, p)
+		p := s.addr(n.Left())
+		return s.newValue1I(ssa.OpOffPtr, t, n.Offset(), p)
 	case ir.ODOTPTR:
-		p := s.exprPtr(n.Left, n.Bounded(), n.Pos)
-		return s.newValue1I(ssa.OpOffPtr, t, n.Xoffset, p)
+		p := s.exprPtr(n.Left(), n.Bounded(), n.Pos())
+		return s.newValue1I(ssa.OpOffPtr, t, n.Offset(), p)
 	case ir.OCLOSUREVAR:
-		return s.newValue1I(ssa.OpOffPtr, t, n.Xoffset,
+		return s.newValue1I(ssa.OpOffPtr, t, n.Offset(),
 			s.entryNewValue0(ssa.OpGetClosurePtr, s.f.Config.Types.BytePtr))
 	case ir.OCONVNOP:
-		addr := s.addr(n.Left)
+		addr := s.addr(n.Left())
 		return s.newValue1(ssa.OpCopy, t, addr) // ensure that addr has the right type
 	case ir.OCALLFUNC, ir.OCALLINTER, ir.OCALLMETH:
 		return s.callAddr(n, callNormal)
@@ -4924,7 +4924,7 @@ func (s *state) addr(n *ir.Node) *ssa.Value {
 		}
 		return v.Args[0]
 	default:
-		s.Fatalf("unhandled addr %v", n.Op)
+		s.Fatalf("unhandled addr %v", n.Op())
 		return nil
 	}
 }
@@ -4935,13 +4935,13 @@ func (s *state) canSSA(n *ir.Node) bool {
 	if base.Flag.N != 0 {
 		return false
 	}
-	for n.Op == ir.ODOT || (n.Op == ir.OINDEX && n.Left.Type.IsArray()) {
-		n = n.Left
+	for n.Op() == ir.ODOT || (n.Op() == ir.OINDEX && n.Left().Type().IsArray()) {
+		n = n.Left()
 	}
-	if n.Op != ir.ONAME {
+	if n.Op() != ir.ONAME {
 		return false
 	}
-	if n.Name.Addrtaken() {
+	if n.Name().Addrtaken() {
 		return false
 	}
 	if isParamHeapCopy(n) {
@@ -4968,13 +4968,13 @@ func (s *state) canSSA(n *ir.Node) bool {
 			return false
 		}
 	}
-	if n.Class() == ir.PPARAM && n.Sym != nil && n.Sym.Name == ".this" {
+	if n.Class() == ir.PPARAM && n.Sym() != nil && n.Sym().Name == ".this" {
 		// wrappers generated by genwrapper need to update
 		// the .this pointer in place.
 		// TODO: treat as a PPARAMOUT?
 		return false
 	}
-	return canSSAType(n.Type)
+	return canSSAType(n.Type())
 	// TODO: try to make more variables SSAable?
 }
 
@@ -5028,7 +5028,7 @@ func (s *state) exprPtr(n *ir.Node, bounded bool, lineno src.XPos) *ssa.Value {
 // Used only for automatically inserted nil checks,
 // not for user code like 'x != nil'.
 func (s *state) nilCheck(ptr *ssa.Value) {
-	if base.Debug.DisableNil != 0 || s.curfn.Func.NilCheckDisabled() {
+	if base.Debug.DisableNil != 0 || s.curfn.Func().NilCheckDisabled() {
 		return
 	}
 	s.newValue2(ssa.OpNilCheck, types.TypeVoid, ptr, s.mem())
@@ -5161,10 +5161,10 @@ func (s *state) intDivide(n *ir.Node, a, b *ssa.Value) *ssa.Value {
 	}
 	if needcheck {
 		// do a size-appropriate check for zero
-		cmp := s.newValue2(s.ssaOp(ir.ONE, n.Type), types.Types[types.TBOOL], b, s.zeroVal(n.Type))
+		cmp := s.newValue2(s.ssaOp(ir.ONE, n.Type()), types.Types[types.TBOOL], b, s.zeroVal(n.Type()))
 		s.check(cmp, panicdivide)
 	}
-	return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b)
+	return s.newValue2(s.ssaOp(n.Op(), n.Type()), a.Type, a, b)
 }
 
 // rtcall issues a call to the given runtime function fn with the listed args.
@@ -5609,7 +5609,7 @@ func (s *state) uint64Tofloat(cvttab *u642fcvtTab, n *ir.Node, x *ssa.Value, ft,
 	bElse.AddEdgeTo(bAfter)
 
 	s.startBlock(bAfter)
-	return s.variable(n, n.Type)
+	return s.variable(n, n.Type())
 }
 
 type u322fcvtTab struct {
@@ -5669,12 +5669,12 @@ func (s *state) uint32Tofloat(cvttab *u322fcvtTab, n *ir.Node, x *ssa.Value, ft,
 	bElse.AddEdgeTo(bAfter)
 
 	s.startBlock(bAfter)
-	return s.variable(n, n.Type)
+	return s.variable(n, n.Type())
 }
 
 // referenceTypeBuiltin generates code for the len/cap builtins for maps and channels.
 func (s *state) referenceTypeBuiltin(n *ir.Node, x *ssa.Value) *ssa.Value {
-	if !n.Left.Type.IsMap() && !n.Left.Type.IsChan() {
+	if !n.Left().Type().IsMap() && !n.Left().Type().IsChan() {
 		s.Fatalf("node must be a map or a channel")
 	}
 	// if n == nil {
@@ -5685,7 +5685,7 @@ func (s *state) referenceTypeBuiltin(n *ir.Node, x *ssa.Value) *ssa.Value {
 	//   // cap
 	//   return *(((*int)n)+1)
 	// }
-	lenType := n.Type
+	lenType := n.Type()
 	nilValue := s.constNil(types.Types[types.TUINTPTR])
 	cmp := s.newValue2(ssa.OpEqPtr, types.Types[types.TBOOL], x, nilValue)
 	b := s.endBlock()
@@ -5706,7 +5706,7 @@ func (s *state) referenceTypeBuiltin(n *ir.Node, x *ssa.Value) *ssa.Value {
 
 	b.AddEdgeTo(bElse)
 	s.startBlock(bElse)
-	switch n.Op {
+	switch n.Op() {
 	case ir.OLEN:
 		// length is stored in the first word for map/chan
 		s.vars[n] = s.load(lenType, x)
@@ -5824,23 +5824,23 @@ func (s *state) floatToUint(cvttab *f2uCvtTab, n *ir.Node, x *ssa.Value, ft, tt
 	bElse.AddEdgeTo(bAfter)
 
 	s.startBlock(bAfter)
-	return s.variable(n, n.Type)
+	return s.variable(n, n.Type())
 }
 
 // dottype generates SSA for a type assertion node.
 // commaok indicates whether to panic or return a bool.
 // If commaok is false, resok will be nil.
 func (s *state) dottype(n *ir.Node, commaok bool) (res, resok *ssa.Value) {
-	iface := s.expr(n.Left)   // input interface
-	target := s.expr(n.Right) // target type
+	iface := s.expr(n.Left())   // input interface
+	target := s.expr(n.Right()) // target type
 	byteptr := s.f.Config.Types.BytePtr
 
-	if n.Type.IsInterface() {
-		if n.Type.IsEmptyInterface() {
+	if n.Type().IsInterface() {
+		if n.Type().IsEmptyInterface() {
 			// Converting to an empty interface.
 			// Input could be an empty or nonempty interface.
 			if base.Debug.TypeAssert > 0 {
-				base.WarnfAt(n.Pos, "type assertion inlined")
+				base.WarnfAt(n.Pos(), "type assertion inlined")
 			}
 
 			// Get itab/type field from input.
@@ -5848,7 +5848,7 @@ func (s *state) dottype(n *ir.Node, commaok bool) (res, resok *ssa.Value) {
 			// Conversion succeeds iff that field is not nil.
 			cond := s.newValue2(ssa.OpNeqPtr, types.Types[types.TBOOL], itab, s.constNil(byteptr))
 
-			if n.Left.Type.IsEmptyInterface() && commaok {
+			if n.Left().Type().IsEmptyInterface() && commaok {
 				// Converting empty interface to empty interface with ,ok is just a nil check.
 				return iface, cond
 			}
@@ -5870,15 +5870,15 @@ func (s *state) dottype(n *ir.Node, commaok bool) (res, resok *ssa.Value) {
 
 				// On success, return (perhaps modified) input interface.
 				s.startBlock(bOk)
-				if n.Left.Type.IsEmptyInterface() {
+				if n.Left().Type().IsEmptyInterface() {
 					res = iface // Use input interface unchanged.
 					return
 				}
 				// Load type out of itab, build interface with existing idata.
 				off := s.newValue1I(ssa.OpOffPtr, byteptr, int64(Widthptr), itab)
 				typ := s.load(byteptr, off)
-				idata := s.newValue1(ssa.OpIData, n.Type, iface)
-				res = s.newValue2(ssa.OpIMake, n.Type, typ, idata)
+				idata := s.newValue1(ssa.OpIData, n.Type(), iface)
+				res = s.newValue2(ssa.OpIMake, n.Type(), typ, idata)
 				return
 			}
 
@@ -5899,55 +5899,55 @@ func (s *state) dottype(n *ir.Node, commaok bool) (res, resok *ssa.Value) {
 			bOk.AddEdgeTo(bEnd)
 			bFail.AddEdgeTo(bEnd)
 			s.startBlock(bEnd)
-			idata := s.newValue1(ssa.OpIData, n.Type, iface)
-			res = s.newValue2(ssa.OpIMake, n.Type, s.variable(typVar, byteptr), idata)
+			idata := s.newValue1(ssa.OpIData, n.Type(), iface)
+			res = s.newValue2(ssa.OpIMake, n.Type(), s.variable(typVar, byteptr), idata)
 			resok = cond
 			delete(s.vars, typVar)
 			return
 		}
 		// converting to a nonempty interface needs a runtime call.
 		if base.Debug.TypeAssert > 0 {
-			base.WarnfAt(n.Pos, "type assertion not inlined")
+			base.WarnfAt(n.Pos(), "type assertion not inlined")
 		}
-		if n.Left.Type.IsEmptyInterface() {
+		if n.Left().Type().IsEmptyInterface() {
 			if commaok {
-				call := s.rtcall(assertE2I2, true, []*types.Type{n.Type, types.Types[types.TBOOL]}, target, iface)
+				call := s.rtcall(assertE2I2, true, []*types.Type{n.Type(), types.Types[types.TBOOL]}, target, iface)
 				return call[0], call[1]
 			}
-			return s.rtcall(assertE2I, true, []*types.Type{n.Type}, target, iface)[0], nil
+			return s.rtcall(assertE2I, true, []*types.Type{n.Type()}, target, iface)[0], nil
 		}
 		if commaok {
-			call := s.rtcall(assertI2I2, true, []*types.Type{n.Type, types.Types[types.TBOOL]}, target, iface)
+			call := s.rtcall(assertI2I2, true, []*types.Type{n.Type(), types.Types[types.TBOOL]}, target, iface)
 			return call[0], call[1]
 		}
-		return s.rtcall(assertI2I, true, []*types.Type{n.Type}, target, iface)[0], nil
+		return s.rtcall(assertI2I, true, []*types.Type{n.Type()}, target, iface)[0], nil
 	}
 
 	if base.Debug.TypeAssert > 0 {
-		base.WarnfAt(n.Pos, "type assertion inlined")
+		base.WarnfAt(n.Pos(), "type assertion inlined")
 	}
 
 	// Converting to a concrete type.
-	direct := isdirectiface(n.Type)
+	direct := isdirectiface(n.Type())
 	itab := s.newValue1(ssa.OpITab, byteptr, iface) // type word of interface
 	if base.Debug.TypeAssert > 0 {
-		base.WarnfAt(n.Pos, "type assertion inlined")
+		base.WarnfAt(n.Pos(), "type assertion inlined")
 	}
 	var targetITab *ssa.Value
-	if n.Left.Type.IsEmptyInterface() {
+	if n.Left().Type().IsEmptyInterface() {
 		// Looking for pointer to target type.
 		targetITab = target
 	} else {
 		// Looking for pointer to itab for target type and source interface.
-		targetITab = s.expr(n.List.First())
+		targetITab = s.expr(n.List().First())
 	}
 
 	var tmp *ir.Node    // temporary for use with large types
 	var addr *ssa.Value // address of tmp
-	if commaok && !canSSAType(n.Type) {
+	if commaok && !canSSAType(n.Type()) {
 		// unSSAable type, use temporary.
 		// TODO: get rid of some of these temporaries.
-		tmp = tempAt(n.Pos, s.curfn, n.Type)
+		tmp = tempAt(n.Pos(), s.curfn, n.Type())
 		s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, tmp, s.mem())
 		addr = s.addr(tmp)
 	}
@@ -5966,8 +5966,8 @@ func (s *state) dottype(n *ir.Node, commaok bool) (res, resok *ssa.Value) {
 	if !commaok {
 		// on failure, panic by calling panicdottype
 		s.startBlock(bFail)
-		taddr := s.expr(n.Right.Right)
-		if n.Left.Type.IsEmptyInterface() {
+		taddr := s.expr(n.Right().Right())
+		if n.Left().Type().IsEmptyInterface() {
 			s.rtcall(panicdottypeE, false, nil, itab, target, taddr)
 		} else {
 			s.rtcall(panicdottypeI, false, nil, itab, target, taddr)
@@ -5976,10 +5976,10 @@ func (s *state) dottype(n *ir.Node, commaok bool) (res, resok *ssa.Value) {
 		// on success, return data from interface
 		s.startBlock(bOk)
 		if direct {
-			return s.newValue1(ssa.OpIData, n.Type, iface), nil
+			return s.newValue1(ssa.OpIData, n.Type(), iface), nil
 		}
-		p := s.newValue1(ssa.OpIData, types.NewPtr(n.Type), iface)
-		return s.load(n.Type, p), nil
+		p := s.newValue1(ssa.OpIData, types.NewPtr(n.Type()), iface)
+		return s.load(n.Type(), p), nil
 	}
 
 	// commaok is the more complicated case because we have
@@ -5993,14 +5993,14 @@ func (s *state) dottype(n *ir.Node, commaok bool) (res, resok *ssa.Value) {
 	s.startBlock(bOk)
 	if tmp == nil {
 		if direct {
-			s.vars[valVar] = s.newValue1(ssa.OpIData, n.Type, iface)
+			s.vars[valVar] = s.newValue1(ssa.OpIData, n.Type(), iface)
 		} else {
-			p := s.newValue1(ssa.OpIData, types.NewPtr(n.Type), iface)
-			s.vars[valVar] = s.load(n.Type, p)
+			p := s.newValue1(ssa.OpIData, types.NewPtr(n.Type()), iface)
+			s.vars[valVar] = s.load(n.Type(), p)
 		}
 	} else {
-		p := s.newValue1(ssa.OpIData, types.NewPtr(n.Type), iface)
-		s.move(n.Type, addr, p)
+		p := s.newValue1(ssa.OpIData, types.NewPtr(n.Type()), iface)
+		s.move(n.Type(), addr, p)
 	}
 	s.vars[okVar] = s.constBool(true)
 	s.endBlock()
@@ -6009,9 +6009,9 @@ func (s *state) dottype(n *ir.Node, commaok bool) (res, resok *ssa.Value) {
 	// type assertion failed
 	s.startBlock(bFail)
 	if tmp == nil {
-		s.vars[valVar] = s.zeroVal(n.Type)
+		s.vars[valVar] = s.zeroVal(n.Type())
 	} else {
-		s.zero(n.Type, addr)
+		s.zero(n.Type(), addr)
 	}
 	s.vars[okVar] = s.constBool(false)
 	s.endBlock()
@@ -6020,10 +6020,10 @@ func (s *state) dottype(n *ir.Node, commaok bool) (res, resok *ssa.Value) {
 	// merge point
 	s.startBlock(bEnd)
 	if tmp == nil {
-		res = s.variable(valVar, n.Type)
+		res = s.variable(valVar, n.Type())
 		delete(s.vars, valVar)
 	} else {
-		res = s.load(n.Type, addr)
+		res = s.load(n.Type(), addr)
 		s.vars[memVar] = s.newValue1A(ssa.OpVarKill, types.TypeMem, tmp, s.mem())
 	}
 	resok = s.variable(okVar, types.Types[types.TBOOL])
@@ -6072,10 +6072,10 @@ func (s *state) addNamedValue(n *ir.Node, v *ssa.Value) {
 		// from being assigned too early. See #14591 and #14762. TODO: allow this.
 		return
 	}
-	if n.Class() == ir.PAUTO && n.Xoffset != 0 {
-		s.Fatalf("AUTO var with offset %v %d", n, n.Xoffset)
+	if n.Class() == ir.PAUTO && n.Offset() != 0 {
+		s.Fatalf("AUTO var with offset %v %d", n, n.Offset())
 	}
-	loc := ssa.LocalSlot{N: n, Type: n.Type, Off: 0}
+	loc := ssa.LocalSlot{N: n, Type: n.Type(), Off: 0}
 	values, ok := s.f.NamedValues[loc]
 	if !ok {
 		s.f.Names = append(s.f.Names, loc)
@@ -6197,13 +6197,13 @@ func (s *SSAGenState) DebugFriendlySetPosFrom(v *ssa.Value) {
 type byXoffset []*ir.Node
 
 func (s byXoffset) Len() int           { return len(s) }
-func (s byXoffset) Less(i, j int) bool { return s[i].Xoffset < s[j].Xoffset }
+func (s byXoffset) Less(i, j int) bool { return s[i].Offset() < s[j].Offset() }
 func (s byXoffset) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 
 func emitStackObjects(e *ssafn, pp *Progs) {
 	var vars []*ir.Node
-	for _, n := range e.curfn.Func.Dcl {
-		if livenessShouldTrack(n) && n.Name.Addrtaken() {
+	for _, n := range e.curfn.Func().Dcl {
+		if livenessShouldTrack(n) && n.Name().Addrtaken() {
 			vars = append(vars, n)
 		}
 	}
@@ -6216,18 +6216,18 @@ func emitStackObjects(e *ssafn, pp *Progs) {
 
 	// Populate the stack object data.
 	// Format must match runtime/stack.go:stackObjectRecord.
-	x := e.curfn.Func.LSym.Func().StackObjects
+	x := e.curfn.Func().LSym.Func().StackObjects
 	off := 0
 	off = duintptr(x, off, uint64(len(vars)))
 	for _, v := range vars {
 		// Note: arguments and return values have non-negative Xoffset,
 		// in which case the offset is relative to argp.
 		// Locals have a negative Xoffset, in which case the offset is relative to varp.
-		off = duintptr(x, off, uint64(v.Xoffset))
-		if !typesym(v.Type).Siggen() {
-			e.Fatalf(v.Pos, "stack object's type symbol not generated for type %s", v.Type)
+		off = duintptr(x, off, uint64(v.Offset()))
+		if !typesym(v.Type()).Siggen() {
+			e.Fatalf(v.Pos(), "stack object's type symbol not generated for type %s", v.Type())
 		}
-		off = dsymptr(x, off, dtypesym(v.Type), 0)
+		off = dsymptr(x, off, dtypesym(v.Type()), 0)
 	}
 
 	// Emit a funcdata pointing at the stack object data.
@@ -6239,7 +6239,7 @@ func emitStackObjects(e *ssafn, pp *Progs) {
 
 	if base.Flag.Live != 0 {
 		for _, v := range vars {
-			base.WarnfAt(v.Pos, "stack object %v %s", v, v.Type.String())
+			base.WarnfAt(v.Pos(), "stack object %v %s", v, v.Type().String())
 		}
 	}
 }
@@ -6253,7 +6253,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 	s.livenessMap = liveness(e, f, pp)
 	emitStackObjects(e, pp)
 
-	openDeferInfo := e.curfn.Func.LSym.Func().OpenCodedDeferInfo
+	openDeferInfo := e.curfn.Func().LSym.Func().OpenCodedDeferInfo
 	if openDeferInfo != nil {
 		// This function uses open-coded defers -- write out the funcdata
 		// info that we computed at the end of genssa.
@@ -6458,7 +6458,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 				// some of the inline marks.
 				// Use this instruction instead.
 				p.Pos = p.Pos.WithIsStmt() // promote position to a statement
-				pp.curfn.Func.LSym.Func().AddInlMark(p, inlMarks[m])
+				pp.curfn.Func().LSym.Func().AddInlMark(p, inlMarks[m])
 				// Make the inline mark a real nop, so it doesn't generate any code.
 				m.As = obj.ANOP
 				m.Pos = src.NoXPos
@@ -6470,14 +6470,14 @@ func genssa(f *ssa.Func, pp *Progs) {
 		// Any unmatched inline marks now need to be added to the inlining tree (and will generate a nop instruction).
 		for _, p := range inlMarkList {
 			if p.As != obj.ANOP {
-				pp.curfn.Func.LSym.Func().AddInlMark(p, inlMarks[p])
+				pp.curfn.Func().LSym.Func().AddInlMark(p, inlMarks[p])
 			}
 		}
 	}
 
 	if base.Ctxt.Flag_locationlists {
 		debugInfo := ssa.BuildFuncDebug(base.Ctxt, f, base.Debug.LocationLists > 1, stackOffset)
-		e.curfn.Func.DebugInfo = debugInfo
+		e.curfn.Func().DebugInfo = debugInfo
 		bstart := s.bstart
 		// Note that at this moment, Prog.Pc is a sequence number; it's
 		// not a real PC until after assembly, so this mapping has to
@@ -6491,7 +6491,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 				}
 				return bstart[b].Pc
 			case ssa.BlockEnd.ID:
-				return e.curfn.Func.LSym.Size
+				return e.curfn.Func().LSym.Size
 			default:
 				return valueToProgAfter[v].Pc
 			}
@@ -6575,7 +6575,7 @@ func defframe(s *SSAGenState, e *ssafn) {
 
 	// Fill in argument and frame size.
 	pp.Text.To.Type = obj.TYPE_TEXTSIZE
-	pp.Text.To.Val = int32(Rnd(e.curfn.Type.ArgWidth(), int64(Widthreg)))
+	pp.Text.To.Val = int32(Rnd(e.curfn.Type().ArgWidth(), int64(Widthreg)))
 	pp.Text.To.Offset = frame
 
 	// Insert code to zero ambiguously live variables so that the
@@ -6589,20 +6589,20 @@ func defframe(s *SSAGenState, e *ssafn) {
 	var state uint32
 
 	// Iterate through declarations. They are sorted in decreasing Xoffset order.
-	for _, n := range e.curfn.Func.Dcl {
-		if !n.Name.Needzero() {
+	for _, n := range e.curfn.Func().Dcl {
+		if !n.Name().Needzero() {
 			continue
 		}
 		if n.Class() != ir.PAUTO {
-			e.Fatalf(n.Pos, "needzero class %d", n.Class())
+			e.Fatalf(n.Pos(), "needzero class %d", n.Class())
 		}
-		if n.Type.Size()%int64(Widthptr) != 0 || n.Xoffset%int64(Widthptr) != 0 || n.Type.Size() == 0 {
-			e.Fatalf(n.Pos, "var %L has size %d offset %d", n, n.Type.Size(), n.Xoffset)
+		if n.Type().Size()%int64(Widthptr) != 0 || n.Offset()%int64(Widthptr) != 0 || n.Type().Size() == 0 {
+			e.Fatalf(n.Pos(), "var %L has size %d offset %d", n, n.Type().Size(), n.Offset())
 		}
 
-		if lo != hi && n.Xoffset+n.Type.Size() >= lo-int64(2*Widthreg) {
+		if lo != hi && n.Offset()+n.Type().Size() >= lo-int64(2*Widthreg) {
 			// Merge with range we already have.
-			lo = n.Xoffset
+			lo = n.Offset()
 			continue
 		}
 
@@ -6610,8 +6610,8 @@ func defframe(s *SSAGenState, e *ssafn) {
 		p = thearch.ZeroRange(pp, p, frame+lo, hi-lo, &state)
 
 		// Set new range.
-		lo = n.Xoffset
-		hi = lo + n.Type.Size()
+		lo = n.Offset()
+		hi = lo + n.Type().Size()
 	}
 
 	// Zero final range.
@@ -6680,13 +6680,13 @@ func AddAux2(a *obj.Addr, v *ssa.Value, offset int64) {
 	case *ir.Node:
 		if n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT {
 			a.Name = obj.NAME_PARAM
-			a.Sym = n.Orig.Sym.Linksym()
-			a.Offset += n.Xoffset
+			a.Sym = n.Orig().Sym().Linksym()
+			a.Offset += n.Offset()
 			break
 		}
 		a.Name = obj.NAME_AUTO
-		a.Sym = n.Sym.Linksym()
-		a.Offset += n.Xoffset
+		a.Sym = n.Sym().Linksym()
+		a.Offset += n.Offset()
 	default:
 		v.Fatalf("aux in %s not implemented %#v", v, v.Aux)
 	}
@@ -6827,9 +6827,9 @@ func AutoVar(v *ssa.Value) (*ir.Node, int64) {
 func AddrAuto(a *obj.Addr, v *ssa.Value) {
 	n, off := AutoVar(v)
 	a.Type = obj.TYPE_MEM
-	a.Sym = n.Sym.Linksym()
+	a.Sym = n.Sym().Linksym()
 	a.Reg = int16(thearch.REGSP)
-	a.Offset = n.Xoffset + off
+	a.Offset = n.Offset() + off
 	if n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT {
 		a.Name = obj.NAME_PARAM
 	} else {
@@ -6843,9 +6843,9 @@ func (s *SSAGenState) AddrScratch(a *obj.Addr) {
 	}
 	a.Type = obj.TYPE_MEM
 	a.Name = obj.NAME_AUTO
-	a.Sym = s.ScratchFpMem.Sym.Linksym()
+	a.Sym = s.ScratchFpMem.Sym().Linksym()
 	a.Reg = int16(thearch.REGSP)
-	a.Offset = s.ScratchFpMem.Xoffset
+	a.Offset = s.ScratchFpMem.Offset()
 }
 
 // Call returns a new CALL instruction for the SSA value v.
@@ -6928,8 +6928,8 @@ func (s *SSAGenState) UseArgs(n int64) {
 
 // fieldIdx finds the index of the field referred to by the ODOT node n.
 func fieldIdx(n *ir.Node) int {
-	t := n.Left.Type
-	f := n.Sym
+	t := n.Left().Type()
+	f := n.Sym()
 	if !t.IsStruct() {
 		panic("ODOT's LHS is not a struct")
 	}
@@ -6940,7 +6940,7 @@ func fieldIdx(n *ir.Node) int {
 			i++
 			continue
 		}
-		if t1.Offset != n.Xoffset {
+		if t1.Offset != n.Offset() {
 			panic("field offset doesn't match")
 		}
 		return i
@@ -6971,7 +6971,7 @@ func (e *ssafn) StringData(s string) *obj.LSym {
 	if e.strings == nil {
 		e.strings = make(map[string]*obj.LSym)
 	}
-	data := stringsym(e.curfn.Pos, s)
+	data := stringsym(e.curfn.Pos(), s)
 	e.strings[s] = data
 	return data
 }
@@ -6996,7 +6996,7 @@ func (e *ssafn) SplitInterface(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot
 	t := types.NewPtr(types.Types[types.TUINT8])
 	// Split this interface up into two separate variables.
 	f := ".itab"
-	if n.Type.IsEmptyInterface() {
+	if n.Type().IsEmptyInterface() {
 		f = ".type"
 	}
 	c := e.SplitSlot(&name, f, 0, u) // see comment in plive.go:onebitwalktype1.
@@ -7051,7 +7051,7 @@ func (e *ssafn) SplitArray(name ssa.LocalSlot) ssa.LocalSlot {
 	n := name.N
 	at := name.Type
 	if at.NumElem() != 1 {
-		e.Fatalf(n.Pos, "bad array size")
+		e.Fatalf(n.Pos(), "bad array size")
 	}
 	et := at.Elem()
 	return e.SplitSlot(&name, "[0]", 0, et)
@@ -7065,20 +7065,20 @@ func (e *ssafn) DerefItab(it *obj.LSym, offset int64) *obj.LSym {
 func (e *ssafn) SplitSlot(parent *ssa.LocalSlot, suffix string, offset int64, t *types.Type) ssa.LocalSlot {
 	node := parent.N
 
-	if node.Class() != ir.PAUTO || node.Name.Addrtaken() {
+	if node.Class() != ir.PAUTO || node.Name().Addrtaken() {
 		// addressed things and non-autos retain their parents (i.e., cannot truly be split)
 		return ssa.LocalSlot{N: node, Type: t, Off: parent.Off + offset}
 	}
 
-	s := &types.Sym{Name: node.Sym.Name + suffix, Pkg: ir.LocalPkg}
-	n := ir.NewNameAt(parent.N.Pos, s)
+	s := &types.Sym{Name: node.Sym().Name + suffix, Pkg: ir.LocalPkg}
+	n := ir.NewNameAt(parent.N.Pos(), s)
 	s.Def = ir.AsTypesNode(n)
-	ir.AsNode(s.Def).Name.SetUsed(true)
-	n.Type = t
+	ir.AsNode(s.Def).Name().SetUsed(true)
+	n.SetType(t)
 	n.SetClass(ir.PAUTO)
-	n.Esc = EscNever
-	n.Name.Curfn = e.curfn
-	e.curfn.Func.Dcl = append(e.curfn.Func.Dcl, n)
+	n.SetEsc(EscNever)
+	n.Name().Curfn = e.curfn
+	e.curfn.Func().Dcl = append(e.curfn.Func().Dcl, n)
 	dowidth(t)
 	return ssa.LocalSlot{N: n, Type: t, Off: 0, SplitOf: parent, SplitOffset: offset}
 }
@@ -7141,7 +7141,7 @@ func (e *ssafn) Syslook(name string) *obj.LSym {
 }
 
 func (e *ssafn) SetWBPos(pos src.XPos) {
-	e.curfn.Func.SetWBPos(pos)
+	e.curfn.Func().SetWBPos(pos)
 }
 
 func (e *ssafn) MyImportPath() string {
@@ -7149,11 +7149,11 @@ func (e *ssafn) MyImportPath() string {
 }
 
 func clobberBase(n *ir.Node) *ir.Node {
-	if n.Op == ir.ODOT && n.Left.Type.NumFields() == 1 {
-		return clobberBase(n.Left)
+	if n.Op() == ir.ODOT && n.Left().Type().NumFields() == 1 {
+		return clobberBase(n.Left())
 	}
-	if n.Op == ir.OINDEX && n.Left.Type.IsArray() && n.Left.Type.NumElem() == 1 {
-		return clobberBase(n.Left)
+	if n.Op() == ir.OINDEX && n.Left().Type().IsArray() && n.Left().Type().NumElem() == 1 {
+		return clobberBase(n.Left())
 	}
 	return n
 }
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 46f4153fe1..542dc49bb0 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -41,16 +41,16 @@ var (
 // whose Pos will point back to their declaration position rather than
 // their usage position.
 func hasUniquePos(n *ir.Node) bool {
-	switch n.Op {
+	switch n.Op() {
 	case ir.ONAME, ir.OPACK:
 		return false
 	case ir.OLITERAL, ir.ONIL, ir.OTYPE:
-		if n.Sym != nil {
+		if n.Sym() != nil {
 			return false
 		}
 	}
 
-	if !n.Pos.IsKnown() {
+	if !n.Pos().IsKnown() {
 		if base.Flag.K != 0 {
 			base.Warn("setlineno: unknown position (line 0)")
 		}
@@ -63,7 +63,7 @@ func hasUniquePos(n *ir.Node) bool {
 func setlineno(n *ir.Node) src.XPos {
 	lno := base.Pos
 	if n != nil && hasUniquePos(n) {
-		base.Pos = n.Pos
+		base.Pos = n.Pos()
 	}
 	return lno
 }
@@ -95,8 +95,8 @@ func autolabel(prefix string) *types.Sym {
 	if Curfn == nil {
 		base.Fatalf("autolabel outside function")
 	}
-	n := fn.Func.Label
-	fn.Func.Label++
+	n := fn.Func().Label
+	fn.Func().Label++
 	return lookupN(prefix, int(n))
 }
 
@@ -120,25 +120,25 @@ func importdot(opkg *types.Pkg, pack *ir.Node) {
 
 		s1.Def = s.Def
 		s1.Block = s.Block
-		if ir.AsNode(s1.Def).Name == nil {
+		if ir.AsNode(s1.Def).Name() == nil {
 			ir.Dump("s1def", ir.AsNode(s1.Def))
 			base.Fatalf("missing Name")
 		}
-		ir.AsNode(s1.Def).Name.Pack = pack
+		ir.AsNode(s1.Def).Name().Pack = pack
 		s1.Origpkg = opkg
 		n++
 	}
 
 	if n == 0 {
 		// can't possibly be used - there were no symbols
-		base.ErrorfAt(pack.Pos, "imported and not used: %q", opkg.Path)
+		base.ErrorfAt(pack.Pos(), "imported and not used: %q", opkg.Path)
 	}
 }
 
 // newname returns a new ONAME Node associated with symbol s.
 func NewName(s *types.Sym) *ir.Node {
 	n := ir.NewNameAt(base.Pos, s)
-	n.Name.Curfn = Curfn
+	n.Name().Curfn = Curfn
 	return n
 }
 
@@ -152,7 +152,7 @@ func nodSym(op ir.Op, left *ir.Node, sym *types.Sym) *ir.Node {
 // and the Sym field set to sym. This is for ODOT and friends.
 func nodlSym(pos src.XPos, op ir.Op, left *ir.Node, sym *types.Sym) *ir.Node {
 	n := ir.NodAt(pos, op, left, nil)
-	n.Sym = sym
+	n.SetSym(sym)
 	return n
 }
 
@@ -169,7 +169,7 @@ func nodintconst(v int64) *ir.Node {
 
 func nodnil() *ir.Node {
 	n := ir.Nod(ir.ONIL, nil, nil)
-	n.Type = types.Types[types.TNIL]
+	n.SetType(types.Types[types.TNIL])
 	return n
 }
 
@@ -190,16 +190,16 @@ func treecopy(n *ir.Node, pos src.XPos) *ir.Node {
 		return nil
 	}
 
-	switch n.Op {
+	switch n.Op() {
 	default:
 		m := ir.SepCopy(n)
-		m.Left = treecopy(n.Left, pos)
-		m.Right = treecopy(n.Right, pos)
-		m.List.Set(listtreecopy(n.List.Slice(), pos))
+		m.SetLeft(treecopy(n.Left(), pos))
+		m.SetRight(treecopy(n.Right(), pos))
+		m.PtrList().Set(listtreecopy(n.List().Slice(), pos))
 		if pos.IsKnown() {
-			m.Pos = pos
+			m.SetPos(pos)
 		}
-		if m.Name != nil && n.Op != ir.ODCLFIELD {
+		if m.Name() != nil && n.Op() != ir.ODCLFIELD {
 			ir.Dump("treecopy", n)
 			base.Fatalf("treecopy Name")
 		}
@@ -517,16 +517,16 @@ func assignconv(n *ir.Node, t *types.Type, context string) *ir.Node {
 
 // Convert node n for assignment to type t.
 func assignconvfn(n *ir.Node, t *types.Type, context func() string) *ir.Node {
-	if n == nil || n.Type == nil || n.Type.Broke() {
+	if n == nil || n.Type() == nil || n.Type().Broke() {
 		return n
 	}
 
-	if t.Etype == types.TBLANK && n.Type.Etype == types.TNIL {
+	if t.Etype == types.TBLANK && n.Type().Etype == types.TNIL {
 		base.Errorf("use of untyped nil")
 	}
 
 	n = convlit1(n, t, false, context)
-	if n.Type == nil {
+	if n.Type() == nil {
 		return n
 	}
 	if t.Etype == types.TBLANK {
@@ -535,31 +535,31 @@ func assignconvfn(n *ir.Node, t *types.Type, context func() string) *ir.Node {
 
 	// Convert ideal bool from comparison to plain bool
 	// if the next step is non-bool (like interface{}).
-	if n.Type == types.UntypedBool && !t.IsBoolean() {
-		if n.Op == ir.ONAME || n.Op == ir.OLITERAL {
+	if n.Type() == types.UntypedBool && !t.IsBoolean() {
+		if n.Op() == ir.ONAME || n.Op() == ir.OLITERAL {
 			r := ir.Nod(ir.OCONVNOP, n, nil)
-			r.Type = types.Types[types.TBOOL]
+			r.SetType(types.Types[types.TBOOL])
 			r.SetTypecheck(1)
 			r.SetImplicit(true)
 			n = r
 		}
 	}
 
-	if types.Identical(n.Type, t) {
+	if types.Identical(n.Type(), t) {
 		return n
 	}
 
-	op, why := assignop(n.Type, t)
+	op, why := assignop(n.Type(), t)
 	if op == ir.OXXX {
 		base.Errorf("cannot use %L as type %v in %s%s", n, t, context(), why)
 		op = ir.OCONV
 	}
 
 	r := ir.Nod(op, n, nil)
-	r.Type = t
+	r.SetType(t)
 	r.SetTypecheck(1)
 	r.SetImplicit(true)
-	r.Orig = n.Orig
+	r.SetOrig(n.Orig())
 	return r
 }
 
@@ -572,27 +572,27 @@ func backingArrayPtrLen(n *ir.Node) (ptr, len *ir.Node) {
 		base.Fatalf("backingArrayPtrLen not cheap: %v", n)
 	}
 	ptr = ir.Nod(ir.OSPTR, n, nil)
-	if n.Type.IsString() {
-		ptr.Type = types.Types[types.TUINT8].PtrTo()
+	if n.Type().IsString() {
+		ptr.SetType(types.Types[types.TUINT8].PtrTo())
 	} else {
-		ptr.Type = n.Type.Elem().PtrTo()
+		ptr.SetType(n.Type().Elem().PtrTo())
 	}
 	len = ir.Nod(ir.OLEN, n, nil)
-	len.Type = types.Types[types.TINT]
+	len.SetType(types.Types[types.TINT])
 	return ptr, len
 }
 
 // labeledControl returns the control flow Node (for, switch, select)
 // associated with the label n, if any.
 func labeledControl(n *ir.Node) *ir.Node {
-	if n.Op != ir.OLABEL {
-		base.Fatalf("labeledControl %v", n.Op)
+	if n.Op() != ir.OLABEL {
+		base.Fatalf("labeledControl %v", n.Op())
 	}
-	ctl := n.Name.Defn
+	ctl := n.Name().Defn
 	if ctl == nil {
 		return nil
 	}
-	switch ctl.Op {
+	switch ctl.Op() {
 	case ir.OFOR, ir.OFORUNTIL, ir.OSWITCH, ir.OSELECT:
 		return ctl
 	}
@@ -626,12 +626,12 @@ func updateHasCall(n *ir.Node) {
 }
 
 func calcHasCall(n *ir.Node) bool {
-	if n.Ninit.Len() != 0 {
+	if n.Init().Len() != 0 {
 		// TODO(mdempsky): This seems overly conservative.
 		return true
 	}
 
-	switch n.Op {
+	switch n.Op() {
 	case ir.OLITERAL, ir.ONIL, ir.ONAME, ir.OTYPE:
 		if n.HasCall() {
 			base.Fatalf("OLITERAL/ONAME/OTYPE should never have calls: %+v", n)
@@ -653,23 +653,23 @@ func calcHasCall(n *ir.Node) bool {
 	// When using soft-float, these ops might be rewritten to function calls
 	// so we ensure they are evaluated first.
 	case ir.OADD, ir.OSUB, ir.ONEG, ir.OMUL:
-		if thearch.SoftFloat && (isFloat[n.Type.Etype] || isComplex[n.Type.Etype]) {
+		if thearch.SoftFloat && (isFloat[n.Type().Etype] || isComplex[n.Type().Etype]) {
 			return true
 		}
 	case ir.OLT, ir.OEQ, ir.ONE, ir.OLE, ir.OGE, ir.OGT:
-		if thearch.SoftFloat && (isFloat[n.Left.Type.Etype] || isComplex[n.Left.Type.Etype]) {
+		if thearch.SoftFloat && (isFloat[n.Left().Type().Etype] || isComplex[n.Left().Type().Etype]) {
 			return true
 		}
 	case ir.OCONV:
-		if thearch.SoftFloat && ((isFloat[n.Type.Etype] || isComplex[n.Type.Etype]) || (isFloat[n.Left.Type.Etype] || isComplex[n.Left.Type.Etype])) {
+		if thearch.SoftFloat && ((isFloat[n.Type().Etype] || isComplex[n.Type().Etype]) || (isFloat[n.Left().Type().Etype] || isComplex[n.Left().Type().Etype])) {
 			return true
 		}
 	}
 
-	if n.Left != nil && n.Left.HasCall() {
+	if n.Left() != nil && n.Left().HasCall() {
 		return true
 	}
-	if n.Right != nil && n.Right.HasCall() {
+	if n.Right() != nil && n.Right().HasCall() {
 		return true
 	}
 	return false
@@ -745,45 +745,45 @@ func safeexpr(n *ir.Node, init *ir.Nodes) *ir.Node {
 		return nil
 	}
 
-	if n.Ninit.Len() != 0 {
-		walkstmtlist(n.Ninit.Slice())
-		init.AppendNodes(&n.Ninit)
+	if n.Init().Len() != 0 {
+		walkstmtlist(n.Init().Slice())
+		init.AppendNodes(n.PtrInit())
 	}
 
-	switch n.Op {
+	switch n.Op() {
 	case ir.ONAME, ir.OLITERAL, ir.ONIL:
 		return n
 
 	case ir.ODOT, ir.OLEN, ir.OCAP:
-		l := safeexpr(n.Left, init)
-		if l == n.Left {
+		l := safeexpr(n.Left(), init)
+		if l == n.Left() {
 			return n
 		}
 		r := ir.Copy(n)
-		r.Left = l
+		r.SetLeft(l)
 		r = typecheck(r, ctxExpr)
 		r = walkexpr(r, init)
 		return r
 
 	case ir.ODOTPTR, ir.ODEREF:
-		l := safeexpr(n.Left, init)
-		if l == n.Left {
+		l := safeexpr(n.Left(), init)
+		if l == n.Left() {
 			return n
 		}
 		a := ir.Copy(n)
-		a.Left = l
+		a.SetLeft(l)
 		a = walkexpr(a, init)
 		return a
 
 	case ir.OINDEX, ir.OINDEXMAP:
-		l := safeexpr(n.Left, init)
-		r := safeexpr(n.Right, init)
-		if l == n.Left && r == n.Right {
+		l := safeexpr(n.Left(), init)
+		r := safeexpr(n.Right(), init)
+		if l == n.Left() && r == n.Right() {
 			return n
 		}
 		a := ir.Copy(n)
-		a.Left = l
-		a.Right = r
+		a.SetLeft(l)
+		a.SetRight(r)
 		a = walkexpr(a, init)
 		return a
 
@@ -812,12 +812,12 @@ func copyexpr(n *ir.Node, t *types.Type, init *ir.Nodes) *ir.Node {
 // return side-effect free and cheap n, appending side effects to init.
 // result may not be assignable.
 func cheapexpr(n *ir.Node, init *ir.Nodes) *ir.Node {
-	switch n.Op {
+	switch n.Op() {
 	case ir.ONAME, ir.OLITERAL, ir.ONIL:
 		return n
 	}
 
-	return copyexpr(n, n.Type, init)
+	return copyexpr(n, n.Type(), init)
 }
 
 // Code to resolve elided DOTs in embedded types.
@@ -958,20 +958,20 @@ func dotpath(s *types.Sym, t *types.Type, save **types.Field, ignorecase bool) (
 // will give shortest unique addressing.
 // modify the tree with missing type names.
 func adddot(n *ir.Node) *ir.Node {
-	n.Left = typecheck(n.Left, ctxType|ctxExpr)
-	if n.Left.Diag() {
+	n.SetLeft(typecheck(n.Left(), ctxType|ctxExpr))
+	if n.Left().Diag() {
 		n.SetDiag(true)
 	}
-	t := n.Left.Type
+	t := n.Left().Type()
 	if t == nil {
 		return n
 	}
 
-	if n.Left.Op == ir.OTYPE {
+	if n.Left().Op() == ir.OTYPE {
 		return n
 	}
 
-	s := n.Sym
+	s := n.Sym()
 	if s == nil {
 		return n
 	}
@@ -980,12 +980,12 @@ func adddot(n *ir.Node) *ir.Node {
 	case path != nil:
 		// rebuild elided dots
 		for c := len(path) - 1; c >= 0; c-- {
-			n.Left = nodSym(ir.ODOT, n.Left, path[c].field.Sym)
-			n.Left.SetImplicit(true)
+			n.SetLeft(nodSym(ir.ODOT, n.Left(), path[c].field.Sym))
+			n.Left().SetImplicit(true)
 		}
 	case ambig:
 		base.Errorf("ambiguous selector %v", n)
-		n.Left = nil
+		n.SetLeft(nil)
 	}
 
 	return n
@@ -1127,7 +1127,7 @@ func structargs(tl *types.Type, mustname bool) []*ir.Node {
 			gen++
 		}
 		a := symfield(s, t.Type)
-		a.Pos = t.Pos
+		a.SetPos(t.Pos)
 		a.SetIsDDD(t.IsDDD())
 		args = append(args, a)
 	}
@@ -1177,14 +1177,14 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	dclcontext = ir.PEXTERN
 
 	tfn := ir.Nod(ir.OTFUNC, nil, nil)
-	tfn.Left = namedfield(".this", rcvr)
-	tfn.List.Set(structargs(method.Type.Params(), true))
-	tfn.Rlist.Set(structargs(method.Type.Results(), false))
+	tfn.SetLeft(namedfield(".this", rcvr))
+	tfn.PtrList().Set(structargs(method.Type.Params(), true))
+	tfn.PtrRlist().Set(structargs(method.Type.Results(), false))
 
 	fn := dclfunc(newnam, tfn)
-	fn.Func.SetDupok(true)
+	fn.Func().SetDupok(true)
 
-	nthis := ir.AsNode(tfn.Type.Recv().Nname)
+	nthis := ir.AsNode(tfn.Type().Recv().Nname)
 
 	methodrcvr := method.Type.Recv().Type
 
@@ -1192,10 +1192,10 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	if rcvr.IsPtr() && rcvr.Elem() == methodrcvr {
 		// generating wrapper from *T to T.
 		n := ir.Nod(ir.OIF, nil, nil)
-		n.Left = ir.Nod(ir.OEQ, nthis, nodnil())
+		n.SetLeft(ir.Nod(ir.OEQ, nthis, nodnil()))
 		call := ir.Nod(ir.OCALL, syslook("panicwrap"), nil)
-		n.Nbody.Set1(call)
-		fn.Nbody.Append(n)
+		n.PtrBody().Set1(call)
+		fn.PtrBody().Append(n)
 	}
 
 	dot := adddot(nodSym(ir.OXDOT, nthis, method.Sym))
@@ -1209,29 +1209,29 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	// value for that function.
 	if !instrumenting && rcvr.IsPtr() && methodrcvr.IsPtr() && method.Embedded != 0 && !isifacemethod(method.Type) && !(thearch.LinkArch.Name == "ppc64le" && base.Ctxt.Flag_dynlink) {
 		// generate tail call: adjust pointer receiver and jump to embedded method.
-		dot = dot.Left // skip final .M
+		dot = dot.Left() // skip final .M
 		// TODO(mdempsky): Remove dependency on dotlist.
 		if !dotlist[0].field.Type.IsPtr() {
 			dot = ir.Nod(ir.OADDR, dot, nil)
 		}
 		as := ir.Nod(ir.OAS, nthis, convnop(dot, rcvr))
-		fn.Nbody.Append(as)
-		fn.Nbody.Append(nodSym(ir.ORETJMP, nil, methodSym(methodrcvr, method.Sym)))
+		fn.PtrBody().Append(as)
+		fn.PtrBody().Append(nodSym(ir.ORETJMP, nil, methodSym(methodrcvr, method.Sym)))
 	} else {
-		fn.Func.SetWrapper(true) // ignore frame for panic+recover matching
+		fn.Func().SetWrapper(true) // ignore frame for panic+recover matching
 		call := ir.Nod(ir.OCALL, dot, nil)
-		call.List.Set(paramNnames(tfn.Type))
-		call.SetIsDDD(tfn.Type.IsVariadic())
+		call.PtrList().Set(paramNnames(tfn.Type()))
+		call.SetIsDDD(tfn.Type().IsVariadic())
 		if method.Type.NumResults() > 0 {
 			n := ir.Nod(ir.ORETURN, nil, nil)
-			n.List.Set1(call)
+			n.PtrList().Set1(call)
 			call = n
 		}
-		fn.Nbody.Append(call)
+		fn.PtrBody().Append(call)
 	}
 
 	if false && base.Flag.LowerR != 0 {
-		ir.DumpList("genwrapper body", fn.Nbody)
+		ir.DumpList("genwrapper body", fn.Body())
 	}
 
 	funcbody()
@@ -1242,7 +1242,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	fn = typecheck(fn, ctxStmt)
 
 	Curfn = fn
-	typecheckslice(fn.Nbody.Slice(), ctxStmt)
+	typecheckslice(fn.Body().Slice(), ctxStmt)
 
 	// Inline calls within (*T).M wrappers. This is safe because we only
 	// generate those wrappers within the same compilation unit as (T).M.
@@ -1269,13 +1269,13 @@ func hashmem(t *types.Type) *ir.Node {
 
 	n := NewName(sym)
 	setNodeNameFunc(n)
-	n.Type = functype(nil, []*ir.Node{
+	n.SetType(functype(nil, []*ir.Node{
 		anonfield(types.NewPtr(t)),
 		anonfield(types.Types[types.TUINTPTR]),
 		anonfield(types.Types[types.TUINTPTR]),
 	}, []*ir.Node{
 		anonfield(types.Types[types.TUINTPTR]),
-	})
+	}))
 	return n
 }
 
@@ -1403,16 +1403,16 @@ func listtreecopy(l []*ir.Node, pos src.XPos) []*ir.Node {
 
 func liststmt(l []*ir.Node) *ir.Node {
 	n := ir.Nod(ir.OBLOCK, nil, nil)
-	n.List.Set(l)
+	n.PtrList().Set(l)
 	if len(l) != 0 {
-		n.Pos = l[0].Pos
+		n.SetPos(l[0].Pos())
 	}
 	return n
 }
 
 func ngotype(n *ir.Node) *types.Sym {
-	if n.Type != nil {
-		return typenamesym(n.Type)
+	if n.Type() != nil {
+		return typenamesym(n.Type())
 	}
 	return nil
 }
@@ -1426,11 +1426,11 @@ func addinit(n *ir.Node, init []*ir.Node) *ir.Node {
 	if ir.MayBeShared(n) {
 		// Introduce OCONVNOP to hold init list.
 		n = ir.Nod(ir.OCONVNOP, n, nil)
-		n.Type = n.Left.Type
+		n.SetType(n.Left().Type())
 		n.SetTypecheck(1)
 	}
 
-	n.Ninit.Prepend(init...)
+	n.PtrInit().Prepend(init...)
 	n.SetHasCall(true)
 	return n
 }
@@ -1520,10 +1520,10 @@ func isdirectiface(t *types.Type) bool {
 // itabType loads the _type field from a runtime.itab struct.
 func itabType(itab *ir.Node) *ir.Node {
 	typ := nodSym(ir.ODOTPTR, itab, nil)
-	typ.Type = types.NewPtr(types.Types[types.TUINT8])
+	typ.SetType(types.NewPtr(types.Types[types.TUINT8]))
 	typ.SetTypecheck(1)
-	typ.Xoffset = int64(Widthptr) // offset of _type in runtime.itab
-	typ.SetBounded(true)          // guaranteed not to fault
+	typ.SetOffset(int64(Widthptr)) // offset of _type in runtime.itab
+	typ.SetBounded(true)           // guaranteed not to fault
 	return typ
 }
 
@@ -1536,14 +1536,14 @@ func ifaceData(pos src.XPos, n *ir.Node, t *types.Type) *ir.Node {
 	}
 	ptr := nodlSym(pos, ir.OIDATA, n, nil)
 	if isdirectiface(t) {
-		ptr.Type = t
+		ptr.SetType(t)
 		ptr.SetTypecheck(1)
 		return ptr
 	}
-	ptr.Type = types.NewPtr(t)
+	ptr.SetType(types.NewPtr(t))
 	ptr.SetTypecheck(1)
 	ind := ir.NodAt(pos, ir.ODEREF, ptr, nil)
-	ind.Type = t
+	ind.SetType(t)
 	ind.SetTypecheck(1)
 	ind.SetBounded(true)
 	return ind
@@ -1553,8 +1553,8 @@ func ifaceData(pos src.XPos, n *ir.Node, t *types.Type) *ir.Node {
 // This is where t was declared or where it appeared as a type expression.
 func typePos(t *types.Type) src.XPos {
 	n := ir.AsNode(t.Nod)
-	if n == nil || !n.Pos.IsKnown() {
+	if n == nil || !n.Pos().IsKnown() {
 		base.Fatalf("bad type: %v", t)
 	}
-	return n.Pos
+	return n.Pos()
 }
diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index f3195df79a..c85483fafa 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -16,8 +16,8 @@ import (
 
 // typecheckswitch typechecks a switch statement.
 func typecheckswitch(n *ir.Node) {
-	typecheckslice(n.Ninit.Slice(), ctxStmt)
-	if n.Left != nil && n.Left.Op == ir.OTYPESW {
+	typecheckslice(n.Init().Slice(), ctxStmt)
+	if n.Left() != nil && n.Left().Op() == ir.OTYPESW {
 		typecheckTypeSwitch(n)
 	} else {
 		typecheckExprSwitch(n)
@@ -25,27 +25,27 @@ func typecheckswitch(n *ir.Node) {
 }
 
 func typecheckTypeSwitch(n *ir.Node) {
-	n.Left.Right = typecheck(n.Left.Right, ctxExpr)
-	t := n.Left.Right.Type
+	n.Left().SetRight(typecheck(n.Left().Right(), ctxExpr))
+	t := n.Left().Right().Type()
 	if t != nil && !t.IsInterface() {
-		base.ErrorfAt(n.Pos, "cannot type switch on non-interface value %L", n.Left.Right)
+		base.ErrorfAt(n.Pos(), "cannot type switch on non-interface value %L", n.Left().Right())
 		t = nil
 	}
 
 	// We don't actually declare the type switch's guarded
 	// declaration itself. So if there are no cases, we won't
 	// notice that it went unused.
-	if v := n.Left.Left; v != nil && !ir.IsBlank(v) && n.List.Len() == 0 {
-		base.ErrorfAt(v.Pos, "%v declared but not used", v.Sym)
+	if v := n.Left().Left(); v != nil && !ir.IsBlank(v) && n.List().Len() == 0 {
+		base.ErrorfAt(v.Pos(), "%v declared but not used", v.Sym())
 	}
 
 	var defCase, nilCase *ir.Node
 	var ts typeSet
-	for _, ncase := range n.List.Slice() {
-		ls := ncase.List.Slice()
+	for _, ncase := range n.List().Slice() {
+		ls := ncase.List().Slice()
 		if len(ls) == 0 { // default:
 			if defCase != nil {
-				base.ErrorfAt(ncase.Pos, "multiple defaults in switch (first at %v)", ir.Line(defCase))
+				base.ErrorfAt(ncase.Pos(), "multiple defaults in switch (first at %v)", ir.Line(defCase))
 			} else {
 				defCase = ncase
 			}
@@ -54,7 +54,7 @@ func typecheckTypeSwitch(n *ir.Node) {
 		for i := range ls {
 			ls[i] = typecheck(ls[i], ctxExpr|ctxType)
 			n1 := ls[i]
-			if t == nil || n1.Type == nil {
+			if t == nil || n1.Type() == nil {
 				continue
 			}
 
@@ -63,36 +63,36 @@ func typecheckTypeSwitch(n *ir.Node) {
 			switch {
 			case ir.IsNil(n1): // case nil:
 				if nilCase != nil {
-					base.ErrorfAt(ncase.Pos, "multiple nil cases in type switch (first at %v)", ir.Line(nilCase))
+					base.ErrorfAt(ncase.Pos(), "multiple nil cases in type switch (first at %v)", ir.Line(nilCase))
 				} else {
 					nilCase = ncase
 				}
-			case n1.Op != ir.OTYPE:
-				base.ErrorfAt(ncase.Pos, "%L is not a type", n1)
-			case !n1.Type.IsInterface() && !implements(n1.Type, t, &missing, &have, &ptr) && !missing.Broke():
+			case n1.Op() != ir.OTYPE:
+				base.ErrorfAt(ncase.Pos(), "%L is not a type", n1)
+			case !n1.Type().IsInterface() && !implements(n1.Type(), t, &missing, &have, &ptr) && !missing.Broke():
 				if have != nil && !have.Broke() {
-					base.ErrorfAt(ncase.Pos, "impossible type switch case: %L cannot have dynamic type %v"+
-						" (wrong type for %v method)\n\thave %v%S\n\twant %v%S", n.Left.Right, n1.Type, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
+					base.ErrorfAt(ncase.Pos(), "impossible type switch case: %L cannot have dynamic type %v"+
+						" (wrong type for %v method)\n\thave %v%S\n\twant %v%S", n.Left().Right(), n1.Type(), missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
 				} else if ptr != 0 {
-					base.ErrorfAt(ncase.Pos, "impossible type switch case: %L cannot have dynamic type %v"+
-						" (%v method has pointer receiver)", n.Left.Right, n1.Type, missing.Sym)
+					base.ErrorfAt(ncase.Pos(), "impossible type switch case: %L cannot have dynamic type %v"+
+						" (%v method has pointer receiver)", n.Left().Right(), n1.Type(), missing.Sym)
 				} else {
-					base.ErrorfAt(ncase.Pos, "impossible type switch case: %L cannot have dynamic type %v"+
-						" (missing %v method)", n.Left.Right, n1.Type, missing.Sym)
+					base.ErrorfAt(ncase.Pos(), "impossible type switch case: %L cannot have dynamic type %v"+
+						" (missing %v method)", n.Left().Right(), n1.Type(), missing.Sym)
 				}
 			}
 
-			if n1.Op == ir.OTYPE {
-				ts.add(ncase.Pos, n1.Type)
+			if n1.Op() == ir.OTYPE {
+				ts.add(ncase.Pos(), n1.Type())
 			}
 		}
 
-		if ncase.Rlist.Len() != 0 {
+		if ncase.Rlist().Len() != 0 {
 			// Assign the clause variable's type.
 			vt := t
 			if len(ls) == 1 {
-				if ls[0].Op == ir.OTYPE {
-					vt = ls[0].Type
+				if ls[0].Op() == ir.OTYPE {
+					vt = ls[0].Type()
 				} else if !ir.IsNil(ls[0]) {
 					// Invalid single-type case;
 					// mark variable as broken.
@@ -100,8 +100,8 @@ func typecheckTypeSwitch(n *ir.Node) {
 				}
 			}
 
-			nvar := ncase.Rlist.First()
-			nvar.Type = vt
+			nvar := ncase.Rlist().First()
+			nvar.SetType(vt)
 			if vt != nil {
 				nvar = typecheck(nvar, ctxExpr|ctxAssign)
 			} else {
@@ -109,10 +109,10 @@ func typecheckTypeSwitch(n *ir.Node) {
 				nvar.SetTypecheck(1)
 				nvar.SetWalkdef(1)
 			}
-			ncase.Rlist.SetFirst(nvar)
+			ncase.Rlist().SetFirst(nvar)
 		}
 
-		typecheckslice(ncase.Nbody.Slice(), ctxStmt)
+		typecheckslice(ncase.Body().Slice(), ctxStmt)
 	}
 }
 
@@ -146,10 +146,10 @@ func (s *typeSet) add(pos src.XPos, typ *types.Type) {
 
 func typecheckExprSwitch(n *ir.Node) {
 	t := types.Types[types.TBOOL]
-	if n.Left != nil {
-		n.Left = typecheck(n.Left, ctxExpr)
-		n.Left = defaultlit(n.Left, nil)
-		t = n.Left.Type
+	if n.Left() != nil {
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		n.SetLeft(defaultlit(n.Left(), nil))
+		t = n.Left().Type()
 	}
 
 	var nilonly string
@@ -164,9 +164,9 @@ func typecheckExprSwitch(n *ir.Node) {
 
 		case !IsComparable(t):
 			if t.IsStruct() {
-				base.ErrorfAt(n.Pos, "cannot switch on %L (struct containing %v cannot be compared)", n.Left, IncomparableField(t).Type)
+				base.ErrorfAt(n.Pos(), "cannot switch on %L (struct containing %v cannot be compared)", n.Left(), IncomparableField(t).Type)
 			} else {
-				base.ErrorfAt(n.Pos, "cannot switch on %L", n.Left)
+				base.ErrorfAt(n.Pos(), "cannot switch on %L", n.Left())
 			}
 			t = nil
 		}
@@ -174,11 +174,11 @@ func typecheckExprSwitch(n *ir.Node) {
 
 	var defCase *ir.Node
 	var cs constSet
-	for _, ncase := range n.List.Slice() {
-		ls := ncase.List.Slice()
+	for _, ncase := range n.List().Slice() {
+		ls := ncase.List().Slice()
 		if len(ls) == 0 { // default:
 			if defCase != nil {
-				base.ErrorfAt(ncase.Pos, "multiple defaults in switch (first at %v)", ir.Line(defCase))
+				base.ErrorfAt(ncase.Pos(), "multiple defaults in switch (first at %v)", ir.Line(defCase))
 			} else {
 				defCase = ncase
 			}
@@ -189,22 +189,22 @@ func typecheckExprSwitch(n *ir.Node) {
 			ls[i] = typecheck(ls[i], ctxExpr)
 			ls[i] = defaultlit(ls[i], t)
 			n1 := ls[i]
-			if t == nil || n1.Type == nil {
+			if t == nil || n1.Type() == nil {
 				continue
 			}
 
 			if nilonly != "" && !ir.IsNil(n1) {
-				base.ErrorfAt(ncase.Pos, "invalid case %v in switch (can only compare %s %v to nil)", n1, nilonly, n.Left)
-			} else if t.IsInterface() && !n1.Type.IsInterface() && !IsComparable(n1.Type) {
-				base.ErrorfAt(ncase.Pos, "invalid case %L in switch (incomparable type)", n1)
+				base.ErrorfAt(ncase.Pos(), "invalid case %v in switch (can only compare %s %v to nil)", n1, nilonly, n.Left())
+			} else if t.IsInterface() && !n1.Type().IsInterface() && !IsComparable(n1.Type()) {
+				base.ErrorfAt(ncase.Pos(), "invalid case %L in switch (incomparable type)", n1)
 			} else {
-				op1, _ := assignop(n1.Type, t)
-				op2, _ := assignop(t, n1.Type)
+				op1, _ := assignop(n1.Type(), t)
+				op2, _ := assignop(t, n1.Type())
 				if op1 == ir.OXXX && op2 == ir.OXXX {
-					if n.Left != nil {
-						base.ErrorfAt(ncase.Pos, "invalid case %v in switch on %v (mismatched types %v and %v)", n1, n.Left, n1.Type, t)
+					if n.Left() != nil {
+						base.ErrorfAt(ncase.Pos(), "invalid case %v in switch on %v (mismatched types %v and %v)", n1, n.Left(), n1.Type(), t)
 					} else {
-						base.ErrorfAt(ncase.Pos, "invalid case %v in switch (mismatched types %v and bool)", n1, n1.Type)
+						base.ErrorfAt(ncase.Pos(), "invalid case %v in switch (mismatched types %v and bool)", n1, n1.Type())
 					}
 				}
 			}
@@ -215,23 +215,23 @@ func typecheckExprSwitch(n *ir.Node) {
 			//       case GOARCH == "arm" && GOARM == "5":
 			//       case GOARCH == "arm":
 			//     which would both evaluate to false for non-ARM compiles.
-			if !n1.Type.IsBoolean() {
-				cs.add(ncase.Pos, n1, "case", "switch")
+			if !n1.Type().IsBoolean() {
+				cs.add(ncase.Pos(), n1, "case", "switch")
 			}
 		}
 
-		typecheckslice(ncase.Nbody.Slice(), ctxStmt)
+		typecheckslice(ncase.Body().Slice(), ctxStmt)
 	}
 }
 
 // walkswitch walks a switch statement.
 func walkswitch(sw *ir.Node) {
 	// Guard against double walk, see #25776.
-	if sw.List.Len() == 0 && sw.Nbody.Len() > 0 {
+	if sw.List().Len() == 0 && sw.Body().Len() > 0 {
 		return // Was fatal, but eliminating every possible source of double-walking is hard
 	}
 
-	if sw.Left != nil && sw.Left.Op == ir.OTYPESW {
+	if sw.Left() != nil && sw.Left().Op() == ir.OTYPESW {
 		walkTypeSwitch(sw)
 	} else {
 		walkExprSwitch(sw)
@@ -243,8 +243,8 @@ func walkswitch(sw *ir.Node) {
 func walkExprSwitch(sw *ir.Node) {
 	lno := setlineno(sw)
 
-	cond := sw.Left
-	sw.Left = nil
+	cond := sw.Left()
+	sw.SetLeft(nil)
 
 	// convert switch {...} to switch true {...}
 	if cond == nil {
@@ -260,13 +260,13 @@ func walkExprSwitch(sw *ir.Node) {
 	// because walkexpr will lower the string
 	// conversion into a runtime call.
 	// See issue 24937 for more discussion.
-	if cond.Op == ir.OBYTES2STR && allCaseExprsAreSideEffectFree(sw) {
-		cond.Op = ir.OBYTES2STRTMP
+	if cond.Op() == ir.OBYTES2STR && allCaseExprsAreSideEffectFree(sw) {
+		cond.SetOp(ir.OBYTES2STRTMP)
 	}
 
-	cond = walkexpr(cond, &sw.Ninit)
-	if cond.Op != ir.OLITERAL && cond.Op != ir.ONIL {
-		cond = copyexpr(cond, cond.Type, &sw.Nbody)
+	cond = walkexpr(cond, sw.PtrInit())
+	if cond.Op() != ir.OLITERAL && cond.Op() != ir.ONIL {
+		cond = copyexpr(cond, cond.Type(), sw.PtrBody())
 	}
 
 	base.Pos = lno
@@ -277,43 +277,43 @@ func walkExprSwitch(sw *ir.Node) {
 
 	var defaultGoto *ir.Node
 	var body ir.Nodes
-	for _, ncase := range sw.List.Slice() {
+	for _, ncase := range sw.List().Slice() {
 		label := autolabel(".s")
-		jmp := npos(ncase.Pos, nodSym(ir.OGOTO, nil, label))
+		jmp := npos(ncase.Pos(), nodSym(ir.OGOTO, nil, label))
 
 		// Process case dispatch.
-		if ncase.List.Len() == 0 {
+		if ncase.List().Len() == 0 {
 			if defaultGoto != nil {
 				base.Fatalf("duplicate default case not detected during typechecking")
 			}
 			defaultGoto = jmp
 		}
 
-		for _, n1 := range ncase.List.Slice() {
-			s.Add(ncase.Pos, n1, jmp)
+		for _, n1 := range ncase.List().Slice() {
+			s.Add(ncase.Pos(), n1, jmp)
 		}
 
 		// Process body.
-		body.Append(npos(ncase.Pos, nodSym(ir.OLABEL, nil, label)))
-		body.Append(ncase.Nbody.Slice()...)
-		if fall, pos := hasFall(ncase.Nbody.Slice()); !fall {
+		body.Append(npos(ncase.Pos(), nodSym(ir.OLABEL, nil, label)))
+		body.Append(ncase.Body().Slice()...)
+		if fall, pos := hasFall(ncase.Body().Slice()); !fall {
 			br := ir.Nod(ir.OBREAK, nil, nil)
-			br.Pos = pos
+			br.SetPos(pos)
 			body.Append(br)
 		}
 	}
-	sw.List.Set(nil)
+	sw.PtrList().Set(nil)
 
 	if defaultGoto == nil {
 		br := ir.Nod(ir.OBREAK, nil, nil)
-		br.Pos = br.Pos.WithNotStmt()
+		br.SetPos(br.Pos().WithNotStmt())
 		defaultGoto = br
 	}
 
-	s.Emit(&sw.Nbody)
-	sw.Nbody.Append(defaultGoto)
-	sw.Nbody.AppendNodes(&body)
-	walkstmtlist(sw.Nbody.Slice())
+	s.Emit(sw.PtrBody())
+	sw.PtrBody().Append(defaultGoto)
+	sw.PtrBody().AppendNodes(&body)
+	walkstmtlist(sw.Body().Slice())
 }
 
 // An exprSwitch walks an expression switch.
@@ -332,7 +332,7 @@ type exprClause struct {
 
 func (s *exprSwitch) Add(pos src.XPos, expr, jmp *ir.Node) {
 	c := exprClause{pos: pos, lo: expr, hi: expr, jmp: jmp}
-	if okforcmp[s.exprname.Type.Etype] && expr.Op == ir.OLITERAL {
+	if okforcmp[s.exprname.Type().Etype] && expr.Op() == ir.OLITERAL {
 		s.clauses = append(s.clauses, c)
 		return
 	}
@@ -359,7 +359,7 @@ func (s *exprSwitch) flush() {
 	// (e.g., sort.Slice doesn't need to invoke the less function
 	// when there's only a single slice element).
 
-	if s.exprname.Type.IsString() && len(cc) >= 2 {
+	if s.exprname.Type().IsString() && len(cc) >= 2 {
 		// Sort strings by length and then by value. It is
 		// much cheaper to compare lengths than values, and
 		// all we need here is consistency. We respect this
@@ -395,8 +395,8 @@ func (s *exprSwitch) flush() {
 			},
 			func(i int, nif *ir.Node) {
 				run := runs[i]
-				nif.Left = ir.Nod(ir.OEQ, ir.Nod(ir.OLEN, s.exprname, nil), nodintconst(runLen(run)))
-				s.search(run, &nif.Nbody)
+				nif.SetLeft(ir.Nod(ir.OEQ, ir.Nod(ir.OLEN, s.exprname, nil), nodintconst(runLen(run))))
+				s.search(run, nif.PtrBody())
 			},
 		)
 		return
@@ -407,7 +407,7 @@ func (s *exprSwitch) flush() {
 	})
 
 	// Merge consecutive integer cases.
-	if s.exprname.Type.IsInteger() {
+	if s.exprname.Type().IsInteger() {
 		merged := cc[:1]
 		for _, c := range cc[1:] {
 			last := &merged[len(merged)-1]
@@ -430,8 +430,8 @@ func (s *exprSwitch) search(cc []exprClause, out *ir.Nodes) {
 		},
 		func(i int, nif *ir.Node) {
 			c := &cc[i]
-			nif.Left = c.test(s.exprname)
-			nif.Nbody.Set1(c.jmp)
+			nif.SetLeft(c.test(s.exprname))
+			nif.PtrBody().Set1(c.jmp)
 		},
 	)
 }
@@ -445,7 +445,7 @@ func (c *exprClause) test(exprname *ir.Node) *ir.Node {
 	}
 
 	// Optimize "switch true { ...}" and "switch false { ... }".
-	if ir.IsConst(exprname, constant.Bool) && !c.lo.Type.IsInterface() {
+	if ir.IsConst(exprname, constant.Bool) && !c.lo.Type().IsInterface() {
 		if exprname.BoolVal() {
 			return c.lo
 		} else {
@@ -464,12 +464,12 @@ func allCaseExprsAreSideEffectFree(sw *ir.Node) bool {
 	// Restricting to constants is simple and probably powerful
 	// enough.
 
-	for _, ncase := range sw.List.Slice() {
-		if ncase.Op != ir.OCASE {
-			base.Fatalf("switch string(byteslice) bad op: %v", ncase.Op)
+	for _, ncase := range sw.List().Slice() {
+		if ncase.Op() != ir.OCASE {
+			base.Fatalf("switch string(byteslice) bad op: %v", ncase.Op())
 		}
-		for _, v := range ncase.List.Slice() {
-			if v.Op != ir.OLITERAL {
+		for _, v := range ncase.List().Slice() {
+			if v.Op() != ir.OLITERAL {
 				return false
 			}
 		}
@@ -486,24 +486,24 @@ func hasFall(stmts []*ir.Node) (bool, src.XPos) {
 	// nodes will be at the end of the list.
 
 	i := len(stmts) - 1
-	for i >= 0 && stmts[i].Op == ir.OVARKILL {
+	for i >= 0 && stmts[i].Op() == ir.OVARKILL {
 		i--
 	}
 	if i < 0 {
 		return false, src.NoXPos
 	}
-	return stmts[i].Op == ir.OFALL, stmts[i].Pos
+	return stmts[i].Op() == ir.OFALL, stmts[i].Pos()
 }
 
 // walkTypeSwitch generates an AST that implements sw, where sw is a
 // type switch.
 func walkTypeSwitch(sw *ir.Node) {
 	var s typeSwitch
-	s.facename = sw.Left.Right
-	sw.Left = nil
+	s.facename = sw.Left().Right()
+	sw.SetLeft(nil)
 
-	s.facename = walkexpr(s.facename, &sw.Ninit)
-	s.facename = copyexpr(s.facename, s.facename.Type, &sw.Nbody)
+	s.facename = walkexpr(s.facename, sw.PtrInit())
+	s.facename = copyexpr(s.facename, s.facename.Type(), sw.PtrBody())
 	s.okname = temp(types.Types[types.TBOOL])
 
 	// Get interface descriptor word.
@@ -518,54 +518,54 @@ func walkTypeSwitch(sw *ir.Node) {
 	//     h := e._type.hash
 	// Use a similar strategy for non-empty interfaces.
 	ifNil := ir.Nod(ir.OIF, nil, nil)
-	ifNil.Left = ir.Nod(ir.OEQ, itab, nodnil())
+	ifNil.SetLeft(ir.Nod(ir.OEQ, itab, nodnil()))
 	base.Pos = base.Pos.WithNotStmt() // disable statement marks after the first check.
-	ifNil.Left = typecheck(ifNil.Left, ctxExpr)
-	ifNil.Left = defaultlit(ifNil.Left, nil)
+	ifNil.SetLeft(typecheck(ifNil.Left(), ctxExpr))
+	ifNil.SetLeft(defaultlit(ifNil.Left(), nil))
 	// ifNil.Nbody assigned at end.
-	sw.Nbody.Append(ifNil)
+	sw.PtrBody().Append(ifNil)
 
 	// Load hash from type or itab.
 	dotHash := nodSym(ir.ODOTPTR, itab, nil)
-	dotHash.Type = types.Types[types.TUINT32]
+	dotHash.SetType(types.Types[types.TUINT32])
 	dotHash.SetTypecheck(1)
-	if s.facename.Type.IsEmptyInterface() {
-		dotHash.Xoffset = int64(2 * Widthptr) // offset of hash in runtime._type
+	if s.facename.Type().IsEmptyInterface() {
+		dotHash.SetOffset(int64(2 * Widthptr)) // offset of hash in runtime._type
 	} else {
-		dotHash.Xoffset = int64(2 * Widthptr) // offset of hash in runtime.itab
+		dotHash.SetOffset(int64(2 * Widthptr)) // offset of hash in runtime.itab
 	}
 	dotHash.SetBounded(true) // guaranteed not to fault
-	s.hashname = copyexpr(dotHash, dotHash.Type, &sw.Nbody)
+	s.hashname = copyexpr(dotHash, dotHash.Type(), sw.PtrBody())
 
 	br := ir.Nod(ir.OBREAK, nil, nil)
 	var defaultGoto, nilGoto *ir.Node
 	var body ir.Nodes
-	for _, ncase := range sw.List.Slice() {
+	for _, ncase := range sw.List().Slice() {
 		var caseVar *ir.Node
-		if ncase.Rlist.Len() != 0 {
-			caseVar = ncase.Rlist.First()
+		if ncase.Rlist().Len() != 0 {
+			caseVar = ncase.Rlist().First()
 		}
 
 		// For single-type cases with an interface type,
 		// we initialize the case variable as part of the type assertion.
 		// In other cases, we initialize it in the body.
 		var singleType *types.Type
-		if ncase.List.Len() == 1 && ncase.List.First().Op == ir.OTYPE {
-			singleType = ncase.List.First().Type
+		if ncase.List().Len() == 1 && ncase.List().First().Op() == ir.OTYPE {
+			singleType = ncase.List().First().Type()
 		}
 		caseVarInitialized := false
 
 		label := autolabel(".s")
-		jmp := npos(ncase.Pos, nodSym(ir.OGOTO, nil, label))
+		jmp := npos(ncase.Pos(), nodSym(ir.OGOTO, nil, label))
 
-		if ncase.List.Len() == 0 { // default:
+		if ncase.List().Len() == 0 { // default:
 			if defaultGoto != nil {
 				base.Fatalf("duplicate default case not detected during typechecking")
 			}
 			defaultGoto = jmp
 		}
 
-		for _, n1 := range ncase.List.Slice() {
+		for _, n1 := range ncase.List().Slice() {
 			if ir.IsNil(n1) { // case nil:
 				if nilGoto != nil {
 					base.Fatalf("duplicate nil case not detected during typechecking")
@@ -575,14 +575,14 @@ func walkTypeSwitch(sw *ir.Node) {
 			}
 
 			if singleType != nil && singleType.IsInterface() {
-				s.Add(ncase.Pos, n1.Type, caseVar, jmp)
+				s.Add(ncase.Pos(), n1.Type(), caseVar, jmp)
 				caseVarInitialized = true
 			} else {
-				s.Add(ncase.Pos, n1.Type, nil, jmp)
+				s.Add(ncase.Pos(), n1.Type(), nil, jmp)
 			}
 		}
 
-		body.Append(npos(ncase.Pos, nodSym(ir.OLABEL, nil, label)))
+		body.Append(npos(ncase.Pos(), nodSym(ir.OLABEL, nil, label)))
 		if caseVar != nil && !caseVarInitialized {
 			val := s.facename
 			if singleType != nil {
@@ -590,19 +590,19 @@ func walkTypeSwitch(sw *ir.Node) {
 				if singleType.IsInterface() {
 					base.Fatalf("singleType interface should have been handled in Add")
 				}
-				val = ifaceData(ncase.Pos, s.facename, singleType)
+				val = ifaceData(ncase.Pos(), s.facename, singleType)
 			}
 			l := []*ir.Node{
-				ir.NodAt(ncase.Pos, ir.ODCL, caseVar, nil),
-				ir.NodAt(ncase.Pos, ir.OAS, caseVar, val),
+				ir.NodAt(ncase.Pos(), ir.ODCL, caseVar, nil),
+				ir.NodAt(ncase.Pos(), ir.OAS, caseVar, val),
 			}
 			typecheckslice(l, ctxStmt)
 			body.Append(l...)
 		}
-		body.Append(ncase.Nbody.Slice()...)
+		body.Append(ncase.Body().Slice()...)
 		body.Append(br)
 	}
-	sw.List.Set(nil)
+	sw.PtrList().Set(nil)
 
 	if defaultGoto == nil {
 		defaultGoto = br
@@ -610,13 +610,13 @@ func walkTypeSwitch(sw *ir.Node) {
 	if nilGoto == nil {
 		nilGoto = defaultGoto
 	}
-	ifNil.Nbody.Set1(nilGoto)
+	ifNil.PtrBody().Set1(nilGoto)
 
-	s.Emit(&sw.Nbody)
-	sw.Nbody.Append(defaultGoto)
-	sw.Nbody.AppendNodes(&body)
+	s.Emit(sw.PtrBody())
+	sw.PtrBody().Append(defaultGoto)
+	sw.PtrBody().AppendNodes(&body)
 
-	walkstmtlist(sw.Nbody.Slice())
+	walkstmtlist(sw.Body().Slice())
 }
 
 // A typeSwitch walks a type switch.
@@ -650,18 +650,18 @@ func (s *typeSwitch) Add(pos src.XPos, typ *types.Type, caseVar, jmp *ir.Node) {
 
 	// cv, ok = iface.(type)
 	as := ir.NodAt(pos, ir.OAS2, nil, nil)
-	as.List.Set2(caseVar, s.okname) // cv, ok =
+	as.PtrList().Set2(caseVar, s.okname) // cv, ok =
 	dot := ir.NodAt(pos, ir.ODOTTYPE, s.facename, nil)
-	dot.Type = typ // iface.(type)
-	as.Rlist.Set1(dot)
+	dot.SetType(typ) // iface.(type)
+	as.PtrRlist().Set1(dot)
 	as = typecheck(as, ctxStmt)
 	as = walkexpr(as, &body)
 	body.Append(as)
 
 	// if ok { goto label }
 	nif := ir.NodAt(pos, ir.OIF, nil, nil)
-	nif.Left = s.okname
-	nif.Nbody.Set1(jmp)
+	nif.SetLeft(s.okname)
+	nif.PtrBody().Set1(jmp)
 	body.Append(nif)
 
 	if !typ.IsInterface() {
@@ -710,8 +710,8 @@ func (s *typeSwitch) flush() {
 			// TODO(mdempsky): Omit hash equality check if
 			// there's only one type.
 			c := cc[i]
-			nif.Left = ir.Nod(ir.OEQ, s.hashname, nodintconst(int64(c.hash)))
-			nif.Nbody.AppendNodes(&c.body)
+			nif.SetLeft(ir.Nod(ir.OEQ, s.hashname, nodintconst(int64(c.hash))))
+			nif.PtrBody().AppendNodes(&c.body)
 		},
 	)
 }
@@ -736,22 +736,22 @@ func binarySearch(n int, out *ir.Nodes, less func(i int) *ir.Node, leaf func(i i
 				nif := ir.Nod(ir.OIF, nil, nil)
 				leaf(i, nif)
 				base.Pos = base.Pos.WithNotStmt()
-				nif.Left = typecheck(nif.Left, ctxExpr)
-				nif.Left = defaultlit(nif.Left, nil)
+				nif.SetLeft(typecheck(nif.Left(), ctxExpr))
+				nif.SetLeft(defaultlit(nif.Left(), nil))
 				out.Append(nif)
-				out = &nif.Rlist
+				out = nif.PtrRlist()
 			}
 			return
 		}
 
 		half := lo + n/2
 		nif := ir.Nod(ir.OIF, nil, nil)
-		nif.Left = less(half)
+		nif.SetLeft(less(half))
 		base.Pos = base.Pos.WithNotStmt()
-		nif.Left = typecheck(nif.Left, ctxExpr)
-		nif.Left = defaultlit(nif.Left, nil)
-		do(lo, half, &nif.Nbody)
-		do(half, hi, &nif.Rlist)
+		nif.SetLeft(typecheck(nif.Left(), ctxExpr))
+		nif.SetLeft(defaultlit(nif.Left(), nil))
+		do(lo, half, nif.PtrBody())
+		do(half, hi, nif.PtrRlist())
 		out.Append(nif)
 	}
 
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 318f315f16..4bc7f035f5 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -27,8 +27,8 @@ func tracePrint(title string, n *ir.Node) func(np **ir.Node) {
 	var pos, op string
 	var tc uint8
 	if n != nil {
-		pos = base.FmtPos(n.Pos)
-		op = n.Op.String()
+		pos = base.FmtPos(n.Pos())
+		op = n.Op().String()
 		tc = n.Typecheck()
 	}
 
@@ -50,10 +50,10 @@ func tracePrint(title string, n *ir.Node) func(np **ir.Node) {
 		var tc uint8
 		var typ *types.Type
 		if n != nil {
-			pos = base.FmtPos(n.Pos)
-			op = n.Op.String()
+			pos = base.FmtPos(n.Pos())
+			op = n.Op().String()
 			tc = n.Typecheck()
-			typ = n.Type
+			typ = n.Type()
 		}
 
 		skipDowidthForTracing = true
@@ -81,7 +81,7 @@ var typecheckdefstack []*ir.Node
 
 // resolve ONONAME to definition, if any.
 func resolve(n *ir.Node) (res *ir.Node) {
-	if n == nil || n.Op != ir.ONONAME {
+	if n == nil || n.Op() != ir.ONONAME {
 		return n
 	}
 
@@ -90,7 +90,7 @@ func resolve(n *ir.Node) (res *ir.Node) {
 		defer tracePrint("resolve", n)(&res)
 	}
 
-	if n.Sym.Pkg != ir.LocalPkg {
+	if n.Sym().Pkg != ir.LocalPkg {
 		if inimport {
 			base.Fatalf("recursive inimport")
 		}
@@ -100,12 +100,12 @@ func resolve(n *ir.Node) (res *ir.Node) {
 		return n
 	}
 
-	r := ir.AsNode(n.Sym.Def)
+	r := ir.AsNode(n.Sym().Def)
 	if r == nil {
 		return n
 	}
 
-	if r.Op == ir.OIOTA {
+	if r.Op() == ir.OIOTA {
 		if x := getIotaValue(); x >= 0 {
 			return nodintconst(x)
 		}
@@ -181,7 +181,7 @@ func cycleFor(start *ir.Node) []*ir.Node {
 	// collect all nodes with same Op
 	var cycle []*ir.Node
 	for _, n := range typecheck_tcstack[i:] {
-		if n.Op == start.Op {
+		if n.Op() == start.Op() {
 			cycle = append(cycle, n)
 		}
 	}
@@ -220,8 +220,8 @@ func typecheck(n *ir.Node, top int) (res *ir.Node) {
 	lno := setlineno(n)
 
 	// Skip over parens.
-	for n.Op == ir.OPAREN {
-		n = n.Left
+	for n.Op() == ir.OPAREN {
+		n = n.Left()
 	}
 
 	// Resolve definition of name and value of iota lazily.
@@ -230,7 +230,7 @@ func typecheck(n *ir.Node, top int) (res *ir.Node) {
 	// Skip typecheck if already done.
 	// But re-typecheck ONAME/OTYPE/OLITERAL/OPACK node in case context has changed.
 	if n.Typecheck() == 1 {
-		switch n.Op {
+		switch n.Op() {
 		case ir.ONAME, ir.OTYPE, ir.OLITERAL, ir.OPACK:
 			break
 
@@ -243,7 +243,7 @@ func typecheck(n *ir.Node, top int) (res *ir.Node) {
 	if n.Typecheck() == 2 {
 		// Typechecking loop. Trying printing a meaningful message,
 		// otherwise a stack trace of typechecking.
-		switch n.Op {
+		switch n.Op() {
 		// We can already diagnose variables used as types.
 		case ir.ONAME:
 			if top&(ctxExpr|ctxType) == ctxType {
@@ -259,20 +259,20 @@ func typecheck(n *ir.Node, top int) (res *ir.Node) {
 				// are substituted.
 				cycle := cycleFor(n)
 				for _, n1 := range cycle {
-					if n1.Name != nil && !n1.Name.Param.Alias() {
+					if n1.Name() != nil && !n1.Name().Param.Alias() {
 						// Cycle is ok. But if n is an alias type and doesn't
 						// have a type yet, we have a recursive type declaration
 						// with aliases that we can't handle properly yet.
 						// Report an error rather than crashing later.
-						if n.Name != nil && n.Name.Param.Alias() && n.Type == nil {
-							base.Pos = n.Pos
+						if n.Name() != nil && n.Name().Param.Alias() && n.Type() == nil {
+							base.Pos = n.Pos()
 							base.Fatalf("cannot handle alias type declaration (issue #25838): %v", n)
 						}
 						base.Pos = lno
 						return n
 					}
 				}
-				base.ErrorfAt(n.Pos, "invalid recursive type alias %v%s", n, cycleTrace(cycle))
+				base.ErrorfAt(n.Pos(), "invalid recursive type alias %v%s", n, cycleTrace(cycle))
 			}
 
 		case ir.OLITERAL:
@@ -280,7 +280,7 @@ func typecheck(n *ir.Node, top int) (res *ir.Node) {
 				base.Errorf("%v is not a type", n)
 				break
 			}
-			base.ErrorfAt(n.Pos, "constant definition loop%s", cycleTrace(cycleFor(n)))
+			base.ErrorfAt(n.Pos(), "constant definition loop%s", cycleTrace(cycleFor(n)))
 		}
 
 		if base.Errors() == 0 {
@@ -318,7 +318,7 @@ func typecheck(n *ir.Node, top int) (res *ir.Node) {
 // The result of indexlit MUST be assigned back to n, e.g.
 // 	n.Left = indexlit(n.Left)
 func indexlit(n *ir.Node) *ir.Node {
-	if n != nil && n.Type != nil && n.Type.Etype == types.TIDEAL {
+	if n != nil && n.Type() != nil && n.Type().Etype == types.TIDEAL {
 		return defaultlit(n, types.Types[types.TINT])
 	}
 	return n
@@ -331,38 +331,38 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 		defer tracePrint("typecheck1", n)(&res)
 	}
 
-	switch n.Op {
+	switch n.Op() {
 	case ir.OLITERAL, ir.ONAME, ir.ONONAME, ir.OTYPE:
-		if n.Sym == nil {
+		if n.Sym() == nil {
 			break
 		}
 
-		if n.Op == ir.ONAME && n.SubOp() != 0 && top&ctxCallee == 0 {
-			base.Errorf("use of builtin %v not in function call", n.Sym)
-			n.Type = nil
+		if n.Op() == ir.ONAME && n.SubOp() != 0 && top&ctxCallee == 0 {
+			base.Errorf("use of builtin %v not in function call", n.Sym())
+			n.SetType(nil)
 			return n
 		}
 
 		typecheckdef(n)
-		if n.Op == ir.ONONAME {
-			n.Type = nil
+		if n.Op() == ir.ONONAME {
+			n.SetType(nil)
 			return n
 		}
 	}
 
 	ok := 0
-	switch n.Op {
+	switch n.Op() {
 	// until typecheck is complete, do nothing.
 	default:
 		ir.Dump("typecheck", n)
 
-		base.Fatalf("typecheck %v", n.Op)
+		base.Fatalf("typecheck %v", n.Op())
 
 	// names
 	case ir.OLITERAL:
 		ok |= ctxExpr
 
-		if n.Type == nil && n.Val().Kind() == constant.String {
+		if n.Type() == nil && n.Val().Kind() == constant.String {
 			base.Fatalf("string literal missing type")
 		}
 
@@ -370,8 +370,8 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 		ok |= ctxExpr
 
 	case ir.ONAME:
-		if n.Name.Decldepth == 0 {
-			n.Name.Decldepth = decldepth
+		if n.Name().Decldepth == 0 {
+			n.Name().Decldepth = decldepth
 		}
 		if n.SubOp() != 0 {
 			ok |= ctxCallee
@@ -382,18 +382,18 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 			// not a write to the variable
 			if ir.IsBlank(n) {
 				base.Errorf("cannot use _ as value")
-				n.Type = nil
+				n.SetType(nil)
 				return n
 			}
 
-			n.Name.SetUsed(true)
+			n.Name().SetUsed(true)
 		}
 
 		ok |= ctxExpr
 
 	case ir.OPACK:
-		base.Errorf("use of package %v without selector", n.Sym)
-		n.Type = nil
+		base.Errorf("use of package %v without selector", n.Sym())
+		n.SetType(nil)
 		return n
 
 	case ir.ODDD:
@@ -403,142 +403,142 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 	case ir.OTYPE:
 		ok |= ctxType
 
-		if n.Type == nil {
+		if n.Type() == nil {
 			return n
 		}
 
 	case ir.OTARRAY:
 		ok |= ctxType
-		r := typecheck(n.Right, ctxType)
-		if r.Type == nil {
-			n.Type = nil
+		r := typecheck(n.Right(), ctxType)
+		if r.Type() == nil {
+			n.SetType(nil)
 			return n
 		}
 
 		var t *types.Type
-		if n.Left == nil {
-			t = types.NewSlice(r.Type)
-		} else if n.Left.Op == ir.ODDD {
+		if n.Left() == nil {
+			t = types.NewSlice(r.Type())
+		} else if n.Left().Op() == ir.ODDD {
 			if !n.Diag() {
 				n.SetDiag(true)
 				base.Errorf("use of [...] array outside of array literal")
 			}
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		} else {
-			n.Left = indexlit(typecheck(n.Left, ctxExpr))
-			l := n.Left
+			n.SetLeft(indexlit(typecheck(n.Left(), ctxExpr)))
+			l := n.Left()
 			if ir.ConstType(l) != constant.Int {
 				switch {
-				case l.Type == nil:
+				case l.Type() == nil:
 					// Error already reported elsewhere.
-				case l.Type.IsInteger() && l.Op != ir.OLITERAL:
+				case l.Type().IsInteger() && l.Op() != ir.OLITERAL:
 					base.Errorf("non-constant array bound %v", l)
 				default:
 					base.Errorf("invalid array bound %v", l)
 				}
-				n.Type = nil
+				n.SetType(nil)
 				return n
 			}
 
 			v := l.Val()
 			if doesoverflow(v, types.Types[types.TINT]) {
 				base.Errorf("array bound is too large")
-				n.Type = nil
+				n.SetType(nil)
 				return n
 			}
 
 			if constant.Sign(v) < 0 {
 				base.Errorf("array bound must be non-negative")
-				n.Type = nil
+				n.SetType(nil)
 				return n
 			}
 
 			bound, _ := constant.Int64Val(v)
-			t = types.NewArray(r.Type, bound)
+			t = types.NewArray(r.Type(), bound)
 		}
 
 		setTypeNode(n, t)
-		n.Left = nil
-		n.Right = nil
+		n.SetLeft(nil)
+		n.SetRight(nil)
 		checkwidth(t)
 
 	case ir.OTMAP:
 		ok |= ctxType
-		n.Left = typecheck(n.Left, ctxType)
-		n.Right = typecheck(n.Right, ctxType)
-		l := n.Left
-		r := n.Right
-		if l.Type == nil || r.Type == nil {
-			n.Type = nil
+		n.SetLeft(typecheck(n.Left(), ctxType))
+		n.SetRight(typecheck(n.Right(), ctxType))
+		l := n.Left()
+		r := n.Right()
+		if l.Type() == nil || r.Type() == nil {
+			n.SetType(nil)
 			return n
 		}
-		if l.Type.NotInHeap() {
+		if l.Type().NotInHeap() {
 			base.Errorf("incomplete (or unallocatable) map key not allowed")
 		}
-		if r.Type.NotInHeap() {
+		if r.Type().NotInHeap() {
 			base.Errorf("incomplete (or unallocatable) map value not allowed")
 		}
 
-		setTypeNode(n, types.NewMap(l.Type, r.Type))
+		setTypeNode(n, types.NewMap(l.Type(), r.Type()))
 		mapqueue = append(mapqueue, n) // check map keys when all types are settled
-		n.Left = nil
-		n.Right = nil
+		n.SetLeft(nil)
+		n.SetRight(nil)
 
 	case ir.OTCHAN:
 		ok |= ctxType
-		n.Left = typecheck(n.Left, ctxType)
-		l := n.Left
-		if l.Type == nil {
-			n.Type = nil
+		n.SetLeft(typecheck(n.Left(), ctxType))
+		l := n.Left()
+		if l.Type() == nil {
+			n.SetType(nil)
 			return n
 		}
-		if l.Type.NotInHeap() {
+		if l.Type().NotInHeap() {
 			base.Errorf("chan of incomplete (or unallocatable) type not allowed")
 		}
 
-		setTypeNode(n, types.NewChan(l.Type, n.TChanDir()))
-		n.Left = nil
+		setTypeNode(n, types.NewChan(l.Type(), n.TChanDir()))
+		n.SetLeft(nil)
 		n.ResetAux()
 
 	case ir.OTSTRUCT:
 		ok |= ctxType
-		setTypeNode(n, tostruct(n.List.Slice()))
-		n.List.Set(nil)
+		setTypeNode(n, tostruct(n.List().Slice()))
+		n.PtrList().Set(nil)
 
 	case ir.OTINTER:
 		ok |= ctxType
-		setTypeNode(n, tointerface(n.List.Slice()))
+		setTypeNode(n, tointerface(n.List().Slice()))
 
 	case ir.OTFUNC:
 		ok |= ctxType
-		setTypeNode(n, functype(n.Left, n.List.Slice(), n.Rlist.Slice()))
-		n.Left = nil
-		n.List.Set(nil)
-		n.Rlist.Set(nil)
+		setTypeNode(n, functype(n.Left(), n.List().Slice(), n.Rlist().Slice()))
+		n.SetLeft(nil)
+		n.PtrList().Set(nil)
+		n.PtrRlist().Set(nil)
 
 	// type or expr
 	case ir.ODEREF:
-		n.Left = typecheck(n.Left, ctxExpr|ctxType)
-		l := n.Left
-		t := l.Type
+		n.SetLeft(typecheck(n.Left(), ctxExpr|ctxType))
+		l := n.Left()
+		t := l.Type()
 		if t == nil {
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
-		if l.Op == ir.OTYPE {
+		if l.Op() == ir.OTYPE {
 			ok |= ctxType
-			setTypeNode(n, types.NewPtr(l.Type))
-			n.Left = nil
+			setTypeNode(n, types.NewPtr(l.Type()))
+			n.SetLeft(nil)
 			// Ensure l.Type gets dowidth'd for the backend. Issue 20174.
-			checkwidth(l.Type)
+			checkwidth(l.Type())
 			break
 		}
 
 		if !t.IsPtr() {
 			if top&(ctxExpr|ctxStmt) != 0 {
-				base.Errorf("invalid indirect of %L", n.Left)
-				n.Type = nil
+				base.Errorf("invalid indirect of %L", n.Left())
+				n.SetType(nil)
 				return n
 			}
 
@@ -546,7 +546,7 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 		}
 
 		ok |= ctxExpr
-		n.Type = t.Elem()
+		n.SetType(t.Elem())
 
 	// arithmetic exprs
 	case ir.OASOP,
@@ -572,62 +572,62 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 		var l *ir.Node
 		var op ir.Op
 		var r *ir.Node
-		if n.Op == ir.OASOP {
+		if n.Op() == ir.OASOP {
 			ok |= ctxStmt
-			n.Left = typecheck(n.Left, ctxExpr)
-			n.Right = typecheck(n.Right, ctxExpr)
-			l = n.Left
-			r = n.Right
-			checkassign(n, n.Left)
-			if l.Type == nil || r.Type == nil {
-				n.Type = nil
+			n.SetLeft(typecheck(n.Left(), ctxExpr))
+			n.SetRight(typecheck(n.Right(), ctxExpr))
+			l = n.Left()
+			r = n.Right()
+			checkassign(n, n.Left())
+			if l.Type() == nil || r.Type() == nil {
+				n.SetType(nil)
 				return n
 			}
-			if n.Implicit() && !okforarith[l.Type.Etype] {
-				base.Errorf("invalid operation: %v (non-numeric type %v)", n, l.Type)
-				n.Type = nil
+			if n.Implicit() && !okforarith[l.Type().Etype] {
+				base.Errorf("invalid operation: %v (non-numeric type %v)", n, l.Type())
+				n.SetType(nil)
 				return n
 			}
 			// TODO(marvin): Fix Node.EType type union.
 			op = n.SubOp()
 		} else {
 			ok |= ctxExpr
-			n.Left = typecheck(n.Left, ctxExpr)
-			n.Right = typecheck(n.Right, ctxExpr)
-			l = n.Left
-			r = n.Right
-			if l.Type == nil || r.Type == nil {
-				n.Type = nil
+			n.SetLeft(typecheck(n.Left(), ctxExpr))
+			n.SetRight(typecheck(n.Right(), ctxExpr))
+			l = n.Left()
+			r = n.Right()
+			if l.Type() == nil || r.Type() == nil {
+				n.SetType(nil)
 				return n
 			}
-			op = n.Op
+			op = n.Op()
 		}
 		if op == ir.OLSH || op == ir.ORSH {
 			r = defaultlit(r, types.Types[types.TUINT])
-			n.Right = r
-			t := r.Type
+			n.SetRight(r)
+			t := r.Type()
 			if !t.IsInteger() {
-				base.Errorf("invalid operation: %v (shift count type %v, must be integer)", n, r.Type)
-				n.Type = nil
+				base.Errorf("invalid operation: %v (shift count type %v, must be integer)", n, r.Type())
+				n.SetType(nil)
 				return n
 			}
 			if t.IsSigned() && !langSupported(1, 13, curpkg()) {
-				base.ErrorfVers("go1.13", "invalid operation: %v (signed shift count type %v)", n, r.Type)
-				n.Type = nil
+				base.ErrorfVers("go1.13", "invalid operation: %v (signed shift count type %v)", n, r.Type())
+				n.SetType(nil)
 				return n
 			}
-			t = l.Type
+			t = l.Type()
 			if t != nil && t.Etype != types.TIDEAL && !t.IsInteger() {
 				base.Errorf("invalid operation: %v (shift of type %v)", n, t)
-				n.Type = nil
+				n.SetType(nil)
 				return n
 			}
 
 			// no defaultlit for left
 			// the outer context gives the type
-			n.Type = l.Type
-			if (l.Type == types.UntypedFloat || l.Type == types.UntypedComplex) && r.Op == ir.OLITERAL {
-				n.Type = types.UntypedInt
+			n.SetType(l.Type())
+			if (l.Type() == types.UntypedFloat || l.Type() == types.UntypedComplex) && r.Op() == ir.OLITERAL {
+				n.SetType(types.UntypedInt)
 			}
 
 			break
@@ -636,15 +636,15 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 		// For "x == x && len(s)", it's better to report that "len(s)" (type int)
 		// can't be used with "&&" than to report that "x == x" (type untyped bool)
 		// can't be converted to int (see issue #41500).
-		if n.Op == ir.OANDAND || n.Op == ir.OOROR {
-			if !n.Left.Type.IsBoolean() {
-				base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op, typekind(n.Left.Type))
-				n.Type = nil
+		if n.Op() == ir.OANDAND || n.Op() == ir.OOROR {
+			if !n.Left().Type().IsBoolean() {
+				base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op(), typekind(n.Left().Type()))
+				n.SetType(nil)
 				return n
 			}
-			if !n.Right.Type.IsBoolean() {
-				base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op, typekind(n.Right.Type))
-				n.Type = nil
+			if !n.Right().Type().IsBoolean() {
+				base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op(), typekind(n.Right().Type()))
+				n.SetType(nil)
 				return n
 			}
 		}
@@ -652,22 +652,22 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 		// ideal mixed with non-ideal
 		l, r = defaultlit2(l, r, false)
 
-		n.Left = l
-		n.Right = r
-		if l.Type == nil || r.Type == nil {
-			n.Type = nil
+		n.SetLeft(l)
+		n.SetRight(r)
+		if l.Type() == nil || r.Type() == nil {
+			n.SetType(nil)
 			return n
 		}
-		t := l.Type
+		t := l.Type()
 		if t.Etype == types.TIDEAL {
-			t = r.Type
+			t = r.Type()
 		}
 		et := t.Etype
 		if et == types.TIDEAL {
 			et = types.TINT
 		}
 		aop := ir.OXXX
-		if iscmp[n.Op] && t.Etype != types.TIDEAL && !types.Identical(l.Type, r.Type) {
+		if iscmp[n.Op()] && t.Etype != types.TIDEAL && !types.Identical(l.Type(), r.Type()) {
 			// comparison is okay as long as one side is
 			// assignable to the other.  convert so they have
 			// the same type.
@@ -676,235 +676,235 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 			// in that case, check comparability of the concrete type.
 			// The conversion allocates, so only do it if the concrete type is huge.
 			converted := false
-			if r.Type.Etype != types.TBLANK {
-				aop, _ = assignop(l.Type, r.Type)
+			if r.Type().Etype != types.TBLANK {
+				aop, _ = assignop(l.Type(), r.Type())
 				if aop != ir.OXXX {
-					if r.Type.IsInterface() && !l.Type.IsInterface() && !IsComparable(l.Type) {
-						base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(l.Type))
-						n.Type = nil
+					if r.Type().IsInterface() && !l.Type().IsInterface() && !IsComparable(l.Type()) {
+						base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(l.Type()))
+						n.SetType(nil)
 						return n
 					}
 
-					dowidth(l.Type)
-					if r.Type.IsInterface() == l.Type.IsInterface() || l.Type.Width >= 1<<16 {
+					dowidth(l.Type())
+					if r.Type().IsInterface() == l.Type().IsInterface() || l.Type().Width >= 1<<16 {
 						l = ir.Nod(aop, l, nil)
-						l.Type = r.Type
+						l.SetType(r.Type())
 						l.SetTypecheck(1)
-						n.Left = l
+						n.SetLeft(l)
 					}
 
-					t = r.Type
+					t = r.Type()
 					converted = true
 				}
 			}
 
-			if !converted && l.Type.Etype != types.TBLANK {
-				aop, _ = assignop(r.Type, l.Type)
+			if !converted && l.Type().Etype != types.TBLANK {
+				aop, _ = assignop(r.Type(), l.Type())
 				if aop != ir.OXXX {
-					if l.Type.IsInterface() && !r.Type.IsInterface() && !IsComparable(r.Type) {
-						base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(r.Type))
-						n.Type = nil
+					if l.Type().IsInterface() && !r.Type().IsInterface() && !IsComparable(r.Type()) {
+						base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(r.Type()))
+						n.SetType(nil)
 						return n
 					}
 
-					dowidth(r.Type)
-					if r.Type.IsInterface() == l.Type.IsInterface() || r.Type.Width >= 1<<16 {
+					dowidth(r.Type())
+					if r.Type().IsInterface() == l.Type().IsInterface() || r.Type().Width >= 1<<16 {
 						r = ir.Nod(aop, r, nil)
-						r.Type = l.Type
+						r.SetType(l.Type())
 						r.SetTypecheck(1)
-						n.Right = r
+						n.SetRight(r)
 					}
 
-					t = l.Type
+					t = l.Type()
 				}
 			}
 
 			et = t.Etype
 		}
 
-		if t.Etype != types.TIDEAL && !types.Identical(l.Type, r.Type) {
+		if t.Etype != types.TIDEAL && !types.Identical(l.Type(), r.Type()) {
 			l, r = defaultlit2(l, r, true)
-			if l.Type == nil || r.Type == nil {
-				n.Type = nil
+			if l.Type() == nil || r.Type() == nil {
+				n.SetType(nil)
 				return n
 			}
-			if l.Type.IsInterface() == r.Type.IsInterface() || aop == 0 {
-				base.Errorf("invalid operation: %v (mismatched types %v and %v)", n, l.Type, r.Type)
-				n.Type = nil
+			if l.Type().IsInterface() == r.Type().IsInterface() || aop == 0 {
+				base.Errorf("invalid operation: %v (mismatched types %v and %v)", n, l.Type(), r.Type())
+				n.SetType(nil)
 				return n
 			}
 		}
 
 		if t.Etype == types.TIDEAL {
-			t = mixUntyped(l.Type, r.Type)
+			t = mixUntyped(l.Type(), r.Type())
 		}
 		if dt := defaultType(t); !okfor[op][dt.Etype] {
 			base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(t))
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
 		// okfor allows any array == array, map == map, func == func.
 		// restrict to slice/map/func == nil and nil == slice/map/func.
-		if l.Type.IsArray() && !IsComparable(l.Type) {
-			base.Errorf("invalid operation: %v (%v cannot be compared)", n, l.Type)
-			n.Type = nil
+		if l.Type().IsArray() && !IsComparable(l.Type()) {
+			base.Errorf("invalid operation: %v (%v cannot be compared)", n, l.Type())
+			n.SetType(nil)
 			return n
 		}
 
-		if l.Type.IsSlice() && !ir.IsNil(l) && !ir.IsNil(r) {
+		if l.Type().IsSlice() && !ir.IsNil(l) && !ir.IsNil(r) {
 			base.Errorf("invalid operation: %v (slice can only be compared to nil)", n)
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
-		if l.Type.IsMap() && !ir.IsNil(l) && !ir.IsNil(r) {
+		if l.Type().IsMap() && !ir.IsNil(l) && !ir.IsNil(r) {
 			base.Errorf("invalid operation: %v (map can only be compared to nil)", n)
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
-		if l.Type.Etype == types.TFUNC && !ir.IsNil(l) && !ir.IsNil(r) {
+		if l.Type().Etype == types.TFUNC && !ir.IsNil(l) && !ir.IsNil(r) {
 			base.Errorf("invalid operation: %v (func can only be compared to nil)", n)
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
-		if l.Type.IsStruct() {
-			if f := IncomparableField(l.Type); f != nil {
+		if l.Type().IsStruct() {
+			if f := IncomparableField(l.Type()); f != nil {
 				base.Errorf("invalid operation: %v (struct containing %v cannot be compared)", n, f.Type)
-				n.Type = nil
+				n.SetType(nil)
 				return n
 			}
 		}
 
-		if iscmp[n.Op] {
+		if iscmp[n.Op()] {
 			t = types.UntypedBool
-			n.Type = t
+			n.SetType(t)
 			n = evalConst(n)
-			if n.Op != ir.OLITERAL {
+			if n.Op() != ir.OLITERAL {
 				l, r = defaultlit2(l, r, true)
-				n.Left = l
-				n.Right = r
+				n.SetLeft(l)
+				n.SetRight(r)
 			}
 		}
 
-		if et == types.TSTRING && n.Op == ir.OADD {
+		if et == types.TSTRING && n.Op() == ir.OADD {
 			// create or update OADDSTR node with list of strings in x + y + z + (w + v) + ...
-			if l.Op == ir.OADDSTR {
+			if l.Op() == ir.OADDSTR {
 				orig := n
 				n = l
-				n.Pos = orig.Pos
+				n.SetPos(orig.Pos())
 			} else {
-				n = ir.NodAt(n.Pos, ir.OADDSTR, nil, nil)
-				n.List.Set1(l)
+				n = ir.NodAt(n.Pos(), ir.OADDSTR, nil, nil)
+				n.PtrList().Set1(l)
 			}
-			if r.Op == ir.OADDSTR {
-				n.List.AppendNodes(&r.List)
+			if r.Op() == ir.OADDSTR {
+				n.PtrList().AppendNodes(r.PtrList())
 			} else {
-				n.List.Append(r)
+				n.PtrList().Append(r)
 			}
 		}
 
 		if (op == ir.ODIV || op == ir.OMOD) && ir.IsConst(r, constant.Int) {
 			if constant.Sign(r.Val()) == 0 {
 				base.Errorf("division by zero")
-				n.Type = nil
+				n.SetType(nil)
 				return n
 			}
 		}
 
-		n.Type = t
+		n.SetType(t)
 
 	case ir.OBITNOT, ir.ONEG, ir.ONOT, ir.OPLUS:
 		ok |= ctxExpr
-		n.Left = typecheck(n.Left, ctxExpr)
-		l := n.Left
-		t := l.Type
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		l := n.Left()
+		t := l.Type()
 		if t == nil {
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
-		if !okfor[n.Op][defaultType(t).Etype] {
-			base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op, typekind(t))
-			n.Type = nil
+		if !okfor[n.Op()][defaultType(t).Etype] {
+			base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op(), typekind(t))
+			n.SetType(nil)
 			return n
 		}
 
-		n.Type = t
+		n.SetType(t)
 
 	// exprs
 	case ir.OADDR:
 		ok |= ctxExpr
 
-		n.Left = typecheck(n.Left, ctxExpr)
-		if n.Left.Type == nil {
-			n.Type = nil
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		if n.Left().Type() == nil {
+			n.SetType(nil)
 			return n
 		}
 
-		switch n.Left.Op {
+		switch n.Left().Op() {
 		case ir.OARRAYLIT, ir.OMAPLIT, ir.OSLICELIT, ir.OSTRUCTLIT:
-			n.Op = ir.OPTRLIT
+			n.SetOp(ir.OPTRLIT)
 
 		default:
-			checklvalue(n.Left, "take the address of")
-			r := outervalue(n.Left)
-			if r.Op == ir.ONAME {
-				if r.Orig != r {
+			checklvalue(n.Left(), "take the address of")
+			r := outervalue(n.Left())
+			if r.Op() == ir.ONAME {
+				if r.Orig() != r {
 					base.Fatalf("found non-orig name node %v", r) // TODO(mdempsky): What does this mean?
 				}
-				r.Name.SetAddrtaken(true)
-				if r.Name.IsClosureVar() && !capturevarscomplete {
+				r.Name().SetAddrtaken(true)
+				if r.Name().IsClosureVar() && !capturevarscomplete {
 					// Mark the original variable as Addrtaken so that capturevars
 					// knows not to pass it by value.
 					// But if the capturevars phase is complete, don't touch it,
 					// in case l.Name's containing function has not yet been compiled.
-					r.Name.Defn.Name.SetAddrtaken(true)
+					r.Name().Defn.Name().SetAddrtaken(true)
 				}
 			}
-			n.Left = defaultlit(n.Left, nil)
-			if n.Left.Type == nil {
-				n.Type = nil
+			n.SetLeft(defaultlit(n.Left(), nil))
+			if n.Left().Type() == nil {
+				n.SetType(nil)
 				return n
 			}
 		}
 
-		n.Type = types.NewPtr(n.Left.Type)
+		n.SetType(types.NewPtr(n.Left().Type()))
 
 	case ir.OCOMPLIT:
 		ok |= ctxExpr
 		n = typecheckcomplit(n)
-		if n.Type == nil {
+		if n.Type() == nil {
 			return n
 		}
 
 	case ir.OXDOT, ir.ODOT:
-		if n.Op == ir.OXDOT {
+		if n.Op() == ir.OXDOT {
 			n = adddot(n)
-			n.Op = ir.ODOT
-			if n.Left == nil {
-				n.Type = nil
+			n.SetOp(ir.ODOT)
+			if n.Left() == nil {
+				n.SetType(nil)
 				return n
 			}
 		}
 
-		n.Left = typecheck(n.Left, ctxExpr|ctxType)
+		n.SetLeft(typecheck(n.Left(), ctxExpr|ctxType))
 
-		n.Left = defaultlit(n.Left, nil)
+		n.SetLeft(defaultlit(n.Left(), nil))
 
-		t := n.Left.Type
+		t := n.Left().Type()
 		if t == nil {
-			base.UpdateErrorDot(ir.Line(n), n.Left.String(), n.String())
-			n.Type = nil
+			base.UpdateErrorDot(ir.Line(n), n.Left().String(), n.String())
+			n.SetType(nil)
 			return n
 		}
 
-		s := n.Sym
+		s := n.Sym()
 
-		if n.Left.Op == ir.OTYPE {
+		if n.Left().Op() == ir.OTYPE {
 			n = typecheckMethodExpr(n)
-			if n.Type == nil {
+			if n.Type() == nil {
 				return n
 			}
 			ok = ctxExpr
@@ -914,16 +914,16 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 		if t.IsPtr() && !t.Elem().IsInterface() {
 			t = t.Elem()
 			if t == nil {
-				n.Type = nil
+				n.SetType(nil)
 				return n
 			}
-			n.Op = ir.ODOTPTR
+			n.SetOp(ir.ODOTPTR)
 			checkwidth(t)
 		}
 
-		if n.Sym.IsBlank() {
+		if n.Sym().IsBlank() {
 			base.Errorf("cannot refer to blank field or method")
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
@@ -931,28 +931,28 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 			// Legitimate field or method lookup failed, try to explain the error
 			switch {
 			case t.IsEmptyInterface():
-				base.Errorf("%v undefined (type %v is interface with no methods)", n, n.Left.Type)
+				base.Errorf("%v undefined (type %v is interface with no methods)", n, n.Left().Type())
 
 			case t.IsPtr() && t.Elem().IsInterface():
 				// Pointer to interface is almost always a mistake.
-				base.Errorf("%v undefined (type %v is pointer to interface, not interface)", n, n.Left.Type)
+				base.Errorf("%v undefined (type %v is pointer to interface, not interface)", n, n.Left().Type())
 
 			case lookdot(n, t, 1) != nil:
 				// Field or method matches by name, but it is not exported.
-				base.Errorf("%v undefined (cannot refer to unexported field or method %v)", n, n.Sym)
+				base.Errorf("%v undefined (cannot refer to unexported field or method %v)", n, n.Sym())
 
 			default:
 				if mt := lookdot(n, t, 2); mt != nil && visible(mt.Sym) { // Case-insensitive lookup.
-					base.Errorf("%v undefined (type %v has no field or method %v, but does have %v)", n, n.Left.Type, n.Sym, mt.Sym)
+					base.Errorf("%v undefined (type %v has no field or method %v, but does have %v)", n, n.Left().Type(), n.Sym(), mt.Sym)
 				} else {
-					base.Errorf("%v undefined (type %v has no field or method %v)", n, n.Left.Type, n.Sym)
+					base.Errorf("%v undefined (type %v has no field or method %v)", n, n.Left().Type(), n.Sym())
 				}
 			}
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
-		switch n.Op {
+		switch n.Op() {
 		case ir.ODOTINTER, ir.ODOTMETH:
 			if top&ctxCallee != 0 {
 				ok |= ctxCallee
@@ -967,74 +967,74 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 
 	case ir.ODOTTYPE:
 		ok |= ctxExpr
-		n.Left = typecheck(n.Left, ctxExpr)
-		n.Left = defaultlit(n.Left, nil)
-		l := n.Left
-		t := l.Type
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		n.SetLeft(defaultlit(n.Left(), nil))
+		l := n.Left()
+		t := l.Type()
 		if t == nil {
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 		if !t.IsInterface() {
 			base.Errorf("invalid type assertion: %v (non-interface type %v on left)", n, t)
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
-		if n.Right != nil {
-			n.Right = typecheck(n.Right, ctxType)
-			n.Type = n.Right.Type
-			n.Right = nil
-			if n.Type == nil {
+		if n.Right() != nil {
+			n.SetRight(typecheck(n.Right(), ctxType))
+			n.SetType(n.Right().Type())
+			n.SetRight(nil)
+			if n.Type() == nil {
 				return n
 			}
 		}
 
-		if n.Type != nil && !n.Type.IsInterface() {
+		if n.Type() != nil && !n.Type().IsInterface() {
 			var missing, have *types.Field
 			var ptr int
-			if !implements(n.Type, t, &missing, &have, &ptr) {
+			if !implements(n.Type(), t, &missing, &have, &ptr) {
 				if have != nil && have.Sym == missing.Sym {
 					base.Errorf("impossible type assertion:\n\t%v does not implement %v (wrong type for %v method)\n"+
-						"\t\thave %v%0S\n\t\twant %v%0S", n.Type, t, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
+						"\t\thave %v%0S\n\t\twant %v%0S", n.Type(), t, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
 				} else if ptr != 0 {
-					base.Errorf("impossible type assertion:\n\t%v does not implement %v (%v method has pointer receiver)", n.Type, t, missing.Sym)
+					base.Errorf("impossible type assertion:\n\t%v does not implement %v (%v method has pointer receiver)", n.Type(), t, missing.Sym)
 				} else if have != nil {
 					base.Errorf("impossible type assertion:\n\t%v does not implement %v (missing %v method)\n"+
-						"\t\thave %v%0S\n\t\twant %v%0S", n.Type, t, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
+						"\t\thave %v%0S\n\t\twant %v%0S", n.Type(), t, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
 				} else {
-					base.Errorf("impossible type assertion:\n\t%v does not implement %v (missing %v method)", n.Type, t, missing.Sym)
+					base.Errorf("impossible type assertion:\n\t%v does not implement %v (missing %v method)", n.Type(), t, missing.Sym)
 				}
-				n.Type = nil
+				n.SetType(nil)
 				return n
 			}
 		}
 
 	case ir.OINDEX:
 		ok |= ctxExpr
-		n.Left = typecheck(n.Left, ctxExpr)
-		n.Left = defaultlit(n.Left, nil)
-		n.Left = implicitstar(n.Left)
-		l := n.Left
-		n.Right = typecheck(n.Right, ctxExpr)
-		r := n.Right
-		t := l.Type
-		if t == nil || r.Type == nil {
-			n.Type = nil
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		n.SetLeft(defaultlit(n.Left(), nil))
+		n.SetLeft(implicitstar(n.Left()))
+		l := n.Left()
+		n.SetRight(typecheck(n.Right(), ctxExpr))
+		r := n.Right()
+		t := l.Type()
+		if t == nil || r.Type() == nil {
+			n.SetType(nil)
 			return n
 		}
 		switch t.Etype {
 		default:
 			base.Errorf("invalid operation: %v (type %v does not support indexing)", n, t)
-			n.Type = nil
+			n.SetType(nil)
 			return n
 
 		case types.TSTRING, types.TARRAY, types.TSLICE:
-			n.Right = indexlit(n.Right)
+			n.SetRight(indexlit(n.Right()))
 			if t.IsString() {
-				n.Type = types.Bytetype
+				n.SetType(types.Bytetype)
 			} else {
-				n.Type = t.Elem()
+				n.SetType(t.Elem())
 			}
 			why := "string"
 			if t.IsArray() {
@@ -1043,83 +1043,83 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 				why = "slice"
 			}
 
-			if n.Right.Type != nil && !n.Right.Type.IsInteger() {
-				base.Errorf("non-integer %s index %v", why, n.Right)
+			if n.Right().Type() != nil && !n.Right().Type().IsInteger() {
+				base.Errorf("non-integer %s index %v", why, n.Right())
 				break
 			}
 
-			if !n.Bounded() && ir.IsConst(n.Right, constant.Int) {
-				x := n.Right.Val()
+			if !n.Bounded() && ir.IsConst(n.Right(), constant.Int) {
+				x := n.Right().Val()
 				if constant.Sign(x) < 0 {
-					base.Errorf("invalid %s index %v (index must be non-negative)", why, n.Right)
+					base.Errorf("invalid %s index %v (index must be non-negative)", why, n.Right())
 				} else if t.IsArray() && constant.Compare(x, token.GEQ, constant.MakeInt64(t.NumElem())) {
-					base.Errorf("invalid array index %v (out of bounds for %d-element array)", n.Right, t.NumElem())
-				} else if ir.IsConst(n.Left, constant.String) && constant.Compare(x, token.GEQ, constant.MakeInt64(int64(len(n.Left.StringVal())))) {
-					base.Errorf("invalid string index %v (out of bounds for %d-byte string)", n.Right, len(n.Left.StringVal()))
+					base.Errorf("invalid array index %v (out of bounds for %d-element array)", n.Right(), t.NumElem())
+				} else if ir.IsConst(n.Left(), constant.String) && constant.Compare(x, token.GEQ, constant.MakeInt64(int64(len(n.Left().StringVal())))) {
+					base.Errorf("invalid string index %v (out of bounds for %d-byte string)", n.Right(), len(n.Left().StringVal()))
 				} else if doesoverflow(x, types.Types[types.TINT]) {
-					base.Errorf("invalid %s index %v (index too large)", why, n.Right)
+					base.Errorf("invalid %s index %v (index too large)", why, n.Right())
 				}
 			}
 
 		case types.TMAP:
-			n.Right = assignconv(n.Right, t.Key(), "map index")
-			n.Type = t.Elem()
-			n.Op = ir.OINDEXMAP
+			n.SetRight(assignconv(n.Right(), t.Key(), "map index"))
+			n.SetType(t.Elem())
+			n.SetOp(ir.OINDEXMAP)
 			n.ResetAux()
 		}
 
 	case ir.ORECV:
 		ok |= ctxStmt | ctxExpr
-		n.Left = typecheck(n.Left, ctxExpr)
-		n.Left = defaultlit(n.Left, nil)
-		l := n.Left
-		t := l.Type
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		n.SetLeft(defaultlit(n.Left(), nil))
+		l := n.Left()
+		t := l.Type()
 		if t == nil {
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 		if !t.IsChan() {
 			base.Errorf("invalid operation: %v (receive from non-chan type %v)", n, t)
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
 		if !t.ChanDir().CanRecv() {
 			base.Errorf("invalid operation: %v (receive from send-only type %v)", n, t)
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
-		n.Type = t.Elem()
+		n.SetType(t.Elem())
 
 	case ir.OSEND:
 		ok |= ctxStmt
-		n.Left = typecheck(n.Left, ctxExpr)
-		n.Right = typecheck(n.Right, ctxExpr)
-		n.Left = defaultlit(n.Left, nil)
-		t := n.Left.Type
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		n.SetRight(typecheck(n.Right(), ctxExpr))
+		n.SetLeft(defaultlit(n.Left(), nil))
+		t := n.Left().Type()
 		if t == nil {
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 		if !t.IsChan() {
 			base.Errorf("invalid operation: %v (send to non-chan type %v)", n, t)
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
 		if !t.ChanDir().CanSend() {
 			base.Errorf("invalid operation: %v (send to receive-only type %v)", n, t)
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
-		n.Right = assignconv(n.Right, t.Elem(), "send")
-		if n.Right.Type == nil {
-			n.Type = nil
+		n.SetRight(assignconv(n.Right(), t.Elem(), "send"))
+		if n.Right().Type() == nil {
+			n.SetType(nil)
 			return n
 		}
-		n.Type = nil
+		n.SetType(nil)
 
 	case ir.OSLICEHEADER:
 		// Errors here are Fatalf instead of Errorf because only the compiler
@@ -1128,26 +1128,26 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 		// have already been typechecked in e.g. OMAKESLICE earlier.
 		ok |= ctxExpr
 
-		t := n.Type
+		t := n.Type()
 		if t == nil {
 			base.Fatalf("no type specified for OSLICEHEADER")
 		}
 
 		if !t.IsSlice() {
-			base.Fatalf("invalid type %v for OSLICEHEADER", n.Type)
+			base.Fatalf("invalid type %v for OSLICEHEADER", n.Type())
 		}
 
-		if n.Left == nil || n.Left.Type == nil || !n.Left.Type.IsUnsafePtr() {
+		if n.Left() == nil || n.Left().Type() == nil || !n.Left().Type().IsUnsafePtr() {
 			base.Fatalf("need unsafe.Pointer for OSLICEHEADER")
 		}
 
-		if x := n.List.Len(); x != 2 {
+		if x := n.List().Len(); x != 2 {
 			base.Fatalf("expected 2 params (len, cap) for OSLICEHEADER, got %d", x)
 		}
 
-		n.Left = typecheck(n.Left, ctxExpr)
-		l := typecheck(n.List.First(), ctxExpr)
-		c := typecheck(n.List.Second(), ctxExpr)
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		l := typecheck(n.List().First(), ctxExpr)
+		c := typecheck(n.List().Second(), ctxExpr)
 		l = defaultlit(l, types.Types[types.TINT])
 		c = defaultlit(c, types.Types[types.TINT])
 
@@ -1163,8 +1163,8 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 			base.Fatalf("len larger than cap for OSLICEHEADER")
 		}
 
-		n.List.SetFirst(l)
-		n.List.SetSecond(c)
+		n.List().SetFirst(l)
+		n.List().SetSecond(c)
 
 	case ir.OMAKESLICECOPY:
 		// Errors here are Fatalf instead of Errorf because only the compiler
@@ -1173,145 +1173,145 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 		// have already been typechecked in OMAKE and OCOPY earlier.
 		ok |= ctxExpr
 
-		t := n.Type
+		t := n.Type()
 
 		if t == nil {
 			base.Fatalf("no type specified for OMAKESLICECOPY")
 		}
 
 		if !t.IsSlice() {
-			base.Fatalf("invalid type %v for OMAKESLICECOPY", n.Type)
+			base.Fatalf("invalid type %v for OMAKESLICECOPY", n.Type())
 		}
 
-		if n.Left == nil {
+		if n.Left() == nil {
 			base.Fatalf("missing len argument for OMAKESLICECOPY")
 		}
 
-		if n.Right == nil {
+		if n.Right() == nil {
 			base.Fatalf("missing slice argument to copy for OMAKESLICECOPY")
 		}
 
-		n.Left = typecheck(n.Left, ctxExpr)
-		n.Right = typecheck(n.Right, ctxExpr)
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		n.SetRight(typecheck(n.Right(), ctxExpr))
 
-		n.Left = defaultlit(n.Left, types.Types[types.TINT])
+		n.SetLeft(defaultlit(n.Left(), types.Types[types.TINT]))
 
-		if !n.Left.Type.IsInteger() && n.Type.Etype != types.TIDEAL {
+		if !n.Left().Type().IsInteger() && n.Type().Etype != types.TIDEAL {
 			base.Errorf("non-integer len argument in OMAKESLICECOPY")
 		}
 
-		if ir.IsConst(n.Left, constant.Int) {
-			if doesoverflow(n.Left.Val(), types.Types[types.TINT]) {
+		if ir.IsConst(n.Left(), constant.Int) {
+			if doesoverflow(n.Left().Val(), types.Types[types.TINT]) {
 				base.Fatalf("len for OMAKESLICECOPY too large")
 			}
-			if constant.Sign(n.Left.Val()) < 0 {
+			if constant.Sign(n.Left().Val()) < 0 {
 				base.Fatalf("len for OMAKESLICECOPY must be non-negative")
 			}
 		}
 
 	case ir.OSLICE, ir.OSLICE3:
 		ok |= ctxExpr
-		n.Left = typecheck(n.Left, ctxExpr)
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		low, high, max := n.SliceBounds()
-		hasmax := n.Op.IsSlice3()
+		hasmax := n.Op().IsSlice3()
 		low = typecheck(low, ctxExpr)
 		high = typecheck(high, ctxExpr)
 		max = typecheck(max, ctxExpr)
-		n.Left = defaultlit(n.Left, nil)
+		n.SetLeft(defaultlit(n.Left(), nil))
 		low = indexlit(low)
 		high = indexlit(high)
 		max = indexlit(max)
 		n.SetSliceBounds(low, high, max)
-		l := n.Left
-		if l.Type == nil {
-			n.Type = nil
+		l := n.Left()
+		if l.Type() == nil {
+			n.SetType(nil)
 			return n
 		}
-		if l.Type.IsArray() {
-			if !islvalue(n.Left) {
+		if l.Type().IsArray() {
+			if !islvalue(n.Left()) {
 				base.Errorf("invalid operation %v (slice of unaddressable value)", n)
-				n.Type = nil
+				n.SetType(nil)
 				return n
 			}
 
-			n.Left = ir.Nod(ir.OADDR, n.Left, nil)
-			n.Left.SetImplicit(true)
-			n.Left = typecheck(n.Left, ctxExpr)
-			l = n.Left
+			n.SetLeft(ir.Nod(ir.OADDR, n.Left(), nil))
+			n.Left().SetImplicit(true)
+			n.SetLeft(typecheck(n.Left(), ctxExpr))
+			l = n.Left()
 		}
-		t := l.Type
+		t := l.Type()
 		var tp *types.Type
 		if t.IsString() {
 			if hasmax {
 				base.Errorf("invalid operation %v (3-index slice of string)", n)
-				n.Type = nil
+				n.SetType(nil)
 				return n
 			}
-			n.Type = t
-			n.Op = ir.OSLICESTR
+			n.SetType(t)
+			n.SetOp(ir.OSLICESTR)
 		} else if t.IsPtr() && t.Elem().IsArray() {
 			tp = t.Elem()
-			n.Type = types.NewSlice(tp.Elem())
-			dowidth(n.Type)
+			n.SetType(types.NewSlice(tp.Elem()))
+			dowidth(n.Type())
 			if hasmax {
-				n.Op = ir.OSLICE3ARR
+				n.SetOp(ir.OSLICE3ARR)
 			} else {
-				n.Op = ir.OSLICEARR
+				n.SetOp(ir.OSLICEARR)
 			}
 		} else if t.IsSlice() {
-			n.Type = t
+			n.SetType(t)
 		} else {
 			base.Errorf("cannot slice %v (type %v)", l, t)
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
 		if low != nil && !checksliceindex(l, low, tp) {
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 		if high != nil && !checksliceindex(l, high, tp) {
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 		if max != nil && !checksliceindex(l, max, tp) {
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 		if !checksliceconst(low, high) || !checksliceconst(low, max) || !checksliceconst(high, max) {
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
 	// call and call like
 	case ir.OCALL:
-		typecheckslice(n.Ninit.Slice(), ctxStmt) // imported rewritten f(g()) calls (#30907)
-		n.Left = typecheck(n.Left, ctxExpr|ctxType|ctxCallee)
-		if n.Left.Diag() {
+		typecheckslice(n.Init().Slice(), ctxStmt) // imported rewritten f(g()) calls (#30907)
+		n.SetLeft(typecheck(n.Left(), ctxExpr|ctxType|ctxCallee))
+		if n.Left().Diag() {
 			n.SetDiag(true)
 		}
 
-		l := n.Left
+		l := n.Left()
 
-		if l.Op == ir.ONAME && l.SubOp() != 0 {
+		if l.Op() == ir.ONAME && l.SubOp() != 0 {
 			if n.IsDDD() && l.SubOp() != ir.OAPPEND {
 				base.Errorf("invalid use of ... with builtin %v", l)
 			}
 
 			// builtin: OLEN, OCAP, etc.
-			n.Op = l.SubOp()
-			n.Left = n.Right
-			n.Right = nil
+			n.SetOp(l.SubOp())
+			n.SetLeft(n.Right())
+			n.SetRight(nil)
 			n = typecheck1(n, top)
 			return n
 		}
 
-		n.Left = defaultlit(n.Left, nil)
-		l = n.Left
-		if l.Op == ir.OTYPE {
+		n.SetLeft(defaultlit(n.Left(), nil))
+		l = n.Left()
+		if l.Op() == ir.OTYPE {
 			if n.IsDDD() {
-				if !l.Type.Broke() {
-					base.Errorf("invalid use of ... in type conversion to %v", l.Type)
+				if !l.Type().Broke() {
+					base.Errorf("invalid use of ... in type conversion to %v", l.Type())
 				}
 				n.SetDiag(true)
 			}
@@ -1320,12 +1320,12 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 			ok |= ctxExpr
 
 			// turn CALL(type, arg) into CONV(arg) w/ type
-			n.Left = nil
+			n.SetLeft(nil)
 
-			n.Op = ir.OCONV
-			n.Type = l.Type
-			if !onearg(n, "conversion to %v", l.Type) {
-				n.Type = nil
+			n.SetOp(ir.OCONV)
+			n.SetType(l.Type())
+			if !onearg(n, "conversion to %v", l.Type()) {
+				n.SetType(nil)
 				return n
 			}
 			n = typecheck1(n, top)
@@ -1333,19 +1333,19 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 		}
 
 		typecheckargs(n)
-		t := l.Type
+		t := l.Type()
 		if t == nil {
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 		checkwidth(t)
 
-		switch l.Op {
+		switch l.Op() {
 		case ir.ODOTINTER:
-			n.Op = ir.OCALLINTER
+			n.SetOp(ir.OCALLINTER)
 
 		case ir.ODOTMETH:
-			n.Op = ir.OCALLMETH
+			n.SetOp(ir.OCALLMETH)
 
 			// typecheckaste was used here but there wasn't enough
 			// information further down the call chain to know if we
@@ -1353,44 +1353,44 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 			// It isn't necessary, so just do a sanity check.
 			tp := t.Recv().Type
 
-			if l.Left == nil || !types.Identical(l.Left.Type, tp) {
+			if l.Left() == nil || !types.Identical(l.Left().Type(), tp) {
 				base.Fatalf("method receiver")
 			}
 
 		default:
-			n.Op = ir.OCALLFUNC
+			n.SetOp(ir.OCALLFUNC)
 			if t.Etype != types.TFUNC {
 				name := l.String()
-				if isBuiltinFuncName(name) && l.Name.Defn != nil {
+				if isBuiltinFuncName(name) && l.Name().Defn != nil {
 					// be more specific when the function
 					// name matches a predeclared function
 					base.Errorf("cannot call non-function %s (type %v), declared at %s",
-						name, t, base.FmtPos(l.Name.Defn.Pos))
+						name, t, base.FmtPos(l.Name().Defn.Pos()))
 				} else {
 					base.Errorf("cannot call non-function %s (type %v)", name, t)
 				}
-				n.Type = nil
+				n.SetType(nil)
 				return n
 			}
 		}
 
-		typecheckaste(ir.OCALL, n.Left, n.IsDDD(), t.Params(), n.List, func() string { return fmt.Sprintf("argument to %v", n.Left) })
+		typecheckaste(ir.OCALL, n.Left(), n.IsDDD(), t.Params(), n.List(), func() string { return fmt.Sprintf("argument to %v", n.Left()) })
 		ok |= ctxStmt
 		if t.NumResults() == 0 {
 			break
 		}
 		ok |= ctxExpr
 		if t.NumResults() == 1 {
-			n.Type = l.Type.Results().Field(0).Type
+			n.SetType(l.Type().Results().Field(0).Type)
 
-			if n.Op == ir.OCALLFUNC && n.Left.Op == ir.ONAME && isRuntimePkg(n.Left.Sym.Pkg) && n.Left.Sym.Name == "getg" {
+			if n.Op() == ir.OCALLFUNC && n.Left().Op() == ir.ONAME && isRuntimePkg(n.Left().Sym().Pkg) && n.Left().Sym().Name == "getg" {
 				// Emit code for runtime.getg() directly instead of calling function.
 				// Most such rewrites (for example the similar one for math.Sqrt) should be done in walk,
 				// so that the ordering pass can make sure to preserve the semantics of the original code
 				// (in particular, the exact time of the function call) by introducing temporaries.
 				// In this case, we know getg() always returns the same result within a given function
 				// and we want to avoid the temporaries, so we do the rewrite earlier than is typical.
-				n.Op = ir.OGETG
+				n.SetOp(ir.OGETG)
 			}
 
 			break
@@ -1402,73 +1402,73 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 			break
 		}
 
-		n.Type = l.Type.Results()
+		n.SetType(l.Type().Results())
 
 	case ir.OALIGNOF, ir.OOFFSETOF, ir.OSIZEOF:
 		ok |= ctxExpr
-		if !onearg(n, "%v", n.Op) {
-			n.Type = nil
+		if !onearg(n, "%v", n.Op()) {
+			n.SetType(nil)
 			return n
 		}
-		n.Type = types.Types[types.TUINTPTR]
+		n.SetType(types.Types[types.TUINTPTR])
 
 	case ir.OCAP, ir.OLEN:
 		ok |= ctxExpr
-		if !onearg(n, "%v", n.Op) {
-			n.Type = nil
+		if !onearg(n, "%v", n.Op()) {
+			n.SetType(nil)
 			return n
 		}
 
-		n.Left = typecheck(n.Left, ctxExpr)
-		n.Left = defaultlit(n.Left, nil)
-		n.Left = implicitstar(n.Left)
-		l := n.Left
-		t := l.Type
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		n.SetLeft(defaultlit(n.Left(), nil))
+		n.SetLeft(implicitstar(n.Left()))
+		l := n.Left()
+		t := l.Type()
 		if t == nil {
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
 		var ok bool
-		if n.Op == ir.OLEN {
+		if n.Op() == ir.OLEN {
 			ok = okforlen[t.Etype]
 		} else {
 			ok = okforcap[t.Etype]
 		}
 		if !ok {
-			base.Errorf("invalid argument %L for %v", l, n.Op)
-			n.Type = nil
+			base.Errorf("invalid argument %L for %v", l, n.Op())
+			n.SetType(nil)
 			return n
 		}
 
-		n.Type = types.Types[types.TINT]
+		n.SetType(types.Types[types.TINT])
 
 	case ir.OREAL, ir.OIMAG:
 		ok |= ctxExpr
-		if !onearg(n, "%v", n.Op) {
-			n.Type = nil
+		if !onearg(n, "%v", n.Op()) {
+			n.SetType(nil)
 			return n
 		}
 
-		n.Left = typecheck(n.Left, ctxExpr)
-		l := n.Left
-		t := l.Type
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		l := n.Left()
+		t := l.Type()
 		if t == nil {
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
 		// Determine result type.
 		switch t.Etype {
 		case types.TIDEAL:
-			n.Type = types.UntypedFloat
+			n.SetType(types.UntypedFloat)
 		case types.TCOMPLEX64:
-			n.Type = types.Types[types.TFLOAT32]
+			n.SetType(types.Types[types.TFLOAT32])
 		case types.TCOMPLEX128:
-			n.Type = types.Types[types.TFLOAT64]
+			n.SetType(types.Types[types.TFLOAT64])
 		default:
-			base.Errorf("invalid argument %L for %v", l, n.Op)
-			n.Type = nil
+			base.Errorf("invalid argument %L for %v", l, n.Op())
+			n.SetType(nil)
 			return n
 		}
 
@@ -1476,34 +1476,34 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 		ok |= ctxExpr
 		typecheckargs(n)
 		if !twoarg(n) {
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
-		l := n.Left
-		r := n.Right
-		if l.Type == nil || r.Type == nil {
-			n.Type = nil
+		l := n.Left()
+		r := n.Right()
+		if l.Type() == nil || r.Type() == nil {
+			n.SetType(nil)
 			return n
 		}
 		l, r = defaultlit2(l, r, false)
-		if l.Type == nil || r.Type == nil {
-			n.Type = nil
+		if l.Type() == nil || r.Type() == nil {
+			n.SetType(nil)
 			return n
 		}
-		n.Left = l
-		n.Right = r
+		n.SetLeft(l)
+		n.SetRight(r)
 
-		if !types.Identical(l.Type, r.Type) {
-			base.Errorf("invalid operation: %v (mismatched types %v and %v)", n, l.Type, r.Type)
-			n.Type = nil
+		if !types.Identical(l.Type(), r.Type()) {
+			base.Errorf("invalid operation: %v (mismatched types %v and %v)", n, l.Type(), r.Type())
+			n.SetType(nil)
 			return n
 		}
 
 		var t *types.Type
-		switch l.Type.Etype {
+		switch l.Type().Etype {
 		default:
-			base.Errorf("invalid operation: %v (arguments have type %v, expected floating-point)", n, l.Type)
-			n.Type = nil
+			base.Errorf("invalid operation: %v (arguments have type %v, expected floating-point)", n, l.Type())
+			n.SetType(nil)
 			return n
 
 		case types.TIDEAL:
@@ -1515,30 +1515,30 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 		case types.TFLOAT64:
 			t = types.Types[types.TCOMPLEX128]
 		}
-		n.Type = t
+		n.SetType(t)
 
 	case ir.OCLOSE:
-		if !onearg(n, "%v", n.Op) {
-			n.Type = nil
+		if !onearg(n, "%v", n.Op()) {
+			n.SetType(nil)
 			return n
 		}
-		n.Left = typecheck(n.Left, ctxExpr)
-		n.Left = defaultlit(n.Left, nil)
-		l := n.Left
-		t := l.Type
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		n.SetLeft(defaultlit(n.Left(), nil))
+		l := n.Left()
+		t := l.Type()
 		if t == nil {
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 		if !t.IsChan() {
 			base.Errorf("invalid operation: %v (non-chan type %v)", n, t)
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
 		if !t.ChanDir().CanSend() {
 			base.Errorf("invalid operation: %v (cannot close receive-only channel)", n)
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
@@ -1547,78 +1547,78 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 	case ir.ODELETE:
 		ok |= ctxStmt
 		typecheckargs(n)
-		args := n.List
+		args := n.List()
 		if args.Len() == 0 {
 			base.Errorf("missing arguments to delete")
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
 		if args.Len() == 1 {
 			base.Errorf("missing second (key) argument to delete")
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
 		if args.Len() != 2 {
 			base.Errorf("too many arguments to delete")
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
 		l := args.First()
 		r := args.Second()
-		if l.Type != nil && !l.Type.IsMap() {
-			base.Errorf("first argument to delete must be map; have %L", l.Type)
-			n.Type = nil
+		if l.Type() != nil && !l.Type().IsMap() {
+			base.Errorf("first argument to delete must be map; have %L", l.Type())
+			n.SetType(nil)
 			return n
 		}
 
-		args.SetSecond(assignconv(r, l.Type.Key(), "delete"))
+		args.SetSecond(assignconv(r, l.Type().Key(), "delete"))
 
 	case ir.OAPPEND:
 		ok |= ctxExpr
 		typecheckargs(n)
-		args := n.List
+		args := n.List()
 		if args.Len() == 0 {
 			base.Errorf("missing arguments to append")
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
-		t := args.First().Type
+		t := args.First().Type()
 		if t == nil {
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
-		n.Type = t
+		n.SetType(t)
 		if !t.IsSlice() {
 			if ir.IsNil(args.First()) {
 				base.Errorf("first argument to append must be typed slice; have untyped nil")
-				n.Type = nil
+				n.SetType(nil)
 				return n
 			}
 
 			base.Errorf("first argument to append must be slice; have %L", t)
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
 		if n.IsDDD() {
 			if args.Len() == 1 {
 				base.Errorf("cannot use ... on first argument to append")
-				n.Type = nil
+				n.SetType(nil)
 				return n
 			}
 
 			if args.Len() != 2 {
 				base.Errorf("too many arguments to append")
-				n.Type = nil
+				n.SetType(nil)
 				return n
 			}
 
-			if t.Elem().IsKind(types.TUINT8) && args.Second().Type.IsString() {
+			if t.Elem().IsKind(types.TUINT8) && args.Second().Type().IsString() {
 				args.SetSecond(defaultlit(args.Second(), types.Types[types.TSTRING]))
 				break
 			}
@@ -1629,90 +1629,90 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 
 		as := args.Slice()[1:]
 		for i, n := range as {
-			if n.Type == nil {
+			if n.Type() == nil {
 				continue
 			}
 			as[i] = assignconv(n, t.Elem(), "append")
-			checkwidth(as[i].Type) // ensure width is calculated for backend
+			checkwidth(as[i].Type()) // ensure width is calculated for backend
 		}
 
 	case ir.OCOPY:
 		ok |= ctxStmt | ctxExpr
 		typecheckargs(n)
 		if !twoarg(n) {
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
-		n.Type = types.Types[types.TINT]
-		if n.Left.Type == nil || n.Right.Type == nil {
-			n.Type = nil
+		n.SetType(types.Types[types.TINT])
+		if n.Left().Type() == nil || n.Right().Type() == nil {
+			n.SetType(nil)
 			return n
 		}
-		n.Left = defaultlit(n.Left, nil)
-		n.Right = defaultlit(n.Right, nil)
-		if n.Left.Type == nil || n.Right.Type == nil {
-			n.Type = nil
+		n.SetLeft(defaultlit(n.Left(), nil))
+		n.SetRight(defaultlit(n.Right(), nil))
+		if n.Left().Type() == nil || n.Right().Type() == nil {
+			n.SetType(nil)
 			return n
 		}
 
 		// copy([]byte, string)
-		if n.Left.Type.IsSlice() && n.Right.Type.IsString() {
-			if types.Identical(n.Left.Type.Elem(), types.Bytetype) {
+		if n.Left().Type().IsSlice() && n.Right().Type().IsString() {
+			if types.Identical(n.Left().Type().Elem(), types.Bytetype) {
 				break
 			}
-			base.Errorf("arguments to copy have different element types: %L and string", n.Left.Type)
-			n.Type = nil
+			base.Errorf("arguments to copy have different element types: %L and string", n.Left().Type())
+			n.SetType(nil)
 			return n
 		}
 
-		if !n.Left.Type.IsSlice() || !n.Right.Type.IsSlice() {
-			if !n.Left.Type.IsSlice() && !n.Right.Type.IsSlice() {
-				base.Errorf("arguments to copy must be slices; have %L, %L", n.Left.Type, n.Right.Type)
-			} else if !n.Left.Type.IsSlice() {
-				base.Errorf("first argument to copy should be slice; have %L", n.Left.Type)
+		if !n.Left().Type().IsSlice() || !n.Right().Type().IsSlice() {
+			if !n.Left().Type().IsSlice() && !n.Right().Type().IsSlice() {
+				base.Errorf("arguments to copy must be slices; have %L, %L", n.Left().Type(), n.Right().Type())
+			} else if !n.Left().Type().IsSlice() {
+				base.Errorf("first argument to copy should be slice; have %L", n.Left().Type())
 			} else {
-				base.Errorf("second argument to copy should be slice or string; have %L", n.Right.Type)
+				base.Errorf("second argument to copy should be slice or string; have %L", n.Right().Type())
 			}
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
-		if !types.Identical(n.Left.Type.Elem(), n.Right.Type.Elem()) {
-			base.Errorf("arguments to copy have different element types: %L and %L", n.Left.Type, n.Right.Type)
-			n.Type = nil
+		if !types.Identical(n.Left().Type().Elem(), n.Right().Type().Elem()) {
+			base.Errorf("arguments to copy have different element types: %L and %L", n.Left().Type(), n.Right().Type())
+			n.SetType(nil)
 			return n
 		}
 
 	case ir.OCONV:
 		ok |= ctxExpr
-		checkwidth(n.Type) // ensure width is calculated for backend
-		n.Left = typecheck(n.Left, ctxExpr)
-		n.Left = convlit1(n.Left, n.Type, true, nil)
-		t := n.Left.Type
-		if t == nil || n.Type == nil {
-			n.Type = nil
-			return n
-		}
-		op, why := convertop(n.Left.Op == ir.OLITERAL, t, n.Type)
-		n.Op = op
-		if n.Op == ir.OXXX {
-			if !n.Diag() && !n.Type.Broke() && !n.Left.Diag() {
-				base.Errorf("cannot convert %L to type %v%s", n.Left, n.Type, why)
+		checkwidth(n.Type()) // ensure width is calculated for backend
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		n.SetLeft(convlit1(n.Left(), n.Type(), true, nil))
+		t := n.Left().Type()
+		if t == nil || n.Type() == nil {
+			n.SetType(nil)
+			return n
+		}
+		op, why := convertop(n.Left().Op() == ir.OLITERAL, t, n.Type())
+		n.SetOp(op)
+		if n.Op() == ir.OXXX {
+			if !n.Diag() && !n.Type().Broke() && !n.Left().Diag() {
+				base.Errorf("cannot convert %L to type %v%s", n.Left(), n.Type(), why)
 				n.SetDiag(true)
 			}
-			n.Op = ir.OCONV
-			n.Type = nil
+			n.SetOp(ir.OCONV)
+			n.SetType(nil)
 			return n
 		}
 
-		switch n.Op {
+		switch n.Op() {
 		case ir.OCONVNOP:
-			if t.Etype == n.Type.Etype {
+			if t.Etype == n.Type().Etype {
 				switch t.Etype {
 				case types.TFLOAT32, types.TFLOAT64, types.TCOMPLEX64, types.TCOMPLEX128:
 					// Floating point casts imply rounding and
 					// so the conversion must be kept.
-					n.Op = ir.OCONV
+					n.SetOp(ir.OCONV)
 				}
 			}
 
@@ -1722,26 +1722,26 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 			break
 
 		case ir.OSTR2RUNES:
-			if n.Left.Op == ir.OLITERAL {
+			if n.Left().Op() == ir.OLITERAL {
 				n = stringtoruneslit(n)
 			}
 		}
 
 	case ir.OMAKE:
 		ok |= ctxExpr
-		args := n.List.Slice()
+		args := n.List().Slice()
 		if len(args) == 0 {
 			base.Errorf("missing argument to make")
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
-		n.List.Set(nil)
+		n.PtrList().Set(nil)
 		l := args[0]
 		l = typecheck(l, ctxType)
-		t := l.Type
+		t := l.Type()
 		if t == nil {
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
@@ -1749,13 +1749,13 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 		switch t.Etype {
 		default:
 			base.Errorf("cannot make type %v", t)
-			n.Type = nil
+			n.SetType(nil)
 			return n
 
 		case types.TSLICE:
 			if i >= len(args) {
 				base.Errorf("missing len argument to make(%v)", t)
-				n.Type = nil
+				n.SetType(nil)
 				return n
 			}
 
@@ -1769,23 +1769,23 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 				r = typecheck(r, ctxExpr)
 			}
 
-			if l.Type == nil || (r != nil && r.Type == nil) {
-				n.Type = nil
+			if l.Type() == nil || (r != nil && r.Type() == nil) {
+				n.SetType(nil)
 				return n
 			}
 			if !checkmake(t, "len", &l) || r != nil && !checkmake(t, "cap", &r) {
-				n.Type = nil
+				n.SetType(nil)
 				return n
 			}
 			if ir.IsConst(l, constant.Int) && r != nil && ir.IsConst(r, constant.Int) && constant.Compare(l.Val(), token.GTR, r.Val()) {
 				base.Errorf("len larger than cap in make(%v)", t)
-				n.Type = nil
+				n.SetType(nil)
 				return n
 			}
 
-			n.Left = l
-			n.Right = r
-			n.Op = ir.OMAKESLICE
+			n.SetLeft(l)
+			n.SetRight(r)
+			n.SetOp(ir.OMAKESLICE)
 
 		case types.TMAP:
 			if i < len(args) {
@@ -1793,19 +1793,19 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 				i++
 				l = typecheck(l, ctxExpr)
 				l = defaultlit(l, types.Types[types.TINT])
-				if l.Type == nil {
-					n.Type = nil
+				if l.Type() == nil {
+					n.SetType(nil)
 					return n
 				}
 				if !checkmake(t, "size", &l) {
-					n.Type = nil
+					n.SetType(nil)
 					return n
 				}
-				n.Left = l
+				n.SetLeft(l)
 			} else {
-				n.Left = nodintconst(0)
+				n.SetLeft(nodintconst(0))
 			}
-			n.Op = ir.OMAKEMAP
+			n.SetOp(ir.OMAKEMAP)
 
 		case types.TCHAN:
 			l = nil
@@ -1814,59 +1814,59 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 				i++
 				l = typecheck(l, ctxExpr)
 				l = defaultlit(l, types.Types[types.TINT])
-				if l.Type == nil {
-					n.Type = nil
+				if l.Type() == nil {
+					n.SetType(nil)
 					return n
 				}
 				if !checkmake(t, "buffer", &l) {
-					n.Type = nil
+					n.SetType(nil)
 					return n
 				}
-				n.Left = l
+				n.SetLeft(l)
 			} else {
-				n.Left = nodintconst(0)
+				n.SetLeft(nodintconst(0))
 			}
-			n.Op = ir.OMAKECHAN
+			n.SetOp(ir.OMAKECHAN)
 		}
 
 		if i < len(args) {
 			base.Errorf("too many arguments to make(%v)", t)
-			n.Op = ir.OMAKE
-			n.Type = nil
+			n.SetOp(ir.OMAKE)
+			n.SetType(nil)
 			return n
 		}
 
-		n.Type = t
+		n.SetType(t)
 
 	case ir.ONEW:
 		ok |= ctxExpr
-		args := n.List
+		args := n.List()
 		if args.Len() == 0 {
 			base.Errorf("missing argument to new")
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
 		l := args.First()
 		l = typecheck(l, ctxType)
-		t := l.Type
+		t := l.Type()
 		if t == nil {
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 		if args.Len() > 1 {
 			base.Errorf("too many arguments to new(%v)", t)
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
-		n.Left = l
-		n.Type = types.NewPtr(t)
+		n.SetLeft(l)
+		n.SetType(types.NewPtr(t))
 
 	case ir.OPRINT, ir.OPRINTN:
 		ok |= ctxStmt
 		typecheckargs(n)
-		ls := n.List.Slice()
+		ls := n.List().Slice()
 		for i1, n1 := range ls {
 			// Special case for print: int constant is int64, not int.
 			if ir.IsConst(n1, constant.Int) {
@@ -1879,45 +1879,45 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 	case ir.OPANIC:
 		ok |= ctxStmt
 		if !onearg(n, "panic") {
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
-		n.Left = typecheck(n.Left, ctxExpr)
-		n.Left = defaultlit(n.Left, types.Types[types.TINTER])
-		if n.Left.Type == nil {
-			n.Type = nil
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		n.SetLeft(defaultlit(n.Left(), types.Types[types.TINTER]))
+		if n.Left().Type() == nil {
+			n.SetType(nil)
 			return n
 		}
 
 	case ir.ORECOVER:
 		ok |= ctxExpr | ctxStmt
-		if n.List.Len() != 0 {
+		if n.List().Len() != 0 {
 			base.Errorf("too many arguments to recover")
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
-		n.Type = types.Types[types.TINTER]
+		n.SetType(types.Types[types.TINTER])
 
 	case ir.OCLOSURE:
 		ok |= ctxExpr
 		typecheckclosure(n, top)
-		if n.Type == nil {
+		if n.Type() == nil {
 			return n
 		}
 
 	case ir.OITAB:
 		ok |= ctxExpr
-		n.Left = typecheck(n.Left, ctxExpr)
-		t := n.Left.Type
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		t := n.Left().Type()
 		if t == nil {
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 		if !t.IsInterface() {
 			base.Fatalf("OITAB of %v", t)
 		}
-		n.Type = types.NewPtr(types.Types[types.TUINTPTR])
+		n.SetType(types.NewPtr(types.Types[types.TUINTPTR]))
 
 	case ir.OIDATA:
 		// Whoever creates the OIDATA node must know a priori the concrete type at that moment,
@@ -1926,19 +1926,19 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 
 	case ir.OSPTR:
 		ok |= ctxExpr
-		n.Left = typecheck(n.Left, ctxExpr)
-		t := n.Left.Type
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		t := n.Left().Type()
 		if t == nil {
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 		if !t.IsSlice() && !t.IsString() {
 			base.Fatalf("OSPTR of %v", t)
 		}
 		if t.IsString() {
-			n.Type = types.NewPtr(types.Types[types.TUINT8])
+			n.SetType(types.NewPtr(types.Types[types.TUINT8]))
 		} else {
-			n.Type = types.NewPtr(t.Elem())
+			n.SetType(types.NewPtr(t.Elem()))
 		}
 
 	case ir.OCLOSUREVAR:
@@ -1946,12 +1946,12 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 
 	case ir.OCFUNC:
 		ok |= ctxExpr
-		n.Left = typecheck(n.Left, ctxExpr)
-		n.Type = types.Types[types.TUINTPTR]
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		n.SetType(types.Types[types.TUINTPTR])
 
 	case ir.OCONVNOP:
 		ok |= ctxExpr
-		n.Left = typecheck(n.Left, ctxExpr)
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
 
 	// statements
 	case ir.OAS:
@@ -1960,8 +1960,8 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 		typecheckas(n)
 
 		// Code that creates temps does not bother to set defn, so do it here.
-		if n.Left.Op == ir.ONAME && ir.IsAutoTmp(n.Left) {
-			n.Left.Name.Defn = n
+		if n.Left().Op() == ir.ONAME && ir.IsAutoTmp(n.Left()) {
+			n.Left().Name().Defn = n
 		}
 
 	case ir.OAS2:
@@ -1981,72 +1981,72 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 	case ir.OLABEL:
 		ok |= ctxStmt
 		decldepth++
-		if n.Sym.IsBlank() {
+		if n.Sym().IsBlank() {
 			// Empty identifier is valid but useless.
 			// Eliminate now to simplify life later.
 			// See issues 7538, 11589, 11593.
-			n.Op = ir.OEMPTY
-			n.Left = nil
+			n.SetOp(ir.OEMPTY)
+			n.SetLeft(nil)
 		}
 
 	case ir.ODEFER:
 		ok |= ctxStmt
-		n.Left = typecheck(n.Left, ctxStmt|ctxExpr)
-		if !n.Left.Diag() {
+		n.SetLeft(typecheck(n.Left(), ctxStmt|ctxExpr))
+		if !n.Left().Diag() {
 			checkdefergo(n)
 		}
 
 	case ir.OGO:
 		ok |= ctxStmt
-		n.Left = typecheck(n.Left, ctxStmt|ctxExpr)
+		n.SetLeft(typecheck(n.Left(), ctxStmt|ctxExpr))
 		checkdefergo(n)
 
 	case ir.OFOR, ir.OFORUNTIL:
 		ok |= ctxStmt
-		typecheckslice(n.Ninit.Slice(), ctxStmt)
+		typecheckslice(n.Init().Slice(), ctxStmt)
 		decldepth++
-		n.Left = typecheck(n.Left, ctxExpr)
-		n.Left = defaultlit(n.Left, nil)
-		if n.Left != nil {
-			t := n.Left.Type
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		n.SetLeft(defaultlit(n.Left(), nil))
+		if n.Left() != nil {
+			t := n.Left().Type()
 			if t != nil && !t.IsBoolean() {
-				base.Errorf("non-bool %L used as for condition", n.Left)
+				base.Errorf("non-bool %L used as for condition", n.Left())
 			}
 		}
-		n.Right = typecheck(n.Right, ctxStmt)
-		if n.Op == ir.OFORUNTIL {
-			typecheckslice(n.List.Slice(), ctxStmt)
+		n.SetRight(typecheck(n.Right(), ctxStmt))
+		if n.Op() == ir.OFORUNTIL {
+			typecheckslice(n.List().Slice(), ctxStmt)
 		}
-		typecheckslice(n.Nbody.Slice(), ctxStmt)
+		typecheckslice(n.Body().Slice(), ctxStmt)
 		decldepth--
 
 	case ir.OIF:
 		ok |= ctxStmt
-		typecheckslice(n.Ninit.Slice(), ctxStmt)
-		n.Left = typecheck(n.Left, ctxExpr)
-		n.Left = defaultlit(n.Left, nil)
-		if n.Left != nil {
-			t := n.Left.Type
+		typecheckslice(n.Init().Slice(), ctxStmt)
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		n.SetLeft(defaultlit(n.Left(), nil))
+		if n.Left() != nil {
+			t := n.Left().Type()
 			if t != nil && !t.IsBoolean() {
-				base.Errorf("non-bool %L used as if condition", n.Left)
+				base.Errorf("non-bool %L used as if condition", n.Left())
 			}
 		}
-		typecheckslice(n.Nbody.Slice(), ctxStmt)
-		typecheckslice(n.Rlist.Slice(), ctxStmt)
+		typecheckslice(n.Body().Slice(), ctxStmt)
+		typecheckslice(n.Rlist().Slice(), ctxStmt)
 
 	case ir.ORETURN:
 		ok |= ctxStmt
 		typecheckargs(n)
 		if Curfn == nil {
 			base.Errorf("return outside function")
-			n.Type = nil
+			n.SetType(nil)
 			return n
 		}
 
-		if Curfn.Type.FuncType().Outnamed && n.List.Len() == 0 {
+		if Curfn.Type().FuncType().Outnamed && n.List().Len() == 0 {
 			break
 		}
-		typecheckaste(ir.ORETURN, nil, false, Curfn.Type.Results(), n.List, func() string { return "return argument" })
+		typecheckaste(ir.ORETURN, nil, false, Curfn.Type().Results(), n.List(), func() string { return "return argument" })
 
 	case ir.ORETJMP:
 		ok |= ctxStmt
@@ -2065,7 +2065,7 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 
 	case ir.OTYPESW:
 		base.Errorf("use of .(type) outside type switch")
-		n.Type = nil
+		n.SetType(nil)
 		return n
 
 	case ir.ODCLFUNC:
@@ -2074,16 +2074,16 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 
 	case ir.ODCLCONST:
 		ok |= ctxStmt
-		n.Left = typecheck(n.Left, ctxExpr)
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
 
 	case ir.ODCLTYPE:
 		ok |= ctxStmt
-		n.Left = typecheck(n.Left, ctxType)
-		checkwidth(n.Left.Type)
+		n.SetLeft(typecheck(n.Left(), ctxType))
+		checkwidth(n.Left().Type())
 	}
 
-	t := n.Type
-	if t != nil && !t.IsFuncArgStruct() && n.Op != ir.OTYPE {
+	t := n.Type()
+	if t != nil && !t.IsFuncArgStruct() && n.Op() != ir.OTYPE {
 		switch t.Etype {
 		case types.TFUNC, // might have TANY; wait until it's called
 			types.TANY, types.TFORW, types.TIDEAL, types.TNIL, types.TBLANK:
@@ -2095,24 +2095,24 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 	}
 
 	n = evalConst(n)
-	if n.Op == ir.OTYPE && top&ctxType == 0 {
-		if !n.Type.Broke() {
-			base.Errorf("type %v is not an expression", n.Type)
+	if n.Op() == ir.OTYPE && top&ctxType == 0 {
+		if !n.Type().Broke() {
+			base.Errorf("type %v is not an expression", n.Type())
 		}
-		n.Type = nil
+		n.SetType(nil)
 		return n
 	}
 
-	if top&(ctxExpr|ctxType) == ctxType && n.Op != ir.OTYPE {
+	if top&(ctxExpr|ctxType) == ctxType && n.Op() != ir.OTYPE {
 		base.Errorf("%v is not a type", n)
-		n.Type = nil
+		n.SetType(nil)
 		return n
 	}
 
 	// TODO(rsc): simplify
 	if (top&(ctxCallee|ctxExpr|ctxType) != 0) && top&ctxStmt == 0 && ok&(ctxExpr|ctxType|ctxCallee) == 0 {
 		base.Errorf("%v used as value", n)
-		n.Type = nil
+		n.SetType(nil)
 		return n
 	}
 
@@ -2122,7 +2122,7 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 			n.SetDiag(true)
 		}
 
-		n.Type = nil
+		n.SetType(nil)
 		return n
 	}
 
@@ -2130,13 +2130,13 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 }
 
 func typecheckargs(n *ir.Node) {
-	if n.List.Len() != 1 || n.IsDDD() {
-		typecheckslice(n.List.Slice(), ctxExpr)
+	if n.List().Len() != 1 || n.IsDDD() {
+		typecheckslice(n.List().Slice(), ctxExpr)
 		return
 	}
 
-	typecheckslice(n.List.Slice(), ctxExpr|ctxMultiOK)
-	t := n.List.First().Type
+	typecheckslice(n.List().Slice(), ctxExpr|ctxMultiOK)
+	t := n.List().First().Type()
 	if t == nil || !t.IsFuncArgStruct() {
 		return
 	}
@@ -2144,12 +2144,12 @@ func typecheckargs(n *ir.Node) {
 	// Rewrite f(g()) into t1, t2, ... = g(); f(t1, t2, ...).
 
 	// Save n as n.Orig for fmt.go.
-	if n.Orig == n {
-		n.Orig = ir.SepCopy(n)
+	if n.Orig() == n {
+		n.SetOrig(ir.SepCopy(n))
 	}
 
 	as := ir.Nod(ir.OAS2, nil, nil)
-	as.Rlist.AppendNodes(&n.List)
+	as.PtrRlist().AppendNodes(n.PtrList())
 
 	// If we're outside of function context, then this call will
 	// be executed during the generated init function. However,
@@ -2162,20 +2162,20 @@ func typecheckargs(n *ir.Node) {
 	}
 	for _, f := range t.FieldSlice() {
 		t := temp(f.Type)
-		as.Ninit.Append(ir.Nod(ir.ODCL, t, nil))
-		as.List.Append(t)
-		n.List.Append(t)
+		as.PtrInit().Append(ir.Nod(ir.ODCL, t, nil))
+		as.PtrList().Append(t)
+		n.PtrList().Append(t)
 	}
 	if static {
 		Curfn = nil
 	}
 
 	as = typecheck(as, ctxStmt)
-	n.Ninit.Append(as)
+	n.PtrInit().Append(as)
 }
 
 func checksliceindex(l *ir.Node, r *ir.Node, tp *types.Type) bool {
-	t := r.Type
+	t := r.Type()
 	if t == nil {
 		return false
 	}
@@ -2184,7 +2184,7 @@ func checksliceindex(l *ir.Node, r *ir.Node, tp *types.Type) bool {
 		return false
 	}
 
-	if r.Op == ir.OLITERAL {
+	if r.Op() == ir.OLITERAL {
 		x := r.Val()
 		if constant.Sign(x) < 0 {
 			base.Errorf("invalid slice index %v (index must be non-negative)", r)
@@ -2205,7 +2205,7 @@ func checksliceindex(l *ir.Node, r *ir.Node, tp *types.Type) bool {
 }
 
 func checksliceconst(lo *ir.Node, hi *ir.Node) bool {
-	if lo != nil && hi != nil && lo.Op == ir.OLITERAL && hi.Op == ir.OLITERAL && constant.Compare(lo.Val(), token.GTR, hi.Val()) {
+	if lo != nil && hi != nil && lo.Op() == ir.OLITERAL && hi.Op() == ir.OLITERAL && constant.Compare(lo.Val(), token.GTR, hi.Val()) {
 		base.Errorf("invalid slice index: %v > %v", lo, hi)
 		return false
 	}
@@ -2215,11 +2215,11 @@ func checksliceconst(lo *ir.Node, hi *ir.Node) bool {
 
 func checkdefergo(n *ir.Node) {
 	what := "defer"
-	if n.Op == ir.OGO {
+	if n.Op() == ir.OGO {
 		what = "go"
 	}
 
-	switch n.Left.Op {
+	switch n.Left().Op() {
 	// ok
 	case ir.OCALLINTER,
 		ir.OCALLMETH,
@@ -2245,16 +2245,16 @@ func checkdefergo(n *ir.Node) {
 		ir.ONEW,
 		ir.OREAL,
 		ir.OLITERAL: // conversion or unsafe.Alignof, Offsetof, Sizeof
-		if n.Left.Orig != nil && n.Left.Orig.Op == ir.OCONV {
+		if n.Left().Orig() != nil && n.Left().Orig().Op() == ir.OCONV {
 			break
 		}
-		base.ErrorfAt(n.Pos, "%s discards result of %v", what, n.Left)
+		base.ErrorfAt(n.Pos(), "%s discards result of %v", what, n.Left())
 		return
 	}
 
 	// type is broken or missing, most likely a method call on a broken type
 	// we will warn about the broken type elsewhere. no need to emit a potentially confusing error
-	if n.Left.Type == nil || n.Left.Type.Broke() {
+	if n.Left().Type() == nil || n.Left().Type().Broke() {
 		return
 	}
 
@@ -2262,7 +2262,7 @@ func checkdefergo(n *ir.Node) {
 		// The syntax made sure it was a call, so this must be
 		// a conversion.
 		n.SetDiag(true)
-		base.ErrorfAt(n.Pos, "%s requires function call, not conversion", what)
+		base.ErrorfAt(n.Pos(), "%s requires function call, not conversion", what)
 	}
 }
 
@@ -2270,7 +2270,7 @@ func checkdefergo(n *ir.Node) {
 // 	n.Left = implicitstar(n.Left)
 func implicitstar(n *ir.Node) *ir.Node {
 	// insert implicit * if needed for fixed array
-	t := n.Type
+	t := n.Type()
 	if t == nil || !t.IsPtr() {
 		return n
 	}
@@ -2288,43 +2288,43 @@ func implicitstar(n *ir.Node) *ir.Node {
 }
 
 func onearg(n *ir.Node, f string, args ...interface{}) bool {
-	if n.Left != nil {
+	if n.Left() != nil {
 		return true
 	}
-	if n.List.Len() == 0 {
+	if n.List().Len() == 0 {
 		p := fmt.Sprintf(f, args...)
 		base.Errorf("missing argument to %s: %v", p, n)
 		return false
 	}
 
-	if n.List.Len() > 1 {
+	if n.List().Len() > 1 {
 		p := fmt.Sprintf(f, args...)
 		base.Errorf("too many arguments to %s: %v", p, n)
-		n.Left = n.List.First()
-		n.List.Set(nil)
+		n.SetLeft(n.List().First())
+		n.PtrList().Set(nil)
 		return false
 	}
 
-	n.Left = n.List.First()
-	n.List.Set(nil)
+	n.SetLeft(n.List().First())
+	n.PtrList().Set(nil)
 	return true
 }
 
 func twoarg(n *ir.Node) bool {
-	if n.Left != nil {
+	if n.Left() != nil {
 		return true
 	}
-	if n.List.Len() != 2 {
-		if n.List.Len() < 2 {
+	if n.List().Len() != 2 {
+		if n.List().Len() < 2 {
 			base.Errorf("not enough arguments in call to %v", n)
 		} else {
 			base.Errorf("too many arguments in call to %v", n)
 		}
 		return false
 	}
-	n.Left = n.List.First()
-	n.Right = n.List.Second()
-	n.List.Set(nil)
+	n.SetLeft(n.List().First())
+	n.SetRight(n.List().Second())
+	n.PtrList().Set(nil)
 	return true
 }
 
@@ -2364,7 +2364,7 @@ func typecheckMethodExpr(n *ir.Node) (res *ir.Node) {
 		defer tracePrint("typecheckMethodExpr", n)(&res)
 	}
 
-	t := n.Left.Type
+	t := n.Left().Type()
 
 	// Compute the method set for t.
 	var ms *types.Fields
@@ -2373,8 +2373,8 @@ func typecheckMethodExpr(n *ir.Node) (res *ir.Node) {
 	} else {
 		mt := methtype(t)
 		if mt == nil {
-			base.Errorf("%v undefined (type %v has no method %v)", n, t, n.Sym)
-			n.Type = nil
+			base.Errorf("%v undefined (type %v has no method %v)", n, t, n.Sym())
+			n.SetType(nil)
 			return n
 		}
 		expandmeth(mt)
@@ -2392,7 +2392,7 @@ func typecheckMethodExpr(n *ir.Node) (res *ir.Node) {
 		}
 	}
 
-	s := n.Sym
+	s := n.Sym()
 	m := lookdot1(n, s, t, ms, 0)
 	if m == nil {
 		if lookdot1(n, s, t, ms, 1) != nil {
@@ -2402,31 +2402,31 @@ func typecheckMethodExpr(n *ir.Node) (res *ir.Node) {
 		} else {
 			base.Errorf("%v undefined (type %v has no method %v)", n, t, s)
 		}
-		n.Type = nil
+		n.SetType(nil)
 		return n
 	}
 
 	if !isMethodApplicable(t, m) {
 		base.Errorf("invalid method expression %v (needs pointer receiver: (*%v).%S)", n, t, s)
-		n.Type = nil
+		n.SetType(nil)
 		return n
 	}
 
-	n.Op = ir.OMETHEXPR
-	if n.Name == nil {
-		n.Name = new(ir.Name)
+	n.SetOp(ir.OMETHEXPR)
+	if n.Name() == nil {
+		n.SetName(new(ir.Name))
 	}
-	n.Right = NewName(n.Sym)
-	n.Sym = methodSym(t, n.Sym)
-	n.Type = methodfunc(m.Type, n.Left.Type)
-	n.Xoffset = 0
+	n.SetRight(NewName(n.Sym()))
+	n.SetSym(methodSym(t, n.Sym()))
+	n.SetType(methodfunc(m.Type, n.Left().Type()))
+	n.SetOffset(0)
 	n.SetClass(ir.PFUNC)
 	n.SetOpt(m)
 	// methodSym already marked n.Sym as a function.
 
 	// Issue 25065. Make sure that we emit the symbol for a local method.
 	if base.Ctxt.Flag_dynlink && !inimport && (t.Sym == nil || t.Sym.Pkg == ir.LocalPkg) {
-		makefuncsym(n.Sym)
+		makefuncsym(n.Sym())
 	}
 
 	return n
@@ -2448,7 +2448,7 @@ func derefall(t *types.Type) *types.Type {
 }
 
 func lookdot(n *ir.Node, t *types.Type, dostrcmp int) *types.Field {
-	s := n.Sym
+	s := n.Sym()
 
 	dowidth(t)
 	var f1 *types.Field
@@ -2457,7 +2457,7 @@ func lookdot(n *ir.Node, t *types.Type, dostrcmp int) *types.Field {
 	}
 
 	var f2 *types.Field
-	if n.Left.Type == t || n.Left.Type.Sym == nil {
+	if n.Left().Type() == t || n.Left().Type().Sym == nil {
 		mt := methtype(t)
 		if mt != nil {
 			f2 = lookdot1(n, s, mt, mt.Methods(), dostrcmp)
@@ -2470,21 +2470,21 @@ func lookdot(n *ir.Node, t *types.Type, dostrcmp int) *types.Field {
 			return f1
 		}
 		if f2 != nil {
-			base.Errorf("%v is both field and method", n.Sym)
+			base.Errorf("%v is both field and method", n.Sym())
 		}
 		if f1.Offset == types.BADWIDTH {
 			base.Fatalf("lookdot badwidth %v %p", f1, f1)
 		}
-		n.Xoffset = f1.Offset
-		n.Type = f1.Type
+		n.SetOffset(f1.Offset)
+		n.SetType(f1.Type)
 		if t.IsInterface() {
-			if n.Left.Type.IsPtr() {
-				n.Left = ir.Nod(ir.ODEREF, n.Left, nil) // implicitstar
-				n.Left.SetImplicit(true)
-				n.Left = typecheck(n.Left, ctxExpr)
+			if n.Left().Type().IsPtr() {
+				n.SetLeft(ir.Nod(ir.ODEREF, n.Left(), nil)) // implicitstar
+				n.Left().SetImplicit(true)
+				n.SetLeft(typecheck(n.Left(), ctxExpr))
 			}
 
-			n.Op = ir.ODOTINTER
+			n.SetOp(ir.ODOTINTER)
 		} else {
 			n.SetOpt(f1)
 		}
@@ -2497,29 +2497,29 @@ func lookdot(n *ir.Node, t *types.Type, dostrcmp int) *types.Field {
 			// Already in the process of diagnosing an error.
 			return f2
 		}
-		tt := n.Left.Type
+		tt := n.Left().Type()
 		dowidth(tt)
 		rcvr := f2.Type.Recv().Type
 		if !types.Identical(rcvr, tt) {
 			if rcvr.IsPtr() && types.Identical(rcvr.Elem(), tt) {
-				checklvalue(n.Left, "call pointer method on")
-				n.Left = ir.Nod(ir.OADDR, n.Left, nil)
-				n.Left.SetImplicit(true)
-				n.Left = typecheck(n.Left, ctxType|ctxExpr)
+				checklvalue(n.Left(), "call pointer method on")
+				n.SetLeft(ir.Nod(ir.OADDR, n.Left(), nil))
+				n.Left().SetImplicit(true)
+				n.SetLeft(typecheck(n.Left(), ctxType|ctxExpr))
 			} else if tt.IsPtr() && (!rcvr.IsPtr() || rcvr.IsPtr() && rcvr.Elem().NotInHeap()) && types.Identical(tt.Elem(), rcvr) {
-				n.Left = ir.Nod(ir.ODEREF, n.Left, nil)
-				n.Left.SetImplicit(true)
-				n.Left = typecheck(n.Left, ctxType|ctxExpr)
+				n.SetLeft(ir.Nod(ir.ODEREF, n.Left(), nil))
+				n.Left().SetImplicit(true)
+				n.SetLeft(typecheck(n.Left(), ctxType|ctxExpr))
 			} else if tt.IsPtr() && tt.Elem().IsPtr() && types.Identical(derefall(tt), derefall(rcvr)) {
-				base.Errorf("calling method %v with receiver %L requires explicit dereference", n.Sym, n.Left)
+				base.Errorf("calling method %v with receiver %L requires explicit dereference", n.Sym(), n.Left())
 				for tt.IsPtr() {
 					// Stop one level early for method with pointer receiver.
 					if rcvr.IsPtr() && !tt.Elem().IsPtr() {
 						break
 					}
-					n.Left = ir.Nod(ir.ODEREF, n.Left, nil)
-					n.Left.SetImplicit(true)
-					n.Left = typecheck(n.Left, ctxType|ctxExpr)
+					n.SetLeft(ir.Nod(ir.ODEREF, n.Left(), nil))
+					n.Left().SetImplicit(true)
+					n.SetLeft(typecheck(n.Left(), ctxType|ctxExpr))
 					tt = tt.Elem()
 				}
 			} else {
@@ -2528,22 +2528,22 @@ func lookdot(n *ir.Node, t *types.Type, dostrcmp int) *types.Field {
 		}
 
 		pll := n
-		ll := n.Left
-		for ll.Left != nil && (ll.Op == ir.ODOT || ll.Op == ir.ODOTPTR || ll.Op == ir.ODEREF) {
+		ll := n.Left()
+		for ll.Left() != nil && (ll.Op() == ir.ODOT || ll.Op() == ir.ODOTPTR || ll.Op() == ir.ODEREF) {
 			pll = ll
-			ll = ll.Left
+			ll = ll.Left()
 		}
-		if pll.Implicit() && ll.Type.IsPtr() && ll.Type.Sym != nil && ir.AsNode(ll.Type.Sym.Def) != nil && ir.AsNode(ll.Type.Sym.Def).Op == ir.OTYPE {
+		if pll.Implicit() && ll.Type().IsPtr() && ll.Type().Sym != nil && ir.AsNode(ll.Type().Sym.Def) != nil && ir.AsNode(ll.Type().Sym.Def).Op() == ir.OTYPE {
 			// It is invalid to automatically dereference a named pointer type when selecting a method.
 			// Make n.Left == ll to clarify error message.
-			n.Left = ll
+			n.SetLeft(ll)
 			return nil
 		}
 
-		n.Sym = methodSym(n.Left.Type, f2.Sym)
-		n.Xoffset = f2.Offset
-		n.Type = f2.Type
-		n.Op = ir.ODOTMETH
+		n.SetSym(methodSym(n.Left().Type(), f2.Sym))
+		n.SetOffset(f2.Offset)
+		n.SetType(f2.Type)
+		n.SetOp(ir.ODOTMETH)
 		n.SetOpt(f2)
 
 		return f2
@@ -2554,7 +2554,7 @@ func lookdot(n *ir.Node, t *types.Type, dostrcmp int) *types.Field {
 
 func nokeys(l ir.Nodes) bool {
 	for _, n := range l.Slice() {
-		if n.Op == ir.OKEY || n.Op == ir.OSTRUCTKEY {
+		if n.Op() == ir.OKEY || n.Op() == ir.OSTRUCTKEY {
 			return false
 		}
 	}
@@ -2625,7 +2625,7 @@ func typecheckaste(op ir.Op, call *ir.Node, isddd bool, tstruct *types.Type, nl
 				}
 				n = nl.Index(i)
 				setlineno(n)
-				if n.Type != nil {
+				if n.Type() != nil {
 					nl.SetIndex(i, assignconvfn(n, t, desc))
 				}
 				return
@@ -2635,7 +2635,7 @@ func typecheckaste(op ir.Op, call *ir.Node, isddd bool, tstruct *types.Type, nl
 			for ; i < nl.Len(); i++ {
 				n = nl.Index(i)
 				setlineno(n)
-				if n.Type != nil {
+				if n.Type() != nil {
 					nl.SetIndex(i, assignconvfn(n, t.Elem(), desc))
 				}
 			}
@@ -2647,7 +2647,7 @@ func typecheckaste(op ir.Op, call *ir.Node, isddd bool, tstruct *types.Type, nl
 		}
 		n = nl.Index(i)
 		setlineno(n)
-		if n.Type != nil {
+		if n.Type() != nil {
 			nl.SetIndex(i, assignconvfn(n, t, desc))
 		}
 		i++
@@ -2666,13 +2666,13 @@ func typecheckaste(op ir.Op, call *ir.Node, isddd bool, tstruct *types.Type, nl
 	return
 
 notenough:
-	if n == nil || (!n.Diag() && n.Type != nil) {
+	if n == nil || (!n.Diag() && n.Type() != nil) {
 		details := errorDetails(nl, tstruct, isddd)
 		if call != nil {
 			// call is the expression being called, not the overall call.
 			// Method expressions have the form T.M, and the compiler has
 			// rewritten those to ONAME nodes but left T in Left.
-			if call.Op == ir.OMETHEXPR {
+			if call.Op() == ir.OMETHEXPR {
 				base.Errorf("not enough arguments in call to method expression %v%s", call, details)
 			} else {
 				base.Errorf("not enough arguments in call to %v%s", call, details)
@@ -2703,7 +2703,7 @@ func errorDetails(nl ir.Nodes, tstruct *types.Type, isddd bool) string {
 	}
 	// If any node has an unknown type, suppress it as well
 	for _, n := range nl.Slice() {
-		if n.Type == nil {
+		if n.Type() == nil {
 			return ""
 		}
 	}
@@ -2747,7 +2747,7 @@ func fmtSignature(nl ir.Nodes, isddd bool) string {
 	var typeStrings []string
 	for i, n := range nl.Slice() {
 		isdddArg := isddd && i == nl.Len()-1
-		typeStrings = append(typeStrings, sigrepr(n.Type, isdddArg))
+		typeStrings = append(typeStrings, sigrepr(n.Type(), isdddArg))
 	}
 
 	return fmt.Sprintf("(%s)", strings.Join(typeStrings, ", "))
@@ -2775,20 +2775,20 @@ func iscomptype(t *types.Type) bool {
 // pushtype adds elided type information for composite literals if
 // appropriate, and returns the resulting expression.
 func pushtype(n *ir.Node, t *types.Type) *ir.Node {
-	if n == nil || n.Op != ir.OCOMPLIT || n.Right != nil {
+	if n == nil || n.Op() != ir.OCOMPLIT || n.Right() != nil {
 		return n
 	}
 
 	switch {
 	case iscomptype(t):
 		// For T, return T{...}.
-		n.Right = typenod(t)
+		n.SetRight(typenod(t))
 
 	case t.IsPtr() && iscomptype(t.Elem()):
 		// For *T, return &T{...}.
-		n.Right = typenod(t.Elem())
+		n.SetRight(typenod(t.Elem()))
 
-		n = ir.NodAt(n.Pos, ir.OADDR, n, nil)
+		n = ir.NodAt(n.Pos(), ir.OADDR, n, nil)
 		n.SetImplicit(true)
 	}
 
@@ -2807,90 +2807,90 @@ func typecheckcomplit(n *ir.Node) (res *ir.Node) {
 		base.Pos = lno
 	}()
 
-	if n.Right == nil {
-		base.ErrorfAt(n.Pos, "missing type in composite literal")
-		n.Type = nil
+	if n.Right() == nil {
+		base.ErrorfAt(n.Pos(), "missing type in composite literal")
+		n.SetType(nil)
 		return n
 	}
 
 	// Save original node (including n.Right)
-	n.Orig = ir.Copy(n)
+	n.SetOrig(ir.Copy(n))
 
-	setlineno(n.Right)
+	setlineno(n.Right())
 
 	// Need to handle [...]T arrays specially.
-	if n.Right.Op == ir.OTARRAY && n.Right.Left != nil && n.Right.Left.Op == ir.ODDD {
-		n.Right.Right = typecheck(n.Right.Right, ctxType)
-		if n.Right.Right.Type == nil {
-			n.Type = nil
+	if n.Right().Op() == ir.OTARRAY && n.Right().Left() != nil && n.Right().Left().Op() == ir.ODDD {
+		n.Right().SetRight(typecheck(n.Right().Right(), ctxType))
+		if n.Right().Right().Type() == nil {
+			n.SetType(nil)
 			return n
 		}
-		elemType := n.Right.Right.Type
+		elemType := n.Right().Right().Type()
 
-		length := typecheckarraylit(elemType, -1, n.List.Slice(), "array literal")
+		length := typecheckarraylit(elemType, -1, n.List().Slice(), "array literal")
 
-		n.Op = ir.OARRAYLIT
-		n.Type = types.NewArray(elemType, length)
-		n.Right = nil
+		n.SetOp(ir.OARRAYLIT)
+		n.SetType(types.NewArray(elemType, length))
+		n.SetRight(nil)
 		return n
 	}
 
-	n.Right = typecheck(n.Right, ctxType)
-	t := n.Right.Type
+	n.SetRight(typecheck(n.Right(), ctxType))
+	t := n.Right().Type()
 	if t == nil {
-		n.Type = nil
+		n.SetType(nil)
 		return n
 	}
-	n.Type = t
+	n.SetType(t)
 
 	switch t.Etype {
 	default:
 		base.Errorf("invalid composite literal type %v", t)
-		n.Type = nil
+		n.SetType(nil)
 
 	case types.TARRAY:
-		typecheckarraylit(t.Elem(), t.NumElem(), n.List.Slice(), "array literal")
-		n.Op = ir.OARRAYLIT
-		n.Right = nil
+		typecheckarraylit(t.Elem(), t.NumElem(), n.List().Slice(), "array literal")
+		n.SetOp(ir.OARRAYLIT)
+		n.SetRight(nil)
 
 	case types.TSLICE:
-		length := typecheckarraylit(t.Elem(), -1, n.List.Slice(), "slice literal")
-		n.Op = ir.OSLICELIT
-		n.Right = nodintconst(length)
+		length := typecheckarraylit(t.Elem(), -1, n.List().Slice(), "slice literal")
+		n.SetOp(ir.OSLICELIT)
+		n.SetRight(nodintconst(length))
 
 	case types.TMAP:
 		var cs constSet
-		for i3, l := range n.List.Slice() {
+		for i3, l := range n.List().Slice() {
 			setlineno(l)
-			if l.Op != ir.OKEY {
-				n.List.SetIndex(i3, typecheck(l, ctxExpr))
+			if l.Op() != ir.OKEY {
+				n.List().SetIndex(i3, typecheck(l, ctxExpr))
 				base.Errorf("missing key in map literal")
 				continue
 			}
 
-			r := l.Left
+			r := l.Left()
 			r = pushtype(r, t.Key())
 			r = typecheck(r, ctxExpr)
-			l.Left = assignconv(r, t.Key(), "map key")
-			cs.add(base.Pos, l.Left, "key", "map literal")
+			l.SetLeft(assignconv(r, t.Key(), "map key"))
+			cs.add(base.Pos, l.Left(), "key", "map literal")
 
-			r = l.Right
+			r = l.Right()
 			r = pushtype(r, t.Elem())
 			r = typecheck(r, ctxExpr)
-			l.Right = assignconv(r, t.Elem(), "map value")
+			l.SetRight(assignconv(r, t.Elem(), "map value"))
 		}
 
-		n.Op = ir.OMAPLIT
-		n.Right = nil
+		n.SetOp(ir.OMAPLIT)
+		n.SetRight(nil)
 
 	case types.TSTRUCT:
 		// Need valid field offsets for Xoffset below.
 		dowidth(t)
 
 		errored := false
-		if n.List.Len() != 0 && nokeys(n.List) {
+		if n.List().Len() != 0 && nokeys(n.List()) {
 			// simple list of variables
-			ls := n.List.Slice()
+			ls := n.List().Slice()
 			for i, n1 := range ls {
 				setlineno(n1)
 				n1 = typecheck(n1, ctxExpr)
@@ -2911,7 +2911,7 @@ func typecheckcomplit(n *ir.Node) (res *ir.Node) {
 				// No pushtype allowed here. Must name fields for that.
 				n1 = assignconv(n1, f.Type, "field value")
 				n1 = nodSym(ir.OSTRUCTKEY, n1, f.Sym)
-				n1.Xoffset = f.Offset
+				n1.SetOffset(f.Offset)
 				ls[i] = n1
 			}
 			if len(ls) < t.NumFields() {
@@ -2921,41 +2921,41 @@ func typecheckcomplit(n *ir.Node) (res *ir.Node) {
 			hash := make(map[string]bool)
 
 			// keyed list
-			ls := n.List.Slice()
+			ls := n.List().Slice()
 			for i, l := range ls {
 				setlineno(l)
 
-				if l.Op == ir.OKEY {
-					key := l.Left
+				if l.Op() == ir.OKEY {
+					key := l.Left()
 
-					l.Op = ir.OSTRUCTKEY
-					l.Left = l.Right
-					l.Right = nil
+					l.SetOp(ir.OSTRUCTKEY)
+					l.SetLeft(l.Right())
+					l.SetRight(nil)
 
 					// An OXDOT uses the Sym field to hold
 					// the field to the right of the dot,
 					// so s will be non-nil, but an OXDOT
 					// is never a valid struct literal key.
-					if key.Sym == nil || key.Op == ir.OXDOT || key.Sym.IsBlank() {
+					if key.Sym() == nil || key.Op() == ir.OXDOT || key.Sym().IsBlank() {
 						base.Errorf("invalid field name %v in struct initializer", key)
-						l.Left = typecheck(l.Left, ctxExpr)
+						l.SetLeft(typecheck(l.Left(), ctxExpr))
 						continue
 					}
 
 					// Sym might have resolved to name in other top-level
 					// package, because of import dot. Redirect to correct sym
 					// before we do the lookup.
-					s := key.Sym
+					s := key.Sym()
 					if s.Pkg != ir.LocalPkg && types.IsExported(s.Name) {
 						s1 := lookup(s.Name)
 						if s1.Origpkg == s.Pkg {
 							s = s1
 						}
 					}
-					l.Sym = s
+					l.SetSym(s)
 				}
 
-				if l.Op != ir.OSTRUCTKEY {
+				if l.Op() != ir.OSTRUCTKEY {
 					if !errored {
 						base.Errorf("mixture of field:value and value initializers")
 						errored = true
@@ -2964,22 +2964,22 @@ func typecheckcomplit(n *ir.Node) (res *ir.Node) {
 					continue
 				}
 
-				f := lookdot1(nil, l.Sym, t, t.Fields(), 0)
+				f := lookdot1(nil, l.Sym(), t, t.Fields(), 0)
 				if f == nil {
-					if ci := lookdot1(nil, l.Sym, t, t.Fields(), 2); ci != nil { // Case-insensitive lookup.
+					if ci := lookdot1(nil, l.Sym(), t, t.Fields(), 2); ci != nil { // Case-insensitive lookup.
 						if visible(ci.Sym) {
-							base.Errorf("unknown field '%v' in struct literal of type %v (but does have %v)", l.Sym, t, ci.Sym)
-						} else if nonexported(l.Sym) && l.Sym.Name == ci.Sym.Name { // Ensure exactness before the suggestion.
-							base.Errorf("cannot refer to unexported field '%v' in struct literal of type %v", l.Sym, t)
+							base.Errorf("unknown field '%v' in struct literal of type %v (but does have %v)", l.Sym(), t, ci.Sym)
+						} else if nonexported(l.Sym()) && l.Sym().Name == ci.Sym.Name { // Ensure exactness before the suggestion.
+							base.Errorf("cannot refer to unexported field '%v' in struct literal of type %v", l.Sym(), t)
 						} else {
-							base.Errorf("unknown field '%v' in struct literal of type %v", l.Sym, t)
+							base.Errorf("unknown field '%v' in struct literal of type %v", l.Sym(), t)
 						}
 						continue
 					}
 					var f *types.Field
-					p, _ := dotpath(l.Sym, t, &f, true)
+					p, _ := dotpath(l.Sym(), t, &f, true)
 					if p == nil || f.IsMethod() {
-						base.Errorf("unknown field '%v' in struct literal of type %v", l.Sym, t)
+						base.Errorf("unknown field '%v' in struct literal of type %v", l.Sym(), t)
 						continue
 					}
 					// dotpath returns the parent embedded types in reverse order.
@@ -2987,21 +2987,21 @@ func typecheckcomplit(n *ir.Node) (res *ir.Node) {
 					for ei := len(p) - 1; ei >= 0; ei-- {
 						ep = append(ep, p[ei].field.Sym.Name)
 					}
-					ep = append(ep, l.Sym.Name)
+					ep = append(ep, l.Sym().Name)
 					base.Errorf("cannot use promoted field %v in struct literal of type %v", strings.Join(ep, "."), t)
 					continue
 				}
 				fielddup(f.Sym.Name, hash)
-				l.Xoffset = f.Offset
+				l.SetOffset(f.Offset)
 
 				// No pushtype allowed here. Tried and rejected.
-				l.Left = typecheck(l.Left, ctxExpr)
-				l.Left = assignconv(l.Left, f.Type, "field value")
+				l.SetLeft(typecheck(l.Left(), ctxExpr))
+				l.SetLeft(assignconv(l.Left(), f.Type, "field value"))
 			}
 		}
 
-		n.Op = ir.OSTRUCTLIT
-		n.Right = nil
+		n.SetOp(ir.OSTRUCTLIT)
+		n.SetRight(nil)
 	}
 
 	return n
@@ -3013,7 +3013,7 @@ func typecheckarraylit(elemType *types.Type, bound int64, elts []*ir.Node, ctx s
 	// keys so we can check for duplicate indices.
 	var indices map[int64]bool
 	for _, elt := range elts {
-		if elt.Op == ir.OKEY {
+		if elt.Op() == ir.OKEY {
 			indices = make(map[int64]bool)
 			break
 		}
@@ -3024,29 +3024,29 @@ func typecheckarraylit(elemType *types.Type, bound int64, elts []*ir.Node, ctx s
 		setlineno(elt)
 		r := elts[i]
 		var kv *ir.Node
-		if elt.Op == ir.OKEY {
-			elt.Left = typecheck(elt.Left, ctxExpr)
-			key = indexconst(elt.Left)
+		if elt.Op() == ir.OKEY {
+			elt.SetLeft(typecheck(elt.Left(), ctxExpr))
+			key = indexconst(elt.Left())
 			if key < 0 {
-				if !elt.Left.Diag() {
+				if !elt.Left().Diag() {
 					if key == -2 {
 						base.Errorf("index too large")
 					} else {
 						base.Errorf("index must be non-negative integer constant")
 					}
-					elt.Left.SetDiag(true)
+					elt.Left().SetDiag(true)
 				}
 				key = -(1 << 30) // stay negative for a while
 			}
 			kv = elt
-			r = elt.Right
+			r = elt.Right()
 		}
 
 		r = pushtype(r, elemType)
 		r = typecheck(r, ctxExpr)
 		r = assignconv(r, elemType, ctx)
 		if kv != nil {
-			kv.Right = r
+			kv.SetRight(r)
 		} else {
 			elts[i] = r
 		}
@@ -3087,12 +3087,12 @@ func nonexported(sym *types.Sym) bool {
 
 // lvalue etc
 func islvalue(n *ir.Node) bool {
-	switch n.Op {
+	switch n.Op() {
 	case ir.OINDEX:
-		if n.Left.Type != nil && n.Left.Type.IsArray() {
-			return islvalue(n.Left)
+		if n.Left().Type() != nil && n.Left().Type().IsArray() {
+			return islvalue(n.Left())
 		}
-		if n.Left.Type != nil && n.Left.Type.IsString() {
+		if n.Left().Type() != nil && n.Left().Type().IsString() {
 			return false
 		}
 		fallthrough
@@ -3100,7 +3100,7 @@ func islvalue(n *ir.Node) bool {
 		return true
 
 	case ir.ODOT:
-		return islvalue(n.Left)
+		return islvalue(n.Left())
 
 	case ir.ONAME:
 		if n.Class() == ir.PFUNC {
@@ -3120,12 +3120,12 @@ func checklvalue(n *ir.Node, verb string) {
 
 func checkassign(stmt *ir.Node, n *ir.Node) {
 	// Variables declared in ORANGE are assigned on every iteration.
-	if n.Name == nil || n.Name.Defn != stmt || stmt.Op == ir.ORANGE {
+	if n.Name() == nil || n.Name().Defn != stmt || stmt.Op() == ir.ORANGE {
 		r := outervalue(n)
-		if r.Op == ir.ONAME {
-			r.Name.SetAssigned(true)
-			if r.Name.IsClosureVar() {
-				r.Name.Defn.Name.SetAssigned(true)
+		if r.Op() == ir.ONAME {
+			r.Name().SetAssigned(true)
+			if r.Name().IsClosureVar() {
+				r.Name().Defn.Name().SetAssigned(true)
 			}
 		}
 	}
@@ -3133,27 +3133,27 @@ func checkassign(stmt *ir.Node, n *ir.Node) {
 	if islvalue(n) {
 		return
 	}
-	if n.Op == ir.OINDEXMAP {
+	if n.Op() == ir.OINDEXMAP {
 		n.SetIndexMapLValue(true)
 		return
 	}
 
 	// have already complained about n being invalid
-	if n.Type == nil {
+	if n.Type() == nil {
 		return
 	}
 
 	switch {
-	case n.Op == ir.ODOT && n.Left.Op == ir.OINDEXMAP:
+	case n.Op() == ir.ODOT && n.Left().Op() == ir.OINDEXMAP:
 		base.Errorf("cannot assign to struct field %v in map", n)
-	case (n.Op == ir.OINDEX && n.Left.Type.IsString()) || n.Op == ir.OSLICESTR:
+	case (n.Op() == ir.OINDEX && n.Left().Type().IsString()) || n.Op() == ir.OSLICESTR:
 		base.Errorf("cannot assign to %v (strings are immutable)", n)
-	case n.Op == ir.OLITERAL && n.Sym != nil && isGoConst(n):
+	case n.Op() == ir.OLITERAL && n.Sym() != nil && isGoConst(n):
 		base.Errorf("cannot assign to %v (declared const)", n)
 	default:
 		base.Errorf("cannot assign to %v", n)
 	}
-	n.Type = nil
+	n.SetType(nil)
 }
 
 func checkassignlist(stmt *ir.Node, l ir.Nodes) {
@@ -3178,29 +3178,29 @@ func checkassignlist(stmt *ir.Node, l ir.Nodes) {
 // lvalue expression is for OSLICE and OAPPEND optimizations, and it
 // is correct in those settings.
 func samesafeexpr(l *ir.Node, r *ir.Node) bool {
-	if l.Op != r.Op || !types.Identical(l.Type, r.Type) {
+	if l.Op() != r.Op() || !types.Identical(l.Type(), r.Type()) {
 		return false
 	}
 
-	switch l.Op {
+	switch l.Op() {
 	case ir.ONAME, ir.OCLOSUREVAR:
 		return l == r
 
 	case ir.ODOT, ir.ODOTPTR:
-		return l.Sym != nil && r.Sym != nil && l.Sym == r.Sym && samesafeexpr(l.Left, r.Left)
+		return l.Sym() != nil && r.Sym() != nil && l.Sym() == r.Sym() && samesafeexpr(l.Left(), r.Left())
 
 	case ir.ODEREF, ir.OCONVNOP,
 		ir.ONOT, ir.OBITNOT, ir.OPLUS, ir.ONEG:
-		return samesafeexpr(l.Left, r.Left)
+		return samesafeexpr(l.Left(), r.Left())
 
 	case ir.OCONV:
 		// Some conversions can't be reused, such as []byte(str).
 		// Allow only numeric-ish types. This is a bit conservative.
-		return issimple[l.Type.Etype] && samesafeexpr(l.Left, r.Left)
+		return issimple[l.Type().Etype] && samesafeexpr(l.Left(), r.Left())
 
 	case ir.OINDEX, ir.OINDEXMAP,
 		ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.OLSH, ir.ORSH, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OMOD:
-		return samesafeexpr(l.Left, r.Left) && samesafeexpr(l.Right, r.Right)
+		return samesafeexpr(l.Left(), r.Left()) && samesafeexpr(l.Right(), r.Right())
 
 	case ir.OLITERAL:
 		return constant.Compare(l.Val(), token.EQL, r.Val())
@@ -3227,30 +3227,30 @@ func typecheckas(n *ir.Node) {
 	// if the variable has a type (ntype) then typechecking
 	// will not look at defn, so it is okay (and desirable,
 	// so that the conversion below happens).
-	n.Left = resolve(n.Left)
+	n.SetLeft(resolve(n.Left()))
 
-	if n.Left.Name == nil || n.Left.Name.Defn != n || n.Left.Name.Param.Ntype != nil {
-		n.Left = typecheck(n.Left, ctxExpr|ctxAssign)
+	if n.Left().Name() == nil || n.Left().Name().Defn != n || n.Left().Name().Param.Ntype != nil {
+		n.SetLeft(typecheck(n.Left(), ctxExpr|ctxAssign))
 	}
 
 	// Use ctxMultiOK so we can emit an "N variables but M values" error
 	// to be consistent with typecheckas2 (#26616).
-	n.Right = typecheck(n.Right, ctxExpr|ctxMultiOK)
-	checkassign(n, n.Left)
-	if n.Right != nil && n.Right.Type != nil {
-		if n.Right.Type.IsFuncArgStruct() {
-			base.Errorf("assignment mismatch: 1 variable but %v returns %d values", n.Right.Left, n.Right.Type.NumFields())
+	n.SetRight(typecheck(n.Right(), ctxExpr|ctxMultiOK))
+	checkassign(n, n.Left())
+	if n.Right() != nil && n.Right().Type() != nil {
+		if n.Right().Type().IsFuncArgStruct() {
+			base.Errorf("assignment mismatch: 1 variable but %v returns %d values", n.Right().Left(), n.Right().Type().NumFields())
 			// Multi-value RHS isn't actually valid for OAS; nil out
 			// to indicate failed typechecking.
-			n.Right.Type = nil
-		} else if n.Left.Type != nil {
-			n.Right = assignconv(n.Right, n.Left.Type, "assignment")
+			n.Right().SetType(nil)
+		} else if n.Left().Type() != nil {
+			n.SetRight(assignconv(n.Right(), n.Left().Type(), "assignment"))
 		}
 	}
 
-	if n.Left.Name != nil && n.Left.Name.Defn == n && n.Left.Name.Param.Ntype == nil {
-		n.Right = defaultlit(n.Right, nil)
-		n.Left.Type = n.Right.Type
+	if n.Left().Name() != nil && n.Left().Name().Defn == n && n.Left().Name().Param.Ntype == nil {
+		n.SetRight(defaultlit(n.Right(), nil))
+		n.Left().SetType(n.Right().Type())
 	}
 
 	// second half of dance.
@@ -3258,16 +3258,16 @@ func typecheckas(n *ir.Node) {
 	// just to get it over with.  see dance above.
 	n.SetTypecheck(1)
 
-	if n.Left.Typecheck() == 0 {
-		n.Left = typecheck(n.Left, ctxExpr|ctxAssign)
+	if n.Left().Typecheck() == 0 {
+		n.SetLeft(typecheck(n.Left(), ctxExpr|ctxAssign))
 	}
-	if !ir.IsBlank(n.Left) {
-		checkwidth(n.Left.Type) // ensure width is calculated for backend
+	if !ir.IsBlank(n.Left()) {
+		checkwidth(n.Left().Type()) // ensure width is calculated for backend
 	}
 }
 
 func checkassignto(src *types.Type, dst *ir.Node) {
-	if op, why := assignop(src, dst.Type); op == ir.OXXX {
+	if op, why := assignop(src, dst.Type()); op == ir.OXXX {
 		base.Errorf("cannot assign %v to %L in multiple assignment%s", src, dst, why)
 		return
 	}
@@ -3278,73 +3278,73 @@ func typecheckas2(n *ir.Node) {
 		defer tracePrint("typecheckas2", n)(nil)
 	}
 
-	ls := n.List.Slice()
+	ls := n.List().Slice()
 	for i1, n1 := range ls {
 		// delicate little dance.
 		n1 = resolve(n1)
 		ls[i1] = n1
 
-		if n1.Name == nil || n1.Name.Defn != n || n1.Name.Param.Ntype != nil {
+		if n1.Name() == nil || n1.Name().Defn != n || n1.Name().Param.Ntype != nil {
 			ls[i1] = typecheck(ls[i1], ctxExpr|ctxAssign)
 		}
 	}
 
-	cl := n.List.Len()
-	cr := n.Rlist.Len()
+	cl := n.List().Len()
+	cr := n.Rlist().Len()
 	if cl > 1 && cr == 1 {
-		n.Rlist.SetFirst(typecheck(n.Rlist.First(), ctxExpr|ctxMultiOK))
+		n.Rlist().SetFirst(typecheck(n.Rlist().First(), ctxExpr|ctxMultiOK))
 	} else {
-		typecheckslice(n.Rlist.Slice(), ctxExpr)
+		typecheckslice(n.Rlist().Slice(), ctxExpr)
 	}
-	checkassignlist(n, n.List)
+	checkassignlist(n, n.List())
 
 	var l *ir.Node
 	var r *ir.Node
 	if cl == cr {
 		// easy
-		ls := n.List.Slice()
-		rs := n.Rlist.Slice()
+		ls := n.List().Slice()
+		rs := n.Rlist().Slice()
 		for il, nl := range ls {
 			nr := rs[il]
-			if nl.Type != nil && nr.Type != nil {
-				rs[il] = assignconv(nr, nl.Type, "assignment")
+			if nl.Type() != nil && nr.Type() != nil {
+				rs[il] = assignconv(nr, nl.Type(), "assignment")
 			}
-			if nl.Name != nil && nl.Name.Defn == n && nl.Name.Param.Ntype == nil {
+			if nl.Name() != nil && nl.Name().Defn == n && nl.Name().Param.Ntype == nil {
 				rs[il] = defaultlit(rs[il], nil)
-				nl.Type = rs[il].Type
+				nl.SetType(rs[il].Type())
 			}
 		}
 
 		goto out
 	}
 
-	l = n.List.First()
-	r = n.Rlist.First()
+	l = n.List().First()
+	r = n.Rlist().First()
 
 	// x,y,z = f()
 	if cr == 1 {
-		if r.Type == nil {
+		if r.Type() == nil {
 			goto out
 		}
-		switch r.Op {
+		switch r.Op() {
 		case ir.OCALLMETH, ir.OCALLINTER, ir.OCALLFUNC:
-			if !r.Type.IsFuncArgStruct() {
+			if !r.Type().IsFuncArgStruct() {
 				break
 			}
-			cr = r.Type.NumFields()
+			cr = r.Type().NumFields()
 			if cr != cl {
 				goto mismatch
 			}
-			n.Op = ir.OAS2FUNC
-			n.Right = r
-			n.Rlist.Set(nil)
-			for i, l := range n.List.Slice() {
-				f := r.Type.Field(i)
-				if f.Type != nil && l.Type != nil {
+			n.SetOp(ir.OAS2FUNC)
+			n.SetRight(r)
+			n.PtrRlist().Set(nil)
+			for i, l := range n.List().Slice() {
+				f := r.Type().Field(i)
+				if f.Type != nil && l.Type() != nil {
 					checkassignto(f.Type, l)
 				}
-				if l.Name != nil && l.Name.Defn == n && l.Name.Param.Ntype == nil {
-					l.Type = f.Type
+				if l.Name() != nil && l.Name().Defn == n && l.Name().Param.Ntype == nil {
+					l.SetType(f.Type)
 				}
 			}
 			goto out
@@ -3353,51 +3353,51 @@ func typecheckas2(n *ir.Node) {
 
 	// x, ok = y
 	if cl == 2 && cr == 1 {
-		if r.Type == nil {
+		if r.Type() == nil {
 			goto out
 		}
-		switch r.Op {
+		switch r.Op() {
 		case ir.OINDEXMAP, ir.ORECV, ir.ODOTTYPE:
-			switch r.Op {
+			switch r.Op() {
 			case ir.OINDEXMAP:
-				n.Op = ir.OAS2MAPR
+				n.SetOp(ir.OAS2MAPR)
 			case ir.ORECV:
-				n.Op = ir.OAS2RECV
+				n.SetOp(ir.OAS2RECV)
 			case ir.ODOTTYPE:
-				n.Op = ir.OAS2DOTTYPE
-				r.Op = ir.ODOTTYPE2
+				n.SetOp(ir.OAS2DOTTYPE)
+				r.SetOp(ir.ODOTTYPE2)
 			}
-			n.Right = r
-			n.Rlist.Set(nil)
-			if l.Type != nil {
-				checkassignto(r.Type, l)
+			n.SetRight(r)
+			n.PtrRlist().Set(nil)
+			if l.Type() != nil {
+				checkassignto(r.Type(), l)
 			}
-			if l.Name != nil && l.Name.Defn == n {
-				l.Type = r.Type
+			if l.Name() != nil && l.Name().Defn == n {
+				l.SetType(r.Type())
 			}
-			l := n.List.Second()
-			if l.Type != nil && !l.Type.IsBoolean() {
+			l := n.List().Second()
+			if l.Type() != nil && !l.Type().IsBoolean() {
 				checkassignto(types.Types[types.TBOOL], l)
 			}
-			if l.Name != nil && l.Name.Defn == n && l.Name.Param.Ntype == nil {
-				l.Type = types.Types[types.TBOOL]
+			if l.Name() != nil && l.Name().Defn == n && l.Name().Param.Ntype == nil {
+				l.SetType(types.Types[types.TBOOL])
 			}
 			goto out
 		}
 	}
 
 mismatch:
-	switch r.Op {
+	switch r.Op() {
 	default:
 		base.Errorf("assignment mismatch: %d variables but %d values", cl, cr)
 	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
-		base.Errorf("assignment mismatch: %d variables but %v returns %d values", cl, r.Left, cr)
+		base.Errorf("assignment mismatch: %d variables but %v returns %d values", cl, r.Left(), cr)
 	}
 
 	// second half of dance
 out:
 	n.SetTypecheck(1)
-	ls = n.List.Slice()
+	ls = n.List().Slice()
 	for i1, n1 := range ls {
 		if n1.Typecheck() == 0 {
 			ls[i1] = typecheck(ls[i1], ctxExpr|ctxAssign)
@@ -3411,50 +3411,50 @@ func typecheckfunc(n *ir.Node) {
 		defer tracePrint("typecheckfunc", n)(nil)
 	}
 
-	for _, ln := range n.Func.Dcl {
-		if ln.Op == ir.ONAME && (ln.Class() == ir.PPARAM || ln.Class() == ir.PPARAMOUT) {
-			ln.Name.Decldepth = 1
+	for _, ln := range n.Func().Dcl {
+		if ln.Op() == ir.ONAME && (ln.Class() == ir.PPARAM || ln.Class() == ir.PPARAMOUT) {
+			ln.Name().Decldepth = 1
 		}
 	}
 
-	n.Func.Nname = typecheck(n.Func.Nname, ctxExpr|ctxAssign)
-	t := n.Func.Nname.Type
+	n.Func().Nname = typecheck(n.Func().Nname, ctxExpr|ctxAssign)
+	t := n.Func().Nname.Type()
 	if t == nil {
 		return
 	}
-	n.Type = t
+	n.SetType(t)
 	rcvr := t.Recv()
-	if rcvr != nil && n.Func.Shortname != nil {
-		m := addmethod(n, n.Func.Shortname, t, true, n.Func.Pragma&ir.Nointerface != 0)
+	if rcvr != nil && n.Func().Shortname != nil {
+		m := addmethod(n, n.Func().Shortname, t, true, n.Func().Pragma&ir.Nointerface != 0)
 		if m == nil {
 			return
 		}
 
-		n.Func.Nname.Sym = methodSym(rcvr.Type, n.Func.Shortname)
-		declare(n.Func.Nname, ir.PFUNC)
+		n.Func().Nname.SetSym(methodSym(rcvr.Type, n.Func().Shortname))
+		declare(n.Func().Nname, ir.PFUNC)
 	}
 
-	if base.Ctxt.Flag_dynlink && !inimport && n.Func.Nname != nil {
-		makefuncsym(n.Func.Nname.Sym)
+	if base.Ctxt.Flag_dynlink && !inimport && n.Func().Nname != nil {
+		makefuncsym(n.Func().Nname.Sym())
 	}
 }
 
 // The result of stringtoruneslit MUST be assigned back to n, e.g.
 // 	n.Left = stringtoruneslit(n.Left)
 func stringtoruneslit(n *ir.Node) *ir.Node {
-	if n.Left.Op != ir.OLITERAL || n.Left.Val().Kind() != constant.String {
+	if n.Left().Op() != ir.OLITERAL || n.Left().Val().Kind() != constant.String {
 		base.Fatalf("stringtoarraylit %v", n)
 	}
 
 	var l []*ir.Node
 	i := 0
-	for _, r := range n.Left.StringVal() {
+	for _, r := range n.Left().StringVal() {
 		l = append(l, ir.Nod(ir.OKEY, nodintconst(int64(i)), nodintconst(int64(r))))
 		i++
 	}
 
-	nn := ir.Nod(ir.OCOMPLIT, nil, typenod(n.Type))
-	nn.List.Set(l)
+	nn := ir.Nod(ir.OCOMPLIT, nil, typenod(n.Type()))
+	nn.PtrList().Set(l)
 	nn = typecheck(nn, ctxExpr)
 	return nn
 }
@@ -3463,9 +3463,9 @@ var mapqueue []*ir.Node
 
 func checkMapKeys() {
 	for _, n := range mapqueue {
-		k := n.Type.MapType().Key
+		k := n.Type().MapType().Key
 		if !k.Broke() && !IsComparable(k) {
-			base.ErrorfAt(n.Pos, "invalid map key type %v", k)
+			base.ErrorfAt(n.Pos(), "invalid map key type %v", k)
 		}
 	}
 	mapqueue = nil
@@ -3487,9 +3487,9 @@ func setUnderlying(t, underlying *types.Type) {
 
 	// Restore unnecessarily clobbered attributes.
 	t.Nod = ir.AsTypesNode(n)
-	t.Sym = n.Sym
-	if n.Name != nil {
-		t.Vargen = n.Name.Vargen
+	t.Sym = n.Sym()
+	if n.Name() != nil {
+		t.Vargen = n.Name().Vargen
 	}
 	t.Cache = cache
 	t.SetDeferwidth(false)
@@ -3503,7 +3503,7 @@ func setUnderlying(t, underlying *types.Type) {
 	}
 
 	// Propagate go:notinheap pragma from the Name to the Type.
-	if n.Name != nil && n.Name.Param != nil && n.Name.Param.Pragma()&ir.NotInHeap != 0 {
+	if n.Name() != nil && n.Name().Param != nil && n.Name().Param.Pragma()&ir.NotInHeap != 0 {
 		t.SetNotInHeap(true)
 	}
 
@@ -3526,17 +3526,17 @@ func typecheckdeftype(n *ir.Node) {
 	}
 
 	n.SetTypecheck(1)
-	n.Name.Param.Ntype = typecheck(n.Name.Param.Ntype, ctxType)
-	t := n.Name.Param.Ntype.Type
+	n.Name().Param.Ntype = typecheck(n.Name().Param.Ntype, ctxType)
+	t := n.Name().Param.Ntype.Type()
 	if t == nil {
 		n.SetDiag(true)
-		n.Type = nil
-	} else if n.Type == nil {
+		n.SetType(nil)
+	} else if n.Type() == nil {
 		n.SetDiag(true)
 	} else {
 		// copy new type and clear fields
 		// that don't come along.
-		setUnderlying(n.Type, t)
+		setUnderlying(n.Type(), t)
 	}
 }
 
@@ -3547,13 +3547,13 @@ func typecheckdef(n *ir.Node) {
 
 	lno := setlineno(n)
 
-	if n.Op == ir.ONONAME {
+	if n.Op() == ir.ONONAME {
 		if !n.Diag() {
 			n.SetDiag(true)
 
 			// Note: adderrorname looks for this string and
 			// adds context about the outer expression
-			base.ErrorfAt(base.Pos, "undefined: %v", n.Sym)
+			base.ErrorfAt(base.Pos, "undefined: %v", n.Sym())
 		}
 		base.Pos = lno
 		return
@@ -3570,7 +3570,7 @@ func typecheckdef(n *ir.Node) {
 		fmt.Printf("typecheckdef loop:")
 		for i := len(typecheckdefstack) - 1; i >= 0; i-- {
 			n := typecheckdefstack[i]
-			fmt.Printf(" %v", n.Sym)
+			fmt.Printf(" %v", n.Sym())
 		}
 		fmt.Printf("\n")
 		base.Fatalf("typecheckdef loop")
@@ -3578,82 +3578,82 @@ func typecheckdef(n *ir.Node) {
 
 	n.SetWalkdef(2)
 
-	if n.Type != nil || n.Sym == nil { // builtin or no name
+	if n.Type() != nil || n.Sym() == nil { // builtin or no name
 		goto ret
 	}
 
-	switch n.Op {
+	switch n.Op() {
 	default:
-		base.Fatalf("typecheckdef %v", n.Op)
+		base.Fatalf("typecheckdef %v", n.Op())
 
 	case ir.OLITERAL:
-		if n.Name.Param.Ntype != nil {
-			n.Name.Param.Ntype = typecheck(n.Name.Param.Ntype, ctxType)
-			n.Type = n.Name.Param.Ntype.Type
-			n.Name.Param.Ntype = nil
-			if n.Type == nil {
+		if n.Name().Param.Ntype != nil {
+			n.Name().Param.Ntype = typecheck(n.Name().Param.Ntype, ctxType)
+			n.SetType(n.Name().Param.Ntype.Type())
+			n.Name().Param.Ntype = nil
+			if n.Type() == nil {
 				n.SetDiag(true)
 				goto ret
 			}
 		}
 
-		e := n.Name.Defn
-		n.Name.Defn = nil
+		e := n.Name().Defn
+		n.Name().Defn = nil
 		if e == nil {
 			ir.Dump("typecheckdef nil defn", n)
-			base.ErrorfAt(n.Pos, "xxx")
+			base.ErrorfAt(n.Pos(), "xxx")
 		}
 
 		e = typecheck(e, ctxExpr)
-		if e.Type == nil {
+		if e.Type() == nil {
 			goto ret
 		}
 		if !isGoConst(e) {
 			if !e.Diag() {
-				if e.Op == ir.ONIL {
-					base.ErrorfAt(n.Pos, "const initializer cannot be nil")
+				if e.Op() == ir.ONIL {
+					base.ErrorfAt(n.Pos(), "const initializer cannot be nil")
 				} else {
-					base.ErrorfAt(n.Pos, "const initializer %v is not a constant", e)
+					base.ErrorfAt(n.Pos(), "const initializer %v is not a constant", e)
 				}
 				e.SetDiag(true)
 			}
 			goto ret
 		}
 
-		t := n.Type
+		t := n.Type()
 		if t != nil {
 			if !ir.OKForConst[t.Etype] {
-				base.ErrorfAt(n.Pos, "invalid constant type %v", t)
+				base.ErrorfAt(n.Pos(), "invalid constant type %v", t)
 				goto ret
 			}
 
-			if !e.Type.IsUntyped() && !types.Identical(t, e.Type) {
-				base.ErrorfAt(n.Pos, "cannot use %L as type %v in const initializer", e, t)
+			if !e.Type().IsUntyped() && !types.Identical(t, e.Type()) {
+				base.ErrorfAt(n.Pos(), "cannot use %L as type %v in const initializer", e, t)
 				goto ret
 			}
 
 			e = convlit(e, t)
 		}
 
-		n.Type = e.Type
-		if n.Type != nil {
+		n.SetType(e.Type())
+		if n.Type() != nil {
 			n.SetVal(e.Val())
 		}
 
 	case ir.ONAME:
-		if n.Name.Param.Ntype != nil {
-			n.Name.Param.Ntype = typecheck(n.Name.Param.Ntype, ctxType)
-			n.Type = n.Name.Param.Ntype.Type
-			if n.Type == nil {
+		if n.Name().Param.Ntype != nil {
+			n.Name().Param.Ntype = typecheck(n.Name().Param.Ntype, ctxType)
+			n.SetType(n.Name().Param.Ntype.Type())
+			if n.Type() == nil {
 				n.SetDiag(true)
 				goto ret
 			}
 		}
 
-		if n.Type != nil {
+		if n.Type() != nil {
 			break
 		}
-		if n.Name.Defn == nil {
+		if n.Name().Defn == nil {
 			if n.SubOp() != 0 { // like OPRINTN
 				break
 			}
@@ -3665,33 +3665,33 @@ func typecheckdef(n *ir.Node) {
 				break
 			}
 
-			base.Fatalf("var without type, init: %v", n.Sym)
+			base.Fatalf("var without type, init: %v", n.Sym())
 		}
 
-		if n.Name.Defn.Op == ir.ONAME {
-			n.Name.Defn = typecheck(n.Name.Defn, ctxExpr)
-			n.Type = n.Name.Defn.Type
+		if n.Name().Defn.Op() == ir.ONAME {
+			n.Name().Defn = typecheck(n.Name().Defn, ctxExpr)
+			n.SetType(n.Name().Defn.Type())
 			break
 		}
 
-		n.Name.Defn = typecheck(n.Name.Defn, ctxStmt) // fills in n.Type
+		n.Name().Defn = typecheck(n.Name().Defn, ctxStmt) // fills in n.Type
 
 	case ir.OTYPE:
-		if p := n.Name.Param; p.Alias() {
+		if p := n.Name().Param; p.Alias() {
 			// Type alias declaration: Simply use the rhs type - no need
 			// to create a new type.
 			// If we have a syntax error, p.Ntype may be nil.
 			if p.Ntype != nil {
 				p.Ntype = typecheck(p.Ntype, ctxType)
-				n.Type = p.Ntype.Type
-				if n.Type == nil {
+				n.SetType(p.Ntype.Type())
+				if n.Type() == nil {
 					n.SetDiag(true)
 					goto ret
 				}
 				// For package-level type aliases, set n.Sym.Def so we can identify
 				// it as a type alias during export. See also #31959.
-				if n.Name.Curfn == nil {
-					n.Sym.Def = ir.AsTypesNode(p.Ntype)
+				if n.Name().Curfn == nil {
+					n.Sym().Def = ir.AsTypesNode(p.Ntype)
 				}
 			}
 			break
@@ -3701,20 +3701,20 @@ func typecheckdef(n *ir.Node) {
 		defercheckwidth()
 		n.SetWalkdef(1)
 		setTypeNode(n, types.New(types.TFORW))
-		n.Type.Sym = n.Sym
+		n.Type().Sym = n.Sym()
 		errorsBefore := base.Errors()
 		typecheckdeftype(n)
-		if n.Type.Etype == types.TFORW && base.Errors() > errorsBefore {
+		if n.Type().Etype == types.TFORW && base.Errors() > errorsBefore {
 			// Something went wrong during type-checking,
 			// but it was reported. Silence future errors.
-			n.Type.SetBroke(true)
+			n.Type().SetBroke(true)
 		}
 		resumecheckwidth()
 	}
 
 ret:
-	if n.Op != ir.OLITERAL && n.Type != nil && n.Type.IsUntyped() {
-		base.Fatalf("got %v for %v", n.Type, n)
+	if n.Op() != ir.OLITERAL && n.Type() != nil && n.Type().IsUntyped() {
+		base.Fatalf("got %v for %v", n.Type(), n)
 	}
 	last := len(typecheckdefstack) - 1
 	if typecheckdefstack[last] != n {
@@ -3729,14 +3729,14 @@ ret:
 
 func checkmake(t *types.Type, arg string, np **ir.Node) bool {
 	n := *np
-	if !n.Type.IsInteger() && n.Type.Etype != types.TIDEAL {
-		base.Errorf("non-integer %s argument in make(%v) - %v", arg, t, n.Type)
+	if !n.Type().IsInteger() && n.Type().Etype != types.TIDEAL {
+		base.Errorf("non-integer %s argument in make(%v) - %v", arg, t, n.Type())
 		return false
 	}
 
 	// Do range checks for constants before defaultlit
 	// to avoid redundant "constant NNN overflows int" errors.
-	if n.Op == ir.OLITERAL {
+	if n.Op() == ir.OLITERAL {
 		v := toint(n.Val())
 		if constant.Sign(v) < 0 {
 			base.Errorf("negative %s argument in make(%v)", arg, t)
@@ -3764,14 +3764,14 @@ func markbreak(n *ir.Node, implicit *ir.Node) {
 		return
 	}
 
-	switch n.Op {
+	switch n.Op() {
 	case ir.OBREAK:
-		if n.Sym == nil {
+		if n.Sym() == nil {
 			if implicit != nil {
 				implicit.SetHasBreak(true)
 			}
 		} else {
-			lab := ir.AsNode(n.Sym.Label)
+			lab := ir.AsNode(n.Sym().Label)
 			if lab != nil {
 				lab.SetHasBreak(true)
 			}
@@ -3780,12 +3780,12 @@ func markbreak(n *ir.Node, implicit *ir.Node) {
 		implicit = n
 		fallthrough
 	default:
-		markbreak(n.Left, implicit)
-		markbreak(n.Right, implicit)
-		markbreaklist(n.Ninit, implicit)
-		markbreaklist(n.Nbody, implicit)
-		markbreaklist(n.List, implicit)
-		markbreaklist(n.Rlist, implicit)
+		markbreak(n.Left(), implicit)
+		markbreak(n.Right(), implicit)
+		markbreaklist(n.Init(), implicit)
+		markbreaklist(n.Body(), implicit)
+		markbreaklist(n.List(), implicit)
+		markbreaklist(n.Rlist(), implicit)
 	}
 }
 
@@ -3796,12 +3796,12 @@ func markbreaklist(l ir.Nodes, implicit *ir.Node) {
 		if n == nil {
 			continue
 		}
-		if n.Op == ir.OLABEL && i+1 < len(s) && n.Name.Defn == s[i+1] {
-			switch n.Name.Defn.Op {
+		if n.Op() == ir.OLABEL && i+1 < len(s) && n.Name().Defn == s[i+1] {
+			switch n.Name().Defn.Op() {
 			case ir.OFOR, ir.OFORUNTIL, ir.OSWITCH, ir.OTYPESW, ir.OSELECT, ir.ORANGE:
-				n.Sym.Label = ir.AsTypesNode(n.Name.Defn)
-				markbreak(n.Name.Defn, n.Name.Defn)
-				n.Sym.Label = nil
+				n.Sym().Label = ir.AsTypesNode(n.Name().Defn)
+				markbreak(n.Name().Defn, n.Name().Defn)
+				n.Sym().Label = nil
 				i++
 				continue
 			}
@@ -3824,20 +3824,20 @@ func isTermNodes(l ir.Nodes) bool {
 // Isterminating reports whether the node n, the last one in a
 // statement list, is a terminating statement.
 func isTermNode(n *ir.Node) bool {
-	switch n.Op {
+	switch n.Op() {
 	// NOTE: OLABEL is treated as a separate statement,
 	// not a separate prefix, so skipping to the last statement
 	// in the block handles the labeled statement case by
 	// skipping over the label. No case OLABEL here.
 
 	case ir.OBLOCK:
-		return isTermNodes(n.List)
+		return isTermNodes(n.List())
 
 	case ir.OGOTO, ir.ORETURN, ir.ORETJMP, ir.OPANIC, ir.OFALL:
 		return true
 
 	case ir.OFOR, ir.OFORUNTIL:
-		if n.Left != nil {
+		if n.Left() != nil {
 			return false
 		}
 		if n.HasBreak() {
@@ -3846,23 +3846,23 @@ func isTermNode(n *ir.Node) bool {
 		return true
 
 	case ir.OIF:
-		return isTermNodes(n.Nbody) && isTermNodes(n.Rlist)
+		return isTermNodes(n.Body()) && isTermNodes(n.Rlist())
 
 	case ir.OSWITCH, ir.OTYPESW, ir.OSELECT:
 		if n.HasBreak() {
 			return false
 		}
 		def := false
-		for _, n1 := range n.List.Slice() {
-			if !isTermNodes(n1.Nbody) {
+		for _, n1 := range n.List().Slice() {
+			if !isTermNodes(n1.Body()) {
 				return false
 			}
-			if n1.List.Len() == 0 { // default
+			if n1.List().Len() == 0 { // default
 				def = true
 			}
 		}
 
-		if n.Op != ir.OSELECT && !def {
+		if n.Op() != ir.OSELECT && !def {
 			return false
 		}
 		return true
@@ -3873,35 +3873,35 @@ func isTermNode(n *ir.Node) bool {
 
 // checkreturn makes sure that fn terminates appropriately.
 func checkreturn(fn *ir.Node) {
-	if fn.Type.NumResults() != 0 && fn.Nbody.Len() != 0 {
-		markbreaklist(fn.Nbody, nil)
-		if !isTermNodes(fn.Nbody) {
-			base.ErrorfAt(fn.Func.Endlineno, "missing return at end of function")
+	if fn.Type().NumResults() != 0 && fn.Body().Len() != 0 {
+		markbreaklist(fn.Body(), nil)
+		if !isTermNodes(fn.Body()) {
+			base.ErrorfAt(fn.Func().Endlineno, "missing return at end of function")
 		}
 	}
 }
 
 func deadcode(fn *ir.Node) {
-	deadcodeslice(&fn.Nbody)
+	deadcodeslice(fn.PtrBody())
 	deadcodefn(fn)
 }
 
 func deadcodefn(fn *ir.Node) {
-	if fn.Nbody.Len() == 0 {
+	if fn.Body().Len() == 0 {
 		return
 	}
 
-	for _, n := range fn.Nbody.Slice() {
-		if n.Ninit.Len() > 0 {
+	for _, n := range fn.Body().Slice() {
+		if n.Init().Len() > 0 {
 			return
 		}
-		switch n.Op {
+		switch n.Op() {
 		case ir.OIF:
-			if !ir.IsConst(n.Left, constant.Bool) || n.Nbody.Len() > 0 || n.Rlist.Len() > 0 {
+			if !ir.IsConst(n.Left(), constant.Bool) || n.Body().Len() > 0 || n.Rlist().Len() > 0 {
 				return
 			}
 		case ir.OFOR:
-			if !ir.IsConst(n.Left, constant.Bool) || n.Left.BoolVal() {
+			if !ir.IsConst(n.Left(), constant.Bool) || n.Left().BoolVal() {
 				return
 			}
 		default:
@@ -3909,13 +3909,13 @@ func deadcodefn(fn *ir.Node) {
 		}
 	}
 
-	fn.Nbody.Set([]*ir.Node{ir.Nod(ir.OEMPTY, nil, nil)})
+	fn.PtrBody().Set([]*ir.Node{ir.Nod(ir.OEMPTY, nil, nil)})
 }
 
 func deadcodeslice(nn *ir.Nodes) {
 	var lastLabel = -1
 	for i, n := range nn.Slice() {
-		if n != nil && n.Op == ir.OLABEL {
+		if n != nil && n.Op() == ir.OLABEL {
 			lastLabel = i
 		}
 	}
@@ -3927,16 +3927,16 @@ func deadcodeslice(nn *ir.Nodes) {
 		if n == nil {
 			continue
 		}
-		if n.Op == ir.OIF {
-			n.Left = deadcodeexpr(n.Left)
-			if ir.IsConst(n.Left, constant.Bool) {
+		if n.Op() == ir.OIF {
+			n.SetLeft(deadcodeexpr(n.Left()))
+			if ir.IsConst(n.Left(), constant.Bool) {
 				var body ir.Nodes
-				if n.Left.BoolVal() {
-					n.Rlist = ir.Nodes{}
-					body = n.Nbody
+				if n.Left().BoolVal() {
+					n.SetRlist(ir.Nodes{})
+					body = n.Body()
 				} else {
-					n.Nbody = ir.Nodes{}
-					body = n.Rlist
+					n.SetBody(ir.Nodes{})
+					body = n.Rlist()
 				}
 				// If "then" or "else" branch ends with panic or return statement,
 				// it is safe to remove all statements after this node.
@@ -3944,7 +3944,7 @@ func deadcodeslice(nn *ir.Nodes) {
 				// We must be careful not to deadcode-remove labels, as they
 				// might be the target of a goto. See issue 28616.
 				if body := body.Slice(); len(body) != 0 {
-					switch body[(len(body) - 1)].Op {
+					switch body[(len(body) - 1)].Op() {
 					case ir.ORETURN, ir.ORETJMP, ir.OPANIC:
 						if i > lastLabel {
 							cut = true
@@ -3954,10 +3954,10 @@ func deadcodeslice(nn *ir.Nodes) {
 			}
 		}
 
-		deadcodeslice(&n.Ninit)
-		deadcodeslice(&n.Nbody)
-		deadcodeslice(&n.List)
-		deadcodeslice(&n.Rlist)
+		deadcodeslice(n.PtrInit())
+		deadcodeslice(n.PtrBody())
+		deadcodeslice(n.PtrList())
+		deadcodeslice(n.PtrRlist())
 		if cut {
 			nn.Set(nn.Slice()[:i+1])
 			break
@@ -3969,25 +3969,25 @@ func deadcodeexpr(n *ir.Node) *ir.Node {
 	// Perform dead-code elimination on short-circuited boolean
 	// expressions involving constants with the intent of
 	// producing a constant 'if' condition.
-	switch n.Op {
+	switch n.Op() {
 	case ir.OANDAND:
-		n.Left = deadcodeexpr(n.Left)
-		n.Right = deadcodeexpr(n.Right)
-		if ir.IsConst(n.Left, constant.Bool) {
-			if n.Left.BoolVal() {
-				return n.Right // true && x => x
+		n.SetLeft(deadcodeexpr(n.Left()))
+		n.SetRight(deadcodeexpr(n.Right()))
+		if ir.IsConst(n.Left(), constant.Bool) {
+			if n.Left().BoolVal() {
+				return n.Right() // true && x => x
 			} else {
-				return n.Left // false && x => false
+				return n.Left() // false && x => false
 			}
 		}
 	case ir.OOROR:
-		n.Left = deadcodeexpr(n.Left)
-		n.Right = deadcodeexpr(n.Right)
-		if ir.IsConst(n.Left, constant.Bool) {
-			if n.Left.BoolVal() {
-				return n.Left // true || x => true
+		n.SetLeft(deadcodeexpr(n.Left()))
+		n.SetRight(deadcodeexpr(n.Right()))
+		if ir.IsConst(n.Left(), constant.Bool) {
+			if n.Left().BoolVal() {
+				return n.Left() // true || x => true
 			} else {
-				return n.Right // false || x => x
+				return n.Right() // false || x => x
 			}
 		}
 	}
@@ -3996,16 +3996,16 @@ func deadcodeexpr(n *ir.Node) *ir.Node {
 
 // setTypeNode sets n to an OTYPE node representing t.
 func setTypeNode(n *ir.Node, t *types.Type) {
-	n.Op = ir.OTYPE
-	n.Type = t
-	n.Type.Nod = ir.AsTypesNode(n)
+	n.SetOp(ir.OTYPE)
+	n.SetType(t)
+	n.Type().Nod = ir.AsTypesNode(n)
 }
 
 // getIotaValue returns the current value for "iota",
 // or -1 if not within a ConstSpec.
 func getIotaValue() int64 {
 	if i := len(typecheckdefstack); i > 0 {
-		if x := typecheckdefstack[i-1]; x.Op == ir.OLITERAL {
+		if x := typecheckdefstack[i-1]; x.Op() == ir.OLITERAL {
 			return x.Iota()
 		}
 	}
@@ -4027,8 +4027,8 @@ func curpkg() *types.Pkg {
 
 	// TODO(mdempsky): Standardize on either ODCLFUNC or ONAME for
 	// Curfn, rather than mixing them.
-	if fn.Op == ir.ODCLFUNC {
-		fn = fn.Func.Nname
+	if fn.Op() == ir.ODCLFUNC {
+		fn = fn.Func().Nname
 	}
 
 	return fnpkg(fn)
@@ -4043,12 +4043,12 @@ func methodExprName(n *ir.Node) *ir.Node {
 
 // MethodFunc is like MethodName, but returns the types.Field instead.
 func methodExprFunc(n *ir.Node) *types.Field {
-	switch n.Op {
+	switch n.Op() {
 	case ir.ODOTMETH, ir.OMETHEXPR:
 		return n.Opt().(*types.Field)
 	case ir.OCALLPART:
 		return callpartMethod(n)
 	}
-	base.Fatalf("unexpected node: %v (%v)", n, n.Op)
+	base.Fatalf("unexpected node: %v (%v)", n, n.Op())
 	panic("unreachable")
 }
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index bf31055dcc..be22b7e9db 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -110,7 +110,7 @@ func lexinit() {
 			types.Types[etype] = t
 		}
 		s2.Def = ir.AsTypesNode(typenod(t))
-		ir.AsNode(s2.Def).Name = new(ir.Name)
+		ir.AsNode(s2.Def).SetName(new(ir.Name))
 	}
 
 	for _, s := range &builtinFuncs {
@@ -131,39 +131,39 @@ func lexinit() {
 
 	s := ir.BuiltinPkg.Lookup("true")
 	s.Def = ir.AsTypesNode(nodbool(true))
-	ir.AsNode(s.Def).Sym = lookup("true")
-	ir.AsNode(s.Def).Name = new(ir.Name)
-	ir.AsNode(s.Def).Type = types.UntypedBool
+	ir.AsNode(s.Def).SetSym(lookup("true"))
+	ir.AsNode(s.Def).SetName(new(ir.Name))
+	ir.AsNode(s.Def).SetType(types.UntypedBool)
 
 	s = ir.BuiltinPkg.Lookup("false")
 	s.Def = ir.AsTypesNode(nodbool(false))
-	ir.AsNode(s.Def).Sym = lookup("false")
-	ir.AsNode(s.Def).Name = new(ir.Name)
-	ir.AsNode(s.Def).Type = types.UntypedBool
+	ir.AsNode(s.Def).SetSym(lookup("false"))
+	ir.AsNode(s.Def).SetName(new(ir.Name))
+	ir.AsNode(s.Def).SetType(types.UntypedBool)
 
 	s = lookup("_")
 	s.Block = -100
 	s.Def = ir.AsTypesNode(NewName(s))
 	types.Types[types.TBLANK] = types.New(types.TBLANK)
-	ir.AsNode(s.Def).Type = types.Types[types.TBLANK]
+	ir.AsNode(s.Def).SetType(types.Types[types.TBLANK])
 	ir.BlankNode = ir.AsNode(s.Def)
 
 	s = ir.BuiltinPkg.Lookup("_")
 	s.Block = -100
 	s.Def = ir.AsTypesNode(NewName(s))
 	types.Types[types.TBLANK] = types.New(types.TBLANK)
-	ir.AsNode(s.Def).Type = types.Types[types.TBLANK]
+	ir.AsNode(s.Def).SetType(types.Types[types.TBLANK])
 
 	types.Types[types.TNIL] = types.New(types.TNIL)
 	s = ir.BuiltinPkg.Lookup("nil")
 	s.Def = ir.AsTypesNode(nodnil())
-	ir.AsNode(s.Def).Sym = s
-	ir.AsNode(s.Def).Name = new(ir.Name)
+	ir.AsNode(s.Def).SetSym(s)
+	ir.AsNode(s.Def).SetName(new(ir.Name))
 
 	s = ir.BuiltinPkg.Lookup("iota")
 	s.Def = ir.AsTypesNode(ir.Nod(ir.OIOTA, nil, nil))
-	ir.AsNode(s.Def).Sym = s
-	ir.AsNode(s.Def).Name = new(ir.Name)
+	ir.AsNode(s.Def).SetSym(s)
+	ir.AsNode(s.Def).SetName(new(ir.Name))
 }
 
 func typeinit() {
@@ -182,7 +182,7 @@ func typeinit() {
 	types.Types[types.TUNSAFEPTR] = t
 	t.Sym = unsafepkg.Lookup("Pointer")
 	t.Sym.Def = ir.AsTypesNode(typenod(t))
-	ir.AsNode(t.Sym.Def).Name = new(ir.Name)
+	ir.AsNode(t.Sym.Def).SetName(new(ir.Name))
 	dowidth(types.Types[types.TUNSAFEPTR])
 
 	for et := types.TINT8; et <= types.TUINT64; et++ {
@@ -359,7 +359,7 @@ func lexinit1() {
 	types.Bytetype = types.New(types.TUINT8)
 	types.Bytetype.Sym = s
 	s.Def = ir.AsTypesNode(typenod(types.Bytetype))
-	ir.AsNode(s.Def).Name = new(ir.Name)
+	ir.AsNode(s.Def).SetName(new(ir.Name))
 	dowidth(types.Bytetype)
 
 	// rune alias
@@ -367,7 +367,7 @@ func lexinit1() {
 	types.Runetype = types.New(types.TINT32)
 	types.Runetype.Sym = s
 	s.Def = ir.AsTypesNode(typenod(types.Runetype))
-	ir.AsNode(s.Def).Name = new(ir.Name)
+	ir.AsNode(s.Def).SetName(new(ir.Name))
 	dowidth(types.Runetype)
 
 	// backend-dependent builtin types (e.g. int).
@@ -385,7 +385,7 @@ func lexinit1() {
 		t.Sym = s1
 		types.Types[s.etype] = t
 		s1.Def = ir.AsTypesNode(typenod(t))
-		ir.AsNode(s1.Def).Name = new(ir.Name)
+		ir.AsNode(s1.Def).SetName(new(ir.Name))
 		s1.Origpkg = ir.BuiltinPkg
 
 		dowidth(t)
@@ -412,7 +412,7 @@ func finishUniverse() {
 	}
 
 	nodfp = NewName(lookup(".fp"))
-	nodfp.Type = types.Types[types.TINT32]
+	nodfp.SetType(types.Types[types.TINT32])
 	nodfp.SetClass(ir.PPARAM)
-	nodfp.Name.SetUsed(true)
+	nodfp.Name().SetUsed(true)
 }
diff --git a/src/cmd/compile/internal/gc/unsafe.go b/src/cmd/compile/internal/gc/unsafe.go
index fce79a6319..c9b0dbcf2f 100644
--- a/src/cmd/compile/internal/gc/unsafe.go
+++ b/src/cmd/compile/internal/gc/unsafe.go
@@ -11,23 +11,23 @@ import (
 
 // evalunsafe evaluates a package unsafe operation and returns the result.
 func evalunsafe(n *ir.Node) int64 {
-	switch n.Op {
+	switch n.Op() {
 	case ir.OALIGNOF, ir.OSIZEOF:
-		n.Left = typecheck(n.Left, ctxExpr)
-		n.Left = defaultlit(n.Left, nil)
-		tr := n.Left.Type
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		n.SetLeft(defaultlit(n.Left(), nil))
+		tr := n.Left().Type()
 		if tr == nil {
 			return 0
 		}
 		dowidth(tr)
-		if n.Op == ir.OALIGNOF {
+		if n.Op() == ir.OALIGNOF {
 			return int64(tr.Align)
 		}
 		return tr.Width
 
 	case ir.OOFFSETOF:
 		// must be a selector.
-		if n.Left.Op != ir.OXDOT {
+		if n.Left().Op() != ir.OXDOT {
 			base.Errorf("invalid expression %v", n)
 			return 0
 		}
@@ -35,14 +35,14 @@ func evalunsafe(n *ir.Node) int64 {
 		// Remember base of selector to find it back after dot insertion.
 		// Since r->left may be mutated by typechecking, check it explicitly
 		// first to track it correctly.
-		n.Left.Left = typecheck(n.Left.Left, ctxExpr)
-		sbase := n.Left.Left
+		n.Left().SetLeft(typecheck(n.Left().Left(), ctxExpr))
+		sbase := n.Left().Left()
 
-		n.Left = typecheck(n.Left, ctxExpr)
-		if n.Left.Type == nil {
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		if n.Left().Type() == nil {
 			return 0
 		}
-		switch n.Left.Op {
+		switch n.Left().Op() {
 		case ir.ODOT, ir.ODOTPTR:
 			break
 		case ir.OCALLPART:
@@ -55,27 +55,27 @@ func evalunsafe(n *ir.Node) int64 {
 
 		// Sum offsets for dots until we reach sbase.
 		var v int64
-		for r := n.Left; r != sbase; r = r.Left {
-			switch r.Op {
+		for r := n.Left(); r != sbase; r = r.Left() {
+			switch r.Op() {
 			case ir.ODOTPTR:
 				// For Offsetof(s.f), s may itself be a pointer,
 				// but accessing f must not otherwise involve
 				// indirection via embedded pointer types.
-				if r.Left != sbase {
-					base.Errorf("invalid expression %v: selector implies indirection of embedded %v", n, r.Left)
+				if r.Left() != sbase {
+					base.Errorf("invalid expression %v: selector implies indirection of embedded %v", n, r.Left())
 					return 0
 				}
 				fallthrough
 			case ir.ODOT:
-				v += r.Xoffset
+				v += r.Offset()
 			default:
-				ir.Dump("unsafenmagic", n.Left)
-				base.Fatalf("impossible %#v node after dot insertion", r.Op)
+				ir.Dump("unsafenmagic", n.Left())
+				base.Fatalf("impossible %#v node after dot insertion", r.Op())
 			}
 		}
 		return v
 	}
 
-	base.Fatalf("unexpected op %v", n.Op)
+	base.Fatalf("unexpected op %v", n.Op())
 	return 0
 }
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 619a413b9e..77cf59bde8 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -27,39 +27,39 @@ func walk(fn *ir.Node) {
 	errorsBefore := base.Errors()
 
 	if base.Flag.W != 0 {
-		s := fmt.Sprintf("\nbefore walk %v", Curfn.Func.Nname.Sym)
-		ir.DumpList(s, Curfn.Nbody)
+		s := fmt.Sprintf("\nbefore walk %v", Curfn.Func().Nname.Sym())
+		ir.DumpList(s, Curfn.Body())
 	}
 
 	lno := base.Pos
 
 	// Final typecheck for any unused variables.
-	for i, ln := range fn.Func.Dcl {
-		if ln.Op == ir.ONAME && (ln.Class() == ir.PAUTO || ln.Class() == ir.PAUTOHEAP) {
+	for i, ln := range fn.Func().Dcl {
+		if ln.Op() == ir.ONAME && (ln.Class() == ir.PAUTO || ln.Class() == ir.PAUTOHEAP) {
 			ln = typecheck(ln, ctxExpr|ctxAssign)
-			fn.Func.Dcl[i] = ln
+			fn.Func().Dcl[i] = ln
 		}
 	}
 
 	// Propagate the used flag for typeswitch variables up to the NONAME in its definition.
-	for _, ln := range fn.Func.Dcl {
-		if ln.Op == ir.ONAME && (ln.Class() == ir.PAUTO || ln.Class() == ir.PAUTOHEAP) && ln.Name.Defn != nil && ln.Name.Defn.Op == ir.OTYPESW && ln.Name.Used() {
-			ln.Name.Defn.Left.Name.SetUsed(true)
+	for _, ln := range fn.Func().Dcl {
+		if ln.Op() == ir.ONAME && (ln.Class() == ir.PAUTO || ln.Class() == ir.PAUTOHEAP) && ln.Name().Defn != nil && ln.Name().Defn.Op() == ir.OTYPESW && ln.Name().Used() {
+			ln.Name().Defn.Left().Name().SetUsed(true)
 		}
 	}
 
-	for _, ln := range fn.Func.Dcl {
-		if ln.Op != ir.ONAME || (ln.Class() != ir.PAUTO && ln.Class() != ir.PAUTOHEAP) || ln.Sym.Name[0] == '&' || ln.Name.Used() {
+	for _, ln := range fn.Func().Dcl {
+		if ln.Op() != ir.ONAME || (ln.Class() != ir.PAUTO && ln.Class() != ir.PAUTOHEAP) || ln.Sym().Name[0] == '&' || ln.Name().Used() {
 			continue
 		}
-		if defn := ln.Name.Defn; defn != nil && defn.Op == ir.OTYPESW {
-			if defn.Left.Name.Used() {
+		if defn := ln.Name().Defn; defn != nil && defn.Op() == ir.OTYPESW {
+			if defn.Left().Name().Used() {
 				continue
 			}
-			base.ErrorfAt(defn.Left.Pos, "%v declared but not used", ln.Sym)
-			defn.Left.Name.SetUsed(true) // suppress repeats
+			base.ErrorfAt(defn.Left().Pos(), "%v declared but not used", ln.Sym())
+			defn.Left().Name().SetUsed(true) // suppress repeats
 		} else {
-			base.ErrorfAt(ln.Pos, "%v declared but not used", ln.Sym)
+			base.ErrorfAt(ln.Pos(), "%v declared but not used", ln.Sym())
 		}
 	}
 
@@ -67,17 +67,17 @@ func walk(fn *ir.Node) {
 	if base.Errors() > errorsBefore {
 		return
 	}
-	walkstmtlist(Curfn.Nbody.Slice())
+	walkstmtlist(Curfn.Body().Slice())
 	if base.Flag.W != 0 {
-		s := fmt.Sprintf("after walk %v", Curfn.Func.Nname.Sym)
-		ir.DumpList(s, Curfn.Nbody)
+		s := fmt.Sprintf("after walk %v", Curfn.Func().Nname.Sym())
+		ir.DumpList(s, Curfn.Body())
 	}
 
 	zeroResults()
 	heapmoves()
-	if base.Flag.W != 0 && Curfn.Func.Enter.Len() > 0 {
-		s := fmt.Sprintf("enter %v", Curfn.Func.Nname.Sym)
-		ir.DumpList(s, Curfn.Func.Enter)
+	if base.Flag.W != 0 && Curfn.Func().Enter.Len() > 0 {
+		s := fmt.Sprintf("enter %v", Curfn.Func().Nname.Sym())
+		ir.DumpList(s, Curfn.Func().Enter)
 	}
 }
 
@@ -88,10 +88,10 @@ func walkstmtlist(s []*ir.Node) {
 }
 
 func paramoutheap(fn *ir.Node) bool {
-	for _, ln := range fn.Func.Dcl {
+	for _, ln := range fn.Func().Dcl {
 		switch ln.Class() {
 		case ir.PPARAMOUT:
-			if isParamStackCopy(ln) || ln.Name.Addrtaken() {
+			if isParamStackCopy(ln) || ln.Name().Addrtaken() {
 				return true
 			}
 
@@ -113,14 +113,14 @@ func walkstmt(n *ir.Node) *ir.Node {
 
 	setlineno(n)
 
-	walkstmtlist(n.Ninit.Slice())
+	walkstmtlist(n.Init().Slice())
 
-	switch n.Op {
+	switch n.Op() {
 	default:
-		if n.Op == ir.ONAME {
-			base.Errorf("%v is not a top level statement", n.Sym)
+		if n.Op() == ir.ONAME {
+			base.Errorf("%v is not a top level statement", n.Sym())
 		} else {
-			base.Errorf("%v is not a top level statement", n.Op)
+			base.Errorf("%v is not a top level statement", n.Op())
 		}
 		ir.Dump("nottop", n)
 
@@ -148,13 +148,13 @@ func walkstmt(n *ir.Node) *ir.Node {
 		if n.Typecheck() == 0 {
 			base.Fatalf("missing typecheck: %+v", n)
 		}
-		wascopy := n.Op == ir.OCOPY
-		init := n.Ninit
-		n.Ninit.Set(nil)
+		wascopy := n.Op() == ir.OCOPY
+		init := n.Init()
+		n.PtrInit().Set(nil)
 		n = walkexpr(n, &init)
 		n = addinit(n, init.Slice())
-		if wascopy && n.Op == ir.OCONVNOP {
-			n.Op = ir.OEMPTY // don't leave plain values as statements.
+		if wascopy && n.Op() == ir.OCONVNOP {
+			n.SetOp(ir.OEMPTY) // don't leave plain values as statements.
 		}
 
 	// special case for a receive where we throw away
@@ -163,11 +163,11 @@ func walkstmt(n *ir.Node) *ir.Node {
 		if n.Typecheck() == 0 {
 			base.Fatalf("missing typecheck: %+v", n)
 		}
-		init := n.Ninit
-		n.Ninit.Set(nil)
+		init := n.Init()
+		n.PtrInit().Set(nil)
 
-		n.Left = walkexpr(n.Left, &init)
-		n = mkcall1(chanfn("chanrecv1", 2, n.Left.Type), nil, &init, n.Left, nodnil())
+		n.SetLeft(walkexpr(n.Left(), &init))
+		n = mkcall1(chanfn("chanrecv1", 2, n.Left().Type()), nil, &init, n.Left(), nodnil())
 		n = walkexpr(n, &init)
 
 		n = addinit(n, init.Slice())
@@ -186,138 +186,138 @@ func walkstmt(n *ir.Node) *ir.Node {
 		break
 
 	case ir.ODCL:
-		v := n.Left
+		v := n.Left()
 		if v.Class() == ir.PAUTOHEAP {
 			if base.Flag.CompilingRuntime {
 				base.Errorf("%v escapes to heap, not allowed in runtime", v)
 			}
 			if prealloc[v] == nil {
-				prealloc[v] = callnew(v.Type)
+				prealloc[v] = callnew(v.Type())
 			}
-			nn := ir.Nod(ir.OAS, v.Name.Param.Heapaddr, prealloc[v])
+			nn := ir.Nod(ir.OAS, v.Name().Param.Heapaddr, prealloc[v])
 			nn.SetColas(true)
 			nn = typecheck(nn, ctxStmt)
 			return walkstmt(nn)
 		}
 
 	case ir.OBLOCK:
-		walkstmtlist(n.List.Slice())
+		walkstmtlist(n.List().Slice())
 
 	case ir.OCASE:
 		base.Errorf("case statement out of place")
 
 	case ir.ODEFER:
-		Curfn.Func.SetHasDefer(true)
-		Curfn.Func.NumDefers++
-		if Curfn.Func.NumDefers > maxOpenDefers {
+		Curfn.Func().SetHasDefer(true)
+		Curfn.Func().NumDefers++
+		if Curfn.Func().NumDefers > maxOpenDefers {
 			// Don't allow open-coded defers if there are more than
 			// 8 defers in the function, since we use a single
 			// byte to record active defers.
-			Curfn.Func.SetOpenCodedDeferDisallowed(true)
+			Curfn.Func().SetOpenCodedDeferDisallowed(true)
 		}
-		if n.Esc != EscNever {
+		if n.Esc() != EscNever {
 			// If n.Esc is not EscNever, then this defer occurs in a loop,
 			// so open-coded defers cannot be used in this function.
-			Curfn.Func.SetOpenCodedDeferDisallowed(true)
+			Curfn.Func().SetOpenCodedDeferDisallowed(true)
 		}
 		fallthrough
 	case ir.OGO:
-		switch n.Left.Op {
+		switch n.Left().Op() {
 		case ir.OPRINT, ir.OPRINTN:
-			n.Left = wrapCall(n.Left, &n.Ninit)
+			n.SetLeft(wrapCall(n.Left(), n.PtrInit()))
 
 		case ir.ODELETE:
-			if mapfast(n.Left.List.First().Type) == mapslow {
-				n.Left = wrapCall(n.Left, &n.Ninit)
+			if mapfast(n.Left().List().First().Type()) == mapslow {
+				n.SetLeft(wrapCall(n.Left(), n.PtrInit()))
 			} else {
-				n.Left = walkexpr(n.Left, &n.Ninit)
+				n.SetLeft(walkexpr(n.Left(), n.PtrInit()))
 			}
 
 		case ir.OCOPY:
-			n.Left = copyany(n.Left, &n.Ninit, true)
+			n.SetLeft(copyany(n.Left(), n.PtrInit(), true))
 
 		case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
-			if n.Left.Nbody.Len() > 0 {
-				n.Left = wrapCall(n.Left, &n.Ninit)
+			if n.Left().Body().Len() > 0 {
+				n.SetLeft(wrapCall(n.Left(), n.PtrInit()))
 			} else {
-				n.Left = walkexpr(n.Left, &n.Ninit)
+				n.SetLeft(walkexpr(n.Left(), n.PtrInit()))
 			}
 
 		default:
-			n.Left = walkexpr(n.Left, &n.Ninit)
+			n.SetLeft(walkexpr(n.Left(), n.PtrInit()))
 		}
 
 	case ir.OFOR, ir.OFORUNTIL:
-		if n.Left != nil {
-			walkstmtlist(n.Left.Ninit.Slice())
-			init := n.Left.Ninit
-			n.Left.Ninit.Set(nil)
-			n.Left = walkexpr(n.Left, &init)
-			n.Left = addinit(n.Left, init.Slice())
+		if n.Left() != nil {
+			walkstmtlist(n.Left().Init().Slice())
+			init := n.Left().Init()
+			n.Left().PtrInit().Set(nil)
+			n.SetLeft(walkexpr(n.Left(), &init))
+			n.SetLeft(addinit(n.Left(), init.Slice()))
 		}
 
-		n.Right = walkstmt(n.Right)
-		if n.Op == ir.OFORUNTIL {
-			walkstmtlist(n.List.Slice())
+		n.SetRight(walkstmt(n.Right()))
+		if n.Op() == ir.OFORUNTIL {
+			walkstmtlist(n.List().Slice())
 		}
-		walkstmtlist(n.Nbody.Slice())
+		walkstmtlist(n.Body().Slice())
 
 	case ir.OIF:
-		n.Left = walkexpr(n.Left, &n.Ninit)
-		walkstmtlist(n.Nbody.Slice())
-		walkstmtlist(n.Rlist.Slice())
+		n.SetLeft(walkexpr(n.Left(), n.PtrInit()))
+		walkstmtlist(n.Body().Slice())
+		walkstmtlist(n.Rlist().Slice())
 
 	case ir.ORETURN:
-		Curfn.Func.NumReturns++
-		if n.List.Len() == 0 {
+		Curfn.Func().NumReturns++
+		if n.List().Len() == 0 {
 			break
 		}
-		if (Curfn.Type.FuncType().Outnamed && n.List.Len() > 1) || paramoutheap(Curfn) {
+		if (Curfn.Type().FuncType().Outnamed && n.List().Len() > 1) || paramoutheap(Curfn) {
 			// assign to the function out parameters,
 			// so that reorder3 can fix up conflicts
 			var rl []*ir.Node
 
-			for _, ln := range Curfn.Func.Dcl {
+			for _, ln := range Curfn.Func().Dcl {
 				cl := ln.Class()
 				if cl == ir.PAUTO || cl == ir.PAUTOHEAP {
 					break
 				}
 				if cl == ir.PPARAMOUT {
 					if isParamStackCopy(ln) {
-						ln = walkexpr(typecheck(ir.Nod(ir.ODEREF, ln.Name.Param.Heapaddr, nil), ctxExpr), nil)
+						ln = walkexpr(typecheck(ir.Nod(ir.ODEREF, ln.Name().Param.Heapaddr, nil), ctxExpr), nil)
 					}
 					rl = append(rl, ln)
 				}
 			}
 
-			if got, want := n.List.Len(), len(rl); got != want {
+			if got, want := n.List().Len(), len(rl); got != want {
 				// order should have rewritten multi-value function calls
 				// with explicit OAS2FUNC nodes.
 				base.Fatalf("expected %v return arguments, have %v", want, got)
 			}
 
 			// move function calls out, to make reorder3's job easier.
-			walkexprlistsafe(n.List.Slice(), &n.Ninit)
+			walkexprlistsafe(n.List().Slice(), n.PtrInit())
 
-			ll := ascompatee(n.Op, rl, n.List.Slice(), &n.Ninit)
-			n.List.Set(reorder3(ll))
+			ll := ascompatee(n.Op(), rl, n.List().Slice(), n.PtrInit())
+			n.PtrList().Set(reorder3(ll))
 			break
 		}
-		walkexprlist(n.List.Slice(), &n.Ninit)
+		walkexprlist(n.List().Slice(), n.PtrInit())
 
 		// For each return parameter (lhs), assign the corresponding result (rhs).
-		lhs := Curfn.Type.Results()
-		rhs := n.List.Slice()
+		lhs := Curfn.Type().Results()
+		rhs := n.List().Slice()
 		res := make([]*ir.Node, lhs.NumFields())
 		for i, nl := range lhs.FieldSlice() {
 			nname := ir.AsNode(nl.Nname)
 			if isParamHeapCopy(nname) {
-				nname = nname.Name.Param.Stackcopy
+				nname = nname.Name().Param.Stackcopy
 			}
 			a := ir.Nod(ir.OAS, nname, rhs[i])
-			res[i] = convas(a, &n.Ninit)
+			res[i] = convas(a, n.PtrInit())
 		}
-		n.List.Set(res)
+		n.PtrList().Set(res)
 
 	case ir.ORETJMP:
 		break
@@ -335,7 +335,7 @@ func walkstmt(n *ir.Node) *ir.Node {
 		n = walkrange(n)
 	}
 
-	if n.Op == ir.ONAME {
+	if n.Op() == ir.ONAME {
 		base.Fatalf("walkstmt ended up with name: %+v", n)
 	}
 	return n
@@ -419,24 +419,24 @@ func walkexpr(n *ir.Node, init *ir.Nodes) *ir.Node {
 	}
 
 	// Eagerly checkwidth all expressions for the back end.
-	if n.Type != nil && !n.Type.WidthCalculated() {
-		switch n.Type.Etype {
+	if n.Type() != nil && !n.Type().WidthCalculated() {
+		switch n.Type().Etype {
 		case types.TBLANK, types.TNIL, types.TIDEAL:
 		default:
-			checkwidth(n.Type)
+			checkwidth(n.Type())
 		}
 	}
 
-	if init == &n.Ninit {
+	if init == n.PtrInit() {
 		// not okay to use n->ninit when walking n,
 		// because we might replace n with some other node
 		// and would lose the init list.
 		base.Fatalf("walkexpr init == &n->ninit")
 	}
 
-	if n.Ninit.Len() != 0 {
-		walkstmtlist(n.Ninit.Slice())
-		init.AppendNodes(&n.Ninit)
+	if n.Init().Len() != 0 {
+		walkstmtlist(n.Init().Slice())
+		init.AppendNodes(n.PtrInit())
 	}
 
 	lno := setlineno(n)
@@ -449,20 +449,20 @@ func walkexpr(n *ir.Node, init *ir.Nodes) *ir.Node {
 		base.Fatalf("missed typecheck: %+v", n)
 	}
 
-	if n.Type.IsUntyped() {
+	if n.Type().IsUntyped() {
 		base.Fatalf("expression has untyped type: %+v", n)
 	}
 
-	if n.Op == ir.ONAME && n.Class() == ir.PAUTOHEAP {
-		nn := ir.Nod(ir.ODEREF, n.Name.Param.Heapaddr, nil)
+	if n.Op() == ir.ONAME && n.Class() == ir.PAUTOHEAP {
+		nn := ir.Nod(ir.ODEREF, n.Name().Param.Heapaddr, nil)
 		nn = typecheck(nn, ctxExpr)
 		nn = walkexpr(nn, init)
-		nn.Left.MarkNonNil()
+		nn.Left().MarkNonNil()
 		return nn
 	}
 
 opswitch:
-	switch n.Op {
+	switch n.Op() {
 	default:
 		ir.Dump("walk", n)
 		base.Fatalf("walkexpr: switch 1 unknown op %+S", n)
@@ -477,134 +477,134 @@ opswitch:
 
 	case ir.ONOT, ir.ONEG, ir.OPLUS, ir.OBITNOT, ir.OREAL, ir.OIMAG, ir.ODOTMETH, ir.ODOTINTER,
 		ir.ODEREF, ir.OSPTR, ir.OITAB, ir.OIDATA, ir.OADDR:
-		n.Left = walkexpr(n.Left, init)
+		n.SetLeft(walkexpr(n.Left(), init))
 
 	case ir.OEFACE, ir.OAND, ir.OANDNOT, ir.OSUB, ir.OMUL, ir.OADD, ir.OOR, ir.OXOR, ir.OLSH, ir.ORSH:
-		n.Left = walkexpr(n.Left, init)
-		n.Right = walkexpr(n.Right, init)
+		n.SetLeft(walkexpr(n.Left(), init))
+		n.SetRight(walkexpr(n.Right(), init))
 
 	case ir.ODOT, ir.ODOTPTR:
 		usefield(n)
-		n.Left = walkexpr(n.Left, init)
+		n.SetLeft(walkexpr(n.Left(), init))
 
 	case ir.ODOTTYPE, ir.ODOTTYPE2:
-		n.Left = walkexpr(n.Left, init)
+		n.SetLeft(walkexpr(n.Left(), init))
 		// Set up interface type addresses for back end.
-		n.Right = typename(n.Type)
-		if n.Op == ir.ODOTTYPE {
-			n.Right.Right = typename(n.Left.Type)
+		n.SetRight(typename(n.Type()))
+		if n.Op() == ir.ODOTTYPE {
+			n.Right().SetRight(typename(n.Left().Type()))
 		}
-		if !n.Type.IsInterface() && !n.Left.Type.IsEmptyInterface() {
-			n.List.Set1(itabname(n.Type, n.Left.Type))
+		if !n.Type().IsInterface() && !n.Left().Type().IsEmptyInterface() {
+			n.PtrList().Set1(itabname(n.Type(), n.Left().Type()))
 		}
 
 	case ir.OLEN, ir.OCAP:
 		if isRuneCount(n) {
 			// Replace len([]rune(string)) with runtime.countrunes(string).
-			n = mkcall("countrunes", n.Type, init, conv(n.Left.Left, types.Types[types.TSTRING]))
+			n = mkcall("countrunes", n.Type(), init, conv(n.Left().Left(), types.Types[types.TSTRING]))
 			break
 		}
 
-		n.Left = walkexpr(n.Left, init)
+		n.SetLeft(walkexpr(n.Left(), init))
 
 		// replace len(*[10]int) with 10.
 		// delayed until now to preserve side effects.
-		t := n.Left.Type
+		t := n.Left().Type()
 
 		if t.IsPtr() {
 			t = t.Elem()
 		}
 		if t.IsArray() {
-			safeexpr(n.Left, init)
+			safeexpr(n.Left(), init)
 			n = origIntConst(n, t.NumElem())
 			n.SetTypecheck(1)
 		}
 
 	case ir.OCOMPLEX:
 		// Use results from call expression as arguments for complex.
-		if n.Left == nil && n.Right == nil {
-			n.Left = n.List.First()
-			n.Right = n.List.Second()
+		if n.Left() == nil && n.Right() == nil {
+			n.SetLeft(n.List().First())
+			n.SetRight(n.List().Second())
 		}
-		n.Left = walkexpr(n.Left, init)
-		n.Right = walkexpr(n.Right, init)
+		n.SetLeft(walkexpr(n.Left(), init))
+		n.SetRight(walkexpr(n.Right(), init))
 
 	case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
 		n = walkcompare(n, init)
 
 	case ir.OANDAND, ir.OOROR:
-		n.Left = walkexpr(n.Left, init)
+		n.SetLeft(walkexpr(n.Left(), init))
 
 		// cannot put side effects from n.Right on init,
 		// because they cannot run before n.Left is checked.
 		// save elsewhere and store on the eventual n.Right.
 		var ll ir.Nodes
 
-		n.Right = walkexpr(n.Right, &ll)
-		n.Right = addinit(n.Right, ll.Slice())
+		n.SetRight(walkexpr(n.Right(), &ll))
+		n.SetRight(addinit(n.Right(), ll.Slice()))
 
 	case ir.OPRINT, ir.OPRINTN:
 		n = walkprint(n, init)
 
 	case ir.OPANIC:
-		n = mkcall("gopanic", nil, init, n.Left)
+		n = mkcall("gopanic", nil, init, n.Left())
 
 	case ir.ORECOVER:
-		n = mkcall("gorecover", n.Type, init, ir.Nod(ir.OADDR, nodfp, nil))
+		n = mkcall("gorecover", n.Type(), init, ir.Nod(ir.OADDR, nodfp, nil))
 
 	case ir.OCLOSUREVAR, ir.OCFUNC:
 
 	case ir.OCALLINTER, ir.OCALLFUNC, ir.OCALLMETH:
-		if n.Op == ir.OCALLINTER {
+		if n.Op() == ir.OCALLINTER {
 			usemethod(n)
 			markUsedIfaceMethod(n)
 		}
 
-		if n.Op == ir.OCALLFUNC && n.Left.Op == ir.OCLOSURE {
+		if n.Op() == ir.OCALLFUNC && n.Left().Op() == ir.OCLOSURE {
 			// Transform direct call of a closure to call of a normal function.
 			// transformclosure already did all preparation work.
 
 			// Prepend captured variables to argument list.
-			n.List.Prepend(n.Left.Func.ClosureEnter.Slice()...)
-			n.Left.Func.ClosureEnter.Set(nil)
+			n.PtrList().Prepend(n.Left().Func().ClosureEnter.Slice()...)
+			n.Left().Func().ClosureEnter.Set(nil)
 
 			// Replace OCLOSURE with ONAME/PFUNC.
-			n.Left = n.Left.Func.Nname
+			n.SetLeft(n.Left().Func().Nname)
 
 			// Update type of OCALLFUNC node.
 			// Output arguments had not changed, but their offsets could.
-			if n.Left.Type.NumResults() == 1 {
-				n.Type = n.Left.Type.Results().Field(0).Type
+			if n.Left().Type().NumResults() == 1 {
+				n.SetType(n.Left().Type().Results().Field(0).Type)
 			} else {
-				n.Type = n.Left.Type.Results()
+				n.SetType(n.Left().Type().Results())
 			}
 		}
 
 		walkCall(n, init)
 
 	case ir.OAS, ir.OASOP:
-		init.AppendNodes(&n.Ninit)
+		init.AppendNodes(n.PtrInit())
 
 		// Recognize m[k] = append(m[k], ...) so we can reuse
 		// the mapassign call.
-		mapAppend := n.Left.Op == ir.OINDEXMAP && n.Right.Op == ir.OAPPEND
-		if mapAppend && !samesafeexpr(n.Left, n.Right.List.First()) {
-			base.Fatalf("not same expressions: %v != %v", n.Left, n.Right.List.First())
+		mapAppend := n.Left().Op() == ir.OINDEXMAP && n.Right().Op() == ir.OAPPEND
+		if mapAppend && !samesafeexpr(n.Left(), n.Right().List().First()) {
+			base.Fatalf("not same expressions: %v != %v", n.Left(), n.Right().List().First())
 		}
 
-		n.Left = walkexpr(n.Left, init)
-		n.Left = safeexpr(n.Left, init)
+		n.SetLeft(walkexpr(n.Left(), init))
+		n.SetLeft(safeexpr(n.Left(), init))
 
 		if mapAppend {
-			n.Right.List.SetFirst(n.Left)
+			n.Right().List().SetFirst(n.Left())
 		}
 
-		if n.Op == ir.OASOP {
+		if n.Op() == ir.OASOP {
 			// Rewrite x op= y into x = x op y.
-			n.Right = ir.Nod(n.SubOp(), n.Left, n.Right)
-			n.Right = typecheck(n.Right, ctxExpr)
+			n.SetRight(ir.Nod(n.SubOp(), n.Left(), n.Right()))
+			n.SetRight(typecheck(n.Right(), ctxExpr))
 
-			n.Op = ir.OAS
+			n.SetOp(ir.OAS)
 			n.ResetAux()
 		}
 
@@ -612,35 +612,35 @@ opswitch:
 			break
 		}
 
-		if n.Right == nil {
+		if n.Right() == nil {
 			// TODO(austin): Check all "implicit zeroing"
 			break
 		}
 
-		if !instrumenting && isZero(n.Right) {
+		if !instrumenting && isZero(n.Right()) {
 			break
 		}
 
-		switch n.Right.Op {
+		switch n.Right().Op() {
 		default:
-			n.Right = walkexpr(n.Right, init)
+			n.SetRight(walkexpr(n.Right(), init))
 
 		case ir.ORECV:
 			// x = <-c; n.Left is x, n.Right.Left is c.
 			// order.stmt made sure x is addressable.
-			n.Right.Left = walkexpr(n.Right.Left, init)
+			n.Right().SetLeft(walkexpr(n.Right().Left(), init))
 
-			n1 := ir.Nod(ir.OADDR, n.Left, nil)
-			r := n.Right.Left // the channel
-			n = mkcall1(chanfn("chanrecv1", 2, r.Type), nil, init, r, n1)
+			n1 := ir.Nod(ir.OADDR, n.Left(), nil)
+			r := n.Right().Left() // the channel
+			n = mkcall1(chanfn("chanrecv1", 2, r.Type()), nil, init, r, n1)
 			n = walkexpr(n, init)
 			break opswitch
 
 		case ir.OAPPEND:
 			// x = append(...)
-			r := n.Right
-			if r.Type.Elem().NotInHeap() {
-				base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", r.Type.Elem())
+			r := n.Right()
+			if r.Type().Elem().NotInHeap() {
+				base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", r.Type().Elem())
 			}
 			switch {
 			case isAppendOfMake(r):
@@ -651,86 +651,86 @@ opswitch:
 			default:
 				r = walkappend(r, init, n)
 			}
-			n.Right = r
-			if r.Op == ir.OAPPEND {
+			n.SetRight(r)
+			if r.Op() == ir.OAPPEND {
 				// Left in place for back end.
 				// Do not add a new write barrier.
 				// Set up address of type for back end.
-				r.Left = typename(r.Type.Elem())
+				r.SetLeft(typename(r.Type().Elem()))
 				break opswitch
 			}
 			// Otherwise, lowered for race detector.
 			// Treat as ordinary assignment.
 		}
 
-		if n.Left != nil && n.Right != nil {
+		if n.Left() != nil && n.Right() != nil {
 			n = convas(n, init)
 		}
 
 	case ir.OAS2:
-		init.AppendNodes(&n.Ninit)
-		walkexprlistsafe(n.List.Slice(), init)
-		walkexprlistsafe(n.Rlist.Slice(), init)
-		ll := ascompatee(ir.OAS, n.List.Slice(), n.Rlist.Slice(), init)
+		init.AppendNodes(n.PtrInit())
+		walkexprlistsafe(n.List().Slice(), init)
+		walkexprlistsafe(n.Rlist().Slice(), init)
+		ll := ascompatee(ir.OAS, n.List().Slice(), n.Rlist().Slice(), init)
 		ll = reorder3(ll)
 		n = liststmt(ll)
 
 	// a,b,... = fn()
 	case ir.OAS2FUNC:
-		init.AppendNodes(&n.Ninit)
+		init.AppendNodes(n.PtrInit())
 
-		r := n.Right
-		walkexprlistsafe(n.List.Slice(), init)
+		r := n.Right()
+		walkexprlistsafe(n.List().Slice(), init)
 		r = walkexpr(r, init)
 
 		if isIntrinsicCall(r) {
-			n.Right = r
+			n.SetRight(r)
 			break
 		}
 		init.Append(r)
 
-		ll := ascompatet(n.List, r.Type)
+		ll := ascompatet(n.List(), r.Type())
 		n = liststmt(ll)
 
 	// x, y = <-c
 	// order.stmt made sure x is addressable or blank.
 	case ir.OAS2RECV:
-		init.AppendNodes(&n.Ninit)
+		init.AppendNodes(n.PtrInit())
 
-		r := n.Right
-		walkexprlistsafe(n.List.Slice(), init)
-		r.Left = walkexpr(r.Left, init)
+		r := n.Right()
+		walkexprlistsafe(n.List().Slice(), init)
+		r.SetLeft(walkexpr(r.Left(), init))
 		var n1 *ir.Node
-		if ir.IsBlank(n.List.First()) {
+		if ir.IsBlank(n.List().First()) {
 			n1 = nodnil()
 		} else {
-			n1 = ir.Nod(ir.OADDR, n.List.First(), nil)
+			n1 = ir.Nod(ir.OADDR, n.List().First(), nil)
 		}
-		fn := chanfn("chanrecv2", 2, r.Left.Type)
-		ok := n.List.Second()
-		call := mkcall1(fn, types.Types[types.TBOOL], init, r.Left, n1)
+		fn := chanfn("chanrecv2", 2, r.Left().Type())
+		ok := n.List().Second()
+		call := mkcall1(fn, types.Types[types.TBOOL], init, r.Left(), n1)
 		n = ir.Nod(ir.OAS, ok, call)
 		n = typecheck(n, ctxStmt)
 
 	// a,b = m[i]
 	case ir.OAS2MAPR:
-		init.AppendNodes(&n.Ninit)
+		init.AppendNodes(n.PtrInit())
 
-		r := n.Right
-		walkexprlistsafe(n.List.Slice(), init)
-		r.Left = walkexpr(r.Left, init)
-		r.Right = walkexpr(r.Right, init)
-		t := r.Left.Type
+		r := n.Right()
+		walkexprlistsafe(n.List().Slice(), init)
+		r.SetLeft(walkexpr(r.Left(), init))
+		r.SetRight(walkexpr(r.Right(), init))
+		t := r.Left().Type()
 
 		fast := mapfast(t)
 		var key *ir.Node
 		if fast != mapslow {
 			// fast versions take key by value
-			key = r.Right
+			key = r.Right()
 		} else {
 			// standard version takes key by reference
 			// order.expr made sure key is addressable.
-			key = ir.Nod(ir.OADDR, r.Right, nil)
+			key = ir.Nod(ir.OADDR, r.Right(), nil)
 		}
 
 		// from:
@@ -738,32 +738,32 @@ opswitch:
 		// to:
 		//   var,b = mapaccess2*(t, m, i)
 		//   a = *var
-		a := n.List.First()
+		a := n.List().First()
 
 		if w := t.Elem().Width; w <= zeroValSize {
 			fn := mapfn(mapaccess2[fast], t)
-			r = mkcall1(fn, fn.Type.Results(), init, typename(t), r.Left, key)
+			r = mkcall1(fn, fn.Type().Results(), init, typename(t), r.Left(), key)
 		} else {
 			fn := mapfn("mapaccess2_fat", t)
 			z := zeroaddr(w)
-			r = mkcall1(fn, fn.Type.Results(), init, typename(t), r.Left, key, z)
+			r = mkcall1(fn, fn.Type().Results(), init, typename(t), r.Left(), key, z)
 		}
 
 		// mapaccess2* returns a typed bool, but due to spec changes,
 		// the boolean result of i.(T) is now untyped so we make it the
 		// same type as the variable on the lhs.
-		if ok := n.List.Second(); !ir.IsBlank(ok) && ok.Type.IsBoolean() {
-			r.Type.Field(1).Type = ok.Type
+		if ok := n.List().Second(); !ir.IsBlank(ok) && ok.Type().IsBoolean() {
+			r.Type().Field(1).Type = ok.Type()
 		}
-		n.Right = r
-		n.Op = ir.OAS2FUNC
+		n.SetRight(r)
+		n.SetOp(ir.OAS2FUNC)
 
 		// don't generate a = *var if a is _
 		if !ir.IsBlank(a) {
 			var_ := temp(types.NewPtr(t.Elem()))
 			var_.SetTypecheck(1)
 			var_.MarkNonNil() // mapaccess always returns a non-nil pointer
-			n.List.SetFirst(var_)
+			n.List().SetFirst(var_)
 			n = walkexpr(n, init)
 			init.Append(n)
 			n = ir.Nod(ir.OAS, a, ir.Nod(ir.ODEREF, var_, nil))
@@ -773,13 +773,13 @@ opswitch:
 		n = walkexpr(n, init)
 
 	case ir.ODELETE:
-		init.AppendNodes(&n.Ninit)
-		map_ := n.List.First()
-		key := n.List.Second()
+		init.AppendNodes(n.PtrInit())
+		map_ := n.List().First()
+		key := n.List().Second()
 		map_ = walkexpr(map_, init)
 		key = walkexpr(key, init)
 
-		t := map_.Type
+		t := map_.Type()
 		fast := mapfast(t)
 		if fast == mapslow {
 			// order.stmt made sure key is addressable.
@@ -788,17 +788,17 @@ opswitch:
 		n = mkcall1(mapfndel(mapdelete[fast], t), nil, init, typename(t), map_, key)
 
 	case ir.OAS2DOTTYPE:
-		walkexprlistsafe(n.List.Slice(), init)
-		n.Right = walkexpr(n.Right, init)
+		walkexprlistsafe(n.List().Slice(), init)
+		n.SetRight(walkexpr(n.Right(), init))
 
 	case ir.OCONVIFACE:
-		n.Left = walkexpr(n.Left, init)
+		n.SetLeft(walkexpr(n.Left(), init))
 
-		fromType := n.Left.Type
-		toType := n.Type
+		fromType := n.Left().Type()
+		toType := n.Type()
 
-		if !fromType.IsInterface() && !ir.IsBlank(Curfn.Func.Nname) { // skip unnamed functions (func _())
-			markTypeUsedInInterface(fromType, Curfn.Func.LSym)
+		if !fromType.IsInterface() && !ir.IsBlank(Curfn.Func().Nname) { // skip unnamed functions (func _())
+			markTypeUsedInInterface(fromType, Curfn.Func().LSym)
 		}
 
 		// typeword generates the type word of the interface value.
@@ -811,8 +811,8 @@ opswitch:
 
 		// Optimize convT2E or convT2I as a two-word copy when T is pointer-shaped.
 		if isdirectiface(fromType) {
-			l := ir.Nod(ir.OEFACE, typeword(), n.Left)
-			l.Type = toType
+			l := ir.Nod(ir.OEFACE, typeword(), n.Left())
+			l.SetType(toType)
 			l.SetTypecheck(n.Typecheck())
 			n = l
 			break
@@ -823,10 +823,10 @@ opswitch:
 			staticuint64s.SetClass(ir.PEXTERN)
 			// The actual type is [256]uint64, but we use [256*8]uint8 so we can address
 			// individual bytes.
-			staticuint64s.Type = types.NewArray(types.Types[types.TUINT8], 256*8)
+			staticuint64s.SetType(types.NewArray(types.Types[types.TUINT8], 256*8))
 			zerobase = NewName(Runtimepkg.Lookup("zerobase"))
 			zerobase.SetClass(ir.PEXTERN)
-			zerobase.Type = types.Types[types.TUINTPTR]
+			zerobase.SetType(types.Types[types.TUINTPTR])
 		}
 
 		// Optimize convT2{E,I} for many cases in which T is not pointer-shaped,
@@ -836,33 +836,33 @@ opswitch:
 		switch {
 		case fromType.Size() == 0:
 			// n.Left is zero-sized. Use zerobase.
-			cheapexpr(n.Left, init) // Evaluate n.Left for side-effects. See issue 19246.
+			cheapexpr(n.Left(), init) // Evaluate n.Left for side-effects. See issue 19246.
 			value = zerobase
 		case fromType.IsBoolean() || (fromType.Size() == 1 && fromType.IsInteger()):
 			// n.Left is a bool/byte. Use staticuint64s[n.Left * 8] on little-endian
 			// and staticuint64s[n.Left * 8 + 7] on big-endian.
-			n.Left = cheapexpr(n.Left, init)
+			n.SetLeft(cheapexpr(n.Left(), init))
 			// byteindex widens n.Left so that the multiplication doesn't overflow.
-			index := ir.Nod(ir.OLSH, byteindex(n.Left), nodintconst(3))
+			index := ir.Nod(ir.OLSH, byteindex(n.Left()), nodintconst(3))
 			if thearch.LinkArch.ByteOrder == binary.BigEndian {
 				index = ir.Nod(ir.OADD, index, nodintconst(7))
 			}
 			value = ir.Nod(ir.OINDEX, staticuint64s, index)
 			value.SetBounded(true)
-		case n.Left.Class() == ir.PEXTERN && n.Left.Name != nil && n.Left.Name.Readonly():
+		case n.Left().Class() == ir.PEXTERN && n.Left().Name() != nil && n.Left().Name().Readonly():
 			// n.Left is a readonly global; use it directly.
-			value = n.Left
-		case !fromType.IsInterface() && n.Esc == EscNone && fromType.Width <= 1024:
+			value = n.Left()
+		case !fromType.IsInterface() && n.Esc() == EscNone && fromType.Width <= 1024:
 			// n.Left does not escape. Use a stack temporary initialized to n.Left.
 			value = temp(fromType)
-			init.Append(typecheck(ir.Nod(ir.OAS, value, n.Left), ctxStmt))
+			init.Append(typecheck(ir.Nod(ir.OAS, value, n.Left()), ctxStmt))
 		}
 
 		if value != nil {
 			// Value is identical to n.Left.
 			// Construct the interface directly: {type/itab, &value}.
 			l := ir.Nod(ir.OEFACE, typeword(), typecheck(ir.Nod(ir.OADDR, value, nil), ctxExpr))
-			l.Type = toType
+			l.SetType(toType)
 			l.SetTypecheck(n.Typecheck())
 			n = l
 			break
@@ -877,7 +877,7 @@ opswitch:
 		if toType.IsEmptyInterface() && fromType.IsInterface() && !fromType.IsEmptyInterface() {
 			// Evaluate the input interface.
 			c := temp(fromType)
-			init.Append(ir.Nod(ir.OAS, c, n.Left))
+			init.Append(ir.Nod(ir.OAS, c, n.Left()))
 
 			// Get the itab out of the interface.
 			tmp := temp(types.NewPtr(types.Types[types.TUINT8]))
@@ -885,12 +885,12 @@ opswitch:
 
 			// Get the type out of the itab.
 			nif := ir.Nod(ir.OIF, typecheck(ir.Nod(ir.ONE, tmp, nodnil()), ctxExpr), nil)
-			nif.Nbody.Set1(ir.Nod(ir.OAS, tmp, itabType(tmp)))
+			nif.PtrBody().Set1(ir.Nod(ir.OAS, tmp, itabType(tmp)))
 			init.Append(nif)
 
 			// Build the result.
-			e := ir.Nod(ir.OEFACE, tmp, ifaceData(n.Pos, c, types.NewPtr(types.Types[types.TUINT8])))
-			e.Type = toType // assign type manually, typecheck doesn't understand OEFACE.
+			e := ir.Nod(ir.OEFACE, tmp, ifaceData(n.Pos(), c, types.NewPtr(types.Types[types.TUINT8])))
+			e.SetType(toType) // assign type manually, typecheck doesn't understand OEFACE.
 			e.SetTypecheck(1)
 			n = e
 			break
@@ -905,14 +905,14 @@ opswitch:
 			fn := syslook(fnname)
 			dowidth(fromType)
 			fn = substArgTypes(fn, fromType)
-			dowidth(fn.Type)
+			dowidth(fn.Type())
 			call := ir.Nod(ir.OCALL, fn, nil)
-			call.List.Set1(n.Left)
+			call.PtrList().Set1(n.Left())
 			call = typecheck(call, ctxExpr)
 			call = walkexpr(call, init)
 			call = safeexpr(call, init)
 			e := ir.Nod(ir.OEFACE, typeword(), call)
-			e.Type = toType
+			e.SetType(toType)
 			e.SetTypecheck(1)
 			n = e
 			break
@@ -927,7 +927,7 @@ opswitch:
 			tab = typeword()
 		}
 
-		v := n.Left
+		v := n.Left()
 		if needsaddr {
 			// Types of large or unknown size are passed by reference.
 			// Orderexpr arranged for n.Left to be a temporary for all
@@ -936,7 +936,7 @@ opswitch:
 			// with non-interface cases, is not visible to order.stmt, so we
 			// have to fall back on allocating a temp here.
 			if !islvalue(v) {
-				v = copyexpr(v, v.Type, init)
+				v = copyexpr(v, v.Type(), init)
 			}
 			v = ir.Nod(ir.OADDR, v, nil)
 		}
@@ -944,41 +944,41 @@ opswitch:
 		dowidth(fromType)
 		fn := syslook(fnname)
 		fn = substArgTypes(fn, fromType, toType)
-		dowidth(fn.Type)
+		dowidth(fn.Type())
 		n = ir.Nod(ir.OCALL, fn, nil)
-		n.List.Set2(tab, v)
+		n.PtrList().Set2(tab, v)
 		n = typecheck(n, ctxExpr)
 		n = walkexpr(n, init)
 
 	case ir.OCONV, ir.OCONVNOP:
-		n.Left = walkexpr(n.Left, init)
-		if n.Op == ir.OCONVNOP && checkPtr(Curfn, 1) {
-			if n.Type.IsPtr() && n.Left.Type.IsUnsafePtr() { // unsafe.Pointer to *T
+		n.SetLeft(walkexpr(n.Left(), init))
+		if n.Op() == ir.OCONVNOP && checkPtr(Curfn, 1) {
+			if n.Type().IsPtr() && n.Left().Type().IsUnsafePtr() { // unsafe.Pointer to *T
 				n = walkCheckPtrAlignment(n, init, nil)
 				break
 			}
-			if n.Type.IsUnsafePtr() && n.Left.Type.IsUintptr() { // uintptr to unsafe.Pointer
+			if n.Type().IsUnsafePtr() && n.Left().Type().IsUintptr() { // uintptr to unsafe.Pointer
 				n = walkCheckPtrArithmetic(n, init)
 				break
 			}
 		}
-		param, result := rtconvfn(n.Left.Type, n.Type)
+		param, result := rtconvfn(n.Left().Type(), n.Type())
 		if param == types.Txxx {
 			break
 		}
 		fn := ir.BasicTypeNames[param] + "to" + ir.BasicTypeNames[result]
-		n = conv(mkcall(fn, types.Types[result], init, conv(n.Left, types.Types[param])), n.Type)
+		n = conv(mkcall(fn, types.Types[result], init, conv(n.Left(), types.Types[param])), n.Type())
 
 	case ir.ODIV, ir.OMOD:
-		n.Left = walkexpr(n.Left, init)
-		n.Right = walkexpr(n.Right, init)
+		n.SetLeft(walkexpr(n.Left(), init))
+		n.SetRight(walkexpr(n.Right(), init))
 
 		// rewrite complex div into function call.
-		et := n.Left.Type.Etype
+		et := n.Left().Type().Etype
 
-		if isComplex[et] && n.Op == ir.ODIV {
-			t := n.Type
-			n = mkcall("complex128div", types.Types[types.TCOMPLEX128], init, conv(n.Left, types.Types[types.TCOMPLEX128]), conv(n.Right, types.Types[types.TCOMPLEX128]))
+		if isComplex[et] && n.Op() == ir.ODIV {
+			t := n.Type()
+			n = mkcall("complex128div", types.Types[types.TCOMPLEX128], init, conv(n.Left(), types.Types[types.TCOMPLEX128]), conv(n.Right(), types.Types[types.TCOMPLEX128]))
 			n = conv(n, t)
 			break
 		}
@@ -992,12 +992,12 @@ opswitch:
 		// TODO: Remove this code once we can introduce
 		// runtime calls late in SSA processing.
 		if Widthreg < 8 && (et == types.TINT64 || et == types.TUINT64) {
-			if n.Right.Op == ir.OLITERAL {
+			if n.Right().Op() == ir.OLITERAL {
 				// Leave div/mod by constant powers of 2 or small 16-bit constants.
 				// The SSA backend will handle those.
 				switch et {
 				case types.TINT64:
-					c := n.Right.Int64Val()
+					c := n.Right().Int64Val()
 					if c < 0 {
 						c = -c
 					}
@@ -1005,7 +1005,7 @@ opswitch:
 						break opswitch
 					}
 				case types.TUINT64:
-					c := n.Right.Uint64Val()
+					c := n.Right().Uint64Val()
 					if c < 1<<16 {
 						break opswitch
 					}
@@ -1020,63 +1020,63 @@ opswitch:
 			} else {
 				fn = "uint64"
 			}
-			if n.Op == ir.ODIV {
+			if n.Op() == ir.ODIV {
 				fn += "div"
 			} else {
 				fn += "mod"
 			}
-			n = mkcall(fn, n.Type, init, conv(n.Left, types.Types[et]), conv(n.Right, types.Types[et]))
+			n = mkcall(fn, n.Type(), init, conv(n.Left(), types.Types[et]), conv(n.Right(), types.Types[et]))
 		}
 
 	case ir.OINDEX:
-		n.Left = walkexpr(n.Left, init)
+		n.SetLeft(walkexpr(n.Left(), init))
 
 		// save the original node for bounds checking elision.
 		// If it was a ODIV/OMOD walk might rewrite it.
-		r := n.Right
+		r := n.Right()
 
-		n.Right = walkexpr(n.Right, init)
+		n.SetRight(walkexpr(n.Right(), init))
 
 		// if range of type cannot exceed static array bound,
 		// disable bounds check.
 		if n.Bounded() {
 			break
 		}
-		t := n.Left.Type
+		t := n.Left().Type()
 		if t != nil && t.IsPtr() {
 			t = t.Elem()
 		}
 		if t.IsArray() {
 			n.SetBounded(bounded(r, t.NumElem()))
-			if base.Flag.LowerM != 0 && n.Bounded() && !ir.IsConst(n.Right, constant.Int) {
+			if base.Flag.LowerM != 0 && n.Bounded() && !ir.IsConst(n.Right(), constant.Int) {
 				base.Warn("index bounds check elided")
 			}
-			if smallintconst(n.Right) && !n.Bounded() {
+			if smallintconst(n.Right()) && !n.Bounded() {
 				base.Errorf("index out of bounds")
 			}
-		} else if ir.IsConst(n.Left, constant.String) {
-			n.SetBounded(bounded(r, int64(len(n.Left.StringVal()))))
-			if base.Flag.LowerM != 0 && n.Bounded() && !ir.IsConst(n.Right, constant.Int) {
+		} else if ir.IsConst(n.Left(), constant.String) {
+			n.SetBounded(bounded(r, int64(len(n.Left().StringVal()))))
+			if base.Flag.LowerM != 0 && n.Bounded() && !ir.IsConst(n.Right(), constant.Int) {
 				base.Warn("index bounds check elided")
 			}
-			if smallintconst(n.Right) && !n.Bounded() {
+			if smallintconst(n.Right()) && !n.Bounded() {
 				base.Errorf("index out of bounds")
 			}
 		}
 
-		if ir.IsConst(n.Right, constant.Int) {
-			if v := n.Right.Val(); constant.Sign(v) < 0 || doesoverflow(v, types.Types[types.TINT]) {
+		if ir.IsConst(n.Right(), constant.Int) {
+			if v := n.Right().Val(); constant.Sign(v) < 0 || doesoverflow(v, types.Types[types.TINT]) {
 				base.Errorf("index out of bounds")
 			}
 		}
 
 	case ir.OINDEXMAP:
 		// Replace m[k] with *map{access1,assign}(maptype, m, &k)
-		n.Left = walkexpr(n.Left, init)
-		n.Right = walkexpr(n.Right, init)
-		map_ := n.Left
-		key := n.Right
-		t := map_.Type
+		n.SetLeft(walkexpr(n.Left(), init))
+		n.SetRight(walkexpr(n.Right(), init))
+		map_ := n.Left()
+		key := n.Right()
+		t := map_.Type()
 		if n.IndexMapLValue() {
 			// This m[k] expression is on the left-hand side of an assignment.
 			fast := mapfast(t)
@@ -1102,26 +1102,26 @@ opswitch:
 				n = mkcall1(mapfn("mapaccess1_fat", t), types.NewPtr(t.Elem()), init, typename(t), map_, key, z)
 			}
 		}
-		n.Type = types.NewPtr(t.Elem())
+		n.SetType(types.NewPtr(t.Elem()))
 		n.MarkNonNil() // mapaccess1* and mapassign always return non-nil pointers.
 		n = ir.Nod(ir.ODEREF, n, nil)
-		n.Type = t.Elem()
+		n.SetType(t.Elem())
 		n.SetTypecheck(1)
 
 	case ir.ORECV:
 		base.Fatalf("walkexpr ORECV") // should see inside OAS only
 
 	case ir.OSLICEHEADER:
-		n.Left = walkexpr(n.Left, init)
-		n.List.SetFirst(walkexpr(n.List.First(), init))
-		n.List.SetSecond(walkexpr(n.List.Second(), init))
+		n.SetLeft(walkexpr(n.Left(), init))
+		n.List().SetFirst(walkexpr(n.List().First(), init))
+		n.List().SetSecond(walkexpr(n.List().Second(), init))
 
 	case ir.OSLICE, ir.OSLICEARR, ir.OSLICESTR, ir.OSLICE3, ir.OSLICE3ARR:
-		checkSlice := checkPtr(Curfn, 1) && n.Op == ir.OSLICE3ARR && n.Left.Op == ir.OCONVNOP && n.Left.Left.Type.IsUnsafePtr()
+		checkSlice := checkPtr(Curfn, 1) && n.Op() == ir.OSLICE3ARR && n.Left().Op() == ir.OCONVNOP && n.Left().Left().Type().IsUnsafePtr()
 		if checkSlice {
-			n.Left.Left = walkexpr(n.Left.Left, init)
+			n.Left().SetLeft(walkexpr(n.Left().Left(), init))
 		} else {
-			n.Left = walkexpr(n.Left, init)
+			n.SetLeft(walkexpr(n.Left(), init))
 		}
 		low, high, max := n.SliceBounds()
 		low = walkexpr(low, init)
@@ -1133,15 +1133,15 @@ opswitch:
 		max = walkexpr(max, init)
 		n.SetSliceBounds(low, high, max)
 		if checkSlice {
-			n.Left = walkCheckPtrAlignment(n.Left, init, max)
+			n.SetLeft(walkCheckPtrAlignment(n.Left(), init, max))
 		}
-		if n.Op.IsSlice3() {
-			if max != nil && max.Op == ir.OCAP && samesafeexpr(n.Left, max.Left) {
+		if n.Op().IsSlice3() {
+			if max != nil && max.Op() == ir.OCAP && samesafeexpr(n.Left(), max.Left()) {
 				// Reduce x[i:j:cap(x)] to x[i:j].
-				if n.Op == ir.OSLICE3 {
-					n.Op = ir.OSLICE
+				if n.Op() == ir.OSLICE3 {
+					n.SetOp(ir.OSLICE)
 				} else {
-					n.Op = ir.OSLICEARR
+					n.SetOp(ir.OSLICEARR)
 				}
 				n = reduceSlice(n)
 			}
@@ -1150,22 +1150,22 @@ opswitch:
 		}
 
 	case ir.ONEW:
-		if n.Type.Elem().NotInHeap() {
-			base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", n.Type.Elem())
+		if n.Type().Elem().NotInHeap() {
+			base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", n.Type().Elem())
 		}
-		if n.Esc == EscNone {
-			if n.Type.Elem().Width >= maxImplicitStackVarSize {
+		if n.Esc() == EscNone {
+			if n.Type().Elem().Width >= maxImplicitStackVarSize {
 				base.Fatalf("large ONEW with EscNone: %v", n)
 			}
-			r := temp(n.Type.Elem())
+			r := temp(n.Type().Elem())
 			r = ir.Nod(ir.OAS, r, nil) // zero temp
 			r = typecheck(r, ctxStmt)
 			init.Append(r)
-			r = ir.Nod(ir.OADDR, r.Left, nil)
+			r = ir.Nod(ir.OADDR, r.Left(), nil)
 			r = typecheck(r, ctxExpr)
 			n = r
 		} else {
-			n = callnew(n.Type.Elem())
+			n = callnew(n.Type().Elem())
 		}
 
 	case ir.OADDSTR:
@@ -1182,34 +1182,34 @@ opswitch:
 	case ir.OCLOSE:
 		fn := syslook("closechan")
 
-		fn = substArgTypes(fn, n.Left.Type)
-		n = mkcall1(fn, nil, init, n.Left)
+		fn = substArgTypes(fn, n.Left().Type())
+		n = mkcall1(fn, nil, init, n.Left())
 
 	case ir.OMAKECHAN:
 		// When size fits into int, use makechan instead of
 		// makechan64, which is faster and shorter on 32 bit platforms.
-		size := n.Left
+		size := n.Left()
 		fnname := "makechan64"
 		argtype := types.Types[types.TINT64]
 
 		// Type checking guarantees that TIDEAL size is positive and fits in an int.
 		// The case of size overflow when converting TUINT or TUINTPTR to TINT
 		// will be handled by the negative range checks in makechan during runtime.
-		if size.Type.IsKind(types.TIDEAL) || size.Type.Size() <= types.Types[types.TUINT].Size() {
+		if size.Type().IsKind(types.TIDEAL) || size.Type().Size() <= types.Types[types.TUINT].Size() {
 			fnname = "makechan"
 			argtype = types.Types[types.TINT]
 		}
 
-		n = mkcall1(chanfn(fnname, 1, n.Type), n.Type, init, typename(n.Type), conv(size, argtype))
+		n = mkcall1(chanfn(fnname, 1, n.Type()), n.Type(), init, typename(n.Type()), conv(size, argtype))
 
 	case ir.OMAKEMAP:
-		t := n.Type
+		t := n.Type()
 		hmapType := hmap(t)
-		hint := n.Left
+		hint := n.Left()
 
 		// var h *hmap
 		var h *ir.Node
-		if n.Esc == EscNone {
+		if n.Esc() == EscNone {
 			// Allocate hmap on stack.
 
 			// var hv hmap
@@ -1243,7 +1243,7 @@ opswitch:
 				// var bv bmap
 				bv := temp(bmap(t))
 				zero = ir.Nod(ir.OAS, bv, nil)
-				nif.Nbody.Append(zero)
+				nif.PtrBody().Append(zero)
 
 				// b = &bv
 				b := ir.Nod(ir.OADDR, bv, nil)
@@ -1251,7 +1251,7 @@ opswitch:
 				// h.buckets = b
 				bsym := hmapType.Field(5).Sym // hmap.buckets see reflect.go:hmap
 				na := ir.Nod(ir.OAS, nodSym(ir.ODOT, h, bsym), b)
-				nif.Nbody.Append(na)
+				nif.PtrBody().Append(na)
 
 				nif = typecheck(nif, ctxStmt)
 				nif = walkstmt(nif)
@@ -1267,7 +1267,7 @@ opswitch:
 			// For hint <= BUCKETSIZE overLoadFactor(hint, 0) is false
 			// and no buckets will be allocated by makemap. Therefore,
 			// no buckets need to be allocated in this code path.
-			if n.Esc == EscNone {
+			if n.Esc() == EscNone {
 				// Only need to initialize h.hash0 since
 				// hmap h has been allocated on the stack already.
 				// h.hash0 = fastrand()
@@ -1283,10 +1283,10 @@ opswitch:
 				// hmap on the heap and initialize hmap's hash0 field.
 				fn := syslook("makemap_small")
 				fn = substArgTypes(fn, t.Key(), t.Elem())
-				n = mkcall1(fn, n.Type, init)
+				n = mkcall1(fn, n.Type(), init)
 			}
 		} else {
-			if n.Esc != EscNone {
+			if n.Esc() != EscNone {
 				h = nodnil()
 			}
 			// Map initialization with a variable or large hint is
@@ -1303,28 +1303,28 @@ opswitch:
 			// See checkmake call in TMAP case of OMAKE case in OpSwitch in typecheck1 function.
 			// The case of hint overflow when converting TUINT or TUINTPTR to TINT
 			// will be handled by the negative range checks in makemap during runtime.
-			if hint.Type.IsKind(types.TIDEAL) || hint.Type.Size() <= types.Types[types.TUINT].Size() {
+			if hint.Type().IsKind(types.TIDEAL) || hint.Type().Size() <= types.Types[types.TUINT].Size() {
 				fnname = "makemap"
 				argtype = types.Types[types.TINT]
 			}
 
 			fn := syslook(fnname)
 			fn = substArgTypes(fn, hmapType, t.Key(), t.Elem())
-			n = mkcall1(fn, n.Type, init, typename(n.Type), conv(hint, argtype), h)
+			n = mkcall1(fn, n.Type(), init, typename(n.Type()), conv(hint, argtype), h)
 		}
 
 	case ir.OMAKESLICE:
-		l := n.Left
-		r := n.Right
+		l := n.Left()
+		r := n.Right()
 		if r == nil {
 			r = safeexpr(l, init)
 			l = r
 		}
-		t := n.Type
+		t := n.Type()
 		if t.Elem().NotInHeap() {
 			base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", t.Elem())
 		}
-		if n.Esc == EscNone {
+		if n.Esc() == EscNone {
 			if why := heapAllocReason(n); why != "" {
 				base.Fatalf("%v has EscNone, but %v", n, why)
 			}
@@ -1344,8 +1344,8 @@ opswitch:
 			// }
 			nif := ir.Nod(ir.OIF, ir.Nod(ir.OGT, conv(l, types.Types[types.TUINT64]), nodintconst(i)), nil)
 			niflen := ir.Nod(ir.OIF, ir.Nod(ir.OLT, l, nodintconst(0)), nil)
-			niflen.Nbody.Set1(mkcall("panicmakeslicelen", nil, init))
-			nif.Nbody.Append(niflen, mkcall("panicmakeslicecap", nil, init))
+			niflen.PtrBody().Set1(mkcall("panicmakeslicelen", nil, init))
+			nif.PtrBody().Append(niflen, mkcall("panicmakeslicecap", nil, init))
 			nif = typecheck(nif, ctxStmt)
 			init.Append(nif)
 
@@ -1356,7 +1356,7 @@ opswitch:
 			init.Append(a)
 			r := ir.Nod(ir.OSLICE, var_, nil) // arr[:l]
 			r.SetSliceBounds(nil, l, nil)
-			r = conv(r, n.Type) // in case n.Type is named.
+			r = conv(r, n.Type()) // in case n.Type is named.
 			r = typecheck(r, ctxExpr)
 			r = walkexpr(r, init)
 			n = r
@@ -1373,19 +1373,19 @@ opswitch:
 			// Type checking guarantees that TIDEAL len/cap are positive and fit in an int.
 			// The case of len or cap overflow when converting TUINT or TUINTPTR to TINT
 			// will be handled by the negative range checks in makeslice during runtime.
-			if (len.Type.IsKind(types.TIDEAL) || len.Type.Size() <= types.Types[types.TUINT].Size()) &&
-				(cap.Type.IsKind(types.TIDEAL) || cap.Type.Size() <= types.Types[types.TUINT].Size()) {
+			if (len.Type().IsKind(types.TIDEAL) || len.Type().Size() <= types.Types[types.TUINT].Size()) &&
+				(cap.Type().IsKind(types.TIDEAL) || cap.Type().Size() <= types.Types[types.TUINT].Size()) {
 				fnname = "makeslice"
 				argtype = types.Types[types.TINT]
 			}
 
 			m := ir.Nod(ir.OSLICEHEADER, nil, nil)
-			m.Type = t
+			m.SetType(t)
 
 			fn := syslook(fnname)
-			m.Left = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), conv(len, argtype), conv(cap, argtype))
-			m.Left.MarkNonNil()
-			m.List.Set2(conv(len, types.Types[types.TINT]), conv(cap, types.Types[types.TINT]))
+			m.SetLeft(mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), conv(len, argtype), conv(cap, argtype)))
+			m.Left().MarkNonNil()
+			m.PtrList().Set2(conv(len, types.Types[types.TINT]), conv(cap, types.Types[types.TINT]))
 
 			m = typecheck(m, ctxExpr)
 			m = walkexpr(m, init)
@@ -1393,18 +1393,18 @@ opswitch:
 		}
 
 	case ir.OMAKESLICECOPY:
-		if n.Esc == EscNone {
+		if n.Esc() == EscNone {
 			base.Fatalf("OMAKESLICECOPY with EscNone: %v", n)
 		}
 
-		t := n.Type
+		t := n.Type()
 		if t.Elem().NotInHeap() {
 			base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", t.Elem())
 		}
 
-		length := conv(n.Left, types.Types[types.TINT])
-		copylen := ir.Nod(ir.OLEN, n.Right, nil)
-		copyptr := ir.Nod(ir.OSPTR, n.Right, nil)
+		length := conv(n.Left(), types.Types[types.TINT])
+		copylen := ir.Nod(ir.OLEN, n.Right(), nil)
+		copyptr := ir.Nod(ir.OSPTR, n.Right(), nil)
 
 		if !t.Elem().HasPointers() && n.Bounded() {
 			// When len(to)==len(from) and elements have no pointers:
@@ -1418,10 +1418,10 @@ opswitch:
 			// instantiate mallocgc(size uintptr, typ *byte, needszero bool) unsafe.Pointer
 			fn := syslook("mallocgc")
 			sh := ir.Nod(ir.OSLICEHEADER, nil, nil)
-			sh.Left = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, size, nodnil(), nodbool(false))
-			sh.Left.MarkNonNil()
-			sh.List.Set2(length, length)
-			sh.Type = t
+			sh.SetLeft(mkcall1(fn, types.Types[types.TUNSAFEPTR], init, size, nodnil(), nodbool(false)))
+			sh.Left().MarkNonNil()
+			sh.PtrList().Set2(length, length)
+			sh.SetType(t)
 
 			s := temp(t)
 			r := typecheck(ir.Nod(ir.OAS, s, sh), ctxStmt)
@@ -1441,61 +1441,61 @@ opswitch:
 			// instantiate makeslicecopy(typ *byte, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointer
 			fn := syslook("makeslicecopy")
 			s := ir.Nod(ir.OSLICEHEADER, nil, nil)
-			s.Left = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), length, copylen, conv(copyptr, types.Types[types.TUNSAFEPTR]))
-			s.Left.MarkNonNil()
-			s.List.Set2(length, length)
-			s.Type = t
+			s.SetLeft(mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), length, copylen, conv(copyptr, types.Types[types.TUNSAFEPTR])))
+			s.Left().MarkNonNil()
+			s.PtrList().Set2(length, length)
+			s.SetType(t)
 			n = typecheck(s, ctxExpr)
 			n = walkexpr(n, init)
 		}
 
 	case ir.ORUNESTR:
 		a := nodnil()
-		if n.Esc == EscNone {
+		if n.Esc() == EscNone {
 			t := types.NewArray(types.Types[types.TUINT8], 4)
 			a = ir.Nod(ir.OADDR, temp(t), nil)
 		}
 		// intstring(*[4]byte, rune)
-		n = mkcall("intstring", n.Type, init, a, conv(n.Left, types.Types[types.TINT64]))
+		n = mkcall("intstring", n.Type(), init, a, conv(n.Left(), types.Types[types.TINT64]))
 
 	case ir.OBYTES2STR, ir.ORUNES2STR:
 		a := nodnil()
-		if n.Esc == EscNone {
+		if n.Esc() == EscNone {
 			// Create temporary buffer for string on stack.
 			t := types.NewArray(types.Types[types.TUINT8], tmpstringbufsize)
 			a = ir.Nod(ir.OADDR, temp(t), nil)
 		}
-		if n.Op == ir.ORUNES2STR {
+		if n.Op() == ir.ORUNES2STR {
 			// slicerunetostring(*[32]byte, []rune) string
-			n = mkcall("slicerunetostring", n.Type, init, a, n.Left)
+			n = mkcall("slicerunetostring", n.Type(), init, a, n.Left())
 		} else {
 			// slicebytetostring(*[32]byte, ptr *byte, n int) string
-			n.Left = cheapexpr(n.Left, init)
-			ptr, len := backingArrayPtrLen(n.Left)
-			n = mkcall("slicebytetostring", n.Type, init, a, ptr, len)
+			n.SetLeft(cheapexpr(n.Left(), init))
+			ptr, len := backingArrayPtrLen(n.Left())
+			n = mkcall("slicebytetostring", n.Type(), init, a, ptr, len)
 		}
 
 	case ir.OBYTES2STRTMP:
-		n.Left = walkexpr(n.Left, init)
+		n.SetLeft(walkexpr(n.Left(), init))
 		if !instrumenting {
 			// Let the backend handle OBYTES2STRTMP directly
 			// to avoid a function call to slicebytetostringtmp.
 			break
 		}
 		// slicebytetostringtmp(ptr *byte, n int) string
-		n.Left = cheapexpr(n.Left, init)
-		ptr, len := backingArrayPtrLen(n.Left)
-		n = mkcall("slicebytetostringtmp", n.Type, init, ptr, len)
+		n.SetLeft(cheapexpr(n.Left(), init))
+		ptr, len := backingArrayPtrLen(n.Left())
+		n = mkcall("slicebytetostringtmp", n.Type(), init, ptr, len)
 
 	case ir.OSTR2BYTES:
-		s := n.Left
+		s := n.Left()
 		if ir.IsConst(s, constant.String) {
 			sc := s.StringVal()
 
 			// Allocate a [n]byte of the right size.
 			t := types.NewArray(types.Types[types.TUINT8], int64(len(sc)))
 			var a *ir.Node
-			if n.Esc == EscNone && len(sc) <= int(maxImplicitStackVarSize) {
+			if n.Esc() == EscNone && len(sc) <= int(maxImplicitStackVarSize) {
 				a = ir.Nod(ir.OADDR, temp(t), nil)
 			} else {
 				a = callnew(t)
@@ -1514,20 +1514,20 @@ opswitch:
 			}
 
 			// Slice the [n]byte to a []byte.
-			n.Op = ir.OSLICEARR
-			n.Left = p
+			n.SetOp(ir.OSLICEARR)
+			n.SetLeft(p)
 			n = walkexpr(n, init)
 			break
 		}
 
 		a := nodnil()
-		if n.Esc == EscNone {
+		if n.Esc() == EscNone {
 			// Create temporary buffer for slice on stack.
 			t := types.NewArray(types.Types[types.TUINT8], tmpstringbufsize)
 			a = ir.Nod(ir.OADDR, temp(t), nil)
 		}
 		// stringtoslicebyte(*32[byte], string) []byte
-		n = mkcall("stringtoslicebyte", n.Type, init, a, conv(s, types.Types[types.TSTRING]))
+		n = mkcall("stringtoslicebyte", n.Type(), init, a, conv(s, types.Types[types.TSTRING]))
 
 	case ir.OSTR2BYTESTMP:
 		// []byte(string) conversion that creates a slice
@@ -1537,38 +1537,38 @@ opswitch:
 		// that know that the slice won't be mutated.
 		// The only such case today is:
 		// for i, c := range []byte(string)
-		n.Left = walkexpr(n.Left, init)
+		n.SetLeft(walkexpr(n.Left(), init))
 
 	case ir.OSTR2RUNES:
 		a := nodnil()
-		if n.Esc == EscNone {
+		if n.Esc() == EscNone {
 			// Create temporary buffer for slice on stack.
 			t := types.NewArray(types.Types[types.TINT32], tmpstringbufsize)
 			a = ir.Nod(ir.OADDR, temp(t), nil)
 		}
 		// stringtoslicerune(*[32]rune, string) []rune
-		n = mkcall("stringtoslicerune", n.Type, init, a, conv(n.Left, types.Types[types.TSTRING]))
+		n = mkcall("stringtoslicerune", n.Type(), init, a, conv(n.Left(), types.Types[types.TSTRING]))
 
 	case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT, ir.OSTRUCTLIT, ir.OPTRLIT:
-		if isStaticCompositeLiteral(n) && !canSSAType(n.Type) {
+		if isStaticCompositeLiteral(n) && !canSSAType(n.Type()) {
 			// n can be directly represented in the read-only data section.
 			// Make direct reference to the static data. See issue 12841.
-			vstat := readonlystaticname(n.Type)
+			vstat := readonlystaticname(n.Type())
 			fixedlit(inInitFunction, initKindStatic, n, vstat, init)
 			n = vstat
 			n = typecheck(n, ctxExpr)
 			break
 		}
-		var_ := temp(n.Type)
+		var_ := temp(n.Type())
 		anylit(n, var_, init)
 		n = var_
 
 	case ir.OSEND:
-		n1 := n.Right
-		n1 = assignconv(n1, n.Left.Type.Elem(), "chan send")
+		n1 := n.Right()
+		n1 = assignconv(n1, n.Left().Type().Elem(), "chan send")
 		n1 = walkexpr(n1, init)
 		n1 = ir.Nod(ir.OADDR, n1, nil)
-		n = mkcall1(chanfn("chansend1", 2, n.Left.Type), nil, init, n.Left, n1)
+		n = mkcall1(chanfn("chansend1", 2, n.Left().Type()), nil, init, n.Left(), n1)
 
 	case ir.OCLOSURE:
 		n = walkclosure(n, init)
@@ -1582,17 +1582,17 @@ opswitch:
 	// constants until walk. For example, if n is y%1 == 0, the
 	// walk of y%1 may have replaced it by 0.
 	// Check whether n with its updated args is itself now a constant.
-	t := n.Type
+	t := n.Type()
 	n = evalConst(n)
-	if n.Type != t {
-		base.Fatalf("evconst changed Type: %v had type %v, now %v", n, t, n.Type)
+	if n.Type() != t {
+		base.Fatalf("evconst changed Type: %v had type %v, now %v", n, t, n.Type())
 	}
-	if n.Op == ir.OLITERAL {
+	if n.Op() == ir.OLITERAL {
 		n = typecheck(n, ctxExpr)
 		// Emit string symbol now to avoid emitting
 		// any concurrently during the backend.
 		if v := n.Val(); v.Kind() == constant.String {
-			_ = stringsym(n.Pos, constant.StringVal(v))
+			_ = stringsym(n.Pos(), constant.StringVal(v))
 		}
 	}
 
@@ -1620,13 +1620,13 @@ func markTypeUsedInInterface(t *types.Type, from *obj.LSym) {
 // markUsedIfaceMethod marks that an interface method is used in the current
 // function. n is OCALLINTER node.
 func markUsedIfaceMethod(n *ir.Node) {
-	ityp := n.Left.Left.Type
+	ityp := n.Left().Left().Type()
 	tsym := typenamesym(ityp).Linksym()
-	r := obj.Addrel(Curfn.Func.LSym)
+	r := obj.Addrel(Curfn.Func().LSym)
 	r.Sym = tsym
 	// n.Left.Xoffset is the method index * Widthptr (the offset of code pointer
 	// in itab).
-	midx := n.Left.Xoffset / int64(Widthptr)
+	midx := n.Left().Offset() / int64(Widthptr)
 	r.Add = ifaceMethodOffset(ityp, midx)
 	r.Type = objabi.R_USEIFACEMETHOD
 }
@@ -1680,17 +1680,17 @@ func rtconvfn(src, dst *types.Type) (param, result types.EType) {
 // TODO(josharian): combine this with its caller and simplify
 func reduceSlice(n *ir.Node) *ir.Node {
 	low, high, max := n.SliceBounds()
-	if high != nil && high.Op == ir.OLEN && samesafeexpr(n.Left, high.Left) {
+	if high != nil && high.Op() == ir.OLEN && samesafeexpr(n.Left(), high.Left()) {
 		// Reduce x[i:len(x)] to x[i:].
 		high = nil
 	}
 	n.SetSliceBounds(low, high, max)
-	if (n.Op == ir.OSLICE || n.Op == ir.OSLICESTR) && low == nil && high == nil {
+	if (n.Op() == ir.OSLICE || n.Op() == ir.OSLICESTR) && low == nil && high == nil {
 		// Reduce x[:] to x.
 		if base.Debug.Slice > 0 {
 			base.Warn("slice: omit slice operation")
 		}
-		return n.Left
+		return n.Left()
 	}
 	return n
 }
@@ -1700,7 +1700,7 @@ func ascompatee1(l *ir.Node, r *ir.Node, init *ir.Nodes) *ir.Node {
 	// making it impossible for reorder3 to work.
 	n := ir.Nod(ir.OAS, l, r)
 
-	if l.Op == ir.OINDEXMAP {
+	if l.Op() == ir.OINDEXMAP {
 		return n
 	}
 
@@ -1745,10 +1745,10 @@ func ascompatee(op ir.Op, nl, nr []*ir.Node, init *ir.Nodes) []*ir.Node {
 
 // fncall reports whether assigning an rvalue of type rt to an lvalue l might involve a function call.
 func fncall(l *ir.Node, rt *types.Type) bool {
-	if l.HasCall() || l.Op == ir.OINDEXMAP {
+	if l.HasCall() || l.Op() == ir.OINDEXMAP {
 		return true
 	}
-	if types.Identical(l.Type, rt) {
+	if types.Identical(l.Type(), rt) {
 		return false
 	}
 	// There might be a conversion required, which might involve a runtime call.
@@ -1782,8 +1782,8 @@ func ascompatet(nl ir.Nodes, nr *types.Type) []*ir.Node {
 		}
 
 		res := ir.Nod(ir.ORESULT, nil, nil)
-		res.Xoffset = base.Ctxt.FixedFrameSize() + r.Offset
-		res.Type = r.Type
+		res.SetOffset(base.Ctxt.FixedFrameSize() + r.Offset)
+		res.SetType(r.Type)
 		res.SetTypecheck(1)
 
 		a := ir.Nod(ir.OAS, l, res)
@@ -1804,15 +1804,15 @@ func mkdotargslice(typ *types.Type, args []*ir.Node) *ir.Node {
 	var n *ir.Node
 	if len(args) == 0 {
 		n = nodnil()
-		n.Type = typ
+		n.SetType(typ)
 	} else {
 		n = ir.Nod(ir.OCOMPLIT, nil, typenod(typ))
-		n.List.Append(args...)
+		n.PtrList().Append(args...)
 		n.SetImplicit(true)
 	}
 
 	n = typecheck(n, ctxExpr)
-	if n.Type == nil {
+	if n.Type() == nil {
 		base.Fatalf("mkdotargslice: typecheck failed")
 	}
 	return n
@@ -1821,7 +1821,7 @@ func mkdotargslice(typ *types.Type, args []*ir.Node) *ir.Node {
 // fixVariadicCall rewrites calls to variadic functions to use an
 // explicit ... argument if one is not already present.
 func fixVariadicCall(call *ir.Node) {
-	fntype := call.Left.Type
+	fntype := call.Left().Type()
 	if !fntype.IsVariadic() || call.IsDDD() {
 		return
 	}
@@ -1829,33 +1829,33 @@ func fixVariadicCall(call *ir.Node) {
 	vi := fntype.NumParams() - 1
 	vt := fntype.Params().Field(vi).Type
 
-	args := call.List.Slice()
+	args := call.List().Slice()
 	extra := args[vi:]
 	slice := mkdotargslice(vt, extra)
 	for i := range extra {
 		extra[i] = nil // allow GC
 	}
 
-	call.List.Set(append(args[:vi], slice))
+	call.PtrList().Set(append(args[:vi], slice))
 	call.SetIsDDD(true)
 }
 
 func walkCall(n *ir.Node, init *ir.Nodes) {
-	if n.Rlist.Len() != 0 {
+	if n.Rlist().Len() != 0 {
 		return // already walked
 	}
 
-	params := n.Left.Type.Params()
-	args := n.List.Slice()
+	params := n.Left().Type().Params()
+	args := n.List().Slice()
 
-	n.Left = walkexpr(n.Left, init)
+	n.SetLeft(walkexpr(n.Left(), init))
 	walkexprlist(args, init)
 
 	// If this is a method call, add the receiver at the beginning of the args.
-	if n.Op == ir.OCALLMETH {
+	if n.Op() == ir.OCALLMETH {
 		withRecv := make([]*ir.Node, len(args)+1)
-		withRecv[0] = n.Left.Left
-		n.Left.Left = nil
+		withRecv[0] = n.Left().Left()
+		n.Left().SetLeft(nil)
 		copy(withRecv[1:], args)
 		args = withRecv
 	}
@@ -1869,9 +1869,9 @@ func walkCall(n *ir.Node, init *ir.Nodes) {
 		updateHasCall(arg)
 		// Determine param type.
 		var t *types.Type
-		if n.Op == ir.OCALLMETH {
+		if n.Op() == ir.OCALLMETH {
 			if i == 0 {
-				t = n.Left.Type.Recv().Type
+				t = n.Left().Type().Recv().Type
 			} else {
 				t = params.Field(i - 1).Type
 			}
@@ -1889,18 +1889,18 @@ func walkCall(n *ir.Node, init *ir.Nodes) {
 		}
 	}
 
-	n.List.Set(tempAssigns)
-	n.Rlist.Set(args)
+	n.PtrList().Set(tempAssigns)
+	n.PtrRlist().Set(args)
 }
 
 // generate code for print
 func walkprint(nn *ir.Node, init *ir.Nodes) *ir.Node {
 	// Hoist all the argument evaluation up before the lock.
-	walkexprlistcheap(nn.List.Slice(), init)
+	walkexprlistcheap(nn.List().Slice(), init)
 
 	// For println, add " " between elements and "\n" at the end.
-	if nn.Op == ir.OPRINTN {
-		s := nn.List.Slice()
+	if nn.Op() == ir.OPRINTN {
+		s := nn.List().Slice()
 		t := make([]*ir.Node, 0, len(s)*2)
 		for i, n := range s {
 			if i != 0 {
@@ -1909,11 +1909,11 @@ func walkprint(nn *ir.Node, init *ir.Nodes) *ir.Node {
 			t = append(t, n)
 		}
 		t = append(t, nodstr("\n"))
-		nn.List.Set(t)
+		nn.PtrList().Set(t)
 	}
 
 	// Collapse runs of constant strings.
-	s := nn.List.Slice()
+	s := nn.List().Slice()
 	t := make([]*ir.Node, 0, len(s))
 	for i := 0; i < len(s); {
 		var strs []string
@@ -1929,12 +1929,12 @@ func walkprint(nn *ir.Node, init *ir.Nodes) *ir.Node {
 			i++
 		}
 	}
-	nn.List.Set(t)
+	nn.PtrList().Set(t)
 
 	calls := []*ir.Node{mkcall("printlock", nil, init)}
-	for i, n := range nn.List.Slice() {
-		if n.Op == ir.OLITERAL {
-			if n.Type == types.UntypedRune {
+	for i, n := range nn.List().Slice() {
+		if n.Op() == ir.OLITERAL {
+			if n.Type() == types.UntypedRune {
 				n = defaultlit(n, types.Runetype)
 			}
 
@@ -1947,42 +1947,42 @@ func walkprint(nn *ir.Node, init *ir.Nodes) *ir.Node {
 			}
 		}
 
-		if n.Op != ir.OLITERAL && n.Type != nil && n.Type.Etype == types.TIDEAL {
+		if n.Op() != ir.OLITERAL && n.Type() != nil && n.Type().Etype == types.TIDEAL {
 			n = defaultlit(n, types.Types[types.TINT64])
 		}
 		n = defaultlit(n, nil)
-		nn.List.SetIndex(i, n)
-		if n.Type == nil || n.Type.Etype == types.TFORW {
+		nn.List().SetIndex(i, n)
+		if n.Type() == nil || n.Type().Etype == types.TFORW {
 			continue
 		}
 
 		var on *ir.Node
-		switch n.Type.Etype {
+		switch n.Type().Etype {
 		case types.TINTER:
-			if n.Type.IsEmptyInterface() {
+			if n.Type().IsEmptyInterface() {
 				on = syslook("printeface")
 			} else {
 				on = syslook("printiface")
 			}
-			on = substArgTypes(on, n.Type) // any-1
+			on = substArgTypes(on, n.Type()) // any-1
 		case types.TPTR:
-			if n.Type.Elem().NotInHeap() {
+			if n.Type().Elem().NotInHeap() {
 				on = syslook("printuintptr")
 				n = ir.Nod(ir.OCONV, n, nil)
-				n.Type = types.Types[types.TUNSAFEPTR]
+				n.SetType(types.Types[types.TUNSAFEPTR])
 				n = ir.Nod(ir.OCONV, n, nil)
-				n.Type = types.Types[types.TUINTPTR]
+				n.SetType(types.Types[types.TUINTPTR])
 				break
 			}
 			fallthrough
 		case types.TCHAN, types.TMAP, types.TFUNC, types.TUNSAFEPTR:
 			on = syslook("printpointer")
-			on = substArgTypes(on, n.Type) // any-1
+			on = substArgTypes(on, n.Type()) // any-1
 		case types.TSLICE:
 			on = syslook("printslice")
-			on = substArgTypes(on, n.Type) // any-1
+			on = substArgTypes(on, n.Type()) // any-1
 		case types.TUINT, types.TUINT8, types.TUINT16, types.TUINT32, types.TUINT64, types.TUINTPTR:
-			if isRuntimePkg(n.Type.Sym.Pkg) && n.Type.Sym.Name == "hex" {
+			if isRuntimePkg(n.Type().Sym.Pkg) && n.Type().Sym.Name == "hex" {
 				on = syslook("printhex")
 			} else {
 				on = syslook("printuint")
@@ -2009,18 +2009,18 @@ func walkprint(nn *ir.Node, init *ir.Nodes) *ir.Node {
 				on = syslook("printstring")
 			}
 		default:
-			badtype(ir.OPRINT, n.Type, nil)
+			badtype(ir.OPRINT, n.Type(), nil)
 			continue
 		}
 
 		r := ir.Nod(ir.OCALL, on, nil)
-		if params := on.Type.Params().FieldSlice(); len(params) > 0 {
+		if params := on.Type().Params().FieldSlice(); len(params) > 0 {
 			t := params[0].Type
-			if !types.Identical(t, n.Type) {
+			if !types.Identical(t, n.Type()) {
 				n = ir.Nod(ir.OCONV, n, nil)
-				n.Type = t
+				n.SetType(t)
 			}
-			r.List.Append(n)
+			r.PtrList().Append(n)
 		}
 		calls = append(calls, r)
 	}
@@ -2033,14 +2033,14 @@ func walkprint(nn *ir.Node, init *ir.Nodes) *ir.Node {
 	r := ir.Nod(ir.OEMPTY, nil, nil)
 	r = typecheck(r, ctxStmt)
 	r = walkexpr(r, init)
-	r.Ninit.Set(calls)
+	r.PtrInit().Set(calls)
 	return r
 }
 
 func callnew(t *types.Type) *ir.Node {
 	dowidth(t)
 	n := ir.Nod(ir.ONEWOBJ, typename(t), nil)
-	n.Type = types.NewPtr(t)
+	n.SetType(types.NewPtr(t))
 	n.SetTypecheck(1)
 	n.MarkNonNil()
 	return n
@@ -2049,54 +2049,54 @@ func callnew(t *types.Type) *ir.Node {
 // isReflectHeaderDataField reports whether l is an expression p.Data
 // where p has type reflect.SliceHeader or reflect.StringHeader.
 func isReflectHeaderDataField(l *ir.Node) bool {
-	if l.Type != types.Types[types.TUINTPTR] {
+	if l.Type() != types.Types[types.TUINTPTR] {
 		return false
 	}
 
 	var tsym *types.Sym
-	switch l.Op {
+	switch l.Op() {
 	case ir.ODOT:
-		tsym = l.Left.Type.Sym
+		tsym = l.Left().Type().Sym
 	case ir.ODOTPTR:
-		tsym = l.Left.Type.Elem().Sym
+		tsym = l.Left().Type().Elem().Sym
 	default:
 		return false
 	}
 
-	if tsym == nil || l.Sym.Name != "Data" || tsym.Pkg.Path != "reflect" {
+	if tsym == nil || l.Sym().Name != "Data" || tsym.Pkg.Path != "reflect" {
 		return false
 	}
 	return tsym.Name == "SliceHeader" || tsym.Name == "StringHeader"
 }
 
 func convas(n *ir.Node, init *ir.Nodes) *ir.Node {
-	if n.Op != ir.OAS {
-		base.Fatalf("convas: not OAS %v", n.Op)
+	if n.Op() != ir.OAS {
+		base.Fatalf("convas: not OAS %v", n.Op())
 	}
 	defer updateHasCall(n)
 
 	n.SetTypecheck(1)
 
-	if n.Left == nil || n.Right == nil {
+	if n.Left() == nil || n.Right() == nil {
 		return n
 	}
 
-	lt := n.Left.Type
-	rt := n.Right.Type
+	lt := n.Left().Type()
+	rt := n.Right().Type()
 	if lt == nil || rt == nil {
 		return n
 	}
 
-	if ir.IsBlank(n.Left) {
-		n.Right = defaultlit(n.Right, nil)
+	if ir.IsBlank(n.Left()) {
+		n.SetRight(defaultlit(n.Right(), nil))
 		return n
 	}
 
 	if !types.Identical(lt, rt) {
-		n.Right = assignconv(n.Right, lt, "assignment")
-		n.Right = walkexpr(n.Right, init)
+		n.SetRight(assignconv(n.Right(), lt, "assignment"))
+		n.SetRight(walkexpr(n.Right(), init))
 	}
-	dowidth(n.Right.Type)
+	dowidth(n.Right().Type())
 
 	return n
 }
@@ -2115,45 +2115,45 @@ func reorder3(all []*ir.Node) []*ir.Node {
 
 	var mapinit ir.Nodes
 	for i, n := range all {
-		l := n.Left
+		l := n.Left()
 
 		// Save subexpressions needed on left side.
 		// Drill through non-dereferences.
 		for {
-			if l.Op == ir.ODOT || l.Op == ir.OPAREN {
-				l = l.Left
+			if l.Op() == ir.ODOT || l.Op() == ir.OPAREN {
+				l = l.Left()
 				continue
 			}
 
-			if l.Op == ir.OINDEX && l.Left.Type.IsArray() {
-				l.Right = reorder3save(l.Right, all, i, &early)
-				l = l.Left
+			if l.Op() == ir.OINDEX && l.Left().Type().IsArray() {
+				l.SetRight(reorder3save(l.Right(), all, i, &early))
+				l = l.Left()
 				continue
 			}
 
 			break
 		}
 
-		switch l.Op {
+		switch l.Op() {
 		default:
-			base.Fatalf("reorder3 unexpected lvalue %#v", l.Op)
+			base.Fatalf("reorder3 unexpected lvalue %#v", l.Op())
 
 		case ir.ONAME:
 			break
 
 		case ir.OINDEX, ir.OINDEXMAP:
-			l.Left = reorder3save(l.Left, all, i, &early)
-			l.Right = reorder3save(l.Right, all, i, &early)
-			if l.Op == ir.OINDEXMAP {
+			l.SetLeft(reorder3save(l.Left(), all, i, &early))
+			l.SetRight(reorder3save(l.Right(), all, i, &early))
+			if l.Op() == ir.OINDEXMAP {
 				all[i] = convas(all[i], &mapinit)
 			}
 
 		case ir.ODEREF, ir.ODOTPTR:
-			l.Left = reorder3save(l.Left, all, i, &early)
+			l.SetLeft(reorder3save(l.Left(), all, i, &early))
 		}
 
 		// Save expression on right side.
-		all[i].Right = reorder3save(all[i].Right, all, i, &early)
+		all[i].SetRight(reorder3save(all[i].Right(), all, i, &early))
 	}
 
 	early = append(mapinit.Slice(), early...)
@@ -2171,26 +2171,26 @@ func reorder3save(n *ir.Node, all []*ir.Node, i int, early *[]*ir.Node) *ir.Node
 		return n
 	}
 
-	q := temp(n.Type)
+	q := temp(n.Type())
 	q = ir.Nod(ir.OAS, q, n)
 	q = typecheck(q, ctxStmt)
 	*early = append(*early, q)
-	return q.Left
+	return q.Left()
 }
 
 // what's the outer value that a write to n affects?
 // outer value means containing struct or array.
 func outervalue(n *ir.Node) *ir.Node {
 	for {
-		switch n.Op {
+		switch n.Op() {
 		case ir.OXDOT:
 			base.Fatalf("OXDOT in walk")
 		case ir.ODOT, ir.OPAREN, ir.OCONVNOP:
-			n = n.Left
+			n = n.Left()
 			continue
 		case ir.OINDEX:
-			if n.Left.Type != nil && n.Left.Type.IsArray() {
-				n = n.Left
+			if n.Left().Type() != nil && n.Left().Type().IsArray() {
+				n = n.Left()
 				continue
 			}
 		}
@@ -2208,8 +2208,8 @@ func aliased(r *ir.Node, all []*ir.Node) bool {
 
 	// Treat all fields of a struct as referring to the whole struct.
 	// We could do better but we would have to keep track of the fields.
-	for r.Op == ir.ODOT {
-		r = r.Left
+	for r.Op() == ir.ODOT {
+		r = r.Left()
 	}
 
 	// Look for obvious aliasing: a variable being assigned
@@ -2220,12 +2220,12 @@ func aliased(r *ir.Node, all []*ir.Node) bool {
 	memwrite := false
 	for _, as := range all {
 		// We can ignore assignments to blank.
-		if ir.IsBlank(as.Left) {
+		if ir.IsBlank(as.Left()) {
 			continue
 		}
 
-		l := outervalue(as.Left)
-		if l.Op != ir.ONAME {
+		l := outervalue(as.Left())
+		if l.Op() != ir.ONAME {
 			memwrite = true
 			continue
 		}
@@ -2239,7 +2239,7 @@ func aliased(r *ir.Node, all []*ir.Node) bool {
 			continue
 
 		case ir.PAUTO, ir.PPARAM, ir.PPARAMOUT:
-			if l.Name.Addrtaken() {
+			if l.Name().Addrtaken() {
 				memwrite = true
 				continue
 			}
@@ -2280,14 +2280,14 @@ func varexpr(n *ir.Node) bool {
 		return true
 	}
 
-	switch n.Op {
+	switch n.Op() {
 	case ir.OLITERAL, ir.ONIL:
 		return true
 
 	case ir.ONAME:
 		switch n.Class() {
 		case ir.PAUTO, ir.PPARAM, ir.PPARAMOUT:
-			if !n.Name.Addrtaken() {
+			if !n.Name().Addrtaken() {
 				return true
 			}
 		}
@@ -2315,7 +2315,7 @@ func varexpr(n *ir.Node) bool {
 		ir.OCONVNOP,
 		ir.OCONVIFACE,
 		ir.ODOTTYPE:
-		return varexpr(n.Left) && varexpr(n.Right)
+		return varexpr(n.Left()) && varexpr(n.Right())
 
 	case ir.ODOT: // but not ODOTPTR
 		// Should have been handled in aliased.
@@ -2331,7 +2331,7 @@ func vmatch2(l *ir.Node, r *ir.Node) bool {
 	if r == nil {
 		return false
 	}
-	switch r.Op {
+	switch r.Op() {
 	// match each right given left
 	case ir.ONAME:
 		return l == r
@@ -2340,13 +2340,13 @@ func vmatch2(l *ir.Node, r *ir.Node) bool {
 		return false
 	}
 
-	if vmatch2(l, r.Left) {
+	if vmatch2(l, r.Left()) {
 		return true
 	}
-	if vmatch2(l, r.Right) {
+	if vmatch2(l, r.Right()) {
 		return true
 	}
-	for _, n := range r.List.Slice() {
+	for _, n := range r.List().Slice() {
 		if vmatch2(l, n) {
 			return true
 		}
@@ -2361,7 +2361,7 @@ func vmatch1(l *ir.Node, r *ir.Node) bool {
 	if l == nil || r == nil {
 		return false
 	}
-	switch l.Op {
+	switch l.Op() {
 	case ir.ONAME:
 		switch l.Class() {
 		case ir.PPARAM, ir.PAUTO:
@@ -2381,13 +2381,13 @@ func vmatch1(l *ir.Node, r *ir.Node) bool {
 		return false
 	}
 
-	if vmatch1(l.Left, r) {
+	if vmatch1(l.Left(), r) {
 		return true
 	}
-	if vmatch1(l.Right, r) {
+	if vmatch1(l.Right(), r) {
 		return true
 	}
-	for _, n := range l.List.Slice() {
+	for _, n := range l.List().Slice() {
 		if vmatch1(n, r) {
 			return true
 		}
@@ -2401,14 +2401,14 @@ func paramstoheap(params *types.Type) []*ir.Node {
 	var nn []*ir.Node
 	for _, t := range params.Fields().Slice() {
 		v := ir.AsNode(t.Nname)
-		if v != nil && v.Sym != nil && strings.HasPrefix(v.Sym.Name, "~r") { // unnamed result
+		if v != nil && v.Sym() != nil && strings.HasPrefix(v.Sym().Name, "~r") { // unnamed result
 			v = nil
 		}
 		if v == nil {
 			continue
 		}
 
-		if stackcopy := v.Name.Param.Stackcopy; stackcopy != nil {
+		if stackcopy := v.Name().Param.Stackcopy; stackcopy != nil {
 			nn = append(nn, walkstmt(ir.Nod(ir.ODCL, v, nil)))
 			if stackcopy.Class() == ir.PPARAM {
 				nn = append(nn, walkstmt(typecheck(ir.Nod(ir.OAS, v, stackcopy), ctxStmt)))
@@ -2427,9 +2427,9 @@ func paramstoheap(params *types.Type) []*ir.Node {
 // even allocations to move params/results to the heap.
 // The generated code is added to Curfn's Enter list.
 func zeroResults() {
-	for _, f := range Curfn.Type.Results().Fields().Slice() {
+	for _, f := range Curfn.Type().Results().Fields().Slice() {
 		v := ir.AsNode(f.Nname)
-		if v != nil && v.Name.Param.Heapaddr != nil {
+		if v != nil && v.Name().Param.Heapaddr != nil {
 			// The local which points to the return value is the
 			// thing that needs zeroing. This is already handled
 			// by a Needzero annotation in plive.go:livenessepilogue.
@@ -2442,10 +2442,10 @@ func zeroResults() {
 			// I don't think the zeroing below matters.
 			// The stack return value will never be marked as live anywhere in the function.
 			// It is not written to until deferreturn returns.
-			v = v.Name.Param.Stackcopy
+			v = v.Name().Param.Stackcopy
 		}
 		// Zero the stack location containing f.
-		Curfn.Func.Enter.Append(ir.NodAt(Curfn.Pos, ir.OAS, v, nil))
+		Curfn.Func().Enter.Append(ir.NodAt(Curfn.Pos(), ir.OAS, v, nil))
 	}
 }
 
@@ -2458,7 +2458,7 @@ func returnsfromheap(params *types.Type) []*ir.Node {
 		if v == nil {
 			continue
 		}
-		if stackcopy := v.Name.Param.Stackcopy; stackcopy != nil && stackcopy.Class() == ir.PPARAMOUT {
+		if stackcopy := v.Name().Param.Stackcopy; stackcopy != nil && stackcopy.Class() == ir.PPARAMOUT {
 			nn = append(nn, walkstmt(typecheck(ir.Nod(ir.OAS, stackcopy, v), ctxStmt)))
 		}
 	}
@@ -2471,35 +2471,35 @@ func returnsfromheap(params *types.Type) []*ir.Node {
 // Enter and Exit lists.
 func heapmoves() {
 	lno := base.Pos
-	base.Pos = Curfn.Pos
-	nn := paramstoheap(Curfn.Type.Recvs())
-	nn = append(nn, paramstoheap(Curfn.Type.Params())...)
-	nn = append(nn, paramstoheap(Curfn.Type.Results())...)
-	Curfn.Func.Enter.Append(nn...)
-	base.Pos = Curfn.Func.Endlineno
-	Curfn.Func.Exit.Append(returnsfromheap(Curfn.Type.Results())...)
+	base.Pos = Curfn.Pos()
+	nn := paramstoheap(Curfn.Type().Recvs())
+	nn = append(nn, paramstoheap(Curfn.Type().Params())...)
+	nn = append(nn, paramstoheap(Curfn.Type().Results())...)
+	Curfn.Func().Enter.Append(nn...)
+	base.Pos = Curfn.Func().Endlineno
+	Curfn.Func().Exit.Append(returnsfromheap(Curfn.Type().Results())...)
 	base.Pos = lno
 }
 
 func vmkcall(fn *ir.Node, t *types.Type, init *ir.Nodes, va []*ir.Node) *ir.Node {
-	if fn.Type == nil || fn.Type.Etype != types.TFUNC {
-		base.Fatalf("mkcall %v %v", fn, fn.Type)
+	if fn.Type() == nil || fn.Type().Etype != types.TFUNC {
+		base.Fatalf("mkcall %v %v", fn, fn.Type())
 	}
 
-	n := fn.Type.NumParams()
+	n := fn.Type().NumParams()
 	if n != len(va) {
 		base.Fatalf("vmkcall %v needs %v args got %v", fn, n, len(va))
 	}
 
 	r := ir.Nod(ir.OCALL, fn, nil)
-	r.List.Set(va)
-	if fn.Type.NumResults() > 0 {
+	r.PtrList().Set(va)
+	if fn.Type().NumResults() > 0 {
 		r = typecheck(r, ctxExpr|ctxMultiOK)
 	} else {
 		r = typecheck(r, ctxStmt)
 	}
 	r = walkexpr(r, init)
-	r.Type = t
+	r.SetType(t)
 	return r
 }
 
@@ -2512,11 +2512,11 @@ func mkcall1(fn *ir.Node, t *types.Type, init *ir.Nodes, args ...*ir.Node) *ir.N
 }
 
 func conv(n *ir.Node, t *types.Type) *ir.Node {
-	if types.Identical(n.Type, t) {
+	if types.Identical(n.Type(), t) {
 		return n
 	}
 	n = ir.Nod(ir.OCONV, n, nil)
-	n.Type = t
+	n.SetType(t)
 	n = typecheck(n, ctxExpr)
 	return n
 }
@@ -2524,11 +2524,11 @@ func conv(n *ir.Node, t *types.Type) *ir.Node {
 // convnop converts node n to type t using the OCONVNOP op
 // and typechecks the result with ctxExpr.
 func convnop(n *ir.Node, t *types.Type) *ir.Node {
-	if types.Identical(n.Type, t) {
+	if types.Identical(n.Type(), t) {
 		return n
 	}
 	n = ir.Nod(ir.OCONVNOP, n, nil)
-	n.Type = t
+	n.SetType(t)
 	n = typecheck(n, ctxExpr)
 	return n
 }
@@ -2541,13 +2541,13 @@ func byteindex(n *ir.Node) *ir.Node {
 	// While converting from int8 to int is possible, it would yield
 	// the wrong result for negative values.
 	// Reinterpreting the value as an unsigned byte solves both cases.
-	if !types.Identical(n.Type, types.Types[types.TUINT8]) {
+	if !types.Identical(n.Type(), types.Types[types.TUINT8]) {
 		n = ir.Nod(ir.OCONV, n, nil)
-		n.Type = types.Types[types.TUINT8]
+		n.SetType(types.Types[types.TUINT8])
 		n.SetTypecheck(1)
 	}
 	n = ir.Nod(ir.OCONV, n, nil)
-	n.Type = types.Types[types.TINT]
+	n.SetType(types.Types[types.TINT])
 	n.SetTypecheck(1)
 	return n
 }
@@ -2644,17 +2644,17 @@ func writebarrierfn(name string, l *types.Type, r *types.Type) *ir.Node {
 
 func addstr(n *ir.Node, init *ir.Nodes) *ir.Node {
 	// order.expr rewrote OADDSTR to have a list of strings.
-	c := n.List.Len()
+	c := n.List().Len()
 
 	if c < 2 {
 		base.Fatalf("addstr count %d too small", c)
 	}
 
 	buf := nodnil()
-	if n.Esc == EscNone {
+	if n.Esc() == EscNone {
 		sz := int64(0)
-		for _, n1 := range n.List.Slice() {
-			if n1.Op == ir.OLITERAL {
+		for _, n1 := range n.List().Slice() {
+			if n1.Op() == ir.OLITERAL {
 				sz += int64(len(n1.StringVal()))
 			}
 		}
@@ -2669,7 +2669,7 @@ func addstr(n *ir.Node, init *ir.Nodes) *ir.Node {
 
 	// build list of string arguments
 	args := []*ir.Node{buf}
-	for _, n2 := range n.List.Slice() {
+	for _, n2 := range n.List().Slice() {
 		args = append(args, conv(n2, types.Types[types.TSTRING]))
 	}
 
@@ -2687,28 +2687,28 @@ func addstr(n *ir.Node, init *ir.Nodes) *ir.Node {
 		if prealloc[n] != nil {
 			prealloc[slice] = prealloc[n]
 		}
-		slice.List.Set(args[1:]) // skip buf arg
+		slice.PtrList().Set(args[1:]) // skip buf arg
 		args = []*ir.Node{buf, slice}
-		slice.Esc = EscNone
+		slice.SetEsc(EscNone)
 	}
 
 	cat := syslook(fn)
 	r := ir.Nod(ir.OCALL, cat, nil)
-	r.List.Set(args)
+	r.PtrList().Set(args)
 	r = typecheck(r, ctxExpr)
 	r = walkexpr(r, init)
-	r.Type = n.Type
+	r.SetType(n.Type())
 
 	return r
 }
 
 func walkAppendArgs(n *ir.Node, init *ir.Nodes) {
-	walkexprlistsafe(n.List.Slice(), init)
+	walkexprlistsafe(n.List().Slice(), init)
 
 	// walkexprlistsafe will leave OINDEX (s[n]) alone if both s
 	// and n are name or literal, but those may index the slice we're
 	// modifying here. Fix explicitly.
-	ls := n.List.Slice()
+	ls := n.List().Slice()
 	for i1, n1 := range ls {
 		ls[i1] = cheapexpr(n1, init)
 	}
@@ -2731,18 +2731,18 @@ func walkAppendArgs(n *ir.Node, init *ir.Nodes) {
 func appendslice(n *ir.Node, init *ir.Nodes) *ir.Node {
 	walkAppendArgs(n, init)
 
-	l1 := n.List.First()
-	l2 := n.List.Second()
+	l1 := n.List().First()
+	l2 := n.List().Second()
 	l2 = cheapexpr(l2, init)
-	n.List.SetSecond(l2)
+	n.List().SetSecond(l2)
 
 	var nodes ir.Nodes
 
 	// var s []T
-	s := temp(l1.Type)
+	s := temp(l1.Type())
 	nodes.Append(ir.Nod(ir.OAS, s, l1)) // s = l1
 
-	elemtype := s.Type.Elem()
+	elemtype := s.Type().Elem()
 
 	// n := len(s) + len(l2)
 	nn := temp(types.Types[types.TINT])
@@ -2752,14 +2752,14 @@ func appendslice(n *ir.Node, init *ir.Nodes) *ir.Node {
 	nif := ir.Nod(ir.OIF, nil, nil)
 	nuint := conv(nn, types.Types[types.TUINT])
 	scapuint := conv(ir.Nod(ir.OCAP, s, nil), types.Types[types.TUINT])
-	nif.Left = ir.Nod(ir.OGT, nuint, scapuint)
+	nif.SetLeft(ir.Nod(ir.OGT, nuint, scapuint))
 
 	// instantiate growslice(typ *type, []any, int) []any
 	fn := syslook("growslice")
 	fn = substArgTypes(fn, elemtype, elemtype)
 
 	// s = growslice(T, s, n)
-	nif.Nbody.Set1(ir.Nod(ir.OAS, s, mkcall1(fn, s.Type, &nif.Ninit, typename(elemtype), s, nn)))
+	nif.PtrBody().Set1(ir.Nod(ir.OAS, s, mkcall1(fn, s.Type(), nif.PtrInit(), typename(elemtype), s, nn)))
 	nodes.Append(nif)
 
 	// s = s[:n]
@@ -2772,17 +2772,17 @@ func appendslice(n *ir.Node, init *ir.Nodes) *ir.Node {
 	if elemtype.HasPointers() {
 		// copy(s[len(l1):], l2)
 		nptr1 := ir.Nod(ir.OSLICE, s, nil)
-		nptr1.Type = s.Type
+		nptr1.SetType(s.Type())
 		nptr1.SetSliceBounds(ir.Nod(ir.OLEN, l1, nil), nil, nil)
 		nptr1 = cheapexpr(nptr1, &nodes)
 
 		nptr2 := l2
 
-		Curfn.Func.SetWBPos(n.Pos)
+		Curfn.Func().SetWBPos(n.Pos())
 
 		// instantiate typedslicecopy(typ *type, dstPtr *any, dstLen int, srcPtr *any, srcLen int) int
 		fn := syslook("typedslicecopy")
-		fn = substArgTypes(fn, l1.Type.Elem(), l2.Type.Elem())
+		fn = substArgTypes(fn, l1.Type().Elem(), l2.Type().Elem())
 		ptr1, len1 := backingArrayPtrLen(nptr1)
 		ptr2, len2 := backingArrayPtrLen(nptr2)
 		ncopy = mkcall1(fn, types.Types[types.TINT], &nodes, typename(elemtype), ptr1, len1, ptr2, len2)
@@ -2791,7 +2791,7 @@ func appendslice(n *ir.Node, init *ir.Nodes) *ir.Node {
 		//  copy(s[len(l1):], l2)
 		// l2 can be a slice or string.
 		nptr1 := ir.Nod(ir.OSLICE, s, nil)
-		nptr1.Type = s.Type
+		nptr1.SetType(s.Type())
 		nptr1.SetSliceBounds(ir.Nod(ir.OLEN, l1, nil), nil, nil)
 		nptr1 = cheapexpr(nptr1, &nodes)
 		nptr2 := l2
@@ -2800,7 +2800,7 @@ func appendslice(n *ir.Node, init *ir.Nodes) *ir.Node {
 		ptr2, len2 := backingArrayPtrLen(nptr2)
 
 		fn := syslook("slicecopy")
-		fn = substArgTypes(fn, ptr1.Type.Elem(), ptr2.Type.Elem())
+		fn = substArgTypes(fn, ptr1.Type().Elem(), ptr2.Type().Elem())
 		ncopy = mkcall1(fn, types.Types[types.TINT], &nodes, ptr1, len1, ptr2, len2, nodintconst(elemtype.Width))
 	} else {
 		// memmove(&s[len(l1)], &l2[0], len(l2)*sizeof(T))
@@ -2837,12 +2837,12 @@ func isAppendOfMake(n *ir.Node) bool {
 		base.Fatalf("missing typecheck: %+v", n)
 	}
 
-	if n.Op != ir.OAPPEND || !n.IsDDD() || n.List.Len() != 2 {
+	if n.Op() != ir.OAPPEND || !n.IsDDD() || n.List().Len() != 2 {
 		return false
 	}
 
-	second := n.List.Second()
-	if second.Op != ir.OMAKESLICE || second.Right != nil {
+	second := n.List().Second()
+	if second.Op() != ir.OMAKESLICE || second.Right() != nil {
 		return false
 	}
 
@@ -2852,8 +2852,8 @@ func isAppendOfMake(n *ir.Node) bool {
 	// typecheck made sure that constant arguments to make are not negative and fit into an int.
 
 	// The care of overflow of the len argument to make will be handled by an explicit check of int(len) < 0 during runtime.
-	y := second.Left
-	if !ir.IsConst(y, constant.Int) && y.Type.Size() > types.Types[types.TUINT].Size() {
+	y := second.Left()
+	if !ir.IsConst(y, constant.Int) && y.Type().Size() > types.Types[types.TUINT].Size() {
 		return false
 	}
 
@@ -2891,14 +2891,14 @@ func extendslice(n *ir.Node, init *ir.Nodes) *ir.Node {
 	// isAppendOfMake made sure all possible positive values of l2 fit into an uint.
 	// The case of l2 overflow when converting from e.g. uint to int is handled by an explicit
 	// check of l2 < 0 at runtime which is generated below.
-	l2 := conv(n.List.Second().Left, types.Types[types.TINT])
+	l2 := conv(n.List().Second().Left(), types.Types[types.TINT])
 	l2 = typecheck(l2, ctxExpr)
-	n.List.SetSecond(l2) // walkAppendArgs expects l2 in n.List.Second().
+	n.List().SetSecond(l2) // walkAppendArgs expects l2 in n.List.Second().
 
 	walkAppendArgs(n, init)
 
-	l1 := n.List.First()
-	l2 = n.List.Second() // re-read l2, as it may have been updated by walkAppendArgs
+	l1 := n.List().First()
+	l2 = n.List().Second() // re-read l2, as it may have been updated by walkAppendArgs
 
 	var nodes []*ir.Node
 
@@ -2907,14 +2907,14 @@ func extendslice(n *ir.Node, init *ir.Nodes) *ir.Node {
 	nifneg.SetLikely(true)
 
 	// else panicmakeslicelen()
-	nifneg.Rlist.Set1(mkcall("panicmakeslicelen", nil, init))
+	nifneg.PtrRlist().Set1(mkcall("panicmakeslicelen", nil, init))
 	nodes = append(nodes, nifneg)
 
 	// s := l1
-	s := temp(l1.Type)
+	s := temp(l1.Type())
 	nodes = append(nodes, ir.Nod(ir.OAS, s, l1))
 
-	elemtype := s.Type.Elem()
+	elemtype := s.Type().Elem()
 
 	// n := len(s) + l2
 	nn := temp(types.Types[types.TINT])
@@ -2930,7 +2930,7 @@ func extendslice(n *ir.Node, init *ir.Nodes) *ir.Node {
 	fn = substArgTypes(fn, elemtype, elemtype)
 
 	// s = growslice(T, s, n)
-	nif.Nbody.Set1(ir.Nod(ir.OAS, s, mkcall1(fn, s.Type, &nif.Ninit, typename(elemtype), s, nn)))
+	nif.PtrBody().Set1(ir.Nod(ir.OAS, s, mkcall1(fn, s.Type(), nif.PtrInit(), typename(elemtype), s, nn)))
 	nodes = append(nodes, nif)
 
 	// s = s[:n]
@@ -2940,7 +2940,7 @@ func extendslice(n *ir.Node, init *ir.Nodes) *ir.Node {
 	nodes = append(nodes, ir.Nod(ir.OAS, s, nt))
 
 	// lptr := &l1[0]
-	l1ptr := temp(l1.Type.Elem().PtrTo())
+	l1ptr := temp(l1.Type().Elem().PtrTo())
 	tmp := ir.Nod(ir.OSPTR, l1, nil)
 	nodes = append(nodes, ir.Nod(ir.OAS, l1ptr, tmp))
 
@@ -2963,7 +2963,7 @@ func extendslice(n *ir.Node, init *ir.Nodes) *ir.Node {
 	hasPointers := elemtype.HasPointers()
 	if hasPointers {
 		clrname = "memclrHasPointers"
-		Curfn.Func.SetWBPos(n.Pos)
+		Curfn.Func().SetWBPos(n.Pos())
 	}
 
 	var clr ir.Nodes
@@ -2973,7 +2973,7 @@ func extendslice(n *ir.Node, init *ir.Nodes) *ir.Node {
 	if hasPointers {
 		// if l1ptr == sptr
 		nifclr := ir.Nod(ir.OIF, ir.Nod(ir.OEQ, l1ptr, sptr), nil)
-		nifclr.Nbody = clr
+		nifclr.SetBody(clr)
 		nodes = append(nodes, nifclr)
 	} else {
 		nodes = append(nodes, clr.Slice()...)
@@ -3007,13 +3007,13 @@ func extendslice(n *ir.Node, init *ir.Nodes) *ir.Node {
 //   }
 //   s
 func walkappend(n *ir.Node, init *ir.Nodes, dst *ir.Node) *ir.Node {
-	if !samesafeexpr(dst, n.List.First()) {
-		n.List.SetFirst(safeexpr(n.List.First(), init))
-		n.List.SetFirst(walkexpr(n.List.First(), init))
+	if !samesafeexpr(dst, n.List().First()) {
+		n.List().SetFirst(safeexpr(n.List().First(), init))
+		n.List().SetFirst(walkexpr(n.List().First(), init))
 	}
-	walkexprlistsafe(n.List.Slice()[1:], init)
+	walkexprlistsafe(n.List().Slice()[1:], init)
 
-	nsrc := n.List.First()
+	nsrc := n.List().First()
 
 	// walkexprlistsafe will leave OINDEX (s[n]) alone if both s
 	// and n are name or literal, but those may index the slice we're
@@ -3021,17 +3021,17 @@ func walkappend(n *ir.Node, init *ir.Nodes, dst *ir.Node) *ir.Node {
 	// Using cheapexpr also makes sure that the evaluation
 	// of all arguments (and especially any panics) happen
 	// before we begin to modify the slice in a visible way.
-	ls := n.List.Slice()[1:]
+	ls := n.List().Slice()[1:]
 	for i, n := range ls {
 		n = cheapexpr(n, init)
-		if !types.Identical(n.Type, nsrc.Type.Elem()) {
-			n = assignconv(n, nsrc.Type.Elem(), "append")
+		if !types.Identical(n.Type(), nsrc.Type().Elem()) {
+			n = assignconv(n, nsrc.Type().Elem(), "append")
 			n = walkexpr(n, init)
 		}
 		ls[i] = n
 	}
 
-	argc := n.List.Len() - 1
+	argc := n.List().Len() - 1
 	if argc < 1 {
 		return nsrc
 	}
@@ -3044,18 +3044,18 @@ func walkappend(n *ir.Node, init *ir.Nodes, dst *ir.Node) *ir.Node {
 
 	var l []*ir.Node
 
-	ns := temp(nsrc.Type)
+	ns := temp(nsrc.Type())
 	l = append(l, ir.Nod(ir.OAS, ns, nsrc)) // s = src
 
 	na := nodintconst(int64(argc)) // const argc
 	nx := ir.Nod(ir.OIF, nil, nil) // if cap(s) - len(s) < argc
-	nx.Left = ir.Nod(ir.OLT, ir.Nod(ir.OSUB, ir.Nod(ir.OCAP, ns, nil), ir.Nod(ir.OLEN, ns, nil)), na)
+	nx.SetLeft(ir.Nod(ir.OLT, ir.Nod(ir.OSUB, ir.Nod(ir.OCAP, ns, nil), ir.Nod(ir.OLEN, ns, nil)), na))
 
 	fn := syslook("growslice") //   growslice(<type>, old []T, mincap int) (ret []T)
-	fn = substArgTypes(fn, ns.Type.Elem(), ns.Type.Elem())
+	fn = substArgTypes(fn, ns.Type().Elem(), ns.Type().Elem())
 
-	nx.Nbody.Set1(ir.Nod(ir.OAS, ns,
-		mkcall1(fn, ns.Type, &nx.Ninit, typename(ns.Type.Elem()), ns,
+	nx.PtrBody().Set1(ir.Nod(ir.OAS, ns,
+		mkcall1(fn, ns.Type(), nx.PtrInit(), typename(ns.Type().Elem()), ns,
 			ir.Nod(ir.OADD, ir.Nod(ir.OLEN, ns, nil), na))))
 
 	l = append(l, nx)
@@ -3068,7 +3068,7 @@ func walkappend(n *ir.Node, init *ir.Nodes, dst *ir.Node) *ir.Node {
 	nx.SetBounded(true)
 	l = append(l, ir.Nod(ir.OAS, ns, nx)) // s = s[:n+argc]
 
-	ls = n.List.Slice()[1:]
+	ls = n.List().Slice()[1:]
 	for i, n := range ls {
 		nx = ir.Nod(ir.OINDEX, ns, nn) // s[n] ...
 		nx.SetBounded(true)
@@ -3096,14 +3096,14 @@ func walkappend(n *ir.Node, init *ir.Nodes, dst *ir.Node) *ir.Node {
 // Also works if b is a string.
 //
 func copyany(n *ir.Node, init *ir.Nodes, runtimecall bool) *ir.Node {
-	if n.Left.Type.Elem().HasPointers() {
-		Curfn.Func.SetWBPos(n.Pos)
-		fn := writebarrierfn("typedslicecopy", n.Left.Type.Elem(), n.Right.Type.Elem())
-		n.Left = cheapexpr(n.Left, init)
-		ptrL, lenL := backingArrayPtrLen(n.Left)
-		n.Right = cheapexpr(n.Right, init)
-		ptrR, lenR := backingArrayPtrLen(n.Right)
-		return mkcall1(fn, n.Type, init, typename(n.Left.Type.Elem()), ptrL, lenL, ptrR, lenR)
+	if n.Left().Type().Elem().HasPointers() {
+		Curfn.Func().SetWBPos(n.Pos())
+		fn := writebarrierfn("typedslicecopy", n.Left().Type().Elem(), n.Right().Type().Elem())
+		n.SetLeft(cheapexpr(n.Left(), init))
+		ptrL, lenL := backingArrayPtrLen(n.Left())
+		n.SetRight(cheapexpr(n.Right(), init))
+		ptrR, lenR := backingArrayPtrLen(n.Right())
+		return mkcall1(fn, n.Type(), init, typename(n.Left().Type().Elem()), ptrL, lenL, ptrR, lenR)
 	}
 
 	if runtimecall {
@@ -3111,24 +3111,24 @@ func copyany(n *ir.Node, init *ir.Nodes, runtimecall bool) *ir.Node {
 		//  copy(n.Left, n.Right)
 		// n.Right can be a slice or string.
 
-		n.Left = cheapexpr(n.Left, init)
-		ptrL, lenL := backingArrayPtrLen(n.Left)
-		n.Right = cheapexpr(n.Right, init)
-		ptrR, lenR := backingArrayPtrLen(n.Right)
+		n.SetLeft(cheapexpr(n.Left(), init))
+		ptrL, lenL := backingArrayPtrLen(n.Left())
+		n.SetRight(cheapexpr(n.Right(), init))
+		ptrR, lenR := backingArrayPtrLen(n.Right())
 
 		fn := syslook("slicecopy")
-		fn = substArgTypes(fn, ptrL.Type.Elem(), ptrR.Type.Elem())
+		fn = substArgTypes(fn, ptrL.Type().Elem(), ptrR.Type().Elem())
 
-		return mkcall1(fn, n.Type, init, ptrL, lenL, ptrR, lenR, nodintconst(n.Left.Type.Elem().Width))
+		return mkcall1(fn, n.Type(), init, ptrL, lenL, ptrR, lenR, nodintconst(n.Left().Type().Elem().Width))
 	}
 
-	n.Left = walkexpr(n.Left, init)
-	n.Right = walkexpr(n.Right, init)
-	nl := temp(n.Left.Type)
-	nr := temp(n.Right.Type)
+	n.SetLeft(walkexpr(n.Left(), init))
+	n.SetRight(walkexpr(n.Right(), init))
+	nl := temp(n.Left().Type())
+	nr := temp(n.Right().Type())
 	var l []*ir.Node
-	l = append(l, ir.Nod(ir.OAS, nl, n.Left))
-	l = append(l, ir.Nod(ir.OAS, nr, n.Right))
+	l = append(l, ir.Nod(ir.OAS, nl, n.Left()))
+	l = append(l, ir.Nod(ir.OAS, nr, n.Right()))
 
 	nfrm := ir.Nod(ir.OSPTR, nr, nil)
 	nto := ir.Nod(ir.OSPTR, nl, nil)
@@ -3141,8 +3141,8 @@ func copyany(n *ir.Node, init *ir.Nodes, runtimecall bool) *ir.Node {
 	// if n > len(frm) { n = len(frm) }
 	nif := ir.Nod(ir.OIF, nil, nil)
 
-	nif.Left = ir.Nod(ir.OGT, nlen, ir.Nod(ir.OLEN, nr, nil))
-	nif.Nbody.Append(ir.Nod(ir.OAS, nlen, ir.Nod(ir.OLEN, nr, nil)))
+	nif.SetLeft(ir.Nod(ir.OGT, nlen, ir.Nod(ir.OLEN, nr, nil)))
+	nif.PtrBody().Append(ir.Nod(ir.OAS, nlen, ir.Nod(ir.OLEN, nr, nil)))
 	l = append(l, nif)
 
 	// if to.ptr != frm.ptr { memmove( ... ) }
@@ -3151,13 +3151,13 @@ func copyany(n *ir.Node, init *ir.Nodes, runtimecall bool) *ir.Node {
 	l = append(l, ne)
 
 	fn := syslook("memmove")
-	fn = substArgTypes(fn, nl.Type.Elem(), nl.Type.Elem())
+	fn = substArgTypes(fn, nl.Type().Elem(), nl.Type().Elem())
 	nwid := temp(types.Types[types.TUINTPTR])
 	setwid := ir.Nod(ir.OAS, nwid, conv(nlen, types.Types[types.TUINTPTR]))
-	ne.Nbody.Append(setwid)
-	nwid = ir.Nod(ir.OMUL, nwid, nodintconst(nl.Type.Elem().Width))
+	ne.PtrBody().Append(setwid)
+	nwid = ir.Nod(ir.OMUL, nwid, nodintconst(nl.Type().Elem().Width))
 	call := mkcall1(fn, nil, init, nto, nfrm, nwid)
-	ne.Nbody.Append(call)
+	ne.PtrBody().Append(call)
 
 	typecheckslice(l, ctxStmt)
 	walkstmtlist(l)
@@ -3179,12 +3179,12 @@ func eqfor(t *types.Type) (n *ir.Node, needsize bool) {
 		sym := typesymprefix(".eq", t)
 		n := NewName(sym)
 		setNodeNameFunc(n)
-		n.Type = functype(nil, []*ir.Node{
+		n.SetType(functype(nil, []*ir.Node{
 			anonfield(types.NewPtr(t)),
 			anonfield(types.NewPtr(t)),
 		}, []*ir.Node{
 			anonfield(types.Types[types.TBOOL]),
-		})
+		}))
 		return n, false
 	}
 	base.Fatalf("eqfor %v", t)
@@ -3194,31 +3194,31 @@ func eqfor(t *types.Type) (n *ir.Node, needsize bool) {
 // The result of walkcompare MUST be assigned back to n, e.g.
 // 	n.Left = walkcompare(n.Left, init)
 func walkcompare(n *ir.Node, init *ir.Nodes) *ir.Node {
-	if n.Left.Type.IsInterface() && n.Right.Type.IsInterface() && n.Left.Op != ir.ONIL && n.Right.Op != ir.ONIL {
+	if n.Left().Type().IsInterface() && n.Right().Type().IsInterface() && n.Left().Op() != ir.ONIL && n.Right().Op() != ir.ONIL {
 		return walkcompareInterface(n, init)
 	}
 
-	if n.Left.Type.IsString() && n.Right.Type.IsString() {
+	if n.Left().Type().IsString() && n.Right().Type().IsString() {
 		return walkcompareString(n, init)
 	}
 
-	n.Left = walkexpr(n.Left, init)
-	n.Right = walkexpr(n.Right, init)
+	n.SetLeft(walkexpr(n.Left(), init))
+	n.SetRight(walkexpr(n.Right(), init))
 
 	// Given mixed interface/concrete comparison,
 	// rewrite into types-equal && data-equal.
 	// This is efficient, avoids allocations, and avoids runtime calls.
-	if n.Left.Type.IsInterface() != n.Right.Type.IsInterface() {
+	if n.Left().Type().IsInterface() != n.Right().Type().IsInterface() {
 		// Preserve side-effects in case of short-circuiting; see #32187.
-		l := cheapexpr(n.Left, init)
-		r := cheapexpr(n.Right, init)
+		l := cheapexpr(n.Left(), init)
+		r := cheapexpr(n.Right(), init)
 		// Swap so that l is the interface value and r is the concrete value.
-		if n.Right.Type.IsInterface() {
+		if n.Right().Type().IsInterface() {
 			l, r = r, l
 		}
 
 		// Handle both == and !=.
-		eq := n.Op
+		eq := n.Op()
 		andor := ir.OOROR
 		if eq == ir.OEQ {
 			andor = ir.OANDAND
@@ -3230,9 +3230,9 @@ func walkcompare(n *ir.Node, init *ir.Nodes) *ir.Node {
 		//   l.tab != nil && l.tab._type == type(r)
 		var eqtype *ir.Node
 		tab := ir.Nod(ir.OITAB, l, nil)
-		rtyp := typename(r.Type)
-		if l.Type.IsEmptyInterface() {
-			tab.Type = types.NewPtr(types.Types[types.TUINT8])
+		rtyp := typename(r.Type())
+		if l.Type().IsEmptyInterface() {
+			tab.SetType(types.NewPtr(types.Types[types.TUINT8]))
 			tab.SetTypecheck(1)
 			eqtype = ir.Nod(eq, tab, rtyp)
 		} else {
@@ -3241,7 +3241,7 @@ func walkcompare(n *ir.Node, init *ir.Nodes) *ir.Node {
 			eqtype = ir.Nod(andor, nonnil, match)
 		}
 		// Check for data equal.
-		eqdata := ir.Nod(eq, ifaceData(n.Pos, l, r.Type), r)
+		eqdata := ir.Nod(eq, ifaceData(n.Pos(), l, r.Type()), r)
 		// Put it all together.
 		expr := ir.Nod(andor, eqtype, eqdata)
 		n = finishcompare(n, expr, init)
@@ -3252,7 +3252,7 @@ func walkcompare(n *ir.Node, init *ir.Nodes) *ir.Node {
 	// Otherwise back end handles it.
 	// While we're here, decide whether to
 	// inline or call an eq alg.
-	t := n.Left.Type
+	t := n.Left().Type()
 	var inline bool
 
 	maxcmpsize := int64(4)
@@ -3265,18 +3265,18 @@ func walkcompare(n *ir.Node, init *ir.Nodes) *ir.Node {
 	switch t.Etype {
 	default:
 		if base.Debug.Libfuzzer != 0 && t.IsInteger() {
-			n.Left = cheapexpr(n.Left, init)
-			n.Right = cheapexpr(n.Right, init)
+			n.SetLeft(cheapexpr(n.Left(), init))
+			n.SetRight(cheapexpr(n.Right(), init))
 
 			// If exactly one comparison operand is
 			// constant, invoke the constcmp functions
 			// instead, and arrange for the constant
 			// operand to be the first argument.
-			l, r := n.Left, n.Right
-			if r.Op == ir.OLITERAL {
+			l, r := n.Left(), n.Right()
+			if r.Op() == ir.OLITERAL {
 				l, r = r, l
 			}
-			constcmp := l.Op == ir.OLITERAL && r.Op != ir.OLITERAL
+			constcmp := l.Op() == ir.OLITERAL && r.Op() != ir.OLITERAL
 
 			var fn string
 			var paramType *types.Type
@@ -3318,13 +3318,13 @@ func walkcompare(n *ir.Node, init *ir.Nodes) *ir.Node {
 		inline = t.NumComponents(types.IgnoreBlankFields) <= 4
 	}
 
-	cmpl := n.Left
-	for cmpl != nil && cmpl.Op == ir.OCONVNOP {
-		cmpl = cmpl.Left
+	cmpl := n.Left()
+	for cmpl != nil && cmpl.Op() == ir.OCONVNOP {
+		cmpl = cmpl.Left()
 	}
-	cmpr := n.Right
-	for cmpr != nil && cmpr.Op == ir.OCONVNOP {
-		cmpr = cmpr.Left
+	cmpr := n.Right()
+	for cmpr != nil && cmpr.Op() == ir.OCONVNOP {
+		cmpr = cmpr.Left()
 	}
 
 	// Chose not to inline. Call equality function directly.
@@ -3336,13 +3336,13 @@ func walkcompare(n *ir.Node, init *ir.Nodes) *ir.Node {
 
 		fn, needsize := eqfor(t)
 		call := ir.Nod(ir.OCALL, fn, nil)
-		call.List.Append(ir.Nod(ir.OADDR, cmpl, nil))
-		call.List.Append(ir.Nod(ir.OADDR, cmpr, nil))
+		call.PtrList().Append(ir.Nod(ir.OADDR, cmpl, nil))
+		call.PtrList().Append(ir.Nod(ir.OADDR, cmpr, nil))
 		if needsize {
-			call.List.Append(nodintconst(t.Width))
+			call.PtrList().Append(nodintconst(t.Width))
 		}
 		res := call
-		if n.Op != ir.OEQ {
+		if n.Op() != ir.OEQ {
 			res = ir.Nod(ir.ONOT, res, nil)
 		}
 		n = finishcompare(n, res, init)
@@ -3351,12 +3351,12 @@ func walkcompare(n *ir.Node, init *ir.Nodes) *ir.Node {
 
 	// inline: build boolean expression comparing element by element
 	andor := ir.OANDAND
-	if n.Op == ir.ONE {
+	if n.Op() == ir.ONE {
 		andor = ir.OOROR
 	}
 	var expr *ir.Node
 	compare := func(el, er *ir.Node) {
-		a := ir.Nod(n.Op, el, er)
+		a := ir.Nod(n.Op(), el, er)
 		if expr == nil {
 			expr = a
 		} else {
@@ -3433,10 +3433,10 @@ func walkcompare(n *ir.Node, init *ir.Nodes) *ir.Node {
 		}
 	}
 	if expr == nil {
-		expr = nodbool(n.Op == ir.OEQ)
+		expr = nodbool(n.Op() == ir.OEQ)
 		// We still need to use cmpl and cmpr, in case they contain
 		// an expression which might panic. See issue 23837.
-		t := temp(cmpl.Type)
+		t := temp(cmpl.Type())
 		a1 := ir.Nod(ir.OAS, t, cmpl)
 		a1 = typecheck(a1, ctxStmt)
 		a2 := ir.Nod(ir.OAS, t, cmpr)
@@ -3449,22 +3449,22 @@ func walkcompare(n *ir.Node, init *ir.Nodes) *ir.Node {
 
 func tracecmpArg(n *ir.Node, t *types.Type, init *ir.Nodes) *ir.Node {
 	// Ugly hack to avoid "constant -1 overflows uintptr" errors, etc.
-	if n.Op == ir.OLITERAL && n.Type.IsSigned() && n.Int64Val() < 0 {
-		n = copyexpr(n, n.Type, init)
+	if n.Op() == ir.OLITERAL && n.Type().IsSigned() && n.Int64Val() < 0 {
+		n = copyexpr(n, n.Type(), init)
 	}
 
 	return conv(n, t)
 }
 
 func walkcompareInterface(n *ir.Node, init *ir.Nodes) *ir.Node {
-	n.Right = cheapexpr(n.Right, init)
-	n.Left = cheapexpr(n.Left, init)
-	eqtab, eqdata := eqinterface(n.Left, n.Right)
+	n.SetRight(cheapexpr(n.Right(), init))
+	n.SetLeft(cheapexpr(n.Left(), init))
+	eqtab, eqdata := eqinterface(n.Left(), n.Right())
 	var cmp *ir.Node
-	if n.Op == ir.OEQ {
+	if n.Op() == ir.OEQ {
 		cmp = ir.Nod(ir.OANDAND, eqtab, eqdata)
 	} else {
-		eqtab.Op = ir.ONE
+		eqtab.SetOp(ir.ONE)
 		cmp = ir.Nod(ir.OOROR, eqtab, ir.Nod(ir.ONOT, eqdata, nil))
 	}
 	return finishcompare(n, cmp, init)
@@ -3474,21 +3474,21 @@ func walkcompareString(n *ir.Node, init *ir.Nodes) *ir.Node {
 	// Rewrite comparisons to short constant strings as length+byte-wise comparisons.
 	var cs, ncs *ir.Node // const string, non-const string
 	switch {
-	case ir.IsConst(n.Left, constant.String) && ir.IsConst(n.Right, constant.String):
+	case ir.IsConst(n.Left(), constant.String) && ir.IsConst(n.Right(), constant.String):
 		// ignore; will be constant evaluated
-	case ir.IsConst(n.Left, constant.String):
-		cs = n.Left
-		ncs = n.Right
-	case ir.IsConst(n.Right, constant.String):
-		cs = n.Right
-		ncs = n.Left
+	case ir.IsConst(n.Left(), constant.String):
+		cs = n.Left()
+		ncs = n.Right()
+	case ir.IsConst(n.Right(), constant.String):
+		cs = n.Right()
+		ncs = n.Left()
 	}
 	if cs != nil {
-		cmp := n.Op
+		cmp := n.Op()
 		// Our comparison below assumes that the non-constant string
 		// is on the left hand side, so rewrite "" cmp x to x cmp "".
 		// See issue 24817.
-		if ir.IsConst(n.Left, constant.String) {
+		if ir.IsConst(n.Left(), constant.String) {
 			cmp = brrev(cmp)
 		}
 
@@ -3571,25 +3571,25 @@ func walkcompareString(n *ir.Node, init *ir.Nodes) *ir.Node {
 	}
 
 	var r *ir.Node
-	if n.Op == ir.OEQ || n.Op == ir.ONE {
+	if n.Op() == ir.OEQ || n.Op() == ir.ONE {
 		// prepare for rewrite below
-		n.Left = cheapexpr(n.Left, init)
-		n.Right = cheapexpr(n.Right, init)
-		eqlen, eqmem := eqstring(n.Left, n.Right)
+		n.SetLeft(cheapexpr(n.Left(), init))
+		n.SetRight(cheapexpr(n.Right(), init))
+		eqlen, eqmem := eqstring(n.Left(), n.Right())
 		// quick check of len before full compare for == or !=.
 		// memequal then tests equality up to length len.
-		if n.Op == ir.OEQ {
+		if n.Op() == ir.OEQ {
 			// len(left) == len(right) && memequal(left, right, len)
 			r = ir.Nod(ir.OANDAND, eqlen, eqmem)
 		} else {
 			// len(left) != len(right) || !memequal(left, right, len)
-			eqlen.Op = ir.ONE
+			eqlen.SetOp(ir.ONE)
 			r = ir.Nod(ir.OOROR, eqlen, ir.Nod(ir.ONOT, eqmem, nil))
 		}
 	} else {
 		// sys_cmpstring(s1, s2) :: 0
-		r = mkcall("cmpstring", types.Types[types.TINT], init, conv(n.Left, types.Types[types.TSTRING]), conv(n.Right, types.Types[types.TSTRING]))
-		r = ir.Nod(n.Op, r, nodintconst(0))
+		r = mkcall("cmpstring", types.Types[types.TINT], init, conv(n.Left(), types.Types[types.TSTRING]), conv(n.Right(), types.Types[types.TSTRING]))
+		r = ir.Nod(n.Op(), r, nodintconst(0))
 	}
 
 	return finishcompare(n, r, init)
@@ -3599,34 +3599,34 @@ func walkcompareString(n *ir.Node, init *ir.Nodes) *ir.Node {
 // 	n.Left = finishcompare(n.Left, x, r, init)
 func finishcompare(n, r *ir.Node, init *ir.Nodes) *ir.Node {
 	r = typecheck(r, ctxExpr)
-	r = conv(r, n.Type)
+	r = conv(r, n.Type())
 	r = walkexpr(r, init)
 	return r
 }
 
 // return 1 if integer n must be in range [0, max), 0 otherwise
 func bounded(n *ir.Node, max int64) bool {
-	if n.Type == nil || !n.Type.IsInteger() {
+	if n.Type() == nil || !n.Type().IsInteger() {
 		return false
 	}
 
-	sign := n.Type.IsSigned()
-	bits := int32(8 * n.Type.Width)
+	sign := n.Type().IsSigned()
+	bits := int32(8 * n.Type().Width)
 
 	if smallintconst(n) {
 		v := n.Int64Val()
 		return 0 <= v && v < max
 	}
 
-	switch n.Op {
+	switch n.Op() {
 	case ir.OAND, ir.OANDNOT:
 		v := int64(-1)
 		switch {
-		case smallintconst(n.Left):
-			v = n.Left.Int64Val()
-		case smallintconst(n.Right):
-			v = n.Right.Int64Val()
-			if n.Op == ir.OANDNOT {
+		case smallintconst(n.Left()):
+			v = n.Left().Int64Val()
+		case smallintconst(n.Right()):
+			v = n.Right().Int64Val()
+			if n.Op() == ir.OANDNOT {
 				v = ^v
 				if !sign {
 					v &= 1<<uint(bits) - 1
@@ -3638,16 +3638,16 @@ func bounded(n *ir.Node, max int64) bool {
 		}
 
 	case ir.OMOD:
-		if !sign && smallintconst(n.Right) {
-			v := n.Right.Int64Val()
+		if !sign && smallintconst(n.Right()) {
+			v := n.Right().Int64Val()
 			if 0 <= v && v <= max {
 				return true
 			}
 		}
 
 	case ir.ODIV:
-		if !sign && smallintconst(n.Right) {
-			v := n.Right.Int64Val()
+		if !sign && smallintconst(n.Right()) {
+			v := n.Right().Int64Val()
 			for bits > 0 && v >= 2 {
 				bits--
 				v >>= 1
@@ -3655,8 +3655,8 @@ func bounded(n *ir.Node, max int64) bool {
 		}
 
 	case ir.ORSH:
-		if !sign && smallintconst(n.Right) {
-			v := n.Right.Int64Val()
+		if !sign && smallintconst(n.Right()) {
+			v := n.Right().Int64Val()
 			if v > int64(bits) {
 				return true
 			}
@@ -3673,7 +3673,7 @@ func bounded(n *ir.Node, max int64) bool {
 
 // usemethod checks interface method calls for uses of reflect.Type.Method.
 func usemethod(n *ir.Node) {
-	t := n.Left.Type
+	t := n.Left().Type()
 
 	// Looking for either of:
 	//	Method(int) reflect.Method
@@ -3711,9 +3711,9 @@ func usemethod(n *ir.Node) {
 	//       (including global variables such as numImports - was issue #19028).
 	// Also need to check for reflect package itself (see Issue #38515).
 	if s := res0.Type.Sym; s != nil && s.Name == "Method" && isReflectPkg(s.Pkg) {
-		Curfn.Func.SetReflectMethod(true)
+		Curfn.Func().SetReflectMethod(true)
 		// The LSym is initialized at this point. We need to set the attribute on the LSym.
-		Curfn.Func.LSym.Set(obj.AttrReflectMethod, true)
+		Curfn.Func().LSym.Set(obj.AttrReflectMethod, true)
 	}
 }
 
@@ -3722,35 +3722,35 @@ func usefield(n *ir.Node) {
 		return
 	}
 
-	switch n.Op {
+	switch n.Op() {
 	default:
-		base.Fatalf("usefield %v", n.Op)
+		base.Fatalf("usefield %v", n.Op())
 
 	case ir.ODOT, ir.ODOTPTR:
 		break
 	}
-	if n.Sym == nil {
+	if n.Sym() == nil {
 		// No field name.  This DOTPTR was built by the compiler for access
 		// to runtime data structures.  Ignore.
 		return
 	}
 
-	t := n.Left.Type
+	t := n.Left().Type()
 	if t.IsPtr() {
 		t = t.Elem()
 	}
 	field := n.Opt().(*types.Field)
 	if field == nil {
-		base.Fatalf("usefield %v %v without paramfld", n.Left.Type, n.Sym)
+		base.Fatalf("usefield %v %v without paramfld", n.Left().Type(), n.Sym())
 	}
-	if field.Sym != n.Sym || field.Offset != n.Xoffset {
-		base.Fatalf("field inconsistency: %v,%v != %v,%v", field.Sym, field.Offset, n.Sym, n.Xoffset)
+	if field.Sym != n.Sym() || field.Offset != n.Offset() {
+		base.Fatalf("field inconsistency: %v,%v != %v,%v", field.Sym, field.Offset, n.Sym(), n.Offset())
 	}
 	if !strings.Contains(field.Note, "go:\"track\"") {
 		return
 	}
 
-	outer := n.Left.Type
+	outer := n.Left().Type()
 	if outer.IsPtr() {
 		outer = outer.Elem()
 	}
@@ -3762,10 +3762,10 @@ func usefield(n *ir.Node) {
 	}
 
 	sym := tracksym(outer, field)
-	if Curfn.Func.FieldTrack == nil {
-		Curfn.Func.FieldTrack = make(map[*types.Sym]struct{})
+	if Curfn.Func().FieldTrack == nil {
+		Curfn.Func().FieldTrack = make(map[*types.Sym]struct{})
 	}
-	Curfn.Func.FieldTrack[sym] = struct{}{}
+	Curfn.Func().FieldTrack[sym] = struct{}{}
 }
 
 func candiscardlist(l ir.Nodes) bool {
@@ -3782,7 +3782,7 @@ func candiscard(n *ir.Node) bool {
 		return true
 	}
 
-	switch n.Op {
+	switch n.Op() {
 	default:
 		return false
 
@@ -3844,14 +3844,14 @@ func candiscard(n *ir.Node) bool {
 
 		// Discardable as long as we know it's not division by zero.
 	case ir.ODIV, ir.OMOD:
-		if n.Right.Op == ir.OLITERAL && constant.Sign(n.Right.Val()) != 0 {
+		if n.Right().Op() == ir.OLITERAL && constant.Sign(n.Right().Val()) != 0 {
 			break
 		}
 		return false
 
 		// Discardable as long as we know it won't fail because of a bad size.
 	case ir.OMAKECHAN, ir.OMAKEMAP:
-		if ir.IsConst(n.Left, constant.Int) && constant.Sign(n.Left.Val()) == 0 {
+		if ir.IsConst(n.Left(), constant.Int) && constant.Sign(n.Left().Val()) == 0 {
 			break
 		}
 		return false
@@ -3864,7 +3864,7 @@ func candiscard(n *ir.Node) bool {
 		return false
 	}
 
-	if !candiscard(n.Left) || !candiscard(n.Right) || !candiscardlist(n.Ninit) || !candiscardlist(n.Nbody) || !candiscardlist(n.List) || !candiscardlist(n.Rlist) {
+	if !candiscard(n.Left()) || !candiscard(n.Right()) || !candiscardlist(n.Init()) || !candiscardlist(n.Body()) || !candiscardlist(n.List()) || !candiscardlist(n.Rlist()) {
 		return false
 	}
 
@@ -3892,66 +3892,66 @@ var wrapCall_prgen int
 // The result of wrapCall MUST be assigned back to n, e.g.
 // 	n.Left = wrapCall(n.Left, init)
 func wrapCall(n *ir.Node, init *ir.Nodes) *ir.Node {
-	if n.Ninit.Len() != 0 {
-		walkstmtlist(n.Ninit.Slice())
-		init.AppendNodes(&n.Ninit)
+	if n.Init().Len() != 0 {
+		walkstmtlist(n.Init().Slice())
+		init.AppendNodes(n.PtrInit())
 	}
 
-	isBuiltinCall := n.Op != ir.OCALLFUNC && n.Op != ir.OCALLMETH && n.Op != ir.OCALLINTER
+	isBuiltinCall := n.Op() != ir.OCALLFUNC && n.Op() != ir.OCALLMETH && n.Op() != ir.OCALLINTER
 
 	// Turn f(a, b, []T{c, d, e}...) back into f(a, b, c, d, e).
 	if !isBuiltinCall && n.IsDDD() {
-		last := n.List.Len() - 1
-		if va := n.List.Index(last); va.Op == ir.OSLICELIT {
-			n.List.Set(append(n.List.Slice()[:last], va.List.Slice()...))
+		last := n.List().Len() - 1
+		if va := n.List().Index(last); va.Op() == ir.OSLICELIT {
+			n.PtrList().Set(append(n.List().Slice()[:last], va.List().Slice()...))
 			n.SetIsDDD(false)
 		}
 	}
 
 	// origArgs keeps track of what argument is uintptr-unsafe/unsafe-uintptr conversion.
-	origArgs := make([]*ir.Node, n.List.Len())
+	origArgs := make([]*ir.Node, n.List().Len())
 	t := ir.Nod(ir.OTFUNC, nil, nil)
-	for i, arg := range n.List.Slice() {
+	for i, arg := range n.List().Slice() {
 		s := lookupN("a", i)
-		if !isBuiltinCall && arg.Op == ir.OCONVNOP && arg.Type.IsUintptr() && arg.Left.Type.IsUnsafePtr() {
+		if !isBuiltinCall && arg.Op() == ir.OCONVNOP && arg.Type().IsUintptr() && arg.Left().Type().IsUnsafePtr() {
 			origArgs[i] = arg
-			arg = arg.Left
-			n.List.SetIndex(i, arg)
+			arg = arg.Left()
+			n.List().SetIndex(i, arg)
 		}
-		t.List.Append(symfield(s, arg.Type))
+		t.PtrList().Append(symfield(s, arg.Type()))
 	}
 
 	wrapCall_prgen++
 	sym := lookupN("wrap·", wrapCall_prgen)
 	fn := dclfunc(sym, t)
 
-	args := paramNnames(t.Type)
+	args := paramNnames(t.Type())
 	for i, origArg := range origArgs {
 		if origArg == nil {
 			continue
 		}
-		arg := ir.Nod(origArg.Op, args[i], nil)
-		arg.Type = origArg.Type
+		arg := ir.Nod(origArg.Op(), args[i], nil)
+		arg.SetType(origArg.Type())
 		args[i] = arg
 	}
-	call := ir.Nod(n.Op, nil, nil)
+	call := ir.Nod(n.Op(), nil, nil)
 	if !isBuiltinCall {
-		call.Op = ir.OCALL
-		call.Left = n.Left
+		call.SetOp(ir.OCALL)
+		call.SetLeft(n.Left())
 		call.SetIsDDD(n.IsDDD())
 	}
-	call.List.Set(args)
-	fn.Nbody.Set1(call)
+	call.PtrList().Set(args)
+	fn.PtrBody().Set1(call)
 
 	funcbody()
 
 	fn = typecheck(fn, ctxStmt)
-	typecheckslice(fn.Nbody.Slice(), ctxStmt)
+	typecheckslice(fn.Body().Slice(), ctxStmt)
 	xtop = append(xtop, fn)
 
 	call = ir.Nod(ir.OCALL, nil, nil)
-	call.Left = fn.Func.Nname
-	call.List.Set(n.List.Slice())
+	call.SetLeft(fn.Func().Nname)
+	call.PtrList().Set(n.List().Slice())
 	call = typecheck(call, ctxStmt)
 	call = walkexpr(call, init)
 	return call
@@ -3968,7 +3968,7 @@ func substArgTypes(old *ir.Node, types_ ...*types.Type) *ir.Node {
 	for _, t := range types_ {
 		dowidth(t)
 	}
-	n.Type = types.SubstAny(n.Type, &types_)
+	n.SetType(types.SubstAny(n.Type(), &types_))
 	if len(types_) > 0 {
 		base.Fatalf("substArgTypes: too many argument types")
 	}
@@ -3993,14 +3993,14 @@ func canMergeLoads() bool {
 // isRuneCount reports whether n is of the form len([]rune(string)).
 // These are optimized into a call to runtime.countrunes.
 func isRuneCount(n *ir.Node) bool {
-	return base.Flag.N == 0 && !instrumenting && n.Op == ir.OLEN && n.Left.Op == ir.OSTR2RUNES
+	return base.Flag.N == 0 && !instrumenting && n.Op() == ir.OLEN && n.Left().Op() == ir.OSTR2RUNES
 }
 
 func walkCheckPtrAlignment(n *ir.Node, init *ir.Nodes, count *ir.Node) *ir.Node {
-	if !n.Type.IsPtr() {
-		base.Fatalf("expected pointer type: %v", n.Type)
+	if !n.Type().IsPtr() {
+		base.Fatalf("expected pointer type: %v", n.Type())
 	}
-	elem := n.Type.Elem()
+	elem := n.Type().Elem()
 	if count != nil {
 		if !elem.IsArray() {
 			base.Fatalf("expected array type: %v", elem)
@@ -4017,8 +4017,8 @@ func walkCheckPtrAlignment(n *ir.Node, init *ir.Nodes, count *ir.Node) *ir.Node
 		count = nodintconst(1)
 	}
 
-	n.Left = cheapexpr(n.Left, init)
-	init.Append(mkcall("checkptrAlignment", nil, init, convnop(n.Left, types.Types[types.TUNSAFEPTR]), typename(elem), conv(count, types.Types[types.TUINTPTR])))
+	n.SetLeft(cheapexpr(n.Left(), init))
+	init.Append(mkcall("checkptrAlignment", nil, init, convnop(n.Left(), types.Types[types.TUNSAFEPTR]), typename(elem), conv(count, types.Types[types.TUINTPTR])))
 	return n
 }
 
@@ -4040,12 +4040,12 @@ func walkCheckPtrArithmetic(n *ir.Node, init *ir.Nodes) *ir.Node {
 
 	// TODO(mdempsky): Make stricter. We only need to exempt
 	// reflect.Value.Pointer and reflect.Value.UnsafeAddr.
-	switch n.Left.Op {
+	switch n.Left().Op() {
 	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
 		return n
 	}
 
-	if n.Left.Op == ir.ODOTPTR && isReflectHeaderDataField(n.Left) {
+	if n.Left().Op() == ir.ODOTPTR && isReflectHeaderDataField(n.Left()) {
 		return n
 	}
 
@@ -4058,25 +4058,25 @@ func walkCheckPtrArithmetic(n *ir.Node, init *ir.Nodes) *ir.Node {
 	var originals []*ir.Node
 	var walk func(n *ir.Node)
 	walk = func(n *ir.Node) {
-		switch n.Op {
+		switch n.Op() {
 		case ir.OADD:
-			walk(n.Left)
-			walk(n.Right)
+			walk(n.Left())
+			walk(n.Right())
 		case ir.OSUB, ir.OANDNOT:
-			walk(n.Left)
+			walk(n.Left())
 		case ir.OCONVNOP:
-			if n.Left.Type.IsUnsafePtr() {
-				n.Left = cheapexpr(n.Left, init)
-				originals = append(originals, convnop(n.Left, types.Types[types.TUNSAFEPTR]))
+			if n.Left().Type().IsUnsafePtr() {
+				n.SetLeft(cheapexpr(n.Left(), init))
+				originals = append(originals, convnop(n.Left(), types.Types[types.TUNSAFEPTR]))
 			}
 		}
 	}
-	walk(n.Left)
+	walk(n.Left())
 
 	n = cheapexpr(n, init)
 
 	slice := mkdotargslice(types.NewSlice(types.Types[types.TUNSAFEPTR]), originals)
-	slice.Esc = EscNone
+	slice.SetEsc(EscNone)
 
 	init.Append(mkcall("checkptrArithmetic", nil, init, convnop(n, types.Types[types.TUNSAFEPTR]), slice))
 	// TODO(khr): Mark backing store of slice as dead. This will allow us to reuse
@@ -4089,5 +4089,5 @@ func walkCheckPtrArithmetic(n *ir.Node, init *ir.Nodes) *ir.Node {
 // function fn at a given level. See debugHelpFooter for defined
 // levels.
 func checkPtr(fn *ir.Node, level int) bool {
-	return base.Debug.Checkptr >= level && fn.Func.Pragma&ir.NoCheckPtr == 0
+	return base.Debug.Checkptr >= level && fn.Func().Pragma&ir.NoCheckPtr == 0
 }
diff --git a/src/cmd/compile/internal/ir/dump.go b/src/cmd/compile/internal/ir/dump.go
index 9306366e8a..43d0742c73 100644
--- a/src/cmd/compile/internal/ir/dump.go
+++ b/src/cmd/compile/internal/ir/dump.go
@@ -205,7 +205,7 @@ func (p *dumper) dump(x reflect.Value, depth int) {
 		isNode := false
 		if n, ok := x.Interface().(Node); ok {
 			isNode = true
-			p.printf("%s %s {", n.Op.String(), p.addr(x))
+			p.printf("%s %s {", n.op.String(), p.addr(x))
 		} else {
 			p.printf("%s {", typ)
 		}
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 5dea0880fc..e1e3813368 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -351,28 +351,28 @@ func jconvFmt(n *Node, s fmt.State, flag FmtFlag) {
 	if base.Debug.DumpPtrs != 0 {
 		fmt.Fprintf(s, " p(%p)", n)
 	}
-	if !short && n.Name != nil && n.Name.Vargen != 0 {
-		fmt.Fprintf(s, " g(%d)", n.Name.Vargen)
+	if !short && n.Name() != nil && n.Name().Vargen != 0 {
+		fmt.Fprintf(s, " g(%d)", n.Name().Vargen)
 	}
 
-	if base.Debug.DumpPtrs != 0 && !short && n.Name != nil && n.Name.Defn != nil {
+	if base.Debug.DumpPtrs != 0 && !short && n.Name() != nil && n.Name().Defn != nil {
 		// Useful to see where Defn is set and what node it points to
-		fmt.Fprintf(s, " defn(%p)", n.Name.Defn)
+		fmt.Fprintf(s, " defn(%p)", n.Name().Defn)
 	}
 
-	if n.Pos.IsKnown() {
+	if n.Pos().IsKnown() {
 		pfx := ""
-		switch n.Pos.IsStmt() {
+		switch n.Pos().IsStmt() {
 		case src.PosNotStmt:
 			pfx = "_" // "-" would be confusing
 		case src.PosIsStmt:
 			pfx = "+"
 		}
-		fmt.Fprintf(s, " l(%s%d)", pfx, n.Pos.Line())
+		fmt.Fprintf(s, " l(%s%d)", pfx, n.Pos().Line())
 	}
 
-	if !short && n.Xoffset != types.BADWIDTH {
-		fmt.Fprintf(s, " x(%d)", n.Xoffset)
+	if !short && n.Offset() != types.BADWIDTH {
+		fmt.Fprintf(s, " x(%d)", n.Offset())
 	}
 
 	if n.Class() != 0 {
@@ -405,20 +405,20 @@ func jconvFmt(n *Node, s fmt.State, flag FmtFlag) {
 		fmt.Fprintf(s, " embedded")
 	}
 
-	if n.Op == ONAME {
-		if n.Name.Addrtaken() {
+	if n.Op() == ONAME {
+		if n.Name().Addrtaken() {
 			fmt.Fprint(s, " addrtaken")
 		}
-		if n.Name.Assigned() {
+		if n.Name().Assigned() {
 			fmt.Fprint(s, " assigned")
 		}
-		if n.Name.IsClosureVar() {
+		if n.Name().IsClosureVar() {
 			fmt.Fprint(s, " closurevar")
 		}
-		if n.Name.Captured() {
+		if n.Name().Captured() {
 			fmt.Fprint(s, " captured")
 		}
-		if n.Name.IsOutputParamHeapAddr() {
+		if n.Name().IsOutputParamHeapAddr() {
 			fmt.Fprint(s, " outputparamheapaddr")
 		}
 	}
@@ -433,7 +433,7 @@ func jconvFmt(n *Node, s fmt.State, flag FmtFlag) {
 		fmt.Fprint(s, " hascall")
 	}
 
-	if !short && n.Name != nil && n.Name.Used() {
+	if !short && n.Name() != nil && n.Name().Used() {
 		fmt.Fprint(s, " used")
 	}
 }
@@ -899,31 +899,31 @@ func stmtFmt(n *Node, s fmt.State, mode FmtMode) {
 	// block starting with the init statements.
 
 	// if we can just say "for" n->ninit; ... then do so
-	simpleinit := n.Ninit.Len() == 1 && n.Ninit.First().Ninit.Len() == 0 && StmtWithInit(n.Op)
+	simpleinit := n.Init().Len() == 1 && n.Init().First().Init().Len() == 0 && StmtWithInit(n.Op())
 
 	// otherwise, print the inits as separate statements
-	complexinit := n.Ninit.Len() != 0 && !simpleinit && (mode != FErr)
+	complexinit := n.Init().Len() != 0 && !simpleinit && (mode != FErr)
 
 	// but if it was for if/for/switch, put in an extra surrounding block to limit the scope
-	extrablock := complexinit && StmtWithInit(n.Op)
+	extrablock := complexinit && StmtWithInit(n.Op())
 
 	if extrablock {
 		fmt.Fprint(s, "{")
 	}
 
 	if complexinit {
-		mode.Fprintf(s, " %v; ", n.Ninit)
+		mode.Fprintf(s, " %v; ", n.Init())
 	}
 
-	switch n.Op {
+	switch n.Op() {
 	case ODCL:
-		mode.Fprintf(s, "var %v %v", n.Left.Sym, n.Left.Type)
+		mode.Fprintf(s, "var %v %v", n.Left().Sym(), n.Left().Type())
 
 	case ODCLFIELD:
-		if n.Sym != nil {
-			mode.Fprintf(s, "%v %v", n.Sym, n.Left)
+		if n.Sym() != nil {
+			mode.Fprintf(s, "%v %v", n.Sym(), n.Left())
 		} else {
-			mode.Fprintf(s, "%v", n.Left)
+			mode.Fprintf(s, "%v", n.Left())
 		}
 
 	// Don't export "v = <N>" initializing statements, hope they're always
@@ -931,61 +931,61 @@ func stmtFmt(n *Node, s fmt.State, mode FmtMode) {
 	// the "v = <N>" again.
 	case OAS:
 		if n.Colas() && !complexinit {
-			mode.Fprintf(s, "%v := %v", n.Left, n.Right)
+			mode.Fprintf(s, "%v := %v", n.Left(), n.Right())
 		} else {
-			mode.Fprintf(s, "%v = %v", n.Left, n.Right)
+			mode.Fprintf(s, "%v = %v", n.Left(), n.Right())
 		}
 
 	case OASOP:
 		if n.Implicit() {
 			if n.SubOp() == OADD {
-				mode.Fprintf(s, "%v++", n.Left)
+				mode.Fprintf(s, "%v++", n.Left())
 			} else {
-				mode.Fprintf(s, "%v--", n.Left)
+				mode.Fprintf(s, "%v--", n.Left())
 			}
 			break
 		}
 
-		mode.Fprintf(s, "%v %#v= %v", n.Left, n.SubOp(), n.Right)
+		mode.Fprintf(s, "%v %#v= %v", n.Left(), n.SubOp(), n.Right())
 
 	case OAS2:
 		if n.Colas() && !complexinit {
-			mode.Fprintf(s, "%.v := %.v", n.List, n.Rlist)
+			mode.Fprintf(s, "%.v := %.v", n.List(), n.Rlist())
 			break
 		}
 		fallthrough
 
 	case OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV:
-		mode.Fprintf(s, "%.v = %v", n.List, n.Right)
+		mode.Fprintf(s, "%.v = %v", n.List(), n.Right())
 
 	case ORETURN:
-		mode.Fprintf(s, "return %.v", n.List)
+		mode.Fprintf(s, "return %.v", n.List())
 
 	case ORETJMP:
-		mode.Fprintf(s, "retjmp %v", n.Sym)
+		mode.Fprintf(s, "retjmp %v", n.Sym())
 
 	case OINLMARK:
-		mode.Fprintf(s, "inlmark %d", n.Xoffset)
+		mode.Fprintf(s, "inlmark %d", n.Offset())
 
 	case OGO:
-		mode.Fprintf(s, "go %v", n.Left)
+		mode.Fprintf(s, "go %v", n.Left())
 
 	case ODEFER:
-		mode.Fprintf(s, "defer %v", n.Left)
+		mode.Fprintf(s, "defer %v", n.Left())
 
 	case OIF:
 		if simpleinit {
-			mode.Fprintf(s, "if %v; %v { %v }", n.Ninit.First(), n.Left, n.Nbody)
+			mode.Fprintf(s, "if %v; %v { %v }", n.Init().First(), n.Left(), n.Body())
 		} else {
-			mode.Fprintf(s, "if %v { %v }", n.Left, n.Nbody)
+			mode.Fprintf(s, "if %v { %v }", n.Left(), n.Body())
 		}
-		if n.Rlist.Len() != 0 {
-			mode.Fprintf(s, " else { %v }", n.Rlist)
+		if n.Rlist().Len() != 0 {
+			mode.Fprintf(s, " else { %v }", n.Rlist())
 		}
 
 	case OFOR, OFORUNTIL:
 		opname := "for"
-		if n.Op == OFORUNTIL {
+		if n.Op() == OFORUNTIL {
 			opname = "foruntil"
 		}
 		if mode == FErr { // TODO maybe only if FmtShort, same below
@@ -995,26 +995,26 @@ func stmtFmt(n *Node, s fmt.State, mode FmtMode) {
 
 		fmt.Fprint(s, opname)
 		if simpleinit {
-			mode.Fprintf(s, " %v;", n.Ninit.First())
-		} else if n.Right != nil {
+			mode.Fprintf(s, " %v;", n.Init().First())
+		} else if n.Right() != nil {
 			fmt.Fprint(s, " ;")
 		}
 
-		if n.Left != nil {
-			mode.Fprintf(s, " %v", n.Left)
+		if n.Left() != nil {
+			mode.Fprintf(s, " %v", n.Left())
 		}
 
-		if n.Right != nil {
-			mode.Fprintf(s, "; %v", n.Right)
+		if n.Right() != nil {
+			mode.Fprintf(s, "; %v", n.Right())
 		} else if simpleinit {
 			fmt.Fprint(s, ";")
 		}
 
-		if n.Op == OFORUNTIL && n.List.Len() != 0 {
-			mode.Fprintf(s, "; %v", n.List)
+		if n.Op() == OFORUNTIL && n.List().Len() != 0 {
+			mode.Fprintf(s, "; %v", n.List())
 		}
 
-		mode.Fprintf(s, " { %v }", n.Nbody)
+		mode.Fprintf(s, " { %v }", n.Body())
 
 	case ORANGE:
 		if mode == FErr {
@@ -1022,49 +1022,49 @@ func stmtFmt(n *Node, s fmt.State, mode FmtMode) {
 			break
 		}
 
-		if n.List.Len() == 0 {
-			mode.Fprintf(s, "for range %v { %v }", n.Right, n.Nbody)
+		if n.List().Len() == 0 {
+			mode.Fprintf(s, "for range %v { %v }", n.Right(), n.Body())
 			break
 		}
 
-		mode.Fprintf(s, "for %.v = range %v { %v }", n.List, n.Right, n.Nbody)
+		mode.Fprintf(s, "for %.v = range %v { %v }", n.List(), n.Right(), n.Body())
 
 	case OSELECT, OSWITCH:
 		if mode == FErr {
-			mode.Fprintf(s, "%v statement", n.Op)
+			mode.Fprintf(s, "%v statement", n.Op())
 			break
 		}
 
-		mode.Fprintf(s, "%#v", n.Op)
+		mode.Fprintf(s, "%#v", n.Op())
 		if simpleinit {
-			mode.Fprintf(s, " %v;", n.Ninit.First())
+			mode.Fprintf(s, " %v;", n.Init().First())
 		}
-		if n.Left != nil {
-			mode.Fprintf(s, " %v ", n.Left)
+		if n.Left() != nil {
+			mode.Fprintf(s, " %v ", n.Left())
 		}
 
-		mode.Fprintf(s, " { %v }", n.List)
+		mode.Fprintf(s, " { %v }", n.List())
 
 	case OCASE:
-		if n.List.Len() != 0 {
-			mode.Fprintf(s, "case %.v", n.List)
+		if n.List().Len() != 0 {
+			mode.Fprintf(s, "case %.v", n.List())
 		} else {
 			fmt.Fprint(s, "default")
 		}
-		mode.Fprintf(s, ": %v", n.Nbody)
+		mode.Fprintf(s, ": %v", n.Body())
 
 	case OBREAK, OCONTINUE, OGOTO, OFALL:
-		if n.Sym != nil {
-			mode.Fprintf(s, "%#v %v", n.Op, n.Sym)
+		if n.Sym() != nil {
+			mode.Fprintf(s, "%#v %v", n.Op(), n.Sym())
 		} else {
-			mode.Fprintf(s, "%#v", n.Op)
+			mode.Fprintf(s, "%#v", n.Op())
 		}
 
 	case OEMPTY:
 		break
 
 	case OLABEL:
-		mode.Fprintf(s, "%v: ", n.Sym)
+		mode.Fprintf(s, "%v: ", n.Sym())
 	}
 
 	if extrablock {
@@ -1193,8 +1193,8 @@ var OpPrec = []int{
 }
 
 func exprFmt(n *Node, s fmt.State, prec int, mode FmtMode) {
-	for n != nil && n.Implicit() && (n.Op == ODEREF || n.Op == OADDR) {
-		n = n.Left
+	for n != nil && n.Implicit() && (n.Op() == ODEREF || n.Op() == OADDR) {
+		n = n.Left()
 	}
 
 	if n == nil {
@@ -1202,8 +1202,8 @@ func exprFmt(n *Node, s fmt.State, prec int, mode FmtMode) {
 		return
 	}
 
-	nprec := OpPrec[n.Op]
-	if n.Op == OTYPE && n.Sym != nil {
+	nprec := OpPrec[n.Op()]
+	if n.Op() == OTYPE && n.Sym() != nil {
 		nprec = 8
 	}
 
@@ -1212,38 +1212,38 @@ func exprFmt(n *Node, s fmt.State, prec int, mode FmtMode) {
 		return
 	}
 
-	switch n.Op {
+	switch n.Op() {
 	case OPAREN:
-		mode.Fprintf(s, "(%v)", n.Left)
+		mode.Fprintf(s, "(%v)", n.Left())
 
 	case ONIL:
 		fmt.Fprint(s, "nil")
 
 	case OLITERAL: // this is a bit of a mess
 		if mode == FErr {
-			if n.Orig != nil && n.Orig != n {
-				exprFmt(n.Orig, s, prec, mode)
+			if n.Orig() != nil && n.Orig() != n {
+				exprFmt(n.Orig(), s, prec, mode)
 				return
 			}
-			if n.Sym != nil {
-				fmt.Fprint(s, smodeString(n.Sym, mode))
+			if n.Sym() != nil {
+				fmt.Fprint(s, smodeString(n.Sym(), mode))
 				return
 			}
 		}
 
 		needUnparen := false
-		if n.Type != nil && !n.Type.IsUntyped() {
+		if n.Type() != nil && !n.Type().IsUntyped() {
 			// Need parens when type begins with what might
 			// be misinterpreted as a unary operator: * or <-.
-			if n.Type.IsPtr() || (n.Type.IsChan() && n.Type.ChanDir() == types.Crecv) {
-				mode.Fprintf(s, "(%v)(", n.Type)
+			if n.Type().IsPtr() || (n.Type().IsChan() && n.Type().ChanDir() == types.Crecv) {
+				mode.Fprintf(s, "(%v)(", n.Type())
 			} else {
-				mode.Fprintf(s, "%v(", n.Type)
+				mode.Fprintf(s, "%v(", n.Type())
 			}
 			needUnparen = true
 		}
 
-		if n.Type == types.UntypedRune {
+		if n.Type() == types.UntypedRune {
 			switch x, ok := constant.Int64Val(n.Val()); {
 			case !ok:
 				fallthrough
@@ -1270,44 +1270,44 @@ func exprFmt(n *Node, s fmt.State, prec int, mode FmtMode) {
 	case ONAME:
 		// Special case: name used as local variable in export.
 		// _ becomes ~b%d internally; print as _ for export
-		if mode == FErr && n.Sym != nil && n.Sym.Name[0] == '~' && n.Sym.Name[1] == 'b' {
+		if mode == FErr && n.Sym() != nil && n.Sym().Name[0] == '~' && n.Sym().Name[1] == 'b' {
 			fmt.Fprint(s, "_")
 			return
 		}
 		fallthrough
 	case OPACK, ONONAME, OMETHEXPR:
-		fmt.Fprint(s, smodeString(n.Sym, mode))
+		fmt.Fprint(s, smodeString(n.Sym(), mode))
 
 	case OTYPE:
-		if n.Type == nil && n.Sym != nil {
-			fmt.Fprint(s, smodeString(n.Sym, mode))
+		if n.Type() == nil && n.Sym() != nil {
+			fmt.Fprint(s, smodeString(n.Sym(), mode))
 			return
 		}
-		mode.Fprintf(s, "%v", n.Type)
+		mode.Fprintf(s, "%v", n.Type())
 
 	case OTARRAY:
-		if n.Left != nil {
-			mode.Fprintf(s, "[%v]%v", n.Left, n.Right)
+		if n.Left() != nil {
+			mode.Fprintf(s, "[%v]%v", n.Left(), n.Right())
 			return
 		}
-		mode.Fprintf(s, "[]%v", n.Right) // happens before typecheck
+		mode.Fprintf(s, "[]%v", n.Right()) // happens before typecheck
 
 	case OTMAP:
-		mode.Fprintf(s, "map[%v]%v", n.Left, n.Right)
+		mode.Fprintf(s, "map[%v]%v", n.Left(), n.Right())
 
 	case OTCHAN:
 		switch n.TChanDir() {
 		case types.Crecv:
-			mode.Fprintf(s, "<-chan %v", n.Left)
+			mode.Fprintf(s, "<-chan %v", n.Left())
 
 		case types.Csend:
-			mode.Fprintf(s, "chan<- %v", n.Left)
+			mode.Fprintf(s, "chan<- %v", n.Left())
 
 		default:
-			if n.Left != nil && n.Left.Op == OTCHAN && n.Left.Sym == nil && n.Left.TChanDir() == types.Crecv {
-				mode.Fprintf(s, "chan (%v)", n.Left)
+			if n.Left() != nil && n.Left().Op() == OTCHAN && n.Left().Sym() == nil && n.Left().TChanDir() == types.Crecv {
+				mode.Fprintf(s, "chan (%v)", n.Left())
 			} else {
-				mode.Fprintf(s, "chan %v", n.Left)
+				mode.Fprintf(s, "chan %v", n.Left())
 			}
 		}
 
@@ -1325,11 +1325,11 @@ func exprFmt(n *Node, s fmt.State, prec int, mode FmtMode) {
 			fmt.Fprint(s, "func literal")
 			return
 		}
-		if n.Nbody.Len() != 0 {
-			mode.Fprintf(s, "%v { %v }", n.Type, n.Nbody)
+		if n.Body().Len() != 0 {
+			mode.Fprintf(s, "%v { %v }", n.Type(), n.Body())
 			return
 		}
-		mode.Fprintf(s, "%v { %v }", n.Type, n.Func.Decl.Nbody)
+		mode.Fprintf(s, "%v { %v }", n.Type(), n.Func().Decl.Body())
 
 	case OCOMPLIT:
 		if mode == FErr {
@@ -1337,75 +1337,75 @@ func exprFmt(n *Node, s fmt.State, prec int, mode FmtMode) {
 				mode.Fprintf(s, "... argument")
 				return
 			}
-			if n.Right != nil {
-				mode.Fprintf(s, "%v{%s}", n.Right, ellipsisIf(n.List.Len() != 0))
+			if n.Right() != nil {
+				mode.Fprintf(s, "%v{%s}", n.Right(), ellipsisIf(n.List().Len() != 0))
 				return
 			}
 
 			fmt.Fprint(s, "composite literal")
 			return
 		}
-		mode.Fprintf(s, "(%v{ %.v })", n.Right, n.List)
+		mode.Fprintf(s, "(%v{ %.v })", n.Right(), n.List())
 
 	case OPTRLIT:
-		mode.Fprintf(s, "&%v", n.Left)
+		mode.Fprintf(s, "&%v", n.Left())
 
 	case OSTRUCTLIT, OARRAYLIT, OSLICELIT, OMAPLIT:
 		if mode == FErr {
-			mode.Fprintf(s, "%v{%s}", n.Type, ellipsisIf(n.List.Len() != 0))
+			mode.Fprintf(s, "%v{%s}", n.Type(), ellipsisIf(n.List().Len() != 0))
 			return
 		}
-		mode.Fprintf(s, "(%v{ %.v })", n.Type, n.List)
+		mode.Fprintf(s, "(%v{ %.v })", n.Type(), n.List())
 
 	case OKEY:
-		if n.Left != nil && n.Right != nil {
-			mode.Fprintf(s, "%v:%v", n.Left, n.Right)
+		if n.Left() != nil && n.Right() != nil {
+			mode.Fprintf(s, "%v:%v", n.Left(), n.Right())
 			return
 		}
 
-		if n.Left == nil && n.Right != nil {
-			mode.Fprintf(s, ":%v", n.Right)
+		if n.Left() == nil && n.Right() != nil {
+			mode.Fprintf(s, ":%v", n.Right())
 			return
 		}
-		if n.Left != nil && n.Right == nil {
-			mode.Fprintf(s, "%v:", n.Left)
+		if n.Left() != nil && n.Right() == nil {
+			mode.Fprintf(s, "%v:", n.Left())
 			return
 		}
 		fmt.Fprint(s, ":")
 
 	case OSTRUCTKEY:
-		mode.Fprintf(s, "%v:%v", n.Sym, n.Left)
+		mode.Fprintf(s, "%v:%v", n.Sym(), n.Left())
 
 	case OCALLPART:
-		exprFmt(n.Left, s, nprec, mode)
-		if n.Right == nil || n.Right.Sym == nil {
+		exprFmt(n.Left(), s, nprec, mode)
+		if n.Right() == nil || n.Right().Sym() == nil {
 			fmt.Fprint(s, ".<nil>")
 			return
 		}
-		mode.Fprintf(s, ".%0S", n.Right.Sym)
+		mode.Fprintf(s, ".%0S", n.Right().Sym())
 
 	case OXDOT, ODOT, ODOTPTR, ODOTINTER, ODOTMETH:
-		exprFmt(n.Left, s, nprec, mode)
-		if n.Sym == nil {
+		exprFmt(n.Left(), s, nprec, mode)
+		if n.Sym() == nil {
 			fmt.Fprint(s, ".<nil>")
 			return
 		}
-		mode.Fprintf(s, ".%0S", n.Sym)
+		mode.Fprintf(s, ".%0S", n.Sym())
 
 	case ODOTTYPE, ODOTTYPE2:
-		exprFmt(n.Left, s, nprec, mode)
-		if n.Right != nil {
-			mode.Fprintf(s, ".(%v)", n.Right)
+		exprFmt(n.Left(), s, nprec, mode)
+		if n.Right() != nil {
+			mode.Fprintf(s, ".(%v)", n.Right())
 			return
 		}
-		mode.Fprintf(s, ".(%v)", n.Type)
+		mode.Fprintf(s, ".(%v)", n.Type())
 
 	case OINDEX, OINDEXMAP:
-		exprFmt(n.Left, s, nprec, mode)
-		mode.Fprintf(s, "[%v]", n.Right)
+		exprFmt(n.Left(), s, nprec, mode)
+		mode.Fprintf(s, "[%v]", n.Right())
 
 	case OSLICE, OSLICESTR, OSLICEARR, OSLICE3, OSLICE3ARR:
-		exprFmt(n.Left, s, nprec, mode)
+		exprFmt(n.Left(), s, nprec, mode)
 		fmt.Fprint(s, "[")
 		low, high, max := n.SliceBounds()
 		if low != nil {
@@ -1415,7 +1415,7 @@ func exprFmt(n *Node, s fmt.State, prec int, mode FmtMode) {
 		if high != nil {
 			fmt.Fprint(s, modeString(high, mode))
 		}
-		if n.Op.IsSlice3() {
+		if n.Op().IsSlice3() {
 			fmt.Fprint(s, ":")
 			if max != nil {
 				fmt.Fprint(s, modeString(max, mode))
@@ -1424,16 +1424,16 @@ func exprFmt(n *Node, s fmt.State, prec int, mode FmtMode) {
 		fmt.Fprint(s, "]")
 
 	case OSLICEHEADER:
-		if n.List.Len() != 2 {
-			base.Fatalf("bad OSLICEHEADER list length %d", n.List.Len())
+		if n.List().Len() != 2 {
+			base.Fatalf("bad OSLICEHEADER list length %d", n.List().Len())
 		}
-		mode.Fprintf(s, "sliceheader{%v,%v,%v}", n.Left, n.List.First(), n.List.Second())
+		mode.Fprintf(s, "sliceheader{%v,%v,%v}", n.Left(), n.List().First(), n.List().Second())
 
 	case OCOMPLEX, OCOPY:
-		if n.Left != nil {
-			mode.Fprintf(s, "%#v(%v, %v)", n.Op, n.Left, n.Right)
+		if n.Left() != nil {
+			mode.Fprintf(s, "%#v(%v, %v)", n.Op(), n.Left(), n.Right())
 		} else {
-			mode.Fprintf(s, "%#v(%.v)", n.Op, n.List)
+			mode.Fprintf(s, "%#v(%.v)", n.Op(), n.List())
 		}
 
 	case OCONV,
@@ -1444,15 +1444,15 @@ func exprFmt(n *Node, s fmt.State, prec int, mode FmtMode) {
 		OSTR2BYTES,
 		OSTR2RUNES,
 		ORUNESTR:
-		if n.Type == nil || n.Type.Sym == nil {
-			mode.Fprintf(s, "(%v)", n.Type)
+		if n.Type() == nil || n.Type().Sym == nil {
+			mode.Fprintf(s, "(%v)", n.Type())
 		} else {
-			mode.Fprintf(s, "%v", n.Type)
+			mode.Fprintf(s, "%v", n.Type())
 		}
-		if n.Left != nil {
-			mode.Fprintf(s, "(%v)", n.Left)
+		if n.Left() != nil {
+			mode.Fprintf(s, "(%v)", n.Left())
 		} else {
-			mode.Fprintf(s, "(%.v)", n.List)
+			mode.Fprintf(s, "(%.v)", n.List())
 		}
 
 	case OREAL,
@@ -1471,49 +1471,49 @@ func exprFmt(n *Node, s fmt.State, prec int, mode FmtMode) {
 		OSIZEOF,
 		OPRINT,
 		OPRINTN:
-		if n.Left != nil {
-			mode.Fprintf(s, "%#v(%v)", n.Op, n.Left)
+		if n.Left() != nil {
+			mode.Fprintf(s, "%#v(%v)", n.Op(), n.Left())
 			return
 		}
 		if n.IsDDD() {
-			mode.Fprintf(s, "%#v(%.v...)", n.Op, n.List)
+			mode.Fprintf(s, "%#v(%.v...)", n.Op(), n.List())
 			return
 		}
-		mode.Fprintf(s, "%#v(%.v)", n.Op, n.List)
+		mode.Fprintf(s, "%#v(%.v)", n.Op(), n.List())
 
 	case OCALL, OCALLFUNC, OCALLINTER, OCALLMETH, OGETG:
-		exprFmt(n.Left, s, nprec, mode)
+		exprFmt(n.Left(), s, nprec, mode)
 		if n.IsDDD() {
-			mode.Fprintf(s, "(%.v...)", n.List)
+			mode.Fprintf(s, "(%.v...)", n.List())
 			return
 		}
-		mode.Fprintf(s, "(%.v)", n.List)
+		mode.Fprintf(s, "(%.v)", n.List())
 
 	case OMAKEMAP, OMAKECHAN, OMAKESLICE:
-		if n.List.Len() != 0 { // pre-typecheck
-			mode.Fprintf(s, "make(%v, %.v)", n.Type, n.List)
+		if n.List().Len() != 0 { // pre-typecheck
+			mode.Fprintf(s, "make(%v, %.v)", n.Type(), n.List())
 			return
 		}
-		if n.Right != nil {
-			mode.Fprintf(s, "make(%v, %v, %v)", n.Type, n.Left, n.Right)
+		if n.Right() != nil {
+			mode.Fprintf(s, "make(%v, %v, %v)", n.Type(), n.Left(), n.Right())
 			return
 		}
-		if n.Left != nil && (n.Op == OMAKESLICE || !n.Left.Type.IsUntyped()) {
-			mode.Fprintf(s, "make(%v, %v)", n.Type, n.Left)
+		if n.Left() != nil && (n.Op() == OMAKESLICE || !n.Left().Type().IsUntyped()) {
+			mode.Fprintf(s, "make(%v, %v)", n.Type(), n.Left())
 			return
 		}
-		mode.Fprintf(s, "make(%v)", n.Type)
+		mode.Fprintf(s, "make(%v)", n.Type())
 
 	case OMAKESLICECOPY:
-		mode.Fprintf(s, "makeslicecopy(%v, %v, %v)", n.Type, n.Left, n.Right)
+		mode.Fprintf(s, "makeslicecopy(%v, %v, %v)", n.Type(), n.Left(), n.Right())
 
 	case OPLUS, ONEG, OADDR, OBITNOT, ODEREF, ONOT, ORECV:
 		// Unary
-		mode.Fprintf(s, "%#v", n.Op)
-		if n.Left != nil && n.Left.Op == n.Op {
+		mode.Fprintf(s, "%#v", n.Op())
+		if n.Left() != nil && n.Left().Op() == n.Op() {
 			fmt.Fprint(s, " ")
 		}
-		exprFmt(n.Left, s, nprec+1, mode)
+		exprFmt(n.Left(), s, nprec+1, mode)
 
 		// Binary
 	case OADD,
@@ -1536,12 +1536,12 @@ func exprFmt(n *Node, s fmt.State, prec int, mode FmtMode) {
 		OSEND,
 		OSUB,
 		OXOR:
-		exprFmt(n.Left, s, nprec, mode)
-		mode.Fprintf(s, " %#v ", n.Op)
-		exprFmt(n.Right, s, nprec+1, mode)
+		exprFmt(n.Left(), s, nprec, mode)
+		mode.Fprintf(s, " %#v ", n.Op())
+		exprFmt(n.Right(), s, nprec+1, mode)
 
 	case OADDSTR:
-		for i, n1 := range n.List.Slice() {
+		for i, n1 := range n.List().Slice() {
 			if i != 0 {
 				fmt.Fprint(s, " + ")
 			}
@@ -1550,23 +1550,23 @@ func exprFmt(n *Node, s fmt.State, prec int, mode FmtMode) {
 	case ODDD:
 		mode.Fprintf(s, "...")
 	default:
-		mode.Fprintf(s, "<node %v>", n.Op)
+		mode.Fprintf(s, "<node %v>", n.Op())
 	}
 }
 
 func nodeFmt(n *Node, s fmt.State, flag FmtFlag, mode FmtMode) {
-	t := n.Type
+	t := n.Type()
 
 	// We almost always want the original.
 	// TODO(gri) Why the special case for OLITERAL?
-	if n.Op != OLITERAL && n.Orig != nil {
-		n = n.Orig
+	if n.Op() != OLITERAL && n.Orig() != nil {
+		n = n.Orig()
 	}
 
 	if flag&FmtLong != 0 && t != nil {
 		if t.Etype == types.TNIL {
 			fmt.Fprint(s, "nil")
-		} else if n.Op == ONAME && n.Name.AutoTemp() {
+		} else if n.Op() == ONAME && n.Name().AutoTemp() {
 			mode.Fprintf(s, "%v value", t)
 		} else {
 			mode.Fprintf(s, "%v (type %v)", n, t)
@@ -1576,7 +1576,7 @@ func nodeFmt(n *Node, s fmt.State, flag FmtFlag, mode FmtMode) {
 
 	// TODO inlining produces expressions with ninits. we can't print these yet.
 
-	if OpPrec[n.Op] < 0 {
+	if OpPrec[n.Op()] < 0 {
 		stmtFmt(n, s, mode)
 		return
 	}
@@ -1594,82 +1594,82 @@ func nodeDumpFmt(n *Node, s fmt.State, flag FmtFlag, mode FmtMode) {
 			return
 		}
 
-		if n.Ninit.Len() != 0 {
-			mode.Fprintf(s, "%v-init%v", n.Op, n.Ninit)
+		if n.Init().Len() != 0 {
+			mode.Fprintf(s, "%v-init%v", n.Op(), n.Init())
 			indent(s)
 		}
 	}
 
-	switch n.Op {
+	switch n.Op() {
 	default:
-		mode.Fprintf(s, "%v%j", n.Op, n)
+		mode.Fprintf(s, "%v%j", n.Op(), n)
 
 	case OLITERAL:
-		mode.Fprintf(s, "%v-%v%j", n.Op, n.Val(), n)
+		mode.Fprintf(s, "%v-%v%j", n.Op(), n.Val(), n)
 
 	case ONAME, ONONAME, OMETHEXPR:
-		if n.Sym != nil {
-			mode.Fprintf(s, "%v-%v%j", n.Op, n.Sym, n)
+		if n.Sym() != nil {
+			mode.Fprintf(s, "%v-%v%j", n.Op(), n.Sym(), n)
 		} else {
-			mode.Fprintf(s, "%v%j", n.Op, n)
+			mode.Fprintf(s, "%v%j", n.Op(), n)
 		}
-		if recur && n.Type == nil && n.Name != nil && n.Name.Param != nil && n.Name.Param.Ntype != nil {
+		if recur && n.Type() == nil && n.Name() != nil && n.Name().Param != nil && n.Name().Param.Ntype != nil {
 			indent(s)
-			mode.Fprintf(s, "%v-ntype%v", n.Op, n.Name.Param.Ntype)
+			mode.Fprintf(s, "%v-ntype%v", n.Op(), n.Name().Param.Ntype)
 		}
 
 	case OASOP:
-		mode.Fprintf(s, "%v-%v%j", n.Op, n.SubOp(), n)
+		mode.Fprintf(s, "%v-%v%j", n.Op(), n.SubOp(), n)
 
 	case OTYPE:
-		mode.Fprintf(s, "%v %v%j type=%v", n.Op, n.Sym, n, n.Type)
-		if recur && n.Type == nil && n.Name != nil && n.Name.Param != nil && n.Name.Param.Ntype != nil {
+		mode.Fprintf(s, "%v %v%j type=%v", n.Op(), n.Sym(), n, n.Type())
+		if recur && n.Type() == nil && n.Name() != nil && n.Name().Param != nil && n.Name().Param.Ntype != nil {
 			indent(s)
-			mode.Fprintf(s, "%v-ntype%v", n.Op, n.Name.Param.Ntype)
+			mode.Fprintf(s, "%v-ntype%v", n.Op(), n.Name().Param.Ntype)
 		}
 	}
 
-	if n.Op == OCLOSURE && n.Func.Decl != nil && n.Func.Nname.Sym != nil {
-		mode.Fprintf(s, " fnName %v", n.Func.Nname.Sym)
+	if n.Op() == OCLOSURE && n.Func().Decl != nil && n.Func().Nname.Sym() != nil {
+		mode.Fprintf(s, " fnName %v", n.Func().Nname.Sym())
 	}
-	if n.Sym != nil && n.Op != ONAME {
-		mode.Fprintf(s, " %v", n.Sym)
+	if n.Sym() != nil && n.Op() != ONAME {
+		mode.Fprintf(s, " %v", n.Sym())
 	}
 
-	if n.Type != nil {
-		mode.Fprintf(s, " %v", n.Type)
+	if n.Type() != nil {
+		mode.Fprintf(s, " %v", n.Type())
 	}
 
 	if recur {
-		if n.Left != nil {
-			mode.Fprintf(s, "%v", n.Left)
+		if n.Left() != nil {
+			mode.Fprintf(s, "%v", n.Left())
 		}
-		if n.Right != nil {
-			mode.Fprintf(s, "%v", n.Right)
+		if n.Right() != nil {
+			mode.Fprintf(s, "%v", n.Right())
 		}
-		if n.Op == OCLOSURE && n.Func != nil && n.Func.Decl != nil && n.Func.Decl.Nbody.Len() != 0 {
+		if n.Op() == OCLOSURE && n.Func() != nil && n.Func().Decl != nil && n.Func().Decl.Body().Len() != 0 {
 			indent(s)
 			// The function associated with a closure
-			mode.Fprintf(s, "%v-clofunc%v", n.Op, n.Func.Decl)
+			mode.Fprintf(s, "%v-clofunc%v", n.Op(), n.Func().Decl)
 		}
-		if n.Op == ODCLFUNC && n.Func != nil && n.Func.Dcl != nil && len(n.Func.Dcl) != 0 {
+		if n.Op() == ODCLFUNC && n.Func() != nil && n.Func().Dcl != nil && len(n.Func().Dcl) != 0 {
 			indent(s)
 			// The dcls for a func or closure
-			mode.Fprintf(s, "%v-dcl%v", n.Op, AsNodes(n.Func.Dcl))
+			mode.Fprintf(s, "%v-dcl%v", n.Op(), AsNodes(n.Func().Dcl))
 		}
-		if n.List.Len() != 0 {
+		if n.List().Len() != 0 {
 			indent(s)
-			mode.Fprintf(s, "%v-list%v", n.Op, n.List)
+			mode.Fprintf(s, "%v-list%v", n.Op(), n.List())
 		}
 
-		if n.Rlist.Len() != 0 {
+		if n.Rlist().Len() != 0 {
 			indent(s)
-			mode.Fprintf(s, "%v-rlist%v", n.Op, n.Rlist)
+			mode.Fprintf(s, "%v-rlist%v", n.Op(), n.Rlist())
 		}
 
-		if n.Nbody.Len() != 0 {
+		if n.Body().Len() != 0 {
 			indent(s)
-			mode.Fprintf(s, "%v-body%v", n.Op, n.Nbody)
+			mode.Fprintf(s, "%v-body%v", n.Op(), n.Body())
 		}
 	}
 }
@@ -1910,5 +1910,5 @@ func InstallTypeFormats() {
 // Line returns n's position as a string. If n has been inlined,
 // it uses the outermost position where n has been inlined.
 func Line(n *Node) string {
-	return base.FmtPos(n.Pos)
+	return base.FmtPos(n.Pos())
 }
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index cac9e6eb3e..dce1bfdbef 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -26,25 +26,25 @@ import (
 type Node struct {
 	// Tree structure.
 	// Generic recursive walks should follow these fields.
-	Left  *Node
-	Right *Node
-	Ninit Nodes
-	Nbody Nodes
-	List  Nodes
-	Rlist Nodes
+	left  *Node
+	right *Node
+	init  Nodes
+	body  Nodes
+	list  Nodes
+	rlist Nodes
 
 	// most nodes
-	Type *types.Type
-	Orig *Node // original form, for printing, and tracking copies of ONAMEs
+	typ  *types.Type
+	orig *Node // original form, for printing, and tracking copies of ONAMEs
 
 	// func
-	Func *Func
+	fn *Func
 
 	// ONAME, OTYPE, OPACK, OLABEL, some OLITERAL
-	Name *Name
+	name *Name
 
-	Sym *types.Sym  // various
-	E   interface{} // Opt or Val, see methods below
+	sym *types.Sym  // various
+	e   interface{} // Opt or Val, see methods below
 
 	// Various. Usually an offset into a struct. For example:
 	// - ONAME nodes that refer to local variables use it to identify their stack frame position.
@@ -54,85 +54,85 @@ type Node struct {
 	// - OINLMARK stores an index into the inlTree data structure.
 	// - OCLOSURE uses it to store ambient iota value, if any.
 	// Possibly still more uses. If you find any, document them.
-	Xoffset int64
+	offset int64
 
-	Pos src.XPos
+	pos src.XPos
 
 	flags bitset32
 
-	Esc uint16 // EscXXX
+	esc uint16 // EscXXX
 
-	Op  Op
+	op  Op
 	aux uint8
 }
 
-func (n *Node) GetLeft() *Node        { return n.Left }
-func (n *Node) SetLeft(x *Node)       { n.Left = x }
-func (n *Node) GetRight() *Node       { return n.Right }
-func (n *Node) SetRight(x *Node)      { n.Right = x }
-func (n *Node) GetOrig() *Node        { return n.Orig }
-func (n *Node) SetOrig(x *Node)       { n.Orig = x }
-func (n *Node) GetType() *types.Type  { return n.Type }
-func (n *Node) SetType(x *types.Type) { n.Type = x }
-func (n *Node) GetFunc() *Func        { return n.Func }
-func (n *Node) SetFunc(x *Func)       { n.Func = x }
-func (n *Node) GetName() *Name        { return n.Name }
-func (n *Node) SetName(x *Name)       { n.Name = x }
-func (n *Node) GetSym() *types.Sym    { return n.Sym }
-func (n *Node) SetSym(x *types.Sym)   { n.Sym = x }
-func (n *Node) GetPos() src.XPos      { return n.Pos }
-func (n *Node) SetPos(x src.XPos)     { n.Pos = x }
-func (n *Node) GetXoffset() int64     { return n.Xoffset }
-func (n *Node) SetXoffset(x int64)    { n.Xoffset = x }
-func (n *Node) GetEsc() uint16        { return n.Esc }
-func (n *Node) SetEsc(x uint16)       { n.Esc = x }
-func (n *Node) GetOp() Op             { return n.Op }
-func (n *Node) SetOp(x Op)            { n.Op = x }
-func (n *Node) GetNinit() Nodes       { return n.Ninit }
-func (n *Node) SetNinit(x Nodes)      { n.Ninit = x }
-func (n *Node) PtrNinit() *Nodes      { return &n.Ninit }
-func (n *Node) GetNbody() Nodes       { return n.Nbody }
-func (n *Node) SetNbody(x Nodes)      { n.Nbody = x }
-func (n *Node) PtrNbody() *Nodes      { return &n.Nbody }
-func (n *Node) GetList() Nodes        { return n.List }
-func (n *Node) SetList(x Nodes)       { n.List = x }
-func (n *Node) PtrList() *Nodes       { return &n.List }
-func (n *Node) GetRlist() Nodes       { return n.Rlist }
-func (n *Node) SetRlist(x Nodes)      { n.Rlist = x }
-func (n *Node) PtrRlist() *Nodes      { return &n.Rlist }
+func (n *Node) Left() *Node           { return n.left }
+func (n *Node) SetLeft(x *Node)       { n.left = x }
+func (n *Node) Right() *Node          { return n.right }
+func (n *Node) SetRight(x *Node)      { n.right = x }
+func (n *Node) Orig() *Node           { return n.orig }
+func (n *Node) SetOrig(x *Node)       { n.orig = x }
+func (n *Node) Type() *types.Type     { return n.typ }
+func (n *Node) SetType(x *types.Type) { n.typ = x }
+func (n *Node) Func() *Func           { return n.fn }
+func (n *Node) SetFunc(x *Func)       { n.fn = x }
+func (n *Node) Name() *Name           { return n.name }
+func (n *Node) SetName(x *Name)       { n.name = x }
+func (n *Node) Sym() *types.Sym       { return n.sym }
+func (n *Node) SetSym(x *types.Sym)   { n.sym = x }
+func (n *Node) Pos() src.XPos         { return n.pos }
+func (n *Node) SetPos(x src.XPos)     { n.pos = x }
+func (n *Node) Offset() int64         { return n.offset }
+func (n *Node) SetOffset(x int64)     { n.offset = x }
+func (n *Node) Esc() uint16           { return n.esc }
+func (n *Node) SetEsc(x uint16)       { n.esc = x }
+func (n *Node) Op() Op                { return n.op }
+func (n *Node) SetOp(x Op)            { n.op = x }
+func (n *Node) Init() Nodes           { return n.init }
+func (n *Node) SetInit(x Nodes)       { n.init = x }
+func (n *Node) PtrInit() *Nodes       { return &n.init }
+func (n *Node) Body() Nodes           { return n.body }
+func (n *Node) SetBody(x Nodes)       { n.body = x }
+func (n *Node) PtrBody() *Nodes       { return &n.body }
+func (n *Node) List() Nodes           { return n.list }
+func (n *Node) SetList(x Nodes)       { n.list = x }
+func (n *Node) PtrList() *Nodes       { return &n.list }
+func (n *Node) Rlist() Nodes          { return n.rlist }
+func (n *Node) SetRlist(x Nodes)      { n.rlist = x }
+func (n *Node) PtrRlist() *Nodes      { return &n.rlist }
 
 func (n *Node) ResetAux() {
 	n.aux = 0
 }
 
 func (n *Node) SubOp() Op {
-	switch n.Op {
+	switch n.Op() {
 	case OASOP, ONAME:
 	default:
-		base.Fatalf("unexpected op: %v", n.Op)
+		base.Fatalf("unexpected op: %v", n.Op())
 	}
 	return Op(n.aux)
 }
 
 func (n *Node) SetSubOp(op Op) {
-	switch n.Op {
+	switch n.Op() {
 	case OASOP, ONAME:
 	default:
-		base.Fatalf("unexpected op: %v", n.Op)
+		base.Fatalf("unexpected op: %v", n.Op())
 	}
 	n.aux = uint8(op)
 }
 
 func (n *Node) IndexMapLValue() bool {
-	if n.Op != OINDEXMAP {
-		base.Fatalf("unexpected op: %v", n.Op)
+	if n.Op() != OINDEXMAP {
+		base.Fatalf("unexpected op: %v", n.Op())
 	}
 	return n.aux != 0
 }
 
 func (n *Node) SetIndexMapLValue(b bool) {
-	if n.Op != OINDEXMAP {
-		base.Fatalf("unexpected op: %v", n.Op)
+	if n.Op() != OINDEXMAP {
+		base.Fatalf("unexpected op: %v", n.Op())
 	}
 	if b {
 		n.aux = 1
@@ -142,31 +142,31 @@ func (n *Node) SetIndexMapLValue(b bool) {
 }
 
 func (n *Node) TChanDir() types.ChanDir {
-	if n.Op != OTCHAN {
-		base.Fatalf("unexpected op: %v", n.Op)
+	if n.Op() != OTCHAN {
+		base.Fatalf("unexpected op: %v", n.Op())
 	}
 	return types.ChanDir(n.aux)
 }
 
 func (n *Node) SetTChanDir(dir types.ChanDir) {
-	if n.Op != OTCHAN {
-		base.Fatalf("unexpected op: %v", n.Op)
+	if n.Op() != OTCHAN {
+		base.Fatalf("unexpected op: %v", n.Op())
 	}
 	n.aux = uint8(dir)
 }
 
 func IsSynthetic(n *Node) bool {
-	name := n.Sym.Name
+	name := n.Sym().Name
 	return name[0] == '.' || name[0] == '~'
 }
 
 // IsAutoTmp indicates if n was created by the compiler as a temporary,
 // based on the setting of the .AutoTemp flag in n's Name.
 func IsAutoTmp(n *Node) bool {
-	if n == nil || n.Op != ONAME {
+	if n == nil || n.Op() != ONAME {
 		return false
 	}
-	return n.Name.AutoTemp()
+	return n.Name().AutoTemp()
 }
 
 const (
@@ -229,8 +229,8 @@ func (n *Node) SetColas(b bool)     { n.flags.set(nodeColas, b) }
 func (n *Node) SetTransient(b bool) { n.flags.set(nodeTransient, b) }
 func (n *Node) SetHasCall(b bool)   { n.flags.set(nodeHasCall, b) }
 func (n *Node) SetLikely(b bool)    { n.flags.set(nodeLikely, b) }
-func (n *Node) SetHasVal(b bool)    { n.flags.set(nodeHasVal, b) }
-func (n *Node) SetHasOpt(b bool)    { n.flags.set(nodeHasOpt, b) }
+func (n *Node) setHasVal(b bool)    { n.flags.set(nodeHasVal, b) }
+func (n *Node) setHasOpt(b bool)    { n.flags.set(nodeHasOpt, b) }
 func (n *Node) SetEmbedded(b bool)  { n.flags.set(nodeEmbedded, b) }
 
 // MarkNonNil marks a pointer n as being guaranteed non-nil,
@@ -238,8 +238,8 @@ func (n *Node) SetEmbedded(b bool)  { n.flags.set(nodeEmbedded, b) }
 // During conversion to SSA, non-nil pointers won't have nil checks
 // inserted before dereferencing. See state.exprPtr.
 func (n *Node) MarkNonNil() {
-	if !n.Type.IsPtr() && !n.Type.IsUnsafePtr() {
-		base.Fatalf("MarkNonNil(%v), type %v", n, n.Type)
+	if !n.Type().IsPtr() && !n.Type().IsUnsafePtr() {
+		base.Fatalf("MarkNonNil(%v), type %v", n, n.Type())
 	}
 	n.flags.set(nodeNonNil, true)
 }
@@ -249,7 +249,7 @@ func (n *Node) MarkNonNil() {
 // When n is a dereferencing operation, n does not need nil checks.
 // When n is a makeslice+copy operation, n does not need length and cap checks.
 func (n *Node) SetBounded(b bool) {
-	switch n.Op {
+	switch n.Op() {
 	case OINDEX, OSLICE, OSLICEARR, OSLICE3, OSLICE3ARR, OSLICESTR:
 		// No bounds checks needed.
 	case ODOTPTR, ODEREF:
@@ -265,14 +265,14 @@ func (n *Node) SetBounded(b bool) {
 
 // MarkReadonly indicates that n is an ONAME with readonly contents.
 func (n *Node) MarkReadonly() {
-	if n.Op != ONAME {
-		base.Fatalf("Node.MarkReadonly %v", n.Op)
+	if n.Op() != ONAME {
+		base.Fatalf("Node.MarkReadonly %v", n.Op())
 	}
-	n.Name.SetReadonly(true)
+	n.Name().SetReadonly(true)
 	// Mark the linksym as readonly immediately
 	// so that the SSA backend can use this information.
 	// It will be overridden later during dumpglobls.
-	n.Sym.Linksym().Type = objabi.SRODATA
+	n.Sym().Linksym().Type = objabi.SRODATA
 }
 
 // Val returns the constant.Value for the node.
@@ -280,7 +280,7 @@ func (n *Node) Val() constant.Value {
 	if !n.HasVal() {
 		return constant.MakeUnknown()
 	}
-	return *n.E.(*constant.Value)
+	return *n.e.(*constant.Value)
 }
 
 // SetVal sets the constant.Value for the node,
@@ -291,11 +291,11 @@ func (n *Node) SetVal(v constant.Value) {
 		Dump("have Opt", n)
 		base.Fatalf("have Opt")
 	}
-	if n.Op == OLITERAL {
-		AssertValidTypeForConst(n.Type, v)
+	if n.Op() == OLITERAL {
+		AssertValidTypeForConst(n.Type(), v)
 	}
-	n.SetHasVal(true)
-	n.E = &v
+	n.setHasVal(true)
+	n.e = &v
 }
 
 // Opt returns the optimizer data for the node.
@@ -303,7 +303,7 @@ func (n *Node) Opt() interface{} {
 	if !n.HasOpt() {
 		return nil
 	}
-	return n.E
+	return n.e
 }
 
 // SetOpt sets the optimizer data for the node, which must not have been used with SetVal.
@@ -311,8 +311,8 @@ func (n *Node) Opt() interface{} {
 func (n *Node) SetOpt(x interface{}) {
 	if x == nil {
 		if n.HasOpt() {
-			n.SetHasOpt(false)
-			n.E = nil
+			n.setHasOpt(false)
+			n.e = nil
 		}
 		return
 	}
@@ -321,22 +321,22 @@ func (n *Node) SetOpt(x interface{}) {
 		Dump("have Val", n)
 		base.Fatalf("have Val")
 	}
-	n.SetHasOpt(true)
-	n.E = x
+	n.setHasOpt(true)
+	n.e = x
 }
 
 func (n *Node) Iota() int64 {
-	return n.Xoffset
+	return n.Offset()
 }
 
 func (n *Node) SetIota(x int64) {
-	n.Xoffset = x
+	n.SetOffset(x)
 }
 
 // mayBeShared reports whether n may occur in multiple places in the AST.
 // Extra care must be taken when mutating such a node.
 func MayBeShared(n *Node) bool {
-	switch n.Op {
+	switch n.Op() {
 	case ONAME, OLITERAL, ONIL, OTYPE:
 		return true
 	}
@@ -345,10 +345,10 @@ func MayBeShared(n *Node) bool {
 
 // funcname returns the name (without the package) of the function n.
 func FuncName(n *Node) string {
-	if n == nil || n.Func == nil || n.Func.Nname == nil {
+	if n == nil || n.Func() == nil || n.Func().Nname == nil {
 		return "<nil>"
 	}
-	return n.Func.Nname.Sym.Name
+	return n.Func().Nname.Sym().Name
 }
 
 // pkgFuncName returns the name of the function referenced by n, with package prepended.
@@ -360,13 +360,13 @@ func PkgFuncName(n *Node) string {
 	if n == nil {
 		return "<nil>"
 	}
-	if n.Op == ONAME {
-		s = n.Sym
+	if n.Op() == ONAME {
+		s = n.Sym()
 	} else {
-		if n.Func == nil || n.Func.Nname == nil {
+		if n.Func() == nil || n.Func().Nname == nil {
 			return "<nil>"
 		}
-		s = n.Func.Nname.Sym
+		s = n.Func().Nname.Sym()
 	}
 	pkg := s.Pkg
 
@@ -1142,12 +1142,12 @@ func Inspect(n *Node, f func(*Node) bool) {
 	if n == nil || !f(n) {
 		return
 	}
-	InspectList(n.Ninit, f)
-	Inspect(n.Left, f)
-	Inspect(n.Right, f)
-	InspectList(n.List, f)
-	InspectList(n.Nbody, f)
-	InspectList(n.Rlist, f)
+	InspectList(n.Init(), f)
+	Inspect(n.Left(), f)
+	Inspect(n.Right(), f)
+	InspectList(n.List(), f)
+	InspectList(n.Body(), f)
+	InspectList(n.Rlist(), f)
 }
 
 func InspectList(l Nodes, f func(*Node) bool) {
@@ -1242,8 +1242,8 @@ func NodAt(pos src.XPos, op Op, nleft, nright *Node) *Node {
 			f Func
 		}
 		n = &x.n
-		n.Func = &x.f
-		n.Func.Decl = n
+		n.SetFunc(&x.f)
+		n.Func().Decl = n
 	case ONAME:
 		base.Fatalf("use newname instead")
 	case OLABEL, OPACK:
@@ -1252,16 +1252,16 @@ func NodAt(pos src.XPos, op Op, nleft, nright *Node) *Node {
 			m Name
 		}
 		n = &x.n
-		n.Name = &x.m
+		n.SetName(&x.m)
 	default:
 		n = new(Node)
 	}
-	n.Op = op
-	n.Left = nleft
-	n.Right = nright
-	n.Pos = pos
-	n.Xoffset = types.BADWIDTH
-	n.Orig = n
+	n.SetOp(op)
+	n.SetLeft(nleft)
+	n.SetRight(nright)
+	n.SetPos(pos)
+	n.SetOffset(types.BADWIDTH)
+	n.SetOrig(n)
 	return n
 }
 
@@ -1278,14 +1278,14 @@ func NewNameAt(pos src.XPos, s *types.Sym) *Node {
 		p Param
 	}
 	n := &x.n
-	n.Name = &x.m
-	n.Name.Param = &x.p
+	n.SetName(&x.m)
+	n.Name().Param = &x.p
 
-	n.Op = ONAME
-	n.Pos = pos
-	n.Orig = n
+	n.SetOp(ONAME)
+	n.SetPos(pos)
+	n.SetOrig(n)
 
-	n.Sym = s
+	n.SetSym(s)
 	return n
 }
 
@@ -1358,7 +1358,7 @@ func OrigSym(s *types.Sym) *types.Sym {
 			return nil
 		case 'b': // originally the blank identifier _
 			// TODO(mdempsky): Does s.Pkg matter here?
-			return BlankNode.Sym
+			return BlankNode.Sym()
 		}
 		return s
 	}
@@ -1374,48 +1374,48 @@ func OrigSym(s *types.Sym) *types.Sym {
 // SliceBounds returns n's slice bounds: low, high, and max in expr[low:high:max].
 // n must be a slice expression. max is nil if n is a simple slice expression.
 func (n *Node) SliceBounds() (low, high, max *Node) {
-	if n.List.Len() == 0 {
+	if n.List().Len() == 0 {
 		return nil, nil, nil
 	}
 
-	switch n.Op {
+	switch n.Op() {
 	case OSLICE, OSLICEARR, OSLICESTR:
-		s := n.List.Slice()
+		s := n.List().Slice()
 		return s[0], s[1], nil
 	case OSLICE3, OSLICE3ARR:
-		s := n.List.Slice()
+		s := n.List().Slice()
 		return s[0], s[1], s[2]
 	}
-	base.Fatalf("SliceBounds op %v: %v", n.Op, n)
+	base.Fatalf("SliceBounds op %v: %v", n.Op(), n)
 	return nil, nil, nil
 }
 
 // SetSliceBounds sets n's slice bounds, where n is a slice expression.
 // n must be a slice expression. If max is non-nil, n must be a full slice expression.
 func (n *Node) SetSliceBounds(low, high, max *Node) {
-	switch n.Op {
+	switch n.Op() {
 	case OSLICE, OSLICEARR, OSLICESTR:
 		if max != nil {
-			base.Fatalf("SetSliceBounds %v given three bounds", n.Op)
+			base.Fatalf("SetSliceBounds %v given three bounds", n.Op())
 		}
-		s := n.List.Slice()
+		s := n.List().Slice()
 		if s == nil {
 			if low == nil && high == nil {
 				return
 			}
-			n.List.Set2(low, high)
+			n.PtrList().Set2(low, high)
 			return
 		}
 		s[0] = low
 		s[1] = high
 		return
 	case OSLICE3, OSLICE3ARR:
-		s := n.List.Slice()
+		s := n.List().Slice()
 		if s == nil {
 			if low == nil && high == nil && max == nil {
 				return
 			}
-			n.List.Set3(low, high, max)
+			n.PtrList().Set3(low, high, max)
 			return
 		}
 		s[0] = low
@@ -1423,7 +1423,7 @@ func (n *Node) SetSliceBounds(low, high, max *Node) {
 		s[2] = max
 		return
 	}
-	base.Fatalf("SetSliceBounds op %v: %v", n.Op, n)
+	base.Fatalf("SetSliceBounds op %v: %v", n.Op(), n)
 }
 
 // IsSlice3 reports whether o is a slice3 op (OSLICE3, OSLICE3ARR).
@@ -1511,7 +1511,7 @@ func (n *Node) RawCopy() *Node {
 // Orig pointing to itself.
 func SepCopy(n *Node) *Node {
 	copy := *n
-	copy.Orig = &copy
+	copy.orig = &copy
 	return &copy
 }
 
@@ -1524,8 +1524,8 @@ func SepCopy(n *Node) *Node {
 // messages; see issues #26855, #27765).
 func Copy(n *Node) *Node {
 	copy := *n
-	if n.Orig == n {
-		copy.Orig = &copy
+	if n.Orig() == n {
+		copy.orig = &copy
 	}
 	return &copy
 }
@@ -1534,18 +1534,18 @@ func Copy(n *Node) *Node {
 func IsNil(n *Node) bool {
 	// Check n.Orig because constant propagation may produce typed nil constants,
 	// which don't exist in the Go spec.
-	return n.Orig.Op == ONIL
+	return n.Orig().Op() == ONIL
 }
 
 func IsBlank(n *Node) bool {
 	if n == nil {
 		return false
 	}
-	return n.Sym.IsBlank()
+	return n.Sym().IsBlank()
 }
 
 // IsMethod reports whether n is a method.
 // n must be a function or a method.
 func IsMethod(n *Node) bool {
-	return n.Type.Recv() != nil
+	return n.Type().Recv() != nil
 }
diff --git a/src/cmd/compile/internal/ir/val.go b/src/cmd/compile/internal/ir/val.go
index 00b5bfd1ad..6bcee7c01c 100644
--- a/src/cmd/compile/internal/ir/val.go
+++ b/src/cmd/compile/internal/ir/val.go
@@ -13,7 +13,7 @@ import (
 )
 
 func ConstType(n *Node) constant.Kind {
-	if n == nil || n.Op != OLITERAL {
+	if n == nil || n.Op() != OLITERAL {
 		return constant.Unknown
 	}
 	return n.Val().Kind()
@@ -32,7 +32,7 @@ func ConstValue(n *Node) interface{} {
 	case constant.String:
 		return constant.StringVal(v)
 	case constant.Int:
-		return Int64Val(n.Type, v)
+		return Int64Val(n.Type(), v)
 	case constant.Float:
 		return Float64Val(v)
 	case constant.Complex:
@@ -94,7 +94,7 @@ func ValidTypeForConst(t *types.Type, v constant.Value) bool {
 func NewLiteral(v constant.Value) *Node {
 	n := Nod(OLITERAL, nil, nil)
 	if k := v.Kind(); k != constant.Unknown {
-		n.Type = idealType(k)
+		n.SetType(idealType(k))
 		n.SetVal(v)
 	}
 	return n
diff --git a/src/cmd/compile/internal/ssa/nilcheck.go b/src/cmd/compile/internal/ssa/nilcheck.go
index e0ae0454ef..3c1fa600a3 100644
--- a/src/cmd/compile/internal/ssa/nilcheck.go
+++ b/src/cmd/compile/internal/ssa/nilcheck.go
@@ -236,7 +236,7 @@ func nilcheckelim2(f *Func) {
 				continue
 			}
 			if v.Type.IsMemory() || v.Type.IsTuple() && v.Type.FieldType(1).IsMemory() {
-				if v.Op == OpVarKill || v.Op == OpVarLive || (v.Op == OpVarDef && !v.Aux.(*ir.Node).Type.HasPointers()) {
+				if v.Op == OpVarKill || v.Op == OpVarLive || (v.Op == OpVarDef && !v.Aux.(*ir.Node).Type().HasPointers()) {
 					// These ops don't really change memory.
 					continue
 					// Note: OpVarDef requires that the defined variable not have pointers.
-- 
GitLab


From c26aead50c3c8226c51fb97a94852f2134b881aa Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 25 Nov 2020 00:30:58 -0500
Subject: [PATCH 0074/2400] [dev.regabi] cmd/compile: convert types.Node (a
 pointer) to types.IRNode (an interface)

The pointer hack was nice and saved a word, but it's untenable
in a world where nodes are themselves interfaces with different
underlying types. Bite the bullet and use an interface to hold the
Node when in types.Sym and types.Type.

This has the nice benefit of removing AsTypesNode entirely.
AsNode is still useful because of its nil handling.

Change-Id: I298cba9ff788b956ee287283bec78010e8b601e5
Reviewed-on: https://go-review.googlesource.com/c/go/+/272933
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/closure.go        |  4 +--
 src/cmd/compile/internal/gc/dcl.go            | 10 +++----
 src/cmd/compile/internal/gc/embed.go          |  2 +-
 src/cmd/compile/internal/gc/escape.go         |  6 ++--
 src/cmd/compile/internal/gc/export.go         |  4 +--
 src/cmd/compile/internal/gc/gen.go            |  2 +-
 src/cmd/compile/internal/gc/iimport.go        |  6 ++--
 src/cmd/compile/internal/gc/init.go           |  2 +-
 src/cmd/compile/internal/gc/noder.go          |  2 +-
 src/cmd/compile/internal/gc/obj.go            |  2 +-
 src/cmd/compile/internal/gc/reflect.go        |  6 ++--
 src/cmd/compile/internal/gc/ssa.go            |  2 +-
 src/cmd/compile/internal/gc/typecheck.go      |  8 +++---
 src/cmd/compile/internal/gc/universe.go       | 28 +++++++++----------
 src/cmd/compile/internal/ir/dump.go           |  3 --
 src/cmd/compile/internal/ir/node.go           | 10 ++++---
 src/cmd/compile/internal/types/scope.go       |  8 +++---
 src/cmd/compile/internal/types/sizeof_test.go |  4 +--
 src/cmd/compile/internal/types/sym.go         |  4 +--
 src/cmd/compile/internal/types/type.go        | 14 +++++-----
 20 files changed, 63 insertions(+), 64 deletions(-)

diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index 1b926ec17e..2dce7b7f03 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -270,7 +270,7 @@ func transformclosure(dcl *ir.Node) {
 			decls = append(decls, v)
 
 			fld := types.NewField(src.NoXPos, v.Sym(), v.Type())
-			fld.Nname = ir.AsTypesNode(v)
+			fld.Nname = v
 			params = append(params, fld)
 		}
 
@@ -511,7 +511,7 @@ func makepartialcall(dot *ir.Node, t0 *types.Type, meth *types.Sym) *ir.Node {
 	// typecheckslice() requires that Curfn is set when processing an ORETURN.
 	Curfn = dcl
 	typecheckslice(dcl.Body().Slice(), ctxStmt)
-	sym.Def = ir.AsTypesNode(dcl)
+	sym.Def = dcl
 	xtop = append(xtop, dcl)
 	Curfn = savecurfn
 	base.Pos = saveLineNo
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 8b3274890f..8980c47e2c 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -118,7 +118,7 @@ func declare(n *ir.Node, ctxt ir.Class) {
 
 	s.Block = types.Block
 	s.Lastlineno = base.Pos
-	s.Def = ir.AsTypesNode(n)
+	s.Def = n
 	n.Name().Vargen = int32(gen)
 	n.SetClass(ctxt)
 	if ctxt == ir.PFUNC {
@@ -235,7 +235,7 @@ func typenodl(pos src.XPos, t *types.Type) *ir.Node {
 	// then t->nod might be out of date, so
 	// check t->nod->type too
 	if ir.AsNode(t.Nod) == nil || ir.AsNode(t.Nod).Type() != t {
-		t.Nod = ir.AsTypesNode(ir.NodAt(pos, ir.OTYPE, nil, nil))
+		t.Nod = ir.NodAt(pos, ir.OTYPE, nil, nil)
 		ir.AsNode(t.Nod).SetType(t)
 		ir.AsNode(t.Nod).SetSym(t.Sym)
 	}
@@ -490,7 +490,7 @@ func funcarg2(f *types.Field, ctxt ir.Class) {
 		return
 	}
 	n := ir.NewNameAt(f.Pos, f.Sym)
-	f.Nname = ir.AsTypesNode(n)
+	f.Nname = n
 	n.SetType(f.Type)
 	n.SetIsDDD(f.IsDDD())
 	declare(n, ctxt)
@@ -614,7 +614,7 @@ func tofunargs(l []*ir.Node, funarg types.Funarg) *types.Type {
 		f.SetIsDDD(n.IsDDD())
 		if n.Right() != nil {
 			n.Right().SetType(f.Type)
-			f.Nname = ir.AsTypesNode(n.Right())
+			f.Nname = n.Right()
 		}
 		if f.Broke() {
 			t.SetBroke(true)
@@ -872,7 +872,7 @@ func addmethod(n *ir.Node, msym *types.Sym, t *types.Type, local, nointerface bo
 	}
 
 	f := types.NewField(base.Pos, msym, t)
-	f.Nname = ir.AsTypesNode(n.Func().Nname)
+	f.Nname = n.Func().Nname
 	f.SetNointerface(nointerface)
 
 	mt.Methods().Append(f)
diff --git a/src/cmd/compile/internal/gc/embed.go b/src/cmd/compile/internal/gc/embed.go
index d515696add..03703f68d5 100644
--- a/src/cmd/compile/internal/gc/embed.go
+++ b/src/cmd/compile/internal/gc/embed.go
@@ -114,7 +114,7 @@ func varEmbed(p *noder, names []*ir.Node, typ *ir.Node, exprs []*ir.Node, embeds
 	if dclcontext != ir.PEXTERN {
 		numLocalEmbed++
 		v = ir.NewNameAt(v.Pos(), lookupN("embed.", numLocalEmbed))
-		v.Sym().Def = ir.AsTypesNode(v)
+		v.Sym().Def = v
 		v.Name().Param.Ntype = typ
 		v.SetClass(ir.PEXTERN)
 		externdcl = append(externdcl, v)
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 866bdf8a6f..f1786e74dc 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -229,13 +229,13 @@ func (e *Escape) walkFunc(fn *ir.Node) {
 	ir.InspectList(fn.Body(), func(n *ir.Node) bool {
 		switch n.Op() {
 		case ir.OLABEL:
-			n.Sym().Label = ir.AsTypesNode(nonlooping)
+			n.Sym().Label = nonlooping
 
 		case ir.OGOTO:
 			// If we visited the label before the goto,
 			// then this is a looping label.
-			if n.Sym().Label == ir.AsTypesNode(nonlooping) {
-				n.Sym().Label = ir.AsTypesNode(looping)
+			if n.Sym().Label == nonlooping {
+				n.Sym().Label = looping
 			}
 		}
 
diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index 1f0288a591..ace461fc90 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -86,7 +86,7 @@ func importsym(ipkg *types.Pkg, s *types.Sym, op ir.Op) *ir.Node {
 		}
 
 		n = dclname(s)
-		s.SetPkgDef(ir.AsTypesNode(n))
+		s.SetPkgDef(n)
 		s.Importdef = ipkg
 	}
 	if n.Op() != ir.ONONAME && n.Op() != op {
@@ -103,7 +103,7 @@ func importtype(ipkg *types.Pkg, pos src.XPos, s *types.Sym) *types.Type {
 	if n.Op() != ir.OTYPE {
 		t := types.New(types.TFORW)
 		t.Sym = s
-		t.Nod = ir.AsTypesNode(n)
+		t.Nod = n
 
 		n.SetOp(ir.OTYPE)
 		n.SetPos(pos)
diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
index d7320f3ccc..a89ff528e5 100644
--- a/src/cmd/compile/internal/gc/gen.go
+++ b/src/cmd/compile/internal/gc/gen.go
@@ -69,7 +69,7 @@ func tempAt(pos src.XPos, curfn *ir.Node, t *types.Type) *ir.Node {
 		Pkg:  ir.LocalPkg,
 	}
 	n := ir.NewNameAt(pos, s)
-	s.Def = ir.AsTypesNode(n)
+	s.Def = n
 	n.SetType(t)
 	n.SetClass(ir.PAUTO)
 	n.SetEsc(EscNever)
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 7106356665..5d845d90e8 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -151,7 +151,7 @@ func iimport(pkg *types.Pkg, in *bio.Reader) (fingerprint goobj.FingerprintType)
 			ir.NumImport[pkgName]++
 
 			// TODO(mdempsky): This belongs somewhere else.
-			pkg.Lookup("_").Def = ir.AsTypesNode(ir.BlankNode)
+			pkg.Lookup("_").Def = ir.BlankNode
 		} else {
 			if pkg.Name != pkgName {
 				base.Fatalf("conflicting package names %v and %v for path %q", pkg.Name, pkgName, pkg.Path)
@@ -175,7 +175,7 @@ func iimport(pkg *types.Pkg, in *bio.Reader) (fingerprint goobj.FingerprintType)
 			if s.Def != nil {
 				base.Fatalf("unexpected definition for %v: %v", s, ir.AsNode(s.Def))
 			}
-			s.Def = ir.AsTypesNode(npos(src.NoXPos, dclname(s)))
+			s.Def = npos(src.NoXPos, dclname(s))
 		}
 	}
 
@@ -337,7 +337,7 @@ func (r *importReader) doDecl(n *ir.Node) {
 			// methodSym already marked m.Sym as a function.
 
 			f := types.NewField(mpos, msym, mtyp)
-			f.Nname = ir.AsTypesNode(m)
+			f.Nname = m
 			ms[i] = f
 		}
 		t.Methods().Set(ms)
diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index b66ee6f953..02a6175c6b 100644
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -93,7 +93,7 @@ func fninit(n []*ir.Node) {
 	nn := NewName(sym)
 	nn.SetType(types.Types[types.TUINT8]) // fake type
 	nn.SetClass(ir.PEXTERN)
-	sym.Def = ir.AsTypesNode(nn)
+	sym.Def = nn
 	exportsym(nn)
 	lsym := sym.Linksym()
 	ot := 0
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 98819fadde..d9642f4b67 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -373,7 +373,7 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
 	if my.Def != nil {
 		redeclare(pack.Pos(), my, "as imported package name")
 	}
-	my.Def = ir.AsTypesNode(pack)
+	my.Def = pack
 	my.Lastlineno = pack.Pos()
 	my.Block = 1 // at top level
 }
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 9f0cefbd1c..05f8358fdf 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -480,7 +480,7 @@ func slicedata(pos src.XPos, s string) *ir.Node {
 	symname := fmt.Sprintf(".gobytes.%d", slicedataGen)
 	sym := ir.LocalPkg.Lookup(symname)
 	symnode := NewName(sym)
-	sym.Def = ir.AsTypesNode(symnode)
+	sym.Def = symnode
 
 	lsym := sym.Linksym()
 	off := dstringdata(lsym, 0, s, pos, "slice")
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 4559dd3a21..664b3cc942 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -997,7 +997,7 @@ func typename(t *types.Type) *ir.Node {
 		n.SetType(types.Types[types.TUINT8])
 		n.SetClass(ir.PEXTERN)
 		n.SetTypecheck(1)
-		s.Def = ir.AsTypesNode(n)
+		s.Def = n
 	}
 
 	n := ir.Nod(ir.OADDR, ir.AsNode(s.Def), nil)
@@ -1016,7 +1016,7 @@ func itabname(t, itype *types.Type) *ir.Node {
 		n.SetType(types.Types[types.TUINT8])
 		n.SetClass(ir.PEXTERN)
 		n.SetTypecheck(1)
-		s.Def = ir.AsTypesNode(n)
+		s.Def = n
 		itabs = append(itabs, itabEntry{t: t, itype: itype, lsym: s.Linksym()})
 	}
 
@@ -1882,7 +1882,7 @@ func zeroaddr(size int64) *ir.Node {
 		x.SetType(types.Types[types.TUINT8])
 		x.SetClass(ir.PEXTERN)
 		x.SetTypecheck(1)
-		s.Def = ir.AsTypesNode(x)
+		s.Def = x
 	}
 	z := ir.Nod(ir.OADDR, ir.AsNode(s.Def), nil)
 	z.SetType(types.NewPtr(types.Types[types.TUINT8]))
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 018b94d9d8..262aa0e95c 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -7072,7 +7072,7 @@ func (e *ssafn) SplitSlot(parent *ssa.LocalSlot, suffix string, offset int64, t
 
 	s := &types.Sym{Name: node.Sym().Name + suffix, Pkg: ir.LocalPkg}
 	n := ir.NewNameAt(parent.N.Pos(), s)
-	s.Def = ir.AsTypesNode(n)
+	s.Def = n
 	ir.AsNode(s.Def).Name().SetUsed(true)
 	n.SetType(t)
 	n.SetClass(ir.PAUTO)
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 4bc7f035f5..0559dabe32 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -3486,7 +3486,7 @@ func setUnderlying(t, underlying *types.Type) {
 	*t = *underlying
 
 	// Restore unnecessarily clobbered attributes.
-	t.Nod = ir.AsTypesNode(n)
+	t.Nod = n
 	t.Sym = n.Sym()
 	if n.Name() != nil {
 		t.Vargen = n.Name().Vargen
@@ -3691,7 +3691,7 @@ func typecheckdef(n *ir.Node) {
 				// For package-level type aliases, set n.Sym.Def so we can identify
 				// it as a type alias during export. See also #31959.
 				if n.Name().Curfn == nil {
-					n.Sym().Def = ir.AsTypesNode(p.Ntype)
+					n.Sym().Def = p.Ntype
 				}
 			}
 			break
@@ -3799,7 +3799,7 @@ func markbreaklist(l ir.Nodes, implicit *ir.Node) {
 		if n.Op() == ir.OLABEL && i+1 < len(s) && n.Name().Defn == s[i+1] {
 			switch n.Name().Defn.Op() {
 			case ir.OFOR, ir.OFORUNTIL, ir.OSWITCH, ir.OTYPESW, ir.OSELECT, ir.ORANGE:
-				n.Sym().Label = ir.AsTypesNode(n.Name().Defn)
+				n.Sym().Label = n.Name().Defn
 				markbreak(n.Name().Defn, n.Name().Defn)
 				n.Sym().Label = nil
 				i++
@@ -3998,7 +3998,7 @@ func deadcodeexpr(n *ir.Node) *ir.Node {
 func setTypeNode(n *ir.Node, t *types.Type) {
 	n.SetOp(ir.OTYPE)
 	n.SetType(t)
-	n.Type().Nod = ir.AsTypesNode(n)
+	n.Type().Nod = n
 }
 
 // getIotaValue returns the current value for "iota",
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index be22b7e9db..978e53ac15 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -109,19 +109,19 @@ func lexinit() {
 			}
 			types.Types[etype] = t
 		}
-		s2.Def = ir.AsTypesNode(typenod(t))
+		s2.Def = typenod(t)
 		ir.AsNode(s2.Def).SetName(new(ir.Name))
 	}
 
 	for _, s := range &builtinFuncs {
 		s2 := ir.BuiltinPkg.Lookup(s.name)
-		s2.Def = ir.AsTypesNode(NewName(s2))
+		s2.Def = NewName(s2)
 		ir.AsNode(s2.Def).SetSubOp(s.op)
 	}
 
 	for _, s := range &unsafeFuncs {
 		s2 := unsafepkg.Lookup(s.name)
-		s2.Def = ir.AsTypesNode(NewName(s2))
+		s2.Def = NewName(s2)
 		ir.AsNode(s2.Def).SetSubOp(s.op)
 	}
 
@@ -130,38 +130,38 @@ func lexinit() {
 	types.Types[types.TANY] = types.New(types.TANY)
 
 	s := ir.BuiltinPkg.Lookup("true")
-	s.Def = ir.AsTypesNode(nodbool(true))
+	s.Def = nodbool(true)
 	ir.AsNode(s.Def).SetSym(lookup("true"))
 	ir.AsNode(s.Def).SetName(new(ir.Name))
 	ir.AsNode(s.Def).SetType(types.UntypedBool)
 
 	s = ir.BuiltinPkg.Lookup("false")
-	s.Def = ir.AsTypesNode(nodbool(false))
+	s.Def = nodbool(false)
 	ir.AsNode(s.Def).SetSym(lookup("false"))
 	ir.AsNode(s.Def).SetName(new(ir.Name))
 	ir.AsNode(s.Def).SetType(types.UntypedBool)
 
 	s = lookup("_")
 	s.Block = -100
-	s.Def = ir.AsTypesNode(NewName(s))
+	s.Def = NewName(s)
 	types.Types[types.TBLANK] = types.New(types.TBLANK)
 	ir.AsNode(s.Def).SetType(types.Types[types.TBLANK])
 	ir.BlankNode = ir.AsNode(s.Def)
 
 	s = ir.BuiltinPkg.Lookup("_")
 	s.Block = -100
-	s.Def = ir.AsTypesNode(NewName(s))
+	s.Def = NewName(s)
 	types.Types[types.TBLANK] = types.New(types.TBLANK)
 	ir.AsNode(s.Def).SetType(types.Types[types.TBLANK])
 
 	types.Types[types.TNIL] = types.New(types.TNIL)
 	s = ir.BuiltinPkg.Lookup("nil")
-	s.Def = ir.AsTypesNode(nodnil())
+	s.Def = nodnil()
 	ir.AsNode(s.Def).SetSym(s)
 	ir.AsNode(s.Def).SetName(new(ir.Name))
 
 	s = ir.BuiltinPkg.Lookup("iota")
-	s.Def = ir.AsTypesNode(ir.Nod(ir.OIOTA, nil, nil))
+	s.Def = ir.Nod(ir.OIOTA, nil, nil)
 	ir.AsNode(s.Def).SetSym(s)
 	ir.AsNode(s.Def).SetName(new(ir.Name))
 }
@@ -181,7 +181,7 @@ func typeinit() {
 	t := types.New(types.TUNSAFEPTR)
 	types.Types[types.TUNSAFEPTR] = t
 	t.Sym = unsafepkg.Lookup("Pointer")
-	t.Sym.Def = ir.AsTypesNode(typenod(t))
+	t.Sym.Def = typenod(t)
 	ir.AsNode(t.Sym.Def).SetName(new(ir.Name))
 	dowidth(types.Types[types.TUNSAFEPTR])
 
@@ -343,7 +343,7 @@ func lexinit1() {
 	types.Errortype = makeErrorInterface()
 	types.Errortype.Sym = s
 	types.Errortype.Orig = makeErrorInterface()
-	s.Def = ir.AsTypesNode(typenod(types.Errortype))
+	s.Def = typenod(types.Errortype)
 	dowidth(types.Errortype)
 
 	// We create separate byte and rune types for better error messages
@@ -358,7 +358,7 @@ func lexinit1() {
 	s = ir.BuiltinPkg.Lookup("byte")
 	types.Bytetype = types.New(types.TUINT8)
 	types.Bytetype.Sym = s
-	s.Def = ir.AsTypesNode(typenod(types.Bytetype))
+	s.Def = typenod(types.Bytetype)
 	ir.AsNode(s.Def).SetName(new(ir.Name))
 	dowidth(types.Bytetype)
 
@@ -366,7 +366,7 @@ func lexinit1() {
 	s = ir.BuiltinPkg.Lookup("rune")
 	types.Runetype = types.New(types.TINT32)
 	types.Runetype.Sym = s
-	s.Def = ir.AsTypesNode(typenod(types.Runetype))
+	s.Def = typenod(types.Runetype)
 	ir.AsNode(s.Def).SetName(new(ir.Name))
 	dowidth(types.Runetype)
 
@@ -384,7 +384,7 @@ func lexinit1() {
 		t := types.New(s.etype)
 		t.Sym = s1
 		types.Types[s.etype] = t
-		s1.Def = ir.AsTypesNode(typenod(t))
+		s1.Def = typenod(t)
 		ir.AsNode(s1.Def).SetName(new(ir.Name))
 		s1.Origpkg = ir.BuiltinPkg
 
diff --git a/src/cmd/compile/internal/ir/dump.go b/src/cmd/compile/internal/ir/dump.go
index 43d0742c73..c4ea5af3d1 100644
--- a/src/cmd/compile/internal/ir/dump.go
+++ b/src/cmd/compile/internal/ir/dump.go
@@ -150,9 +150,6 @@ func (p *dumper) dump(x reflect.Value, depth int) {
 	case src.XPos:
 		p.printf("%s", base.FmtPos(v))
 		return
-
-	case *types.Node:
-		x = reflect.ValueOf(AsNode(v))
 	}
 
 	switch x.Kind() {
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index dce1bfdbef..b42ca5b8a3 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -10,7 +10,6 @@ import (
 	"go/constant"
 	"sort"
 	"strings"
-	"unsafe"
 
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
@@ -1340,9 +1339,12 @@ type SymAndPos struct {
 	Pos src.XPos  // line of call
 }
 
-func AsNode(n *types.Node) *Node { return (*Node)(unsafe.Pointer(n)) }
-
-func AsTypesNode(n *Node) *types.Node { return (*types.Node)(unsafe.Pointer(n)) }
+func AsNode(n types.IRNode) *Node {
+	if n == nil {
+		return nil
+	}
+	return n.(*Node)
+}
 
 var BlankNode *Node
 
diff --git a/src/cmd/compile/internal/types/scope.go b/src/cmd/compile/internal/types/scope.go
index 40d3d86ef1..33a02c543d 100644
--- a/src/cmd/compile/internal/types/scope.go
+++ b/src/cmd/compile/internal/types/scope.go
@@ -15,7 +15,7 @@ var Block int32        // current block number
 // restored once the block scope ends.
 type dsym struct {
 	sym        *Sym // sym == nil indicates stack mark
-	def        *Node
+	def        IRNode
 	block      int32
 	lastlineno src.XPos // last declaration for diagnostic
 }
@@ -79,16 +79,16 @@ func IsDclstackValid() bool {
 }
 
 // PkgDef returns the definition associated with s at package scope.
-func (s *Sym) PkgDef() *Node {
+func (s *Sym) PkgDef() IRNode {
 	return *s.pkgDefPtr()
 }
 
 // SetPkgDef sets the definition associated with s at package scope.
-func (s *Sym) SetPkgDef(n *Node) {
+func (s *Sym) SetPkgDef(n IRNode) {
 	*s.pkgDefPtr() = n
 }
 
-func (s *Sym) pkgDefPtr() **Node {
+func (s *Sym) pkgDefPtr() *IRNode {
 	// Look for outermost saved declaration, which must be the
 	// package scope definition, if present.
 	for _, d := range dclstack {
diff --git a/src/cmd/compile/internal/types/sizeof_test.go b/src/cmd/compile/internal/types/sizeof_test.go
index 0cf343e8f1..2821d9a3c7 100644
--- a/src/cmd/compile/internal/types/sizeof_test.go
+++ b/src/cmd/compile/internal/types/sizeof_test.go
@@ -20,8 +20,8 @@ func TestSizeof(t *testing.T) {
 		_32bit uintptr     // size on 32bit platforms
 		_64bit uintptr     // size on 64bit platforms
 	}{
-		{Sym{}, 52, 88},
-		{Type{}, 52, 88},
+		{Sym{}, 60, 104},
+		{Type{}, 56, 96},
 		{Map{}, 20, 40},
 		{Forward{}, 20, 32},
 		{Func{}, 28, 48},
diff --git a/src/cmd/compile/internal/types/sym.go b/src/cmd/compile/internal/types/sym.go
index 07bce4d5cd..046104d0dc 100644
--- a/src/cmd/compile/internal/types/sym.go
+++ b/src/cmd/compile/internal/types/sym.go
@@ -33,12 +33,12 @@ type Sym struct {
 	Name string // object name
 
 	// saved and restored by dcopy
-	Def        *Node    // definition: ONAME OTYPE OPACK or OLITERAL
+	Def        IRNode    // definition: ONAME OTYPE OPACK or OLITERAL
 	Block      int32    // blocknumber to catch redeclaration
 	Lastlineno src.XPos // last declaration for diagnostic
 
 	flags   bitset8
-	Label   *Node // corresponding label (ephemeral)
+	Label   IRNode // corresponding label (ephemeral)
 	Origpkg *Pkg  // original package for . import
 }
 
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index b93409aac1..8499a36edc 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -10,10 +10,10 @@ import (
 	"fmt"
 )
 
-// Our own “Node” so we can refer to *gc.Node without actually
-// having a gc.Node. Necessary to break import cycles.
-// TODO(gri) try to eliminate soon
-type Node struct{ _ int }
+// IRNode represents an ir.Node, but without needing to import cmd/compile/internal/ir,
+// which would cause an import cycle. The uses in other packages must type assert
+// values of type IRNode to ir.Node or a more specific type.
+type IRNode interface{ Type() *Type }
 
 //go:generate stringer -type EType -trimprefix T
 
@@ -141,8 +141,8 @@ type Type struct {
 	methods    Fields
 	allMethods Fields
 
-	Nod  *Node // canonical OTYPE node
-	Orig *Type // original type (type literal or predefined type)
+	Nod  IRNode // canonical OTYPE node
+	Orig *Type  // original type (type literal or predefined type)
 
 	// Cache of composite types, with this type being the element type.
 	Cache struct {
@@ -360,7 +360,7 @@ type Field struct {
 
 	// For fields that represent function parameters, Nname points
 	// to the associated ONAME Node.
-	Nname *Node
+	Nname IRNode
 
 	// Offset in bytes of this field or method within its enclosing struct
 	// or interface Type.
-- 
GitLab


From 4d0d9c2c5c35377b0662f2fd0995867919552251 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 25 Nov 2020 00:37:36 -0500
Subject: [PATCH 0075/2400] [dev.regabi] cmd/compile: introduce ir.INode
 interface for *ir.Node

Define the interface for an IR node.
The next CL will shuffle the names and leave us with ir.Node being the interface.

Change-Id: Ifc40f7846d522cf99efa6b4e558bebb6db5218f9
Reviewed-on: https://go-review.googlesource.com/c/go/+/272934
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/fmt.go  |   8 +-
 src/cmd/compile/internal/ir/node.go | 126 ++++++++++++++++++++++++++--
 2 files changed, 125 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index e1e3813368..9682bae39b 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -247,7 +247,7 @@ type fmtNode struct {
 	m FmtMode
 }
 
-func (f *fmtNode) Format(s fmt.State, verb rune) { f.x.format(s, verb, f.m) }
+func (f *fmtNode) Format(s fmt.State, verb rune) { nodeFormat(f.x, s, verb, f.m) }
 
 type fmtOp struct {
 	x Op
@@ -282,7 +282,7 @@ func (n *Node) Format(s fmt.State, verb rune) {
 }
 
 func FmtNode(n *Node, s fmt.State, verb rune) {
-	n.format(s, verb, FErr)
+	nodeFormat(n, s, verb, FErr)
 }
 
 func (o Op) Format(s fmt.State, verb rune) { o.format(s, verb, FErr) }
@@ -313,6 +313,8 @@ func (m FmtMode) prepareArgs(args []interface{}) {
 			args[i] = &fmtOp{arg, m}
 		case *Node:
 			args[i] = &fmtNode{arg, m}
+		case nil:
+			args[i] = &fmtNode{nil, m} // assume this was a node interface
 		case *types.Type:
 			args[i] = &fmtType{arg, m}
 		case *types.Sym:
@@ -327,7 +329,7 @@ func (m FmtMode) prepareArgs(args []interface{}) {
 	}
 }
 
-func (n *Node) format(s fmt.State, verb rune, mode FmtMode) {
+func nodeFormat(n *Node, s fmt.State, verb rune, mode FmtMode) {
 	switch verb {
 	case 'v', 'S', 'L':
 		nconvFmt(n, s, fmtFlag(s, verb), mode)
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index b42ca5b8a3..d700c59390 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -7,6 +7,7 @@
 package ir
 
 import (
+	"fmt"
 	"go/constant"
 	"sort"
 	"strings"
@@ -18,6 +19,119 @@ import (
 	"cmd/internal/src"
 )
 
+// A Node is the abstract interface to an IR node.
+type INode interface {
+	// Formatting
+	Format(s fmt.State, verb rune)
+	String() string
+
+	// Source position.
+	Pos() src.XPos
+	SetPos(x src.XPos)
+
+	// For making copies. Mainly used by Copy and SepCopy.
+	RawCopy() *Node
+
+	// Abstract graph structure, for generic traversals.
+	Op() Op
+	SetOp(x Op)
+	Orig() *Node
+	SetOrig(x *Node)
+	SubOp() Op
+	SetSubOp(x Op)
+	Left() *Node
+	SetLeft(x *Node)
+	Right() *Node
+	SetRight(x *Node)
+	Init() Nodes
+	PtrInit() *Nodes
+	SetInit(x Nodes)
+	Body() Nodes
+	PtrBody() *Nodes
+	SetBody(x Nodes)
+	List() Nodes
+	SetList(x Nodes)
+	PtrList() *Nodes
+	Rlist() Nodes
+	SetRlist(x Nodes)
+	PtrRlist() *Nodes
+
+	// Fields specific to certain Ops only.
+	Type() *types.Type
+	SetType(t *types.Type)
+	Func() *Func
+	SetFunc(x *Func)
+	Name() *Name
+	SetName(x *Name)
+	Sym() *types.Sym
+	SetSym(x *types.Sym)
+	Offset() int64
+	SetOffset(x int64)
+	Class() Class
+	SetClass(x Class)
+	Likely() bool
+	SetLikely(x bool)
+	SliceBounds() (low, high, max *Node)
+	SetSliceBounds(low, high, max *Node)
+	Iota() int64
+	SetIota(x int64)
+	Colas() bool
+	SetColas(x bool)
+	NoInline() bool
+	SetNoInline(x bool)
+	Transient() bool
+	SetTransient(x bool)
+	Implicit() bool
+	SetImplicit(x bool)
+	IsDDD() bool
+	SetIsDDD(x bool)
+	Embedded() bool
+	SetEmbedded(x bool)
+	IndexMapLValue() bool
+	SetIndexMapLValue(x bool)
+	TChanDir() types.ChanDir
+	SetTChanDir(x types.ChanDir)
+	ResetAux()
+	HasBreak() bool
+	SetHasBreak(x bool)
+	MarkReadonly()
+	Val() constant.Value
+	HasVal() bool
+	SetVal(v constant.Value)
+	Int64Val() int64
+	Uint64Val() uint64
+	CanInt64() bool
+	BoolVal() bool
+	StringVal() string
+
+	// Storage for analysis passes.
+	Esc() uint16
+	SetEsc(x uint16)
+	Walkdef() uint8
+	SetWalkdef(x uint8)
+	Opt() interface{}
+	SetOpt(x interface{})
+	HasOpt() bool
+	Diag() bool
+	SetDiag(x bool)
+	Bounded() bool
+	SetBounded(x bool)
+	Typecheck() uint8
+	SetTypecheck(x uint8)
+	Initorder() uint8
+	SetInitorder(x uint8)
+	NonNil() bool
+	MarkNonNil()
+	HasCall() bool
+	SetHasCall(x bool)
+
+	// Only for SSA and should be removed when SSA starts
+	// using a more specific type than Node.
+	CanBeAnSSASym()
+}
+
+var _ INode = (*Node)(nil)
+
 // A Node is a single node in the syntax tree.
 // Actually the syntax tree is a syntax DAG, because there is only one
 // node with Op=ONAME for a given instance of a variable x.
@@ -1512,9 +1626,9 @@ func (n *Node) RawCopy() *Node {
 // sepcopy returns a separate shallow copy of n, with the copy's
 // Orig pointing to itself.
 func SepCopy(n *Node) *Node {
-	copy := *n
-	copy.orig = &copy
-	return &copy
+	n = n.RawCopy()
+	n.SetOrig(n)
+	return n
 }
 
 // copy returns shallow copy of n and adjusts the copy's Orig if
@@ -1525,11 +1639,11 @@ func SepCopy(n *Node) *Node {
 // (This caused the wrong complit Op to be used when printing error
 // messages; see issues #26855, #27765).
 func Copy(n *Node) *Node {
-	copy := *n
+	copy := n.RawCopy()
 	if n.Orig() == n {
-		copy.orig = &copy
+		copy.SetOrig(copy)
 	}
-	return &copy
+	return copy
 }
 
 // isNil reports whether n represents the universal untyped zero value "nil".
-- 
GitLab


From 41f3af9d04362a56c1af186af134c704a03fa97b Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 25 Nov 2020 01:11:56 -0500
Subject: [PATCH 0076/2400] [dev.regabi] cmd/compile: replace *Node type with
 an interface Node [generated]
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The plan is to introduce a Node interface that replaces the old *Node pointer-to-struct.

The previous CL defined an interface INode modeling a *Node.

This CL:
 - Changes all references outside internal/ir to use INode,
   along with many references inside internal/ir as well.
 - Renames Node to node.
 - Renames INode to Node

So now ir.Node is an interface implemented by *ir.node, which is otherwise inaccessible,
and the code outside package ir is now (clearly) using only the interface.

The usual rule is never to redefine an existing name with a new meaning,
so that old code that hasn't been updated gets a "unknown name" error
instead of more mysterious errors or silent misbehavior. That rule would
caution against replacing Node-the-struct with Node-the-interface,
as in this CL, because code that says *Node would now be using a pointer
to an interface. But this CL is being landed at the same time as another that
moves Node from gc to ir. So the net effect is to replace *gc.Node with ir.Node,
which does follow the rule: any lingering references to gc.Node will be told
it's gone, not silently start using pointers to interfaces. So the rule is followed
by the CL sequence, just not this specific CL.

Overall, the loss of inlining caused by using interfaces cuts the compiler speed
by about 6%, a not insignificant amount. However, as we convert the representation
to concrete structs that are not the giant Node over the next weeks, that speed
should come back as more of the compiler starts operating directly on concrete types
and the memory taken up by the graph of Nodes drops due to the more precise
structs. Honestly, I was expecting worse.

% benchstat bench.old bench.new
name                      old time/op       new time/op       delta
Template                        168ms ± 4%        182ms ± 2%   +8.34%  (p=0.000 n=9+9)
Unicode                        72.2ms ±10%       82.5ms ± 6%  +14.38%  (p=0.000 n=9+9)
GoTypes                         563ms ± 8%        598ms ± 2%   +6.14%  (p=0.006 n=9+9)
Compiler                        2.89s ± 4%        3.04s ± 2%   +5.37%  (p=0.000 n=10+9)
SSA                             6.45s ± 4%        7.25s ± 5%  +12.41%  (p=0.000 n=9+10)
Flate                           105ms ± 2%        115ms ± 1%   +9.66%  (p=0.000 n=10+8)
GoParser                        144ms ±10%        152ms ± 2%   +5.79%  (p=0.011 n=9+8)
Reflect                         345ms ± 9%        370ms ± 4%   +7.28%  (p=0.001 n=10+9)
Tar                             149ms ± 9%        161ms ± 5%   +8.05%  (p=0.001 n=10+9)
XML                             190ms ± 3%        209ms ± 2%   +9.54%  (p=0.000 n=9+8)
LinkCompiler                    327ms ± 2%        325ms ± 2%     ~     (p=0.382 n=8+8)
ExternalLinkCompiler            1.77s ± 4%        1.73s ± 6%     ~     (p=0.113 n=9+10)
LinkWithoutDebugCompiler        214ms ± 4%        211ms ± 2%     ~     (p=0.360 n=10+8)
StdCmd                          14.8s ± 3%        15.9s ± 1%   +6.98%  (p=0.000 n=10+9)
[Geo mean]                      480ms             510ms        +6.31%

name                      old user-time/op  new user-time/op  delta
Template                        223ms ± 3%        237ms ± 3%   +6.16%  (p=0.000 n=9+10)
Unicode                         103ms ± 6%        113ms ± 3%   +9.53%  (p=0.000 n=9+9)
GoTypes                         758ms ± 8%        800ms ± 2%   +5.55%  (p=0.003 n=10+9)
Compiler                        3.95s ± 2%        4.12s ± 2%   +4.34%  (p=0.000 n=10+9)
SSA                             9.43s ± 1%        9.74s ± 4%   +3.25%  (p=0.000 n=8+10)
Flate                           132ms ± 2%        141ms ± 2%   +6.89%  (p=0.000 n=9+9)
GoParser                        177ms ± 9%        183ms ± 4%     ~     (p=0.050 n=9+9)
Reflect                         467ms ±10%        495ms ± 7%   +6.17%  (p=0.029 n=10+10)
Tar                             183ms ± 9%        197ms ± 5%   +7.92%  (p=0.001 n=10+10)
XML                             249ms ± 5%        268ms ± 4%   +7.82%  (p=0.000 n=10+9)
LinkCompiler                    544ms ± 5%        544ms ± 6%     ~     (p=0.863 n=9+9)
ExternalLinkCompiler            1.79s ± 4%        1.75s ± 6%     ~     (p=0.075 n=10+10)
LinkWithoutDebugCompiler        248ms ± 6%        246ms ± 2%     ~     (p=0.965 n=10+8)
[Geo mean]                      483ms             504ms        +4.41%

[git-generate]
cd src/cmd/compile/internal/ir
: # We need to do the conversion in multiple steps, so we introduce
: # a temporary type alias that will start out meaning the pointer-to-struct
: # and then change to mean the interface.
rf '
	mv Node OldNode

	add node.go \
		type Node = *OldNode
'

: # It should work to do this ex in ir, but it misses test files, due to a bug in rf.
: # Run the command in gc to handle gc's tests, and then again in ssa for ssa's tests.
cd ../gc
rf '
        ex .  ../arm ../riscv64 ../arm64 ../mips64 ../ppc64 ../mips ../wasm {
                import "cmd/compile/internal/ir"
                *ir.OldNode -> ir.Node
        }
'
cd ../ssa
rf '
        ex {
                import "cmd/compile/internal/ir"
                *ir.OldNode -> ir.Node
        }
'

: # Back in ir, finish conversion clumsily with sed,
: # because type checking and circular aliases do not mix.
cd ../ir
sed -i '' '
	/type Node = \*OldNode/d
	s/\*OldNode/Node/g
	s/^func (n Node)/func (n *OldNode)/
	s/OldNode/node/g
	s/type INode interface/type Node interface/
	s/var _ INode = (Node)(nil)/var _ Node = (*node)(nil)/
' *.go
gofmt -w *.go

sed -i '' '
	s/{Func{}, 136, 248}/{Func{}, 152, 280}/
	s/{Name{}, 32, 56}/{Name{}, 44, 80}/
	s/{Param{}, 24, 48}/{Param{}, 44, 88}/
	s/{node{}, 76, 128}/{node{}, 88, 152}/
' sizeof_test.go

cd ../ssa
sed -i '' '
	s/{LocalSlot{}, 28, 40}/{LocalSlot{}, 32, 48}/
' sizeof_test.go

cd ../gc
sed -i '' 's/\*ir.Node/ir.Node/' mkbuiltin.go

cd ../../../..
go install std cmd
cd cmd/compile
go test -u || go test -u

Change-Id: I196bbe3b648e4701662e4a2bada40bf155e2a553
Reviewed-on: https://go-review.googlesource.com/c/go/+/272935
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/fmtmap_test.go              |  23 +-
 src/cmd/compile/internal/arm/ssa.go         |   2 +-
 src/cmd/compile/internal/arm64/ssa.go       |   2 +-
 src/cmd/compile/internal/gc/alg.go          |  46 +--
 src/cmd/compile/internal/gc/bexport.go      |   2 +-
 src/cmd/compile/internal/gc/bimport.go      |   4 +-
 src/cmd/compile/internal/gc/builtin.go      | 182 +++++-----
 src/cmd/compile/internal/gc/closure.go      |  40 +--
 src/cmd/compile/internal/gc/const.go        |  30 +-
 src/cmd/compile/internal/gc/dcl.go          |  90 ++---
 src/cmd/compile/internal/gc/embed.go        |  10 +-
 src/cmd/compile/internal/gc/escape.go       |  84 ++---
 src/cmd/compile/internal/gc/export.go       |  10 +-
 src/cmd/compile/internal/gc/gen.go          |   8 +-
 src/cmd/compile/internal/gc/go.go           |  12 +-
 src/cmd/compile/internal/gc/gsubr.go        |   8 +-
 src/cmd/compile/internal/gc/iexport.go      |  38 +-
 src/cmd/compile/internal/gc/iimport.go      |  44 +--
 src/cmd/compile/internal/gc/init.go         |   2 +-
 src/cmd/compile/internal/gc/initorder.go    |  38 +-
 src/cmd/compile/internal/gc/inl.go          |  96 +++---
 src/cmd/compile/internal/gc/main.go         |   4 +-
 src/cmd/compile/internal/gc/mkbuiltin.go    |   2 +-
 src/cmd/compile/internal/gc/noder.go        | 126 +++----
 src/cmd/compile/internal/gc/obj.go          |  16 +-
 src/cmd/compile/internal/gc/order.go        |  74 ++--
 src/cmd/compile/internal/gc/pgen.go         |  56 +--
 src/cmd/compile/internal/gc/pgen_test.go    |  14 +-
 src/cmd/compile/internal/gc/phi.go          |  34 +-
 src/cmd/compile/internal/gc/plive.go        |  28 +-
 src/cmd/compile/internal/gc/racewalk.go     |   2 +-
 src/cmd/compile/internal/gc/range.go        |  36 +-
 src/cmd/compile/internal/gc/reflect.go      |  14 +-
 src/cmd/compile/internal/gc/scc.go          |  14 +-
 src/cmd/compile/internal/gc/scope.go        |   2 +-
 src/cmd/compile/internal/gc/select.go       |  30 +-
 src/cmd/compile/internal/gc/sinit.go        |  78 ++---
 src/cmd/compile/internal/gc/ssa.go          | 326 +++++++++---------
 src/cmd/compile/internal/gc/subr.go         |  74 ++--
 src/cmd/compile/internal/gc/swt.go          |  62 ++--
 src/cmd/compile/internal/gc/typecheck.go    | 118 +++----
 src/cmd/compile/internal/gc/unsafe.go       |   2 +-
 src/cmd/compile/internal/gc/walk.go         | 202 +++++------
 src/cmd/compile/internal/ir/dump.go         |   2 +-
 src/cmd/compile/internal/ir/fmt.go          |  32 +-
 src/cmd/compile/internal/ir/node.go         | 364 ++++++++++----------
 src/cmd/compile/internal/ir/sizeof_test.go  |   8 +-
 src/cmd/compile/internal/ir/val.go          |   6 +-
 src/cmd/compile/internal/mips/ssa.go        |   2 +-
 src/cmd/compile/internal/mips64/ssa.go      |   2 +-
 src/cmd/compile/internal/ppc64/ssa.go       |   2 +-
 src/cmd/compile/internal/riscv64/ssa.go     |   2 +-
 src/cmd/compile/internal/ssa/config.go      |   2 +-
 src/cmd/compile/internal/ssa/deadstore.go   |  20 +-
 src/cmd/compile/internal/ssa/debug.go       |  12 +-
 src/cmd/compile/internal/ssa/export_test.go |   2 +-
 src/cmd/compile/internal/ssa/location.go    |   2 +-
 src/cmd/compile/internal/ssa/nilcheck.go    |   2 +-
 src/cmd/compile/internal/ssa/regalloc.go    |   2 +-
 src/cmd/compile/internal/ssa/sizeof_test.go |   2 +-
 src/cmd/compile/internal/ssa/stackalloc.go  |   2 +-
 src/cmd/compile/internal/wasm/ssa.go        |   2 +-
 62 files changed, 1277 insertions(+), 1276 deletions(-)

diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
index 432d26a7b8..7a375604fd 100644
--- a/src/cmd/compile/fmtmap_test.go
+++ b/src/cmd/compile/fmtmap_test.go
@@ -22,14 +22,7 @@ package main_test
 var knownFormats = map[string]string{
 	"*bytes.Buffer %s":                                "",
 	"*cmd/compile/internal/gc.EscLocation %v":         "",
-	"*cmd/compile/internal/ir.Node %#v":               "",
-	"*cmd/compile/internal/ir.Node %+S":               "",
-	"*cmd/compile/internal/ir.Node %+v":               "",
-	"*cmd/compile/internal/ir.Node %L":                "",
-	"*cmd/compile/internal/ir.Node %S":                "",
-	"*cmd/compile/internal/ir.Node %j":                "",
-	"*cmd/compile/internal/ir.Node %p":                "",
-	"*cmd/compile/internal/ir.Node %v":                "",
+	"*cmd/compile/internal/ir.node %v":                "",
 	"*cmd/compile/internal/ssa.Block %s":              "",
 	"*cmd/compile/internal/ssa.Block %v":              "",
 	"*cmd/compile/internal/ssa.Func %s":               "",
@@ -83,6 +76,14 @@ var knownFormats = map[string]string{
 	"cmd/compile/internal/ir.Class %d":                "",
 	"cmd/compile/internal/ir.Class %v":                "",
 	"cmd/compile/internal/ir.FmtMode %d":              "",
+	"cmd/compile/internal/ir.Node %#v":                "",
+	"cmd/compile/internal/ir.Node %+S":                "",
+	"cmd/compile/internal/ir.Node %+v":                "",
+	"cmd/compile/internal/ir.Node %L":                 "",
+	"cmd/compile/internal/ir.Node %S":                 "",
+	"cmd/compile/internal/ir.Node %j":                 "",
+	"cmd/compile/internal/ir.Node %p":                 "",
+	"cmd/compile/internal/ir.Node %v":                 "",
 	"cmd/compile/internal/ir.Nodes %#v":               "",
 	"cmd/compile/internal/ir.Nodes %+v":               "",
 	"cmd/compile/internal/ir.Nodes %.v":               "",
@@ -160,9 +161,9 @@ var knownFormats = map[string]string{
 	"interface{} %q":                                  "",
 	"interface{} %s":                                  "",
 	"interface{} %v":                                  "",
-	"map[*cmd/compile/internal/ir.Node]*cmd/compile/internal/ssa.Value %v": "",
-	"map[*cmd/compile/internal/ir.Node][]*cmd/compile/internal/ir.Node %v": "",
-	"map[cmd/compile/internal/ssa.ID]uint32 %v":                            "",
+	"map[cmd/compile/internal/ir.Node]*cmd/compile/internal/ssa.Value %v": "",
+	"map[cmd/compile/internal/ir.Node][]cmd/compile/internal/ir.Node %v":  "",
+	"map[cmd/compile/internal/ssa.ID]uint32 %v":                           "",
 	"map[int64]uint32 %v":  "",
 	"math/big.Accuracy %s": "",
 	"reflect.Type %s":      "",
diff --git a/src/cmd/compile/internal/arm/ssa.go b/src/cmd/compile/internal/arm/ssa.go
index ff1dd8869e..b34e2973b2 100644
--- a/src/cmd/compile/internal/arm/ssa.go
+++ b/src/cmd/compile/internal/arm/ssa.go
@@ -546,7 +546,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		case *obj.LSym:
 			wantreg = "SB"
 			gc.AddAux(&p.From, v)
-		case *ir.Node:
+		case ir.Node:
 			wantreg = "SP"
 			gc.AddAux(&p.From, v)
 		case nil:
diff --git a/src/cmd/compile/internal/arm64/ssa.go b/src/cmd/compile/internal/arm64/ssa.go
index 58c00dc3bd..d5bd9687cf 100644
--- a/src/cmd/compile/internal/arm64/ssa.go
+++ b/src/cmd/compile/internal/arm64/ssa.go
@@ -396,7 +396,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		case *obj.LSym:
 			wantreg = "SB"
 			gc.AddAux(&p.From, v)
-		case *ir.Node:
+		case ir.Node:
 			wantreg = "SP"
 			gc.AddAux(&p.From, v)
 		case nil:
diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index ffd1682b35..d2762126ad 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -404,7 +404,7 @@ func genhash(t *types.Type) *obj.LSym {
 	return closure
 }
 
-func hashfor(t *types.Type) *ir.Node {
+func hashfor(t *types.Type) ir.Node {
 	var sym *types.Sym
 
 	switch a, _ := algtype1(t); a {
@@ -432,10 +432,10 @@ func hashfor(t *types.Type) *ir.Node {
 
 	n := NewName(sym)
 	setNodeNameFunc(n)
-	n.SetType(functype(nil, []*ir.Node{
+	n.SetType(functype(nil, []ir.Node{
 		anonfield(types.NewPtr(t)),
 		anonfield(types.Types[types.TUINTPTR]),
-	}, []*ir.Node{
+	}, []ir.Node{
 		anonfield(types.Types[types.TUINTPTR]),
 	}))
 	return n
@@ -567,9 +567,9 @@ func geneq(t *types.Type) *obj.LSym {
 		//
 		// TODO(josharian): consider doing some loop unrolling
 		// for larger nelem as well, processing a few elements at a time in a loop.
-		checkAll := func(unroll int64, last bool, eq func(pi, qi *ir.Node) *ir.Node) {
+		checkAll := func(unroll int64, last bool, eq func(pi, qi ir.Node) ir.Node) {
 			// checkIdx generates a node to check for equality at index i.
-			checkIdx := func(i *ir.Node) *ir.Node {
+			checkIdx := func(i ir.Node) ir.Node {
 				// pi := p[i]
 				pi := ir.Nod(ir.OINDEX, np, i)
 				pi.SetBounded(true)
@@ -621,24 +621,24 @@ func geneq(t *types.Type) *obj.LSym {
 			// Do two loops. First, check that all the lengths match (cheap).
 			// Second, check that all the contents match (expensive).
 			// TODO: when the array size is small, unroll the length match checks.
-			checkAll(3, false, func(pi, qi *ir.Node) *ir.Node {
+			checkAll(3, false, func(pi, qi ir.Node) ir.Node {
 				// Compare lengths.
 				eqlen, _ := eqstring(pi, qi)
 				return eqlen
 			})
-			checkAll(1, true, func(pi, qi *ir.Node) *ir.Node {
+			checkAll(1, true, func(pi, qi ir.Node) ir.Node {
 				// Compare contents.
 				_, eqmem := eqstring(pi, qi)
 				return eqmem
 			})
 		case types.TFLOAT32, types.TFLOAT64:
-			checkAll(2, true, func(pi, qi *ir.Node) *ir.Node {
+			checkAll(2, true, func(pi, qi ir.Node) ir.Node {
 				// p[i] == q[i]
 				return ir.Nod(ir.OEQ, pi, qi)
 			})
 		// TODO: pick apart structs, do them piecemeal too
 		default:
-			checkAll(1, true, func(pi, qi *ir.Node) *ir.Node {
+			checkAll(1, true, func(pi, qi ir.Node) ir.Node {
 				// p[i] == q[i]
 				return ir.Nod(ir.OEQ, pi, qi)
 			})
@@ -648,9 +648,9 @@ func geneq(t *types.Type) *obj.LSym {
 		// Build a list of conditions to satisfy.
 		// The conditions are a list-of-lists. Conditions are reorderable
 		// within each inner list. The outer lists must be evaluated in order.
-		var conds [][]*ir.Node
-		conds = append(conds, []*ir.Node{})
-		and := func(n *ir.Node) {
+		var conds [][]ir.Node
+		conds = append(conds, []ir.Node{})
+		and := func(n ir.Node) {
 			i := len(conds) - 1
 			conds[i] = append(conds[i], n)
 		}
@@ -670,7 +670,7 @@ func geneq(t *types.Type) *obj.LSym {
 			if !IsRegularMemory(f.Type) {
 				if EqCanPanic(f.Type) {
 					// Enforce ordering by starting a new set of reorderable conditions.
-					conds = append(conds, []*ir.Node{})
+					conds = append(conds, []ir.Node{})
 				}
 				p := nodSym(ir.OXDOT, np, f.Sym)
 				q := nodSym(ir.OXDOT, nq, f.Sym)
@@ -684,7 +684,7 @@ func geneq(t *types.Type) *obj.LSym {
 				}
 				if EqCanPanic(f.Type) {
 					// Also enforce ordering after something that can panic.
-					conds = append(conds, []*ir.Node{})
+					conds = append(conds, []ir.Node{})
 				}
 				i++
 				continue
@@ -709,9 +709,9 @@ func geneq(t *types.Type) *obj.LSym {
 
 		// Sort conditions to put runtime calls last.
 		// Preserve the rest of the ordering.
-		var flatConds []*ir.Node
+		var flatConds []ir.Node
 		for _, c := range conds {
-			isCall := func(n *ir.Node) bool {
+			isCall := func(n ir.Node) bool {
 				return n.Op() == ir.OCALL || n.Op() == ir.OCALLFUNC
 			}
 			sort.SliceStable(c, func(i, j int) bool {
@@ -785,7 +785,7 @@ func geneq(t *types.Type) *obj.LSym {
 	return closure
 }
 
-func hasCall(n *ir.Node) bool {
+func hasCall(n ir.Node) bool {
 	if n.Op() == ir.OCALL || n.Op() == ir.OCALLFUNC {
 		return true
 	}
@@ -820,7 +820,7 @@ func hasCall(n *ir.Node) bool {
 
 // eqfield returns the node
 // 	p.field == q.field
-func eqfield(p *ir.Node, q *ir.Node, field *types.Sym) *ir.Node {
+func eqfield(p ir.Node, q ir.Node, field *types.Sym) ir.Node {
 	nx := nodSym(ir.OXDOT, p, field)
 	ny := nodSym(ir.OXDOT, q, field)
 	ne := ir.Nod(ir.OEQ, nx, ny)
@@ -833,7 +833,7 @@ func eqfield(p *ir.Node, q *ir.Node, field *types.Sym) *ir.Node {
 //   memequal(s.ptr, t.ptr, len(s))
 // which can be used to construct string equality comparison.
 // eqlen must be evaluated before eqmem, and shortcircuiting is required.
-func eqstring(s, t *ir.Node) (eqlen, eqmem *ir.Node) {
+func eqstring(s, t ir.Node) (eqlen, eqmem ir.Node) {
 	s = conv(s, types.Types[types.TSTRING])
 	t = conv(t, types.Types[types.TSTRING])
 	sptr := ir.Nod(ir.OSPTR, s, nil)
@@ -859,13 +859,13 @@ func eqstring(s, t *ir.Node) (eqlen, eqmem *ir.Node) {
 //   ifaceeq(s.tab, s.data, t.data) (or efaceeq(s.typ, s.data, t.data), as appropriate)
 // which can be used to construct interface equality comparison.
 // eqtab must be evaluated before eqdata, and shortcircuiting is required.
-func eqinterface(s, t *ir.Node) (eqtab, eqdata *ir.Node) {
+func eqinterface(s, t ir.Node) (eqtab, eqdata ir.Node) {
 	if !types.Identical(s.Type(), t.Type()) {
 		base.Fatalf("eqinterface %v %v", s.Type(), t.Type())
 	}
 	// func ifaceeq(tab *uintptr, x, y unsafe.Pointer) (ret bool)
 	// func efaceeq(typ *uintptr, x, y unsafe.Pointer) (ret bool)
-	var fn *ir.Node
+	var fn ir.Node
 	if s.Type().IsEmptyInterface() {
 		fn = syslook("efaceeq")
 	} else {
@@ -893,7 +893,7 @@ func eqinterface(s, t *ir.Node) (eqtab, eqdata *ir.Node) {
 
 // eqmem returns the node
 // 	memequal(&p.field, &q.field [, size])
-func eqmem(p *ir.Node, q *ir.Node, field *types.Sym, size int64) *ir.Node {
+func eqmem(p ir.Node, q ir.Node, field *types.Sym, size int64) ir.Node {
 	nx := ir.Nod(ir.OADDR, nodSym(ir.OXDOT, p, field), nil)
 	ny := ir.Nod(ir.OADDR, nodSym(ir.OXDOT, q, field), nil)
 	nx = typecheck(nx, ctxExpr)
@@ -910,7 +910,7 @@ func eqmem(p *ir.Node, q *ir.Node, field *types.Sym, size int64) *ir.Node {
 	return call
 }
 
-func eqmemfunc(size int64, t *types.Type) (fn *ir.Node, needsize bool) {
+func eqmemfunc(size int64, t *types.Type) (fn ir.Node, needsize bool) {
 	switch size {
 	default:
 		fn = syslook("memequal")
diff --git a/src/cmd/compile/internal/gc/bexport.go b/src/cmd/compile/internal/gc/bexport.go
index e36903cbe0..a470b842ff 100644
--- a/src/cmd/compile/internal/gc/bexport.go
+++ b/src/cmd/compile/internal/gc/bexport.go
@@ -14,7 +14,7 @@ type exporter struct {
 }
 
 // markObject visits a reachable object.
-func (p *exporter) markObject(n *ir.Node) {
+func (p *exporter) markObject(n ir.Node) {
 	if n.Op() == ir.ONAME && n.Class() == ir.PFUNC {
 		inlFlood(n)
 	}
diff --git a/src/cmd/compile/internal/gc/bimport.go b/src/cmd/compile/internal/gc/bimport.go
index 603710d6b1..c0c18e728e 100644
--- a/src/cmd/compile/internal/gc/bimport.go
+++ b/src/cmd/compile/internal/gc/bimport.go
@@ -9,11 +9,11 @@ import (
 	"cmd/internal/src"
 )
 
-func npos(pos src.XPos, n *ir.Node) *ir.Node {
+func npos(pos src.XPos, n ir.Node) ir.Node {
 	n.SetPos(pos)
 	return n
 }
 
-func builtinCall(op ir.Op) *ir.Node {
+func builtinCall(op ir.Op) ir.Node {
 	return ir.Nod(ir.OCALL, mkname(ir.BuiltinPkg.Lookup(ir.OpNames[op])), nil)
 }
diff --git a/src/cmd/compile/internal/gc/builtin.go b/src/cmd/compile/internal/gc/builtin.go
index 5016905f22..a57c611559 100644
--- a/src/cmd/compile/internal/gc/builtin.go
+++ b/src/cmd/compile/internal/gc/builtin.go
@@ -210,132 +210,132 @@ func runtimeTypes() []*types.Type {
 	typs[1] = types.NewPtr(typs[0])
 	typs[2] = types.Types[types.TANY]
 	typs[3] = types.NewPtr(typs[2])
-	typs[4] = functype(nil, []*ir.Node{anonfield(typs[1])}, []*ir.Node{anonfield(typs[3])})
+	typs[4] = functype(nil, []ir.Node{anonfield(typs[1])}, []ir.Node{anonfield(typs[3])})
 	typs[5] = types.Types[types.TUINTPTR]
 	typs[6] = types.Types[types.TBOOL]
 	typs[7] = types.Types[types.TUNSAFEPTR]
-	typs[8] = functype(nil, []*ir.Node{anonfield(typs[5]), anonfield(typs[1]), anonfield(typs[6])}, []*ir.Node{anonfield(typs[7])})
+	typs[8] = functype(nil, []ir.Node{anonfield(typs[5]), anonfield(typs[1]), anonfield(typs[6])}, []ir.Node{anonfield(typs[7])})
 	typs[9] = functype(nil, nil, nil)
 	typs[10] = types.Types[types.TINTER]
-	typs[11] = functype(nil, []*ir.Node{anonfield(typs[10])}, nil)
+	typs[11] = functype(nil, []ir.Node{anonfield(typs[10])}, nil)
 	typs[12] = types.Types[types.TINT32]
 	typs[13] = types.NewPtr(typs[12])
-	typs[14] = functype(nil, []*ir.Node{anonfield(typs[13])}, []*ir.Node{anonfield(typs[10])})
+	typs[14] = functype(nil, []ir.Node{anonfield(typs[13])}, []ir.Node{anonfield(typs[10])})
 	typs[15] = types.Types[types.TINT]
-	typs[16] = functype(nil, []*ir.Node{anonfield(typs[15]), anonfield(typs[15])}, nil)
+	typs[16] = functype(nil, []ir.Node{anonfield(typs[15]), anonfield(typs[15])}, nil)
 	typs[17] = types.Types[types.TUINT]
-	typs[18] = functype(nil, []*ir.Node{anonfield(typs[17]), anonfield(typs[15])}, nil)
-	typs[19] = functype(nil, []*ir.Node{anonfield(typs[6])}, nil)
+	typs[18] = functype(nil, []ir.Node{anonfield(typs[17]), anonfield(typs[15])}, nil)
+	typs[19] = functype(nil, []ir.Node{anonfield(typs[6])}, nil)
 	typs[20] = types.Types[types.TFLOAT64]
-	typs[21] = functype(nil, []*ir.Node{anonfield(typs[20])}, nil)
+	typs[21] = functype(nil, []ir.Node{anonfield(typs[20])}, nil)
 	typs[22] = types.Types[types.TINT64]
-	typs[23] = functype(nil, []*ir.Node{anonfield(typs[22])}, nil)
+	typs[23] = functype(nil, []ir.Node{anonfield(typs[22])}, nil)
 	typs[24] = types.Types[types.TUINT64]
-	typs[25] = functype(nil, []*ir.Node{anonfield(typs[24])}, nil)
+	typs[25] = functype(nil, []ir.Node{anonfield(typs[24])}, nil)
 	typs[26] = types.Types[types.TCOMPLEX128]
-	typs[27] = functype(nil, []*ir.Node{anonfield(typs[26])}, nil)
+	typs[27] = functype(nil, []ir.Node{anonfield(typs[26])}, nil)
 	typs[28] = types.Types[types.TSTRING]
-	typs[29] = functype(nil, []*ir.Node{anonfield(typs[28])}, nil)
-	typs[30] = functype(nil, []*ir.Node{anonfield(typs[2])}, nil)
-	typs[31] = functype(nil, []*ir.Node{anonfield(typs[5])}, nil)
+	typs[29] = functype(nil, []ir.Node{anonfield(typs[28])}, nil)
+	typs[30] = functype(nil, []ir.Node{anonfield(typs[2])}, nil)
+	typs[31] = functype(nil, []ir.Node{anonfield(typs[5])}, nil)
 	typs[32] = types.NewArray(typs[0], 32)
 	typs[33] = types.NewPtr(typs[32])
-	typs[34] = functype(nil, []*ir.Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28])}, []*ir.Node{anonfield(typs[28])})
-	typs[35] = functype(nil, []*ir.Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []*ir.Node{anonfield(typs[28])})
-	typs[36] = functype(nil, []*ir.Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []*ir.Node{anonfield(typs[28])})
-	typs[37] = functype(nil, []*ir.Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []*ir.Node{anonfield(typs[28])})
+	typs[34] = functype(nil, []ir.Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28])}, []ir.Node{anonfield(typs[28])})
+	typs[35] = functype(nil, []ir.Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []ir.Node{anonfield(typs[28])})
+	typs[36] = functype(nil, []ir.Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []ir.Node{anonfield(typs[28])})
+	typs[37] = functype(nil, []ir.Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []ir.Node{anonfield(typs[28])})
 	typs[38] = types.NewSlice(typs[28])
-	typs[39] = functype(nil, []*ir.Node{anonfield(typs[33]), anonfield(typs[38])}, []*ir.Node{anonfield(typs[28])})
-	typs[40] = functype(nil, []*ir.Node{anonfield(typs[28]), anonfield(typs[28])}, []*ir.Node{anonfield(typs[15])})
+	typs[39] = functype(nil, []ir.Node{anonfield(typs[33]), anonfield(typs[38])}, []ir.Node{anonfield(typs[28])})
+	typs[40] = functype(nil, []ir.Node{anonfield(typs[28]), anonfield(typs[28])}, []ir.Node{anonfield(typs[15])})
 	typs[41] = types.NewArray(typs[0], 4)
 	typs[42] = types.NewPtr(typs[41])
-	typs[43] = functype(nil, []*ir.Node{anonfield(typs[42]), anonfield(typs[22])}, []*ir.Node{anonfield(typs[28])})
-	typs[44] = functype(nil, []*ir.Node{anonfield(typs[33]), anonfield(typs[1]), anonfield(typs[15])}, []*ir.Node{anonfield(typs[28])})
-	typs[45] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[15])}, []*ir.Node{anonfield(typs[28])})
+	typs[43] = functype(nil, []ir.Node{anonfield(typs[42]), anonfield(typs[22])}, []ir.Node{anonfield(typs[28])})
+	typs[44] = functype(nil, []ir.Node{anonfield(typs[33]), anonfield(typs[1]), anonfield(typs[15])}, []ir.Node{anonfield(typs[28])})
+	typs[45] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[15])}, []ir.Node{anonfield(typs[28])})
 	typs[46] = types.Runetype
 	typs[47] = types.NewSlice(typs[46])
-	typs[48] = functype(nil, []*ir.Node{anonfield(typs[33]), anonfield(typs[47])}, []*ir.Node{anonfield(typs[28])})
+	typs[48] = functype(nil, []ir.Node{anonfield(typs[33]), anonfield(typs[47])}, []ir.Node{anonfield(typs[28])})
 	typs[49] = types.NewSlice(typs[0])
-	typs[50] = functype(nil, []*ir.Node{anonfield(typs[33]), anonfield(typs[28])}, []*ir.Node{anonfield(typs[49])})
+	typs[50] = functype(nil, []ir.Node{anonfield(typs[33]), anonfield(typs[28])}, []ir.Node{anonfield(typs[49])})
 	typs[51] = types.NewArray(typs[46], 32)
 	typs[52] = types.NewPtr(typs[51])
-	typs[53] = functype(nil, []*ir.Node{anonfield(typs[52]), anonfield(typs[28])}, []*ir.Node{anonfield(typs[47])})
-	typs[54] = functype(nil, []*ir.Node{anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[5])}, []*ir.Node{anonfield(typs[15])})
-	typs[55] = functype(nil, []*ir.Node{anonfield(typs[28]), anonfield(typs[15])}, []*ir.Node{anonfield(typs[46]), anonfield(typs[15])})
-	typs[56] = functype(nil, []*ir.Node{anonfield(typs[28])}, []*ir.Node{anonfield(typs[15])})
-	typs[57] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[2])}, []*ir.Node{anonfield(typs[2])})
-	typs[58] = functype(nil, []*ir.Node{anonfield(typs[2])}, []*ir.Node{anonfield(typs[7])})
-	typs[59] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[3])}, []*ir.Node{anonfield(typs[2])})
-	typs[60] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[2])}, []*ir.Node{anonfield(typs[2]), anonfield(typs[6])})
-	typs[61] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[1]), anonfield(typs[1])}, nil)
-	typs[62] = functype(nil, []*ir.Node{anonfield(typs[1])}, nil)
+	typs[53] = functype(nil, []ir.Node{anonfield(typs[52]), anonfield(typs[28])}, []ir.Node{anonfield(typs[47])})
+	typs[54] = functype(nil, []ir.Node{anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[5])}, []ir.Node{anonfield(typs[15])})
+	typs[55] = functype(nil, []ir.Node{anonfield(typs[28]), anonfield(typs[15])}, []ir.Node{anonfield(typs[46]), anonfield(typs[15])})
+	typs[56] = functype(nil, []ir.Node{anonfield(typs[28])}, []ir.Node{anonfield(typs[15])})
+	typs[57] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[2])}, []ir.Node{anonfield(typs[2])})
+	typs[58] = functype(nil, []ir.Node{anonfield(typs[2])}, []ir.Node{anonfield(typs[7])})
+	typs[59] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[3])}, []ir.Node{anonfield(typs[2])})
+	typs[60] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[2])}, []ir.Node{anonfield(typs[2]), anonfield(typs[6])})
+	typs[61] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[1]), anonfield(typs[1])}, nil)
+	typs[62] = functype(nil, []ir.Node{anonfield(typs[1])}, nil)
 	typs[63] = types.NewPtr(typs[5])
-	typs[64] = functype(nil, []*ir.Node{anonfield(typs[63]), anonfield(typs[7]), anonfield(typs[7])}, []*ir.Node{anonfield(typs[6])})
+	typs[64] = functype(nil, []ir.Node{anonfield(typs[63]), anonfield(typs[7]), anonfield(typs[7])}, []ir.Node{anonfield(typs[6])})
 	typs[65] = types.Types[types.TUINT32]
-	typs[66] = functype(nil, nil, []*ir.Node{anonfield(typs[65])})
+	typs[66] = functype(nil, nil, []ir.Node{anonfield(typs[65])})
 	typs[67] = types.NewMap(typs[2], typs[2])
-	typs[68] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[22]), anonfield(typs[3])}, []*ir.Node{anonfield(typs[67])})
-	typs[69] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[3])}, []*ir.Node{anonfield(typs[67])})
-	typs[70] = functype(nil, nil, []*ir.Node{anonfield(typs[67])})
-	typs[71] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, []*ir.Node{anonfield(typs[3])})
-	typs[72] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, []*ir.Node{anonfield(typs[3])})
-	typs[73] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3]), anonfield(typs[1])}, []*ir.Node{anonfield(typs[3])})
-	typs[74] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, []*ir.Node{anonfield(typs[3]), anonfield(typs[6])})
-	typs[75] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, []*ir.Node{anonfield(typs[3]), anonfield(typs[6])})
-	typs[76] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3]), anonfield(typs[1])}, []*ir.Node{anonfield(typs[3]), anonfield(typs[6])})
-	typs[77] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, nil)
-	typs[78] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, nil)
-	typs[79] = functype(nil, []*ir.Node{anonfield(typs[3])}, nil)
-	typs[80] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[67])}, nil)
+	typs[68] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[22]), anonfield(typs[3])}, []ir.Node{anonfield(typs[67])})
+	typs[69] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[3])}, []ir.Node{anonfield(typs[67])})
+	typs[70] = functype(nil, nil, []ir.Node{anonfield(typs[67])})
+	typs[71] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, []ir.Node{anonfield(typs[3])})
+	typs[72] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, []ir.Node{anonfield(typs[3])})
+	typs[73] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3]), anonfield(typs[1])}, []ir.Node{anonfield(typs[3])})
+	typs[74] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, []ir.Node{anonfield(typs[3]), anonfield(typs[6])})
+	typs[75] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, []ir.Node{anonfield(typs[3]), anonfield(typs[6])})
+	typs[76] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3]), anonfield(typs[1])}, []ir.Node{anonfield(typs[3]), anonfield(typs[6])})
+	typs[77] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, nil)
+	typs[78] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, nil)
+	typs[79] = functype(nil, []ir.Node{anonfield(typs[3])}, nil)
+	typs[80] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[67])}, nil)
 	typs[81] = types.NewChan(typs[2], types.Cboth)
-	typs[82] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[22])}, []*ir.Node{anonfield(typs[81])})
-	typs[83] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[15])}, []*ir.Node{anonfield(typs[81])})
+	typs[82] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[22])}, []ir.Node{anonfield(typs[81])})
+	typs[83] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[15])}, []ir.Node{anonfield(typs[81])})
 	typs[84] = types.NewChan(typs[2], types.Crecv)
-	typs[85] = functype(nil, []*ir.Node{anonfield(typs[84]), anonfield(typs[3])}, nil)
-	typs[86] = functype(nil, []*ir.Node{anonfield(typs[84]), anonfield(typs[3])}, []*ir.Node{anonfield(typs[6])})
+	typs[85] = functype(nil, []ir.Node{anonfield(typs[84]), anonfield(typs[3])}, nil)
+	typs[86] = functype(nil, []ir.Node{anonfield(typs[84]), anonfield(typs[3])}, []ir.Node{anonfield(typs[6])})
 	typs[87] = types.NewChan(typs[2], types.Csend)
-	typs[88] = functype(nil, []*ir.Node{anonfield(typs[87]), anonfield(typs[3])}, nil)
+	typs[88] = functype(nil, []ir.Node{anonfield(typs[87]), anonfield(typs[3])}, nil)
 	typs[89] = types.NewArray(typs[0], 3)
-	typs[90] = tostruct([]*ir.Node{namedfield("enabled", typs[6]), namedfield("pad", typs[89]), namedfield("needed", typs[6]), namedfield("cgo", typs[6]), namedfield("alignme", typs[24])})
-	typs[91] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[3]), anonfield(typs[3])}, nil)
-	typs[92] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[3])}, nil)
-	typs[93] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[3]), anonfield(typs[15])}, []*ir.Node{anonfield(typs[15])})
-	typs[94] = functype(nil, []*ir.Node{anonfield(typs[87]), anonfield(typs[3])}, []*ir.Node{anonfield(typs[6])})
-	typs[95] = functype(nil, []*ir.Node{anonfield(typs[3]), anonfield(typs[84])}, []*ir.Node{anonfield(typs[6])})
+	typs[90] = tostruct([]ir.Node{namedfield("enabled", typs[6]), namedfield("pad", typs[89]), namedfield("needed", typs[6]), namedfield("cgo", typs[6]), namedfield("alignme", typs[24])})
+	typs[91] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[3]), anonfield(typs[3])}, nil)
+	typs[92] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[3])}, nil)
+	typs[93] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[3]), anonfield(typs[15])}, []ir.Node{anonfield(typs[15])})
+	typs[94] = functype(nil, []ir.Node{anonfield(typs[87]), anonfield(typs[3])}, []ir.Node{anonfield(typs[6])})
+	typs[95] = functype(nil, []ir.Node{anonfield(typs[3]), anonfield(typs[84])}, []ir.Node{anonfield(typs[6])})
 	typs[96] = types.NewPtr(typs[6])
-	typs[97] = functype(nil, []*ir.Node{anonfield(typs[3]), anonfield(typs[96]), anonfield(typs[84])}, []*ir.Node{anonfield(typs[6])})
-	typs[98] = functype(nil, []*ir.Node{anonfield(typs[63])}, nil)
-	typs[99] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[1]), anonfield(typs[63]), anonfield(typs[15]), anonfield(typs[15]), anonfield(typs[6])}, []*ir.Node{anonfield(typs[15]), anonfield(typs[6])})
-	typs[100] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[15])}, []*ir.Node{anonfield(typs[7])})
-	typs[101] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[22]), anonfield(typs[22])}, []*ir.Node{anonfield(typs[7])})
-	typs[102] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[15]), anonfield(typs[7])}, []*ir.Node{anonfield(typs[7])})
+	typs[97] = functype(nil, []ir.Node{anonfield(typs[3]), anonfield(typs[96]), anonfield(typs[84])}, []ir.Node{anonfield(typs[6])})
+	typs[98] = functype(nil, []ir.Node{anonfield(typs[63])}, nil)
+	typs[99] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[1]), anonfield(typs[63]), anonfield(typs[15]), anonfield(typs[15]), anonfield(typs[6])}, []ir.Node{anonfield(typs[15]), anonfield(typs[6])})
+	typs[100] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[15])}, []ir.Node{anonfield(typs[7])})
+	typs[101] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[22]), anonfield(typs[22])}, []ir.Node{anonfield(typs[7])})
+	typs[102] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[15]), anonfield(typs[7])}, []ir.Node{anonfield(typs[7])})
 	typs[103] = types.NewSlice(typs[2])
-	typs[104] = functype(nil, []*ir.Node{anonfield(typs[1]), anonfield(typs[103]), anonfield(typs[15])}, []*ir.Node{anonfield(typs[103])})
-	typs[105] = functype(nil, []*ir.Node{anonfield(typs[3]), anonfield(typs[3]), anonfield(typs[5])}, nil)
-	typs[106] = functype(nil, []*ir.Node{anonfield(typs[7]), anonfield(typs[5])}, nil)
-	typs[107] = functype(nil, []*ir.Node{anonfield(typs[3]), anonfield(typs[3]), anonfield(typs[5])}, []*ir.Node{anonfield(typs[6])})
-	typs[108] = functype(nil, []*ir.Node{anonfield(typs[3]), anonfield(typs[3])}, []*ir.Node{anonfield(typs[6])})
-	typs[109] = functype(nil, []*ir.Node{anonfield(typs[7]), anonfield(typs[7])}, []*ir.Node{anonfield(typs[6])})
-	typs[110] = functype(nil, []*ir.Node{anonfield(typs[7]), anonfield(typs[5]), anonfield(typs[5])}, []*ir.Node{anonfield(typs[5])})
-	typs[111] = functype(nil, []*ir.Node{anonfield(typs[7]), anonfield(typs[5])}, []*ir.Node{anonfield(typs[5])})
-	typs[112] = functype(nil, []*ir.Node{anonfield(typs[22]), anonfield(typs[22])}, []*ir.Node{anonfield(typs[22])})
-	typs[113] = functype(nil, []*ir.Node{anonfield(typs[24]), anonfield(typs[24])}, []*ir.Node{anonfield(typs[24])})
-	typs[114] = functype(nil, []*ir.Node{anonfield(typs[20])}, []*ir.Node{anonfield(typs[22])})
-	typs[115] = functype(nil, []*ir.Node{anonfield(typs[20])}, []*ir.Node{anonfield(typs[24])})
-	typs[116] = functype(nil, []*ir.Node{anonfield(typs[20])}, []*ir.Node{anonfield(typs[65])})
-	typs[117] = functype(nil, []*ir.Node{anonfield(typs[22])}, []*ir.Node{anonfield(typs[20])})
-	typs[118] = functype(nil, []*ir.Node{anonfield(typs[24])}, []*ir.Node{anonfield(typs[20])})
-	typs[119] = functype(nil, []*ir.Node{anonfield(typs[65])}, []*ir.Node{anonfield(typs[20])})
-	typs[120] = functype(nil, []*ir.Node{anonfield(typs[26]), anonfield(typs[26])}, []*ir.Node{anonfield(typs[26])})
-	typs[121] = functype(nil, []*ir.Node{anonfield(typs[5]), anonfield(typs[5])}, nil)
-	typs[122] = functype(nil, []*ir.Node{anonfield(typs[7]), anonfield(typs[1]), anonfield(typs[5])}, nil)
+	typs[104] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[103]), anonfield(typs[15])}, []ir.Node{anonfield(typs[103])})
+	typs[105] = functype(nil, []ir.Node{anonfield(typs[3]), anonfield(typs[3]), anonfield(typs[5])}, nil)
+	typs[106] = functype(nil, []ir.Node{anonfield(typs[7]), anonfield(typs[5])}, nil)
+	typs[107] = functype(nil, []ir.Node{anonfield(typs[3]), anonfield(typs[3]), anonfield(typs[5])}, []ir.Node{anonfield(typs[6])})
+	typs[108] = functype(nil, []ir.Node{anonfield(typs[3]), anonfield(typs[3])}, []ir.Node{anonfield(typs[6])})
+	typs[109] = functype(nil, []ir.Node{anonfield(typs[7]), anonfield(typs[7])}, []ir.Node{anonfield(typs[6])})
+	typs[110] = functype(nil, []ir.Node{anonfield(typs[7]), anonfield(typs[5]), anonfield(typs[5])}, []ir.Node{anonfield(typs[5])})
+	typs[111] = functype(nil, []ir.Node{anonfield(typs[7]), anonfield(typs[5])}, []ir.Node{anonfield(typs[5])})
+	typs[112] = functype(nil, []ir.Node{anonfield(typs[22]), anonfield(typs[22])}, []ir.Node{anonfield(typs[22])})
+	typs[113] = functype(nil, []ir.Node{anonfield(typs[24]), anonfield(typs[24])}, []ir.Node{anonfield(typs[24])})
+	typs[114] = functype(nil, []ir.Node{anonfield(typs[20])}, []ir.Node{anonfield(typs[22])})
+	typs[115] = functype(nil, []ir.Node{anonfield(typs[20])}, []ir.Node{anonfield(typs[24])})
+	typs[116] = functype(nil, []ir.Node{anonfield(typs[20])}, []ir.Node{anonfield(typs[65])})
+	typs[117] = functype(nil, []ir.Node{anonfield(typs[22])}, []ir.Node{anonfield(typs[20])})
+	typs[118] = functype(nil, []ir.Node{anonfield(typs[24])}, []ir.Node{anonfield(typs[20])})
+	typs[119] = functype(nil, []ir.Node{anonfield(typs[65])}, []ir.Node{anonfield(typs[20])})
+	typs[120] = functype(nil, []ir.Node{anonfield(typs[26]), anonfield(typs[26])}, []ir.Node{anonfield(typs[26])})
+	typs[121] = functype(nil, []ir.Node{anonfield(typs[5]), anonfield(typs[5])}, nil)
+	typs[122] = functype(nil, []ir.Node{anonfield(typs[7]), anonfield(typs[1]), anonfield(typs[5])}, nil)
 	typs[123] = types.NewSlice(typs[7])
-	typs[124] = functype(nil, []*ir.Node{anonfield(typs[7]), anonfield(typs[123])}, nil)
+	typs[124] = functype(nil, []ir.Node{anonfield(typs[7]), anonfield(typs[123])}, nil)
 	typs[125] = types.Types[types.TUINT8]
-	typs[126] = functype(nil, []*ir.Node{anonfield(typs[125]), anonfield(typs[125])}, nil)
+	typs[126] = functype(nil, []ir.Node{anonfield(typs[125]), anonfield(typs[125])}, nil)
 	typs[127] = types.Types[types.TUINT16]
-	typs[128] = functype(nil, []*ir.Node{anonfield(typs[127]), anonfield(typs[127])}, nil)
-	typs[129] = functype(nil, []*ir.Node{anonfield(typs[65]), anonfield(typs[65])}, nil)
-	typs[130] = functype(nil, []*ir.Node{anonfield(typs[24]), anonfield(typs[24])}, nil)
+	typs[128] = functype(nil, []ir.Node{anonfield(typs[127]), anonfield(typs[127])}, nil)
+	typs[129] = functype(nil, []ir.Node{anonfield(typs[65]), anonfield(typs[65])}, nil)
+	typs[130] = functype(nil, []ir.Node{anonfield(typs[24]), anonfield(typs[24])}, nil)
 	return typs[:]
 }
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index 2dce7b7f03..2901ae41d6 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -13,7 +13,7 @@ import (
 	"fmt"
 )
 
-func (p *noder) funcLit(expr *syntax.FuncLit) *ir.Node {
+func (p *noder) funcLit(expr *syntax.FuncLit) ir.Node {
 	xtype := p.typeExpr(expr.Type)
 	ntype := p.typeExpr(expr.Type)
 
@@ -78,7 +78,7 @@ func (p *noder) funcLit(expr *syntax.FuncLit) *ir.Node {
 // function associated with the closure.
 // TODO: This creation of the named function should probably really be done in a
 // separate pass from type-checking.
-func typecheckclosure(clo *ir.Node, top int) {
+func typecheckclosure(clo ir.Node, top int) {
 	fn := clo.Func()
 	dcl := fn.Decl
 	// Set current associated iota value, so iota can be used inside
@@ -140,7 +140,7 @@ var globClosgen int
 
 // closurename generates a new unique name for a closure within
 // outerfunc.
-func closurename(outerfunc *ir.Node) *types.Sym {
+func closurename(outerfunc ir.Node) *types.Sym {
 	outer := "glob."
 	prefix := "func"
 	gen := &globClosgen
@@ -172,7 +172,7 @@ var capturevarscomplete bool
 // by value or by reference.
 // We use value capturing for values <= 128 bytes that are never reassigned
 // after capturing (effectively constant).
-func capturevars(dcl *ir.Node) {
+func capturevars(dcl ir.Node) {
 	lno := base.Pos
 	base.Pos = dcl.Pos()
 	fn := dcl.Func()
@@ -227,7 +227,7 @@ func capturevars(dcl *ir.Node) {
 
 // transformclosure is called in a separate phase after escape analysis.
 // It transform closure bodies to properly reference captured variables.
-func transformclosure(dcl *ir.Node) {
+func transformclosure(dcl ir.Node) {
 	lno := base.Pos
 	base.Pos = dcl.Pos()
 	fn := dcl.Func()
@@ -253,7 +253,7 @@ func transformclosure(dcl *ir.Node) {
 
 		// We are going to insert captured variables before input args.
 		var params []*types.Field
-		var decls []*ir.Node
+		var decls []ir.Node
 		for _, v := range fn.ClosureVars.Slice() {
 			if !v.Name().Byval() {
 				// If v of type T is captured by reference,
@@ -284,7 +284,7 @@ func transformclosure(dcl *ir.Node) {
 		dcl.SetType(f.Type()) // update type of ODCLFUNC
 	} else {
 		// The closure is not called, so it is going to stay as closure.
-		var body []*ir.Node
+		var body []ir.Node
 		offset := int64(Widthptr)
 		for _, v := range fn.ClosureVars.Slice() {
 			// cv refers to the field inside of closure OSTRUCTLIT.
@@ -332,13 +332,13 @@ func transformclosure(dcl *ir.Node) {
 
 // hasemptycvars reports whether closure clo has an
 // empty list of captured vars.
-func hasemptycvars(clo *ir.Node) bool {
+func hasemptycvars(clo ir.Node) bool {
 	return clo.Func().ClosureVars.Len() == 0
 }
 
 // closuredebugruntimecheck applies boilerplate checks for debug flags
 // and compiling runtime
-func closuredebugruntimecheck(clo *ir.Node) {
+func closuredebugruntimecheck(clo ir.Node) {
 	if base.Debug.Closure > 0 {
 		if clo.Esc() == EscHeap {
 			base.WarnfAt(clo.Pos(), "heap closure, captured vars = %v", clo.Func().ClosureVars)
@@ -354,7 +354,7 @@ func closuredebugruntimecheck(clo *ir.Node) {
 // closureType returns the struct type used to hold all the information
 // needed in the closure for clo (clo must be a OCLOSURE node).
 // The address of a variable of the returned type can be cast to a func.
-func closureType(clo *ir.Node) *types.Type {
+func closureType(clo ir.Node) *types.Type {
 	// Create closure in the form of a composite literal.
 	// supposing the closure captures an int i and a string s
 	// and has one float64 argument and no results,
@@ -368,7 +368,7 @@ func closureType(clo *ir.Node) *types.Type {
 	// The information appears in the binary in the form of type descriptors;
 	// the struct is unnamed so that closures in multiple packages with the
 	// same struct type can share the descriptor.
-	fields := []*ir.Node{
+	fields := []ir.Node{
 		namedfield(".F", types.Types[types.TUINTPTR]),
 	}
 	for _, v := range clo.Func().ClosureVars.Slice() {
@@ -383,7 +383,7 @@ func closureType(clo *ir.Node) *types.Type {
 	return typ
 }
 
-func walkclosure(clo *ir.Node, init *ir.Nodes) *ir.Node {
+func walkclosure(clo ir.Node, init *ir.Nodes) ir.Node {
 	fn := clo.Func()
 
 	// If no closure vars, don't bother wrapping.
@@ -399,7 +399,7 @@ func walkclosure(clo *ir.Node, init *ir.Nodes) *ir.Node {
 
 	clos := ir.Nod(ir.OCOMPLIT, nil, typenod(typ))
 	clos.SetEsc(clo.Esc())
-	clos.PtrList().Set(append([]*ir.Node{ir.Nod(ir.OCFUNC, fn.Nname, nil)}, fn.ClosureEnter.Slice()...))
+	clos.PtrList().Set(append([]ir.Node{ir.Nod(ir.OCFUNC, fn.Nname, nil)}, fn.ClosureEnter.Slice()...))
 
 	clos = ir.Nod(ir.OADDR, clos, nil)
 	clos.SetEsc(clo.Esc())
@@ -419,7 +419,7 @@ func walkclosure(clo *ir.Node, init *ir.Nodes) *ir.Node {
 	return walkexpr(clos, init)
 }
 
-func typecheckpartialcall(dot *ir.Node, sym *types.Sym) {
+func typecheckpartialcall(dot ir.Node, sym *types.Sym) {
 	switch dot.Op() {
 	case ir.ODOTINTER, ir.ODOTMETH:
 		break
@@ -440,7 +440,7 @@ func typecheckpartialcall(dot *ir.Node, sym *types.Sym) {
 
 // makepartialcall returns a DCLFUNC node representing the wrapper function (*-fm) needed
 // for partial calls.
-func makepartialcall(dot *ir.Node, t0 *types.Type, meth *types.Sym) *ir.Node {
+func makepartialcall(dot ir.Node, t0 *types.Type, meth *types.Sym) ir.Node {
 	rcvrtype := dot.Left().Type()
 	sym := methodSymSuffix(rcvrtype, meth, "-fm")
 
@@ -484,7 +484,7 @@ func makepartialcall(dot *ir.Node, t0 *types.Type, meth *types.Sym) *ir.Node {
 	ptr := NewName(lookup(".this"))
 	declare(ptr, ir.PAUTO)
 	ptr.Name().SetUsed(true)
-	var body []*ir.Node
+	var body []ir.Node
 	if rcvrtype.IsPtr() || rcvrtype.IsInterface() {
 		ptr.SetType(rcvrtype)
 		body = append(body, ir.Nod(ir.OAS, ptr, cv))
@@ -522,8 +522,8 @@ func makepartialcall(dot *ir.Node, t0 *types.Type, meth *types.Sym) *ir.Node {
 // partialCallType returns the struct type used to hold all the information
 // needed in the closure for n (n must be a OCALLPART node).
 // The address of a variable of the returned type can be cast to a func.
-func partialCallType(n *ir.Node) *types.Type {
-	t := tostruct([]*ir.Node{
+func partialCallType(n ir.Node) *types.Type {
+	t := tostruct([]ir.Node{
 		namedfield("F", types.Types[types.TUINTPTR]),
 		namedfield("R", n.Left().Type()),
 	})
@@ -531,7 +531,7 @@ func partialCallType(n *ir.Node) *types.Type {
 	return t
 }
 
-func walkpartialcall(n *ir.Node, init *ir.Nodes) *ir.Node {
+func walkpartialcall(n ir.Node, init *ir.Nodes) ir.Node {
 	// Create closure in the form of a composite literal.
 	// For x.M with receiver (x) type T, the generated code looks like:
 	//
@@ -579,7 +579,7 @@ func walkpartialcall(n *ir.Node, init *ir.Nodes) *ir.Node {
 
 // callpartMethod returns the *types.Field representing the method
 // referenced by method value n.
-func callpartMethod(n *ir.Node) *types.Field {
+func callpartMethod(n ir.Node) *types.Field {
 	if n.Op() != ir.OCALLPART {
 		base.Fatalf("expected OCALLPART, got %v", n)
 	}
diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 27e54b46c8..4beb85245f 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -84,8 +84,8 @@ func trunccmplxlit(v constant.Value, t *types.Type) constant.Value {
 }
 
 // TODO(mdempsky): Replace these with better APIs.
-func convlit(n *ir.Node, t *types.Type) *ir.Node    { return convlit1(n, t, false, nil) }
-func defaultlit(n *ir.Node, t *types.Type) *ir.Node { return convlit1(n, t, false, nil) }
+func convlit(n ir.Node, t *types.Type) ir.Node    { return convlit1(n, t, false, nil) }
+func defaultlit(n ir.Node, t *types.Type) ir.Node { return convlit1(n, t, false, nil) }
 
 // convlit1 converts an untyped expression n to type t. If n already
 // has a type, convlit1 has no effect.
@@ -98,7 +98,7 @@ func defaultlit(n *ir.Node, t *types.Type) *ir.Node { return convlit1(n, t, fals
 //
 // If there's an error converting n to t, context is used in the error
 // message.
-func convlit1(n *ir.Node, t *types.Type, explicit bool, context func() string) *ir.Node {
+func convlit1(n ir.Node, t *types.Type, explicit bool, context func() string) ir.Node {
 	if explicit && t == nil {
 		base.Fatalf("explicit conversion missing type")
 	}
@@ -438,7 +438,7 @@ var tokenForOp = [...]token.Token{
 // If n is not a constant, evalConst returns n.
 // Otherwise, evalConst returns a new OLITERAL with the same value as n,
 // and with .Orig pointing back to n.
-func evalConst(n *ir.Node) *ir.Node {
+func evalConst(n ir.Node) ir.Node {
 	nl, nr := n.Left(), n.Right()
 
 	// Pick off just the opcodes that can be constant evaluated.
@@ -525,7 +525,7 @@ func evalConst(n *ir.Node) *ir.Node {
 			}
 			return origConst(n, constant.MakeString(strings.Join(strs, "")))
 		}
-		newList := make([]*ir.Node, 0, need)
+		newList := make([]ir.Node, 0, need)
 		for i := 0; i < len(s); i++ {
 			if ir.IsConst(s[i], constant.String) && i+1 < len(s) && ir.IsConst(s[i+1], constant.String) {
 				// merge from i up to but not including i2
@@ -619,7 +619,7 @@ var overflowNames = [...]string{
 }
 
 // origConst returns an OLITERAL with orig n and value v.
-func origConst(n *ir.Node, v constant.Value) *ir.Node {
+func origConst(n ir.Node, v constant.Value) ir.Node {
 	lno := setlineno(n)
 	v = convertVal(v, n.Type(), false)
 	base.Pos = lno
@@ -648,11 +648,11 @@ func origConst(n *ir.Node, v constant.Value) *ir.Node {
 	return n
 }
 
-func origBoolConst(n *ir.Node, v bool) *ir.Node {
+func origBoolConst(n ir.Node, v bool) ir.Node {
 	return origConst(n, constant.MakeBool(v))
 }
 
-func origIntConst(n *ir.Node, v int64) *ir.Node {
+func origIntConst(n ir.Node, v int64) ir.Node {
 	return origConst(n, constant.MakeInt64(v))
 }
 
@@ -662,7 +662,7 @@ func origIntConst(n *ir.Node, v int64) *ir.Node {
 // force means must assign concrete (non-ideal) type.
 // The results of defaultlit2 MUST be assigned back to l and r, e.g.
 // 	n.Left, n.Right = defaultlit2(n.Left, n.Right, force)
-func defaultlit2(l *ir.Node, r *ir.Node, force bool) (*ir.Node, *ir.Node) {
+func defaultlit2(l ir.Node, r ir.Node, force bool) (ir.Node, ir.Node) {
 	if l.Type() == nil || r.Type() == nil {
 		return l, r
 	}
@@ -747,7 +747,7 @@ func defaultType(t *types.Type) *types.Type {
 	return nil
 }
 
-func smallintconst(n *ir.Node) bool {
+func smallintconst(n ir.Node) bool {
 	if n.Op() == ir.OLITERAL {
 		v, ok := constant.Int64Val(n.Val())
 		return ok && int64(int32(v)) == v
@@ -760,7 +760,7 @@ func smallintconst(n *ir.Node) bool {
 // If n is not a constant expression, not representable as an
 // integer, or negative, it returns -1. If n is too large, it
 // returns -2.
-func indexconst(n *ir.Node) int64 {
+func indexconst(n ir.Node) int64 {
 	if n.Op() != ir.OLITERAL {
 		return -1
 	}
@@ -783,11 +783,11 @@ func indexconst(n *ir.Node) int64 {
 //
 // Expressions derived from nil, like string([]byte(nil)), while they
 // may be known at compile time, are not Go language constants.
-func isGoConst(n *ir.Node) bool {
+func isGoConst(n ir.Node) bool {
 	return n.Op() == ir.OLITERAL
 }
 
-func hascallchan(n *ir.Node) bool {
+func hascallchan(n ir.Node) bool {
 	if n == nil {
 		return false
 	}
@@ -851,7 +851,7 @@ type constSetKey struct {
 // where are used in the error message.
 //
 // n must not be an untyped constant.
-func (s *constSet) add(pos src.XPos, n *ir.Node, what, where string) {
+func (s *constSet) add(pos src.XPos, n ir.Node, what, where string) {
 	if n.Op() == ir.OCONVIFACE && n.Implicit() {
 		n = n.Left()
 	}
@@ -908,7 +908,7 @@ func (s *constSet) add(pos src.XPos, n *ir.Node, what, where string) {
 // the latter is non-obvious.
 //
 // TODO(mdempsky): This could probably be a fmt.go flag.
-func nodeAndVal(n *ir.Node) string {
+func nodeAndVal(n ir.Node) string {
 	show := n.String()
 	val := ir.ConstValue(n)
 	if s := fmt.Sprintf("%#v", val); show != s {
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 8980c47e2c..2a7be137c0 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -18,7 +18,7 @@ import (
 
 // Declaration stack & operations
 
-var externdcl []*ir.Node
+var externdcl []ir.Node
 
 func testdclstack() {
 	if !types.IsDclstackValid() {
@@ -59,7 +59,7 @@ var declare_typegen int
 
 // declare records that Node n declares symbol n.Sym in the specified
 // declaration context.
-func declare(n *ir.Node, ctxt ir.Class) {
+func declare(n ir.Node, ctxt ir.Class) {
 	if ir.IsBlank(n) {
 		return
 	}
@@ -128,7 +128,7 @@ func declare(n *ir.Node, ctxt ir.Class) {
 	autoexport(n, ctxt)
 }
 
-func addvar(n *ir.Node, t *types.Type, ctxt ir.Class) {
+func addvar(n ir.Node, t *types.Type, ctxt ir.Class) {
 	if n == nil || n.Sym() == nil || (n.Op() != ir.ONAME && n.Op() != ir.ONONAME) || t == nil {
 		base.Fatalf("addvar: n=%v t=%v nil", n, t)
 	}
@@ -140,8 +140,8 @@ func addvar(n *ir.Node, t *types.Type, ctxt ir.Class) {
 
 // declare variables from grammar
 // new_name_list (type | [type] = expr_list)
-func variter(vl []*ir.Node, t *ir.Node, el []*ir.Node) []*ir.Node {
-	var init []*ir.Node
+func variter(vl []ir.Node, t ir.Node, el []ir.Node) []ir.Node {
+	var init []ir.Node
 	doexpr := len(el) > 0
 
 	if len(el) == 1 && len(vl) > 1 {
@@ -164,7 +164,7 @@ func variter(vl []*ir.Node, t *ir.Node, el []*ir.Node) []*ir.Node {
 
 	nel := len(el)
 	for _, v := range vl {
-		var e *ir.Node
+		var e ir.Node
 		if doexpr {
 			if len(el) == 0 {
 				base.Errorf("assignment mismatch: %d variables but %d values", len(vl), nel)
@@ -197,7 +197,7 @@ func variter(vl []*ir.Node, t *ir.Node, el []*ir.Node) []*ir.Node {
 }
 
 // newnoname returns a new ONONAME Node associated with symbol s.
-func newnoname(s *types.Sym) *ir.Node {
+func newnoname(s *types.Sym) ir.Node {
 	if s == nil {
 		base.Fatalf("newnoname nil")
 	}
@@ -208,7 +208,7 @@ func newnoname(s *types.Sym) *ir.Node {
 }
 
 // newfuncnamel generates a new name node for a function or method.
-func newfuncnamel(pos src.XPos, s *types.Sym, fn *ir.Func) *ir.Node {
+func newfuncnamel(pos src.XPos, s *types.Sym, fn *ir.Func) ir.Node {
 	if fn.Nname != nil {
 		base.Fatalf("newfuncnamel - already have name")
 	}
@@ -220,17 +220,17 @@ func newfuncnamel(pos src.XPos, s *types.Sym, fn *ir.Func) *ir.Node {
 
 // this generates a new name node for a name
 // being declared.
-func dclname(s *types.Sym) *ir.Node {
+func dclname(s *types.Sym) ir.Node {
 	n := NewName(s)
 	n.SetOp(ir.ONONAME) // caller will correct it
 	return n
 }
 
-func typenod(t *types.Type) *ir.Node {
+func typenod(t *types.Type) ir.Node {
 	return typenodl(src.NoXPos, t)
 }
 
-func typenodl(pos src.XPos, t *types.Type) *ir.Node {
+func typenodl(pos src.XPos, t *types.Type) ir.Node {
 	// if we copied another type with *t = *u
 	// then t->nod might be out of date, so
 	// check t->nod->type too
@@ -243,15 +243,15 @@ func typenodl(pos src.XPos, t *types.Type) *ir.Node {
 	return ir.AsNode(t.Nod)
 }
 
-func anonfield(typ *types.Type) *ir.Node {
+func anonfield(typ *types.Type) ir.Node {
 	return symfield(nil, typ)
 }
 
-func namedfield(s string, typ *types.Type) *ir.Node {
+func namedfield(s string, typ *types.Type) ir.Node {
 	return symfield(lookup(s), typ)
 }
 
-func symfield(s *types.Sym, typ *types.Type) *ir.Node {
+func symfield(s *types.Sym, typ *types.Type) ir.Node {
 	n := nodSym(ir.ODCLFIELD, nil, s)
 	n.SetType(typ)
 	return n
@@ -261,7 +261,7 @@ func symfield(s *types.Sym, typ *types.Type) *ir.Node {
 // If no such Node currently exists, an ONONAME Node is returned instead.
 // Automatically creates a new closure variable if the referenced symbol was
 // declared in a different (containing) function.
-func oldname(s *types.Sym) *ir.Node {
+func oldname(s *types.Sym) ir.Node {
 	n := ir.AsNode(s.Def)
 	if n == nil {
 		// Maybe a top-level declaration will come along later to
@@ -302,7 +302,7 @@ func oldname(s *types.Sym) *ir.Node {
 }
 
 // importName is like oldname, but it reports an error if sym is from another package and not exported.
-func importName(sym *types.Sym) *ir.Node {
+func importName(sym *types.Sym) ir.Node {
 	n := oldname(sym)
 	if !types.IsExported(sym.Name) && sym.Pkg != ir.LocalPkg {
 		n.SetDiag(true)
@@ -312,7 +312,7 @@ func importName(sym *types.Sym) *ir.Node {
 }
 
 // := declarations
-func colasname(n *ir.Node) bool {
+func colasname(n ir.Node) bool {
 	switch n.Op() {
 	case ir.ONAME,
 		ir.ONONAME,
@@ -325,7 +325,7 @@ func colasname(n *ir.Node) bool {
 	return false
 }
 
-func colasdefn(left []*ir.Node, defn *ir.Node) {
+func colasdefn(left []ir.Node, defn ir.Node) {
 	for _, n := range left {
 		if n.Sym() != nil {
 			n.Sym().SetUniq(true)
@@ -370,7 +370,7 @@ func colasdefn(left []*ir.Node, defn *ir.Node) {
 
 // declare the arguments in an
 // interface field declaration.
-func ifacedcl(n *ir.Node) {
+func ifacedcl(n ir.Node) {
 	if n.Op() != ir.ODCLFIELD || n.Left() == nil {
 		base.Fatalf("ifacedcl")
 	}
@@ -384,7 +384,7 @@ func ifacedcl(n *ir.Node) {
 // and declare the arguments.
 // called in extern-declaration context
 // returns in auto-declaration context.
-func funchdr(n *ir.Node) {
+func funchdr(n ir.Node) {
 	// change the declaration context from extern to auto
 	funcStack = append(funcStack, funcStackEnt{Curfn, dclcontext})
 	Curfn = n
@@ -399,7 +399,7 @@ func funchdr(n *ir.Node) {
 	}
 }
 
-func funcargs(nt *ir.Node) {
+func funcargs(nt ir.Node) {
 	if nt.Op() != ir.OTFUNC {
 		base.Fatalf("funcargs %v", nt.Op())
 	}
@@ -449,7 +449,7 @@ func funcargs(nt *ir.Node) {
 	vargen = oldvargen
 }
 
-func funcarg(n *ir.Node, ctxt ir.Class) {
+func funcarg(n ir.Node, ctxt ir.Class) {
 	if n.Op() != ir.ODCLFIELD {
 		base.Fatalf("funcarg %v", n.Op())
 	}
@@ -499,7 +499,7 @@ func funcarg2(f *types.Field, ctxt ir.Class) {
 var funcStack []funcStackEnt // stack of previous values of Curfn/dclcontext
 
 type funcStackEnt struct {
-	curfn      *ir.Node
+	curfn      ir.Node
 	dclcontext ir.Class
 }
 
@@ -535,7 +535,7 @@ func checkembeddedtype(t *types.Type) {
 	}
 }
 
-func structfield(n *ir.Node) *types.Field {
+func structfield(n ir.Node) *types.Field {
 	lno := base.Pos
 	base.Pos = n.Pos()
 
@@ -582,7 +582,7 @@ func checkdupfields(what string, fss ...[]*types.Field) {
 
 // convert a parsed id/type list into
 // a type for struct/interface/arglist
-func tostruct(l []*ir.Node) *types.Type {
+func tostruct(l []ir.Node) *types.Type {
 	t := types.New(types.TSTRUCT)
 
 	fields := make([]*types.Field, len(l))
@@ -604,7 +604,7 @@ func tostruct(l []*ir.Node) *types.Type {
 	return t
 }
 
-func tofunargs(l []*ir.Node, funarg types.Funarg) *types.Type {
+func tofunargs(l []ir.Node, funarg types.Funarg) *types.Type {
 	t := types.New(types.TSTRUCT)
 	t.StructType().Funarg = funarg
 
@@ -632,7 +632,7 @@ func tofunargsfield(fields []*types.Field, funarg types.Funarg) *types.Type {
 	return t
 }
 
-func interfacefield(n *ir.Node) *types.Field {
+func interfacefield(n ir.Node) *types.Field {
 	lno := base.Pos
 	base.Pos = n.Pos()
 
@@ -661,7 +661,7 @@ func interfacefield(n *ir.Node) *types.Field {
 	return f
 }
 
-func tointerface(l []*ir.Node) *types.Type {
+func tointerface(l []ir.Node) *types.Type {
 	if len(l) == 0 {
 		return types.Types[types.TINTER]
 	}
@@ -678,7 +678,7 @@ func tointerface(l []*ir.Node) *types.Type {
 	return t
 }
 
-func fakeRecv() *ir.Node {
+func fakeRecv() ir.Node {
 	return anonfield(types.FakeRecvType())
 }
 
@@ -694,12 +694,12 @@ func isifacemethod(f *types.Type) bool {
 }
 
 // turn a parsed function declaration into a type
-func functype(this *ir.Node, in, out []*ir.Node) *types.Type {
+func functype(this ir.Node, in, out []ir.Node) *types.Type {
 	t := types.New(types.TFUNC)
 
-	var rcvr []*ir.Node
+	var rcvr []ir.Node
 	if this != nil {
-		rcvr = []*ir.Node{this}
+		rcvr = []ir.Node{this}
 	}
 	t.FuncType().Receiver = tofunargs(rcvr, types.FunargRcvr)
 	t.FuncType().Params = tofunargs(in, types.FunargParams)
@@ -799,7 +799,7 @@ func methodSymSuffix(recv *types.Type, msym *types.Sym, suffix string) *types.Sy
 // - msym is the method symbol
 // - t is function type (with receiver)
 // Returns a pointer to the existing or added Field; or nil if there's an error.
-func addmethod(n *ir.Node, msym *types.Sym, t *types.Type, local, nointerface bool) *types.Field {
+func addmethod(n ir.Node, msym *types.Sym, t *types.Type, local, nointerface bool) *types.Field {
 	if msym == nil {
 		base.Fatalf("no method symbol")
 	}
@@ -935,7 +935,7 @@ func makefuncsym(s *types.Sym) {
 }
 
 // setNodeNameFunc marks a node as a function.
-func setNodeNameFunc(n *ir.Node) {
+func setNodeNameFunc(n ir.Node) {
 	if n.Op() != ir.ONAME || n.Class() != ir.Pxxx {
 		base.Fatalf("expected ONAME/Pxxx node, got %v", n)
 	}
@@ -944,7 +944,7 @@ func setNodeNameFunc(n *ir.Node) {
 	n.Sym().SetFunc(true)
 }
 
-func dclfunc(sym *types.Sym, tfn *ir.Node) *ir.Node {
+func dclfunc(sym *types.Sym, tfn ir.Node) ir.Node {
 	if tfn.Op() != ir.OTFUNC {
 		base.Fatalf("expected OTFUNC node, got %v", tfn)
 	}
@@ -963,14 +963,14 @@ type nowritebarrierrecChecker struct {
 	// extraCalls contains extra function calls that may not be
 	// visible during later analysis. It maps from the ODCLFUNC of
 	// the caller to a list of callees.
-	extraCalls map[*ir.Node][]nowritebarrierrecCall
+	extraCalls map[ir.Node][]nowritebarrierrecCall
 
 	// curfn is the current function during AST walks.
-	curfn *ir.Node
+	curfn ir.Node
 }
 
 type nowritebarrierrecCall struct {
-	target *ir.Node // ODCLFUNC of caller or callee
+	target ir.Node  // ODCLFUNC of caller or callee
 	lineno src.XPos // line of call
 }
 
@@ -978,7 +978,7 @@ type nowritebarrierrecCall struct {
 // must be called before transformclosure and walk.
 func newNowritebarrierrecChecker() *nowritebarrierrecChecker {
 	c := &nowritebarrierrecChecker{
-		extraCalls: make(map[*ir.Node][]nowritebarrierrecCall),
+		extraCalls: make(map[ir.Node][]nowritebarrierrecCall),
 	}
 
 	// Find all systemstack calls and record their targets. In
@@ -997,7 +997,7 @@ func newNowritebarrierrecChecker() *nowritebarrierrecChecker {
 	return c
 }
 
-func (c *nowritebarrierrecChecker) findExtraCalls(n *ir.Node) bool {
+func (c *nowritebarrierrecChecker) findExtraCalls(n ir.Node) bool {
 	if n.Op() != ir.OCALLFUNC {
 		return true
 	}
@@ -1009,7 +1009,7 @@ func (c *nowritebarrierrecChecker) findExtraCalls(n *ir.Node) bool {
 		return true
 	}
 
-	var callee *ir.Node
+	var callee ir.Node
 	arg := n.List().First()
 	switch arg.Op() {
 	case ir.ONAME:
@@ -1034,7 +1034,7 @@ func (c *nowritebarrierrecChecker) findExtraCalls(n *ir.Node) bool {
 // because that's all we know after we start SSA.
 //
 // This can be called concurrently for different from Nodes.
-func (c *nowritebarrierrecChecker) recordCall(from *ir.Node, to *obj.LSym, pos src.XPos) {
+func (c *nowritebarrierrecChecker) recordCall(from ir.Node, to *obj.LSym, pos src.XPos) {
 	if from.Op() != ir.ODCLFUNC {
 		base.Fatalf("expected ODCLFUNC, got %v", from)
 	}
@@ -1052,14 +1052,14 @@ func (c *nowritebarrierrecChecker) check() {
 	// capture all calls created by lowering, but this means we
 	// only get to see the obj.LSyms of calls. symToFunc lets us
 	// get back to the ODCLFUNCs.
-	symToFunc := make(map[*obj.LSym]*ir.Node)
+	symToFunc := make(map[*obj.LSym]ir.Node)
 	// funcs records the back-edges of the BFS call graph walk. It
 	// maps from the ODCLFUNC of each function that must not have
 	// write barriers to the call that inhibits them. Functions
 	// that are directly marked go:nowritebarrierrec are in this
 	// map with a zero-valued nowritebarrierrecCall. This also
 	// acts as the set of marks for the BFS of the call graph.
-	funcs := make(map[*ir.Node]nowritebarrierrecCall)
+	funcs := make(map[ir.Node]nowritebarrierrecCall)
 	// q is the queue of ODCLFUNC Nodes to visit in BFS order.
 	var q ir.NodeQueue
 
@@ -1083,7 +1083,7 @@ func (c *nowritebarrierrecChecker) check() {
 
 	// Perform a BFS of the call graph from all
 	// go:nowritebarrierrec functions.
-	enqueue := func(src, target *ir.Node, pos src.XPos) {
+	enqueue := func(src, target ir.Node, pos src.XPos) {
 		if target.Func().Pragma&ir.Yeswritebarrierrec != 0 {
 			// Don't flow into this function.
 			return
diff --git a/src/cmd/compile/internal/gc/embed.go b/src/cmd/compile/internal/gc/embed.go
index 03703f68d5..33b05a5bf0 100644
--- a/src/cmd/compile/internal/gc/embed.go
+++ b/src/cmd/compile/internal/gc/embed.go
@@ -17,7 +17,7 @@ import (
 	"strings"
 )
 
-var embedlist []*ir.Node
+var embedlist []ir.Node
 
 const (
 	embedUnknown = iota
@@ -28,7 +28,7 @@ const (
 
 var numLocalEmbed int
 
-func varEmbed(p *noder, names []*ir.Node, typ *ir.Node, exprs []*ir.Node, embeds []PragmaEmbed) (newExprs []*ir.Node) {
+func varEmbed(p *noder, names []ir.Node, typ ir.Node, exprs []ir.Node, embeds []PragmaEmbed) (newExprs []ir.Node) {
 	haveEmbed := false
 	for _, decl := range p.file.DeclList {
 		imp, ok := decl.(*syntax.ImportDecl)
@@ -118,7 +118,7 @@ func varEmbed(p *noder, names []*ir.Node, typ *ir.Node, exprs []*ir.Node, embeds
 		v.Name().Param.Ntype = typ
 		v.SetClass(ir.PEXTERN)
 		externdcl = append(externdcl, v)
-		exprs = []*ir.Node{v}
+		exprs = []ir.Node{v}
 	}
 
 	v.Name().Param.SetEmbedFiles(list)
@@ -130,7 +130,7 @@ func varEmbed(p *noder, names []*ir.Node, typ *ir.Node, exprs []*ir.Node, embeds
 // The match is approximate because we haven't done scope resolution yet and
 // can't tell whether "string" and "byte" really mean "string" and "byte".
 // The result must be confirmed later, after type checking, using embedKind.
-func embedKindApprox(typ *ir.Node) int {
+func embedKindApprox(typ ir.Node) int {
 	if typ.Sym() != nil && typ.Sym().Name == "FS" && (typ.Sym().Pkg.Path == "embed" || (typ.Sym().Pkg == ir.LocalPkg && base.Ctxt.Pkgpath == "embed")) {
 		return embedFiles
 	}
@@ -192,7 +192,7 @@ func dumpembeds() {
 
 // initEmbed emits the init data for a //go:embed variable,
 // which is either a string, a []byte, or an embed.FS.
-func initEmbed(v *ir.Node) {
+func initEmbed(v ir.Node) {
 	files := v.Name().Param.EmbedFiles()
 	switch kind := embedKind(v.Type()); kind {
 	case embedUnknown:
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index f1786e74dc..783bc8c41d 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -86,7 +86,7 @@ import (
 type Escape struct {
 	allLocs []*EscLocation
 
-	curfn *ir.Node
+	curfn ir.Node
 
 	// loopDepth counts the current loop nesting depth within
 	// curfn. It increments within each "for" loop and at each
@@ -101,8 +101,8 @@ type Escape struct {
 // An EscLocation represents an abstract location that stores a Go
 // variable.
 type EscLocation struct {
-	n         *ir.Node  // represented variable or expression, if any
-	curfn     *ir.Node  // enclosing function
+	n         ir.Node   // represented variable or expression, if any
+	curfn     ir.Node   // enclosing function
 	edges     []EscEdge // incoming edges
 	loopDepth int       // loopDepth at declaration
 
@@ -147,7 +147,7 @@ func init() {
 }
 
 // escFmt is called from node printing to print information about escape analysis results.
-func escFmt(n *ir.Node, short bool) string {
+func escFmt(n ir.Node, short bool) string {
 	text := ""
 	switch n.Esc() {
 	case EscUnknown:
@@ -179,7 +179,7 @@ func escFmt(n *ir.Node, short bool) string {
 
 // escapeFuncs performs escape analysis on a minimal batch of
 // functions.
-func escapeFuncs(fns []*ir.Node, recursive bool) {
+func escapeFuncs(fns []ir.Node, recursive bool) {
 	for _, fn := range fns {
 		if fn.Op() != ir.ODCLFUNC {
 			base.Fatalf("unexpected node: %v", fn)
@@ -202,7 +202,7 @@ func escapeFuncs(fns []*ir.Node, recursive bool) {
 	e.finish(fns)
 }
 
-func (e *Escape) initFunc(fn *ir.Node) {
+func (e *Escape) initFunc(fn ir.Node) {
 	if fn.Op() != ir.ODCLFUNC || fn.Esc() != EscFuncUnknown {
 		base.Fatalf("unexpected node: %v", fn)
 	}
@@ -222,11 +222,11 @@ func (e *Escape) initFunc(fn *ir.Node) {
 	}
 }
 
-func (e *Escape) walkFunc(fn *ir.Node) {
+func (e *Escape) walkFunc(fn ir.Node) {
 	fn.SetEsc(EscFuncStarted)
 
 	// Identify labels that mark the head of an unstructured loop.
-	ir.InspectList(fn.Body(), func(n *ir.Node) bool {
+	ir.InspectList(fn.Body(), func(n ir.Node) bool {
 		switch n.Op() {
 		case ir.OLABEL:
 			n.Sym().Label = nonlooping
@@ -274,7 +274,7 @@ func (e *Escape) walkFunc(fn *ir.Node) {
 //    }
 
 // stmt evaluates a single Go statement.
-func (e *Escape) stmt(n *ir.Node) {
+func (e *Escape) stmt(n ir.Node) {
 	if n == nil {
 		return
 	}
@@ -447,7 +447,7 @@ func (e *Escape) block(l ir.Nodes) {
 
 // expr models evaluating an expression n and flowing the result into
 // hole k.
-func (e *Escape) expr(k EscHole, n *ir.Node) {
+func (e *Escape) expr(k EscHole, n ir.Node) {
 	if n == nil {
 		return
 	}
@@ -455,7 +455,7 @@ func (e *Escape) expr(k EscHole, n *ir.Node) {
 	e.exprSkipInit(k, n)
 }
 
-func (e *Escape) exprSkipInit(k EscHole, n *ir.Node) {
+func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 	if n == nil {
 		return
 	}
@@ -653,7 +653,7 @@ func (e *Escape) exprSkipInit(k EscHole, n *ir.Node) {
 
 // unsafeValue evaluates a uintptr-typed arithmetic expression looking
 // for conversions from an unsafe.Pointer.
-func (e *Escape) unsafeValue(k EscHole, n *ir.Node) {
+func (e *Escape) unsafeValue(k EscHole, n ir.Node) {
 	if n.Type().Etype != types.TUINTPTR {
 		base.Fatalf("unexpected type %v for %v", n.Type(), n)
 	}
@@ -690,7 +690,7 @@ func (e *Escape) unsafeValue(k EscHole, n *ir.Node) {
 
 // discard evaluates an expression n for side-effects, but discards
 // its value.
-func (e *Escape) discard(n *ir.Node) {
+func (e *Escape) discard(n ir.Node) {
 	e.expr(e.discardHole(), n)
 }
 
@@ -702,7 +702,7 @@ func (e *Escape) discards(l ir.Nodes) {
 
 // addr evaluates an addressable expression n and returns an EscHole
 // that represents storing into the represented location.
-func (e *Escape) addr(n *ir.Node) EscHole {
+func (e *Escape) addr(n ir.Node) EscHole {
 	if n == nil || ir.IsBlank(n) {
 		// Can happen at least in OSELRECV.
 		// TODO(mdempsky): Anywhere else?
@@ -751,7 +751,7 @@ func (e *Escape) addrs(l ir.Nodes) []EscHole {
 }
 
 // assign evaluates the assignment dst = src.
-func (e *Escape) assign(dst, src *ir.Node, why string, where *ir.Node) {
+func (e *Escape) assign(dst, src ir.Node, why string, where ir.Node) {
 	// Filter out some no-op assignments for escape analysis.
 	ignore := dst != nil && src != nil && isSelfAssign(dst, src)
 	if ignore && base.Flag.LowerM != 0 {
@@ -769,14 +769,14 @@ func (e *Escape) assign(dst, src *ir.Node, why string, where *ir.Node) {
 	}
 }
 
-func (e *Escape) assignHeap(src *ir.Node, why string, where *ir.Node) {
+func (e *Escape) assignHeap(src ir.Node, why string, where ir.Node) {
 	e.expr(e.heapHole().note(where, why), src)
 }
 
 // call evaluates a call expressions, including builtin calls. ks
 // should contain the holes representing where the function callee's
 // results flows; where is the OGO/ODEFER context of the call, if any.
-func (e *Escape) call(ks []EscHole, call, where *ir.Node) {
+func (e *Escape) call(ks []EscHole, call, where ir.Node) {
 	topLevelDefer := where != nil && where.Op() == ir.ODEFER && e.loopDepth == 1
 	if topLevelDefer {
 		// force stack allocation of defer record, unless
@@ -784,7 +784,7 @@ func (e *Escape) call(ks []EscHole, call, where *ir.Node) {
 		where.SetEsc(EscNever)
 	}
 
-	argument := func(k EscHole, arg *ir.Node) {
+	argument := func(k EscHole, arg ir.Node) {
 		if topLevelDefer {
 			// Top level defers arguments don't escape to
 			// heap, but they do need to last until end of
@@ -805,7 +805,7 @@ func (e *Escape) call(ks []EscHole, call, where *ir.Node) {
 		fixVariadicCall(call)
 
 		// Pick out the function callee, if statically known.
-		var fn *ir.Node
+		var fn ir.Node
 		switch call.Op() {
 		case ir.OCALLFUNC:
 			switch v := staticValue(call.Left()); {
@@ -894,7 +894,7 @@ func (e *Escape) call(ks []EscHole, call, where *ir.Node) {
 // ks should contain the holes representing where the function
 // callee's results flows. fn is the statically-known callee function,
 // if any.
-func (e *Escape) tagHole(ks []EscHole, fn *ir.Node, param *types.Field) EscHole {
+func (e *Escape) tagHole(ks []EscHole, fn ir.Node, param *types.Field) EscHole {
 	// If this is a dynamic call, we can't rely on param.Note.
 	if fn == nil {
 		return e.heapHole()
@@ -935,7 +935,7 @@ func (e *Escape) tagHole(ks []EscHole, fn *ir.Node, param *types.Field) EscHole
 // fn has not yet been analyzed, so its parameters and results
 // should be incorporated directly into the flow graph instead of
 // relying on its escape analysis tagging.
-func (e *Escape) inMutualBatch(fn *ir.Node) bool {
+func (e *Escape) inMutualBatch(fn ir.Node) bool {
 	if fn.Name().Defn != nil && fn.Name().Defn.Esc() < EscFuncTagged {
 		if fn.Name().Defn.Esc() == EscFuncUnknown {
 			base.Fatalf("graph inconsistency")
@@ -960,11 +960,11 @@ type EscHole struct {
 
 type EscNote struct {
 	next  *EscNote
-	where *ir.Node
+	where ir.Node
 	why   string
 }
 
-func (k EscHole) note(where *ir.Node, why string) EscHole {
+func (k EscHole) note(where ir.Node, why string) EscHole {
 	if where == nil || why == "" {
 		base.Fatalf("note: missing where/why")
 	}
@@ -986,10 +986,10 @@ func (k EscHole) shift(delta int) EscHole {
 	return k
 }
 
-func (k EscHole) deref(where *ir.Node, why string) EscHole { return k.shift(1).note(where, why) }
-func (k EscHole) addr(where *ir.Node, why string) EscHole  { return k.shift(-1).note(where, why) }
+func (k EscHole) deref(where ir.Node, why string) EscHole { return k.shift(1).note(where, why) }
+func (k EscHole) addr(where ir.Node, why string) EscHole  { return k.shift(-1).note(where, why) }
 
-func (k EscHole) dotType(t *types.Type, where *ir.Node, why string) EscHole {
+func (k EscHole) dotType(t *types.Type, where ir.Node, why string) EscHole {
 	if !t.IsInterface() && !isdirectiface(t) {
 		k = k.shift(1)
 	}
@@ -1026,7 +1026,7 @@ func (e *Escape) teeHole(ks ...EscHole) EscHole {
 	return loc.asHole()
 }
 
-func (e *Escape) dcl(n *ir.Node) EscHole {
+func (e *Escape) dcl(n ir.Node) EscHole {
 	loc := e.oldLoc(n)
 	loc.loopDepth = e.loopDepth
 	return loc.asHole()
@@ -1035,7 +1035,7 @@ func (e *Escape) dcl(n *ir.Node) EscHole {
 // spill allocates a new location associated with expression n, flows
 // its address to k, and returns a hole that flows values to it. It's
 // intended for use with most expressions that allocate storage.
-func (e *Escape) spill(k EscHole, n *ir.Node) EscHole {
+func (e *Escape) spill(k EscHole, n ir.Node) EscHole {
 	loc := e.newLoc(n, true)
 	e.flow(k.addr(n, "spill"), loc)
 	return loc.asHole()
@@ -1052,7 +1052,7 @@ func (e *Escape) later(k EscHole) EscHole {
 
 // canonicalNode returns the canonical *Node that n logically
 // represents.
-func canonicalNode(n *ir.Node) *ir.Node {
+func canonicalNode(n ir.Node) ir.Node {
 	if n != nil && n.Op() == ir.ONAME && n.Name().IsClosureVar() {
 		n = n.Name().Defn
 		if n.Name().IsClosureVar() {
@@ -1063,7 +1063,7 @@ func canonicalNode(n *ir.Node) *ir.Node {
 	return n
 }
 
-func (e *Escape) newLoc(n *ir.Node, transient bool) *EscLocation {
+func (e *Escape) newLoc(n ir.Node, transient bool) *EscLocation {
 	if e.curfn == nil {
 		base.Fatalf("e.curfn isn't set")
 	}
@@ -1096,7 +1096,7 @@ func (e *Escape) newLoc(n *ir.Node, transient bool) *EscLocation {
 	return loc
 }
 
-func (e *Escape) oldLoc(n *ir.Node) *EscLocation {
+func (e *Escape) oldLoc(n ir.Node) *EscLocation {
 	n = canonicalNode(n)
 	return n.Opt().(*EscLocation)
 }
@@ -1394,7 +1394,7 @@ func (e *Escape) outlives(l, other *EscLocation) bool {
 }
 
 // containsClosure reports whether c is a closure contained within f.
-func containsClosure(f, c *ir.Node) bool {
+func containsClosure(f, c ir.Node) bool {
 	if f.Op() != ir.ODCLFUNC || c.Op() != ir.ODCLFUNC {
 		base.Fatalf("bad containsClosure: %v, %v", f, c)
 	}
@@ -1429,7 +1429,7 @@ func (l *EscLocation) leakTo(sink *EscLocation, derefs int) {
 	l.paramEsc.AddHeap(derefs)
 }
 
-func (e *Escape) finish(fns []*ir.Node) {
+func (e *Escape) finish(fns []ir.Node) {
 	// Record parameter tags for package export data.
 	for _, fn := range fns {
 		fn.SetEsc(EscFuncTagged)
@@ -1574,7 +1574,7 @@ func ParseLeaks(s string) EscLeaks {
 	return l
 }
 
-func escapes(all []*ir.Node) {
+func escapes(all []ir.Node) {
 	visitBottomUp(all, escapeFuncs)
 }
 
@@ -1607,7 +1607,7 @@ const (
 )
 
 // funcSym returns fn.Func.Nname.Sym if no nils are encountered along the way.
-func funcSym(fn *ir.Node) *types.Sym {
+func funcSym(fn ir.Node) *types.Sym {
 	if fn == nil || fn.Func().Nname == nil {
 		return nil
 	}
@@ -1622,7 +1622,7 @@ var (
 	nonlooping = ir.Nod(ir.OXXX, nil, nil)
 )
 
-func isSliceSelfAssign(dst, src *ir.Node) bool {
+func isSliceSelfAssign(dst, src ir.Node) bool {
 	// Detect the following special case.
 	//
 	//	func (b *Buffer) Foo() {
@@ -1672,7 +1672,7 @@ func isSliceSelfAssign(dst, src *ir.Node) bool {
 
 // isSelfAssign reports whether assignment from src to dst can
 // be ignored by the escape analysis as it's effectively a self-assignment.
-func isSelfAssign(dst, src *ir.Node) bool {
+func isSelfAssign(dst, src ir.Node) bool {
 	if isSliceSelfAssign(dst, src) {
 		return true
 	}
@@ -1709,7 +1709,7 @@ func isSelfAssign(dst, src *ir.Node) bool {
 // mayAffectMemory reports whether evaluation of n may affect the program's
 // memory state. If the expression can't affect memory state, then it can be
 // safely ignored by the escape analysis.
-func mayAffectMemory(n *ir.Node) bool {
+func mayAffectMemory(n ir.Node) bool {
 	// We may want to use a list of "memory safe" ops instead of generally
 	// "side-effect free", which would include all calls and other ops that can
 	// allocate or change global state. For now, it's safer to start with the latter.
@@ -1736,7 +1736,7 @@ func mayAffectMemory(n *ir.Node) bool {
 
 // heapAllocReason returns the reason the given Node must be heap
 // allocated, or the empty string if it doesn't.
-func heapAllocReason(n *ir.Node) string {
+func heapAllocReason(n ir.Node) string {
 	if n.Type() == nil {
 		return ""
 	}
@@ -1781,7 +1781,7 @@ func heapAllocReason(n *ir.Node) string {
 // by "increasing" the "value" of n.Esc to EscHeap.
 // Storage is allocated as necessary to allow the address
 // to be taken.
-func addrescapes(n *ir.Node) {
+func addrescapes(n ir.Node) {
 	switch n.Op() {
 	default:
 		// Unexpected Op, probably due to a previous type error. Ignore.
@@ -1847,7 +1847,7 @@ func addrescapes(n *ir.Node) {
 }
 
 // moveToHeap records the parameter or local variable n as moved to the heap.
-func moveToHeap(n *ir.Node) {
+func moveToHeap(n ir.Node) {
 	if base.Flag.LowerR != 0 {
 		ir.Dump("MOVE", n)
 	}
@@ -1939,7 +1939,7 @@ const unsafeUintptrTag = "unsafe-uintptr"
 // marked go:uintptrescapes.
 const uintptrEscapesTag = "uintptr-escapes"
 
-func (e *Escape) paramTag(fn *ir.Node, narg int, f *types.Field) string {
+func (e *Escape) paramTag(fn ir.Node, narg int, f *types.Field) string {
 	name := func() string {
 		if f.Sym != nil {
 			return f.Sym.Name
diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index ace461fc90..10033793bf 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -21,10 +21,10 @@ func exportf(bout *bio.Writer, format string, args ...interface{}) {
 	}
 }
 
-var asmlist []*ir.Node
+var asmlist []ir.Node
 
 // exportsym marks n for export (or reexport).
-func exportsym(n *ir.Node) {
+func exportsym(n ir.Node) {
 	if n.Sym().OnExportList() {
 		return
 	}
@@ -41,7 +41,7 @@ func initname(s string) bool {
 	return s == "init"
 }
 
-func autoexport(n *ir.Node, ctxt ir.Class) {
+func autoexport(n ir.Node, ctxt ir.Class) {
 	if n.Sym().Pkg != ir.LocalPkg {
 		return
 	}
@@ -74,7 +74,7 @@ func dumpexport(bout *bio.Writer) {
 	}
 }
 
-func importsym(ipkg *types.Pkg, s *types.Sym, op ir.Op) *ir.Node {
+func importsym(ipkg *types.Pkg, s *types.Sym, op ir.Op) ir.Node {
 	n := ir.AsNode(s.PkgDef())
 	if n == nil {
 		// iimport should have created a stub ONONAME
@@ -120,7 +120,7 @@ func importtype(ipkg *types.Pkg, pos src.XPos, s *types.Sym) *types.Type {
 
 // importobj declares symbol s as an imported object representable by op.
 // ipkg is the package being imported
-func importobj(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op ir.Op, ctxt ir.Class, t *types.Type) *ir.Node {
+func importobj(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op ir.Op, ctxt ir.Class, t *types.Type) ir.Node {
 	n := importsym(ipkg, s, op)
 	if n.Op() != ir.ONONAME {
 		if n.Op() == op && (n.Class() != ctxt || !types.Identical(n.Type(), t)) {
diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
index a89ff528e5..44e918f2c1 100644
--- a/src/cmd/compile/internal/gc/gen.go
+++ b/src/cmd/compile/internal/gc/gen.go
@@ -30,13 +30,13 @@ func sysvar(name string) *obj.LSym {
 
 // isParamStackCopy reports whether this is the on-stack copy of a
 // function parameter that moved to the heap.
-func isParamStackCopy(n *ir.Node) bool {
+func isParamStackCopy(n ir.Node) bool {
 	return n.Op() == ir.ONAME && (n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT) && n.Name().Param.Heapaddr != nil
 }
 
 // isParamHeapCopy reports whether this is the on-heap copy of
 // a function parameter that moved to the heap.
-func isParamHeapCopy(n *ir.Node) bool {
+func isParamHeapCopy(n ir.Node) bool {
 	return n.Op() == ir.ONAME && n.Class() == ir.PAUTOHEAP && n.Name().Param.Stackcopy != nil
 }
 
@@ -52,7 +52,7 @@ func autotmpname(n int) string {
 }
 
 // make a new Node off the books
-func tempAt(pos src.XPos, curfn *ir.Node, t *types.Type) *ir.Node {
+func tempAt(pos src.XPos, curfn ir.Node, t *types.Type) ir.Node {
 	if curfn == nil {
 		base.Fatalf("no curfn for tempAt")
 	}
@@ -83,6 +83,6 @@ func tempAt(pos src.XPos, curfn *ir.Node, t *types.Type) *ir.Node {
 	return n.Orig()
 }
 
-func temp(t *types.Type) *ir.Node {
+func temp(t *types.Type) ir.Node {
 	return tempAt(base.Pos, Curfn, t)
 }
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index 8642cc4a30..84e6bc5faf 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -128,11 +128,11 @@ var (
 	iscmp [ir.OEND]bool
 )
 
-var xtop []*ir.Node
+var xtop []ir.Node
 
-var exportlist []*ir.Node
+var exportlist []ir.Node
 
-var importlist []*ir.Node // imported functions and methods with inlinable bodies
+var importlist []ir.Node // imported functions and methods with inlinable bodies
 
 var (
 	funcsymsmu sync.Mutex // protects funcsyms and associated package lookups (see func funcsym)
@@ -141,7 +141,7 @@ var (
 
 var dclcontext ir.Class // PEXTERN/PAUTO
 
-var Curfn *ir.Node
+var Curfn ir.Node
 
 var Widthptr int
 
@@ -156,7 +156,7 @@ var instrumenting bool
 // Whether we are tracking lexical scopes for DWARF.
 var trackScopes bool
 
-var nodfp *ir.Node
+var nodfp ir.Node
 
 var autogeneratedPos src.XPos
 
@@ -193,7 +193,7 @@ var thearch Arch
 
 var (
 	staticuint64s,
-	zerobase *ir.Node
+	zerobase ir.Node
 
 	assertE2I,
 	assertE2I2,
diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go
index 3416a00cd1..950033a8a3 100644
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ b/src/cmd/compile/internal/gc/gsubr.go
@@ -47,7 +47,7 @@ type Progs struct {
 	next      *obj.Prog  // next Prog
 	pc        int64      // virtual PC; count of Progs
 	pos       src.XPos   // position to use for new Progs
-	curfn     *ir.Node   // fn these Progs are for
+	curfn     ir.Node    // fn these Progs are for
 	progcache []obj.Prog // local progcache
 	cacheidx  int        // first free element of progcache
 
@@ -57,7 +57,7 @@ type Progs struct {
 
 // newProgs returns a new Progs for fn.
 // worker indicates which of the backend workers will use the Progs.
-func newProgs(fn *ir.Node, worker int) *Progs {
+func newProgs(fn ir.Node, worker int) *Progs {
 	pp := new(Progs)
 	if base.Ctxt.CanReuseProgs() {
 		sz := len(sharedProgArray) / base.Flag.LowerC
@@ -174,7 +174,7 @@ func (pp *Progs) Appendpp(p *obj.Prog, as obj.As, ftype obj.AddrType, freg int16
 	return q
 }
 
-func (pp *Progs) settext(fn *ir.Node) {
+func (pp *Progs) settext(fn ir.Node) {
 	if pp.Text != nil {
 		base.Fatalf("Progs.settext called twice")
 	}
@@ -290,7 +290,7 @@ func initLSym(f *ir.Func, hasBody bool) {
 	base.Ctxt.InitTextSym(f.LSym, flag)
 }
 
-func ggloblnod(nam *ir.Node) {
+func ggloblnod(nam ir.Node) {
 	s := nam.Sym().Linksym()
 	s.Gotype = ngotype(nam).Linksym()
 	flags := 0
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index 281e2de43d..ef52e40f21 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -259,8 +259,8 @@ func iexport(out *bufio.Writer) {
 	p := iexporter{
 		allPkgs:     map[*types.Pkg]bool{},
 		stringIndex: map[string]uint64{},
-		declIndex:   map[*ir.Node]uint64{},
-		inlineIndex: map[*ir.Node]uint64{},
+		declIndex:   map[ir.Node]uint64{},
+		inlineIndex: map[ir.Node]uint64{},
 		typIndex:    map[*types.Type]uint64{},
 	}
 
@@ -314,9 +314,9 @@ func iexport(out *bufio.Writer) {
 // we're writing out the main index, which is also read by
 // non-compiler tools and includes a complete package description
 // (i.e., name and height).
-func (w *exportWriter) writeIndex(index map[*ir.Node]uint64, mainIndex bool) {
+func (w *exportWriter) writeIndex(index map[ir.Node]uint64, mainIndex bool) {
 	// Build a map from packages to objects from that package.
-	pkgObjs := map[*types.Pkg][]*ir.Node{}
+	pkgObjs := map[*types.Pkg][]ir.Node{}
 
 	// For the main index, make sure to include every package that
 	// we reference, even if we're not exporting (or reexporting)
@@ -374,8 +374,8 @@ type iexporter struct {
 	stringIndex map[string]uint64
 
 	data0       intWriter
-	declIndex   map[*ir.Node]uint64
-	inlineIndex map[*ir.Node]uint64
+	declIndex   map[ir.Node]uint64
+	inlineIndex map[ir.Node]uint64
 	typIndex    map[*types.Type]uint64
 }
 
@@ -394,7 +394,7 @@ func (p *iexporter) stringOff(s string) uint64 {
 }
 
 // pushDecl adds n to the declaration work queue, if not already present.
-func (p *iexporter) pushDecl(n *ir.Node) {
+func (p *iexporter) pushDecl(n ir.Node) {
 	if n.Sym() == nil || ir.AsNode(n.Sym().Def) != n && n.Op() != ir.OTYPE {
 		base.Fatalf("weird Sym: %v, %v", n, n.Sym())
 	}
@@ -423,7 +423,7 @@ type exportWriter struct {
 	prevColumn int64
 }
 
-func (p *iexporter) doDecl(n *ir.Node) {
+func (p *iexporter) doDecl(n ir.Node) {
 	w := p.newWriter()
 	w.setPkg(n.Sym().Pkg, false)
 
@@ -515,7 +515,7 @@ func (w *exportWriter) tag(tag byte) {
 	w.data.WriteByte(tag)
 }
 
-func (p *iexporter) doInline(f *ir.Node) {
+func (p *iexporter) doInline(f ir.Node) {
 	w := p.newWriter()
 	w.setPkg(fnpkg(f), false)
 
@@ -570,7 +570,7 @@ func (w *exportWriter) pkg(pkg *types.Pkg) {
 	w.string(pkg.Path)
 }
 
-func (w *exportWriter) qualifiedIdent(n *ir.Node) {
+func (w *exportWriter) qualifiedIdent(n ir.Node) {
 	// Ensure any referenced declarations are written out too.
 	w.p.pushDecl(n)
 
@@ -955,12 +955,12 @@ func (w *exportWriter) string(s string) { w.uint64(w.p.stringOff(s)) }
 
 // Compiler-specific extensions.
 
-func (w *exportWriter) varExt(n *ir.Node) {
+func (w *exportWriter) varExt(n ir.Node) {
 	w.linkname(n.Sym())
 	w.symIdx(n.Sym())
 }
 
-func (w *exportWriter) funcExt(n *ir.Node) {
+func (w *exportWriter) funcExt(n ir.Node) {
 	w.linkname(n.Sym())
 	w.symIdx(n.Sym())
 
@@ -1037,7 +1037,7 @@ func (w *exportWriter) stmtList(list ir.Nodes) {
 	w.op(ir.OEND)
 }
 
-func (w *exportWriter) node(n *ir.Node) {
+func (w *exportWriter) node(n ir.Node) {
 	if ir.OpPrec[n.Op()] < 0 {
 		w.stmt(n)
 	} else {
@@ -1047,7 +1047,7 @@ func (w *exportWriter) node(n *ir.Node) {
 
 // Caution: stmt will emit more than one node for statement nodes n that have a non-empty
 // n.Ninit and where n cannot have a natural init section (such as in "if", "for", etc.).
-func (w *exportWriter) stmt(n *ir.Node) {
+func (w *exportWriter) stmt(n ir.Node) {
 	if n.Init().Len() > 0 && !ir.StmtWithInit(n.Op()) {
 		// can't use stmtList here since we don't want the final OEND
 		for _, n := range n.Init().Slice() {
@@ -1095,7 +1095,7 @@ func (w *exportWriter) stmt(n *ir.Node) {
 		w.op(ir.OAS2)
 		w.pos(n.Pos())
 		w.exprList(n.List())
-		w.exprList(ir.AsNodes([]*ir.Node{n.Right()}))
+		w.exprList(ir.AsNodes([]ir.Node{n.Right()}))
 
 	case ir.ORETURN:
 		w.op(ir.ORETURN)
@@ -1164,7 +1164,7 @@ func (w *exportWriter) stmt(n *ir.Node) {
 	}
 }
 
-func (w *exportWriter) caseList(sw *ir.Node) {
+func (w *exportWriter) caseList(sw ir.Node) {
 	namedTypeSwitch := sw.Op() == ir.OSWITCH && sw.Left() != nil && sw.Left().Op() == ir.OTYPESW && sw.Left().Left() != nil
 
 	cases := sw.List().Slice()
@@ -1189,7 +1189,7 @@ func (w *exportWriter) exprList(list ir.Nodes) {
 	w.op(ir.OEND)
 }
 
-func (w *exportWriter) expr(n *ir.Node) {
+func (w *exportWriter) expr(n ir.Node) {
 	// from nodefmt (fmt.go)
 	//
 	// nodefmt reverts nodes back to their original - we don't need to do
@@ -1430,7 +1430,7 @@ func (w *exportWriter) op(op ir.Op) {
 	w.uint64(uint64(op))
 }
 
-func (w *exportWriter) exprsOrNil(a, b *ir.Node) {
+func (w *exportWriter) exprsOrNil(a, b ir.Node) {
 	ab := 0
 	if a != nil {
 		ab |= 1
@@ -1455,7 +1455,7 @@ func (w *exportWriter) elemList(list ir.Nodes) {
 	}
 }
 
-func (w *exportWriter) localName(n *ir.Node) {
+func (w *exportWriter) localName(n ir.Node) {
 	// Escape analysis happens after inline bodies are saved, but
 	// we're using the same ONAME nodes, so we might still see
 	// PAUTOHEAP here.
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 5d845d90e8..77078c118a 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -41,7 +41,7 @@ var (
 	inlineImporter = map[*types.Sym]iimporterAndOffset{}
 )
 
-func expandDecl(n *ir.Node) {
+func expandDecl(n ir.Node) {
 	if n.Op() != ir.ONONAME {
 		return
 	}
@@ -55,7 +55,7 @@ func expandDecl(n *ir.Node) {
 	r.doDecl(n)
 }
 
-func expandInline(fn *ir.Node) {
+func expandInline(fn ir.Node) {
 	if fn.Func().Inl.Body != nil {
 		return
 	}
@@ -68,7 +68,7 @@ func expandInline(fn *ir.Node) {
 	r.doInline(fn)
 }
 
-func importReaderFor(n *ir.Node, importers map[*types.Sym]iimporterAndOffset) *importReader {
+func importReaderFor(n ir.Node, importers map[*types.Sym]iimporterAndOffset) *importReader {
 	x, ok := importers[n.Sym()]
 	if !ok {
 		return nil
@@ -281,7 +281,7 @@ func (r *importReader) setPkg() {
 	r.currPkg = r.pkg()
 }
 
-func (r *importReader) doDecl(n *ir.Node) {
+func (r *importReader) doDecl(n ir.Node) {
 	if n.Op() != ir.ONONAME {
 		base.Fatalf("doDecl: unexpected Op for %v: %v", n.Sym(), n.Op())
 	}
@@ -635,12 +635,12 @@ func (r *importReader) byte() byte {
 
 // Compiler-specific extensions.
 
-func (r *importReader) varExt(n *ir.Node) {
+func (r *importReader) varExt(n ir.Node) {
 	r.linkname(n.Sym())
 	r.symIdx(n.Sym())
 }
 
-func (r *importReader) funcExt(n *ir.Node) {
+func (r *importReader) funcExt(n ir.Node) {
 	r.linkname(n.Sym())
 	r.symIdx(n.Sym())
 
@@ -695,7 +695,7 @@ func (r *importReader) typeExt(t *types.Type) {
 // so we can use index to reference the symbol.
 var typeSymIdx = make(map[*types.Type][2]int64)
 
-func (r *importReader) doInline(n *ir.Node) {
+func (r *importReader) doInline(n ir.Node) {
 	if len(n.Func().Inl.Body) != 0 {
 		base.Fatalf("%v already has inline body", n)
 	}
@@ -710,7 +710,7 @@ func (r *importReader) doInline(n *ir.Node) {
 		// (not doing so can cause significant performance
 		// degradation due to unnecessary calls to empty
 		// functions).
-		body = []*ir.Node{}
+		body = []ir.Node{}
 	}
 	n.Func().Inl.Body = body
 
@@ -740,8 +740,8 @@ func (r *importReader) doInline(n *ir.Node) {
 // unrefined nodes (since this is what the importer uses). The respective case
 // entries are unreachable in the importer.
 
-func (r *importReader) stmtList() []*ir.Node {
-	var list []*ir.Node
+func (r *importReader) stmtList() []ir.Node {
+	var list []ir.Node
 	for {
 		n := r.node()
 		if n == nil {
@@ -758,10 +758,10 @@ func (r *importReader) stmtList() []*ir.Node {
 	return list
 }
 
-func (r *importReader) caseList(sw *ir.Node) []*ir.Node {
+func (r *importReader) caseList(sw ir.Node) []ir.Node {
 	namedTypeSwitch := sw.Op() == ir.OSWITCH && sw.Left() != nil && sw.Left().Op() == ir.OTYPESW && sw.Left().Left() != nil
 
-	cases := make([]*ir.Node, r.uint64())
+	cases := make([]ir.Node, r.uint64())
 	for i := range cases {
 		cas := ir.NodAt(r.pos(), ir.OCASE, nil, nil)
 		cas.PtrList().Set(r.stmtList())
@@ -780,8 +780,8 @@ func (r *importReader) caseList(sw *ir.Node) []*ir.Node {
 	return cases
 }
 
-func (r *importReader) exprList() []*ir.Node {
-	var list []*ir.Node
+func (r *importReader) exprList() []ir.Node {
+	var list []ir.Node
 	for {
 		n := r.expr()
 		if n == nil {
@@ -792,7 +792,7 @@ func (r *importReader) exprList() []*ir.Node {
 	return list
 }
 
-func (r *importReader) expr() *ir.Node {
+func (r *importReader) expr() ir.Node {
 	n := r.node()
 	if n != nil && n.Op() == ir.OBLOCK {
 		base.Fatalf("unexpected block node: %v", n)
@@ -801,7 +801,7 @@ func (r *importReader) expr() *ir.Node {
 }
 
 // TODO(gri) split into expr and stmt
-func (r *importReader) node() *ir.Node {
+func (r *importReader) node() ir.Node {
 	switch op := r.op(); op {
 	// expressions
 	// case OPAREN:
@@ -814,7 +814,7 @@ func (r *importReader) node() *ir.Node {
 		pos := r.pos()
 		typ := r.typ()
 
-		var n *ir.Node
+		var n ir.Node
 		if typ.HasNil() {
 			n = nodnil()
 		} else {
@@ -906,7 +906,7 @@ func (r *importReader) node() *ir.Node {
 	case ir.OSLICE, ir.OSLICE3:
 		n := ir.NodAt(r.pos(), op, r.expr(), nil)
 		low, high := r.exprsOrNil()
-		var max *ir.Node
+		var max ir.Node
 		if n.Op().IsSlice3() {
 			max = r.expr()
 		}
@@ -970,7 +970,7 @@ func (r *importReader) node() *ir.Node {
 		pos := r.pos()
 		lhs := npos(pos, dclname(r.ident()))
 		typ := typenod(r.typ())
-		return npos(pos, liststmt(variter([]*ir.Node{lhs}, typ, nil))) // TODO(gri) avoid list creation
+		return npos(pos, liststmt(variter([]ir.Node{lhs}, typ, nil))) // TODO(gri) avoid list creation
 
 	// case ODCLFIELD:
 	//	unimplemented
@@ -1082,9 +1082,9 @@ func (r *importReader) op() ir.Op {
 	return ir.Op(r.uint64())
 }
 
-func (r *importReader) elemList() []*ir.Node {
+func (r *importReader) elemList() []ir.Node {
 	c := r.uint64()
-	list := make([]*ir.Node, c)
+	list := make([]ir.Node, c)
 	for i := range list {
 		s := r.ident()
 		list[i] = nodSym(ir.OSTRUCTKEY, r.expr(), s)
@@ -1092,7 +1092,7 @@ func (r *importReader) elemList() []*ir.Node {
 	return list
 }
 
-func (r *importReader) exprsOrNil() (a, b *ir.Node) {
+func (r *importReader) exprsOrNil() (a, b ir.Node) {
 	ab := r.uint64()
 	if ab&1 != 0 {
 		a = r.expr()
diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index 02a6175c6b..2b7ecd1d05 100644
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -33,7 +33,7 @@ func renameinit() *types.Sym {
 //   1) Initialize all of the packages the current package depends on.
 //   2) Initialize all the variables that have initializers.
 //   3) Run any init functions.
-func fninit(n []*ir.Node) {
+func fninit(n []ir.Node) {
 	nf := initOrder(n)
 
 	var deps []*obj.LSym // initTask records for packages the current package depends on
diff --git a/src/cmd/compile/internal/gc/initorder.go b/src/cmd/compile/internal/gc/initorder.go
index 71da72f0cf..1003f131b8 100644
--- a/src/cmd/compile/internal/gc/initorder.go
+++ b/src/cmd/compile/internal/gc/initorder.go
@@ -64,7 +64,7 @@ const (
 type InitOrder struct {
 	// blocking maps initialization assignments to the assignments
 	// that depend on it.
-	blocking map[*ir.Node][]*ir.Node
+	blocking map[ir.Node][]ir.Node
 
 	// ready is the queue of Pending initialization assignments
 	// that are ready for initialization.
@@ -75,13 +75,13 @@ type InitOrder struct {
 // package-level declarations (in declaration order) and outputs the
 // corresponding list of statements to include in the init() function
 // body.
-func initOrder(l []*ir.Node) []*ir.Node {
+func initOrder(l []ir.Node) []ir.Node {
 	s := InitSchedule{
-		initplans: make(map[*ir.Node]*InitPlan),
-		inittemps: make(map[*ir.Node]*ir.Node),
+		initplans: make(map[ir.Node]*InitPlan),
+		inittemps: make(map[ir.Node]ir.Node),
 	}
 	o := InitOrder{
-		blocking: make(map[*ir.Node][]*ir.Node),
+		blocking: make(map[ir.Node][]ir.Node),
 	}
 
 	// Process all package-level assignment in declaration order.
@@ -110,7 +110,7 @@ func initOrder(l []*ir.Node) []*ir.Node {
 				// first.
 				base.ExitIfErrors()
 
-				findInitLoopAndExit(firstLHS(n), new([]*ir.Node))
+				findInitLoopAndExit(firstLHS(n), new([]ir.Node))
 				base.Fatalf("initialization unfinished, but failed to identify loop")
 			}
 		}
@@ -125,7 +125,7 @@ func initOrder(l []*ir.Node) []*ir.Node {
 	return s.out
 }
 
-func (o *InitOrder) processAssign(n *ir.Node) {
+func (o *InitOrder) processAssign(n ir.Node) {
 	if n.Initorder() != InitNotStarted || n.Offset() != types.BADWIDTH {
 		base.Fatalf("unexpected state: %v, %v, %v", n, n.Initorder(), n.Offset())
 	}
@@ -154,9 +154,9 @@ func (o *InitOrder) processAssign(n *ir.Node) {
 // flushReady repeatedly applies initialize to the earliest (in
 // declaration order) assignment ready for initialization and updates
 // the inverse dependency ("blocking") graph.
-func (o *InitOrder) flushReady(initialize func(*ir.Node)) {
+func (o *InitOrder) flushReady(initialize func(ir.Node)) {
 	for o.ready.Len() != 0 {
-		n := heap.Pop(&o.ready).(*ir.Node)
+		n := heap.Pop(&o.ready).(ir.Node)
 		if n.Initorder() != InitPending || n.Offset() != 0 {
 			base.Fatalf("unexpected state: %v, %v, %v", n, n.Initorder(), n.Offset())
 		}
@@ -183,7 +183,7 @@ func (o *InitOrder) flushReady(initialize func(*ir.Node)) {
 // path points to a slice used for tracking the sequence of
 // variables/functions visited. Using a pointer to a slice allows the
 // slice capacity to grow and limit reallocations.
-func findInitLoopAndExit(n *ir.Node, path *[]*ir.Node) {
+func findInitLoopAndExit(n ir.Node, path *[]ir.Node) {
 	// We implement a simple DFS loop-finding algorithm. This
 	// could be faster, but initialization cycles are rare.
 
@@ -196,7 +196,7 @@ func findInitLoopAndExit(n *ir.Node, path *[]*ir.Node) {
 
 	// There might be multiple loops involving n; by sorting
 	// references, we deterministically pick the one reported.
-	refers := collectDeps(n.Name().Defn, false).Sorted(func(ni, nj *ir.Node) bool {
+	refers := collectDeps(n.Name().Defn, false).Sorted(func(ni, nj ir.Node) bool {
 		return ni.Pos().Before(nj.Pos())
 	})
 
@@ -215,7 +215,7 @@ func findInitLoopAndExit(n *ir.Node, path *[]*ir.Node) {
 // reportInitLoopAndExit reports and initialization loop as an error
 // and exits. However, if l is not actually an initialization loop, it
 // simply returns instead.
-func reportInitLoopAndExit(l []*ir.Node) {
+func reportInitLoopAndExit(l []ir.Node) {
 	// Rotate loop so that the earliest variable declaration is at
 	// the start.
 	i := -1
@@ -250,7 +250,7 @@ func reportInitLoopAndExit(l []*ir.Node) {
 // variables that declaration n depends on. If transitive is true,
 // then it also includes the transitive dependencies of any depended
 // upon functions (but not variables).
-func collectDeps(n *ir.Node, transitive bool) ir.NodeSet {
+func collectDeps(n ir.Node, transitive bool) ir.NodeSet {
 	d := initDeps{transitive: transitive}
 	switch n.Op() {
 	case ir.OAS:
@@ -270,12 +270,12 @@ type initDeps struct {
 	seen       ir.NodeSet
 }
 
-func (d *initDeps) inspect(n *ir.Node)     { ir.Inspect(n, d.visit) }
+func (d *initDeps) inspect(n ir.Node)      { ir.Inspect(n, d.visit) }
 func (d *initDeps) inspectList(l ir.Nodes) { ir.InspectList(l, d.visit) }
 
 // visit calls foundDep on any package-level functions or variables
 // referenced by n, if any.
-func (d *initDeps) visit(n *ir.Node) bool {
+func (d *initDeps) visit(n ir.Node) bool {
 	switch n.Op() {
 	case ir.OMETHEXPR:
 		d.foundDep(methodExprName(n))
@@ -299,7 +299,7 @@ func (d *initDeps) visit(n *ir.Node) bool {
 
 // foundDep records that we've found a dependency on n by adding it to
 // seen.
-func (d *initDeps) foundDep(n *ir.Node) {
+func (d *initDeps) foundDep(n ir.Node) {
 	// Can happen with method expressions involving interface
 	// types; e.g., fixedbugs/issue4495.go.
 	if n == nil {
@@ -328,7 +328,7 @@ func (d *initDeps) foundDep(n *ir.Node) {
 // an OAS node's Pos may not be unique. For example, given the
 // declaration "var a, b = f(), g()", "a" must be ordered before "b",
 // but both OAS nodes use the "=" token's position as their Pos.
-type declOrder []*ir.Node
+type declOrder []ir.Node
 
 func (s declOrder) Len() int { return len(s) }
 func (s declOrder) Less(i, j int) bool {
@@ -336,7 +336,7 @@ func (s declOrder) Less(i, j int) bool {
 }
 func (s declOrder) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
 
-func (s *declOrder) Push(x interface{}) { *s = append(*s, x.(*ir.Node)) }
+func (s *declOrder) Push(x interface{}) { *s = append(*s, x.(ir.Node)) }
 func (s *declOrder) Pop() interface{} {
 	n := (*s)[len(*s)-1]
 	*s = (*s)[:len(*s)-1]
@@ -345,7 +345,7 @@ func (s *declOrder) Pop() interface{} {
 
 // firstLHS returns the first expression on the left-hand side of
 // assignment n.
-func firstLHS(n *ir.Node) *ir.Node {
+func firstLHS(n ir.Node) ir.Node {
 	switch n.Op() {
 	case ir.OAS:
 		return n.Left()
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index f82c128265..6310762c1f 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -53,7 +53,7 @@ const (
 
 // Get the function's package. For ordinary functions it's on the ->sym, but for imported methods
 // the ->sym can be re-used in the local package, so peel it off the receiver's type.
-func fnpkg(fn *ir.Node) *types.Pkg {
+func fnpkg(fn ir.Node) *types.Pkg {
 	if ir.IsMethod(fn) {
 		// method
 		rcvr := fn.Type().Recv().Type
@@ -73,7 +73,7 @@ func fnpkg(fn *ir.Node) *types.Pkg {
 
 // Lazy typechecking of imported bodies. For local functions, caninl will set ->typecheck
 // because they're a copy of an already checked body.
-func typecheckinl(fn *ir.Node) {
+func typecheckinl(fn ir.Node) {
 	lno := setlineno(fn)
 
 	expandInline(fn)
@@ -111,7 +111,7 @@ func typecheckinl(fn *ir.Node) {
 // Caninl determines whether fn is inlineable.
 // If so, caninl saves fn->nbody in fn->inl and substitutes it with a copy.
 // fn and ->nbody will already have been typechecked.
-func caninl(fn *ir.Node) {
+func caninl(fn ir.Node) {
 	if fn.Op() != ir.ODCLFUNC {
 		base.Fatalf("caninl %v", fn)
 	}
@@ -207,7 +207,7 @@ func caninl(fn *ir.Node) {
 	visitor := hairyVisitor{
 		budget:        inlineMaxBudget,
 		extraCallCost: cc,
-		usedLocals:    make(map[*ir.Node]bool),
+		usedLocals:    make(map[ir.Node]bool),
 	}
 	if visitor.visitList(fn.Body()) {
 		reason = visitor.reason
@@ -236,7 +236,7 @@ func caninl(fn *ir.Node) {
 
 // inlFlood marks n's inline body for export and recursively ensures
 // all called functions are marked too.
-func inlFlood(n *ir.Node) {
+func inlFlood(n ir.Node) {
 	if n == nil {
 		return
 	}
@@ -260,7 +260,7 @@ func inlFlood(n *ir.Node) {
 	// Recursively identify all referenced functions for
 	// reexport. We want to include even non-called functions,
 	// because after inlining they might be callable.
-	ir.InspectList(ir.AsNodes(n.Func().Inl.Body), func(n *ir.Node) bool {
+	ir.InspectList(ir.AsNodes(n.Func().Inl.Body), func(n ir.Node) bool {
 		switch n.Op() {
 		case ir.OMETHEXPR:
 			inlFlood(methodExprName(n))
@@ -300,7 +300,7 @@ type hairyVisitor struct {
 	budget        int32
 	reason        string
 	extraCallCost int32
-	usedLocals    map[*ir.Node]bool
+	usedLocals    map[ir.Node]bool
 }
 
 // Look for anything we want to punt on.
@@ -313,7 +313,7 @@ func (v *hairyVisitor) visitList(ll ir.Nodes) bool {
 	return false
 }
 
-func (v *hairyVisitor) visit(n *ir.Node) bool {
+func (v *hairyVisitor) visit(n ir.Node) bool {
 	if n == nil {
 		return false
 	}
@@ -447,15 +447,15 @@ func (v *hairyVisitor) visit(n *ir.Node) bool {
 // inlcopylist (together with inlcopy) recursively copies a list of nodes, except
 // that it keeps the same ONAME, OTYPE, and OLITERAL nodes. It is used for copying
 // the body and dcls of an inlineable function.
-func inlcopylist(ll []*ir.Node) []*ir.Node {
-	s := make([]*ir.Node, 0, len(ll))
+func inlcopylist(ll []ir.Node) []ir.Node {
+	s := make([]ir.Node, 0, len(ll))
 	for _, n := range ll {
 		s = append(s, inlcopy(n))
 	}
 	return s
 }
 
-func inlcopy(n *ir.Node) *ir.Node {
+func inlcopy(n ir.Node) ir.Node {
 	if n == nil {
 		return nil
 	}
@@ -479,7 +479,7 @@ func inlcopy(n *ir.Node) *ir.Node {
 	return m
 }
 
-func countNodes(n *ir.Node) int {
+func countNodes(n ir.Node) int {
 	if n == nil {
 		return 0
 	}
@@ -503,7 +503,7 @@ func countNodes(n *ir.Node) int {
 
 // Inlcalls/nodelist/node walks fn's statements and expressions and substitutes any
 // calls made to inlineable functions. This is the external entry point.
-func inlcalls(fn *ir.Node) {
+func inlcalls(fn ir.Node) {
 	savefn := Curfn
 	Curfn = fn
 	maxCost := int32(inlineMaxBudget)
@@ -516,7 +516,7 @@ func inlcalls(fn *ir.Node) {
 	// but allow inlining if there is a recursion cycle of many functions.
 	// Most likely, the inlining will stop before we even hit the beginning of
 	// the cycle again, but the map catches the unusual case.
-	inlMap := make(map[*ir.Node]bool)
+	inlMap := make(map[ir.Node]bool)
 	fn = inlnode(fn, maxCost, inlMap)
 	if fn != Curfn {
 		base.Fatalf("inlnode replaced curfn")
@@ -525,7 +525,7 @@ func inlcalls(fn *ir.Node) {
 }
 
 // Turn an OINLCALL into a statement.
-func inlconv2stmt(n *ir.Node) {
+func inlconv2stmt(n ir.Node) {
 	n.SetOp(ir.OBLOCK)
 
 	// n->ninit stays
@@ -538,7 +538,7 @@ func inlconv2stmt(n *ir.Node) {
 // Turn an OINLCALL into a single valued expression.
 // The result of inlconv2expr MUST be assigned back to n, e.g.
 // 	n.Left = inlconv2expr(n.Left)
-func inlconv2expr(n *ir.Node) *ir.Node {
+func inlconv2expr(n ir.Node) ir.Node {
 	r := n.Rlist().First()
 	return addinit(r, append(n.Init().Slice(), n.Body().Slice()...))
 }
@@ -548,7 +548,7 @@ func inlconv2expr(n *ir.Node) *ir.Node {
 // containing the inlined statements on the first list element so
 // order will be preserved Used in return, oas2func and call
 // statements.
-func inlconv2list(n *ir.Node) []*ir.Node {
+func inlconv2list(n ir.Node) []ir.Node {
 	if n.Op() != ir.OINLCALL || n.Rlist().Len() == 0 {
 		base.Fatalf("inlconv2list %+v\n", n)
 	}
@@ -558,7 +558,7 @@ func inlconv2list(n *ir.Node) []*ir.Node {
 	return s
 }
 
-func inlnodelist(l ir.Nodes, maxCost int32, inlMap map[*ir.Node]bool) {
+func inlnodelist(l ir.Nodes, maxCost int32, inlMap map[ir.Node]bool) {
 	s := l.Slice()
 	for i := range s {
 		s[i] = inlnode(s[i], maxCost, inlMap)
@@ -578,7 +578,7 @@ func inlnodelist(l ir.Nodes, maxCost int32, inlMap map[*ir.Node]bool) {
 // shorter and less complicated.
 // The result of inlnode MUST be assigned back to n, e.g.
 // 	n.Left = inlnode(n.Left)
-func inlnode(n *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node {
+func inlnode(n ir.Node, maxCost int32, inlMap map[ir.Node]bool) ir.Node {
 	if n == nil {
 		return n
 	}
@@ -707,7 +707,7 @@ func inlnode(n *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node {
 
 // inlCallee takes a function-typed expression and returns the underlying function ONAME
 // that it refers to if statically known. Otherwise, it returns nil.
-func inlCallee(fn *ir.Node) *ir.Node {
+func inlCallee(fn ir.Node) ir.Node {
 	fn = staticValue(fn)
 	switch {
 	case fn.Op() == ir.OMETHEXPR:
@@ -729,7 +729,7 @@ func inlCallee(fn *ir.Node) *ir.Node {
 	return nil
 }
 
-func staticValue(n *ir.Node) *ir.Node {
+func staticValue(n ir.Node) ir.Node {
 	for {
 		if n.Op() == ir.OCONVNOP {
 			n = n.Left()
@@ -747,7 +747,7 @@ func staticValue(n *ir.Node) *ir.Node {
 // staticValue1 implements a simple SSA-like optimization. If n is a local variable
 // that is initialized and never reassigned, staticValue1 returns the initializer
 // expression. Otherwise, it returns nil.
-func staticValue1(n *ir.Node) *ir.Node {
+func staticValue1(n ir.Node) ir.Node {
 	if n.Op() != ir.ONAME || n.Class() != ir.PAUTO || n.Name().Addrtaken() {
 		return nil
 	}
@@ -757,7 +757,7 @@ func staticValue1(n *ir.Node) *ir.Node {
 		return nil
 	}
 
-	var rhs *ir.Node
+	var rhs ir.Node
 FindRHS:
 	switch defn.Op() {
 	case ir.OAS:
@@ -791,7 +791,7 @@ FindRHS:
 // useful for -m output documenting the reason for inhibited optimizations.
 // NB: global variables are always considered to be re-assigned.
 // TODO: handle initial declaration not including an assignment and followed by a single assignment?
-func reassigned(n *ir.Node) (bool, *ir.Node) {
+func reassigned(n ir.Node) (bool, ir.Node) {
 	if n.Op() != ir.ONAME {
 		base.Fatalf("reassigned %v", n)
 	}
@@ -814,10 +814,10 @@ func reassigned(n *ir.Node) (bool, *ir.Node) {
 }
 
 type reassignVisitor struct {
-	name *ir.Node
+	name ir.Node
 }
 
-func (v *reassignVisitor) visit(n *ir.Node) *ir.Node {
+func (v *reassignVisitor) visit(n ir.Node) ir.Node {
 	if n == nil {
 		return nil
 	}
@@ -854,7 +854,7 @@ func (v *reassignVisitor) visit(n *ir.Node) *ir.Node {
 	return nil
 }
 
-func (v *reassignVisitor) visitList(l ir.Nodes) *ir.Node {
+func (v *reassignVisitor) visitList(l ir.Nodes) ir.Node {
 	for _, n := range l.Slice() {
 		if a := v.visit(n); a != nil {
 			return a
@@ -863,7 +863,7 @@ func (v *reassignVisitor) visitList(l ir.Nodes) *ir.Node {
 	return nil
 }
 
-func inlParam(t *types.Field, as *ir.Node, inlvars map[*ir.Node]*ir.Node) *ir.Node {
+func inlParam(t *types.Field, as ir.Node, inlvars map[ir.Node]ir.Node) ir.Node {
 	n := ir.AsNode(t.Nname)
 	if n == nil || ir.IsBlank(n) {
 		return ir.BlankNode
@@ -887,7 +887,7 @@ var inlgen int
 // parameters.
 // The result of mkinlcall MUST be assigned back to n, e.g.
 // 	n.Left = mkinlcall(n.Left, fn, isddd)
-func mkinlcall(n, fn *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node {
+func mkinlcall(n, fn ir.Node, maxCost int32, inlMap map[ir.Node]bool) ir.Node {
 	if fn.Func().Inl == nil {
 		if logopt.Enabled() {
 			logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", ir.FuncName(Curfn),
@@ -969,10 +969,10 @@ func mkinlcall(n, fn *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node
 	}
 
 	// Make temp names to use instead of the originals.
-	inlvars := make(map[*ir.Node]*ir.Node)
+	inlvars := make(map[ir.Node]ir.Node)
 
 	// record formals/locals for later post-processing
-	var inlfvars []*ir.Node
+	var inlfvars []ir.Node
 
 	// Handle captured variables when inlining closures.
 	if fn.Name().Defn != nil {
@@ -1040,7 +1040,7 @@ func mkinlcall(n, fn *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node
 	}
 
 	nreturns := 0
-	ir.InspectList(ir.AsNodes(fn.Func().Inl.Body), func(n *ir.Node) bool {
+	ir.InspectList(ir.AsNodes(fn.Func().Inl.Body), func(n ir.Node) bool {
 		if n != nil && n.Op() == ir.ORETURN {
 			nreturns++
 		}
@@ -1053,9 +1053,9 @@ func mkinlcall(n, fn *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node
 	delayretvars := nreturns == 1
 
 	// temporaries for return values.
-	var retvars []*ir.Node
+	var retvars []ir.Node
 	for i, t := range fn.Type().Results().Fields().Slice() {
-		var m *ir.Node
+		var m ir.Node
 		if n := ir.AsNode(t.Nname); n != nil && !ir.IsBlank(n) && !strings.HasPrefix(n.Sym().Name, "~r") {
 			m = inlvar(n)
 			m = typecheck(m, ctxExpr)
@@ -1093,7 +1093,7 @@ func mkinlcall(n, fn *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node
 
 	// For non-dotted calls to variadic functions, we assign the
 	// variadic parameter's temp name separately.
-	var vas *ir.Node
+	var vas ir.Node
 
 	if recv := fn.Type().Recv(); recv != nil {
 		as.PtrList().Append(inlParam(recv, as, inlvars))
@@ -1228,7 +1228,7 @@ func mkinlcall(n, fn *ir.Node, maxCost int32, inlMap map[*ir.Node]bool) *ir.Node
 // Every time we expand a function we generate a new set of tmpnames,
 // PAUTO's in the calling functions, and link them off of the
 // PPARAM's, PAUTOS and PPARAMOUTs of the called function.
-func inlvar(var_ *ir.Node) *ir.Node {
+func inlvar(var_ ir.Node) ir.Node {
 	if base.Flag.LowerM > 3 {
 		fmt.Printf("inlvar %+v\n", var_)
 	}
@@ -1245,7 +1245,7 @@ func inlvar(var_ *ir.Node) *ir.Node {
 }
 
 // Synthesize a variable to store the inlined function's results in.
-func retvar(t *types.Field, i int) *ir.Node {
+func retvar(t *types.Field, i int) ir.Node {
 	n := NewName(lookupN("~R", i))
 	n.SetType(t.Type)
 	n.SetClass(ir.PAUTO)
@@ -1257,7 +1257,7 @@ func retvar(t *types.Field, i int) *ir.Node {
 
 // Synthesize a variable to store the inlined function's arguments
 // when they come from a multiple return call.
-func argvar(t *types.Type, i int) *ir.Node {
+func argvar(t *types.Type, i int) ir.Node {
 	n := NewName(lookupN("~arg", i))
 	n.SetType(t.Elem())
 	n.SetClass(ir.PAUTO)
@@ -1274,13 +1274,13 @@ type inlsubst struct {
 	retlabel *types.Sym
 
 	// Temporary result variables.
-	retvars []*ir.Node
+	retvars []ir.Node
 
 	// Whether result variables should be initialized at the
 	// "return" statement.
 	delayretvars bool
 
-	inlvars map[*ir.Node]*ir.Node
+	inlvars map[ir.Node]ir.Node
 
 	// bases maps from original PosBase to PosBase with an extra
 	// inlined call frame.
@@ -1292,8 +1292,8 @@ type inlsubst struct {
 }
 
 // list inlines a list of nodes.
-func (subst *inlsubst) list(ll ir.Nodes) []*ir.Node {
-	s := make([]*ir.Node, 0, ll.Len())
+func (subst *inlsubst) list(ll ir.Nodes) []ir.Node {
+	s := make([]ir.Node, 0, ll.Len())
 	for _, n := range ll.Slice() {
 		s = append(s, subst.node(n))
 	}
@@ -1304,7 +1304,7 @@ func (subst *inlsubst) list(ll ir.Nodes) []*ir.Node {
 // inlined function, substituting references to input/output
 // parameters with ones to the tmpnames, and substituting returns with
 // assignments to the output.
-func (subst *inlsubst) node(n *ir.Node) *ir.Node {
+func (subst *inlsubst) node(n ir.Node) ir.Node {
 	if n == nil {
 		return nil
 	}
@@ -1409,8 +1409,8 @@ func (subst *inlsubst) updatedPos(xpos src.XPos) src.XPos {
 	return base.Ctxt.PosTable.XPos(pos)
 }
 
-func pruneUnusedAutos(ll []*ir.Node, vis *hairyVisitor) []*ir.Node {
-	s := make([]*ir.Node, 0, len(ll))
+func pruneUnusedAutos(ll []ir.Node, vis *hairyVisitor) []ir.Node {
+	s := make([]ir.Node, 0, len(ll))
 	for _, n := range ll {
 		if n.Class() == ir.PAUTO {
 			if _, found := vis.usedLocals[n]; !found {
@@ -1424,9 +1424,9 @@ func pruneUnusedAutos(ll []*ir.Node, vis *hairyVisitor) []*ir.Node {
 
 // devirtualize replaces interface method calls within fn with direct
 // concrete-type method calls where applicable.
-func devirtualize(fn *ir.Node) {
+func devirtualize(fn ir.Node) {
 	Curfn = fn
-	ir.InspectList(fn.Body(), func(n *ir.Node) bool {
+	ir.InspectList(fn.Body(), func(n ir.Node) bool {
 		if n.Op() == ir.OCALLINTER {
 			devirtualizeCall(n)
 		}
@@ -1434,7 +1434,7 @@ func devirtualize(fn *ir.Node) {
 	})
 }
 
-func devirtualizeCall(call *ir.Node) {
+func devirtualizeCall(call ir.Node) {
 	recv := staticValue(call.Left().Left())
 	if recv.Op() != ir.OCONVIFACE {
 		return
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index a7d605f3ba..30ee57c02d 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -330,7 +330,7 @@ func Main(archInit func(*Arch)) {
 
 	if base.Flag.LowerL != 0 {
 		// Find functions that can be inlined and clone them before walk expands them.
-		visitBottomUp(xtop, func(list []*ir.Node, recursive bool) {
+		visitBottomUp(xtop, func(list []ir.Node, recursive bool) {
 			numfns := numNonClosures(list)
 			for _, n := range list {
 				if !recursive || numfns > 1 {
@@ -481,7 +481,7 @@ func Main(archInit func(*Arch)) {
 }
 
 // numNonClosures returns the number of functions in list which are not closures.
-func numNonClosures(list []*ir.Node) int {
+func numNonClosures(list []ir.Node) int {
 	count := 0
 	for _, n := range list {
 		if n.Func().OClosure == nil {
diff --git a/src/cmd/compile/internal/gc/mkbuiltin.go b/src/cmd/compile/internal/gc/mkbuiltin.go
index 8fa6d02f2c..d763f1ebee 100644
--- a/src/cmd/compile/internal/gc/mkbuiltin.go
+++ b/src/cmd/compile/internal/gc/mkbuiltin.go
@@ -207,7 +207,7 @@ func (i *typeInterner) fields(fl *ast.FieldList, keepNames bool) string {
 			}
 		}
 	}
-	return fmt.Sprintf("[]*ir.Node{%s}", strings.Join(res, ", "))
+	return fmt.Sprintf("[]ir.Node{%s}", strings.Join(res, ", "))
 }
 
 func intconst(e ast.Expr) int64 {
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index d9642f4b67..950d509047 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -152,7 +152,7 @@ type noder struct {
 	lastCloseScopePos syntax.Pos
 }
 
-func (p *noder) funcBody(fn *ir.Node, block *syntax.BlockStmt) {
+func (p *noder) funcBody(fn ir.Node, block *syntax.BlockStmt) {
 	oldScope := p.scope
 	p.scope = 0
 	funchdr(fn)
@@ -160,7 +160,7 @@ func (p *noder) funcBody(fn *ir.Node, block *syntax.BlockStmt) {
 	if block != nil {
 		body := p.stmts(block.List)
 		if body == nil {
-			body = []*ir.Node{ir.Nod(ir.OEMPTY, nil, nil)}
+			body = []ir.Node{ir.Nod(ir.OEMPTY, nil, nil)}
 		}
 		fn.PtrBody().Set(body)
 
@@ -294,7 +294,7 @@ func (p *noder) node() {
 	clearImports()
 }
 
-func (p *noder) decls(decls []syntax.Decl) (l []*ir.Node) {
+func (p *noder) decls(decls []syntax.Decl) (l []ir.Node) {
 	var cs constState
 
 	for _, decl := range decls {
@@ -378,11 +378,11 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
 	my.Block = 1 // at top level
 }
 
-func (p *noder) varDecl(decl *syntax.VarDecl) []*ir.Node {
+func (p *noder) varDecl(decl *syntax.VarDecl) []ir.Node {
 	names := p.declNames(decl.NameList)
 	typ := p.typeExprOrNil(decl.Type)
 
-	var exprs []*ir.Node
+	var exprs []ir.Node
 	if decl.Values != nil {
 		exprs = p.exprList(decl.Values)
 	}
@@ -414,12 +414,12 @@ func (p *noder) varDecl(decl *syntax.VarDecl) []*ir.Node {
 // constant declarations are handled correctly (e.g., issue 15550).
 type constState struct {
 	group  *syntax.Group
-	typ    *ir.Node
-	values []*ir.Node
+	typ    ir.Node
+	values []ir.Node
 	iota   int64
 }
 
-func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []*ir.Node {
+func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []ir.Node {
 	if decl.Group == nil || decl.Group != cs.group {
 		*cs = constState{
 			group: decl.Group,
@@ -433,7 +433,7 @@ func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []*ir.Node {
 	names := p.declNames(decl.NameList)
 	typ := p.typeExprOrNil(decl.Type)
 
-	var values []*ir.Node
+	var values []ir.Node
 	if decl.Values != nil {
 		values = p.exprList(decl.Values)
 		cs.typ, cs.values = typ, values
@@ -444,7 +444,7 @@ func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []*ir.Node {
 		typ, values = cs.typ, cs.values
 	}
 
-	nn := make([]*ir.Node, 0, len(names))
+	nn := make([]ir.Node, 0, len(names))
 	for i, n := range names {
 		if i >= len(values) {
 			base.Errorf("missing value in const declaration")
@@ -474,7 +474,7 @@ func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []*ir.Node {
 	return nn
 }
 
-func (p *noder) typeDecl(decl *syntax.TypeDecl) *ir.Node {
+func (p *noder) typeDecl(decl *syntax.TypeDecl) ir.Node {
 	n := p.declName(decl.Name)
 	n.SetOp(ir.OTYPE)
 	declare(n, dclcontext)
@@ -500,21 +500,21 @@ func (p *noder) typeDecl(decl *syntax.TypeDecl) *ir.Node {
 	return nod
 }
 
-func (p *noder) declNames(names []*syntax.Name) []*ir.Node {
-	nodes := make([]*ir.Node, 0, len(names))
+func (p *noder) declNames(names []*syntax.Name) []ir.Node {
+	nodes := make([]ir.Node, 0, len(names))
 	for _, name := range names {
 		nodes = append(nodes, p.declName(name))
 	}
 	return nodes
 }
 
-func (p *noder) declName(name *syntax.Name) *ir.Node {
+func (p *noder) declName(name *syntax.Name) ir.Node {
 	n := dclname(p.name(name))
 	n.SetPos(p.pos(name))
 	return n
 }
 
-func (p *noder) funcDecl(fun *syntax.FuncDecl) *ir.Node {
+func (p *noder) funcDecl(fun *syntax.FuncDecl) ir.Node {
 	name := p.name(fun.Name)
 	t := p.signature(fun.Recv, fun.Type)
 	f := p.nod(fun, ir.ODCLFUNC, nil, nil)
@@ -580,7 +580,7 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) *ir.Node {
 	return f
 }
 
-func (p *noder) signature(recv *syntax.Field, typ *syntax.FuncType) *ir.Node {
+func (p *noder) signature(recv *syntax.Field, typ *syntax.FuncType) ir.Node {
 	n := p.nod(typ, ir.OTFUNC, nil, nil)
 	if recv != nil {
 		n.SetLeft(p.param(recv, false, false))
@@ -590,8 +590,8 @@ func (p *noder) signature(recv *syntax.Field, typ *syntax.FuncType) *ir.Node {
 	return n
 }
 
-func (p *noder) params(params []*syntax.Field, dddOk bool) []*ir.Node {
-	nodes := make([]*ir.Node, 0, len(params))
+func (p *noder) params(params []*syntax.Field, dddOk bool) []ir.Node {
+	nodes := make([]ir.Node, 0, len(params))
 	for i, param := range params {
 		p.setlineno(param)
 		nodes = append(nodes, p.param(param, dddOk, i+1 == len(params)))
@@ -599,7 +599,7 @@ func (p *noder) params(params []*syntax.Field, dddOk bool) []*ir.Node {
 	return nodes
 }
 
-func (p *noder) param(param *syntax.Field, dddOk, final bool) *ir.Node {
+func (p *noder) param(param *syntax.Field, dddOk, final bool) ir.Node {
 	var name *types.Sym
 	if param.Name != nil {
 		name = p.name(param.Name)
@@ -633,22 +633,22 @@ func (p *noder) param(param *syntax.Field, dddOk, final bool) *ir.Node {
 	return n
 }
 
-func (p *noder) exprList(expr syntax.Expr) []*ir.Node {
+func (p *noder) exprList(expr syntax.Expr) []ir.Node {
 	if list, ok := expr.(*syntax.ListExpr); ok {
 		return p.exprs(list.ElemList)
 	}
-	return []*ir.Node{p.expr(expr)}
+	return []ir.Node{p.expr(expr)}
 }
 
-func (p *noder) exprs(exprs []syntax.Expr) []*ir.Node {
-	nodes := make([]*ir.Node, 0, len(exprs))
+func (p *noder) exprs(exprs []syntax.Expr) []ir.Node {
+	nodes := make([]ir.Node, 0, len(exprs))
 	for _, expr := range exprs {
 		nodes = append(nodes, p.expr(expr))
 	}
 	return nodes
 }
 
-func (p *noder) expr(expr syntax.Expr) *ir.Node {
+func (p *noder) expr(expr syntax.Expr) ir.Node {
 	p.setlineno(expr)
 	switch expr := expr.(type) {
 	case nil, *syntax.BadExpr:
@@ -699,7 +699,7 @@ func (p *noder) expr(expr syntax.Expr) *ir.Node {
 			op = ir.OSLICE3
 		}
 		n := p.nod(expr, op, p.expr(expr.X), nil)
-		var index [3]*ir.Node
+		var index [3]ir.Node
 		for i, x := range &expr.Index {
 			if x != nil {
 				index[i] = p.expr(x)
@@ -725,7 +725,7 @@ func (p *noder) expr(expr syntax.Expr) *ir.Node {
 		return n
 
 	case *syntax.ArrayType:
-		var len *ir.Node
+		var len ir.Node
 		if expr.Len != nil {
 			len = p.expr(expr.Len)
 		} else {
@@ -765,7 +765,7 @@ func (p *noder) expr(expr syntax.Expr) *ir.Node {
 // sum efficiently handles very large summation expressions (such as
 // in issue #16394). In particular, it avoids left recursion and
 // collapses string literals.
-func (p *noder) sum(x syntax.Expr) *ir.Node {
+func (p *noder) sum(x syntax.Expr) ir.Node {
 	// While we need to handle long sums with asymptotic
 	// efficiency, the vast majority of sums are very small: ~95%
 	// have only 2 or 3 operands, and ~99% of string literals are
@@ -800,7 +800,7 @@ func (p *noder) sum(x syntax.Expr) *ir.Node {
 	// handle correctly. For now, we avoid these problems by
 	// treating named string constants the same as non-constant
 	// operands.
-	var nstr *ir.Node
+	var nstr ir.Node
 	chunks := make([]string, 0, 1)
 
 	n := p.expr(x)
@@ -838,12 +838,12 @@ func (p *noder) sum(x syntax.Expr) *ir.Node {
 	return n
 }
 
-func (p *noder) typeExpr(typ syntax.Expr) *ir.Node {
+func (p *noder) typeExpr(typ syntax.Expr) ir.Node {
 	// TODO(mdempsky): Be stricter? typecheck should handle errors anyway.
 	return p.expr(typ)
 }
 
-func (p *noder) typeExprOrNil(typ syntax.Expr) *ir.Node {
+func (p *noder) typeExprOrNil(typ syntax.Expr) ir.Node {
 	if typ != nil {
 		return p.expr(typ)
 	}
@@ -862,11 +862,11 @@ func (p *noder) chanDir(dir syntax.ChanDir) types.ChanDir {
 	panic("unhandled ChanDir")
 }
 
-func (p *noder) structType(expr *syntax.StructType) *ir.Node {
-	l := make([]*ir.Node, 0, len(expr.FieldList))
+func (p *noder) structType(expr *syntax.StructType) ir.Node {
+	l := make([]ir.Node, 0, len(expr.FieldList))
 	for i, field := range expr.FieldList {
 		p.setlineno(field)
-		var n *ir.Node
+		var n ir.Node
 		if field.Name == nil {
 			n = p.embedded(field.Type)
 		} else {
@@ -884,11 +884,11 @@ func (p *noder) structType(expr *syntax.StructType) *ir.Node {
 	return n
 }
 
-func (p *noder) interfaceType(expr *syntax.InterfaceType) *ir.Node {
-	l := make([]*ir.Node, 0, len(expr.MethodList))
+func (p *noder) interfaceType(expr *syntax.InterfaceType) ir.Node {
+	l := make([]ir.Node, 0, len(expr.MethodList))
 	for _, method := range expr.MethodList {
 		p.setlineno(method)
-		var n *ir.Node
+		var n ir.Node
 		if method.Name == nil {
 			n = p.nodSym(method, ir.ODCLFIELD, importName(p.packname(method.Type)), nil)
 		} else {
@@ -934,7 +934,7 @@ func (p *noder) packname(expr syntax.Expr) *types.Sym {
 	panic(fmt.Sprintf("unexpected packname: %#v", expr))
 }
 
-func (p *noder) embedded(typ syntax.Expr) *ir.Node {
+func (p *noder) embedded(typ syntax.Expr) ir.Node {
 	op, isStar := typ.(*syntax.Operation)
 	if isStar {
 		if op.Op != syntax.Mul || op.Y != nil {
@@ -953,12 +953,12 @@ func (p *noder) embedded(typ syntax.Expr) *ir.Node {
 	return n
 }
 
-func (p *noder) stmts(stmts []syntax.Stmt) []*ir.Node {
+func (p *noder) stmts(stmts []syntax.Stmt) []ir.Node {
 	return p.stmtsFall(stmts, false)
 }
 
-func (p *noder) stmtsFall(stmts []syntax.Stmt, fallOK bool) []*ir.Node {
-	var nodes []*ir.Node
+func (p *noder) stmtsFall(stmts []syntax.Stmt, fallOK bool) []ir.Node {
+	var nodes []ir.Node
 	for i, stmt := range stmts {
 		s := p.stmtFall(stmt, fallOK && i+1 == len(stmts))
 		if s == nil {
@@ -971,11 +971,11 @@ func (p *noder) stmtsFall(stmts []syntax.Stmt, fallOK bool) []*ir.Node {
 	return nodes
 }
 
-func (p *noder) stmt(stmt syntax.Stmt) *ir.Node {
+func (p *noder) stmt(stmt syntax.Stmt) ir.Node {
 	return p.stmtFall(stmt, false)
 }
 
-func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) *ir.Node {
+func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) ir.Node {
 	p.setlineno(stmt)
 	switch stmt := stmt.(type) {
 	case *syntax.EmptyStmt:
@@ -1053,7 +1053,7 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) *ir.Node {
 		}
 		return p.nod(stmt, op, p.expr(stmt.Call), nil)
 	case *syntax.ReturnStmt:
-		var results []*ir.Node
+		var results []ir.Node
 		if stmt.Results != nil {
 			results = p.exprList(stmt.Results)
 		}
@@ -1085,7 +1085,7 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) *ir.Node {
 	panic("unhandled Stmt")
 }
 
-func (p *noder) assignList(expr syntax.Expr, defn *ir.Node, colas bool) []*ir.Node {
+func (p *noder) assignList(expr syntax.Expr, defn ir.Node, colas bool) []ir.Node {
 	if !colas {
 		return p.exprList(expr)
 	}
@@ -1099,7 +1099,7 @@ func (p *noder) assignList(expr syntax.Expr, defn *ir.Node, colas bool) []*ir.No
 		exprs = []syntax.Expr{expr}
 	}
 
-	res := make([]*ir.Node, len(exprs))
+	res := make([]ir.Node, len(exprs))
 	seen := make(map[*types.Sym]bool, len(exprs))
 
 	newOrErr := false
@@ -1145,14 +1145,14 @@ func (p *noder) assignList(expr syntax.Expr, defn *ir.Node, colas bool) []*ir.No
 	return res
 }
 
-func (p *noder) blockStmt(stmt *syntax.BlockStmt) []*ir.Node {
+func (p *noder) blockStmt(stmt *syntax.BlockStmt) []ir.Node {
 	p.openScope(stmt.Pos())
 	nodes := p.stmts(stmt.List)
 	p.closeScope(stmt.Rbrace)
 	return nodes
 }
 
-func (p *noder) ifStmt(stmt *syntax.IfStmt) *ir.Node {
+func (p *noder) ifStmt(stmt *syntax.IfStmt) ir.Node {
 	p.openScope(stmt.Pos())
 	n := p.nod(stmt, ir.OIF, nil, nil)
 	if stmt.Init != nil {
@@ -1174,9 +1174,9 @@ func (p *noder) ifStmt(stmt *syntax.IfStmt) *ir.Node {
 	return n
 }
 
-func (p *noder) forStmt(stmt *syntax.ForStmt) *ir.Node {
+func (p *noder) forStmt(stmt *syntax.ForStmt) ir.Node {
 	p.openScope(stmt.Pos())
-	var n *ir.Node
+	var n ir.Node
 	if r, ok := stmt.Init.(*syntax.RangeClause); ok {
 		if stmt.Cond != nil || stmt.Post != nil {
 			panic("unexpected RangeClause")
@@ -1203,7 +1203,7 @@ func (p *noder) forStmt(stmt *syntax.ForStmt) *ir.Node {
 	return n
 }
 
-func (p *noder) switchStmt(stmt *syntax.SwitchStmt) *ir.Node {
+func (p *noder) switchStmt(stmt *syntax.SwitchStmt) ir.Node {
 	p.openScope(stmt.Pos())
 	n := p.nod(stmt, ir.OSWITCH, nil, nil)
 	if stmt.Init != nil {
@@ -1223,8 +1223,8 @@ func (p *noder) switchStmt(stmt *syntax.SwitchStmt) *ir.Node {
 	return n
 }
 
-func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *ir.Node, rbrace syntax.Pos) []*ir.Node {
-	nodes := make([]*ir.Node, 0, len(clauses))
+func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch ir.Node, rbrace syntax.Pos) []ir.Node {
+	nodes := make([]ir.Node, 0, len(clauses))
 	for i, clause := range clauses {
 		p.setlineno(clause)
 		if i > 0 {
@@ -1273,14 +1273,14 @@ func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *ir.Node, rbra
 	return nodes
 }
 
-func (p *noder) selectStmt(stmt *syntax.SelectStmt) *ir.Node {
+func (p *noder) selectStmt(stmt *syntax.SelectStmt) ir.Node {
 	n := p.nod(stmt, ir.OSELECT, nil, nil)
 	n.PtrList().Set(p.commClauses(stmt.Body, stmt.Rbrace))
 	return n
 }
 
-func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []*ir.Node {
-	nodes := make([]*ir.Node, 0, len(clauses))
+func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []ir.Node {
+	nodes := make([]ir.Node, 0, len(clauses))
 	for i, clause := range clauses {
 		p.setlineno(clause)
 		if i > 0 {
@@ -1301,16 +1301,16 @@ func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []*
 	return nodes
 }
 
-func (p *noder) labeledStmt(label *syntax.LabeledStmt, fallOK bool) *ir.Node {
+func (p *noder) labeledStmt(label *syntax.LabeledStmt, fallOK bool) ir.Node {
 	lhs := p.nodSym(label, ir.OLABEL, nil, p.name(label.Label))
 
-	var ls *ir.Node
+	var ls ir.Node
 	if label.Stmt != nil { // TODO(mdempsky): Should always be present.
 		ls = p.stmtFall(label.Stmt, fallOK)
 	}
 
 	lhs.Name().Defn = ls
-	l := []*ir.Node{lhs}
+	l := []ir.Node{lhs}
 	if ls != nil {
 		if ls.Op() == ir.OBLOCK && ls.Init().Len() == 0 {
 			l = append(l, ls.List().Slice()...)
@@ -1443,12 +1443,12 @@ func (p *noder) name(name *syntax.Name) *types.Sym {
 	return lookup(name.Value)
 }
 
-func (p *noder) mkname(name *syntax.Name) *ir.Node {
+func (p *noder) mkname(name *syntax.Name) ir.Node {
 	// TODO(mdempsky): Set line number?
 	return mkname(p.name(name))
 }
 
-func (p *noder) wrapname(n syntax.Node, x *ir.Node) *ir.Node {
+func (p *noder) wrapname(n syntax.Node, x ir.Node) ir.Node {
 	// These nodes do not carry line numbers.
 	// Introduce a wrapper node to give them the correct line.
 	switch x.Op() {
@@ -1464,11 +1464,11 @@ func (p *noder) wrapname(n syntax.Node, x *ir.Node) *ir.Node {
 	return x
 }
 
-func (p *noder) nod(orig syntax.Node, op ir.Op, left, right *ir.Node) *ir.Node {
+func (p *noder) nod(orig syntax.Node, op ir.Op, left, right ir.Node) ir.Node {
 	return ir.NodAt(p.pos(orig), op, left, right)
 }
 
-func (p *noder) nodSym(orig syntax.Node, op ir.Op, left *ir.Node, sym *types.Sym) *ir.Node {
+func (p *noder) nodSym(orig syntax.Node, op ir.Op, left ir.Node, sym *types.Sym) ir.Node {
 	n := nodSym(op, left, sym)
 	n.SetPos(p.pos(orig))
 	return n
@@ -1668,7 +1668,7 @@ func safeArg(name string) bool {
 	return '0' <= c && c <= '9' || 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || c == '.' || c == '_' || c == '/' || c >= utf8.RuneSelf
 }
 
-func mkname(sym *types.Sym) *ir.Node {
+func mkname(sym *types.Sym) ir.Node {
 	n := oldname(sym)
 	if n.Name() != nil && n.Name().Pack != nil {
 		n.Name().Pack.Name().SetUsed(true)
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 05f8358fdf..d566959d9e 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -228,7 +228,7 @@ func addptabs() {
 	}
 }
 
-func dumpGlobal(n *ir.Node) {
+func dumpGlobal(n ir.Node) {
 	if n.Type() == nil {
 		base.Fatalf("external %v nil type\n", n)
 	}
@@ -242,7 +242,7 @@ func dumpGlobal(n *ir.Node) {
 	ggloblnod(n)
 }
 
-func dumpGlobalConst(n *ir.Node) {
+func dumpGlobalConst(n ir.Node) {
 	// only export typed constants
 	t := n.Type()
 	if t == nil {
@@ -475,7 +475,7 @@ func fileStringSym(pos src.XPos, file string, readonly bool, hash []byte) (*obj.
 
 var slicedataGen int
 
-func slicedata(pos src.XPos, s string) *ir.Node {
+func slicedata(pos src.XPos, s string) ir.Node {
 	slicedataGen++
 	symname := fmt.Sprintf(".gobytes.%d", slicedataGen)
 	sym := ir.LocalPkg.Lookup(symname)
@@ -489,7 +489,7 @@ func slicedata(pos src.XPos, s string) *ir.Node {
 	return symnode
 }
 
-func slicebytes(nam *ir.Node, s string) {
+func slicebytes(nam ir.Node, s string) {
 	if nam.Op() != ir.ONAME {
 		base.Fatalf("slicebytes %v", nam)
 	}
@@ -530,7 +530,7 @@ func dsymptrWeakOff(s *obj.LSym, off int, x *obj.LSym) int {
 
 // slicesym writes a static slice symbol {&arr, lencap, lencap} to n.
 // arr must be an ONAME. slicesym does not modify n.
-func slicesym(n, arr *ir.Node, lencap int64) {
+func slicesym(n, arr ir.Node, lencap int64) {
 	s := n.Sym().Linksym()
 	off := n.Offset()
 	if arr.Op() != ir.ONAME {
@@ -543,7 +543,7 @@ func slicesym(n, arr *ir.Node, lencap int64) {
 
 // addrsym writes the static address of a to n. a must be an ONAME.
 // Neither n nor a is modified.
-func addrsym(n, a *ir.Node) {
+func addrsym(n, a ir.Node) {
 	if n.Op() != ir.ONAME {
 		base.Fatalf("addrsym n op %v", n.Op())
 	}
@@ -559,7 +559,7 @@ func addrsym(n, a *ir.Node) {
 
 // pfuncsym writes the static address of f to n. f must be a global function.
 // Neither n nor f is modified.
-func pfuncsym(n, f *ir.Node) {
+func pfuncsym(n, f ir.Node) {
 	if n.Op() != ir.ONAME {
 		base.Fatalf("pfuncsym n op %v", n.Op())
 	}
@@ -575,7 +575,7 @@ func pfuncsym(n, f *ir.Node) {
 
 // litsym writes the static literal c to n.
 // Neither n nor c is modified.
-func litsym(n, c *ir.Node, wid int) {
+func litsym(n, c ir.Node, wid int) {
 	if n.Op() != ir.ONAME {
 		base.Fatalf("litsym n op %v", n.Op())
 	}
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 36a4095640..b7d713439b 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -44,27 +44,27 @@ import (
 
 // Order holds state during the ordering process.
 type Order struct {
-	out  []*ir.Node            // list of generated statements
-	temp []*ir.Node            // stack of temporary variables
-	free map[string][]*ir.Node // free list of unused temporaries, by type.LongString().
+	out  []ir.Node            // list of generated statements
+	temp []ir.Node            // stack of temporary variables
+	free map[string][]ir.Node // free list of unused temporaries, by type.LongString().
 }
 
 // Order rewrites fn.Nbody to apply the ordering constraints
 // described in the comment at the top of the file.
-func order(fn *ir.Node) {
+func order(fn ir.Node) {
 	if base.Flag.W > 1 {
 		s := fmt.Sprintf("\nbefore order %v", fn.Func().Nname.Sym())
 		ir.DumpList(s, fn.Body())
 	}
 
-	orderBlock(fn.PtrBody(), map[string][]*ir.Node{})
+	orderBlock(fn.PtrBody(), map[string][]ir.Node{})
 }
 
 // newTemp allocates a new temporary with the given type,
 // pushes it onto the temp stack, and returns it.
 // If clear is true, newTemp emits code to zero the temporary.
-func (o *Order) newTemp(t *types.Type, clear bool) *ir.Node {
-	var v *ir.Node
+func (o *Order) newTemp(t *types.Type, clear bool) ir.Node {
+	var v ir.Node
 	// Note: LongString is close to the type equality we want,
 	// but not exactly. We still need to double-check with types.Identical.
 	key := t.LongString()
@@ -103,7 +103,7 @@ func (o *Order) newTemp(t *types.Type, clear bool) *ir.Node {
 // (The other candidate would be map access, but map access
 // returns a pointer to the result data instead of taking a pointer
 // to be filled in.)
-func (o *Order) copyExpr(n *ir.Node, t *types.Type, clear bool) *ir.Node {
+func (o *Order) copyExpr(n ir.Node, t *types.Type, clear bool) ir.Node {
 	v := o.newTemp(t, clear)
 	a := ir.Nod(ir.OAS, v, n)
 	a = typecheck(a, ctxStmt)
@@ -115,7 +115,7 @@ func (o *Order) copyExpr(n *ir.Node, t *types.Type, clear bool) *ir.Node {
 // The definition of cheap is that n is a variable or constant.
 // If not, cheapExpr allocates a new tmp, emits tmp = n,
 // and then returns tmp.
-func (o *Order) cheapExpr(n *ir.Node) *ir.Node {
+func (o *Order) cheapExpr(n ir.Node) ir.Node {
 	if n == nil {
 		return nil
 	}
@@ -143,7 +143,7 @@ func (o *Order) cheapExpr(n *ir.Node) *ir.Node {
 // as assigning to the original n.
 //
 // The intended use is to apply to x when rewriting x += y into x = x + y.
-func (o *Order) safeExpr(n *ir.Node) *ir.Node {
+func (o *Order) safeExpr(n ir.Node) ir.Node {
 	switch n.Op() {
 	case ir.ONAME, ir.OLITERAL, ir.ONIL:
 		return n
@@ -167,7 +167,7 @@ func (o *Order) safeExpr(n *ir.Node) *ir.Node {
 		return typecheck(a, ctxExpr)
 
 	case ir.OINDEX, ir.OINDEXMAP:
-		var l *ir.Node
+		var l ir.Node
 		if n.Left().Type().IsArray() {
 			l = o.safeExpr(n.Left())
 		} else {
@@ -194,7 +194,7 @@ func (o *Order) safeExpr(n *ir.Node) *ir.Node {
 // of ordinary stack variables, those are not 'isaddrokay'. Temporaries are okay,
 // because we emit explicit VARKILL instructions marking the end of those
 // temporaries' lifetimes.
-func isaddrokay(n *ir.Node) bool {
+func isaddrokay(n ir.Node) bool {
 	return islvalue(n) && (n.Op() != ir.ONAME || n.Class() == ir.PEXTERN || ir.IsAutoTmp(n))
 }
 
@@ -203,7 +203,7 @@ func isaddrokay(n *ir.Node) bool {
 // tmp = n, and then returns tmp.
 // The result of addrTemp MUST be assigned back to n, e.g.
 // 	n.Left = o.addrTemp(n.Left)
-func (o *Order) addrTemp(n *ir.Node) *ir.Node {
+func (o *Order) addrTemp(n ir.Node) ir.Node {
 	if n.Op() == ir.OLITERAL || n.Op() == ir.ONIL {
 		// TODO: expand this to all static composite literal nodes?
 		n = defaultlit(n, nil)
@@ -225,7 +225,7 @@ func (o *Order) addrTemp(n *ir.Node) *ir.Node {
 
 // mapKeyTemp prepares n to be a key in a map runtime call and returns n.
 // It should only be used for map runtime calls which have *_fast* versions.
-func (o *Order) mapKeyTemp(t *types.Type, n *ir.Node) *ir.Node {
+func (o *Order) mapKeyTemp(t *types.Type, n ir.Node) ir.Node {
 	// Most map calls need to take the address of the key.
 	// Exception: map*_fast* calls. See golang.org/issue/19015.
 	if mapfast(t) == mapslow {
@@ -248,7 +248,7 @@ func (o *Order) mapKeyTemp(t *types.Type, n *ir.Node) *ir.Node {
 // It would be nice to handle these generally, but because
 // []byte keys are not allowed in maps, the use of string(k)
 // comes up in important cases in practice. See issue 3512.
-func mapKeyReplaceStrConv(n *ir.Node) bool {
+func mapKeyReplaceStrConv(n ir.Node) bool {
 	var replaced bool
 	switch n.Op() {
 	case ir.OBYTES2STR:
@@ -293,8 +293,8 @@ func (o *Order) popTemp(mark ordermarker) {
 // cleanTempNoPop emits VARKILL instructions to *out
 // for each temporary above the mark on the temporary stack.
 // It does not pop the temporaries from the stack.
-func (o *Order) cleanTempNoPop(mark ordermarker) []*ir.Node {
-	var out []*ir.Node
+func (o *Order) cleanTempNoPop(mark ordermarker) []ir.Node {
+	var out []ir.Node
 	for i := len(o.temp) - 1; i >= int(mark); i-- {
 		n := o.temp[i]
 		kill := ir.Nod(ir.OVARKILL, n, nil)
@@ -324,7 +324,7 @@ func (o *Order) stmtList(l ir.Nodes) {
 //  m = OMAKESLICE([]T, x); OCOPY(m, s)
 // and rewrites it to:
 //  m = OMAKESLICECOPY([]T, x, s); nil
-func orderMakeSliceCopy(s []*ir.Node) {
+func orderMakeSliceCopy(s []ir.Node) {
 	if base.Flag.N != 0 || instrumenting {
 		return
 	}
@@ -406,7 +406,7 @@ func (o *Order) edge() {
 // orderBlock orders the block of statements in n into a new slice,
 // and then replaces the old slice in n with the new slice.
 // free is a map that can be used to obtain temporary variables by type.
-func orderBlock(n *ir.Nodes, free map[string][]*ir.Node) {
+func orderBlock(n *ir.Nodes, free map[string][]ir.Node) {
 	var order Order
 	order.free = free
 	mark := order.markTemp()
@@ -420,7 +420,7 @@ func orderBlock(n *ir.Nodes, free map[string][]*ir.Node) {
 // leaves them as the init list of the final *np.
 // The result of exprInPlace MUST be assigned back to n, e.g.
 // 	n.Left = o.exprInPlace(n.Left)
-func (o *Order) exprInPlace(n *ir.Node) *ir.Node {
+func (o *Order) exprInPlace(n ir.Node) ir.Node {
 	var order Order
 	order.free = o.free
 	n = order.expr(n, nil)
@@ -437,7 +437,7 @@ func (o *Order) exprInPlace(n *ir.Node) *ir.Node {
 // The result of orderStmtInPlace MUST be assigned back to n, e.g.
 // 	n.Left = orderStmtInPlace(n.Left)
 // free is a map that can be used to obtain temporary variables by type.
-func orderStmtInPlace(n *ir.Node, free map[string][]*ir.Node) *ir.Node {
+func orderStmtInPlace(n ir.Node, free map[string][]ir.Node) ir.Node {
 	var order Order
 	order.free = free
 	mark := order.markTemp()
@@ -447,7 +447,7 @@ func orderStmtInPlace(n *ir.Node, free map[string][]*ir.Node) *ir.Node {
 }
 
 // init moves n's init list to o.out.
-func (o *Order) init(n *ir.Node) {
+func (o *Order) init(n ir.Node) {
 	if ir.MayBeShared(n) {
 		// For concurrency safety, don't mutate potentially shared nodes.
 		// First, ensure that no work is required here.
@@ -462,7 +462,7 @@ func (o *Order) init(n *ir.Node) {
 
 // call orders the call expression n.
 // n.Op is OCALLMETH/OCALLFUNC/OCALLINTER or a builtin like OCOPY.
-func (o *Order) call(n *ir.Node) {
+func (o *Order) call(n ir.Node) {
 	if n.Init().Len() > 0 {
 		// Caller should have already called o.init(n).
 		base.Fatalf("%v with unexpected ninit", n.Op())
@@ -483,7 +483,7 @@ func (o *Order) call(n *ir.Node) {
 	if n.Op() == ir.OCALLINTER {
 		return
 	}
-	keepAlive := func(arg *ir.Node) {
+	keepAlive := func(arg ir.Node) {
 		// If the argument is really a pointer being converted to uintptr,
 		// arrange for the pointer to be kept alive until the call returns,
 		// by copying it into a temp and marking that temp
@@ -525,7 +525,7 @@ func (o *Order) call(n *ir.Node) {
 // cases they are also typically registerizable, so not much harm done.
 // And this only applies to the multiple-assignment form.
 // We could do a more precise analysis if needed, like in walk.go.
-func (o *Order) mapAssign(n *ir.Node) {
+func (o *Order) mapAssign(n ir.Node) {
 	switch n.Op() {
 	default:
 		base.Fatalf("order.mapAssign %v", n.Op())
@@ -546,7 +546,7 @@ func (o *Order) mapAssign(n *ir.Node) {
 		o.out = append(o.out, n)
 
 	case ir.OAS2, ir.OAS2DOTTYPE, ir.OAS2MAPR, ir.OAS2FUNC:
-		var post []*ir.Node
+		var post []ir.Node
 		for i, m := range n.List().Slice() {
 			switch {
 			case m.Op() == ir.OINDEXMAP:
@@ -574,7 +574,7 @@ func (o *Order) mapAssign(n *ir.Node) {
 // stmt orders the statement n, appending to o.out.
 // Temporaries created during the statement are cleaned
 // up using VARKILL instructions as possible.
-func (o *Order) stmt(n *ir.Node) {
+func (o *Order) stmt(n ir.Node) {
 	if n == nil {
 		return
 	}
@@ -1022,7 +1022,7 @@ func (o *Order) stmt(n *ir.Node) {
 	base.Pos = lno
 }
 
-func hasDefaultCase(n *ir.Node) bool {
+func hasDefaultCase(n ir.Node) bool {
 	for _, ncas := range n.List().Slice() {
 		if ncas.Op() != ir.OCASE {
 			base.Fatalf("expected case, found %v", ncas.Op())
@@ -1052,7 +1052,7 @@ func (o *Order) exprListInPlace(l ir.Nodes) {
 }
 
 // prealloc[x] records the allocation to use for x.
-var prealloc = map[*ir.Node]*ir.Node{}
+var prealloc = map[ir.Node]ir.Node{}
 
 // expr orders a single expression, appending side
 // effects to o.out as needed.
@@ -1061,7 +1061,7 @@ var prealloc = map[*ir.Node]*ir.Node{}
 // to avoid copying the result of the expression to a temporary.)
 // The result of expr MUST be assigned back to n, e.g.
 // 	n.Left = o.expr(n.Left, lhs)
-func (o *Order) expr(n, lhs *ir.Node) *ir.Node {
+func (o *Order) expr(n, lhs ir.Node) ir.Node {
 	if n == nil {
 		return n
 	}
@@ -1329,7 +1329,7 @@ func (o *Order) expr(n, lhs *ir.Node) *ir.Node {
 		// See issue 26552.
 		entries := n.List().Slice()
 		statics := entries[:0]
-		var dynamics []*ir.Node
+		var dynamics []ir.Node
 		for _, r := range entries {
 			if r.Op() != ir.OKEY {
 				base.Fatalf("OMAPLIT entry not OKEY: %v\n", r)
@@ -1377,7 +1377,7 @@ func (o *Order) expr(n, lhs *ir.Node) *ir.Node {
 
 // okas creates and returns an assignment of val to ok,
 // including an explicit conversion if necessary.
-func okas(ok, val *ir.Node) *ir.Node {
+func okas(ok, val ir.Node) ir.Node {
 	if !ir.IsBlank(ok) {
 		val = conv(val, ok.Type())
 	}
@@ -1392,9 +1392,9 @@ func okas(ok, val *ir.Node) *ir.Node {
 //	tmp1, tmp2, tmp3 = ...
 // 	a, b, a = tmp1, tmp2, tmp3
 // This is necessary to ensure left to right assignment order.
-func (o *Order) as2(n *ir.Node) {
-	tmplist := []*ir.Node{}
-	left := []*ir.Node{}
+func (o *Order) as2(n ir.Node) {
+	tmplist := []ir.Node{}
+	left := []ir.Node{}
 	for ni, l := range n.List().Slice() {
 		if !ir.IsBlank(l) {
 			tmp := o.newTemp(l.Type(), l.Type().HasPointers())
@@ -1415,8 +1415,8 @@ func (o *Order) as2(n *ir.Node) {
 
 // okAs2 orders OAS2XXX with ok.
 // Just like as2, this also adds temporaries to ensure left-to-right assignment.
-func (o *Order) okAs2(n *ir.Node) {
-	var tmp1, tmp2 *ir.Node
+func (o *Order) okAs2(n ir.Node) {
+	var tmp1, tmp2 ir.Node
 	if !ir.IsBlank(n.List().First()) {
 		typ := n.Right().Type()
 		tmp1 = o.newTemp(typ, typ.HasPointers())
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index 5827b5a7a6..221b733a07 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -24,10 +24,10 @@ import (
 // "Portable" code generation.
 
 var (
-	compilequeue []*ir.Node // functions waiting to be compiled
+	compilequeue []ir.Node // functions waiting to be compiled
 )
 
-func emitptrargsmap(fn *ir.Node) {
+func emitptrargsmap(fn ir.Node) {
 	if ir.FuncName(fn) == "_" || fn.Func().Nname.Sym().Linkname != "" {
 		return
 	}
@@ -68,7 +68,7 @@ func emitptrargsmap(fn *ir.Node) {
 // really means, in memory, things with pointers needing zeroing at
 // the top of the stack and increasing in size.
 // Non-autos sort on offset.
-func cmpstackvarlt(a, b *ir.Node) bool {
+func cmpstackvarlt(a, b ir.Node) bool {
 	if (a.Class() == ir.PAUTO) != (b.Class() == ir.PAUTO) {
 		return b.Class() == ir.PAUTO
 	}
@@ -101,7 +101,7 @@ func cmpstackvarlt(a, b *ir.Node) bool {
 }
 
 // byStackvar implements sort.Interface for []*Node using cmpstackvarlt.
-type byStackVar []*ir.Node
+type byStackVar []ir.Node
 
 func (s byStackVar) Len() int           { return len(s) }
 func (s byStackVar) Less(i, j int) bool { return cmpstackvarlt(s[i], s[j]) }
@@ -128,7 +128,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 	scratchUsed := false
 	for _, b := range f.Blocks {
 		for _, v := range b.Values {
-			if n, ok := v.Aux.(*ir.Node); ok {
+			if n, ok := v.Aux.(ir.Node); ok {
 				switch n.Class() {
 				case ir.PPARAM, ir.PPARAMOUT:
 					// Don't modify nodfp; it is a global.
@@ -193,7 +193,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 	s.stkptrsize = Rnd(s.stkptrsize, int64(Widthreg))
 }
 
-func funccompile(fn *ir.Node) {
+func funccompile(fn ir.Node) {
 	if Curfn != nil {
 		base.Fatalf("funccompile %v inside %v", fn.Func().Nname.Sym(), Curfn.Func().Nname.Sym())
 	}
@@ -224,7 +224,7 @@ func funccompile(fn *ir.Node) {
 	dclcontext = ir.PEXTERN
 }
 
-func compile(fn *ir.Node) {
+func compile(fn ir.Node) {
 	errorsBefore := base.Errors()
 	order(fn)
 	if base.Errors() > errorsBefore {
@@ -284,7 +284,7 @@ func compile(fn *ir.Node) {
 // If functions are not compiled immediately,
 // they are enqueued in compilequeue,
 // which is drained by compileFunctions.
-func compilenow(fn *ir.Node) bool {
+func compilenow(fn ir.Node) bool {
 	// Issue 38068: if this function is a method AND an inline
 	// candidate AND was not inlined (yet), put it onto the compile
 	// queue instead of compiling it immediately. This is in case we
@@ -299,7 +299,7 @@ func compilenow(fn *ir.Node) bool {
 // isInlinableButNotInlined returns true if 'fn' was marked as an
 // inline candidate but then never inlined (presumably because we
 // found no call sites).
-func isInlinableButNotInlined(fn *ir.Node) bool {
+func isInlinableButNotInlined(fn ir.Node) bool {
 	if fn.Func().Nname.Func().Inl == nil {
 		return false
 	}
@@ -315,7 +315,7 @@ const maxStackSize = 1 << 30
 // uses it to generate a plist,
 // and flushes that plist to machine code.
 // worker indicates which of the backend workers is doing the processing.
-func compileSSA(fn *ir.Node, worker int) {
+func compileSSA(fn ir.Node, worker int) {
 	f := buildssa(fn, worker)
 	// Note: check arg size to fix issue 25507.
 	if f.Frontend().(*ssafn).stksize >= maxStackSize || fn.Type().ArgWidth() >= maxStackSize {
@@ -360,7 +360,7 @@ func compileFunctions() {
 		sizeCalculationDisabled = true // not safe to calculate sizes concurrently
 		if race.Enabled {
 			// Randomize compilation order to try to shake out races.
-			tmp := make([]*ir.Node, len(compilequeue))
+			tmp := make([]ir.Node, len(compilequeue))
 			perm := rand.Perm(len(compilequeue))
 			for i, v := range perm {
 				tmp[v] = compilequeue[i]
@@ -376,7 +376,7 @@ func compileFunctions() {
 		}
 		var wg sync.WaitGroup
 		base.Ctxt.InParallel = true
-		c := make(chan *ir.Node, base.Flag.LowerC)
+		c := make(chan ir.Node, base.Flag.LowerC)
 		for i := 0; i < base.Flag.LowerC; i++ {
 			wg.Add(1)
 			go func(worker int) {
@@ -398,7 +398,7 @@ func compileFunctions() {
 }
 
 func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.Scope, dwarf.InlCalls) {
-	fn := curfn.(*ir.Node)
+	fn := curfn.(ir.Node)
 	if fn.Func().Nname != nil {
 		if expect := fn.Func().Nname.Sym().Linksym(); fnsym != expect {
 			base.Fatalf("unexpected fnsym: %v != %v", fnsym, expect)
@@ -432,7 +432,7 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 	// Deciding the right answer is, as they say, future work.
 	isODCLFUNC := fn.Op() == ir.ODCLFUNC
 
-	var apdecls []*ir.Node
+	var apdecls []ir.Node
 	// Populate decls for fn.
 	if isODCLFUNC {
 		for _, n := range fn.Func().Dcl {
@@ -489,7 +489,7 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 	return scopes, inlcalls
 }
 
-func declPos(decl *ir.Node) src.XPos {
+func declPos(decl ir.Node) src.XPos {
 	if decl.Name().Defn != nil && (decl.Name().Captured() || decl.Name().Byval()) {
 		// It's not clear which position is correct for captured variables here:
 		// * decl.Pos is the wrong position for captured variables, in the inner
@@ -512,10 +512,10 @@ func declPos(decl *ir.Node) src.XPos {
 
 // createSimpleVars creates a DWARF entry for every variable declared in the
 // function, claiming that they are permanently on the stack.
-func createSimpleVars(fnsym *obj.LSym, apDecls []*ir.Node) ([]*ir.Node, []*dwarf.Var, map[*ir.Node]bool) {
+func createSimpleVars(fnsym *obj.LSym, apDecls []ir.Node) ([]ir.Node, []*dwarf.Var, map[ir.Node]bool) {
 	var vars []*dwarf.Var
-	var decls []*ir.Node
-	selected := make(map[*ir.Node]bool)
+	var decls []ir.Node
+	selected := make(map[ir.Node]bool)
 	for _, n := range apDecls {
 		if ir.IsAutoTmp(n) {
 			continue
@@ -528,7 +528,7 @@ func createSimpleVars(fnsym *obj.LSym, apDecls []*ir.Node) ([]*ir.Node, []*dwarf
 	return decls, vars, selected
 }
 
-func createSimpleVar(fnsym *obj.LSym, n *ir.Node) *dwarf.Var {
+func createSimpleVar(fnsym *obj.LSym, n ir.Node) *dwarf.Var {
 	var abbrev int
 	offs := n.Offset()
 
@@ -579,13 +579,13 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Node) *dwarf.Var {
 
 // createComplexVars creates recomposed DWARF vars with location lists,
 // suitable for describing optimized code.
-func createComplexVars(fnsym *obj.LSym, fn *ir.Func) ([]*ir.Node, []*dwarf.Var, map[*ir.Node]bool) {
+func createComplexVars(fnsym *obj.LSym, fn *ir.Func) ([]ir.Node, []*dwarf.Var, map[ir.Node]bool) {
 	debugInfo := fn.DebugInfo.(*ssa.FuncDebug)
 
 	// Produce a DWARF variable entry for each user variable.
-	var decls []*ir.Node
+	var decls []ir.Node
 	var vars []*dwarf.Var
-	ssaVars := make(map[*ir.Node]bool)
+	ssaVars := make(map[ir.Node]bool)
 
 	for varID, dvar := range debugInfo.Vars {
 		n := dvar
@@ -605,11 +605,11 @@ func createComplexVars(fnsym *obj.LSym, fn *ir.Func) ([]*ir.Node, []*dwarf.Var,
 
 // createDwarfVars process fn, returning a list of DWARF variables and the
 // Nodes they represent.
-func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir.Node) ([]*ir.Node, []*dwarf.Var) {
+func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []ir.Node) ([]ir.Node, []*dwarf.Var) {
 	// Collect a raw list of DWARF vars.
 	var vars []*dwarf.Var
-	var decls []*ir.Node
-	var selected map[*ir.Node]bool
+	var decls []ir.Node
+	var selected map[ir.Node]bool
 	if base.Ctxt.Flag_locationlists && base.Ctxt.Flag_optimize && fn.DebugInfo != nil && complexOK {
 		decls, vars, selected = createComplexVars(fnsym, fn)
 	} else {
@@ -708,9 +708,9 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 // function that is not local to the package being compiled, then the
 // names of the variables may have been "versioned" to avoid conflicts
 // with local vars; disregard this versioning when sorting.
-func preInliningDcls(fnsym *obj.LSym) []*ir.Node {
-	fn := base.Ctxt.DwFixups.GetPrecursorFunc(fnsym).(*ir.Node)
-	var rdcl []*ir.Node
+func preInliningDcls(fnsym *obj.LSym) []ir.Node {
+	fn := base.Ctxt.DwFixups.GetPrecursorFunc(fnsym).(ir.Node)
+	var rdcl []ir.Node
 	for _, n := range fn.Func().Inl.Dcl {
 		c := n.Sym().Name[0]
 		// Avoid reporting "_" parameters, since if there are more than
diff --git a/src/cmd/compile/internal/gc/pgen_test.go b/src/cmd/compile/internal/gc/pgen_test.go
index efdffe0256..1984f9aa08 100644
--- a/src/cmd/compile/internal/gc/pgen_test.go
+++ b/src/cmd/compile/internal/gc/pgen_test.go
@@ -26,19 +26,19 @@ func typeWithPointers() *types.Type {
 	return t
 }
 
-func markUsed(n *ir.Node) *ir.Node {
+func markUsed(n ir.Node) ir.Node {
 	n.Name().SetUsed(true)
 	return n
 }
 
-func markNeedZero(n *ir.Node) *ir.Node {
+func markNeedZero(n ir.Node) ir.Node {
 	n.Name().SetNeedzero(true)
 	return n
 }
 
 // Test all code paths for cmpstackvarlt.
 func TestCmpstackvar(t *testing.T) {
-	nod := func(xoffset int64, t *types.Type, s *types.Sym, cl ir.Class) *ir.Node {
+	nod := func(xoffset int64, t *types.Type, s *types.Sym, cl ir.Class) ir.Node {
 		if s == nil {
 			s = &types.Sym{Name: "."}
 		}
@@ -49,7 +49,7 @@ func TestCmpstackvar(t *testing.T) {
 		return n
 	}
 	testdata := []struct {
-		a, b *ir.Node
+		a, b ir.Node
 		lt   bool
 	}{
 		{
@@ -156,14 +156,14 @@ func TestCmpstackvar(t *testing.T) {
 }
 
 func TestStackvarSort(t *testing.T) {
-	nod := func(xoffset int64, t *types.Type, s *types.Sym, cl ir.Class) *ir.Node {
+	nod := func(xoffset int64, t *types.Type, s *types.Sym, cl ir.Class) ir.Node {
 		n := NewName(s)
 		n.SetType(t)
 		n.SetOffset(xoffset)
 		n.SetClass(cl)
 		return n
 	}
-	inp := []*ir.Node{
+	inp := []ir.Node{
 		nod(0, &types.Type{}, &types.Sym{}, ir.PFUNC),
 		nod(0, &types.Type{}, &types.Sym{}, ir.PAUTO),
 		nod(0, &types.Type{}, &types.Sym{}, ir.PFUNC),
@@ -178,7 +178,7 @@ func TestStackvarSort(t *testing.T) {
 		nod(0, &types.Type{}, &types.Sym{Name: "abc"}, ir.PAUTO),
 		nod(0, &types.Type{}, &types.Sym{Name: "xyz"}, ir.PAUTO),
 	}
-	want := []*ir.Node{
+	want := []ir.Node{
 		nod(0, &types.Type{}, &types.Sym{}, ir.PFUNC),
 		nod(0, &types.Type{}, &types.Sym{}, ir.PFUNC),
 		nod(10, &types.Type{}, &types.Sym{}, ir.PFUNC),
diff --git a/src/cmd/compile/internal/gc/phi.go b/src/cmd/compile/internal/gc/phi.go
index 2a88d4a5b4..677bfc92df 100644
--- a/src/cmd/compile/internal/gc/phi.go
+++ b/src/cmd/compile/internal/gc/phi.go
@@ -41,11 +41,11 @@ func (s *state) insertPhis() {
 }
 
 type phiState struct {
-	s       *state                    // SSA state
-	f       *ssa.Func                 // function to work on
-	defvars []map[*ir.Node]*ssa.Value // defined variables at end of each block
+	s       *state                   // SSA state
+	f       *ssa.Func                // function to work on
+	defvars []map[ir.Node]*ssa.Value // defined variables at end of each block
 
-	varnum map[*ir.Node]int32 // variable numbering
+	varnum map[ir.Node]int32 // variable numbering
 
 	// properties of the dominator tree
 	idom  []*ssa.Block // dominator parents
@@ -71,15 +71,15 @@ func (s *phiState) insertPhis() {
 	// Find all the variables for which we need to match up reads & writes.
 	// This step prunes any basic-block-only variables from consideration.
 	// Generate a numbering for these variables.
-	s.varnum = map[*ir.Node]int32{}
-	var vars []*ir.Node
+	s.varnum = map[ir.Node]int32{}
+	var vars []ir.Node
 	var vartypes []*types.Type
 	for _, b := range s.f.Blocks {
 		for _, v := range b.Values {
 			if v.Op != ssa.OpFwdRef {
 				continue
 			}
-			var_ := v.Aux.(*ir.Node)
+			var_ := v.Aux.(ir.Node)
 
 			// Optimization: look back 1 block for the definition.
 			if len(b.Preds) == 1 {
@@ -184,7 +184,7 @@ levels:
 	}
 }
 
-func (s *phiState) insertVarPhis(n int, var_ *ir.Node, defs []*ssa.Block, typ *types.Type) {
+func (s *phiState) insertVarPhis(n int, var_ ir.Node, defs []*ssa.Block, typ *types.Type) {
 	priq := &s.priq
 	q := s.q
 	queued := s.queued
@@ -319,7 +319,7 @@ func (s *phiState) resolveFwdRefs() {
 			if v.Op != ssa.OpFwdRef {
 				continue
 			}
-			n := s.varnum[v.Aux.(*ir.Node)]
+			n := s.varnum[v.Aux.(ir.Node)]
 			v.Op = ssa.OpCopy
 			v.Aux = nil
 			v.AddArg(values[n])
@@ -433,11 +433,11 @@ func (s *sparseSet) clear() {
 
 // Variant to use for small functions.
 type simplePhiState struct {
-	s         *state                    // SSA state
-	f         *ssa.Func                 // function to work on
-	fwdrefs   []*ssa.Value              // list of FwdRefs to be processed
-	defvars   []map[*ir.Node]*ssa.Value // defined variables at end of each block
-	reachable []bool                    // which blocks are reachable
+	s         *state                   // SSA state
+	f         *ssa.Func                // function to work on
+	fwdrefs   []*ssa.Value             // list of FwdRefs to be processed
+	defvars   []map[ir.Node]*ssa.Value // defined variables at end of each block
+	reachable []bool                   // which blocks are reachable
 }
 
 func (s *simplePhiState) insertPhis() {
@@ -450,7 +450,7 @@ func (s *simplePhiState) insertPhis() {
 				continue
 			}
 			s.fwdrefs = append(s.fwdrefs, v)
-			var_ := v.Aux.(*ir.Node)
+			var_ := v.Aux.(ir.Node)
 			if _, ok := s.defvars[b.ID][var_]; !ok {
 				s.defvars[b.ID][var_] = v // treat FwdDefs as definitions.
 			}
@@ -464,7 +464,7 @@ loop:
 		v := s.fwdrefs[len(s.fwdrefs)-1]
 		s.fwdrefs = s.fwdrefs[:len(s.fwdrefs)-1]
 		b := v.Block
-		var_ := v.Aux.(*ir.Node)
+		var_ := v.Aux.(ir.Node)
 		if b == s.f.Entry {
 			// No variable should be live at entry.
 			s.s.Fatalf("Value live at entry. It shouldn't be. func %s, node %v, value %v", s.f.Name, var_, v)
@@ -512,7 +512,7 @@ loop:
 }
 
 // lookupVarOutgoing finds the variable's value at the end of block b.
-func (s *simplePhiState) lookupVarOutgoing(b *ssa.Block, t *types.Type, var_ *ir.Node, line src.XPos) *ssa.Value {
+func (s *simplePhiState) lookupVarOutgoing(b *ssa.Block, t *types.Type, var_ ir.Node, line src.XPos) *ssa.Value {
 	for {
 		if v := s.defvars[b.ID][var_]; v != nil {
 			return v
diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/gc/plive.go
index c1e523f7a0..bd7696d859 100644
--- a/src/cmd/compile/internal/gc/plive.go
+++ b/src/cmd/compile/internal/gc/plive.go
@@ -101,10 +101,10 @@ type BlockEffects struct {
 
 // A collection of global state used by liveness analysis.
 type Liveness struct {
-	fn         *ir.Node
+	fn         ir.Node
 	f          *ssa.Func
-	vars       []*ir.Node
-	idx        map[*ir.Node]int32
+	vars       []ir.Node
+	idx        map[ir.Node]int32
 	stkptrsize int64
 
 	be []BlockEffects
@@ -206,20 +206,20 @@ type progeffectscache struct {
 // nor do we care about non-local variables,
 // nor do we care about empty structs (handled by the pointer check),
 // nor do we care about the fake PAUTOHEAP variables.
-func livenessShouldTrack(n *ir.Node) bool {
+func livenessShouldTrack(n ir.Node) bool {
 	return n.Op() == ir.ONAME && (n.Class() == ir.PAUTO || n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT) && n.Type().HasPointers()
 }
 
 // getvariables returns the list of on-stack variables that we need to track
 // and a map for looking up indices by *Node.
-func getvariables(fn *ir.Node) ([]*ir.Node, map[*ir.Node]int32) {
-	var vars []*ir.Node
+func getvariables(fn ir.Node) ([]ir.Node, map[ir.Node]int32) {
+	var vars []ir.Node
 	for _, n := range fn.Func().Dcl {
 		if livenessShouldTrack(n) {
 			vars = append(vars, n)
 		}
 	}
-	idx := make(map[*ir.Node]int32, len(vars))
+	idx := make(map[ir.Node]int32, len(vars))
 	for i, n := range vars {
 		idx[n] = int32(i)
 	}
@@ -312,7 +312,7 @@ func (lv *Liveness) valueEffects(v *ssa.Value) (int32, liveEffect) {
 }
 
 // affectedNode returns the *Node affected by v
-func affectedNode(v *ssa.Value) (*ir.Node, ssa.SymEffect) {
+func affectedNode(v *ssa.Value) (ir.Node, ssa.SymEffect) {
 	// Special cases.
 	switch v.Op {
 	case ssa.OpLoadReg:
@@ -323,9 +323,9 @@ func affectedNode(v *ssa.Value) (*ir.Node, ssa.SymEffect) {
 		return n, ssa.SymWrite
 
 	case ssa.OpVarLive:
-		return v.Aux.(*ir.Node), ssa.SymRead
+		return v.Aux.(ir.Node), ssa.SymRead
 	case ssa.OpVarDef, ssa.OpVarKill:
-		return v.Aux.(*ir.Node), ssa.SymWrite
+		return v.Aux.(ir.Node), ssa.SymWrite
 	case ssa.OpKeepAlive:
 		n, _ := AutoVar(v.Args[0])
 		return n, ssa.SymRead
@@ -340,7 +340,7 @@ func affectedNode(v *ssa.Value) (*ir.Node, ssa.SymEffect) {
 	case nil, *obj.LSym:
 		// ok, but no node
 		return nil, e
-	case *ir.Node:
+	case ir.Node:
 		return a, e
 	default:
 		base.Fatalf("weird aux: %s", v.LongString())
@@ -356,7 +356,7 @@ type livenessFuncCache struct {
 // Constructs a new liveness structure used to hold the global state of the
 // liveness computation. The cfg argument is a slice of *BasicBlocks and the
 // vars argument is a slice of *Nodes.
-func newliveness(fn *ir.Node, f *ssa.Func, vars []*ir.Node, idx map[*ir.Node]int32, stkptrsize int64) *Liveness {
+func newliveness(fn ir.Node, f *ssa.Func, vars []ir.Node, idx map[ir.Node]int32, stkptrsize int64) *Liveness {
 	lv := &Liveness{
 		fn:         fn,
 		f:          f,
@@ -482,7 +482,7 @@ func onebitwalktype1(t *types.Type, off int64, bv bvec) {
 // Generates live pointer value maps for arguments and local variables. The
 // this argument and the in arguments are always assumed live. The vars
 // argument is a slice of *Nodes.
-func (lv *Liveness) pointerMap(liveout bvec, vars []*ir.Node, args, locals bvec) {
+func (lv *Liveness) pointerMap(liveout bvec, vars []ir.Node, args, locals bvec) {
 	for i := int32(0); ; i++ {
 		i = liveout.Next(i)
 		if i < 0 {
@@ -1164,7 +1164,7 @@ func (lv *Liveness) emit() (argsSym, liveSym *obj.LSym) {
 	// Size args bitmaps to be just large enough to hold the largest pointer.
 	// First, find the largest Xoffset node we care about.
 	// (Nodes without pointers aren't in lv.vars; see livenessShouldTrack.)
-	var maxArgNode *ir.Node
+	var maxArgNode ir.Node
 	for _, n := range lv.vars {
 		switch n.Class() {
 		case ir.PPARAM, ir.PPARAMOUT:
diff --git a/src/cmd/compile/internal/gc/racewalk.go b/src/cmd/compile/internal/gc/racewalk.go
index 5ab2821187..c41d923f78 100644
--- a/src/cmd/compile/internal/gc/racewalk.go
+++ b/src/cmd/compile/internal/gc/racewalk.go
@@ -60,7 +60,7 @@ func ispkgin(pkgs []string) bool {
 	return false
 }
 
-func instrument(fn *ir.Node) {
+func instrument(fn ir.Node) {
 	if fn.Func().Pragma&ir.Norace != 0 {
 		return
 	}
diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index 6a2a65c2df..0ff00cca44 100644
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -13,7 +13,7 @@ import (
 )
 
 // range
-func typecheckrange(n *ir.Node) {
+func typecheckrange(n ir.Node) {
 	// Typechecking order is important here:
 	// 0. first typecheck range expression (slice/map/chan),
 	//	it is evaluated only once and so logically it is not part of the loop.
@@ -39,7 +39,7 @@ func typecheckrange(n *ir.Node) {
 	decldepth--
 }
 
-func typecheckrangeExpr(n *ir.Node) {
+func typecheckrangeExpr(n ir.Node) {
 	n.SetRight(typecheck(n.Right(), ctxExpr))
 
 	t := n.Right().Type()
@@ -95,7 +95,7 @@ func typecheckrangeExpr(n *ir.Node) {
 		base.ErrorfAt(n.Pos(), "too many variables in range")
 	}
 
-	var v1, v2 *ir.Node
+	var v1, v2 ir.Node
 	if n.List().Len() != 0 {
 		v1 = n.List().First()
 	}
@@ -157,7 +157,7 @@ func cheapComputableIndex(width int64) bool {
 // simpler forms.  The result must be assigned back to n.
 // Node n may also be modified in place, and may also be
 // the returned node.
-func walkrange(n *ir.Node) *ir.Node {
+func walkrange(n ir.Node) ir.Node {
 	if isMapClear(n) {
 		m := n.Right()
 		lno := setlineno(m)
@@ -179,7 +179,7 @@ func walkrange(n *ir.Node) *ir.Node {
 	lno := setlineno(a)
 	n.SetRight(nil)
 
-	var v1, v2 *ir.Node
+	var v1, v2 ir.Node
 	l := n.List().Len()
 	if l > 0 {
 		v1 = n.List().First()
@@ -205,12 +205,12 @@ func walkrange(n *ir.Node) *ir.Node {
 	// to avoid erroneous processing by racewalk.
 	n.PtrList().Set(nil)
 
-	var ifGuard *ir.Node
+	var ifGuard ir.Node
 
 	translatedLoopOp := ir.OFOR
 
-	var body []*ir.Node
-	var init []*ir.Node
+	var body []ir.Node
+	var init []ir.Node
 	switch t.Etype {
 	default:
 		base.Fatalf("walkrange")
@@ -240,7 +240,7 @@ func walkrange(n *ir.Node) *ir.Node {
 
 		// for v1 := range ha { body }
 		if v2 == nil {
-			body = []*ir.Node{ir.Nod(ir.OAS, v1, hv1)}
+			body = []ir.Node{ir.Nod(ir.OAS, v1, hv1)}
 			break
 		}
 
@@ -254,7 +254,7 @@ func walkrange(n *ir.Node) *ir.Node {
 			a := ir.Nod(ir.OAS2, nil, nil)
 			a.PtrList().Set2(v1, v2)
 			a.PtrRlist().Set2(hv1, tmp)
-			body = []*ir.Node{a}
+			body = []ir.Node{a}
 			break
 		}
 
@@ -321,14 +321,14 @@ func walkrange(n *ir.Node) *ir.Node {
 		if v1 == nil {
 			body = nil
 		} else if v2 == nil {
-			body = []*ir.Node{ir.Nod(ir.OAS, v1, key)}
+			body = []ir.Node{ir.Nod(ir.OAS, v1, key)}
 		} else {
 			elem := nodSym(ir.ODOT, hit, elemsym)
 			elem = ir.Nod(ir.ODEREF, elem, nil)
 			a := ir.Nod(ir.OAS2, nil, nil)
 			a.PtrList().Set2(v1, v2)
 			a.PtrRlist().Set2(key, elem)
-			body = []*ir.Node{a}
+			body = []ir.Node{a}
 		}
 
 	case types.TCHAN:
@@ -353,7 +353,7 @@ func walkrange(n *ir.Node) *ir.Node {
 		if v1 == nil {
 			body = nil
 		} else {
-			body = []*ir.Node{ir.Nod(ir.OAS, v1, hv1)}
+			body = []ir.Node{ir.Nod(ir.OAS, v1, hv1)}
 		}
 		// Zero hv1. This prevents hv1 from being the sole, inaccessible
 		// reference to an otherwise GC-able value during the next channel receive.
@@ -467,7 +467,7 @@ func walkrange(n *ir.Node) *ir.Node {
 // }
 //
 // where == for keys of map m is reflexive.
-func isMapClear(n *ir.Node) bool {
+func isMapClear(n ir.Node) bool {
 	if base.Flag.N != 0 || instrumenting {
 		return false
 	}
@@ -509,7 +509,7 @@ func isMapClear(n *ir.Node) bool {
 }
 
 // mapClear constructs a call to runtime.mapclear for the map m.
-func mapClear(m *ir.Node) *ir.Node {
+func mapClear(m ir.Node) ir.Node {
 	t := m.Type()
 
 	// instantiate mapclear(typ *type, hmap map[any]any)
@@ -534,7 +534,7 @@ func mapClear(m *ir.Node) *ir.Node {
 // in which the evaluation of a is side-effect-free.
 //
 // Parameters are as in walkrange: "for v1, v2 = range a".
-func arrayClear(n, v1, v2, a *ir.Node) bool {
+func arrayClear(n, v1, v2, a ir.Node) bool {
 	if base.Flag.N != 0 || instrumenting {
 		return false
 	}
@@ -590,7 +590,7 @@ func arrayClear(n, v1, v2, a *ir.Node) bool {
 	tmp = conv(tmp, types.Types[types.TUINTPTR])
 	n.PtrBody().Append(ir.Nod(ir.OAS, hn, tmp))
 
-	var fn *ir.Node
+	var fn ir.Node
 	if a.Type().Elem().HasPointers() {
 		// memclrHasPointers(hp, hn)
 		Curfn.Func().SetWBPos(stmt.Pos())
@@ -615,7 +615,7 @@ func arrayClear(n, v1, v2, a *ir.Node) bool {
 }
 
 // addptr returns (*T)(uintptr(p) + n).
-func addptr(p *ir.Node, n int64) *ir.Node {
+func addptr(p ir.Node, n int64) ir.Node {
 	t := p.Type()
 
 	p = ir.Nod(ir.OCONVNOP, p, nil)
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 664b3cc942..dc9efc07fe 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -347,7 +347,7 @@ func methodfunc(f *types.Type, receiver *types.Type) *types.Type {
 	if receiver != nil {
 		inLen++
 	}
-	in := make([]*ir.Node, 0, inLen)
+	in := make([]ir.Node, 0, inLen)
 
 	if receiver != nil {
 		d := anonfield(receiver)
@@ -361,7 +361,7 @@ func methodfunc(f *types.Type, receiver *types.Type) *types.Type {
 	}
 
 	outLen := f.Results().Fields().Len()
-	out := make([]*ir.Node, 0, outLen)
+	out := make([]ir.Node, 0, outLen)
 	for _, t := range f.Results().Fields().Slice() {
 		d := anonfield(t.Type)
 		out = append(out, d)
@@ -990,7 +990,7 @@ func typenamesym(t *types.Type) *types.Sym {
 	return s
 }
 
-func typename(t *types.Type) *ir.Node {
+func typename(t *types.Type) ir.Node {
 	s := typenamesym(t)
 	if s.Def == nil {
 		n := ir.NewNameAt(src.NoXPos, s)
@@ -1006,7 +1006,7 @@ func typename(t *types.Type) *ir.Node {
 	return n
 }
 
-func itabname(t, itype *types.Type) *ir.Node {
+func itabname(t, itype *types.Type) ir.Node {
 	if t == nil || (t.IsPtr() && t.Elem() == nil) || t.IsUntyped() || !itype.IsInterface() || itype.IsEmptyInterface() {
 		base.Fatalf("itabname(%v, %v)", t, itype)
 	}
@@ -1516,7 +1516,7 @@ func addsignat(t *types.Type) {
 	}
 }
 
-func addsignats(dcls []*ir.Node) {
+func addsignats(dcls []ir.Node) {
 	// copy types from dcl list to signatset
 	for _, n := range dcls {
 		if n.Op() == ir.OTYPE {
@@ -1626,7 +1626,7 @@ func dumpbasictypes() {
 		// The latter is the type of an auto-generated wrapper.
 		dtypesym(types.NewPtr(types.Errortype))
 
-		dtypesym(functype(nil, []*ir.Node{anonfield(types.Errortype)}, []*ir.Node{anonfield(types.Types[types.TSTRING])}))
+		dtypesym(functype(nil, []ir.Node{anonfield(types.Errortype)}, []ir.Node{anonfield(types.Types[types.TSTRING])}))
 
 		// add paths for runtime and main, which 6l imports implicitly.
 		dimportpath(Runtimepkg)
@@ -1869,7 +1869,7 @@ func (p *GCProg) emit(t *types.Type, offset int64) {
 
 // zeroaddr returns the address of a symbol with at least
 // size bytes of zeros.
-func zeroaddr(size int64) *ir.Node {
+func zeroaddr(size int64) ir.Node {
 	if size >= 1<<31 {
 		base.Fatalf("map elem too big %d", size)
 	}
diff --git a/src/cmd/compile/internal/gc/scc.go b/src/cmd/compile/internal/gc/scc.go
index 880eff7595..fe7956d5d5 100644
--- a/src/cmd/compile/internal/gc/scc.go
+++ b/src/cmd/compile/internal/gc/scc.go
@@ -32,10 +32,10 @@ import "cmd/compile/internal/ir"
 // when analyzing a set of mutually recursive functions.
 
 type bottomUpVisitor struct {
-	analyze  func([]*ir.Node, bool)
+	analyze  func([]ir.Node, bool)
 	visitgen uint32
-	nodeID   map[*ir.Node]uint32
-	stack    []*ir.Node
+	nodeID   map[ir.Node]uint32
+	stack    []ir.Node
 }
 
 // visitBottomUp invokes analyze on the ODCLFUNC nodes listed in list.
@@ -51,10 +51,10 @@ type bottomUpVisitor struct {
 // If recursive is false, the list consists of only a single function and its closures.
 // If recursive is true, the list may still contain only a single function,
 // if that function is itself recursive.
-func visitBottomUp(list []*ir.Node, analyze func(list []*ir.Node, recursive bool)) {
+func visitBottomUp(list []ir.Node, analyze func(list []ir.Node, recursive bool)) {
 	var v bottomUpVisitor
 	v.analyze = analyze
-	v.nodeID = make(map[*ir.Node]uint32)
+	v.nodeID = make(map[ir.Node]uint32)
 	for _, n := range list {
 		if n.Op() == ir.ODCLFUNC && !n.Func().IsHiddenClosure() {
 			v.visit(n)
@@ -62,7 +62,7 @@ func visitBottomUp(list []*ir.Node, analyze func(list []*ir.Node, recursive bool
 	}
 }
 
-func (v *bottomUpVisitor) visit(n *ir.Node) uint32 {
+func (v *bottomUpVisitor) visit(n ir.Node) uint32 {
 	if id := v.nodeID[n]; id > 0 {
 		// already visited
 		return id
@@ -75,7 +75,7 @@ func (v *bottomUpVisitor) visit(n *ir.Node) uint32 {
 	min := v.visitgen
 	v.stack = append(v.stack, n)
 
-	ir.InspectList(n.Body(), func(n *ir.Node) bool {
+	ir.InspectList(n.Body(), func(n ir.Node) bool {
 		switch n.Op() {
 		case ir.ONAME:
 			if n.Class() == ir.PFUNC {
diff --git a/src/cmd/compile/internal/gc/scope.go b/src/cmd/compile/internal/gc/scope.go
index 16e66dee6c..fe4e1d185a 100644
--- a/src/cmd/compile/internal/gc/scope.go
+++ b/src/cmd/compile/internal/gc/scope.go
@@ -28,7 +28,7 @@ func findScope(marks []ir.Mark, pos src.XPos) ir.ScopeID {
 	return marks[i-1].Scope
 }
 
-func assembleScopes(fnsym *obj.LSym, fn *ir.Node, dwarfVars []*dwarf.Var, varScopes []ir.ScopeID) []dwarf.Scope {
+func assembleScopes(fnsym *obj.LSym, fn ir.Node, dwarfVars []*dwarf.Var, varScopes []ir.ScopeID) []dwarf.Scope {
 	// Initialize the DWARF scope tree based on lexical scopes.
 	dwarfScopes := make([]dwarf.Scope, 1+len(fn.Func().Parents))
 	for i, parent := range fn.Func().Parents {
diff --git a/src/cmd/compile/internal/gc/select.go b/src/cmd/compile/internal/gc/select.go
index 73b808b815..116b6f5b6e 100644
--- a/src/cmd/compile/internal/gc/select.go
+++ b/src/cmd/compile/internal/gc/select.go
@@ -11,8 +11,8 @@ import (
 )
 
 // select
-func typecheckselect(sel *ir.Node) {
-	var def *ir.Node
+func typecheckselect(sel ir.Node) {
+	var def ir.Node
 	lno := setlineno(sel)
 	typecheckslice(sel.Init().Slice(), ctxStmt)
 	for _, ncase := range sel.List().Slice() {
@@ -91,7 +91,7 @@ func typecheckselect(sel *ir.Node) {
 	base.Pos = lno
 }
 
-func walkselect(sel *ir.Node) {
+func walkselect(sel ir.Node) {
 	lno := setlineno(sel)
 	if sel.Body().Len() != 0 {
 		base.Fatalf("double walkselect")
@@ -109,13 +109,13 @@ func walkselect(sel *ir.Node) {
 	base.Pos = lno
 }
 
-func walkselectcases(cases *ir.Nodes) []*ir.Node {
+func walkselectcases(cases *ir.Nodes) []ir.Node {
 	ncas := cases.Len()
 	sellineno := base.Pos
 
 	// optimization: zero-case select
 	if ncas == 0 {
-		return []*ir.Node{mkcall("block", nil, nil)}
+		return []ir.Node{mkcall("block", nil, nil)}
 	}
 
 	// optimization: one-case select: single op.
@@ -168,7 +168,7 @@ func walkselectcases(cases *ir.Nodes) []*ir.Node {
 
 	// convert case value arguments to addresses.
 	// this rewrite is used by both the general code and the next optimization.
-	var dflt *ir.Node
+	var dflt ir.Node
 	for _, cas := range cases.Slice() {
 		setlineno(cas)
 		n := cas.Left()
@@ -237,16 +237,16 @@ func walkselectcases(cases *ir.Nodes) []*ir.Node {
 		r.SetLeft(typecheck(r.Left(), ctxExpr))
 		r.PtrBody().Set(cas.Body().Slice())
 		r.PtrRlist().Set(append(dflt.Init().Slice(), dflt.Body().Slice()...))
-		return []*ir.Node{r, ir.Nod(ir.OBREAK, nil, nil)}
+		return []ir.Node{r, ir.Nod(ir.OBREAK, nil, nil)}
 	}
 
 	if dflt != nil {
 		ncas--
 	}
-	casorder := make([]*ir.Node, ncas)
+	casorder := make([]ir.Node, ncas)
 	nsends, nrecvs := 0, 0
 
-	var init []*ir.Node
+	var init []ir.Node
 
 	// generate sel-struct
 	base.Pos = sellineno
@@ -258,7 +258,7 @@ func walkselectcases(cases *ir.Nodes) []*ir.Node {
 	// No initialization for order; runtime.selectgo is responsible for that.
 	order := temp(types.NewArray(types.Types[types.TUINT16], 2*int64(ncas)))
 
-	var pc0, pcs *ir.Node
+	var pc0, pcs ir.Node
 	if base.Flag.Race {
 		pcs = temp(types.NewArray(types.Types[types.TUINTPTR], int64(ncas)))
 		pc0 = typecheck(ir.Nod(ir.OADDR, ir.Nod(ir.OINDEX, pcs, nodintconst(0)), nil), ctxExpr)
@@ -279,7 +279,7 @@ func walkselectcases(cases *ir.Nodes) []*ir.Node {
 		}
 
 		var i int
-		var c, elem *ir.Node
+		var c, elem ir.Node
 		switch n.Op() {
 		default:
 			base.Fatalf("select %v", n.Op())
@@ -297,7 +297,7 @@ func walkselectcases(cases *ir.Nodes) []*ir.Node {
 
 		casorder[i] = cas
 
-		setField := func(f string, val *ir.Node) {
+		setField := func(f string, val ir.Node) {
 			r := ir.Nod(ir.OAS, nodSym(ir.ODOT, ir.Nod(ir.OINDEX, selv, nodintconst(int64(i))), lookup(f)), val)
 			r = typecheck(r, ctxStmt)
 			init = append(init, r)
@@ -340,7 +340,7 @@ func walkselectcases(cases *ir.Nodes) []*ir.Node {
 	}
 
 	// dispatch cases
-	dispatch := func(cond, cas *ir.Node) {
+	dispatch := func(cond, cas ir.Node) {
 		cond = typecheck(cond, ctxExpr)
 		cond = defaultlit(cond, nil)
 
@@ -370,7 +370,7 @@ func walkselectcases(cases *ir.Nodes) []*ir.Node {
 }
 
 // bytePtrToIndex returns a Node representing "(*byte)(&n[i])".
-func bytePtrToIndex(n *ir.Node, i int64) *ir.Node {
+func bytePtrToIndex(n ir.Node, i int64) ir.Node {
 	s := ir.Nod(ir.OADDR, ir.Nod(ir.OINDEX, n, nodintconst(i)), nil)
 	t := types.NewPtr(types.Types[types.TUINT8])
 	return convnop(s, t)
@@ -381,7 +381,7 @@ var scase *types.Type
 // Keep in sync with src/runtime/select.go.
 func scasetype() *types.Type {
 	if scase == nil {
-		scase = tostruct([]*ir.Node{
+		scase = tostruct([]ir.Node{
 			namedfield("c", types.Types[types.TUNSAFEPTR]),
 			namedfield("elem", types.Types[types.TUNSAFEPTR]),
 		})
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index c0f85a1e33..e30663cfbb 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -14,8 +14,8 @@ import (
 )
 
 type InitEntry struct {
-	Xoffset int64    // struct, array only
-	Expr    *ir.Node // bytes of run-time computed expressions
+	Xoffset int64   // struct, array only
+	Expr    ir.Node // bytes of run-time computed expressions
 }
 
 type InitPlan struct {
@@ -29,18 +29,18 @@ type InitPlan struct {
 type InitSchedule struct {
 	// out is the ordered list of dynamic initialization
 	// statements.
-	out []*ir.Node
+	out []ir.Node
 
-	initplans map[*ir.Node]*InitPlan
-	inittemps map[*ir.Node]*ir.Node
+	initplans map[ir.Node]*InitPlan
+	inittemps map[ir.Node]ir.Node
 }
 
-func (s *InitSchedule) append(n *ir.Node) {
+func (s *InitSchedule) append(n ir.Node) {
 	s.out = append(s.out, n)
 }
 
 // staticInit adds an initialization statement n to the schedule.
-func (s *InitSchedule) staticInit(n *ir.Node) {
+func (s *InitSchedule) staticInit(n ir.Node) {
 	if !s.tryStaticInit(n) {
 		if base.Flag.Percent != 0 {
 			ir.Dump("nonstatic", n)
@@ -51,7 +51,7 @@ func (s *InitSchedule) staticInit(n *ir.Node) {
 
 // tryStaticInit attempts to statically execute an initialization
 // statement and reports whether it succeeded.
-func (s *InitSchedule) tryStaticInit(n *ir.Node) bool {
+func (s *InitSchedule) tryStaticInit(n ir.Node) bool {
 	// Only worry about simple "l = r" assignments. Multiple
 	// variable/expression OAS2 assignments have already been
 	// replaced by multiple simple OAS assignments, and the other
@@ -70,7 +70,7 @@ func (s *InitSchedule) tryStaticInit(n *ir.Node) bool {
 
 // like staticassign but we are copying an already
 // initialized value r.
-func (s *InitSchedule) staticcopy(l *ir.Node, r *ir.Node) bool {
+func (s *InitSchedule) staticcopy(l ir.Node, r ir.Node) bool {
 	if r.Op() != ir.ONAME && r.Op() != ir.OMETHEXPR {
 		return false
 	}
@@ -168,7 +168,7 @@ func (s *InitSchedule) staticcopy(l *ir.Node, r *ir.Node) bool {
 	return false
 }
 
-func (s *InitSchedule) staticassign(l *ir.Node, r *ir.Node) bool {
+func (s *InitSchedule) staticassign(l ir.Node, r ir.Node) bool {
 	for r.Op() == ir.OCONVNOP {
 		r = r.Left()
 	}
@@ -289,7 +289,7 @@ func (s *InitSchedule) staticassign(l *ir.Node, r *ir.Node) bool {
 
 		markTypeUsedInInterface(val.Type(), l.Sym().Linksym())
 
-		var itab *ir.Node
+		var itab ir.Node
 		if l.Type().IsEmptyInterface() {
 			itab = typename(val.Type())
 		} else {
@@ -367,7 +367,7 @@ var statuniqgen int // name generator for static temps
 
 // staticname returns a name backed by a (writable) static data symbol.
 // Use readonlystaticname for read-only node.
-func staticname(t *types.Type) *ir.Node {
+func staticname(t *types.Type) ir.Node {
 	// Don't use lookupN; it interns the resulting string, but these are all unique.
 	n := NewName(lookup(fmt.Sprintf("%s%d", obj.StaticNamePref, statuniqgen)))
 	statuniqgen++
@@ -377,18 +377,18 @@ func staticname(t *types.Type) *ir.Node {
 }
 
 // readonlystaticname returns a name backed by a (writable) static data symbol.
-func readonlystaticname(t *types.Type) *ir.Node {
+func readonlystaticname(t *types.Type) ir.Node {
 	n := staticname(t)
 	n.MarkReadonly()
 	n.Sym().Linksym().Set(obj.AttrContentAddressable, true)
 	return n
 }
 
-func isSimpleName(n *ir.Node) bool {
+func isSimpleName(n ir.Node) bool {
 	return (n.Op() == ir.ONAME || n.Op() == ir.OMETHEXPR) && n.Class() != ir.PAUTOHEAP && n.Class() != ir.PEXTERN
 }
 
-func litas(l *ir.Node, r *ir.Node, init *ir.Nodes) {
+func litas(l ir.Node, r ir.Node, init *ir.Nodes) {
 	a := ir.Nod(ir.OAS, l, r)
 	a = typecheck(a, ctxStmt)
 	a = walkexpr(a, init)
@@ -405,7 +405,7 @@ const (
 
 // getdyn calculates the initGenType for n.
 // If top is false, getdyn is recursing.
-func getdyn(n *ir.Node, top bool) initGenType {
+func getdyn(n ir.Node, top bool) initGenType {
 	switch n.Op() {
 	default:
 		if isGoConst(n) {
@@ -447,7 +447,7 @@ func getdyn(n *ir.Node, top bool) initGenType {
 }
 
 // isStaticCompositeLiteral reports whether n is a compile-time constant.
-func isStaticCompositeLiteral(n *ir.Node) bool {
+func isStaticCompositeLiteral(n ir.Node) bool {
 	switch n.Op() {
 	case ir.OSLICELIT:
 		return false
@@ -509,13 +509,13 @@ const (
 
 // fixedlit handles struct, array, and slice literals.
 // TODO: expand documentation.
-func fixedlit(ctxt initContext, kind initKind, n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
+func fixedlit(ctxt initContext, kind initKind, n ir.Node, var_ ir.Node, init *ir.Nodes) {
 	isBlank := var_ == ir.BlankNode
-	var splitnode func(*ir.Node) (a *ir.Node, value *ir.Node)
+	var splitnode func(ir.Node) (a ir.Node, value ir.Node)
 	switch n.Op() {
 	case ir.OARRAYLIT, ir.OSLICELIT:
 		var k int64
-		splitnode = func(r *ir.Node) (*ir.Node, *ir.Node) {
+		splitnode = func(r ir.Node) (ir.Node, ir.Node) {
 			if r.Op() == ir.OKEY {
 				k = indexconst(r.Left())
 				if k < 0 {
@@ -531,7 +531,7 @@ func fixedlit(ctxt initContext, kind initKind, n *ir.Node, var_ *ir.Node, init *
 			return a, r
 		}
 	case ir.OSTRUCTLIT:
-		splitnode = func(r *ir.Node) (*ir.Node, *ir.Node) {
+		splitnode = func(r ir.Node) (ir.Node, ir.Node) {
 			if r.Op() != ir.OSTRUCTKEY {
 				base.Fatalf("fixedlit: rhs not OSTRUCTKEY: %v", r)
 			}
@@ -576,7 +576,7 @@ func fixedlit(ctxt initContext, kind initKind, n *ir.Node, var_ *ir.Node, init *
 		case initKindStatic:
 			genAsStatic(a)
 		case initKindDynamic, initKindLocalCode:
-			a = orderStmtInPlace(a, map[string][]*ir.Node{})
+			a = orderStmtInPlace(a, map[string][]ir.Node{})
 			a = walkstmt(a)
 			init.Append(a)
 		default:
@@ -586,7 +586,7 @@ func fixedlit(ctxt initContext, kind initKind, n *ir.Node, var_ *ir.Node, init *
 	}
 }
 
-func isSmallSliceLit(n *ir.Node) bool {
+func isSmallSliceLit(n ir.Node) bool {
 	if n.Op() != ir.OSLICELIT {
 		return false
 	}
@@ -596,7 +596,7 @@ func isSmallSliceLit(n *ir.Node) bool {
 	return smallintconst(r) && (n.Type().Elem().Width == 0 || r.Int64Val() <= smallArrayBytes/n.Type().Elem().Width)
 }
 
-func slicelit(ctxt initContext, n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
+func slicelit(ctxt initContext, n ir.Node, var_ ir.Node, init *ir.Nodes) {
 	// make an array type corresponding the number of elements we have
 	t := types.NewArray(n.Type().Elem(), n.Right().Int64Val())
 	dowidth(t)
@@ -639,7 +639,7 @@ func slicelit(ctxt initContext, n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
 
 	// if the literal contains constants,
 	// make static initialized array (1),(2)
-	var vstat *ir.Node
+	var vstat ir.Node
 
 	mode := getdyn(n, true)
 	if mode&initConst != 0 && !isSmallSliceLit(n) {
@@ -655,7 +655,7 @@ func slicelit(ctxt initContext, n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
 	vauto := temp(types.NewPtr(t))
 
 	// set auto to point at new temp or heap (3 assign)
-	var a *ir.Node
+	var a ir.Node
 	if x := prealloc[n]; x != nil {
 		// temp allocated during order.go for dddarg
 		if !types.Identical(t, x.Type()) {
@@ -745,7 +745,7 @@ func slicelit(ctxt initContext, n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
 		a = ir.Nod(ir.OAS, a, value)
 
 		a = typecheck(a, ctxStmt)
-		a = orderStmtInPlace(a, map[string][]*ir.Node{})
+		a = orderStmtInPlace(a, map[string][]ir.Node{})
 		a = walkstmt(a)
 		init.Append(a)
 	}
@@ -754,12 +754,12 @@ func slicelit(ctxt initContext, n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
 	a = ir.Nod(ir.OAS, var_, ir.Nod(ir.OSLICE, vauto, nil))
 
 	a = typecheck(a, ctxStmt)
-	a = orderStmtInPlace(a, map[string][]*ir.Node{})
+	a = orderStmtInPlace(a, map[string][]ir.Node{})
 	a = walkstmt(a)
 	init.Append(a)
 }
 
-func maplit(n *ir.Node, m *ir.Node, init *ir.Nodes) {
+func maplit(n ir.Node, m ir.Node, init *ir.Nodes) {
 	// make the map var
 	a := ir.Nod(ir.OMAKE, nil, nil)
 	a.SetEsc(n.Esc())
@@ -866,7 +866,7 @@ func maplit(n *ir.Node, m *ir.Node, init *ir.Nodes) {
 	init.Append(a)
 }
 
-func anylit(n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
+func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 	t := n.Type()
 	switch n.Op() {
 	default:
@@ -882,7 +882,7 @@ func anylit(n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
 			base.Fatalf("anylit: not ptr")
 		}
 
-		var r *ir.Node
+		var r ir.Node
 		if n.Right() != nil {
 			// n.Right is stack temporary used as backing store.
 			init.Append(ir.Nod(ir.OAS, n.Right(), nil)) // zero backing store, just in case (#18410)
@@ -959,7 +959,7 @@ func anylit(n *ir.Node, var_ *ir.Node, init *ir.Nodes) {
 	}
 }
 
-func oaslit(n *ir.Node, init *ir.Nodes) bool {
+func oaslit(n ir.Node, init *ir.Nodes) bool {
 	if n.Left() == nil || n.Right() == nil {
 		// not a special composite literal assignment
 		return false
@@ -995,7 +995,7 @@ func oaslit(n *ir.Node, init *ir.Nodes) bool {
 	return true
 }
 
-func getlit(lit *ir.Node) int {
+func getlit(lit ir.Node) int {
 	if smallintconst(lit) {
 		return int(lit.Int64Val())
 	}
@@ -1003,7 +1003,7 @@ func getlit(lit *ir.Node) int {
 }
 
 // stataddr returns the static address of n, if n has one, or else nil.
-func stataddr(n *ir.Node) *ir.Node {
+func stataddr(n ir.Node) ir.Node {
 	if n == nil {
 		return nil
 	}
@@ -1046,7 +1046,7 @@ func stataddr(n *ir.Node) *ir.Node {
 	return nil
 }
 
-func (s *InitSchedule) initplan(n *ir.Node) {
+func (s *InitSchedule) initplan(n ir.Node) {
 	if s.initplans[n] != nil {
 		return
 	}
@@ -1091,7 +1091,7 @@ func (s *InitSchedule) initplan(n *ir.Node) {
 	}
 }
 
-func (s *InitSchedule) addvalue(p *InitPlan, xoffset int64, n *ir.Node) {
+func (s *InitSchedule) addvalue(p *InitPlan, xoffset int64, n ir.Node) {
 	// special case: zero can be dropped entirely
 	if isZero(n) {
 		return
@@ -1113,7 +1113,7 @@ func (s *InitSchedule) addvalue(p *InitPlan, xoffset int64, n *ir.Node) {
 	p.E = append(p.E, InitEntry{Xoffset: xoffset, Expr: n})
 }
 
-func isZero(n *ir.Node) bool {
+func isZero(n ir.Node) bool {
 	switch n.Op() {
 	case ir.ONIL:
 		return true
@@ -1151,11 +1151,11 @@ func isZero(n *ir.Node) bool {
 	return false
 }
 
-func isvaluelit(n *ir.Node) bool {
+func isvaluelit(n ir.Node) bool {
 	return n.Op() == ir.OARRAYLIT || n.Op() == ir.OSTRUCTLIT
 }
 
-func genAsStatic(as *ir.Node) {
+func genAsStatic(as ir.Node) {
 	if as.Left().Type() == nil {
 		base.Fatalf("genAsStatic as.Left not typechecked")
 	}
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 262aa0e95c..cb73532b48 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -40,7 +40,7 @@ const ssaDumpFile = "ssa.html"
 const maxOpenDefers = 8
 
 // ssaDumpInlined holds all inlined functions when ssaDump contains a function name.
-var ssaDumpInlined []*ir.Node
+var ssaDumpInlined []ir.Node
 
 func initssaconfig() {
 	types_ := ssa.NewTypes()
@@ -186,7 +186,7 @@ func initssaconfig() {
 // function/method/interface call), where the receiver of a method call is
 // considered as the 0th parameter. This does not include the receiver of an
 // interface call.
-func getParam(n *ir.Node, i int) *types.Field {
+func getParam(n ir.Node, i int) *types.Field {
 	t := n.Left().Type()
 	if n.Op() == ir.OCALLMETH {
 		if i == 0 {
@@ -289,7 +289,7 @@ func (s *state) emitOpenDeferInfo() {
 
 // buildssa builds an SSA function for fn.
 // worker indicates which of the backend workers is doing the processing.
-func buildssa(fn *ir.Node, worker int) *ssa.Func {
+func buildssa(fn ir.Node, worker int) *ssa.Func {
 	name := ir.FuncName(fn)
 	printssa := false
 	if ssaDump != "" { // match either a simple name e.g. "(*Reader).Reset", or a package.name e.g. "compress/gzip.(*Reader).Reset"
@@ -356,8 +356,8 @@ func buildssa(fn *ir.Node, worker int) *ssa.Func {
 
 	// Allocate starting values
 	s.labels = map[string]*ssaLabel{}
-	s.labeledNodes = map[*ir.Node]*ssaLabel{}
-	s.fwdVars = map[*ir.Node]*ssa.Value{}
+	s.labeledNodes = map[ir.Node]*ssaLabel{}
+	s.fwdVars = map[ir.Node]*ssa.Value{}
 	s.startmem = s.entryNewValue0(ssa.OpInitMem, types.TypeMem)
 
 	s.hasOpenDefers = base.Flag.N == 0 && s.hasdefer && !s.curfn.Func().OpenCodedDeferDisallowed()
@@ -411,7 +411,7 @@ func buildssa(fn *ir.Node, worker int) *ssa.Func {
 	}
 
 	// Generate addresses of local declarations
-	s.decladdrs = map[*ir.Node]*ssa.Value{}
+	s.decladdrs = map[ir.Node]*ssa.Value{}
 	var args []ssa.Param
 	var results []ssa.Param
 	for _, n := range fn.Func().Dcl {
@@ -478,7 +478,7 @@ func buildssa(fn *ir.Node, worker int) *ssa.Func {
 	return s.f
 }
 
-func dumpSourcesColumn(writer *ssa.HTMLWriter, fn *ir.Node) {
+func dumpSourcesColumn(writer *ssa.HTMLWriter, fn ir.Node) {
 	// Read sources of target function fn.
 	fname := base.Ctxt.PosTable.Pos(fn.Pos()).Filename()
 	targetFn, err := readFuncLines(fname, fn.Pos().Line(), fn.Func().Endlineno.Line())
@@ -566,24 +566,24 @@ func (s *state) updateUnsetPredPos(b *ssa.Block) {
 // Information about each open-coded defer.
 type openDeferInfo struct {
 	// The ODEFER node representing the function call of the defer
-	n *ir.Node
+	n ir.Node
 	// If defer call is closure call, the address of the argtmp where the
 	// closure is stored.
 	closure *ssa.Value
 	// The node representing the argtmp where the closure is stored - used for
 	// function, method, or interface call, to store a closure that panic
 	// processing can use for this defer.
-	closureNode *ir.Node
+	closureNode ir.Node
 	// If defer call is interface call, the address of the argtmp where the
 	// receiver is stored
 	rcvr *ssa.Value
 	// The node representing the argtmp where the receiver is stored
-	rcvrNode *ir.Node
+	rcvrNode ir.Node
 	// The addresses of the argtmps where the evaluated arguments of the defer
 	// function call are stored.
 	argVals []*ssa.Value
 	// The nodes representing the argtmps where the args of the defer are stored
-	argNodes []*ir.Node
+	argNodes []ir.Node
 }
 
 type state struct {
@@ -594,11 +594,11 @@ type state struct {
 	f *ssa.Func
 
 	// Node for function
-	curfn *ir.Node
+	curfn ir.Node
 
 	// labels and labeled control flow nodes (OFOR, OFORUNTIL, OSWITCH, OSELECT) in f
 	labels       map[string]*ssaLabel
-	labeledNodes map[*ir.Node]*ssaLabel
+	labeledNodes map[ir.Node]*ssaLabel
 
 	// unlabeled break and continue statement tracking
 	breakTo    *ssa.Block // current target for plain break statement
@@ -610,18 +610,18 @@ type state struct {
 	// variable assignments in the current block (map from variable symbol to ssa value)
 	// *Node is the unique identifier (an ONAME Node) for the variable.
 	// TODO: keep a single varnum map, then make all of these maps slices instead?
-	vars map[*ir.Node]*ssa.Value
+	vars map[ir.Node]*ssa.Value
 
 	// fwdVars are variables that are used before they are defined in the current block.
 	// This map exists just to coalesce multiple references into a single FwdRef op.
 	// *Node is the unique identifier (an ONAME Node) for the variable.
-	fwdVars map[*ir.Node]*ssa.Value
+	fwdVars map[ir.Node]*ssa.Value
 
 	// all defined variables at the end of each block. Indexed by block ID.
-	defvars []map[*ir.Node]*ssa.Value
+	defvars []map[ir.Node]*ssa.Value
 
 	// addresses of PPARAM and PPARAMOUT variables.
-	decladdrs map[*ir.Node]*ssa.Value
+	decladdrs map[ir.Node]*ssa.Value
 
 	// starting values. Memory, stack pointer, and globals pointer
 	startmem *ssa.Value
@@ -629,7 +629,7 @@ type state struct {
 	sb       *ssa.Value
 	// value representing address of where deferBits autotmp is stored
 	deferBitsAddr *ssa.Value
-	deferBitsTemp *ir.Node
+	deferBitsTemp ir.Node
 
 	// line number stack. The current line number is top of stack
 	line []src.XPos
@@ -641,7 +641,7 @@ type state struct {
 	panics map[funcLine]*ssa.Block
 
 	// list of PPARAMOUT (return) variables.
-	returns []*ir.Node
+	returns []ir.Node
 
 	cgoUnsafeArgs bool
 	hasdefer      bool // whether the function contains a defer statement
@@ -693,7 +693,7 @@ func (s *state) Fatalf(msg string, args ...interface{}) {
 func (s *state) Warnl(pos src.XPos, msg string, args ...interface{}) { s.f.Warnl(pos, msg, args...) }
 func (s *state) Debug_checknil() bool                                { return s.f.Frontend().Debug_checknil() }
 
-func ssaMarker(name string) *ir.Node {
+func ssaMarker(name string) ir.Node {
 	return NewName(&types.Sym{Name: name})
 }
 
@@ -717,7 +717,7 @@ func (s *state) startBlock(b *ssa.Block) {
 		s.Fatalf("starting block %v when block %v has not ended", b, s.curBlock)
 	}
 	s.curBlock = b
-	s.vars = map[*ir.Node]*ssa.Value{}
+	s.vars = map[ir.Node]*ssa.Value{}
 	for n := range s.fwdVars {
 		delete(s.fwdVars, n)
 	}
@@ -1059,7 +1059,7 @@ func (s *state) stmtList(l ir.Nodes) {
 }
 
 // stmt converts the statement n to SSA and adds it to s.
-func (s *state) stmt(n *ir.Node) {
+func (s *state) stmt(n ir.Node) {
 	if !(n.Op() == ir.OVARKILL || n.Op() == ir.OVARLIVE || n.Op() == ir.OVARDEF) {
 		// OVARKILL, OVARLIVE, and OVARDEF are invisible to the programmer, so we don't use their line numbers to avoid confusion in debugging.
 		s.pushLine(n.Pos())
@@ -1999,7 +1999,7 @@ func (s *state) ssaShiftOp(op ir.Op, t *types.Type, u *types.Type) ssa.Op {
 }
 
 // expr converts the expression n to ssa, adds it to s and returns the ssa result.
-func (s *state) expr(n *ir.Node) *ssa.Value {
+func (s *state) expr(n ir.Node) *ssa.Value {
 	if hasUniquePos(n) {
 		// ONAMEs and named OLITERALs have the line number
 		// of the decl, not the use. See issue 14742.
@@ -2790,7 +2790,7 @@ func (s *state) expr(n *ir.Node) *ssa.Value {
 // If inplace is true, it writes the result of the OAPPEND expression n
 // back to the slice being appended to, and returns nil.
 // inplace MUST be set to false if the slice can be SSA'd.
-func (s *state) append(n *ir.Node, inplace bool) *ssa.Value {
+func (s *state) append(n ir.Node, inplace bool) *ssa.Value {
 	// If inplace is false, process as expression "append(s, e1, e2, e3)":
 	//
 	// ptr, len, cap := s
@@ -2948,7 +2948,7 @@ func (s *state) append(n *ir.Node, inplace bool) *ssa.Value {
 // if cond is true and no if cond is false.
 // This function is intended to handle && and || better than just calling
 // s.expr(cond) and branching on the result.
-func (s *state) condBranch(cond *ir.Node, yes, no *ssa.Block, likely int8) {
+func (s *state) condBranch(cond ir.Node, yes, no *ssa.Block, likely int8) {
 	switch cond.Op() {
 	case ir.OANDAND:
 		mid := s.f.NewBlock(ssa.BlockPlain)
@@ -3000,7 +3000,7 @@ const (
 // If deref is true, then we do left = *right instead (and right has already been nil-checked).
 // If deref is true and right == nil, just do left = 0.
 // skip indicates assignments (at the top level) that can be avoided.
-func (s *state) assign(left *ir.Node, right *ssa.Value, deref bool, skip skipMask) {
+func (s *state) assign(left ir.Node, right *ssa.Value, deref bool, skip skipMask) {
 	if left.Op() == ir.ONAME && ir.IsBlank(left) {
 		return
 	}
@@ -3254,7 +3254,7 @@ var intrinsics map[intrinsicKey]intrinsicBuilder
 
 // An intrinsicBuilder converts a call node n into an ssa value that
 // implements that call as an intrinsic. args is a list of arguments to the func.
-type intrinsicBuilder func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value
+type intrinsicBuilder func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value
 
 type intrinsicKey struct {
 	arch *sys.Arch
@@ -3319,7 +3319,7 @@ func init() {
 	/******** runtime ********/
 	if !instrumenting {
 		add("runtime", "slicebytetostringtmp",
-			func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+			func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 				// Compiler frontend optimizations emit OBYTES2STRTMP nodes
 				// for the backend instead of slicebytetostringtmp calls
 				// when not instrumenting.
@@ -3328,7 +3328,7 @@ func init() {
 			all...)
 	}
 	addF("runtime/internal/math", "MulUintptr",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			if s.config.PtrSize == 4 {
 				return s.newValue2(ssa.OpMul32uover, types.NewTuple(types.Types[types.TUINT], types.Types[types.TUINT]), args[0], args[1])
 			}
@@ -3336,90 +3336,90 @@ func init() {
 		},
 		sys.AMD64, sys.I386, sys.MIPS64)
 	add("runtime", "KeepAlive",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			data := s.newValue1(ssa.OpIData, s.f.Config.Types.BytePtr, args[0])
 			s.vars[memVar] = s.newValue2(ssa.OpKeepAlive, types.TypeMem, data, s.mem())
 			return nil
 		},
 		all...)
 	add("runtime", "getclosureptr",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue0(ssa.OpGetClosurePtr, s.f.Config.Types.Uintptr)
 		},
 		all...)
 
 	add("runtime", "getcallerpc",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue0(ssa.OpGetCallerPC, s.f.Config.Types.Uintptr)
 		},
 		all...)
 
 	add("runtime", "getcallersp",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue0(ssa.OpGetCallerSP, s.f.Config.Types.Uintptr)
 		},
 		all...)
 
 	/******** runtime/internal/sys ********/
 	addF("runtime/internal/sys", "Ctz32",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpCtz32, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64)
 	addF("runtime/internal/sys", "Ctz64",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpCtz64, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64)
 	addF("runtime/internal/sys", "Bswap32",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpBswap32, types.Types[types.TUINT32], args[0])
 		},
 		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X)
 	addF("runtime/internal/sys", "Bswap64",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpBswap64, types.Types[types.TUINT64], args[0])
 		},
 		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X)
 
 	/******** runtime/internal/atomic ********/
 	addF("runtime/internal/atomic", "Load",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue2(ssa.OpAtomicLoad32, types.NewTuple(types.Types[types.TUINT32], types.TypeMem), args[0], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT32], v)
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Load8",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue2(ssa.OpAtomicLoad8, types.NewTuple(types.Types[types.TUINT8], types.TypeMem), args[0], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT8], v)
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Load64",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue2(ssa.OpAtomicLoad64, types.NewTuple(types.Types[types.TUINT64], types.TypeMem), args[0], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT64], v)
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "LoadAcq",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue2(ssa.OpAtomicLoadAcq32, types.NewTuple(types.Types[types.TUINT32], types.TypeMem), args[0], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT32], v)
 		},
 		sys.PPC64, sys.S390X)
 	addF("runtime/internal/atomic", "LoadAcq64",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue2(ssa.OpAtomicLoadAcq64, types.NewTuple(types.Types[types.TUINT64], types.TypeMem), args[0], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT64], v)
 		},
 		sys.PPC64)
 	addF("runtime/internal/atomic", "Loadp",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue2(ssa.OpAtomicLoadPtr, types.NewTuple(s.f.Config.Types.BytePtr, types.TypeMem), args[0], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, s.f.Config.Types.BytePtr, v)
@@ -3427,62 +3427,62 @@ func init() {
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 
 	addF("runtime/internal/atomic", "Store",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicStore32, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Store8",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicStore8, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Store64",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicStore64, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "StorepNoWB",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicStorePtrNoWB, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "StoreRel",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicStoreRel32, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.PPC64, sys.S390X)
 	addF("runtime/internal/atomic", "StoreRel64",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicStoreRel64, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.PPC64)
 
 	addF("runtime/internal/atomic", "Xchg",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue3(ssa.OpAtomicExchange32, types.NewTuple(types.Types[types.TUINT32], types.TypeMem), args[0], args[1], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT32], v)
 		},
 		sys.AMD64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Xchg64",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue3(ssa.OpAtomicExchange64, types.NewTuple(types.Types[types.TUINT64], types.TypeMem), args[0], args[1], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT64], v)
 		},
 		sys.AMD64, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 
-	type atomicOpEmitter func(s *state, n *ir.Node, args []*ssa.Value, op ssa.Op, typ types.EType)
+	type atomicOpEmitter func(s *state, n ir.Node, args []*ssa.Value, op ssa.Op, typ types.EType)
 
 	makeAtomicGuardedIntrinsicARM64 := func(op0, op1 ssa.Op, typ, rtyp types.EType, emit atomicOpEmitter) intrinsicBuilder {
 
-		return func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		return func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			// Target Atomic feature is identified by dynamic detection
 			addr := s.entryNewValue1A(ssa.OpAddr, types.Types[types.TBOOL].PtrTo(), arm64HasATOMICS, s.sb)
 			v := s.load(types.Types[types.TBOOL], addr)
@@ -3516,7 +3516,7 @@ func init() {
 		}
 	}
 
-	atomicXchgXaddEmitterARM64 := func(s *state, n *ir.Node, args []*ssa.Value, op ssa.Op, typ types.EType) {
+	atomicXchgXaddEmitterARM64 := func(s *state, n ir.Node, args []*ssa.Value, op ssa.Op, typ types.EType) {
 		v := s.newValue3(op, types.NewTuple(types.Types[typ], types.TypeMem), args[0], args[1], s.mem())
 		s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 		s.vars[n] = s.newValue1(ssa.OpSelect0, types.Types[typ], v)
@@ -3529,14 +3529,14 @@ func init() {
 		sys.ARM64)
 
 	addF("runtime/internal/atomic", "Xadd",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue3(ssa.OpAtomicAdd32, types.NewTuple(types.Types[types.TUINT32], types.TypeMem), args[0], args[1], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT32], v)
 		},
 		sys.AMD64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Xadd64",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue3(ssa.OpAtomicAdd64, types.NewTuple(types.Types[types.TUINT64], types.TypeMem), args[0], args[1], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT64], v)
@@ -3551,28 +3551,28 @@ func init() {
 		sys.ARM64)
 
 	addF("runtime/internal/atomic", "Cas",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue4(ssa.OpAtomicCompareAndSwap32, types.NewTuple(types.Types[types.TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TBOOL], v)
 		},
 		sys.AMD64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Cas64",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue4(ssa.OpAtomicCompareAndSwap64, types.NewTuple(types.Types[types.TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TBOOL], v)
 		},
 		sys.AMD64, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "CasRel",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			v := s.newValue4(ssa.OpAtomicCompareAndSwap32, types.NewTuple(types.Types[types.TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TBOOL], v)
 		},
 		sys.PPC64)
 
-	atomicCasEmitterARM64 := func(s *state, n *ir.Node, args []*ssa.Value, op ssa.Op, typ types.EType) {
+	atomicCasEmitterARM64 := func(s *state, n ir.Node, args []*ssa.Value, op ssa.Op, typ types.EType) {
 		v := s.newValue4(op, types.NewTuple(types.Types[types.TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
 		s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 		s.vars[n] = s.newValue1(ssa.OpSelect0, types.Types[typ], v)
@@ -3586,31 +3586,31 @@ func init() {
 		sys.ARM64)
 
 	addF("runtime/internal/atomic", "And8",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicAnd8, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.MIPS, sys.PPC64, sys.S390X)
 	addF("runtime/internal/atomic", "And",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicAnd32, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.MIPS, sys.PPC64, sys.S390X)
 	addF("runtime/internal/atomic", "Or8",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicOr8, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.PPC64, sys.S390X)
 	addF("runtime/internal/atomic", "Or",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicOr32, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.MIPS, sys.PPC64, sys.S390X)
 
-	atomicAndOrEmitterARM64 := func(s *state, n *ir.Node, args []*ssa.Value, op ssa.Op, typ types.EType) {
+	atomicAndOrEmitterARM64 := func(s *state, n ir.Node, args []*ssa.Value, op ssa.Op, typ types.EType) {
 		s.vars[memVar] = s.newValue3(op, types.TypeMem, args[0], args[1], s.mem())
 	}
 
@@ -3659,52 +3659,52 @@ func init() {
 
 	/******** math ********/
 	addF("math", "Sqrt",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpSqrt, types.Types[types.TFLOAT64], args[0])
 		},
 		sys.I386, sys.AMD64, sys.ARM, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X, sys.Wasm)
 	addF("math", "Trunc",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpTrunc, types.Types[types.TFLOAT64], args[0])
 		},
 		sys.ARM64, sys.PPC64, sys.S390X, sys.Wasm)
 	addF("math", "Ceil",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpCeil, types.Types[types.TFLOAT64], args[0])
 		},
 		sys.ARM64, sys.PPC64, sys.S390X, sys.Wasm)
 	addF("math", "Floor",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpFloor, types.Types[types.TFLOAT64], args[0])
 		},
 		sys.ARM64, sys.PPC64, sys.S390X, sys.Wasm)
 	addF("math", "Round",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpRound, types.Types[types.TFLOAT64], args[0])
 		},
 		sys.ARM64, sys.PPC64, sys.S390X)
 	addF("math", "RoundToEven",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpRoundToEven, types.Types[types.TFLOAT64], args[0])
 		},
 		sys.ARM64, sys.S390X, sys.Wasm)
 	addF("math", "Abs",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpAbs, types.Types[types.TFLOAT64], args[0])
 		},
 		sys.ARM64, sys.ARM, sys.PPC64, sys.Wasm)
 	addF("math", "Copysign",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue2(ssa.OpCopysign, types.Types[types.TFLOAT64], args[0], args[1])
 		},
 		sys.PPC64, sys.Wasm)
 	addF("math", "FMA",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue3(ssa.OpFMA, types.Types[types.TFLOAT64], args[0], args[1], args[2])
 		},
 		sys.ARM64, sys.PPC64, sys.S390X)
 	addF("math", "FMA",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			if !s.config.UseFMA {
 				s.vars[n] = s.callResult(n, callNormal) // types.Types[TFLOAT64]
 				return s.variable(n, types.Types[types.TFLOAT64])
@@ -3736,7 +3736,7 @@ func init() {
 		},
 		sys.AMD64)
 	addF("math", "FMA",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			if !s.config.UseFMA {
 				s.vars[n] = s.callResult(n, callNormal) // types.Types[TFLOAT64]
 				return s.variable(n, types.Types[types.TFLOAT64])
@@ -3769,8 +3769,8 @@ func init() {
 		},
 		sys.ARM)
 
-	makeRoundAMD64 := func(op ssa.Op) func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
-		return func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+	makeRoundAMD64 := func(op ssa.Op) func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		return func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			v := s.entryNewValue0A(ssa.OpHasCPUFeature, types.Types[types.TBOOL], x86HasSSE41)
 			b := s.endBlock()
 			b.Kind = ssa.BlockIf
@@ -3812,17 +3812,17 @@ func init() {
 
 	/******** math/bits ********/
 	addF("math/bits", "TrailingZeros64",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpCtz64, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
 	addF("math/bits", "TrailingZeros32",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpCtz32, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
 	addF("math/bits", "TrailingZeros16",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			x := s.newValue1(ssa.OpZeroExt16to32, types.Types[types.TUINT32], args[0])
 			c := s.constInt32(types.Types[types.TUINT32], 1<<16)
 			y := s.newValue2(ssa.OpOr32, types.Types[types.TUINT32], x, c)
@@ -3830,12 +3830,12 @@ func init() {
 		},
 		sys.MIPS)
 	addF("math/bits", "TrailingZeros16",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpCtz16, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.I386, sys.ARM, sys.ARM64, sys.Wasm)
 	addF("math/bits", "TrailingZeros16",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			x := s.newValue1(ssa.OpZeroExt16to64, types.Types[types.TUINT64], args[0])
 			c := s.constInt64(types.Types[types.TUINT64], 1<<16)
 			y := s.newValue2(ssa.OpOr64, types.Types[types.TUINT64], x, c)
@@ -3843,7 +3843,7 @@ func init() {
 		},
 		sys.S390X, sys.PPC64)
 	addF("math/bits", "TrailingZeros8",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			x := s.newValue1(ssa.OpZeroExt8to32, types.Types[types.TUINT32], args[0])
 			c := s.constInt32(types.Types[types.TUINT32], 1<<8)
 			y := s.newValue2(ssa.OpOr32, types.Types[types.TUINT32], x, c)
@@ -3851,12 +3851,12 @@ func init() {
 		},
 		sys.MIPS)
 	addF("math/bits", "TrailingZeros8",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpCtz8, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.ARM, sys.ARM64, sys.Wasm)
 	addF("math/bits", "TrailingZeros8",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			x := s.newValue1(ssa.OpZeroExt8to64, types.Types[types.TUINT64], args[0])
 			c := s.constInt64(types.Types[types.TUINT64], 1<<8)
 			y := s.newValue2(ssa.OpOr64, types.Types[types.TUINT64], x, c)
@@ -3868,17 +3868,17 @@ func init() {
 	// ReverseBytes inlines correctly, no need to intrinsify it.
 	// ReverseBytes16 lowers to a rotate, no need for anything special here.
 	addF("math/bits", "Len64",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpBitLen64, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
 	addF("math/bits", "Len32",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpBitLen32, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.ARM64)
 	addF("math/bits", "Len32",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			if s.config.PtrSize == 4 {
 				return s.newValue1(ssa.OpBitLen32, types.Types[types.TINT], args[0])
 			}
@@ -3887,7 +3887,7 @@ func init() {
 		},
 		sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
 	addF("math/bits", "Len16",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			if s.config.PtrSize == 4 {
 				x := s.newValue1(ssa.OpZeroExt16to32, types.Types[types.TUINT32], args[0])
 				return s.newValue1(ssa.OpBitLen32, types.Types[types.TINT], x)
@@ -3897,12 +3897,12 @@ func init() {
 		},
 		sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
 	addF("math/bits", "Len16",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpBitLen16, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64)
 	addF("math/bits", "Len8",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			if s.config.PtrSize == 4 {
 				x := s.newValue1(ssa.OpZeroExt8to32, types.Types[types.TUINT32], args[0])
 				return s.newValue1(ssa.OpBitLen32, types.Types[types.TINT], x)
@@ -3912,12 +3912,12 @@ func init() {
 		},
 		sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
 	addF("math/bits", "Len8",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpBitLen8, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64)
 	addF("math/bits", "Len",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			if s.config.PtrSize == 4 {
 				return s.newValue1(ssa.OpBitLen32, types.Types[types.TINT], args[0])
 			}
@@ -3926,27 +3926,27 @@ func init() {
 		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
 	// LeadingZeros is handled because it trivially calls Len.
 	addF("math/bits", "Reverse64",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpBitRev64, types.Types[types.TINT], args[0])
 		},
 		sys.ARM64)
 	addF("math/bits", "Reverse32",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpBitRev32, types.Types[types.TINT], args[0])
 		},
 		sys.ARM64)
 	addF("math/bits", "Reverse16",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpBitRev16, types.Types[types.TINT], args[0])
 		},
 		sys.ARM64)
 	addF("math/bits", "Reverse8",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpBitRev8, types.Types[types.TINT], args[0])
 		},
 		sys.ARM64)
 	addF("math/bits", "Reverse",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			if s.config.PtrSize == 4 {
 				return s.newValue1(ssa.OpBitRev32, types.Types[types.TINT], args[0])
 			}
@@ -3954,29 +3954,29 @@ func init() {
 		},
 		sys.ARM64)
 	addF("math/bits", "RotateLeft8",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue2(ssa.OpRotateLeft8, types.Types[types.TUINT8], args[0], args[1])
 		},
 		sys.AMD64)
 	addF("math/bits", "RotateLeft16",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue2(ssa.OpRotateLeft16, types.Types[types.TUINT16], args[0], args[1])
 		},
 		sys.AMD64)
 	addF("math/bits", "RotateLeft32",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue2(ssa.OpRotateLeft32, types.Types[types.TUINT32], args[0], args[1])
 		},
 		sys.AMD64, sys.ARM, sys.ARM64, sys.S390X, sys.PPC64, sys.Wasm)
 	addF("math/bits", "RotateLeft64",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue2(ssa.OpRotateLeft64, types.Types[types.TUINT64], args[0], args[1])
 		},
 		sys.AMD64, sys.ARM64, sys.S390X, sys.PPC64, sys.Wasm)
 	alias("math/bits", "RotateLeft", "math/bits", "RotateLeft64", p8...)
 
-	makeOnesCountAMD64 := func(op64 ssa.Op, op32 ssa.Op) func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
-		return func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+	makeOnesCountAMD64 := func(op64 ssa.Op, op32 ssa.Op) func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		return func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			v := s.entryNewValue0A(ssa.OpHasCPUFeature, types.Types[types.TBOOL], x86HasPOPCNT)
 			b := s.endBlock()
 			b.Kind = ssa.BlockIf
@@ -4011,7 +4011,7 @@ func init() {
 		makeOnesCountAMD64(ssa.OpPopCount64, ssa.OpPopCount64),
 		sys.AMD64)
 	addF("math/bits", "OnesCount64",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpPopCount64, types.Types[types.TINT], args[0])
 		},
 		sys.PPC64, sys.ARM64, sys.S390X, sys.Wasm)
@@ -4019,7 +4019,7 @@ func init() {
 		makeOnesCountAMD64(ssa.OpPopCount32, ssa.OpPopCount32),
 		sys.AMD64)
 	addF("math/bits", "OnesCount32",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpPopCount32, types.Types[types.TINT], args[0])
 		},
 		sys.PPC64, sys.ARM64, sys.S390X, sys.Wasm)
@@ -4027,12 +4027,12 @@ func init() {
 		makeOnesCountAMD64(ssa.OpPopCount16, ssa.OpPopCount16),
 		sys.AMD64)
 	addF("math/bits", "OnesCount16",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpPopCount16, types.Types[types.TINT], args[0])
 		},
 		sys.ARM64, sys.S390X, sys.PPC64, sys.Wasm)
 	addF("math/bits", "OnesCount8",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpPopCount8, types.Types[types.TINT], args[0])
 		},
 		sys.S390X, sys.PPC64, sys.Wasm)
@@ -4040,25 +4040,25 @@ func init() {
 		makeOnesCountAMD64(ssa.OpPopCount64, ssa.OpPopCount32),
 		sys.AMD64)
 	addF("math/bits", "Mul64",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue2(ssa.OpMul64uhilo, types.NewTuple(types.Types[types.TUINT64], types.Types[types.TUINT64]), args[0], args[1])
 		},
 		sys.AMD64, sys.ARM64, sys.PPC64, sys.S390X, sys.MIPS64)
 	alias("math/bits", "Mul", "math/bits", "Mul64", sys.ArchAMD64, sys.ArchARM64, sys.ArchPPC64, sys.ArchS390X, sys.ArchMIPS64, sys.ArchMIPS64LE)
 	addF("math/bits", "Add64",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue3(ssa.OpAdd64carry, types.NewTuple(types.Types[types.TUINT64], types.Types[types.TUINT64]), args[0], args[1], args[2])
 		},
 		sys.AMD64, sys.ARM64, sys.PPC64, sys.S390X)
 	alias("math/bits", "Add", "math/bits", "Add64", sys.ArchAMD64, sys.ArchARM64, sys.ArchPPC64, sys.ArchS390X)
 	addF("math/bits", "Sub64",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue3(ssa.OpSub64borrow, types.NewTuple(types.Types[types.TUINT64], types.Types[types.TUINT64]), args[0], args[1], args[2])
 		},
 		sys.AMD64, sys.ARM64, sys.S390X)
 	alias("math/bits", "Sub", "math/bits", "Sub64", sys.ArchAMD64, sys.ArchARM64, sys.ArchS390X)
 	addF("math/bits", "Div64",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			// check for divide-by-zero/overflow and panic with appropriate message
 			cmpZero := s.newValue2(s.ssaOp(ir.ONE, types.Types[types.TUINT64]), types.Types[types.TBOOL], args[2], s.zeroVal(types.Types[types.TUINT64]))
 			s.check(cmpZero, panicdivide)
@@ -4118,7 +4118,7 @@ func init() {
 
 	/******** math/big ********/
 	add("math/big", "mulWW",
-		func(s *state, n *ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			return s.newValue2(ssa.OpMul64uhilo, types.NewTuple(types.Types[types.TUINT64], types.Types[types.TUINT64]), args[0], args[1])
 		},
 		sys.ArchAMD64, sys.ArchARM64, sys.ArchPPC64LE, sys.ArchPPC64, sys.ArchS390X)
@@ -4156,7 +4156,7 @@ func findIntrinsic(sym *types.Sym) intrinsicBuilder {
 	return intrinsics[intrinsicKey{thearch.LinkArch.Arch, pkg, fn}]
 }
 
-func isIntrinsicCall(n *ir.Node) bool {
+func isIntrinsicCall(n ir.Node) bool {
 	if n == nil || n.Left() == nil {
 		return false
 	}
@@ -4164,7 +4164,7 @@ func isIntrinsicCall(n *ir.Node) bool {
 }
 
 // intrinsicCall converts a call to a recognized intrinsic function into the intrinsic SSA operation.
-func (s *state) intrinsicCall(n *ir.Node) *ssa.Value {
+func (s *state) intrinsicCall(n ir.Node) *ssa.Value {
 	v := findIntrinsic(n.Left().Sym())(s, n, s.intrinsicArgs(n))
 	if ssa.IntrinsicsDebug > 0 {
 		x := v
@@ -4180,9 +4180,9 @@ func (s *state) intrinsicCall(n *ir.Node) *ssa.Value {
 }
 
 // intrinsicArgs extracts args from n, evaluates them to SSA values, and returns them.
-func (s *state) intrinsicArgs(n *ir.Node) []*ssa.Value {
+func (s *state) intrinsicArgs(n ir.Node) []*ssa.Value {
 	// Construct map of temps; see comments in s.call about the structure of n.
-	temps := map[*ir.Node]*ssa.Value{}
+	temps := map[ir.Node]*ssa.Value{}
 	for _, a := range n.List().Slice() {
 		if a.Op() != ir.OAS {
 			s.Fatalf("non-assignment as a temp function argument %v", a.Op())
@@ -4215,7 +4215,7 @@ func (s *state) intrinsicArgs(n *ir.Node) []*ssa.Value {
 // call. We will also record funcdata information on where the args are stored
 // (as well as the deferBits variable), and this will enable us to run the proper
 // defer calls during panics.
-func (s *state) openDeferRecord(n *ir.Node) {
+func (s *state) openDeferRecord(n ir.Node) {
 	// Do any needed expression evaluation for the args (including the
 	// receiver, if any). This may be evaluating something like 'autotmp_3 =
 	// once.mutex'. Such a statement will create a mapping in s.vars[] from
@@ -4224,7 +4224,7 @@ func (s *state) openDeferRecord(n *ir.Node) {
 	s.stmtList(n.List())
 
 	var args []*ssa.Value
-	var argNodes []*ir.Node
+	var argNodes []ir.Node
 
 	opendefer := &openDeferInfo{
 		n: n,
@@ -4236,7 +4236,7 @@ func (s *state) openDeferRecord(n *ir.Node) {
 		// call the function directly if it is a static function.
 		closureVal := s.expr(fn)
 		closure := s.openDeferSave(nil, fn.Type(), closureVal)
-		opendefer.closureNode = closure.Aux.(*ir.Node)
+		opendefer.closureNode = closure.Aux.(ir.Node)
 		if !(fn.Op() == ir.ONAME && fn.Class() == ir.PFUNC) {
 			opendefer.closure = closure
 		}
@@ -4249,7 +4249,7 @@ func (s *state) openDeferRecord(n *ir.Node) {
 		// runtime panic code to use. But in the defer exit code, we will
 		// call the method directly.
 		closure := s.openDeferSave(nil, fn.Type(), closureVal)
-		opendefer.closureNode = closure.Aux.(*ir.Node)
+		opendefer.closureNode = closure.Aux.(ir.Node)
 	} else {
 		if fn.Op() != ir.ODOTINTER {
 			base.Fatalf("OCALLINTER: n.Left not an ODOTINTER: %v", fn.Op())
@@ -4259,8 +4259,8 @@ func (s *state) openDeferRecord(n *ir.Node) {
 		// Important to get the receiver type correct, so it is recognized
 		// as a pointer for GC purposes.
 		opendefer.rcvr = s.openDeferSave(nil, fn.Type().Recv().Type, rcvr)
-		opendefer.closureNode = opendefer.closure.Aux.(*ir.Node)
-		opendefer.rcvrNode = opendefer.rcvr.Aux.(*ir.Node)
+		opendefer.closureNode = opendefer.closure.Aux.(ir.Node)
+		opendefer.rcvrNode = opendefer.rcvr.Aux.(ir.Node)
 	}
 	for _, argn := range n.Rlist().Slice() {
 		var v *ssa.Value
@@ -4270,7 +4270,7 @@ func (s *state) openDeferRecord(n *ir.Node) {
 			v = s.openDeferSave(argn, argn.Type(), nil)
 		}
 		args = append(args, v)
-		argNodes = append(argNodes, v.Aux.(*ir.Node))
+		argNodes = append(argNodes, v.Aux.(ir.Node))
 	}
 	opendefer.argVals = args
 	opendefer.argNodes = argNodes
@@ -4292,7 +4292,7 @@ func (s *state) openDeferRecord(n *ir.Node) {
 // type t is non-SSAable, then n must be non-nil (and val should be nil) and n is
 // evaluated (via s.addr() below) to get the value that is to be stored. The
 // function returns an SSA value representing a pointer to the autotmp location.
-func (s *state) openDeferSave(n *ir.Node, t *types.Type, val *ssa.Value) *ssa.Value {
+func (s *state) openDeferSave(n ir.Node, t *types.Type, val *ssa.Value) *ssa.Value {
 	canSSA := canSSAType(t)
 	var pos src.XPos
 	if canSSA {
@@ -4476,17 +4476,17 @@ func (s *state) openDeferExit() {
 	}
 }
 
-func (s *state) callResult(n *ir.Node, k callKind) *ssa.Value {
+func (s *state) callResult(n ir.Node, k callKind) *ssa.Value {
 	return s.call(n, k, false)
 }
 
-func (s *state) callAddr(n *ir.Node, k callKind) *ssa.Value {
+func (s *state) callAddr(n ir.Node, k callKind) *ssa.Value {
 	return s.call(n, k, true)
 }
 
 // Calls the function n using the specified call type.
 // Returns the address of the return value (or nil if none).
-func (s *state) call(n *ir.Node, k callKind, returnResultAddr bool) *ssa.Value {
+func (s *state) call(n ir.Node, k callKind, returnResultAddr bool) *ssa.Value {
 	s.prevCall = nil
 	var sym *types.Sym     // target symbol (if static)
 	var closure *ssa.Value // ptr to closure to run (if dynamic)
@@ -4788,7 +4788,7 @@ func (s *state) maybeNilCheckClosure(closure *ssa.Value, k callKind) {
 }
 
 // getMethodClosure returns a value representing the closure for a method call
-func (s *state) getMethodClosure(fn *ir.Node) *ssa.Value {
+func (s *state) getMethodClosure(fn ir.Node) *ssa.Value {
 	// Make a name n2 for the function.
 	// fn.Sym might be sync.(*Mutex).Unlock.
 	// Make a PFUNC node out of that, then evaluate it.
@@ -4805,7 +4805,7 @@ func (s *state) getMethodClosure(fn *ir.Node) *ssa.Value {
 
 // getClosureAndRcvr returns values for the appropriate closure and receiver of an
 // interface call
-func (s *state) getClosureAndRcvr(fn *ir.Node) (*ssa.Value, *ssa.Value) {
+func (s *state) getClosureAndRcvr(fn ir.Node) (*ssa.Value, *ssa.Value) {
 	i := s.expr(fn.Left())
 	itab := s.newValue1(ssa.OpITab, types.Types[types.TUINTPTR], i)
 	s.nilCheck(itab)
@@ -4829,7 +4829,7 @@ func etypesign(e types.EType) int8 {
 
 // addr converts the address of the expression n to SSA, adds it to s and returns the SSA result.
 // The value that the returned Value represents is guaranteed to be non-nil.
-func (s *state) addr(n *ir.Node) *ssa.Value {
+func (s *state) addr(n ir.Node) *ssa.Value {
 	if n.Op() != ir.ONAME {
 		s.pushLine(n.Pos())
 		defer s.popLine()
@@ -4931,7 +4931,7 @@ func (s *state) addr(n *ir.Node) *ssa.Value {
 
 // canSSA reports whether n is SSA-able.
 // n must be an ONAME (or an ODOT sequence with an ONAME base).
-func (s *state) canSSA(n *ir.Node) bool {
+func (s *state) canSSA(n ir.Node) bool {
 	if base.Flag.N != 0 {
 		return false
 	}
@@ -5012,7 +5012,7 @@ func canSSAType(t *types.Type) bool {
 }
 
 // exprPtr evaluates n to a pointer and nil-checks it.
-func (s *state) exprPtr(n *ir.Node, bounded bool, lineno src.XPos) *ssa.Value {
+func (s *state) exprPtr(n ir.Node, bounded bool, lineno src.XPos) *ssa.Value {
 	p := s.expr(n)
 	if bounded || n.NonNil() {
 		if s.f.Frontend().Debug_checknil() && lineno.Line() > 1 {
@@ -5151,7 +5151,7 @@ func (s *state) check(cmp *ssa.Value, fn *obj.LSym) {
 	s.startBlock(bNext)
 }
 
-func (s *state) intDivide(n *ir.Node, a, b *ssa.Value) *ssa.Value {
+func (s *state) intDivide(n ir.Node, a, b *ssa.Value) *ssa.Value {
 	needcheck := true
 	switch b.Op {
 	case ssa.OpConst8, ssa.OpConst16, ssa.OpConst32, ssa.OpConst64:
@@ -5370,7 +5370,7 @@ func (s *state) storeTypePtrs(t *types.Type, left, right *ssa.Value) {
 // putArg evaluates n for the purpose of passing it as an argument to a function and returns the corresponding Param for the call.
 // If forLateExpandedCall is true, it returns the argument value to pass to the call operation.
 // If forLateExpandedCall is false, then the value is stored at the specified stack offset, and the returned value is nil.
-func (s *state) putArg(n *ir.Node, t *types.Type, off int64, forLateExpandedCall bool) (ssa.Param, *ssa.Value) {
+func (s *state) putArg(n ir.Node, t *types.Type, off int64, forLateExpandedCall bool) (ssa.Param, *ssa.Value) {
 	var a *ssa.Value
 	if forLateExpandedCall {
 		if !canSSAType(t) {
@@ -5384,7 +5384,7 @@ func (s *state) putArg(n *ir.Node, t *types.Type, off int64, forLateExpandedCall
 	return ssa.Param{Type: t, Offset: int32(off)}, a
 }
 
-func (s *state) storeArgWithBase(n *ir.Node, t *types.Type, base *ssa.Value, off int64) {
+func (s *state) storeArgWithBase(n ir.Node, t *types.Type, base *ssa.Value, off int64) {
 	pt := types.NewPtr(t)
 	var addr *ssa.Value
 	if base == s.sp {
@@ -5545,15 +5545,15 @@ var u64_f32 = u642fcvtTab{
 	one:   (*state).constInt64,
 }
 
-func (s *state) uint64Tofloat64(n *ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) uint64Tofloat64(n ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
 	return s.uint64Tofloat(&u64_f64, n, x, ft, tt)
 }
 
-func (s *state) uint64Tofloat32(n *ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) uint64Tofloat32(n ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
 	return s.uint64Tofloat(&u64_f32, n, x, ft, tt)
 }
 
-func (s *state) uint64Tofloat(cvttab *u642fcvtTab, n *ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) uint64Tofloat(cvttab *u642fcvtTab, n ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
 	// if x >= 0 {
 	//    result = (floatY) x
 	// } else {
@@ -5626,15 +5626,15 @@ var u32_f32 = u322fcvtTab{
 	cvtF2F: ssa.OpCvt64Fto32F,
 }
 
-func (s *state) uint32Tofloat64(n *ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) uint32Tofloat64(n ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
 	return s.uint32Tofloat(&u32_f64, n, x, ft, tt)
 }
 
-func (s *state) uint32Tofloat32(n *ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) uint32Tofloat32(n ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
 	return s.uint32Tofloat(&u32_f32, n, x, ft, tt)
 }
 
-func (s *state) uint32Tofloat(cvttab *u322fcvtTab, n *ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) uint32Tofloat(cvttab *u322fcvtTab, n ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
 	// if x >= 0 {
 	// 	result = floatY(x)
 	// } else {
@@ -5673,7 +5673,7 @@ func (s *state) uint32Tofloat(cvttab *u322fcvtTab, n *ir.Node, x *ssa.Value, ft,
 }
 
 // referenceTypeBuiltin generates code for the len/cap builtins for maps and channels.
-func (s *state) referenceTypeBuiltin(n *ir.Node, x *ssa.Value) *ssa.Value {
+func (s *state) referenceTypeBuiltin(n ir.Node, x *ssa.Value) *ssa.Value {
 	if !n.Left().Type().IsMap() && !n.Left().Type().IsChan() {
 		s.Fatalf("node must be a map or a channel")
 	}
@@ -5771,22 +5771,22 @@ var f64_u32 = f2uCvtTab{
 	cutoff:     1 << 31,
 }
 
-func (s *state) float32ToUint64(n *ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) float32ToUint64(n ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
 	return s.floatToUint(&f32_u64, n, x, ft, tt)
 }
-func (s *state) float64ToUint64(n *ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) float64ToUint64(n ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
 	return s.floatToUint(&f64_u64, n, x, ft, tt)
 }
 
-func (s *state) float32ToUint32(n *ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) float32ToUint32(n ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
 	return s.floatToUint(&f32_u32, n, x, ft, tt)
 }
 
-func (s *state) float64ToUint32(n *ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) float64ToUint32(n ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
 	return s.floatToUint(&f64_u32, n, x, ft, tt)
 }
 
-func (s *state) floatToUint(cvttab *f2uCvtTab, n *ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
+func (s *state) floatToUint(cvttab *f2uCvtTab, n ir.Node, x *ssa.Value, ft, tt *types.Type) *ssa.Value {
 	// cutoff:=1<<(intY_Size-1)
 	// if x < floatX(cutoff) {
 	// 	result = uintY(x)
@@ -5830,7 +5830,7 @@ func (s *state) floatToUint(cvttab *f2uCvtTab, n *ir.Node, x *ssa.Value, ft, tt
 // dottype generates SSA for a type assertion node.
 // commaok indicates whether to panic or return a bool.
 // If commaok is false, resok will be nil.
-func (s *state) dottype(n *ir.Node, commaok bool) (res, resok *ssa.Value) {
+func (s *state) dottype(n ir.Node, commaok bool) (res, resok *ssa.Value) {
 	iface := s.expr(n.Left())   // input interface
 	target := s.expr(n.Right()) // target type
 	byteptr := s.f.Config.Types.BytePtr
@@ -5942,7 +5942,7 @@ func (s *state) dottype(n *ir.Node, commaok bool) (res, resok *ssa.Value) {
 		targetITab = s.expr(n.List().First())
 	}
 
-	var tmp *ir.Node    // temporary for use with large types
+	var tmp ir.Node     // temporary for use with large types
 	var addr *ssa.Value // address of tmp
 	if commaok && !canSSAType(n.Type()) {
 		// unSSAable type, use temporary.
@@ -6032,7 +6032,7 @@ func (s *state) dottype(n *ir.Node, commaok bool) (res, resok *ssa.Value) {
 }
 
 // variable returns the value of a variable at the current location.
-func (s *state) variable(name *ir.Node, t *types.Type) *ssa.Value {
+func (s *state) variable(name ir.Node, t *types.Type) *ssa.Value {
 	v := s.vars[name]
 	if v != nil {
 		return v
@@ -6058,7 +6058,7 @@ func (s *state) mem() *ssa.Value {
 	return s.variable(memVar, types.TypeMem)
 }
 
-func (s *state) addNamedValue(n *ir.Node, v *ssa.Value) {
+func (s *state) addNamedValue(n ir.Node, v *ssa.Value) {
 	if n.Class() == ir.Pxxx {
 		// Don't track our marker nodes (memVar etc.).
 		return
@@ -6111,7 +6111,7 @@ type SSAGenState struct {
 	bstart []*obj.Prog
 
 	// Some architectures require a 64-bit temporary for FP-related register shuffling. Examples include PPC and Sparc V8.
-	ScratchFpMem *ir.Node
+	ScratchFpMem ir.Node
 
 	maxarg int64 // largest frame size for arguments to calls made by the function
 
@@ -6194,14 +6194,14 @@ func (s *SSAGenState) DebugFriendlySetPosFrom(v *ssa.Value) {
 }
 
 // byXoffset implements sort.Interface for []*Node using Xoffset as the ordering.
-type byXoffset []*ir.Node
+type byXoffset []ir.Node
 
 func (s byXoffset) Len() int           { return len(s) }
 func (s byXoffset) Less(i, j int) bool { return s[i].Offset() < s[j].Offset() }
 func (s byXoffset) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 
 func emitStackObjects(e *ssafn, pp *Progs) {
-	var vars []*ir.Node
+	var vars []ir.Node
 	for _, n := range e.curfn.Func().Dcl {
 		if livenessShouldTrack(n) && n.Name().Addrtaken() {
 			vars = append(vars, n)
@@ -6677,7 +6677,7 @@ func AddAux2(a *obj.Addr, v *ssa.Value, offset int64) {
 	case *obj.LSym:
 		a.Name = obj.NAME_EXTERN
 		a.Sym = n
-	case *ir.Node:
+	case ir.Node:
 		if n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT {
 			a.Name = obj.NAME_PARAM
 			a.Sym = n.Orig().Sym().Linksym()
@@ -6816,7 +6816,7 @@ func CheckLoweredGetClosurePtr(v *ssa.Value) {
 
 // AutoVar returns a *Node and int64 representing the auto variable and offset within it
 // where v should be spilled.
-func AutoVar(v *ssa.Value) (*ir.Node, int64) {
+func AutoVar(v *ssa.Value) (ir.Node, int64) {
 	loc := v.Block.Func.RegAlloc[v.ID].(ssa.LocalSlot)
 	if v.Type.Size() > loc.Type.Size() {
 		v.Fatalf("spill/restore type %s doesn't fit in slot type %s", v.Type, loc.Type)
@@ -6927,7 +6927,7 @@ func (s *SSAGenState) UseArgs(n int64) {
 }
 
 // fieldIdx finds the index of the field referred to by the ODOT node n.
-func fieldIdx(n *ir.Node) int {
+func fieldIdx(n ir.Node) int {
 	t := n.Left().Type()
 	f := n.Sym()
 	if !t.IsStruct() {
@@ -6954,9 +6954,9 @@ func fieldIdx(n *ir.Node) int {
 // ssafn holds frontend information about a function that the backend is processing.
 // It also exports a bunch of compiler services for the ssa backend.
 type ssafn struct {
-	curfn        *ir.Node
+	curfn        ir.Node
 	strings      map[string]*obj.LSym // map from constant string to data symbols
-	scratchFpMem *ir.Node             // temp for floating point register / memory moves on some architectures
+	scratchFpMem ir.Node              // temp for floating point register / memory moves on some architectures
 	stksize      int64                // stack size for current frame
 	stkptrsize   int64                // prefix of stack containing pointers
 	log          bool                 // print ssa debug to the stdout
@@ -6976,7 +6976,7 @@ func (e *ssafn) StringData(s string) *obj.LSym {
 	return data
 }
 
-func (e *ssafn) Auto(pos src.XPos, t *types.Type) *ir.Node {
+func (e *ssafn) Auto(pos src.XPos, t *types.Type) ir.Node {
 	n := tempAt(pos, e.curfn, t) // Note: adds new auto to e.curfn.Func.Dcl list
 	return n
 }
@@ -7148,7 +7148,7 @@ func (e *ssafn) MyImportPath() string {
 	return base.Ctxt.Pkgpath
 }
 
-func clobberBase(n *ir.Node) *ir.Node {
+func clobberBase(n ir.Node) ir.Node {
 	if n.Op() == ir.ODOT && n.Left().Type().NumFields() == 1 {
 		return clobberBase(n.Left())
 	}
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 542dc49bb0..fcda219737 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -40,7 +40,7 @@ var (
 // It's primarily used to distinguish references to named objects,
 // whose Pos will point back to their declaration position rather than
 // their usage position.
-func hasUniquePos(n *ir.Node) bool {
+func hasUniquePos(n ir.Node) bool {
 	switch n.Op() {
 	case ir.ONAME, ir.OPACK:
 		return false
@@ -60,7 +60,7 @@ func hasUniquePos(n *ir.Node) bool {
 	return true
 }
 
-func setlineno(n *ir.Node) src.XPos {
+func setlineno(n ir.Node) src.XPos {
 	lno := base.Pos
 	if n != nil && hasUniquePos(n) {
 		base.Pos = n.Pos()
@@ -102,7 +102,7 @@ func autolabel(prefix string) *types.Sym {
 
 // find all the exported symbols in package opkg
 // and make them available in the current package
-func importdot(opkg *types.Pkg, pack *ir.Node) {
+func importdot(opkg *types.Pkg, pack ir.Node) {
 	n := 0
 	for _, s := range opkg.Syms {
 		if s.Def == nil {
@@ -136,7 +136,7 @@ func importdot(opkg *types.Pkg, pack *ir.Node) {
 }
 
 // newname returns a new ONAME Node associated with symbol s.
-func NewName(s *types.Sym) *ir.Node {
+func NewName(s *types.Sym) ir.Node {
 	n := ir.NewNameAt(base.Pos, s)
 	n.Name().Curfn = Curfn
 	return n
@@ -144,13 +144,13 @@ func NewName(s *types.Sym) *ir.Node {
 
 // nodSym makes a Node with Op op and with the Left field set to left
 // and the Sym field set to sym. This is for ODOT and friends.
-func nodSym(op ir.Op, left *ir.Node, sym *types.Sym) *ir.Node {
+func nodSym(op ir.Op, left ir.Node, sym *types.Sym) ir.Node {
 	return nodlSym(base.Pos, op, left, sym)
 }
 
 // nodlSym makes a Node with position Pos, with Op op, and with the Left field set to left
 // and the Sym field set to sym. This is for ODOT and friends.
-func nodlSym(pos src.XPos, op ir.Op, left *ir.Node, sym *types.Sym) *ir.Node {
+func nodlSym(pos src.XPos, op ir.Op, left ir.Node, sym *types.Sym) ir.Node {
 	n := ir.NodAt(pos, op, left, nil)
 	n.SetSym(sym)
 	return n
@@ -163,21 +163,21 @@ func (x methcmp) Len() int           { return len(x) }
 func (x methcmp) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
 func (x methcmp) Less(i, j int) bool { return x[i].Sym.Less(x[j].Sym) }
 
-func nodintconst(v int64) *ir.Node {
+func nodintconst(v int64) ir.Node {
 	return ir.NewLiteral(constant.MakeInt64(v))
 }
 
-func nodnil() *ir.Node {
+func nodnil() ir.Node {
 	n := ir.Nod(ir.ONIL, nil, nil)
 	n.SetType(types.Types[types.TNIL])
 	return n
 }
 
-func nodbool(b bool) *ir.Node {
+func nodbool(b bool) ir.Node {
 	return ir.NewLiteral(constant.MakeBool(b))
 }
 
-func nodstr(s string) *ir.Node {
+func nodstr(s string) ir.Node {
 	return ir.NewLiteral(constant.MakeString(s))
 }
 
@@ -185,7 +185,7 @@ func nodstr(s string) *ir.Node {
 // ONAME, OLITERAL, OTYPE, and ONONAME leaves.
 // If pos.IsKnown(), it sets the source position of newly
 // allocated nodes to pos.
-func treecopy(n *ir.Node, pos src.XPos) *ir.Node {
+func treecopy(n ir.Node, pos src.XPos) ir.Node {
 	if n == nil {
 		return nil
 	}
@@ -511,12 +511,12 @@ func convertop(srcConstant bool, src, dst *types.Type) (ir.Op, string) {
 	return ir.OXXX, ""
 }
 
-func assignconv(n *ir.Node, t *types.Type, context string) *ir.Node {
+func assignconv(n ir.Node, t *types.Type, context string) ir.Node {
 	return assignconvfn(n, t, func() string { return context })
 }
 
 // Convert node n for assignment to type t.
-func assignconvfn(n *ir.Node, t *types.Type, context func() string) *ir.Node {
+func assignconvfn(n ir.Node, t *types.Type, context func() string) ir.Node {
 	if n == nil || n.Type() == nil || n.Type().Broke() {
 		return n
 	}
@@ -565,7 +565,7 @@ func assignconvfn(n *ir.Node, t *types.Type, context func() string) *ir.Node {
 
 // backingArrayPtrLen extracts the pointer and length from a slice or string.
 // This constructs two nodes referring to n, so n must be a cheapexpr.
-func backingArrayPtrLen(n *ir.Node) (ptr, len *ir.Node) {
+func backingArrayPtrLen(n ir.Node) (ptr, len ir.Node) {
 	var init ir.Nodes
 	c := cheapexpr(n, &init)
 	if c != n || init.Len() != 0 {
@@ -584,7 +584,7 @@ func backingArrayPtrLen(n *ir.Node) (ptr, len *ir.Node) {
 
 // labeledControl returns the control flow Node (for, switch, select)
 // associated with the label n, if any.
-func labeledControl(n *ir.Node) *ir.Node {
+func labeledControl(n ir.Node) ir.Node {
 	if n.Op() != ir.OLABEL {
 		base.Fatalf("labeledControl %v", n.Op())
 	}
@@ -599,7 +599,7 @@ func labeledControl(n *ir.Node) *ir.Node {
 	return nil
 }
 
-func syslook(name string) *ir.Node {
+func syslook(name string) ir.Node {
 	s := Runtimepkg.Lookup(name)
 	if s == nil || s.Def == nil {
 		base.Fatalf("syslook: can't find runtime.%s", name)
@@ -618,14 +618,14 @@ func typehash(t *types.Type) uint32 {
 
 // updateHasCall checks whether expression n contains any function
 // calls and sets the n.HasCall flag if so.
-func updateHasCall(n *ir.Node) {
+func updateHasCall(n ir.Node) {
 	if n == nil {
 		return
 	}
 	n.SetHasCall(calcHasCall(n))
 }
 
-func calcHasCall(n *ir.Node) bool {
+func calcHasCall(n ir.Node) bool {
 	if n.Init().Len() != 0 {
 		// TODO(mdempsky): This seems overly conservative.
 		return true
@@ -740,7 +740,7 @@ func brrev(op ir.Op) ir.Op {
 
 // return side effect-free n, appending side effects to init.
 // result is assignable if n is.
-func safeexpr(n *ir.Node, init *ir.Nodes) *ir.Node {
+func safeexpr(n ir.Node, init *ir.Nodes) ir.Node {
 	if n == nil {
 		return nil
 	}
@@ -800,7 +800,7 @@ func safeexpr(n *ir.Node, init *ir.Nodes) *ir.Node {
 	return cheapexpr(n, init)
 }
 
-func copyexpr(n *ir.Node, t *types.Type, init *ir.Nodes) *ir.Node {
+func copyexpr(n ir.Node, t *types.Type, init *ir.Nodes) ir.Node {
 	l := temp(t)
 	a := ir.Nod(ir.OAS, l, n)
 	a = typecheck(a, ctxStmt)
@@ -811,7 +811,7 @@ func copyexpr(n *ir.Node, t *types.Type, init *ir.Nodes) *ir.Node {
 
 // return side-effect free and cheap n, appending side effects to init.
 // result may not be assignable.
-func cheapexpr(n *ir.Node, init *ir.Nodes) *ir.Node {
+func cheapexpr(n ir.Node, init *ir.Nodes) ir.Node {
 	switch n.Op() {
 	case ir.ONAME, ir.OLITERAL, ir.ONIL:
 		return n
@@ -957,7 +957,7 @@ func dotpath(s *types.Sym, t *types.Type, save **types.Field, ignorecase bool) (
 // find missing fields that
 // will give shortest unique addressing.
 // modify the tree with missing type names.
-func adddot(n *ir.Node) *ir.Node {
+func adddot(n ir.Node) ir.Node {
 	n.SetLeft(typecheck(n.Left(), ctxType|ctxExpr))
 	if n.Left().Diag() {
 		n.SetDiag(true)
@@ -1116,8 +1116,8 @@ func expandmeth(t *types.Type) {
 }
 
 // Given funarg struct list, return list of ODCLFIELD Node fn args.
-func structargs(tl *types.Type, mustname bool) []*ir.Node {
-	var args []*ir.Node
+func structargs(tl *types.Type, mustname bool) []ir.Node {
+	var args []ir.Node
 	gen := 0
 	for _, t := range tl.Fields().Slice() {
 		s := t.Sym
@@ -1250,30 +1250,30 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	if rcvr.IsPtr() && rcvr.Elem() == method.Type.Recv().Type && rcvr.Elem().Sym != nil {
 		inlcalls(fn)
 	}
-	escapeFuncs([]*ir.Node{fn}, false)
+	escapeFuncs([]ir.Node{fn}, false)
 
 	Curfn = nil
 	xtop = append(xtop, fn)
 }
 
-func paramNnames(ft *types.Type) []*ir.Node {
-	args := make([]*ir.Node, ft.NumParams())
+func paramNnames(ft *types.Type) []ir.Node {
+	args := make([]ir.Node, ft.NumParams())
 	for i, f := range ft.Params().FieldSlice() {
 		args[i] = ir.AsNode(f.Nname)
 	}
 	return args
 }
 
-func hashmem(t *types.Type) *ir.Node {
+func hashmem(t *types.Type) ir.Node {
 	sym := Runtimepkg.Lookup("memhash")
 
 	n := NewName(sym)
 	setNodeNameFunc(n)
-	n.SetType(functype(nil, []*ir.Node{
+	n.SetType(functype(nil, []ir.Node{
 		anonfield(types.NewPtr(t)),
 		anonfield(types.Types[types.TUINTPTR]),
 		anonfield(types.Types[types.TUINTPTR]),
-	}, []*ir.Node{
+	}, []ir.Node{
 		anonfield(types.Types[types.TUINTPTR]),
 	}))
 	return n
@@ -1393,15 +1393,15 @@ func implements(t, iface *types.Type, m, samename **types.Field, ptr *int) bool
 	return true
 }
 
-func listtreecopy(l []*ir.Node, pos src.XPos) []*ir.Node {
-	var out []*ir.Node
+func listtreecopy(l []ir.Node, pos src.XPos) []ir.Node {
+	var out []ir.Node
 	for _, n := range l {
 		out = append(out, treecopy(n, pos))
 	}
 	return out
 }
 
-func liststmt(l []*ir.Node) *ir.Node {
+func liststmt(l []ir.Node) ir.Node {
 	n := ir.Nod(ir.OBLOCK, nil, nil)
 	n.PtrList().Set(l)
 	if len(l) != 0 {
@@ -1410,7 +1410,7 @@ func liststmt(l []*ir.Node) *ir.Node {
 	return n
 }
 
-func ngotype(n *ir.Node) *types.Sym {
+func ngotype(n ir.Node) *types.Sym {
 	if n.Type() != nil {
 		return typenamesym(n.Type())
 	}
@@ -1419,7 +1419,7 @@ func ngotype(n *ir.Node) *types.Sym {
 
 // The result of addinit MUST be assigned back to n, e.g.
 // 	n.Left = addinit(n.Left, init)
-func addinit(n *ir.Node, init []*ir.Node) *ir.Node {
+func addinit(n ir.Node, init []ir.Node) ir.Node {
 	if len(init) == 0 {
 		return n
 	}
@@ -1518,7 +1518,7 @@ func isdirectiface(t *types.Type) bool {
 }
 
 // itabType loads the _type field from a runtime.itab struct.
-func itabType(itab *ir.Node) *ir.Node {
+func itabType(itab ir.Node) ir.Node {
 	typ := nodSym(ir.ODOTPTR, itab, nil)
 	typ.SetType(types.NewPtr(types.Types[types.TUINT8]))
 	typ.SetTypecheck(1)
@@ -1530,7 +1530,7 @@ func itabType(itab *ir.Node) *ir.Node {
 // ifaceData loads the data field from an interface.
 // The concrete type must be known to have type t.
 // It follows the pointer if !isdirectiface(t).
-func ifaceData(pos src.XPos, n *ir.Node, t *types.Type) *ir.Node {
+func ifaceData(pos src.XPos, n ir.Node, t *types.Type) ir.Node {
 	if t.IsInterface() {
 		base.Fatalf("ifaceData interface: %v", t)
 	}
diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index c85483fafa..02d38ac4b1 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -15,7 +15,7 @@ import (
 )
 
 // typecheckswitch typechecks a switch statement.
-func typecheckswitch(n *ir.Node) {
+func typecheckswitch(n ir.Node) {
 	typecheckslice(n.Init().Slice(), ctxStmt)
 	if n.Left() != nil && n.Left().Op() == ir.OTYPESW {
 		typecheckTypeSwitch(n)
@@ -24,7 +24,7 @@ func typecheckswitch(n *ir.Node) {
 	}
 }
 
-func typecheckTypeSwitch(n *ir.Node) {
+func typecheckTypeSwitch(n ir.Node) {
 	n.Left().SetRight(typecheck(n.Left().Right(), ctxExpr))
 	t := n.Left().Right().Type()
 	if t != nil && !t.IsInterface() {
@@ -39,7 +39,7 @@ func typecheckTypeSwitch(n *ir.Node) {
 		base.ErrorfAt(v.Pos(), "%v declared but not used", v.Sym())
 	}
 
-	var defCase, nilCase *ir.Node
+	var defCase, nilCase ir.Node
 	var ts typeSet
 	for _, ncase := range n.List().Slice() {
 		ls := ncase.List().Slice()
@@ -144,7 +144,7 @@ func (s *typeSet) add(pos src.XPos, typ *types.Type) {
 	s.m[ls] = append(prevs, typeSetEntry{pos, typ})
 }
 
-func typecheckExprSwitch(n *ir.Node) {
+func typecheckExprSwitch(n ir.Node) {
 	t := types.Types[types.TBOOL]
 	if n.Left() != nil {
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
@@ -172,7 +172,7 @@ func typecheckExprSwitch(n *ir.Node) {
 		}
 	}
 
-	var defCase *ir.Node
+	var defCase ir.Node
 	var cs constSet
 	for _, ncase := range n.List().Slice() {
 		ls := ncase.List().Slice()
@@ -225,7 +225,7 @@ func typecheckExprSwitch(n *ir.Node) {
 }
 
 // walkswitch walks a switch statement.
-func walkswitch(sw *ir.Node) {
+func walkswitch(sw ir.Node) {
 	// Guard against double walk, see #25776.
 	if sw.List().Len() == 0 && sw.Body().Len() > 0 {
 		return // Was fatal, but eliminating every possible source of double-walking is hard
@@ -240,7 +240,7 @@ func walkswitch(sw *ir.Node) {
 
 // walkExprSwitch generates an AST implementing sw.  sw is an
 // expression switch.
-func walkExprSwitch(sw *ir.Node) {
+func walkExprSwitch(sw ir.Node) {
 	lno := setlineno(sw)
 
 	cond := sw.Left()
@@ -275,7 +275,7 @@ func walkExprSwitch(sw *ir.Node) {
 		exprname: cond,
 	}
 
-	var defaultGoto *ir.Node
+	var defaultGoto ir.Node
 	var body ir.Nodes
 	for _, ncase := range sw.List().Slice() {
 		label := autolabel(".s")
@@ -318,7 +318,7 @@ func walkExprSwitch(sw *ir.Node) {
 
 // An exprSwitch walks an expression switch.
 type exprSwitch struct {
-	exprname *ir.Node // value being switched on
+	exprname ir.Node // value being switched on
 
 	done    ir.Nodes
 	clauses []exprClause
@@ -326,11 +326,11 @@ type exprSwitch struct {
 
 type exprClause struct {
 	pos    src.XPos
-	lo, hi *ir.Node
-	jmp    *ir.Node
+	lo, hi ir.Node
+	jmp    ir.Node
 }
 
-func (s *exprSwitch) Add(pos src.XPos, expr, jmp *ir.Node) {
+func (s *exprSwitch) Add(pos src.XPos, expr, jmp ir.Node) {
 	c := exprClause{pos: pos, lo: expr, hi: expr, jmp: jmp}
 	if okforcmp[s.exprname.Type().Etype] && expr.Op() == ir.OLITERAL {
 		s.clauses = append(s.clauses, c)
@@ -390,10 +390,10 @@ func (s *exprSwitch) flush() {
 
 		// Perform two-level binary search.
 		binarySearch(len(runs), &s.done,
-			func(i int) *ir.Node {
+			func(i int) ir.Node {
 				return ir.Nod(ir.OLE, ir.Nod(ir.OLEN, s.exprname, nil), nodintconst(runLen(runs[i-1])))
 			},
-			func(i int, nif *ir.Node) {
+			func(i int, nif ir.Node) {
 				run := runs[i]
 				nif.SetLeft(ir.Nod(ir.OEQ, ir.Nod(ir.OLEN, s.exprname, nil), nodintconst(runLen(run))))
 				s.search(run, nif.PtrBody())
@@ -425,10 +425,10 @@ func (s *exprSwitch) flush() {
 
 func (s *exprSwitch) search(cc []exprClause, out *ir.Nodes) {
 	binarySearch(len(cc), out,
-		func(i int) *ir.Node {
+		func(i int) ir.Node {
 			return ir.Nod(ir.OLE, s.exprname, cc[i-1].hi)
 		},
-		func(i int, nif *ir.Node) {
+		func(i int, nif ir.Node) {
 			c := &cc[i]
 			nif.SetLeft(c.test(s.exprname))
 			nif.PtrBody().Set1(c.jmp)
@@ -436,7 +436,7 @@ func (s *exprSwitch) search(cc []exprClause, out *ir.Nodes) {
 	)
 }
 
-func (c *exprClause) test(exprname *ir.Node) *ir.Node {
+func (c *exprClause) test(exprname ir.Node) ir.Node {
 	// Integer range.
 	if c.hi != c.lo {
 		low := ir.NodAt(c.pos, ir.OGE, exprname, c.lo)
@@ -456,7 +456,7 @@ func (c *exprClause) test(exprname *ir.Node) *ir.Node {
 	return ir.NodAt(c.pos, ir.OEQ, exprname, c.lo)
 }
 
-func allCaseExprsAreSideEffectFree(sw *ir.Node) bool {
+func allCaseExprsAreSideEffectFree(sw ir.Node) bool {
 	// In theory, we could be more aggressive, allowing any
 	// side-effect-free expressions in cases, but it's a bit
 	// tricky because some of that information is unavailable due
@@ -478,7 +478,7 @@ func allCaseExprsAreSideEffectFree(sw *ir.Node) bool {
 }
 
 // hasFall reports whether stmts ends with a "fallthrough" statement.
-func hasFall(stmts []*ir.Node) (bool, src.XPos) {
+func hasFall(stmts []ir.Node) (bool, src.XPos) {
 	// Search backwards for the index of the fallthrough
 	// statement. Do not assume it'll be in the last
 	// position, since in some cases (e.g. when the statement
@@ -497,7 +497,7 @@ func hasFall(stmts []*ir.Node) (bool, src.XPos) {
 
 // walkTypeSwitch generates an AST that implements sw, where sw is a
 // type switch.
-func walkTypeSwitch(sw *ir.Node) {
+func walkTypeSwitch(sw ir.Node) {
 	var s typeSwitch
 	s.facename = sw.Left().Right()
 	sw.SetLeft(nil)
@@ -538,10 +538,10 @@ func walkTypeSwitch(sw *ir.Node) {
 	s.hashname = copyexpr(dotHash, dotHash.Type(), sw.PtrBody())
 
 	br := ir.Nod(ir.OBREAK, nil, nil)
-	var defaultGoto, nilGoto *ir.Node
+	var defaultGoto, nilGoto ir.Node
 	var body ir.Nodes
 	for _, ncase := range sw.List().Slice() {
-		var caseVar *ir.Node
+		var caseVar ir.Node
 		if ncase.Rlist().Len() != 0 {
 			caseVar = ncase.Rlist().First()
 		}
@@ -592,7 +592,7 @@ func walkTypeSwitch(sw *ir.Node) {
 				}
 				val = ifaceData(ncase.Pos(), s.facename, singleType)
 			}
-			l := []*ir.Node{
+			l := []ir.Node{
 				ir.NodAt(ncase.Pos(), ir.ODCL, caseVar, nil),
 				ir.NodAt(ncase.Pos(), ir.OAS, caseVar, val),
 			}
@@ -622,9 +622,9 @@ func walkTypeSwitch(sw *ir.Node) {
 // A typeSwitch walks a type switch.
 type typeSwitch struct {
 	// Temporary variables (i.e., ONAMEs) used by type switch dispatch logic:
-	facename *ir.Node // value being type-switched on
-	hashname *ir.Node // type hash of the value being type-switched on
-	okname   *ir.Node // boolean used for comma-ok type assertions
+	facename ir.Node // value being type-switched on
+	hashname ir.Node // type hash of the value being type-switched on
+	okname   ir.Node // boolean used for comma-ok type assertions
 
 	done    ir.Nodes
 	clauses []typeClause
@@ -635,10 +635,10 @@ type typeClause struct {
 	body ir.Nodes
 }
 
-func (s *typeSwitch) Add(pos src.XPos, typ *types.Type, caseVar, jmp *ir.Node) {
+func (s *typeSwitch) Add(pos src.XPos, typ *types.Type, caseVar, jmp ir.Node) {
 	var body ir.Nodes
 	if caseVar != nil {
-		l := []*ir.Node{
+		l := []ir.Node{
 			ir.NodAt(pos, ir.ODCL, caseVar, nil),
 			ir.NodAt(pos, ir.OAS, caseVar, nil),
 		}
@@ -703,10 +703,10 @@ func (s *typeSwitch) flush() {
 	cc = merged
 
 	binarySearch(len(cc), &s.done,
-		func(i int) *ir.Node {
+		func(i int) ir.Node {
 			return ir.Nod(ir.OLE, s.hashname, nodintconst(int64(cc[i-1].hash)))
 		},
-		func(i int, nif *ir.Node) {
+		func(i int, nif ir.Node) {
 			// TODO(mdempsky): Omit hash equality check if
 			// there's only one type.
 			c := cc[i]
@@ -725,7 +725,7 @@ func (s *typeSwitch) flush() {
 //
 // leaf(i, nif) should setup nif (an OIF node) to test case i. In
 // particular, it should set nif.Left and nif.Nbody.
-func binarySearch(n int, out *ir.Nodes, less func(i int) *ir.Node, leaf func(i int, nif *ir.Node)) {
+func binarySearch(n int, out *ir.Nodes, less func(i int) ir.Node, leaf func(i int, nif ir.Node)) {
 	const binarySearchMin = 4 // minimum number of cases for binary search
 
 	var do func(lo, hi int, out *ir.Nodes)
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 0559dabe32..4e2f205312 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -20,7 +20,7 @@ const enableTrace = false
 var traceIndent []byte
 var skipDowidthForTracing bool
 
-func tracePrint(title string, n *ir.Node) func(np **ir.Node) {
+func tracePrint(title string, n ir.Node) func(np *ir.Node) {
 	indent := traceIndent
 
 	// guard against nil
@@ -37,7 +37,7 @@ func tracePrint(title string, n *ir.Node) func(np **ir.Node) {
 	fmt.Printf("%s: %s%s %p %s %v tc=%d\n", pos, indent, title, n, op, n, tc)
 	traceIndent = append(traceIndent, ". "...)
 
-	return func(np **ir.Node) {
+	return func(np *ir.Node) {
 		traceIndent = traceIndent[:len(traceIndent)-2]
 
 		// if we have a result, use that
@@ -77,10 +77,10 @@ const (
 // marks variables that escape the local frame.
 // rewrites n.Op to be more specific in some cases.
 
-var typecheckdefstack []*ir.Node
+var typecheckdefstack []ir.Node
 
 // resolve ONONAME to definition, if any.
-func resolve(n *ir.Node) (res *ir.Node) {
+func resolve(n ir.Node) (res ir.Node) {
 	if n == nil || n.Op() != ir.ONONAME {
 		return n
 	}
@@ -115,7 +115,7 @@ func resolve(n *ir.Node) (res *ir.Node) {
 	return r
 }
 
-func typecheckslice(l []*ir.Node, top int) {
+func typecheckslice(l []ir.Node, top int) {
 	for i := range l {
 		l[i] = typecheck(l[i], top)
 	}
@@ -166,7 +166,7 @@ func typekind(t *types.Type) string {
 	return fmt.Sprintf("etype=%d", et)
 }
 
-func cycleFor(start *ir.Node) []*ir.Node {
+func cycleFor(start ir.Node) []ir.Node {
 	// Find the start node in typecheck_tcstack.
 	// We know that it must exist because each time we mark
 	// a node with n.SetTypecheck(2) we push it on the stack,
@@ -179,7 +179,7 @@ func cycleFor(start *ir.Node) []*ir.Node {
 	}
 
 	// collect all nodes with same Op
-	var cycle []*ir.Node
+	var cycle []ir.Node
 	for _, n := range typecheck_tcstack[i:] {
 		if n.Op() == start.Op() {
 			cycle = append(cycle, n)
@@ -189,7 +189,7 @@ func cycleFor(start *ir.Node) []*ir.Node {
 	return cycle
 }
 
-func cycleTrace(cycle []*ir.Node) string {
+func cycleTrace(cycle []ir.Node) string {
 	var s string
 	for i, n := range cycle {
 		s += fmt.Sprintf("\n\t%v: %v uses %v", ir.Line(n), n, cycle[(i+1)%len(cycle)])
@@ -197,12 +197,12 @@ func cycleTrace(cycle []*ir.Node) string {
 	return s
 }
 
-var typecheck_tcstack []*ir.Node
+var typecheck_tcstack []ir.Node
 
 // typecheck type checks node n.
 // The result of typecheck MUST be assigned back to n, e.g.
 // 	n.Left = typecheck(n.Left, top)
-func typecheck(n *ir.Node, top int) (res *ir.Node) {
+func typecheck(n ir.Node, top int) (res ir.Node) {
 	// cannot type check until all the source has been parsed
 	if !typecheckok {
 		base.Fatalf("early typecheck")
@@ -317,7 +317,7 @@ func typecheck(n *ir.Node, top int) (res *ir.Node) {
 // value of type int (see also checkmake for comparison).
 // The result of indexlit MUST be assigned back to n, e.g.
 // 	n.Left = indexlit(n.Left)
-func indexlit(n *ir.Node) *ir.Node {
+func indexlit(n ir.Node) ir.Node {
 	if n != nil && n.Type() != nil && n.Type().Etype == types.TIDEAL {
 		return defaultlit(n, types.Types[types.TINT])
 	}
@@ -326,7 +326,7 @@ func indexlit(n *ir.Node) *ir.Node {
 
 // The result of typecheck1 MUST be assigned back to n, e.g.
 // 	n.Left = typecheck1(n.Left, top)
-func typecheck1(n *ir.Node, top int) (res *ir.Node) {
+func typecheck1(n ir.Node, top int) (res ir.Node) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheck1", n)(&res)
 	}
@@ -569,9 +569,9 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 		ir.OOROR,
 		ir.OSUB,
 		ir.OXOR:
-		var l *ir.Node
+		var l ir.Node
 		var op ir.Op
-		var r *ir.Node
+		var r ir.Node
 		if n.Op() == ir.OASOP {
 			ok |= ctxStmt
 			n.SetLeft(typecheck(n.Left(), ctxExpr))
@@ -1762,7 +1762,7 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 			l = args[i]
 			i++
 			l = typecheck(l, ctxExpr)
-			var r *ir.Node
+			var r ir.Node
 			if i < len(args) {
 				r = args[i]
 				i++
@@ -2129,7 +2129,7 @@ func typecheck1(n *ir.Node, top int) (res *ir.Node) {
 	return n
 }
 
-func typecheckargs(n *ir.Node) {
+func typecheckargs(n ir.Node) {
 	if n.List().Len() != 1 || n.IsDDD() {
 		typecheckslice(n.List().Slice(), ctxExpr)
 		return
@@ -2174,7 +2174,7 @@ func typecheckargs(n *ir.Node) {
 	n.PtrInit().Append(as)
 }
 
-func checksliceindex(l *ir.Node, r *ir.Node, tp *types.Type) bool {
+func checksliceindex(l ir.Node, r ir.Node, tp *types.Type) bool {
 	t := r.Type()
 	if t == nil {
 		return false
@@ -2204,7 +2204,7 @@ func checksliceindex(l *ir.Node, r *ir.Node, tp *types.Type) bool {
 	return true
 }
 
-func checksliceconst(lo *ir.Node, hi *ir.Node) bool {
+func checksliceconst(lo ir.Node, hi ir.Node) bool {
 	if lo != nil && hi != nil && lo.Op() == ir.OLITERAL && hi.Op() == ir.OLITERAL && constant.Compare(lo.Val(), token.GTR, hi.Val()) {
 		base.Errorf("invalid slice index: %v > %v", lo, hi)
 		return false
@@ -2213,7 +2213,7 @@ func checksliceconst(lo *ir.Node, hi *ir.Node) bool {
 	return true
 }
 
-func checkdefergo(n *ir.Node) {
+func checkdefergo(n ir.Node) {
 	what := "defer"
 	if n.Op() == ir.OGO {
 		what = "go"
@@ -2268,7 +2268,7 @@ func checkdefergo(n *ir.Node) {
 
 // The result of implicitstar MUST be assigned back to n, e.g.
 // 	n.Left = implicitstar(n.Left)
-func implicitstar(n *ir.Node) *ir.Node {
+func implicitstar(n ir.Node) ir.Node {
 	// insert implicit * if needed for fixed array
 	t := n.Type()
 	if t == nil || !t.IsPtr() {
@@ -2287,7 +2287,7 @@ func implicitstar(n *ir.Node) *ir.Node {
 	return n
 }
 
-func onearg(n *ir.Node, f string, args ...interface{}) bool {
+func onearg(n ir.Node, f string, args ...interface{}) bool {
 	if n.Left() != nil {
 		return true
 	}
@@ -2310,7 +2310,7 @@ func onearg(n *ir.Node, f string, args ...interface{}) bool {
 	return true
 }
 
-func twoarg(n *ir.Node) bool {
+func twoarg(n ir.Node) bool {
 	if n.Left() != nil {
 		return true
 	}
@@ -2328,7 +2328,7 @@ func twoarg(n *ir.Node) bool {
 	return true
 }
 
-func lookdot1(errnode *ir.Node, s *types.Sym, t *types.Type, fs *types.Fields, dostrcmp int) *types.Field {
+func lookdot1(errnode ir.Node, s *types.Sym, t *types.Type, fs *types.Fields, dostrcmp int) *types.Field {
 	var r *types.Field
 	for _, f := range fs.Slice() {
 		if dostrcmp != 0 && f.Sym.Name == s.Name {
@@ -2359,7 +2359,7 @@ func lookdot1(errnode *ir.Node, s *types.Sym, t *types.Type, fs *types.Fields, d
 
 // typecheckMethodExpr checks selector expressions (ODOT) where the
 // base expression is a type expression (OTYPE).
-func typecheckMethodExpr(n *ir.Node) (res *ir.Node) {
+func typecheckMethodExpr(n ir.Node) (res ir.Node) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckMethodExpr", n)(&res)
 	}
@@ -2447,7 +2447,7 @@ func derefall(t *types.Type) *types.Type {
 	return t
 }
 
-func lookdot(n *ir.Node, t *types.Type, dostrcmp int) *types.Field {
+func lookdot(n ir.Node, t *types.Type, dostrcmp int) *types.Field {
 	s := n.Sym()
 
 	dowidth(t)
@@ -2572,7 +2572,7 @@ func hasddd(t *types.Type) bool {
 }
 
 // typecheck assignment: type list = expression list
-func typecheckaste(op ir.Op, call *ir.Node, isddd bool, tstruct *types.Type, nl ir.Nodes, desc func() string) {
+func typecheckaste(op ir.Op, call ir.Node, isddd bool, tstruct *types.Type, nl ir.Nodes, desc func() string) {
 	var t *types.Type
 	var i int
 
@@ -2583,7 +2583,7 @@ func typecheckaste(op ir.Op, call *ir.Node, isddd bool, tstruct *types.Type, nl
 		return
 	}
 
-	var n *ir.Node
+	var n ir.Node
 	if nl.Len() == 1 {
 		n = nl.First()
 	}
@@ -2774,7 +2774,7 @@ func iscomptype(t *types.Type) bool {
 
 // pushtype adds elided type information for composite literals if
 // appropriate, and returns the resulting expression.
-func pushtype(n *ir.Node, t *types.Type) *ir.Node {
+func pushtype(n ir.Node, t *types.Type) ir.Node {
 	if n == nil || n.Op() != ir.OCOMPLIT || n.Right() != nil {
 		return n
 	}
@@ -2797,7 +2797,7 @@ func pushtype(n *ir.Node, t *types.Type) *ir.Node {
 
 // The result of typecheckcomplit MUST be assigned back to n, e.g.
 // 	n.Left = typecheckcomplit(n.Left)
-func typecheckcomplit(n *ir.Node) (res *ir.Node) {
+func typecheckcomplit(n ir.Node) (res ir.Node) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckcomplit", n)(&res)
 	}
@@ -3008,7 +3008,7 @@ func typecheckcomplit(n *ir.Node) (res *ir.Node) {
 }
 
 // typecheckarraylit type-checks a sequence of slice/array literal elements.
-func typecheckarraylit(elemType *types.Type, bound int64, elts []*ir.Node, ctx string) int64 {
+func typecheckarraylit(elemType *types.Type, bound int64, elts []ir.Node, ctx string) int64 {
 	// If there are key/value pairs, create a map to keep seen
 	// keys so we can check for duplicate indices.
 	var indices map[int64]bool
@@ -3023,7 +3023,7 @@ func typecheckarraylit(elemType *types.Type, bound int64, elts []*ir.Node, ctx s
 	for i, elt := range elts {
 		setlineno(elt)
 		r := elts[i]
-		var kv *ir.Node
+		var kv ir.Node
 		if elt.Op() == ir.OKEY {
 			elt.SetLeft(typecheck(elt.Left(), ctxExpr))
 			key = indexconst(elt.Left())
@@ -3086,7 +3086,7 @@ func nonexported(sym *types.Sym) bool {
 }
 
 // lvalue etc
-func islvalue(n *ir.Node) bool {
+func islvalue(n ir.Node) bool {
 	switch n.Op() {
 	case ir.OINDEX:
 		if n.Left().Type() != nil && n.Left().Type().IsArray() {
@@ -3112,13 +3112,13 @@ func islvalue(n *ir.Node) bool {
 	return false
 }
 
-func checklvalue(n *ir.Node, verb string) {
+func checklvalue(n ir.Node, verb string) {
 	if !islvalue(n) {
 		base.Errorf("cannot %s %v", verb, n)
 	}
 }
 
-func checkassign(stmt *ir.Node, n *ir.Node) {
+func checkassign(stmt ir.Node, n ir.Node) {
 	// Variables declared in ORANGE are assigned on every iteration.
 	if n.Name() == nil || n.Name().Defn != stmt || stmt.Op() == ir.ORANGE {
 		r := outervalue(n)
@@ -3156,7 +3156,7 @@ func checkassign(stmt *ir.Node, n *ir.Node) {
 	n.SetType(nil)
 }
 
-func checkassignlist(stmt *ir.Node, l ir.Nodes) {
+func checkassignlist(stmt ir.Node, l ir.Nodes) {
 	for _, n := range l.Slice() {
 		checkassign(stmt, n)
 	}
@@ -3177,7 +3177,7 @@ func checkassignlist(stmt *ir.Node, l ir.Nodes) {
 // currently OK, since the only place samesafeexpr gets used on an
 // lvalue expression is for OSLICE and OAPPEND optimizations, and it
 // is correct in those settings.
-func samesafeexpr(l *ir.Node, r *ir.Node) bool {
+func samesafeexpr(l ir.Node, r ir.Node) bool {
 	if l.Op() != r.Op() || !types.Identical(l.Type(), r.Type()) {
 		return false
 	}
@@ -3215,7 +3215,7 @@ func samesafeexpr(l *ir.Node, r *ir.Node) bool {
 // type check assignment.
 // if this assignment is the definition of a var on the left side,
 // fill in the var's type.
-func typecheckas(n *ir.Node) {
+func typecheckas(n ir.Node) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckas", n)(nil)
 	}
@@ -3266,14 +3266,14 @@ func typecheckas(n *ir.Node) {
 	}
 }
 
-func checkassignto(src *types.Type, dst *ir.Node) {
+func checkassignto(src *types.Type, dst ir.Node) {
 	if op, why := assignop(src, dst.Type()); op == ir.OXXX {
 		base.Errorf("cannot assign %v to %L in multiple assignment%s", src, dst, why)
 		return
 	}
 }
 
-func typecheckas2(n *ir.Node) {
+func typecheckas2(n ir.Node) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckas2", n)(nil)
 	}
@@ -3298,8 +3298,8 @@ func typecheckas2(n *ir.Node) {
 	}
 	checkassignlist(n, n.List())
 
-	var l *ir.Node
-	var r *ir.Node
+	var l ir.Node
+	var r ir.Node
 	if cl == cr {
 		// easy
 		ls := n.List().Slice()
@@ -3406,7 +3406,7 @@ out:
 }
 
 // type check function definition
-func typecheckfunc(n *ir.Node) {
+func typecheckfunc(n ir.Node) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckfunc", n)(nil)
 	}
@@ -3441,12 +3441,12 @@ func typecheckfunc(n *ir.Node) {
 
 // The result of stringtoruneslit MUST be assigned back to n, e.g.
 // 	n.Left = stringtoruneslit(n.Left)
-func stringtoruneslit(n *ir.Node) *ir.Node {
+func stringtoruneslit(n ir.Node) ir.Node {
 	if n.Left().Op() != ir.OLITERAL || n.Left().Val().Kind() != constant.String {
 		base.Fatalf("stringtoarraylit %v", n)
 	}
 
-	var l []*ir.Node
+	var l []ir.Node
 	i := 0
 	for _, r := range n.Left().StringVal() {
 		l = append(l, ir.Nod(ir.OKEY, nodintconst(int64(i)), nodintconst(int64(r))))
@@ -3459,7 +3459,7 @@ func stringtoruneslit(n *ir.Node) *ir.Node {
 	return nn
 }
 
-var mapqueue []*ir.Node
+var mapqueue []ir.Node
 
 func checkMapKeys() {
 	for _, n := range mapqueue {
@@ -3520,7 +3520,7 @@ func setUnderlying(t, underlying *types.Type) {
 	}
 }
 
-func typecheckdeftype(n *ir.Node) {
+func typecheckdeftype(n ir.Node) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckdeftype", n)(nil)
 	}
@@ -3540,7 +3540,7 @@ func typecheckdeftype(n *ir.Node) {
 	}
 }
 
-func typecheckdef(n *ir.Node) {
+func typecheckdef(n ir.Node) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckdef", n)(nil)
 	}
@@ -3727,7 +3727,7 @@ ret:
 	n.SetWalkdef(1)
 }
 
-func checkmake(t *types.Type, arg string, np **ir.Node) bool {
+func checkmake(t *types.Type, arg string, np *ir.Node) bool {
 	n := *np
 	if !n.Type().IsInteger() && n.Type().Etype != types.TIDEAL {
 		base.Errorf("non-integer %s argument in make(%v) - %v", arg, t, n.Type())
@@ -3759,7 +3759,7 @@ func checkmake(t *types.Type, arg string, np **ir.Node) bool {
 	return true
 }
 
-func markbreak(n *ir.Node, implicit *ir.Node) {
+func markbreak(n ir.Node, implicit ir.Node) {
 	if n == nil {
 		return
 	}
@@ -3789,7 +3789,7 @@ func markbreak(n *ir.Node, implicit *ir.Node) {
 	}
 }
 
-func markbreaklist(l ir.Nodes, implicit *ir.Node) {
+func markbreaklist(l ir.Nodes, implicit ir.Node) {
 	s := l.Slice()
 	for i := 0; i < len(s); i++ {
 		n := s[i]
@@ -3823,7 +3823,7 @@ func isTermNodes(l ir.Nodes) bool {
 
 // Isterminating reports whether the node n, the last one in a
 // statement list, is a terminating statement.
-func isTermNode(n *ir.Node) bool {
+func isTermNode(n ir.Node) bool {
 	switch n.Op() {
 	// NOTE: OLABEL is treated as a separate statement,
 	// not a separate prefix, so skipping to the last statement
@@ -3872,7 +3872,7 @@ func isTermNode(n *ir.Node) bool {
 }
 
 // checkreturn makes sure that fn terminates appropriately.
-func checkreturn(fn *ir.Node) {
+func checkreturn(fn ir.Node) {
 	if fn.Type().NumResults() != 0 && fn.Body().Len() != 0 {
 		markbreaklist(fn.Body(), nil)
 		if !isTermNodes(fn.Body()) {
@@ -3881,12 +3881,12 @@ func checkreturn(fn *ir.Node) {
 	}
 }
 
-func deadcode(fn *ir.Node) {
+func deadcode(fn ir.Node) {
 	deadcodeslice(fn.PtrBody())
 	deadcodefn(fn)
 }
 
-func deadcodefn(fn *ir.Node) {
+func deadcodefn(fn ir.Node) {
 	if fn.Body().Len() == 0 {
 		return
 	}
@@ -3909,7 +3909,7 @@ func deadcodefn(fn *ir.Node) {
 		}
 	}
 
-	fn.PtrBody().Set([]*ir.Node{ir.Nod(ir.OEMPTY, nil, nil)})
+	fn.PtrBody().Set([]ir.Node{ir.Nod(ir.OEMPTY, nil, nil)})
 }
 
 func deadcodeslice(nn *ir.Nodes) {
@@ -3965,7 +3965,7 @@ func deadcodeslice(nn *ir.Nodes) {
 	}
 }
 
-func deadcodeexpr(n *ir.Node) *ir.Node {
+func deadcodeexpr(n ir.Node) ir.Node {
 	// Perform dead-code elimination on short-circuited boolean
 	// expressions involving constants with the intent of
 	// producing a constant 'if' condition.
@@ -3995,7 +3995,7 @@ func deadcodeexpr(n *ir.Node) *ir.Node {
 }
 
 // setTypeNode sets n to an OTYPE node representing t.
-func setTypeNode(n *ir.Node, t *types.Type) {
+func setTypeNode(n ir.Node, t *types.Type) {
 	n.SetOp(ir.OTYPE)
 	n.SetType(t)
 	n.Type().Nod = n
@@ -4037,12 +4037,12 @@ func curpkg() *types.Pkg {
 // MethodName returns the ONAME representing the method
 // referenced by expression n, which must be a method selector,
 // method expression, or method value.
-func methodExprName(n *ir.Node) *ir.Node {
+func methodExprName(n ir.Node) ir.Node {
 	return ir.AsNode(methodExprFunc(n).Nname)
 }
 
 // MethodFunc is like MethodName, but returns the types.Field instead.
-func methodExprFunc(n *ir.Node) *types.Field {
+func methodExprFunc(n ir.Node) *types.Field {
 	switch n.Op() {
 	case ir.ODOTMETH, ir.OMETHEXPR:
 		return n.Opt().(*types.Field)
diff --git a/src/cmd/compile/internal/gc/unsafe.go b/src/cmd/compile/internal/gc/unsafe.go
index c9b0dbcf2f..678924b229 100644
--- a/src/cmd/compile/internal/gc/unsafe.go
+++ b/src/cmd/compile/internal/gc/unsafe.go
@@ -10,7 +10,7 @@ import (
 )
 
 // evalunsafe evaluates a package unsafe operation and returns the result.
-func evalunsafe(n *ir.Node) int64 {
+func evalunsafe(n ir.Node) int64 {
 	switch n.Op() {
 	case ir.OALIGNOF, ir.OSIZEOF:
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 77cf59bde8..db8791ee05 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -22,7 +22,7 @@ import (
 const tmpstringbufsize = 32
 const zeroValSize = 1024 // must match value of runtime/map.go:maxZero
 
-func walk(fn *ir.Node) {
+func walk(fn ir.Node) {
 	Curfn = fn
 	errorsBefore := base.Errors()
 
@@ -81,13 +81,13 @@ func walk(fn *ir.Node) {
 	}
 }
 
-func walkstmtlist(s []*ir.Node) {
+func walkstmtlist(s []ir.Node) {
 	for i := range s {
 		s[i] = walkstmt(s[i])
 	}
 }
 
-func paramoutheap(fn *ir.Node) bool {
+func paramoutheap(fn ir.Node) bool {
 	for _, ln := range fn.Func().Dcl {
 		switch ln.Class() {
 		case ir.PPARAMOUT:
@@ -106,7 +106,7 @@ func paramoutheap(fn *ir.Node) bool {
 
 // The result of walkstmt MUST be assigned back to n, e.g.
 // 	n.Left = walkstmt(n.Left)
-func walkstmt(n *ir.Node) *ir.Node {
+func walkstmt(n ir.Node) ir.Node {
 	if n == nil {
 		return n
 	}
@@ -275,7 +275,7 @@ func walkstmt(n *ir.Node) *ir.Node {
 		if (Curfn.Type().FuncType().Outnamed && n.List().Len() > 1) || paramoutheap(Curfn) {
 			// assign to the function out parameters,
 			// so that reorder3 can fix up conflicts
-			var rl []*ir.Node
+			var rl []ir.Node
 
 			for _, ln := range Curfn.Func().Dcl {
 				cl := ln.Class()
@@ -308,7 +308,7 @@ func walkstmt(n *ir.Node) *ir.Node {
 		// For each return parameter (lhs), assign the corresponding result (rhs).
 		lhs := Curfn.Type().Results()
 		rhs := n.List().Slice()
-		res := make([]*ir.Node, lhs.NumFields())
+		res := make([]ir.Node, lhs.NumFields())
 		for i, nl := range lhs.FieldSlice() {
 			nname := ir.AsNode(nl.Nname)
 			if isParamHeapCopy(nname) {
@@ -346,20 +346,20 @@ func walkstmt(n *ir.Node) *ir.Node {
 // the types expressions are calculated.
 // compile-time constants are evaluated.
 // complex side effects like statements are appended to init
-func walkexprlist(s []*ir.Node, init *ir.Nodes) {
+func walkexprlist(s []ir.Node, init *ir.Nodes) {
 	for i := range s {
 		s[i] = walkexpr(s[i], init)
 	}
 }
 
-func walkexprlistsafe(s []*ir.Node, init *ir.Nodes) {
+func walkexprlistsafe(s []ir.Node, init *ir.Nodes) {
 	for i, n := range s {
 		s[i] = safeexpr(n, init)
 		s[i] = walkexpr(s[i], init)
 	}
 }
 
-func walkexprlistcheap(s []*ir.Node, init *ir.Nodes) {
+func walkexprlistcheap(s []ir.Node, init *ir.Nodes) {
 	for i, n := range s {
 		s[i] = cheapexpr(n, init)
 		s[i] = walkexpr(s[i], init)
@@ -413,7 +413,7 @@ func convFuncName(from, to *types.Type) (fnname string, needsaddr bool) {
 
 // The result of walkexpr MUST be assigned back to n, e.g.
 // 	n.Left = walkexpr(n.Left, init)
-func walkexpr(n *ir.Node, init *ir.Nodes) *ir.Node {
+func walkexpr(n ir.Node, init *ir.Nodes) ir.Node {
 	if n == nil {
 		return n
 	}
@@ -700,7 +700,7 @@ opswitch:
 		r := n.Right()
 		walkexprlistsafe(n.List().Slice(), init)
 		r.SetLeft(walkexpr(r.Left(), init))
-		var n1 *ir.Node
+		var n1 ir.Node
 		if ir.IsBlank(n.List().First()) {
 			n1 = nodnil()
 		} else {
@@ -723,7 +723,7 @@ opswitch:
 		t := r.Left().Type()
 
 		fast := mapfast(t)
-		var key *ir.Node
+		var key ir.Node
 		if fast != mapslow {
 			// fast versions take key by value
 			key = r.Right()
@@ -802,7 +802,7 @@ opswitch:
 		}
 
 		// typeword generates the type word of the interface value.
-		typeword := func() *ir.Node {
+		typeword := func() ir.Node {
 			if toType.IsEmptyInterface() {
 				return typename(fromType)
 			}
@@ -832,7 +832,7 @@ opswitch:
 		// Optimize convT2{E,I} for many cases in which T is not pointer-shaped,
 		// by using an existing addressable value identical to n.Left
 		// or creating one on the stack.
-		var value *ir.Node
+		var value ir.Node
 		switch {
 		case fromType.Size() == 0:
 			// n.Left is zero-sized. Use zerobase.
@@ -918,7 +918,7 @@ opswitch:
 			break
 		}
 
-		var tab *ir.Node
+		var tab ir.Node
 		if fromType.IsInterface() {
 			// convI2I
 			tab = typename(toType)
@@ -1208,7 +1208,7 @@ opswitch:
 		hint := n.Left()
 
 		// var h *hmap
-		var h *ir.Node
+		var h ir.Node
 		if n.Esc() == EscNone {
 			// Allocate hmap on stack.
 
@@ -1494,7 +1494,7 @@ opswitch:
 
 			// Allocate a [n]byte of the right size.
 			t := types.NewArray(types.Types[types.TUINT8], int64(len(sc)))
-			var a *ir.Node
+			var a ir.Node
 			if n.Esc() == EscNone && len(sc) <= int(maxImplicitStackVarSize) {
 				a = ir.Nod(ir.OADDR, temp(t), nil)
 			} else {
@@ -1619,7 +1619,7 @@ func markTypeUsedInInterface(t *types.Type, from *obj.LSym) {
 
 // markUsedIfaceMethod marks that an interface method is used in the current
 // function. n is OCALLINTER node.
-func markUsedIfaceMethod(n *ir.Node) {
+func markUsedIfaceMethod(n ir.Node) {
 	ityp := n.Left().Left().Type()
 	tsym := typenamesym(ityp).Linksym()
 	r := obj.Addrel(Curfn.Func().LSym)
@@ -1678,7 +1678,7 @@ func rtconvfn(src, dst *types.Type) (param, result types.EType) {
 }
 
 // TODO(josharian): combine this with its caller and simplify
-func reduceSlice(n *ir.Node) *ir.Node {
+func reduceSlice(n ir.Node) ir.Node {
 	low, high, max := n.SliceBounds()
 	if high != nil && high.Op() == ir.OLEN && samesafeexpr(n.Left(), high.Left()) {
 		// Reduce x[i:len(x)] to x[i:].
@@ -1695,7 +1695,7 @@ func reduceSlice(n *ir.Node) *ir.Node {
 	return n
 }
 
-func ascompatee1(l *ir.Node, r *ir.Node, init *ir.Nodes) *ir.Node {
+func ascompatee1(l ir.Node, r ir.Node, init *ir.Nodes) ir.Node {
 	// convas will turn map assigns into function calls,
 	// making it impossible for reorder3 to work.
 	n := ir.Nod(ir.OAS, l, r)
@@ -1707,7 +1707,7 @@ func ascompatee1(l *ir.Node, r *ir.Node, init *ir.Nodes) *ir.Node {
 	return convas(n, init)
 }
 
-func ascompatee(op ir.Op, nl, nr []*ir.Node, init *ir.Nodes) []*ir.Node {
+func ascompatee(op ir.Op, nl, nr []ir.Node, init *ir.Nodes) []ir.Node {
 	// check assign expression list to
 	// an expression list. called in
 	//	expr-list = expr-list
@@ -1720,7 +1720,7 @@ func ascompatee(op ir.Op, nl, nr []*ir.Node, init *ir.Nodes) []*ir.Node {
 		nr[i1] = safeexpr(nr[i1], init)
 	}
 
-	var nn []*ir.Node
+	var nn []ir.Node
 	i := 0
 	for ; i < len(nl); i++ {
 		if i >= len(nr) {
@@ -1744,7 +1744,7 @@ func ascompatee(op ir.Op, nl, nr []*ir.Node, init *ir.Nodes) []*ir.Node {
 }
 
 // fncall reports whether assigning an rvalue of type rt to an lvalue l might involve a function call.
-func fncall(l *ir.Node, rt *types.Type) bool {
+func fncall(l ir.Node, rt *types.Type) bool {
 	if l.HasCall() || l.Op() == ir.OINDEXMAP {
 		return true
 	}
@@ -1758,7 +1758,7 @@ func fncall(l *ir.Node, rt *types.Type) bool {
 // check assign type list to
 // an expression list. called in
 //	expr-list = func()
-func ascompatet(nl ir.Nodes, nr *types.Type) []*ir.Node {
+func ascompatet(nl ir.Nodes, nr *types.Type) []ir.Node {
 	if nl.Len() != nr.NumFields() {
 		base.Fatalf("ascompatet: assignment count mismatch: %d = %d", nl.Len(), nr.NumFields())
 	}
@@ -1800,8 +1800,8 @@ func ascompatet(nl ir.Nodes, nr *types.Type) []*ir.Node {
 }
 
 // package all the arguments that match a ... T parameter into a []T.
-func mkdotargslice(typ *types.Type, args []*ir.Node) *ir.Node {
-	var n *ir.Node
+func mkdotargslice(typ *types.Type, args []ir.Node) ir.Node {
+	var n ir.Node
 	if len(args) == 0 {
 		n = nodnil()
 		n.SetType(typ)
@@ -1820,7 +1820,7 @@ func mkdotargslice(typ *types.Type, args []*ir.Node) *ir.Node {
 
 // fixVariadicCall rewrites calls to variadic functions to use an
 // explicit ... argument if one is not already present.
-func fixVariadicCall(call *ir.Node) {
+func fixVariadicCall(call ir.Node) {
 	fntype := call.Left().Type()
 	if !fntype.IsVariadic() || call.IsDDD() {
 		return
@@ -1840,7 +1840,7 @@ func fixVariadicCall(call *ir.Node) {
 	call.SetIsDDD(true)
 }
 
-func walkCall(n *ir.Node, init *ir.Nodes) {
+func walkCall(n ir.Node, init *ir.Nodes) {
 	if n.Rlist().Len() != 0 {
 		return // already walked
 	}
@@ -1853,7 +1853,7 @@ func walkCall(n *ir.Node, init *ir.Nodes) {
 
 	// If this is a method call, add the receiver at the beginning of the args.
 	if n.Op() == ir.OCALLMETH {
-		withRecv := make([]*ir.Node, len(args)+1)
+		withRecv := make([]ir.Node, len(args)+1)
 		withRecv[0] = n.Left().Left()
 		n.Left().SetLeft(nil)
 		copy(withRecv[1:], args)
@@ -1864,7 +1864,7 @@ func walkCall(n *ir.Node, init *ir.Nodes) {
 	// store that argument into a temporary variable,
 	// to prevent that calls from clobbering arguments already on the stack.
 	// When instrumenting, all arguments might require function calls.
-	var tempAssigns []*ir.Node
+	var tempAssigns []ir.Node
 	for i, arg := range args {
 		updateHasCall(arg)
 		// Determine param type.
@@ -1894,14 +1894,14 @@ func walkCall(n *ir.Node, init *ir.Nodes) {
 }
 
 // generate code for print
-func walkprint(nn *ir.Node, init *ir.Nodes) *ir.Node {
+func walkprint(nn ir.Node, init *ir.Nodes) ir.Node {
 	// Hoist all the argument evaluation up before the lock.
 	walkexprlistcheap(nn.List().Slice(), init)
 
 	// For println, add " " between elements and "\n" at the end.
 	if nn.Op() == ir.OPRINTN {
 		s := nn.List().Slice()
-		t := make([]*ir.Node, 0, len(s)*2)
+		t := make([]ir.Node, 0, len(s)*2)
 		for i, n := range s {
 			if i != 0 {
 				t = append(t, nodstr(" "))
@@ -1914,7 +1914,7 @@ func walkprint(nn *ir.Node, init *ir.Nodes) *ir.Node {
 
 	// Collapse runs of constant strings.
 	s := nn.List().Slice()
-	t := make([]*ir.Node, 0, len(s))
+	t := make([]ir.Node, 0, len(s))
 	for i := 0; i < len(s); {
 		var strs []string
 		for i < len(s) && ir.IsConst(s[i], constant.String) {
@@ -1931,7 +1931,7 @@ func walkprint(nn *ir.Node, init *ir.Nodes) *ir.Node {
 	}
 	nn.PtrList().Set(t)
 
-	calls := []*ir.Node{mkcall("printlock", nil, init)}
+	calls := []ir.Node{mkcall("printlock", nil, init)}
 	for i, n := range nn.List().Slice() {
 		if n.Op() == ir.OLITERAL {
 			if n.Type() == types.UntypedRune {
@@ -1956,7 +1956,7 @@ func walkprint(nn *ir.Node, init *ir.Nodes) *ir.Node {
 			continue
 		}
 
-		var on *ir.Node
+		var on ir.Node
 		switch n.Type().Etype {
 		case types.TINTER:
 			if n.Type().IsEmptyInterface() {
@@ -2037,7 +2037,7 @@ func walkprint(nn *ir.Node, init *ir.Nodes) *ir.Node {
 	return r
 }
 
-func callnew(t *types.Type) *ir.Node {
+func callnew(t *types.Type) ir.Node {
 	dowidth(t)
 	n := ir.Nod(ir.ONEWOBJ, typename(t), nil)
 	n.SetType(types.NewPtr(t))
@@ -2048,7 +2048,7 @@ func callnew(t *types.Type) *ir.Node {
 
 // isReflectHeaderDataField reports whether l is an expression p.Data
 // where p has type reflect.SliceHeader or reflect.StringHeader.
-func isReflectHeaderDataField(l *ir.Node) bool {
+func isReflectHeaderDataField(l ir.Node) bool {
 	if l.Type() != types.Types[types.TUINTPTR] {
 		return false
 	}
@@ -2069,7 +2069,7 @@ func isReflectHeaderDataField(l *ir.Node) bool {
 	return tsym.Name == "SliceHeader" || tsym.Name == "StringHeader"
 }
 
-func convas(n *ir.Node, init *ir.Nodes) *ir.Node {
+func convas(n ir.Node, init *ir.Nodes) ir.Node {
 	if n.Op() != ir.OAS {
 		base.Fatalf("convas: not OAS %v", n.Op())
 	}
@@ -2107,11 +2107,11 @@ func convas(n *ir.Node, init *ir.Nodes) *ir.Node {
 // be later use of an earlier lvalue.
 //
 // function calls have been removed.
-func reorder3(all []*ir.Node) []*ir.Node {
+func reorder3(all []ir.Node) []ir.Node {
 	// If a needed expression may be affected by an
 	// earlier assignment, make an early copy of that
 	// expression and use the copy instead.
-	var early []*ir.Node
+	var early []ir.Node
 
 	var mapinit ir.Nodes
 	for i, n := range all {
@@ -2166,7 +2166,7 @@ func reorder3(all []*ir.Node) []*ir.Node {
 // replace *np with that temp.
 // The result of reorder3save MUST be assigned back to n, e.g.
 // 	n.Left = reorder3save(n.Left, all, i, early)
-func reorder3save(n *ir.Node, all []*ir.Node, i int, early *[]*ir.Node) *ir.Node {
+func reorder3save(n ir.Node, all []ir.Node, i int, early *[]ir.Node) ir.Node {
 	if !aliased(n, all[:i]) {
 		return n
 	}
@@ -2180,7 +2180,7 @@ func reorder3save(n *ir.Node, all []*ir.Node, i int, early *[]*ir.Node) *ir.Node
 
 // what's the outer value that a write to n affects?
 // outer value means containing struct or array.
-func outervalue(n *ir.Node) *ir.Node {
+func outervalue(n ir.Node) ir.Node {
 	for {
 		switch n.Op() {
 		case ir.OXDOT:
@@ -2201,7 +2201,7 @@ func outervalue(n *ir.Node) *ir.Node {
 
 // Is it possible that the computation of r might be
 // affected by assignments in all?
-func aliased(r *ir.Node, all []*ir.Node) bool {
+func aliased(r ir.Node, all []ir.Node) bool {
 	if r == nil {
 		return false
 	}
@@ -2275,7 +2275,7 @@ func aliased(r *ir.Node, all []*ir.Node) bool {
 // does the evaluation of n only refer to variables
 // whose addresses have not been taken?
 // (and no other memory)
-func varexpr(n *ir.Node) bool {
+func varexpr(n ir.Node) bool {
 	if n == nil {
 		return true
 	}
@@ -2327,7 +2327,7 @@ func varexpr(n *ir.Node) bool {
 }
 
 // is the name l mentioned in r?
-func vmatch2(l *ir.Node, r *ir.Node) bool {
+func vmatch2(l ir.Node, r ir.Node) bool {
 	if r == nil {
 		return false
 	}
@@ -2356,7 +2356,7 @@ func vmatch2(l *ir.Node, r *ir.Node) bool {
 
 // is any name mentioned in l also mentioned in r?
 // called by sinit.go
-func vmatch1(l *ir.Node, r *ir.Node) bool {
+func vmatch1(l ir.Node, r ir.Node) bool {
 	// isolate all left sides
 	if l == nil || r == nil {
 		return false
@@ -2397,8 +2397,8 @@ func vmatch1(l *ir.Node, r *ir.Node) bool {
 
 // paramstoheap returns code to allocate memory for heap-escaped parameters
 // and to copy non-result parameters' values from the stack.
-func paramstoheap(params *types.Type) []*ir.Node {
-	var nn []*ir.Node
+func paramstoheap(params *types.Type) []ir.Node {
+	var nn []ir.Node
 	for _, t := range params.Fields().Slice() {
 		v := ir.AsNode(t.Nname)
 		if v != nil && v.Sym() != nil && strings.HasPrefix(v.Sym().Name, "~r") { // unnamed result
@@ -2451,8 +2451,8 @@ func zeroResults() {
 
 // returnsfromheap returns code to copy values for heap-escaped parameters
 // back to the stack.
-func returnsfromheap(params *types.Type) []*ir.Node {
-	var nn []*ir.Node
+func returnsfromheap(params *types.Type) []ir.Node {
+	var nn []ir.Node
 	for _, t := range params.Fields().Slice() {
 		v := ir.AsNode(t.Nname)
 		if v == nil {
@@ -2481,7 +2481,7 @@ func heapmoves() {
 	base.Pos = lno
 }
 
-func vmkcall(fn *ir.Node, t *types.Type, init *ir.Nodes, va []*ir.Node) *ir.Node {
+func vmkcall(fn ir.Node, t *types.Type, init *ir.Nodes, va []ir.Node) ir.Node {
 	if fn.Type() == nil || fn.Type().Etype != types.TFUNC {
 		base.Fatalf("mkcall %v %v", fn, fn.Type())
 	}
@@ -2503,15 +2503,15 @@ func vmkcall(fn *ir.Node, t *types.Type, init *ir.Nodes, va []*ir.Node) *ir.Node
 	return r
 }
 
-func mkcall(name string, t *types.Type, init *ir.Nodes, args ...*ir.Node) *ir.Node {
+func mkcall(name string, t *types.Type, init *ir.Nodes, args ...ir.Node) ir.Node {
 	return vmkcall(syslook(name), t, init, args)
 }
 
-func mkcall1(fn *ir.Node, t *types.Type, init *ir.Nodes, args ...*ir.Node) *ir.Node {
+func mkcall1(fn ir.Node, t *types.Type, init *ir.Nodes, args ...ir.Node) ir.Node {
 	return vmkcall(fn, t, init, args)
 }
 
-func conv(n *ir.Node, t *types.Type) *ir.Node {
+func conv(n ir.Node, t *types.Type) ir.Node {
 	if types.Identical(n.Type(), t) {
 		return n
 	}
@@ -2523,7 +2523,7 @@ func conv(n *ir.Node, t *types.Type) *ir.Node {
 
 // convnop converts node n to type t using the OCONVNOP op
 // and typechecks the result with ctxExpr.
-func convnop(n *ir.Node, t *types.Type) *ir.Node {
+func convnop(n ir.Node, t *types.Type) ir.Node {
 	if types.Identical(n.Type(), t) {
 		return n
 	}
@@ -2536,7 +2536,7 @@ func convnop(n *ir.Node, t *types.Type) *ir.Node {
 // byteindex converts n, which is byte-sized, to an int used to index into an array.
 // We cannot use conv, because we allow converting bool to int here,
 // which is forbidden in user code.
-func byteindex(n *ir.Node) *ir.Node {
+func byteindex(n ir.Node) ir.Node {
 	// We cannot convert from bool to int directly.
 	// While converting from int8 to int is possible, it would yield
 	// the wrong result for negative values.
@@ -2552,7 +2552,7 @@ func byteindex(n *ir.Node) *ir.Node {
 	return n
 }
 
-func chanfn(name string, n int, t *types.Type) *ir.Node {
+func chanfn(name string, n int, t *types.Type) ir.Node {
 	if !t.IsChan() {
 		base.Fatalf("chanfn %v", t)
 	}
@@ -2568,7 +2568,7 @@ func chanfn(name string, n int, t *types.Type) *ir.Node {
 	return fn
 }
 
-func mapfn(name string, t *types.Type) *ir.Node {
+func mapfn(name string, t *types.Type) ir.Node {
 	if !t.IsMap() {
 		base.Fatalf("mapfn %v", t)
 	}
@@ -2577,7 +2577,7 @@ func mapfn(name string, t *types.Type) *ir.Node {
 	return fn
 }
 
-func mapfndel(name string, t *types.Type) *ir.Node {
+func mapfndel(name string, t *types.Type) ir.Node {
 	if !t.IsMap() {
 		base.Fatalf("mapfn %v", t)
 	}
@@ -2636,13 +2636,13 @@ func mapfast(t *types.Type) int {
 	return mapslow
 }
 
-func writebarrierfn(name string, l *types.Type, r *types.Type) *ir.Node {
+func writebarrierfn(name string, l *types.Type, r *types.Type) ir.Node {
 	fn := syslook(name)
 	fn = substArgTypes(fn, l, r)
 	return fn
 }
 
-func addstr(n *ir.Node, init *ir.Nodes) *ir.Node {
+func addstr(n ir.Node, init *ir.Nodes) ir.Node {
 	// order.expr rewrote OADDSTR to have a list of strings.
 	c := n.List().Len()
 
@@ -2668,7 +2668,7 @@ func addstr(n *ir.Node, init *ir.Nodes) *ir.Node {
 	}
 
 	// build list of string arguments
-	args := []*ir.Node{buf}
+	args := []ir.Node{buf}
 	for _, n2 := range n.List().Slice() {
 		args = append(args, conv(n2, types.Types[types.TSTRING]))
 	}
@@ -2688,7 +2688,7 @@ func addstr(n *ir.Node, init *ir.Nodes) *ir.Node {
 			prealloc[slice] = prealloc[n]
 		}
 		slice.PtrList().Set(args[1:]) // skip buf arg
-		args = []*ir.Node{buf, slice}
+		args = []ir.Node{buf, slice}
 		slice.SetEsc(EscNone)
 	}
 
@@ -2702,7 +2702,7 @@ func addstr(n *ir.Node, init *ir.Nodes) *ir.Node {
 	return r
 }
 
-func walkAppendArgs(n *ir.Node, init *ir.Nodes) {
+func walkAppendArgs(n ir.Node, init *ir.Nodes) {
 	walkexprlistsafe(n.List().Slice(), init)
 
 	// walkexprlistsafe will leave OINDEX (s[n]) alone if both s
@@ -2728,7 +2728,7 @@ func walkAppendArgs(n *ir.Node, init *ir.Nodes) {
 //   s
 //
 // l2 is allowed to be a string.
-func appendslice(n *ir.Node, init *ir.Nodes) *ir.Node {
+func appendslice(n ir.Node, init *ir.Nodes) ir.Node {
 	walkAppendArgs(n, init)
 
 	l1 := n.List().First()
@@ -2768,7 +2768,7 @@ func appendslice(n *ir.Node, init *ir.Nodes) *ir.Node {
 	nt.SetBounded(true)
 	nodes.Append(ir.Nod(ir.OAS, s, nt))
 
-	var ncopy *ir.Node
+	var ncopy ir.Node
 	if elemtype.HasPointers() {
 		// copy(s[len(l1):], l2)
 		nptr1 := ir.Nod(ir.OSLICE, s, nil)
@@ -2828,7 +2828,7 @@ func appendslice(n *ir.Node, init *ir.Nodes) *ir.Node {
 
 // isAppendOfMake reports whether n is of the form append(x , make([]T, y)...).
 // isAppendOfMake assumes n has already been typechecked.
-func isAppendOfMake(n *ir.Node) bool {
+func isAppendOfMake(n ir.Node) bool {
 	if base.Flag.N != 0 || instrumenting {
 		return false
 	}
@@ -2887,7 +2887,7 @@ func isAppendOfMake(n *ir.Node) bool {
 //     }
 //   }
 //   s
-func extendslice(n *ir.Node, init *ir.Nodes) *ir.Node {
+func extendslice(n ir.Node, init *ir.Nodes) ir.Node {
 	// isAppendOfMake made sure all possible positive values of l2 fit into an uint.
 	// The case of l2 overflow when converting from e.g. uint to int is handled by an explicit
 	// check of l2 < 0 at runtime which is generated below.
@@ -2900,7 +2900,7 @@ func extendslice(n *ir.Node, init *ir.Nodes) *ir.Node {
 	l1 := n.List().First()
 	l2 = n.List().Second() // re-read l2, as it may have been updated by walkAppendArgs
 
-	var nodes []*ir.Node
+	var nodes []ir.Node
 
 	// if l2 >= 0 (likely happens), do nothing
 	nifneg := ir.Nod(ir.OIF, ir.Nod(ir.OGE, l2, nodintconst(0)), nil)
@@ -3006,7 +3006,7 @@ func extendslice(n *ir.Node, init *ir.Nodes) *ir.Node {
 //     ...
 //   }
 //   s
-func walkappend(n *ir.Node, init *ir.Nodes, dst *ir.Node) *ir.Node {
+func walkappend(n ir.Node, init *ir.Nodes, dst ir.Node) ir.Node {
 	if !samesafeexpr(dst, n.List().First()) {
 		n.List().SetFirst(safeexpr(n.List().First(), init))
 		n.List().SetFirst(walkexpr(n.List().First(), init))
@@ -3042,7 +3042,7 @@ func walkappend(n *ir.Node, init *ir.Nodes, dst *ir.Node) *ir.Node {
 		return n
 	}
 
-	var l []*ir.Node
+	var l []ir.Node
 
 	ns := temp(nsrc.Type())
 	l = append(l, ir.Nod(ir.OAS, ns, nsrc)) // s = src
@@ -3095,7 +3095,7 @@ func walkappend(n *ir.Node, init *ir.Nodes, dst *ir.Node) *ir.Node {
 //
 // Also works if b is a string.
 //
-func copyany(n *ir.Node, init *ir.Nodes, runtimecall bool) *ir.Node {
+func copyany(n ir.Node, init *ir.Nodes, runtimecall bool) ir.Node {
 	if n.Left().Type().Elem().HasPointers() {
 		Curfn.Func().SetWBPos(n.Pos())
 		fn := writebarrierfn("typedslicecopy", n.Left().Type().Elem(), n.Right().Type().Elem())
@@ -3126,7 +3126,7 @@ func copyany(n *ir.Node, init *ir.Nodes, runtimecall bool) *ir.Node {
 	n.SetRight(walkexpr(n.Right(), init))
 	nl := temp(n.Left().Type())
 	nr := temp(n.Right().Type())
-	var l []*ir.Node
+	var l []ir.Node
 	l = append(l, ir.Nod(ir.OAS, nl, n.Left()))
 	l = append(l, ir.Nod(ir.OAS, nr, n.Right()))
 
@@ -3165,7 +3165,7 @@ func copyany(n *ir.Node, init *ir.Nodes, runtimecall bool) *ir.Node {
 	return nlen
 }
 
-func eqfor(t *types.Type) (n *ir.Node, needsize bool) {
+func eqfor(t *types.Type) (n ir.Node, needsize bool) {
 	// Should only arrive here with large memory or
 	// a struct/array containing a non-memory field/element.
 	// Small memory is handled inline, and single non-memory
@@ -3179,10 +3179,10 @@ func eqfor(t *types.Type) (n *ir.Node, needsize bool) {
 		sym := typesymprefix(".eq", t)
 		n := NewName(sym)
 		setNodeNameFunc(n)
-		n.SetType(functype(nil, []*ir.Node{
+		n.SetType(functype(nil, []ir.Node{
 			anonfield(types.NewPtr(t)),
 			anonfield(types.NewPtr(t)),
-		}, []*ir.Node{
+		}, []ir.Node{
 			anonfield(types.Types[types.TBOOL]),
 		}))
 		return n, false
@@ -3193,7 +3193,7 @@ func eqfor(t *types.Type) (n *ir.Node, needsize bool) {
 
 // The result of walkcompare MUST be assigned back to n, e.g.
 // 	n.Left = walkcompare(n.Left, init)
-func walkcompare(n *ir.Node, init *ir.Nodes) *ir.Node {
+func walkcompare(n ir.Node, init *ir.Nodes) ir.Node {
 	if n.Left().Type().IsInterface() && n.Right().Type().IsInterface() && n.Left().Op() != ir.ONIL && n.Right().Op() != ir.ONIL {
 		return walkcompareInterface(n, init)
 	}
@@ -3228,7 +3228,7 @@ func walkcompare(n *ir.Node, init *ir.Nodes) *ir.Node {
 		//   l.tab == type(r)
 		// For non-empty interface, this is:
 		//   l.tab != nil && l.tab._type == type(r)
-		var eqtype *ir.Node
+		var eqtype ir.Node
 		tab := ir.Nod(ir.OITAB, l, nil)
 		rtyp := typename(r.Type())
 		if l.Type().IsEmptyInterface() {
@@ -3354,8 +3354,8 @@ func walkcompare(n *ir.Node, init *ir.Nodes) *ir.Node {
 	if n.Op() == ir.ONE {
 		andor = ir.OOROR
 	}
-	var expr *ir.Node
-	compare := func(el, er *ir.Node) {
+	var expr ir.Node
+	compare := func(el, er ir.Node) {
 		a := ir.Nod(n.Op(), el, er)
 		if expr == nil {
 			expr = a
@@ -3447,7 +3447,7 @@ func walkcompare(n *ir.Node, init *ir.Nodes) *ir.Node {
 	return n
 }
 
-func tracecmpArg(n *ir.Node, t *types.Type, init *ir.Nodes) *ir.Node {
+func tracecmpArg(n ir.Node, t *types.Type, init *ir.Nodes) ir.Node {
 	// Ugly hack to avoid "constant -1 overflows uintptr" errors, etc.
 	if n.Op() == ir.OLITERAL && n.Type().IsSigned() && n.Int64Val() < 0 {
 		n = copyexpr(n, n.Type(), init)
@@ -3456,11 +3456,11 @@ func tracecmpArg(n *ir.Node, t *types.Type, init *ir.Nodes) *ir.Node {
 	return conv(n, t)
 }
 
-func walkcompareInterface(n *ir.Node, init *ir.Nodes) *ir.Node {
+func walkcompareInterface(n ir.Node, init *ir.Nodes) ir.Node {
 	n.SetRight(cheapexpr(n.Right(), init))
 	n.SetLeft(cheapexpr(n.Left(), init))
 	eqtab, eqdata := eqinterface(n.Left(), n.Right())
-	var cmp *ir.Node
+	var cmp ir.Node
 	if n.Op() == ir.OEQ {
 		cmp = ir.Nod(ir.OANDAND, eqtab, eqdata)
 	} else {
@@ -3470,9 +3470,9 @@ func walkcompareInterface(n *ir.Node, init *ir.Nodes) *ir.Node {
 	return finishcompare(n, cmp, init)
 }
 
-func walkcompareString(n *ir.Node, init *ir.Nodes) *ir.Node {
+func walkcompareString(n ir.Node, init *ir.Nodes) ir.Node {
 	// Rewrite comparisons to short constant strings as length+byte-wise comparisons.
-	var cs, ncs *ir.Node // const string, non-const string
+	var cs, ncs ir.Node // const string, non-const string
 	switch {
 	case ir.IsConst(n.Left(), constant.String) && ir.IsConst(n.Right(), constant.String):
 		// ignore; will be constant evaluated
@@ -3570,7 +3570,7 @@ func walkcompareString(n *ir.Node, init *ir.Nodes) *ir.Node {
 		}
 	}
 
-	var r *ir.Node
+	var r ir.Node
 	if n.Op() == ir.OEQ || n.Op() == ir.ONE {
 		// prepare for rewrite below
 		n.SetLeft(cheapexpr(n.Left(), init))
@@ -3597,7 +3597,7 @@ func walkcompareString(n *ir.Node, init *ir.Nodes) *ir.Node {
 
 // The result of finishcompare MUST be assigned back to n, e.g.
 // 	n.Left = finishcompare(n.Left, x, r, init)
-func finishcompare(n, r *ir.Node, init *ir.Nodes) *ir.Node {
+func finishcompare(n, r ir.Node, init *ir.Nodes) ir.Node {
 	r = typecheck(r, ctxExpr)
 	r = conv(r, n.Type())
 	r = walkexpr(r, init)
@@ -3605,7 +3605,7 @@ func finishcompare(n, r *ir.Node, init *ir.Nodes) *ir.Node {
 }
 
 // return 1 if integer n must be in range [0, max), 0 otherwise
-func bounded(n *ir.Node, max int64) bool {
+func bounded(n ir.Node, max int64) bool {
 	if n.Type() == nil || !n.Type().IsInteger() {
 		return false
 	}
@@ -3672,7 +3672,7 @@ func bounded(n *ir.Node, max int64) bool {
 }
 
 // usemethod checks interface method calls for uses of reflect.Type.Method.
-func usemethod(n *ir.Node) {
+func usemethod(n ir.Node) {
 	t := n.Left().Type()
 
 	// Looking for either of:
@@ -3717,7 +3717,7 @@ func usemethod(n *ir.Node) {
 	}
 }
 
-func usefield(n *ir.Node) {
+func usefield(n ir.Node) {
 	if objabi.Fieldtrack_enabled == 0 {
 		return
 	}
@@ -3777,7 +3777,7 @@ func candiscardlist(l ir.Nodes) bool {
 	return true
 }
 
-func candiscard(n *ir.Node) bool {
+func candiscard(n ir.Node) bool {
 	if n == nil {
 		return true
 	}
@@ -3891,7 +3891,7 @@ var wrapCall_prgen int
 
 // The result of wrapCall MUST be assigned back to n, e.g.
 // 	n.Left = wrapCall(n.Left, init)
-func wrapCall(n *ir.Node, init *ir.Nodes) *ir.Node {
+func wrapCall(n ir.Node, init *ir.Nodes) ir.Node {
 	if n.Init().Len() != 0 {
 		walkstmtlist(n.Init().Slice())
 		init.AppendNodes(n.PtrInit())
@@ -3909,7 +3909,7 @@ func wrapCall(n *ir.Node, init *ir.Nodes) *ir.Node {
 	}
 
 	// origArgs keeps track of what argument is uintptr-unsafe/unsafe-uintptr conversion.
-	origArgs := make([]*ir.Node, n.List().Len())
+	origArgs := make([]ir.Node, n.List().Len())
 	t := ir.Nod(ir.OTFUNC, nil, nil)
 	for i, arg := range n.List().Slice() {
 		s := lookupN("a", i)
@@ -3962,7 +3962,7 @@ func wrapCall(n *ir.Node, init *ir.Nodes) *ir.Node {
 // type syntax expression n.Type.
 // The result of substArgTypes MUST be assigned back to old, e.g.
 // 	n.Left = substArgTypes(n.Left, t1, t2)
-func substArgTypes(old *ir.Node, types_ ...*types.Type) *ir.Node {
+func substArgTypes(old ir.Node, types_ ...*types.Type) ir.Node {
 	n := ir.Copy(old)
 
 	for _, t := range types_ {
@@ -3992,11 +3992,11 @@ func canMergeLoads() bool {
 
 // isRuneCount reports whether n is of the form len([]rune(string)).
 // These are optimized into a call to runtime.countrunes.
-func isRuneCount(n *ir.Node) bool {
+func isRuneCount(n ir.Node) bool {
 	return base.Flag.N == 0 && !instrumenting && n.Op() == ir.OLEN && n.Left().Op() == ir.OSTR2RUNES
 }
 
-func walkCheckPtrAlignment(n *ir.Node, init *ir.Nodes, count *ir.Node) *ir.Node {
+func walkCheckPtrAlignment(n ir.Node, init *ir.Nodes, count ir.Node) ir.Node {
 	if !n.Type().IsPtr() {
 		base.Fatalf("expected pointer type: %v", n.Type())
 	}
@@ -4024,7 +4024,7 @@ func walkCheckPtrAlignment(n *ir.Node, init *ir.Nodes, count *ir.Node) *ir.Node
 
 var walkCheckPtrArithmeticMarker byte
 
-func walkCheckPtrArithmetic(n *ir.Node, init *ir.Nodes) *ir.Node {
+func walkCheckPtrArithmetic(n ir.Node, init *ir.Nodes) ir.Node {
 	// Calling cheapexpr(n, init) below leads to a recursive call
 	// to walkexpr, which leads us back here again. Use n.Opt to
 	// prevent infinite loops.
@@ -4055,9 +4055,9 @@ func walkCheckPtrArithmetic(n *ir.Node, init *ir.Nodes) *ir.Node {
 	// "It is valid both to add and to subtract offsets from a
 	// pointer in this way. It is also valid to use &^ to round
 	// pointers, usually for alignment."
-	var originals []*ir.Node
-	var walk func(n *ir.Node)
-	walk = func(n *ir.Node) {
+	var originals []ir.Node
+	var walk func(n ir.Node)
+	walk = func(n ir.Node) {
 		switch n.Op() {
 		case ir.OADD:
 			walk(n.Left())
@@ -4088,6 +4088,6 @@ func walkCheckPtrArithmetic(n *ir.Node, init *ir.Nodes) *ir.Node {
 // checkPtr reports whether pointer checking should be enabled for
 // function fn at a given level. See debugHelpFooter for defined
 // levels.
-func checkPtr(fn *ir.Node, level int) bool {
+func checkPtr(fn ir.Node, level int) bool {
 	return base.Debug.Checkptr >= level && fn.Func().Pragma&ir.NoCheckPtr == 0
 }
diff --git a/src/cmd/compile/internal/ir/dump.go b/src/cmd/compile/internal/ir/dump.go
index c4ea5af3d1..fe1410969f 100644
--- a/src/cmd/compile/internal/ir/dump.go
+++ b/src/cmd/compile/internal/ir/dump.go
@@ -200,7 +200,7 @@ func (p *dumper) dump(x reflect.Value, depth int) {
 		typ := x.Type()
 
 		isNode := false
-		if n, ok := x.Interface().(Node); ok {
+		if n, ok := x.Interface().(node); ok {
 			isNode = true
 			p.printf("%s %s {", n.op.String(), p.addr(x))
 		} else {
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 9682bae39b..f394219c05 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -243,7 +243,7 @@ func (o Op) oconv(s fmt.State, flag FmtFlag, mode FmtMode) {
 type FmtMode int
 
 type fmtNode struct {
-	x *Node
+	x Node
 	m FmtMode
 }
 
@@ -277,11 +277,11 @@ type fmtNodes struct {
 
 func (f *fmtNodes) Format(s fmt.State, verb rune) { f.x.format(s, verb, f.m) }
 
-func (n *Node) Format(s fmt.State, verb rune) {
+func (n *node) Format(s fmt.State, verb rune) {
 	FmtNode(n, s, verb)
 }
 
-func FmtNode(n *Node, s fmt.State, verb rune) {
+func FmtNode(n Node, s fmt.State, verb rune) {
 	nodeFormat(n, s, verb, FErr)
 }
 
@@ -311,7 +311,7 @@ func (m FmtMode) prepareArgs(args []interface{}) {
 		switch arg := arg.(type) {
 		case Op:
 			args[i] = &fmtOp{arg, m}
-		case *Node:
+		case Node:
 			args[i] = &fmtNode{arg, m}
 		case nil:
 			args[i] = &fmtNode{nil, m} // assume this was a node interface
@@ -329,7 +329,7 @@ func (m FmtMode) prepareArgs(args []interface{}) {
 	}
 }
 
-func nodeFormat(n *Node, s fmt.State, verb rune, mode FmtMode) {
+func nodeFormat(n Node, s fmt.State, verb rune, mode FmtMode) {
 	switch verb {
 	case 'v', 'S', 'L':
 		nconvFmt(n, s, fmtFlag(s, verb), mode)
@@ -343,10 +343,10 @@ func nodeFormat(n *Node, s fmt.State, verb rune, mode FmtMode) {
 }
 
 // EscFmt is set by the escape analysis code to add escape analysis details to the node print.
-var EscFmt func(n *Node, short bool) string
+var EscFmt func(n Node, short bool) string
 
 // *Node details
-func jconvFmt(n *Node, s fmt.State, flag FmtFlag) {
+func jconvFmt(n Node, s fmt.State, flag FmtFlag) {
 	short := flag&FmtShort != 0
 
 	// Useful to see which nodes in an AST printout are actually identical
@@ -894,7 +894,7 @@ func StmtWithInit(op Op) bool {
 	return false
 }
 
-func stmtFmt(n *Node, s fmt.State, mode FmtMode) {
+func stmtFmt(n Node, s fmt.State, mode FmtMode) {
 	// some statements allow for an init, but at most one,
 	// but we may have an arbitrary number added, eg by typecheck
 	// and inlining. If it doesn't fit the syntax, emit an enclosing
@@ -1194,7 +1194,7 @@ var OpPrec = []int{
 	OEND: 0,
 }
 
-func exprFmt(n *Node, s fmt.State, prec int, mode FmtMode) {
+func exprFmt(n Node, s fmt.State, prec int, mode FmtMode) {
 	for n != nil && n.Implicit() && (n.Op() == ODEREF || n.Op() == OADDR) {
 		n = n.Left()
 	}
@@ -1556,7 +1556,7 @@ func exprFmt(n *Node, s fmt.State, prec int, mode FmtMode) {
 	}
 }
 
-func nodeFmt(n *Node, s fmt.State, flag FmtFlag, mode FmtMode) {
+func nodeFmt(n Node, s fmt.State, flag FmtFlag, mode FmtMode) {
 	t := n.Type()
 
 	// We almost always want the original.
@@ -1586,7 +1586,7 @@ func nodeFmt(n *Node, s fmt.State, flag FmtFlag, mode FmtMode) {
 	exprFmt(n, s, 0, mode)
 }
 
-func nodeDumpFmt(n *Node, s fmt.State, flag FmtFlag, mode FmtMode) {
+func nodeDumpFmt(n Node, s fmt.State, flag FmtFlag, mode FmtMode) {
 	recur := flag&FmtShort == 0
 
 	if recur {
@@ -1794,12 +1794,12 @@ func typeFormat(t *types.Type, s fmt.State, verb rune, mode FmtMode) {
 	}
 }
 
-func (n *Node) String() string                { return fmt.Sprint(n) }
-func modeString(n *Node, mode FmtMode) string { return mode.Sprint(n) }
+func (n *node) String() string               { return fmt.Sprint(n) }
+func modeString(n Node, mode FmtMode) string { return mode.Sprint(n) }
 
 // "%L"  suffix with "(type %T)" where possible
 // "%+S" in debug mode, don't recurse, no multiline output
-func nconvFmt(n *Node, s fmt.State, flag FmtFlag, mode FmtMode) {
+func nconvFmt(n Node, s fmt.State, flag FmtFlag, mode FmtMode) {
 	if n == nil {
 		fmt.Fprint(s, "<N>")
 		return
@@ -1866,7 +1866,7 @@ func FDumpList(w io.Writer, s string, l Nodes) {
 	fmt.Fprintf(w, "%s%+v\n", s, l)
 }
 
-func Dump(s string, n *Node) {
+func Dump(s string, n Node) {
 	fmt.Printf("%s [%p]%+v\n", s, n, n)
 }
 
@@ -1911,6 +1911,6 @@ func InstallTypeFormats() {
 
 // Line returns n's position as a string. If n has been inlined,
 // it uses the outermost position where n has been inlined.
-func Line(n *Node) string {
+func Line(n Node) string {
 	return base.FmtPos(n.Pos())
 }
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index d700c59390..477d07f502 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -20,7 +20,7 @@ import (
 )
 
 // A Node is the abstract interface to an IR node.
-type INode interface {
+type Node interface {
 	// Formatting
 	Format(s fmt.State, verb rune)
 	String() string
@@ -30,19 +30,19 @@ type INode interface {
 	SetPos(x src.XPos)
 
 	// For making copies. Mainly used by Copy and SepCopy.
-	RawCopy() *Node
+	RawCopy() Node
 
 	// Abstract graph structure, for generic traversals.
 	Op() Op
 	SetOp(x Op)
-	Orig() *Node
-	SetOrig(x *Node)
+	Orig() Node
+	SetOrig(x Node)
 	SubOp() Op
 	SetSubOp(x Op)
-	Left() *Node
-	SetLeft(x *Node)
-	Right() *Node
-	SetRight(x *Node)
+	Left() Node
+	SetLeft(x Node)
+	Right() Node
+	SetRight(x Node)
 	Init() Nodes
 	PtrInit() *Nodes
 	SetInit(x Nodes)
@@ -71,8 +71,8 @@ type INode interface {
 	SetClass(x Class)
 	Likely() bool
 	SetLikely(x bool)
-	SliceBounds() (low, high, max *Node)
-	SetSliceBounds(low, high, max *Node)
+	SliceBounds() (low, high, max Node)
+	SetSliceBounds(low, high, max Node)
 	Iota() int64
 	SetIota(x int64)
 	Colas() bool
@@ -130,17 +130,17 @@ type INode interface {
 	CanBeAnSSASym()
 }
 
-var _ INode = (*Node)(nil)
+var _ Node = (*node)(nil)
 
 // A Node is a single node in the syntax tree.
 // Actually the syntax tree is a syntax DAG, because there is only one
 // node with Op=ONAME for a given instance of a variable x.
 // The same is true for Op=OTYPE and Op=OLITERAL. See Node.mayBeShared.
-type Node struct {
+type node struct {
 	// Tree structure.
 	// Generic recursive walks should follow these fields.
-	left  *Node
-	right *Node
+	left  Node
+	right Node
 	init  Nodes
 	body  Nodes
 	list  Nodes
@@ -148,7 +148,7 @@ type Node struct {
 
 	// most nodes
 	typ  *types.Type
-	orig *Node // original form, for printing, and tracking copies of ONAMEs
+	orig Node // original form, for printing, and tracking copies of ONAMEs
 
 	// func
 	fn *Func
@@ -179,46 +179,46 @@ type Node struct {
 	aux uint8
 }
 
-func (n *Node) Left() *Node           { return n.left }
-func (n *Node) SetLeft(x *Node)       { n.left = x }
-func (n *Node) Right() *Node          { return n.right }
-func (n *Node) SetRight(x *Node)      { n.right = x }
-func (n *Node) Orig() *Node           { return n.orig }
-func (n *Node) SetOrig(x *Node)       { n.orig = x }
-func (n *Node) Type() *types.Type     { return n.typ }
-func (n *Node) SetType(x *types.Type) { n.typ = x }
-func (n *Node) Func() *Func           { return n.fn }
-func (n *Node) SetFunc(x *Func)       { n.fn = x }
-func (n *Node) Name() *Name           { return n.name }
-func (n *Node) SetName(x *Name)       { n.name = x }
-func (n *Node) Sym() *types.Sym       { return n.sym }
-func (n *Node) SetSym(x *types.Sym)   { n.sym = x }
-func (n *Node) Pos() src.XPos         { return n.pos }
-func (n *Node) SetPos(x src.XPos)     { n.pos = x }
-func (n *Node) Offset() int64         { return n.offset }
-func (n *Node) SetOffset(x int64)     { n.offset = x }
-func (n *Node) Esc() uint16           { return n.esc }
-func (n *Node) SetEsc(x uint16)       { n.esc = x }
-func (n *Node) Op() Op                { return n.op }
-func (n *Node) SetOp(x Op)            { n.op = x }
-func (n *Node) Init() Nodes           { return n.init }
-func (n *Node) SetInit(x Nodes)       { n.init = x }
-func (n *Node) PtrInit() *Nodes       { return &n.init }
-func (n *Node) Body() Nodes           { return n.body }
-func (n *Node) SetBody(x Nodes)       { n.body = x }
-func (n *Node) PtrBody() *Nodes       { return &n.body }
-func (n *Node) List() Nodes           { return n.list }
-func (n *Node) SetList(x Nodes)       { n.list = x }
-func (n *Node) PtrList() *Nodes       { return &n.list }
-func (n *Node) Rlist() Nodes          { return n.rlist }
-func (n *Node) SetRlist(x Nodes)      { n.rlist = x }
-func (n *Node) PtrRlist() *Nodes      { return &n.rlist }
-
-func (n *Node) ResetAux() {
+func (n *node) Left() Node            { return n.left }
+func (n *node) SetLeft(x Node)        { n.left = x }
+func (n *node) Right() Node           { return n.right }
+func (n *node) SetRight(x Node)       { n.right = x }
+func (n *node) Orig() Node            { return n.orig }
+func (n *node) SetOrig(x Node)        { n.orig = x }
+func (n *node) Type() *types.Type     { return n.typ }
+func (n *node) SetType(x *types.Type) { n.typ = x }
+func (n *node) Func() *Func           { return n.fn }
+func (n *node) SetFunc(x *Func)       { n.fn = x }
+func (n *node) Name() *Name           { return n.name }
+func (n *node) SetName(x *Name)       { n.name = x }
+func (n *node) Sym() *types.Sym       { return n.sym }
+func (n *node) SetSym(x *types.Sym)   { n.sym = x }
+func (n *node) Pos() src.XPos         { return n.pos }
+func (n *node) SetPos(x src.XPos)     { n.pos = x }
+func (n *node) Offset() int64         { return n.offset }
+func (n *node) SetOffset(x int64)     { n.offset = x }
+func (n *node) Esc() uint16           { return n.esc }
+func (n *node) SetEsc(x uint16)       { n.esc = x }
+func (n *node) Op() Op                { return n.op }
+func (n *node) SetOp(x Op)            { n.op = x }
+func (n *node) Init() Nodes           { return n.init }
+func (n *node) SetInit(x Nodes)       { n.init = x }
+func (n *node) PtrInit() *Nodes       { return &n.init }
+func (n *node) Body() Nodes           { return n.body }
+func (n *node) SetBody(x Nodes)       { n.body = x }
+func (n *node) PtrBody() *Nodes       { return &n.body }
+func (n *node) List() Nodes           { return n.list }
+func (n *node) SetList(x Nodes)       { n.list = x }
+func (n *node) PtrList() *Nodes       { return &n.list }
+func (n *node) Rlist() Nodes          { return n.rlist }
+func (n *node) SetRlist(x Nodes)      { n.rlist = x }
+func (n *node) PtrRlist() *Nodes      { return &n.rlist }
+
+func (n *node) ResetAux() {
 	n.aux = 0
 }
 
-func (n *Node) SubOp() Op {
+func (n *node) SubOp() Op {
 	switch n.Op() {
 	case OASOP, ONAME:
 	default:
@@ -227,7 +227,7 @@ func (n *Node) SubOp() Op {
 	return Op(n.aux)
 }
 
-func (n *Node) SetSubOp(op Op) {
+func (n *node) SetSubOp(op Op) {
 	switch n.Op() {
 	case OASOP, ONAME:
 	default:
@@ -236,14 +236,14 @@ func (n *Node) SetSubOp(op Op) {
 	n.aux = uint8(op)
 }
 
-func (n *Node) IndexMapLValue() bool {
+func (n *node) IndexMapLValue() bool {
 	if n.Op() != OINDEXMAP {
 		base.Fatalf("unexpected op: %v", n.Op())
 	}
 	return n.aux != 0
 }
 
-func (n *Node) SetIndexMapLValue(b bool) {
+func (n *node) SetIndexMapLValue(b bool) {
 	if n.Op() != OINDEXMAP {
 		base.Fatalf("unexpected op: %v", n.Op())
 	}
@@ -254,28 +254,28 @@ func (n *Node) SetIndexMapLValue(b bool) {
 	}
 }
 
-func (n *Node) TChanDir() types.ChanDir {
+func (n *node) TChanDir() types.ChanDir {
 	if n.Op() != OTCHAN {
 		base.Fatalf("unexpected op: %v", n.Op())
 	}
 	return types.ChanDir(n.aux)
 }
 
-func (n *Node) SetTChanDir(dir types.ChanDir) {
+func (n *node) SetTChanDir(dir types.ChanDir) {
 	if n.Op() != OTCHAN {
 		base.Fatalf("unexpected op: %v", n.Op())
 	}
 	n.aux = uint8(dir)
 }
 
-func IsSynthetic(n *Node) bool {
+func IsSynthetic(n Node) bool {
 	name := n.Sym().Name
 	return name[0] == '.' || name[0] == '~'
 }
 
 // IsAutoTmp indicates if n was created by the compiler as a temporary,
 // based on the setting of the .AutoTemp flag in n's Name.
-func IsAutoTmp(n *Node) bool {
+func IsAutoTmp(n Node) bool {
 	if n == nil || n.Op() != ONAME {
 		return false
 	}
@@ -308,49 +308,49 @@ const (
 	_, nodeEmbedded  // ODCLFIELD embedded type
 )
 
-func (n *Node) Class() Class     { return Class(n.flags.get3(nodeClass)) }
-func (n *Node) Walkdef() uint8   { return n.flags.get2(nodeWalkdef) }
-func (n *Node) Typecheck() uint8 { return n.flags.get2(nodeTypecheck) }
-func (n *Node) Initorder() uint8 { return n.flags.get2(nodeInitorder) }
-
-func (n *Node) HasBreak() bool  { return n.flags&nodeHasBreak != 0 }
-func (n *Node) NoInline() bool  { return n.flags&nodeNoInline != 0 }
-func (n *Node) Implicit() bool  { return n.flags&nodeImplicit != 0 }
-func (n *Node) IsDDD() bool     { return n.flags&nodeIsDDD != 0 }
-func (n *Node) Diag() bool      { return n.flags&nodeDiag != 0 }
-func (n *Node) Colas() bool     { return n.flags&nodeColas != 0 }
-func (n *Node) NonNil() bool    { return n.flags&nodeNonNil != 0 }
-func (n *Node) Transient() bool { return n.flags&nodeTransient != 0 }
-func (n *Node) Bounded() bool   { return n.flags&nodeBounded != 0 }
-func (n *Node) HasCall() bool   { return n.flags&nodeHasCall != 0 }
-func (n *Node) Likely() bool    { return n.flags&nodeLikely != 0 }
-func (n *Node) HasVal() bool    { return n.flags&nodeHasVal != 0 }
-func (n *Node) HasOpt() bool    { return n.flags&nodeHasOpt != 0 }
-func (n *Node) Embedded() bool  { return n.flags&nodeEmbedded != 0 }
-
-func (n *Node) SetClass(b Class)     { n.flags.set3(nodeClass, uint8(b)) }
-func (n *Node) SetWalkdef(b uint8)   { n.flags.set2(nodeWalkdef, b) }
-func (n *Node) SetTypecheck(b uint8) { n.flags.set2(nodeTypecheck, b) }
-func (n *Node) SetInitorder(b uint8) { n.flags.set2(nodeInitorder, b) }
-
-func (n *Node) SetHasBreak(b bool)  { n.flags.set(nodeHasBreak, b) }
-func (n *Node) SetNoInline(b bool)  { n.flags.set(nodeNoInline, b) }
-func (n *Node) SetImplicit(b bool)  { n.flags.set(nodeImplicit, b) }
-func (n *Node) SetIsDDD(b bool)     { n.flags.set(nodeIsDDD, b) }
-func (n *Node) SetDiag(b bool)      { n.flags.set(nodeDiag, b) }
-func (n *Node) SetColas(b bool)     { n.flags.set(nodeColas, b) }
-func (n *Node) SetTransient(b bool) { n.flags.set(nodeTransient, b) }
-func (n *Node) SetHasCall(b bool)   { n.flags.set(nodeHasCall, b) }
-func (n *Node) SetLikely(b bool)    { n.flags.set(nodeLikely, b) }
-func (n *Node) setHasVal(b bool)    { n.flags.set(nodeHasVal, b) }
-func (n *Node) setHasOpt(b bool)    { n.flags.set(nodeHasOpt, b) }
-func (n *Node) SetEmbedded(b bool)  { n.flags.set(nodeEmbedded, b) }
+func (n *node) Class() Class     { return Class(n.flags.get3(nodeClass)) }
+func (n *node) Walkdef() uint8   { return n.flags.get2(nodeWalkdef) }
+func (n *node) Typecheck() uint8 { return n.flags.get2(nodeTypecheck) }
+func (n *node) Initorder() uint8 { return n.flags.get2(nodeInitorder) }
+
+func (n *node) HasBreak() bool  { return n.flags&nodeHasBreak != 0 }
+func (n *node) NoInline() bool  { return n.flags&nodeNoInline != 0 }
+func (n *node) Implicit() bool  { return n.flags&nodeImplicit != 0 }
+func (n *node) IsDDD() bool     { return n.flags&nodeIsDDD != 0 }
+func (n *node) Diag() bool      { return n.flags&nodeDiag != 0 }
+func (n *node) Colas() bool     { return n.flags&nodeColas != 0 }
+func (n *node) NonNil() bool    { return n.flags&nodeNonNil != 0 }
+func (n *node) Transient() bool { return n.flags&nodeTransient != 0 }
+func (n *node) Bounded() bool   { return n.flags&nodeBounded != 0 }
+func (n *node) HasCall() bool   { return n.flags&nodeHasCall != 0 }
+func (n *node) Likely() bool    { return n.flags&nodeLikely != 0 }
+func (n *node) HasVal() bool    { return n.flags&nodeHasVal != 0 }
+func (n *node) HasOpt() bool    { return n.flags&nodeHasOpt != 0 }
+func (n *node) Embedded() bool  { return n.flags&nodeEmbedded != 0 }
+
+func (n *node) SetClass(b Class)     { n.flags.set3(nodeClass, uint8(b)) }
+func (n *node) SetWalkdef(b uint8)   { n.flags.set2(nodeWalkdef, b) }
+func (n *node) SetTypecheck(b uint8) { n.flags.set2(nodeTypecheck, b) }
+func (n *node) SetInitorder(b uint8) { n.flags.set2(nodeInitorder, b) }
+
+func (n *node) SetHasBreak(b bool)  { n.flags.set(nodeHasBreak, b) }
+func (n *node) SetNoInline(b bool)  { n.flags.set(nodeNoInline, b) }
+func (n *node) SetImplicit(b bool)  { n.flags.set(nodeImplicit, b) }
+func (n *node) SetIsDDD(b bool)     { n.flags.set(nodeIsDDD, b) }
+func (n *node) SetDiag(b bool)      { n.flags.set(nodeDiag, b) }
+func (n *node) SetColas(b bool)     { n.flags.set(nodeColas, b) }
+func (n *node) SetTransient(b bool) { n.flags.set(nodeTransient, b) }
+func (n *node) SetHasCall(b bool)   { n.flags.set(nodeHasCall, b) }
+func (n *node) SetLikely(b bool)    { n.flags.set(nodeLikely, b) }
+func (n *node) setHasVal(b bool)    { n.flags.set(nodeHasVal, b) }
+func (n *node) setHasOpt(b bool)    { n.flags.set(nodeHasOpt, b) }
+func (n *node) SetEmbedded(b bool)  { n.flags.set(nodeEmbedded, b) }
 
 // MarkNonNil marks a pointer n as being guaranteed non-nil,
 // on all code paths, at all times.
 // During conversion to SSA, non-nil pointers won't have nil checks
 // inserted before dereferencing. See state.exprPtr.
-func (n *Node) MarkNonNil() {
+func (n *node) MarkNonNil() {
 	if !n.Type().IsPtr() && !n.Type().IsUnsafePtr() {
 		base.Fatalf("MarkNonNil(%v), type %v", n, n.Type())
 	}
@@ -361,7 +361,7 @@ func (n *Node) MarkNonNil() {
 // When n is an index or slice operation, n does not need bounds checks.
 // When n is a dereferencing operation, n does not need nil checks.
 // When n is a makeslice+copy operation, n does not need length and cap checks.
-func (n *Node) SetBounded(b bool) {
+func (n *node) SetBounded(b bool) {
 	switch n.Op() {
 	case OINDEX, OSLICE, OSLICEARR, OSLICE3, OSLICE3ARR, OSLICESTR:
 		// No bounds checks needed.
@@ -377,7 +377,7 @@ func (n *Node) SetBounded(b bool) {
 }
 
 // MarkReadonly indicates that n is an ONAME with readonly contents.
-func (n *Node) MarkReadonly() {
+func (n *node) MarkReadonly() {
 	if n.Op() != ONAME {
 		base.Fatalf("Node.MarkReadonly %v", n.Op())
 	}
@@ -389,7 +389,7 @@ func (n *Node) MarkReadonly() {
 }
 
 // Val returns the constant.Value for the node.
-func (n *Node) Val() constant.Value {
+func (n *node) Val() constant.Value {
 	if !n.HasVal() {
 		return constant.MakeUnknown()
 	}
@@ -398,7 +398,7 @@ func (n *Node) Val() constant.Value {
 
 // SetVal sets the constant.Value for the node,
 // which must not have been used with SetOpt.
-func (n *Node) SetVal(v constant.Value) {
+func (n *node) SetVal(v constant.Value) {
 	if n.HasOpt() {
 		base.Flag.LowerH = 1
 		Dump("have Opt", n)
@@ -412,7 +412,7 @@ func (n *Node) SetVal(v constant.Value) {
 }
 
 // Opt returns the optimizer data for the node.
-func (n *Node) Opt() interface{} {
+func (n *node) Opt() interface{} {
 	if !n.HasOpt() {
 		return nil
 	}
@@ -421,7 +421,7 @@ func (n *Node) Opt() interface{} {
 
 // SetOpt sets the optimizer data for the node, which must not have been used with SetVal.
 // SetOpt(nil) is ignored for Vals to simplify call sites that are clearing Opts.
-func (n *Node) SetOpt(x interface{}) {
+func (n *node) SetOpt(x interface{}) {
 	if x == nil {
 		if n.HasOpt() {
 			n.setHasOpt(false)
@@ -438,17 +438,17 @@ func (n *Node) SetOpt(x interface{}) {
 	n.e = x
 }
 
-func (n *Node) Iota() int64 {
+func (n *node) Iota() int64 {
 	return n.Offset()
 }
 
-func (n *Node) SetIota(x int64) {
+func (n *node) SetIota(x int64) {
 	n.SetOffset(x)
 }
 
 // mayBeShared reports whether n may occur in multiple places in the AST.
 // Extra care must be taken when mutating such a node.
-func MayBeShared(n *Node) bool {
+func MayBeShared(n Node) bool {
 	switch n.Op() {
 	case ONAME, OLITERAL, ONIL, OTYPE:
 		return true
@@ -457,7 +457,7 @@ func MayBeShared(n *Node) bool {
 }
 
 // funcname returns the name (without the package) of the function n.
-func FuncName(n *Node) string {
+func FuncName(n Node) string {
 	if n == nil || n.Func() == nil || n.Func().Nname == nil {
 		return "<nil>"
 	}
@@ -468,7 +468,7 @@ func FuncName(n *Node) string {
 // This differs from the compiler's internal convention where local functions lack a package
 // because the ultimate consumer of this is a human looking at an IDE; package is only empty
 // if the compilation package is actually the empty string.
-func PkgFuncName(n *Node) string {
+func PkgFuncName(n Node) string {
 	var s *types.Sym
 	if n == nil {
 		return "<nil>"
@@ -494,19 +494,19 @@ func PkgFuncName(n *Node) string {
 }
 
 // The compiler needs *Node to be assignable to cmd/compile/internal/ssa.Sym.
-func (n *Node) CanBeAnSSASym() {
+func (n *node) CanBeAnSSASym() {
 }
 
 // Name holds Node fields used only by named nodes (ONAME, OTYPE, OPACK, OLABEL, some OLITERAL).
 type Name struct {
-	Pack *Node      // real package for import . names
+	Pack Node       // real package for import . names
 	Pkg  *types.Pkg // pkg for OPACK nodes
 	// For a local variable (not param) or extern, the initializing assignment (OAS or OAS2).
 	// For a closure var, the ONAME node of the outer captured variable
-	Defn *Node
+	Defn Node
 	// The ODCLFUNC node (for a static function/method or a closure) in which
 	// local variable or param is declared.
-	Curfn     *Node
+	Curfn     Node
 	Param     *Param // additional fields for ONAME, OTYPE
 	Decldepth int32  // declaration loop depth, increased for every loop or label
 	// Unique number for ONAME nodes within a function. Function outputs
@@ -565,11 +565,11 @@ func (n *Name) SetOpenDeferSlot(b bool)         { n.flags.set(nameOpenDeferSlot,
 func (n *Name) SetLibfuzzerExtraCounter(b bool) { n.flags.set(nameLibfuzzerExtraCounter, b) }
 
 type Param struct {
-	Ntype    *Node
-	Heapaddr *Node // temp holding heap address of param
+	Ntype    Node
+	Heapaddr Node // temp holding heap address of param
 
 	// ONAME PAUTOHEAP
-	Stackcopy *Node // the PPARAM/PPARAMOUT on-stack slot (moved func params only)
+	Stackcopy Node // the PPARAM/PPARAMOUT on-stack slot (moved func params only)
 
 	// ONAME closure linkage
 	// Consider:
@@ -640,8 +640,8 @@ type Param struct {
 	//
 	// Because of the sharding of pieces of the node, x.Defn means x.Name.Defn
 	// and x.Innermost/Outer means x.Name.Param.Innermost/Outer.
-	Innermost *Node
-	Outer     *Node
+	Innermost Node
+	Outer     Node
 
 	// OTYPE & ONAME //go:embed info,
 	// sharing storage to reduce gc.Param size.
@@ -762,9 +762,9 @@ func (p *Param) SetEmbedFiles(list []string) {
 // the generated ODCLFUNC (as n.Func.Decl), but there is no
 // pointer from the Func back to the OCALLPART.
 type Func struct {
-	Nname    *Node // ONAME node
-	Decl     *Node // ODCLFUNC node
-	OClosure *Node // OCLOSURE node
+	Nname    Node // ONAME node
+	Decl     Node // ODCLFUNC node
+	OClosure Node // OCLOSURE node
 
 	Shortname *types.Sym
 
@@ -774,10 +774,10 @@ type Func struct {
 	Exit  Nodes
 	// ONAME nodes for all params/locals for this func/closure, does NOT
 	// include closurevars until transformclosure runs.
-	Dcl []*Node
+	Dcl []Node
 
 	ClosureEnter  Nodes // list of ONAME nodes of captured variables
-	ClosureType   *Node // closure representation type
+	ClosureType   Node  // closure representation type
 	ClosureCalled bool  // closure is only immediately called
 	ClosureVars   Nodes // closure params; each has closurevar set
 
@@ -822,8 +822,8 @@ type Inline struct {
 	Cost int32 // heuristic cost of inlining this function
 
 	// Copies of Func.Dcl and Nbody for use during inlining.
-	Dcl  []*Node
-	Body []*Node
+	Dcl  []Node
+	Body []Node
 }
 
 // A Mark represents a scope boundary.
@@ -1108,17 +1108,17 @@ const (
 // Nodes is a pointer to a slice of *Node.
 // For fields that are not used in most nodes, this is used instead of
 // a slice to save space.
-type Nodes struct{ slice *[]*Node }
+type Nodes struct{ slice *[]Node }
 
 // asNodes returns a slice of *Node as a Nodes value.
-func AsNodes(s []*Node) Nodes {
+func AsNodes(s []Node) Nodes {
 	return Nodes{&s}
 }
 
 // Slice returns the entries in Nodes as a slice.
 // Changes to the slice entries (as in s[i] = n) will be reflected in
 // the Nodes.
-func (n Nodes) Slice() []*Node {
+func (n Nodes) Slice() []Node {
 	if n.slice == nil {
 		return nil
 	}
@@ -1135,25 +1135,25 @@ func (n Nodes) Len() int {
 
 // Index returns the i'th element of Nodes.
 // It panics if n does not have at least i+1 elements.
-func (n Nodes) Index(i int) *Node {
+func (n Nodes) Index(i int) Node {
 	return (*n.slice)[i]
 }
 
 // First returns the first element of Nodes (same as n.Index(0)).
 // It panics if n has no elements.
-func (n Nodes) First() *Node {
+func (n Nodes) First() Node {
 	return (*n.slice)[0]
 }
 
 // Second returns the second element of Nodes (same as n.Index(1)).
 // It panics if n has fewer than two elements.
-func (n Nodes) Second() *Node {
+func (n Nodes) Second() Node {
 	return (*n.slice)[1]
 }
 
 // Set sets n to a slice.
 // This takes ownership of the slice.
-func (n *Nodes) Set(s []*Node) {
+func (n *Nodes) Set(s []Node) {
 	if len(s) == 0 {
 		n.slice = nil
 	} else {
@@ -1166,18 +1166,18 @@ func (n *Nodes) Set(s []*Node) {
 }
 
 // Set1 sets n to a slice containing a single node.
-func (n *Nodes) Set1(n1 *Node) {
-	n.slice = &[]*Node{n1}
+func (n *Nodes) Set1(n1 Node) {
+	n.slice = &[]Node{n1}
 }
 
 // Set2 sets n to a slice containing two nodes.
-func (n *Nodes) Set2(n1, n2 *Node) {
-	n.slice = &[]*Node{n1, n2}
+func (n *Nodes) Set2(n1, n2 Node) {
+	n.slice = &[]Node{n1, n2}
 }
 
 // Set3 sets n to a slice containing three nodes.
-func (n *Nodes) Set3(n1, n2, n3 *Node) {
-	n.slice = &[]*Node{n1, n2, n3}
+func (n *Nodes) Set3(n1, n2, n3 Node) {
+	n.slice = &[]Node{n1, n2, n3}
 }
 
 // MoveNodes sets n to the contents of n2, then clears n2.
@@ -1188,35 +1188,35 @@ func (n *Nodes) MoveNodes(n2 *Nodes) {
 
 // SetIndex sets the i'th element of Nodes to node.
 // It panics if n does not have at least i+1 elements.
-func (n Nodes) SetIndex(i int, node *Node) {
+func (n Nodes) SetIndex(i int, node Node) {
 	(*n.slice)[i] = node
 }
 
 // SetFirst sets the first element of Nodes to node.
 // It panics if n does not have at least one elements.
-func (n Nodes) SetFirst(node *Node) {
+func (n Nodes) SetFirst(node Node) {
 	(*n.slice)[0] = node
 }
 
 // SetSecond sets the second element of Nodes to node.
 // It panics if n does not have at least two elements.
-func (n Nodes) SetSecond(node *Node) {
+func (n Nodes) SetSecond(node Node) {
 	(*n.slice)[1] = node
 }
 
 // Addr returns the address of the i'th element of Nodes.
 // It panics if n does not have at least i+1 elements.
-func (n Nodes) Addr(i int) **Node {
+func (n Nodes) Addr(i int) *Node {
 	return &(*n.slice)[i]
 }
 
 // Append appends entries to Nodes.
-func (n *Nodes) Append(a ...*Node) {
+func (n *Nodes) Append(a ...Node) {
 	if len(a) == 0 {
 		return
 	}
 	if n.slice == nil {
-		s := make([]*Node, len(a))
+		s := make([]Node, len(a))
 		copy(s, a)
 		n.slice = &s
 		return
@@ -1226,7 +1226,7 @@ func (n *Nodes) Append(a ...*Node) {
 
 // Prepend prepends entries to Nodes.
 // If a slice is passed in, this will take ownership of it.
-func (n *Nodes) Prepend(a ...*Node) {
+func (n *Nodes) Prepend(a ...Node) {
 	if len(a) == 0 {
 		return
 	}
@@ -1251,7 +1251,7 @@ func (n *Nodes) AppendNodes(n2 *Nodes) {
 
 // inspect invokes f on each node in an AST in depth-first order.
 // If f(n) returns false, inspect skips visiting n's children.
-func Inspect(n *Node, f func(*Node) bool) {
+func Inspect(n Node, f func(Node) bool) {
 	if n == nil || !f(n) {
 		return
 	}
@@ -1263,7 +1263,7 @@ func Inspect(n *Node, f func(*Node) bool) {
 	InspectList(n.Rlist(), f)
 }
 
-func InspectList(l Nodes, f func(*Node) bool) {
+func InspectList(l Nodes, f func(Node) bool) {
 	for _, n := range l.Slice() {
 		Inspect(n, f)
 	}
@@ -1272,7 +1272,7 @@ func InspectList(l Nodes, f func(*Node) bool) {
 // nodeQueue is a FIFO queue of *Node. The zero value of nodeQueue is
 // a ready-to-use empty queue.
 type NodeQueue struct {
-	ring       []*Node
+	ring       []Node
 	head, tail int
 }
 
@@ -1282,12 +1282,12 @@ func (q *NodeQueue) Empty() bool {
 }
 
 // pushRight appends n to the right of the queue.
-func (q *NodeQueue) PushRight(n *Node) {
+func (q *NodeQueue) PushRight(n Node) {
 	if len(q.ring) == 0 {
-		q.ring = make([]*Node, 16)
+		q.ring = make([]Node, 16)
 	} else if q.head+len(q.ring) == q.tail {
 		// Grow the ring.
-		nring := make([]*Node, len(q.ring)*2)
+		nring := make([]Node, len(q.ring)*2)
 		// Copy the old elements.
 		part := q.ring[q.head%len(q.ring):]
 		if q.tail-q.head <= len(part) {
@@ -1306,7 +1306,7 @@ func (q *NodeQueue) PushRight(n *Node) {
 
 // popLeft pops a node from the left of the queue. It panics if q is
 // empty.
-func (q *NodeQueue) PopLeft() *Node {
+func (q *NodeQueue) PopLeft() Node {
 	if q.Empty() {
 		panic("dequeue empty")
 	}
@@ -1316,25 +1316,25 @@ func (q *NodeQueue) PopLeft() *Node {
 }
 
 // NodeSet is a set of Nodes.
-type NodeSet map[*Node]struct{}
+type NodeSet map[Node]struct{}
 
 // Has reports whether s contains n.
-func (s NodeSet) Has(n *Node) bool {
+func (s NodeSet) Has(n Node) bool {
 	_, isPresent := s[n]
 	return isPresent
 }
 
 // Add adds n to s.
-func (s *NodeSet) Add(n *Node) {
+func (s *NodeSet) Add(n Node) {
 	if *s == nil {
-		*s = make(map[*Node]struct{})
+		*s = make(map[Node]struct{})
 	}
 	(*s)[n] = struct{}{}
 }
 
 // Sorted returns s sorted according to less.
-func (s NodeSet) Sorted(less func(*Node, *Node) bool) []*Node {
-	var res []*Node
+func (s NodeSet) Sorted(less func(Node, Node) bool) []Node {
+	var res []Node
 	for n := range s {
 		res = append(res, n)
 	}
@@ -1342,16 +1342,16 @@ func (s NodeSet) Sorted(less func(*Node, *Node) bool) []*Node {
 	return res
 }
 
-func Nod(op Op, nleft, nright *Node) *Node {
+func Nod(op Op, nleft, nright Node) Node {
 	return NodAt(base.Pos, op, nleft, nright)
 }
 
-func NodAt(pos src.XPos, op Op, nleft, nright *Node) *Node {
-	var n *Node
+func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
+	var n Node
 	switch op {
 	case ODCLFUNC:
 		var x struct {
-			n Node
+			n node
 			f Func
 		}
 		n = &x.n
@@ -1361,13 +1361,13 @@ func NodAt(pos src.XPos, op Op, nleft, nright *Node) *Node {
 		base.Fatalf("use newname instead")
 	case OLABEL, OPACK:
 		var x struct {
-			n Node
+			n node
 			m Name
 		}
 		n = &x.n
 		n.SetName(&x.m)
 	default:
-		n = new(Node)
+		n = new(node)
 	}
 	n.SetOp(op)
 	n.SetLeft(nleft)
@@ -1380,13 +1380,13 @@ func NodAt(pos src.XPos, op Op, nleft, nright *Node) *Node {
 
 // newnamel returns a new ONAME Node associated with symbol s at position pos.
 // The caller is responsible for setting n.Name.Curfn.
-func NewNameAt(pos src.XPos, s *types.Sym) *Node {
+func NewNameAt(pos src.XPos, s *types.Sym) Node {
 	if s == nil {
 		base.Fatalf("newnamel nil")
 	}
 
 	var x struct {
-		n Node
+		n node
 		m Name
 		p Param
 	}
@@ -1453,14 +1453,14 @@ type SymAndPos struct {
 	Pos src.XPos  // line of call
 }
 
-func AsNode(n types.IRNode) *Node {
+func AsNode(n types.IRNode) Node {
 	if n == nil {
 		return nil
 	}
-	return n.(*Node)
+	return n.(Node)
 }
 
-var BlankNode *Node
+var BlankNode Node
 
 // origSym returns the original symbol written by the user.
 func OrigSym(s *types.Sym) *types.Sym {
@@ -1489,7 +1489,7 @@ func OrigSym(s *types.Sym) *types.Sym {
 
 // SliceBounds returns n's slice bounds: low, high, and max in expr[low:high:max].
 // n must be a slice expression. max is nil if n is a simple slice expression.
-func (n *Node) SliceBounds() (low, high, max *Node) {
+func (n *node) SliceBounds() (low, high, max Node) {
 	if n.List().Len() == 0 {
 		return nil, nil, nil
 	}
@@ -1508,7 +1508,7 @@ func (n *Node) SliceBounds() (low, high, max *Node) {
 
 // SetSliceBounds sets n's slice bounds, where n is a slice expression.
 // n must be a slice expression. If max is non-nil, n must be a full slice expression.
-func (n *Node) SetSliceBounds(low, high, max *Node) {
+func (n *node) SetSliceBounds(low, high, max Node) {
 	switch n.Op() {
 	case OSLICE, OSLICEARR, OSLICESTR:
 		if max != nil {
@@ -1555,13 +1555,13 @@ func (o Op) IsSlice3() bool {
 	return false
 }
 
-func IsConst(n *Node, ct constant.Kind) bool {
+func IsConst(n Node, ct constant.Kind) bool {
 	return ConstType(n) == ct
 }
 
 // Int64Val returns n as an int64.
 // n must be an integer or rune constant.
-func (n *Node) Int64Val() int64 {
+func (n *node) Int64Val() int64 {
 	if !IsConst(n, constant.Int) {
 		base.Fatalf("Int64Val(%v)", n)
 	}
@@ -1573,7 +1573,7 @@ func (n *Node) Int64Val() int64 {
 }
 
 // CanInt64 reports whether it is safe to call Int64Val() on n.
-func (n *Node) CanInt64() bool {
+func (n *node) CanInt64() bool {
 	if !IsConst(n, constant.Int) {
 		return false
 	}
@@ -1586,7 +1586,7 @@ func (n *Node) CanInt64() bool {
 
 // Uint64Val returns n as an uint64.
 // n must be an integer or rune constant.
-func (n *Node) Uint64Val() uint64 {
+func (n *node) Uint64Val() uint64 {
 	if !IsConst(n, constant.Int) {
 		base.Fatalf("Uint64Val(%v)", n)
 	}
@@ -1599,7 +1599,7 @@ func (n *Node) Uint64Val() uint64 {
 
 // BoolVal returns n as a bool.
 // n must be a boolean constant.
-func (n *Node) BoolVal() bool {
+func (n *node) BoolVal() bool {
 	if !IsConst(n, constant.Bool) {
 		base.Fatalf("BoolVal(%v)", n)
 	}
@@ -1608,7 +1608,7 @@ func (n *Node) BoolVal() bool {
 
 // StringVal returns the value of a literal string Node as a string.
 // n must be a string constant.
-func (n *Node) StringVal() string {
+func (n *node) StringVal() string {
 	if !IsConst(n, constant.String) {
 		base.Fatalf("StringVal(%v)", n)
 	}
@@ -1618,14 +1618,14 @@ func (n *Node) StringVal() string {
 // rawcopy returns a shallow copy of n.
 // Note: copy or sepcopy (rather than rawcopy) is usually the
 //       correct choice (see comment with Node.copy, below).
-func (n *Node) RawCopy() *Node {
+func (n *node) RawCopy() Node {
 	copy := *n
 	return &copy
 }
 
 // sepcopy returns a separate shallow copy of n, with the copy's
 // Orig pointing to itself.
-func SepCopy(n *Node) *Node {
+func SepCopy(n Node) Node {
 	n = n.RawCopy()
 	n.SetOrig(n)
 	return n
@@ -1638,7 +1638,7 @@ func SepCopy(n *Node) *Node {
 // represent the original node anymore.
 // (This caused the wrong complit Op to be used when printing error
 // messages; see issues #26855, #27765).
-func Copy(n *Node) *Node {
+func Copy(n Node) Node {
 	copy := n.RawCopy()
 	if n.Orig() == n {
 		copy.SetOrig(copy)
@@ -1647,13 +1647,13 @@ func Copy(n *Node) *Node {
 }
 
 // isNil reports whether n represents the universal untyped zero value "nil".
-func IsNil(n *Node) bool {
+func IsNil(n Node) bool {
 	// Check n.Orig because constant propagation may produce typed nil constants,
 	// which don't exist in the Go spec.
 	return n.Orig().Op() == ONIL
 }
 
-func IsBlank(n *Node) bool {
+func IsBlank(n Node) bool {
 	if n == nil {
 		return false
 	}
@@ -1662,6 +1662,6 @@ func IsBlank(n *Node) bool {
 
 // IsMethod reports whether n is a method.
 // n must be a function or a method.
-func IsMethod(n *Node) bool {
+func IsMethod(n Node) bool {
 	return n.Type().Recv() != nil
 }
diff --git a/src/cmd/compile/internal/ir/sizeof_test.go b/src/cmd/compile/internal/ir/sizeof_test.go
index 1ec89c338d..0a9542fa44 100644
--- a/src/cmd/compile/internal/ir/sizeof_test.go
+++ b/src/cmd/compile/internal/ir/sizeof_test.go
@@ -20,10 +20,10 @@ func TestSizeof(t *testing.T) {
 		_32bit uintptr     // size on 32bit platforms
 		_64bit uintptr     // size on 64bit platforms
 	}{
-		{Func{}, 136, 248},
-		{Name{}, 32, 56},
-		{Param{}, 24, 48},
-		{Node{}, 76, 128},
+		{Func{}, 152, 280},
+		{Name{}, 44, 80},
+		{Param{}, 44, 88},
+		{node{}, 88, 152},
 	}
 
 	for _, tt := range tests {
diff --git a/src/cmd/compile/internal/ir/val.go b/src/cmd/compile/internal/ir/val.go
index 6bcee7c01c..9035e90084 100644
--- a/src/cmd/compile/internal/ir/val.go
+++ b/src/cmd/compile/internal/ir/val.go
@@ -12,7 +12,7 @@ import (
 	"cmd/compile/internal/types"
 )
 
-func ConstType(n *Node) constant.Kind {
+func ConstType(n Node) constant.Kind {
 	if n == nil || n.Op() != OLITERAL {
 		return constant.Unknown
 	}
@@ -22,7 +22,7 @@ func ConstType(n *Node) constant.Kind {
 // ValueInterface returns the constant value stored in n as an interface{}.
 // It returns int64s for ints and runes, float64s for floats,
 // and complex128s for complex values.
-func ConstValue(n *Node) interface{} {
+func ConstValue(n Node) interface{} {
 	switch v := n.Val(); v.Kind() {
 	default:
 		base.Fatalf("unexpected constant: %v", v)
@@ -91,7 +91,7 @@ func ValidTypeForConst(t *types.Type, v constant.Value) bool {
 }
 
 // nodlit returns a new untyped constant with value v.
-func NewLiteral(v constant.Value) *Node {
+func NewLiteral(v constant.Value) Node {
 	n := Nod(OLITERAL, nil, nil)
 	if k := v.Kind(); k != constant.Unknown {
 		n.SetType(idealType(k))
diff --git a/src/cmd/compile/internal/mips/ssa.go b/src/cmd/compile/internal/mips/ssa.go
index 87e6f5b0c7..bd71b2fcd8 100644
--- a/src/cmd/compile/internal/mips/ssa.go
+++ b/src/cmd/compile/internal/mips/ssa.go
@@ -289,7 +289,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		case *obj.LSym:
 			wantreg = "SB"
 			gc.AddAux(&p.From, v)
-		case *ir.Node:
+		case ir.Node:
 			wantreg = "SP"
 			gc.AddAux(&p.From, v)
 		case nil:
diff --git a/src/cmd/compile/internal/mips64/ssa.go b/src/cmd/compile/internal/mips64/ssa.go
index ea22c488aa..bcadebde4e 100644
--- a/src/cmd/compile/internal/mips64/ssa.go
+++ b/src/cmd/compile/internal/mips64/ssa.go
@@ -263,7 +263,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		case *obj.LSym:
 			wantreg = "SB"
 			gc.AddAux(&p.From, v)
-		case *ir.Node:
+		case ir.Node:
 			wantreg = "SP"
 			gc.AddAux(&p.From, v)
 		case nil:
diff --git a/src/cmd/compile/internal/ppc64/ssa.go b/src/cmd/compile/internal/ppc64/ssa.go
index 848f27af84..32e9be8417 100644
--- a/src/cmd/compile/internal/ppc64/ssa.go
+++ b/src/cmd/compile/internal/ppc64/ssa.go
@@ -752,7 +752,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 				p.To.Reg = v.Reg()
 			}
 
-		case *obj.LSym, *ir.Node:
+		case *obj.LSym, ir.Node:
 			p := s.Prog(ppc64.AMOVD)
 			p.From.Type = obj.TYPE_ADDR
 			p.From.Reg = v.Args[0].Reg()
diff --git a/src/cmd/compile/internal/riscv64/ssa.go b/src/cmd/compile/internal/riscv64/ssa.go
index a3dc07fe03..c81b6897a6 100644
--- a/src/cmd/compile/internal/riscv64/ssa.go
+++ b/src/cmd/compile/internal/riscv64/ssa.go
@@ -324,7 +324,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		case *obj.LSym:
 			wantreg = "SB"
 			gc.AddAux(&p.From, v)
-		case *ir.Node:
+		case ir.Node:
 			wantreg = "SP"
 			gc.AddAux(&p.From, v)
 		case nil:
diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go
index 62abbdc223..eeabd81d03 100644
--- a/src/cmd/compile/internal/ssa/config.go
+++ b/src/cmd/compile/internal/ssa/config.go
@@ -139,7 +139,7 @@ type Frontend interface {
 
 	// Auto returns a Node for an auto variable of the given type.
 	// The SSA compiler uses this function to allocate space for spills.
-	Auto(src.XPos, *types.Type) *ir.Node
+	Auto(src.XPos, *types.Type) ir.Node
 
 	// Given the name for a compound type, returns the name we should use
 	// for the parts of that compound type.
diff --git a/src/cmd/compile/internal/ssa/deadstore.go b/src/cmd/compile/internal/ssa/deadstore.go
index 0f1cd4bc9f..f3ef33d670 100644
--- a/src/cmd/compile/internal/ssa/deadstore.go
+++ b/src/cmd/compile/internal/ssa/deadstore.go
@@ -137,9 +137,9 @@ func dse(f *Func) {
 // reaches stores then we delete all the stores. The other operations will then
 // be eliminated by the dead code elimination pass.
 func elimDeadAutosGeneric(f *Func) {
-	addr := make(map[*Value]*ir.Node) // values that the address of the auto reaches
-	elim := make(map[*Value]*ir.Node) // values that could be eliminated if the auto is
-	used := make(map[*ir.Node]bool)   // used autos that must be kept
+	addr := make(map[*Value]ir.Node) // values that the address of the auto reaches
+	elim := make(map[*Value]ir.Node) // values that could be eliminated if the auto is
+	used := make(map[ir.Node]bool)   // used autos that must be kept
 
 	// visit the value and report whether any of the maps are updated
 	visit := func(v *Value) (changed bool) {
@@ -147,7 +147,7 @@ func elimDeadAutosGeneric(f *Func) {
 		switch v.Op {
 		case OpAddr, OpLocalAddr:
 			// Propagate the address if it points to an auto.
-			n, ok := v.Aux.(*ir.Node)
+			n, ok := v.Aux.(ir.Node)
 			if !ok || n.Class() != ir.PAUTO {
 				return
 			}
@@ -158,7 +158,7 @@ func elimDeadAutosGeneric(f *Func) {
 			return
 		case OpVarDef, OpVarKill:
 			// v should be eliminated if we eliminate the auto.
-			n, ok := v.Aux.(*ir.Node)
+			n, ok := v.Aux.(ir.Node)
 			if !ok || n.Class() != ir.PAUTO {
 				return
 			}
@@ -174,7 +174,7 @@ func elimDeadAutosGeneric(f *Func) {
 			// for open-coded defers from being removed (since they
 			// may not be used by the inline code, but will be used by
 			// panic processing).
-			n, ok := v.Aux.(*ir.Node)
+			n, ok := v.Aux.(ir.Node)
 			if !ok || n.Class() != ir.PAUTO {
 				return
 			}
@@ -222,7 +222,7 @@ func elimDeadAutosGeneric(f *Func) {
 		}
 
 		// Propagate any auto addresses through v.
-		var node *ir.Node
+		var node ir.Node
 		for _, a := range args {
 			if n, ok := addr[a]; ok && !used[n] {
 				if node == nil {
@@ -299,11 +299,11 @@ func elimUnreadAutos(f *Func) {
 	// Loop over all ops that affect autos taking note of which
 	// autos we need and also stores that we might be able to
 	// eliminate.
-	seen := make(map[*ir.Node]bool)
+	seen := make(map[ir.Node]bool)
 	var stores []*Value
 	for _, b := range f.Blocks {
 		for _, v := range b.Values {
-			n, ok := v.Aux.(*ir.Node)
+			n, ok := v.Aux.(ir.Node)
 			if !ok {
 				continue
 			}
@@ -335,7 +335,7 @@ func elimUnreadAutos(f *Func) {
 
 	// Eliminate stores to unread autos.
 	for _, store := range stores {
-		n, _ := store.Aux.(*ir.Node)
+		n, _ := store.Aux.(ir.Node)
 		if seen[n] {
 			continue
 		}
diff --git a/src/cmd/compile/internal/ssa/debug.go b/src/cmd/compile/internal/ssa/debug.go
index 9de5f427c0..0d660361b1 100644
--- a/src/cmd/compile/internal/ssa/debug.go
+++ b/src/cmd/compile/internal/ssa/debug.go
@@ -25,7 +25,7 @@ type FuncDebug struct {
 	// Slots is all the slots used in the debug info, indexed by their SlotID.
 	Slots []LocalSlot
 	// The user variables, indexed by VarID.
-	Vars []*ir.Node
+	Vars []ir.Node
 	// The slots that make up each variable, indexed by VarID.
 	VarSlots [][]SlotID
 	// The location list data, indexed by VarID. Must be processed by PutLocationList.
@@ -166,7 +166,7 @@ func (s *debugState) logf(msg string, args ...interface{}) {
 type debugState struct {
 	// See FuncDebug.
 	slots    []LocalSlot
-	vars     []*ir.Node
+	vars     []ir.Node
 	varSlots [][]SlotID
 	lists    [][]byte
 
@@ -190,7 +190,7 @@ type debugState struct {
 	// The pending location list entry for each user variable, indexed by VarID.
 	pendingEntries []pendingEntry
 
-	varParts           map[*ir.Node][]SlotID
+	varParts           map[ir.Node][]SlotID
 	blockDebug         []BlockDebug
 	pendingSlotLocs    []VarLoc
 	liveSlots          []liveSlot
@@ -347,7 +347,7 @@ func BuildFuncDebug(ctxt *obj.Link, f *Func, loggingEnabled bool, stackOffset fu
 	}
 
 	if state.varParts == nil {
-		state.varParts = make(map[*ir.Node][]SlotID)
+		state.varParts = make(map[ir.Node][]SlotID)
 	} else {
 		for n := range state.varParts {
 			delete(state.varParts, n)
@@ -380,7 +380,7 @@ func BuildFuncDebug(ctxt *obj.Link, f *Func, loggingEnabled bool, stackOffset fu
 	for _, b := range f.Blocks {
 		for _, v := range b.Values {
 			if v.Op == OpVarDef || v.Op == OpVarKill {
-				n := v.Aux.(*ir.Node)
+				n := v.Aux.(ir.Node)
 				if ir.IsSynthetic(n) {
 					continue
 				}
@@ -718,7 +718,7 @@ func (state *debugState) processValue(v *Value, vSlots []SlotID, vReg *Register)
 
 	switch {
 	case v.Op == OpVarDef, v.Op == OpVarKill:
-		n := v.Aux.(*ir.Node)
+		n := v.Aux.(ir.Node)
 		if ir.IsSynthetic(n) {
 			break
 		}
diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go
index 3d142a2272..df83383308 100644
--- a/src/cmd/compile/internal/ssa/export_test.go
+++ b/src/cmd/compile/internal/ssa/export_test.go
@@ -69,7 +69,7 @@ type TestFrontend struct {
 func (TestFrontend) StringData(s string) *obj.LSym {
 	return nil
 }
-func (TestFrontend) Auto(pos src.XPos, t *types.Type) *ir.Node {
+func (TestFrontend) Auto(pos src.XPos, t *types.Type) ir.Node {
 	n := ir.NewNameAt(pos, &types.Sym{Name: "aFakeAuto"})
 	n.SetClass(ir.PAUTO)
 	return n
diff --git a/src/cmd/compile/internal/ssa/location.go b/src/cmd/compile/internal/ssa/location.go
index 2f456c9f89..3dc3a81703 100644
--- a/src/cmd/compile/internal/ssa/location.go
+++ b/src/cmd/compile/internal/ssa/location.go
@@ -60,7 +60,7 @@ func (r *Register) GCNum() int16 {
 //                           { N: len, Type: int, Off: 0, SplitOf: parent, SplitOffset: 8}
 //                           parent = &{N: s, Type: string}
 type LocalSlot struct {
-	N    *ir.Node    // an ONAME *gc.Node representing a stack location.
+	N    ir.Node     // an ONAME *gc.Node representing a stack location.
 	Type *types.Type // type of slot
 	Off  int64       // offset of slot in N
 
diff --git a/src/cmd/compile/internal/ssa/nilcheck.go b/src/cmd/compile/internal/ssa/nilcheck.go
index 3c1fa600a3..b36f6b97e1 100644
--- a/src/cmd/compile/internal/ssa/nilcheck.go
+++ b/src/cmd/compile/internal/ssa/nilcheck.go
@@ -236,7 +236,7 @@ func nilcheckelim2(f *Func) {
 				continue
 			}
 			if v.Type.IsMemory() || v.Type.IsTuple() && v.Type.FieldType(1).IsMemory() {
-				if v.Op == OpVarKill || v.Op == OpVarLive || (v.Op == OpVarDef && !v.Aux.(*ir.Node).Type().HasPointers()) {
+				if v.Op == OpVarKill || v.Op == OpVarLive || (v.Op == OpVarDef && !v.Aux.(ir.Node).Type().HasPointers()) {
 					// These ops don't really change memory.
 					continue
 					// Note: OpVarDef requires that the defined variable not have pointers.
diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go
index 9841883939..459a9923f7 100644
--- a/src/cmd/compile/internal/ssa/regalloc.go
+++ b/src/cmd/compile/internal/ssa/regalloc.go
@@ -1249,7 +1249,7 @@ func (s *regAllocState) regalloc(f *Func) {
 					// This forces later liveness analysis to make the
 					// value live at this point.
 					v.SetArg(0, s.makeSpill(a, b))
-				} else if _, ok := a.Aux.(*ir.Node); ok && vi.rematerializeable {
+				} else if _, ok := a.Aux.(ir.Node); ok && vi.rematerializeable {
 					// Rematerializeable value with a gc.Node. This is the address of
 					// a stack object (e.g. an LEAQ). Keep the object live.
 					// Change it to VarLive, which is what plive expects for locals.
diff --git a/src/cmd/compile/internal/ssa/sizeof_test.go b/src/cmd/compile/internal/ssa/sizeof_test.go
index a27002ee3a..60ada011e3 100644
--- a/src/cmd/compile/internal/ssa/sizeof_test.go
+++ b/src/cmd/compile/internal/ssa/sizeof_test.go
@@ -22,7 +22,7 @@ func TestSizeof(t *testing.T) {
 	}{
 		{Value{}, 72, 112},
 		{Block{}, 164, 304},
-		{LocalSlot{}, 28, 40},
+		{LocalSlot{}, 32, 48},
 		{valState{}, 28, 40},
 	}
 
diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go
index eee0a21a66..5257d44cfe 100644
--- a/src/cmd/compile/internal/ssa/stackalloc.go
+++ b/src/cmd/compile/internal/ssa/stackalloc.go
@@ -157,7 +157,7 @@ func (s *stackAllocState) stackalloc() {
 		if v.Aux == nil {
 			f.Fatalf("%s has nil Aux\n", v.LongString())
 		}
-		loc := LocalSlot{N: v.Aux.(*ir.Node), Type: v.Type, Off: v.AuxInt}
+		loc := LocalSlot{N: v.Aux.(ir.Node), Type: v.Type, Off: v.AuxInt}
 		if f.pass.debug > stackDebug {
 			fmt.Printf("stackalloc %s to %s\n", v, loc)
 		}
diff --git a/src/cmd/compile/internal/wasm/ssa.go b/src/cmd/compile/internal/wasm/ssa.go
index 1a8b5691ef..e7451381b4 100644
--- a/src/cmd/compile/internal/wasm/ssa.go
+++ b/src/cmd/compile/internal/wasm/ssa.go
@@ -237,7 +237,7 @@ func ssaGenValueOnStack(s *gc.SSAGenState, v *ssa.Value, extend bool) {
 		switch v.Aux.(type) {
 		case *obj.LSym:
 			gc.AddAux(&p.From, v)
-		case *ir.Node:
+		case ir.Node:
 			p.From.Reg = v.Args[0].Reg()
 			gc.AddAux(&p.From, v)
 		default:
-- 
GitLab


From 88e33f6ecb9ea44a464bd3863f8037bc081b2a6e Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 25 Nov 2020 14:02:46 -0800
Subject: [PATCH 0077/2400] [dev.regabi] cmd/compile: fix latent import/export
 issue with break/continue

In CL 145200, I changed OBREAK, OCONTINUE, OGOTO, and OLABEL to just
use Sym instead of Node. However, within the export data, I forgot to
update the code for OBREAK and OCONTINUE.

This isn't currently an issue because the inliner currently disallows
these anyway, but it'll be an issue in the future once we add support
for inlining them. Also, Russ independently ran into it in CL 273246.

Updates #14768.

Change-Id: I94575df59c08a750b0dce1d3ce612aba7bfeeb76
Reviewed-on: https://go-review.googlesource.com/c/go/+/273270
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/gc/iexport.go | 13 ++++++-------
 src/cmd/compile/internal/gc/iimport.go | 14 ++++----------
 2 files changed, 10 insertions(+), 17 deletions(-)

diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index ef52e40f21..7c42e43bee 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -1146,18 +1146,17 @@ func (w *exportWriter) stmt(n ir.Node) {
 		w.op(ir.OFALL)
 		w.pos(n.Pos())
 
-	case ir.OBREAK, ir.OCONTINUE:
-		w.op(op)
-		w.pos(n.Pos())
-		w.exprsOrNil(n.Left(), nil)
-
 	case ir.OEMPTY:
 		// nothing to emit
 
-	case ir.OGOTO, ir.OLABEL:
+	case ir.OBREAK, ir.OCONTINUE, ir.OGOTO, ir.OLABEL:
 		w.op(op)
 		w.pos(n.Pos())
-		w.string(n.Sym().Name)
+		label := ""
+		if sym := n.Sym(); sym != nil {
+			label = sym.Name
+		}
+		w.string(label)
 
 	default:
 		base.Fatalf("exporter: CANNOT EXPORT: %v\nPlease notify gri@\n", n.Op())
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 77078c118a..066d956b93 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -1052,20 +1052,14 @@ func (r *importReader) node() ir.Node {
 		n := ir.NodAt(r.pos(), ir.OFALL, nil, nil)
 		return n
 
-	case ir.OBREAK, ir.OCONTINUE:
-		pos := r.pos()
-		left, _ := r.exprsOrNil()
-		if left != nil {
-			left = NewName(left.Sym())
-		}
-		return ir.NodAt(pos, op, left, nil)
-
 	// case OEMPTY:
 	// 	unreachable - not emitted by exporter
 
-	case ir.OGOTO, ir.OLABEL:
+	case ir.OBREAK, ir.OCONTINUE, ir.OGOTO, ir.OLABEL:
 		n := ir.NodAt(r.pos(), op, nil, nil)
-		n.SetSym(lookup(r.string()))
+		if label := r.string(); label != "" {
+			n.SetSym(lookup(label))
+		}
 		return n
 
 	case ir.OEND:
-- 
GitLab


From 65f4ec2faec54b7a3e70f2404132df9d83df11e0 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 27 Nov 2020 23:52:37 -0500
Subject: [PATCH 0078/2400] [dev.regabi] cmd/compile: cleanup label handling

- The use of a label's Name.Defn to point at the named for/select/switch
  means that any rewrite of the for/select/switch must overwrite the original
  or else the pointer will dangle. Remove that pointer by adding the label
  name directly to the for/select/switch representation instead.

- The only uses of a label's Sym.Label were ephemeral values during
  markbreak and escape analysis. Use a map for each. Although in general
  we are not going to replace all computed fields with maps (too slow),
  the one in markbreak is only for labeled for/select/switch, and the one
  in escape is for all labels, but even so, labels are fairly rare.

In theory this cleanup should make it easy to allow labeled for/select/switch
in inlined bodies, but this CL does not attempt that. It's only concerned
with cleanup to enable a new Node representation.

Passes buildall w/ toolstash -cmp.

Change-Id: I7e36ee98d2ea40dbae94e6722d585f007b7afcfa
Reviewed-on: https://go-review.googlesource.com/c/go/+/274086
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/escape.go         | 28 +++++++----
 src/cmd/compile/internal/gc/inl.go            |  8 ++--
 src/cmd/compile/internal/gc/noder.go          |  9 +++-
 src/cmd/compile/internal/gc/ssa.go            | 21 ++++-----
 src/cmd/compile/internal/gc/subr.go           | 17 -------
 src/cmd/compile/internal/gc/typecheck.go      | 47 ++++++++-----------
 src/cmd/compile/internal/types/sizeof_test.go |  2 +-
 src/cmd/compile/internal/types/sym.go         |  5 +-
 8 files changed, 60 insertions(+), 77 deletions(-)

diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 783bc8c41d..34f52c743a 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -85,6 +85,7 @@ import (
 
 type Escape struct {
 	allLocs []*EscLocation
+	labels  map[*types.Sym]labelState // known labels
 
 	curfn ir.Node
 
@@ -229,13 +230,16 @@ func (e *Escape) walkFunc(fn ir.Node) {
 	ir.InspectList(fn.Body(), func(n ir.Node) bool {
 		switch n.Op() {
 		case ir.OLABEL:
-			n.Sym().Label = nonlooping
+			if e.labels == nil {
+				e.labels = make(map[*types.Sym]labelState)
+			}
+			e.labels[n.Sym()] = nonlooping
 
 		case ir.OGOTO:
 			// If we visited the label before the goto,
 			// then this is a looping label.
-			if n.Sym().Label == nonlooping {
-				n.Sym().Label = looping
+			if e.labels[n.Sym()] == nonlooping {
+				e.labels[n.Sym()] = looping
 			}
 		}
 
@@ -245,6 +249,10 @@ func (e *Escape) walkFunc(fn ir.Node) {
 	e.curfn = fn
 	e.loopDepth = 1
 	e.block(fn.Body())
+
+	if len(e.labels) != 0 {
+		base.FatalfAt(fn.Pos(), "leftover labels after walkFunc")
+	}
 }
 
 // Below we implement the methods for walking the AST and recording
@@ -310,7 +318,7 @@ func (e *Escape) stmt(n ir.Node) {
 		}
 
 	case ir.OLABEL:
-		switch ir.AsNode(n.Sym().Label) {
+		switch e.labels[n.Sym()] {
 		case nonlooping:
 			if base.Flag.LowerM > 2 {
 				fmt.Printf("%v:%v non-looping label\n", base.FmtPos(base.Pos), n)
@@ -323,7 +331,7 @@ func (e *Escape) stmt(n ir.Node) {
 		default:
 			base.Fatalf("label missing tag")
 		}
-		n.Sym().Label = nil
+		delete(e.labels, n.Sym())
 
 	case ir.OIF:
 		e.discard(n.Left())
@@ -1615,11 +1623,11 @@ func funcSym(fn ir.Node) *types.Sym {
 }
 
 // Mark labels that have no backjumps to them as not increasing e.loopdepth.
-// Walk hasn't generated (goto|label).Left.Sym.Label yet, so we'll cheat
-// and set it to one of the following two. Then in esc we'll clear it again.
-var (
-	looping    = ir.Nod(ir.OXXX, nil, nil)
-	nonlooping = ir.Nod(ir.OXXX, nil, nil)
+type labelState int
+
+const (
+	looping labelState = 1 + iota
+	nonlooping
 )
 
 func isSliceSelfAssign(dst, src ir.Node) bool {
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 6310762c1f..d43d0d06af 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -405,16 +405,16 @@ func (v *hairyVisitor) visit(n ir.Node) bool {
 		// These nodes don't produce code; omit from inlining budget.
 		return false
 
-	case ir.OLABEL:
-		// TODO(mdempsky): Add support for inlining labeled control statements.
-		if labeledControl(n) != nil {
+	case ir.OFOR, ir.OFORUNTIL, ir.OSWITCH:
+		// ORANGE, OSELECT in "unhandled" above
+		if n.Sym() != nil {
 			v.reason = "labeled control"
 			return true
 		}
 
 	case ir.OBREAK, ir.OCONTINUE:
 		if n.Sym() != nil {
-			// Should have short-circuited due to labeledControl above.
+			// Should have short-circuited due to labeled control error above.
 			base.Fatalf("unexpected labeled break/continue: %v", n)
 		}
 
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 950d509047..ecd50b87f6 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -1302,14 +1302,19 @@ func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []i
 }
 
 func (p *noder) labeledStmt(label *syntax.LabeledStmt, fallOK bool) ir.Node {
-	lhs := p.nodSym(label, ir.OLABEL, nil, p.name(label.Label))
+	sym := p.name(label.Label)
+	lhs := p.nodSym(label, ir.OLABEL, nil, sym)
 
 	var ls ir.Node
 	if label.Stmt != nil { // TODO(mdempsky): Should always be present.
 		ls = p.stmtFall(label.Stmt, fallOK)
+		switch label.Stmt.(type) {
+		case *syntax.ForStmt, *syntax.SwitchStmt, *syntax.SelectStmt:
+			// Attach label directly to control statement too.
+			ls.SetSym(sym)
+		}
 	}
 
-	lhs.Name().Defn = ls
 	l := []ir.Node{lhs}
 	if ls != nil {
 		if ls.Op() == ir.OBLOCK && ls.Init().Len() == 0 {
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index cb73532b48..bcc126f82e 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -356,7 +356,6 @@ func buildssa(fn ir.Node, worker int) *ssa.Func {
 
 	// Allocate starting values
 	s.labels = map[string]*ssaLabel{}
-	s.labeledNodes = map[ir.Node]*ssaLabel{}
 	s.fwdVars = map[ir.Node]*ssa.Value{}
 	s.startmem = s.entryNewValue0(ssa.OpInitMem, types.TypeMem)
 
@@ -596,9 +595,8 @@ type state struct {
 	// Node for function
 	curfn ir.Node
 
-	// labels and labeled control flow nodes (OFOR, OFORUNTIL, OSWITCH, OSELECT) in f
-	labels       map[string]*ssaLabel
-	labeledNodes map[ir.Node]*ssaLabel
+	// labels in f
+	labels map[string]*ssaLabel
 
 	// unlabeled break and continue statement tracking
 	breakTo    *ssa.Block // current target for plain break statement
@@ -1169,11 +1167,6 @@ func (s *state) stmt(n ir.Node) {
 		sym := n.Sym()
 		lab := s.label(sym)
 
-		// Associate label with its control flow node, if any
-		if ctl := labeledControl(n); ctl != nil {
-			s.labeledNodes[ctl] = lab
-		}
-
 		// The label might already have a target block via a goto.
 		if lab.target == nil {
 			lab.target = s.f.NewBlock(ssa.BlockPlain)
@@ -1431,9 +1424,10 @@ func (s *state) stmt(n ir.Node) {
 		prevBreak := s.breakTo
 		s.continueTo = bIncr
 		s.breakTo = bEnd
-		lab := s.labeledNodes[n]
-		if lab != nil {
+		var lab *ssaLabel
+		if sym := n.Sym(); sym != nil {
 			// labeled for loop
+			lab = s.label(sym)
 			lab.continueTarget = bIncr
 			lab.breakTarget = bEnd
 		}
@@ -1489,9 +1483,10 @@ func (s *state) stmt(n ir.Node) {
 
 		prevBreak := s.breakTo
 		s.breakTo = bEnd
-		lab := s.labeledNodes[n]
-		if lab != nil {
+		var lab *ssaLabel
+		if sym := n.Sym(); sym != nil {
 			// labeled
+			lab = s.label(sym)
 			lab.breakTarget = bEnd
 		}
 
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index fcda219737..d174ebd582 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -582,23 +582,6 @@ func backingArrayPtrLen(n ir.Node) (ptr, len ir.Node) {
 	return ptr, len
 }
 
-// labeledControl returns the control flow Node (for, switch, select)
-// associated with the label n, if any.
-func labeledControl(n ir.Node) ir.Node {
-	if n.Op() != ir.OLABEL {
-		base.Fatalf("labeledControl %v", n.Op())
-	}
-	ctl := n.Name().Defn
-	if ctl == nil {
-		return nil
-	}
-	switch ctl.Op() {
-	case ir.OFOR, ir.OFORUNTIL, ir.OSWITCH, ir.OSELECT:
-		return ctl
-	}
-	return nil
-}
-
 func syslook(name string) ir.Node {
 	s := Runtimepkg.Lookup(name)
 	if s == nil || s.Def == nil {
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 4e2f205312..ede3778184 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -3759,7 +3759,7 @@ func checkmake(t *types.Type, arg string, np *ir.Node) bool {
 	return true
 }
 
-func markbreak(n ir.Node, implicit ir.Node) {
+func markbreak(labels *map[*types.Sym]ir.Node, n ir.Node, implicit ir.Node) {
 	if n == nil {
 		return
 	}
@@ -3771,43 +3771,35 @@ func markbreak(n ir.Node, implicit ir.Node) {
 				implicit.SetHasBreak(true)
 			}
 		} else {
-			lab := ir.AsNode(n.Sym().Label)
-			if lab != nil {
+			if lab := (*labels)[n.Sym()]; lab != nil {
 				lab.SetHasBreak(true)
 			}
 		}
 	case ir.OFOR, ir.OFORUNTIL, ir.OSWITCH, ir.OTYPESW, ir.OSELECT, ir.ORANGE:
 		implicit = n
+		if sym := n.Sym(); sym != nil {
+			if *labels == nil {
+				// Map creation delayed until we need it - most functions don't.
+				*labels = make(map[*types.Sym]ir.Node)
+			}
+			(*labels)[sym] = n
+			defer delete(*labels, sym)
+		}
 		fallthrough
 	default:
-		markbreak(n.Left(), implicit)
-		markbreak(n.Right(), implicit)
-		markbreaklist(n.Init(), implicit)
-		markbreaklist(n.Body(), implicit)
-		markbreaklist(n.List(), implicit)
-		markbreaklist(n.Rlist(), implicit)
+		markbreak(labels, n.Left(), implicit)
+		markbreak(labels, n.Right(), implicit)
+		markbreaklist(labels, n.Init(), implicit)
+		markbreaklist(labels, n.Body(), implicit)
+		markbreaklist(labels, n.List(), implicit)
+		markbreaklist(labels, n.Rlist(), implicit)
 	}
 }
 
-func markbreaklist(l ir.Nodes, implicit ir.Node) {
+func markbreaklist(labels *map[*types.Sym]ir.Node, l ir.Nodes, implicit ir.Node) {
 	s := l.Slice()
 	for i := 0; i < len(s); i++ {
-		n := s[i]
-		if n == nil {
-			continue
-		}
-		if n.Op() == ir.OLABEL && i+1 < len(s) && n.Name().Defn == s[i+1] {
-			switch n.Name().Defn.Op() {
-			case ir.OFOR, ir.OFORUNTIL, ir.OSWITCH, ir.OTYPESW, ir.OSELECT, ir.ORANGE:
-				n.Sym().Label = n.Name().Defn
-				markbreak(n.Name().Defn, n.Name().Defn)
-				n.Sym().Label = nil
-				i++
-				continue
-			}
-		}
-
-		markbreak(n, implicit)
+		markbreak(labels, s[i], implicit)
 	}
 }
 
@@ -3874,7 +3866,8 @@ func isTermNode(n ir.Node) bool {
 // checkreturn makes sure that fn terminates appropriately.
 func checkreturn(fn ir.Node) {
 	if fn.Type().NumResults() != 0 && fn.Body().Len() != 0 {
-		markbreaklist(fn.Body(), nil)
+		var labels map[*types.Sym]ir.Node
+		markbreaklist(&labels, fn.Body(), nil)
 		if !isTermNodes(fn.Body()) {
 			base.ErrorfAt(fn.Func().Endlineno, "missing return at end of function")
 		}
diff --git a/src/cmd/compile/internal/types/sizeof_test.go b/src/cmd/compile/internal/types/sizeof_test.go
index 2821d9a3c7..88a2fbba2f 100644
--- a/src/cmd/compile/internal/types/sizeof_test.go
+++ b/src/cmd/compile/internal/types/sizeof_test.go
@@ -20,7 +20,7 @@ func TestSizeof(t *testing.T) {
 		_32bit uintptr     // size on 32bit platforms
 		_64bit uintptr     // size on 64bit platforms
 	}{
-		{Sym{}, 60, 104},
+		{Sym{}, 52, 88},
 		{Type{}, 56, 96},
 		{Map{}, 20, 40},
 		{Forward{}, 20, 32},
diff --git a/src/cmd/compile/internal/types/sym.go b/src/cmd/compile/internal/types/sym.go
index 046104d0dc..7272f1f786 100644
--- a/src/cmd/compile/internal/types/sym.go
+++ b/src/cmd/compile/internal/types/sym.go
@@ -33,13 +33,12 @@ type Sym struct {
 	Name string // object name
 
 	// saved and restored by dcopy
-	Def        IRNode    // definition: ONAME OTYPE OPACK or OLITERAL
+	Def        IRNode   // definition: ONAME OTYPE OPACK or OLITERAL
 	Block      int32    // blocknumber to catch redeclaration
 	Lastlineno src.XPos // last declaration for diagnostic
 
 	flags   bitset8
-	Label   IRNode // corresponding label (ephemeral)
-	Origpkg *Pkg  // original package for . import
+	Origpkg *Pkg // original package for . import
 }
 
 const (
-- 
GitLab


From 0c65a2f31734021654ec5eebc270f8c84e5410c7 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 28 Nov 2020 00:05:15 -0500
Subject: [PATCH 0079/2400] [dev.regabi] cmd/compile: drop Node.HasOpt method

Node.HasOpt is only used once, and that use can use Opt instead.
Interface is one method smaller.

Passes buildall w/ toolstash -cmp.

Change-Id: I6a9d5859a9977a8f4c9db70e166f50f0d8052160
Reviewed-on: https://go-review.googlesource.com/c/go/+/274087
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/escape.go | 2 +-
 src/cmd/compile/internal/ir/node.go   | 9 ++++-----
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 34f52c743a..6b6fb44a99 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -1092,7 +1092,7 @@ func (e *Escape) newLoc(n ir.Node, transient bool) *EscLocation {
 			base.Fatalf("curfn mismatch: %v != %v", n.Name().Curfn, e.curfn)
 		}
 
-		if n.HasOpt() {
+		if n.Opt() != nil {
 			base.Fatalf("%v already has a location", n)
 		}
 		n.SetOpt(loc)
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 477d07f502..acfddd2dc7 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -111,7 +111,6 @@ type Node interface {
 	SetWalkdef(x uint8)
 	Opt() interface{}
 	SetOpt(x interface{})
-	HasOpt() bool
 	Diag() bool
 	SetDiag(x bool)
 	Bounded() bool
@@ -325,7 +324,7 @@ func (n *node) Bounded() bool   { return n.flags&nodeBounded != 0 }
 func (n *node) HasCall() bool   { return n.flags&nodeHasCall != 0 }
 func (n *node) Likely() bool    { return n.flags&nodeLikely != 0 }
 func (n *node) HasVal() bool    { return n.flags&nodeHasVal != 0 }
-func (n *node) HasOpt() bool    { return n.flags&nodeHasOpt != 0 }
+func (n *node) hasOpt() bool    { return n.flags&nodeHasOpt != 0 }
 func (n *node) Embedded() bool  { return n.flags&nodeEmbedded != 0 }
 
 func (n *node) SetClass(b Class)     { n.flags.set3(nodeClass, uint8(b)) }
@@ -399,7 +398,7 @@ func (n *node) Val() constant.Value {
 // SetVal sets the constant.Value for the node,
 // which must not have been used with SetOpt.
 func (n *node) SetVal(v constant.Value) {
-	if n.HasOpt() {
+	if n.hasOpt() {
 		base.Flag.LowerH = 1
 		Dump("have Opt", n)
 		base.Fatalf("have Opt")
@@ -413,7 +412,7 @@ func (n *node) SetVal(v constant.Value) {
 
 // Opt returns the optimizer data for the node.
 func (n *node) Opt() interface{} {
-	if !n.HasOpt() {
+	if !n.hasOpt() {
 		return nil
 	}
 	return n.e
@@ -423,7 +422,7 @@ func (n *node) Opt() interface{} {
 // SetOpt(nil) is ignored for Vals to simplify call sites that are clearing Opts.
 func (n *node) SetOpt(x interface{}) {
 	if x == nil {
-		if n.HasOpt() {
+		if n.hasOpt() {
 			n.setHasOpt(false)
 			n.e = nil
 		}
-- 
GitLab


From 79a3d5ce158de1696256d58aa563ca7cd30f6c3f Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 28 Nov 2020 00:14:38 -0500
Subject: [PATCH 0080/2400] [dev.regabi] cmd/compile: setup for new Node
 implementations

Start a list of which ops are valid for the default
node struct implementation (currently all of them).

Add a Node implementation helper for a minimal node.

Passes buildall w/ toolstash -cmp.

Change-Id: I7ae45f2cf2be85013cb71ab00524be53f243e13d
Reviewed-on: https://go-review.googlesource.com/c/go/+/274088
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/typecheck.go |   4 +-
 src/cmd/compile/internal/ir/bitset.go    |  12 ++
 src/cmd/compile/internal/ir/mini.go      | 188 ++++++++++++++++
 src/cmd/compile/internal/ir/node.go      | 260 +++++++++++++++++++----
 4 files changed, 424 insertions(+), 40 deletions(-)
 create mode 100644 src/cmd/compile/internal/ir/mini.go

diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index ede3778184..9da464e1b6 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -1694,8 +1694,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			return n
 		}
 		op, why := convertop(n.Left().Op() == ir.OLITERAL, t, n.Type())
-		n.SetOp(op)
-		if n.Op() == ir.OXXX {
+		if op == ir.OXXX {
 			if !n.Diag() && !n.Type().Broke() && !n.Left().Diag() {
 				base.Errorf("cannot convert %L to type %v%s", n.Left(), n.Type(), why)
 				n.SetDiag(true)
@@ -1705,6 +1704,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			return n
 		}
 
+		n.SetOp(op)
 		switch n.Op() {
 		case ir.OCONVNOP:
 			if t.Etype == n.Type().Etype {
diff --git a/src/cmd/compile/internal/ir/bitset.go b/src/cmd/compile/internal/ir/bitset.go
index 29f136296f..0c7bd542f6 100644
--- a/src/cmd/compile/internal/ir/bitset.go
+++ b/src/cmd/compile/internal/ir/bitset.go
@@ -14,6 +14,18 @@ func (f *bitset8) set(mask uint8, b bool) {
 	}
 }
 
+func (f bitset8) get2(shift uint8) uint8 {
+	return uint8(f>>shift) & 3
+}
+
+// set2 sets two bits in f using the bottom two bits of b.
+func (f *bitset8) set2(shift uint8, b uint8) {
+	// Clear old bits.
+	*(*uint8)(f) &^= 3 << shift
+	// Set new bits.
+	*(*uint8)(f) |= uint8(b&3) << shift
+}
+
 type bitset16 uint16
 
 func (f *bitset16) set(mask uint16, b bool) {
diff --git a/src/cmd/compile/internal/ir/mini.go b/src/cmd/compile/internal/ir/mini.go
new file mode 100644
index 0000000000..48dccf6a5f
--- /dev/null
+++ b/src/cmd/compile/internal/ir/mini.go
@@ -0,0 +1,188 @@
+// Copyright 2020 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 ir
+
+import (
+	"cmd/compile/internal/types"
+	"cmd/internal/src"
+	"fmt"
+	"go/constant"
+)
+
+// A miniNode is a minimal node implementation,
+// meant to be embedded as the first field in a larger node implementation,
+// at a cost of 8 bytes.
+//
+// A miniNode is NOT a valid Node by itself: the embedding struct
+// must at the least provide:
+//
+//	func (n *MyNode) String() string { return fmt.Sprint(n) }
+//	func (n *MyNode) RawCopy() Node { c := *n; return &c }
+//	func (n *MyNode) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+//
+// The embedding struct should also fill in n.op in its constructor,
+// for more useful panic messages when invalid methods are called,
+// instead of implementing Op itself.
+//
+type miniNode struct {
+	pos  src.XPos // uint32
+	op   Op       // uint8
+	bits bitset8
+	esc  uint16
+}
+
+// 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.)
+func (n *miniNode) Op() Op            { return n.op }
+func (n *miniNode) Pos() src.XPos     { return n.pos }
+func (n *miniNode) SetPos(x src.XPos) { n.pos = x }
+func (n *miniNode) Esc() uint16       { return n.esc }
+func (n *miniNode) SetEsc(x uint16)   { n.esc = x }
+
+const (
+	miniWalkdefShift   = 0
+	miniTypecheckShift = 2
+	miniInitorderShift = 4
+	miniDiag           = 1 << 6
+	miniHasCall        = 1 << 7 // for miniStmt
+)
+
+func (n *miniNode) Walkdef() uint8   { return n.bits.get2(miniWalkdefShift) }
+func (n *miniNode) Typecheck() uint8 { return n.bits.get2(miniTypecheckShift) }
+func (n *miniNode) Initorder() uint8 { return n.bits.get2(miniInitorderShift) }
+func (n *miniNode) SetWalkdef(x uint8) {
+	if x > 3 {
+		panic(fmt.Sprintf("cannot SetWalkdef %d", x))
+	}
+	n.bits.set2(miniWalkdefShift, x)
+}
+func (n *miniNode) SetTypecheck(x uint8) {
+	if x > 3 {
+		panic(fmt.Sprintf("cannot SetTypecheck %d", x))
+	}
+	n.bits.set2(miniTypecheckShift, x)
+}
+func (n *miniNode) SetInitorder(x uint8) {
+	if x > 3 {
+		panic(fmt.Sprintf("cannot SetInitorder %d", x))
+	}
+	n.bits.set2(miniInitorderShift, x)
+}
+
+func (n *miniNode) Diag() bool     { return n.bits&miniDiag != 0 }
+func (n *miniNode) SetDiag(x bool) { n.bits.set(miniDiag, x) }
+
+// Empty, immutable graph structure.
+
+func (n *miniNode) Left() Node       { return nil }
+func (n *miniNode) Right() Node      { return nil }
+func (n *miniNode) Init() Nodes      { return Nodes{} }
+func (n *miniNode) PtrInit() *Nodes  { return &immutableEmptyNodes }
+func (n *miniNode) Body() Nodes      { return Nodes{} }
+func (n *miniNode) PtrBody() *Nodes  { return &immutableEmptyNodes }
+func (n *miniNode) List() Nodes      { return Nodes{} }
+func (n *miniNode) PtrList() *Nodes  { return &immutableEmptyNodes }
+func (n *miniNode) Rlist() Nodes     { return Nodes{} }
+func (n *miniNode) PtrRlist() *Nodes { return &immutableEmptyNodes }
+func (n *miniNode) SetLeft(x Node) {
+	if x != nil {
+		panic(n.no("SetLeft"))
+	}
+}
+func (n *miniNode) SetRight(x Node) {
+	if x != nil {
+		panic(n.no("SetRight"))
+	}
+}
+func (n *miniNode) SetInit(x Nodes) {
+	if x != (Nodes{}) {
+		panic(n.no("SetInit"))
+	}
+}
+func (n *miniNode) SetBody(x Nodes) {
+	if x != (Nodes{}) {
+		panic(n.no("SetBody"))
+	}
+}
+func (n *miniNode) SetList(x Nodes) {
+	if x != (Nodes{}) {
+		panic(n.no("SetList"))
+	}
+}
+func (n *miniNode) SetRlist(x Nodes) {
+	if x != (Nodes{}) {
+		panic(n.no("SetRlist"))
+	}
+}
+
+// Additional functionality unavailable.
+
+func (n *miniNode) no(name string) string { return "cannot " + name + " on " + n.op.String() }
+
+func (n *miniNode) SetOp(Op)            { panic(n.no("SetOp")) }
+func (n *miniNode) SubOp() Op           { panic(n.no("SubOp")) }
+func (n *miniNode) SetSubOp(Op)         { panic(n.no("SetSubOp")) }
+func (n *miniNode) Type() *types.Type   { return nil }
+func (n *miniNode) SetType(*types.Type) { panic(n.no("SetType")) }
+func (n *miniNode) Func() *Func         { panic(n.no("Func")) }
+func (n *miniNode) SetFunc(*Func)       { panic(n.no("SetFunc")) }
+func (n *miniNode) Name() *Name         { return nil }
+func (n *miniNode) SetName(*Name)       { panic(n.no("SetName")) }
+func (n *miniNode) Sym() *types.Sym     { return nil }
+func (n *miniNode) SetSym(*types.Sym)   { panic(n.no("SetSym")) }
+func (n *miniNode) Offset() int64       { return types.BADWIDTH }
+func (n *miniNode) SetOffset(x int64)   { panic(n.no("SetOffset")) }
+func (n *miniNode) Class() Class        { return Pxxx }
+func (n *miniNode) SetClass(Class)      { panic(n.no("SetClass")) }
+func (n *miniNode) Likely() bool        { panic(n.no("Likely")) }
+func (n *miniNode) SetLikely(bool)      { panic(n.no("SetLikely")) }
+func (n *miniNode) SliceBounds() (low, high, max Node) {
+	panic(n.no("SliceBounds"))
+}
+func (n *miniNode) SetSliceBounds(low, high, max Node) {
+	panic(n.no("SetSliceBounds"))
+}
+func (n *miniNode) Iota() int64               { panic(n.no("Iota")) }
+func (n *miniNode) SetIota(int64)             { panic(n.no("SetIota")) }
+func (n *miniNode) Colas() bool               { return false }
+func (n *miniNode) SetColas(bool)             { panic(n.no("SetColas")) }
+func (n *miniNode) NoInline() bool            { panic(n.no("NoInline")) }
+func (n *miniNode) SetNoInline(bool)          { panic(n.no("SetNoInline")) }
+func (n *miniNode) Transient() bool           { panic(n.no("Transient")) }
+func (n *miniNode) SetTransient(bool)         { panic(n.no("SetTransient")) }
+func (n *miniNode) Implicit() bool            { return false }
+func (n *miniNode) SetImplicit(bool)          { panic(n.no("SetImplicit")) }
+func (n *miniNode) IsDDD() bool               { return false }
+func (n *miniNode) SetIsDDD(bool)             { panic(n.no("SetIsDDD")) }
+func (n *miniNode) Embedded() bool            { return false }
+func (n *miniNode) SetEmbedded(bool)          { panic(n.no("SetEmbedded")) }
+func (n *miniNode) IndexMapLValue() bool      { panic(n.no("IndexMapLValue")) }
+func (n *miniNode) SetIndexMapLValue(bool)    { panic(n.no("SetIndexMapLValue")) }
+func (n *miniNode) ResetAux()                 { panic(n.no("ResetAux")) }
+func (n *miniNode) HasBreak() bool            { panic(n.no("HasBreak")) }
+func (n *miniNode) SetHasBreak(bool)          { panic(n.no("SetHasBreak")) }
+func (n *miniNode) HasVal() bool              { return false }
+func (n *miniNode) Val() constant.Value       { panic(n.no("Val")) }
+func (n *miniNode) SetVal(v constant.Value)   { panic(n.no("SetVal")) }
+func (n *miniNode) Int64Val() int64           { panic(n.no("Int64Val")) }
+func (n *miniNode) Uint64Val() uint64         { panic(n.no("Uint64Val")) }
+func (n *miniNode) CanInt64() bool            { panic(n.no("CanInt64")) }
+func (n *miniNode) BoolVal() bool             { panic(n.no("BoolVal")) }
+func (n *miniNode) StringVal() string         { panic(n.no("StringVal")) }
+func (n *miniNode) HasCall() bool             { panic(n.no("HasCall")) }
+func (n *miniNode) SetHasCall(bool)           { panic(n.no("SetHasCall")) }
+func (n *miniNode) NonNil() bool              { return false }
+func (n *miniNode) MarkNonNil()               { panic(n.no("MarkNonNil")) }
+func (n *miniNode) Bounded() bool             { return false }
+func (n *miniNode) SetBounded(bool)           { panic(n.no("SetBounded")) }
+func (n *miniNode) Opt() interface{}          { return nil }
+func (n *miniNode) SetOpt(interface{})        { panic(n.no("SetOpt")) }
+func (n *miniNode) MarkReadonly()             { panic(n.no("MarkReadonly")) }
+func (n *miniNode) TChanDir() types.ChanDir   { panic(n.no("TChanDir")) }
+func (n *miniNode) SetTChanDir(types.ChanDir) { panic(n.no("SetTChanDir")) }
+
+// TODO: Delete when CanBeAnSSASym is removed from Node itself.
+func (*miniNode) CanBeAnSSASym() {}
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index acfddd2dc7..7a61355858 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -199,7 +199,6 @@ func (n *node) SetOffset(x int64)     { n.offset = x }
 func (n *node) Esc() uint16           { return n.esc }
 func (n *node) SetEsc(x uint16)       { n.esc = x }
 func (n *node) Op() Op                { return n.op }
-func (n *node) SetOp(x Op)            { n.op = x }
 func (n *node) Init() Nodes           { return n.init }
 func (n *node) SetInit(x Nodes)       { n.init = x }
 func (n *node) PtrInit() *Nodes       { return &n.init }
@@ -213,6 +212,13 @@ func (n *node) Rlist() Nodes          { return n.rlist }
 func (n *node) SetRlist(x Nodes)      { n.rlist = x }
 func (n *node) PtrRlist() *Nodes      { return &n.rlist }
 
+func (n *node) SetOp(op Op) {
+	if !okForNod[op] {
+		panic("cannot node.SetOp " + op.String())
+	}
+	n.op = op
+}
+
 func (n *node) ResetAux() {
 	n.aux = 0
 }
@@ -1109,6 +1115,10 @@ const (
 // a slice to save space.
 type Nodes struct{ slice *[]Node }
 
+// immutableEmptyNodes is an immutable, empty Nodes list.
+// The methods that would modify it panic instead.
+var immutableEmptyNodes = Nodes{}
+
 // asNodes returns a slice of *Node as a Nodes value.
 func AsNodes(s []Node) Nodes {
 	return Nodes{&s}
@@ -1150,9 +1160,22 @@ func (n Nodes) Second() Node {
 	return (*n.slice)[1]
 }
 
+func (n *Nodes) mutate() {
+	if n == &immutableEmptyNodes {
+		panic("immutable Nodes.Set")
+	}
+}
+
 // Set sets n to a slice.
 // This takes ownership of the slice.
 func (n *Nodes) Set(s []Node) {
+	if n == &immutableEmptyNodes {
+		if len(s) == 0 {
+			// Allow immutableEmptyNodes.Set(nil) (a no-op).
+			return
+		}
+		n.mutate()
+	}
 	if len(s) == 0 {
 		n.slice = nil
 	} else {
@@ -1166,21 +1189,25 @@ func (n *Nodes) Set(s []Node) {
 
 // Set1 sets n to a slice containing a single node.
 func (n *Nodes) Set1(n1 Node) {
+	n.mutate()
 	n.slice = &[]Node{n1}
 }
 
 // Set2 sets n to a slice containing two nodes.
 func (n *Nodes) Set2(n1, n2 Node) {
+	n.mutate()
 	n.slice = &[]Node{n1, n2}
 }
 
 // Set3 sets n to a slice containing three nodes.
 func (n *Nodes) Set3(n1, n2, n3 Node) {
+	n.mutate()
 	n.slice = &[]Node{n1, n2, n3}
 }
 
 // MoveNodes sets n to the contents of n2, then clears n2.
 func (n *Nodes) MoveNodes(n2 *Nodes) {
+	n.mutate()
 	n.slice = n2.slice
 	n2.slice = nil
 }
@@ -1214,6 +1241,7 @@ func (n *Nodes) Append(a ...Node) {
 	if len(a) == 0 {
 		return
 	}
+	n.mutate()
 	if n.slice == nil {
 		s := make([]Node, len(a))
 		copy(s, a)
@@ -1229,6 +1257,7 @@ func (n *Nodes) Prepend(a ...Node) {
 	if len(a) == 0 {
 		return
 	}
+	n.mutate()
 	if n.slice == nil {
 		n.slice = &a
 	} else {
@@ -1238,6 +1267,7 @@ func (n *Nodes) Prepend(a ...Node) {
 
 // AppendNodes appends the contents of *n2 to n, then clears n2.
 func (n *Nodes) AppendNodes(n2 *Nodes) {
+	n.mutate()
 	switch {
 	case n2.slice == nil:
 	case n.slice == nil:
@@ -1341,43 +1371,7 @@ func (s NodeSet) Sorted(less func(Node, Node) bool) []Node {
 	return res
 }
 
-func Nod(op Op, nleft, nright Node) Node {
-	return NodAt(base.Pos, op, nleft, nright)
-}
-
-func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
-	var n Node
-	switch op {
-	case ODCLFUNC:
-		var x struct {
-			n node
-			f Func
-		}
-		n = &x.n
-		n.SetFunc(&x.f)
-		n.Func().Decl = n
-	case ONAME:
-		base.Fatalf("use newname instead")
-	case OLABEL, OPACK:
-		var x struct {
-			n node
-			m Name
-		}
-		n = &x.n
-		n.SetName(&x.m)
-	default:
-		n = new(node)
-	}
-	n.SetOp(op)
-	n.SetLeft(nleft)
-	n.SetRight(nright)
-	n.SetPos(pos)
-	n.SetOffset(types.BADWIDTH)
-	n.SetOrig(n)
-	return n
-}
-
-// newnamel returns a new ONAME Node associated with symbol s at position pos.
+// NewNameAt returns a new ONAME Node associated with symbol s at position pos.
 // The caller is responsible for setting n.Name.Curfn.
 func NewNameAt(pos src.XPos, s *types.Sym) Node {
 	if s == nil {
@@ -1664,3 +1658,193 @@ func IsBlank(n Node) bool {
 func IsMethod(n Node) bool {
 	return n.Type().Recv() != nil
 }
+
+func Nod(op Op, nleft, nright Node) Node {
+	return NodAt(base.Pos, op, nleft, nright)
+}
+
+func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
+	var n Node
+	switch op {
+	case ODCLFUNC:
+		var x struct {
+			n node
+			f Func
+		}
+		n = &x.n
+		n.SetFunc(&x.f)
+		n.Func().Decl = n
+	case OLABEL, OPACK:
+		var x struct {
+			n node
+			m Name
+		}
+		n = &x.n
+		n.SetName(&x.m)
+	default:
+		n = new(node)
+	}
+	n.SetOp(op)
+	n.SetLeft(nleft)
+	n.SetRight(nright)
+	n.SetPos(pos)
+	n.SetOffset(types.BADWIDTH)
+	n.SetOrig(n)
+	return n
+}
+
+var okForNod = [OEND]bool{
+	OADD:           true,
+	OADDR:          true,
+	OADDSTR:        true,
+	OALIGNOF:       true,
+	OAND:           true,
+	OANDAND:        true,
+	OANDNOT:        true,
+	OAPPEND:        true,
+	OARRAYLIT:      true,
+	OAS:            true,
+	OAS2:           true,
+	OAS2DOTTYPE:    true,
+	OAS2FUNC:       true,
+	OAS2MAPR:       true,
+	OAS2RECV:       true,
+	OASOP:          true,
+	OBITNOT:        true,
+	OBLOCK:         true,
+	OBREAK:         true,
+	OBYTES2STR:     true,
+	OBYTES2STRTMP:  true,
+	OCALL:          true,
+	OCALLFUNC:      true,
+	OCALLINTER:     true,
+	OCALLMETH:      true,
+	OCALLPART:      true,
+	OCAP:           true,
+	OCASE:          true,
+	OCFUNC:         true,
+	OCHECKNIL:      true,
+	OCLOSE:         true,
+	OCLOSURE:       true,
+	OCLOSUREVAR:    true,
+	OCOMPLEX:       true,
+	OCOMPLIT:       true,
+	OCONTINUE:      true,
+	OCONV:          true,
+	OCONVIFACE:     true,
+	OCONVNOP:       true,
+	OCOPY:          true,
+	ODCL:           true,
+	ODCLCONST:      true,
+	ODCLFIELD:      true,
+	ODCLFUNC:       true,
+	ODCLTYPE:       true,
+	ODDD:           true,
+	ODEFER:         true,
+	ODELETE:        true,
+	ODEREF:         true,
+	ODIV:           true,
+	ODOT:           true,
+	ODOTINTER:      true,
+	ODOTMETH:       true,
+	ODOTPTR:        true,
+	ODOTTYPE:       true,
+	ODOTTYPE2:      true,
+	OEFACE:         true,
+	OEMPTY:         true,
+	OEQ:            true,
+	OFALL:          true,
+	OFOR:           true,
+	OFORUNTIL:      true,
+	OGE:            true,
+	OGETG:          true,
+	OGO:            true,
+	OGOTO:          true,
+	OGT:            true,
+	OIDATA:         true,
+	OIF:            true,
+	OIMAG:          true,
+	OINDEX:         true,
+	OINDEXMAP:      true,
+	OINLCALL:       true,
+	OINLMARK:       true,
+	OIOTA:          true,
+	OITAB:          true,
+	OKEY:           true,
+	OLABEL:         true,
+	OLE:            true,
+	OLEN:           true,
+	OLITERAL:       true,
+	OLSH:           true,
+	OLT:            true,
+	OMAKE:          true,
+	OMAKECHAN:      true,
+	OMAKEMAP:       true,
+	OMAKESLICE:     true,
+	OMAKESLICECOPY: true,
+	OMAPLIT:        true,
+	OMETHEXPR:      true,
+	OMOD:           true,
+	OMUL:           true,
+	ONAME:          true,
+	ONE:            true,
+	ONEG:           true,
+	ONEW:           true,
+	ONEWOBJ:        true,
+	ONIL:           true,
+	ONONAME:        true,
+	ONOT:           true,
+	OOFFSETOF:      true,
+	OOR:            true,
+	OOROR:          true,
+	OPACK:          true,
+	OPANIC:         true,
+	OPAREN:         true,
+	OPLUS:          true,
+	OPRINT:         true,
+	OPRINTN:        true,
+	OPTRLIT:        true,
+	ORANGE:         true,
+	OREAL:          true,
+	ORECOVER:       true,
+	ORECV:          true,
+	ORESULT:        true,
+	ORETJMP:        true,
+	ORETURN:        true,
+	ORSH:           true,
+	ORUNES2STR:     true,
+	ORUNESTR:       true,
+	OSELECT:        true,
+	OSELRECV:       true,
+	OSELRECV2:      true,
+	OSEND:          true,
+	OSIZEOF:        true,
+	OSLICE:         true,
+	OSLICE3:        true,
+	OSLICE3ARR:     true,
+	OSLICEARR:      true,
+	OSLICEHEADER:   true,
+	OSLICELIT:      true,
+	OSLICESTR:      true,
+	OSPTR:          true,
+	OSTR2BYTES:     true,
+	OSTR2BYTESTMP:  true,
+	OSTR2RUNES:     true,
+	OSTRUCTKEY:     true,
+	OSTRUCTLIT:     true,
+	OSUB:           true,
+	OSWITCH:        true,
+	OTARRAY:        true,
+	OTCHAN:         true,
+	OTFUNC:         true,
+	OTINTER:        true,
+	OTMAP:          true,
+	OTSTRUCT:       true,
+	OTYPE:          true,
+	OTYPESW:        true,
+	OVARDEF:        true,
+	OVARKILL:       true,
+	OVARLIVE:       true,
+	OXDOT:          true,
+	OXOR:           true,
+}
-- 
GitLab


From 171787efcd7a59c90f05a191c74bf5844f1c542a Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 28 Nov 2020 00:36:44 -0500
Subject: [PATCH 0081/2400] [dev.regabi] cmd/compile: remove Orig, SetOrig from
 Node interface

These are only needed for a few opcodes, and we can avoid
wasting storage in every implementation by using the extension
interface pattern with a helper function for access.

Of course, in the current codebase, there is only one Node
implementation (*node) and it has these methods, so there
is no danger of a functional change in this particular CL.

Passes buildall w/ toolstash -cmp.

Change-Id: I440c6c232f1fe7b56b852a00dc530f8f49a6b12d
Reviewed-on: https://go-review.googlesource.com/c/go/+/274089
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/const.go     |  4 +--
 src/cmd/compile/internal/gc/escape.go    |  2 +-
 src/cmd/compile/internal/gc/gen.go       |  2 +-
 src/cmd/compile/internal/gc/iexport.go   |  4 +--
 src/cmd/compile/internal/gc/ssa.go       |  2 +-
 src/cmd/compile/internal/gc/subr.go      |  2 +-
 src/cmd/compile/internal/gc/typecheck.go | 10 +++---
 src/cmd/compile/internal/ir/fmt.go       |  8 ++---
 src/cmd/compile/internal/ir/node.go      | 42 ++++++++++++++++++++----
 9 files changed, 52 insertions(+), 24 deletions(-)

diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 4beb85245f..3c161d8e12 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -537,7 +537,7 @@ func evalConst(n ir.Node) ir.Node {
 				}
 
 				nl := origConst(s[i], constant.MakeString(strings.Join(strs, "")))
-				nl.SetOrig(nl) // it's bigger than just s[i]
+				nl.(ir.OrigNode).SetOrig(nl) // it's bigger than just s[i]
 				newList = append(newList, nl)
 				i = i2 - 1
 			} else {
@@ -642,7 +642,7 @@ func origConst(n ir.Node, v constant.Value) ir.Node {
 
 	orig := n
 	n = ir.NodAt(orig.Pos(), ir.OLITERAL, nil, nil)
-	n.SetOrig(orig)
+	n.(ir.OrigNode).SetOrig(orig)
 	n.SetType(orig.Type())
 	n.SetVal(v)
 	return n
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 6b6fb44a99..e3ac883e95 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -1871,7 +1871,7 @@ func moveToHeap(n ir.Node) {
 	// temp will add it to the function declaration list automatically.
 	heapaddr := temp(types.NewPtr(n.Type()))
 	heapaddr.SetSym(lookup("&" + n.Sym().Name))
-	heapaddr.Orig().SetSym(heapaddr.Sym())
+	ir.Orig(heapaddr).SetSym(heapaddr.Sym())
 	heapaddr.SetPos(n.Pos())
 
 	// Unset AutoTemp to persist the &foo variable name through SSA to
diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
index 44e918f2c1..cb640c7ccf 100644
--- a/src/cmd/compile/internal/gc/gen.go
+++ b/src/cmd/compile/internal/gc/gen.go
@@ -80,7 +80,7 @@ func tempAt(pos src.XPos, curfn ir.Node, t *types.Type) ir.Node {
 
 	dowidth(t)
 
-	return n.Orig()
+	return ir.Orig(n)
 }
 
 func temp(t *types.Type) ir.Node {
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index 7c42e43bee..c2ea599af4 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -1210,8 +1210,8 @@ func (w *exportWriter) expr(n ir.Node) {
 		if !n.Type().HasNil() {
 			base.Fatalf("unexpected type for nil: %v", n.Type())
 		}
-		if n.Orig() != nil && n.Orig() != n {
-			w.expr(n.Orig())
+		if orig := ir.Orig(n); orig != nil && orig != n {
+			w.expr(orig)
 			break
 		}
 		w.op(ir.OLITERAL)
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index bcc126f82e..1a13b14376 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -6675,7 +6675,7 @@ func AddAux2(a *obj.Addr, v *ssa.Value, offset int64) {
 	case ir.Node:
 		if n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT {
 			a.Name = obj.NAME_PARAM
-			a.Sym = n.Orig().Sym().Linksym()
+			a.Sym = ir.Orig(n).Sym().Linksym()
 			a.Offset += n.Offset()
 			break
 		}
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index d174ebd582..722876abf5 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -559,7 +559,7 @@ func assignconvfn(n ir.Node, t *types.Type, context func() string) ir.Node {
 	r.SetType(t)
 	r.SetTypecheck(1)
 	r.SetImplicit(true)
-	r.SetOrig(n.Orig())
+	r.(ir.OrigNode).SetOrig(ir.Orig(n))
 	return r
 }
 
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 9da464e1b6..7037eddff0 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -851,7 +851,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			checklvalue(n.Left(), "take the address of")
 			r := outervalue(n.Left())
 			if r.Op() == ir.ONAME {
-				if r.Orig() != r {
+				if ir.Orig(r) != r {
 					base.Fatalf("found non-orig name node %v", r) // TODO(mdempsky): What does this mean?
 				}
 				r.Name().SetAddrtaken(true)
@@ -2144,8 +2144,8 @@ func typecheckargs(n ir.Node) {
 	// Rewrite f(g()) into t1, t2, ... = g(); f(t1, t2, ...).
 
 	// Save n as n.Orig for fmt.go.
-	if n.Orig() == n {
-		n.SetOrig(ir.SepCopy(n))
+	if ir.Orig(n) == n {
+		n.(ir.OrigNode).SetOrig(ir.SepCopy(n))
 	}
 
 	as := ir.Nod(ir.OAS2, nil, nil)
@@ -2245,7 +2245,7 @@ func checkdefergo(n ir.Node) {
 		ir.ONEW,
 		ir.OREAL,
 		ir.OLITERAL: // conversion or unsafe.Alignof, Offsetof, Sizeof
-		if n.Left().Orig() != nil && n.Left().Orig().Op() == ir.OCONV {
+		if orig := ir.Orig(n.Left()); orig.Op() == ir.OCONV {
 			break
 		}
 		base.ErrorfAt(n.Pos(), "%s discards result of %v", what, n.Left())
@@ -2814,7 +2814,7 @@ func typecheckcomplit(n ir.Node) (res ir.Node) {
 	}
 
 	// Save original node (including n.Right)
-	n.SetOrig(ir.Copy(n))
+	n.(ir.OrigNode).SetOrig(ir.Copy(n))
 
 	setlineno(n.Right())
 
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index f394219c05..24318d501f 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -1223,8 +1223,8 @@ func exprFmt(n Node, s fmt.State, prec int, mode FmtMode) {
 
 	case OLITERAL: // this is a bit of a mess
 		if mode == FErr {
-			if n.Orig() != nil && n.Orig() != n {
-				exprFmt(n.Orig(), s, prec, mode)
+			if orig := Orig(n); orig != nil && orig != n {
+				exprFmt(orig, s, prec, mode)
 				return
 			}
 			if n.Sym() != nil {
@@ -1561,8 +1561,8 @@ func nodeFmt(n Node, s fmt.State, flag FmtFlag, mode FmtMode) {
 
 	// We almost always want the original.
 	// TODO(gri) Why the special case for OLITERAL?
-	if n.Op() != OLITERAL && n.Orig() != nil {
-		n = n.Orig()
+	if n.Op() != OLITERAL && Orig(n) != nil {
+		n = Orig(n)
 	}
 
 	if flag&FmtLong != 0 && t != nil {
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 7a61355858..7e46673eab 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -35,8 +35,6 @@ type Node interface {
 	// Abstract graph structure, for generic traversals.
 	Op() Op
 	SetOp(x Op)
-	Orig() Node
-	SetOrig(x Node)
 	SubOp() Op
 	SetSubOp(x Op)
 	Left() Node
@@ -1616,11 +1614,41 @@ func (n *node) RawCopy() Node {
 	return &copy
 }
 
+// A Node may implement the Orig and SetOrig method to
+// maintain a pointer to the "unrewritten" form of a Node.
+// If a Node does not implement OrigNode, it is its own Orig.
+//
+// Note that both SepCopy and Copy have definitions compatible
+// with a Node that does not implement OrigNode: such a Node
+// is its own Orig, and in that case, that's what both want to return
+// anyway (SepCopy unconditionally, and Copy only when the input
+// is its own Orig as well, but if the output does not implement
+// OrigNode, then neither does the input, making the condition true).
+type OrigNode interface {
+	Node
+	Orig() Node
+	SetOrig(Node)
+}
+
+func Orig(n Node) Node {
+	if n, ok := n.(OrigNode); ok {
+		o := n.Orig()
+		if o == nil {
+			Dump("Orig nil", n)
+			base.Fatalf("Orig returned nil")
+		}
+		return o
+	}
+	return n
+}
+
 // sepcopy returns a separate shallow copy of n, with the copy's
 // Orig pointing to itself.
 func SepCopy(n Node) Node {
 	n = n.RawCopy()
-	n.SetOrig(n)
+	if n, ok := n.(OrigNode); ok {
+		n.SetOrig(n)
+	}
 	return n
 }
 
@@ -1633,8 +1661,8 @@ func SepCopy(n Node) Node {
 // messages; see issues #26855, #27765).
 func Copy(n Node) Node {
 	copy := n.RawCopy()
-	if n.Orig() == n {
-		copy.SetOrig(copy)
+	if n, ok := n.(OrigNode); ok && n.Orig() == n {
+		copy.(OrigNode).SetOrig(copy)
 	}
 	return copy
 }
@@ -1643,7 +1671,7 @@ func Copy(n Node) Node {
 func IsNil(n Node) bool {
 	// Check n.Orig because constant propagation may produce typed nil constants,
 	// which don't exist in the Go spec.
-	return n.Orig().Op() == ONIL
+	return Orig(n).Op() == ONIL
 }
 
 func IsBlank(n Node) bool {
@@ -1664,7 +1692,7 @@ func Nod(op Op, nleft, nright Node) Node {
 }
 
 func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
-	var n Node
+	var n *node
 	switch op {
 	case ODCLFUNC:
 		var x struct {
-- 
GitLab


From b09dbc69132aeee3571867cd269f5273290a2255 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 28 Nov 2020 00:54:58 -0500
Subject: [PATCH 0082/2400] [dev.regabi] cmd/compile: remove SetOp(OEMPTY)
 calls

In preparation for OEMPTY being its own Node implementation,
remove SetOp(OEMPTY) calls that assume other implementations
can be turned into OEMPTY.

Passes buildall w/ toolstash -cmp.

Change-Id: Icac16d12548f35f52a5efa9d09dacf8260f42075
Reviewed-on: https://go-review.googlesource.com/c/go/+/274090
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/sinit.go     | 5 +++--
 src/cmd/compile/internal/gc/typecheck.go | 3 +--
 src/cmd/compile/internal/gc/walk.go      | 9 ++++++---
 3 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index e30663cfbb..fca81763c0 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -959,6 +959,9 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 	}
 }
 
+// oaslit handles special composite literal assignments.
+// It returns true if n's effects have been added to init,
+// in which case n should be dropped from the program by the caller.
 func oaslit(n ir.Node, init *ir.Nodes) bool {
 	if n.Left() == nil || n.Right() == nil {
 		// not a special composite literal assignment
@@ -990,8 +993,6 @@ func oaslit(n ir.Node, init *ir.Nodes) bool {
 		anylit(n.Right(), n.Left(), init)
 	}
 
-	n.SetOp(ir.OEMPTY)
-	n.SetRight(nil)
 	return true
 }
 
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 7037eddff0..0c4a3ad833 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -1985,8 +1985,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			// Empty identifier is valid but useless.
 			// Eliminate now to simplify life later.
 			// See issues 7538, 11589, 11593.
-			n.SetOp(ir.OEMPTY)
-			n.SetLeft(nil)
+			n = ir.NodAt(n.Pos(), ir.OEMPTY, nil, nil)
 		}
 
 	case ir.ODEFER:
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index db8791ee05..87fe36b08a 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -152,10 +152,12 @@ func walkstmt(n ir.Node) ir.Node {
 		init := n.Init()
 		n.PtrInit().Set(nil)
 		n = walkexpr(n, &init)
-		n = addinit(n, init.Slice())
-		if wascopy && n.Op() == ir.OCONVNOP {
-			n.SetOp(ir.OEMPTY) // don't leave plain values as statements.
+		if wascopy && n.Op() == ir.ONAME {
+			// copy rewrote to a statement list and a temp for the length.
+			// Throw away the temp to avoid plain values as statements.
+			n = ir.NodAt(n.Pos(), ir.OEMPTY, nil, nil)
 		}
+		n = addinit(n, init.Slice())
 
 	// special case for a receive where we throw away
 	// the value received.
@@ -609,6 +611,7 @@ opswitch:
 		}
 
 		if oaslit(n, init) {
+			n = ir.NodAt(n.Pos(), ir.OEMPTY, nil, nil)
 			break
 		}
 
-- 
GitLab


From be3d8b40b5447f787174015260e85b5198e8f7e6 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 28 Nov 2020 00:43:50 -0500
Subject: [PATCH 0083/2400] [dev.regabi] cmd/compile: ir.BranchStmt, add
 ir.EmptyStmt, ir.LabelStmt

These are the first three specific implementations of Node.
They are both a bit of a warmup and also working toward
removing references to Name from Node types other than
the proper named things - ONAME, ONONAME, OTYPE, OLITERAL.
(In this case, BranchStmt and LabelStmt.)

Passes buildall w/ toolstash -cmp.

Change-Id: Ide816b162025ee4c858dd061d7c29ed633fb7baf
Reviewed-on: https://go-review.googlesource.com/c/go/+/274091
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/mini.go |  4 +-
 src/cmd/compile/internal/ir/node.go | 13 ++---
 src/cmd/compile/internal/ir/stmt.go | 83 +++++++++++++++++++++++++++++
 3 files changed, 92 insertions(+), 8 deletions(-)
 create mode 100644 src/cmd/compile/internal/ir/stmt.go

diff --git a/src/cmd/compile/internal/ir/mini.go b/src/cmd/compile/internal/ir/mini.go
index 48dccf6a5f..608c2bed81 100644
--- a/src/cmd/compile/internal/ir/mini.go
+++ b/src/cmd/compile/internal/ir/mini.go
@@ -127,7 +127,7 @@ func (n *miniNode) SubOp() Op           { panic(n.no("SubOp")) }
 func (n *miniNode) SetSubOp(Op)         { panic(n.no("SetSubOp")) }
 func (n *miniNode) Type() *types.Type   { return nil }
 func (n *miniNode) SetType(*types.Type) { panic(n.no("SetType")) }
-func (n *miniNode) Func() *Func         { panic(n.no("Func")) }
+func (n *miniNode) Func() *Func         { return nil }
 func (n *miniNode) SetFunc(*Func)       { panic(n.no("SetFunc")) }
 func (n *miniNode) Name() *Name         { return nil }
 func (n *miniNode) SetName(*Name)       { panic(n.no("SetName")) }
@@ -172,7 +172,7 @@ func (n *miniNode) Uint64Val() uint64         { panic(n.no("Uint64Val")) }
 func (n *miniNode) CanInt64() bool            { panic(n.no("CanInt64")) }
 func (n *miniNode) BoolVal() bool             { panic(n.no("BoolVal")) }
 func (n *miniNode) StringVal() string         { panic(n.no("StringVal")) }
-func (n *miniNode) HasCall() bool             { panic(n.no("HasCall")) }
+func (n *miniNode) HasCall() bool             { return false }
 func (n *miniNode) SetHasCall(bool)           { panic(n.no("SetHasCall")) }
 func (n *miniNode) NonNil() bool              { return false }
 func (n *miniNode) MarkNonNil()               { panic(n.no("MarkNonNil")) }
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 7e46673eab..cafe47493b 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -1702,13 +1702,19 @@ func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
 		n = &x.n
 		n.SetFunc(&x.f)
 		n.Func().Decl = n
-	case OLABEL, OPACK:
+	case OPACK:
 		var x struct {
 			n node
 			m Name
 		}
 		n = &x.n
 		n.SetName(&x.m)
+	case OEMPTY:
+		return NewEmptyStmt(pos)
+	case OBREAK, OCONTINUE, OFALL, OGOTO:
+		return NewBranchStmt(pos, op, nil)
+	case OLABEL:
+		return NewLabelStmt(pos, nil)
 	default:
 		n = new(node)
 	}
@@ -1740,7 +1746,6 @@ var okForNod = [OEND]bool{
 	OASOP:          true,
 	OBITNOT:        true,
 	OBLOCK:         true,
-	OBREAK:         true,
 	OBYTES2STR:     true,
 	OBYTES2STRTMP:  true,
 	OCALL:          true,
@@ -1757,7 +1762,6 @@ var okForNod = [OEND]bool{
 	OCLOSUREVAR:    true,
 	OCOMPLEX:       true,
 	OCOMPLIT:       true,
-	OCONTINUE:      true,
 	OCONV:          true,
 	OCONVIFACE:     true,
 	OCONVNOP:       true,
@@ -1779,15 +1783,12 @@ var okForNod = [OEND]bool{
 	ODOTTYPE:       true,
 	ODOTTYPE2:      true,
 	OEFACE:         true,
-	OEMPTY:         true,
 	OEQ:            true,
-	OFALL:          true,
 	OFOR:           true,
 	OFORUNTIL:      true,
 	OGE:            true,
 	OGETG:          true,
 	OGO:            true,
-	OGOTO:          true,
 	OGT:            true,
 	OIDATA:         true,
 	OIF:            true,
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
new file mode 100644
index 0000000000..5b89ff27a4
--- /dev/null
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -0,0 +1,83 @@
+// Copyright 2020 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 ir
+
+import (
+	"cmd/compile/internal/types"
+	"cmd/internal/src"
+	"fmt"
+)
+
+// A miniStmt is a miniNode with extra fields common to statements.
+type miniStmt struct {
+	miniNode
+	init Nodes
+}
+
+func (n *miniStmt) Init() Nodes       { return n.init }
+func (n *miniStmt) SetInit(x Nodes)   { n.init = x }
+func (n *miniStmt) PtrInit() *Nodes   { return &n.init }
+func (n *miniStmt) HasCall() bool     { return n.bits&miniHasCall != 0 }
+func (n *miniStmt) SetHasCall(b bool) { n.bits.set(miniHasCall, b) }
+
+// A BranchStmt is a break, continue, fallthrough, or goto statement.
+type BranchStmt struct {
+	miniStmt
+	Label *types.Sym // label if present
+}
+
+func NewBranchStmt(pos src.XPos, op Op, label *types.Sym) *BranchStmt {
+	switch op {
+	case OBREAK, OCONTINUE, OFALL, OGOTO:
+		// ok
+	default:
+		panic("NewBranch " + op.String())
+	}
+	n := &BranchStmt{Label: label}
+	n.pos = pos
+	n.op = op
+	return n
+}
+
+func (n *BranchStmt) String() string                { return fmt.Sprint(n) }
+func (n *BranchStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *BranchStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *BranchStmt) Sym() *types.Sym               { return n.Label }
+func (n *BranchStmt) SetSym(sym *types.Sym)         { n.Label = sym }
+
+// An EmptyStmt is an empty statement
+type EmptyStmt struct {
+	miniStmt
+}
+
+func NewEmptyStmt(pos src.XPos) *EmptyStmt {
+	n := &EmptyStmt{}
+	n.pos = pos
+	n.op = OEMPTY
+	return n
+}
+
+func (n *EmptyStmt) String() string                { return fmt.Sprint(n) }
+func (n *EmptyStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *EmptyStmt) RawCopy() Node                 { c := *n; return &c }
+
+// A LabelStmt is a label statement (just the label, not including the statement it labels).
+type LabelStmt struct {
+	miniStmt
+	Label *types.Sym // "Label:"
+}
+
+func NewLabelStmt(pos src.XPos, label *types.Sym) *LabelStmt {
+	n := &LabelStmt{Label: label}
+	n.pos = pos
+	n.op = OLABEL
+	return n
+}
+
+func (n *LabelStmt) String() string                { return fmt.Sprint(n) }
+func (n *LabelStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *LabelStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *LabelStmt) Sym() *types.Sym               { return n.Label }
+func (n *LabelStmt) SetSym(x *types.Sym)           { n.Label = x }
-- 
GitLab


From 420809ab08d28fbe8dbe0e8fa4159c7dc82d88ae Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 28 Nov 2020 01:03:40 -0500
Subject: [PATCH 0084/2400] [dev.regabi] cmd/compile: move name code from
 node.go to name.go

No code changes here, only copying of text.
This will make the diffs in a future CL readable.

Passes buildall w/ toolstash -cmp.

Change-Id: I1b8d8b9ec9408859e36af5ff3bef7c6c10eac0d6
Reviewed-on: https://go-review.googlesource.com/c/go/+/274092
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/name.go | 376 ++++++++++++++++++++++++++++
 src/cmd/compile/internal/ir/node.go | 364 ---------------------------
 2 files changed, 376 insertions(+), 364 deletions(-)
 create mode 100644 src/cmd/compile/internal/ir/name.go

diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
new file mode 100644
index 0000000000..fc7a5049e0
--- /dev/null
+++ b/src/cmd/compile/internal/ir/name.go
@@ -0,0 +1,376 @@
+// Copyright 2020 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 ir
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/types"
+	"cmd/internal/objabi"
+	"cmd/internal/src"
+	"go/constant"
+)
+
+// Name holds Node fields used only by named nodes (ONAME, OTYPE, OPACK, OLABEL, some OLITERAL).
+type Name struct {
+	Pack Node       // real package for import . names
+	Pkg  *types.Pkg // pkg for OPACK nodes
+	// For a local variable (not param) or extern, the initializing assignment (OAS or OAS2).
+	// For a closure var, the ONAME node of the outer captured variable
+	Defn Node
+	// The ODCLFUNC node (for a static function/method or a closure) in which
+	// local variable or param is declared.
+	Curfn     Node
+	Param     *Param // additional fields for ONAME, OTYPE
+	Decldepth int32  // declaration loop depth, increased for every loop or label
+	// Unique number for ONAME nodes within a function. Function outputs
+	// (results) are numbered starting at one, followed by function inputs
+	// (parameters), and then local variables. Vargen is used to distinguish
+	// local variables/params with the same name.
+	Vargen int32
+	flags  bitset16
+}
+
+type Param struct {
+	Ntype    Node
+	Heapaddr Node // temp holding heap address of param
+
+	// ONAME PAUTOHEAP
+	Stackcopy Node // the PPARAM/PPARAMOUT on-stack slot (moved func params only)
+
+	// ONAME closure linkage
+	// Consider:
+	//
+	//	func f() {
+	//		x := 1 // x1
+	//		func() {
+	//			use(x) // x2
+	//			func() {
+	//				use(x) // x3
+	//				--- parser is here ---
+	//			}()
+	//		}()
+	//	}
+	//
+	// There is an original declaration of x and then a chain of mentions of x
+	// leading into the current function. Each time x is mentioned in a new closure,
+	// we create a variable representing x for use in that specific closure,
+	// since the way you get to x is different in each closure.
+	//
+	// Let's number the specific variables as shown in the code:
+	// x1 is the original x, x2 is when mentioned in the closure,
+	// and x3 is when mentioned in the closure in the closure.
+	//
+	// We keep these linked (assume N > 1):
+	//
+	//   - x1.Defn = original declaration statement for x (like most variables)
+	//   - x1.Innermost = current innermost closure x (in this case x3), or nil for none
+	//   - x1.IsClosureVar() = false
+	//
+	//   - xN.Defn = x1, N > 1
+	//   - xN.IsClosureVar() = true, N > 1
+	//   - x2.Outer = nil
+	//   - xN.Outer = x(N-1), N > 2
+	//
+	//
+	// When we look up x in the symbol table, we always get x1.
+	// Then we can use x1.Innermost (if not nil) to get the x
+	// for the innermost known closure function,
+	// but the first reference in a closure will find either no x1.Innermost
+	// or an x1.Innermost with .Funcdepth < Funcdepth.
+	// In that case, a new xN must be created, linked in with:
+	//
+	//     xN.Defn = x1
+	//     xN.Outer = x1.Innermost
+	//     x1.Innermost = xN
+	//
+	// When we finish the function, we'll process its closure variables
+	// and find xN and pop it off the list using:
+	//
+	//     x1 := xN.Defn
+	//     x1.Innermost = xN.Outer
+	//
+	// We leave x1.Innermost set so that we can still get to the original
+	// variable quickly. Not shown here, but once we're
+	// done parsing a function and no longer need xN.Outer for the
+	// lexical x reference links as described above, funcLit
+	// recomputes xN.Outer as the semantic x reference link tree,
+	// even filling in x in intermediate closures that might not
+	// have mentioned it along the way to inner closures that did.
+	// See funcLit for details.
+	//
+	// During the eventual compilation, then, for closure variables we have:
+	//
+	//     xN.Defn = original variable
+	//     xN.Outer = variable captured in next outward scope
+	//                to make closure where xN appears
+	//
+	// Because of the sharding of pieces of the node, x.Defn means x.Name.Defn
+	// and x.Innermost/Outer means x.Name.Param.Innermost/Outer.
+	Innermost Node
+	Outer     Node
+
+	// OTYPE & ONAME //go:embed info,
+	// sharing storage to reduce gc.Param size.
+	// Extra is nil, or else *Extra is a *paramType or an *embedFileList.
+	Extra *interface{}
+}
+
+// NewNameAt returns a new ONAME Node associated with symbol s at position pos.
+// The caller is responsible for setting n.Name.Curfn.
+func NewNameAt(pos src.XPos, s *types.Sym) Node {
+	if s == nil {
+		base.Fatalf("newnamel nil")
+	}
+
+	var x struct {
+		n node
+		m Name
+		p Param
+	}
+	n := &x.n
+	n.SetName(&x.m)
+	n.Name().Param = &x.p
+
+	n.SetOp(ONAME)
+	n.SetPos(pos)
+	n.SetOrig(n)
+
+	n.SetSym(s)
+	return n
+}
+
+type paramType struct {
+	flag  PragmaFlag
+	alias bool
+}
+
+// Pragma returns the PragmaFlag for p, which must be for an OTYPE.
+func (p *Param) Pragma() PragmaFlag {
+	if p.Extra == nil {
+		return 0
+	}
+	return (*p.Extra).(*paramType).flag
+}
+
+// SetPragma sets the PragmaFlag for p, which must be for an OTYPE.
+func (p *Param) SetPragma(flag PragmaFlag) {
+	if p.Extra == nil {
+		if flag == 0 {
+			return
+		}
+		p.Extra = new(interface{})
+		*p.Extra = &paramType{flag: flag}
+		return
+	}
+	(*p.Extra).(*paramType).flag = flag
+}
+
+// Alias reports whether p, which must be for an OTYPE, is a type alias.
+func (p *Param) Alias() bool {
+	if p.Extra == nil {
+		return false
+	}
+	t, ok := (*p.Extra).(*paramType)
+	if !ok {
+		return false
+	}
+	return t.alias
+}
+
+// SetAlias sets whether p, which must be for an OTYPE, is a type alias.
+func (p *Param) SetAlias(alias bool) {
+	if p.Extra == nil {
+		if !alias {
+			return
+		}
+		p.Extra = new(interface{})
+		*p.Extra = &paramType{alias: alias}
+		return
+	}
+	(*p.Extra).(*paramType).alias = alias
+}
+
+type embedFileList []string
+
+// EmbedFiles returns the list of embedded files for p,
+// which must be for an ONAME var.
+func (p *Param) EmbedFiles() []string {
+	if p.Extra == nil {
+		return nil
+	}
+	return *(*p.Extra).(*embedFileList)
+}
+
+// SetEmbedFiles sets the list of embedded files for p,
+// which must be for an ONAME var.
+func (p *Param) SetEmbedFiles(list []string) {
+	if p.Extra == nil {
+		if len(list) == 0 {
+			return
+		}
+		f := embedFileList(list)
+		p.Extra = new(interface{})
+		*p.Extra = &f
+		return
+	}
+	*(*p.Extra).(*embedFileList) = list
+}
+
+const (
+	nameCaptured = 1 << iota // is the variable captured by a closure
+	nameReadonly
+	nameByval                 // is the variable captured by value or by reference
+	nameNeedzero              // if it contains pointers, needs to be zeroed on function entry
+	nameAutoTemp              // is the variable a temporary (implies no dwarf info. reset if escapes to heap)
+	nameUsed                  // for variable declared and not used error
+	nameIsClosureVar          // PAUTOHEAP closure pseudo-variable; original at n.Name.Defn
+	nameIsOutputParamHeapAddr // pointer to a result parameter's heap copy
+	nameAssigned              // is the variable ever assigned to
+	nameAddrtaken             // address taken, even if not moved to heap
+	nameInlFormal             // PAUTO created by inliner, derived from callee formal
+	nameInlLocal              // PAUTO created by inliner, derived from callee local
+	nameOpenDeferSlot         // if temporary var storing info for open-coded defers
+	nameLibfuzzerExtraCounter // if PEXTERN should be assigned to __libfuzzer_extra_counters section
+)
+
+func (n *Name) Captured() bool              { return n.flags&nameCaptured != 0 }
+func (n *Name) Readonly() bool              { return n.flags&nameReadonly != 0 }
+func (n *Name) Byval() bool                 { return n.flags&nameByval != 0 }
+func (n *Name) Needzero() bool              { return n.flags&nameNeedzero != 0 }
+func (n *Name) AutoTemp() bool              { return n.flags&nameAutoTemp != 0 }
+func (n *Name) Used() bool                  { return n.flags&nameUsed != 0 }
+func (n *Name) IsClosureVar() bool          { return n.flags&nameIsClosureVar != 0 }
+func (n *Name) IsOutputParamHeapAddr() bool { return n.flags&nameIsOutputParamHeapAddr != 0 }
+func (n *Name) Assigned() bool              { return n.flags&nameAssigned != 0 }
+func (n *Name) Addrtaken() bool             { return n.flags&nameAddrtaken != 0 }
+func (n *Name) InlFormal() bool             { return n.flags&nameInlFormal != 0 }
+func (n *Name) InlLocal() bool              { return n.flags&nameInlLocal != 0 }
+func (n *Name) OpenDeferSlot() bool         { return n.flags&nameOpenDeferSlot != 0 }
+func (n *Name) LibfuzzerExtraCounter() bool { return n.flags&nameLibfuzzerExtraCounter != 0 }
+
+func (n *Name) SetCaptured(b bool)              { n.flags.set(nameCaptured, b) }
+func (n *Name) SetReadonly(b bool)              { n.flags.set(nameReadonly, b) }
+func (n *Name) SetByval(b bool)                 { n.flags.set(nameByval, b) }
+func (n *Name) SetNeedzero(b bool)              { n.flags.set(nameNeedzero, b) }
+func (n *Name) SetAutoTemp(b bool)              { n.flags.set(nameAutoTemp, b) }
+func (n *Name) SetUsed(b bool)                  { n.flags.set(nameUsed, b) }
+func (n *Name) SetIsClosureVar(b bool)          { n.flags.set(nameIsClosureVar, b) }
+func (n *Name) SetIsOutputParamHeapAddr(b bool) { n.flags.set(nameIsOutputParamHeapAddr, b) }
+func (n *Name) SetAssigned(b bool)              { n.flags.set(nameAssigned, b) }
+func (n *Name) SetAddrtaken(b bool)             { n.flags.set(nameAddrtaken, b) }
+func (n *Name) SetInlFormal(b bool)             { n.flags.set(nameInlFormal, b) }
+func (n *Name) SetInlLocal(b bool)              { n.flags.set(nameInlLocal, b) }
+func (n *Name) SetOpenDeferSlot(b bool)         { n.flags.set(nameOpenDeferSlot, b) }
+func (n *Name) SetLibfuzzerExtraCounter(b bool) { n.flags.set(nameLibfuzzerExtraCounter, b) }
+
+// MarkReadonly indicates that n is an ONAME with readonly contents.
+func (n *node) MarkReadonly() {
+	if n.Op() != ONAME {
+		base.Fatalf("Node.MarkReadonly %v", n.Op())
+	}
+	n.Name().SetReadonly(true)
+	// Mark the linksym as readonly immediately
+	// so that the SSA backend can use this information.
+	// It will be overridden later during dumpglobls.
+	n.Sym().Linksym().Type = objabi.SRODATA
+}
+
+// Val returns the constant.Value for the node.
+func (n *node) Val() constant.Value {
+	if !n.HasVal() {
+		return constant.MakeUnknown()
+	}
+	return *n.e.(*constant.Value)
+}
+
+// SetVal sets the constant.Value for the node,
+// which must not have been used with SetOpt.
+func (n *node) SetVal(v constant.Value) {
+	if n.hasOpt() {
+		base.Flag.LowerH = 1
+		Dump("have Opt", n)
+		base.Fatalf("have Opt")
+	}
+	if n.Op() == OLITERAL {
+		AssertValidTypeForConst(n.Type(), v)
+	}
+	n.setHasVal(true)
+	n.e = &v
+}
+
+// Int64Val returns n as an int64.
+// n must be an integer or rune constant.
+func (n *node) Int64Val() int64 {
+	if !IsConst(n, constant.Int) {
+		base.Fatalf("Int64Val(%v)", n)
+	}
+	x, ok := constant.Int64Val(n.Val())
+	if !ok {
+		base.Fatalf("Int64Val(%v)", n)
+	}
+	return x
+}
+
+// CanInt64 reports whether it is safe to call Int64Val() on n.
+func (n *node) CanInt64() bool {
+	if !IsConst(n, constant.Int) {
+		return false
+	}
+
+	// if the value inside n cannot be represented as an int64, the
+	// return value of Int64 is undefined
+	_, ok := constant.Int64Val(n.Val())
+	return ok
+}
+
+// Uint64Val returns n as an uint64.
+// n must be an integer or rune constant.
+func (n *node) Uint64Val() uint64 {
+	if !IsConst(n, constant.Int) {
+		base.Fatalf("Uint64Val(%v)", n)
+	}
+	x, ok := constant.Uint64Val(n.Val())
+	if !ok {
+		base.Fatalf("Uint64Val(%v)", n)
+	}
+	return x
+}
+
+// BoolVal returns n as a bool.
+// n must be a boolean constant.
+func (n *node) BoolVal() bool {
+	if !IsConst(n, constant.Bool) {
+		base.Fatalf("BoolVal(%v)", n)
+	}
+	return constant.BoolVal(n.Val())
+}
+
+// StringVal returns the value of a literal string Node as a string.
+// n must be a string constant.
+func (n *node) StringVal() string {
+	if !IsConst(n, constant.String) {
+		base.Fatalf("StringVal(%v)", n)
+	}
+	return constant.StringVal(n.Val())
+}
+
+// The Class of a variable/function describes the "storage class"
+// of a variable or function. During parsing, storage classes are
+// called declaration contexts.
+type Class uint8
+
+//go:generate stringer -type=Class
+const (
+	Pxxx      Class = iota // no class; used during ssa conversion to indicate pseudo-variables
+	PEXTERN                // global variables
+	PAUTO                  // local variables
+	PAUTOHEAP              // local variables or parameters moved to heap
+	PPARAM                 // input arguments
+	PPARAMOUT              // output results
+	PFUNC                  // global functions
+
+	// Careful: Class is stored in three bits in Node.flags.
+	_ = uint((1 << 3) - iota) // static assert for iota <= (1 << 3)
+)
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index cafe47493b..079871879d 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -15,7 +15,6 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
-	"cmd/internal/objabi"
 	"cmd/internal/src"
 )
 
@@ -379,41 +378,6 @@ func (n *node) SetBounded(b bool) {
 	n.flags.set(nodeBounded, b)
 }
 
-// MarkReadonly indicates that n is an ONAME with readonly contents.
-func (n *node) MarkReadonly() {
-	if n.Op() != ONAME {
-		base.Fatalf("Node.MarkReadonly %v", n.Op())
-	}
-	n.Name().SetReadonly(true)
-	// Mark the linksym as readonly immediately
-	// so that the SSA backend can use this information.
-	// It will be overridden later during dumpglobls.
-	n.Sym().Linksym().Type = objabi.SRODATA
-}
-
-// Val returns the constant.Value for the node.
-func (n *node) Val() constant.Value {
-	if !n.HasVal() {
-		return constant.MakeUnknown()
-	}
-	return *n.e.(*constant.Value)
-}
-
-// SetVal sets the constant.Value for the node,
-// which must not have been used with SetOpt.
-func (n *node) SetVal(v constant.Value) {
-	if n.hasOpt() {
-		base.Flag.LowerH = 1
-		Dump("have Opt", n)
-		base.Fatalf("have Opt")
-	}
-	if n.Op() == OLITERAL {
-		AssertValidTypeForConst(n.Type(), v)
-	}
-	n.setHasVal(true)
-	n.e = &v
-}
-
 // Opt returns the optimizer data for the node.
 func (n *node) Opt() interface{} {
 	if !n.hasOpt() {
@@ -500,235 +464,6 @@ func PkgFuncName(n Node) string {
 func (n *node) CanBeAnSSASym() {
 }
 
-// Name holds Node fields used only by named nodes (ONAME, OTYPE, OPACK, OLABEL, some OLITERAL).
-type Name struct {
-	Pack Node       // real package for import . names
-	Pkg  *types.Pkg // pkg for OPACK nodes
-	// For a local variable (not param) or extern, the initializing assignment (OAS or OAS2).
-	// For a closure var, the ONAME node of the outer captured variable
-	Defn Node
-	// The ODCLFUNC node (for a static function/method or a closure) in which
-	// local variable or param is declared.
-	Curfn     Node
-	Param     *Param // additional fields for ONAME, OTYPE
-	Decldepth int32  // declaration loop depth, increased for every loop or label
-	// Unique number for ONAME nodes within a function. Function outputs
-	// (results) are numbered starting at one, followed by function inputs
-	// (parameters), and then local variables. Vargen is used to distinguish
-	// local variables/params with the same name.
-	Vargen int32
-	flags  bitset16
-}
-
-const (
-	nameCaptured = 1 << iota // is the variable captured by a closure
-	nameReadonly
-	nameByval                 // is the variable captured by value or by reference
-	nameNeedzero              // if it contains pointers, needs to be zeroed on function entry
-	nameAutoTemp              // is the variable a temporary (implies no dwarf info. reset if escapes to heap)
-	nameUsed                  // for variable declared and not used error
-	nameIsClosureVar          // PAUTOHEAP closure pseudo-variable; original at n.Name.Defn
-	nameIsOutputParamHeapAddr // pointer to a result parameter's heap copy
-	nameAssigned              // is the variable ever assigned to
-	nameAddrtaken             // address taken, even if not moved to heap
-	nameInlFormal             // PAUTO created by inliner, derived from callee formal
-	nameInlLocal              // PAUTO created by inliner, derived from callee local
-	nameOpenDeferSlot         // if temporary var storing info for open-coded defers
-	nameLibfuzzerExtraCounter // if PEXTERN should be assigned to __libfuzzer_extra_counters section
-)
-
-func (n *Name) Captured() bool              { return n.flags&nameCaptured != 0 }
-func (n *Name) Readonly() bool              { return n.flags&nameReadonly != 0 }
-func (n *Name) Byval() bool                 { return n.flags&nameByval != 0 }
-func (n *Name) Needzero() bool              { return n.flags&nameNeedzero != 0 }
-func (n *Name) AutoTemp() bool              { return n.flags&nameAutoTemp != 0 }
-func (n *Name) Used() bool                  { return n.flags&nameUsed != 0 }
-func (n *Name) IsClosureVar() bool          { return n.flags&nameIsClosureVar != 0 }
-func (n *Name) IsOutputParamHeapAddr() bool { return n.flags&nameIsOutputParamHeapAddr != 0 }
-func (n *Name) Assigned() bool              { return n.flags&nameAssigned != 0 }
-func (n *Name) Addrtaken() bool             { return n.flags&nameAddrtaken != 0 }
-func (n *Name) InlFormal() bool             { return n.flags&nameInlFormal != 0 }
-func (n *Name) InlLocal() bool              { return n.flags&nameInlLocal != 0 }
-func (n *Name) OpenDeferSlot() bool         { return n.flags&nameOpenDeferSlot != 0 }
-func (n *Name) LibfuzzerExtraCounter() bool { return n.flags&nameLibfuzzerExtraCounter != 0 }
-
-func (n *Name) SetCaptured(b bool)              { n.flags.set(nameCaptured, b) }
-func (n *Name) SetReadonly(b bool)              { n.flags.set(nameReadonly, b) }
-func (n *Name) SetByval(b bool)                 { n.flags.set(nameByval, b) }
-func (n *Name) SetNeedzero(b bool)              { n.flags.set(nameNeedzero, b) }
-func (n *Name) SetAutoTemp(b bool)              { n.flags.set(nameAutoTemp, b) }
-func (n *Name) SetUsed(b bool)                  { n.flags.set(nameUsed, b) }
-func (n *Name) SetIsClosureVar(b bool)          { n.flags.set(nameIsClosureVar, b) }
-func (n *Name) SetIsOutputParamHeapAddr(b bool) { n.flags.set(nameIsOutputParamHeapAddr, b) }
-func (n *Name) SetAssigned(b bool)              { n.flags.set(nameAssigned, b) }
-func (n *Name) SetAddrtaken(b bool)             { n.flags.set(nameAddrtaken, b) }
-func (n *Name) SetInlFormal(b bool)             { n.flags.set(nameInlFormal, b) }
-func (n *Name) SetInlLocal(b bool)              { n.flags.set(nameInlLocal, b) }
-func (n *Name) SetOpenDeferSlot(b bool)         { n.flags.set(nameOpenDeferSlot, b) }
-func (n *Name) SetLibfuzzerExtraCounter(b bool) { n.flags.set(nameLibfuzzerExtraCounter, b) }
-
-type Param struct {
-	Ntype    Node
-	Heapaddr Node // temp holding heap address of param
-
-	// ONAME PAUTOHEAP
-	Stackcopy Node // the PPARAM/PPARAMOUT on-stack slot (moved func params only)
-
-	// ONAME closure linkage
-	// Consider:
-	//
-	//	func f() {
-	//		x := 1 // x1
-	//		func() {
-	//			use(x) // x2
-	//			func() {
-	//				use(x) // x3
-	//				--- parser is here ---
-	//			}()
-	//		}()
-	//	}
-	//
-	// There is an original declaration of x and then a chain of mentions of x
-	// leading into the current function. Each time x is mentioned in a new closure,
-	// we create a variable representing x for use in that specific closure,
-	// since the way you get to x is different in each closure.
-	//
-	// Let's number the specific variables as shown in the code:
-	// x1 is the original x, x2 is when mentioned in the closure,
-	// and x3 is when mentioned in the closure in the closure.
-	//
-	// We keep these linked (assume N > 1):
-	//
-	//   - x1.Defn = original declaration statement for x (like most variables)
-	//   - x1.Innermost = current innermost closure x (in this case x3), or nil for none
-	//   - x1.IsClosureVar() = false
-	//
-	//   - xN.Defn = x1, N > 1
-	//   - xN.IsClosureVar() = true, N > 1
-	//   - x2.Outer = nil
-	//   - xN.Outer = x(N-1), N > 2
-	//
-	//
-	// When we look up x in the symbol table, we always get x1.
-	// Then we can use x1.Innermost (if not nil) to get the x
-	// for the innermost known closure function,
-	// but the first reference in a closure will find either no x1.Innermost
-	// or an x1.Innermost with .Funcdepth < Funcdepth.
-	// In that case, a new xN must be created, linked in with:
-	//
-	//     xN.Defn = x1
-	//     xN.Outer = x1.Innermost
-	//     x1.Innermost = xN
-	//
-	// When we finish the function, we'll process its closure variables
-	// and find xN and pop it off the list using:
-	//
-	//     x1 := xN.Defn
-	//     x1.Innermost = xN.Outer
-	//
-	// We leave x1.Innermost set so that we can still get to the original
-	// variable quickly. Not shown here, but once we're
-	// done parsing a function and no longer need xN.Outer for the
-	// lexical x reference links as described above, funcLit
-	// recomputes xN.Outer as the semantic x reference link tree,
-	// even filling in x in intermediate closures that might not
-	// have mentioned it along the way to inner closures that did.
-	// See funcLit for details.
-	//
-	// During the eventual compilation, then, for closure variables we have:
-	//
-	//     xN.Defn = original variable
-	//     xN.Outer = variable captured in next outward scope
-	//                to make closure where xN appears
-	//
-	// Because of the sharding of pieces of the node, x.Defn means x.Name.Defn
-	// and x.Innermost/Outer means x.Name.Param.Innermost/Outer.
-	Innermost Node
-	Outer     Node
-
-	// OTYPE & ONAME //go:embed info,
-	// sharing storage to reduce gc.Param size.
-	// Extra is nil, or else *Extra is a *paramType or an *embedFileList.
-	Extra *interface{}
-}
-
-type paramType struct {
-	flag  PragmaFlag
-	alias bool
-}
-
-type embedFileList []string
-
-// Pragma returns the PragmaFlag for p, which must be for an OTYPE.
-func (p *Param) Pragma() PragmaFlag {
-	if p.Extra == nil {
-		return 0
-	}
-	return (*p.Extra).(*paramType).flag
-}
-
-// SetPragma sets the PragmaFlag for p, which must be for an OTYPE.
-func (p *Param) SetPragma(flag PragmaFlag) {
-	if p.Extra == nil {
-		if flag == 0 {
-			return
-		}
-		p.Extra = new(interface{})
-		*p.Extra = &paramType{flag: flag}
-		return
-	}
-	(*p.Extra).(*paramType).flag = flag
-}
-
-// Alias reports whether p, which must be for an OTYPE, is a type alias.
-func (p *Param) Alias() bool {
-	if p.Extra == nil {
-		return false
-	}
-	t, ok := (*p.Extra).(*paramType)
-	if !ok {
-		return false
-	}
-	return t.alias
-}
-
-// SetAlias sets whether p, which must be for an OTYPE, is a type alias.
-func (p *Param) SetAlias(alias bool) {
-	if p.Extra == nil {
-		if !alias {
-			return
-		}
-		p.Extra = new(interface{})
-		*p.Extra = &paramType{alias: alias}
-		return
-	}
-	(*p.Extra).(*paramType).alias = alias
-}
-
-// EmbedFiles returns the list of embedded files for p,
-// which must be for an ONAME var.
-func (p *Param) EmbedFiles() []string {
-	if p.Extra == nil {
-		return nil
-	}
-	return *(*p.Extra).(*embedFileList)
-}
-
-// SetEmbedFiles sets the list of embedded files for p,
-// which must be for an ONAME var.
-func (p *Param) SetEmbedFiles(list []string) {
-	if p.Extra == nil {
-		if len(list) == 0 {
-			return
-		}
-		f := embedFileList(list)
-		p.Extra = new(interface{})
-		*p.Extra = &f
-		return
-	}
-	*(*p.Extra).(*embedFileList) = list
-}
-
 // A Func corresponds to a single function in a Go program
 // (and vice versa: each function is denoted by exactly one *Func).
 //
@@ -1369,49 +1104,6 @@ func (s NodeSet) Sorted(less func(Node, Node) bool) []Node {
 	return res
 }
 
-// NewNameAt returns a new ONAME Node associated with symbol s at position pos.
-// The caller is responsible for setting n.Name.Curfn.
-func NewNameAt(pos src.XPos, s *types.Sym) Node {
-	if s == nil {
-		base.Fatalf("newnamel nil")
-	}
-
-	var x struct {
-		n node
-		m Name
-		p Param
-	}
-	n := &x.n
-	n.SetName(&x.m)
-	n.Name().Param = &x.p
-
-	n.SetOp(ONAME)
-	n.SetPos(pos)
-	n.SetOrig(n)
-
-	n.SetSym(s)
-	return n
-}
-
-// The Class of a variable/function describes the "storage class"
-// of a variable or function. During parsing, storage classes are
-// called declaration contexts.
-type Class uint8
-
-//go:generate stringer -type=Class
-const (
-	Pxxx      Class = iota // no class; used during ssa conversion to indicate pseudo-variables
-	PEXTERN                // global variables
-	PAUTO                  // local variables
-	PAUTOHEAP              // local variables or parameters moved to heap
-	PPARAM                 // input arguments
-	PPARAMOUT              // output results
-	PFUNC                  // global functions
-
-	// Careful: Class is stored in three bits in Node.flags.
-	_ = uint((1 << 3) - iota) // static assert for iota <= (1 << 3)
-)
-
 type PragmaFlag int16
 
 const (
@@ -1550,62 +1242,6 @@ func IsConst(n Node, ct constant.Kind) bool {
 	return ConstType(n) == ct
 }
 
-// Int64Val returns n as an int64.
-// n must be an integer or rune constant.
-func (n *node) Int64Val() int64 {
-	if !IsConst(n, constant.Int) {
-		base.Fatalf("Int64Val(%v)", n)
-	}
-	x, ok := constant.Int64Val(n.Val())
-	if !ok {
-		base.Fatalf("Int64Val(%v)", n)
-	}
-	return x
-}
-
-// CanInt64 reports whether it is safe to call Int64Val() on n.
-func (n *node) CanInt64() bool {
-	if !IsConst(n, constant.Int) {
-		return false
-	}
-
-	// if the value inside n cannot be represented as an int64, the
-	// return value of Int64 is undefined
-	_, ok := constant.Int64Val(n.Val())
-	return ok
-}
-
-// Uint64Val returns n as an uint64.
-// n must be an integer or rune constant.
-func (n *node) Uint64Val() uint64 {
-	if !IsConst(n, constant.Int) {
-		base.Fatalf("Uint64Val(%v)", n)
-	}
-	x, ok := constant.Uint64Val(n.Val())
-	if !ok {
-		base.Fatalf("Uint64Val(%v)", n)
-	}
-	return x
-}
-
-// BoolVal returns n as a bool.
-// n must be a boolean constant.
-func (n *node) BoolVal() bool {
-	if !IsConst(n, constant.Bool) {
-		base.Fatalf("BoolVal(%v)", n)
-	}
-	return constant.BoolVal(n.Val())
-}
-
-// StringVal returns the value of a literal string Node as a string.
-// n must be a string constant.
-func (n *node) StringVal() string {
-	if !IsConst(n, constant.String) {
-		base.Fatalf("StringVal(%v)", n)
-	}
-	return constant.StringVal(n.Val())
-}
-
 // rawcopy returns a shallow copy of n.
 // Note: copy or sepcopy (rather than rawcopy) is usually the
 //       correct choice (see comment with Node.copy, below).
-- 
GitLab


From f6106d195db8bd7ef268e621f4a0d9ddbe9c58f6 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 28 Nov 2020 01:11:49 -0500
Subject: [PATCH 0085/2400] [dev.regabi] cmd/compile: add ir.PkgName

OPACK was using a whole Node and Name and Param
to hold about three fields. Give it its own implementation.

Passes buildall w/ toolstash -cmp.

Change-Id: I85a28b43d37183b2062d337b0b1b2eea52884e8c
Reviewed-on: https://go-review.googlesource.com/c/go/+/274093
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/main.go        | 11 ++++-----
 src/cmd/compile/internal/gc/noder.go       | 22 +++++++++---------
 src/cmd/compile/internal/gc/subr.go        |  4 ++--
 src/cmd/compile/internal/ir/name.go        | 26 +++++++++++++++++++---
 src/cmd/compile/internal/ir/node.go        |  8 +------
 src/cmd/compile/internal/ir/sizeof_test.go |  2 +-
 6 files changed, 44 insertions(+), 29 deletions(-)

diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 30ee57c02d..7d2933f360 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -955,8 +955,9 @@ func clearImports() {
 			// leave s->block set to cause redeclaration
 			// errors if a conflicting top-level name is
 			// introduced by a different file.
-			if !n.Name().Used() && base.SyntaxErrors() == 0 {
-				unused = append(unused, importedPkg{n.Pos(), n.Name().Pkg.Path, s.Name})
+			p := n.(*ir.PkgName)
+			if !p.Used && base.SyntaxErrors() == 0 {
+				unused = append(unused, importedPkg{p.Pos(), p.Pkg.Path, s.Name})
 			}
 			s.Def = nil
 			continue
@@ -964,9 +965,9 @@ func clearImports() {
 		if IsAlias(s) {
 			// throw away top-level name left over
 			// from previous import . "x"
-			if n.Name() != nil && n.Name().Pack != nil && !n.Name().Pack.Name().Used() && base.SyntaxErrors() == 0 {
-				unused = append(unused, importedPkg{n.Name().Pack.Pos(), n.Name().Pack.Name().Pkg.Path, ""})
-				n.Name().Pack.Name().SetUsed(true)
+			if name := n.Name(); name != nil && name.PkgName != nil && !name.PkgName.Used && base.SyntaxErrors() == 0 {
+				unused = append(unused, importedPkg{name.PkgName.Pos(), name.PkgName.Pkg.Path, ""})
+				name.PkgName.Used = true
 			}
 			s.Def = nil
 			continue
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index ecd50b87f6..54915d7693 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -356,9 +356,7 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
 		my = lookup(ipkg.Name)
 	}
 
-	pack := p.nod(imp, ir.OPACK, nil, nil)
-	pack.SetSym(my)
-	pack.Name().Pkg = ipkg
+	pack := ir.NewPkgName(p.pos(imp), my, ipkg)
 
 	switch my.Name {
 	case ".":
@@ -685,8 +683,9 @@ func (p *noder) expr(expr syntax.Expr) ir.Node {
 		// parser.new_dotname
 		obj := p.expr(expr.X)
 		if obj.Op() == ir.OPACK {
-			obj.Name().SetUsed(true)
-			return importName(obj.Name().Pkg.Lookup(expr.Sel.Value))
+			pack := obj.(*ir.PkgName)
+			pack.Used = true
+			return importName(pack.Pkg.Lookup(expr.Sel.Value))
 		}
 		n := nodSym(ir.OXDOT, obj, p.name(expr.Sel))
 		n.SetPos(p.pos(expr)) // lineno may have been changed by p.expr(expr.X)
@@ -910,8 +909,8 @@ func (p *noder) packname(expr syntax.Expr) *types.Sym {
 	switch expr := expr.(type) {
 	case *syntax.Name:
 		name := p.name(expr)
-		if n := oldname(name); n.Name() != nil && n.Name().Pack != nil {
-			n.Name().Pack.Name().SetUsed(true)
+		if n := oldname(name); n.Name() != nil && n.Name().PkgName != nil {
+			n.Name().PkgName.Used = true
 		}
 		return name
 	case *syntax.SelectorExpr:
@@ -926,8 +925,9 @@ func (p *noder) packname(expr syntax.Expr) *types.Sym {
 			base.Errorf("%v is not a package", name)
 			pkg = ir.LocalPkg
 		} else {
-			def.Name().SetUsed(true)
-			pkg = def.Name().Pkg
+			def := def.(*ir.PkgName)
+			def.Used = true
+			pkg = def.Pkg
 		}
 		return pkg.Lookup(expr.Sel.Value)
 	}
@@ -1675,8 +1675,8 @@ func safeArg(name string) bool {
 
 func mkname(sym *types.Sym) ir.Node {
 	n := oldname(sym)
-	if n.Name() != nil && n.Name().Pack != nil {
-		n.Name().Pack.Name().SetUsed(true)
+	if n.Name() != nil && n.Name().PkgName != nil {
+		n.Name().PkgName.Used = true
 	}
 	return n
 }
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 722876abf5..5c410ce3ba 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -102,7 +102,7 @@ func autolabel(prefix string) *types.Sym {
 
 // find all the exported symbols in package opkg
 // and make them available in the current package
-func importdot(opkg *types.Pkg, pack ir.Node) {
+func importdot(opkg *types.Pkg, pack *ir.PkgName) {
 	n := 0
 	for _, s := range opkg.Syms {
 		if s.Def == nil {
@@ -124,7 +124,7 @@ func importdot(opkg *types.Pkg, pack ir.Node) {
 			ir.Dump("s1def", ir.AsNode(s1.Def))
 			base.Fatalf("missing Name")
 		}
-		ir.AsNode(s1.Def).Name().Pack = pack
+		ir.AsNode(s1.Def).Name().PkgName = pack
 		s1.Origpkg = opkg
 		n++
 	}
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index fc7a5049e0..64d5d2a2ed 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -9,13 +9,13 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/objabi"
 	"cmd/internal/src"
+	"fmt"
 	"go/constant"
 )
 
-// Name holds Node fields used only by named nodes (ONAME, OTYPE, OPACK, OLABEL, some OLITERAL).
+// Name holds Node fields used only by named nodes (ONAME, OTYPE, some OLITERAL).
 type Name struct {
-	Pack Node       // real package for import . names
-	Pkg  *types.Pkg // pkg for OPACK nodes
+	PkgName *PkgName // real package for import . names
 	// For a local variable (not param) or extern, the initializing assignment (OAS or OAS2).
 	// For a closure var, the ONAME node of the outer captured variable
 	Defn Node
@@ -374,3 +374,23 @@ const (
 	// Careful: Class is stored in three bits in Node.flags.
 	_ = uint((1 << 3) - iota) // static assert for iota <= (1 << 3)
 )
+
+// A Pack is an identifier referring to an imported package.
+type PkgName struct {
+	miniNode
+	sym  *types.Sym
+	Pkg  *types.Pkg
+	Used bool
+}
+
+func (p *PkgName) String() string                { return fmt.Sprint(p) }
+func (p *PkgName) Format(s fmt.State, verb rune) { FmtNode(p, s, verb) }
+func (p *PkgName) RawCopy() Node                 { c := *p; return &c }
+func (p *PkgName) Sym() *types.Sym               { return p.sym }
+
+func NewPkgName(pos src.XPos, sym *types.Sym, pkg *types.Pkg) *PkgName {
+	p := &PkgName{sym: sym, Pkg: pkg}
+	p.op = OPACK
+	p.pos = pos
+	return p
+}
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 079871879d..0023df97a8 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -1339,12 +1339,7 @@ func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
 		n.SetFunc(&x.f)
 		n.Func().Decl = n
 	case OPACK:
-		var x struct {
-			n node
-			m Name
-		}
-		n = &x.n
-		n.SetName(&x.m)
+		return NewPkgName(pos, nil, nil)
 	case OEMPTY:
 		return NewEmptyStmt(pos)
 	case OBREAK, OCONTINUE, OFALL, OGOTO:
@@ -1462,7 +1457,6 @@ var okForNod = [OEND]bool{
 	OOFFSETOF:      true,
 	OOR:            true,
 	OOROR:          true,
-	OPACK:          true,
 	OPANIC:         true,
 	OPAREN:         true,
 	OPLUS:          true,
diff --git a/src/cmd/compile/internal/ir/sizeof_test.go b/src/cmd/compile/internal/ir/sizeof_test.go
index 0a9542fa44..a025cb5986 100644
--- a/src/cmd/compile/internal/ir/sizeof_test.go
+++ b/src/cmd/compile/internal/ir/sizeof_test.go
@@ -21,7 +21,7 @@ func TestSizeof(t *testing.T) {
 		_64bit uintptr     // size on 64bit platforms
 	}{
 		{Func{}, 152, 280},
-		{Name{}, 44, 80},
+		{Name{}, 36, 64},
 		{Param{}, 44, 88},
 		{node{}, 88, 152},
 	}
-- 
GitLab


From 862f638a89c5ec721a53446fb1a74f9ad15893d5 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 28 Nov 2020 01:41:13 -0500
Subject: [PATCH 0086/2400] [dev.regabi] cmd/compile: make ir.Name the ONAME
 Node implementation

Before this CL, an ONAME Node was represented by three structs
linked together: a node, a Name, and a Param. Previous CLs removed
OLABEL and OPACK from the set of nodes that knew about Name.
Now Name can be repurposed to *be* the ONAME Node implementation,
replacing three linked structs totaling 152+64+88 = 304 bytes (64-bit)
with a single 232-byte struct.

Many expressions in the code become simpler as well, without having
to use .Param. and sometimes even .Name().
(For a node n where n.Name() != nil, n.Name() == n.(*Name) now.)

Passes buildall w/ toolstash -cmp.

Change-Id: Ie719f1285c05623b9fd2faaa059e5b360a64b3be
Reviewed-on: https://go-review.googlesource.com/c/go/+/274094
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/fmtmap_test.go             |   1 +
 src/cmd/compile/internal/gc/alg.go         |   2 +-
 src/cmd/compile/internal/gc/align.go       |  10 +-
 src/cmd/compile/internal/gc/closure.go     |  13 +-
 src/cmd/compile/internal/gc/dcl.go         |  39 ++--
 src/cmd/compile/internal/gc/embed.go       |   6 +-
 src/cmd/compile/internal/gc/escape.go      |   6 +-
 src/cmd/compile/internal/gc/gen.go         |  10 +-
 src/cmd/compile/internal/gc/iexport.go     |   2 +-
 src/cmd/compile/internal/gc/inl.go         |   2 +-
 src/cmd/compile/internal/gc/main.go        |   4 +-
 src/cmd/compile/internal/gc/noder.go       |  17 +-
 src/cmd/compile/internal/gc/pgen.go        |   2 +-
 src/cmd/compile/internal/gc/plive.go       |   2 +-
 src/cmd/compile/internal/gc/subr.go        |   2 +-
 src/cmd/compile/internal/gc/typecheck.go   |  52 +++---
 src/cmd/compile/internal/gc/universe.go    |   9 -
 src/cmd/compile/internal/gc/walk.go        |  24 +--
 src/cmd/compile/internal/ir/expr.go        |  47 +++++
 src/cmd/compile/internal/ir/fmt.go         |   8 +-
 src/cmd/compile/internal/ir/mini.go        |   2 -
 src/cmd/compile/internal/ir/name.go        | 200 ++++++++++-----------
 src/cmd/compile/internal/ir/node.go        |  56 ++----
 src/cmd/compile/internal/ir/sizeof_test.go |   5 +-
 24 files changed, 256 insertions(+), 265 deletions(-)
 create mode 100644 src/cmd/compile/internal/ir/expr.go

diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
index 7a375604fd..978c83e5c2 100644
--- a/src/cmd/compile/fmtmap_test.go
+++ b/src/cmd/compile/fmtmap_test.go
@@ -22,6 +22,7 @@ package main_test
 var knownFormats = map[string]string{
 	"*bytes.Buffer %s":                                "",
 	"*cmd/compile/internal/gc.EscLocation %v":         "",
+	"*cmd/compile/internal/ir.Name %v":                "",
 	"*cmd/compile/internal/ir.node %v":                "",
 	"*cmd/compile/internal/ssa.Block %s":              "",
 	"*cmd/compile/internal/ssa.Block %v":              "",
diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index d2762126ad..356f0eada7 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -311,7 +311,7 @@ func genhash(t *types.Type) *obj.LSym {
 		hashel := hashfor(t.Elem())
 
 		n := ir.Nod(ir.ORANGE, nil, ir.Nod(ir.ODEREF, np, nil))
-		ni := NewName(lookup("i"))
+		ni := ir.Node(NewName(lookup("i")))
 		ni.SetType(types.Types[types.TINT])
 		n.PtrList().Set1(ni)
 		n.SetColas(true)
diff --git a/src/cmd/compile/internal/gc/align.go b/src/cmd/compile/internal/gc/align.go
index edf7d263a3..4f8f04d73d 100644
--- a/src/cmd/compile/internal/gc/align.go
+++ b/src/cmd/compile/internal/gc/align.go
@@ -126,8 +126,8 @@ func widstruct(errtype *types.Type, t *types.Type, o int64, flag int) int64 {
 			// NOTE(rsc): This comment may be stale.
 			// It's possible the ordering has changed and this is
 			// now the common case. I'm not sure.
-			if n.Name().Param.Stackcopy != nil {
-				n.Name().Param.Stackcopy.SetOffset(o)
+			if n.Name().Stackcopy != nil {
+				n.Name().Stackcopy.SetOffset(o)
 				n.SetOffset(0)
 			} else {
 				n.SetOffset(o)
@@ -198,8 +198,10 @@ func findTypeLoop(t *types.Type, path *[]*types.Type) bool {
 		}
 
 		*path = append(*path, t)
-		if p := ir.AsNode(t.Nod).Name().Param; p != nil && findTypeLoop(p.Ntype.Type(), path) {
-			return true
+		if n := ir.AsNode(t.Nod); n != nil {
+			if name := n.Name(); name != nil && name.Ntype != nil && findTypeLoop(name.Ntype.Type(), path) {
+				return true
+			}
 		}
 		*path = (*path)[:len(*path)-1]
 	} else {
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index 2901ae41d6..7a1078326d 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -21,7 +21,7 @@ func (p *noder) funcLit(expr *syntax.FuncLit) ir.Node {
 	fn := dcl.Func()
 	fn.SetIsHiddenClosure(Curfn != nil)
 	fn.Nname = newfuncnamel(p.pos(expr), ir.BlankNode.Sym(), fn) // filled in by typecheckclosure
-	fn.Nname.Name().Param.Ntype = xtype
+	fn.Nname.Name().Ntype = xtype
 	fn.Nname.Name().Defn = dcl
 
 	clo := p.nod(expr, ir.OCLOSURE, nil, nil)
@@ -38,7 +38,7 @@ func (p *noder) funcLit(expr *syntax.FuncLit) ir.Node {
 	for _, v := range fn.ClosureVars.Slice() {
 		// Unlink from v1; see comment in syntax.go type Param for these fields.
 		v1 := v.Name().Defn
-		v1.Name().Param.Innermost = v.Name().Param.Outer
+		v1.Name().Innermost = v.Name().Outer
 
 		// If the closure usage of v is not dense,
 		// we need to make it dense; now that we're out
@@ -68,7 +68,7 @@ func (p *noder) funcLit(expr *syntax.FuncLit) ir.Node {
 		// obtains f3's v, creating it if necessary (as it is in the example).
 		//
 		// capturevars will decide whether to use v directly or &v.
-		v.Name().Param.Outer = oldname(v.Sym())
+		v.Name().Outer = oldname(v.Sym()).(*ir.Name)
 	}
 
 	return clo
@@ -194,7 +194,8 @@ func capturevars(dcl ir.Node) {
 		// so that the outer frame also grabs them and knows they escape.
 		dowidth(v.Type())
 
-		outer := v.Name().Param.Outer
+		var outer ir.Node
+		outer = v.Name().Outer
 		outermost := v.Name().Defn
 
 		// out parameters will be assigned to implicitly upon return.
@@ -262,7 +263,7 @@ func transformclosure(dcl ir.Node) {
 				// (accesses will implicitly deref &v).
 				addr := NewName(lookup("&" + v.Sym().Name))
 				addr.SetType(types.NewPtr(v.Type()))
-				v.Name().Param.Heapaddr = addr
+				v.Name().Heapaddr = addr
 				v = addr
 			}
 
@@ -312,7 +313,7 @@ func transformclosure(dcl ir.Node) {
 				addr.Name().SetUsed(true)
 				addr.Name().Curfn = dcl
 				fn.Dcl = append(fn.Dcl, addr)
-				v.Name().Param.Heapaddr = addr
+				v.Name().Heapaddr = addr
 				if v.Name().Byval() {
 					cv = ir.Nod(ir.OADDR, cv, nil)
 				}
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 2a7be137c0..04e6e7a596 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -12,7 +12,6 @@ import (
 	"cmd/internal/obj"
 	"cmd/internal/src"
 	"fmt"
-	"go/constant"
 	"strings"
 )
 
@@ -64,11 +63,6 @@ func declare(n ir.Node, ctxt ir.Class) {
 		return
 	}
 
-	if n.Name() == nil {
-		// named OLITERAL needs Name; most OLITERALs don't.
-		n.SetName(new(ir.Name))
-	}
-
 	s := n.Sym()
 
 	// kludgy: typecheckok means we're past parsing. Eg genwrapper may declare out of package names later.
@@ -152,7 +146,7 @@ func variter(vl []ir.Node, t ir.Node, el []ir.Node) []ir.Node {
 		for _, v := range vl {
 			v.SetOp(ir.ONAME)
 			declare(v, dclcontext)
-			v.Name().Param.Ntype = t
+			v.Name().Ntype = t
 			v.Name().Defn = as2
 			if Curfn != nil {
 				init = append(init, ir.Nod(ir.ODCL, v, nil))
@@ -176,7 +170,7 @@ func variter(vl []ir.Node, t ir.Node, el []ir.Node) []ir.Node {
 
 		v.SetOp(ir.ONAME)
 		declare(v, dclcontext)
-		v.Name().Param.Ntype = t
+		v.Name().Ntype = t
 
 		if e != nil || Curfn != nil || ir.IsBlank(v) {
 			if Curfn != nil {
@@ -201,9 +195,8 @@ func newnoname(s *types.Sym) ir.Node {
 	if s == nil {
 		base.Fatalf("newnoname nil")
 	}
-	n := ir.Nod(ir.ONONAME, nil, nil)
-	n.SetSym(s)
-	n.SetOffset(0)
+	n := ir.NewNameAt(base.Pos, s)
+	n.SetOp(ir.ONONAME)
 	return n
 }
 
@@ -220,7 +213,7 @@ func newfuncnamel(pos src.XPos, s *types.Sym, fn *ir.Func) ir.Node {
 
 // this generates a new name node for a name
 // being declared.
-func dclname(s *types.Sym) ir.Node {
+func dclname(s *types.Sym) *ir.Name {
 	n := NewName(s)
 	n.SetOp(ir.ONONAME) // caller will correct it
 	return n
@@ -277,7 +270,7 @@ func oldname(s *types.Sym) ir.Node {
 		// are parsing x := 5 inside the closure, until we get to
 		// the := it looks like a reference to the outer x so we'll
 		// make x a closure variable unnecessarily.
-		c := n.Name().Param.Innermost
+		c := n.Name().Innermost
 		if c == nil || c.Name().Curfn != Curfn {
 			// Do not have a closure var for the active closure yet; make one.
 			c = NewName(s)
@@ -288,8 +281,8 @@ func oldname(s *types.Sym) ir.Node {
 
 			// Link into list of active closure variables.
 			// Popped from list in func funcLit.
-			c.Name().Param.Outer = n.Name().Param.Innermost
-			n.Name().Param.Innermost = c
+			c.Name().Outer = n.Name().Innermost
+			n.Name().Innermost = c
 
 			Curfn.Func().ClosureVars.Append(c)
 		}
@@ -392,8 +385,8 @@ func funchdr(n ir.Node) {
 
 	types.Markdcl()
 
-	if n.Func().Nname != nil && n.Func().Nname.Name().Param.Ntype != nil {
-		funcargs(n.Func().Nname.Name().Param.Ntype)
+	if n.Func().Nname != nil && n.Func().Nname.Name().Ntype != nil {
+		funcargs(n.Func().Nname.Name().Ntype)
 	} else {
 		funcargs2(n.Type())
 	}
@@ -458,7 +451,7 @@ func funcarg(n ir.Node, ctxt ir.Class) {
 	}
 
 	n.SetRight(ir.NewNameAt(n.Pos(), n.Sym()))
-	n.Right().Name().Param.Ntype = n.Left()
+	n.Right().Name().Ntype = n.Left()
 	n.Right().SetIsDDD(n.IsDDD())
 	declare(n.Right(), ctxt)
 
@@ -554,8 +547,8 @@ func structfield(n ir.Node) *types.Field {
 		checkembeddedtype(n.Type())
 		f.Embedded = 1
 	}
-	if n.HasVal() {
-		f.Note = constant.StringVal(n.Val())
+	if n.Opt() != nil {
+		f.Note = n.Opt().(string)
 	}
 
 	base.Pos = lno
@@ -640,7 +633,7 @@ func interfacefield(n ir.Node) *types.Field {
 		base.Fatalf("interfacefield: oops %v\n", n)
 	}
 
-	if n.HasVal() {
+	if n.Opt() != nil {
 		base.Errorf("interface method cannot have annotation")
 	}
 
@@ -952,10 +945,10 @@ func dclfunc(sym *types.Sym, tfn ir.Node) ir.Node {
 	fn := ir.Nod(ir.ODCLFUNC, nil, nil)
 	fn.Func().Nname = newfuncnamel(base.Pos, sym, fn.Func())
 	fn.Func().Nname.Name().Defn = fn
-	fn.Func().Nname.Name().Param.Ntype = tfn
+	fn.Func().Nname.Name().Ntype = tfn
 	setNodeNameFunc(fn.Func().Nname)
 	funchdr(fn)
-	fn.Func().Nname.Name().Param.Ntype = typecheck(fn.Func().Nname.Name().Param.Ntype, ctxType)
+	fn.Func().Nname.Name().Ntype = typecheck(fn.Func().Nname.Name().Ntype, ctxType)
 	return fn
 }
 
diff --git a/src/cmd/compile/internal/gc/embed.go b/src/cmd/compile/internal/gc/embed.go
index 33b05a5bf0..1c8ccdadef 100644
--- a/src/cmd/compile/internal/gc/embed.go
+++ b/src/cmd/compile/internal/gc/embed.go
@@ -115,13 +115,13 @@ func varEmbed(p *noder, names []ir.Node, typ ir.Node, exprs []ir.Node, embeds []
 		numLocalEmbed++
 		v = ir.NewNameAt(v.Pos(), lookupN("embed.", numLocalEmbed))
 		v.Sym().Def = v
-		v.Name().Param.Ntype = typ
+		v.Name().Ntype = typ
 		v.SetClass(ir.PEXTERN)
 		externdcl = append(externdcl, v)
 		exprs = []ir.Node{v}
 	}
 
-	v.Name().Param.SetEmbedFiles(list)
+	v.Name().SetEmbedFiles(list)
 	embedlist = append(embedlist, v)
 	return exprs
 }
@@ -193,7 +193,7 @@ func dumpembeds() {
 // initEmbed emits the init data for a //go:embed variable,
 // which is either a string, a []byte, or an embed.FS.
 func initEmbed(v ir.Node) {
-	files := v.Name().Param.EmbedFiles()
+	files := v.Name().EmbedFiles()
 	switch kind := embedKind(v.Type()); kind {
 	case embedUnknown:
 		base.ErrorfAt(v.Pos(), "go:embed cannot apply to var of type %v", v.Type())
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index e3ac883e95..351643ef5d 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -1895,7 +1895,7 @@ func moveToHeap(n ir.Node) {
 		stackcopy.SetType(n.Type())
 		stackcopy.SetOffset(n.Offset())
 		stackcopy.SetClass(n.Class())
-		stackcopy.Name().Param.Heapaddr = heapaddr
+		stackcopy.Name().Heapaddr = heapaddr
 		if n.Class() == ir.PPARAMOUT {
 			// Make sure the pointer to the heap copy is kept live throughout the function.
 			// The function could panic at any point, and then a defer could recover.
@@ -1904,7 +1904,7 @@ func moveToHeap(n ir.Node) {
 			// See issue 16095.
 			heapaddr.Name().SetIsOutputParamHeapAddr(true)
 		}
-		n.Name().Param.Stackcopy = stackcopy
+		n.Name().Stackcopy = stackcopy
 
 		// Substitute the stackcopy into the function variable list so that
 		// liveness and other analyses use the underlying stack slot
@@ -1931,7 +1931,7 @@ func moveToHeap(n ir.Node) {
 	// Modify n in place so that uses of n now mean indirection of the heapaddr.
 	n.SetClass(ir.PAUTOHEAP)
 	n.SetOffset(0)
-	n.Name().Param.Heapaddr = heapaddr
+	n.Name().Heapaddr = heapaddr
 	n.SetEsc(EscHeap)
 	if base.Flag.LowerM != 0 {
 		base.WarnfAt(n.Pos(), "moved to heap: %v", n)
diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
index cb640c7ccf..cf9e0d58bf 100644
--- a/src/cmd/compile/internal/gc/gen.go
+++ b/src/cmd/compile/internal/gc/gen.go
@@ -31,13 +31,13 @@ func sysvar(name string) *obj.LSym {
 // isParamStackCopy reports whether this is the on-stack copy of a
 // function parameter that moved to the heap.
 func isParamStackCopy(n ir.Node) bool {
-	return n.Op() == ir.ONAME && (n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT) && n.Name().Param.Heapaddr != nil
+	return n.Op() == ir.ONAME && (n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT) && n.Name().Heapaddr != nil
 }
 
 // isParamHeapCopy reports whether this is the on-heap copy of
 // a function parameter that moved to the heap.
 func isParamHeapCopy(n ir.Node) bool {
-	return n.Op() == ir.ONAME && n.Class() == ir.PAUTOHEAP && n.Name().Param.Stackcopy != nil
+	return n.Op() == ir.ONAME && n.Class() == ir.PAUTOHEAP && n.Name().Stackcopy != nil
 }
 
 // autotmpname returns the name for an autotmp variable numbered n.
@@ -52,7 +52,7 @@ func autotmpname(n int) string {
 }
 
 // make a new Node off the books
-func tempAt(pos src.XPos, curfn ir.Node, t *types.Type) ir.Node {
+func tempAt(pos src.XPos, curfn ir.Node, t *types.Type) *ir.Name {
 	if curfn == nil {
 		base.Fatalf("no curfn for tempAt")
 	}
@@ -80,9 +80,9 @@ func tempAt(pos src.XPos, curfn ir.Node, t *types.Type) ir.Node {
 
 	dowidth(t)
 
-	return ir.Orig(n)
+	return n
 }
 
-func temp(t *types.Type) ir.Node {
+func temp(t *types.Type) *ir.Name {
 	return tempAt(base.Pos, Curfn, t)
 }
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index c2ea599af4..88d3a6477c 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -1463,7 +1463,7 @@ func (w *exportWriter) localName(n ir.Node) {
 	// PPARAM/PPARAMOUT, because we only want to include vargen in
 	// non-param names.
 	var v int32
-	if n.Class() == ir.PAUTO || (n.Class() == ir.PAUTOHEAP && n.Name().Param.Stackcopy == nil) {
+	if n.Class() == ir.PAUTO || (n.Class() == ir.PAUTOHEAP && n.Name().Stackcopy == nil) {
 		v = n.Name().Vargen
 	}
 
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index d43d0d06af..102144aedf 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -982,7 +982,7 @@ func mkinlcall(n, fn ir.Node, maxCost int32, inlMap map[ir.Node]bool) ir.Node {
 					continue
 				}
 
-				o := v.Name().Param.Outer
+				o := v.Name().Outer
 				// make sure the outer param matches the inlining location
 				// NB: if we enabled inlining of functions containing OCLOSURE or refined
 				// the reassigned check via some sort of copy propagation this would most
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 7d2933f360..931626159d 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -253,7 +253,7 @@ func Main(archInit func(*Arch)) {
 	timings.Start("fe", "typecheck", "top1")
 	for i := 0; i < len(xtop); i++ {
 		n := xtop[i]
-		if op := n.Op(); op != ir.ODCL && op != ir.OAS && op != ir.OAS2 && (op != ir.ODCLTYPE || !n.Left().Name().Param.Alias()) {
+		if op := n.Op(); op != ir.ODCL && op != ir.OAS && op != ir.OAS2 && (op != ir.ODCLTYPE || !n.Left().Name().Alias()) {
 			xtop[i] = typecheck(n, ctxStmt)
 		}
 	}
@@ -265,7 +265,7 @@ func Main(archInit func(*Arch)) {
 	timings.Start("fe", "typecheck", "top2")
 	for i := 0; i < len(xtop); i++ {
 		n := xtop[i]
-		if op := n.Op(); op == ir.ODCL || op == ir.OAS || op == ir.OAS2 || op == ir.ODCLTYPE && n.Left().Name().Param.Alias() {
+		if op := n.Op(); op == ir.ODCL || op == ir.OAS || op == ir.OAS2 || op == ir.ODCLTYPE && n.Left().Name().Alias() {
 			xtop[i] = typecheck(n, ctxStmt)
 		}
 	}
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 54915d7693..cbe8a24051 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -456,7 +456,7 @@ func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []ir.Node {
 		n.SetOp(ir.OLITERAL)
 		declare(n, dclcontext)
 
-		n.Name().Param.Ntype = typ
+		n.Name().Ntype = typ
 		n.Name().Defn = v
 		n.SetIota(cs.iota)
 
@@ -480,19 +480,18 @@ func (p *noder) typeDecl(decl *syntax.TypeDecl) ir.Node {
 	// decl.Type may be nil but in that case we got a syntax error during parsing
 	typ := p.typeExprOrNil(decl.Type)
 
-	param := n.Name().Param
-	param.Ntype = typ
-	param.SetAlias(decl.Alias)
+	n.Ntype = typ
+	n.SetAlias(decl.Alias)
 	if pragma, ok := decl.Pragma.(*Pragma); ok {
 		if !decl.Alias {
-			param.SetPragma(pragma.Flag & TypePragmas)
+			n.SetPragma(pragma.Flag & TypePragmas)
 			pragma.Flag &^= TypePragmas
 		}
 		p.checkUnused(pragma)
 	}
 
 	nod := p.nod(decl, ir.ODCLTYPE, n, nil)
-	if param.Alias() && !langSupported(1, 9, ir.LocalPkg) {
+	if n.Alias() && !langSupported(1, 9, ir.LocalPkg) {
 		base.ErrorfAt(nod.Pos(), "type aliases only supported as of -lang=go1.9")
 	}
 	return nod
@@ -506,7 +505,7 @@ func (p *noder) declNames(names []*syntax.Name) []ir.Node {
 	return nodes
 }
 
-func (p *noder) declName(name *syntax.Name) ir.Node {
+func (p *noder) declName(name *syntax.Name) *ir.Name {
 	n := dclname(p.name(name))
 	n.SetPos(p.pos(name))
 	return n
@@ -537,7 +536,7 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) ir.Node {
 
 	f.Func().Nname = newfuncnamel(p.pos(fun.Name), name, f.Func())
 	f.Func().Nname.Name().Defn = f
-	f.Func().Nname.Name().Param.Ntype = t
+	f.Func().Nname.Name().Ntype = t
 
 	if pragma, ok := fun.Pragma.(*Pragma); ok {
 		f.Func().Pragma = pragma.Flag & FuncPragmas
@@ -872,7 +871,7 @@ func (p *noder) structType(expr *syntax.StructType) ir.Node {
 			n = p.nodSym(field, ir.ODCLFIELD, p.typeExpr(field.Type), p.name(field.Name))
 		}
 		if i < len(expr.TagList) && expr.TagList[i] != nil {
-			n.SetVal(p.basicLit(expr.TagList[i]))
+			n.SetOpt(constant.StringVal(p.basicLit(expr.TagList[i])))
 		}
 		l = append(l, n)
 	}
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index 221b733a07..b74b132632 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -667,7 +667,7 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []ir.
 			// misleading location for the param (we want pointer-to-heap
 			// and not stack).
 			// TODO(thanm): generate a better location expression
-			stackcopy := n.Name().Param.Stackcopy
+			stackcopy := n.Name().Stackcopy
 			if stackcopy != nil && (stackcopy.Class() == ir.PPARAM || stackcopy.Class() == ir.PPARAMOUT) {
 				abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
 				isReturnValue = (stackcopy.Class() == ir.PPARAMOUT)
diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/gc/plive.go
index bd7696d859..e3a9b2a198 100644
--- a/src/cmd/compile/internal/gc/plive.go
+++ b/src/cmd/compile/internal/gc/plive.go
@@ -795,7 +795,7 @@ func (lv *Liveness) epilogue() {
 					// Just to be paranoid.  Heap addresses are PAUTOs.
 					base.Fatalf("variable %v both output param and heap output param", n)
 				}
-				if n.Name().Param.Heapaddr != nil {
+				if n.Name().Heapaddr != nil {
 					// If this variable moved to the heap, then
 					// its stack copy is not live.
 					continue
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 5c410ce3ba..28703205d6 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -136,7 +136,7 @@ func importdot(opkg *types.Pkg, pack *ir.PkgName) {
 }
 
 // newname returns a new ONAME Node associated with symbol s.
-func NewName(s *types.Sym) ir.Node {
+func NewName(s *types.Sym) *ir.Name {
 	n := ir.NewNameAt(base.Pos, s)
 	n.Name().Curfn = Curfn
 	return n
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 0c4a3ad833..4ab47fb406 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -259,12 +259,12 @@ func typecheck(n ir.Node, top int) (res ir.Node) {
 				// are substituted.
 				cycle := cycleFor(n)
 				for _, n1 := range cycle {
-					if n1.Name() != nil && !n1.Name().Param.Alias() {
+					if n1.Name() != nil && !n1.Name().Alias() {
 						// Cycle is ok. But if n is an alias type and doesn't
 						// have a type yet, we have a recursive type declaration
 						// with aliases that we can't handle properly yet.
 						// Report an error rather than crashing later.
-						if n.Name() != nil && n.Name().Param.Alias() && n.Type() == nil {
+						if n.Name() != nil && n.Name().Alias() && n.Type() == nil {
 							base.Pos = n.Pos()
 							base.Fatalf("cannot handle alias type declaration (issue #25838): %v", n)
 						}
@@ -2412,9 +2412,6 @@ func typecheckMethodExpr(n ir.Node) (res ir.Node) {
 	}
 
 	n.SetOp(ir.OMETHEXPR)
-	if n.Name() == nil {
-		n.SetName(new(ir.Name))
-	}
 	n.SetRight(NewName(n.Sym()))
 	n.SetSym(methodSym(t, n.Sym()))
 	n.SetType(methodfunc(m.Type, n.Left().Type()))
@@ -3228,7 +3225,7 @@ func typecheckas(n ir.Node) {
 	// so that the conversion below happens).
 	n.SetLeft(resolve(n.Left()))
 
-	if n.Left().Name() == nil || n.Left().Name().Defn != n || n.Left().Name().Param.Ntype != nil {
+	if n.Left().Name() == nil || n.Left().Name().Defn != n || n.Left().Name().Ntype != nil {
 		n.SetLeft(typecheck(n.Left(), ctxExpr|ctxAssign))
 	}
 
@@ -3247,7 +3244,7 @@ func typecheckas(n ir.Node) {
 		}
 	}
 
-	if n.Left().Name() != nil && n.Left().Name().Defn == n && n.Left().Name().Param.Ntype == nil {
+	if n.Left().Name() != nil && n.Left().Name().Defn == n && n.Left().Name().Ntype == nil {
 		n.SetRight(defaultlit(n.Right(), nil))
 		n.Left().SetType(n.Right().Type())
 	}
@@ -3283,7 +3280,7 @@ func typecheckas2(n ir.Node) {
 		n1 = resolve(n1)
 		ls[i1] = n1
 
-		if n1.Name() == nil || n1.Name().Defn != n || n1.Name().Param.Ntype != nil {
+		if n1.Name() == nil || n1.Name().Defn != n || n1.Name().Ntype != nil {
 			ls[i1] = typecheck(ls[i1], ctxExpr|ctxAssign)
 		}
 	}
@@ -3308,7 +3305,7 @@ func typecheckas2(n ir.Node) {
 			if nl.Type() != nil && nr.Type() != nil {
 				rs[il] = assignconv(nr, nl.Type(), "assignment")
 			}
-			if nl.Name() != nil && nl.Name().Defn == n && nl.Name().Param.Ntype == nil {
+			if nl.Name() != nil && nl.Name().Defn == n && nl.Name().Ntype == nil {
 				rs[il] = defaultlit(rs[il], nil)
 				nl.SetType(rs[il].Type())
 			}
@@ -3342,7 +3339,7 @@ func typecheckas2(n ir.Node) {
 				if f.Type != nil && l.Type() != nil {
 					checkassignto(f.Type, l)
 				}
-				if l.Name() != nil && l.Name().Defn == n && l.Name().Param.Ntype == nil {
+				if l.Name() != nil && l.Name().Defn == n && l.Name().Ntype == nil {
 					l.SetType(f.Type)
 				}
 			}
@@ -3378,7 +3375,7 @@ func typecheckas2(n ir.Node) {
 			if l.Type() != nil && !l.Type().IsBoolean() {
 				checkassignto(types.Types[types.TBOOL], l)
 			}
-			if l.Name() != nil && l.Name().Defn == n && l.Name().Param.Ntype == nil {
+			if l.Name() != nil && l.Name().Defn == n && l.Name().Ntype == nil {
 				l.SetType(types.Types[types.TBOOL])
 			}
 			goto out
@@ -3502,7 +3499,7 @@ func setUnderlying(t, underlying *types.Type) {
 	}
 
 	// Propagate go:notinheap pragma from the Name to the Type.
-	if n.Name() != nil && n.Name().Param != nil && n.Name().Param.Pragma()&ir.NotInHeap != 0 {
+	if n.Name() != nil && n.Name().Pragma()&ir.NotInHeap != 0 {
 		t.SetNotInHeap(true)
 	}
 
@@ -3525,8 +3522,8 @@ func typecheckdeftype(n ir.Node) {
 	}
 
 	n.SetTypecheck(1)
-	n.Name().Param.Ntype = typecheck(n.Name().Param.Ntype, ctxType)
-	t := n.Name().Param.Ntype.Type()
+	n.Name().Ntype = typecheck(n.Name().Ntype, ctxType)
+	t := n.Name().Ntype.Type()
 	if t == nil {
 		n.SetDiag(true)
 		n.SetType(nil)
@@ -3586,10 +3583,10 @@ func typecheckdef(n ir.Node) {
 		base.Fatalf("typecheckdef %v", n.Op())
 
 	case ir.OLITERAL:
-		if n.Name().Param.Ntype != nil {
-			n.Name().Param.Ntype = typecheck(n.Name().Param.Ntype, ctxType)
-			n.SetType(n.Name().Param.Ntype.Type())
-			n.Name().Param.Ntype = nil
+		if n.Name().Ntype != nil {
+			n.Name().Ntype = typecheck(n.Name().Ntype, ctxType)
+			n.SetType(n.Name().Ntype.Type())
+			n.Name().Ntype = nil
 			if n.Type() == nil {
 				n.SetDiag(true)
 				goto ret
@@ -3640,9 +3637,9 @@ func typecheckdef(n ir.Node) {
 		}
 
 	case ir.ONAME:
-		if n.Name().Param.Ntype != nil {
-			n.Name().Param.Ntype = typecheck(n.Name().Param.Ntype, ctxType)
-			n.SetType(n.Name().Param.Ntype.Type())
+		if n.Name().Ntype != nil {
+			n.Name().Ntype = typecheck(n.Name().Ntype, ctxType)
+			n.SetType(n.Name().Ntype.Type())
 			if n.Type() == nil {
 				n.SetDiag(true)
 				goto ret
@@ -3676,21 +3673,22 @@ func typecheckdef(n ir.Node) {
 		n.Name().Defn = typecheck(n.Name().Defn, ctxStmt) // fills in n.Type
 
 	case ir.OTYPE:
-		if p := n.Name().Param; p.Alias() {
+		n := n.(*ir.Name)
+		if n.Alias() {
 			// Type alias declaration: Simply use the rhs type - no need
 			// to create a new type.
 			// If we have a syntax error, p.Ntype may be nil.
-			if p.Ntype != nil {
-				p.Ntype = typecheck(p.Ntype, ctxType)
-				n.SetType(p.Ntype.Type())
+			if n.Ntype != nil {
+				n.Ntype = typecheck(n.Ntype, ctxType)
+				n.SetType(n.Ntype.Type())
 				if n.Type() == nil {
 					n.SetDiag(true)
 					goto ret
 				}
 				// For package-level type aliases, set n.Sym.Def so we can identify
 				// it as a type alias during export. See also #31959.
-				if n.Name().Curfn == nil {
-					n.Sym().Def = p.Ntype
+				if n.Curfn == nil {
+					n.Sym().Def = n.Ntype
 				}
 			}
 			break
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index 978e53ac15..1068720748 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -110,7 +110,6 @@ func lexinit() {
 			types.Types[etype] = t
 		}
 		s2.Def = typenod(t)
-		ir.AsNode(s2.Def).SetName(new(ir.Name))
 	}
 
 	for _, s := range &builtinFuncs {
@@ -132,13 +131,11 @@ func lexinit() {
 	s := ir.BuiltinPkg.Lookup("true")
 	s.Def = nodbool(true)
 	ir.AsNode(s.Def).SetSym(lookup("true"))
-	ir.AsNode(s.Def).SetName(new(ir.Name))
 	ir.AsNode(s.Def).SetType(types.UntypedBool)
 
 	s = ir.BuiltinPkg.Lookup("false")
 	s.Def = nodbool(false)
 	ir.AsNode(s.Def).SetSym(lookup("false"))
-	ir.AsNode(s.Def).SetName(new(ir.Name))
 	ir.AsNode(s.Def).SetType(types.UntypedBool)
 
 	s = lookup("_")
@@ -158,12 +155,10 @@ func lexinit() {
 	s = ir.BuiltinPkg.Lookup("nil")
 	s.Def = nodnil()
 	ir.AsNode(s.Def).SetSym(s)
-	ir.AsNode(s.Def).SetName(new(ir.Name))
 
 	s = ir.BuiltinPkg.Lookup("iota")
 	s.Def = ir.Nod(ir.OIOTA, nil, nil)
 	ir.AsNode(s.Def).SetSym(s)
-	ir.AsNode(s.Def).SetName(new(ir.Name))
 }
 
 func typeinit() {
@@ -182,7 +177,6 @@ func typeinit() {
 	types.Types[types.TUNSAFEPTR] = t
 	t.Sym = unsafepkg.Lookup("Pointer")
 	t.Sym.Def = typenod(t)
-	ir.AsNode(t.Sym.Def).SetName(new(ir.Name))
 	dowidth(types.Types[types.TUNSAFEPTR])
 
 	for et := types.TINT8; et <= types.TUINT64; et++ {
@@ -359,7 +353,6 @@ func lexinit1() {
 	types.Bytetype = types.New(types.TUINT8)
 	types.Bytetype.Sym = s
 	s.Def = typenod(types.Bytetype)
-	ir.AsNode(s.Def).SetName(new(ir.Name))
 	dowidth(types.Bytetype)
 
 	// rune alias
@@ -367,7 +360,6 @@ func lexinit1() {
 	types.Runetype = types.New(types.TINT32)
 	types.Runetype.Sym = s
 	s.Def = typenod(types.Runetype)
-	ir.AsNode(s.Def).SetName(new(ir.Name))
 	dowidth(types.Runetype)
 
 	// backend-dependent builtin types (e.g. int).
@@ -385,7 +377,6 @@ func lexinit1() {
 		t.Sym = s1
 		types.Types[s.etype] = t
 		s1.Def = typenod(t)
-		ir.AsNode(s1.Def).SetName(new(ir.Name))
 		s1.Origpkg = ir.BuiltinPkg
 
 		dowidth(t)
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 87fe36b08a..c05aa0c372 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -196,7 +196,7 @@ func walkstmt(n ir.Node) ir.Node {
 			if prealloc[v] == nil {
 				prealloc[v] = callnew(v.Type())
 			}
-			nn := ir.Nod(ir.OAS, v.Name().Param.Heapaddr, prealloc[v])
+			nn := ir.Nod(ir.OAS, v.Name().Heapaddr, prealloc[v])
 			nn.SetColas(true)
 			nn = typecheck(nn, ctxStmt)
 			return walkstmt(nn)
@@ -286,7 +286,7 @@ func walkstmt(n ir.Node) ir.Node {
 				}
 				if cl == ir.PPARAMOUT {
 					if isParamStackCopy(ln) {
-						ln = walkexpr(typecheck(ir.Nod(ir.ODEREF, ln.Name().Param.Heapaddr, nil), ctxExpr), nil)
+						ln = walkexpr(typecheck(ir.Nod(ir.ODEREF, ln.Name().Heapaddr, nil), ctxExpr), nil)
 					}
 					rl = append(rl, ln)
 				}
@@ -314,7 +314,7 @@ func walkstmt(n ir.Node) ir.Node {
 		for i, nl := range lhs.FieldSlice() {
 			nname := ir.AsNode(nl.Nname)
 			if isParamHeapCopy(nname) {
-				nname = nname.Name().Param.Stackcopy
+				nname = nname.Name().Stackcopy
 			}
 			a := ir.Nod(ir.OAS, nname, rhs[i])
 			res[i] = convas(a, n.PtrInit())
@@ -456,7 +456,7 @@ func walkexpr(n ir.Node, init *ir.Nodes) ir.Node {
 	}
 
 	if n.Op() == ir.ONAME && n.Class() == ir.PAUTOHEAP {
-		nn := ir.Nod(ir.ODEREF, n.Name().Param.Heapaddr, nil)
+		nn := ir.Nod(ir.ODEREF, n.Name().Heapaddr, nil)
 		nn = typecheck(nn, ctxExpr)
 		nn = walkexpr(nn, init)
 		nn.Left().MarkNonNil()
@@ -1160,7 +1160,7 @@ opswitch:
 			if n.Type().Elem().Width >= maxImplicitStackVarSize {
 				base.Fatalf("large ONEW with EscNone: %v", n)
 			}
-			r := temp(n.Type().Elem())
+			r := ir.Node(temp(n.Type().Elem()))
 			r = ir.Nod(ir.OAS, r, nil) // zero temp
 			r = typecheck(r, ctxStmt)
 			init.Append(r)
@@ -1776,7 +1776,7 @@ func ascompatet(nl ir.Nodes, nr *types.Type) []ir.Node {
 		// Any assignment to an lvalue that might cause a function call must be
 		// deferred until all the returned values have been read.
 		if fncall(l, r.Type) {
-			tmp := temp(r.Type)
+			tmp := ir.Node(temp(r.Type))
 			tmp = typecheck(tmp, ctxExpr)
 			a := ir.Nod(ir.OAS, l, tmp)
 			a = convas(a, &mm)
@@ -2174,7 +2174,7 @@ func reorder3save(n ir.Node, all []ir.Node, i int, early *[]ir.Node) ir.Node {
 		return n
 	}
 
-	q := temp(n.Type())
+	q := ir.Node(temp(n.Type()))
 	q = ir.Nod(ir.OAS, q, n)
 	q = typecheck(q, ctxStmt)
 	*early = append(*early, q)
@@ -2411,7 +2411,7 @@ func paramstoheap(params *types.Type) []ir.Node {
 			continue
 		}
 
-		if stackcopy := v.Name().Param.Stackcopy; stackcopy != nil {
+		if stackcopy := v.Name().Stackcopy; stackcopy != nil {
 			nn = append(nn, walkstmt(ir.Nod(ir.ODCL, v, nil)))
 			if stackcopy.Class() == ir.PPARAM {
 				nn = append(nn, walkstmt(typecheck(ir.Nod(ir.OAS, v, stackcopy), ctxStmt)))
@@ -2432,7 +2432,7 @@ func paramstoheap(params *types.Type) []ir.Node {
 func zeroResults() {
 	for _, f := range Curfn.Type().Results().Fields().Slice() {
 		v := ir.AsNode(f.Nname)
-		if v != nil && v.Name().Param.Heapaddr != nil {
+		if v != nil && v.Name().Heapaddr != nil {
 			// The local which points to the return value is the
 			// thing that needs zeroing. This is already handled
 			// by a Needzero annotation in plive.go:livenessepilogue.
@@ -2445,7 +2445,7 @@ func zeroResults() {
 			// I don't think the zeroing below matters.
 			// The stack return value will never be marked as live anywhere in the function.
 			// It is not written to until deferreturn returns.
-			v = v.Name().Param.Stackcopy
+			v = v.Name().Stackcopy
 		}
 		// Zero the stack location containing f.
 		Curfn.Func().Enter.Append(ir.NodAt(Curfn.Pos(), ir.OAS, v, nil))
@@ -2461,7 +2461,7 @@ func returnsfromheap(params *types.Type) []ir.Node {
 		if v == nil {
 			continue
 		}
-		if stackcopy := v.Name().Param.Stackcopy; stackcopy != nil && stackcopy.Class() == ir.PPARAMOUT {
+		if stackcopy := v.Name().Stackcopy; stackcopy != nil && stackcopy.Class() == ir.PPARAMOUT {
 			nn = append(nn, walkstmt(typecheck(ir.Nod(ir.OAS, stackcopy, v), ctxStmt)))
 		}
 	}
@@ -3155,7 +3155,7 @@ func copyany(n ir.Node, init *ir.Nodes, runtimecall bool) ir.Node {
 
 	fn := syslook("memmove")
 	fn = substArgTypes(fn, nl.Type().Elem(), nl.Type().Elem())
-	nwid := temp(types.Types[types.TUINTPTR])
+	nwid := ir.Node(temp(types.Types[types.TUINTPTR]))
 	setwid := ir.Nod(ir.OAS, nwid, conv(nlen, types.Types[types.TUINTPTR]))
 	ne.PtrBody().Append(setwid)
 	nwid = ir.Nod(ir.OMUL, nwid, nodintconst(nl.Type().Elem().Width))
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
new file mode 100644
index 0000000000..418351742e
--- /dev/null
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -0,0 +1,47 @@
+// Copyright 2020 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 ir
+
+import (
+	"cmd/compile/internal/types"
+)
+
+// A miniStmt is a miniNode with extra fields common to expressions.
+// TODO(rsc): Once we are sure about the contents, compact the bools
+// into a bit field and leave extra bits available for implementations
+// embedding miniExpr. Right now there are ~60 unused bits sitting here.
+type miniExpr struct {
+	miniNode
+	typ   *types.Type
+	init  Nodes       // TODO(rsc): Don't require every Node to have an init
+	opt   interface{} // TODO(rsc): Don't require every Node to have an opt?
+	flags bitset8
+}
+
+const (
+	miniExprHasCall = 1 << iota
+	miniExprImplicit
+	miniExprNonNil
+	miniExprTransient
+	miniExprBounded
+)
+
+func (n *miniExpr) Type() *types.Type     { return n.typ }
+func (n *miniExpr) SetType(x *types.Type) { n.typ = x }
+func (n *miniExpr) Opt() interface{}      { return n.opt }
+func (n *miniExpr) SetOpt(x interface{})  { n.opt = x }
+func (n *miniExpr) HasCall() bool         { return n.flags&miniExprHasCall != 0 }
+func (n *miniExpr) SetHasCall(b bool)     { n.flags.set(miniExprHasCall, b) }
+func (n *miniExpr) Implicit() bool        { return n.flags&miniExprImplicit != 0 }
+func (n *miniExpr) SetImplicit(b bool)    { n.flags.set(miniExprImplicit, b) }
+func (n *miniExpr) NonNil() bool          { return n.flags&miniExprNonNil != 0 }
+func (n *miniExpr) MarkNonNil()           { n.flags |= miniExprNonNil }
+func (n *miniExpr) Transient() bool       { return n.flags&miniExprTransient != 0 }
+func (n *miniExpr) SetTransient(b bool)   { n.flags.set(miniExprTransient, b) }
+func (n *miniExpr) Bounded() bool         { return n.flags&miniExprBounded != 0 }
+func (n *miniExpr) SetBounded(b bool)     { n.flags.set(miniExprBounded, b) }
+func (n *miniExpr) Init() Nodes           { return n.init }
+func (n *miniExpr) PtrInit() *Nodes       { return &n.init }
+func (n *miniExpr) SetInit(x Nodes)       { n.init = x }
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 24318d501f..e749778030 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -1615,9 +1615,9 @@ func nodeDumpFmt(n Node, s fmt.State, flag FmtFlag, mode FmtMode) {
 		} else {
 			mode.Fprintf(s, "%v%j", n.Op(), n)
 		}
-		if recur && n.Type() == nil && n.Name() != nil && n.Name().Param != nil && n.Name().Param.Ntype != nil {
+		if recur && n.Type() == nil && n.Name() != nil && n.Name().Ntype != nil {
 			indent(s)
-			mode.Fprintf(s, "%v-ntype%v", n.Op(), n.Name().Param.Ntype)
+			mode.Fprintf(s, "%v-ntype%v", n.Op(), n.Name().Ntype)
 		}
 
 	case OASOP:
@@ -1625,9 +1625,9 @@ func nodeDumpFmt(n Node, s fmt.State, flag FmtFlag, mode FmtMode) {
 
 	case OTYPE:
 		mode.Fprintf(s, "%v %v%j type=%v", n.Op(), n.Sym(), n, n.Type())
-		if recur && n.Type() == nil && n.Name() != nil && n.Name().Param != nil && n.Name().Param.Ntype != nil {
+		if recur && n.Type() == nil && n.Name() != nil && n.Name().Ntype != nil {
 			indent(s)
-			mode.Fprintf(s, "%v-ntype%v", n.Op(), n.Name().Param.Ntype)
+			mode.Fprintf(s, "%v-ntype%v", n.Op(), n.Name().Ntype)
 		}
 	}
 
diff --git a/src/cmd/compile/internal/ir/mini.go b/src/cmd/compile/internal/ir/mini.go
index 608c2bed81..248fe232cb 100644
--- a/src/cmd/compile/internal/ir/mini.go
+++ b/src/cmd/compile/internal/ir/mini.go
@@ -130,7 +130,6 @@ func (n *miniNode) SetType(*types.Type) { panic(n.no("SetType")) }
 func (n *miniNode) Func() *Func         { return nil }
 func (n *miniNode) SetFunc(*Func)       { panic(n.no("SetFunc")) }
 func (n *miniNode) Name() *Name         { return nil }
-func (n *miniNode) SetName(*Name)       { panic(n.no("SetName")) }
 func (n *miniNode) Sym() *types.Sym     { return nil }
 func (n *miniNode) SetSym(*types.Sym)   { panic(n.no("SetSym")) }
 func (n *miniNode) Offset() int64       { return types.BADWIDTH }
@@ -164,7 +163,6 @@ func (n *miniNode) SetIndexMapLValue(bool)    { panic(n.no("SetIndexMapLValue"))
 func (n *miniNode) ResetAux()                 { panic(n.no("ResetAux")) }
 func (n *miniNode) HasBreak() bool            { panic(n.no("HasBreak")) }
 func (n *miniNode) SetHasBreak(bool)          { panic(n.no("SetHasBreak")) }
-func (n *miniNode) HasVal() bool              { return false }
 func (n *miniNode) Val() constant.Value       { panic(n.no("Val")) }
 func (n *miniNode) SetVal(v constant.Value)   { panic(n.no("SetVal")) }
 func (n *miniNode) Int64Val() int64           { panic(n.no("Int64Val")) }
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 64d5d2a2ed..d330745cfb 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -15,29 +15,38 @@ import (
 
 // Name holds Node fields used only by named nodes (ONAME, OTYPE, some OLITERAL).
 type Name struct {
+	miniExpr
+	subOp      Op    // uint8
+	class      Class // uint8
+	flags      bitset16
+	pragma     PragmaFlag // int16
+	sym        *types.Sym
+	typ        *types.Type
+	fn         *Func
+	offset     int64
+	val        constant.Value
+	orig       Node
+	embedFiles *[]string // list of embedded files, for ONAME var
+
 	PkgName *PkgName // real package for import . names
 	// For a local variable (not param) or extern, the initializing assignment (OAS or OAS2).
 	// For a closure var, the ONAME node of the outer captured variable
 	Defn Node
 	// The ODCLFUNC node (for a static function/method or a closure) in which
 	// local variable or param is declared.
-	Curfn     Node
-	Param     *Param // additional fields for ONAME, OTYPE
-	Decldepth int32  // declaration loop depth, increased for every loop or label
+	Curfn Node
 	// Unique number for ONAME nodes within a function. Function outputs
 	// (results) are numbered starting at one, followed by function inputs
 	// (parameters), and then local variables. Vargen is used to distinguish
 	// local variables/params with the same name.
-	Vargen int32
-	flags  bitset16
-}
+	Vargen    int32
+	Decldepth int32 // declaration loop depth, increased for every loop or label
 
-type Param struct {
 	Ntype    Node
-	Heapaddr Node // temp holding heap address of param
+	Heapaddr *Name // temp holding heap address of param
 
 	// ONAME PAUTOHEAP
-	Stackcopy Node // the PPARAM/PPARAMOUT on-stack slot (moved func params only)
+	Stackcopy *Name // the PPARAM/PPARAMOUT on-stack slot (moved func params only)
 
 	// ONAME closure linkage
 	// Consider:
@@ -108,114 +117,88 @@ type Param struct {
 	//
 	// Because of the sharding of pieces of the node, x.Defn means x.Name.Defn
 	// and x.Innermost/Outer means x.Name.Param.Innermost/Outer.
-	Innermost Node
-	Outer     Node
-
-	// OTYPE & ONAME //go:embed info,
-	// sharing storage to reduce gc.Param size.
-	// Extra is nil, or else *Extra is a *paramType or an *embedFileList.
-	Extra *interface{}
+	Innermost *Name
+	Outer     *Name
 }
 
 // NewNameAt returns a new ONAME Node associated with symbol s at position pos.
 // The caller is responsible for setting n.Name.Curfn.
-func NewNameAt(pos src.XPos, s *types.Sym) Node {
-	if s == nil {
-		base.Fatalf("newnamel nil")
+func NewNameAt(pos src.XPos, sym *types.Sym) *Name {
+	if sym == nil {
+		base.Fatalf("NewNameAt nil")
 	}
+	return newNameAt(pos, sym)
+}
 
-	var x struct {
-		n node
-		m Name
-		p Param
-	}
-	n := &x.n
-	n.SetName(&x.m)
-	n.Name().Param = &x.p
-
-	n.SetOp(ONAME)
-	n.SetPos(pos)
-	n.SetOrig(n)
-
-	n.SetSym(s)
+// newNameAt is like NewNameAt but allows sym == nil.
+func newNameAt(pos src.XPos, sym *types.Sym) *Name {
+	n := new(Name)
+	n.op = ONAME
+	n.pos = pos
+	n.orig = n
+	n.sym = sym
 	return n
 }
 
-type paramType struct {
-	flag  PragmaFlag
-	alias bool
+func (n *Name) String() string                { return fmt.Sprint(n) }
+func (n *Name) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *Name) RawCopy() Node                 { c := *n; return &c }
+func (n *Name) Name() *Name                   { return n }
+func (n *Name) Sym() *types.Sym               { return n.sym }
+func (n *Name) SetSym(x *types.Sym)           { n.sym = x }
+func (n *Name) Orig() Node                    { return n.orig }
+func (n *Name) SetOrig(x Node)                { n.orig = x }
+func (n *Name) SubOp() Op                     { return n.subOp }
+func (n *Name) SetSubOp(x Op)                 { n.subOp = x }
+func (n *Name) Class() Class                  { return n.class }
+func (n *Name) SetClass(x Class)              { n.class = x }
+func (n *Name) Func() *Func                   { return n.fn }
+func (n *Name) SetFunc(x *Func)               { n.fn = x }
+func (n *Name) Offset() int64                 { return n.offset }
+func (n *Name) SetOffset(x int64)             { n.offset = x }
+func (n *Name) Iota() int64                   { return n.offset }
+func (n *Name) SetIota(x int64)               { n.offset = x }
+
+func (n *Name) SetOp(op Op) {
+	switch op {
+	default:
+		panic(n.no("SetOp " + op.String()))
+	case OLITERAL, ONONAME, ONAME, OTYPE, OIOTA:
+		n.op = op
+	}
 }
 
 // Pragma returns the PragmaFlag for p, which must be for an OTYPE.
-func (p *Param) Pragma() PragmaFlag {
-	if p.Extra == nil {
-		return 0
-	}
-	return (*p.Extra).(*paramType).flag
-}
+func (n *Name) Pragma() PragmaFlag { return n.pragma }
 
 // SetPragma sets the PragmaFlag for p, which must be for an OTYPE.
-func (p *Param) SetPragma(flag PragmaFlag) {
-	if p.Extra == nil {
-		if flag == 0 {
-			return
-		}
-		p.Extra = new(interface{})
-		*p.Extra = &paramType{flag: flag}
-		return
-	}
-	(*p.Extra).(*paramType).flag = flag
-}
+func (n *Name) SetPragma(flag PragmaFlag) { n.pragma = flag }
 
 // Alias reports whether p, which must be for an OTYPE, is a type alias.
-func (p *Param) Alias() bool {
-	if p.Extra == nil {
-		return false
-	}
-	t, ok := (*p.Extra).(*paramType)
-	if !ok {
-		return false
-	}
-	return t.alias
-}
+func (n *Name) Alias() bool { return n.flags&nameAlias != 0 }
 
 // SetAlias sets whether p, which must be for an OTYPE, is a type alias.
-func (p *Param) SetAlias(alias bool) {
-	if p.Extra == nil {
-		if !alias {
-			return
-		}
-		p.Extra = new(interface{})
-		*p.Extra = &paramType{alias: alias}
-		return
-	}
-	(*p.Extra).(*paramType).alias = alias
-}
-
-type embedFileList []string
+func (n *Name) SetAlias(alias bool) { n.flags.set(nameAlias, alias) }
 
 // EmbedFiles returns the list of embedded files for p,
 // which must be for an ONAME var.
-func (p *Param) EmbedFiles() []string {
-	if p.Extra == nil {
+func (n *Name) EmbedFiles() []string {
+	if n.embedFiles == nil {
 		return nil
 	}
-	return *(*p.Extra).(*embedFileList)
+	return *n.embedFiles
 }
 
 // SetEmbedFiles sets the list of embedded files for p,
 // which must be for an ONAME var.
-func (p *Param) SetEmbedFiles(list []string) {
-	if p.Extra == nil {
-		if len(list) == 0 {
-			return
-		}
-		f := embedFileList(list)
-		p.Extra = new(interface{})
-		*p.Extra = &f
+func (n *Name) SetEmbedFiles(list []string) {
+	if n.embedFiles == nil && list == nil {
 		return
 	}
-	*(*p.Extra).(*embedFileList) = list
+	if n.embedFiles == nil {
+		n.embedFiles = new([]string)
+	}
+	*n.embedFiles = list
 }
 
 const (
@@ -233,6 +216,8 @@ const (
 	nameInlLocal              // PAUTO created by inliner, derived from callee local
 	nameOpenDeferSlot         // if temporary var storing info for open-coded defers
 	nameLibfuzzerExtraCounter // if PEXTERN should be assigned to __libfuzzer_extra_counters section
+	nameIsDDD                 // is function argument a ...
+	nameAlias                 // is type name an alias
 )
 
 func (n *Name) Captured() bool              { return n.flags&nameCaptured != 0 }
@@ -249,9 +234,10 @@ func (n *Name) InlFormal() bool             { return n.flags&nameInlFormal != 0
 func (n *Name) InlLocal() bool              { return n.flags&nameInlLocal != 0 }
 func (n *Name) OpenDeferSlot() bool         { return n.flags&nameOpenDeferSlot != 0 }
 func (n *Name) LibfuzzerExtraCounter() bool { return n.flags&nameLibfuzzerExtraCounter != 0 }
+func (n *Name) IsDDD() bool                 { return n.flags&nameIsDDD != 0 }
 
 func (n *Name) SetCaptured(b bool)              { n.flags.set(nameCaptured, b) }
-func (n *Name) SetReadonly(b bool)              { n.flags.set(nameReadonly, b) }
+func (n *Name) setReadonly(b bool)              { n.flags.set(nameReadonly, b) }
 func (n *Name) SetByval(b bool)                 { n.flags.set(nameByval, b) }
 func (n *Name) SetNeedzero(b bool)              { n.flags.set(nameNeedzero, b) }
 func (n *Name) SetAutoTemp(b bool)              { n.flags.set(nameAutoTemp, b) }
@@ -264,13 +250,14 @@ func (n *Name) SetInlFormal(b bool)             { n.flags.set(nameInlFormal, b)
 func (n *Name) SetInlLocal(b bool)              { n.flags.set(nameInlLocal, b) }
 func (n *Name) SetOpenDeferSlot(b bool)         { n.flags.set(nameOpenDeferSlot, b) }
 func (n *Name) SetLibfuzzerExtraCounter(b bool) { n.flags.set(nameLibfuzzerExtraCounter, b) }
+func (n *Name) SetIsDDD(b bool)                 { n.flags.set(nameIsDDD, b) }
 
 // MarkReadonly indicates that n is an ONAME with readonly contents.
-func (n *node) MarkReadonly() {
+func (n *Name) MarkReadonly() {
 	if n.Op() != ONAME {
 		base.Fatalf("Node.MarkReadonly %v", n.Op())
 	}
-	n.Name().SetReadonly(true)
+	n.Name().setReadonly(true)
 	// Mark the linksym as readonly immediately
 	// so that the SSA backend can use this information.
 	// It will be overridden later during dumpglobls.
@@ -278,31 +265,26 @@ func (n *node) MarkReadonly() {
 }
 
 // Val returns the constant.Value for the node.
-func (n *node) Val() constant.Value {
-	if !n.HasVal() {
+func (n *Name) Val() constant.Value {
+	if n.val == nil {
 		return constant.MakeUnknown()
 	}
-	return *n.e.(*constant.Value)
+	return n.val
 }
 
 // SetVal sets the constant.Value for the node,
 // which must not have been used with SetOpt.
-func (n *node) SetVal(v constant.Value) {
-	if n.hasOpt() {
-		base.Flag.LowerH = 1
-		Dump("have Opt", n)
-		base.Fatalf("have Opt")
-	}
-	if n.Op() == OLITERAL {
-		AssertValidTypeForConst(n.Type(), v)
+func (n *Name) SetVal(v constant.Value) {
+	if n.op != OLITERAL {
+		panic(n.no("SetVal"))
 	}
-	n.setHasVal(true)
-	n.e = &v
+	AssertValidTypeForConst(n.Type(), v)
+	n.val = v
 }
 
 // Int64Val returns n as an int64.
 // n must be an integer or rune constant.
-func (n *node) Int64Val() int64 {
+func (n *Name) Int64Val() int64 {
 	if !IsConst(n, constant.Int) {
 		base.Fatalf("Int64Val(%v)", n)
 	}
@@ -314,7 +296,7 @@ func (n *node) Int64Val() int64 {
 }
 
 // CanInt64 reports whether it is safe to call Int64Val() on n.
-func (n *node) CanInt64() bool {
+func (n *Name) CanInt64() bool {
 	if !IsConst(n, constant.Int) {
 		return false
 	}
@@ -327,7 +309,7 @@ func (n *node) CanInt64() bool {
 
 // Uint64Val returns n as an uint64.
 // n must be an integer or rune constant.
-func (n *node) Uint64Val() uint64 {
+func (n *Name) Uint64Val() uint64 {
 	if !IsConst(n, constant.Int) {
 		base.Fatalf("Uint64Val(%v)", n)
 	}
@@ -340,7 +322,7 @@ func (n *node) Uint64Val() uint64 {
 
 // BoolVal returns n as a bool.
 // n must be a boolean constant.
-func (n *node) BoolVal() bool {
+func (n *Name) BoolVal() bool {
 	if !IsConst(n, constant.Bool) {
 		base.Fatalf("BoolVal(%v)", n)
 	}
@@ -349,7 +331,7 @@ func (n *node) BoolVal() bool {
 
 // StringVal returns the value of a literal string Node as a string.
 // n must be a string constant.
-func (n *node) StringVal() string {
+func (n *Name) StringVal() string {
 	if !IsConst(n, constant.String) {
 		base.Fatalf("StringVal(%v)", n)
 	}
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 0023df97a8..a6a24774b5 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -59,7 +59,6 @@ type Node interface {
 	Func() *Func
 	SetFunc(x *Func)
 	Name() *Name
-	SetName(x *Name)
 	Sym() *types.Sym
 	SetSym(x *types.Sym)
 	Offset() int64
@@ -93,7 +92,6 @@ type Node interface {
 	SetHasBreak(x bool)
 	MarkReadonly()
 	Val() constant.Value
-	HasVal() bool
 	SetVal(v constant.Value)
 	Int64Val() int64
 	Uint64Val() uint64
@@ -149,11 +147,8 @@ type node struct {
 	// func
 	fn *Func
 
-	// ONAME, OTYPE, OPACK, OLABEL, some OLITERAL
-	name *Name
-
-	sym *types.Sym  // various
-	e   interface{} // Opt or Val, see methods below
+	sym *types.Sym // various
+	opt interface{}
 
 	// Various. Usually an offset into a struct. For example:
 	// - ONAME nodes that refer to local variables use it to identify their stack frame position.
@@ -185,8 +180,7 @@ func (n *node) Type() *types.Type     { return n.typ }
 func (n *node) SetType(x *types.Type) { n.typ = x }
 func (n *node) Func() *Func           { return n.fn }
 func (n *node) SetFunc(x *Func)       { n.fn = x }
-func (n *node) Name() *Name           { return n.name }
-func (n *node) SetName(x *Name)       { n.name = x }
+func (n *node) Name() *Name           { return nil }
 func (n *node) Sym() *types.Sym       { return n.sym }
 func (n *node) SetSym(x *types.Sym)   { n.sym = x }
 func (n *node) Pos() src.XPos         { return n.pos }
@@ -208,6 +202,14 @@ func (n *node) PtrList() *Nodes       { return &n.list }
 func (n *node) Rlist() Nodes          { return n.rlist }
 func (n *node) SetRlist(x Nodes)      { n.rlist = x }
 func (n *node) PtrRlist() *Nodes      { return &n.rlist }
+func (n *node) MarkReadonly()         { panic("node.MarkReadOnly") }
+func (n *node) Val() constant.Value   { panic("node.Val") }
+func (n *node) SetVal(constant.Value) { panic("node.SetVal") }
+func (n *node) Int64Val() int64       { panic("node.Int64Val") }
+func (n *node) CanInt64() bool        { return false }
+func (n *node) Uint64Val() uint64     { panic("node.Uint64Val") }
+func (n *node) BoolVal() bool         { panic("node.BoolVal") }
+func (n *node) StringVal() string     { panic("node.StringVal") }
 
 func (n *node) SetOp(op Op) {
 	if !okForNod[op] {
@@ -305,8 +307,6 @@ const (
 	_, nodeBounded   // bounds check unnecessary
 	_, nodeHasCall   // expression contains a function call
 	_, nodeLikely    // if statement condition likely
-	_, nodeHasVal    // node.E contains a Val
-	_, nodeHasOpt    // node.E contains an Opt
 	_, nodeEmbedded  // ODCLFIELD embedded type
 )
 
@@ -326,8 +326,6 @@ func (n *node) Transient() bool { return n.flags&nodeTransient != 0 }
 func (n *node) Bounded() bool   { return n.flags&nodeBounded != 0 }
 func (n *node) HasCall() bool   { return n.flags&nodeHasCall != 0 }
 func (n *node) Likely() bool    { return n.flags&nodeLikely != 0 }
-func (n *node) HasVal() bool    { return n.flags&nodeHasVal != 0 }
-func (n *node) hasOpt() bool    { return n.flags&nodeHasOpt != 0 }
 func (n *node) Embedded() bool  { return n.flags&nodeEmbedded != 0 }
 
 func (n *node) SetClass(b Class)     { n.flags.set3(nodeClass, uint8(b)) }
@@ -344,8 +342,6 @@ func (n *node) SetColas(b bool)     { n.flags.set(nodeColas, b) }
 func (n *node) SetTransient(b bool) { n.flags.set(nodeTransient, b) }
 func (n *node) SetHasCall(b bool)   { n.flags.set(nodeHasCall, b) }
 func (n *node) SetLikely(b bool)    { n.flags.set(nodeLikely, b) }
-func (n *node) setHasVal(b bool)    { n.flags.set(nodeHasVal, b) }
-func (n *node) setHasOpt(b bool)    { n.flags.set(nodeHasOpt, b) }
 func (n *node) SetEmbedded(b bool)  { n.flags.set(nodeEmbedded, b) }
 
 // MarkNonNil marks a pointer n as being guaranteed non-nil,
@@ -380,29 +376,13 @@ func (n *node) SetBounded(b bool) {
 
 // Opt returns the optimizer data for the node.
 func (n *node) Opt() interface{} {
-	if !n.hasOpt() {
-		return nil
-	}
-	return n.e
+	return n.opt
 }
 
 // SetOpt sets the optimizer data for the node, which must not have been used with SetVal.
 // SetOpt(nil) is ignored for Vals to simplify call sites that are clearing Opts.
 func (n *node) SetOpt(x interface{}) {
-	if x == nil {
-		if n.hasOpt() {
-			n.setHasOpt(false)
-			n.e = nil
-		}
-		return
-	}
-	if n.HasVal() {
-		base.Flag.LowerH = 1
-		Dump("have Val", n)
-		base.Fatalf("have Val")
-	}
-	n.setHasOpt(true)
-	n.e = x
+	n.opt = x
 }
 
 func (n *node) Iota() int64 {
@@ -1344,6 +1324,10 @@ func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
 		return NewEmptyStmt(pos)
 	case OBREAK, OCONTINUE, OFALL, OGOTO:
 		return NewBranchStmt(pos, op, nil)
+	case OLITERAL, OTYPE, OIOTA:
+		n := newNameAt(pos, nil)
+		n.SetOp(op)
+		return n
 	case OLABEL:
 		return NewLabelStmt(pos, nil)
 	default:
@@ -1428,13 +1412,11 @@ var okForNod = [OEND]bool{
 	OINDEXMAP:      true,
 	OINLCALL:       true,
 	OINLMARK:       true,
-	OIOTA:          true,
 	OITAB:          true,
 	OKEY:           true,
 	OLABEL:         true,
 	OLE:            true,
 	OLEN:           true,
-	OLITERAL:       true,
 	OLSH:           true,
 	OLT:            true,
 	OMAKE:          true,
@@ -1446,13 +1428,11 @@ var okForNod = [OEND]bool{
 	OMETHEXPR:      true,
 	OMOD:           true,
 	OMUL:           true,
-	ONAME:          true,
 	ONE:            true,
 	ONEG:           true,
 	ONEW:           true,
 	ONEWOBJ:        true,
 	ONIL:           true,
-	ONONAME:        true,
 	ONOT:           true,
 	OOFFSETOF:      true,
 	OOR:            true,
@@ -1499,7 +1479,7 @@ var okForNod = [OEND]bool{
 	OTINTER:        true,
 	OTMAP:          true,
 	OTSTRUCT:       true,
-	OTYPE:          true,
+	OTYPE:          true, // TODO: Remove once setTypeNode is gone.
 	OTYPESW:        true,
 	OVARDEF:        true,
 	OVARKILL:       true,
diff --git a/src/cmd/compile/internal/ir/sizeof_test.go b/src/cmd/compile/internal/ir/sizeof_test.go
index a025cb5986..8a0b078b9b 100644
--- a/src/cmd/compile/internal/ir/sizeof_test.go
+++ b/src/cmd/compile/internal/ir/sizeof_test.go
@@ -21,9 +21,8 @@ func TestSizeof(t *testing.T) {
 		_64bit uintptr     // size on 64bit platforms
 	}{
 		{Func{}, 152, 280},
-		{Name{}, 36, 64},
-		{Param{}, 44, 88},
-		{node{}, 88, 152},
+		{Name{}, 132, 232},
+		{node{}, 84, 144},
 	}
 
 	for _, tt := range tests {
-- 
GitLab


From 65ae15ac5d43ad82f664e5a914d74c7549568c93 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 28 Nov 2020 07:13:54 -0500
Subject: [PATCH 0087/2400] [dev.regabi] cmd/compile: move func code from
 node.go to func.go

No code changes here, only copying of text.
This will make the diffs in a future CL readable.

Passes buildall w/ toolstash -cmp.

Change-Id: I325a62e79edd82f1437769891ea63a32f51c0170
Reviewed-on: https://go-review.googlesource.com/c/go/+/274095
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/func.go | 216 ++++++++++++++++++++++++++++
 src/cmd/compile/internal/ir/node.go | 205 --------------------------
 2 files changed, 216 insertions(+), 205 deletions(-)
 create mode 100644 src/cmd/compile/internal/ir/func.go

diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
new file mode 100644
index 0000000000..1566125955
--- /dev/null
+++ b/src/cmd/compile/internal/ir/func.go
@@ -0,0 +1,216 @@
+// Copyright 2020 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 ir
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/types"
+	"cmd/internal/obj"
+	"cmd/internal/src"
+)
+
+// A Func corresponds to a single function in a Go program
+// (and vice versa: each function is denoted by exactly one *Func).
+//
+// There are multiple nodes that represent a Func in the IR.
+//
+// The ONAME node (Func.Name) is used for plain references to it.
+// The ODCLFUNC node (Func.Decl) is used for its declaration code.
+// The OCLOSURE node (Func.Closure) is used for a reference to a
+// function literal.
+//
+// A Func for an imported function will have only an ONAME node.
+// A declared function or method has an ONAME and an ODCLFUNC.
+// A function literal is represented directly by an OCLOSURE, but it also
+// has an ODCLFUNC (and a matching ONAME) representing the compiled
+// underlying form of the closure, which accesses the captured variables
+// using a special data structure passed in a register.
+//
+// A method declaration is represented like functions, except f.Sym
+// will be the qualified method name (e.g., "T.m") and
+// f.Func.Shortname is the bare method name (e.g., "m").
+//
+// A method expression (T.M) is represented as an OMETHEXPR node,
+// in which n.Left and n.Right point to the type and method, respectively.
+// Each distinct mention of a method expression in the source code
+// constructs a fresh node.
+//
+// A method value (t.M) is represented by ODOTMETH/ODOTINTER
+// when it is called directly and by OCALLPART otherwise.
+// These are like method expressions, except that for ODOTMETH/ODOTINTER,
+// the method name is stored in Sym instead of Right.
+// Each OCALLPART ends up being implemented as a new
+// function, a bit like a closure, with its own ODCLFUNC.
+// The OCALLPART has uses n.Func to record the linkage to
+// the generated ODCLFUNC (as n.Func.Decl), but there is no
+// pointer from the Func back to the OCALLPART.
+type Func struct {
+	Nname    Node // ONAME node
+	Decl     Node // ODCLFUNC node
+	OClosure Node // OCLOSURE node
+
+	Shortname *types.Sym
+
+	// Extra entry code for the function. For example, allocate and initialize
+	// memory for escaping parameters.
+	Enter Nodes
+	Exit  Nodes
+	// ONAME nodes for all params/locals for this func/closure, does NOT
+	// include closurevars until transformclosure runs.
+	Dcl []Node
+
+	ClosureEnter  Nodes // list of ONAME nodes of captured variables
+	ClosureType   Node  // closure representation type
+	ClosureCalled bool  // closure is only immediately called
+	ClosureVars   Nodes // closure params; each has closurevar set
+
+	// Parents records the parent scope of each scope within a
+	// function. The root scope (0) has no parent, so the i'th
+	// scope's parent is stored at Parents[i-1].
+	Parents []ScopeID
+
+	// Marks records scope boundary changes.
+	Marks []Mark
+
+	// Closgen tracks how many closures have been generated within
+	// this function. Used by closurename for creating unique
+	// function names.
+	Closgen int
+
+	FieldTrack map[*types.Sym]struct{}
+	DebugInfo  interface{}
+	LSym       *obj.LSym
+
+	Inl *Inline
+
+	Label int32 // largest auto-generated label in this function
+
+	Endlineno src.XPos
+	WBPos     src.XPos // position of first write barrier; see SetWBPos
+
+	Pragma PragmaFlag // go:xxx function annotations
+
+	flags      bitset16
+	NumDefers  int // number of defer calls in the function
+	NumReturns int // number of explicit returns in the function
+
+	// nwbrCalls records the LSyms of functions called by this
+	// function for go:nowritebarrierrec analysis. Only filled in
+	// if nowritebarrierrecCheck != nil.
+	NWBRCalls *[]SymAndPos
+}
+
+// An Inline holds fields used for function bodies that can be inlined.
+type Inline struct {
+	Cost int32 // heuristic cost of inlining this function
+
+	// Copies of Func.Dcl and Nbody for use during inlining.
+	Dcl  []Node
+	Body []Node
+}
+
+// A Mark represents a scope boundary.
+type Mark struct {
+	// Pos is the position of the token that marks the scope
+	// change.
+	Pos src.XPos
+
+	// Scope identifies the innermost scope to the right of Pos.
+	Scope ScopeID
+}
+
+// A ScopeID represents a lexical scope within a function.
+type ScopeID int32
+
+const (
+	funcDupok         = 1 << iota // duplicate definitions ok
+	funcWrapper                   // is method wrapper
+	funcNeedctxt                  // function uses context register (has closure variables)
+	funcReflectMethod             // function calls reflect.Type.Method or MethodByName
+	// true if closure inside a function; false if a simple function or a
+	// closure in a global variable initialization
+	funcIsHiddenClosure
+	funcHasDefer                 // contains a defer statement
+	funcNilCheckDisabled         // disable nil checks when compiling this function
+	funcInlinabilityChecked      // inliner has already determined whether the function is inlinable
+	funcExportInline             // include inline body in export data
+	funcInstrumentBody           // add race/msan instrumentation during SSA construction
+	funcOpenCodedDeferDisallowed // can't do open-coded defers
+)
+
+type SymAndPos struct {
+	Sym *obj.LSym // LSym of callee
+	Pos src.XPos  // line of call
+}
+
+func (f *Func) Dupok() bool                    { return f.flags&funcDupok != 0 }
+func (f *Func) Wrapper() bool                  { return f.flags&funcWrapper != 0 }
+func (f *Func) Needctxt() bool                 { return f.flags&funcNeedctxt != 0 }
+func (f *Func) ReflectMethod() bool            { return f.flags&funcReflectMethod != 0 }
+func (f *Func) IsHiddenClosure() bool          { return f.flags&funcIsHiddenClosure != 0 }
+func (f *Func) HasDefer() bool                 { return f.flags&funcHasDefer != 0 }
+func (f *Func) NilCheckDisabled() bool         { return f.flags&funcNilCheckDisabled != 0 }
+func (f *Func) InlinabilityChecked() bool      { return f.flags&funcInlinabilityChecked != 0 }
+func (f *Func) ExportInline() bool             { return f.flags&funcExportInline != 0 }
+func (f *Func) InstrumentBody() bool           { return f.flags&funcInstrumentBody != 0 }
+func (f *Func) OpenCodedDeferDisallowed() bool { return f.flags&funcOpenCodedDeferDisallowed != 0 }
+
+func (f *Func) SetDupok(b bool)                    { f.flags.set(funcDupok, b) }
+func (f *Func) SetWrapper(b bool)                  { f.flags.set(funcWrapper, b) }
+func (f *Func) SetNeedctxt(b bool)                 { f.flags.set(funcNeedctxt, b) }
+func (f *Func) SetReflectMethod(b bool)            { f.flags.set(funcReflectMethod, b) }
+func (f *Func) SetIsHiddenClosure(b bool)          { f.flags.set(funcIsHiddenClosure, b) }
+func (f *Func) SetHasDefer(b bool)                 { f.flags.set(funcHasDefer, b) }
+func (f *Func) SetNilCheckDisabled(b bool)         { f.flags.set(funcNilCheckDisabled, b) }
+func (f *Func) SetInlinabilityChecked(b bool)      { f.flags.set(funcInlinabilityChecked, b) }
+func (f *Func) SetExportInline(b bool)             { f.flags.set(funcExportInline, b) }
+func (f *Func) SetInstrumentBody(b bool)           { f.flags.set(funcInstrumentBody, b) }
+func (f *Func) SetOpenCodedDeferDisallowed(b bool) { f.flags.set(funcOpenCodedDeferDisallowed, b) }
+
+func (f *Func) SetWBPos(pos src.XPos) {
+	if base.Debug.WB != 0 {
+		base.WarnfAt(pos, "write barrier")
+	}
+	if !f.WBPos.IsKnown() {
+		f.WBPos = pos
+	}
+}
+
+// funcname returns the name (without the package) of the function n.
+func FuncName(n Node) string {
+	if n == nil || n.Func() == nil || n.Func().Nname == nil {
+		return "<nil>"
+	}
+	return n.Func().Nname.Sym().Name
+}
+
+// pkgFuncName returns the name of the function referenced by n, with package prepended.
+// This differs from the compiler's internal convention where local functions lack a package
+// because the ultimate consumer of this is a human looking at an IDE; package is only empty
+// if the compilation package is actually the empty string.
+func PkgFuncName(n Node) string {
+	var s *types.Sym
+	if n == nil {
+		return "<nil>"
+	}
+	if n.Op() == ONAME {
+		s = n.Sym()
+	} else {
+		if n.Func() == nil || n.Func().Nname == nil {
+			return "<nil>"
+		}
+		s = n.Func().Nname.Sym()
+	}
+	pkg := s.Pkg
+
+	p := base.Ctxt.Pkgpath
+	if pkg != nil && pkg.Path != "" {
+		p = pkg.Path
+	}
+	if p == "" {
+		return s.Name
+	}
+	return p + "." + s.Name
+}
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index a6a24774b5..1b01032c9b 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -14,7 +14,6 @@ import (
 
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
-	"cmd/internal/obj"
 	"cmd/internal/src"
 )
 
@@ -403,209 +402,10 @@ func MayBeShared(n Node) bool {
 	return false
 }
 
-// funcname returns the name (without the package) of the function n.
-func FuncName(n Node) string {
-	if n == nil || n.Func() == nil || n.Func().Nname == nil {
-		return "<nil>"
-	}
-	return n.Func().Nname.Sym().Name
-}
-
-// pkgFuncName returns the name of the function referenced by n, with package prepended.
-// This differs from the compiler's internal convention where local functions lack a package
-// because the ultimate consumer of this is a human looking at an IDE; package is only empty
-// if the compilation package is actually the empty string.
-func PkgFuncName(n Node) string {
-	var s *types.Sym
-	if n == nil {
-		return "<nil>"
-	}
-	if n.Op() == ONAME {
-		s = n.Sym()
-	} else {
-		if n.Func() == nil || n.Func().Nname == nil {
-			return "<nil>"
-		}
-		s = n.Func().Nname.Sym()
-	}
-	pkg := s.Pkg
-
-	p := base.Ctxt.Pkgpath
-	if pkg != nil && pkg.Path != "" {
-		p = pkg.Path
-	}
-	if p == "" {
-		return s.Name
-	}
-	return p + "." + s.Name
-}
-
 // The compiler needs *Node to be assignable to cmd/compile/internal/ssa.Sym.
 func (n *node) CanBeAnSSASym() {
 }
 
-// A Func corresponds to a single function in a Go program
-// (and vice versa: each function is denoted by exactly one *Func).
-//
-// There are multiple nodes that represent a Func in the IR.
-//
-// The ONAME node (Func.Name) is used for plain references to it.
-// The ODCLFUNC node (Func.Decl) is used for its declaration code.
-// The OCLOSURE node (Func.Closure) is used for a reference to a
-// function literal.
-//
-// A Func for an imported function will have only an ONAME node.
-// A declared function or method has an ONAME and an ODCLFUNC.
-// A function literal is represented directly by an OCLOSURE, but it also
-// has an ODCLFUNC (and a matching ONAME) representing the compiled
-// underlying form of the closure, which accesses the captured variables
-// using a special data structure passed in a register.
-//
-// A method declaration is represented like functions, except f.Sym
-// will be the qualified method name (e.g., "T.m") and
-// f.Func.Shortname is the bare method name (e.g., "m").
-//
-// A method expression (T.M) is represented as an OMETHEXPR node,
-// in which n.Left and n.Right point to the type and method, respectively.
-// Each distinct mention of a method expression in the source code
-// constructs a fresh node.
-//
-// A method value (t.M) is represented by ODOTMETH/ODOTINTER
-// when it is called directly and by OCALLPART otherwise.
-// These are like method expressions, except that for ODOTMETH/ODOTINTER,
-// the method name is stored in Sym instead of Right.
-// Each OCALLPART ends up being implemented as a new
-// function, a bit like a closure, with its own ODCLFUNC.
-// The OCALLPART has uses n.Func to record the linkage to
-// the generated ODCLFUNC (as n.Func.Decl), but there is no
-// pointer from the Func back to the OCALLPART.
-type Func struct {
-	Nname    Node // ONAME node
-	Decl     Node // ODCLFUNC node
-	OClosure Node // OCLOSURE node
-
-	Shortname *types.Sym
-
-	// Extra entry code for the function. For example, allocate and initialize
-	// memory for escaping parameters.
-	Enter Nodes
-	Exit  Nodes
-	// ONAME nodes for all params/locals for this func/closure, does NOT
-	// include closurevars until transformclosure runs.
-	Dcl []Node
-
-	ClosureEnter  Nodes // list of ONAME nodes of captured variables
-	ClosureType   Node  // closure representation type
-	ClosureCalled bool  // closure is only immediately called
-	ClosureVars   Nodes // closure params; each has closurevar set
-
-	// Parents records the parent scope of each scope within a
-	// function. The root scope (0) has no parent, so the i'th
-	// scope's parent is stored at Parents[i-1].
-	Parents []ScopeID
-
-	// Marks records scope boundary changes.
-	Marks []Mark
-
-	// Closgen tracks how many closures have been generated within
-	// this function. Used by closurename for creating unique
-	// function names.
-	Closgen int
-
-	FieldTrack map[*types.Sym]struct{}
-	DebugInfo  interface{}
-	LSym       *obj.LSym
-
-	Inl *Inline
-
-	Label int32 // largest auto-generated label in this function
-
-	Endlineno src.XPos
-	WBPos     src.XPos // position of first write barrier; see SetWBPos
-
-	Pragma PragmaFlag // go:xxx function annotations
-
-	flags      bitset16
-	NumDefers  int // number of defer calls in the function
-	NumReturns int // number of explicit returns in the function
-
-	// nwbrCalls records the LSyms of functions called by this
-	// function for go:nowritebarrierrec analysis. Only filled in
-	// if nowritebarrierrecCheck != nil.
-	NWBRCalls *[]SymAndPos
-}
-
-// An Inline holds fields used for function bodies that can be inlined.
-type Inline struct {
-	Cost int32 // heuristic cost of inlining this function
-
-	// Copies of Func.Dcl and Nbody for use during inlining.
-	Dcl  []Node
-	Body []Node
-}
-
-// A Mark represents a scope boundary.
-type Mark struct {
-	// Pos is the position of the token that marks the scope
-	// change.
-	Pos src.XPos
-
-	// Scope identifies the innermost scope to the right of Pos.
-	Scope ScopeID
-}
-
-// A ScopeID represents a lexical scope within a function.
-type ScopeID int32
-
-const (
-	funcDupok         = 1 << iota // duplicate definitions ok
-	funcWrapper                   // is method wrapper
-	funcNeedctxt                  // function uses context register (has closure variables)
-	funcReflectMethod             // function calls reflect.Type.Method or MethodByName
-	// true if closure inside a function; false if a simple function or a
-	// closure in a global variable initialization
-	funcIsHiddenClosure
-	funcHasDefer                 // contains a defer statement
-	funcNilCheckDisabled         // disable nil checks when compiling this function
-	funcInlinabilityChecked      // inliner has already determined whether the function is inlinable
-	funcExportInline             // include inline body in export data
-	funcInstrumentBody           // add race/msan instrumentation during SSA construction
-	funcOpenCodedDeferDisallowed // can't do open-coded defers
-)
-
-func (f *Func) Dupok() bool                    { return f.flags&funcDupok != 0 }
-func (f *Func) Wrapper() bool                  { return f.flags&funcWrapper != 0 }
-func (f *Func) Needctxt() bool                 { return f.flags&funcNeedctxt != 0 }
-func (f *Func) ReflectMethod() bool            { return f.flags&funcReflectMethod != 0 }
-func (f *Func) IsHiddenClosure() bool          { return f.flags&funcIsHiddenClosure != 0 }
-func (f *Func) HasDefer() bool                 { return f.flags&funcHasDefer != 0 }
-func (f *Func) NilCheckDisabled() bool         { return f.flags&funcNilCheckDisabled != 0 }
-func (f *Func) InlinabilityChecked() bool      { return f.flags&funcInlinabilityChecked != 0 }
-func (f *Func) ExportInline() bool             { return f.flags&funcExportInline != 0 }
-func (f *Func) InstrumentBody() bool           { return f.flags&funcInstrumentBody != 0 }
-func (f *Func) OpenCodedDeferDisallowed() bool { return f.flags&funcOpenCodedDeferDisallowed != 0 }
-
-func (f *Func) SetDupok(b bool)                    { f.flags.set(funcDupok, b) }
-func (f *Func) SetWrapper(b bool)                  { f.flags.set(funcWrapper, b) }
-func (f *Func) SetNeedctxt(b bool)                 { f.flags.set(funcNeedctxt, b) }
-func (f *Func) SetReflectMethod(b bool)            { f.flags.set(funcReflectMethod, b) }
-func (f *Func) SetIsHiddenClosure(b bool)          { f.flags.set(funcIsHiddenClosure, b) }
-func (f *Func) SetHasDefer(b bool)                 { f.flags.set(funcHasDefer, b) }
-func (f *Func) SetNilCheckDisabled(b bool)         { f.flags.set(funcNilCheckDisabled, b) }
-func (f *Func) SetInlinabilityChecked(b bool)      { f.flags.set(funcInlinabilityChecked, b) }
-func (f *Func) SetExportInline(b bool)             { f.flags.set(funcExportInline, b) }
-func (f *Func) SetInstrumentBody(b bool)           { f.flags.set(funcInstrumentBody, b) }
-func (f *Func) SetOpenCodedDeferDisallowed(b bool) { f.flags.set(funcOpenCodedDeferDisallowed, b) }
-
-func (f *Func) SetWBPos(pos src.XPos) {
-	if base.Debug.WB != 0 {
-		base.WarnfAt(pos, "write barrier")
-	}
-	if !f.WBPos.IsKnown() {
-		f.WBPos = pos
-	}
-}
-
 //go:generate stringer -type=Op -trimprefix=O
 
 type Op uint8
@@ -1111,11 +911,6 @@ const (
 	GoBuildPragma
 )
 
-type SymAndPos struct {
-	Sym *obj.LSym // LSym of callee
-	Pos src.XPos  // line of call
-}
-
 func AsNode(n types.IRNode) Node {
 	if n == nil {
 		return nil
-- 
GitLab


From c4bd0b7474f169a60acf66306a4a721f790e36c9 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 28 Nov 2020 07:23:50 -0500
Subject: [PATCH 0088/2400] [dev.regabi] cmd/compile: make ir.Func the ODCLFUNC
 Node implementation
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Before this CL, an ODCLFUNC Node was represented by both
a node struct and a Func struct (and a Name for the ONAME,
which isn't changing here). Now Func can be repurposed as
the ODCLFUNC implementation, replacing the two structs
totaling 280+144 = 424 bytes (64-bit) with a single 320-byte struct.

Using the *Func as the node also gives us a clear, typed answer to
“which node should we use to represent functions?”
The next CL will clean up uses. This CL is just the trivial
change in representation.

Passes buildall w/ toolstash -cmp.

Change-Id: Ie6d670da91d6eb8d67a85f8f83630b9586dc7443
Reviewed-on: https://go-review.googlesource.com/c/go/+/274096
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/fmt.go         |  7 +++++
 src/cmd/compile/internal/ir/func.go        | 34 ++++++++++++++++++++++
 src/cmd/compile/internal/ir/node.go        |  9 +-----
 src/cmd/compile/internal/ir/sizeof_test.go |  2 +-
 4 files changed, 43 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index e749778030..3822c4c73b 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -1269,6 +1269,13 @@ func exprFmt(n Node, s fmt.State, prec int, mode FmtMode) {
 			mode.Fprintf(s, ")")
 		}
 
+	case ODCLFUNC:
+		if sym := n.Sym(); sym != nil {
+			fmt.Fprint(s, smodeString(sym, mode))
+			return
+		}
+		mode.Fprintf(s, "<unnamed Func>")
+
 	case ONAME:
 		// Special case: name used as local variable in export.
 		// _ becomes ~b%d internally; print as _ for export
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 1566125955..57ec0707e9 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -9,6 +9,7 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/src"
+	"fmt"
 )
 
 // A Func corresponds to a single function in a Go program
@@ -47,6 +48,11 @@ import (
 // the generated ODCLFUNC (as n.Func.Decl), but there is no
 // pointer from the Func back to the OCALLPART.
 type Func struct {
+	miniNode
+	typ  *types.Type
+	body Nodes
+	iota int64
+
 	Nname    Node // ONAME node
 	Decl     Node // ODCLFUNC node
 	OClosure Node // OCLOSURE node
@@ -102,6 +108,34 @@ type Func struct {
 	NWBRCalls *[]SymAndPos
 }
 
+func NewFunc(pos src.XPos) *Func {
+	f := new(Func)
+	f.pos = pos
+	f.op = ODCLFUNC
+	f.Decl = f
+	f.iota = -1
+	return f
+}
+
+func (f *Func) String() string                { return fmt.Sprint(f) }
+func (f *Func) Format(s fmt.State, verb rune) { FmtNode(f, s, verb) }
+func (f *Func) RawCopy() Node                 { panic(f.no("RawCopy")) }
+func (f *Func) Func() *Func                   { return f }
+func (f *Func) Body() Nodes                   { return f.body }
+func (f *Func) PtrBody() *Nodes               { return &f.body }
+func (f *Func) SetBody(x Nodes)               { f.body = x }
+func (f *Func) Type() *types.Type             { return f.typ }
+func (f *Func) SetType(x *types.Type)         { f.typ = x }
+func (f *Func) Iota() int64                   { return f.iota }
+func (f *Func) SetIota(x int64)               { f.iota = x }
+
+func (f *Func) Sym() *types.Sym {
+	if f.Nname != nil {
+		return f.Nname.Sym()
+	}
+	return nil
+}
+
 // An Inline holds fields used for function bodies that can be inlined.
 type Inline struct {
 	Cost int32 // heuristic cost of inlining this function
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 1b01032c9b..02a5d7769a 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -1106,13 +1106,7 @@ func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
 	var n *node
 	switch op {
 	case ODCLFUNC:
-		var x struct {
-			n node
-			f Func
-		}
-		n = &x.n
-		n.SetFunc(&x.f)
-		n.Func().Decl = n
+		return NewFunc(pos)
 	case OPACK:
 		return NewPkgName(pos, nil, nil)
 	case OEMPTY:
@@ -1179,7 +1173,6 @@ var okForNod = [OEND]bool{
 	ODCL:           true,
 	ODCLCONST:      true,
 	ODCLFIELD:      true,
-	ODCLFUNC:       true,
 	ODCLTYPE:       true,
 	ODDD:           true,
 	ODEFER:         true,
diff --git a/src/cmd/compile/internal/ir/sizeof_test.go b/src/cmd/compile/internal/ir/sizeof_test.go
index 8a0b078b9b..8597ad492a 100644
--- a/src/cmd/compile/internal/ir/sizeof_test.go
+++ b/src/cmd/compile/internal/ir/sizeof_test.go
@@ -20,7 +20,7 @@ func TestSizeof(t *testing.T) {
 		_32bit uintptr     // size on 32bit platforms
 		_64bit uintptr     // size on 64bit platforms
 	}{
-		{Func{}, 152, 280},
+		{Func{}, 180, 320},
 		{Name{}, 132, 232},
 		{node{}, 84, 144},
 	}
-- 
GitLab


From e84b27bec587e4393533e83e3ea1cbf1ed548425 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 28 Nov 2020 07:31:18 -0500
Subject: [PATCH 0089/2400] [dev.regabi] cmd/compile: clean up Name and Func
 uses

Now that we have specific types for ONAME and ODCLFUNC nodes
(*Name and *Func), use them throughout the compiler to be more
precise about what data is being operated on.

This is a somewhat large CL, but once you start applying the types
in a few places, you end up needing to apply them to many other
places to keep everything type-checking. A lot of code also melts
away as types are added.

Passes buildall w/ toolstash -cmp.

Change-Id: I21dd9b945d701c470332bac5394fca744a5b232d
Reviewed-on: https://go-review.googlesource.com/c/go/+/274097
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/fmtmap_test.go             |   8 +-
 src/cmd/compile/internal/gc/alg.go         |  12 +-
 src/cmd/compile/internal/gc/bexport.go     |   2 +-
 src/cmd/compile/internal/gc/closure.go     | 142 ++++++-------
 src/cmd/compile/internal/gc/dcl.go         | 121 ++++++-----
 src/cmd/compile/internal/gc/dwinl.go       |   2 +
 src/cmd/compile/internal/gc/escape.go      |  80 ++++---
 src/cmd/compile/internal/gc/export.go      |   6 +-
 src/cmd/compile/internal/gc/gen.go         |  12 +-
 src/cmd/compile/internal/gc/go.go          |   6 +-
 src/cmd/compile/internal/gc/gsubr.go       |  12 +-
 src/cmd/compile/internal/gc/iexport.go     |  16 +-
 src/cmd/compile/internal/gc/iimport.go     |  34 +--
 src/cmd/compile/internal/gc/init.go        |  12 +-
 src/cmd/compile/internal/gc/initorder.go   |  10 +-
 src/cmd/compile/internal/gc/inl.go         | 231 ++++++++++-----------
 src/cmd/compile/internal/gc/main.go        |  26 +--
 src/cmd/compile/internal/gc/noder.go       |  63 +++---
 src/cmd/compile/internal/gc/obj.go         |   2 +-
 src/cmd/compile/internal/gc/order.go       |   6 +-
 src/cmd/compile/internal/gc/pgen.go        |  72 ++++---
 src/cmd/compile/internal/gc/pgen_test.go   |  18 +-
 src/cmd/compile/internal/gc/plive.go       |  22 +-
 src/cmd/compile/internal/gc/racewalk.go    |  18 +-
 src/cmd/compile/internal/gc/range.go       |   2 +-
 src/cmd/compile/internal/gc/scc.go         |  30 +--
 src/cmd/compile/internal/gc/ssa.go         |  82 ++++----
 src/cmd/compile/internal/gc/subr.go        |  15 +-
 src/cmd/compile/internal/gc/typecheck.go   |  56 ++---
 src/cmd/compile/internal/gc/walk.go        |  79 +++----
 src/cmd/compile/internal/ir/fmt.go         |  20 +-
 src/cmd/compile/internal/ir/func.go        |  34 +--
 src/cmd/compile/internal/ir/name.go        |   7 +-
 src/cmd/compile/internal/ir/sizeof_test.go |   4 +-
 34 files changed, 628 insertions(+), 634 deletions(-)

diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
index 978c83e5c2..e949a89d93 100644
--- a/src/cmd/compile/fmtmap_test.go
+++ b/src/cmd/compile/fmtmap_test.go
@@ -22,6 +22,12 @@ package main_test
 var knownFormats = map[string]string{
 	"*bytes.Buffer %s":                                "",
 	"*cmd/compile/internal/gc.EscLocation %v":         "",
+	"*cmd/compile/internal/ir.Func %+v":               "",
+	"*cmd/compile/internal/ir.Func %L":                "",
+	"*cmd/compile/internal/ir.Func %v":                "",
+	"*cmd/compile/internal/ir.Name %#v":               "",
+	"*cmd/compile/internal/ir.Name %+v":               "",
+	"*cmd/compile/internal/ir.Name %L":                "",
 	"*cmd/compile/internal/ir.Name %v":                "",
 	"*cmd/compile/internal/ir.node %v":                "",
 	"*cmd/compile/internal/ssa.Block %s":              "",
@@ -54,6 +60,7 @@ var knownFormats = map[string]string{
 	"*math/big.Float %f":                              "",
 	"*math/big.Int %s":                                "",
 	"[16]byte %x":                                     "",
+	"[]*cmd/compile/internal/ir.Name %v":              "",
 	"[]*cmd/compile/internal/ssa.Block %v":            "",
 	"[]*cmd/compile/internal/ssa.Value %v":            "",
 	"[][]string %q":                                   "",
@@ -77,7 +84,6 @@ var knownFormats = map[string]string{
 	"cmd/compile/internal/ir.Class %d":                "",
 	"cmd/compile/internal/ir.Class %v":                "",
 	"cmd/compile/internal/ir.FmtMode %d":              "",
-	"cmd/compile/internal/ir.Node %#v":                "",
 	"cmd/compile/internal/ir.Node %+S":                "",
 	"cmd/compile/internal/ir.Node %+v":                "",
 	"cmd/compile/internal/ir.Node %L":                 "",
diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index 356f0eada7..b40a56fe39 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -382,8 +382,8 @@ func genhash(t *types.Type) *obj.LSym {
 
 	funcbody()
 
-	fn.Func().SetDupok(true)
-	fn = typecheck(fn, ctxStmt)
+	fn.SetDupok(true)
+	typecheckFunc(fn)
 
 	Curfn = fn
 	typecheckslice(fn.Body().Slice(), ctxStmt)
@@ -393,7 +393,7 @@ func genhash(t *types.Type) *obj.LSym {
 		testdclstack()
 	}
 
-	fn.Func().SetNilCheckDisabled(true)
+	fn.SetNilCheckDisabled(true)
 	xtop = append(xtop, fn)
 
 	// Build closure. It doesn't close over any variables, so
@@ -761,8 +761,8 @@ func geneq(t *types.Type) *obj.LSym {
 
 	funcbody()
 
-	fn.Func().SetDupok(true)
-	fn = typecheck(fn, ctxStmt)
+	fn.SetDupok(true)
+	typecheckFunc(fn)
 
 	Curfn = fn
 	typecheckslice(fn.Body().Slice(), ctxStmt)
@@ -776,7 +776,7 @@ func geneq(t *types.Type) *obj.LSym {
 	// We are comparing a struct or an array,
 	// neither of which can be nil, and our comparisons
 	// are shallow.
-	fn.Func().SetNilCheckDisabled(true)
+	fn.SetNilCheckDisabled(true)
 	xtop = append(xtop, fn)
 
 	// Generate a closure which points at the function we just generated.
diff --git a/src/cmd/compile/internal/gc/bexport.go b/src/cmd/compile/internal/gc/bexport.go
index a470b842ff..dbbac559ae 100644
--- a/src/cmd/compile/internal/gc/bexport.go
+++ b/src/cmd/compile/internal/gc/bexport.go
@@ -16,7 +16,7 @@ type exporter struct {
 // markObject visits a reachable object.
 func (p *exporter) markObject(n ir.Node) {
 	if n.Op() == ir.ONAME && n.Class() == ir.PFUNC {
-		inlFlood(n)
+		inlFlood(n.(*ir.Name))
 	}
 
 	p.markType(n.Type())
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index 7a1078326d..0cf59ee0eb 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -17,28 +17,27 @@ func (p *noder) funcLit(expr *syntax.FuncLit) ir.Node {
 	xtype := p.typeExpr(expr.Type)
 	ntype := p.typeExpr(expr.Type)
 
-	dcl := p.nod(expr, ir.ODCLFUNC, nil, nil)
-	fn := dcl.Func()
+	fn := ir.NewFunc(p.pos(expr))
 	fn.SetIsHiddenClosure(Curfn != nil)
-	fn.Nname = newfuncnamel(p.pos(expr), ir.BlankNode.Sym(), fn) // filled in by typecheckclosure
-	fn.Nname.Name().Ntype = xtype
-	fn.Nname.Name().Defn = dcl
+	fn.Nname = newFuncNameAt(p.pos(expr), ir.BlankNode.Sym(), fn) // filled in by typecheckclosure
+	fn.Nname.Ntype = xtype
+	fn.Nname.Defn = fn
 
 	clo := p.nod(expr, ir.OCLOSURE, nil, nil)
 	clo.SetFunc(fn)
 	fn.ClosureType = ntype
 	fn.OClosure = clo
 
-	p.funcBody(dcl, expr.Body)
+	p.funcBody(fn, expr.Body)
 
 	// closure-specific variables are hanging off the
 	// ordinary ones in the symbol table; see oldname.
 	// unhook them.
 	// make the list of pointers for the closure call.
-	for _, v := range fn.ClosureVars.Slice() {
+	for _, v := range fn.ClosureVars {
 		// Unlink from v1; see comment in syntax.go type Param for these fields.
-		v1 := v.Name().Defn
-		v1.Name().Innermost = v.Name().Outer
+		v1 := v.Defn
+		v1.Name().Innermost = v.Outer
 
 		// If the closure usage of v is not dense,
 		// we need to make it dense; now that we're out
@@ -68,7 +67,7 @@ func (p *noder) funcLit(expr *syntax.FuncLit) ir.Node {
 		// obtains f3's v, creating it if necessary (as it is in the example).
 		//
 		// capturevars will decide whether to use v directly or &v.
-		v.Name().Outer = oldname(v.Sym()).(*ir.Name)
+		v.Outer = oldname(v.Sym()).(*ir.Name)
 	}
 
 	return clo
@@ -80,26 +79,25 @@ func (p *noder) funcLit(expr *syntax.FuncLit) ir.Node {
 // separate pass from type-checking.
 func typecheckclosure(clo ir.Node, top int) {
 	fn := clo.Func()
-	dcl := fn.Decl
 	// Set current associated iota value, so iota can be used inside
 	// function in ConstSpec, see issue #22344
 	if x := getIotaValue(); x >= 0 {
-		dcl.SetIota(x)
+		fn.SetIota(x)
 	}
 
 	fn.ClosureType = typecheck(fn.ClosureType, ctxType)
 	clo.SetType(fn.ClosureType.Type())
-	fn.ClosureCalled = top&ctxCallee != 0
+	fn.SetClosureCalled(top&ctxCallee != 0)
 
-	// Do not typecheck dcl twice, otherwise, we will end up pushing
-	// dcl to xtop multiple times, causing initLSym called twice.
+	// Do not typecheck fn twice, otherwise, we will end up pushing
+	// fn to xtop multiple times, causing initLSym called twice.
 	// See #30709
-	if dcl.Typecheck() == 1 {
+	if fn.Typecheck() == 1 {
 		return
 	}
 
-	for _, ln := range fn.ClosureVars.Slice() {
-		n := ln.Name().Defn
+	for _, ln := range fn.ClosureVars {
+		n := ln.Defn
 		if !n.Name().Captured() {
 			n.Name().SetCaptured(true)
 			if n.Name().Decldepth == 0 {
@@ -116,7 +114,7 @@ func typecheckclosure(clo ir.Node, top int) {
 
 	fn.Nname.SetSym(closurename(Curfn))
 	setNodeNameFunc(fn.Nname)
-	dcl = typecheck(dcl, ctxStmt)
+	typecheckFunc(fn)
 
 	// Type check the body now, but only if we're inside a function.
 	// At top level (in a variable initialization: curfn==nil) we're not
@@ -124,29 +122,29 @@ func typecheckclosure(clo ir.Node, top int) {
 	// underlying closure function we create is added to xtop.
 	if Curfn != nil && clo.Type() != nil {
 		oldfn := Curfn
-		Curfn = dcl
+		Curfn = fn
 		olddd := decldepth
 		decldepth = 1
-		typecheckslice(dcl.Body().Slice(), ctxStmt)
+		typecheckslice(fn.Body().Slice(), ctxStmt)
 		decldepth = olddd
 		Curfn = oldfn
 	}
 
-	xtop = append(xtop, dcl)
+	xtop = append(xtop, fn)
 }
 
 // globClosgen is like Func.Closgen, but for the global scope.
-var globClosgen int
+var globClosgen int32
 
 // closurename generates a new unique name for a closure within
 // outerfunc.
-func closurename(outerfunc ir.Node) *types.Sym {
+func closurename(outerfunc *ir.Func) *types.Sym {
 	outer := "glob."
 	prefix := "func"
 	gen := &globClosgen
 
 	if outerfunc != nil {
-		if outerfunc.Func().OClosure != nil {
+		if outerfunc.OClosure != nil {
 			prefix = ""
 		}
 
@@ -155,8 +153,8 @@ func closurename(outerfunc ir.Node) *types.Sym {
 		// There may be multiple functions named "_". In those
 		// cases, we can't use their individual Closgens as it
 		// would lead to name clashes.
-		if !ir.IsBlank(outerfunc.Func().Nname) {
-			gen = &outerfunc.Func().Closgen
+		if !ir.IsBlank(outerfunc.Nname) {
+			gen = &outerfunc.Closgen
 		}
 	}
 
@@ -172,11 +170,10 @@ var capturevarscomplete bool
 // by value or by reference.
 // We use value capturing for values <= 128 bytes that are never reassigned
 // after capturing (effectively constant).
-func capturevars(dcl ir.Node) {
+func capturevars(fn *ir.Func) {
 	lno := base.Pos
-	base.Pos = dcl.Pos()
-	fn := dcl.Func()
-	cvars := fn.ClosureVars.Slice()
+	base.Pos = fn.Pos()
+	cvars := fn.ClosureVars
 	out := cvars[:0]
 	for _, v := range cvars {
 		if v.Type() == nil {
@@ -195,12 +192,12 @@ func capturevars(dcl ir.Node) {
 		dowidth(v.Type())
 
 		var outer ir.Node
-		outer = v.Name().Outer
-		outermost := v.Name().Defn
+		outer = v.Outer
+		outermost := v.Defn
 
 		// out parameters will be assigned to implicitly upon return.
 		if outermost.Class() != ir.PPARAMOUT && !outermost.Name().Addrtaken() && !outermost.Name().Assigned() && v.Type().Width <= 128 {
-			v.Name().SetByval(true)
+			v.SetByval(true)
 		} else {
 			outermost.Name().SetAddrtaken(true)
 			outer = ir.Nod(ir.OADDR, outer, nil)
@@ -208,11 +205,11 @@ func capturevars(dcl ir.Node) {
 
 		if base.Flag.LowerM > 1 {
 			var name *types.Sym
-			if v.Name().Curfn != nil && v.Name().Curfn.Func().Nname != nil {
-				name = v.Name().Curfn.Func().Nname.Sym()
+			if v.Curfn != nil && v.Curfn.Nname != nil {
+				name = v.Curfn.Sym()
 			}
 			how := "ref"
-			if v.Name().Byval() {
+			if v.Byval() {
 				how = "value"
 			}
 			base.WarnfAt(v.Pos(), "%v capturing by %s: %v (addr=%v assign=%v width=%d)", name, how, v.Sym(), outermost.Name().Addrtaken(), outermost.Name().Assigned(), int32(v.Type().Width))
@@ -222,18 +219,17 @@ func capturevars(dcl ir.Node) {
 		fn.ClosureEnter.Append(outer)
 	}
 
-	fn.ClosureVars.Set(out)
+	fn.ClosureVars = out
 	base.Pos = lno
 }
 
 // transformclosure is called in a separate phase after escape analysis.
 // It transform closure bodies to properly reference captured variables.
-func transformclosure(dcl ir.Node) {
+func transformclosure(fn *ir.Func) {
 	lno := base.Pos
-	base.Pos = dcl.Pos()
-	fn := dcl.Func()
+	base.Pos = fn.Pos()
 
-	if fn.ClosureCalled {
+	if fn.ClosureCalled() {
 		// If the closure is directly called, we transform it to a plain function call
 		// with variables passed as args. This avoids allocation of a closure object.
 		// Here we do only a part of the transformation. Walk of OCALLFUNC(OCLOSURE)
@@ -254,16 +250,16 @@ func transformclosure(dcl ir.Node) {
 
 		// We are going to insert captured variables before input args.
 		var params []*types.Field
-		var decls []ir.Node
-		for _, v := range fn.ClosureVars.Slice() {
-			if !v.Name().Byval() {
+		var decls []*ir.Name
+		for _, v := range fn.ClosureVars {
+			if !v.Byval() {
 				// If v of type T is captured by reference,
 				// we introduce function param &v *T
 				// and v remains PAUTOHEAP with &v heapaddr
 				// (accesses will implicitly deref &v).
 				addr := NewName(lookup("&" + v.Sym().Name))
 				addr.SetType(types.NewPtr(v.Type()))
-				v.Name().Heapaddr = addr
+				v.Heapaddr = addr
 				v = addr
 			}
 
@@ -282,24 +278,24 @@ func transformclosure(dcl ir.Node) {
 		}
 
 		dowidth(f.Type())
-		dcl.SetType(f.Type()) // update type of ODCLFUNC
+		fn.SetType(f.Type()) // update type of ODCLFUNC
 	} else {
 		// The closure is not called, so it is going to stay as closure.
 		var body []ir.Node
 		offset := int64(Widthptr)
-		for _, v := range fn.ClosureVars.Slice() {
+		for _, v := range fn.ClosureVars {
 			// cv refers to the field inside of closure OSTRUCTLIT.
 			cv := ir.Nod(ir.OCLOSUREVAR, nil, nil)
 
 			cv.SetType(v.Type())
-			if !v.Name().Byval() {
+			if !v.Byval() {
 				cv.SetType(types.NewPtr(v.Type()))
 			}
 			offset = Rnd(offset, int64(cv.Type().Align))
 			cv.SetOffset(offset)
 			offset += cv.Type().Width
 
-			if v.Name().Byval() && v.Type().Width <= int64(2*Widthptr) {
+			if v.Byval() && v.Type().Width <= int64(2*Widthptr) {
 				// If it is a small variable captured by value, downgrade it to PAUTO.
 				v.SetClass(ir.PAUTO)
 				fn.Dcl = append(fn.Dcl, v)
@@ -310,11 +306,11 @@ func transformclosure(dcl ir.Node) {
 				addr := NewName(lookup("&" + v.Sym().Name))
 				addr.SetType(types.NewPtr(v.Type()))
 				addr.SetClass(ir.PAUTO)
-				addr.Name().SetUsed(true)
-				addr.Name().Curfn = dcl
+				addr.SetUsed(true)
+				addr.Curfn = fn
 				fn.Dcl = append(fn.Dcl, addr)
-				v.Name().Heapaddr = addr
-				if v.Name().Byval() {
+				v.Heapaddr = addr
+				if v.Byval() {
 					cv = ir.Nod(ir.OADDR, cv, nil)
 				}
 				body = append(body, ir.Nod(ir.OAS, addr, cv))
@@ -334,7 +330,7 @@ func transformclosure(dcl ir.Node) {
 // hasemptycvars reports whether closure clo has an
 // empty list of captured vars.
 func hasemptycvars(clo ir.Node) bool {
-	return clo.Func().ClosureVars.Len() == 0
+	return len(clo.Func().ClosureVars) == 0
 }
 
 // closuredebugruntimecheck applies boilerplate checks for debug flags
@@ -372,9 +368,9 @@ func closureType(clo ir.Node) *types.Type {
 	fields := []ir.Node{
 		namedfield(".F", types.Types[types.TUINTPTR]),
 	}
-	for _, v := range clo.Func().ClosureVars.Slice() {
+	for _, v := range clo.Func().ClosureVars {
 		typ := v.Type()
-		if !v.Name().Byval() {
+		if !v.Byval() {
 			typ = types.NewPtr(typ)
 		}
 		fields = append(fields, symfield(v.Sym(), typ))
@@ -430,23 +426,24 @@ func typecheckpartialcall(dot ir.Node, sym *types.Sym) {
 	}
 
 	// Create top-level function.
-	dcl := makepartialcall(dot, dot.Type(), sym)
-	dcl.Func().SetWrapper(true)
+	fn := makepartialcall(dot, dot.Type(), sym)
+	fn.SetWrapper(true)
+
 	dot.SetOp(ir.OCALLPART)
 	dot.SetRight(NewName(sym))
-	dot.SetType(dcl.Type())
-	dot.SetFunc(dcl.Func())
+	dot.SetType(fn.Type())
+	dot.SetFunc(fn)
 	dot.SetOpt(nil) // clear types.Field from ODOTMETH
 }
 
 // makepartialcall returns a DCLFUNC node representing the wrapper function (*-fm) needed
 // for partial calls.
-func makepartialcall(dot ir.Node, t0 *types.Type, meth *types.Sym) ir.Node {
+func makepartialcall(dot ir.Node, t0 *types.Type, meth *types.Sym) *ir.Func {
 	rcvrtype := dot.Left().Type()
 	sym := methodSymSuffix(rcvrtype, meth, "-fm")
 
 	if sym.Uniq() {
-		return ir.AsNode(sym.Def)
+		return ir.AsNode(sym.Def).(*ir.Func)
 	}
 	sym.SetUniq(true)
 
@@ -469,8 +466,7 @@ func makepartialcall(dot ir.Node, t0 *types.Type, meth *types.Sym) ir.Node {
 	tfn.PtrList().Set(structargs(t0.Params(), true))
 	tfn.PtrRlist().Set(structargs(t0.Results(), false))
 
-	dcl := dclfunc(sym, tfn)
-	fn := dcl.Func()
+	fn := dclfunc(sym, tfn)
 	fn.SetDupok(true)
 	fn.SetNeedctxt(true)
 
@@ -484,7 +480,7 @@ func makepartialcall(dot ir.Node, t0 *types.Type, meth *types.Sym) ir.Node {
 
 	ptr := NewName(lookup(".this"))
 	declare(ptr, ir.PAUTO)
-	ptr.Name().SetUsed(true)
+	ptr.SetUsed(true)
 	var body []ir.Node
 	if rcvrtype.IsPtr() || rcvrtype.IsInterface() {
 		ptr.SetType(rcvrtype)
@@ -504,20 +500,20 @@ func makepartialcall(dot ir.Node, t0 *types.Type, meth *types.Sym) ir.Node {
 	}
 	body = append(body, call)
 
-	dcl.PtrBody().Set(body)
+	fn.PtrBody().Set(body)
 	funcbody()
 
-	dcl = typecheck(dcl, ctxStmt)
+	typecheckFunc(fn)
 	// Need to typecheck the body of the just-generated wrapper.
 	// typecheckslice() requires that Curfn is set when processing an ORETURN.
-	Curfn = dcl
-	typecheckslice(dcl.Body().Slice(), ctxStmt)
-	sym.Def = dcl
-	xtop = append(xtop, dcl)
+	Curfn = fn
+	typecheckslice(fn.Body().Slice(), ctxStmt)
+	sym.Def = fn
+	xtop = append(xtop, fn)
 	Curfn = savecurfn
 	base.Pos = saveLineNo
 
-	return dcl
+	return fn
 }
 
 // partialCallType returns the struct type used to hold all the information
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 04e6e7a596..2bcee269d9 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -58,7 +58,7 @@ var declare_typegen int
 
 // declare records that Node n declares symbol n.Sym in the specified
 // declaration context.
-func declare(n ir.Node, ctxt ir.Class) {
+func declare(n *ir.Name, ctxt ir.Class) {
 	if ir.IsBlank(n) {
 		return
 	}
@@ -85,7 +85,7 @@ func declare(n ir.Node, ctxt ir.Class) {
 			base.Fatalf("automatic outside function")
 		}
 		if Curfn != nil && ctxt != ir.PFUNC {
-			Curfn.Func().Dcl = append(Curfn.Func().Dcl, n)
+			Curfn.Dcl = append(Curfn.Dcl, n)
 		}
 		if n.Op() == ir.OTYPE {
 			declare_typegen++
@@ -122,7 +122,7 @@ func declare(n ir.Node, ctxt ir.Class) {
 	autoexport(n, ctxt)
 }
 
-func addvar(n ir.Node, t *types.Type, ctxt ir.Class) {
+func addvar(n *ir.Name, t *types.Type, ctxt ir.Class) {
 	if n == nil || n.Sym() == nil || (n.Op() != ir.ONAME && n.Op() != ir.ONONAME) || t == nil {
 		base.Fatalf("addvar: n=%v t=%v nil", n, t)
 	}
@@ -144,10 +144,11 @@ func variter(vl []ir.Node, t ir.Node, el []ir.Node) []ir.Node {
 		as2.PtrList().Set(vl)
 		as2.PtrRlist().Set1(e)
 		for _, v := range vl {
+			v := v.(*ir.Name)
 			v.SetOp(ir.ONAME)
 			declare(v, dclcontext)
-			v.Name().Ntype = t
-			v.Name().Defn = as2
+			v.Ntype = t
+			v.Defn = as2
 			if Curfn != nil {
 				init = append(init, ir.Nod(ir.ODCL, v, nil))
 			}
@@ -158,6 +159,7 @@ func variter(vl []ir.Node, t ir.Node, el []ir.Node) []ir.Node {
 
 	nel := len(el)
 	for _, v := range vl {
+		v := v.(*ir.Name)
 		var e ir.Node
 		if doexpr {
 			if len(el) == 0 {
@@ -170,7 +172,7 @@ func variter(vl []ir.Node, t ir.Node, el []ir.Node) []ir.Node {
 
 		v.SetOp(ir.ONAME)
 		declare(v, dclcontext)
-		v.Name().Ntype = t
+		v.Ntype = t
 
 		if e != nil || Curfn != nil || ir.IsBlank(v) {
 			if Curfn != nil {
@@ -179,7 +181,7 @@ func variter(vl []ir.Node, t ir.Node, el []ir.Node) []ir.Node {
 			e = ir.Nod(ir.OAS, v, e)
 			init = append(init, e)
 			if e.Right() != nil {
-				v.Name().Defn = e
+				v.Defn = e
 			}
 		}
 	}
@@ -200,10 +202,10 @@ func newnoname(s *types.Sym) ir.Node {
 	return n
 }
 
-// newfuncnamel generates a new name node for a function or method.
-func newfuncnamel(pos src.XPos, s *types.Sym, fn *ir.Func) ir.Node {
+// newFuncNameAt generates a new name node for a function or method.
+func newFuncNameAt(pos src.XPos, s *types.Sym, fn *ir.Func) *ir.Name {
 	if fn.Nname != nil {
-		base.Fatalf("newfuncnamel - already have name")
+		base.Fatalf("newFuncName - already have name")
 	}
 	n := ir.NewNameAt(pos, s)
 	n.SetFunc(fn)
@@ -271,20 +273,20 @@ func oldname(s *types.Sym) ir.Node {
 		// the := it looks like a reference to the outer x so we'll
 		// make x a closure variable unnecessarily.
 		c := n.Name().Innermost
-		if c == nil || c.Name().Curfn != Curfn {
+		if c == nil || c.Curfn != Curfn {
 			// Do not have a closure var for the active closure yet; make one.
 			c = NewName(s)
 			c.SetClass(ir.PAUTOHEAP)
-			c.Name().SetIsClosureVar(true)
+			c.SetIsClosureVar(true)
 			c.SetIsDDD(n.IsDDD())
-			c.Name().Defn = n
+			c.Defn = n
 
 			// Link into list of active closure variables.
 			// Popped from list in func funcLit.
-			c.Name().Outer = n.Name().Innermost
+			c.Outer = n.Name().Innermost
 			n.Name().Innermost = c
 
-			Curfn.Func().ClosureVars.Append(c)
+			Curfn.ClosureVars = append(Curfn.ClosureVars, c)
 		}
 
 		// return ref to closure var, not original
@@ -349,7 +351,7 @@ func colasdefn(left []ir.Node, defn ir.Node) {
 		}
 
 		nnew++
-		n = NewName(n.Sym())
+		n := NewName(n.Sym())
 		declare(n, dclcontext)
 		n.Name().Defn = defn
 		defn.PtrInit().Append(ir.Nod(ir.ODCL, n, nil))
@@ -377,18 +379,18 @@ func ifacedcl(n ir.Node) {
 // and declare the arguments.
 // called in extern-declaration context
 // returns in auto-declaration context.
-func funchdr(n ir.Node) {
+func funchdr(fn *ir.Func) {
 	// change the declaration context from extern to auto
 	funcStack = append(funcStack, funcStackEnt{Curfn, dclcontext})
-	Curfn = n
+	Curfn = fn
 	dclcontext = ir.PAUTO
 
 	types.Markdcl()
 
-	if n.Func().Nname != nil && n.Func().Nname.Name().Ntype != nil {
-		funcargs(n.Func().Nname.Name().Ntype)
+	if fn.Nname != nil && fn.Nname.Ntype != nil {
+		funcargs(fn.Nname.Ntype)
 	} else {
-		funcargs2(n.Type())
+		funcargs2(fn.Type())
 	}
 }
 
@@ -450,10 +452,11 @@ func funcarg(n ir.Node, ctxt ir.Class) {
 		return
 	}
 
-	n.SetRight(ir.NewNameAt(n.Pos(), n.Sym()))
-	n.Right().Name().Ntype = n.Left()
-	n.Right().SetIsDDD(n.IsDDD())
-	declare(n.Right(), ctxt)
+	name := ir.NewNameAt(n.Pos(), n.Sym())
+	n.SetRight(name)
+	name.Ntype = n.Left()
+	name.SetIsDDD(n.IsDDD())
+	declare(name, ctxt)
 
 	vargen++
 	n.Right().Name().Vargen = int32(vargen)
@@ -492,7 +495,7 @@ func funcarg2(f *types.Field, ctxt ir.Class) {
 var funcStack []funcStackEnt // stack of previous values of Curfn/dclcontext
 
 type funcStackEnt struct {
-	curfn      ir.Node
+	curfn      *ir.Func
 	dclcontext ir.Class
 }
 
@@ -937,18 +940,18 @@ func setNodeNameFunc(n ir.Node) {
 	n.Sym().SetFunc(true)
 }
 
-func dclfunc(sym *types.Sym, tfn ir.Node) ir.Node {
+func dclfunc(sym *types.Sym, tfn ir.Node) *ir.Func {
 	if tfn.Op() != ir.OTFUNC {
 		base.Fatalf("expected OTFUNC node, got %v", tfn)
 	}
 
-	fn := ir.Nod(ir.ODCLFUNC, nil, nil)
-	fn.Func().Nname = newfuncnamel(base.Pos, sym, fn.Func())
-	fn.Func().Nname.Name().Defn = fn
-	fn.Func().Nname.Name().Ntype = tfn
-	setNodeNameFunc(fn.Func().Nname)
+	fn := ir.NewFunc(base.Pos)
+	fn.Nname = newFuncNameAt(base.Pos, sym, fn)
+	fn.Nname.Defn = fn
+	fn.Nname.Ntype = tfn
+	setNodeNameFunc(fn.Nname)
 	funchdr(fn)
-	fn.Func().Nname.Name().Ntype = typecheck(fn.Func().Nname.Name().Ntype, ctxType)
+	fn.Nname.Ntype = typecheck(fn.Nname.Ntype, ctxType)
 	return fn
 }
 
@@ -959,11 +962,11 @@ type nowritebarrierrecChecker struct {
 	extraCalls map[ir.Node][]nowritebarrierrecCall
 
 	// curfn is the current function during AST walks.
-	curfn ir.Node
+	curfn *ir.Func
 }
 
 type nowritebarrierrecCall struct {
-	target ir.Node  // ODCLFUNC of caller or callee
+	target *ir.Func // caller or callee
 	lineno src.XPos // line of call
 }
 
@@ -983,7 +986,7 @@ func newNowritebarrierrecChecker() *nowritebarrierrecChecker {
 		if n.Op() != ir.ODCLFUNC {
 			continue
 		}
-		c.curfn = n
+		c.curfn = n.(*ir.Func)
 		ir.Inspect(n, c.findExtraCalls)
 	}
 	c.curfn = nil
@@ -1002,13 +1005,13 @@ func (c *nowritebarrierrecChecker) findExtraCalls(n ir.Node) bool {
 		return true
 	}
 
-	var callee ir.Node
+	var callee *ir.Func
 	arg := n.List().First()
 	switch arg.Op() {
 	case ir.ONAME:
-		callee = arg.Name().Defn
+		callee = arg.Name().Defn.(*ir.Func)
 	case ir.OCLOSURE:
-		callee = arg.Func().Decl
+		callee = arg.Func()
 	default:
 		base.Fatalf("expected ONAME or OCLOSURE node, got %+v", arg)
 	}
@@ -1027,13 +1030,8 @@ func (c *nowritebarrierrecChecker) findExtraCalls(n ir.Node) bool {
 // because that's all we know after we start SSA.
 //
 // This can be called concurrently for different from Nodes.
-func (c *nowritebarrierrecChecker) recordCall(from ir.Node, to *obj.LSym, pos src.XPos) {
-	if from.Op() != ir.ODCLFUNC {
-		base.Fatalf("expected ODCLFUNC, got %v", from)
-	}
-	// We record this information on the *Func so this is
-	// concurrent-safe.
-	fn := from.Func()
+func (c *nowritebarrierrecChecker) recordCall(fn *ir.Func, to *obj.LSym, pos src.XPos) {
+	// We record this information on the *Func so this is concurrent-safe.
 	if fn.NWBRCalls == nil {
 		fn.NWBRCalls = new([]ir.SymAndPos)
 	}
@@ -1045,7 +1043,7 @@ func (c *nowritebarrierrecChecker) check() {
 	// capture all calls created by lowering, but this means we
 	// only get to see the obj.LSyms of calls. symToFunc lets us
 	// get back to the ODCLFUNCs.
-	symToFunc := make(map[*obj.LSym]ir.Node)
+	symToFunc := make(map[*obj.LSym]*ir.Func)
 	// funcs records the back-edges of the BFS call graph walk. It
 	// maps from the ODCLFUNC of each function that must not have
 	// write barriers to the call that inhibits them. Functions
@@ -1060,24 +1058,25 @@ func (c *nowritebarrierrecChecker) check() {
 		if n.Op() != ir.ODCLFUNC {
 			continue
 		}
+		fn := n.(*ir.Func)
 
-		symToFunc[n.Func().LSym] = n
+		symToFunc[fn.LSym] = fn
 
 		// Make nowritebarrierrec functions BFS roots.
-		if n.Func().Pragma&ir.Nowritebarrierrec != 0 {
-			funcs[n] = nowritebarrierrecCall{}
-			q.PushRight(n)
+		if fn.Pragma&ir.Nowritebarrierrec != 0 {
+			funcs[fn] = nowritebarrierrecCall{}
+			q.PushRight(fn)
 		}
 		// Check go:nowritebarrier functions.
-		if n.Func().Pragma&ir.Nowritebarrier != 0 && n.Func().WBPos.IsKnown() {
-			base.ErrorfAt(n.Func().WBPos, "write barrier prohibited")
+		if fn.Pragma&ir.Nowritebarrier != 0 && fn.WBPos.IsKnown() {
+			base.ErrorfAt(fn.WBPos, "write barrier prohibited")
 		}
 	}
 
 	// Perform a BFS of the call graph from all
 	// go:nowritebarrierrec functions.
-	enqueue := func(src, target ir.Node, pos src.XPos) {
-		if target.Func().Pragma&ir.Yeswritebarrierrec != 0 {
+	enqueue := func(src, target *ir.Func, pos src.XPos) {
+		if target.Pragma&ir.Yeswritebarrierrec != 0 {
 			// Don't flow into this function.
 			return
 		}
@@ -1091,17 +1090,17 @@ func (c *nowritebarrierrecChecker) check() {
 		q.PushRight(target)
 	}
 	for !q.Empty() {
-		fn := q.PopLeft()
+		fn := q.PopLeft().(*ir.Func)
 
 		// Check fn.
-		if fn.Func().WBPos.IsKnown() {
+		if fn.WBPos.IsKnown() {
 			var err bytes.Buffer
 			call := funcs[fn]
 			for call.target != nil {
-				fmt.Fprintf(&err, "\n\t%v: called by %v", base.FmtPos(call.lineno), call.target.Func().Nname)
+				fmt.Fprintf(&err, "\n\t%v: called by %v", base.FmtPos(call.lineno), call.target.Nname)
 				call = funcs[call.target]
 			}
-			base.ErrorfAt(fn.Func().WBPos, "write barrier prohibited by caller; %v%s", fn.Func().Nname, err.String())
+			base.ErrorfAt(fn.WBPos, "write barrier prohibited by caller; %v%s", fn.Nname, err.String())
 			continue
 		}
 
@@ -1109,10 +1108,10 @@ func (c *nowritebarrierrecChecker) check() {
 		for _, callee := range c.extraCalls[fn] {
 			enqueue(fn, callee.target, callee.lineno)
 		}
-		if fn.Func().NWBRCalls == nil {
+		if fn.NWBRCalls == nil {
 			continue
 		}
-		for _, callee := range *fn.Func().NWBRCalls {
+		for _, callee := range *fn.NWBRCalls {
 			target := symToFunc[callee.Sym]
 			if target != nil {
 				enqueue(fn, target, callee.Pos)
diff --git a/src/cmd/compile/internal/gc/dwinl.go b/src/cmd/compile/internal/gc/dwinl.go
index 1e4e43caad..d9eb930037 100644
--- a/src/cmd/compile/internal/gc/dwinl.go
+++ b/src/cmd/compile/internal/gc/dwinl.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
 	"cmd/internal/dwarf"
 	"cmd/internal/obj"
 	"cmd/internal/src"
@@ -211,6 +212,7 @@ func genAbstractFunc(fn *obj.LSym) {
 		base.Ctxt.Diag("failed to locate precursor fn for %v", fn)
 		return
 	}
+	_ = ifn.(*ir.Func)
 	if base.Debug.DwarfInl != 0 {
 		base.Ctxt.Logf("DwarfAbstractFunc(%v)\n", fn.Name)
 	}
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 351643ef5d..4bddb7f0f4 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -87,7 +87,7 @@ type Escape struct {
 	allLocs []*EscLocation
 	labels  map[*types.Sym]labelState // known labels
 
-	curfn ir.Node
+	curfn *ir.Func
 
 	// loopDepth counts the current loop nesting depth within
 	// curfn. It increments within each "for" loop and at each
@@ -103,7 +103,7 @@ type Escape struct {
 // variable.
 type EscLocation struct {
 	n         ir.Node   // represented variable or expression, if any
-	curfn     ir.Node   // enclosing function
+	curfn     *ir.Func  // enclosing function
 	edges     []EscEdge // incoming edges
 	loopDepth int       // loopDepth at declaration
 
@@ -180,7 +180,7 @@ func escFmt(n ir.Node, short bool) string {
 
 // escapeFuncs performs escape analysis on a minimal batch of
 // functions.
-func escapeFuncs(fns []ir.Node, recursive bool) {
+func escapeFuncs(fns []*ir.Func, recursive bool) {
 	for _, fn := range fns {
 		if fn.Op() != ir.ODCLFUNC {
 			base.Fatalf("unexpected node: %v", fn)
@@ -203,8 +203,8 @@ func escapeFuncs(fns []ir.Node, recursive bool) {
 	e.finish(fns)
 }
 
-func (e *Escape) initFunc(fn ir.Node) {
-	if fn.Op() != ir.ODCLFUNC || fn.Esc() != EscFuncUnknown {
+func (e *Escape) initFunc(fn *ir.Func) {
+	if fn.Esc() != EscFuncUnknown {
 		base.Fatalf("unexpected node: %v", fn)
 	}
 	fn.SetEsc(EscFuncPlanned)
@@ -216,14 +216,14 @@ func (e *Escape) initFunc(fn ir.Node) {
 	e.loopDepth = 1
 
 	// Allocate locations for local variables.
-	for _, dcl := range fn.Func().Dcl {
+	for _, dcl := range fn.Dcl {
 		if dcl.Op() == ir.ONAME {
 			e.newLoc(dcl, false)
 		}
 	}
 }
 
-func (e *Escape) walkFunc(fn ir.Node) {
+func (e *Escape) walkFunc(fn *ir.Func) {
 	fn.SetEsc(EscFuncStarted)
 
 	// Identify labels that mark the head of an unstructured loop.
@@ -589,7 +589,8 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 		for i := m.Type.NumResults(); i > 0; i-- {
 			ks = append(ks, e.heapHole())
 		}
-		paramK := e.tagHole(ks, ir.AsNode(m.Nname), m.Type.Recv())
+		name, _ := m.Nname.(*ir.Name)
+		paramK := e.tagHole(ks, name, m.Type.Recv())
 
 		e.expr(e.teeHole(paramK, closureK), n.Left())
 
@@ -633,17 +634,13 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 		k = e.spill(k, n)
 
 		// Link addresses of captured variables to closure.
-		for _, v := range n.Func().ClosureVars.Slice() {
-			if v.Op() == ir.OXXX { // unnamed out argument; see dcl.go:/^funcargs
-				continue
-			}
-
+		for _, v := range n.Func().ClosureVars {
 			k := k
-			if !v.Name().Byval() {
+			if !v.Byval() {
 				k = k.addr(v, "reference")
 			}
 
-			e.expr(k.note(n, "captured by a closure"), v.Name().Defn)
+			e.expr(k.note(n, "captured by a closure"), v.Defn)
 		}
 
 	case ir.ORUNES2STR, ir.OBYTES2STR, ir.OSTR2RUNES, ir.OSTR2BYTES, ir.ORUNESTR:
@@ -813,12 +810,12 @@ func (e *Escape) call(ks []EscHole, call, where ir.Node) {
 		fixVariadicCall(call)
 
 		// Pick out the function callee, if statically known.
-		var fn ir.Node
+		var fn *ir.Name
 		switch call.Op() {
 		case ir.OCALLFUNC:
 			switch v := staticValue(call.Left()); {
 			case v.Op() == ir.ONAME && v.Class() == ir.PFUNC:
-				fn = v
+				fn = v.(*ir.Name)
 			case v.Op() == ir.OCLOSURE:
 				fn = v.Func().Nname
 			}
@@ -902,7 +899,7 @@ func (e *Escape) call(ks []EscHole, call, where ir.Node) {
 // ks should contain the holes representing where the function
 // callee's results flows. fn is the statically-known callee function,
 // if any.
-func (e *Escape) tagHole(ks []EscHole, fn ir.Node, param *types.Field) EscHole {
+func (e *Escape) tagHole(ks []EscHole, fn *ir.Name, param *types.Field) EscHole {
 	// If this is a dynamic call, we can't rely on param.Note.
 	if fn == nil {
 		return e.heapHole()
@@ -943,9 +940,9 @@ func (e *Escape) tagHole(ks []EscHole, fn ir.Node, param *types.Field) EscHole {
 // fn has not yet been analyzed, so its parameters and results
 // should be incorporated directly into the flow graph instead of
 // relying on its escape analysis tagging.
-func (e *Escape) inMutualBatch(fn ir.Node) bool {
-	if fn.Name().Defn != nil && fn.Name().Defn.Esc() < EscFuncTagged {
-		if fn.Name().Defn.Esc() == EscFuncUnknown {
+func (e *Escape) inMutualBatch(fn *ir.Name) bool {
+	if fn.Defn != nil && fn.Defn.Esc() < EscFuncTagged {
+		if fn.Defn.Esc() == EscFuncUnknown {
 			base.Fatalf("graph inconsistency")
 		}
 		return true
@@ -1368,7 +1365,7 @@ func (e *Escape) outlives(l, other *EscLocation) bool {
 		//
 		//    var u int  // okay to stack allocate
 		//    *(func() *int { return &u }()) = 42
-		if containsClosure(other.curfn, l.curfn) && l.curfn.Func().ClosureCalled {
+		if containsClosure(other.curfn, l.curfn) && l.curfn.ClosureCalled() {
 			return false
 		}
 
@@ -1402,11 +1399,7 @@ func (e *Escape) outlives(l, other *EscLocation) bool {
 }
 
 // containsClosure reports whether c is a closure contained within f.
-func containsClosure(f, c ir.Node) bool {
-	if f.Op() != ir.ODCLFUNC || c.Op() != ir.ODCLFUNC {
-		base.Fatalf("bad containsClosure: %v, %v", f, c)
-	}
-
+func containsClosure(f, c *ir.Func) bool {
 	// Common case.
 	if f == c {
 		return false
@@ -1414,8 +1407,8 @@ func containsClosure(f, c ir.Node) bool {
 
 	// Closures within function Foo are named like "Foo.funcN..."
 	// TODO(mdempsky): Better way to recognize this.
-	fn := f.Func().Nname.Sym().Name
-	cn := c.Func().Nname.Sym().Name
+	fn := f.Sym().Name
+	cn := c.Sym().Name
 	return len(cn) > len(fn) && cn[:len(fn)] == fn && cn[len(fn)] == '.'
 }
 
@@ -1437,7 +1430,7 @@ func (l *EscLocation) leakTo(sink *EscLocation, derefs int) {
 	l.paramEsc.AddHeap(derefs)
 }
 
-func (e *Escape) finish(fns []ir.Node) {
+func (e *Escape) finish(fns []*ir.Func) {
 	// Record parameter tags for package export data.
 	for _, fn := range fns {
 		fn.SetEsc(EscFuncTagged)
@@ -1614,12 +1607,12 @@ const (
 	EscNever   // By construction will not escape.
 )
 
-// funcSym returns fn.Func.Nname.Sym if no nils are encountered along the way.
-func funcSym(fn ir.Node) *types.Sym {
-	if fn == nil || fn.Func().Nname == nil {
+// funcSym returns fn.Nname.Sym if no nils are encountered along the way.
+func funcSym(fn *ir.Func) *types.Sym {
+	if fn == nil || fn.Nname == nil {
 		return nil
 	}
-	return fn.Func().Nname.Sym()
+	return fn.Sym()
 }
 
 // Mark labels that have no backjumps to them as not increasing e.loopdepth.
@@ -1798,6 +1791,7 @@ func addrescapes(n ir.Node) {
 		// Nothing to do.
 
 	case ir.ONAME:
+		n := n.(*ir.Name)
 		if n == nodfp {
 			break
 		}
@@ -1832,10 +1826,6 @@ func addrescapes(n ir.Node) {
 		// heap in f, not in the inner closure. Flip over to f before calling moveToHeap.
 		oldfn := Curfn
 		Curfn = n.Name().Curfn
-		if Curfn.Op() == ir.OCLOSURE {
-			Curfn = Curfn.Func().Decl
-			panic("can't happen")
-		}
 		ln := base.Pos
 		base.Pos = Curfn.Pos()
 		moveToHeap(n)
@@ -1855,7 +1845,7 @@ func addrescapes(n ir.Node) {
 }
 
 // moveToHeap records the parameter or local variable n as moved to the heap.
-func moveToHeap(n ir.Node) {
+func moveToHeap(n *ir.Name) {
 	if base.Flag.LowerR != 0 {
 		ir.Dump("MOVE", n)
 	}
@@ -1877,7 +1867,7 @@ func moveToHeap(n ir.Node) {
 	// Unset AutoTemp to persist the &foo variable name through SSA to
 	// liveness analysis.
 	// TODO(mdempsky/drchase): Cleaner solution?
-	heapaddr.Name().SetAutoTemp(false)
+	heapaddr.SetAutoTemp(false)
 
 	// Parameters have a local stack copy used at function start/end
 	// in addition to the copy in the heap that may live longer than
@@ -1895,14 +1885,14 @@ func moveToHeap(n ir.Node) {
 		stackcopy.SetType(n.Type())
 		stackcopy.SetOffset(n.Offset())
 		stackcopy.SetClass(n.Class())
-		stackcopy.Name().Heapaddr = heapaddr
+		stackcopy.Heapaddr = heapaddr
 		if n.Class() == ir.PPARAMOUT {
 			// Make sure the pointer to the heap copy is kept live throughout the function.
 			// The function could panic at any point, and then a defer could recover.
 			// Thus, we need the pointer to the heap copy always available so the
 			// post-deferreturn code can copy the return value back to the stack.
 			// See issue 16095.
-			heapaddr.Name().SetIsOutputParamHeapAddr(true)
+			heapaddr.SetIsOutputParamHeapAddr(true)
 		}
 		n.Name().Stackcopy = stackcopy
 
@@ -1910,9 +1900,9 @@ func moveToHeap(n ir.Node) {
 		// liveness and other analyses use the underlying stack slot
 		// and not the now-pseudo-variable n.
 		found := false
-		for i, d := range Curfn.Func().Dcl {
+		for i, d := range Curfn.Dcl {
 			if d == n {
-				Curfn.Func().Dcl[i] = stackcopy
+				Curfn.Dcl[i] = stackcopy
 				found = true
 				break
 			}
@@ -1925,7 +1915,7 @@ func moveToHeap(n ir.Node) {
 		if !found {
 			base.Fatalf("cannot find %v in local variable list", n)
 		}
-		Curfn.Func().Dcl = append(Curfn.Func().Dcl, n)
+		Curfn.Dcl = append(Curfn.Dcl, n)
 	}
 
 	// Modify n in place so that uses of n now mean indirection of the heapaddr.
diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index 10033793bf..5cd379a7d3 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -161,8 +161,12 @@ func importfunc(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) {
 	if n == nil {
 		return
 	}
+	name := n.(*ir.Name)
 
-	n.SetFunc(new(ir.Func))
+	fn := ir.NewFunc(pos)
+	fn.SetType(t)
+	name.SetFunc(fn)
+	fn.Nname = name
 
 	if base.Flag.E != 0 {
 		fmt.Printf("import func %v%S\n", s, t)
diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
index cf9e0d58bf..0d3f9392fb 100644
--- a/src/cmd/compile/internal/gc/gen.go
+++ b/src/cmd/compile/internal/gc/gen.go
@@ -52,7 +52,7 @@ func autotmpname(n int) string {
 }
 
 // make a new Node off the books
-func tempAt(pos src.XPos, curfn ir.Node, t *types.Type) *ir.Name {
+func tempAt(pos src.XPos, curfn *ir.Func, t *types.Type) *ir.Name {
 	if curfn == nil {
 		base.Fatalf("no curfn for tempAt")
 	}
@@ -65,7 +65,7 @@ func tempAt(pos src.XPos, curfn ir.Node, t *types.Type) *ir.Name {
 	}
 
 	s := &types.Sym{
-		Name: autotmpname(len(curfn.Func().Dcl)),
+		Name: autotmpname(len(curfn.Dcl)),
 		Pkg:  ir.LocalPkg,
 	}
 	n := ir.NewNameAt(pos, s)
@@ -73,10 +73,10 @@ func tempAt(pos src.XPos, curfn ir.Node, t *types.Type) *ir.Name {
 	n.SetType(t)
 	n.SetClass(ir.PAUTO)
 	n.SetEsc(EscNever)
-	n.Name().Curfn = curfn
-	n.Name().SetUsed(true)
-	n.Name().SetAutoTemp(true)
-	curfn.Func().Dcl = append(curfn.Func().Dcl, n)
+	n.Curfn = curfn
+	n.SetUsed(true)
+	n.SetAutoTemp(true)
+	curfn.Dcl = append(curfn.Dcl, n)
 
 	dowidth(t)
 
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index 84e6bc5faf..24393de53d 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -132,7 +132,7 @@ var xtop []ir.Node
 
 var exportlist []ir.Node
 
-var importlist []ir.Node // imported functions and methods with inlinable bodies
+var importlist []*ir.Func // imported functions and methods with inlinable bodies
 
 var (
 	funcsymsmu sync.Mutex // protects funcsyms and associated package lookups (see func funcsym)
@@ -141,7 +141,7 @@ var (
 
 var dclcontext ir.Class // PEXTERN/PAUTO
 
-var Curfn ir.Node
+var Curfn *ir.Func
 
 var Widthptr int
 
@@ -156,7 +156,7 @@ var instrumenting bool
 // Whether we are tracking lexical scopes for DWARF.
 var trackScopes bool
 
-var nodfp ir.Node
+var nodfp *ir.Name
 
 var autogeneratedPos src.XPos
 
diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go
index 950033a8a3..79ca669dfb 100644
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ b/src/cmd/compile/internal/gc/gsubr.go
@@ -47,7 +47,7 @@ type Progs struct {
 	next      *obj.Prog  // next Prog
 	pc        int64      // virtual PC; count of Progs
 	pos       src.XPos   // position to use for new Progs
-	curfn     ir.Node    // fn these Progs are for
+	curfn     *ir.Func   // fn these Progs are for
 	progcache []obj.Prog // local progcache
 	cacheidx  int        // first free element of progcache
 
@@ -57,7 +57,7 @@ type Progs struct {
 
 // newProgs returns a new Progs for fn.
 // worker indicates which of the backend workers will use the Progs.
-func newProgs(fn ir.Node, worker int) *Progs {
+func newProgs(fn *ir.Func, worker int) *Progs {
 	pp := new(Progs)
 	if base.Ctxt.CanReuseProgs() {
 		sz := len(sharedProgArray) / base.Flag.LowerC
@@ -174,17 +174,17 @@ func (pp *Progs) Appendpp(p *obj.Prog, as obj.As, ftype obj.AddrType, freg int16
 	return q
 }
 
-func (pp *Progs) settext(fn ir.Node) {
+func (pp *Progs) settext(fn *ir.Func) {
 	if pp.Text != nil {
 		base.Fatalf("Progs.settext called twice")
 	}
 	ptxt := pp.Prog(obj.ATEXT)
 	pp.Text = ptxt
 
-	fn.Func().LSym.Func().Text = ptxt
+	fn.LSym.Func().Text = ptxt
 	ptxt.From.Type = obj.TYPE_MEM
 	ptxt.From.Name = obj.NAME_EXTERN
-	ptxt.From.Sym = fn.Func().LSym
+	ptxt.From.Sym = fn.LSym
 }
 
 // initLSym defines f's obj.LSym and initializes it based on the
@@ -281,7 +281,7 @@ func initLSym(f *ir.Func, hasBody bool) {
 	// See test/recover.go for test cases and src/reflect/value.go
 	// for the actual functions being considered.
 	if base.Ctxt.Pkgpath == "reflect" {
-		switch f.Nname.Sym().Name {
+		switch f.Sym().Name {
 		case "callReflect", "callMethod":
 			flag |= obj.WRAPPER
 		}
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index 88d3a6477c..3f5ec2e4dd 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -429,6 +429,7 @@ func (p *iexporter) doDecl(n ir.Node) {
 
 	switch n.Op() {
 	case ir.ONAME:
+		n := n.(*ir.Name)
 		switch n.Class() {
 		case ir.PEXTERN:
 			// Variable.
@@ -515,7 +516,7 @@ func (w *exportWriter) tag(tag byte) {
 	w.data.WriteByte(tag)
 }
 
-func (p *iexporter) doInline(f ir.Node) {
+func (p *iexporter) doInline(f *ir.Name) {
 	w := p.newWriter()
 	w.setPkg(fnpkg(f), false)
 
@@ -960,7 +961,7 @@ func (w *exportWriter) varExt(n ir.Node) {
 	w.symIdx(n.Sym())
 }
 
-func (w *exportWriter) funcExt(n ir.Node) {
+func (w *exportWriter) funcExt(n *ir.Name) {
 	w.linkname(n.Sym())
 	w.symIdx(n.Sym())
 
@@ -979,14 +980,7 @@ func (w *exportWriter) funcExt(n ir.Node) {
 		}
 
 		// Endlineno for inlined function.
-		if n.Name().Defn != nil {
-			w.pos(n.Name().Defn.Func().Endlineno)
-		} else {
-			// When the exported node was defined externally,
-			// e.g. io exports atomic.(*Value).Load or bytes exports errors.New.
-			// Keep it as we don't distinguish this case in iimport.go.
-			w.pos(n.Func().Endlineno)
-		}
+		w.pos(n.Func().Endlineno)
 	} else {
 		w.uint64(0)
 	}
@@ -994,7 +988,7 @@ func (w *exportWriter) funcExt(n ir.Node) {
 
 func (w *exportWriter) methExt(m *types.Field) {
 	w.bool(m.Nointerface())
-	w.funcExt(ir.AsNode(m.Nname))
+	w.funcExt(ir.AsNode(m.Nname).(*ir.Name))
 }
 
 func (w *exportWriter) linkname(s *types.Sym) {
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 066d956b93..5a50682ab2 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -41,7 +41,7 @@ var (
 	inlineImporter = map[*types.Sym]iimporterAndOffset{}
 )
 
-func expandDecl(n ir.Node) {
+func expandDecl(n *ir.Name) {
 	if n.Op() != ir.ONONAME {
 		return
 	}
@@ -55,12 +55,12 @@ func expandDecl(n ir.Node) {
 	r.doDecl(n)
 }
 
-func expandInline(fn ir.Node) {
-	if fn.Func().Inl.Body != nil {
+func expandInline(fn *ir.Func) {
+	if fn.Inl.Body != nil {
 		return
 	}
 
-	r := importReaderFor(fn, inlineImporter)
+	r := importReaderFor(fn.Nname, inlineImporter)
 	if r == nil {
 		base.Fatalf("missing import reader for %v", fn)
 	}
@@ -68,7 +68,7 @@ func expandInline(fn ir.Node) {
 	r.doInline(fn)
 }
 
-func importReaderFor(n ir.Node, importers map[*types.Sym]iimporterAndOffset) *importReader {
+func importReaderFor(n *ir.Name, importers map[*types.Sym]iimporterAndOffset) *importReader {
 	x, ok := importers[n.Sym()]
 	if !ok {
 		return nil
@@ -331,7 +331,9 @@ func (r *importReader) doDecl(n ir.Node) {
 			recv := r.param()
 			mtyp := r.signature(recv)
 
-			m := newfuncnamel(mpos, methodSym(recv.Type, msym), new(ir.Func))
+			fn := ir.NewFunc(mpos)
+			fn.SetType(mtyp)
+			m := newFuncNameAt(mpos, methodSym(recv.Type, msym), fn)
 			m.SetType(mtyp)
 			m.SetClass(ir.PFUNC)
 			// methodSym already marked m.Sym as a function.
@@ -501,7 +503,7 @@ func (r *importReader) typ1() *types.Type {
 		// type.
 		n := ir.AsNode(r.qualifiedIdent().PkgDef())
 		if n.Op() == ir.ONONAME {
-			expandDecl(n)
+			expandDecl(n.(*ir.Name))
 		}
 		if n.Op() != ir.OTYPE {
 			base.Fatalf("expected OTYPE, got %v: %v, %v", n.Op(), n.Sym(), n)
@@ -695,12 +697,12 @@ func (r *importReader) typeExt(t *types.Type) {
 // so we can use index to reference the symbol.
 var typeSymIdx = make(map[*types.Type][2]int64)
 
-func (r *importReader) doInline(n ir.Node) {
-	if len(n.Func().Inl.Body) != 0 {
-		base.Fatalf("%v already has inline body", n)
+func (r *importReader) doInline(fn *ir.Func) {
+	if len(fn.Inl.Body) != 0 {
+		base.Fatalf("%v already has inline body", fn)
 	}
 
-	funchdr(n)
+	funchdr(fn)
 	body := r.stmtList()
 	funcbody()
 	if body == nil {
@@ -712,15 +714,15 @@ func (r *importReader) doInline(n ir.Node) {
 		// functions).
 		body = []ir.Node{}
 	}
-	n.Func().Inl.Body = body
+	fn.Inl.Body = body
 
-	importlist = append(importlist, n)
+	importlist = append(importlist, fn)
 
 	if base.Flag.E > 0 && base.Flag.LowerM > 2 {
 		if base.Flag.LowerM > 3 {
-			fmt.Printf("inl body for %v %#v: %+v\n", n, n.Type(), ir.AsNodes(n.Func().Inl.Body))
+			fmt.Printf("inl body for %v %#v: %+v\n", fn, fn.Type(), ir.AsNodes(fn.Inl.Body))
 		} else {
-			fmt.Printf("inl body for %v %#v: %v\n", n, n.Type(), ir.AsNodes(n.Func().Inl.Body))
+			fmt.Printf("inl body for %v %#v: %v\n", fn, fn.Type(), ir.AsNodes(fn.Inl.Body))
 		}
 	}
 }
@@ -772,7 +774,7 @@ func (r *importReader) caseList(sw ir.Node) []ir.Node {
 			caseVar := ir.NewNameAt(cas.Pos(), r.ident())
 			declare(caseVar, dclcontext)
 			cas.PtrRlist().Set1(caseVar)
-			caseVar.Name().Defn = sw.Left()
+			caseVar.Defn = sw.Left()
 		}
 		cas.PtrBody().Set(r.stmtList())
 		cases[i] = cas
diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index 2b7ecd1d05..7f2a39ff46 100644
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -19,7 +19,7 @@ var renameinitgen int
 
 // Function collecting autotmps generated during typechecking,
 // to be included in the package-level init function.
-var initTodo = ir.Nod(ir.ODCLFUNC, nil, nil)
+var initTodo = ir.NewFunc(base.Pos)
 
 func renameinit() *types.Sym {
 	s := lookupN("init.", renameinitgen)
@@ -49,23 +49,23 @@ func fninit(n []ir.Node) {
 		base.Pos = nf[0].Pos() // prolog/epilog gets line number of first init stmt
 		initializers := lookup("init")
 		fn := dclfunc(initializers, ir.Nod(ir.OTFUNC, nil, nil))
-		for _, dcl := range initTodo.Func().Dcl {
+		for _, dcl := range initTodo.Dcl {
 			dcl.Name().Curfn = fn
 		}
-		fn.Func().Dcl = append(fn.Func().Dcl, initTodo.Func().Dcl...)
-		initTodo.Func().Dcl = nil
+		fn.Dcl = append(fn.Dcl, initTodo.Dcl...)
+		initTodo.Dcl = nil
 
 		fn.PtrBody().Set(nf)
 		funcbody()
 
-		fn = typecheck(fn, ctxStmt)
+		typecheckFunc(fn)
 		Curfn = fn
 		typecheckslice(nf, ctxStmt)
 		Curfn = nil
 		xtop = append(xtop, fn)
 		fns = append(fns, initializers.Linksym())
 	}
-	if initTodo.Func().Dcl != nil {
+	if initTodo.Dcl != nil {
 		// We only generate temps using initTodo if there
 		// are package-scope initialization statements, so
 		// something's weird if we get here.
diff --git a/src/cmd/compile/internal/gc/initorder.go b/src/cmd/compile/internal/gc/initorder.go
index 1003f131b8..ea3d74d5ba 100644
--- a/src/cmd/compile/internal/gc/initorder.go
+++ b/src/cmd/compile/internal/gc/initorder.go
@@ -284,11 +284,11 @@ func (d *initDeps) visit(n ir.Node) bool {
 	case ir.ONAME:
 		switch n.Class() {
 		case ir.PEXTERN, ir.PFUNC:
-			d.foundDep(n)
+			d.foundDep(n.(*ir.Name))
 		}
 
 	case ir.OCLOSURE:
-		d.inspectList(n.Func().Decl.Body())
+		d.inspectList(n.Func().Body())
 
 	case ir.ODOTMETH, ir.OCALLPART:
 		d.foundDep(methodExprName(n))
@@ -299,7 +299,7 @@ func (d *initDeps) visit(n ir.Node) bool {
 
 // foundDep records that we've found a dependency on n by adding it to
 // seen.
-func (d *initDeps) foundDep(n ir.Node) {
+func (d *initDeps) foundDep(n *ir.Name) {
 	// Can happen with method expressions involving interface
 	// types; e.g., fixedbugs/issue4495.go.
 	if n == nil {
@@ -308,7 +308,7 @@ func (d *initDeps) foundDep(n ir.Node) {
 
 	// Names without definitions aren't interesting as far as
 	// initialization ordering goes.
-	if n.Name().Defn == nil {
+	if n.Defn == nil {
 		return
 	}
 
@@ -317,7 +317,7 @@ func (d *initDeps) foundDep(n ir.Node) {
 	}
 	d.seen.Add(n)
 	if d.transitive && n.Class() == ir.PFUNC {
-		d.inspectList(n.Name().Defn.Body())
+		d.inspectList(n.Defn.Body())
 	}
 }
 
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 102144aedf..20f145b8eb 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -53,7 +53,7 @@ const (
 
 // Get the function's package. For ordinary functions it's on the ->sym, but for imported methods
 // the ->sym can be re-used in the local package, so peel it off the receiver's type.
-func fnpkg(fn ir.Node) *types.Pkg {
+func fnpkg(fn *ir.Name) *types.Pkg {
 	if ir.IsMethod(fn) {
 		// method
 		rcvr := fn.Type().Recv().Type
@@ -73,8 +73,8 @@ func fnpkg(fn ir.Node) *types.Pkg {
 
 // Lazy typechecking of imported bodies. For local functions, caninl will set ->typecheck
 // because they're a copy of an already checked body.
-func typecheckinl(fn ir.Node) {
-	lno := setlineno(fn)
+func typecheckinl(fn *ir.Func) {
+	lno := setlineno(fn.Nname)
 
 	expandInline(fn)
 
@@ -82,19 +82,19 @@ func typecheckinl(fn ir.Node) {
 	// their bodies may refer to unsafe as long as the package
 	// was marked safe during import (which was checked then).
 	// the ->inl of a local function has been typechecked before caninl copied it.
-	pkg := fnpkg(fn)
+	pkg := fnpkg(fn.Nname)
 
 	if pkg == ir.LocalPkg || pkg == nil {
 		return // typecheckinl on local function
 	}
 
 	if base.Flag.LowerM > 2 || base.Debug.Export != 0 {
-		fmt.Printf("typecheck import [%v] %L { %#v }\n", fn.Sym(), fn, ir.AsNodes(fn.Func().Inl.Body))
+		fmt.Printf("typecheck import [%v] %L { %#v }\n", fn.Sym(), fn, ir.AsNodes(fn.Inl.Body))
 	}
 
 	savefn := Curfn
 	Curfn = fn
-	typecheckslice(fn.Func().Inl.Body, ctxStmt)
+	typecheckslice(fn.Inl.Body, ctxStmt)
 	Curfn = savefn
 
 	// During expandInline (which imports fn.Func.Inl.Body),
@@ -102,8 +102,8 @@ func typecheckinl(fn ir.Node) {
 	// to fn.Func.Inl.Dcl for consistency with how local functions
 	// behave. (Append because typecheckinl may be called multiple
 	// times.)
-	fn.Func().Inl.Dcl = append(fn.Func().Inl.Dcl, fn.Func().Dcl...)
-	fn.Func().Dcl = nil
+	fn.Inl.Dcl = append(fn.Inl.Dcl, fn.Dcl...)
+	fn.Dcl = nil
 
 	base.Pos = lno
 }
@@ -111,11 +111,8 @@ func typecheckinl(fn ir.Node) {
 // Caninl determines whether fn is inlineable.
 // If so, caninl saves fn->nbody in fn->inl and substitutes it with a copy.
 // fn and ->nbody will already have been typechecked.
-func caninl(fn ir.Node) {
-	if fn.Op() != ir.ODCLFUNC {
-		base.Fatalf("caninl %v", fn)
-	}
-	if fn.Func().Nname == nil {
+func caninl(fn *ir.Func) {
+	if fn.Nname == nil {
 		base.Fatalf("caninl no nname %+v", fn)
 	}
 
@@ -124,7 +121,7 @@ func caninl(fn ir.Node) {
 		defer func() {
 			if reason != "" {
 				if base.Flag.LowerM > 1 {
-					fmt.Printf("%v: cannot inline %v: %s\n", ir.Line(fn), fn.Func().Nname, reason)
+					fmt.Printf("%v: cannot inline %v: %s\n", ir.Line(fn), fn.Nname, reason)
 				}
 				if logopt.Enabled() {
 					logopt.LogOpt(fn.Pos(), "cannotInlineFunction", "inline", ir.FuncName(fn), reason)
@@ -134,33 +131,33 @@ func caninl(fn ir.Node) {
 	}
 
 	// If marked "go:noinline", don't inline
-	if fn.Func().Pragma&ir.Noinline != 0 {
+	if fn.Pragma&ir.Noinline != 0 {
 		reason = "marked go:noinline"
 		return
 	}
 
 	// If marked "go:norace" and -race compilation, don't inline.
-	if base.Flag.Race && fn.Func().Pragma&ir.Norace != 0 {
+	if base.Flag.Race && fn.Pragma&ir.Norace != 0 {
 		reason = "marked go:norace with -race compilation"
 		return
 	}
 
 	// If marked "go:nocheckptr" and -d checkptr compilation, don't inline.
-	if base.Debug.Checkptr != 0 && fn.Func().Pragma&ir.NoCheckPtr != 0 {
+	if base.Debug.Checkptr != 0 && fn.Pragma&ir.NoCheckPtr != 0 {
 		reason = "marked go:nocheckptr"
 		return
 	}
 
 	// If marked "go:cgo_unsafe_args", don't inline, since the
 	// function makes assumptions about its argument frame layout.
-	if fn.Func().Pragma&ir.CgoUnsafeArgs != 0 {
+	if fn.Pragma&ir.CgoUnsafeArgs != 0 {
 		reason = "marked go:cgo_unsafe_args"
 		return
 	}
 
 	// If marked as "go:uintptrescapes", don't inline, since the
 	// escape information is lost during inlining.
-	if fn.Func().Pragma&ir.UintptrEscapes != 0 {
+	if fn.Pragma&ir.UintptrEscapes != 0 {
 		reason = "marked as having an escaping uintptr argument"
 		return
 	}
@@ -169,7 +166,7 @@ func caninl(fn ir.Node) {
 	// granularity, so inlining yeswritebarrierrec functions can
 	// confuse it (#22342). As a workaround, disallow inlining
 	// them for now.
-	if fn.Func().Pragma&ir.Yeswritebarrierrec != 0 {
+	if fn.Pragma&ir.Yeswritebarrierrec != 0 {
 		reason = "marked go:yeswritebarrierrec"
 		return
 	}
@@ -184,7 +181,7 @@ func caninl(fn ir.Node) {
 		base.Fatalf("caninl on non-typechecked function %v", fn)
 	}
 
-	n := fn.Func().Nname
+	n := fn.Nname
 	if n.Func().InlinabilityChecked() {
 		return
 	}
@@ -220,7 +217,7 @@ func caninl(fn ir.Node) {
 
 	n.Func().Inl = &ir.Inline{
 		Cost: inlineMaxBudget - visitor.budget,
-		Dcl:  inlcopylist(pruneUnusedAutos(n.Name().Defn.Func().Dcl, &visitor)),
+		Dcl:  pruneUnusedAutos(n.Defn.Func().Dcl, &visitor),
 		Body: inlcopylist(fn.Body().Slice()),
 	}
 
@@ -236,36 +233,38 @@ func caninl(fn ir.Node) {
 
 // inlFlood marks n's inline body for export and recursively ensures
 // all called functions are marked too.
-func inlFlood(n ir.Node) {
+func inlFlood(n *ir.Name) {
 	if n == nil {
 		return
 	}
 	if n.Op() != ir.ONAME || n.Class() != ir.PFUNC {
 		base.Fatalf("inlFlood: unexpected %v, %v, %v", n, n.Op(), n.Class())
 	}
-	if n.Func() == nil {
+	fn := n.Func()
+	if fn == nil {
 		base.Fatalf("inlFlood: missing Func on %v", n)
 	}
-	if n.Func().Inl == nil {
+	if fn.Inl == nil {
 		return
 	}
 
-	if n.Func().ExportInline() {
+	if fn.ExportInline() {
 		return
 	}
-	n.Func().SetExportInline(true)
+	fn.SetExportInline(true)
 
-	typecheckinl(n)
+	typecheckinl(fn)
 
 	// Recursively identify all referenced functions for
 	// reexport. We want to include even non-called functions,
 	// because after inlining they might be callable.
-	ir.InspectList(ir.AsNodes(n.Func().Inl.Body), func(n ir.Node) bool {
+	ir.InspectList(ir.AsNodes(fn.Inl.Body), func(n ir.Node) bool {
 		switch n.Op() {
-		case ir.OMETHEXPR:
+		case ir.OMETHEXPR, ir.ODOTMETH:
 			inlFlood(methodExprName(n))
 
 		case ir.ONAME:
+			n := n.(*ir.Name)
 			switch n.Class() {
 			case ir.PFUNC:
 				inlFlood(n)
@@ -274,10 +273,6 @@ func inlFlood(n ir.Node) {
 				exportsym(n)
 			}
 
-		case ir.ODOTMETH:
-			fn := methodExprName(n)
-			inlFlood(fn)
-
 		case ir.OCALLPART:
 			// Okay, because we don't yet inline indirect
 			// calls to method values.
@@ -342,8 +337,8 @@ func (v *hairyVisitor) visit(n ir.Node) bool {
 			break
 		}
 
-		if fn := inlCallee(n.Left()); fn != nil && fn.Func().Inl != nil {
-			v.budget -= fn.Func().Inl.Cost
+		if fn := inlCallee(n.Left()); fn != nil && fn.Inl != nil {
+			v.budget -= fn.Inl.Cost
 			break
 		}
 
@@ -503,7 +498,7 @@ func countNodes(n ir.Node) int {
 
 // Inlcalls/nodelist/node walks fn's statements and expressions and substitutes any
 // calls made to inlineable functions. This is the external entry point.
-func inlcalls(fn ir.Node) {
+func inlcalls(fn *ir.Func) {
 	savefn := Curfn
 	Curfn = fn
 	maxCost := int32(inlineMaxBudget)
@@ -516,8 +511,8 @@ func inlcalls(fn ir.Node) {
 	// but allow inlining if there is a recursion cycle of many functions.
 	// Most likely, the inlining will stop before we even hit the beginning of
 	// the cycle again, but the map catches the unusual case.
-	inlMap := make(map[ir.Node]bool)
-	fn = inlnode(fn, maxCost, inlMap)
+	inlMap := make(map[*ir.Func]bool)
+	fn = inlnode(fn, maxCost, inlMap).(*ir.Func)
 	if fn != Curfn {
 		base.Fatalf("inlnode replaced curfn")
 	}
@@ -558,7 +553,7 @@ func inlconv2list(n ir.Node) []ir.Node {
 	return s
 }
 
-func inlnodelist(l ir.Nodes, maxCost int32, inlMap map[ir.Node]bool) {
+func inlnodelist(l ir.Nodes, maxCost int32, inlMap map[*ir.Func]bool) {
 	s := l.Slice()
 	for i := range s {
 		s[i] = inlnode(s[i], maxCost, inlMap)
@@ -578,7 +573,7 @@ func inlnodelist(l ir.Nodes, maxCost int32, inlMap map[ir.Node]bool) {
 // shorter and less complicated.
 // The result of inlnode MUST be assigned back to n, e.g.
 // 	n.Left = inlnode(n.Left)
-func inlnode(n ir.Node, maxCost int32, inlMap map[ir.Node]bool) ir.Node {
+func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool) ir.Node {
 	if n == nil {
 		return n
 	}
@@ -684,7 +679,7 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[ir.Node]bool) ir.Node {
 		if isIntrinsicCall(n) {
 			break
 		}
-		if fn := inlCallee(n.Left()); fn != nil && fn.Func().Inl != nil {
+		if fn := inlCallee(n.Left()); fn != nil && fn.Inl != nil {
 			n = mkinlcall(n, fn, maxCost, inlMap)
 		}
 
@@ -698,7 +693,7 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[ir.Node]bool) ir.Node {
 			base.Fatalf("no function type for [%p] %+v\n", n.Left(), n.Left())
 		}
 
-		n = mkinlcall(n, methodExprName(n.Left()), maxCost, inlMap)
+		n = mkinlcall(n, methodExprName(n.Left()).Func(), maxCost, inlMap)
 	}
 
 	base.Pos = lno
@@ -707,7 +702,7 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[ir.Node]bool) ir.Node {
 
 // inlCallee takes a function-typed expression and returns the underlying function ONAME
 // that it refers to if statically known. Otherwise, it returns nil.
-func inlCallee(fn ir.Node) ir.Node {
+func inlCallee(fn ir.Node) *ir.Func {
 	fn = staticValue(fn)
 	switch {
 	case fn.Op() == ir.OMETHEXPR:
@@ -718,13 +713,13 @@ func inlCallee(fn ir.Node) ir.Node {
 		if n == nil || !types.Identical(n.Type().Recv().Type, fn.Left().Type()) {
 			return nil
 		}
-		return n
+		return n.Func()
 	case fn.Op() == ir.ONAME && fn.Class() == ir.PFUNC:
-		return fn
+		return fn.Func()
 	case fn.Op() == ir.OCLOSURE:
-		c := fn.Func().Decl
+		c := fn.Func()
 		caninl(c)
-		return c.Func().Nname
+		return c
 	}
 	return nil
 }
@@ -777,7 +772,7 @@ FindRHS:
 		base.Fatalf("RHS is nil: %v", defn)
 	}
 
-	unsafe, _ := reassigned(n)
+	unsafe, _ := reassigned(n.(*ir.Name))
 	if unsafe {
 		return nil
 	}
@@ -791,23 +786,15 @@ FindRHS:
 // useful for -m output documenting the reason for inhibited optimizations.
 // NB: global variables are always considered to be re-assigned.
 // TODO: handle initial declaration not including an assignment and followed by a single assignment?
-func reassigned(n ir.Node) (bool, ir.Node) {
+func reassigned(n *ir.Name) (bool, ir.Node) {
 	if n.Op() != ir.ONAME {
 		base.Fatalf("reassigned %v", n)
 	}
 	// no way to reliably check for no-reassignment of globals, assume it can be
-	if n.Name().Curfn == nil {
+	if n.Curfn == nil {
 		return true, nil
 	}
-	f := n.Name().Curfn
-	// There just might be a good reason for this although this can be pretty surprising:
-	// local variables inside a closure have Curfn pointing to the OCLOSURE node instead
-	// of the corresponding ODCLFUNC.
-	// We need to walk the function body to check for reassignments so we follow the
-	// linkage to the ODCLFUNC node as that is where body is held.
-	if f.Op() == ir.OCLOSURE {
-		f = f.Func().Decl
-	}
+	f := n.Curfn
 	v := reassignVisitor{name: n}
 	a := v.visitList(f.Body())
 	return a != nil, a
@@ -863,13 +850,13 @@ func (v *reassignVisitor) visitList(l ir.Nodes) ir.Node {
 	return nil
 }
 
-func inlParam(t *types.Field, as ir.Node, inlvars map[ir.Node]ir.Node) ir.Node {
+func inlParam(t *types.Field, as ir.Node, inlvars map[*ir.Name]ir.Node) ir.Node {
 	n := ir.AsNode(t.Nname)
 	if n == nil || ir.IsBlank(n) {
 		return ir.BlankNode
 	}
 
-	inlvar := inlvars[n]
+	inlvar := inlvars[n.(*ir.Name)]
 	if inlvar == nil {
 		base.Fatalf("missing inlvar for %v", n)
 	}
@@ -887,25 +874,25 @@ var inlgen int
 // parameters.
 // The result of mkinlcall MUST be assigned back to n, e.g.
 // 	n.Left = mkinlcall(n.Left, fn, isddd)
-func mkinlcall(n, fn ir.Node, maxCost int32, inlMap map[ir.Node]bool) ir.Node {
-	if fn.Func().Inl == nil {
+func mkinlcall(n ir.Node, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]bool) ir.Node {
+	if fn.Inl == nil {
 		if logopt.Enabled() {
 			logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", ir.FuncName(Curfn),
 				fmt.Sprintf("%s cannot be inlined", ir.PkgFuncName(fn)))
 		}
 		return n
 	}
-	if fn.Func().Inl.Cost > maxCost {
+	if fn.Inl.Cost > maxCost {
 		// The inlined function body is too big. Typically we use this check to restrict
 		// inlining into very big functions.  See issue 26546 and 17566.
 		if logopt.Enabled() {
 			logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", ir.FuncName(Curfn),
-				fmt.Sprintf("cost %d of %s exceeds max large caller cost %d", fn.Func().Inl.Cost, ir.PkgFuncName(fn), maxCost))
+				fmt.Sprintf("cost %d of %s exceeds max large caller cost %d", fn.Inl.Cost, ir.PkgFuncName(fn), maxCost))
 		}
 		return n
 	}
 
-	if fn == Curfn || fn.Name().Defn == Curfn {
+	if fn == Curfn {
 		// Can't recursively inline a function into itself.
 		if logopt.Enabled() {
 			logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", fmt.Sprintf("recursive call to %s", ir.FuncName(Curfn)))
@@ -939,7 +926,7 @@ func mkinlcall(n, fn ir.Node, maxCost int32, inlMap map[ir.Node]bool) ir.Node {
 
 	// We have a function node, and it has an inlineable body.
 	if base.Flag.LowerM > 1 {
-		fmt.Printf("%v: inlining call to %v %#v { %#v }\n", ir.Line(n), fn.Sym(), fn.Type(), ir.AsNodes(fn.Func().Inl.Body))
+		fmt.Printf("%v: inlining call to %v %#v { %#v }\n", ir.Line(n), fn.Sym(), fn.Type(), ir.AsNodes(fn.Inl.Body))
 	} else if base.Flag.LowerM != 0 {
 		fmt.Printf("%v: inlining call to %v\n", ir.Line(n), fn)
 	}
@@ -969,50 +956,48 @@ func mkinlcall(n, fn ir.Node, maxCost int32, inlMap map[ir.Node]bool) ir.Node {
 	}
 
 	// Make temp names to use instead of the originals.
-	inlvars := make(map[ir.Node]ir.Node)
+	inlvars := make(map[*ir.Name]ir.Node)
 
 	// record formals/locals for later post-processing
 	var inlfvars []ir.Node
 
 	// Handle captured variables when inlining closures.
-	if fn.Name().Defn != nil {
-		if c := fn.Name().Defn.Func().OClosure; c != nil {
-			for _, v := range c.Func().ClosureVars.Slice() {
-				if v.Op() == ir.OXXX {
-					continue
-				}
+	if c := fn.OClosure; c != nil {
+		for _, v := range c.Func().ClosureVars {
+			if v.Op() == ir.OXXX {
+				continue
+			}
 
-				o := v.Name().Outer
-				// make sure the outer param matches the inlining location
-				// NB: if we enabled inlining of functions containing OCLOSURE or refined
-				// the reassigned check via some sort of copy propagation this would most
-				// likely need to be changed to a loop to walk up to the correct Param
-				if o == nil || (o.Name().Curfn != Curfn && o.Name().Curfn.Func().OClosure != Curfn) {
-					base.Fatalf("%v: unresolvable capture %v %v\n", ir.Line(n), fn, v)
-				}
+			o := v.Outer
+			// make sure the outer param matches the inlining location
+			// NB: if we enabled inlining of functions containing OCLOSURE or refined
+			// the reassigned check via some sort of copy propagation this would most
+			// likely need to be changed to a loop to walk up to the correct Param
+			if o == nil || (o.Curfn != Curfn && o.Curfn.OClosure != Curfn) {
+				base.Fatalf("%v: unresolvable capture %v %v\n", ir.Line(n), fn, v)
+			}
 
-				if v.Name().Byval() {
-					iv := typecheck(inlvar(v), ctxExpr)
-					ninit.Append(ir.Nod(ir.ODCL, iv, nil))
-					ninit.Append(typecheck(ir.Nod(ir.OAS, iv, o), ctxStmt))
-					inlvars[v] = iv
-				} else {
-					addr := NewName(lookup("&" + v.Sym().Name))
-					addr.SetType(types.NewPtr(v.Type()))
-					ia := typecheck(inlvar(addr), ctxExpr)
-					ninit.Append(ir.Nod(ir.ODCL, ia, nil))
-					ninit.Append(typecheck(ir.Nod(ir.OAS, ia, ir.Nod(ir.OADDR, o, nil)), ctxStmt))
-					inlvars[addr] = ia
-
-					// When capturing by reference, all occurrence of the captured var
-					// must be substituted with dereference of the temporary address
-					inlvars[v] = typecheck(ir.Nod(ir.ODEREF, ia, nil), ctxExpr)
-				}
+			if v.Byval() {
+				iv := typecheck(inlvar(v), ctxExpr)
+				ninit.Append(ir.Nod(ir.ODCL, iv, nil))
+				ninit.Append(typecheck(ir.Nod(ir.OAS, iv, o), ctxStmt))
+				inlvars[v] = iv
+			} else {
+				addr := NewName(lookup("&" + v.Sym().Name))
+				addr.SetType(types.NewPtr(v.Type()))
+				ia := typecheck(inlvar(addr), ctxExpr)
+				ninit.Append(ir.Nod(ir.ODCL, ia, nil))
+				ninit.Append(typecheck(ir.Nod(ir.OAS, ia, ir.Nod(ir.OADDR, o, nil)), ctxStmt))
+				inlvars[addr] = ia
+
+				// When capturing by reference, all occurrence of the captured var
+				// must be substituted with dereference of the temporary address
+				inlvars[v] = typecheck(ir.Nod(ir.ODEREF, ia, nil), ctxExpr)
 			}
 		}
 	}
 
-	for _, ln := range fn.Func().Inl.Dcl {
+	for _, ln := range fn.Inl.Dcl {
 		if ln.Op() != ir.ONAME {
 			continue
 		}
@@ -1040,7 +1025,7 @@ func mkinlcall(n, fn ir.Node, maxCost int32, inlMap map[ir.Node]bool) ir.Node {
 	}
 
 	nreturns := 0
-	ir.InspectList(ir.AsNodes(fn.Func().Inl.Body), func(n ir.Node) bool {
+	ir.InspectList(ir.AsNodes(fn.Inl.Body), func(n ir.Node) bool {
 		if n != nil && n.Op() == ir.ORETURN {
 			nreturns++
 		}
@@ -1057,6 +1042,7 @@ func mkinlcall(n, fn ir.Node, maxCost int32, inlMap map[ir.Node]bool) ir.Node {
 	for i, t := range fn.Type().Results().Fields().Slice() {
 		var m ir.Node
 		if n := ir.AsNode(t.Nname); n != nil && !ir.IsBlank(n) && !strings.HasPrefix(n.Sym().Name, "~r") {
+			n := n.(*ir.Name)
 			m = inlvar(n)
 			m = typecheck(m, ctxExpr)
 			inlvars[n] = m
@@ -1155,7 +1141,9 @@ func mkinlcall(n, fn ir.Node, maxCost int32, inlMap map[ir.Node]bool) ir.Node {
 	if b := base.Ctxt.PosTable.Pos(n.Pos()).Base(); b != nil {
 		parent = b.InliningIndex()
 	}
-	newIndex := base.Ctxt.InlTree.Add(parent, n.Pos(), fn.Sym().Linksym())
+
+	sym := fn.Sym().Linksym()
+	newIndex := base.Ctxt.InlTree.Add(parent, n.Pos(), sym)
 
 	// Add an inline mark just before the inlined body.
 	// This mark is inline in the code so that it's a reasonable spot
@@ -1168,9 +1156,9 @@ func mkinlcall(n, fn ir.Node, maxCost int32, inlMap map[ir.Node]bool) ir.Node {
 	ninit.Append(inlMark)
 
 	if base.Flag.GenDwarfInl > 0 {
-		if !fn.Sym().Linksym().WasInlined() {
-			base.Ctxt.DwFixups.SetPrecursorFunc(fn.Sym().Linksym(), fn)
-			fn.Sym().Linksym().Set(obj.AttrWasInlined, true)
+		if !sym.WasInlined() {
+			base.Ctxt.DwFixups.SetPrecursorFunc(sym, fn)
+			sym.Set(obj.AttrWasInlined, true)
 		}
 	}
 
@@ -1183,7 +1171,7 @@ func mkinlcall(n, fn ir.Node, maxCost int32, inlMap map[ir.Node]bool) ir.Node {
 		newInlIndex:  newIndex,
 	}
 
-	body := subst.list(ir.AsNodes(fn.Func().Inl.Body))
+	body := subst.list(ir.AsNodes(fn.Inl.Body))
 
 	lab := nodSym(ir.OLABEL, nil, retlabel)
 	body = append(body, lab)
@@ -1236,11 +1224,11 @@ func inlvar(var_ ir.Node) ir.Node {
 	n := NewName(var_.Sym())
 	n.SetType(var_.Type())
 	n.SetClass(ir.PAUTO)
-	n.Name().SetUsed(true)
-	n.Name().Curfn = Curfn // the calling function, not the called one
-	n.Name().SetAddrtaken(var_.Name().Addrtaken())
+	n.SetUsed(true)
+	n.Curfn = Curfn // the calling function, not the called one
+	n.SetAddrtaken(var_.Name().Addrtaken())
 
-	Curfn.Func().Dcl = append(Curfn.Func().Dcl, n)
+	Curfn.Dcl = append(Curfn.Dcl, n)
 	return n
 }
 
@@ -1249,9 +1237,9 @@ func retvar(t *types.Field, i int) ir.Node {
 	n := NewName(lookupN("~R", i))
 	n.SetType(t.Type)
 	n.SetClass(ir.PAUTO)
-	n.Name().SetUsed(true)
-	n.Name().Curfn = Curfn // the calling function, not the called one
-	Curfn.Func().Dcl = append(Curfn.Func().Dcl, n)
+	n.SetUsed(true)
+	n.Curfn = Curfn // the calling function, not the called one
+	Curfn.Dcl = append(Curfn.Dcl, n)
 	return n
 }
 
@@ -1261,9 +1249,9 @@ func argvar(t *types.Type, i int) ir.Node {
 	n := NewName(lookupN("~arg", i))
 	n.SetType(t.Elem())
 	n.SetClass(ir.PAUTO)
-	n.Name().SetUsed(true)
-	n.Name().Curfn = Curfn // the calling function, not the called one
-	Curfn.Func().Dcl = append(Curfn.Func().Dcl, n)
+	n.SetUsed(true)
+	n.Curfn = Curfn // the calling function, not the called one
+	Curfn.Dcl = append(Curfn.Dcl, n)
 	return n
 }
 
@@ -1280,7 +1268,7 @@ type inlsubst struct {
 	// "return" statement.
 	delayretvars bool
 
-	inlvars map[ir.Node]ir.Node
+	inlvars map[*ir.Name]ir.Node
 
 	// bases maps from original PosBase to PosBase with an extra
 	// inlined call frame.
@@ -1311,6 +1299,7 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 
 	switch n.Op() {
 	case ir.ONAME:
+		n := n.(*ir.Name)
 		if inlvar := subst.inlvars[n]; inlvar != nil { // These will be set during inlnode
 			if base.Flag.LowerM > 2 {
 				fmt.Printf("substituting name %+v  ->  %+v\n", n, inlvar)
@@ -1409,8 +1398,8 @@ func (subst *inlsubst) updatedPos(xpos src.XPos) src.XPos {
 	return base.Ctxt.PosTable.XPos(pos)
 }
 
-func pruneUnusedAutos(ll []ir.Node, vis *hairyVisitor) []ir.Node {
-	s := make([]ir.Node, 0, len(ll))
+func pruneUnusedAutos(ll []*ir.Name, vis *hairyVisitor) []*ir.Name {
+	s := make([]*ir.Name, 0, len(ll))
 	for _, n := range ll {
 		if n.Class() == ir.PAUTO {
 			if _, found := vis.usedLocals[n]; !found {
@@ -1424,7 +1413,7 @@ func pruneUnusedAutos(ll []ir.Node, vis *hairyVisitor) []ir.Node {
 
 // devirtualize replaces interface method calls within fn with direct
 // concrete-type method calls where applicable.
-func devirtualize(fn ir.Node) {
+func devirtualize(fn *ir.Func) {
 	Curfn = fn
 	ir.InspectList(fn.Body(), func(n ir.Node) bool {
 		if n.Op() == ir.OCALLINTER {
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 931626159d..7bad05265d 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -277,7 +277,7 @@ func Main(archInit func(*Arch)) {
 	for i := 0; i < len(xtop); i++ {
 		n := xtop[i]
 		if n.Op() == ir.ODCLFUNC {
-			Curfn = n
+			Curfn = n.(*ir.Func)
 			decldepth = 1
 			errorsBefore := base.Errors()
 			typecheckslice(Curfn.Body().Slice(), ctxStmt)
@@ -307,8 +307,8 @@ func Main(archInit func(*Arch)) {
 	timings.Start("fe", "capturevars")
 	for _, n := range xtop {
 		if n.Op() == ir.ODCLFUNC && n.Func().OClosure != nil {
-			Curfn = n
-			capturevars(n)
+			Curfn = n.(*ir.Func)
+			capturevars(Curfn)
 		}
 	}
 	capturevarscomplete = true
@@ -321,7 +321,7 @@ func Main(archInit func(*Arch)) {
 		// Typecheck imported function bodies if Debug.l > 1,
 		// otherwise lazily when used or re-exported.
 		for _, n := range importlist {
-			if n.Func().Inl != nil {
+			if n.Inl != nil {
 				typecheckinl(n)
 			}
 		}
@@ -330,7 +330,7 @@ func Main(archInit func(*Arch)) {
 
 	if base.Flag.LowerL != 0 {
 		// Find functions that can be inlined and clone them before walk expands them.
-		visitBottomUp(xtop, func(list []ir.Node, recursive bool) {
+		visitBottomUp(xtop, func(list []*ir.Func, recursive bool) {
 			numfns := numNonClosures(list)
 			for _, n := range list {
 				if !recursive || numfns > 1 {
@@ -340,7 +340,7 @@ func Main(archInit func(*Arch)) {
 					caninl(n)
 				} else {
 					if base.Flag.LowerM > 1 {
-						fmt.Printf("%v: cannot inline %v: recursive\n", ir.Line(n), n.Func().Nname)
+						fmt.Printf("%v: cannot inline %v: recursive\n", ir.Line(n), n.Nname)
 					}
 				}
 				inlcalls(n)
@@ -350,7 +350,7 @@ func Main(archInit func(*Arch)) {
 
 	for _, n := range xtop {
 		if n.Op() == ir.ODCLFUNC {
-			devirtualize(n)
+			devirtualize(n.(*ir.Func))
 		}
 	}
 	Curfn = nil
@@ -380,8 +380,8 @@ func Main(archInit func(*Arch)) {
 	timings.Start("fe", "xclosures")
 	for _, n := range xtop {
 		if n.Op() == ir.ODCLFUNC && n.Func().OClosure != nil {
-			Curfn = n
-			transformclosure(n)
+			Curfn = n.(*ir.Func)
+			transformclosure(Curfn)
 		}
 	}
 
@@ -403,7 +403,7 @@ func Main(archInit func(*Arch)) {
 	for i := 0; i < len(xtop); i++ {
 		n := xtop[i]
 		if n.Op() == ir.ODCLFUNC {
-			funccompile(n)
+			funccompile(n.(*ir.Func))
 			fcount++
 		}
 	}
@@ -481,10 +481,10 @@ func Main(archInit func(*Arch)) {
 }
 
 // numNonClosures returns the number of functions in list which are not closures.
-func numNonClosures(list []ir.Node) int {
+func numNonClosures(list []*ir.Func) int {
 	count := 0
-	for _, n := range list {
-		if n.Func().OClosure == nil {
+	for _, fn := range list {
+		if fn.OClosure == nil {
 			count++
 		}
 	}
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index cbe8a24051..8ae5874d3b 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -152,7 +152,7 @@ type noder struct {
 	lastCloseScopePos syntax.Pos
 }
 
-func (p *noder) funcBody(fn ir.Node, block *syntax.BlockStmt) {
+func (p *noder) funcBody(fn *ir.Func, block *syntax.BlockStmt) {
 	oldScope := p.scope
 	p.scope = 0
 	funchdr(fn)
@@ -165,7 +165,7 @@ func (p *noder) funcBody(fn ir.Node, block *syntax.BlockStmt) {
 		fn.PtrBody().Set(body)
 
 		base.Pos = p.makeXPos(block.Rbrace)
-		fn.Func().Endlineno = base.Pos
+		fn.Endlineno = base.Pos
 	}
 
 	funcbody()
@@ -176,9 +176,9 @@ func (p *noder) openScope(pos syntax.Pos) {
 	types.Markdcl()
 
 	if trackScopes {
-		Curfn.Func().Parents = append(Curfn.Func().Parents, p.scope)
-		p.scopeVars = append(p.scopeVars, len(Curfn.Func().Dcl))
-		p.scope = ir.ScopeID(len(Curfn.Func().Parents))
+		Curfn.Parents = append(Curfn.Parents, p.scope)
+		p.scopeVars = append(p.scopeVars, len(Curfn.Dcl))
+		p.scope = ir.ScopeID(len(Curfn.Parents))
 
 		p.markScope(pos)
 	}
@@ -191,29 +191,29 @@ func (p *noder) closeScope(pos syntax.Pos) {
 	if trackScopes {
 		scopeVars := p.scopeVars[len(p.scopeVars)-1]
 		p.scopeVars = p.scopeVars[:len(p.scopeVars)-1]
-		if scopeVars == len(Curfn.Func().Dcl) {
+		if scopeVars == len(Curfn.Dcl) {
 			// no variables were declared in this scope, so we can retract it.
 
-			if int(p.scope) != len(Curfn.Func().Parents) {
+			if int(p.scope) != len(Curfn.Parents) {
 				base.Fatalf("scope tracking inconsistency, no variables declared but scopes were not retracted")
 			}
 
-			p.scope = Curfn.Func().Parents[p.scope-1]
-			Curfn.Func().Parents = Curfn.Func().Parents[:len(Curfn.Func().Parents)-1]
+			p.scope = Curfn.Parents[p.scope-1]
+			Curfn.Parents = Curfn.Parents[:len(Curfn.Parents)-1]
 
-			nmarks := len(Curfn.Func().Marks)
-			Curfn.Func().Marks[nmarks-1].Scope = p.scope
+			nmarks := len(Curfn.Marks)
+			Curfn.Marks[nmarks-1].Scope = p.scope
 			prevScope := ir.ScopeID(0)
 			if nmarks >= 2 {
-				prevScope = Curfn.Func().Marks[nmarks-2].Scope
+				prevScope = Curfn.Marks[nmarks-2].Scope
 			}
-			if Curfn.Func().Marks[nmarks-1].Scope == prevScope {
-				Curfn.Func().Marks = Curfn.Func().Marks[:nmarks-1]
+			if Curfn.Marks[nmarks-1].Scope == prevScope {
+				Curfn.Marks = Curfn.Marks[:nmarks-1]
 			}
 			return
 		}
 
-		p.scope = Curfn.Func().Parents[p.scope-1]
+		p.scope = Curfn.Parents[p.scope-1]
 
 		p.markScope(pos)
 	}
@@ -221,10 +221,10 @@ func (p *noder) closeScope(pos syntax.Pos) {
 
 func (p *noder) markScope(pos syntax.Pos) {
 	xpos := p.makeXPos(pos)
-	if i := len(Curfn.Func().Marks); i > 0 && Curfn.Func().Marks[i-1].Pos == xpos {
-		Curfn.Func().Marks[i-1].Scope = p.scope
+	if i := len(Curfn.Marks); i > 0 && Curfn.Marks[i-1].Pos == xpos {
+		Curfn.Marks[i-1].Scope = p.scope
 	} else {
-		Curfn.Func().Marks = append(Curfn.Func().Marks, ir.Mark{Pos: xpos, Scope: p.scope})
+		Curfn.Marks = append(Curfn.Marks, ir.Mark{Pos: xpos, Scope: p.scope})
 	}
 }
 
@@ -444,6 +444,7 @@ func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []ir.Node {
 
 	nn := make([]ir.Node, 0, len(names))
 	for i, n := range names {
+		n := n.(*ir.Name)
 		if i >= len(values) {
 			base.Errorf("missing value in const declaration")
 			break
@@ -456,8 +457,8 @@ func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []ir.Node {
 		n.SetOp(ir.OLITERAL)
 		declare(n, dclcontext)
 
-		n.Name().Ntype = typ
-		n.Name().Defn = v
+		n.Ntype = typ
+		n.Defn = v
 		n.SetIota(cs.iota)
 
 		nn = append(nn, p.nod(decl, ir.ODCLCONST, n, nil))
@@ -514,7 +515,7 @@ func (p *noder) declName(name *syntax.Name) *ir.Name {
 func (p *noder) funcDecl(fun *syntax.FuncDecl) ir.Node {
 	name := p.name(fun.Name)
 	t := p.signature(fun.Recv, fun.Type)
-	f := p.nod(fun, ir.ODCLFUNC, nil, nil)
+	f := ir.NewFunc(p.pos(fun))
 
 	if fun.Recv == nil {
 		if name.Name == "init" {
@@ -530,16 +531,16 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) ir.Node {
 			}
 		}
 	} else {
-		f.Func().Shortname = name
+		f.Shortname = name
 		name = ir.BlankNode.Sym() // filled in by typecheckfunc
 	}
 
-	f.Func().Nname = newfuncnamel(p.pos(fun.Name), name, f.Func())
-	f.Func().Nname.Name().Defn = f
-	f.Func().Nname.Name().Ntype = t
+	f.Nname = newFuncNameAt(p.pos(fun.Name), name, f)
+	f.Nname.Defn = f
+	f.Nname.Ntype = t
 
 	if pragma, ok := fun.Pragma.(*Pragma); ok {
-		f.Func().Pragma = pragma.Flag & FuncPragmas
+		f.Pragma = pragma.Flag & FuncPragmas
 		if pragma.Flag&ir.Systemstack != 0 && pragma.Flag&ir.Nosplit != 0 {
 			base.ErrorfAt(f.Pos(), "go:nosplit and go:systemstack cannot be combined")
 		}
@@ -548,13 +549,13 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) ir.Node {
 	}
 
 	if fun.Recv == nil {
-		declare(f.Func().Nname, ir.PFUNC)
+		declare(f.Nname, ir.PFUNC)
 	}
 
 	p.funcBody(f, fun.Body)
 
 	if fun.Body != nil {
-		if f.Func().Pragma&ir.Noescape != 0 {
+		if f.Pragma&ir.Noescape != 0 {
 			base.ErrorfAt(f.Pos(), "can only use //go:noescape with external func implementations")
 		}
 	} else {
@@ -1059,7 +1060,7 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) ir.Node {
 		n := p.nod(stmt, ir.ORETURN, nil, nil)
 		n.PtrList().Set(results)
 		if n.List().Len() == 0 && Curfn != nil {
-			for _, ln := range Curfn.Func().Dcl {
+			for _, ln := range Curfn.Dcl {
 				if ln.Class() == ir.PPARAM {
 					continue
 				}
@@ -1133,7 +1134,7 @@ func (p *noder) assignList(expr syntax.Expr, defn ir.Node, colas bool) []ir.Node
 		newOrErr = true
 		n := NewName(sym)
 		declare(n, dclcontext)
-		n.Name().Defn = defn
+		n.Defn = defn
 		defn.PtrInit().Append(ir.Nod(ir.ODCL, n, nil))
 		res[i] = n
 	}
@@ -1240,7 +1241,7 @@ func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch ir.Node, rbrac
 			declare(nn, dclcontext)
 			n.PtrRlist().Set1(nn)
 			// keep track of the instances for reporting unused
-			nn.Name().Defn = tswitch
+			nn.Defn = tswitch
 		}
 
 		// Trim trailing empty statements. We omit them from
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index d566959d9e..7b5e3015c2 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -143,7 +143,7 @@ func dumpdata() {
 		for i := xtops; i < len(xtop); i++ {
 			n := xtop[i]
 			if n.Op() == ir.ODCLFUNC {
-				funccompile(n)
+				funccompile(n.(*ir.Func))
 			}
 		}
 		xtops = len(xtop)
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index b7d713439b..6a91b8c91b 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -51,9 +51,9 @@ type Order struct {
 
 // Order rewrites fn.Nbody to apply the ordering constraints
 // described in the comment at the top of the file.
-func order(fn ir.Node) {
+func order(fn *ir.Func) {
 	if base.Flag.W > 1 {
-		s := fmt.Sprintf("\nbefore order %v", fn.Func().Nname.Sym())
+		s := fmt.Sprintf("\nbefore order %v", fn.Sym())
 		ir.DumpList(s, fn.Body())
 	}
 
@@ -1258,7 +1258,7 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 		}
 
 	case ir.OCLOSURE:
-		if n.Transient() && n.Func().ClosureVars.Len() > 0 {
+		if n.Transient() && len(n.Func().ClosureVars) > 0 {
 			prealloc[n] = o.newTemp(closureType(n), false)
 		}
 
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index b74b132632..ea294ed66d 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -24,14 +24,14 @@ import (
 // "Portable" code generation.
 
 var (
-	compilequeue []ir.Node // functions waiting to be compiled
+	compilequeue []*ir.Func // functions waiting to be compiled
 )
 
-func emitptrargsmap(fn ir.Node) {
-	if ir.FuncName(fn) == "_" || fn.Func().Nname.Sym().Linkname != "" {
+func emitptrargsmap(fn *ir.Func) {
+	if ir.FuncName(fn) == "_" || fn.Sym().Linkname != "" {
 		return
 	}
-	lsym := base.Ctxt.Lookup(fn.Func().LSym.Name + ".args_stackmap")
+	lsym := base.Ctxt.Lookup(fn.LSym.Name + ".args_stackmap")
 
 	nptr := int(fn.Type().ArgWidth() / int64(Widthptr))
 	bv := bvalloc(int32(nptr) * 2)
@@ -68,7 +68,7 @@ func emitptrargsmap(fn ir.Node) {
 // really means, in memory, things with pointers needing zeroing at
 // the top of the stack and increasing in size.
 // Non-autos sort on offset.
-func cmpstackvarlt(a, b ir.Node) bool {
+func cmpstackvarlt(a, b *ir.Name) bool {
 	if (a.Class() == ir.PAUTO) != (b.Class() == ir.PAUTO) {
 		return b.Class() == ir.PAUTO
 	}
@@ -101,7 +101,7 @@ func cmpstackvarlt(a, b ir.Node) bool {
 }
 
 // byStackvar implements sort.Interface for []*Node using cmpstackvarlt.
-type byStackVar []ir.Node
+type byStackVar []*ir.Name
 
 func (s byStackVar) Len() int           { return len(s) }
 func (s byStackVar) Less(i, j int) bool { return cmpstackvarlt(s[i], s[j]) }
@@ -110,7 +110,7 @@ func (s byStackVar) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 func (s *ssafn) AllocFrame(f *ssa.Func) {
 	s.stksize = 0
 	s.stkptrsize = 0
-	fn := s.curfn.Func()
+	fn := s.curfn
 
 	// Mark the PAUTO's unused.
 	for _, ln := range fn.Dcl {
@@ -193,9 +193,9 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 	s.stkptrsize = Rnd(s.stkptrsize, int64(Widthreg))
 }
 
-func funccompile(fn ir.Node) {
+func funccompile(fn *ir.Func) {
 	if Curfn != nil {
-		base.Fatalf("funccompile %v inside %v", fn.Func().Nname.Sym(), Curfn.Func().Nname.Sym())
+		base.Fatalf("funccompile %v inside %v", fn.Sym(), Curfn.Sym())
 	}
 
 	if fn.Type() == nil {
@@ -210,21 +210,19 @@ func funccompile(fn ir.Node) {
 
 	if fn.Body().Len() == 0 {
 		// Initialize ABI wrappers if necessary.
-		initLSym(fn.Func(), false)
+		initLSym(fn, false)
 		emitptrargsmap(fn)
 		return
 	}
 
 	dclcontext = ir.PAUTO
 	Curfn = fn
-
 	compile(fn)
-
 	Curfn = nil
 	dclcontext = ir.PEXTERN
 }
 
-func compile(fn ir.Node) {
+func compile(fn *ir.Func) {
 	errorsBefore := base.Errors()
 	order(fn)
 	if base.Errors() > errorsBefore {
@@ -234,7 +232,7 @@ func compile(fn ir.Node) {
 	// Set up the function's LSym early to avoid data races with the assemblers.
 	// Do this before walk, as walk needs the LSym to set attributes/relocations
 	// (e.g. in markTypeUsedInInterface).
-	initLSym(fn.Func(), true)
+	initLSym(fn, true)
 
 	walk(fn)
 	if base.Errors() > errorsBefore {
@@ -259,15 +257,15 @@ func compile(fn ir.Node) {
 	// be types of stack objects. We need to do this here
 	// because symbols must be allocated before the parallel
 	// phase of the compiler.
-	for _, n := range fn.Func().Dcl {
+	for _, n := range fn.Dcl {
 		switch n.Class() {
 		case ir.PPARAM, ir.PPARAMOUT, ir.PAUTO:
 			if livenessShouldTrack(n) && n.Name().Addrtaken() {
 				dtypesym(n.Type())
 				// Also make sure we allocate a linker symbol
 				// for the stack object data, for the same reason.
-				if fn.Func().LSym.Func().StackObjects == nil {
-					fn.Func().LSym.Func().StackObjects = base.Ctxt.Lookup(fn.Func().LSym.Name + ".stkobj")
+				if fn.LSym.Func().StackObjects == nil {
+					fn.LSym.Func().StackObjects = base.Ctxt.Lookup(fn.LSym.Name + ".stkobj")
 				}
 			}
 		}
@@ -284,7 +282,7 @@ func compile(fn ir.Node) {
 // If functions are not compiled immediately,
 // they are enqueued in compilequeue,
 // which is drained by compileFunctions.
-func compilenow(fn ir.Node) bool {
+func compilenow(fn *ir.Func) bool {
 	// Issue 38068: if this function is a method AND an inline
 	// candidate AND was not inlined (yet), put it onto the compile
 	// queue instead of compiling it immediately. This is in case we
@@ -299,8 +297,8 @@ func compilenow(fn ir.Node) bool {
 // isInlinableButNotInlined returns true if 'fn' was marked as an
 // inline candidate but then never inlined (presumably because we
 // found no call sites).
-func isInlinableButNotInlined(fn ir.Node) bool {
-	if fn.Func().Nname.Func().Inl == nil {
+func isInlinableButNotInlined(fn *ir.Func) bool {
+	if fn.Inl == nil {
 		return false
 	}
 	if fn.Sym() == nil {
@@ -315,7 +313,7 @@ const maxStackSize = 1 << 30
 // uses it to generate a plist,
 // and flushes that plist to machine code.
 // worker indicates which of the backend workers is doing the processing.
-func compileSSA(fn ir.Node, worker int) {
+func compileSSA(fn *ir.Func, worker int) {
 	f := buildssa(fn, worker)
 	// Note: check arg size to fix issue 25507.
 	if f.Frontend().(*ssafn).stksize >= maxStackSize || fn.Type().ArgWidth() >= maxStackSize {
@@ -343,7 +341,7 @@ func compileSSA(fn ir.Node, worker int) {
 
 	pp.Flush() // assemble, fill in boilerplate, etc.
 	// fieldtrack must be called after pp.Flush. See issue 20014.
-	fieldtrack(pp.Text.From.Sym, fn.Func().FieldTrack)
+	fieldtrack(pp.Text.From.Sym, fn.FieldTrack)
 }
 
 func init() {
@@ -360,7 +358,7 @@ func compileFunctions() {
 		sizeCalculationDisabled = true // not safe to calculate sizes concurrently
 		if race.Enabled {
 			// Randomize compilation order to try to shake out races.
-			tmp := make([]ir.Node, len(compilequeue))
+			tmp := make([]*ir.Func, len(compilequeue))
 			perm := rand.Perm(len(compilequeue))
 			for i, v := range perm {
 				tmp[v] = compilequeue[i]
@@ -376,7 +374,7 @@ func compileFunctions() {
 		}
 		var wg sync.WaitGroup
 		base.Ctxt.InParallel = true
-		c := make(chan ir.Node, base.Flag.LowerC)
+		c := make(chan *ir.Func, base.Flag.LowerC)
 		for i := 0; i < base.Flag.LowerC; i++ {
 			wg.Add(1)
 			go func(worker int) {
@@ -398,9 +396,10 @@ func compileFunctions() {
 }
 
 func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.Scope, dwarf.InlCalls) {
-	fn := curfn.(ir.Node)
-	if fn.Func().Nname != nil {
-		if expect := fn.Func().Nname.Sym().Linksym(); fnsym != expect {
+	fn := curfn.(*ir.Func)
+
+	if fn.Nname != nil {
+		if expect := fn.Sym().Linksym(); fnsym != expect {
 			base.Fatalf("unexpected fnsym: %v != %v", fnsym, expect)
 		}
 	}
@@ -430,12 +429,19 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 	//
 	// These two adjustments keep toolstash -cmp working for now.
 	// Deciding the right answer is, as they say, future work.
-	isODCLFUNC := fn.Op() == ir.ODCLFUNC
+	//
+	// We can tell the difference between the old ODCLFUNC and ONAME
+	// cases by looking at the infosym.Name. If it's empty, DebugInfo is
+	// being called from (*obj.Link).populateDWARF, which used to use
+	// the ODCLFUNC. If it's non-empty (the name will end in $abstract),
+	// DebugInfo is being called from (*obj.Link).DwarfAbstractFunc,
+	// which used to use the ONAME form.
+	isODCLFUNC := infosym.Name == ""
 
 	var apdecls []ir.Node
 	// Populate decls for fn.
 	if isODCLFUNC {
-		for _, n := range fn.Func().Dcl {
+		for _, n := range fn.Dcl {
 			if n.Op() != ir.ONAME { // might be OTYPE or OLITERAL
 				continue
 			}
@@ -457,7 +463,7 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 		}
 	}
 
-	decls, dwarfVars := createDwarfVars(fnsym, isODCLFUNC, fn.Func(), apdecls)
+	decls, dwarfVars := createDwarfVars(fnsym, isODCLFUNC, fn, apdecls)
 
 	// For each type referenced by the functions auto vars but not
 	// already referenced by a dwarf var, attach an R_USETYPE relocation to
@@ -478,7 +484,7 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 	var varScopes []ir.ScopeID
 	for _, decl := range decls {
 		pos := declPos(decl)
-		varScopes = append(varScopes, findScope(fn.Func().Marks, pos))
+		varScopes = append(varScopes, findScope(fn.Marks, pos))
 	}
 
 	scopes := assembleScopes(fnsym, fn, dwarfVars, varScopes)
@@ -709,9 +715,9 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []ir.
 // names of the variables may have been "versioned" to avoid conflicts
 // with local vars; disregard this versioning when sorting.
 func preInliningDcls(fnsym *obj.LSym) []ir.Node {
-	fn := base.Ctxt.DwFixups.GetPrecursorFunc(fnsym).(ir.Node)
+	fn := base.Ctxt.DwFixups.GetPrecursorFunc(fnsym).(*ir.Func)
 	var rdcl []ir.Node
-	for _, n := range fn.Func().Inl.Dcl {
+	for _, n := range fn.Inl.Dcl {
 		c := n.Sym().Name[0]
 		// Avoid reporting "_" parameters, since if there are more than
 		// one, it can result in a collision later on, as in #23179.
diff --git a/src/cmd/compile/internal/gc/pgen_test.go b/src/cmd/compile/internal/gc/pgen_test.go
index 1984f9aa08..35ce087af6 100644
--- a/src/cmd/compile/internal/gc/pgen_test.go
+++ b/src/cmd/compile/internal/gc/pgen_test.go
@@ -26,19 +26,19 @@ func typeWithPointers() *types.Type {
 	return t
 }
 
-func markUsed(n ir.Node) ir.Node {
-	n.Name().SetUsed(true)
+func markUsed(n *ir.Name) *ir.Name {
+	n.SetUsed(true)
 	return n
 }
 
-func markNeedZero(n ir.Node) ir.Node {
-	n.Name().SetNeedzero(true)
+func markNeedZero(n *ir.Name) *ir.Name {
+	n.SetNeedzero(true)
 	return n
 }
 
 // Test all code paths for cmpstackvarlt.
 func TestCmpstackvar(t *testing.T) {
-	nod := func(xoffset int64, t *types.Type, s *types.Sym, cl ir.Class) ir.Node {
+	nod := func(xoffset int64, t *types.Type, s *types.Sym, cl ir.Class) *ir.Name {
 		if s == nil {
 			s = &types.Sym{Name: "."}
 		}
@@ -49,7 +49,7 @@ func TestCmpstackvar(t *testing.T) {
 		return n
 	}
 	testdata := []struct {
-		a, b ir.Node
+		a, b *ir.Name
 		lt   bool
 	}{
 		{
@@ -156,14 +156,14 @@ func TestCmpstackvar(t *testing.T) {
 }
 
 func TestStackvarSort(t *testing.T) {
-	nod := func(xoffset int64, t *types.Type, s *types.Sym, cl ir.Class) ir.Node {
+	nod := func(xoffset int64, t *types.Type, s *types.Sym, cl ir.Class) *ir.Name {
 		n := NewName(s)
 		n.SetType(t)
 		n.SetOffset(xoffset)
 		n.SetClass(cl)
 		return n
 	}
-	inp := []ir.Node{
+	inp := []*ir.Name{
 		nod(0, &types.Type{}, &types.Sym{}, ir.PFUNC),
 		nod(0, &types.Type{}, &types.Sym{}, ir.PAUTO),
 		nod(0, &types.Type{}, &types.Sym{}, ir.PFUNC),
@@ -178,7 +178,7 @@ func TestStackvarSort(t *testing.T) {
 		nod(0, &types.Type{}, &types.Sym{Name: "abc"}, ir.PAUTO),
 		nod(0, &types.Type{}, &types.Sym{Name: "xyz"}, ir.PAUTO),
 	}
-	want := []ir.Node{
+	want := []*ir.Name{
 		nod(0, &types.Type{}, &types.Sym{}, ir.PFUNC),
 		nod(0, &types.Type{}, &types.Sym{}, ir.PFUNC),
 		nod(10, &types.Type{}, &types.Sym{}, ir.PFUNC),
diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/gc/plive.go
index e3a9b2a198..6ad3140081 100644
--- a/src/cmd/compile/internal/gc/plive.go
+++ b/src/cmd/compile/internal/gc/plive.go
@@ -101,7 +101,7 @@ type BlockEffects struct {
 
 // A collection of global state used by liveness analysis.
 type Liveness struct {
-	fn         ir.Node
+	fn         *ir.Func
 	f          *ssa.Func
 	vars       []ir.Node
 	idx        map[ir.Node]int32
@@ -212,9 +212,9 @@ func livenessShouldTrack(n ir.Node) bool {
 
 // getvariables returns the list of on-stack variables that we need to track
 // and a map for looking up indices by *Node.
-func getvariables(fn ir.Node) ([]ir.Node, map[ir.Node]int32) {
+func getvariables(fn *ir.Func) ([]ir.Node, map[ir.Node]int32) {
 	var vars []ir.Node
-	for _, n := range fn.Func().Dcl {
+	for _, n := range fn.Dcl {
 		if livenessShouldTrack(n) {
 			vars = append(vars, n)
 		}
@@ -356,7 +356,7 @@ type livenessFuncCache struct {
 // Constructs a new liveness structure used to hold the global state of the
 // liveness computation. The cfg argument is a slice of *BasicBlocks and the
 // vars argument is a slice of *Nodes.
-func newliveness(fn ir.Node, f *ssa.Func, vars []ir.Node, idx map[ir.Node]int32, stkptrsize int64) *Liveness {
+func newliveness(fn *ir.Func, f *ssa.Func, vars []ir.Node, idx map[ir.Node]int32, stkptrsize int64) *Liveness {
 	lv := &Liveness{
 		fn:         fn,
 		f:          f,
@@ -788,7 +788,7 @@ func (lv *Liveness) epilogue() {
 	// pointers to copy values back to the stack).
 	// TODO: if the output parameter is heap-allocated, then we
 	// don't need to keep the stack copy live?
-	if lv.fn.Func().HasDefer() {
+	if lv.fn.HasDefer() {
 		for i, n := range lv.vars {
 			if n.Class() == ir.PPARAMOUT {
 				if n.Name().IsOutputParamHeapAddr() {
@@ -891,7 +891,7 @@ func (lv *Liveness) epilogue() {
 				if n.Class() == ir.PPARAM {
 					continue // ok
 				}
-				base.Fatalf("bad live variable at entry of %v: %L", lv.fn.Func().Nname, n)
+				base.Fatalf("bad live variable at entry of %v: %L", lv.fn.Nname, n)
 			}
 
 			// Record live variables.
@@ -904,7 +904,7 @@ func (lv *Liveness) epilogue() {
 	}
 
 	// If we have an open-coded deferreturn call, make a liveness map for it.
-	if lv.fn.Func().OpenCodedDeferDisallowed() {
+	if lv.fn.OpenCodedDeferDisallowed() {
 		lv.livenessMap.deferreturn = LivenessDontCare
 	} else {
 		lv.livenessMap.deferreturn = LivenessIndex{
@@ -922,7 +922,7 @@ func (lv *Liveness) epilogue() {
 	// input parameters.
 	for j, n := range lv.vars {
 		if n.Class() != ir.PPARAM && lv.stackMaps[0].Get(int32(j)) {
-			lv.f.Fatalf("%v %L recorded as live on entry", lv.fn.Func().Nname, n)
+			lv.f.Fatalf("%v %L recorded as live on entry", lv.fn.Nname, n)
 		}
 	}
 }
@@ -980,7 +980,7 @@ func (lv *Liveness) showlive(v *ssa.Value, live bvec) {
 		return
 	}
 
-	pos := lv.fn.Func().Nname.Pos()
+	pos := lv.fn.Nname.Pos()
 	if v != nil {
 		pos = v.Pos
 	}
@@ -1090,7 +1090,7 @@ func (lv *Liveness) printDebug() {
 
 		if b == lv.f.Entry {
 			live := lv.stackMaps[0]
-			fmt.Printf("(%s) function entry\n", base.FmtPos(lv.fn.Func().Nname.Pos()))
+			fmt.Printf("(%s) function entry\n", base.FmtPos(lv.fn.Nname.Pos()))
 			fmt.Printf("\tlive=")
 			printed = false
 			for j, n := range lv.vars {
@@ -1266,7 +1266,7 @@ func liveness(e *ssafn, f *ssa.Func, pp *Progs) LivenessMap {
 	}
 
 	// Emit the live pointer map data structures
-	ls := e.curfn.Func().LSym
+	ls := e.curfn.LSym
 	fninfo := ls.Func()
 	fninfo.GCArgs, fninfo.GCLocals = lv.emit()
 
diff --git a/src/cmd/compile/internal/gc/racewalk.go b/src/cmd/compile/internal/gc/racewalk.go
index c41d923f78..6b5d53e806 100644
--- a/src/cmd/compile/internal/gc/racewalk.go
+++ b/src/cmd/compile/internal/gc/racewalk.go
@@ -60,13 +60,13 @@ func ispkgin(pkgs []string) bool {
 	return false
 }
 
-func instrument(fn ir.Node) {
-	if fn.Func().Pragma&ir.Norace != 0 {
+func instrument(fn *ir.Func) {
+	if fn.Pragma&ir.Norace != 0 {
 		return
 	}
 
 	if !base.Flag.Race || !ispkgin(norace_inst_pkgs) {
-		fn.Func().SetInstrumentBody(true)
+		fn.SetInstrumentBody(true)
 	}
 
 	if base.Flag.Race {
@@ -74,8 +74,8 @@ func instrument(fn ir.Node) {
 		base.Pos = src.NoXPos
 
 		if thearch.LinkArch.Arch.Family != sys.AMD64 {
-			fn.Func().Enter.Prepend(mkcall("racefuncenterfp", nil, nil))
-			fn.Func().Exit.Append(mkcall("racefuncexit", nil, nil))
+			fn.Enter.Prepend(mkcall("racefuncenterfp", nil, nil))
+			fn.Exit.Append(mkcall("racefuncexit", nil, nil))
 		} else {
 
 			// nodpc is the PC of the caller as extracted by
@@ -83,12 +83,12 @@ func instrument(fn ir.Node) {
 			// This only works for amd64. This will not
 			// work on arm or others that might support
 			// race in the future.
-			nodpc := ir.Copy(nodfp)
+			nodpc := ir.Copy(nodfp).(*ir.Name)
 			nodpc.SetType(types.Types[types.TUINTPTR])
 			nodpc.SetOffset(int64(-Widthptr))
-			fn.Func().Dcl = append(fn.Func().Dcl, nodpc)
-			fn.Func().Enter.Prepend(mkcall("racefuncenter", nil, nil, nodpc))
-			fn.Func().Exit.Append(mkcall("racefuncexit", nil, nil))
+			fn.Dcl = append(fn.Dcl, nodpc)
+			fn.Enter.Prepend(mkcall("racefuncenter", nil, nil, nodpc))
+			fn.Exit.Append(mkcall("racefuncexit", nil, nil))
 		}
 		base.Pos = lno
 	}
diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index 0ff00cca44..d52fad5fec 100644
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -593,7 +593,7 @@ func arrayClear(n, v1, v2, a ir.Node) bool {
 	var fn ir.Node
 	if a.Type().Elem().HasPointers() {
 		// memclrHasPointers(hp, hn)
-		Curfn.Func().SetWBPos(stmt.Pos())
+		Curfn.SetWBPos(stmt.Pos())
 		fn = mkcall("memclrHasPointers", nil, nil, hp, hn)
 	} else {
 		// memclrNoHeapPointers(hp, hn)
diff --git a/src/cmd/compile/internal/gc/scc.go b/src/cmd/compile/internal/gc/scc.go
index fe7956d5d5..063aaa09bd 100644
--- a/src/cmd/compile/internal/gc/scc.go
+++ b/src/cmd/compile/internal/gc/scc.go
@@ -32,10 +32,10 @@ import "cmd/compile/internal/ir"
 // when analyzing a set of mutually recursive functions.
 
 type bottomUpVisitor struct {
-	analyze  func([]ir.Node, bool)
+	analyze  func([]*ir.Func, bool)
 	visitgen uint32
-	nodeID   map[ir.Node]uint32
-	stack    []ir.Node
+	nodeID   map[*ir.Func]uint32
+	stack    []*ir.Func
 }
 
 // visitBottomUp invokes analyze on the ODCLFUNC nodes listed in list.
@@ -51,18 +51,18 @@ type bottomUpVisitor struct {
 // If recursive is false, the list consists of only a single function and its closures.
 // If recursive is true, the list may still contain only a single function,
 // if that function is itself recursive.
-func visitBottomUp(list []ir.Node, analyze func(list []ir.Node, recursive bool)) {
+func visitBottomUp(list []ir.Node, analyze func(list []*ir.Func, recursive bool)) {
 	var v bottomUpVisitor
 	v.analyze = analyze
-	v.nodeID = make(map[ir.Node]uint32)
+	v.nodeID = make(map[*ir.Func]uint32)
 	for _, n := range list {
 		if n.Op() == ir.ODCLFUNC && !n.Func().IsHiddenClosure() {
-			v.visit(n)
+			v.visit(n.(*ir.Func))
 		}
 	}
 }
 
-func (v *bottomUpVisitor) visit(n ir.Node) uint32 {
+func (v *bottomUpVisitor) visit(n *ir.Func) uint32 {
 	if id := v.nodeID[n]; id > 0 {
 		// already visited
 		return id
@@ -80,41 +80,41 @@ func (v *bottomUpVisitor) visit(n ir.Node) uint32 {
 		case ir.ONAME:
 			if n.Class() == ir.PFUNC {
 				if n != nil && n.Name().Defn != nil {
-					if m := v.visit(n.Name().Defn); m < min {
+					if m := v.visit(n.Name().Defn.(*ir.Func)); m < min {
 						min = m
 					}
 				}
 			}
 		case ir.OMETHEXPR:
 			fn := methodExprName(n)
-			if fn != nil && fn.Name().Defn != nil {
-				if m := v.visit(fn.Name().Defn); m < min {
+			if fn != nil && fn.Defn != nil {
+				if m := v.visit(fn.Defn.(*ir.Func)); m < min {
 					min = m
 				}
 			}
 		case ir.ODOTMETH:
 			fn := methodExprName(n)
-			if fn != nil && fn.Op() == ir.ONAME && fn.Class() == ir.PFUNC && fn.Name().Defn != nil {
-				if m := v.visit(fn.Name().Defn); m < min {
+			if fn != nil && fn.Op() == ir.ONAME && fn.Class() == ir.PFUNC && fn.Defn != nil {
+				if m := v.visit(fn.Defn.(*ir.Func)); m < min {
 					min = m
 				}
 			}
 		case ir.OCALLPART:
 			fn := ir.AsNode(callpartMethod(n).Nname)
 			if fn != nil && fn.Op() == ir.ONAME && fn.Class() == ir.PFUNC && fn.Name().Defn != nil {
-				if m := v.visit(fn.Name().Defn); m < min {
+				if m := v.visit(fn.Name().Defn.(*ir.Func)); m < min {
 					min = m
 				}
 			}
 		case ir.OCLOSURE:
-			if m := v.visit(n.Func().Decl); m < min {
+			if m := v.visit(n.Func()); m < min {
 				min = m
 			}
 		}
 		return true
 	})
 
-	if (min == id || min == id+1) && !n.Func().IsHiddenClosure() {
+	if (min == id || min == id+1) && !n.IsHiddenClosure() {
 		// This node is the root of a strongly connected component.
 
 		// The original min passed to visitcodelist was v.nodeID[n]+1.
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 1a13b14376..91faf18a1d 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -40,7 +40,7 @@ const ssaDumpFile = "ssa.html"
 const maxOpenDefers = 8
 
 // ssaDumpInlined holds all inlined functions when ssaDump contains a function name.
-var ssaDumpInlined []ir.Node
+var ssaDumpInlined []*ir.Func
 
 func initssaconfig() {
 	types_ := ssa.NewTypes()
@@ -242,8 +242,8 @@ func dvarint(x *obj.LSym, off int, v int64) int {
 //      - Size of the argument
 //      - Offset of where argument should be placed in the args frame when making call
 func (s *state) emitOpenDeferInfo() {
-	x := base.Ctxt.Lookup(s.curfn.Func().LSym.Name + ".opendefer")
-	s.curfn.Func().LSym.Func().OpenCodedDeferInfo = x
+	x := base.Ctxt.Lookup(s.curfn.LSym.Name + ".opendefer")
+	s.curfn.LSym.Func().OpenCodedDeferInfo = x
 	off := 0
 
 	// Compute maxargsize (max size of arguments for all defers)
@@ -289,7 +289,7 @@ func (s *state) emitOpenDeferInfo() {
 
 // buildssa builds an SSA function for fn.
 // worker indicates which of the backend workers is doing the processing.
-func buildssa(fn ir.Node, worker int) *ssa.Func {
+func buildssa(fn *ir.Func, worker int) *ssa.Func {
 	name := ir.FuncName(fn)
 	printssa := false
 	if ssaDump != "" { // match either a simple name e.g. "(*Reader).Reset", or a package.name e.g. "compress/gzip.(*Reader).Reset"
@@ -298,9 +298,9 @@ func buildssa(fn ir.Node, worker int) *ssa.Func {
 	var astBuf *bytes.Buffer
 	if printssa {
 		astBuf = &bytes.Buffer{}
-		ir.FDumpList(astBuf, "buildssa-enter", fn.Func().Enter)
+		ir.FDumpList(astBuf, "buildssa-enter", fn.Enter)
 		ir.FDumpList(astBuf, "buildssa-body", fn.Body())
-		ir.FDumpList(astBuf, "buildssa-exit", fn.Func().Exit)
+		ir.FDumpList(astBuf, "buildssa-exit", fn.Exit)
 		if ssaDumpStdout {
 			fmt.Println("generating SSA for", name)
 			fmt.Print(astBuf.String())
@@ -311,8 +311,8 @@ func buildssa(fn ir.Node, worker int) *ssa.Func {
 	s.pushLine(fn.Pos())
 	defer s.popLine()
 
-	s.hasdefer = fn.Func().HasDefer()
-	if fn.Func().Pragma&ir.CgoUnsafeArgs != 0 {
+	s.hasdefer = fn.HasDefer()
+	if fn.Pragma&ir.CgoUnsafeArgs != 0 {
 		s.cgoUnsafeArgs = true
 	}
 
@@ -331,7 +331,7 @@ func buildssa(fn ir.Node, worker int) *ssa.Func {
 	s.f.Name = name
 	s.f.DebugTest = s.f.DebugHashMatch("GOSSAHASH")
 	s.f.PrintOrHtmlSSA = printssa
-	if fn.Func().Pragma&ir.Nosplit != 0 {
+	if fn.Pragma&ir.Nosplit != 0 {
 		s.f.NoSplit = true
 	}
 	s.panics = map[funcLine]*ssa.Block{}
@@ -359,7 +359,7 @@ func buildssa(fn ir.Node, worker int) *ssa.Func {
 	s.fwdVars = map[ir.Node]*ssa.Value{}
 	s.startmem = s.entryNewValue0(ssa.OpInitMem, types.TypeMem)
 
-	s.hasOpenDefers = base.Flag.N == 0 && s.hasdefer && !s.curfn.Func().OpenCodedDeferDisallowed()
+	s.hasOpenDefers = base.Flag.N == 0 && s.hasdefer && !s.curfn.OpenCodedDeferDisallowed()
 	switch {
 	case s.hasOpenDefers && (base.Ctxt.Flag_shared || base.Ctxt.Flag_dynlink) && thearch.LinkArch.Name == "386":
 		// Don't support open-coded defers for 386 ONLY when using shared
@@ -368,7 +368,7 @@ func buildssa(fn ir.Node, worker int) *ssa.Func {
 		// that we don't track correctly.
 		s.hasOpenDefers = false
 	}
-	if s.hasOpenDefers && s.curfn.Func().Exit.Len() > 0 {
+	if s.hasOpenDefers && s.curfn.Exit.Len() > 0 {
 		// Skip doing open defers if there is any extra exit code (likely
 		// copying heap-allocated return values or race detection), since
 		// we will not generate that code in the case of the extra
@@ -376,7 +376,7 @@ func buildssa(fn ir.Node, worker int) *ssa.Func {
 		s.hasOpenDefers = false
 	}
 	if s.hasOpenDefers &&
-		s.curfn.Func().NumReturns*s.curfn.Func().NumDefers > 15 {
+		s.curfn.NumReturns*s.curfn.NumDefers > 15 {
 		// Since we are generating defer calls at every exit for
 		// open-coded defers, skip doing open-coded defers if there are
 		// too many returns (especially if there are multiple defers).
@@ -413,7 +413,7 @@ func buildssa(fn ir.Node, worker int) *ssa.Func {
 	s.decladdrs = map[ir.Node]*ssa.Value{}
 	var args []ssa.Param
 	var results []ssa.Param
-	for _, n := range fn.Func().Dcl {
+	for _, n := range fn.Dcl {
 		switch n.Class() {
 		case ir.PPARAM:
 			s.decladdrs[n] = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(n.Type()), n, s.sp, s.startmem)
@@ -440,7 +440,7 @@ func buildssa(fn ir.Node, worker int) *ssa.Func {
 	}
 
 	// Populate SSAable arguments.
-	for _, n := range fn.Func().Dcl {
+	for _, n := range fn.Dcl {
 		if n.Class() == ir.PPARAM && s.canSSA(n) {
 			v := s.newValue0A(ssa.OpArg, n.Type(), n)
 			s.vars[n] = v
@@ -449,12 +449,12 @@ func buildssa(fn ir.Node, worker int) *ssa.Func {
 	}
 
 	// Convert the AST-based IR to the SSA-based IR
-	s.stmtList(fn.Func().Enter)
+	s.stmtList(fn.Enter)
 	s.stmtList(fn.Body())
 
 	// fallthrough to exit
 	if s.curBlock != nil {
-		s.pushLine(fn.Func().Endlineno)
+		s.pushLine(fn.Endlineno)
 		s.exit()
 		s.popLine()
 	}
@@ -477,10 +477,10 @@ func buildssa(fn ir.Node, worker int) *ssa.Func {
 	return s.f
 }
 
-func dumpSourcesColumn(writer *ssa.HTMLWriter, fn ir.Node) {
+func dumpSourcesColumn(writer *ssa.HTMLWriter, fn *ir.Func) {
 	// Read sources of target function fn.
 	fname := base.Ctxt.PosTable.Pos(fn.Pos()).Filename()
-	targetFn, err := readFuncLines(fname, fn.Pos().Line(), fn.Func().Endlineno.Line())
+	targetFn, err := readFuncLines(fname, fn.Pos().Line(), fn.Endlineno.Line())
 	if err != nil {
 		writer.Logf("cannot read sources for function %v: %v", fn, err)
 	}
@@ -488,13 +488,7 @@ func dumpSourcesColumn(writer *ssa.HTMLWriter, fn ir.Node) {
 	// Read sources of inlined functions.
 	var inlFns []*ssa.FuncLines
 	for _, fi := range ssaDumpInlined {
-		var elno src.XPos
-		if fi.Name().Defn == nil {
-			// Endlineno is filled from exported data.
-			elno = fi.Func().Endlineno
-		} else {
-			elno = fi.Name().Defn.Func().Endlineno
-		}
+		elno := fi.Endlineno
 		fname := base.Ctxt.PosTable.Pos(fi.Pos()).Filename()
 		fnLines, err := readFuncLines(fname, fi.Pos().Line(), elno.Line())
 		if err != nil {
@@ -593,7 +587,7 @@ type state struct {
 	f *ssa.Func
 
 	// Node for function
-	curfn ir.Node
+	curfn *ir.Func
 
 	// labels in f
 	labels map[string]*ssaLabel
@@ -972,7 +966,7 @@ func (s *state) newValueOrSfCall2(op ssa.Op, t *types.Type, arg0, arg1 *ssa.Valu
 }
 
 func (s *state) instrument(t *types.Type, addr *ssa.Value, wr bool) {
-	if !s.curfn.Func().InstrumentBody() {
+	if !s.curfn.InstrumentBody() {
 		return
 	}
 
@@ -1571,7 +1565,7 @@ func (s *state) exit() *ssa.Block {
 
 	// Run exit code. Typically, this code copies heap-allocated PPARAMOUT
 	// variables back to the stack.
-	s.stmtList(s.curfn.Func().Exit)
+	s.stmtList(s.curfn.Exit)
 
 	// Store SSAable PPARAMOUT variables back to stack locations.
 	for _, n := range s.returns {
@@ -4296,7 +4290,7 @@ func (s *state) openDeferSave(n ir.Node, t *types.Type, val *ssa.Value) *ssa.Val
 		pos = n.Pos()
 	}
 	argTemp := tempAt(pos.WithNotStmt(), s.curfn, t)
-	argTemp.Name().SetOpenDeferSlot(true)
+	argTemp.SetOpenDeferSlot(true)
 	var addrArgTemp *ssa.Value
 	// Use OpVarLive to make sure stack slots for the args, etc. are not
 	// removed by dead-store elimination
@@ -4322,7 +4316,7 @@ func (s *state) openDeferSave(n ir.Node, t *types.Type, val *ssa.Value) *ssa.Val
 		// Therefore, we must make sure it is zeroed out in the entry
 		// block if it contains pointers, else GC may wrongly follow an
 		// uninitialized pointer value.
-		argTemp.Name().SetNeedzero(true)
+		argTemp.SetNeedzero(true)
 	}
 	if !canSSA {
 		a := s.addr(n)
@@ -4790,7 +4784,7 @@ func (s *state) getMethodClosure(fn ir.Node) *ssa.Value {
 	// We get back an SSA value representing &sync.(*Mutex).Unlock·f.
 	// We can then pass that to defer or go.
 	n2 := ir.NewNameAt(fn.Pos(), fn.Sym())
-	n2.Name().Curfn = s.curfn
+	n2.Curfn = s.curfn
 	n2.SetClass(ir.PFUNC)
 	// n2.Sym already existed, so it's already marked as a function.
 	n2.SetPos(fn.Pos())
@@ -5023,7 +5017,7 @@ func (s *state) exprPtr(n ir.Node, bounded bool, lineno src.XPos) *ssa.Value {
 // Used only for automatically inserted nil checks,
 // not for user code like 'x != nil'.
 func (s *state) nilCheck(ptr *ssa.Value) {
-	if base.Debug.DisableNil != 0 || s.curfn.Func().NilCheckDisabled() {
+	if base.Debug.DisableNil != 0 || s.curfn.NilCheckDisabled() {
 		return
 	}
 	s.newValue2(ssa.OpNilCheck, types.TypeVoid, ptr, s.mem())
@@ -6197,7 +6191,7 @@ func (s byXoffset) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 
 func emitStackObjects(e *ssafn, pp *Progs) {
 	var vars []ir.Node
-	for _, n := range e.curfn.Func().Dcl {
+	for _, n := range e.curfn.Dcl {
 		if livenessShouldTrack(n) && n.Name().Addrtaken() {
 			vars = append(vars, n)
 		}
@@ -6211,7 +6205,7 @@ func emitStackObjects(e *ssafn, pp *Progs) {
 
 	// Populate the stack object data.
 	// Format must match runtime/stack.go:stackObjectRecord.
-	x := e.curfn.Func().LSym.Func().StackObjects
+	x := e.curfn.LSym.Func().StackObjects
 	off := 0
 	off = duintptr(x, off, uint64(len(vars)))
 	for _, v := range vars {
@@ -6248,7 +6242,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 	s.livenessMap = liveness(e, f, pp)
 	emitStackObjects(e, pp)
 
-	openDeferInfo := e.curfn.Func().LSym.Func().OpenCodedDeferInfo
+	openDeferInfo := e.curfn.LSym.Func().OpenCodedDeferInfo
 	if openDeferInfo != nil {
 		// This function uses open-coded defers -- write out the funcdata
 		// info that we computed at the end of genssa.
@@ -6453,7 +6447,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 				// some of the inline marks.
 				// Use this instruction instead.
 				p.Pos = p.Pos.WithIsStmt() // promote position to a statement
-				pp.curfn.Func().LSym.Func().AddInlMark(p, inlMarks[m])
+				pp.curfn.LSym.Func().AddInlMark(p, inlMarks[m])
 				// Make the inline mark a real nop, so it doesn't generate any code.
 				m.As = obj.ANOP
 				m.Pos = src.NoXPos
@@ -6465,14 +6459,14 @@ func genssa(f *ssa.Func, pp *Progs) {
 		// Any unmatched inline marks now need to be added to the inlining tree (and will generate a nop instruction).
 		for _, p := range inlMarkList {
 			if p.As != obj.ANOP {
-				pp.curfn.Func().LSym.Func().AddInlMark(p, inlMarks[p])
+				pp.curfn.LSym.Func().AddInlMark(p, inlMarks[p])
 			}
 		}
 	}
 
 	if base.Ctxt.Flag_locationlists {
 		debugInfo := ssa.BuildFuncDebug(base.Ctxt, f, base.Debug.LocationLists > 1, stackOffset)
-		e.curfn.Func().DebugInfo = debugInfo
+		e.curfn.DebugInfo = debugInfo
 		bstart := s.bstart
 		// Note that at this moment, Prog.Pc is a sequence number; it's
 		// not a real PC until after assembly, so this mapping has to
@@ -6486,7 +6480,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 				}
 				return bstart[b].Pc
 			case ssa.BlockEnd.ID:
-				return e.curfn.Func().LSym.Size
+				return e.curfn.LSym.Size
 			default:
 				return valueToProgAfter[v].Pc
 			}
@@ -6584,7 +6578,7 @@ func defframe(s *SSAGenState, e *ssafn) {
 	var state uint32
 
 	// Iterate through declarations. They are sorted in decreasing Xoffset order.
-	for _, n := range e.curfn.Func().Dcl {
+	for _, n := range e.curfn.Dcl {
 		if !n.Name().Needzero() {
 			continue
 		}
@@ -6949,7 +6943,7 @@ func fieldIdx(n ir.Node) int {
 // ssafn holds frontend information about a function that the backend is processing.
 // It also exports a bunch of compiler services for the ssa backend.
 type ssafn struct {
-	curfn        ir.Node
+	curfn        *ir.Func
 	strings      map[string]*obj.LSym // map from constant string to data symbols
 	scratchFpMem ir.Node              // temp for floating point register / memory moves on some architectures
 	stksize      int64                // stack size for current frame
@@ -7072,8 +7066,8 @@ func (e *ssafn) SplitSlot(parent *ssa.LocalSlot, suffix string, offset int64, t
 	n.SetType(t)
 	n.SetClass(ir.PAUTO)
 	n.SetEsc(EscNever)
-	n.Name().Curfn = e.curfn
-	e.curfn.Func().Dcl = append(e.curfn.Func().Dcl, n)
+	n.Curfn = e.curfn
+	e.curfn.Dcl = append(e.curfn.Dcl, n)
 	dowidth(t)
 	return ssa.LocalSlot{N: n, Type: t, Off: 0, SplitOf: parent, SplitOffset: offset}
 }
@@ -7136,7 +7130,7 @@ func (e *ssafn) Syslook(name string) *obj.LSym {
 }
 
 func (e *ssafn) SetWBPos(pos src.XPos) {
-	e.curfn.Func().SetWBPos(pos)
+	e.curfn.SetWBPos(pos)
 }
 
 func (e *ssafn) MyImportPath() string {
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 28703205d6..336465db98 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -95,8 +95,8 @@ func autolabel(prefix string) *types.Sym {
 	if Curfn == nil {
 		base.Fatalf("autolabel outside function")
 	}
-	n := fn.Func().Label
-	fn.Func().Label++
+	n := fn.Label
+	fn.Label++
 	return lookupN(prefix, int(n))
 }
 
@@ -138,7 +138,7 @@ func importdot(opkg *types.Pkg, pack *ir.PkgName) {
 // newname returns a new ONAME Node associated with symbol s.
 func NewName(s *types.Sym) *ir.Name {
 	n := ir.NewNameAt(base.Pos, s)
-	n.Name().Curfn = Curfn
+	n.Curfn = Curfn
 	return n
 }
 
@@ -1165,7 +1165,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	tfn.PtrRlist().Set(structargs(method.Type.Results(), false))
 
 	fn := dclfunc(newnam, tfn)
-	fn.Func().SetDupok(true)
+	fn.SetDupok(true)
 
 	nthis := ir.AsNode(tfn.Type().Recv().Nname)
 
@@ -1201,7 +1201,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 		fn.PtrBody().Append(as)
 		fn.PtrBody().Append(nodSym(ir.ORETJMP, nil, methodSym(methodrcvr, method.Sym)))
 	} else {
-		fn.Func().SetWrapper(true) // ignore frame for panic+recover matching
+		fn.SetWrapper(true) // ignore frame for panic+recover matching
 		call := ir.Nod(ir.OCALL, dot, nil)
 		call.PtrList().Set(paramNnames(tfn.Type()))
 		call.SetIsDDD(tfn.Type().IsVariadic())
@@ -1222,8 +1222,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 		testdclstack()
 	}
 
-	fn = typecheck(fn, ctxStmt)
-
+	typecheckFunc(fn)
 	Curfn = fn
 	typecheckslice(fn.Body().Slice(), ctxStmt)
 
@@ -1233,7 +1232,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	if rcvr.IsPtr() && rcvr.Elem() == method.Type.Recv().Type && rcvr.Elem().Sym != nil {
 		inlcalls(fn)
 	}
-	escapeFuncs([]ir.Node{fn}, false)
+	escapeFuncs([]*ir.Func{fn}, false)
 
 	Curfn = nil
 	xtop = append(xtop, fn)
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 4ab47fb406..7d19a2b58e 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -95,7 +95,7 @@ func resolve(n ir.Node) (res ir.Node) {
 			base.Fatalf("recursive inimport")
 		}
 		inimport = true
-		expandDecl(n)
+		expandDecl(n.(*ir.Name))
 		inimport = false
 		return n
 	}
@@ -199,6 +199,13 @@ func cycleTrace(cycle []ir.Node) string {
 
 var typecheck_tcstack []ir.Node
 
+func typecheckFunc(fn *ir.Func) {
+	new := typecheck(fn, ctxStmt)
+	if new != fn {
+		base.Fatalf("typecheck changed func")
+	}
+}
+
 // typecheck type checks node n.
 // The result of typecheck MUST be assigned back to n, e.g.
 // 	n.Left = typecheck(n.Left, top)
@@ -2069,7 +2076,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.ODCLFUNC:
 		ok |= ctxStmt
-		typecheckfunc(n)
+		typecheckfunc(n.(*ir.Func))
 
 	case ir.ODCLCONST:
 		ok |= ctxStmt
@@ -3402,36 +3409,38 @@ out:
 }
 
 // type check function definition
-func typecheckfunc(n ir.Node) {
+// To be called by typecheck, not directly.
+// (Call typecheckfn instead.)
+func typecheckfunc(n *ir.Func) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckfunc", n)(nil)
 	}
 
-	for _, ln := range n.Func().Dcl {
+	for _, ln := range n.Dcl {
 		if ln.Op() == ir.ONAME && (ln.Class() == ir.PPARAM || ln.Class() == ir.PPARAMOUT) {
 			ln.Name().Decldepth = 1
 		}
 	}
 
-	n.Func().Nname = typecheck(n.Func().Nname, ctxExpr|ctxAssign)
-	t := n.Func().Nname.Type()
+	n.Nname = typecheck(n.Nname, ctxExpr|ctxAssign).(*ir.Name)
+	t := n.Nname.Type()
 	if t == nil {
 		return
 	}
 	n.SetType(t)
 	rcvr := t.Recv()
-	if rcvr != nil && n.Func().Shortname != nil {
-		m := addmethod(n, n.Func().Shortname, t, true, n.Func().Pragma&ir.Nointerface != 0)
+	if rcvr != nil && n.Shortname != nil {
+		m := addmethod(n, n.Shortname, t, true, n.Pragma&ir.Nointerface != 0)
 		if m == nil {
 			return
 		}
 
-		n.Func().Nname.SetSym(methodSym(rcvr.Type, n.Func().Shortname))
-		declare(n.Func().Nname, ir.PFUNC)
+		n.Nname.SetSym(methodSym(rcvr.Type, n.Shortname))
+		declare(n.Nname, ir.PFUNC)
 	}
 
-	if base.Ctxt.Flag_dynlink && !inimport && n.Func().Nname != nil {
-		makefuncsym(n.Func().Nname.Sym())
+	if base.Ctxt.Flag_dynlink && !inimport && n.Nname != nil {
+		makefuncsym(n.Sym())
 	}
 }
 
@@ -3861,22 +3870,19 @@ func isTermNode(n ir.Node) bool {
 }
 
 // checkreturn makes sure that fn terminates appropriately.
-func checkreturn(fn ir.Node) {
+func checkreturn(fn *ir.Func) {
 	if fn.Type().NumResults() != 0 && fn.Body().Len() != 0 {
 		var labels map[*types.Sym]ir.Node
 		markbreaklist(&labels, fn.Body(), nil)
 		if !isTermNodes(fn.Body()) {
-			base.ErrorfAt(fn.Func().Endlineno, "missing return at end of function")
+			base.ErrorfAt(fn.Endlineno, "missing return at end of function")
 		}
 	}
 }
 
-func deadcode(fn ir.Node) {
+func deadcode(fn *ir.Func) {
 	deadcodeslice(fn.PtrBody())
-	deadcodefn(fn)
-}
 
-func deadcodefn(fn ir.Node) {
 	if fn.Body().Len() == 0 {
 		return
 	}
@@ -4014,21 +4020,15 @@ func curpkg() *types.Pkg {
 		// Initialization expressions for package-scope variables.
 		return ir.LocalPkg
 	}
-
-	// TODO(mdempsky): Standardize on either ODCLFUNC or ONAME for
-	// Curfn, rather than mixing them.
-	if fn.Op() == ir.ODCLFUNC {
-		fn = fn.Func().Nname
-	}
-
-	return fnpkg(fn)
+	return fnpkg(fn.Nname)
 }
 
 // MethodName returns the ONAME representing the method
 // referenced by expression n, which must be a method selector,
 // method expression, or method value.
-func methodExprName(n ir.Node) ir.Node {
-	return ir.AsNode(methodExprFunc(n).Nname)
+func methodExprName(n ir.Node) *ir.Name {
+	name, _ := ir.AsNode(methodExprFunc(n).Nname).(*ir.Name)
+	return name
 }
 
 // MethodFunc is like MethodName, but returns the types.Field instead.
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index c05aa0c372..d749dff827 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -22,33 +22,33 @@ import (
 const tmpstringbufsize = 32
 const zeroValSize = 1024 // must match value of runtime/map.go:maxZero
 
-func walk(fn ir.Node) {
+func walk(fn *ir.Func) {
 	Curfn = fn
 	errorsBefore := base.Errors()
 
 	if base.Flag.W != 0 {
-		s := fmt.Sprintf("\nbefore walk %v", Curfn.Func().Nname.Sym())
+		s := fmt.Sprintf("\nbefore walk %v", Curfn.Sym())
 		ir.DumpList(s, Curfn.Body())
 	}
 
 	lno := base.Pos
 
 	// Final typecheck for any unused variables.
-	for i, ln := range fn.Func().Dcl {
+	for i, ln := range fn.Dcl {
 		if ln.Op() == ir.ONAME && (ln.Class() == ir.PAUTO || ln.Class() == ir.PAUTOHEAP) {
-			ln = typecheck(ln, ctxExpr|ctxAssign)
-			fn.Func().Dcl[i] = ln
+			ln = typecheck(ln, ctxExpr|ctxAssign).(*ir.Name)
+			fn.Dcl[i] = ln
 		}
 	}
 
 	// Propagate the used flag for typeswitch variables up to the NONAME in its definition.
-	for _, ln := range fn.Func().Dcl {
+	for _, ln := range fn.Dcl {
 		if ln.Op() == ir.ONAME && (ln.Class() == ir.PAUTO || ln.Class() == ir.PAUTOHEAP) && ln.Name().Defn != nil && ln.Name().Defn.Op() == ir.OTYPESW && ln.Name().Used() {
 			ln.Name().Defn.Left().Name().SetUsed(true)
 		}
 	}
 
-	for _, ln := range fn.Func().Dcl {
+	for _, ln := range fn.Dcl {
 		if ln.Op() != ir.ONAME || (ln.Class() != ir.PAUTO && ln.Class() != ir.PAUTOHEAP) || ln.Sym().Name[0] == '&' || ln.Name().Used() {
 			continue
 		}
@@ -69,15 +69,15 @@ func walk(fn ir.Node) {
 	}
 	walkstmtlist(Curfn.Body().Slice())
 	if base.Flag.W != 0 {
-		s := fmt.Sprintf("after walk %v", Curfn.Func().Nname.Sym())
+		s := fmt.Sprintf("after walk %v", Curfn.Sym())
 		ir.DumpList(s, Curfn.Body())
 	}
 
 	zeroResults()
 	heapmoves()
-	if base.Flag.W != 0 && Curfn.Func().Enter.Len() > 0 {
-		s := fmt.Sprintf("enter %v", Curfn.Func().Nname.Sym())
-		ir.DumpList(s, Curfn.Func().Enter)
+	if base.Flag.W != 0 && Curfn.Enter.Len() > 0 {
+		s := fmt.Sprintf("enter %v", Curfn.Sym())
+		ir.DumpList(s, Curfn.Enter)
 	}
 }
 
@@ -87,8 +87,8 @@ func walkstmtlist(s []ir.Node) {
 	}
 }
 
-func paramoutheap(fn ir.Node) bool {
-	for _, ln := range fn.Func().Dcl {
+func paramoutheap(fn *ir.Func) bool {
+	for _, ln := range fn.Dcl {
 		switch ln.Class() {
 		case ir.PPARAMOUT:
 			if isParamStackCopy(ln) || ln.Name().Addrtaken() {
@@ -209,18 +209,18 @@ func walkstmt(n ir.Node) ir.Node {
 		base.Errorf("case statement out of place")
 
 	case ir.ODEFER:
-		Curfn.Func().SetHasDefer(true)
-		Curfn.Func().NumDefers++
-		if Curfn.Func().NumDefers > maxOpenDefers {
+		Curfn.SetHasDefer(true)
+		Curfn.NumDefers++
+		if Curfn.NumDefers > maxOpenDefers {
 			// Don't allow open-coded defers if there are more than
 			// 8 defers in the function, since we use a single
 			// byte to record active defers.
-			Curfn.Func().SetOpenCodedDeferDisallowed(true)
+			Curfn.SetOpenCodedDeferDisallowed(true)
 		}
 		if n.Esc() != EscNever {
 			// If n.Esc is not EscNever, then this defer occurs in a loop,
 			// so open-coded defers cannot be used in this function.
-			Curfn.Func().SetOpenCodedDeferDisallowed(true)
+			Curfn.SetOpenCodedDeferDisallowed(true)
 		}
 		fallthrough
 	case ir.OGO:
@@ -270,7 +270,7 @@ func walkstmt(n ir.Node) ir.Node {
 		walkstmtlist(n.Rlist().Slice())
 
 	case ir.ORETURN:
-		Curfn.Func().NumReturns++
+		Curfn.NumReturns++
 		if n.List().Len() == 0 {
 			break
 		}
@@ -279,12 +279,13 @@ func walkstmt(n ir.Node) ir.Node {
 			// so that reorder3 can fix up conflicts
 			var rl []ir.Node
 
-			for _, ln := range Curfn.Func().Dcl {
+			for _, ln := range Curfn.Dcl {
 				cl := ln.Class()
 				if cl == ir.PAUTO || cl == ir.PAUTOHEAP {
 					break
 				}
 				if cl == ir.PPARAMOUT {
+					var ln ir.Node = ln
 					if isParamStackCopy(ln) {
 						ln = walkexpr(typecheck(ir.Nod(ir.ODEREF, ln.Name().Heapaddr, nil), ctxExpr), nil)
 					}
@@ -800,8 +801,8 @@ opswitch:
 		fromType := n.Left().Type()
 		toType := n.Type()
 
-		if !fromType.IsInterface() && !ir.IsBlank(Curfn.Func().Nname) { // skip unnamed functions (func _())
-			markTypeUsedInInterface(fromType, Curfn.Func().LSym)
+		if !fromType.IsInterface() && !ir.IsBlank(Curfn.Nname) { // skip unnamed functions (func _())
+			markTypeUsedInInterface(fromType, Curfn.LSym)
 		}
 
 		// typeword generates the type word of the interface value.
@@ -1625,7 +1626,7 @@ func markTypeUsedInInterface(t *types.Type, from *obj.LSym) {
 func markUsedIfaceMethod(n ir.Node) {
 	ityp := n.Left().Left().Type()
 	tsym := typenamesym(ityp).Linksym()
-	r := obj.Addrel(Curfn.Func().LSym)
+	r := obj.Addrel(Curfn.LSym)
 	r.Sym = tsym
 	// n.Left.Xoffset is the method index * Widthptr (the offset of code pointer
 	// in itab).
@@ -2448,7 +2449,7 @@ func zeroResults() {
 			v = v.Name().Stackcopy
 		}
 		// Zero the stack location containing f.
-		Curfn.Func().Enter.Append(ir.NodAt(Curfn.Pos(), ir.OAS, v, nil))
+		Curfn.Enter.Append(ir.NodAt(Curfn.Pos(), ir.OAS, v, nil))
 	}
 }
 
@@ -2478,9 +2479,9 @@ func heapmoves() {
 	nn := paramstoheap(Curfn.Type().Recvs())
 	nn = append(nn, paramstoheap(Curfn.Type().Params())...)
 	nn = append(nn, paramstoheap(Curfn.Type().Results())...)
-	Curfn.Func().Enter.Append(nn...)
-	base.Pos = Curfn.Func().Endlineno
-	Curfn.Func().Exit.Append(returnsfromheap(Curfn.Type().Results())...)
+	Curfn.Enter.Append(nn...)
+	base.Pos = Curfn.Endlineno
+	Curfn.Exit.Append(returnsfromheap(Curfn.Type().Results())...)
 	base.Pos = lno
 }
 
@@ -2781,7 +2782,7 @@ func appendslice(n ir.Node, init *ir.Nodes) ir.Node {
 
 		nptr2 := l2
 
-		Curfn.Func().SetWBPos(n.Pos())
+		Curfn.SetWBPos(n.Pos())
 
 		// instantiate typedslicecopy(typ *type, dstPtr *any, dstLen int, srcPtr *any, srcLen int) int
 		fn := syslook("typedslicecopy")
@@ -2966,7 +2967,7 @@ func extendslice(n ir.Node, init *ir.Nodes) ir.Node {
 	hasPointers := elemtype.HasPointers()
 	if hasPointers {
 		clrname = "memclrHasPointers"
-		Curfn.Func().SetWBPos(n.Pos())
+		Curfn.SetWBPos(n.Pos())
 	}
 
 	var clr ir.Nodes
@@ -3100,7 +3101,7 @@ func walkappend(n ir.Node, init *ir.Nodes, dst ir.Node) ir.Node {
 //
 func copyany(n ir.Node, init *ir.Nodes, runtimecall bool) ir.Node {
 	if n.Left().Type().Elem().HasPointers() {
-		Curfn.Func().SetWBPos(n.Pos())
+		Curfn.SetWBPos(n.Pos())
 		fn := writebarrierfn("typedslicecopy", n.Left().Type().Elem(), n.Right().Type().Elem())
 		n.SetLeft(cheapexpr(n.Left(), init))
 		ptrL, lenL := backingArrayPtrLen(n.Left())
@@ -3714,9 +3715,9 @@ func usemethod(n ir.Node) {
 	//       (including global variables such as numImports - was issue #19028).
 	// Also need to check for reflect package itself (see Issue #38515).
 	if s := res0.Type.Sym; s != nil && s.Name == "Method" && isReflectPkg(s.Pkg) {
-		Curfn.Func().SetReflectMethod(true)
+		Curfn.SetReflectMethod(true)
 		// The LSym is initialized at this point. We need to set the attribute on the LSym.
-		Curfn.Func().LSym.Set(obj.AttrReflectMethod, true)
+		Curfn.LSym.Set(obj.AttrReflectMethod, true)
 	}
 }
 
@@ -3765,10 +3766,10 @@ func usefield(n ir.Node) {
 	}
 
 	sym := tracksym(outer, field)
-	if Curfn.Func().FieldTrack == nil {
-		Curfn.Func().FieldTrack = make(map[*types.Sym]struct{})
+	if Curfn.FieldTrack == nil {
+		Curfn.FieldTrack = make(map[*types.Sym]struct{})
 	}
-	Curfn.Func().FieldTrack[sym] = struct{}{}
+	Curfn.FieldTrack[sym] = struct{}{}
 }
 
 func candiscardlist(l ir.Nodes) bool {
@@ -3948,12 +3949,12 @@ func wrapCall(n ir.Node, init *ir.Nodes) ir.Node {
 
 	funcbody()
 
-	fn = typecheck(fn, ctxStmt)
+	typecheckFunc(fn)
 	typecheckslice(fn.Body().Slice(), ctxStmt)
 	xtop = append(xtop, fn)
 
 	call = ir.Nod(ir.OCALL, nil, nil)
-	call.SetLeft(fn.Func().Nname)
+	call.SetLeft(fn.Nname)
 	call.PtrList().Set(n.List().Slice())
 	call = typecheck(call, ctxStmt)
 	call = walkexpr(call, init)
@@ -4091,6 +4092,6 @@ func walkCheckPtrArithmetic(n ir.Node, init *ir.Nodes) ir.Node {
 // checkPtr reports whether pointer checking should be enabled for
 // function fn at a given level. See debugHelpFooter for defined
 // levels.
-func checkPtr(fn ir.Node, level int) bool {
-	return base.Debug.Checkptr >= level && fn.Func().Pragma&ir.NoCheckPtr == 0
+func checkPtr(fn *ir.Func, level int) bool {
+	return base.Debug.Checkptr >= level && fn.Pragma&ir.NoCheckPtr == 0
 }
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 3822c4c73b..a3999b6da0 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -1338,7 +1338,7 @@ func exprFmt(n Node, s fmt.State, prec int, mode FmtMode) {
 			mode.Fprintf(s, "%v { %v }", n.Type(), n.Body())
 			return
 		}
-		mode.Fprintf(s, "%v { %v }", n.Type(), n.Func().Decl.Body())
+		mode.Fprintf(s, "%v { %v }", n.Type(), n.Func().Body())
 
 	case OCOMPLIT:
 		if mode == FErr {
@@ -1638,7 +1638,7 @@ func nodeDumpFmt(n Node, s fmt.State, flag FmtFlag, mode FmtMode) {
 		}
 	}
 
-	if n.Op() == OCLOSURE && n.Func().Decl != nil && n.Func().Nname.Sym() != nil {
+	if n.Op() == OCLOSURE && n.Func() != nil && n.Func().Nname.Sym() != nil {
 		mode.Fprintf(s, " fnName %v", n.Func().Nname.Sym())
 	}
 	if n.Sym() != nil && n.Op() != ONAME {
@@ -1656,15 +1656,15 @@ func nodeDumpFmt(n Node, s fmt.State, flag FmtFlag, mode FmtMode) {
 		if n.Right() != nil {
 			mode.Fprintf(s, "%v", n.Right())
 		}
-		if n.Op() == OCLOSURE && n.Func() != nil && n.Func().Decl != nil && n.Func().Decl.Body().Len() != 0 {
+		if n.Op() == OCLOSURE && n.Func() != nil && n.Func().Body().Len() != 0 {
 			indent(s)
 			// The function associated with a closure
-			mode.Fprintf(s, "%v-clofunc%v", n.Op(), n.Func().Decl)
+			mode.Fprintf(s, "%v-clofunc%v", n.Op(), n.Func())
 		}
 		if n.Op() == ODCLFUNC && n.Func() != nil && n.Func().Dcl != nil && len(n.Func().Dcl) != 0 {
 			indent(s)
 			// The dcls for a func or closure
-			mode.Fprintf(s, "%v-dcl%v", n.Op(), AsNodes(n.Func().Dcl))
+			mode.Fprintf(s, "%v-dcl%v", n.Op(), asNameNodes(n.Func().Dcl))
 		}
 		if n.List().Len() != 0 {
 			indent(s)
@@ -1683,6 +1683,16 @@ func nodeDumpFmt(n Node, s fmt.State, flag FmtFlag, mode FmtMode) {
 	}
 }
 
+// asNameNodes copies list to a new Nodes.
+// It should only be called in debug formatting and other low-performance contexts.
+func asNameNodes(list []*Name) Nodes {
+	var ns Nodes
+	for _, n := range list {
+		ns.Append(n)
+	}
+	return ns
+}
+
 // "%S" suppresses qualifying with package
 func symFormat(s *types.Sym, f fmt.State, verb rune, mode FmtMode) {
 	switch verb {
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 57ec0707e9..92a24c8385 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -53,9 +53,8 @@ type Func struct {
 	body Nodes
 	iota int64
 
-	Nname    Node // ONAME node
-	Decl     Node // ODCLFUNC node
-	OClosure Node // OCLOSURE node
+	Nname    *Name // ONAME node
+	OClosure Node  // OCLOSURE node
 
 	Shortname *types.Sym
 
@@ -65,12 +64,11 @@ type Func struct {
 	Exit  Nodes
 	// ONAME nodes for all params/locals for this func/closure, does NOT
 	// include closurevars until transformclosure runs.
-	Dcl []Node
+	Dcl []*Name
 
-	ClosureEnter  Nodes // list of ONAME nodes of captured variables
-	ClosureType   Node  // closure representation type
-	ClosureCalled bool  // closure is only immediately called
-	ClosureVars   Nodes // closure params; each has closurevar set
+	ClosureEnter Nodes   // list of ONAME nodes (or OADDR-of-ONAME nodes, for output parameters) of captured variables
+	ClosureType  Node    // closure representation type
+	ClosureVars  []*Name // closure params; each has closurevar set
 
 	// Parents records the parent scope of each scope within a
 	// function. The root scope (0) has no parent, so the i'th
@@ -80,17 +78,17 @@ type Func struct {
 	// Marks records scope boundary changes.
 	Marks []Mark
 
-	// Closgen tracks how many closures have been generated within
-	// this function. Used by closurename for creating unique
-	// function names.
-	Closgen int
-
 	FieldTrack map[*types.Sym]struct{}
 	DebugInfo  interface{}
 	LSym       *obj.LSym
 
 	Inl *Inline
 
+	// Closgen tracks how many closures have been generated within
+	// this function. Used by closurename for creating unique
+	// function names.
+	Closgen int32
+
 	Label int32 // largest auto-generated label in this function
 
 	Endlineno src.XPos
@@ -99,8 +97,8 @@ type Func struct {
 	Pragma PragmaFlag // go:xxx function annotations
 
 	flags      bitset16
-	NumDefers  int // number of defer calls in the function
-	NumReturns int // number of explicit returns in the function
+	NumDefers  int32 // number of defer calls in the function
+	NumReturns int32 // number of explicit returns in the function
 
 	// nwbrCalls records the LSyms of functions called by this
 	// function for go:nowritebarrierrec analysis. Only filled in
@@ -112,7 +110,6 @@ func NewFunc(pos src.XPos) *Func {
 	f := new(Func)
 	f.pos = pos
 	f.op = ODCLFUNC
-	f.Decl = f
 	f.iota = -1
 	return f
 }
@@ -141,7 +138,7 @@ type Inline struct {
 	Cost int32 // heuristic cost of inlining this function
 
 	// Copies of Func.Dcl and Nbody for use during inlining.
-	Dcl  []Node
+	Dcl  []*Name
 	Body []Node
 }
 
@@ -172,6 +169,7 @@ const (
 	funcExportInline             // include inline body in export data
 	funcInstrumentBody           // add race/msan instrumentation during SSA construction
 	funcOpenCodedDeferDisallowed // can't do open-coded defers
+	funcClosureCalled            // closure is only immediately called
 )
 
 type SymAndPos struct {
@@ -190,6 +188,7 @@ func (f *Func) InlinabilityChecked() bool      { return f.flags&funcInlinability
 func (f *Func) ExportInline() bool             { return f.flags&funcExportInline != 0 }
 func (f *Func) InstrumentBody() bool           { return f.flags&funcInstrumentBody != 0 }
 func (f *Func) OpenCodedDeferDisallowed() bool { return f.flags&funcOpenCodedDeferDisallowed != 0 }
+func (f *Func) ClosureCalled() bool            { return f.flags&funcClosureCalled != 0 }
 
 func (f *Func) SetDupok(b bool)                    { f.flags.set(funcDupok, b) }
 func (f *Func) SetWrapper(b bool)                  { f.flags.set(funcWrapper, b) }
@@ -202,6 +201,7 @@ func (f *Func) SetInlinabilityChecked(b bool)      { f.flags.set(funcInlinabilit
 func (f *Func) SetExportInline(b bool)             { f.flags.set(funcExportInline, b) }
 func (f *Func) SetInstrumentBody(b bool)           { f.flags.set(funcInstrumentBody, b) }
 func (f *Func) SetOpenCodedDeferDisallowed(b bool) { f.flags.set(funcOpenCodedDeferDisallowed, b) }
+func (f *Func) SetClosureCalled(b bool)            { f.flags.set(funcClosureCalled, b) }
 
 func (f *Func) SetWBPos(pos src.XPos) {
 	if base.Debug.WB != 0 {
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index d330745cfb..5546488fa7 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -32,9 +32,10 @@ type Name struct {
 	// For a local variable (not param) or extern, the initializing assignment (OAS or OAS2).
 	// For a closure var, the ONAME node of the outer captured variable
 	Defn Node
-	// The ODCLFUNC node (for a static function/method or a closure) in which
-	// local variable or param is declared.
-	Curfn Node
+
+	// The function, method, or closure in which local variable or param is declared.
+	Curfn *Func
+
 	// Unique number for ONAME nodes within a function. Function outputs
 	// (results) are numbered starting at one, followed by function inputs
 	// (parameters), and then local variables. Vargen is used to distinguish
diff --git a/src/cmd/compile/internal/ir/sizeof_test.go b/src/cmd/compile/internal/ir/sizeof_test.go
index 8597ad492a..9321f765e0 100644
--- a/src/cmd/compile/internal/ir/sizeof_test.go
+++ b/src/cmd/compile/internal/ir/sizeof_test.go
@@ -20,8 +20,8 @@ func TestSizeof(t *testing.T) {
 		_32bit uintptr     // size on 32bit platforms
 		_64bit uintptr     // size on 64bit platforms
 	}{
-		{Func{}, 180, 320},
-		{Name{}, 132, 232},
+		{Func{}, 172, 296},
+		{Name{}, 128, 224},
 		{node{}, 84, 144},
 	}
 
-- 
GitLab


From 4eaef981b5b5bac873256d63ffecaaa73fb5f28b Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 26 Nov 2020 00:47:44 -0500
Subject: [PATCH 0090/2400] [dev.regabi] cmd/compile: add ir.Closure,
 ir.ClosureRead

Closures are another reference to Funcs,
and it cleans up the code quite a bit to be clear about types.

OCLOSUREVAR is renamed to OCLOSUREREAD to make
clearer that it is unrelated to the list Func.ClosureVars.

Passes buildall w/ toolstash -cmp.

Change-Id: Id0d28df2d4d6e9954e34df7a39ea226995eee937
Reviewed-on: https://go-review.googlesource.com/c/go/+/274098
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/closure.go     | 32 ++++++++----------
 src/cmd/compile/internal/gc/escape.go      |  4 +--
 src/cmd/compile/internal/gc/inl.go         |  4 +--
 src/cmd/compile/internal/gc/ssa.go         |  4 +--
 src/cmd/compile/internal/gc/typecheck.go   |  6 ++--
 src/cmd/compile/internal/gc/walk.go        |  2 +-
 src/cmd/compile/internal/ir/expr.go        | 39 ++++++++++++++++++++++
 src/cmd/compile/internal/ir/func.go        |  4 +--
 src/cmd/compile/internal/ir/node.go        | 30 ++++++++---------
 src/cmd/compile/internal/ir/op_string.go   |  6 ++--
 src/cmd/compile/internal/ir/sizeof_test.go |  2 +-
 11 files changed, 82 insertions(+), 51 deletions(-)

diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index 0cf59ee0eb..e8a0617be3 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -23,8 +23,7 @@ func (p *noder) funcLit(expr *syntax.FuncLit) ir.Node {
 	fn.Nname.Ntype = xtype
 	fn.Nname.Defn = fn
 
-	clo := p.nod(expr, ir.OCLOSURE, nil, nil)
-	clo.SetFunc(fn)
+	clo := ir.NewClosureExpr(p.pos(expr), fn)
 	fn.ClosureType = ntype
 	fn.OClosure = clo
 
@@ -285,21 +284,19 @@ func transformclosure(fn *ir.Func) {
 		offset := int64(Widthptr)
 		for _, v := range fn.ClosureVars {
 			// cv refers to the field inside of closure OSTRUCTLIT.
-			cv := ir.Nod(ir.OCLOSUREVAR, nil, nil)
-
-			cv.SetType(v.Type())
+			typ := v.Type()
 			if !v.Byval() {
-				cv.SetType(types.NewPtr(v.Type()))
+				typ = types.NewPtr(typ)
 			}
-			offset = Rnd(offset, int64(cv.Type().Align))
-			cv.SetOffset(offset)
-			offset += cv.Type().Width
+			offset = Rnd(offset, int64(typ.Align))
+			cr := ir.NewClosureRead(typ, offset)
+			offset += typ.Width
 
 			if v.Byval() && v.Type().Width <= int64(2*Widthptr) {
 				// If it is a small variable captured by value, downgrade it to PAUTO.
 				v.SetClass(ir.PAUTO)
 				fn.Dcl = append(fn.Dcl, v)
-				body = append(body, ir.Nod(ir.OAS, v, cv))
+				body = append(body, ir.Nod(ir.OAS, v, cr))
 			} else {
 				// Declare variable holding addresses taken from closure
 				// and initialize in entry prologue.
@@ -310,10 +307,11 @@ func transformclosure(fn *ir.Func) {
 				addr.Curfn = fn
 				fn.Dcl = append(fn.Dcl, addr)
 				v.Heapaddr = addr
+				var src ir.Node = cr
 				if v.Byval() {
-					cv = ir.Nod(ir.OADDR, cv, nil)
+					src = ir.Nod(ir.OADDR, cr, nil)
 				}
-				body = append(body, ir.Nod(ir.OAS, addr, cv))
+				body = append(body, ir.Nod(ir.OAS, addr, src))
 			}
 		}
 
@@ -473,21 +471,17 @@ func makepartialcall(dot ir.Node, t0 *types.Type, meth *types.Sym) *ir.Func {
 	tfn.Type().SetPkg(t0.Pkg())
 
 	// Declare and initialize variable holding receiver.
-
-	cv := ir.Nod(ir.OCLOSUREVAR, nil, nil)
-	cv.SetType(rcvrtype)
-	cv.SetOffset(Rnd(int64(Widthptr), int64(cv.Type().Align)))
-
+	cr := ir.NewClosureRead(rcvrtype, Rnd(int64(Widthptr), int64(rcvrtype.Align)))
 	ptr := NewName(lookup(".this"))
 	declare(ptr, ir.PAUTO)
 	ptr.SetUsed(true)
 	var body []ir.Node
 	if rcvrtype.IsPtr() || rcvrtype.IsInterface() {
 		ptr.SetType(rcvrtype)
-		body = append(body, ir.Nod(ir.OAS, ptr, cv))
+		body = append(body, ir.Nod(ir.OAS, ptr, cr))
 	} else {
 		ptr.SetType(types.NewPtr(rcvrtype))
-		body = append(body, ir.Nod(ir.OAS, ptr, ir.Nod(ir.OADDR, cv, nil)))
+		body = append(body, ir.Nod(ir.OAS, ptr, ir.Nod(ir.OADDR, cr, nil)))
 	}
 
 	call := ir.Nod(ir.OCALL, nodSym(ir.OXDOT, ptr, meth), nil)
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 4bddb7f0f4..4cbc5d3851 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -486,7 +486,7 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 	default:
 		base.Fatalf("unexpected expr: %v", n)
 
-	case ir.OLITERAL, ir.ONIL, ir.OGETG, ir.OCLOSUREVAR, ir.OTYPE, ir.OMETHEXPR:
+	case ir.OLITERAL, ir.ONIL, ir.OGETG, ir.OCLOSUREREAD, ir.OTYPE, ir.OMETHEXPR:
 		// nop
 
 	case ir.ONAME:
@@ -1718,7 +1718,7 @@ func mayAffectMemory(n ir.Node) bool {
 	// We're ignoring things like division by zero, index out of range,
 	// and nil pointer dereference here.
 	switch n.Op() {
-	case ir.ONAME, ir.OCLOSUREVAR, ir.OLITERAL, ir.ONIL:
+	case ir.ONAME, ir.OCLOSUREREAD, ir.OLITERAL, ir.ONIL:
 		return false
 
 	// Left+Right group.
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 20f145b8eb..97f37a4716 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -963,7 +963,7 @@ func mkinlcall(n ir.Node, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]bool)
 
 	// Handle captured variables when inlining closures.
 	if c := fn.OClosure; c != nil {
-		for _, v := range c.Func().ClosureVars {
+		for _, v := range fn.ClosureVars {
 			if v.Op() == ir.OXXX {
 				continue
 			}
@@ -973,7 +973,7 @@ func mkinlcall(n ir.Node, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]bool)
 			// NB: if we enabled inlining of functions containing OCLOSURE or refined
 			// the reassigned check via some sort of copy propagation this would most
 			// likely need to be changed to a loop to walk up to the correct Param
-			if o == nil || (o.Curfn != Curfn && o.Curfn.OClosure != Curfn) {
+			if o == nil || o.Curfn != Curfn {
 				base.Fatalf("%v: unresolvable capture %v %v\n", ir.Line(n), fn, v)
 			}
 
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 91faf18a1d..10df6d5411 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -2025,7 +2025,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		}
 		addr := s.addr(n)
 		return s.load(n.Type(), addr)
-	case ir.OCLOSUREVAR:
+	case ir.OCLOSUREREAD:
 		addr := s.addr(n)
 		return s.load(n.Type(), addr)
 	case ir.ONIL:
@@ -4895,7 +4895,7 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 	case ir.ODOTPTR:
 		p := s.exprPtr(n.Left(), n.Bounded(), n.Pos())
 		return s.newValue1I(ssa.OpOffPtr, t, n.Offset(), p)
-	case ir.OCLOSUREVAR:
+	case ir.OCLOSUREREAD:
 		return s.newValue1I(ssa.OpOffPtr, t, n.Offset(),
 			s.entryNewValue0(ssa.OpGetClosurePtr, s.f.Config.Types.BytePtr))
 	case ir.OCONVNOP:
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 7d19a2b58e..8c2df77ffe 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -1948,7 +1948,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			n.SetType(types.NewPtr(t.Elem()))
 		}
 
-	case ir.OCLOSUREVAR:
+	case ir.OCLOSUREREAD:
 		ok |= ctxExpr
 
 	case ir.OCFUNC:
@@ -3099,7 +3099,7 @@ func islvalue(n ir.Node) bool {
 			return false
 		}
 		fallthrough
-	case ir.ODEREF, ir.ODOTPTR, ir.OCLOSUREVAR:
+	case ir.ODEREF, ir.ODOTPTR, ir.OCLOSUREREAD:
 		return true
 
 	case ir.ODOT:
@@ -3186,7 +3186,7 @@ func samesafeexpr(l ir.Node, r ir.Node) bool {
 	}
 
 	switch l.Op() {
-	case ir.ONAME, ir.OCLOSUREVAR:
+	case ir.ONAME, ir.OCLOSUREREAD:
 		return l == r
 
 	case ir.ODOT, ir.ODOTPTR:
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index d749dff827..e0e715716b 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -555,7 +555,7 @@ opswitch:
 	case ir.ORECOVER:
 		n = mkcall("gorecover", n.Type(), init, ir.Nod(ir.OADDR, nodfp, nil))
 
-	case ir.OCLOSUREVAR, ir.OCFUNC:
+	case ir.OCLOSUREREAD, ir.OCFUNC:
 
 	case ir.OCALLINTER, ir.OCALLFUNC, ir.OCALLMETH:
 		if n.Op() == ir.OCALLINTER {
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 418351742e..13774a2c7b 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -6,6 +6,8 @@ package ir
 
 import (
 	"cmd/compile/internal/types"
+	"cmd/internal/src"
+	"fmt"
 )
 
 // A miniStmt is a miniNode with extra fields common to expressions.
@@ -45,3 +47,40 @@ func (n *miniExpr) SetBounded(b bool)     { n.flags.set(miniExprBounded, b) }
 func (n *miniExpr) Init() Nodes           { return n.init }
 func (n *miniExpr) PtrInit() *Nodes       { return &n.init }
 func (n *miniExpr) SetInit(x Nodes)       { n.init = x }
+
+// A ClosureExpr is a function literal expression.
+type ClosureExpr struct {
+	miniExpr
+	fn *Func
+}
+
+func NewClosureExpr(pos src.XPos, fn *Func) *ClosureExpr {
+	n := &ClosureExpr{fn: fn}
+	n.op = OCLOSURE
+	n.pos = pos
+	return n
+}
+
+func (n *ClosureExpr) String() string                { return fmt.Sprint(n) }
+func (n *ClosureExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ClosureExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *ClosureExpr) Func() *Func                   { return n.fn }
+
+// A ClosureRead denotes reading a variable stored within a closure struct.
+type ClosureRead struct {
+	miniExpr
+	offset int64
+}
+
+func NewClosureRead(typ *types.Type, offset int64) *ClosureRead {
+	n := &ClosureRead{offset: offset}
+	n.typ = typ
+	n.op = OCLOSUREREAD
+	return n
+}
+
+func (n *ClosureRead) String() string                { return fmt.Sprint(n) }
+func (n *ClosureRead) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ClosureRead) RawCopy() Node                 { c := *n; return &c }
+func (n *ClosureRead) Type() *types.Type             { return n.typ }
+func (n *ClosureRead) Offset() int64                 { return n.offset }
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 92a24c8385..9d2a8ad94b 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -53,8 +53,8 @@ type Func struct {
 	body Nodes
 	iota int64
 
-	Nname    *Name // ONAME node
-	OClosure Node  // OCLOSURE node
+	Nname    *Name        // ONAME node
+	OClosure *ClosureExpr // OCLOSURE node
 
 	Shortname *types.Sym
 
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 02a5d7769a..8e10569f6a 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -601,20 +601,20 @@ const (
 	OTARRAY // []int, [8]int, [N]int or [...]int
 
 	// misc
-	ODDD        // func f(args ...int) or f(l...) or var a = [...]int{0, 1, 2}.
-	OINLCALL    // intermediary representation of an inlined call.
-	OEFACE      // itable and data words of an empty-interface value.
-	OITAB       // itable word of an interface value.
-	OIDATA      // data word of an interface value in Left
-	OSPTR       // base pointer of a slice or string.
-	OCLOSUREVAR // variable reference at beginning of closure function
-	OCFUNC      // reference to c function pointer (not go func value)
-	OCHECKNIL   // emit code to ensure pointer/interface not nil
-	OVARDEF     // variable is about to be fully initialized
-	OVARKILL    // variable is dead
-	OVARLIVE    // variable is alive
-	ORESULT     // result of a function call; Xoffset is stack offset
-	OINLMARK    // start of an inlined body, with file/line of caller. Xoffset is an index into the inline tree.
+	ODDD         // func f(args ...int) or f(l...) or var a = [...]int{0, 1, 2}.
+	OINLCALL     // intermediary representation of an inlined call.
+	OEFACE       // itable and data words of an empty-interface value.
+	OITAB        // itable word of an interface value.
+	OIDATA       // data word of an interface value in Left
+	OSPTR        // base pointer of a slice or string.
+	OCLOSUREREAD // read from inside closure struct at beginning of closure function
+	OCFUNC       // reference to c function pointer (not go func value)
+	OCHECKNIL    // emit code to ensure pointer/interface not nil
+	OVARDEF      // variable is about to be fully initialized
+	OVARKILL     // variable is dead
+	OVARLIVE     // variable is alive
+	ORESULT      // result of a function call; Xoffset is stack offset
+	OINLMARK     // start of an inlined body, with file/line of caller. Xoffset is an index into the inline tree.
 
 	// arch-specific opcodes
 	ORETJMP // return to other function
@@ -1162,8 +1162,6 @@ var okForNod = [OEND]bool{
 	OCFUNC:         true,
 	OCHECKNIL:      true,
 	OCLOSE:         true,
-	OCLOSURE:       true,
-	OCLOSUREVAR:    true,
 	OCOMPLEX:       true,
 	OCOMPLIT:       true,
 	OCONV:          true,
diff --git a/src/cmd/compile/internal/ir/op_string.go b/src/cmd/compile/internal/ir/op_string.go
index d0d3778357..637c924dd5 100644
--- a/src/cmd/compile/internal/ir/op_string.go
+++ b/src/cmd/compile/internal/ir/op_string.go
@@ -152,7 +152,7 @@ func _() {
 	_ = x[OITAB-141]
 	_ = x[OIDATA-142]
 	_ = x[OSPTR-143]
-	_ = x[OCLOSUREVAR-144]
+	_ = x[OCLOSUREREAD-144]
 	_ = x[OCFUNC-145]
 	_ = x[OCHECKNIL-146]
 	_ = x[OVARDEF-147]
@@ -165,9 +165,9 @@ func _() {
 	_ = x[OEND-154]
 }
 
-const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLFIELDDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNEWOBJNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECVSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRBLOCKBREAKCASECONTINUEDEFEREMPTYFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYDDDINLCALLEFACEITABIDATASPTRCLOSUREVARCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKRETJMPGETGEND"
+const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLFIELDDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNEWOBJNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECVSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRBLOCKBREAKCASECONTINUEDEFEREMPTYFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYDDDINLCALLEFACEITABIDATASPTRCLOSUREREADCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKRETJMPGETGEND"
 
-var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 310, 317, 323, 326, 332, 339, 347, 351, 358, 366, 368, 370, 372, 374, 376, 378, 383, 388, 396, 399, 408, 411, 415, 423, 430, 439, 452, 455, 458, 461, 464, 467, 470, 476, 479, 485, 488, 494, 498, 501, 505, 510, 515, 521, 526, 530, 535, 543, 551, 557, 566, 577, 584, 588, 595, 602, 610, 614, 618, 622, 629, 636, 644, 650, 658, 663, 668, 672, 680, 685, 690, 694, 697, 705, 709, 711, 716, 718, 723, 729, 735, 741, 747, 752, 756, 763, 769, 774, 780, 783, 790, 795, 799, 804, 808, 818, 823, 831, 837, 844, 851, 857, 864, 870, 874, 877}
+var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 310, 317, 323, 326, 332, 339, 347, 351, 358, 366, 368, 370, 372, 374, 376, 378, 383, 388, 396, 399, 408, 411, 415, 423, 430, 439, 452, 455, 458, 461, 464, 467, 470, 476, 479, 485, 488, 494, 498, 501, 505, 510, 515, 521, 526, 530, 535, 543, 551, 557, 566, 577, 584, 588, 595, 602, 610, 614, 618, 622, 629, 636, 644, 650, 658, 663, 668, 672, 680, 685, 690, 694, 697, 705, 709, 711, 716, 718, 723, 729, 735, 741, 747, 752, 756, 763, 769, 774, 780, 783, 790, 795, 799, 804, 808, 819, 824, 832, 838, 845, 852, 858, 865, 871, 875, 878}
 
 func (i Op) String() string {
 	if i >= Op(len(_Op_index)-1) {
diff --git a/src/cmd/compile/internal/ir/sizeof_test.go b/src/cmd/compile/internal/ir/sizeof_test.go
index 9321f765e0..0859022a62 100644
--- a/src/cmd/compile/internal/ir/sizeof_test.go
+++ b/src/cmd/compile/internal/ir/sizeof_test.go
@@ -20,7 +20,7 @@ func TestSizeof(t *testing.T) {
 		_32bit uintptr     // size on 32bit platforms
 		_64bit uintptr     // size on 64bit platforms
 	}{
-		{Func{}, 172, 296},
+		{Func{}, 168, 288},
 		{Name{}, 128, 224},
 		{node{}, 84, 144},
 	}
-- 
GitLab


From e5c6463e205e0dfe5df8af59c76fd1ee94feddd4 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 26 Nov 2020 01:05:39 -0500
Subject: [PATCH 0091/2400] [dev.regabi] cmd/compile: add ir.CallPartExpr

Now there are no longer any generic nodes with a non-nil
associated Func, so node.fn can be deleted. Also all manipulation
of func fields is done with concrete types, so Node.SetFunc can be
deleted, along with generic implementations.

Passes buildall w/ toolstash -cmp.

Change-Id: I4fee99870951ec9dc224f146d87b22e2bfe16889
Reviewed-on: https://go-review.googlesource.com/c/go/+/274099
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/closure.go     | 10 +++------
 src/cmd/compile/internal/gc/dcl.go         |  2 +-
 src/cmd/compile/internal/gc/ssa.go         |  8 +++++--
 src/cmd/compile/internal/gc/typecheck.go   |  2 +-
 src/cmd/compile/internal/gc/walk.go        |  2 +-
 src/cmd/compile/internal/ir/expr.go        | 26 ++++++++++++++++++++++
 src/cmd/compile/internal/ir/mini.go        |  1 -
 src/cmd/compile/internal/ir/node.go        |  8 +------
 src/cmd/compile/internal/ir/sizeof_test.go |  2 +-
 9 files changed, 40 insertions(+), 21 deletions(-)

diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index e8a0617be3..58113977d5 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -414,7 +414,7 @@ func walkclosure(clo ir.Node, init *ir.Nodes) ir.Node {
 	return walkexpr(clos, init)
 }
 
-func typecheckpartialcall(dot ir.Node, sym *types.Sym) {
+func typecheckpartialcall(dot ir.Node, sym *types.Sym) *ir.CallPartExpr {
 	switch dot.Op() {
 	case ir.ODOTINTER, ir.ODOTMETH:
 		break
@@ -427,11 +427,7 @@ func typecheckpartialcall(dot ir.Node, sym *types.Sym) {
 	fn := makepartialcall(dot, dot.Type(), sym)
 	fn.SetWrapper(true)
 
-	dot.SetOp(ir.OCALLPART)
-	dot.SetRight(NewName(sym))
-	dot.SetType(fn.Type())
-	dot.SetFunc(fn)
-	dot.SetOpt(nil) // clear types.Field from ODOTMETH
+	return ir.NewCallPartExpr(dot.Pos(), dot.Left(), NewName(sym), fn)
 }
 
 // makepartialcall returns a DCLFUNC node representing the wrapper function (*-fm) needed
@@ -522,7 +518,7 @@ func partialCallType(n ir.Node) *types.Type {
 	return t
 }
 
-func walkpartialcall(n ir.Node, init *ir.Nodes) ir.Node {
+func walkpartialcall(n *ir.CallPartExpr, init *ir.Nodes) ir.Node {
 	// Create closure in the form of a composite literal.
 	// For x.M with receiver (x) type T, the generated code looks like:
 	//
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 2bcee269d9..5d1bde384a 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -795,7 +795,7 @@ func methodSymSuffix(recv *types.Type, msym *types.Sym, suffix string) *types.Sy
 // - msym is the method symbol
 // - t is function type (with receiver)
 // Returns a pointer to the existing or added Field; or nil if there's an error.
-func addmethod(n ir.Node, msym *types.Sym, t *types.Type, local, nointerface bool) *types.Field {
+func addmethod(n *ir.Func, msym *types.Sym, t *types.Type, local, nointerface bool) *types.Field {
 	if msym == nil {
 		base.Fatalf("no method symbol")
 	}
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 10df6d5411..6d818be132 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -4146,10 +4146,14 @@ func findIntrinsic(sym *types.Sym) intrinsicBuilder {
 }
 
 func isIntrinsicCall(n ir.Node) bool {
-	if n == nil || n.Left() == nil {
+	if n == nil {
 		return false
 	}
-	return findIntrinsic(n.Left().Sym()) != nil
+	name, ok := n.Left().(*ir.Name)
+	if !ok {
+		return false
+	}
+	return findIntrinsic(name.Sym()) != nil
 }
 
 // intrinsicCall converts a call to a recognized intrinsic function into the intrinsic SSA operation.
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 8c2df77ffe..0ed5009a22 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -964,7 +964,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			if top&ctxCallee != 0 {
 				ok |= ctxCallee
 			} else {
-				typecheckpartialcall(n, s)
+				n = typecheckpartialcall(n, s)
 				ok |= ctxExpr
 			}
 
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index e0e715716b..e04413841a 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -1578,7 +1578,7 @@ opswitch:
 		n = walkclosure(n, init)
 
 	case ir.OCALLPART:
-		n = walkpartialcall(n, init)
+		n = walkpartialcall(n.(*ir.CallPartExpr), init)
 	}
 
 	// Expressions that are constant at run time but not
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 13774a2c7b..2c13918599 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -84,3 +84,29 @@ func (n *ClosureRead) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *ClosureRead) RawCopy() Node                 { c := *n; return &c }
 func (n *ClosureRead) Type() *types.Type             { return n.typ }
 func (n *ClosureRead) Offset() int64                 { return n.offset }
+
+// A CallPartExpr is a method expression X.Method (uncalled).
+type CallPartExpr struct {
+	miniExpr
+	fn     *Func
+	X      Node
+	Method *Name
+}
+
+func NewCallPartExpr(pos src.XPos, x Node, method *Name, fn *Func) *CallPartExpr {
+	n := &CallPartExpr{fn: fn, X: x, Method: method}
+	n.op = OCALLPART
+	n.pos = pos
+	n.typ = fn.Type()
+	n.fn = fn
+	return n
+}
+
+func (n *CallPartExpr) String() string                { return fmt.Sprint(n) }
+func (n *CallPartExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *CallPartExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *CallPartExpr) Func() *Func                   { return n.fn }
+func (n *CallPartExpr) Left() Node                    { return n.X }
+func (n *CallPartExpr) Right() Node                   { return n.Method }
+func (n *CallPartExpr) SetLeft(x Node)                { n.X = x }
+func (n *CallPartExpr) SetRight(x Node)               { n.Method = x.(*Name) }
diff --git a/src/cmd/compile/internal/ir/mini.go b/src/cmd/compile/internal/ir/mini.go
index 248fe232cb..338ded3308 100644
--- a/src/cmd/compile/internal/ir/mini.go
+++ b/src/cmd/compile/internal/ir/mini.go
@@ -128,7 +128,6 @@ func (n *miniNode) SetSubOp(Op)         { panic(n.no("SetSubOp")) }
 func (n *miniNode) Type() *types.Type   { return nil }
 func (n *miniNode) SetType(*types.Type) { panic(n.no("SetType")) }
 func (n *miniNode) Func() *Func         { return nil }
-func (n *miniNode) SetFunc(*Func)       { panic(n.no("SetFunc")) }
 func (n *miniNode) Name() *Name         { return nil }
 func (n *miniNode) Sym() *types.Sym     { return nil }
 func (n *miniNode) SetSym(*types.Sym)   { panic(n.no("SetSym")) }
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 8e10569f6a..f09727c369 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -56,7 +56,6 @@ type Node interface {
 	Type() *types.Type
 	SetType(t *types.Type)
 	Func() *Func
-	SetFunc(x *Func)
 	Name() *Name
 	Sym() *types.Sym
 	SetSym(x *types.Sym)
@@ -143,9 +142,6 @@ type node struct {
 	typ  *types.Type
 	orig Node // original form, for printing, and tracking copies of ONAMEs
 
-	// func
-	fn *Func
-
 	sym *types.Sym // various
 	opt interface{}
 
@@ -177,8 +173,7 @@ func (n *node) Orig() Node            { return n.orig }
 func (n *node) SetOrig(x Node)        { n.orig = x }
 func (n *node) Type() *types.Type     { return n.typ }
 func (n *node) SetType(x *types.Type) { n.typ = x }
-func (n *node) Func() *Func           { return n.fn }
-func (n *node) SetFunc(x *Func)       { n.fn = x }
+func (n *node) Func() *Func           { return nil }
 func (n *node) Name() *Name           { return nil }
 func (n *node) Sym() *types.Sym       { return n.sym }
 func (n *node) SetSym(x *types.Sym)   { n.sym = x }
@@ -1156,7 +1151,6 @@ var okForNod = [OEND]bool{
 	OCALLFUNC:      true,
 	OCALLINTER:     true,
 	OCALLMETH:      true,
-	OCALLPART:      true,
 	OCAP:           true,
 	OCASE:          true,
 	OCFUNC:         true,
diff --git a/src/cmd/compile/internal/ir/sizeof_test.go b/src/cmd/compile/internal/ir/sizeof_test.go
index 0859022a62..2f31ba8d34 100644
--- a/src/cmd/compile/internal/ir/sizeof_test.go
+++ b/src/cmd/compile/internal/ir/sizeof_test.go
@@ -22,7 +22,7 @@ func TestSizeof(t *testing.T) {
 	}{
 		{Func{}, 168, 288},
 		{Name{}, 128, 224},
-		{node{}, 84, 144},
+		{node{}, 80, 136},
 	}
 
 	for _, tt := range tests {
-- 
GitLab


From 1b84aabb01770ae65d28f951c65a9eb6c16441d7 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 28 Nov 2020 09:07:48 -0500
Subject: [PATCH 0092/2400] [dev.regabi] cmd/compile: move typenod, typenodl to
 ir.TypeNode, ir.TypeNodeAt [generated]

[git-generate]
cd src/cmd/compile/internal/gc
rf '
	mv typenod TypeNode
	mv typenodl TypeNodeAt
	mv TypeNode TypeNodeAt type.go
	mv type.go cmd/compile/internal/ir
'

Passes buildall w/ toolstash -cmp.

Change-Id: Id546a8cfae93074ebb1496490da7635800807faf
Reviewed-on: https://go-review.googlesource.com/c/go/+/274100
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/closure.go   |  4 ++--
 src/cmd/compile/internal/gc/dcl.go       | 17 ---------------
 src/cmd/compile/internal/gc/iexport.go   |  2 +-
 src/cmd/compile/internal/gc/iimport.go   | 10 ++++-----
 src/cmd/compile/internal/gc/inl.go       |  2 +-
 src/cmd/compile/internal/gc/sinit.go     |  4 ++--
 src/cmd/compile/internal/gc/typecheck.go |  6 +++---
 src/cmd/compile/internal/gc/universe.go  | 12 +++++------
 src/cmd/compile/internal/gc/walk.go      |  4 ++--
 src/cmd/compile/internal/ir/type.go      | 27 ++++++++++++++++++++++++
 10 files changed, 49 insertions(+), 39 deletions(-)
 create mode 100644 src/cmd/compile/internal/ir/type.go

diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index 58113977d5..ee09e7876e 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -392,7 +392,7 @@ func walkclosure(clo ir.Node, init *ir.Nodes) ir.Node {
 
 	typ := closureType(clo)
 
-	clos := ir.Nod(ir.OCOMPLIT, nil, typenod(typ))
+	clos := ir.Nod(ir.OCOMPLIT, nil, ir.TypeNode(typ))
 	clos.SetEsc(clo.Esc())
 	clos.PtrList().Set(append([]ir.Node{ir.Nod(ir.OCFUNC, fn.Nname, nil)}, fn.ClosureEnter.Slice()...))
 
@@ -542,7 +542,7 @@ func walkpartialcall(n *ir.CallPartExpr, init *ir.Nodes) ir.Node {
 
 	typ := partialCallType(n)
 
-	clos := ir.Nod(ir.OCOMPLIT, nil, typenod(typ))
+	clos := ir.Nod(ir.OCOMPLIT, nil, ir.TypeNode(typ))
 	clos.SetEsc(n.Esc())
 	clos.PtrList().Set2(ir.Nod(ir.OCFUNC, n.Func().Nname, nil), n.Left())
 
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 5d1bde384a..3d8f97d93d 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -221,23 +221,6 @@ func dclname(s *types.Sym) *ir.Name {
 	return n
 }
 
-func typenod(t *types.Type) ir.Node {
-	return typenodl(src.NoXPos, t)
-}
-
-func typenodl(pos src.XPos, t *types.Type) ir.Node {
-	// if we copied another type with *t = *u
-	// then t->nod might be out of date, so
-	// check t->nod->type too
-	if ir.AsNode(t.Nod) == nil || ir.AsNode(t.Nod).Type() != t {
-		t.Nod = ir.NodAt(pos, ir.OTYPE, nil, nil)
-		ir.AsNode(t.Nod).SetType(t)
-		ir.AsNode(t.Nod).SetSym(t.Sym)
-	}
-
-	return ir.AsNode(t.Nod)
-}
-
 func anonfield(typ *types.Type) ir.Node {
 	return symfield(nil, typ)
 }
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index 3f5ec2e4dd..3f0f381974 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -640,7 +640,7 @@ func (w *exportWriter) doTyp(t *types.Type) {
 		}
 
 		w.startType(definedType)
-		w.qualifiedIdent(typenod(t))
+		w.qualifiedIdent(ir.TypeNode(t))
 		return
 	}
 
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 5a50682ab2..88f6e36e07 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -836,7 +836,7 @@ func (r *importReader) node() ir.Node {
 	// 	unreachable - should have been resolved by typechecking
 
 	case ir.OTYPE:
-		return typenod(r.typ())
+		return ir.TypeNode(r.typ())
 
 	case ir.OTYPESW:
 		n := ir.NodAt(r.pos(), ir.OTYPESW, nil, nil)
@@ -860,7 +860,7 @@ func (r *importReader) node() ir.Node {
 		// TODO(mdempsky): Export position information for OSTRUCTKEY nodes.
 		savedlineno := base.Pos
 		base.Pos = r.pos()
-		n := ir.NodAt(base.Pos, ir.OCOMPLIT, nil, typenod(r.typ()))
+		n := ir.NodAt(base.Pos, ir.OCOMPLIT, nil, ir.TypeNode(r.typ()))
 		n.PtrList().Set(r.elemList()) // special handling of field names
 		base.Pos = savedlineno
 		return n
@@ -869,7 +869,7 @@ func (r *importReader) node() ir.Node {
 	// 	unreachable - mapped to case OCOMPLIT below by exporter
 
 	case ir.OCOMPLIT:
-		n := ir.NodAt(r.pos(), ir.OCOMPLIT, nil, typenod(r.typ()))
+		n := ir.NodAt(r.pos(), ir.OCOMPLIT, nil, ir.TypeNode(r.typ()))
 		n.PtrList().Set(r.exprList())
 		return n
 
@@ -944,7 +944,7 @@ func (r *importReader) node() ir.Node {
 
 	case ir.OMAKEMAP, ir.OMAKECHAN, ir.OMAKESLICE:
 		n := npos(r.pos(), builtinCall(ir.OMAKE))
-		n.PtrList().Append(typenod(r.typ()))
+		n.PtrList().Append(ir.TypeNode(r.typ()))
 		n.PtrList().Append(r.exprList()...)
 		return n
 
@@ -971,7 +971,7 @@ func (r *importReader) node() ir.Node {
 	case ir.ODCL:
 		pos := r.pos()
 		lhs := npos(pos, dclname(r.ident()))
-		typ := typenod(r.typ())
+		typ := ir.TypeNode(r.typ())
 		return npos(pos, liststmt(variter([]ir.Node{lhs}, typ, nil))) // TODO(gri) avoid list creation
 
 	// case ODCLFIELD:
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 97f37a4716..bbbffebf5c 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -1108,7 +1108,7 @@ func mkinlcall(n ir.Node, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]bool)
 			vas.SetRight(nodnil())
 			vas.Right().SetType(param.Type)
 		} else {
-			vas.SetRight(ir.Nod(ir.OCOMPLIT, nil, typenod(param.Type)))
+			vas.SetRight(ir.Nod(ir.OCOMPLIT, nil, ir.TypeNode(param.Type)))
 			vas.Right().PtrList().Set(varargs)
 		}
 	}
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index fca81763c0..ff3d3281dd 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -687,7 +687,7 @@ func slicelit(ctxt initContext, n ir.Node, var_ ir.Node, init *ir.Nodes) {
 		a = ir.Nod(ir.OADDR, a, nil)
 	} else {
 		a = ir.Nod(ir.ONEW, nil, nil)
-		a.PtrList().Set1(typenod(t))
+		a.PtrList().Set1(ir.TypeNode(t))
 	}
 
 	a = ir.Nod(ir.OAS, vauto, a)
@@ -763,7 +763,7 @@ func maplit(n ir.Node, m ir.Node, init *ir.Nodes) {
 	// make the map var
 	a := ir.Nod(ir.OMAKE, nil, nil)
 	a.SetEsc(n.Esc())
-	a.PtrList().Set2(typenod(n.Type()), nodintconst(int64(n.List().Len())))
+	a.PtrList().Set2(ir.TypeNode(n.Type()), nodintconst(int64(n.List().Len())))
 	litas(m, a, init)
 
 	entries := n.List().Slice()
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 0ed5009a22..a1b1809790 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -2785,11 +2785,11 @@ func pushtype(n ir.Node, t *types.Type) ir.Node {
 	switch {
 	case iscomptype(t):
 		// For T, return T{...}.
-		n.SetRight(typenod(t))
+		n.SetRight(ir.TypeNode(t))
 
 	case t.IsPtr() && iscomptype(t.Elem()):
 		// For *T, return &T{...}.
-		n.SetRight(typenod(t.Elem()))
+		n.SetRight(ir.TypeNode(t.Elem()))
 
 		n = ir.NodAt(n.Pos(), ir.OADDR, n, nil)
 		n.SetImplicit(true)
@@ -3458,7 +3458,7 @@ func stringtoruneslit(n ir.Node) ir.Node {
 		i++
 	}
 
-	nn := ir.Nod(ir.OCOMPLIT, nil, typenod(n.Type()))
+	nn := ir.Nod(ir.OCOMPLIT, nil, ir.TypeNode(n.Type()))
 	nn.PtrList().Set(l)
 	nn = typecheck(nn, ctxExpr)
 	return nn
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index 1068720748..931135759a 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -109,7 +109,7 @@ func lexinit() {
 			}
 			types.Types[etype] = t
 		}
-		s2.Def = typenod(t)
+		s2.Def = ir.TypeNode(t)
 	}
 
 	for _, s := range &builtinFuncs {
@@ -176,7 +176,7 @@ func typeinit() {
 	t := types.New(types.TUNSAFEPTR)
 	types.Types[types.TUNSAFEPTR] = t
 	t.Sym = unsafepkg.Lookup("Pointer")
-	t.Sym.Def = typenod(t)
+	t.Sym.Def = ir.TypeNode(t)
 	dowidth(types.Types[types.TUNSAFEPTR])
 
 	for et := types.TINT8; et <= types.TUINT64; et++ {
@@ -337,7 +337,7 @@ func lexinit1() {
 	types.Errortype = makeErrorInterface()
 	types.Errortype.Sym = s
 	types.Errortype.Orig = makeErrorInterface()
-	s.Def = typenod(types.Errortype)
+	s.Def = ir.TypeNode(types.Errortype)
 	dowidth(types.Errortype)
 
 	// We create separate byte and rune types for better error messages
@@ -352,14 +352,14 @@ func lexinit1() {
 	s = ir.BuiltinPkg.Lookup("byte")
 	types.Bytetype = types.New(types.TUINT8)
 	types.Bytetype.Sym = s
-	s.Def = typenod(types.Bytetype)
+	s.Def = ir.TypeNode(types.Bytetype)
 	dowidth(types.Bytetype)
 
 	// rune alias
 	s = ir.BuiltinPkg.Lookup("rune")
 	types.Runetype = types.New(types.TINT32)
 	types.Runetype.Sym = s
-	s.Def = typenod(types.Runetype)
+	s.Def = ir.TypeNode(types.Runetype)
 	dowidth(types.Runetype)
 
 	// backend-dependent builtin types (e.g. int).
@@ -376,7 +376,7 @@ func lexinit1() {
 		t := types.New(s.etype)
 		t.Sym = s1
 		types.Types[s.etype] = t
-		s1.Def = typenod(t)
+		s1.Def = ir.TypeNode(t)
 		s1.Origpkg = ir.BuiltinPkg
 
 		dowidth(t)
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index e04413841a..2376bfc093 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -1810,7 +1810,7 @@ func mkdotargslice(typ *types.Type, args []ir.Node) ir.Node {
 		n = nodnil()
 		n.SetType(typ)
 	} else {
-		n = ir.Nod(ir.OCOMPLIT, nil, typenod(typ))
+		n = ir.Nod(ir.OCOMPLIT, nil, ir.TypeNode(typ))
 		n.PtrList().Append(args...)
 		n.SetImplicit(true)
 	}
@@ -2687,7 +2687,7 @@ func addstr(n ir.Node, init *ir.Nodes) ir.Node {
 		fn = "concatstrings"
 
 		t := types.NewSlice(types.Types[types.TSTRING])
-		slice := ir.Nod(ir.OCOMPLIT, nil, typenod(t))
+		slice := ir.Nod(ir.OCOMPLIT, nil, ir.TypeNode(t))
 		if prealloc[n] != nil {
 			prealloc[slice] = prealloc[n]
 		}
diff --git a/src/cmd/compile/internal/ir/type.go b/src/cmd/compile/internal/ir/type.go
new file mode 100644
index 0000000000..3409424fed
--- /dev/null
+++ b/src/cmd/compile/internal/ir/type.go
@@ -0,0 +1,27 @@
+// Copyright 2009 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 ir
+
+import (
+	"cmd/compile/internal/types"
+	"cmd/internal/src"
+)
+
+func TypeNode(t *types.Type) Node {
+	return TypeNodeAt(src.NoXPos, t)
+}
+
+func TypeNodeAt(pos src.XPos, t *types.Type) Node {
+	// if we copied another type with *t = *u
+	// then t->nod might be out of date, so
+	// check t->nod->type too
+	if AsNode(t.Nod) == nil || AsNode(t.Nod).Type() != t {
+		t.Nod = NodAt(pos, OTYPE, nil, nil)
+		AsNode(t.Nod).SetType(t)
+		AsNode(t.Nod).SetSym(t.Sym)
+	}
+
+	return AsNode(t.Nod)
+}
-- 
GitLab


From f0001e8867be0004a8bc13eaea8b59653a5d141e Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 29 Nov 2020 08:09:01 -0500
Subject: [PATCH 0093/2400] [dev.regabi] cmd/compile: add OTSLICE Op

This is not safe for toolstash -cmp and so is split into its own CL.

Change-Id: Ic3254e68fb84a90a11ac5f0b59ef252135c23658
Reviewed-on: https://go-review.googlesource.com/c/go/+/274101
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/node.go      |  1 +
 src/cmd/compile/internal/ir/op_string.go | 39 ++++++++++++------------
 2 files changed, 21 insertions(+), 19 deletions(-)

diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index f09727c369..47c38c2ab5 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -594,6 +594,7 @@ const (
 	// list of result fields.
 	OTFUNC
 	OTARRAY // []int, [8]int, [N]int or [...]int
+	OTSLICE // to be used in future CL
 
 	// misc
 	ODDD         // func f(args ...int) or f(l...) or var a = [...]int{0, 1, 2}.
diff --git a/src/cmd/compile/internal/ir/op_string.go b/src/cmd/compile/internal/ir/op_string.go
index 637c924dd5..faec164c7b 100644
--- a/src/cmd/compile/internal/ir/op_string.go
+++ b/src/cmd/compile/internal/ir/op_string.go
@@ -146,28 +146,29 @@ func _() {
 	_ = x[OTINTER-135]
 	_ = x[OTFUNC-136]
 	_ = x[OTARRAY-137]
-	_ = x[ODDD-138]
-	_ = x[OINLCALL-139]
-	_ = x[OEFACE-140]
-	_ = x[OITAB-141]
-	_ = x[OIDATA-142]
-	_ = x[OSPTR-143]
-	_ = x[OCLOSUREREAD-144]
-	_ = x[OCFUNC-145]
-	_ = x[OCHECKNIL-146]
-	_ = x[OVARDEF-147]
-	_ = x[OVARKILL-148]
-	_ = x[OVARLIVE-149]
-	_ = x[ORESULT-150]
-	_ = x[OINLMARK-151]
-	_ = x[ORETJMP-152]
-	_ = x[OGETG-153]
-	_ = x[OEND-154]
+	_ = x[OTSLICE-138]
+	_ = x[ODDD-139]
+	_ = x[OINLCALL-140]
+	_ = x[OEFACE-141]
+	_ = x[OITAB-142]
+	_ = x[OIDATA-143]
+	_ = x[OSPTR-144]
+	_ = x[OCLOSUREREAD-145]
+	_ = x[OCFUNC-146]
+	_ = x[OCHECKNIL-147]
+	_ = x[OVARDEF-148]
+	_ = x[OVARKILL-149]
+	_ = x[OVARLIVE-150]
+	_ = x[ORESULT-151]
+	_ = x[OINLMARK-152]
+	_ = x[ORETJMP-153]
+	_ = x[OGETG-154]
+	_ = x[OEND-155]
 }
 
-const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLFIELDDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNEWOBJNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECVSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRBLOCKBREAKCASECONTINUEDEFEREMPTYFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYDDDINLCALLEFACEITABIDATASPTRCLOSUREREADCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKRETJMPGETGEND"
+const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLFIELDDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNEWOBJNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECVSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRBLOCKBREAKCASECONTINUEDEFEREMPTYFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEDDDINLCALLEFACEITABIDATASPTRCLOSUREREADCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKRETJMPGETGEND"
 
-var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 310, 317, 323, 326, 332, 339, 347, 351, 358, 366, 368, 370, 372, 374, 376, 378, 383, 388, 396, 399, 408, 411, 415, 423, 430, 439, 452, 455, 458, 461, 464, 467, 470, 476, 479, 485, 488, 494, 498, 501, 505, 510, 515, 521, 526, 530, 535, 543, 551, 557, 566, 577, 584, 588, 595, 602, 610, 614, 618, 622, 629, 636, 644, 650, 658, 663, 668, 672, 680, 685, 690, 694, 697, 705, 709, 711, 716, 718, 723, 729, 735, 741, 747, 752, 756, 763, 769, 774, 780, 783, 790, 795, 799, 804, 808, 819, 824, 832, 838, 845, 852, 858, 865, 871, 875, 878}
+var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 310, 317, 323, 326, 332, 339, 347, 351, 358, 366, 368, 370, 372, 374, 376, 378, 383, 388, 396, 399, 408, 411, 415, 423, 430, 439, 452, 455, 458, 461, 464, 467, 470, 476, 479, 485, 488, 494, 498, 501, 505, 510, 515, 521, 526, 530, 535, 543, 551, 557, 566, 577, 584, 588, 595, 602, 610, 614, 618, 622, 629, 636, 644, 650, 658, 663, 668, 672, 680, 685, 690, 694, 697, 705, 709, 711, 716, 718, 723, 729, 735, 741, 747, 752, 756, 763, 769, 774, 780, 786, 789, 796, 801, 805, 810, 814, 825, 830, 838, 844, 851, 858, 864, 871, 877, 881, 884}
 
 func (i Op) String() string {
 	if i >= Op(len(_Op_index)-1) {
-- 
GitLab


From d40869fcedb208b0bcf7e7d828db12f210a17dc6 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 29 Nov 2020 09:38:52 -0500
Subject: [PATCH 0094/2400] [dev.regabi] cmd/compile: move gc.treecopy to
 ir.DeepCopy

This is a general operation on IR nodes, so it belongs in ir.
The copied implementation is adapted to support the
extension pattern, allowing nodes to implement their
own DeepCopy implementations if needed.

This is the first step toward higher-level operations instead
of Left, Right, etc. It will allow the new type syntax nodes
to be properly immutable and opt out of those fine-grained methods.

Passes buildall w/ toolstash -cmp.

Change-Id: Ibd64061e01daf14aebc6586cb2eb2b12057ca85a
Reviewed-on: https://go-review.googlesource.com/c/go/+/274102
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/noder.go |   2 +-
 src/cmd/compile/internal/gc/order.go |   8 +-
 src/cmd/compile/internal/gc/subr.go  |  44 ----------
 src/cmd/compile/internal/ir/copy.go  | 127 +++++++++++++++++++++++++++
 src/cmd/compile/internal/ir/node.go  |  53 -----------
 5 files changed, 133 insertions(+), 101 deletions(-)
 create mode 100644 src/cmd/compile/internal/ir/copy.go

diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 8ae5874d3b..1c433b5d30 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -451,7 +451,7 @@ func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []ir.Node {
 		}
 		v := values[i]
 		if decl.Values == nil {
-			v = treecopy(v, n.Pos())
+			v = ir.DeepCopy(n.Pos(), v)
 		}
 
 		n.SetOp(ir.OLITERAL)
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 6a91b8c91b..d4db7be911 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -609,7 +609,10 @@ func (o *Order) stmt(n ir.Node) {
 
 			n.SetLeft(o.safeExpr(n.Left()))
 
-			l := treecopy(n.Left(), src.NoXPos)
+			// TODO(rsc): Why is this DeepCopy?
+			// We should know enough about the form here
+			// to do something more provably shallower.
+			l := ir.DeepCopy(src.NoXPos, n.Left())
 			if l.Op() == ir.OINDEXMAP {
 				l.SetIndexMapLValue(false)
 			}
@@ -1123,8 +1126,7 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 			needCopy = mapKeyReplaceStrConv(n.Right())
 
 			if instrumenting {
-				// Race detector needs the copy so it can
-				// call treecopy on the result.
+				// Race detector needs the copy.
 				needCopy = true
 			}
 		}
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 336465db98..25490246e6 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -181,42 +181,6 @@ func nodstr(s string) ir.Node {
 	return ir.NewLiteral(constant.MakeString(s))
 }
 
-// treecopy recursively copies n, with the exception of
-// ONAME, OLITERAL, OTYPE, and ONONAME leaves.
-// If pos.IsKnown(), it sets the source position of newly
-// allocated nodes to pos.
-func treecopy(n ir.Node, pos src.XPos) ir.Node {
-	if n == nil {
-		return nil
-	}
-
-	switch n.Op() {
-	default:
-		m := ir.SepCopy(n)
-		m.SetLeft(treecopy(n.Left(), pos))
-		m.SetRight(treecopy(n.Right(), pos))
-		m.PtrList().Set(listtreecopy(n.List().Slice(), pos))
-		if pos.IsKnown() {
-			m.SetPos(pos)
-		}
-		if m.Name() != nil && n.Op() != ir.ODCLFIELD {
-			ir.Dump("treecopy", n)
-			base.Fatalf("treecopy Name")
-		}
-		return m
-
-	case ir.OPACK:
-		// OPACK nodes are never valid in const value declarations,
-		// but allow them like any other declared symbol to avoid
-		// crashing (golang.org/issue/11361).
-		fallthrough
-
-	case ir.ONAME, ir.ONONAME, ir.OLITERAL, ir.ONIL, ir.OTYPE:
-		return n
-
-	}
-}
-
 func isptrto(t *types.Type, et types.EType) bool {
 	if t == nil {
 		return false
@@ -1375,14 +1339,6 @@ func implements(t, iface *types.Type, m, samename **types.Field, ptr *int) bool
 	return true
 }
 
-func listtreecopy(l []ir.Node, pos src.XPos) []ir.Node {
-	var out []ir.Node
-	for _, n := range l {
-		out = append(out, treecopy(n, pos))
-	}
-	return out
-}
-
 func liststmt(l []ir.Node) ir.Node {
 	n := ir.Nod(ir.OBLOCK, nil, nil)
 	n.PtrList().Set(l)
diff --git a/src/cmd/compile/internal/ir/copy.go b/src/cmd/compile/internal/ir/copy.go
new file mode 100644
index 0000000000..7a1611d0d6
--- /dev/null
+++ b/src/cmd/compile/internal/ir/copy.go
@@ -0,0 +1,127 @@
+// Copyright 2020 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 ir
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/internal/src"
+)
+
+// A Node may implement the Orig and SetOrig method to
+// maintain a pointer to the "unrewritten" form of a Node.
+// If a Node does not implement OrigNode, it is its own Orig.
+//
+// Note that both SepCopy and Copy have definitions compatible
+// with a Node that does not implement OrigNode: such a Node
+// is its own Orig, and in that case, that's what both want to return
+// anyway (SepCopy unconditionally, and Copy only when the input
+// is its own Orig as well, but if the output does not implement
+// OrigNode, then neither does the input, making the condition true).
+type OrigNode interface {
+	Node
+	Orig() Node
+	SetOrig(Node)
+}
+
+// Orig returns the “original” node for n.
+// If n implements OrigNode, Orig returns n.Orig().
+// Otherwise Orig returns n itself.
+func Orig(n Node) Node {
+	if n, ok := n.(OrigNode); ok {
+		o := n.Orig()
+		if o == nil {
+			Dump("Orig nil", n)
+			base.Fatalf("Orig returned nil")
+		}
+		return o
+	}
+	return n
+}
+
+// SepCopy returns a separate shallow copy of n,
+// breaking any Orig link to any other nodes.
+func SepCopy(n Node) Node {
+	n = n.RawCopy()
+	if n, ok := n.(OrigNode); ok {
+		n.SetOrig(n)
+	}
+	return n
+}
+
+// Copy returns a shallow copy of n.
+// If Orig(n) == n, then Orig(Copy(n)) == the copy.
+// Otherwise the Orig link is preserved as well.
+//
+// The specific semantics surrounding Orig are subtle but right for most uses.
+// See issues #26855 and #27765 for pitfalls.
+func Copy(n Node) Node {
+	copy := n.RawCopy()
+	if n, ok := n.(OrigNode); ok && n.Orig() == n {
+		copy.(OrigNode).SetOrig(copy)
+	}
+	return copy
+}
+
+// A Node can implement DeepCopyNode to provide a custom implementation
+// of DeepCopy. If the compiler only needs access to a Node's structure during
+// DeepCopy, then a Node can implement DeepCopyNode instead of providing
+// fine-grained mutable access with Left, SetLeft, Right, SetRight, and so on.
+type DeepCopyNode interface {
+	Node
+	DeepCopy(pos src.XPos) Node
+}
+
+// DeepCopy returns a “deep” copy of n, with its entire structure copied
+// (except for shared nodes like ONAME, ONONAME, OLITERAL, and OTYPE).
+// If pos.IsKnown(), it sets the source position of newly allocated Nodes to pos.
+//
+// The default implementation is to traverse the Node graph, making
+// a shallow copy of each node and then updating each field to point
+// at shallow copies of children, recursively, using Left, SetLeft, and so on.
+//
+// If a Node wishes to provide an alternate implementation, it can
+// implement a DeepCopy method: see the DeepCopyNode interface.
+func DeepCopy(pos src.XPos, n Node) Node {
+	if n == nil {
+		return nil
+	}
+
+	if n, ok := n.(DeepCopyNode); ok {
+		return n.DeepCopy(pos)
+	}
+
+	switch n.Op() {
+	default:
+		m := SepCopy(n)
+		m.SetLeft(DeepCopy(pos, n.Left()))
+		m.SetRight(DeepCopy(pos, n.Right()))
+		m.PtrList().Set(deepCopyList(pos, n.List().Slice()))
+		if pos.IsKnown() {
+			m.SetPos(pos)
+		}
+		if m.Name() != nil {
+			Dump("DeepCopy", n)
+			base.Fatalf("DeepCopy Name")
+		}
+		return m
+
+	case OPACK:
+		// OPACK nodes are never valid in const value declarations,
+		// but allow them like any other declared symbol to avoid
+		// crashing (golang.org/issue/11361).
+		fallthrough
+
+	case ONAME, ONONAME, OLITERAL, ONIL, OTYPE:
+		return n
+	}
+}
+
+func deepCopyList(pos src.XPos, list []Node) []Node {
+	var out []Node
+	for _, n := range list {
+		out = append(out, DeepCopy(pos, n))
+	}
+	return out
+}
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 47c38c2ab5..653410d175 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -1021,59 +1021,6 @@ func (n *node) RawCopy() Node {
 	return &copy
 }
 
-// A Node may implement the Orig and SetOrig method to
-// maintain a pointer to the "unrewritten" form of a Node.
-// If a Node does not implement OrigNode, it is its own Orig.
-//
-// Note that both SepCopy and Copy have definitions compatible
-// with a Node that does not implement OrigNode: such a Node
-// is its own Orig, and in that case, that's what both want to return
-// anyway (SepCopy unconditionally, and Copy only when the input
-// is its own Orig as well, but if the output does not implement
-// OrigNode, then neither does the input, making the condition true).
-type OrigNode interface {
-	Node
-	Orig() Node
-	SetOrig(Node)
-}
-
-func Orig(n Node) Node {
-	if n, ok := n.(OrigNode); ok {
-		o := n.Orig()
-		if o == nil {
-			Dump("Orig nil", n)
-			base.Fatalf("Orig returned nil")
-		}
-		return o
-	}
-	return n
-}
-
-// sepcopy returns a separate shallow copy of n, with the copy's
-// Orig pointing to itself.
-func SepCopy(n Node) Node {
-	n = n.RawCopy()
-	if n, ok := n.(OrigNode); ok {
-		n.SetOrig(n)
-	}
-	return n
-}
-
-// copy returns shallow copy of n and adjusts the copy's Orig if
-// necessary: In general, if n.Orig points to itself, the copy's
-// Orig should point to itself as well. Otherwise, if n is modified,
-// the copy's Orig node appears modified, too, and then doesn't
-// represent the original node anymore.
-// (This caused the wrong complit Op to be used when printing error
-// messages; see issues #26855, #27765).
-func Copy(n Node) Node {
-	copy := n.RawCopy()
-	if n, ok := n.(OrigNode); ok && n.Orig() == n {
-		copy.(OrigNode).SetOrig(copy)
-	}
-	return copy
-}
-
 // isNil reports whether n represents the universal untyped zero value "nil".
 func IsNil(n Node) bool {
 	// Check n.Orig because constant propagation may produce typed nil constants,
-- 
GitLab


From 4e7685ef1afbf8b1cc692f2a1bd3b02e444d5901 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 26 Nov 2020 07:02:13 -0500
Subject: [PATCH 0095/2400] [dev.regabi] cmd/compile: add custom type syntax
 Node implementations

The type syntax is reused to stand in for the actual type once typechecked,
to avoid updating all the possible references to the original type syntax.
So all these implementations allow changing their Op from the raw syntax
like OTMAP to the finished form OTYPE, even though obviously the
representation does not change.

Passes buildall w/ toolstash -cmp.

Change-Id: I4acca1a5b35fa2f48ee08e8f1e5a330a004c284b
Reviewed-on: https://go-review.googlesource.com/c/go/+/274103
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/fmtmap_test.go           |   1 +
 src/cmd/compile/internal/gc/alg.go       |  21 +-
 src/cmd/compile/internal/gc/builtin.go   | 182 +++++------
 src/cmd/compile/internal/gc/closure.go   |  10 +-
 src/cmd/compile/internal/gc/dcl.go       | 134 ++++----
 src/cmd/compile/internal/gc/embed.go     |   8 +-
 src/cmd/compile/internal/gc/iexport.go   |   3 -
 src/cmd/compile/internal/gc/iimport.go   |   3 -
 src/cmd/compile/internal/gc/init.go      |   2 +-
 src/cmd/compile/internal/gc/mkbuiltin.go |   2 +-
 src/cmd/compile/internal/gc/noder.go     | 102 +++---
 src/cmd/compile/internal/gc/reflect.go   |   8 +-
 src/cmd/compile/internal/gc/select.go    |   2 +-
 src/cmd/compile/internal/gc/subr.go      |  22 +-
 src/cmd/compile/internal/gc/typecheck.go | 170 +++++-----
 src/cmd/compile/internal/gc/universe.go  |   5 +-
 src/cmd/compile/internal/gc/walk.go      |  11 +-
 src/cmd/compile/internal/ir/expr.go      |  44 +++
 src/cmd/compile/internal/ir/fmt.go       |  48 ++-
 src/cmd/compile/internal/ir/mini.go      |   9 +
 src/cmd/compile/internal/ir/name.go      |   6 +-
 src/cmd/compile/internal/ir/node.go      |  45 +--
 src/cmd/compile/internal/ir/type.go      | 376 ++++++++++++++++++++++-
 23 files changed, 787 insertions(+), 427 deletions(-)

diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
index e949a89d93..32891aea66 100644
--- a/src/cmd/compile/fmtmap_test.go
+++ b/src/cmd/compile/fmtmap_test.go
@@ -95,6 +95,7 @@ var knownFormats = map[string]string{
 	"cmd/compile/internal/ir.Nodes %+v":               "",
 	"cmd/compile/internal/ir.Nodes %.v":               "",
 	"cmd/compile/internal/ir.Nodes %v":                "",
+	"cmd/compile/internal/ir.Ntype %v":                "",
 	"cmd/compile/internal/ir.Op %#v":                  "",
 	"cmd/compile/internal/ir.Op %v":                   "",
 	"cmd/compile/internal/ssa.BranchPrediction %d":    "",
diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index b40a56fe39..806417d03d 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -292,12 +292,12 @@ func genhash(t *types.Type) *obj.LSym {
 	dclcontext = ir.PEXTERN
 
 	// func sym(p *T, h uintptr) uintptr
-	tfn := ir.Nod(ir.OTFUNC, nil, nil)
-	tfn.PtrList().Set2(
+	args := []*ir.Field{
 		namedfield("p", types.NewPtr(t)),
 		namedfield("h", types.Types[types.TUINTPTR]),
-	)
-	tfn.PtrRlist().Set1(anonfield(types.Types[types.TUINTPTR]))
+	}
+	results := []*ir.Field{anonfield(types.Types[types.TUINTPTR])}
+	tfn := ir.NewFuncType(base.Pos, nil, args, results)
 
 	fn := dclfunc(sym, tfn)
 	np := ir.AsNode(tfn.Type().Params().Field(0).Nname)
@@ -432,10 +432,10 @@ func hashfor(t *types.Type) ir.Node {
 
 	n := NewName(sym)
 	setNodeNameFunc(n)
-	n.SetType(functype(nil, []ir.Node{
+	n.SetType(functype(nil, []*ir.Field{
 		anonfield(types.NewPtr(t)),
 		anonfield(types.Types[types.TUINTPTR]),
-	}, []ir.Node{
+	}, []*ir.Field{
 		anonfield(types.Types[types.TUINTPTR]),
 	}))
 	return n
@@ -521,12 +521,9 @@ func geneq(t *types.Type) *obj.LSym {
 	dclcontext = ir.PEXTERN
 
 	// func sym(p, q *T) bool
-	tfn := ir.Nod(ir.OTFUNC, nil, nil)
-	tfn.PtrList().Set2(
-		namedfield("p", types.NewPtr(t)),
-		namedfield("q", types.NewPtr(t)),
-	)
-	tfn.PtrRlist().Set1(namedfield("r", types.Types[types.TBOOL]))
+	tfn := ir.NewFuncType(base.Pos, nil,
+		[]*ir.Field{namedfield("p", types.NewPtr(t)), namedfield("q", types.NewPtr(t))},
+		[]*ir.Field{namedfield("r", types.Types[types.TBOOL])})
 
 	fn := dclfunc(sym, tfn)
 	np := ir.AsNode(tfn.Type().Params().Field(0).Nname)
diff --git a/src/cmd/compile/internal/gc/builtin.go b/src/cmd/compile/internal/gc/builtin.go
index a57c611559..efca44c667 100644
--- a/src/cmd/compile/internal/gc/builtin.go
+++ b/src/cmd/compile/internal/gc/builtin.go
@@ -210,132 +210,132 @@ func runtimeTypes() []*types.Type {
 	typs[1] = types.NewPtr(typs[0])
 	typs[2] = types.Types[types.TANY]
 	typs[3] = types.NewPtr(typs[2])
-	typs[4] = functype(nil, []ir.Node{anonfield(typs[1])}, []ir.Node{anonfield(typs[3])})
+	typs[4] = functype(nil, []*ir.Field{anonfield(typs[1])}, []*ir.Field{anonfield(typs[3])})
 	typs[5] = types.Types[types.TUINTPTR]
 	typs[6] = types.Types[types.TBOOL]
 	typs[7] = types.Types[types.TUNSAFEPTR]
-	typs[8] = functype(nil, []ir.Node{anonfield(typs[5]), anonfield(typs[1]), anonfield(typs[6])}, []ir.Node{anonfield(typs[7])})
+	typs[8] = functype(nil, []*ir.Field{anonfield(typs[5]), anonfield(typs[1]), anonfield(typs[6])}, []*ir.Field{anonfield(typs[7])})
 	typs[9] = functype(nil, nil, nil)
 	typs[10] = types.Types[types.TINTER]
-	typs[11] = functype(nil, []ir.Node{anonfield(typs[10])}, nil)
+	typs[11] = functype(nil, []*ir.Field{anonfield(typs[10])}, nil)
 	typs[12] = types.Types[types.TINT32]
 	typs[13] = types.NewPtr(typs[12])
-	typs[14] = functype(nil, []ir.Node{anonfield(typs[13])}, []ir.Node{anonfield(typs[10])})
+	typs[14] = functype(nil, []*ir.Field{anonfield(typs[13])}, []*ir.Field{anonfield(typs[10])})
 	typs[15] = types.Types[types.TINT]
-	typs[16] = functype(nil, []ir.Node{anonfield(typs[15]), anonfield(typs[15])}, nil)
+	typs[16] = functype(nil, []*ir.Field{anonfield(typs[15]), anonfield(typs[15])}, nil)
 	typs[17] = types.Types[types.TUINT]
-	typs[18] = functype(nil, []ir.Node{anonfield(typs[17]), anonfield(typs[15])}, nil)
-	typs[19] = functype(nil, []ir.Node{anonfield(typs[6])}, nil)
+	typs[18] = functype(nil, []*ir.Field{anonfield(typs[17]), anonfield(typs[15])}, nil)
+	typs[19] = functype(nil, []*ir.Field{anonfield(typs[6])}, nil)
 	typs[20] = types.Types[types.TFLOAT64]
-	typs[21] = functype(nil, []ir.Node{anonfield(typs[20])}, nil)
+	typs[21] = functype(nil, []*ir.Field{anonfield(typs[20])}, nil)
 	typs[22] = types.Types[types.TINT64]
-	typs[23] = functype(nil, []ir.Node{anonfield(typs[22])}, nil)
+	typs[23] = functype(nil, []*ir.Field{anonfield(typs[22])}, nil)
 	typs[24] = types.Types[types.TUINT64]
-	typs[25] = functype(nil, []ir.Node{anonfield(typs[24])}, nil)
+	typs[25] = functype(nil, []*ir.Field{anonfield(typs[24])}, nil)
 	typs[26] = types.Types[types.TCOMPLEX128]
-	typs[27] = functype(nil, []ir.Node{anonfield(typs[26])}, nil)
+	typs[27] = functype(nil, []*ir.Field{anonfield(typs[26])}, nil)
 	typs[28] = types.Types[types.TSTRING]
-	typs[29] = functype(nil, []ir.Node{anonfield(typs[28])}, nil)
-	typs[30] = functype(nil, []ir.Node{anonfield(typs[2])}, nil)
-	typs[31] = functype(nil, []ir.Node{anonfield(typs[5])}, nil)
+	typs[29] = functype(nil, []*ir.Field{anonfield(typs[28])}, nil)
+	typs[30] = functype(nil, []*ir.Field{anonfield(typs[2])}, nil)
+	typs[31] = functype(nil, []*ir.Field{anonfield(typs[5])}, nil)
 	typs[32] = types.NewArray(typs[0], 32)
 	typs[33] = types.NewPtr(typs[32])
-	typs[34] = functype(nil, []ir.Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28])}, []ir.Node{anonfield(typs[28])})
-	typs[35] = functype(nil, []ir.Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []ir.Node{anonfield(typs[28])})
-	typs[36] = functype(nil, []ir.Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []ir.Node{anonfield(typs[28])})
-	typs[37] = functype(nil, []ir.Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []ir.Node{anonfield(typs[28])})
+	typs[34] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28])}, []*ir.Field{anonfield(typs[28])})
+	typs[35] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []*ir.Field{anonfield(typs[28])})
+	typs[36] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []*ir.Field{anonfield(typs[28])})
+	typs[37] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []*ir.Field{anonfield(typs[28])})
 	typs[38] = types.NewSlice(typs[28])
-	typs[39] = functype(nil, []ir.Node{anonfield(typs[33]), anonfield(typs[38])}, []ir.Node{anonfield(typs[28])})
-	typs[40] = functype(nil, []ir.Node{anonfield(typs[28]), anonfield(typs[28])}, []ir.Node{anonfield(typs[15])})
+	typs[39] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[38])}, []*ir.Field{anonfield(typs[28])})
+	typs[40] = functype(nil, []*ir.Field{anonfield(typs[28]), anonfield(typs[28])}, []*ir.Field{anonfield(typs[15])})
 	typs[41] = types.NewArray(typs[0], 4)
 	typs[42] = types.NewPtr(typs[41])
-	typs[43] = functype(nil, []ir.Node{anonfield(typs[42]), anonfield(typs[22])}, []ir.Node{anonfield(typs[28])})
-	typs[44] = functype(nil, []ir.Node{anonfield(typs[33]), anonfield(typs[1]), anonfield(typs[15])}, []ir.Node{anonfield(typs[28])})
-	typs[45] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[15])}, []ir.Node{anonfield(typs[28])})
+	typs[43] = functype(nil, []*ir.Field{anonfield(typs[42]), anonfield(typs[22])}, []*ir.Field{anonfield(typs[28])})
+	typs[44] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[1]), anonfield(typs[15])}, []*ir.Field{anonfield(typs[28])})
+	typs[45] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[15])}, []*ir.Field{anonfield(typs[28])})
 	typs[46] = types.Runetype
 	typs[47] = types.NewSlice(typs[46])
-	typs[48] = functype(nil, []ir.Node{anonfield(typs[33]), anonfield(typs[47])}, []ir.Node{anonfield(typs[28])})
+	typs[48] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[47])}, []*ir.Field{anonfield(typs[28])})
 	typs[49] = types.NewSlice(typs[0])
-	typs[50] = functype(nil, []ir.Node{anonfield(typs[33]), anonfield(typs[28])}, []ir.Node{anonfield(typs[49])})
+	typs[50] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[28])}, []*ir.Field{anonfield(typs[49])})
 	typs[51] = types.NewArray(typs[46], 32)
 	typs[52] = types.NewPtr(typs[51])
-	typs[53] = functype(nil, []ir.Node{anonfield(typs[52]), anonfield(typs[28])}, []ir.Node{anonfield(typs[47])})
-	typs[54] = functype(nil, []ir.Node{anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[5])}, []ir.Node{anonfield(typs[15])})
-	typs[55] = functype(nil, []ir.Node{anonfield(typs[28]), anonfield(typs[15])}, []ir.Node{anonfield(typs[46]), anonfield(typs[15])})
-	typs[56] = functype(nil, []ir.Node{anonfield(typs[28])}, []ir.Node{anonfield(typs[15])})
-	typs[57] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[2])}, []ir.Node{anonfield(typs[2])})
-	typs[58] = functype(nil, []ir.Node{anonfield(typs[2])}, []ir.Node{anonfield(typs[7])})
-	typs[59] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[3])}, []ir.Node{anonfield(typs[2])})
-	typs[60] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[2])}, []ir.Node{anonfield(typs[2]), anonfield(typs[6])})
-	typs[61] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[1]), anonfield(typs[1])}, nil)
-	typs[62] = functype(nil, []ir.Node{anonfield(typs[1])}, nil)
+	typs[53] = functype(nil, []*ir.Field{anonfield(typs[52]), anonfield(typs[28])}, []*ir.Field{anonfield(typs[47])})
+	typs[54] = functype(nil, []*ir.Field{anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[5])}, []*ir.Field{anonfield(typs[15])})
+	typs[55] = functype(nil, []*ir.Field{anonfield(typs[28]), anonfield(typs[15])}, []*ir.Field{anonfield(typs[46]), anonfield(typs[15])})
+	typs[56] = functype(nil, []*ir.Field{anonfield(typs[28])}, []*ir.Field{anonfield(typs[15])})
+	typs[57] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[2])}, []*ir.Field{anonfield(typs[2])})
+	typs[58] = functype(nil, []*ir.Field{anonfield(typs[2])}, []*ir.Field{anonfield(typs[7])})
+	typs[59] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[3])}, []*ir.Field{anonfield(typs[2])})
+	typs[60] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[2])}, []*ir.Field{anonfield(typs[2]), anonfield(typs[6])})
+	typs[61] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[1]), anonfield(typs[1])}, nil)
+	typs[62] = functype(nil, []*ir.Field{anonfield(typs[1])}, nil)
 	typs[63] = types.NewPtr(typs[5])
-	typs[64] = functype(nil, []ir.Node{anonfield(typs[63]), anonfield(typs[7]), anonfield(typs[7])}, []ir.Node{anonfield(typs[6])})
+	typs[64] = functype(nil, []*ir.Field{anonfield(typs[63]), anonfield(typs[7]), anonfield(typs[7])}, []*ir.Field{anonfield(typs[6])})
 	typs[65] = types.Types[types.TUINT32]
-	typs[66] = functype(nil, nil, []ir.Node{anonfield(typs[65])})
+	typs[66] = functype(nil, nil, []*ir.Field{anonfield(typs[65])})
 	typs[67] = types.NewMap(typs[2], typs[2])
-	typs[68] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[22]), anonfield(typs[3])}, []ir.Node{anonfield(typs[67])})
-	typs[69] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[3])}, []ir.Node{anonfield(typs[67])})
-	typs[70] = functype(nil, nil, []ir.Node{anonfield(typs[67])})
-	typs[71] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, []ir.Node{anonfield(typs[3])})
-	typs[72] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, []ir.Node{anonfield(typs[3])})
-	typs[73] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3]), anonfield(typs[1])}, []ir.Node{anonfield(typs[3])})
-	typs[74] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, []ir.Node{anonfield(typs[3]), anonfield(typs[6])})
-	typs[75] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, []ir.Node{anonfield(typs[3]), anonfield(typs[6])})
-	typs[76] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3]), anonfield(typs[1])}, []ir.Node{anonfield(typs[3]), anonfield(typs[6])})
-	typs[77] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, nil)
-	typs[78] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, nil)
-	typs[79] = functype(nil, []ir.Node{anonfield(typs[3])}, nil)
-	typs[80] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[67])}, nil)
+	typs[68] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[22]), anonfield(typs[3])}, []*ir.Field{anonfield(typs[67])})
+	typs[69] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[3])}, []*ir.Field{anonfield(typs[67])})
+	typs[70] = functype(nil, nil, []*ir.Field{anonfield(typs[67])})
+	typs[71] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, []*ir.Field{anonfield(typs[3])})
+	typs[72] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, []*ir.Field{anonfield(typs[3])})
+	typs[73] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3]), anonfield(typs[1])}, []*ir.Field{anonfield(typs[3])})
+	typs[74] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, []*ir.Field{anonfield(typs[3]), anonfield(typs[6])})
+	typs[75] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, []*ir.Field{anonfield(typs[3]), anonfield(typs[6])})
+	typs[76] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3]), anonfield(typs[1])}, []*ir.Field{anonfield(typs[3]), anonfield(typs[6])})
+	typs[77] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, nil)
+	typs[78] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, nil)
+	typs[79] = functype(nil, []*ir.Field{anonfield(typs[3])}, nil)
+	typs[80] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67])}, nil)
 	typs[81] = types.NewChan(typs[2], types.Cboth)
-	typs[82] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[22])}, []ir.Node{anonfield(typs[81])})
-	typs[83] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[15])}, []ir.Node{anonfield(typs[81])})
+	typs[82] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[22])}, []*ir.Field{anonfield(typs[81])})
+	typs[83] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[15])}, []*ir.Field{anonfield(typs[81])})
 	typs[84] = types.NewChan(typs[2], types.Crecv)
-	typs[85] = functype(nil, []ir.Node{anonfield(typs[84]), anonfield(typs[3])}, nil)
-	typs[86] = functype(nil, []ir.Node{anonfield(typs[84]), anonfield(typs[3])}, []ir.Node{anonfield(typs[6])})
+	typs[85] = functype(nil, []*ir.Field{anonfield(typs[84]), anonfield(typs[3])}, nil)
+	typs[86] = functype(nil, []*ir.Field{anonfield(typs[84]), anonfield(typs[3])}, []*ir.Field{anonfield(typs[6])})
 	typs[87] = types.NewChan(typs[2], types.Csend)
-	typs[88] = functype(nil, []ir.Node{anonfield(typs[87]), anonfield(typs[3])}, nil)
+	typs[88] = functype(nil, []*ir.Field{anonfield(typs[87]), anonfield(typs[3])}, nil)
 	typs[89] = types.NewArray(typs[0], 3)
-	typs[90] = tostruct([]ir.Node{namedfield("enabled", typs[6]), namedfield("pad", typs[89]), namedfield("needed", typs[6]), namedfield("cgo", typs[6]), namedfield("alignme", typs[24])})
-	typs[91] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[3]), anonfield(typs[3])}, nil)
-	typs[92] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[3])}, nil)
-	typs[93] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[3]), anonfield(typs[15])}, []ir.Node{anonfield(typs[15])})
-	typs[94] = functype(nil, []ir.Node{anonfield(typs[87]), anonfield(typs[3])}, []ir.Node{anonfield(typs[6])})
-	typs[95] = functype(nil, []ir.Node{anonfield(typs[3]), anonfield(typs[84])}, []ir.Node{anonfield(typs[6])})
+	typs[90] = tostruct([]*ir.Field{namedfield("enabled", typs[6]), namedfield("pad", typs[89]), namedfield("needed", typs[6]), namedfield("cgo", typs[6]), namedfield("alignme", typs[24])})
+	typs[91] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[3]), anonfield(typs[3])}, nil)
+	typs[92] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[3])}, nil)
+	typs[93] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[3]), anonfield(typs[15])}, []*ir.Field{anonfield(typs[15])})
+	typs[94] = functype(nil, []*ir.Field{anonfield(typs[87]), anonfield(typs[3])}, []*ir.Field{anonfield(typs[6])})
+	typs[95] = functype(nil, []*ir.Field{anonfield(typs[3]), anonfield(typs[84])}, []*ir.Field{anonfield(typs[6])})
 	typs[96] = types.NewPtr(typs[6])
-	typs[97] = functype(nil, []ir.Node{anonfield(typs[3]), anonfield(typs[96]), anonfield(typs[84])}, []ir.Node{anonfield(typs[6])})
-	typs[98] = functype(nil, []ir.Node{anonfield(typs[63])}, nil)
-	typs[99] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[1]), anonfield(typs[63]), anonfield(typs[15]), anonfield(typs[15]), anonfield(typs[6])}, []ir.Node{anonfield(typs[15]), anonfield(typs[6])})
-	typs[100] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[15])}, []ir.Node{anonfield(typs[7])})
-	typs[101] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[22]), anonfield(typs[22])}, []ir.Node{anonfield(typs[7])})
-	typs[102] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[15]), anonfield(typs[7])}, []ir.Node{anonfield(typs[7])})
+	typs[97] = functype(nil, []*ir.Field{anonfield(typs[3]), anonfield(typs[96]), anonfield(typs[84])}, []*ir.Field{anonfield(typs[6])})
+	typs[98] = functype(nil, []*ir.Field{anonfield(typs[63])}, nil)
+	typs[99] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[1]), anonfield(typs[63]), anonfield(typs[15]), anonfield(typs[15]), anonfield(typs[6])}, []*ir.Field{anonfield(typs[15]), anonfield(typs[6])})
+	typs[100] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[15])}, []*ir.Field{anonfield(typs[7])})
+	typs[101] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[22]), anonfield(typs[22])}, []*ir.Field{anonfield(typs[7])})
+	typs[102] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[15]), anonfield(typs[7])}, []*ir.Field{anonfield(typs[7])})
 	typs[103] = types.NewSlice(typs[2])
-	typs[104] = functype(nil, []ir.Node{anonfield(typs[1]), anonfield(typs[103]), anonfield(typs[15])}, []ir.Node{anonfield(typs[103])})
-	typs[105] = functype(nil, []ir.Node{anonfield(typs[3]), anonfield(typs[3]), anonfield(typs[5])}, nil)
-	typs[106] = functype(nil, []ir.Node{anonfield(typs[7]), anonfield(typs[5])}, nil)
-	typs[107] = functype(nil, []ir.Node{anonfield(typs[3]), anonfield(typs[3]), anonfield(typs[5])}, []ir.Node{anonfield(typs[6])})
-	typs[108] = functype(nil, []ir.Node{anonfield(typs[3]), anonfield(typs[3])}, []ir.Node{anonfield(typs[6])})
-	typs[109] = functype(nil, []ir.Node{anonfield(typs[7]), anonfield(typs[7])}, []ir.Node{anonfield(typs[6])})
-	typs[110] = functype(nil, []ir.Node{anonfield(typs[7]), anonfield(typs[5]), anonfield(typs[5])}, []ir.Node{anonfield(typs[5])})
-	typs[111] = functype(nil, []ir.Node{anonfield(typs[7]), anonfield(typs[5])}, []ir.Node{anonfield(typs[5])})
-	typs[112] = functype(nil, []ir.Node{anonfield(typs[22]), anonfield(typs[22])}, []ir.Node{anonfield(typs[22])})
-	typs[113] = functype(nil, []ir.Node{anonfield(typs[24]), anonfield(typs[24])}, []ir.Node{anonfield(typs[24])})
-	typs[114] = functype(nil, []ir.Node{anonfield(typs[20])}, []ir.Node{anonfield(typs[22])})
-	typs[115] = functype(nil, []ir.Node{anonfield(typs[20])}, []ir.Node{anonfield(typs[24])})
-	typs[116] = functype(nil, []ir.Node{anonfield(typs[20])}, []ir.Node{anonfield(typs[65])})
-	typs[117] = functype(nil, []ir.Node{anonfield(typs[22])}, []ir.Node{anonfield(typs[20])})
-	typs[118] = functype(nil, []ir.Node{anonfield(typs[24])}, []ir.Node{anonfield(typs[20])})
-	typs[119] = functype(nil, []ir.Node{anonfield(typs[65])}, []ir.Node{anonfield(typs[20])})
-	typs[120] = functype(nil, []ir.Node{anonfield(typs[26]), anonfield(typs[26])}, []ir.Node{anonfield(typs[26])})
-	typs[121] = functype(nil, []ir.Node{anonfield(typs[5]), anonfield(typs[5])}, nil)
-	typs[122] = functype(nil, []ir.Node{anonfield(typs[7]), anonfield(typs[1]), anonfield(typs[5])}, nil)
+	typs[104] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[103]), anonfield(typs[15])}, []*ir.Field{anonfield(typs[103])})
+	typs[105] = functype(nil, []*ir.Field{anonfield(typs[3]), anonfield(typs[3]), anonfield(typs[5])}, nil)
+	typs[106] = functype(nil, []*ir.Field{anonfield(typs[7]), anonfield(typs[5])}, nil)
+	typs[107] = functype(nil, []*ir.Field{anonfield(typs[3]), anonfield(typs[3]), anonfield(typs[5])}, []*ir.Field{anonfield(typs[6])})
+	typs[108] = functype(nil, []*ir.Field{anonfield(typs[3]), anonfield(typs[3])}, []*ir.Field{anonfield(typs[6])})
+	typs[109] = functype(nil, []*ir.Field{anonfield(typs[7]), anonfield(typs[7])}, []*ir.Field{anonfield(typs[6])})
+	typs[110] = functype(nil, []*ir.Field{anonfield(typs[7]), anonfield(typs[5]), anonfield(typs[5])}, []*ir.Field{anonfield(typs[5])})
+	typs[111] = functype(nil, []*ir.Field{anonfield(typs[7]), anonfield(typs[5])}, []*ir.Field{anonfield(typs[5])})
+	typs[112] = functype(nil, []*ir.Field{anonfield(typs[22]), anonfield(typs[22])}, []*ir.Field{anonfield(typs[22])})
+	typs[113] = functype(nil, []*ir.Field{anonfield(typs[24]), anonfield(typs[24])}, []*ir.Field{anonfield(typs[24])})
+	typs[114] = functype(nil, []*ir.Field{anonfield(typs[20])}, []*ir.Field{anonfield(typs[22])})
+	typs[115] = functype(nil, []*ir.Field{anonfield(typs[20])}, []*ir.Field{anonfield(typs[24])})
+	typs[116] = functype(nil, []*ir.Field{anonfield(typs[20])}, []*ir.Field{anonfield(typs[65])})
+	typs[117] = functype(nil, []*ir.Field{anonfield(typs[22])}, []*ir.Field{anonfield(typs[20])})
+	typs[118] = functype(nil, []*ir.Field{anonfield(typs[24])}, []*ir.Field{anonfield(typs[20])})
+	typs[119] = functype(nil, []*ir.Field{anonfield(typs[65])}, []*ir.Field{anonfield(typs[20])})
+	typs[120] = functype(nil, []*ir.Field{anonfield(typs[26]), anonfield(typs[26])}, []*ir.Field{anonfield(typs[26])})
+	typs[121] = functype(nil, []*ir.Field{anonfield(typs[5]), anonfield(typs[5])}, nil)
+	typs[122] = functype(nil, []*ir.Field{anonfield(typs[7]), anonfield(typs[1]), anonfield(typs[5])}, nil)
 	typs[123] = types.NewSlice(typs[7])
-	typs[124] = functype(nil, []ir.Node{anonfield(typs[7]), anonfield(typs[123])}, nil)
+	typs[124] = functype(nil, []*ir.Field{anonfield(typs[7]), anonfield(typs[123])}, nil)
 	typs[125] = types.Types[types.TUINT8]
-	typs[126] = functype(nil, []ir.Node{anonfield(typs[125]), anonfield(typs[125])}, nil)
+	typs[126] = functype(nil, []*ir.Field{anonfield(typs[125]), anonfield(typs[125])}, nil)
 	typs[127] = types.Types[types.TUINT16]
-	typs[128] = functype(nil, []ir.Node{anonfield(typs[127]), anonfield(typs[127])}, nil)
-	typs[129] = functype(nil, []ir.Node{anonfield(typs[65]), anonfield(typs[65])}, nil)
-	typs[130] = functype(nil, []ir.Node{anonfield(typs[24]), anonfield(typs[24])}, nil)
+	typs[128] = functype(nil, []*ir.Field{anonfield(typs[127]), anonfield(typs[127])}, nil)
+	typs[129] = functype(nil, []*ir.Field{anonfield(typs[65]), anonfield(typs[65])}, nil)
+	typs[130] = functype(nil, []*ir.Field{anonfield(typs[24]), anonfield(typs[24])}, nil)
 	return typs[:]
 }
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index ee09e7876e..0ba2858b8b 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -363,7 +363,7 @@ func closureType(clo ir.Node) *types.Type {
 	// The information appears in the binary in the form of type descriptors;
 	// the struct is unnamed so that closures in multiple packages with the
 	// same struct type can share the descriptor.
-	fields := []ir.Node{
+	fields := []*ir.Field{
 		namedfield(".F", types.Types[types.TUINTPTR]),
 	}
 	for _, v := range clo.Func().ClosureVars {
@@ -456,9 +456,9 @@ func makepartialcall(dot ir.Node, t0 *types.Type, meth *types.Sym) *ir.Func {
 	// number at the use of the method expression in this
 	// case. See issue 29389.
 
-	tfn := ir.Nod(ir.OTFUNC, nil, nil)
-	tfn.PtrList().Set(structargs(t0.Params(), true))
-	tfn.PtrRlist().Set(structargs(t0.Results(), false))
+	tfn := ir.NewFuncType(base.Pos, nil,
+		structargs(t0.Params(), true),
+		structargs(t0.Results(), false))
 
 	fn := dclfunc(sym, tfn)
 	fn.SetDupok(true)
@@ -510,7 +510,7 @@ func makepartialcall(dot ir.Node, t0 *types.Type, meth *types.Sym) *ir.Func {
 // needed in the closure for n (n must be a OCALLPART node).
 // The address of a variable of the returned type can be cast to a func.
 func partialCallType(n ir.Node) *types.Type {
-	t := tostruct([]ir.Node{
+	t := tostruct([]*ir.Field{
 		namedfield("F", types.Types[types.TUINTPTR]),
 		namedfield("R", n.Left().Type()),
 	})
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 3d8f97d93d..637587392a 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -134,7 +134,7 @@ func addvar(n *ir.Name, t *types.Type, ctxt ir.Class) {
 
 // declare variables from grammar
 // new_name_list (type | [type] = expr_list)
-func variter(vl []ir.Node, t ir.Node, el []ir.Node) []ir.Node {
+func variter(vl []ir.Node, t ir.Ntype, el []ir.Node) []ir.Node {
 	var init []ir.Node
 	doexpr := len(el) > 0
 
@@ -221,18 +221,16 @@ func dclname(s *types.Sym) *ir.Name {
 	return n
 }
 
-func anonfield(typ *types.Type) ir.Node {
+func anonfield(typ *types.Type) *ir.Field {
 	return symfield(nil, typ)
 }
 
-func namedfield(s string, typ *types.Type) ir.Node {
+func namedfield(s string, typ *types.Type) *ir.Field {
 	return symfield(lookup(s), typ)
 }
 
-func symfield(s *types.Sym, typ *types.Type) ir.Node {
-	n := nodSym(ir.ODCLFIELD, nil, s)
-	n.SetType(typ)
-	return n
+func symfield(s *types.Sym, typ *types.Type) *ir.Field {
+	return ir.NewField(base.Pos, s, nil, typ)
 }
 
 // oldname returns the Node that declares symbol s in the current scope.
@@ -279,7 +277,8 @@ func oldname(s *types.Sym) ir.Node {
 	return n
 }
 
-// importName is like oldname, but it reports an error if sym is from another package and not exported.
+// importName is like oldname,
+// but it reports an error if sym is from another package and not exported.
 func importName(sym *types.Sym) ir.Node {
 	n := oldname(sym)
 	if !types.IsExported(sym.Name) && sym.Pkg != ir.LocalPkg {
@@ -348,12 +347,12 @@ func colasdefn(left []ir.Node, defn ir.Node) {
 
 // declare the arguments in an
 // interface field declaration.
-func ifacedcl(n ir.Node) {
-	if n.Op() != ir.ODCLFIELD || n.Left() == nil {
+func ifacedcl(n *ir.Field) {
+	if n.Sym == nil {
 		base.Fatalf("ifacedcl")
 	}
 
-	if n.Sym().IsBlank() {
+	if n.Sym.IsBlank() {
 		base.Errorf("methods must have a unique non-blank name")
 	}
 }
@@ -371,13 +370,13 @@ func funchdr(fn *ir.Func) {
 	types.Markdcl()
 
 	if fn.Nname != nil && fn.Nname.Ntype != nil {
-		funcargs(fn.Nname.Ntype)
+		funcargs(fn.Nname.Ntype.(*ir.FuncType))
 	} else {
 		funcargs2(fn.Type())
 	}
 }
 
-func funcargs(nt ir.Node) {
+func funcargs(nt *ir.FuncType) {
 	if nt.Op() != ir.OTFUNC {
 		base.Fatalf("funcargs %v", nt.Op())
 	}
@@ -389,13 +388,13 @@ func funcargs(nt ir.Node) {
 	// TODO(mdempsky): This is ugly, and only necessary because
 	// esc.go uses Vargen to figure out result parameters' index
 	// within the result tuple.
-	vargen = nt.Rlist().Len()
+	vargen = len(nt.Results)
 
 	// declare the receiver and in arguments.
-	if nt.Left() != nil {
-		funcarg(nt.Left(), ir.PPARAM)
+	if nt.Recv != nil {
+		funcarg(nt.Recv, ir.PPARAM)
 	}
-	for _, n := range nt.List().Slice() {
+	for _, n := range nt.Params {
 		funcarg(n, ir.PPARAM)
 	}
 
@@ -403,21 +402,21 @@ func funcargs(nt ir.Node) {
 	vargen = 0
 
 	// declare the out arguments.
-	gen := nt.List().Len()
-	for _, n := range nt.Rlist().Slice() {
-		if n.Sym() == nil {
+	gen := len(nt.Params)
+	for _, n := range nt.Results {
+		if n.Sym == nil {
 			// Name so that escape analysis can track it. ~r stands for 'result'.
-			n.SetSym(lookupN("~r", gen))
+			n.Sym = lookupN("~r", gen)
 			gen++
 		}
-		if n.Sym().IsBlank() {
+		if n.Sym.IsBlank() {
 			// Give it a name so we can assign to it during return. ~b stands for 'blank'.
 			// The name must be different from ~r above because if you have
 			//	func f() (_ int)
 			//	func g() int
 			// f is allowed to use a plain 'return' with no arguments, while g is not.
 			// So the two cases must be distinguished.
-			n.SetSym(lookupN("~b", gen))
+			n.Sym = lookupN("~b", gen)
 			gen++
 		}
 
@@ -427,22 +426,19 @@ func funcargs(nt ir.Node) {
 	vargen = oldvargen
 }
 
-func funcarg(n ir.Node, ctxt ir.Class) {
-	if n.Op() != ir.ODCLFIELD {
-		base.Fatalf("funcarg %v", n.Op())
-	}
-	if n.Sym() == nil {
+func funcarg(n *ir.Field, ctxt ir.Class) {
+	if n.Sym == nil {
 		return
 	}
 
-	name := ir.NewNameAt(n.Pos(), n.Sym())
-	n.SetRight(name)
-	name.Ntype = n.Left()
-	name.SetIsDDD(n.IsDDD())
+	name := ir.NewNameAt(n.Pos, n.Sym)
+	n.Decl = name
+	name.Ntype = n.Ntype
+	name.SetIsDDD(n.IsDDD)
 	declare(name, ctxt)
 
 	vargen++
-	n.Right().Name().Vargen = int32(vargen)
+	n.Decl.Name().Vargen = int32(vargen)
 }
 
 // Same as funcargs, except run over an already constructed TFUNC.
@@ -514,28 +510,22 @@ func checkembeddedtype(t *types.Type) {
 	}
 }
 
-func structfield(n ir.Node) *types.Field {
+func structfield(n *ir.Field) *types.Field {
 	lno := base.Pos
-	base.Pos = n.Pos()
-
-	if n.Op() != ir.ODCLFIELD {
-		base.Fatalf("structfield: oops %v\n", n)
-	}
+	base.Pos = n.Pos
 
-	if n.Left() != nil {
-		n.SetLeft(typecheck(n.Left(), ctxType))
-		n.SetType(n.Left().Type())
-		n.SetLeft(nil)
+	if n.Ntype != nil {
+		n.Ntype = typecheckNtype(n.Ntype)
+		n.Type = n.Ntype.Type()
+		n.Ntype = nil
 	}
 
-	f := types.NewField(n.Pos(), n.Sym(), n.Type())
-	if n.Embedded() {
-		checkembeddedtype(n.Type())
+	f := types.NewField(n.Pos, n.Sym, n.Type)
+	if n.Embedded {
+		checkembeddedtype(n.Type)
 		f.Embedded = 1
 	}
-	if n.Opt() != nil {
-		f.Note = n.Opt().(string)
-	}
+	f.Note = n.Note
 
 	base.Pos = lno
 	return f
@@ -561,7 +551,7 @@ func checkdupfields(what string, fss ...[]*types.Field) {
 
 // convert a parsed id/type list into
 // a type for struct/interface/arglist
-func tostruct(l []ir.Node) *types.Type {
+func tostruct(l []*ir.Field) *types.Type {
 	t := types.New(types.TSTRUCT)
 
 	fields := make([]*types.Field, len(l))
@@ -583,17 +573,17 @@ func tostruct(l []ir.Node) *types.Type {
 	return t
 }
 
-func tofunargs(l []ir.Node, funarg types.Funarg) *types.Type {
+func tofunargs(l []*ir.Field, funarg types.Funarg) *types.Type {
 	t := types.New(types.TSTRUCT)
 	t.StructType().Funarg = funarg
 
 	fields := make([]*types.Field, len(l))
 	for i, n := range l {
 		f := structfield(n)
-		f.SetIsDDD(n.IsDDD())
-		if n.Right() != nil {
-			n.Right().SetType(f.Type)
-			f.Nname = n.Right()
+		f.SetIsDDD(n.IsDDD)
+		if n.Decl != nil {
+			n.Decl.SetType(f.Type)
+			f.Nname = n.Decl
 		}
 		if f.Broke() {
 			t.SetBroke(true)
@@ -611,15 +601,11 @@ func tofunargsfield(fields []*types.Field, funarg types.Funarg) *types.Type {
 	return t
 }
 
-func interfacefield(n ir.Node) *types.Field {
+func interfacefield(n *ir.Field) *types.Field {
 	lno := base.Pos
-	base.Pos = n.Pos()
-
-	if n.Op() != ir.ODCLFIELD {
-		base.Fatalf("interfacefield: oops %v\n", n)
-	}
+	base.Pos = n.Pos
 
-	if n.Opt() != nil {
+	if n.Note != "" {
 		base.Errorf("interface method cannot have annotation")
 	}
 
@@ -628,19 +614,19 @@ func interfacefield(n ir.Node) *types.Field {
 	// If Sym != nil, then Sym is MethodName and Left is Signature.
 	// Otherwise, Left is InterfaceTypeName.
 
-	if n.Left() != nil {
-		n.SetLeft(typecheck(n.Left(), ctxType))
-		n.SetType(n.Left().Type())
-		n.SetLeft(nil)
+	if n.Ntype != nil {
+		n.Ntype = typecheckNtype(n.Ntype)
+		n.Type = n.Ntype.Type()
+		n.Ntype = nil
 	}
 
-	f := types.NewField(n.Pos(), n.Sym(), n.Type())
+	f := types.NewField(n.Pos, n.Sym, n.Type)
 
 	base.Pos = lno
 	return f
 }
 
-func tointerface(l []ir.Node) *types.Type {
+func tointerface(l []*ir.Field) *types.Type {
 	if len(l) == 0 {
 		return types.Types[types.TINTER]
 	}
@@ -657,7 +643,7 @@ func tointerface(l []ir.Node) *types.Type {
 	return t
 }
 
-func fakeRecv() ir.Node {
+func fakeRecv() *ir.Field {
 	return anonfield(types.FakeRecvType())
 }
 
@@ -673,12 +659,12 @@ func isifacemethod(f *types.Type) bool {
 }
 
 // turn a parsed function declaration into a type
-func functype(this ir.Node, in, out []ir.Node) *types.Type {
+func functype(this *ir.Field, in, out []*ir.Field) *types.Type {
 	t := types.New(types.TFUNC)
 
-	var rcvr []ir.Node
+	var rcvr []*ir.Field
 	if this != nil {
-		rcvr = []ir.Node{this}
+		rcvr = []*ir.Field{this}
 	}
 	t.FuncType().Receiver = tofunargs(rcvr, types.FunargRcvr)
 	t.FuncType().Params = tofunargs(in, types.FunargParams)
@@ -923,7 +909,7 @@ func setNodeNameFunc(n ir.Node) {
 	n.Sym().SetFunc(true)
 }
 
-func dclfunc(sym *types.Sym, tfn ir.Node) *ir.Func {
+func dclfunc(sym *types.Sym, tfn ir.Ntype) *ir.Func {
 	if tfn.Op() != ir.OTFUNC {
 		base.Fatalf("expected OTFUNC node, got %v", tfn)
 	}
@@ -934,7 +920,7 @@ func dclfunc(sym *types.Sym, tfn ir.Node) *ir.Func {
 	fn.Nname.Ntype = tfn
 	setNodeNameFunc(fn.Nname)
 	funchdr(fn)
-	fn.Nname.Ntype = typecheck(fn.Nname.Ntype, ctxType)
+	fn.Nname.Ntype = typecheckNtype(fn.Nname.Ntype)
 	return fn
 }
 
diff --git a/src/cmd/compile/internal/gc/embed.go b/src/cmd/compile/internal/gc/embed.go
index 1c8ccdadef..d9bfd6f5ed 100644
--- a/src/cmd/compile/internal/gc/embed.go
+++ b/src/cmd/compile/internal/gc/embed.go
@@ -28,7 +28,7 @@ const (
 
 var numLocalEmbed int
 
-func varEmbed(p *noder, names []ir.Node, typ ir.Node, exprs []ir.Node, embeds []PragmaEmbed) (newExprs []ir.Node) {
+func varEmbed(p *noder, names []ir.Node, typ ir.Ntype, exprs []ir.Node, embeds []PragmaEmbed) (newExprs []ir.Node) {
 	haveEmbed := false
 	for _, decl := range p.file.DeclList {
 		imp, ok := decl.(*syntax.ImportDecl)
@@ -141,8 +141,10 @@ func embedKindApprox(typ ir.Node) int {
 	if typ.Sym() != nil && typ.Sym().Name == "string" && typ.Sym().Pkg == ir.LocalPkg {
 		return embedString
 	}
-	if typ.Op() == ir.OTARRAY && typ.Left() == nil && typ.Right().Sym() != nil && typ.Right().Sym().Name == "byte" && typ.Right().Sym().Pkg == ir.LocalPkg {
-		return embedBytes
+	if typ, ok := typ.(*ir.SliceType); ok {
+		if sym := typ.Elem.Sym(); sym != nil && sym.Name == "byte" && sym.Pkg == ir.LocalPkg {
+			return embedBytes
+		}
 	}
 	return embedUnknown
 }
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index 3f0f381974..c9f5d0c85c 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -1056,9 +1056,6 @@ func (w *exportWriter) stmt(n ir.Node) {
 		w.localName(n.Left())
 		w.typ(n.Left().Type())
 
-	// case ODCLFIELD:
-	//	unimplemented - handled by default case
-
 	case ir.OAS:
 		// Don't export "v = <N>" initializing statements, hope they're always
 		// preceded by the DCL which will be re-parsed and typecheck to reproduce
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 88f6e36e07..c219b70e0f 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -974,9 +974,6 @@ func (r *importReader) node() ir.Node {
 		typ := ir.TypeNode(r.typ())
 		return npos(pos, liststmt(variter([]ir.Node{lhs}, typ, nil))) // TODO(gri) avoid list creation
 
-	// case ODCLFIELD:
-	//	unimplemented
-
 	// case OAS, OASWB:
 	// 	unreachable - mapped to OAS case below by exporter
 
diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index 7f2a39ff46..ed0218c0e2 100644
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -48,7 +48,7 @@ func fninit(n []ir.Node) {
 	if len(nf) > 0 {
 		base.Pos = nf[0].Pos() // prolog/epilog gets line number of first init stmt
 		initializers := lookup("init")
-		fn := dclfunc(initializers, ir.Nod(ir.OTFUNC, nil, nil))
+		fn := dclfunc(initializers, ir.NewFuncType(base.Pos, nil, nil, nil))
 		for _, dcl := range initTodo.Dcl {
 			dcl.Name().Curfn = fn
 		}
diff --git a/src/cmd/compile/internal/gc/mkbuiltin.go b/src/cmd/compile/internal/gc/mkbuiltin.go
index d763f1ebee..5317484de9 100644
--- a/src/cmd/compile/internal/gc/mkbuiltin.go
+++ b/src/cmd/compile/internal/gc/mkbuiltin.go
@@ -207,7 +207,7 @@ func (i *typeInterner) fields(fl *ast.FieldList, keepNames bool) string {
 			}
 		}
 	}
-	return fmt.Sprintf("[]ir.Node{%s}", strings.Join(res, ", "))
+	return fmt.Sprintf("[]*ir.Field{%s}", strings.Join(res, ", "))
 }
 
 func intconst(e ast.Expr) int64 {
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 1c433b5d30..e6c78d1afb 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -412,7 +412,7 @@ func (p *noder) varDecl(decl *syntax.VarDecl) []ir.Node {
 // constant declarations are handled correctly (e.g., issue 15550).
 type constState struct {
 	group  *syntax.Group
-	typ    ir.Node
+	typ    ir.Ntype
 	values []ir.Node
 	iota   int64
 }
@@ -578,18 +578,18 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) ir.Node {
 	return f
 }
 
-func (p *noder) signature(recv *syntax.Field, typ *syntax.FuncType) ir.Node {
-	n := p.nod(typ, ir.OTFUNC, nil, nil)
+func (p *noder) signature(recv *syntax.Field, typ *syntax.FuncType) *ir.FuncType {
+	var rcvr *ir.Field
 	if recv != nil {
-		n.SetLeft(p.param(recv, false, false))
+		rcvr = p.param(recv, false, false)
 	}
-	n.PtrList().Set(p.params(typ.ParamList, true))
-	n.PtrRlist().Set(p.params(typ.ResultList, false))
-	return n
+	return ir.NewFuncType(p.pos(typ), rcvr,
+		p.params(typ.ParamList, true),
+		p.params(typ.ResultList, false))
 }
 
-func (p *noder) params(params []*syntax.Field, dddOk bool) []ir.Node {
-	nodes := make([]ir.Node, 0, len(params))
+func (p *noder) params(params []*syntax.Field, dddOk bool) []*ir.Field {
+	nodes := make([]*ir.Field, 0, len(params))
 	for i, param := range params {
 		p.setlineno(param)
 		nodes = append(nodes, p.param(param, dddOk, i+1 == len(params)))
@@ -597,17 +597,17 @@ func (p *noder) params(params []*syntax.Field, dddOk bool) []ir.Node {
 	return nodes
 }
 
-func (p *noder) param(param *syntax.Field, dddOk, final bool) ir.Node {
+func (p *noder) param(param *syntax.Field, dddOk, final bool) *ir.Field {
 	var name *types.Sym
 	if param.Name != nil {
 		name = p.name(param.Name)
 	}
 
 	typ := p.typeExpr(param.Type)
-	n := p.nodSym(param, ir.ODCLFIELD, typ, name)
+	n := ir.NewField(p.pos(param), name, typ, nil)
 
 	// rewrite ...T parameter
-	if typ.Op() == ir.ODDD {
+	if typ, ok := typ.(*ir.SliceType); ok && typ.DDD {
 		if !dddOk {
 			// We mark these as syntax errors to get automatic elimination
 			// of multiple such errors per line (see ErrorfAt in subr.go).
@@ -619,13 +619,8 @@ func (p *noder) param(param *syntax.Field, dddOk, final bool) ir.Node {
 				p.errorAt(param.Name.Pos(), "syntax error: cannot use ... with non-final parameter %s", param.Name.Value)
 			}
 		}
-		typ.SetOp(ir.OTARRAY)
-		typ.SetRight(typ.Left())
-		typ.SetLeft(nil)
-		n.SetIsDDD(true)
-		if n.Left() != nil {
-			n.Left().SetIsDDD(true)
-		}
+		typ.DDD = false
+		n.IsDDD = true
 	}
 
 	return n
@@ -727,14 +722,14 @@ func (p *noder) expr(expr syntax.Expr) ir.Node {
 		var len ir.Node
 		if expr.Len != nil {
 			len = p.expr(expr.Len)
-		} else {
-			len = p.nod(expr, ir.ODDD, nil, nil)
 		}
-		return p.nod(expr, ir.OTARRAY, len, p.typeExpr(expr.Elem))
+		return ir.NewArrayType(p.pos(expr), len, p.typeExpr(expr.Elem))
 	case *syntax.SliceType:
-		return p.nod(expr, ir.OTARRAY, nil, p.typeExpr(expr.Elem))
+		return ir.NewSliceType(p.pos(expr), p.typeExpr(expr.Elem))
 	case *syntax.DotsType:
-		return p.nod(expr, ir.ODDD, p.typeExpr(expr.Elem), nil)
+		t := ir.NewSliceType(p.pos(expr), p.typeExpr(expr.Elem))
+		t.DDD = true
+		return t
 	case *syntax.StructType:
 		return p.structType(expr)
 	case *syntax.InterfaceType:
@@ -742,11 +737,11 @@ func (p *noder) expr(expr syntax.Expr) ir.Node {
 	case *syntax.FuncType:
 		return p.signature(nil, expr)
 	case *syntax.MapType:
-		return p.nod(expr, ir.OTMAP, p.typeExpr(expr.Key), p.typeExpr(expr.Value))
+		return ir.NewMapType(p.pos(expr),
+			p.typeExpr(expr.Key), p.typeExpr(expr.Value))
 	case *syntax.ChanType:
-		n := p.nod(expr, ir.OTCHAN, p.typeExpr(expr.Elem), nil)
-		n.SetTChanDir(p.chanDir(expr.Dir))
-		return n
+		return ir.NewChanType(p.pos(expr),
+			p.typeExpr(expr.Elem), p.chanDir(expr.Dir))
 
 	case *syntax.TypeSwitchGuard:
 		n := p.nod(expr, ir.OTYPESW, nil, p.expr(expr.X))
@@ -837,14 +832,21 @@ func (p *noder) sum(x syntax.Expr) ir.Node {
 	return n
 }
 
-func (p *noder) typeExpr(typ syntax.Expr) ir.Node {
+func (p *noder) typeExpr(typ syntax.Expr) ir.Ntype {
 	// TODO(mdempsky): Be stricter? typecheck should handle errors anyway.
-	return p.expr(typ)
+	n := p.expr(typ)
+	if n == nil {
+		return nil
+	}
+	if _, ok := n.(ir.Ntype); !ok {
+		ir.Dump("NOT NTYPE", n)
+	}
+	return n.(ir.Ntype)
 }
 
-func (p *noder) typeExprOrNil(typ syntax.Expr) ir.Node {
+func (p *noder) typeExprOrNil(typ syntax.Expr) ir.Ntype {
 	if typ != nil {
-		return p.expr(typ)
+		return p.typeExpr(typ)
 	}
 	return nil
 }
@@ -862,47 +864,43 @@ func (p *noder) chanDir(dir syntax.ChanDir) types.ChanDir {
 }
 
 func (p *noder) structType(expr *syntax.StructType) ir.Node {
-	l := make([]ir.Node, 0, len(expr.FieldList))
+	l := make([]*ir.Field, 0, len(expr.FieldList))
 	for i, field := range expr.FieldList {
 		p.setlineno(field)
-		var n ir.Node
+		var n *ir.Field
 		if field.Name == nil {
 			n = p.embedded(field.Type)
 		} else {
-			n = p.nodSym(field, ir.ODCLFIELD, p.typeExpr(field.Type), p.name(field.Name))
+			n = ir.NewField(p.pos(field), p.name(field.Name), p.typeExpr(field.Type), nil)
 		}
 		if i < len(expr.TagList) && expr.TagList[i] != nil {
-			n.SetOpt(constant.StringVal(p.basicLit(expr.TagList[i])))
+			n.Note = constant.StringVal(p.basicLit(expr.TagList[i]))
 		}
 		l = append(l, n)
 	}
 
 	p.setlineno(expr)
-	n := p.nod(expr, ir.OTSTRUCT, nil, nil)
-	n.PtrList().Set(l)
-	return n
+	return ir.NewStructType(p.pos(expr), l)
 }
 
 func (p *noder) interfaceType(expr *syntax.InterfaceType) ir.Node {
-	l := make([]ir.Node, 0, len(expr.MethodList))
+	l := make([]*ir.Field, 0, len(expr.MethodList))
 	for _, method := range expr.MethodList {
 		p.setlineno(method)
-		var n ir.Node
+		var n *ir.Field
 		if method.Name == nil {
-			n = p.nodSym(method, ir.ODCLFIELD, importName(p.packname(method.Type)), nil)
+			n = ir.NewField(p.pos(method), nil, importName(p.packname(method.Type)).(ir.Ntype), nil)
 		} else {
 			mname := p.name(method.Name)
-			sig := p.typeExpr(method.Type)
-			sig.SetLeft(fakeRecv())
-			n = p.nodSym(method, ir.ODCLFIELD, sig, mname)
+			sig := p.typeExpr(method.Type).(*ir.FuncType)
+			sig.Recv = fakeRecv()
+			n = ir.NewField(p.pos(method), mname, sig, nil)
 			ifacedcl(n)
 		}
 		l = append(l, n)
 	}
 
-	n := p.nod(expr, ir.OTINTER, nil, nil)
-	n.PtrList().Set(l)
-	return n
+	return ir.NewInterfaceType(p.pos(expr), l)
 }
 
 func (p *noder) packname(expr syntax.Expr) *types.Sym {
@@ -934,7 +932,7 @@ func (p *noder) packname(expr syntax.Expr) *types.Sym {
 	panic(fmt.Sprintf("unexpected packname: %#v", expr))
 }
 
-func (p *noder) embedded(typ syntax.Expr) ir.Node {
+func (p *noder) embedded(typ syntax.Expr) *ir.Field {
 	op, isStar := typ.(*syntax.Operation)
 	if isStar {
 		if op.Op != syntax.Mul || op.Y != nil {
@@ -944,11 +942,11 @@ func (p *noder) embedded(typ syntax.Expr) ir.Node {
 	}
 
 	sym := p.packname(typ)
-	n := p.nodSym(typ, ir.ODCLFIELD, importName(sym), lookup(sym.Name))
-	n.SetEmbedded(true)
+	n := ir.NewField(p.pos(typ), lookup(sym.Name), importName(sym).(ir.Ntype), nil)
+	n.Embedded = true
 
 	if isStar {
-		n.SetLeft(p.nod(op, ir.ODEREF, n.Left(), nil))
+		n.Ntype = ir.NewStarExpr(p.pos(op), n.Ntype)
 	}
 	return n
 }
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index dc9efc07fe..73d369f413 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -347,7 +347,7 @@ func methodfunc(f *types.Type, receiver *types.Type) *types.Type {
 	if receiver != nil {
 		inLen++
 	}
-	in := make([]ir.Node, 0, inLen)
+	in := make([]*ir.Field, 0, inLen)
 
 	if receiver != nil {
 		d := anonfield(receiver)
@@ -356,12 +356,12 @@ func methodfunc(f *types.Type, receiver *types.Type) *types.Type {
 
 	for _, t := range f.Params().Fields().Slice() {
 		d := anonfield(t.Type)
-		d.SetIsDDD(t.IsDDD())
+		d.IsDDD = t.IsDDD()
 		in = append(in, d)
 	}
 
 	outLen := f.Results().Fields().Len()
-	out := make([]ir.Node, 0, outLen)
+	out := make([]*ir.Field, 0, outLen)
 	for _, t := range f.Results().Fields().Slice() {
 		d := anonfield(t.Type)
 		out = append(out, d)
@@ -1626,7 +1626,7 @@ func dumpbasictypes() {
 		// The latter is the type of an auto-generated wrapper.
 		dtypesym(types.NewPtr(types.Errortype))
 
-		dtypesym(functype(nil, []ir.Node{anonfield(types.Errortype)}, []ir.Node{anonfield(types.Types[types.TSTRING])}))
+		dtypesym(functype(nil, []*ir.Field{anonfield(types.Errortype)}, []*ir.Field{anonfield(types.Types[types.TSTRING])}))
 
 		// add paths for runtime and main, which 6l imports implicitly.
 		dimportpath(Runtimepkg)
diff --git a/src/cmd/compile/internal/gc/select.go b/src/cmd/compile/internal/gc/select.go
index 116b6f5b6e..9668df082a 100644
--- a/src/cmd/compile/internal/gc/select.go
+++ b/src/cmd/compile/internal/gc/select.go
@@ -381,7 +381,7 @@ var scase *types.Type
 // Keep in sync with src/runtime/select.go.
 func scasetype() *types.Type {
 	if scase == nil {
-		scase = tostruct([]ir.Node{
+		scase = tostruct([]*ir.Field{
 			namedfield("c", types.Types[types.TUNSAFEPTR]),
 			namedfield("elem", types.Types[types.TUNSAFEPTR]),
 		})
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 25490246e6..b1c9d24d99 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -1062,9 +1062,9 @@ func expandmeth(t *types.Type) {
 	t.AllMethods().Set(ms)
 }
 
-// Given funarg struct list, return list of ODCLFIELD Node fn args.
-func structargs(tl *types.Type, mustname bool) []ir.Node {
-	var args []ir.Node
+// Given funarg struct list, return list of fn args.
+func structargs(tl *types.Type, mustname bool) []*ir.Field {
+	var args []*ir.Field
 	gen := 0
 	for _, t := range tl.Fields().Slice() {
 		s := t.Sym
@@ -1074,8 +1074,8 @@ func structargs(tl *types.Type, mustname bool) []ir.Node {
 			gen++
 		}
 		a := symfield(s, t.Type)
-		a.SetPos(t.Pos)
-		a.SetIsDDD(t.IsDDD())
+		a.Pos = t.Pos
+		a.IsDDD = t.IsDDD()
 		args = append(args, a)
 	}
 
@@ -1123,10 +1123,10 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	base.Pos = autogeneratedPos
 	dclcontext = ir.PEXTERN
 
-	tfn := ir.Nod(ir.OTFUNC, nil, nil)
-	tfn.SetLeft(namedfield(".this", rcvr))
-	tfn.PtrList().Set(structargs(method.Type.Params(), true))
-	tfn.PtrRlist().Set(structargs(method.Type.Results(), false))
+	tfn := ir.NewFuncType(base.Pos,
+		namedfield(".this", rcvr),
+		structargs(method.Type.Params(), true),
+		structargs(method.Type.Results(), false))
 
 	fn := dclfunc(newnam, tfn)
 	fn.SetDupok(true)
@@ -1215,11 +1215,11 @@ func hashmem(t *types.Type) ir.Node {
 
 	n := NewName(sym)
 	setNodeNameFunc(n)
-	n.SetType(functype(nil, []ir.Node{
+	n.SetType(functype(nil, []*ir.Field{
 		anonfield(types.NewPtr(t)),
 		anonfield(types.Types[types.TUINTPTR]),
 		anonfield(types.Types[types.TUINTPTR]),
-	}, []ir.Node{
+	}, []*ir.Field{
 		anonfield(types.Types[types.TUINTPTR]),
 	}))
 	return n
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index a1b1809790..19146e2a9e 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -206,6 +206,10 @@ func typecheckFunc(fn *ir.Func) {
 	}
 }
 
+func typecheckNtype(n ir.Ntype) ir.Ntype {
+	return typecheck(n, ctxType).(ir.Ntype)
+}
+
 // typecheck type checks node n.
 // The result of typecheck MUST be assigned back to n, e.g.
 // 	n.Left = typecheck(n.Left, top)
@@ -403,9 +407,6 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		n.SetType(nil)
 		return n
 
-	case ir.ODDD:
-		break
-
 	// types (ODEREF is with exprs)
 	case ir.OTYPE:
 		ok |= ctxType
@@ -414,70 +415,69 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			return n
 		}
 
-	case ir.OTARRAY:
+	case ir.OTSLICE:
 		ok |= ctxType
-		r := typecheck(n.Right(), ctxType)
-		if r.Type() == nil {
-			n.SetType(nil)
+		n := n.(*ir.SliceType)
+		n.Elem = typecheck(n.Elem, ctxType)
+		if n.Elem.Type() == nil {
 			return n
 		}
+		t := types.NewSlice(n.Elem.Type())
+		n.SetOTYPE(t)
+		checkwidth(t)
 
-		var t *types.Type
-		if n.Left() == nil {
-			t = types.NewSlice(r.Type())
-		} else if n.Left().Op() == ir.ODDD {
+	case ir.OTARRAY:
+		ok |= ctxType
+		n := n.(*ir.ArrayType)
+		n.Elem = typecheck(n.Elem, ctxType)
+		if n.Elem.Type() == nil {
+			return n
+		}
+		if n.Len == nil { // [...]T
 			if !n.Diag() {
 				n.SetDiag(true)
 				base.Errorf("use of [...] array outside of array literal")
 			}
-			n.SetType(nil)
 			return n
-		} else {
-			n.SetLeft(indexlit(typecheck(n.Left(), ctxExpr)))
-			l := n.Left()
-			if ir.ConstType(l) != constant.Int {
-				switch {
-				case l.Type() == nil:
-					// Error already reported elsewhere.
-				case l.Type().IsInteger() && l.Op() != ir.OLITERAL:
-					base.Errorf("non-constant array bound %v", l)
-				default:
-					base.Errorf("invalid array bound %v", l)
-				}
-				n.SetType(nil)
-				return n
-			}
-
-			v := l.Val()
-			if doesoverflow(v, types.Types[types.TINT]) {
-				base.Errorf("array bound is too large")
-				n.SetType(nil)
-				return n
+		}
+		n.Len = indexlit(typecheck(n.Len, ctxExpr))
+		size := n.Len
+		if ir.ConstType(size) != constant.Int {
+			switch {
+			case size.Type() == nil:
+				// Error already reported elsewhere.
+			case size.Type().IsInteger() && size.Op() != ir.OLITERAL:
+				base.Errorf("non-constant array bound %v", size)
+			default:
+				base.Errorf("invalid array bound %v", size)
 			}
+			return n
+		}
 
-			if constant.Sign(v) < 0 {
-				base.Errorf("array bound must be non-negative")
-				n.SetType(nil)
-				return n
-			}
+		v := size.Val()
+		if doesoverflow(v, types.Types[types.TINT]) {
+			base.Errorf("array bound is too large")
+			return n
+		}
 
-			bound, _ := constant.Int64Val(v)
-			t = types.NewArray(r.Type(), bound)
+		if constant.Sign(v) < 0 {
+			base.Errorf("array bound must be non-negative")
+			return n
 		}
 
-		setTypeNode(n, t)
-		n.SetLeft(nil)
-		n.SetRight(nil)
+		bound, _ := constant.Int64Val(v)
+		t := types.NewArray(n.Elem.Type(), bound)
+		n.SetOTYPE(t)
 		checkwidth(t)
 
 	case ir.OTMAP:
 		ok |= ctxType
-		n.SetLeft(typecheck(n.Left(), ctxType))
-		n.SetRight(typecheck(n.Right(), ctxType))
-		l := n.Left()
-		r := n.Right()
+		n := n.(*ir.MapType)
+		n.Key = typecheck(n.Key, ctxType)
+		n.Elem = typecheck(n.Elem, ctxType)
+		l := n.Key
+		r := n.Elem
 		if l.Type() == nil || r.Type() == nil {
-			n.SetType(nil)
 			return n
 		}
 		if l.Type().NotInHeap() {
@@ -486,48 +486,42 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		if r.Type().NotInHeap() {
 			base.Errorf("incomplete (or unallocatable) map value not allowed")
 		}
-
-		setTypeNode(n, types.NewMap(l.Type(), r.Type()))
+		n.SetOTYPE(types.NewMap(l.Type(), r.Type()))
 		mapqueue = append(mapqueue, n) // check map keys when all types are settled
-		n.SetLeft(nil)
-		n.SetRight(nil)
 
 	case ir.OTCHAN:
 		ok |= ctxType
-		n.SetLeft(typecheck(n.Left(), ctxType))
-		l := n.Left()
+		n := n.(*ir.ChanType)
+		n.Elem = typecheck(n.Elem, ctxType)
+		l := n.Elem
 		if l.Type() == nil {
-			n.SetType(nil)
 			return n
 		}
 		if l.Type().NotInHeap() {
 			base.Errorf("chan of incomplete (or unallocatable) type not allowed")
 		}
-
-		setTypeNode(n, types.NewChan(l.Type(), n.TChanDir()))
-		n.SetLeft(nil)
-		n.ResetAux()
+		n.SetOTYPE(types.NewChan(l.Type(), n.Dir))
 
 	case ir.OTSTRUCT:
 		ok |= ctxType
-		setTypeNode(n, tostruct(n.List().Slice()))
-		n.PtrList().Set(nil)
+		n := n.(*ir.StructType)
+		n.SetOTYPE(tostruct(n.Fields))
 
 	case ir.OTINTER:
 		ok |= ctxType
-		setTypeNode(n, tointerface(n.List().Slice()))
+		n := n.(*ir.InterfaceType)
+		n.SetOTYPE(tointerface(n.Methods))
 
 	case ir.OTFUNC:
 		ok |= ctxType
-		setTypeNode(n, functype(n.Left(), n.List().Slice(), n.Rlist().Slice()))
-		n.SetLeft(nil)
-		n.PtrList().Set(nil)
-		n.PtrRlist().Set(nil)
+		n := n.(*ir.FuncType)
+		n.SetOTYPE(functype(n.Recv, n.Params, n.Results))
 
 	// type or expr
 	case ir.ODEREF:
-		n.SetLeft(typecheck(n.Left(), ctxExpr|ctxType))
-		l := n.Left()
+		n := n.(*ir.StarExpr)
+		n.X = typecheck(n.X, ctxExpr|ctxType)
+		l := n.X
 		t := l.Type()
 		if t == nil {
 			n.SetType(nil)
@@ -535,8 +529,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 		if l.Op() == ir.OTYPE {
 			ok |= ctxType
-			setTypeNode(n, types.NewPtr(l.Type()))
-			n.SetLeft(nil)
+			n.SetOTYPE(types.NewPtr(l.Type()))
 			// Ensure l.Type gets dowidth'd for the backend. Issue 20174.
 			checkwidth(l.Type())
 			break
@@ -2822,16 +2815,14 @@ func typecheckcomplit(n ir.Node) (res ir.Node) {
 	setlineno(n.Right())
 
 	// Need to handle [...]T arrays specially.
-	if n.Right().Op() == ir.OTARRAY && n.Right().Left() != nil && n.Right().Left().Op() == ir.ODDD {
-		n.Right().SetRight(typecheck(n.Right().Right(), ctxType))
-		if n.Right().Right().Type() == nil {
+	if array, ok := n.Right().(*ir.ArrayType); ok && array.Elem != nil && array.Len == nil {
+		array.Elem = typecheck(array.Elem, ctxType)
+		elemType := array.Elem.Type()
+		if elemType == nil {
 			n.SetType(nil)
 			return n
 		}
-		elemType := n.Right().Right().Type()
-
 		length := typecheckarraylit(elemType, -1, n.List().Slice(), "array literal")
-
 		n.SetOp(ir.OARRAYLIT)
 		n.SetType(types.NewArray(elemType, length))
 		n.SetRight(nil)
@@ -3464,7 +3455,7 @@ func stringtoruneslit(n ir.Node) ir.Node {
 	return nn
 }
 
-var mapqueue []ir.Node
+var mapqueue []*ir.MapType
 
 func checkMapKeys() {
 	for _, n := range mapqueue {
@@ -3531,7 +3522,7 @@ func typecheckdeftype(n ir.Node) {
 	}
 
 	n.SetTypecheck(1)
-	n.Name().Ntype = typecheck(n.Name().Ntype, ctxType)
+	n.Name().Ntype = typecheckNtype(n.Name().Ntype)
 	t := n.Name().Ntype.Type()
 	if t == nil {
 		n.SetDiag(true)
@@ -3593,7 +3584,7 @@ func typecheckdef(n ir.Node) {
 
 	case ir.OLITERAL:
 		if n.Name().Ntype != nil {
-			n.Name().Ntype = typecheck(n.Name().Ntype, ctxType)
+			n.Name().Ntype = typecheckNtype(n.Name().Ntype)
 			n.SetType(n.Name().Ntype.Type())
 			n.Name().Ntype = nil
 			if n.Type() == nil {
@@ -3647,7 +3638,7 @@ func typecheckdef(n ir.Node) {
 
 	case ir.ONAME:
 		if n.Name().Ntype != nil {
-			n.Name().Ntype = typecheck(n.Name().Ntype, ctxType)
+			n.Name().Ntype = typecheckNtype(n.Name().Ntype)
 			n.SetType(n.Name().Ntype.Type())
 			if n.Type() == nil {
 				n.SetDiag(true)
@@ -3686,9 +3677,9 @@ func typecheckdef(n ir.Node) {
 		if n.Alias() {
 			// Type alias declaration: Simply use the rhs type - no need
 			// to create a new type.
-			// If we have a syntax error, p.Ntype may be nil.
+			// If we have a syntax error, name.Ntype may be nil.
 			if n.Ntype != nil {
-				n.Ntype = typecheck(n.Ntype, ctxType)
+				n.Ntype = typecheckNtype(n.Ntype)
 				n.SetType(n.Ntype.Type())
 				if n.Type() == nil {
 					n.SetDiag(true)
@@ -3706,8 +3697,10 @@ func typecheckdef(n ir.Node) {
 		// regular type declaration
 		defercheckwidth()
 		n.SetWalkdef(1)
-		setTypeNode(n, types.New(types.TFORW))
-		n.Type().Sym = n.Sym()
+		t := types.New(types.TFORW)
+		t.Nod = n
+		t.Sym = n.Sym()
+		n.SetType(t)
 		errorsBefore := base.Errors()
 		typecheckdeftype(n)
 		if n.Type().Etype == types.TFORW && base.Errors() > errorsBefore {
@@ -3990,11 +3983,12 @@ func deadcodeexpr(n ir.Node) ir.Node {
 	return n
 }
 
-// setTypeNode sets n to an OTYPE node representing t.
-func setTypeNode(n ir.Node, t *types.Type) {
-	n.SetOp(ir.OTYPE)
+func toTypeNode(orig ir.Node, t *types.Type) ir.Node {
+	n := ir.Nod(ir.OTYPE, nil, nil)
+	n.SetPos(orig.Pos())
 	n.SetType(t)
-	n.Type().Nod = n
+	t.Nod = n
+	return n
 }
 
 // getIotaValue returns the current value for "iota",
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index 931135759a..d43545391c 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -176,7 +176,10 @@ func typeinit() {
 	t := types.New(types.TUNSAFEPTR)
 	types.Types[types.TUNSAFEPTR] = t
 	t.Sym = unsafepkg.Lookup("Pointer")
-	t.Sym.Def = ir.TypeNode(t)
+	n := ir.NewNameAt(src.NoXPos, t.Sym) // NewNameAt to get a package for use tracking
+	n.SetOp(ir.OTYPE)
+	n.SetType(t)
+	t.Sym.Def = n
 	dowidth(types.Types[types.TUNSAFEPTR])
 
 	for et := types.TINT8; et <= types.TUINT64; et++ {
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 2376bfc093..e7c88bd329 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -853,7 +853,7 @@ opswitch:
 			}
 			value = ir.Nod(ir.OINDEX, staticuint64s, index)
 			value.SetBounded(true)
-		case n.Left().Class() == ir.PEXTERN && n.Left().Name() != nil && n.Left().Name().Readonly():
+		case n.Left().Name() != nil && n.Left().Class() == ir.PEXTERN && n.Left().Name().Readonly():
 			// n.Left is a readonly global; use it directly.
 			value = n.Left()
 		case !fromType.IsInterface() && n.Esc() == EscNone && fromType.Width <= 1024:
@@ -3183,10 +3183,10 @@ func eqfor(t *types.Type) (n ir.Node, needsize bool) {
 		sym := typesymprefix(".eq", t)
 		n := NewName(sym)
 		setNodeNameFunc(n)
-		n.SetType(functype(nil, []ir.Node{
+		n.SetType(functype(nil, []*ir.Field{
 			anonfield(types.NewPtr(t)),
 			anonfield(types.NewPtr(t)),
-		}, []ir.Node{
+		}, []*ir.Field{
 			anonfield(types.Types[types.TBOOL]),
 		}))
 		return n, false
@@ -3914,7 +3914,7 @@ func wrapCall(n ir.Node, init *ir.Nodes) ir.Node {
 
 	// origArgs keeps track of what argument is uintptr-unsafe/unsafe-uintptr conversion.
 	origArgs := make([]ir.Node, n.List().Len())
-	t := ir.Nod(ir.OTFUNC, nil, nil)
+	var funcArgs []*ir.Field
 	for i, arg := range n.List().Slice() {
 		s := lookupN("a", i)
 		if !isBuiltinCall && arg.Op() == ir.OCONVNOP && arg.Type().IsUintptr() && arg.Left().Type().IsUnsafePtr() {
@@ -3922,8 +3922,9 @@ func wrapCall(n ir.Node, init *ir.Nodes) ir.Node {
 			arg = arg.Left()
 			n.List().SetIndex(i, arg)
 		}
-		t.PtrList().Append(symfield(s, arg.Type()))
+		funcArgs = append(funcArgs, symfield(s, arg.Type()))
 	}
+	t := ir.NewFuncType(base.Pos, nil, funcArgs, nil)
 
 	wrapCall_prgen++
 	sym := lookupN("wrap·", wrapCall_prgen)
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 2c13918599..f8e5f7641c 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -110,3 +110,47 @@ func (n *CallPartExpr) Left() Node                    { return n.X }
 func (n *CallPartExpr) Right() Node                   { return n.Method }
 func (n *CallPartExpr) SetLeft(x Node)                { n.X = x }
 func (n *CallPartExpr) SetRight(x Node)               { n.Method = x.(*Name) }
+
+// A StarExpr is a dereference expression *X.
+// It may end up being a value or a type.
+type StarExpr struct {
+	miniExpr
+	X Node
+}
+
+func NewStarExpr(pos src.XPos, x Node) *StarExpr {
+	n := &StarExpr{X: x}
+	n.op = ODEREF
+	n.pos = pos
+	return n
+}
+
+func (n *StarExpr) String() string                { return fmt.Sprint(n) }
+func (n *StarExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *StarExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *StarExpr) Left() Node                    { return n.X }
+func (n *StarExpr) SetLeft(x Node)                { n.X = x }
+
+func (*StarExpr) CanBeNtype() {}
+
+// SetOTYPE changes n to be an OTYPE node returning t,
+// like all the type nodes in type.go.
+func (n *StarExpr) SetOTYPE(t *types.Type) {
+	n.op = OTYPE
+	n.X = nil
+	n.typ = t
+	if t.Nod == nil {
+		t.Nod = n
+	}
+}
+
+func (n *StarExpr) DeepCopy(pos src.XPos) Node {
+	if n.op == OTYPE {
+		// Can't change types and no node references left.
+		return n
+	}
+	c := SepCopy(n).(*StarExpr)
+	c.pos = n.posOr(pos)
+	c.X = DeepCopy(pos, n.X)
+	return c
+}
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index a3999b6da0..c723bad4c9 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -403,10 +403,6 @@ func jconvFmt(n Node, s fmt.State, flag FmtFlag) {
 		fmt.Fprintf(s, " implicit(%v)", n.Implicit())
 	}
 
-	if n.Embedded() {
-		fmt.Fprintf(s, " embedded")
-	}
-
 	if n.Op() == ONAME {
 		if n.Name().Addrtaken() {
 			fmt.Fprint(s, " addrtaken")
@@ -921,13 +917,6 @@ func stmtFmt(n Node, s fmt.State, mode FmtMode) {
 	case ODCL:
 		mode.Fprintf(s, "var %v %v", n.Left().Sym(), n.Left().Type())
 
-	case ODCLFIELD:
-		if n.Sym() != nil {
-			mode.Fprintf(s, "%v %v", n.Sym(), n.Left())
-		} else {
-			mode.Fprintf(s, "%v", n.Left())
-		}
-
 	// Don't export "v = <N>" initializing statements, hope they're always
 	// preceded by the DCL which will be re-parsed and typechecked to reproduce
 	// the "v = <N>" again.
@@ -1115,6 +1104,7 @@ var OpPrec = []int{
 	OSTR2RUNES:     8,
 	OSTRUCTLIT:     8,
 	OTARRAY:        8,
+	OTSLICE:        8,
 	OTCHAN:         8,
 	OTFUNC:         8,
 	OTINTER:        8,
@@ -1176,7 +1166,6 @@ var OpPrec = []int{
 	OCASE:       -1,
 	OCONTINUE:   -1,
 	ODCL:        -1,
-	ODCLFIELD:   -1,
 	ODEFER:      -1,
 	OEMPTY:      -1,
 	OFALL:       -1,
@@ -1294,29 +1283,40 @@ func exprFmt(n Node, s fmt.State, prec int, mode FmtMode) {
 		}
 		mode.Fprintf(s, "%v", n.Type())
 
+	case OTSLICE:
+		n := n.(*SliceType)
+		if n.DDD {
+			mode.Fprintf(s, "...%v", n.Elem)
+		} else {
+			mode.Fprintf(s, "[]%v", n.Elem) // happens before typecheck
+		}
+
 	case OTARRAY:
-		if n.Left() != nil {
-			mode.Fprintf(s, "[%v]%v", n.Left(), n.Right())
-			return
+		n := n.(*ArrayType)
+		if n.Len == nil {
+			mode.Fprintf(s, "[...]%v", n.Elem)
+		} else {
+			mode.Fprintf(s, "[%v]%v", n.Len, n.Elem)
 		}
-		mode.Fprintf(s, "[]%v", n.Right()) // happens before typecheck
 
 	case OTMAP:
-		mode.Fprintf(s, "map[%v]%v", n.Left(), n.Right())
+		n := n.(*MapType)
+		mode.Fprintf(s, "map[%v]%v", n.Key, n.Elem)
 
 	case OTCHAN:
-		switch n.TChanDir() {
+		n := n.(*ChanType)
+		switch n.Dir {
 		case types.Crecv:
-			mode.Fprintf(s, "<-chan %v", n.Left())
+			mode.Fprintf(s, "<-chan %v", n.Elem)
 
 		case types.Csend:
-			mode.Fprintf(s, "chan<- %v", n.Left())
+			mode.Fprintf(s, "chan<- %v", n.Elem)
 
 		default:
-			if n.Left() != nil && n.Left().Op() == OTCHAN && n.Left().Sym() == nil && n.Left().TChanDir() == types.Crecv {
-				mode.Fprintf(s, "chan (%v)", n.Left())
+			if n.Elem != nil && n.Elem.Op() == OTCHAN && n.Elem.(*ChanType).Dir == types.Crecv {
+				mode.Fprintf(s, "chan (%v)", n.Elem)
 			} else {
-				mode.Fprintf(s, "chan %v", n.Left())
+				mode.Fprintf(s, "chan %v", n.Elem)
 			}
 		}
 
@@ -1556,8 +1556,6 @@ func exprFmt(n Node, s fmt.State, prec int, mode FmtMode) {
 			}
 			exprFmt(n1, s, nprec, mode)
 		}
-	case ODDD:
-		mode.Fprintf(s, "...")
 	default:
 		mode.Fprintf(s, "<node %v>", n.Op())
 	}
diff --git a/src/cmd/compile/internal/ir/mini.go b/src/cmd/compile/internal/ir/mini.go
index 338ded3308..d73ec4ecd5 100644
--- a/src/cmd/compile/internal/ir/mini.go
+++ b/src/cmd/compile/internal/ir/mini.go
@@ -33,6 +33,15 @@ 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.)
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 5546488fa7..1bc6bea3b6 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -43,7 +43,7 @@ type Name struct {
 	Vargen    int32
 	Decldepth int32 // declaration loop depth, increased for every loop or label
 
-	Ntype    Node
+	Ntype    Ntype
 	Heapaddr *Name // temp holding heap address of param
 
 	// ONAME PAUTOHEAP
@@ -160,6 +160,8 @@ func (n *Name) SetOffset(x int64)             { n.offset = x }
 func (n *Name) Iota() int64                   { return n.offset }
 func (n *Name) SetIota(x int64)               { n.offset = x }
 
+func (*Name) CanBeNtype() {}
+
 func (n *Name) SetOp(op Op) {
 	switch op {
 	default:
@@ -371,6 +373,8 @@ func (p *PkgName) Format(s fmt.State, verb rune) { FmtNode(p, s, verb) }
 func (p *PkgName) RawCopy() Node                 { c := *p; return &c }
 func (p *PkgName) Sym() *types.Sym               { return p.sym }
 
+func (*PkgName) CanBeNtype() {}
+
 func NewPkgName(pos src.XPos, sym *types.Sym, pkg *types.Pkg) *PkgName {
 	p := &PkgName{sym: sym, Pkg: pkg}
 	p.op = OPACK
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 653410d175..74557236cc 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -79,12 +79,8 @@ type Node interface {
 	SetImplicit(x bool)
 	IsDDD() bool
 	SetIsDDD(x bool)
-	Embedded() bool
-	SetEmbedded(x bool)
 	IndexMapLValue() bool
 	SetIndexMapLValue(x bool)
-	TChanDir() types.ChanDir
-	SetTChanDir(x types.ChanDir)
 	ResetAux()
 	HasBreak() bool
 	SetHasBreak(x bool)
@@ -205,6 +201,10 @@ func (n *node) Uint64Val() uint64     { panic("node.Uint64Val") }
 func (n *node) BoolVal() bool         { panic("node.BoolVal") }
 func (n *node) StringVal() string     { panic("node.StringVal") }
 
+// node can be Ntype only because of OXDOT of undefined name.
+// When that moves into its own syntax, can drop this.
+func (n *node) CanBeNtype() {}
+
 func (n *node) SetOp(op Op) {
 	if !okForNod[op] {
 		panic("cannot node.SetOp " + op.String())
@@ -252,20 +252,6 @@ func (n *node) SetIndexMapLValue(b bool) {
 	}
 }
 
-func (n *node) TChanDir() types.ChanDir {
-	if n.Op() != OTCHAN {
-		base.Fatalf("unexpected op: %v", n.Op())
-	}
-	return types.ChanDir(n.aux)
-}
-
-func (n *node) SetTChanDir(dir types.ChanDir) {
-	if n.Op() != OTCHAN {
-		base.Fatalf("unexpected op: %v", n.Op())
-	}
-	n.aux = uint8(dir)
-}
-
 func IsSynthetic(n Node) bool {
 	name := n.Sym().Name
 	return name[0] == '.' || name[0] == '~'
@@ -301,7 +287,6 @@ const (
 	_, nodeBounded   // bounds check unnecessary
 	_, nodeHasCall   // expression contains a function call
 	_, nodeLikely    // if statement condition likely
-	_, nodeEmbedded  // ODCLFIELD embedded type
 )
 
 func (n *node) Class() Class     { return Class(n.flags.get3(nodeClass)) }
@@ -320,7 +305,6 @@ func (n *node) Transient() bool { return n.flags&nodeTransient != 0 }
 func (n *node) Bounded() bool   { return n.flags&nodeBounded != 0 }
 func (n *node) HasCall() bool   { return n.flags&nodeHasCall != 0 }
 func (n *node) Likely() bool    { return n.flags&nodeLikely != 0 }
-func (n *node) Embedded() bool  { return n.flags&nodeEmbedded != 0 }
 
 func (n *node) SetClass(b Class)     { n.flags.set3(nodeClass, uint8(b)) }
 func (n *node) SetWalkdef(b uint8)   { n.flags.set2(nodeWalkdef, b) }
@@ -336,7 +320,6 @@ func (n *node) SetColas(b bool)     { n.flags.set(nodeColas, b) }
 func (n *node) SetTransient(b bool) { n.flags.set(nodeTransient, b) }
 func (n *node) SetHasCall(b bool)   { n.flags.set(nodeHasCall, b) }
 func (n *node) SetLikely(b bool)    { n.flags.set(nodeLikely, b) }
-func (n *node) SetEmbedded(b bool)  { n.flags.set(nodeEmbedded, b) }
 
 // MarkNonNil marks a pointer n as being guaranteed non-nil,
 // on all code paths, at all times.
@@ -474,7 +457,7 @@ const (
 
 	// Used during parsing but don't last.
 	ODCLFUNC  // func f() or func (r) f()
-	ODCLFIELD // struct field, interface field, or func/method argument/return value.
+	ODCLFIELD // UNUSED: TODO(rsc): Delete.
 	ODCLCONST // const pi = 3.14
 	ODCLTYPE  // type Int int or type Int = int
 
@@ -593,11 +576,11 @@ const (
 	// OTFUNC: func() - Left is receiver field, List is list of param fields, Rlist is
 	// list of result fields.
 	OTFUNC
-	OTARRAY // []int, [8]int, [N]int or [...]int
-	OTSLICE // to be used in future CL
+	OTARRAY // [8]int or [...]int
+	OTSLICE // []int
 
 	// misc
-	ODDD         // func f(args ...int) or f(l...) or var a = [...]int{0, 1, 2}.
+	ODDD         // UNUSED; TODO(rsc): Delete.
 	OINLCALL     // intermediary representation of an inlined call.
 	OEFACE       // itable and data words of an empty-interface value.
 	OITAB        // itable word of an interface value.
@@ -1050,6 +1033,8 @@ func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
 	switch op {
 	case ODCLFUNC:
 		return NewFunc(pos)
+	case ODEREF:
+		return NewStarExpr(pos, nleft)
 	case OPACK:
 		return NewPkgName(pos, nil, nil)
 	case OEMPTY:
@@ -1112,12 +1097,9 @@ var okForNod = [OEND]bool{
 	OCOPY:          true,
 	ODCL:           true,
 	ODCLCONST:      true,
-	ODCLFIELD:      true,
 	ODCLTYPE:       true,
-	ODDD:           true,
 	ODEFER:         true,
 	ODELETE:        true,
-	ODEREF:         true,
 	ODIV:           true,
 	ODOT:           true,
 	ODOTINTER:      true,
@@ -1201,13 +1183,6 @@ var okForNod = [OEND]bool{
 	OSTRUCTLIT:     true,
 	OSUB:           true,
 	OSWITCH:        true,
-	OTARRAY:        true,
-	OTCHAN:         true,
-	OTFUNC:         true,
-	OTINTER:        true,
-	OTMAP:          true,
-	OTSTRUCT:       true,
-	OTYPE:          true, // TODO: Remove once setTypeNode is gone.
 	OTYPESW:        true,
 	OVARDEF:        true,
 	OVARKILL:       true,
diff --git a/src/cmd/compile/internal/ir/type.go b/src/cmd/compile/internal/ir/type.go
index 3409424fed..39411ed431 100644
--- a/src/cmd/compile/internal/ir/type.go
+++ b/src/cmd/compile/internal/ir/type.go
@@ -7,21 +7,375 @@ package ir
 import (
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
+	"fmt"
 )
 
-func TypeNode(t *types.Type) Node {
-	return TypeNodeAt(src.NoXPos, t)
+// Nodes that represent the syntax of a type before type-checking.
+// After type-checking, they serve only as shells around a *types.Type.
+// Calling TypeNode converts a *types.Type to a Node shell.
+
+// An Ntype is a Node that syntactically looks like a type.
+// It can be the raw syntax for a type before typechecking,
+// or it can be an OTYPE with Type() set to a *types.Type.
+// Note that syntax doesn't guarantee it's a type: an expression
+// like *fmt is an Ntype (we don't know whether names are types yet),
+// but at least 1+1 is not an Ntype.
+type Ntype interface {
+	Node
+	CanBeNtype()
+}
+
+// A miniType is a minimal type syntax Node implementation,
+// to be embedded as the first field in a larger node implementation.
+type miniType struct {
+	miniNode
+	typ *types.Type
+}
+
+func (*miniType) CanBeNtype() {}
+
+func (n *miniType) Type() *types.Type { return n.typ }
+
+// setOTYPE changes n to be an OTYPE node returning t.
+// Rewriting the node in place this way should not be strictly
+// necessary (we should be able to update the uses with
+// proper OTYPE nodes), but it's mostly harmless and easy
+// to keep doing for now.
+//
+// setOTYPE also records t.Nod = self if t.Nod is not already set.
+// (Some types are shared by multiple OTYPE nodes, so only
+// the first such node is used as t.Nod.)
+func (n *miniType) setOTYPE(t *types.Type, self Node) {
+	if n.typ != nil {
+		panic(n.op.String() + " SetType: type already set")
+	}
+	n.op = OTYPE
+	n.typ = t
+
+	// t.Nod can be non-nil already
+	// in the case of shared *type.Types, like []byte or interface{}.
+	if t.Nod == nil {
+		t.Nod = self
+	}
+}
+
+func (n *miniType) Sym() *types.Sym { return nil }   // for Format OTYPE
+func (n *miniType) Implicit() bool  { return false } // for Format OTYPE
+
+// A ChanType represents a chan Elem syntax with the direction Dir.
+type ChanType struct {
+	miniType
+	Elem Node
+	Dir  types.ChanDir
+}
+
+func NewChanType(pos src.XPos, elem Node, dir types.ChanDir) *ChanType {
+	n := &ChanType{Elem: elem, Dir: dir}
+	n.op = OTCHAN
+	n.pos = pos
+	return n
 }
 
-func TypeNodeAt(pos src.XPos, t *types.Type) Node {
-	// if we copied another type with *t = *u
-	// then t->nod might be out of date, so
-	// check t->nod->type too
-	if AsNode(t.Nod) == nil || AsNode(t.Nod).Type() != t {
-		t.Nod = NodAt(pos, OTYPE, nil, nil)
-		AsNode(t.Nod).SetType(t)
-		AsNode(t.Nod).SetSym(t.Sym)
+func (n *ChanType) String() string                { return fmt.Sprint(n) }
+func (n *ChanType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ChanType) RawCopy() Node                 { c := *n; return &c }
+func (n *ChanType) SetOTYPE(t *types.Type) {
+	n.setOTYPE(t, n)
+	n.Elem = nil
+}
+
+func (n *ChanType) DeepCopy(pos src.XPos) Node {
+	if n.op == OTYPE {
+		// Can't change types and no node references left.
+		return n
 	}
+	return NewChanType(n.posOr(pos), DeepCopy(pos, n.Elem), n.Dir)
+}
+
+// A MapType represents a map[Key]Value type syntax.u
+type MapType struct {
+	miniType
+	Key  Node
+	Elem Node
+}
+
+func NewMapType(pos src.XPos, key, elem Node) *MapType {
+	n := &MapType{Key: key, Elem: elem}
+	n.op = OTMAP
+	n.pos = pos
+	return n
+}
+
+func (n *MapType) String() string                { return fmt.Sprint(n) }
+func (n *MapType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *MapType) RawCopy() Node                 { c := *n; return &c }
+func (n *MapType) SetOTYPE(t *types.Type) {
+	n.setOTYPE(t, n)
+	n.Key = nil
+	n.Elem = nil
+}
+
+func (n *MapType) DeepCopy(pos src.XPos) Node {
+	if n.op == OTYPE {
+		// Can't change types and no node references left.
+		return n
+	}
+	return NewMapType(n.posOr(pos), DeepCopy(pos, n.Key), DeepCopy(pos, n.Elem))
+}
+
+// A StructType represents a struct { ... } type syntax.
+type StructType struct {
+	miniType
+	Fields []*Field
+}
+
+func NewStructType(pos src.XPos, fields []*Field) *StructType {
+	n := &StructType{Fields: fields}
+	n.op = OTSTRUCT
+	n.pos = pos
+	return n
+}
+
+func (n *StructType) String() string                { return fmt.Sprint(n) }
+func (n *StructType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *StructType) RawCopy() Node                 { c := *n; return &c }
+func (n *StructType) SetOTYPE(t *types.Type) {
+	n.setOTYPE(t, n)
+	n.Fields = nil
+}
+
+func (n *StructType) DeepCopy(pos src.XPos) Node {
+	if n.op == OTYPE {
+		// Can't change types and no node references left.
+		return n
+	}
+	return NewStructType(n.posOr(pos), deepCopyFields(pos, n.Fields))
+}
+
+func deepCopyFields(pos src.XPos, fields []*Field) []*Field {
+	var out []*Field
+	for _, f := range fields {
+		out = append(out, f.deepCopy(pos))
+	}
+	return out
+}
+
+// An InterfaceType represents a struct { ... } type syntax.
+type InterfaceType struct {
+	miniType
+	Methods []*Field
+}
+
+func NewInterfaceType(pos src.XPos, methods []*Field) *InterfaceType {
+	n := &InterfaceType{Methods: methods}
+	n.op = OTINTER
+	n.pos = pos
+	return n
+}
+
+func (n *InterfaceType) String() string                { return fmt.Sprint(n) }
+func (n *InterfaceType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *InterfaceType) RawCopy() Node                 { c := *n; return &c }
+func (n *InterfaceType) SetOTYPE(t *types.Type) {
+	n.setOTYPE(t, n)
+	n.Methods = nil
+}
+
+func (n *InterfaceType) DeepCopy(pos src.XPos) Node {
+	if n.op == OTYPE {
+		// Can't change types and no node references left.
+		return n
+	}
+	return NewInterfaceType(n.posOr(pos), deepCopyFields(pos, n.Methods))
+}
+
+// A FuncType represents a func(Args) Results type syntax.
+type FuncType struct {
+	miniType
+	Recv    *Field
+	Params  []*Field
+	Results []*Field
+}
 
-	return AsNode(t.Nod)
+func NewFuncType(pos src.XPos, rcvr *Field, args, results []*Field) *FuncType {
+	n := &FuncType{Recv: rcvr, Params: args, Results: results}
+	n.op = OTFUNC
+	n.pos = pos
+	return n
+}
+
+func (n *FuncType) String() string                { return fmt.Sprint(n) }
+func (n *FuncType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *FuncType) RawCopy() Node                 { c := *n; return &c }
+
+func (n *FuncType) SetOTYPE(t *types.Type) {
+	n.setOTYPE(t, n)
+	n.Recv = nil
+	n.Params = nil
+	n.Results = nil
+}
+
+func (n *FuncType) DeepCopy(pos src.XPos) Node {
+	if n.op == OTYPE {
+		// Can't change types and no node references left.
+		return n
+	}
+	return NewFuncType(n.posOr(pos),
+		n.Recv.deepCopy(pos),
+		deepCopyFields(pos, n.Params),
+		deepCopyFields(pos, n.Results))
+}
+
+// A Field is a declared struct field, interface method, or function argument.
+// It is not a Node.
+type Field struct {
+	Pos      src.XPos
+	Sym      *types.Sym
+	Ntype    Ntype
+	Type     *types.Type
+	Embedded bool
+	IsDDD    bool
+	Note     string
+	Decl     *Name
+}
+
+func NewField(pos src.XPos, sym *types.Sym, ntyp Ntype, typ *types.Type) *Field {
+	return &Field{Pos: pos, Sym: sym, Ntype: ntyp, Type: typ}
+}
+
+func (f *Field) String() string {
+	var typ string
+	if f.Type != nil {
+		typ = fmt.Sprint(f.Type)
+	} else {
+		typ = fmt.Sprint(f.Ntype)
+	}
+	if f.Sym != nil {
+		return fmt.Sprintf("%v %v", f.Sym, typ)
+	}
+	return typ
+}
+
+func (f *Field) deepCopy(pos src.XPos) *Field {
+	if f == nil {
+		return nil
+	}
+	fpos := pos
+	if !pos.IsKnown() {
+		fpos = f.Pos
+	}
+	decl := f.Decl
+	if decl != nil {
+		decl = DeepCopy(pos, decl).(*Name)
+	}
+	ntype := f.Ntype
+	if ntype != nil {
+		ntype = DeepCopy(pos, ntype).(Ntype)
+	}
+	// No keyed literal here: if a new struct field is added, we want this to stop compiling.
+	return &Field{fpos, f.Sym, ntype, f.Type, f.Embedded, f.IsDDD, f.Note, decl}
+}
+
+// A SliceType represents a []Elem type syntax.
+// If DDD is true, it's the ...Elem at the end of a function list.
+type SliceType struct {
+	miniType
+	Elem Node
+	DDD  bool
+}
+
+func NewSliceType(pos src.XPos, elem Node) *SliceType {
+	n := &SliceType{Elem: elem}
+	n.op = OTSLICE
+	n.pos = pos
+	return n
+}
+
+func (n *SliceType) String() string                { return fmt.Sprint(n) }
+func (n *SliceType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *SliceType) RawCopy() Node                 { c := *n; return &c }
+func (n *SliceType) SetOTYPE(t *types.Type) {
+	n.setOTYPE(t, n)
+	n.Elem = nil
+}
+
+func (n *SliceType) DeepCopy(pos src.XPos) Node {
+	if n.op == OTYPE {
+		// Can't change types and no node references left.
+		return n
+	}
+	return NewSliceType(n.posOr(pos), DeepCopy(pos, n.Elem))
+}
+
+// An ArrayType represents a [Len]Elem type syntax.
+// If Len is nil, the type is a [...]Elem in an array literal.
+type ArrayType struct {
+	miniType
+	Len  Node
+	Elem Node
+}
+
+func NewArrayType(pos src.XPos, size Node, elem Node) *ArrayType {
+	n := &ArrayType{Len: size, Elem: elem}
+	n.op = OTARRAY
+	n.pos = pos
+	return n
+}
+
+func (n *ArrayType) String() string                { return fmt.Sprint(n) }
+func (n *ArrayType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ArrayType) RawCopy() Node                 { c := *n; return &c }
+
+func (n *ArrayType) DeepCopy(pos src.XPos) Node {
+	if n.op == OTYPE {
+		// Can't change types and no node references left.
+		return n
+	}
+	return NewArrayType(n.posOr(pos), DeepCopy(pos, n.Len), DeepCopy(pos, n.Elem))
+}
+
+func (n *ArrayType) SetOTYPE(t *types.Type) {
+	n.setOTYPE(t, n)
+	n.Len = nil
+	n.Elem = nil
+}
+
+// A typeNode is a Node wrapper for type t.
+type typeNode struct {
+	miniNode
+	typ *types.Type
+}
+
+func newTypeNode(pos src.XPos, typ *types.Type) *typeNode {
+	n := &typeNode{typ: typ}
+	n.pos = pos
+	n.op = OTYPE
+	return n
+}
+
+func (n *typeNode) String() string                { return fmt.Sprint(n) }
+func (n *typeNode) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *typeNode) RawCopy() Node                 { c := *n; return &c }
+func (n *typeNode) Type() *types.Type             { return n.typ }
+func (n *typeNode) Sym() *types.Sym               { return n.typ.Sym }
+func (n *typeNode) CanBeNtype()                   {}
+
+// TypeNode returns the Node representing the type t.
+func TypeNode(t *types.Type) Ntype {
+	return TypeNodeAt(src.NoXPos, t)
+}
+
+// TypeNodeAt returns the Node representing the type t.
+// If the node must be created, TypeNodeAt uses the position pos.
+// TODO(rsc): Does anyone actually use position on these type nodes?
+func TypeNodeAt(pos src.XPos, t *types.Type) Ntype {
+	// If we copied another type with *t = *u,
+	// then t.Nod might be out of date, so check t.Nod.Type() too.
+	n := AsNode(t.Nod)
+	if n == nil || n.Type() != t {
+		n := newTypeNode(pos, t) // t.Sym may be nil
+		t.Nod = n
+		return n
+	}
+	return n.(Ntype)
 }
-- 
GitLab


From ae1a3378092e25c7a7aa0100c2e29397f7bc2798 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 29 Nov 2020 08:58:39 -0500
Subject: [PATCH 0096/2400] [dev.regabi] cmd/compile: remove ODCLFIELD and ODDD
 ops

These are plain data now, not nodes (see previous CL).
The opcode deletions are not safe for toolstash -cmp,
so they are split into a separate CL.

Change-Id: Icef8a01e190195a7539a35b92f42835d823e314a
Reviewed-on: https://go-review.googlesource.com/c/go/+/274104
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/node.go      |   2 -
 src/cmd/compile/internal/ir/op_string.go | 218 +++++++++++------------
 2 files changed, 108 insertions(+), 112 deletions(-)

diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 74557236cc..2850704ae1 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -457,7 +457,6 @@ const (
 
 	// Used during parsing but don't last.
 	ODCLFUNC  // func f() or func (r) f()
-	ODCLFIELD // UNUSED: TODO(rsc): Delete.
 	ODCLCONST // const pi = 3.14
 	ODCLTYPE  // type Int int or type Int = int
 
@@ -580,7 +579,6 @@ const (
 	OTSLICE // []int
 
 	// misc
-	ODDD         // UNUSED; TODO(rsc): Delete.
 	OINLCALL     // intermediary representation of an inlined call.
 	OEFACE       // itable and data words of an empty-interface value.
 	OITAB        // itable word of an interface value.
diff --git a/src/cmd/compile/internal/ir/op_string.go b/src/cmd/compile/internal/ir/op_string.go
index faec164c7b..eefdc0ee59 100644
--- a/src/cmd/compile/internal/ir/op_string.go
+++ b/src/cmd/compile/internal/ir/op_string.go
@@ -56,119 +56,117 @@ func _() {
 	_ = x[OCOPY-45]
 	_ = x[ODCL-46]
 	_ = x[ODCLFUNC-47]
-	_ = x[ODCLFIELD-48]
-	_ = x[ODCLCONST-49]
-	_ = x[ODCLTYPE-50]
-	_ = x[ODELETE-51]
-	_ = x[ODOT-52]
-	_ = x[ODOTPTR-53]
-	_ = x[ODOTMETH-54]
-	_ = x[ODOTINTER-55]
-	_ = x[OXDOT-56]
-	_ = x[ODOTTYPE-57]
-	_ = x[ODOTTYPE2-58]
-	_ = x[OEQ-59]
-	_ = x[ONE-60]
-	_ = x[OLT-61]
-	_ = x[OLE-62]
-	_ = x[OGE-63]
-	_ = x[OGT-64]
-	_ = x[ODEREF-65]
-	_ = x[OINDEX-66]
-	_ = x[OINDEXMAP-67]
-	_ = x[OKEY-68]
-	_ = x[OSTRUCTKEY-69]
-	_ = x[OLEN-70]
-	_ = x[OMAKE-71]
-	_ = x[OMAKECHAN-72]
-	_ = x[OMAKEMAP-73]
-	_ = x[OMAKESLICE-74]
-	_ = x[OMAKESLICECOPY-75]
-	_ = x[OMUL-76]
-	_ = x[ODIV-77]
-	_ = x[OMOD-78]
-	_ = x[OLSH-79]
-	_ = x[ORSH-80]
-	_ = x[OAND-81]
-	_ = x[OANDNOT-82]
-	_ = x[ONEW-83]
-	_ = x[ONEWOBJ-84]
-	_ = x[ONOT-85]
-	_ = x[OBITNOT-86]
-	_ = x[OPLUS-87]
-	_ = x[ONEG-88]
-	_ = x[OOROR-89]
-	_ = x[OPANIC-90]
-	_ = x[OPRINT-91]
-	_ = x[OPRINTN-92]
-	_ = x[OPAREN-93]
-	_ = x[OSEND-94]
-	_ = x[OSLICE-95]
-	_ = x[OSLICEARR-96]
-	_ = x[OSLICESTR-97]
-	_ = x[OSLICE3-98]
-	_ = x[OSLICE3ARR-99]
-	_ = x[OSLICEHEADER-100]
-	_ = x[ORECOVER-101]
-	_ = x[ORECV-102]
-	_ = x[ORUNESTR-103]
-	_ = x[OSELRECV-104]
-	_ = x[OSELRECV2-105]
-	_ = x[OIOTA-106]
-	_ = x[OREAL-107]
-	_ = x[OIMAG-108]
-	_ = x[OCOMPLEX-109]
-	_ = x[OALIGNOF-110]
-	_ = x[OOFFSETOF-111]
-	_ = x[OSIZEOF-112]
-	_ = x[OMETHEXPR-113]
-	_ = x[OBLOCK-114]
-	_ = x[OBREAK-115]
-	_ = x[OCASE-116]
-	_ = x[OCONTINUE-117]
-	_ = x[ODEFER-118]
-	_ = x[OEMPTY-119]
-	_ = x[OFALL-120]
-	_ = x[OFOR-121]
-	_ = x[OFORUNTIL-122]
-	_ = x[OGOTO-123]
-	_ = x[OIF-124]
-	_ = x[OLABEL-125]
-	_ = x[OGO-126]
-	_ = x[ORANGE-127]
-	_ = x[ORETURN-128]
-	_ = x[OSELECT-129]
-	_ = x[OSWITCH-130]
-	_ = x[OTYPESW-131]
-	_ = x[OTCHAN-132]
-	_ = x[OTMAP-133]
-	_ = x[OTSTRUCT-134]
-	_ = x[OTINTER-135]
-	_ = x[OTFUNC-136]
-	_ = x[OTARRAY-137]
-	_ = x[OTSLICE-138]
-	_ = x[ODDD-139]
-	_ = x[OINLCALL-140]
-	_ = x[OEFACE-141]
-	_ = x[OITAB-142]
-	_ = x[OIDATA-143]
-	_ = x[OSPTR-144]
-	_ = x[OCLOSUREREAD-145]
-	_ = x[OCFUNC-146]
-	_ = x[OCHECKNIL-147]
-	_ = x[OVARDEF-148]
-	_ = x[OVARKILL-149]
-	_ = x[OVARLIVE-150]
-	_ = x[ORESULT-151]
-	_ = x[OINLMARK-152]
-	_ = x[ORETJMP-153]
-	_ = x[OGETG-154]
-	_ = x[OEND-155]
+	_ = x[ODCLCONST-48]
+	_ = x[ODCLTYPE-49]
+	_ = x[ODELETE-50]
+	_ = x[ODOT-51]
+	_ = x[ODOTPTR-52]
+	_ = x[ODOTMETH-53]
+	_ = x[ODOTINTER-54]
+	_ = x[OXDOT-55]
+	_ = x[ODOTTYPE-56]
+	_ = x[ODOTTYPE2-57]
+	_ = x[OEQ-58]
+	_ = x[ONE-59]
+	_ = x[OLT-60]
+	_ = x[OLE-61]
+	_ = x[OGE-62]
+	_ = x[OGT-63]
+	_ = x[ODEREF-64]
+	_ = x[OINDEX-65]
+	_ = x[OINDEXMAP-66]
+	_ = x[OKEY-67]
+	_ = x[OSTRUCTKEY-68]
+	_ = x[OLEN-69]
+	_ = x[OMAKE-70]
+	_ = x[OMAKECHAN-71]
+	_ = x[OMAKEMAP-72]
+	_ = x[OMAKESLICE-73]
+	_ = x[OMAKESLICECOPY-74]
+	_ = x[OMUL-75]
+	_ = x[ODIV-76]
+	_ = x[OMOD-77]
+	_ = x[OLSH-78]
+	_ = x[ORSH-79]
+	_ = x[OAND-80]
+	_ = x[OANDNOT-81]
+	_ = x[ONEW-82]
+	_ = x[ONEWOBJ-83]
+	_ = x[ONOT-84]
+	_ = x[OBITNOT-85]
+	_ = x[OPLUS-86]
+	_ = x[ONEG-87]
+	_ = x[OOROR-88]
+	_ = x[OPANIC-89]
+	_ = x[OPRINT-90]
+	_ = x[OPRINTN-91]
+	_ = x[OPAREN-92]
+	_ = x[OSEND-93]
+	_ = x[OSLICE-94]
+	_ = x[OSLICEARR-95]
+	_ = x[OSLICESTR-96]
+	_ = x[OSLICE3-97]
+	_ = x[OSLICE3ARR-98]
+	_ = x[OSLICEHEADER-99]
+	_ = x[ORECOVER-100]
+	_ = x[ORECV-101]
+	_ = x[ORUNESTR-102]
+	_ = x[OSELRECV-103]
+	_ = x[OSELRECV2-104]
+	_ = x[OIOTA-105]
+	_ = x[OREAL-106]
+	_ = x[OIMAG-107]
+	_ = x[OCOMPLEX-108]
+	_ = x[OALIGNOF-109]
+	_ = x[OOFFSETOF-110]
+	_ = x[OSIZEOF-111]
+	_ = x[OMETHEXPR-112]
+	_ = x[OBLOCK-113]
+	_ = x[OBREAK-114]
+	_ = x[OCASE-115]
+	_ = x[OCONTINUE-116]
+	_ = x[ODEFER-117]
+	_ = x[OEMPTY-118]
+	_ = x[OFALL-119]
+	_ = x[OFOR-120]
+	_ = x[OFORUNTIL-121]
+	_ = x[OGOTO-122]
+	_ = x[OIF-123]
+	_ = x[OLABEL-124]
+	_ = x[OGO-125]
+	_ = x[ORANGE-126]
+	_ = x[ORETURN-127]
+	_ = x[OSELECT-128]
+	_ = x[OSWITCH-129]
+	_ = x[OTYPESW-130]
+	_ = x[OTCHAN-131]
+	_ = x[OTMAP-132]
+	_ = x[OTSTRUCT-133]
+	_ = x[OTINTER-134]
+	_ = x[OTFUNC-135]
+	_ = x[OTARRAY-136]
+	_ = x[OTSLICE-137]
+	_ = x[OINLCALL-138]
+	_ = x[OEFACE-139]
+	_ = x[OITAB-140]
+	_ = x[OIDATA-141]
+	_ = x[OSPTR-142]
+	_ = x[OCLOSUREREAD-143]
+	_ = x[OCFUNC-144]
+	_ = x[OCHECKNIL-145]
+	_ = x[OVARDEF-146]
+	_ = x[OVARKILL-147]
+	_ = x[OVARLIVE-148]
+	_ = x[ORESULT-149]
+	_ = x[OINLMARK-150]
+	_ = x[ORETJMP-151]
+	_ = x[OGETG-152]
+	_ = x[OEND-153]
 }
 
-const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLFIELDDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNEWOBJNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECVSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRBLOCKBREAKCASECONTINUEDEFEREMPTYFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEDDDINLCALLEFACEITABIDATASPTRCLOSUREREADCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKRETJMPGETGEND"
+const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNEWOBJNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECVSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRBLOCKBREAKCASECONTINUEDEFEREMPTYFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCLOSUREREADCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKRETJMPGETGEND"
 
-var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 310, 317, 323, 326, 332, 339, 347, 351, 358, 366, 368, 370, 372, 374, 376, 378, 383, 388, 396, 399, 408, 411, 415, 423, 430, 439, 452, 455, 458, 461, 464, 467, 470, 476, 479, 485, 488, 494, 498, 501, 505, 510, 515, 521, 526, 530, 535, 543, 551, 557, 566, 577, 584, 588, 595, 602, 610, 614, 618, 622, 629, 636, 644, 650, 658, 663, 668, 672, 680, 685, 690, 694, 697, 705, 709, 711, 716, 718, 723, 729, 735, 741, 747, 752, 756, 763, 769, 774, 780, 786, 789, 796, 801, 805, 810, 814, 825, 830, 838, 844, 851, 858, 864, 871, 877, 881, 884}
+var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 388, 391, 400, 403, 407, 415, 422, 431, 444, 447, 450, 453, 456, 459, 462, 468, 471, 477, 480, 486, 490, 493, 497, 502, 507, 513, 518, 522, 527, 535, 543, 549, 558, 569, 576, 580, 587, 594, 602, 606, 610, 614, 621, 628, 636, 642, 650, 655, 660, 664, 672, 677, 682, 686, 689, 697, 701, 703, 708, 710, 715, 721, 727, 733, 739, 744, 748, 755, 761, 766, 772, 778, 785, 790, 794, 799, 803, 814, 819, 827, 833, 840, 847, 853, 860, 866, 870, 873}
 
 func (i Op) String() string {
 	if i >= Op(len(_Op_index)-1) {
-- 
GitLab


From c6de5d8d1f56465869a9271753796da35c60f3e6 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 30 Nov 2020 13:50:05 -0800
Subject: [PATCH 0097/2400] [dev.regabi] cmd/compile: simplify export data
 representation of nil

The handling of ONIL and Orig has been a mess for a while, and dates
back to how fmt.go used to print out typed nils. That hasn't applied
for a while, but we've kept dragging it along to appease toolstash
with the intention of someday finally removing it.

Today is that day.

Change-Id: I9a441628e53068ab1993cd2b67b977574d8117b7
Reviewed-on: https://go-review.googlesource.com/c/go/+/274212
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/gc/iexport.go |  6 +-----
 src/cmd/compile/internal/gc/iimport.go | 17 ++++++++---------
 2 files changed, 9 insertions(+), 14 deletions(-)

diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index c9f5d0c85c..f19acb8bc2 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -1201,11 +1201,7 @@ func (w *exportWriter) expr(n ir.Node) {
 		if !n.Type().HasNil() {
 			base.Fatalf("unexpected type for nil: %v", n.Type())
 		}
-		if orig := ir.Orig(n); orig != nil && orig != n {
-			w.expr(orig)
-			break
-		}
-		w.op(ir.OLITERAL)
+		w.op(ir.ONIL)
 		w.pos(n.Pos())
 		w.typ(n.Type())
 
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index c219b70e0f..57c5e62182 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -809,20 +809,19 @@ func (r *importReader) node() ir.Node {
 	// case OPAREN:
 	// 	unreachable - unpacked by exporter
 
-	// case ONIL:
-	//	unreachable - mapped to OLITERAL
+	case ir.ONIL:
+		pos := r.pos()
+		typ := r.typ()
+
+		n := npos(pos, nodnil())
+		n.SetType(typ)
+		return n
 
 	case ir.OLITERAL:
 		pos := r.pos()
 		typ := r.typ()
 
-		var n ir.Node
-		if typ.HasNil() {
-			n = nodnil()
-		} else {
-			n = ir.NewLiteral(r.value(typ))
-		}
-		n = npos(pos, n)
+		n := npos(pos, ir.NewLiteral(r.value(typ)))
 		n.SetType(typ)
 		return n
 
-- 
GitLab


From 7c9b6b1ca249c14d358075da9678cd1c20041b21 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 28 Nov 2020 15:28:18 -0500
Subject: [PATCH 0098/2400] [dev.regabi] cmd/compile: clean up in preparation
 for statement Nodes

Using statement nodes restricts the set of valid SetOp operations,
because you can't SetOp across representation. Rewrite various
code to avoid crossing those as-yet-unintroduced boundaries.

In particular, code like

        x, y := v.(T)
        x, y := f()
        x, y := m[k]
        x, y := <-c

starts out with Op = OAS2, and then it turns into a specific Op
OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV, and then
later in walk is lowered to an OAS2 again.

In the middle, the specific forms move the right-hand side from
n.Rlist().First() to n.Right(), and then the conversion to OAS2 moves
it back. This is unnecessary and makes it hard for these all to
share an underlying Node implementation.

This CL changes these specific forms to leave the right-hand side
in n.Rlist().First().

Similarly, OSELRECV2 is really just a temporary form of OAS2.
This CL changes it to use same fields too.

Finally, this CL fixes the printing of OAS2 nodes in ir/fmt.go,
which formerly printed n.Right() instead of n.Rlist().
This results in a (correct!) update to cmd/compile/internal/logopt's
expected output: ~R0 = <N> becomes ~R0 = &y.b.

Passes buildall w/ toolstash -cmp.

Change-Id: I164aa2e17dc55bfb292024de53d7d250192ad64a
Reviewed-on: https://go-review.googlesource.com/c/go/+/274105
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/escape.go         |  17 ++-
 src/cmd/compile/internal/gc/iexport.go        |   8 +-
 src/cmd/compile/internal/gc/initorder.go      |   2 +-
 src/cmd/compile/internal/gc/inl.go            |  74 +++++-----
 src/cmd/compile/internal/gc/noder.go          |  19 ++-
 src/cmd/compile/internal/gc/order.go          | 136 +++++++++---------
 src/cmd/compile/internal/gc/range.go          | 102 +++++++------
 src/cmd/compile/internal/gc/select.go         |  99 ++++++-------
 src/cmd/compile/internal/gc/ssa.go            |  10 +-
 src/cmd/compile/internal/gc/typecheck.go      |   4 -
 src/cmd/compile/internal/gc/universe.go       |   1 +
 src/cmd/compile/internal/gc/walk.go           |  19 ++-
 src/cmd/compile/internal/ir/fmt.go            |   9 +-
 src/cmd/compile/internal/ir/node.go           |   4 +-
 .../compile/internal/logopt/logopt_test.go    |   4 +-
 15 files changed, 241 insertions(+), 267 deletions(-)

diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 4cbc5d3851..f2fff02959 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -394,8 +394,8 @@ func (e *Escape) stmt(n ir.Node) {
 	case ir.OSELRECV:
 		e.assign(n.Left(), n.Right(), "selrecv", n)
 	case ir.OSELRECV2:
-		e.assign(n.Left(), n.Right(), "selrecv", n)
-		e.assign(n.List().First(), nil, "selrecv", n)
+		e.assign(n.List().First(), n.Rlist().First(), "selrecv", n)
+		e.assign(n.List().Second(), nil, "selrecv", n)
 	case ir.ORECV:
 		// TODO(mdempsky): Consider e.discard(n.Left).
 		e.exprSkipInit(e.discardHole(), n) // already visited n.Ninit
@@ -412,18 +412,18 @@ func (e *Escape) stmt(n ir.Node) {
 		}
 
 	case ir.OAS2DOTTYPE: // v, ok = x.(type)
-		e.assign(n.List().First(), n.Right(), "assign-pair-dot-type", n)
+		e.assign(n.List().First(), n.Rlist().First(), "assign-pair-dot-type", n)
 		e.assign(n.List().Second(), nil, "assign-pair-dot-type", n)
 	case ir.OAS2MAPR: // v, ok = m[k]
-		e.assign(n.List().First(), n.Right(), "assign-pair-mapr", n)
+		e.assign(n.List().First(), n.Rlist().First(), "assign-pair-mapr", n)
 		e.assign(n.List().Second(), nil, "assign-pair-mapr", n)
 	case ir.OAS2RECV: // v, ok = <-ch
-		e.assign(n.List().First(), n.Right(), "assign-pair-receive", n)
+		e.assign(n.List().First(), n.Rlist().First(), "assign-pair-receive", n)
 		e.assign(n.List().Second(), nil, "assign-pair-receive", n)
 
 	case ir.OAS2FUNC:
-		e.stmts(n.Right().Init())
-		e.call(e.addrs(n.List()), n.Right(), nil)
+		e.stmts(n.Rlist().First().Init())
+		e.call(e.addrs(n.List()), n.Rlist().First(), nil)
 	case ir.ORETURN:
 		results := e.curfn.Type().Results().FieldSlice()
 		for i, v := range n.List().Slice() {
@@ -709,8 +709,7 @@ func (e *Escape) discards(l ir.Nodes) {
 // that represents storing into the represented location.
 func (e *Escape) addr(n ir.Node) EscHole {
 	if n == nil || ir.IsBlank(n) {
-		// Can happen at least in OSELRECV.
-		// TODO(mdempsky): Anywhere else?
+		// Can happen in select case, range, maybe others.
 		return e.discardHole()
 	}
 
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index f19acb8bc2..d6c50c7285 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -1076,18 +1076,12 @@ func (w *exportWriter) stmt(n ir.Node) {
 			w.expr(n.Right())
 		}
 
-	case ir.OAS2:
+	case ir.OAS2, ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV:
 		w.op(ir.OAS2)
 		w.pos(n.Pos())
 		w.exprList(n.List())
 		w.exprList(n.Rlist())
 
-	case ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV:
-		w.op(ir.OAS2)
-		w.pos(n.Pos())
-		w.exprList(n.List())
-		w.exprList(ir.AsNodes([]ir.Node{n.Right()}))
-
 	case ir.ORETURN:
 		w.op(ir.ORETURN)
 		w.pos(n.Pos())
diff --git a/src/cmd/compile/internal/gc/initorder.go b/src/cmd/compile/internal/gc/initorder.go
index ea3d74d5ba..87a78ae053 100644
--- a/src/cmd/compile/internal/gc/initorder.go
+++ b/src/cmd/compile/internal/gc/initorder.go
@@ -256,7 +256,7 @@ func collectDeps(n ir.Node, transitive bool) ir.NodeSet {
 	case ir.OAS:
 		d.inspect(n.Right())
 	case ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV:
-		d.inspect(n.Right())
+		d.inspect(n.Rlist().First())
 	case ir.ODCLFUNC:
 		d.inspectList(n.Body())
 	default:
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index bbbffebf5c..97ecb9559b 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -520,14 +520,11 @@ func inlcalls(fn *ir.Func) {
 }
 
 // Turn an OINLCALL into a statement.
-func inlconv2stmt(n ir.Node) {
-	n.SetOp(ir.OBLOCK)
-
-	// n->ninit stays
-	n.PtrList().Set(n.Body().Slice())
-
-	n.PtrBody().Set(nil)
-	n.PtrRlist().Set(nil)
+func inlconv2stmt(inlcall ir.Node) ir.Node {
+	n := ir.NodAt(inlcall.Pos(), ir.OBLOCK, nil, nil)
+	n.SetList(inlcall.Body())
+	n.SetInit(inlcall.Init())
+	return n
 }
 
 // Turn an OINLCALL into a single valued expression.
@@ -600,9 +597,10 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool) ir.Node {
 	lno := setlineno(n)
 
 	inlnodelist(n.Init(), maxCost, inlMap)
-	for _, n1 := range n.Init().Slice() {
+	init := n.Init().Slice()
+	for i, n1 := range init {
 		if n1.Op() == ir.OINLCALL {
-			inlconv2stmt(n1)
+			init[i] = inlconv2stmt(n1)
 		}
 	}
 
@@ -614,50 +612,49 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool) ir.Node {
 	n.SetRight(inlnode(n.Right(), maxCost, inlMap))
 	if n.Right() != nil && n.Right().Op() == ir.OINLCALL {
 		if n.Op() == ir.OFOR || n.Op() == ir.OFORUNTIL {
-			inlconv2stmt(n.Right())
-		} else if n.Op() == ir.OAS2FUNC {
-			n.PtrRlist().Set(inlconv2list(n.Right()))
-			n.SetRight(nil)
-			n.SetOp(ir.OAS2)
-			n.SetTypecheck(0)
-			n = typecheck(n, ctxStmt)
+			n.SetRight(inlconv2stmt(n.Right()))
 		} else {
 			n.SetRight(inlconv2expr(n.Right()))
 		}
 	}
 
 	inlnodelist(n.List(), maxCost, inlMap)
+	s := n.List().Slice()
+	convert := inlconv2expr
 	if n.Op() == ir.OBLOCK {
-		for _, n2 := range n.List().Slice() {
-			if n2.Op() == ir.OINLCALL {
-				inlconv2stmt(n2)
-			}
-		}
-	} else {
-		s := n.List().Slice()
-		for i1, n1 := range s {
-			if n1 != nil && n1.Op() == ir.OINLCALL {
-				s[i1] = inlconv2expr(s[i1])
-			}
+		convert = inlconv2stmt
+	}
+	for i, n1 := range s {
+		if n1 != nil && n1.Op() == ir.OINLCALL {
+			s[i] = convert(n1)
 		}
 	}
 
 	inlnodelist(n.Rlist(), maxCost, inlMap)
-	s := n.Rlist().Slice()
-	for i1, n1 := range s {
+
+	if n.Op() == ir.OAS2FUNC && n.Rlist().First().Op() == ir.OINLCALL {
+		n.PtrRlist().Set(inlconv2list(n.Rlist().First()))
+		n.SetOp(ir.OAS2)
+		n.SetTypecheck(0)
+		n = typecheck(n, ctxStmt)
+	}
+
+	s = n.Rlist().Slice()
+	for i, n1 := range s {
 		if n1.Op() == ir.OINLCALL {
 			if n.Op() == ir.OIF {
-				inlconv2stmt(n1)
+				s[i] = inlconv2stmt(n1)
 			} else {
-				s[i1] = inlconv2expr(s[i1])
+				s[i] = inlconv2expr(n1)
 			}
 		}
 	}
 
 	inlnodelist(n.Body(), maxCost, inlMap)
-	for _, n := range n.Body().Slice() {
-		if n.Op() == ir.OINLCALL {
-			inlconv2stmt(n)
+	s = n.Body().Slice()
+	for i, n1 := range s {
+		if n1.Op() == ir.OINLCALL {
+			s[i] = inlconv2stmt(n1)
 		}
 	}
 
@@ -1200,9 +1197,10 @@ func mkinlcall(n ir.Node, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]bool)
 	// and each use must redo the inlining.
 	// luckily these are small.
 	inlnodelist(call.Body(), maxCost, inlMap)
-	for _, n := range call.Body().Slice() {
-		if n.Op() == ir.OINLCALL {
-			inlconv2stmt(n)
+	s := call.Body().Slice()
+	for i, n1 := range s {
+		if n1.Op() == ir.OINLCALL {
+			s[i] = inlconv2stmt(n1)
 		}
 	}
 
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index e6c78d1afb..98a09f4006 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -1001,20 +1001,17 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) ir.Node {
 			return n
 		}
 
-		n := p.nod(stmt, ir.OAS, nil, nil) // assume common case
-
 		rhs := p.exprList(stmt.Rhs)
-		lhs := p.assignList(stmt.Lhs, n, stmt.Op == syntax.Def)
-
-		if len(lhs) == 1 && len(rhs) == 1 {
-			// common case
-			n.SetLeft(lhs[0])
-			n.SetRight(rhs[0])
-		} else {
-			n.SetOp(ir.OAS2)
-			n.PtrList().Set(lhs)
+		if list, ok := stmt.Lhs.(*syntax.ListExpr); ok && len(list.ElemList) != 1 || len(rhs) != 1 {
+			n := p.nod(stmt, ir.OAS2, nil, nil)
+			n.PtrList().Set(p.assignList(stmt.Lhs, n, stmt.Op == syntax.Def))
 			n.PtrRlist().Set(rhs)
+			return n
 		}
+
+		n := p.nod(stmt, ir.OAS, nil, nil)
+		n.SetLeft(p.assignList(stmt.Lhs, n, stmt.Op == syntax.Def)[0])
+		n.SetRight(rhs[0])
 		return n
 
 	case *syntax.BranchStmt:
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index d4db7be911..66e279d85f 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -103,7 +103,11 @@ func (o *Order) newTemp(t *types.Type, clear bool) ir.Node {
 // (The other candidate would be map access, but map access
 // returns a pointer to the result data instead of taking a pointer
 // to be filled in.)
+// TODO(rsc): t == n.Type() always; remove parameter.
 func (o *Order) copyExpr(n ir.Node, t *types.Type, clear bool) ir.Node {
+	if t != n.Type() {
+		panic("copyExpr")
+	}
 	v := o.newTemp(t, clear)
 	a := ir.Nod(ir.OAS, v, n)
 	a = typecheck(a, ctxStmt)
@@ -606,23 +610,19 @@ func (o *Order) stmt(n ir.Node) {
 			// that we can ensure that if op panics
 			// because r is zero, the panic happens before
 			// the map assignment.
-
-			n.SetLeft(o.safeExpr(n.Left()))
-
-			// TODO(rsc): Why is this DeepCopy?
-			// We should know enough about the form here
-			// to do something more provably shallower.
-			l := ir.DeepCopy(src.NoXPos, n.Left())
-			if l.Op() == ir.OINDEXMAP {
-				l.SetIndexMapLValue(false)
+			// DeepCopy is a big hammer here, but safeExpr
+			// makes sure there is nothing too deep being copied.
+			l1 := o.safeExpr(n.Left())
+			l2 := ir.DeepCopy(src.NoXPos, l1)
+			if l1.Op() == ir.OINDEXMAP {
+				l2.SetIndexMapLValue(false)
 			}
-			l = o.copyExpr(l, n.Left().Type(), false)
-			n.SetRight(ir.Nod(n.SubOp(), l, n.Right()))
-			n.SetRight(typecheck(n.Right(), ctxExpr))
-			n.SetRight(o.expr(n.Right(), nil))
-
-			n.SetOp(ir.OAS)
-			n.ResetAux()
+			l2 = o.copyExpr(l2, l2.Type(), false)
+			r := ir.NodAt(n.Pos(), n.SubOp(), l2, n.Right())
+			r = typecheck(r, ctxExpr)
+			r = o.expr(r, nil)
+			n = ir.NodAt(n.Pos(), ir.OAS, l1, r)
+			n = typecheck(n, ctxStmt)
 		}
 
 		o.mapAssign(n)
@@ -639,8 +639,8 @@ func (o *Order) stmt(n ir.Node) {
 	case ir.OAS2FUNC:
 		t := o.markTemp()
 		o.exprList(n.List())
-		o.init(n.Right())
-		o.call(n.Right())
+		o.init(n.Rlist().First())
+		o.call(n.Rlist().First())
 		o.as2(n)
 		o.cleanTemp(t)
 
@@ -654,7 +654,7 @@ func (o *Order) stmt(n ir.Node) {
 		t := o.markTemp()
 		o.exprList(n.List())
 
-		switch r := n.Right(); r.Op() {
+		switch r := n.Rlist().First(); r.Op() {
 		case ir.ODOTTYPE2, ir.ORECV:
 			r.SetLeft(o.expr(r.Left(), nil))
 		case ir.OINDEXMAP:
@@ -866,38 +866,39 @@ func (o *Order) stmt(n ir.Node) {
 				ir.Dump("select case", r)
 				base.Fatalf("unknown op in select %v", r.Op())
 
-			// If this is case x := <-ch or case x, y := <-ch, the case has
-			// the ODCL nodes to declare x and y. We want to delay that
-			// declaration (and possible allocation) until inside the case body.
-			// Delete the ODCL nodes here and recreate them inside the body below.
 			case ir.OSELRECV, ir.OSELRECV2:
+				var dst, ok, recv ir.Node
+				if r.Op() == ir.OSELRECV {
+					// case x = <-c
+					// case <-c (dst is ir.BlankNode)
+					dst, ok, recv = r.Left(), ir.BlankNode, r.Right()
+				} else {
+					// case x, ok = <-c
+					dst, ok, recv = r.List().First(), r.List().Second(), r.Rlist().First()
+				}
+
+				// If this is case x := <-ch or case x, y := <-ch, the case has
+				// the ODCL nodes to declare x and y. We want to delay that
+				// declaration (and possible allocation) until inside the case body.
+				// Delete the ODCL nodes here and recreate them inside the body below.
 				if r.Colas() {
-					i := 0
-					if r.Init().Len() != 0 && r.Init().First().Op() == ir.ODCL && r.Init().First().Left() == r.Left() {
-						i++
-					}
-					if i < r.Init().Len() && r.Init().Index(i).Op() == ir.ODCL && r.List().Len() != 0 && r.Init().Index(i).Left() == r.List().First() {
-						i++
+					init := r.Init().Slice()
+					if len(init) > 0 && init[0].Op() == ir.ODCL && init[0].Left() == dst {
+						init = init[1:]
 					}
-					if i >= r.Init().Len() {
-						r.PtrInit().Set(nil)
+					if len(init) > 0 && init[0].Op() == ir.ODCL && init[0].Left() == ok {
+						init = init[1:]
 					}
+					r.PtrInit().Set(init)
 				}
-
 				if r.Init().Len() != 0 {
 					ir.DumpList("ninit", r.Init())
 					base.Fatalf("ninit on select recv")
 				}
 
-				// case x = <-c
-				// case x, ok = <-c
-				// r->left is x, r->ntest is ok, r->right is ORECV, r->right->left is c.
-				// r->left == N means 'case <-c'.
-				// c is always evaluated; x and ok are only evaluated when assigned.
-				r.Right().SetLeft(o.expr(r.Right().Left(), nil))
-
-				if r.Right().Left().Op() != ir.ONAME {
-					r.Right().SetLeft(o.copyExpr(r.Right().Left(), r.Right().Left().Type(), false))
+				recv.SetLeft(o.expr(recv.Left(), nil))
+				if recv.Left().Op() != ir.ONAME {
+					recv.SetLeft(o.copyExpr(recv.Left(), recv.Left().Type(), false))
 				}
 
 				// Introduce temporary for receive and move actual copy into case body.
@@ -906,42 +907,41 @@ func (o *Order) stmt(n ir.Node) {
 				// temporary per distinct type, sharing the temp among all receives
 				// with that temp. Similarly one ok bool could be shared among all
 				// the x,ok receives. Not worth doing until there's a clear need.
-				if r.Left() != nil && ir.IsBlank(r.Left()) {
-					r.SetLeft(nil)
-				}
-				if r.Left() != nil {
+				if !ir.IsBlank(dst) {
 					// use channel element type for temporary to avoid conversions,
 					// such as in case interfacevalue = <-intchan.
 					// the conversion happens in the OAS instead.
-					tmp1 := r.Left()
-
 					if r.Colas() {
-						tmp2 := ir.Nod(ir.ODCL, tmp1, nil)
-						tmp2 = typecheck(tmp2, ctxStmt)
-						n2.PtrInit().Append(tmp2)
+						dcl := ir.Nod(ir.ODCL, dst, nil)
+						dcl = typecheck(dcl, ctxStmt)
+						n2.PtrInit().Append(dcl)
 					}
 
-					r.SetLeft(o.newTemp(r.Right().Left().Type().Elem(), r.Right().Left().Type().Elem().HasPointers()))
-					tmp2 := ir.Nod(ir.OAS, tmp1, r.Left())
-					tmp2 = typecheck(tmp2, ctxStmt)
-					n2.PtrInit().Append(tmp2)
+					tmp := o.newTemp(recv.Left().Type().Elem(), recv.Left().Type().Elem().HasPointers())
+					as := ir.Nod(ir.OAS, dst, tmp)
+					as = typecheck(as, ctxStmt)
+					n2.PtrInit().Append(as)
+					dst = tmp
 				}
-
-				if r.List().Len() != 0 && ir.IsBlank(r.List().First()) {
-					r.PtrList().Set(nil)
-				}
-				if r.List().Len() != 0 {
-					tmp1 := r.List().First()
+				if !ir.IsBlank(ok) {
 					if r.Colas() {
-						tmp2 := ir.Nod(ir.ODCL, tmp1, nil)
-						tmp2 = typecheck(tmp2, ctxStmt)
-						n2.PtrInit().Append(tmp2)
+						dcl := ir.Nod(ir.ODCL, ok, nil)
+						dcl = typecheck(dcl, ctxStmt)
+						n2.PtrInit().Append(dcl)
 					}
 
-					r.PtrList().Set1(o.newTemp(types.Types[types.TBOOL], false))
-					tmp2 := okas(tmp1, r.List().First())
-					tmp2 = typecheck(tmp2, ctxStmt)
-					n2.PtrInit().Append(tmp2)
+					tmp := o.newTemp(types.Types[types.TBOOL], false)
+					as := okas(ok, tmp)
+					as = typecheck(as, ctxStmt)
+					n2.PtrInit().Append(as)
+					ok = tmp
+				}
+
+				if r.Op() == ir.OSELRECV {
+					r.SetLeft(dst)
+				} else {
+					r.List().SetIndex(0, dst)
+					r.List().SetIndex(1, ok)
 				}
 				orderBlock(n2.PtrInit(), o.free)
 
@@ -1420,7 +1420,7 @@ func (o *Order) as2(n ir.Node) {
 func (o *Order) okAs2(n ir.Node) {
 	var tmp1, tmp2 ir.Node
 	if !ir.IsBlank(n.List().First()) {
-		typ := n.Right().Type()
+		typ := n.Rlist().First().Type()
 		tmp1 = o.newTemp(typ, typ.HasPointers())
 	}
 
diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index d52fad5fec..2f2d7051c3 100644
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -157,15 +157,19 @@ func cheapComputableIndex(width int64) bool {
 // simpler forms.  The result must be assigned back to n.
 // Node n may also be modified in place, and may also be
 // the returned node.
-func walkrange(n ir.Node) ir.Node {
-	if isMapClear(n) {
-		m := n.Right()
+func walkrange(nrange ir.Node) ir.Node {
+	if isMapClear(nrange) {
+		m := nrange.Right()
 		lno := setlineno(m)
-		n = mapClear(m)
+		n := mapClear(m)
 		base.Pos = lno
 		return n
 	}
 
+	nfor := ir.NodAt(nrange.Pos(), ir.OFOR, nil, nil)
+	nfor.SetInit(nrange.Init())
+	nfor.SetSym(nrange.Sym())
+
 	// variable name conventions:
 	//	ohv1, hv1, hv2: hidden (old) val 1, 2
 	//	ha, hit: hidden aggregate, iterator
@@ -173,20 +177,19 @@ func walkrange(n ir.Node) ir.Node {
 	//	hb: hidden bool
 	//	a, v1, v2: not hidden aggregate, val 1, 2
 
-	t := n.Type()
+	t := nrange.Type()
 
-	a := n.Right()
+	a := nrange.Right()
 	lno := setlineno(a)
-	n.SetRight(nil)
 
 	var v1, v2 ir.Node
-	l := n.List().Len()
+	l := nrange.List().Len()
 	if l > 0 {
-		v1 = n.List().First()
+		v1 = nrange.List().First()
 	}
 
 	if l > 1 {
-		v2 = n.List().Second()
+		v2 = nrange.List().Second()
 	}
 
 	if ir.IsBlank(v2) {
@@ -201,14 +204,8 @@ func walkrange(n ir.Node) ir.Node {
 		base.Fatalf("walkrange: v2 != nil while v1 == nil")
 	}
 
-	// n.List has no meaning anymore, clear it
-	// to avoid erroneous processing by racewalk.
-	n.PtrList().Set(nil)
-
 	var ifGuard ir.Node
 
-	translatedLoopOp := ir.OFOR
-
 	var body []ir.Node
 	var init []ir.Node
 	switch t.Etype {
@@ -216,9 +213,9 @@ func walkrange(n ir.Node) ir.Node {
 		base.Fatalf("walkrange")
 
 	case types.TARRAY, types.TSLICE:
-		if arrayClear(n, v1, v2, a) {
+		if nn := arrayClear(nrange, v1, v2, a); nn != nil {
 			base.Pos = lno
-			return n
+			return nn
 		}
 
 		// order.stmt arranged for a copy of the array/slice variable if needed.
@@ -230,8 +227,8 @@ func walkrange(n ir.Node) ir.Node {
 		init = append(init, ir.Nod(ir.OAS, hv1, nil))
 		init = append(init, ir.Nod(ir.OAS, hn, ir.Nod(ir.OLEN, ha, nil)))
 
-		n.SetLeft(ir.Nod(ir.OLT, hv1, hn))
-		n.SetRight(ir.Nod(ir.OAS, hv1, ir.Nod(ir.OADD, hv1, nodintconst(1))))
+		nfor.SetLeft(ir.Nod(ir.OLT, hv1, hn))
+		nfor.SetRight(ir.Nod(ir.OAS, hv1, ir.Nod(ir.OADD, hv1, nodintconst(1))))
 
 		// for range ha { body }
 		if v1 == nil {
@@ -245,7 +242,7 @@ func walkrange(n ir.Node) ir.Node {
 		}
 
 		// for v1, v2 := range ha { body }
-		if cheapComputableIndex(n.Type().Elem().Width) {
+		if cheapComputableIndex(nrange.Type().Elem().Width) {
 			// v1, v2 = hv1, ha[hv1]
 			tmp := ir.Nod(ir.OINDEX, ha, hv1)
 			tmp.SetBounded(true)
@@ -272,9 +269,9 @@ func walkrange(n ir.Node) ir.Node {
 		// Enhance the prove pass to understand this.
 		ifGuard = ir.Nod(ir.OIF, nil, nil)
 		ifGuard.SetLeft(ir.Nod(ir.OLT, hv1, hn))
-		translatedLoopOp = ir.OFORUNTIL
+		nfor.SetOp(ir.OFORUNTIL)
 
-		hp := temp(types.NewPtr(n.Type().Elem()))
+		hp := temp(types.NewPtr(nrange.Type().Elem()))
 		tmp := ir.Nod(ir.OINDEX, ha, nodintconst(0))
 		tmp.SetBounded(true)
 		init = append(init, ir.Nod(ir.OAS, hp, ir.Nod(ir.OADDR, tmp, nil)))
@@ -293,16 +290,15 @@ func walkrange(n ir.Node) ir.Node {
 		// end of the allocation.
 		a = ir.Nod(ir.OAS, hp, addptr(hp, t.Elem().Width))
 		a = typecheck(a, ctxStmt)
-		n.PtrList().Set1(a)
+		nfor.PtrList().Set1(a)
 
 	case types.TMAP:
 		// order.stmt allocated the iterator for us.
 		// we only use a once, so no copy needed.
 		ha := a
 
-		hit := prealloc[n]
+		hit := prealloc[nrange]
 		th := hit.Type()
-		n.SetLeft(nil)
 		keysym := th.Field(0).Sym  // depends on layout of iterator struct.  See reflect.go:hiter
 		elemsym := th.Field(1).Sym // ditto
 
@@ -310,11 +306,11 @@ func walkrange(n ir.Node) ir.Node {
 
 		fn = substArgTypes(fn, t.Key(), t.Elem(), th)
 		init = append(init, mkcall1(fn, nil, nil, typename(t), ha, ir.Nod(ir.OADDR, hit, nil)))
-		n.SetLeft(ir.Nod(ir.ONE, nodSym(ir.ODOT, hit, keysym), nodnil()))
+		nfor.SetLeft(ir.Nod(ir.ONE, nodSym(ir.ODOT, hit, keysym), nodnil()))
 
 		fn = syslook("mapiternext")
 		fn = substArgTypes(fn, th)
-		n.SetRight(mkcall1(fn, nil, nil, ir.Nod(ir.OADDR, hit, nil)))
+		nfor.SetRight(mkcall1(fn, nil, nil, ir.Nod(ir.OADDR, hit, nil)))
 
 		key := nodSym(ir.ODOT, hit, keysym)
 		key = ir.Nod(ir.ODEREF, key, nil)
@@ -335,8 +331,6 @@ func walkrange(n ir.Node) ir.Node {
 		// order.stmt arranged for a copy of the channel variable.
 		ha := a
 
-		n.SetLeft(nil)
-
 		hv1 := temp(t.Elem())
 		hv1.SetTypecheck(1)
 		if t.Elem().HasPointers() {
@@ -344,12 +338,12 @@ func walkrange(n ir.Node) ir.Node {
 		}
 		hb := temp(types.Types[types.TBOOL])
 
-		n.SetLeft(ir.Nod(ir.ONE, hb, nodbool(false)))
+		nfor.SetLeft(ir.Nod(ir.ONE, hb, nodbool(false)))
 		a := ir.Nod(ir.OAS2RECV, nil, nil)
 		a.SetTypecheck(1)
 		a.PtrList().Set2(hv1, hb)
-		a.SetRight(ir.Nod(ir.ORECV, ha, nil))
-		n.Left().PtrInit().Set1(a)
+		a.PtrRlist().Set1(ir.Nod(ir.ORECV, ha, nil))
+		nfor.Left().PtrInit().Set1(a)
 		if v1 == nil {
 			body = nil
 		} else {
@@ -387,7 +381,7 @@ func walkrange(n ir.Node) ir.Node {
 		init = append(init, ir.Nod(ir.OAS, hv1, nil))
 
 		// hv1 < len(ha)
-		n.SetLeft(ir.Nod(ir.OLT, hv1, ir.Nod(ir.OLEN, ha, nil)))
+		nfor.SetLeft(ir.Nod(ir.OLT, hv1, ir.Nod(ir.OLEN, ha, nil)))
 
 		if v1 != nil {
 			// hv1t = hv1
@@ -431,24 +425,25 @@ func walkrange(n ir.Node) ir.Node {
 		}
 	}
 
-	n.SetOp(translatedLoopOp)
 	typecheckslice(init, ctxStmt)
 
 	if ifGuard != nil {
 		ifGuard.PtrInit().Append(init...)
 		ifGuard = typecheck(ifGuard, ctxStmt)
 	} else {
-		n.PtrInit().Append(init...)
+		nfor.PtrInit().Append(init...)
 	}
 
-	typecheckslice(n.Left().Init().Slice(), ctxStmt)
+	typecheckslice(nfor.Left().Init().Slice(), ctxStmt)
 
-	n.SetLeft(typecheck(n.Left(), ctxExpr))
-	n.SetLeft(defaultlit(n.Left(), nil))
-	n.SetRight(typecheck(n.Right(), ctxStmt))
+	nfor.SetLeft(typecheck(nfor.Left(), ctxExpr))
+	nfor.SetLeft(defaultlit(nfor.Left(), nil))
+	nfor.SetRight(typecheck(nfor.Right(), ctxStmt))
 	typecheckslice(body, ctxStmt)
-	n.PtrBody().Prepend(body...)
+	nfor.PtrBody().Append(body...)
+	nfor.PtrBody().Append(nrange.Body().Slice()...)
 
+	var n ir.Node = nfor
 	if ifGuard != nil {
 		ifGuard.PtrBody().Set1(n)
 		n = ifGuard
@@ -534,31 +529,31 @@ func mapClear(m ir.Node) ir.Node {
 // in which the evaluation of a is side-effect-free.
 //
 // Parameters are as in walkrange: "for v1, v2 = range a".
-func arrayClear(n, v1, v2, a ir.Node) bool {
+func arrayClear(loop, v1, v2, a ir.Node) ir.Node {
 	if base.Flag.N != 0 || instrumenting {
-		return false
+		return nil
 	}
 
 	if v1 == nil || v2 != nil {
-		return false
+		return nil
 	}
 
-	if n.Body().Len() != 1 || n.Body().First() == nil {
-		return false
+	if loop.Body().Len() != 1 || loop.Body().First() == nil {
+		return nil
 	}
 
-	stmt := n.Body().First() // only stmt in body
+	stmt := loop.Body().First() // only stmt in body
 	if stmt.Op() != ir.OAS || stmt.Left().Op() != ir.OINDEX {
-		return false
+		return nil
 	}
 
 	if !samesafeexpr(stmt.Left().Left(), a) || !samesafeexpr(stmt.Left().Right(), v1) {
-		return false
+		return nil
 	}
 
-	elemsize := n.Type().Elem().Width
+	elemsize := loop.Type().Elem().Width
 	if elemsize <= 0 || !isZero(stmt.Right()) {
-		return false
+		return nil
 	}
 
 	// Convert to
@@ -568,8 +563,7 @@ func arrayClear(n, v1, v2, a ir.Node) bool {
 	// 	memclr{NoHeap,Has}Pointers(hp, hn)
 	// 	i = len(a) - 1
 	// }
-	n.SetOp(ir.OIF)
-
+	n := ir.Nod(ir.OIF, nil, nil)
 	n.PtrBody().Set(nil)
 	n.SetLeft(ir.Nod(ir.ONE, ir.Nod(ir.OLEN, a, nil), nodintconst(0)))
 
@@ -611,7 +605,7 @@ func arrayClear(n, v1, v2, a ir.Node) bool {
 	n.SetLeft(defaultlit(n.Left(), nil))
 	typecheckslice(n.Body().Slice(), ctxStmt)
 	n = walkstmt(n)
-	return true
+	return n
 }
 
 // addptr returns (*T)(uintptr(p) + n).
diff --git a/src/cmd/compile/internal/gc/select.go b/src/cmd/compile/internal/gc/select.go
index 9668df082a..3afcef69f8 100644
--- a/src/cmd/compile/internal/gc/select.go
+++ b/src/cmd/compile/internal/gc/select.go
@@ -47,36 +47,30 @@ func typecheckselect(sel ir.Node) {
 				}
 				base.ErrorfAt(pos, "select case must be receive, send or assign recv")
 
-			// convert x = <-c into OSELRECV(x, <-c).
-			// remove implicit conversions; the eventual assignment
-			// will reintroduce them.
 			case ir.OAS:
+				// convert x = <-c into OSELRECV(x, <-c).
+				// remove implicit conversions; the eventual assignment
+				// will reintroduce them.
 				if (n.Right().Op() == ir.OCONVNOP || n.Right().Op() == ir.OCONVIFACE) && n.Right().Implicit() {
 					n.SetRight(n.Right().Left())
 				}
-
 				if n.Right().Op() != ir.ORECV {
 					base.ErrorfAt(n.Pos(), "select assignment must have receive on right hand side")
 					break
 				}
-
 				n.SetOp(ir.OSELRECV)
 
-				// convert x, ok = <-c into OSELRECV2(x, <-c) with ntest=ok
 			case ir.OAS2RECV:
-				if n.Right().Op() != ir.ORECV {
+				// convert x, ok = <-c into OSELRECV2(x, <-c) with ntest=ok
+				if n.Rlist().First().Op() != ir.ORECV {
 					base.ErrorfAt(n.Pos(), "select assignment must have receive on right hand side")
 					break
 				}
-
 				n.SetOp(ir.OSELRECV2)
-				n.SetLeft(n.List().First())
-				n.PtrList().Set1(n.List().Second())
 
-				// convert <-c into OSELRECV(N, <-c)
 			case ir.ORECV:
-				n = ir.NodAt(n.Pos(), ir.OSELRECV, nil, n)
-
+				// convert <-c into OSELRECV(_, <-c)
+				n = ir.NodAt(n.Pos(), ir.OSELRECV, ir.BlankNode, n)
 				n.SetTypecheck(1)
 				ncase.SetLeft(n)
 
@@ -134,28 +128,19 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 			case ir.OSEND:
 				// already ok
 
-			case ir.OSELRECV, ir.OSELRECV2:
-				if n.Op() == ir.OSELRECV || n.List().Len() == 0 {
-					if n.Left() == nil {
-						n = n.Right()
-					} else {
-						n.SetOp(ir.OAS)
-					}
+			case ir.OSELRECV:
+				if ir.IsBlank(n.Left()) {
+					n = n.Right()
 					break
 				}
+				n.SetOp(ir.OAS)
 
-				if n.Left() == nil {
-					ir.BlankNode = typecheck(ir.BlankNode, ctxExpr|ctxAssign)
-					n.SetLeft(ir.BlankNode)
+			case ir.OSELRECV2:
+				if ir.IsBlank(n.List().First()) && ir.IsBlank(n.List().Second()) {
+					n = n.Rlist().First()
+					break
 				}
-
-				n.SetOp(ir.OAS2)
-				n.PtrList().Prepend(n.Left())
-				n.PtrRlist().Set1(n.Right())
-				n.SetRight(nil)
-				n.SetLeft(nil)
-				n.SetTypecheck(0)
-				n = typecheck(n, ctxStmt)
+				n.SetOp(ir.OAS2RECV)
 			}
 
 			l = append(l, n)
@@ -176,20 +161,30 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 			dflt = cas
 			continue
 		}
+
+		// Lower x, _ = <-c to x = <-c.
+		if n.Op() == ir.OSELRECV2 && ir.IsBlank(n.List().Second()) {
+			n = ir.NodAt(n.Pos(), ir.OSELRECV, n.List().First(), n.Rlist().First())
+			n.SetTypecheck(1)
+			cas.SetLeft(n)
+		}
+
 		switch n.Op() {
 		case ir.OSEND:
 			n.SetRight(ir.Nod(ir.OADDR, n.Right(), nil))
 			n.SetRight(typecheck(n.Right(), ctxExpr))
 
-		case ir.OSELRECV, ir.OSELRECV2:
-			if n.Op() == ir.OSELRECV2 && n.List().Len() == 0 {
-				n.SetOp(ir.OSELRECV)
-			}
-
-			if n.Left() != nil {
+		case ir.OSELRECV:
+			if !ir.IsBlank(n.Left()) {
 				n.SetLeft(ir.Nod(ir.OADDR, n.Left(), nil))
 				n.SetLeft(typecheck(n.Left(), ctxExpr))
 			}
+
+		case ir.OSELRECV2:
+			if !ir.IsBlank(n.List().First()) {
+				n.List().SetIndex(0, ir.Nod(ir.OADDR, n.List().First(), nil))
+				n.List().SetIndex(0, typecheck(n.List().First(), ctxExpr))
+			}
 		}
 	}
 
@@ -204,6 +199,7 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 		setlineno(n)
 		r := ir.Nod(ir.OIF, nil, nil)
 		r.PtrInit().Set(cas.Init().Slice())
+		var call ir.Node
 		switch n.Op() {
 		default:
 			base.Fatalf("select %v", n.Op())
@@ -211,30 +207,30 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 		case ir.OSEND:
 			// if selectnbsend(c, v) { body } else { default body }
 			ch := n.Left()
-			r.SetLeft(mkcall1(chanfn("selectnbsend", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), ch, n.Right()))
+			call = mkcall1(chanfn("selectnbsend", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), ch, n.Right())
 
 		case ir.OSELRECV:
 			// if selectnbrecv(&v, c) { body } else { default body }
 			ch := n.Right().Left()
 			elem := n.Left()
-			if elem == nil {
+			if ir.IsBlank(elem) {
 				elem = nodnil()
 			}
-			r.SetLeft(mkcall1(chanfn("selectnbrecv", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), elem, ch))
+			call = mkcall1(chanfn("selectnbrecv", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), elem, ch)
 
 		case ir.OSELRECV2:
 			// if selectnbrecv2(&v, &received, c) { body } else { default body }
-			ch := n.Right().Left()
-			elem := n.Left()
-			if elem == nil {
+			ch := n.Rlist().First().Left()
+			elem := n.List().First()
+			if ir.IsBlank(elem) {
 				elem = nodnil()
 			}
-			receivedp := ir.Nod(ir.OADDR, n.List().First(), nil)
+			receivedp := ir.Nod(ir.OADDR, n.List().Second(), nil)
 			receivedp = typecheck(receivedp, ctxExpr)
-			r.SetLeft(mkcall1(chanfn("selectnbrecv2", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), elem, receivedp, ch))
+			call = mkcall1(chanfn("selectnbrecv2", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), elem, receivedp, ch)
 		}
 
-		r.SetLeft(typecheck(r.Left(), ctxExpr))
+		r.SetLeft(typecheck(call, ctxExpr))
 		r.PtrBody().Set(cas.Body().Slice())
 		r.PtrRlist().Set(append(dflt.Init().Slice(), dflt.Body().Slice()...))
 		return []ir.Node{r, ir.Nod(ir.OBREAK, nil, nil)}
@@ -288,11 +284,16 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 			nsends++
 			c = n.Left()
 			elem = n.Right()
-		case ir.OSELRECV, ir.OSELRECV2:
+		case ir.OSELRECV:
 			nrecvs++
 			i = ncas - nrecvs
 			c = n.Right().Left()
 			elem = n.Left()
+		case ir.OSELRECV2:
+			nrecvs++
+			i = ncas - nrecvs
+			c = n.Rlist().First().Left()
+			elem = n.List().First()
 		}
 
 		casorder[i] = cas
@@ -305,7 +306,7 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 
 		c = convnop(c, types.Types[types.TUNSAFEPTR])
 		setField("c", c)
-		if elem != nil {
+		if !ir.IsBlank(elem) {
 			elem = convnop(elem, types.Types[types.TUNSAFEPTR])
 			setField("elem", elem)
 		}
@@ -347,7 +348,7 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 		r := ir.Nod(ir.OIF, cond, nil)
 
 		if n := cas.Left(); n != nil && n.Op() == ir.OSELRECV2 {
-			x := ir.Nod(ir.OAS, n.List().First(), recvOK)
+			x := ir.Nod(ir.OAS, n.List().Second(), recvOK)
 			x = typecheck(x, ctxStmt)
 			r.PtrBody().Append(x)
 		}
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 6d818be132..4be6caa0e3 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -1120,9 +1120,9 @@ func (s *state) stmt(n ir.Node) {
 		s.callResult(n.Left(), callGo)
 
 	case ir.OAS2DOTTYPE:
-		res, resok := s.dottype(n.Right(), true)
+		res, resok := s.dottype(n.Rlist().First(), true)
 		deref := false
-		if !canSSAType(n.Right().Type()) {
+		if !canSSAType(n.Rlist().First().Type()) {
 			if res.Op != ssa.OpLoad {
 				s.Fatalf("dottype of non-load")
 			}
@@ -1142,10 +1142,10 @@ func (s *state) stmt(n ir.Node) {
 
 	case ir.OAS2FUNC:
 		// We come here only when it is an intrinsic call returning two values.
-		if !isIntrinsicCall(n.Right()) {
-			s.Fatalf("non-intrinsic AS2FUNC not expanded %v", n.Right())
+		if !isIntrinsicCall(n.Rlist().First()) {
+			s.Fatalf("non-intrinsic AS2FUNC not expanded %v", n.Rlist().First())
 		}
-		v := s.intrinsicCall(n.Right())
+		v := s.intrinsicCall(n.Rlist().First())
 		v1 := s.newValue1(ssa.OpSelect0, n.List().First().Type(), v)
 		v2 := s.newValue1(ssa.OpSelect1, n.List().Second().Type(), v)
 		s.assign(n.List().First(), v1, false, 0)
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 19146e2a9e..b5ace76552 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -3330,8 +3330,6 @@ func typecheckas2(n ir.Node) {
 				goto mismatch
 			}
 			n.SetOp(ir.OAS2FUNC)
-			n.SetRight(r)
-			n.PtrRlist().Set(nil)
 			for i, l := range n.List().Slice() {
 				f := r.Type().Field(i)
 				if f.Type != nil && l.Type() != nil {
@@ -3361,8 +3359,6 @@ func typecheckas2(n ir.Node) {
 				n.SetOp(ir.OAS2DOTTYPE)
 				r.SetOp(ir.ODOTTYPE2)
 			}
-			n.SetRight(r)
-			n.PtrRlist().Set(nil)
 			if l.Type() != nil {
 				checkassignto(r.Type(), l)
 			}
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index d43545391c..c3c2c0492a 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -144,6 +144,7 @@ func lexinit() {
 	types.Types[types.TBLANK] = types.New(types.TBLANK)
 	ir.AsNode(s.Def).SetType(types.Types[types.TBLANK])
 	ir.BlankNode = ir.AsNode(s.Def)
+	ir.BlankNode.SetTypecheck(1)
 
 	s = ir.BuiltinPkg.Lookup("_")
 	s.Block = -100
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index e7c88bd329..0a77cfbb38 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -604,11 +604,8 @@ opswitch:
 
 		if n.Op() == ir.OASOP {
 			// Rewrite x op= y into x = x op y.
-			n.SetRight(ir.Nod(n.SubOp(), n.Left(), n.Right()))
-			n.SetRight(typecheck(n.Right(), ctxExpr))
-
-			n.SetOp(ir.OAS)
-			n.ResetAux()
+			n = ir.Nod(ir.OAS, n.Left(),
+				typecheck(ir.Nod(n.SubOp(), n.Left(), n.Right()), ctxExpr))
 		}
 
 		if oaslit(n, init) {
@@ -683,12 +680,12 @@ opswitch:
 	case ir.OAS2FUNC:
 		init.AppendNodes(n.PtrInit())
 
-		r := n.Right()
+		r := n.Rlist().First()
 		walkexprlistsafe(n.List().Slice(), init)
 		r = walkexpr(r, init)
 
 		if isIntrinsicCall(r) {
-			n.SetRight(r)
+			n.PtrRlist().Set1(r)
 			break
 		}
 		init.Append(r)
@@ -701,7 +698,7 @@ opswitch:
 	case ir.OAS2RECV:
 		init.AppendNodes(n.PtrInit())
 
-		r := n.Right()
+		r := n.Rlist().First()
 		walkexprlistsafe(n.List().Slice(), init)
 		r.SetLeft(walkexpr(r.Left(), init))
 		var n1 ir.Node
@@ -720,7 +717,7 @@ opswitch:
 	case ir.OAS2MAPR:
 		init.AppendNodes(n.PtrInit())
 
-		r := n.Right()
+		r := n.Rlist().First()
 		walkexprlistsafe(n.List().Slice(), init)
 		r.SetLeft(walkexpr(r.Left(), init))
 		r.SetRight(walkexpr(r.Right(), init))
@@ -759,7 +756,7 @@ opswitch:
 		if ok := n.List().Second(); !ir.IsBlank(ok) && ok.Type().IsBoolean() {
 			r.Type().Field(1).Type = ok.Type()
 		}
-		n.SetRight(r)
+		n.PtrRlist().Set1(r)
 		n.SetOp(ir.OAS2FUNC)
 
 		// don't generate a = *var if a is _
@@ -793,7 +790,7 @@ opswitch:
 
 	case ir.OAS2DOTTYPE:
 		walkexprlistsafe(n.List().Slice(), init)
-		n.SetRight(walkexpr(n.Right(), init))
+		n.PtrRlist().SetIndex(0, walkexpr(n.Rlist().First(), init))
 
 	case ir.OCONVIFACE:
 		n.SetLeft(walkexpr(n.Left(), init))
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index c723bad4c9..4a08cca359 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -939,15 +939,12 @@ func stmtFmt(n Node, s fmt.State, mode FmtMode) {
 
 		mode.Fprintf(s, "%v %#v= %v", n.Left(), n.SubOp(), n.Right())
 
-	case OAS2:
+	case OAS2, OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV:
 		if n.Colas() && !complexinit {
 			mode.Fprintf(s, "%.v := %.v", n.List(), n.Rlist())
-			break
+		} else {
+			mode.Fprintf(s, "%.v = %.v", n.List(), n.Rlist())
 		}
-		fallthrough
-
-	case OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV:
-		mode.Fprintf(s, "%.v = %v", n.List(), n.Right())
 
 	case ORETURN:
 		mode.Fprintf(s, "return %.v", n.List())
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 2850704ae1..85f7f92a42 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -520,8 +520,8 @@ const (
 	ORECOVER     // recover()
 	ORECV        // <-Left
 	ORUNESTR     // Type(Left) (Type is string, Left is rune)
-	OSELRECV     // Left = <-Right.Left: (appears as .Left of OCASE; Right.Op == ORECV)
-	OSELRECV2    // List = <-Right.Left: (appears as .Left of OCASE; count(List) == 2, Right.Op == ORECV)
+	OSELRECV     // like OAS: Left = Right where Right.Op = ORECV (appears as .Left of OCASE)
+	OSELRECV2    // like OAS2: List = Rlist where len(List)=2, len(Rlist)=1, Rlist[0].Op = ORECV (appears as .Left of OCASE)
 	OIOTA        // iota
 	OREAL        // real(Left)
 	OIMAG        // imag(Left)
diff --git a/src/cmd/compile/internal/logopt/logopt_test.go b/src/cmd/compile/internal/logopt/logopt_test.go
index 51bab49518..4a6ed2fac9 100644
--- a/src/cmd/compile/internal/logopt/logopt_test.go
+++ b/src/cmd/compile/internal/logopt/logopt_test.go
@@ -132,7 +132,7 @@ func TestLogOpt(t *testing.T) {
 	// Check at both 1 and 8-byte alignments.
 	t.Run("Copy", func(t *testing.T) {
 		const copyCode = `package x
-func s128a1(x *[128]int8) [128]int8 { 
+func s128a1(x *[128]int8) [128]int8 {
 	return *x
 }
 func s127a1(x *[127]int8) [127]int8 {
@@ -219,7 +219,7 @@ func s15a8(x *[15]int64) [15]int64 {
 			`{"location":{"uri":"file://tmpdir/file.go","range":{"start":{"line":4,"character":11},"end":{"line":4,"character":11}}},"message":"inlineLoc"},`+
 			`{"location":{"uri":"file://tmpdir/file.go","range":{"start":{"line":9,"character":13},"end":{"line":9,"character":13}}},"message":"escflow:      from \u0026y.b (address-of)"},`+
 			`{"location":{"uri":"file://tmpdir/file.go","range":{"start":{"line":4,"character":9},"end":{"line":4,"character":9}}},"message":"inlineLoc"},`+
-			`{"location":{"uri":"file://tmpdir/file.go","range":{"start":{"line":9,"character":13},"end":{"line":9,"character":13}}},"message":"escflow:      from ~R0 = \u003cN\u003e (assign-pair)"},`+
+			`{"location":{"uri":"file://tmpdir/file.go","range":{"start":{"line":9,"character":13},"end":{"line":9,"character":13}}},"message":"escflow:      from ~R0 = \u0026y.b (assign-pair)"},`+
 			`{"location":{"uri":"file://tmpdir/file.go","range":{"start":{"line":9,"character":3},"end":{"line":9,"character":3}}},"message":"escflow:    flow: ~r2 = ~R0:"},`+
 			`{"location":{"uri":"file://tmpdir/file.go","range":{"start":{"line":9,"character":3},"end":{"line":9,"character":3}}},"message":"escflow:      from return (*int)(~R0) (return)"}]}`)
 	})
-- 
GitLab


From 5fc192af56dd1a9977bf73175ab9e32232b4a14d Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 29 Nov 2020 11:16:20 -0500
Subject: [PATCH 0099/2400] [dev.regabi] cmd/compile: clean up Order.copyExpr
 TODO

Just a little cleaner to read.

Passes buildall w/ toolstash -cmp.

Change-Id: I27b9f09bf6756f74f1c01794444518ded1a7d625
Reviewed-on: https://go-review.googlesource.com/c/go/+/274106
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/order.go | 65 +++++++++++++++-------------
 1 file changed, 35 insertions(+), 30 deletions(-)

diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 66e279d85f..83cfb44474 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -93,21 +93,26 @@ func (o *Order) newTemp(t *types.Type, clear bool) ir.Node {
 
 // copyExpr behaves like newTemp but also emits
 // code to initialize the temporary to the value n.
-//
-// The clear argument is provided for use when the evaluation
-// of tmp = n turns into a function call that is passed a pointer
-// to the temporary as the output space. If the call blocks before
-// tmp has been written, the garbage collector will still treat the
-// temporary as live, so we must zero it before entering that call.
+func (o *Order) copyExpr(n ir.Node) ir.Node {
+	return o.copyExpr1(n, false)
+}
+
+// copyExprClear is like copyExpr but clears the temp before assignment.
+// It is provided for use when the evaluation of tmp = n turns into
+// a function call that is passed a pointer to the temporary as the output space.
+// If the call blocks before tmp has been written,
+// the garbage collector will still treat the temporary as live,
+// so we must zero it before entering that call.
 // Today, this only happens for channel receive operations.
 // (The other candidate would be map access, but map access
 // returns a pointer to the result data instead of taking a pointer
 // to be filled in.)
-// TODO(rsc): t == n.Type() always; remove parameter.
-func (o *Order) copyExpr(n ir.Node, t *types.Type, clear bool) ir.Node {
-	if t != n.Type() {
-		panic("copyExpr")
-	}
+func (o *Order) copyExprClear(n ir.Node) ir.Node {
+	return o.copyExpr1(n, true)
+}
+
+func (o *Order) copyExpr1(n ir.Node, clear bool) ir.Node {
+	t := n.Type()
 	v := o.newTemp(t, clear)
 	a := ir.Nod(ir.OAS, v, n)
 	a = typecheck(a, ctxStmt)
@@ -137,7 +142,7 @@ func (o *Order) cheapExpr(n ir.Node) ir.Node {
 		return typecheck(a, ctxExpr)
 	}
 
-	return o.copyExpr(n, n.Type(), false)
+	return o.copyExpr(n)
 }
 
 // safeExpr returns a safe version of n.
@@ -224,7 +229,7 @@ func (o *Order) addrTemp(n ir.Node) ir.Node {
 	if isaddrokay(n) {
 		return n
 	}
-	return o.copyExpr(n, n.Type(), false)
+	return o.copyExpr(n)
 }
 
 // mapKeyTemp prepares n to be a key in a map runtime call and returns n.
@@ -493,7 +498,7 @@ func (o *Order) call(n ir.Node) {
 		// by copying it into a temp and marking that temp
 		// still alive when we pop the temp stack.
 		if arg.Op() == ir.OCONVNOP && arg.Left().Type().IsUnsafePtr() {
-			x := o.copyExpr(arg.Left(), arg.Left().Type(), false)
+			x := o.copyExpr(arg.Left())
 			arg.SetLeft(x)
 			x.Name().SetAddrtaken(true) // ensure SSA keeps the x variable
 			n.PtrBody().Append(typecheck(ir.Nod(ir.OVARLIVE, x, nil), ctxStmt))
@@ -555,10 +560,10 @@ func (o *Order) mapAssign(n ir.Node) {
 			switch {
 			case m.Op() == ir.OINDEXMAP:
 				if !ir.IsAutoTmp(m.Left()) {
-					m.SetLeft(o.copyExpr(m.Left(), m.Left().Type(), false))
+					m.SetLeft(o.copyExpr(m.Left()))
 				}
 				if !ir.IsAutoTmp(m.Right()) {
-					m.SetRight(o.copyExpr(m.Right(), m.Right().Type(), false))
+					m.SetRight(o.copyExpr(m.Right()))
 				}
 				fallthrough
 			case instrumenting && n.Op() == ir.OAS2FUNC && !ir.IsBlank(m):
@@ -617,7 +622,7 @@ func (o *Order) stmt(n ir.Node) {
 			if l1.Op() == ir.OINDEXMAP {
 				l2.SetIndexMapLValue(false)
 			}
-			l2 = o.copyExpr(l2, l2.Type(), false)
+			l2 = o.copyExpr(l2)
 			r := ir.NodAt(n.Pos(), n.SubOp(), l2, n.Right())
 			r = typecheck(r, ctxExpr)
 			r = o.expr(r, nil)
@@ -802,7 +807,7 @@ func (o *Order) stmt(n ir.Node) {
 				r = typecheck(r, ctxExpr)
 			}
 
-			n.SetRight(o.copyExpr(r, r.Type(), false))
+			n.SetRight(o.copyExpr(r))
 
 		case types.TMAP:
 			if isMapClear(n) {
@@ -817,7 +822,7 @@ func (o *Order) stmt(n ir.Node) {
 			// TODO(rsc): Make tmp = literal expressions reuse tmp.
 			// For maps tmp is just one word so it hardly matters.
 			r := n.Right()
-			n.SetRight(o.copyExpr(r, r.Type(), false))
+			n.SetRight(o.copyExpr(r))
 
 			// prealloc[n] is the temp for the iterator.
 			// hiter contains pointers and needs to be zeroed.
@@ -898,7 +903,7 @@ func (o *Order) stmt(n ir.Node) {
 
 				recv.SetLeft(o.expr(recv.Left(), nil))
 				if recv.Left().Op() != ir.ONAME {
-					recv.SetLeft(o.copyExpr(recv.Left(), recv.Left().Type(), false))
+					recv.SetLeft(o.copyExpr(recv.Left()))
 				}
 
 				// Introduce temporary for receive and move actual copy into case body.
@@ -956,11 +961,11 @@ func (o *Order) stmt(n ir.Node) {
 				r.SetLeft(o.expr(r.Left(), nil))
 
 				if !ir.IsAutoTmp(r.Left()) {
-					r.SetLeft(o.copyExpr(r.Left(), r.Left().Type(), false))
+					r.SetLeft(o.copyExpr(r.Left()))
 				}
 				r.SetRight(o.expr(r.Right(), nil))
 				if !ir.IsAutoTmp(r.Right()) {
-					r.SetRight(o.copyExpr(r.Right(), r.Right().Type(), false))
+					r.SetRight(o.copyExpr(r.Right()))
 				}
 			}
 		}
@@ -988,7 +993,7 @@ func (o *Order) stmt(n ir.Node) {
 		if instrumenting {
 			// Force copying to the stack so that (chan T)(nil) <- x
 			// is still instrumented as a read of x.
-			n.SetRight(o.copyExpr(n.Right(), n.Right().Type(), false))
+			n.SetRight(o.copyExpr(n.Right()))
 		} else {
 			n.SetRight(o.addrTemp(n.Right()))
 		}
@@ -1134,7 +1139,7 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 		// key must be addressable
 		n.SetRight(o.mapKeyTemp(n.Left().Type(), n.Right()))
 		if needCopy {
-			n = o.copyExpr(n, n.Type(), false)
+			n = o.copyExpr(n)
 		}
 
 	// concrete type (not interface) argument might need an addressable
@@ -1159,7 +1164,7 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 			o.init(n.Left())
 			o.call(n.Left())
 			if lhs == nil || lhs.Op() != ir.ONAME || instrumenting {
-				n = o.copyExpr(n, n.Type(), false)
+				n = o.copyExpr(n)
 			}
 		} else {
 			n.SetLeft(o.expr(n.Left(), nil))
@@ -1229,7 +1234,7 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 		}
 
 		if lhs == nil || lhs.Op() != ir.ONAME || instrumenting {
-			n = o.copyExpr(n, n.Type(), false)
+			n = o.copyExpr(n)
 		}
 
 	case ir.OAPPEND:
@@ -1242,7 +1247,7 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 		}
 
 		if lhs == nil || lhs.Op() != ir.ONAME && !samesafeexpr(lhs, n.List().First()) {
-			n = o.copyExpr(n, n.Type(), false)
+			n = o.copyExpr(n)
 		}
 
 	case ir.OSLICE, ir.OSLICEARR, ir.OSLICESTR, ir.OSLICE3, ir.OSLICE3ARR:
@@ -1256,7 +1261,7 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 		max = o.cheapExpr(max)
 		n.SetSliceBounds(low, high, max)
 		if lhs == nil || lhs.Op() != ir.ONAME && !samesafeexpr(lhs, n.Left()) {
-			n = o.copyExpr(n, n.Type(), false)
+			n = o.copyExpr(n)
 		}
 
 	case ir.OCLOSURE:
@@ -1283,12 +1288,12 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 	case ir.ODOTTYPE, ir.ODOTTYPE2:
 		n.SetLeft(o.expr(n.Left(), nil))
 		if !isdirectiface(n.Type()) || instrumenting {
-			n = o.copyExpr(n, n.Type(), true)
+			n = o.copyExprClear(n)
 		}
 
 	case ir.ORECV:
 		n.SetLeft(o.expr(n.Left(), nil))
-		n = o.copyExpr(n, n.Type(), true)
+		n = o.copyExprClear(n)
 
 	case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
 		n.SetLeft(o.expr(n.Left(), nil))
-- 
GitLab


From b7f67b75d2fe94098afb618adc1badc12ce6e21c Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 29 Nov 2020 21:11:07 -0500
Subject: [PATCH 0100/2400] [dev.regabi] cmd/compile: clean up in preparation
 for expression Nodes

Using expression nodes restricts the set of valid SetOp operations,
because you can't SetOp across representation. Rewrite various code
to avoid crossing those as-yet-unintroduced boundaries.

This also includes choosing a single representation for any given Op.
For example, OCLOSE starts out as an OCALL, so it starts with a List
of one node and then moves that node to Left. That's no good with
real data structures, so the code picks a single canonical implementation
and prepares it during the conversion from one Op to the next.
In this case, the conversion of an OCALL to an OCLOSE now creates
a new node with Left initialized from the start. This pattern repeats.

Passes buildall w/ toolstash -cmp.

Change-Id: I55a0872c614d883cac9d64976c46aeeaa639e25d
Reviewed-on: https://go-review.googlesource.com/c/go/+/274107
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/sinit.go     |   8 +-
 src/cmd/compile/internal/gc/subr.go      |   2 +-
 src/cmd/compile/internal/gc/typecheck.go | 185 ++++++++++-------------
 src/cmd/compile/internal/gc/walk.go      |   7 +-
 4 files changed, 85 insertions(+), 117 deletions(-)

diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index ff3d3281dd..8146f30377 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -686,8 +686,7 @@ func slicelit(ctxt initContext, n ir.Node, var_ ir.Node, init *ir.Nodes) {
 
 		a = ir.Nod(ir.OADDR, a, nil)
 	} else {
-		a = ir.Nod(ir.ONEW, nil, nil)
-		a.PtrList().Set1(ir.TypeNode(t))
+		a = ir.Nod(ir.ONEW, ir.TypeNode(t), nil)
 	}
 
 	a = ir.Nod(ir.OAS, vauto, a)
@@ -889,9 +888,8 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 			r = ir.Nod(ir.OADDR, n.Right(), nil)
 			r = typecheck(r, ctxExpr)
 		} else {
-			r = ir.Nod(ir.ONEW, nil, nil)
-			r.SetTypecheck(1)
-			r.SetType(t)
+			r = ir.Nod(ir.ONEW, ir.TypeNode(n.Left().Type()), nil)
+			r = typecheck(r, ctxExpr)
 			r.SetEsc(n.Esc())
 		}
 
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index b1c9d24d99..0163653d3b 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -1472,7 +1472,7 @@ func ifaceData(pos src.XPos, n ir.Node, t *types.Type) ir.Node {
 	if t.IsInterface() {
 		base.Fatalf("ifaceData interface: %v", t)
 	}
-	ptr := nodlSym(pos, ir.OIDATA, n, nil)
+	ptr := ir.NodAt(pos, ir.OIDATA, n, nil)
 	if isdirectiface(t) {
 		ptr.SetType(t)
 		ptr.SetTypecheck(1)
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index b5ace76552..f021ea48b1 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -1065,7 +1065,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			n.SetRight(assignconv(n.Right(), t.Key(), "map index"))
 			n.SetType(t.Elem())
 			n.SetOp(ir.OINDEXMAP)
-			n.ResetAux()
+			n.SetIndexMapLValue(false)
 		}
 
 	case ir.ORECV:
@@ -1099,27 +1099,22 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		n.SetLeft(defaultlit(n.Left(), nil))
 		t := n.Left().Type()
 		if t == nil {
-			n.SetType(nil)
 			return n
 		}
 		if !t.IsChan() {
 			base.Errorf("invalid operation: %v (send to non-chan type %v)", n, t)
-			n.SetType(nil)
 			return n
 		}
 
 		if !t.ChanDir().CanSend() {
 			base.Errorf("invalid operation: %v (send to receive-only type %v)", n, t)
-			n.SetType(nil)
 			return n
 		}
 
 		n.SetRight(assignconv(n.Right(), t.Elem(), "send"))
 		if n.Right().Type() == nil {
-			n.SetType(nil)
 			return n
 		}
-		n.SetType(nil)
 
 	case ir.OSLICEHEADER:
 		// Errors here are Fatalf instead of Errorf because only the compiler
@@ -1299,9 +1294,44 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			}
 
 			// builtin: OLEN, OCAP, etc.
-			n.SetOp(l.SubOp())
-			n.SetLeft(n.Right())
-			n.SetRight(nil)
+			switch l.SubOp() {
+			default:
+				base.Fatalf("unknown builtin %v", l)
+				return n
+
+			case ir.OAPPEND, ir.ODELETE, ir.OMAKE, ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
+				n.SetOp(l.SubOp())
+				n.SetLeft(nil)
+
+			case ir.OCAP, ir.OCLOSE, ir.OIMAG, ir.OLEN, ir.OPANIC, ir.OREAL:
+				typecheckargs(n)
+				fallthrough
+			case ir.ONEW, ir.OALIGNOF, ir.OOFFSETOF, ir.OSIZEOF:
+				arg, ok := needOneArg(n, "%v", n.Op())
+				if !ok {
+					n.SetType(nil)
+					return n
+				}
+				old := n
+				n = ir.NodAt(n.Pos(), l.SubOp(), arg, nil)
+				n = addinit(n, old.Init().Slice()) // typecheckargs can add to old.Init
+				if l.SubOp() == ir.ONEW {
+					// Bug-compatibility with earlier version.
+					// This extra node is unnecessary but raises the inlining cost by 1.
+					n.SetList(old.List())
+				}
+
+			case ir.OCOMPLEX, ir.OCOPY:
+				typecheckargs(n)
+				arg1, arg2, ok := needTwoArgs(n)
+				if !ok {
+					n.SetType(nil)
+					return n
+				}
+				old := n
+				n = ir.NodAt(n.Pos(), l.SubOp(), arg1, arg2)
+				n = addinit(n, old.Init().Slice()) // typecheckargs can add to old.Init
+			}
 			n = typecheck1(n, top)
 			return n
 		}
@@ -1319,15 +1349,14 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			// pick off before type-checking arguments
 			ok |= ctxExpr
 
-			// turn CALL(type, arg) into CONV(arg) w/ type
-			n.SetLeft(nil)
-
-			n.SetOp(ir.OCONV)
-			n.SetType(l.Type())
-			if !onearg(n, "conversion to %v", l.Type()) {
+			arg, ok := needOneArg(n, "conversion to %v", l.Type())
+			if !ok {
 				n.SetType(nil)
 				return n
 			}
+
+			n = ir.NodAt(n.Pos(), ir.OCONV, arg, nil)
+			n.SetType(l.Type())
 			n = typecheck1(n, top)
 			return n
 		}
@@ -1406,19 +1435,10 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OALIGNOF, ir.OOFFSETOF, ir.OSIZEOF:
 		ok |= ctxExpr
-		if !onearg(n, "%v", n.Op()) {
-			n.SetType(nil)
-			return n
-		}
 		n.SetType(types.Types[types.TUINTPTR])
 
 	case ir.OCAP, ir.OLEN:
 		ok |= ctxExpr
-		if !onearg(n, "%v", n.Op()) {
-			n.SetType(nil)
-			return n
-		}
-
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetLeft(defaultlit(n.Left(), nil))
 		n.SetLeft(implicitstar(n.Left()))
@@ -1445,11 +1465,6 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OREAL, ir.OIMAG:
 		ok |= ctxExpr
-		if !onearg(n, "%v", n.Op()) {
-			n.SetType(nil)
-			return n
-		}
-
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		l := n.Left()
 		t := l.Type()
@@ -1474,13 +1489,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OCOMPLEX:
 		ok |= ctxExpr
-		typecheckargs(n)
-		if !twoarg(n) {
-			n.SetType(nil)
-			return n
-		}
-		l := n.Left()
-		r := n.Right()
+		l := typecheck(n.Left(), ctxExpr)
+		r := typecheck(n.Right(), ctxExpr)
 		if l.Type() == nil || r.Type() == nil {
 			n.SetType(nil)
 			return n
@@ -1518,10 +1528,6 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		n.SetType(t)
 
 	case ir.OCLOSE:
-		if !onearg(n, "%v", n.Op()) {
-			n.SetType(nil)
-			return n
-		}
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetLeft(defaultlit(n.Left(), nil))
 		l := n.Left()
@@ -1638,17 +1644,10 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OCOPY:
 		ok |= ctxStmt | ctxExpr
-		typecheckargs(n)
-		if !twoarg(n) {
-			n.SetType(nil)
-			return n
-		}
 		n.SetType(types.Types[types.TINT])
-		if n.Left().Type() == nil || n.Right().Type() == nil {
-			n.SetType(nil)
-			return n
-		}
+		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetLeft(defaultlit(n.Left(), nil))
+		n.SetRight(typecheck(n.Right(), ctxExpr))
 		n.SetRight(defaultlit(n.Right(), nil))
 		if n.Left().Type() == nil || n.Right().Type() == nil {
 			n.SetType(nil)
@@ -1746,6 +1745,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 
 		i := 1
+		var nn ir.Node
 		switch t.Etype {
 		default:
 			base.Errorf("cannot make type %v", t)
@@ -1782,10 +1782,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				n.SetType(nil)
 				return n
 			}
-
-			n.SetLeft(l)
-			n.SetRight(r)
-			n.SetOp(ir.OMAKESLICE)
+			nn = ir.NodAt(n.Pos(), ir.OMAKESLICE, l, r)
 
 		case types.TMAP:
 			if i < len(args) {
@@ -1801,11 +1798,11 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 					n.SetType(nil)
 					return n
 				}
-				n.SetLeft(l)
 			} else {
-				n.SetLeft(nodintconst(0))
+				l = nodintconst(0)
 			}
-			n.SetOp(ir.OMAKEMAP)
+			nn = ir.NodAt(n.Pos(), ir.OMAKEMAP, l, nil)
+			nn.SetEsc(n.Esc())
 
 		case types.TCHAN:
 			l = nil
@@ -1822,44 +1819,35 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 					n.SetType(nil)
 					return n
 				}
-				n.SetLeft(l)
 			} else {
-				n.SetLeft(nodintconst(0))
+				l = nodintconst(0)
 			}
-			n.SetOp(ir.OMAKECHAN)
+			nn = ir.NodAt(n.Pos(), ir.OMAKECHAN, l, nil)
 		}
 
 		if i < len(args) {
 			base.Errorf("too many arguments to make(%v)", t)
-			n.SetOp(ir.OMAKE)
 			n.SetType(nil)
 			return n
 		}
 
-		n.SetType(t)
+		nn.SetType(t)
+		n = nn
 
 	case ir.ONEW:
 		ok |= ctxExpr
-		args := n.List()
-		if args.Len() == 0 {
-			base.Errorf("missing argument to new")
-			n.SetType(nil)
-			return n
+		if n.Left() == nil {
+			// Fatalf because the OCALL above checked for us,
+			// so this must be an internally-generated mistake.
+			base.Fatalf("missing argument to new")
 		}
-
-		l := args.First()
+		l := n.Left()
 		l = typecheck(l, ctxType)
 		t := l.Type()
 		if t == nil {
 			n.SetType(nil)
 			return n
 		}
-		if args.Len() > 1 {
-			base.Errorf("too many arguments to new(%v)", t)
-			n.SetType(nil)
-			return n
-		}
-
 		n.SetLeft(l)
 		n.SetType(types.NewPtr(t))
 
@@ -1878,10 +1866,6 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OPANIC:
 		ok |= ctxStmt
-		if !onearg(n, "panic") {
-			n.SetType(nil)
-			return n
-		}
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetLeft(defaultlit(n.Left(), types.Types[types.TINTER]))
 		if n.Left().Type() == nil {
@@ -2286,45 +2270,32 @@ func implicitstar(n ir.Node) ir.Node {
 	return n
 }
 
-func onearg(n ir.Node, f string, args ...interface{}) bool {
-	if n.Left() != nil {
-		return true
-	}
+func needOneArg(n ir.Node, f string, args ...interface{}) (ir.Node, bool) {
 	if n.List().Len() == 0 {
 		p := fmt.Sprintf(f, args...)
 		base.Errorf("missing argument to %s: %v", p, n)
-		return false
+		return nil, false
 	}
 
 	if n.List().Len() > 1 {
 		p := fmt.Sprintf(f, args...)
 		base.Errorf("too many arguments to %s: %v", p, n)
-		n.SetLeft(n.List().First())
-		n.PtrList().Set(nil)
-		return false
+		return n.List().First(), false
 	}
 
-	n.SetLeft(n.List().First())
-	n.PtrList().Set(nil)
-	return true
+	return n.List().First(), true
 }
 
-func twoarg(n ir.Node) bool {
-	if n.Left() != nil {
-		return true
-	}
+func needTwoArgs(n ir.Node) (ir.Node, ir.Node, bool) {
 	if n.List().Len() != 2 {
 		if n.List().Len() < 2 {
 			base.Errorf("not enough arguments in call to %v", n)
 		} else {
 			base.Errorf("too many arguments in call to %v", n)
 		}
-		return false
+		return nil, nil, false
 	}
-	n.SetLeft(n.List().First())
-	n.SetRight(n.List().Second())
-	n.PtrList().Set(nil)
-	return true
+	return n.List().First(), n.List().Second(), true
 }
 
 func lookdot1(errnode ir.Node, s *types.Sym, t *types.Type, fs *types.Fields, dostrcmp int) *types.Field {
@@ -2411,21 +2382,19 @@ func typecheckMethodExpr(n ir.Node) (res ir.Node) {
 		return n
 	}
 
-	n.SetOp(ir.OMETHEXPR)
-	n.SetRight(NewName(n.Sym()))
-	n.SetSym(methodSym(t, n.Sym()))
-	n.SetType(methodfunc(m.Type, n.Left().Type()))
-	n.SetOffset(0)
-	n.SetClass(ir.PFUNC)
-	n.SetOpt(m)
-	// methodSym already marked n.Sym as a function.
+	me := ir.NodAt(n.Pos(), ir.OMETHEXPR, n.Left(), NewName(n.Sym()))
+	me.SetSym(methodSym(t, n.Sym()))
+	me.SetType(methodfunc(m.Type, n.Left().Type()))
+	me.SetOffset(0)
+	me.SetClass(ir.PFUNC)
+	me.SetOpt(m)
 
 	// Issue 25065. Make sure that we emit the symbol for a local method.
 	if base.Ctxt.Flag_dynlink && !inimport && (t.Sym == nil || t.Sym.Pkg == ir.LocalPkg) {
-		makefuncsym(n.Sym())
+		makefuncsym(me.Sym())
 	}
 
-	return n
+	return me
 }
 
 // isMethodApplicable reports whether method m can be called on a
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 0a77cfbb38..511cdd3685 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -1515,9 +1515,10 @@ opswitch:
 			}
 
 			// Slice the [n]byte to a []byte.
-			n.SetOp(ir.OSLICEARR)
-			n.SetLeft(p)
-			n = walkexpr(n, init)
+			slice := ir.NodAt(n.Pos(), ir.OSLICEARR, p, nil)
+			slice.SetType(n.Type())
+			slice.SetTypecheck(1)
+			n = walkexpr(slice, init)
 			break
 		}
 
-- 
GitLab


From 2bc814cd18b582030f25d22e0a3e80d4d30b19cf Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 30 Nov 2020 14:16:39 -0500
Subject: [PATCH 0101/2400] [dev.regabi] cmd/compile: clean up ONEW node

The list is no longer needed and can be deleted.
Doing so reduces the inlining cost of any function containing
an explicit call to new by 1 point, so this change is not
toolstash -cmp safe.

Change-Id: Id29e115d68e466a353708ab4b8c1021e9c85a628
Reviewed-on: https://go-review.googlesource.com/c/go/+/274132
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/typecheck.go | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index f021ea48b1..874594d764 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -1315,11 +1315,6 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				old := n
 				n = ir.NodAt(n.Pos(), l.SubOp(), arg, nil)
 				n = addinit(n, old.Init().Slice()) // typecheckargs can add to old.Init
-				if l.SubOp() == ir.ONEW {
-					// Bug-compatibility with earlier version.
-					// This extra node is unnecessary but raises the inlining cost by 1.
-					n.SetList(old.List())
-				}
 
 			case ir.OCOMPLEX, ir.OCOPY:
 				typecheckargs(n)
-- 
GitLab


From ffa68716a0d50acd29a8eae7874c7e8d02f757ca Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 29 Nov 2020 21:23:47 -0500
Subject: [PATCH 0102/2400] [dev.regabi] cmd/compile: add custom statement Node
 implementations

These are fairly rote implementations of structs appropriate to
each Op (or group of Ops).

The names of these are unknown except to ir.NodAt for now.
A later, automated change will introduce direct use of the types
throughout package gc.

Passes buildall w/ toolstash -cmp.

Change-Id: Ie9835fcd2b214fda5b2149e187af369d76534487
Reviewed-on: https://go-review.googlesource.com/c/go/+/274108
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/node.go |  78 ++--
 src/cmd/compile/internal/ir/stmt.go | 535 +++++++++++++++++++++++++++-
 2 files changed, 578 insertions(+), 35 deletions(-)

diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 85f7f92a42..a4d19c39f8 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -1029,22 +1029,60 @@ func Nod(op Op, nleft, nright Node) Node {
 func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
 	var n *node
 	switch op {
+	case OAS, OSELRECV:
+		n := NewAssignStmt(pos, nleft, nright)
+		n.SetOp(op)
+		return n
+	case OAS2, OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV, OSELRECV2:
+		n := NewAssignListStmt(pos, nil, nil)
+		n.SetOp(op)
+		return n
+	case OASOP:
+		return NewAssignOpStmt(pos, OXXX, nleft, nright)
+	case OBLOCK:
+		return NewBlockStmt(pos, nil)
+	case OBREAK, OCONTINUE, OFALL, OGOTO, ORETJMP:
+		return NewBranchStmt(pos, op, nil)
+	case OCASE:
+		return NewCaseStmt(pos, nil, nil)
+	case ODCL, ODCLCONST, ODCLTYPE:
+		return NewDecl(pos, op, nleft)
 	case ODCLFUNC:
 		return NewFunc(pos)
+	case ODEFER:
+		return NewDeferStmt(pos, nleft)
 	case ODEREF:
 		return NewStarExpr(pos, nleft)
-	case OPACK:
-		return NewPkgName(pos, nil, nil)
 	case OEMPTY:
 		return NewEmptyStmt(pos)
-	case OBREAK, OCONTINUE, OFALL, OGOTO:
-		return NewBranchStmt(pos, op, nil)
+	case OFOR:
+		return NewForStmt(pos, nil, nleft, nright, nil)
+	case OGO:
+		return NewGoStmt(pos, nleft)
+	case OIF:
+		return NewIfStmt(pos, nleft, nil, nil)
+	case OINLMARK:
+		return NewInlineMarkStmt(pos, types.BADWIDTH)
+	case OLABEL:
+		return NewLabelStmt(pos, nil)
 	case OLITERAL, OTYPE, OIOTA:
 		n := newNameAt(pos, nil)
 		n.SetOp(op)
 		return n
-	case OLABEL:
-		return NewLabelStmt(pos, nil)
+	case OPACK:
+		return NewPkgName(pos, nil, nil)
+	case ORANGE:
+		return NewRangeStmt(pos, nil, nright, nil)
+	case ORETURN:
+		return NewReturnStmt(pos, nil)
+	case OSELECT:
+		return NewSelectStmt(pos, nil)
+	case OSEND:
+		return NewSendStmt(pos, nleft, nright)
+	case OSWITCH:
+		return NewSwitchStmt(pos, nleft, nil)
+	case OTYPESW:
+		return NewTypeSwitchGuard(pos, nleft, nright)
 	default:
 		n = new(node)
 	}
@@ -1067,15 +1105,7 @@ var okForNod = [OEND]bool{
 	OANDNOT:        true,
 	OAPPEND:        true,
 	OARRAYLIT:      true,
-	OAS:            true,
-	OAS2:           true,
-	OAS2DOTTYPE:    true,
-	OAS2FUNC:       true,
-	OAS2MAPR:       true,
-	OAS2RECV:       true,
-	OASOP:          true,
 	OBITNOT:        true,
-	OBLOCK:         true,
 	OBYTES2STR:     true,
 	OBYTES2STRTMP:  true,
 	OCALL:          true,
@@ -1083,7 +1113,6 @@ var okForNod = [OEND]bool{
 	OCALLINTER:     true,
 	OCALLMETH:      true,
 	OCAP:           true,
-	OCASE:          true,
 	OCFUNC:         true,
 	OCHECKNIL:      true,
 	OCLOSE:         true,
@@ -1093,10 +1122,6 @@ var okForNod = [OEND]bool{
 	OCONVIFACE:     true,
 	OCONVNOP:       true,
 	OCOPY:          true,
-	ODCL:           true,
-	ODCLCONST:      true,
-	ODCLTYPE:       true,
-	ODEFER:         true,
 	ODELETE:        true,
 	ODIV:           true,
 	ODOT:           true,
@@ -1107,22 +1132,16 @@ var okForNod = [OEND]bool{
 	ODOTTYPE2:      true,
 	OEFACE:         true,
 	OEQ:            true,
-	OFOR:           true,
-	OFORUNTIL:      true,
 	OGE:            true,
 	OGETG:          true,
-	OGO:            true,
 	OGT:            true,
 	OIDATA:         true,
-	OIF:            true,
 	OIMAG:          true,
 	OINDEX:         true,
 	OINDEXMAP:      true,
 	OINLCALL:       true,
-	OINLMARK:       true,
 	OITAB:          true,
 	OKEY:           true,
-	OLABEL:         true,
 	OLE:            true,
 	OLEN:           true,
 	OLSH:           true,
@@ -1151,20 +1170,13 @@ var okForNod = [OEND]bool{
 	OPRINT:         true,
 	OPRINTN:        true,
 	OPTRLIT:        true,
-	ORANGE:         true,
 	OREAL:          true,
 	ORECOVER:       true,
 	ORECV:          true,
 	ORESULT:        true,
-	ORETJMP:        true,
-	ORETURN:        true,
 	ORSH:           true,
 	ORUNES2STR:     true,
 	ORUNESTR:       true,
-	OSELECT:        true,
-	OSELRECV:       true,
-	OSELRECV2:      true,
-	OSEND:          true,
 	OSIZEOF:        true,
 	OSLICE:         true,
 	OSLICE3:        true,
@@ -1180,8 +1192,6 @@ var okForNod = [OEND]bool{
 	OSTRUCTKEY:     true,
 	OSTRUCTLIT:     true,
 	OSUB:           true,
-	OSWITCH:        true,
-	OTYPESW:        true,
 	OVARDEF:        true,
 	OVARKILL:       true,
 	OVARLIVE:       true,
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index 5b89ff27a4..2516835513 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -10,6 +10,31 @@ import (
 	"fmt"
 )
 
+// A Decl is a declaration of a const, type, or var. (A declared func is a Func.)
+// (This is not technically a statement but it's not worth its own file.)
+type Decl struct {
+	miniNode
+	X Node // the thing being declared
+}
+
+func NewDecl(pos src.XPos, op Op, x Node) *Decl {
+	n := &Decl{X: x}
+	n.pos = pos
+	switch op {
+	default:
+		panic("invalid Decl op " + op.String())
+	case ODCL, ODCLCONST, ODCLTYPE:
+		n.op = op
+	}
+	return n
+}
+
+func (n *Decl) String() string                { return fmt.Sprint(n) }
+func (n *Decl) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *Decl) RawCopy() Node                 { c := *n; return &c }
+func (n *Decl) Left() Node                    { return n.X }
+func (n *Decl) SetLeft(x Node)                { n.X = x }
+
 // A miniStmt is a miniNode with extra fields common to statements.
 type miniStmt struct {
 	miniNode
@@ -22,7 +47,148 @@ func (n *miniStmt) PtrInit() *Nodes   { return &n.init }
 func (n *miniStmt) HasCall() bool     { return n.bits&miniHasCall != 0 }
 func (n *miniStmt) SetHasCall(b bool) { n.bits.set(miniHasCall, b) }
 
+// An AssignListStmt is an assignment statement with
+// more than one item on at least one side: Lhs = Rhs.
+// If Def is true, the assignment is a :=.
+type AssignListStmt struct {
+	miniStmt
+	Lhs    Nodes
+	Def    bool
+	Rhs    Nodes
+	offset int64 // for initorder
+}
+
+func NewAssignListStmt(pos src.XPos, lhs, rhs []Node) *AssignListStmt {
+	n := &AssignListStmt{}
+	n.pos = pos
+	n.op = OAS2
+	n.Lhs.Set(lhs)
+	n.Rhs.Set(rhs)
+	n.offset = types.BADWIDTH
+	return n
+}
+
+func (n *AssignListStmt) String() string                { return fmt.Sprint(n) }
+func (n *AssignListStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *AssignListStmt) RawCopy() Node                 { c := *n; return &c }
+
+func (n *AssignListStmt) List() Nodes       { return n.Lhs }
+func (n *AssignListStmt) PtrList() *Nodes   { return &n.Lhs }
+func (n *AssignListStmt) SetList(x Nodes)   { n.Lhs = x }
+func (n *AssignListStmt) Rlist() Nodes      { return n.Rhs }
+func (n *AssignListStmt) PtrRlist() *Nodes  { return &n.Rhs }
+func (n *AssignListStmt) SetRlist(x Nodes)  { n.Rhs = x }
+func (n *AssignListStmt) Colas() bool       { return n.Def }
+func (n *AssignListStmt) SetColas(x bool)   { n.Def = x }
+func (n *AssignListStmt) Offset() int64     { return n.offset }
+func (n *AssignListStmt) SetOffset(x int64) { n.offset = x }
+
+func (n *AssignListStmt) SetOp(op Op) {
+	switch op {
+	default:
+		panic(n.no("SetOp " + op.String()))
+	case OAS2, OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV, OSELRECV2:
+		n.op = op
+	}
+}
+
+// An AssignStmt is a simple assignment statement: X = Y.
+// If Def is true, the assignment is a :=.
+type AssignStmt struct {
+	miniStmt
+	X      Node
+	Def    bool
+	Y      Node
+	offset int64 // for initorder
+}
+
+func NewAssignStmt(pos src.XPos, x, y Node) *AssignStmt {
+	n := &AssignStmt{X: x, Y: y}
+	n.pos = pos
+	n.op = OAS
+	n.offset = types.BADWIDTH
+	return n
+}
+
+func (n *AssignStmt) String() string                { return fmt.Sprint(n) }
+func (n *AssignStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *AssignStmt) RawCopy() Node                 { c := *n; return &c }
+
+func (n *AssignStmt) Left() Node        { return n.X }
+func (n *AssignStmt) SetLeft(x Node)    { n.X = x }
+func (n *AssignStmt) Right() Node       { return n.Y }
+func (n *AssignStmt) SetRight(y Node)   { n.Y = y }
+func (n *AssignStmt) Colas() bool       { return n.Def }
+func (n *AssignStmt) SetColas(x bool)   { n.Def = x }
+func (n *AssignStmt) Offset() int64     { return n.offset }
+func (n *AssignStmt) SetOffset(x int64) { n.offset = x }
+
+func (n *AssignStmt) SetOp(op Op) {
+	switch op {
+	default:
+		panic(n.no("SetOp " + op.String()))
+	case OAS, OSELRECV:
+		n.op = op
+	}
+}
+
+// An AssignOpStmt is an AsOp= assignment statement: X AsOp= Y.
+type AssignOpStmt struct {
+	miniStmt
+	typ    *types.Type
+	X      Node
+	AsOp   Op // OADD etc
+	Y      Node
+	IncDec bool // actually ++ or --
+}
+
+func NewAssignOpStmt(pos src.XPos, op Op, x, y Node) *AssignOpStmt {
+	n := &AssignOpStmt{AsOp: op, X: x, Y: y}
+	n.pos = pos
+	n.op = OASOP
+	return n
+}
+
+func (n *AssignOpStmt) String() string                { return fmt.Sprint(n) }
+func (n *AssignOpStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *AssignOpStmt) RawCopy() Node                 { c := *n; return &c }
+
+func (n *AssignOpStmt) Left() Node            { return n.X }
+func (n *AssignOpStmt) SetLeft(x Node)        { n.X = x }
+func (n *AssignOpStmt) Right() Node           { return n.Y }
+func (n *AssignOpStmt) SetRight(y Node)       { n.Y = y }
+func (n *AssignOpStmt) SubOp() Op             { return n.AsOp }
+func (n *AssignOpStmt) SetSubOp(x Op)         { n.AsOp = x }
+func (n *AssignOpStmt) Implicit() bool        { return n.IncDec }
+func (n *AssignOpStmt) SetImplicit(b bool)    { n.IncDec = b }
+func (n *AssignOpStmt) Type() *types.Type     { return n.typ }
+func (n *AssignOpStmt) SetType(x *types.Type) { n.typ = x }
+
+// A BlockStmt is a block: { List }.
+type BlockStmt struct {
+	miniStmt
+	list Nodes
+}
+
+func NewBlockStmt(pos src.XPos, list []Node) *BlockStmt {
+	n := &BlockStmt{}
+	n.pos = pos
+	n.op = OBLOCK
+	n.list.Set(list)
+	return n
+}
+
+func (n *BlockStmt) String() string                { return fmt.Sprint(n) }
+func (n *BlockStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *BlockStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *BlockStmt) List() Nodes                   { return n.list }
+func (n *BlockStmt) PtrList() *Nodes               { return &n.list }
+func (n *BlockStmt) SetList(x Nodes)               { n.list = x }
+
 // A BranchStmt is a break, continue, fallthrough, or goto statement.
+//
+// For back-end code generation, Op may also be RETJMP (return+jump),
+// in which case the label names another function entirely.
 type BranchStmt struct {
 	miniStmt
 	Label *types.Sym // label if present
@@ -30,7 +196,7 @@ type BranchStmt struct {
 
 func NewBranchStmt(pos src.XPos, op Op, label *types.Sym) *BranchStmt {
 	switch op {
-	case OBREAK, OCONTINUE, OFALL, OGOTO:
+	case OBREAK, OCONTINUE, OFALL, OGOTO, ORETJMP:
 		// ok
 	default:
 		panic("NewBranch " + op.String())
@@ -47,6 +213,59 @@ func (n *BranchStmt) RawCopy() Node                 { c := *n; return &c }
 func (n *BranchStmt) Sym() *types.Sym               { return n.Label }
 func (n *BranchStmt) SetSym(sym *types.Sym)         { n.Label = sym }
 
+// A CaseStmt is a case statement in a switch or select: case List: Body.
+type CaseStmt struct {
+	miniStmt
+	Vars Nodes // declared variable for this case in type switch
+	list Nodes // list of expressions for switch, early select
+	Comm Node  // communication case (Exprs[0]) after select is type-checked
+	body Nodes
+}
+
+func NewCaseStmt(pos src.XPos, list, body []Node) *CaseStmt {
+	n := &CaseStmt{}
+	n.pos = pos
+	n.op = OCASE
+	n.list.Set(list)
+	n.body.Set(body)
+	return n
+}
+
+func (n *CaseStmt) String() string                { return fmt.Sprint(n) }
+func (n *CaseStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *CaseStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *CaseStmt) List() Nodes                   { return n.list }
+func (n *CaseStmt) PtrList() *Nodes               { return &n.list }
+func (n *CaseStmt) SetList(x Nodes)               { n.list = x }
+func (n *CaseStmt) Body() Nodes                   { return n.body }
+func (n *CaseStmt) PtrBody() *Nodes               { return &n.body }
+func (n *CaseStmt) SetBody(x Nodes)               { n.body = x }
+func (n *CaseStmt) Rlist() Nodes                  { return n.Vars }
+func (n *CaseStmt) PtrRlist() *Nodes              { return &n.Vars }
+func (n *CaseStmt) SetRlist(x Nodes)              { n.Vars = x }
+func (n *CaseStmt) Left() Node                    { return n.Comm }
+func (n *CaseStmt) SetLeft(x Node)                { n.Comm = x }
+
+// A DeferStmt is a defer statement: defer Call.
+type DeferStmt struct {
+	miniStmt
+	Call Node
+}
+
+func NewDeferStmt(pos src.XPos, call Node) *DeferStmt {
+	n := &DeferStmt{Call: call}
+	n.pos = pos
+	n.op = ODEFER
+	return n
+}
+
+func (n *DeferStmt) String() string                { return fmt.Sprint(n) }
+func (n *DeferStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *DeferStmt) RawCopy() Node                 { c := *n; return &c }
+
+func (n *DeferStmt) Left() Node     { return n.Call }
+func (n *DeferStmt) SetLeft(x Node) { n.Call = x }
+
 // An EmptyStmt is an empty statement
 type EmptyStmt struct {
 	miniStmt
@@ -63,6 +282,123 @@ func (n *EmptyStmt) String() string                { return fmt.Sprint(n) }
 func (n *EmptyStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *EmptyStmt) RawCopy() Node                 { c := *n; return &c }
 
+// A ForStmt is a non-range for loop: for Init; Cond; Post { Body }
+// Op can be OFOR or OFORUNTIL (!Cond).
+type ForStmt struct {
+	miniStmt
+	Label    *types.Sym
+	Cond     Node
+	Post     Node
+	Late     Nodes
+	body     Nodes
+	hasBreak bool
+}
+
+func NewForStmt(pos src.XPos, init []Node, cond, post Node, body []Node) *ForStmt {
+	n := &ForStmt{Cond: cond, Post: post}
+	n.pos = pos
+	n.op = OFOR
+	n.init.Set(init)
+	n.body.Set(body)
+	return n
+}
+
+func (n *ForStmt) String() string                { return fmt.Sprint(n) }
+func (n *ForStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ForStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *ForStmt) Sym() *types.Sym               { return n.Label }
+func (n *ForStmt) SetSym(x *types.Sym)           { n.Label = x }
+func (n *ForStmt) Left() Node                    { return n.Cond }
+func (n *ForStmt) SetLeft(x Node)                { n.Cond = x }
+func (n *ForStmt) Right() Node                   { return n.Post }
+func (n *ForStmt) SetRight(x Node)               { n.Post = x }
+func (n *ForStmt) Body() Nodes                   { return n.body }
+func (n *ForStmt) PtrBody() *Nodes               { return &n.body }
+func (n *ForStmt) SetBody(x Nodes)               { n.body = x }
+func (n *ForStmt) List() Nodes                   { return n.Late }
+func (n *ForStmt) PtrList() *Nodes               { return &n.Late }
+func (n *ForStmt) SetList(x Nodes)               { n.Late = x }
+func (n *ForStmt) HasBreak() bool                { return n.hasBreak }
+func (n *ForStmt) SetHasBreak(b bool)            { n.hasBreak = b }
+
+func (n *ForStmt) SetOp(op Op) {
+	if op != OFOR && op != OFORUNTIL {
+		panic(n.no("SetOp " + op.String()))
+	}
+	n.op = op
+}
+
+// A GoStmt is a go statement: go Call.
+type GoStmt struct {
+	miniStmt
+	Call Node
+}
+
+func NewGoStmt(pos src.XPos, call Node) *GoStmt {
+	n := &GoStmt{Call: call}
+	n.pos = pos
+	n.op = OGO
+	return n
+}
+
+func (n *GoStmt) String() string                { return fmt.Sprint(n) }
+func (n *GoStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *GoStmt) RawCopy() Node                 { c := *n; return &c }
+
+func (n *GoStmt) Left() Node     { return n.Call }
+func (n *GoStmt) SetLeft(x Node) { n.Call = x }
+
+// A IfStmt is a return statement: if Init; Cond { Then } else { Else }.
+type IfStmt struct {
+	miniStmt
+	Cond   Node
+	body   Nodes
+	Else   Nodes
+	likely bool // code layout hint
+}
+
+func NewIfStmt(pos src.XPos, cond Node, body, els []Node) *IfStmt {
+	n := &IfStmt{Cond: cond}
+	n.pos = pos
+	n.op = OIF
+	n.body.Set(body)
+	n.Else.Set(els)
+	return n
+}
+
+func (n *IfStmt) String() string                { return fmt.Sprint(n) }
+func (n *IfStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *IfStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *IfStmt) Left() Node                    { return n.Cond }
+func (n *IfStmt) SetLeft(x Node)                { n.Cond = x }
+func (n *IfStmt) Body() Nodes                   { return n.body }
+func (n *IfStmt) PtrBody() *Nodes               { return &n.body }
+func (n *IfStmt) SetBody(x Nodes)               { n.body = x }
+func (n *IfStmt) Rlist() Nodes                  { return n.Else }
+func (n *IfStmt) PtrRlist() *Nodes              { return &n.Else }
+func (n *IfStmt) SetRlist(x Nodes)              { n.Else = x }
+func (n *IfStmt) Likely() bool                  { return n.likely }
+func (n *IfStmt) SetLikely(x bool)              { n.likely = x }
+
+// An InlineMarkStmt is a marker placed just before an inlined body.
+type InlineMarkStmt struct {
+	miniStmt
+	Index int64
+}
+
+func NewInlineMarkStmt(pos src.XPos, index int64) *InlineMarkStmt {
+	n := &InlineMarkStmt{Index: index}
+	n.pos = pos
+	n.op = OINLMARK
+	return n
+}
+
+func (n *InlineMarkStmt) String() string                { return fmt.Sprint(n) }
+func (n *InlineMarkStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *InlineMarkStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *InlineMarkStmt) Offset() int64                 { return n.Index }
+func (n *InlineMarkStmt) SetOffset(x int64)             { n.Index = x }
+
 // A LabelStmt is a label statement (just the label, not including the statement it labels).
 type LabelStmt struct {
 	miniStmt
@@ -81,3 +417,200 @@ func (n *LabelStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *LabelStmt) RawCopy() Node                 { c := *n; return &c }
 func (n *LabelStmt) Sym() *types.Sym               { return n.Label }
 func (n *LabelStmt) SetSym(x *types.Sym)           { n.Label = x }
+
+// A RangeStmt is a range loop: for Vars = range X { Stmts }
+// Op can be OFOR or OFORUNTIL (!Cond).
+type RangeStmt struct {
+	miniStmt
+	Label    *types.Sym
+	Vars     Nodes // TODO(rsc): Replace with Key, Value Node
+	Def      bool
+	X        Node
+	body     Nodes
+	hasBreak bool
+	typ      *types.Type // TODO(rsc): Remove - use X.Type() instead
+}
+
+func NewRangeStmt(pos src.XPos, vars []Node, x Node, body []Node) *RangeStmt {
+	n := &RangeStmt{X: x}
+	n.pos = pos
+	n.op = ORANGE
+	n.Vars.Set(vars)
+	n.body.Set(body)
+	return n
+}
+
+func (n *RangeStmt) String() string                { return fmt.Sprint(n) }
+func (n *RangeStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *RangeStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *RangeStmt) Sym() *types.Sym               { return n.Label }
+func (n *RangeStmt) SetSym(x *types.Sym)           { n.Label = x }
+func (n *RangeStmt) Right() Node                   { return n.X }
+func (n *RangeStmt) SetRight(x Node)               { n.X = x }
+func (n *RangeStmt) Body() Nodes                   { return n.body }
+func (n *RangeStmt) PtrBody() *Nodes               { return &n.body }
+func (n *RangeStmt) SetBody(x Nodes)               { n.body = x }
+func (n *RangeStmt) List() Nodes                   { return n.Vars }
+func (n *RangeStmt) PtrList() *Nodes               { return &n.Vars }
+func (n *RangeStmt) SetList(x Nodes)               { n.Vars = x }
+func (n *RangeStmt) HasBreak() bool                { return n.hasBreak }
+func (n *RangeStmt) SetHasBreak(b bool)            { n.hasBreak = b }
+func (n *RangeStmt) Colas() bool                   { return n.Def }
+func (n *RangeStmt) SetColas(b bool)               { n.Def = b }
+func (n *RangeStmt) Type() *types.Type             { return n.typ }
+func (n *RangeStmt) SetType(x *types.Type)         { n.typ = x }
+
+// A ReturnStmt is a return statement.
+type ReturnStmt struct {
+	miniStmt
+	orig    Node  // for typecheckargs rewrite
+	Results Nodes // return list
+}
+
+func NewReturnStmt(pos src.XPos, results []Node) *ReturnStmt {
+	n := &ReturnStmt{}
+	n.pos = pos
+	n.op = ORETURN
+	n.orig = n
+	n.Results.Set(results)
+	return n
+}
+
+func (n *ReturnStmt) String() string                { return fmt.Sprint(n) }
+func (n *ReturnStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ReturnStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *ReturnStmt) Orig() Node                    { return n.orig }
+func (n *ReturnStmt) SetOrig(x Node)                { n.orig = x }
+func (n *ReturnStmt) List() Nodes                   { return n.Results }
+func (n *ReturnStmt) PtrList() *Nodes               { return &n.Results }
+func (n *ReturnStmt) SetList(x Nodes)               { n.Results = x }
+func (n *ReturnStmt) IsDDD() bool                   { return false } // typecheckargs asks
+
+// A SelectStmt is a block: { Cases }.
+type SelectStmt struct {
+	miniStmt
+	Label    *types.Sym
+	Cases    Nodes
+	hasBreak bool
+
+	// TODO(rsc): Instead of recording here, replace with a block?
+	Compiled Nodes // compiled form, after walkswitch
+}
+
+func NewSelectStmt(pos src.XPos, cases []Node) *SelectStmt {
+	n := &SelectStmt{}
+	n.pos = pos
+	n.op = OSELECT
+	n.Cases.Set(cases)
+	return n
+}
+
+func (n *SelectStmt) String() string                { return fmt.Sprint(n) }
+func (n *SelectStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *SelectStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *SelectStmt) List() Nodes                   { return n.Cases }
+func (n *SelectStmt) PtrList() *Nodes               { return &n.Cases }
+func (n *SelectStmt) SetList(x Nodes)               { n.Cases = x }
+func (n *SelectStmt) Sym() *types.Sym               { return n.Label }
+func (n *SelectStmt) SetSym(x *types.Sym)           { n.Label = x }
+func (n *SelectStmt) HasBreak() bool                { return n.hasBreak }
+func (n *SelectStmt) SetHasBreak(x bool)            { n.hasBreak = x }
+func (n *SelectStmt) Body() Nodes                   { return n.Compiled }
+func (n *SelectStmt) PtrBody() *Nodes               { return &n.Compiled }
+func (n *SelectStmt) SetBody(x Nodes)               { n.Compiled = x }
+
+// A SendStmt is a send statement: X <- Y.
+type SendStmt struct {
+	miniStmt
+	Chan  Node
+	Value Node
+}
+
+func NewSendStmt(pos src.XPos, ch, value Node) *SendStmt {
+	n := &SendStmt{Chan: ch, Value: value}
+	n.pos = pos
+	n.op = OSEND
+	return n
+}
+
+func (n *SendStmt) String() string                { return fmt.Sprint(n) }
+func (n *SendStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *SendStmt) RawCopy() Node                 { c := *n; return &c }
+
+func (n *SendStmt) Left() Node      { return n.Chan }
+func (n *SendStmt) SetLeft(x Node)  { n.Chan = x }
+func (n *SendStmt) Right() Node     { return n.Value }
+func (n *SendStmt) SetRight(y Node) { n.Value = y }
+
+// A SwitchStmt is a switch statement: switch Init; Expr { Cases }.
+type SwitchStmt struct {
+	miniStmt
+	Tag      Node
+	Cases    Nodes // list of *CaseStmt
+	Label    *types.Sym
+	hasBreak bool
+
+	// TODO(rsc): Instead of recording here, replace with a block?
+	Compiled Nodes // compiled form, after walkswitch
+}
+
+func NewSwitchStmt(pos src.XPos, tag Node, cases []Node) *SwitchStmt {
+	n := &SwitchStmt{Tag: tag}
+	n.pos = pos
+	n.op = OSWITCH
+	n.Cases.Set(cases)
+	return n
+}
+
+func (n *SwitchStmt) String() string                { return fmt.Sprint(n) }
+func (n *SwitchStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *SwitchStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *SwitchStmt) Left() Node                    { return n.Tag }
+func (n *SwitchStmt) SetLeft(x Node)                { n.Tag = x }
+func (n *SwitchStmt) List() Nodes                   { return n.Cases }
+func (n *SwitchStmt) PtrList() *Nodes               { return &n.Cases }
+func (n *SwitchStmt) SetList(x Nodes)               { n.Cases = x }
+func (n *SwitchStmt) Body() Nodes                   { return n.Compiled }
+func (n *SwitchStmt) PtrBody() *Nodes               { return &n.Compiled }
+func (n *SwitchStmt) SetBody(x Nodes)               { n.Compiled = x }
+func (n *SwitchStmt) Sym() *types.Sym               { return n.Label }
+func (n *SwitchStmt) SetSym(x *types.Sym)           { n.Label = x }
+func (n *SwitchStmt) HasBreak() bool                { return n.hasBreak }
+func (n *SwitchStmt) SetHasBreak(x bool)            { n.hasBreak = x }
+
+// A TypeSwitchGuard is the [Name :=] X.(type) in a type switch.
+type TypeSwitchGuard struct {
+	miniNode
+	name *Name
+	X    Node
+}
+
+func NewTypeSwitchGuard(pos src.XPos, name, x Node) *TypeSwitchGuard {
+	n := &TypeSwitchGuard{X: x}
+	if name != nil {
+		n.name = name.(*Name)
+	}
+	n.pos = pos
+	n.op = OTYPESW
+	return n
+}
+
+func (n *TypeSwitchGuard) String() string                { return fmt.Sprint(n) }
+func (n *TypeSwitchGuard) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *TypeSwitchGuard) RawCopy() Node                 { c := *n; return &c }
+
+func (n *TypeSwitchGuard) Left() Node {
+	if n.name == nil {
+		return nil
+	}
+	return n.name
+}
+func (n *TypeSwitchGuard) SetLeft(x Node) {
+	if x == nil {
+		n.name = nil
+		return
+	}
+	n.name = x.(*Name)
+}
+func (n *TypeSwitchGuard) Right() Node     { return n.X }
+func (n *TypeSwitchGuard) SetRight(x Node) { n.X = x }
-- 
GitLab


From 41ad4dec991c11d9e1efff27fc0b1568f5981c9c Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 30 Nov 2020 09:34:34 -0500
Subject: [PATCH 0103/2400] [dev.regabi] cmd/compile: fix -h

The compile -h flag is *meant* to panic, so you can see the stack
trace where the error is being printed. Make it do that again.

Change-Id: Ieb0042863582d7a4c5d08d2f866a144962915b06
Reviewed-on: https://go-review.googlesource.com/c/go/+/274116
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/main.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 7bad05265d..718239484b 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -43,6 +43,9 @@ func hidePanic() {
 		// about a panic too; let the user clean up
 		// the code and try again.
 		if err := recover(); err != nil {
+			if err == "-h" {
+				panic(err)
+			}
 			base.ErrorExit()
 		}
 	}
-- 
GitLab


From 0f9f27287b6eaac1634248e325aaab848e0dfd55 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 30 Nov 2020 00:01:26 -0800
Subject: [PATCH 0104/2400] [dev.regabi] cmd/compile: remove types.InitSyms

It's not types's responsibility to understand how package
initialization is implemented. Instead, have gc keep track of the
order that packages were imported, and then look for inittask
declarations.

Also, use resolve to force importing of the inittask's export data, so
that we can get the appropriate linker symbol index. (This is also why
this CL doesn't satisfy "toolstash -cmp".)

Change-Id: I5b706497d4a8d1c4439178863b4a8dba4da0f5a9
Reviewed-on: https://go-review.googlesource.com/c/go/+/274006
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/gc/init.go   | 14 ++++++++++++--
 src/cmd/compile/internal/gc/noder.go  |  3 +++
 src/cmd/compile/internal/types/pkg.go |  6 ------
 3 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index ed0218c0e2..b5fd2e7c75 100644
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -27,6 +27,9 @@ func renameinit() *types.Sym {
 	return s
 }
 
+// List of imported packages, in source code order. See #31636.
+var sourceOrderImports []*types.Pkg
+
 // fninit makes an initialization record for the package.
 // See runtime/proc.go:initTask for its layout.
 // The 3 tasks for initialization are:
@@ -40,8 +43,15 @@ func fninit(n []ir.Node) {
 	var fns []*obj.LSym  // functions to call for package initialization
 
 	// Find imported packages with init tasks.
-	for _, s := range types.InitSyms {
-		deps = append(deps, s.Linksym())
+	for _, pkg := range sourceOrderImports {
+		n := resolve(ir.AsNode(pkg.Lookup(".inittask").Def))
+		if n == nil {
+			continue
+		}
+		if n.Op() != ir.ONAME || n.Class() != ir.PEXTERN {
+			base.Fatalf("bad inittask: %v", n)
+		}
+		deps = append(deps, n.Sym().Linksym())
 	}
 
 	// Make a function that contains all the initialization statements.
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 98a09f4006..6a5afe7687 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -347,6 +347,9 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
 		p.importedEmbed = true
 	}
 
+	if !ipkg.Direct {
+		sourceOrderImports = append(sourceOrderImports, ipkg)
+	}
 	ipkg.Direct = true
 
 	var my *types.Sym
diff --git a/src/cmd/compile/internal/types/pkg.go b/src/cmd/compile/internal/types/pkg.go
index bcc6789509..bf90570b53 100644
--- a/src/cmd/compile/internal/types/pkg.go
+++ b/src/cmd/compile/internal/types/pkg.go
@@ -84,9 +84,6 @@ func (pkg *Pkg) Lookup(name string) *Sym {
 	return s
 }
 
-// List of .inittask entries in imported packages, in source code order.
-var InitSyms []*Sym
-
 // LookupOK looks up name in pkg and reports whether it previously existed.
 func (pkg *Pkg) LookupOK(name string) (s *Sym, existed bool) {
 	// TODO(gri) remove this check in favor of specialized lookup
@@ -101,9 +98,6 @@ func (pkg *Pkg) LookupOK(name string) (s *Sym, existed bool) {
 		Name: name,
 		Pkg:  pkg,
 	}
-	if name == ".inittask" {
-		InitSyms = append(InitSyms, s)
-	}
 	pkg.Syms[name] = s
 	return s, false
 }
-- 
GitLab


From 9a5a11adfa0f5ead728641d8fb72244e03239547 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 29 Nov 2020 21:25:47 -0500
Subject: [PATCH 0105/2400] [dev.regabi] cmd/compile: add custom expression
 Node implementations

These are fairly rote implementations of structs appropriate to
each Op (or group of Ops).

The names of these are unknown except to ir.NodAt for now.
A later, automated change will introduce direct use of the types
throughout package gc.

(This CL is expressions; the previous one was statements.)

This is the last of the Ops that were previously handled by the
generic node struct, so that struct and its methods can be
and are deleted in this CL.

Passes buildall w/ toolstash -cmp.

Change-Id: I1703f35f24dcd3f7c5782a278e53c3fe04e87c37
Reviewed-on: https://go-review.googlesource.com/c/go/+/274109
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/fmtmap_test.go             |   2 +-
 src/cmd/compile/internal/ir/dump.go        |   4 +-
 src/cmd/compile/internal/ir/expr.go        | 725 ++++++++++++++++++++-
 src/cmd/compile/internal/ir/fmt.go         |   5 -
 src/cmd/compile/internal/ir/node.go        | 504 ++------------
 src/cmd/compile/internal/ir/sizeof_test.go |   1 -
 6 files changed, 782 insertions(+), 459 deletions(-)

diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
index 32891aea66..09b06c4d93 100644
--- a/src/cmd/compile/fmtmap_test.go
+++ b/src/cmd/compile/fmtmap_test.go
@@ -29,7 +29,7 @@ var knownFormats = map[string]string{
 	"*cmd/compile/internal/ir.Name %+v":               "",
 	"*cmd/compile/internal/ir.Name %L":                "",
 	"*cmd/compile/internal/ir.Name %v":                "",
-	"*cmd/compile/internal/ir.node %v":                "",
+	"*cmd/compile/internal/ir.SliceExpr %v":           "",
 	"*cmd/compile/internal/ssa.Block %s":              "",
 	"*cmd/compile/internal/ssa.Block %v":              "",
 	"*cmd/compile/internal/ssa.Func %s":               "",
diff --git a/src/cmd/compile/internal/ir/dump.go b/src/cmd/compile/internal/ir/dump.go
index fe1410969f..bff3a40855 100644
--- a/src/cmd/compile/internal/ir/dump.go
+++ b/src/cmd/compile/internal/ir/dump.go
@@ -200,9 +200,9 @@ func (p *dumper) dump(x reflect.Value, depth int) {
 		typ := x.Type()
 
 		isNode := false
-		if n, ok := x.Interface().(node); ok {
+		if n, ok := x.Interface().(Node); ok {
 			isNode = true
-			p.printf("%s %s {", n.op.String(), p.addr(x))
+			p.printf("%s %s {", n.Op().String(), p.addr(x))
 		} else {
 			p.printf("%s {", typ)
 		}
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index f8e5f7641c..be9f486682 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -5,6 +5,7 @@
 package ir
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"fmt"
@@ -48,6 +49,182 @@ func (n *miniExpr) Init() Nodes           { return n.init }
 func (n *miniExpr) PtrInit() *Nodes       { return &n.init }
 func (n *miniExpr) SetInit(x Nodes)       { n.init = x }
 
+func toNtype(x Node) Ntype {
+	if x == nil {
+		return nil
+	}
+	if _, ok := x.(Ntype); !ok {
+		Dump("not Ntype", x)
+	}
+	return x.(Ntype)
+}
+
+// An AddStringExpr is a string concatenation Expr[0] + Exprs[1] + ... + Expr[len(Expr)-1].
+type AddStringExpr struct {
+	miniExpr
+	list Nodes
+}
+
+func NewAddStringExpr(pos src.XPos, list []Node) *AddStringExpr {
+	n := &AddStringExpr{}
+	n.pos = pos
+	n.op = OADDSTR
+	n.list.Set(list)
+	return n
+}
+
+func (n *AddStringExpr) String() string                { return fmt.Sprint(n) }
+func (n *AddStringExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *AddStringExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *AddStringExpr) List() Nodes                   { return n.list }
+func (n *AddStringExpr) PtrList() *Nodes               { return &n.list }
+func (n *AddStringExpr) SetList(x Nodes)               { n.list = x }
+
+// An AddrExpr is an address-of expression &X.
+// It may end up being a normal address-of or an allocation of a composite literal.
+type AddrExpr struct {
+	miniExpr
+	X     Node
+	Alloc Node // preallocated storage if any
+}
+
+func NewAddrExpr(pos src.XPos, x Node) *AddrExpr {
+	n := &AddrExpr{X: x}
+	n.op = OADDR
+	n.pos = pos
+	return n
+}
+
+func (n *AddrExpr) String() string                { return fmt.Sprint(n) }
+func (n *AddrExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *AddrExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *AddrExpr) Left() Node                    { return n.X }
+func (n *AddrExpr) SetLeft(x Node)                { n.X = x }
+func (n *AddrExpr) Right() Node                   { return n.Alloc }
+func (n *AddrExpr) SetRight(x Node)               { n.Alloc = x }
+
+func (n *AddrExpr) SetOp(op Op) {
+	switch op {
+	default:
+		panic(n.no("SetOp " + op.String()))
+	case OADDR, OPTRLIT:
+		n.op = op
+	}
+}
+
+// A BinaryExpr is a binary expression X Op Y,
+// or Op(X, Y) for builtin functions that do not become calls.
+type BinaryExpr struct {
+	miniExpr
+	X Node
+	Y Node
+}
+
+func NewBinaryExpr(pos src.XPos, op Op, x, y Node) *BinaryExpr {
+	n := &BinaryExpr{X: x, Y: y}
+	n.pos = pos
+	n.SetOp(op)
+	return n
+}
+
+func (n *BinaryExpr) String() string                { return fmt.Sprint(n) }
+func (n *BinaryExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *BinaryExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *BinaryExpr) Left() Node                    { return n.X }
+func (n *BinaryExpr) SetLeft(x Node)                { n.X = x }
+func (n *BinaryExpr) Right() Node                   { return n.Y }
+func (n *BinaryExpr) SetRight(y Node)               { n.Y = y }
+
+func (n *BinaryExpr) SetOp(op Op) {
+	switch op {
+	default:
+		panic(n.no("SetOp " + op.String()))
+	case OADD, OADDSTR, OAND, OANDAND, OANDNOT, ODIV, OEQ, OGE, OGT, OLE,
+		OLSH, OLT, OMOD, OMUL, ONE, OOR, OOROR, ORSH, OSUB, OXOR,
+		OCOPY, OCOMPLEX,
+		OEFACE:
+		n.op = op
+	}
+}
+
+// A CallExpr is a function call X(Args).
+type CallExpr struct {
+	miniExpr
+	orig     Node
+	X        Node
+	Args     Nodes
+	Rargs    Nodes // TODO(rsc): Delete.
+	body     Nodes // TODO(rsc): Delete.
+	DDD      bool
+	noInline bool
+}
+
+func NewCallExpr(pos src.XPos, fun Node, args []Node) *CallExpr {
+	n := &CallExpr{X: fun}
+	n.pos = pos
+	n.orig = n
+	n.op = OCALL
+	n.Args.Set(args)
+	return n
+}
+
+func (n *CallExpr) String() string                { return fmt.Sprint(n) }
+func (n *CallExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *CallExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *CallExpr) Orig() Node                    { return n.orig }
+func (n *CallExpr) SetOrig(x Node)                { n.orig = x }
+func (n *CallExpr) Left() Node                    { return n.X }
+func (n *CallExpr) SetLeft(x Node)                { n.X = x }
+func (n *CallExpr) List() Nodes                   { return n.Args }
+func (n *CallExpr) PtrList() *Nodes               { return &n.Args }
+func (n *CallExpr) SetList(x Nodes)               { n.Args = x }
+func (n *CallExpr) Rlist() Nodes                  { return n.Rargs }
+func (n *CallExpr) PtrRlist() *Nodes              { return &n.Rargs }
+func (n *CallExpr) SetRlist(x Nodes)              { n.Rargs = x }
+func (n *CallExpr) IsDDD() bool                   { return n.DDD }
+func (n *CallExpr) SetIsDDD(x bool)               { n.DDD = x }
+func (n *CallExpr) NoInline() bool                { return n.noInline }
+func (n *CallExpr) SetNoInline(x bool)            { n.noInline = x }
+func (n *CallExpr) Body() Nodes                   { return n.body }
+func (n *CallExpr) PtrBody() *Nodes               { return &n.body }
+func (n *CallExpr) SetBody(x Nodes)               { n.body = x }
+
+func (n *CallExpr) SetOp(op Op) {
+	switch op {
+	default:
+		panic(n.no("SetOp " + op.String()))
+	case OCALL, OCALLFUNC, OCALLINTER, OCALLMETH,
+		OAPPEND, ODELETE, OGETG, OMAKE, OPRINT, OPRINTN, ORECOVER:
+		n.op = op
+	}
+}
+
+// A CallPartExpr is a method expression X.Method (uncalled).
+type CallPartExpr struct {
+	miniExpr
+	fn     *Func
+	X      Node
+	Method *Name
+}
+
+func NewCallPartExpr(pos src.XPos, x Node, method *Name, fn *Func) *CallPartExpr {
+	n := &CallPartExpr{fn: fn, X: x, Method: method}
+	n.op = OCALLPART
+	n.pos = pos
+	n.typ = fn.Type()
+	n.fn = fn
+	return n
+}
+
+func (n *CallPartExpr) String() string                { return fmt.Sprint(n) }
+func (n *CallPartExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *CallPartExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *CallPartExpr) Func() *Func                   { return n.fn }
+func (n *CallPartExpr) Left() Node                    { return n.X }
+func (n *CallPartExpr) Right() Node                   { return n.Method }
+func (n *CallPartExpr) SetLeft(x Node)                { n.X = x }
+func (n *CallPartExpr) SetRight(x Node)               { n.Method = x.(*Name) }
+
 // A ClosureExpr is a function literal expression.
 type ClosureExpr struct {
 	miniExpr
@@ -85,31 +262,477 @@ func (n *ClosureRead) RawCopy() Node                 { c := *n; return &c }
 func (n *ClosureRead) Type() *types.Type             { return n.typ }
 func (n *ClosureRead) Offset() int64                 { return n.offset }
 
-// A CallPartExpr is a method expression X.Method (uncalled).
-type CallPartExpr struct {
+// A CompLitExpr is a composite literal Type{Vals}.
+// Before type-checking, the type is Ntype.
+type CompLitExpr struct {
+	miniExpr
+	orig  Node
+	Ntype Ntype
+	list  Nodes // initialized values
+}
+
+func NewCompLitExpr(pos src.XPos, typ Ntype, list []Node) *CompLitExpr {
+	n := &CompLitExpr{Ntype: typ}
+	n.pos = pos
+	n.op = OCOMPLIT
+	n.list.Set(list)
+	n.orig = n
+	return n
+}
+
+func (n *CompLitExpr) String() string                { return fmt.Sprint(n) }
+func (n *CompLitExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *CompLitExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *CompLitExpr) Orig() Node                    { return n.orig }
+func (n *CompLitExpr) SetOrig(x Node)                { n.orig = x }
+func (n *CompLitExpr) Right() Node                   { return n.Ntype }
+func (n *CompLitExpr) SetRight(x Node)               { n.Ntype = toNtype(x) }
+func (n *CompLitExpr) List() Nodes                   { return n.list }
+func (n *CompLitExpr) PtrList() *Nodes               { return &n.list }
+func (n *CompLitExpr) SetList(x Nodes)               { n.list = x }
+
+func (n *CompLitExpr) SetOp(op Op) {
+	switch op {
+	default:
+		panic(n.no("SetOp " + op.String()))
+	case OARRAYLIT, OCOMPLIT, OMAPLIT, OSTRUCTLIT, OSLICELIT:
+		n.op = op
+	}
+}
+
+// A ConvExpr is a conversion Type(X).
+// It may end up being a value or a type.
+type ConvExpr struct {
+	miniExpr
+	orig Node
+	X    Node
+}
+
+func NewConvExpr(pos src.XPos, op Op, typ *types.Type, x Node) *ConvExpr {
+	n := &ConvExpr{X: x}
+	n.pos = pos
+	n.typ = typ
+	n.SetOp(op)
+	n.orig = n
+	return n
+}
+
+func (n *ConvExpr) String() string                { return fmt.Sprint(n) }
+func (n *ConvExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ConvExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *ConvExpr) Orig() Node                    { return n.orig }
+func (n *ConvExpr) SetOrig(x Node)                { n.orig = x }
+func (n *ConvExpr) Left() Node                    { return n.X }
+func (n *ConvExpr) SetLeft(x Node)                { n.X = x }
+
+func (n *ConvExpr) SetOp(op Op) {
+	switch op {
+	default:
+		panic(n.no("SetOp " + op.String()))
+	case OCONV, OCONVIFACE, OCONVNOP, OBYTES2STR, OBYTES2STRTMP, ORUNES2STR, OSTR2BYTES, OSTR2BYTESTMP, OSTR2RUNES, ORUNESTR:
+		n.op = op
+	}
+}
+
+// An IndexExpr is an index expression X[Y].
+type IndexExpr struct {
+	miniExpr
+	X        Node
+	Index    Node
+	Assigned bool
+}
+
+func NewIndexExpr(pos src.XPos, x, index Node) *IndexExpr {
+	n := &IndexExpr{X: x, Index: index}
+	n.pos = pos
+	n.op = OINDEX
+	return n
+}
+
+func (n *IndexExpr) String() string                { return fmt.Sprint(n) }
+func (n *IndexExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *IndexExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *IndexExpr) Left() Node                    { return n.X }
+func (n *IndexExpr) SetLeft(x Node)                { n.X = x }
+func (n *IndexExpr) Right() Node                   { return n.Index }
+func (n *IndexExpr) SetRight(y Node)               { n.Index = y }
+func (n *IndexExpr) IndexMapLValue() bool          { return n.Assigned }
+func (n *IndexExpr) SetIndexMapLValue(x bool)      { n.Assigned = x }
+
+func (n *IndexExpr) SetOp(op Op) {
+	switch op {
+	default:
+		panic(n.no("SetOp " + op.String()))
+	case OINDEX, OINDEXMAP:
+		n.op = op
+	}
+}
+
+// A KeyExpr is an X:Y composite literal key.
+// After type-checking, a key for a struct sets Sym to the field.
+type KeyExpr struct {
+	miniExpr
+	Key    Node
+	sym    *types.Sym
+	Value  Node
+	offset int64
+}
+
+func NewKeyExpr(pos src.XPos, key, value Node) *KeyExpr {
+	n := &KeyExpr{Key: key, Value: value}
+	n.pos = pos
+	n.op = OKEY
+	n.offset = types.BADWIDTH
+	return n
+}
+
+func (n *KeyExpr) String() string                { return fmt.Sprint(n) }
+func (n *KeyExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *KeyExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *KeyExpr) Left() Node                    { return n.Key }
+func (n *KeyExpr) SetLeft(x Node)                { n.Key = x }
+func (n *KeyExpr) Right() Node                   { return n.Value }
+func (n *KeyExpr) SetRight(y Node)               { n.Value = y }
+func (n *KeyExpr) Sym() *types.Sym               { return n.sym }
+func (n *KeyExpr) SetSym(x *types.Sym)           { n.sym = x }
+func (n *KeyExpr) Offset() int64                 { return n.offset }
+func (n *KeyExpr) SetOffset(x int64)             { n.offset = x }
+
+func (n *KeyExpr) SetOp(op Op) {
+	switch op {
+	default:
+		panic(n.no("SetOp " + op.String()))
+	case OKEY, OSTRUCTKEY:
+		n.op = op
+	}
+}
+
+// An InlinedCallExpr is an inlined function call.
+type InlinedCallExpr struct {
+	miniExpr
+	body       Nodes
+	ReturnVars Nodes
+}
+
+func NewInlinedCallExpr(pos src.XPos, body, retvars []Node) *InlinedCallExpr {
+	n := &InlinedCallExpr{}
+	n.pos = pos
+	n.op = OINLCALL
+	n.body.Set(body)
+	n.ReturnVars.Set(retvars)
+	return n
+}
+
+func (n *InlinedCallExpr) String() string                { return fmt.Sprint(n) }
+func (n *InlinedCallExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *InlinedCallExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *InlinedCallExpr) Body() Nodes                   { return n.body }
+func (n *InlinedCallExpr) PtrBody() *Nodes               { return &n.body }
+func (n *InlinedCallExpr) SetBody(x Nodes)               { n.body = x }
+func (n *InlinedCallExpr) Rlist() Nodes                  { return n.ReturnVars }
+func (n *InlinedCallExpr) PtrRlist() *Nodes              { return &n.ReturnVars }
+func (n *InlinedCallExpr) SetRlist(x Nodes)              { n.ReturnVars = x }
+
+// A MakeExpr is a make expression: make(Type[, Len[, Cap]]).
+// Op is OMAKECHAN, OMAKEMAP, OMAKESLICE, or OMAKESLICECOPY,
+// but *not* OMAKE (that's a pre-typechecking CallExpr).
+type MakeExpr struct {
+	miniExpr
+	Len Node
+	Cap Node
+}
+
+func NewMakeExpr(pos src.XPos, op Op, len, cap Node) *MakeExpr {
+	n := &MakeExpr{Len: len, Cap: cap}
+	n.pos = pos
+	n.SetOp(op)
+	return n
+}
+
+func (n *MakeExpr) String() string                { return fmt.Sprint(n) }
+func (n *MakeExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *MakeExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *MakeExpr) Left() Node                    { return n.Len }
+func (n *MakeExpr) SetLeft(x Node)                { n.Len = x }
+func (n *MakeExpr) Right() Node                   { return n.Cap }
+func (n *MakeExpr) SetRight(x Node)               { n.Cap = x }
+
+func (n *MakeExpr) SetOp(op Op) {
+	switch op {
+	default:
+		panic(n.no("SetOp " + op.String()))
+	case OMAKECHAN, OMAKEMAP, OMAKESLICE, OMAKESLICECOPY:
+		n.op = op
+	}
+}
+
+// A MethodExpr is a method expression X.M (where X is an expression, not a type).
+type MethodExpr struct {
 	miniExpr
-	fn     *Func
 	X      Node
-	Method *Name
+	M      Node
+	sym    *types.Sym
+	offset int64
+	class  Class
 }
 
-func NewCallPartExpr(pos src.XPos, x Node, method *Name, fn *Func) *CallPartExpr {
-	n := &CallPartExpr{fn: fn, X: x, Method: method}
-	n.op = OCALLPART
+func NewMethodExpr(pos src.XPos, op Op, x, m Node) *MethodExpr {
+	n := &MethodExpr{X: x, M: m}
 	n.pos = pos
-	n.typ = fn.Type()
-	n.fn = fn
+	n.op = OMETHEXPR
+	n.offset = types.BADWIDTH
 	return n
 }
 
-func (n *CallPartExpr) String() string                { return fmt.Sprint(n) }
-func (n *CallPartExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *CallPartExpr) RawCopy() Node                 { c := *n; return &c }
-func (n *CallPartExpr) Func() *Func                   { return n.fn }
-func (n *CallPartExpr) Left() Node                    { return n.X }
-func (n *CallPartExpr) Right() Node                   { return n.Method }
-func (n *CallPartExpr) SetLeft(x Node)                { n.X = x }
-func (n *CallPartExpr) SetRight(x Node)               { n.Method = x.(*Name) }
+func (n *MethodExpr) String() string                { return fmt.Sprint(n) }
+func (n *MethodExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *MethodExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *MethodExpr) Left() Node                    { return n.X }
+func (n *MethodExpr) SetLeft(x Node)                { n.X = x }
+func (n *MethodExpr) Right() Node                   { return n.M }
+func (n *MethodExpr) SetRight(y Node)               { n.M = y }
+func (n *MethodExpr) Sym() *types.Sym               { return n.sym }
+func (n *MethodExpr) SetSym(x *types.Sym)           { n.sym = x }
+func (n *MethodExpr) Offset() int64                 { return n.offset }
+func (n *MethodExpr) SetOffset(x int64)             { n.offset = x }
+func (n *MethodExpr) Class() Class                  { return n.class }
+func (n *MethodExpr) SetClass(x Class)              { n.class = x }
+
+// A NilExpr represents the predefined untyped constant nil.
+// (It may be copied and assigned a type, though.)
+type NilExpr struct {
+	miniExpr
+	sym *types.Sym // TODO: Remove
+}
+
+func NewNilExpr(pos src.XPos) *NilExpr {
+	n := &NilExpr{}
+	n.pos = pos
+	n.op = ONIL
+	return n
+}
+
+func (n *NilExpr) String() string                { return fmt.Sprint(n) }
+func (n *NilExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *NilExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *NilExpr) Sym() *types.Sym               { return n.sym }
+func (n *NilExpr) SetSym(x *types.Sym)           { n.sym = x }
+
+// A ParenExpr is a parenthesized expression (X).
+// It may end up being a value or a type.
+type ParenExpr struct {
+	miniExpr
+	X Node
+}
+
+func NewParenExpr(pos src.XPos, x Node) *ParenExpr {
+	n := &ParenExpr{X: x}
+	n.op = OPAREN
+	n.pos = pos
+	return n
+}
+
+func (n *ParenExpr) String() string                { return fmt.Sprint(n) }
+func (n *ParenExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ParenExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *ParenExpr) Left() Node                    { return n.X }
+func (n *ParenExpr) SetLeft(x Node)                { n.X = x }
+
+func (*ParenExpr) CanBeNtype() {}
+
+// SetOTYPE changes n to be an OTYPE node returning t,
+// like all the type nodes in type.go.
+func (n *ParenExpr) SetOTYPE(t *types.Type) {
+	n.op = OTYPE
+	n.typ = t
+	if t.Nod == nil {
+		t.Nod = n
+	}
+}
+
+// A ResultExpr represents a direct access to a result slot on the stack frame.
+type ResultExpr struct {
+	miniExpr
+	offset int64
+}
+
+func NewResultExpr(pos src.XPos, typ *types.Type, offset int64) *ResultExpr {
+	n := &ResultExpr{offset: offset}
+	n.pos = pos
+	n.op = ORESULT
+	n.typ = typ
+	return n
+}
+
+func (n *ResultExpr) String() string                { return fmt.Sprint(n) }
+func (n *ResultExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ResultExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *ResultExpr) Offset() int64                 { return n.offset }
+func (n *ResultExpr) SetOffset(x int64)             { n.offset = x }
+
+// A SelectorExpr is a selector expression X.Sym.
+type SelectorExpr struct {
+	miniExpr
+	X      Node
+	Sel    *types.Sym
+	offset int64
+}
+
+func NewSelectorExpr(pos src.XPos, x Node, sel *types.Sym) *SelectorExpr {
+	n := &SelectorExpr{X: x, Sel: sel}
+	n.pos = pos
+	n.op = OXDOT
+	n.offset = types.BADWIDTH
+	return n
+}
+
+func (n *SelectorExpr) SetOp(op Op) {
+	switch op {
+	default:
+		panic(n.no("SetOp " + op.String()))
+	case ODOT, ODOTPTR, ODOTMETH, ODOTINTER, OXDOT:
+		n.op = op
+	}
+}
+
+func (n *SelectorExpr) String() string                { return fmt.Sprint(n) }
+func (n *SelectorExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *SelectorExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *SelectorExpr) Left() Node                    { return n.X }
+func (n *SelectorExpr) SetLeft(x Node)                { n.X = x }
+func (n *SelectorExpr) Sym() *types.Sym               { return n.Sel }
+func (n *SelectorExpr) SetSym(x *types.Sym)           { n.Sel = x }
+func (n *SelectorExpr) Offset() int64                 { return n.offset }
+func (n *SelectorExpr) SetOffset(x int64)             { n.offset = x }
+
+// Before type-checking, bytes.Buffer is a SelectorExpr.
+// After type-checking it becomes a Name.
+func (*SelectorExpr) CanBeNtype() {}
+
+// A SliceExpr is a slice expression X[Low:High] or X[Low:High:Max].
+type SliceExpr struct {
+	miniExpr
+	X    Node
+	list Nodes // TODO(rsc): Use separate Nodes
+}
+
+func NewSliceExpr(pos src.XPos, op Op, x Node) *SliceExpr {
+	n := &SliceExpr{X: x}
+	n.pos = pos
+	n.op = op
+	return n
+}
+
+func (n *SliceExpr) String() string                { return fmt.Sprint(n) }
+func (n *SliceExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *SliceExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *SliceExpr) Left() Node                    { return n.X }
+func (n *SliceExpr) SetLeft(x Node)                { n.X = x }
+func (n *SliceExpr) List() Nodes                   { return n.list }
+func (n *SliceExpr) PtrList() *Nodes               { return &n.list }
+func (n *SliceExpr) SetList(x Nodes)               { n.list = x }
+
+func (n *SliceExpr) SetOp(op Op) {
+	switch op {
+	default:
+		panic(n.no("SetOp " + op.String()))
+	case OSLICE, OSLICEARR, OSLICESTR, OSLICE3, OSLICE3ARR:
+		n.op = op
+	}
+}
+
+// SliceBounds returns n's slice bounds: low, high, and max in expr[low:high:max].
+// n must be a slice expression. max is nil if n is a simple slice expression.
+func (n *SliceExpr) SliceBounds() (low, high, max Node) {
+	if n.list.Len() == 0 {
+		return nil, nil, nil
+	}
+
+	switch n.Op() {
+	case OSLICE, OSLICEARR, OSLICESTR:
+		s := n.list.Slice()
+		return s[0], s[1], nil
+	case OSLICE3, OSLICE3ARR:
+		s := n.list.Slice()
+		return s[0], s[1], s[2]
+	}
+	base.Fatalf("SliceBounds op %v: %v", n.Op(), n)
+	return nil, nil, nil
+}
+
+// SetSliceBounds sets n's slice bounds, where n is a slice expression.
+// n must be a slice expression. If max is non-nil, n must be a full slice expression.
+func (n *SliceExpr) SetSliceBounds(low, high, max Node) {
+	switch n.Op() {
+	case OSLICE, OSLICEARR, OSLICESTR:
+		if max != nil {
+			base.Fatalf("SetSliceBounds %v given three bounds", n.Op())
+		}
+		s := n.list.Slice()
+		if s == nil {
+			if low == nil && high == nil {
+				return
+			}
+			n.list.Set2(low, high)
+			return
+		}
+		s[0] = low
+		s[1] = high
+		return
+	case OSLICE3, OSLICE3ARR:
+		s := n.list.Slice()
+		if s == nil {
+			if low == nil && high == nil && max == nil {
+				return
+			}
+			n.list.Set3(low, high, max)
+			return
+		}
+		s[0] = low
+		s[1] = high
+		s[2] = max
+		return
+	}
+	base.Fatalf("SetSliceBounds op %v: %v", n.Op(), n)
+}
+
+// IsSlice3 reports whether o is a slice3 op (OSLICE3, OSLICE3ARR).
+// o must be a slicing op.
+func (o Op) IsSlice3() bool {
+	switch o {
+	case OSLICE, OSLICEARR, OSLICESTR:
+		return false
+	case OSLICE3, OSLICE3ARR:
+		return true
+	}
+	base.Fatalf("IsSlice3 op %v", o)
+	return false
+}
+
+// A SliceHeader expression constructs a slice header from its parts.
+type SliceHeaderExpr struct {
+	miniExpr
+	Ptr    Node
+	lenCap Nodes // TODO(rsc): Split into two Node fields
+}
+
+func NewSliceHeaderExpr(pos src.XPos, typ *types.Type, ptr, len, cap Node) *SliceHeaderExpr {
+	n := &SliceHeaderExpr{Ptr: ptr}
+	n.pos = pos
+	n.op = OSLICEHEADER
+	n.typ = typ
+	n.lenCap.Set2(len, cap)
+	return n
+}
+
+func (n *SliceHeaderExpr) String() string                { return fmt.Sprint(n) }
+func (n *SliceHeaderExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *SliceHeaderExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *SliceHeaderExpr) Left() Node                    { return n.Ptr }
+func (n *SliceHeaderExpr) SetLeft(x Node)                { n.Ptr = x }
+func (n *SliceHeaderExpr) List() Nodes                   { return n.lenCap }
+func (n *SliceHeaderExpr) PtrList() *Nodes               { return &n.lenCap }
+func (n *SliceHeaderExpr) SetList(x Nodes)               { n.lenCap = x }
 
 // A StarExpr is a dereference expression *X.
 // It may end up being a value or a type.
@@ -154,3 +777,71 @@ func (n *StarExpr) DeepCopy(pos src.XPos) Node {
 	c.X = DeepCopy(pos, n.X)
 	return c
 }
+
+// A TypeAssertionExpr is a selector expression X.(Type).
+// Before type-checking, the type is Ntype.
+type TypeAssertExpr struct {
+	miniExpr
+	X     Node
+	Ntype Node  // TODO: Should be Ntype, but reused as address of type structure
+	Itab  Nodes // Itab[0] is itab
+}
+
+func NewTypeAssertExpr(pos src.XPos, x Node, typ Ntype) *TypeAssertExpr {
+	n := &TypeAssertExpr{X: x, Ntype: typ}
+	n.pos = pos
+	n.op = ODOTTYPE
+	return n
+}
+
+func (n *TypeAssertExpr) String() string                { return fmt.Sprint(n) }
+func (n *TypeAssertExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *TypeAssertExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *TypeAssertExpr) Left() Node                    { return n.X }
+func (n *TypeAssertExpr) SetLeft(x Node)                { n.X = x }
+func (n *TypeAssertExpr) Right() Node                   { return n.Ntype }
+func (n *TypeAssertExpr) SetRight(x Node)               { n.Ntype = x } // TODO: toNtype(x)
+func (n *TypeAssertExpr) List() Nodes                   { return n.Itab }
+func (n *TypeAssertExpr) PtrList() *Nodes               { return &n.Itab }
+func (n *TypeAssertExpr) SetList(x Nodes)               { n.Itab = x }
+
+func (n *TypeAssertExpr) SetOp(op Op) {
+	switch op {
+	default:
+		panic(n.no("SetOp " + op.String()))
+	case ODOTTYPE, ODOTTYPE2:
+		n.op = op
+	}
+}
+
+// A UnaryExpr is a unary expression Op X,
+// or Op(X) for a builtin function that does not end up being a call.
+type UnaryExpr struct {
+	miniExpr
+	X Node
+}
+
+func NewUnaryExpr(pos src.XPos, op Op, x Node) *UnaryExpr {
+	n := &UnaryExpr{X: x}
+	n.pos = pos
+	n.SetOp(op)
+	return n
+}
+
+func (n *UnaryExpr) String() string                { return fmt.Sprint(n) }
+func (n *UnaryExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *UnaryExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *UnaryExpr) Left() Node                    { return n.X }
+func (n *UnaryExpr) SetLeft(x Node)                { n.X = x }
+
+func (n *UnaryExpr) SetOp(op Op) {
+	switch op {
+	default:
+		panic(n.no("SetOp " + op.String()))
+	case OBITNOT, ONEG, ONOT, OPLUS, ORECV,
+		OALIGNOF, OCAP, OCLOSE, OIMAG, OLEN, ONEW,
+		OOFFSETOF, OPANIC, OREAL, OSIZEOF,
+		OCHECKNIL, OCFUNC, OIDATA, OITAB, ONEWOBJ, OSPTR, OVARDEF, OVARKILL, OVARLIVE:
+		n.op = op
+	}
+}
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 4a08cca359..a111471222 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -277,10 +277,6 @@ type fmtNodes struct {
 
 func (f *fmtNodes) Format(s fmt.State, verb rune) { f.x.format(s, verb, f.m) }
 
-func (n *node) Format(s fmt.State, verb rune) {
-	FmtNode(n, s, verb)
-}
-
 func FmtNode(n Node, s fmt.State, verb rune) {
 	nodeFormat(n, s, verb, FErr)
 }
@@ -1806,7 +1802,6 @@ func typeFormat(t *types.Type, s fmt.State, verb rune, mode FmtMode) {
 	}
 }
 
-func (n *node) String() string               { return fmt.Sprint(n) }
 func modeString(n Node, mode FmtMode) string { return mode.Sprint(n) }
 
 // "%L"  suffix with "(type %T)" where possible
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index a4d19c39f8..9b407b36c0 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -118,140 +118,6 @@ type Node interface {
 	CanBeAnSSASym()
 }
 
-var _ Node = (*node)(nil)
-
-// A Node is a single node in the syntax tree.
-// Actually the syntax tree is a syntax DAG, because there is only one
-// node with Op=ONAME for a given instance of a variable x.
-// The same is true for Op=OTYPE and Op=OLITERAL. See Node.mayBeShared.
-type node struct {
-	// Tree structure.
-	// Generic recursive walks should follow these fields.
-	left  Node
-	right Node
-	init  Nodes
-	body  Nodes
-	list  Nodes
-	rlist Nodes
-
-	// most nodes
-	typ  *types.Type
-	orig Node // original form, for printing, and tracking copies of ONAMEs
-
-	sym *types.Sym // various
-	opt interface{}
-
-	// Various. Usually an offset into a struct. For example:
-	// - ONAME nodes that refer to local variables use it to identify their stack frame position.
-	// - ODOT, ODOTPTR, and ORESULT use it to indicate offset relative to their base address.
-	// - OSTRUCTKEY uses it to store the named field's offset.
-	// - Named OLITERALs use it to store their ambient iota value.
-	// - OINLMARK stores an index into the inlTree data structure.
-	// - OCLOSURE uses it to store ambient iota value, if any.
-	// Possibly still more uses. If you find any, document them.
-	offset int64
-
-	pos src.XPos
-
-	flags bitset32
-
-	esc uint16 // EscXXX
-
-	op  Op
-	aux uint8
-}
-
-func (n *node) Left() Node            { return n.left }
-func (n *node) SetLeft(x Node)        { n.left = x }
-func (n *node) Right() Node           { return n.right }
-func (n *node) SetRight(x Node)       { n.right = x }
-func (n *node) Orig() Node            { return n.orig }
-func (n *node) SetOrig(x Node)        { n.orig = x }
-func (n *node) Type() *types.Type     { return n.typ }
-func (n *node) SetType(x *types.Type) { n.typ = x }
-func (n *node) Func() *Func           { return nil }
-func (n *node) Name() *Name           { return nil }
-func (n *node) Sym() *types.Sym       { return n.sym }
-func (n *node) SetSym(x *types.Sym)   { n.sym = x }
-func (n *node) Pos() src.XPos         { return n.pos }
-func (n *node) SetPos(x src.XPos)     { n.pos = x }
-func (n *node) Offset() int64         { return n.offset }
-func (n *node) SetOffset(x int64)     { n.offset = x }
-func (n *node) Esc() uint16           { return n.esc }
-func (n *node) SetEsc(x uint16)       { n.esc = x }
-func (n *node) Op() Op                { return n.op }
-func (n *node) Init() Nodes           { return n.init }
-func (n *node) SetInit(x Nodes)       { n.init = x }
-func (n *node) PtrInit() *Nodes       { return &n.init }
-func (n *node) Body() Nodes           { return n.body }
-func (n *node) SetBody(x Nodes)       { n.body = x }
-func (n *node) PtrBody() *Nodes       { return &n.body }
-func (n *node) List() Nodes           { return n.list }
-func (n *node) SetList(x Nodes)       { n.list = x }
-func (n *node) PtrList() *Nodes       { return &n.list }
-func (n *node) Rlist() Nodes          { return n.rlist }
-func (n *node) SetRlist(x Nodes)      { n.rlist = x }
-func (n *node) PtrRlist() *Nodes      { return &n.rlist }
-func (n *node) MarkReadonly()         { panic("node.MarkReadOnly") }
-func (n *node) Val() constant.Value   { panic("node.Val") }
-func (n *node) SetVal(constant.Value) { panic("node.SetVal") }
-func (n *node) Int64Val() int64       { panic("node.Int64Val") }
-func (n *node) CanInt64() bool        { return false }
-func (n *node) Uint64Val() uint64     { panic("node.Uint64Val") }
-func (n *node) BoolVal() bool         { panic("node.BoolVal") }
-func (n *node) StringVal() string     { panic("node.StringVal") }
-
-// node can be Ntype only because of OXDOT of undefined name.
-// When that moves into its own syntax, can drop this.
-func (n *node) CanBeNtype() {}
-
-func (n *node) SetOp(op Op) {
-	if !okForNod[op] {
-		panic("cannot node.SetOp " + op.String())
-	}
-	n.op = op
-}
-
-func (n *node) ResetAux() {
-	n.aux = 0
-}
-
-func (n *node) SubOp() Op {
-	switch n.Op() {
-	case OASOP, ONAME:
-	default:
-		base.Fatalf("unexpected op: %v", n.Op())
-	}
-	return Op(n.aux)
-}
-
-func (n *node) SetSubOp(op Op) {
-	switch n.Op() {
-	case OASOP, ONAME:
-	default:
-		base.Fatalf("unexpected op: %v", n.Op())
-	}
-	n.aux = uint8(op)
-}
-
-func (n *node) IndexMapLValue() bool {
-	if n.Op() != OINDEXMAP {
-		base.Fatalf("unexpected op: %v", n.Op())
-	}
-	return n.aux != 0
-}
-
-func (n *node) SetIndexMapLValue(b bool) {
-	if n.Op() != OINDEXMAP {
-		base.Fatalf("unexpected op: %v", n.Op())
-	}
-	if b {
-		n.aux = 1
-	} else {
-		n.aux = 0
-	}
-}
-
 func IsSynthetic(n Node) bool {
 	name := n.Sym().Name
 	return name[0] == '.' || name[0] == '~'
@@ -266,110 +132,6 @@ func IsAutoTmp(n Node) bool {
 	return n.Name().AutoTemp()
 }
 
-const (
-	nodeClass, _     = iota, 1 << iota // PPARAM, PAUTO, PEXTERN, etc; three bits; first in the list because frequently accessed
-	_, _                               // second nodeClass bit
-	_, _                               // third nodeClass bit
-	nodeWalkdef, _                     // tracks state during typecheckdef; 2 == loop detected; two bits
-	_, _                               // second nodeWalkdef bit
-	nodeTypecheck, _                   // tracks state during typechecking; 2 == loop detected; two bits
-	_, _                               // second nodeTypecheck bit
-	nodeInitorder, _                   // tracks state during init1; two bits
-	_, _                               // second nodeInitorder bit
-	_, nodeHasBreak
-	_, nodeNoInline  // used internally by inliner to indicate that a function call should not be inlined; set for OCALLFUNC and OCALLMETH only
-	_, nodeImplicit  // implicit OADDR or ODEREF; ++/-- statement represented as OASOP
-	_, nodeIsDDD     // is the argument variadic
-	_, nodeDiag      // already printed error about this
-	_, nodeColas     // OAS resulting from :=
-	_, nodeNonNil    // guaranteed to be non-nil
-	_, nodeTransient // storage can be reused immediately after this statement
-	_, nodeBounded   // bounds check unnecessary
-	_, nodeHasCall   // expression contains a function call
-	_, nodeLikely    // if statement condition likely
-)
-
-func (n *node) Class() Class     { return Class(n.flags.get3(nodeClass)) }
-func (n *node) Walkdef() uint8   { return n.flags.get2(nodeWalkdef) }
-func (n *node) Typecheck() uint8 { return n.flags.get2(nodeTypecheck) }
-func (n *node) Initorder() uint8 { return n.flags.get2(nodeInitorder) }
-
-func (n *node) HasBreak() bool  { return n.flags&nodeHasBreak != 0 }
-func (n *node) NoInline() bool  { return n.flags&nodeNoInline != 0 }
-func (n *node) Implicit() bool  { return n.flags&nodeImplicit != 0 }
-func (n *node) IsDDD() bool     { return n.flags&nodeIsDDD != 0 }
-func (n *node) Diag() bool      { return n.flags&nodeDiag != 0 }
-func (n *node) Colas() bool     { return n.flags&nodeColas != 0 }
-func (n *node) NonNil() bool    { return n.flags&nodeNonNil != 0 }
-func (n *node) Transient() bool { return n.flags&nodeTransient != 0 }
-func (n *node) Bounded() bool   { return n.flags&nodeBounded != 0 }
-func (n *node) HasCall() bool   { return n.flags&nodeHasCall != 0 }
-func (n *node) Likely() bool    { return n.flags&nodeLikely != 0 }
-
-func (n *node) SetClass(b Class)     { n.flags.set3(nodeClass, uint8(b)) }
-func (n *node) SetWalkdef(b uint8)   { n.flags.set2(nodeWalkdef, b) }
-func (n *node) SetTypecheck(b uint8) { n.flags.set2(nodeTypecheck, b) }
-func (n *node) SetInitorder(b uint8) { n.flags.set2(nodeInitorder, b) }
-
-func (n *node) SetHasBreak(b bool)  { n.flags.set(nodeHasBreak, b) }
-func (n *node) SetNoInline(b bool)  { n.flags.set(nodeNoInline, b) }
-func (n *node) SetImplicit(b bool)  { n.flags.set(nodeImplicit, b) }
-func (n *node) SetIsDDD(b bool)     { n.flags.set(nodeIsDDD, b) }
-func (n *node) SetDiag(b bool)      { n.flags.set(nodeDiag, b) }
-func (n *node) SetColas(b bool)     { n.flags.set(nodeColas, b) }
-func (n *node) SetTransient(b bool) { n.flags.set(nodeTransient, b) }
-func (n *node) SetHasCall(b bool)   { n.flags.set(nodeHasCall, b) }
-func (n *node) SetLikely(b bool)    { n.flags.set(nodeLikely, b) }
-
-// MarkNonNil marks a pointer n as being guaranteed non-nil,
-// on all code paths, at all times.
-// During conversion to SSA, non-nil pointers won't have nil checks
-// inserted before dereferencing. See state.exprPtr.
-func (n *node) MarkNonNil() {
-	if !n.Type().IsPtr() && !n.Type().IsUnsafePtr() {
-		base.Fatalf("MarkNonNil(%v), type %v", n, n.Type())
-	}
-	n.flags.set(nodeNonNil, true)
-}
-
-// SetBounded indicates whether operation n does not need safety checks.
-// When n is an index or slice operation, n does not need bounds checks.
-// When n is a dereferencing operation, n does not need nil checks.
-// When n is a makeslice+copy operation, n does not need length and cap checks.
-func (n *node) SetBounded(b bool) {
-	switch n.Op() {
-	case OINDEX, OSLICE, OSLICEARR, OSLICE3, OSLICE3ARR, OSLICESTR:
-		// No bounds checks needed.
-	case ODOTPTR, ODEREF:
-		// No nil check needed.
-	case OMAKESLICECOPY:
-		// No length and cap checks needed
-		// since new slice and copied over slice data have same length.
-	default:
-		base.Fatalf("SetBounded(%v)", n)
-	}
-	n.flags.set(nodeBounded, b)
-}
-
-// Opt returns the optimizer data for the node.
-func (n *node) Opt() interface{} {
-	return n.opt
-}
-
-// SetOpt sets the optimizer data for the node, which must not have been used with SetVal.
-// SetOpt(nil) is ignored for Vals to simplify call sites that are clearing Opts.
-func (n *node) SetOpt(x interface{}) {
-	n.opt = x
-}
-
-func (n *node) Iota() int64 {
-	return n.Offset()
-}
-
-func (n *node) SetIota(x int64) {
-	n.SetOffset(x)
-}
-
 // mayBeShared reports whether n may occur in multiple places in the AST.
 // Extra care must be taken when mutating such a node.
 func MayBeShared(n Node) bool {
@@ -380,10 +142,6 @@ func MayBeShared(n Node) bool {
 	return false
 }
 
-// The compiler needs *Node to be assignable to cmd/compile/internal/ssa.Sym.
-func (n *node) CanBeAnSSASym() {
-}
-
 //go:generate stringer -type=Op -trimprefix=O
 
 type Op uint8
@@ -922,91 +680,15 @@ func OrigSym(s *types.Sym) *types.Sym {
 	return s
 }
 
-// SliceBounds returns n's slice bounds: low, high, and max in expr[low:high:max].
-// n must be a slice expression. max is nil if n is a simple slice expression.
-func (n *node) SliceBounds() (low, high, max Node) {
-	if n.List().Len() == 0 {
-		return nil, nil, nil
-	}
-
-	switch n.Op() {
-	case OSLICE, OSLICEARR, OSLICESTR:
-		s := n.List().Slice()
-		return s[0], s[1], nil
-	case OSLICE3, OSLICE3ARR:
-		s := n.List().Slice()
-		return s[0], s[1], s[2]
-	}
-	base.Fatalf("SliceBounds op %v: %v", n.Op(), n)
-	return nil, nil, nil
-}
-
-// SetSliceBounds sets n's slice bounds, where n is a slice expression.
-// n must be a slice expression. If max is non-nil, n must be a full slice expression.
-func (n *node) SetSliceBounds(low, high, max Node) {
-	switch n.Op() {
-	case OSLICE, OSLICEARR, OSLICESTR:
-		if max != nil {
-			base.Fatalf("SetSliceBounds %v given three bounds", n.Op())
-		}
-		s := n.List().Slice()
-		if s == nil {
-			if low == nil && high == nil {
-				return
-			}
-			n.PtrList().Set2(low, high)
-			return
-		}
-		s[0] = low
-		s[1] = high
-		return
-	case OSLICE3, OSLICE3ARR:
-		s := n.List().Slice()
-		if s == nil {
-			if low == nil && high == nil && max == nil {
-				return
-			}
-			n.PtrList().Set3(low, high, max)
-			return
-		}
-		s[0] = low
-		s[1] = high
-		s[2] = max
-		return
-	}
-	base.Fatalf("SetSliceBounds op %v: %v", n.Op(), n)
-}
-
-// IsSlice3 reports whether o is a slice3 op (OSLICE3, OSLICE3ARR).
-// o must be a slicing op.
-func (o Op) IsSlice3() bool {
-	switch o {
-	case OSLICE, OSLICEARR, OSLICESTR:
-		return false
-	case OSLICE3, OSLICE3ARR:
-		return true
-	}
-	base.Fatalf("IsSlice3 op %v", o)
-	return false
-}
-
 func IsConst(n Node, ct constant.Kind) bool {
 	return ConstType(n) == ct
 }
 
-// rawcopy returns a shallow copy of n.
-// Note: copy or sepcopy (rather than rawcopy) is usually the
-//       correct choice (see comment with Node.copy, below).
-func (n *node) RawCopy() Node {
-	copy := *n
-	return &copy
-}
-
 // isNil reports whether n represents the universal untyped zero value "nil".
 func IsNil(n Node) bool {
 	// Check n.Orig because constant propagation may produce typed nil constants,
 	// which don't exist in the Go spec.
-	return Orig(n).Op() == ONIL
+	return n != nil && Orig(n).Op() == ONIL
 }
 
 func IsBlank(n Node) bool {
@@ -1027,8 +709,26 @@ func Nod(op Op, nleft, nright Node) Node {
 }
 
 func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
-	var n *node
 	switch op {
+	default:
+		panic("NodAt " + op.String())
+	case OADD, OAND, OANDAND, OANDNOT, ODIV, OEQ, OGE, OGT, OLE,
+		OLSH, OLT, OMOD, OMUL, ONE, OOR, OOROR, ORSH, OSUB, OXOR,
+		OCOPY, OCOMPLEX,
+		OEFACE:
+		return NewBinaryExpr(pos, op, nleft, nright)
+	case OADDR, OPTRLIT:
+		return NewAddrExpr(pos, nleft)
+	case OADDSTR:
+		return NewAddStringExpr(pos, nil)
+	case OARRAYLIT, OCOMPLIT, OMAPLIT, OSTRUCTLIT, OSLICELIT:
+		var typ Ntype
+		if nright != nil {
+			typ = nright.(Ntype)
+		}
+		n := NewCompLitExpr(pos, typ, nil)
+		n.SetOp(op)
+		return n
 	case OAS, OSELRECV:
 		n := NewAssignStmt(pos, nleft, nright)
 		n.SetOp(op)
@@ -1039,12 +739,27 @@ func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
 		return n
 	case OASOP:
 		return NewAssignOpStmt(pos, OXXX, nleft, nright)
+	case OBITNOT, ONEG, ONOT, OPLUS, ORECV,
+		OALIGNOF, OCAP, OCLOSE, OIMAG, OLEN, ONEW, ONEWOBJ,
+		OOFFSETOF, OPANIC, OREAL, OSIZEOF,
+		OCHECKNIL, OCFUNC, OIDATA, OITAB, OSPTR, OVARDEF, OVARKILL, OVARLIVE:
+		if nright != nil {
+			panic("unary nright")
+		}
+		return NewUnaryExpr(pos, op, nleft)
 	case OBLOCK:
 		return NewBlockStmt(pos, nil)
 	case OBREAK, OCONTINUE, OFALL, OGOTO, ORETJMP:
 		return NewBranchStmt(pos, op, nil)
+	case OCALL, OCALLFUNC, OCALLINTER, OCALLMETH,
+		OAPPEND, ODELETE, OGETG, OMAKE, OPRINT, OPRINTN, ORECOVER:
+		n := NewCallExpr(pos, nleft, nil)
+		n.SetOp(op)
+		return n
 	case OCASE:
 		return NewCaseStmt(pos, nil, nil)
+	case OCONV, OCONVIFACE, OCONVNOP, ORUNESTR:
+		return NewConvExpr(pos, op, nil, nleft)
 	case ODCL, ODCLCONST, ODCLTYPE:
 		return NewDecl(pos, op, nleft)
 	case ODCLFUNC:
@@ -1053,6 +768,18 @@ func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
 		return NewDeferStmt(pos, nleft)
 	case ODEREF:
 		return NewStarExpr(pos, nleft)
+	case ODOT, ODOTPTR, ODOTMETH, ODOTINTER, OXDOT:
+		n := NewSelectorExpr(pos, nleft, nil)
+		n.SetOp(op)
+		return n
+	case ODOTTYPE, ODOTTYPE2:
+		var typ Ntype
+		if nright != nil {
+			typ = nright.(Ntype)
+		}
+		n := NewTypeAssertExpr(pos, nleft, typ)
+		n.SetOp(op)
+		return n
 	case OEMPTY:
 		return NewEmptyStmt(pos)
 	case OFOR:
@@ -1061,140 +788,51 @@ func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
 		return NewGoStmt(pos, nleft)
 	case OIF:
 		return NewIfStmt(pos, nleft, nil, nil)
+	case OINDEX, OINDEXMAP:
+		n := NewIndexExpr(pos, nleft, nright)
+		n.SetOp(op)
+		return n
 	case OINLMARK:
 		return NewInlineMarkStmt(pos, types.BADWIDTH)
+	case OKEY, OSTRUCTKEY:
+		n := NewKeyExpr(pos, nleft, nright)
+		n.SetOp(op)
+		return n
 	case OLABEL:
 		return NewLabelStmt(pos, nil)
 	case OLITERAL, OTYPE, OIOTA:
 		n := newNameAt(pos, nil)
 		n.SetOp(op)
 		return n
+	case OMAKECHAN, OMAKEMAP, OMAKESLICE, OMAKESLICECOPY:
+		return NewMakeExpr(pos, op, nleft, nright)
+	case OMETHEXPR:
+		return NewMethodExpr(pos, op, nleft, nright)
+	case ONIL:
+		return NewNilExpr(pos)
 	case OPACK:
 		return NewPkgName(pos, nil, nil)
+	case OPAREN:
+		return NewParenExpr(pos, nleft)
 	case ORANGE:
 		return NewRangeStmt(pos, nil, nright, nil)
+	case ORESULT:
+		return NewResultExpr(pos, nil, types.BADWIDTH)
 	case ORETURN:
 		return NewReturnStmt(pos, nil)
 	case OSELECT:
 		return NewSelectStmt(pos, nil)
 	case OSEND:
 		return NewSendStmt(pos, nleft, nright)
+	case OSLICE, OSLICEARR, OSLICESTR, OSLICE3, OSLICE3ARR:
+		return NewSliceExpr(pos, op, nleft)
+	case OSLICEHEADER:
+		return NewSliceHeaderExpr(pos, nil, nleft, nil, nil)
 	case OSWITCH:
 		return NewSwitchStmt(pos, nleft, nil)
 	case OTYPESW:
 		return NewTypeSwitchGuard(pos, nleft, nright)
-	default:
-		n = new(node)
+	case OINLCALL:
+		return NewInlinedCallExpr(pos, nil, nil)
 	}
-	n.SetOp(op)
-	n.SetLeft(nleft)
-	n.SetRight(nright)
-	n.SetPos(pos)
-	n.SetOffset(types.BADWIDTH)
-	n.SetOrig(n)
-	return n
-}
-
-var okForNod = [OEND]bool{
-	OADD:           true,
-	OADDR:          true,
-	OADDSTR:        true,
-	OALIGNOF:       true,
-	OAND:           true,
-	OANDAND:        true,
-	OANDNOT:        true,
-	OAPPEND:        true,
-	OARRAYLIT:      true,
-	OBITNOT:        true,
-	OBYTES2STR:     true,
-	OBYTES2STRTMP:  true,
-	OCALL:          true,
-	OCALLFUNC:      true,
-	OCALLINTER:     true,
-	OCALLMETH:      true,
-	OCAP:           true,
-	OCFUNC:         true,
-	OCHECKNIL:      true,
-	OCLOSE:         true,
-	OCOMPLEX:       true,
-	OCOMPLIT:       true,
-	OCONV:          true,
-	OCONVIFACE:     true,
-	OCONVNOP:       true,
-	OCOPY:          true,
-	ODELETE:        true,
-	ODIV:           true,
-	ODOT:           true,
-	ODOTINTER:      true,
-	ODOTMETH:       true,
-	ODOTPTR:        true,
-	ODOTTYPE:       true,
-	ODOTTYPE2:      true,
-	OEFACE:         true,
-	OEQ:            true,
-	OGE:            true,
-	OGETG:          true,
-	OGT:            true,
-	OIDATA:         true,
-	OIMAG:          true,
-	OINDEX:         true,
-	OINDEXMAP:      true,
-	OINLCALL:       true,
-	OITAB:          true,
-	OKEY:           true,
-	OLE:            true,
-	OLEN:           true,
-	OLSH:           true,
-	OLT:            true,
-	OMAKE:          true,
-	OMAKECHAN:      true,
-	OMAKEMAP:       true,
-	OMAKESLICE:     true,
-	OMAKESLICECOPY: true,
-	OMAPLIT:        true,
-	OMETHEXPR:      true,
-	OMOD:           true,
-	OMUL:           true,
-	ONE:            true,
-	ONEG:           true,
-	ONEW:           true,
-	ONEWOBJ:        true,
-	ONIL:           true,
-	ONOT:           true,
-	OOFFSETOF:      true,
-	OOR:            true,
-	OOROR:          true,
-	OPANIC:         true,
-	OPAREN:         true,
-	OPLUS:          true,
-	OPRINT:         true,
-	OPRINTN:        true,
-	OPTRLIT:        true,
-	OREAL:          true,
-	ORECOVER:       true,
-	ORECV:          true,
-	ORESULT:        true,
-	ORSH:           true,
-	ORUNES2STR:     true,
-	ORUNESTR:       true,
-	OSIZEOF:        true,
-	OSLICE:         true,
-	OSLICE3:        true,
-	OSLICE3ARR:     true,
-	OSLICEARR:      true,
-	OSLICEHEADER:   true,
-	OSLICELIT:      true,
-	OSLICESTR:      true,
-	OSPTR:          true,
-	OSTR2BYTES:     true,
-	OSTR2BYTESTMP:  true,
-	OSTR2RUNES:     true,
-	OSTRUCTKEY:     true,
-	OSTRUCTLIT:     true,
-	OSUB:           true,
-	OVARDEF:        true,
-	OVARKILL:       true,
-	OVARLIVE:       true,
-	OXDOT:          true,
-	OXOR:           true,
 }
diff --git a/src/cmd/compile/internal/ir/sizeof_test.go b/src/cmd/compile/internal/ir/sizeof_test.go
index 2f31ba8d34..4a133cb999 100644
--- a/src/cmd/compile/internal/ir/sizeof_test.go
+++ b/src/cmd/compile/internal/ir/sizeof_test.go
@@ -22,7 +22,6 @@ func TestSizeof(t *testing.T) {
 	}{
 		{Func{}, 168, 288},
 		{Name{}, 128, 224},
-		{node{}, 80, 136},
 	}
 
 	for _, tt := range tests {
-- 
GitLab


From 45f3b646d42d73a8a54c81ada0ef1ffc11dce592 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 29 Nov 2020 23:06:02 -0500
Subject: [PATCH 0106/2400] [dev.regabi] cmd/compile: add OSTMTEXPR Op

This CL only adds the new constant, which is not safe for toolstash -cmp.

Change-Id: I774463a0ab5f57113d67a8888b6ac787be68510c
Reviewed-on: https://go-review.googlesource.com/c/go/+/274110
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/node.go      |  1 +
 src/cmd/compile/internal/ir/op_string.go | 87 ++++++++++++------------
 2 files changed, 45 insertions(+), 43 deletions(-)

diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 9b407b36c0..a93a87fb68 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -288,6 +288,7 @@ const (
 	OOFFSETOF    // unsafe.Offsetof(Left)
 	OSIZEOF      // unsafe.Sizeof(Left)
 	OMETHEXPR    // method expression
+	OSTMTEXPR    // statement expression (Init; Left)
 
 	// statements
 	OBLOCK // { List } (block of code)
diff --git a/src/cmd/compile/internal/ir/op_string.go b/src/cmd/compile/internal/ir/op_string.go
index eefdc0ee59..96eee43974 100644
--- a/src/cmd/compile/internal/ir/op_string.go
+++ b/src/cmd/compile/internal/ir/op_string.go
@@ -121,52 +121,53 @@ func _() {
 	_ = x[OOFFSETOF-110]
 	_ = x[OSIZEOF-111]
 	_ = x[OMETHEXPR-112]
-	_ = x[OBLOCK-113]
-	_ = x[OBREAK-114]
-	_ = x[OCASE-115]
-	_ = x[OCONTINUE-116]
-	_ = x[ODEFER-117]
-	_ = x[OEMPTY-118]
-	_ = x[OFALL-119]
-	_ = x[OFOR-120]
-	_ = x[OFORUNTIL-121]
-	_ = x[OGOTO-122]
-	_ = x[OIF-123]
-	_ = x[OLABEL-124]
-	_ = x[OGO-125]
-	_ = x[ORANGE-126]
-	_ = x[ORETURN-127]
-	_ = x[OSELECT-128]
-	_ = x[OSWITCH-129]
-	_ = x[OTYPESW-130]
-	_ = x[OTCHAN-131]
-	_ = x[OTMAP-132]
-	_ = x[OTSTRUCT-133]
-	_ = x[OTINTER-134]
-	_ = x[OTFUNC-135]
-	_ = x[OTARRAY-136]
-	_ = x[OTSLICE-137]
-	_ = x[OINLCALL-138]
-	_ = x[OEFACE-139]
-	_ = x[OITAB-140]
-	_ = x[OIDATA-141]
-	_ = x[OSPTR-142]
-	_ = x[OCLOSUREREAD-143]
-	_ = x[OCFUNC-144]
-	_ = x[OCHECKNIL-145]
-	_ = x[OVARDEF-146]
-	_ = x[OVARKILL-147]
-	_ = x[OVARLIVE-148]
-	_ = x[ORESULT-149]
-	_ = x[OINLMARK-150]
-	_ = x[ORETJMP-151]
-	_ = x[OGETG-152]
-	_ = x[OEND-153]
+	_ = x[OSTMTEXPR-113]
+	_ = x[OBLOCK-114]
+	_ = x[OBREAK-115]
+	_ = x[OCASE-116]
+	_ = x[OCONTINUE-117]
+	_ = x[ODEFER-118]
+	_ = x[OEMPTY-119]
+	_ = x[OFALL-120]
+	_ = x[OFOR-121]
+	_ = x[OFORUNTIL-122]
+	_ = x[OGOTO-123]
+	_ = x[OIF-124]
+	_ = x[OLABEL-125]
+	_ = x[OGO-126]
+	_ = x[ORANGE-127]
+	_ = x[ORETURN-128]
+	_ = x[OSELECT-129]
+	_ = x[OSWITCH-130]
+	_ = x[OTYPESW-131]
+	_ = x[OTCHAN-132]
+	_ = x[OTMAP-133]
+	_ = x[OTSTRUCT-134]
+	_ = x[OTINTER-135]
+	_ = x[OTFUNC-136]
+	_ = x[OTARRAY-137]
+	_ = x[OTSLICE-138]
+	_ = x[OINLCALL-139]
+	_ = x[OEFACE-140]
+	_ = x[OITAB-141]
+	_ = x[OIDATA-142]
+	_ = x[OSPTR-143]
+	_ = x[OCLOSUREREAD-144]
+	_ = x[OCFUNC-145]
+	_ = x[OCHECKNIL-146]
+	_ = x[OVARDEF-147]
+	_ = x[OVARKILL-148]
+	_ = x[OVARLIVE-149]
+	_ = x[ORESULT-150]
+	_ = x[OINLMARK-151]
+	_ = x[ORETJMP-152]
+	_ = x[OGETG-153]
+	_ = x[OEND-154]
 }
 
-const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNEWOBJNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECVSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRBLOCKBREAKCASECONTINUEDEFEREMPTYFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCLOSUREREADCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKRETJMPGETGEND"
+const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNEWOBJNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECVSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFEREMPTYFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCLOSUREREADCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKRETJMPGETGEND"
 
-var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 388, 391, 400, 403, 407, 415, 422, 431, 444, 447, 450, 453, 456, 459, 462, 468, 471, 477, 480, 486, 490, 493, 497, 502, 507, 513, 518, 522, 527, 535, 543, 549, 558, 569, 576, 580, 587, 594, 602, 606, 610, 614, 621, 628, 636, 642, 650, 655, 660, 664, 672, 677, 682, 686, 689, 697, 701, 703, 708, 710, 715, 721, 727, 733, 739, 744, 748, 755, 761, 766, 772, 778, 785, 790, 794, 799, 803, 814, 819, 827, 833, 840, 847, 853, 860, 866, 870, 873}
+var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 388, 391, 400, 403, 407, 415, 422, 431, 444, 447, 450, 453, 456, 459, 462, 468, 471, 477, 480, 486, 490, 493, 497, 502, 507, 513, 518, 522, 527, 535, 543, 549, 558, 569, 576, 580, 587, 594, 602, 606, 610, 614, 621, 628, 636, 642, 650, 658, 663, 668, 672, 680, 685, 690, 694, 697, 705, 709, 711, 716, 718, 723, 729, 735, 741, 747, 752, 756, 763, 769, 774, 780, 786, 793, 798, 802, 807, 811, 822, 827, 835, 841, 848, 855, 861, 868, 874, 878, 881}
 
 func (i Op) String() string {
 	if i >= Op(len(_Op_index)-1) {
-- 
GitLab


From dadfc80bc173ce4475bc76231de5259d797b0522 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 30 Nov 2020 20:34:25 -0800
Subject: [PATCH 0107/2400] [dev.regabi] cmd/compile: improve findTypeLoop

When checking if a defined type is part of a type loop, we can
short-circuit if it was defined in another package. We can assume any
package we import already successfully compiled, so any types it
contains cannot be part of a type loop.

This also allows us to simplify the logic for recursing into the type
used in the type declaration, because any defined type from this
package will have a properly setup node.

Change-Id: Ic024814d95533afd9e59f2103c8ddb22bd87e900
Reviewed-on: https://go-review.googlesource.com/c/go/+/274294
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/gc/align.go | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/gc/align.go b/src/cmd/compile/internal/gc/align.go
index 4f8f04d73d..ffae8dc27b 100644
--- a/src/cmd/compile/internal/gc/align.go
+++ b/src/cmd/compile/internal/gc/align.go
@@ -190,6 +190,13 @@ func findTypeLoop(t *types.Type, path *[]*types.Type) bool {
 		// recurse on the type expression used in the type
 		// declaration.
 
+		// Type imported from package, so it can't be part of
+		// a type loop (otherwise that package should have
+		// failed to compile).
+		if t.Sym.Pkg != ir.LocalPkg {
+			return false
+		}
+
 		for i, x := range *path {
 			if x == t {
 				*path = (*path)[i:]
@@ -198,10 +205,8 @@ func findTypeLoop(t *types.Type, path *[]*types.Type) bool {
 		}
 
 		*path = append(*path, t)
-		if n := ir.AsNode(t.Nod); n != nil {
-			if name := n.Name(); name != nil && name.Ntype != nil && findTypeLoop(name.Ntype.Type(), path) {
-				return true
-			}
+		if findTypeLoop(ir.AsNode(t.Nod).Name().Ntype.Type(), path) {
+			return true
 		}
 		*path = (*path)[:len(*path)-1]
 	} else {
-- 
GitLab


From fbc4c6a3ae5eb21c93d167e5eebdb07327aa5462 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 25 Nov 2020 15:20:30 -0800
Subject: [PATCH 0108/2400] [dev.typeparams] cmd/compile/internal/types2:
 remove support for type parameter pointer designation

An earlier version of the draft design supported pointer designation for
type parameters. Remove related code since we don't need it anymore.

Change-Id: I0d9e8c5f02a9a6745ff7ee15b8267a99ab1529e1
Reviewed-on: https://go-review.googlesource.com/c/go/+/273327
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/builtins.go   |  2 +-
 src/cmd/compile/internal/types2/decl.go       | 12 +++---------
 src/cmd/compile/internal/types2/lookup.go     |  2 +-
 src/cmd/compile/internal/types2/subst.go      | 17 ++---------------
 src/cmd/compile/internal/types2/type.go       |  5 ++---
 src/cmd/compile/internal/types2/typestring.go |  3 ---
 src/cmd/compile/internal/types2/typexpr.go    |  4 ----
 7 files changed, 9 insertions(+), 36 deletions(-)

diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go
index c1706fd873..6ad84f4354 100644
--- a/src/cmd/compile/internal/types2/builtins.go
+++ b/src/cmd/compile/internal/types2/builtins.go
@@ -727,7 +727,7 @@ func (check *Checker) applyTypeFunc(f func(Type) Type, x Type) Type {
 
 		// construct a suitable new type parameter
 		tpar := NewTypeName(nopos, nil /* = Universe pkg */, "<type parameter>", nil)
-		ptyp := check.NewTypeParam(tp.ptr, tpar, 0, &emptyInterface) // assigns type to tpar as a side-effect
+		ptyp := check.NewTypeParam(tpar, 0, &emptyInterface) // assigns type to tpar as a side-effect
 		tsum := NewSum(rtypes)
 		ptyp.bound = &Interface{types: tsum, allMethods: markComplete, allTypes: tsum}
 
diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index ef8dc7a245..ff37d85c6f 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -734,15 +734,9 @@ func (check *Checker) collectTypeParams(list []*syntax.Field) (tparams []*TypeNa
 }
 
 func (check *Checker) declareTypeParam(tparams []*TypeName, name *syntax.Name) []*TypeName {
-	var ptr bool
-	nstr := name.Value
-	if len(nstr) > 0 && nstr[0] == '*' {
-		ptr = true
-		nstr = nstr[1:]
-	}
-	tpar := NewTypeName(name.Pos(), check.pkg, nstr, nil)
-	check.NewTypeParam(ptr, tpar, len(tparams), &emptyInterface) // assigns type to tpar as a side-effect
-	check.declare(check.scope, name, tpar, check.scope.pos)      // TODO(gri) check scope position
+	tpar := NewTypeName(name.Pos(), check.pkg, name.Value, nil)
+	check.NewTypeParam(tpar, len(tparams), &emptyInterface) // assigns type to tpar as a side-effect
+	check.declare(check.scope, name, tpar, check.scope.pos) // TODO(gri) check scope position
 	tparams = append(tparams, tpar)
 
 	if check.conf.Trace {
diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go
index 277212c568..e1e7b5814d 100644
--- a/src/cmd/compile/internal/types2/lookup.go
+++ b/src/cmd/compile/internal/types2/lookup.go
@@ -222,7 +222,7 @@ func (check *Checker) rawLookupFieldOrMethod(T Type, addressable bool, pkg *Pack
 			//        is shorthand for (&x).m()".
 			if f, _ := obj.(*Func); f != nil {
 				// determine if method has a pointer receiver
-				hasPtrRecv := tpar == nil && ptrRecv(f) || tpar != nil && tpar.ptr
+				hasPtrRecv := tpar == nil && ptrRecv(f)
 				if hasPtrRecv && !indirect && !addressable {
 					return nil, nil, true // pointer/addressable receiver required
 				}
diff --git a/src/cmd/compile/internal/types2/subst.go b/src/cmd/compile/internal/types2/subst.go
index 27c907de10..e64e24a8a1 100644
--- a/src/cmd/compile/internal/types2/subst.go
+++ b/src/cmd/compile/internal/types2/subst.go
@@ -143,27 +143,14 @@ func (check *Checker) instantiate(pos syntax.Pos, typ Type, targs []Type, poslis
 		// - check only if we have methods
 		check.completeInterface(nopos, iface)
 		if len(iface.allMethods) > 0 {
-			// If the type argument is a type parameter itself, its pointer designation
-			// must match the pointer designation of the callee's type parameter.
 			// If the type argument is a pointer to a type parameter, the type argument's
 			// method set is empty.
 			// TODO(gri) is this what we want? (spec question)
-			if tparg := targ.TypeParam(); tparg != nil {
-				if tparg.ptr != tpar.ptr {
-					check.errorf(pos, "pointer designation mismatch")
-					break
-				}
-			} else if base, isPtr := deref(targ); isPtr && base.TypeParam() != nil {
+			if base, isPtr := deref(targ); isPtr && base.TypeParam() != nil {
 				check.errorf(pos, "%s has no methods", targ)
 				break
 			}
-			// If a type parameter is marked as a pointer type, the type bound applies
-			// to a pointer of the type argument.
-			actual := targ
-			if tpar.ptr {
-				actual = NewPointer(targ)
-			}
-			if m, wrong := check.missingMethod(actual, iface, true); m != nil {
+			if m, wrong := check.missingMethod(targ, iface, true); m != nil {
 				// TODO(gri) needs to print updated name to avoid major confusion in error message!
 				//           (print warning for now)
 				// check.softErrorf(pos, "%s does not satisfy %s (warning: name not updated) = %s (missing method %s)", targ, tpar.bound, iface, m)
diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
index c26d243f3c..1bfde41159 100644
--- a/src/cmd/compile/internal/types2/type.go
+++ b/src/cmd/compile/internal/types2/type.go
@@ -832,7 +832,6 @@ func (t *Named) AddMethod(m *Func) {
 type TypeParam struct {
 	check *Checker  // for lazy type bound completion
 	id    uint64    // unique id
-	ptr   bool      // pointer designation
 	obj   *TypeName // corresponding type name
 	index int       // parameter index
 	bound Type      // *Named or *Interface; underlying type is always *Interface
@@ -840,9 +839,9 @@ type TypeParam struct {
 }
 
 // NewTypeParam returns a new TypeParam.
-func (check *Checker) NewTypeParam(ptr bool, obj *TypeName, index int, bound Type) *TypeParam {
+func (check *Checker) NewTypeParam(obj *TypeName, index int, bound Type) *TypeParam {
 	assert(bound != nil)
-	typ := &TypeParam{check: check, id: check.nextId, ptr: ptr, obj: obj, index: index, bound: bound}
+	typ := &TypeParam{check: check, id: check.nextId, obj: obj, index: index, bound: bound}
 	check.nextId++
 	if obj.typ == nil {
 		obj.typ = typ
diff --git a/src/cmd/compile/internal/types2/typestring.go b/src/cmd/compile/internal/types2/typestring.go
index 98021797a1..6b6d7ad2be 100644
--- a/src/cmd/compile/internal/types2/typestring.go
+++ b/src/cmd/compile/internal/types2/typestring.go
@@ -350,9 +350,6 @@ func writeTParamList(buf *bytes.Buffer, list []*TypeName, qf Qualifier, visited
 		prev = b
 
 		if t, _ := p.typ.(*TypeParam); t != nil {
-			if t.ptr {
-				buf.WriteByte('*')
-			}
 			writeType(buf, t, qf, visited)
 		} else {
 			buf.WriteString(p.name)
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 0edd7731fa..1adf967859 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -307,12 +307,8 @@ func (check *Checker) funcType(sig *Signature, recvPar *syntax.Field, tparams []
 			// - only do this if we have the right number (otherwise an error is reported elsewhere)
 			if len(sig.rparams) == len(recvTParams) {
 				// We have a list of *TypeNames but we need a list of Types.
-				// While creating this list, also update type parameter pointer designation
-				// for each (*TypeParam) list entry, by copying the information from the
-				// receiver base type's type parameters.
 				list := make([]Type, len(sig.rparams))
 				for i, t := range sig.rparams {
-					t.typ.(*TypeParam).ptr = recvTParams[i].typ.(*TypeParam).ptr
 					list[i] = t.typ
 				}
 				for i, tname := range sig.rparams {
-- 
GitLab


From 4da41fb3f8aa2e81b6ed371b617643042ba5e170 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 30 Nov 2020 21:18:48 -0500
Subject: [PATCH 0109/2400] [dev.regabi] cmd/compile: use ir.Copy instead of
 direct use of RawCopy
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The ONIL export bug happened because the logic about
maintaining an “implicit” orig pointer in the comments
around ir.Orig only applies to Copy and SepCopy, not to
direct use of RawCopy. I'd forgotten those could exist.

The sole direct use of RawCopy was for the OLITERAL/ONIL case.
The ONIL is now provably indistinguishable from Copy, since
NilExpr does not have an explicit Orig field, so for NilExpr
RawCopy and Copy are the same.
The OLITERAL is not, but we can reconstruct the effect
with Copy+SetOrig to be explicit that we need the orig link.

The next CL will unexport RawCopy.

Also fix a typo in MapType doc comment.

Passes buildall w/ toolstash -cmp.

Change-Id: I876a85ff188e6d1cd4c0dfa385be32482e0de0d4
Reviewed-on: https://go-review.googlesource.com/c/go/+/274292
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/gc/const.go | 7 ++++++-
 src/cmd/compile/internal/ir/type.go  | 2 +-
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 3c161d8e12..4dee373bfa 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -118,7 +118,12 @@ func convlit1(n ir.Node, t *types.Type, explicit bool, context func() string) ir
 	if n.Op() == ir.OLITERAL || n.Op() == ir.ONIL {
 		// Can't always set n.Type directly on OLITERAL nodes.
 		// See discussion on CL 20813.
-		n = n.RawCopy()
+		old := n
+		n = ir.Copy(old)
+		if old.Op() == ir.OLITERAL {
+			// Keep untyped constants in their original untyped syntax for error messages.
+			n.(ir.OrigNode).SetOrig(old)
+		}
 	}
 
 	// Nil is technically not a constant, so handle it specially.
diff --git a/src/cmd/compile/internal/ir/type.go b/src/cmd/compile/internal/ir/type.go
index 39411ed431..519a7291b0 100644
--- a/src/cmd/compile/internal/ir/type.go
+++ b/src/cmd/compile/internal/ir/type.go
@@ -92,7 +92,7 @@ func (n *ChanType) DeepCopy(pos src.XPos) Node {
 	return NewChanType(n.posOr(pos), DeepCopy(pos, n.Elem), n.Dir)
 }
 
-// A MapType represents a map[Key]Value type syntax.u
+// A MapType represents a map[Key]Value type syntax.
 type MapType struct {
 	miniType
 	Key  Node
-- 
GitLab


From ecff7628ead3b0191f5fe191864ee47fcc90bb92 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 30 Nov 2020 21:20:45 -0500
Subject: [PATCH 0110/2400] [dev.regabi] cmd/compile: unexport Node.RawCopy

RawCopy breaks the invariant that ir.Orig depends on for
allowing nodes to omit keeping their own orig fields.
Avoid surprises by unexporting it.

The only use in package gc was removed in the previous CL.
This one is a straight global search and replace RawCopy -> rawCopy.

Change-Id: Ia99c0f4665bf7ed4f878cc44456d5fbdf33bab8d
Reviewed-on: https://go-review.googlesource.com/c/go/+/274293
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ir/copy.go |  4 +--
 src/cmd/compile/internal/ir/expr.go | 46 ++++++++++++++---------------
 src/cmd/compile/internal/ir/func.go |  2 +-
 src/cmd/compile/internal/ir/mini.go |  2 +-
 src/cmd/compile/internal/ir/name.go |  4 +--
 src/cmd/compile/internal/ir/node.go |  2 +-
 src/cmd/compile/internal/ir/stmt.go | 40 ++++++++++++-------------
 src/cmd/compile/internal/ir/type.go | 16 +++++-----
 8 files changed, 58 insertions(+), 58 deletions(-)

diff --git a/src/cmd/compile/internal/ir/copy.go b/src/cmd/compile/internal/ir/copy.go
index 7a1611d0d6..a356074bb8 100644
--- a/src/cmd/compile/internal/ir/copy.go
+++ b/src/cmd/compile/internal/ir/copy.go
@@ -43,7 +43,7 @@ func Orig(n Node) Node {
 // SepCopy returns a separate shallow copy of n,
 // breaking any Orig link to any other nodes.
 func SepCopy(n Node) Node {
-	n = n.RawCopy()
+	n = n.rawCopy()
 	if n, ok := n.(OrigNode); ok {
 		n.SetOrig(n)
 	}
@@ -57,7 +57,7 @@ func SepCopy(n Node) Node {
 // The specific semantics surrounding Orig are subtle but right for most uses.
 // See issues #26855 and #27765 for pitfalls.
 func Copy(n Node) Node {
-	copy := n.RawCopy()
+	copy := n.rawCopy()
 	if n, ok := n.(OrigNode); ok && n.Orig() == n {
 		copy.(OrigNode).SetOrig(copy)
 	}
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index be9f486682..87593520a1 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -75,7 +75,7 @@ func NewAddStringExpr(pos src.XPos, list []Node) *AddStringExpr {
 
 func (n *AddStringExpr) String() string                { return fmt.Sprint(n) }
 func (n *AddStringExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *AddStringExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *AddStringExpr) rawCopy() Node                 { c := *n; return &c }
 func (n *AddStringExpr) List() Nodes                   { return n.list }
 func (n *AddStringExpr) PtrList() *Nodes               { return &n.list }
 func (n *AddStringExpr) SetList(x Nodes)               { n.list = x }
@@ -97,7 +97,7 @@ func NewAddrExpr(pos src.XPos, x Node) *AddrExpr {
 
 func (n *AddrExpr) String() string                { return fmt.Sprint(n) }
 func (n *AddrExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *AddrExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *AddrExpr) rawCopy() Node                 { c := *n; return &c }
 func (n *AddrExpr) Left() Node                    { return n.X }
 func (n *AddrExpr) SetLeft(x Node)                { n.X = x }
 func (n *AddrExpr) Right() Node                   { return n.Alloc }
@@ -129,7 +129,7 @@ func NewBinaryExpr(pos src.XPos, op Op, x, y Node) *BinaryExpr {
 
 func (n *BinaryExpr) String() string                { return fmt.Sprint(n) }
 func (n *BinaryExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *BinaryExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *BinaryExpr) rawCopy() Node                 { c := *n; return &c }
 func (n *BinaryExpr) Left() Node                    { return n.X }
 func (n *BinaryExpr) SetLeft(x Node)                { n.X = x }
 func (n *BinaryExpr) Right() Node                   { return n.Y }
@@ -170,7 +170,7 @@ func NewCallExpr(pos src.XPos, fun Node, args []Node) *CallExpr {
 
 func (n *CallExpr) String() string                { return fmt.Sprint(n) }
 func (n *CallExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *CallExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *CallExpr) rawCopy() Node                 { c := *n; return &c }
 func (n *CallExpr) Orig() Node                    { return n.orig }
 func (n *CallExpr) SetOrig(x Node)                { n.orig = x }
 func (n *CallExpr) Left() Node                    { return n.X }
@@ -218,7 +218,7 @@ func NewCallPartExpr(pos src.XPos, x Node, method *Name, fn *Func) *CallPartExpr
 
 func (n *CallPartExpr) String() string                { return fmt.Sprint(n) }
 func (n *CallPartExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *CallPartExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *CallPartExpr) rawCopy() Node                 { c := *n; return &c }
 func (n *CallPartExpr) Func() *Func                   { return n.fn }
 func (n *CallPartExpr) Left() Node                    { return n.X }
 func (n *CallPartExpr) Right() Node                   { return n.Method }
@@ -240,7 +240,7 @@ func NewClosureExpr(pos src.XPos, fn *Func) *ClosureExpr {
 
 func (n *ClosureExpr) String() string                { return fmt.Sprint(n) }
 func (n *ClosureExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ClosureExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *ClosureExpr) rawCopy() Node                 { c := *n; return &c }
 func (n *ClosureExpr) Func() *Func                   { return n.fn }
 
 // A ClosureRead denotes reading a variable stored within a closure struct.
@@ -258,7 +258,7 @@ func NewClosureRead(typ *types.Type, offset int64) *ClosureRead {
 
 func (n *ClosureRead) String() string                { return fmt.Sprint(n) }
 func (n *ClosureRead) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ClosureRead) RawCopy() Node                 { c := *n; return &c }
+func (n *ClosureRead) rawCopy() Node                 { c := *n; return &c }
 func (n *ClosureRead) Type() *types.Type             { return n.typ }
 func (n *ClosureRead) Offset() int64                 { return n.offset }
 
@@ -282,7 +282,7 @@ func NewCompLitExpr(pos src.XPos, typ Ntype, list []Node) *CompLitExpr {
 
 func (n *CompLitExpr) String() string                { return fmt.Sprint(n) }
 func (n *CompLitExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *CompLitExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *CompLitExpr) rawCopy() Node                 { c := *n; return &c }
 func (n *CompLitExpr) Orig() Node                    { return n.orig }
 func (n *CompLitExpr) SetOrig(x Node)                { n.orig = x }
 func (n *CompLitExpr) Right() Node                   { return n.Ntype }
@@ -319,7 +319,7 @@ func NewConvExpr(pos src.XPos, op Op, typ *types.Type, x Node) *ConvExpr {
 
 func (n *ConvExpr) String() string                { return fmt.Sprint(n) }
 func (n *ConvExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ConvExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *ConvExpr) rawCopy() Node                 { c := *n; return &c }
 func (n *ConvExpr) Orig() Node                    { return n.orig }
 func (n *ConvExpr) SetOrig(x Node)                { n.orig = x }
 func (n *ConvExpr) Left() Node                    { return n.X }
@@ -351,7 +351,7 @@ func NewIndexExpr(pos src.XPos, x, index Node) *IndexExpr {
 
 func (n *IndexExpr) String() string                { return fmt.Sprint(n) }
 func (n *IndexExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *IndexExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *IndexExpr) rawCopy() Node                 { c := *n; return &c }
 func (n *IndexExpr) Left() Node                    { return n.X }
 func (n *IndexExpr) SetLeft(x Node)                { n.X = x }
 func (n *IndexExpr) Right() Node                   { return n.Index }
@@ -388,7 +388,7 @@ func NewKeyExpr(pos src.XPos, key, value Node) *KeyExpr {
 
 func (n *KeyExpr) String() string                { return fmt.Sprint(n) }
 func (n *KeyExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *KeyExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *KeyExpr) rawCopy() Node                 { c := *n; return &c }
 func (n *KeyExpr) Left() Node                    { return n.Key }
 func (n *KeyExpr) SetLeft(x Node)                { n.Key = x }
 func (n *KeyExpr) Right() Node                   { return n.Value }
@@ -425,7 +425,7 @@ func NewInlinedCallExpr(pos src.XPos, body, retvars []Node) *InlinedCallExpr {
 
 func (n *InlinedCallExpr) String() string                { return fmt.Sprint(n) }
 func (n *InlinedCallExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *InlinedCallExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *InlinedCallExpr) rawCopy() Node                 { c := *n; return &c }
 func (n *InlinedCallExpr) Body() Nodes                   { return n.body }
 func (n *InlinedCallExpr) PtrBody() *Nodes               { return &n.body }
 func (n *InlinedCallExpr) SetBody(x Nodes)               { n.body = x }
@@ -451,7 +451,7 @@ func NewMakeExpr(pos src.XPos, op Op, len, cap Node) *MakeExpr {
 
 func (n *MakeExpr) String() string                { return fmt.Sprint(n) }
 func (n *MakeExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *MakeExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *MakeExpr) rawCopy() Node                 { c := *n; return &c }
 func (n *MakeExpr) Left() Node                    { return n.Len }
 func (n *MakeExpr) SetLeft(x Node)                { n.Len = x }
 func (n *MakeExpr) Right() Node                   { return n.Cap }
@@ -486,7 +486,7 @@ func NewMethodExpr(pos src.XPos, op Op, x, m Node) *MethodExpr {
 
 func (n *MethodExpr) String() string                { return fmt.Sprint(n) }
 func (n *MethodExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *MethodExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *MethodExpr) rawCopy() Node                 { c := *n; return &c }
 func (n *MethodExpr) Left() Node                    { return n.X }
 func (n *MethodExpr) SetLeft(x Node)                { n.X = x }
 func (n *MethodExpr) Right() Node                   { return n.M }
@@ -514,7 +514,7 @@ func NewNilExpr(pos src.XPos) *NilExpr {
 
 func (n *NilExpr) String() string                { return fmt.Sprint(n) }
 func (n *NilExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *NilExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *NilExpr) rawCopy() Node                 { c := *n; return &c }
 func (n *NilExpr) Sym() *types.Sym               { return n.sym }
 func (n *NilExpr) SetSym(x *types.Sym)           { n.sym = x }
 
@@ -534,7 +534,7 @@ func NewParenExpr(pos src.XPos, x Node) *ParenExpr {
 
 func (n *ParenExpr) String() string                { return fmt.Sprint(n) }
 func (n *ParenExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ParenExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *ParenExpr) rawCopy() Node                 { c := *n; return &c }
 func (n *ParenExpr) Left() Node                    { return n.X }
 func (n *ParenExpr) SetLeft(x Node)                { n.X = x }
 
@@ -566,7 +566,7 @@ func NewResultExpr(pos src.XPos, typ *types.Type, offset int64) *ResultExpr {
 
 func (n *ResultExpr) String() string                { return fmt.Sprint(n) }
 func (n *ResultExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ResultExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *ResultExpr) rawCopy() Node                 { c := *n; return &c }
 func (n *ResultExpr) Offset() int64                 { return n.offset }
 func (n *ResultExpr) SetOffset(x int64)             { n.offset = x }
 
@@ -597,7 +597,7 @@ func (n *SelectorExpr) SetOp(op Op) {
 
 func (n *SelectorExpr) String() string                { return fmt.Sprint(n) }
 func (n *SelectorExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *SelectorExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *SelectorExpr) rawCopy() Node                 { c := *n; return &c }
 func (n *SelectorExpr) Left() Node                    { return n.X }
 func (n *SelectorExpr) SetLeft(x Node)                { n.X = x }
 func (n *SelectorExpr) Sym() *types.Sym               { return n.Sel }
@@ -625,7 +625,7 @@ func NewSliceExpr(pos src.XPos, op Op, x Node) *SliceExpr {
 
 func (n *SliceExpr) String() string                { return fmt.Sprint(n) }
 func (n *SliceExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *SliceExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *SliceExpr) rawCopy() Node                 { c := *n; return &c }
 func (n *SliceExpr) Left() Node                    { return n.X }
 func (n *SliceExpr) SetLeft(x Node)                { n.X = x }
 func (n *SliceExpr) List() Nodes                   { return n.list }
@@ -727,7 +727,7 @@ func NewSliceHeaderExpr(pos src.XPos, typ *types.Type, ptr, len, cap Node) *Slic
 
 func (n *SliceHeaderExpr) String() string                { return fmt.Sprint(n) }
 func (n *SliceHeaderExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *SliceHeaderExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *SliceHeaderExpr) rawCopy() Node                 { c := *n; return &c }
 func (n *SliceHeaderExpr) Left() Node                    { return n.Ptr }
 func (n *SliceHeaderExpr) SetLeft(x Node)                { n.Ptr = x }
 func (n *SliceHeaderExpr) List() Nodes                   { return n.lenCap }
@@ -750,7 +750,7 @@ func NewStarExpr(pos src.XPos, x Node) *StarExpr {
 
 func (n *StarExpr) String() string                { return fmt.Sprint(n) }
 func (n *StarExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *StarExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *StarExpr) rawCopy() Node                 { c := *n; return &c }
 func (n *StarExpr) Left() Node                    { return n.X }
 func (n *StarExpr) SetLeft(x Node)                { n.X = x }
 
@@ -796,7 +796,7 @@ func NewTypeAssertExpr(pos src.XPos, x Node, typ Ntype) *TypeAssertExpr {
 
 func (n *TypeAssertExpr) String() string                { return fmt.Sprint(n) }
 func (n *TypeAssertExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *TypeAssertExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *TypeAssertExpr) rawCopy() Node                 { c := *n; return &c }
 func (n *TypeAssertExpr) Left() Node                    { return n.X }
 func (n *TypeAssertExpr) SetLeft(x Node)                { n.X = x }
 func (n *TypeAssertExpr) Right() Node                   { return n.Ntype }
@@ -830,7 +830,7 @@ func NewUnaryExpr(pos src.XPos, op Op, x Node) *UnaryExpr {
 
 func (n *UnaryExpr) String() string                { return fmt.Sprint(n) }
 func (n *UnaryExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *UnaryExpr) RawCopy() Node                 { c := *n; return &c }
+func (n *UnaryExpr) rawCopy() Node                 { c := *n; return &c }
 func (n *UnaryExpr) Left() Node                    { return n.X }
 func (n *UnaryExpr) SetLeft(x Node)                { n.X = x }
 
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 9d2a8ad94b..3fc8597ef0 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -116,7 +116,7 @@ func NewFunc(pos src.XPos) *Func {
 
 func (f *Func) String() string                { return fmt.Sprint(f) }
 func (f *Func) Format(s fmt.State, verb rune) { FmtNode(f, s, verb) }
-func (f *Func) RawCopy() Node                 { panic(f.no("RawCopy")) }
+func (f *Func) rawCopy() Node                 { panic(f.no("rawCopy")) }
 func (f *Func) Func() *Func                   { return f }
 func (f *Func) Body() Nodes                   { return f.body }
 func (f *Func) PtrBody() *Nodes               { return &f.body }
diff --git a/src/cmd/compile/internal/ir/mini.go b/src/cmd/compile/internal/ir/mini.go
index d73ec4ecd5..909ca0220d 100644
--- a/src/cmd/compile/internal/ir/mini.go
+++ b/src/cmd/compile/internal/ir/mini.go
@@ -19,7 +19,7 @@ import (
 // must at the least provide:
 //
 //	func (n *MyNode) String() string { return fmt.Sprint(n) }
-//	func (n *MyNode) RawCopy() Node { c := *n; return &c }
+//	func (n *MyNode) rawCopy() Node { c := *n; return &c }
 //	func (n *MyNode) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 //
 // The embedding struct should also fill in n.op in its constructor,
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 1bc6bea3b6..76abb454ee 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -143,7 +143,7 @@ func newNameAt(pos src.XPos, sym *types.Sym) *Name {
 
 func (n *Name) String() string                { return fmt.Sprint(n) }
 func (n *Name) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *Name) RawCopy() Node                 { c := *n; return &c }
+func (n *Name) rawCopy() Node                 { c := *n; return &c }
 func (n *Name) Name() *Name                   { return n }
 func (n *Name) Sym() *types.Sym               { return n.sym }
 func (n *Name) SetSym(x *types.Sym)           { n.sym = x }
@@ -370,7 +370,7 @@ type PkgName struct {
 
 func (p *PkgName) String() string                { return fmt.Sprint(p) }
 func (p *PkgName) Format(s fmt.State, verb rune) { FmtNode(p, s, verb) }
-func (p *PkgName) RawCopy() Node                 { c := *p; return &c }
+func (p *PkgName) rawCopy() Node                 { c := *p; return &c }
 func (p *PkgName) Sym() *types.Sym               { return p.sym }
 
 func (*PkgName) CanBeNtype() {}
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index a93a87fb68..a7144eee44 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -28,7 +28,7 @@ type Node interface {
 	SetPos(x src.XPos)
 
 	// For making copies. Mainly used by Copy and SepCopy.
-	RawCopy() Node
+	rawCopy() Node
 
 	// Abstract graph structure, for generic traversals.
 	Op() Op
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index 2516835513..91714e38e3 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -31,7 +31,7 @@ func NewDecl(pos src.XPos, op Op, x Node) *Decl {
 
 func (n *Decl) String() string                { return fmt.Sprint(n) }
 func (n *Decl) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *Decl) RawCopy() Node                 { c := *n; return &c }
+func (n *Decl) rawCopy() Node                 { c := *n; return &c }
 func (n *Decl) Left() Node                    { return n.X }
 func (n *Decl) SetLeft(x Node)                { n.X = x }
 
@@ -70,7 +70,7 @@ func NewAssignListStmt(pos src.XPos, lhs, rhs []Node) *AssignListStmt {
 
 func (n *AssignListStmt) String() string                { return fmt.Sprint(n) }
 func (n *AssignListStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *AssignListStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *AssignListStmt) rawCopy() Node                 { c := *n; return &c }
 
 func (n *AssignListStmt) List() Nodes       { return n.Lhs }
 func (n *AssignListStmt) PtrList() *Nodes   { return &n.Lhs }
@@ -112,7 +112,7 @@ func NewAssignStmt(pos src.XPos, x, y Node) *AssignStmt {
 
 func (n *AssignStmt) String() string                { return fmt.Sprint(n) }
 func (n *AssignStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *AssignStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *AssignStmt) rawCopy() Node                 { c := *n; return &c }
 
 func (n *AssignStmt) Left() Node        { return n.X }
 func (n *AssignStmt) SetLeft(x Node)    { n.X = x }
@@ -151,7 +151,7 @@ func NewAssignOpStmt(pos src.XPos, op Op, x, y Node) *AssignOpStmt {
 
 func (n *AssignOpStmt) String() string                { return fmt.Sprint(n) }
 func (n *AssignOpStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *AssignOpStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *AssignOpStmt) rawCopy() Node                 { c := *n; return &c }
 
 func (n *AssignOpStmt) Left() Node            { return n.X }
 func (n *AssignOpStmt) SetLeft(x Node)        { n.X = x }
@@ -180,7 +180,7 @@ func NewBlockStmt(pos src.XPos, list []Node) *BlockStmt {
 
 func (n *BlockStmt) String() string                { return fmt.Sprint(n) }
 func (n *BlockStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *BlockStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *BlockStmt) rawCopy() Node                 { c := *n; return &c }
 func (n *BlockStmt) List() Nodes                   { return n.list }
 func (n *BlockStmt) PtrList() *Nodes               { return &n.list }
 func (n *BlockStmt) SetList(x Nodes)               { n.list = x }
@@ -209,7 +209,7 @@ func NewBranchStmt(pos src.XPos, op Op, label *types.Sym) *BranchStmt {
 
 func (n *BranchStmt) String() string                { return fmt.Sprint(n) }
 func (n *BranchStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *BranchStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *BranchStmt) rawCopy() Node                 { c := *n; return &c }
 func (n *BranchStmt) Sym() *types.Sym               { return n.Label }
 func (n *BranchStmt) SetSym(sym *types.Sym)         { n.Label = sym }
 
@@ -233,7 +233,7 @@ func NewCaseStmt(pos src.XPos, list, body []Node) *CaseStmt {
 
 func (n *CaseStmt) String() string                { return fmt.Sprint(n) }
 func (n *CaseStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *CaseStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *CaseStmt) rawCopy() Node                 { c := *n; return &c }
 func (n *CaseStmt) List() Nodes                   { return n.list }
 func (n *CaseStmt) PtrList() *Nodes               { return &n.list }
 func (n *CaseStmt) SetList(x Nodes)               { n.list = x }
@@ -261,7 +261,7 @@ func NewDeferStmt(pos src.XPos, call Node) *DeferStmt {
 
 func (n *DeferStmt) String() string                { return fmt.Sprint(n) }
 func (n *DeferStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *DeferStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *DeferStmt) rawCopy() Node                 { c := *n; return &c }
 
 func (n *DeferStmt) Left() Node     { return n.Call }
 func (n *DeferStmt) SetLeft(x Node) { n.Call = x }
@@ -280,7 +280,7 @@ func NewEmptyStmt(pos src.XPos) *EmptyStmt {
 
 func (n *EmptyStmt) String() string                { return fmt.Sprint(n) }
 func (n *EmptyStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *EmptyStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *EmptyStmt) rawCopy() Node                 { c := *n; return &c }
 
 // A ForStmt is a non-range for loop: for Init; Cond; Post { Body }
 // Op can be OFOR or OFORUNTIL (!Cond).
@@ -305,7 +305,7 @@ func NewForStmt(pos src.XPos, init []Node, cond, post Node, body []Node) *ForStm
 
 func (n *ForStmt) String() string                { return fmt.Sprint(n) }
 func (n *ForStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ForStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *ForStmt) rawCopy() Node                 { c := *n; return &c }
 func (n *ForStmt) Sym() *types.Sym               { return n.Label }
 func (n *ForStmt) SetSym(x *types.Sym)           { n.Label = x }
 func (n *ForStmt) Left() Node                    { return n.Cond }
@@ -343,7 +343,7 @@ func NewGoStmt(pos src.XPos, call Node) *GoStmt {
 
 func (n *GoStmt) String() string                { return fmt.Sprint(n) }
 func (n *GoStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *GoStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *GoStmt) rawCopy() Node                 { c := *n; return &c }
 
 func (n *GoStmt) Left() Node     { return n.Call }
 func (n *GoStmt) SetLeft(x Node) { n.Call = x }
@@ -368,7 +368,7 @@ func NewIfStmt(pos src.XPos, cond Node, body, els []Node) *IfStmt {
 
 func (n *IfStmt) String() string                { return fmt.Sprint(n) }
 func (n *IfStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *IfStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *IfStmt) rawCopy() Node                 { c := *n; return &c }
 func (n *IfStmt) Left() Node                    { return n.Cond }
 func (n *IfStmt) SetLeft(x Node)                { n.Cond = x }
 func (n *IfStmt) Body() Nodes                   { return n.body }
@@ -395,7 +395,7 @@ func NewInlineMarkStmt(pos src.XPos, index int64) *InlineMarkStmt {
 
 func (n *InlineMarkStmt) String() string                { return fmt.Sprint(n) }
 func (n *InlineMarkStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *InlineMarkStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *InlineMarkStmt) rawCopy() Node                 { c := *n; return &c }
 func (n *InlineMarkStmt) Offset() int64                 { return n.Index }
 func (n *InlineMarkStmt) SetOffset(x int64)             { n.Index = x }
 
@@ -414,7 +414,7 @@ func NewLabelStmt(pos src.XPos, label *types.Sym) *LabelStmt {
 
 func (n *LabelStmt) String() string                { return fmt.Sprint(n) }
 func (n *LabelStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *LabelStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *LabelStmt) rawCopy() Node                 { c := *n; return &c }
 func (n *LabelStmt) Sym() *types.Sym               { return n.Label }
 func (n *LabelStmt) SetSym(x *types.Sym)           { n.Label = x }
 
@@ -442,7 +442,7 @@ func NewRangeStmt(pos src.XPos, vars []Node, x Node, body []Node) *RangeStmt {
 
 func (n *RangeStmt) String() string                { return fmt.Sprint(n) }
 func (n *RangeStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *RangeStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *RangeStmt) rawCopy() Node                 { c := *n; return &c }
 func (n *RangeStmt) Sym() *types.Sym               { return n.Label }
 func (n *RangeStmt) SetSym(x *types.Sym)           { n.Label = x }
 func (n *RangeStmt) Right() Node                   { return n.X }
@@ -478,7 +478,7 @@ func NewReturnStmt(pos src.XPos, results []Node) *ReturnStmt {
 
 func (n *ReturnStmt) String() string                { return fmt.Sprint(n) }
 func (n *ReturnStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ReturnStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *ReturnStmt) rawCopy() Node                 { c := *n; return &c }
 func (n *ReturnStmt) Orig() Node                    { return n.orig }
 func (n *ReturnStmt) SetOrig(x Node)                { n.orig = x }
 func (n *ReturnStmt) List() Nodes                   { return n.Results }
@@ -507,7 +507,7 @@ func NewSelectStmt(pos src.XPos, cases []Node) *SelectStmt {
 
 func (n *SelectStmt) String() string                { return fmt.Sprint(n) }
 func (n *SelectStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *SelectStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *SelectStmt) rawCopy() Node                 { c := *n; return &c }
 func (n *SelectStmt) List() Nodes                   { return n.Cases }
 func (n *SelectStmt) PtrList() *Nodes               { return &n.Cases }
 func (n *SelectStmt) SetList(x Nodes)               { n.Cases = x }
@@ -535,7 +535,7 @@ func NewSendStmt(pos src.XPos, ch, value Node) *SendStmt {
 
 func (n *SendStmt) String() string                { return fmt.Sprint(n) }
 func (n *SendStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *SendStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *SendStmt) rawCopy() Node                 { c := *n; return &c }
 
 func (n *SendStmt) Left() Node      { return n.Chan }
 func (n *SendStmt) SetLeft(x Node)  { n.Chan = x }
@@ -564,7 +564,7 @@ func NewSwitchStmt(pos src.XPos, tag Node, cases []Node) *SwitchStmt {
 
 func (n *SwitchStmt) String() string                { return fmt.Sprint(n) }
 func (n *SwitchStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *SwitchStmt) RawCopy() Node                 { c := *n; return &c }
+func (n *SwitchStmt) rawCopy() Node                 { c := *n; return &c }
 func (n *SwitchStmt) Left() Node                    { return n.Tag }
 func (n *SwitchStmt) SetLeft(x Node)                { n.Tag = x }
 func (n *SwitchStmt) List() Nodes                   { return n.Cases }
@@ -597,7 +597,7 @@ func NewTypeSwitchGuard(pos src.XPos, name, x Node) *TypeSwitchGuard {
 
 func (n *TypeSwitchGuard) String() string                { return fmt.Sprint(n) }
 func (n *TypeSwitchGuard) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *TypeSwitchGuard) RawCopy() Node                 { c := *n; return &c }
+func (n *TypeSwitchGuard) rawCopy() Node                 { c := *n; return &c }
 
 func (n *TypeSwitchGuard) Left() Node {
 	if n.name == nil {
diff --git a/src/cmd/compile/internal/ir/type.go b/src/cmd/compile/internal/ir/type.go
index 519a7291b0..af8db15e84 100644
--- a/src/cmd/compile/internal/ir/type.go
+++ b/src/cmd/compile/internal/ir/type.go
@@ -78,7 +78,7 @@ func NewChanType(pos src.XPos, elem Node, dir types.ChanDir) *ChanType {
 
 func (n *ChanType) String() string                { return fmt.Sprint(n) }
 func (n *ChanType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ChanType) RawCopy() Node                 { c := *n; return &c }
+func (n *ChanType) rawCopy() Node                 { c := *n; return &c }
 func (n *ChanType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
 	n.Elem = nil
@@ -108,7 +108,7 @@ func NewMapType(pos src.XPos, key, elem Node) *MapType {
 
 func (n *MapType) String() string                { return fmt.Sprint(n) }
 func (n *MapType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *MapType) RawCopy() Node                 { c := *n; return &c }
+func (n *MapType) rawCopy() Node                 { c := *n; return &c }
 func (n *MapType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
 	n.Key = nil
@@ -138,7 +138,7 @@ func NewStructType(pos src.XPos, fields []*Field) *StructType {
 
 func (n *StructType) String() string                { return fmt.Sprint(n) }
 func (n *StructType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *StructType) RawCopy() Node                 { c := *n; return &c }
+func (n *StructType) rawCopy() Node                 { c := *n; return &c }
 func (n *StructType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
 	n.Fields = nil
@@ -175,7 +175,7 @@ func NewInterfaceType(pos src.XPos, methods []*Field) *InterfaceType {
 
 func (n *InterfaceType) String() string                { return fmt.Sprint(n) }
 func (n *InterfaceType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *InterfaceType) RawCopy() Node                 { c := *n; return &c }
+func (n *InterfaceType) rawCopy() Node                 { c := *n; return &c }
 func (n *InterfaceType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
 	n.Methods = nil
@@ -206,7 +206,7 @@ func NewFuncType(pos src.XPos, rcvr *Field, args, results []*Field) *FuncType {
 
 func (n *FuncType) String() string                { return fmt.Sprint(n) }
 func (n *FuncType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *FuncType) RawCopy() Node                 { c := *n; return &c }
+func (n *FuncType) rawCopy() Node                 { c := *n; return &c }
 
 func (n *FuncType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
@@ -293,7 +293,7 @@ func NewSliceType(pos src.XPos, elem Node) *SliceType {
 
 func (n *SliceType) String() string                { return fmt.Sprint(n) }
 func (n *SliceType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *SliceType) RawCopy() Node                 { c := *n; return &c }
+func (n *SliceType) rawCopy() Node                 { c := *n; return &c }
 func (n *SliceType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
 	n.Elem = nil
@@ -324,7 +324,7 @@ func NewArrayType(pos src.XPos, size Node, elem Node) *ArrayType {
 
 func (n *ArrayType) String() string                { return fmt.Sprint(n) }
 func (n *ArrayType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ArrayType) RawCopy() Node                 { c := *n; return &c }
+func (n *ArrayType) rawCopy() Node                 { c := *n; return &c }
 
 func (n *ArrayType) DeepCopy(pos src.XPos) Node {
 	if n.op == OTYPE {
@@ -355,7 +355,7 @@ func newTypeNode(pos src.XPos, typ *types.Type) *typeNode {
 
 func (n *typeNode) String() string                { return fmt.Sprint(n) }
 func (n *typeNode) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *typeNode) RawCopy() Node                 { c := *n; return &c }
+func (n *typeNode) rawCopy() Node                 { c := *n; return &c }
 func (n *typeNode) Type() *types.Type             { return n.typ }
 func (n *typeNode) Sym() *types.Sym               { return n.typ.Sym }
 func (n *typeNode) CanBeNtype()                   {}
-- 
GitLab


From 2d6ff998edc0f3877ee24d28647a494491742f25 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 29 Nov 2020 14:06:17 -0800
Subject: [PATCH 0111/2400] [dev.regabi] cmd/compile: process //go:linknames
 after declarations

Allows emitting errors about ineffectual //go:linkname directives.

In particular, this exposed: a typo in os2_aix.go; redundant (but
harmless) directives for libc_pipe in both os3_solaris.go and
syscall2_solaris.go; and a bunch of useless //go:linkname directives
in macOS wrapper code.

However, because there's also ineffectual directives in the vendored
macOS code from x/sys, that can't be an error just yet. So instead we
print a warning (including a heads up that it will be promoted to an
error in Go 1.17) to prevent backsliding while we fix and re-vendor
that code.

Passes toolstash-check.

Change-Id: I59badeab5df0d8b3abfd14c6066e9bb00e840f73
Reviewed-on: https://go-review.googlesource.com/c/go/+/273986
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/noder.go          |  43 ++++---
 .../x509/internal/macos/corefoundation.go     |   9 --
 src/crypto/x509/internal/macos/security.go    |   4 -
 src/go/types/stdlib_test.go                   |   1 +
 src/runtime/os2_aix.go                        |   4 +-
 src/runtime/syscall2_solaris.go               |   2 -
 src/syscall/mksyscall.pl                      |   3 -
 src/syscall/syscall_darwin.go                 |   3 -
 src/syscall/syscall_darwin_amd64.go           |   1 -
 src/syscall/syscall_darwin_arm64.go           |   1 -
 src/syscall/zsyscall_darwin_amd64.go          | 121 ------------------
 src/syscall/zsyscall_darwin_arm64.go          | 121 ------------------
 test/linkname2.go                             |  27 ++++
 13 files changed, 58 insertions(+), 282 deletions(-)
 create mode 100644 test/linkname2.go

diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 6a5afe7687..1340068c72 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -75,6 +75,10 @@ func parseFiles(filenames []string) uint {
 		testdclstack()
 	}
 
+	for _, p := range noders {
+		p.processPragmas()
+	}
+
 	ir.LocalPkg.Height = myheight
 
 	return lines
@@ -258,23 +262,27 @@ func (p *noder) node() {
 
 	xtop = append(xtop, p.decls(p.file.DeclList)...)
 
-	for _, n := range p.linknames {
+	base.Pos = src.NoXPos
+	clearImports()
+}
+
+func (p *noder) processPragmas() {
+	for _, l := range p.linknames {
 		if !p.importedUnsafe {
-			p.errorAt(n.pos, "//go:linkname only allowed in Go files that import \"unsafe\"")
+			p.errorAt(l.pos, "//go:linkname only allowed in Go files that import \"unsafe\"")
 			continue
 		}
-		s := lookup(n.local)
-		if n.remote != "" {
-			s.Linkname = n.remote
-		} else {
-			// Use the default object symbol name if the
-			// user didn't provide one.
-			if base.Ctxt.Pkgpath == "" {
-				p.errorAt(n.pos, "//go:linkname requires linkname argument or -p compiler flag")
-			} else {
-				s.Linkname = objabi.PathToPrefix(base.Ctxt.Pkgpath) + "." + n.local
-			}
+		n := ir.AsNode(lookup(l.local).Def)
+		if n == nil || n.Op() != ir.ONAME {
+			// TODO(mdempsky): Change to p.errorAt before Go 1.17 release.
+			base.WarnfAt(p.makeXPos(l.pos), "//go:linkname must refer to declared function or variable (will be an error in Go 1.17)")
+			continue
 		}
+		if n.Sym().Linkname != "" {
+			p.errorAt(l.pos, "duplicate //go:linkname for %s", l.local)
+			continue
+		}
+		n.Sym().Linkname = l.remote
 	}
 
 	// The linker expects an ABI0 wrapper for all cgo-exported
@@ -290,8 +298,6 @@ func (p *noder) node() {
 	}
 
 	pragcgobuf = append(pragcgobuf, p.pragcgobuf...)
-	base.Pos = src.NoXPos
-	clearImports()
 }
 
 func (p *noder) decls(decls []syntax.Decl) (l []ir.Node) {
@@ -1592,6 +1598,13 @@ func (p *noder) pragma(pos syntax.Pos, blankLine bool, text string, old syntax.P
 		var target string
 		if len(f) == 3 {
 			target = f[2]
+		} else if base.Ctxt.Pkgpath != "" {
+			// Use the default object symbol name if the
+			// user didn't provide one.
+			target = objabi.PathToPrefix(base.Ctxt.Pkgpath) + "." + f[1]
+		} else {
+			p.error(syntax.Error{Pos: pos, Msg: "//go:linkname requires linkname argument or -p compiler flag"})
+			break
 		}
 		p.linknames = append(p.linknames, linkname{pos, f[1], target})
 
diff --git a/src/crypto/x509/internal/macos/corefoundation.go b/src/crypto/x509/internal/macos/corefoundation.go
index 9b776d4b85..0572c6ccd8 100644
--- a/src/crypto/x509/internal/macos/corefoundation.go
+++ b/src/crypto/x509/internal/macos/corefoundation.go
@@ -39,7 +39,6 @@ type CFString CFRef
 const kCFAllocatorDefault = 0
 const kCFStringEncodingUTF8 = 0x08000100
 
-//go:linkname x509_CFStringCreateWithBytes x509_CFStringCreateWithBytes
 //go:cgo_import_dynamic x509_CFStringCreateWithBytes CFStringCreateWithBytes "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 // StringToCFString returns a copy of the UTF-8 contents of s as a new CFString.
@@ -52,7 +51,6 @@ func StringToCFString(s string) CFString {
 }
 func x509_CFStringCreateWithBytes_trampoline()
 
-//go:linkname x509_CFDictionaryGetValueIfPresent x509_CFDictionaryGetValueIfPresent
 //go:cgo_import_dynamic x509_CFDictionaryGetValueIfPresent CFDictionaryGetValueIfPresent "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 func CFDictionaryGetValueIfPresent(dict CFRef, key CFString) (value CFRef, ok bool) {
@@ -67,7 +65,6 @@ func x509_CFDictionaryGetValueIfPresent_trampoline()
 
 const kCFNumberSInt32Type = 3
 
-//go:linkname x509_CFNumberGetValue x509_CFNumberGetValue
 //go:cgo_import_dynamic x509_CFNumberGetValue CFNumberGetValue "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 func CFNumberGetValue(num CFRef) (int32, error) {
@@ -81,7 +78,6 @@ func CFNumberGetValue(num CFRef) (int32, error) {
 }
 func x509_CFNumberGetValue_trampoline()
 
-//go:linkname x509_CFDataGetLength x509_CFDataGetLength
 //go:cgo_import_dynamic x509_CFDataGetLength CFDataGetLength "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 func CFDataGetLength(data CFRef) int {
@@ -90,7 +86,6 @@ func CFDataGetLength(data CFRef) int {
 }
 func x509_CFDataGetLength_trampoline()
 
-//go:linkname x509_CFDataGetBytePtr x509_CFDataGetBytePtr
 //go:cgo_import_dynamic x509_CFDataGetBytePtr CFDataGetBytePtr "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 func CFDataGetBytePtr(data CFRef) uintptr {
@@ -99,7 +94,6 @@ func CFDataGetBytePtr(data CFRef) uintptr {
 }
 func x509_CFDataGetBytePtr_trampoline()
 
-//go:linkname x509_CFArrayGetCount x509_CFArrayGetCount
 //go:cgo_import_dynamic x509_CFArrayGetCount CFArrayGetCount "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 func CFArrayGetCount(array CFRef) int {
@@ -108,7 +102,6 @@ func CFArrayGetCount(array CFRef) int {
 }
 func x509_CFArrayGetCount_trampoline()
 
-//go:linkname x509_CFArrayGetValueAtIndex x509_CFArrayGetValueAtIndex
 //go:cgo_import_dynamic x509_CFArrayGetValueAtIndex CFArrayGetValueAtIndex "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 func CFArrayGetValueAtIndex(array CFRef, index int) CFRef {
@@ -117,7 +110,6 @@ func CFArrayGetValueAtIndex(array CFRef, index int) CFRef {
 }
 func x509_CFArrayGetValueAtIndex_trampoline()
 
-//go:linkname x509_CFEqual x509_CFEqual
 //go:cgo_import_dynamic x509_CFEqual CFEqual "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 func CFEqual(a, b CFRef) bool {
@@ -126,7 +118,6 @@ func CFEqual(a, b CFRef) bool {
 }
 func x509_CFEqual_trampoline()
 
-//go:linkname x509_CFRelease x509_CFRelease
 //go:cgo_import_dynamic x509_CFRelease CFRelease "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 func CFRelease(ref CFRef) {
diff --git a/src/crypto/x509/internal/macos/security.go b/src/crypto/x509/internal/macos/security.go
index 5e39e93666..3163e3a4f7 100644
--- a/src/crypto/x509/internal/macos/security.go
+++ b/src/crypto/x509/internal/macos/security.go
@@ -63,7 +63,6 @@ var ErrNoTrustSettings = errors.New("no trust settings found")
 
 const errSecNoTrustSettings = -25263
 
-//go:linkname x509_SecTrustSettingsCopyCertificates x509_SecTrustSettingsCopyCertificates
 //go:cgo_import_dynamic x509_SecTrustSettingsCopyCertificates SecTrustSettingsCopyCertificates "/System/Library/Frameworks/Security.framework/Versions/A/Security"
 
 func SecTrustSettingsCopyCertificates(domain SecTrustSettingsDomain) (certArray CFRef, err error) {
@@ -80,7 +79,6 @@ func x509_SecTrustSettingsCopyCertificates_trampoline()
 
 const kSecFormatX509Cert int32 = 9
 
-//go:linkname x509_SecItemExport x509_SecItemExport
 //go:cgo_import_dynamic x509_SecItemExport SecItemExport "/System/Library/Frameworks/Security.framework/Versions/A/Security"
 
 func SecItemExport(cert CFRef) (data CFRef, err error) {
@@ -95,7 +93,6 @@ func x509_SecItemExport_trampoline()
 
 const errSecItemNotFound = -25300
 
-//go:linkname x509_SecTrustSettingsCopyTrustSettings x509_SecTrustSettingsCopyTrustSettings
 //go:cgo_import_dynamic x509_SecTrustSettingsCopyTrustSettings SecTrustSettingsCopyTrustSettings "/System/Library/Frameworks/Security.framework/Versions/A/Security"
 
 func SecTrustSettingsCopyTrustSettings(cert CFRef, domain SecTrustSettingsDomain) (trustSettings CFRef, err error) {
@@ -110,7 +107,6 @@ func SecTrustSettingsCopyTrustSettings(cert CFRef, domain SecTrustSettingsDomain
 }
 func x509_SecTrustSettingsCopyTrustSettings_trampoline()
 
-//go:linkname x509_SecPolicyCopyProperties x509_SecPolicyCopyProperties
 //go:cgo_import_dynamic x509_SecPolicyCopyProperties SecPolicyCopyProperties "/System/Library/Frameworks/Security.framework/Versions/A/Security"
 
 func SecPolicyCopyProperties(policy CFRef) CFRef {
diff --git a/src/go/types/stdlib_test.go b/src/go/types/stdlib_test.go
index 669e7bec20..5bd43e688a 100644
--- a/src/go/types/stdlib_test.go
+++ b/src/go/types/stdlib_test.go
@@ -156,6 +156,7 @@ func TestStdTest(t *testing.T) {
 	testTestDir(t, filepath.Join(runtime.GOROOT(), "test"),
 		"cmplxdivide.go", // also needs file cmplxdivide1.go - ignore
 		"directive.go",   // tests compiler rejection of bad directive placement - ignore
+		"linkname2.go",   // go/types doesn't check validity of //go:xxx directives
 	)
 }
 
diff --git a/src/runtime/os2_aix.go b/src/runtime/os2_aix.go
index 428ff7f225..abd1010be9 100644
--- a/src/runtime/os2_aix.go
+++ b/src/runtime/os2_aix.go
@@ -18,11 +18,11 @@ import (
 
 //go:cgo_import_dynamic libc___n_pthreads __n_pthreads "libpthread.a/shr_xpg5_64.o"
 //go:cgo_import_dynamic libc___mod_init __mod_init "libc.a/shr_64.o"
-//go:linkname libc___n_pthreads libc___n_pthread
+//go:linkname libc___n_pthreads libc___n_pthreads
 //go:linkname libc___mod_init libc___mod_init
 
 var (
-	libc___n_pthread,
+	libc___n_pthreads,
 	libc___mod_init libFunc
 )
 
diff --git a/src/runtime/syscall2_solaris.go b/src/runtime/syscall2_solaris.go
index e098e8006a..3310489202 100644
--- a/src/runtime/syscall2_solaris.go
+++ b/src/runtime/syscall2_solaris.go
@@ -15,7 +15,6 @@ import _ "unsafe" // for go:linkname
 //go:cgo_import_dynamic libc_gethostname gethostname "libc.so"
 //go:cgo_import_dynamic libc_getpid getpid "libc.so"
 //go:cgo_import_dynamic libc_ioctl ioctl "libc.so"
-//go:cgo_import_dynamic libc_pipe pipe "libc.so"
 //go:cgo_import_dynamic libc_setgid setgid "libc.so"
 //go:cgo_import_dynamic libc_setgroups setgroups "libc.so"
 //go:cgo_import_dynamic libc_setsid setsid "libc.so"
@@ -33,7 +32,6 @@ import _ "unsafe" // for go:linkname
 //go:linkname libc_gethostname libc_gethostname
 //go:linkname libc_getpid libc_getpid
 //go:linkname libc_ioctl libc_ioctl
-//go:linkname libc_pipe libc_pipe
 //go:linkname libc_setgid libc_setgid
 //go:linkname libc_setgroups libc_setgroups
 //go:linkname libc_setsid libc_setsid
diff --git a/src/syscall/mksyscall.pl b/src/syscall/mksyscall.pl
index 25b40d7ba2..790df3825b 100755
--- a/src/syscall/mksyscall.pl
+++ b/src/syscall/mksyscall.pl
@@ -343,9 +343,6 @@ while(<>) {
 			$trampolines{$funcname} = 1;
 			# The assembly trampoline that jumps to the libc routine.
 			$text .= "func ${funcname}_trampoline()\n";
-			# Map syscall.funcname to just plain funcname.
-			# (The jump to this function is in the assembly trampoline, generated by mksyscallasm_darwin.go.)
-			$text .= "//go:linkname $funcname $funcname\n";
 			# Tell the linker that funcname can be found in libSystem using varname without the libc_ prefix.
 			my $basename = substr $funcname, 5;
 			$text .= "//go:cgo_import_dynamic $funcname $basename \"/usr/lib/libSystem.B.dylib\"\n\n";
diff --git a/src/syscall/syscall_darwin.go b/src/syscall/syscall_darwin.go
index afdadbf894..162e94479f 100644
--- a/src/syscall/syscall_darwin.go
+++ b/src/syscall/syscall_darwin.go
@@ -115,7 +115,6 @@ func Getfsstat(buf []Statfs_t, flags int) (n int, err error) {
 
 func libc_getfsstat_trampoline()
 
-//go:linkname libc_getfsstat libc_getfsstat
 //go:cgo_import_dynamic libc_getfsstat getfsstat "/usr/lib/libSystem.B.dylib"
 
 func setattrlistTimes(path string, times []Timespec) error {
@@ -148,7 +147,6 @@ func setattrlistTimes(path string, times []Timespec) error {
 
 func libc_setattrlist_trampoline()
 
-//go:linkname libc_setattrlist libc_setattrlist
 //go:cgo_import_dynamic libc_setattrlist setattrlist "/usr/lib/libSystem.B.dylib"
 
 func utimensat(dirfd int, path string, times *[2]Timespec, flag int) error {
@@ -276,7 +274,6 @@ func fdopendir(fd int) (dir uintptr, err error) {
 
 func libc_fdopendir_trampoline()
 
-//go:linkname libc_fdopendir libc_fdopendir
 //go:cgo_import_dynamic libc_fdopendir fdopendir "/usr/lib/libSystem.B.dylib"
 
 func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
diff --git a/src/syscall/syscall_darwin_amd64.go b/src/syscall/syscall_darwin_amd64.go
index 23a4e5f996..96fadf7837 100644
--- a/src/syscall/syscall_darwin_amd64.go
+++ b/src/syscall/syscall_darwin_amd64.go
@@ -56,7 +56,6 @@ func sendfile(outfd int, infd int, offset *int64, count int) (written int, err e
 
 func libc_sendfile_trampoline()
 
-//go:linkname libc_sendfile libc_sendfile
 //go:cgo_import_dynamic libc_sendfile sendfile "/usr/lib/libSystem.B.dylib"
 
 // Implemented in the runtime package (runtime/sys_darwin_64.go)
diff --git a/src/syscall/syscall_darwin_arm64.go b/src/syscall/syscall_darwin_arm64.go
index c824f6d89d..d267a4ae6e 100644
--- a/src/syscall/syscall_darwin_arm64.go
+++ b/src/syscall/syscall_darwin_arm64.go
@@ -56,7 +56,6 @@ func sendfile(outfd int, infd int, offset *int64, count int) (written int, err e
 
 func libc_sendfile_trampoline()
 
-//go:linkname libc_sendfile libc_sendfile
 //go:cgo_import_dynamic libc_sendfile sendfile "/usr/lib/libSystem.B.dylib"
 
 // Implemented in the runtime package (runtime/sys_darwin_64.go)
diff --git a/src/syscall/zsyscall_darwin_amd64.go b/src/syscall/zsyscall_darwin_amd64.go
index 093739ebc7..ee726fb24d 100644
--- a/src/syscall/zsyscall_darwin_amd64.go
+++ b/src/syscall/zsyscall_darwin_amd64.go
@@ -20,7 +20,6 @@ func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
 
 func libc_getgroups_trampoline()
 
-//go:linkname libc_getgroups libc_getgroups
 //go:cgo_import_dynamic libc_getgroups getgroups "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -35,7 +34,6 @@ func setgroups(ngid int, gid *_Gid_t) (err error) {
 
 func libc_setgroups_trampoline()
 
-//go:linkname libc_setgroups libc_setgroups
 //go:cgo_import_dynamic libc_setgroups setgroups "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -51,7 +49,6 @@ func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err
 
 func libc_wait4_trampoline()
 
-//go:linkname libc_wait4 libc_wait4
 //go:cgo_import_dynamic libc_wait4 wait4 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -67,7 +64,6 @@ func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
 
 func libc_accept_trampoline()
 
-//go:linkname libc_accept libc_accept
 //go:cgo_import_dynamic libc_accept accept "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -82,7 +78,6 @@ func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
 
 func libc_bind_trampoline()
 
-//go:linkname libc_bind libc_bind
 //go:cgo_import_dynamic libc_bind bind "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -97,7 +92,6 @@ func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
 
 func libc_connect_trampoline()
 
-//go:linkname libc_connect libc_connect
 //go:cgo_import_dynamic libc_connect connect "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -113,7 +107,6 @@ func socket(domain int, typ int, proto int) (fd int, err error) {
 
 func libc_socket_trampoline()
 
-//go:linkname libc_socket libc_socket
 //go:cgo_import_dynamic libc_socket socket "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -128,7 +121,6 @@ func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen
 
 func libc_getsockopt_trampoline()
 
-//go:linkname libc_getsockopt libc_getsockopt
 //go:cgo_import_dynamic libc_getsockopt getsockopt "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -143,7 +135,6 @@ func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr)
 
 func libc_setsockopt_trampoline()
 
-//go:linkname libc_setsockopt libc_setsockopt
 //go:cgo_import_dynamic libc_setsockopt setsockopt "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -158,7 +149,6 @@ func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
 
 func libc_getpeername_trampoline()
 
-//go:linkname libc_getpeername libc_getpeername
 //go:cgo_import_dynamic libc_getpeername getpeername "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -173,7 +163,6 @@ func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
 
 func libc_getsockname_trampoline()
 
-//go:linkname libc_getsockname libc_getsockname
 //go:cgo_import_dynamic libc_getsockname getsockname "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -188,7 +177,6 @@ func Shutdown(s int, how int) (err error) {
 
 func libc_shutdown_trampoline()
 
-//go:linkname libc_shutdown libc_shutdown
 //go:cgo_import_dynamic libc_shutdown shutdown "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -203,7 +191,6 @@ func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
 
 func libc_socketpair_trampoline()
 
-//go:linkname libc_socketpair libc_socketpair
 //go:cgo_import_dynamic libc_socketpair socketpair "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -225,7 +212,6 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
 
 func libc_recvfrom_trampoline()
 
-//go:linkname libc_recvfrom libc_recvfrom
 //go:cgo_import_dynamic libc_recvfrom recvfrom "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -246,7 +232,6 @@ func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (
 
 func libc_sendto_trampoline()
 
-//go:linkname libc_sendto libc_sendto
 //go:cgo_import_dynamic libc_sendto sendto "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -262,7 +247,6 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 
 func libc_recvmsg_trampoline()
 
-//go:linkname libc_recvmsg libc_recvmsg
 //go:cgo_import_dynamic libc_recvmsg recvmsg "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -278,7 +262,6 @@ func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 
 func libc_sendmsg_trampoline()
 
-//go:linkname libc_sendmsg libc_sendmsg
 //go:cgo_import_dynamic libc_sendmsg sendmsg "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -294,7 +277,6 @@ func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, ne
 
 func libc_kevent_trampoline()
 
-//go:linkname libc_kevent libc_kevent
 //go:cgo_import_dynamic libc_kevent kevent "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -314,7 +296,6 @@ func utimes(path string, timeval *[2]Timeval) (err error) {
 
 func libc_utimes_trampoline()
 
-//go:linkname libc_utimes libc_utimes
 //go:cgo_import_dynamic libc_utimes utimes "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -329,7 +310,6 @@ func futimes(fd int, timeval *[2]Timeval) (err error) {
 
 func libc_futimes_trampoline()
 
-//go:linkname libc_futimes libc_futimes
 //go:cgo_import_dynamic libc_futimes futimes "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -345,7 +325,6 @@ func fcntl(fd int, cmd int, arg int) (val int, err error) {
 
 func libc_fcntl_trampoline()
 
-//go:linkname libc_fcntl libc_fcntl
 //go:cgo_import_dynamic libc_fcntl fcntl "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -360,7 +339,6 @@ func pipe(p *[2]int32) (err error) {
 
 func libc_pipe_trampoline()
 
-//go:linkname libc_pipe libc_pipe
 //go:cgo_import_dynamic libc_pipe pipe "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -375,7 +353,6 @@ func kill(pid int, signum int, posix int) (err error) {
 
 func libc_kill_trampoline()
 
-//go:linkname libc_kill libc_kill
 //go:cgo_import_dynamic libc_kill kill "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -395,7 +372,6 @@ func Access(path string, mode uint32) (err error) {
 
 func libc_access_trampoline()
 
-//go:linkname libc_access libc_access
 //go:cgo_import_dynamic libc_access access "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -410,7 +386,6 @@ func Adjtime(delta *Timeval, olddelta *Timeval) (err error) {
 
 func libc_adjtime_trampoline()
 
-//go:linkname libc_adjtime libc_adjtime
 //go:cgo_import_dynamic libc_adjtime adjtime "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -430,7 +405,6 @@ func Chdir(path string) (err error) {
 
 func libc_chdir_trampoline()
 
-//go:linkname libc_chdir libc_chdir
 //go:cgo_import_dynamic libc_chdir chdir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -450,7 +424,6 @@ func Chflags(path string, flags int) (err error) {
 
 func libc_chflags_trampoline()
 
-//go:linkname libc_chflags libc_chflags
 //go:cgo_import_dynamic libc_chflags chflags "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -470,7 +443,6 @@ func Chmod(path string, mode uint32) (err error) {
 
 func libc_chmod_trampoline()
 
-//go:linkname libc_chmod libc_chmod
 //go:cgo_import_dynamic libc_chmod chmod "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -490,7 +462,6 @@ func Chown(path string, uid int, gid int) (err error) {
 
 func libc_chown_trampoline()
 
-//go:linkname libc_chown libc_chown
 //go:cgo_import_dynamic libc_chown chown "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -510,7 +481,6 @@ func Chroot(path string) (err error) {
 
 func libc_chroot_trampoline()
 
-//go:linkname libc_chroot libc_chroot
 //go:cgo_import_dynamic libc_chroot chroot "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -525,7 +495,6 @@ func Close(fd int) (err error) {
 
 func libc_close_trampoline()
 
-//go:linkname libc_close libc_close
 //go:cgo_import_dynamic libc_close close "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -540,7 +509,6 @@ func closedir(dir uintptr) (err error) {
 
 func libc_closedir_trampoline()
 
-//go:linkname libc_closedir libc_closedir
 //go:cgo_import_dynamic libc_closedir closedir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -556,7 +524,6 @@ func Dup(fd int) (nfd int, err error) {
 
 func libc_dup_trampoline()
 
-//go:linkname libc_dup libc_dup
 //go:cgo_import_dynamic libc_dup dup "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -571,7 +538,6 @@ func Dup2(from int, to int) (err error) {
 
 func libc_dup2_trampoline()
 
-//go:linkname libc_dup2 libc_dup2
 //go:cgo_import_dynamic libc_dup2 dup2 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -596,7 +562,6 @@ func Exchangedata(path1 string, path2 string, options int) (err error) {
 
 func libc_exchangedata_trampoline()
 
-//go:linkname libc_exchangedata libc_exchangedata
 //go:cgo_import_dynamic libc_exchangedata exchangedata "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -611,7 +576,6 @@ func Fchdir(fd int) (err error) {
 
 func libc_fchdir_trampoline()
 
-//go:linkname libc_fchdir libc_fchdir
 //go:cgo_import_dynamic libc_fchdir fchdir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -626,7 +590,6 @@ func Fchflags(fd int, flags int) (err error) {
 
 func libc_fchflags_trampoline()
 
-//go:linkname libc_fchflags libc_fchflags
 //go:cgo_import_dynamic libc_fchflags fchflags "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -641,7 +604,6 @@ func Fchmod(fd int, mode uint32) (err error) {
 
 func libc_fchmod_trampoline()
 
-//go:linkname libc_fchmod libc_fchmod
 //go:cgo_import_dynamic libc_fchmod fchmod "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -656,7 +618,6 @@ func Fchown(fd int, uid int, gid int) (err error) {
 
 func libc_fchown_trampoline()
 
-//go:linkname libc_fchown libc_fchown
 //go:cgo_import_dynamic libc_fchown fchown "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -671,7 +632,6 @@ func Flock(fd int, how int) (err error) {
 
 func libc_flock_trampoline()
 
-//go:linkname libc_flock libc_flock
 //go:cgo_import_dynamic libc_flock flock "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -687,7 +647,6 @@ func Fpathconf(fd int, name int) (val int, err error) {
 
 func libc_fpathconf_trampoline()
 
-//go:linkname libc_fpathconf libc_fpathconf
 //go:cgo_import_dynamic libc_fpathconf fpathconf "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -702,7 +661,6 @@ func Fsync(fd int) (err error) {
 
 func libc_fsync_trampoline()
 
-//go:linkname libc_fsync libc_fsync
 //go:cgo_import_dynamic libc_fsync fsync "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -717,7 +675,6 @@ func Ftruncate(fd int, length int64) (err error) {
 
 func libc_ftruncate_trampoline()
 
-//go:linkname libc_ftruncate libc_ftruncate
 //go:cgo_import_dynamic libc_ftruncate ftruncate "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -730,7 +687,6 @@ func Getdtablesize() (size int) {
 
 func libc_getdtablesize_trampoline()
 
-//go:linkname libc_getdtablesize libc_getdtablesize
 //go:cgo_import_dynamic libc_getdtablesize getdtablesize "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -743,7 +699,6 @@ func Getegid() (egid int) {
 
 func libc_getegid_trampoline()
 
-//go:linkname libc_getegid libc_getegid
 //go:cgo_import_dynamic libc_getegid getegid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -756,7 +711,6 @@ func Geteuid() (uid int) {
 
 func libc_geteuid_trampoline()
 
-//go:linkname libc_geteuid libc_geteuid
 //go:cgo_import_dynamic libc_geteuid geteuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -769,7 +723,6 @@ func Getgid() (gid int) {
 
 func libc_getgid_trampoline()
 
-//go:linkname libc_getgid libc_getgid
 //go:cgo_import_dynamic libc_getgid getgid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -785,7 +738,6 @@ func Getpgid(pid int) (pgid int, err error) {
 
 func libc_getpgid_trampoline()
 
-//go:linkname libc_getpgid libc_getpgid
 //go:cgo_import_dynamic libc_getpgid getpgid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -798,7 +750,6 @@ func Getpgrp() (pgrp int) {
 
 func libc_getpgrp_trampoline()
 
-//go:linkname libc_getpgrp libc_getpgrp
 //go:cgo_import_dynamic libc_getpgrp getpgrp "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -811,7 +762,6 @@ func Getpid() (pid int) {
 
 func libc_getpid_trampoline()
 
-//go:linkname libc_getpid libc_getpid
 //go:cgo_import_dynamic libc_getpid getpid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -824,7 +774,6 @@ func Getppid() (ppid int) {
 
 func libc_getppid_trampoline()
 
-//go:linkname libc_getppid libc_getppid
 //go:cgo_import_dynamic libc_getppid getppid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -840,7 +789,6 @@ func Getpriority(which int, who int) (prio int, err error) {
 
 func libc_getpriority_trampoline()
 
-//go:linkname libc_getpriority libc_getpriority
 //go:cgo_import_dynamic libc_getpriority getpriority "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -855,7 +803,6 @@ func Getrlimit(which int, lim *Rlimit) (err error) {
 
 func libc_getrlimit_trampoline()
 
-//go:linkname libc_getrlimit libc_getrlimit
 //go:cgo_import_dynamic libc_getrlimit getrlimit "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -870,7 +817,6 @@ func Getrusage(who int, rusage *Rusage) (err error) {
 
 func libc_getrusage_trampoline()
 
-//go:linkname libc_getrusage libc_getrusage
 //go:cgo_import_dynamic libc_getrusage getrusage "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -886,7 +832,6 @@ func Getsid(pid int) (sid int, err error) {
 
 func libc_getsid_trampoline()
 
-//go:linkname libc_getsid libc_getsid
 //go:cgo_import_dynamic libc_getsid getsid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -899,7 +844,6 @@ func Getuid() (uid int) {
 
 func libc_getuid_trampoline()
 
-//go:linkname libc_getuid libc_getuid
 //go:cgo_import_dynamic libc_getuid getuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -912,7 +856,6 @@ func Issetugid() (tainted bool) {
 
 func libc_issetugid_trampoline()
 
-//go:linkname libc_issetugid libc_issetugid
 //go:cgo_import_dynamic libc_issetugid issetugid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -928,7 +871,6 @@ func Kqueue() (fd int, err error) {
 
 func libc_kqueue_trampoline()
 
-//go:linkname libc_kqueue libc_kqueue
 //go:cgo_import_dynamic libc_kqueue kqueue "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -948,7 +890,6 @@ func Lchown(path string, uid int, gid int) (err error) {
 
 func libc_lchown_trampoline()
 
-//go:linkname libc_lchown libc_lchown
 //go:cgo_import_dynamic libc_lchown lchown "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -973,7 +914,6 @@ func Link(path string, link string) (err error) {
 
 func libc_link_trampoline()
 
-//go:linkname libc_link libc_link
 //go:cgo_import_dynamic libc_link link "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -988,7 +928,6 @@ func Listen(s int, backlog int) (err error) {
 
 func libc_listen_trampoline()
 
-//go:linkname libc_listen libc_listen
 //go:cgo_import_dynamic libc_listen listen "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1008,7 +947,6 @@ func Mkdir(path string, mode uint32) (err error) {
 
 func libc_mkdir_trampoline()
 
-//go:linkname libc_mkdir libc_mkdir
 //go:cgo_import_dynamic libc_mkdir mkdir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1028,7 +966,6 @@ func Mkfifo(path string, mode uint32) (err error) {
 
 func libc_mkfifo_trampoline()
 
-//go:linkname libc_mkfifo libc_mkfifo
 //go:cgo_import_dynamic libc_mkfifo mkfifo "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1048,7 +985,6 @@ func Mknod(path string, mode uint32, dev int) (err error) {
 
 func libc_mknod_trampoline()
 
-//go:linkname libc_mknod libc_mknod
 //go:cgo_import_dynamic libc_mknod mknod "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1069,7 +1005,6 @@ func Mlock(b []byte) (err error) {
 
 func libc_mlock_trampoline()
 
-//go:linkname libc_mlock libc_mlock
 //go:cgo_import_dynamic libc_mlock mlock "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1084,7 +1019,6 @@ func Mlockall(flags int) (err error) {
 
 func libc_mlockall_trampoline()
 
-//go:linkname libc_mlockall libc_mlockall
 //go:cgo_import_dynamic libc_mlockall mlockall "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1105,7 +1039,6 @@ func Mprotect(b []byte, prot int) (err error) {
 
 func libc_mprotect_trampoline()
 
-//go:linkname libc_mprotect libc_mprotect
 //go:cgo_import_dynamic libc_mprotect mprotect "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1126,7 +1059,6 @@ func Munlock(b []byte) (err error) {
 
 func libc_munlock_trampoline()
 
-//go:linkname libc_munlock libc_munlock
 //go:cgo_import_dynamic libc_munlock munlock "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1141,7 +1073,6 @@ func Munlockall() (err error) {
 
 func libc_munlockall_trampoline()
 
-//go:linkname libc_munlockall libc_munlockall
 //go:cgo_import_dynamic libc_munlockall munlockall "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1162,7 +1093,6 @@ func Open(path string, mode int, perm uint32) (fd int, err error) {
 
 func libc_open_trampoline()
 
-//go:linkname libc_open libc_open
 //go:cgo_import_dynamic libc_open open "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1183,7 +1113,6 @@ func Pathconf(path string, name int) (val int, err error) {
 
 func libc_pathconf_trampoline()
 
-//go:linkname libc_pathconf libc_pathconf
 //go:cgo_import_dynamic libc_pathconf pathconf "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1205,7 +1134,6 @@ func Pread(fd int, p []byte, offset int64) (n int, err error) {
 
 func libc_pread_trampoline()
 
-//go:linkname libc_pread libc_pread
 //go:cgo_import_dynamic libc_pread pread "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1227,7 +1155,6 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
 
 func libc_pwrite_trampoline()
 
-//go:linkname libc_pwrite libc_pwrite
 //go:cgo_import_dynamic libc_pwrite pwrite "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1249,7 +1176,6 @@ func read(fd int, p []byte) (n int, err error) {
 
 func libc_read_trampoline()
 
-//go:linkname libc_read libc_read
 //go:cgo_import_dynamic libc_read read "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1262,7 +1188,6 @@ func readdir_r(dir uintptr, entry *Dirent, result **Dirent) (res Errno) {
 
 func libc_readdir_r_trampoline()
 
-//go:linkname libc_readdir_r libc_readdir_r
 //go:cgo_import_dynamic libc_readdir_r readdir_r "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1289,7 +1214,6 @@ func Readlink(path string, buf []byte) (n int, err error) {
 
 func libc_readlink_trampoline()
 
-//go:linkname libc_readlink libc_readlink
 //go:cgo_import_dynamic libc_readlink readlink "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1314,7 +1238,6 @@ func Rename(from string, to string) (err error) {
 
 func libc_rename_trampoline()
 
-//go:linkname libc_rename libc_rename
 //go:cgo_import_dynamic libc_rename rename "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1334,7 +1257,6 @@ func Revoke(path string) (err error) {
 
 func libc_revoke_trampoline()
 
-//go:linkname libc_revoke libc_revoke
 //go:cgo_import_dynamic libc_revoke revoke "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1354,7 +1276,6 @@ func Rmdir(path string) (err error) {
 
 func libc_rmdir_trampoline()
 
-//go:linkname libc_rmdir libc_rmdir
 //go:cgo_import_dynamic libc_rmdir rmdir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1370,7 +1291,6 @@ func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
 
 func libc_lseek_trampoline()
 
-//go:linkname libc_lseek libc_lseek
 //go:cgo_import_dynamic libc_lseek lseek "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1385,7 +1305,6 @@ func Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (err error) {
 
 func libc_select_trampoline()
 
-//go:linkname libc_select libc_select
 //go:cgo_import_dynamic libc_select select "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1400,7 +1319,6 @@ func Setegid(egid int) (err error) {
 
 func libc_setegid_trampoline()
 
-//go:linkname libc_setegid libc_setegid
 //go:cgo_import_dynamic libc_setegid setegid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1415,7 +1333,6 @@ func Seteuid(euid int) (err error) {
 
 func libc_seteuid_trampoline()
 
-//go:linkname libc_seteuid libc_seteuid
 //go:cgo_import_dynamic libc_seteuid seteuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1430,7 +1347,6 @@ func Setgid(gid int) (err error) {
 
 func libc_setgid_trampoline()
 
-//go:linkname libc_setgid libc_setgid
 //go:cgo_import_dynamic libc_setgid setgid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1450,7 +1366,6 @@ func Setlogin(name string) (err error) {
 
 func libc_setlogin_trampoline()
 
-//go:linkname libc_setlogin libc_setlogin
 //go:cgo_import_dynamic libc_setlogin setlogin "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1465,7 +1380,6 @@ func Setpgid(pid int, pgid int) (err error) {
 
 func libc_setpgid_trampoline()
 
-//go:linkname libc_setpgid libc_setpgid
 //go:cgo_import_dynamic libc_setpgid setpgid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1480,7 +1394,6 @@ func Setpriority(which int, who int, prio int) (err error) {
 
 func libc_setpriority_trampoline()
 
-//go:linkname libc_setpriority libc_setpriority
 //go:cgo_import_dynamic libc_setpriority setpriority "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1495,7 +1408,6 @@ func Setprivexec(flag int) (err error) {
 
 func libc_setprivexec_trampoline()
 
-//go:linkname libc_setprivexec libc_setprivexec
 //go:cgo_import_dynamic libc_setprivexec setprivexec "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1510,7 +1422,6 @@ func Setregid(rgid int, egid int) (err error) {
 
 func libc_setregid_trampoline()
 
-//go:linkname libc_setregid libc_setregid
 //go:cgo_import_dynamic libc_setregid setregid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1525,7 +1436,6 @@ func Setreuid(ruid int, euid int) (err error) {
 
 func libc_setreuid_trampoline()
 
-//go:linkname libc_setreuid libc_setreuid
 //go:cgo_import_dynamic libc_setreuid setreuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1540,7 +1450,6 @@ func Setrlimit(which int, lim *Rlimit) (err error) {
 
 func libc_setrlimit_trampoline()
 
-//go:linkname libc_setrlimit libc_setrlimit
 //go:cgo_import_dynamic libc_setrlimit setrlimit "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1556,7 +1465,6 @@ func Setsid() (pid int, err error) {
 
 func libc_setsid_trampoline()
 
-//go:linkname libc_setsid libc_setsid
 //go:cgo_import_dynamic libc_setsid setsid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1571,7 +1479,6 @@ func Settimeofday(tp *Timeval) (err error) {
 
 func libc_settimeofday_trampoline()
 
-//go:linkname libc_settimeofday libc_settimeofday
 //go:cgo_import_dynamic libc_settimeofday settimeofday "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1586,7 +1493,6 @@ func Setuid(uid int) (err error) {
 
 func libc_setuid_trampoline()
 
-//go:linkname libc_setuid libc_setuid
 //go:cgo_import_dynamic libc_setuid setuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1611,7 +1517,6 @@ func Symlink(path string, link string) (err error) {
 
 func libc_symlink_trampoline()
 
-//go:linkname libc_symlink libc_symlink
 //go:cgo_import_dynamic libc_symlink symlink "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1626,7 +1531,6 @@ func Sync() (err error) {
 
 func libc_sync_trampoline()
 
-//go:linkname libc_sync libc_sync
 //go:cgo_import_dynamic libc_sync sync "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1646,7 +1550,6 @@ func Truncate(path string, length int64) (err error) {
 
 func libc_truncate_trampoline()
 
-//go:linkname libc_truncate libc_truncate
 //go:cgo_import_dynamic libc_truncate truncate "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1659,7 +1562,6 @@ func Umask(newmask int) (oldmask int) {
 
 func libc_umask_trampoline()
 
-//go:linkname libc_umask libc_umask
 //go:cgo_import_dynamic libc_umask umask "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1679,7 +1581,6 @@ func Undelete(path string) (err error) {
 
 func libc_undelete_trampoline()
 
-//go:linkname libc_undelete libc_undelete
 //go:cgo_import_dynamic libc_undelete undelete "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1699,7 +1600,6 @@ func Unlink(path string) (err error) {
 
 func libc_unlink_trampoline()
 
-//go:linkname libc_unlink libc_unlink
 //go:cgo_import_dynamic libc_unlink unlink "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1719,7 +1619,6 @@ func Unmount(path string, flags int) (err error) {
 
 func libc_unmount_trampoline()
 
-//go:linkname libc_unmount libc_unmount
 //go:cgo_import_dynamic libc_unmount unmount "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1741,7 +1640,6 @@ func write(fd int, p []byte) (n int, err error) {
 
 func libc_write_trampoline()
 
-//go:linkname libc_write libc_write
 //go:cgo_import_dynamic libc_write write "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1763,7 +1661,6 @@ func writev(fd int, iovecs []Iovec) (cnt uintptr, err error) {
 
 func libc_writev_trampoline()
 
-//go:linkname libc_writev libc_writev
 //go:cgo_import_dynamic libc_writev writev "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1779,7 +1676,6 @@ func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (
 
 func libc_mmap_trampoline()
 
-//go:linkname libc_mmap libc_mmap
 //go:cgo_import_dynamic libc_mmap mmap "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1794,7 +1690,6 @@ func munmap(addr uintptr, length uintptr) (err error) {
 
 func libc_munmap_trampoline()
 
-//go:linkname libc_munmap libc_munmap
 //go:cgo_import_dynamic libc_munmap munmap "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1810,7 +1705,6 @@ func fork() (pid int, err error) {
 
 func libc_fork_trampoline()
 
-//go:linkname libc_fork libc_fork
 //go:cgo_import_dynamic libc_fork fork "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1825,7 +1719,6 @@ func ioctl(fd int, req int, arg int) (err error) {
 
 func libc_ioctl_trampoline()
 
-//go:linkname libc_ioctl libc_ioctl
 //go:cgo_import_dynamic libc_ioctl ioctl "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1850,7 +1743,6 @@ func execve(path *byte, argv **byte, envp **byte) (err error) {
 
 func libc_execve_trampoline()
 
-//go:linkname libc_execve libc_execve
 //go:cgo_import_dynamic libc_execve execve "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1865,7 +1757,6 @@ func exit(res int) (err error) {
 
 func libc_exit_trampoline()
 
-//go:linkname libc_exit libc_exit
 //go:cgo_import_dynamic libc_exit exit "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1886,7 +1777,6 @@ func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr)
 
 func libc_sysctl_trampoline()
 
-//go:linkname libc_sysctl libc_sysctl
 //go:cgo_import_dynamic libc_sysctl sysctl "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1917,7 +1807,6 @@ func unlinkat(fd int, path string, flags int) (err error) {
 
 func libc_unlinkat_trampoline()
 
-//go:linkname libc_unlinkat libc_unlinkat
 //go:cgo_import_dynamic libc_unlinkat unlinkat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1938,7 +1827,6 @@ func openat(fd int, path string, flags int, perm uint32) (fdret int, err error)
 
 func libc_openat_trampoline()
 
-//go:linkname libc_openat libc_openat
 //go:cgo_import_dynamic libc_openat openat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1960,7 +1848,6 @@ func getcwd(buf []byte) (n int, err error) {
 
 func libc_getcwd_trampoline()
 
-//go:linkname libc_getcwd libc_getcwd
 //go:cgo_import_dynamic libc_getcwd getcwd "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1975,7 +1862,6 @@ func Fstat(fd int, stat *Stat_t) (err error) {
 
 func libc_fstat64_trampoline()
 
-//go:linkname libc_fstat64 libc_fstat64
 //go:cgo_import_dynamic libc_fstat64 fstat64 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1990,7 +1876,6 @@ func Fstatfs(fd int, stat *Statfs_t) (err error) {
 
 func libc_fstatfs64_trampoline()
 
-//go:linkname libc_fstatfs64 libc_fstatfs64
 //go:cgo_import_dynamic libc_fstatfs64 fstatfs64 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -2005,7 +1890,6 @@ func Gettimeofday(tp *Timeval) (err error) {
 
 func libc_gettimeofday_trampoline()
 
-//go:linkname libc_gettimeofday libc_gettimeofday
 //go:cgo_import_dynamic libc_gettimeofday gettimeofday "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -2025,7 +1909,6 @@ func Lstat(path string, stat *Stat_t) (err error) {
 
 func libc_lstat64_trampoline()
 
-//go:linkname libc_lstat64 libc_lstat64
 //go:cgo_import_dynamic libc_lstat64 lstat64 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -2045,7 +1928,6 @@ func Stat(path string, stat *Stat_t) (err error) {
 
 func libc_stat64_trampoline()
 
-//go:linkname libc_stat64 libc_stat64
 //go:cgo_import_dynamic libc_stat64 stat64 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -2065,7 +1947,6 @@ func Statfs(path string, stat *Statfs_t) (err error) {
 
 func libc_statfs64_trampoline()
 
-//go:linkname libc_statfs64 libc_statfs64
 //go:cgo_import_dynamic libc_statfs64 statfs64 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -2085,7 +1966,6 @@ func fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
 
 func libc_fstatat64_trampoline()
 
-//go:linkname libc_fstatat64 libc_fstatat64
 //go:cgo_import_dynamic libc_fstatat64 fstatat64 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -2101,5 +1981,4 @@ func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
 
 func libc_ptrace_trampoline()
 
-//go:linkname libc_ptrace libc_ptrace
 //go:cgo_import_dynamic libc_ptrace ptrace "/usr/lib/libSystem.B.dylib"
diff --git a/src/syscall/zsyscall_darwin_arm64.go b/src/syscall/zsyscall_darwin_arm64.go
index 7698b2503e..ac530f3108 100644
--- a/src/syscall/zsyscall_darwin_arm64.go
+++ b/src/syscall/zsyscall_darwin_arm64.go
@@ -20,7 +20,6 @@ func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
 
 func libc_getgroups_trampoline()
 
-//go:linkname libc_getgroups libc_getgroups
 //go:cgo_import_dynamic libc_getgroups getgroups "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -35,7 +34,6 @@ func setgroups(ngid int, gid *_Gid_t) (err error) {
 
 func libc_setgroups_trampoline()
 
-//go:linkname libc_setgroups libc_setgroups
 //go:cgo_import_dynamic libc_setgroups setgroups "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -51,7 +49,6 @@ func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err
 
 func libc_wait4_trampoline()
 
-//go:linkname libc_wait4 libc_wait4
 //go:cgo_import_dynamic libc_wait4 wait4 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -67,7 +64,6 @@ func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
 
 func libc_accept_trampoline()
 
-//go:linkname libc_accept libc_accept
 //go:cgo_import_dynamic libc_accept accept "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -82,7 +78,6 @@ func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
 
 func libc_bind_trampoline()
 
-//go:linkname libc_bind libc_bind
 //go:cgo_import_dynamic libc_bind bind "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -97,7 +92,6 @@ func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
 
 func libc_connect_trampoline()
 
-//go:linkname libc_connect libc_connect
 //go:cgo_import_dynamic libc_connect connect "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -113,7 +107,6 @@ func socket(domain int, typ int, proto int) (fd int, err error) {
 
 func libc_socket_trampoline()
 
-//go:linkname libc_socket libc_socket
 //go:cgo_import_dynamic libc_socket socket "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -128,7 +121,6 @@ func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen
 
 func libc_getsockopt_trampoline()
 
-//go:linkname libc_getsockopt libc_getsockopt
 //go:cgo_import_dynamic libc_getsockopt getsockopt "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -143,7 +135,6 @@ func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr)
 
 func libc_setsockopt_trampoline()
 
-//go:linkname libc_setsockopt libc_setsockopt
 //go:cgo_import_dynamic libc_setsockopt setsockopt "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -158,7 +149,6 @@ func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
 
 func libc_getpeername_trampoline()
 
-//go:linkname libc_getpeername libc_getpeername
 //go:cgo_import_dynamic libc_getpeername getpeername "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -173,7 +163,6 @@ func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
 
 func libc_getsockname_trampoline()
 
-//go:linkname libc_getsockname libc_getsockname
 //go:cgo_import_dynamic libc_getsockname getsockname "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -188,7 +177,6 @@ func Shutdown(s int, how int) (err error) {
 
 func libc_shutdown_trampoline()
 
-//go:linkname libc_shutdown libc_shutdown
 //go:cgo_import_dynamic libc_shutdown shutdown "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -203,7 +191,6 @@ func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
 
 func libc_socketpair_trampoline()
 
-//go:linkname libc_socketpair libc_socketpair
 //go:cgo_import_dynamic libc_socketpair socketpair "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -225,7 +212,6 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
 
 func libc_recvfrom_trampoline()
 
-//go:linkname libc_recvfrom libc_recvfrom
 //go:cgo_import_dynamic libc_recvfrom recvfrom "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -246,7 +232,6 @@ func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (
 
 func libc_sendto_trampoline()
 
-//go:linkname libc_sendto libc_sendto
 //go:cgo_import_dynamic libc_sendto sendto "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -262,7 +247,6 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 
 func libc_recvmsg_trampoline()
 
-//go:linkname libc_recvmsg libc_recvmsg
 //go:cgo_import_dynamic libc_recvmsg recvmsg "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -278,7 +262,6 @@ func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 
 func libc_sendmsg_trampoline()
 
-//go:linkname libc_sendmsg libc_sendmsg
 //go:cgo_import_dynamic libc_sendmsg sendmsg "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -294,7 +277,6 @@ func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, ne
 
 func libc_kevent_trampoline()
 
-//go:linkname libc_kevent libc_kevent
 //go:cgo_import_dynamic libc_kevent kevent "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -314,7 +296,6 @@ func utimes(path string, timeval *[2]Timeval) (err error) {
 
 func libc_utimes_trampoline()
 
-//go:linkname libc_utimes libc_utimes
 //go:cgo_import_dynamic libc_utimes utimes "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -329,7 +310,6 @@ func futimes(fd int, timeval *[2]Timeval) (err error) {
 
 func libc_futimes_trampoline()
 
-//go:linkname libc_futimes libc_futimes
 //go:cgo_import_dynamic libc_futimes futimes "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -345,7 +325,6 @@ func fcntl(fd int, cmd int, arg int) (val int, err error) {
 
 func libc_fcntl_trampoline()
 
-//go:linkname libc_fcntl libc_fcntl
 //go:cgo_import_dynamic libc_fcntl fcntl "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -360,7 +339,6 @@ func pipe(p *[2]int32) (err error) {
 
 func libc_pipe_trampoline()
 
-//go:linkname libc_pipe libc_pipe
 //go:cgo_import_dynamic libc_pipe pipe "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -375,7 +353,6 @@ func kill(pid int, signum int, posix int) (err error) {
 
 func libc_kill_trampoline()
 
-//go:linkname libc_kill libc_kill
 //go:cgo_import_dynamic libc_kill kill "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -395,7 +372,6 @@ func Access(path string, mode uint32) (err error) {
 
 func libc_access_trampoline()
 
-//go:linkname libc_access libc_access
 //go:cgo_import_dynamic libc_access access "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -410,7 +386,6 @@ func Adjtime(delta *Timeval, olddelta *Timeval) (err error) {
 
 func libc_adjtime_trampoline()
 
-//go:linkname libc_adjtime libc_adjtime
 //go:cgo_import_dynamic libc_adjtime adjtime "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -430,7 +405,6 @@ func Chdir(path string) (err error) {
 
 func libc_chdir_trampoline()
 
-//go:linkname libc_chdir libc_chdir
 //go:cgo_import_dynamic libc_chdir chdir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -450,7 +424,6 @@ func Chflags(path string, flags int) (err error) {
 
 func libc_chflags_trampoline()
 
-//go:linkname libc_chflags libc_chflags
 //go:cgo_import_dynamic libc_chflags chflags "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -470,7 +443,6 @@ func Chmod(path string, mode uint32) (err error) {
 
 func libc_chmod_trampoline()
 
-//go:linkname libc_chmod libc_chmod
 //go:cgo_import_dynamic libc_chmod chmod "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -490,7 +462,6 @@ func Chown(path string, uid int, gid int) (err error) {
 
 func libc_chown_trampoline()
 
-//go:linkname libc_chown libc_chown
 //go:cgo_import_dynamic libc_chown chown "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -510,7 +481,6 @@ func Chroot(path string) (err error) {
 
 func libc_chroot_trampoline()
 
-//go:linkname libc_chroot libc_chroot
 //go:cgo_import_dynamic libc_chroot chroot "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -525,7 +495,6 @@ func Close(fd int) (err error) {
 
 func libc_close_trampoline()
 
-//go:linkname libc_close libc_close
 //go:cgo_import_dynamic libc_close close "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -540,7 +509,6 @@ func closedir(dir uintptr) (err error) {
 
 func libc_closedir_trampoline()
 
-//go:linkname libc_closedir libc_closedir
 //go:cgo_import_dynamic libc_closedir closedir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -556,7 +524,6 @@ func Dup(fd int) (nfd int, err error) {
 
 func libc_dup_trampoline()
 
-//go:linkname libc_dup libc_dup
 //go:cgo_import_dynamic libc_dup dup "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -571,7 +538,6 @@ func Dup2(from int, to int) (err error) {
 
 func libc_dup2_trampoline()
 
-//go:linkname libc_dup2 libc_dup2
 //go:cgo_import_dynamic libc_dup2 dup2 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -596,7 +562,6 @@ func Exchangedata(path1 string, path2 string, options int) (err error) {
 
 func libc_exchangedata_trampoline()
 
-//go:linkname libc_exchangedata libc_exchangedata
 //go:cgo_import_dynamic libc_exchangedata exchangedata "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -611,7 +576,6 @@ func Fchdir(fd int) (err error) {
 
 func libc_fchdir_trampoline()
 
-//go:linkname libc_fchdir libc_fchdir
 //go:cgo_import_dynamic libc_fchdir fchdir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -626,7 +590,6 @@ func Fchflags(fd int, flags int) (err error) {
 
 func libc_fchflags_trampoline()
 
-//go:linkname libc_fchflags libc_fchflags
 //go:cgo_import_dynamic libc_fchflags fchflags "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -641,7 +604,6 @@ func Fchmod(fd int, mode uint32) (err error) {
 
 func libc_fchmod_trampoline()
 
-//go:linkname libc_fchmod libc_fchmod
 //go:cgo_import_dynamic libc_fchmod fchmod "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -656,7 +618,6 @@ func Fchown(fd int, uid int, gid int) (err error) {
 
 func libc_fchown_trampoline()
 
-//go:linkname libc_fchown libc_fchown
 //go:cgo_import_dynamic libc_fchown fchown "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -671,7 +632,6 @@ func Flock(fd int, how int) (err error) {
 
 func libc_flock_trampoline()
 
-//go:linkname libc_flock libc_flock
 //go:cgo_import_dynamic libc_flock flock "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -687,7 +647,6 @@ func Fpathconf(fd int, name int) (val int, err error) {
 
 func libc_fpathconf_trampoline()
 
-//go:linkname libc_fpathconf libc_fpathconf
 //go:cgo_import_dynamic libc_fpathconf fpathconf "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -702,7 +661,6 @@ func Fsync(fd int) (err error) {
 
 func libc_fsync_trampoline()
 
-//go:linkname libc_fsync libc_fsync
 //go:cgo_import_dynamic libc_fsync fsync "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -717,7 +675,6 @@ func Ftruncate(fd int, length int64) (err error) {
 
 func libc_ftruncate_trampoline()
 
-//go:linkname libc_ftruncate libc_ftruncate
 //go:cgo_import_dynamic libc_ftruncate ftruncate "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -730,7 +687,6 @@ func Getdtablesize() (size int) {
 
 func libc_getdtablesize_trampoline()
 
-//go:linkname libc_getdtablesize libc_getdtablesize
 //go:cgo_import_dynamic libc_getdtablesize getdtablesize "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -743,7 +699,6 @@ func Getegid() (egid int) {
 
 func libc_getegid_trampoline()
 
-//go:linkname libc_getegid libc_getegid
 //go:cgo_import_dynamic libc_getegid getegid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -756,7 +711,6 @@ func Geteuid() (uid int) {
 
 func libc_geteuid_trampoline()
 
-//go:linkname libc_geteuid libc_geteuid
 //go:cgo_import_dynamic libc_geteuid geteuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -769,7 +723,6 @@ func Getgid() (gid int) {
 
 func libc_getgid_trampoline()
 
-//go:linkname libc_getgid libc_getgid
 //go:cgo_import_dynamic libc_getgid getgid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -785,7 +738,6 @@ func Getpgid(pid int) (pgid int, err error) {
 
 func libc_getpgid_trampoline()
 
-//go:linkname libc_getpgid libc_getpgid
 //go:cgo_import_dynamic libc_getpgid getpgid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -798,7 +750,6 @@ func Getpgrp() (pgrp int) {
 
 func libc_getpgrp_trampoline()
 
-//go:linkname libc_getpgrp libc_getpgrp
 //go:cgo_import_dynamic libc_getpgrp getpgrp "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -811,7 +762,6 @@ func Getpid() (pid int) {
 
 func libc_getpid_trampoline()
 
-//go:linkname libc_getpid libc_getpid
 //go:cgo_import_dynamic libc_getpid getpid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -824,7 +774,6 @@ func Getppid() (ppid int) {
 
 func libc_getppid_trampoline()
 
-//go:linkname libc_getppid libc_getppid
 //go:cgo_import_dynamic libc_getppid getppid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -840,7 +789,6 @@ func Getpriority(which int, who int) (prio int, err error) {
 
 func libc_getpriority_trampoline()
 
-//go:linkname libc_getpriority libc_getpriority
 //go:cgo_import_dynamic libc_getpriority getpriority "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -855,7 +803,6 @@ func Getrlimit(which int, lim *Rlimit) (err error) {
 
 func libc_getrlimit_trampoline()
 
-//go:linkname libc_getrlimit libc_getrlimit
 //go:cgo_import_dynamic libc_getrlimit getrlimit "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -870,7 +817,6 @@ func Getrusage(who int, rusage *Rusage) (err error) {
 
 func libc_getrusage_trampoline()
 
-//go:linkname libc_getrusage libc_getrusage
 //go:cgo_import_dynamic libc_getrusage getrusage "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -886,7 +832,6 @@ func Getsid(pid int) (sid int, err error) {
 
 func libc_getsid_trampoline()
 
-//go:linkname libc_getsid libc_getsid
 //go:cgo_import_dynamic libc_getsid getsid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -899,7 +844,6 @@ func Getuid() (uid int) {
 
 func libc_getuid_trampoline()
 
-//go:linkname libc_getuid libc_getuid
 //go:cgo_import_dynamic libc_getuid getuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -912,7 +856,6 @@ func Issetugid() (tainted bool) {
 
 func libc_issetugid_trampoline()
 
-//go:linkname libc_issetugid libc_issetugid
 //go:cgo_import_dynamic libc_issetugid issetugid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -928,7 +871,6 @@ func Kqueue() (fd int, err error) {
 
 func libc_kqueue_trampoline()
 
-//go:linkname libc_kqueue libc_kqueue
 //go:cgo_import_dynamic libc_kqueue kqueue "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -948,7 +890,6 @@ func Lchown(path string, uid int, gid int) (err error) {
 
 func libc_lchown_trampoline()
 
-//go:linkname libc_lchown libc_lchown
 //go:cgo_import_dynamic libc_lchown lchown "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -973,7 +914,6 @@ func Link(path string, link string) (err error) {
 
 func libc_link_trampoline()
 
-//go:linkname libc_link libc_link
 //go:cgo_import_dynamic libc_link link "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -988,7 +928,6 @@ func Listen(s int, backlog int) (err error) {
 
 func libc_listen_trampoline()
 
-//go:linkname libc_listen libc_listen
 //go:cgo_import_dynamic libc_listen listen "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1008,7 +947,6 @@ func Mkdir(path string, mode uint32) (err error) {
 
 func libc_mkdir_trampoline()
 
-//go:linkname libc_mkdir libc_mkdir
 //go:cgo_import_dynamic libc_mkdir mkdir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1028,7 +966,6 @@ func Mkfifo(path string, mode uint32) (err error) {
 
 func libc_mkfifo_trampoline()
 
-//go:linkname libc_mkfifo libc_mkfifo
 //go:cgo_import_dynamic libc_mkfifo mkfifo "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1048,7 +985,6 @@ func Mknod(path string, mode uint32, dev int) (err error) {
 
 func libc_mknod_trampoline()
 
-//go:linkname libc_mknod libc_mknod
 //go:cgo_import_dynamic libc_mknod mknod "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1069,7 +1005,6 @@ func Mlock(b []byte) (err error) {
 
 func libc_mlock_trampoline()
 
-//go:linkname libc_mlock libc_mlock
 //go:cgo_import_dynamic libc_mlock mlock "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1084,7 +1019,6 @@ func Mlockall(flags int) (err error) {
 
 func libc_mlockall_trampoline()
 
-//go:linkname libc_mlockall libc_mlockall
 //go:cgo_import_dynamic libc_mlockall mlockall "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1105,7 +1039,6 @@ func Mprotect(b []byte, prot int) (err error) {
 
 func libc_mprotect_trampoline()
 
-//go:linkname libc_mprotect libc_mprotect
 //go:cgo_import_dynamic libc_mprotect mprotect "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1126,7 +1059,6 @@ func Munlock(b []byte) (err error) {
 
 func libc_munlock_trampoline()
 
-//go:linkname libc_munlock libc_munlock
 //go:cgo_import_dynamic libc_munlock munlock "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1141,7 +1073,6 @@ func Munlockall() (err error) {
 
 func libc_munlockall_trampoline()
 
-//go:linkname libc_munlockall libc_munlockall
 //go:cgo_import_dynamic libc_munlockall munlockall "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1162,7 +1093,6 @@ func Open(path string, mode int, perm uint32) (fd int, err error) {
 
 func libc_open_trampoline()
 
-//go:linkname libc_open libc_open
 //go:cgo_import_dynamic libc_open open "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1183,7 +1113,6 @@ func Pathconf(path string, name int) (val int, err error) {
 
 func libc_pathconf_trampoline()
 
-//go:linkname libc_pathconf libc_pathconf
 //go:cgo_import_dynamic libc_pathconf pathconf "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1205,7 +1134,6 @@ func Pread(fd int, p []byte, offset int64) (n int, err error) {
 
 func libc_pread_trampoline()
 
-//go:linkname libc_pread libc_pread
 //go:cgo_import_dynamic libc_pread pread "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1227,7 +1155,6 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
 
 func libc_pwrite_trampoline()
 
-//go:linkname libc_pwrite libc_pwrite
 //go:cgo_import_dynamic libc_pwrite pwrite "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1249,7 +1176,6 @@ func read(fd int, p []byte) (n int, err error) {
 
 func libc_read_trampoline()
 
-//go:linkname libc_read libc_read
 //go:cgo_import_dynamic libc_read read "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1262,7 +1188,6 @@ func readdir_r(dir uintptr, entry *Dirent, result **Dirent) (res Errno) {
 
 func libc_readdir_r_trampoline()
 
-//go:linkname libc_readdir_r libc_readdir_r
 //go:cgo_import_dynamic libc_readdir_r readdir_r "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1289,7 +1214,6 @@ func Readlink(path string, buf []byte) (n int, err error) {
 
 func libc_readlink_trampoline()
 
-//go:linkname libc_readlink libc_readlink
 //go:cgo_import_dynamic libc_readlink readlink "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1314,7 +1238,6 @@ func Rename(from string, to string) (err error) {
 
 func libc_rename_trampoline()
 
-//go:linkname libc_rename libc_rename
 //go:cgo_import_dynamic libc_rename rename "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1334,7 +1257,6 @@ func Revoke(path string) (err error) {
 
 func libc_revoke_trampoline()
 
-//go:linkname libc_revoke libc_revoke
 //go:cgo_import_dynamic libc_revoke revoke "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1354,7 +1276,6 @@ func Rmdir(path string) (err error) {
 
 func libc_rmdir_trampoline()
 
-//go:linkname libc_rmdir libc_rmdir
 //go:cgo_import_dynamic libc_rmdir rmdir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1370,7 +1291,6 @@ func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
 
 func libc_lseek_trampoline()
 
-//go:linkname libc_lseek libc_lseek
 //go:cgo_import_dynamic libc_lseek lseek "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1385,7 +1305,6 @@ func Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (err error) {
 
 func libc_select_trampoline()
 
-//go:linkname libc_select libc_select
 //go:cgo_import_dynamic libc_select select "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1400,7 +1319,6 @@ func Setegid(egid int) (err error) {
 
 func libc_setegid_trampoline()
 
-//go:linkname libc_setegid libc_setegid
 //go:cgo_import_dynamic libc_setegid setegid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1415,7 +1333,6 @@ func Seteuid(euid int) (err error) {
 
 func libc_seteuid_trampoline()
 
-//go:linkname libc_seteuid libc_seteuid
 //go:cgo_import_dynamic libc_seteuid seteuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1430,7 +1347,6 @@ func Setgid(gid int) (err error) {
 
 func libc_setgid_trampoline()
 
-//go:linkname libc_setgid libc_setgid
 //go:cgo_import_dynamic libc_setgid setgid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1450,7 +1366,6 @@ func Setlogin(name string) (err error) {
 
 func libc_setlogin_trampoline()
 
-//go:linkname libc_setlogin libc_setlogin
 //go:cgo_import_dynamic libc_setlogin setlogin "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1465,7 +1380,6 @@ func Setpgid(pid int, pgid int) (err error) {
 
 func libc_setpgid_trampoline()
 
-//go:linkname libc_setpgid libc_setpgid
 //go:cgo_import_dynamic libc_setpgid setpgid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1480,7 +1394,6 @@ func Setpriority(which int, who int, prio int) (err error) {
 
 func libc_setpriority_trampoline()
 
-//go:linkname libc_setpriority libc_setpriority
 //go:cgo_import_dynamic libc_setpriority setpriority "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1495,7 +1408,6 @@ func Setprivexec(flag int) (err error) {
 
 func libc_setprivexec_trampoline()
 
-//go:linkname libc_setprivexec libc_setprivexec
 //go:cgo_import_dynamic libc_setprivexec setprivexec "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1510,7 +1422,6 @@ func Setregid(rgid int, egid int) (err error) {
 
 func libc_setregid_trampoline()
 
-//go:linkname libc_setregid libc_setregid
 //go:cgo_import_dynamic libc_setregid setregid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1525,7 +1436,6 @@ func Setreuid(ruid int, euid int) (err error) {
 
 func libc_setreuid_trampoline()
 
-//go:linkname libc_setreuid libc_setreuid
 //go:cgo_import_dynamic libc_setreuid setreuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1540,7 +1450,6 @@ func Setrlimit(which int, lim *Rlimit) (err error) {
 
 func libc_setrlimit_trampoline()
 
-//go:linkname libc_setrlimit libc_setrlimit
 //go:cgo_import_dynamic libc_setrlimit setrlimit "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1556,7 +1465,6 @@ func Setsid() (pid int, err error) {
 
 func libc_setsid_trampoline()
 
-//go:linkname libc_setsid libc_setsid
 //go:cgo_import_dynamic libc_setsid setsid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1571,7 +1479,6 @@ func Settimeofday(tp *Timeval) (err error) {
 
 func libc_settimeofday_trampoline()
 
-//go:linkname libc_settimeofday libc_settimeofday
 //go:cgo_import_dynamic libc_settimeofday settimeofday "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1586,7 +1493,6 @@ func Setuid(uid int) (err error) {
 
 func libc_setuid_trampoline()
 
-//go:linkname libc_setuid libc_setuid
 //go:cgo_import_dynamic libc_setuid setuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1611,7 +1517,6 @@ func Symlink(path string, link string) (err error) {
 
 func libc_symlink_trampoline()
 
-//go:linkname libc_symlink libc_symlink
 //go:cgo_import_dynamic libc_symlink symlink "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1626,7 +1531,6 @@ func Sync() (err error) {
 
 func libc_sync_trampoline()
 
-//go:linkname libc_sync libc_sync
 //go:cgo_import_dynamic libc_sync sync "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1646,7 +1550,6 @@ func Truncate(path string, length int64) (err error) {
 
 func libc_truncate_trampoline()
 
-//go:linkname libc_truncate libc_truncate
 //go:cgo_import_dynamic libc_truncate truncate "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1659,7 +1562,6 @@ func Umask(newmask int) (oldmask int) {
 
 func libc_umask_trampoline()
 
-//go:linkname libc_umask libc_umask
 //go:cgo_import_dynamic libc_umask umask "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1679,7 +1581,6 @@ func Undelete(path string) (err error) {
 
 func libc_undelete_trampoline()
 
-//go:linkname libc_undelete libc_undelete
 //go:cgo_import_dynamic libc_undelete undelete "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1699,7 +1600,6 @@ func Unlink(path string) (err error) {
 
 func libc_unlink_trampoline()
 
-//go:linkname libc_unlink libc_unlink
 //go:cgo_import_dynamic libc_unlink unlink "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1719,7 +1619,6 @@ func Unmount(path string, flags int) (err error) {
 
 func libc_unmount_trampoline()
 
-//go:linkname libc_unmount libc_unmount
 //go:cgo_import_dynamic libc_unmount unmount "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1741,7 +1640,6 @@ func write(fd int, p []byte) (n int, err error) {
 
 func libc_write_trampoline()
 
-//go:linkname libc_write libc_write
 //go:cgo_import_dynamic libc_write write "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1763,7 +1661,6 @@ func writev(fd int, iovecs []Iovec) (cnt uintptr, err error) {
 
 func libc_writev_trampoline()
 
-//go:linkname libc_writev libc_writev
 //go:cgo_import_dynamic libc_writev writev "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1779,7 +1676,6 @@ func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (
 
 func libc_mmap_trampoline()
 
-//go:linkname libc_mmap libc_mmap
 //go:cgo_import_dynamic libc_mmap mmap "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1794,7 +1690,6 @@ func munmap(addr uintptr, length uintptr) (err error) {
 
 func libc_munmap_trampoline()
 
-//go:linkname libc_munmap libc_munmap
 //go:cgo_import_dynamic libc_munmap munmap "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1810,7 +1705,6 @@ func fork() (pid int, err error) {
 
 func libc_fork_trampoline()
 
-//go:linkname libc_fork libc_fork
 //go:cgo_import_dynamic libc_fork fork "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1825,7 +1719,6 @@ func ioctl(fd int, req int, arg int) (err error) {
 
 func libc_ioctl_trampoline()
 
-//go:linkname libc_ioctl libc_ioctl
 //go:cgo_import_dynamic libc_ioctl ioctl "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1850,7 +1743,6 @@ func execve(path *byte, argv **byte, envp **byte) (err error) {
 
 func libc_execve_trampoline()
 
-//go:linkname libc_execve libc_execve
 //go:cgo_import_dynamic libc_execve execve "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1865,7 +1757,6 @@ func exit(res int) (err error) {
 
 func libc_exit_trampoline()
 
-//go:linkname libc_exit libc_exit
 //go:cgo_import_dynamic libc_exit exit "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1886,7 +1777,6 @@ func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr)
 
 func libc_sysctl_trampoline()
 
-//go:linkname libc_sysctl libc_sysctl
 //go:cgo_import_dynamic libc_sysctl sysctl "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1917,7 +1807,6 @@ func unlinkat(fd int, path string, flags int) (err error) {
 
 func libc_unlinkat_trampoline()
 
-//go:linkname libc_unlinkat libc_unlinkat
 //go:cgo_import_dynamic libc_unlinkat unlinkat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1938,7 +1827,6 @@ func openat(fd int, path string, flags int, perm uint32) (fdret int, err error)
 
 func libc_openat_trampoline()
 
-//go:linkname libc_openat libc_openat
 //go:cgo_import_dynamic libc_openat openat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1960,7 +1848,6 @@ func getcwd(buf []byte) (n int, err error) {
 
 func libc_getcwd_trampoline()
 
-//go:linkname libc_getcwd libc_getcwd
 //go:cgo_import_dynamic libc_getcwd getcwd "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1975,7 +1862,6 @@ func Fstat(fd int, stat *Stat_t) (err error) {
 
 func libc_fstat_trampoline()
 
-//go:linkname libc_fstat libc_fstat
 //go:cgo_import_dynamic libc_fstat fstat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1990,7 +1876,6 @@ func Fstatfs(fd int, stat *Statfs_t) (err error) {
 
 func libc_fstatfs_trampoline()
 
-//go:linkname libc_fstatfs libc_fstatfs
 //go:cgo_import_dynamic libc_fstatfs fstatfs "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -2005,7 +1890,6 @@ func Gettimeofday(tp *Timeval) (err error) {
 
 func libc_gettimeofday_trampoline()
 
-//go:linkname libc_gettimeofday libc_gettimeofday
 //go:cgo_import_dynamic libc_gettimeofday gettimeofday "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -2025,7 +1909,6 @@ func Lstat(path string, stat *Stat_t) (err error) {
 
 func libc_lstat_trampoline()
 
-//go:linkname libc_lstat libc_lstat
 //go:cgo_import_dynamic libc_lstat lstat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -2045,7 +1928,6 @@ func Stat(path string, stat *Stat_t) (err error) {
 
 func libc_stat_trampoline()
 
-//go:linkname libc_stat libc_stat
 //go:cgo_import_dynamic libc_stat stat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -2065,7 +1947,6 @@ func Statfs(path string, stat *Statfs_t) (err error) {
 
 func libc_statfs_trampoline()
 
-//go:linkname libc_statfs libc_statfs
 //go:cgo_import_dynamic libc_statfs statfs "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -2085,7 +1966,6 @@ func fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
 
 func libc_fstatat_trampoline()
 
-//go:linkname libc_fstatat libc_fstatat
 //go:cgo_import_dynamic libc_fstatat fstatat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -2101,5 +1981,4 @@ func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
 
 func libc_ptrace_trampoline()
 
-//go:linkname libc_ptrace libc_ptrace
 //go:cgo_import_dynamic libc_ptrace ptrace "/usr/lib/libSystem.B.dylib"
diff --git a/test/linkname2.go b/test/linkname2.go
new file mode 100644
index 0000000000..cb7f9be345
--- /dev/null
+++ b/test/linkname2.go
@@ -0,0 +1,27 @@
+// errorcheck
+
+// Copyright 2020 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.
+
+// Tests that errors are reported for misuse of linkname.
+package p
+
+import _ "unsafe"
+
+type t int
+
+var x, y int
+
+//go:linkname x ok
+
+// ERROR "//go:linkname requires linkname argument or -p compiler flag"
+// ERROR "//go:linkname must refer to declared function or variable"
+// ERROR "//go:linkname must refer to declared function or variable"
+// ERROR "duplicate //go:linkname for x"
+
+//line linkname2.go:18
+//go:linkname y
+//go:linkname nonexist nonexist
+//go:linkname t notvarfunc
+//go:linkname x duplicate
-- 
GitLab


From f2311462ab6f2359006f42b7febd19ce95a9bbcf Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 1 Dec 2020 01:01:59 -0800
Subject: [PATCH 0112/2400] [dev.regabi] cmd/compile: cleanup type-checking of
 defined types

The code for type-checking defined types was scattered between
typecheckdef, typecheckdeftype, and setUnderlying. There was redundant
work between them, and setUnderlying also needed to redo a lot of work
because of its brute-force solution of just copying all Type fields.

This CL reorders things so as many of the defined type's fields are
set in advance (in typecheckdeftype), and then setUnderlying only
copies over the details actually needed from the underlying type.

Incidentally, this evidently improves our error handling for an
existing test case, by allowing us to report an additional error.

Passes toolstash/buildall.

Change-Id: Id59a24341e7e960edd1f7366c3e2356da91b9fe7
Reviewed-on: https://go-review.googlesource.com/c/go/+/274432
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/gc/typecheck.go | 78 +++++++++++-------------
 test/fixedbugs/issue28079b.go            |  2 +-
 2 files changed, 38 insertions(+), 42 deletions(-)

diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 874594d764..d9ec06c531 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -3434,33 +3434,28 @@ func setUnderlying(t, underlying *types.Type) {
 		return
 	}
 
-	n := ir.AsNode(t.Nod)
 	ft := t.ForwardType()
-	cache := t.Cache
 
 	// TODO(mdempsky): Fix Type rekinding.
-	*t = *underlying
+	t.Etype = underlying.Etype
+	t.Extra = underlying.Extra
+	t.Width = underlying.Width
+	t.Align = underlying.Align
+	t.Orig = underlying.Orig
 
-	// Restore unnecessarily clobbered attributes.
-	t.Nod = n
-	t.Sym = n.Sym()
-	if n.Name() != nil {
-		t.Vargen = n.Name().Vargen
+	if underlying.NotInHeap() {
+		t.SetNotInHeap(true)
+	}
+	if underlying.Broke() {
+		t.SetBroke(true)
 	}
-	t.Cache = cache
-	t.SetDeferwidth(false)
 
 	// spec: "The declared type does not inherit any methods bound
 	// to the existing type, but the method set of an interface
 	// type [...] remains unchanged."
-	if !t.IsInterface() {
-		*t.Methods() = types.Fields{}
-		*t.AllMethods() = types.Fields{}
-	}
-
-	// Propagate go:notinheap pragma from the Name to the Type.
-	if n.Name() != nil && n.Name().Pragma()&ir.NotInHeap != 0 {
-		t.SetNotInHeap(true)
+	if t.IsInterface() {
+		*t.Methods() = *underlying.Methods()
+		*t.AllMethods() = *underlying.AllMethods()
 	}
 
 	// Update types waiting on this type.
@@ -3476,24 +3471,38 @@ func setUnderlying(t, underlying *types.Type) {
 	}
 }
 
-func typecheckdeftype(n ir.Node) {
+func typecheckdeftype(n *ir.Name) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckdeftype", n)(nil)
 	}
 
+	t := types.New(types.TFORW)
+	t.Sym = n.Sym()
+	t.Vargen = n.Vargen
+	t.Nod = n
+	if n.Pragma()&ir.NotInHeap != 0 {
+		t.SetNotInHeap(true)
+	}
+
+	n.SetType(t)
 	n.SetTypecheck(1)
-	n.Name().Ntype = typecheckNtype(n.Name().Ntype)
-	t := n.Name().Ntype.Type()
-	if t == nil {
+	n.SetWalkdef(1)
+
+	defercheckwidth()
+	errorsBefore := base.Errors()
+	n.Ntype = typecheckNtype(n.Ntype)
+	if underlying := n.Ntype.Type(); underlying != nil {
+		setUnderlying(t, underlying)
+	} else {
 		n.SetDiag(true)
 		n.SetType(nil)
-	} else if n.Type() == nil {
-		n.SetDiag(true)
-	} else {
-		// copy new type and clear fields
-		// that don't come along.
-		setUnderlying(n.Type(), t)
 	}
+	if t.Etype == types.TFORW && base.Errors() > errorsBefore {
+		// Something went wrong during type-checking,
+		// but it was reported. Silence future errors.
+		t.SetBroke(true)
+	}
+	resumecheckwidth()
 }
 
 func typecheckdef(n ir.Node) {
@@ -3655,20 +3664,7 @@ func typecheckdef(n ir.Node) {
 		}
 
 		// regular type declaration
-		defercheckwidth()
-		n.SetWalkdef(1)
-		t := types.New(types.TFORW)
-		t.Nod = n
-		t.Sym = n.Sym()
-		n.SetType(t)
-		errorsBefore := base.Errors()
 		typecheckdeftype(n)
-		if n.Type().Etype == types.TFORW && base.Errors() > errorsBefore {
-			// Something went wrong during type-checking,
-			// but it was reported. Silence future errors.
-			n.Type().SetBroke(true)
-		}
-		resumecheckwidth()
 	}
 
 ret:
diff --git a/test/fixedbugs/issue28079b.go b/test/fixedbugs/issue28079b.go
index 47cc16dfb2..9ff221baff 100644
--- a/test/fixedbugs/issue28079b.go
+++ b/test/fixedbugs/issue28079b.go
@@ -13,5 +13,5 @@ import "unsafe"
 type T [uintptr(unsafe.Pointer(nil))]int // ERROR "non-constant array bound"
 
 func f() {
-	_ = complex(1<<uintptr(unsafe.Pointer(nil)), 0)
+	_ = complex(1<<uintptr(unsafe.Pointer(nil)), 0) // ERROR "shift of type float64"
 }
-- 
GitLab


From 63a6f08b39b8ccb0dbbd373572a04f1a089f3573 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 1 Dec 2020 01:31:29 -0800
Subject: [PATCH 0113/2400] [dev.regabi] cmd/compile: move setUnderlying to
 package types

Now that setUnderlying is decoupled from Nodes, it can be moved into
package types, where it really belongs.

[git-generate]
cd src/cmd/compile/internal/gc
rf '
mv setUnderlying SetUnderlying
mv SetUnderlying typex.go
mv typex.go cmd/compile/internal/types
'

cd ../types
rf '
mv typex.go type.go
'

Change-Id: I76e2d4d8a6df599f24a731c4d8e5774ec83a119c
Reviewed-on: https://go-review.googlesource.com/c/go/+/274433
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/gc/iimport.go   |  2 +-
 src/cmd/compile/internal/gc/typecheck.go | 46 +-----------------------
 src/cmd/compile/internal/types/type.go   | 45 +++++++++++++++++++++++
 3 files changed, 47 insertions(+), 46 deletions(-)

diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 57c5e62182..0696d05c11 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -316,7 +316,7 @@ func (r *importReader) doDecl(n ir.Node) {
 		// after the underlying type has been assigned.
 		defercheckwidth()
 		underlying := r.typ()
-		setUnderlying(t, underlying)
+		types.SetUnderlying(t, underlying)
 		resumecheckwidth()
 
 		if underlying.IsInterface() {
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index d9ec06c531..6858b51699 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -3427,50 +3427,6 @@ func checkMapKeys() {
 	mapqueue = nil
 }
 
-func setUnderlying(t, underlying *types.Type) {
-	if underlying.Etype == types.TFORW {
-		// This type isn't computed yet; when it is, update n.
-		underlying.ForwardType().Copyto = append(underlying.ForwardType().Copyto, t)
-		return
-	}
-
-	ft := t.ForwardType()
-
-	// TODO(mdempsky): Fix Type rekinding.
-	t.Etype = underlying.Etype
-	t.Extra = underlying.Extra
-	t.Width = underlying.Width
-	t.Align = underlying.Align
-	t.Orig = underlying.Orig
-
-	if underlying.NotInHeap() {
-		t.SetNotInHeap(true)
-	}
-	if underlying.Broke() {
-		t.SetBroke(true)
-	}
-
-	// spec: "The declared type does not inherit any methods bound
-	// to the existing type, but the method set of an interface
-	// type [...] remains unchanged."
-	if t.IsInterface() {
-		*t.Methods() = *underlying.Methods()
-		*t.AllMethods() = *underlying.AllMethods()
-	}
-
-	// Update types waiting on this type.
-	for _, w := range ft.Copyto {
-		setUnderlying(w, t)
-	}
-
-	// Double-check use of type as embedded type.
-	if ft.Embedlineno.IsKnown() {
-		if t.IsPtr() || t.IsUnsafePtr() {
-			base.ErrorfAt(ft.Embedlineno, "embedded type cannot be a pointer")
-		}
-	}
-}
-
 func typecheckdeftype(n *ir.Name) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckdeftype", n)(nil)
@@ -3492,7 +3448,7 @@ func typecheckdeftype(n *ir.Name) {
 	errorsBefore := base.Errors()
 	n.Ntype = typecheckNtype(n.Ntype)
 	if underlying := n.Ntype.Type(); underlying != nil {
-		setUnderlying(t, underlying)
+		types.SetUnderlying(t, underlying)
 	} else {
 		n.SetDiag(true)
 		n.SetType(nil)
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 8499a36edc..2a65b713be 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -5,6 +5,7 @@
 package types
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/internal/obj"
 	"cmd/internal/src"
 	"fmt"
@@ -1517,3 +1518,47 @@ var (
 	TypeVoid    = newSSA("void")
 	TypeInt128  = newSSA("int128")
 )
+
+func SetUnderlying(t, underlying *Type) {
+	if underlying.Etype == TFORW {
+		// This type isn't computed yet; when it is, update n.
+		underlying.ForwardType().Copyto = append(underlying.ForwardType().Copyto, t)
+		return
+	}
+
+	ft := t.ForwardType()
+
+	// TODO(mdempsky): Fix Type rekinding.
+	t.Etype = underlying.Etype
+	t.Extra = underlying.Extra
+	t.Width = underlying.Width
+	t.Align = underlying.Align
+	t.Orig = underlying.Orig
+
+	if underlying.NotInHeap() {
+		t.SetNotInHeap(true)
+	}
+	if underlying.Broke() {
+		t.SetBroke(true)
+	}
+
+	// spec: "The declared type does not inherit any methods bound
+	// to the existing type, but the method set of an interface
+	// type [...] remains unchanged."
+	if t.IsInterface() {
+		*t.Methods() = *underlying.Methods()
+		*t.AllMethods() = *underlying.AllMethods()
+	}
+
+	// Update types waiting on this type.
+	for _, w := range ft.Copyto {
+		SetUnderlying(w, t)
+	}
+
+	// Double-check use of type as embedded type.
+	if ft.Embedlineno.IsKnown() {
+		if t.IsPtr() || t.IsUnsafePtr() {
+			base.ErrorfAt(ft.Embedlineno, "embedded type cannot be a pointer")
+		}
+	}
+}
-- 
GitLab


From f37aa5e4e26a7212b6300e2021b8e6ea7000979b Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 1 Dec 2020 01:42:47 -0800
Subject: [PATCH 0114/2400] [dev.regabi] cmd/compile: add NewNamed

The start of abstracting away Type fields. This adds a new constructor
for named types, styled after go/types.NewNamed. Along with helper
methods for SetNod and Pos, this allows hiding Nod.

Change-Id: Ica107034b6346c7b523bf6ae2a34009e350a9aa8
Reviewed-on: https://go-review.googlesource.com/c/go/+/274434
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/fmtmap_test.go           |  1 +
 src/cmd/compile/internal/gc/align.go     |  6 +--
 src/cmd/compile/internal/gc/export.go    |  4 +-
 src/cmd/compile/internal/gc/iexport.go   |  2 +-
 src/cmd/compile/internal/gc/iimport.go   |  2 +-
 src/cmd/compile/internal/gc/subr.go      |  8 ++--
 src/cmd/compile/internal/gc/typecheck.go | 14 +------
 src/cmd/compile/internal/gc/universe.go  | 13 +++---
 src/cmd/compile/internal/ir/expr.go      |  8 +---
 src/cmd/compile/internal/ir/type.go      | 29 ++++----------
 src/cmd/compile/internal/types/type.go   | 51 +++++++++++++++++++++---
 11 files changed, 75 insertions(+), 63 deletions(-)

diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
index 09b06c4d93..ca31705f72 100644
--- a/src/cmd/compile/fmtmap_test.go
+++ b/src/cmd/compile/fmtmap_test.go
@@ -130,6 +130,7 @@ var knownFormats = map[string]string{
 	"cmd/compile/internal/types.EType %d":             "",
 	"cmd/compile/internal/types.EType %s":             "",
 	"cmd/compile/internal/types.EType %v":             "",
+	"cmd/compile/internal/types.IRNode %v":            "",
 	"cmd/internal/obj.ABI %v":                         "",
 	"error %v":                                        "",
 	"float64 %.2f":                                    "",
diff --git a/src/cmd/compile/internal/gc/align.go b/src/cmd/compile/internal/gc/align.go
index ffae8dc27b..5171983af0 100644
--- a/src/cmd/compile/internal/gc/align.go
+++ b/src/cmd/compile/internal/gc/align.go
@@ -205,7 +205,7 @@ func findTypeLoop(t *types.Type, path *[]*types.Type) bool {
 		}
 
 		*path = append(*path, t)
-		if findTypeLoop(ir.AsNode(t.Nod).Name().Ntype.Type(), path) {
+		if findTypeLoop(t.Obj().(*ir.Name).Ntype.Type(), path) {
 			return true
 		}
 		*path = (*path)[:len(*path)-1]
@@ -314,8 +314,8 @@ func dowidth(t *types.Type) {
 	defercheckwidth()
 
 	lno := base.Pos
-	if ir.AsNode(t.Nod) != nil {
-		base.Pos = ir.AsNode(t.Nod).Pos()
+	if pos := t.Pos(); pos.IsKnown() {
+		base.Pos = pos
 	}
 
 	t.Width = -2
diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index 5cd379a7d3..f803a17c60 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -101,9 +101,7 @@ func importsym(ipkg *types.Pkg, s *types.Sym, op ir.Op) ir.Node {
 func importtype(ipkg *types.Pkg, pos src.XPos, s *types.Sym) *types.Type {
 	n := importsym(ipkg, s, ir.OTYPE)
 	if n.Op() != ir.OTYPE {
-		t := types.New(types.TFORW)
-		t.Sym = s
-		t.Nod = n
+		t := types.NewNamed(n)
 
 		n.SetOp(ir.OTYPE)
 		n.SetPos(pos)
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index d6c50c7285..2dfce26596 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -640,7 +640,7 @@ func (w *exportWriter) doTyp(t *types.Type) {
 		}
 
 		w.startType(definedType)
-		w.qualifiedIdent(ir.TypeNode(t))
+		w.qualifiedIdent(t.Obj().(*ir.Name))
 		return
 	}
 
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 0696d05c11..15f1b646f7 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -316,7 +316,7 @@ func (r *importReader) doDecl(n ir.Node) {
 		// after the underlying type has been assigned.
 		defercheckwidth()
 		underlying := r.typ()
-		types.SetUnderlying(t, underlying)
+		t.SetUnderlying(underlying)
 		resumecheckwidth()
 
 		if underlying.IsInterface() {
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 0163653d3b..04c8c537bd 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -1490,9 +1490,9 @@ func ifaceData(pos src.XPos, n ir.Node, t *types.Type) ir.Node {
 // typePos returns the position associated with t.
 // This is where t was declared or where it appeared as a type expression.
 func typePos(t *types.Type) src.XPos {
-	n := ir.AsNode(t.Nod)
-	if n == nil || !n.Pos().IsKnown() {
-		base.Fatalf("bad type: %v", t)
+	if pos := t.Pos(); pos.IsKnown() {
+		return pos
 	}
-	return n.Pos()
+	base.Fatalf("bad type: %v", t)
+	panic("unreachable")
 }
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 6858b51699..dccb5ecdce 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -3432,10 +3432,8 @@ func typecheckdeftype(n *ir.Name) {
 		defer tracePrint("typecheckdeftype", n)(nil)
 	}
 
-	t := types.New(types.TFORW)
-	t.Sym = n.Sym()
+	t := types.NewNamed(n)
 	t.Vargen = n.Vargen
-	t.Nod = n
 	if n.Pragma()&ir.NotInHeap != 0 {
 		t.SetNotInHeap(true)
 	}
@@ -3448,7 +3446,7 @@ func typecheckdeftype(n *ir.Name) {
 	errorsBefore := base.Errors()
 	n.Ntype = typecheckNtype(n.Ntype)
 	if underlying := n.Ntype.Type(); underlying != nil {
-		types.SetUnderlying(t, underlying)
+		t.SetUnderlying(underlying)
 	} else {
 		n.SetDiag(true)
 		n.SetType(nil)
@@ -3895,14 +3893,6 @@ func deadcodeexpr(n ir.Node) ir.Node {
 	return n
 }
 
-func toTypeNode(orig ir.Node, t *types.Type) ir.Node {
-	n := ir.Nod(ir.OTYPE, nil, nil)
-	n.SetPos(orig.Pos())
-	n.SetType(t)
-	t.Nod = n
-	return n
-}
-
 // getIotaValue returns the current value for "iota",
 // or -1 if not within a ConstSpec.
 func getIotaValue() int64 {
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index c3c2c0492a..31b49e05a5 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -337,11 +337,12 @@ func makeErrorInterface() *types.Type {
 
 func lexinit1() {
 	// error type
-	s := ir.BuiltinPkg.Lookup("error")
-	types.Errortype = makeErrorInterface()
-	types.Errortype.Sym = s
-	types.Errortype.Orig = makeErrorInterface()
-	s.Def = ir.TypeNode(types.Errortype)
+	n := ir.NewNameAt(src.NoXPos, ir.BuiltinPkg.Lookup("error"))
+	types.Errortype = types.NewNamed(n)
+	types.Errortype.SetUnderlying(makeErrorInterface())
+	n.SetOp(ir.OTYPE)
+	n.SetType(types.Errortype)
+	n.Sym().Def = n
 	dowidth(types.Errortype)
 
 	// We create separate byte and rune types for better error messages
@@ -353,7 +354,7 @@ func lexinit1() {
 	// type aliases, albeit at the cost of having to deal with it everywhere).
 
 	// byte alias
-	s = ir.BuiltinPkg.Lookup("byte")
+	s := ir.BuiltinPkg.Lookup("byte")
 	types.Bytetype = types.New(types.TUINT8)
 	types.Bytetype.Sym = s
 	s.Def = ir.TypeNode(types.Bytetype)
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 87593520a1..2a7211cfda 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -545,9 +545,7 @@ func (*ParenExpr) CanBeNtype() {}
 func (n *ParenExpr) SetOTYPE(t *types.Type) {
 	n.op = OTYPE
 	n.typ = t
-	if t.Nod == nil {
-		t.Nod = n
-	}
+	t.SetNod(n)
 }
 
 // A ResultExpr represents a direct access to a result slot on the stack frame.
@@ -762,9 +760,7 @@ func (n *StarExpr) SetOTYPE(t *types.Type) {
 	n.op = OTYPE
 	n.X = nil
 	n.typ = t
-	if t.Nod == nil {
-		t.Nod = n
-	}
+	t.SetNod(n)
 }
 
 func (n *StarExpr) DeepCopy(pos src.XPos) Node {
diff --git a/src/cmd/compile/internal/ir/type.go b/src/cmd/compile/internal/ir/type.go
index af8db15e84..446145b24c 100644
--- a/src/cmd/compile/internal/ir/type.go
+++ b/src/cmd/compile/internal/ir/type.go
@@ -5,6 +5,7 @@
 package ir
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"fmt"
@@ -51,12 +52,7 @@ func (n *miniType) setOTYPE(t *types.Type, self Node) {
 	}
 	n.op = OTYPE
 	n.typ = t
-
-	// t.Nod can be non-nil already
-	// in the case of shared *type.Types, like []byte or interface{}.
-	if t.Nod == nil {
-		t.Nod = self
-	}
+	t.SetNod(self)
 }
 
 func (n *miniType) Sym() *types.Sym { return nil }   // for Format OTYPE
@@ -362,20 +358,11 @@ func (n *typeNode) CanBeNtype()                   {}
 
 // TypeNode returns the Node representing the type t.
 func TypeNode(t *types.Type) Ntype {
-	return TypeNodeAt(src.NoXPos, t)
-}
-
-// TypeNodeAt returns the Node representing the type t.
-// If the node must be created, TypeNodeAt uses the position pos.
-// TODO(rsc): Does anyone actually use position on these type nodes?
-func TypeNodeAt(pos src.XPos, t *types.Type) Ntype {
-	// If we copied another type with *t = *u,
-	// then t.Nod might be out of date, so check t.Nod.Type() too.
-	n := AsNode(t.Nod)
-	if n == nil || n.Type() != t {
-		n := newTypeNode(pos, t) // t.Sym may be nil
-		t.Nod = n
-		return n
+	if n := t.Obj(); n != nil {
+		if n.Type() != t {
+			base.Fatalf("type skew: %v has type %v, but expected %v", n, n.Type(), t)
+		}
+		return n.(Ntype)
 	}
-	return n.(Ntype)
+	return newTypeNode(src.NoXPos, t)
 }
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 2a65b713be..d6d56426a5 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -14,7 +14,11 @@ import (
 // IRNode represents an ir.Node, but without needing to import cmd/compile/internal/ir,
 // which would cause an import cycle. The uses in other packages must type assert
 // values of type IRNode to ir.Node or a more specific type.
-type IRNode interface{ Type() *Type }
+type IRNode interface {
+	Pos() src.XPos
+	Sym() *Sym
+	Type() *Type
+}
 
 //go:generate stringer -type EType -trimprefix T
 
@@ -142,7 +146,7 @@ type Type struct {
 	methods    Fields
 	allMethods Fields
 
-	Nod  IRNode // canonical OTYPE node
+	nod  IRNode // canonical OTYPE node
 	Orig *Type  // original type (type literal or predefined type)
 
 	// Cache of composite types, with this type being the element type.
@@ -180,6 +184,24 @@ func (t *Type) SetNoalg(b bool)      { t.flags.set(typeNoalg, b) }
 func (t *Type) SetDeferwidth(b bool) { t.flags.set(typeDeferwidth, b) }
 func (t *Type) SetRecur(b bool)      { t.flags.set(typeRecur, b) }
 
+// SetNod associates t with syntax node n.
+func (t *Type) SetNod(n IRNode) {
+	// t.nod can be non-nil already
+	// in the case of shared *Types, like []byte or interface{}.
+	if t.nod == nil {
+		t.nod = n
+	}
+}
+
+// Pos returns a position associated with t, if any.
+// This should only be used for diagnostics.
+func (t *Type) Pos() src.XPos {
+	if t.nod != nil {
+		return t.nod.Pos()
+	}
+	return src.NoXPos
+}
+
 // Pkg returns the package that t appeared in.
 //
 // Pkg is only defined for function, struct, and interface types
@@ -1519,7 +1541,24 @@ var (
 	TypeInt128  = newSSA("int128")
 )
 
-func SetUnderlying(t, underlying *Type) {
+// NewNamed returns a new named type for the given type name.
+func NewNamed(obj IRNode) *Type {
+	t := New(TFORW)
+	t.Sym = obj.Sym()
+	t.nod = obj
+	return t
+}
+
+// Obj returns the type name for the named type t.
+func (t *Type) Obj() IRNode {
+	if t.Sym != nil {
+		return t.nod
+	}
+	return nil
+}
+
+// SetUnderlying sets the underlying type.
+func (t *Type) SetUnderlying(underlying *Type) {
 	if underlying.Etype == TFORW {
 		// This type isn't computed yet; when it is, update n.
 		underlying.ForwardType().Copyto = append(underlying.ForwardType().Copyto, t)
@@ -1546,13 +1585,13 @@ func SetUnderlying(t, underlying *Type) {
 	// to the existing type, but the method set of an interface
 	// type [...] remains unchanged."
 	if t.IsInterface() {
-		*t.Methods() = *underlying.Methods()
-		*t.AllMethods() = *underlying.AllMethods()
+		t.methods = underlying.methods
+		t.allMethods = underlying.allMethods
 	}
 
 	// Update types waiting on this type.
 	for _, w := range ft.Copyto {
-		SetUnderlying(w, t)
+		w.SetUnderlying(t)
 	}
 
 	// Double-check use of type as embedded type.
-- 
GitLab


From a17c5e2fce9340ec19d4019490b38a7645f244df Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 1 Dec 2020 02:58:41 -0800
Subject: [PATCH 0115/2400] [dev.regabi] cmd/compile: add NewBasic and cleanup
 universe

This CL introduces types.NewBasic, for creating the predeclared
universal types, and reorganizes how the universe is initialized so
that all predeclared types are uniformly constructed.

There are now a bunch of Type fields that are no longer assigned
outside of the package, so this CL also introduces some new accessor
methods that a subsequent CL will mechanically introduce uses of.

Change-Id: Ie7996c3d5f1ca46cd5bfe45ecc91ebfa6a7b6c7d
Reviewed-on: https://go-review.googlesource.com/c/go/+/274435
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/gc/universe.go | 194 +++++++++---------------
 src/cmd/compile/internal/types/type.go  |  21 ++-
 2 files changed, 90 insertions(+), 125 deletions(-)

diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index 31b49e05a5..b1492659b4 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -87,31 +87,80 @@ var unsafeFuncs = [...]struct {
 
 // initUniverse initializes the universe block.
 func initUniverse() {
-	lexinit()
-	typeinit()
-	lexinit1()
-}
+	if Widthptr == 0 {
+		base.Fatalf("typeinit before betypeinit")
+	}
 
-// lexinit initializes known symbols and the basic types.
-func lexinit() {
-	for _, s := range &basicTypes {
-		etype := s.etype
-		if int(etype) >= len(types.Types) {
-			base.Fatalf("lexinit: %s bad etype", s.name)
+	slicePtrOffset = 0
+	sliceLenOffset = Rnd(slicePtrOffset+int64(Widthptr), int64(Widthptr))
+	sliceCapOffset = Rnd(sliceLenOffset+int64(Widthptr), int64(Widthptr))
+	sizeofSlice = Rnd(sliceCapOffset+int64(Widthptr), int64(Widthptr))
+
+	// string is same as slice wo the cap
+	sizeofString = Rnd(sliceLenOffset+int64(Widthptr), int64(Widthptr))
+
+	for et := types.EType(0); et < types.NTYPE; et++ {
+		simtype[et] = et
+	}
+
+	types.Types[types.TANY] = types.New(types.TANY)
+	types.Types[types.TINTER] = types.New(types.TINTER) // empty interface
+
+	defBasic := func(kind types.EType, pkg *types.Pkg, name string) *types.Type {
+		sym := pkg.Lookup(name)
+		n := ir.NewNameAt(src.NoXPos, sym)
+		n.SetOp(ir.OTYPE)
+		t := types.NewBasic(kind, n)
+		n.SetType(t)
+		sym.Def = n
+		if kind != types.TANY {
+			dowidth(t)
 		}
-		s2 := ir.BuiltinPkg.Lookup(s.name)
-		t := types.Types[etype]
-		if t == nil {
-			t = types.New(etype)
-			t.Sym = s2
-			if etype != types.TANY && etype != types.TSTRING {
-				dowidth(t)
-			}
-			types.Types[etype] = t
+		return t
+	}
+
+	for _, s := range &basicTypes {
+		types.Types[s.etype] = defBasic(s.etype, ir.BuiltinPkg, s.name)
+	}
+
+	for _, s := range &typedefs {
+		sameas := s.sameas32
+		if Widthptr == 8 {
+			sameas = s.sameas64
 		}
-		s2.Def = ir.TypeNode(t)
+		simtype[s.etype] = sameas
+
+		types.Types[s.etype] = defBasic(s.etype, ir.BuiltinPkg, s.name)
 	}
 
+	// We create separate byte and rune types for better error messages
+	// rather than just creating type alias *types.Sym's for the uint8 and
+	// int32 types. Hence, (bytetype|runtype).Sym.isAlias() is false.
+	// TODO(gri) Should we get rid of this special case (at the cost
+	// of less informative error messages involving bytes and runes)?
+	// (Alternatively, we could introduce an OTALIAS node representing
+	// type aliases, albeit at the cost of having to deal with it everywhere).
+	types.Bytetype = defBasic(types.TUINT8, ir.BuiltinPkg, "byte")
+	types.Runetype = defBasic(types.TINT32, ir.BuiltinPkg, "rune")
+
+	// error type
+	s := ir.BuiltinPkg.Lookup("error")
+	n := ir.NewNameAt(src.NoXPos, s)
+	n.SetOp(ir.OTYPE)
+	types.Errortype = types.NewNamed(n)
+	types.Errortype.SetUnderlying(makeErrorInterface())
+	n.SetType(types.Errortype)
+	s.Def = n
+	dowidth(types.Errortype)
+
+	types.Types[types.TUNSAFEPTR] = defBasic(types.TUNSAFEPTR, unsafepkg, "Pointer")
+
+	// simple aliases
+	simtype[types.TMAP] = types.TPTR
+	simtype[types.TCHAN] = types.TPTR
+	simtype[types.TFUNC] = types.TPTR
+	simtype[types.TUNSAFEPTR] = types.TPTR
+
 	for _, s := range &builtinFuncs {
 		s2 := ir.BuiltinPkg.Lookup(s.name)
 		s2.Def = NewName(s2)
@@ -124,19 +173,13 @@ func lexinit() {
 		ir.AsNode(s2.Def).SetSubOp(s.op)
 	}
 
-	types.UntypedString = types.New(types.TSTRING)
-	types.UntypedBool = types.New(types.TBOOL)
-	types.Types[types.TANY] = types.New(types.TANY)
-
-	s := ir.BuiltinPkg.Lookup("true")
+	s = ir.BuiltinPkg.Lookup("true")
 	s.Def = nodbool(true)
 	ir.AsNode(s.Def).SetSym(lookup("true"))
-	ir.AsNode(s.Def).SetType(types.UntypedBool)
 
 	s = ir.BuiltinPkg.Lookup("false")
 	s.Def = nodbool(false)
 	ir.AsNode(s.Def).SetSym(lookup("false"))
-	ir.AsNode(s.Def).SetType(types.UntypedBool)
 
 	s = lookup("_")
 	s.Block = -100
@@ -160,28 +203,6 @@ func lexinit() {
 	s = ir.BuiltinPkg.Lookup("iota")
 	s.Def = ir.Nod(ir.OIOTA, nil, nil)
 	ir.AsNode(s.Def).SetSym(s)
-}
-
-func typeinit() {
-	if Widthptr == 0 {
-		base.Fatalf("typeinit before betypeinit")
-	}
-
-	for et := types.EType(0); et < types.NTYPE; et++ {
-		simtype[et] = et
-	}
-
-	types.Types[types.TPTR] = types.New(types.TPTR)
-	dowidth(types.Types[types.TPTR])
-
-	t := types.New(types.TUNSAFEPTR)
-	types.Types[types.TUNSAFEPTR] = t
-	t.Sym = unsafepkg.Lookup("Pointer")
-	n := ir.NewNameAt(src.NoXPos, t.Sym) // NewNameAt to get a package for use tracking
-	n.SetOp(ir.OTYPE)
-	n.SetType(t)
-	t.Sym.Def = n
-	dowidth(types.Types[types.TUNSAFEPTR])
 
 	for et := types.TINT8; et <= types.TUINT64; et++ {
 		isInt[et] = true
@@ -259,8 +280,7 @@ func typeinit() {
 
 	okforcmp[types.TSTRING] = true
 
-	var i int
-	for i = 0; i < len(okfor); i++ {
+	for i := range okfor {
 		okfor[i] = okfornone[:]
 	}
 
@@ -302,25 +322,6 @@ func typeinit() {
 	iscmp[ir.OLE] = true
 	iscmp[ir.OEQ] = true
 	iscmp[ir.ONE] = true
-
-	types.Types[types.TINTER] = types.New(types.TINTER) // empty interface
-
-	// simple aliases
-	simtype[types.TMAP] = types.TPTR
-	simtype[types.TCHAN] = types.TPTR
-	simtype[types.TFUNC] = types.TPTR
-	simtype[types.TUNSAFEPTR] = types.TPTR
-
-	slicePtrOffset = 0
-	sliceLenOffset = Rnd(slicePtrOffset+int64(Widthptr), int64(Widthptr))
-	sliceCapOffset = Rnd(sliceLenOffset+int64(Widthptr), int64(Widthptr))
-	sizeofSlice = Rnd(sliceCapOffset+int64(Widthptr), int64(Widthptr))
-
-	// string is same as slice wo the cap
-	sizeofString = Rnd(sliceLenOffset+int64(Widthptr), int64(Widthptr))
-
-	dowidth(types.Types[types.TSTRING])
-	dowidth(types.UntypedString)
 }
 
 func makeErrorInterface() *types.Type {
@@ -335,59 +336,6 @@ func makeErrorInterface() *types.Type {
 	return t
 }
 
-func lexinit1() {
-	// error type
-	n := ir.NewNameAt(src.NoXPos, ir.BuiltinPkg.Lookup("error"))
-	types.Errortype = types.NewNamed(n)
-	types.Errortype.SetUnderlying(makeErrorInterface())
-	n.SetOp(ir.OTYPE)
-	n.SetType(types.Errortype)
-	n.Sym().Def = n
-	dowidth(types.Errortype)
-
-	// We create separate byte and rune types for better error messages
-	// rather than just creating type alias *types.Sym's for the uint8 and
-	// int32 types. Hence, (bytetype|runtype).Sym.isAlias() is false.
-	// TODO(gri) Should we get rid of this special case (at the cost
-	// of less informative error messages involving bytes and runes)?
-	// (Alternatively, we could introduce an OTALIAS node representing
-	// type aliases, albeit at the cost of having to deal with it everywhere).
-
-	// byte alias
-	s := ir.BuiltinPkg.Lookup("byte")
-	types.Bytetype = types.New(types.TUINT8)
-	types.Bytetype.Sym = s
-	s.Def = ir.TypeNode(types.Bytetype)
-	dowidth(types.Bytetype)
-
-	// rune alias
-	s = ir.BuiltinPkg.Lookup("rune")
-	types.Runetype = types.New(types.TINT32)
-	types.Runetype.Sym = s
-	s.Def = ir.TypeNode(types.Runetype)
-	dowidth(types.Runetype)
-
-	// backend-dependent builtin types (e.g. int).
-	for _, s := range &typedefs {
-		s1 := ir.BuiltinPkg.Lookup(s.name)
-
-		sameas := s.sameas32
-		if Widthptr == 8 {
-			sameas = s.sameas64
-		}
-
-		simtype[s.etype] = sameas
-
-		t := types.New(s.etype)
-		t.Sym = s1
-		types.Types[s.etype] = t
-		s1.Def = ir.TypeNode(t)
-		s1.Origpkg = ir.BuiltinPkg
-
-		dowidth(t)
-	}
-}
-
 // finishUniverse makes the universe block visible within the current package.
 func finishUniverse() {
 	// Operationally, this is similar to a dot import of builtinpkg, except
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index d6d56426a5..f0211a67fb 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -110,8 +110,8 @@ var (
 	Errortype *Type
 
 	// Types to represent untyped string and boolean constants.
-	UntypedString *Type
-	UntypedBool   *Type
+	UntypedString = New(TSTRING)
+	UntypedBool   = New(TBOOL)
 
 	// Types to represent untyped numeric constants.
 	UntypedInt     = New(TIDEAL)
@@ -184,6 +184,15 @@ func (t *Type) SetNoalg(b bool)      { t.flags.set(typeNoalg, b) }
 func (t *Type) SetDeferwidth(b bool) { t.flags.set(typeDeferwidth, b) }
 func (t *Type) SetRecur(b bool)      { t.flags.set(typeRecur, b) }
 
+// Kind returns the kind of type t.
+func (t *Type) Kind() EType { return t.Etype }
+
+// Sym returns the name of type t.
+func (t *Type) GetSym() *Sym { return t.Sym }
+
+// Underlying returns the underlying type of type t.
+func (t *Type) Underlying() *Type { return t.Orig }
+
 // SetNod associates t with syntax node n.
 func (t *Type) SetNod(n IRNode) {
 	// t.nod can be non-nil already
@@ -1601,3 +1610,11 @@ func (t *Type) SetUnderlying(underlying *Type) {
 		}
 	}
 }
+
+// NewNamed returns a new basic type of the given kind.
+func NewBasic(kind EType, obj IRNode) *Type {
+	t := New(kind)
+	t.Sym = obj.Sym()
+	t.nod = obj
+	return t
+}
-- 
GitLab


From 6ca23a45feebc8672a1851dbc65c5b34d481ca30 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 1 Dec 2020 03:52:20 -0800
Subject: [PATCH 0116/2400] [dev.regabi] cmd/compile: only save ONAMEs on
 Curfn.Dcl

There's not really any use to tracking function-scoped constants and
types on Curfn.Dcl, and there's sloppy code that assumes all of the
declarations are variables (e.g., cmpstackvarlt).

Change-Id: I5d10dc681dac2c161c7b73ba808403052ca0608e
Reviewed-on: https://go-review.googlesource.com/c/go/+/274436
Reviewed-by: Russ Cox <rsc@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/dcl.go | 2 +-
 test/live.go                       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 637587392a..3b60496c5c 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -84,7 +84,7 @@ func declare(n *ir.Name, ctxt ir.Class) {
 			base.Pos = n.Pos()
 			base.Fatalf("automatic outside function")
 		}
-		if Curfn != nil && ctxt != ir.PFUNC {
+		if Curfn != nil && ctxt != ir.PFUNC && n.Op() == ir.ONAME {
 			Curfn.Dcl = append(Curfn.Dcl, n)
 		}
 		if n.Op() == ir.OTYPE {
diff --git a/test/live.go b/test/live.go
index 3df7ab01af..d52ce7f007 100644
--- a/test/live.go
+++ b/test/live.go
@@ -718,5 +718,5 @@ func f44(f func() [2]*int) interface{} { // ERROR "live at entry to f44: f"
 	}
 	ret := T{}
 	ret.s[0] = f()
-	return ret // ERROR "stack object .autotmp_5 T"
+	return ret // ERROR "stack object .autotmp_[0-9]+ T"
 }
-- 
GitLab


From 5ffa275f3cab631483a1ce76a63fc4ede3d204e8 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 1 Dec 2020 03:25:29 -0800
Subject: [PATCH 0117/2400] [dev.regabi] cmd/compile: first pass at abstracting
 Type

Passes toolstash/buildall.

[git-generate]
cd src/cmd/compile/internal/ssa
rf '
ex . ../ir ../gc {
  import "cmd/compile/internal/types"
  var t *types.Type
  t.Etype -> t.Kind()
  t.Sym -> t.GetSym()
  t.Orig -> t.Underlying()
}
'

cd ../types
rf '
mv EType Kind
mv IRNode Object

mv Type.Etype Type.kind
mv Type.Sym Type.sym
mv Type.Orig Type.underlying
mv Type.Cache Type.cache

mv Type.GetSym Type.Sym

mv Bytetype ByteType
mv Runetype RuneType
mv Errortype ErrorType
'

cd ../gc
sed -i 's/Bytetype/ByteType/; s/Runetype/RuneType/' mkbuiltin.go

git codereview gofmt
go install cmd/compile/internal/...
go test cmd/compile -u || go test cmd/compile

Change-Id: Ibecb2d7100d3318a49238eb4a78d70acb49eedca
Reviewed-on: https://go-review.googlesource.com/c/go/+/274437
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Russ Cox <rsc@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/fmtmap_test.go                |   8 +-
 src/cmd/compile/internal/gc/alg.go            |  12 +-
 src/cmd/compile/internal/gc/align.go          |  12 +-
 src/cmd/compile/internal/gc/bexport.go        |  10 +-
 src/cmd/compile/internal/gc/builtin.go        |   4 +-
 src/cmd/compile/internal/gc/const.go          |  22 +--
 src/cmd/compile/internal/gc/dcl.go            |  18 +-
 src/cmd/compile/internal/gc/embed.go          |   4 +-
 src/cmd/compile/internal/gc/escape.go         |   2 +-
 src/cmd/compile/internal/gc/go.go             |   2 +-
 src/cmd/compile/internal/gc/iexport.go        |  18 +-
 src/cmd/compile/internal/gc/inl.go            |   4 +-
 src/cmd/compile/internal/gc/mkbuiltin.go      |   4 +-
 src/cmd/compile/internal/gc/obj.go            |   6 +-
 src/cmd/compile/internal/gc/order.go          |   2 +-
 src/cmd/compile/internal/gc/plive.go          |   4 +-
 src/cmd/compile/internal/gc/range.go          |  12 +-
 src/cmd/compile/internal/gc/reflect.go        |  76 ++++----
 src/cmd/compile/internal/gc/ssa.go            |  56 +++---
 src/cmd/compile/internal/gc/subr.go           |  72 +++----
 src/cmd/compile/internal/gc/swt.go            |   4 +-
 src/cmd/compile/internal/gc/typecheck.go      |  80 ++++----
 src/cmd/compile/internal/gc/universe.go       |  26 +--
 src/cmd/compile/internal/gc/walk.go           |  48 ++---
 src/cmd/compile/internal/ir/fmt.go            |  50 ++---
 src/cmd/compile/internal/ir/node.go           |   2 +-
 src/cmd/compile/internal/ir/type.go           |   2 +-
 src/cmd/compile/internal/ir/val.go            |   2 +-
 src/cmd/compile/internal/ssa/expand_calls.go  |  16 +-
 src/cmd/compile/internal/ssa/export_test.go   |   6 +-
 src/cmd/compile/internal/ssa/regalloc.go      |   4 +-
 .../compile/internal/types/etype_string.go    |   4 +-
 src/cmd/compile/internal/types/identity.go    |  12 +-
 src/cmd/compile/internal/types/scope.go       |   8 +-
 src/cmd/compile/internal/types/sym.go         |   2 +-
 src/cmd/compile/internal/types/type.go        | 182 +++++++++---------
 36 files changed, 398 insertions(+), 398 deletions(-)

diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
index ca31705f72..fde9c51b27 100644
--- a/src/cmd/compile/fmtmap_test.go
+++ b/src/cmd/compile/fmtmap_test.go
@@ -127,10 +127,10 @@ var knownFormats = map[string]string{
 	"cmd/compile/internal/syntax.position %s":         "",
 	"cmd/compile/internal/syntax.token %q":            "",
 	"cmd/compile/internal/syntax.token %s":            "",
-	"cmd/compile/internal/types.EType %d":             "",
-	"cmd/compile/internal/types.EType %s":             "",
-	"cmd/compile/internal/types.EType %v":             "",
-	"cmd/compile/internal/types.IRNode %v":            "",
+	"cmd/compile/internal/types.Kind %d":              "",
+	"cmd/compile/internal/types.Kind %s":              "",
+	"cmd/compile/internal/types.Kind %v":              "",
+	"cmd/compile/internal/types.Object %v":            "",
 	"cmd/internal/obj.ABI %v":                         "",
 	"error %v":                                        "",
 	"float64 %.2f":                                    "",
diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index 806417d03d..b2716399a5 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -68,7 +68,7 @@ func IncomparableField(t *types.Type) *types.Field {
 // EqCanPanic reports whether == on type t could panic (has an interface somewhere).
 // t must be comparable.
 func EqCanPanic(t *types.Type) bool {
-	switch t.Etype {
+	switch t.Kind() {
 	default:
 		return false
 	case types.TINTER:
@@ -120,7 +120,7 @@ func algtype1(t *types.Type) (AlgKind, *types.Type) {
 		return ANOEQ, t
 	}
 
-	switch t.Etype {
+	switch t.Kind() {
 	case types.TANY, types.TFORW:
 		// will be defined later.
 		return ANOEQ, t
@@ -274,7 +274,7 @@ func genhash(t *types.Type) *obj.LSym {
 	// (And the closure generated by genhash will also get
 	// dead-code eliminated, as we call the subtype hashers
 	// directly.)
-	switch t.Etype {
+	switch t.Kind() {
 	case types.TARRAY:
 		genhash(t.Elem())
 	case types.TSTRUCT:
@@ -303,7 +303,7 @@ func genhash(t *types.Type) *obj.LSym {
 	np := ir.AsNode(tfn.Type().Params().Field(0).Nname)
 	nh := ir.AsNode(tfn.Type().Params().Field(1).Nname)
 
-	switch t.Etype {
+	switch t.Kind() {
 	case types.TARRAY:
 		// An array of pure memory would be handled by the
 		// standard algorithm, so the element type must not be
@@ -536,7 +536,7 @@ func geneq(t *types.Type) *obj.LSym {
 	// We reach here only for types that have equality but
 	// cannot be handled by the standard algorithms,
 	// so t must be either an array or a struct.
-	switch t.Etype {
+	switch t.Kind() {
 	default:
 		base.Fatalf("geneq %v", t)
 
@@ -613,7 +613,7 @@ func geneq(t *types.Type) *obj.LSym {
 			}
 		}
 
-		switch t.Elem().Etype {
+		switch t.Elem().Kind() {
 		case types.TSTRING:
 			// Do two loops. First, check that all the lengths match (cheap).
 			// Second, check that all the contents match (expensive).
diff --git a/src/cmd/compile/internal/gc/align.go b/src/cmd/compile/internal/gc/align.go
index 5171983af0..af426f5b24 100644
--- a/src/cmd/compile/internal/gc/align.go
+++ b/src/cmd/compile/internal/gc/align.go
@@ -185,7 +185,7 @@ func findTypeLoop(t *types.Type, path *[]*types.Type) bool {
 	// We implement a simple DFS loop-finding algorithm. This
 	// could be faster, but type cycles are rare.
 
-	if t.Sym != nil {
+	if t.Sym() != nil {
 		// Declared type. Check for loops and otherwise
 		// recurse on the type expression used in the type
 		// declaration.
@@ -193,7 +193,7 @@ func findTypeLoop(t *types.Type, path *[]*types.Type) bool {
 		// Type imported from package, so it can't be part of
 		// a type loop (otherwise that package should have
 		// failed to compile).
-		if t.Sym.Pkg != ir.LocalPkg {
+		if t.Sym().Pkg != ir.LocalPkg {
 			return false
 		}
 
@@ -212,7 +212,7 @@ func findTypeLoop(t *types.Type, path *[]*types.Type) bool {
 	} else {
 		// Anonymous type. Recurse on contained types.
 
-		switch t.Etype {
+		switch t.Kind() {
 		case types.TARRAY:
 			if findTypeLoop(t.Elem(), path) {
 				return true
@@ -321,15 +321,15 @@ func dowidth(t *types.Type) {
 	t.Width = -2
 	t.Align = 0 // 0 means use t.Width, below
 
-	et := t.Etype
+	et := t.Kind()
 	switch et {
 	case types.TFUNC, types.TCHAN, types.TMAP, types.TSTRING:
 		break
 
 	// simtype == 0 during bootstrap
 	default:
-		if simtype[t.Etype] != 0 {
-			et = simtype[t.Etype]
+		if simtype[t.Kind()] != 0 {
+			et = simtype[t.Kind()]
 		}
 	}
 
diff --git a/src/cmd/compile/internal/gc/bexport.go b/src/cmd/compile/internal/gc/bexport.go
index dbbac559ae..43c4ce7150 100644
--- a/src/cmd/compile/internal/gc/bexport.go
+++ b/src/cmd/compile/internal/gc/bexport.go
@@ -35,7 +35,7 @@ func (p *exporter) markType(t *types.Type) {
 	// only their unexpanded method set (i.e., exclusive of
 	// interface embeddings), and the switch statement below
 	// handles their full method set.
-	if t.Sym != nil && t.Etype != types.TINTER {
+	if t.Sym() != nil && t.Kind() != types.TINTER {
 		for _, m := range t.Methods().Slice() {
 			if types.IsExported(m.Sym.Name) {
 				p.markObject(ir.AsNode(m.Nname))
@@ -52,7 +52,7 @@ func (p *exporter) markType(t *types.Type) {
 	// Notably, we don't mark function parameter types, because
 	// the user already needs some way to construct values of
 	// those types.
-	switch t.Etype {
+	switch t.Kind() {
 	case types.TPTR, types.TARRAY, types.TSLICE:
 		p.markType(t.Elem())
 
@@ -153,11 +153,11 @@ func predeclared() []*types.Type {
 			types.Types[types.TSTRING],
 
 			// basic type aliases
-			types.Bytetype,
-			types.Runetype,
+			types.ByteType,
+			types.RuneType,
 
 			// error
-			types.Errortype,
+			types.ErrorType,
 
 			// untyped types
 			types.UntypedBool,
diff --git a/src/cmd/compile/internal/gc/builtin.go b/src/cmd/compile/internal/gc/builtin.go
index efca44c667..07e864dd2e 100644
--- a/src/cmd/compile/internal/gc/builtin.go
+++ b/src/cmd/compile/internal/gc/builtin.go
@@ -206,7 +206,7 @@ var runtimeDecls = [...]struct {
 
 func runtimeTypes() []*types.Type {
 	var typs [131]*types.Type
-	typs[0] = types.Bytetype
+	typs[0] = types.ByteType
 	typs[1] = types.NewPtr(typs[0])
 	typs[2] = types.Types[types.TANY]
 	typs[3] = types.NewPtr(typs[2])
@@ -252,7 +252,7 @@ func runtimeTypes() []*types.Type {
 	typs[43] = functype(nil, []*ir.Field{anonfield(typs[42]), anonfield(typs[22])}, []*ir.Field{anonfield(typs[28])})
 	typs[44] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[1]), anonfield(typs[15])}, []*ir.Field{anonfield(typs[28])})
 	typs[45] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[15])}, []*ir.Field{anonfield(typs[28])})
-	typs[46] = types.Runetype
+	typs[46] = types.RuneType
 	typs[47] = types.NewSlice(typs[46])
 	typs[48] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[47])}, []*ir.Field{anonfield(typs[28])})
 	typs[49] = types.NewSlice(typs[0])
diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 4dee373bfa..4a61c77630 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -127,7 +127,7 @@ func convlit1(n ir.Node, t *types.Type, explicit bool, context func() string) ir
 	}
 
 	// Nil is technically not a constant, so handle it specially.
-	if n.Type().Etype == types.TNIL {
+	if n.Type().Kind() == types.TNIL {
 		if n.Op() != ir.ONIL {
 			base.Fatalf("unexpected op: %v (%v)", n, n.Op())
 		}
@@ -147,7 +147,7 @@ func convlit1(n ir.Node, t *types.Type, explicit bool, context func() string) ir
 		return n
 	}
 
-	if t == nil || !ir.OKForConst[t.Etype] {
+	if t == nil || !ir.OKForConst[t.Kind()] {
 		t = defaultType(n.Type())
 	}
 
@@ -245,7 +245,7 @@ func operandType(op ir.Op, t *types.Type) *types.Type {
 			return complexForFloat(t)
 		}
 	default:
-		if okfor[op][t.Etype] {
+		if okfor[op][t.Kind()] {
 			return t
 		}
 	}
@@ -499,12 +499,12 @@ func evalConst(n ir.Node) ir.Node {
 		}
 
 	case ir.OCONV, ir.ORUNESTR:
-		if ir.OKForConst[n.Type().Etype] && nl.Op() == ir.OLITERAL {
+		if ir.OKForConst[n.Type().Kind()] && nl.Op() == ir.OLITERAL {
 			return origConst(n, convertVal(nl.Val(), n.Type(), true))
 		}
 
 	case ir.OCONVNOP:
-		if ir.OKForConst[n.Type().Etype] && nl.Op() == ir.OLITERAL {
+		if ir.OKForConst[n.Type().Kind()] && nl.Op() == ir.OLITERAL {
 			// set so n.Orig gets OCONV instead of OCONVNOP
 			n.SetOp(ir.OCONV)
 			return origConst(n, nl.Val())
@@ -555,7 +555,7 @@ func evalConst(n ir.Node) ir.Node {
 		return n
 
 	case ir.OCAP, ir.OLEN:
-		switch nl.Type().Etype {
+		switch nl.Type().Kind() {
 		case types.TSTRING:
 			if ir.IsConst(nl, constant.String) {
 				return origIntConst(n, int64(len(nl.StringVal())))
@@ -729,7 +729,7 @@ func mixUntyped(t1, t2 *types.Type) *types.Type {
 }
 
 func defaultType(t *types.Type) *types.Type {
-	if !t.IsUntyped() || t.Etype == types.TNIL {
+	if !t.IsUntyped() || t.Kind() == types.TNIL {
 		return t
 	}
 
@@ -741,7 +741,7 @@ func defaultType(t *types.Type) *types.Type {
 	case types.UntypedInt:
 		return types.Types[types.TINT]
 	case types.UntypedRune:
-		return types.Runetype
+		return types.RuneType
 	case types.UntypedFloat:
 		return types.Types[types.TFLOAT64]
 	case types.UntypedComplex:
@@ -769,7 +769,7 @@ func indexconst(n ir.Node) int64 {
 	if n.Op() != ir.OLITERAL {
 		return -1
 	}
-	if !n.Type().IsInteger() && n.Type().Etype != types.TIDEAL {
+	if !n.Type().IsInteger() && n.Type().Kind() != types.TIDEAL {
 		return -1
 	}
 
@@ -885,9 +885,9 @@ func (s *constSet) add(pos src.XPos, n ir.Node, what, where string) {
 
 	typ := n.Type()
 	switch typ {
-	case types.Bytetype:
+	case types.ByteType:
 		typ = types.Types[types.TUINT8]
-	case types.Runetype:
+	case types.RuneType:
 		typ = types.Types[types.TINT32]
 	}
 	k := constSetKey{typ, ir.ConstValue(n)}
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 3b60496c5c..3d0bdaec7a 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -445,7 +445,7 @@ func funcarg(n *ir.Field, ctxt ir.Class) {
 // This happens during import, where the hidden_fndcl rule has
 // used functype directly to parse the function's type.
 func funcargs2(t *types.Type) {
-	if t.Etype != types.TFUNC {
+	if t.Kind() != types.TFUNC {
 		base.Fatalf("funcargs2 %v", t)
 	}
 
@@ -496,7 +496,7 @@ func checkembeddedtype(t *types.Type) {
 		return
 	}
 
-	if t.Sym == nil && t.IsPtr() {
+	if t.Sym() == nil && t.IsPtr() {
 		t = t.Elem()
 		if t.IsInterface() {
 			base.Errorf("embedded type cannot be a pointer to interface")
@@ -505,7 +505,7 @@ func checkembeddedtype(t *types.Type) {
 
 	if t.IsPtr() || t.IsUnsafePtr() {
 		base.Errorf("embedded type cannot be a pointer")
-	} else if t.Etype == types.TFORW && !t.ForwardType().Embedlineno.IsKnown() {
+	} else if t.Kind() == types.TFORW && !t.ForwardType().Embedlineno.IsKnown() {
 		t.ForwardType().Embedlineno = base.Pos
 	}
 }
@@ -719,12 +719,12 @@ func methodSymSuffix(recv *types.Type, msym *types.Sym, suffix string) *types.Sy
 		base.Fatalf("blank method name")
 	}
 
-	rsym := recv.Sym
+	rsym := recv.Sym()
 	if recv.IsPtr() {
 		if rsym != nil {
 			base.Fatalf("declared pointer receiver type: %v", recv)
 		}
-		rsym = recv.Elem().Sym
+		rsym = recv.Elem().Sym()
 	}
 
 	// Find the package the receiver type appeared in. For
@@ -777,11 +777,11 @@ func addmethod(n *ir.Func, msym *types.Sym, t *types.Type, local, nointerface bo
 	}
 
 	mt := methtype(rf.Type)
-	if mt == nil || mt.Sym == nil {
+	if mt == nil || mt.Sym() == nil {
 		pa := rf.Type
 		t := pa
 		if t != nil && t.IsPtr() {
-			if t.Sym != nil {
+			if t.Sym() != nil {
 				base.Errorf("invalid receiver type %v (%v is a pointer type)", pa, t)
 				return nil
 			}
@@ -791,7 +791,7 @@ func addmethod(n *ir.Func, msym *types.Sym, t *types.Type, local, nointerface bo
 		switch {
 		case t == nil || t.Broke():
 			// rely on typecheck having complained before
-		case t.Sym == nil:
+		case t.Sym() == nil:
 			base.Errorf("invalid receiver type %v (%v is not a defined type)", pa, t)
 		case t.IsPtr():
 			base.Errorf("invalid receiver type %v (%v is a pointer type)", pa, t)
@@ -805,7 +805,7 @@ func addmethod(n *ir.Func, msym *types.Sym, t *types.Type, local, nointerface bo
 		return nil
 	}
 
-	if local && mt.Sym.Pkg != ir.LocalPkg {
+	if local && mt.Sym().Pkg != ir.LocalPkg {
 		base.Errorf("cannot define new methods on non-local type %v", mt)
 		return nil
 	}
diff --git a/src/cmd/compile/internal/gc/embed.go b/src/cmd/compile/internal/gc/embed.go
index d9bfd6f5ed..d6e42e4f03 100644
--- a/src/cmd/compile/internal/gc/embed.go
+++ b/src/cmd/compile/internal/gc/embed.go
@@ -151,13 +151,13 @@ func embedKindApprox(typ ir.Node) int {
 
 // embedKind determines the kind of embedding variable.
 func embedKind(typ *types.Type) int {
-	if typ.Sym != nil && typ.Sym.Name == "FS" && (typ.Sym.Pkg.Path == "embed" || (typ.Sym.Pkg == ir.LocalPkg && base.Ctxt.Pkgpath == "embed")) {
+	if typ.Sym() != nil && typ.Sym().Name == "FS" && (typ.Sym().Pkg.Path == "embed" || (typ.Sym().Pkg == ir.LocalPkg && base.Ctxt.Pkgpath == "embed")) {
 		return embedFiles
 	}
 	if typ == types.Types[types.TSTRING] {
 		return embedString
 	}
-	if typ.Sym == nil && typ.IsSlice() && typ.Elem() == types.Bytetype {
+	if typ.Sym() == nil && typ.IsSlice() && typ.Elem() == types.ByteType {
 		return embedBytes
 	}
 	return embedUnknown
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index f2fff02959..b29896e5a4 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -659,7 +659,7 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 // unsafeValue evaluates a uintptr-typed arithmetic expression looking
 // for conversions from an unsafe.Pointer.
 func (e *Escape) unsafeValue(k EscHole, n ir.Node) {
-	if n.Type().Etype != types.TUINTPTR {
+	if n.Type().Kind() != types.TUINTPTR {
 		base.Fatalf("unexpected type %v for %v", n.Type(), n)
 	}
 
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index 24393de53d..c493165c76 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -102,7 +102,7 @@ var gopkg *types.Pkg // pseudo-package for method symbols on anonymous receiver
 
 var zerosize int64
 
-var simtype [types.NTYPE]types.EType
+var simtype [types.NTYPE]types.Kind
 
 var (
 	isInt     [types.NTYPE]bool
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index 2dfce26596..8f50868fc7 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -473,15 +473,15 @@ func (p *iexporter) doDecl(n ir.Node) {
 		w.tag('T')
 		w.pos(n.Pos())
 
-		underlying := n.Type().Orig
-		if underlying == types.Errortype.Orig {
+		underlying := n.Type().Underlying()
+		if underlying == types.ErrorType.Underlying() {
 			// For "type T error", use error as the
 			// underlying type instead of error's own
 			// underlying anonymous interface. This
 			// ensures consistency with how importers may
 			// declare error (e.g., go/types uses nil Pkg
 			// for predeclared objects).
-			underlying = types.Errortype
+			underlying = types.ErrorType
 		}
 		w.typ(underlying)
 
@@ -634,8 +634,8 @@ func (w *exportWriter) startType(k itag) {
 }
 
 func (w *exportWriter) doTyp(t *types.Type) {
-	if t.Sym != nil {
-		if t.Sym.Pkg == ir.BuiltinPkg || t.Sym.Pkg == unsafepkg {
+	if t.Sym() != nil {
+		if t.Sym().Pkg == ir.BuiltinPkg || t.Sym().Pkg == unsafepkg {
 			base.Fatalf("builtin type missing from typIndex: %v", t)
 		}
 
@@ -644,7 +644,7 @@ func (w *exportWriter) doTyp(t *types.Type) {
 		return
 	}
 
-	switch t.Etype {
+	switch t.Kind() {
 	case types.TPTR:
 		w.startType(pointerType)
 		w.typ(t.Elem())
@@ -762,7 +762,7 @@ func constTypeOf(typ *types.Type) constant.Kind {
 		return constant.Complex
 	}
 
-	switch typ.Etype {
+	switch typ.Kind() {
 	case types.TBOOL:
 		return constant.Bool
 	case types.TSTRING:
@@ -809,7 +809,7 @@ func intSize(typ *types.Type) (signed bool, maxBytes uint) {
 		return true, Mpprec / 8
 	}
 
-	switch typ.Etype {
+	switch typ.Kind() {
 	case types.TFLOAT32, types.TCOMPLEX64:
 		return true, 3
 	case types.TFLOAT64, types.TCOMPLEX128:
@@ -821,7 +821,7 @@ func intSize(typ *types.Type) (signed bool, maxBytes uint) {
 
 	// The go/types API doesn't expose sizes to importers, so they
 	// don't know how big these types are.
-	switch typ.Etype {
+	switch typ.Kind() {
 	case types.TINT, types.TUINT, types.TUINTPTR:
 		maxBytes = 8
 	}
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 97ecb9559b..b36a01e389 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -61,10 +61,10 @@ func fnpkg(fn *ir.Name) *types.Pkg {
 		if rcvr.IsPtr() {
 			rcvr = rcvr.Elem()
 		}
-		if rcvr.Sym == nil {
+		if rcvr.Sym() == nil {
 			base.Fatalf("receiver with no sym: [%v] %L  (%v)", fn.Sym(), fn, rcvr)
 		}
-		return rcvr.Sym.Pkg
+		return rcvr.Sym().Pkg
 	}
 
 	// non-method
diff --git a/src/cmd/compile/internal/gc/mkbuiltin.go b/src/cmd/compile/internal/gc/mkbuiltin.go
index 5317484de9..38aa601645 100644
--- a/src/cmd/compile/internal/gc/mkbuiltin.go
+++ b/src/cmd/compile/internal/gc/mkbuiltin.go
@@ -143,9 +143,9 @@ func (i *typeInterner) mktype(t ast.Expr) string {
 	case *ast.Ident:
 		switch t.Name {
 		case "byte":
-			return "types.Bytetype"
+			return "types.ByteType"
 		case "rune":
-			return "types.Runetype"
+			return "types.RuneType"
 		}
 		return fmt.Sprintf("types.Types[types.T%s]", strings.ToUpper(t.Name))
 	case *ast.SelectorExpr:
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 7b5e3015c2..f65131417a 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -218,7 +218,7 @@ func addptabs() {
 		if s.Pkg.Name != "main" {
 			continue
 		}
-		if n.Type().Etype == types.TFUNC && n.Class() == ir.PFUNC {
+		if n.Type().Kind() == types.TFUNC && n.Class() == ir.PFUNC {
 			// function
 			ptabs = append(ptabs, ptabEntry{s: s, t: ir.AsNode(s.Def).Type()})
 		} else {
@@ -602,7 +602,7 @@ func litsym(n, c ir.Node, wid int) {
 
 	case constant.Float:
 		f, _ := constant.Float64Val(u)
-		switch n.Type().Etype {
+		switch n.Type().Kind() {
 		case types.TFLOAT32:
 			s.WriteFloat32(base.Ctxt, n.Offset(), float32(f))
 		case types.TFLOAT64:
@@ -612,7 +612,7 @@ func litsym(n, c ir.Node, wid int) {
 	case constant.Complex:
 		re, _ := constant.Float64Val(constant.Real(u))
 		im, _ := constant.Float64Val(constant.Imag(u))
-		switch n.Type().Etype {
+		switch n.Type().Kind() {
 		case types.TCOMPLEX64:
 			s.WriteFloat32(base.Ctxt, n.Offset(), float32(re))
 			s.WriteFloat32(base.Ctxt, n.Offset()+4, float32(im))
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 83cfb44474..c2e236537f 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -784,7 +784,7 @@ func (o *Order) stmt(n ir.Node) {
 		n.SetRight(o.expr(n.Right(), nil))
 
 		orderBody := true
-		switch n.Type().Etype {
+		switch n.Type().Kind() {
 		default:
 			base.Fatalf("order.stmt range %v", n.Type())
 
diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/gc/plive.go
index 6ad3140081..f2555cc941 100644
--- a/src/cmd/compile/internal/gc/plive.go
+++ b/src/cmd/compile/internal/gc/plive.go
@@ -416,7 +416,7 @@ func onebitwalktype1(t *types.Type, off int64, bv bvec) {
 		return
 	}
 
-	switch t.Etype {
+	switch t.Kind() {
 	case types.TPTR, types.TUNSAFEPTR, types.TFUNC, types.TCHAN, types.TMAP:
 		if off&int64(Widthptr-1) != 0 {
 			base.Fatalf("onebitwalktype1: invalid alignment, %v", t)
@@ -1300,7 +1300,7 @@ func liveness(e *ssafn, f *ssa.Func, pp *Progs) LivenessMap {
 // to fully initialize t.
 func isfat(t *types.Type) bool {
 	if t != nil {
-		switch t.Etype {
+		switch t.Kind() {
 		case types.TSLICE, types.TSTRING,
 			types.TINTER: // maybe remove later
 			return true
diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index 2f2d7051c3..e48642a854 100644
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -61,7 +61,7 @@ func typecheckrangeExpr(n ir.Node) {
 
 	var t1, t2 *types.Type
 	toomany := false
-	switch t.Etype {
+	switch t.Kind() {
 	default:
 		base.ErrorfAt(n.Pos(), "cannot range over %L", n.Right())
 		return
@@ -88,7 +88,7 @@ func typecheckrangeExpr(n ir.Node) {
 
 	case types.TSTRING:
 		t1 = types.Types[types.TINT]
-		t2 = types.Runetype
+		t2 = types.RuneType
 	}
 
 	if n.List().Len() > 2 || toomany {
@@ -208,7 +208,7 @@ func walkrange(nrange ir.Node) ir.Node {
 
 	var body []ir.Node
 	var init []ir.Node
-	switch t.Etype {
+	switch t.Kind() {
 	default:
 		base.Fatalf("walkrange")
 
@@ -375,7 +375,7 @@ func walkrange(nrange ir.Node) ir.Node {
 
 		hv1 := temp(types.Types[types.TINT])
 		hv1t := temp(types.Types[types.TINT])
-		hv2 := temp(types.Runetype)
+		hv2 := temp(types.RuneType)
 
 		// hv1 := 0
 		init = append(init, ir.Nod(ir.OAS, hv1, nil))
@@ -391,7 +391,7 @@ func walkrange(nrange ir.Node) ir.Node {
 		// hv2 := rune(ha[hv1])
 		nind := ir.Nod(ir.OINDEX, ha, hv1)
 		nind.SetBounded(true)
-		body = append(body, ir.Nod(ir.OAS, hv2, conv(nind, types.Runetype)))
+		body = append(body, ir.Nod(ir.OAS, hv2, conv(nind, types.RuneType)))
 
 		// if hv2 < utf8.RuneSelf
 		nif := ir.Nod(ir.OIF, nil, nil)
@@ -467,7 +467,7 @@ func isMapClear(n ir.Node) bool {
 		return false
 	}
 
-	if n.Op() != ir.ORANGE || n.Type().Etype != types.TMAP || n.List().Len() != 1 {
+	if n.Op() != ir.ORANGE || n.Type().Kind() != types.TMAP || n.List().Len() != 1 {
 		return false
 	}
 
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 73d369f413..4ab3005ce8 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -68,7 +68,7 @@ func imethodSize() int     { return 4 + 4 }              // Sizeof(runtime.imeth
 func commonSize() int      { return 4*Widthptr + 8 + 8 } // Sizeof(runtime._type{})
 
 func uncommonSize(t *types.Type) int { // Sizeof(runtime.uncommontype{})
-	if t.Sym == nil && len(methods(t)) == 0 {
+	if t.Sym() == nil && len(methods(t)) == 0 {
 		return 0
 	}
 	return 4 + 2 + 2 + 4 + 4
@@ -448,7 +448,7 @@ func methods(t *types.Type) []*Sig {
 func imethods(t *types.Type) []*Sig {
 	var methods []*Sig
 	for _, f := range t.Fields().Slice() {
-		if f.Type.Etype != types.TFUNC || f.Sym == nil {
+		if f.Type.Kind() != types.TFUNC || f.Sym == nil {
 			continue
 		}
 		if f.Sym.IsBlank() {
@@ -640,7 +640,7 @@ func dname(name, tag string, pkg *types.Pkg, exported bool) *obj.LSym {
 // backing array of the []method field is written (by dextratypeData).
 func dextratype(lsym *obj.LSym, ot int, t *types.Type, dataAdd int) int {
 	m := methods(t)
-	if t.Sym == nil && len(m) == 0 {
+	if t.Sym() == nil && len(m) == 0 {
 		return ot
 	}
 	noff := int(Rnd(int64(ot), int64(Widthptr)))
@@ -672,16 +672,16 @@ func dextratype(lsym *obj.LSym, ot int, t *types.Type, dataAdd int) int {
 }
 
 func typePkg(t *types.Type) *types.Pkg {
-	tsym := t.Sym
+	tsym := t.Sym()
 	if tsym == nil {
-		switch t.Etype {
+		switch t.Kind() {
 		case types.TARRAY, types.TSLICE, types.TPTR, types.TCHAN:
 			if t.Elem() != nil {
-				tsym = t.Elem().Sym
+				tsym = t.Elem().Sym()
 			}
 		}
 	}
-	if tsym != nil && t != types.Types[t.Etype] && t != types.Errortype {
+	if tsym != nil && t != types.Types[t.Kind()] && t != types.ErrorType {
 		return tsym.Pkg
 	}
 	return nil
@@ -753,7 +753,7 @@ func typeptrdata(t *types.Type) int64 {
 		return 0
 	}
 
-	switch t.Etype {
+	switch t.Kind() {
 	case types.TPTR,
 		types.TUNSAFEPTR,
 		types.TFUNC,
@@ -823,7 +823,7 @@ func dcommontype(lsym *obj.LSym, t *types.Type) int {
 	var sptr *obj.LSym
 	if !t.IsPtr() || t.IsPtrElem() {
 		tptr := types.NewPtr(t)
-		if t.Sym != nil || methods(tptr) != nil {
+		if t.Sym() != nil || methods(tptr) != nil {
 			sptrWeak = false
 		}
 		sptr = dtypesym(tptr)
@@ -855,7 +855,7 @@ func dcommontype(lsym *obj.LSym, t *types.Type) int {
 	if uncommonSize(t) != 0 {
 		tflag |= tflagUncommon
 	}
-	if t.Sym != nil && t.Sym.Name != "" {
+	if t.Sym() != nil && t.Sym().Name != "" {
 		tflag |= tflagNamed
 	}
 	if IsRegularMemory(t) {
@@ -872,12 +872,12 @@ func dcommontype(lsym *obj.LSym, t *types.Type) int {
 	if !strings.HasPrefix(p, "*") {
 		p = "*" + p
 		tflag |= tflagExtraStar
-		if t.Sym != nil {
-			exported = types.IsExported(t.Sym.Name)
+		if t.Sym() != nil {
+			exported = types.IsExported(t.Sym().Name)
 		}
 	} else {
-		if t.Elem() != nil && t.Elem().Sym != nil {
-			exported = types.IsExported(t.Elem().Sym.Name)
+		if t.Elem() != nil && t.Elem().Sym() != nil {
+			exported = types.IsExported(t.Elem().Sym().Name)
 		}
 	}
 
@@ -895,7 +895,7 @@ func dcommontype(lsym *obj.LSym, t *types.Type) int {
 	ot = duint8(lsym, ot, t.Align) // align
 	ot = duint8(lsym, ot, t.Align) // fieldAlign
 
-	i = kinds[t.Etype]
+	i = kinds[t.Kind()]
 	if isdirectiface(t) {
 		i |= objabi.KindDirectIface
 	}
@@ -1029,7 +1029,7 @@ func itabname(t, itype *types.Type) ir.Node {
 // isreflexive reports whether t has a reflexive equality operator.
 // That is, if x==x for all x of type t.
 func isreflexive(t *types.Type) bool {
-	switch t.Etype {
+	switch t.Kind() {
 	case types.TBOOL,
 		types.TINT,
 		types.TUINT,
@@ -1075,7 +1075,7 @@ func isreflexive(t *types.Type) bool {
 // needkeyupdate reports whether map updates with t as a key
 // need the key to be updated.
 func needkeyupdate(t *types.Type) bool {
-	switch t.Etype {
+	switch t.Kind() {
 	case types.TBOOL, types.TINT, types.TUINT, types.TINT8, types.TUINT8, types.TINT16, types.TUINT16, types.TINT32, types.TUINT32,
 		types.TINT64, types.TUINT64, types.TUINTPTR, types.TPTR, types.TUNSAFEPTR, types.TCHAN:
 		return false
@@ -1104,7 +1104,7 @@ func needkeyupdate(t *types.Type) bool {
 
 // hashMightPanic reports whether the hash of a map key of type t might panic.
 func hashMightPanic(t *types.Type) bool {
-	switch t.Etype {
+	switch t.Kind() {
 	case types.TINTER:
 		return true
 
@@ -1128,8 +1128,8 @@ func hashMightPanic(t *types.Type) bool {
 // They've been separate internally to make error messages
 // better, but we have to merge them in the reflect tables.
 func formalType(t *types.Type) *types.Type {
-	if t == types.Bytetype || t == types.Runetype {
-		return types.Types[t.Etype]
+	if t == types.ByteType || t == types.RuneType {
+		return types.Types[t.Kind()]
 	}
 	return t
 }
@@ -1152,19 +1152,19 @@ func dtypesym(t *types.Type) *obj.LSym {
 	// emit the type structures for int, float, etc.
 	tbase := t
 
-	if t.IsPtr() && t.Sym == nil && t.Elem().Sym != nil {
+	if t.IsPtr() && t.Sym() == nil && t.Elem().Sym() != nil {
 		tbase = t.Elem()
 	}
 	dupok := 0
-	if tbase.Sym == nil {
+	if tbase.Sym() == nil {
 		dupok = obj.DUPOK
 	}
 
-	if base.Ctxt.Pkgpath != "runtime" || (tbase != types.Types[tbase.Etype] && tbase != types.Bytetype && tbase != types.Runetype && tbase != types.Errortype) { // int, float, etc
+	if base.Ctxt.Pkgpath != "runtime" || (tbase != types.Types[tbase.Kind()] && tbase != types.ByteType && tbase != types.RuneType && tbase != types.ErrorType) { // int, float, etc
 		// named types from other files are defined only by those files
-		if tbase.Sym != nil && tbase.Sym.Pkg != ir.LocalPkg {
+		if tbase.Sym() != nil && tbase.Sym().Pkg != ir.LocalPkg {
 			if i, ok := typeSymIdx[tbase]; ok {
-				lsym.Pkg = tbase.Sym.Pkg.Prefix
+				lsym.Pkg = tbase.Sym().Pkg.Prefix
 				if t != tbase {
 					lsym.SymIdx = int32(i[1])
 				} else {
@@ -1175,13 +1175,13 @@ func dtypesym(t *types.Type) *obj.LSym {
 			return lsym
 		}
 		// TODO(mdempsky): Investigate whether this can happen.
-		if tbase.Etype == types.TFORW {
+		if tbase.Kind() == types.TFORW {
 			return lsym
 		}
 	}
 
 	ot := 0
-	switch t.Etype {
+	switch t.Kind() {
 	default:
 		ot = dcommontype(lsym, t)
 		ot = dextratype(lsym, ot, t, 0)
@@ -1262,8 +1262,8 @@ func dtypesym(t *types.Type) *obj.LSym {
 		ot = dcommontype(lsym, t)
 
 		var tpkg *types.Pkg
-		if t.Sym != nil && t != types.Types[t.Etype] && t != types.Errortype {
-			tpkg = t.Sym.Pkg
+		if t.Sym() != nil && t != types.Types[t.Kind()] && t != types.ErrorType {
+			tpkg = t.Sym().Pkg
 		}
 		ot = dgopkgpath(lsym, ot, tpkg)
 
@@ -1328,7 +1328,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 		ot = dextratype(lsym, ot, t, 0)
 
 	case types.TPTR:
-		if t.Elem().Etype == types.TANY {
+		if t.Elem().Kind() == types.TANY {
 			// ../../../../runtime/type.go:/UnsafePointerType
 			ot = dcommontype(lsym, t)
 			ot = dextratype(lsym, ot, t, 0)
@@ -1397,13 +1397,13 @@ func dtypesym(t *types.Type) *obj.LSym {
 	// When buildmode=shared, all types are in typelinks so the
 	// runtime can deduplicate type pointers.
 	keep := base.Ctxt.Flag_dynlink
-	if !keep && t.Sym == nil {
+	if !keep && t.Sym() == nil {
 		// For an unnamed type, we only need the link if the type can
 		// be created at run time by reflect.PtrTo and similar
 		// functions. If the type exists in the program, those
 		// functions must return the existing type structure rather
 		// than creating a new one.
-		switch t.Etype {
+		switch t.Kind() {
 		case types.TPTR, types.TARRAY, types.TCHAN, types.TFUNC, types.TMAP, types.TSLICE, types.TSTRUCT:
 			keep = true
 		}
@@ -1541,7 +1541,7 @@ func dumpsignats() {
 		for _, ts := range signats {
 			t := ts.t
 			dtypesym(t)
-			if t.Sym != nil {
+			if t.Sym() != nil {
 				dtypesym(types.NewPtr(t))
 			}
 		}
@@ -1616,7 +1616,7 @@ func dumpbasictypes() {
 	// another possible choice would be package main,
 	// but using runtime means fewer copies in object files.
 	if base.Ctxt.Pkgpath == "runtime" {
-		for i := types.EType(1); i <= types.TBOOL; i++ {
+		for i := types.Kind(1); i <= types.TBOOL; i++ {
 			dtypesym(types.NewPtr(types.Types[i]))
 		}
 		dtypesym(types.NewPtr(types.Types[types.TSTRING]))
@@ -1624,9 +1624,9 @@ func dumpbasictypes() {
 
 		// emit type structs for error and func(error) string.
 		// The latter is the type of an auto-generated wrapper.
-		dtypesym(types.NewPtr(types.Errortype))
+		dtypesym(types.NewPtr(types.ErrorType))
 
-		dtypesym(functype(nil, []*ir.Field{anonfield(types.Errortype)}, []*ir.Field{anonfield(types.Types[types.TSTRING])}))
+		dtypesym(functype(nil, []*ir.Field{anonfield(types.ErrorType)}, []*ir.Field{anonfield(types.Types[types.TSTRING])}))
 
 		// add paths for runtime and main, which 6l imports implicitly.
 		dimportpath(Runtimepkg)
@@ -1665,7 +1665,7 @@ func (a typesByString) Less(i, j int) bool {
 	// will be equal for the above checks, but different in DWARF output.
 	// Sort by source position to ensure deterministic order.
 	// See issues 27013 and 30202.
-	if a[i].t.Etype == types.TINTER && a[i].t.Methods().Len() > 0 {
+	if a[i].t.Kind() == types.TINTER && a[i].t.Methods().Len() > 0 {
 		return a[i].t.Methods().Index(0).Pos.Before(a[j].t.Methods().Index(0).Pos)
 	}
 	return false
@@ -1821,7 +1821,7 @@ func (p *GCProg) emit(t *types.Type, offset int64) {
 		p.w.Ptr(offset / int64(Widthptr))
 		return
 	}
-	switch t.Etype {
+	switch t.Kind() {
 	default:
 		base.Fatalf("GCProg.emit: unexpected type %v", t)
 
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 4be6caa0e3..3e020d7b92 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -54,13 +54,13 @@ func initssaconfig() {
 	_ = types.NewPtr(types.Types[types.TINTER])                             // *interface{}
 	_ = types.NewPtr(types.NewPtr(types.Types[types.TSTRING]))              // **string
 	_ = types.NewPtr(types.NewSlice(types.Types[types.TINTER]))             // *[]interface{}
-	_ = types.NewPtr(types.NewPtr(types.Bytetype))                          // **byte
-	_ = types.NewPtr(types.NewSlice(types.Bytetype))                        // *[]byte
+	_ = types.NewPtr(types.NewPtr(types.ByteType))                          // **byte
+	_ = types.NewPtr(types.NewSlice(types.ByteType))                        // *[]byte
 	_ = types.NewPtr(types.NewSlice(types.Types[types.TSTRING]))            // *[]string
 	_ = types.NewPtr(types.NewPtr(types.NewPtr(types.Types[types.TUINT8]))) // ***uint8
 	_ = types.NewPtr(types.Types[types.TINT16])                             // *int16
 	_ = types.NewPtr(types.Types[types.TINT64])                             // *int64
-	_ = types.NewPtr(types.Errortype)                                       // *error
+	_ = types.NewPtr(types.ErrorType)                                       // *error
 	types.NewPtrCacheEnabled = false
 	ssaConfig = ssa.NewConfig(thearch.LinkArch.Name, *types_, base.Ctxt, base.Flag.N == 0)
 	ssaConfig.SoftFloat = thearch.SoftFloat
@@ -1591,7 +1591,7 @@ func (s *state) exit() *ssa.Block {
 
 type opAndType struct {
 	op    ir.Op
-	etype types.EType
+	etype types.Kind
 }
 
 var opToSSA = map[opAndType]ssa.Op{
@@ -1766,8 +1766,8 @@ var opToSSA = map[opAndType]ssa.Op{
 	opAndType{ir.OLE, types.TFLOAT32}: ssa.OpLeq32F,
 }
 
-func (s *state) concreteEtype(t *types.Type) types.EType {
-	e := t.Etype
+func (s *state) concreteEtype(t *types.Type) types.Kind {
+	e := t.Kind()
 	switch e {
 	default:
 		return e
@@ -1799,7 +1799,7 @@ func (s *state) ssaOp(op ir.Op, t *types.Type) ssa.Op {
 }
 
 func floatForComplex(t *types.Type) *types.Type {
-	switch t.Etype {
+	switch t.Kind() {
 	case types.TCOMPLEX64:
 		return types.Types[types.TFLOAT32]
 	case types.TCOMPLEX128:
@@ -1810,7 +1810,7 @@ func floatForComplex(t *types.Type) *types.Type {
 }
 
 func complexForFloat(t *types.Type) *types.Type {
-	switch t.Etype {
+	switch t.Kind() {
 	case types.TFLOAT32:
 		return types.Types[types.TCOMPLEX64]
 	case types.TFLOAT64:
@@ -1822,19 +1822,19 @@ func complexForFloat(t *types.Type) *types.Type {
 
 type opAndTwoTypes struct {
 	op     ir.Op
-	etype1 types.EType
-	etype2 types.EType
+	etype1 types.Kind
+	etype2 types.Kind
 }
 
 type twoTypes struct {
-	etype1 types.EType
-	etype2 types.EType
+	etype1 types.Kind
+	etype2 types.Kind
 }
 
 type twoOpsAndType struct {
 	op1              ssa.Op
 	op2              ssa.Op
-	intermediateType types.EType
+	intermediateType types.Kind
 }
 
 var fpConvOpToSSA = map[twoTypes]twoOpsAndType{
@@ -2115,12 +2115,12 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		v := s.newValue1(ssa.OpCopy, to, x) // ensure that v has the right type
 
 		// CONVNOP closure
-		if to.Etype == types.TFUNC && from.IsPtrShaped() {
+		if to.Kind() == types.TFUNC && from.IsPtrShaped() {
 			return v
 		}
 
 		// named <--> unnamed type or typed <--> untyped const
-		if from.Etype == to.Etype {
+		if from.Kind() == to.Kind() {
 			return v
 		}
 
@@ -2130,7 +2130,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		}
 
 		// map <--> *hmap
-		if to.Etype == types.TMAP && from.IsPtr() &&
+		if to.Kind() == types.TMAP && from.IsPtr() &&
 			to.MapType().Hmap == from.Elem() {
 			return v
 		}
@@ -2141,8 +2141,8 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 			s.Fatalf("CONVNOP width mismatch %v (%d) -> %v (%d)\n", from, from.Width, to, to.Width)
 			return nil
 		}
-		if etypesign(from.Etype) != etypesign(to.Etype) {
-			s.Fatalf("CONVNOP sign mismatch %v (%s) -> %v (%s)\n", from, from.Etype, to, to.Etype)
+		if etypesign(from.Kind()) != etypesign(to.Kind()) {
+			s.Fatalf("CONVNOP sign mismatch %v (%s) -> %v (%s)\n", from, from.Kind(), to, to.Kind())
 			return nil
 		}
 
@@ -2153,7 +2153,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 			return v
 		}
 
-		if etypesign(from.Etype) == 0 {
+		if etypesign(from.Kind()) == 0 {
 			s.Fatalf("CONVNOP unrecognized non-integer %v -> %v\n", from, to)
 			return nil
 		}
@@ -2329,7 +2329,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 				s.newValueOrSfCall1(op, ttp, s.newValue1(ssa.OpComplexImag, ftp, x)))
 		}
 
-		s.Fatalf("unhandled OCONV %s -> %s", n.Left().Type().Etype, n.Type().Etype)
+		s.Fatalf("unhandled OCONV %s -> %s", n.Left().Type().Kind(), n.Type().Kind())
 		return nil
 
 	case ir.ODOTTYPE:
@@ -3172,7 +3172,7 @@ const (
 
 type sfRtCallDef struct {
 	rtfn  *obj.LSym
-	rtype types.EType
+	rtype types.Kind
 }
 
 var softFloatOps map[ssa.Op]sfRtCallDef
@@ -3467,9 +3467,9 @@ func init() {
 		},
 		sys.AMD64, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 
-	type atomicOpEmitter func(s *state, n ir.Node, args []*ssa.Value, op ssa.Op, typ types.EType)
+	type atomicOpEmitter func(s *state, n ir.Node, args []*ssa.Value, op ssa.Op, typ types.Kind)
 
-	makeAtomicGuardedIntrinsicARM64 := func(op0, op1 ssa.Op, typ, rtyp types.EType, emit atomicOpEmitter) intrinsicBuilder {
+	makeAtomicGuardedIntrinsicARM64 := func(op0, op1 ssa.Op, typ, rtyp types.Kind, emit atomicOpEmitter) intrinsicBuilder {
 
 		return func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
 			// Target Atomic feature is identified by dynamic detection
@@ -3505,7 +3505,7 @@ func init() {
 		}
 	}
 
-	atomicXchgXaddEmitterARM64 := func(s *state, n ir.Node, args []*ssa.Value, op ssa.Op, typ types.EType) {
+	atomicXchgXaddEmitterARM64 := func(s *state, n ir.Node, args []*ssa.Value, op ssa.Op, typ types.Kind) {
 		v := s.newValue3(op, types.NewTuple(types.Types[typ], types.TypeMem), args[0], args[1], s.mem())
 		s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 		s.vars[n] = s.newValue1(ssa.OpSelect0, types.Types[typ], v)
@@ -3561,7 +3561,7 @@ func init() {
 		},
 		sys.PPC64)
 
-	atomicCasEmitterARM64 := func(s *state, n ir.Node, args []*ssa.Value, op ssa.Op, typ types.EType) {
+	atomicCasEmitterARM64 := func(s *state, n ir.Node, args []*ssa.Value, op ssa.Op, typ types.Kind) {
 		v := s.newValue4(op, types.NewTuple(types.Types[types.TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
 		s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 		s.vars[n] = s.newValue1(ssa.OpSelect0, types.Types[typ], v)
@@ -3599,7 +3599,7 @@ func init() {
 		},
 		sys.AMD64, sys.MIPS, sys.PPC64, sys.S390X)
 
-	atomicAndOrEmitterARM64 := func(s *state, n ir.Node, args []*ssa.Value, op ssa.Op, typ types.EType) {
+	atomicAndOrEmitterARM64 := func(s *state, n ir.Node, args []*ssa.Value, op ssa.Op, typ types.Kind) {
 		s.vars[memVar] = s.newValue3(op, types.TypeMem, args[0], args[1], s.mem())
 	}
 
@@ -4810,7 +4810,7 @@ func (s *state) getClosureAndRcvr(fn ir.Node) (*ssa.Value, *ssa.Value) {
 
 // etypesign returns the signed-ness of e, for integer/pointer etypes.
 // -1 means signed, +1 means unsigned, 0 means non-integer/non-pointer.
-func etypesign(e types.EType) int8 {
+func etypesign(e types.Kind) int8 {
 	switch e {
 	case types.TINT8, types.TINT16, types.TINT32, types.TINT64, types.TINT:
 		return -1
@@ -4980,7 +4980,7 @@ func canSSAType(t *types.Type) bool {
 		// Too big and we'll introduce too much register pressure.
 		return false
 	}
-	switch t.Etype {
+	switch t.Kind() {
 	case types.TARRAY:
 		// We can't do larger arrays because dynamic indexing is
 		// not supported on SSA variables.
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 04c8c537bd..011a7ac5bc 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -181,7 +181,7 @@ func nodstr(s string) ir.Node {
 	return ir.NewLiteral(constant.MakeString(s))
 }
 
-func isptrto(t *types.Type, et types.EType) bool {
+func isptrto(t *types.Type, et types.Kind) bool {
 	if t == nil {
 		return false
 	}
@@ -192,7 +192,7 @@ func isptrto(t *types.Type, et types.EType) bool {
 	if t == nil {
 		return false
 	}
-	if t.Etype != et {
+	if t.Kind() != et {
 		return false
 	}
 	return true
@@ -208,7 +208,7 @@ func methtype(t *types.Type) *types.Type {
 
 	// Strip away pointer if it's there.
 	if t.IsPtr() {
-		if t.Sym != nil {
+		if t.Sym() != nil {
 			return nil
 		}
 		t = t.Elem()
@@ -218,15 +218,15 @@ func methtype(t *types.Type) *types.Type {
 	}
 
 	// Must be a named type or anonymous struct.
-	if t.Sym == nil && !t.IsStruct() {
+	if t.Sym() == nil && !t.IsStruct() {
 		return nil
 	}
 
 	// Check types.
-	if issimple[t.Etype] {
+	if issimple[t.Kind()] {
 		return t
 	}
-	switch t.Etype {
+	switch t.Kind() {
 	case types.TARRAY, types.TCHAN, types.TFUNC, types.TMAP, types.TSLICE, types.TSTRING, types.TSTRUCT:
 		return t
 	}
@@ -241,7 +241,7 @@ func assignop(src, dst *types.Type) (ir.Op, string) {
 	if src == dst {
 		return ir.OCONVNOP, ""
 	}
-	if src == nil || dst == nil || src.Etype == types.TFORW || dst.Etype == types.TFORW || src.Orig == nil || dst.Orig == nil {
+	if src == nil || dst == nil || src.Kind() == types.TFORW || dst.Kind() == types.TFORW || src.Underlying() == nil || dst.Underlying() == nil {
 		return ir.OXXX, ""
 	}
 
@@ -257,13 +257,13 @@ func assignop(src, dst *types.Type) (ir.Op, string) {
 	// we want to recompute the itab. Recomputing the itab ensures
 	// that itabs are unique (thus an interface with a compile-time
 	// type I has an itab with interface type I).
-	if types.Identical(src.Orig, dst.Orig) {
+	if types.Identical(src.Underlying(), dst.Underlying()) {
 		if src.IsEmptyInterface() {
 			// Conversion between two empty interfaces
 			// requires no code.
 			return ir.OCONVNOP, ""
 		}
-		if (src.Sym == nil || dst.Sym == nil) && !src.IsInterface() {
+		if (src.Sym() == nil || dst.Sym() == nil) && !src.IsInterface() {
 			// Conversion between two types, at least one unnamed,
 			// needs no conversion. The exception is nonempty interfaces
 			// which need to have their itab updated.
@@ -272,7 +272,7 @@ func assignop(src, dst *types.Type) (ir.Op, string) {
 	}
 
 	// 3. dst is an interface type and src implements dst.
-	if dst.IsInterface() && src.Etype != types.TNIL {
+	if dst.IsInterface() && src.Kind() != types.TNIL {
 		var missing, have *types.Field
 		var ptr int
 		if implements(src, dst, &missing, &have, &ptr) {
@@ -309,7 +309,7 @@ func assignop(src, dst *types.Type) (ir.Op, string) {
 		return ir.OXXX, why
 	}
 
-	if src.IsInterface() && dst.Etype != types.TBLANK {
+	if src.IsInterface() && dst.Kind() != types.TBLANK {
 		var missing, have *types.Field
 		var ptr int
 		var why string
@@ -323,14 +323,14 @@ func assignop(src, dst *types.Type) (ir.Op, string) {
 	// src and dst have identical element types, and
 	// either src or dst is not a named type.
 	if src.IsChan() && src.ChanDir() == types.Cboth && dst.IsChan() {
-		if types.Identical(src.Elem(), dst.Elem()) && (src.Sym == nil || dst.Sym == nil) {
+		if types.Identical(src.Elem(), dst.Elem()) && (src.Sym() == nil || dst.Sym() == nil) {
 			return ir.OCONVNOP, ""
 		}
 	}
 
 	// 5. src is the predeclared identifier nil and dst is a nillable type.
-	if src.Etype == types.TNIL {
-		switch dst.Etype {
+	if src.Kind() == types.TNIL {
+		switch dst.Kind() {
 		case types.TPTR,
 			types.TFUNC,
 			types.TMAP,
@@ -344,7 +344,7 @@ func assignop(src, dst *types.Type) (ir.Op, string) {
 	// 6. rule about untyped constants - already converted by defaultlit.
 
 	// 7. Any typed value can be assigned to the blank identifier.
-	if dst.Etype == types.TBLANK {
+	if dst.Kind() == types.TBLANK {
 		return ir.OCONVNOP, ""
 	}
 
@@ -373,7 +373,7 @@ func convertop(srcConstant bool, src, dst *types.Type) (ir.Op, string) {
 		return ir.OXXX, why
 	}
 	// (b) Disallow string to []T where T is go:notinheap.
-	if src.IsString() && dst.IsSlice() && dst.Elem().NotInHeap() && (dst.Elem().Etype == types.Bytetype.Etype || dst.Elem().Etype == types.Runetype.Etype) {
+	if src.IsString() && dst.IsSlice() && dst.Elem().NotInHeap() && (dst.Elem().Kind() == types.ByteType.Kind() || dst.Elem().Kind() == types.RuneType.Kind()) {
 		why := fmt.Sprintf(":\n\t%v is incomplete (or unallocatable)", dst.Elem())
 		return ir.OXXX, why
 	}
@@ -393,21 +393,21 @@ func convertop(srcConstant bool, src, dst *types.Type) (ir.Op, string) {
 	}
 
 	// 2. Ignoring struct tags, src and dst have identical underlying types.
-	if types.IdenticalIgnoreTags(src.Orig, dst.Orig) {
+	if types.IdenticalIgnoreTags(src.Underlying(), dst.Underlying()) {
 		return ir.OCONVNOP, ""
 	}
 
 	// 3. src and dst are unnamed pointer types and, ignoring struct tags,
 	// their base types have identical underlying types.
-	if src.IsPtr() && dst.IsPtr() && src.Sym == nil && dst.Sym == nil {
-		if types.IdenticalIgnoreTags(src.Elem().Orig, dst.Elem().Orig) {
+	if src.IsPtr() && dst.IsPtr() && src.Sym() == nil && dst.Sym() == nil {
+		if types.IdenticalIgnoreTags(src.Elem().Underlying(), dst.Elem().Underlying()) {
 			return ir.OCONVNOP, ""
 		}
 	}
 
 	// 4. src and dst are both integer or floating point types.
 	if (src.IsInteger() || src.IsFloat()) && (dst.IsInteger() || dst.IsFloat()) {
-		if simtype[src.Etype] == simtype[dst.Etype] {
+		if simtype[src.Kind()] == simtype[dst.Kind()] {
 			return ir.OCONVNOP, ""
 		}
 		return ir.OCONV, ""
@@ -415,7 +415,7 @@ func convertop(srcConstant bool, src, dst *types.Type) (ir.Op, string) {
 
 	// 5. src and dst are both complex types.
 	if src.IsComplex() && dst.IsComplex() {
-		if simtype[src.Etype] == simtype[dst.Etype] {
+		if simtype[src.Kind()] == simtype[dst.Kind()] {
 			return ir.OCONVNOP, ""
 		}
 		return ir.OCONV, ""
@@ -435,10 +435,10 @@ func convertop(srcConstant bool, src, dst *types.Type) (ir.Op, string) {
 	}
 
 	if src.IsSlice() && dst.IsString() {
-		if src.Elem().Etype == types.Bytetype.Etype {
+		if src.Elem().Kind() == types.ByteType.Kind() {
 			return ir.OBYTES2STR, ""
 		}
-		if src.Elem().Etype == types.Runetype.Etype {
+		if src.Elem().Kind() == types.RuneType.Kind() {
 			return ir.ORUNES2STR, ""
 		}
 	}
@@ -446,10 +446,10 @@ func convertop(srcConstant bool, src, dst *types.Type) (ir.Op, string) {
 	// 7. src is a string and dst is []byte or []rune.
 	// String to slice.
 	if src.IsString() && dst.IsSlice() {
-		if dst.Elem().Etype == types.Bytetype.Etype {
+		if dst.Elem().Kind() == types.ByteType.Kind() {
 			return ir.OSTR2BYTES, ""
 		}
-		if dst.Elem().Etype == types.Runetype.Etype {
+		if dst.Elem().Kind() == types.RuneType.Kind() {
 			return ir.OSTR2RUNES, ""
 		}
 	}
@@ -467,7 +467,7 @@ func convertop(srcConstant bool, src, dst *types.Type) (ir.Op, string) {
 	// src is map and dst is a pointer to corresponding hmap.
 	// This rule is needed for the implementation detail that
 	// go gc maps are implemented as a pointer to a hmap struct.
-	if src.Etype == types.TMAP && dst.IsPtr() &&
+	if src.Kind() == types.TMAP && dst.IsPtr() &&
 		src.MapType().Hmap == dst.Elem() {
 		return ir.OCONVNOP, ""
 	}
@@ -485,7 +485,7 @@ func assignconvfn(n ir.Node, t *types.Type, context func() string) ir.Node {
 		return n
 	}
 
-	if t.Etype == types.TBLANK && n.Type().Etype == types.TNIL {
+	if t.Kind() == types.TBLANK && n.Type().Kind() == types.TNIL {
 		base.Errorf("use of untyped nil")
 	}
 
@@ -493,7 +493,7 @@ func assignconvfn(n ir.Node, t *types.Type, context func() string) ir.Node {
 	if n.Type() == nil {
 		return n
 	}
-	if t.Etype == types.TBLANK {
+	if t.Kind() == types.TBLANK {
 		return n
 	}
 
@@ -600,15 +600,15 @@ func calcHasCall(n ir.Node) bool {
 	// When using soft-float, these ops might be rewritten to function calls
 	// so we ensure they are evaluated first.
 	case ir.OADD, ir.OSUB, ir.ONEG, ir.OMUL:
-		if thearch.SoftFloat && (isFloat[n.Type().Etype] || isComplex[n.Type().Etype]) {
+		if thearch.SoftFloat && (isFloat[n.Type().Kind()] || isComplex[n.Type().Kind()]) {
 			return true
 		}
 	case ir.OLT, ir.OEQ, ir.ONE, ir.OLE, ir.OGE, ir.OGT:
-		if thearch.SoftFloat && (isFloat[n.Left().Type().Etype] || isComplex[n.Left().Type().Etype]) {
+		if thearch.SoftFloat && (isFloat[n.Left().Type().Kind()] || isComplex[n.Left().Type().Kind()]) {
 			return true
 		}
 	case ir.OCONV:
-		if thearch.SoftFloat && ((isFloat[n.Type().Etype] || isComplex[n.Type().Etype]) || (isFloat[n.Left().Type().Etype] || isComplex[n.Left().Type().Etype])) {
+		if thearch.SoftFloat && ((isFloat[n.Type().Kind()] || isComplex[n.Type().Kind()]) || (isFloat[n.Left().Type().Kind()] || isComplex[n.Left().Type().Kind()])) {
 			return true
 		}
 	}
@@ -802,7 +802,7 @@ func lookdot0(s *types.Sym, t *types.Type, save **types.Field, ignorecase bool)
 	}
 
 	u = t
-	if t.Sym != nil && t.IsPtr() && !t.Elem().IsPtr() {
+	if t.Sym() != nil && t.IsPtr() && !t.Elem().IsPtr() {
 		// If t is a defined pointer type, then x.m is shorthand for (*x).m.
 		u = t.Elem()
 	}
@@ -1110,13 +1110,13 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 
 	// Only generate (*T).M wrappers for T.M in T's own package.
 	if rcvr.IsPtr() && rcvr.Elem() == method.Type.Recv().Type &&
-		rcvr.Elem().Sym != nil && rcvr.Elem().Sym.Pkg != ir.LocalPkg {
+		rcvr.Elem().Sym() != nil && rcvr.Elem().Sym().Pkg != ir.LocalPkg {
 		return
 	}
 
 	// Only generate I.M wrappers for I in I's own package
 	// but keep doing it for error.Error (was issue #29304).
-	if rcvr.IsInterface() && rcvr.Sym != nil && rcvr.Sym.Pkg != ir.LocalPkg && rcvr != types.Errortype {
+	if rcvr.IsInterface() && rcvr.Sym() != nil && rcvr.Sym().Pkg != ir.LocalPkg && rcvr != types.ErrorType {
 		return
 	}
 
@@ -1193,7 +1193,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	// Inline calls within (*T).M wrappers. This is safe because we only
 	// generate those wrappers within the same compilation unit as (T).M.
 	// TODO(mdempsky): Investigate why we can't enable this more generally.
-	if rcvr.IsPtr() && rcvr.Elem() == method.Type.Recv().Type && rcvr.Elem().Sym != nil {
+	if rcvr.IsPtr() && rcvr.Elem() == method.Type.Recv().Type && rcvr.Elem().Sym() != nil {
 		inlcalls(fn)
 	}
 	escapeFuncs([]*ir.Func{fn}, false)
@@ -1433,7 +1433,7 @@ func isdirectiface(t *types.Type) bool {
 		return false
 	}
 
-	switch t.Etype {
+	switch t.Kind() {
 	case types.TPTR:
 		// Pointers to notinheap types must be stored indirectly. See issue 42076.
 		return !t.Elem().NotInHeap()
diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index 02d38ac4b1..30179e1dd6 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -157,7 +157,7 @@ func typecheckExprSwitch(n ir.Node) {
 		switch {
 		case t.IsMap():
 			nilonly = "map"
-		case t.Etype == types.TFUNC:
+		case t.Kind() == types.TFUNC:
 			nilonly = "func"
 		case t.IsSlice():
 			nilonly = "slice"
@@ -332,7 +332,7 @@ type exprClause struct {
 
 func (s *exprSwitch) Add(pos src.XPos, expr, jmp ir.Node) {
 	c := exprClause{pos: pos, lo: expr, hi: expr, jmp: jmp}
-	if okforcmp[s.exprname.Type().Etype] && expr.Op() == ir.OLITERAL {
+	if okforcmp[s.exprname.Type().Kind()] && expr.Op() == ir.OLITERAL {
 		s.clauses = append(s.clauses, c)
 		return
 	}
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index dccb5ecdce..f120b44413 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -156,7 +156,7 @@ func typekind(t *types.Type) string {
 	if t.IsUntyped() {
 		return fmt.Sprintf("%v", t)
 	}
-	et := t.Etype
+	et := t.Kind()
 	if int(et) < len(_typekind) {
 		s := _typekind[et]
 		if s != "" {
@@ -329,7 +329,7 @@ func typecheck(n ir.Node, top int) (res ir.Node) {
 // The result of indexlit MUST be assigned back to n, e.g.
 // 	n.Left = indexlit(n.Left)
 func indexlit(n ir.Node) ir.Node {
-	if n != nil && n.Type() != nil && n.Type().Etype == types.TIDEAL {
+	if n != nil && n.Type() != nil && n.Type().Kind() == types.TIDEAL {
 		return defaultlit(n, types.Types[types.TINT])
 	}
 	return n
@@ -583,7 +583,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				n.SetType(nil)
 				return n
 			}
-			if n.Implicit() && !okforarith[l.Type().Etype] {
+			if n.Implicit() && !okforarith[l.Type().Kind()] {
 				base.Errorf("invalid operation: %v (non-numeric type %v)", n, l.Type())
 				n.SetType(nil)
 				return n
@@ -617,7 +617,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				return n
 			}
 			t = l.Type()
-			if t != nil && t.Etype != types.TIDEAL && !t.IsInteger() {
+			if t != nil && t.Kind() != types.TIDEAL && !t.IsInteger() {
 				base.Errorf("invalid operation: %v (shift of type %v)", n, t)
 				n.SetType(nil)
 				return n
@@ -659,15 +659,15 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			return n
 		}
 		t := l.Type()
-		if t.Etype == types.TIDEAL {
+		if t.Kind() == types.TIDEAL {
 			t = r.Type()
 		}
-		et := t.Etype
+		et := t.Kind()
 		if et == types.TIDEAL {
 			et = types.TINT
 		}
 		aop := ir.OXXX
-		if iscmp[n.Op()] && t.Etype != types.TIDEAL && !types.Identical(l.Type(), r.Type()) {
+		if iscmp[n.Op()] && t.Kind() != types.TIDEAL && !types.Identical(l.Type(), r.Type()) {
 			// comparison is okay as long as one side is
 			// assignable to the other.  convert so they have
 			// the same type.
@@ -676,7 +676,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			// in that case, check comparability of the concrete type.
 			// The conversion allocates, so only do it if the concrete type is huge.
 			converted := false
-			if r.Type().Etype != types.TBLANK {
+			if r.Type().Kind() != types.TBLANK {
 				aop, _ = assignop(l.Type(), r.Type())
 				if aop != ir.OXXX {
 					if r.Type().IsInterface() && !l.Type().IsInterface() && !IsComparable(l.Type()) {
@@ -698,7 +698,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				}
 			}
 
-			if !converted && l.Type().Etype != types.TBLANK {
+			if !converted && l.Type().Kind() != types.TBLANK {
 				aop, _ = assignop(r.Type(), l.Type())
 				if aop != ir.OXXX {
 					if l.Type().IsInterface() && !r.Type().IsInterface() && !IsComparable(r.Type()) {
@@ -719,10 +719,10 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				}
 			}
 
-			et = t.Etype
+			et = t.Kind()
 		}
 
-		if t.Etype != types.TIDEAL && !types.Identical(l.Type(), r.Type()) {
+		if t.Kind() != types.TIDEAL && !types.Identical(l.Type(), r.Type()) {
 			l, r = defaultlit2(l, r, true)
 			if l.Type() == nil || r.Type() == nil {
 				n.SetType(nil)
@@ -735,10 +735,10 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			}
 		}
 
-		if t.Etype == types.TIDEAL {
+		if t.Kind() == types.TIDEAL {
 			t = mixUntyped(l.Type(), r.Type())
 		}
-		if dt := defaultType(t); !okfor[op][dt.Etype] {
+		if dt := defaultType(t); !okfor[op][dt.Kind()] {
 			base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(t))
 			n.SetType(nil)
 			return n
@@ -764,7 +764,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			return n
 		}
 
-		if l.Type().Etype == types.TFUNC && !ir.IsNil(l) && !ir.IsNil(r) {
+		if l.Type().Kind() == types.TFUNC && !ir.IsNil(l) && !ir.IsNil(r) {
 			base.Errorf("invalid operation: %v (func can only be compared to nil)", n)
 			n.SetType(nil)
 			return n
@@ -825,7 +825,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			n.SetType(nil)
 			return n
 		}
-		if !okfor[n.Op()][defaultType(t).Etype] {
+		if !okfor[n.Op()][defaultType(t).Kind()] {
 			base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op(), typekind(t))
 			n.SetType(nil)
 			return n
@@ -1023,7 +1023,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			n.SetType(nil)
 			return n
 		}
-		switch t.Etype {
+		switch t.Kind() {
 		default:
 			base.Errorf("invalid operation: %v (type %v does not support indexing)", n, t)
 			n.SetType(nil)
@@ -1032,7 +1032,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		case types.TSTRING, types.TARRAY, types.TSLICE:
 			n.SetRight(indexlit(n.Right()))
 			if t.IsString() {
-				n.SetType(types.Bytetype)
+				n.SetType(types.ByteType)
 			} else {
 				n.SetType(t.Elem())
 			}
@@ -1191,7 +1191,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 		n.SetLeft(defaultlit(n.Left(), types.Types[types.TINT]))
 
-		if !n.Left().Type().IsInteger() && n.Type().Etype != types.TIDEAL {
+		if !n.Left().Type().IsInteger() && n.Type().Kind() != types.TIDEAL {
 			base.Errorf("non-integer len argument in OMAKESLICECOPY")
 		}
 
@@ -1383,7 +1383,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 		default:
 			n.SetOp(ir.OCALLFUNC)
-			if t.Etype != types.TFUNC {
+			if t.Kind() != types.TFUNC {
 				name := l.String()
 				if isBuiltinFuncName(name) && l.Name().Defn != nil {
 					// be more specific when the function
@@ -1446,9 +1446,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 		var ok bool
 		if n.Op() == ir.OLEN {
-			ok = okforlen[t.Etype]
+			ok = okforlen[t.Kind()]
 		} else {
-			ok = okforcap[t.Etype]
+			ok = okforcap[t.Kind()]
 		}
 		if !ok {
 			base.Errorf("invalid argument %L for %v", l, n.Op())
@@ -1469,7 +1469,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 
 		// Determine result type.
-		switch t.Etype {
+		switch t.Kind() {
 		case types.TIDEAL:
 			n.SetType(types.UntypedFloat)
 		case types.TCOMPLEX64:
@@ -1505,7 +1505,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 
 		var t *types.Type
-		switch l.Type().Etype {
+		switch l.Type().Kind() {
 		default:
 			base.Errorf("invalid operation: %v (arguments have type %v, expected floating-point)", n, l.Type())
 			n.SetType(nil)
@@ -1624,7 +1624,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				break
 			}
 
-			args.SetSecond(assignconv(args.Second(), t.Orig, "append"))
+			args.SetSecond(assignconv(args.Second(), t.Underlying(), "append"))
 			break
 		}
 
@@ -1651,7 +1651,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 		// copy([]byte, string)
 		if n.Left().Type().IsSlice() && n.Right().Type().IsString() {
-			if types.Identical(n.Left().Type().Elem(), types.Bytetype) {
+			if types.Identical(n.Left().Type().Elem(), types.ByteType) {
 				break
 			}
 			base.Errorf("arguments to copy have different element types: %L and string", n.Left().Type())
@@ -1701,8 +1701,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		n.SetOp(op)
 		switch n.Op() {
 		case ir.OCONVNOP:
-			if t.Etype == n.Type().Etype {
-				switch t.Etype {
+			if t.Kind() == n.Type().Kind() {
+				switch t.Kind() {
 				case types.TFLOAT32, types.TFLOAT64, types.TCOMPLEX64, types.TCOMPLEX128:
 					// Floating point casts imply rounding and
 					// so the conversion must be kept.
@@ -1741,7 +1741,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 		i := 1
 		var nn ir.Node
-		switch t.Etype {
+		switch t.Kind() {
 		default:
 			base.Errorf("cannot make type %v", t)
 			n.SetType(nil)
@@ -2062,7 +2062,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	t := n.Type()
 	if t != nil && !t.IsFuncArgStruct() && n.Op() != ir.OTYPE {
-		switch t.Etype {
+		switch t.Kind() {
 		case types.TFUNC, // might have TANY; wait until it's called
 			types.TANY, types.TFORW, types.TIDEAL, types.TNIL, types.TBLANK:
 			break
@@ -2352,7 +2352,7 @@ func typecheckMethodExpr(n ir.Node) (res ir.Node) {
 		// types declared at package scope. However, we need
 		// to make sure to generate wrappers for anonymous
 		// receiver types too.
-		if mt.Sym == nil {
+		if mt.Sym() == nil {
 			addsignat(t)
 		}
 	}
@@ -2385,7 +2385,7 @@ func typecheckMethodExpr(n ir.Node) (res ir.Node) {
 	me.SetOpt(m)
 
 	// Issue 25065. Make sure that we emit the symbol for a local method.
-	if base.Ctxt.Flag_dynlink && !inimport && (t.Sym == nil || t.Sym.Pkg == ir.LocalPkg) {
+	if base.Ctxt.Flag_dynlink && !inimport && (t.Sym() == nil || t.Sym().Pkg == ir.LocalPkg) {
 		makefuncsym(me.Sym())
 	}
 
@@ -2417,7 +2417,7 @@ func lookdot(n ir.Node, t *types.Type, dostrcmp int) *types.Field {
 	}
 
 	var f2 *types.Field
-	if n.Left().Type() == t || n.Left().Type().Sym == nil {
+	if n.Left().Type() == t || n.Left().Type().Sym() == nil {
 		mt := methtype(t)
 		if mt != nil {
 			f2 = lookdot1(n, s, mt, mt.Methods(), dostrcmp)
@@ -2493,7 +2493,7 @@ func lookdot(n ir.Node, t *types.Type, dostrcmp int) *types.Field {
 			pll = ll
 			ll = ll.Left()
 		}
-		if pll.Implicit() && ll.Type().IsPtr() && ll.Type().Sym != nil && ir.AsNode(ll.Type().Sym.Def) != nil && ir.AsNode(ll.Type().Sym.Def).Op() == ir.OTYPE {
+		if pll.Implicit() && ll.Type().IsPtr() && ll.Type().Sym() != nil && ir.AsNode(ll.Type().Sym().Def) != nil && ir.AsNode(ll.Type().Sym().Def).Op() == ir.OTYPE {
 			// It is invalid to automatically dereference a named pointer type when selecting a method.
 			// Make n.Left == ll to clarify error message.
 			n.SetLeft(ll)
@@ -2681,7 +2681,7 @@ func sigrepr(t *types.Type, isddd bool) string {
 		return "bool"
 	}
 
-	if t.Etype == types.TIDEAL {
+	if t.Kind() == types.TIDEAL {
 		// "untyped number" is not commonly used
 		// outside of the compiler, so let's use "number".
 		// TODO(mdempsky): Revisit this.
@@ -2724,7 +2724,7 @@ func fielddup(name string, hash map[string]bool) {
 
 // iscomptype reports whether type t is a composite literal type.
 func iscomptype(t *types.Type) bool {
-	switch t.Etype {
+	switch t.Kind() {
 	case types.TARRAY, types.TSLICE, types.TSTRUCT, types.TMAP:
 		return true
 	default:
@@ -2801,7 +2801,7 @@ func typecheckcomplit(n ir.Node) (res ir.Node) {
 	}
 	n.SetType(t)
 
-	switch t.Etype {
+	switch t.Kind() {
 	default:
 		base.Errorf("invalid composite literal type %v", t)
 		n.SetType(nil)
@@ -3154,7 +3154,7 @@ func samesafeexpr(l ir.Node, r ir.Node) bool {
 	case ir.OCONV:
 		// Some conversions can't be reused, such as []byte(str).
 		// Allow only numeric-ish types. This is a bit conservative.
-		return issimple[l.Type().Etype] && samesafeexpr(l.Left(), r.Left())
+		return issimple[l.Type().Kind()] && samesafeexpr(l.Left(), r.Left())
 
 	case ir.OINDEX, ir.OINDEXMAP,
 		ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.OLSH, ir.ORSH, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OMOD:
@@ -3451,7 +3451,7 @@ func typecheckdeftype(n *ir.Name) {
 		n.SetDiag(true)
 		n.SetType(nil)
 	}
-	if t.Etype == types.TFORW && base.Errors() > errorsBefore {
+	if t.Kind() == types.TFORW && base.Errors() > errorsBefore {
 		// Something went wrong during type-checking,
 		// but it was reported. Silence future errors.
 		t.SetBroke(true)
@@ -3541,7 +3541,7 @@ func typecheckdef(n ir.Node) {
 
 		t := n.Type()
 		if t != nil {
-			if !ir.OKForConst[t.Etype] {
+			if !ir.OKForConst[t.Kind()] {
 				base.ErrorfAt(n.Pos(), "invalid constant type %v", t)
 				goto ret
 			}
@@ -3638,7 +3638,7 @@ ret:
 
 func checkmake(t *types.Type, arg string, np *ir.Node) bool {
 	n := *np
-	if !n.Type().IsInteger() && n.Type().Etype != types.TIDEAL {
+	if !n.Type().IsInteger() && n.Type().Kind() != types.TIDEAL {
 		base.Errorf("non-integer %s argument in make(%v) - %v", arg, t, n.Type())
 		return false
 	}
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index b1492659b4..49e50734c6 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -15,7 +15,7 @@ import (
 
 var basicTypes = [...]struct {
 	name  string
-	etype types.EType
+	etype types.Kind
 }{
 	{"int8", types.TINT8},
 	{"int16", types.TINT16},
@@ -35,9 +35,9 @@ var basicTypes = [...]struct {
 
 var typedefs = [...]struct {
 	name     string
-	etype    types.EType
-	sameas32 types.EType
-	sameas64 types.EType
+	etype    types.Kind
+	sameas32 types.Kind
+	sameas64 types.Kind
 }{
 	{"int", types.TINT, types.TINT32, types.TINT64},
 	{"uint", types.TUINT, types.TUINT32, types.TUINT64},
@@ -99,14 +99,14 @@ func initUniverse() {
 	// string is same as slice wo the cap
 	sizeofString = Rnd(sliceLenOffset+int64(Widthptr), int64(Widthptr))
 
-	for et := types.EType(0); et < types.NTYPE; et++ {
+	for et := types.Kind(0); et < types.NTYPE; et++ {
 		simtype[et] = et
 	}
 
 	types.Types[types.TANY] = types.New(types.TANY)
 	types.Types[types.TINTER] = types.New(types.TINTER) // empty interface
 
-	defBasic := func(kind types.EType, pkg *types.Pkg, name string) *types.Type {
+	defBasic := func(kind types.Kind, pkg *types.Pkg, name string) *types.Type {
 		sym := pkg.Lookup(name)
 		n := ir.NewNameAt(src.NoXPos, sym)
 		n.SetOp(ir.OTYPE)
@@ -140,18 +140,18 @@ func initUniverse() {
 	// of less informative error messages involving bytes and runes)?
 	// (Alternatively, we could introduce an OTALIAS node representing
 	// type aliases, albeit at the cost of having to deal with it everywhere).
-	types.Bytetype = defBasic(types.TUINT8, ir.BuiltinPkg, "byte")
-	types.Runetype = defBasic(types.TINT32, ir.BuiltinPkg, "rune")
+	types.ByteType = defBasic(types.TUINT8, ir.BuiltinPkg, "byte")
+	types.RuneType = defBasic(types.TINT32, ir.BuiltinPkg, "rune")
 
 	// error type
 	s := ir.BuiltinPkg.Lookup("error")
 	n := ir.NewNameAt(src.NoXPos, s)
 	n.SetOp(ir.OTYPE)
-	types.Errortype = types.NewNamed(n)
-	types.Errortype.SetUnderlying(makeErrorInterface())
-	n.SetType(types.Errortype)
+	types.ErrorType = types.NewNamed(n)
+	types.ErrorType.SetUnderlying(makeErrorInterface())
+	n.SetType(types.ErrorType)
 	s.Def = n
-	dowidth(types.Errortype)
+	dowidth(types.ErrorType)
 
 	types.Types[types.TUNSAFEPTR] = defBasic(types.TUNSAFEPTR, unsafepkg, "Pointer")
 
@@ -218,7 +218,7 @@ func initUniverse() {
 	isComplex[types.TCOMPLEX128] = true
 
 	// initialize okfor
-	for et := types.EType(0); et < types.NTYPE; et++ {
+	for et := types.Kind(0); et < types.NTYPE; et++ {
 		if isInt[et] || et == types.TIDEAL {
 			okforeq[et] = true
 			okforcmp[et] = true
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 511cdd3685..b3af353c3f 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -423,7 +423,7 @@ func walkexpr(n ir.Node, init *ir.Nodes) ir.Node {
 
 	// Eagerly checkwidth all expressions for the back end.
 	if n.Type() != nil && !n.Type().WidthCalculated() {
-		switch n.Type().Etype {
+		switch n.Type().Kind() {
 		case types.TBLANK, types.TNIL, types.TIDEAL:
 		default:
 			checkwidth(n.Type())
@@ -975,7 +975,7 @@ opswitch:
 		n.SetRight(walkexpr(n.Right(), init))
 
 		// rewrite complex div into function call.
-		et := n.Left().Type().Etype
+		et := n.Left().Type().Kind()
 
 		if isComplex[et] && n.Op() == ir.ODIV {
 			t := n.Type()
@@ -1638,7 +1638,7 @@ func markUsedIfaceMethod(n ir.Node) {
 // name can be derived from the names of the returned types.
 //
 // If no such function is necessary, it returns (Txxx, Txxx).
-func rtconvfn(src, dst *types.Type) (param, result types.EType) {
+func rtconvfn(src, dst *types.Type) (param, result types.Kind) {
 	if thearch.SoftFloat {
 		return types.Txxx, types.Txxx
 	}
@@ -1646,31 +1646,31 @@ func rtconvfn(src, dst *types.Type) (param, result types.EType) {
 	switch thearch.LinkArch.Family {
 	case sys.ARM, sys.MIPS:
 		if src.IsFloat() {
-			switch dst.Etype {
+			switch dst.Kind() {
 			case types.TINT64, types.TUINT64:
-				return types.TFLOAT64, dst.Etype
+				return types.TFLOAT64, dst.Kind()
 			}
 		}
 		if dst.IsFloat() {
-			switch src.Etype {
+			switch src.Kind() {
 			case types.TINT64, types.TUINT64:
-				return src.Etype, types.TFLOAT64
+				return src.Kind(), types.TFLOAT64
 			}
 		}
 
 	case sys.I386:
 		if src.IsFloat() {
-			switch dst.Etype {
+			switch dst.Kind() {
 			case types.TINT64, types.TUINT64:
-				return types.TFLOAT64, dst.Etype
+				return types.TFLOAT64, dst.Kind()
 			case types.TUINT32, types.TUINT, types.TUINTPTR:
 				return types.TFLOAT64, types.TUINT32
 			}
 		}
 		if dst.IsFloat() {
-			switch src.Etype {
+			switch src.Kind() {
 			case types.TINT64, types.TUINT64:
-				return src.Etype, types.TFLOAT64
+				return src.Kind(), types.TFLOAT64
 			case types.TUINT32, types.TUINT, types.TUINTPTR:
 				return types.TUINT32, types.TFLOAT64
 			}
@@ -1937,7 +1937,7 @@ func walkprint(nn ir.Node, init *ir.Nodes) ir.Node {
 	for i, n := range nn.List().Slice() {
 		if n.Op() == ir.OLITERAL {
 			if n.Type() == types.UntypedRune {
-				n = defaultlit(n, types.Runetype)
+				n = defaultlit(n, types.RuneType)
 			}
 
 			switch n.Val().Kind() {
@@ -1949,17 +1949,17 @@ func walkprint(nn ir.Node, init *ir.Nodes) ir.Node {
 			}
 		}
 
-		if n.Op() != ir.OLITERAL && n.Type() != nil && n.Type().Etype == types.TIDEAL {
+		if n.Op() != ir.OLITERAL && n.Type() != nil && n.Type().Kind() == types.TIDEAL {
 			n = defaultlit(n, types.Types[types.TINT64])
 		}
 		n = defaultlit(n, nil)
 		nn.List().SetIndex(i, n)
-		if n.Type() == nil || n.Type().Etype == types.TFORW {
+		if n.Type() == nil || n.Type().Kind() == types.TFORW {
 			continue
 		}
 
 		var on ir.Node
-		switch n.Type().Etype {
+		switch n.Type().Kind() {
 		case types.TINTER:
 			if n.Type().IsEmptyInterface() {
 				on = syslook("printeface")
@@ -1984,7 +1984,7 @@ func walkprint(nn ir.Node, init *ir.Nodes) ir.Node {
 			on = syslook("printslice")
 			on = substArgTypes(on, n.Type()) // any-1
 		case types.TUINT, types.TUINT8, types.TUINT16, types.TUINT32, types.TUINT64, types.TUINTPTR:
-			if isRuntimePkg(n.Type().Sym.Pkg) && n.Type().Sym.Name == "hex" {
+			if isRuntimePkg(n.Type().Sym().Pkg) && n.Type().Sym().Name == "hex" {
 				on = syslook("printhex")
 			} else {
 				on = syslook("printuint")
@@ -2058,9 +2058,9 @@ func isReflectHeaderDataField(l ir.Node) bool {
 	var tsym *types.Sym
 	switch l.Op() {
 	case ir.ODOT:
-		tsym = l.Left().Type().Sym
+		tsym = l.Left().Type().Sym()
 	case ir.ODOTPTR:
-		tsym = l.Left().Type().Elem().Sym
+		tsym = l.Left().Type().Elem().Sym()
 	default:
 		return false
 	}
@@ -2484,7 +2484,7 @@ func heapmoves() {
 }
 
 func vmkcall(fn ir.Node, t *types.Type, init *ir.Nodes, va []ir.Node) ir.Node {
-	if fn.Type() == nil || fn.Type().Etype != types.TFUNC {
+	if fn.Type() == nil || fn.Type().Kind() != types.TFUNC {
 		base.Fatalf("mkcall %v %v", fn, fn.Type())
 	}
 
@@ -3264,7 +3264,7 @@ func walkcompare(n ir.Node, init *ir.Nodes) ir.Node {
 		maxcmpsize = 2 * int64(thearch.LinkArch.RegSize)
 	}
 
-	switch t.Etype {
+	switch t.Kind() {
 	default:
 		if base.Debug.Libfuzzer != 0 && t.IsInteger() {
 			n.SetLeft(cheapexpr(n.Left(), init))
@@ -3315,7 +3315,7 @@ func walkcompare(n ir.Node, init *ir.Nodes) ir.Node {
 		return n
 	case types.TARRAY:
 		// We can compare several elements at once with 2/4/8 byte integer compares
-		inline = t.NumElem() <= 1 || (issimple[t.Elem().Etype] && (t.NumElem() <= 4 || t.Elem().Width*t.NumElem() <= maxcmpsize))
+		inline = t.NumElem() <= 1 || (issimple[t.Elem().Kind()] && (t.NumElem() <= 4 || t.Elem().Width*t.NumElem() <= maxcmpsize))
 	case types.TSTRUCT:
 		inline = t.NumComponents(types.IgnoreBlankFields) <= 4
 	}
@@ -3697,7 +3697,7 @@ func usemethod(n ir.Node) {
 	}
 
 	if res1 == nil {
-		if p0.Type.Etype != types.TINT {
+		if p0.Type.Kind() != types.TINT {
 			return
 		}
 	} else {
@@ -3712,7 +3712,7 @@ func usemethod(n ir.Node) {
 	// Note: Don't rely on res0.Type.String() since its formatting depends on multiple factors
 	//       (including global variables such as numImports - was issue #19028).
 	// Also need to check for reflect package itself (see Issue #38515).
-	if s := res0.Type.Sym; s != nil && s.Name == "Method" && isReflectPkg(s.Pkg) {
+	if s := res0.Type.Sym(); s != nil && s.Name == "Method" && isReflectPkg(s.Pkg) {
 		Curfn.SetReflectMethod(true)
 		// The LSym is initialized at this point. We need to set the attribute on the LSym.
 		Curfn.LSym.Set(obj.AttrReflectMethod, true)
@@ -3756,7 +3756,7 @@ func usefield(n ir.Node) {
 	if outer.IsPtr() {
 		outer = outer.Elem()
 	}
-	if outer.Sym == nil {
+	if outer.Sym() == nil {
 		base.Errorf("tracked field must be in named struct type")
 	}
 	if !types.IsExported(field.Sym.Name) {
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index a111471222..5bb1ed857c 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -317,7 +317,7 @@ func (m FmtMode) prepareArgs(args []interface{}) {
 			args[i] = &fmtSym{arg, m}
 		case Nodes:
 			args[i] = &fmtNodes{arg, m}
-		case int32, int64, string, types.EType, constant.Value:
+		case int32, int64, string, types.Kind, constant.Value:
 			// OK: printing these types doesn't depend on mode
 		default:
 			base.Fatalf("mode.prepareArgs type %T", arg)
@@ -590,18 +590,18 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode FmtMode, visited
 		b.WriteString("<T>")
 		return
 	}
-	if t.Etype == types.TSSA {
+	if t.Kind() == types.TSSA {
 		b.WriteString(t.Extra.(string))
 		return
 	}
-	if t.Etype == types.TTUPLE {
+	if t.Kind() == types.TTUPLE {
 		b.WriteString(t.FieldType(0).String())
 		b.WriteByte(',')
 		b.WriteString(t.FieldType(1).String())
 		return
 	}
 
-	if t.Etype == types.TRESULTS {
+	if t.Kind() == types.TRESULTS {
 		tys := t.Extra.(*types.Results).Types
 		for i, et := range tys {
 			if i > 0 {
@@ -616,51 +616,51 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode FmtMode, visited
 	if mode == FTypeIdName {
 		flag |= FmtUnsigned
 	}
-	if t == types.Bytetype || t == types.Runetype {
+	if t == types.ByteType || t == types.RuneType {
 		// in %-T mode collapse rune and byte with their originals.
 		switch mode {
 		case FTypeIdName, FTypeId:
-			t = types.Types[t.Etype]
+			t = types.Types[t.Kind()]
 		default:
-			sconv2(b, t.Sym, FmtShort, mode)
+			sconv2(b, t.Sym(), FmtShort, mode)
 			return
 		}
 	}
-	if t == types.Errortype {
+	if t == types.ErrorType {
 		b.WriteString("error")
 		return
 	}
 
 	// Unless the 'L' flag was specified, if the type has a name, just print that name.
-	if flag&FmtLong == 0 && t.Sym != nil && t != types.Types[t.Etype] {
+	if flag&FmtLong == 0 && t.Sym() != nil && t != types.Types[t.Kind()] {
 		switch mode {
 		case FTypeId, FTypeIdName:
 			if flag&FmtShort != 0 {
 				if t.Vargen != 0 {
-					sconv2(b, t.Sym, FmtShort, mode)
+					sconv2(b, t.Sym(), FmtShort, mode)
 					fmt.Fprintf(b, "·%d", t.Vargen)
 					return
 				}
-				sconv2(b, t.Sym, FmtShort, mode)
+				sconv2(b, t.Sym(), FmtShort, mode)
 				return
 			}
 
 			if mode == FTypeIdName {
-				sconv2(b, t.Sym, FmtUnsigned, mode)
+				sconv2(b, t.Sym(), FmtUnsigned, mode)
 				return
 			}
 
-			if t.Sym.Pkg == LocalPkg && t.Vargen != 0 {
-				b.WriteString(mode.Sprintf("%v·%d", t.Sym, t.Vargen))
+			if t.Sym().Pkg == LocalPkg && t.Vargen != 0 {
+				b.WriteString(mode.Sprintf("%v·%d", t.Sym(), t.Vargen))
 				return
 			}
 		}
 
-		sconv2(b, t.Sym, 0, mode)
+		sconv2(b, t.Sym(), 0, mode)
 		return
 	}
 
-	if int(t.Etype) < len(BasicTypeNames) && BasicTypeNames[t.Etype] != "" {
+	if int(t.Kind()) < len(BasicTypeNames) && BasicTypeNames[t.Kind()] != "" {
 		var name string
 		switch t {
 		case types.UntypedBool:
@@ -676,14 +676,14 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode FmtMode, visited
 		case types.UntypedComplex:
 			name = "untyped complex"
 		default:
-			name = BasicTypeNames[t.Etype]
+			name = BasicTypeNames[t.Kind()]
 		}
 		b.WriteString(name)
 		return
 	}
 
 	if mode == FDbg {
-		b.WriteString(t.Etype.String())
+		b.WriteString(t.Kind().String())
 		b.WriteByte('-')
 		tconv2(b, t, flag, FErr, visited)
 		return
@@ -702,7 +702,7 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode FmtMode, visited
 	visited[t] = b.Len()
 	defer delete(visited, t)
 
-	switch t.Etype {
+	switch t.Kind() {
 	case types.TPTR:
 		b.WriteByte('*')
 		switch mode {
@@ -734,7 +734,7 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode FmtMode, visited
 			tconv2(b, t.Elem(), 0, mode, visited)
 		default:
 			b.WriteString("chan ")
-			if t.Elem() != nil && t.Elem().IsChan() && t.Elem().Sym == nil && t.Elem().ChanDir() == types.Crecv {
+			if t.Elem() != nil && t.Elem().IsChan() && t.Elem().Sym() == nil && t.Elem().ChanDir() == types.Crecv {
 				b.WriteByte('(')
 				tconv2(b, t.Elem(), 0, mode, visited)
 				b.WriteByte(')')
@@ -860,9 +860,9 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode FmtMode, visited
 
 	case types.TFORW:
 		b.WriteString("undefined")
-		if t.Sym != nil {
+		if t.Sym() != nil {
 			b.WriteByte(' ')
-			sconv2(b, t.Sym, 0, mode)
+			sconv2(b, t.Sym(), 0, mode)
 		}
 
 	case types.TUNSAFEPTR:
@@ -872,7 +872,7 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode FmtMode, visited
 		b.WriteString("Txxx")
 	default:
 		// Don't know how to handle - fall back to detailed prints.
-		b.WriteString(mode.Sprintf("%v <%v>", t.Etype, t.Sym))
+		b.WriteString(mode.Sprintf("%v <%v>", t.Kind(), t.Sym()))
 	}
 }
 
@@ -1446,7 +1446,7 @@ func exprFmt(n Node, s fmt.State, prec int, mode FmtMode) {
 		OSTR2BYTES,
 		OSTR2RUNES,
 		ORUNESTR:
-		if n.Type() == nil || n.Type().Sym == nil {
+		if n.Type() == nil || n.Type().Sym() == nil {
 			mode.Fprintf(s, "(%v)", n.Type())
 		} else {
 			mode.Fprintf(s, "%v", n.Type())
@@ -1564,7 +1564,7 @@ func nodeFmt(n Node, s fmt.State, flag FmtFlag, mode FmtMode) {
 	}
 
 	if flag&FmtLong != 0 && t != nil {
-		if t.Etype == types.TNIL {
+		if t.Kind() == types.TNIL {
 			fmt.Fprint(s, "nil")
 		} else if n.Op() == ONAME && n.Name().AutoTemp() {
 			mode.Fprintf(s, "%v value", t)
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index a7144eee44..fc4c593929 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -647,7 +647,7 @@ const (
 	GoBuildPragma
 )
 
-func AsNode(n types.IRNode) Node {
+func AsNode(n types.Object) Node {
 	if n == nil {
 		return nil
 	}
diff --git a/src/cmd/compile/internal/ir/type.go b/src/cmd/compile/internal/ir/type.go
index 446145b24c..d2f5bb9239 100644
--- a/src/cmd/compile/internal/ir/type.go
+++ b/src/cmd/compile/internal/ir/type.go
@@ -353,7 +353,7 @@ func (n *typeNode) String() string                { return fmt.Sprint(n) }
 func (n *typeNode) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *typeNode) rawCopy() Node                 { c := *n; return &c }
 func (n *typeNode) Type() *types.Type             { return n.typ }
-func (n *typeNode) Sym() *types.Sym               { return n.typ.Sym }
+func (n *typeNode) Sym() *types.Sym               { return n.typ.Sym() }
 func (n *typeNode) CanBeNtype()                   {}
 
 // TypeNode returns the Node representing the type t.
diff --git a/src/cmd/compile/internal/ir/val.go b/src/cmd/compile/internal/ir/val.go
index 9035e90084..aae965bb4c 100644
--- a/src/cmd/compile/internal/ir/val.go
+++ b/src/cmd/compile/internal/ir/val.go
@@ -73,7 +73,7 @@ func AssertValidTypeForConst(t *types.Type, v constant.Value) {
 func ValidTypeForConst(t *types.Type, v constant.Value) bool {
 	switch v.Kind() {
 	case constant.Unknown:
-		return OKForConst[t.Etype]
+		return OKForConst[t.Kind()]
 	case constant.Bool:
 		return t.IsBoolean()
 	case constant.String:
diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index f266e49327..0eba238d81 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -69,7 +69,7 @@ func expandCalls(f *Func) {
 
 	// intPairTypes returns the pair of 32-bit int types needed to encode a 64-bit integer type on a target
 	// that has no 64-bit integer registers.
-	intPairTypes := func(et types.EType) (tHi, tLo *types.Type) {
+	intPairTypes := func(et types.Kind) (tHi, tLo *types.Type) {
 		tHi = typ.UInt32
 		if et == types.TINT64 {
 			tHi = typ.Int32
@@ -294,7 +294,7 @@ func expandCalls(f *Func) {
 		case OpStructSelect:
 			w := selector.Args[0]
 			var ls []LocalSlot
-			if w.Type.Etype != types.TSTRUCT { // IData artifact
+			if w.Type.Kind() != types.TSTRUCT { // IData artifact
 				ls = rewriteSelect(leaf, w, offset)
 			} else {
 				ls = rewriteSelect(leaf, w, offset+w.Type.FieldOff(int(selector.AuxInt)))
@@ -383,7 +383,7 @@ func expandCalls(f *Func) {
 		decomposeOne func(pos src.XPos, b *Block, base, source, mem *Value, t1 *types.Type, offArg, offStore int64) *Value,
 		decomposeTwo func(pos src.XPos, b *Block, base, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64) *Value) *Value {
 		u := source.Type
-		switch u.Etype {
+		switch u.Kind() {
 		case types.TARRAY:
 			elem := u.Elem()
 			for i := int64(0); i < u.NumElem(); i++ {
@@ -403,7 +403,7 @@ func expandCalls(f *Func) {
 			if t.Width == regSize {
 				break
 			}
-			tHi, tLo := intPairTypes(t.Etype)
+			tHi, tLo := intPairTypes(t.Kind())
 			mem = decomposeOne(pos, b, base, source, mem, tHi, source.AuxInt+hiOffset, offset+hiOffset)
 			pos = pos.WithNotStmt()
 			return decomposeOne(pos, b, base, source, mem, tLo, source.AuxInt+lowOffset, offset+lowOffset)
@@ -491,7 +491,7 @@ func expandCalls(f *Func) {
 			return storeArgOrLoad(pos, b, base, source.Args[0], mem, t.Elem(), offset)
 
 		case OpInt64Make:
-			tHi, tLo := intPairTypes(t.Etype)
+			tHi, tLo := intPairTypes(t.Kind())
 			mem = storeArgOrLoad(pos, b, base, source.Args[0], mem, tHi, offset+hiOffset)
 			pos = pos.WithNotStmt()
 			return storeArgOrLoad(pos, b, base, source.Args[1], mem, tLo, offset+lowOffset)
@@ -524,7 +524,7 @@ func expandCalls(f *Func) {
 		}
 
 		// For nodes that cannot be taken apart -- OpSelectN, other structure selectors.
-		switch t.Etype {
+		switch t.Kind() {
 		case types.TARRAY:
 			elt := t.Elem()
 			if source.Type != t && t.NumElem() == 1 && elt.Width == t.Width && t.Width == regSize {
@@ -576,7 +576,7 @@ func expandCalls(f *Func) {
 			if t.Width == regSize {
 				break
 			}
-			tHi, tLo := intPairTypes(t.Etype)
+			tHi, tLo := intPairTypes(t.Kind())
 			sel := source.Block.NewValue1(pos, OpInt64Hi, tHi, source)
 			mem = storeArgOrLoad(pos, b, base, sel, mem, tHi, offset+hiOffset)
 			pos = pos.WithNotStmt()
@@ -873,7 +873,7 @@ func expandCalls(f *Func) {
 		offset := int64(0)
 		switch v.Op {
 		case OpStructSelect:
-			if w.Type.Etype == types.TSTRUCT {
+			if w.Type.Kind() == types.TSTRUCT {
 				offset = w.Type.FieldOff(int(v.AuxInt))
 			} else { // Immediate interface data artifact, offset is zero.
 				f.Fatalf("Expand calls interface data problem, func %s, v=%s, w=%s\n", f.Name, v.LongString(), w.LongString())
diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go
index df83383308..5a81f76ceb 100644
--- a/src/cmd/compile/internal/ssa/export_test.go
+++ b/src/cmd/compile/internal/ssa/export_test.go
@@ -140,7 +140,7 @@ func init() {
 	// so this test setup can share it.
 
 	types.Tconv = func(t *types.Type, flag, mode int) string {
-		return t.Etype.String()
+		return t.Kind().String()
 	}
 	types.Sconv = func(s *types.Sym, flag, mode int) string {
 		return "sym"
@@ -149,13 +149,13 @@ func init() {
 		fmt.Fprintf(s, "sym")
 	}
 	types.FormatType = func(t *types.Type, s fmt.State, verb rune, mode int) {
-		fmt.Fprintf(s, "%v", t.Etype)
+		fmt.Fprintf(s, "%v", t.Kind())
 	}
 	types.Dowidth = func(t *types.Type) {}
 
 	for _, typ := range [...]struct {
 		width int64
-		et    types.EType
+		et    types.Kind
 	}{
 		{1, types.TINT8},
 		{1, types.TUINT8},
diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go
index 459a9923f7..376ca97512 100644
--- a/src/cmd/compile/internal/ssa/regalloc.go
+++ b/src/cmd/compile/internal/ssa/regalloc.go
@@ -783,9 +783,9 @@ func (s *regAllocState) compatRegs(t *types.Type) regMask {
 		return 0
 	}
 	if t.IsFloat() || t == types.TypeInt128 {
-		if t.Etype == types.TFLOAT32 && s.f.Config.fp32RegMask != 0 {
+		if t.Kind() == types.TFLOAT32 && s.f.Config.fp32RegMask != 0 {
 			m = s.f.Config.fp32RegMask
-		} else if t.Etype == types.TFLOAT64 && s.f.Config.fp64RegMask != 0 {
+		} else if t.Kind() == types.TFLOAT64 && s.f.Config.fp64RegMask != 0 {
 			m = s.f.Config.fp64RegMask
 		} else {
 			m = s.f.Config.fpRegMask
diff --git a/src/cmd/compile/internal/types/etype_string.go b/src/cmd/compile/internal/types/etype_string.go
index 14fd5b71df..e7698296ab 100644
--- a/src/cmd/compile/internal/types/etype_string.go
+++ b/src/cmd/compile/internal/types/etype_string.go
@@ -52,8 +52,8 @@ const _EType_name = "xxxINT8UINT8INT16UINT16INT32UINT32INT64UINT64INTUINTUINTPTR
 
 var _EType_index = [...]uint8{0, 3, 7, 12, 17, 23, 28, 34, 39, 45, 48, 52, 59, 68, 78, 85, 92, 96, 99, 103, 108, 113, 119, 123, 126, 131, 135, 138, 144, 153, 158, 161, 166, 174, 182, 185, 190, 197, 202}
 
-func (i EType) String() string {
-	if i >= EType(len(_EType_index)-1) {
+func (i Kind) String() string {
+	if i >= Kind(len(_EType_index)-1) {
 		return "EType(" + strconv.FormatInt(int64(i), 10) + ")"
 	}
 	return _EType_name[_EType_index[i]:_EType_index[i+1]]
diff --git a/src/cmd/compile/internal/types/identity.go b/src/cmd/compile/internal/types/identity.go
index a77f514df9..9bc636d7ff 100644
--- a/src/cmd/compile/internal/types/identity.go
+++ b/src/cmd/compile/internal/types/identity.go
@@ -25,17 +25,17 @@ func identical(t1, t2 *Type, cmpTags bool, assumedEqual map[typePair]struct{}) b
 	if t1 == t2 {
 		return true
 	}
-	if t1 == nil || t2 == nil || t1.Etype != t2.Etype || t1.Broke() || t2.Broke() {
+	if t1 == nil || t2 == nil || t1.kind != t2.kind || t1.Broke() || t2.Broke() {
 		return false
 	}
-	if t1.Sym != nil || t2.Sym != nil {
+	if t1.sym != nil || t2.sym != nil {
 		// Special case: we keep byte/uint8 and rune/int32
 		// separate for error messages. Treat them as equal.
-		switch t1.Etype {
+		switch t1.kind {
 		case TUINT8:
-			return (t1 == Types[TUINT8] || t1 == Bytetype) && (t2 == Types[TUINT8] || t2 == Bytetype)
+			return (t1 == Types[TUINT8] || t1 == ByteType) && (t2 == Types[TUINT8] || t2 == ByteType)
 		case TINT32:
-			return (t1 == Types[TINT32] || t1 == Runetype) && (t2 == Types[TINT32] || t2 == Runetype)
+			return (t1 == Types[TINT32] || t1 == RuneType) && (t2 == Types[TINT32] || t2 == RuneType)
 		default:
 			return false
 		}
@@ -52,7 +52,7 @@ func identical(t1, t2 *Type, cmpTags bool, assumedEqual map[typePair]struct{}) b
 	}
 	assumedEqual[typePair{t1, t2}] = struct{}{}
 
-	switch t1.Etype {
+	switch t1.kind {
 	case TIDEAL:
 		// Historically, cmd/compile used a single "untyped
 		// number" type, so all untyped number types were
diff --git a/src/cmd/compile/internal/types/scope.go b/src/cmd/compile/internal/types/scope.go
index 33a02c543d..37ac90a025 100644
--- a/src/cmd/compile/internal/types/scope.go
+++ b/src/cmd/compile/internal/types/scope.go
@@ -15,7 +15,7 @@ var Block int32        // current block number
 // restored once the block scope ends.
 type dsym struct {
 	sym        *Sym // sym == nil indicates stack mark
-	def        IRNode
+	def        Object
 	block      int32
 	lastlineno src.XPos // last declaration for diagnostic
 }
@@ -79,16 +79,16 @@ func IsDclstackValid() bool {
 }
 
 // PkgDef returns the definition associated with s at package scope.
-func (s *Sym) PkgDef() IRNode {
+func (s *Sym) PkgDef() Object {
 	return *s.pkgDefPtr()
 }
 
 // SetPkgDef sets the definition associated with s at package scope.
-func (s *Sym) SetPkgDef(n IRNode) {
+func (s *Sym) SetPkgDef(n Object) {
 	*s.pkgDefPtr() = n
 }
 
-func (s *Sym) pkgDefPtr() *IRNode {
+func (s *Sym) pkgDefPtr() *Object {
 	// Look for outermost saved declaration, which must be the
 	// package scope definition, if present.
 	for _, d := range dclstack {
diff --git a/src/cmd/compile/internal/types/sym.go b/src/cmd/compile/internal/types/sym.go
index 7272f1f786..490222d843 100644
--- a/src/cmd/compile/internal/types/sym.go
+++ b/src/cmd/compile/internal/types/sym.go
@@ -33,7 +33,7 @@ type Sym struct {
 	Name string // object name
 
 	// saved and restored by dcopy
-	Def        IRNode   // definition: ONAME OTYPE OPACK or OLITERAL
+	Def        Object   // definition: ONAME OTYPE OPACK or OLITERAL
 	Block      int32    // blocknumber to catch redeclaration
 	Lastlineno src.XPos // last declaration for diagnostic
 
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index f0211a67fb..36aac53124 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -14,7 +14,7 @@ import (
 // IRNode represents an ir.Node, but without needing to import cmd/compile/internal/ir,
 // which would cause an import cycle. The uses in other packages must type assert
 // values of type IRNode to ir.Node or a more specific type.
-type IRNode interface {
+type Object interface {
 	Pos() src.XPos
 	Sym() *Sym
 	Type() *Type
@@ -23,10 +23,10 @@ type IRNode interface {
 //go:generate stringer -type EType -trimprefix T
 
 // EType describes a kind of type.
-type EType uint8
+type Kind uint8
 
 const (
-	Txxx EType = iota
+	Txxx Kind = iota
 
 	TINT8
 	TUINT8
@@ -103,11 +103,11 @@ var Types [NTYPE]*Type
 
 var (
 	// Predeclared alias types. Kept separate for better error messages.
-	Bytetype *Type
-	Runetype *Type
+	ByteType *Type
+	RuneType *Type
 
 	// Predeclared error interface type.
-	Errortype *Type
+	ErrorType *Type
 
 	// Types to represent untyped string and boolean constants.
 	UntypedString = New(TSTRING)
@@ -146,19 +146,19 @@ type Type struct {
 	methods    Fields
 	allMethods Fields
 
-	nod  IRNode // canonical OTYPE node
-	Orig *Type  // original type (type literal or predefined type)
+	nod        Object // canonical OTYPE node
+	underlying *Type  // original type (type literal or predefined type)
 
 	// Cache of composite types, with this type being the element type.
-	Cache struct {
+	cache struct {
 		ptr   *Type // *T, or nil
 		slice *Type // []T, or nil
 	}
 
-	Sym    *Sym  // symbol containing name, for named types
+	sym    *Sym  // symbol containing name, for named types
 	Vargen int32 // unique name for OTYPE/ONAME
 
-	Etype EType // kind of type
+	kind  Kind  // kind of type
 	Align uint8 // the required alignment of this type, in bytes (0 means Width and Align have not yet been computed)
 
 	flags bitset8
@@ -185,16 +185,16 @@ func (t *Type) SetDeferwidth(b bool) { t.flags.set(typeDeferwidth, b) }
 func (t *Type) SetRecur(b bool)      { t.flags.set(typeRecur, b) }
 
 // Kind returns the kind of type t.
-func (t *Type) Kind() EType { return t.Etype }
+func (t *Type) Kind() Kind { return t.kind }
 
 // Sym returns the name of type t.
-func (t *Type) GetSym() *Sym { return t.Sym }
+func (t *Type) Sym() *Sym { return t.sym }
 
 // Underlying returns the underlying type of type t.
-func (t *Type) Underlying() *Type { return t.Orig }
+func (t *Type) Underlying() *Type { return t.underlying }
 
 // SetNod associates t with syntax node n.
-func (t *Type) SetNod(n IRNode) {
+func (t *Type) SetNod(n Object) {
 	// t.nod can be non-nil already
 	// in the case of shared *Types, like []byte or interface{}.
 	if t.nod == nil {
@@ -218,7 +218,7 @@ func (t *Type) Pos() src.XPos {
 // cmd/compile itself, but we need to track it because it's exposed by
 // the go/types API.
 func (t *Type) Pkg() *Pkg {
-	switch t.Etype {
+	switch t.kind {
 	case TFUNC:
 		return t.Extra.(*Func).pkg
 	case TSTRUCT:
@@ -233,7 +233,7 @@ func (t *Type) Pkg() *Pkg {
 
 // SetPkg sets the package that t appeared in.
 func (t *Type) SetPkg(pkg *Pkg) {
-	switch t.Etype {
+	switch t.kind {
 	case TFUNC:
 		t.Extra.(*Func).pkg = pkg
 	case TSTRUCT:
@@ -392,7 +392,7 @@ type Field struct {
 
 	// For fields that represent function parameters, Nname points
 	// to the associated ONAME Node.
-	Nname IRNode
+	Nname Object
 
 	// Offset in bytes of this field or method within its enclosing struct
 	// or interface Type.
@@ -420,7 +420,7 @@ func (f *Field) End() int64 {
 
 // IsMethod reports whether f represents a method rather than a struct field.
 func (f *Field) IsMethod() bool {
-	return f.Type.Etype == TFUNC && f.Type.Recv() != nil
+	return f.Type.kind == TFUNC && f.Type.Recv() != nil
 }
 
 // Fields is a pointer to a slice of *Field.
@@ -475,14 +475,14 @@ func (f *Fields) Append(s ...*Field) {
 }
 
 // New returns a new Type of the specified kind.
-func New(et EType) *Type {
+func New(et Kind) *Type {
 	t := &Type{
-		Etype: et,
+		kind:  et,
 		Width: BADWIDTH,
 	}
-	t.Orig = t
+	t.underlying = t
 	// TODO(josharian): lazily initialize some of these?
-	switch t.Etype {
+	switch t.kind {
 	case TMAP:
 		t.Extra = new(Map)
 	case TFORW:
@@ -522,7 +522,7 @@ func NewArray(elem *Type, bound int64) *Type {
 
 // NewSlice returns the slice Type with element type elem.
 func NewSlice(elem *Type) *Type {
-	if t := elem.Cache.slice; t != nil {
+	if t := elem.cache.slice; t != nil {
 		if t.Elem() != elem {
 			Fatalf("elem mismatch")
 		}
@@ -531,7 +531,7 @@ func NewSlice(elem *Type) *Type {
 
 	t := New(TSLICE)
 	t.Extra = Slice{Elem: elem}
-	elem.Cache.slice = t
+	elem.cache.slice = t
 	return t
 }
 
@@ -583,7 +583,7 @@ func NewPtr(elem *Type) *Type {
 		Fatalf("NewPtr: pointer to elem Type is nil")
 	}
 
-	if t := elem.Cache.ptr; t != nil {
+	if t := elem.cache.ptr; t != nil {
 		if t.Elem() != elem {
 			Fatalf("NewPtr: elem mismatch")
 		}
@@ -595,7 +595,7 @@ func NewPtr(elem *Type) *Type {
 	t.Width = int64(Widthptr)
 	t.Align = uint8(Widthptr)
 	if NewPtrCacheEnabled {
-		elem.Cache.ptr = t
+		elem.cache.ptr = t
 	}
 	return t
 }
@@ -634,7 +634,7 @@ func SubstAny(t *Type, types *[]*Type) *Type {
 		return nil
 	}
 
-	switch t.Etype {
+	switch t.kind {
 	default:
 		// Leave the type unchanged.
 
@@ -718,7 +718,7 @@ func (t *Type) copy() *Type {
 	}
 	nt := *t
 	// copy any *T Extra fields, to avoid aliasing
-	switch t.Etype {
+	switch t.kind {
 	case TMAP:
 		x := *t.Extra.(*Map)
 		nt.Extra = &x
@@ -744,8 +744,8 @@ func (t *Type) copy() *Type {
 		Fatalf("ssa types cannot be copied")
 	}
 	// TODO(mdempsky): Find out why this is necessary and explain.
-	if t.Orig == t {
-		nt.Orig = &nt
+	if t.underlying == t {
+		nt.underlying = &nt
 	}
 	return &nt
 }
@@ -755,8 +755,8 @@ func (f *Field) Copy() *Field {
 	return &nf
 }
 
-func (t *Type) wantEtype(et EType) {
-	if t.Etype != et {
+func (t *Type) wantEtype(et Kind) {
+	if t.kind != et {
 		Fatalf("want %v, but have %v", et, t)
 	}
 }
@@ -810,7 +810,7 @@ func (t *Type) Key() *Type {
 // Elem returns the type of elements of t.
 // Usable with pointers, channels, arrays, slices, and maps.
 func (t *Type) Elem() *Type {
-	switch t.Etype {
+	switch t.kind {
 	case TPTR:
 		return t.Extra.(Ptr).Elem
 	case TARRAY:
@@ -822,7 +822,7 @@ func (t *Type) Elem() *Type {
 	case TMAP:
 		return t.Extra.(*Map).Elem
 	}
-	Fatalf("Type.Elem %s", t.Etype)
+	Fatalf("Type.Elem %s", t.kind)
 	return nil
 }
 
@@ -840,7 +840,7 @@ func (t *Type) FuncArgs() *Type {
 
 // IsFuncArgStruct reports whether t is a struct representing function parameters.
 func (t *Type) IsFuncArgStruct() bool {
-	return t.Etype == TSTRUCT && t.Extra.(*Struct).Funarg != FunargNone
+	return t.kind == TSTRUCT && t.Extra.(*Struct).Funarg != FunargNone
 }
 
 func (t *Type) Methods() *Fields {
@@ -854,7 +854,7 @@ func (t *Type) AllMethods() *Fields {
 }
 
 func (t *Type) Fields() *Fields {
-	switch t.Etype {
+	switch t.kind {
 	case TSTRUCT:
 		return &t.Extra.(*Struct).fields
 	case TINTER:
@@ -919,7 +919,7 @@ func (t *Type) ArgWidth() int64 {
 }
 
 func (t *Type) Size() int64 {
-	if t.Etype == TSSA {
+	if t.kind == TSSA {
 		if t == TypeInt128 {
 			return 16
 		}
@@ -935,7 +935,7 @@ func (t *Type) Alignment() int64 {
 }
 
 func (t *Type) SimpleString() string {
-	return t.Etype.String()
+	return t.kind.String()
 }
 
 // Cmp is a comparison between values a and b.
@@ -1019,31 +1019,31 @@ func (t *Type) cmp(x *Type) Cmp {
 		return CMPgt
 	}
 
-	if t.Etype != x.Etype {
-		return cmpForNe(t.Etype < x.Etype)
+	if t.kind != x.kind {
+		return cmpForNe(t.kind < x.kind)
 	}
 
-	if t.Sym != nil || x.Sym != nil {
+	if t.sym != nil || x.sym != nil {
 		// Special case: we keep byte and uint8 separate
 		// for error messages. Treat them as equal.
-		switch t.Etype {
+		switch t.kind {
 		case TUINT8:
-			if (t == Types[TUINT8] || t == Bytetype) && (x == Types[TUINT8] || x == Bytetype) {
+			if (t == Types[TUINT8] || t == ByteType) && (x == Types[TUINT8] || x == ByteType) {
 				return CMPeq
 			}
 
 		case TINT32:
-			if (t == Types[Runetype.Etype] || t == Runetype) && (x == Types[Runetype.Etype] || x == Runetype) {
+			if (t == Types[RuneType.kind] || t == RuneType) && (x == Types[RuneType.kind] || x == RuneType) {
 				return CMPeq
 			}
 		}
 	}
 
-	if c := t.Sym.cmpsym(x.Sym); c != CMPeq {
+	if c := t.sym.cmpsym(x.sym); c != CMPeq {
 		return c
 	}
 
-	if x.Sym != nil {
+	if x.sym != nil {
 		// Syms non-nil, if vargens match then equal.
 		if t.Vargen != x.Vargen {
 			return cmpForNe(t.Vargen < x.Vargen)
@@ -1052,7 +1052,7 @@ func (t *Type) cmp(x *Type) Cmp {
 	}
 	// both syms nil, look at structure below.
 
-	switch t.Etype {
+	switch t.kind {
 	case TBOOL, TFLOAT32, TFLOAT64, TCOMPLEX64, TCOMPLEX128, TUNSAFEPTR, TUINTPTR,
 		TINT8, TINT16, TINT32, TINT64, TINT, TUINT8, TUINT16, TUINT32, TUINT64, TUINT:
 		return CMPeq
@@ -1209,15 +1209,15 @@ func (t *Type) cmp(x *Type) Cmp {
 }
 
 // IsKind reports whether t is a Type of the specified kind.
-func (t *Type) IsKind(et EType) bool {
-	return t != nil && t.Etype == et
+func (t *Type) IsKind(et Kind) bool {
+	return t != nil && t.kind == et
 }
 
 func (t *Type) IsBoolean() bool {
-	return t.Etype == TBOOL
+	return t.kind == TBOOL
 }
 
-var unsignedEType = [...]EType{
+var unsignedEType = [...]Kind{
 	TINT8:    TUINT8,
 	TUINT8:   TUINT8,
 	TINT16:   TUINT16,
@@ -1236,11 +1236,11 @@ func (t *Type) ToUnsigned() *Type {
 	if !t.IsInteger() {
 		Fatalf("unsignedType(%v)", t)
 	}
-	return Types[unsignedEType[t.Etype]]
+	return Types[unsignedEType[t.kind]]
 }
 
 func (t *Type) IsInteger() bool {
-	switch t.Etype {
+	switch t.kind {
 	case TINT8, TUINT8, TINT16, TUINT16, TINT32, TUINT32, TINT64, TUINT64, TINT, TUINT, TUINTPTR:
 		return true
 	}
@@ -1248,7 +1248,7 @@ func (t *Type) IsInteger() bool {
 }
 
 func (t *Type) IsSigned() bool {
-	switch t.Etype {
+	switch t.kind {
 	case TINT8, TINT16, TINT32, TINT64, TINT:
 		return true
 	}
@@ -1256,7 +1256,7 @@ func (t *Type) IsSigned() bool {
 }
 
 func (t *Type) IsUnsigned() bool {
-	switch t.Etype {
+	switch t.kind {
 	case TUINT8, TUINT16, TUINT32, TUINT64, TUINT, TUINTPTR:
 		return true
 	}
@@ -1264,32 +1264,32 @@ func (t *Type) IsUnsigned() bool {
 }
 
 func (t *Type) IsFloat() bool {
-	return t.Etype == TFLOAT32 || t.Etype == TFLOAT64 || t == UntypedFloat
+	return t.kind == TFLOAT32 || t.kind == TFLOAT64 || t == UntypedFloat
 }
 
 func (t *Type) IsComplex() bool {
-	return t.Etype == TCOMPLEX64 || t.Etype == TCOMPLEX128 || t == UntypedComplex
+	return t.kind == TCOMPLEX64 || t.kind == TCOMPLEX128 || t == UntypedComplex
 }
 
 // IsPtr reports whether t is a regular Go pointer type.
 // This does not include unsafe.Pointer.
 func (t *Type) IsPtr() bool {
-	return t.Etype == TPTR
+	return t.kind == TPTR
 }
 
 // IsPtrElem reports whether t is the element of a pointer (to t).
 func (t *Type) IsPtrElem() bool {
-	return t.Cache.ptr != nil
+	return t.cache.ptr != nil
 }
 
 // IsUnsafePtr reports whether t is an unsafe pointer.
 func (t *Type) IsUnsafePtr() bool {
-	return t.Etype == TUNSAFEPTR
+	return t.kind == TUNSAFEPTR
 }
 
 // IsUintptr reports whether t is an uintptr.
 func (t *Type) IsUintptr() bool {
-	return t.Etype == TUINTPTR
+	return t.kind == TUINTPTR
 }
 
 // IsPtrShaped reports whether t is represented by a single machine pointer.
@@ -1298,13 +1298,13 @@ func (t *Type) IsUintptr() bool {
 // that consist of a single pointer shaped type.
 // TODO(mdempsky): Should it? See golang.org/issue/15028.
 func (t *Type) IsPtrShaped() bool {
-	return t.Etype == TPTR || t.Etype == TUNSAFEPTR ||
-		t.Etype == TMAP || t.Etype == TCHAN || t.Etype == TFUNC
+	return t.kind == TPTR || t.kind == TUNSAFEPTR ||
+		t.kind == TMAP || t.kind == TCHAN || t.kind == TFUNC
 }
 
 // HasNil reports whether the set of values determined by t includes nil.
 func (t *Type) HasNil() bool {
-	switch t.Etype {
+	switch t.kind {
 	case TCHAN, TFUNC, TINTER, TMAP, TNIL, TPTR, TSLICE, TUNSAFEPTR:
 		return true
 	}
@@ -1312,31 +1312,31 @@ func (t *Type) HasNil() bool {
 }
 
 func (t *Type) IsString() bool {
-	return t.Etype == TSTRING
+	return t.kind == TSTRING
 }
 
 func (t *Type) IsMap() bool {
-	return t.Etype == TMAP
+	return t.kind == TMAP
 }
 
 func (t *Type) IsChan() bool {
-	return t.Etype == TCHAN
+	return t.kind == TCHAN
 }
 
 func (t *Type) IsSlice() bool {
-	return t.Etype == TSLICE
+	return t.kind == TSLICE
 }
 
 func (t *Type) IsArray() bool {
-	return t.Etype == TARRAY
+	return t.kind == TARRAY
 }
 
 func (t *Type) IsStruct() bool {
-	return t.Etype == TSTRUCT
+	return t.kind == TSTRUCT
 }
 
 func (t *Type) IsInterface() bool {
-	return t.Etype == TINTER
+	return t.kind == TINTER
 }
 
 // IsEmptyInterface reports whether t is an empty interface type.
@@ -1352,7 +1352,7 @@ func (t *Type) NumFields() int {
 	return t.Fields().Len()
 }
 func (t *Type) FieldType(i int) *Type {
-	if t.Etype == TTUPLE {
+	if t.kind == TTUPLE {
 		switch i {
 		case 0:
 			return t.Extra.(*Tuple).first
@@ -1362,7 +1362,7 @@ func (t *Type) FieldType(i int) *Type {
 			panic("bad tuple index")
 		}
 	}
-	if t.Etype == TRESULTS {
+	if t.kind == TRESULTS {
 		return t.Extra.(*Results).Types[i]
 	}
 	return t.Field(i).Type
@@ -1393,7 +1393,7 @@ const (
 // (and their comprised elements) are excluded from the count.
 // struct { x, y [3]int } has six components; [10]struct{ x, y string } has twenty.
 func (t *Type) NumComponents(countBlank componentsIncludeBlankFields) int64 {
-	switch t.Etype {
+	switch t.kind {
 	case TSTRUCT:
 		if t.IsFuncArgStruct() {
 			Fatalf("NumComponents func arg struct")
@@ -1416,7 +1416,7 @@ func (t *Type) NumComponents(countBlank componentsIncludeBlankFields) int64 {
 // if there is exactly one. Otherwise, it returns nil.
 // Components are counted as in NumComponents, including blank fields.
 func (t *Type) SoleComponent() *Type {
-	switch t.Etype {
+	switch t.kind {
 	case TSTRUCT:
 		if t.IsFuncArgStruct() {
 			Fatalf("SoleComponent func arg struct")
@@ -1442,10 +1442,10 @@ func (t *Type) ChanDir() ChanDir {
 }
 
 func (t *Type) IsMemory() bool {
-	if t == TypeMem || t.Etype == TTUPLE && t.Extra.(*Tuple).second == TypeMem {
+	if t == TypeMem || t.kind == TTUPLE && t.Extra.(*Tuple).second == TypeMem {
 		return true
 	}
-	if t.Etype == TRESULTS {
+	if t.kind == TRESULTS {
 		if types := t.Extra.(*Results).Types; len(types) > 0 && types[len(types)-1] == TypeMem {
 			return true
 		}
@@ -1454,8 +1454,8 @@ func (t *Type) IsMemory() bool {
 }
 func (t *Type) IsFlags() bool   { return t == TypeFlags }
 func (t *Type) IsVoid() bool    { return t == TypeVoid }
-func (t *Type) IsTuple() bool   { return t.Etype == TTUPLE }
-func (t *Type) IsResults() bool { return t.Etype == TRESULTS }
+func (t *Type) IsTuple() bool   { return t.kind == TTUPLE }
+func (t *Type) IsResults() bool { return t.kind == TRESULTS }
 
 // IsUntyped reports whether t is an untyped type.
 func (t *Type) IsUntyped() bool {
@@ -1465,7 +1465,7 @@ func (t *Type) IsUntyped() bool {
 	if t == UntypedString || t == UntypedBool {
 		return true
 	}
-	switch t.Etype {
+	switch t.kind {
 	case TNIL, TIDEAL:
 		return true
 	}
@@ -1475,7 +1475,7 @@ func (t *Type) IsUntyped() bool {
 // HasPointers reports whether t contains a heap pointer.
 // Note that this function ignores pointers to go:notinheap types.
 func (t *Type) HasPointers() bool {
-	switch t.Etype {
+	switch t.kind {
 	case TINT, TUINT, TINT8, TUINT8, TINT16, TUINT16, TINT32, TUINT32, TINT64,
 		TUINT64, TUINTPTR, TFLOAT32, TFLOAT64, TCOMPLEX64, TCOMPLEX128, TBOOL, TSSA:
 		return false
@@ -1551,16 +1551,16 @@ var (
 )
 
 // NewNamed returns a new named type for the given type name.
-func NewNamed(obj IRNode) *Type {
+func NewNamed(obj Object) *Type {
 	t := New(TFORW)
-	t.Sym = obj.Sym()
+	t.sym = obj.Sym()
 	t.nod = obj
 	return t
 }
 
 // Obj returns the type name for the named type t.
-func (t *Type) Obj() IRNode {
-	if t.Sym != nil {
+func (t *Type) Obj() Object {
+	if t.sym != nil {
 		return t.nod
 	}
 	return nil
@@ -1568,7 +1568,7 @@ func (t *Type) Obj() IRNode {
 
 // SetUnderlying sets the underlying type.
 func (t *Type) SetUnderlying(underlying *Type) {
-	if underlying.Etype == TFORW {
+	if underlying.kind == TFORW {
 		// This type isn't computed yet; when it is, update n.
 		underlying.ForwardType().Copyto = append(underlying.ForwardType().Copyto, t)
 		return
@@ -1577,11 +1577,11 @@ func (t *Type) SetUnderlying(underlying *Type) {
 	ft := t.ForwardType()
 
 	// TODO(mdempsky): Fix Type rekinding.
-	t.Etype = underlying.Etype
+	t.kind = underlying.kind
 	t.Extra = underlying.Extra
 	t.Width = underlying.Width
 	t.Align = underlying.Align
-	t.Orig = underlying.Orig
+	t.underlying = underlying.underlying
 
 	if underlying.NotInHeap() {
 		t.SetNotInHeap(true)
@@ -1612,9 +1612,9 @@ func (t *Type) SetUnderlying(underlying *Type) {
 }
 
 // NewNamed returns a new basic type of the given kind.
-func NewBasic(kind EType, obj IRNode) *Type {
+func NewBasic(kind Kind, obj Object) *Type {
 	t := New(kind)
-	t.Sym = obj.Sym()
+	t.sym = obj.Sym()
 	t.nod = obj
 	return t
 }
-- 
GitLab


From 87bc85a846d5dc2d8fe7dbda900d6066ab98f1a5 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 30 Nov 2020 21:28:32 -0800
Subject: [PATCH 0118/2400] [dev.typeparams] cmd/compile/internal/types2:
 adjustments toward matching compiler error messages

In order to get types2 usable by the compiler, we need to
pass all the compiler tests with respect to error messages.
Sometimes the compiler error messages are better, sometimes
the types2 error messages are better. Where we can, we decide
on a case-by-case basis; but sometimes, for expediency's sake,
we just choose the compiler error message as it may reduce the
amount of tests that we need to update.

This CL introduces a new Config flag: CompilerErrorMessages.
If set, the typechecker emits an error message that matches
the expected errors in the tests most easily. Eventually, we
need to get rid of this flag by either adjusting the typechecker
errors or the test cases; t.b.d. on a case-by-case basis.

This CL also adjust a few error typechecker error messages already.

Change-Id: I9d4e491efadf87e999fc0d5b5151ec02a059f891
Reviewed-on: https://go-review.googlesource.com/c/go/+/274312
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/api.go             |  5 +++++
 src/cmd/compile/internal/types2/api_test.go        |  8 ++++----
 src/cmd/compile/internal/types2/assignments.go     | 10 +++++++---
 src/cmd/compile/internal/types2/builtins.go        |  2 +-
 src/cmd/compile/internal/types2/decl.go            |  6 +++++-
 src/cmd/compile/internal/types2/expr.go            |  8 ++++++--
 src/cmd/compile/internal/types2/exprstring.go      | 14 ++++++++++----
 src/cmd/compile/internal/types2/exprstring_test.go |  6 +++---
 .../compile/internal/types2/testdata/decls3.src    | 10 +++++-----
 .../compile/internal/types2/testdata/decls4.src    |  4 ++--
 .../internal/types2/testdata/issue28251.src        |  2 +-
 src/cmd/compile/internal/types2/typexpr.go         | 14 ++++++++++++--
 12 files changed, 61 insertions(+), 28 deletions(-)

diff --git a/src/cmd/compile/internal/types2/api.go b/src/cmd/compile/internal/types2/api.go
index eff90d4cdf..a40665ee17 100644
--- a/src/cmd/compile/internal/types2/api.go
+++ b/src/cmd/compile/internal/types2/api.go
@@ -119,6 +119,11 @@ type Config struct {
 	//          Do not use casually!
 	FakeImportC bool
 
+	// If CompilerErrorMessages is set, errors are reported using
+	// cmd/compile error strings to match $GOROOT/test errors.
+	// TODO(gri) Consolidate error messages and remove this flag.
+	CompilerErrorMessages bool
+
 	// If go115UsesCgo is set, the type checker expects the
 	// _cgo_gotypes.go file generated by running cmd/cgo to be
 	// provided as a package source file. Qualified identifiers
diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go
index 403df3f941..58d7df2f1d 100644
--- a/src/cmd/compile/internal/types2/api_test.go
+++ b/src/cmd/compile/internal/types2/api_test.go
@@ -687,8 +687,8 @@ func TestPredicatesInfo(t *testing.T) {
 
 		// values
 		{`package v0; var (a, b int; _ = a + b)`, `a + b`, `value`},
-		{`package v1; var _ = &[]int{1}`, `([]int literal)`, `value`},
-		{`package v2; var _ = func(){}`, `(func() literal)`, `value`},
+		{`package v1; var _ = &[]int{1}`, `[]int{…}`, `value`},
+		{`package v2; var _ = func(){}`, `func() {}`, `value`},
 		{`package v4; func f() { _ = f }`, `f`, `value`},
 		{`package v3; var _ *int = nil`, `nil`, `value, nil`},
 		{`package v3; var _ *int = (nil)`, `(nil)`, `value, nil`},
@@ -896,10 +896,10 @@ func TestInitOrderInfo(t *testing.T) {
 			"z = 0", "a, b = f()",
 		}},
 		{`package p7; var (a = func() int { return b }(); b = 1)`, []string{
-			"b = 1", "a = (func() int literal)()",
+			"b = 1", "a = func() int {…}()",
 		}},
 		{`package p8; var (a, b = func() (_, _ int) { return c, c }(); c = 1)`, []string{
-			"c = 1", "a, b = (func() (_, _ int) literal)()",
+			"c = 1", "a, b = func() (_, _ int) {…}()",
 		}},
 		{`package p9; type T struct{}; func (T) m() int { _ = y; return 0 }; var x, y = T.m, 1`, []string{
 			"y = 1", "x = T.m",
diff --git a/src/cmd/compile/internal/types2/assignments.go b/src/cmd/compile/internal/types2/assignments.go
index 93d3255686..3178c38ade 100644
--- a/src/cmd/compile/internal/types2/assignments.go
+++ b/src/cmd/compile/internal/types2/assignments.go
@@ -63,10 +63,14 @@ func (check *Checker) assignment(x *operand, T Type, context string) {
 	}
 
 	if reason := ""; !x.assignableTo(check, T, &reason) {
-		if reason != "" {
-			check.errorf(x, "cannot use %s as %s value in %s: %s", x, T, context, reason)
+		if check.conf.CompilerErrorMessages {
+			check.errorf(x, "incompatible type: cannot use %s as %s value", x, T)
 		} else {
-			check.errorf(x, "cannot use %s as %s value in %s", x, T, context)
+			if reason != "" {
+				check.errorf(x, "cannot use %s as %s value in %s: %s", x, T, context, reason)
+			} else {
+				check.errorf(x, "cannot use %s as %s value in %s", x, T, context)
+			}
 		}
 		x.mode = invalid
 	}
diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go
index 6ad84f4354..43da6a1529 100644
--- a/src/cmd/compile/internal/types2/builtins.go
+++ b/src/cmd/compile/internal/types2/builtins.go
@@ -281,7 +281,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 
 		// both argument types must be identical
 		if !check.identical(x.typ, y.typ) {
-			check.invalidArgf(x, "mismatched types %s and %s", x.typ, y.typ)
+			check.invalidOpf(x, "%s (mismatched types %s and %s)", call, x.typ, y.typ)
 			return
 		}
 
diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index ff37d85c6f..c7bfd3fd7b 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -792,7 +792,11 @@ func (check *Checker) collectMethods(obj *TypeName) {
 			case *Var:
 				check.errorf(m.pos, "field and method with the same name %s", m.name)
 			case *Func:
-				check.errorf(m.pos, "method %s already declared for %s", m.name, obj)
+				if check.conf.CompilerErrorMessages {
+					check.errorf(m.pos, "%s.%s redeclared in this block", obj.Name(), m.name)
+				} else {
+					check.errorf(m.pos, "method %s already declared for %s", m.name, obj)
+				}
 			default:
 				unreachable()
 			}
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index cb92143f93..3c9540783a 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -736,7 +736,8 @@ func (check *Checker) comparison(x, y *operand, op syntax.Operator) {
 	}
 
 	if err != "" {
-		check.errorf(x, "cannot compare %s %s %s (%s)", x.expr, op, y.expr, err)
+		// TODO(gri) better error message for cases where one can only compare against nil
+		check.invalidOpf(x, "cannot compare %s %s %s (%s)", x.expr, op, y.expr, err)
 		x.mode = invalid
 		return
 	}
@@ -1174,6 +1175,9 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 		goto Error
 
 	case *syntax.BasicLit:
+		if e.Bad {
+			goto Error // error was reported before
+		}
 		x.setConst(e.Kind, e.Value)
 		if x.mode == invalid {
 			// The parser already establishes syntactic correctness.
@@ -1624,7 +1628,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 			valid = true
 			length = typ.len
 			if x.mode != variable {
-				check.invalidOpf(x, "cannot slice %s (value not addressable)", x)
+				check.invalidOpf(x, "%s (slice of unaddressable value)", x)
 				goto Error
 			}
 			x.typ = &Slice{elem: typ.elem}
diff --git a/src/cmd/compile/internal/types2/exprstring.go b/src/cmd/compile/internal/types2/exprstring.go
index e187d050e6..0ec5d1338f 100644
--- a/src/cmd/compile/internal/types2/exprstring.go
+++ b/src/cmd/compile/internal/types2/exprstring.go
@@ -50,14 +50,20 @@ func WriteExpr(buf *bytes.Buffer, x syntax.Expr) {
 		buf.WriteString(x.Value)
 
 	case *syntax.FuncLit:
-		buf.WriteByte('(')
 		WriteExpr(buf, x.Type)
-		buf.WriteString(" literal)") // shortened
+		if x.Body != nil && len(x.Body.List) > 0 {
+			buf.WriteString(" {…}") // shortened
+		} else {
+			buf.WriteString(" {}")
+		}
 
 	case *syntax.CompositeLit:
-		buf.WriteByte('(')
 		WriteExpr(buf, x.Type)
-		buf.WriteString(" literal)") // shortened
+		if len(x.ElemList) > 0 {
+			buf.WriteString("{…}") // shortened
+		} else {
+			buf.WriteString("{}")
+		}
 
 	case *syntax.ParenExpr:
 		buf.WriteByte('(')
diff --git a/src/cmd/compile/internal/types2/exprstring_test.go b/src/cmd/compile/internal/types2/exprstring_test.go
index d7b9d5b2ef..efb7c308b7 100644
--- a/src/cmd/compile/internal/types2/exprstring_test.go
+++ b/src/cmd/compile/internal/types2/exprstring_test.go
@@ -24,9 +24,9 @@ var testExprs = []testEntry{
 	dup("`bar`"),
 
 	// func and composite literals
-	{"func(){}", "(func() literal)"},
-	{"func(x int) complex128 {}", "(func(x int) complex128 literal)"},
-	{"[]int{1, 2, 3}", "([]int literal)"},
+	{"func(){}", "func() {}"},
+	{"func(x int) complex128 {}", "func(x int) complex128 {}"},
+	{"[]int{1, 2, 3}", "[]int{…}"},
 
 	// non-type expressions
 	dup("(x)"),
diff --git a/src/cmd/compile/internal/types2/testdata/decls3.src b/src/cmd/compile/internal/types2/testdata/decls3.src
index 745175c710..d7a0c444da 100644
--- a/src/cmd/compile/internal/types2/testdata/decls3.src
+++ b/src/cmd/compile/internal/types2/testdata/decls3.src
@@ -221,16 +221,16 @@ func _() {
 	_ = S2{}.B
 	_ = S2{}.C
 	_ = S2{}.D /* ERROR "no field or method" */
-	_ = S3{}.S1 /* ERROR "ambiguous selector \(S3 literal\).S1" */
+	_ = S3{}.S1 /* ERROR "ambiguous selector S3\{\}.S1" */
 	_ = S3{}.A
-	_ = S3{}.B /* ERROR "ambiguous selector" \(S3 literal\).B */
+	_ = S3{}.B /* ERROR "ambiguous selector" S3\{\}.B */
 	_ = S3{}.D
 	_ = S3{}.E
 	_ = S4{}.A
 	_ = S4{}.B /* ERROR "no field or method" */
-	_ = S5{}.X /* ERROR "ambiguous selector \(S5 literal\).X" */
+	_ = S5{}.X /* ERROR "ambiguous selector S5\{\}.X" */
 	_ = S5{}.Y
-	_ = S10{}.X /* ERROR "ambiguous selector \(S10 literal\).X" */
+	_ = S10{}.X /* ERROR "ambiguous selector S10\{\}.X" */
 	_ = S10{}.Y
 }
 
@@ -306,4 +306,4 @@ type R22 R21
 type R23 R21
 type R24 R21
 
-var _ = R0{}.X /* ERROR "ambiguous selector \(R0 literal\).X" */
\ No newline at end of file
+var _ = R0{}.X /* ERROR "ambiguous selector R0\{\}.X" */
\ No newline at end of file
diff --git a/src/cmd/compile/internal/types2/testdata/decls4.src b/src/cmd/compile/internal/types2/testdata/decls4.src
index 140bbfd31f..eb08421bee 100644
--- a/src/cmd/compile/internal/types2/testdata/decls4.src
+++ b/src/cmd/compile/internal/types2/testdata/decls4.src
@@ -190,8 +190,8 @@ type eD struct {
 }
 
 var (
-	_ = eD{}.xf /* ERROR ambiguous selector \(eD literal\).xf */
-	_ = eD{}.xm /* ERROR ambiguous selector \(eD literal\).xm */
+	_ = eD{}.xf /* ERROR ambiguous selector eD\{\}.xf */
+	_ = eD{}.xm /* ERROR ambiguous selector eD\{\}.xm */
 )
 
 var (
diff --git a/src/cmd/compile/internal/types2/testdata/issue28251.src b/src/cmd/compile/internal/types2/testdata/issue28251.src
index cd79e0e8b5..ef5e61df47 100644
--- a/src/cmd/compile/internal/types2/testdata/issue28251.src
+++ b/src/cmd/compile/internal/types2/testdata/issue28251.src
@@ -60,6 +60,6 @@ type (
         T11 = T
 )
 
-func (T9 /* ERROR invalid receiver \*\*T */ ) m9() {}
+func (T9 /* ERROR invalid receiver type \*\*T */ ) m9() {}
 func _() { (T{}).m9 /* ERROR has no field or method m9 */ () }
 func _() { (&T{}).m9 /* ERROR has no field or method m9 */ () }
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 1adf967859..0c27e5e04b 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -384,6 +384,10 @@ func (check *Checker) funcType(sig *Signature, recvPar *syntax.Field, tparams []
 				// as the method."
 				if T.obj.pkg != check.pkg {
 					err = "type not defined in this package"
+					if check.conf.CompilerErrorMessages {
+						check.errorf(recv.pos, "cannot define new methods on non-local type %s", recv.typ)
+						err = ""
+					}
 				} else {
 					switch u := optype(T.Under()).(type) {
 					case *Basic:
@@ -395,11 +399,17 @@ func (check *Checker) funcType(sig *Signature, recvPar *syntax.Field, tparams []
 						err = "pointer or interface type"
 					}
 				}
-			} else {
+			} else if T := t.Basic(); T != nil {
 				err = "basic or unnamed type"
+				if check.conf.CompilerErrorMessages {
+					check.errorf(recv.pos, "cannot define new methods on non-local type %s", recv.typ)
+					err = ""
+				}
+			} else {
+				check.errorf(recv.pos, "invalid receiver type %s", recv.typ)
 			}
 			if err != "" {
-				check.errorf(recv.pos, "invalid receiver %s (%s)", recv.typ, err)
+				check.errorf(recv.pos, "invalid receiver type %s (%s)", recv.typ, err)
 				// ok to continue
 			}
 		}
-- 
GitLab


From 72ad2f44eaf8bb71ea100fd4acf7dd04384c7175 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 30 Nov 2020 21:38:49 -0800
Subject: [PATCH 0119/2400] [dev.typeparams] test: add scaffolding to run.go to
 check compiler with -G flag

Added a new flag -G to run. Setting -G (as in: go run run.go -G)
will run tests marked with "errorcheck" (and no other flags) also
with the compiler using the new typechecker.

Many tests don't pass yet (due to discrepancies in error messages).
The top-level tests in the test directory which don't pass yet have
been explicitly excluded, permitting to see the current status.
Future CLs will bring error messages in sync and eventually all
tests should pass.

Change-Id: I7caf5eff413e173f68d092af4bbe458434718d74
Reviewed-on: https://go-review.googlesource.com/c/go/+/274313
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/noder.go |   3 +-
 test/alias2.go                       |   4 +-
 test/append1.go                      |  10 +--
 test/assign.go                       |   6 +-
 test/blank1.go                       |   4 +-
 test/cannotassign.go                 |  22 +++---
 test/cmp6.go                         |  10 +--
 test/const1.go                       |  56 +++++++-------
 test/const2.go                       |   4 +-
 test/convert2.go                     |  74 +++++++++---------
 test/run.go                          | 112 ++++++++++++++++++++++++++-
 11 files changed, 208 insertions(+), 97 deletions(-)

diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 0cbea2c461..1cdb6bc08c 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -83,7 +83,8 @@ func parseFiles(filenames []string, allowGenerics bool) (lines uint) {
 		}
 
 		conf := types2.Config{
-			InferFromConstraints: true,
+			InferFromConstraints:  true,
+			CompilerErrorMessages: true,
 			Error: func(err error) {
 				terr := err.(types2.Error)
 				if len(terr.Msg) > 0 && terr.Msg[0] == '\t' {
diff --git a/test/alias2.go b/test/alias2.go
index 1c141ac490..d7b5dccb68 100644
--- a/test/alias2.go
+++ b/test/alias2.go
@@ -36,7 +36,7 @@ type (
 
 // Methods can be declared on the original named type and the alias.
 func (T0) m1()  {} // GCCGO_ERROR "previous"
-func (*T0) m1() {} // ERROR "method redeclared: T0\.m1|redefinition of .m1."
+func (*T0) m1() {} // ERROR "method redeclared: T0\.m1|T0\.m1 redeclared in this block|redefinition of .m1."
 func (A0) m1()  {} // ERROR "T0\.m1 redeclared in this block|redefinition of .m1."
 func (A0) m1()  {} // ERROR "T0\.m1 redeclared in this block|redefinition of .m1."
 func (A0) m2()  {}
@@ -90,7 +90,7 @@ func _() {
 
 // Invalid type alias declarations.
 
-type _ = reflect.ValueOf // ERROR "reflect.ValueOf is not a type|expected type"
+type _ = reflect.ValueOf // ERROR "reflect.ValueOf .*is not a type|expected type"
 
 func (A1) m() {} // ERROR "cannot define new methods on non-local type int|may not define methods on non-local type"
 func (A2) m() {} // ERROR "invalid receiver type"
diff --git a/test/append1.go b/test/append1.go
index 0fe24c0956..9dab120b25 100644
--- a/test/append1.go
+++ b/test/append1.go
@@ -13,10 +13,10 @@ func main() {
 
 	s := make([]int, 8)
 
-	_ = append()           // ERROR "missing arguments to append"
-	_ = append(s...)       // ERROR "cannot use ... on first argument"
-	_ = append(s, 2, s...) // ERROR "too many arguments to append"
+	_ = append()           // ERROR "missing arguments to append|not enough arguments for append"
+	_ = append(s...)       // ERROR "cannot use ... on first argument|not enough arguments in call to append"
+	_ = append(s, 2, s...) // ERROR "too many arguments to append|too many arguments in call to append"
 
-	_ = append(s, make([]int, 0))     // ERROR "cannot use make.* as type int in append"
-	_ = append(s, make([]int, -1)...) // ERROR "negative len argument in make"
+	_ = append(s, make([]int, 0))     // ERROR "cannot use make.* as type int in append|cannot use make.* as int value"
+	_ = append(s, make([]int, -1)...) // ERROR "negative len argument in make|index -1.* must not be negative"
 }
diff --git a/test/assign.go b/test/assign.go
index 6611f8ce3e..549f42eb80 100644
--- a/test/assign.go
+++ b/test/assign.go
@@ -42,7 +42,7 @@ func main() {
 		_ = x
 	}
 	{
-		x := sync.Mutex{key: 0} // ERROR "(unknown|assignment).*Mutex"
+		x := sync.Mutex{key: 0} // ERROR "(unknown|assignment).*Mutex|unknown field.* in struct literal"
 		_ = x
 	}
 	{
@@ -56,13 +56,13 @@ func main() {
 	{
 		var x = 1
 		{
-			x, x := 2, 3 // ERROR "x repeated on left side of :="
+			x, x := 2, 3 // ERROR "x repeated on left side of :=|x redeclared in this block"
 			_ = x
 		}
 		_ = x
 	}
 	{
-		a, a := 1, 2 // ERROR "a repeated on left side of :="
+		a, a := 1, 2 // ERROR "a repeated on left side of :=|a redeclared in this block"
 		_ = a
 	}
 }
diff --git a/test/blank1.go b/test/blank1.go
index c9a8e6a290..3c981cd5eb 100644
--- a/test/blank1.go
+++ b/test/blank1.go
@@ -25,8 +25,8 @@ func main() {
 	_()	// ERROR "cannot use .* as value"
 	x := _+1	// ERROR "cannot use .* as value"
 	_ = x
-	_ = t._ // ERROR "cannot refer to blank field|invalid use of"
+	_ = t._ // ERROR "cannot refer to blank field|invalid use of|t._ undefined"
 
       var v1, v2 T
-      _ = v1 == v2 // ERROR "cannot be compared|non-comparable"
+      _ = v1 == v2 // ERROR "cannot be compared|non-comparable|cannot compare v1 == v2"
 }
diff --git a/test/cannotassign.go b/test/cannotassign.go
index 0de04ecad0..27e62890c5 100644
--- a/test/cannotassign.go
+++ b/test/cannotassign.go
@@ -10,24 +10,24 @@ package main
 
 func main() {
 	var s string = "hello"
-	s[1:2] = "a" // ERROR "cannot assign to .* \(strings are immutable\)"
-	s[3] = "b"   // ERROR "cannot assign to .* \(strings are immutable\)"
+	s[1:2] = "a" // ERROR "cannot assign to .* (\(strings are immutable\))?"
+	s[3] = "b"   // ERROR "cannot assign to .* (\(strings are immutable\))?"
 
 	const n int = 1
 	const cs string = "hello"
-	n = 2        // ERROR "cannot assign to .* \(declared const\)"
-	cs = "hi"    // ERROR "cannot assign to .* \(declared const\)"
-	true = false // ERROR "cannot assign to .* \(declared const\)"
+	n = 2        // ERROR "cannot assign to .* (\(declared const\))?"
+	cs = "hi"    // ERROR "cannot assign to .* (\(declared const\))?"
+	true = false // ERROR "cannot assign to .* (\(declared const\))?"
 
 	var m map[int]struct{ n int }
 	m[0].n = 7 // ERROR "cannot assign to struct field .* in map$"
 
-	1 = 7         // ERROR "cannot assign to 1$"
-	"hi" = 7      // ERROR `cannot assign to "hi"$`
-	nil = 7       // ERROR "cannot assign to nil$"
-	len("") = 7   // ERROR `cannot assign to len\(""\)$`
-	[]int{} = nil // ERROR "cannot assign to \[\]int\{\}$"
+	1 = 7         // ERROR "cannot assign to 1"
+	"hi" = 7      // ERROR `cannot assign to "hi"`
+	nil = 7       // ERROR "cannot assign to nil"
+	len("") = 7   // ERROR `cannot assign to len\(""\)`
+	[]int{} = nil // ERROR "cannot assign to \[\]int\{\}"
 
 	var x int = 7
-	x + 1 = 7 // ERROR "cannot assign to x \+ 1$"
+	x + 1 = 7 // ERROR "cannot assign to x \+ 1"
 }
diff --git a/test/cmp6.go b/test/cmp6.go
index 7cf76044ef..704ead2caa 100644
--- a/test/cmp6.go
+++ b/test/cmp6.go
@@ -63,16 +63,16 @@ func main() {
 	use(a3 == a3) // ERROR "invalid operation|invalid comparison"
 
 	// Comparison of structs should have a good message
-	use(t3 == t3) // ERROR "struct|expected"
-	use(t4 == t4) // ERROR "cannot be compared|non-comparable"
+	use(t3 == t3) // ERROR "struct|expected|cannot compare"
+	use(t4 == t4) // ERROR "cannot be compared|non-comparable|cannot compare"
 
 	// Slices, functions, and maps too.
 	var x []int
 	var f func()
 	var m map[int]int
-	use(x == x) // ERROR "slice can only be compared to nil"
-	use(f == f) // ERROR "func can only be compared to nil"
-	use(m == m) // ERROR "map can only be compared to nil"
+	use(x == x) // ERROR "slice can only be compared to nil|cannot compare"
+	use(f == f) // ERROR "func can only be compared to nil|cannot compare"
+	use(m == m) // ERROR "map can only be compared to nil|cannot compare"
 
 	// Comparison with interface that cannot return true
 	// (would panic).
diff --git a/test/const1.go b/test/const1.go
index 3fd5b55522..1efe688cb9 100644
--- a/test/const1.go
+++ b/test/const1.go
@@ -30,43 +30,43 @@ const (
 )
 
 var (
-	a1 = Int8 * 100              // ERROR "overflow"
+	a1 = Int8 * 100              // ERROR "overflow|cannot convert"
 	a2 = Int8 * -1               // OK
-	a3 = Int8 * 1000             // ERROR "overflow"
-	a4 = Int8 * int8(1000)       // ERROR "overflow"
-	a5 = int8(Int8 * 1000)       // ERROR "overflow"
-	a6 = int8(Int8 * int8(1000)) // ERROR "overflow"
-	a7 = Int8 - 2*Int8 - 2*Int8  // ERROR "overflow"
-	a8 = Int8 * Const / 100      // ERROR "overflow"
+	a3 = Int8 * 1000             // ERROR "overflow|cannot convert"
+	a4 = Int8 * int8(1000)       // ERROR "overflow|cannot convert"
+	a5 = int8(Int8 * 1000)       // ERROR "overflow|cannot convert"
+	a6 = int8(Int8 * int8(1000)) // ERROR "overflow|cannot convert"
+	a7 = Int8 - 2*Int8 - 2*Int8  // ERROR "overflow|cannot convert"
+	a8 = Int8 * Const / 100      // ERROR "overflow|cannot convert"
 	a9 = Int8 * (Const / 100)    // OK
 
-	b1        = Uint8 * Uint8         // ERROR "overflow"
-	b2        = Uint8 * -1            // ERROR "overflow"
+	b1        = Uint8 * Uint8         // ERROR "overflow|cannot convert"
+	b2        = Uint8 * -1            // ERROR "overflow|cannot convert"
 	b3        = Uint8 - Uint8         // OK
-	b4        = Uint8 - Uint8 - Uint8 // ERROR "overflow"
-	b5        = uint8(^0)             // ERROR "overflow"
+	b4        = Uint8 - Uint8 - Uint8 // ERROR "overflow|cannot convert"
+	b5        = uint8(^0)             // ERROR "overflow|cannot convert"
 	b5a       = int64(^0)             // OK
 	b6        = ^uint8(0)             // OK
 	b6a       = ^int64(0)             // OK
-	b7        = uint8(Minus1)         // ERROR "overflow"
-	b8        = uint8(int8(-1))       // ERROR "overflow"
-	b8a       = uint8(-1)             // ERROR "overflow"
+	b7        = uint8(Minus1)         // ERROR "overflow|cannot convert"
+	b8        = uint8(int8(-1))       // ERROR "overflow|cannot convert"
+	b8a       = uint8(-1)             // ERROR "overflow|cannot convert"
 	b9   byte = (1 << 10) >> 8        // OK
-	b10  byte = (1 << 10)             // ERROR "overflow"
-	b11  byte = (byte(1) << 10) >> 8  // ERROR "overflow"
-	b12  byte = 1000                  // ERROR "overflow"
-	b13  byte = byte(1000)            // ERROR "overflow"
-	b14  byte = byte(100) * byte(100) // ERROR "overflow"
-	b15  byte = byte(100) * 100       // ERROR "overflow"
-	b16  byte = byte(0) * 1000        // ERROR "overflow"
+	b10  byte = (1 << 10)             // ERROR "overflow|cannot convert"
+	b11  byte = (byte(1) << 10) >> 8  // ERROR "overflow|cannot convert"
+	b12  byte = 1000                  // ERROR "overflow|cannot convert"
+	b13  byte = byte(1000)            // ERROR "overflow|cannot convert"
+	b14  byte = byte(100) * byte(100) // ERROR "overflow|cannot convert"
+	b15  byte = byte(100) * 100       // ERROR "overflow|cannot convert"
+	b16  byte = byte(0) * 1000        // ERROR "overflow|cannot convert"
 	b16a byte = 0 * 1000              // OK
-	b17  byte = byte(0) * byte(1000)  // ERROR "overflow"
+	b17  byte = byte(0) * byte(1000)  // ERROR "overflow|cannot convert"
 	b18  byte = Uint8 / 0             // ERROR "division by zero"
 
 	c1 float64 = Big
-	c2 float64 = Big * Big          // ERROR "overflow"
-	c3 float64 = float64(Big) * Big // ERROR "overflow"
-	c4         = Big * Big          // ERROR "overflow"
+	c2 float64 = Big * Big          // ERROR "overflow|cannot convert"
+	c3 float64 = float64(Big) * Big // ERROR "overflow|cannot convert"
+	c4         = Big * Big          // ERROR "overflow|cannot convert"
 	c5         = Big / 0            // ERROR "division by zero"
 	c6         = 1000 % 1e3         // ERROR "invalid operation|expected integer type"
 )
@@ -87,8 +87,8 @@ func main() {
 	f(Bool)             // ERROR "convert|wrong type|cannot|incompatible"
 }
 
-const ptr = nil // ERROR "const.*nil"
+const ptr = nil // ERROR "const.*nil|not constant"
 const _ = string([]byte(nil)) // ERROR "is not a? ?constant"
 const _ = uintptr(unsafe.Pointer((*int)(nil))) // ERROR "is not a? ?constant"
-const _ = unsafe.Pointer((*int)(nil)) // ERROR "cannot be nil|invalid constant type|is not a constant"
-const _ = (*int)(nil) // ERROR "cannot be nil|invalid constant type|is not a constant"
+const _ = unsafe.Pointer((*int)(nil)) // ERROR "cannot be nil|invalid constant type|is not a constant|not constant"
+const _ = (*int)(nil) // ERROR "cannot be nil|invalid constant type|is not a constant|not constant"
diff --git a/test/const2.go b/test/const2.go
index d104a2fa71..f0de37be15 100644
--- a/test/const2.go
+++ b/test/const2.go
@@ -11,7 +11,7 @@ package main
 
 const (
 	A int = 1
-	B byte;	// ERROR "type without expr|expected .=."
+	B byte;	// ERROR "type without expr|expected .=.|missing init expr"
 )
 
 const LargeA = 1000000000000000000
@@ -23,7 +23,7 @@ const AlsoLargeA = LargeA << 400 << 400 >> 400 >> 400 // GC_ERROR "constant shif
 // Issue #42732.
 
 const a = 1e+500000000
-const b = a * a // ERROR "constant multiplication overflow"
+const b = a * a // ERROR "constant multiplication overflow|not representable"
 const c = b * b
 
 const MaxInt512 = (1<<256 - 1) * (1<<256 + 1)
diff --git a/test/convert2.go b/test/convert2.go
index c500638929..e7044b2453 100644
--- a/test/convert2.go
+++ b/test/convert2.go
@@ -22,7 +22,7 @@ func _() {
 	var t T
 	var u struct{}
 	s = s
-	s = t // ERROR "cannot use .* in assignment"
+	s = t // ERROR "cannot use .* in assignment|incompatible type"
 	s = u
 	s = S(s)
 	s = S(t)
@@ -42,12 +42,12 @@ func _() {
 		x int "bar"
 	}
 	s = s
-	s = t // ERROR "cannot use .* in assignment"
-	s = u // ERROR "cannot use .* in assignment"
+	s = t // ERROR "cannot use .* in assignment|incompatible type"
+	s = u // ERROR "cannot use .* in assignment|incompatible type"
 	s = S(s)
 	s = S(t)
 	s = S(u)
-	t = u // ERROR "cannot use .* in assignment"
+	t = u // ERROR "cannot use .* in assignment|incompatible type"
 	t = T(u)
 }
 
@@ -63,12 +63,12 @@ func _() {
 		x E "bar"
 	}
 	s = s
-	s = t // ERROR "cannot use .* in assignment"
-	s = u // ERROR "cannot use .* in assignment"
+	s = t // ERROR "cannot use .* in assignment|incompatible type"
+	s = u // ERROR "cannot use .* in assignment|incompatible type"
 	s = S(s)
 	s = S(t)
 	s = S(u)
-	t = u // ERROR "cannot use .* in assignment"
+	t = u // ERROR "cannot use .* in assignment|incompatible type"
 	t = T(u)
 }
 
@@ -91,12 +91,12 @@ func _() {
 		} "bar"
 	}
 	s = s
-	s = t // ERROR "cannot use .* in assignment"
-	s = u // ERROR "cannot use .* in assignment"
+	s = t // ERROR "cannot use .* in assignment|incompatible type"
+	s = u // ERROR "cannot use .* in assignment|incompatible type"
 	s = S(s)
 	s = S(t)
 	s = S(u)
-	t = u // ERROR "cannot use .* in assignment"
+	t = u // ERROR "cannot use .* in assignment|incompatible type"
 	t = T(u)
 }
 
@@ -117,12 +117,12 @@ func _() {
 		x E2 "bar"
 	}
 	s = s
-	s = t // ERROR "cannot use .* in assignment"
-	s = u // ERROR "cannot use .* in assignment"
+	s = t // ERROR "cannot use .* in assignment|incompatible type"
+	s = u // ERROR "cannot use .* in assignment|incompatible type"
 	s = S(s)
 	s = S(t) // ERROR "cannot convert"
 	s = S(u) // ERROR "cannot convert"
-	t = u    // ERROR "cannot use .* in assignment"
+	t = u    // ERROR "cannot use .* in assignment|incompatible type"
 	t = T(u)
 }
 
@@ -142,12 +142,12 @@ func _() {
 	var t T
 	var u struct{ f func(E) }
 	s = s
-	s = t // ERROR "cannot use .* in assignment"
-	s = u // ERROR "cannot use .* in assignment"
+	s = t // ERROR "cannot use .* in assignment|incompatible type"
+	s = u // ERROR "cannot use .* in assignment|incompatible type"
 	s = S(s)
 	s = S(t)
 	s = S(u) // ERROR "cannot convert"
-	t = u    // ERROR "cannot use .* in assignment"
+	t = u    // ERROR "cannot use .* in assignment|incompatible type"
 	t = T(u) // ERROR "cannot convert"
 }
 
@@ -160,12 +160,12 @@ func _() {
 	var t *T
 	var u *struct{}
 	s = s
-	s = t // ERROR "cannot use .* in assignment"
-	s = u // ERROR "cannot use .* in assignment"
+	s = t // ERROR "cannot use .* in assignment|incompatible type"
+	s = u // ERROR "cannot use .* in assignment|incompatible type"
 	s = (*S)(s)
 	s = (*S)(t)
 	s = (*S)(u)
-	t = u // ERROR "cannot use .* in assignment"
+	t = u // ERROR "cannot use .* in assignment|incompatible type"
 	t = (*T)(u)
 }
 
@@ -180,12 +180,12 @@ func _() {
 		x int "bar"
 	}
 	s = s
-	s = t // ERROR "cannot use .* in assignment"
-	s = u // ERROR "cannot use .* in assignment"
+	s = t // ERROR "cannot use .* in assignment|incompatible type"
+	s = u // ERROR "cannot use .* in assignment|incompatible type"
 	s = (*S)(s)
 	s = (*S)(t)
 	s = (*S)(u)
-	t = u // ERROR "cannot use .* in assignment"
+	t = u // ERROR "cannot use .* in assignment|incompatible type"
 	t = (*T)(u)
 }
 
@@ -201,12 +201,12 @@ func _() {
 		x E "bar"
 	}
 	s = s
-	s = t // ERROR "cannot use .* in assignment"
-	s = u // ERROR "cannot use .* in assignment"
+	s = t // ERROR "cannot use .* in assignment|incompatible type"
+	s = u // ERROR "cannot use .* in assignment|incompatible type"
 	s = (*S)(s)
 	s = (*S)(t)
 	s = (*S)(u)
-	t = u // ERROR "cannot use .* in assignment"
+	t = u // ERROR "cannot use .* in assignment|incompatible type"
 	t = (*T)(u)
 }
 
@@ -229,12 +229,12 @@ func _() {
 		} "bar"
 	}
 	s = s
-	s = t // ERROR "cannot use .* in assignment"
-	s = u // ERROR "cannot use .* in assignment"
+	s = t // ERROR "cannot use .* in assignment|incompatible type"
+	s = u // ERROR "cannot use .* in assignment|incompatible type"
 	s = (*S)(s)
 	s = (*S)(t)
 	s = (*S)(u)
-	t = u // ERROR "cannot use .* in assignment"
+	t = u // ERROR "cannot use .* in assignment|incompatible type"
 	t = (*T)(u)
 }
 
@@ -255,12 +255,12 @@ func _() {
 		x E2 "bar"
 	}
 	s = s
-	s = t // ERROR "cannot use .* in assignment"
-	s = u // ERROR "cannot use .* in assignment"
+	s = t // ERROR "cannot use .* in assignment|incompatible type"
+	s = u // ERROR "cannot use .* in assignment|incompatible type"
 	s = (*S)(s)
 	s = (*S)(t) // ERROR "cannot convert"
 	s = (*S)(u) // ERROR "cannot convert"
-	t = u       // ERROR "cannot use .* in assignment"
+	t = u       // ERROR "cannot use .* in assignment|incompatible type"
 	t = (*T)(u)
 }
 
@@ -280,12 +280,12 @@ func _() {
 	var t *T
 	var u *struct{ f func(E) }
 	s = s
-	s = t // ERROR "cannot use .* in assignment"
-	s = u // ERROR "cannot use .* in assignment"
+	s = t // ERROR "cannot use .* in assignment|incompatible type"
+	s = u // ERROR "cannot use .* in assignment|incompatible type"
 	s = (*S)(s)
 	s = (*S)(t)
 	s = (*S)(u) // ERROR "cannot convert"
-	t = u       // ERROR "cannot use .* in assignment"
+	t = u       // ERROR "cannot use .* in assignment|incompatible type"
 	t = (*T)(u) // ERROR "cannot convert"
 }
 
@@ -305,11 +305,11 @@ func _() {
 	var t *T
 	var u *struct{ f func(E) }
 	s = s
-	s = t // ERROR "cannot use .* in assignment"
-	s = u // ERROR "cannot use .* in assignment"
+	s = t // ERROR "cannot use .* in assignment|incompatible type"
+	s = u // ERROR "cannot use .* in assignment|incompatible type"
 	s = (*S)(s)
 	s = (*S)(t)
 	s = (*S)(u) // ERROR "cannot convert"
-	t = u       // ERROR "cannot use .* in assignment"
+	t = u       // ERROR "cannot use .* in assignment|incompatible type"
 	t = (*T)(u) // ERROR "cannot convert"
 }
diff --git a/test/run.go b/test/run.go
index 7422e6922d..319aed5ac1 100644
--- a/test/run.go
+++ b/test/run.go
@@ -39,6 +39,7 @@ var (
 	runSkips       = flag.Bool("run_skips", false, "run skipped tests (ignore skip and build tags)")
 	linkshared     = flag.Bool("linkshared", false, "")
 	updateErrors   = flag.Bool("update_errors", false, "update error messages in test file based on compiler output")
+	newTypechecker = flag.Bool("G", false, "generics typechecker. if set, run basic errorcheck tests also with new typechecker")
 	runoutputLimit = flag.Int("l", defaultRunOutputLimit(), "number of parallel runoutput tests to run")
 
 	shard  = flag.Int("shard", 0, "shard index to run. Only applicable if -shards is non-zero.")
@@ -740,7 +741,116 @@ func (t *test) run() {
 			t.updateErrors(string(out), long)
 		}
 		t.err = t.errorCheck(string(out), wantAuto, long, t.gofile)
-		return
+
+		if t.err != nil || !*newTypechecker {
+			return
+		}
+
+		// The following is temporary scaffolding to get types2 typechecker
+		// up and running against the existing test cases. The explicitly
+		// listed files don't pass yet, usually because the error messages
+		// are slightly different (this list is not complete). Any errorcheck
+		// tests that require output from analysis phases past intial type-
+		// checking are also excluded since these phases are not running yet.
+		// We can get rid of this code once types2 is fully plugged in.
+
+		// For now we're done when we can't handle the file or some of the flags.
+		// The first goal is to eliminate the file list; the second goal is to
+		// eliminate the flag list.
+
+		// Excluded files.
+		for _, file := range []string{
+			"complit1",
+			"const2",
+			"convlit.go",
+			"copy1.go",
+			"ddd1.go",
+			"devirt.go",
+			"directive.go",
+			"float_lit3.go",
+			"func1.go",
+			"funcdup.go",
+			"funcdup2.go",
+			"goto.go",
+			"import1.go",
+			"import5.go",
+			"import6.go",
+			"init.go",
+			"initializerr.go",
+			"initloop.go",
+			"label.go",
+			"label1.go",
+			"makechan.go",
+			"makemap.go",
+			"makenew.go",
+			"map1.go",
+			"method2.go",
+			"method6.go",
+			"named1.go",
+			"rename1.go",
+			"runtime.go",
+			"shift1.go",
+			"slice3err.go",
+			"switch3.go",
+			"switch5.go",
+			"switch6.go",
+			"switch7.go",
+			"typecheck.go",
+			"typecheckloop.go",
+			"typeswitch3.go",
+			"undef.go",
+			"varerr.go",
+		} {
+			if strings.Contains(long, file) {
+				return // cannot handle file
+			}
+		}
+
+		// Excluded flags.
+		for _, flag := range flags {
+			for _, pattern := range []string{
+				"-+",
+				"-m",
+				"-live",
+				"wb",
+				"append",
+				"slice",
+				"ssa/check_bce/debug",
+				"ssa/intrinsics/debug",
+				"ssa/prove/debug",
+				"ssa/likelyadjust/debug",
+				"ssa/insert_resched_checks/off",
+				"ssa/phiopt/debug",
+				"defer",
+				"nil",
+			} {
+				if strings.Contains(flag, pattern) {
+					return // cannot handle flag
+				}
+			}
+		}
+
+		// Run errorcheck again with -G option (new typechecker).
+		cmdline = []string{goTool(), "tool", "compile", "-G", "-C", "-e", "-o", "a.o"}
+		// No need to add -dynlink even if linkshared if we're just checking for errors...
+		cmdline = append(cmdline, flags...)
+		cmdline = append(cmdline, long)
+		out, err = runcmd(cmdline...)
+		if wantError {
+			if err == nil {
+				t.err = fmt.Errorf("compilation succeeded unexpectedly\n%s", out)
+				return
+			}
+		} else {
+			if err != nil {
+				t.err = err
+				return
+			}
+		}
+		if *updateErrors {
+			t.updateErrors(string(out), long)
+		}
+		t.err = t.errorCheck(string(out), wantAuto, long, t.gofile)
 
 	case "compile":
 		// Compile Go file.
-- 
GitLab


From bdc4ffe9a86d1dae0fef9de8395850e5c0b391c6 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 1 Dec 2020 12:18:20 -0800
Subject: [PATCH 0120/2400] [dev.typeparams] cmd/compile/internal/types2: add
 Config.IgnoreBranches flag

If the new Config.IgnoreBranches flag is set, the typechecker
ignores errors due to misplaced labels, break, continue,
fallthrough, or goto statements.

Since the syntax parser already checks these errors, we need
to disable a 2nd check by the typechecker to avoid duplicate
errors when running the compiler with the new typechecker.

Adjusted test/run.go to not ignore some of the tests that
used to fail because of duplicate errors.

Change-Id: I8756eb1d44f67afef5e57da289cd604b8e1716db
Reviewed-on: https://go-review.googlesource.com/c/go/+/274612
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/gc/noder.go    |  3 ++-
 src/cmd/compile/internal/types2/api.go  |  5 +++++
 src/cmd/compile/internal/types2/stmt.go | 10 +++++++++-
 test/run.go                             |  4 +---
 4 files changed, 17 insertions(+), 5 deletions(-)

diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 1cdb6bc08c..5115932b1e 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -84,7 +84,8 @@ func parseFiles(filenames []string, allowGenerics bool) (lines uint) {
 
 		conf := types2.Config{
 			InferFromConstraints:  true,
-			CompilerErrorMessages: true,
+			IgnoreBranches:        true, // parser already checked via syntax.CheckBranches mode
+			CompilerErrorMessages: true, // use error strings matching existing compiler errors
 			Error: func(err error) {
 				terr := err.(types2.Error)
 				if len(terr.Msg) > 0 && terr.Msg[0] == '\t' {
diff --git a/src/cmd/compile/internal/types2/api.go b/src/cmd/compile/internal/types2/api.go
index a40665ee17..c5c30babff 100644
--- a/src/cmd/compile/internal/types2/api.go
+++ b/src/cmd/compile/internal/types2/api.go
@@ -119,6 +119,11 @@ type Config struct {
 	//          Do not use casually!
 	FakeImportC bool
 
+	// If IgnoreBranches is set, errors related to incorrectly placed
+	// labels, gotos, break, continue, and fallthrough statements are
+	// ignored.
+	IgnoreBranches bool
+
 	// If CompilerErrorMessages is set, errors are reported using
 	// cmd/compile error strings to match $GOROOT/test errors.
 	// TODO(gri) Consolidate error messages and remove this flag.
diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go
index 37aa3c7308..11a9b8313f 100644
--- a/src/cmd/compile/internal/types2/stmt.go
+++ b/src/cmd/compile/internal/types2/stmt.go
@@ -42,6 +42,7 @@ func (check *Checker) funcBody(decl *declInfo, name string, sig *Signature, body
 	check.stmtList(0, body.List)
 
 	if check.hasLabel {
+		assert(!check.conf.IgnoreBranches)
 		check.labels(body)
 	}
 
@@ -316,7 +317,7 @@ func (check *Checker) stmt(ctxt stmtContext, s syntax.Stmt) {
 		check.declStmt(s.DeclList)
 
 	case *syntax.LabeledStmt:
-		check.hasLabel = true
+		check.hasLabel = !check.conf.IgnoreBranches
 		check.stmt(ctxt, s.Stmt)
 
 	case *syntax.ExprStmt:
@@ -443,6 +444,10 @@ func (check *Checker) stmt(ctxt stmtContext, s syntax.Stmt) {
 		}
 
 	case *syntax.BranchStmt:
+		if check.conf.IgnoreBranches {
+			break
+		}
+
 		if s.Label != nil {
 			check.hasLabel = true
 			return // checked in 2nd pass (check.labels)
@@ -464,6 +469,9 @@ func (check *Checker) stmt(ctxt stmtContext, s syntax.Stmt) {
 				}
 				check.error(s, msg)
 			}
+		case syntax.Goto:
+			// goto's must have labels, should have been caught above
+			fallthrough
 		default:
 			check.invalidASTf(s, "branch statement: %s", s.Tok)
 		}
diff --git a/test/run.go b/test/run.go
index 319aed5ac1..1eef6f1f35 100644
--- a/test/run.go
+++ b/test/run.go
@@ -771,15 +771,12 @@ func (t *test) run() {
 			"func1.go",
 			"funcdup.go",
 			"funcdup2.go",
-			"goto.go",
 			"import1.go",
 			"import5.go",
 			"import6.go",
 			"init.go",
 			"initializerr.go",
 			"initloop.go",
-			"label.go",
-			"label1.go",
 			"makechan.go",
 			"makemap.go",
 			"makenew.go",
@@ -792,6 +789,7 @@ func (t *test) run() {
 			"shift1.go",
 			"slice3err.go",
 			"switch3.go",
+			"switch4.go",
 			"switch5.go",
 			"switch6.go",
 			"switch7.go",
-- 
GitLab


From 1408d26ccca5f770e29785ddd442523416de2dd6 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 1 Dec 2020 11:37:30 -0800
Subject: [PATCH 0121/2400] [dev.regabi] cmd/compile: cleanup some leftover
 cruft

Just clearing away some scaffolding artifacts from previous
refactorings.

[git-generate]
cd src/cmd/compile/internal/gc
rf '
ex {
  import "cmd/compile/internal/ir"
  import "cmd/compile/internal/types"

  var n *ir.Name; n.Name() -> n
  var f *ir.Func; f.Func() -> f

  var o types.Object
  ir.AsNode(o).Sym() -> o.Sym()
  ir.AsNode(o).Type() -> o.Type()
  ir.AsNode(o).(*ir.Name) -> o.(*ir.Name)
  ir.AsNode(o).(*ir.Func) -> o.(*ir.Func)

  var x ir.Node
  ir.AsNode(o) != x -> o != x
}
'

Change-Id: I946ec344bd7ee274900a392da53b95308ceaade4
Reviewed-on: https://go-review.googlesource.com/c/go/+/274592
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/gc/closure.go   |  2 +-
 src/cmd/compile/internal/gc/dcl.go       | 10 +++++-----
 src/cmd/compile/internal/gc/escape.go    | 10 +++++-----
 src/cmd/compile/internal/gc/iexport.go   |  4 ++--
 src/cmd/compile/internal/gc/init.go      |  2 +-
 src/cmd/compile/internal/gc/main.go      |  2 +-
 src/cmd/compile/internal/gc/noder.go     |  2 +-
 src/cmd/compile/internal/gc/obj.go       |  4 ++--
 src/cmd/compile/internal/gc/pgen.go      | 16 ++++++++--------
 src/cmd/compile/internal/gc/reflect.go   |  4 ++--
 src/cmd/compile/internal/gc/ssa.go       |  4 ++--
 src/cmd/compile/internal/gc/typecheck.go |  6 +++---
 src/cmd/compile/internal/gc/universe.go  |  2 +-
 src/cmd/compile/internal/gc/walk.go      | 10 +++++-----
 14 files changed, 39 insertions(+), 39 deletions(-)

diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index 0ba2858b8b..e33a561bd4 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -437,7 +437,7 @@ func makepartialcall(dot ir.Node, t0 *types.Type, meth *types.Sym) *ir.Func {
 	sym := methodSymSuffix(rcvrtype, meth, "-fm")
 
 	if sym.Uniq() {
-		return ir.AsNode(sym.Def).(*ir.Func)
+		return sym.Def.(*ir.Func)
 	}
 	sym.SetUniq(true)
 
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 3d0bdaec7a..dd59d829fe 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -95,7 +95,7 @@ func declare(n *ir.Name, ctxt ir.Class) {
 			gen = vargen
 		}
 		types.Pushdcl(s)
-		n.Name().Curfn = Curfn
+		n.Curfn = Curfn
 	}
 
 	if ctxt == ir.PAUTO {
@@ -113,7 +113,7 @@ func declare(n *ir.Name, ctxt ir.Class) {
 	s.Block = types.Block
 	s.Lastlineno = base.Pos
 	s.Def = n
-	n.Name().Vargen = int32(gen)
+	n.Vargen = int32(gen)
 	n.SetClass(ctxt)
 	if ctxt == ir.PFUNC {
 		n.Sym().SetFunc(true)
@@ -335,7 +335,7 @@ func colasdefn(left []ir.Node, defn ir.Node) {
 		nnew++
 		n := NewName(n.Sym())
 		declare(n, dclcontext)
-		n.Name().Defn = defn
+		n.Defn = defn
 		defn.PtrInit().Append(ir.Nod(ir.ODCL, n, nil))
 		left[i] = n
 	}
@@ -438,7 +438,7 @@ func funcarg(n *ir.Field, ctxt ir.Class) {
 	declare(name, ctxt)
 
 	vargen++
-	n.Decl.Name().Vargen = int32(vargen)
+	n.Decl.Vargen = int32(vargen)
 }
 
 // Same as funcargs, except run over an already constructed TFUNC.
@@ -837,7 +837,7 @@ func addmethod(n *ir.Func, msym *types.Sym, t *types.Type, local, nointerface bo
 	}
 
 	f := types.NewField(base.Pos, msym, t)
-	f.Nname = n.Func().Nname
+	f.Nname = n.Nname
 	f.SetNointerface(nointerface)
 
 	mt.Methods().Append(f)
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index b29896e5a4..c139771730 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -1802,8 +1802,8 @@ func addrescapes(n ir.Node) {
 		}
 
 		// If a closure reference escapes, mark the outer variable as escaping.
-		if n.Name().IsClosureVar() {
-			addrescapes(n.Name().Defn)
+		if n.IsClosureVar() {
+			addrescapes(n.Defn)
 			break
 		}
 
@@ -1824,7 +1824,7 @@ func addrescapes(n ir.Node) {
 		// then we're analyzing the inner closure but we need to move x to the
 		// heap in f, not in the inner closure. Flip over to f before calling moveToHeap.
 		oldfn := Curfn
-		Curfn = n.Name().Curfn
+		Curfn = n.Curfn
 		ln := base.Pos
 		base.Pos = Curfn.Pos()
 		moveToHeap(n)
@@ -1893,7 +1893,7 @@ func moveToHeap(n *ir.Name) {
 			// See issue 16095.
 			heapaddr.SetIsOutputParamHeapAddr(true)
 		}
-		n.Name().Stackcopy = stackcopy
+		n.Stackcopy = stackcopy
 
 		// Substitute the stackcopy into the function variable list so that
 		// liveness and other analyses use the underlying stack slot
@@ -1920,7 +1920,7 @@ func moveToHeap(n *ir.Name) {
 	// Modify n in place so that uses of n now mean indirection of the heapaddr.
 	n.SetClass(ir.PAUTOHEAP)
 	n.SetOffset(0)
-	n.Name().Heapaddr = heapaddr
+	n.Heapaddr = heapaddr
 	n.SetEsc(EscHeap)
 	if base.Flag.LowerM != 0 {
 		base.WarnfAt(n.Pos(), "moved to heap: %v", n)
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index 8f50868fc7..2231f493dd 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -395,7 +395,7 @@ func (p *iexporter) stringOff(s string) uint64 {
 
 // pushDecl adds n to the declaration work queue, if not already present.
 func (p *iexporter) pushDecl(n ir.Node) {
-	if n.Sym() == nil || ir.AsNode(n.Sym().Def) != n && n.Op() != ir.OTYPE {
+	if n.Sym() == nil || n.Sym().Def != n && n.Op() != ir.OTYPE {
 		base.Fatalf("weird Sym: %v, %v", n, n.Sym())
 	}
 
@@ -988,7 +988,7 @@ func (w *exportWriter) funcExt(n *ir.Name) {
 
 func (w *exportWriter) methExt(m *types.Field) {
 	w.bool(m.Nointerface())
-	w.funcExt(ir.AsNode(m.Nname).(*ir.Name))
+	w.funcExt(m.Nname.(*ir.Name))
 }
 
 func (w *exportWriter) linkname(s *types.Sym) {
diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index b5fd2e7c75..e67a032c5d 100644
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -60,7 +60,7 @@ func fninit(n []ir.Node) {
 		initializers := lookup("init")
 		fn := dclfunc(initializers, ir.NewFuncType(base.Pos, nil, nil, nil))
 		for _, dcl := range initTodo.Dcl {
-			dcl.Name().Curfn = fn
+			dcl.Curfn = fn
 		}
 		fn.Dcl = append(fn.Dcl, initTodo.Dcl...)
 		initTodo.Dcl = nil
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 718239484b..96031fe511 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -984,7 +984,7 @@ func clearImports() {
 }
 
 func IsAlias(sym *types.Sym) bool {
-	return sym.Def != nil && ir.AsNode(sym.Def).Sym() != sym
+	return sym.Def != nil && sym.Def.Sym() != sym
 }
 
 // recordFlags records the specified command-line flags to be placed
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 1340068c72..de7dcda15e 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -1071,7 +1071,7 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) ir.Node {
 				if ln.Class() != ir.PPARAMOUT {
 					break
 				}
-				if ir.AsNode(ln.Sym().Def) != ln {
+				if ln.Sym().Def != ln {
 					base.Errorf("%s is shadowed during return", ln.Sym().Name)
 				}
 			}
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index f65131417a..21a50257b8 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -220,10 +220,10 @@ func addptabs() {
 		}
 		if n.Type().Kind() == types.TFUNC && n.Class() == ir.PFUNC {
 			// function
-			ptabs = append(ptabs, ptabEntry{s: s, t: ir.AsNode(s.Def).Type()})
+			ptabs = append(ptabs, ptabEntry{s: s, t: s.Def.Type()})
 		} else {
 			// variable
-			ptabs = append(ptabs, ptabEntry{s: s, t: types.NewPtr(ir.AsNode(s.Def).Type())})
+			ptabs = append(ptabs, ptabEntry{s: s, t: types.NewPtr(s.Def.Type())})
 		}
 	}
 }
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index ea294ed66d..1da0929290 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -77,8 +77,8 @@ func cmpstackvarlt(a, b *ir.Name) bool {
 		return a.Offset() < b.Offset()
 	}
 
-	if a.Name().Used() != b.Name().Used() {
-		return a.Name().Used()
+	if a.Used() != b.Used() {
+		return a.Used()
 	}
 
 	ap := a.Type().HasPointers()
@@ -87,8 +87,8 @@ func cmpstackvarlt(a, b *ir.Name) bool {
 		return ap
 	}
 
-	ap = a.Name().Needzero()
-	bp = b.Name().Needzero()
+	ap = a.Needzero()
+	bp = b.Needzero()
 	if ap != bp {
 		return ap
 	}
@@ -115,7 +115,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 	// Mark the PAUTO's unused.
 	for _, ln := range fn.Dcl {
 		if ln.Class() == ir.PAUTO {
-			ln.Name().SetUsed(false)
+			ln.SetUsed(false)
 		}
 	}
 
@@ -158,7 +158,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 		if n.Op() != ir.ONAME || n.Class() != ir.PAUTO {
 			continue
 		}
-		if !n.Name().Used() {
+		if !n.Used() {
 			fn.Dcl = fn.Dcl[:i]
 			break
 		}
@@ -260,7 +260,7 @@ func compile(fn *ir.Func) {
 	for _, n := range fn.Dcl {
 		switch n.Class() {
 		case ir.PPARAM, ir.PPARAMOUT, ir.PAUTO:
-			if livenessShouldTrack(n) && n.Name().Addrtaken() {
+			if livenessShouldTrack(n) && n.Addrtaken() {
 				dtypesym(n.Type())
 				// Also make sure we allocate a linker symbol
 				// for the stack object data, for the same reason.
@@ -447,7 +447,7 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 			}
 			switch n.Class() {
 			case ir.PAUTO:
-				if !n.Name().Used() {
+				if !n.Used() {
 					// Text == nil -> generating abstract function
 					if fnsym.Func().Text != nil {
 						base.Fatalf("debuginfo unused node (AllocFrame should truncate fn.Func.Dcl)")
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 4ab3005ce8..06b91ddae6 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -1001,7 +1001,7 @@ func typename(t *types.Type) ir.Node {
 	}
 
 	n := ir.Nod(ir.OADDR, ir.AsNode(s.Def), nil)
-	n.SetType(types.NewPtr(ir.AsNode(s.Def).Type()))
+	n.SetType(types.NewPtr(s.Def.Type()))
 	n.SetTypecheck(1)
 	return n
 }
@@ -1021,7 +1021,7 @@ func itabname(t, itype *types.Type) ir.Node {
 	}
 
 	n := ir.Nod(ir.OADDR, ir.AsNode(s.Def), nil)
-	n.SetType(types.NewPtr(ir.AsNode(s.Def).Type()))
+	n.SetType(types.NewPtr(s.Def.Type()))
 	n.SetTypecheck(1)
 	return n
 }
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 3e020d7b92..60e65e4b11 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -6196,7 +6196,7 @@ func (s byXoffset) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 func emitStackObjects(e *ssafn, pp *Progs) {
 	var vars []ir.Node
 	for _, n := range e.curfn.Dcl {
-		if livenessShouldTrack(n) && n.Name().Addrtaken() {
+		if livenessShouldTrack(n) && n.Addrtaken() {
 			vars = append(vars, n)
 		}
 	}
@@ -6583,7 +6583,7 @@ func defframe(s *SSAGenState, e *ssafn) {
 
 	// Iterate through declarations. They are sorted in decreasing Xoffset order.
 	for _, n := range e.curfn.Dcl {
-		if !n.Name().Needzero() {
+		if !n.Needzero() {
 			continue
 		}
 		if n.Class() != ir.PAUTO {
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index f120b44413..20ef3fc70a 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -2493,7 +2493,7 @@ func lookdot(n ir.Node, t *types.Type, dostrcmp int) *types.Field {
 			pll = ll
 			ll = ll.Left()
 		}
-		if pll.Implicit() && ll.Type().IsPtr() && ll.Type().Sym() != nil && ir.AsNode(ll.Type().Sym().Def) != nil && ir.AsNode(ll.Type().Sym().Def).Op() == ir.OTYPE {
+		if pll.Implicit() && ll.Type().IsPtr() && ll.Type().Sym() != nil && ll.Type().Sym().Def != nil && ir.AsNode(ll.Type().Sym().Def).Op() == ir.OTYPE {
 			// It is invalid to automatically dereference a named pointer type when selecting a method.
 			// Make n.Left == ll to clarify error message.
 			n.SetLeft(ll)
@@ -3369,7 +3369,7 @@ func typecheckfunc(n *ir.Func) {
 
 	for _, ln := range n.Dcl {
 		if ln.Op() == ir.ONAME && (ln.Class() == ir.PPARAM || ln.Class() == ir.PPARAMOUT) {
-			ln.Name().Decldepth = 1
+			ln.Decldepth = 1
 		}
 	}
 
@@ -3923,7 +3923,7 @@ func curpkg() *types.Pkg {
 // referenced by expression n, which must be a method selector,
 // method expression, or method value.
 func methodExprName(n ir.Node) *ir.Name {
-	name, _ := ir.AsNode(methodExprFunc(n).Nname).(*ir.Name)
+	name, _ := methodExprFunc(n).Nname.(*ir.Name)
 	return name
 }
 
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index 49e50734c6..b554674fbc 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -358,5 +358,5 @@ func finishUniverse() {
 	nodfp = NewName(lookup(".fp"))
 	nodfp.SetType(types.Types[types.TINT32])
 	nodfp.SetClass(ir.PPARAM)
-	nodfp.Name().SetUsed(true)
+	nodfp.SetUsed(true)
 }
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index b3af353c3f..be6f1539b9 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -43,16 +43,16 @@ func walk(fn *ir.Func) {
 
 	// Propagate the used flag for typeswitch variables up to the NONAME in its definition.
 	for _, ln := range fn.Dcl {
-		if ln.Op() == ir.ONAME && (ln.Class() == ir.PAUTO || ln.Class() == ir.PAUTOHEAP) && ln.Name().Defn != nil && ln.Name().Defn.Op() == ir.OTYPESW && ln.Name().Used() {
-			ln.Name().Defn.Left().Name().SetUsed(true)
+		if ln.Op() == ir.ONAME && (ln.Class() == ir.PAUTO || ln.Class() == ir.PAUTOHEAP) && ln.Defn != nil && ln.Defn.Op() == ir.OTYPESW && ln.Used() {
+			ln.Defn.Left().Name().SetUsed(true)
 		}
 	}
 
 	for _, ln := range fn.Dcl {
-		if ln.Op() != ir.ONAME || (ln.Class() != ir.PAUTO && ln.Class() != ir.PAUTOHEAP) || ln.Sym().Name[0] == '&' || ln.Name().Used() {
+		if ln.Op() != ir.ONAME || (ln.Class() != ir.PAUTO && ln.Class() != ir.PAUTOHEAP) || ln.Sym().Name[0] == '&' || ln.Used() {
 			continue
 		}
-		if defn := ln.Name().Defn; defn != nil && defn.Op() == ir.OTYPESW {
+		if defn := ln.Defn; defn != nil && defn.Op() == ir.OTYPESW {
 			if defn.Left().Name().Used() {
 				continue
 			}
@@ -91,7 +91,7 @@ func paramoutheap(fn *ir.Func) bool {
 	for _, ln := range fn.Dcl {
 		switch ln.Class() {
 		case ir.PPARAMOUT:
-			if isParamStackCopy(ln) || ln.Name().Addrtaken() {
+			if isParamStackCopy(ln) || ln.Addrtaken() {
 				return true
 			}
 
-- 
GitLab


From 036245862aa9db844ee8a6d12809f7d444d33042 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 1 Dec 2020 16:07:00 -0800
Subject: [PATCH 0122/2400] [dev.typeparams] cmd/compile/internal/types2: set
 compiler error message for undeclared variable

Change-Id: Ie2950cdc5406915935f114bfd97ef03d965f9069
Reviewed-on: https://go-review.googlesource.com/c/go/+/274616
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/types2/typexpr.go | 6 +++++-
 test/typeparam/tparam1.go                  | 4 ++--
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 0c27e5e04b..2d568b7e87 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -32,7 +32,11 @@ func (check *Checker) ident(x *operand, e *syntax.Name, def *Named, wantType boo
 		if e.Value == "_" {
 			check.errorf(e, "cannot use _ as value or type")
 		} else {
-			check.errorf(e, "undeclared name: %s", e.Value)
+			if check.conf.CompilerErrorMessages {
+				check.errorf(e, "undefined: %s", e.Value)
+			} else {
+				check.errorf(e, "undeclared name: %s", e.Value)
+			}
 		}
 		return
 	}
diff --git a/test/typeparam/tparam1.go b/test/typeparam/tparam1.go
index 5d6dcb6a62..7043933326 100644
--- a/test/typeparam/tparam1.go
+++ b/test/typeparam/tparam1.go
@@ -10,8 +10,8 @@ package tparam1
 
 // The predeclared identifier "any" is only visible as a constraint
 // in a type parameter list.
-var _ any // ERROR "undeclared"
-func _(_ any) // ERROR "undeclared"
+var _ any // ERROR "undefined"
+func _(_ any) // ERROR "undefined"
 type _[_ any /* ok here */ ] struct{}
 
 const N = 10
-- 
GitLab


From ab1812556777ffe61e554efb01c080cff90a6308 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 1 Dec 2020 16:02:37 -0800
Subject: [PATCH 0123/2400] [dev.typeparams] cmd/compile/internal/types2: no
 "declared but not used" errors for invalid var decls

Matches compiler behavior.

Change-Id: I87ca46fb7269fbac61ffbf8ed48902156b06f6e4
Reviewed-on: https://go-review.googlesource.com/c/go/+/274615
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/assignments.go     |  1 +
 src/cmd/compile/internal/types2/decl.go            | 14 ++++++++++++++
 .../compile/internal/types2/testdata/vardecl.src   | 13 ++++++++++++-
 3 files changed, 27 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/assignments.go b/src/cmd/compile/internal/types2/assignments.go
index 3178c38ade..b367aa76da 100644
--- a/src/cmd/compile/internal/types2/assignments.go
+++ b/src/cmd/compile/internal/types2/assignments.go
@@ -112,6 +112,7 @@ func (check *Checker) initVar(lhs *Var, x *operand, context string) Type {
 		if lhs.typ == nil {
 			lhs.typ = Typ[Invalid]
 		}
+		lhs.used = true // avoid follow-on "declared but not used" errors
 		return nil
 	}
 
diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index c7bfd3fd7b..bb33e38051 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -457,6 +457,20 @@ func (check *Checker) constDecl(obj *Const, typ, init syntax.Expr) {
 func (check *Checker) varDecl(obj *Var, lhs []*Var, typ, init syntax.Expr) {
 	assert(obj.typ == nil)
 
+	// If we have undefined variable types due to errors,
+	// mark variables as used to avoid follow-on errors.
+	// Matches compiler behavior.
+	defer func() {
+		if obj.typ == Typ[Invalid] {
+			obj.used = true
+		}
+		for _, lhs := range lhs {
+			if lhs.typ == Typ[Invalid] {
+				lhs.used = true
+			}
+		}
+	}()
+
 	// determine type, if any
 	if typ != nil {
 		obj.typ = check.varType(typ)
diff --git a/src/cmd/compile/internal/types2/testdata/vardecl.src b/src/cmd/compile/internal/types2/testdata/vardecl.src
index d8980f2ede..9e48cdf847 100644
--- a/src/cmd/compile/internal/types2/testdata/vardecl.src
+++ b/src/cmd/compile/internal/types2/testdata/vardecl.src
@@ -155,7 +155,18 @@ func _() {
 	}
 }
 
-// Invalid (unused) expressions must not lead to spurious "declared but not used errors"
+// Invalid variable declarations must not lead to "declared but not used errors".
+func _() {
+	var a x                        // ERROR undeclared name: x
+	var b = x                      // ERROR undeclared name: x
+	var c int = x                  // ERROR undeclared name: x
+	var d, e, f x                  /* ERROR x */ /* ERROR x */ /* ERROR x */
+	var g, h, i = x, x, x          /* ERROR x */ /* ERROR x */ /* ERROR x */
+	var j, k, l float32 = x, x, x  /* ERROR x */ /* ERROR x */ /* ERROR x */
+	// but no "declared but not used" errors
+}
+
+// Invalid (unused) expressions must not lead to spurious "declared but not used errors".
 func _() {
 	var a, b, c int
 	var x, y int
-- 
GitLab


From 15085f89746762e0919fa257feac3eb5b996e6db Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 1 Dec 2020 13:38:26 -0800
Subject: [PATCH 0124/2400] [dev.regabi] cmd/compile: tweak hash bucket type
 descriptor

There's no need for the bucket type to be precise. The compiler
doesn't actually generate code that references these fields; it just
needs it for size and GC bitmap calculations.

However, changing the type field does alter the runtime type
descriptor and relocations emitted by the compiler, so this change
isn't safe for toolstash.

Change-Id: Icf79d6c4326515889b13435a575d618e3bbfbcd7
Reviewed-on: https://go-review.googlesource.com/c/go/+/274712
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/gc/reflect.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 06b91ddae6..0b860b5f7a 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -85,7 +85,6 @@ func bmap(t *types.Type) *types.Type {
 		return t.MapType().Bucket
 	}
 
-	bucket := types.New(types.TSTRUCT)
 	keytype := t.Key()
 	elemtype := t.Elem()
 	dowidth(keytype)
@@ -119,7 +118,7 @@ func bmap(t *types.Type) *types.Type {
 	// Arrange for the bucket to have no pointers by changing
 	// the type of the overflow field to uintptr in this case.
 	// See comment on hmap.overflow in runtime/map.go.
-	otyp := types.NewPtr(bucket)
+	otyp := types.Types[types.TUNSAFEPTR]
 	if !elemtype.HasPointers() && !keytype.HasPointers() {
 		otyp = types.Types[types.TUINTPTR]
 	}
@@ -127,6 +126,7 @@ func bmap(t *types.Type) *types.Type {
 	field = append(field, overflow)
 
 	// link up fields
+	bucket := types.New(types.TSTRUCT)
 	bucket.SetNoalg(true)
 	bucket.SetFields(field[:])
 	dowidth(bucket)
-- 
GitLab


From 77a71e0057357b0567cc5036f7e0f903d82705bb Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 1 Dec 2020 13:07:35 -0800
Subject: [PATCH 0125/2400] [dev.regabi] cmd/compile: add Interface, Signature,
 and Struct constructors

This CL adds the remaining constructors needed to abstract away
construction of Types, and updates the compiler to use them
throughout. There's now just a couple uses within test cases to
remove.

While at it, I also replace the Func.Outnamed field with a simple
helper function, which reduces the size of function types somewhat.

Passes toolstash/buildall.

Change-Id: If1aa1095c98ae34b00380d0b3531bd63c10ce885
Reviewed-on: https://go-review.googlesource.com/c/go/+/274713
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/gc/dcl.go            | 182 ++++++------------
 src/cmd/compile/internal/gc/iimport.go        |   8 +-
 src/cmd/compile/internal/gc/pgen_test.go      |  15 +-
 src/cmd/compile/internal/gc/reflect.go        |  12 +-
 src/cmd/compile/internal/gc/typecheck.go      |   2 +-
 src/cmd/compile/internal/gc/universe.go       |  10 +-
 src/cmd/compile/internal/gc/walk.go           |   2 +-
 src/cmd/compile/internal/types/sizeof_test.go |   2 +-
 src/cmd/compile/internal/types/type.go        |  59 +++++-
 9 files changed, 137 insertions(+), 155 deletions(-)

diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index dd59d829fe..e0c87d4517 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -369,7 +369,7 @@ func funchdr(fn *ir.Func) {
 
 	types.Markdcl()
 
-	if fn.Nname != nil && fn.Nname.Ntype != nil {
+	if fn.Nname.Ntype != nil {
 		funcargs(fn.Nname.Ntype.(*ir.FuncType))
 	} else {
 		funcargs2(fn.Type())
@@ -510,27 +510,6 @@ func checkembeddedtype(t *types.Type) {
 	}
 }
 
-func structfield(n *ir.Field) *types.Field {
-	lno := base.Pos
-	base.Pos = n.Pos
-
-	if n.Ntype != nil {
-		n.Ntype = typecheckNtype(n.Ntype)
-		n.Type = n.Ntype.Type()
-		n.Ntype = nil
-	}
-
-	f := types.NewField(n.Pos, n.Sym, n.Type)
-	if n.Embedded {
-		checkembeddedtype(n.Type)
-		f.Embedded = 1
-	}
-	f.Note = n.Note
-
-	base.Pos = lno
-	return f
-}
-
 // checkdupfields emits errors for duplicately named fields or methods in
 // a list of struct or interface types.
 func checkdupfields(what string, fss ...[]*types.Field) {
@@ -552,95 +531,49 @@ func checkdupfields(what string, fss ...[]*types.Field) {
 // convert a parsed id/type list into
 // a type for struct/interface/arglist
 func tostruct(l []*ir.Field) *types.Type {
-	t := types.New(types.TSTRUCT)
+	lno := base.Pos
 
 	fields := make([]*types.Field, len(l))
 	for i, n := range l {
-		f := structfield(n)
-		if f.Broke() {
-			t.SetBroke(true)
-		}
-		fields[i] = f
-	}
-	t.SetFields(fields)
-
-	checkdupfields("field", t.FieldSlice())
-
-	if !t.Broke() {
-		checkwidth(t)
-	}
+		base.Pos = n.Pos
 
-	return t
-}
-
-func tofunargs(l []*ir.Field, funarg types.Funarg) *types.Type {
-	t := types.New(types.TSTRUCT)
-	t.StructType().Funarg = funarg
-
-	fields := make([]*types.Field, len(l))
-	for i, n := range l {
-		f := structfield(n)
-		f.SetIsDDD(n.IsDDD)
-		if n.Decl != nil {
-			n.Decl.SetType(f.Type)
-			f.Nname = n.Decl
+		if n.Ntype != nil {
+			n.Type = typecheckNtype(n.Ntype).Type()
+			n.Ntype = nil
 		}
-		if f.Broke() {
-			t.SetBroke(true)
+		f := types.NewField(n.Pos, n.Sym, n.Type)
+		if n.Embedded {
+			checkembeddedtype(n.Type)
+			f.Embedded = 1
 		}
+		f.Note = n.Note
 		fields[i] = f
 	}
-	t.SetFields(fields)
-	return t
-}
+	checkdupfields("field", fields)
 
-func tofunargsfield(fields []*types.Field, funarg types.Funarg) *types.Type {
-	t := types.New(types.TSTRUCT)
-	t.StructType().Funarg = funarg
-	t.SetFields(fields)
-	return t
+	base.Pos = lno
+	return types.NewStruct(fields)
 }
 
-func interfacefield(n *ir.Field) *types.Field {
-	lno := base.Pos
-	base.Pos = n.Pos
-
-	if n.Note != "" {
-		base.Errorf("interface method cannot have annotation")
+func tointerface(nmethods []*ir.Field) *types.Type {
+	if len(nmethods) == 0 {
+		return types.Types[types.TINTER]
 	}
 
-	// MethodSpec = MethodName Signature | InterfaceTypeName .
-	//
-	// If Sym != nil, then Sym is MethodName and Left is Signature.
-	// Otherwise, Left is InterfaceTypeName.
+	lno := base.Pos
 
-	if n.Ntype != nil {
-		n.Ntype = typecheckNtype(n.Ntype)
-		n.Type = n.Ntype.Type()
-		n.Ntype = nil
+	methods := make([]*types.Field, len(nmethods))
+	for i, n := range nmethods {
+		base.Pos = n.Pos
+		if n.Ntype != nil {
+			n.Type = typecheckNtype(n.Ntype).Type()
+			n.Ntype = nil
+		}
+		methods[i] = types.NewField(n.Pos, n.Sym, n.Type)
 	}
 
-	f := types.NewField(n.Pos, n.Sym, n.Type)
-
 	base.Pos = lno
-	return f
-}
-
-func tointerface(l []*ir.Field) *types.Type {
-	if len(l) == 0 {
-		return types.Types[types.TINTER]
-	}
-	t := types.New(types.TINTER)
-	var fields []*types.Field
-	for _, n := range l {
-		f := interfacefield(n)
-		if f.Broke() {
-			t.SetBroke(true)
-		}
-		fields = append(fields, f)
-	}
-	t.SetInterface(fields)
-	return t
+	return types.NewInterface(methods)
 }
 
 func fakeRecv() *ir.Field {
@@ -659,42 +592,47 @@ func isifacemethod(f *types.Type) bool {
 }
 
 // turn a parsed function declaration into a type
-func functype(this *ir.Field, in, out []*ir.Field) *types.Type {
-	t := types.New(types.TFUNC)
-
-	var rcvr []*ir.Field
-	if this != nil {
-		rcvr = []*ir.Field{this}
-	}
-	t.FuncType().Receiver = tofunargs(rcvr, types.FunargRcvr)
-	t.FuncType().Params = tofunargs(in, types.FunargParams)
-	t.FuncType().Results = tofunargs(out, types.FunargResults)
+func functype(nrecv *ir.Field, nparams, nresults []*ir.Field) *types.Type {
+	funarg := func(n *ir.Field) *types.Field {
+		lno := base.Pos
+		base.Pos = n.Pos
+
+		if n.Ntype != nil {
+			n.Type = typecheckNtype(n.Ntype).Type()
+			n.Ntype = nil
+		}
 
-	checkdupfields("argument", t.Recvs().FieldSlice(), t.Params().FieldSlice(), t.Results().FieldSlice())
+		f := types.NewField(n.Pos, n.Sym, n.Type)
+		f.SetIsDDD(n.IsDDD)
+		if n.Decl != nil {
+			n.Decl.SetType(f.Type)
+			f.Nname = n.Decl
+		}
 
-	if t.Recvs().Broke() || t.Results().Broke() || t.Params().Broke() {
-		t.SetBroke(true)
+		base.Pos = lno
+		return f
+	}
+	funargs := func(nn []*ir.Field) []*types.Field {
+		res := make([]*types.Field, len(nn))
+		for i, n := range nn {
+			res[i] = funarg(n)
+		}
+		return res
 	}
 
-	t.FuncType().Outnamed = t.NumResults() > 0 && ir.OrigSym(t.Results().Field(0).Sym) != nil
+	var recv *types.Field
+	if nrecv != nil {
+		recv = funarg(nrecv)
+	}
 
+	t := types.NewSignature(recv, funargs(nparams), funargs(nresults))
+	checkdupfields("argument", t.Recvs().FieldSlice(), t.Params().FieldSlice(), t.Results().FieldSlice())
 	return t
 }
 
-func functypefield(this *types.Field, in, out []*types.Field) *types.Type {
-	t := types.New(types.TFUNC)
-
-	var rcvr []*types.Field
-	if this != nil {
-		rcvr = []*types.Field{this}
-	}
-	t.FuncType().Receiver = tofunargsfield(rcvr, types.FunargRcvr)
-	t.FuncType().Params = tofunargsfield(in, types.FunargParams)
-	t.FuncType().Results = tofunargsfield(out, types.FunargResults)
-
-	t.FuncType().Outnamed = t.NumResults() > 0 && ir.OrigSym(t.Results().Field(0).Sym) != nil
-
-	return t
+func hasNamedResults(fn *ir.Func) bool {
+	typ := fn.Type()
+	return typ.NumResults() > 0 && ir.OrigSym(typ.Results().Field(0).Sym) != nil
 }
 
 // methodSym returns the method symbol representing a method name
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 15f1b646f7..1bb9841564 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -545,9 +545,8 @@ func (r *importReader) typ1() *types.Type {
 			fs[i] = f
 		}
 
-		t := types.New(types.TSTRUCT)
+		t := types.NewStruct(fs)
 		t.SetPkg(r.currPkg)
-		t.SetFields(fs)
 		return t
 
 	case interfaceType:
@@ -570,9 +569,8 @@ func (r *importReader) typ1() *types.Type {
 			methods[i] = types.NewField(pos, sym, typ)
 		}
 
-		t := types.New(types.TINTER)
+		t := types.NewInterface(append(embeddeds, methods...))
 		t.SetPkg(r.currPkg)
-		t.SetInterface(append(embeddeds, methods...))
 
 		// Ensure we expand the interface in the frontend (#25055).
 		checkwidth(t)
@@ -590,7 +588,7 @@ func (r *importReader) signature(recv *types.Field) *types.Type {
 	if n := len(params); n > 0 {
 		params[n-1].SetIsDDD(r.bool())
 	}
-	t := functypefield(recv, params, results)
+	t := types.NewSignature(recv, params, results)
 	t.SetPkg(r.currPkg)
 	return t
 }
diff --git a/src/cmd/compile/internal/gc/pgen_test.go b/src/cmd/compile/internal/gc/pgen_test.go
index 35ce087af6..710bc32534 100644
--- a/src/cmd/compile/internal/gc/pgen_test.go
+++ b/src/cmd/compile/internal/gc/pgen_test.go
@@ -7,23 +7,22 @@ package gc
 import (
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
+	"cmd/internal/src"
 	"reflect"
 	"sort"
 	"testing"
 )
 
 func typeWithoutPointers() *types.Type {
-	t := types.New(types.TSTRUCT)
-	f := &types.Field{Type: types.New(types.TINT)}
-	t.SetFields([]*types.Field{f})
-	return t
+	return types.NewStruct([]*types.Field{
+		types.NewField(src.NoXPos, nil, types.New(types.TINT)),
+	})
 }
 
 func typeWithPointers() *types.Type {
-	t := types.New(types.TSTRUCT)
-	f := &types.Field{Type: types.NewPtr(types.New(types.TINT))}
-	t.SetFields([]*types.Field{f})
-	return t
+	return types.NewStruct([]*types.Field{
+		types.NewField(src.NoXPos, nil, types.NewPtr(types.New(types.TINT))),
+	})
 }
 
 func markUsed(n *ir.Name) *ir.Name {
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 0b860b5f7a..b249310df0 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -126,9 +126,8 @@ func bmap(t *types.Type) *types.Type {
 	field = append(field, overflow)
 
 	// link up fields
-	bucket := types.New(types.TSTRUCT)
+	bucket := types.NewStruct(field[:])
 	bucket.SetNoalg(true)
-	bucket.SetFields(field[:])
 	dowidth(bucket)
 
 	// Check invariants that map code depends on.
@@ -221,9 +220,8 @@ func hmap(t *types.Type) *types.Type {
 		makefield("extra", types.Types[types.TUNSAFEPTR]),
 	}
 
-	hmap := types.New(types.TSTRUCT)
+	hmap := types.NewStruct(fields)
 	hmap.SetNoalg(true)
-	hmap.SetFields(fields)
 	dowidth(hmap)
 
 	// The size of hmap should be 48 bytes on 64 bit
@@ -285,9 +283,8 @@ func hiter(t *types.Type) *types.Type {
 	}
 
 	// build iterator struct holding the above fields
-	hiter := types.New(types.TSTRUCT)
+	hiter := types.NewStruct(fields)
 	hiter.SetNoalg(true)
-	hiter.SetFields(fields)
 	dowidth(hiter)
 	if hiter.Width != int64(12*Widthptr) {
 		base.Fatalf("hash_iter size not correct %d %d", hiter.Width, 12*Widthptr)
@@ -332,9 +329,8 @@ func deferstruct(stksize int64) *types.Type {
 	}
 
 	// build struct holding the above fields
-	s := types.New(types.TSTRUCT)
+	s := types.NewStruct(fields)
 	s.SetNoalg(true)
-	s.SetFields(fields)
 	s.Width = widstruct(s, s, 0, 1)
 	s.Align = uint8(Widthptr)
 	return s
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 20ef3fc70a..2a0caad469 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -2021,7 +2021,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			return n
 		}
 
-		if Curfn.Type().FuncType().Outnamed && n.List().Len() == 0 {
+		if hasNamedResults(Curfn) && n.List().Len() == 0 {
 			break
 		}
 		typecheckaste(ir.ORETURN, nil, false, Curfn.Type().Results(), n.List(), func() string { return "return argument" })
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index b554674fbc..1c744dc367 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -104,7 +104,7 @@ func initUniverse() {
 	}
 
 	types.Types[types.TANY] = types.New(types.TANY)
-	types.Types[types.TINTER] = types.New(types.TINTER) // empty interface
+	types.Types[types.TINTER] = types.NewInterface(nil)
 
 	defBasic := func(kind types.Kind, pkg *types.Pkg, name string) *types.Type {
 		sym := pkg.Lookup(name)
@@ -325,15 +325,11 @@ func initUniverse() {
 }
 
 func makeErrorInterface() *types.Type {
-	sig := functypefield(fakeRecvField(), nil, []*types.Field{
+	sig := types.NewSignature(fakeRecvField(), nil, []*types.Field{
 		types.NewField(src.NoXPos, nil, types.Types[types.TSTRING]),
 	})
-
 	method := types.NewField(src.NoXPos, lookup("Error"), sig)
-
-	t := types.New(types.TINTER)
-	t.SetInterface([]*types.Field{method})
-	return t
+	return types.NewInterface([]*types.Field{method})
 }
 
 // finishUniverse makes the universe block visible within the current package.
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index be6f1539b9..183a7acc1b 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -274,7 +274,7 @@ func walkstmt(n ir.Node) ir.Node {
 		if n.List().Len() == 0 {
 			break
 		}
-		if (Curfn.Type().FuncType().Outnamed && n.List().Len() > 1) || paramoutheap(Curfn) {
+		if (hasNamedResults(Curfn) && n.List().Len() > 1) || paramoutheap(Curfn) {
 			// assign to the function out parameters,
 			// so that reorder3 can fix up conflicts
 			var rl []ir.Node
diff --git a/src/cmd/compile/internal/types/sizeof_test.go b/src/cmd/compile/internal/types/sizeof_test.go
index 88a2fbba2f..72a35bc7da 100644
--- a/src/cmd/compile/internal/types/sizeof_test.go
+++ b/src/cmd/compile/internal/types/sizeof_test.go
@@ -24,7 +24,7 @@ func TestSizeof(t *testing.T) {
 		{Type{}, 56, 96},
 		{Map{}, 20, 40},
 		{Forward{}, 20, 32},
-		{Func{}, 28, 48},
+		{Func{}, 24, 40},
 		{Struct{}, 16, 32},
 		{Interface{}, 8, 16},
 		{Chan{}, 8, 16},
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 36aac53124..2eff8e3ba4 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -285,8 +285,6 @@ type Func struct {
 	// It gets calculated via a temporary TFUNCARGS type.
 	// Note that TFUNC's Width is Widthptr.
 	Argwid int64
-
-	Outnamed bool
 }
 
 // FuncType returns t's extra func-specific fields.
@@ -1618,3 +1616,60 @@ func NewBasic(kind Kind, obj Object) *Type {
 	t.nod = obj
 	return t
 }
+
+// NewInterface returns a new interface for the given methods and
+// embedded types. Embedded types are specified as fields with no Sym.
+func NewInterface(methods []*Field) *Type {
+	t := New(TINTER)
+	t.SetInterface(methods)
+	if anyBroke(methods) {
+		t.SetBroke(true)
+	}
+	return t
+}
+
+//  NewSignature returns a new function type for the given receiver,
+//  parameters, and results, any of which may be nil.
+func NewSignature(recv *Field, params, results []*Field) *Type {
+	var recvs []*Field
+	if recv != nil {
+		recvs = []*Field{recv}
+	}
+
+	t := New(TFUNC)
+	ft := t.FuncType()
+
+	funargs := func(fields []*Field, funarg Funarg) *Type {
+		s := NewStruct(fields)
+		s.StructType().Funarg = funarg
+		if s.Broke() {
+			t.SetBroke(true)
+		}
+		return s
+	}
+
+	ft.Receiver = funargs(recvs, FunargRcvr)
+	ft.Params = funargs(params, FunargParams)
+	ft.Results = funargs(results, FunargResults)
+
+	return t
+}
+
+// NewStruct returns a new struct with the given fields.
+func NewStruct(fields []*Field) *Type {
+	t := New(TSTRUCT)
+	t.SetFields(fields)
+	if anyBroke(fields) {
+		t.SetBroke(true)
+	}
+	return t
+}
+
+func anyBroke(fields []*Field) bool {
+	for _, f := range fields {
+		if f.Broke() {
+			return true
+		}
+	}
+	return false
+}
-- 
GitLab


From 42e46f4ae0c4f3d6bf7f3920fa936f056ea485c4 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 1 Dec 2020 22:11:56 -0800
Subject: [PATCH 0126/2400] [dev.regabi] cmd/compile: comment out //go:linkname
 warning

It's noisy and not doing any harm, and we still have an entire release
cycle to revisit and address the issue properly.

Updates #42938

Change-Id: I1de5cfb495a8148c9c08b215deba38f2617fb467
Reviewed-on: https://go-review.googlesource.com/c/go/+/274732
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/gc/noder.go | 2 +-
 test/linkname2.go                    | 7 +++++--
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index de7dcda15e..e5677f921f 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -275,7 +275,7 @@ func (p *noder) processPragmas() {
 		n := ir.AsNode(lookup(l.local).Def)
 		if n == nil || n.Op() != ir.ONAME {
 			// TODO(mdempsky): Change to p.errorAt before Go 1.17 release.
-			base.WarnfAt(p.makeXPos(l.pos), "//go:linkname must refer to declared function or variable (will be an error in Go 1.17)")
+			// base.WarnfAt(p.makeXPos(l.pos), "//go:linkname must refer to declared function or variable (will be an error in Go 1.17)")
 			continue
 		}
 		if n.Sym().Linkname != "" {
diff --git a/test/linkname2.go b/test/linkname2.go
index cb7f9be345..43e66a5849 100644
--- a/test/linkname2.go
+++ b/test/linkname2.go
@@ -16,10 +16,13 @@ var x, y int
 //go:linkname x ok
 
 // ERROR "//go:linkname requires linkname argument or -p compiler flag"
-// ERROR "//go:linkname must refer to declared function or variable"
-// ERROR "//go:linkname must refer to declared function or variable"
+// BAD: want error "//go:linkname must refer to declared function or variable"
+// BAD: want error "//go:linkname must refer to declared function or variable"
 // ERROR "duplicate //go:linkname for x"
 
+// The two BAD lines are just waiting for #42938 before we can
+// re-enable the errors.
+
 //line linkname2.go:18
 //go:linkname y
 //go:linkname nonexist nonexist
-- 
GitLab


From c10b0ad628b4c7dd0f327c583702364abebb5132 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 1 Dec 2020 23:05:53 -0800
Subject: [PATCH 0127/2400] [dev.regabi] cmd/compile: add Pkg parameter to type
 constructors

Allows getting rid of the SetPkg method and also addresses a
long-standing TODO in the exporter. Suggested by rsc@.

Passes buildall w/ toolstash -cmp.

Change-Id: Ib294f75f1350572efb2e0d993d49efef884de3d4
Reviewed-on: https://go-review.googlesource.com/c/go/+/274440
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/gc/closure.go   |  2 --
 src/cmd/compile/internal/gc/dcl.go       |  6 ++--
 src/cmd/compile/internal/gc/iexport.go   |  6 ++--
 src/cmd/compile/internal/gc/iimport.go   | 11 ++------
 src/cmd/compile/internal/gc/pgen_test.go |  4 +--
 src/cmd/compile/internal/gc/reflect.go   |  8 +++---
 src/cmd/compile/internal/gc/universe.go  |  6 ++--
 src/cmd/compile/internal/types/type.go   | 36 ++++++++++--------------
 8 files changed, 32 insertions(+), 47 deletions(-)

diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index e33a561bd4..a5441a037a 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -464,8 +464,6 @@ func makepartialcall(dot ir.Node, t0 *types.Type, meth *types.Sym) *ir.Func {
 	fn.SetDupok(true)
 	fn.SetNeedctxt(true)
 
-	tfn.Type().SetPkg(t0.Pkg())
-
 	// Declare and initialize variable holding receiver.
 	cr := ir.NewClosureRead(rcvrtype, Rnd(int64(Widthptr), int64(rcvrtype.Align)))
 	ptr := NewName(lookup(".this"))
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index e0c87d4517..87b389b98b 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -552,7 +552,7 @@ func tostruct(l []*ir.Field) *types.Type {
 	checkdupfields("field", fields)
 
 	base.Pos = lno
-	return types.NewStruct(fields)
+	return types.NewStruct(ir.LocalPkg, fields)
 }
 
 func tointerface(nmethods []*ir.Field) *types.Type {
@@ -573,7 +573,7 @@ func tointerface(nmethods []*ir.Field) *types.Type {
 	}
 
 	base.Pos = lno
-	return types.NewInterface(methods)
+	return types.NewInterface(ir.LocalPkg, methods)
 }
 
 func fakeRecv() *ir.Field {
@@ -625,7 +625,7 @@ func functype(nrecv *ir.Field, nparams, nresults []*ir.Field) *types.Type {
 		recv = funarg(nrecv)
 	}
 
-	t := types.NewSignature(recv, funargs(nparams), funargs(nresults))
+	t := types.NewSignature(ir.LocalPkg, recv, funargs(nparams), funargs(nresults))
 	checkdupfields("argument", t.Recvs().FieldSlice(), t.Params().FieldSlice(), t.Results().FieldSlice())
 	return t
 }
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index 2231f493dd..7b21efb8c2 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -718,10 +718,8 @@ func (w *exportWriter) doTyp(t *types.Type) {
 }
 
 func (w *exportWriter) setPkg(pkg *types.Pkg, write bool) {
-	if pkg == nil {
-		// TODO(mdempsky): Proactively set Pkg for types and
-		// remove this fallback logic.
-		pkg = ir.LocalPkg
+	if pkg == types.NoPkg {
+		base.Fatalf("missing pkg")
 	}
 
 	if write {
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 1bb9841564..b6653dabda 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -545,9 +545,7 @@ func (r *importReader) typ1() *types.Type {
 			fs[i] = f
 		}
 
-		t := types.NewStruct(fs)
-		t.SetPkg(r.currPkg)
-		return t
+		return types.NewStruct(r.currPkg, fs)
 
 	case interfaceType:
 		r.setPkg()
@@ -569,8 +567,7 @@ func (r *importReader) typ1() *types.Type {
 			methods[i] = types.NewField(pos, sym, typ)
 		}
 
-		t := types.NewInterface(append(embeddeds, methods...))
-		t.SetPkg(r.currPkg)
+		t := types.NewInterface(r.currPkg, append(embeddeds, methods...))
 
 		// Ensure we expand the interface in the frontend (#25055).
 		checkwidth(t)
@@ -588,9 +585,7 @@ func (r *importReader) signature(recv *types.Field) *types.Type {
 	if n := len(params); n > 0 {
 		params[n-1].SetIsDDD(r.bool())
 	}
-	t := types.NewSignature(recv, params, results)
-	t.SetPkg(r.currPkg)
-	return t
+	return types.NewSignature(r.currPkg, recv, params, results)
 }
 
 func (r *importReader) paramList() []*types.Field {
diff --git a/src/cmd/compile/internal/gc/pgen_test.go b/src/cmd/compile/internal/gc/pgen_test.go
index 710bc32534..473df82a0d 100644
--- a/src/cmd/compile/internal/gc/pgen_test.go
+++ b/src/cmd/compile/internal/gc/pgen_test.go
@@ -14,13 +14,13 @@ import (
 )
 
 func typeWithoutPointers() *types.Type {
-	return types.NewStruct([]*types.Field{
+	return types.NewStruct(types.NoPkg, []*types.Field{
 		types.NewField(src.NoXPos, nil, types.New(types.TINT)),
 	})
 }
 
 func typeWithPointers() *types.Type {
-	return types.NewStruct([]*types.Field{
+	return types.NewStruct(types.NoPkg, []*types.Field{
 		types.NewField(src.NoXPos, nil, types.NewPtr(types.New(types.TINT))),
 	})
 }
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index b249310df0..42139b7135 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -126,7 +126,7 @@ func bmap(t *types.Type) *types.Type {
 	field = append(field, overflow)
 
 	// link up fields
-	bucket := types.NewStruct(field[:])
+	bucket := types.NewStruct(types.NoPkg, field[:])
 	bucket.SetNoalg(true)
 	dowidth(bucket)
 
@@ -220,7 +220,7 @@ func hmap(t *types.Type) *types.Type {
 		makefield("extra", types.Types[types.TUNSAFEPTR]),
 	}
 
-	hmap := types.NewStruct(fields)
+	hmap := types.NewStruct(types.NoPkg, fields)
 	hmap.SetNoalg(true)
 	dowidth(hmap)
 
@@ -283,7 +283,7 @@ func hiter(t *types.Type) *types.Type {
 	}
 
 	// build iterator struct holding the above fields
-	hiter := types.NewStruct(fields)
+	hiter := types.NewStruct(types.NoPkg, fields)
 	hiter.SetNoalg(true)
 	dowidth(hiter)
 	if hiter.Width != int64(12*Widthptr) {
@@ -329,7 +329,7 @@ func deferstruct(stksize int64) *types.Type {
 	}
 
 	// build struct holding the above fields
-	s := types.NewStruct(fields)
+	s := types.NewStruct(types.NoPkg, fields)
 	s.SetNoalg(true)
 	s.Width = widstruct(s, s, 0, 1)
 	s.Align = uint8(Widthptr)
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index 1c744dc367..b315502964 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -104,7 +104,7 @@ func initUniverse() {
 	}
 
 	types.Types[types.TANY] = types.New(types.TANY)
-	types.Types[types.TINTER] = types.NewInterface(nil)
+	types.Types[types.TINTER] = types.NewInterface(ir.LocalPkg, nil)
 
 	defBasic := func(kind types.Kind, pkg *types.Pkg, name string) *types.Type {
 		sym := pkg.Lookup(name)
@@ -325,11 +325,11 @@ func initUniverse() {
 }
 
 func makeErrorInterface() *types.Type {
-	sig := types.NewSignature(fakeRecvField(), nil, []*types.Field{
+	sig := types.NewSignature(types.NoPkg, fakeRecvField(), nil, []*types.Field{
 		types.NewField(src.NoXPos, nil, types.Types[types.TSTRING]),
 	})
 	method := types.NewField(src.NoXPos, lookup("Error"), sig)
-	return types.NewInterface([]*types.Field{method})
+	return types.NewInterface(types.NoPkg, []*types.Field{method})
 }
 
 // finishUniverse makes the universe block visible within the current package.
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 2eff8e3ba4..2c42e5579d 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -211,6 +211,11 @@ func (t *Type) Pos() src.XPos {
 	return src.NoXPos
 }
 
+// NoPkg is a nil *Pkg value for clarity.
+// It's intended for use when constructing types that aren't exported
+// and thus don't need to be associated with any package.
+var NoPkg *Pkg = nil
+
 // Pkg returns the package that t appeared in.
 //
 // Pkg is only defined for function, struct, and interface types
@@ -231,20 +236,6 @@ func (t *Type) Pkg() *Pkg {
 	}
 }
 
-// SetPkg sets the package that t appeared in.
-func (t *Type) SetPkg(pkg *Pkg) {
-	switch t.kind {
-	case TFUNC:
-		t.Extra.(*Func).pkg = pkg
-	case TSTRUCT:
-		t.Extra.(*Struct).pkg = pkg
-	case TINTER:
-		t.Extra.(*Interface).pkg = pkg
-	default:
-		Fatalf("Pkg: unexpected kind: %v", t)
-	}
-}
-
 // Map contains Type fields specific to maps.
 type Map struct {
 	Key  *Type // Key type
@@ -1609,7 +1600,7 @@ func (t *Type) SetUnderlying(underlying *Type) {
 	}
 }
 
-// NewNamed returns a new basic type of the given kind.
+// NewBasic returns a new basic type of the given kind.
 func NewBasic(kind Kind, obj Object) *Type {
 	t := New(kind)
 	t.sym = obj.Sym()
@@ -1619,18 +1610,19 @@ func NewBasic(kind Kind, obj Object) *Type {
 
 // NewInterface returns a new interface for the given methods and
 // embedded types. Embedded types are specified as fields with no Sym.
-func NewInterface(methods []*Field) *Type {
+func NewInterface(pkg *Pkg, methods []*Field) *Type {
 	t := New(TINTER)
 	t.SetInterface(methods)
 	if anyBroke(methods) {
 		t.SetBroke(true)
 	}
+	t.Extra.(*Interface).pkg = pkg
 	return t
 }
 
-//  NewSignature returns a new function type for the given receiver,
-//  parameters, and results, any of which may be nil.
-func NewSignature(recv *Field, params, results []*Field) *Type {
+// NewSignature returns a new function type for the given receiver,
+// parameters, and results, any of which may be nil.
+func NewSignature(pkg *Pkg, recv *Field, params, results []*Field) *Type {
 	var recvs []*Field
 	if recv != nil {
 		recvs = []*Field{recv}
@@ -1640,7 +1632,7 @@ func NewSignature(recv *Field, params, results []*Field) *Type {
 	ft := t.FuncType()
 
 	funargs := func(fields []*Field, funarg Funarg) *Type {
-		s := NewStruct(fields)
+		s := NewStruct(NoPkg, fields)
 		s.StructType().Funarg = funarg
 		if s.Broke() {
 			t.SetBroke(true)
@@ -1651,17 +1643,19 @@ func NewSignature(recv *Field, params, results []*Field) *Type {
 	ft.Receiver = funargs(recvs, FunargRcvr)
 	ft.Params = funargs(params, FunargParams)
 	ft.Results = funargs(results, FunargResults)
+	ft.pkg = pkg
 
 	return t
 }
 
 // NewStruct returns a new struct with the given fields.
-func NewStruct(fields []*Field) *Type {
+func NewStruct(pkg *Pkg, fields []*Field) *Type {
 	t := New(TSTRUCT)
 	t.SetFields(fields)
 	if anyBroke(fields) {
 		t.SetBroke(true)
 	}
+	t.Extra.(*Struct).pkg = pkg
 	return t
 }
 
-- 
GitLab


From c769d393de3d735d32aa9c8917afcd0394e5ac57 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 1 Dec 2020 23:55:03 -0800
Subject: [PATCH 0128/2400] [dev.regabi] cmd/compile: add ir.NewDeclNameAt

This allows directly creating an ONONAME, which is a primordial Name
before having its Op initialized. Then after an Op is assigned, we
never allow it to be reassigned.

Passes buildall w/ toolstash -cmp.

Change-Id: Ibc2f413dc68c0af6a96abfe653c25ce31b184287
Reviewed-on: https://go-review.googlesource.com/c/go/+/274620
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/gc/dcl.go      | 30 +------------------------
 src/cmd/compile/internal/gc/export.go   |  2 +-
 src/cmd/compile/internal/gc/iimport.go  |  6 ++---
 src/cmd/compile/internal/gc/noder.go    |  4 +---
 src/cmd/compile/internal/gc/sinit.go    |  3 ++-
 src/cmd/compile/internal/gc/universe.go |  4 ++--
 src/cmd/compile/internal/ir/name.go     | 22 +++++++++++++-----
 src/cmd/compile/internal/ir/node.go     |  4 +---
 8 files changed, 28 insertions(+), 47 deletions(-)

diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 87b389b98b..ce13f0bdfc 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -122,16 +122,6 @@ func declare(n *ir.Name, ctxt ir.Class) {
 	autoexport(n, ctxt)
 }
 
-func addvar(n *ir.Name, t *types.Type, ctxt ir.Class) {
-	if n == nil || n.Sym() == nil || (n.Op() != ir.ONAME && n.Op() != ir.ONONAME) || t == nil {
-		base.Fatalf("addvar: n=%v t=%v nil", n, t)
-	}
-
-	n.SetOp(ir.ONAME)
-	declare(n, ctxt)
-	n.SetType(t)
-}
-
 // declare variables from grammar
 // new_name_list (type | [type] = expr_list)
 func variter(vl []ir.Node, t ir.Ntype, el []ir.Node) []ir.Node {
@@ -192,16 +182,6 @@ func variter(vl []ir.Node, t ir.Ntype, el []ir.Node) []ir.Node {
 	return init
 }
 
-// newnoname returns a new ONONAME Node associated with symbol s.
-func newnoname(s *types.Sym) ir.Node {
-	if s == nil {
-		base.Fatalf("newnoname nil")
-	}
-	n := ir.NewNameAt(base.Pos, s)
-	n.SetOp(ir.ONONAME)
-	return n
-}
-
 // newFuncNameAt generates a new name node for a function or method.
 func newFuncNameAt(pos src.XPos, s *types.Sym, fn *ir.Func) *ir.Name {
 	if fn.Nname != nil {
@@ -213,14 +193,6 @@ func newFuncNameAt(pos src.XPos, s *types.Sym, fn *ir.Func) *ir.Name {
 	return n
 }
 
-// this generates a new name node for a name
-// being declared.
-func dclname(s *types.Sym) *ir.Name {
-	n := NewName(s)
-	n.SetOp(ir.ONONAME) // caller will correct it
-	return n
-}
-
 func anonfield(typ *types.Type) *ir.Field {
 	return symfield(nil, typ)
 }
@@ -243,7 +215,7 @@ func oldname(s *types.Sym) ir.Node {
 		// Maybe a top-level declaration will come along later to
 		// define s. resolve will check s.Def again once all input
 		// source has been processed.
-		return newnoname(s)
+		return ir.NewDeclNameAt(base.Pos, s)
 	}
 
 	if Curfn != nil && n.Op() == ir.ONAME && n.Name().Curfn != nil && n.Name().Curfn != Curfn {
diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index f803a17c60..44fc70be03 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -85,7 +85,7 @@ func importsym(ipkg *types.Pkg, s *types.Sym, op ir.Op) ir.Node {
 			base.Fatalf("missing ONONAME for %v\n", s)
 		}
 
-		n = dclname(s)
+		n = ir.NewDeclNameAt(src.NoXPos, s)
 		s.SetPkgDef(n)
 		s.Importdef = ipkg
 	}
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index b6653dabda..419db285b5 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -175,7 +175,7 @@ func iimport(pkg *types.Pkg, in *bio.Reader) (fingerprint goobj.FingerprintType)
 			if s.Def != nil {
 				base.Fatalf("unexpected definition for %v: %v", s, ir.AsNode(s.Def))
 			}
-			s.Def = npos(src.NoXPos, dclname(s))
+			s.Def = ir.NewDeclNameAt(src.NoXPos, s)
 		}
 	}
 
@@ -833,7 +833,7 @@ func (r *importReader) node() ir.Node {
 	case ir.OTYPESW:
 		n := ir.NodAt(r.pos(), ir.OTYPESW, nil, nil)
 		if s := r.ident(); s != nil {
-			n.SetLeft(npos(n.Pos(), newnoname(s)))
+			n.SetLeft(ir.NewDeclNameAt(n.Pos(), s))
 		}
 		right, _ := r.exprsOrNil()
 		n.SetRight(right)
@@ -962,7 +962,7 @@ func (r *importReader) node() ir.Node {
 	// statements
 	case ir.ODCL:
 		pos := r.pos()
-		lhs := npos(pos, dclname(r.ident()))
+		lhs := ir.NewDeclNameAt(pos, r.ident())
 		typ := ir.TypeNode(r.typ())
 		return npos(pos, liststmt(variter([]ir.Node{lhs}, typ, nil))) // TODO(gri) avoid list creation
 
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index e5677f921f..4c81657628 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -516,9 +516,7 @@ func (p *noder) declNames(names []*syntax.Name) []ir.Node {
 }
 
 func (p *noder) declName(name *syntax.Name) *ir.Name {
-	n := dclname(p.name(name))
-	n.SetPos(p.pos(name))
-	return n
+	return ir.NewDeclNameAt(p.pos(name), p.name(name))
 }
 
 func (p *noder) funcDecl(fun *syntax.FuncDecl) ir.Node {
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 8146f30377..2dc4281857 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -371,7 +371,8 @@ func staticname(t *types.Type) ir.Node {
 	// Don't use lookupN; it interns the resulting string, but these are all unique.
 	n := NewName(lookup(fmt.Sprintf("%s%d", obj.StaticNamePref, statuniqgen)))
 	statuniqgen++
-	addvar(n, t, ir.PEXTERN)
+	declare(n, ir.PEXTERN)
+	n.SetType(t)
 	n.Sym().Linksym().Set(obj.AttrLocal, true)
 	return n
 }
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index b315502964..f9984cbe94 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -108,7 +108,7 @@ func initUniverse() {
 
 	defBasic := func(kind types.Kind, pkg *types.Pkg, name string) *types.Type {
 		sym := pkg.Lookup(name)
-		n := ir.NewNameAt(src.NoXPos, sym)
+		n := ir.NewDeclNameAt(src.NoXPos, sym)
 		n.SetOp(ir.OTYPE)
 		t := types.NewBasic(kind, n)
 		n.SetType(t)
@@ -145,7 +145,7 @@ func initUniverse() {
 
 	// error type
 	s := ir.BuiltinPkg.Lookup("error")
-	n := ir.NewNameAt(src.NoXPos, s)
+	n := ir.NewDeclNameAt(src.NoXPos, s)
 	n.SetOp(ir.OTYPE)
 	types.ErrorType = types.NewNamed(n)
 	types.ErrorType.SetUnderlying(makeErrorInterface())
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 76abb454ee..3c62800ad3 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -123,18 +123,27 @@ type Name struct {
 }
 
 // NewNameAt returns a new ONAME Node associated with symbol s at position pos.
-// The caller is responsible for setting n.Name.Curfn.
+// The caller is responsible for setting Curfn.
 func NewNameAt(pos src.XPos, sym *types.Sym) *Name {
 	if sym == nil {
 		base.Fatalf("NewNameAt nil")
 	}
-	return newNameAt(pos, sym)
+	return newNameAt(pos, ONAME, sym)
+}
+
+// NewDeclNameAt returns a new ONONAME Node associated with symbol s at position pos.
+// The caller is responsible for setting Curfn.
+func NewDeclNameAt(pos src.XPos, sym *types.Sym) *Name {
+	if sym == nil {
+		base.Fatalf("NewDeclNameAt nil")
+	}
+	return newNameAt(pos, ONONAME, sym)
 }
 
 // newNameAt is like NewNameAt but allows sym == nil.
-func newNameAt(pos src.XPos, sym *types.Sym) *Name {
+func newNameAt(pos src.XPos, op Op, sym *types.Sym) *Name {
 	n := new(Name)
-	n.op = ONAME
+	n.op = op
 	n.pos = pos
 	n.orig = n
 	n.sym = sym
@@ -163,10 +172,13 @@ func (n *Name) SetIota(x int64)               { n.offset = x }
 func (*Name) CanBeNtype() {}
 
 func (n *Name) SetOp(op Op) {
+	if n.op != ONONAME {
+		base.Fatalf("%v already has Op %v", n, n.op)
+	}
 	switch op {
 	default:
 		panic(n.no("SetOp " + op.String()))
-	case OLITERAL, ONONAME, ONAME, OTYPE, OIOTA:
+	case OLITERAL, ONAME, OTYPE, OIOTA:
 		n.op = op
 	}
 }
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index fc4c593929..d121cc19d4 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -802,9 +802,7 @@ func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
 	case OLABEL:
 		return NewLabelStmt(pos, nil)
 	case OLITERAL, OTYPE, OIOTA:
-		n := newNameAt(pos, nil)
-		n.SetOp(op)
-		return n
+		return newNameAt(pos, op, nil)
 	case OMAKECHAN, OMAKEMAP, OMAKESLICE, OMAKESLICECOPY:
 		return NewMakeExpr(pos, op, nleft, nright)
 	case OMETHEXPR:
-- 
GitLab


From ec5f349b2291fa3c0a30d8859c84f7476a1d14a2 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 30 Nov 2020 21:56:24 -0500
Subject: [PATCH 0129/2400] [dev.regabi] cmd/compile: merge OBLOCK and OEMPTY

OEMPTY is an empty *statement*, but it confusingly
gets handled as an expression in a few places.
More confusingly, OEMPTY often has an init list,
making it not empty at all. Replace uses and analysis
of OEMPTY with OBLOCK instead.

Passes buildall w/ toolstash -cmp.

Change-Id: I8d4fcef151e4f441fa19b1b96da5272d778131d6
Reviewed-on: https://go-review.googlesource.com/c/go/+/274594
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/escape.go    |  2 +-
 src/cmd/compile/internal/gc/iexport.go   | 14 +++++++++++---
 src/cmd/compile/internal/gc/iimport.go   |  4 +++-
 src/cmd/compile/internal/gc/init.go      |  6 ++++--
 src/cmd/compile/internal/gc/inl.go       |  7 ++++++-
 src/cmd/compile/internal/gc/noder.go     | 12 +++++++-----
 src/cmd/compile/internal/gc/order.go     |  2 +-
 src/cmd/compile/internal/gc/ssa.go       |  2 +-
 src/cmd/compile/internal/gc/typecheck.go |  9 ++++++---
 src/cmd/compile/internal/gc/walk.go      | 13 ++++++-------
 src/cmd/compile/internal/ir/fmt.go       | 10 ++++++----
 src/cmd/compile/internal/ir/node.go      |  4 +---
 src/cmd/compile/internal/ir/stmt.go      | 16 ----------------
 13 files changed, 53 insertions(+), 48 deletions(-)

diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index c139771730..9fc3dd2778 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -302,7 +302,7 @@ func (e *Escape) stmt(n ir.Node) {
 	default:
 		base.Fatalf("unexpected stmt: %v", n)
 
-	case ir.ODCLCONST, ir.ODCLTYPE, ir.OEMPTY, ir.OFALL, ir.OINLMARK:
+	case ir.ODCLCONST, ir.ODCLTYPE, ir.OFALL, ir.OINLMARK:
 		// nop
 
 	case ir.OBREAK, ir.OCONTINUE, ir.OGOTO:
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index 7b21efb8c2..85518bc939 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -1048,6 +1048,17 @@ func (w *exportWriter) stmt(n ir.Node) {
 	}
 
 	switch op := n.Op(); op {
+	case ir.OBLOCK:
+		// No OBLOCK in export data.
+		// Inline content into this statement list,
+		// like the init list above.
+		// (At the moment neither the parser nor the typechecker
+		// generate OBLOCK nodes except to denote an empty
+		// function body, although that may change.)
+		for _, n := range n.List().Slice() {
+			w.stmt(n)
+		}
+
 	case ir.ODCL:
 		w.op(ir.ODCL)
 		w.pos(n.Left().Pos())
@@ -1129,9 +1140,6 @@ func (w *exportWriter) stmt(n ir.Node) {
 		w.op(ir.OFALL)
 		w.pos(n.Pos())
 
-	case ir.OEMPTY:
-		// nothing to emit
-
 	case ir.OBREAK, ir.OCONTINUE, ir.OGOTO, ir.OLABEL:
 		w.op(op)
 		w.pos(n.Pos())
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 419db285b5..1d9baed5ad 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -742,7 +742,9 @@ func (r *importReader) stmtList() []ir.Node {
 		if n == nil {
 			break
 		}
-		// OBLOCK nodes may be created when importing ODCL nodes - unpack them
+		// OBLOCK nodes are not written to the import data directly,
+		// but the handling of ODCL calls liststmt, which creates one.
+		// Inline them into the statement list.
 		if n.Op() == ir.OBLOCK {
 			list = append(list, n.List().Slice()...)
 		} else {
diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index e67a032c5d..dc825b2421 100644
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -88,8 +88,10 @@ func fninit(n []ir.Node) {
 		s := lookupN("init.", i)
 		fn := ir.AsNode(s.Def).Name().Defn
 		// Skip init functions with empty bodies.
-		if fn.Body().Len() == 1 && fn.Body().First().Op() == ir.OEMPTY {
-			continue
+		if fn.Body().Len() == 1 {
+			if stmt := fn.Body().First(); stmt.Op() == ir.OBLOCK && stmt.List().Len() == 0 {
+				continue
+			}
 		}
 		fns = append(fns, s.Linksym())
 	}
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index b36a01e389..89c9873c1d 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -396,7 +396,7 @@ func (v *hairyVisitor) visit(n ir.Node) bool {
 	case ir.OAPPEND:
 		v.budget -= inlineExtraAppendCost
 
-	case ir.ODCLCONST, ir.OEMPTY, ir.OFALL:
+	case ir.ODCLCONST, ir.OFALL:
 		// These nodes don't produce code; omit from inlining budget.
 		return false
 
@@ -425,6 +425,11 @@ func (v *hairyVisitor) visit(n ir.Node) bool {
 			v.usedLocals[n] = true
 		}
 
+	case ir.OBLOCK:
+		// The only OBLOCK we should see at this point is an empty one.
+		// In any event, let the visitList(n.List()) below take care of the statements,
+		// and don't charge for the OBLOCK itself. The ++ undoes the -- below.
+		v.budget++
 	}
 
 	v.budget--
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 4c81657628..9352463f18 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -164,7 +164,7 @@ func (p *noder) funcBody(fn *ir.Func, block *syntax.BlockStmt) {
 	if block != nil {
 		body := p.stmts(block.List)
 		if body == nil {
-			body = []ir.Node{ir.Nod(ir.OEMPTY, nil, nil)}
+			body = []ir.Node{ir.Nod(ir.OBLOCK, nil, nil)}
 		}
 		fn.PtrBody().Set(body)
 
@@ -967,7 +967,9 @@ func (p *noder) stmtsFall(stmts []syntax.Stmt, fallOK bool) []ir.Node {
 	for i, stmt := range stmts {
 		s := p.stmtFall(stmt, fallOK && i+1 == len(stmts))
 		if s == nil {
-		} else if s.Op() == ir.OBLOCK && s.Init().Len() == 0 {
+		} else if s.Op() == ir.OBLOCK && s.List().Len() > 0 {
+			// Inline non-empty block.
+			// Empty blocks must be preserved for checkreturn.
 			nodes = append(nodes, s.List().Slice()...)
 		} else {
 			nodes = append(nodes, s)
@@ -991,7 +993,7 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) ir.Node {
 		l := p.blockStmt(stmt)
 		if len(l) == 0 {
 			// TODO(mdempsky): Line number?
-			return ir.Nod(ir.OEMPTY, nil, nil)
+			return ir.Nod(ir.OBLOCK, nil, nil)
 		}
 		return liststmt(l)
 	case *syntax.ExprStmt:
@@ -1166,7 +1168,7 @@ func (p *noder) ifStmt(stmt *syntax.IfStmt) ir.Node {
 	n.PtrBody().Set(p.blockStmt(stmt.Then))
 	if stmt.Else != nil {
 		e := p.stmt(stmt.Else)
-		if e.Op() == ir.OBLOCK && e.Init().Len() == 0 {
+		if e.Op() == ir.OBLOCK {
 			n.PtrRlist().Set(e.List().Slice())
 		} else {
 			n.PtrRlist().Set1(e)
@@ -1319,7 +1321,7 @@ func (p *noder) labeledStmt(label *syntax.LabeledStmt, fallOK bool) ir.Node {
 
 	l := []ir.Node{lhs}
 	if ls != nil {
-		if ls.Op() == ir.OBLOCK && ls.Init().Len() == 0 {
+		if ls.Op() == ir.OBLOCK {
 			l = append(l, ls.List().Slice()...)
 		} else {
 			l = append(l, ls)
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index c2e236537f..352e9c473b 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -676,7 +676,7 @@ func (o *Order) stmt(n ir.Node) {
 		o.cleanTemp(t)
 
 	// Special: does not save n onto out.
-	case ir.OBLOCK, ir.OEMPTY:
+	case ir.OBLOCK:
 		o.stmtList(n.List())
 
 	// Special: n->left is not an expression; save as is.
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 60e65e4b11..7c74054b60 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -1071,7 +1071,7 @@ func (s *state) stmt(n ir.Node) {
 		s.stmtList(n.List())
 
 	// No-ops
-	case ir.OEMPTY, ir.ODCLCONST, ir.ODCLTYPE, ir.OFALL:
+	case ir.ODCLCONST, ir.ODCLTYPE, ir.OFALL:
 
 	// Expression statements
 	case ir.OCALLFUNC:
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 2a0caad469..5a073ac324 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -1950,13 +1950,16 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 	case ir.OBREAK,
 		ir.OCONTINUE,
 		ir.ODCL,
-		ir.OEMPTY,
 		ir.OGOTO,
 		ir.OFALL,
 		ir.OVARKILL,
 		ir.OVARLIVE:
 		ok |= ctxStmt
 
+	case ir.OBLOCK:
+		ok |= ctxStmt
+		typecheckslice(n.List().Slice(), ctxStmt)
+
 	case ir.OLABEL:
 		ok |= ctxStmt
 		decldepth++
@@ -1964,7 +1967,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			// Empty identifier is valid but useless.
 			// Eliminate now to simplify life later.
 			// See issues 7538, 11589, 11593.
-			n = ir.NodAt(n.Pos(), ir.OEMPTY, nil, nil)
+			n = ir.NodAt(n.Pos(), ir.OBLOCK, nil, nil)
 		}
 
 	case ir.ODEFER:
@@ -3808,7 +3811,7 @@ func deadcode(fn *ir.Func) {
 		}
 	}
 
-	fn.PtrBody().Set([]ir.Node{ir.Nod(ir.OEMPTY, nil, nil)})
+	fn.PtrBody().Set([]ir.Node{ir.Nod(ir.OBLOCK, nil, nil)})
 }
 
 func deadcodeslice(nn *ir.Nodes) {
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 183a7acc1b..7e8ae22e4e 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -142,7 +142,6 @@ func walkstmt(n ir.Node) ir.Node {
 		ir.OPRINT,
 		ir.OPRINTN,
 		ir.OPANIC,
-		ir.OEMPTY,
 		ir.ORECOVER,
 		ir.OGETG:
 		if n.Typecheck() == 0 {
@@ -155,7 +154,7 @@ func walkstmt(n ir.Node) ir.Node {
 		if wascopy && n.Op() == ir.ONAME {
 			// copy rewrote to a statement list and a temp for the length.
 			// Throw away the temp to avoid plain values as statements.
-			n = ir.NodAt(n.Pos(), ir.OEMPTY, nil, nil)
+			n = ir.NodAt(n.Pos(), ir.OBLOCK, nil, nil)
 		}
 		n = addinit(n, init.Slice())
 
@@ -470,7 +469,7 @@ opswitch:
 		ir.Dump("walk", n)
 		base.Fatalf("walkexpr: switch 1 unknown op %+S", n)
 
-	case ir.ONONAME, ir.OEMPTY, ir.OGETG, ir.ONEWOBJ, ir.OMETHEXPR:
+	case ir.ONONAME, ir.OGETG, ir.ONEWOBJ, ir.OMETHEXPR:
 
 	case ir.OTYPE, ir.ONAME, ir.OLITERAL, ir.ONIL:
 		// TODO(mdempsky): Just return n; see discussion on CL 38655.
@@ -609,7 +608,7 @@ opswitch:
 		}
 
 		if oaslit(n, init) {
-			n = ir.NodAt(n.Pos(), ir.OEMPTY, nil, nil)
+			n = ir.NodAt(n.Pos(), ir.OBLOCK, nil, nil)
 			break
 		}
 
@@ -2032,10 +2031,10 @@ func walkprint(nn ir.Node, init *ir.Nodes) ir.Node {
 	typecheckslice(calls, ctxStmt)
 	walkexprlist(calls, init)
 
-	r := ir.Nod(ir.OEMPTY, nil, nil)
+	r := ir.Nod(ir.OBLOCK, nil, nil)
 	r = typecheck(r, ctxStmt)
-	r = walkexpr(r, init)
-	r.PtrInit().Set(calls)
+	r = walkstmt(r)
+	r.PtrList().Set(calls)
 	return r
 }
 
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 5bb1ed857c..9486d8b021 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -942,6 +942,11 @@ func stmtFmt(n Node, s fmt.State, mode FmtMode) {
 			mode.Fprintf(s, "%.v = %.v", n.List(), n.Rlist())
 		}
 
+	case OBLOCK:
+		if n.List().Len() != 0 {
+			mode.Fprintf(s, "%v", n.List())
+		}
+
 	case ORETURN:
 		mode.Fprintf(s, "return %.v", n.List())
 
@@ -1044,9 +1049,6 @@ func stmtFmt(n Node, s fmt.State, mode FmtMode) {
 			mode.Fprintf(s, "%#v", n.Op())
 		}
 
-	case OEMPTY:
-		break
-
 	case OLABEL:
 		mode.Fprintf(s, "%v: ", n.Sym())
 	}
@@ -1155,12 +1157,12 @@ var OpPrec = []int{
 	OAS2MAPR:    -1,
 	OAS2RECV:    -1,
 	OASOP:       -1,
+	OBLOCK:      -1,
 	OBREAK:      -1,
 	OCASE:       -1,
 	OCONTINUE:   -1,
 	ODCL:        -1,
 	ODEFER:      -1,
-	OEMPTY:      -1,
 	OFALL:       -1,
 	OFOR:        -1,
 	OFORUNTIL:   -1,
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index d121cc19d4..06bc48e9ca 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -301,7 +301,7 @@ const (
 	OCASE
 	OCONTINUE // continue [Sym]
 	ODEFER    // defer Left (Left must be call)
-	OEMPTY    // no-op (empty statement)
+	OEMPTY    // TODO(rsc): Delete. (Use OBLOCK instead.)
 	OFALL     // fallthrough
 	OFOR      // for Ninit; Left; Right { Nbody }
 	// OFORUNTIL is like OFOR, but the test (Left) is applied after the body:
@@ -781,8 +781,6 @@ func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
 		n := NewTypeAssertExpr(pos, nleft, typ)
 		n.SetOp(op)
 		return n
-	case OEMPTY:
-		return NewEmptyStmt(pos)
 	case OFOR:
 		return NewForStmt(pos, nil, nleft, nright, nil)
 	case OGO:
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index 91714e38e3..a6bbab4889 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -266,22 +266,6 @@ func (n *DeferStmt) rawCopy() Node                 { c := *n; return &c }
 func (n *DeferStmt) Left() Node     { return n.Call }
 func (n *DeferStmt) SetLeft(x Node) { n.Call = x }
 
-// An EmptyStmt is an empty statement
-type EmptyStmt struct {
-	miniStmt
-}
-
-func NewEmptyStmt(pos src.XPos) *EmptyStmt {
-	n := &EmptyStmt{}
-	n.pos = pos
-	n.op = OEMPTY
-	return n
-}
-
-func (n *EmptyStmt) String() string                { return fmt.Sprint(n) }
-func (n *EmptyStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *EmptyStmt) rawCopy() Node                 { c := *n; return &c }
-
 // A ForStmt is a non-range for loop: for Init; Cond; Post { Body }
 // Op can be OFOR or OFORUNTIL (!Cond).
 type ForStmt struct {
-- 
GitLab


From ecc8d15bc5f48916176c4bba809b327a72b66e2c Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 30 Nov 2020 21:59:44 -0500
Subject: [PATCH 0130/2400] [dev.regabi] cmd/compile: delete OEMPTY

Not toolstash -cmp safe, so split into its own CL.

Change-Id: I523227514a95e19c9afe17556d754a03164bce76
Reviewed-on: https://go-review.googlesource.com/c/go/+/274595
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/node.go      |  1 -
 src/cmd/compile/internal/ir/op_string.go | 75 ++++++++++++------------
 2 files changed, 37 insertions(+), 39 deletions(-)

diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 06bc48e9ca..cc3ac5765d 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -301,7 +301,6 @@ const (
 	OCASE
 	OCONTINUE // continue [Sym]
 	ODEFER    // defer Left (Left must be call)
-	OEMPTY    // TODO(rsc): Delete. (Use OBLOCK instead.)
 	OFALL     // fallthrough
 	OFOR      // for Ninit; Left; Right { Nbody }
 	// OFORUNTIL is like OFOR, but the test (Left) is applied after the body:
diff --git a/src/cmd/compile/internal/ir/op_string.go b/src/cmd/compile/internal/ir/op_string.go
index 96eee43974..bb5e16fbbc 100644
--- a/src/cmd/compile/internal/ir/op_string.go
+++ b/src/cmd/compile/internal/ir/op_string.go
@@ -127,47 +127,46 @@ func _() {
 	_ = x[OCASE-116]
 	_ = x[OCONTINUE-117]
 	_ = x[ODEFER-118]
-	_ = x[OEMPTY-119]
-	_ = x[OFALL-120]
-	_ = x[OFOR-121]
-	_ = x[OFORUNTIL-122]
-	_ = x[OGOTO-123]
-	_ = x[OIF-124]
-	_ = x[OLABEL-125]
-	_ = x[OGO-126]
-	_ = x[ORANGE-127]
-	_ = x[ORETURN-128]
-	_ = x[OSELECT-129]
-	_ = x[OSWITCH-130]
-	_ = x[OTYPESW-131]
-	_ = x[OTCHAN-132]
-	_ = x[OTMAP-133]
-	_ = x[OTSTRUCT-134]
-	_ = x[OTINTER-135]
-	_ = x[OTFUNC-136]
-	_ = x[OTARRAY-137]
-	_ = x[OTSLICE-138]
-	_ = x[OINLCALL-139]
-	_ = x[OEFACE-140]
-	_ = x[OITAB-141]
-	_ = x[OIDATA-142]
-	_ = x[OSPTR-143]
-	_ = x[OCLOSUREREAD-144]
-	_ = x[OCFUNC-145]
-	_ = x[OCHECKNIL-146]
-	_ = x[OVARDEF-147]
-	_ = x[OVARKILL-148]
-	_ = x[OVARLIVE-149]
-	_ = x[ORESULT-150]
-	_ = x[OINLMARK-151]
-	_ = x[ORETJMP-152]
-	_ = x[OGETG-153]
-	_ = x[OEND-154]
+	_ = x[OFALL-119]
+	_ = x[OFOR-120]
+	_ = x[OFORUNTIL-121]
+	_ = x[OGOTO-122]
+	_ = x[OIF-123]
+	_ = x[OLABEL-124]
+	_ = x[OGO-125]
+	_ = x[ORANGE-126]
+	_ = x[ORETURN-127]
+	_ = x[OSELECT-128]
+	_ = x[OSWITCH-129]
+	_ = x[OTYPESW-130]
+	_ = x[OTCHAN-131]
+	_ = x[OTMAP-132]
+	_ = x[OTSTRUCT-133]
+	_ = x[OTINTER-134]
+	_ = x[OTFUNC-135]
+	_ = x[OTARRAY-136]
+	_ = x[OTSLICE-137]
+	_ = x[OINLCALL-138]
+	_ = x[OEFACE-139]
+	_ = x[OITAB-140]
+	_ = x[OIDATA-141]
+	_ = x[OSPTR-142]
+	_ = x[OCLOSUREREAD-143]
+	_ = x[OCFUNC-144]
+	_ = x[OCHECKNIL-145]
+	_ = x[OVARDEF-146]
+	_ = x[OVARKILL-147]
+	_ = x[OVARLIVE-148]
+	_ = x[ORESULT-149]
+	_ = x[OINLMARK-150]
+	_ = x[ORETJMP-151]
+	_ = x[OGETG-152]
+	_ = x[OEND-153]
 }
 
-const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNEWOBJNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECVSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFEREMPTYFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCLOSUREREADCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKRETJMPGETGEND"
+const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNEWOBJNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECVSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCLOSUREREADCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKRETJMPGETGEND"
 
-var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 388, 391, 400, 403, 407, 415, 422, 431, 444, 447, 450, 453, 456, 459, 462, 468, 471, 477, 480, 486, 490, 493, 497, 502, 507, 513, 518, 522, 527, 535, 543, 549, 558, 569, 576, 580, 587, 594, 602, 606, 610, 614, 621, 628, 636, 642, 650, 658, 663, 668, 672, 680, 685, 690, 694, 697, 705, 709, 711, 716, 718, 723, 729, 735, 741, 747, 752, 756, 763, 769, 774, 780, 786, 793, 798, 802, 807, 811, 822, 827, 835, 841, 848, 855, 861, 868, 874, 878, 881}
+var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 388, 391, 400, 403, 407, 415, 422, 431, 444, 447, 450, 453, 456, 459, 462, 468, 471, 477, 480, 486, 490, 493, 497, 502, 507, 513, 518, 522, 527, 535, 543, 549, 558, 569, 576, 580, 587, 594, 602, 606, 610, 614, 621, 628, 636, 642, 650, 658, 663, 668, 672, 680, 685, 689, 692, 700, 704, 706, 711, 713, 718, 724, 730, 736, 742, 747, 751, 758, 764, 769, 775, 781, 788, 793, 797, 802, 806, 817, 822, 830, 836, 843, 850, 856, 863, 869, 873, 876}
 
 func (i Op) String() string {
 	if i >= Op(len(_Op_index)-1) {
-- 
GitLab


From 72cc2353f0522ec7e2ccfc8d4320e3ca932041cf Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 25 Nov 2020 11:17:38 -0500
Subject: [PATCH 0131/2400] [dev.typeparams] go/printer: adapt changes from
 dev.go2go

Import go/printer changes from the dev.go2go branch, with the following
modifications:
 - update tests to only use bracketed notation for type parameters
 - remove the UseBrackets mode, since it is now implied
 - remove guards on ast.Field.Type != nil

Patchset #1 contains the dev.go2go source, unmodified except to resolve
merge conflicts.

Change-Id: I3ddecfd3bee0fc32425a30fe6bd93b24fd3187e9
Reviewed-on: https://go-review.googlesource.com/c/go/+/273226
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Trust: Robert Findley <rfindley@google.com>
---
 src/go/printer/nodes.go                     | 143 +++++++++++++-------
 src/go/printer/printer_test.go              |   5 +-
 src/go/printer/testdata/declarations.golden |  11 ++
 src/go/printer/testdata/declarations.input  |  11 +-
 src/go/printer/testdata/generics.golden     |  33 +++++
 src/go/printer/testdata/generics.input      |  30 ++++
 6 files changed, 183 insertions(+), 50 deletions(-)
 create mode 100644 src/go/printer/testdata/generics.golden
 create mode 100644 src/go/printer/testdata/generics.input

diff --git a/src/go/printer/nodes.go b/src/go/printer/nodes.go
index 95b9e91891..cc795532b0 100644
--- a/src/go/printer/nodes.go
+++ b/src/go/printer/nodes.go
@@ -319,8 +319,12 @@ func (p *printer) exprList(prev0 token.Pos, list []ast.Expr, depth int, mode exp
 	}
 }
 
-func (p *printer) parameters(fields *ast.FieldList) {
-	p.print(fields.Opening, token.LPAREN)
+func (p *printer) parameters(fields *ast.FieldList, isTypeParam bool) {
+	openTok, closeTok := token.LPAREN, token.RPAREN
+	if isTypeParam {
+		openTok, closeTok = token.LBRACK, token.RBRACK
+	}
+	p.print(fields.Opening, openTok)
 	if len(fields.List) > 0 {
 		prevLine := p.lineFor(fields.Opening)
 		ws := indent
@@ -328,13 +332,8 @@ func (p *printer) parameters(fields *ast.FieldList) {
 			// determine par begin and end line (may be different
 			// if there are multiple parameter names for this par
 			// or the type is on a separate line)
-			var parLineBeg int
-			if len(par.Names) > 0 {
-				parLineBeg = p.lineFor(par.Names[0].Pos())
-			} else {
-				parLineBeg = p.lineFor(par.Type.Pos())
-			}
-			var parLineEnd = p.lineFor(par.Type.End())
+			parLineBeg := p.lineFor(par.Pos())
+			parLineEnd := p.lineFor(par.End())
 			// separating "," if needed
 			needsLinebreak := 0 < prevLine && prevLine < parLineBeg
 			if i > 0 {
@@ -379,25 +378,29 @@ func (p *printer) parameters(fields *ast.FieldList) {
 			p.print(unindent)
 		}
 	}
-	p.print(fields.Closing, token.RPAREN)
+	p.print(fields.Closing, closeTok)
 }
 
-func (p *printer) signature(params, result *ast.FieldList) {
-	if params != nil {
-		p.parameters(params)
+func (p *printer) signature(sig *ast.FuncType) {
+	if sig.TParams != nil {
+		p.parameters(sig.TParams, true)
+	}
+	if sig.Params != nil {
+		p.parameters(sig.Params, false)
 	} else {
 		p.print(token.LPAREN, token.RPAREN)
 	}
-	n := result.NumFields()
+	res := sig.Results
+	n := res.NumFields()
 	if n > 0 {
-		// result != nil
+		// res != nil
 		p.print(blank)
-		if n == 1 && result.List[0].Names == nil {
-			// single anonymous result; no ()'s
-			p.expr(stripParensAlways(result.List[0].Type))
+		if n == 1 && res.List[0].Names == nil {
+			// single anonymous res; no ()'s
+			p.expr(stripParensAlways(res.List[0].Type))
 			return
 		}
-		p.parameters(result)
+		p.parameters(res, false)
 	}
 }
 
@@ -467,10 +470,18 @@ func (p *printer) fieldList(fields *ast.FieldList, isStruct, isIncomplete bool)
 				}
 				p.expr(f.Type)
 			} else { // interface
-				if ftyp, isFtyp := f.Type.(*ast.FuncType); isFtyp {
-					// method
-					p.expr(f.Names[0])
-					p.signature(ftyp.Params, ftyp.Results)
+				if len(f.Names) > 0 {
+					// type list type or method
+					name := f.Names[0] // "type" or method name
+					p.expr(name)
+					if name.Name == "type" {
+						// type list type
+						p.print(blank)
+						p.expr(f.Type)
+					} else {
+						// method
+						p.signature(f.Type.(*ast.FuncType)) // don't print "func"
+					}
 				} else {
 					// embedded interface
 					p.expr(f.Type)
@@ -538,19 +549,47 @@ func (p *printer) fieldList(fields *ast.FieldList, isStruct, isIncomplete bool)
 	} else { // interface
 
 		var line int
+		var prev *ast.Ident // previous "type" identifier
 		for i, f := range list {
+			var name *ast.Ident // first name, or nil
+			if len(f.Names) > 0 {
+				name = f.Names[0]
+			}
 			if i > 0 {
-				p.linebreak(p.lineFor(f.Pos()), 1, ignore, p.linesFrom(line) > 0)
+				// don't do a line break (min == 0) if we are printing a list of types
+				// TODO(gri) this doesn't work quite right if the list of types is
+				//           spread across multiple lines
+				min := 1
+				if prev != nil && name == prev {
+					min = 0
+				}
+				p.linebreak(p.lineFor(f.Pos()), min, ignore, p.linesFrom(line) > 0)
 			}
 			p.setComment(f.Doc)
 			p.recordLine(&line)
-			if ftyp, isFtyp := f.Type.(*ast.FuncType); isFtyp {
-				// method
-				p.expr(f.Names[0])
-				p.signature(ftyp.Params, ftyp.Results)
+			if name != nil {
+				// type list type or method
+				if name.Name == "type" {
+					// type list type
+					if name == prev {
+						// type is part of a list of types
+						p.print(token.COMMA, blank)
+					} else {
+						// type starts a new list of types
+						p.print(name, blank)
+					}
+					p.expr(f.Type)
+					prev = name
+				} else {
+					// method
+					p.expr(name)
+					p.signature(f.Type.(*ast.FuncType)) // don't print "func"
+					prev = nil
+				}
 			} else {
 				// embedded interface
 				p.expr(f.Type)
+				prev = nil
 			}
 			p.setComment(f.Comment)
 		}
@@ -800,7 +839,7 @@ func (p *printer) expr1(expr ast.Expr, prec1, depth int) {
 		p.print(x.Type.Pos(), token.FUNC)
 		// See the comment in funcDecl about how the header size is computed.
 		startCol := p.out.Column - len("func")
-		p.signature(x.Type.Params, x.Type.Results)
+		p.signature(x.Type)
 		p.funcBody(p.distanceFrom(x.Type.Pos(), startCol), blank, x.Body)
 
 	case *ast.ParenExpr:
@@ -880,25 +919,32 @@ func (p *printer) expr1(expr ast.Expr, prec1, depth int) {
 			depth++
 		}
 		var wasIndented bool
-		if _, ok := x.Fun.(*ast.FuncType); ok {
-			// conversions to literal function types require parentheses around the type
-			p.print(token.LPAREN)
+		if x.Brackets {
 			wasIndented = p.possibleSelectorExpr(x.Fun, token.HighestPrec, depth)
-			p.print(token.RPAREN)
+			p.print(x.Lparen, token.LBRACK)
+			p.exprList(x.Lparen, x.Args, depth, commaTerm, x.Rparen, false)
+			p.print(x.Rparen, token.RBRACK)
 		} else {
-			wasIndented = p.possibleSelectorExpr(x.Fun, token.HighestPrec, depth)
-		}
-		p.print(x.Lparen, token.LPAREN)
-		if x.Ellipsis.IsValid() {
-			p.exprList(x.Lparen, x.Args, depth, 0, x.Ellipsis, false)
-			p.print(x.Ellipsis, token.ELLIPSIS)
-			if x.Rparen.IsValid() && p.lineFor(x.Ellipsis) < p.lineFor(x.Rparen) {
-				p.print(token.COMMA, formfeed)
+			if _, ok := x.Fun.(*ast.FuncType); ok {
+				// conversions to literal function types require parentheses around the type
+				p.print(token.LPAREN)
+				wasIndented = p.possibleSelectorExpr(x.Fun, token.HighestPrec, depth)
+				p.print(token.RPAREN)
+			} else {
+				wasIndented = p.possibleSelectorExpr(x.Fun, token.HighestPrec, depth)
 			}
-		} else {
-			p.exprList(x.Lparen, x.Args, depth, commaTerm, x.Rparen, false)
+			p.print(x.Lparen, token.LPAREN)
+			if x.Ellipsis.IsValid() {
+				p.exprList(x.Lparen, x.Args, depth, 0, x.Ellipsis, false)
+				p.print(x.Ellipsis, token.ELLIPSIS)
+				if x.Rparen.IsValid() && p.lineFor(x.Ellipsis) < p.lineFor(x.Rparen) {
+					p.print(token.COMMA, formfeed)
+				}
+			} else {
+				p.exprList(x.Lparen, x.Args, depth, commaTerm, x.Rparen, false)
+			}
+			p.print(x.Rparen, token.RPAREN)
 		}
-		p.print(x.Rparen, token.RPAREN)
 		if wasIndented {
 			p.print(unindent)
 		}
@@ -945,7 +991,7 @@ func (p *printer) expr1(expr ast.Expr, prec1, depth int) {
 
 	case *ast.FuncType:
 		p.print(token.FUNC)
-		p.signature(x.Params, x.Results)
+		p.signature(x)
 
 	case *ast.InterfaceType:
 		p.print(token.INTERFACE)
@@ -1585,6 +1631,9 @@ func (p *printer) spec(spec ast.Spec, n int, doIndent bool) {
 	case *ast.TypeSpec:
 		p.setComment(s.Doc)
 		p.expr(s.Name)
+		if s.TParams != nil {
+			p.parameters(s.TParams, true)
+		}
 		if n == 1 {
 			p.print(blank)
 		} else {
@@ -1773,11 +1822,11 @@ func (p *printer) funcDecl(d *ast.FuncDecl) {
 	// FUNC is emitted).
 	startCol := p.out.Column - len("func ")
 	if d.Recv != nil {
-		p.parameters(d.Recv) // method: print receiver
+		p.parameters(d.Recv, false) // method: print receiver
 		p.print(blank)
 	}
 	p.expr(d.Name)
-	p.signature(d.Type.Params, d.Type.Results)
+	p.signature(d.Type)
 	p.funcBody(p.distanceFrom(d.Pos(), startCol), vtab, d.Body)
 }
 
diff --git a/src/go/printer/printer_test.go b/src/go/printer/printer_test.go
index b64bc6bfb7..3efa468d82 100644
--- a/src/go/printer/printer_test.go
+++ b/src/go/printer/printer_test.go
@@ -42,7 +42,7 @@ const (
 // if any.
 func format(src []byte, mode checkMode) ([]byte, error) {
 	// parse src
-	f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
+	f, err := parser.ParseFile(fset, "", src, parser.ParseComments|parser.ParseTypeParams)
 	if err != nil {
 		return nil, fmt.Errorf("parse: %s\n%s", err, src)
 	}
@@ -70,7 +70,7 @@ func format(src []byte, mode checkMode) ([]byte, error) {
 
 	// make sure formatted output is syntactically correct
 	res := buf.Bytes()
-	if _, err := parser.ParseFile(fset, "", res, 0); err != nil {
+	if _, err := parser.ParseFile(fset, "", res, parser.ParseTypeParams); err != nil {
 		return nil, fmt.Errorf("re-parse: %s\n%s", err, buf.Bytes())
 	}
 
@@ -206,6 +206,7 @@ var data = []entry{
 	{"complit.input", "complit.x", export},
 	{"go2numbers.input", "go2numbers.golden", idempotent},
 	{"go2numbers.input", "go2numbers.norm", normNumber | idempotent},
+	{"generics.input", "generics.golden", idempotent},
 }
 
 func TestFiles(t *testing.T) {
diff --git a/src/go/printer/testdata/declarations.golden b/src/go/printer/testdata/declarations.golden
index fe0f7838de..74ffce7d73 100644
--- a/src/go/printer/testdata/declarations.golden
+++ b/src/go/printer/testdata/declarations.golden
@@ -942,6 +942,13 @@ type _ interface {
 		x ...int)
 }
 
+// properly format one-line type lists
+type _ interface{ type a }
+
+type _ interface {
+	type a, b, c
+}
+
 // omit superfluous parentheses in parameter lists
 func _(int)
 func _(int)
@@ -992,6 +999,10 @@ func _(struct {
 	y	int
 })	// no extra comma between } and )
 
+// type parameters
+func _[A, B any](a A, b B) int	{}
+func _[T any](x, y T) T
+
 // alias declarations
 
 type c0 struct{}
diff --git a/src/go/printer/testdata/declarations.input b/src/go/printer/testdata/declarations.input
index a858051ef0..ab2022142a 100644
--- a/src/go/printer/testdata/declarations.input
+++ b/src/go/printer/testdata/declarations.input
@@ -955,6 +955,11 @@ r string,
 		x ...int)
 }
 
+// properly format one-line type lists
+type _ interface { type a }
+
+type _ interface { type a,b,c }
+
 // omit superfluous parentheses in parameter lists
 func _((int))
 func _((((((int))))))
@@ -1005,6 +1010,10 @@ func _(struct {
 	y int
 }) // no extra comma between } and )
 
+// type parameters
+func _[A, B any](a A, b B) int {}
+func _[T any](x, y T) T
+
 // alias declarations
 
 type c0 struct{}
@@ -1018,4 +1027,4 @@ type (
 	c = foo
 	d = interface{}
 	ddd = p.Foo
-)
\ No newline at end of file
+)
diff --git a/src/go/printer/testdata/generics.golden b/src/go/printer/testdata/generics.golden
new file mode 100644
index 0000000000..88c461622e
--- /dev/null
+++ b/src/go/printer/testdata/generics.golden
@@ -0,0 +1,33 @@
+// Copyright 2020 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 generics
+
+type T[P any] struct{}
+type T[P1, P2, P3 any] struct{}
+
+type T[P C] struct{}
+type T[P1, P2, P3 C] struct{}
+
+type T[P C[P]] struct{}
+type T[P1, P2, P3 C[P1, P2, P3]] struct{}
+
+func f[P any](x P)
+func f[P1, P2, P3 any](x1 P1, x2 P2, x3 P3) struct{}
+
+func f[P interface{}](x P)
+func f[P1, P2, P3 interface {
+	m1(P1)
+	type P2, P3
+}](x1 P1, x2 P2, x3 P3) struct{}
+func f[P any](T1[P], T2[P]) T3[P]
+
+func (x T[P]) m()
+func (T[P]) m(x T[P]) P
+
+func _() {
+	type _ []T[P]
+	var _ []T[P]
+	_ = []T[P]{}
+}
diff --git a/src/go/printer/testdata/generics.input b/src/go/printer/testdata/generics.input
new file mode 100644
index 0000000000..5fdf8cdb87
--- /dev/null
+++ b/src/go/printer/testdata/generics.input
@@ -0,0 +1,30 @@
+// Copyright 2020 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 generics
+
+type T[P any] struct{}
+type T[P1, P2, P3 any] struct{}
+
+type T[P C] struct{}
+type T[P1, P2, P3 C] struct{}
+
+type T[P C[P]] struct{}
+type T[P1, P2, P3 C[P1, P2, P3]] struct{}
+
+func f[P any](x P)
+func f[P1, P2, P3 any](x1 P1, x2 P2, x3 P3) struct{}
+
+func f[P interface{}](x P)
+func f[P1, P2, P3 interface{ m1(P1); type P2, P3 }](x1 P1, x2 P2, x3 P3) struct{}
+func f[P any](T1[P], T2[P]) T3[P]
+
+func (x T[P]) m()
+func ((T[P])) m(x T[P]) P
+
+func _() {
+	type _ []T[P]
+	var _ []T[P]
+	_ = []T[P]{}
+}
-- 
GitLab


From 64bc656aed3ba7539a85f6b52f2aa933c9ce8130 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 30 Nov 2020 23:49:25 -0500
Subject: [PATCH 0132/2400] [dev.regabi] cmd/compile: use explicit block
 statements for init

For statements like goto that don't need an init, use an
explicit block statement instead of forcing them to have one.

There is also one call to addinit that is being replaced with
a block. That call is the source of much of my confusion
regarding init statements: walkstmt calls addinit on a statement,
whereas all the other uses of addinit are on expressions.

After this CL, they're all expressions.

Passes buildall w/ toolstash -cmp.

Change-Id: Ifdef9d318c236dc1a7567f9e9ef4a6bedd3fe81f
Reviewed-on: https://go-review.googlesource.com/c/go/+/274597
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/inl.go  | 21 +++++++----------
 src/cmd/compile/internal/gc/walk.go | 36 ++++++++++++++++++++---------
 2 files changed, 33 insertions(+), 24 deletions(-)

diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 89c9873c1d..fd8e9cfd46 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -527,8 +527,8 @@ func inlcalls(fn *ir.Func) {
 // Turn an OINLCALL into a statement.
 func inlconv2stmt(inlcall ir.Node) ir.Node {
 	n := ir.NodAt(inlcall.Pos(), ir.OBLOCK, nil, nil)
-	n.SetList(inlcall.Body())
-	n.SetInit(inlcall.Init())
+	n.SetList(inlcall.Init())
+	n.PtrList().AppendNodes(inlcall.PtrBody())
 	return n
 }
 
@@ -543,7 +543,7 @@ func inlconv2expr(n ir.Node) ir.Node {
 // Turn the rlist (with the return values) of the OINLCALL in
 // n into an expression list lumping the ninit and body
 // containing the inlined statements on the first list element so
-// order will be preserved Used in return, oas2func and call
+// order will be preserved. Used in return, oas2func and call
 // statements.
 func inlconv2list(n ir.Node) []ir.Node {
 	if n.Op() != ir.OINLCALL || n.Rlist().Len() == 0 {
@@ -1330,9 +1330,7 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 
 	//		dump("Return before substitution", n);
 	case ir.ORETURN:
-		m := nodSym(ir.OGOTO, nil, subst.retlabel)
-		m.PtrInit().Set(subst.list(n.Init()))
-
+		init := subst.list(n.Init())
 		if len(subst.retvars) != 0 && n.List().Len() != 0 {
 			as := ir.Nod(ir.OAS2, nil, nil)
 
@@ -1352,14 +1350,11 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 			}
 
 			as = typecheck(as, ctxStmt)
-			m.PtrInit().Append(as)
+			init = append(init, as)
 		}
-
-		typecheckslice(m.Init().Slice(), ctxStmt)
-		m = typecheck(m, ctxStmt)
-
-		//		dump("Return after substitution", m);
-		return m
+		init = append(init, nodSym(ir.OGOTO, nil, subst.retlabel))
+		typecheckslice(init, ctxStmt)
+		return ir.NewBlockStmt(base.Pos, init)
 
 	case ir.OGOTO, ir.OLABEL:
 		m := ir.Copy(n)
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 7e8ae22e4e..f439237936 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -147,16 +147,25 @@ func walkstmt(n ir.Node) ir.Node {
 		if n.Typecheck() == 0 {
 			base.Fatalf("missing typecheck: %+v", n)
 		}
-		wascopy := n.Op() == ir.OCOPY
 		init := n.Init()
 		n.PtrInit().Set(nil)
 		n = walkexpr(n, &init)
-		if wascopy && n.Op() == ir.ONAME {
+		if n.Op() == ir.ONAME {
 			// copy rewrote to a statement list and a temp for the length.
 			// Throw away the temp to avoid plain values as statements.
-			n = ir.NodAt(n.Pos(), ir.OBLOCK, nil, nil)
+			n = ir.NewBlockStmt(n.Pos(), init.Slice())
+			init.Set(nil)
+		}
+		if init.Len() > 0 {
+			switch n.Op() {
+			case ir.OAS, ir.OAS2, ir.OBLOCK:
+				n.PtrInit().Prepend(init.Slice()...)
+
+			default:
+				init.Append(n)
+				n = ir.NewBlockStmt(n.Pos(), init.Slice())
+			}
 		}
-		n = addinit(n, init.Slice())
 
 	// special case for a receive where we throw away
 	// the value received.
@@ -223,29 +232,34 @@ func walkstmt(n ir.Node) ir.Node {
 		}
 		fallthrough
 	case ir.OGO:
+		var init ir.Nodes
 		switch n.Left().Op() {
 		case ir.OPRINT, ir.OPRINTN:
-			n.SetLeft(wrapCall(n.Left(), n.PtrInit()))
+			n.SetLeft(wrapCall(n.Left(), &init))
 
 		case ir.ODELETE:
 			if mapfast(n.Left().List().First().Type()) == mapslow {
-				n.SetLeft(wrapCall(n.Left(), n.PtrInit()))
+				n.SetLeft(wrapCall(n.Left(), &init))
 			} else {
-				n.SetLeft(walkexpr(n.Left(), n.PtrInit()))
+				n.SetLeft(walkexpr(n.Left(), &init))
 			}
 
 		case ir.OCOPY:
-			n.SetLeft(copyany(n.Left(), n.PtrInit(), true))
+			n.SetLeft(copyany(n.Left(), &init, true))
 
 		case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
 			if n.Left().Body().Len() > 0 {
-				n.SetLeft(wrapCall(n.Left(), n.PtrInit()))
+				n.SetLeft(wrapCall(n.Left(), &init))
 			} else {
-				n.SetLeft(walkexpr(n.Left(), n.PtrInit()))
+				n.SetLeft(walkexpr(n.Left(), &init))
 			}
 
 		default:
-			n.SetLeft(walkexpr(n.Left(), n.PtrInit()))
+			n.SetLeft(walkexpr(n.Left(), &init))
+		}
+		if init.Len() > 0 {
+			init.Append(n)
+			n = ir.NewBlockStmt(n.Pos(), init.Slice())
 		}
 
 	case ir.OFOR, ir.OFORUNTIL:
-- 
GitLab


From 6b4da14dd3db660ff8579d9390d52d00f4f33f9a Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 2 Dec 2020 16:58:46 -0800
Subject: [PATCH 0133/2400] [dev.typeparams] cmd/compile: provide scaffolding
 to get types2 types during noding

Initial setup of types2.Info structure to provide access to types
computed by generic typechecker.

Use -G flag to control compiler phases with new typechecker:

-G    (or -G=1)  parsing and typechecking ony
-G -G (or -G=2)  parsing, typechecking, and noding
-G=3             continue after noding (currently will run old
                 typechecker again, leading to duplicate errors

Change-Id: I87dd54f7c3773228f288f7a134ac809d9481ca95
Reviewed-on: https://go-review.googlesource.com/c/go/+/274444
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/gc/main.go  |  4 +-
 src/cmd/compile/internal/gc/noder.go | 76 ++++++++++++++++++++++++----
 2 files changed, 68 insertions(+), 12 deletions(-)

diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 6b7123dc71..69a457da4d 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -229,10 +229,10 @@ func Main(archInit func(*Arch)) {
 	loadsys()
 
 	timings.Start("fe", "parse")
-	lines := parseFiles(flag.Args(), base.Flag.G != 0)
+	lines := parseFiles(flag.Args())
 	timings.Stop()
 	timings.AddEvent(int64(lines), "lines")
-	if base.Flag.G != 0 {
+	if base.Flag.G != 0 && base.Flag.G < 3 {
 		// can only parse generic code for now
 		base.ExitIfErrors()
 		return
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 5115932b1e..4eaeedb63b 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -32,7 +32,7 @@ import (
 // Each declaration in every *syntax.File is converted to a syntax tree
 // and its root represented by *Node is appended to xtop.
 // Returns the total count of parsed lines.
-func parseFiles(filenames []string, allowGenerics bool) (lines uint) {
+func parseFiles(filenames []string) (lines uint) {
 	noders := make([]*noder, 0, len(filenames))
 	// Limit the number of simultaneously open files.
 	sem := make(chan struct{}, runtime.GOMAXPROCS(0)+10)
@@ -48,7 +48,7 @@ func parseFiles(filenames []string, allowGenerics bool) (lines uint) {
 			sem <- struct{}{}
 			defer func() { <-sem }()
 			defer close(p.err)
-			base := syntax.NewFileBase(filename)
+			fbase := syntax.NewFileBase(filename)
 
 			f, err := os.Open(filename)
 			if err != nil {
@@ -58,14 +58,16 @@ func parseFiles(filenames []string, allowGenerics bool) (lines uint) {
 			defer f.Close()
 
 			mode := syntax.CheckBranches
-			if allowGenerics {
+			if base.Flag.G != 0 {
 				mode |= syntax.AllowGenerics
 			}
-			p.file, _ = syntax.Parse(base, f, p.error, p.pragma, mode) // errors are tracked via p.error
+			p.file, _ = syntax.Parse(fbase, f, p.error, p.pragma, mode) // errors are tracked via p.error
 		}(filename)
 	}
 
-	if allowGenerics {
+	// generic noding phase (using new typechecker)
+	if base.Flag.G != 0 {
+		// setup and syntax error reporting
 		nodersmap := make(map[string]*noder)
 		var files []*syntax.File
 		for _, p := range noders {
@@ -77,11 +79,12 @@ func parseFiles(filenames []string, allowGenerics bool) (lines uint) {
 			files = append(files, p.file)
 			lines += p.file.EOF.Line()
 
-			if base.SyntaxErrors() != 0 {
-				base.ErrorExit()
-			}
+		}
+		if base.SyntaxErrors() != 0 {
+			base.ErrorExit()
 		}
 
+		// typechecking
 		conf := types2.Config{
 			InferFromConstraints:  true,
 			IgnoreBranches:        true, // parser already checked via syntax.CheckBranches mode
@@ -110,10 +113,37 @@ func parseFiles(filenames []string, allowGenerics bool) (lines uint) {
 				},
 			},
 		}
-		conf.Check(base.Ctxt.Pkgpath, files, nil)
+		info := types2.Info{
+			Types: make(map[syntax.Expr]types2.TypeAndValue),
+			Defs:  make(map[*syntax.Name]types2.Object),
+			Uses:  make(map[*syntax.Name]types2.Object),
+			// expand as needed
+		}
+		conf.Check(base.Ctxt.Pkgpath, files, &info)
+		base.ExitIfErrors()
+		if base.Flag.G < 2 {
+			return
+		}
+
+		// noding
+		for _, p := range noders {
+			// errors have already been reported
+
+			p.typeInfo = &info
+			p.node()
+			lines += p.file.EOF.Line()
+			p.file = nil // release memory
+			base.ExitIfErrors()
+
+			// Always run testdclstack here, even when debug_dclstack is not set, as a sanity measure.
+			testdclstack()
+		}
+
+		ir.LocalPkg.Height = myheight
 		return
 	}
 
+	// traditional (non-generic) noding phase
 	for _, p := range noders {
 		for e := range p.err {
 			p.errorAt(e.Pos, "%s", e.Msg)
@@ -122,10 +152,10 @@ func parseFiles(filenames []string, allowGenerics bool) (lines uint) {
 		p.node()
 		lines += p.file.EOF.Line()
 		p.file = nil // release memory
-
 		if base.SyntaxErrors() != 0 {
 			base.ErrorExit()
 		}
+
 		// Always run testdclstack here, even when debug_dclstack is not set, as a sanity measure.
 		testdclstack()
 	}
@@ -220,9 +250,35 @@ type noder struct {
 	// current function at the moment each open scope was opened.
 	scopeVars []int
 
+	// typeInfo provides access to the type information computed by the new
+	// typechecker. It is only present if -G is set, and all noders point to
+	// the same types.Info. For now this is a local field, if need be we can
+	// make it global.
+	typeInfo *types2.Info
+
 	lastCloseScopePos syntax.Pos
 }
 
+// For now we provide these basic accessors to get to type and object
+// information of expression nodes during noding. Eventually we will
+// attach this information directly to the syntax tree which should
+// simplify access and make it more efficient as well.
+
+// typ returns the type and value information for the given expression.
+func (p *noder) typ(x syntax.Expr) types2.TypeAndValue {
+	return p.typeInfo.Types[x]
+}
+
+// def returns the object for the given name in its declaration.
+func (p *noder) def(x *syntax.Name) types2.Object {
+	return p.typeInfo.Defs[x]
+}
+
+// use returns the object for the given name outside its declaration.
+func (p *noder) use(x *syntax.Name) types2.Object {
+	return p.typeInfo.Uses[x]
+}
+
 func (p *noder) funcBody(fn ir.Node, block *syntax.BlockStmt) {
 	oldScope := p.scope
 	p.scope = 0
-- 
GitLab


From 5a3b6796cdb1833929805262b6f843c0e82fa7e1 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Tue, 1 Dec 2020 20:51:18 -0800
Subject: [PATCH 0134/2400] [dev.regabi] cmd/compile: remove extra typ field in
 Name struct

Noticed the typ field was duplicated, since it is also in miniExpr inside Name.

Also clarified the comments for Func, now that it is actually the ODCLFUNC node.

Change-Id: Ia483a0ad34bb409cd92c43d4ae0a6852f9e4f644
Reviewed-on: https://go-review.googlesource.com/c/go/+/274619
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/ir/func.go        | 15 ++++++++-------
 src/cmd/compile/internal/ir/name.go        |  1 -
 src/cmd/compile/internal/ir/sizeof_test.go |  2 +-
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 3fc8597ef0..98830fb502 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -17,13 +17,14 @@ import (
 //
 // There are multiple nodes that represent a Func in the IR.
 //
-// The ONAME node (Func.Name) is used for plain references to it.
-// The ODCLFUNC node (Func.Decl) is used for its declaration code.
-// The OCLOSURE node (Func.Closure) is used for a reference to a
+// The ONAME node (Func.Nname) is used for plain references to it.
+// The ODCLFUNC node (the Func itself) is used for its declaration code.
+// The OCLOSURE node (Func.OClosure) is used for a reference to a
 // function literal.
 //
-// A Func for an imported function will have only an ONAME node.
-// A declared function or method has an ONAME and an ODCLFUNC.
+// An imported function will have an ONAME node which points to a Func
+// with an empty body.
+// A declared function or method has an ODCLFUNC (the Func itself) and an ONAME.
 // A function literal is represented directly by an OCLOSURE, but it also
 // has an ODCLFUNC (and a matching ONAME) representing the compiled
 // underlying form of the closure, which accesses the captured variables
@@ -44,8 +45,8 @@ import (
 // the method name is stored in Sym instead of Right.
 // Each OCALLPART ends up being implemented as a new
 // function, a bit like a closure, with its own ODCLFUNC.
-// The OCALLPART has uses n.Func to record the linkage to
-// the generated ODCLFUNC (as n.Func.Decl), but there is no
+// The OCALLPART uses n.Func to record the linkage to
+// the generated ODCLFUNC, but there is no
 // pointer from the Func back to the OCALLPART.
 type Func struct {
 	miniNode
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 3c62800ad3..1d886bb9a1 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -21,7 +21,6 @@ type Name struct {
 	flags      bitset16
 	pragma     PragmaFlag // int16
 	sym        *types.Sym
-	typ        *types.Type
 	fn         *Func
 	offset     int64
 	val        constant.Value
diff --git a/src/cmd/compile/internal/ir/sizeof_test.go b/src/cmd/compile/internal/ir/sizeof_test.go
index 4a133cb999..181f1462fe 100644
--- a/src/cmd/compile/internal/ir/sizeof_test.go
+++ b/src/cmd/compile/internal/ir/sizeof_test.go
@@ -21,7 +21,7 @@ func TestSizeof(t *testing.T) {
 		_64bit uintptr     // size on 64bit platforms
 	}{
 		{Func{}, 168, 288},
-		{Name{}, 128, 224},
+		{Name{}, 124, 216},
 	}
 
 	for _, tt := range tests {
-- 
GitLab


From 00e572779077737d409ed57194510ec42c520b34 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Wed, 2 Dec 2020 14:40:48 +0700
Subject: [PATCH 0135/2400] [dev.regabi] cmd/compile: remove okAs

The check for blank in okAs is redundant with what its callers already
done, so just inline the conversion in callers side instead.

Passes toolstash-check.

Change-Id: I606105e2d2cf8e80214722a13c3101c464d20d82
Reviewed-on: https://go-review.googlesource.com/c/go/+/274793
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/order.go | 13 ++-----------
 1 file changed, 2 insertions(+), 11 deletions(-)

diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 352e9c473b..7816e684dc 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -936,7 +936,7 @@ func (o *Order) stmt(n ir.Node) {
 					}
 
 					tmp := o.newTemp(types.Types[types.TBOOL], false)
-					as := okas(ok, tmp)
+					as := ir.Nod(ir.OAS, ok, conv(tmp, ok.Type()))
 					as = typecheck(as, ctxStmt)
 					n2.PtrInit().Append(as)
 					ok = tmp
@@ -1382,15 +1382,6 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 	return n
 }
 
-// okas creates and returns an assignment of val to ok,
-// including an explicit conversion if necessary.
-func okas(ok, val ir.Node) ir.Node {
-	if !ir.IsBlank(ok) {
-		val = conv(val, ok.Type())
-	}
-	return ir.Nod(ir.OAS, ok, val)
-}
-
 // as2 orders OAS2XXXX nodes. It creates temporaries to ensure left-to-right assignment.
 // The caller should order the right-hand side of the assignment before calling order.as2.
 // It rewrites,
@@ -1442,7 +1433,7 @@ func (o *Order) okAs2(n ir.Node) {
 		n.List().SetFirst(tmp1)
 	}
 	if tmp2 != nil {
-		r := okas(n.List().Second(), tmp2)
+		r := ir.Nod(ir.OAS, n.List().Second(), conv(tmp2, n.List().Second().Type()))
 		r = typecheck(r, ctxStmt)
 		o.mapAssign(r)
 		n.List().SetSecond(tmp2)
-- 
GitLab


From 59b8916d482bdca933885881dff54365432ec9f5 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 1 Dec 2020 12:02:16 -0500
Subject: [PATCH 0136/2400] [dev.regabi] cmd/compile: handle OCONVNOP better in
 ssa

This CL improves handling of OCONVNOP nodes during ssa generation,
so it is not toolstash safe.

An OCONVNOP wrapper is necessary for the "for" condition of
certain compiled range loops, and the boolean evaluator was
not looking through them properly, generating unnecessary
temporaries. That change saved 8k of the (13 MB) go binary.

The other changes just streamline the handling of OCONVNOP
to be more like what OSTMTEXPR will be like. They have no
effect on output size but do tweak the ssa graph a little, which
causes different register decisions and therefore different output.

Change-Id: I9e1dcd413b60944e21554c3e3f2bdc9adcee7634
Reviewed-on: https://go-review.googlesource.com/c/go/+/274598
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/gc/ssa.go  | 10 ++++++++++
 src/cmd/compile/internal/gc/walk.go |  3 +++
 2 files changed, 13 insertions(+)

diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 7c74054b60..d53bd1aa4f 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -2103,6 +2103,9 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		// Assume everything will work out, so set up our return value.
 		// Anything interesting that happens from here is a fatal.
 		x := s.expr(n.Left())
+		if to == from {
+			return x
+		}
 
 		// Special case for not confusing GC and liveness.
 		// We don't want pointers accidentally classified
@@ -2966,6 +2969,10 @@ func (s *state) condBranch(cond ir.Node, yes, no *ssa.Block, likely int8) {
 		s.stmtList(cond.Init())
 		s.condBranch(cond.Left(), no, yes, -likely)
 		return
+	case ir.OCONVNOP:
+		s.stmtList(cond.Init())
+		s.condBranch(cond.Left(), yes, no, likely)
+		return
 	}
 	c := s.expr(cond)
 	b := s.endBlock()
@@ -4903,6 +4910,9 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 		return s.newValue1I(ssa.OpOffPtr, t, n.Offset(),
 			s.entryNewValue0(ssa.OpGetClosurePtr, s.f.Config.Types.BytePtr))
 	case ir.OCONVNOP:
+		if n.Type() == n.Left().Type() {
+			return s.addr(n.Left())
+		}
 		addr := s.addr(n.Left())
 		return s.newValue1(ssa.OpCopy, t, addr) // ensure that addr has the right type
 	case ir.OCALLFUNC, ir.OCALLINTER, ir.OCALLMETH:
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index f439237936..c0f447f1a2 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -966,6 +966,9 @@ opswitch:
 
 	case ir.OCONV, ir.OCONVNOP:
 		n.SetLeft(walkexpr(n.Left(), init))
+		if n.Op() == ir.OCONVNOP && n.Type() == n.Left().Type() {
+			return n.Left()
+		}
 		if n.Op() == ir.OCONVNOP && checkPtr(Curfn, 1) {
 			if n.Type().IsPtr() && n.Left().Type().IsUnsafePtr() { // unsafe.Pointer to *T
 				n = walkCheckPtrAlignment(n, init, nil)
-- 
GitLab


From 07d32c8183eb4f7d8d1d6185ea69b8fb0425f6a6 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 1 Dec 2020 17:37:12 -0800
Subject: [PATCH 0137/2400] [dev.typeparams] cmd/compile/internal/types: adjust
 some error messages to match the compiler

Change-Id: I04bd7b294de4ed0fb01bc0609e09debea2d797bd
Reviewed-on: https://go-review.googlesource.com/c/go/+/274974
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/expr.go    | 6 +++++-
 src/cmd/compile/internal/types2/stmt.go    | 2 +-
 src/cmd/compile/internal/types2/typexpr.go | 6 +++++-
 3 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 3c9540783a..c68077547e 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -1867,7 +1867,11 @@ func (check *Checker) typeAssertion(pos syntax.Pos, x *operand, xtyp *Interface,
 	} else {
 		msg = "missing method " + method.name
 	}
-	check.errorf(pos, "%s cannot have dynamic type %s (%s)", x, T, msg)
+	if check.conf.CompilerErrorMessages {
+		check.errorf(pos, "impossible type assertion: %s (%s)", x, msg)
+	} else {
+		check.errorf(pos, "%s cannot have dynamic type %s (%s)", x, T, msg)
+	}
 }
 
 // expr typechecks expression e and initializes x with the expression value.
diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go
index 11a9b8313f..f1317fa0a3 100644
--- a/src/cmd/compile/internal/types2/stmt.go
+++ b/src/cmd/compile/internal/types2/stmt.go
@@ -886,7 +886,7 @@ func rangeKeyVal(typ Type, wantKey, wantVal bool) (Type, Type, string) {
 	case *Chan:
 		var msg string
 		if typ.dir == SendOnly {
-			msg = "send-only channel"
+			msg = "receive from send-only channel"
 		}
 		return typ.elem, Typ[Invalid], msg
 	case *Sum:
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 2d568b7e87..39bb3a6b14 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -806,7 +806,11 @@ func (check *Checker) interfaceType(ityp *Interface, iface *syntax.InterfaceType
 			// of a type list (f.Name.Value == "type").
 			name := f.Name.Value
 			if name == "_" {
-				check.errorf(f.Name, "invalid method name _")
+				if check.conf.CompilerErrorMessages {
+					check.errorf(f.Name, "methods must have a unique non-blank name")
+				} else {
+					check.errorf(f.Name, "invalid method name _")
+				}
 				continue // ignore
 			}
 
-- 
GitLab


From 7e81135be7b264517cf2ae17dec0fdbafc4c6841 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 2 Dec 2020 17:03:18 -0500
Subject: [PATCH 0138/2400] [dev.regabi] cmd/compile: rename addinit(n, init)
 to initExpr(init, n)

Recreated manually to push below some CLs it depended on.

Change-Id: I1b3316fcdce39cbb33e5cbb471f5cd1cd2efc1f5
Reviewed-on: https://go-review.googlesource.com/c/go/+/274599
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/inl.go       | 4 ++--
 src/cmd/compile/internal/gc/order.go     | 2 +-
 src/cmd/compile/internal/gc/subr.go      | 6 +++---
 src/cmd/compile/internal/gc/typecheck.go | 4 ++--
 src/cmd/compile/internal/gc/walk.go      | 6 +++---
 5 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index fd8e9cfd46..42125f38f3 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -537,7 +537,7 @@ func inlconv2stmt(inlcall ir.Node) ir.Node {
 // 	n.Left = inlconv2expr(n.Left)
 func inlconv2expr(n ir.Node) ir.Node {
 	r := n.Rlist().First()
-	return addinit(r, append(n.Init().Slice(), n.Body().Slice()...))
+	return initExpr(append(n.Init().Slice(), n.Body().Slice()...), r)
 }
 
 // Turn the rlist (with the return values) of the OINLCALL in
@@ -551,7 +551,7 @@ func inlconv2list(n ir.Node) []ir.Node {
 	}
 
 	s := n.Rlist().Slice()
-	s[0] = addinit(s[0], append(n.Init().Slice(), n.Body().Slice()...))
+	s[0] = initExpr(append(n.Init().Slice(), n.Body().Slice()...), s[0])
 	return s
 }
 
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 7816e684dc..e4175bbf36 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -433,7 +433,7 @@ func (o *Order) exprInPlace(n ir.Node) ir.Node {
 	var order Order
 	order.free = o.free
 	n = order.expr(n, nil)
-	n = addinit(n, order.out)
+	n = initExpr(order.out, n)
 
 	// insert new temporaries from order
 	// at head of outer list.
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 011a7ac5bc..970f78b355 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -1355,9 +1355,9 @@ func ngotype(n ir.Node) *types.Sym {
 	return nil
 }
 
-// The result of addinit MUST be assigned back to n, e.g.
-// 	n.Left = addinit(n.Left, init)
-func addinit(n ir.Node, init []ir.Node) ir.Node {
+// The result of initExpr MUST be assigned back to n, e.g.
+// 	n.Left = initExpr(init, n.Left)
+func initExpr(init []ir.Node, n ir.Node) ir.Node {
 	if len(init) == 0 {
 		return n
 	}
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 5a073ac324..55443ba596 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -1314,7 +1314,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				}
 				old := n
 				n = ir.NodAt(n.Pos(), l.SubOp(), arg, nil)
-				n = addinit(n, old.Init().Slice()) // typecheckargs can add to old.Init
+				n = initExpr(old.Init().Slice(), n) // typecheckargs can add to old.Init
 
 			case ir.OCOMPLEX, ir.OCOPY:
 				typecheckargs(n)
@@ -1325,7 +1325,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				}
 				old := n
 				n = ir.NodAt(n.Pos(), l.SubOp(), arg1, arg2)
-				n = addinit(n, old.Init().Slice()) // typecheckargs can add to old.Init
+				n = initExpr(old.Init().Slice(), n) // typecheckargs can add to old.Init
 			}
 			n = typecheck1(n, top)
 			return n
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index c0f447f1a2..e72015c05e 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -180,7 +180,7 @@ func walkstmt(n ir.Node) ir.Node {
 		n = mkcall1(chanfn("chanrecv1", 2, n.Left().Type()), nil, &init, n.Left(), nodnil())
 		n = walkexpr(n, &init)
 
-		n = addinit(n, init.Slice())
+		n = initExpr(init.Slice(), n)
 
 	case ir.OBREAK,
 		ir.OCONTINUE,
@@ -268,7 +268,7 @@ func walkstmt(n ir.Node) ir.Node {
 			init := n.Left().Init()
 			n.Left().PtrInit().Set(nil)
 			n.SetLeft(walkexpr(n.Left(), &init))
-			n.SetLeft(addinit(n.Left(), init.Slice()))
+			n.SetLeft(initExpr(init.Slice(), n.Left()))
 		}
 
 		n.SetRight(walkstmt(n.Right()))
@@ -557,7 +557,7 @@ opswitch:
 		var ll ir.Nodes
 
 		n.SetRight(walkexpr(n.Right(), &ll))
-		n.SetRight(addinit(n.Right(), ll.Slice()))
+		n.SetRight(initExpr(ll.Slice(), n.Right()))
 
 	case ir.OPRINT, ir.OPRINTN:
 		n = walkprint(n, init)
-- 
GitLab


From 7a1aa7dfaf9a7208a6cae7518037d885c9fabdbd Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 1 Dec 2020 17:37:12 -0800
Subject: [PATCH 0139/2400] [dev.typeparams] test: adjust more test cases to
 match compiler -G output

With this CL, the first ~500 errorcheck tests pass when running

go run run.go -v -G

in the $GOROOT/test directory (the log output includes a few dozen
tests that are currently skipped).

Change-Id: I9eaa2319fb39a090df54f8699ddc29ffe58b1bf1
Reviewed-on: https://go-review.googlesource.com/c/go/+/274975
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 test/chan/perm.go           |  2 +-
 test/fixedbugs/bug040.go    |  2 +-
 test/fixedbugs/bug062.go    |  1 +
 test/fixedbugs/bug081.go    |  2 +-
 test/fixedbugs/bug090.go    |  2 +-
 test/fixedbugs/bug122.go    |  2 +-
 test/fixedbugs/bug131.go    |  1 +
 test/fixedbugs/bug132.go    |  2 +-
 test/fixedbugs/bug13343.go  |  2 +-
 test/fixedbugs/bug175.go    |  2 +-
 test/fixedbugs/bug205.go    |  6 +++---
 test/fixedbugs/bug215.go    |  2 +-
 test/fixedbugs/bug223.go    |  2 +-
 test/fixedbugs/bug224.go    |  2 +-
 test/fixedbugs/bug280.go    |  2 +-
 test/fixedbugs/bug289.go    |  4 ++--
 test/interface/embed2.go    | 10 +++++-----
 test/interface/explicit.go  | 22 +++++++++++++---------
 test/interface/pointer.go   |  4 +++-
 test/interface/receiver1.go |  4 ++--
 test/run.go                 |  1 +
 21 files changed, 43 insertions(+), 34 deletions(-)

diff --git a/test/chan/perm.go b/test/chan/perm.go
index 7da88bdae8..607a356a02 100644
--- a/test/chan/perm.go
+++ b/test/chan/perm.go
@@ -66,5 +66,5 @@ func main() {
 	close(c)
 	close(cs)
 	close(cr) // ERROR "receive"
-	close(n)  // ERROR "invalid operation.*non-chan type"
+	close(n)  // ERROR "invalid operation.*non-chan type|not a channel"
 }
diff --git a/test/fixedbugs/bug040.go b/test/fixedbugs/bug040.go
index d2cf88afcb..5c3a1d7c12 100644
--- a/test/fixedbugs/bug040.go
+++ b/test/fixedbugs/bug040.go
@@ -7,5 +7,5 @@
 package main
 
 func f (x,		// GCCGO_ERROR "previous"
-	x int) {	// ERROR "duplicate argument|redefinition"
+	x int) {	// ERROR "duplicate argument|redefinition|redeclared"
 }
diff --git a/test/fixedbugs/bug062.go b/test/fixedbugs/bug062.go
index 1cc5003655..24c2dff933 100644
--- a/test/fixedbugs/bug062.go
+++ b/test/fixedbugs/bug062.go
@@ -8,4 +8,5 @@ package main
 
 func main() {
 	var s string = nil;	// ERROR "illegal|invalid|incompatible|cannot"
+	_ = s
 }
diff --git a/test/fixedbugs/bug081.go b/test/fixedbugs/bug081.go
index c25d288370..40e6dd1b6f 100644
--- a/test/fixedbugs/bug081.go
+++ b/test/fixedbugs/bug081.go
@@ -6,7 +6,7 @@
 
 package main
 
-const x x = 2 // ERROR "loop|type"
+const x x = 2 // ERROR "loop|type|cycle"
 
 /*
 bug081.go:3: first constant must evaluate an expression
diff --git a/test/fixedbugs/bug090.go b/test/fixedbugs/bug090.go
index 320bd57f5c..6d30cca017 100644
--- a/test/fixedbugs/bug090.go
+++ b/test/fixedbugs/bug090.go
@@ -42,5 +42,5 @@ func main() {
 
 	const h float64 = 3.14;
 	i = h;  // ERROR "convert|incompatible|cannot"
-	i = int(h);	// ERROR "truncate"
+	i = int(h);	// ERROR "truncate|cannot convert"
 }
diff --git a/test/fixedbugs/bug122.go b/test/fixedbugs/bug122.go
index fb4eb9f3ad..5640cf263a 100644
--- a/test/fixedbugs/bug122.go
+++ b/test/fixedbugs/bug122.go
@@ -8,5 +8,5 @@ package main
 
 func main() {
 	// should allow at most 2 sizes
-	a := make([]int, 10, 20, 30, 40); // ERROR "too many"
+	a := make([]int, 10, 20, 30, 40); // ERROR "too many|expects 2 or 3 arguments; found 5"
 }
diff --git a/test/fixedbugs/bug131.go b/test/fixedbugs/bug131.go
index 0ebbd26069..2c9d120ed0 100644
--- a/test/fixedbugs/bug131.go
+++ b/test/fixedbugs/bug131.go
@@ -9,4 +9,5 @@ package main
 func main() {
 	const a uint64 = 10;
 	var b int64 = a;	// ERROR "convert|cannot|incompatible"
+	_ = b
 }
diff --git a/test/fixedbugs/bug132.go b/test/fixedbugs/bug132.go
index e334566c79..b75e8338de 100644
--- a/test/fixedbugs/bug132.go
+++ b/test/fixedbugs/bug132.go
@@ -7,5 +7,5 @@
 package main
 
 type T struct {
-	x, x int  // ERROR "duplicate"
+	x, x int  // ERROR "duplicate|redeclared"
 }
diff --git a/test/fixedbugs/bug13343.go b/test/fixedbugs/bug13343.go
index 5dc736d443..08a306277b 100644
--- a/test/fixedbugs/bug13343.go
+++ b/test/fixedbugs/bug13343.go
@@ -7,7 +7,7 @@
 package main
 
 var (
-	a, b = f() // ERROR "initialization loop|depends upon itself"
+	a, b = f() // ERROR "initialization loop|depends upon itself|initialization cycle"
 	c    = b
 )
 
diff --git a/test/fixedbugs/bug175.go b/test/fixedbugs/bug175.go
index 5fca4b22bc..88210a59b3 100644
--- a/test/fixedbugs/bug175.go
+++ b/test/fixedbugs/bug175.go
@@ -9,6 +9,6 @@ package main
 func f() (int, bool) { return 0, true }
 
 func main() {
-	x, y := f(), 2;	// ERROR "multi"
+	x, y := f(), 2;	// ERROR "multi|2-valued"
 	_, _ = x, y
 }
diff --git a/test/fixedbugs/bug205.go b/test/fixedbugs/bug205.go
index 1e0d9d1f34..789696df0c 100644
--- a/test/fixedbugs/bug205.go
+++ b/test/fixedbugs/bug205.go
@@ -11,8 +11,8 @@ var s string;
 var m map[string]int;
 
 func main() {
-	println(t["hi"]); // ERROR "non-integer slice index|must be integer"
-	println(s["hi"]); // ERROR "non-integer string index|must be integer"
-	println(m[0]);    // ERROR "cannot use.*as type string"
+	println(t["hi"]); // ERROR "non-integer slice index|must be integer|cannot convert"
+	println(s["hi"]); // ERROR "non-integer string index|must be integer|cannot convert"
+	println(m[0]);    // ERROR "cannot use.*as type string|cannot convert"
 }
 
diff --git a/test/fixedbugs/bug215.go b/test/fixedbugs/bug215.go
index b27cc7db1a..5546d0c889 100644
--- a/test/fixedbugs/bug215.go
+++ b/test/fixedbugs/bug215.go
@@ -9,6 +9,6 @@
 
 package main
 
-type A struct {	a A }	// ERROR "recursive"
+type A struct {	a A }	// ERROR "recursive|cycle"
 func foo()		{ new(A).bar() }
 func (a A) bar()	{}
diff --git a/test/fixedbugs/bug223.go b/test/fixedbugs/bug223.go
index 29ae53cb71..50082cbab1 100644
--- a/test/fixedbugs/bug223.go
+++ b/test/fixedbugs/bug223.go
@@ -18,4 +18,4 @@ func f() {
 	}
 }
 
-var m = map[string]F{"f": f} // ERROR "initialization loop|depends upon itself"
+var m = map[string]F{"f": f} // ERROR "initialization loop|depends upon itself|initialization cycle"
diff --git a/test/fixedbugs/bug224.go b/test/fixedbugs/bug224.go
index d2fd67cf32..4ff83019df 100644
--- a/test/fixedbugs/bug224.go
+++ b/test/fixedbugs/bug224.go
@@ -6,5 +6,5 @@
 
 package main
 
-type T T		// ERROR "recursive"
+type T T		// ERROR "recursive|cycle"
 
diff --git a/test/fixedbugs/bug280.go b/test/fixedbugs/bug280.go
index afec57f037..9a9d4c902d 100644
--- a/test/fixedbugs/bug280.go
+++ b/test/fixedbugs/bug280.go
@@ -8,6 +8,6 @@
 
 package main
 
-type A [...]int	// ERROR "outside of array literal"
+type A [...]int	// ERROR "outside of array literal|invalid use of \[\.\.\.\]"
 
 
diff --git a/test/fixedbugs/bug289.go b/test/fixedbugs/bug289.go
index 3fc7fb2eef..fea6829992 100644
--- a/test/fixedbugs/bug289.go
+++ b/test/fixedbugs/bug289.go
@@ -9,14 +9,14 @@
 package main
 
 func f1() {
-	a, b := f()	// ERROR "assignment mismatch|does not match"
+	a, b := f()	// ERROR "assignment mismatch|does not match|cannot initialize"
 	_ = a
 	_ = b
 }
 
 func f2() {
 	var a, b int
-	a, b = f()	// ERROR "assignment mismatch|does not match"
+	a, b = f()	// ERROR "assignment mismatch|does not match|cannot assign"
 	_ = a
 	_ = b
 }
diff --git a/test/interface/embed2.go b/test/interface/embed2.go
index df3e2e435b..97a2d963f0 100644
--- a/test/interface/embed2.go
+++ b/test/interface/embed2.go
@@ -48,25 +48,25 @@ func main() {
 	check("t.M()", t.M())
 	check("pt.M()", pt.M())
 	check("ti.M()", ti.M())
-	check("pti.M()", pti.M()) // ERROR "pointer to interface, not interface"
+	check("pti.M()", pti.M()) // ERROR "pointer to interface, not interface|no field or method M"
 	check("s.M()", s.M())
 	check("ps.M()", ps.M())
 
 	i = t
 	check("i = t; i.M()", i.M())
-	check("i = t; pi.M()", pi.M()) // ERROR "pointer to interface, not interface"
+	check("i = t; pi.M()", pi.M()) // ERROR "pointer to interface, not interface|no field or method M"
 
 	i = pt
 	check("i = pt; i.M()", i.M())
-	check("i = pt; pi.M()", pi.M()) // ERROR "pointer to interface, not interface"
+	check("i = pt; pi.M()", pi.M()) // ERROR "pointer to interface, not interface|no field or method M"
 
 	i = s
 	check("i = s; i.M()", i.M())
-	check("i = s; pi.M()", pi.M()) // ERROR "pointer to interface, not interface"
+	check("i = s; pi.M()", pi.M()) // ERROR "pointer to interface, not interface|no field or method M"
 
 	i = ps
 	check("i = ps; i.M()", i.M())
-	check("i = ps; pi.M()", pi.M()) // ERROR "pointer to interface, not interface"
+	check("i = ps; pi.M()", pi.M()) // ERROR "pointer to interface, not interface|no field or method M"
 
 	if !ok {
 		println("BUG: interface10")
diff --git a/test/interface/explicit.go b/test/interface/explicit.go
index 1fb3b6a05a..7aaaad4e48 100644
--- a/test/interface/explicit.go
+++ b/test/interface/explicit.go
@@ -38,7 +38,7 @@ var e E
 
 func main() {
 	e = t // ok
-	t = e // ERROR "need explicit|need type assertion"
+	t = e // ERROR "need explicit|need type assertion|incompatible type"
 
 	// neither of these can work,
 	// because i has an extra method
@@ -47,17 +47,17 @@ func main() {
 	t = i // ERROR "incompatible|assignment$"
 
 	i = i2 // ok
-	i2 = i // ERROR "incompatible|missing N method"
+	i2 = i // ERROR "incompatible|missing N method|cannot convert"
 
 	i = I(i2)  // ok
-	i2 = I2(i) // ERROR "invalid|missing N method"
+	i2 = I2(i) // ERROR "invalid|missing N method|cannot convert"
 
 	e = E(t) // ok
-	t = T(e) // ERROR "need explicit|need type assertion|incompatible"
+	t = T(e) // ERROR "need explicit|need type assertion|incompatible|cannot convert"
 
 	// cannot type-assert non-interfaces
 	f := 2.0
-	_ = f.(int) // ERROR "non-interface type"
+	_ = f.(int) // ERROR "non-interface type|not an interface type"
 
 }
 
@@ -83,8 +83,8 @@ var jj Int
 var m1 M = ii // ERROR "incompatible|missing"
 var m2 M = jj // ERROR "incompatible|wrong type for M method"
 
-var m3 = M(ii) // ERROR "invalid|missing"
-var m4 = M(jj) // ERROR "invalid|wrong type for M method"
+var m3 = M(ii) // ERROR "invalid|missing|cannot convert"
+var m4 = M(jj) // ERROR "invalid|wrong type for M method|cannot convert"
 
 type B1 interface {
 	_() // ERROR "methods must have a unique non-blank name"
@@ -101,5 +101,9 @@ func (t *T2) M() {}
 func (t *T2) _() {}
 
 // Check that nothing satisfies an interface with blank methods.
-var b1 B1 = &T2{} // ERROR "incompatible|missing _ method"
-var b2 B2 = &T2{} // ERROR "incompatible|missing _ method"
+// Disabled this test as it's not clear we need this behavior.
+// See also issue #42964.
+/*
+var b1 B1 = &T2{} // "incompatible|missing _ method"
+var b2 B2 = &T2{} // "incompatible|missing _ method"
+*/
\ No newline at end of file
diff --git a/test/interface/pointer.go b/test/interface/pointer.go
index 2927050669..c21e4da390 100644
--- a/test/interface/pointer.go
+++ b/test/interface/pointer.go
@@ -32,7 +32,9 @@ func AddInst(Inst) *Inst {
 
 func main() {
 	print("call addinst\n")
-	var x Inst = AddInst(new(Start)) // ERROR "pointer to interface"
+	var x Inst = AddInst(new(Start)) // ERROR "pointer to interface|incompatible type"
+	_ = x
 	print("return from  addinst\n")
 	var y *Inst = new(Start)  // ERROR "pointer to interface|incompatible type"
+	_ = y
 }
diff --git a/test/interface/receiver1.go b/test/interface/receiver1.go
index 2b7ccdc1a7..a0a87534a4 100644
--- a/test/interface/receiver1.go
+++ b/test/interface/receiver1.go
@@ -37,14 +37,14 @@ func main() {
 	var sp SP
 
 	v = t
-	p = t // ERROR "does not implement|requires a pointer"
+	p = t // ERROR "does not implement|requires a pointer|cannot use"
 	_, _ = v, p
 	v = &t
 	p = &t
 	_, _ = v, p
 
 	v = s
-	p = s // ERROR "does not implement|requires a pointer"
+	p = s // ERROR "does not implement|requires a pointer|cannot use"
 	_, _ = v, p
 	v = &s
 	p = &s
diff --git a/test/run.go b/test/run.go
index 1eef6f1f35..d354646552 100644
--- a/test/run.go
+++ b/test/run.go
@@ -813,6 +813,7 @@ func (t *test) run() {
 				"wb",
 				"append",
 				"slice",
+				"typeassert",
 				"ssa/check_bce/debug",
 				"ssa/intrinsics/debug",
 				"ssa/prove/debug",
-- 
GitLab


From beb5e0540406e2281a7502a2009db752668219da Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 2 Dec 2020 23:55:42 -0800
Subject: [PATCH 0140/2400] [dev.regabi] cmd/compile: refactoring prep for
 ConstExpr

The next CL adds ConstExpr, which is a more memory efficient
representation for constant expressions than Name. However, currently
a bunch of Val helper methods are defined on Name. This CL changes
them into standalone functions that work with any Node.Val
implementation.

There's also an existing standalone function named Int64Val, which
takes a Type argument to specify what type of integer is expected. So
to avoid collisions, this CL renames it to IntVal.

Passes buildall w/ toolstash -cmp.

[git-generate]
cd src/cmd/compile/internal/ir
rf 'mv Int64Val IntVal'
sed -i -E -e 's/\(n \*Name\) (CanInt64|((I|Ui)nt64|Bool|String)Val)\(/\1(n Node/' name.go

cd ../gc
rf '
ex {
  import "cmd/compile/internal/ir"
  var n ir.Node
  n.CanInt64() -> ir.CanInt64(n)
  n.Int64Val() -> ir.Int64Val(n)
  n.Uint64Val() -> ir.Uint64Val(n)
  n.BoolVal() -> ir.BoolVal(n)
  n.StringVal() -> ir.StringVal(n)
}
'

cd ../ir
rf '
mv CanInt64 Int64Val Uint64Val BoolVal StringVal val.go
rm Node.CanInt64 Node.Int64Val Node.Uint64Val Node.BoolVal Node.StringVal
'

Change-Id: I003140bda1690d770fd608bdd087e6d4ff00fb1f
Reviewed-on: https://go-review.googlesource.com/c/go/+/275032
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/gc/const.go     |  8 ++--
 src/cmd/compile/internal/gc/escape.go    |  2 +-
 src/cmd/compile/internal/gc/noder.go     |  6 +--
 src/cmd/compile/internal/gc/obj.go       |  4 +-
 src/cmd/compile/internal/gc/order.go     |  4 +-
 src/cmd/compile/internal/gc/sinit.go     | 14 +++---
 src/cmd/compile/internal/gc/ssa.go       | 10 ++--
 src/cmd/compile/internal/gc/swt.go       | 10 ++--
 src/cmd/compile/internal/gc/typecheck.go | 22 ++++-----
 src/cmd/compile/internal/gc/walk.go      | 30 ++++++------
 src/cmd/compile/internal/ir/name.go      | 56 ----------------------
 src/cmd/compile/internal/ir/node.go      |  5 --
 src/cmd/compile/internal/ir/val.go       | 60 +++++++++++++++++++++++-
 13 files changed, 113 insertions(+), 118 deletions(-)

diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 4a61c77630..8771d82cfa 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -526,7 +526,7 @@ func evalConst(n ir.Node) ir.Node {
 		if need == 1 {
 			var strs []string
 			for _, c := range s {
-				strs = append(strs, c.StringVal())
+				strs = append(strs, ir.StringVal(c))
 			}
 			return origConst(n, constant.MakeString(strings.Join(strs, "")))
 		}
@@ -537,7 +537,7 @@ func evalConst(n ir.Node) ir.Node {
 				var strs []string
 				i2 := i
 				for i2 < len(s) && ir.IsConst(s[i2], constant.String) {
-					strs = append(strs, s[i2].StringVal())
+					strs = append(strs, ir.StringVal(s[i2]))
 					i2++
 				}
 
@@ -558,7 +558,7 @@ func evalConst(n ir.Node) ir.Node {
 		switch nl.Type().Kind() {
 		case types.TSTRING:
 			if ir.IsConst(nl, constant.String) {
-				return origIntConst(n, int64(len(nl.StringVal())))
+				return origIntConst(n, int64(len(ir.StringVal(nl))))
 			}
 		case types.TARRAY:
 			if !hascallchan(nl) {
@@ -780,7 +780,7 @@ func indexconst(n ir.Node) int64 {
 	if doesoverflow(v, types.Types[types.TINT]) {
 		return -2
 	}
-	return ir.Int64Val(types.Types[types.TINT], v)
+	return ir.IntVal(types.Types[types.TINT], v)
 }
 
 // isGoConst reports whether n is a Go language constant (as opposed to a
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 9fc3dd2778..622edb9820 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -1769,7 +1769,7 @@ func heapAllocReason(n ir.Node) string {
 		if !smallintconst(r) {
 			return "non-constant size"
 		}
-		if t := n.Type(); t.Elem().Width != 0 && r.Int64Val() >= maxImplicitStackVarSize/t.Elem().Width {
+		if t := n.Type(); t.Elem().Width != 0 && ir.Int64Val(r) >= maxImplicitStackVarSize/t.Elem().Width {
 			return "too large for stack"
 		}
 	}
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 9352463f18..61320123a8 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -807,7 +807,7 @@ func (p *noder) sum(x syntax.Expr) ir.Node {
 	n := p.expr(x)
 	if ir.IsConst(n, constant.String) && n.Sym() == nil {
 		nstr = n
-		chunks = append(chunks, nstr.StringVal())
+		chunks = append(chunks, ir.StringVal(nstr))
 	}
 
 	for i := len(adds) - 1; i >= 0; i-- {
@@ -817,12 +817,12 @@ func (p *noder) sum(x syntax.Expr) ir.Node {
 		if ir.IsConst(r, constant.String) && r.Sym() == nil {
 			if nstr != nil {
 				// Collapse r into nstr instead of adding to n.
-				chunks = append(chunks, r.StringVal())
+				chunks = append(chunks, ir.StringVal(r))
 				continue
 			}
 
 			nstr = r
-			chunks = append(chunks, nstr.StringVal())
+			chunks = append(chunks, ir.StringVal(nstr))
 		} else {
 			if len(chunks) > 1 {
 				nstr.SetVal(constant.MakeString(strings.Join(chunks, "")))
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 21a50257b8..b1701b30a1 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -263,7 +263,7 @@ func dumpGlobalConst(n ir.Node) {
 			return
 		}
 	}
-	base.Ctxt.DwarfIntConst(base.Ctxt.Pkgpath, n.Sym().Name, typesymname(t), ir.Int64Val(t, v))
+	base.Ctxt.DwarfIntConst(base.Ctxt.Pkgpath, n.Sym().Name, typesymname(t), ir.IntVal(t, v))
 }
 
 func dumpglobls() {
@@ -598,7 +598,7 @@ func litsym(n, c ir.Node, wid int) {
 		s.WriteInt(base.Ctxt, n.Offset(), wid, i)
 
 	case constant.Int:
-		s.WriteInt(base.Ctxt, n.Offset(), wid, ir.Int64Val(n.Type(), u))
+		s.WriteInt(base.Ctxt, n.Offset(), wid, ir.IntVal(n.Type(), u))
 
 	case constant.Float:
 		f, _ := constant.Float64Val(u)
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index e4175bbf36..5440806e8e 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -1107,7 +1107,7 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 		haslit := false
 		for _, n1 := range n.List().Slice() {
 			hasbyte = hasbyte || n1.Op() == ir.OBYTES2STR
-			haslit = haslit || n1.Op() == ir.OLITERAL && len(n1.StringVal()) != 0
+			haslit = haslit || n1.Op() == ir.OLITERAL && len(ir.StringVal(n1)) != 0
 		}
 
 		if haslit && hasbyte {
@@ -1278,7 +1278,7 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 			var t *types.Type
 			switch n.Op() {
 			case ir.OSLICELIT:
-				t = types.NewArray(n.Type().Elem(), n.Right().Int64Val())
+				t = types.NewArray(n.Type().Elem(), ir.Int64Val(n.Right()))
 			case ir.OCALLPART:
 				t = partialCallType(n)
 			}
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 2dc4281857..3ef976d8aa 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -134,7 +134,7 @@ func (s *InitSchedule) staticcopy(l ir.Node, r ir.Node) bool {
 	case ir.OSLICELIT:
 		// copy slice
 		a := s.inittemps[r]
-		slicesym(l, a, r.Right().Int64Val())
+		slicesym(l, a, ir.Int64Val(r.Right()))
 		return true
 
 	case ir.OARRAYLIT, ir.OSTRUCTLIT:
@@ -213,7 +213,7 @@ func (s *InitSchedule) staticassign(l ir.Node, r ir.Node) bool {
 
 	case ir.OSTR2BYTES:
 		if l.Class() == ir.PEXTERN && r.Left().Op() == ir.OLITERAL {
-			sval := r.Left().StringVal()
+			sval := ir.StringVal(r.Left())
 			slicebytes(l, sval)
 			return true
 		}
@@ -221,7 +221,7 @@ func (s *InitSchedule) staticassign(l ir.Node, r ir.Node) bool {
 	case ir.OSLICELIT:
 		s.initplan(r)
 		// Init slice.
-		bound := r.Right().Int64Val()
+		bound := ir.Int64Val(r.Right())
 		ta := types.NewArray(r.Type().Elem(), bound)
 		ta.SetNoalg(true)
 		a := staticname(ta)
@@ -418,7 +418,7 @@ func getdyn(n ir.Node, top bool) initGenType {
 		if !top {
 			return initDynamic
 		}
-		if n.Right().Int64Val()/4 > int64(n.List().Len()) {
+		if ir.Int64Val(n.Right())/4 > int64(n.List().Len()) {
 			// <25% of entries have explicit values.
 			// Very rough estimation, it takes 4 bytes of instructions
 			// to initialize 1 byte of result. So don't use a static
@@ -594,12 +594,12 @@ func isSmallSliceLit(n ir.Node) bool {
 
 	r := n.Right()
 
-	return smallintconst(r) && (n.Type().Elem().Width == 0 || r.Int64Val() <= smallArrayBytes/n.Type().Elem().Width)
+	return smallintconst(r) && (n.Type().Elem().Width == 0 || ir.Int64Val(r) <= smallArrayBytes/n.Type().Elem().Width)
 }
 
 func slicelit(ctxt initContext, n ir.Node, var_ ir.Node, init *ir.Nodes) {
 	// make an array type corresponding the number of elements we have
-	t := types.NewArray(n.Type().Elem(), n.Right().Int64Val())
+	t := types.NewArray(n.Type().Elem(), ir.Int64Val(n.Right()))
 	dowidth(t)
 
 	if ctxt == inNonInitFunction {
@@ -997,7 +997,7 @@ func oaslit(n ir.Node, init *ir.Nodes) bool {
 
 func getlit(lit ir.Node) int {
 	if smallintconst(lit) {
-		return int(lit.Int64Val())
+		return int(ir.Int64Val(lit))
 	}
 	return -1
 }
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index d53bd1aa4f..89918e2133 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -1271,7 +1271,7 @@ func (s *state) stmt(n ir.Node) {
 			// We're assigning a slicing operation back to its source.
 			// Don't write back fields we aren't changing. See issue #14855.
 			i, j, k := rhs.SliceBounds()
-			if i != nil && (i.Op() == ir.OLITERAL && i.Val().Kind() == constant.Int && i.Int64Val() == 0) {
+			if i != nil && (i.Op() == ir.OLITERAL && i.Val().Kind() == constant.Int && ir.Int64Val(i) == 0) {
 				// [0:...] is the same as [:...]
 				i = nil
 			}
@@ -1301,7 +1301,7 @@ func (s *state) stmt(n ir.Node) {
 	case ir.OIF:
 		if ir.IsConst(n.Left(), constant.Bool) {
 			s.stmtList(n.Left().Init())
-			if n.Left().BoolVal() {
+			if ir.BoolVal(n.Left()) {
 				s.stmtList(n.Body())
 			} else {
 				s.stmtList(n.Rlist())
@@ -2041,7 +2041,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 	case ir.OLITERAL:
 		switch u := n.Val(); u.Kind() {
 		case constant.Int:
-			i := ir.Int64Val(n.Type(), u)
+			i := ir.IntVal(n.Type(), u)
 			switch n.Type().Size() {
 			case 1:
 				return s.constInt8(n.Type(), int8(i))
@@ -2624,7 +2624,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 				// Replace "abc"[1] with 'b'.
 				// Delayed until now because "abc"[1] is not an ideal constant.
 				// See test/fixedbugs/issue11370.go.
-				return s.newValue0I(ssa.OpConst8, types.Types[types.TUINT8], int64(int8(n.Left().StringVal()[n.Right().Int64Val()])))
+				return s.newValue0I(ssa.OpConst8, types.Types[types.TUINT8], int64(int8(ir.StringVal(n.Left())[ir.Int64Val(n.Right())])))
 			}
 			a := s.expr(n.Left())
 			i := s.expr(n.Right())
@@ -2633,7 +2633,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 			ptrtyp := s.f.Config.Types.BytePtr
 			ptr := s.newValue1(ssa.OpStringPtr, ptrtyp, a)
 			if ir.IsConst(n.Right(), constant.Int) {
-				ptr = s.newValue1I(ssa.OpOffPtr, ptrtyp, n.Right().Int64Val(), ptr)
+				ptr = s.newValue1I(ssa.OpOffPtr, ptrtyp, ir.Int64Val(n.Right()), ptr)
 			} else {
 				ptr = s.newValue2(ssa.OpAddPtr, ptrtyp, ptr, i)
 			}
diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index 30179e1dd6..e241721588 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -365,8 +365,8 @@ func (s *exprSwitch) flush() {
 		// all we need here is consistency. We respect this
 		// sorting below.
 		sort.Slice(cc, func(i, j int) bool {
-			si := cc[i].lo.StringVal()
-			sj := cc[j].lo.StringVal()
+			si := ir.StringVal(cc[i].lo)
+			sj := ir.StringVal(cc[j].lo)
 			if len(si) != len(sj) {
 				return len(si) < len(sj)
 			}
@@ -375,7 +375,7 @@ func (s *exprSwitch) flush() {
 
 		// runLen returns the string length associated with a
 		// particular run of exprClauses.
-		runLen := func(run []exprClause) int64 { return int64(len(run[0].lo.StringVal())) }
+		runLen := func(run []exprClause) int64 { return int64(len(ir.StringVal(run[0].lo))) }
 
 		// Collapse runs of consecutive strings with the same length.
 		var runs [][]exprClause
@@ -411,7 +411,7 @@ func (s *exprSwitch) flush() {
 		merged := cc[:1]
 		for _, c := range cc[1:] {
 			last := &merged[len(merged)-1]
-			if last.jmp == c.jmp && last.hi.Int64Val()+1 == c.lo.Int64Val() {
+			if last.jmp == c.jmp && ir.Int64Val(last.hi)+1 == ir.Int64Val(c.lo) {
 				last.hi = c.lo
 			} else {
 				merged = append(merged, c)
@@ -446,7 +446,7 @@ func (c *exprClause) test(exprname ir.Node) ir.Node {
 
 	// Optimize "switch true { ...}" and "switch false { ... }".
 	if ir.IsConst(exprname, constant.Bool) && !c.lo.Type().IsInterface() {
-		if exprname.BoolVal() {
+		if ir.BoolVal(exprname) {
 			return c.lo
 		} else {
 			return ir.NodAt(c.pos, ir.ONOT, c.lo, nil)
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 55443ba596..b19481311b 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -1054,8 +1054,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 					base.Errorf("invalid %s index %v (index must be non-negative)", why, n.Right())
 				} else if t.IsArray() && constant.Compare(x, token.GEQ, constant.MakeInt64(t.NumElem())) {
 					base.Errorf("invalid array index %v (out of bounds for %d-element array)", n.Right(), t.NumElem())
-				} else if ir.IsConst(n.Left(), constant.String) && constant.Compare(x, token.GEQ, constant.MakeInt64(int64(len(n.Left().StringVal())))) {
-					base.Errorf("invalid string index %v (out of bounds for %d-byte string)", n.Right(), len(n.Left().StringVal()))
+				} else if ir.IsConst(n.Left(), constant.String) && constant.Compare(x, token.GEQ, constant.MakeInt64(int64(len(ir.StringVal(n.Left()))))) {
+					base.Errorf("invalid string index %v (out of bounds for %d-byte string)", n.Right(), len(ir.StringVal(n.Left())))
 				} else if doesoverflow(x, types.Types[types.TINT]) {
 					base.Errorf("invalid %s index %v (index too large)", why, n.Right())
 				}
@@ -1146,11 +1146,11 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		l = defaultlit(l, types.Types[types.TINT])
 		c = defaultlit(c, types.Types[types.TINT])
 
-		if ir.IsConst(l, constant.Int) && l.Int64Val() < 0 {
+		if ir.IsConst(l, constant.Int) && ir.Int64Val(l) < 0 {
 			base.Fatalf("len for OSLICEHEADER must be non-negative")
 		}
 
-		if ir.IsConst(c, constant.Int) && c.Int64Val() < 0 {
+		if ir.IsConst(c, constant.Int) && ir.Int64Val(c) < 0 {
 			base.Fatalf("cap for OSLICEHEADER must be non-negative")
 		}
 
@@ -2173,8 +2173,8 @@ func checksliceindex(l ir.Node, r ir.Node, tp *types.Type) bool {
 		} else if tp != nil && tp.NumElem() >= 0 && constant.Compare(x, token.GTR, constant.MakeInt64(tp.NumElem())) {
 			base.Errorf("invalid slice index %v (out of bounds for %d-element array)", r, tp.NumElem())
 			return false
-		} else if ir.IsConst(l, constant.String) && constant.Compare(x, token.GTR, constant.MakeInt64(int64(len(l.StringVal())))) {
-			base.Errorf("invalid slice index %v (out of bounds for %d-byte string)", r, len(l.StringVal()))
+		} else if ir.IsConst(l, constant.String) && constant.Compare(x, token.GTR, constant.MakeInt64(int64(len(ir.StringVal(l))))) {
+			base.Errorf("invalid slice index %v (out of bounds for %d-byte string)", r, len(ir.StringVal(l)))
 			return false
 		} else if doesoverflow(x, types.Types[types.TINT]) {
 			base.Errorf("invalid slice index %v (index too large)", r)
@@ -3407,7 +3407,7 @@ func stringtoruneslit(n ir.Node) ir.Node {
 
 	var l []ir.Node
 	i := 0
-	for _, r := range n.Left().StringVal() {
+	for _, r := range ir.StringVal(n.Left()) {
 		l = append(l, ir.Nod(ir.OKEY, nodintconst(int64(i)), nodintconst(int64(r))))
 		i++
 	}
@@ -3803,7 +3803,7 @@ func deadcode(fn *ir.Func) {
 				return
 			}
 		case ir.OFOR:
-			if !ir.IsConst(n.Left(), constant.Bool) || n.Left().BoolVal() {
+			if !ir.IsConst(n.Left(), constant.Bool) || ir.BoolVal(n.Left()) {
 				return
 			}
 		default:
@@ -3833,7 +3833,7 @@ func deadcodeslice(nn *ir.Nodes) {
 			n.SetLeft(deadcodeexpr(n.Left()))
 			if ir.IsConst(n.Left(), constant.Bool) {
 				var body ir.Nodes
-				if n.Left().BoolVal() {
+				if ir.BoolVal(n.Left()) {
 					n.SetRlist(ir.Nodes{})
 					body = n.Body()
 				} else {
@@ -3876,7 +3876,7 @@ func deadcodeexpr(n ir.Node) ir.Node {
 		n.SetLeft(deadcodeexpr(n.Left()))
 		n.SetRight(deadcodeexpr(n.Right()))
 		if ir.IsConst(n.Left(), constant.Bool) {
-			if n.Left().BoolVal() {
+			if ir.BoolVal(n.Left()) {
 				return n.Right() // true && x => x
 			} else {
 				return n.Left() // false && x => false
@@ -3886,7 +3886,7 @@ func deadcodeexpr(n ir.Node) ir.Node {
 		n.SetLeft(deadcodeexpr(n.Left()))
 		n.SetRight(deadcodeexpr(n.Right()))
 		if ir.IsConst(n.Left(), constant.Bool) {
-			if n.Left().BoolVal() {
+			if ir.BoolVal(n.Left()) {
 				return n.Left() // true || x => true
 			} else {
 				return n.Right() // false || x => x
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index e72015c05e..ce7de1396b 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -1014,7 +1014,7 @@ opswitch:
 				// The SSA backend will handle those.
 				switch et {
 				case types.TINT64:
-					c := n.Right().Int64Val()
+					c := ir.Int64Val(n.Right())
 					if c < 0 {
 						c = -c
 					}
@@ -1022,7 +1022,7 @@ opswitch:
 						break opswitch
 					}
 				case types.TUINT64:
-					c := n.Right().Uint64Val()
+					c := ir.Uint64Val(n.Right())
 					if c < 1<<16 {
 						break opswitch
 					}
@@ -1072,7 +1072,7 @@ opswitch:
 				base.Errorf("index out of bounds")
 			}
 		} else if ir.IsConst(n.Left(), constant.String) {
-			n.SetBounded(bounded(r, int64(len(n.Left().StringVal()))))
+			n.SetBounded(bounded(r, int64(len(ir.StringVal(n.Left())))))
 			if base.Flag.LowerM != 0 && n.Bounded() && !ir.IsConst(n.Right(), constant.Int) {
 				base.Warn("index bounds check elided")
 			}
@@ -1507,7 +1507,7 @@ opswitch:
 	case ir.OSTR2BYTES:
 		s := n.Left()
 		if ir.IsConst(s, constant.String) {
-			sc := s.StringVal()
+			sc := ir.StringVal(s)
 
 			// Allocate a [n]byte of the right size.
 			t := types.NewArray(types.Types[types.TUINT8], int64(len(sc)))
@@ -1936,7 +1936,7 @@ func walkprint(nn ir.Node, init *ir.Nodes) ir.Node {
 	for i := 0; i < len(s); {
 		var strs []string
 		for i < len(s) && ir.IsConst(s[i], constant.String) {
-			strs = append(strs, s[i].StringVal())
+			strs = append(strs, ir.StringVal(s[i]))
 			i++
 		}
 		if len(strs) > 0 {
@@ -2016,7 +2016,7 @@ func walkprint(nn ir.Node, init *ir.Nodes) ir.Node {
 		case types.TSTRING:
 			cs := ""
 			if ir.IsConst(n, constant.String) {
-				cs = n.StringVal()
+				cs = ir.StringVal(n)
 			}
 			switch cs {
 			case " ":
@@ -2673,7 +2673,7 @@ func addstr(n ir.Node, init *ir.Nodes) ir.Node {
 		sz := int64(0)
 		for _, n1 := range n.List().Slice() {
 			if n1.Op() == ir.OLITERAL {
-				sz += int64(len(n1.StringVal()))
+				sz += int64(len(ir.StringVal(n1)))
 			}
 		}
 
@@ -3467,7 +3467,7 @@ func walkcompare(n ir.Node, init *ir.Nodes) ir.Node {
 
 func tracecmpArg(n ir.Node, t *types.Type, init *ir.Nodes) ir.Node {
 	// Ugly hack to avoid "constant -1 overflows uintptr" errors, etc.
-	if n.Op() == ir.OLITERAL && n.Type().IsSigned() && n.Int64Val() < 0 {
+	if n.Op() == ir.OLITERAL && n.Type().IsSigned() && ir.Int64Val(n) < 0 {
 		n = copyexpr(n, n.Type(), init)
 	}
 
@@ -3537,7 +3537,7 @@ func walkcompareString(n ir.Node, init *ir.Nodes) ir.Node {
 			// Length-only checks are ok, though.
 			maxRewriteLen = 0
 		}
-		if s := cs.StringVal(); len(s) <= maxRewriteLen {
+		if s := ir.StringVal(cs); len(s) <= maxRewriteLen {
 			if len(s) > 0 {
 				ncs = safeexpr(ncs, init)
 			}
@@ -3632,7 +3632,7 @@ func bounded(n ir.Node, max int64) bool {
 	bits := int32(8 * n.Type().Width)
 
 	if smallintconst(n) {
-		v := n.Int64Val()
+		v := ir.Int64Val(n)
 		return 0 <= v && v < max
 	}
 
@@ -3641,9 +3641,9 @@ func bounded(n ir.Node, max int64) bool {
 		v := int64(-1)
 		switch {
 		case smallintconst(n.Left()):
-			v = n.Left().Int64Val()
+			v = ir.Int64Val(n.Left())
 		case smallintconst(n.Right()):
-			v = n.Right().Int64Val()
+			v = ir.Int64Val(n.Right())
 			if n.Op() == ir.OANDNOT {
 				v = ^v
 				if !sign {
@@ -3657,7 +3657,7 @@ func bounded(n ir.Node, max int64) bool {
 
 	case ir.OMOD:
 		if !sign && smallintconst(n.Right()) {
-			v := n.Right().Int64Val()
+			v := ir.Int64Val(n.Right())
 			if 0 <= v && v <= max {
 				return true
 			}
@@ -3665,7 +3665,7 @@ func bounded(n ir.Node, max int64) bool {
 
 	case ir.ODIV:
 		if !sign && smallintconst(n.Right()) {
-			v := n.Right().Int64Val()
+			v := ir.Int64Val(n.Right())
 			for bits > 0 && v >= 2 {
 				bits--
 				v >>= 1
@@ -3674,7 +3674,7 @@ func bounded(n ir.Node, max int64) bool {
 
 	case ir.ORSH:
 		if !sign && smallintconst(n.Right()) {
-			v := n.Right().Int64Val()
+			v := ir.Int64Val(n.Right())
 			if v > int64(bits) {
 				return true
 			}
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 1d886bb9a1..aeeb63d2d6 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -296,62 +296,6 @@ func (n *Name) SetVal(v constant.Value) {
 	n.val = v
 }
 
-// Int64Val returns n as an int64.
-// n must be an integer or rune constant.
-func (n *Name) Int64Val() int64 {
-	if !IsConst(n, constant.Int) {
-		base.Fatalf("Int64Val(%v)", n)
-	}
-	x, ok := constant.Int64Val(n.Val())
-	if !ok {
-		base.Fatalf("Int64Val(%v)", n)
-	}
-	return x
-}
-
-// CanInt64 reports whether it is safe to call Int64Val() on n.
-func (n *Name) CanInt64() bool {
-	if !IsConst(n, constant.Int) {
-		return false
-	}
-
-	// if the value inside n cannot be represented as an int64, the
-	// return value of Int64 is undefined
-	_, ok := constant.Int64Val(n.Val())
-	return ok
-}
-
-// Uint64Val returns n as an uint64.
-// n must be an integer or rune constant.
-func (n *Name) Uint64Val() uint64 {
-	if !IsConst(n, constant.Int) {
-		base.Fatalf("Uint64Val(%v)", n)
-	}
-	x, ok := constant.Uint64Val(n.Val())
-	if !ok {
-		base.Fatalf("Uint64Val(%v)", n)
-	}
-	return x
-}
-
-// BoolVal returns n as a bool.
-// n must be a boolean constant.
-func (n *Name) BoolVal() bool {
-	if !IsConst(n, constant.Bool) {
-		base.Fatalf("BoolVal(%v)", n)
-	}
-	return constant.BoolVal(n.Val())
-}
-
-// StringVal returns the value of a literal string Node as a string.
-// n must be a string constant.
-func (n *Name) StringVal() string {
-	if !IsConst(n, constant.String) {
-		base.Fatalf("StringVal(%v)", n)
-	}
-	return constant.StringVal(n.Val())
-}
-
 // The Class of a variable/function describes the "storage class"
 // of a variable or function. During parsing, storage classes are
 // called declaration contexts.
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index cc3ac5765d..42ba4cb0e9 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -87,11 +87,6 @@ type Node interface {
 	MarkReadonly()
 	Val() constant.Value
 	SetVal(v constant.Value)
-	Int64Val() int64
-	Uint64Val() uint64
-	CanInt64() bool
-	BoolVal() bool
-	StringVal() string
 
 	// Storage for analysis passes.
 	Esc() uint16
diff --git a/src/cmd/compile/internal/ir/val.go b/src/cmd/compile/internal/ir/val.go
index aae965bb4c..ad0df5508d 100644
--- a/src/cmd/compile/internal/ir/val.go
+++ b/src/cmd/compile/internal/ir/val.go
@@ -32,7 +32,7 @@ func ConstValue(n Node) interface{} {
 	case constant.String:
 		return constant.StringVal(v)
 	case constant.Int:
-		return Int64Val(n.Type(), v)
+		return IntVal(n.Type(), v)
 	case constant.Float:
 		return Float64Val(v)
 	case constant.Complex:
@@ -42,7 +42,7 @@ func ConstValue(n Node) interface{} {
 
 // int64Val returns v converted to int64.
 // Note: if t is uint64, very large values will be converted to negative int64.
-func Int64Val(t *types.Type, v constant.Value) int64 {
+func IntVal(t *types.Type, v constant.Value) int64 {
 	if t.IsUnsigned() {
 		if x, ok := constant.Uint64Val(v); ok {
 			return int64(x)
@@ -118,3 +118,59 @@ func idealType(ct constant.Kind) *types.Type {
 }
 
 var OKForConst [types.NTYPE]bool
+
+// CanInt64 reports whether it is safe to call Int64Val() on n.
+func CanInt64(n Node) bool {
+	if !IsConst(n, constant.Int) {
+		return false
+	}
+
+	// if the value inside n cannot be represented as an int64, the
+	// return value of Int64 is undefined
+	_, ok := constant.Int64Val(n.Val())
+	return ok
+}
+
+// Int64Val returns n as an int64.
+// n must be an integer or rune constant.
+func Int64Val(n Node) int64 {
+	if !IsConst(n, constant.Int) {
+		base.Fatalf("Int64Val(%v)", n)
+	}
+	x, ok := constant.Int64Val(n.Val())
+	if !ok {
+		base.Fatalf("Int64Val(%v)", n)
+	}
+	return x
+}
+
+// Uint64Val returns n as an uint64.
+// n must be an integer or rune constant.
+func Uint64Val(n Node) uint64 {
+	if !IsConst(n, constant.Int) {
+		base.Fatalf("Uint64Val(%v)", n)
+	}
+	x, ok := constant.Uint64Val(n.Val())
+	if !ok {
+		base.Fatalf("Uint64Val(%v)", n)
+	}
+	return x
+}
+
+// BoolVal returns n as a bool.
+// n must be a boolean constant.
+func BoolVal(n Node) bool {
+	if !IsConst(n, constant.Bool) {
+		base.Fatalf("BoolVal(%v)", n)
+	}
+	return constant.BoolVal(n.Val())
+}
+
+// StringVal returns the value of a literal string Node as a string.
+// n must be a string constant.
+func StringVal(n Node) string {
+	if !IsConst(n, constant.String) {
+		base.Fatalf("StringVal(%v)", n)
+	}
+	return constant.StringVal(n.Val())
+}
-- 
GitLab


From a2058bac21f40925a33d7f99622c967b65827f29 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 2 Dec 2020 19:26:56 -0800
Subject: [PATCH 0141/2400] [dev.regabi] cmd/compile: add ConstExpr
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Currently, we represent constant-folded expressions with Name, which
is suboptimal because Name has a lot of fields to support declared
names (which are irrelevant to constant-folded expressions), while
constant expressions are fairly common.

This CL introduces a new lightweight ConstExpr type that simply wraps
an existing expression and associates it with a value.

Passes buildall w/ toolstash -cmp.

name                      old time/op       new time/op       delta
Template                        252ms ± 3%        254ms ± 1%     ~     (p=0.821 n=12+10)
Unicode                         120ms ± 2%        107ms ± 7%  -11.09%  (p=0.000 n=12+12)
GoTypes                         918ms ± 2%        918ms ± 1%     ~     (p=0.974 n=12+10)
Compiler                        5.19s ± 1%        5.18s ± 0%     ~     (p=0.190 n=12+11)
SSA                             12.4s ± 1%        12.3s ± 1%     ~     (p=0.283 n=10+12)
Flate                           152ms ± 2%        148ms ± 4%   -2.68%  (p=0.007 n=10+12)
GoParser                        212ms ± 1%        211ms ± 2%     ~     (p=0.674 n=10+12)
Reflect                         543ms ± 3%        542ms ± 3%     ~     (p=0.799 n=12+12)
Tar                             224ms ± 2%        225ms ± 2%     ~     (p=0.378 n=12+12)
XML                             292ms ± 1%        299ms ± 3%   +2.18%  (p=0.006 n=10+12)

name                      old user-time/op  new user-time/op  delta
Template                        243ms ± 4%        244ms ± 5%     ~     (p=0.887 n=12+12)
Unicode                         112ms ± 6%        100ms ±10%  -10.76%  (p=0.000 n=12+12)
GoTypes                         898ms ± 3%        895ms ± 3%     ~     (p=0.671 n=12+12)
Compiler                        5.10s ± 1%        5.08s ± 1%     ~     (p=0.104 n=12+11)
SSA                             12.2s ± 2%        12.1s ± 1%     ~     (p=0.487 n=11+12)
Flate                           144ms ± 6%        145ms ± 5%     ~     (p=0.695 n=12+11)
GoParser                        205ms ± 5%        204ms ± 3%     ~     (p=0.514 n=12+12)
Reflect                         528ms ± 3%        531ms ± 4%     ~     (p=0.630 n=12+12)
Tar                             218ms ± 4%        219ms ± 3%     ~     (p=0.843 n=12+12)
XML                             284ms ± 5%        291ms ± 5%     ~     (p=0.069 n=11+12)

name                      old alloc/op      new alloc/op      delta
Template                       37.0MB ± 0%       36.7MB ± 0%   -0.72%  (p=0.000 n=12+12)
Unicode                        31.9MB ± 0%       29.5MB ± 0%   -7.60%  (p=0.000 n=12+12)
GoTypes                         119MB ± 0%        118MB ± 0%   -0.40%  (p=0.000 n=12+12)
Compiler                        629MB ± 0%        626MB ± 0%   -0.36%  (p=0.000 n=11+12)
SSA                            1.45GB ± 0%       1.43GB ± 0%   -0.78%  (p=0.000 n=12+12)
Flate                          22.2MB ± 0%       21.9MB ± 0%   -1.12%  (p=0.000 n=12+12)
GoParser                       29.4MB ± 0%       29.3MB ± 0%   -0.36%  (p=0.000 n=12+12)
Reflect                        76.1MB ± 0%       75.8MB ± 0%   -0.38%  (p=0.000 n=12+12)
Tar                            33.4MB ± 0%       33.2MB ± 0%   -0.61%  (p=0.000 n=12+12)
XML                            43.2MB ± 0%       42.8MB ± 0%   -1.03%  (p=0.000 n=11+12)

name                      old allocs/op     new allocs/op     delta
Template                         375k ± 0%         375k ± 0%     ~     (p=0.854 n=12+12)
Unicode                          300k ± 0%         300k ± 0%     ~     (p=0.766 n=12+12)
GoTypes                         1.30M ± 0%        1.30M ± 0%     ~     (p=0.272 n=12+12)
Compiler                        5.89M ± 0%        5.89M ± 0%     ~     (p=0.478 n=12+12)
SSA                             14.0M ± 0%        14.0M ± 0%     ~     (p=0.266 n=12+12)
Flate                            226k ± 0%         226k ± 0%     ~     (p=0.898 n=12+12)
GoParser                         313k ± 0%         313k ± 0%   -0.01%  (p=0.042 n=12+11)
Reflect                          971k ± 0%         971k ± 0%     ~     (p=0.080 n=12+12)
Tar                              342k ± 0%         342k ± 0%     ~     (p=0.600 n=12+12)
XML                              416k ± 0%         416k ± 0%     ~     (p=0.217 n=11+12)

name                      old maxRSS/op     new maxRSS/op     delta
Template                        43.1M ± 5%        42.5M ± 5%     ~     (p=0.086 n=12+12)
Unicode                         49.4M ± 2%        47.0M ± 2%   -4.88%  (p=0.000 n=12+12)
GoTypes                         85.3M ± 2%        84.6M ± 2%   -0.84%  (p=0.047 n=11+11)
Compiler                         394M ± 3%         386M ± 2%   -1.97%  (p=0.000 n=10+11)
SSA                              847M ± 4%         821M ± 2%   -2.98%  (p=0.000 n=11+12)
Flate                           36.0M ± 7%        35.2M ± 7%     ~     (p=0.128 n=12+12)
GoParser                        39.4M ± 7%        39.5M ± 4%     ~     (p=0.413 n=12+11)
Reflect                         64.0M ± 3%        63.6M ± 3%     ~     (p=0.413 n=11+12)
Tar                             43.3M ± 5%        43.3M ± 5%     ~     (p=0.503 n=12+12)
XML                             47.6M ± 4%        46.4M ± 2%   -2.46%  (p=0.013 n=11+12)

Change-Id: If5781be346351c30b2228807211b5e57f777c506
Reviewed-on: https://go-review.googlesource.com/c/go/+/275033
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/const.go | 27 +++++++--------------------
 src/cmd/compile/internal/ir/expr.go  | 25 +++++++++++++++++++++++++
 2 files changed, 32 insertions(+), 20 deletions(-)

diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 8771d82cfa..9aa65f97b6 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -115,22 +115,12 @@ func convlit1(n ir.Node, t *types.Type, explicit bool, context func() string) ir
 		return n
 	}
 
-	if n.Op() == ir.OLITERAL || n.Op() == ir.ONIL {
-		// Can't always set n.Type directly on OLITERAL nodes.
-		// See discussion on CL 20813.
-		old := n
-		n = ir.Copy(old)
-		if old.Op() == ir.OLITERAL {
-			// Keep untyped constants in their original untyped syntax for error messages.
-			n.(ir.OrigNode).SetOrig(old)
-		}
-	}
-
 	// Nil is technically not a constant, so handle it specially.
 	if n.Type().Kind() == types.TNIL {
 		if n.Op() != ir.ONIL {
 			base.Fatalf("unexpected op: %v (%v)", n, n.Op())
 		}
+		n = ir.Copy(n)
 		if t == nil {
 			base.Errorf("use of untyped nil")
 			n.SetDiag(true)
@@ -158,10 +148,11 @@ func convlit1(n ir.Node, t *types.Type, explicit bool, context func() string) ir
 	case ir.OLITERAL:
 		v := convertVal(n.Val(), t, explicit)
 		if v.Kind() == constant.Unknown {
+			n = ir.NewConstExpr(n.Val(), n)
 			break
 		}
+		n = ir.NewConstExpr(v, n)
 		n.SetType(t)
-		n.SetVal(v)
 		return n
 
 	case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT, ir.OREAL, ir.OIMAG:
@@ -541,8 +532,9 @@ func evalConst(n ir.Node) ir.Node {
 					i2++
 				}
 
-				nl := origConst(s[i], constant.MakeString(strings.Join(strs, "")))
-				nl.(ir.OrigNode).SetOrig(nl) // it's bigger than just s[i]
+				nl := ir.Copy(n)
+				nl.PtrList().Set(s[i:i2])
+				nl = origConst(nl, constant.MakeString(strings.Join(strs, "")))
 				newList = append(newList, nl)
 				i = i2 - 1
 			} else {
@@ -645,12 +637,7 @@ func origConst(n ir.Node, v constant.Value) ir.Node {
 		return n
 	}
 
-	orig := n
-	n = ir.NodAt(orig.Pos(), ir.OLITERAL, nil, nil)
-	n.(ir.OrigNode).SetOrig(orig)
-	n.SetType(orig.Type())
-	n.SetVal(v)
-	return n
+	return ir.NewConstExpr(v, n)
 }
 
 func origBoolConst(n ir.Node, v bool) ir.Node {
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 2a7211cfda..412b7a18f0 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -9,6 +9,7 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"fmt"
+	"go/constant"
 )
 
 // A miniStmt is a miniNode with extra fields common to expressions.
@@ -300,6 +301,30 @@ func (n *CompLitExpr) SetOp(op Op) {
 	}
 }
 
+type ConstExpr struct {
+	miniExpr
+	val  constant.Value
+	orig Node
+}
+
+func NewConstExpr(val constant.Value, orig Node) Node {
+	n := &ConstExpr{orig: orig, val: val}
+	n.op = OLITERAL
+	n.pos = orig.Pos()
+	n.SetType(orig.Type())
+	n.SetTypecheck(orig.Typecheck())
+	n.SetDiag(orig.Diag())
+	return n
+}
+
+func (n *ConstExpr) String() string                { return fmt.Sprint(n) }
+func (n *ConstExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ConstExpr) rawCopy() Node                 { c := *n; return &c }
+func (n *ConstExpr) Sym() *types.Sym               { return n.orig.Sym() }
+func (n *ConstExpr) Orig() Node                    { return n.orig }
+func (n *ConstExpr) SetOrig(orig Node)             { n.orig = orig }
+func (n *ConstExpr) Val() constant.Value           { return n.val }
+
 // A ConvExpr is a conversion Type(X).
 // It may end up being a value or a type.
 type ConvExpr struct {
-- 
GitLab


From 351bc2f38c4291c01299c2add16f1f5a96e54bb4 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 2 Dec 2020 21:38:20 -0800
Subject: [PATCH 0142/2400] [dev.regabi] cmd/compile: store types.Field on
 {Selector,CallPart}Expr

It's useful to have quick access to the types.Field that a given
selector or method value expression refer to. Previously we abused Opt
for this, but couldn't do that for OCALLPART because escape analysis
uses Opt.

Now that we have more flexibility, we can simply add additional
pointer fields for this. This also allows getting rid of an unneeded
ONAME node for OCALLPART.

Passes buildall w/ toolstash -cmp.

Change-Id: I980d7bdb19abfd0b6f58a232876861b88dee1e47
Reviewed-on: https://go-review.googlesource.com/c/go/+/275034
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/closure.go   | 15 ++-------------
 src/cmd/compile/internal/gc/iexport.go   |  3 +--
 src/cmd/compile/internal/gc/inl.go       |  3 +++
 src/cmd/compile/internal/gc/typecheck.go | 14 +++++++-------
 src/cmd/compile/internal/gc/walk.go      |  2 +-
 src/cmd/compile/internal/ir/expr.go      | 15 ++++++++-------
 src/cmd/compile/internal/ir/fmt.go       |  4 ++--
 7 files changed, 24 insertions(+), 32 deletions(-)

diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index a5441a037a..01e5a953de 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -427,7 +427,7 @@ func typecheckpartialcall(dot ir.Node, sym *types.Sym) *ir.CallPartExpr {
 	fn := makepartialcall(dot, dot.Type(), sym)
 	fn.SetWrapper(true)
 
-	return ir.NewCallPartExpr(dot.Pos(), dot.Left(), NewName(sym), fn)
+	return ir.NewCallPartExpr(dot.Pos(), dot.Left(), dot.(*ir.SelectorExpr).Selection, fn)
 }
 
 // makepartialcall returns a DCLFUNC node representing the wrapper function (*-fm) needed
@@ -565,16 +565,5 @@ func walkpartialcall(n *ir.CallPartExpr, init *ir.Nodes) ir.Node {
 // callpartMethod returns the *types.Field representing the method
 // referenced by method value n.
 func callpartMethod(n ir.Node) *types.Field {
-	if n.Op() != ir.OCALLPART {
-		base.Fatalf("expected OCALLPART, got %v", n)
-	}
-
-	// TODO(mdempsky): Optimize this. If necessary,
-	// makepartialcall could save m for us somewhere.
-	var m *types.Field
-	if lookdot0(n.Right().Sym(), n.Left().Type(), &m, false) != 1 {
-		base.Fatalf("failed to find field for OCALLPART")
-	}
-
-	return m
+	return n.(*ir.CallPartExpr).Method
 }
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index 85518bc939..bb6f2b11e6 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -1290,8 +1290,7 @@ func (w *exportWriter) expr(n ir.Node) {
 		w.op(ir.OXDOT)
 		w.pos(n.Pos())
 		w.expr(n.Left())
-		// Right node should be ONAME
-		w.selector(n.Right().Sym())
+		w.selector(n.Sym())
 
 	case ir.OXDOT, ir.ODOT, ir.ODOTPTR, ir.ODOTINTER, ir.ODOTMETH:
 		w.op(ir.OXDOT)
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 42125f38f3..64f1b062be 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -430,6 +430,9 @@ func (v *hairyVisitor) visit(n ir.Node) bool {
 		// In any event, let the visitList(n.List()) below take care of the statements,
 		// and don't charge for the OBLOCK itself. The ++ undoes the -- below.
 		v.budget++
+
+	case ir.OCALLPART:
+		v.budget-- // Hack for toolstash -cmp.
 	}
 
 	v.budget--
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index b19481311b..e2100481aa 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -2385,7 +2385,7 @@ func typecheckMethodExpr(n ir.Node) (res ir.Node) {
 	me.SetType(methodfunc(m.Type, n.Left().Type()))
 	me.SetOffset(0)
 	me.SetClass(ir.PFUNC)
-	me.SetOpt(m)
+	me.(*ir.MethodExpr).Method = m
 
 	// Issue 25065. Make sure that we emit the symbol for a local method.
 	if base.Ctxt.Flag_dynlink && !inimport && (t.Sym() == nil || t.Sym().Pkg == ir.LocalPkg) {
@@ -2448,10 +2448,8 @@ func lookdot(n ir.Node, t *types.Type, dostrcmp int) *types.Field {
 			}
 
 			n.SetOp(ir.ODOTINTER)
-		} else {
-			n.SetOpt(f1)
 		}
-
+		n.(*ir.SelectorExpr).Selection = f1
 		return f1
 	}
 
@@ -2507,7 +2505,7 @@ func lookdot(n ir.Node, t *types.Type, dostrcmp int) *types.Field {
 		n.SetOffset(f2.Offset)
 		n.SetType(f2.Type)
 		n.SetOp(ir.ODOTMETH)
-		n.SetOpt(f2)
+		n.(*ir.SelectorExpr).Selection = f2
 
 		return f2
 	}
@@ -3933,8 +3931,10 @@ func methodExprName(n ir.Node) *ir.Name {
 // MethodFunc is like MethodName, but returns the types.Field instead.
 func methodExprFunc(n ir.Node) *types.Field {
 	switch n.Op() {
-	case ir.ODOTMETH, ir.OMETHEXPR:
-		return n.Opt().(*types.Field)
+	case ir.ODOTMETH:
+		return n.(*ir.SelectorExpr).Selection
+	case ir.OMETHEXPR:
+		return n.(*ir.MethodExpr).Method
 	case ir.OCALLPART:
 		return callpartMethod(n)
 	}
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index ce7de1396b..3d22c66d90 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -3757,7 +3757,7 @@ func usefield(n ir.Node) {
 	if t.IsPtr() {
 		t = t.Elem()
 	}
-	field := n.Opt().(*types.Field)
+	field := n.(*ir.SelectorExpr).Selection
 	if field == nil {
 		base.Fatalf("usefield %v %v without paramfld", n.Left().Type(), n.Sym())
 	}
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 412b7a18f0..18d85a01df 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -205,10 +205,10 @@ type CallPartExpr struct {
 	miniExpr
 	fn     *Func
 	X      Node
-	Method *Name
+	Method *types.Field
 }
 
-func NewCallPartExpr(pos src.XPos, x Node, method *Name, fn *Func) *CallPartExpr {
+func NewCallPartExpr(pos src.XPos, x Node, method *types.Field, fn *Func) *CallPartExpr {
 	n := &CallPartExpr{fn: fn, X: x, Method: method}
 	n.op = OCALLPART
 	n.pos = pos
@@ -222,9 +222,8 @@ func (n *CallPartExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *CallPartExpr) rawCopy() Node                 { c := *n; return &c }
 func (n *CallPartExpr) Func() *Func                   { return n.fn }
 func (n *CallPartExpr) Left() Node                    { return n.X }
-func (n *CallPartExpr) Right() Node                   { return n.Method }
+func (n *CallPartExpr) Sym() *types.Sym               { return n.Method.Sym }
 func (n *CallPartExpr) SetLeft(x Node)                { n.X = x }
-func (n *CallPartExpr) SetRight(x Node)               { n.Method = x.(*Name) }
 
 // A ClosureExpr is a function literal expression.
 type ClosureExpr struct {
@@ -499,6 +498,7 @@ type MethodExpr struct {
 	sym    *types.Sym
 	offset int64
 	class  Class
+	Method *types.Field
 }
 
 func NewMethodExpr(pos src.XPos, op Op, x, m Node) *MethodExpr {
@@ -596,9 +596,10 @@ func (n *ResultExpr) SetOffset(x int64)             { n.offset = x }
 // A SelectorExpr is a selector expression X.Sym.
 type SelectorExpr struct {
 	miniExpr
-	X      Node
-	Sel    *types.Sym
-	offset int64
+	X         Node
+	Sel       *types.Sym
+	offset    int64
+	Selection *types.Field
 }
 
 func NewSelectorExpr(pos src.XPos, x Node, sel *types.Sym) *SelectorExpr {
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 9486d8b021..45a66a2290 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -1382,11 +1382,11 @@ func exprFmt(n Node, s fmt.State, prec int, mode FmtMode) {
 
 	case OCALLPART:
 		exprFmt(n.Left(), s, nprec, mode)
-		if n.Right() == nil || n.Right().Sym() == nil {
+		if n.Sym() == nil {
 			fmt.Fprint(s, ".<nil>")
 			return
 		}
-		mode.Fprintf(s, ".%0S", n.Right().Sym())
+		mode.Fprintf(s, ".%0S", n.Sym())
 
 	case OXDOT, ODOT, ODOTPTR, ODOTINTER, ODOTMETH:
 		exprFmt(n.Left(), s, nprec, mode)
-- 
GitLab


From 9ff27e9fad185338b09141886b1041b82478b2d6 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 3 Dec 2020 11:11:05 -0800
Subject: [PATCH 0143/2400] [dev.typeparams] test: run all errorcheck tests
 that pass compiler with -G flag

Replace existing ad-hoc file exclusion mechanism with list of
excluded files; i.e., files for which the compiler with -G
option doesn't produce matching error messages yet.

Remove -G option since we now always run all passing tests.

Change-Id: I0655d2cf8bc135b3f50b1a811b8f49090c427580
Reviewed-on: https://go-review.googlesource.com/c/go/+/275212
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 test/run.go | 303 +++++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 255 insertions(+), 48 deletions(-)

diff --git a/test/run.go b/test/run.go
index d354646552..0a69fa62bc 100644
--- a/test/run.go
+++ b/test/run.go
@@ -39,7 +39,6 @@ var (
 	runSkips       = flag.Bool("run_skips", false, "run skipped tests (ignore skip and build tags)")
 	linkshared     = flag.Bool("linkshared", false, "")
 	updateErrors   = flag.Bool("update_errors", false, "update error messages in test file based on compiler output")
-	newTypechecker = flag.Bool("G", false, "generics typechecker. if set, run basic errorcheck tests also with new typechecker")
 	runoutputLimit = flag.Int("l", defaultRunOutputLimit(), "number of parallel runoutput tests to run")
 
 	shard  = flag.Int("shard", 0, "shard index to run. Only applicable if -shards is non-zero.")
@@ -742,10 +741,6 @@ func (t *test) run() {
 		}
 		t.err = t.errorCheck(string(out), wantAuto, long, t.gofile)
 
-		if t.err != nil || !*newTypechecker {
-			return
-		}
-
 		// The following is temporary scaffolding to get types2 typechecker
 		// up and running against the existing test cases. The explicitly
 		// listed files don't pass yet, usually because the error messages
@@ -755,53 +750,15 @@ func (t *test) run() {
 		// We can get rid of this code once types2 is fully plugged in.
 
 		// For now we're done when we can't handle the file or some of the flags.
-		// The first goal is to eliminate the file list; the second goal is to
+		// The first goal is to eliminate the excluded list; the second goal is to
 		// eliminate the flag list.
 
 		// Excluded files.
-		for _, file := range []string{
-			"complit1",
-			"const2",
-			"convlit.go",
-			"copy1.go",
-			"ddd1.go",
-			"devirt.go",
-			"directive.go",
-			"float_lit3.go",
-			"func1.go",
-			"funcdup.go",
-			"funcdup2.go",
-			"import1.go",
-			"import5.go",
-			"import6.go",
-			"init.go",
-			"initializerr.go",
-			"initloop.go",
-			"makechan.go",
-			"makemap.go",
-			"makenew.go",
-			"map1.go",
-			"method2.go",
-			"method6.go",
-			"named1.go",
-			"rename1.go",
-			"runtime.go",
-			"shift1.go",
-			"slice3err.go",
-			"switch3.go",
-			"switch4.go",
-			"switch5.go",
-			"switch6.go",
-			"switch7.go",
-			"typecheck.go",
-			"typecheckloop.go",
-			"typeswitch3.go",
-			"undef.go",
-			"varerr.go",
-		} {
-			if strings.Contains(long, file) {
-				return // cannot handle file
+		if excluded[t.goFileName()] {
+			if *verbose {
+				fmt.Printf("excl\t%s\n", t.goFileName())
 			}
+			return // cannot handle file yet
 		}
 
 		// Excluded flags.
@@ -824,6 +781,9 @@ func (t *test) run() {
 				"nil",
 			} {
 				if strings.Contains(flag, pattern) {
+					if *verbose {
+						fmt.Printf("excl\t%s\t%s\n", t.goFileName(), flags)
+					}
 					return // cannot handle flag
 				}
 			}
@@ -1952,3 +1912,250 @@ func overlayDir(dstRoot, srcRoot string) error {
 		return err
 	})
 }
+
+// List of files that the compiler cannot errorcheck with the new typechecker (compiler -G option).
+// Temporary scaffolding until we pass all the tests at which point this map can be removed.
+var excluded = map[string]bool{
+	"complit1.go":      true,
+	"const2.go":        true,
+	"convlit.go":       true,
+	"copy1.go":         true,
+	"ddd1.go":          true,
+	"devirt.go":        true,
+	"directive.go":     true,
+	"float_lit3.go":    true,
+	"func1.go":         true,
+	"funcdup.go":       true,
+	"funcdup2.go":      true,
+	"import1.go":       true,
+	"import5.go":       true,
+	"import6.go":       true,
+	"init.go":          true,
+	"initializerr.go":  true,
+	"initloop.go":      true,
+	"makechan.go":      true,
+	"makemap.go":       true,
+	"makenew.go":       true,
+	"map1.go":          true,
+	"method2.go":       true,
+	"method6.go":       true,
+	"named1.go":        true,
+	"rename1.go":       true,
+	"runtime.go":       true,
+	"shift1.go":        true,
+	"slice3err.go":     true,
+	"switch3.go":       true,
+	"switch4.go":       true,
+	"switch5.go":       true,
+	"switch6.go":       true,
+	"switch7.go":       true,
+	"typecheck.go":     true,
+	"typecheckloop.go": true,
+	"typeswitch3.go":   true,
+	"undef.go":         true,
+	"varerr.go":        true,
+
+	"fixedbugs/bug163.go":      true,
+	"fixedbugs/bug176.go":      true,
+	"fixedbugs/bug192.go":      true,
+	"fixedbugs/bug193.go":      true,
+	"fixedbugs/bug195.go":      true,
+	"fixedbugs/bug213.go":      true,
+	"fixedbugs/bug228.go":      true,
+	"fixedbugs/bug229.go":      true,
+	"fixedbugs/bug231.go":      true,
+	"fixedbugs/bug251.go":      true,
+	"fixedbugs/bug255.go":      true,
+	"fixedbugs/bug256.go":      true,
+	"fixedbugs/bug325.go":      true,
+	"fixedbugs/bug326.go":      true,
+	"fixedbugs/bug340.go":      true,
+	"fixedbugs/bug342.go":      true,
+	"fixedbugs/bug350.go":      true,
+	"fixedbugs/bug351.go":      true,
+	"fixedbugs/bug353.go":      true,
+	"fixedbugs/bug357.go":      true,
+	"fixedbugs/bug362.go":      true,
+	"fixedbugs/bug371.go":      true,
+	"fixedbugs/bug374.go":      true,
+	"fixedbugs/bug379.go":      true,
+	"fixedbugs/bug383.go":      true,
+	"fixedbugs/bug385_64.go":   true,
+	"fixedbugs/bug386.go":      true,
+	"fixedbugs/bug388.go":      true,
+	"fixedbugs/bug389.go":      true,
+	"fixedbugs/bug390.go":      true,
+	"fixedbugs/bug397.go":      true,
+	"fixedbugs/bug412.go":      true,
+	"fixedbugs/bug413.go":      true,
+	"fixedbugs/bug416.go":      true,
+	"fixedbugs/bug418.go":      true,
+	"fixedbugs/bug459.go":      true,
+	"fixedbugs/bug462.go":      true,
+	"fixedbugs/bug463.go":      true,
+	"fixedbugs/bug487.go":      true,
+	"fixedbugs/issue10975.go":  true,
+	"fixedbugs/issue11326.go":  true,
+	"fixedbugs/issue11361.go":  true,
+	"fixedbugs/issue11362.go":  true,
+	"fixedbugs/issue11371.go":  true,
+	"fixedbugs/issue11590.go":  true,
+	"fixedbugs/issue11610.go":  true,
+	"fixedbugs/issue11614.go":  true,
+	"fixedbugs/issue11674.go":  true,
+	"fixedbugs/issue11737.go":  true,
+	"fixedbugs/issue13365.go":  true,
+	"fixedbugs/issue13415.go":  true,
+	"fixedbugs/issue13471.go":  true,
+	"fixedbugs/issue13480.go":  true,
+	"fixedbugs/issue13485.go":  true,
+	"fixedbugs/issue13539.go":  true,
+	"fixedbugs/issue13559.go":  true,
+	"fixedbugs/issue14136.go":  true,
+	"fixedbugs/issue14321.go":  true,
+	"fixedbugs/issue14520.go":  true,
+	"fixedbugs/issue14540.go":  true,
+	"fixedbugs/issue14729.go":  true,
+	"fixedbugs/issue15055.go":  true,
+	"fixedbugs/issue15898.go":  true,
+	"fixedbugs/issue16428.go":  true,
+	"fixedbugs/issue16439.go":  true,
+	"fixedbugs/issue16949.go":  true,
+	"fixedbugs/issue17038.go":  true,
+	"fixedbugs/issue17588.go":  true,
+	"fixedbugs/issue17631.go":  true,
+	"fixedbugs/issue17645.go":  true,
+	"fixedbugs/issue18331.go":  true,
+	"fixedbugs/issue18392.go":  true,
+	"fixedbugs/issue18393.go":  true,
+	"fixedbugs/issue19012.go":  true,
+	"fixedbugs/issue19323.go":  true,
+	"fixedbugs/issue19482.go":  true,
+	"fixedbugs/issue19699b.go": true,
+	"fixedbugs/issue19880.go":  true,
+	"fixedbugs/issue19947.go":  true,
+	"fixedbugs/issue20185.go":  true,
+	"fixedbugs/issue20227.go":  true,
+	"fixedbugs/issue20233.go":  true,
+	"fixedbugs/issue20245.go":  true,
+	"fixedbugs/issue20298.go":  true,
+	"fixedbugs/issue20415.go":  true,
+	"fixedbugs/issue20529.go":  true,
+	"fixedbugs/issue20749.go":  true,
+	"fixedbugs/issue20780.go":  true,
+	"fixedbugs/issue21273.go":  true,
+	"fixedbugs/issue21882.go":  true,
+	"fixedbugs/issue21979.go":  true,
+	"fixedbugs/issue22200.go":  true,
+	"fixedbugs/issue22200b.go": true,
+	"fixedbugs/issue22389.go":  true,
+	"fixedbugs/issue22794.go":  true,
+	"fixedbugs/issue22822.go":  true,
+	"fixedbugs/issue22904.go":  true,
+	"fixedbugs/issue22921.go":  true,
+	"fixedbugs/issue23093.go":  true,
+	"fixedbugs/issue23094.go":  true,
+	"fixedbugs/issue23609.go":  true,
+	"fixedbugs/issue23732.go":  true,
+	"fixedbugs/issue23823.go":  true,
+	"fixedbugs/issue24339.go":  true,
+	"fixedbugs/issue24470.go":  true,
+	"fixedbugs/issue25507.go":  true,
+	"fixedbugs/issue25727.go":  true,
+	"fixedbugs/issue25958.go":  true,
+	"fixedbugs/issue26416.go":  true,
+	"fixedbugs/issue26616.go":  true,
+	"fixedbugs/issue27595.go":  true,
+	"fixedbugs/issue28079b.go": true,
+	"fixedbugs/issue28079c.go": true,
+	"fixedbugs/issue28268.go":  true,
+	"fixedbugs/issue28450.go":  true,
+	"fixedbugs/issue29855.go":  true,
+	"fixedbugs/issue30085.go":  true,
+	"fixedbugs/issue30087.go":  true,
+	"fixedbugs/issue31747.go":  true,
+	"fixedbugs/issue32133.go":  true,
+	"fixedbugs/issue32723.go":  true,
+	"fixedbugs/issue33460.go":  true,
+	"fixedbugs/issue34329.go":  true,
+	"fixedbugs/issue35291.go":  true,
+	"fixedbugs/issue38117.go":  true,
+	"fixedbugs/issue38745.go":  true,
+	"fixedbugs/issue3925.go":   true,
+	"fixedbugs/issue4085a.go":  true,
+	"fixedbugs/issue41247.go":  true,
+	"fixedbugs/issue41440.go":  true,
+	"fixedbugs/issue41500.go":  true,
+	"fixedbugs/issue41575.go":  true,
+	"fixedbugs/issue42058a.go": true,
+	"fixedbugs/issue42058b.go": true,
+	"fixedbugs/issue42075.go":  true,
+	"fixedbugs/issue4215.go":   true,
+	"fixedbugs/issue4232.go":   true,
+	"fixedbugs/issue4251.go":   true,
+	"fixedbugs/issue4429.go":   true,
+	"fixedbugs/issue4452.go":   true,
+	"fixedbugs/issue4458.go":   true,
+	"fixedbugs/issue4470.go":   true,
+	"fixedbugs/issue4517d.go":  true,
+	"fixedbugs/issue4847.go":   true,
+	"fixedbugs/issue4909a.go":  true,
+	"fixedbugs/issue5609.go":   true,
+	"fixedbugs/issue6402.go":   true,
+	"fixedbugs/issue6403.go":   true,
+	"fixedbugs/issue6500.go":   true,
+	"fixedbugs/issue6572.go":   true,
+	"fixedbugs/issue6703a.go":  true,
+	"fixedbugs/issue6703b.go":  true,
+	"fixedbugs/issue6703c.go":  true,
+	"fixedbugs/issue6703d.go":  true,
+	"fixedbugs/issue6703e.go":  true,
+	"fixedbugs/issue6703f.go":  true,
+	"fixedbugs/issue6703g.go":  true,
+	"fixedbugs/issue6703h.go":  true,
+	"fixedbugs/issue6703i.go":  true,
+	"fixedbugs/issue6703j.go":  true,
+	"fixedbugs/issue6703k.go":  true,
+	"fixedbugs/issue6703l.go":  true,
+	"fixedbugs/issue6703m.go":  true,
+	"fixedbugs/issue6703n.go":  true,
+	"fixedbugs/issue6703o.go":  true,
+	"fixedbugs/issue6703p.go":  true,
+	"fixedbugs/issue6703q.go":  true,
+	"fixedbugs/issue6703r.go":  true,
+	"fixedbugs/issue6703s.go":  true,
+	"fixedbugs/issue6703t.go":  true,
+	"fixedbugs/issue6703u.go":  true,
+	"fixedbugs/issue6703v.go":  true,
+	"fixedbugs/issue6703w.go":  true,
+	"fixedbugs/issue6703x.go":  true,
+	"fixedbugs/issue6703y.go":  true,
+	"fixedbugs/issue6703z.go":  true,
+	"fixedbugs/issue6750.go":   true,
+	"fixedbugs/issue6772.go":   true,
+	"fixedbugs/issue6889.go":   true,
+	"fixedbugs/issue7129.go":   true,
+	"fixedbugs/issue7150.go":   true,
+	"fixedbugs/issue7153.go":   true,
+	"fixedbugs/issue7223.go":   true,
+	"fixedbugs/issue7310.go":   true,
+	"fixedbugs/issue7525.go":   true,
+	"fixedbugs/issue7525b.go":  true,
+	"fixedbugs/issue7525c.go":  true,
+	"fixedbugs/issue7525d.go":  true,
+	"fixedbugs/issue7525e.go":  true,
+	"fixedbugs/issue7742.go":   true, // type-checking doesn't terminate
+	"fixedbugs/issue7746.go":   true, // type-checking doesn't terminate
+	"fixedbugs/issue8501.go":   true, // crashes
+	"fixedbugs/issue8507.go":   true, // crashes
+	"fixedbugs/issue8183.go":   true,
+	"fixedbugs/issue8385.go":   true,
+	"fixedbugs/issue8438.go":   true,
+	"fixedbugs/issue8440.go":   true,
+	"fixedbugs/issue8745.go":   true,
+	"fixedbugs/issue9083.go":   true,
+	"fixedbugs/issue9370.go":   true,
+	"fixedbugs/issue9432.go":   true,
+	"fixedbugs/issue9521.go":   true,
+	"fixedbugs/issue9634.go":   true,
+}
-- 
GitLab


From 84cb51d7d7a936d56d6287ca075dd578097499a9 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 3 Dec 2020 11:56:29 -0800
Subject: [PATCH 0144/2400] [dev.regabi] cmd/compile: eliminate more SetOrig

This CL consolidates and cleans up fmt.go's logic for skipping past
Nodes introduced during typechecking. This allows eliminating SetOrig
on ConvExpr and Name. Also changes ConstExpr.SetOrig to a panic for
good measure.

The only remaining SetOrig uses now are for rewriting multi-value
"f(g())" calls and "return g()" statements, and type-checking
composite literals. It should be possible to eliminate both of those
as well.

Passes buildall w/ toolstash -cmp.

Change-Id: I478aea1a17dfb7a784293b930bf9081637eb2d7a
Reviewed-on: https://go-review.googlesource.com/c/go/+/275179
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/gc/subr.go |  1 -
 src/cmd/compile/internal/ir/expr.go |  4 +--
 src/cmd/compile/internal/ir/fmt.go  | 47 +++++++++++++++--------------
 src/cmd/compile/internal/ir/name.go |  2 --
 4 files changed, 26 insertions(+), 28 deletions(-)

diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 970f78b355..65eb61e680 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -523,7 +523,6 @@ func assignconvfn(n ir.Node, t *types.Type, context func() string) ir.Node {
 	r.SetType(t)
 	r.SetTypecheck(1)
 	r.SetImplicit(true)
-	r.(ir.OrigNode).SetOrig(ir.Orig(n))
 	return r
 }
 
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 18d85a01df..49543f4286 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -321,7 +321,7 @@ func (n *ConstExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *ConstExpr) rawCopy() Node                 { c := *n; return &c }
 func (n *ConstExpr) Sym() *types.Sym               { return n.orig.Sym() }
 func (n *ConstExpr) Orig() Node                    { return n.orig }
-func (n *ConstExpr) SetOrig(orig Node)             { n.orig = orig }
+func (n *ConstExpr) SetOrig(orig Node)             { panic(n.no("SetOrig")) }
 func (n *ConstExpr) Val() constant.Value           { return n.val }
 
 // A ConvExpr is a conversion Type(X).
@@ -344,8 +344,6 @@ func NewConvExpr(pos src.XPos, op Op, typ *types.Type, x Node) *ConvExpr {
 func (n *ConvExpr) String() string                { return fmt.Sprint(n) }
 func (n *ConvExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *ConvExpr) rawCopy() Node                 { c := *n; return &c }
-func (n *ConvExpr) Orig() Node                    { return n.orig }
-func (n *ConvExpr) SetOrig(x Node)                { n.orig = x }
 func (n *ConvExpr) Left() Node                    { return n.X }
 func (n *ConvExpr) SetLeft(x Node)                { n.X = x }
 
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 45a66a2290..bc5536241e 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -1071,6 +1071,7 @@ var OpPrec = []int{
 	OCALL:          8,
 	OCAP:           8,
 	OCLOSE:         8,
+	OCOMPLIT:       8,
 	OCONVIFACE:     8,
 	OCONVNOP:       8,
 	OCONV:          8,
@@ -1179,13 +1180,28 @@ var OpPrec = []int{
 }
 
 func exprFmt(n Node, s fmt.State, prec int, mode FmtMode) {
-	for n != nil && n.Implicit() && (n.Op() == ODEREF || n.Op() == OADDR) {
-		n = n.Left()
-	}
+	for {
+		if n == nil {
+			fmt.Fprint(s, "<N>")
+			return
+		}
 
-	if n == nil {
-		fmt.Fprint(s, "<N>")
-		return
+		// We always want the original, if any.
+		if o := Orig(n); o != n {
+			n = o
+			continue
+		}
+
+		// Skip implicit operations introduced during typechecking.
+		switch n.Op() {
+		case OADDR, ODEREF, OCONV, OCONVNOP, OCONVIFACE:
+			if n.Implicit() {
+				n = n.Left()
+				continue
+			}
+		}
+
+		break
 	}
 
 	nprec := OpPrec[n.Op()]
@@ -1206,15 +1222,9 @@ func exprFmt(n Node, s fmt.State, prec int, mode FmtMode) {
 		fmt.Fprint(s, "nil")
 
 	case OLITERAL: // this is a bit of a mess
-		if mode == FErr {
-			if orig := Orig(n); orig != nil && orig != n {
-				exprFmt(orig, s, prec, mode)
-				return
-			}
-			if n.Sym() != nil {
-				fmt.Fprint(s, smodeString(n.Sym(), mode))
-				return
-			}
+		if mode == FErr && n.Sym() != nil {
+			fmt.Fprint(s, smodeString(n.Sym(), mode))
+			return
 		}
 
 		needUnparen := false
@@ -1558,13 +1568,6 @@ func exprFmt(n Node, s fmt.State, prec int, mode FmtMode) {
 
 func nodeFmt(n Node, s fmt.State, flag FmtFlag, mode FmtMode) {
 	t := n.Type()
-
-	// We almost always want the original.
-	// TODO(gri) Why the special case for OLITERAL?
-	if n.Op() != OLITERAL && Orig(n) != nil {
-		n = Orig(n)
-	}
-
 	if flag&FmtLong != 0 && t != nil {
 		if t.Kind() == types.TNIL {
 			fmt.Fprint(s, "nil")
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index aeeb63d2d6..67d4d2b391 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -155,8 +155,6 @@ func (n *Name) rawCopy() Node                 { c := *n; return &c }
 func (n *Name) Name() *Name                   { return n }
 func (n *Name) Sym() *types.Sym               { return n.sym }
 func (n *Name) SetSym(x *types.Sym)           { n.sym = x }
-func (n *Name) Orig() Node                    { return n.orig }
-func (n *Name) SetOrig(x Node)                { n.orig = x }
 func (n *Name) SubOp() Op                     { return n.subOp }
 func (n *Name) SetSubOp(x Op)                 { n.subOp = x }
 func (n *Name) Class() Class                  { return n.class }
-- 
GitLab


From 99ecfcae31e52a297195b2c1d1d9326e16d6c775 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 3 Dec 2020 15:40:46 -0500
Subject: [PATCH 0145/2400] [dev.regabi] cmd/compile: swap inlining order of if
 then vs else blocks

The upcoming general iterators will process nodes in
source code order, meaning that the "then" block comes
before the "else" block. But for an if node, "then" is Body
while "else" is Rlist, and the inliner processes Rlist first.

The order of processing changes the order of inlining decisions,
which can affect which functions are inlined, but in general
won't affect much. (It's not like we know that we should prefer
to inline functions in else bodies over then bodies.)

Swapping these is not safe for toolstash -cmp.
Doing it in a separate CL lets the upcoming CLs all be toolstash-safe.

Change-Id: Id16172849239b0564930d2bbff1260ad6d03d5ab
Reviewed-on: https://go-review.googlesource.com/c/go/+/275308
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/inl.go | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 64f1b062be..980ba7429a 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -638,6 +638,14 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool) ir.Node {
 		}
 	}
 
+	inlnodelist(n.Body(), maxCost, inlMap)
+	s = n.Body().Slice()
+	for i, n1 := range s {
+		if n1.Op() == ir.OINLCALL {
+			s[i] = inlconv2stmt(n1)
+		}
+	}
+
 	inlnodelist(n.Rlist(), maxCost, inlMap)
 
 	if n.Op() == ir.OAS2FUNC && n.Rlist().First().Op() == ir.OINLCALL {
@@ -658,14 +666,6 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool) ir.Node {
 		}
 	}
 
-	inlnodelist(n.Body(), maxCost, inlMap)
-	s = n.Body().Slice()
-	for i, n1 := range s {
-		if n1.Op() == ir.OINLCALL {
-			s[i] = inlconv2stmt(n1)
-		}
-	}
-
 	// with all the branches out of the way, it is now time to
 	// transmogrify this node itself unless inhibited by the
 	// switch at the top of this function.
-- 
GitLab


From 989a3f5041d2055e165e363d3fb2d27e75e2fa38 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 2 Dec 2020 22:42:24 -0500
Subject: [PATCH 0146/2400] [dev.regabi] cmd/compile: adjustments to Copy and
 DeepCopy

DeepCopy is not called DeepSepCopy, so it should use Copy, not SepCopy.

Also, the old gc.treecopy, which became ir.DeepCopy, only copied
the Left, Right, and List fields - not Init, Rlist, Body - and I didn't
notice when I moved it over. A general utility function should of
course copy the whole node, so do that.

Finally, the semantics of Copy should not depend on whether a
particular child node is held directly in a field or in a slice,
so make Copy duplicate the slice backing arrays as well.
(Logically, those backing arrays are part of the node storage.)

Passes buildall w/ toolstash -cmp.

Change-Id: I18fbe3f2b40078f566ed6370684d5585052b36a1
Reviewed-on: https://go-review.googlesource.com/c/go/+/275309
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/copy.go | 43 +++++++++++++++++++++++++++--
 1 file changed, 40 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/ir/copy.go b/src/cmd/compile/internal/ir/copy.go
index a356074bb8..705de0195b 100644
--- a/src/cmd/compile/internal/ir/copy.go
+++ b/src/cmd/compile/internal/ir/copy.go
@@ -61,9 +61,33 @@ func Copy(n Node) Node {
 	if n, ok := n.(OrigNode); ok && n.Orig() == n {
 		copy.(OrigNode).SetOrig(copy)
 	}
+
+	// Copy lists so that updates to n.List[0]
+	// don't affect copy.List[0] and vice versa,
+	// same as updates to Left and Right.
+	// TODO(rsc): Eventually the Node implementations will need to do this.
+	if l := copy.List(); l.Len() > 0 {
+		copy.SetList(copyList(l))
+	}
+	if l := copy.Rlist(); l.Len() > 0 {
+		copy.SetRlist(copyList(l))
+	}
+	if l := copy.Init(); l.Len() > 0 {
+		copy.SetInit(copyList(l))
+	}
+	if l := copy.Body(); l.Len() > 0 {
+		copy.SetBody(copyList(l))
+	}
+
 	return copy
 }
 
+func copyList(x Nodes) Nodes {
+	out := make([]Node, x.Len())
+	copy(out, x.Slice())
+	return AsNodes(out)
+}
+
 // A Node can implement DeepCopyNode to provide a custom implementation
 // of DeepCopy. If the compiler only needs access to a Node's structure during
 // DeepCopy, then a Node can implement DeepCopyNode instead of providing
@@ -94,10 +118,15 @@ func DeepCopy(pos src.XPos, n Node) Node {
 
 	switch n.Op() {
 	default:
-		m := SepCopy(n)
+		m := Copy(n)
 		m.SetLeft(DeepCopy(pos, n.Left()))
 		m.SetRight(DeepCopy(pos, n.Right()))
-		m.PtrList().Set(deepCopyList(pos, n.List().Slice()))
+		// deepCopyList instead of DeepCopyList
+		// because Copy already copied all these slices.
+		deepCopyList(pos, m.PtrList().Slice())
+		deepCopyList(pos, m.PtrRlist().Slice())
+		deepCopyList(pos, m.PtrInit().Slice())
+		deepCopyList(pos, m.PtrBody().Slice())
 		if pos.IsKnown() {
 			m.SetPos(pos)
 		}
@@ -118,10 +147,18 @@ func DeepCopy(pos src.XPos, n Node) Node {
 	}
 }
 
-func deepCopyList(pos src.XPos, list []Node) []Node {
+// 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
 }
+
+// deepCopyList edits list to point to deep copies of its elements.
+func deepCopyList(pos src.XPos, list []Node) {
+	for i, n := range list {
+		list[i] = DeepCopy(pos, n)
+	}
+}
-- 
GitLab


From 7fcf5b994cf24dc7eda4d65d448e25489dd357f6 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 2 Dec 2020 22:54:33 -0500
Subject: [PATCH 0147/2400] [dev.regabi] cmd/compile: replace inlcopy with
 ir.DeepCopy

Now inlcopy and ir.DeepCopy are semantically the same,
so drop the inlcopy implementation.

Passes buildall w/ toolstash -cmp.

Change-Id: Id2abb39a412a8e57167a29be5ecf76e990dc9d3d
Reviewed-on: https://go-review.googlesource.com/c/go/+/275310
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/inl.go | 37 +-----------------------------
 1 file changed, 1 insertion(+), 36 deletions(-)

diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 980ba7429a..efd6fea844 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -218,7 +218,7 @@ func caninl(fn *ir.Func) {
 	n.Func().Inl = &ir.Inline{
 		Cost: inlineMaxBudget - visitor.budget,
 		Dcl:  pruneUnusedAutos(n.Defn.Func().Dcl, &visitor),
-		Body: inlcopylist(fn.Body().Slice()),
+		Body: ir.DeepCopyList(src.NoXPos, fn.Body().Slice()),
 	}
 
 	if base.Flag.LowerM > 1 {
@@ -447,41 +447,6 @@ func (v *hairyVisitor) visit(n ir.Node) bool {
 		v.visitList(n.Init()) || v.visitList(n.Body())
 }
 
-// inlcopylist (together with inlcopy) recursively copies a list of nodes, except
-// that it keeps the same ONAME, OTYPE, and OLITERAL nodes. It is used for copying
-// the body and dcls of an inlineable function.
-func inlcopylist(ll []ir.Node) []ir.Node {
-	s := make([]ir.Node, 0, len(ll))
-	for _, n := range ll {
-		s = append(s, inlcopy(n))
-	}
-	return s
-}
-
-func inlcopy(n ir.Node) ir.Node {
-	if n == nil {
-		return nil
-	}
-
-	switch n.Op() {
-	case ir.ONAME, ir.OTYPE, ir.OLITERAL, ir.ONIL:
-		return n
-	}
-
-	m := ir.Copy(n)
-	if n.Op() != ir.OCALLPART && m.Func() != nil {
-		base.Fatalf("unexpected Func: %v", m)
-	}
-	m.SetLeft(inlcopy(n.Left()))
-	m.SetRight(inlcopy(n.Right()))
-	m.PtrList().Set(inlcopylist(n.List().Slice()))
-	m.PtrRlist().Set(inlcopylist(n.Rlist().Slice()))
-	m.PtrInit().Set(inlcopylist(n.Init().Slice()))
-	m.PtrBody().Set(inlcopylist(n.Body().Slice()))
-
-	return m
-}
-
 func countNodes(n ir.Node) int {
 	if n == nil {
 		return 0
-- 
GitLab


From 0d1b44c6457bcfad611252175934e82f73440475 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 3 Dec 2020 12:57:38 -0500
Subject: [PATCH 0148/2400] [dev.regabi] cmd/compile: introduce IR visitors

This CL introduces the general visitor functionality that will replace
the Left, SetLeft, Right, SetRight, etc methods in the Node interface.

For now, the CL defines the functionality in terms of those methods,
but eventually the Nodes themselves will implement DoChildren
and EditChildren and be relieved of implementing Left, SetLeft, and so on.

The CL also updates Inspect (which moved to visit.go) and DeepCopy
to use the new functionality.

The Find helper is not used in this CL but will be used in a future one.

Passes buildall w/ toolstash -cmp.

Change-Id: Id0eea654a884ab3ea25f48bd8bdd71712b5dcb44
Reviewed-on: https://go-review.googlesource.com/c/go/+/275311
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/copy.go  |  57 ++----
 src/cmd/compile/internal/ir/node.go  |  20 --
 src/cmd/compile/internal/ir/visit.go | 273 +++++++++++++++++++++++++++
 3 files changed, 289 insertions(+), 61 deletions(-)
 create mode 100644 src/cmd/compile/internal/ir/visit.go

diff --git a/src/cmd/compile/internal/ir/copy.go b/src/cmd/compile/internal/ir/copy.go
index 705de0195b..2f340df1ab 100644
--- a/src/cmd/compile/internal/ir/copy.go
+++ b/src/cmd/compile/internal/ir/copy.go
@@ -107,44 +107,26 @@ type DeepCopyNode interface {
 //
 // If a Node wishes to provide an alternate implementation, it can
 // implement a DeepCopy method: see the DeepCopyNode interface.
+//
+// TODO(rsc): Once Nodes implement EditChildren, remove the DeepCopyNode interface.
 func DeepCopy(pos src.XPos, n Node) Node {
-	if n == nil {
-		return nil
-	}
-
-	if n, ok := n.(DeepCopyNode); ok {
-		return n.DeepCopy(pos)
-	}
-
-	switch n.Op() {
-	default:
-		m := Copy(n)
-		m.SetLeft(DeepCopy(pos, n.Left()))
-		m.SetRight(DeepCopy(pos, n.Right()))
-		// deepCopyList instead of DeepCopyList
-		// because Copy already copied all these slices.
-		deepCopyList(pos, m.PtrList().Slice())
-		deepCopyList(pos, m.PtrRlist().Slice())
-		deepCopyList(pos, m.PtrInit().Slice())
-		deepCopyList(pos, m.PtrBody().Slice())
-		if pos.IsKnown() {
-			m.SetPos(pos)
+	var edit func(Node) Node
+	edit = func(x Node) Node {
+		if x, ok := x.(DeepCopyNode); ok {
+			return x.DeepCopy(pos)
 		}
-		if m.Name() != nil {
-			Dump("DeepCopy", n)
-			base.Fatalf("DeepCopy Name")
+		switch x.Op() {
+		case OPACK, ONAME, ONONAME, OLITERAL, ONIL, OTYPE:
+			return x
 		}
-		return m
-
-	case OPACK:
-		// OPACK nodes are never valid in const value declarations,
-		// but allow them like any other declared symbol to avoid
-		// crashing (golang.org/issue/11361).
-		fallthrough
-
-	case ONAME, ONONAME, OLITERAL, ONIL, OTYPE:
-		return n
+		x = Copy(x)
+		if pos.IsKnown() {
+			x.SetPos(pos)
+		}
+		EditChildren(x, edit)
+		return x
 	}
+	return edit(n)
 }
 
 // DeepCopyList returns a list of deep copies (using DeepCopy) of the nodes in list.
@@ -155,10 +137,3 @@ func DeepCopyList(pos src.XPos, list []Node) []Node {
 	}
 	return out
 }
-
-// deepCopyList edits list to point to deep copies of its elements.
-func deepCopyList(pos src.XPos, list []Node) {
-	for i, n := range list {
-		list[i] = DeepCopy(pos, n)
-	}
-}
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 42ba4cb0e9..c3184a3a0b 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -521,26 +521,6 @@ func (n *Nodes) AppendNodes(n2 *Nodes) {
 	n2.slice = nil
 }
 
-// inspect invokes f on each node in an AST in depth-first order.
-// If f(n) returns false, inspect skips visiting n's children.
-func Inspect(n Node, f func(Node) bool) {
-	if n == nil || !f(n) {
-		return
-	}
-	InspectList(n.Init(), f)
-	Inspect(n.Left(), f)
-	Inspect(n.Right(), f)
-	InspectList(n.List(), f)
-	InspectList(n.Body(), f)
-	InspectList(n.Rlist(), f)
-}
-
-func InspectList(l Nodes, f func(Node) bool) {
-	for _, n := range l.Slice() {
-		Inspect(n, f)
-	}
-}
-
 // nodeQueue is a FIFO queue of *Node. The zero value of nodeQueue is
 // a ready-to-use empty queue.
 type NodeQueue struct {
diff --git a/src/cmd/compile/internal/ir/visit.go b/src/cmd/compile/internal/ir/visit.go
new file mode 100644
index 0000000000..a239fd1532
--- /dev/null
+++ b/src/cmd/compile/internal/ir/visit.go
@@ -0,0 +1,273 @@
+// Copyright 2020 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.
+
+// IR visitors for walking the IR tree.
+//
+// The lowest level helpers are DoChildren and EditChildren,
+// which nodes help implement (TODO(rsc): eventually) and
+// provide control over whether and when recursion happens
+// during the walk of the IR.
+//
+// Although these are both useful directly, two simpler patterns
+// are fairly common and also provided: Inspect and Scan.
+
+package ir
+
+import "errors"
+
+// DoChildren calls do(x) on each of n's non-nil child nodes x.
+// If any call returns a non-nil error, DoChildren stops and returns that error.
+// Otherwise, DoChildren returns nil.
+//
+// Note that DoChildren(n, do) only calls do(x) for n's immediate children.
+// If x's children should be processed, then do(x) must call DoChildren(x, do).
+//
+// DoChildren allows constructing general traversals of the IR graph
+// that can stop early if needed. The most general usage is:
+//
+//	var do func(ir.Node) error
+//	do = func(x ir.Node) error {
+//		... processing BEFORE visting children ...
+//		if ... should visit children ... {
+//			ir.DoChildren(x, do)
+//			... processing AFTER visting children ...
+//		}
+//		if ... should stop parent DoChildren call from visiting siblings ... {
+//			return non-nil error
+//		}
+//		return nil
+//	}
+//	do(root)
+//
+// Since DoChildren does not generate any errors itself, if the do function
+// never wants to stop the traversal, it can assume that DoChildren itself
+// will always return nil, simplifying to:
+//
+//	var do func(ir.Node) error
+//	do = func(x ir.Node) error {
+//		... processing BEFORE visting children ...
+//		if ... should visit children ... {
+//			ir.DoChildren(x, do)
+//		}
+//		... processing AFTER visting children ...
+//		return nil
+//	}
+//	do(root)
+//
+// The Inspect function illustrates a further simplification of the pattern,
+// only considering processing before visiting children, and letting
+// that processing decide whether children are visited at all:
+//
+//	func Inspect(n ir.Node, inspect func(ir.Node) bool) {
+//		var do func(ir.Node) error
+//		do = func(x ir.Node) error {
+//			if inspect(x) {
+//				ir.DoChildren(x, do)
+//			}
+//			return nil
+//		}
+//		if n != nil {
+//			do(n)
+//		}
+//	}
+//
+// The Find function illustrates a different simplification of the pattern,
+// visiting each node and then its children, recursively, until finding
+// a node x such that find(x) returns a non-nil result,
+// at which point the entire traversal stops:
+//
+//	func Find(n ir.Node, find func(ir.Node) interface{}) interface{} {
+//		stop := errors.New("stop")
+//		var found interface{}
+//		var do func(ir.Node) error
+//		do = func(x ir.Node) error {
+//			if v := find(x); v != nil {
+//				found = v
+//				return stop
+//			}
+//			return DoChildren(x, do)
+//		}
+//		do(n)
+//		return found
+//	}
+//
+// Inspect and Find are presented above as examples of how to use
+// DoChildren effectively, but of course, usage that fits within the
+// simplifications captured by Inspect or Find will be best served
+// by directly calling the ones provided by this package.
+func DoChildren(n Node, do func(Node) error) error {
+	if n == nil {
+		return nil
+	}
+	if err := DoList(n.Init(), do); err != nil {
+		return err
+	}
+	if l := n.Left(); l != nil {
+		if err := do(l); err != nil {
+			return err
+		}
+	}
+	if r := n.Right(); r != nil {
+		if err := do(r); err != nil {
+			return err
+		}
+	}
+	if err := DoList(n.List(), do); err != nil {
+		return err
+	}
+	if err := DoList(n.Body(), do); err != nil {
+		return err
+	}
+	if err := DoList(n.Rlist(), do); err != nil {
+		return err
+	}
+	return nil
+}
+
+// DoList calls f on each non-nil node x in the list, in list order.
+// If any call returns a non-nil error, DoList stops and returns that error.
+// Otherwise DoList returns nil.
+//
+// Note that DoList only calls do on the nodes in the list, not their children.
+// If x's children should be processed, do(x) must call DoChildren(x, do) itself.
+func DoList(list Nodes, do func(Node) error) error {
+	for _, x := range list.Slice() {
+		if x != nil {
+			if err := do(x); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// Inspect visits each node x in the IR tree rooted at n
+// in a depth-first preorder traversal, calling inspect on each node visited.
+// If inspect(x) returns false, then Inspect skips over x's children.
+//
+// Note that the meaning of the boolean result in the callback function
+// passed to Inspect differs from that of Scan.
+// During Scan, if scan(x) returns false, then Scan stops the scan.
+// During Inspect, if inspect(x) returns false, then Inspect skips x's children
+// but continues with the remainder of the tree (x's siblings and so on).
+func Inspect(n Node, inspect func(Node) bool) {
+	var do func(Node) error
+	do = func(x Node) error {
+		if inspect(x) {
+			DoChildren(x, do)
+		}
+		return nil
+	}
+	if n != nil {
+		do(n)
+	}
+}
+
+// InspectList calls Inspect(x, inspect) for each node x in the list.
+func InspectList(list Nodes, inspect func(Node) bool) {
+	for _, x := range list.Slice() {
+		Inspect(x, inspect)
+	}
+}
+
+var stop = errors.New("stop")
+
+// Find looks for a non-nil node x in the IR tree rooted at n
+// for which find(x) returns a non-nil value.
+// Find considers nodes in a depth-first, preorder traversal.
+// When Find finds a node x such that find(x) != nil,
+// Find ends the traversal and returns the value of find(x) immediately.
+// Otherwise Find returns nil.
+func Find(n Node, find func(Node) interface{}) interface{} {
+	if n == nil {
+		return nil
+	}
+	var found interface{}
+	var do func(Node) error
+	do = func(x Node) error {
+		if v := find(x); v != nil {
+			found = v
+			return stop
+		}
+		return DoChildren(x, do)
+	}
+	do(n)
+	return found
+}
+
+// FindList calls Find(x, ok) for each node x in the list, in order.
+// If any call find(x) returns a non-nil result, FindList stops and
+// returns that result, skipping the remainder of the list.
+// Otherwise FindList returns nil.
+func FindList(list Nodes, find func(Node) interface{}) interface{} {
+	for _, x := range list.Slice() {
+		if v := Find(x, find); v != nil {
+			return v
+		}
+	}
+	return nil
+}
+
+// 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.
+// If x's children should be processed, then edit(x) must call EditChildren(x, edit).
+//
+// EditChildren allows constructing general editing passes of the IR graph.
+// The most general usage is:
+//
+//	var edit func(ir.Node) ir.Node
+//	edit = func(x ir.Node) ir.Node {
+//		... processing BEFORE editing children ...
+//		if ... should edit children ... {
+//			EditChildren(x, edit)
+//			... processing AFTER editing children ...
+//		}
+//		... return x ...
+//	}
+//	n = edit(n)
+//
+// EditChildren edits the node in place. To edit a copy, call Copy first.
+// As an example, a simple deep copy implementation would be:
+//
+//	func deepCopy(n ir.Node) ir.Node {
+//		var edit func(ir.Node) ir.Node
+//		edit = func(x ir.Node) ir.Node {
+//			x = ir.Copy(x)
+//			ir.EditChildren(x, edit)
+//			return x
+//		}
+//		return edit(n)
+//	}
+//
+// Of course, in this case it is better to call ir.DeepCopy than to build one anew.
+func EditChildren(n Node, edit func(Node) Node) {
+	if n == nil {
+		return
+	}
+	editList(n.Init(), edit)
+	if l := n.Left(); l != nil {
+		n.SetLeft(edit(l))
+	}
+	if r := n.Right(); r != nil {
+		n.SetRight(edit(r))
+	}
+	editList(n.List(), edit)
+	editList(n.Body(), edit)
+	editList(n.Rlist(), edit)
+}
+
+// editList calls edit on each non-nil node x in the list,
+// saving the result of edit back into the list.
+//
+// Note that editList only calls edit on the nodes in the list, not their children.
+// If x's children should be processed, edit(x) must call EditChildren(x, edit) itself.
+func editList(list Nodes, edit func(Node) Node) {
+	s := list.Slice()
+	for i, x := range list.Slice() {
+		if x != nil {
+			s[i] = edit(x)
+		}
+	}
+}
-- 
GitLab


From b9df26d7a86e0b402f4ae5fd0cb44bab46b6331e Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 2 Dec 2020 20:18:47 -0500
Subject: [PATCH 0149/2400] [dev.regabi] cmd/compile: use ir.Find for "search"
 traversals

This CL converts all the generic searching traversal to use ir.Find
instead of relying on direct access to Left, Right, and so on.

Passes buildall w/ toolstash -cmp.

Change-Id: I4d951aef630c00bf333f24be79565cc564694d04
Reviewed-on: https://go-review.googlesource.com/c/go/+/275372
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/alg.go       |  37 +----
 src/cmd/compile/internal/gc/const.go     |  72 ++++-----
 src/cmd/compile/internal/gc/inl.go       | 192 +++++++++--------------
 src/cmd/compile/internal/gc/order.go     |   9 +-
 src/cmd/compile/internal/gc/sinit.go     |   6 +-
 src/cmd/compile/internal/gc/typecheck.go |  78 ++++-----
 src/cmd/compile/internal/gc/walk.go      | 180 ++++++++++-----------
 7 files changed, 240 insertions(+), 334 deletions(-)

diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index b2716399a5..c786a27415 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -782,37 +782,14 @@ func geneq(t *types.Type) *obj.LSym {
 	return closure
 }
 
-func hasCall(n ir.Node) bool {
-	if n.Op() == ir.OCALL || n.Op() == ir.OCALLFUNC {
-		return true
-	}
-	if n.Left() != nil && hasCall(n.Left()) {
-		return true
-	}
-	if n.Right() != nil && hasCall(n.Right()) {
-		return true
-	}
-	for _, x := range n.Init().Slice() {
-		if hasCall(x) {
-			return true
-		}
-	}
-	for _, x := range n.Body().Slice() {
-		if hasCall(x) {
-			return true
-		}
-	}
-	for _, x := range n.List().Slice() {
-		if hasCall(x) {
-			return true
+func hasCall(fn *ir.Func) bool {
+	found := ir.Find(fn, func(n ir.Node) interface{} {
+		if op := n.Op(); op == ir.OCALL || op == ir.OCALLFUNC {
+			return n
 		}
-	}
-	for _, x := range n.Rlist().Slice() {
-		if hasCall(x) {
-			return true
-		}
-	}
-	return false
+		return nil
+	})
+	return found != nil
 }
 
 // eqfield returns the node
diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 9aa65f97b6..6cd414a419 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -553,7 +553,7 @@ func evalConst(n ir.Node) ir.Node {
 				return origIntConst(n, int64(len(ir.StringVal(nl))))
 			}
 		case types.TARRAY:
-			if !hascallchan(nl) {
+			if !hasCallOrChan(nl) {
 				return origIntConst(n, nl.Type().NumElem())
 			}
 		}
@@ -779,49 +779,35 @@ func isGoConst(n ir.Node) bool {
 	return n.Op() == ir.OLITERAL
 }
 
-func hascallchan(n ir.Node) bool {
-	if n == nil {
-		return false
-	}
-	switch n.Op() {
-	case ir.OAPPEND,
-		ir.OCALL,
-		ir.OCALLFUNC,
-		ir.OCALLINTER,
-		ir.OCALLMETH,
-		ir.OCAP,
-		ir.OCLOSE,
-		ir.OCOMPLEX,
-		ir.OCOPY,
-		ir.ODELETE,
-		ir.OIMAG,
-		ir.OLEN,
-		ir.OMAKE,
-		ir.ONEW,
-		ir.OPANIC,
-		ir.OPRINT,
-		ir.OPRINTN,
-		ir.OREAL,
-		ir.ORECOVER,
-		ir.ORECV:
-		return true
-	}
-
-	if hascallchan(n.Left()) || hascallchan(n.Right()) {
-		return true
-	}
-	for _, n1 := range n.List().Slice() {
-		if hascallchan(n1) {
-			return true
-		}
-	}
-	for _, n2 := range n.Rlist().Slice() {
-		if hascallchan(n2) {
-			return true
+// hasCallOrChan reports whether n contains any calls or channel operations.
+func hasCallOrChan(n ir.Node) bool {
+	found := ir.Find(n, func(n ir.Node) interface{} {
+		switch n.Op() {
+		case ir.OAPPEND,
+			ir.OCALL,
+			ir.OCALLFUNC,
+			ir.OCALLINTER,
+			ir.OCALLMETH,
+			ir.OCAP,
+			ir.OCLOSE,
+			ir.OCOMPLEX,
+			ir.OCOPY,
+			ir.ODELETE,
+			ir.OIMAG,
+			ir.OLEN,
+			ir.OMAKE,
+			ir.ONEW,
+			ir.OPANIC,
+			ir.OPRINT,
+			ir.OPRINTN,
+			ir.OREAL,
+			ir.ORECOVER,
+			ir.ORECV:
+			return n
 		}
-	}
-
-	return false
+		return nil
+	})
+	return found != nil
 }
 
 // A constSet represents a set of Go constant expressions.
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index efd6fea844..09ec0b6f99 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -33,6 +33,7 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/src"
+	"errors"
 	"fmt"
 	"go/constant"
 	"strings"
@@ -206,14 +207,10 @@ func caninl(fn *ir.Func) {
 		extraCallCost: cc,
 		usedLocals:    make(map[ir.Node]bool),
 	}
-	if visitor.visitList(fn.Body()) {
+	if visitor.tooHairy(fn) {
 		reason = visitor.reason
 		return
 	}
-	if visitor.budget < 0 {
-		reason = fmt.Sprintf("function too complex: cost %d exceeds budget %d", inlineMaxBudget-visitor.budget, inlineMaxBudget)
-		return
-	}
 
 	n.Func().Inl = &ir.Inline{
 		Cost: inlineMaxBudget - visitor.budget,
@@ -296,21 +293,29 @@ type hairyVisitor struct {
 	reason        string
 	extraCallCost int32
 	usedLocals    map[ir.Node]bool
+	do            func(ir.Node) error
 }
 
-// Look for anything we want to punt on.
-func (v *hairyVisitor) visitList(ll ir.Nodes) bool {
-	for _, n := range ll.Slice() {
-		if v.visit(n) {
-			return true
-		}
+var errBudget = errors.New("too expensive")
+
+func (v *hairyVisitor) tooHairy(fn *ir.Func) bool {
+	v.do = v.doNode // cache closure
+
+	err := ir.DoChildren(fn, v.do)
+	if err != nil {
+		v.reason = err.Error()
+		return true
+	}
+	if v.budget < 0 {
+		v.reason = fmt.Sprintf("function too complex: cost %d exceeds budget %d", inlineMaxBudget-v.budget, inlineMaxBudget)
+		return true
 	}
 	return false
 }
 
-func (v *hairyVisitor) visit(n ir.Node) bool {
+func (v *hairyVisitor) doNode(n ir.Node) error {
 	if n == nil {
-		return false
+		return nil
 	}
 
 	switch n.Op() {
@@ -323,8 +328,7 @@ func (v *hairyVisitor) visit(n ir.Node) bool {
 		if n.Left().Op() == ir.ONAME && n.Left().Class() == ir.PFUNC && isRuntimePkg(n.Left().Sym().Pkg) {
 			fn := n.Left().Sym().Name
 			if fn == "getcallerpc" || fn == "getcallersp" {
-				v.reason = "call to " + fn
-				return true
+				return errors.New("call to " + fn)
 			}
 			if fn == "throw" {
 				v.budget -= inlineExtraThrowCost
@@ -380,8 +384,7 @@ func (v *hairyVisitor) visit(n ir.Node) bool {
 	case ir.ORECOVER:
 		// recover matches the argument frame pointer to find
 		// the right panic value, so it needs an argument frame.
-		v.reason = "call to recover"
-		return true
+		return errors.New("call to recover")
 
 	case ir.OCLOSURE,
 		ir.ORANGE,
@@ -390,21 +393,19 @@ func (v *hairyVisitor) visit(n ir.Node) bool {
 		ir.ODEFER,
 		ir.ODCLTYPE, // can't print yet
 		ir.ORETJMP:
-		v.reason = "unhandled op " + n.Op().String()
-		return true
+		return errors.New("unhandled op " + n.Op().String())
 
 	case ir.OAPPEND:
 		v.budget -= inlineExtraAppendCost
 
 	case ir.ODCLCONST, ir.OFALL:
 		// These nodes don't produce code; omit from inlining budget.
-		return false
+		return nil
 
 	case ir.OFOR, ir.OFORUNTIL, ir.OSWITCH:
 		// ORANGE, OSELECT in "unhandled" above
 		if n.Sym() != nil {
-			v.reason = "labeled control"
-			return true
+			return errors.New("labeled control")
 		}
 
 	case ir.OBREAK, ir.OCONTINUE:
@@ -416,8 +417,17 @@ func (v *hairyVisitor) visit(n ir.Node) bool {
 	case ir.OIF:
 		if ir.IsConst(n.Left(), constant.Bool) {
 			// This if and the condition cost nothing.
-			return v.visitList(n.Init()) || v.visitList(n.Body()) ||
-				v.visitList(n.Rlist())
+			// TODO(rsc): It seems strange that we visit the dead branch.
+			if err := ir.DoList(n.Init(), v.do); err != nil {
+				return err
+			}
+			if err := ir.DoList(n.Body(), v.do); err != nil {
+				return err
+			}
+			if err := ir.DoList(n.Rlist(), v.do); err != nil {
+				return err
+			}
+			return nil
 		}
 
 	case ir.ONAME:
@@ -439,34 +449,22 @@ func (v *hairyVisitor) visit(n ir.Node) bool {
 
 	// When debugging, don't stop early, to get full cost of inlining this function
 	if v.budget < 0 && base.Flag.LowerM < 2 && !logopt.Enabled() {
-		return true
+		return errBudget
 	}
 
-	return v.visit(n.Left()) || v.visit(n.Right()) ||
-		v.visitList(n.List()) || v.visitList(n.Rlist()) ||
-		v.visitList(n.Init()) || v.visitList(n.Body())
+	return ir.DoChildren(n, v.do)
 }
 
-func countNodes(n ir.Node) int {
-	if n == nil {
-		return 0
-	}
-	cnt := 1
-	cnt += countNodes(n.Left())
-	cnt += countNodes(n.Right())
-	for _, n1 := range n.Init().Slice() {
-		cnt += countNodes(n1)
-	}
-	for _, n1 := range n.Body().Slice() {
-		cnt += countNodes(n1)
-	}
-	for _, n1 := range n.List().Slice() {
-		cnt += countNodes(n1)
-	}
-	for _, n1 := range n.Rlist().Slice() {
-		cnt += countNodes(n1)
-	}
-	return cnt
+func isBigFunc(fn *ir.Func) bool {
+	budget := inlineBigFunctionNodes
+	over := ir.Find(fn, func(n ir.Node) interface{} {
+		budget--
+		if budget <= 0 {
+			return n
+		}
+		return nil
+	})
+	return over != nil
 }
 
 // Inlcalls/nodelist/node walks fn's statements and expressions and substitutes any
@@ -475,7 +473,7 @@ func inlcalls(fn *ir.Func) {
 	savefn := Curfn
 	Curfn = fn
 	maxCost := int32(inlineMaxBudget)
-	if countNodes(fn) >= inlineBigFunctionNodes {
+	if isBigFunc(fn) {
 		maxCost = inlineBigFunctionMaxCost
 	}
 	// Map to keep track of functions that have been inlined at a particular
@@ -742,82 +740,45 @@ FindRHS:
 		base.Fatalf("RHS is nil: %v", defn)
 	}
 
-	unsafe, _ := reassigned(n.(*ir.Name))
-	if unsafe {
+	if reassigned(n.(*ir.Name)) {
 		return nil
 	}
 
 	return rhs
 }
 
+var errFound = errors.New("found")
+
 // reassigned takes an ONAME node, walks the function in which it is defined, and returns a boolean
 // indicating whether the name has any assignments other than its declaration.
 // The second return value is the first such assignment encountered in the walk, if any. It is mostly
 // useful for -m output documenting the reason for inhibited optimizations.
 // NB: global variables are always considered to be re-assigned.
 // TODO: handle initial declaration not including an assignment and followed by a single assignment?
-func reassigned(n *ir.Name) (bool, ir.Node) {
-	if n.Op() != ir.ONAME {
-		base.Fatalf("reassigned %v", n)
+func reassigned(name *ir.Name) bool {
+	if name.Op() != ir.ONAME {
+		base.Fatalf("reassigned %v", name)
 	}
 	// no way to reliably check for no-reassignment of globals, assume it can be
-	if n.Curfn == nil {
-		return true, nil
-	}
-	f := n.Curfn
-	v := reassignVisitor{name: n}
-	a := v.visitList(f.Body())
-	return a != nil, a
-}
-
-type reassignVisitor struct {
-	name ir.Node
-}
-
-func (v *reassignVisitor) visit(n ir.Node) ir.Node {
-	if n == nil {
-		return nil
+	if name.Curfn == nil {
+		return true
 	}
-	switch n.Op() {
-	case ir.OAS:
-		if n.Left() == v.name && n != v.name.Name().Defn {
-			return n
-		}
-	case ir.OAS2, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2DOTTYPE:
-		for _, p := range n.List().Slice() {
-			if p == v.name && n != v.name.Name().Defn {
+	a := ir.Find(name.Curfn, func(n ir.Node) interface{} {
+		switch n.Op() {
+		case ir.OAS:
+			if n.Left() == name && n != name.Defn {
 				return n
 			}
+		case ir.OAS2, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2DOTTYPE:
+			for _, p := range n.List().Slice() {
+				if p == name && n != name.Defn {
+					return n
+				}
+			}
 		}
-	}
-	if a := v.visit(n.Left()); a != nil {
-		return a
-	}
-	if a := v.visit(n.Right()); a != nil {
-		return a
-	}
-	if a := v.visitList(n.List()); a != nil {
-		return a
-	}
-	if a := v.visitList(n.Rlist()); a != nil {
-		return a
-	}
-	if a := v.visitList(n.Init()); a != nil {
-		return a
-	}
-	if a := v.visitList(n.Body()); a != nil {
-		return a
-	}
-	return nil
-}
-
-func (v *reassignVisitor) visitList(l ir.Nodes) ir.Node {
-	for _, n := range l.Slice() {
-		if a := v.visit(n); a != nil {
-			return a
-		}
-	}
-	return nil
+		return nil
+	})
+	return a != nil
 }
 
 func inlParam(t *types.Field, as ir.Node, inlvars map[*ir.Name]ir.Node) ir.Node {
@@ -1140,6 +1101,7 @@ func mkinlcall(n ir.Node, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]bool)
 		bases:        make(map[*src.PosBase]*src.PosBase),
 		newInlIndex:  newIndex,
 	}
+	subst.edit = subst.node
 
 	body := subst.list(ir.AsNodes(fn.Inl.Body))
 
@@ -1248,6 +1210,8 @@ type inlsubst struct {
 	// newInlIndex is the index of the inlined call frame to
 	// insert for inlined nodes.
 	newInlIndex int
+
+	edit func(ir.Node) ir.Node // cached copy of subst.node method value closure
 }
 
 // list inlines a list of nodes.
@@ -1334,21 +1298,13 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 		return m
 	}
 
-	m := ir.Copy(n)
-	m.SetPos(subst.updatedPos(m.Pos()))
-	m.PtrInit().Set(nil)
-
 	if n.Op() == ir.OCLOSURE {
 		base.Fatalf("cannot inline function containing closure: %+v", n)
 	}
 
-	m.SetLeft(subst.node(n.Left()))
-	m.SetRight(subst.node(n.Right()))
-	m.PtrList().Set(subst.list(n.List()))
-	m.PtrRlist().Set(subst.list(n.Rlist()))
-	m.PtrInit().Set(append(m.Init().Slice(), subst.list(n.Init())...))
-	m.PtrBody().Set(subst.list(n.Body()))
-
+	m := ir.Copy(n)
+	m.SetPos(subst.updatedPos(m.Pos()))
+	ir.EditChildren(m, subst.edit)
 	return m
 }
 
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 5440806e8e..1680d9d920 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -1062,6 +1062,10 @@ func (o *Order) exprListInPlace(l ir.Nodes) {
 // prealloc[x] records the allocation to use for x.
 var prealloc = map[ir.Node]ir.Node{}
 
+func (o *Order) exprNoLHS(n ir.Node) ir.Node {
+	return o.expr(n, nil)
+}
+
 // expr orders a single expression, appending side
 // effects to o.out as needed.
 // If this is part of an assignment lhs = *np, lhs is given.
@@ -1079,10 +1083,7 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 
 	switch n.Op() {
 	default:
-		n.SetLeft(o.expr(n.Left(), nil))
-		n.SetRight(o.expr(n.Right(), nil))
-		o.exprList(n.List())
-		o.exprList(n.Rlist())
+		ir.EditChildren(n, o.exprNoLHS)
 
 	// Addition of strings turns into a function call.
 	// Allocate a temporary to hold the strings.
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 3ef976d8aa..20abbfef8c 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -60,7 +60,8 @@ func (s *InitSchedule) tryStaticInit(n ir.Node) bool {
 	if n.Op() != ir.OAS {
 		return false
 	}
-	if ir.IsBlank(n.Left()) && candiscard(n.Right()) {
+	if ir.IsBlank(n.Left()) && !hasSideEffects(n.Right()) {
+		// Discard.
 		return true
 	}
 	lno := setlineno(n)
@@ -548,7 +549,8 @@ func fixedlit(ctxt initContext, kind initKind, n ir.Node, var_ ir.Node, init *ir
 
 	for _, r := range n.List().Slice() {
 		a, value := splitnode(r)
-		if a == ir.BlankNode && candiscard(value) {
+		if a == ir.BlankNode && !hasSideEffects(value) {
+			// Discard.
 			continue
 		}
 
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index e2100481aa..a8acd468c9 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -3669,51 +3669,52 @@ func checkmake(t *types.Type, arg string, np *ir.Node) bool {
 	return true
 }
 
-func markbreak(labels *map[*types.Sym]ir.Node, n ir.Node, implicit ir.Node) {
-	if n == nil {
-		return
-	}
+// markBreak marks control statements containing break statements with SetHasBreak(true).
+func markBreak(fn *ir.Func) {
+	var labels map[*types.Sym]ir.Node
+	var implicit ir.Node
 
-	switch n.Op() {
-	case ir.OBREAK:
-		if n.Sym() == nil {
-			if implicit != nil {
-				implicit.SetHasBreak(true)
+	var mark func(ir.Node) error
+	mark = func(n ir.Node) error {
+		switch n.Op() {
+		default:
+			ir.DoChildren(n, mark)
+
+		case ir.OBREAK:
+			if n.Sym() == nil {
+				if implicit != nil {
+					implicit.SetHasBreak(true)
+				}
+			} else {
+				if lab := labels[n.Sym()]; lab != nil {
+					lab.SetHasBreak(true)
+				}
 			}
-		} else {
-			if lab := (*labels)[n.Sym()]; lab != nil {
-				lab.SetHasBreak(true)
+
+		case ir.OFOR, ir.OFORUNTIL, ir.OSWITCH, ir.OTYPESW, ir.OSELECT, ir.ORANGE:
+			old := implicit
+			implicit = n
+			sym := n.Sym()
+			if sym != nil {
+				if labels == nil {
+					// Map creation delayed until we need it - most functions don't.
+					labels = make(map[*types.Sym]ir.Node)
+				}
+				labels[sym] = n
 			}
-		}
-	case ir.OFOR, ir.OFORUNTIL, ir.OSWITCH, ir.OTYPESW, ir.OSELECT, ir.ORANGE:
-		implicit = n
-		if sym := n.Sym(); sym != nil {
-			if *labels == nil {
-				// Map creation delayed until we need it - most functions don't.
-				*labels = make(map[*types.Sym]ir.Node)
+			ir.DoChildren(n, mark)
+			if sym != nil {
+				delete(labels, sym)
 			}
-			(*labels)[sym] = n
-			defer delete(*labels, sym)
+			implicit = old
 		}
-		fallthrough
-	default:
-		markbreak(labels, n.Left(), implicit)
-		markbreak(labels, n.Right(), implicit)
-		markbreaklist(labels, n.Init(), implicit)
-		markbreaklist(labels, n.Body(), implicit)
-		markbreaklist(labels, n.List(), implicit)
-		markbreaklist(labels, n.Rlist(), implicit)
+		return nil
 	}
-}
 
-func markbreaklist(labels *map[*types.Sym]ir.Node, l ir.Nodes, implicit ir.Node) {
-	s := l.Slice()
-	for i := 0; i < len(s); i++ {
-		markbreak(labels, s[i], implicit)
-	}
+	mark(fn)
 }
 
-// isterminating reports whether the Nodes list ends with a terminating statement.
+// isTermNodes reports whether the Nodes list ends with a terminating statement.
 func isTermNodes(l ir.Nodes) bool {
 	s := l.Slice()
 	c := len(s)
@@ -3723,7 +3724,7 @@ func isTermNodes(l ir.Nodes) bool {
 	return isTermNode(s[c-1])
 }
 
-// Isterminating reports whether the node n, the last one in a
+// isTermNode reports whether the node n, the last one in a
 // statement list, is a terminating statement.
 func isTermNode(n ir.Node) bool {
 	switch n.Op() {
@@ -3776,8 +3777,7 @@ func isTermNode(n ir.Node) bool {
 // checkreturn makes sure that fn terminates appropriately.
 func checkreturn(fn *ir.Func) {
 	if fn.Type().NumResults() != 0 && fn.Body().Len() != 0 {
-		var labels map[*types.Sym]ir.Node
-		markbreaklist(&labels, fn.Body(), nil)
+		markBreak(fn)
 		if !isTermNodes(fn.Body()) {
 			base.ErrorfAt(fn.Endlineno, "missing return at end of function")
 		}
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 3d22c66d90..bbc08ab953 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -3786,107 +3786,91 @@ func usefield(n ir.Node) {
 	Curfn.FieldTrack[sym] = struct{}{}
 }
 
-func candiscardlist(l ir.Nodes) bool {
-	for _, n := range l.Slice() {
-		if !candiscard(n) {
-			return false
-		}
-	}
-	return true
-}
-
-func candiscard(n ir.Node) bool {
-	if n == nil {
-		return true
-	}
-
-	switch n.Op() {
-	default:
-		return false
-
-		// Discardable as long as the subpieces are.
-	case ir.ONAME,
-		ir.ONONAME,
-		ir.OTYPE,
-		ir.OPACK,
-		ir.OLITERAL,
-		ir.ONIL,
-		ir.OADD,
-		ir.OSUB,
-		ir.OOR,
-		ir.OXOR,
-		ir.OADDSTR,
-		ir.OADDR,
-		ir.OANDAND,
-		ir.OBYTES2STR,
-		ir.ORUNES2STR,
-		ir.OSTR2BYTES,
-		ir.OSTR2RUNES,
-		ir.OCAP,
-		ir.OCOMPLIT,
-		ir.OMAPLIT,
-		ir.OSTRUCTLIT,
-		ir.OARRAYLIT,
-		ir.OSLICELIT,
-		ir.OPTRLIT,
-		ir.OCONV,
-		ir.OCONVIFACE,
-		ir.OCONVNOP,
-		ir.ODOT,
-		ir.OEQ,
-		ir.ONE,
-		ir.OLT,
-		ir.OLE,
-		ir.OGT,
-		ir.OGE,
-		ir.OKEY,
-		ir.OSTRUCTKEY,
-		ir.OLEN,
-		ir.OMUL,
-		ir.OLSH,
-		ir.ORSH,
-		ir.OAND,
-		ir.OANDNOT,
-		ir.ONEW,
-		ir.ONOT,
-		ir.OBITNOT,
-		ir.OPLUS,
-		ir.ONEG,
-		ir.OOROR,
-		ir.OPAREN,
-		ir.ORUNESTR,
-		ir.OREAL,
-		ir.OIMAG,
-		ir.OCOMPLEX:
-		break
+// hasSideEffects reports whether n contains any operations that could have observable side effects.
+func hasSideEffects(n ir.Node) bool {
+	found := ir.Find(n, func(n ir.Node) interface{} {
+		switch n.Op() {
+		// Assume side effects unless we know otherwise.
+		default:
+			return n
+
+		// No side effects here (arguments are checked separately).
+		case ir.ONAME,
+			ir.ONONAME,
+			ir.OTYPE,
+			ir.OPACK,
+			ir.OLITERAL,
+			ir.ONIL,
+			ir.OADD,
+			ir.OSUB,
+			ir.OOR,
+			ir.OXOR,
+			ir.OADDSTR,
+			ir.OADDR,
+			ir.OANDAND,
+			ir.OBYTES2STR,
+			ir.ORUNES2STR,
+			ir.OSTR2BYTES,
+			ir.OSTR2RUNES,
+			ir.OCAP,
+			ir.OCOMPLIT,
+			ir.OMAPLIT,
+			ir.OSTRUCTLIT,
+			ir.OARRAYLIT,
+			ir.OSLICELIT,
+			ir.OPTRLIT,
+			ir.OCONV,
+			ir.OCONVIFACE,
+			ir.OCONVNOP,
+			ir.ODOT,
+			ir.OEQ,
+			ir.ONE,
+			ir.OLT,
+			ir.OLE,
+			ir.OGT,
+			ir.OGE,
+			ir.OKEY,
+			ir.OSTRUCTKEY,
+			ir.OLEN,
+			ir.OMUL,
+			ir.OLSH,
+			ir.ORSH,
+			ir.OAND,
+			ir.OANDNOT,
+			ir.ONEW,
+			ir.ONOT,
+			ir.OBITNOT,
+			ir.OPLUS,
+			ir.ONEG,
+			ir.OOROR,
+			ir.OPAREN,
+			ir.ORUNESTR,
+			ir.OREAL,
+			ir.OIMAG,
+			ir.OCOMPLEX:
+			return nil
+
+		// Only possible side effect is division by zero.
+		case ir.ODIV, ir.OMOD:
+			if n.Right().Op() != ir.OLITERAL || constant.Sign(n.Right().Val()) == 0 {
+				return n
+			}
 
-		// Discardable as long as we know it's not division by zero.
-	case ir.ODIV, ir.OMOD:
-		if n.Right().Op() == ir.OLITERAL && constant.Sign(n.Right().Val()) != 0 {
-			break
-		}
-		return false
+		// Only possible side effect is panic on invalid size,
+		// but many makechan and makemap use size zero, which is definitely OK.
+		case ir.OMAKECHAN, ir.OMAKEMAP:
+			if !ir.IsConst(n.Left(), constant.Int) || constant.Sign(n.Left().Val()) != 0 {
+				return n
+			}
 
-		// Discardable as long as we know it won't fail because of a bad size.
-	case ir.OMAKECHAN, ir.OMAKEMAP:
-		if ir.IsConst(n.Left(), constant.Int) && constant.Sign(n.Left().Val()) == 0 {
-			break
+		// Only possible side effect is panic on invalid size.
+		// TODO(rsc): Merge with previous case (probably breaks toolstash -cmp).
+		case ir.OMAKESLICE, ir.OMAKESLICECOPY:
+			return n
 		}
-		return false
-
-		// Difficult to tell what sizes are okay.
-	case ir.OMAKESLICE:
-		return false
-
-	case ir.OMAKESLICECOPY:
-		return false
-	}
-
-	if !candiscard(n.Left()) || !candiscard(n.Right()) || !candiscardlist(n.Init()) || !candiscardlist(n.Body()) || !candiscardlist(n.List()) || !candiscardlist(n.Rlist()) {
-		return false
-	}
-
-	return true
+		return nil
+	})
+	return found != nil
 }
 
 // Rewrite
-- 
GitLab


From d855b30fe48fe108921733c8d86e42063a5c601f Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 3 Dec 2020 14:06:41 -0500
Subject: [PATCH 0150/2400] [dev.regabi] cmd/compile: use ir.EditChildren for
 inline rewriting

This CL rephrases the general inlining rewriter in terms of ir.EditChildren.
It is the final part of the code that was processing arbitrary nodes using
Left, SetLeft, and so on. After this CL, there should be none left except
for the implementations of DoChildren and EditChildren, which fall next.

Passes buildall w/ toolstash -cmp.

Change-Id: I9c36053360cd040710716f0b39397a80114be713
Reviewed-on: https://go-review.googlesource.com/c/go/+/275373
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/escape.go    |   1 +
 src/cmd/compile/internal/gc/inl.go       | 103 ++++++-----------------
 src/cmd/compile/internal/gc/typecheck.go |   5 ++
 src/cmd/compile/internal/ir/expr.go      |  12 +++
 4 files changed, 46 insertions(+), 75 deletions(-)

diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 622edb9820..32bc7b297b 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -803,6 +803,7 @@ func (e *Escape) call(ks []EscHole, call, where ir.Node) {
 
 	switch call.Op() {
 	default:
+		ir.Dump("esc", call)
 		base.Fatalf("unexpected call op: %v", call.Op())
 
 	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 09ec0b6f99..8402852424 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -483,10 +483,11 @@ func inlcalls(fn *ir.Func) {
 	// Most likely, the inlining will stop before we even hit the beginning of
 	// the cycle again, but the map catches the unusual case.
 	inlMap := make(map[*ir.Func]bool)
-	fn = inlnode(fn, maxCost, inlMap).(*ir.Func)
-	if fn != Curfn {
-		base.Fatalf("inlnode replaced curfn")
+	var edit func(ir.Node) ir.Node
+	edit = func(n ir.Node) ir.Node {
+		return inlnode(n, maxCost, inlMap, edit)
 	}
+	ir.EditChildren(fn, edit)
 	Curfn = savefn
 }
 
@@ -521,13 +522,6 @@ func inlconv2list(n ir.Node) []ir.Node {
 	return s
 }
 
-func inlnodelist(l ir.Nodes, maxCost int32, inlMap map[*ir.Func]bool) {
-	s := l.Slice()
-	for i := range s {
-		s[i] = inlnode(s[i], maxCost, inlMap)
-	}
-}
-
 // inlnode recurses over the tree to find inlineable calls, which will
 // be turned into OINLCALLs by mkinlcall. When the recursion comes
 // back up will examine left, right, list, rlist, ninit, ntest, nincr,
@@ -541,7 +535,7 @@ func inlnodelist(l ir.Nodes, maxCost int32, inlMap map[*ir.Func]bool) {
 // shorter and less complicated.
 // The result of inlnode MUST be assigned back to n, e.g.
 // 	n.Left = inlnode(n.Left)
-func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool) ir.Node {
+func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.Node) ir.Node) ir.Node {
 	if n == nil {
 		return n
 	}
@@ -567,49 +561,7 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool) ir.Node {
 
 	lno := setlineno(n)
 
-	inlnodelist(n.Init(), maxCost, inlMap)
-	init := n.Init().Slice()
-	for i, n1 := range init {
-		if n1.Op() == ir.OINLCALL {
-			init[i] = inlconv2stmt(n1)
-		}
-	}
-
-	n.SetLeft(inlnode(n.Left(), maxCost, inlMap))
-	if n.Left() != nil && n.Left().Op() == ir.OINLCALL {
-		n.SetLeft(inlconv2expr(n.Left()))
-	}
-
-	n.SetRight(inlnode(n.Right(), maxCost, inlMap))
-	if n.Right() != nil && n.Right().Op() == ir.OINLCALL {
-		if n.Op() == ir.OFOR || n.Op() == ir.OFORUNTIL {
-			n.SetRight(inlconv2stmt(n.Right()))
-		} else {
-			n.SetRight(inlconv2expr(n.Right()))
-		}
-	}
-
-	inlnodelist(n.List(), maxCost, inlMap)
-	s := n.List().Slice()
-	convert := inlconv2expr
-	if n.Op() == ir.OBLOCK {
-		convert = inlconv2stmt
-	}
-	for i, n1 := range s {
-		if n1 != nil && n1.Op() == ir.OINLCALL {
-			s[i] = convert(n1)
-		}
-	}
-
-	inlnodelist(n.Body(), maxCost, inlMap)
-	s = n.Body().Slice()
-	for i, n1 := range s {
-		if n1.Op() == ir.OINLCALL {
-			s[i] = inlconv2stmt(n1)
-		}
-	}
-
-	inlnodelist(n.Rlist(), maxCost, inlMap)
+	ir.EditChildren(n, edit)
 
 	if n.Op() == ir.OAS2FUNC && n.Rlist().First().Op() == ir.OINLCALL {
 		n.PtrRlist().Set(inlconv2list(n.Rlist().First()))
@@ -618,17 +570,6 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool) ir.Node {
 		n = typecheck(n, ctxStmt)
 	}
 
-	s = n.Rlist().Slice()
-	for i, n1 := range s {
-		if n1.Op() == ir.OINLCALL {
-			if n.Op() == ir.OIF {
-				s[i] = inlconv2stmt(n1)
-			} else {
-				s[i] = inlconv2expr(n1)
-			}
-		}
-	}
-
 	// with all the branches out of the way, it is now time to
 	// transmogrify this node itself unless inhibited by the
 	// switch at the top of this function.
@@ -639,8 +580,10 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool) ir.Node {
 		}
 	}
 
+	var call ir.Node
 	switch n.Op() {
 	case ir.OCALLFUNC:
+		call = n
 		if base.Flag.LowerM > 3 {
 			fmt.Printf("%v:call to func %+v\n", ir.Line(n), n.Left())
 		}
@@ -648,10 +591,11 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool) ir.Node {
 			break
 		}
 		if fn := inlCallee(n.Left()); fn != nil && fn.Inl != nil {
-			n = mkinlcall(n, fn, maxCost, inlMap)
+			n = mkinlcall(n, fn, maxCost, inlMap, edit)
 		}
 
 	case ir.OCALLMETH:
+		call = n
 		if base.Flag.LowerM > 3 {
 			fmt.Printf("%v:call to meth %L\n", ir.Line(n), n.Left().Right())
 		}
@@ -661,10 +605,25 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool) ir.Node {
 			base.Fatalf("no function type for [%p] %+v\n", n.Left(), n.Left())
 		}
 
-		n = mkinlcall(n, methodExprName(n.Left()).Func(), maxCost, inlMap)
+		n = mkinlcall(n, methodExprName(n.Left()).Func(), maxCost, inlMap, edit)
 	}
 
 	base.Pos = lno
+
+	if n.Op() == ir.OINLCALL {
+		switch call.(*ir.CallExpr).Use {
+		default:
+			ir.Dump("call", call)
+			base.Fatalf("call missing use")
+		case ir.CallUseExpr:
+			n = inlconv2expr(n)
+		case ir.CallUseStmt:
+			n = inlconv2stmt(n)
+		case ir.CallUseList:
+			// leave for caller to convert
+		}
+	}
+
 	return n
 }
 
@@ -805,7 +764,7 @@ var inlgen int
 // parameters.
 // The result of mkinlcall MUST be assigned back to n, e.g.
 // 	n.Left = mkinlcall(n.Left, fn, isddd)
-func mkinlcall(n ir.Node, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]bool) ir.Node {
+func mkinlcall(n ir.Node, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.Node) ir.Node) ir.Node {
 	if fn.Inl == nil {
 		if logopt.Enabled() {
 			logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", ir.FuncName(Curfn),
@@ -1131,13 +1090,7 @@ func mkinlcall(n ir.Node, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]bool)
 	// instead we emit the things that the body needs
 	// and each use must redo the inlining.
 	// luckily these are small.
-	inlnodelist(call.Body(), maxCost, inlMap)
-	s := call.Body().Slice()
-	for i, n1 := range s {
-		if n1.Op() == ir.OINLCALL {
-			s[i] = inlconv2stmt(n1)
-		}
-	}
+	ir.EditChildren(call, edit)
 
 	if base.Flag.LowerM > 2 {
 		fmt.Printf("%v: After inlining %+v\n\n", ir.Line(call), call)
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index a8acd468c9..65c5f2abce 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -1280,6 +1280,10 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	// call and call like
 	case ir.OCALL:
+		n.(*ir.CallExpr).Use = ir.CallUseExpr
+		if top == ctxStmt {
+			n.(*ir.CallExpr).Use = ir.CallUseStmt
+		}
 		typecheckslice(n.Init().Slice(), ctxStmt) // imported rewritten f(g()) calls (#30907)
 		n.SetLeft(typecheck(n.Left(), ctxExpr|ctxType|ctxCallee))
 		if n.Left().Diag() {
@@ -3294,6 +3298,7 @@ func typecheckas2(n ir.Node) {
 			if cr != cl {
 				goto mismatch
 			}
+			r.(*ir.CallExpr).Use = ir.CallUseList
 			n.SetOp(ir.OAS2FUNC)
 			for i, l := range n.List().Slice() {
 				f := r.Type().Field(i)
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 49543f4286..9600d13d8e 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -148,6 +148,17 @@ func (n *BinaryExpr) SetOp(op Op) {
 	}
 }
 
+// A CallUse records how the result of the call is used:
+type CallUse int
+
+const (
+	_ CallUse = iota
+
+	CallUseExpr // single expression result is used
+	CallUseList // list of results are used
+	CallUseStmt // results not used - call is a statement
+)
+
 // A CallExpr is a function call X(Args).
 type CallExpr struct {
 	miniExpr
@@ -157,6 +168,7 @@ type CallExpr struct {
 	Rargs    Nodes // TODO(rsc): Delete.
 	body     Nodes // TODO(rsc): Delete.
 	DDD      bool
+	Use      CallUse
 	noInline bool
 }
 
-- 
GitLab


From 18f2df7e810ac221d05577b746f2bf4e3cd789f4 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 3 Dec 2020 18:43:18 -0500
Subject: [PATCH 0151/2400] [dev.regabi] cmd/compile: implement copy for nodes

Put each node in charge of making copies of its own slices.
This removes a generic use of Body, SetBody, and so on
in func Copy, heading toward removing those even from
being used in package ir.

Passes buildall w/ toolstash -cmp.

Change-Id: I249b7fe54cf72e9d2f0467b10f3f257abf9b29b9
Reviewed-on: https://go-review.googlesource.com/c/go/+/275374
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/copy.go |  26 +-
 src/cmd/compile/internal/ir/expr.go | 404 ++++++++++++++++++----------
 src/cmd/compile/internal/ir/func.go |   2 +-
 src/cmd/compile/internal/ir/name.go |   4 +-
 src/cmd/compile/internal/ir/node.go |  19 +-
 src/cmd/compile/internal/ir/stmt.go | 310 +++++++++++++--------
 src/cmd/compile/internal/ir/type.go |  48 +++-
 7 files changed, 532 insertions(+), 281 deletions(-)

diff --git a/src/cmd/compile/internal/ir/copy.go b/src/cmd/compile/internal/ir/copy.go
index 2f340df1ab..8d174d6e53 100644
--- a/src/cmd/compile/internal/ir/copy.go
+++ b/src/cmd/compile/internal/ir/copy.go
@@ -43,7 +43,7 @@ func Orig(n Node) Node {
 // SepCopy returns a separate shallow copy of n,
 // breaking any Orig link to any other nodes.
 func SepCopy(n Node) Node {
-	n = n.rawCopy()
+	n = n.copy()
 	if n, ok := n.(OrigNode); ok {
 		n.SetOrig(n)
 	}
@@ -57,29 +57,11 @@ func SepCopy(n Node) Node {
 // The specific semantics surrounding Orig are subtle but right for most uses.
 // See issues #26855 and #27765 for pitfalls.
 func Copy(n Node) Node {
-	copy := n.rawCopy()
+	c := n.copy()
 	if n, ok := n.(OrigNode); ok && n.Orig() == n {
-		copy.(OrigNode).SetOrig(copy)
+		c.(OrigNode).SetOrig(c)
 	}
-
-	// Copy lists so that updates to n.List[0]
-	// don't affect copy.List[0] and vice versa,
-	// same as updates to Left and Right.
-	// TODO(rsc): Eventually the Node implementations will need to do this.
-	if l := copy.List(); l.Len() > 0 {
-		copy.SetList(copyList(l))
-	}
-	if l := copy.Rlist(); l.Len() > 0 {
-		copy.SetRlist(copyList(l))
-	}
-	if l := copy.Init(); l.Len() > 0 {
-		copy.SetInit(copyList(l))
-	}
-	if l := copy.Body(); l.Len() > 0 {
-		copy.SetBody(copyList(l))
-	}
-
-	return copy
+	return c
 }
 
 func copyList(x Nodes) Nodes {
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 9600d13d8e..7431a56d94 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -76,10 +76,16 @@ func NewAddStringExpr(pos src.XPos, list []Node) *AddStringExpr {
 
 func (n *AddStringExpr) String() string                { return fmt.Sprint(n) }
 func (n *AddStringExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *AddStringExpr) rawCopy() Node                 { c := *n; return &c }
-func (n *AddStringExpr) List() Nodes                   { return n.list }
-func (n *AddStringExpr) PtrList() *Nodes               { return &n.list }
-func (n *AddStringExpr) SetList(x Nodes)               { n.list = x }
+func (n *AddStringExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.list = c.list.Copy()
+	return &c
+}
+
+func (n *AddStringExpr) List() Nodes     { return n.list }
+func (n *AddStringExpr) PtrList() *Nodes { return &n.list }
+func (n *AddStringExpr) SetList(x Nodes) { n.list = x }
 
 // An AddrExpr is an address-of expression &X.
 // It may end up being a normal address-of or an allocation of a composite literal.
@@ -98,11 +104,16 @@ func NewAddrExpr(pos src.XPos, x Node) *AddrExpr {
 
 func (n *AddrExpr) String() string                { return fmt.Sprint(n) }
 func (n *AddrExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *AddrExpr) rawCopy() Node                 { c := *n; return &c }
-func (n *AddrExpr) Left() Node                    { return n.X }
-func (n *AddrExpr) SetLeft(x Node)                { n.X = x }
-func (n *AddrExpr) Right() Node                   { return n.Alloc }
-func (n *AddrExpr) SetRight(x Node)               { n.Alloc = x }
+func (n *AddrExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+
+func (n *AddrExpr) Left() Node      { return n.X }
+func (n *AddrExpr) SetLeft(x Node)  { n.X = x }
+func (n *AddrExpr) Right() Node     { return n.Alloc }
+func (n *AddrExpr) SetRight(x Node) { n.Alloc = x }
 
 func (n *AddrExpr) SetOp(op Op) {
 	switch op {
@@ -130,11 +141,16 @@ func NewBinaryExpr(pos src.XPos, op Op, x, y Node) *BinaryExpr {
 
 func (n *BinaryExpr) String() string                { return fmt.Sprint(n) }
 func (n *BinaryExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *BinaryExpr) rawCopy() Node                 { c := *n; return &c }
-func (n *BinaryExpr) Left() Node                    { return n.X }
-func (n *BinaryExpr) SetLeft(x Node)                { n.X = x }
-func (n *BinaryExpr) Right() Node                   { return n.Y }
-func (n *BinaryExpr) SetRight(y Node)               { n.Y = y }
+func (n *BinaryExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+
+func (n *BinaryExpr) Left() Node      { return n.X }
+func (n *BinaryExpr) SetLeft(x Node)  { n.X = x }
+func (n *BinaryExpr) Right() Node     { return n.Y }
+func (n *BinaryExpr) SetRight(y Node) { n.Y = y }
 
 func (n *BinaryExpr) SetOp(op Op) {
 	switch op {
@@ -183,24 +199,32 @@ func NewCallExpr(pos src.XPos, fun Node, args []Node) *CallExpr {
 
 func (n *CallExpr) String() string                { return fmt.Sprint(n) }
 func (n *CallExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *CallExpr) rawCopy() Node                 { c := *n; return &c }
-func (n *CallExpr) Orig() Node                    { return n.orig }
-func (n *CallExpr) SetOrig(x Node)                { n.orig = x }
-func (n *CallExpr) Left() Node                    { return n.X }
-func (n *CallExpr) SetLeft(x Node)                { n.X = x }
-func (n *CallExpr) List() Nodes                   { return n.Args }
-func (n *CallExpr) PtrList() *Nodes               { return &n.Args }
-func (n *CallExpr) SetList(x Nodes)               { n.Args = x }
-func (n *CallExpr) Rlist() Nodes                  { return n.Rargs }
-func (n *CallExpr) PtrRlist() *Nodes              { return &n.Rargs }
-func (n *CallExpr) SetRlist(x Nodes)              { n.Rargs = x }
-func (n *CallExpr) IsDDD() bool                   { return n.DDD }
-func (n *CallExpr) SetIsDDD(x bool)               { n.DDD = x }
-func (n *CallExpr) NoInline() bool                { return n.noInline }
-func (n *CallExpr) SetNoInline(x bool)            { n.noInline = x }
-func (n *CallExpr) Body() Nodes                   { return n.body }
-func (n *CallExpr) PtrBody() *Nodes               { return &n.body }
-func (n *CallExpr) SetBody(x Nodes)               { n.body = x }
+func (n *CallExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.Args = c.Args.Copy()
+	c.Rargs = c.Rargs.Copy()
+	c.body = c.body.Copy()
+	return &c
+}
+
+func (n *CallExpr) Orig() Node         { return n.orig }
+func (n *CallExpr) SetOrig(x Node)     { n.orig = x }
+func (n *CallExpr) Left() Node         { return n.X }
+func (n *CallExpr) SetLeft(x Node)     { n.X = x }
+func (n *CallExpr) List() Nodes        { return n.Args }
+func (n *CallExpr) PtrList() *Nodes    { return &n.Args }
+func (n *CallExpr) SetList(x Nodes)    { n.Args = x }
+func (n *CallExpr) Rlist() Nodes       { return n.Rargs }
+func (n *CallExpr) PtrRlist() *Nodes   { return &n.Rargs }
+func (n *CallExpr) SetRlist(x Nodes)   { n.Rargs = x }
+func (n *CallExpr) IsDDD() bool        { return n.DDD }
+func (n *CallExpr) SetIsDDD(x bool)    { n.DDD = x }
+func (n *CallExpr) NoInline() bool     { return n.noInline }
+func (n *CallExpr) SetNoInline(x bool) { n.noInline = x }
+func (n *CallExpr) Body() Nodes        { return n.body }
+func (n *CallExpr) PtrBody() *Nodes    { return &n.body }
+func (n *CallExpr) SetBody(x Nodes)    { n.body = x }
 
 func (n *CallExpr) SetOp(op Op) {
 	switch op {
@@ -231,11 +255,16 @@ func NewCallPartExpr(pos src.XPos, x Node, method *types.Field, fn *Func) *CallP
 
 func (n *CallPartExpr) String() string                { return fmt.Sprint(n) }
 func (n *CallPartExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *CallPartExpr) rawCopy() Node                 { c := *n; return &c }
-func (n *CallPartExpr) Func() *Func                   { return n.fn }
-func (n *CallPartExpr) Left() Node                    { return n.X }
-func (n *CallPartExpr) Sym() *types.Sym               { return n.Method.Sym }
-func (n *CallPartExpr) SetLeft(x Node)                { n.X = x }
+func (n *CallPartExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+
+func (n *CallPartExpr) Func() *Func     { return n.fn }
+func (n *CallPartExpr) Left() Node      { return n.X }
+func (n *CallPartExpr) Sym() *types.Sym { return n.Method.Sym }
+func (n *CallPartExpr) SetLeft(x Node)  { n.X = x }
 
 // A ClosureExpr is a function literal expression.
 type ClosureExpr struct {
@@ -252,8 +281,13 @@ func NewClosureExpr(pos src.XPos, fn *Func) *ClosureExpr {
 
 func (n *ClosureExpr) String() string                { return fmt.Sprint(n) }
 func (n *ClosureExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ClosureExpr) rawCopy() Node                 { c := *n; return &c }
-func (n *ClosureExpr) Func() *Func                   { return n.fn }
+func (n *ClosureExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+
+func (n *ClosureExpr) Func() *Func { return n.fn }
 
 // A ClosureRead denotes reading a variable stored within a closure struct.
 type ClosureRead struct {
@@ -270,9 +304,14 @@ func NewClosureRead(typ *types.Type, offset int64) *ClosureRead {
 
 func (n *ClosureRead) String() string                { return fmt.Sprint(n) }
 func (n *ClosureRead) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ClosureRead) rawCopy() Node                 { c := *n; return &c }
-func (n *ClosureRead) Type() *types.Type             { return n.typ }
-func (n *ClosureRead) Offset() int64                 { return n.offset }
+func (n *ClosureRead) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+
+func (n *ClosureRead) Type() *types.Type { return n.typ }
+func (n *ClosureRead) Offset() int64     { return n.offset }
 
 // A CompLitExpr is a composite literal Type{Vals}.
 // Before type-checking, the type is Ntype.
@@ -294,14 +333,20 @@ func NewCompLitExpr(pos src.XPos, typ Ntype, list []Node) *CompLitExpr {
 
 func (n *CompLitExpr) String() string                { return fmt.Sprint(n) }
 func (n *CompLitExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *CompLitExpr) rawCopy() Node                 { c := *n; return &c }
-func (n *CompLitExpr) Orig() Node                    { return n.orig }
-func (n *CompLitExpr) SetOrig(x Node)                { n.orig = x }
-func (n *CompLitExpr) Right() Node                   { return n.Ntype }
-func (n *CompLitExpr) SetRight(x Node)               { n.Ntype = toNtype(x) }
-func (n *CompLitExpr) List() Nodes                   { return n.list }
-func (n *CompLitExpr) PtrList() *Nodes               { return &n.list }
-func (n *CompLitExpr) SetList(x Nodes)               { n.list = x }
+func (n *CompLitExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.list = c.list.Copy()
+	return &c
+}
+
+func (n *CompLitExpr) Orig() Node      { return n.orig }
+func (n *CompLitExpr) SetOrig(x Node)  { n.orig = x }
+func (n *CompLitExpr) Right() Node     { return n.Ntype }
+func (n *CompLitExpr) SetRight(x Node) { n.Ntype = toNtype(x) }
+func (n *CompLitExpr) List() Nodes     { return n.list }
+func (n *CompLitExpr) PtrList() *Nodes { return &n.list }
+func (n *CompLitExpr) SetList(x Nodes) { n.list = x }
 
 func (n *CompLitExpr) SetOp(op Op) {
 	switch op {
@@ -330,11 +375,12 @@ func NewConstExpr(val constant.Value, orig Node) Node {
 
 func (n *ConstExpr) String() string                { return fmt.Sprint(n) }
 func (n *ConstExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ConstExpr) rawCopy() Node                 { c := *n; return &c }
-func (n *ConstExpr) Sym() *types.Sym               { return n.orig.Sym() }
-func (n *ConstExpr) Orig() Node                    { return n.orig }
-func (n *ConstExpr) SetOrig(orig Node)             { panic(n.no("SetOrig")) }
-func (n *ConstExpr) Val() constant.Value           { return n.val }
+func (n *ConstExpr) copy() Node                    { c := *n; return &c }
+
+func (n *ConstExpr) Sym() *types.Sym     { return n.orig.Sym() }
+func (n *ConstExpr) Orig() Node          { return n.orig }
+func (n *ConstExpr) SetOrig(orig Node)   { panic(n.no("SetOrig")) }
+func (n *ConstExpr) Val() constant.Value { return n.val }
 
 // A ConvExpr is a conversion Type(X).
 // It may end up being a value or a type.
@@ -355,9 +401,15 @@ func NewConvExpr(pos src.XPos, op Op, typ *types.Type, x Node) *ConvExpr {
 
 func (n *ConvExpr) String() string                { return fmt.Sprint(n) }
 func (n *ConvExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ConvExpr) rawCopy() Node                 { c := *n; return &c }
-func (n *ConvExpr) Left() Node                    { return n.X }
-func (n *ConvExpr) SetLeft(x Node)                { n.X = x }
+func (n *ConvExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+
+func (n *ConvExpr) rawCopy() Node  { c := *n; return &c }
+func (n *ConvExpr) Left() Node     { return n.X }
+func (n *ConvExpr) SetLeft(x Node) { n.X = x }
 
 func (n *ConvExpr) SetOp(op Op) {
 	switch op {
@@ -385,13 +437,18 @@ func NewIndexExpr(pos src.XPos, x, index Node) *IndexExpr {
 
 func (n *IndexExpr) String() string                { return fmt.Sprint(n) }
 func (n *IndexExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *IndexExpr) rawCopy() Node                 { c := *n; return &c }
-func (n *IndexExpr) Left() Node                    { return n.X }
-func (n *IndexExpr) SetLeft(x Node)                { n.X = x }
-func (n *IndexExpr) Right() Node                   { return n.Index }
-func (n *IndexExpr) SetRight(y Node)               { n.Index = y }
-func (n *IndexExpr) IndexMapLValue() bool          { return n.Assigned }
-func (n *IndexExpr) SetIndexMapLValue(x bool)      { n.Assigned = x }
+func (n *IndexExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+
+func (n *IndexExpr) Left() Node               { return n.X }
+func (n *IndexExpr) SetLeft(x Node)           { n.X = x }
+func (n *IndexExpr) Right() Node              { return n.Index }
+func (n *IndexExpr) SetRight(y Node)          { n.Index = y }
+func (n *IndexExpr) IndexMapLValue() bool     { return n.Assigned }
+func (n *IndexExpr) SetIndexMapLValue(x bool) { n.Assigned = x }
 
 func (n *IndexExpr) SetOp(op Op) {
 	switch op {
@@ -422,15 +479,20 @@ func NewKeyExpr(pos src.XPos, key, value Node) *KeyExpr {
 
 func (n *KeyExpr) String() string                { return fmt.Sprint(n) }
 func (n *KeyExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *KeyExpr) rawCopy() Node                 { c := *n; return &c }
-func (n *KeyExpr) Left() Node                    { return n.Key }
-func (n *KeyExpr) SetLeft(x Node)                { n.Key = x }
-func (n *KeyExpr) Right() Node                   { return n.Value }
-func (n *KeyExpr) SetRight(y Node)               { n.Value = y }
-func (n *KeyExpr) Sym() *types.Sym               { return n.sym }
-func (n *KeyExpr) SetSym(x *types.Sym)           { n.sym = x }
-func (n *KeyExpr) Offset() int64                 { return n.offset }
-func (n *KeyExpr) SetOffset(x int64)             { n.offset = x }
+func (n *KeyExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+
+func (n *KeyExpr) Left() Node          { return n.Key }
+func (n *KeyExpr) SetLeft(x Node)      { n.Key = x }
+func (n *KeyExpr) Right() Node         { return n.Value }
+func (n *KeyExpr) SetRight(y Node)     { n.Value = y }
+func (n *KeyExpr) Sym() *types.Sym     { return n.sym }
+func (n *KeyExpr) SetSym(x *types.Sym) { n.sym = x }
+func (n *KeyExpr) Offset() int64       { return n.offset }
+func (n *KeyExpr) SetOffset(x int64)   { n.offset = x }
 
 func (n *KeyExpr) SetOp(op Op) {
 	switch op {
@@ -459,13 +521,20 @@ func NewInlinedCallExpr(pos src.XPos, body, retvars []Node) *InlinedCallExpr {
 
 func (n *InlinedCallExpr) String() string                { return fmt.Sprint(n) }
 func (n *InlinedCallExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *InlinedCallExpr) rawCopy() Node                 { c := *n; return &c }
-func (n *InlinedCallExpr) Body() Nodes                   { return n.body }
-func (n *InlinedCallExpr) PtrBody() *Nodes               { return &n.body }
-func (n *InlinedCallExpr) SetBody(x Nodes)               { n.body = x }
-func (n *InlinedCallExpr) Rlist() Nodes                  { return n.ReturnVars }
-func (n *InlinedCallExpr) PtrRlist() *Nodes              { return &n.ReturnVars }
-func (n *InlinedCallExpr) SetRlist(x Nodes)              { n.ReturnVars = x }
+func (n *InlinedCallExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.body = c.body.Copy()
+	c.ReturnVars = c.ReturnVars.Copy()
+	return &c
+}
+
+func (n *InlinedCallExpr) Body() Nodes      { return n.body }
+func (n *InlinedCallExpr) PtrBody() *Nodes  { return &n.body }
+func (n *InlinedCallExpr) SetBody(x Nodes)  { n.body = x }
+func (n *InlinedCallExpr) Rlist() Nodes     { return n.ReturnVars }
+func (n *InlinedCallExpr) PtrRlist() *Nodes { return &n.ReturnVars }
+func (n *InlinedCallExpr) SetRlist(x Nodes) { n.ReturnVars = x }
 
 // A MakeExpr is a make expression: make(Type[, Len[, Cap]]).
 // Op is OMAKECHAN, OMAKEMAP, OMAKESLICE, or OMAKESLICECOPY,
@@ -485,11 +554,16 @@ func NewMakeExpr(pos src.XPos, op Op, len, cap Node) *MakeExpr {
 
 func (n *MakeExpr) String() string                { return fmt.Sprint(n) }
 func (n *MakeExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *MakeExpr) rawCopy() Node                 { c := *n; return &c }
-func (n *MakeExpr) Left() Node                    { return n.Len }
-func (n *MakeExpr) SetLeft(x Node)                { n.Len = x }
-func (n *MakeExpr) Right() Node                   { return n.Cap }
-func (n *MakeExpr) SetRight(x Node)               { n.Cap = x }
+func (n *MakeExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+
+func (n *MakeExpr) Left() Node      { return n.Len }
+func (n *MakeExpr) SetLeft(x Node)  { n.Len = x }
+func (n *MakeExpr) Right() Node     { return n.Cap }
+func (n *MakeExpr) SetRight(x Node) { n.Cap = x }
 
 func (n *MakeExpr) SetOp(op Op) {
 	switch op {
@@ -521,17 +595,22 @@ func NewMethodExpr(pos src.XPos, op Op, x, m Node) *MethodExpr {
 
 func (n *MethodExpr) String() string                { return fmt.Sprint(n) }
 func (n *MethodExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *MethodExpr) rawCopy() Node                 { c := *n; return &c }
-func (n *MethodExpr) Left() Node                    { return n.X }
-func (n *MethodExpr) SetLeft(x Node)                { n.X = x }
-func (n *MethodExpr) Right() Node                   { return n.M }
-func (n *MethodExpr) SetRight(y Node)               { n.M = y }
-func (n *MethodExpr) Sym() *types.Sym               { return n.sym }
-func (n *MethodExpr) SetSym(x *types.Sym)           { n.sym = x }
-func (n *MethodExpr) Offset() int64                 { return n.offset }
-func (n *MethodExpr) SetOffset(x int64)             { n.offset = x }
-func (n *MethodExpr) Class() Class                  { return n.class }
-func (n *MethodExpr) SetClass(x Class)              { n.class = x }
+func (n *MethodExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+
+func (n *MethodExpr) Left() Node          { return n.X }
+func (n *MethodExpr) SetLeft(x Node)      { n.X = x }
+func (n *MethodExpr) Right() Node         { return n.M }
+func (n *MethodExpr) SetRight(y Node)     { n.M = y }
+func (n *MethodExpr) Sym() *types.Sym     { return n.sym }
+func (n *MethodExpr) SetSym(x *types.Sym) { n.sym = x }
+func (n *MethodExpr) Offset() int64       { return n.offset }
+func (n *MethodExpr) SetOffset(x int64)   { n.offset = x }
+func (n *MethodExpr) Class() Class        { return n.class }
+func (n *MethodExpr) SetClass(x Class)    { n.class = x }
 
 // A NilExpr represents the predefined untyped constant nil.
 // (It may be copied and assigned a type, though.)
@@ -549,9 +628,14 @@ func NewNilExpr(pos src.XPos) *NilExpr {
 
 func (n *NilExpr) String() string                { return fmt.Sprint(n) }
 func (n *NilExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *NilExpr) rawCopy() Node                 { c := *n; return &c }
-func (n *NilExpr) Sym() *types.Sym               { return n.sym }
-func (n *NilExpr) SetSym(x *types.Sym)           { n.sym = x }
+func (n *NilExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+
+func (n *NilExpr) Sym() *types.Sym     { return n.sym }
+func (n *NilExpr) SetSym(x *types.Sym) { n.sym = x }
 
 // A ParenExpr is a parenthesized expression (X).
 // It may end up being a value or a type.
@@ -569,9 +653,14 @@ func NewParenExpr(pos src.XPos, x Node) *ParenExpr {
 
 func (n *ParenExpr) String() string                { return fmt.Sprint(n) }
 func (n *ParenExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ParenExpr) rawCopy() Node                 { c := *n; return &c }
-func (n *ParenExpr) Left() Node                    { return n.X }
-func (n *ParenExpr) SetLeft(x Node)                { n.X = x }
+func (n *ParenExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+
+func (n *ParenExpr) Left() Node     { return n.X }
+func (n *ParenExpr) SetLeft(x Node) { n.X = x }
 
 func (*ParenExpr) CanBeNtype() {}
 
@@ -599,9 +688,14 @@ func NewResultExpr(pos src.XPos, typ *types.Type, offset int64) *ResultExpr {
 
 func (n *ResultExpr) String() string                { return fmt.Sprint(n) }
 func (n *ResultExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ResultExpr) rawCopy() Node                 { c := *n; return &c }
-func (n *ResultExpr) Offset() int64                 { return n.offset }
-func (n *ResultExpr) SetOffset(x int64)             { n.offset = x }
+func (n *ResultExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+
+func (n *ResultExpr) Offset() int64     { return n.offset }
+func (n *ResultExpr) SetOffset(x int64) { n.offset = x }
 
 // A SelectorExpr is a selector expression X.Sym.
 type SelectorExpr struct {
@@ -631,13 +725,18 @@ func (n *SelectorExpr) SetOp(op Op) {
 
 func (n *SelectorExpr) String() string                { return fmt.Sprint(n) }
 func (n *SelectorExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *SelectorExpr) rawCopy() Node                 { c := *n; return &c }
-func (n *SelectorExpr) Left() Node                    { return n.X }
-func (n *SelectorExpr) SetLeft(x Node)                { n.X = x }
-func (n *SelectorExpr) Sym() *types.Sym               { return n.Sel }
-func (n *SelectorExpr) SetSym(x *types.Sym)           { n.Sel = x }
-func (n *SelectorExpr) Offset() int64                 { return n.offset }
-func (n *SelectorExpr) SetOffset(x int64)             { n.offset = x }
+func (n *SelectorExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+
+func (n *SelectorExpr) Left() Node          { return n.X }
+func (n *SelectorExpr) SetLeft(x Node)      { n.X = x }
+func (n *SelectorExpr) Sym() *types.Sym     { return n.Sel }
+func (n *SelectorExpr) SetSym(x *types.Sym) { n.Sel = x }
+func (n *SelectorExpr) Offset() int64       { return n.offset }
+func (n *SelectorExpr) SetOffset(x int64)   { n.offset = x }
 
 // Before type-checking, bytes.Buffer is a SelectorExpr.
 // After type-checking it becomes a Name.
@@ -659,12 +758,18 @@ func NewSliceExpr(pos src.XPos, op Op, x Node) *SliceExpr {
 
 func (n *SliceExpr) String() string                { return fmt.Sprint(n) }
 func (n *SliceExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *SliceExpr) rawCopy() Node                 { c := *n; return &c }
-func (n *SliceExpr) Left() Node                    { return n.X }
-func (n *SliceExpr) SetLeft(x Node)                { n.X = x }
-func (n *SliceExpr) List() Nodes                   { return n.list }
-func (n *SliceExpr) PtrList() *Nodes               { return &n.list }
-func (n *SliceExpr) SetList(x Nodes)               { n.list = x }
+func (n *SliceExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.list = c.list.Copy()
+	return &c
+}
+
+func (n *SliceExpr) Left() Node      { return n.X }
+func (n *SliceExpr) SetLeft(x Node)  { n.X = x }
+func (n *SliceExpr) List() Nodes     { return n.list }
+func (n *SliceExpr) PtrList() *Nodes { return &n.list }
+func (n *SliceExpr) SetList(x Nodes) { n.list = x }
 
 func (n *SliceExpr) SetOp(op Op) {
 	switch op {
@@ -761,12 +866,17 @@ func NewSliceHeaderExpr(pos src.XPos, typ *types.Type, ptr, len, cap Node) *Slic
 
 func (n *SliceHeaderExpr) String() string                { return fmt.Sprint(n) }
 func (n *SliceHeaderExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *SliceHeaderExpr) rawCopy() Node                 { c := *n; return &c }
-func (n *SliceHeaderExpr) Left() Node                    { return n.Ptr }
-func (n *SliceHeaderExpr) SetLeft(x Node)                { n.Ptr = x }
-func (n *SliceHeaderExpr) List() Nodes                   { return n.lenCap }
-func (n *SliceHeaderExpr) PtrList() *Nodes               { return &n.lenCap }
-func (n *SliceHeaderExpr) SetList(x Nodes)               { n.lenCap = x }
+func (n *SliceHeaderExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+
+func (n *SliceHeaderExpr) Left() Node      { return n.Ptr }
+func (n *SliceHeaderExpr) SetLeft(x Node)  { n.Ptr = x }
+func (n *SliceHeaderExpr) List() Nodes     { return n.lenCap }
+func (n *SliceHeaderExpr) PtrList() *Nodes { return &n.lenCap }
+func (n *SliceHeaderExpr) SetList(x Nodes) { n.lenCap = x }
 
 // A StarExpr is a dereference expression *X.
 // It may end up being a value or a type.
@@ -784,9 +894,14 @@ func NewStarExpr(pos src.XPos, x Node) *StarExpr {
 
 func (n *StarExpr) String() string                { return fmt.Sprint(n) }
 func (n *StarExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *StarExpr) rawCopy() Node                 { c := *n; return &c }
-func (n *StarExpr) Left() Node                    { return n.X }
-func (n *StarExpr) SetLeft(x Node)                { n.X = x }
+func (n *StarExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+
+func (n *StarExpr) Left() Node     { return n.X }
+func (n *StarExpr) SetLeft(x Node) { n.X = x }
 
 func (*StarExpr) CanBeNtype() {}
 
@@ -828,14 +943,20 @@ func NewTypeAssertExpr(pos src.XPos, x Node, typ Ntype) *TypeAssertExpr {
 
 func (n *TypeAssertExpr) String() string                { return fmt.Sprint(n) }
 func (n *TypeAssertExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *TypeAssertExpr) rawCopy() Node                 { c := *n; return &c }
-func (n *TypeAssertExpr) Left() Node                    { return n.X }
-func (n *TypeAssertExpr) SetLeft(x Node)                { n.X = x }
-func (n *TypeAssertExpr) Right() Node                   { return n.Ntype }
-func (n *TypeAssertExpr) SetRight(x Node)               { n.Ntype = x } // TODO: toNtype(x)
-func (n *TypeAssertExpr) List() Nodes                   { return n.Itab }
-func (n *TypeAssertExpr) PtrList() *Nodes               { return &n.Itab }
-func (n *TypeAssertExpr) SetList(x Nodes)               { n.Itab = x }
+func (n *TypeAssertExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.Itab = c.Itab.Copy()
+	return &c
+}
+
+func (n *TypeAssertExpr) Left() Node      { return n.X }
+func (n *TypeAssertExpr) SetLeft(x Node)  { n.X = x }
+func (n *TypeAssertExpr) Right() Node     { return n.Ntype }
+func (n *TypeAssertExpr) SetRight(x Node) { n.Ntype = x } // TODO: toNtype(x)
+func (n *TypeAssertExpr) List() Nodes     { return n.Itab }
+func (n *TypeAssertExpr) PtrList() *Nodes { return &n.Itab }
+func (n *TypeAssertExpr) SetList(x Nodes) { n.Itab = x }
 
 func (n *TypeAssertExpr) SetOp(op Op) {
 	switch op {
@@ -862,9 +983,14 @@ func NewUnaryExpr(pos src.XPos, op Op, x Node) *UnaryExpr {
 
 func (n *UnaryExpr) String() string                { return fmt.Sprint(n) }
 func (n *UnaryExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *UnaryExpr) rawCopy() Node                 { c := *n; return &c }
-func (n *UnaryExpr) Left() Node                    { return n.X }
-func (n *UnaryExpr) SetLeft(x Node)                { n.X = x }
+func (n *UnaryExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+
+func (n *UnaryExpr) Left() Node     { return n.X }
+func (n *UnaryExpr) SetLeft(x Node) { n.X = x }
 
 func (n *UnaryExpr) SetOp(op Op) {
 	switch op {
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 98830fb502..ae803cd6a5 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -117,7 +117,7 @@ func NewFunc(pos src.XPos) *Func {
 
 func (f *Func) String() string                { return fmt.Sprint(f) }
 func (f *Func) Format(s fmt.State, verb rune) { FmtNode(f, s, verb) }
-func (f *Func) rawCopy() Node                 { panic(f.no("rawCopy")) }
+func (f *Func) copy() Node                    { panic(f.no("copy")) }
 func (f *Func) Func() *Func                   { return f }
 func (f *Func) Body() Nodes                   { return f.body }
 func (f *Func) PtrBody() *Nodes               { return &f.body }
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 67d4d2b391..dc8c58e4f4 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -151,7 +151,7 @@ func newNameAt(pos src.XPos, op Op, sym *types.Sym) *Name {
 
 func (n *Name) String() string                { return fmt.Sprint(n) }
 func (n *Name) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *Name) rawCopy() Node                 { c := *n; return &c }
+func (n *Name) copy() Node                    { c := *n; return &c }
 func (n *Name) Name() *Name                   { return n }
 func (n *Name) Sym() *types.Sym               { return n.sym }
 func (n *Name) SetSym(x *types.Sym)           { n.sym = x }
@@ -323,7 +323,7 @@ type PkgName struct {
 
 func (p *PkgName) String() string                { return fmt.Sprint(p) }
 func (p *PkgName) Format(s fmt.State, verb rune) { FmtNode(p, s, verb) }
-func (p *PkgName) rawCopy() Node                 { c := *p; return &c }
+func (p *PkgName) copy() Node                    { c := *p; return &c }
 func (p *PkgName) Sym() *types.Sym               { return p.sym }
 
 func (*PkgName) CanBeNtype() {}
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index c3184a3a0b..705eb9e47e 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -27,8 +27,8 @@ type Node interface {
 	Pos() src.XPos
 	SetPos(x src.XPos)
 
-	// For making copies. Mainly used by Copy and SepCopy.
-	rawCopy() Node
+	// For making copies. For Copy and SepCopy.
+	copy() Node
 
 	// Abstract graph structure, for generic traversals.
 	Op() Op
@@ -521,6 +521,21 @@ func (n *Nodes) AppendNodes(n2 *Nodes) {
 	n2.slice = nil
 }
 
+// Copy returns a copy of the content of the slice.
+func (n Nodes) Copy() Nodes {
+	var c Nodes
+	if n.slice == nil {
+		return c
+	}
+	c.slice = new([]Node)
+	if *n.slice == nil {
+		return c
+	}
+	*c.slice = make([]Node, n.Len())
+	copy(*c.slice, n.Slice())
+	return c
+}
+
 // nodeQueue is a FIFO queue of *Node. The zero value of nodeQueue is
 // a ready-to-use empty queue.
 type NodeQueue struct {
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index a6bbab4889..5af6a62cf2 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -31,7 +31,7 @@ func NewDecl(pos src.XPos, op Op, x Node) *Decl {
 
 func (n *Decl) String() string                { return fmt.Sprint(n) }
 func (n *Decl) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *Decl) rawCopy() Node                 { c := *n; return &c }
+func (n *Decl) copy() Node                    { c := *n; return &c }
 func (n *Decl) Left() Node                    { return n.X }
 func (n *Decl) SetLeft(x Node)                { n.X = x }
 
@@ -70,7 +70,13 @@ func NewAssignListStmt(pos src.XPos, lhs, rhs []Node) *AssignListStmt {
 
 func (n *AssignListStmt) String() string                { return fmt.Sprint(n) }
 func (n *AssignListStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *AssignListStmt) rawCopy() Node                 { c := *n; return &c }
+func (n *AssignListStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.Lhs = c.Lhs.Copy()
+	c.Rhs = c.Rhs.Copy()
+	return &c
+}
 
 func (n *AssignListStmt) List() Nodes       { return n.Lhs }
 func (n *AssignListStmt) PtrList() *Nodes   { return &n.Lhs }
@@ -112,7 +118,11 @@ func NewAssignStmt(pos src.XPos, x, y Node) *AssignStmt {
 
 func (n *AssignStmt) String() string                { return fmt.Sprint(n) }
 func (n *AssignStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *AssignStmt) rawCopy() Node                 { c := *n; return &c }
+func (n *AssignStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
 
 func (n *AssignStmt) Left() Node        { return n.X }
 func (n *AssignStmt) SetLeft(x Node)    { n.X = x }
@@ -151,7 +161,11 @@ func NewAssignOpStmt(pos src.XPos, op Op, x, y Node) *AssignOpStmt {
 
 func (n *AssignOpStmt) String() string                { return fmt.Sprint(n) }
 func (n *AssignOpStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *AssignOpStmt) rawCopy() Node                 { c := *n; return &c }
+func (n *AssignOpStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
 
 func (n *AssignOpStmt) Left() Node            { return n.X }
 func (n *AssignOpStmt) SetLeft(x Node)        { n.X = x }
@@ -180,10 +194,16 @@ func NewBlockStmt(pos src.XPos, list []Node) *BlockStmt {
 
 func (n *BlockStmt) String() string                { return fmt.Sprint(n) }
 func (n *BlockStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *BlockStmt) rawCopy() Node                 { c := *n; return &c }
-func (n *BlockStmt) List() Nodes                   { return n.list }
-func (n *BlockStmt) PtrList() *Nodes               { return &n.list }
-func (n *BlockStmt) SetList(x Nodes)               { n.list = x }
+func (n *BlockStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.list = c.list.Copy()
+	return &c
+}
+
+func (n *BlockStmt) List() Nodes     { return n.list }
+func (n *BlockStmt) PtrList() *Nodes { return &n.list }
+func (n *BlockStmt) SetList(x Nodes) { n.list = x }
 
 // A BranchStmt is a break, continue, fallthrough, or goto statement.
 //
@@ -209,9 +229,14 @@ func NewBranchStmt(pos src.XPos, op Op, label *types.Sym) *BranchStmt {
 
 func (n *BranchStmt) String() string                { return fmt.Sprint(n) }
 func (n *BranchStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *BranchStmt) rawCopy() Node                 { c := *n; return &c }
-func (n *BranchStmt) Sym() *types.Sym               { return n.Label }
-func (n *BranchStmt) SetSym(sym *types.Sym)         { n.Label = sym }
+func (n *BranchStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+
+func (n *BranchStmt) Sym() *types.Sym       { return n.Label }
+func (n *BranchStmt) SetSym(sym *types.Sym) { n.Label = sym }
 
 // A CaseStmt is a case statement in a switch or select: case List: Body.
 type CaseStmt struct {
@@ -233,18 +258,26 @@ func NewCaseStmt(pos src.XPos, list, body []Node) *CaseStmt {
 
 func (n *CaseStmt) String() string                { return fmt.Sprint(n) }
 func (n *CaseStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *CaseStmt) rawCopy() Node                 { c := *n; return &c }
-func (n *CaseStmt) List() Nodes                   { return n.list }
-func (n *CaseStmt) PtrList() *Nodes               { return &n.list }
-func (n *CaseStmt) SetList(x Nodes)               { n.list = x }
-func (n *CaseStmt) Body() Nodes                   { return n.body }
-func (n *CaseStmt) PtrBody() *Nodes               { return &n.body }
-func (n *CaseStmt) SetBody(x Nodes)               { n.body = x }
-func (n *CaseStmt) Rlist() Nodes                  { return n.Vars }
-func (n *CaseStmt) PtrRlist() *Nodes              { return &n.Vars }
-func (n *CaseStmt) SetRlist(x Nodes)              { n.Vars = x }
-func (n *CaseStmt) Left() Node                    { return n.Comm }
-func (n *CaseStmt) SetLeft(x Node)                { n.Comm = x }
+func (n *CaseStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.Vars = c.Vars.Copy()
+	c.list = c.list.Copy()
+	c.body = c.body.Copy()
+	return &c
+}
+
+func (n *CaseStmt) List() Nodes      { return n.list }
+func (n *CaseStmt) PtrList() *Nodes  { return &n.list }
+func (n *CaseStmt) SetList(x Nodes)  { n.list = x }
+func (n *CaseStmt) Body() Nodes      { return n.body }
+func (n *CaseStmt) PtrBody() *Nodes  { return &n.body }
+func (n *CaseStmt) SetBody(x Nodes)  { n.body = x }
+func (n *CaseStmt) Rlist() Nodes     { return n.Vars }
+func (n *CaseStmt) PtrRlist() *Nodes { return &n.Vars }
+func (n *CaseStmt) SetRlist(x Nodes) { n.Vars = x }
+func (n *CaseStmt) Left() Node       { return n.Comm }
+func (n *CaseStmt) SetLeft(x Node)   { n.Comm = x }
 
 // A DeferStmt is a defer statement: defer Call.
 type DeferStmt struct {
@@ -261,7 +294,11 @@ func NewDeferStmt(pos src.XPos, call Node) *DeferStmt {
 
 func (n *DeferStmt) String() string                { return fmt.Sprint(n) }
 func (n *DeferStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *DeferStmt) rawCopy() Node                 { c := *n; return &c }
+func (n *DeferStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
 
 func (n *DeferStmt) Left() Node     { return n.Call }
 func (n *DeferStmt) SetLeft(x Node) { n.Call = x }
@@ -289,21 +326,28 @@ func NewForStmt(pos src.XPos, init []Node, cond, post Node, body []Node) *ForStm
 
 func (n *ForStmt) String() string                { return fmt.Sprint(n) }
 func (n *ForStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ForStmt) rawCopy() Node                 { c := *n; return &c }
-func (n *ForStmt) Sym() *types.Sym               { return n.Label }
-func (n *ForStmt) SetSym(x *types.Sym)           { n.Label = x }
-func (n *ForStmt) Left() Node                    { return n.Cond }
-func (n *ForStmt) SetLeft(x Node)                { n.Cond = x }
-func (n *ForStmt) Right() Node                   { return n.Post }
-func (n *ForStmt) SetRight(x Node)               { n.Post = x }
-func (n *ForStmt) Body() Nodes                   { return n.body }
-func (n *ForStmt) PtrBody() *Nodes               { return &n.body }
-func (n *ForStmt) SetBody(x Nodes)               { n.body = x }
-func (n *ForStmt) List() Nodes                   { return n.Late }
-func (n *ForStmt) PtrList() *Nodes               { return &n.Late }
-func (n *ForStmt) SetList(x Nodes)               { n.Late = x }
-func (n *ForStmt) HasBreak() bool                { return n.hasBreak }
-func (n *ForStmt) SetHasBreak(b bool)            { n.hasBreak = b }
+func (n *ForStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.Late = c.Late.Copy()
+	c.body = c.body.Copy()
+	return &c
+}
+
+func (n *ForStmt) Sym() *types.Sym     { return n.Label }
+func (n *ForStmt) SetSym(x *types.Sym) { n.Label = x }
+func (n *ForStmt) Left() Node          { return n.Cond }
+func (n *ForStmt) SetLeft(x Node)      { n.Cond = x }
+func (n *ForStmt) Right() Node         { return n.Post }
+func (n *ForStmt) SetRight(x Node)     { n.Post = x }
+func (n *ForStmt) Body() Nodes         { return n.body }
+func (n *ForStmt) PtrBody() *Nodes     { return &n.body }
+func (n *ForStmt) SetBody(x Nodes)     { n.body = x }
+func (n *ForStmt) List() Nodes         { return n.Late }
+func (n *ForStmt) PtrList() *Nodes     { return &n.Late }
+func (n *ForStmt) SetList(x Nodes)     { n.Late = x }
+func (n *ForStmt) HasBreak() bool      { return n.hasBreak }
+func (n *ForStmt) SetHasBreak(b bool)  { n.hasBreak = b }
 
 func (n *ForStmt) SetOp(op Op) {
 	if op != OFOR && op != OFORUNTIL {
@@ -327,7 +371,11 @@ func NewGoStmt(pos src.XPos, call Node) *GoStmt {
 
 func (n *GoStmt) String() string                { return fmt.Sprint(n) }
 func (n *GoStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *GoStmt) rawCopy() Node                 { c := *n; return &c }
+func (n *GoStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
 
 func (n *GoStmt) Left() Node     { return n.Call }
 func (n *GoStmt) SetLeft(x Node) { n.Call = x }
@@ -352,17 +400,24 @@ func NewIfStmt(pos src.XPos, cond Node, body, els []Node) *IfStmt {
 
 func (n *IfStmt) String() string                { return fmt.Sprint(n) }
 func (n *IfStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *IfStmt) rawCopy() Node                 { c := *n; return &c }
-func (n *IfStmt) Left() Node                    { return n.Cond }
-func (n *IfStmt) SetLeft(x Node)                { n.Cond = x }
-func (n *IfStmt) Body() Nodes                   { return n.body }
-func (n *IfStmt) PtrBody() *Nodes               { return &n.body }
-func (n *IfStmt) SetBody(x Nodes)               { n.body = x }
-func (n *IfStmt) Rlist() Nodes                  { return n.Else }
-func (n *IfStmt) PtrRlist() *Nodes              { return &n.Else }
-func (n *IfStmt) SetRlist(x Nodes)              { n.Else = x }
-func (n *IfStmt) Likely() bool                  { return n.likely }
-func (n *IfStmt) SetLikely(x bool)              { n.likely = x }
+func (n *IfStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.body = c.body.Copy()
+	c.Else = c.Else.Copy()
+	return &c
+}
+
+func (n *IfStmt) Left() Node       { return n.Cond }
+func (n *IfStmt) SetLeft(x Node)   { n.Cond = x }
+func (n *IfStmt) Body() Nodes      { return n.body }
+func (n *IfStmt) PtrBody() *Nodes  { return &n.body }
+func (n *IfStmt) SetBody(x Nodes)  { n.body = x }
+func (n *IfStmt) Rlist() Nodes     { return n.Else }
+func (n *IfStmt) PtrRlist() *Nodes { return &n.Else }
+func (n *IfStmt) SetRlist(x Nodes) { n.Else = x }
+func (n *IfStmt) Likely() bool     { return n.likely }
+func (n *IfStmt) SetLikely(x bool) { n.likely = x }
 
 // An InlineMarkStmt is a marker placed just before an inlined body.
 type InlineMarkStmt struct {
@@ -379,9 +434,14 @@ func NewInlineMarkStmt(pos src.XPos, index int64) *InlineMarkStmt {
 
 func (n *InlineMarkStmt) String() string                { return fmt.Sprint(n) }
 func (n *InlineMarkStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *InlineMarkStmt) rawCopy() Node                 { c := *n; return &c }
-func (n *InlineMarkStmt) Offset() int64                 { return n.Index }
-func (n *InlineMarkStmt) SetOffset(x int64)             { n.Index = x }
+func (n *InlineMarkStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+
+func (n *InlineMarkStmt) Offset() int64     { return n.Index }
+func (n *InlineMarkStmt) SetOffset(x int64) { n.Index = x }
 
 // A LabelStmt is a label statement (just the label, not including the statement it labels).
 type LabelStmt struct {
@@ -398,9 +458,14 @@ func NewLabelStmt(pos src.XPos, label *types.Sym) *LabelStmt {
 
 func (n *LabelStmt) String() string                { return fmt.Sprint(n) }
 func (n *LabelStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *LabelStmt) rawCopy() Node                 { c := *n; return &c }
-func (n *LabelStmt) Sym() *types.Sym               { return n.Label }
-func (n *LabelStmt) SetSym(x *types.Sym)           { n.Label = x }
+func (n *LabelStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+
+func (n *LabelStmt) Sym() *types.Sym     { return n.Label }
+func (n *LabelStmt) SetSym(x *types.Sym) { n.Label = x }
 
 // A RangeStmt is a range loop: for Vars = range X { Stmts }
 // Op can be OFOR or OFORUNTIL (!Cond).
@@ -426,23 +491,30 @@ func NewRangeStmt(pos src.XPos, vars []Node, x Node, body []Node) *RangeStmt {
 
 func (n *RangeStmt) String() string                { return fmt.Sprint(n) }
 func (n *RangeStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *RangeStmt) rawCopy() Node                 { c := *n; return &c }
-func (n *RangeStmt) Sym() *types.Sym               { return n.Label }
-func (n *RangeStmt) SetSym(x *types.Sym)           { n.Label = x }
-func (n *RangeStmt) Right() Node                   { return n.X }
-func (n *RangeStmt) SetRight(x Node)               { n.X = x }
-func (n *RangeStmt) Body() Nodes                   { return n.body }
-func (n *RangeStmt) PtrBody() *Nodes               { return &n.body }
-func (n *RangeStmt) SetBody(x Nodes)               { n.body = x }
-func (n *RangeStmt) List() Nodes                   { return n.Vars }
-func (n *RangeStmt) PtrList() *Nodes               { return &n.Vars }
-func (n *RangeStmt) SetList(x Nodes)               { n.Vars = x }
-func (n *RangeStmt) HasBreak() bool                { return n.hasBreak }
-func (n *RangeStmt) SetHasBreak(b bool)            { n.hasBreak = b }
-func (n *RangeStmt) Colas() bool                   { return n.Def }
-func (n *RangeStmt) SetColas(b bool)               { n.Def = b }
-func (n *RangeStmt) Type() *types.Type             { return n.typ }
-func (n *RangeStmt) SetType(x *types.Type)         { n.typ = x }
+func (n *RangeStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.Vars = c.Vars.Copy()
+	c.body = c.body.Copy()
+	return &c
+}
+
+func (n *RangeStmt) Sym() *types.Sym       { return n.Label }
+func (n *RangeStmt) SetSym(x *types.Sym)   { n.Label = x }
+func (n *RangeStmt) Right() Node           { return n.X }
+func (n *RangeStmt) SetRight(x Node)       { n.X = x }
+func (n *RangeStmt) Body() Nodes           { return n.body }
+func (n *RangeStmt) PtrBody() *Nodes       { return &n.body }
+func (n *RangeStmt) SetBody(x Nodes)       { n.body = x }
+func (n *RangeStmt) List() Nodes           { return n.Vars }
+func (n *RangeStmt) PtrList() *Nodes       { return &n.Vars }
+func (n *RangeStmt) SetList(x Nodes)       { n.Vars = x }
+func (n *RangeStmt) HasBreak() bool        { return n.hasBreak }
+func (n *RangeStmt) SetHasBreak(b bool)    { n.hasBreak = b }
+func (n *RangeStmt) Colas() bool           { return n.Def }
+func (n *RangeStmt) SetColas(b bool)       { n.Def = b }
+func (n *RangeStmt) Type() *types.Type     { return n.typ }
+func (n *RangeStmt) SetType(x *types.Type) { n.typ = x }
 
 // A ReturnStmt is a return statement.
 type ReturnStmt struct {
@@ -462,13 +534,19 @@ func NewReturnStmt(pos src.XPos, results []Node) *ReturnStmt {
 
 func (n *ReturnStmt) String() string                { return fmt.Sprint(n) }
 func (n *ReturnStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ReturnStmt) rawCopy() Node                 { c := *n; return &c }
-func (n *ReturnStmt) Orig() Node                    { return n.orig }
-func (n *ReturnStmt) SetOrig(x Node)                { n.orig = x }
-func (n *ReturnStmt) List() Nodes                   { return n.Results }
-func (n *ReturnStmt) PtrList() *Nodes               { return &n.Results }
-func (n *ReturnStmt) SetList(x Nodes)               { n.Results = x }
-func (n *ReturnStmt) IsDDD() bool                   { return false } // typecheckargs asks
+func (n *ReturnStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.Results = c.Results.Copy()
+	return &c
+}
+
+func (n *ReturnStmt) Orig() Node      { return n.orig }
+func (n *ReturnStmt) SetOrig(x Node)  { n.orig = x }
+func (n *ReturnStmt) List() Nodes     { return n.Results }
+func (n *ReturnStmt) PtrList() *Nodes { return &n.Results }
+func (n *ReturnStmt) SetList(x Nodes) { n.Results = x }
+func (n *ReturnStmt) IsDDD() bool     { return false } // typecheckargs asks
 
 // A SelectStmt is a block: { Cases }.
 type SelectStmt struct {
@@ -491,17 +569,24 @@ func NewSelectStmt(pos src.XPos, cases []Node) *SelectStmt {
 
 func (n *SelectStmt) String() string                { return fmt.Sprint(n) }
 func (n *SelectStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *SelectStmt) rawCopy() Node                 { c := *n; return &c }
-func (n *SelectStmt) List() Nodes                   { return n.Cases }
-func (n *SelectStmt) PtrList() *Nodes               { return &n.Cases }
-func (n *SelectStmt) SetList(x Nodes)               { n.Cases = x }
-func (n *SelectStmt) Sym() *types.Sym               { return n.Label }
-func (n *SelectStmt) SetSym(x *types.Sym)           { n.Label = x }
-func (n *SelectStmt) HasBreak() bool                { return n.hasBreak }
-func (n *SelectStmt) SetHasBreak(x bool)            { n.hasBreak = x }
-func (n *SelectStmt) Body() Nodes                   { return n.Compiled }
-func (n *SelectStmt) PtrBody() *Nodes               { return &n.Compiled }
-func (n *SelectStmt) SetBody(x Nodes)               { n.Compiled = x }
+func (n *SelectStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.Cases = c.Cases.Copy()
+	c.Compiled = c.Compiled.Copy()
+	return &c
+}
+
+func (n *SelectStmt) List() Nodes         { return n.Cases }
+func (n *SelectStmt) PtrList() *Nodes     { return &n.Cases }
+func (n *SelectStmt) SetList(x Nodes)     { n.Cases = x }
+func (n *SelectStmt) Sym() *types.Sym     { return n.Label }
+func (n *SelectStmt) SetSym(x *types.Sym) { n.Label = x }
+func (n *SelectStmt) HasBreak() bool      { return n.hasBreak }
+func (n *SelectStmt) SetHasBreak(x bool)  { n.hasBreak = x }
+func (n *SelectStmt) Body() Nodes         { return n.Compiled }
+func (n *SelectStmt) PtrBody() *Nodes     { return &n.Compiled }
+func (n *SelectStmt) SetBody(x Nodes)     { n.Compiled = x }
 
 // A SendStmt is a send statement: X <- Y.
 type SendStmt struct {
@@ -519,7 +604,11 @@ func NewSendStmt(pos src.XPos, ch, value Node) *SendStmt {
 
 func (n *SendStmt) String() string                { return fmt.Sprint(n) }
 func (n *SendStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *SendStmt) rawCopy() Node                 { c := *n; return &c }
+func (n *SendStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
 
 func (n *SendStmt) Left() Node      { return n.Chan }
 func (n *SendStmt) SetLeft(x Node)  { n.Chan = x }
@@ -548,19 +637,26 @@ func NewSwitchStmt(pos src.XPos, tag Node, cases []Node) *SwitchStmt {
 
 func (n *SwitchStmt) String() string                { return fmt.Sprint(n) }
 func (n *SwitchStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *SwitchStmt) rawCopy() Node                 { c := *n; return &c }
-func (n *SwitchStmt) Left() Node                    { return n.Tag }
-func (n *SwitchStmt) SetLeft(x Node)                { n.Tag = x }
-func (n *SwitchStmt) List() Nodes                   { return n.Cases }
-func (n *SwitchStmt) PtrList() *Nodes               { return &n.Cases }
-func (n *SwitchStmt) SetList(x Nodes)               { n.Cases = x }
-func (n *SwitchStmt) Body() Nodes                   { return n.Compiled }
-func (n *SwitchStmt) PtrBody() *Nodes               { return &n.Compiled }
-func (n *SwitchStmt) SetBody(x Nodes)               { n.Compiled = x }
-func (n *SwitchStmt) Sym() *types.Sym               { return n.Label }
-func (n *SwitchStmt) SetSym(x *types.Sym)           { n.Label = x }
-func (n *SwitchStmt) HasBreak() bool                { return n.hasBreak }
-func (n *SwitchStmt) SetHasBreak(x bool)            { n.hasBreak = x }
+func (n *SwitchStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.Cases = c.Cases.Copy()
+	c.Compiled = c.Compiled.Copy()
+	return &c
+}
+
+func (n *SwitchStmt) Left() Node          { return n.Tag }
+func (n *SwitchStmt) SetLeft(x Node)      { n.Tag = x }
+func (n *SwitchStmt) List() Nodes         { return n.Cases }
+func (n *SwitchStmt) PtrList() *Nodes     { return &n.Cases }
+func (n *SwitchStmt) SetList(x Nodes)     { n.Cases = x }
+func (n *SwitchStmt) Body() Nodes         { return n.Compiled }
+func (n *SwitchStmt) PtrBody() *Nodes     { return &n.Compiled }
+func (n *SwitchStmt) SetBody(x Nodes)     { n.Compiled = x }
+func (n *SwitchStmt) Sym() *types.Sym     { return n.Label }
+func (n *SwitchStmt) SetSym(x *types.Sym) { n.Label = x }
+func (n *SwitchStmt) HasBreak() bool      { return n.hasBreak }
+func (n *SwitchStmt) SetHasBreak(x bool)  { n.hasBreak = x }
 
 // A TypeSwitchGuard is the [Name :=] X.(type) in a type switch.
 type TypeSwitchGuard struct {
@@ -581,7 +677,7 @@ func NewTypeSwitchGuard(pos src.XPos, name, x Node) *TypeSwitchGuard {
 
 func (n *TypeSwitchGuard) String() string                { return fmt.Sprint(n) }
 func (n *TypeSwitchGuard) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *TypeSwitchGuard) rawCopy() Node                 { c := *n; return &c }
+func (n *TypeSwitchGuard) copy() Node                    { c := *n; return &c }
 
 func (n *TypeSwitchGuard) Left() Node {
 	if n.name == nil {
diff --git a/src/cmd/compile/internal/ir/type.go b/src/cmd/compile/internal/ir/type.go
index d2f5bb9239..a8af99034d 100644
--- a/src/cmd/compile/internal/ir/type.go
+++ b/src/cmd/compile/internal/ir/type.go
@@ -74,7 +74,7 @@ func NewChanType(pos src.XPos, elem Node, dir types.ChanDir) *ChanType {
 
 func (n *ChanType) String() string                { return fmt.Sprint(n) }
 func (n *ChanType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ChanType) rawCopy() Node                 { c := *n; return &c }
+func (n *ChanType) copy() Node                    { c := *n; return &c }
 func (n *ChanType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
 	n.Elem = nil
@@ -104,7 +104,7 @@ func NewMapType(pos src.XPos, key, elem Node) *MapType {
 
 func (n *MapType) String() string                { return fmt.Sprint(n) }
 func (n *MapType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *MapType) rawCopy() Node                 { c := *n; return &c }
+func (n *MapType) copy() Node                    { c := *n; return &c }
 func (n *MapType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
 	n.Key = nil
@@ -134,7 +134,12 @@ func NewStructType(pos src.XPos, fields []*Field) *StructType {
 
 func (n *StructType) String() string                { return fmt.Sprint(n) }
 func (n *StructType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *StructType) rawCopy() Node                 { c := *n; return &c }
+func (n *StructType) copy() Node {
+	c := *n
+	c.Fields = copyFields(c.Fields)
+	return &c
+}
+
 func (n *StructType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
 	n.Fields = nil
@@ -171,7 +176,12 @@ func NewInterfaceType(pos src.XPos, methods []*Field) *InterfaceType {
 
 func (n *InterfaceType) String() string                { return fmt.Sprint(n) }
 func (n *InterfaceType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *InterfaceType) rawCopy() Node                 { c := *n; return &c }
+func (n *InterfaceType) copy() Node {
+	c := *n
+	c.Methods = copyFields(c.Methods)
+	return &c
+}
+
 func (n *InterfaceType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
 	n.Methods = nil
@@ -202,7 +212,15 @@ func NewFuncType(pos src.XPos, rcvr *Field, args, results []*Field) *FuncType {
 
 func (n *FuncType) String() string                { return fmt.Sprint(n) }
 func (n *FuncType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *FuncType) rawCopy() Node                 { c := *n; return &c }
+func (n *FuncType) copy() Node {
+	c := *n
+	if c.Recv != nil {
+		c.Recv = c.Recv.copy()
+	}
+	c.Params = copyFields(c.Params)
+	c.Results = copyFields(c.Results)
+	return &c
+}
 
 func (n *FuncType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
@@ -252,6 +270,20 @@ func (f *Field) String() string {
 	return typ
 }
 
+func (f *Field) copy() *Field {
+	c := *f
+	return &c
+}
+
+func copyFields(list []*Field) []*Field {
+	out := make([]*Field, len(list))
+	copy(out, list)
+	for i, f := range out {
+		out[i] = f.copy()
+	}
+	return out
+}
+
 func (f *Field) deepCopy(pos src.XPos) *Field {
 	if f == nil {
 		return nil
@@ -289,7 +321,7 @@ func NewSliceType(pos src.XPos, elem Node) *SliceType {
 
 func (n *SliceType) String() string                { return fmt.Sprint(n) }
 func (n *SliceType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *SliceType) rawCopy() Node                 { c := *n; return &c }
+func (n *SliceType) copy() Node                    { c := *n; return &c }
 func (n *SliceType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
 	n.Elem = nil
@@ -320,7 +352,7 @@ func NewArrayType(pos src.XPos, size Node, elem Node) *ArrayType {
 
 func (n *ArrayType) String() string                { return fmt.Sprint(n) }
 func (n *ArrayType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ArrayType) rawCopy() Node                 { c := *n; return &c }
+func (n *ArrayType) copy() Node                    { c := *n; return &c }
 
 func (n *ArrayType) DeepCopy(pos src.XPos) Node {
 	if n.op == OTYPE {
@@ -351,7 +383,7 @@ func newTypeNode(pos src.XPos, typ *types.Type) *typeNode {
 
 func (n *typeNode) String() string                { return fmt.Sprint(n) }
 func (n *typeNode) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *typeNode) rawCopy() Node                 { c := *n; return &c }
+func (n *typeNode) copy() Node                    { c := *n; return &c }
 func (n *typeNode) Type() *types.Type             { return n.typ }
 func (n *typeNode) Sym() *types.Sym               { return n.typ.Sym() }
 func (n *typeNode) CanBeNtype()                   {}
-- 
GitLab


From 4725c3ffd1b8baf87204936e59bf00c96e3bf4a0 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 3 Dec 2020 21:02:19 -0500
Subject: [PATCH 0152/2400] [dev.regabi] cmd/compile: implement doChildren for
 nodes

Put each node in charge of its DoChildren implementation.
This removes a generic use of Left, Right, and so on
in func DoChildren, heading toward removing those even from
being used in package ir.

Passes buildall w/ toolstash -cmp.

Change-Id: Ibdf56f36801217cf24549e063da0078c1820a56b
Reviewed-on: https://go-review.googlesource.com/c/go/+/275375
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/copy.go  |   6 +-
 src/cmd/compile/internal/ir/expr.go  | 171 ++++++++++++++++++++++++++-
 src/cmd/compile/internal/ir/func.go  |  22 ++--
 src/cmd/compile/internal/ir/name.go  |  44 +++----
 src/cmd/compile/internal/ir/node.go  |   2 +
 src/cmd/compile/internal/ir/stmt.go  | 137 ++++++++++++++++++++-
 src/cmd/compile/internal/ir/type.go  |  74 +++++++++++-
 src/cmd/compile/internal/ir/visit.go |  30 +----
 8 files changed, 419 insertions(+), 67 deletions(-)

diff --git a/src/cmd/compile/internal/ir/copy.go b/src/cmd/compile/internal/ir/copy.go
index 8d174d6e53..86e78cfc33 100644
--- a/src/cmd/compile/internal/ir/copy.go
+++ b/src/cmd/compile/internal/ir/copy.go
@@ -65,9 +65,9 @@ func Copy(n Node) Node {
 }
 
 func copyList(x Nodes) Nodes {
-	out := make([]Node, x.Len())
-	copy(out, x.Slice())
-	return AsNodes(out)
+	c := make([]Node, x.Len())
+	copy(c, x.Slice())
+	return AsNodes(c)
 }
 
 // A Node can implement DeepCopyNode to provide a custom implementation
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 7431a56d94..9e5dfaf0f2 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -12,6 +12,20 @@ import (
 	"go/constant"
 )
 
+func maybeDo(x Node, err error, do func(Node) error) error {
+	if x != nil && err == nil {
+		err = do(x)
+	}
+	return err
+}
+
+func maybeDoList(x Nodes, err error, do func(Node) error) error {
+	if err == nil {
+		err = DoList(x, do)
+	}
+	return err
+}
+
 // A miniStmt is a miniNode with extra fields common to expressions.
 // TODO(rsc): Once we are sure about the contents, compact the bools
 // into a bit field and leave extra bits available for implementations
@@ -82,6 +96,12 @@ func (n *AddStringExpr) copy() Node {
 	c.list = c.list.Copy()
 	return &c
 }
+func (n *AddStringExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDoList(n.list, err, do)
+	return err
+}
 
 func (n *AddStringExpr) List() Nodes     { return n.list }
 func (n *AddStringExpr) PtrList() *Nodes { return &n.list }
@@ -109,6 +129,12 @@ func (n *AddrExpr) copy() Node {
 	c.init = c.init.Copy()
 	return &c
 }
+func (n *AddrExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	return err
+}
 
 func (n *AddrExpr) Left() Node      { return n.X }
 func (n *AddrExpr) SetLeft(x Node)  { n.X = x }
@@ -146,6 +172,13 @@ func (n *BinaryExpr) copy() Node {
 	c.init = c.init.Copy()
 	return &c
 }
+func (n *BinaryExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	err = maybeDo(n.Y, err, do)
+	return err
+}
 
 func (n *BinaryExpr) Left() Node      { return n.X }
 func (n *BinaryExpr) SetLeft(x Node)  { n.X = x }
@@ -207,6 +240,15 @@ func (n *CallExpr) copy() Node {
 	c.body = c.body.Copy()
 	return &c
 }
+func (n *CallExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	err = maybeDoList(n.Args, err, do)
+	err = maybeDoList(n.Rargs, err, do)
+	err = maybeDoList(n.body, err, do)
+	return err
+}
 
 func (n *CallExpr) Orig() Node         { return n.orig }
 func (n *CallExpr) SetOrig(x Node)     { n.orig = x }
@@ -260,6 +302,12 @@ func (n *CallPartExpr) copy() Node {
 	c.init = c.init.Copy()
 	return &c
 }
+func (n *CallPartExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	return err
+}
 
 func (n *CallPartExpr) Func() *Func     { return n.fn }
 func (n *CallPartExpr) Left() Node      { return n.X }
@@ -286,6 +334,11 @@ func (n *ClosureExpr) copy() Node {
 	c.init = c.init.Copy()
 	return &c
 }
+func (n *ClosureExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	return err
+}
 
 func (n *ClosureExpr) Func() *Func { return n.fn }
 
@@ -312,6 +365,11 @@ func (n *ClosureRead) copy() Node {
 
 func (n *ClosureRead) Type() *types.Type { return n.typ }
 func (n *ClosureRead) Offset() int64     { return n.offset }
+func (n *ClosureRead) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	return err
+}
 
 // A CompLitExpr is a composite literal Type{Vals}.
 // Before type-checking, the type is Ntype.
@@ -339,6 +397,13 @@ func (n *CompLitExpr) copy() Node {
 	c.list = c.list.Copy()
 	return &c
 }
+func (n *CompLitExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.Ntype, err, do)
+	err = maybeDoList(n.list, err, do)
+	return err
+}
 
 func (n *CompLitExpr) Orig() Node      { return n.orig }
 func (n *CompLitExpr) SetOrig(x Node)  { n.orig = x }
@@ -373,9 +438,10 @@ func NewConstExpr(val constant.Value, orig Node) Node {
 	return n
 }
 
-func (n *ConstExpr) String() string                { return fmt.Sprint(n) }
-func (n *ConstExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ConstExpr) copy() Node                    { c := *n; return &c }
+func (n *ConstExpr) String() string                       { return fmt.Sprint(n) }
+func (n *ConstExpr) Format(s fmt.State, verb rune)        { FmtNode(n, s, verb) }
+func (n *ConstExpr) copy() Node                           { c := *n; return &c }
+func (n *ConstExpr) doChildren(do func(Node) error) error { return nil }
 
 func (n *ConstExpr) Sym() *types.Sym     { return n.orig.Sym() }
 func (n *ConstExpr) Orig() Node          { return n.orig }
@@ -406,6 +472,12 @@ func (n *ConvExpr) copy() Node {
 	c.init = c.init.Copy()
 	return &c
 }
+func (n *ConvExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	return err
+}
 
 func (n *ConvExpr) rawCopy() Node  { c := *n; return &c }
 func (n *ConvExpr) Left() Node     { return n.X }
@@ -442,6 +514,13 @@ func (n *IndexExpr) copy() Node {
 	c.init = c.init.Copy()
 	return &c
 }
+func (n *IndexExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	err = maybeDo(n.Index, err, do)
+	return err
+}
 
 func (n *IndexExpr) Left() Node               { return n.X }
 func (n *IndexExpr) SetLeft(x Node)           { n.X = x }
@@ -484,6 +563,13 @@ func (n *KeyExpr) copy() Node {
 	c.init = c.init.Copy()
 	return &c
 }
+func (n *KeyExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.Key, err, do)
+	err = maybeDo(n.Value, err, do)
+	return err
+}
 
 func (n *KeyExpr) Left() Node          { return n.Key }
 func (n *KeyExpr) SetLeft(x Node)      { n.Key = x }
@@ -528,6 +614,13 @@ func (n *InlinedCallExpr) copy() Node {
 	c.ReturnVars = c.ReturnVars.Copy()
 	return &c
 }
+func (n *InlinedCallExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDoList(n.body, err, do)
+	err = maybeDoList(n.ReturnVars, err, do)
+	return err
+}
 
 func (n *InlinedCallExpr) Body() Nodes      { return n.body }
 func (n *InlinedCallExpr) PtrBody() *Nodes  { return &n.body }
@@ -559,6 +652,13 @@ func (n *MakeExpr) copy() Node {
 	c.init = c.init.Copy()
 	return &c
 }
+func (n *MakeExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.Len, err, do)
+	err = maybeDo(n.Cap, err, do)
+	return err
+}
 
 func (n *MakeExpr) Left() Node      { return n.Len }
 func (n *MakeExpr) SetLeft(x Node)  { n.Len = x }
@@ -574,7 +674,7 @@ func (n *MakeExpr) SetOp(op Op) {
 	}
 }
 
-// A MethodExpr is a method expression X.M (where X is an expression, not a type).
+// A MethodExpr is a method value X.M (where X is an expression, not a type).
 type MethodExpr struct {
 	miniExpr
 	X      Node
@@ -600,6 +700,13 @@ func (n *MethodExpr) copy() Node {
 	c.init = c.init.Copy()
 	return &c
 }
+func (n *MethodExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	err = maybeDo(n.M, err, do)
+	return err
+}
 
 func (n *MethodExpr) Left() Node          { return n.X }
 func (n *MethodExpr) SetLeft(x Node)      { n.X = x }
@@ -633,6 +740,11 @@ func (n *NilExpr) copy() Node {
 	c.init = c.init.Copy()
 	return &c
 }
+func (n *NilExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	return err
+}
 
 func (n *NilExpr) Sym() *types.Sym     { return n.sym }
 func (n *NilExpr) SetSym(x *types.Sym) { n.sym = x }
@@ -658,6 +770,12 @@ func (n *ParenExpr) copy() Node {
 	c.init = c.init.Copy()
 	return &c
 }
+func (n *ParenExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	return err
+}
 
 func (n *ParenExpr) Left() Node     { return n.X }
 func (n *ParenExpr) SetLeft(x Node) { n.X = x }
@@ -693,6 +811,11 @@ func (n *ResultExpr) copy() Node {
 	c.init = c.init.Copy()
 	return &c
 }
+func (n *ResultExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	return err
+}
 
 func (n *ResultExpr) Offset() int64     { return n.offset }
 func (n *ResultExpr) SetOffset(x int64) { n.offset = x }
@@ -730,6 +853,12 @@ func (n *SelectorExpr) copy() Node {
 	c.init = c.init.Copy()
 	return &c
 }
+func (n *SelectorExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	return err
+}
 
 func (n *SelectorExpr) Left() Node          { return n.X }
 func (n *SelectorExpr) SetLeft(x Node)      { n.X = x }
@@ -764,6 +893,13 @@ func (n *SliceExpr) copy() Node {
 	c.list = c.list.Copy()
 	return &c
 }
+func (n *SliceExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	err = maybeDoList(n.list, err, do)
+	return err
+}
 
 func (n *SliceExpr) Left() Node      { return n.X }
 func (n *SliceExpr) SetLeft(x Node)  { n.X = x }
@@ -871,6 +1007,13 @@ func (n *SliceHeaderExpr) copy() Node {
 	c.init = c.init.Copy()
 	return &c
 }
+func (n *SliceHeaderExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.Ptr, err, do)
+	err = maybeDoList(n.lenCap, err, do)
+	return err
+}
 
 func (n *SliceHeaderExpr) Left() Node      { return n.Ptr }
 func (n *SliceHeaderExpr) SetLeft(x Node)  { n.Ptr = x }
@@ -899,6 +1042,12 @@ func (n *StarExpr) copy() Node {
 	c.init = c.init.Copy()
 	return &c
 }
+func (n *StarExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	return err
+}
 
 func (n *StarExpr) Left() Node     { return n.X }
 func (n *StarExpr) SetLeft(x Node) { n.X = x }
@@ -949,6 +1098,14 @@ func (n *TypeAssertExpr) copy() Node {
 	c.Itab = c.Itab.Copy()
 	return &c
 }
+func (n *TypeAssertExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	err = maybeDo(n.Ntype, err, do)
+	err = maybeDoList(n.Itab, err, do)
+	return err
+}
 
 func (n *TypeAssertExpr) Left() Node      { return n.X }
 func (n *TypeAssertExpr) SetLeft(x Node)  { n.X = x }
@@ -988,6 +1145,12 @@ func (n *UnaryExpr) copy() Node {
 	c.init = c.init.Copy()
 	return &c
 }
+func (n *UnaryExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	return err
+}
 
 func (n *UnaryExpr) Left() Node     { return n.X }
 func (n *UnaryExpr) SetLeft(x Node) { n.X = x }
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index ae803cd6a5..342b7a91e7 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -118,14 +118,20 @@ func NewFunc(pos src.XPos) *Func {
 func (f *Func) String() string                { return fmt.Sprint(f) }
 func (f *Func) Format(s fmt.State, verb rune) { FmtNode(f, s, verb) }
 func (f *Func) copy() Node                    { panic(f.no("copy")) }
-func (f *Func) Func() *Func                   { return f }
-func (f *Func) Body() Nodes                   { return f.body }
-func (f *Func) PtrBody() *Nodes               { return &f.body }
-func (f *Func) SetBody(x Nodes)               { f.body = x }
-func (f *Func) Type() *types.Type             { return f.typ }
-func (f *Func) SetType(x *types.Type)         { f.typ = x }
-func (f *Func) Iota() int64                   { return f.iota }
-func (f *Func) SetIota(x int64)               { f.iota = x }
+func (f *Func) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(f.body, err, do)
+	return err
+}
+
+func (f *Func) Func() *Func           { return f }
+func (f *Func) Body() Nodes           { return f.body }
+func (f *Func) PtrBody() *Nodes       { return &f.body }
+func (f *Func) SetBody(x Nodes)       { f.body = x }
+func (f *Func) Type() *types.Type     { return f.typ }
+func (f *Func) SetType(x *types.Type) { f.typ = x }
+func (f *Func) Iota() int64           { return f.iota }
+func (f *Func) SetIota(x int64)       { f.iota = x }
 
 func (f *Func) Sym() *types.Sym {
 	if f.Nname != nil {
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index dc8c58e4f4..2ff1fbc683 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -149,22 +149,24 @@ func newNameAt(pos src.XPos, op Op, sym *types.Sym) *Name {
 	return n
 }
 
-func (n *Name) String() string                { return fmt.Sprint(n) }
-func (n *Name) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *Name) copy() Node                    { c := *n; return &c }
-func (n *Name) Name() *Name                   { return n }
-func (n *Name) Sym() *types.Sym               { return n.sym }
-func (n *Name) SetSym(x *types.Sym)           { n.sym = x }
-func (n *Name) SubOp() Op                     { return n.subOp }
-func (n *Name) SetSubOp(x Op)                 { n.subOp = x }
-func (n *Name) Class() Class                  { return n.class }
-func (n *Name) SetClass(x Class)              { n.class = x }
-func (n *Name) Func() *Func                   { return n.fn }
-func (n *Name) SetFunc(x *Func)               { n.fn = x }
-func (n *Name) Offset() int64                 { return n.offset }
-func (n *Name) SetOffset(x int64)             { n.offset = x }
-func (n *Name) Iota() int64                   { return n.offset }
-func (n *Name) SetIota(x int64)               { n.offset = x }
+func (n *Name) String() string                       { return fmt.Sprint(n) }
+func (n *Name) Format(s fmt.State, verb rune)        { FmtNode(n, s, verb) }
+func (n *Name) copy() Node                           { c := *n; return &c }
+func (n *Name) doChildren(do func(Node) error) error { return nil }
+
+func (n *Name) Name() *Name         { return n }
+func (n *Name) Sym() *types.Sym     { return n.sym }
+func (n *Name) SetSym(x *types.Sym) { n.sym = x }
+func (n *Name) SubOp() Op           { return n.subOp }
+func (n *Name) SetSubOp(x Op)       { n.subOp = x }
+func (n *Name) Class() Class        { return n.class }
+func (n *Name) SetClass(x Class)    { n.class = x }
+func (n *Name) Func() *Func         { return n.fn }
+func (n *Name) SetFunc(x *Func)     { n.fn = x }
+func (n *Name) Offset() int64       { return n.offset }
+func (n *Name) SetOffset(x int64)   { n.offset = x }
+func (n *Name) Iota() int64         { return n.offset }
+func (n *Name) SetIota(x int64)     { n.offset = x }
 
 func (*Name) CanBeNtype() {}
 
@@ -321,10 +323,12 @@ type PkgName struct {
 	Used bool
 }
 
-func (p *PkgName) String() string                { return fmt.Sprint(p) }
-func (p *PkgName) Format(s fmt.State, verb rune) { FmtNode(p, s, verb) }
-func (p *PkgName) copy() Node                    { c := *p; return &c }
-func (p *PkgName) Sym() *types.Sym               { return p.sym }
+func (p *PkgName) String() string                       { return fmt.Sprint(p) }
+func (p *PkgName) Format(s fmt.State, verb rune)        { FmtNode(p, s, verb) }
+func (p *PkgName) copy() Node                           { c := *p; return &c }
+func (p *PkgName) doChildren(do func(Node) error) error { return nil }
+
+func (p *PkgName) Sym() *types.Sym { return p.sym }
 
 func (*PkgName) CanBeNtype() {}
 
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 705eb9e47e..02ab87846f 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -30,6 +30,8 @@ type Node interface {
 	// For making copies. For Copy and SepCopy.
 	copy() Node
 
+	doChildren(func(Node) error) error
+
 	// Abstract graph structure, for generic traversals.
 	Op() Op
 	SetOp(x Op)
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index 5af6a62cf2..b940c5f59d 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -11,7 +11,6 @@ import (
 )
 
 // A Decl is a declaration of a const, type, or var. (A declared func is a Func.)
-// (This is not technically a statement but it's not worth its own file.)
 type Decl struct {
 	miniNode
 	X Node // the thing being declared
@@ -32,8 +31,14 @@ func NewDecl(pos src.XPos, op Op, x Node) *Decl {
 func (n *Decl) String() string                { return fmt.Sprint(n) }
 func (n *Decl) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *Decl) copy() Node                    { c := *n; return &c }
-func (n *Decl) Left() Node                    { return n.X }
-func (n *Decl) SetLeft(x Node)                { n.X = x }
+func (n *Decl) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDo(n.X, err, do)
+	return err
+}
+
+func (n *Decl) Left() Node     { return n.X }
+func (n *Decl) SetLeft(x Node) { n.X = x }
 
 // A miniStmt is a miniNode with extra fields common to statements.
 type miniStmt struct {
@@ -77,6 +82,13 @@ func (n *AssignListStmt) copy() Node {
 	c.Rhs = c.Rhs.Copy()
 	return &c
 }
+func (n *AssignListStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDoList(n.Lhs, err, do)
+	err = maybeDoList(n.Rhs, err, do)
+	return err
+}
 
 func (n *AssignListStmt) List() Nodes       { return n.Lhs }
 func (n *AssignListStmt) PtrList() *Nodes   { return &n.Lhs }
@@ -123,6 +135,13 @@ func (n *AssignStmt) copy() Node {
 	c.init = c.init.Copy()
 	return &c
 }
+func (n *AssignStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	err = maybeDo(n.Y, err, do)
+	return err
+}
 
 func (n *AssignStmt) Left() Node        { return n.X }
 func (n *AssignStmt) SetLeft(x Node)    { n.X = x }
@@ -166,6 +185,13 @@ func (n *AssignOpStmt) copy() Node {
 	c.init = c.init.Copy()
 	return &c
 }
+func (n *AssignOpStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	err = maybeDo(n.Y, err, do)
+	return err
+}
 
 func (n *AssignOpStmt) Left() Node            { return n.X }
 func (n *AssignOpStmt) SetLeft(x Node)        { n.X = x }
@@ -200,6 +226,12 @@ func (n *BlockStmt) copy() Node {
 	c.list = c.list.Copy()
 	return &c
 }
+func (n *BlockStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDoList(n.list, err, do)
+	return err
+}
 
 func (n *BlockStmt) List() Nodes     { return n.list }
 func (n *BlockStmt) PtrList() *Nodes { return &n.list }
@@ -234,6 +266,11 @@ func (n *BranchStmt) copy() Node {
 	c.init = c.init.Copy()
 	return &c
 }
+func (n *BranchStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	return err
+}
 
 func (n *BranchStmt) Sym() *types.Sym       { return n.Label }
 func (n *BranchStmt) SetSym(sym *types.Sym) { n.Label = sym }
@@ -266,6 +303,15 @@ func (n *CaseStmt) copy() Node {
 	c.body = c.body.Copy()
 	return &c
 }
+func (n *CaseStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDoList(n.Vars, err, do)
+	err = maybeDoList(n.list, err, do)
+	err = maybeDo(n.Comm, err, do)
+	err = maybeDoList(n.body, err, do)
+	return err
+}
 
 func (n *CaseStmt) List() Nodes      { return n.list }
 func (n *CaseStmt) PtrList() *Nodes  { return &n.list }
@@ -299,6 +345,12 @@ func (n *DeferStmt) copy() Node {
 	c.init = c.init.Copy()
 	return &c
 }
+func (n *DeferStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.Call, err, do)
+	return err
+}
 
 func (n *DeferStmt) Left() Node     { return n.Call }
 func (n *DeferStmt) SetLeft(x Node) { n.Call = x }
@@ -309,8 +361,8 @@ type ForStmt struct {
 	miniStmt
 	Label    *types.Sym
 	Cond     Node
-	Post     Node
 	Late     Nodes
+	Post     Node
 	body     Nodes
 	hasBreak bool
 }
@@ -333,6 +385,15 @@ func (n *ForStmt) copy() Node {
 	c.body = c.body.Copy()
 	return &c
 }
+func (n *ForStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.Cond, err, do)
+	err = maybeDoList(n.Late, err, do)
+	err = maybeDo(n.Post, err, do)
+	err = maybeDoList(n.body, err, do)
+	return err
+}
 
 func (n *ForStmt) Sym() *types.Sym     { return n.Label }
 func (n *ForStmt) SetSym(x *types.Sym) { n.Label = x }
@@ -376,6 +437,12 @@ func (n *GoStmt) copy() Node {
 	c.init = c.init.Copy()
 	return &c
 }
+func (n *GoStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.Call, err, do)
+	return err
+}
 
 func (n *GoStmt) Left() Node     { return n.Call }
 func (n *GoStmt) SetLeft(x Node) { n.Call = x }
@@ -407,6 +474,14 @@ func (n *IfStmt) copy() Node {
 	c.Else = c.Else.Copy()
 	return &c
 }
+func (n *IfStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.Cond, err, do)
+	err = maybeDoList(n.body, err, do)
+	err = maybeDoList(n.Else, err, do)
+	return err
+}
 
 func (n *IfStmt) Left() Node       { return n.Cond }
 func (n *IfStmt) SetLeft(x Node)   { n.Cond = x }
@@ -439,6 +514,11 @@ func (n *InlineMarkStmt) copy() Node {
 	c.init = c.init.Copy()
 	return &c
 }
+func (n *InlineMarkStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	return err
+}
 
 func (n *InlineMarkStmt) Offset() int64     { return n.Index }
 func (n *InlineMarkStmt) SetOffset(x int64) { n.Index = x }
@@ -463,6 +543,11 @@ func (n *LabelStmt) copy() Node {
 	c.init = c.init.Copy()
 	return &c
 }
+func (n *LabelStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	return err
+}
 
 func (n *LabelStmt) Sym() *types.Sym     { return n.Label }
 func (n *LabelStmt) SetSym(x *types.Sym) { n.Label = x }
@@ -498,6 +583,14 @@ func (n *RangeStmt) copy() Node {
 	c.body = c.body.Copy()
 	return &c
 }
+func (n *RangeStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDoList(n.Vars, err, do)
+	err = maybeDo(n.X, err, do)
+	err = maybeDoList(n.body, err, do)
+	return err
+}
 
 func (n *RangeStmt) Sym() *types.Sym       { return n.Label }
 func (n *RangeStmt) SetSym(x *types.Sym)   { n.Label = x }
@@ -540,6 +633,12 @@ func (n *ReturnStmt) copy() Node {
 	c.Results = c.Results.Copy()
 	return &c
 }
+func (n *ReturnStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDoList(n.Results, err, do)
+	return err
+}
 
 func (n *ReturnStmt) Orig() Node      { return n.orig }
 func (n *ReturnStmt) SetOrig(x Node)  { n.orig = x }
@@ -576,6 +675,13 @@ func (n *SelectStmt) copy() Node {
 	c.Compiled = c.Compiled.Copy()
 	return &c
 }
+func (n *SelectStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDoList(n.Cases, err, do)
+	err = maybeDoList(n.Compiled, err, do)
+	return err
+}
 
 func (n *SelectStmt) List() Nodes         { return n.Cases }
 func (n *SelectStmt) PtrList() *Nodes     { return &n.Cases }
@@ -609,6 +715,13 @@ func (n *SendStmt) copy() Node {
 	c.init = c.init.Copy()
 	return &c
 }
+func (n *SendStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.Chan, err, do)
+	err = maybeDo(n.Value, err, do)
+	return err
+}
 
 func (n *SendStmt) Left() Node      { return n.Chan }
 func (n *SendStmt) SetLeft(x Node)  { n.Chan = x }
@@ -644,6 +757,14 @@ func (n *SwitchStmt) copy() Node {
 	c.Compiled = c.Compiled.Copy()
 	return &c
 }
+func (n *SwitchStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.Tag, err, do)
+	err = maybeDoList(n.Cases, err, do)
+	err = maybeDoList(n.Compiled, err, do)
+	return err
+}
 
 func (n *SwitchStmt) Left() Node          { return n.Tag }
 func (n *SwitchStmt) SetLeft(x Node)      { n.Tag = x }
@@ -678,6 +799,14 @@ func NewTypeSwitchGuard(pos src.XPos, name, x Node) *TypeSwitchGuard {
 func (n *TypeSwitchGuard) String() string                { return fmt.Sprint(n) }
 func (n *TypeSwitchGuard) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *TypeSwitchGuard) copy() Node                    { c := *n; return &c }
+func (n *TypeSwitchGuard) doChildren(do func(Node) error) error {
+	var err error
+	if n.name != nil {
+		err = maybeDo(n.name, err, do)
+	}
+	err = maybeDo(n.X, err, do)
+	return err
+}
 
 func (n *TypeSwitchGuard) Left() Node {
 	if n.name == nil {
diff --git a/src/cmd/compile/internal/ir/type.go b/src/cmd/compile/internal/ir/type.go
index a8af99034d..2723c00044 100644
--- a/src/cmd/compile/internal/ir/type.go
+++ b/src/cmd/compile/internal/ir/type.go
@@ -75,6 +75,11 @@ func NewChanType(pos src.XPos, elem Node, dir types.ChanDir) *ChanType {
 func (n *ChanType) String() string                { return fmt.Sprint(n) }
 func (n *ChanType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *ChanType) copy() Node                    { c := *n; return &c }
+func (n *ChanType) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDo(n.Elem, err, do)
+	return err
+}
 func (n *ChanType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
 	n.Elem = nil
@@ -105,6 +110,12 @@ func NewMapType(pos src.XPos, key, elem Node) *MapType {
 func (n *MapType) String() string                { return fmt.Sprint(n) }
 func (n *MapType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *MapType) copy() Node                    { c := *n; return &c }
+func (n *MapType) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDo(n.Key, err, do)
+	err = maybeDo(n.Elem, err, do)
+	return err
+}
 func (n *MapType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
 	n.Key = nil
@@ -139,6 +150,11 @@ func (n *StructType) copy() Node {
 	c.Fields = copyFields(c.Fields)
 	return &c
 }
+func (n *StructType) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoFields(n.Fields, err, do)
+	return err
+}
 
 func (n *StructType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
@@ -181,6 +197,11 @@ func (n *InterfaceType) copy() Node {
 	c.Methods = copyFields(c.Methods)
 	return &c
 }
+func (n *InterfaceType) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoFields(n.Methods, err, do)
+	return err
+}
 
 func (n *InterfaceType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
@@ -221,6 +242,13 @@ func (n *FuncType) copy() Node {
 	c.Results = copyFields(c.Results)
 	return &c
 }
+func (n *FuncType) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoField(n.Recv, err, do)
+	err = maybeDoFields(n.Params, err, do)
+	err = maybeDoFields(n.Results, err, do)
+	return err
+}
 
 func (n *FuncType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
@@ -284,6 +312,31 @@ func copyFields(list []*Field) []*Field {
 	return out
 }
 
+func maybeDoField(f *Field, err error, do func(Node) error) error {
+	if f != nil {
+		if err == nil && f.Decl != nil {
+			err = do(f.Decl)
+		}
+		if err == nil && f.Ntype != nil {
+			err = do(f.Ntype)
+		}
+	}
+	return err
+}
+
+func maybeDoFields(list []*Field, err error, do func(Node) error) error {
+	if err != nil {
+		return err
+	}
+	for _, f := range list {
+		err = maybeDoField(f, err, do)
+		if err != nil {
+			return err
+		}
+	}
+	return err
+}
+
 func (f *Field) deepCopy(pos src.XPos) *Field {
 	if f == nil {
 		return nil
@@ -322,6 +375,11 @@ func NewSliceType(pos src.XPos, elem Node) *SliceType {
 func (n *SliceType) String() string                { return fmt.Sprint(n) }
 func (n *SliceType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *SliceType) copy() Node                    { c := *n; return &c }
+func (n *SliceType) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDo(n.Elem, err, do)
+	return err
+}
 func (n *SliceType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
 	n.Elem = nil
@@ -353,6 +411,12 @@ func NewArrayType(pos src.XPos, size Node, elem Node) *ArrayType {
 func (n *ArrayType) String() string                { return fmt.Sprint(n) }
 func (n *ArrayType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *ArrayType) copy() Node                    { c := *n; return &c }
+func (n *ArrayType) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDo(n.Len, err, do)
+	err = maybeDo(n.Elem, err, do)
+	return err
+}
 
 func (n *ArrayType) DeepCopy(pos src.XPos) Node {
 	if n.op == OTYPE {
@@ -384,9 +448,13 @@ func newTypeNode(pos src.XPos, typ *types.Type) *typeNode {
 func (n *typeNode) String() string                { return fmt.Sprint(n) }
 func (n *typeNode) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *typeNode) copy() Node                    { c := *n; return &c }
-func (n *typeNode) Type() *types.Type             { return n.typ }
-func (n *typeNode) Sym() *types.Sym               { return n.typ.Sym() }
-func (n *typeNode) CanBeNtype()                   {}
+func (n *typeNode) doChildren(do func(Node) error) error {
+	return nil
+}
+
+func (n *typeNode) Type() *types.Type { return n.typ }
+func (n *typeNode) Sym() *types.Sym   { return n.typ.Sym() }
+func (n *typeNode) CanBeNtype()       {}
 
 // TypeNode returns the Node representing the type t.
 func TypeNode(t *types.Type) Ntype {
diff --git a/src/cmd/compile/internal/ir/visit.go b/src/cmd/compile/internal/ir/visit.go
index a239fd1532..042257c32a 100644
--- a/src/cmd/compile/internal/ir/visit.go
+++ b/src/cmd/compile/internal/ir/visit.go
@@ -14,7 +14,9 @@
 
 package ir
 
-import "errors"
+import (
+	"errors"
+)
 
 // DoChildren calls do(x) on each of n's non-nil child nodes x.
 // If any call returns a non-nil error, DoChildren stops and returns that error.
@@ -86,7 +88,7 @@ import "errors"
 //				found = v
 //				return stop
 //			}
-//			return DoChildren(x, do)
+//			return ir.DoChildren(x, do)
 //		}
 //		do(n)
 //		return found
@@ -100,29 +102,7 @@ func DoChildren(n Node, do func(Node) error) error {
 	if n == nil {
 		return nil
 	}
-	if err := DoList(n.Init(), do); err != nil {
-		return err
-	}
-	if l := n.Left(); l != nil {
-		if err := do(l); err != nil {
-			return err
-		}
-	}
-	if r := n.Right(); r != nil {
-		if err := do(r); err != nil {
-			return err
-		}
-	}
-	if err := DoList(n.List(), do); err != nil {
-		return err
-	}
-	if err := DoList(n.Body(), do); err != nil {
-		return err
-	}
-	if err := DoList(n.Rlist(), do); err != nil {
-		return err
-	}
-	return nil
+	return n.doChildren(do)
 }
 
 // DoList calls f on each non-nil node x in the list, in list order.
-- 
GitLab


From bb5aa2b664331087d3230732cb0d11c8e87b9e98 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 3 Dec 2020 21:29:23 -0500
Subject: [PATCH 0153/2400] [dev.regabi] cmd/compile: implement editChildren
 for nodes

Put each node in charge of its EditChildren implementation.
This removes the final generic use of Left, SetLeft, Right, SetRight,
and so on in package ir.

Passes buildall w/ toolstash -cmp.

Change-Id: I9821cc20f5b91cc9b44eb1f386cc82f20cd6770c
Reviewed-on: https://go-review.googlesource.com/c/go/+/275376
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/expr.go  | 110 +++++++++++++++++++++++++++
 src/cmd/compile/internal/ir/func.go  |   3 +
 src/cmd/compile/internal/ir/name.go  |   2 +
 src/cmd/compile/internal/ir/node.go  |   1 +
 src/cmd/compile/internal/ir/stmt.go  |  91 ++++++++++++++++++++++
 src/cmd/compile/internal/ir/type.go  |  44 +++++++++++
 src/cmd/compile/internal/ir/visit.go |  11 +--
 7 files changed, 252 insertions(+), 10 deletions(-)

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 9e5dfaf0f2..312faa8436 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -26,6 +26,13 @@ func maybeDoList(x Nodes, err error, do func(Node) error) error {
 	return err
 }
 
+func maybeEdit(x Node, edit func(Node) Node) Node {
+	if x == nil {
+		return x
+	}
+	return edit(x)
+}
+
 // A miniStmt is a miniNode with extra fields common to expressions.
 // TODO(rsc): Once we are sure about the contents, compact the bools
 // into a bit field and leave extra bits available for implementations
@@ -102,6 +109,10 @@ func (n *AddStringExpr) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.list, err, do)
 	return err
 }
+func (n *AddStringExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	editList(n.list, edit)
+}
 
 func (n *AddStringExpr) List() Nodes     { return n.list }
 func (n *AddStringExpr) PtrList() *Nodes { return &n.list }
@@ -135,6 +146,10 @@ func (n *AddrExpr) doChildren(do func(Node) error) error {
 	err = maybeDo(n.X, err, do)
 	return err
 }
+func (n *AddrExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+}
 
 func (n *AddrExpr) Left() Node      { return n.X }
 func (n *AddrExpr) SetLeft(x Node)  { n.X = x }
@@ -179,6 +194,11 @@ func (n *BinaryExpr) doChildren(do func(Node) error) error {
 	err = maybeDo(n.Y, err, do)
 	return err
 }
+func (n *BinaryExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+	n.Y = maybeEdit(n.Y, edit)
+}
 
 func (n *BinaryExpr) Left() Node      { return n.X }
 func (n *BinaryExpr) SetLeft(x Node)  { n.X = x }
@@ -249,6 +269,13 @@ func (n *CallExpr) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.body, err, do)
 	return err
 }
+func (n *CallExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+	editList(n.Args, edit)
+	editList(n.Rargs, edit)
+	editList(n.body, edit)
+}
 
 func (n *CallExpr) Orig() Node         { return n.orig }
 func (n *CallExpr) SetOrig(x Node)     { n.orig = x }
@@ -308,6 +335,10 @@ func (n *CallPartExpr) doChildren(do func(Node) error) error {
 	err = maybeDo(n.X, err, do)
 	return err
 }
+func (n *CallPartExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+}
 
 func (n *CallPartExpr) Func() *Func     { return n.fn }
 func (n *CallPartExpr) Left() Node      { return n.X }
@@ -339,6 +370,9 @@ func (n *ClosureExpr) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.init, err, do)
 	return err
 }
+func (n *ClosureExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+}
 
 func (n *ClosureExpr) Func() *Func { return n.fn }
 
@@ -370,6 +404,9 @@ func (n *ClosureRead) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.init, err, do)
 	return err
 }
+func (n *ClosureRead) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+}
 
 // A CompLitExpr is a composite literal Type{Vals}.
 // Before type-checking, the type is Ntype.
@@ -404,6 +441,11 @@ func (n *CompLitExpr) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.list, err, do)
 	return err
 }
+func (n *CompLitExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.Ntype = toNtype(maybeEdit(n.Ntype, edit))
+	editList(n.list, edit)
+}
 
 func (n *CompLitExpr) Orig() Node      { return n.orig }
 func (n *CompLitExpr) SetOrig(x Node)  { n.orig = x }
@@ -442,6 +484,7 @@ func (n *ConstExpr) String() string                       { return fmt.Sprint(n)
 func (n *ConstExpr) Format(s fmt.State, verb rune)        { FmtNode(n, s, verb) }
 func (n *ConstExpr) copy() Node                           { c := *n; return &c }
 func (n *ConstExpr) doChildren(do func(Node) error) error { return nil }
+func (n *ConstExpr) editChildren(edit func(Node) Node)    {}
 
 func (n *ConstExpr) Sym() *types.Sym     { return n.orig.Sym() }
 func (n *ConstExpr) Orig() Node          { return n.orig }
@@ -478,6 +521,10 @@ func (n *ConvExpr) doChildren(do func(Node) error) error {
 	err = maybeDo(n.X, err, do)
 	return err
 }
+func (n *ConvExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+}
 
 func (n *ConvExpr) rawCopy() Node  { c := *n; return &c }
 func (n *ConvExpr) Left() Node     { return n.X }
@@ -521,6 +568,11 @@ func (n *IndexExpr) doChildren(do func(Node) error) error {
 	err = maybeDo(n.Index, err, do)
 	return err
 }
+func (n *IndexExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+	n.Index = maybeEdit(n.Index, edit)
+}
 
 func (n *IndexExpr) Left() Node               { return n.X }
 func (n *IndexExpr) SetLeft(x Node)           { n.X = x }
@@ -570,6 +622,11 @@ func (n *KeyExpr) doChildren(do func(Node) error) error {
 	err = maybeDo(n.Value, err, do)
 	return err
 }
+func (n *KeyExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.Key = maybeEdit(n.Key, edit)
+	n.Value = maybeEdit(n.Value, edit)
+}
 
 func (n *KeyExpr) Left() Node          { return n.Key }
 func (n *KeyExpr) SetLeft(x Node)      { n.Key = x }
@@ -621,6 +678,11 @@ func (n *InlinedCallExpr) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.ReturnVars, err, do)
 	return err
 }
+func (n *InlinedCallExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	editList(n.body, edit)
+	editList(n.ReturnVars, edit)
+}
 
 func (n *InlinedCallExpr) Body() Nodes      { return n.body }
 func (n *InlinedCallExpr) PtrBody() *Nodes  { return &n.body }
@@ -659,6 +721,11 @@ func (n *MakeExpr) doChildren(do func(Node) error) error {
 	err = maybeDo(n.Cap, err, do)
 	return err
 }
+func (n *MakeExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.Len = maybeEdit(n.Len, edit)
+	n.Cap = maybeEdit(n.Cap, edit)
+}
 
 func (n *MakeExpr) Left() Node      { return n.Len }
 func (n *MakeExpr) SetLeft(x Node)  { n.Len = x }
@@ -707,6 +774,11 @@ func (n *MethodExpr) doChildren(do func(Node) error) error {
 	err = maybeDo(n.M, err, do)
 	return err
 }
+func (n *MethodExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+	n.M = maybeEdit(n.M, edit)
+}
 
 func (n *MethodExpr) Left() Node          { return n.X }
 func (n *MethodExpr) SetLeft(x Node)      { n.X = x }
@@ -745,6 +817,9 @@ func (n *NilExpr) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.init, err, do)
 	return err
 }
+func (n *NilExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+}
 
 func (n *NilExpr) Sym() *types.Sym     { return n.sym }
 func (n *NilExpr) SetSym(x *types.Sym) { n.sym = x }
@@ -776,6 +851,10 @@ func (n *ParenExpr) doChildren(do func(Node) error) error {
 	err = maybeDo(n.X, err, do)
 	return err
 }
+func (n *ParenExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+}
 
 func (n *ParenExpr) Left() Node     { return n.X }
 func (n *ParenExpr) SetLeft(x Node) { n.X = x }
@@ -816,6 +895,9 @@ func (n *ResultExpr) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.init, err, do)
 	return err
 }
+func (n *ResultExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+}
 
 func (n *ResultExpr) Offset() int64     { return n.offset }
 func (n *ResultExpr) SetOffset(x int64) { n.offset = x }
@@ -859,6 +941,10 @@ func (n *SelectorExpr) doChildren(do func(Node) error) error {
 	err = maybeDo(n.X, err, do)
 	return err
 }
+func (n *SelectorExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+}
 
 func (n *SelectorExpr) Left() Node          { return n.X }
 func (n *SelectorExpr) SetLeft(x Node)      { n.X = x }
@@ -900,6 +986,11 @@ func (n *SliceExpr) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.list, err, do)
 	return err
 }
+func (n *SliceExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+	editList(n.list, edit)
+}
 
 func (n *SliceExpr) Left() Node      { return n.X }
 func (n *SliceExpr) SetLeft(x Node)  { n.X = x }
@@ -1014,6 +1105,11 @@ func (n *SliceHeaderExpr) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.lenCap, err, do)
 	return err
 }
+func (n *SliceHeaderExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.Ptr = maybeEdit(n.Ptr, edit)
+	editList(n.lenCap, edit)
+}
 
 func (n *SliceHeaderExpr) Left() Node      { return n.Ptr }
 func (n *SliceHeaderExpr) SetLeft(x Node)  { n.Ptr = x }
@@ -1048,6 +1144,10 @@ func (n *StarExpr) doChildren(do func(Node) error) error {
 	err = maybeDo(n.X, err, do)
 	return err
 }
+func (n *StarExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+}
 
 func (n *StarExpr) Left() Node     { return n.X }
 func (n *StarExpr) SetLeft(x Node) { n.X = x }
@@ -1106,6 +1206,12 @@ func (n *TypeAssertExpr) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.Itab, err, do)
 	return err
 }
+func (n *TypeAssertExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+	n.Ntype = maybeEdit(n.Ntype, edit)
+	editList(n.Itab, edit)
+}
 
 func (n *TypeAssertExpr) Left() Node      { return n.X }
 func (n *TypeAssertExpr) SetLeft(x Node)  { n.X = x }
@@ -1151,6 +1257,10 @@ func (n *UnaryExpr) doChildren(do func(Node) error) error {
 	err = maybeDo(n.X, err, do)
 	return err
 }
+func (n *UnaryExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+}
 
 func (n *UnaryExpr) Left() Node     { return n.X }
 func (n *UnaryExpr) SetLeft(x Node) { n.X = x }
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 342b7a91e7..78e98c4d31 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -123,6 +123,9 @@ func (f *Func) doChildren(do func(Node) error) error {
 	err = maybeDoList(f.body, err, do)
 	return err
 }
+func (f *Func) editChildren(edit func(Node) Node) {
+	editList(f.body, edit)
+}
 
 func (f *Func) Func() *Func           { return f }
 func (f *Func) Body() Nodes           { return f.body }
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 2ff1fbc683..d2c33eab2b 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -153,6 +153,7 @@ func (n *Name) String() string                       { return fmt.Sprint(n) }
 func (n *Name) Format(s fmt.State, verb rune)        { FmtNode(n, s, verb) }
 func (n *Name) copy() Node                           { c := *n; return &c }
 func (n *Name) doChildren(do func(Node) error) error { return nil }
+func (n *Name) editChildren(edit func(Node) Node)    {}
 
 func (n *Name) Name() *Name         { return n }
 func (n *Name) Sym() *types.Sym     { return n.sym }
@@ -327,6 +328,7 @@ func (p *PkgName) String() string                       { return fmt.Sprint(p) }
 func (p *PkgName) Format(s fmt.State, verb rune)        { FmtNode(p, s, verb) }
 func (p *PkgName) copy() Node                           { c := *p; return &c }
 func (p *PkgName) doChildren(do func(Node) error) error { return nil }
+func (p *PkgName) editChildren(edit func(Node) Node) {}
 
 func (p *PkgName) Sym() *types.Sym { return p.sym }
 
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 02ab87846f..f44d22313c 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -31,6 +31,7 @@ type Node interface {
 	copy() Node
 
 	doChildren(func(Node) error) error
+	editChildren(func(Node) Node)
 
 	// Abstract graph structure, for generic traversals.
 	Op() Op
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index b940c5f59d..c859fae55b 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -36,6 +36,9 @@ func (n *Decl) doChildren(do func(Node) error) error {
 	err = maybeDo(n.X, err, do)
 	return err
 }
+func (n *Decl) editChildren(edit func(Node) Node) {
+	n.X = maybeEdit(n.X, edit)
+}
 
 func (n *Decl) Left() Node     { return n.X }
 func (n *Decl) SetLeft(x Node) { n.X = x }
@@ -89,6 +92,11 @@ func (n *AssignListStmt) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.Rhs, err, do)
 	return err
 }
+func (n *AssignListStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	editList(n.Lhs, edit)
+	editList(n.Rhs, edit)
+}
 
 func (n *AssignListStmt) List() Nodes       { return n.Lhs }
 func (n *AssignListStmt) PtrList() *Nodes   { return &n.Lhs }
@@ -142,6 +150,11 @@ func (n *AssignStmt) doChildren(do func(Node) error) error {
 	err = maybeDo(n.Y, err, do)
 	return err
 }
+func (n *AssignStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+	n.Y = maybeEdit(n.Y, edit)
+}
 
 func (n *AssignStmt) Left() Node        { return n.X }
 func (n *AssignStmt) SetLeft(x Node)    { n.X = x }
@@ -192,6 +205,11 @@ func (n *AssignOpStmt) doChildren(do func(Node) error) error {
 	err = maybeDo(n.Y, err, do)
 	return err
 }
+func (n *AssignOpStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+	n.Y = maybeEdit(n.Y, edit)
+}
 
 func (n *AssignOpStmt) Left() Node            { return n.X }
 func (n *AssignOpStmt) SetLeft(x Node)        { n.X = x }
@@ -232,6 +250,10 @@ func (n *BlockStmt) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.list, err, do)
 	return err
 }
+func (n *BlockStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	editList(n.list, edit)
+}
 
 func (n *BlockStmt) List() Nodes     { return n.list }
 func (n *BlockStmt) PtrList() *Nodes { return &n.list }
@@ -271,6 +293,9 @@ func (n *BranchStmt) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.init, err, do)
 	return err
 }
+func (n *BranchStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+}
 
 func (n *BranchStmt) Sym() *types.Sym       { return n.Label }
 func (n *BranchStmt) SetSym(sym *types.Sym) { n.Label = sym }
@@ -312,6 +337,13 @@ func (n *CaseStmt) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.body, err, do)
 	return err
 }
+func (n *CaseStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	editList(n.Vars, edit)
+	editList(n.list, edit)
+	n.Comm = maybeEdit(n.Comm, edit)
+	editList(n.body, edit)
+}
 
 func (n *CaseStmt) List() Nodes      { return n.list }
 func (n *CaseStmt) PtrList() *Nodes  { return &n.list }
@@ -351,6 +383,10 @@ func (n *DeferStmt) doChildren(do func(Node) error) error {
 	err = maybeDo(n.Call, err, do)
 	return err
 }
+func (n *DeferStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.Call = maybeEdit(n.Call, edit)
+}
 
 func (n *DeferStmt) Left() Node     { return n.Call }
 func (n *DeferStmt) SetLeft(x Node) { n.Call = x }
@@ -394,6 +430,13 @@ func (n *ForStmt) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.body, err, do)
 	return err
 }
+func (n *ForStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.Cond = maybeEdit(n.Cond, edit)
+	editList(n.Late, edit)
+	n.Post = maybeEdit(n.Post, edit)
+	editList(n.body, edit)
+}
 
 func (n *ForStmt) Sym() *types.Sym     { return n.Label }
 func (n *ForStmt) SetSym(x *types.Sym) { n.Label = x }
@@ -443,6 +486,10 @@ func (n *GoStmt) doChildren(do func(Node) error) error {
 	err = maybeDo(n.Call, err, do)
 	return err
 }
+func (n *GoStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.Call = maybeEdit(n.Call, edit)
+}
 
 func (n *GoStmt) Left() Node     { return n.Call }
 func (n *GoStmt) SetLeft(x Node) { n.Call = x }
@@ -482,6 +529,12 @@ func (n *IfStmt) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.Else, err, do)
 	return err
 }
+func (n *IfStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.Cond = maybeEdit(n.Cond, edit)
+	editList(n.body, edit)
+	editList(n.Else, edit)
+}
 
 func (n *IfStmt) Left() Node       { return n.Cond }
 func (n *IfStmt) SetLeft(x Node)   { n.Cond = x }
@@ -519,6 +572,9 @@ func (n *InlineMarkStmt) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.init, err, do)
 	return err
 }
+func (n *InlineMarkStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+}
 
 func (n *InlineMarkStmt) Offset() int64     { return n.Index }
 func (n *InlineMarkStmt) SetOffset(x int64) { n.Index = x }
@@ -548,6 +604,9 @@ func (n *LabelStmt) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.init, err, do)
 	return err
 }
+func (n *LabelStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+}
 
 func (n *LabelStmt) Sym() *types.Sym     { return n.Label }
 func (n *LabelStmt) SetSym(x *types.Sym) { n.Label = x }
@@ -591,6 +650,12 @@ func (n *RangeStmt) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.body, err, do)
 	return err
 }
+func (n *RangeStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	editList(n.Vars, edit)
+	n.X = maybeEdit(n.X, edit)
+	editList(n.body, edit)
+}
 
 func (n *RangeStmt) Sym() *types.Sym       { return n.Label }
 func (n *RangeStmt) SetSym(x *types.Sym)   { n.Label = x }
@@ -639,6 +704,10 @@ func (n *ReturnStmt) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.Results, err, do)
 	return err
 }
+func (n *ReturnStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	editList(n.Results, edit)
+}
 
 func (n *ReturnStmt) Orig() Node      { return n.orig }
 func (n *ReturnStmt) SetOrig(x Node)  { n.orig = x }
@@ -682,6 +751,11 @@ func (n *SelectStmt) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.Compiled, err, do)
 	return err
 }
+func (n *SelectStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	editList(n.Cases, edit)
+	editList(n.Compiled, edit)
+}
 
 func (n *SelectStmt) List() Nodes         { return n.Cases }
 func (n *SelectStmt) PtrList() *Nodes     { return &n.Cases }
@@ -722,6 +796,11 @@ func (n *SendStmt) doChildren(do func(Node) error) error {
 	err = maybeDo(n.Value, err, do)
 	return err
 }
+func (n *SendStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.Chan = maybeEdit(n.Chan, edit)
+	n.Value = maybeEdit(n.Value, edit)
+}
 
 func (n *SendStmt) Left() Node      { return n.Chan }
 func (n *SendStmt) SetLeft(x Node)  { n.Chan = x }
@@ -765,6 +844,12 @@ func (n *SwitchStmt) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.Compiled, err, do)
 	return err
 }
+func (n *SwitchStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.Tag = maybeEdit(n.Tag, edit)
+	editList(n.Cases, edit)
+	editList(n.Compiled, edit)
+}
 
 func (n *SwitchStmt) Left() Node          { return n.Tag }
 func (n *SwitchStmt) SetLeft(x Node)      { n.Tag = x }
@@ -807,6 +892,12 @@ func (n *TypeSwitchGuard) doChildren(do func(Node) error) error {
 	err = maybeDo(n.X, err, do)
 	return err
 }
+func (n *TypeSwitchGuard) editChildren(edit func(Node) Node) {
+	if n.name != nil {
+		n.name = edit(n.name).(*Name)
+	}
+	n.X = maybeEdit(n.X, edit)
+}
 
 func (n *TypeSwitchGuard) Left() Node {
 	if n.name == nil {
diff --git a/src/cmd/compile/internal/ir/type.go b/src/cmd/compile/internal/ir/type.go
index 2723c00044..d69dc3fd2a 100644
--- a/src/cmd/compile/internal/ir/type.go
+++ b/src/cmd/compile/internal/ir/type.go
@@ -80,6 +80,9 @@ func (n *ChanType) doChildren(do func(Node) error) error {
 	err = maybeDo(n.Elem, err, do)
 	return err
 }
+func (n *ChanType) editChildren(edit func(Node) Node) {
+	n.Elem = maybeEdit(n.Elem, edit)
+}
 func (n *ChanType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
 	n.Elem = nil
@@ -116,6 +119,10 @@ func (n *MapType) doChildren(do func(Node) error) error {
 	err = maybeDo(n.Elem, err, do)
 	return err
 }
+func (n *MapType) editChildren(edit func(Node) Node) {
+	n.Key = maybeEdit(n.Key, edit)
+	n.Elem = maybeEdit(n.Elem, edit)
+}
 func (n *MapType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
 	n.Key = nil
@@ -155,6 +162,9 @@ func (n *StructType) doChildren(do func(Node) error) error {
 	err = maybeDoFields(n.Fields, err, do)
 	return err
 }
+func (n *StructType) editChildren(edit func(Node) Node) {
+	editFields(n.Fields, edit)
+}
 
 func (n *StructType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
@@ -202,6 +212,9 @@ func (n *InterfaceType) doChildren(do func(Node) error) error {
 	err = maybeDoFields(n.Methods, err, do)
 	return err
 }
+func (n *InterfaceType) editChildren(edit func(Node) Node) {
+	editFields(n.Methods, edit)
+}
 
 func (n *InterfaceType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
@@ -249,6 +262,11 @@ func (n *FuncType) doChildren(do func(Node) error) error {
 	err = maybeDoFields(n.Results, err, do)
 	return err
 }
+func (n *FuncType) editChildren(edit func(Node) Node) {
+	editField(n.Recv, edit)
+	editFields(n.Params, edit)
+	editFields(n.Results, edit)
+}
 
 func (n *FuncType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
@@ -337,6 +355,24 @@ func maybeDoFields(list []*Field, err error, do func(Node) error) error {
 	return err
 }
 
+func editField(f *Field, edit func(Node) Node) {
+	if f == nil {
+		return
+	}
+	if f.Decl != nil {
+		f.Decl = edit(f.Decl).(*Name)
+	}
+	if f.Ntype != nil {
+		f.Ntype = toNtype(edit(f.Ntype))
+	}
+}
+
+func editFields(list []*Field, edit func(Node) Node) {
+	for _, f := range list {
+		editField(f, edit)
+	}
+}
+
 func (f *Field) deepCopy(pos src.XPos) *Field {
 	if f == nil {
 		return nil
@@ -380,6 +416,9 @@ func (n *SliceType) doChildren(do func(Node) error) error {
 	err = maybeDo(n.Elem, err, do)
 	return err
 }
+func (n *SliceType) editChildren(edit func(Node) Node) {
+	n.Elem = maybeEdit(n.Elem, edit)
+}
 func (n *SliceType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
 	n.Elem = nil
@@ -417,6 +456,10 @@ func (n *ArrayType) doChildren(do func(Node) error) error {
 	err = maybeDo(n.Elem, err, do)
 	return err
 }
+func (n *ArrayType) editChildren(edit func(Node) Node) {
+	n.Len = maybeEdit(n.Len, edit)
+	n.Elem = maybeEdit(n.Elem, edit)
+}
 
 func (n *ArrayType) DeepCopy(pos src.XPos) Node {
 	if n.op == OTYPE {
@@ -451,6 +494,7 @@ func (n *typeNode) copy() Node                    { c := *n; return &c }
 func (n *typeNode) doChildren(do func(Node) error) error {
 	return nil
 }
+func (n *typeNode) editChildren(edit func(Node) Node) {}
 
 func (n *typeNode) Type() *types.Type { return n.typ }
 func (n *typeNode) Sym() *types.Sym   { return n.typ.Sym() }
diff --git a/src/cmd/compile/internal/ir/visit.go b/src/cmd/compile/internal/ir/visit.go
index 042257c32a..4f3575614d 100644
--- a/src/cmd/compile/internal/ir/visit.go
+++ b/src/cmd/compile/internal/ir/visit.go
@@ -226,16 +226,7 @@ func EditChildren(n Node, edit func(Node) Node) {
 	if n == nil {
 		return
 	}
-	editList(n.Init(), edit)
-	if l := n.Left(); l != nil {
-		n.SetLeft(edit(l))
-	}
-	if r := n.Right(); r != nil {
-		n.SetRight(edit(r))
-	}
-	editList(n.List(), edit)
-	editList(n.Body(), edit)
-	editList(n.Rlist(), edit)
+	n.editChildren(edit)
 }
 
 // editList calls edit on each non-nil node x in the list,
-- 
GitLab


From 9ab3d854ad95d06f5dd0874050ee57dd63c5a746 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 3 Dec 2020 23:56:16 -0500
Subject: [PATCH 0154/2400] [dev.regabi] cmd/compile: avoid general traversal
 in deadcode

deadcode is trying to walk the statements it can find,
but it can sweep in other nodes too. Stop doing that:
only walk known statements containing statements.

Otherwise, if we put panics in expression accessors that
shouldn't be used anymore, deadcode can trip them.

deadcode would be a good candidate to rewrite using
EditChildren, but that would certainly cause toolstash
changes, since deadcode is so ad-hoc about exactly
which parts of the function it looks at. For now just
remove the general traversal and leave as is.

Passes buildall w/ toolstash -cmp.

Change-Id: I06481eb87350905597600203c4fa724d55645b46
Reviewed-on: https://go-review.googlesource.com/c/go/+/275377
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/typecheck.go | 21 ++++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 65c5f2abce..2070297bc0 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -3860,9 +3860,24 @@ func deadcodeslice(nn *ir.Nodes) {
 		}
 
 		deadcodeslice(n.PtrInit())
-		deadcodeslice(n.PtrBody())
-		deadcodeslice(n.PtrList())
-		deadcodeslice(n.PtrRlist())
+		switch n.Op() {
+		case ir.OBLOCK:
+			deadcodeslice(n.PtrList())
+		case ir.OCASE:
+			deadcodeslice(n.PtrBody())
+		case ir.OFOR:
+			deadcodeslice(n.PtrBody())
+		case ir.OIF:
+			deadcodeslice(n.PtrBody())
+			deadcodeslice(n.PtrRlist())
+		case ir.ORANGE:
+			deadcodeslice(n.PtrBody())
+		case ir.OSELECT:
+			deadcodeslice(n.PtrList())
+		case ir.OSWITCH:
+			deadcodeslice(n.PtrList())
+		}
+
 		if cut {
 			nn.Set(nn.Slice()[:i+1])
 			break
-- 
GitLab


From 5dbd2e8e44d823bfbc3df883c544e23f4a872de1 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 4 Dec 2020 00:30:53 -0500
Subject: [PATCH 0155/2400] [dev.regabi] cmd/compile: remove DeepCopyNode
 interface

The only reason for the DeepCopyNode interface was to
allow the type syntaxes to avoid being constrained by
Left, Right etc. methods. Now those are gone, so the
general traversal methods they implement (doChildren, editChildren)
do the right thing for DeepCopy.

Passes buildall w/ toolstash -cmp.

Change-Id: I54672c011114a95efabff32dbcf02e6071f91b9e
Reviewed-on: https://go-review.googlesource.com/c/go/+/275379
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/copy.go | 21 ----------
 src/cmd/compile/internal/ir/expr.go | 11 ------
 src/cmd/compile/internal/ir/type.go | 59 -----------------------------
 3 files changed, 91 deletions(-)

diff --git a/src/cmd/compile/internal/ir/copy.go b/src/cmd/compile/internal/ir/copy.go
index 86e78cfc33..7f5d313513 100644
--- a/src/cmd/compile/internal/ir/copy.go
+++ b/src/cmd/compile/internal/ir/copy.go
@@ -70,33 +70,12 @@ func copyList(x Nodes) Nodes {
 	return AsNodes(c)
 }
 
-// A Node can implement DeepCopyNode to provide a custom implementation
-// of DeepCopy. If the compiler only needs access to a Node's structure during
-// DeepCopy, then a Node can implement DeepCopyNode instead of providing
-// fine-grained mutable access with Left, SetLeft, Right, SetRight, and so on.
-type DeepCopyNode interface {
-	Node
-	DeepCopy(pos src.XPos) Node
-}
-
 // DeepCopy returns a “deep” copy of n, with its entire structure copied
 // (except for shared nodes like ONAME, ONONAME, OLITERAL, and OTYPE).
 // If pos.IsKnown(), it sets the source position of newly allocated Nodes to pos.
-//
-// The default implementation is to traverse the Node graph, making
-// a shallow copy of each node and then updating each field to point
-// at shallow copies of children, recursively, using Left, SetLeft, and so on.
-//
-// If a Node wishes to provide an alternate implementation, it can
-// implement a DeepCopy method: see the DeepCopyNode interface.
-//
-// TODO(rsc): Once Nodes implement EditChildren, remove the DeepCopyNode interface.
 func DeepCopy(pos src.XPos, n Node) Node {
 	var edit func(Node) Node
 	edit = func(x Node) Node {
-		if x, ok := x.(DeepCopyNode); ok {
-			return x.DeepCopy(pos)
-		}
 		switch x.Op() {
 		case OPACK, ONAME, ONONAME, OLITERAL, ONIL, OTYPE:
 			return x
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 312faa8436..cfdb86f221 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -1163,17 +1163,6 @@ func (n *StarExpr) SetOTYPE(t *types.Type) {
 	t.SetNod(n)
 }
 
-func (n *StarExpr) DeepCopy(pos src.XPos) Node {
-	if n.op == OTYPE {
-		// Can't change types and no node references left.
-		return n
-	}
-	c := SepCopy(n).(*StarExpr)
-	c.pos = n.posOr(pos)
-	c.X = DeepCopy(pos, n.X)
-	return c
-}
-
 // A TypeAssertionExpr is a selector expression X.(Type).
 // Before type-checking, the type is Ntype.
 type TypeAssertExpr struct {
diff --git a/src/cmd/compile/internal/ir/type.go b/src/cmd/compile/internal/ir/type.go
index d69dc3fd2a..9f82c9faa2 100644
--- a/src/cmd/compile/internal/ir/type.go
+++ b/src/cmd/compile/internal/ir/type.go
@@ -88,14 +88,6 @@ func (n *ChanType) SetOTYPE(t *types.Type) {
 	n.Elem = nil
 }
 
-func (n *ChanType) DeepCopy(pos src.XPos) Node {
-	if n.op == OTYPE {
-		// Can't change types and no node references left.
-		return n
-	}
-	return NewChanType(n.posOr(pos), DeepCopy(pos, n.Elem), n.Dir)
-}
-
 // A MapType represents a map[Key]Value type syntax.
 type MapType struct {
 	miniType
@@ -129,14 +121,6 @@ func (n *MapType) SetOTYPE(t *types.Type) {
 	n.Elem = nil
 }
 
-func (n *MapType) DeepCopy(pos src.XPos) Node {
-	if n.op == OTYPE {
-		// Can't change types and no node references left.
-		return n
-	}
-	return NewMapType(n.posOr(pos), DeepCopy(pos, n.Key), DeepCopy(pos, n.Elem))
-}
-
 // A StructType represents a struct { ... } type syntax.
 type StructType struct {
 	miniType
@@ -171,14 +155,6 @@ func (n *StructType) SetOTYPE(t *types.Type) {
 	n.Fields = nil
 }
 
-func (n *StructType) DeepCopy(pos src.XPos) Node {
-	if n.op == OTYPE {
-		// Can't change types and no node references left.
-		return n
-	}
-	return NewStructType(n.posOr(pos), deepCopyFields(pos, n.Fields))
-}
-
 func deepCopyFields(pos src.XPos, fields []*Field) []*Field {
 	var out []*Field
 	for _, f := range fields {
@@ -221,14 +197,6 @@ func (n *InterfaceType) SetOTYPE(t *types.Type) {
 	n.Methods = nil
 }
 
-func (n *InterfaceType) DeepCopy(pos src.XPos) Node {
-	if n.op == OTYPE {
-		// Can't change types and no node references left.
-		return n
-	}
-	return NewInterfaceType(n.posOr(pos), deepCopyFields(pos, n.Methods))
-}
-
 // A FuncType represents a func(Args) Results type syntax.
 type FuncType struct {
 	miniType
@@ -275,17 +243,6 @@ func (n *FuncType) SetOTYPE(t *types.Type) {
 	n.Results = nil
 }
 
-func (n *FuncType) DeepCopy(pos src.XPos) Node {
-	if n.op == OTYPE {
-		// Can't change types and no node references left.
-		return n
-	}
-	return NewFuncType(n.posOr(pos),
-		n.Recv.deepCopy(pos),
-		deepCopyFields(pos, n.Params),
-		deepCopyFields(pos, n.Results))
-}
-
 // A Field is a declared struct field, interface method, or function argument.
 // It is not a Node.
 type Field struct {
@@ -424,14 +381,6 @@ func (n *SliceType) SetOTYPE(t *types.Type) {
 	n.Elem = nil
 }
 
-func (n *SliceType) DeepCopy(pos src.XPos) Node {
-	if n.op == OTYPE {
-		// Can't change types and no node references left.
-		return n
-	}
-	return NewSliceType(n.posOr(pos), DeepCopy(pos, n.Elem))
-}
-
 // An ArrayType represents a [Len]Elem type syntax.
 // If Len is nil, the type is a [...]Elem in an array literal.
 type ArrayType struct {
@@ -461,14 +410,6 @@ func (n *ArrayType) editChildren(edit func(Node) Node) {
 	n.Elem = maybeEdit(n.Elem, edit)
 }
 
-func (n *ArrayType) DeepCopy(pos src.XPos) Node {
-	if n.op == OTYPE {
-		// Can't change types and no node references left.
-		return n
-	}
-	return NewArrayType(n.posOr(pos), DeepCopy(pos, n.Len), DeepCopy(pos, n.Elem))
-}
-
 func (n *ArrayType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
 	n.Len = nil
-- 
GitLab


From d9cb84c84bb0edc1afb782f99de4cc424ac0d23f Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 3 Dec 2020 16:52:45 -0800
Subject: [PATCH 0156/2400] [dev.regabi] cmd/compile: add SameSource, Uses, and
 DeclaredBy helpers

Currently, because we use the same *Name to represent both declaration
and uses of an object, it's ambiguous what "n1 == n2" means when
comparing two Node values. It can mean any of: Are these the same
syntactic element? Is n1 a use of declared variable n2? Are n1 and n2
both uses of the same declared variable?

We'd like to introduce a new IdentExpr node to replace use of Name
within the AST, but that means those three cases need to be handled
differently. The first case needs to stay "n1 == n2", but the other
cases need to become "n1.Name() == n2" and "n1.Name() == n2.Name()",
respectively. ("n1.Name() == n2.Name()" also currently works for the
second case, but eventually we'll want to get rid of the Name.Name
method.)

This CL introduces helper functions SameSource and Uses to handle
these cases. It also introduces DeclaredBy, which is another somewhat
common case that the next CL introduces uses of.

Passes buildall w/ toolstash -cmp.

Updates #42990.

Change-Id: Ia816c124446e9067645d5820a8163f295968794f
Reviewed-on: https://go-review.googlesource.com/c/go/+/275305
Reviewed-by: Russ Cox <rsc@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/name.go | 37 +++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index d2c33eab2b..030fb82a7d 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -297,6 +297,43 @@ func (n *Name) SetVal(v constant.Value) {
 	n.val = v
 }
 
+// SameSource reports whether two nodes refer to the same source
+// element.
+//
+// It exists to help incrementally migrate the compiler towards
+// allowing the introduction of IdentExpr (#42990). Once we have
+// IdentExpr, it will no longer be safe to directly compare Node
+// values to tell if they refer to the same Name. Instead, code will
+// need to explicitly get references to the underlying Name object(s),
+// and compare those instead.
+//
+// It will still be safe to compare Nodes directly for checking if two
+// nodes are syntactically the same. The SameSource function exists to
+// indicate code that intentionally compares Nodes for syntactic
+// equality as opposed to code that has yet to be updated in
+// preparation for IdentExpr.
+func SameSource(n1, n2 Node) bool {
+	return n1 == n2
+}
+
+// Uses reports whether expression x is a (direct) use of the given
+// variable.
+func Uses(x Node, v *Name) bool {
+	if v == nil || v.Op() != ONAME {
+		base.Fatalf("RefersTo bad Name: %v", v)
+	}
+	return x.Op() == ONAME && x.Name() == v
+}
+
+// DeclaredBy reports whether expression x refers (directly) to a
+// variable that was declared by the given statement.
+func DeclaredBy(x, stmt Node) bool {
+	if stmt == nil {
+		base.Fatalf("DeclaredBy nil")
+	}
+	return x.Op() == ONAME && SameSource(x.Name().Defn, stmt)
+}
+
 // The Class of a variable/function describes the "storage class"
 // of a variable or function. During parsing, storage classes are
 // called declaration contexts.
-- 
GitLab


From 133b03e1c386dc69e46fa36f9053ff6993125ace Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 3 Dec 2020 16:57:56 -0800
Subject: [PATCH 0157/2400] [dev.regabi] cmd/compile: rewrite code to use
 DeclaredBy

Passes buildall w/ toolstash -cmp.

Updates #42990.

[git-generate]
cd src/cmd/compile/internal/gc
rf '
ex {
  import "cmd/compile/internal/ir"
  var x, stmt ir.Node
  x.Name() != nil && x.Name().Defn == stmt ->  ir.DeclaredBy(x, stmt)
  x.Name() == nil || x.Name().Defn != stmt -> !ir.DeclaredBy(x, stmt)
}
'

Change-Id: I222a757296dbcb5d0889d617d221a9d7319f2d74
Reviewed-on: https://go-review.googlesource.com/c/go/+/275306
Reviewed-by: Russ Cox <rsc@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/range.go     |  8 ++++----
 src/cmd/compile/internal/gc/typecheck.go | 16 ++++++++--------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index e48642a854..8025119c5e 100644
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -49,7 +49,7 @@ func typecheckrangeExpr(n ir.Node) {
 	// delicate little dance.  see typecheckas2
 	ls := n.List().Slice()
 	for i1, n1 := range ls {
-		if n1.Name() == nil || n1.Name().Defn != n {
+		if !ir.DeclaredBy(n1, n) {
 			ls[i1] = typecheck(ls[i1], ctxExpr|ctxAssign)
 		}
 	}
@@ -115,7 +115,7 @@ func typecheckrangeExpr(n ir.Node) {
 	}
 
 	if v1 != nil {
-		if v1.Name() != nil && v1.Name().Defn == n {
+		if ir.DeclaredBy(v1, n) {
 			v1.SetType(t1)
 		} else if v1.Type() != nil {
 			if op, why := assignop(t1, v1.Type()); op == ir.OXXX {
@@ -126,7 +126,7 @@ func typecheckrangeExpr(n ir.Node) {
 	}
 
 	if v2 != nil {
-		if v2.Name() != nil && v2.Name().Defn == n {
+		if ir.DeclaredBy(v2, n) {
 			v2.SetType(t2)
 		} else if v2.Type() != nil {
 			if op, why := assignop(t2, v2.Type()); op == ir.OXXX {
@@ -477,7 +477,7 @@ func isMapClear(n ir.Node) bool {
 	}
 
 	// Require k to be a new variable name.
-	if k.Name() == nil || k.Name().Defn != n {
+	if !ir.DeclaredBy(k, n) {
 		return false
 	}
 
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 2070297bc0..c22786f148 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -3083,7 +3083,7 @@ func checklvalue(n ir.Node, verb string) {
 
 func checkassign(stmt ir.Node, n ir.Node) {
 	// Variables declared in ORANGE are assigned on every iteration.
-	if n.Name() == nil || n.Name().Defn != stmt || stmt.Op() == ir.ORANGE {
+	if !ir.DeclaredBy(n, stmt) || stmt.Op() == ir.ORANGE {
 		r := outervalue(n)
 		if r.Op() == ir.ONAME {
 			r.Name().SetAssigned(true)
@@ -3192,7 +3192,7 @@ func typecheckas(n ir.Node) {
 	// so that the conversion below happens).
 	n.SetLeft(resolve(n.Left()))
 
-	if n.Left().Name() == nil || n.Left().Name().Defn != n || n.Left().Name().Ntype != nil {
+	if !ir.DeclaredBy(n.Left(), n) || n.Left().Name().Ntype != nil {
 		n.SetLeft(typecheck(n.Left(), ctxExpr|ctxAssign))
 	}
 
@@ -3211,7 +3211,7 @@ func typecheckas(n ir.Node) {
 		}
 	}
 
-	if n.Left().Name() != nil && n.Left().Name().Defn == n && n.Left().Name().Ntype == nil {
+	if ir.DeclaredBy(n.Left(), n) && n.Left().Name().Ntype == nil {
 		n.SetRight(defaultlit(n.Right(), nil))
 		n.Left().SetType(n.Right().Type())
 	}
@@ -3247,7 +3247,7 @@ func typecheckas2(n ir.Node) {
 		n1 = resolve(n1)
 		ls[i1] = n1
 
-		if n1.Name() == nil || n1.Name().Defn != n || n1.Name().Ntype != nil {
+		if !ir.DeclaredBy(n1, n) || n1.Name().Ntype != nil {
 			ls[i1] = typecheck(ls[i1], ctxExpr|ctxAssign)
 		}
 	}
@@ -3272,7 +3272,7 @@ func typecheckas2(n ir.Node) {
 			if nl.Type() != nil && nr.Type() != nil {
 				rs[il] = assignconv(nr, nl.Type(), "assignment")
 			}
-			if nl.Name() != nil && nl.Name().Defn == n && nl.Name().Ntype == nil {
+			if ir.DeclaredBy(nl, n) && nl.Name().Ntype == nil {
 				rs[il] = defaultlit(rs[il], nil)
 				nl.SetType(rs[il].Type())
 			}
@@ -3305,7 +3305,7 @@ func typecheckas2(n ir.Node) {
 				if f.Type != nil && l.Type() != nil {
 					checkassignto(f.Type, l)
 				}
-				if l.Name() != nil && l.Name().Defn == n && l.Name().Ntype == nil {
+				if ir.DeclaredBy(l, n) && l.Name().Ntype == nil {
 					l.SetType(f.Type)
 				}
 			}
@@ -3332,14 +3332,14 @@ func typecheckas2(n ir.Node) {
 			if l.Type() != nil {
 				checkassignto(r.Type(), l)
 			}
-			if l.Name() != nil && l.Name().Defn == n {
+			if ir.DeclaredBy(l, n) {
 				l.SetType(r.Type())
 			}
 			l := n.List().Second()
 			if l.Type() != nil && !l.Type().IsBoolean() {
 				checkassignto(types.Types[types.TBOOL], l)
 			}
-			if l.Name() != nil && l.Name().Defn == n && l.Name().Ntype == nil {
+			if ir.DeclaredBy(l, n) && l.Name().Ntype == nil {
 				l.SetType(types.Types[types.TBOOL])
 			}
 			goto out
-- 
GitLab


From b75f51c6451a00f223ad43ed7069e4136466fdac Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Fri, 4 Dec 2020 11:07:25 +0700
Subject: [PATCH 0158/2400] [dev.regabi] cmd/compile: replace ir.Node with
 *ir.Name in Liveness

Passes buildall w/ toolstash -cmp.

Updates #42982

Change-Id: Iad8df321adfd576da070c13ed16a9651d4e59ad8
Reviewed-on: https://go-review.googlesource.com/c/go/+/275352
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/plive.go | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/gc/plive.go
index f2555cc941..06e423daa1 100644
--- a/src/cmd/compile/internal/gc/plive.go
+++ b/src/cmd/compile/internal/gc/plive.go
@@ -103,8 +103,8 @@ type BlockEffects struct {
 type Liveness struct {
 	fn         *ir.Func
 	f          *ssa.Func
-	vars       []ir.Node
-	idx        map[ir.Node]int32
+	vars       []*ir.Name
+	idx        map[*ir.Name]int32
 	stkptrsize int64
 
 	be []BlockEffects
@@ -212,14 +212,14 @@ func livenessShouldTrack(n ir.Node) bool {
 
 // getvariables returns the list of on-stack variables that we need to track
 // and a map for looking up indices by *Node.
-func getvariables(fn *ir.Func) ([]ir.Node, map[ir.Node]int32) {
-	var vars []ir.Node
+func getvariables(fn *ir.Func) ([]*ir.Name, map[*ir.Name]int32) {
+	var vars []*ir.Name
 	for _, n := range fn.Dcl {
 		if livenessShouldTrack(n) {
 			vars = append(vars, n)
 		}
 	}
-	idx := make(map[ir.Node]int32, len(vars))
+	idx := make(map[*ir.Name]int32, len(vars))
 	for i, n := range vars {
 		idx[n] = int32(i)
 	}
@@ -276,13 +276,14 @@ func (lv *Liveness) valueEffects(v *ssa.Value) (int32, liveEffect) {
 		return -1, 0
 	}
 
+	nn := n.(*ir.Name)
 	// AllocFrame has dropped unused variables from
 	// lv.fn.Func.Dcl, but they might still be referenced by
 	// OpVarFoo pseudo-ops. Ignore them to prevent "lost track of
 	// variable" ICEs (issue 19632).
 	switch v.Op {
 	case ssa.OpVarDef, ssa.OpVarKill, ssa.OpVarLive, ssa.OpKeepAlive:
-		if !n.Name().Used() {
+		if !nn.Name().Used() {
 			return -1, 0
 		}
 	}
@@ -305,7 +306,7 @@ func (lv *Liveness) valueEffects(v *ssa.Value) (int32, liveEffect) {
 		return -1, 0
 	}
 
-	if pos, ok := lv.idx[n]; ok {
+	if pos, ok := lv.idx[nn]; ok {
 		return pos, effect
 	}
 	return -1, 0
@@ -356,7 +357,7 @@ type livenessFuncCache struct {
 // Constructs a new liveness structure used to hold the global state of the
 // liveness computation. The cfg argument is a slice of *BasicBlocks and the
 // vars argument is a slice of *Nodes.
-func newliveness(fn *ir.Func, f *ssa.Func, vars []ir.Node, idx map[ir.Node]int32, stkptrsize int64) *Liveness {
+func newliveness(fn *ir.Func, f *ssa.Func, vars []*ir.Name, idx map[*ir.Name]int32, stkptrsize int64) *Liveness {
 	lv := &Liveness{
 		fn:         fn,
 		f:          f,
@@ -482,7 +483,7 @@ func onebitwalktype1(t *types.Type, off int64, bv bvec) {
 // Generates live pointer value maps for arguments and local variables. The
 // this argument and the in arguments are always assumed live. The vars
 // argument is a slice of *Nodes.
-func (lv *Liveness) pointerMap(liveout bvec, vars []ir.Node, args, locals bvec) {
+func (lv *Liveness) pointerMap(liveout bvec, vars []*ir.Name, args, locals bvec) {
 	for i := int32(0); ; i++ {
 		i = liveout.Next(i)
 		if i < 0 {
-- 
GitLab


From 46b6e70e3b9380b5dff6319673e385950b9fb201 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Fri, 4 Dec 2020 11:38:47 +0700
Subject: [PATCH 0159/2400] [dev.regabi] cmd/compile: replace ir.Node with
 *ir.Name in Order

Passes buildall w/ toolstash -cmp.

Updates #42982

Change-Id: I7121c37f72ccbc141a7dd17fba1753f2c6289908
Reviewed-on: https://go-review.googlesource.com/c/go/+/275353
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/order.go | 14 +++++++-------
 src/cmd/compile/internal/gc/sinit.go |  6 +++---
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 1680d9d920..39b78c9819 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -44,9 +44,9 @@ import (
 
 // Order holds state during the ordering process.
 type Order struct {
-	out  []ir.Node            // list of generated statements
-	temp []ir.Node            // stack of temporary variables
-	free map[string][]ir.Node // free list of unused temporaries, by type.LongString().
+	out  []ir.Node             // list of generated statements
+	temp []*ir.Name            // stack of temporary variables
+	free map[string][]*ir.Name // free list of unused temporaries, by type.LongString().
 }
 
 // Order rewrites fn.Nbody to apply the ordering constraints
@@ -57,14 +57,14 @@ func order(fn *ir.Func) {
 		ir.DumpList(s, fn.Body())
 	}
 
-	orderBlock(fn.PtrBody(), map[string][]ir.Node{})
+	orderBlock(fn.PtrBody(), map[string][]*ir.Name{})
 }
 
 // newTemp allocates a new temporary with the given type,
 // pushes it onto the temp stack, and returns it.
 // If clear is true, newTemp emits code to zero the temporary.
 func (o *Order) newTemp(t *types.Type, clear bool) ir.Node {
-	var v ir.Node
+	var v *ir.Name
 	// Note: LongString is close to the type equality we want,
 	// but not exactly. We still need to double-check with types.Identical.
 	key := t.LongString()
@@ -415,7 +415,7 @@ func (o *Order) edge() {
 // orderBlock orders the block of statements in n into a new slice,
 // and then replaces the old slice in n with the new slice.
 // free is a map that can be used to obtain temporary variables by type.
-func orderBlock(n *ir.Nodes, free map[string][]ir.Node) {
+func orderBlock(n *ir.Nodes, free map[string][]*ir.Name) {
 	var order Order
 	order.free = free
 	mark := order.markTemp()
@@ -446,7 +446,7 @@ func (o *Order) exprInPlace(n ir.Node) ir.Node {
 // The result of orderStmtInPlace MUST be assigned back to n, e.g.
 // 	n.Left = orderStmtInPlace(n.Left)
 // free is a map that can be used to obtain temporary variables by type.
-func orderStmtInPlace(n ir.Node, free map[string][]ir.Node) ir.Node {
+func orderStmtInPlace(n ir.Node, free map[string][]*ir.Name) ir.Node {
 	var order Order
 	order.free = free
 	mark := order.markTemp()
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 20abbfef8c..c446c9d083 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -579,7 +579,7 @@ func fixedlit(ctxt initContext, kind initKind, n ir.Node, var_ ir.Node, init *ir
 		case initKindStatic:
 			genAsStatic(a)
 		case initKindDynamic, initKindLocalCode:
-			a = orderStmtInPlace(a, map[string][]ir.Node{})
+			a = orderStmtInPlace(a, map[string][]*ir.Name{})
 			a = walkstmt(a)
 			init.Append(a)
 		default:
@@ -747,7 +747,7 @@ func slicelit(ctxt initContext, n ir.Node, var_ ir.Node, init *ir.Nodes) {
 		a = ir.Nod(ir.OAS, a, value)
 
 		a = typecheck(a, ctxStmt)
-		a = orderStmtInPlace(a, map[string][]ir.Node{})
+		a = orderStmtInPlace(a, map[string][]*ir.Name{})
 		a = walkstmt(a)
 		init.Append(a)
 	}
@@ -756,7 +756,7 @@ func slicelit(ctxt initContext, n ir.Node, var_ ir.Node, init *ir.Nodes) {
 	a = ir.Nod(ir.OAS, var_, ir.Nod(ir.OSLICE, vauto, nil))
 
 	a = typecheck(a, ctxStmt)
-	a = orderStmtInPlace(a, map[string][]ir.Node{})
+	a = orderStmtInPlace(a, map[string][]*ir.Name{})
 	a = walkstmt(a)
 	init.Append(a)
 }
-- 
GitLab


From 02820d61a9d0027140e6da567323e0822d513358 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 3 Dec 2020 18:15:50 -0800
Subject: [PATCH 0160/2400] [dev.typeparams] test: enable some more errorcheck
 tests

Change-Id: I103e3eeacd5b11efd63c965482a626878ba5ac81
Reviewed-on: https://go-review.googlesource.com/c/go/+/275216
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 test/copy1.go                |  8 ++--
 test/fixedbugs/issue10975.go |  2 +-
 test/fixedbugs/issue11361.go |  4 +-
 test/fixedbugs/issue11371.go | 12 +++---
 test/fixedbugs/issue8385.go  |  8 ++--
 test/fixedbugs/issue8438.go  |  6 +--
 test/fixedbugs/issue8440.go  |  2 +-
 test/fixedbugs/issue8745.go  |  2 +-
 test/fixedbugs/issue9083.go  |  1 +
 test/fixedbugs/issue9370.go  | 12 +++---
 test/fixedbugs/issue9432.go  |  2 +-
 test/fixedbugs/issue9521.go  |  4 +-
 test/fixedbugs/issue9634.go  |  2 +-
 test/func1.go                |  2 +-
 test/funcdup.go              | 24 +++++------
 test/funcdup2.go             | 12 +++---
 test/init.go                 |  2 +-
 test/initloop.go             |  2 +-
 test/makenew.go              |  8 ++--
 test/map1.go                 |  6 +--
 test/method2.go              |  6 +--
 test/method6.go              |  2 +-
 test/named1.go               |  2 +-
 test/rename1.go              |  2 +-
 test/run.go                  | 77 ++++++++++++------------------------
 test/runtime.go              |  2 +-
 test/typecheckloop.go        |  4 +-
 test/typeswitch3.go          |  6 +--
 test/varerr.go               |  2 +-
 29 files changed, 100 insertions(+), 124 deletions(-)

diff --git a/test/copy1.go b/test/copy1.go
index e1fa105584..c0760f7190 100644
--- a/test/copy1.go
+++ b/test/copy1.go
@@ -17,11 +17,11 @@ func main() {
 	_ = copy()        // ERROR "not enough arguments"
 	_ = copy(1, 2, 3) // ERROR "too many arguments"
 
-	_ = copy(si, "hi") // ERROR "have different element types.*int.*string"
+	_ = copy(si, "hi") // ERROR "have different element types(.*int.*string| int and byte)"
 	_ = copy(si, sf)   // ERROR "have different element types.*int.*float64"
 
-	_ = copy(1, 2)  // ERROR "must be slices; have int, int"
-	_ = copy(1, si) // ERROR "first argument to copy should be"
-	_ = copy(si, 2) // ERROR "second argument to copy should be"
+	_ = copy(1, 2)  // ERROR "must be slices; have int, int|expects slice arguments"
+	_ = copy(1, si) // ERROR "first argument to copy should be|expects slice arguments"
+	_ = copy(si, 2) // ERROR "second argument to copy should be|expects slice arguments"
 
 }
diff --git a/test/fixedbugs/issue10975.go b/test/fixedbugs/issue10975.go
index b5f043f0a7..415b71b945 100644
--- a/test/fixedbugs/issue10975.go
+++ b/test/fixedbugs/issue10975.go
@@ -10,7 +10,7 @@
 package main
 
 type I interface {
-	int // ERROR "interface contains embedded non-interface int"
+	int // ERROR "interface contains embedded non-interface int|not an interface"
 }
 
 func New() I {
diff --git a/test/fixedbugs/issue11361.go b/test/fixedbugs/issue11361.go
index 1260ea89c9..2544adb55b 100644
--- a/test/fixedbugs/issue11361.go
+++ b/test/fixedbugs/issue11361.go
@@ -6,6 +6,6 @@
 
 package a
 
-import "fmt"  // ERROR "imported and not used"
+import "fmt"  // ERROR "imported and not used|imported but not used"
 
-const n = fmt // ERROR "fmt without selector"
+const n = fmt // ERROR "fmt without selector|not in selector"
diff --git a/test/fixedbugs/issue11371.go b/test/fixedbugs/issue11371.go
index b2d966fac8..c0fc117687 100644
--- a/test/fixedbugs/issue11371.go
+++ b/test/fixedbugs/issue11371.go
@@ -9,9 +9,9 @@
 
 package issue11371
 
-const a int = 1.1        // ERROR "constant 1.1 truncated to integer"
-const b int = 1e20       // ERROR "overflows int"
-const c int = 1 + 1e-100 // ERROR "constant truncated to integer"
-const d int = 1 - 1e-100 // ERROR "constant truncated to integer"
-const e int = 1.00000001 // ERROR "constant truncated to integer"
-const f int = 0.00000001 // ERROR "constant 1e-08 truncated to integer"
+const a int = 1.1        // ERROR "constant 1.1 truncated to integer|truncated to int"
+const b int = 1e20       // ERROR "overflows int|truncated to int"
+const c int = 1 + 1e-100 // ERROR "constant truncated to integer|truncated to int"
+const d int = 1 - 1e-100 // ERROR "constant truncated to integer|truncated to int"
+const e int = 1.00000001 // ERROR "constant truncated to integer|truncated to int"
+const f int = 0.00000001 // ERROR "constant 1e-08 truncated to integer|truncated to int"
diff --git a/test/fixedbugs/issue8385.go b/test/fixedbugs/issue8385.go
index 6447e9f0e8..d8094fe7a7 100644
--- a/test/fixedbugs/issue8385.go
+++ b/test/fixedbugs/issue8385.go
@@ -27,7 +27,7 @@ func (t T) M(x int) {
 func g() func(int)
 
 func main() {
-	Fooer.Foo(5, 6) // ERROR "not enough arguments in call to method expression Fooer.Foo"
+	Fooer.Foo(5, 6) // ERROR "not enough arguments in call to method expression Fooer.Foo|not enough arguments in call"
 
 	var i I
 	var t *T
@@ -35,8 +35,8 @@ func main() {
 	g()()    // ERROR "not enough arguments in call to g\(\)"
 	f()      // ERROR "not enough arguments in call to f"
 	i.M()    // ERROR "not enough arguments in call to i\.M"
-	I.M()    // ERROR "not enough arguments in call to method expression I\.M"
+	I.M()    // ERROR "not enough arguments in call to method expression I\.M|not enough arguments in call"
 	t.M()    // ERROR "not enough arguments in call to t\.M"
-	T.M()    // ERROR "not enough arguments in call to method expression T\.M"
-	(*T).M() // ERROR "not enough arguments in call to method expression \(\*T\)\.M"
+	T.M()    // ERROR "not enough arguments in call to method expression T\.M|not enough arguments in call"
+	(*T).M() // ERROR "not enough arguments in call to method expression \(\*T\)\.M|not enough arguments in call"
 }
diff --git a/test/fixedbugs/issue8438.go b/test/fixedbugs/issue8438.go
index 3a4f193b57..1a223e701f 100644
--- a/test/fixedbugs/issue8438.go
+++ b/test/fixedbugs/issue8438.go
@@ -10,8 +10,8 @@
 package main
 
 func main() {
-	_ = []byte{"foo"}   // ERROR "cannot use"
-	_ = []int{"foo"}    // ERROR "cannot use"
-	_ = []rune{"foo"}   // ERROR "cannot use"
+	_ = []byte{"foo"}   // ERROR "cannot use|cannot convert"
+	_ = []int{"foo"}    // ERROR "cannot use|cannot convert"
+	_ = []rune{"foo"}   // ERROR "cannot use|cannot convert"
 	_ = []string{"foo"} // OK
 }
diff --git a/test/fixedbugs/issue8440.go b/test/fixedbugs/issue8440.go
index f9b1dea3eb..da482b4483 100644
--- a/test/fixedbugs/issue8440.go
+++ b/test/fixedbugs/issue8440.go
@@ -7,5 +7,5 @@
 package main
 
 func main() {
-	n.foo = 6 // ERROR "undefined: n in n.foo"
+	n.foo = 6 // ERROR "undefined: n in n.foo|undefined: n"
 }
diff --git a/test/fixedbugs/issue8745.go b/test/fixedbugs/issue8745.go
index fee2ca7ce0..c2d00a7ebd 100644
--- a/test/fixedbugs/issue8745.go
+++ b/test/fixedbugs/issue8745.go
@@ -9,5 +9,5 @@
 package p
 
 func f(s string) {
-	var _ float64 = s[2] // ERROR "cannot use.*type byte.*as type float64"
+	var _ float64 = s[2] // ERROR "cannot use.*type byte.*as type float64|cannot use .* as float64 value"
 }
diff --git a/test/fixedbugs/issue9083.go b/test/fixedbugs/issue9083.go
index 8fbd78be7a..f7e6388de8 100644
--- a/test/fixedbugs/issue9083.go
+++ b/test/fixedbugs/issue9083.go
@@ -13,6 +13,7 @@ const zero = 0
 
 func main() {
 	var x int
+	_ = x
 	x = make(map[int]int) // ERROR "cannot use make\(map\[int\]int\)|incompatible"
 	x = make(map[int]int, 0) // ERROR "cannot use make\(map\[int\]int, 0\)|incompatible"
 	x = make(map[int]int, zero) // ERROR "cannot use make\(map\[int\]int, zero\)|incompatible"
diff --git a/test/fixedbugs/issue9370.go b/test/fixedbugs/issue9370.go
index 120af35397..4724b6e2d9 100644
--- a/test/fixedbugs/issue9370.go
+++ b/test/fixedbugs/issue9370.go
@@ -67,12 +67,12 @@ var (
 	_ = 1 != e
 	_ = 1 >= e // ERROR "invalid operation.*not defined"
 
-	_ = i == 1 // ERROR "invalid operation.*mismatched types"
-	_ = i != 1 // ERROR "invalid operation.*mismatched types"
-	_ = i >= 1 // ERROR "invalid operation.*mismatched types"
-	_ = 1 == i // ERROR "invalid operation.*mismatched types"
-	_ = 1 != i // ERROR "invalid operation.*mismatched types"
-	_ = 1 >= i // ERROR "invalid operation.*mismatched types"
+	_ = i == 1 // ERROR "invalid operation.*mismatched types|cannot convert"
+	_ = i != 1 // ERROR "invalid operation.*mismatched types|cannot convert"
+	_ = i >= 1 // ERROR "invalid operation.*mismatched types|cannot convert"
+	_ = 1 == i // ERROR "invalid operation.*mismatched types|cannot convert"
+	_ = 1 != i // ERROR "invalid operation.*mismatched types|cannot convert"
+	_ = 1 >= i // ERROR "invalid operation.*mismatched types|cannot convert"
 
 	_ = e == f // ERROR "invalid operation.*not defined"
 	_ = e != f // ERROR "invalid operation.*not defined"
diff --git a/test/fixedbugs/issue9432.go b/test/fixedbugs/issue9432.go
index e8946a5be2..3df3b9097b 100644
--- a/test/fixedbugs/issue9432.go
+++ b/test/fixedbugs/issue9432.go
@@ -9,7 +9,7 @@
 // See golang.org/issue/9432.
 package p
 
-type foo struct { // ERROR "invalid recursive type"
+type foo struct { // ERROR "invalid recursive type|cycle"
 	bar  foo
 	blah foo
 }
diff --git a/test/fixedbugs/issue9521.go b/test/fixedbugs/issue9521.go
index a33f0483f3..7cb1ef1f8e 100644
--- a/test/fixedbugs/issue9521.go
+++ b/test/fixedbugs/issue9521.go
@@ -13,6 +13,6 @@ func f() (_, _ []int)         { return }
 func g() (x []int, y float64) { return }
 
 func main() {
-	_ = append(f()) // ERROR "cannot use \[\]int value as type int in append"
-	_ = append(g()) // ERROR "cannot use float64 value as type int in append"
+	_ = append(f()) // ERROR "cannot use \[\]int value as type int in append|cannot use .* as int value"
+	_ = append(g()) // ERROR "cannot use float64 value as type int in append|cannot use .* as int value"
 }
diff --git a/test/fixedbugs/issue9634.go b/test/fixedbugs/issue9634.go
index 2d5aae4a30..86e3e9a2df 100644
--- a/test/fixedbugs/issue9634.go
+++ b/test/fixedbugs/issue9634.go
@@ -14,5 +14,5 @@ func main() {
 		t []int
 		u int
 	}{}
-	_ = append(s, 0) // ERROR "must be a slice|must be slice"
+	_ = append(s, 0) // ERROR "must be a slice|must be slice|not a slice"
 }
diff --git a/test/func1.go b/test/func1.go
index fb6f56184f..ec25161d13 100644
--- a/test/func1.go
+++ b/test/func1.go
@@ -14,6 +14,6 @@ func f1(a int) (int, float32) {
 }
 
 
-func f2(a int) (a int, b float32) { // ERROR "duplicate argument a|definition"
+func f2(a int) (a int, b float32) { // ERROR "duplicate argument a|definition|redeclared"
 	return 8, 8.0
 }
diff --git a/test/funcdup.go b/test/funcdup.go
index 7b05d12606..3dbb15b0d4 100644
--- a/test/funcdup.go
+++ b/test/funcdup.go
@@ -7,21 +7,21 @@
 package p
 
 type T interface {
-	F1(i int) (i int) // ERROR "duplicate argument i|redefinition|previous"
-	F2(i, i int) // ERROR "duplicate argument i|redefinition|previous"
-	F3() (i, i int) // ERROR "duplicate argument i|redefinition|previous"
+	F1(i int) (i int) // ERROR "duplicate argument i|redefinition|previous|redeclared"
+	F2(i, i int) // ERROR "duplicate argument i|redefinition|previous|redeclared"
+	F3() (i, i int) // ERROR "duplicate argument i|redefinition|previous|redeclared"
 }
 
-type T1 func(i, i int) // ERROR "duplicate argument i|redefinition|previous"
-type T2 func(i int) (i int) // ERROR "duplicate argument i|redefinition|previous"
-type T3 func() (i, i int) // ERROR "duplicate argument i|redefinition|previous"
+type T1 func(i, i int) // ERROR "duplicate argument i|redefinition|previous|redeclared"
+type T2 func(i int) (i int) // ERROR "duplicate argument i|redefinition|previous|redeclared"
+type T3 func() (i, i int) // ERROR "duplicate argument i|redefinition|previous|redeclared"
 
 type R struct{}
 
-func (i *R) F1(i int)         {} // ERROR "duplicate argument i|redefinition|previous"
-func (i *R) F2() (i int)      {return 0} // ERROR "duplicate argument i|redefinition|previous"
-func (i *R) F3(j int) (j int) {return 0} // ERROR "duplicate argument j|redefinition|previous"
+func (i *R) F1(i int)         {} // ERROR "duplicate argument i|redefinition|previous|redeclared"
+func (i *R) F2() (i int)      {return 0} // ERROR "duplicate argument i|redefinition|previous|redeclared"
+func (i *R) F3(j int) (j int) {return 0} // ERROR "duplicate argument j|redefinition|previous|redeclared"
 
-func F1(i, i int)      {} // ERROR "duplicate argument i|redefinition|previous"
-func F2(i int) (i int) {return 0} // ERROR "duplicate argument i|redefinition|previous"
-func F3() (i, i int)   {return 0, 0} // ERROR "duplicate argument i|redefinition|previous"
+func F1(i, i int)      {} // ERROR "duplicate argument i|redefinition|previous|redeclared"
+func F2(i int) (i int) {return 0} // ERROR "duplicate argument i|redefinition|previous|redeclared"
+func F3() (i, i int)   {return 0, 0} // ERROR "duplicate argument i|redefinition|previous|redeclared"
diff --git a/test/funcdup2.go b/test/funcdup2.go
index 9513ef46bd..2ee3024e5c 100644
--- a/test/funcdup2.go
+++ b/test/funcdup2.go
@@ -7,11 +7,11 @@
 package p
 
 var T interface {
-	F1(i int) (i int) // ERROR "duplicate argument i|redefinition|previous"
-	F2(i, i int) // ERROR "duplicate argument i|redefinition|previous"
-	F3() (i, i int) // ERROR "duplicate argument i|redefinition|previous"
+	F1(i int) (i int) // ERROR "duplicate argument i|redefinition|previous|redeclared"
+	F2(i, i int) // ERROR "duplicate argument i|redefinition|previous|redeclared"
+	F3() (i, i int) // ERROR "duplicate argument i|redefinition|previous|redeclared"
 }
 
-var T1 func(i, i int) // ERROR "duplicate argument i|redefinition|previous"
-var T2 func(i int) (i int) // ERROR "duplicate argument i|redefinition|previous"
-var T3 func() (i, i int) // ERROR "duplicate argument i|redefinition|previous"
+var T1 func(i, i int) // ERROR "duplicate argument i|redefinition|previous|redeclared"
+var T2 func(i int) (i int) // ERROR "duplicate argument i|redefinition|previous|redeclared"
+var T3 func() (i, i int) // ERROR "duplicate argument i|redefinition|previous|redeclared"
diff --git a/test/init.go b/test/init.go
index 317f2472cb..c2c25c7860 100644
--- a/test/init.go
+++ b/test/init.go
@@ -14,6 +14,6 @@ func init() {
 
 func main() {
 	init()         // ERROR "undefined.*init"
-	runtime.init() // ERROR "undefined.*runtime\.init"
+	runtime.init() // ERROR "undefined.*runtime\.init|undefined: runtime"
 	var _ = init   // ERROR "undefined.*init"
 }
diff --git a/test/initloop.go b/test/initloop.go
index d90395d753..ca652f86f4 100644
--- a/test/initloop.go
+++ b/test/initloop.go
@@ -11,7 +11,7 @@ package main
 
 var (
 	x int = a
-	a int = b // ERROR "a refers to\n.*b refers to\n.*c refers to\n.*a"
+	a int = b // ERROR "a refers to\n.*b refers to\n.*c refers to\n.*a|initialization cycle"
 	b int = c
 	c int = a
 )
diff --git a/test/makenew.go b/test/makenew.go
index 058d975898..14854dcf0c 100644
--- a/test/makenew.go
+++ b/test/makenew.go
@@ -10,10 +10,10 @@
 package main
 
 func main() {
-	_ = make()      // ERROR "missing argument"
-	_ = make(int)   // ERROR "cannot make type"
-	_ = make([]int) // ERROR "missing len argument"
+	_ = make()      // ERROR "missing argument|not enough arguments"
+	_ = make(int)   // ERROR "cannot make type|cannot make int"
+	_ = make([]int) // ERROR "missing len argument|expects 2 or 3 arguments"
 
-	_ = new()       // ERROR "missing argument"
+	_ = new()       // ERROR "missing argument|not enough arguments"
 	_ = new(int, 2) // ERROR "too many arguments"
 }
diff --git a/test/map1.go b/test/map1.go
index 498c2ec45b..bd4d87b871 100644
--- a/test/map1.go
+++ b/test/map1.go
@@ -61,8 +61,8 @@ type T8 struct { F *T7 }
 
 func main() {
 	m := make(map[int]int)
-	delete()        // ERROR "missing arguments"
-	delete(m)       // ERROR "missing second \(key\) argument"
+	delete()        // ERROR "missing arguments|not enough arguments"
+	delete(m)       // ERROR "missing second \(key\) argument|not enough arguments"
 	delete(m, 2, 3) // ERROR "too many arguments"
-	delete(1, m)    // ERROR "first argument to delete must be map"
+	delete(1, m)    // ERROR "first argument to delete must be map|is not a map"
 }
\ No newline at end of file
diff --git a/test/method2.go b/test/method2.go
index a45a943156..790062c2af 100644
--- a/test/method2.go
+++ b/test/method2.go
@@ -15,8 +15,8 @@ type T struct {
 type P *T
 type P1 *T
 
-func (p P) val() int   { return 1 } // ERROR "receiver.* pointer|invalid pointer or interface receiver"
-func (p *P1) val() int { return 1 } // ERROR "receiver.* pointer|invalid pointer or interface receiver"
+func (p P) val() int   { return 1 } // ERROR "receiver.* pointer|invalid pointer or interface receiver|invalid receiver"
+func (p *P1) val() int { return 1 } // ERROR "receiver.* pointer|invalid pointer or interface receiver|invalid receiver"
 
 type I interface{}
 type I1 interface{}
@@ -38,4 +38,4 @@ var _ = pv.val   // ERROR "pv.val undefined"
 
 func (t *T) g() int { return t.a }
 
-var _ = (T).g() // ERROR "needs pointer receiver|undefined"
+var _ = (T).g() // ERROR "needs pointer receiver|undefined|cannot call pointer method"
diff --git a/test/method6.go b/test/method6.go
index 20eccce413..ede3467c5c 100644
--- a/test/method6.go
+++ b/test/method6.go
@@ -18,5 +18,5 @@ func (*B) g() {}
 
 var _ = func() {
 	var a A
-	A(a).g() // ERROR "cannot call pointer method on|cannot take the address of"
+	A(a).g() // ERROR "cannot call pointer method .*on|cannot take the address of"
 }
diff --git a/test/named1.go b/test/named1.go
index 7feae13b9d..452c6da27e 100644
--- a/test/named1.go
+++ b/test/named1.go
@@ -54,7 +54,7 @@ func main() {
 	_ = b
 
 	_, bb := <-c
-	asBool(bb) // ERROR "cannot use.*type bool.*as type Bool"
+	asBool(bb) // ERROR "cannot use.*type bool.*as type Bool|cannot use bb"
 	_, b = <-c // ok now
 	_ = b
 
diff --git a/test/rename1.go b/test/rename1.go
index c49a70a263..058db4494a 100644
--- a/test/rename1.go
+++ b/test/rename1.go
@@ -13,7 +13,7 @@ func main() {
 	var n byte         // ERROR "not a type|expected type"
 	var y = float32(0) // ERROR "cannot call|expected function"
 	const (
-		a = 1 + iota // ERROR "invalid operation|incompatible types"
+		a = 1 + iota // ERROR "invalid operation|incompatible types|cannot convert"
 	)
 
 }
diff --git a/test/run.go b/test/run.go
index 0a69fa62bc..0ffb2c1a3d 100644
--- a/test/run.go
+++ b/test/run.go
@@ -740,6 +740,9 @@ func (t *test) run() {
 			t.updateErrors(string(out), long)
 		}
 		t.err = t.errorCheck(string(out), wantAuto, long, t.gofile)
+		if t.err != nil {
+			return // don't hide error if run below succeeds
+		}
 
 		// The following is temporary scaffolding to get types2 typechecker
 		// up and running against the existing test cases. The explicitly
@@ -765,6 +768,7 @@ func (t *test) run() {
 		for _, flag := range flags {
 			for _, pattern := range []string{
 				"-+",
+				"-0",
 				"-m",
 				"-live",
 				"wb",
@@ -773,6 +777,7 @@ func (t *test) run() {
 				"typeassert",
 				"ssa/check_bce/debug",
 				"ssa/intrinsics/debug",
+				"ssa/opt/debug",
 				"ssa/prove/debug",
 				"ssa/likelyadjust/debug",
 				"ssa/insert_resched_checks/off",
@@ -1916,44 +1921,26 @@ func overlayDir(dstRoot, srcRoot string) error {
 // List of files that the compiler cannot errorcheck with the new typechecker (compiler -G option).
 // Temporary scaffolding until we pass all the tests at which point this map can be removed.
 var excluded = map[string]bool{
-	"complit1.go":      true,
-	"const2.go":        true,
-	"convlit.go":       true,
-	"copy1.go":         true,
-	"ddd1.go":          true,
-	"devirt.go":        true,
-	"directive.go":     true,
-	"float_lit3.go":    true,
-	"func1.go":         true,
-	"funcdup.go":       true,
-	"funcdup2.go":      true,
-	"import1.go":       true,
-	"import5.go":       true,
-	"import6.go":       true,
-	"init.go":          true,
-	"initializerr.go":  true,
-	"initloop.go":      true,
-	"makechan.go":      true,
-	"makemap.go":       true,
-	"makenew.go":       true,
-	"map1.go":          true,
-	"method2.go":       true,
-	"method6.go":       true,
-	"named1.go":        true,
-	"rename1.go":       true,
-	"runtime.go":       true,
-	"shift1.go":        true,
-	"slice3err.go":     true,
-	"switch3.go":       true,
-	"switch4.go":       true,
-	"switch5.go":       true,
-	"switch6.go":       true,
-	"switch7.go":       true,
-	"typecheck.go":     true,
-	"typecheckloop.go": true,
-	"typeswitch3.go":   true,
-	"undef.go":         true,
-	"varerr.go":        true,
+	"complit1.go":     true,
+	"const2.go":       true,
+	"convlit.go":      true,
+	"ddd1.go":         true, // issue #42987
+	"directive.go":    true, // misplaced compiler directive checks
+	"float_lit3.go":   true,
+	"import1.go":      true,
+	"import5.go":      true, // issue #42988
+	"import6.go":      true,
+	"initializerr.go": true,
+	"makechan.go":     true,
+	"makemap.go":      true,
+	"shift1.go":       true, // issue #42989
+	"slice3err.go":    true,
+	"switch3.go":      true,
+	"switch4.go":      true,
+	"switch5.go":      true,
+	"switch6.go":      true,
+	"switch7.go":      true,
+	"typecheck.go":    true, // invalid function is not causing errors when called
 
 	"fixedbugs/bug163.go":      true,
 	"fixedbugs/bug176.go":      true,
@@ -1994,11 +1981,8 @@ var excluded = map[string]bool{
 	"fixedbugs/bug462.go":      true,
 	"fixedbugs/bug463.go":      true,
 	"fixedbugs/bug487.go":      true,
-	"fixedbugs/issue10975.go":  true,
 	"fixedbugs/issue11326.go":  true,
-	"fixedbugs/issue11361.go":  true,
 	"fixedbugs/issue11362.go":  true,
-	"fixedbugs/issue11371.go":  true,
 	"fixedbugs/issue11590.go":  true,
 	"fixedbugs/issue11610.go":  true,
 	"fixedbugs/issue11614.go":  true,
@@ -2148,14 +2132,5 @@ var excluded = map[string]bool{
 	"fixedbugs/issue7746.go":   true, // type-checking doesn't terminate
 	"fixedbugs/issue8501.go":   true, // crashes
 	"fixedbugs/issue8507.go":   true, // crashes
-	"fixedbugs/issue8183.go":   true,
-	"fixedbugs/issue8385.go":   true,
-	"fixedbugs/issue8438.go":   true,
-	"fixedbugs/issue8440.go":   true,
-	"fixedbugs/issue8745.go":   true,
-	"fixedbugs/issue9083.go":   true,
-	"fixedbugs/issue9370.go":   true,
-	"fixedbugs/issue9432.go":   true,
-	"fixedbugs/issue9521.go":   true,
-	"fixedbugs/issue9634.go":   true,
+	"fixedbugs/issue8183.go":   true, // issue #42992
 }
diff --git a/test/runtime.go b/test/runtime.go
index bccc9b53af..a833129dd6 100644
--- a/test/runtime.go
+++ b/test/runtime.go
@@ -17,5 +17,5 @@ package main
 import "runtime"
 
 func main() {
-	runtime.printbool(true)	// ERROR "unexported"
+	runtime.printbool(true)	// ERROR "unexported|not declared"
 }
diff --git a/test/typecheckloop.go b/test/typecheckloop.go
index 3b3e78858e..a143e0984c 100644
--- a/test/typecheckloop.go
+++ b/test/typecheckloop.go
@@ -9,6 +9,6 @@
 
 package main
 
-const A = 1 + B // ERROR "constant definition loop\n.*A uses B\n.*B uses C\n.*C uses A"
-const B = C - 1 // ERROR "constant definition loop\n.*B uses C\n.*C uses B"
+const A = 1 + B // ERROR "constant definition loop\n.*A uses B\n.*B uses C\n.*C uses A|initialization cycle"
+const B = C - 1 // ERROR "constant definition loop\n.*B uses C\n.*C uses B|initialization cycle"
 const C = A + B + 1
diff --git a/test/typeswitch3.go b/test/typeswitch3.go
index 1388187566..a57889bc1d 100644
--- a/test/typeswitch3.go
+++ b/test/typeswitch3.go
@@ -36,13 +36,13 @@ func main() {
 	}
 
 	// Issue 2827.
-	switch _ := r.(type) { // ERROR "invalid variable name _|no new variables"
+	switch _ := r.(type) { // ERROR "invalid variable name _|no new variables?"
 	}
 }
 
 func noninterface() {
 	var i int
-	switch i.(type) { // ERROR "cannot type switch on non-interface value"
+	switch i.(type) { // ERROR "cannot type switch on non-interface value|not an interface type"
 	case string:
 	case int:
 	}
@@ -51,6 +51,6 @@ func noninterface() {
 		name string
 	}
 	var s S
-	switch s.(type) { // ERROR "cannot type switch on non-interface value"
+	switch s.(type) { // ERROR "cannot type switch on non-interface value|not an interface type"
 	}
 }
diff --git a/test/varerr.go b/test/varerr.go
index 82ab814197..349cc8b4e3 100644
--- a/test/varerr.go
+++ b/test/varerr.go
@@ -12,6 +12,6 @@ package main
 func main() {
 	_ = asdf	// ERROR "undefined.*asdf"
 
-	new = 1	// ERROR "use of builtin new not in function call|invalid left hand side"
+	new = 1	// ERROR "use of builtin new not in function call|invalid left hand side|must be called"
 }
 
-- 
GitLab


From 6c5967e528f1efc9dfed107c33dccf2d305f2a25 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 5 Dec 2020 15:49:03 -0800
Subject: [PATCH 0161/2400] [dev.regabi] cmd/compile: change NodeSet to NameSet

The only user of NodeSet (computing initialization dependencies) only
needs to store *Names in this structure. So change its definition to
match that need, and update the code in initorder.go accordingly.

Passes buildall w/ toolstash -cmp.

Updates #42982.

Change-Id: I181a8aaf9bc71e88f4ac009c4f381a718080e48f
Reviewed-on: https://go-review.googlesource.com/c/go/+/275752
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/gc/initorder.go | 22 +++++++++++-----------
 src/cmd/compile/internal/ir/node.go      | 14 +++++++-------
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/src/cmd/compile/internal/gc/initorder.go b/src/cmd/compile/internal/gc/initorder.go
index 87a78ae053..7f1f3cba92 100644
--- a/src/cmd/compile/internal/gc/initorder.go
+++ b/src/cmd/compile/internal/gc/initorder.go
@@ -110,7 +110,7 @@ func initOrder(l []ir.Node) []ir.Node {
 				// first.
 				base.ExitIfErrors()
 
-				findInitLoopAndExit(firstLHS(n), new([]ir.Node))
+				findInitLoopAndExit(firstLHS(n), new([]*ir.Name))
 				base.Fatalf("initialization unfinished, but failed to identify loop")
 			}
 		}
@@ -136,7 +136,7 @@ func (o *InitOrder) processAssign(n ir.Node) {
 	// Compute number of variable dependencies and build the
 	// inverse dependency ("blocking") graph.
 	for dep := range collectDeps(n, true) {
-		defn := dep.Name().Defn
+		defn := dep.Defn
 		// Skip dependencies on functions (PFUNC) and
 		// variables already initialized (InitDone).
 		if dep.Class() != ir.PEXTERN || defn.Initorder() == InitDone {
@@ -183,7 +183,7 @@ func (o *InitOrder) flushReady(initialize func(ir.Node)) {
 // path points to a slice used for tracking the sequence of
 // variables/functions visited. Using a pointer to a slice allows the
 // slice capacity to grow and limit reallocations.
-func findInitLoopAndExit(n ir.Node, path *[]ir.Node) {
+func findInitLoopAndExit(n *ir.Name, path *[]*ir.Name) {
 	// We implement a simple DFS loop-finding algorithm. This
 	// could be faster, but initialization cycles are rare.
 
@@ -196,14 +196,14 @@ func findInitLoopAndExit(n ir.Node, path *[]ir.Node) {
 
 	// There might be multiple loops involving n; by sorting
 	// references, we deterministically pick the one reported.
-	refers := collectDeps(n.Name().Defn, false).Sorted(func(ni, nj ir.Node) bool {
+	refers := collectDeps(n.Name().Defn, false).Sorted(func(ni, nj *ir.Name) bool {
 		return ni.Pos().Before(nj.Pos())
 	})
 
 	*path = append(*path, n)
 	for _, ref := range refers {
 		// Short-circuit variables that were initialized.
-		if ref.Class() == ir.PEXTERN && ref.Name().Defn.Initorder() == InitDone {
+		if ref.Class() == ir.PEXTERN && ref.Defn.Initorder() == InitDone {
 			continue
 		}
 
@@ -215,7 +215,7 @@ func findInitLoopAndExit(n ir.Node, path *[]ir.Node) {
 // reportInitLoopAndExit reports and initialization loop as an error
 // and exits. However, if l is not actually an initialization loop, it
 // simply returns instead.
-func reportInitLoopAndExit(l []ir.Node) {
+func reportInitLoopAndExit(l []*ir.Name) {
 	// Rotate loop so that the earliest variable declaration is at
 	// the start.
 	i := -1
@@ -250,7 +250,7 @@ func reportInitLoopAndExit(l []ir.Node) {
 // variables that declaration n depends on. If transitive is true,
 // then it also includes the transitive dependencies of any depended
 // upon functions (but not variables).
-func collectDeps(n ir.Node, transitive bool) ir.NodeSet {
+func collectDeps(n ir.Node, transitive bool) ir.NameSet {
 	d := initDeps{transitive: transitive}
 	switch n.Op() {
 	case ir.OAS:
@@ -267,7 +267,7 @@ func collectDeps(n ir.Node, transitive bool) ir.NodeSet {
 
 type initDeps struct {
 	transitive bool
-	seen       ir.NodeSet
+	seen       ir.NameSet
 }
 
 func (d *initDeps) inspect(n ir.Node)      { ir.Inspect(n, d.visit) }
@@ -345,12 +345,12 @@ func (s *declOrder) Pop() interface{} {
 
 // firstLHS returns the first expression on the left-hand side of
 // assignment n.
-func firstLHS(n ir.Node) ir.Node {
+func firstLHS(n ir.Node) *ir.Name {
 	switch n.Op() {
 	case ir.OAS:
-		return n.Left()
+		return n.Left().Name()
 	case ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2RECV, ir.OAS2MAPR:
-		return n.List().First()
+		return n.List().First().Name()
 	}
 
 	base.Fatalf("unexpected Op: %v", n.Op())
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index f44d22313c..a0ee8aa0fe 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -585,26 +585,26 @@ func (q *NodeQueue) PopLeft() Node {
 	return n
 }
 
-// NodeSet is a set of Nodes.
-type NodeSet map[Node]struct{}
+// NameSet is a set of Names.
+type NameSet map[*Name]struct{}
 
 // Has reports whether s contains n.
-func (s NodeSet) Has(n Node) bool {
+func (s NameSet) Has(n *Name) bool {
 	_, isPresent := s[n]
 	return isPresent
 }
 
 // Add adds n to s.
-func (s *NodeSet) Add(n Node) {
+func (s *NameSet) Add(n *Name) {
 	if *s == nil {
-		*s = make(map[Node]struct{})
+		*s = make(map[*Name]struct{})
 	}
 	(*s)[n] = struct{}{}
 }
 
 // Sorted returns s sorted according to less.
-func (s NodeSet) Sorted(less func(Node, Node) bool) []Node {
-	var res []Node
+func (s NameSet) Sorted(less func(*Name, *Name) bool) []*Name {
+	var res []*Name
 	for n := range s {
 		res = append(res, n)
 	}
-- 
GitLab


From 1b5eed89828f41e290ae212c596ff301c5db7204 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 6 Dec 2020 12:29:42 -0800
Subject: [PATCH 0162/2400] [dev.regabi] cmd/compile: replace NodeQueue with
 NameQueue

Similar to the previous CL, the only two users of NodeQueue only
needed it for tracking objects, not arbitrary AST nodes. So change
it's signature to use *Name instead of Node.

This does require a tweak to the nowritebarrierrec checker, because
previously it was pushing the ODCLFUNC *Func pointers into the queue,
whereas now we push the ONAME/PFUNC *Name pointers instead. However,
it's trivial and safe to flip between them.

Also, this changes a handful of export-related code from Node to
*Name, to avoid introducing type assertions within iexport.go.

Passes buildall w/ toolstash -cmp.

Updates #42982.

Change-Id: I867f9752121509fc3da753978c6a41d5015bc0ce
Reviewed-on: https://go-review.googlesource.com/c/go/+/275753
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/gc/dcl.go     |  8 ++++----
 src/cmd/compile/internal/gc/export.go  |  4 ++--
 src/cmd/compile/internal/gc/go.go      |  2 +-
 src/cmd/compile/internal/gc/iexport.go |  6 +++---
 src/cmd/compile/internal/ir/node.go    | 22 +++++++++++-----------
 5 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index ce13f0bdfc..56f8d1b9bf 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -931,7 +931,7 @@ func (c *nowritebarrierrecChecker) check() {
 	// acts as the set of marks for the BFS of the call graph.
 	funcs := make(map[ir.Node]nowritebarrierrecCall)
 	// q is the queue of ODCLFUNC Nodes to visit in BFS order.
-	var q ir.NodeQueue
+	var q ir.NameQueue
 
 	for _, n := range xtop {
 		if n.Op() != ir.ODCLFUNC {
@@ -944,7 +944,7 @@ func (c *nowritebarrierrecChecker) check() {
 		// Make nowritebarrierrec functions BFS roots.
 		if fn.Pragma&ir.Nowritebarrierrec != 0 {
 			funcs[fn] = nowritebarrierrecCall{}
-			q.PushRight(fn)
+			q.PushRight(fn.Nname)
 		}
 		// Check go:nowritebarrier functions.
 		if fn.Pragma&ir.Nowritebarrier != 0 && fn.WBPos.IsKnown() {
@@ -966,10 +966,10 @@ func (c *nowritebarrierrecChecker) check() {
 
 		// Record the path.
 		funcs[target] = nowritebarrierrecCall{target: src, lineno: pos}
-		q.PushRight(target)
+		q.PushRight(target.Nname)
 	}
 	for !q.Empty() {
-		fn := q.PopLeft().(*ir.Func)
+		fn := q.PopLeft().Func()
 
 		// Check fn.
 		if fn.WBPos.IsKnown() {
diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index 44fc70be03..b632a15865 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -24,7 +24,7 @@ func exportf(bout *bio.Writer, format string, args ...interface{}) {
 var asmlist []ir.Node
 
 // exportsym marks n for export (or reexport).
-func exportsym(n ir.Node) {
+func exportsym(n *ir.Name) {
 	if n.Sym().OnExportList() {
 		return
 	}
@@ -41,7 +41,7 @@ func initname(s string) bool {
 	return s == "init"
 }
 
-func autoexport(n ir.Node, ctxt ir.Class) {
+func autoexport(n *ir.Name, ctxt ir.Class) {
 	if n.Sym().Pkg != ir.LocalPkg {
 		return
 	}
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index c493165c76..c4b9c185dc 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -130,7 +130,7 @@ var (
 
 var xtop []ir.Node
 
-var exportlist []ir.Node
+var exportlist []*ir.Name
 
 var importlist []*ir.Func // imported functions and methods with inlinable bodies
 
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index bb6f2b11e6..14614d8ab8 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -368,7 +368,7 @@ type iexporter struct {
 	// main index.
 	allPkgs map[*types.Pkg]bool
 
-	declTodo ir.NodeQueue
+	declTodo ir.NameQueue
 
 	strings     intWriter
 	stringIndex map[string]uint64
@@ -394,7 +394,7 @@ func (p *iexporter) stringOff(s string) uint64 {
 }
 
 // pushDecl adds n to the declaration work queue, if not already present.
-func (p *iexporter) pushDecl(n ir.Node) {
+func (p *iexporter) pushDecl(n *ir.Name) {
 	if n.Sym() == nil || n.Sym().Def != n && n.Op() != ir.OTYPE {
 		base.Fatalf("weird Sym: %v, %v", n, n.Sym())
 	}
@@ -573,7 +573,7 @@ func (w *exportWriter) pkg(pkg *types.Pkg) {
 
 func (w *exportWriter) qualifiedIdent(n ir.Node) {
 	// Ensure any referenced declarations are written out too.
-	w.p.pushDecl(n)
+	w.p.pushDecl(n.Name())
 
 	s := n.Sym()
 	w.string(s.Name)
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index a0ee8aa0fe..7fd02925ba 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -539,25 +539,25 @@ func (n Nodes) Copy() Nodes {
 	return c
 }
 
-// nodeQueue is a FIFO queue of *Node. The zero value of nodeQueue is
+// NameQueue is a FIFO queue of *Name. The zero value of NameQueue is
 // a ready-to-use empty queue.
-type NodeQueue struct {
-	ring       []Node
+type NameQueue struct {
+	ring       []*Name
 	head, tail int
 }
 
-// empty reports whether q contains no Nodes.
-func (q *NodeQueue) Empty() bool {
+// Empty reports whether q contains no Names.
+func (q *NameQueue) Empty() bool {
 	return q.head == q.tail
 }
 
-// pushRight appends n to the right of the queue.
-func (q *NodeQueue) PushRight(n Node) {
+// PushRight appends n to the right of the queue.
+func (q *NameQueue) PushRight(n *Name) {
 	if len(q.ring) == 0 {
-		q.ring = make([]Node, 16)
+		q.ring = make([]*Name, 16)
 	} else if q.head+len(q.ring) == q.tail {
 		// Grow the ring.
-		nring := make([]Node, len(q.ring)*2)
+		nring := make([]*Name, len(q.ring)*2)
 		// Copy the old elements.
 		part := q.ring[q.head%len(q.ring):]
 		if q.tail-q.head <= len(part) {
@@ -574,9 +574,9 @@ func (q *NodeQueue) PushRight(n Node) {
 	q.tail++
 }
 
-// popLeft pops a node from the left of the queue. It panics if q is
+// PopLeft pops a Name from the left of the queue. It panics if q is
 // empty.
-func (q *NodeQueue) PopLeft() Node {
+func (q *NameQueue) PopLeft() *Name {
 	if q.Empty() {
 		panic("dequeue empty")
 	}
-- 
GitLab


From 2d4c95565a770227ef2943b68ebe9fac02f79377 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 5 Dec 2020 16:33:59 -0800
Subject: [PATCH 0163/2400] [dev.regabi] cmd/compile: change nowritebarrierrec
 to use map[*ir.Func]

All of the uses were already using *ir.Func index operands, so only
needs the map type itself updated.

Passes buildall w/ toolstash -cmp.

Updates #42982.

Change-Id: I568d8601f3eb077e07e887f2071aa1a2667d803c
Reviewed-on: https://go-review.googlesource.com/c/go/+/275754
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/dcl.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 56f8d1b9bf..5936aeb950 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -838,7 +838,7 @@ type nowritebarrierrecChecker struct {
 	// extraCalls contains extra function calls that may not be
 	// visible during later analysis. It maps from the ODCLFUNC of
 	// the caller to a list of callees.
-	extraCalls map[ir.Node][]nowritebarrierrecCall
+	extraCalls map[*ir.Func][]nowritebarrierrecCall
 
 	// curfn is the current function during AST walks.
 	curfn *ir.Func
@@ -853,7 +853,7 @@ type nowritebarrierrecCall struct {
 // must be called before transformclosure and walk.
 func newNowritebarrierrecChecker() *nowritebarrierrecChecker {
 	c := &nowritebarrierrecChecker{
-		extraCalls: make(map[ir.Node][]nowritebarrierrecCall),
+		extraCalls: make(map[*ir.Func][]nowritebarrierrecCall),
 	}
 
 	// Find all systemstack calls and record their targets. In
@@ -929,7 +929,7 @@ func (c *nowritebarrierrecChecker) check() {
 	// that are directly marked go:nowritebarrierrec are in this
 	// map with a zero-valued nowritebarrierrecCall. This also
 	// acts as the set of marks for the BFS of the call graph.
-	funcs := make(map[ir.Node]nowritebarrierrecCall)
+	funcs := make(map[*ir.Func]nowritebarrierrecCall)
 	// q is the queue of ODCLFUNC Nodes to visit in BFS order.
 	var q ir.NameQueue
 
-- 
GitLab


From e885df2731cb36925c9a9de9cf1a34a167461cd7 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 6 Dec 2020 12:14:46 -0800
Subject: [PATCH 0164/2400] [dev.regabi] cmd/compile: change iexport to avoid
 map[ir.Node]

In the past, we had a lot of trouble with misusing *types.Sym
throughout the frontend, so I tried to push us towards always passing
around ONAMEs instead. But for constructing and writing out the symbol
indexes for the indexed export data, keying by *types.Sym is exactly
what we want.

Passes buildall w/ toolstash -cmp.

Updates #42982.

Change-Id: Idd8f1fb057d75a52a34ebc7788d9332fb49caf8d
Reviewed-on: https://go-review.googlesource.com/c/go/+/275755
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/gc/iexport.go | 62 +++++++++++++-------------
 1 file changed, 32 insertions(+), 30 deletions(-)

diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index 14614d8ab8..003cf3b446 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -259,8 +259,8 @@ func iexport(out *bufio.Writer) {
 	p := iexporter{
 		allPkgs:     map[*types.Pkg]bool{},
 		stringIndex: map[string]uint64{},
-		declIndex:   map[ir.Node]uint64{},
-		inlineIndex: map[ir.Node]uint64{},
+		declIndex:   map[*types.Sym]uint64{},
+		inlineIndex: map[*types.Sym]uint64{},
 		typIndex:    map[*types.Type]uint64{},
 	}
 
@@ -310,37 +310,34 @@ func iexport(out *bufio.Writer) {
 	out.Write(base.Ctxt.Fingerprint[:])
 }
 
-// writeIndex writes out an object index. mainIndex indicates whether
+// writeIndex writes out a symbol index. mainIndex indicates whether
 // we're writing out the main index, which is also read by
 // non-compiler tools and includes a complete package description
 // (i.e., name and height).
-func (w *exportWriter) writeIndex(index map[ir.Node]uint64, mainIndex bool) {
-	// Build a map from packages to objects from that package.
-	pkgObjs := map[*types.Pkg][]ir.Node{}
+func (w *exportWriter) writeIndex(index map[*types.Sym]uint64, mainIndex bool) {
+	// Build a map from packages to symbols from that package.
+	pkgSyms := map[*types.Pkg][]*types.Sym{}
 
 	// For the main index, make sure to include every package that
 	// we reference, even if we're not exporting (or reexporting)
 	// any symbols from it.
 	if mainIndex {
-		pkgObjs[ir.LocalPkg] = nil
+		pkgSyms[ir.LocalPkg] = nil
 		for pkg := range w.p.allPkgs {
-			pkgObjs[pkg] = nil
+			pkgSyms[pkg] = nil
 		}
 	}
 
-	for n := range index {
-		pkgObjs[n.Sym().Pkg] = append(pkgObjs[n.Sym().Pkg], n)
+	// Group symbols by package.
+	for sym := range index {
+		pkgSyms[sym.Pkg] = append(pkgSyms[sym.Pkg], sym)
 	}
 
+	// Sort packages by path.
 	var pkgs []*types.Pkg
-	for pkg, objs := range pkgObjs {
+	for pkg := range pkgSyms {
 		pkgs = append(pkgs, pkg)
-
-		sort.Slice(objs, func(i, j int) bool {
-			return objs[i].Sym().Name < objs[j].Sym().Name
-		})
 	}
-
 	sort.Slice(pkgs, func(i, j int) bool {
 		return pkgs[i].Path < pkgs[j].Path
 	})
@@ -353,11 +350,16 @@ func (w *exportWriter) writeIndex(index map[ir.Node]uint64, mainIndex bool) {
 			w.uint64(uint64(pkg.Height))
 		}
 
-		objs := pkgObjs[pkg]
-		w.uint64(uint64(len(objs)))
-		for _, n := range objs {
-			w.string(n.Sym().Name)
-			w.uint64(index[n])
+		// Sort symbols within a package by name.
+		syms := pkgSyms[pkg]
+		sort.Slice(syms, func(i, j int) bool {
+			return syms[i].Name < syms[j].Name
+		})
+
+		w.uint64(uint64(len(syms)))
+		for _, sym := range syms {
+			w.string(sym.Name)
+			w.uint64(index[sym])
 		}
 	}
 }
@@ -374,8 +376,8 @@ type iexporter struct {
 	stringIndex map[string]uint64
 
 	data0       intWriter
-	declIndex   map[ir.Node]uint64
-	inlineIndex map[ir.Node]uint64
+	declIndex   map[*types.Sym]uint64
+	inlineIndex map[*types.Sym]uint64
 	typIndex    map[*types.Type]uint64
 }
 
@@ -404,11 +406,11 @@ func (p *iexporter) pushDecl(n *ir.Name) {
 		return
 	}
 
-	if _, ok := p.declIndex[n]; ok {
+	if _, ok := p.declIndex[n.Sym()]; ok {
 		return
 	}
 
-	p.declIndex[n] = ^uint64(0) // mark n present in work queue
+	p.declIndex[n.Sym()] = ^uint64(0) // mark n present in work queue
 	p.declTodo.PushRight(n)
 }
 
@@ -423,13 +425,12 @@ type exportWriter struct {
 	prevColumn int64
 }
 
-func (p *iexporter) doDecl(n ir.Node) {
+func (p *iexporter) doDecl(n *ir.Name) {
 	w := p.newWriter()
 	w.setPkg(n.Sym().Pkg, false)
 
 	switch n.Op() {
 	case ir.ONAME:
-		n := n.(*ir.Name)
 		switch n.Class() {
 		case ir.PEXTERN:
 			// Variable.
@@ -455,7 +456,8 @@ func (p *iexporter) doDecl(n ir.Node) {
 
 	case ir.OLITERAL:
 		// Constant.
-		n = typecheck(n, ctxExpr)
+		// TODO(mdempsky): Do we still need this typecheck? If so, why?
+		n = typecheck(n, ctxExpr).(*ir.Name)
 		w.tag('C')
 		w.pos(n.Pos())
 		w.value(n.Type(), n.Val())
@@ -509,7 +511,7 @@ func (p *iexporter) doDecl(n ir.Node) {
 		base.Fatalf("unexpected node: %v", n)
 	}
 
-	p.declIndex[n] = w.flush()
+	p.declIndex[n.Sym()] = w.flush()
 }
 
 func (w *exportWriter) tag(tag byte) {
@@ -522,7 +524,7 @@ func (p *iexporter) doInline(f *ir.Name) {
 
 	w.stmtList(ir.AsNodes(f.Func().Inl.Body))
 
-	p.inlineIndex[f] = w.flush()
+	p.inlineIndex[f.Sym()] = w.flush()
 }
 
 func (w *exportWriter) pos(pos src.XPos) {
-- 
GitLab


From d90b199e9c3d6673b1951ddb6a78addd7e0dda26 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 3 Dec 2020 14:00:19 -0800
Subject: [PATCH 0165/2400] [dev.regabi] cmd/compile: silence errors about
 missing blank methods

If an interface contains a blank method, that's already an error. No
need for useless follow-up error messages about not implementing them.

Fixes #42964.

Change-Id: I5bf53a8f27d75d4c86c61588c5e2e3e95563d320
Reviewed-on: https://go-review.googlesource.com/c/go/+/275294
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/gc/dcl.go   | 12 ------------
 src/cmd/compile/internal/gc/noder.go |  5 ++++-
 test/interface/explicit.go           |  7 ++++---
 3 files changed, 8 insertions(+), 16 deletions(-)

diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 5936aeb950..a77c1aed45 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -317,18 +317,6 @@ func colasdefn(left []ir.Node, defn ir.Node) {
 	}
 }
 
-// declare the arguments in an
-// interface field declaration.
-func ifacedcl(n *ir.Field) {
-	if n.Sym == nil {
-		base.Fatalf("ifacedcl")
-	}
-
-	if n.Sym.IsBlank() {
-		base.Errorf("methods must have a unique non-blank name")
-	}
-}
-
 // declare the function proper
 // and declare the arguments.
 // called in extern-declaration context
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 61320123a8..1cd8375677 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -899,10 +899,13 @@ func (p *noder) interfaceType(expr *syntax.InterfaceType) ir.Node {
 			n = ir.NewField(p.pos(method), nil, importName(p.packname(method.Type)).(ir.Ntype), nil)
 		} else {
 			mname := p.name(method.Name)
+			if mname.IsBlank() {
+				base.Errorf("methods must have a unique non-blank name")
+				continue
+			}
 			sig := p.typeExpr(method.Type).(*ir.FuncType)
 			sig.Recv = fakeRecv()
 			n = ir.NewField(p.pos(method), mname, sig, nil)
-			ifacedcl(n)
 		}
 		l = append(l, n)
 	}
diff --git a/test/interface/explicit.go b/test/interface/explicit.go
index 3f9451e8d2..b705b97676 100644
--- a/test/interface/explicit.go
+++ b/test/interface/explicit.go
@@ -100,6 +100,7 @@ type T2 struct{}
 func (t *T2) M() {}
 func (t *T2) _() {}
 
-// Check that nothing satisfies an interface with blank methods.
-var b1 B1 = &T2{} // ERROR "incompatible|missing _ method"
-var b2 B2 = &T2{} // ERROR "incompatible|missing _ method"
+// Already reported about the invalid blank interface method above;
+// no need to report about not implementing it.
+var b1 B1 = &T2{}
+var b2 B2 = &T2{}
-- 
GitLab


From cd15a48036b7c0e8369b18d6def93a950c35ff0a Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Fri, 4 Dec 2020 13:20:06 -0800
Subject: [PATCH 0166/2400] [dev.typeparams] cmd/compile/internal/types2:
 correct error position for inherited const init expression

Enabled fixedbugs/issue8183.go for run.go with new typechecker
now that issue is fixed.

Fixes #42992.
Updates #42991.

Change-Id: I23451999983b740d5f37ce3fa75ee756daf1a44f
Reviewed-on: https://go-review.googlesource.com/c/go/+/275517
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/check.go      |  1 +
 src/cmd/compile/internal/types2/decl.go       | 23 +++++++++++---
 src/cmd/compile/internal/types2/errors.go     | 11 +++++++
 src/cmd/compile/internal/types2/resolver.go   | 15 ++++-----
 .../internal/types2/testdata/constdecl.src    | 31 +++++++++++++++++++
 test/fixedbugs/issue8183.go                   |  6 ++--
 test/run.go                                   |  1 -
 7 files changed, 72 insertions(+), 16 deletions(-)

diff --git a/src/cmd/compile/internal/types2/check.go b/src/cmd/compile/internal/types2/check.go
index 4504586545..6ba8506916 100644
--- a/src/cmd/compile/internal/types2/check.go
+++ b/src/cmd/compile/internal/types2/check.go
@@ -51,6 +51,7 @@ type context struct {
 	scope         *Scope                    // top-most scope for lookups
 	pos           syntax.Pos                // if valid, identifiers are looked up as if at position pos (used by Eval)
 	iota          constant.Value            // value of iota in a constant declaration; nil otherwise
+	errpos        syntax.Pos                // if valid, identifier position of a constant with inherited initializer
 	sig           *Signature                // function signature if inside a function; nil otherwise
 	isPanic       map[*syntax.CallExpr]bool // set of panic call expressions (used for termination check)
 	hasLabel      bool                      // set if a function makes use of labels (only ~1% of functions); unused outside functions
diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index bb33e38051..bc3e665b71 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -187,7 +187,7 @@ func (check *Checker) objDecl(obj Object, def *Named) {
 	switch obj := obj.(type) {
 	case *Const:
 		check.decl = d // new package-level const decl
-		check.constDecl(obj, d.vtyp, d.init)
+		check.constDecl(obj, d.vtyp, d.init, d.inherited)
 	case *Var:
 		check.decl = d // new package-level var decl
 		check.varDecl(obj, d.lhs, d.vtyp, d.init)
@@ -421,12 +421,16 @@ func firstInSrc(path []Object) int {
 	return fst
 }
 
-func (check *Checker) constDecl(obj *Const, typ, init syntax.Expr) {
+func (check *Checker) constDecl(obj *Const, typ, init syntax.Expr, inherited bool) {
 	assert(obj.typ == nil)
 
-	// use the correct value of iota
-	defer func(iota constant.Value) { check.iota = iota }(check.iota)
+	// use the correct value of iota and errpos
+	defer func(iota constant.Value, errpos syntax.Pos) {
+		check.iota = iota
+		check.errpos = errpos
+	}(check.iota, check.errpos)
 	check.iota = obj.val
+	check.errpos = nopos
 
 	// provide valid constant value under all circumstances
 	obj.val = constant.MakeUnknown()
@@ -449,6 +453,15 @@ func (check *Checker) constDecl(obj *Const, typ, init syntax.Expr) {
 	// check initialization
 	var x operand
 	if init != nil {
+		if inherited {
+			// The initialization expression is inherited from a previous
+			// constant declaration, and (error) positions refer to that
+			// expression and not the current constant declaration. Use
+			// the constant identifier position for any errors during
+			// init expression evaluation since that is all we have
+			// (see issues #42991, #42992).
+			check.errpos = obj.pos
+		}
 		check.expr(&x, init)
 	}
 	check.initConst(obj, &x)
@@ -898,7 +911,7 @@ func (check *Checker) declStmt(list []syntax.Decl) {
 					init = values[i]
 				}
 
-				check.constDecl(obj, last.Type, init)
+				check.constDecl(obj, last.Type, init, inherited)
 			}
 
 			// Constants must always have init values.
diff --git a/src/cmd/compile/internal/types2/errors.go b/src/cmd/compile/internal/types2/errors.go
index 07f9aad48b..941e7c6fd3 100644
--- a/src/cmd/compile/internal/types2/errors.go
+++ b/src/cmd/compile/internal/types2/errors.go
@@ -87,6 +87,17 @@ func (check *Checker) err(pos syntax.Pos, msg string, soft bool) {
 		return
 	}
 
+	// If we are encountering an error while evaluating an inherited
+	// constant initialization expression, pos is the position of in
+	// the original expression, and not of the currently declared
+	// constant identifier. Use the provided errpos instead.
+	// TODO(gri) We may also want to augment the error message and
+	// refer to the position (pos) in the original expression.
+	if check.errpos.IsKnown() {
+		assert(check.iota != nil)
+		pos = check.errpos
+	}
+
 	err := Error{pos, stripAnnotations(msg), msg, soft}
 	if check.firstErr == nil {
 		check.firstErr = err
diff --git a/src/cmd/compile/internal/types2/resolver.go b/src/cmd/compile/internal/types2/resolver.go
index b116888bf2..cf9893ca87 100644
--- a/src/cmd/compile/internal/types2/resolver.go
+++ b/src/cmd/compile/internal/types2/resolver.go
@@ -17,12 +17,13 @@ import (
 
 // A declInfo describes a package-level const, type, var, or func declaration.
 type declInfo struct {
-	file  *Scope           // scope of file containing this declaration
-	lhs   []*Var           // lhs of n:1 variable declarations, or nil
-	vtyp  syntax.Expr      // type, or nil (for const and var declarations only)
-	init  syntax.Expr      // init/orig expression, or nil (for const and var declarations only)
-	tdecl *syntax.TypeDecl // type declaration, or nil
-	fdecl *syntax.FuncDecl // func declaration, or nil
+	file      *Scope           // scope of file containing this declaration
+	lhs       []*Var           // lhs of n:1 variable declarations, or nil
+	vtyp      syntax.Expr      // type, or nil (for const and var declarations only)
+	init      syntax.Expr      // init/orig expression, or nil (for const and var declarations only)
+	inherited bool             // if set, the init expression is inherited from a previous constant declaration
+	tdecl     *syntax.TypeDecl // type declaration, or nil
+	fdecl     *syntax.FuncDecl // func declaration, or nil
 
 	// The deps field tracks initialization expression dependencies.
 	deps map[Object]bool // lazily initialized
@@ -338,7 +339,7 @@ func (check *Checker) collectObjects() {
 						init = values[i]
 					}
 
-					d := &declInfo{file: fileScope, vtyp: last.Type, init: init}
+					d := &declInfo{file: fileScope, vtyp: last.Type, init: init, inherited: inherited}
 					check.declarePkgObj(name, obj, d)
 				}
 
diff --git a/src/cmd/compile/internal/types2/testdata/constdecl.src b/src/cmd/compile/internal/types2/testdata/constdecl.src
index e9a5162e9c..1a7ed003a4 100644
--- a/src/cmd/compile/internal/types2/testdata/constdecl.src
+++ b/src/cmd/compile/internal/types2/testdata/constdecl.src
@@ -104,4 +104,35 @@ func _() {
 	const x, y, z = 0, 1, unsafe.Sizeof(func() { _ = x /* ERROR "undeclared name" */ + y /* ERROR "undeclared name" */ + z /* ERROR "undeclared name" */ })
 }
 
+// Test cases for errors in inherited constant initialization expressions.
+// Errors related to inherited initialization expressions must appear at
+// the constant identifier being declared, not at the original expression
+// (issues #42991, #42992).
+const (
+	_ byte = 255 + iota
+	/* some gap */
+	_ // ERROR overflows byte
+	/* some gap */
+	/* some gap */ _ /* ERROR overflows byte */; _ /* ERROR overflows byte */
+	/* some gap */
+	_ = 255 + iota
+	_ = byte /* ERROR overflows byte */ (255) + iota
+	_ /* ERROR overflows byte */
+)
+
+// Test cases from issue.
+const (
+	ok = byte(iota + 253)
+	bad
+	barn
+	bard // ERROR cannot convert
+)
+
+const (
+	c = len([1 - iota]int{})
+	d
+	e // ERROR invalid array length
+	f // ERROR invalid array length
+)
+
 // TODO(gri) move extra tests from testdata/const0.src into here
diff --git a/test/fixedbugs/issue8183.go b/test/fixedbugs/issue8183.go
index 531dd4dbf8..01954dd107 100644
--- a/test/fixedbugs/issue8183.go
+++ b/test/fixedbugs/issue8183.go
@@ -12,12 +12,12 @@ const (
 	ok = byte(iota + 253)
 	bad
 	barn
-	bard // ERROR "constant 256 overflows byte"
+	bard // ERROR "constant 256 overflows byte|cannot convert"
 )
 
 const (
 	c = len([1 - iota]int{})
 	d
-	e // ERROR "array bound must be non-negative"
-	f // ERROR "array bound must be non-negative"
+	e // ERROR "array bound must be non-negative|invalid array length"
+	f // ERROR "array bound must be non-negative|invalid array length"
 )
diff --git a/test/run.go b/test/run.go
index 0ffb2c1a3d..a3e2ac5e32 100644
--- a/test/run.go
+++ b/test/run.go
@@ -2132,5 +2132,4 @@ var excluded = map[string]bool{
 	"fixedbugs/issue7746.go":   true, // type-checking doesn't terminate
 	"fixedbugs/issue8501.go":   true, // crashes
 	"fixedbugs/issue8507.go":   true, // crashes
-	"fixedbugs/issue8183.go":   true, // issue #42992
 }
-- 
GitLab


From 2cec6c4a8cca6106c9939ae1560d614dec656839 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 4 Dec 2020 10:17:50 -0500
Subject: [PATCH 0167/2400] [dev.regabi] cmd/compile: generate Node methods
 using program

Add Node method generator by Matthew Dempsky,
lightly adapted to account for a few special cases.
No more writing these by hand.

Change-Id: I6933b895df666928b851bddf81b994799c0c97f7
Reviewed-on: https://go-review.googlesource.com/c/go/+/275434
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/expr.go     |  455 +---------
 src/cmd/compile/internal/ir/func.go     |   13 -
 src/cmd/compile/internal/ir/mini.go     |    8 +
 src/cmd/compile/internal/ir/mknode.go   |  175 ++++
 src/cmd/compile/internal/ir/name.go     |   14 +-
 src/cmd/compile/internal/ir/node_gen.go | 1029 +++++++++++++++++++++++
 src/cmd/compile/internal/ir/stmt.go     |  382 ---------
 src/cmd/compile/internal/ir/type.go     |  113 ---
 8 files changed, 1214 insertions(+), 975 deletions(-)
 create mode 100644 src/cmd/compile/internal/ir/mknode.go
 create mode 100644 src/cmd/compile/internal/ir/node_gen.go

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index cfdb86f221..7b1aeedcdf 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -8,7 +8,6 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
-	"fmt"
 	"go/constant"
 )
 
@@ -95,25 +94,6 @@ func NewAddStringExpr(pos src.XPos, list []Node) *AddStringExpr {
 	return n
 }
 
-func (n *AddStringExpr) String() string                { return fmt.Sprint(n) }
-func (n *AddStringExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *AddStringExpr) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	c.list = c.list.Copy()
-	return &c
-}
-func (n *AddStringExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDoList(n.list, err, do)
-	return err
-}
-func (n *AddStringExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	editList(n.list, edit)
-}
-
 func (n *AddStringExpr) List() Nodes     { return n.list }
 func (n *AddStringExpr) PtrList() *Nodes { return &n.list }
 func (n *AddStringExpr) SetList(x Nodes) { n.list = x }
@@ -133,24 +113,6 @@ func NewAddrExpr(pos src.XPos, x Node) *AddrExpr {
 	return n
 }
 
-func (n *AddrExpr) String() string                { return fmt.Sprint(n) }
-func (n *AddrExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *AddrExpr) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *AddrExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	return err
-}
-func (n *AddrExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-}
-
 func (n *AddrExpr) Left() Node      { return n.X }
 func (n *AddrExpr) SetLeft(x Node)  { n.X = x }
 func (n *AddrExpr) Right() Node     { return n.Alloc }
@@ -180,26 +142,6 @@ func NewBinaryExpr(pos src.XPos, op Op, x, y Node) *BinaryExpr {
 	return n
 }
 
-func (n *BinaryExpr) String() string                { return fmt.Sprint(n) }
-func (n *BinaryExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *BinaryExpr) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *BinaryExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	err = maybeDo(n.Y, err, do)
-	return err
-}
-func (n *BinaryExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-	n.Y = maybeEdit(n.Y, edit)
-}
-
 func (n *BinaryExpr) Left() Node      { return n.X }
 func (n *BinaryExpr) SetLeft(x Node)  { n.X = x }
 func (n *BinaryExpr) Right() Node     { return n.Y }
@@ -250,33 +192,6 @@ func NewCallExpr(pos src.XPos, fun Node, args []Node) *CallExpr {
 	return n
 }
 
-func (n *CallExpr) String() string                { return fmt.Sprint(n) }
-func (n *CallExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *CallExpr) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	c.Args = c.Args.Copy()
-	c.Rargs = c.Rargs.Copy()
-	c.body = c.body.Copy()
-	return &c
-}
-func (n *CallExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	err = maybeDoList(n.Args, err, do)
-	err = maybeDoList(n.Rargs, err, do)
-	err = maybeDoList(n.body, err, do)
-	return err
-}
-func (n *CallExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-	editList(n.Args, edit)
-	editList(n.Rargs, edit)
-	editList(n.body, edit)
-}
-
 func (n *CallExpr) Orig() Node         { return n.orig }
 func (n *CallExpr) SetOrig(x Node)     { n.orig = x }
 func (n *CallExpr) Left() Node         { return n.X }
@@ -322,24 +237,6 @@ func NewCallPartExpr(pos src.XPos, x Node, method *types.Field, fn *Func) *CallP
 	return n
 }
 
-func (n *CallPartExpr) String() string                { return fmt.Sprint(n) }
-func (n *CallPartExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *CallPartExpr) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *CallPartExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	return err
-}
-func (n *CallPartExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-}
-
 func (n *CallPartExpr) Func() *Func     { return n.fn }
 func (n *CallPartExpr) Left() Node      { return n.X }
 func (n *CallPartExpr) Sym() *types.Sym { return n.Method.Sym }
@@ -358,22 +255,6 @@ func NewClosureExpr(pos src.XPos, fn *Func) *ClosureExpr {
 	return n
 }
 
-func (n *ClosureExpr) String() string                { return fmt.Sprint(n) }
-func (n *ClosureExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ClosureExpr) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *ClosureExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	return err
-}
-func (n *ClosureExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-}
-
 func (n *ClosureExpr) Func() *Func { return n.fn }
 
 // A ClosureRead denotes reading a variable stored within a closure struct.
@@ -389,24 +270,8 @@ func NewClosureRead(typ *types.Type, offset int64) *ClosureRead {
 	return n
 }
 
-func (n *ClosureRead) String() string                { return fmt.Sprint(n) }
-func (n *ClosureRead) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ClosureRead) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-
 func (n *ClosureRead) Type() *types.Type { return n.typ }
 func (n *ClosureRead) Offset() int64     { return n.offset }
-func (n *ClosureRead) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	return err
-}
-func (n *ClosureRead) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-}
 
 // A CompLitExpr is a composite literal Type{Vals}.
 // Before type-checking, the type is Ntype.
@@ -426,27 +291,6 @@ func NewCompLitExpr(pos src.XPos, typ Ntype, list []Node) *CompLitExpr {
 	return n
 }
 
-func (n *CompLitExpr) String() string                { return fmt.Sprint(n) }
-func (n *CompLitExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *CompLitExpr) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	c.list = c.list.Copy()
-	return &c
-}
-func (n *CompLitExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.Ntype, err, do)
-	err = maybeDoList(n.list, err, do)
-	return err
-}
-func (n *CompLitExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.Ntype = toNtype(maybeEdit(n.Ntype, edit))
-	editList(n.list, edit)
-}
-
 func (n *CompLitExpr) Orig() Node      { return n.orig }
 func (n *CompLitExpr) SetOrig(x Node)  { n.orig = x }
 func (n *CompLitExpr) Right() Node     { return n.Ntype }
@@ -480,12 +324,6 @@ func NewConstExpr(val constant.Value, orig Node) Node {
 	return n
 }
 
-func (n *ConstExpr) String() string                       { return fmt.Sprint(n) }
-func (n *ConstExpr) Format(s fmt.State, verb rune)        { FmtNode(n, s, verb) }
-func (n *ConstExpr) copy() Node                           { c := *n; return &c }
-func (n *ConstExpr) doChildren(do func(Node) error) error { return nil }
-func (n *ConstExpr) editChildren(edit func(Node) Node)    {}
-
 func (n *ConstExpr) Sym() *types.Sym     { return n.orig.Sym() }
 func (n *ConstExpr) Orig() Node          { return n.orig }
 func (n *ConstExpr) SetOrig(orig Node)   { panic(n.no("SetOrig")) }
@@ -495,8 +333,7 @@ func (n *ConstExpr) Val() constant.Value { return n.val }
 // It may end up being a value or a type.
 type ConvExpr struct {
 	miniExpr
-	orig Node
-	X    Node
+	X Node
 }
 
 func NewConvExpr(pos src.XPos, op Op, typ *types.Type, x Node) *ConvExpr {
@@ -504,29 +341,9 @@ func NewConvExpr(pos src.XPos, op Op, typ *types.Type, x Node) *ConvExpr {
 	n.pos = pos
 	n.typ = typ
 	n.SetOp(op)
-	n.orig = n
 	return n
 }
 
-func (n *ConvExpr) String() string                { return fmt.Sprint(n) }
-func (n *ConvExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ConvExpr) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *ConvExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	return err
-}
-func (n *ConvExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-}
-
-func (n *ConvExpr) rawCopy() Node  { c := *n; return &c }
 func (n *ConvExpr) Left() Node     { return n.X }
 func (n *ConvExpr) SetLeft(x Node) { n.X = x }
 
@@ -554,26 +371,6 @@ func NewIndexExpr(pos src.XPos, x, index Node) *IndexExpr {
 	return n
 }
 
-func (n *IndexExpr) String() string                { return fmt.Sprint(n) }
-func (n *IndexExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *IndexExpr) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *IndexExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	err = maybeDo(n.Index, err, do)
-	return err
-}
-func (n *IndexExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-	n.Index = maybeEdit(n.Index, edit)
-}
-
 func (n *IndexExpr) Left() Node               { return n.X }
 func (n *IndexExpr) SetLeft(x Node)           { n.X = x }
 func (n *IndexExpr) Right() Node              { return n.Index }
@@ -608,26 +405,6 @@ func NewKeyExpr(pos src.XPos, key, value Node) *KeyExpr {
 	return n
 }
 
-func (n *KeyExpr) String() string                { return fmt.Sprint(n) }
-func (n *KeyExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *KeyExpr) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *KeyExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.Key, err, do)
-	err = maybeDo(n.Value, err, do)
-	return err
-}
-func (n *KeyExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.Key = maybeEdit(n.Key, edit)
-	n.Value = maybeEdit(n.Value, edit)
-}
-
 func (n *KeyExpr) Left() Node          { return n.Key }
 func (n *KeyExpr) SetLeft(x Node)      { n.Key = x }
 func (n *KeyExpr) Right() Node         { return n.Value }
@@ -662,28 +439,6 @@ func NewInlinedCallExpr(pos src.XPos, body, retvars []Node) *InlinedCallExpr {
 	return n
 }
 
-func (n *InlinedCallExpr) String() string                { return fmt.Sprint(n) }
-func (n *InlinedCallExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *InlinedCallExpr) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	c.body = c.body.Copy()
-	c.ReturnVars = c.ReturnVars.Copy()
-	return &c
-}
-func (n *InlinedCallExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDoList(n.body, err, do)
-	err = maybeDoList(n.ReturnVars, err, do)
-	return err
-}
-func (n *InlinedCallExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	editList(n.body, edit)
-	editList(n.ReturnVars, edit)
-}
-
 func (n *InlinedCallExpr) Body() Nodes      { return n.body }
 func (n *InlinedCallExpr) PtrBody() *Nodes  { return &n.body }
 func (n *InlinedCallExpr) SetBody(x Nodes)  { n.body = x }
@@ -707,26 +462,6 @@ func NewMakeExpr(pos src.XPos, op Op, len, cap Node) *MakeExpr {
 	return n
 }
 
-func (n *MakeExpr) String() string                { return fmt.Sprint(n) }
-func (n *MakeExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *MakeExpr) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *MakeExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.Len, err, do)
-	err = maybeDo(n.Cap, err, do)
-	return err
-}
-func (n *MakeExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.Len = maybeEdit(n.Len, edit)
-	n.Cap = maybeEdit(n.Cap, edit)
-}
-
 func (n *MakeExpr) Left() Node      { return n.Len }
 func (n *MakeExpr) SetLeft(x Node)  { n.Len = x }
 func (n *MakeExpr) Right() Node     { return n.Cap }
@@ -760,26 +495,6 @@ func NewMethodExpr(pos src.XPos, op Op, x, m Node) *MethodExpr {
 	return n
 }
 
-func (n *MethodExpr) String() string                { return fmt.Sprint(n) }
-func (n *MethodExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *MethodExpr) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *MethodExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	err = maybeDo(n.M, err, do)
-	return err
-}
-func (n *MethodExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-	n.M = maybeEdit(n.M, edit)
-}
-
 func (n *MethodExpr) Left() Node          { return n.X }
 func (n *MethodExpr) SetLeft(x Node)      { n.X = x }
 func (n *MethodExpr) Right() Node         { return n.M }
@@ -805,22 +520,6 @@ func NewNilExpr(pos src.XPos) *NilExpr {
 	return n
 }
 
-func (n *NilExpr) String() string                { return fmt.Sprint(n) }
-func (n *NilExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *NilExpr) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *NilExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	return err
-}
-func (n *NilExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-}
-
 func (n *NilExpr) Sym() *types.Sym     { return n.sym }
 func (n *NilExpr) SetSym(x *types.Sym) { n.sym = x }
 
@@ -838,24 +537,6 @@ func NewParenExpr(pos src.XPos, x Node) *ParenExpr {
 	return n
 }
 
-func (n *ParenExpr) String() string                { return fmt.Sprint(n) }
-func (n *ParenExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ParenExpr) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *ParenExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	return err
-}
-func (n *ParenExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-}
-
 func (n *ParenExpr) Left() Node     { return n.X }
 func (n *ParenExpr) SetLeft(x Node) { n.X = x }
 
@@ -883,22 +564,6 @@ func NewResultExpr(pos src.XPos, typ *types.Type, offset int64) *ResultExpr {
 	return n
 }
 
-func (n *ResultExpr) String() string                { return fmt.Sprint(n) }
-func (n *ResultExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ResultExpr) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *ResultExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	return err
-}
-func (n *ResultExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-}
-
 func (n *ResultExpr) Offset() int64     { return n.offset }
 func (n *ResultExpr) SetOffset(x int64) { n.offset = x }
 
@@ -928,24 +593,6 @@ func (n *SelectorExpr) SetOp(op Op) {
 	}
 }
 
-func (n *SelectorExpr) String() string                { return fmt.Sprint(n) }
-func (n *SelectorExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *SelectorExpr) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *SelectorExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	return err
-}
-func (n *SelectorExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-}
-
 func (n *SelectorExpr) Left() Node          { return n.X }
 func (n *SelectorExpr) SetLeft(x Node)      { n.X = x }
 func (n *SelectorExpr) Sym() *types.Sym     { return n.Sel }
@@ -971,27 +618,6 @@ func NewSliceExpr(pos src.XPos, op Op, x Node) *SliceExpr {
 	return n
 }
 
-func (n *SliceExpr) String() string                { return fmt.Sprint(n) }
-func (n *SliceExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *SliceExpr) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	c.list = c.list.Copy()
-	return &c
-}
-func (n *SliceExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	err = maybeDoList(n.list, err, do)
-	return err
-}
-func (n *SliceExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-	editList(n.list, edit)
-}
-
 func (n *SliceExpr) Left() Node      { return n.X }
 func (n *SliceExpr) SetLeft(x Node)  { n.X = x }
 func (n *SliceExpr) List() Nodes     { return n.list }
@@ -1091,26 +717,6 @@ func NewSliceHeaderExpr(pos src.XPos, typ *types.Type, ptr, len, cap Node) *Slic
 	return n
 }
 
-func (n *SliceHeaderExpr) String() string                { return fmt.Sprint(n) }
-func (n *SliceHeaderExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *SliceHeaderExpr) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *SliceHeaderExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.Ptr, err, do)
-	err = maybeDoList(n.lenCap, err, do)
-	return err
-}
-func (n *SliceHeaderExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.Ptr = maybeEdit(n.Ptr, edit)
-	editList(n.lenCap, edit)
-}
-
 func (n *SliceHeaderExpr) Left() Node      { return n.Ptr }
 func (n *SliceHeaderExpr) SetLeft(x Node)  { n.Ptr = x }
 func (n *SliceHeaderExpr) List() Nodes     { return n.lenCap }
@@ -1131,24 +737,6 @@ func NewStarExpr(pos src.XPos, x Node) *StarExpr {
 	return n
 }
 
-func (n *StarExpr) String() string                { return fmt.Sprint(n) }
-func (n *StarExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *StarExpr) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *StarExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	return err
-}
-func (n *StarExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-}
-
 func (n *StarExpr) Left() Node     { return n.X }
 func (n *StarExpr) SetLeft(x Node) { n.X = x }
 
@@ -1179,29 +767,6 @@ func NewTypeAssertExpr(pos src.XPos, x Node, typ Ntype) *TypeAssertExpr {
 	return n
 }
 
-func (n *TypeAssertExpr) String() string                { return fmt.Sprint(n) }
-func (n *TypeAssertExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *TypeAssertExpr) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	c.Itab = c.Itab.Copy()
-	return &c
-}
-func (n *TypeAssertExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	err = maybeDo(n.Ntype, err, do)
-	err = maybeDoList(n.Itab, err, do)
-	return err
-}
-func (n *TypeAssertExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-	n.Ntype = maybeEdit(n.Ntype, edit)
-	editList(n.Itab, edit)
-}
-
 func (n *TypeAssertExpr) Left() Node      { return n.X }
 func (n *TypeAssertExpr) SetLeft(x Node)  { n.X = x }
 func (n *TypeAssertExpr) Right() Node     { return n.Ntype }
@@ -1233,24 +798,6 @@ func NewUnaryExpr(pos src.XPos, op Op, x Node) *UnaryExpr {
 	return n
 }
 
-func (n *UnaryExpr) String() string                { return fmt.Sprint(n) }
-func (n *UnaryExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *UnaryExpr) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *UnaryExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	return err
-}
-func (n *UnaryExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-}
-
 func (n *UnaryExpr) Left() Node     { return n.X }
 func (n *UnaryExpr) SetLeft(x Node) { n.X = x }
 
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 78e98c4d31..38e00da7da 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -9,7 +9,6 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/src"
-	"fmt"
 )
 
 // A Func corresponds to a single function in a Go program
@@ -115,18 +114,6 @@ func NewFunc(pos src.XPos) *Func {
 	return f
 }
 
-func (f *Func) String() string                { return fmt.Sprint(f) }
-func (f *Func) Format(s fmt.State, verb rune) { FmtNode(f, s, verb) }
-func (f *Func) copy() Node                    { panic(f.no("copy")) }
-func (f *Func) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(f.body, err, do)
-	return err
-}
-func (f *Func) editChildren(edit func(Node) Node) {
-	editList(f.body, edit)
-}
-
 func (f *Func) Func() *Func           { return f }
 func (f *Func) Body() Nodes           { return f.body }
 func (f *Func) PtrBody() *Nodes       { return &f.body }
diff --git a/src/cmd/compile/internal/ir/mini.go b/src/cmd/compile/internal/ir/mini.go
index 909ca0220d..612e7d62c3 100644
--- a/src/cmd/compile/internal/ir/mini.go
+++ b/src/cmd/compile/internal/ir/mini.go
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:generate go run -mod=mod mknode.go
+
 package ir
 
 import (
@@ -33,6 +35,12 @@ type miniNode struct {
 	esc  uint16
 }
 
+func (n *miniNode) String() string                       { panic(1) }
+func (n *miniNode) Format(s fmt.State, verb rune)        { panic(1) }
+func (n *miniNode) copy() Node                           { panic(1) }
+func (n *miniNode) doChildren(do func(Node) error) error { panic(1) }
+func (n *miniNode) editChildren(edit func(Node) Node)    { panic(1) }
+
 // posOr returns pos if known, or else n.pos.
 // For use in DeepCopy.
 func (n *miniNode) posOr(pos src.XPos) src.XPos {
diff --git a/src/cmd/compile/internal/ir/mknode.go b/src/cmd/compile/internal/ir/mknode.go
new file mode 100644
index 0000000000..2c007f93f1
--- /dev/null
+++ b/src/cmd/compile/internal/ir/mknode.go
@@ -0,0 +1,175 @@
+// Copyright 2020 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.
+
+// +build ignore
+
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"go/format"
+	"go/types"
+	"io/ioutil"
+	"log"
+	"strings"
+
+	"golang.org/x/tools/go/packages"
+)
+
+func main() {
+	cfg := &packages.Config{
+		Mode: packages.NeedSyntax | packages.NeedTypes,
+	}
+	pkgs, err := packages.Load(cfg, "cmd/compile/internal/ir")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	pkg := pkgs[0].Types
+	scope := pkg.Scope()
+
+	lookup := func(name string) *types.Named {
+		return scope.Lookup(name).(*types.TypeName).Type().(*types.Named)
+	}
+
+	nodeType := lookup("Node")
+	ntypeType := lookup("Ntype")
+	nodesType := lookup("Nodes")
+	ptrFieldType := types.NewPointer(lookup("Field"))
+	slicePtrFieldType := types.NewSlice(ptrFieldType)
+	ptrNameType := types.NewPointer(lookup("Name"))
+
+	var buf bytes.Buffer
+	fmt.Fprintln(&buf, "// Code generated by mknode.go. DO NOT EDIT.")
+	fmt.Fprintln(&buf)
+	fmt.Fprintln(&buf, "package ir")
+	fmt.Fprintln(&buf)
+	fmt.Fprintln(&buf, `import "fmt"`)
+
+	for _, name := range scope.Names() {
+		obj, ok := scope.Lookup(name).(*types.TypeName)
+		if !ok {
+			continue
+		}
+
+		typName := obj.Name()
+		typ, ok := obj.Type().(*types.Named).Underlying().(*types.Struct)
+		if !ok {
+			continue
+		}
+
+		if strings.HasPrefix(typName, "mini") || !hasMiniNode(typ) {
+			continue
+		}
+
+		fmt.Fprintf(&buf, "\n")
+		fmt.Fprintf(&buf, "func (n *%s) String() string { return fmt.Sprint(n) }\n", name)
+		fmt.Fprintf(&buf, "func (n *%s) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }\n", name)
+
+		fmt.Fprintf(&buf, "func (n *%s) copy() Node { c := *n\n", name)
+		forNodeFields(typName, typ, func(name string, is func(types.Type) bool) {
+			switch {
+			case is(nodesType):
+				fmt.Fprintf(&buf, "c.%s = c.%s.Copy()\n", name, name)
+			case is(ptrFieldType):
+				fmt.Fprintf(&buf, "if c.%s != nil { c.%s = c.%s.copy() }\n", name, name, name)
+			case is(slicePtrFieldType):
+				fmt.Fprintf(&buf, "c.%s = copyFields(c.%s)\n", name, name)
+			}
+		})
+		fmt.Fprintf(&buf, "return &c }\n")
+
+		fmt.Fprintf(&buf, "func (n *%s) doChildren(do func(Node) error) error { var err error\n", name)
+		forNodeFields(typName, typ, func(name string, is func(types.Type) bool) {
+			switch {
+			case is(ptrNameType):
+				fmt.Fprintf(&buf, "if n.%s != nil { err = maybeDo(n.%s, err, do) }\n", name, name)
+			case is(nodeType), is(ntypeType):
+				fmt.Fprintf(&buf, "err = maybeDo(n.%s, err, do)\n", name)
+			case is(nodesType):
+				fmt.Fprintf(&buf, "err = maybeDoList(n.%s, err, do)\n", name)
+			case is(ptrFieldType):
+				fmt.Fprintf(&buf, "err = maybeDoField(n.%s, err, do)\n", name)
+			case is(slicePtrFieldType):
+				fmt.Fprintf(&buf, "err = maybeDoFields(n.%s, err, do)\n", name)
+			}
+		})
+		fmt.Fprintf(&buf, "return err }\n")
+
+		fmt.Fprintf(&buf, "func (n *%s) editChildren(edit func(Node) Node) {\n", name)
+		forNodeFields(typName, typ, func(name string, is func(types.Type) bool) {
+			switch {
+			case is(ptrNameType):
+				fmt.Fprintf(&buf, "if n.%s != nil { n.%s = edit(n.%s).(*Name) }\n", name, name, name)
+			case is(nodeType):
+				fmt.Fprintf(&buf, "n.%s = maybeEdit(n.%s, edit)\n", name, name)
+			case is(ntypeType):
+				fmt.Fprintf(&buf, "n.%s = toNtype(maybeEdit(n.%s, edit))\n", name, name)
+			case is(nodesType):
+				fmt.Fprintf(&buf, "editList(n.%s, edit)\n", name)
+			case is(ptrFieldType):
+				fmt.Fprintf(&buf, "editField(n.%s, edit)\n", name)
+			case is(slicePtrFieldType):
+				fmt.Fprintf(&buf, "editFields(n.%s, edit)\n", name)
+			}
+		})
+		fmt.Fprintf(&buf, "}\n")
+	}
+
+	out, err := format.Source(buf.Bytes())
+	if err != nil {
+		// write out mangled source so we can see the bug.
+		out = buf.Bytes()
+	}
+
+	err = ioutil.WriteFile("node_gen.go", out, 0666)
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+func forNodeFields(typName string, typ *types.Struct, f func(name string, is func(types.Type) bool)) {
+	for i, n := 0, typ.NumFields(); i < n; i++ {
+		v := typ.Field(i)
+		if v.Embedded() {
+			if typ, ok := v.Type().Underlying().(*types.Struct); ok {
+				forNodeFields(typName, typ, f)
+				continue
+			}
+		}
+		switch typName {
+		case "Func":
+			if v.Name() != "body" {
+				continue
+			}
+		case "Name", "Pack":
+			continue
+		}
+		switch v.Name() {
+		case "orig":
+			continue
+		}
+		switch typName + "." + v.Name() {
+		case "AddStringExpr.Alloc":
+			continue
+		}
+		f(v.Name(), func(t types.Type) bool { return types.Identical(t, v.Type()) })
+	}
+}
+
+func hasMiniNode(typ *types.Struct) bool {
+	for i, n := 0, typ.NumFields(); i < n; i++ {
+		v := typ.Field(i)
+		if v.Name() == "miniNode" {
+			return true
+		}
+		if v.Embedded() {
+			if typ, ok := v.Type().Underlying().(*types.Struct); ok && hasMiniNode(typ) {
+				return true
+			}
+		}
+	}
+	return false
+}
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 030fb82a7d..06cffe0325 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -9,7 +9,7 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/objabi"
 	"cmd/internal/src"
-	"fmt"
+
 	"go/constant"
 )
 
@@ -149,12 +149,6 @@ func newNameAt(pos src.XPos, op Op, sym *types.Sym) *Name {
 	return n
 }
 
-func (n *Name) String() string                       { return fmt.Sprint(n) }
-func (n *Name) Format(s fmt.State, verb rune)        { FmtNode(n, s, verb) }
-func (n *Name) copy() Node                           { c := *n; return &c }
-func (n *Name) doChildren(do func(Node) error) error { return nil }
-func (n *Name) editChildren(edit func(Node) Node)    {}
-
 func (n *Name) Name() *Name         { return n }
 func (n *Name) Sym() *types.Sym     { return n.sym }
 func (n *Name) SetSym(x *types.Sym) { n.sym = x }
@@ -361,12 +355,6 @@ type PkgName struct {
 	Used bool
 }
 
-func (p *PkgName) String() string                       { return fmt.Sprint(p) }
-func (p *PkgName) Format(s fmt.State, verb rune)        { FmtNode(p, s, verb) }
-func (p *PkgName) copy() Node                           { c := *p; return &c }
-func (p *PkgName) doChildren(do func(Node) error) error { return nil }
-func (p *PkgName) editChildren(edit func(Node) Node) {}
-
 func (p *PkgName) Sym() *types.Sym { return p.sym }
 
 func (*PkgName) CanBeNtype() {}
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
new file mode 100644
index 0000000000..4c47a4486e
--- /dev/null
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -0,0 +1,1029 @@
+// Code generated by mknode.go. DO NOT EDIT.
+
+package ir
+
+import "fmt"
+
+func (n *AddStringExpr) String() string                { return fmt.Sprint(n) }
+func (n *AddStringExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *AddStringExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.list = c.list.Copy()
+	return &c
+}
+func (n *AddStringExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDoList(n.list, err, do)
+	return err
+}
+func (n *AddStringExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	editList(n.list, edit)
+}
+
+func (n *AddrExpr) String() string                { return fmt.Sprint(n) }
+func (n *AddrExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *AddrExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *AddrExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	err = maybeDo(n.Alloc, err, do)
+	return err
+}
+func (n *AddrExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+	n.Alloc = maybeEdit(n.Alloc, edit)
+}
+
+func (n *ArrayType) String() string                { return fmt.Sprint(n) }
+func (n *ArrayType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ArrayType) copy() Node {
+	c := *n
+	return &c
+}
+func (n *ArrayType) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDo(n.Len, err, do)
+	err = maybeDo(n.Elem, err, do)
+	return err
+}
+func (n *ArrayType) editChildren(edit func(Node) Node) {
+	n.Len = maybeEdit(n.Len, edit)
+	n.Elem = maybeEdit(n.Elem, edit)
+}
+
+func (n *AssignListStmt) String() string                { return fmt.Sprint(n) }
+func (n *AssignListStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *AssignListStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.Lhs = c.Lhs.Copy()
+	c.Rhs = c.Rhs.Copy()
+	return &c
+}
+func (n *AssignListStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDoList(n.Lhs, err, do)
+	err = maybeDoList(n.Rhs, err, do)
+	return err
+}
+func (n *AssignListStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	editList(n.Lhs, edit)
+	editList(n.Rhs, edit)
+}
+
+func (n *AssignOpStmt) String() string                { return fmt.Sprint(n) }
+func (n *AssignOpStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *AssignOpStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *AssignOpStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	err = maybeDo(n.Y, err, do)
+	return err
+}
+func (n *AssignOpStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+	n.Y = maybeEdit(n.Y, edit)
+}
+
+func (n *AssignStmt) String() string                { return fmt.Sprint(n) }
+func (n *AssignStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *AssignStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *AssignStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	err = maybeDo(n.Y, err, do)
+	return err
+}
+func (n *AssignStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+	n.Y = maybeEdit(n.Y, edit)
+}
+
+func (n *BinaryExpr) String() string                { return fmt.Sprint(n) }
+func (n *BinaryExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *BinaryExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *BinaryExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	err = maybeDo(n.Y, err, do)
+	return err
+}
+func (n *BinaryExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+	n.Y = maybeEdit(n.Y, edit)
+}
+
+func (n *BlockStmt) String() string                { return fmt.Sprint(n) }
+func (n *BlockStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *BlockStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.list = c.list.Copy()
+	return &c
+}
+func (n *BlockStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDoList(n.list, err, do)
+	return err
+}
+func (n *BlockStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	editList(n.list, edit)
+}
+
+func (n *BranchStmt) String() string                { return fmt.Sprint(n) }
+func (n *BranchStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *BranchStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *BranchStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	return err
+}
+func (n *BranchStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+}
+
+func (n *CallExpr) String() string                { return fmt.Sprint(n) }
+func (n *CallExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *CallExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.Args = c.Args.Copy()
+	c.Rargs = c.Rargs.Copy()
+	c.body = c.body.Copy()
+	return &c
+}
+func (n *CallExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	err = maybeDoList(n.Args, err, do)
+	err = maybeDoList(n.Rargs, err, do)
+	err = maybeDoList(n.body, err, do)
+	return err
+}
+func (n *CallExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+	editList(n.Args, edit)
+	editList(n.Rargs, edit)
+	editList(n.body, edit)
+}
+
+func (n *CallPartExpr) String() string                { return fmt.Sprint(n) }
+func (n *CallPartExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *CallPartExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *CallPartExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	return err
+}
+func (n *CallPartExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+}
+
+func (n *CaseStmt) String() string                { return fmt.Sprint(n) }
+func (n *CaseStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *CaseStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.Vars = c.Vars.Copy()
+	c.list = c.list.Copy()
+	c.body = c.body.Copy()
+	return &c
+}
+func (n *CaseStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDoList(n.Vars, err, do)
+	err = maybeDoList(n.list, err, do)
+	err = maybeDo(n.Comm, err, do)
+	err = maybeDoList(n.body, err, do)
+	return err
+}
+func (n *CaseStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	editList(n.Vars, edit)
+	editList(n.list, edit)
+	n.Comm = maybeEdit(n.Comm, edit)
+	editList(n.body, edit)
+}
+
+func (n *ChanType) String() string                { return fmt.Sprint(n) }
+func (n *ChanType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ChanType) copy() Node {
+	c := *n
+	return &c
+}
+func (n *ChanType) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDo(n.Elem, err, do)
+	return err
+}
+func (n *ChanType) editChildren(edit func(Node) Node) {
+	n.Elem = maybeEdit(n.Elem, edit)
+}
+
+func (n *ClosureExpr) String() string                { return fmt.Sprint(n) }
+func (n *ClosureExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ClosureExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *ClosureExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	return err
+}
+func (n *ClosureExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+}
+
+func (n *ClosureRead) String() string                { return fmt.Sprint(n) }
+func (n *ClosureRead) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ClosureRead) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *ClosureRead) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	return err
+}
+func (n *ClosureRead) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+}
+
+func (n *CompLitExpr) String() string                { return fmt.Sprint(n) }
+func (n *CompLitExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *CompLitExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.list = c.list.Copy()
+	return &c
+}
+func (n *CompLitExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.Ntype, err, do)
+	err = maybeDoList(n.list, err, do)
+	return err
+}
+func (n *CompLitExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.Ntype = toNtype(maybeEdit(n.Ntype, edit))
+	editList(n.list, edit)
+}
+
+func (n *ConstExpr) String() string                { return fmt.Sprint(n) }
+func (n *ConstExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ConstExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *ConstExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	return err
+}
+func (n *ConstExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+}
+
+func (n *ConvExpr) String() string                { return fmt.Sprint(n) }
+func (n *ConvExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ConvExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *ConvExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	return err
+}
+func (n *ConvExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+}
+
+func (n *Decl) String() string                { return fmt.Sprint(n) }
+func (n *Decl) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *Decl) copy() Node {
+	c := *n
+	return &c
+}
+func (n *Decl) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDo(n.X, err, do)
+	return err
+}
+func (n *Decl) editChildren(edit func(Node) Node) {
+	n.X = maybeEdit(n.X, edit)
+}
+
+func (n *DeferStmt) String() string                { return fmt.Sprint(n) }
+func (n *DeferStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *DeferStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *DeferStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.Call, err, do)
+	return err
+}
+func (n *DeferStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.Call = maybeEdit(n.Call, edit)
+}
+
+func (n *ForStmt) String() string                { return fmt.Sprint(n) }
+func (n *ForStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ForStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.Late = c.Late.Copy()
+	c.body = c.body.Copy()
+	return &c
+}
+func (n *ForStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.Cond, err, do)
+	err = maybeDoList(n.Late, err, do)
+	err = maybeDo(n.Post, err, do)
+	err = maybeDoList(n.body, err, do)
+	return err
+}
+func (n *ForStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.Cond = maybeEdit(n.Cond, edit)
+	editList(n.Late, edit)
+	n.Post = maybeEdit(n.Post, edit)
+	editList(n.body, edit)
+}
+
+func (n *Func) String() string                { return fmt.Sprint(n) }
+func (n *Func) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *Func) copy() Node {
+	c := *n
+	c.body = c.body.Copy()
+	return &c
+}
+func (n *Func) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.body, err, do)
+	return err
+}
+func (n *Func) editChildren(edit func(Node) Node) {
+	editList(n.body, edit)
+}
+
+func (n *FuncType) String() string                { return fmt.Sprint(n) }
+func (n *FuncType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *FuncType) copy() Node {
+	c := *n
+	if c.Recv != nil {
+		c.Recv = c.Recv.copy()
+	}
+	c.Params = copyFields(c.Params)
+	c.Results = copyFields(c.Results)
+	return &c
+}
+func (n *FuncType) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoField(n.Recv, err, do)
+	err = maybeDoFields(n.Params, err, do)
+	err = maybeDoFields(n.Results, err, do)
+	return err
+}
+func (n *FuncType) editChildren(edit func(Node) Node) {
+	editField(n.Recv, edit)
+	editFields(n.Params, edit)
+	editFields(n.Results, edit)
+}
+
+func (n *GoStmt) String() string                { return fmt.Sprint(n) }
+func (n *GoStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *GoStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *GoStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.Call, err, do)
+	return err
+}
+func (n *GoStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.Call = maybeEdit(n.Call, edit)
+}
+
+func (n *IfStmt) String() string                { return fmt.Sprint(n) }
+func (n *IfStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *IfStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.body = c.body.Copy()
+	c.Else = c.Else.Copy()
+	return &c
+}
+func (n *IfStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.Cond, err, do)
+	err = maybeDoList(n.body, err, do)
+	err = maybeDoList(n.Else, err, do)
+	return err
+}
+func (n *IfStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.Cond = maybeEdit(n.Cond, edit)
+	editList(n.body, edit)
+	editList(n.Else, edit)
+}
+
+func (n *IndexExpr) String() string                { return fmt.Sprint(n) }
+func (n *IndexExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *IndexExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *IndexExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	err = maybeDo(n.Index, err, do)
+	return err
+}
+func (n *IndexExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+	n.Index = maybeEdit(n.Index, edit)
+}
+
+func (n *InlineMarkStmt) String() string                { return fmt.Sprint(n) }
+func (n *InlineMarkStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *InlineMarkStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *InlineMarkStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	return err
+}
+func (n *InlineMarkStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+}
+
+func (n *InlinedCallExpr) String() string                { return fmt.Sprint(n) }
+func (n *InlinedCallExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *InlinedCallExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.body = c.body.Copy()
+	c.ReturnVars = c.ReturnVars.Copy()
+	return &c
+}
+func (n *InlinedCallExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDoList(n.body, err, do)
+	err = maybeDoList(n.ReturnVars, err, do)
+	return err
+}
+func (n *InlinedCallExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	editList(n.body, edit)
+	editList(n.ReturnVars, edit)
+}
+
+func (n *InterfaceType) String() string                { return fmt.Sprint(n) }
+func (n *InterfaceType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *InterfaceType) copy() Node {
+	c := *n
+	c.Methods = copyFields(c.Methods)
+	return &c
+}
+func (n *InterfaceType) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoFields(n.Methods, err, do)
+	return err
+}
+func (n *InterfaceType) editChildren(edit func(Node) Node) {
+	editFields(n.Methods, edit)
+}
+
+func (n *KeyExpr) String() string                { return fmt.Sprint(n) }
+func (n *KeyExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *KeyExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *KeyExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.Key, err, do)
+	err = maybeDo(n.Value, err, do)
+	return err
+}
+func (n *KeyExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.Key = maybeEdit(n.Key, edit)
+	n.Value = maybeEdit(n.Value, edit)
+}
+
+func (n *LabelStmt) String() string                { return fmt.Sprint(n) }
+func (n *LabelStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *LabelStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *LabelStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	return err
+}
+func (n *LabelStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+}
+
+func (n *MakeExpr) String() string                { return fmt.Sprint(n) }
+func (n *MakeExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *MakeExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *MakeExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.Len, err, do)
+	err = maybeDo(n.Cap, err, do)
+	return err
+}
+func (n *MakeExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.Len = maybeEdit(n.Len, edit)
+	n.Cap = maybeEdit(n.Cap, edit)
+}
+
+func (n *MapType) String() string                { return fmt.Sprint(n) }
+func (n *MapType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *MapType) copy() Node {
+	c := *n
+	return &c
+}
+func (n *MapType) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDo(n.Key, err, do)
+	err = maybeDo(n.Elem, err, do)
+	return err
+}
+func (n *MapType) editChildren(edit func(Node) Node) {
+	n.Key = maybeEdit(n.Key, edit)
+	n.Elem = maybeEdit(n.Elem, edit)
+}
+
+func (n *MethodExpr) String() string                { return fmt.Sprint(n) }
+func (n *MethodExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *MethodExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *MethodExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	err = maybeDo(n.M, err, do)
+	return err
+}
+func (n *MethodExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+	n.M = maybeEdit(n.M, edit)
+}
+
+func (n *Name) String() string                { return fmt.Sprint(n) }
+func (n *Name) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *Name) copy() Node {
+	c := *n
+	return &c
+}
+func (n *Name) doChildren(do func(Node) error) error {
+	var err error
+	return err
+}
+func (n *Name) editChildren(edit func(Node) Node) {
+}
+
+func (n *NilExpr) String() string                { return fmt.Sprint(n) }
+func (n *NilExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *NilExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *NilExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	return err
+}
+func (n *NilExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+}
+
+func (n *ParenExpr) String() string                { return fmt.Sprint(n) }
+func (n *ParenExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ParenExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *ParenExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	return err
+}
+func (n *ParenExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+}
+
+func (n *PkgName) String() string                { return fmt.Sprint(n) }
+func (n *PkgName) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *PkgName) copy() Node {
+	c := *n
+	return &c
+}
+func (n *PkgName) doChildren(do func(Node) error) error {
+	var err error
+	return err
+}
+func (n *PkgName) editChildren(edit func(Node) Node) {
+}
+
+func (n *RangeStmt) String() string                { return fmt.Sprint(n) }
+func (n *RangeStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *RangeStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.Vars = c.Vars.Copy()
+	c.body = c.body.Copy()
+	return &c
+}
+func (n *RangeStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDoList(n.Vars, err, do)
+	err = maybeDo(n.X, err, do)
+	err = maybeDoList(n.body, err, do)
+	return err
+}
+func (n *RangeStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	editList(n.Vars, edit)
+	n.X = maybeEdit(n.X, edit)
+	editList(n.body, edit)
+}
+
+func (n *ResultExpr) String() string                { return fmt.Sprint(n) }
+func (n *ResultExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ResultExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *ResultExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	return err
+}
+func (n *ResultExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+}
+
+func (n *ReturnStmt) String() string                { return fmt.Sprint(n) }
+func (n *ReturnStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ReturnStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.Results = c.Results.Copy()
+	return &c
+}
+func (n *ReturnStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDoList(n.Results, err, do)
+	return err
+}
+func (n *ReturnStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	editList(n.Results, edit)
+}
+
+func (n *SelectStmt) String() string                { return fmt.Sprint(n) }
+func (n *SelectStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *SelectStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.Cases = c.Cases.Copy()
+	c.Compiled = c.Compiled.Copy()
+	return &c
+}
+func (n *SelectStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDoList(n.Cases, err, do)
+	err = maybeDoList(n.Compiled, err, do)
+	return err
+}
+func (n *SelectStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	editList(n.Cases, edit)
+	editList(n.Compiled, edit)
+}
+
+func (n *SelectorExpr) String() string                { return fmt.Sprint(n) }
+func (n *SelectorExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *SelectorExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *SelectorExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	return err
+}
+func (n *SelectorExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+}
+
+func (n *SendStmt) String() string                { return fmt.Sprint(n) }
+func (n *SendStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *SendStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *SendStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.Chan, err, do)
+	err = maybeDo(n.Value, err, do)
+	return err
+}
+func (n *SendStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.Chan = maybeEdit(n.Chan, edit)
+	n.Value = maybeEdit(n.Value, edit)
+}
+
+func (n *SliceExpr) String() string                { return fmt.Sprint(n) }
+func (n *SliceExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *SliceExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.list = c.list.Copy()
+	return &c
+}
+func (n *SliceExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	err = maybeDoList(n.list, err, do)
+	return err
+}
+func (n *SliceExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+	editList(n.list, edit)
+}
+
+func (n *SliceHeaderExpr) String() string                { return fmt.Sprint(n) }
+func (n *SliceHeaderExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *SliceHeaderExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.lenCap = c.lenCap.Copy()
+	return &c
+}
+func (n *SliceHeaderExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.Ptr, err, do)
+	err = maybeDoList(n.lenCap, err, do)
+	return err
+}
+func (n *SliceHeaderExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.Ptr = maybeEdit(n.Ptr, edit)
+	editList(n.lenCap, edit)
+}
+
+func (n *SliceType) String() string                { return fmt.Sprint(n) }
+func (n *SliceType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *SliceType) copy() Node {
+	c := *n
+	return &c
+}
+func (n *SliceType) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDo(n.Elem, err, do)
+	return err
+}
+func (n *SliceType) editChildren(edit func(Node) Node) {
+	n.Elem = maybeEdit(n.Elem, edit)
+}
+
+func (n *StarExpr) String() string                { return fmt.Sprint(n) }
+func (n *StarExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *StarExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *StarExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	return err
+}
+func (n *StarExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+}
+
+func (n *StructType) String() string                { return fmt.Sprint(n) }
+func (n *StructType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *StructType) copy() Node {
+	c := *n
+	c.Fields = copyFields(c.Fields)
+	return &c
+}
+func (n *StructType) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoFields(n.Fields, err, do)
+	return err
+}
+func (n *StructType) editChildren(edit func(Node) Node) {
+	editFields(n.Fields, edit)
+}
+
+func (n *SwitchStmt) String() string                { return fmt.Sprint(n) }
+func (n *SwitchStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *SwitchStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.Cases = c.Cases.Copy()
+	c.Compiled = c.Compiled.Copy()
+	return &c
+}
+func (n *SwitchStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.Tag, err, do)
+	err = maybeDoList(n.Cases, err, do)
+	err = maybeDoList(n.Compiled, err, do)
+	return err
+}
+func (n *SwitchStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.Tag = maybeEdit(n.Tag, edit)
+	editList(n.Cases, edit)
+	editList(n.Compiled, edit)
+}
+
+func (n *TypeAssertExpr) String() string                { return fmt.Sprint(n) }
+func (n *TypeAssertExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *TypeAssertExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.Itab = c.Itab.Copy()
+	return &c
+}
+func (n *TypeAssertExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	err = maybeDo(n.Ntype, err, do)
+	err = maybeDoList(n.Itab, err, do)
+	return err
+}
+func (n *TypeAssertExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+	n.Ntype = maybeEdit(n.Ntype, edit)
+	editList(n.Itab, edit)
+}
+
+func (n *TypeSwitchGuard) String() string                { return fmt.Sprint(n) }
+func (n *TypeSwitchGuard) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *TypeSwitchGuard) copy() Node {
+	c := *n
+	return &c
+}
+func (n *TypeSwitchGuard) doChildren(do func(Node) error) error {
+	var err error
+	if n.name != nil {
+		err = maybeDo(n.name, err, do)
+	}
+	err = maybeDo(n.X, err, do)
+	return err
+}
+func (n *TypeSwitchGuard) editChildren(edit func(Node) Node) {
+	if n.name != nil {
+		n.name = edit(n.name).(*Name)
+	}
+	n.X = maybeEdit(n.X, edit)
+}
+
+func (n *UnaryExpr) String() string                { return fmt.Sprint(n) }
+func (n *UnaryExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *UnaryExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *UnaryExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	return err
+}
+func (n *UnaryExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+}
+
+func (n *typeNode) String() string                { return fmt.Sprint(n) }
+func (n *typeNode) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *typeNode) copy() Node {
+	c := *n
+	return &c
+}
+func (n *typeNode) doChildren(do func(Node) error) error {
+	var err error
+	return err
+}
+func (n *typeNode) editChildren(edit func(Node) Node) {
+}
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index c859fae55b..19f90ce1fa 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -7,7 +7,6 @@ package ir
 import (
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
-	"fmt"
 )
 
 // A Decl is a declaration of a const, type, or var. (A declared func is a Func.)
@@ -28,18 +27,6 @@ func NewDecl(pos src.XPos, op Op, x Node) *Decl {
 	return n
 }
 
-func (n *Decl) String() string                { return fmt.Sprint(n) }
-func (n *Decl) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *Decl) copy() Node                    { c := *n; return &c }
-func (n *Decl) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDo(n.X, err, do)
-	return err
-}
-func (n *Decl) editChildren(edit func(Node) Node) {
-	n.X = maybeEdit(n.X, edit)
-}
-
 func (n *Decl) Left() Node     { return n.X }
 func (n *Decl) SetLeft(x Node) { n.X = x }
 
@@ -76,28 +63,6 @@ func NewAssignListStmt(pos src.XPos, lhs, rhs []Node) *AssignListStmt {
 	return n
 }
 
-func (n *AssignListStmt) String() string                { return fmt.Sprint(n) }
-func (n *AssignListStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *AssignListStmt) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	c.Lhs = c.Lhs.Copy()
-	c.Rhs = c.Rhs.Copy()
-	return &c
-}
-func (n *AssignListStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDoList(n.Lhs, err, do)
-	err = maybeDoList(n.Rhs, err, do)
-	return err
-}
-func (n *AssignListStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	editList(n.Lhs, edit)
-	editList(n.Rhs, edit)
-}
-
 func (n *AssignListStmt) List() Nodes       { return n.Lhs }
 func (n *AssignListStmt) PtrList() *Nodes   { return &n.Lhs }
 func (n *AssignListStmt) SetList(x Nodes)   { n.Lhs = x }
@@ -136,26 +101,6 @@ func NewAssignStmt(pos src.XPos, x, y Node) *AssignStmt {
 	return n
 }
 
-func (n *AssignStmt) String() string                { return fmt.Sprint(n) }
-func (n *AssignStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *AssignStmt) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *AssignStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	err = maybeDo(n.Y, err, do)
-	return err
-}
-func (n *AssignStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-	n.Y = maybeEdit(n.Y, edit)
-}
-
 func (n *AssignStmt) Left() Node        { return n.X }
 func (n *AssignStmt) SetLeft(x Node)    { n.X = x }
 func (n *AssignStmt) Right() Node       { return n.Y }
@@ -191,26 +136,6 @@ func NewAssignOpStmt(pos src.XPos, op Op, x, y Node) *AssignOpStmt {
 	return n
 }
 
-func (n *AssignOpStmt) String() string                { return fmt.Sprint(n) }
-func (n *AssignOpStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *AssignOpStmt) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *AssignOpStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	err = maybeDo(n.Y, err, do)
-	return err
-}
-func (n *AssignOpStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-	n.Y = maybeEdit(n.Y, edit)
-}
-
 func (n *AssignOpStmt) Left() Node            { return n.X }
 func (n *AssignOpStmt) SetLeft(x Node)        { n.X = x }
 func (n *AssignOpStmt) Right() Node           { return n.Y }
@@ -236,25 +161,6 @@ func NewBlockStmt(pos src.XPos, list []Node) *BlockStmt {
 	return n
 }
 
-func (n *BlockStmt) String() string                { return fmt.Sprint(n) }
-func (n *BlockStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *BlockStmt) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	c.list = c.list.Copy()
-	return &c
-}
-func (n *BlockStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDoList(n.list, err, do)
-	return err
-}
-func (n *BlockStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	editList(n.list, edit)
-}
-
 func (n *BlockStmt) List() Nodes     { return n.list }
 func (n *BlockStmt) PtrList() *Nodes { return &n.list }
 func (n *BlockStmt) SetList(x Nodes) { n.list = x }
@@ -281,22 +187,6 @@ func NewBranchStmt(pos src.XPos, op Op, label *types.Sym) *BranchStmt {
 	return n
 }
 
-func (n *BranchStmt) String() string                { return fmt.Sprint(n) }
-func (n *BranchStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *BranchStmt) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *BranchStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	return err
-}
-func (n *BranchStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-}
-
 func (n *BranchStmt) Sym() *types.Sym       { return n.Label }
 func (n *BranchStmt) SetSym(sym *types.Sym) { n.Label = sym }
 
@@ -318,33 +208,6 @@ func NewCaseStmt(pos src.XPos, list, body []Node) *CaseStmt {
 	return n
 }
 
-func (n *CaseStmt) String() string                { return fmt.Sprint(n) }
-func (n *CaseStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *CaseStmt) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	c.Vars = c.Vars.Copy()
-	c.list = c.list.Copy()
-	c.body = c.body.Copy()
-	return &c
-}
-func (n *CaseStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDoList(n.Vars, err, do)
-	err = maybeDoList(n.list, err, do)
-	err = maybeDo(n.Comm, err, do)
-	err = maybeDoList(n.body, err, do)
-	return err
-}
-func (n *CaseStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	editList(n.Vars, edit)
-	editList(n.list, edit)
-	n.Comm = maybeEdit(n.Comm, edit)
-	editList(n.body, edit)
-}
-
 func (n *CaseStmt) List() Nodes      { return n.list }
 func (n *CaseStmt) PtrList() *Nodes  { return &n.list }
 func (n *CaseStmt) SetList(x Nodes)  { n.list = x }
@@ -370,24 +233,6 @@ func NewDeferStmt(pos src.XPos, call Node) *DeferStmt {
 	return n
 }
 
-func (n *DeferStmt) String() string                { return fmt.Sprint(n) }
-func (n *DeferStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *DeferStmt) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *DeferStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.Call, err, do)
-	return err
-}
-func (n *DeferStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.Call = maybeEdit(n.Call, edit)
-}
-
 func (n *DeferStmt) Left() Node     { return n.Call }
 func (n *DeferStmt) SetLeft(x Node) { n.Call = x }
 
@@ -412,32 +257,6 @@ func NewForStmt(pos src.XPos, init []Node, cond, post Node, body []Node) *ForStm
 	return n
 }
 
-func (n *ForStmt) String() string                { return fmt.Sprint(n) }
-func (n *ForStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ForStmt) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	c.Late = c.Late.Copy()
-	c.body = c.body.Copy()
-	return &c
-}
-func (n *ForStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.Cond, err, do)
-	err = maybeDoList(n.Late, err, do)
-	err = maybeDo(n.Post, err, do)
-	err = maybeDoList(n.body, err, do)
-	return err
-}
-func (n *ForStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.Cond = maybeEdit(n.Cond, edit)
-	editList(n.Late, edit)
-	n.Post = maybeEdit(n.Post, edit)
-	editList(n.body, edit)
-}
-
 func (n *ForStmt) Sym() *types.Sym     { return n.Label }
 func (n *ForStmt) SetSym(x *types.Sym) { n.Label = x }
 func (n *ForStmt) Left() Node          { return n.Cond }
@@ -473,24 +292,6 @@ func NewGoStmt(pos src.XPos, call Node) *GoStmt {
 	return n
 }
 
-func (n *GoStmt) String() string                { return fmt.Sprint(n) }
-func (n *GoStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *GoStmt) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *GoStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.Call, err, do)
-	return err
-}
-func (n *GoStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.Call = maybeEdit(n.Call, edit)
-}
-
 func (n *GoStmt) Left() Node     { return n.Call }
 func (n *GoStmt) SetLeft(x Node) { n.Call = x }
 
@@ -512,30 +313,6 @@ func NewIfStmt(pos src.XPos, cond Node, body, els []Node) *IfStmt {
 	return n
 }
 
-func (n *IfStmt) String() string                { return fmt.Sprint(n) }
-func (n *IfStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *IfStmt) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	c.body = c.body.Copy()
-	c.Else = c.Else.Copy()
-	return &c
-}
-func (n *IfStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.Cond, err, do)
-	err = maybeDoList(n.body, err, do)
-	err = maybeDoList(n.Else, err, do)
-	return err
-}
-func (n *IfStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.Cond = maybeEdit(n.Cond, edit)
-	editList(n.body, edit)
-	editList(n.Else, edit)
-}
-
 func (n *IfStmt) Left() Node       { return n.Cond }
 func (n *IfStmt) SetLeft(x Node)   { n.Cond = x }
 func (n *IfStmt) Body() Nodes      { return n.body }
@@ -560,22 +337,6 @@ func NewInlineMarkStmt(pos src.XPos, index int64) *InlineMarkStmt {
 	return n
 }
 
-func (n *InlineMarkStmt) String() string                { return fmt.Sprint(n) }
-func (n *InlineMarkStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *InlineMarkStmt) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *InlineMarkStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	return err
-}
-func (n *InlineMarkStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-}
-
 func (n *InlineMarkStmt) Offset() int64     { return n.Index }
 func (n *InlineMarkStmt) SetOffset(x int64) { n.Index = x }
 
@@ -592,22 +353,6 @@ func NewLabelStmt(pos src.XPos, label *types.Sym) *LabelStmt {
 	return n
 }
 
-func (n *LabelStmt) String() string                { return fmt.Sprint(n) }
-func (n *LabelStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *LabelStmt) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *LabelStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	return err
-}
-func (n *LabelStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-}
-
 func (n *LabelStmt) Sym() *types.Sym     { return n.Label }
 func (n *LabelStmt) SetSym(x *types.Sym) { n.Label = x }
 
@@ -633,30 +378,6 @@ func NewRangeStmt(pos src.XPos, vars []Node, x Node, body []Node) *RangeStmt {
 	return n
 }
 
-func (n *RangeStmt) String() string                { return fmt.Sprint(n) }
-func (n *RangeStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *RangeStmt) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	c.Vars = c.Vars.Copy()
-	c.body = c.body.Copy()
-	return &c
-}
-func (n *RangeStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDoList(n.Vars, err, do)
-	err = maybeDo(n.X, err, do)
-	err = maybeDoList(n.body, err, do)
-	return err
-}
-func (n *RangeStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	editList(n.Vars, edit)
-	n.X = maybeEdit(n.X, edit)
-	editList(n.body, edit)
-}
-
 func (n *RangeStmt) Sym() *types.Sym       { return n.Label }
 func (n *RangeStmt) SetSym(x *types.Sym)   { n.Label = x }
 func (n *RangeStmt) Right() Node           { return n.X }
@@ -690,25 +411,6 @@ func NewReturnStmt(pos src.XPos, results []Node) *ReturnStmt {
 	return n
 }
 
-func (n *ReturnStmt) String() string                { return fmt.Sprint(n) }
-func (n *ReturnStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ReturnStmt) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	c.Results = c.Results.Copy()
-	return &c
-}
-func (n *ReturnStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDoList(n.Results, err, do)
-	return err
-}
-func (n *ReturnStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	editList(n.Results, edit)
-}
-
 func (n *ReturnStmt) Orig() Node      { return n.orig }
 func (n *ReturnStmt) SetOrig(x Node)  { n.orig = x }
 func (n *ReturnStmt) List() Nodes     { return n.Results }
@@ -735,28 +437,6 @@ func NewSelectStmt(pos src.XPos, cases []Node) *SelectStmt {
 	return n
 }
 
-func (n *SelectStmt) String() string                { return fmt.Sprint(n) }
-func (n *SelectStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *SelectStmt) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	c.Cases = c.Cases.Copy()
-	c.Compiled = c.Compiled.Copy()
-	return &c
-}
-func (n *SelectStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDoList(n.Cases, err, do)
-	err = maybeDoList(n.Compiled, err, do)
-	return err
-}
-func (n *SelectStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	editList(n.Cases, edit)
-	editList(n.Compiled, edit)
-}
-
 func (n *SelectStmt) List() Nodes         { return n.Cases }
 func (n *SelectStmt) PtrList() *Nodes     { return &n.Cases }
 func (n *SelectStmt) SetList(x Nodes)     { n.Cases = x }
@@ -782,26 +462,6 @@ func NewSendStmt(pos src.XPos, ch, value Node) *SendStmt {
 	return n
 }
 
-func (n *SendStmt) String() string                { return fmt.Sprint(n) }
-func (n *SendStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *SendStmt) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *SendStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.Chan, err, do)
-	err = maybeDo(n.Value, err, do)
-	return err
-}
-func (n *SendStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.Chan = maybeEdit(n.Chan, edit)
-	n.Value = maybeEdit(n.Value, edit)
-}
-
 func (n *SendStmt) Left() Node      { return n.Chan }
 func (n *SendStmt) SetLeft(x Node)  { n.Chan = x }
 func (n *SendStmt) Right() Node     { return n.Value }
@@ -827,30 +487,6 @@ func NewSwitchStmt(pos src.XPos, tag Node, cases []Node) *SwitchStmt {
 	return n
 }
 
-func (n *SwitchStmt) String() string                { return fmt.Sprint(n) }
-func (n *SwitchStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *SwitchStmt) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	c.Cases = c.Cases.Copy()
-	c.Compiled = c.Compiled.Copy()
-	return &c
-}
-func (n *SwitchStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.Tag, err, do)
-	err = maybeDoList(n.Cases, err, do)
-	err = maybeDoList(n.Compiled, err, do)
-	return err
-}
-func (n *SwitchStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.Tag = maybeEdit(n.Tag, edit)
-	editList(n.Cases, edit)
-	editList(n.Compiled, edit)
-}
-
 func (n *SwitchStmt) Left() Node          { return n.Tag }
 func (n *SwitchStmt) SetLeft(x Node)      { n.Tag = x }
 func (n *SwitchStmt) List() Nodes         { return n.Cases }
@@ -881,24 +517,6 @@ func NewTypeSwitchGuard(pos src.XPos, name, x Node) *TypeSwitchGuard {
 	return n
 }
 
-func (n *TypeSwitchGuard) String() string                { return fmt.Sprint(n) }
-func (n *TypeSwitchGuard) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *TypeSwitchGuard) copy() Node                    { c := *n; return &c }
-func (n *TypeSwitchGuard) doChildren(do func(Node) error) error {
-	var err error
-	if n.name != nil {
-		err = maybeDo(n.name, err, do)
-	}
-	err = maybeDo(n.X, err, do)
-	return err
-}
-func (n *TypeSwitchGuard) editChildren(edit func(Node) Node) {
-	if n.name != nil {
-		n.name = edit(n.name).(*Name)
-	}
-	n.X = maybeEdit(n.X, edit)
-}
-
 func (n *TypeSwitchGuard) Left() Node {
 	if n.name == nil {
 		return nil
diff --git a/src/cmd/compile/internal/ir/type.go b/src/cmd/compile/internal/ir/type.go
index 9f82c9faa2..5e6d76229d 100644
--- a/src/cmd/compile/internal/ir/type.go
+++ b/src/cmd/compile/internal/ir/type.go
@@ -72,17 +72,6 @@ func NewChanType(pos src.XPos, elem Node, dir types.ChanDir) *ChanType {
 	return n
 }
 
-func (n *ChanType) String() string                { return fmt.Sprint(n) }
-func (n *ChanType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ChanType) copy() Node                    { c := *n; return &c }
-func (n *ChanType) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDo(n.Elem, err, do)
-	return err
-}
-func (n *ChanType) editChildren(edit func(Node) Node) {
-	n.Elem = maybeEdit(n.Elem, edit)
-}
 func (n *ChanType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
 	n.Elem = nil
@@ -102,19 +91,6 @@ func NewMapType(pos src.XPos, key, elem Node) *MapType {
 	return n
 }
 
-func (n *MapType) String() string                { return fmt.Sprint(n) }
-func (n *MapType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *MapType) copy() Node                    { c := *n; return &c }
-func (n *MapType) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDo(n.Key, err, do)
-	err = maybeDo(n.Elem, err, do)
-	return err
-}
-func (n *MapType) editChildren(edit func(Node) Node) {
-	n.Key = maybeEdit(n.Key, edit)
-	n.Elem = maybeEdit(n.Elem, edit)
-}
 func (n *MapType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
 	n.Key = nil
@@ -134,22 +110,6 @@ func NewStructType(pos src.XPos, fields []*Field) *StructType {
 	return n
 }
 
-func (n *StructType) String() string                { return fmt.Sprint(n) }
-func (n *StructType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *StructType) copy() Node {
-	c := *n
-	c.Fields = copyFields(c.Fields)
-	return &c
-}
-func (n *StructType) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoFields(n.Fields, err, do)
-	return err
-}
-func (n *StructType) editChildren(edit func(Node) Node) {
-	editFields(n.Fields, edit)
-}
-
 func (n *StructType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
 	n.Fields = nil
@@ -176,22 +136,6 @@ func NewInterfaceType(pos src.XPos, methods []*Field) *InterfaceType {
 	return n
 }
 
-func (n *InterfaceType) String() string                { return fmt.Sprint(n) }
-func (n *InterfaceType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *InterfaceType) copy() Node {
-	c := *n
-	c.Methods = copyFields(c.Methods)
-	return &c
-}
-func (n *InterfaceType) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoFields(n.Methods, err, do)
-	return err
-}
-func (n *InterfaceType) editChildren(edit func(Node) Node) {
-	editFields(n.Methods, edit)
-}
-
 func (n *InterfaceType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
 	n.Methods = nil
@@ -212,30 +156,6 @@ func NewFuncType(pos src.XPos, rcvr *Field, args, results []*Field) *FuncType {
 	return n
 }
 
-func (n *FuncType) String() string                { return fmt.Sprint(n) }
-func (n *FuncType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *FuncType) copy() Node {
-	c := *n
-	if c.Recv != nil {
-		c.Recv = c.Recv.copy()
-	}
-	c.Params = copyFields(c.Params)
-	c.Results = copyFields(c.Results)
-	return &c
-}
-func (n *FuncType) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoField(n.Recv, err, do)
-	err = maybeDoFields(n.Params, err, do)
-	err = maybeDoFields(n.Results, err, do)
-	return err
-}
-func (n *FuncType) editChildren(edit func(Node) Node) {
-	editField(n.Recv, edit)
-	editFields(n.Params, edit)
-	editFields(n.Results, edit)
-}
-
 func (n *FuncType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
 	n.Recv = nil
@@ -365,17 +285,6 @@ func NewSliceType(pos src.XPos, elem Node) *SliceType {
 	return n
 }
 
-func (n *SliceType) String() string                { return fmt.Sprint(n) }
-func (n *SliceType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *SliceType) copy() Node                    { c := *n; return &c }
-func (n *SliceType) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDo(n.Elem, err, do)
-	return err
-}
-func (n *SliceType) editChildren(edit func(Node) Node) {
-	n.Elem = maybeEdit(n.Elem, edit)
-}
 func (n *SliceType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
 	n.Elem = nil
@@ -396,20 +305,6 @@ func NewArrayType(pos src.XPos, size Node, elem Node) *ArrayType {
 	return n
 }
 
-func (n *ArrayType) String() string                { return fmt.Sprint(n) }
-func (n *ArrayType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ArrayType) copy() Node                    { c := *n; return &c }
-func (n *ArrayType) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDo(n.Len, err, do)
-	err = maybeDo(n.Elem, err, do)
-	return err
-}
-func (n *ArrayType) editChildren(edit func(Node) Node) {
-	n.Len = maybeEdit(n.Len, edit)
-	n.Elem = maybeEdit(n.Elem, edit)
-}
-
 func (n *ArrayType) SetOTYPE(t *types.Type) {
 	n.setOTYPE(t, n)
 	n.Len = nil
@@ -429,14 +324,6 @@ func newTypeNode(pos src.XPos, typ *types.Type) *typeNode {
 	return n
 }
 
-func (n *typeNode) String() string                { return fmt.Sprint(n) }
-func (n *typeNode) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *typeNode) copy() Node                    { c := *n; return &c }
-func (n *typeNode) doChildren(do func(Node) error) error {
-	return nil
-}
-func (n *typeNode) editChildren(edit func(Node) Node) {}
-
 func (n *typeNode) Type() *types.Type { return n.typ }
 func (n *typeNode) Sym() *types.Sym   { return n.typ.Sym() }
 func (n *typeNode) CanBeNtype()       {}
-- 
GitLab


From dcc640e8391d6d022b595a3b53124bbcbd985c76 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 4 Dec 2020 12:40:39 -0500
Subject: [PATCH 0168/2400] [dev.regabi] test: add exhaustive test of evaluated
 but not used

Change-Id: I49db03c88b7595f1ea593df568244ad6aad3b024
Reviewed-on: https://go-review.googlesource.com/c/go/+/275443
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 test/used.go | 142 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 142 insertions(+)
 create mode 100644 test/used.go

diff --git a/test/used.go b/test/used.go
new file mode 100644
index 0000000000..adf2bfcb95
--- /dev/null
+++ b/test/used.go
@@ -0,0 +1,142 @@
+// errorcheck
+
+// Copyright 2020 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 p
+
+import "unsafe"
+
+const C = 1
+
+var x1, x int
+var b bool
+var s string
+var c chan int
+var cp complex128
+var slice []int
+var array [2]int
+var bytes []byte
+var runes []rune
+var r rune
+
+func f0()            {}
+func f1() int        { return 1 }
+func f2() (int, int) { return 1, 1 }
+
+type T struct{ X int }
+
+func (T) M1() int { return 1 }
+func (T) M0()     {}
+func (T) M()      {}
+
+var t T
+var tp *T
+
+type I interface{ M() }
+
+var i I
+
+var m map[int]int
+
+func _() {
+	// Note: if the next line changes to x, the error silences the x+x etc below!
+	x1 // ERROR "x1 evaluated but not used"
+
+	nil                    // ERROR "nil evaluated but not used"
+	C                      // ERROR  "C evaluated but not used"
+	1                      // ERROR "1 evaluated but not used"
+	x + x                  // ERROR "x \+ x evaluated but not used"
+	x - x                  // ERROR "x - x evaluated but not used"
+	x | x                  // ERROR "x \| x evaluated but not used"
+	"a" + s                // ERROR ".a. \+ s evaluated but not used"
+	&x                     // ERROR "&x evaluated but not used"
+	b && b                 // ERROR "b && b evaluated but not used"
+	append(slice, 1)       // ERROR "append\(slice, 1\) evaluated but not used"
+	string(bytes)          // ERROR "string\(bytes\) evaluated but not used"
+	string(runes)          // ERROR "string\(runes\) evaluated but not used"
+	f0()                   // ok
+	f1()                   // ok
+	f2()                   // ok
+	_ = f0()               // ERROR "f0\(\) used as value"
+	_ = f1()               // ok
+	_, _ = f2()            // ok
+	_ = f2()               // ERROR "assignment mismatch: 1 variable but f2 returns 2 values"
+	T.M0                   // ERROR "T.M0 evaluated but not used"
+	t.M0                   // ERROR "t.M0 evaluated but not used"
+	cap                    // ERROR "use of builtin cap not in function call"
+	cap(slice)             // ERROR "cap\(slice\) evaluated but not used"
+	close(c)               // ok
+	_ = close(c)           // ERROR "close\(c\) used as value"
+	func() {}              // ERROR "func literal evaluated but not used"
+	X{}                    // ERROR "undefined: X"
+	map[string]int{}       // ERROR "map\[string\]int{} evaluated but not used"
+	struct{}{}             // ERROR "struct ?{}{} evaluated but not used"
+	[1]int{}               // ERROR "\[1\]int{} evaluated but not used"
+	[]int{}                // ERROR "\[\]int{} evaluated but not used"
+	&struct{}{}            // ERROR "&struct ?{}{} evaluated but not used"
+	float32(x)             // ERROR "float32\(x\) evaluated but not used"
+	I(t)                   // ERROR "I\(t\) evaluated but not used"
+	int(x)                 // ERROR "int\(x\) evaluated but not used"
+	copy(slice, slice)     // ok
+	_ = copy(slice, slice) // ok
+	delete(m, 1)           // ok
+	_ = delete(m, 1)       // ERROR "delete\(m, 1\) used as value"
+	t.X                    // ERROR "t.X evaluated but not used"
+	tp.X                   // ERROR "tp.X evaluated but not used"
+	t.M                    // ERROR "t.M evaluated but not used"
+	I.M                    // ERROR "I.M evaluated but not used"
+	i.(T)                  // ERROR "i.\(T\) evaluated but not used"
+	x == x                 // ERROR "x == x evaluated but not used"
+	x != x                 // ERROR "x != x evaluated but not used"
+	x != x                 // ERROR "x != x evaluated but not used"
+	x < x                  // ERROR "x < x evaluated but not used"
+	x >= x                 // ERROR "x >= x evaluated but not used"
+	x > x                  // ERROR "x > x evaluated but not used"
+	*tp                    // ERROR "\*tp evaluated but not used"
+	slice[0]               // ERROR "slice\[0\] evaluated but not used"
+	m[1]                   // ERROR "m\[1\] evaluated but not used"
+	len(slice)             // ERROR "len\(slice\) evaluated but not used"
+	make(chan int)         // ERROR "make\(chan int\) evaluated but not used"
+	make(map[int]int)      // ERROR "make\(map\[int\]int\) evaluated but not used"
+	make([]int, 1)         // ERROR "make\(\[\]int, 1\) evaluated but not used"
+	x * x                  // ERROR "x \* x evaluated but not used"
+	x / x                  // ERROR "x / x evaluated but not used"
+	x % x                  // ERROR "x % x evaluated but not used"
+	x << x                 // ERROR "x << x evaluated but not used"
+	x >> x                 // ERROR "x >> x evaluated but not used"
+	x & x                  // ERROR "x & x evaluated but not used"
+	x &^ x                 // ERROR "x &\^ x evaluated but not used"
+	new(int)               // ERROR "new\(int\) evaluated but not used"
+	!b                     // ERROR "!b evaluated but not used"
+	^x                     // ERROR "\^x evaluated but not used"
+	+x                     // ERROR "\+x evaluated but not used"
+	-x                     // ERROR "-x evaluated but not used"
+	b || b                 // ERROR "b \|\| b evaluated but not used"
+	panic(1)               // ok
+	_ = panic(1)           // ERROR "panic\(1\) used as value"
+	print(1)               // ok
+	_ = print(1)           // ERROR "print\(1\) used as value"
+	println(1)             // ok
+	_ = println(1)         // ERROR "println\(1\) used as value"
+	(x)                    // ERROR "x evaluated but not used"
+	c <- 1                 // ok
+	slice[1:1]             // ERROR "slice\[1:1\] evaluated but not used"
+	array[1:1]             // ERROR "array\[1:1\] evaluated but not used"
+	s[1:1]                 // ERROR "s\[1:1\] evaluated but not used"
+	slice[1:1:1]           // ERROR "slice\[1:1:1\] evaluated but not used"
+	array[1:1:1]           // ERROR "array\[1:1:1\] evaluated but not used"
+	recover()              // ok
+	<-c                    // ok
+	string(r)              // ERROR "string\(r\) evaluated but not used"
+	iota                   // ERROR "undefined: iota"
+	real(cp)               // ERROR "real\(cp\) evaluated but not used"
+	imag(cp)               // ERROR "imag\(cp\) evaluated but not used"
+	complex(1, 2)          // ERROR "complex\(1, 2\) evaluated but not used"
+	unsafe.Alignof(t.X)    // ERROR "unsafe.Alignof\(t.X\) evaluated but not used"
+	unsafe.Offsetof(t.X)   // ERROR "unsafe.Offsetof\(t.X\) evaluated but not used"
+	unsafe.Sizeof(t)       // ERROR "unsafe.Sizeof\(t\) evaluated but not used"
+	_ = new(x)             // ERROR "x is not a type"
+	_ = int                // ERROR "type int is not an expression"
+}
-- 
GitLab


From ef5964dd6b092f7e0d9bd4332a5d258eb80ecef8 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 4 Dec 2020 11:37:54 -0500
Subject: [PATCH 0169/2400] [dev.regabi] cmd/compile: arrange for typecheck1 to
 end in switch

Ending typecheck1 in the switch makes it safe for each case
to do an appropriate type assertion. The main change is dropping
the computation of "ok" and using the syntax nodes themselves
to decide what's OK.

Passes buildall w/ toolstash -cmp.

Change-Id: I2a1873a51e3f1194d74bb87a6653cb9857a02a1b
Reviewed-on: https://go-review.googlesource.com/c/go/+/275444
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/typecheck.go | 336 +++++++++++------------
 src/cmd/compile/internal/ir/expr.go      |  12 +-
 src/cmd/compile/internal/ir/func.go      |   2 +
 src/cmd/compile/internal/ir/name.go      |   2 +
 src/cmd/compile/internal/ir/stmt.go      |  11 +
 test/used.go                             |   7 +-
 6 files changed, 195 insertions(+), 175 deletions(-)

diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index c22786f148..dc9e23069e 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -307,17 +307,91 @@ func typecheck(n ir.Node, top int) (res ir.Node) {
 		return n
 	}
 
-	n.SetTypecheck(2)
-
 	typecheck_tcstack = append(typecheck_tcstack, n)
-	n = typecheck1(n, top)
 
+	n.SetTypecheck(2)
+	n = typecheck1(n, top)
 	n.SetTypecheck(1)
 
 	last := len(typecheck_tcstack) - 1
 	typecheck_tcstack[last] = nil
 	typecheck_tcstack = typecheck_tcstack[:last]
 
+	_, isExpr := n.(ir.Expr)
+	_, isStmt := n.(ir.Stmt)
+	isMulti := false
+	switch n.Op() {
+	case ir.OCALLFUNC, ir.OCALLINTER, ir.OCALLMETH:
+		if t := n.Left().Type(); t != nil && t.Kind() == types.TFUNC {
+			nr := t.NumResults()
+			isMulti = nr > 1
+			if nr == 0 {
+				isExpr = false
+			}
+		}
+	case ir.OAPPEND:
+		// Must be used (and not BinaryExpr/UnaryExpr).
+		isStmt = false
+	case ir.OCLOSE, ir.ODELETE, ir.OPANIC, ir.OPRINT, ir.OPRINTN, ir.OVARKILL, ir.OVARLIVE:
+		// Must not be used.
+		isExpr = false
+		isStmt = true
+	case ir.OCOPY, ir.ORECOVER, ir.ORECV:
+		// Can be used or not.
+		isStmt = true
+	}
+
+	t := n.Type()
+	if t != nil && !t.IsFuncArgStruct() && n.Op() != ir.OTYPE {
+		switch t.Kind() {
+		case types.TFUNC, // might have TANY; wait until it's called
+			types.TANY, types.TFORW, types.TIDEAL, types.TNIL, types.TBLANK:
+			break
+
+		default:
+			checkwidth(t)
+		}
+	}
+	if t != nil {
+		n = evalConst(n)
+		t = n.Type()
+	}
+
+	// TODO(rsc): Lots of the complexity here is because typecheck can
+	// see OTYPE, ONAME, and OLITERAL nodes multiple times.
+	// Once we make the IR a proper tree, we should be able to simplify
+	// this code a bit, especially the final case.
+	switch {
+	case top&(ctxStmt|ctxExpr) == ctxExpr && !isExpr && n.Op() != ir.OTYPE && !isMulti:
+		if !n.Diag() {
+			base.Errorf("%v used as value", n)
+			n.SetDiag(true)
+		}
+		if t != nil {
+			n.SetType(nil)
+		}
+
+	case top&ctxType == 0 && n.Op() == ir.OTYPE && t != nil:
+		if !n.Type().Broke() {
+			base.Errorf("type %v is not an expression", n.Type())
+		}
+		n.SetType(nil)
+
+	case top&(ctxStmt|ctxExpr) == ctxStmt && !isStmt && t != nil:
+		if !n.Diag() {
+			base.Errorf("%v evaluated but not used", n)
+			n.SetDiag(true)
+		}
+		n.SetType(nil)
+
+	case top&(ctxType|ctxExpr) == ctxType && n.Op() != ir.OTYPE && n.Op() != ir.ONONAME && (t != nil || n.Op() == ir.ONAME):
+		base.Errorf("%v is not a type", n)
+		if t != nil {
+			n.SetType(nil)
+		}
+
+	}
+
 	base.Pos = lno
 	return n
 }
@@ -335,8 +409,7 @@ func indexlit(n ir.Node) ir.Node {
 	return n
 }
 
-// The result of typecheck1 MUST be assigned back to n, e.g.
-// 	n.Left = typecheck1(n.Left, top)
+// typecheck1 should ONLY be called from typecheck.
 func typecheck1(n ir.Node, top int) (res ir.Node) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheck1", n)(&res)
@@ -345,7 +418,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 	switch n.Op() {
 	case ir.OLITERAL, ir.ONAME, ir.ONONAME, ir.OTYPE:
 		if n.Sym() == nil {
-			break
+			return n
 		}
 
 		if n.Op() == ir.ONAME && n.SubOp() != 0 && top&ctxCallee == 0 {
@@ -361,34 +434,29 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 	}
 
-	ok := 0
 	switch n.Op() {
-	// until typecheck is complete, do nothing.
 	default:
 		ir.Dump("typecheck", n)
-
 		base.Fatalf("typecheck %v", n.Op())
+		panic("unreachable")
 
 	// names
 	case ir.OLITERAL:
-		ok |= ctxExpr
-
 		if n.Type() == nil && n.Val().Kind() == constant.String {
 			base.Fatalf("string literal missing type")
 		}
+		return n
 
 	case ir.ONIL, ir.ONONAME:
-		ok |= ctxExpr
+		return n
 
 	case ir.ONAME:
 		if n.Name().Decldepth == 0 {
 			n.Name().Decldepth = decldepth
 		}
 		if n.SubOp() != 0 {
-			ok |= ctxCallee
-			break
+			return n
 		}
-
 		if top&ctxAssign == 0 {
 			// not a write to the variable
 			if ir.IsBlank(n) {
@@ -396,11 +464,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				n.SetType(nil)
 				return n
 			}
-
 			n.Name().SetUsed(true)
 		}
-
-		ok |= ctxExpr
+		return n
 
 	case ir.OPACK:
 		base.Errorf("use of package %v without selector", n.Sym())
@@ -409,14 +475,12 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	// types (ODEREF is with exprs)
 	case ir.OTYPE:
-		ok |= ctxType
-
 		if n.Type() == nil {
 			return n
 		}
+		return n
 
 	case ir.OTSLICE:
-		ok |= ctxType
 		n := n.(*ir.SliceType)
 		n.Elem = typecheck(n.Elem, ctxType)
 		if n.Elem.Type() == nil {
@@ -425,9 +489,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		t := types.NewSlice(n.Elem.Type())
 		n.SetOTYPE(t)
 		checkwidth(t)
+		return n
 
 	case ir.OTARRAY:
-		ok |= ctxType
 		n := n.(*ir.ArrayType)
 		n.Elem = typecheck(n.Elem, ctxType)
 		if n.Elem.Type() == nil {
@@ -469,9 +533,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		t := types.NewArray(n.Elem.Type(), bound)
 		n.SetOTYPE(t)
 		checkwidth(t)
+		return n
 
 	case ir.OTMAP:
-		ok |= ctxType
 		n := n.(*ir.MapType)
 		n.Key = typecheck(n.Key, ctxType)
 		n.Elem = typecheck(n.Elem, ctxType)
@@ -488,9 +552,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 		n.SetOTYPE(types.NewMap(l.Type(), r.Type()))
 		mapqueue = append(mapqueue, n) // check map keys when all types are settled
+		return n
 
 	case ir.OTCHAN:
-		ok |= ctxType
 		n := n.(*ir.ChanType)
 		n.Elem = typecheck(n.Elem, ctxType)
 		l := n.Elem
@@ -501,21 +565,22 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			base.Errorf("chan of incomplete (or unallocatable) type not allowed")
 		}
 		n.SetOTYPE(types.NewChan(l.Type(), n.Dir))
+		return n
 
 	case ir.OTSTRUCT:
-		ok |= ctxType
 		n := n.(*ir.StructType)
 		n.SetOTYPE(tostruct(n.Fields))
+		return n
 
 	case ir.OTINTER:
-		ok |= ctxType
 		n := n.(*ir.InterfaceType)
 		n.SetOTYPE(tointerface(n.Methods))
+		return n
 
 	case ir.OTFUNC:
-		ok |= ctxType
 		n := n.(*ir.FuncType)
 		n.SetOTYPE(functype(n.Recv, n.Params, n.Results))
+		return n
 
 	// type or expr
 	case ir.ODEREF:
@@ -528,11 +593,10 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			return n
 		}
 		if l.Op() == ir.OTYPE {
-			ok |= ctxType
 			n.SetOTYPE(types.NewPtr(l.Type()))
 			// Ensure l.Type gets dowidth'd for the backend. Issue 20174.
 			checkwidth(l.Type())
-			break
+			return n
 		}
 
 		if !t.IsPtr() {
@@ -541,12 +605,12 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				n.SetType(nil)
 				return n
 			}
-
-			break
+			base.Errorf("%v is not a type", l)
+			return n
 		}
 
-		ok |= ctxExpr
 		n.SetType(t.Elem())
+		return n
 
 	// arithmetic exprs
 	case ir.OASOP,
@@ -573,7 +637,6 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		var op ir.Op
 		var r ir.Node
 		if n.Op() == ir.OASOP {
-			ok |= ctxStmt
 			n.SetLeft(typecheck(n.Left(), ctxExpr))
 			n.SetRight(typecheck(n.Right(), ctxExpr))
 			l = n.Left()
@@ -591,7 +654,6 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			// TODO(marvin): Fix Node.EType type union.
 			op = n.SubOp()
 		} else {
-			ok |= ctxExpr
 			n.SetLeft(typecheck(n.Left(), ctxExpr))
 			n.SetRight(typecheck(n.Right(), ctxExpr))
 			l = n.Left()
@@ -629,8 +691,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			if (l.Type() == types.UntypedFloat || l.Type() == types.UntypedComplex) && r.Op() == ir.OLITERAL {
 				n.SetType(types.UntypedInt)
 			}
-
-			break
+			return n
 		}
 
 		// For "x == x && len(s)", it's better to report that "len(s)" (type int)
@@ -815,9 +876,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 
 		n.SetType(t)
+		return n
 
 	case ir.OBITNOT, ir.ONEG, ir.ONOT, ir.OPLUS:
-		ok |= ctxExpr
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		l := n.Left()
 		t := l.Type()
@@ -832,11 +893,10 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 
 		n.SetType(t)
+		return n
 
 	// exprs
 	case ir.OADDR:
-		ok |= ctxExpr
-
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		if n.Left().Type() == nil {
 			n.SetType(nil)
@@ -871,13 +931,10 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 
 		n.SetType(types.NewPtr(n.Left().Type()))
+		return n
 
 	case ir.OCOMPLIT:
-		ok |= ctxExpr
-		n = typecheckcomplit(n)
-		if n.Type() == nil {
-			return n
-		}
+		return typecheckcomplit(n)
 
 	case ir.OXDOT, ir.ODOT:
 		if n.Op() == ir.OXDOT {
@@ -903,12 +960,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		s := n.Sym()
 
 		if n.Left().Op() == ir.OTYPE {
-			n = typecheckMethodExpr(n)
-			if n.Type() == nil {
-				return n
-			}
-			ok = ctxExpr
-			break
+			return typecheckMethodExpr(n)
 		}
 
 		if t.IsPtr() && !t.Elem().IsInterface() {
@@ -952,21 +1004,12 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			return n
 		}
 
-		switch n.Op() {
-		case ir.ODOTINTER, ir.ODOTMETH:
-			if top&ctxCallee != 0 {
-				ok |= ctxCallee
-			} else {
-				n = typecheckpartialcall(n, s)
-				ok |= ctxExpr
-			}
-
-		default:
-			ok |= ctxExpr
+		if (n.Op() == ir.ODOTINTER || n.Op() == ir.ODOTMETH) && top&ctxCallee == 0 {
+			n = typecheckpartialcall(n, s)
 		}
+		return n
 
 	case ir.ODOTTYPE:
-		ok |= ctxExpr
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetLeft(defaultlit(n.Left(), nil))
 		l := n.Left()
@@ -1009,9 +1052,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				return n
 			}
 		}
+		return n
 
 	case ir.OINDEX:
-		ok |= ctxExpr
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetLeft(defaultlit(n.Left(), nil))
 		n.SetLeft(implicitstar(n.Left()))
@@ -1045,7 +1088,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 			if n.Right().Type() != nil && !n.Right().Type().IsInteger() {
 				base.Errorf("non-integer %s index %v", why, n.Right())
-				break
+				return n
 			}
 
 			if !n.Bounded() && ir.IsConst(n.Right(), constant.Int) {
@@ -1067,9 +1110,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			n.SetOp(ir.OINDEXMAP)
 			n.SetIndexMapLValue(false)
 		}
+		return n
 
 	case ir.ORECV:
-		ok |= ctxStmt | ctxExpr
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetLeft(defaultlit(n.Left(), nil))
 		l := n.Left()
@@ -1091,9 +1134,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 
 		n.SetType(t.Elem())
+		return n
 
 	case ir.OSEND:
-		ok |= ctxStmt
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetRight(typecheck(n.Right(), ctxExpr))
 		n.SetLeft(defaultlit(n.Left(), nil))
@@ -1115,14 +1158,13 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		if n.Right().Type() == nil {
 			return n
 		}
+		return n
 
 	case ir.OSLICEHEADER:
 		// Errors here are Fatalf instead of Errorf because only the compiler
 		// can construct an OSLICEHEADER node.
 		// Components used in OSLICEHEADER that are supplied by parsed source code
 		// have already been typechecked in e.g. OMAKESLICE earlier.
-		ok |= ctxExpr
-
 		t := n.Type()
 		if t == nil {
 			base.Fatalf("no type specified for OSLICEHEADER")
@@ -1160,14 +1202,13 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 		n.List().SetFirst(l)
 		n.List().SetSecond(c)
+		return n
 
 	case ir.OMAKESLICECOPY:
 		// Errors here are Fatalf instead of Errorf because only the compiler
 		// can construct an OMAKESLICECOPY node.
 		// Components used in OMAKESCLICECOPY that are supplied by parsed source code
 		// have already been typechecked in OMAKE and OCOPY earlier.
-		ok |= ctxExpr
-
 		t := n.Type()
 
 		if t == nil {
@@ -1203,9 +1244,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				base.Fatalf("len for OMAKESLICECOPY must be non-negative")
 			}
 		}
+		return n
 
 	case ir.OSLICE, ir.OSLICE3:
-		ok |= ctxExpr
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		low, high, max := n.SliceBounds()
 		hasmax := n.Op().IsSlice3()
@@ -1277,6 +1318,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			n.SetType(nil)
 			return n
 		}
+		return n
 
 	// call and call like
 	case ir.OCALL:
@@ -1306,6 +1348,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			case ir.OAPPEND, ir.ODELETE, ir.OMAKE, ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
 				n.SetOp(l.SubOp())
 				n.SetLeft(nil)
+				n.SetTypecheck(0) // re-typechecking new op is OK, not a loop
 
 			case ir.OCAP, ir.OCLOSE, ir.OIMAG, ir.OLEN, ir.OPANIC, ir.OREAL:
 				typecheckargs(n)
@@ -1331,8 +1374,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				n = ir.NodAt(n.Pos(), l.SubOp(), arg1, arg2)
 				n = initExpr(old.Init().Slice(), n) // typecheckargs can add to old.Init
 			}
-			n = typecheck1(n, top)
-			return n
+			return typecheck(n, top)
 		}
 
 		n.SetLeft(defaultlit(n.Left(), nil))
@@ -1346,8 +1388,6 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			}
 
 			// pick off before type-checking arguments
-			ok |= ctxExpr
-
 			arg, ok := needOneArg(n, "conversion to %v", l.Type())
 			if !ok {
 				n.SetType(nil)
@@ -1356,8 +1396,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 			n = ir.NodAt(n.Pos(), ir.OCONV, arg, nil)
 			n.SetType(l.Type())
-			n = typecheck1(n, top)
-			return n
+			return typecheck1(n, top)
 		}
 
 		typecheckargs(n)
@@ -1403,11 +1442,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 
 		typecheckaste(ir.OCALL, n.Left(), n.IsDDD(), t.Params(), n.List(), func() string { return fmt.Sprintf("argument to %v", n.Left()) })
-		ok |= ctxStmt
 		if t.NumResults() == 0 {
-			break
+			return n
 		}
-		ok |= ctxExpr
 		if t.NumResults() == 1 {
 			n.SetType(l.Type().Results().Field(0).Type)
 
@@ -1420,24 +1457,23 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				// and we want to avoid the temporaries, so we do the rewrite earlier than is typical.
 				n.SetOp(ir.OGETG)
 			}
-
-			break
+			return n
 		}
 
 		// multiple return
 		if top&(ctxMultiOK|ctxStmt) == 0 {
 			base.Errorf("multiple-value %v() in single-value context", l)
-			break
+			return n
 		}
 
 		n.SetType(l.Type().Results())
+		return n
 
 	case ir.OALIGNOF, ir.OOFFSETOF, ir.OSIZEOF:
-		ok |= ctxExpr
 		n.SetType(types.Types[types.TUINTPTR])
+		return n
 
 	case ir.OCAP, ir.OLEN:
-		ok |= ctxExpr
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetLeft(defaultlit(n.Left(), nil))
 		n.SetLeft(implicitstar(n.Left()))
@@ -1461,9 +1497,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 
 		n.SetType(types.Types[types.TINT])
+		return n
 
 	case ir.OREAL, ir.OIMAG:
-		ok |= ctxExpr
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		l := n.Left()
 		t := l.Type()
@@ -1485,9 +1521,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			n.SetType(nil)
 			return n
 		}
+		return n
 
 	case ir.OCOMPLEX:
-		ok |= ctxExpr
 		l := typecheck(n.Left(), ctxExpr)
 		r := typecheck(n.Right(), ctxExpr)
 		if l.Type() == nil || r.Type() == nil {
@@ -1525,6 +1561,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			t = types.Types[types.TCOMPLEX128]
 		}
 		n.SetType(t)
+		return n
 
 	case ir.OCLOSE:
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
@@ -1546,11 +1583,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			n.SetType(nil)
 			return n
 		}
-
-		ok |= ctxStmt
+		return n
 
 	case ir.ODELETE:
-		ok |= ctxStmt
 		typecheckargs(n)
 		args := n.List()
 		if args.Len() == 0 {
@@ -1580,9 +1615,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 
 		args.SetSecond(assignconv(r, l.Type().Key(), "delete"))
+		return n
 
 	case ir.OAPPEND:
-		ok |= ctxExpr
 		typecheckargs(n)
 		args := n.List()
 		if args.Len() == 0 {
@@ -1625,11 +1660,11 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 			if t.Elem().IsKind(types.TUINT8) && args.Second().Type().IsString() {
 				args.SetSecond(defaultlit(args.Second(), types.Types[types.TSTRING]))
-				break
+				return n
 			}
 
 			args.SetSecond(assignconv(args.Second(), t.Underlying(), "append"))
-			break
+			return n
 		}
 
 		as := args.Slice()[1:]
@@ -1640,9 +1675,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			as[i] = assignconv(n, t.Elem(), "append")
 			checkwidth(as[i].Type()) // ensure width is calculated for backend
 		}
+		return n
 
 	case ir.OCOPY:
-		ok |= ctxStmt | ctxExpr
 		n.SetType(types.Types[types.TINT])
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetLeft(defaultlit(n.Left(), nil))
@@ -1656,7 +1691,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		// copy([]byte, string)
 		if n.Left().Type().IsSlice() && n.Right().Type().IsString() {
 			if types.Identical(n.Left().Type().Elem(), types.ByteType) {
-				break
+				return n
 			}
 			base.Errorf("arguments to copy have different element types: %L and string", n.Left().Type())
 			n.SetType(nil)
@@ -1680,9 +1715,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			n.SetType(nil)
 			return n
 		}
+		return n
 
 	case ir.OCONV:
-		ok |= ctxExpr
 		checkwidth(n.Type()) // ensure width is calculated for backend
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetLeft(convlit1(n.Left(), n.Type(), true, nil))
@@ -1717,16 +1752,16 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		// do not convert to []byte literal. See CL 125796.
 		// generated code and compiler memory footprint is better without it.
 		case ir.OSTR2BYTES:
-			break
+			// ok
 
 		case ir.OSTR2RUNES:
 			if n.Left().Op() == ir.OLITERAL {
 				n = stringtoruneslit(n)
 			}
 		}
+		return n
 
 	case ir.OMAKE:
-		ok |= ctxExpr
 		args := n.List().Slice()
 		if len(args) == 0 {
 			base.Errorf("missing argument to make")
@@ -1832,9 +1867,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 		nn.SetType(t)
 		n = nn
+		return n
 
 	case ir.ONEW:
-		ok |= ctxExpr
 		if n.Left() == nil {
 			// Fatalf because the OCALL above checked for us,
 			// so this must be an internally-generated mistake.
@@ -1849,9 +1884,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 		n.SetLeft(l)
 		n.SetType(types.NewPtr(t))
+		return n
 
 	case ir.OPRINT, ir.OPRINTN:
-		ok |= ctxStmt
 		typecheckargs(n)
 		ls := n.List().Slice()
 		for i1, n1 := range ls {
@@ -1862,18 +1897,18 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				ls[i1] = defaultlit(ls[i1], nil)
 			}
 		}
+		return n
 
 	case ir.OPANIC:
-		ok |= ctxStmt
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetLeft(defaultlit(n.Left(), types.Types[types.TINTER]))
 		if n.Left().Type() == nil {
 			n.SetType(nil)
 			return n
 		}
+		return n
 
 	case ir.ORECOVER:
-		ok |= ctxExpr | ctxStmt
 		if n.List().Len() != 0 {
 			base.Errorf("too many arguments to recover")
 			n.SetType(nil)
@@ -1881,16 +1916,16 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 
 		n.SetType(types.Types[types.TINTER])
+		return n
 
 	case ir.OCLOSURE:
-		ok |= ctxExpr
 		typecheckclosure(n, top)
 		if n.Type() == nil {
 			return n
 		}
+		return n
 
 	case ir.OITAB:
-		ok |= ctxExpr
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		t := n.Left().Type()
 		if t == nil {
@@ -1901,14 +1936,15 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			base.Fatalf("OITAB of %v", t)
 		}
 		n.SetType(types.NewPtr(types.Types[types.TUINTPTR]))
+		return n
 
 	case ir.OIDATA:
 		// Whoever creates the OIDATA node must know a priori the concrete type at that moment,
 		// usually by just having checked the OITAB.
 		base.Fatalf("cannot typecheck interface data %v", n)
+		panic("unreachable")
 
 	case ir.OSPTR:
-		ok |= ctxExpr
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		t := n.Left().Type()
 		if t == nil {
@@ -1923,33 +1959,33 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		} else {
 			n.SetType(types.NewPtr(t.Elem()))
 		}
+		return n
 
 	case ir.OCLOSUREREAD:
-		ok |= ctxExpr
+		return n
 
 	case ir.OCFUNC:
-		ok |= ctxExpr
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetType(types.Types[types.TUINTPTR])
+		return n
 
 	case ir.OCONVNOP:
-		ok |= ctxExpr
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		return n
 
 	// statements
 	case ir.OAS:
-		ok |= ctxStmt
-
 		typecheckas(n)
 
 		// Code that creates temps does not bother to set defn, so do it here.
 		if n.Left().Op() == ir.ONAME && ir.IsAutoTmp(n.Left()) {
 			n.Left().Name().Defn = n
 		}
+		return n
 
 	case ir.OAS2:
-		ok |= ctxStmt
 		typecheckas2(n)
+		return n
 
 	case ir.OBREAK,
 		ir.OCONTINUE,
@@ -1958,14 +1994,13 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		ir.OFALL,
 		ir.OVARKILL,
 		ir.OVARLIVE:
-		ok |= ctxStmt
+		return n
 
 	case ir.OBLOCK:
-		ok |= ctxStmt
 		typecheckslice(n.List().Slice(), ctxStmt)
+		return n
 
 	case ir.OLABEL:
-		ok |= ctxStmt
 		decldepth++
 		if n.Sym().IsBlank() {
 			// Empty identifier is valid but useless.
@@ -1973,21 +2008,21 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			// See issues 7538, 11589, 11593.
 			n = ir.NodAt(n.Pos(), ir.OBLOCK, nil, nil)
 		}
+		return n
 
 	case ir.ODEFER:
-		ok |= ctxStmt
 		n.SetLeft(typecheck(n.Left(), ctxStmt|ctxExpr))
 		if !n.Left().Diag() {
 			checkdefergo(n)
 		}
+		return n
 
 	case ir.OGO:
-		ok |= ctxStmt
 		n.SetLeft(typecheck(n.Left(), ctxStmt|ctxExpr))
 		checkdefergo(n)
+		return n
 
 	case ir.OFOR, ir.OFORUNTIL:
-		ok |= ctxStmt
 		typecheckslice(n.Init().Slice(), ctxStmt)
 		decldepth++
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
@@ -2004,9 +2039,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 		typecheckslice(n.Body().Slice(), ctxStmt)
 		decldepth--
+		return n
 
 	case ir.OIF:
-		ok |= ctxStmt
 		typecheckslice(n.Init().Slice(), ctxStmt)
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetLeft(defaultlit(n.Left(), nil))
@@ -2018,9 +2053,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 		typecheckslice(n.Body().Slice(), ctxStmt)
 		typecheckslice(n.Rlist().Slice(), ctxStmt)
+		return n
 
 	case ir.ORETURN:
-		ok |= ctxStmt
 		typecheckargs(n)
 		if Curfn == nil {
 			base.Errorf("return outside function")
@@ -2029,24 +2064,25 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 
 		if hasNamedResults(Curfn) && n.List().Len() == 0 {
-			break
+			return n
 		}
 		typecheckaste(ir.ORETURN, nil, false, Curfn.Type().Results(), n.List(), func() string { return "return argument" })
+		return n
 
 	case ir.ORETJMP:
-		ok |= ctxStmt
+		return n
 
 	case ir.OSELECT:
-		ok |= ctxStmt
 		typecheckselect(n)
+		return n
 
 	case ir.OSWITCH:
-		ok |= ctxStmt
 		typecheckswitch(n)
+		return n
 
 	case ir.ORANGE:
-		ok |= ctxStmt
 		typecheckrange(n)
+		return n
 
 	case ir.OTYPESW:
 		base.Errorf("use of .(type) outside type switch")
@@ -2054,64 +2090,22 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.ODCLFUNC:
-		ok |= ctxStmt
 		typecheckfunc(n.(*ir.Func))
+		return n
 
 	case ir.ODCLCONST:
-		ok |= ctxStmt
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		return n
 
 	case ir.ODCLTYPE:
-		ok |= ctxStmt
 		n.SetLeft(typecheck(n.Left(), ctxType))
 		checkwidth(n.Left().Type())
-	}
-
-	t := n.Type()
-	if t != nil && !t.IsFuncArgStruct() && n.Op() != ir.OTYPE {
-		switch t.Kind() {
-		case types.TFUNC, // might have TANY; wait until it's called
-			types.TANY, types.TFORW, types.TIDEAL, types.TNIL, types.TBLANK:
-			break
-
-		default:
-			checkwidth(t)
-		}
-	}
-
-	n = evalConst(n)
-	if n.Op() == ir.OTYPE && top&ctxType == 0 {
-		if !n.Type().Broke() {
-			base.Errorf("type %v is not an expression", n.Type())
-		}
-		n.SetType(nil)
 		return n
 	}
 
-	if top&(ctxExpr|ctxType) == ctxType && n.Op() != ir.OTYPE {
-		base.Errorf("%v is not a type", n)
-		n.SetType(nil)
-		return n
-	}
-
-	// TODO(rsc): simplify
-	if (top&(ctxCallee|ctxExpr|ctxType) != 0) && top&ctxStmt == 0 && ok&(ctxExpr|ctxType|ctxCallee) == 0 {
-		base.Errorf("%v used as value", n)
-		n.SetType(nil)
-		return n
-	}
-
-	if (top&ctxStmt != 0) && top&(ctxCallee|ctxExpr|ctxType) == 0 && ok&ctxStmt == 0 {
-		if !n.Diag() {
-			base.Errorf("%v evaluated but not used", n)
-			n.SetDiag(true)
-		}
-
-		n.SetType(nil)
-		return n
-	}
-
-	return n
+	// No return n here!
+	// Individual cases can type-assert n, introducing a new one.
+	// Each must execute its own return n.
 }
 
 func typecheckargs(n ir.Node) {
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 7b1aeedcdf..7165a06b25 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -32,7 +32,13 @@ func maybeEdit(x Node, edit func(Node) Node) Node {
 	return edit(x)
 }
 
-// A miniStmt is a miniNode with extra fields common to expressions.
+// An Expr is a Node that can appear as an expression.
+type Expr interface {
+	Node
+	isExpr()
+}
+
+// A miniExpr is a miniNode with extra fields common to expressions.
 // TODO(rsc): Once we are sure about the contents, compact the bools
 // into a bit field and leave extra bits available for implementations
 // embedding miniExpr. Right now there are ~60 unused bits sitting here.
@@ -52,6 +58,8 @@ const (
 	miniExprBounded
 )
 
+func (*miniExpr) isExpr() {}
+
 func (n *miniExpr) Type() *types.Type     { return n.typ }
 func (n *miniExpr) SetType(x *types.Type) { n.typ = x }
 func (n *miniExpr) Opt() interface{}      { return n.opt }
@@ -192,6 +200,8 @@ func NewCallExpr(pos src.XPos, fun Node, args []Node) *CallExpr {
 	return n
 }
 
+func (*CallExpr) isStmt() {}
+
 func (n *CallExpr) Orig() Node         { return n.orig }
 func (n *CallExpr) SetOrig(x Node)     { n.orig = x }
 func (n *CallExpr) Left() Node         { return n.X }
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 38e00da7da..3bca25b504 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -114,6 +114,8 @@ func NewFunc(pos src.XPos) *Func {
 	return f
 }
 
+func (f *Func) isStmt() {}
+
 func (f *Func) Func() *Func           { return f }
 func (f *Func) Body() Nodes           { return f.body }
 func (f *Func) PtrBody() *Nodes       { return &f.body }
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 06cffe0325..c527ba281d 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -121,6 +121,8 @@ type Name struct {
 	Outer     *Name
 }
 
+func (n *Name) isExpr() {}
+
 // NewNameAt returns a new ONAME Node associated with symbol s at position pos.
 // The caller is responsible for setting Curfn.
 func NewNameAt(pos src.XPos, sym *types.Sym) *Name {
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index 19f90ce1fa..836bbcb453 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -27,15 +27,26 @@ func NewDecl(pos src.XPos, op Op, x Node) *Decl {
 	return n
 }
 
+func (*Decl) isStmt() {}
+
 func (n *Decl) Left() Node     { return n.X }
 func (n *Decl) SetLeft(x Node) { n.X = x }
 
+// A Stmt is a Node that can appear as a statement.
+// This includes statement-like expressions such as <-c and f().
+type Stmt interface {
+	Node
+	isStmt()
+}
+
 // A miniStmt is a miniNode with extra fields common to statements.
 type miniStmt struct {
 	miniNode
 	init Nodes
 }
 
+func (*miniStmt) isStmt() {}
+
 func (n *miniStmt) Init() Nodes       { return n.init }
 func (n *miniStmt) SetInit(x Nodes)   { n.init = x }
 func (n *miniStmt) PtrInit() *Nodes   { return &n.init }
diff --git a/test/used.go b/test/used.go
index adf2bfcb95..5c7aad24a6 100644
--- a/test/used.go
+++ b/test/used.go
@@ -10,7 +10,7 @@ import "unsafe"
 
 const C = 1
 
-var x1, x int
+var x, x1, x2 int
 var b bool
 var s string
 var c chan int
@@ -120,7 +120,6 @@ func _() {
 	_ = print(1)           // ERROR "print\(1\) used as value"
 	println(1)             // ok
 	_ = println(1)         // ERROR "println\(1\) used as value"
-	(x)                    // ERROR "x evaluated but not used"
 	c <- 1                 // ok
 	slice[1:1]             // ERROR "slice\[1:1\] evaluated but not used"
 	array[1:1]             // ERROR "array\[1:1\] evaluated but not used"
@@ -137,6 +136,8 @@ func _() {
 	unsafe.Alignof(t.X)    // ERROR "unsafe.Alignof\(t.X\) evaluated but not used"
 	unsafe.Offsetof(t.X)   // ERROR "unsafe.Offsetof\(t.X\) evaluated but not used"
 	unsafe.Sizeof(t)       // ERROR "unsafe.Sizeof\(t\) evaluated but not used"
-	_ = new(x)             // ERROR "x is not a type"
 	_ = int                // ERROR "type int is not an expression"
+	(x)                    // ERROR "x evaluated but not used"
+	_ = new(x2)            // ERROR "x2 is not a type"
+	_ = new(1 + 1)         // ERROR "1 \+ 1 is not a type"
 }
-- 
GitLab


From a79742f39a906a52fce4873895599298c0699743 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 4 Dec 2020 18:40:24 -0500
Subject: [PATCH 0170/2400] [dev.regabi] cmd/compile: remove "short" node
 header mode

This is unreachable code - the only way short can be true is
if verb == 'S', but jconv is only called when verb == 'j'.
Simplify by removing.

Passes buildall w/ toolstash -cmp.

Change-Id: I27bd38319f72215069e940b320b5c82608e2651a
Reviewed-on: https://go-review.googlesource.com/c/go/+/275772
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/escape.go |  6 ++----
 src/cmd/compile/internal/ir/fmt.go    | 18 ++++++++----------
 2 files changed, 10 insertions(+), 14 deletions(-)

diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 32bc7b297b..a7458ab733 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -148,7 +148,7 @@ func init() {
 }
 
 // escFmt is called from node printing to print information about escape analysis results.
-func escFmt(n ir.Node, short bool) string {
+func escFmt(n ir.Node) string {
 	text := ""
 	switch n.Esc() {
 	case EscUnknown:
@@ -161,9 +161,7 @@ func escFmt(n ir.Node, short bool) string {
 		text = "esc(no)"
 
 	case EscNever:
-		if !short {
-			text = "esc(N)"
-		}
+		text = "esc(N)"
 
 	default:
 		text = fmt.Sprintf("esc(%d)", n.Esc())
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index bc5536241e..593e77880d 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -339,21 +339,19 @@ func nodeFormat(n Node, s fmt.State, verb rune, mode FmtMode) {
 }
 
 // EscFmt is set by the escape analysis code to add escape analysis details to the node print.
-var EscFmt func(n Node, short bool) string
+var EscFmt func(n Node) string
 
 // *Node details
 func jconvFmt(n Node, s fmt.State, flag FmtFlag) {
-	short := flag&FmtShort != 0
-
 	// Useful to see which nodes in an AST printout are actually identical
 	if base.Debug.DumpPtrs != 0 {
 		fmt.Fprintf(s, " p(%p)", n)
 	}
-	if !short && n.Name() != nil && n.Name().Vargen != 0 {
+	if n.Name() != nil && n.Name().Vargen != 0 {
 		fmt.Fprintf(s, " g(%d)", n.Name().Vargen)
 	}
 
-	if base.Debug.DumpPtrs != 0 && !short && n.Name() != nil && n.Name().Defn != nil {
+	if base.Debug.DumpPtrs != 0 && n.Name() != nil && n.Name().Defn != nil {
 		// Useful to see where Defn is set and what node it points to
 		fmt.Fprintf(s, " defn(%p)", n.Name().Defn)
 	}
@@ -369,7 +367,7 @@ func jconvFmt(n Node, s fmt.State, flag FmtFlag) {
 		fmt.Fprintf(s, " l(%s%d)", pfx, n.Pos().Line())
 	}
 
-	if !short && n.Offset() != types.BADWIDTH {
+	if n.Offset() != types.BADWIDTH {
 		fmt.Fprintf(s, " x(%d)", n.Offset())
 	}
 
@@ -382,12 +380,12 @@ func jconvFmt(n Node, s fmt.State, flag FmtFlag) {
 	}
 
 	if EscFmt != nil {
-		if esc := EscFmt(n, short); esc != "" {
+		if esc := EscFmt(n); esc != "" {
 			fmt.Fprintf(s, " %s", esc)
 		}
 	}
 
-	if !short && n.Typecheck() != 0 {
+	if n.Typecheck() != 0 {
 		fmt.Fprintf(s, " tc(%d)", n.Typecheck())
 	}
 
@@ -423,11 +421,11 @@ func jconvFmt(n Node, s fmt.State, flag FmtFlag) {
 		fmt.Fprint(s, " nonnil")
 	}
 
-	if !short && n.HasCall() {
+	if n.HasCall() {
 		fmt.Fprint(s, " hascall")
 	}
 
-	if !short && n.Name() != nil && n.Name().Used() {
+	if n.Name() != nil && n.Name().Used() {
 		fmt.Fprint(s, " used")
 	}
 }
-- 
GitLab


From 158c9dd131db86a381535a902b54bc7f610a8c97 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 5 Dec 2020 00:02:46 -0500
Subject: [PATCH 0171/2400] [dev.regabi] cmd/compile: reorganize ir/fmt.go

This code is a few layer of abstraction stacked up on top
of each other, and they're hard to see all at the same time
because the file is pretty mixed up. As much as I try to avoid
code rearrangement to keep history, this one is long overdue.

A followup CL will cut out some of the layers, and the diff will be
much clearer what's going on with the code ordered with
callers near callees, as it is now.

Passes buildall w/ toolstash -cmp.

Change-Id: Iffc49d43cf4be9fab47e2dd59a5f98930573350f
Reviewed-on: https://go-review.googlesource.com/c/go/+/275773
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/fmt.go  | 1416 +++++++++++++--------------
 src/cmd/compile/internal/ir/node.go |    6 +
 2 files changed, 712 insertions(+), 710 deletions(-)

diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 593e77880d..ae33dcddd7 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -19,53 +19,6 @@ import (
 	"cmd/internal/src"
 )
 
-// A FmtFlag value is a set of flags (or 0).
-// They control how the Xconv functions format their values.
-// See the respective function's documentation for details.
-type FmtFlag int
-
-const ( //                                 fmt.Format flag/prec or verb
-	FmtLeft     FmtFlag = 1 << iota // '-'
-	FmtSharp                        // '#'
-	FmtSign                         // '+'
-	FmtUnsigned                     // internal use only (historic: u flag)
-	FmtShort                        // verb == 'S'       (historic: h flag)
-	FmtLong                         // verb == 'L'       (historic: l flag)
-	FmtComma                        // '.' (== hasPrec)  (historic: , flag)
-	FmtByte                         // '0'               (historic: hh flag)
-)
-
-// fmtFlag computes the (internal) FmtFlag
-// value given the fmt.State and format verb.
-func fmtFlag(s fmt.State, verb rune) FmtFlag {
-	var flag FmtFlag
-	if s.Flag('-') {
-		flag |= FmtLeft
-	}
-	if s.Flag('#') {
-		flag |= FmtSharp
-	}
-	if s.Flag('+') {
-		flag |= FmtSign
-	}
-	if s.Flag(' ') {
-		base.Fatalf("FmtUnsigned in format string")
-	}
-	if _, ok := s.Precision(); ok {
-		flag |= FmtComma
-	}
-	if s.Flag('0') {
-		flag |= FmtByte
-	}
-	switch verb {
-	case 'S':
-		flag |= FmtShort
-	case 'L':
-		flag |= FmtLong
-	}
-	return flag
-}
-
 // Format conversions:
 // TODO(gri) verify these; eliminate those not used anymore
 //
@@ -98,12 +51,6 @@ func fmtFlag(s fmt.State, verb rune) FmtFlag {
 //			.: separate items with ',' instead of ';'
 
 // *types.Sym, *types.Type, and *Node types use the flags below to set the format mode
-const (
-	FErr FmtMode = iota
-	FDbg
-	FTypeId
-	FTypeIdName // same as FTypeId, but use package name instead of prefix
-)
 
 // The mode flags '+', '-', and '#' are sticky; they persist through
 // recursions of *Node, *types.Type, and *types.Sym values. The ' ' flag is
@@ -131,6 +78,62 @@ const (
 //   %-S    type identifiers without "func" and arg names in type signatures (methodsym)
 //   %- v   type identifiers with package name instead of prefix (typesym, dcommontype, typehash)
 
+type FmtMode int
+
+const (
+	FErr FmtMode = iota
+	FDbg
+	FTypeId
+	FTypeIdName // same as FTypeId, but use package name instead of prefix
+)
+
+// A FmtFlag value is a set of flags (or 0).
+// They control how the Xconv functions format their values.
+// See the respective function's documentation for details.
+type FmtFlag int
+
+const ( //                                 fmt.Format flag/prec or verb
+	FmtLeft     FmtFlag = 1 << iota // '-'
+	FmtSharp                        // '#'
+	FmtSign                         // '+'
+	FmtUnsigned                     // internal use only (historic: u flag)
+	FmtShort                        // verb == 'S'       (historic: h flag)
+	FmtLong                         // verb == 'L'       (historic: l flag)
+	FmtComma                        // '.' (== hasPrec)  (historic: , flag)
+	FmtByte                         // '0'               (historic: hh flag)
+)
+
+// fmtFlag computes the (internal) FmtFlag
+// value given the fmt.State and format verb.
+func fmtFlag(s fmt.State, verb rune) FmtFlag {
+	var flag FmtFlag
+	if s.Flag('-') {
+		flag |= FmtLeft
+	}
+	if s.Flag('#') {
+		flag |= FmtSharp
+	}
+	if s.Flag('+') {
+		flag |= FmtSign
+	}
+	if s.Flag(' ') {
+		base.Fatalf("FmtUnsigned in format string")
+	}
+	if _, ok := s.Precision(); ok {
+		flag |= FmtComma
+	}
+	if s.Flag('0') {
+		flag |= FmtByte
+	}
+	switch verb {
+	case 'S':
+		flag |= FmtShort
+	case 'L':
+		flag |= FmtLong
+	}
+	return flag
+}
+
 // update returns the results of applying f to mode.
 func (f FmtFlag) update(mode FmtMode) (FmtFlag, FmtMode) {
 	switch {
@@ -148,6 +151,46 @@ func (f FmtFlag) update(mode FmtMode) (FmtFlag, FmtMode) {
 	return f, mode
 }
 
+func (m FmtMode) Fprintf(s fmt.State, format string, args ...interface{}) {
+	m.prepareArgs(args)
+	fmt.Fprintf(s, format, args...)
+}
+
+func (m FmtMode) Sprintf(format string, args ...interface{}) string {
+	m.prepareArgs(args)
+	return fmt.Sprintf(format, args...)
+}
+
+func (m FmtMode) Sprint(args ...interface{}) string {
+	m.prepareArgs(args)
+	return fmt.Sprint(args...)
+}
+
+func (m FmtMode) prepareArgs(args []interface{}) {
+	for i, arg := range args {
+		switch arg := arg.(type) {
+		case Op:
+			args[i] = &fmtOp{arg, m}
+		case Node:
+			args[i] = &fmtNode{arg, m}
+		case nil:
+			args[i] = &fmtNode{nil, m} // assume this was a node interface
+		case *types.Type:
+			args[i] = &fmtType{arg, m}
+		case *types.Sym:
+			args[i] = &fmtSym{arg, m}
+		case Nodes:
+			args[i] = &fmtNodes{arg, m}
+		case int32, int64, string, types.Kind, constant.Value:
+			// OK: printing these types doesn't depend on mode
+		default:
+			base.Fatalf("mode.prepareArgs type %T", arg)
+		}
+	}
+}
+
+// Op
+
 var OpNames = []string{
 	OADDR:     "&",
 	OADD:      "+",
@@ -218,6 +261,15 @@ func (o Op) GoString() string {
 	return fmt.Sprintf("%#v", o)
 }
 
+type fmtOp struct {
+	x Op
+	m FmtMode
+}
+
+func (f *fmtOp) Format(s fmt.State, verb rune) { f.x.format(s, verb, f.m) }
+
+func (o Op) Format(s fmt.State, verb rune) { o.format(s, verb, FErr) }
+
 func (o Op) format(s fmt.State, verb rune, mode FmtMode) {
 	switch verb {
 	case 'v':
@@ -240,28 +292,48 @@ func (o Op) oconv(s fmt.State, flag FmtFlag, mode FmtMode) {
 	fmt.Fprint(s, o.String())
 }
 
-type FmtMode int
+// Val
 
-type fmtNode struct {
-	x Node
-	m FmtMode
-}
+func FmtConst(v constant.Value, flag FmtFlag) string {
+	if flag&FmtSharp == 0 && v.Kind() == constant.Complex {
+		real, imag := constant.Real(v), constant.Imag(v)
 
-func (f *fmtNode) Format(s fmt.State, verb rune) { nodeFormat(f.x, s, verb, f.m) }
+		var re string
+		sre := constant.Sign(real)
+		if sre != 0 {
+			re = real.String()
+		}
 
-type fmtOp struct {
-	x Op
-	m FmtMode
-}
+		var im string
+		sim := constant.Sign(imag)
+		if sim != 0 {
+			im = imag.String()
+		}
 
-func (f *fmtOp) Format(s fmt.State, verb rune) { f.x.format(s, verb, f.m) }
+		switch {
+		case sre == 0 && sim == 0:
+			return "0"
+		case sre == 0:
+			return im + "i"
+		case sim == 0:
+			return re
+		case sim < 0:
+			return fmt.Sprintf("(%s%si)", re, im)
+		default:
+			return fmt.Sprintf("(%s+%si)", re, im)
+		}
+	}
 
-type fmtType struct {
-	x *types.Type
-	m FmtMode
+	return v.String()
 }
 
-func (f *fmtType) Format(s fmt.State, verb rune) { typeFormat(f.x, s, verb, f.m) }
+// Sym
+
+// numImport tracks how often a package with a given name is imported.
+// It is used to provide a better error message (by using the package
+// path to disambiguate) if a package that appears multiple times with
+// the same name appears in an error message.
+var NumImport = make(map[string]int)
 
 type fmtSym struct {
 	x *types.Sym
@@ -270,209 +342,58 @@ type fmtSym struct {
 
 func (f *fmtSym) Format(s fmt.State, verb rune) { symFormat(f.x, s, verb, f.m) }
 
-type fmtNodes struct {
-	x Nodes
-	m FmtMode
-}
-
-func (f *fmtNodes) Format(s fmt.State, verb rune) { f.x.format(s, verb, f.m) }
+// "%S" suppresses qualifying with package
+func symFormat(s *types.Sym, f fmt.State, verb rune, mode FmtMode) {
+	switch verb {
+	case 'v', 'S':
+		fmt.Fprint(f, sconv(s, fmtFlag(f, verb), mode))
 
-func FmtNode(n Node, s fmt.State, verb rune) {
-	nodeFormat(n, s, verb, FErr)
+	default:
+		fmt.Fprintf(f, "%%!%c(*types.Sym=%p)", verb, s)
+	}
 }
 
-func (o Op) Format(s fmt.State, verb rune) { o.format(s, verb, FErr) }
+func smodeString(s *types.Sym, mode FmtMode) string { return sconv(s, 0, mode) }
 
-// func (t *types.Type) Format(s fmt.State, verb rune)     // in package types
-// func (y *types.Sym) Format(s fmt.State, verb rune)            // in package types  { y.format(s, verb, FErr) }
-func (n Nodes) Format(s fmt.State, verb rune) { n.format(s, verb, FErr) }
+// See #16897 before changing the implementation of sconv.
+func sconv(s *types.Sym, flag FmtFlag, mode FmtMode) string {
+	if flag&FmtLong != 0 {
+		panic("linksymfmt")
+	}
 
-func (m FmtMode) Fprintf(s fmt.State, format string, args ...interface{}) {
-	m.prepareArgs(args)
-	fmt.Fprintf(s, format, args...)
-}
+	if s == nil {
+		return "<S>"
+	}
 
-func (m FmtMode) Sprintf(format string, args ...interface{}) string {
-	m.prepareArgs(args)
-	return fmt.Sprintf(format, args...)
-}
+	if s.Name == "_" {
+		return "_"
+	}
+	buf := fmtBufferPool.Get().(*bytes.Buffer)
+	buf.Reset()
+	defer fmtBufferPool.Put(buf)
 
-func (m FmtMode) Sprint(args ...interface{}) string {
-	m.prepareArgs(args)
-	return fmt.Sprint(args...)
+	flag, mode = flag.update(mode)
+	symfmt(buf, s, flag, mode)
+	return types.InternString(buf.Bytes())
 }
 
-func (m FmtMode) prepareArgs(args []interface{}) {
-	for i, arg := range args {
-		switch arg := arg.(type) {
-		case Op:
-			args[i] = &fmtOp{arg, m}
-		case Node:
-			args[i] = &fmtNode{arg, m}
-		case nil:
-			args[i] = &fmtNode{nil, m} // assume this was a node interface
-		case *types.Type:
-			args[i] = &fmtType{arg, m}
-		case *types.Sym:
-			args[i] = &fmtSym{arg, m}
-		case Nodes:
-			args[i] = &fmtNodes{arg, m}
-		case int32, int64, string, types.Kind, constant.Value:
-			// OK: printing these types doesn't depend on mode
-		default:
-			base.Fatalf("mode.prepareArgs type %T", arg)
-		}
-	}
-}
-
-func nodeFormat(n Node, s fmt.State, verb rune, mode FmtMode) {
-	switch verb {
-	case 'v', 'S', 'L':
-		nconvFmt(n, s, fmtFlag(s, verb), mode)
-
-	case 'j':
-		jconvFmt(n, s, fmtFlag(s, verb))
-
-	default:
-		fmt.Fprintf(s, "%%!%c(*Node=%p)", verb, n)
-	}
-}
-
-// EscFmt is set by the escape analysis code to add escape analysis details to the node print.
-var EscFmt func(n Node) string
-
-// *Node details
-func jconvFmt(n Node, s fmt.State, flag FmtFlag) {
-	// Useful to see which nodes in an AST printout are actually identical
-	if base.Debug.DumpPtrs != 0 {
-		fmt.Fprintf(s, " p(%p)", n)
-	}
-	if n.Name() != nil && n.Name().Vargen != 0 {
-		fmt.Fprintf(s, " g(%d)", n.Name().Vargen)
-	}
-
-	if base.Debug.DumpPtrs != 0 && n.Name() != nil && n.Name().Defn != nil {
-		// Useful to see where Defn is set and what node it points to
-		fmt.Fprintf(s, " defn(%p)", n.Name().Defn)
-	}
-
-	if n.Pos().IsKnown() {
-		pfx := ""
-		switch n.Pos().IsStmt() {
-		case src.PosNotStmt:
-			pfx = "_" // "-" would be confusing
-		case src.PosIsStmt:
-			pfx = "+"
-		}
-		fmt.Fprintf(s, " l(%s%d)", pfx, n.Pos().Line())
-	}
-
-	if n.Offset() != types.BADWIDTH {
-		fmt.Fprintf(s, " x(%d)", n.Offset())
-	}
-
-	if n.Class() != 0 {
-		fmt.Fprintf(s, " class(%v)", n.Class())
-	}
-
-	if n.Colas() {
-		fmt.Fprintf(s, " colas(%v)", n.Colas())
-	}
-
-	if EscFmt != nil {
-		if esc := EscFmt(n); esc != "" {
-			fmt.Fprintf(s, " %s", esc)
-		}
-	}
-
-	if n.Typecheck() != 0 {
-		fmt.Fprintf(s, " tc(%d)", n.Typecheck())
-	}
-
-	if n.IsDDD() {
-		fmt.Fprintf(s, " isddd(%v)", n.IsDDD())
-	}
-
-	if n.Implicit() {
-		fmt.Fprintf(s, " implicit(%v)", n.Implicit())
-	}
-
-	if n.Op() == ONAME {
-		if n.Name().Addrtaken() {
-			fmt.Fprint(s, " addrtaken")
-		}
-		if n.Name().Assigned() {
-			fmt.Fprint(s, " assigned")
-		}
-		if n.Name().IsClosureVar() {
-			fmt.Fprint(s, " closurevar")
-		}
-		if n.Name().Captured() {
-			fmt.Fprint(s, " captured")
-		}
-		if n.Name().IsOutputParamHeapAddr() {
-			fmt.Fprint(s, " outputparamheapaddr")
-		}
-	}
-	if n.Bounded() {
-		fmt.Fprint(s, " bounded")
-	}
-	if n.NonNil() {
-		fmt.Fprint(s, " nonnil")
-	}
-
-	if n.HasCall() {
-		fmt.Fprint(s, " hascall")
+func sconv2(b *bytes.Buffer, s *types.Sym, flag FmtFlag, mode FmtMode) {
+	if flag&FmtLong != 0 {
+		panic("linksymfmt")
 	}
-
-	if n.Name() != nil && n.Name().Used() {
-		fmt.Fprint(s, " used")
+	if s == nil {
+		b.WriteString("<S>")
+		return
 	}
-}
-
-func FmtConst(v constant.Value, flag FmtFlag) string {
-	if flag&FmtSharp == 0 && v.Kind() == constant.Complex {
-		real, imag := constant.Real(v), constant.Imag(v)
-
-		var re string
-		sre := constant.Sign(real)
-		if sre != 0 {
-			re = real.String()
-		}
-
-		var im string
-		sim := constant.Sign(imag)
-		if sim != 0 {
-			im = imag.String()
-		}
-
-		switch {
-		case sre == 0 && sim == 0:
-			return "0"
-		case sre == 0:
-			return im + "i"
-		case sim == 0:
-			return re
-		case sim < 0:
-			return fmt.Sprintf("(%s%si)", re, im)
-		default:
-			return fmt.Sprintf("(%s+%si)", re, im)
-		}
+	if s.Name == "_" {
+		b.WriteString("_")
+		return
 	}
 
-	return v.String()
+	flag, mode = flag.update(mode)
+	symfmt(b, s, flag, mode)
 }
 
-/*
-s%,%,\n%g
-s%\n+%\n%g
-s%^[	]*T%%g
-s%,.*%%g
-s%.+%	[T&]		= "&",%g
-s%^	........*\]%&~%g
-s%~	%%g
-*/
-
 func symfmt(b *bytes.Buffer, s *types.Sym, flag FmtFlag, mode FmtMode) {
 	if flag&FmtShort == 0 {
 		switch mode {
@@ -534,6 +455,8 @@ func symfmt(b *bytes.Buffer, s *types.Sym, flag FmtFlag, mode FmtMode) {
 	b.WriteString(s.Name)
 }
 
+// Type
+
 var BasicTypeNames = []string{
 	types.TINT:        "int",
 	types.TUINT:       "uint",
@@ -564,6 +487,39 @@ var fmtBufferPool = sync.Pool{
 	},
 }
 
+func InstallTypeFormats() {
+	types.Sconv = func(s *types.Sym, flag, mode int) string {
+		return sconv(s, FmtFlag(flag), FmtMode(mode))
+	}
+	types.Tconv = func(t *types.Type, flag, mode int) string {
+		return tconv(t, FmtFlag(flag), FmtMode(mode))
+	}
+	types.FormatSym = func(sym *types.Sym, s fmt.State, verb rune, mode int) {
+		symFormat(sym, s, verb, FmtMode(mode))
+	}
+	types.FormatType = func(t *types.Type, s fmt.State, verb rune, mode int) {
+		typeFormat(t, s, verb, FmtMode(mode))
+	}
+}
+
+type fmtType struct {
+	x *types.Type
+	m FmtMode
+}
+
+func (f *fmtType) Format(s fmt.State, verb rune) { typeFormat(f.x, s, verb, f.m) }
+
+// "%L"  print definition, not name
+// "%S"  omit 'func' and receiver from function types, short type names
+func typeFormat(t *types.Type, s fmt.State, verb rune, mode FmtMode) {
+	switch verb {
+	case 'v', 'S', 'L':
+		fmt.Fprint(s, tconv(t, fmtFlag(s, verb), mode))
+	default:
+		fmt.Fprintf(s, "%%!%c(*Type=%p)", verb, t)
+	}
+}
+
 func tconv(t *types.Type, flag FmtFlag, mode FmtMode) string {
 	buf := fmtBufferPool.Get().(*bytes.Buffer)
 	buf.Reset()
@@ -874,186 +830,134 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode FmtMode, visited
 	}
 }
 
-// Statements which may be rendered with a simplestmt as init.
-func StmtWithInit(op Op) bool {
-	switch op {
-	case OIF, OFOR, OFORUNTIL, OSWITCH:
-		return true
+func fldconv(b *bytes.Buffer, f *types.Field, flag FmtFlag, mode FmtMode, visited map[*types.Type]int, funarg types.Funarg) {
+	if f == nil {
+		b.WriteString("<T>")
+		return
+	}
+	flag, mode = flag.update(mode)
+	if mode == FTypeIdName {
+		flag |= FmtUnsigned
 	}
 
-	return false
-}
-
-func stmtFmt(n Node, s fmt.State, mode FmtMode) {
-	// some statements allow for an init, but at most one,
-	// but we may have an arbitrary number added, eg by typecheck
-	// and inlining. If it doesn't fit the syntax, emit an enclosing
-	// block starting with the init statements.
-
-	// if we can just say "for" n->ninit; ... then do so
-	simpleinit := n.Init().Len() == 1 && n.Init().First().Init().Len() == 0 && StmtWithInit(n.Op())
-
-	// otherwise, print the inits as separate statements
-	complexinit := n.Init().Len() != 0 && !simpleinit && (mode != FErr)
+	var name string
+	if flag&FmtShort == 0 {
+		s := f.Sym
 
-	// but if it was for if/for/switch, put in an extra surrounding block to limit the scope
-	extrablock := complexinit && StmtWithInit(n.Op())
+		// Take the name from the original.
+		if mode == FErr {
+			s = OrigSym(s)
+		}
 
-	if extrablock {
-		fmt.Fprint(s, "{")
+		if s != nil && f.Embedded == 0 {
+			if funarg != types.FunargNone {
+				name = modeString(AsNode(f.Nname), mode)
+			} else if flag&FmtLong != 0 {
+				name = mode.Sprintf("%0S", s)
+				if !types.IsExported(name) && flag&FmtUnsigned == 0 {
+					name = smodeString(s, mode) // qualify non-exported names (used on structs, not on funarg)
+				}
+			} else {
+				name = smodeString(s, mode)
+			}
+		}
 	}
 
-	if complexinit {
-		mode.Fprintf(s, " %v; ", n.Init())
+	if name != "" {
+		b.WriteString(name)
+		b.WriteString(" ")
 	}
 
-	switch n.Op() {
-	case ODCL:
-		mode.Fprintf(s, "var %v %v", n.Left().Sym(), n.Left().Type())
-
-	// Don't export "v = <N>" initializing statements, hope they're always
-	// preceded by the DCL which will be re-parsed and typechecked to reproduce
-	// the "v = <N>" again.
-	case OAS:
-		if n.Colas() && !complexinit {
-			mode.Fprintf(s, "%v := %v", n.Left(), n.Right())
-		} else {
-			mode.Fprintf(s, "%v = %v", n.Left(), n.Right())
-		}
-
-	case OASOP:
-		if n.Implicit() {
-			if n.SubOp() == OADD {
-				mode.Fprintf(s, "%v++", n.Left())
-			} else {
-				mode.Fprintf(s, "%v--", n.Left())
-			}
-			break
-		}
-
-		mode.Fprintf(s, "%v %#v= %v", n.Left(), n.SubOp(), n.Right())
-
-	case OAS2, OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV:
-		if n.Colas() && !complexinit {
-			mode.Fprintf(s, "%.v := %.v", n.List(), n.Rlist())
-		} else {
-			mode.Fprintf(s, "%.v = %.v", n.List(), n.Rlist())
-		}
-
-	case OBLOCK:
-		if n.List().Len() != 0 {
-			mode.Fprintf(s, "%v", n.List())
+	if f.IsDDD() {
+		var et *types.Type
+		if f.Type != nil {
+			et = f.Type.Elem()
 		}
+		b.WriteString("...")
+		tconv2(b, et, 0, mode, visited)
+	} else {
+		tconv2(b, f.Type, 0, mode, visited)
+	}
 
-	case ORETURN:
-		mode.Fprintf(s, "return %.v", n.List())
-
-	case ORETJMP:
-		mode.Fprintf(s, "retjmp %v", n.Sym())
-
-	case OINLMARK:
-		mode.Fprintf(s, "inlmark %d", n.Offset())
-
-	case OGO:
-		mode.Fprintf(s, "go %v", n.Left())
-
-	case ODEFER:
-		mode.Fprintf(s, "defer %v", n.Left())
+	if flag&FmtShort == 0 && funarg == types.FunargNone && f.Note != "" {
+		b.WriteString(" ")
+		b.WriteString(strconv.Quote(f.Note))
+	}
+}
 
-	case OIF:
-		if simpleinit {
-			mode.Fprintf(s, "if %v; %v { %v }", n.Init().First(), n.Left(), n.Body())
-		} else {
-			mode.Fprintf(s, "if %v { %v }", n.Left(), n.Body())
-		}
-		if n.Rlist().Len() != 0 {
-			mode.Fprintf(s, " else { %v }", n.Rlist())
-		}
+// Node
 
-	case OFOR, OFORUNTIL:
-		opname := "for"
-		if n.Op() == OFORUNTIL {
-			opname = "foruntil"
-		}
-		if mode == FErr { // TODO maybe only if FmtShort, same below
-			fmt.Fprintf(s, "%s loop", opname)
-			break
-		}
+func modeString(n Node, mode FmtMode) string { return mode.Sprint(n) }
 
-		fmt.Fprint(s, opname)
-		if simpleinit {
-			mode.Fprintf(s, " %v;", n.Init().First())
-		} else if n.Right() != nil {
-			fmt.Fprint(s, " ;")
-		}
+type fmtNode struct {
+	x Node
+	m FmtMode
+}
 
-		if n.Left() != nil {
-			mode.Fprintf(s, " %v", n.Left())
-		}
+func (f *fmtNode) Format(s fmt.State, verb rune) { nodeFormat(f.x, s, verb, f.m) }
 
-		if n.Right() != nil {
-			mode.Fprintf(s, "; %v", n.Right())
-		} else if simpleinit {
-			fmt.Fprint(s, ";")
-		}
+func FmtNode(n Node, s fmt.State, verb rune) {
+	nodeFormat(n, s, verb, FErr)
+}
 
-		if n.Op() == OFORUNTIL && n.List().Len() != 0 {
-			mode.Fprintf(s, "; %v", n.List())
-		}
+func nodeFormat(n Node, s fmt.State, verb rune, mode FmtMode) {
+	switch verb {
+	case 'v', 'S', 'L':
+		nconvFmt(n, s, fmtFlag(s, verb), mode)
 
-		mode.Fprintf(s, " { %v }", n.Body())
+	case 'j':
+		jconvFmt(n, s, fmtFlag(s, verb))
 
-	case ORANGE:
-		if mode == FErr {
-			fmt.Fprint(s, "for loop")
-			break
-		}
+	default:
+		fmt.Fprintf(s, "%%!%c(*Node=%p)", verb, n)
+	}
+}
 
-		if n.List().Len() == 0 {
-			mode.Fprintf(s, "for range %v { %v }", n.Right(), n.Body())
-			break
-		}
+// "%L"  suffix with "(type %T)" where possible
+// "%+S" in debug mode, don't recurse, no multiline output
+func nconvFmt(n Node, s fmt.State, flag FmtFlag, mode FmtMode) {
+	if n == nil {
+		fmt.Fprint(s, "<N>")
+		return
+	}
 
-		mode.Fprintf(s, "for %.v = range %v { %v }", n.List(), n.Right(), n.Body())
+	flag, mode = flag.update(mode)
 
-	case OSELECT, OSWITCH:
-		if mode == FErr {
-			mode.Fprintf(s, "%v statement", n.Op())
-			break
-		}
+	switch mode {
+	case FErr:
+		nodeFmt(n, s, flag, mode)
 
-		mode.Fprintf(s, "%#v", n.Op())
-		if simpleinit {
-			mode.Fprintf(s, " %v;", n.Init().First())
-		}
-		if n.Left() != nil {
-			mode.Fprintf(s, " %v ", n.Left())
-		}
+	case FDbg:
+		dumpdepth++
+		nodeDumpFmt(n, s, flag, mode)
+		dumpdepth--
 
-		mode.Fprintf(s, " { %v }", n.List())
+	default:
+		base.Fatalf("unhandled %%N mode: %d", mode)
+	}
+}
 
-	case OCASE:
-		if n.List().Len() != 0 {
-			mode.Fprintf(s, "case %.v", n.List())
+func nodeFmt(n Node, s fmt.State, flag FmtFlag, mode FmtMode) {
+	t := n.Type()
+	if flag&FmtLong != 0 && t != nil {
+		if t.Kind() == types.TNIL {
+			fmt.Fprint(s, "nil")
+		} else if n.Op() == ONAME && n.Name().AutoTemp() {
+			mode.Fprintf(s, "%v value", t)
 		} else {
-			fmt.Fprint(s, "default")
+			mode.Fprintf(s, "%v (type %v)", n, t)
 		}
-		mode.Fprintf(s, ": %v", n.Body())
+		return
+	}
 
-	case OBREAK, OCONTINUE, OGOTO, OFALL:
-		if n.Sym() != nil {
-			mode.Fprintf(s, "%#v %v", n.Op(), n.Sym())
-		} else {
-			mode.Fprintf(s, "%#v", n.Op())
-		}
+	// TODO inlining produces expressions with ninits. we can't print these yet.
 
-	case OLABEL:
-		mode.Fprintf(s, "%v: ", n.Sym())
+	if OpPrec[n.Op()] < 0 {
+		stmtFmt(n, s, mode)
+		return
 	}
 
-	if extrablock {
-		fmt.Fprint(s, "}")
-	}
+	exprFmt(n, s, 0, mode)
 }
 
 var OpPrec = []int{
@@ -1177,51 +1081,232 @@ var OpPrec = []int{
 	OEND: 0,
 }
 
-func exprFmt(n Node, s fmt.State, prec int, mode FmtMode) {
-	for {
-		if n == nil {
-			fmt.Fprint(s, "<N>")
-			return
-		}
+// Statements which may be rendered with a simplestmt as init.
+func StmtWithInit(op Op) bool {
+	switch op {
+	case OIF, OFOR, OFORUNTIL, OSWITCH:
+		return true
+	}
+	return false
+}
 
-		// We always want the original, if any.
-		if o := Orig(n); o != n {
-			n = o
-			continue
-		}
+func stmtFmt(n Node, s fmt.State, mode FmtMode) {
+	// some statements allow for an init, but at most one,
+	// but we may have an arbitrary number added, eg by typecheck
+	// and inlining. If it doesn't fit the syntax, emit an enclosing
+	// block starting with the init statements.
 
-		// Skip implicit operations introduced during typechecking.
-		switch n.Op() {
-		case OADDR, ODEREF, OCONV, OCONVNOP, OCONVIFACE:
-			if n.Implicit() {
-				n = n.Left()
-				continue
-			}
-		}
+	// if we can just say "for" n->ninit; ... then do so
+	simpleinit := n.Init().Len() == 1 && n.Init().First().Init().Len() == 0 && StmtWithInit(n.Op())
 
-		break
-	}
+	// otherwise, print the inits as separate statements
+	complexinit := n.Init().Len() != 0 && !simpleinit && (mode != FErr)
 
-	nprec := OpPrec[n.Op()]
-	if n.Op() == OTYPE && n.Sym() != nil {
-		nprec = 8
+	// but if it was for if/for/switch, put in an extra surrounding block to limit the scope
+	extrablock := complexinit && StmtWithInit(n.Op())
+
+	if extrablock {
+		fmt.Fprint(s, "{")
 	}
 
-	if prec > nprec {
-		mode.Fprintf(s, "(%v)", n)
-		return
+	if complexinit {
+		mode.Fprintf(s, " %v; ", n.Init())
 	}
 
 	switch n.Op() {
-	case OPAREN:
-		mode.Fprintf(s, "(%v)", n.Left())
+	case ODCL:
+		mode.Fprintf(s, "var %v %v", n.Left().Sym(), n.Left().Type())
 
-	case ONIL:
-		fmt.Fprint(s, "nil")
+	// Don't export "v = <N>" initializing statements, hope they're always
+	// preceded by the DCL which will be re-parsed and typechecked to reproduce
+	// the "v = <N>" again.
+	case OAS:
+		if n.Colas() && !complexinit {
+			mode.Fprintf(s, "%v := %v", n.Left(), n.Right())
+		} else {
+			mode.Fprintf(s, "%v = %v", n.Left(), n.Right())
+		}
 
-	case OLITERAL: // this is a bit of a mess
-		if mode == FErr && n.Sym() != nil {
-			fmt.Fprint(s, smodeString(n.Sym(), mode))
+	case OASOP:
+		if n.Implicit() {
+			if n.SubOp() == OADD {
+				mode.Fprintf(s, "%v++", n.Left())
+			} else {
+				mode.Fprintf(s, "%v--", n.Left())
+			}
+			break
+		}
+
+		mode.Fprintf(s, "%v %#v= %v", n.Left(), n.SubOp(), n.Right())
+
+	case OAS2, OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV:
+		if n.Colas() && !complexinit {
+			mode.Fprintf(s, "%.v := %.v", n.List(), n.Rlist())
+		} else {
+			mode.Fprintf(s, "%.v = %.v", n.List(), n.Rlist())
+		}
+
+	case OBLOCK:
+		if n.List().Len() != 0 {
+			mode.Fprintf(s, "%v", n.List())
+		}
+
+	case ORETURN:
+		mode.Fprintf(s, "return %.v", n.List())
+
+	case ORETJMP:
+		mode.Fprintf(s, "retjmp %v", n.Sym())
+
+	case OINLMARK:
+		mode.Fprintf(s, "inlmark %d", n.Offset())
+
+	case OGO:
+		mode.Fprintf(s, "go %v", n.Left())
+
+	case ODEFER:
+		mode.Fprintf(s, "defer %v", n.Left())
+
+	case OIF:
+		if simpleinit {
+			mode.Fprintf(s, "if %v; %v { %v }", n.Init().First(), n.Left(), n.Body())
+		} else {
+			mode.Fprintf(s, "if %v { %v }", n.Left(), n.Body())
+		}
+		if n.Rlist().Len() != 0 {
+			mode.Fprintf(s, " else { %v }", n.Rlist())
+		}
+
+	case OFOR, OFORUNTIL:
+		opname := "for"
+		if n.Op() == OFORUNTIL {
+			opname = "foruntil"
+		}
+		if mode == FErr { // TODO maybe only if FmtShort, same below
+			fmt.Fprintf(s, "%s loop", opname)
+			break
+		}
+
+		fmt.Fprint(s, opname)
+		if simpleinit {
+			mode.Fprintf(s, " %v;", n.Init().First())
+		} else if n.Right() != nil {
+			fmt.Fprint(s, " ;")
+		}
+
+		if n.Left() != nil {
+			mode.Fprintf(s, " %v", n.Left())
+		}
+
+		if n.Right() != nil {
+			mode.Fprintf(s, "; %v", n.Right())
+		} else if simpleinit {
+			fmt.Fprint(s, ";")
+		}
+
+		if n.Op() == OFORUNTIL && n.List().Len() != 0 {
+			mode.Fprintf(s, "; %v", n.List())
+		}
+
+		mode.Fprintf(s, " { %v }", n.Body())
+
+	case ORANGE:
+		if mode == FErr {
+			fmt.Fprint(s, "for loop")
+			break
+		}
+
+		if n.List().Len() == 0 {
+			mode.Fprintf(s, "for range %v { %v }", n.Right(), n.Body())
+			break
+		}
+
+		mode.Fprintf(s, "for %.v = range %v { %v }", n.List(), n.Right(), n.Body())
+
+	case OSELECT, OSWITCH:
+		if mode == FErr {
+			mode.Fprintf(s, "%v statement", n.Op())
+			break
+		}
+
+		mode.Fprintf(s, "%#v", n.Op())
+		if simpleinit {
+			mode.Fprintf(s, " %v;", n.Init().First())
+		}
+		if n.Left() != nil {
+			mode.Fprintf(s, " %v ", n.Left())
+		}
+
+		mode.Fprintf(s, " { %v }", n.List())
+
+	case OCASE:
+		if n.List().Len() != 0 {
+			mode.Fprintf(s, "case %.v", n.List())
+		} else {
+			fmt.Fprint(s, "default")
+		}
+		mode.Fprintf(s, ": %v", n.Body())
+
+	case OBREAK, OCONTINUE, OGOTO, OFALL:
+		if n.Sym() != nil {
+			mode.Fprintf(s, "%#v %v", n.Op(), n.Sym())
+		} else {
+			mode.Fprintf(s, "%#v", n.Op())
+		}
+
+	case OLABEL:
+		mode.Fprintf(s, "%v: ", n.Sym())
+	}
+
+	if extrablock {
+		fmt.Fprint(s, "}")
+	}
+}
+
+func exprFmt(n Node, s fmt.State, prec int, mode FmtMode) {
+	for {
+		if n == nil {
+			fmt.Fprint(s, "<N>")
+			return
+		}
+
+		// We always want the original, if any.
+		if o := Orig(n); o != n {
+			n = o
+			continue
+		}
+
+		// Skip implicit operations introduced during typechecking.
+		switch n.Op() {
+		case OADDR, ODEREF, OCONV, OCONVNOP, OCONVIFACE:
+			if n.Implicit() {
+				n = n.Left()
+				continue
+			}
+		}
+
+		break
+	}
+
+	nprec := OpPrec[n.Op()]
+	if n.Op() == OTYPE && n.Sym() != nil {
+		nprec = 8
+	}
+
+	if prec > nprec {
+		mode.Fprintf(s, "(%v)", n)
+		return
+	}
+
+	switch n.Op() {
+	case OPAREN:
+		mode.Fprintf(s, "(%v)", n.Left())
+
+	case ONIL:
+		fmt.Fprint(s, "nil")
+
+	case OLITERAL: // this is a bit of a mess
+		if mode == FErr && n.Sym() != nil {
+			fmt.Fprint(s, smodeString(n.Sym(), mode))
 			return
 		}
 
@@ -1564,51 +1649,200 @@ func exprFmt(n Node, s fmt.State, prec int, mode FmtMode) {
 	}
 }
 
-func nodeFmt(n Node, s fmt.State, flag FmtFlag, mode FmtMode) {
-	t := n.Type()
-	if flag&FmtLong != 0 && t != nil {
-		if t.Kind() == types.TNIL {
-			fmt.Fprint(s, "nil")
-		} else if n.Op() == ONAME && n.Name().AutoTemp() {
-			mode.Fprintf(s, "%v value", t)
-		} else {
-			mode.Fprintf(s, "%v (type %v)", n, t)
-		}
-		return
+func ellipsisIf(b bool) string {
+	if b {
+		return "..."
 	}
+	return ""
+}
 
-	// TODO inlining produces expressions with ninits. we can't print these yet.
+// Nodes
 
-	if OpPrec[n.Op()] < 0 {
-		stmtFmt(n, s, mode)
-		return
+type fmtNodes struct {
+	x Nodes
+	m FmtMode
+}
+
+func (f *fmtNodes) Format(s fmt.State, verb rune) { f.x.format(s, verb, f.m) }
+
+func (l Nodes) Format(s fmt.State, verb rune) { l.format(s, verb, FErr) }
+
+func (l Nodes) format(s fmt.State, verb rune, mode FmtMode) {
+	switch verb {
+	case 'v':
+		l.hconv(s, fmtFlag(s, verb), mode)
+
+	default:
+		fmt.Fprintf(s, "%%!%c(Nodes)", verb)
 	}
+}
 
-	exprFmt(n, s, 0, mode)
+func (n Nodes) String() string {
+	return fmt.Sprint(n)
 }
 
-func nodeDumpFmt(n Node, s fmt.State, flag FmtFlag, mode FmtMode) {
-	recur := flag&FmtShort == 0
+// Flags: all those of %N plus '.': separate with comma's instead of semicolons.
+func (l Nodes) hconv(s fmt.State, flag FmtFlag, mode FmtMode) {
+	if l.Len() == 0 && mode == FDbg {
+		fmt.Fprint(s, "<nil>")
+		return
+	}
 
-	if recur {
-		indent(s)
-		if dumpdepth > 40 {
-			fmt.Fprint(s, "...")
-			return
-		}
+	flag, mode = flag.update(mode)
+	sep := "; "
+	if mode == FDbg {
+		sep = "\n"
+	} else if flag&FmtComma != 0 {
+		sep = ", "
+	}
 
-		if n.Init().Len() != 0 {
-			mode.Fprintf(s, "%v-init%v", n.Op(), n.Init())
-			indent(s)
+	for i, n := range l.Slice() {
+		fmt.Fprint(s, modeString(n, mode))
+		if i+1 < l.Len() {
+			fmt.Fprint(s, sep)
 		}
 	}
+}
 
-	switch n.Op() {
-	default:
-		mode.Fprintf(s, "%v%j", n.Op(), n)
+// Dump
 
-	case OLITERAL:
-		mode.Fprintf(s, "%v-%v%j", n.Op(), n.Val(), n)
+func Dump(s string, n Node) {
+	fmt.Printf("%s [%p]%+v\n", s, n, n)
+}
+
+func DumpList(s string, l Nodes) {
+	fmt.Printf("%s%+v\n", s, l)
+}
+
+func FDumpList(w io.Writer, s string, l Nodes) {
+	fmt.Fprintf(w, "%s%+v\n", s, l)
+}
+
+// TODO(gri) make variable local somehow
+var dumpdepth int
+
+// indent prints indentation to s.
+func indent(s fmt.State) {
+	fmt.Fprint(s, "\n")
+	for i := 0; i < dumpdepth; i++ {
+		fmt.Fprint(s, ".   ")
+	}
+}
+
+// EscFmt is set by the escape analysis code to add escape analysis details to the node print.
+var EscFmt func(n Node) string
+
+// *Node details
+func jconvFmt(n Node, s fmt.State, flag FmtFlag) {
+	// Useful to see which nodes in an AST printout are actually identical
+	if base.Debug.DumpPtrs != 0 {
+		fmt.Fprintf(s, " p(%p)", n)
+	}
+	if n.Name() != nil && n.Name().Vargen != 0 {
+		fmt.Fprintf(s, " g(%d)", n.Name().Vargen)
+	}
+
+	if base.Debug.DumpPtrs != 0 && n.Name() != nil && n.Name().Defn != nil {
+		// Useful to see where Defn is set and what node it points to
+		fmt.Fprintf(s, " defn(%p)", n.Name().Defn)
+	}
+
+	if n.Pos().IsKnown() {
+		pfx := ""
+		switch n.Pos().IsStmt() {
+		case src.PosNotStmt:
+			pfx = "_" // "-" would be confusing
+		case src.PosIsStmt:
+			pfx = "+"
+		}
+		fmt.Fprintf(s, " l(%s%d)", pfx, n.Pos().Line())
+	}
+
+	if n.Offset() != types.BADWIDTH {
+		fmt.Fprintf(s, " x(%d)", n.Offset())
+	}
+
+	if n.Class() != 0 {
+		fmt.Fprintf(s, " class(%v)", n.Class())
+	}
+
+	if n.Colas() {
+		fmt.Fprintf(s, " colas(%v)", n.Colas())
+	}
+
+	if EscFmt != nil {
+		if esc := EscFmt(n); esc != "" {
+			fmt.Fprintf(s, " %s", esc)
+		}
+	}
+
+	if n.Typecheck() != 0 {
+		fmt.Fprintf(s, " tc(%d)", n.Typecheck())
+	}
+
+	if n.IsDDD() {
+		fmt.Fprintf(s, " isddd(%v)", n.IsDDD())
+	}
+
+	if n.Implicit() {
+		fmt.Fprintf(s, " implicit(%v)", n.Implicit())
+	}
+
+	if n.Op() == ONAME {
+		if n.Name().Addrtaken() {
+			fmt.Fprint(s, " addrtaken")
+		}
+		if n.Name().Assigned() {
+			fmt.Fprint(s, " assigned")
+		}
+		if n.Name().IsClosureVar() {
+			fmt.Fprint(s, " closurevar")
+		}
+		if n.Name().Captured() {
+			fmt.Fprint(s, " captured")
+		}
+		if n.Name().IsOutputParamHeapAddr() {
+			fmt.Fprint(s, " outputparamheapaddr")
+		}
+	}
+	if n.Bounded() {
+		fmt.Fprint(s, " bounded")
+	}
+	if n.NonNil() {
+		fmt.Fprint(s, " nonnil")
+	}
+
+	if n.HasCall() {
+		fmt.Fprint(s, " hascall")
+	}
+
+	if n.Name() != nil && n.Name().Used() {
+		fmt.Fprint(s, " used")
+	}
+}
+
+func nodeDumpFmt(n Node, s fmt.State, flag FmtFlag, mode FmtMode) {
+	recur := flag&FmtShort == 0
+
+	if recur {
+		indent(s)
+		if dumpdepth > 40 {
+			fmt.Fprint(s, "...")
+			return
+		}
+
+		if n.Init().Len() != 0 {
+			mode.Fprintf(s, "%v-init%v", n.Op(), n.Init())
+			indent(s)
+		}
+	}
+
+	switch n.Op() {
+	default:
+		mode.Fprintf(s, "%v%j", n.Op(), n)
+
+	case OLITERAL:
+		mode.Fprintf(s, "%v-%v%j", n.Op(), n.Val(), n)
 
 	case ONAME, ONONAME, OMETHEXPR:
 		if n.Sym() != nil {
@@ -1686,241 +1920,3 @@ func asNameNodes(list []*Name) Nodes {
 	}
 	return ns
 }
-
-// "%S" suppresses qualifying with package
-func symFormat(s *types.Sym, f fmt.State, verb rune, mode FmtMode) {
-	switch verb {
-	case 'v', 'S':
-		fmt.Fprint(f, sconv(s, fmtFlag(f, verb), mode))
-
-	default:
-		fmt.Fprintf(f, "%%!%c(*types.Sym=%p)", verb, s)
-	}
-}
-
-func smodeString(s *types.Sym, mode FmtMode) string { return sconv(s, 0, mode) }
-
-// See #16897 before changing the implementation of sconv.
-func sconv(s *types.Sym, flag FmtFlag, mode FmtMode) string {
-	if flag&FmtLong != 0 {
-		panic("linksymfmt")
-	}
-
-	if s == nil {
-		return "<S>"
-	}
-
-	if s.Name == "_" {
-		return "_"
-	}
-	buf := fmtBufferPool.Get().(*bytes.Buffer)
-	buf.Reset()
-	defer fmtBufferPool.Put(buf)
-
-	flag, mode = flag.update(mode)
-	symfmt(buf, s, flag, mode)
-	return types.InternString(buf.Bytes())
-}
-
-func sconv2(b *bytes.Buffer, s *types.Sym, flag FmtFlag, mode FmtMode) {
-	if flag&FmtLong != 0 {
-		panic("linksymfmt")
-	}
-	if s == nil {
-		b.WriteString("<S>")
-		return
-	}
-	if s.Name == "_" {
-		b.WriteString("_")
-		return
-	}
-
-	flag, mode = flag.update(mode)
-	symfmt(b, s, flag, mode)
-}
-
-func fldconv(b *bytes.Buffer, f *types.Field, flag FmtFlag, mode FmtMode, visited map[*types.Type]int, funarg types.Funarg) {
-	if f == nil {
-		b.WriteString("<T>")
-		return
-	}
-	flag, mode = flag.update(mode)
-	if mode == FTypeIdName {
-		flag |= FmtUnsigned
-	}
-
-	var name string
-	if flag&FmtShort == 0 {
-		s := f.Sym
-
-		// Take the name from the original.
-		if mode == FErr {
-			s = OrigSym(s)
-		}
-
-		if s != nil && f.Embedded == 0 {
-			if funarg != types.FunargNone {
-				name = modeString(AsNode(f.Nname), mode)
-			} else if flag&FmtLong != 0 {
-				name = mode.Sprintf("%0S", s)
-				if !types.IsExported(name) && flag&FmtUnsigned == 0 {
-					name = smodeString(s, mode) // qualify non-exported names (used on structs, not on funarg)
-				}
-			} else {
-				name = smodeString(s, mode)
-			}
-		}
-	}
-
-	if name != "" {
-		b.WriteString(name)
-		b.WriteString(" ")
-	}
-
-	if f.IsDDD() {
-		var et *types.Type
-		if f.Type != nil {
-			et = f.Type.Elem()
-		}
-		b.WriteString("...")
-		tconv2(b, et, 0, mode, visited)
-	} else {
-		tconv2(b, f.Type, 0, mode, visited)
-	}
-
-	if flag&FmtShort == 0 && funarg == types.FunargNone && f.Note != "" {
-		b.WriteString(" ")
-		b.WriteString(strconv.Quote(f.Note))
-	}
-}
-
-// "%L"  print definition, not name
-// "%S"  omit 'func' and receiver from function types, short type names
-func typeFormat(t *types.Type, s fmt.State, verb rune, mode FmtMode) {
-	switch verb {
-	case 'v', 'S', 'L':
-		fmt.Fprint(s, tconv(t, fmtFlag(s, verb), mode))
-	default:
-		fmt.Fprintf(s, "%%!%c(*Type=%p)", verb, t)
-	}
-}
-
-func modeString(n Node, mode FmtMode) string { return mode.Sprint(n) }
-
-// "%L"  suffix with "(type %T)" where possible
-// "%+S" in debug mode, don't recurse, no multiline output
-func nconvFmt(n Node, s fmt.State, flag FmtFlag, mode FmtMode) {
-	if n == nil {
-		fmt.Fprint(s, "<N>")
-		return
-	}
-
-	flag, mode = flag.update(mode)
-
-	switch mode {
-	case FErr:
-		nodeFmt(n, s, flag, mode)
-
-	case FDbg:
-		dumpdepth++
-		nodeDumpFmt(n, s, flag, mode)
-		dumpdepth--
-
-	default:
-		base.Fatalf("unhandled %%N mode: %d", mode)
-	}
-}
-
-func (l Nodes) format(s fmt.State, verb rune, mode FmtMode) {
-	switch verb {
-	case 'v':
-		l.hconv(s, fmtFlag(s, verb), mode)
-
-	default:
-		fmt.Fprintf(s, "%%!%c(Nodes)", verb)
-	}
-}
-
-func (n Nodes) String() string {
-	return fmt.Sprint(n)
-}
-
-// Flags: all those of %N plus '.': separate with comma's instead of semicolons.
-func (l Nodes) hconv(s fmt.State, flag FmtFlag, mode FmtMode) {
-	if l.Len() == 0 && mode == FDbg {
-		fmt.Fprint(s, "<nil>")
-		return
-	}
-
-	flag, mode = flag.update(mode)
-	sep := "; "
-	if mode == FDbg {
-		sep = "\n"
-	} else if flag&FmtComma != 0 {
-		sep = ", "
-	}
-
-	for i, n := range l.Slice() {
-		fmt.Fprint(s, modeString(n, mode))
-		if i+1 < l.Len() {
-			fmt.Fprint(s, sep)
-		}
-	}
-}
-
-func DumpList(s string, l Nodes) {
-	fmt.Printf("%s%+v\n", s, l)
-}
-
-func FDumpList(w io.Writer, s string, l Nodes) {
-	fmt.Fprintf(w, "%s%+v\n", s, l)
-}
-
-func Dump(s string, n Node) {
-	fmt.Printf("%s [%p]%+v\n", s, n, n)
-}
-
-// TODO(gri) make variable local somehow
-var dumpdepth int
-
-// indent prints indentation to s.
-func indent(s fmt.State) {
-	fmt.Fprint(s, "\n")
-	for i := 0; i < dumpdepth; i++ {
-		fmt.Fprint(s, ".   ")
-	}
-}
-
-func ellipsisIf(b bool) string {
-	if b {
-		return "..."
-	}
-	return ""
-}
-
-// numImport tracks how often a package with a given name is imported.
-// It is used to provide a better error message (by using the package
-// path to disambiguate) if a package that appears multiple times with
-// the same name appears in an error message.
-var NumImport = make(map[string]int)
-
-func InstallTypeFormats() {
-	types.Sconv = func(s *types.Sym, flag, mode int) string {
-		return sconv(s, FmtFlag(flag), FmtMode(mode))
-	}
-	types.Tconv = func(t *types.Type, flag, mode int) string {
-		return tconv(t, FmtFlag(flag), FmtMode(mode))
-	}
-	types.FormatSym = func(sym *types.Sym, s fmt.State, verb rune, mode int) {
-		symFormat(sym, s, verb, FmtMode(mode))
-	}
-	types.FormatType = func(t *types.Type, s fmt.State, verb rune, mode int) {
-		typeFormat(t, s, verb, FmtMode(mode))
-	}
-}
-
-// Line returns n's position as a string. If n has been inlined,
-// it uses the outermost position where n has been inlined.
-func Line(n Node) string {
-	return base.FmtPos(n.Pos())
-}
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 7fd02925ba..83f5b0cf78 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -116,6 +116,12 @@ type Node interface {
 	CanBeAnSSASym()
 }
 
+// Line returns n's position as a string. If n has been inlined,
+// it uses the outermost position where n has been inlined.
+func Line(n Node) string {
+	return base.FmtPos(n.Pos())
+}
+
 func IsSynthetic(n Node) bool {
 	name := n.Sym().Name
 	return name[0] == '.' || name[0] == '~'
-- 
GitLab


From 8ce2605c5b4bc64432e1711a1273f91eee3a41fc Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 5 Dec 2020 00:02:46 -0500
Subject: [PATCH 0172/2400] [dev.regabi] cmd/compile: untangle ir.Dump printing

The Node printing code is tangled up due to the multiple printing modes.
Split out the Dump mode into its own code, which clarifies it considerably.
We are going to have to change the code for the new Node representations,
so it is nice to have it in an understandable form first.

The output of Dump is unchanged except for the removal of spurious
mid-Dump blank lines that have been printed for a while but don't
really make sense and appear to be a bug.

The %+v verb on Op prints the name ("ADD" not "+"), matching
%+v on Node and %+v on Nodes to get Dump and DumpList formats.

Passes buildall w/ toolstash -cmp.

Change-Id: I07f0f245859f1f785e10bdd671855ca43c51b545
Reviewed-on: https://go-review.googlesource.com/c/go/+/275774
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/fmtmap_test.go     |   4 +-
 src/cmd/compile/internal/ir/fmt.go | 272 +++++++++++++++--------------
 2 files changed, 144 insertions(+), 132 deletions(-)

diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
index fde9c51b27..bf81cc07db 100644
--- a/src/cmd/compile/fmtmap_test.go
+++ b/src/cmd/compile/fmtmap_test.go
@@ -42,12 +42,14 @@ var knownFormats = map[string]string{
 	"*cmd/compile/internal/ssa.sparseTreeMapEntry %v": "",
 	"*cmd/compile/internal/types.Field %p":            "",
 	"*cmd/compile/internal/types.Field %v":            "",
+	"*cmd/compile/internal/types.Sym %+v":             "",
 	"*cmd/compile/internal/types.Sym %0S":             "",
 	"*cmd/compile/internal/types.Sym %S":              "",
 	"*cmd/compile/internal/types.Sym %p":              "",
 	"*cmd/compile/internal/types.Sym %v":              "",
 	"*cmd/compile/internal/types.Type %#L":            "",
 	"*cmd/compile/internal/types.Type %#v":            "",
+	"*cmd/compile/internal/types.Type %+v":            "",
 	"*cmd/compile/internal/types.Type %-S":            "",
 	"*cmd/compile/internal/types.Type %0S":            "",
 	"*cmd/compile/internal/types.Type %L":             "",
@@ -88,7 +90,6 @@ var knownFormats = map[string]string{
 	"cmd/compile/internal/ir.Node %+v":                "",
 	"cmd/compile/internal/ir.Node %L":                 "",
 	"cmd/compile/internal/ir.Node %S":                 "",
-	"cmd/compile/internal/ir.Node %j":                 "",
 	"cmd/compile/internal/ir.Node %p":                 "",
 	"cmd/compile/internal/ir.Node %v":                 "",
 	"cmd/compile/internal/ir.Nodes %#v":               "",
@@ -97,6 +98,7 @@ var knownFormats = map[string]string{
 	"cmd/compile/internal/ir.Nodes %v":                "",
 	"cmd/compile/internal/ir.Ntype %v":                "",
 	"cmd/compile/internal/ir.Op %#v":                  "",
+	"cmd/compile/internal/ir.Op %+v":                  "",
 	"cmd/compile/internal/ir.Op %v":                   "",
 	"cmd/compile/internal/ssa.BranchPrediction %d":    "",
 	"cmd/compile/internal/ssa.Edge %v":                "",
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index ae33dcddd7..b5bf036d5e 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -9,6 +9,7 @@ import (
 	"fmt"
 	"go/constant"
 	"io"
+	"os"
 	"strconv"
 	"strings"
 	"sync"
@@ -258,7 +259,10 @@ var OpNames = []string{
 }
 
 func (o Op) GoString() string {
-	return fmt.Sprintf("%#v", o)
+	if int(o) < len(OpNames) && OpNames[o] != "" {
+		return OpNames[o]
+	}
+	return o.String()
 }
 
 type fmtOp struct {
@@ -266,30 +270,20 @@ type fmtOp struct {
 	m FmtMode
 }
 
-func (f *fmtOp) Format(s fmt.State, verb rune) { f.x.format(s, verb, f.m) }
-
-func (o Op) Format(s fmt.State, verb rune) { o.format(s, verb, FErr) }
+func (f *fmtOp) Format(s fmt.State, verb rune) { f.x.Format(s, verb) }
 
-func (o Op) format(s fmt.State, verb rune, mode FmtMode) {
+func (o Op) Format(s fmt.State, verb rune) {
 	switch verb {
-	case 'v':
-		o.oconv(s, fmtFlag(s, verb), mode)
-
 	default:
 		fmt.Fprintf(s, "%%!%c(Op=%d)", verb, int(o))
-	}
-}
-
-func (o Op) oconv(s fmt.State, flag FmtFlag, mode FmtMode) {
-	if flag&FmtSharp != 0 || mode != FDbg {
-		if int(o) < len(OpNames) && OpNames[o] != "" {
-			fmt.Fprint(s, OpNames[o])
+	case 'v':
+		if s.Flag('+') {
+			// %+v is OMUL instead of "*"
+			io.WriteString(s, o.String())
 			return
 		}
+		io.WriteString(s, o.GoString())
 	}
-
-	// 'o.String()' instead of just 'o' to avoid infinite recursion
-	fmt.Fprint(s, o.String())
 }
 
 // Val
@@ -346,6 +340,9 @@ func (f *fmtSym) Format(s fmt.State, verb rune) { symFormat(f.x, s, verb, f.m) }
 func symFormat(s *types.Sym, f fmt.State, verb rune, mode FmtMode) {
 	switch verb {
 	case 'v', 'S':
+		if verb == 'v' && f.Flag('+') {
+			mode = FDbg
+		}
 		fmt.Fprint(f, sconv(s, fmtFlag(f, verb), mode))
 
 	default:
@@ -514,6 +511,9 @@ func (f *fmtType) Format(s fmt.State, verb rune) { typeFormat(f.x, s, verb, f.m)
 func typeFormat(t *types.Type, s fmt.State, verb rune, mode FmtMode) {
 	switch verb {
 	case 'v', 'S', 'L':
+		if verb == 'v' && s.Flag('+') { // %+v is debug format
+			mode = FDbg
+		}
 		fmt.Fprint(s, tconv(t, fmtFlag(s, verb), mode))
 	default:
 		fmt.Fprintf(s, "%%!%c(*Type=%p)", verb, t)
@@ -897,6 +897,13 @@ type fmtNode struct {
 func (f *fmtNode) Format(s fmt.State, verb rune) { nodeFormat(f.x, s, verb, f.m) }
 
 func FmtNode(n Node, s fmt.State, verb rune) {
+	// %+v prints Dump.
+	if s.Flag('+') && verb == 'v' {
+		dumpNode(s, n, 1)
+		return
+	}
+
+	// Otherwise print Go syntax.
 	nodeFormat(n, s, verb, FErr)
 }
 
@@ -905,9 +912,6 @@ func nodeFormat(n Node, s fmt.State, verb rune, mode FmtMode) {
 	case 'v', 'S', 'L':
 		nconvFmt(n, s, fmtFlag(s, verb), mode)
 
-	case 'j':
-		jconvFmt(n, s, fmtFlag(s, verb))
-
 	default:
 		fmt.Fprintf(s, "%%!%c(*Node=%p)", verb, n)
 	}
@@ -927,11 +931,6 @@ func nconvFmt(n Node, s fmt.State, flag FmtFlag, mode FmtMode) {
 	case FErr:
 		nodeFmt(n, s, flag, mode)
 
-	case FDbg:
-		dumpdepth++
-		nodeDumpFmt(n, s, flag, mode)
-		dumpdepth--
-
 	default:
 		base.Fatalf("unhandled %%N mode: %d", mode)
 	}
@@ -1663,11 +1662,17 @@ type fmtNodes struct {
 	m FmtMode
 }
 
-func (f *fmtNodes) Format(s fmt.State, verb rune) { f.x.format(s, verb, f.m) }
+func (f *fmtNodes) Format(s fmt.State, verb rune) { f.x.format(s, verb, FErr) }
 
 func (l Nodes) Format(s fmt.State, verb rune) { l.format(s, verb, FErr) }
 
 func (l Nodes) format(s fmt.State, verb rune, mode FmtMode) {
+	if s.Flag('+') && verb == 'v' {
+		// %+v is DumpList output
+		dumpNodes(s, l, 1)
+		return
+	}
+
 	switch verb {
 	case 'v':
 		l.hconv(s, fmtFlag(s, verb), mode)
@@ -1683,16 +1688,9 @@ func (n Nodes) String() string {
 
 // Flags: all those of %N plus '.': separate with comma's instead of semicolons.
 func (l Nodes) hconv(s fmt.State, flag FmtFlag, mode FmtMode) {
-	if l.Len() == 0 && mode == FDbg {
-		fmt.Fprint(s, "<nil>")
-		return
-	}
-
 	flag, mode = flag.update(mode)
 	sep := "; "
-	if mode == FDbg {
-		sep = "\n"
-	} else if flag&FmtComma != 0 {
+	if flag&FmtComma != 0 {
 		sep = ", "
 	}
 
@@ -1707,44 +1705,45 @@ func (l Nodes) hconv(s fmt.State, flag FmtFlag, mode FmtMode) {
 // Dump
 
 func Dump(s string, n Node) {
-	fmt.Printf("%s [%p]%+v\n", s, n, n)
+	fmt.Printf("%s [%p]%+v", s, n, n)
 }
 
 func DumpList(s string, l Nodes) {
-	fmt.Printf("%s%+v\n", s, l)
+	var buf bytes.Buffer
+	FDumpList(&buf, s, l)
+	os.Stdout.Write(buf.Bytes())
 }
 
 func FDumpList(w io.Writer, s string, l Nodes) {
-	fmt.Fprintf(w, "%s%+v\n", s, l)
+	io.WriteString(w, s)
+	dumpNodes(w, l, 1)
+	io.WriteString(w, "\n")
 }
 
-// TODO(gri) make variable local somehow
-var dumpdepth int
-
-// indent prints indentation to s.
-func indent(s fmt.State) {
-	fmt.Fprint(s, "\n")
-	for i := 0; i < dumpdepth; i++ {
-		fmt.Fprint(s, ".   ")
+// indent prints indentation to w.
+func indent(w io.Writer, depth int) {
+	fmt.Fprint(w, "\n")
+	for i := 0; i < depth; i++ {
+		fmt.Fprint(w, ".   ")
 	}
 }
 
 // EscFmt is set by the escape analysis code to add escape analysis details to the node print.
 var EscFmt func(n Node) string
 
-// *Node details
-func jconvFmt(n Node, s fmt.State, flag FmtFlag) {
+// dumpNodeHeader prints the debug-format node header line to w.
+func dumpNodeHeader(w io.Writer, n Node) {
 	// Useful to see which nodes in an AST printout are actually identical
 	if base.Debug.DumpPtrs != 0 {
-		fmt.Fprintf(s, " p(%p)", n)
+		fmt.Fprintf(w, " p(%p)", n)
 	}
 	if n.Name() != nil && n.Name().Vargen != 0 {
-		fmt.Fprintf(s, " g(%d)", n.Name().Vargen)
+		fmt.Fprintf(w, " g(%d)", n.Name().Vargen)
 	}
 
 	if base.Debug.DumpPtrs != 0 && n.Name() != nil && n.Name().Defn != nil {
 		// Useful to see where Defn is set and what node it points to
-		fmt.Fprintf(s, " defn(%p)", n.Name().Defn)
+		fmt.Fprintf(w, " defn(%p)", n.Name().Defn)
 	}
 
 	if n.Pos().IsKnown() {
@@ -1755,168 +1754,179 @@ func jconvFmt(n Node, s fmt.State, flag FmtFlag) {
 		case src.PosIsStmt:
 			pfx = "+"
 		}
-		fmt.Fprintf(s, " l(%s%d)", pfx, n.Pos().Line())
+		fmt.Fprintf(w, " l(%s%d)", pfx, n.Pos().Line())
 	}
 
 	if n.Offset() != types.BADWIDTH {
-		fmt.Fprintf(s, " x(%d)", n.Offset())
+		fmt.Fprintf(w, " x(%d)", n.Offset())
 	}
 
 	if n.Class() != 0 {
-		fmt.Fprintf(s, " class(%v)", n.Class())
+		fmt.Fprintf(w, " class(%v)", n.Class())
 	}
 
 	if n.Colas() {
-		fmt.Fprintf(s, " colas(%v)", n.Colas())
+		fmt.Fprintf(w, " colas(%v)", n.Colas())
 	}
 
 	if EscFmt != nil {
 		if esc := EscFmt(n); esc != "" {
-			fmt.Fprintf(s, " %s", esc)
+			fmt.Fprintf(w, " %s", esc)
 		}
 	}
 
 	if n.Typecheck() != 0 {
-		fmt.Fprintf(s, " tc(%d)", n.Typecheck())
+		fmt.Fprintf(w, " tc(%d)", n.Typecheck())
 	}
 
 	if n.IsDDD() {
-		fmt.Fprintf(s, " isddd(%v)", n.IsDDD())
+		fmt.Fprintf(w, " isddd(%v)", n.IsDDD())
 	}
 
 	if n.Implicit() {
-		fmt.Fprintf(s, " implicit(%v)", n.Implicit())
+		fmt.Fprintf(w, " implicit(%v)", n.Implicit())
 	}
 
 	if n.Op() == ONAME {
 		if n.Name().Addrtaken() {
-			fmt.Fprint(s, " addrtaken")
+			fmt.Fprint(w, " addrtaken")
 		}
 		if n.Name().Assigned() {
-			fmt.Fprint(s, " assigned")
+			fmt.Fprint(w, " assigned")
 		}
 		if n.Name().IsClosureVar() {
-			fmt.Fprint(s, " closurevar")
+			fmt.Fprint(w, " closurevar")
 		}
 		if n.Name().Captured() {
-			fmt.Fprint(s, " captured")
+			fmt.Fprint(w, " captured")
 		}
 		if n.Name().IsOutputParamHeapAddr() {
-			fmt.Fprint(s, " outputparamheapaddr")
+			fmt.Fprint(w, " outputparamheapaddr")
 		}
 	}
 	if n.Bounded() {
-		fmt.Fprint(s, " bounded")
+		fmt.Fprint(w, " bounded")
 	}
 	if n.NonNil() {
-		fmt.Fprint(s, " nonnil")
+		fmt.Fprint(w, " nonnil")
 	}
 
 	if n.HasCall() {
-		fmt.Fprint(s, " hascall")
+		fmt.Fprint(w, " hascall")
 	}
 
 	if n.Name() != nil && n.Name().Used() {
-		fmt.Fprint(s, " used")
+		fmt.Fprint(w, " used")
 	}
 }
 
-func nodeDumpFmt(n Node, s fmt.State, flag FmtFlag, mode FmtMode) {
-	recur := flag&FmtShort == 0
-
-	if recur {
-		indent(s)
-		if dumpdepth > 40 {
-			fmt.Fprint(s, "...")
-			return
-		}
+func dumpNode(w io.Writer, n Node, depth int) {
+	indent(w, depth)
+	if depth > 40 {
+		fmt.Fprint(w, "...")
+		return
+	}
 
-		if n.Init().Len() != 0 {
-			mode.Fprintf(s, "%v-init%v", n.Op(), n.Init())
-			indent(s)
-		}
+	if n.Init().Len() != 0 {
+		fmt.Fprintf(w, "%+v-init", n.Op())
+		dumpNodes(w, n.Init(), depth+1)
+		indent(w, depth)
 	}
 
 	switch n.Op() {
 	default:
-		mode.Fprintf(s, "%v%j", n.Op(), n)
+		fmt.Fprintf(w, "%+v", n.Op())
+		dumpNodeHeader(w, n)
 
 	case OLITERAL:
-		mode.Fprintf(s, "%v-%v%j", n.Op(), n.Val(), n)
+		fmt.Fprintf(w, "%+v-%v", n.Op(), n.Val())
+		dumpNodeHeader(w, n)
 
 	case ONAME, ONONAME, OMETHEXPR:
 		if n.Sym() != nil {
-			mode.Fprintf(s, "%v-%v%j", n.Op(), n.Sym(), n)
+			fmt.Fprintf(w, "%+v-%+v", n.Op(), n.Sym())
 		} else {
-			mode.Fprintf(s, "%v%j", n.Op(), n)
+			fmt.Fprintf(w, "%+v", n.Op())
 		}
-		if recur && n.Type() == nil && n.Name() != nil && n.Name().Ntype != nil {
-			indent(s)
-			mode.Fprintf(s, "%v-ntype%v", n.Op(), n.Name().Ntype)
+		dumpNodeHeader(w, n)
+		if n.Type() == nil && n.Name() != nil && n.Name().Ntype != nil {
+			indent(w, depth)
+			fmt.Fprintf(w, "%+v-ntype", n.Op())
+			dumpNode(w, n.Name().Ntype, depth+1)
 		}
 
 	case OASOP:
-		mode.Fprintf(s, "%v-%v%j", n.Op(), n.SubOp(), n)
+		fmt.Fprintf(w, "%+v-%+v", n.Op(), n.SubOp())
+		dumpNodeHeader(w, n)
 
 	case OTYPE:
-		mode.Fprintf(s, "%v %v%j type=%v", n.Op(), n.Sym(), n, n.Type())
-		if recur && n.Type() == nil && n.Name() != nil && n.Name().Ntype != nil {
-			indent(s)
-			mode.Fprintf(s, "%v-ntype%v", n.Op(), n.Name().Ntype)
+		fmt.Fprintf(w, "%+v %+v", n.Op(), n.Sym())
+		dumpNodeHeader(w, n)
+		fmt.Fprintf(w, " type=%+v", n.Type())
+		if n.Type() == nil && n.Name() != nil && n.Name().Ntype != nil {
+			indent(w, depth)
+			fmt.Fprintf(w, "%+v-ntype", n.Op())
+			dumpNode(w, n.Name().Ntype, depth+1)
 		}
 	}
 
 	if n.Op() == OCLOSURE && n.Func() != nil && n.Func().Nname.Sym() != nil {
-		mode.Fprintf(s, " fnName %v", n.Func().Nname.Sym())
+		fmt.Fprintf(w, " fnName %+v", n.Func().Nname.Sym())
 	}
 	if n.Sym() != nil && n.Op() != ONAME {
-		mode.Fprintf(s, " %v", n.Sym())
+		fmt.Fprintf(w, " %+v", n.Sym())
 	}
 
 	if n.Type() != nil {
-		mode.Fprintf(s, " %v", n.Type())
+		fmt.Fprintf(w, " %+v", n.Type())
 	}
 
-	if recur {
-		if n.Left() != nil {
-			mode.Fprintf(s, "%v", n.Left())
-		}
-		if n.Right() != nil {
-			mode.Fprintf(s, "%v", n.Right())
-		}
-		if n.Op() == OCLOSURE && n.Func() != nil && n.Func().Body().Len() != 0 {
-			indent(s)
-			// The function associated with a closure
-			mode.Fprintf(s, "%v-clofunc%v", n.Op(), n.Func())
-		}
-		if n.Op() == ODCLFUNC && n.Func() != nil && n.Func().Dcl != nil && len(n.Func().Dcl) != 0 {
-			indent(s)
-			// The dcls for a func or closure
-			mode.Fprintf(s, "%v-dcl%v", n.Op(), asNameNodes(n.Func().Dcl))
-		}
-		if n.List().Len() != 0 {
-			indent(s)
-			mode.Fprintf(s, "%v-list%v", n.Op(), n.List())
+	if n.Left() != nil {
+		dumpNode(w, n.Left(), depth+1)
+	}
+	if n.Right() != nil {
+		dumpNode(w, n.Right(), depth+1)
+	}
+	if n.Op() == OCLOSURE && n.Func() != nil && n.Func().Body().Len() != 0 {
+		indent(w, depth)
+		// The function associated with a closure
+		fmt.Fprintf(w, "%+v-clofunc", n.Op())
+		dumpNode(w, n.Func(), depth+1)
+	}
+	if n.Op() == ODCLFUNC && n.Func() != nil && n.Func().Dcl != nil && len(n.Func().Dcl) != 0 {
+		indent(w, depth)
+		// The dcls for a func or closure
+		fmt.Fprintf(w, "%+v-dcl", n.Op())
+		for _, dcl := range n.Func().Dcl {
+			dumpNode(w, dcl, depth+1)
 		}
+	}
+	if n.List().Len() != 0 {
+		indent(w, depth)
+		fmt.Fprintf(w, "%+v-list", n.Op())
+		dumpNodes(w, n.List(), depth+1)
+	}
 
-		if n.Rlist().Len() != 0 {
-			indent(s)
-			mode.Fprintf(s, "%v-rlist%v", n.Op(), n.Rlist())
-		}
+	if n.Rlist().Len() != 0 {
+		indent(w, depth)
+		fmt.Fprintf(w, "%+v-rlist", n.Op())
+		dumpNodes(w, n.Rlist(), depth+1)
+	}
 
-		if n.Body().Len() != 0 {
-			indent(s)
-			mode.Fprintf(s, "%v-body%v", n.Op(), n.Body())
-		}
+	if n.Body().Len() != 0 {
+		indent(w, depth)
+		fmt.Fprintf(w, "%+v-body", n.Op())
+		dumpNodes(w, n.Body(), depth+1)
 	}
 }
 
-// asNameNodes copies list to a new Nodes.
-// It should only be called in debug formatting and other low-performance contexts.
-func asNameNodes(list []*Name) Nodes {
-	var ns Nodes
-	for _, n := range list {
-		ns.Append(n)
+func dumpNodes(w io.Writer, list Nodes, depth int) {
+	if list.Len() == 0 {
+		fmt.Fprintf(w, " <nil>")
+		return
+	}
+
+	for _, n := range list.Slice() {
+		dumpNode(w, n, depth)
 	}
-	return ns
 }
-- 
GitLab


From 3b25f3c1504cdc8f2263d68436df42042251b290 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 5 Dec 2020 14:46:19 -0500
Subject: [PATCH 0173/2400] [dev.regabi] cmd/compile: simplify Op, Node, Nodes
 printing

nconvFmt calls base.Fatalf if mode is anything but FErr,
proving that the only formats that matter for nodes are
plain %v, %S, and %L. And the nodes formatter can only get to %v.
(%S and %v are the same; we'll clean that up separately.)

Node and Nodes can therefore ignore mode, and all the mode
code can be removed from those implementations, removing
quite a few layers of abstraction.

Op similarly only runs in one mode and can be simplified.

Passes buildall w/ toolstash -cmp.

Change-Id: Ibfd845033e9c68181a20fb81c8f3dd428463920a
Reviewed-on: https://go-review.googlesource.com/c/go/+/275775
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/fmtmap_test.go      |   2 -
 src/cmd/compile/internal/gc/walk.go |   2 +-
 src/cmd/compile/internal/ir/fmt.go  | 351 ++++++++++++----------------
 3 files changed, 155 insertions(+), 200 deletions(-)

diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
index bf81cc07db..60b772e932 100644
--- a/src/cmd/compile/fmtmap_test.go
+++ b/src/cmd/compile/fmtmap_test.go
@@ -85,8 +85,6 @@ var knownFormats = map[string]string{
 	"cmd/compile/internal/gc.itag %v":                 "",
 	"cmd/compile/internal/ir.Class %d":                "",
 	"cmd/compile/internal/ir.Class %v":                "",
-	"cmd/compile/internal/ir.FmtMode %d":              "",
-	"cmd/compile/internal/ir.Node %+S":                "",
 	"cmd/compile/internal/ir.Node %+v":                "",
 	"cmd/compile/internal/ir.Node %L":                 "",
 	"cmd/compile/internal/ir.Node %S":                 "",
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index bbc08ab953..574c7c4709 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -481,7 +481,7 @@ opswitch:
 	switch n.Op() {
 	default:
 		ir.Dump("walk", n)
-		base.Fatalf("walkexpr: switch 1 unknown op %+S", n)
+		base.Fatalf("walkexpr: switch 1 unknown op %+v", n.Op())
 
 	case ir.ONONAME, ir.OGETG, ir.ONEWOBJ, ir.OMETHEXPR:
 
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index b5bf036d5e..b0c732ae56 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -170,19 +170,13 @@ func (m FmtMode) Sprint(args ...interface{}) string {
 func (m FmtMode) prepareArgs(args []interface{}) {
 	for i, arg := range args {
 		switch arg := arg.(type) {
-		case Op:
-			args[i] = &fmtOp{arg, m}
-		case Node:
-			args[i] = &fmtNode{arg, m}
 		case nil:
-			args[i] = &fmtNode{nil, m} // assume this was a node interface
+			args[i] = "<N>" // assume this was a node interface
 		case *types.Type:
 			args[i] = &fmtType{arg, m}
 		case *types.Sym:
 			args[i] = &fmtSym{arg, m}
-		case Nodes:
-			args[i] = &fmtNodes{arg, m}
-		case int32, int64, string, types.Kind, constant.Value:
+		case int32, int64, string, Op, Node, Nodes, types.Kind, constant.Value:
 			// OK: printing these types doesn't depend on mode
 		default:
 			base.Fatalf("mode.prepareArgs type %T", arg)
@@ -265,13 +259,6 @@ func (o Op) GoString() string {
 	return o.String()
 }
 
-type fmtOp struct {
-	x Op
-	m FmtMode
-}
-
-func (f *fmtOp) Format(s fmt.State, verb rune) { f.x.Format(s, verb) }
-
 func (o Op) Format(s fmt.State, verb rune) {
 	switch verb {
 	default:
@@ -851,7 +838,7 @@ func fldconv(b *bytes.Buffer, f *types.Field, flag FmtFlag, mode FmtMode, visite
 
 		if s != nil && f.Embedded == 0 {
 			if funarg != types.FunargNone {
-				name = modeString(AsNode(f.Nname), mode)
+				name = fmt.Sprint(f.Nname)
 			} else if flag&FmtLong != 0 {
 				name = mode.Sprintf("%0S", s)
 				if !types.IsExported(name) && flag&FmtUnsigned == 0 {
@@ -887,64 +874,38 @@ func fldconv(b *bytes.Buffer, f *types.Field, flag FmtFlag, mode FmtMode, visite
 
 // Node
 
-func modeString(n Node, mode FmtMode) string { return mode.Sprint(n) }
-
-type fmtNode struct {
-	x Node
-	m FmtMode
-}
-
-func (f *fmtNode) Format(s fmt.State, verb rune) { nodeFormat(f.x, s, verb, f.m) }
-
 func FmtNode(n Node, s fmt.State, verb rune) {
+	// TODO(rsc): Remove uses of %#v, which behaves just like %v.
+	// TODO(rsc): Remove uses of %S, which behaves just like %v.
+	if verb == 'S' {
+		verb = 'v'
+	}
+
 	// %+v prints Dump.
+	// Otherwise we print Go syntax.
 	if s.Flag('+') && verb == 'v' {
 		dumpNode(s, n, 1)
 		return
 	}
 
-	// Otherwise print Go syntax.
-	nodeFormat(n, s, verb, FErr)
-}
-
-func nodeFormat(n Node, s fmt.State, verb rune, mode FmtMode) {
-	switch verb {
-	case 'v', 'S', 'L':
-		nconvFmt(n, s, fmtFlag(s, verb), mode)
-
-	default:
+	if verb != 'v' && verb != 'S' && verb != 'L' {
 		fmt.Fprintf(s, "%%!%c(*Node=%p)", verb, n)
+		return
 	}
-}
 
-// "%L"  suffix with "(type %T)" where possible
-// "%+S" in debug mode, don't recurse, no multiline output
-func nconvFmt(n Node, s fmt.State, flag FmtFlag, mode FmtMode) {
 	if n == nil {
 		fmt.Fprint(s, "<N>")
 		return
 	}
 
-	flag, mode = flag.update(mode)
-
-	switch mode {
-	case FErr:
-		nodeFmt(n, s, flag, mode)
-
-	default:
-		base.Fatalf("unhandled %%N mode: %d", mode)
-	}
-}
-
-func nodeFmt(n Node, s fmt.State, flag FmtFlag, mode FmtMode) {
 	t := n.Type()
-	if flag&FmtLong != 0 && t != nil {
+	if verb == 'L' && t != nil {
 		if t.Kind() == types.TNIL {
 			fmt.Fprint(s, "nil")
 		} else if n.Op() == ONAME && n.Name().AutoTemp() {
-			mode.Fprintf(s, "%v value", t)
+			fmt.Fprintf(s, "%v value", t)
 		} else {
-			mode.Fprintf(s, "%v (type %v)", n, t)
+			fmt.Fprintf(s, "%v (type %v)", n, t)
 		}
 		return
 	}
@@ -952,11 +913,11 @@ func nodeFmt(n Node, s fmt.State, flag FmtFlag, mode FmtMode) {
 	// TODO inlining produces expressions with ninits. we can't print these yet.
 
 	if OpPrec[n.Op()] < 0 {
-		stmtFmt(n, s, mode)
+		stmtFmt(n, s)
 		return
 	}
 
-	exprFmt(n, s, 0, mode)
+	exprFmt(n, s, 0)
 }
 
 var OpPrec = []int{
@@ -1089,7 +1050,15 @@ func StmtWithInit(op Op) bool {
 	return false
 }
 
-func stmtFmt(n Node, s fmt.State, mode FmtMode) {
+func stmtFmt(n Node, s fmt.State) {
+	// NOTE(rsc): This code used to support the text-based
+	// which was more aggressive about printing full Go syntax
+	// (for example, an actual loop instead of "for loop").
+	// The code is preserved for now in case we want to expand
+	// any of those shortenings later. Or maybe we will delete
+	// the code. But for now, keep it.
+	const exportFormat = false
+
 	// some statements allow for an init, but at most one,
 	// but we may have an arbitrary number added, eg by typecheck
 	// and inlining. If it doesn't fit the syntax, emit an enclosing
@@ -1099,7 +1068,7 @@ func stmtFmt(n Node, s fmt.State, mode FmtMode) {
 	simpleinit := n.Init().Len() == 1 && n.Init().First().Init().Len() == 0 && StmtWithInit(n.Op())
 
 	// otherwise, print the inits as separate statements
-	complexinit := n.Init().Len() != 0 && !simpleinit && (mode != FErr)
+	complexinit := n.Init().Len() != 0 && !simpleinit && exportFormat
 
 	// but if it was for if/for/switch, put in an extra surrounding block to limit the scope
 	extrablock := complexinit && StmtWithInit(n.Op())
@@ -1109,70 +1078,70 @@ func stmtFmt(n Node, s fmt.State, mode FmtMode) {
 	}
 
 	if complexinit {
-		mode.Fprintf(s, " %v; ", n.Init())
+		fmt.Fprintf(s, " %v; ", n.Init())
 	}
 
 	switch n.Op() {
 	case ODCL:
-		mode.Fprintf(s, "var %v %v", n.Left().Sym(), n.Left().Type())
+		fmt.Fprintf(s, "var %v %v", n.Left().Sym(), n.Left().Type())
 
 	// Don't export "v = <N>" initializing statements, hope they're always
 	// preceded by the DCL which will be re-parsed and typechecked to reproduce
 	// the "v = <N>" again.
 	case OAS:
 		if n.Colas() && !complexinit {
-			mode.Fprintf(s, "%v := %v", n.Left(), n.Right())
+			fmt.Fprintf(s, "%v := %v", n.Left(), n.Right())
 		} else {
-			mode.Fprintf(s, "%v = %v", n.Left(), n.Right())
+			fmt.Fprintf(s, "%v = %v", n.Left(), n.Right())
 		}
 
 	case OASOP:
 		if n.Implicit() {
 			if n.SubOp() == OADD {
-				mode.Fprintf(s, "%v++", n.Left())
+				fmt.Fprintf(s, "%v++", n.Left())
 			} else {
-				mode.Fprintf(s, "%v--", n.Left())
+				fmt.Fprintf(s, "%v--", n.Left())
 			}
 			break
 		}
 
-		mode.Fprintf(s, "%v %#v= %v", n.Left(), n.SubOp(), n.Right())
+		fmt.Fprintf(s, "%v %#v= %v", n.Left(), n.SubOp(), n.Right())
 
 	case OAS2, OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV:
 		if n.Colas() && !complexinit {
-			mode.Fprintf(s, "%.v := %.v", n.List(), n.Rlist())
+			fmt.Fprintf(s, "%.v := %.v", n.List(), n.Rlist())
 		} else {
-			mode.Fprintf(s, "%.v = %.v", n.List(), n.Rlist())
+			fmt.Fprintf(s, "%.v = %.v", n.List(), n.Rlist())
 		}
 
 	case OBLOCK:
 		if n.List().Len() != 0 {
-			mode.Fprintf(s, "%v", n.List())
+			fmt.Fprintf(s, "%v", n.List())
 		}
 
 	case ORETURN:
-		mode.Fprintf(s, "return %.v", n.List())
+		fmt.Fprintf(s, "return %.v", n.List())
 
 	case ORETJMP:
-		mode.Fprintf(s, "retjmp %v", n.Sym())
+		fmt.Fprintf(s, "retjmp %v", n.Sym())
 
 	case OINLMARK:
-		mode.Fprintf(s, "inlmark %d", n.Offset())
+		fmt.Fprintf(s, "inlmark %d", n.Offset())
 
 	case OGO:
-		mode.Fprintf(s, "go %v", n.Left())
+		fmt.Fprintf(s, "go %v", n.Left())
 
 	case ODEFER:
-		mode.Fprintf(s, "defer %v", n.Left())
+		fmt.Fprintf(s, "defer %v", n.Left())
 
 	case OIF:
 		if simpleinit {
-			mode.Fprintf(s, "if %v; %v { %v }", n.Init().First(), n.Left(), n.Body())
+			fmt.Fprintf(s, "if %v; %v { %v }", n.Init().First(), n.Left(), n.Body())
 		} else {
-			mode.Fprintf(s, "if %v { %v }", n.Left(), n.Body())
+			fmt.Fprintf(s, "if %v { %v }", n.Left(), n.Body())
 		}
 		if n.Rlist().Len() != 0 {
-			mode.Fprintf(s, " else { %v }", n.Rlist())
+			fmt.Fprintf(s, " else { %v }", n.Rlist())
 		}
 
 	case OFOR, OFORUNTIL:
@@ -1180,80 +1149,80 @@ func stmtFmt(n Node, s fmt.State, mode FmtMode) {
 		if n.Op() == OFORUNTIL {
 			opname = "foruntil"
 		}
-		if mode == FErr { // TODO maybe only if FmtShort, same below
+		if !exportFormat { // TODO maybe only if FmtShort, same below
 			fmt.Fprintf(s, "%s loop", opname)
 			break
 		}
 
 		fmt.Fprint(s, opname)
 		if simpleinit {
-			mode.Fprintf(s, " %v;", n.Init().First())
+			fmt.Fprintf(s, " %v;", n.Init().First())
 		} else if n.Right() != nil {
 			fmt.Fprint(s, " ;")
 		}
 
 		if n.Left() != nil {
-			mode.Fprintf(s, " %v", n.Left())
+			fmt.Fprintf(s, " %v", n.Left())
 		}
 
 		if n.Right() != nil {
-			mode.Fprintf(s, "; %v", n.Right())
+			fmt.Fprintf(s, "; %v", n.Right())
 		} else if simpleinit {
 			fmt.Fprint(s, ";")
 		}
 
 		if n.Op() == OFORUNTIL && n.List().Len() != 0 {
-			mode.Fprintf(s, "; %v", n.List())
+			fmt.Fprintf(s, "; %v", n.List())
 		}
 
-		mode.Fprintf(s, " { %v }", n.Body())
+		fmt.Fprintf(s, " { %v }", n.Body())
 
 	case ORANGE:
-		if mode == FErr {
+		if !exportFormat {
 			fmt.Fprint(s, "for loop")
 			break
 		}
 
 		if n.List().Len() == 0 {
-			mode.Fprintf(s, "for range %v { %v }", n.Right(), n.Body())
+			fmt.Fprintf(s, "for range %v { %v }", n.Right(), n.Body())
 			break
 		}
 
-		mode.Fprintf(s, "for %.v = range %v { %v }", n.List(), n.Right(), n.Body())
+		fmt.Fprintf(s, "for %.v = range %v { %v }", n.List(), n.Right(), n.Body())
 
 	case OSELECT, OSWITCH:
-		if mode == FErr {
-			mode.Fprintf(s, "%v statement", n.Op())
+		if !exportFormat {
+			fmt.Fprintf(s, "%v statement", n.Op())
 			break
 		}
 
-		mode.Fprintf(s, "%#v", n.Op())
+		fmt.Fprintf(s, "%#v", n.Op())
 		if simpleinit {
-			mode.Fprintf(s, " %v;", n.Init().First())
+			fmt.Fprintf(s, " %v;", n.Init().First())
 		}
 		if n.Left() != nil {
-			mode.Fprintf(s, " %v ", n.Left())
+			fmt.Fprintf(s, " %v ", n.Left())
 		}
 
-		mode.Fprintf(s, " { %v }", n.List())
+		fmt.Fprintf(s, " { %v }", n.List())
 
 	case OCASE:
 		if n.List().Len() != 0 {
-			mode.Fprintf(s, "case %.v", n.List())
+			fmt.Fprintf(s, "case %.v", n.List())
 		} else {
 			fmt.Fprint(s, "default")
 		}
-		mode.Fprintf(s, ": %v", n.Body())
+		fmt.Fprintf(s, ": %v", n.Body())
 
 	case OBREAK, OCONTINUE, OGOTO, OFALL:
 		if n.Sym() != nil {
-			mode.Fprintf(s, "%#v %v", n.Op(), n.Sym())
+			fmt.Fprintf(s, "%#v %v", n.Op(), n.Sym())
 		} else {
-			mode.Fprintf(s, "%#v", n.Op())
+			fmt.Fprintf(s, "%#v", n.Op())
 		}
 
 	case OLABEL:
-		mode.Fprintf(s, "%v: ", n.Sym())
+		fmt.Fprintf(s, "%v: ", n.Sym())
 	}
 
 	if extrablock {
@@ -1261,7 +1230,15 @@ func stmtFmt(n Node, s fmt.State, mode FmtMode) {
 	}
 }
 
-func exprFmt(n Node, s fmt.State, prec int, mode FmtMode) {
+func exprFmt(n Node, s fmt.State, prec int) {
+	// NOTE(rsc): This code used to support the text-based
+	// which was more aggressive about printing full Go syntax
+	// (for example, an actual loop instead of "for loop").
+	// The code is preserved for now in case we want to expand
+	// any of those shortenings later. Or maybe we will delete
+	// the code. But for now, keep it.
+	const exportFormat = false
+
 	for {
 		if n == nil {
 			fmt.Fprint(s, "<N>")
@@ -1292,20 +1269,20 @@ func exprFmt(n Node, s fmt.State, prec int, mode FmtMode) {
 	}
 
 	if prec > nprec {
-		mode.Fprintf(s, "(%v)", n)
+		fmt.Fprintf(s, "(%v)", n)
 		return
 	}
 
 	switch n.Op() {
 	case OPAREN:
-		mode.Fprintf(s, "(%v)", n.Left())
+		fmt.Fprintf(s, "(%v)", n.Left())
 
 	case ONIL:
 		fmt.Fprint(s, "nil")
 
 	case OLITERAL: // this is a bit of a mess
-		if mode == FErr && n.Sym() != nil {
-			fmt.Fprint(s, smodeString(n.Sym(), mode))
+		if !exportFormat && n.Sym() != nil {
+			fmt.Fprint(s, smodeString(n.Sym(), FErr))
 			return
 		}
 
@@ -1314,9 +1291,9 @@ func exprFmt(n Node, s fmt.State, prec int, mode FmtMode) {
 			// Need parens when type begins with what might
 			// be misinterpreted as a unary operator: * or <-.
 			if n.Type().IsPtr() || (n.Type().IsChan() && n.Type().ChanDir() == types.Crecv) {
-				mode.Fprintf(s, "(%v)(", n.Type())
+				fmt.Fprintf(s, "(%v)(", n.Type())
 			} else {
-				mode.Fprintf(s, "%v(", n.Type())
+				fmt.Fprintf(s, "%v(", n.Type())
 			}
 			needUnparen = true
 		}
@@ -1342,68 +1319,68 @@ func exprFmt(n Node, s fmt.State, prec int, mode FmtMode) {
 		}
 
 		if needUnparen {
-			mode.Fprintf(s, ")")
+			fmt.Fprintf(s, ")")
 		}
 
 	case ODCLFUNC:
 		if sym := n.Sym(); sym != nil {
-			fmt.Fprint(s, smodeString(sym, mode))
+			fmt.Fprint(s, smodeString(sym, FErr))
 			return
 		}
-		mode.Fprintf(s, "<unnamed Func>")
+		fmt.Fprintf(s, "<unnamed Func>")
 
 	case ONAME:
 		// Special case: name used as local variable in export.
 		// _ becomes ~b%d internally; print as _ for export
-		if mode == FErr && n.Sym() != nil && n.Sym().Name[0] == '~' && n.Sym().Name[1] == 'b' {
+		if !exportFormat && n.Sym() != nil && n.Sym().Name[0] == '~' && n.Sym().Name[1] == 'b' {
 			fmt.Fprint(s, "_")
 			return
 		}
 		fallthrough
 	case OPACK, ONONAME, OMETHEXPR:
-		fmt.Fprint(s, smodeString(n.Sym(), mode))
+		fmt.Fprint(s, smodeString(n.Sym(), FErr))
 
 	case OTYPE:
 		if n.Type() == nil && n.Sym() != nil {
-			fmt.Fprint(s, smodeString(n.Sym(), mode))
+			fmt.Fprint(s, smodeString(n.Sym(), FErr))
 			return
 		}
-		mode.Fprintf(s, "%v", n.Type())
+		fmt.Fprintf(s, "%v", n.Type())
 
 	case OTSLICE:
 		n := n.(*SliceType)
 		if n.DDD {
-			mode.Fprintf(s, "...%v", n.Elem)
+			fmt.Fprintf(s, "...%v", n.Elem)
 		} else {
-			mode.Fprintf(s, "[]%v", n.Elem) // happens before typecheck
+			fmt.Fprintf(s, "[]%v", n.Elem) // happens before typecheck
 		}
 
 	case OTARRAY:
 		n := n.(*ArrayType)
 		if n.Len == nil {
-			mode.Fprintf(s, "[...]%v", n.Elem)
+			fmt.Fprintf(s, "[...]%v", n.Elem)
 		} else {
-			mode.Fprintf(s, "[%v]%v", n.Len, n.Elem)
+			fmt.Fprintf(s, "[%v]%v", n.Len, n.Elem)
 		}
 
 	case OTMAP:
 		n := n.(*MapType)
-		mode.Fprintf(s, "map[%v]%v", n.Key, n.Elem)
+		fmt.Fprintf(s, "map[%v]%v", n.Key, n.Elem)
 
 	case OTCHAN:
 		n := n.(*ChanType)
 		switch n.Dir {
 		case types.Crecv:
-			mode.Fprintf(s, "<-chan %v", n.Elem)
+			fmt.Fprintf(s, "<-chan %v", n.Elem)
 
 		case types.Csend:
-			mode.Fprintf(s, "chan<- %v", n.Elem)
+			fmt.Fprintf(s, "chan<- %v", n.Elem)
 
 		default:
 			if n.Elem != nil && n.Elem.Op() == OTCHAN && n.Elem.(*ChanType).Dir == types.Crecv {
-				mode.Fprintf(s, "chan (%v)", n.Elem)
+				fmt.Fprintf(s, "chan (%v)", n.Elem)
 			} else {
-				mode.Fprintf(s, "chan %v", n.Elem)
+				fmt.Fprintf(s, "chan %v", n.Elem)
 			}
 		}
 
@@ -1417,104 +1394,104 @@ func exprFmt(n Node, s fmt.State, prec int, mode FmtMode) {
 		fmt.Fprint(s, "<func>")
 
 	case OCLOSURE:
-		if mode == FErr {
+		if !exportFormat {
 			fmt.Fprint(s, "func literal")
 			return
 		}
 		if n.Body().Len() != 0 {
-			mode.Fprintf(s, "%v { %v }", n.Type(), n.Body())
+			fmt.Fprintf(s, "%v { %v }", n.Type(), n.Body())
 			return
 		}
-		mode.Fprintf(s, "%v { %v }", n.Type(), n.Func().Body())
+		fmt.Fprintf(s, "%v { %v }", n.Type(), n.Func().Body())
 
 	case OCOMPLIT:
-		if mode == FErr {
+		if !exportFormat {
 			if n.Implicit() {
-				mode.Fprintf(s, "... argument")
+				fmt.Fprintf(s, "... argument")
 				return
 			}
 			if n.Right() != nil {
-				mode.Fprintf(s, "%v{%s}", n.Right(), ellipsisIf(n.List().Len() != 0))
+				fmt.Fprintf(s, "%v{%s}", n.Right(), ellipsisIf(n.List().Len() != 0))
 				return
 			}
 
 			fmt.Fprint(s, "composite literal")
 			return
 		}
-		mode.Fprintf(s, "(%v{ %.v })", n.Right(), n.List())
+		fmt.Fprintf(s, "(%v{ %.v })", n.Right(), n.List())
 
 	case OPTRLIT:
-		mode.Fprintf(s, "&%v", n.Left())
+		fmt.Fprintf(s, "&%v", n.Left())
 
 	case OSTRUCTLIT, OARRAYLIT, OSLICELIT, OMAPLIT:
-		if mode == FErr {
-			mode.Fprintf(s, "%v{%s}", n.Type(), ellipsisIf(n.List().Len() != 0))
+		if !exportFormat {
+			fmt.Fprintf(s, "%v{%s}", n.Type(), ellipsisIf(n.List().Len() != 0))
 			return
 		}
-		mode.Fprintf(s, "(%v{ %.v })", n.Type(), n.List())
+		fmt.Fprintf(s, "(%v{ %.v })", n.Type(), n.List())
 
 	case OKEY:
 		if n.Left() != nil && n.Right() != nil {
-			mode.Fprintf(s, "%v:%v", n.Left(), n.Right())
+			fmt.Fprintf(s, "%v:%v", n.Left(), n.Right())
 			return
 		}
 
 		if n.Left() == nil && n.Right() != nil {
-			mode.Fprintf(s, ":%v", n.Right())
+			fmt.Fprintf(s, ":%v", n.Right())
 			return
 		}
 		if n.Left() != nil && n.Right() == nil {
-			mode.Fprintf(s, "%v:", n.Left())
+			fmt.Fprintf(s, "%v:", n.Left())
 			return
 		}
 		fmt.Fprint(s, ":")
 
 	case OSTRUCTKEY:
-		mode.Fprintf(s, "%v:%v", n.Sym(), n.Left())
+		fmt.Fprintf(s, "%v:%v", n.Sym(), n.Left())
 
 	case OCALLPART:
-		exprFmt(n.Left(), s, nprec, mode)
+		exprFmt(n.Left(), s, nprec)
 		if n.Sym() == nil {
 			fmt.Fprint(s, ".<nil>")
 			return
 		}
-		mode.Fprintf(s, ".%0S", n.Sym())
+		fmt.Fprintf(s, ".%0S", n.Sym())
 
 	case OXDOT, ODOT, ODOTPTR, ODOTINTER, ODOTMETH:
-		exprFmt(n.Left(), s, nprec, mode)
+		exprFmt(n.Left(), s, nprec)
 		if n.Sym() == nil {
 			fmt.Fprint(s, ".<nil>")
 			return
 		}
-		mode.Fprintf(s, ".%0S", n.Sym())
+		fmt.Fprintf(s, ".%0S", n.Sym())
 
 	case ODOTTYPE, ODOTTYPE2:
-		exprFmt(n.Left(), s, nprec, mode)
+		exprFmt(n.Left(), s, nprec)
 		if n.Right() != nil {
-			mode.Fprintf(s, ".(%v)", n.Right())
+			fmt.Fprintf(s, ".(%v)", n.Right())
 			return
 		}
-		mode.Fprintf(s, ".(%v)", n.Type())
+		fmt.Fprintf(s, ".(%v)", n.Type())
 
 	case OINDEX, OINDEXMAP:
-		exprFmt(n.Left(), s, nprec, mode)
-		mode.Fprintf(s, "[%v]", n.Right())
+		exprFmt(n.Left(), s, nprec)
+		fmt.Fprintf(s, "[%v]", n.Right())
 
 	case OSLICE, OSLICESTR, OSLICEARR, OSLICE3, OSLICE3ARR:
-		exprFmt(n.Left(), s, nprec, mode)
+		exprFmt(n.Left(), s, nprec)
 		fmt.Fprint(s, "[")
 		low, high, max := n.SliceBounds()
 		if low != nil {
-			fmt.Fprint(s, modeString(low, mode))
+			fmt.Fprint(s, low)
 		}
 		fmt.Fprint(s, ":")
 		if high != nil {
-			fmt.Fprint(s, modeString(high, mode))
+			fmt.Fprint(s, high)
 		}
 		if n.Op().IsSlice3() {
 			fmt.Fprint(s, ":")
 			if max != nil {
-				fmt.Fprint(s, modeString(max, mode))
+				fmt.Fprint(s, max)
 			}
 		}
 		fmt.Fprint(s, "]")
@@ -1523,13 +1500,13 @@ func exprFmt(n Node, s fmt.State, prec int, mode FmtMode) {
 		if n.List().Len() != 2 {
 			base.Fatalf("bad OSLICEHEADER list length %d", n.List().Len())
 		}
-		mode.Fprintf(s, "sliceheader{%v,%v,%v}", n.Left(), n.List().First(), n.List().Second())
+		fmt.Fprintf(s, "sliceheader{%v,%v,%v}", n.Left(), n.List().First(), n.List().Second())
 
 	case OCOMPLEX, OCOPY:
 		if n.Left() != nil {
-			mode.Fprintf(s, "%#v(%v, %v)", n.Op(), n.Left(), n.Right())
+			fmt.Fprintf(s, "%#v(%v, %v)", n.Op(), n.Left(), n.Right())
 		} else {
-			mode.Fprintf(s, "%#v(%.v)", n.Op(), n.List())
+			fmt.Fprintf(s, "%#v(%.v)", n.Op(), n.List())
 		}
 
 	case OCONV,
@@ -1541,14 +1518,14 @@ func exprFmt(n Node, s fmt.State, prec int, mode FmtMode) {
 		OSTR2RUNES,
 		ORUNESTR:
 		if n.Type() == nil || n.Type().Sym() == nil {
-			mode.Fprintf(s, "(%v)", n.Type())
+			fmt.Fprintf(s, "(%v)", n.Type())
 		} else {
-			mode.Fprintf(s, "%v", n.Type())
+			fmt.Fprintf(s, "%v", n.Type())
 		}
 		if n.Left() != nil {
-			mode.Fprintf(s, "(%v)", n.Left())
+			fmt.Fprintf(s, "(%v)", n.Left())
 		} else {
-			mode.Fprintf(s, "(%.v)", n.List())
+			fmt.Fprintf(s, "(%.v)", n.List())
 		}
 
 	case OREAL,
@@ -1568,48 +1545,48 @@ func exprFmt(n Node, s fmt.State, prec int, mode FmtMode) {
 		OPRINT,
 		OPRINTN:
 		if n.Left() != nil {
-			mode.Fprintf(s, "%#v(%v)", n.Op(), n.Left())
+			fmt.Fprintf(s, "%#v(%v)", n.Op(), n.Left())
 			return
 		}
 		if n.IsDDD() {
-			mode.Fprintf(s, "%#v(%.v...)", n.Op(), n.List())
+			fmt.Fprintf(s, "%#v(%.v...)", n.Op(), n.List())
 			return
 		}
-		mode.Fprintf(s, "%#v(%.v)", n.Op(), n.List())
+		fmt.Fprintf(s, "%#v(%.v)", n.Op(), n.List())
 
 	case OCALL, OCALLFUNC, OCALLINTER, OCALLMETH, OGETG:
-		exprFmt(n.Left(), s, nprec, mode)
+		exprFmt(n.Left(), s, nprec)
 		if n.IsDDD() {
-			mode.Fprintf(s, "(%.v...)", n.List())
+			fmt.Fprintf(s, "(%.v...)", n.List())
 			return
 		}
-		mode.Fprintf(s, "(%.v)", n.List())
+		fmt.Fprintf(s, "(%.v)", n.List())
 
 	case OMAKEMAP, OMAKECHAN, OMAKESLICE:
 		if n.List().Len() != 0 { // pre-typecheck
-			mode.Fprintf(s, "make(%v, %.v)", n.Type(), n.List())
+			fmt.Fprintf(s, "make(%v, %.v)", n.Type(), n.List())
 			return
 		}
 		if n.Right() != nil {
-			mode.Fprintf(s, "make(%v, %v, %v)", n.Type(), n.Left(), n.Right())
+			fmt.Fprintf(s, "make(%v, %v, %v)", n.Type(), n.Left(), n.Right())
 			return
 		}
 		if n.Left() != nil && (n.Op() == OMAKESLICE || !n.Left().Type().IsUntyped()) {
-			mode.Fprintf(s, "make(%v, %v)", n.Type(), n.Left())
+			fmt.Fprintf(s, "make(%v, %v)", n.Type(), n.Left())
 			return
 		}
-		mode.Fprintf(s, "make(%v)", n.Type())
+		fmt.Fprintf(s, "make(%v)", n.Type())
 
 	case OMAKESLICECOPY:
-		mode.Fprintf(s, "makeslicecopy(%v, %v, %v)", n.Type(), n.Left(), n.Right())
+		fmt.Fprintf(s, "makeslicecopy(%v, %v, %v)", n.Type(), n.Left(), n.Right())
 
 	case OPLUS, ONEG, OADDR, OBITNOT, ODEREF, ONOT, ORECV:
 		// Unary
-		mode.Fprintf(s, "%#v", n.Op())
+		fmt.Fprintf(s, "%#v", n.Op())
 		if n.Left() != nil && n.Left().Op() == n.Op() {
 			fmt.Fprint(s, " ")
 		}
-		exprFmt(n.Left(), s, nprec+1, mode)
+		exprFmt(n.Left(), s, nprec+1)
 
 		// Binary
 	case OADD,
@@ -1632,19 +1609,19 @@ func exprFmt(n Node, s fmt.State, prec int, mode FmtMode) {
 		OSEND,
 		OSUB,
 		OXOR:
-		exprFmt(n.Left(), s, nprec, mode)
-		mode.Fprintf(s, " %#v ", n.Op())
-		exprFmt(n.Right(), s, nprec+1, mode)
+		exprFmt(n.Left(), s, nprec)
+		fmt.Fprintf(s, " %#v ", n.Op())
+		exprFmt(n.Right(), s, nprec+1)
 
 	case OADDSTR:
 		for i, n1 := range n.List().Slice() {
 			if i != 0 {
 				fmt.Fprint(s, " + ")
 			}
-			exprFmt(n1, s, nprec, mode)
+			exprFmt(n1, s, nprec)
 		}
 	default:
-		mode.Fprintf(s, "<node %v>", n.Op())
+		fmt.Fprintf(s, "<node %v>", n.Op())
 	}
 }
 
@@ -1657,45 +1634,25 @@ func ellipsisIf(b bool) string {
 
 // Nodes
 
-type fmtNodes struct {
-	x Nodes
-	m FmtMode
-}
-
-func (f *fmtNodes) Format(s fmt.State, verb rune) { f.x.format(s, verb, FErr) }
-
-func (l Nodes) Format(s fmt.State, verb rune) { l.format(s, verb, FErr) }
-
-func (l Nodes) format(s fmt.State, verb rune, mode FmtMode) {
+func (l Nodes) Format(s fmt.State, verb rune) {
 	if s.Flag('+') && verb == 'v' {
 		// %+v is DumpList output
 		dumpNodes(s, l, 1)
 		return
 	}
 
-	switch verb {
-	case 'v':
-		l.hconv(s, fmtFlag(s, verb), mode)
-
-	default:
+	if verb != 'v' {
 		fmt.Fprintf(s, "%%!%c(Nodes)", verb)
+		return
 	}
-}
 
-func (n Nodes) String() string {
-	return fmt.Sprint(n)
-}
-
-// Flags: all those of %N plus '.': separate with comma's instead of semicolons.
-func (l Nodes) hconv(s fmt.State, flag FmtFlag, mode FmtMode) {
-	flag, mode = flag.update(mode)
 	sep := "; "
-	if flag&FmtComma != 0 {
+	if _, ok := s.Precision(); ok { // %.v is expr list
 		sep = ", "
 	}
 
 	for i, n := range l.Slice() {
-		fmt.Fprint(s, modeString(n, mode))
+		fmt.Fprint(s, n)
 		if i+1 < l.Len() {
 			fmt.Fprint(s, sep)
 		}
-- 
GitLab


From fb17dfa43d1c8e08d08f380ea082195d1c4f89f4 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 5 Dec 2020 15:20:51 -0500
Subject: [PATCH 0174/2400] [dev.regabi] cmd/compile: narrow interface between
 ir and types

Narrow the interface between package ir and package types
to make it easier to clean up the type formatting code all in one place.

Also introduce ir.BlankSym for use by OrigSym, so that later
OrigSym can move to package types without needing to reference
a variable of type ir.Node.

Passes buildall w/ toolstash -cmp.

Change-Id: I39fa419a1c8fb3318203e31cacc8d06399deeff9
Reviewed-on: https://go-review.googlesource.com/c/go/+/275776
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/main.go         |  5 ---
 src/cmd/compile/internal/gc/universe.go     |  1 +
 src/cmd/compile/internal/ir/fmt.go          | 25 ++++++++------
 src/cmd/compile/internal/ir/node.go         |  4 ++-
 src/cmd/compile/internal/ssa/export_test.go | 15 +--------
 src/cmd/compile/internal/types/scope.go     |  7 ++--
 src/cmd/compile/internal/types/sym.go       |  5 +--
 src/cmd/compile/internal/types/type.go      | 28 ++++++++--------
 src/cmd/compile/internal/types/utils.go     | 36 +++++++++------------
 9 files changed, 59 insertions(+), 67 deletions(-)

diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 96031fe511..a40671bccf 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -212,15 +212,10 @@ func Main(archInit func(*Arch)) {
 	// would lead to import cycles)
 	types.Widthptr = Widthptr
 	types.Dowidth = dowidth
-	types.Fatalf = base.Fatalf
 	ir.InstallTypeFormats()
 	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
 		return typenamesym(t).Linksym()
 	}
-	types.FmtLeft = int(ir.FmtLeft)
-	types.FmtUnsigned = int(ir.FmtUnsigned)
-	types.FErr = int(ir.FErr)
-	types.Ctxt = base.Ctxt
 
 	initUniverse()
 
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index f9984cbe94..cd68719a99 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -182,6 +182,7 @@ func initUniverse() {
 	ir.AsNode(s.Def).SetSym(lookup("false"))
 
 	s = lookup("_")
+	ir.BlankSym = s
 	s.Block = -100
 	s.Def = NewName(s)
 	types.Types[types.TBLANK] = types.New(types.TBLANK)
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index b0c732ae56..88534864a9 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -339,7 +339,8 @@ func symFormat(s *types.Sym, f fmt.State, verb rune, mode FmtMode) {
 
 func smodeString(s *types.Sym, mode FmtMode) string { return sconv(s, 0, mode) }
 
-// See #16897 before changing the implementation of sconv.
+// See #16897 for details about performance implications
+// before changing the implementation of sconv.
 func sconv(s *types.Sym, flag FmtFlag, mode FmtMode) string {
 	if flag&FmtLong != 0 {
 		panic("linksymfmt")
@@ -472,17 +473,23 @@ var fmtBufferPool = sync.Pool{
 }
 
 func InstallTypeFormats() {
-	types.Sconv = func(s *types.Sym, flag, mode int) string {
-		return sconv(s, FmtFlag(flag), FmtMode(mode))
+	types.SymString = func(s *types.Sym) string {
+		return sconv(s, 0, FErr)
 	}
-	types.Tconv = func(t *types.Type, flag, mode int) string {
-		return tconv(t, FmtFlag(flag), FmtMode(mode))
+	types.TypeString = func(t *types.Type) string {
+		return tconv(t, 0, FErr)
 	}
-	types.FormatSym = func(sym *types.Sym, s fmt.State, verb rune, mode int) {
-		symFormat(sym, s, verb, FmtMode(mode))
+	types.TypeShortString = func(t *types.Type) string {
+		return tconv(t, FmtLeft, FErr)
 	}
-	types.FormatType = func(t *types.Type, s fmt.State, verb rune, mode int) {
-		typeFormat(t, s, verb, FmtMode(mode))
+	types.TypeLongString = func(t *types.Type) string {
+		return tconv(t, FmtLeft|FmtUnsigned, FErr)
+	}
+	types.FormatSym = func(sym *types.Sym, s fmt.State, verb rune) {
+		symFormat(sym, s, verb, FErr)
+	}
+	types.FormatType = func(t *types.Type, s fmt.State, verb rune) {
+		typeFormat(t, s, verb, FErr)
 	}
 }
 
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 83f5b0cf78..56b320e726 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -654,6 +654,8 @@ func AsNode(n types.Object) Node {
 
 var BlankNode Node
 
+var BlankSym *types.Sym
+
 // origSym returns the original symbol written by the user.
 func OrigSym(s *types.Sym) *types.Sym {
 	if s == nil {
@@ -666,7 +668,7 @@ func OrigSym(s *types.Sym) *types.Sym {
 			return nil
 		case 'b': // originally the blank identifier _
 			// TODO(mdempsky): Does s.Pkg matter here?
-			return BlankNode.Sym()
+			return BlankSym
 		}
 		return s
 	}
diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go
index 5a81f76ceb..cb3b9c0e2a 100644
--- a/src/cmd/compile/internal/ssa/export_test.go
+++ b/src/cmd/compile/internal/ssa/export_test.go
@@ -12,7 +12,6 @@ import (
 	"cmd/internal/obj/s390x"
 	"cmd/internal/obj/x86"
 	"cmd/internal/src"
-	"fmt"
 	"testing"
 )
 
@@ -138,19 +137,7 @@ func init() {
 	// Initialize just enough of the universe and the types package to make our tests function.
 	// TODO(josharian): move universe initialization to the types package,
 	// so this test setup can share it.
-
-	types.Tconv = func(t *types.Type, flag, mode int) string {
-		return t.Kind().String()
-	}
-	types.Sconv = func(s *types.Sym, flag, mode int) string {
-		return "sym"
-	}
-	types.FormatSym = func(sym *types.Sym, s fmt.State, verb rune, mode int) {
-		fmt.Fprintf(s, "sym")
-	}
-	types.FormatType = func(t *types.Type, s fmt.State, verb rune, mode int) {
-		fmt.Fprintf(s, "%v", t.Kind())
-	}
+	ir.InstallTypeFormats()
 	types.Dowidth = func(t *types.Type) {}
 
 	for _, typ := range [...]struct {
diff --git a/src/cmd/compile/internal/types/scope.go b/src/cmd/compile/internal/types/scope.go
index 37ac90a025..04ea3c325f 100644
--- a/src/cmd/compile/internal/types/scope.go
+++ b/src/cmd/compile/internal/types/scope.go
@@ -4,7 +4,10 @@
 
 package types
 
-import "cmd/internal/src"
+import (
+	"cmd/compile/internal/base"
+	"cmd/internal/src"
+)
 
 // Declaration stack & operations
 
@@ -56,7 +59,7 @@ func Popdcl() {
 		d.sym = nil
 		d.def = nil
 	}
-	Fatalf("popdcl: no stack mark")
+	base.Fatalf("popdcl: no stack mark")
 }
 
 // Markdcl records the start of a new block scope for declarations.
diff --git a/src/cmd/compile/internal/types/sym.go b/src/cmd/compile/internal/types/sym.go
index 490222d843..fcb095c53c 100644
--- a/src/cmd/compile/internal/types/sym.go
+++ b/src/cmd/compile/internal/types/sym.go
@@ -5,6 +5,7 @@
 package types
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/internal/obj"
 	"cmd/internal/src"
 	"unicode"
@@ -88,9 +89,9 @@ func (sym *Sym) Linksym() *obj.LSym {
 	}
 	if sym.Func() {
 		// This is a function symbol. Mark it as "internal ABI".
-		return Ctxt.LookupABIInit(sym.LinksymName(), obj.ABIInternal, initPkg)
+		return base.Ctxt.LookupABIInit(sym.LinksymName(), obj.ABIInternal, initPkg)
 	}
-	return Ctxt.LookupInit(sym.LinksymName(), initPkg)
+	return base.Ctxt.LookupInit(sym.LinksymName(), initPkg)
 }
 
 // Less reports whether symbol a is ordered before symbol b.
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 2c42e5579d..c5807af199 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -231,7 +231,7 @@ func (t *Type) Pkg() *Pkg {
 	case TINTER:
 		return t.Extra.(*Interface).pkg
 	default:
-		Fatalf("Pkg: unexpected kind: %v", t)
+		base.Fatalf("Pkg: unexpected kind: %v", t)
 		return nil
 	}
 }
@@ -501,7 +501,7 @@ func New(et Kind) *Type {
 // NewArray returns a new fixed-length array Type.
 func NewArray(elem *Type, bound int64) *Type {
 	if bound < 0 {
-		Fatalf("NewArray: invalid bound %v", bound)
+		base.Fatalf("NewArray: invalid bound %v", bound)
 	}
 	t := New(TARRAY)
 	t.Extra = &Array{Elem: elem, Bound: bound}
@@ -513,7 +513,7 @@ func NewArray(elem *Type, bound int64) *Type {
 func NewSlice(elem *Type) *Type {
 	if t := elem.cache.slice; t != nil {
 		if t.Elem() != elem {
-			Fatalf("elem mismatch")
+			base.Fatalf("elem mismatch")
 		}
 		return t
 	}
@@ -569,12 +569,12 @@ var NewPtrCacheEnabled = true
 // NewPtr returns the pointer type pointing to t.
 func NewPtr(elem *Type) *Type {
 	if elem == nil {
-		Fatalf("NewPtr: pointer to elem Type is nil")
+		base.Fatalf("NewPtr: pointer to elem Type is nil")
 	}
 
 	if t := elem.cache.ptr; t != nil {
 		if t.Elem() != elem {
-			Fatalf("NewPtr: elem mismatch")
+			base.Fatalf("NewPtr: elem mismatch")
 		}
 		return t
 	}
@@ -629,7 +629,7 @@ func SubstAny(t *Type, types *[]*Type) *Type {
 
 	case TANY:
 		if len(*types) == 0 {
-			Fatalf("substArgTypes: not enough argument types")
+			base.Fatalf("substArgTypes: not enough argument types")
 		}
 		t = (*types)[0]
 		*types = (*types)[1:]
@@ -730,7 +730,7 @@ func (t *Type) copy() *Type {
 		x := *t.Extra.(*Array)
 		nt.Extra = &x
 	case TTUPLE, TSSA, TRESULTS:
-		Fatalf("ssa types cannot be copied")
+		base.Fatalf("ssa types cannot be copied")
 	}
 	// TODO(mdempsky): Find out why this is necessary and explain.
 	if t.underlying == t {
@@ -746,7 +746,7 @@ func (f *Field) Copy() *Field {
 
 func (t *Type) wantEtype(et Kind) {
 	if t.kind != et {
-		Fatalf("want %v, but have %v", et, t)
+		base.Fatalf("want %v, but have %v", et, t)
 	}
 }
 
@@ -811,7 +811,7 @@ func (t *Type) Elem() *Type {
 	case TMAP:
 		return t.Extra.(*Map).Elem
 	}
-	Fatalf("Type.Elem %s", t.kind)
+	base.Fatalf("Type.Elem %s", t.kind)
 	return nil
 }
 
@@ -850,7 +850,7 @@ func (t *Type) Fields() *Fields {
 		Dowidth(t)
 		return &t.Extra.(*Interface).Fields
 	}
-	Fatalf("Fields: type %v does not have fields", t)
+	base.Fatalf("Fields: type %v does not have fields", t)
 	return nil
 }
 
@@ -874,7 +874,7 @@ func (t *Type) SetFields(fields []*Field) {
 	// enforce that SetFields cannot be called once
 	// t's width has been calculated.
 	if t.WidthCalculated() {
-		Fatalf("SetFields of %v: width previously calculated", t)
+		base.Fatalf("SetFields of %v: width previously calculated", t)
 	}
 	t.wantEtype(TSTRUCT)
 	for _, f := range fields {
@@ -1223,7 +1223,7 @@ var unsignedEType = [...]Kind{
 // ToUnsigned returns the unsigned equivalent of integer type t.
 func (t *Type) ToUnsigned() *Type {
 	if !t.IsInteger() {
-		Fatalf("unsignedType(%v)", t)
+		base.Fatalf("unsignedType(%v)", t)
 	}
 	return Types[unsignedEType[t.kind]]
 }
@@ -1385,7 +1385,7 @@ func (t *Type) NumComponents(countBlank componentsIncludeBlankFields) int64 {
 	switch t.kind {
 	case TSTRUCT:
 		if t.IsFuncArgStruct() {
-			Fatalf("NumComponents func arg struct")
+			base.Fatalf("NumComponents func arg struct")
 		}
 		var n int64
 		for _, f := range t.FieldSlice() {
@@ -1408,7 +1408,7 @@ func (t *Type) SoleComponent() *Type {
 	switch t.kind {
 	case TSTRUCT:
 		if t.IsFuncArgStruct() {
-			Fatalf("SoleComponent func arg struct")
+			base.Fatalf("SoleComponent func arg struct")
 		}
 		if t.NumFields() != 1 {
 			return nil
diff --git a/src/cmd/compile/internal/types/utils.go b/src/cmd/compile/internal/types/utils.go
index e8b1073818..a1be77eef1 100644
--- a/src/cmd/compile/internal/types/utils.go
+++ b/src/cmd/compile/internal/types/utils.go
@@ -15,51 +15,47 @@ const BADWIDTH = -1000000000
 // They are here to break import cycles.
 // TODO(gri) eliminate these dependencies.
 var (
-	Widthptr    int
-	Dowidth     func(*Type)
-	Fatalf      func(string, ...interface{})
-	Sconv       func(*Sym, int, int) string       // orig: func sconv(s *Sym, flag FmtFlag, mode fmtMode) string
-	Tconv       func(*Type, int, int) string      // orig: func tconv(t *Type, flag FmtFlag, mode fmtMode) string
-	FormatSym   func(*Sym, fmt.State, rune, int)  // orig: func symFormat(sym *Sym, s fmt.State, verb rune, mode fmtMode)
-	FormatType  func(*Type, fmt.State, rune, int) // orig: func typeFormat(t *Type, s fmt.State, verb rune, mode fmtMode)
-	TypeLinkSym func(*Type) *obj.LSym
-	Ctxt        *obj.Link
-
-	FmtLeft     int
-	FmtUnsigned int
-	FErr        int
+	Widthptr        int
+	Dowidth         func(*Type)
+	SymString       func(*Sym) string
+	TypeString      func(*Type) string
+	TypeShortString func(*Type) string
+	TypeLongString  func(*Type) string
+	FormatSym       func(*Sym, fmt.State, rune)
+	FormatType      func(*Type, fmt.State, rune)
+	TypeLinkSym     func(*Type) *obj.LSym
 )
 
 func (s *Sym) String() string {
-	return Sconv(s, 0, FErr)
+	return SymString(s)
 }
 
 func (sym *Sym) Format(s fmt.State, verb rune) {
-	FormatSym(sym, s, verb, FErr)
+	FormatSym(sym, s, verb)
 }
 
 func (t *Type) String() string {
-	// The implementation of tconv (including typefmt and fldconv)
+	// The implementation
 	// must handle recursive types correctly.
-	return Tconv(t, 0, FErr)
+	return TypeString(t)
 }
 
 // ShortString generates a short description of t.
 // It is used in autogenerated method names, reflection,
 // and itab names.
 func (t *Type) ShortString() string {
-	return Tconv(t, FmtLeft, FErr)
+	return TypeShortString(t)
 }
 
 // LongString generates a complete description of t.
 // It is useful for reflection,
 // or when a unique fingerprint or hash of a type is required.
 func (t *Type) LongString() string {
-	return Tconv(t, FmtLeft|FmtUnsigned, FErr)
+	return TypeLongString(t)
 }
 
 func (t *Type) Format(s fmt.State, verb rune) {
-	FormatType(t, s, verb, FErr)
+	FormatType(t, s, verb)
 }
 
 type bitset8 uint8
-- 
GitLab


From 3904a6282945276ec72683920c278b2e3141a1fe Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 6 Dec 2020 12:38:11 -0500
Subject: [PATCH 0175/2400] [dev.regabi] cmd/compile: remove mode.Sprintf etc
 in printer

This code is now hardly used and not worth the complexity.
It also tangles together Nodes and Types in a way that keeps
this code in package ir instead of package types.

Passes buildall w/ toolstash -cmp.

Change-Id: I2e829c1f6b602acbdc8ab4aac3b798f9ded762ef
Reviewed-on: https://go-review.googlesource.com/c/go/+/275777
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/fmtmap_test.go     |   1 -
 src/cmd/compile/internal/ir/fmt.go | 111 +++++++++--------------------
 2 files changed, 32 insertions(+), 80 deletions(-)

diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
index 60b772e932..5dd30e619b 100644
--- a/src/cmd/compile/fmtmap_test.go
+++ b/src/cmd/compile/fmtmap_test.go
@@ -43,7 +43,6 @@ var knownFormats = map[string]string{
 	"*cmd/compile/internal/types.Field %p":            "",
 	"*cmd/compile/internal/types.Field %v":            "",
 	"*cmd/compile/internal/types.Sym %+v":             "",
-	"*cmd/compile/internal/types.Sym %0S":             "",
 	"*cmd/compile/internal/types.Sym %S":              "",
 	"*cmd/compile/internal/types.Sym %p":              "",
 	"*cmd/compile/internal/types.Sym %v":              "",
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 88534864a9..0bd0340af8 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -152,38 +152,6 @@ func (f FmtFlag) update(mode FmtMode) (FmtFlag, FmtMode) {
 	return f, mode
 }
 
-func (m FmtMode) Fprintf(s fmt.State, format string, args ...interface{}) {
-	m.prepareArgs(args)
-	fmt.Fprintf(s, format, args...)
-}
-
-func (m FmtMode) Sprintf(format string, args ...interface{}) string {
-	m.prepareArgs(args)
-	return fmt.Sprintf(format, args...)
-}
-
-func (m FmtMode) Sprint(args ...interface{}) string {
-	m.prepareArgs(args)
-	return fmt.Sprint(args...)
-}
-
-func (m FmtMode) prepareArgs(args []interface{}) {
-	for i, arg := range args {
-		switch arg := arg.(type) {
-		case nil:
-			args[i] = "<N>" // assume this was a node interface
-		case *types.Type:
-			args[i] = &fmtType{arg, m}
-		case *types.Sym:
-			args[i] = &fmtSym{arg, m}
-		case int32, int64, string, Op, Node, Nodes, types.Kind, constant.Value:
-			// OK: printing these types doesn't depend on mode
-		default:
-			base.Fatalf("mode.prepareArgs type %T", arg)
-		}
-	}
-}
-
 // Op
 
 var OpNames = []string{
@@ -316,15 +284,9 @@ func FmtConst(v constant.Value, flag FmtFlag) string {
 // the same name appears in an error message.
 var NumImport = make(map[string]int)
 
-type fmtSym struct {
-	x *types.Sym
-	m FmtMode
-}
-
-func (f *fmtSym) Format(s fmt.State, verb rune) { symFormat(f.x, s, verb, f.m) }
-
 // "%S" suppresses qualifying with package
-func symFormat(s *types.Sym, f fmt.State, verb rune, mode FmtMode) {
+func symFormat(s *types.Sym, f fmt.State, verb rune) {
+	mode := FErr
 	switch verb {
 	case 'v', 'S':
 		if verb == 'v' && f.Flag('+') {
@@ -337,8 +299,6 @@ func symFormat(s *types.Sym, f fmt.State, verb rune, mode FmtMode) {
 	}
 }
 
-func smodeString(s *types.Sym, mode FmtMode) string { return sconv(s, 0, mode) }
-
 // See #16897 for details about performance implications
 // before changing the implementation of sconv.
 func sconv(s *types.Sym, flag FmtFlag, mode FmtMode) string {
@@ -421,25 +381,22 @@ func symfmt(b *bytes.Buffer, s *types.Sym, flag FmtFlag, mode FmtMode) {
 	}
 
 	if flag&FmtByte != 0 {
-		// FmtByte (hh) implies FmtShort (h)
-		// skip leading "type." in method name
-		name := s.Name
-		if i := strings.LastIndex(name, "."); i >= 0 {
-			name = name[i+1:]
-		}
-
-		if mode == FDbg {
-			fmt.Fprintf(b, "@%q.%s", s.Pkg.Path, name)
-			return
-		}
-
-		b.WriteString(name)
+		b.WriteString(methodSymName(s))
 		return
 	}
 
 	b.WriteString(s.Name)
 }
 
+func methodSymName(s *types.Sym) string {
+	// Skip leading "type." in method name
+	name := s.Name
+	if i := strings.LastIndex(name, "."); i >= 0 {
+		name = name[i+1:]
+	}
+	return name
+}
+
 // Type
 
 var BasicTypeNames = []string{
@@ -485,24 +442,14 @@ func InstallTypeFormats() {
 	types.TypeLongString = func(t *types.Type) string {
 		return tconv(t, FmtLeft|FmtUnsigned, FErr)
 	}
-	types.FormatSym = func(sym *types.Sym, s fmt.State, verb rune) {
-		symFormat(sym, s, verb, FErr)
-	}
-	types.FormatType = func(t *types.Type, s fmt.State, verb rune) {
-		typeFormat(t, s, verb, FErr)
-	}
-}
-
-type fmtType struct {
-	x *types.Type
-	m FmtMode
+	types.FormatSym = symFormat
+	types.FormatType = typeFormat
 }
 
-func (f *fmtType) Format(s fmt.State, verb rune) { typeFormat(f.x, s, verb, f.m) }
-
 // "%L"  print definition, not name
 // "%S"  omit 'func' and receiver from function types, short type names
-func typeFormat(t *types.Type, s fmt.State, verb rune, mode FmtMode) {
+func typeFormat(t *types.Type, s fmt.State, verb rune) {
+	mode := FErr
 	switch verb {
 	case 'v', 'S', 'L':
 		if verb == 'v' && s.Flag('+') { // %+v is debug format
@@ -599,7 +546,8 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode FmtMode, visited
 			}
 
 			if t.Sym().Pkg == LocalPkg && t.Vargen != 0 {
-				b.WriteString(mode.Sprintf("%v·%d", t.Sym(), t.Vargen))
+				sconv2(b, t.Sym(), 0, mode)
+				fmt.Fprintf(b, "·%d", t.Vargen)
 				return
 			}
 		}
@@ -818,9 +766,14 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode FmtMode, visited
 
 	case types.Txxx:
 		b.WriteString("Txxx")
+
 	default:
-		// Don't know how to handle - fall back to detailed prints.
-		b.WriteString(mode.Sprintf("%v <%v>", t.Kind(), t.Sym()))
+		// Don't know how to handle - fall back to detailed prints
+		b.WriteString(t.Kind().String())
+		b.WriteString(" <")
+		sconv2(b, t.Sym(), 0, mode)
+		b.WriteString(">")
+
 	}
 }
 
@@ -847,12 +800,12 @@ func fldconv(b *bytes.Buffer, f *types.Field, flag FmtFlag, mode FmtMode, visite
 			if funarg != types.FunargNone {
 				name = fmt.Sprint(f.Nname)
 			} else if flag&FmtLong != 0 {
-				name = mode.Sprintf("%0S", s)
+				name = methodSymName(s)
 				if !types.IsExported(name) && flag&FmtUnsigned == 0 {
-					name = smodeString(s, mode) // qualify non-exported names (used on structs, not on funarg)
+					name = sconv(s, 0, mode) // qualify non-exported names (used on structs, not on funarg)
 				}
 			} else {
-				name = smodeString(s, mode)
+				name = sconv(s, 0, mode)
 			}
 		}
 	}
@@ -1289,7 +1242,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 
 	case OLITERAL: // this is a bit of a mess
 		if !exportFormat && n.Sym() != nil {
-			fmt.Fprint(s, smodeString(n.Sym(), FErr))
+			fmt.Fprint(s, n.Sym())
 			return
 		}
 
@@ -1331,7 +1284,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 
 	case ODCLFUNC:
 		if sym := n.Sym(); sym != nil {
-			fmt.Fprint(s, smodeString(sym, FErr))
+			fmt.Fprint(s, sym)
 			return
 		}
 		fmt.Fprintf(s, "<unnamed Func>")
@@ -1345,11 +1298,11 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		}
 		fallthrough
 	case OPACK, ONONAME, OMETHEXPR:
-		fmt.Fprint(s, smodeString(n.Sym(), FErr))
+		fmt.Fprint(s, n.Sym())
 
 	case OTYPE:
 		if n.Type() == nil && n.Sym() != nil {
-			fmt.Fprint(s, smodeString(n.Sym(), FErr))
+			fmt.Fprint(s, n.Sym())
 			return
 		}
 		fmt.Fprintf(s, "%v", n.Type())
-- 
GitLab


From 70155cca81d061686d4f23b7ad59fe8213e87f9f Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 6 Dec 2020 13:17:03 -0500
Subject: [PATCH 0176/2400] [dev.regabi] cmd/compile: untangle FmtFlag, FmtMode

It turns out that the FmtFlag is really only tracking the FmtLong and FmtShort bits,
and the others simply mirror the state of the FmtMode and are copied out and
back in repeatedly.

Simplify to FmtFlag being the verb itself ('S', 'L', or 'v').

Now there is only one formatting enumeration, making it a bit
easier to understand what's going on.

Passes buildall w/ toolstash -cmp.

Change-Id: I85bde2183eb22228fcf46d19d003401d588d9825
Reviewed-on: https://go-review.googlesource.com/c/go/+/275778
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/const.go |   2 +-
 src/cmd/compile/internal/ir/fmt.go   | 181 ++++++++-------------------
 2 files changed, 53 insertions(+), 130 deletions(-)

diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 6cd414a419..304c9aa2c3 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -384,7 +384,7 @@ func overflow(v constant.Value, t *types.Type) bool {
 		return true
 	}
 	if doesoverflow(v, t) {
-		base.Errorf("constant %v overflows %v", ir.FmtConst(v, 0), t)
+		base.Errorf("constant %v overflows %v", ir.FmtConst(v, false), t)
 		return true
 	}
 	return false
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 0bd0340af8..117c7417d2 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -88,70 +88,6 @@ const (
 	FTypeIdName // same as FTypeId, but use package name instead of prefix
 )
 
-// A FmtFlag value is a set of flags (or 0).
-// They control how the Xconv functions format their values.
-// See the respective function's documentation for details.
-type FmtFlag int
-
-const ( //                                 fmt.Format flag/prec or verb
-	FmtLeft     FmtFlag = 1 << iota // '-'
-	FmtSharp                        // '#'
-	FmtSign                         // '+'
-	FmtUnsigned                     // internal use only (historic: u flag)
-	FmtShort                        // verb == 'S'       (historic: h flag)
-	FmtLong                         // verb == 'L'       (historic: l flag)
-	FmtComma                        // '.' (== hasPrec)  (historic: , flag)
-	FmtByte                         // '0'               (historic: hh flag)
-)
-
-// fmtFlag computes the (internal) FmtFlag
-// value given the fmt.State and format verb.
-func fmtFlag(s fmt.State, verb rune) FmtFlag {
-	var flag FmtFlag
-	if s.Flag('-') {
-		flag |= FmtLeft
-	}
-	if s.Flag('#') {
-		flag |= FmtSharp
-	}
-	if s.Flag('+') {
-		flag |= FmtSign
-	}
-	if s.Flag(' ') {
-		base.Fatalf("FmtUnsigned in format string")
-	}
-	if _, ok := s.Precision(); ok {
-		flag |= FmtComma
-	}
-	if s.Flag('0') {
-		flag |= FmtByte
-	}
-	switch verb {
-	case 'S':
-		flag |= FmtShort
-	case 'L':
-		flag |= FmtLong
-	}
-	return flag
-}
-
-// update returns the results of applying f to mode.
-func (f FmtFlag) update(mode FmtMode) (FmtFlag, FmtMode) {
-	switch {
-	case f&FmtSign != 0:
-		mode = FDbg
-	case f&FmtSharp != 0:
-		// ignore (textual export format no longer supported)
-	case f&FmtUnsigned != 0:
-		mode = FTypeIdName
-	case f&FmtLeft != 0:
-		mode = FTypeId
-	}
-
-	f &^= FmtSharp | FmtLeft | FmtSign
-	return f, mode
-}
-
 // Op
 
 var OpNames = []string{
@@ -243,8 +179,8 @@ func (o Op) Format(s fmt.State, verb rune) {
 
 // Val
 
-func FmtConst(v constant.Value, flag FmtFlag) string {
-	if flag&FmtSharp == 0 && v.Kind() == constant.Complex {
+func FmtConst(v constant.Value, sharp bool) string {
+	if !sharp && v.Kind() == constant.Complex {
 		real, imag := constant.Real(v), constant.Imag(v)
 
 		var re string
@@ -292,7 +228,7 @@ func symFormat(s *types.Sym, f fmt.State, verb rune) {
 		if verb == 'v' && f.Flag('+') {
 			mode = FDbg
 		}
-		fmt.Fprint(f, sconv(s, fmtFlag(f, verb), mode))
+		fmt.Fprint(f, sconv(s, verb, mode))
 
 	default:
 		fmt.Fprintf(f, "%%!%c(*types.Sym=%p)", verb, s)
@@ -301,8 +237,8 @@ func symFormat(s *types.Sym, f fmt.State, verb rune) {
 
 // See #16897 for details about performance implications
 // before changing the implementation of sconv.
-func sconv(s *types.Sym, flag FmtFlag, mode FmtMode) string {
-	if flag&FmtLong != 0 {
+func sconv(s *types.Sym, verb rune, mode FmtMode) string {
+	if verb == 'L' {
 		panic("linksymfmt")
 	}
 
@@ -317,13 +253,12 @@ func sconv(s *types.Sym, flag FmtFlag, mode FmtMode) string {
 	buf.Reset()
 	defer fmtBufferPool.Put(buf)
 
-	flag, mode = flag.update(mode)
-	symfmt(buf, s, flag, mode)
+	symfmt(buf, s, verb, mode)
 	return types.InternString(buf.Bytes())
 }
 
-func sconv2(b *bytes.Buffer, s *types.Sym, flag FmtFlag, mode FmtMode) {
-	if flag&FmtLong != 0 {
+func sconv2(b *bytes.Buffer, s *types.Sym, verb rune, mode FmtMode) {
+	if verb == 'L' {
 		panic("linksymfmt")
 	}
 	if s == nil {
@@ -335,12 +270,11 @@ func sconv2(b *bytes.Buffer, s *types.Sym, flag FmtFlag, mode FmtMode) {
 		return
 	}
 
-	flag, mode = flag.update(mode)
-	symfmt(b, s, flag, mode)
+	symfmt(b, s, verb, mode)
 }
 
-func symfmt(b *bytes.Buffer, s *types.Sym, flag FmtFlag, mode FmtMode) {
-	if flag&FmtShort == 0 {
+func symfmt(b *bytes.Buffer, s *types.Sym, verb rune, mode FmtMode) {
+	if verb != 'S' {
 		switch mode {
 		case FErr: // This is for the user
 			if s.Pkg == BuiltinPkg || s.Pkg == LocalPkg {
@@ -380,11 +314,6 @@ func symfmt(b *bytes.Buffer, s *types.Sym, flag FmtFlag, mode FmtMode) {
 		}
 	}
 
-	if flag&FmtByte != 0 {
-		b.WriteString(methodSymName(s))
-		return
-	}
-
 	b.WriteString(s.Name)
 }
 
@@ -437,10 +366,10 @@ func InstallTypeFormats() {
 		return tconv(t, 0, FErr)
 	}
 	types.TypeShortString = func(t *types.Type) string {
-		return tconv(t, FmtLeft, FErr)
+		return tconv(t, 0, FTypeId)
 	}
 	types.TypeLongString = func(t *types.Type) string {
-		return tconv(t, FmtLeft|FmtUnsigned, FErr)
+		return tconv(t, 0, FTypeIdName)
 	}
 	types.FormatSym = symFormat
 	types.FormatType = typeFormat
@@ -455,18 +384,21 @@ func typeFormat(t *types.Type, s fmt.State, verb rune) {
 		if verb == 'v' && s.Flag('+') { // %+v is debug format
 			mode = FDbg
 		}
-		fmt.Fprint(s, tconv(t, fmtFlag(s, verb), mode))
+		if verb == 'S' && s.Flag('-') { // %-S is special case for receiver - short typeid format
+			mode = FTypeId
+		}
+		fmt.Fprint(s, tconv(t, verb, mode))
 	default:
 		fmt.Fprintf(s, "%%!%c(*Type=%p)", verb, t)
 	}
 }
 
-func tconv(t *types.Type, flag FmtFlag, mode FmtMode) string {
+func tconv(t *types.Type, verb rune, mode FmtMode) string {
 	buf := fmtBufferPool.Get().(*bytes.Buffer)
 	buf.Reset()
 	defer fmtBufferPool.Put(buf)
 
-	tconv2(buf, t, flag, mode, nil)
+	tconv2(buf, t, verb, mode, nil)
 	return types.InternString(buf.Bytes())
 }
 
@@ -474,7 +406,7 @@ func tconv(t *types.Type, flag FmtFlag, mode FmtMode) string {
 // flag and mode control exactly what is printed.
 // Any types x that are already in the visited map get printed as @%d where %d=visited[x].
 // See #16897 before changing the implementation of tconv.
-func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode FmtMode, visited map[*types.Type]int) {
+func tconv2(b *bytes.Buffer, t *types.Type, verb rune, mode FmtMode, visited map[*types.Type]int) {
 	if off, ok := visited[t]; ok {
 		// We've seen this type before, so we're trying to print it recursively.
 		// Print a reference to it instead.
@@ -507,17 +439,13 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode FmtMode, visited
 		return
 	}
 
-	flag, mode = flag.update(mode)
-	if mode == FTypeIdName {
-		flag |= FmtUnsigned
-	}
 	if t == types.ByteType || t == types.RuneType {
 		// in %-T mode collapse rune and byte with their originals.
 		switch mode {
 		case FTypeIdName, FTypeId:
 			t = types.Types[t.Kind()]
 		default:
-			sconv2(b, t.Sym(), FmtShort, mode)
+			sconv2(b, t.Sym(), 'S', mode)
 			return
 		}
 	}
@@ -527,32 +455,32 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode FmtMode, visited
 	}
 
 	// Unless the 'L' flag was specified, if the type has a name, just print that name.
-	if flag&FmtLong == 0 && t.Sym() != nil && t != types.Types[t.Kind()] {
+	if verb != 'L' && t.Sym() != nil && t != types.Types[t.Kind()] {
 		switch mode {
 		case FTypeId, FTypeIdName:
-			if flag&FmtShort != 0 {
+			if verb == 'S' {
 				if t.Vargen != 0 {
-					sconv2(b, t.Sym(), FmtShort, mode)
+					sconv2(b, t.Sym(), 'S', mode)
 					fmt.Fprintf(b, "·%d", t.Vargen)
 					return
 				}
-				sconv2(b, t.Sym(), FmtShort, mode)
+				sconv2(b, t.Sym(), 'S', mode)
 				return
 			}
 
 			if mode == FTypeIdName {
-				sconv2(b, t.Sym(), FmtUnsigned, mode)
+				sconv2(b, t.Sym(), 'v', FTypeIdName)
 				return
 			}
 
 			if t.Sym().Pkg == LocalPkg && t.Vargen != 0 {
-				sconv2(b, t.Sym(), 0, mode)
+				sconv2(b, t.Sym(), 'v', mode)
 				fmt.Fprintf(b, "·%d", t.Vargen)
 				return
 			}
 		}
 
-		sconv2(b, t.Sym(), 0, mode)
+		sconv2(b, t.Sym(), 'v', mode)
 		return
 	}
 
@@ -581,7 +509,7 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode FmtMode, visited
 	if mode == FDbg {
 		b.WriteString(t.Kind().String())
 		b.WriteByte('-')
-		tconv2(b, t, flag, FErr, visited)
+		tconv2(b, t, 'v', FErr, visited)
 		return
 	}
 
@@ -603,12 +531,12 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode FmtMode, visited
 		b.WriteByte('*')
 		switch mode {
 		case FTypeId, FTypeIdName:
-			if flag&FmtShort != 0 {
-				tconv2(b, t.Elem(), FmtShort, mode, visited)
+			if verb == 'S' {
+				tconv2(b, t.Elem(), 'S', mode, visited)
 				return
 			}
 		}
-		tconv2(b, t.Elem(), 0, mode, visited)
+		tconv2(b, t.Elem(), 'v', mode, visited)
 
 	case types.TARRAY:
 		b.WriteByte('[')
@@ -662,15 +590,14 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode FmtMode, visited
 				// Wrong interface definitions may have types lacking a symbol.
 				break
 			case types.IsExported(f.Sym.Name):
-				sconv2(b, f.Sym, FmtShort, mode)
+				sconv2(b, f.Sym, 'S', mode)
 			default:
-				flag1 := FmtLeft
-				if flag&FmtUnsigned != 0 {
-					flag1 = FmtUnsigned
+				if mode != FTypeIdName {
+					mode = FTypeId
 				}
-				sconv2(b, f.Sym, flag1, mode)
+				sconv2(b, f.Sym, 'v', mode)
 			}
-			tconv2(b, f.Type, FmtShort, mode, visited)
+			tconv2(b, f.Type, 'S', mode, visited)
 		}
 		if t.NumFields() != 0 {
 			b.WriteByte(' ')
@@ -678,7 +605,7 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode FmtMode, visited
 		b.WriteByte('}')
 
 	case types.TFUNC:
-		if flag&FmtShort != 0 {
+		if verb == 'S' {
 			// no leading func
 		} else {
 			if t.Recv() != nil {
@@ -726,17 +653,17 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode FmtMode, visited
 
 		if funarg := t.StructType().Funarg; funarg != types.FunargNone {
 			b.WriteByte('(')
-			var flag1 FmtFlag
+			fieldVerb := 'v'
 			switch mode {
 			case FTypeId, FTypeIdName, FErr:
 				// no argument names on function signature, and no "noescape"/"nosplit" tags
-				flag1 = FmtShort
+				fieldVerb = 'S'
 			}
 			for i, f := range t.Fields().Slice() {
 				if i != 0 {
 					b.WriteString(", ")
 				}
-				fldconv(b, f, flag1, mode, visited, funarg)
+				fldconv(b, f, fieldVerb, mode, visited, funarg)
 			}
 			b.WriteByte(')')
 		} else {
@@ -746,7 +673,7 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode FmtMode, visited
 					b.WriteByte(';')
 				}
 				b.WriteByte(' ')
-				fldconv(b, f, FmtLong, mode, visited, funarg)
+				fldconv(b, f, 'L', mode, visited, funarg)
 			}
 			if t.NumFields() != 0 {
 				b.WriteByte(' ')
@@ -758,7 +685,7 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode FmtMode, visited
 		b.WriteString("undefined")
 		if t.Sym() != nil {
 			b.WriteByte(' ')
-			sconv2(b, t.Sym(), 0, mode)
+			sconv2(b, t.Sym(), 'v', mode)
 		}
 
 	case types.TUNSAFEPTR:
@@ -771,24 +698,20 @@ func tconv2(b *bytes.Buffer, t *types.Type, flag FmtFlag, mode FmtMode, visited
 		// Don't know how to handle - fall back to detailed prints
 		b.WriteString(t.Kind().String())
 		b.WriteString(" <")
-		sconv2(b, t.Sym(), 0, mode)
+		sconv2(b, t.Sym(), 'v', mode)
 		b.WriteString(">")
 
 	}
 }
 
-func fldconv(b *bytes.Buffer, f *types.Field, flag FmtFlag, mode FmtMode, visited map[*types.Type]int, funarg types.Funarg) {
+func fldconv(b *bytes.Buffer, f *types.Field, verb rune, mode FmtMode, visited map[*types.Type]int, funarg types.Funarg) {
 	if f == nil {
 		b.WriteString("<T>")
 		return
 	}
-	flag, mode = flag.update(mode)
-	if mode == FTypeIdName {
-		flag |= FmtUnsigned
-	}
 
 	var name string
-	if flag&FmtShort == 0 {
+	if verb != 'S' {
 		s := f.Sym
 
 		// Take the name from the original.
@@ -799,9 +722,9 @@ func fldconv(b *bytes.Buffer, f *types.Field, flag FmtFlag, mode FmtMode, visite
 		if s != nil && f.Embedded == 0 {
 			if funarg != types.FunargNone {
 				name = fmt.Sprint(f.Nname)
-			} else if flag&FmtLong != 0 {
+			} else if verb == 'L' {
 				name = methodSymName(s)
-				if !types.IsExported(name) && flag&FmtUnsigned == 0 {
+				if !types.IsExported(name) && mode != FTypeIdName {
 					name = sconv(s, 0, mode) // qualify non-exported names (used on structs, not on funarg)
 				}
 			} else {
@@ -826,7 +749,7 @@ func fldconv(b *bytes.Buffer, f *types.Field, flag FmtFlag, mode FmtMode, visite
 		tconv2(b, f.Type, 0, mode, visited)
 	}
 
-	if flag&FmtShort == 0 && funarg == types.FunargNone && f.Note != "" {
+	if verb != 'S' && funarg == types.FunargNone && f.Note != "" {
 		b.WriteString(" ")
 		b.WriteString(strconv.Quote(f.Note))
 	}
@@ -1275,7 +1198,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 				fmt.Fprintf(s, "'\\U%08x'", uint64(x))
 			}
 		} else {
-			fmt.Fprint(s, FmtConst(n.Val(), fmtFlag(s, 'v')))
+			fmt.Fprint(s, FmtConst(n.Val(), s.Flag('#')))
 		}
 
 		if needUnparen {
@@ -1415,7 +1338,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 			fmt.Fprint(s, ".<nil>")
 			return
 		}
-		fmt.Fprintf(s, ".%0S", n.Sym())
+		fmt.Fprintf(s, ".%s", methodSymName(n.Sym()))
 
 	case OXDOT, ODOT, ODOTPTR, ODOTINTER, ODOTMETH:
 		exprFmt(n.Left(), s, nprec)
@@ -1423,7 +1346,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 			fmt.Fprint(s, ".<nil>")
 			return
 		}
-		fmt.Fprintf(s, ".%0S", n.Sym())
+		fmt.Fprintf(s, ".%s", methodSymName(n.Sym()))
 
 	case ODOTTYPE, ODOTTYPE2:
 		exprFmt(n.Left(), s, nprec)
-- 
GitLab


From bb4a37bd9316a04c45845634a721ef44d8b5b787 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 6 Dec 2020 13:54:50 -0500
Subject: [PATCH 0177/2400] [dev.regabi] cmd/compile: move Type, Sym printing
 to package types [generated]

Move the printing of types.Type and types.Sym out of ir
into package types, where it properly belongs. This wasn't
done originally (when the code was in gc) because the Type
and Sym printing was a bit tangled up with the Node printing.
But now they are untangled and can move into the correct
package.

This CL is automatically generated.
A followup CL will clean up a little bit more by hand.

Passes buildall w/ toolstash -cmp.

[git-generate]
cd src/cmd/compile/internal/ir
rf '
	mv FmtMode fmtMode
	mv FErr fmtGo
	mv FDbg fmtDebug
	mv FTypeId fmtTypeID
	mv FTypeIdName fmtTypeIDName
	mv methodSymName SymMethodName

	mv BuiltinPkg LocalPkg BlankSym OrigSym NumImport \
		fmtMode fmtGo symFormat sconv sconv2 symfmt SymMethodName \
		BasicTypeNames fmtBufferPool InstallTypeFormats typeFormat tconv tconv2 fldconv FmtConst \
		typefmt.go

	mv typefmt.go cmd/compile/internal/types
'
cd ../types
mv typefmt.go fmt.go

Change-Id: I6f3fd818323733ab8446f00594937c1628760b27
Reviewed-on: https://go-review.googlesource.com/c/go/+/275779
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/align.go        |   2 +-
 src/cmd/compile/internal/gc/bimport.go      |   3 +-
 src/cmd/compile/internal/gc/const.go        |   2 +-
 src/cmd/compile/internal/gc/dcl.go          |  14 +-
 src/cmd/compile/internal/gc/embed.go        |   8 +-
 src/cmd/compile/internal/gc/export.go       |   4 +-
 src/cmd/compile/internal/gc/gen.go          |   2 +-
 src/cmd/compile/internal/gc/go.go           |   4 +-
 src/cmd/compile/internal/gc/iexport.go      |  10 +-
 src/cmd/compile/internal/gc/iimport.go      |   4 +-
 src/cmd/compile/internal/gc/init.go         |   2 +-
 src/cmd/compile/internal/gc/inl.go          |   2 +-
 src/cmd/compile/internal/gc/main.go         |  28 +-
 src/cmd/compile/internal/gc/noder.go        |  10 +-
 src/cmd/compile/internal/gc/obj.go          |  10 +-
 src/cmd/compile/internal/gc/reflect.go      |  12 +-
 src/cmd/compile/internal/gc/sinit.go        |   2 +-
 src/cmd/compile/internal/gc/ssa.go          |   4 +-
 src/cmd/compile/internal/gc/subr.go         |   8 +-
 src/cmd/compile/internal/gc/typecheck.go    |  12 +-
 src/cmd/compile/internal/gc/universe.go     |  28 +-
 src/cmd/compile/internal/gc/walk.go         |   2 +-
 src/cmd/compile/internal/ir/fmt.go          | 656 +-----------------
 src/cmd/compile/internal/ir/ir.go           |   7 -
 src/cmd/compile/internal/ir/node.go         |  28 -
 src/cmd/compile/internal/ssa/export_test.go |   2 +-
 src/cmd/compile/internal/types/fmt.go       | 694 ++++++++++++++++++++
 27 files changed, 786 insertions(+), 774 deletions(-)
 create mode 100644 src/cmd/compile/internal/types/fmt.go

diff --git a/src/cmd/compile/internal/gc/align.go b/src/cmd/compile/internal/gc/align.go
index af426f5b24..212e4c46ae 100644
--- a/src/cmd/compile/internal/gc/align.go
+++ b/src/cmd/compile/internal/gc/align.go
@@ -193,7 +193,7 @@ func findTypeLoop(t *types.Type, path *[]*types.Type) bool {
 		// Type imported from package, so it can't be part of
 		// a type loop (otherwise that package should have
 		// failed to compile).
-		if t.Sym().Pkg != ir.LocalPkg {
+		if t.Sym().Pkg != types.LocalPkg {
 			return false
 		}
 
diff --git a/src/cmd/compile/internal/gc/bimport.go b/src/cmd/compile/internal/gc/bimport.go
index c0c18e728e..5a7018d8e6 100644
--- a/src/cmd/compile/internal/gc/bimport.go
+++ b/src/cmd/compile/internal/gc/bimport.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
 	"cmd/internal/src"
 )
 
@@ -15,5 +16,5 @@ func npos(pos src.XPos, n ir.Node) ir.Node {
 }
 
 func builtinCall(op ir.Op) ir.Node {
-	return ir.Nod(ir.OCALL, mkname(ir.BuiltinPkg.Lookup(ir.OpNames[op])), nil)
+	return ir.Nod(ir.OCALL, mkname(types.BuiltinPkg.Lookup(ir.OpNames[op])), nil)
 }
diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 304c9aa2c3..80799580c6 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -384,7 +384,7 @@ func overflow(v constant.Value, t *types.Type) bool {
 		return true
 	}
 	if doesoverflow(v, t) {
-		base.Errorf("constant %v overflows %v", ir.FmtConst(v, false), t)
+		base.Errorf("constant %v overflows %v", types.FmtConst(v, false), t)
 		return true
 	}
 	return false
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index a77c1aed45..1c23c5a92f 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -66,7 +66,7 @@ func declare(n *ir.Name, ctxt ir.Class) {
 	s := n.Sym()
 
 	// kludgy: typecheckok means we're past parsing. Eg genwrapper may declare out of package names later.
-	if !inimport && !typecheckok && s.Pkg != ir.LocalPkg {
+	if !inimport && !typecheckok && s.Pkg != types.LocalPkg {
 		base.ErrorfAt(n.Pos(), "cannot declare name %v", s)
 	}
 
@@ -253,7 +253,7 @@ func oldname(s *types.Sym) ir.Node {
 // but it reports an error if sym is from another package and not exported.
 func importName(sym *types.Sym) ir.Node {
 	n := oldname(sym)
-	if !types.IsExported(sym.Name) && sym.Pkg != ir.LocalPkg {
+	if !types.IsExported(sym.Name) && sym.Pkg != types.LocalPkg {
 		n.SetDiag(true)
 		base.Errorf("cannot refer to unexported name %s.%s", sym.Pkg.Name, sym.Name)
 	}
@@ -512,7 +512,7 @@ func tostruct(l []*ir.Field) *types.Type {
 	checkdupfields("field", fields)
 
 	base.Pos = lno
-	return types.NewStruct(ir.LocalPkg, fields)
+	return types.NewStruct(types.LocalPkg, fields)
 }
 
 func tointerface(nmethods []*ir.Field) *types.Type {
@@ -533,7 +533,7 @@ func tointerface(nmethods []*ir.Field) *types.Type {
 	}
 
 	base.Pos = lno
-	return types.NewInterface(ir.LocalPkg, methods)
+	return types.NewInterface(types.LocalPkg, methods)
 }
 
 func fakeRecv() *ir.Field {
@@ -585,14 +585,14 @@ func functype(nrecv *ir.Field, nparams, nresults []*ir.Field) *types.Type {
 		recv = funarg(nrecv)
 	}
 
-	t := types.NewSignature(ir.LocalPkg, recv, funargs(nparams), funargs(nresults))
+	t := types.NewSignature(types.LocalPkg, recv, funargs(nparams), funargs(nresults))
 	checkdupfields("argument", t.Recvs().FieldSlice(), t.Params().FieldSlice(), t.Results().FieldSlice())
 	return t
 }
 
 func hasNamedResults(fn *ir.Func) bool {
 	typ := fn.Type()
-	return typ.NumResults() > 0 && ir.OrigSym(typ.Results().Field(0).Sym) != nil
+	return typ.NumResults() > 0 && types.OrigSym(typ.Results().Field(0).Sym) != nil
 }
 
 // methodSym returns the method symbol representing a method name
@@ -703,7 +703,7 @@ func addmethod(n *ir.Func, msym *types.Sym, t *types.Type, local, nointerface bo
 		return nil
 	}
 
-	if local && mt.Sym().Pkg != ir.LocalPkg {
+	if local && mt.Sym().Pkg != types.LocalPkg {
 		base.Errorf("cannot define new methods on non-local type %v", mt)
 		return nil
 	}
diff --git a/src/cmd/compile/internal/gc/embed.go b/src/cmd/compile/internal/gc/embed.go
index d6e42e4f03..7664bde1c5 100644
--- a/src/cmd/compile/internal/gc/embed.go
+++ b/src/cmd/compile/internal/gc/embed.go
@@ -131,18 +131,18 @@ func varEmbed(p *noder, names []ir.Node, typ ir.Ntype, exprs []ir.Node, embeds [
 // can't tell whether "string" and "byte" really mean "string" and "byte".
 // The result must be confirmed later, after type checking, using embedKind.
 func embedKindApprox(typ ir.Node) int {
-	if typ.Sym() != nil && typ.Sym().Name == "FS" && (typ.Sym().Pkg.Path == "embed" || (typ.Sym().Pkg == ir.LocalPkg && base.Ctxt.Pkgpath == "embed")) {
+	if typ.Sym() != nil && typ.Sym().Name == "FS" && (typ.Sym().Pkg.Path == "embed" || (typ.Sym().Pkg == types.LocalPkg && base.Ctxt.Pkgpath == "embed")) {
 		return embedFiles
 	}
 	// These are not guaranteed to match only string and []byte -
 	// maybe the local package has redefined one of those words.
 	// But it's the best we can do now during the noder.
 	// The stricter check happens later, in initEmbed calling embedKind.
-	if typ.Sym() != nil && typ.Sym().Name == "string" && typ.Sym().Pkg == ir.LocalPkg {
+	if typ.Sym() != nil && typ.Sym().Name == "string" && typ.Sym().Pkg == types.LocalPkg {
 		return embedString
 	}
 	if typ, ok := typ.(*ir.SliceType); ok {
-		if sym := typ.Elem.Sym(); sym != nil && sym.Name == "byte" && sym.Pkg == ir.LocalPkg {
+		if sym := typ.Elem.Sym(); sym != nil && sym.Name == "byte" && sym.Pkg == types.LocalPkg {
 			return embedBytes
 		}
 	}
@@ -151,7 +151,7 @@ func embedKindApprox(typ ir.Node) int {
 
 // embedKind determines the kind of embedding variable.
 func embedKind(typ *types.Type) int {
-	if typ.Sym() != nil && typ.Sym().Name == "FS" && (typ.Sym().Pkg.Path == "embed" || (typ.Sym().Pkg == ir.LocalPkg && base.Ctxt.Pkgpath == "embed")) {
+	if typ.Sym() != nil && typ.Sym().Name == "FS" && (typ.Sym().Pkg.Path == "embed" || (typ.Sym().Pkg == types.LocalPkg && base.Ctxt.Pkgpath == "embed")) {
 		return embedFiles
 	}
 	if typ == types.Types[types.TSTRING] {
diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index b632a15865..593dd3b2f8 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -42,7 +42,7 @@ func initname(s string) bool {
 }
 
 func autoexport(n *ir.Name, ctxt ir.Class) {
-	if n.Sym().Pkg != ir.LocalPkg {
+	if n.Sym().Pkg != types.LocalPkg {
 		return
 	}
 	if (ctxt != ir.PEXTERN && ctxt != ir.PFUNC) || dclcontext != ir.PEXTERN {
@@ -202,7 +202,7 @@ func dumpasmhdr() {
 	if err != nil {
 		base.Fatalf("%v", err)
 	}
-	fmt.Fprintf(b, "// generated by compile -asmhdr from package %s\n\n", ir.LocalPkg.Name)
+	fmt.Fprintf(b, "// generated by compile -asmhdr from package %s\n\n", types.LocalPkg.Name)
 	for _, n := range asmlist {
 		if n.Sym().IsBlank() {
 			continue
diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
index 0d3f9392fb..39e9425978 100644
--- a/src/cmd/compile/internal/gc/gen.go
+++ b/src/cmd/compile/internal/gc/gen.go
@@ -66,7 +66,7 @@ func tempAt(pos src.XPos, curfn *ir.Func, t *types.Type) *ir.Name {
 
 	s := &types.Sym{
 		Name: autotmpname(len(curfn.Dcl)),
-		Pkg:  ir.LocalPkg,
+		Pkg:  types.LocalPkg,
 	}
 	n := ir.NewNameAt(pos, s)
 	s.Def = n
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index c4b9c185dc..041073f117 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -37,7 +37,7 @@ var (
 
 // isRuntimePkg reports whether p is package runtime.
 func isRuntimePkg(p *types.Pkg) bool {
-	if base.Flag.CompilingRuntime && p == ir.LocalPkg {
+	if base.Flag.CompilingRuntime && p == types.LocalPkg {
 		return true
 	}
 	return p.Path == "runtime"
@@ -45,7 +45,7 @@ func isRuntimePkg(p *types.Pkg) bool {
 
 // isReflectPkg reports whether p is package reflect.
 func isReflectPkg(p *types.Pkg) bool {
-	if p == ir.LocalPkg {
+	if p == types.LocalPkg {
 		return base.Ctxt.Pkgpath == "reflect"
 	}
 	return p.Path == "reflect"
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index 003cf3b446..b1cc9a3dd9 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -322,7 +322,7 @@ func (w *exportWriter) writeIndex(index map[*types.Sym]uint64, mainIndex bool) {
 	// we reference, even if we're not exporting (or reexporting)
 	// any symbols from it.
 	if mainIndex {
-		pkgSyms[ir.LocalPkg] = nil
+		pkgSyms[types.LocalPkg] = nil
 		for pkg := range w.p.allPkgs {
 			pkgSyms[pkg] = nil
 		}
@@ -402,7 +402,7 @@ func (p *iexporter) pushDecl(n *ir.Name) {
 	}
 
 	// Don't export predeclared declarations.
-	if n.Sym().Pkg == ir.BuiltinPkg || n.Sym().Pkg == unsafepkg {
+	if n.Sym().Pkg == types.BuiltinPkg || n.Sym().Pkg == unsafepkg {
 		return
 	}
 
@@ -596,7 +596,7 @@ func (w *exportWriter) selector(s *types.Sym) {
 	} else {
 		pkg := w.currPkg
 		if types.IsExported(name) {
-			pkg = ir.LocalPkg
+			pkg = types.LocalPkg
 		}
 		if s.Pkg != pkg {
 			base.Fatalf("package mismatch in selector: %v in package %q, but want %q", s, s.Pkg.Path, pkg.Path)
@@ -637,7 +637,7 @@ func (w *exportWriter) startType(k itag) {
 
 func (w *exportWriter) doTyp(t *types.Type) {
 	if t.Sym() != nil {
-		if t.Sym().Pkg == ir.BuiltinPkg || t.Sym().Pkg == unsafepkg {
+		if t.Sym().Pkg == types.BuiltinPkg || t.Sym().Pkg == unsafepkg {
 			base.Fatalf("builtin type missing from typIndex: %v", t)
 		}
 
@@ -748,7 +748,7 @@ func (w *exportWriter) paramList(fs []*types.Field) {
 
 func (w *exportWriter) param(f *types.Field) {
 	w.pos(f.Pos)
-	w.localIdent(ir.OrigSym(f.Sym), 0)
+	w.localIdent(types.OrigSym(f.Sym), 0)
 	w.typ(f.Type)
 }
 
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 1d9baed5ad..859263c83f 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -148,7 +148,7 @@ func iimport(pkg *types.Pkg, in *bio.Reader) (fingerprint goobj.FingerprintType)
 		if pkg.Name == "" {
 			pkg.Name = pkgName
 			pkg.Height = pkgHeight
-			ir.NumImport[pkgName]++
+			types.NumImport[pkgName]++
 
 			// TODO(mdempsky): This belongs somewhere else.
 			pkg.Lookup("_").Def = ir.BlankNode
@@ -437,7 +437,7 @@ func (r *importReader) ident() *types.Sym {
 	}
 	pkg := r.currPkg
 	if types.IsExported(name) {
-		pkg = ir.LocalPkg
+		pkg = types.LocalPkg
 	}
 	return pkg.Lookup(name)
 }
diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index dc825b2421..e0907f952c 100644
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -96,7 +96,7 @@ func fninit(n []ir.Node) {
 		fns = append(fns, s.Linksym())
 	}
 
-	if len(deps) == 0 && len(fns) == 0 && ir.LocalPkg.Name != "main" && ir.LocalPkg.Name != "runtime" {
+	if len(deps) == 0 && len(fns) == 0 && types.LocalPkg.Name != "main" && types.LocalPkg.Name != "runtime" {
 		return // nothing to initialize
 	}
 
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 8402852424..77fbf7c802 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -85,7 +85,7 @@ func typecheckinl(fn *ir.Func) {
 	// the ->inl of a local function has been typechecked before caninl copied it.
 	pkg := fnpkg(fn.Nname)
 
-	if pkg == ir.LocalPkg || pkg == nil {
+	if pkg == types.LocalPkg || pkg == nil {
 		return // typecheckinl on local function
 	}
 
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index a40671bccf..15659dc7fd 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -77,17 +77,17 @@ func Main(archInit func(*Arch)) {
 	// See bugs 31188 and 21945 (CLs 170638, 98075, 72371).
 	base.Ctxt.UseBASEntries = base.Ctxt.Headtype != objabi.Hdarwin
 
-	ir.LocalPkg = types.NewPkg("", "")
-	ir.LocalPkg.Prefix = "\"\""
+	types.LocalPkg = types.NewPkg("", "")
+	types.LocalPkg.Prefix = "\"\""
 
 	// We won't know localpkg's height until after import
 	// processing. In the mean time, set to MaxPkgHeight to ensure
 	// height comparisons at least work until then.
-	ir.LocalPkg.Height = types.MaxPkgHeight
+	types.LocalPkg.Height = types.MaxPkgHeight
 
 	// pseudo-package, for scoping
-	ir.BuiltinPkg = types.NewPkg("go.builtin", "") // TODO(gri) name this package go.builtin?
-	ir.BuiltinPkg.Prefix = "go.builtin"            // not go%2ebuiltin
+	types.BuiltinPkg = types.NewPkg("go.builtin", "") // TODO(gri) name this package go.builtin?
+	types.BuiltinPkg.Prefix = "go.builtin"            // not go%2ebuiltin
 
 	// pseudo-package, accessed by import "unsafe"
 	unsafepkg = types.NewPkg("unsafe", "unsafe")
@@ -212,7 +212,7 @@ func Main(archInit func(*Arch)) {
 	// would lead to import cycles)
 	types.Widthptr = Widthptr
 	types.Dowidth = dowidth
-	ir.InstallTypeFormats()
+	types.InstallTypeFormats()
 	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
 		return typenamesym(t).Linksym()
 	}
@@ -922,14 +922,14 @@ func pkgnotused(lineno src.XPos, path string, name string) {
 }
 
 func mkpackage(pkgname string) {
-	if ir.LocalPkg.Name == "" {
+	if types.LocalPkg.Name == "" {
 		if pkgname == "_" {
 			base.Errorf("invalid package name _")
 		}
-		ir.LocalPkg.Name = pkgname
+		types.LocalPkg.Name = pkgname
 	} else {
-		if pkgname != ir.LocalPkg.Name {
-			base.Errorf("package %s; expected %s", pkgname, ir.LocalPkg.Name)
+		if pkgname != types.LocalPkg.Name {
+			base.Errorf("package %s; expected %s", pkgname, types.LocalPkg.Name)
 		}
 	}
 }
@@ -942,7 +942,7 @@ func clearImports() {
 	}
 	var unused []importedPkg
 
-	for _, s := range ir.LocalPkg.Syms {
+	for _, s := range types.LocalPkg.Syms {
 		n := ir.AsNode(s.Def)
 		if n == nil {
 			continue
@@ -1046,7 +1046,7 @@ func recordPackageName() {
 	// together two package main archives. So allow dups.
 	s.Set(obj.AttrDuplicateOK, true)
 	base.Ctxt.Data = append(base.Ctxt.Data, s)
-	s.P = []byte(ir.LocalPkg.Name)
+	s.P = []byte(types.LocalPkg.Name)
 }
 
 // currentLang returns the current language version.
@@ -1073,9 +1073,9 @@ var langWant lang
 func langSupported(major, minor int, pkg *types.Pkg) bool {
 	if pkg == nil {
 		// TODO(mdempsky): Set Pkg for local types earlier.
-		pkg = ir.LocalPkg
+		pkg = types.LocalPkg
 	}
-	if pkg != ir.LocalPkg {
+	if pkg != types.LocalPkg {
 		// Assume imported packages passed type-checking.
 		return true
 	}
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 1cd8375677..f39bf2ff3c 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -79,7 +79,7 @@ func parseFiles(filenames []string) uint {
 		p.processPragmas()
 	}
 
-	ir.LocalPkg.Height = myheight
+	types.LocalPkg.Height = myheight
 
 	return lines
 }
@@ -501,7 +501,7 @@ func (p *noder) typeDecl(decl *syntax.TypeDecl) ir.Node {
 	}
 
 	nod := p.nod(decl, ir.ODCLTYPE, n, nil)
-	if n.Alias() && !langSupported(1, 9, ir.LocalPkg) {
+	if n.Alias() && !langSupported(1, 9, types.LocalPkg) {
 		base.ErrorfAt(nod.Pos(), "type aliases only supported as of -lang=go1.9")
 	}
 	return nod
@@ -532,7 +532,7 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) ir.Node {
 			}
 		}
 
-		if ir.LocalPkg.Name == "main" && name.Name == "main" {
+		if types.LocalPkg.Name == "main" && name.Name == "main" {
 			if t.List().Len() > 0 || t.Rlist().Len() > 0 {
 				base.ErrorfAt(f.Pos(), "func main must have no arguments and no return values")
 			}
@@ -931,7 +931,7 @@ func (p *noder) packname(expr syntax.Expr) *types.Sym {
 		var pkg *types.Pkg
 		if def.Op() != ir.OPACK {
 			base.Errorf("%v is not a package", name)
-			pkg = ir.LocalPkg
+			pkg = types.LocalPkg
 		} else {
 			def := def.(*ir.PkgName)
 			def.Used = true
@@ -1387,7 +1387,7 @@ func (p *noder) binOp(op syntax.Operator) ir.Op {
 // literal is not compatible with the current language version.
 func checkLangCompat(lit *syntax.BasicLit) {
 	s := lit.Value
-	if len(s) <= 2 || langSupported(1, 13, ir.LocalPkg) {
+	if len(s) <= 2 || langSupported(1, 13, types.LocalPkg) {
 		return
 	}
 	// len(s) > 2
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index b1701b30a1..c34a86d4eb 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -84,7 +84,7 @@ func printObjHeader(bout *bio.Writer) {
 	if base.Flag.BuildID != "" {
 		fmt.Fprintf(bout, "build id %q\n", base.Flag.BuildID)
 	}
-	if ir.LocalPkg.Name == "main" {
+	if types.LocalPkg.Name == "main" {
 		fmt.Fprintf(bout, "main\n")
 	}
 	fmt.Fprintf(bout, "\n") // header ends with blank line
@@ -200,7 +200,7 @@ func dumpLinkerObj(bout *bio.Writer) {
 }
 
 func addptabs() {
-	if !base.Ctxt.Flag_dynlink || ir.LocalPkg.Name != "main" {
+	if !base.Ctxt.Flag_dynlink || types.LocalPkg.Name != "main" {
 		return
 	}
 	for _, exportn := range exportlist {
@@ -235,7 +235,7 @@ func dumpGlobal(n ir.Node) {
 	if n.Class() == ir.PFUNC {
 		return
 	}
-	if n.Sym().Pkg != ir.LocalPkg {
+	if n.Sym().Pkg != types.LocalPkg {
 		return
 	}
 	dowidth(n.Type())
@@ -248,7 +248,7 @@ func dumpGlobalConst(n ir.Node) {
 	if t == nil {
 		return
 	}
-	if n.Sym().Pkg != ir.LocalPkg {
+	if n.Sym().Pkg != types.LocalPkg {
 		return
 	}
 	// only export integer constants for now
@@ -478,7 +478,7 @@ var slicedataGen int
 func slicedata(pos src.XPos, s string) ir.Node {
 	slicedataGen++
 	symname := fmt.Sprintf(".gobytes.%d", slicedataGen)
-	sym := ir.LocalPkg.Lookup(symname)
+	sym := types.LocalPkg.Lookup(symname)
 	symnode := NewName(sym)
 	sym.Def = symnode
 
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 42139b7135..9b8f26a84b 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -301,7 +301,7 @@ func deferstruct(stksize int64) *types.Type {
 		// Unlike the global makefield function, this one needs to set Pkg
 		// because these types might be compared (in SSA CSE sorting).
 		// TODO: unify this makefield and the global one above.
-		sym := &types.Sym{Name: name, Pkg: ir.LocalPkg}
+		sym := &types.Sym{Name: name, Pkg: types.LocalPkg}
 		return types.NewField(src.NoXPos, sym, typ)
 	}
 	argtype := types.NewArray(types.Types[types.TUINT8], stksize)
@@ -491,7 +491,7 @@ func dimportpath(p *types.Pkg) {
 	}
 
 	str := p.Path
-	if p == ir.LocalPkg {
+	if p == types.LocalPkg {
 		// Note: myimportpath != "", or else dgopkgpath won't call dimportpath.
 		str = base.Ctxt.Pkgpath
 	}
@@ -508,7 +508,7 @@ func dgopkgpath(s *obj.LSym, ot int, pkg *types.Pkg) int {
 		return duintptr(s, ot, 0)
 	}
 
-	if pkg == ir.LocalPkg && base.Ctxt.Pkgpath == "" {
+	if pkg == types.LocalPkg && base.Ctxt.Pkgpath == "" {
 		// If we don't know the full import path of the package being compiled
 		// (i.e. -p was not passed on the compiler command line), emit a reference to
 		// type..importpath.""., which the linker will rewrite using the correct import path.
@@ -527,7 +527,7 @@ func dgopkgpathOff(s *obj.LSym, ot int, pkg *types.Pkg) int {
 	if pkg == nil {
 		return duint32(s, ot, 0)
 	}
-	if pkg == ir.LocalPkg && base.Ctxt.Pkgpath == "" {
+	if pkg == types.LocalPkg && base.Ctxt.Pkgpath == "" {
 		// If we don't know the full import path of the package being compiled
 		// (i.e. -p was not passed on the compiler command line), emit a reference to
 		// type..importpath.""., which the linker will rewrite using the correct import path.
@@ -1158,7 +1158,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 
 	if base.Ctxt.Pkgpath != "runtime" || (tbase != types.Types[tbase.Kind()] && tbase != types.ByteType && tbase != types.RuneType && tbase != types.ErrorType) { // int, float, etc
 		// named types from other files are defined only by those files
-		if tbase.Sym() != nil && tbase.Sym().Pkg != ir.LocalPkg {
+		if tbase.Sym() != nil && tbase.Sym().Pkg != types.LocalPkg {
 			if i, ok := typeSymIdx[tbase]; ok {
 				lsym.Pkg = tbase.Sym().Pkg.Prefix
 				if t != tbase {
@@ -1568,7 +1568,7 @@ func dumptabs() {
 	}
 
 	// process ptabs
-	if ir.LocalPkg.Name == "main" && len(ptabs) > 0 {
+	if types.LocalPkg.Name == "main" && len(ptabs) > 0 {
 		ot := 0
 		s := base.Ctxt.Lookup("go.plugin.tabs")
 		for _, p := range ptabs {
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index c446c9d083..3c5f11c5ab 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -79,7 +79,7 @@ func (s *InitSchedule) staticcopy(l ir.Node, r ir.Node) bool {
 		pfuncsym(l, r)
 		return true
 	}
-	if r.Class() != ir.PEXTERN || r.Sym().Pkg != ir.LocalPkg {
+	if r.Class() != ir.PEXTERN || r.Sym().Pkg != types.LocalPkg {
 		return false
 	}
 	if r.Name().Defn == nil { // probably zeroed but perhaps supplied externally and of unknown value
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 89918e2133..add50c35d7 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -4127,7 +4127,7 @@ func findIntrinsic(sym *types.Sym) intrinsicBuilder {
 		return nil
 	}
 	pkg := sym.Pkg.Path
-	if sym.Pkg == ir.LocalPkg {
+	if sym.Pkg == types.LocalPkg {
 		pkg = base.Ctxt.Pkgpath
 	}
 	if base.Flag.Race && pkg == "sync/atomic" {
@@ -7073,7 +7073,7 @@ func (e *ssafn) SplitSlot(parent *ssa.LocalSlot, suffix string, offset int64, t
 		return ssa.LocalSlot{N: node, Type: t, Off: parent.Off + offset}
 	}
 
-	s := &types.Sym{Name: node.Sym().Name + suffix, Pkg: ir.LocalPkg}
+	s := &types.Sym{Name: node.Sym().Name + suffix, Pkg: types.LocalPkg}
 	n := ir.NewNameAt(parent.N.Pos(), s)
 	s.Def = n
 	ir.AsNode(s.Def).Name().SetUsed(true)
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 65eb61e680..dffebc58f2 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -69,7 +69,7 @@ func setlineno(n ir.Node) src.XPos {
 }
 
 func lookup(name string) *types.Sym {
-	return ir.LocalPkg.Lookup(name)
+	return types.LocalPkg.Lookup(name)
 }
 
 // lookupN looks up the symbol starting with prefix and ending with
@@ -78,7 +78,7 @@ func lookupN(prefix string, n int) *types.Sym {
 	var buf [20]byte // plenty long enough for all current users
 	copy(buf[:], prefix)
 	b := strconv.AppendInt(buf[:len(prefix)], int64(n), 10)
-	return ir.LocalPkg.LookupBytes(b)
+	return types.LocalPkg.LookupBytes(b)
 }
 
 // autolabel generates a new Name node for use with
@@ -1109,13 +1109,13 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 
 	// Only generate (*T).M wrappers for T.M in T's own package.
 	if rcvr.IsPtr() && rcvr.Elem() == method.Type.Recv().Type &&
-		rcvr.Elem().Sym() != nil && rcvr.Elem().Sym().Pkg != ir.LocalPkg {
+		rcvr.Elem().Sym() != nil && rcvr.Elem().Sym().Pkg != types.LocalPkg {
 		return
 	}
 
 	// Only generate I.M wrappers for I in I's own package
 	// but keep doing it for error.Error (was issue #29304).
-	if rcvr.IsInterface() && rcvr.Sym() != nil && rcvr.Sym().Pkg != ir.LocalPkg && rcvr != types.ErrorType {
+	if rcvr.IsInterface() && rcvr.Sym() != nil && rcvr.Sym().Pkg != types.LocalPkg && rcvr != types.ErrorType {
 		return
 	}
 
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index dc9e23069e..85094dbebc 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -90,7 +90,7 @@ func resolve(n ir.Node) (res ir.Node) {
 		defer tracePrint("resolve", n)(&res)
 	}
 
-	if n.Sym().Pkg != ir.LocalPkg {
+	if n.Sym().Pkg != types.LocalPkg {
 		if inimport {
 			base.Fatalf("recursive inimport")
 		}
@@ -2386,7 +2386,7 @@ func typecheckMethodExpr(n ir.Node) (res ir.Node) {
 	me.(*ir.MethodExpr).Method = m
 
 	// Issue 25065. Make sure that we emit the symbol for a local method.
-	if base.Ctxt.Flag_dynlink && !inimport && (t.Sym() == nil || t.Sym().Pkg == ir.LocalPkg) {
+	if base.Ctxt.Flag_dynlink && !inimport && (t.Sym() == nil || t.Sym().Pkg == types.LocalPkg) {
 		makefuncsym(me.Sym())
 	}
 
@@ -2862,7 +2862,7 @@ func typecheckcomplit(n ir.Node) (res ir.Node) {
 
 				f := t.Field(i)
 				s := f.Sym
-				if s != nil && !types.IsExported(s.Name) && s.Pkg != ir.LocalPkg {
+				if s != nil && !types.IsExported(s.Name) && s.Pkg != types.LocalPkg {
 					base.Errorf("implicit assignment of unexported field '%s' in %v literal", s.Name, t)
 				}
 				// No pushtype allowed here. Must name fields for that.
@@ -2903,7 +2903,7 @@ func typecheckcomplit(n ir.Node) (res ir.Node) {
 					// package, because of import dot. Redirect to correct sym
 					// before we do the lookup.
 					s := key.Sym()
-					if s.Pkg != ir.LocalPkg && types.IsExported(s.Name) {
+					if s.Pkg != types.LocalPkg && types.IsExported(s.Name) {
 						s1 := lookup(s.Name)
 						if s1.Origpkg == s.Pkg {
 							s = s1
@@ -3034,7 +3034,7 @@ func typecheckarraylit(elemType *types.Type, bound int64, elts []ir.Node, ctx st
 
 // visible reports whether sym is exported or locally defined.
 func visible(sym *types.Sym) bool {
-	return sym != nil && (types.IsExported(sym.Name) || sym.Pkg == ir.LocalPkg)
+	return sym != nil && (types.IsExported(sym.Name) || sym.Pkg == types.LocalPkg)
 }
 
 // nonexported reports whether sym is an unexported field.
@@ -3929,7 +3929,7 @@ func curpkg() *types.Pkg {
 	fn := Curfn
 	if fn == nil {
 		// Initialization expressions for package-scope variables.
-		return ir.LocalPkg
+		return types.LocalPkg
 	}
 	return fnpkg(fn.Nname)
 }
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index cd68719a99..42b996d88d 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -104,7 +104,7 @@ func initUniverse() {
 	}
 
 	types.Types[types.TANY] = types.New(types.TANY)
-	types.Types[types.TINTER] = types.NewInterface(ir.LocalPkg, nil)
+	types.Types[types.TINTER] = types.NewInterface(types.LocalPkg, nil)
 
 	defBasic := func(kind types.Kind, pkg *types.Pkg, name string) *types.Type {
 		sym := pkg.Lookup(name)
@@ -120,7 +120,7 @@ func initUniverse() {
 	}
 
 	for _, s := range &basicTypes {
-		types.Types[s.etype] = defBasic(s.etype, ir.BuiltinPkg, s.name)
+		types.Types[s.etype] = defBasic(s.etype, types.BuiltinPkg, s.name)
 	}
 
 	for _, s := range &typedefs {
@@ -130,7 +130,7 @@ func initUniverse() {
 		}
 		simtype[s.etype] = sameas
 
-		types.Types[s.etype] = defBasic(s.etype, ir.BuiltinPkg, s.name)
+		types.Types[s.etype] = defBasic(s.etype, types.BuiltinPkg, s.name)
 	}
 
 	// We create separate byte and rune types for better error messages
@@ -140,11 +140,11 @@ func initUniverse() {
 	// of less informative error messages involving bytes and runes)?
 	// (Alternatively, we could introduce an OTALIAS node representing
 	// type aliases, albeit at the cost of having to deal with it everywhere).
-	types.ByteType = defBasic(types.TUINT8, ir.BuiltinPkg, "byte")
-	types.RuneType = defBasic(types.TINT32, ir.BuiltinPkg, "rune")
+	types.ByteType = defBasic(types.TUINT8, types.BuiltinPkg, "byte")
+	types.RuneType = defBasic(types.TINT32, types.BuiltinPkg, "rune")
 
 	// error type
-	s := ir.BuiltinPkg.Lookup("error")
+	s := types.BuiltinPkg.Lookup("error")
 	n := ir.NewDeclNameAt(src.NoXPos, s)
 	n.SetOp(ir.OTYPE)
 	types.ErrorType = types.NewNamed(n)
@@ -162,7 +162,7 @@ func initUniverse() {
 	simtype[types.TUNSAFEPTR] = types.TPTR
 
 	for _, s := range &builtinFuncs {
-		s2 := ir.BuiltinPkg.Lookup(s.name)
+		s2 := types.BuiltinPkg.Lookup(s.name)
 		s2.Def = NewName(s2)
 		ir.AsNode(s2.Def).SetSubOp(s.op)
 	}
@@ -173,16 +173,16 @@ func initUniverse() {
 		ir.AsNode(s2.Def).SetSubOp(s.op)
 	}
 
-	s = ir.BuiltinPkg.Lookup("true")
+	s = types.BuiltinPkg.Lookup("true")
 	s.Def = nodbool(true)
 	ir.AsNode(s.Def).SetSym(lookup("true"))
 
-	s = ir.BuiltinPkg.Lookup("false")
+	s = types.BuiltinPkg.Lookup("false")
 	s.Def = nodbool(false)
 	ir.AsNode(s.Def).SetSym(lookup("false"))
 
 	s = lookup("_")
-	ir.BlankSym = s
+	types.BlankSym = s
 	s.Block = -100
 	s.Def = NewName(s)
 	types.Types[types.TBLANK] = types.New(types.TBLANK)
@@ -190,18 +190,18 @@ func initUniverse() {
 	ir.BlankNode = ir.AsNode(s.Def)
 	ir.BlankNode.SetTypecheck(1)
 
-	s = ir.BuiltinPkg.Lookup("_")
+	s = types.BuiltinPkg.Lookup("_")
 	s.Block = -100
 	s.Def = NewName(s)
 	types.Types[types.TBLANK] = types.New(types.TBLANK)
 	ir.AsNode(s.Def).SetType(types.Types[types.TBLANK])
 
 	types.Types[types.TNIL] = types.New(types.TNIL)
-	s = ir.BuiltinPkg.Lookup("nil")
+	s = types.BuiltinPkg.Lookup("nil")
 	s.Def = nodnil()
 	ir.AsNode(s.Def).SetSym(s)
 
-	s = ir.BuiltinPkg.Lookup("iota")
+	s = types.BuiltinPkg.Lookup("iota")
 	s.Def = ir.Nod(ir.OIOTA, nil, nil)
 	ir.AsNode(s.Def).SetSym(s)
 
@@ -339,7 +339,7 @@ func finishUniverse() {
 	// that we silently skip symbols that are already declared in the
 	// package block rather than emitting a redeclared symbol error.
 
-	for _, s := range ir.BuiltinPkg.Syms {
+	for _, s := range types.BuiltinPkg.Syms {
 		if s.Def == nil {
 			continue
 		}
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 574c7c4709..346817e589 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -983,7 +983,7 @@ opswitch:
 		if param == types.Txxx {
 			break
 		}
-		fn := ir.BasicTypeNames[param] + "to" + ir.BasicTypeNames[result]
+		fn := types.BasicTypeNames[param] + "to" + types.BasicTypeNames[result]
 		n = conv(mkcall(fn, types.Types[result], init, conv(n.Left(), types.Types[param])), n.Type())
 
 	case ir.ODIV, ir.OMOD:
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 117c7417d2..79d85d1803 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -10,9 +10,7 @@ import (
 	"go/constant"
 	"io"
 	"os"
-	"strconv"
-	"strings"
-	"sync"
+
 	"unicode/utf8"
 
 	"cmd/compile/internal/base"
@@ -20,74 +18,6 @@ import (
 	"cmd/internal/src"
 )
 
-// Format conversions:
-// TODO(gri) verify these; eliminate those not used anymore
-//
-//	%v Op		Node opcodes
-//		Flags:  #: print Go syntax (automatic unless mode == FDbg)
-//
-//	%j *Node	Node details
-//		Flags:  0: suppresses things not relevant until walk
-//
-//	%v *Val		Constant values
-//
-//	%v *types.Sym		Symbols
-//	%S              unqualified identifier in any mode
-//		Flags:  +,- #: mode (see below)
-//			0: in export mode: unqualified identifier if exported, qualified if not
-//
-//	%v *types.Type	Types
-//	%S              omit "func" and receiver in function types
-//	%L              definition instead of name.
-//		Flags:  +,- #: mode (see below)
-//			' ' (only in -/Sym mode) print type identifiers wit package name instead of prefix.
-//
-//	%v *Node	Nodes
-//	%S              (only in +/debug mode) suppress recursion
-//	%L              (only in Error mode) print "foo (type Bar)"
-//		Flags:  +,- #: mode (see below)
-//
-//	%v Nodes	Node lists
-//		Flags:  those of *Node
-//			.: separate items with ',' instead of ';'
-
-// *types.Sym, *types.Type, and *Node types use the flags below to set the format mode
-
-// The mode flags '+', '-', and '#' are sticky; they persist through
-// recursions of *Node, *types.Type, and *types.Sym values. The ' ' flag is
-// sticky only on *types.Type recursions and only used in %-/*types.Sym mode.
-//
-// Example: given a *types.Sym: %+v %#v %-v print an identifier properly qualified for debug/export/internal mode
-
-// Useful format combinations:
-// TODO(gri): verify these
-//
-// *Node, Nodes:
-//   %+v    multiline recursive debug dump of *Node/Nodes
-//   %+S    non-recursive debug dump
-//
-// *Node:
-//   %#v    Go format
-//   %L     "foo (type Bar)" for error messages
-//
-// *types.Type:
-//   %#v    Go format
-//   %#L    type definition instead of name
-//   %#S    omit "func" and receiver in function signature
-//
-//   %-v    type identifiers
-//   %-S    type identifiers without "func" and arg names in type signatures (methodsym)
-//   %- v   type identifiers with package name instead of prefix (typesym, dcommontype, typehash)
-
-type FmtMode int
-
-const (
-	FErr FmtMode = iota
-	FDbg
-	FTypeId
-	FTypeIdName // same as FTypeId, but use package name instead of prefix
-)
-
 // Op
 
 var OpNames = []string{
@@ -177,584 +107,6 @@ func (o Op) Format(s fmt.State, verb rune) {
 	}
 }
 
-// Val
-
-func FmtConst(v constant.Value, sharp bool) string {
-	if !sharp && v.Kind() == constant.Complex {
-		real, imag := constant.Real(v), constant.Imag(v)
-
-		var re string
-		sre := constant.Sign(real)
-		if sre != 0 {
-			re = real.String()
-		}
-
-		var im string
-		sim := constant.Sign(imag)
-		if sim != 0 {
-			im = imag.String()
-		}
-
-		switch {
-		case sre == 0 && sim == 0:
-			return "0"
-		case sre == 0:
-			return im + "i"
-		case sim == 0:
-			return re
-		case sim < 0:
-			return fmt.Sprintf("(%s%si)", re, im)
-		default:
-			return fmt.Sprintf("(%s+%si)", re, im)
-		}
-	}
-
-	return v.String()
-}
-
-// Sym
-
-// numImport tracks how often a package with a given name is imported.
-// It is used to provide a better error message (by using the package
-// path to disambiguate) if a package that appears multiple times with
-// the same name appears in an error message.
-var NumImport = make(map[string]int)
-
-// "%S" suppresses qualifying with package
-func symFormat(s *types.Sym, f fmt.State, verb rune) {
-	mode := FErr
-	switch verb {
-	case 'v', 'S':
-		if verb == 'v' && f.Flag('+') {
-			mode = FDbg
-		}
-		fmt.Fprint(f, sconv(s, verb, mode))
-
-	default:
-		fmt.Fprintf(f, "%%!%c(*types.Sym=%p)", verb, s)
-	}
-}
-
-// See #16897 for details about performance implications
-// before changing the implementation of sconv.
-func sconv(s *types.Sym, verb rune, mode FmtMode) string {
-	if verb == 'L' {
-		panic("linksymfmt")
-	}
-
-	if s == nil {
-		return "<S>"
-	}
-
-	if s.Name == "_" {
-		return "_"
-	}
-	buf := fmtBufferPool.Get().(*bytes.Buffer)
-	buf.Reset()
-	defer fmtBufferPool.Put(buf)
-
-	symfmt(buf, s, verb, mode)
-	return types.InternString(buf.Bytes())
-}
-
-func sconv2(b *bytes.Buffer, s *types.Sym, verb rune, mode FmtMode) {
-	if verb == 'L' {
-		panic("linksymfmt")
-	}
-	if s == nil {
-		b.WriteString("<S>")
-		return
-	}
-	if s.Name == "_" {
-		b.WriteString("_")
-		return
-	}
-
-	symfmt(b, s, verb, mode)
-}
-
-func symfmt(b *bytes.Buffer, s *types.Sym, verb rune, mode FmtMode) {
-	if verb != 'S' {
-		switch mode {
-		case FErr: // This is for the user
-			if s.Pkg == BuiltinPkg || s.Pkg == LocalPkg {
-				b.WriteString(s.Name)
-				return
-			}
-
-			// If the name was used by multiple packages, display the full path,
-			if s.Pkg.Name != "" && NumImport[s.Pkg.Name] > 1 {
-				fmt.Fprintf(b, "%q.%s", s.Pkg.Path, s.Name)
-				return
-			}
-			b.WriteString(s.Pkg.Name)
-			b.WriteByte('.')
-			b.WriteString(s.Name)
-			return
-
-		case FDbg:
-			b.WriteString(s.Pkg.Name)
-			b.WriteByte('.')
-			b.WriteString(s.Name)
-			return
-
-		case FTypeIdName:
-			// dcommontype, typehash
-			b.WriteString(s.Pkg.Name)
-			b.WriteByte('.')
-			b.WriteString(s.Name)
-			return
-
-		case FTypeId:
-			// (methodsym), typesym, weaksym
-			b.WriteString(s.Pkg.Prefix)
-			b.WriteByte('.')
-			b.WriteString(s.Name)
-			return
-		}
-	}
-
-	b.WriteString(s.Name)
-}
-
-func methodSymName(s *types.Sym) string {
-	// Skip leading "type." in method name
-	name := s.Name
-	if i := strings.LastIndex(name, "."); i >= 0 {
-		name = name[i+1:]
-	}
-	return name
-}
-
-// Type
-
-var BasicTypeNames = []string{
-	types.TINT:        "int",
-	types.TUINT:       "uint",
-	types.TINT8:       "int8",
-	types.TUINT8:      "uint8",
-	types.TINT16:      "int16",
-	types.TUINT16:     "uint16",
-	types.TINT32:      "int32",
-	types.TUINT32:     "uint32",
-	types.TINT64:      "int64",
-	types.TUINT64:     "uint64",
-	types.TUINTPTR:    "uintptr",
-	types.TFLOAT32:    "float32",
-	types.TFLOAT64:    "float64",
-	types.TCOMPLEX64:  "complex64",
-	types.TCOMPLEX128: "complex128",
-	types.TBOOL:       "bool",
-	types.TANY:        "any",
-	types.TSTRING:     "string",
-	types.TNIL:        "nil",
-	types.TIDEAL:      "untyped number",
-	types.TBLANK:      "blank",
-}
-
-var fmtBufferPool = sync.Pool{
-	New: func() interface{} {
-		return new(bytes.Buffer)
-	},
-}
-
-func InstallTypeFormats() {
-	types.SymString = func(s *types.Sym) string {
-		return sconv(s, 0, FErr)
-	}
-	types.TypeString = func(t *types.Type) string {
-		return tconv(t, 0, FErr)
-	}
-	types.TypeShortString = func(t *types.Type) string {
-		return tconv(t, 0, FTypeId)
-	}
-	types.TypeLongString = func(t *types.Type) string {
-		return tconv(t, 0, FTypeIdName)
-	}
-	types.FormatSym = symFormat
-	types.FormatType = typeFormat
-}
-
-// "%L"  print definition, not name
-// "%S"  omit 'func' and receiver from function types, short type names
-func typeFormat(t *types.Type, s fmt.State, verb rune) {
-	mode := FErr
-	switch verb {
-	case 'v', 'S', 'L':
-		if verb == 'v' && s.Flag('+') { // %+v is debug format
-			mode = FDbg
-		}
-		if verb == 'S' && s.Flag('-') { // %-S is special case for receiver - short typeid format
-			mode = FTypeId
-		}
-		fmt.Fprint(s, tconv(t, verb, mode))
-	default:
-		fmt.Fprintf(s, "%%!%c(*Type=%p)", verb, t)
-	}
-}
-
-func tconv(t *types.Type, verb rune, mode FmtMode) string {
-	buf := fmtBufferPool.Get().(*bytes.Buffer)
-	buf.Reset()
-	defer fmtBufferPool.Put(buf)
-
-	tconv2(buf, t, verb, mode, nil)
-	return types.InternString(buf.Bytes())
-}
-
-// tconv2 writes a string representation of t to b.
-// flag and mode control exactly what is printed.
-// Any types x that are already in the visited map get printed as @%d where %d=visited[x].
-// See #16897 before changing the implementation of tconv.
-func tconv2(b *bytes.Buffer, t *types.Type, verb rune, mode FmtMode, visited map[*types.Type]int) {
-	if off, ok := visited[t]; ok {
-		// We've seen this type before, so we're trying to print it recursively.
-		// Print a reference to it instead.
-		fmt.Fprintf(b, "@%d", off)
-		return
-	}
-	if t == nil {
-		b.WriteString("<T>")
-		return
-	}
-	if t.Kind() == types.TSSA {
-		b.WriteString(t.Extra.(string))
-		return
-	}
-	if t.Kind() == types.TTUPLE {
-		b.WriteString(t.FieldType(0).String())
-		b.WriteByte(',')
-		b.WriteString(t.FieldType(1).String())
-		return
-	}
-
-	if t.Kind() == types.TRESULTS {
-		tys := t.Extra.(*types.Results).Types
-		for i, et := range tys {
-			if i > 0 {
-				b.WriteByte(',')
-			}
-			b.WriteString(et.String())
-		}
-		return
-	}
-
-	if t == types.ByteType || t == types.RuneType {
-		// in %-T mode collapse rune and byte with their originals.
-		switch mode {
-		case FTypeIdName, FTypeId:
-			t = types.Types[t.Kind()]
-		default:
-			sconv2(b, t.Sym(), 'S', mode)
-			return
-		}
-	}
-	if t == types.ErrorType {
-		b.WriteString("error")
-		return
-	}
-
-	// Unless the 'L' flag was specified, if the type has a name, just print that name.
-	if verb != 'L' && t.Sym() != nil && t != types.Types[t.Kind()] {
-		switch mode {
-		case FTypeId, FTypeIdName:
-			if verb == 'S' {
-				if t.Vargen != 0 {
-					sconv2(b, t.Sym(), 'S', mode)
-					fmt.Fprintf(b, "·%d", t.Vargen)
-					return
-				}
-				sconv2(b, t.Sym(), 'S', mode)
-				return
-			}
-
-			if mode == FTypeIdName {
-				sconv2(b, t.Sym(), 'v', FTypeIdName)
-				return
-			}
-
-			if t.Sym().Pkg == LocalPkg && t.Vargen != 0 {
-				sconv2(b, t.Sym(), 'v', mode)
-				fmt.Fprintf(b, "·%d", t.Vargen)
-				return
-			}
-		}
-
-		sconv2(b, t.Sym(), 'v', mode)
-		return
-	}
-
-	if int(t.Kind()) < len(BasicTypeNames) && BasicTypeNames[t.Kind()] != "" {
-		var name string
-		switch t {
-		case types.UntypedBool:
-			name = "untyped bool"
-		case types.UntypedString:
-			name = "untyped string"
-		case types.UntypedInt:
-			name = "untyped int"
-		case types.UntypedRune:
-			name = "untyped rune"
-		case types.UntypedFloat:
-			name = "untyped float"
-		case types.UntypedComplex:
-			name = "untyped complex"
-		default:
-			name = BasicTypeNames[t.Kind()]
-		}
-		b.WriteString(name)
-		return
-	}
-
-	if mode == FDbg {
-		b.WriteString(t.Kind().String())
-		b.WriteByte('-')
-		tconv2(b, t, 'v', FErr, visited)
-		return
-	}
-
-	// At this point, we might call tconv2 recursively. Add the current type to the visited list so we don't
-	// try to print it recursively.
-	// We record the offset in the result buffer where the type's text starts. This offset serves as a reference
-	// point for any later references to the same type.
-	// Note that we remove the type from the visited map as soon as the recursive call is done.
-	// This prevents encoding types like map[*int]*int as map[*int]@4. (That encoding would work,
-	// but I'd like to use the @ notation only when strictly necessary.)
-	if visited == nil {
-		visited = map[*types.Type]int{}
-	}
-	visited[t] = b.Len()
-	defer delete(visited, t)
-
-	switch t.Kind() {
-	case types.TPTR:
-		b.WriteByte('*')
-		switch mode {
-		case FTypeId, FTypeIdName:
-			if verb == 'S' {
-				tconv2(b, t.Elem(), 'S', mode, visited)
-				return
-			}
-		}
-		tconv2(b, t.Elem(), 'v', mode, visited)
-
-	case types.TARRAY:
-		b.WriteByte('[')
-		b.WriteString(strconv.FormatInt(t.NumElem(), 10))
-		b.WriteByte(']')
-		tconv2(b, t.Elem(), 0, mode, visited)
-
-	case types.TSLICE:
-		b.WriteString("[]")
-		tconv2(b, t.Elem(), 0, mode, visited)
-
-	case types.TCHAN:
-		switch t.ChanDir() {
-		case types.Crecv:
-			b.WriteString("<-chan ")
-			tconv2(b, t.Elem(), 0, mode, visited)
-		case types.Csend:
-			b.WriteString("chan<- ")
-			tconv2(b, t.Elem(), 0, mode, visited)
-		default:
-			b.WriteString("chan ")
-			if t.Elem() != nil && t.Elem().IsChan() && t.Elem().Sym() == nil && t.Elem().ChanDir() == types.Crecv {
-				b.WriteByte('(')
-				tconv2(b, t.Elem(), 0, mode, visited)
-				b.WriteByte(')')
-			} else {
-				tconv2(b, t.Elem(), 0, mode, visited)
-			}
-		}
-
-	case types.TMAP:
-		b.WriteString("map[")
-		tconv2(b, t.Key(), 0, mode, visited)
-		b.WriteByte(']')
-		tconv2(b, t.Elem(), 0, mode, visited)
-
-	case types.TINTER:
-		if t.IsEmptyInterface() {
-			b.WriteString("interface {}")
-			break
-		}
-		b.WriteString("interface {")
-		for i, f := range t.Fields().Slice() {
-			if i != 0 {
-				b.WriteByte(';')
-			}
-			b.WriteByte(' ')
-			switch {
-			case f.Sym == nil:
-				// Check first that a symbol is defined for this type.
-				// Wrong interface definitions may have types lacking a symbol.
-				break
-			case types.IsExported(f.Sym.Name):
-				sconv2(b, f.Sym, 'S', mode)
-			default:
-				if mode != FTypeIdName {
-					mode = FTypeId
-				}
-				sconv2(b, f.Sym, 'v', mode)
-			}
-			tconv2(b, f.Type, 'S', mode, visited)
-		}
-		if t.NumFields() != 0 {
-			b.WriteByte(' ')
-		}
-		b.WriteByte('}')
-
-	case types.TFUNC:
-		if verb == 'S' {
-			// no leading func
-		} else {
-			if t.Recv() != nil {
-				b.WriteString("method")
-				tconv2(b, t.Recvs(), 0, mode, visited)
-				b.WriteByte(' ')
-			}
-			b.WriteString("func")
-		}
-		tconv2(b, t.Params(), 0, mode, visited)
-
-		switch t.NumResults() {
-		case 0:
-			// nothing to do
-
-		case 1:
-			b.WriteByte(' ')
-			tconv2(b, t.Results().Field(0).Type, 0, mode, visited) // struct->field->field's type
-
-		default:
-			b.WriteByte(' ')
-			tconv2(b, t.Results(), 0, mode, visited)
-		}
-
-	case types.TSTRUCT:
-		if m := t.StructType().Map; m != nil {
-			mt := m.MapType()
-			// Format the bucket struct for map[x]y as map.bucket[x]y.
-			// This avoids a recursive print that generates very long names.
-			switch t {
-			case mt.Bucket:
-				b.WriteString("map.bucket[")
-			case mt.Hmap:
-				b.WriteString("map.hdr[")
-			case mt.Hiter:
-				b.WriteString("map.iter[")
-			default:
-				base.Fatalf("unknown internal map type")
-			}
-			tconv2(b, m.Key(), 0, mode, visited)
-			b.WriteByte(']')
-			tconv2(b, m.Elem(), 0, mode, visited)
-			break
-		}
-
-		if funarg := t.StructType().Funarg; funarg != types.FunargNone {
-			b.WriteByte('(')
-			fieldVerb := 'v'
-			switch mode {
-			case FTypeId, FTypeIdName, FErr:
-				// no argument names on function signature, and no "noescape"/"nosplit" tags
-				fieldVerb = 'S'
-			}
-			for i, f := range t.Fields().Slice() {
-				if i != 0 {
-					b.WriteString(", ")
-				}
-				fldconv(b, f, fieldVerb, mode, visited, funarg)
-			}
-			b.WriteByte(')')
-		} else {
-			b.WriteString("struct {")
-			for i, f := range t.Fields().Slice() {
-				if i != 0 {
-					b.WriteByte(';')
-				}
-				b.WriteByte(' ')
-				fldconv(b, f, 'L', mode, visited, funarg)
-			}
-			if t.NumFields() != 0 {
-				b.WriteByte(' ')
-			}
-			b.WriteByte('}')
-		}
-
-	case types.TFORW:
-		b.WriteString("undefined")
-		if t.Sym() != nil {
-			b.WriteByte(' ')
-			sconv2(b, t.Sym(), 'v', mode)
-		}
-
-	case types.TUNSAFEPTR:
-		b.WriteString("unsafe.Pointer")
-
-	case types.Txxx:
-		b.WriteString("Txxx")
-
-	default:
-		// Don't know how to handle - fall back to detailed prints
-		b.WriteString(t.Kind().String())
-		b.WriteString(" <")
-		sconv2(b, t.Sym(), 'v', mode)
-		b.WriteString(">")
-
-	}
-}
-
-func fldconv(b *bytes.Buffer, f *types.Field, verb rune, mode FmtMode, visited map[*types.Type]int, funarg types.Funarg) {
-	if f == nil {
-		b.WriteString("<T>")
-		return
-	}
-
-	var name string
-	if verb != 'S' {
-		s := f.Sym
-
-		// Take the name from the original.
-		if mode == FErr {
-			s = OrigSym(s)
-		}
-
-		if s != nil && f.Embedded == 0 {
-			if funarg != types.FunargNone {
-				name = fmt.Sprint(f.Nname)
-			} else if verb == 'L' {
-				name = methodSymName(s)
-				if !types.IsExported(name) && mode != FTypeIdName {
-					name = sconv(s, 0, mode) // qualify non-exported names (used on structs, not on funarg)
-				}
-			} else {
-				name = sconv(s, 0, mode)
-			}
-		}
-	}
-
-	if name != "" {
-		b.WriteString(name)
-		b.WriteString(" ")
-	}
-
-	if f.IsDDD() {
-		var et *types.Type
-		if f.Type != nil {
-			et = f.Type.Elem()
-		}
-		b.WriteString("...")
-		tconv2(b, et, 0, mode, visited)
-	} else {
-		tconv2(b, f.Type, 0, mode, visited)
-	}
-
-	if verb != 'S' && funarg == types.FunargNone && f.Note != "" {
-		b.WriteString(" ")
-		b.WriteString(strconv.Quote(f.Note))
-	}
-}
-
 // Node
 
 func FmtNode(n Node, s fmt.State, verb rune) {
@@ -1198,7 +550,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 				fmt.Fprintf(s, "'\\U%08x'", uint64(x))
 			}
 		} else {
-			fmt.Fprint(s, FmtConst(n.Val(), s.Flag('#')))
+			fmt.Fprint(s, types.FmtConst(n.Val(), s.Flag('#')))
 		}
 
 		if needUnparen {
@@ -1338,7 +690,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 			fmt.Fprint(s, ".<nil>")
 			return
 		}
-		fmt.Fprintf(s, ".%s", methodSymName(n.Sym()))
+		fmt.Fprintf(s, ".%s", types.SymMethodName(n.Sym()))
 
 	case OXDOT, ODOT, ODOTPTR, ODOTINTER, ODOTMETH:
 		exprFmt(n.Left(), s, nprec)
@@ -1346,7 +698,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 			fmt.Fprint(s, ".<nil>")
 			return
 		}
-		fmt.Fprintf(s, ".%s", methodSymName(n.Sym()))
+		fmt.Fprintf(s, ".%s", types.SymMethodName(n.Sym()))
 
 	case ODOTTYPE, ODOTTYPE2:
 		exprFmt(n.Left(), s, nprec)
diff --git a/src/cmd/compile/internal/ir/ir.go b/src/cmd/compile/internal/ir/ir.go
index ad7f692b07..82224ca2ed 100644
--- a/src/cmd/compile/internal/ir/ir.go
+++ b/src/cmd/compile/internal/ir/ir.go
@@ -3,10 +3,3 @@
 // license that can be found in the LICENSE file.
 
 package ir
-
-import "cmd/compile/internal/types"
-
-var LocalPkg *types.Pkg // package being compiled
-
-// builtinpkg is a fake package that declares the universe block.
-var BuiltinPkg *types.Pkg
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 56b320e726..ba7eaae1b9 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -10,7 +10,6 @@ import (
 	"fmt"
 	"go/constant"
 	"sort"
-	"strings"
 
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
@@ -654,33 +653,6 @@ func AsNode(n types.Object) Node {
 
 var BlankNode Node
 
-var BlankSym *types.Sym
-
-// origSym returns the original symbol written by the user.
-func OrigSym(s *types.Sym) *types.Sym {
-	if s == nil {
-		return nil
-	}
-
-	if len(s.Name) > 1 && s.Name[0] == '~' {
-		switch s.Name[1] {
-		case 'r': // originally an unnamed result
-			return nil
-		case 'b': // originally the blank identifier _
-			// TODO(mdempsky): Does s.Pkg matter here?
-			return BlankSym
-		}
-		return s
-	}
-
-	if strings.HasPrefix(s.Name, ".anon") {
-		// originally an unnamed or _ name (see subr.go: structargs)
-		return nil
-	}
-
-	return s
-}
-
 func IsConst(n Node, ct constant.Kind) bool {
 	return ConstType(n) == ct
 }
diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go
index cb3b9c0e2a..decb843465 100644
--- a/src/cmd/compile/internal/ssa/export_test.go
+++ b/src/cmd/compile/internal/ssa/export_test.go
@@ -137,7 +137,7 @@ func init() {
 	// Initialize just enough of the universe and the types package to make our tests function.
 	// TODO(josharian): move universe initialization to the types package,
 	// so this test setup can share it.
-	ir.InstallTypeFormats()
+	types.InstallTypeFormats()
 	types.Dowidth = func(t *types.Type) {}
 
 	for _, typ := range [...]struct {
diff --git a/src/cmd/compile/internal/types/fmt.go b/src/cmd/compile/internal/types/fmt.go
new file mode 100644
index 0000000000..4f36e4c393
--- /dev/null
+++ b/src/cmd/compile/internal/types/fmt.go
@@ -0,0 +1,694 @@
+// Copyright 2009 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 types
+
+import (
+	"bytes"
+	"fmt"
+	"go/constant"
+	"strconv"
+	"strings"
+	"sync"
+
+	"cmd/compile/internal/base"
+)
+
+// builtinpkg is a fake package that declares the universe block.
+var BuiltinPkg *Pkg
+
+var LocalPkg *Pkg // package being compiled
+
+var BlankSym *Sym
+
+// origSym returns the original symbol written by the user.
+func OrigSym(s *Sym) *Sym {
+	if s == nil {
+		return nil
+	}
+
+	if len(s.Name) > 1 && s.Name[0] == '~' {
+		switch s.Name[1] {
+		case 'r': // originally an unnamed result
+			return nil
+		case 'b': // originally the blank identifier _
+			// TODO(mdempsky): Does s.Pkg matter here?
+			return BlankSym
+		}
+		return s
+	}
+
+	if strings.HasPrefix(s.Name, ".anon") {
+		// originally an unnamed or _ name (see subr.go: structargs)
+		return nil
+	}
+
+	return s
+}
+
+// Sym
+
+// numImport tracks how often a package with a given name is imported.
+// It is used to provide a better error message (by using the package
+// path to disambiguate) if a package that appears multiple times with
+// the same name appears in an error message.
+var NumImport = make(map[string]int)
+
+// Format conversions:
+// TODO(gri) verify these; eliminate those not used anymore
+//
+//	%v Op		Node opcodes
+//		Flags:  #: print Go syntax (automatic unless mode == FDbg)
+//
+//	%j *Node	Node details
+//		Flags:  0: suppresses things not relevant until walk
+//
+//	%v *Val		Constant values
+//
+//	%v *types.Sym		Symbols
+//	%S              unqualified identifier in any mode
+//		Flags:  +,- #: mode (see below)
+//			0: in export mode: unqualified identifier if exported, qualified if not
+//
+//	%v *types.Type	Types
+//	%S              omit "func" and receiver in function types
+//	%L              definition instead of name.
+//		Flags:  +,- #: mode (see below)
+//			' ' (only in -/Sym mode) print type identifiers wit package name instead of prefix.
+//
+//	%v *Node	Nodes
+//	%S              (only in +/debug mode) suppress recursion
+//	%L              (only in Error mode) print "foo (type Bar)"
+//		Flags:  +,- #: mode (see below)
+//
+//	%v Nodes	Node lists
+//		Flags:  those of *Node
+//			.: separate items with ',' instead of ';'
+
+// *types.Sym, *types.Type, and *Node types use the flags below to set the format mode
+
+// The mode flags '+', '-', and '#' are sticky; they persist through
+// recursions of *Node, *types.Type, and *types.Sym values. The ' ' flag is
+// sticky only on *types.Type recursions and only used in %-/*types.Sym mode.
+//
+// Example: given a *types.Sym: %+v %#v %-v print an identifier properly qualified for debug/export/internal mode
+
+// Useful format combinations:
+// TODO(gri): verify these
+//
+// *Node, Nodes:
+//   %+v    multiline recursive debug dump of *Node/Nodes
+//   %+S    non-recursive debug dump
+//
+// *Node:
+//   %#v    Go format
+//   %L     "foo (type Bar)" for error messages
+//
+// *types.Type:
+//   %#v    Go format
+//   %#L    type definition instead of name
+//   %#S    omit "func" and receiver in function signature
+//
+//   %-v    type identifiers
+//   %-S    type identifiers without "func" and arg names in type signatures (methodsym)
+//   %- v   type identifiers with package name instead of prefix (typesym, dcommontype, typehash)
+
+type fmtMode int
+
+const (
+	fmtGo fmtMode = iota
+	fmtDebug
+	fmtTypeID
+	fmtTypeIDName // same as FTypeId, but use package name instead of prefix
+)
+
+// "%S" suppresses qualifying with package
+func symFormat(s *Sym, f fmt.State, verb rune) {
+	mode := fmtGo
+	switch verb {
+	case 'v', 'S':
+		if verb == 'v' && f.Flag('+') {
+			mode = fmtDebug
+		}
+		fmt.Fprint(f, sconv(s, verb, mode))
+
+	default:
+		fmt.Fprintf(f, "%%!%c(*types.Sym=%p)", verb, s)
+	}
+}
+
+// See #16897 for details about performance implications
+// before changing the implementation of sconv.
+func sconv(s *Sym, verb rune, mode fmtMode) string {
+	if verb == 'L' {
+		panic("linksymfmt")
+	}
+
+	if s == nil {
+		return "<S>"
+	}
+
+	if s.Name == "_" {
+		return "_"
+	}
+	buf := fmtBufferPool.Get().(*bytes.Buffer)
+	buf.Reset()
+	defer fmtBufferPool.Put(buf)
+
+	symfmt(buf, s, verb, mode)
+	return InternString(buf.Bytes())
+}
+
+func sconv2(b *bytes.Buffer, s *Sym, verb rune, mode fmtMode) {
+	if verb == 'L' {
+		panic("linksymfmt")
+	}
+	if s == nil {
+		b.WriteString("<S>")
+		return
+	}
+	if s.Name == "_" {
+		b.WriteString("_")
+		return
+	}
+
+	symfmt(b, s, verb, mode)
+}
+
+func symfmt(b *bytes.Buffer, s *Sym, verb rune, mode fmtMode) {
+	if verb != 'S' {
+		switch mode {
+		case fmtGo: // This is for the user
+			if s.Pkg == BuiltinPkg || s.Pkg == LocalPkg {
+				b.WriteString(s.Name)
+				return
+			}
+
+			// If the name was used by multiple packages, display the full path,
+			if s.Pkg.Name != "" && NumImport[s.Pkg.Name] > 1 {
+				fmt.Fprintf(b, "%q.%s", s.Pkg.Path, s.Name)
+				return
+			}
+			b.WriteString(s.Pkg.Name)
+			b.WriteByte('.')
+			b.WriteString(s.Name)
+			return
+
+		case fmtDebug:
+			b.WriteString(s.Pkg.Name)
+			b.WriteByte('.')
+			b.WriteString(s.Name)
+			return
+
+		case fmtTypeIDName:
+			// dcommontype, typehash
+			b.WriteString(s.Pkg.Name)
+			b.WriteByte('.')
+			b.WriteString(s.Name)
+			return
+
+		case fmtTypeID:
+			// (methodsym), typesym, weaksym
+			b.WriteString(s.Pkg.Prefix)
+			b.WriteByte('.')
+			b.WriteString(s.Name)
+			return
+		}
+	}
+
+	b.WriteString(s.Name)
+}
+
+func SymMethodName(s *Sym) string {
+	// Skip leading "type." in method name
+	name := s.Name
+	if i := strings.LastIndex(name, "."); i >= 0 {
+		name = name[i+1:]
+	}
+	return name
+}
+
+// Type
+
+var BasicTypeNames = []string{
+	TINT:        "int",
+	TUINT:       "uint",
+	TINT8:       "int8",
+	TUINT8:      "uint8",
+	TINT16:      "int16",
+	TUINT16:     "uint16",
+	TINT32:      "int32",
+	TUINT32:     "uint32",
+	TINT64:      "int64",
+	TUINT64:     "uint64",
+	TUINTPTR:    "uintptr",
+	TFLOAT32:    "float32",
+	TFLOAT64:    "float64",
+	TCOMPLEX64:  "complex64",
+	TCOMPLEX128: "complex128",
+	TBOOL:       "bool",
+	TANY:        "any",
+	TSTRING:     "string",
+	TNIL:        "nil",
+	TIDEAL:      "untyped number",
+	TBLANK:      "blank",
+}
+
+var fmtBufferPool = sync.Pool{
+	New: func() interface{} {
+		return new(bytes.Buffer)
+	},
+}
+
+func InstallTypeFormats() {
+	SymString = func(s *Sym) string {
+		return sconv(s, 0, fmtGo)
+	}
+	TypeString = func(t *Type) string {
+		return tconv(t, 0, fmtGo)
+	}
+	TypeShortString = func(t *Type) string {
+		return tconv(t, 0, fmtTypeID)
+	}
+	TypeLongString = func(t *Type) string {
+		return tconv(t, 0, fmtTypeIDName)
+	}
+	FormatSym = symFormat
+	FormatType = typeFormat
+}
+
+// "%L"  print definition, not name
+// "%S"  omit 'func' and receiver from function types, short type names
+func typeFormat(t *Type, s fmt.State, verb rune) {
+	mode := fmtGo
+	switch verb {
+	case 'v', 'S', 'L':
+		if verb == 'v' && s.Flag('+') { // %+v is debug format
+			mode = fmtDebug
+		}
+		if verb == 'S' && s.Flag('-') { // %-S is special case for receiver - short typeid format
+			mode = fmtTypeID
+		}
+		fmt.Fprint(s, tconv(t, verb, mode))
+	default:
+		fmt.Fprintf(s, "%%!%c(*Type=%p)", verb, t)
+	}
+}
+
+func tconv(t *Type, verb rune, mode fmtMode) string {
+	buf := fmtBufferPool.Get().(*bytes.Buffer)
+	buf.Reset()
+	defer fmtBufferPool.Put(buf)
+
+	tconv2(buf, t, verb, mode, nil)
+	return InternString(buf.Bytes())
+}
+
+// tconv2 writes a string representation of t to b.
+// flag and mode control exactly what is printed.
+// Any types x that are already in the visited map get printed as @%d where %d=visited[x].
+// See #16897 before changing the implementation of tconv.
+func tconv2(b *bytes.Buffer, t *Type, verb rune, mode fmtMode, visited map[*Type]int) {
+	if off, ok := visited[t]; ok {
+		// We've seen this type before, so we're trying to print it recursively.
+		// Print a reference to it instead.
+		fmt.Fprintf(b, "@%d", off)
+		return
+	}
+	if t == nil {
+		b.WriteString("<T>")
+		return
+	}
+	if t.Kind() == TSSA {
+		b.WriteString(t.Extra.(string))
+		return
+	}
+	if t.Kind() == TTUPLE {
+		b.WriteString(t.FieldType(0).String())
+		b.WriteByte(',')
+		b.WriteString(t.FieldType(1).String())
+		return
+	}
+
+	if t.Kind() == TRESULTS {
+		tys := t.Extra.(*Results).Types
+		for i, et := range tys {
+			if i > 0 {
+				b.WriteByte(',')
+			}
+			b.WriteString(et.String())
+		}
+		return
+	}
+
+	if t == ByteType || t == RuneType {
+		// in %-T mode collapse rune and byte with their originals.
+		switch mode {
+		case fmtTypeIDName, fmtTypeID:
+			t = Types[t.Kind()]
+		default:
+			sconv2(b, t.Sym(), 'S', mode)
+			return
+		}
+	}
+	if t == ErrorType {
+		b.WriteString("error")
+		return
+	}
+
+	// Unless the 'L' flag was specified, if the type has a name, just print that name.
+	if verb != 'L' && t.Sym() != nil && t != Types[t.Kind()] {
+		switch mode {
+		case fmtTypeID, fmtTypeIDName:
+			if verb == 'S' {
+				if t.Vargen != 0 {
+					sconv2(b, t.Sym(), 'S', mode)
+					fmt.Fprintf(b, "·%d", t.Vargen)
+					return
+				}
+				sconv2(b, t.Sym(), 'S', mode)
+				return
+			}
+
+			if mode == fmtTypeIDName {
+				sconv2(b, t.Sym(), 'v', fmtTypeIDName)
+				return
+			}
+
+			if t.Sym().Pkg == LocalPkg && t.Vargen != 0 {
+				sconv2(b, t.Sym(), 'v', mode)
+				fmt.Fprintf(b, "·%d", t.Vargen)
+				return
+			}
+		}
+
+		sconv2(b, t.Sym(), 'v', mode)
+		return
+	}
+
+	if int(t.Kind()) < len(BasicTypeNames) && BasicTypeNames[t.Kind()] != "" {
+		var name string
+		switch t {
+		case UntypedBool:
+			name = "untyped bool"
+		case UntypedString:
+			name = "untyped string"
+		case UntypedInt:
+			name = "untyped int"
+		case UntypedRune:
+			name = "untyped rune"
+		case UntypedFloat:
+			name = "untyped float"
+		case UntypedComplex:
+			name = "untyped complex"
+		default:
+			name = BasicTypeNames[t.Kind()]
+		}
+		b.WriteString(name)
+		return
+	}
+
+	if mode == fmtDebug {
+		b.WriteString(t.Kind().String())
+		b.WriteByte('-')
+		tconv2(b, t, 'v', fmtGo, visited)
+		return
+	}
+
+	// At this point, we might call tconv2 recursively. Add the current type to the visited list so we don't
+	// try to print it recursively.
+	// We record the offset in the result buffer where the type's text starts. This offset serves as a reference
+	// point for any later references to the same type.
+	// Note that we remove the type from the visited map as soon as the recursive call is done.
+	// This prevents encoding types like map[*int]*int as map[*int]@4. (That encoding would work,
+	// but I'd like to use the @ notation only when strictly necessary.)
+	if visited == nil {
+		visited = map[*Type]int{}
+	}
+	visited[t] = b.Len()
+	defer delete(visited, t)
+
+	switch t.Kind() {
+	case TPTR:
+		b.WriteByte('*')
+		switch mode {
+		case fmtTypeID, fmtTypeIDName:
+			if verb == 'S' {
+				tconv2(b, t.Elem(), 'S', mode, visited)
+				return
+			}
+		}
+		tconv2(b, t.Elem(), 'v', mode, visited)
+
+	case TARRAY:
+		b.WriteByte('[')
+		b.WriteString(strconv.FormatInt(t.NumElem(), 10))
+		b.WriteByte(']')
+		tconv2(b, t.Elem(), 0, mode, visited)
+
+	case TSLICE:
+		b.WriteString("[]")
+		tconv2(b, t.Elem(), 0, mode, visited)
+
+	case TCHAN:
+		switch t.ChanDir() {
+		case Crecv:
+			b.WriteString("<-chan ")
+			tconv2(b, t.Elem(), 0, mode, visited)
+		case Csend:
+			b.WriteString("chan<- ")
+			tconv2(b, t.Elem(), 0, mode, visited)
+		default:
+			b.WriteString("chan ")
+			if t.Elem() != nil && t.Elem().IsChan() && t.Elem().Sym() == nil && t.Elem().ChanDir() == Crecv {
+				b.WriteByte('(')
+				tconv2(b, t.Elem(), 0, mode, visited)
+				b.WriteByte(')')
+			} else {
+				tconv2(b, t.Elem(), 0, mode, visited)
+			}
+		}
+
+	case TMAP:
+		b.WriteString("map[")
+		tconv2(b, t.Key(), 0, mode, visited)
+		b.WriteByte(']')
+		tconv2(b, t.Elem(), 0, mode, visited)
+
+	case TINTER:
+		if t.IsEmptyInterface() {
+			b.WriteString("interface {}")
+			break
+		}
+		b.WriteString("interface {")
+		for i, f := range t.Fields().Slice() {
+			if i != 0 {
+				b.WriteByte(';')
+			}
+			b.WriteByte(' ')
+			switch {
+			case f.Sym == nil:
+				// Check first that a symbol is defined for this type.
+				// Wrong interface definitions may have types lacking a symbol.
+				break
+			case IsExported(f.Sym.Name):
+				sconv2(b, f.Sym, 'S', mode)
+			default:
+				if mode != fmtTypeIDName {
+					mode = fmtTypeID
+				}
+				sconv2(b, f.Sym, 'v', mode)
+			}
+			tconv2(b, f.Type, 'S', mode, visited)
+		}
+		if t.NumFields() != 0 {
+			b.WriteByte(' ')
+		}
+		b.WriteByte('}')
+
+	case TFUNC:
+		if verb == 'S' {
+			// no leading func
+		} else {
+			if t.Recv() != nil {
+				b.WriteString("method")
+				tconv2(b, t.Recvs(), 0, mode, visited)
+				b.WriteByte(' ')
+			}
+			b.WriteString("func")
+		}
+		tconv2(b, t.Params(), 0, mode, visited)
+
+		switch t.NumResults() {
+		case 0:
+			// nothing to do
+
+		case 1:
+			b.WriteByte(' ')
+			tconv2(b, t.Results().Field(0).Type, 0, mode, visited) // struct->field->field's type
+
+		default:
+			b.WriteByte(' ')
+			tconv2(b, t.Results(), 0, mode, visited)
+		}
+
+	case TSTRUCT:
+		if m := t.StructType().Map; m != nil {
+			mt := m.MapType()
+			// Format the bucket struct for map[x]y as map.bucket[x]y.
+			// This avoids a recursive print that generates very long names.
+			switch t {
+			case mt.Bucket:
+				b.WriteString("map.bucket[")
+			case mt.Hmap:
+				b.WriteString("map.hdr[")
+			case mt.Hiter:
+				b.WriteString("map.iter[")
+			default:
+				base.Fatalf("unknown internal map type")
+			}
+			tconv2(b, m.Key(), 0, mode, visited)
+			b.WriteByte(']')
+			tconv2(b, m.Elem(), 0, mode, visited)
+			break
+		}
+
+		if funarg := t.StructType().Funarg; funarg != FunargNone {
+			b.WriteByte('(')
+			fieldVerb := 'v'
+			switch mode {
+			case fmtTypeID, fmtTypeIDName, fmtGo:
+				// no argument names on function signature, and no "noescape"/"nosplit" tags
+				fieldVerb = 'S'
+			}
+			for i, f := range t.Fields().Slice() {
+				if i != 0 {
+					b.WriteString(", ")
+				}
+				fldconv(b, f, fieldVerb, mode, visited, funarg)
+			}
+			b.WriteByte(')')
+		} else {
+			b.WriteString("struct {")
+			for i, f := range t.Fields().Slice() {
+				if i != 0 {
+					b.WriteByte(';')
+				}
+				b.WriteByte(' ')
+				fldconv(b, f, 'L', mode, visited, funarg)
+			}
+			if t.NumFields() != 0 {
+				b.WriteByte(' ')
+			}
+			b.WriteByte('}')
+		}
+
+	case TFORW:
+		b.WriteString("undefined")
+		if t.Sym() != nil {
+			b.WriteByte(' ')
+			sconv2(b, t.Sym(), 'v', mode)
+		}
+
+	case TUNSAFEPTR:
+		b.WriteString("unsafe.Pointer")
+
+	case Txxx:
+		b.WriteString("Txxx")
+
+	default:
+		// Don't know how to handle - fall back to detailed prints
+		b.WriteString(t.Kind().String())
+		b.WriteString(" <")
+		sconv2(b, t.Sym(), 'v', mode)
+		b.WriteString(">")
+
+	}
+}
+
+func fldconv(b *bytes.Buffer, f *Field, verb rune, mode fmtMode, visited map[*Type]int, funarg Funarg) {
+	if f == nil {
+		b.WriteString("<T>")
+		return
+	}
+
+	var name string
+	if verb != 'S' {
+		s := f.Sym
+
+		// Take the name from the original.
+		if mode == fmtGo {
+			s = OrigSym(s)
+		}
+
+		if s != nil && f.Embedded == 0 {
+			if funarg != FunargNone {
+				name = fmt.Sprint(f.Nname)
+			} else if verb == 'L' {
+				name = SymMethodName(s)
+				if !IsExported(name) && mode != fmtTypeIDName {
+					name = sconv(s, 0, mode) // qualify non-exported names (used on structs, not on funarg)
+				}
+			} else {
+				name = sconv(s, 0, mode)
+			}
+		}
+	}
+
+	if name != "" {
+		b.WriteString(name)
+		b.WriteString(" ")
+	}
+
+	if f.IsDDD() {
+		var et *Type
+		if f.Type != nil {
+			et = f.Type.Elem()
+		}
+		b.WriteString("...")
+		tconv2(b, et, 0, mode, visited)
+	} else {
+		tconv2(b, f.Type, 0, mode, visited)
+	}
+
+	if verb != 'S' && funarg == FunargNone && f.Note != "" {
+		b.WriteString(" ")
+		b.WriteString(strconv.Quote(f.Note))
+	}
+}
+
+// Val
+
+func FmtConst(v constant.Value, sharp bool) string {
+	if !sharp && v.Kind() == constant.Complex {
+		real, imag := constant.Real(v), constant.Imag(v)
+
+		var re string
+		sre := constant.Sign(real)
+		if sre != 0 {
+			re = real.String()
+		}
+
+		var im string
+		sim := constant.Sign(imag)
+		if sim != 0 {
+			im = imag.String()
+		}
+
+		switch {
+		case sre == 0 && sim == 0:
+			return "0"
+		case sre == 0:
+			return im + "i"
+		case sim == 0:
+			return re
+		case sim < 0:
+			return fmt.Sprintf("(%s%si)", re, im)
+		default:
+			return fmt.Sprintf("(%s+%si)", re, im)
+		}
+	}
+
+	return v.String()
+}
-- 
GitLab


From 6ea2b8c54cbc2d3a03d5dd174bc7526d33459d37 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 6 Dec 2020 14:15:09 -0500
Subject: [PATCH 0178/2400] [dev.regabi] cmd/compile: clean up and document
 formatting

Some cleanup left over from moving the Type and Sym formatting to types.
And then document what the type formats are, now that it's clear.

Passes buildall w/ toolstash -cmp.

Change-Id: I35cb8978f1627db1056cb8ab343ce6ba6c99afad
Reviewed-on: https://go-review.googlesource.com/c/go/+/275780
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/main.go         |   1 -
 src/cmd/compile/internal/ir/fmt.go          |  35 ++++-
 src/cmd/compile/internal/ssa/export_test.go |   1 -
 src/cmd/compile/internal/types/fmt.go       | 141 ++++++++------------
 src/cmd/compile/internal/types/utils.go     |  45 +------
 5 files changed, 87 insertions(+), 136 deletions(-)

diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 15659dc7fd..503dc449d3 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -212,7 +212,6 @@ func Main(archInit func(*Arch)) {
 	// would lead to import cycles)
 	types.Widthptr = Widthptr
 	types.Dowidth = dowidth
-	types.InstallTypeFormats()
 	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
 		return typenamesym(t).Linksym()
 	}
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 79d85d1803..85c6b218e2 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -86,6 +86,7 @@ var OpNames = []string{
 	OXOR:      "^",
 }
 
+// GoString returns the Go syntax for the Op, or else its name.
 func (o Op) GoString() string {
 	if int(o) < len(OpNames) && OpNames[o] != "" {
 		return OpNames[o]
@@ -93,6 +94,12 @@ func (o Op) GoString() string {
 	return o.String()
 }
 
+// Format implements formatting for an Op.
+// The valid formats are:
+//
+//	%v	Go syntax ("+", "<-", "print")
+//	%+v	Debug syntax ("ADD", "RECV", "PRINT")
+//
 func (o Op) Format(s fmt.State, verb rune) {
 	switch verb {
 	default:
@@ -109,6 +116,14 @@ func (o Op) Format(s fmt.State, verb rune) {
 
 // Node
 
+// FmtNode implements formatting for a Node n.
+// Every Node implementation must define a Format method that calls FmtNode.
+// The valid formats are:
+//
+//	%v	Go syntax
+//	%L	Go syntax followed by " (type T)" if type is known.
+//	%+v	Debug syntax, as in Dump.
+//
 func FmtNode(n Node, s fmt.State, verb rune) {
 	// TODO(rsc): Remove uses of %#v, which behaves just like %v.
 	// TODO(rsc): Remove uses of %S, which behaves just like %v.
@@ -276,7 +291,7 @@ var OpPrec = []int{
 	OEND: 0,
 }
 
-// Statements which may be rendered with a simplestmt as init.
+// StmtWithInit reports whether op is a statement with an explicit init list.
 func StmtWithInit(op Op) bool {
 	switch op {
 	case OIF, OFOR, OFORUNTIL, OSWITCH:
@@ -869,6 +884,13 @@ func ellipsisIf(b bool) string {
 
 // Nodes
 
+// Format implements formatting for a Nodes.
+// The valid formats are:
+//
+//	%v	Go syntax, semicolon-separated
+//	%.v	Go syntax, comma-separated
+//	%+v	Debug syntax, as in DumpList.
+//
 func (l Nodes) Format(s fmt.State, verb rune) {
 	if s.Flag('+') && verb == 'v' {
 		// %+v is DumpList output
@@ -896,19 +918,22 @@ func (l Nodes) Format(s fmt.State, verb rune) {
 
 // Dump
 
+// Dump prints the message s followed by a debug dump of n.
 func Dump(s string, n Node) {
 	fmt.Printf("%s [%p]%+v", s, n, n)
 }
 
-func DumpList(s string, l Nodes) {
+// DumpList prints the message s followed by a debug dump of each node in the list.
+func DumpList(s string, list Nodes) {
 	var buf bytes.Buffer
-	FDumpList(&buf, s, l)
+	FDumpList(&buf, s, list)
 	os.Stdout.Write(buf.Bytes())
 }
 
-func FDumpList(w io.Writer, s string, l Nodes) {
+// FDumpList prints to w the message s followed by a debug dump of each node in the list.
+func FDumpList(w io.Writer, s string, list Nodes) {
 	io.WriteString(w, s)
-	dumpNodes(w, l, 1)
+	dumpNodes(w, list, 1)
 	io.WriteString(w, "\n")
 }
 
diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go
index decb843465..55fce31088 100644
--- a/src/cmd/compile/internal/ssa/export_test.go
+++ b/src/cmd/compile/internal/ssa/export_test.go
@@ -137,7 +137,6 @@ func init() {
 	// Initialize just enough of the universe and the types package to make our tests function.
 	// TODO(josharian): move universe initialization to the types package,
 	// so this test setup can share it.
-	types.InstallTypeFormats()
 	types.Dowidth = func(t *types.Type) {}
 
 	for _, typ := range [...]struct {
diff --git a/src/cmd/compile/internal/types/fmt.go b/src/cmd/compile/internal/types/fmt.go
index 4f36e4c393..d63f7a4f8d 100644
--- a/src/cmd/compile/internal/types/fmt.go
+++ b/src/cmd/compile/internal/types/fmt.go
@@ -15,14 +15,16 @@ import (
 	"cmd/compile/internal/base"
 )
 
-// builtinpkg is a fake package that declares the universe block.
+// BuiltinPkg is a fake package that declares the universe block.
 var BuiltinPkg *Pkg
 
-var LocalPkg *Pkg // package being compiled
+// LocalPkg is the package being compiled.
+var LocalPkg *Pkg
 
+// BlankSym is the blank (_) symbol.
 var BlankSym *Sym
 
-// origSym returns the original symbol written by the user.
+// OrigSym returns the original symbol written by the user.
 func OrigSym(s *Sym) *Sym {
 	if s == nil {
 		return nil
@@ -47,84 +49,36 @@ func OrigSym(s *Sym) *Sym {
 	return s
 }
 
-// Sym
-
 // numImport tracks how often a package with a given name is imported.
 // It is used to provide a better error message (by using the package
 // path to disambiguate) if a package that appears multiple times with
 // the same name appears in an error message.
 var NumImport = make(map[string]int)
 
-// Format conversions:
-// TODO(gri) verify these; eliminate those not used anymore
-//
-//	%v Op		Node opcodes
-//		Flags:  #: print Go syntax (automatic unless mode == FDbg)
-//
-//	%j *Node	Node details
-//		Flags:  0: suppresses things not relevant until walk
-//
-//	%v *Val		Constant values
-//
-//	%v *types.Sym		Symbols
-//	%S              unqualified identifier in any mode
-//		Flags:  +,- #: mode (see below)
-//			0: in export mode: unqualified identifier if exported, qualified if not
-//
-//	%v *types.Type	Types
-//	%S              omit "func" and receiver in function types
-//	%L              definition instead of name.
-//		Flags:  +,- #: mode (see below)
-//			' ' (only in -/Sym mode) print type identifiers wit package name instead of prefix.
-//
-//	%v *Node	Nodes
-//	%S              (only in +/debug mode) suppress recursion
-//	%L              (only in Error mode) print "foo (type Bar)"
-//		Flags:  +,- #: mode (see below)
-//
-//	%v Nodes	Node lists
-//		Flags:  those of *Node
-//			.: separate items with ',' instead of ';'
-
-// *types.Sym, *types.Type, and *Node types use the flags below to set the format mode
-
-// The mode flags '+', '-', and '#' are sticky; they persist through
-// recursions of *Node, *types.Type, and *types.Sym values. The ' ' flag is
-// sticky only on *types.Type recursions and only used in %-/*types.Sym mode.
-//
-// Example: given a *types.Sym: %+v %#v %-v print an identifier properly qualified for debug/export/internal mode
-
-// Useful format combinations:
-// TODO(gri): verify these
-//
-// *Node, Nodes:
-//   %+v    multiline recursive debug dump of *Node/Nodes
-//   %+S    non-recursive debug dump
-//
-// *Node:
-//   %#v    Go format
-//   %L     "foo (type Bar)" for error messages
-//
-// *types.Type:
-//   %#v    Go format
-//   %#L    type definition instead of name
-//   %#S    omit "func" and receiver in function signature
-//
-//   %-v    type identifiers
-//   %-S    type identifiers without "func" and arg names in type signatures (methodsym)
-//   %- v   type identifiers with package name instead of prefix (typesym, dcommontype, typehash)
-
+// fmtMode represents the kind of printing being done.
+// The default is regular Go syntax (fmtGo).
+// fmtDebug is like fmtGo but for debugging dumps and prints the type kind too.
+// fmtTypeID and fmtTypeIDName are for generating various unique representations
+// of types used in hashes and the linker.
 type fmtMode int
 
 const (
 	fmtGo fmtMode = iota
 	fmtDebug
 	fmtTypeID
-	fmtTypeIDName // same as FTypeId, but use package name instead of prefix
+	fmtTypeIDName
 )
 
-// "%S" suppresses qualifying with package
-func symFormat(s *Sym, f fmt.State, verb rune) {
+// Sym
+
+// Format implements formatting for a Sym.
+// The valid formats are:
+//
+//	%v	Go syntax: Name for symbols in the local package, PkgName.Name for imported symbols.
+//	%+v	Debug syntax: always include PkgName. prefix even for local names.
+//	%S	Short syntax: Name only, no matter what.
+//
+func (s *Sym) Format(f fmt.State, verb rune) {
 	mode := fmtGo
 	switch verb {
 	case 'v', 'S':
@@ -138,6 +92,10 @@ func symFormat(s *Sym, f fmt.State, verb rune) {
 	}
 }
 
+func (s *Sym) String() string {
+	return sconv(s, 0, fmtGo)
+}
+
 // See #16897 for details about performance implications
 // before changing the implementation of sconv.
 func sconv(s *Sym, verb rune, mode fmtMode) string {
@@ -261,26 +219,16 @@ var fmtBufferPool = sync.Pool{
 	},
 }
 
-func InstallTypeFormats() {
-	SymString = func(s *Sym) string {
-		return sconv(s, 0, fmtGo)
-	}
-	TypeString = func(t *Type) string {
-		return tconv(t, 0, fmtGo)
-	}
-	TypeShortString = func(t *Type) string {
-		return tconv(t, 0, fmtTypeID)
-	}
-	TypeLongString = func(t *Type) string {
-		return tconv(t, 0, fmtTypeIDName)
-	}
-	FormatSym = symFormat
-	FormatType = typeFormat
-}
-
-// "%L"  print definition, not name
-// "%S"  omit 'func' and receiver from function types, short type names
-func typeFormat(t *Type, s fmt.State, verb rune) {
+// Format implements formatting for a Type.
+// The valid formats are:
+//
+//	%v	Go syntax
+//	%+v	Debug syntax: Go syntax with a KIND- prefix for all but builtins.
+//	%L	Go syntax for underlying type if t is named
+//	%S	short Go syntax: drop leading "func" in function type
+//	%-S	special case for method receiver symbol
+//
+func (t *Type) Format(s fmt.State, verb rune) {
 	mode := fmtGo
 	switch verb {
 	case 'v', 'S', 'L':
@@ -296,6 +244,25 @@ func typeFormat(t *Type, s fmt.State, verb rune) {
 	}
 }
 
+// String returns the Go syntax for the type t.
+func (t *Type) String() string {
+	return tconv(t, 0, fmtGo)
+}
+
+// ShortString generates a short description of t.
+// It is used in autogenerated method names, reflection,
+// and itab names.
+func (t *Type) ShortString() string {
+	return tconv(t, 0, fmtTypeID)
+}
+
+// LongString generates a complete description of t.
+// It is useful for reflection,
+// or when a unique fingerprint or hash of a type is required.
+func (t *Type) LongString() string {
+	return tconv(t, 0, fmtTypeIDName)
+}
+
 func tconv(t *Type, verb rune, mode fmtMode) string {
 	buf := fmtBufferPool.Get().(*bytes.Buffer)
 	buf.Reset()
diff --git a/src/cmd/compile/internal/types/utils.go b/src/cmd/compile/internal/types/utils.go
index a1be77eef1..531f3ea1ca 100644
--- a/src/cmd/compile/internal/types/utils.go
+++ b/src/cmd/compile/internal/types/utils.go
@@ -6,7 +6,6 @@ package types
 
 import (
 	"cmd/internal/obj"
-	"fmt"
 )
 
 const BADWIDTH = -1000000000
@@ -15,49 +14,11 @@ const BADWIDTH = -1000000000
 // They are here to break import cycles.
 // TODO(gri) eliminate these dependencies.
 var (
-	Widthptr        int
-	Dowidth         func(*Type)
-	SymString       func(*Sym) string
-	TypeString      func(*Type) string
-	TypeShortString func(*Type) string
-	TypeLongString  func(*Type) string
-	FormatSym       func(*Sym, fmt.State, rune)
-	FormatType      func(*Type, fmt.State, rune)
-	TypeLinkSym     func(*Type) *obj.LSym
+	Widthptr    int
+	Dowidth     func(*Type)
+	TypeLinkSym func(*Type) *obj.LSym
 )
 
-func (s *Sym) String() string {
-	return SymString(s)
-}
-
-func (sym *Sym) Format(s fmt.State, verb rune) {
-	FormatSym(sym, s, verb)
-}
-
-func (t *Type) String() string {
-	// The implementation
-	// must handle recursive types correctly.
-	return TypeString(t)
-}
-
-// ShortString generates a short description of t.
-// It is used in autogenerated method names, reflection,
-// and itab names.
-func (t *Type) ShortString() string {
-	return TypeShortString(t)
-}
-
-// LongString generates a complete description of t.
-// It is useful for reflection,
-// or when a unique fingerprint or hash of a type is required.
-func (t *Type) LongString() string {
-	return TypeLongString(t)
-}
-
-func (t *Type) Format(s fmt.State, verb rune) {
-	FormatType(t, s, verb)
-}
-
 type bitset8 uint8
 
 func (f *bitset8) set(mask uint8, b bool) {
-- 
GitLab


From 61889ba68098fa0e79e0b182f3b8c38b69c9b36c Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 6 Dec 2020 14:33:06 -0500
Subject: [PATCH 0179/2400] [dev.regabi] cmd/compile: simplify fmtmap

The format map is going to keep growing as we add more use of
concrete node types. Stop that by reporting all Node implementations
as Node.

Also, there's little point to reporting uses of %v, %p, %T, nor to reporting
formatting of basic types like int and []byte. Remove those too.
(Vet takes care of mistakes involving basic types now.)

Passes buildall w/ toolstash -cmp.

Change-Id: Ia9fb39b401c29bf0c76ffebaa24836c70acd773f
Reviewed-on: https://go-review.googlesource.com/c/go/+/275781
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/fmt_test.go    |  18 ++-
 src/cmd/compile/fmtmap_test.go | 242 ++++++++-------------------------
 2 files changed, 72 insertions(+), 188 deletions(-)

diff --git a/src/cmd/compile/fmt_test.go b/src/cmd/compile/fmt_test.go
index 6625ccf5e2..6398a84f8f 100644
--- a/src/cmd/compile/fmt_test.go
+++ b/src/cmd/compile/fmt_test.go
@@ -125,6 +125,12 @@ func TestFormats(t *testing.T) {
 			typ := p.types[index]
 			format := typ + " " + in // e.g., "*Node %n"
 
+			// Do not bother reporting basic types, nor %v, %T, %p.
+			// Vet handles basic types, and those three formats apply to all types.
+			if !strings.Contains(typ, ".") || (in == "%v" || in == "%T" || in == "%p") {
+				return in
+			}
+
 			// check if format is known
 			out, known := knownFormats[format]
 
@@ -413,7 +419,17 @@ func nodeString(n ast.Node) string {
 
 // typeString returns a string representation of n.
 func typeString(typ types.Type) string {
-	return filepath.ToSlash(typ.String())
+	s := filepath.ToSlash(typ.String())
+
+	// Report all the concrete IR types as Node, to shorten fmtmap.
+	const ir = "cmd/compile/internal/ir."
+	if s == "*"+ir+"Name" || s == "*"+ir+"Func" || s == "*"+ir+"Decl" ||
+		s == ir+"Ntype" || s == ir+"Expr" || s == ir+"Stmt" ||
+		strings.HasPrefix(s, "*"+ir) && (strings.HasSuffix(s, "Expr") || strings.HasSuffix(s, "Stmt")) {
+		return "cmd/compile/internal/ir.Node"
+	}
+
+	return s
 }
 
 // stringLit returns the unquoted string value and true if
diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
index 5dd30e619b..ca6f1c302e 100644
--- a/src/cmd/compile/fmtmap_test.go
+++ b/src/cmd/compile/fmtmap_test.go
@@ -20,191 +20,59 @@ package main_test
 // An absent entry means that the format is not recognized as valid.
 // An empty new format means that the format should remain unchanged.
 var knownFormats = map[string]string{
-	"*bytes.Buffer %s":                                "",
-	"*cmd/compile/internal/gc.EscLocation %v":         "",
-	"*cmd/compile/internal/ir.Func %+v":               "",
-	"*cmd/compile/internal/ir.Func %L":                "",
-	"*cmd/compile/internal/ir.Func %v":                "",
-	"*cmd/compile/internal/ir.Name %#v":               "",
-	"*cmd/compile/internal/ir.Name %+v":               "",
-	"*cmd/compile/internal/ir.Name %L":                "",
-	"*cmd/compile/internal/ir.Name %v":                "",
-	"*cmd/compile/internal/ir.SliceExpr %v":           "",
-	"*cmd/compile/internal/ssa.Block %s":              "",
-	"*cmd/compile/internal/ssa.Block %v":              "",
-	"*cmd/compile/internal/ssa.Func %s":               "",
-	"*cmd/compile/internal/ssa.Func %v":               "",
-	"*cmd/compile/internal/ssa.Register %s":           "",
-	"*cmd/compile/internal/ssa.Register %v":           "",
-	"*cmd/compile/internal/ssa.SparseTreeNode %v":     "",
-	"*cmd/compile/internal/ssa.Value %s":              "",
-	"*cmd/compile/internal/ssa.Value %v":              "",
-	"*cmd/compile/internal/ssa.sparseTreeMapEntry %v": "",
-	"*cmd/compile/internal/types.Field %p":            "",
-	"*cmd/compile/internal/types.Field %v":            "",
-	"*cmd/compile/internal/types.Sym %+v":             "",
-	"*cmd/compile/internal/types.Sym %S":              "",
-	"*cmd/compile/internal/types.Sym %p":              "",
-	"*cmd/compile/internal/types.Sym %v":              "",
-	"*cmd/compile/internal/types.Type %#L":            "",
-	"*cmd/compile/internal/types.Type %#v":            "",
-	"*cmd/compile/internal/types.Type %+v":            "",
-	"*cmd/compile/internal/types.Type %-S":            "",
-	"*cmd/compile/internal/types.Type %0S":            "",
-	"*cmd/compile/internal/types.Type %L":             "",
-	"*cmd/compile/internal/types.Type %S":             "",
-	"*cmd/compile/internal/types.Type %p":             "",
-	"*cmd/compile/internal/types.Type %s":             "",
-	"*cmd/compile/internal/types.Type %v":             "",
-	"*cmd/internal/obj.Addr %v":                       "",
-	"*cmd/internal/obj.LSym %v":                       "",
-	"*math/big.Float %f":                              "",
-	"*math/big.Int %s":                                "",
-	"[16]byte %x":                                     "",
-	"[]*cmd/compile/internal/ir.Name %v":              "",
-	"[]*cmd/compile/internal/ssa.Block %v":            "",
-	"[]*cmd/compile/internal/ssa.Value %v":            "",
-	"[][]string %q":                                   "",
-	"[]byte %s":                                       "",
-	"[]byte %x":                                       "",
-	"[]cmd/compile/internal/ssa.Edge %v":              "",
-	"[]cmd/compile/internal/ssa.ID %v":                "",
-	"[]cmd/compile/internal/ssa.posetNode %v":         "",
-	"[]cmd/compile/internal/ssa.posetUndo %v":         "",
-	"[]cmd/compile/internal/syntax.token %s":          "",
-	"[]string %v":                                     "",
-	"[]uint32 %v":                                     "",
-	"bool %v":                                         "",
-	"byte %08b":                                       "",
-	"byte %c":                                         "",
-	"byte %q":                                         "",
-	"byte %v":                                         "",
-	"cmd/compile/internal/arm.shift %d":               "",
-	"cmd/compile/internal/gc.initKind %d":             "",
-	"cmd/compile/internal/gc.itag %v":                 "",
-	"cmd/compile/internal/ir.Class %d":                "",
-	"cmd/compile/internal/ir.Class %v":                "",
-	"cmd/compile/internal/ir.Node %+v":                "",
-	"cmd/compile/internal/ir.Node %L":                 "",
-	"cmd/compile/internal/ir.Node %S":                 "",
-	"cmd/compile/internal/ir.Node %p":                 "",
-	"cmd/compile/internal/ir.Node %v":                 "",
-	"cmd/compile/internal/ir.Nodes %#v":               "",
-	"cmd/compile/internal/ir.Nodes %+v":               "",
-	"cmd/compile/internal/ir.Nodes %.v":               "",
-	"cmd/compile/internal/ir.Nodes %v":                "",
-	"cmd/compile/internal/ir.Ntype %v":                "",
-	"cmd/compile/internal/ir.Op %#v":                  "",
-	"cmd/compile/internal/ir.Op %+v":                  "",
-	"cmd/compile/internal/ir.Op %v":                   "",
-	"cmd/compile/internal/ssa.BranchPrediction %d":    "",
-	"cmd/compile/internal/ssa.Edge %v":                "",
-	"cmd/compile/internal/ssa.ID %d":                  "",
-	"cmd/compile/internal/ssa.ID %v":                  "",
-	"cmd/compile/internal/ssa.LocalSlot %s":           "",
-	"cmd/compile/internal/ssa.LocalSlot %v":           "",
-	"cmd/compile/internal/ssa.Location %s":            "",
-	"cmd/compile/internal/ssa.Op %s":                  "",
-	"cmd/compile/internal/ssa.Op %v":                  "",
-	"cmd/compile/internal/ssa.Sym %v":                 "",
-	"cmd/compile/internal/ssa.ValAndOff %s":           "",
-	"cmd/compile/internal/ssa.domain %v":              "",
-	"cmd/compile/internal/ssa.flagConstant %s":        "",
-	"cmd/compile/internal/ssa.posetNode %v":           "",
-	"cmd/compile/internal/ssa.posetTestOp %v":         "",
-	"cmd/compile/internal/ssa.rbrank %d":              "",
-	"cmd/compile/internal/ssa.regMask %d":             "",
-	"cmd/compile/internal/ssa.register %d":            "",
-	"cmd/compile/internal/ssa.relation %s":            "",
-	"cmd/compile/internal/syntax.Error %q":            "",
-	"cmd/compile/internal/syntax.Expr %#v":            "",
-	"cmd/compile/internal/syntax.LitKind %d":          "",
-	"cmd/compile/internal/syntax.Node %T":             "",
-	"cmd/compile/internal/syntax.Operator %s":         "",
-	"cmd/compile/internal/syntax.Pos %s":              "",
-	"cmd/compile/internal/syntax.Pos %v":              "",
-	"cmd/compile/internal/syntax.position %s":         "",
-	"cmd/compile/internal/syntax.token %q":            "",
-	"cmd/compile/internal/syntax.token %s":            "",
-	"cmd/compile/internal/types.Kind %d":              "",
-	"cmd/compile/internal/types.Kind %s":              "",
-	"cmd/compile/internal/types.Kind %v":              "",
-	"cmd/compile/internal/types.Object %v":            "",
-	"cmd/internal/obj.ABI %v":                         "",
-	"error %v":                                        "",
-	"float64 %.2f":                                    "",
-	"float64 %.3f":                                    "",
-	"float64 %g":                                      "",
-	"go/constant.Kind %v":                             "",
-	"go/constant.Value %#v":                           "",
-	"go/constant.Value %v":                            "",
-	"int %#x":                                         "",
-	"int %-12d":                                       "",
-	"int %-6d":                                        "",
-	"int %-8o":                                        "",
-	"int %02d":                                        "",
-	"int %6d":                                         "",
-	"int %c":                                          "",
-	"int %d":                                          "",
-	"int %v":                                          "",
-	"int %x":                                          "",
-	"int16 %d":                                        "",
-	"int16 %x":                                        "",
-	"int32 %#x":                                       "",
-	"int32 %d":                                        "",
-	"int32 %v":                                        "",
-	"int32 %x":                                        "",
-	"int64 %#x":                                       "",
-	"int64 %-10d":                                     "",
-	"int64 %.5d":                                      "",
-	"int64 %d":                                        "",
-	"int64 %v":                                        "",
-	"int64 %x":                                        "",
-	"int8 %d":                                         "",
-	"int8 %v":                                         "",
-	"int8 %x":                                         "",
-	"interface{} %#v":                                 "",
-	"interface{} %T":                                  "",
-	"interface{} %p":                                  "",
-	"interface{} %q":                                  "",
-	"interface{} %s":                                  "",
-	"interface{} %v":                                  "",
-	"map[cmd/compile/internal/ir.Node]*cmd/compile/internal/ssa.Value %v": "",
-	"map[cmd/compile/internal/ir.Node][]cmd/compile/internal/ir.Node %v":  "",
-	"map[cmd/compile/internal/ssa.ID]uint32 %v":                           "",
-	"map[int64]uint32 %v":  "",
-	"math/big.Accuracy %s": "",
-	"reflect.Type %s":      "",
-	"reflect.Type %v":      "",
-	"rune %#U":             "",
-	"rune %c":              "",
-	"rune %q":              "",
-	"string %-*s":          "",
-	"string %-16s":         "",
-	"string %-6s":          "",
-	"string %q":            "",
-	"string %s":            "",
-	"string %v":            "",
-	"time.Duration %d":     "",
-	"time.Duration %v":     "",
-	"uint %04x":            "",
-	"uint %5d":             "",
-	"uint %d":              "",
-	"uint %x":              "",
-	"uint16 %d":            "",
-	"uint16 %x":            "",
-	"uint32 %#U":           "",
-	"uint32 %#x":           "",
-	"uint32 %d":            "",
-	"uint32 %v":            "",
-	"uint32 %x":            "",
-	"uint64 %08x":          "",
-	"uint64 %b":            "",
-	"uint64 %d":            "",
-	"uint64 %x":            "",
-	"uint8 %#x":            "",
-	"uint8 %d":             "",
-	"uint8 %v":             "",
-	"uint8 %x":             "",
-	"uintptr %d":           "",
+	"*bytes.Buffer %s":                             "",
+	"*cmd/compile/internal/ssa.Block %s":           "",
+	"*cmd/compile/internal/ssa.Func %s":            "",
+	"*cmd/compile/internal/ssa.Register %s":        "",
+	"*cmd/compile/internal/ssa.Value %s":           "",
+	"*cmd/compile/internal/types.Sym %+v":          "",
+	"*cmd/compile/internal/types.Sym %S":           "",
+	"*cmd/compile/internal/types.Type %#L":         "",
+	"*cmd/compile/internal/types.Type %#v":         "",
+	"*cmd/compile/internal/types.Type %+v":         "",
+	"*cmd/compile/internal/types.Type %-S":         "",
+	"*cmd/compile/internal/types.Type %0S":         "",
+	"*cmd/compile/internal/types.Type %L":          "",
+	"*cmd/compile/internal/types.Type %S":          "",
+	"*cmd/compile/internal/types.Type %s":          "",
+	"*math/big.Float %f":                           "",
+	"*math/big.Int %s":                             "",
+	"[]cmd/compile/internal/syntax.token %s":       "",
+	"cmd/compile/internal/arm.shift %d":            "",
+	"cmd/compile/internal/gc.initKind %d":          "",
+	"cmd/compile/internal/ir.Class %d":             "",
+	"cmd/compile/internal/ir.Node %#v":             "",
+	"cmd/compile/internal/ir.Node %+v":             "",
+	"cmd/compile/internal/ir.Node %L":              "",
+	"cmd/compile/internal/ir.Node %S":              "",
+	"cmd/compile/internal/ir.Nodes %#v":            "",
+	"cmd/compile/internal/ir.Nodes %+v":            "",
+	"cmd/compile/internal/ir.Nodes %.v":            "",
+	"cmd/compile/internal/ir.Op %#v":               "",
+	"cmd/compile/internal/ir.Op %+v":               "",
+	"cmd/compile/internal/ssa.BranchPrediction %d": "",
+	"cmd/compile/internal/ssa.ID %d":               "",
+	"cmd/compile/internal/ssa.LocalSlot %s":        "",
+	"cmd/compile/internal/ssa.Location %s":         "",
+	"cmd/compile/internal/ssa.Op %s":               "",
+	"cmd/compile/internal/ssa.ValAndOff %s":        "",
+	"cmd/compile/internal/ssa.flagConstant %s":     "",
+	"cmd/compile/internal/ssa.rbrank %d":           "",
+	"cmd/compile/internal/ssa.regMask %d":          "",
+	"cmd/compile/internal/ssa.register %d":         "",
+	"cmd/compile/internal/ssa.relation %s":         "",
+	"cmd/compile/internal/syntax.Error %q":         "",
+	"cmd/compile/internal/syntax.Expr %#v":         "",
+	"cmd/compile/internal/syntax.LitKind %d":       "",
+	"cmd/compile/internal/syntax.Operator %s":      "",
+	"cmd/compile/internal/syntax.Pos %s":           "",
+	"cmd/compile/internal/syntax.position %s":      "",
+	"cmd/compile/internal/syntax.token %q":         "",
+	"cmd/compile/internal/syntax.token %s":         "",
+	"cmd/compile/internal/types.Kind %d":           "",
+	"cmd/compile/internal/types.Kind %s":           "",
+	"go/constant.Value %#v":                        "",
+	"math/big.Accuracy %s":                         "",
+	"reflect.Type %s":                              "",
+	"time.Duration %d":                             "",
 }
-- 
GitLab


From 724374f85985d6ce5e5a8a32b4b9aea22ead6dc3 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 6 Dec 2020 14:53:38 -0500
Subject: [PATCH 0180/2400] [dev.regabi] cmd/compile: rewrite stale format
 strings

On ir.Node, ir.Nodes, and ir.Op, # is ignored, so %#v is %v.
On ir.Node, %S is the same as %v.

On types.Type, # is ignored, so %#L is %L, %#v is %v.
On types.Type, 0 is ignored, so %0S is %S.

Rewrite all these using go test cmd/compile -r, plus a
few multiline formats mentioning %0S on types updated by hand.

Now the formats used in the compiler match the documentation
for the format methods, a minor miracle.

Passes buildall w/ toolstash -cmp.

Change-Id: I3d4a3fae543145a68da13eede91166632c5b1ceb
Reviewed-on: https://go-review.googlesource.com/c/go/+/275782
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/fmtmap_test.go           |  7 ------
 src/cmd/compile/internal/gc/closure.go   |  2 +-
 src/cmd/compile/internal/gc/escape.go    |  6 ++---
 src/cmd/compile/internal/gc/iimport.go   |  4 ++--
 src/cmd/compile/internal/gc/inl.go       |  6 ++---
 src/cmd/compile/internal/gc/pgen_test.go |  4 ++--
 src/cmd/compile/internal/gc/subr.go      |  4 ++--
 src/cmd/compile/internal/gc/typecheck.go |  6 ++---
 src/cmd/compile/internal/gc/unsafe.go    |  2 +-
 src/cmd/compile/internal/gc/walk.go      |  2 +-
 src/cmd/compile/internal/ir/fmt.go       | 28 ++++++++++--------------
 11 files changed, 29 insertions(+), 42 deletions(-)

diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
index ca6f1c302e..756320285c 100644
--- a/src/cmd/compile/fmtmap_test.go
+++ b/src/cmd/compile/fmtmap_test.go
@@ -27,11 +27,8 @@ var knownFormats = map[string]string{
 	"*cmd/compile/internal/ssa.Value %s":           "",
 	"*cmd/compile/internal/types.Sym %+v":          "",
 	"*cmd/compile/internal/types.Sym %S":           "",
-	"*cmd/compile/internal/types.Type %#L":         "",
-	"*cmd/compile/internal/types.Type %#v":         "",
 	"*cmd/compile/internal/types.Type %+v":         "",
 	"*cmd/compile/internal/types.Type %-S":         "",
-	"*cmd/compile/internal/types.Type %0S":         "",
 	"*cmd/compile/internal/types.Type %L":          "",
 	"*cmd/compile/internal/types.Type %S":          "",
 	"*cmd/compile/internal/types.Type %s":          "",
@@ -41,14 +38,10 @@ var knownFormats = map[string]string{
 	"cmd/compile/internal/arm.shift %d":            "",
 	"cmd/compile/internal/gc.initKind %d":          "",
 	"cmd/compile/internal/ir.Class %d":             "",
-	"cmd/compile/internal/ir.Node %#v":             "",
 	"cmd/compile/internal/ir.Node %+v":             "",
 	"cmd/compile/internal/ir.Node %L":              "",
-	"cmd/compile/internal/ir.Node %S":              "",
-	"cmd/compile/internal/ir.Nodes %#v":            "",
 	"cmd/compile/internal/ir.Nodes %+v":            "",
 	"cmd/compile/internal/ir.Nodes %.v":            "",
-	"cmd/compile/internal/ir.Op %#v":               "",
 	"cmd/compile/internal/ir.Op %+v":               "",
 	"cmd/compile/internal/ssa.BranchPrediction %d": "",
 	"cmd/compile/internal/ssa.ID %d":               "",
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index 01e5a953de..b56e255d10 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -100,7 +100,7 @@ func typecheckclosure(clo ir.Node, top int) {
 		if !n.Name().Captured() {
 			n.Name().SetCaptured(true)
 			if n.Name().Decldepth == 0 {
-				base.Fatalf("typecheckclosure: var %S does not have decldepth assigned", n)
+				base.Fatalf("typecheckclosure: var %v does not have decldepth assigned", n)
 			}
 
 			// Ignore assignments to the variable in straightline code
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index a7458ab733..f317e9999c 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -757,7 +757,7 @@ func (e *Escape) assign(dst, src ir.Node, why string, where ir.Node) {
 	// Filter out some no-op assignments for escape analysis.
 	ignore := dst != nil && src != nil && isSelfAssign(dst, src)
 	if ignore && base.Flag.LowerM != 0 {
-		base.WarnfAt(where.Pos(), "%v ignoring self-assignment in %S", funcSym(e.curfn), where)
+		base.WarnfAt(where.Pos(), "%v ignoring self-assignment in %v", funcSym(e.curfn), where)
 	}
 
 	k := e.addr(dst)
@@ -1454,7 +1454,7 @@ func (e *Escape) finish(fns []*ir.Func) {
 		if loc.escapes {
 			if n.Op() != ir.ONAME {
 				if base.Flag.LowerM != 0 {
-					base.WarnfAt(n.Pos(), "%S escapes to heap", n)
+					base.WarnfAt(n.Pos(), "%v escapes to heap", n)
 				}
 				if logopt.Enabled() {
 					logopt.LogOpt(n.Pos(), "escape", "escape", ir.FuncName(e.curfn))
@@ -1464,7 +1464,7 @@ func (e *Escape) finish(fns []*ir.Func) {
 			addrescapes(n)
 		} else {
 			if base.Flag.LowerM != 0 && n.Op() != ir.ONAME {
-				base.WarnfAt(n.Pos(), "%S does not escape", n)
+				base.WarnfAt(n.Pos(), "%v does not escape", n)
 			}
 			n.SetEsc(EscNone)
 			if loc.transient {
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 859263c83f..1f75393b3e 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -713,9 +713,9 @@ func (r *importReader) doInline(fn *ir.Func) {
 
 	if base.Flag.E > 0 && base.Flag.LowerM > 2 {
 		if base.Flag.LowerM > 3 {
-			fmt.Printf("inl body for %v %#v: %+v\n", fn, fn.Type(), ir.AsNodes(fn.Inl.Body))
+			fmt.Printf("inl body for %v %v: %+v\n", fn, fn.Type(), ir.AsNodes(fn.Inl.Body))
 		} else {
-			fmt.Printf("inl body for %v %#v: %v\n", fn, fn.Type(), ir.AsNodes(fn.Inl.Body))
+			fmt.Printf("inl body for %v %v: %v\n", fn, fn.Type(), ir.AsNodes(fn.Inl.Body))
 		}
 	}
 }
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 77fbf7c802..f965fa6325 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -90,7 +90,7 @@ func typecheckinl(fn *ir.Func) {
 	}
 
 	if base.Flag.LowerM > 2 || base.Debug.Export != 0 {
-		fmt.Printf("typecheck import [%v] %L { %#v }\n", fn.Sym(), fn, ir.AsNodes(fn.Inl.Body))
+		fmt.Printf("typecheck import [%v] %L { %v }\n", fn.Sym(), fn, ir.AsNodes(fn.Inl.Body))
 	}
 
 	savefn := Curfn
@@ -219,7 +219,7 @@ func caninl(fn *ir.Func) {
 	}
 
 	if base.Flag.LowerM > 1 {
-		fmt.Printf("%v: can inline %#v with cost %d as: %#v { %#v }\n", ir.Line(fn), n, inlineMaxBudget-visitor.budget, fn.Type(), ir.AsNodes(n.Func().Inl.Body))
+		fmt.Printf("%v: can inline %v with cost %d as: %v { %v }\n", ir.Line(fn), n, inlineMaxBudget-visitor.budget, fn.Type(), ir.AsNodes(n.Func().Inl.Body))
 	} else if base.Flag.LowerM != 0 {
 		fmt.Printf("%v: can inline %v\n", ir.Line(fn), n)
 	}
@@ -816,7 +816,7 @@ func mkinlcall(n ir.Node, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]bool,
 
 	// We have a function node, and it has an inlineable body.
 	if base.Flag.LowerM > 1 {
-		fmt.Printf("%v: inlining call to %v %#v { %#v }\n", ir.Line(n), fn.Sym(), fn.Type(), ir.AsNodes(fn.Inl.Body))
+		fmt.Printf("%v: inlining call to %v %v { %v }\n", ir.Line(n), fn.Sym(), fn.Type(), ir.AsNodes(fn.Inl.Body))
 	} else if base.Flag.LowerM != 0 {
 		fmt.Printf("%v: inlining call to %v\n", ir.Line(n), fn)
 	}
diff --git a/src/cmd/compile/internal/gc/pgen_test.go b/src/cmd/compile/internal/gc/pgen_test.go
index 473df82a0d..ad8b87c6f5 100644
--- a/src/cmd/compile/internal/gc/pgen_test.go
+++ b/src/cmd/compile/internal/gc/pgen_test.go
@@ -145,11 +145,11 @@ func TestCmpstackvar(t *testing.T) {
 	for _, d := range testdata {
 		got := cmpstackvarlt(d.a, d.b)
 		if got != d.lt {
-			t.Errorf("want %#v < %#v", d.a, d.b)
+			t.Errorf("want %v < %v", d.a, d.b)
 		}
 		// If we expect a < b to be true, check that b < a is false.
 		if d.lt && cmpstackvarlt(d.b, d.a) {
-			t.Errorf("unexpected %#v < %#v", d.b, d.a)
+			t.Errorf("unexpected %v < %v", d.b, d.a)
 		}
 	}
 }
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index dffebc58f2..e05a124b29 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -291,12 +291,12 @@ func assignop(src, dst *types.Type) (ir.Op, string) {
 			why = fmt.Sprintf(":\n\t%v does not implement %v (%v method is marked 'nointerface')", src, dst, missing.Sym)
 		} else if have != nil && have.Sym == missing.Sym {
 			why = fmt.Sprintf(":\n\t%v does not implement %v (wrong type for %v method)\n"+
-				"\t\thave %v%0S\n\t\twant %v%0S", src, dst, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
+				"\t\thave %v%S\n\t\twant %v%S", src, dst, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
 		} else if ptr != 0 {
 			why = fmt.Sprintf(":\n\t%v does not implement %v (%v method has pointer receiver)", src, dst, missing.Sym)
 		} else if have != nil {
 			why = fmt.Sprintf(":\n\t%v does not implement %v (missing %v method)\n"+
-				"\t\thave %v%0S\n\t\twant %v%0S", src, dst, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
+				"\t\thave %v%S\n\t\twant %v%S", src, dst, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
 		} else {
 			why = fmt.Sprintf(":\n\t%v does not implement %v (missing %v method)", src, dst, missing.Sym)
 		}
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 85094dbebc..a7c05c6c0f 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -58,7 +58,7 @@ func tracePrint(title string, n ir.Node) func(np *ir.Node) {
 
 		skipDowidthForTracing = true
 		defer func() { skipDowidthForTracing = false }()
-		fmt.Printf("%s: %s=> %p %s %v tc=%d type=%#L\n", pos, indent, n, op, n, tc, typ)
+		fmt.Printf("%s: %s=> %p %s %v tc=%d type=%L\n", pos, indent, n, op, n, tc, typ)
 	}
 }
 
@@ -1039,12 +1039,12 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			if !implements(n.Type(), t, &missing, &have, &ptr) {
 				if have != nil && have.Sym == missing.Sym {
 					base.Errorf("impossible type assertion:\n\t%v does not implement %v (wrong type for %v method)\n"+
-						"\t\thave %v%0S\n\t\twant %v%0S", n.Type(), t, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
+						"\t\thave %v%S\n\t\twant %v%S", n.Type(), t, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
 				} else if ptr != 0 {
 					base.Errorf("impossible type assertion:\n\t%v does not implement %v (%v method has pointer receiver)", n.Type(), t, missing.Sym)
 				} else if have != nil {
 					base.Errorf("impossible type assertion:\n\t%v does not implement %v (missing %v method)\n"+
-						"\t\thave %v%0S\n\t\twant %v%0S", n.Type(), t, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
+						"\t\thave %v%S\n\t\twant %v%S", n.Type(), t, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
 				} else {
 					base.Errorf("impossible type assertion:\n\t%v does not implement %v (missing %v method)", n.Type(), t, missing.Sym)
 				}
diff --git a/src/cmd/compile/internal/gc/unsafe.go b/src/cmd/compile/internal/gc/unsafe.go
index 678924b229..d7ae5d7aaa 100644
--- a/src/cmd/compile/internal/gc/unsafe.go
+++ b/src/cmd/compile/internal/gc/unsafe.go
@@ -70,7 +70,7 @@ func evalunsafe(n ir.Node) int64 {
 				v += r.Offset()
 			default:
 				ir.Dump("unsafenmagic", n.Left())
-				base.Fatalf("impossible %#v node after dot insertion", r.Op())
+				base.Fatalf("impossible %v node after dot insertion", r.Op())
 			}
 		}
 		return v
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 346817e589..4189d1a721 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -2154,7 +2154,7 @@ func reorder3(all []ir.Node) []ir.Node {
 
 		switch l.Op() {
 		default:
-			base.Fatalf("reorder3 unexpected lvalue %#v", l.Op())
+			base.Fatalf("reorder3 unexpected lvalue %v", l.Op())
 
 		case ir.ONAME:
 			break
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 85c6b218e2..68e425bdaa 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -125,12 +125,6 @@ func (o Op) Format(s fmt.State, verb rune) {
 //	%+v	Debug syntax, as in Dump.
 //
 func FmtNode(n Node, s fmt.State, verb rune) {
-	// TODO(rsc): Remove uses of %#v, which behaves just like %v.
-	// TODO(rsc): Remove uses of %S, which behaves just like %v.
-	if verb == 'S' {
-		verb = 'v'
-	}
-
 	// %+v prints Dump.
 	// Otherwise we print Go syntax.
 	if s.Flag('+') && verb == 'v' {
@@ -355,7 +349,7 @@ func stmtFmt(n Node, s fmt.State) {
 			break
 		}
 
-		fmt.Fprintf(s, "%v %#v= %v", n.Left(), n.SubOp(), n.Right())
+		fmt.Fprintf(s, "%v %v= %v", n.Left(), n.SubOp(), n.Right())
 
 	case OAS2, OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV:
 		if n.Colas() && !complexinit {
@@ -446,7 +440,7 @@ func stmtFmt(n Node, s fmt.State) {
 			break
 		}
 
-		fmt.Fprintf(s, "%#v", n.Op())
+		fmt.Fprintf(s, "%v", n.Op())
 		if simpleinit {
 			fmt.Fprintf(s, " %v;", n.Init().First())
 		}
@@ -466,9 +460,9 @@ func stmtFmt(n Node, s fmt.State) {
 
 	case OBREAK, OCONTINUE, OGOTO, OFALL:
 		if n.Sym() != nil {
-			fmt.Fprintf(s, "%#v %v", n.Op(), n.Sym())
+			fmt.Fprintf(s, "%v %v", n.Op(), n.Sym())
 		} else {
-			fmt.Fprintf(s, "%#v", n.Op())
+			fmt.Fprintf(s, "%v", n.Op())
 		}
 
 	case OLABEL:
@@ -754,9 +748,9 @@ func exprFmt(n Node, s fmt.State, prec int) {
 
 	case OCOMPLEX, OCOPY:
 		if n.Left() != nil {
-			fmt.Fprintf(s, "%#v(%v, %v)", n.Op(), n.Left(), n.Right())
+			fmt.Fprintf(s, "%v(%v, %v)", n.Op(), n.Left(), n.Right())
 		} else {
-			fmt.Fprintf(s, "%#v(%.v)", n.Op(), n.List())
+			fmt.Fprintf(s, "%v(%.v)", n.Op(), n.List())
 		}
 
 	case OCONV,
@@ -795,14 +789,14 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		OPRINT,
 		OPRINTN:
 		if n.Left() != nil {
-			fmt.Fprintf(s, "%#v(%v)", n.Op(), n.Left())
+			fmt.Fprintf(s, "%v(%v)", n.Op(), n.Left())
 			return
 		}
 		if n.IsDDD() {
-			fmt.Fprintf(s, "%#v(%.v...)", n.Op(), n.List())
+			fmt.Fprintf(s, "%v(%.v...)", n.Op(), n.List())
 			return
 		}
-		fmt.Fprintf(s, "%#v(%.v)", n.Op(), n.List())
+		fmt.Fprintf(s, "%v(%.v)", n.Op(), n.List())
 
 	case OCALL, OCALLFUNC, OCALLINTER, OCALLMETH, OGETG:
 		exprFmt(n.Left(), s, nprec)
@@ -832,7 +826,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 
 	case OPLUS, ONEG, OADDR, OBITNOT, ODEREF, ONOT, ORECV:
 		// Unary
-		fmt.Fprintf(s, "%#v", n.Op())
+		fmt.Fprintf(s, "%v", n.Op())
 		if n.Left() != nil && n.Left().Op() == n.Op() {
 			fmt.Fprint(s, " ")
 		}
@@ -860,7 +854,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		OSUB,
 		OXOR:
 		exprFmt(n.Left(), s, nprec)
-		fmt.Fprintf(s, " %#v ", n.Op())
+		fmt.Fprintf(s, " %v ", n.Op())
 		exprFmt(n.Right(), s, nprec+1)
 
 	case OADDSTR:
-- 
GitLab


From 2de0af3b1b09e11b71ec4c58bb406be7abf112b0 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 6 Dec 2020 15:49:58 -0500
Subject: [PATCH 0181/2400] [dev.regabi] cmd/compile: prepare mknode for rename
 of Func.body

The next CL will rename Func.body to Func.Body_.
At some point in the future we will rename it to Func.Body.
Make the generator not get confused.

Passes buildall w/ toolstash -cmp.

Change-Id: Iee3f4915889a8287377bf3304d5b9250a909477e
Reviewed-on: https://go-review.googlesource.com/c/go/+/275783
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/mknode.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ir/mknode.go b/src/cmd/compile/internal/ir/mknode.go
index 2c007f93f1..978b2de5a5 100644
--- a/src/cmd/compile/internal/ir/mknode.go
+++ b/src/cmd/compile/internal/ir/mknode.go
@@ -141,7 +141,7 @@ func forNodeFields(typName string, typ *types.Struct, f func(name string, is fun
 		}
 		switch typName {
 		case "Func":
-			if v.Name() != "body" {
+			if strings.ToLower(strings.TrimSuffix(v.Name(), "_")) != "body" {
 				continue
 			}
 		case "Name", "Pack":
-- 
GitLab


From 6d783e7440056ca24b57b52605def43d09d8b2a2 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 6 Dec 2020 15:36:58 -0500
Subject: [PATCH 0182/2400] [dev.regabi] cmd/compile: export all Node fields
 [generated]

The plan was always to export them once we remove the getters
and setters, but do it a bit early, with _ suffixes as needed, so that
the reflection-based ir.Dump can access the fields.

Passes buildall w/ toolstash -cmp.

[git-generate]
cd src/cmd/compile/internal/ir
rf '
	mv AddStringExpr.list AddStringExpr.List_
	mv BlockStmt.list BlockStmt.List_
	mv CallExpr.body CallExpr.Body_
	mv CaseStmt.list CaseStmt.List_
	mv CaseStmt.body CaseStmt.Body_
	mv ClosureExpr.fn ClosureExpr.Func_
	mv CompLitExpr.list CompLitExpr.List_
	mv ForStmt.body ForStmt.Body_
	mv Func.body Func.Body_
	mv IfStmt.body IfStmt.Body_
	mv InlinedCallExpr.body InlinedCallExpr.Body_
	mv RangeStmt.body RangeStmt.Body_
	mv SliceExpr.list SliceExpr.List_
	mv SliceHeaderExpr.lenCap SliceHeaderExpr.LenCap_
	mv TypeSwitchGuard.name TypeSwitchGuard.Name_
'
go generate

Change-Id: I06e65920cecbcc51bea2254f52fcd7d5c5d0dc90
Reviewed-on: https://go-review.googlesource.com/c/go/+/275784
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/expr.go     | 80 +++++++++++------------
 src/cmd/compile/internal/ir/func.go     | 12 ++--
 src/cmd/compile/internal/ir/node_gen.go | 86 ++++++++++++-------------
 src/cmd/compile/internal/ir/stmt.go     | 78 +++++++++++-----------
 4 files changed, 128 insertions(+), 128 deletions(-)

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 7165a06b25..a74e0712b9 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -91,20 +91,20 @@ func toNtype(x Node) Ntype {
 // An AddStringExpr is a string concatenation Expr[0] + Exprs[1] + ... + Expr[len(Expr)-1].
 type AddStringExpr struct {
 	miniExpr
-	list Nodes
+	List_ Nodes
 }
 
 func NewAddStringExpr(pos src.XPos, list []Node) *AddStringExpr {
 	n := &AddStringExpr{}
 	n.pos = pos
 	n.op = OADDSTR
-	n.list.Set(list)
+	n.List_.Set(list)
 	return n
 }
 
-func (n *AddStringExpr) List() Nodes     { return n.list }
-func (n *AddStringExpr) PtrList() *Nodes { return &n.list }
-func (n *AddStringExpr) SetList(x Nodes) { n.list = x }
+func (n *AddStringExpr) List() Nodes     { return n.List_ }
+func (n *AddStringExpr) PtrList() *Nodes { return &n.List_ }
+func (n *AddStringExpr) SetList(x Nodes) { n.List_ = x }
 
 // An AddrExpr is an address-of expression &X.
 // It may end up being a normal address-of or an allocation of a composite literal.
@@ -185,7 +185,7 @@ type CallExpr struct {
 	X        Node
 	Args     Nodes
 	Rargs    Nodes // TODO(rsc): Delete.
-	body     Nodes // TODO(rsc): Delete.
+	Body_    Nodes // TODO(rsc): Delete.
 	DDD      bool
 	Use      CallUse
 	noInline bool
@@ -216,9 +216,9 @@ func (n *CallExpr) IsDDD() bool        { return n.DDD }
 func (n *CallExpr) SetIsDDD(x bool)    { n.DDD = x }
 func (n *CallExpr) NoInline() bool     { return n.noInline }
 func (n *CallExpr) SetNoInline(x bool) { n.noInline = x }
-func (n *CallExpr) Body() Nodes        { return n.body }
-func (n *CallExpr) PtrBody() *Nodes    { return &n.body }
-func (n *CallExpr) SetBody(x Nodes)    { n.body = x }
+func (n *CallExpr) Body() Nodes        { return n.Body_ }
+func (n *CallExpr) PtrBody() *Nodes    { return &n.Body_ }
+func (n *CallExpr) SetBody(x Nodes)    { n.Body_ = x }
 
 func (n *CallExpr) SetOp(op Op) {
 	switch op {
@@ -255,17 +255,17 @@ func (n *CallPartExpr) SetLeft(x Node)  { n.X = x }
 // A ClosureExpr is a function literal expression.
 type ClosureExpr struct {
 	miniExpr
-	fn *Func
+	Func_ *Func
 }
 
 func NewClosureExpr(pos src.XPos, fn *Func) *ClosureExpr {
-	n := &ClosureExpr{fn: fn}
+	n := &ClosureExpr{Func_: fn}
 	n.op = OCLOSURE
 	n.pos = pos
 	return n
 }
 
-func (n *ClosureExpr) Func() *Func { return n.fn }
+func (n *ClosureExpr) Func() *Func { return n.Func_ }
 
 // A ClosureRead denotes reading a variable stored within a closure struct.
 type ClosureRead struct {
@@ -289,14 +289,14 @@ type CompLitExpr struct {
 	miniExpr
 	orig  Node
 	Ntype Ntype
-	list  Nodes // initialized values
+	List_ Nodes // initialized values
 }
 
 func NewCompLitExpr(pos src.XPos, typ Ntype, list []Node) *CompLitExpr {
 	n := &CompLitExpr{Ntype: typ}
 	n.pos = pos
 	n.op = OCOMPLIT
-	n.list.Set(list)
+	n.List_.Set(list)
 	n.orig = n
 	return n
 }
@@ -305,9 +305,9 @@ func (n *CompLitExpr) Orig() Node      { return n.orig }
 func (n *CompLitExpr) SetOrig(x Node)  { n.orig = x }
 func (n *CompLitExpr) Right() Node     { return n.Ntype }
 func (n *CompLitExpr) SetRight(x Node) { n.Ntype = toNtype(x) }
-func (n *CompLitExpr) List() Nodes     { return n.list }
-func (n *CompLitExpr) PtrList() *Nodes { return &n.list }
-func (n *CompLitExpr) SetList(x Nodes) { n.list = x }
+func (n *CompLitExpr) List() Nodes     { return n.List_ }
+func (n *CompLitExpr) PtrList() *Nodes { return &n.List_ }
+func (n *CompLitExpr) SetList(x Nodes) { n.List_ = x }
 
 func (n *CompLitExpr) SetOp(op Op) {
 	switch op {
@@ -436,7 +436,7 @@ func (n *KeyExpr) SetOp(op Op) {
 // An InlinedCallExpr is an inlined function call.
 type InlinedCallExpr struct {
 	miniExpr
-	body       Nodes
+	Body_      Nodes
 	ReturnVars Nodes
 }
 
@@ -444,14 +444,14 @@ func NewInlinedCallExpr(pos src.XPos, body, retvars []Node) *InlinedCallExpr {
 	n := &InlinedCallExpr{}
 	n.pos = pos
 	n.op = OINLCALL
-	n.body.Set(body)
+	n.Body_.Set(body)
 	n.ReturnVars.Set(retvars)
 	return n
 }
 
-func (n *InlinedCallExpr) Body() Nodes      { return n.body }
-func (n *InlinedCallExpr) PtrBody() *Nodes  { return &n.body }
-func (n *InlinedCallExpr) SetBody(x Nodes)  { n.body = x }
+func (n *InlinedCallExpr) Body() Nodes      { return n.Body_ }
+func (n *InlinedCallExpr) PtrBody() *Nodes  { return &n.Body_ }
+func (n *InlinedCallExpr) SetBody(x Nodes)  { n.Body_ = x }
 func (n *InlinedCallExpr) Rlist() Nodes     { return n.ReturnVars }
 func (n *InlinedCallExpr) PtrRlist() *Nodes { return &n.ReturnVars }
 func (n *InlinedCallExpr) SetRlist(x Nodes) { n.ReturnVars = x }
@@ -617,8 +617,8 @@ func (*SelectorExpr) CanBeNtype() {}
 // A SliceExpr is a slice expression X[Low:High] or X[Low:High:Max].
 type SliceExpr struct {
 	miniExpr
-	X    Node
-	list Nodes // TODO(rsc): Use separate Nodes
+	X     Node
+	List_ Nodes // TODO(rsc): Use separate Nodes
 }
 
 func NewSliceExpr(pos src.XPos, op Op, x Node) *SliceExpr {
@@ -630,9 +630,9 @@ func NewSliceExpr(pos src.XPos, op Op, x Node) *SliceExpr {
 
 func (n *SliceExpr) Left() Node      { return n.X }
 func (n *SliceExpr) SetLeft(x Node)  { n.X = x }
-func (n *SliceExpr) List() Nodes     { return n.list }
-func (n *SliceExpr) PtrList() *Nodes { return &n.list }
-func (n *SliceExpr) SetList(x Nodes) { n.list = x }
+func (n *SliceExpr) List() Nodes     { return n.List_ }
+func (n *SliceExpr) PtrList() *Nodes { return &n.List_ }
+func (n *SliceExpr) SetList(x Nodes) { n.List_ = x }
 
 func (n *SliceExpr) SetOp(op Op) {
 	switch op {
@@ -646,16 +646,16 @@ func (n *SliceExpr) SetOp(op Op) {
 // SliceBounds returns n's slice bounds: low, high, and max in expr[low:high:max].
 // n must be a slice expression. max is nil if n is a simple slice expression.
 func (n *SliceExpr) SliceBounds() (low, high, max Node) {
-	if n.list.Len() == 0 {
+	if n.List_.Len() == 0 {
 		return nil, nil, nil
 	}
 
 	switch n.Op() {
 	case OSLICE, OSLICEARR, OSLICESTR:
-		s := n.list.Slice()
+		s := n.List_.Slice()
 		return s[0], s[1], nil
 	case OSLICE3, OSLICE3ARR:
-		s := n.list.Slice()
+		s := n.List_.Slice()
 		return s[0], s[1], s[2]
 	}
 	base.Fatalf("SliceBounds op %v: %v", n.Op(), n)
@@ -670,24 +670,24 @@ func (n *SliceExpr) SetSliceBounds(low, high, max Node) {
 		if max != nil {
 			base.Fatalf("SetSliceBounds %v given three bounds", n.Op())
 		}
-		s := n.list.Slice()
+		s := n.List_.Slice()
 		if s == nil {
 			if low == nil && high == nil {
 				return
 			}
-			n.list.Set2(low, high)
+			n.List_.Set2(low, high)
 			return
 		}
 		s[0] = low
 		s[1] = high
 		return
 	case OSLICE3, OSLICE3ARR:
-		s := n.list.Slice()
+		s := n.List_.Slice()
 		if s == nil {
 			if low == nil && high == nil && max == nil {
 				return
 			}
-			n.list.Set3(low, high, max)
+			n.List_.Set3(low, high, max)
 			return
 		}
 		s[0] = low
@@ -714,8 +714,8 @@ func (o Op) IsSlice3() bool {
 // A SliceHeader expression constructs a slice header from its parts.
 type SliceHeaderExpr struct {
 	miniExpr
-	Ptr    Node
-	lenCap Nodes // TODO(rsc): Split into two Node fields
+	Ptr     Node
+	LenCap_ Nodes // TODO(rsc): Split into two Node fields
 }
 
 func NewSliceHeaderExpr(pos src.XPos, typ *types.Type, ptr, len, cap Node) *SliceHeaderExpr {
@@ -723,15 +723,15 @@ func NewSliceHeaderExpr(pos src.XPos, typ *types.Type, ptr, len, cap Node) *Slic
 	n.pos = pos
 	n.op = OSLICEHEADER
 	n.typ = typ
-	n.lenCap.Set2(len, cap)
+	n.LenCap_.Set2(len, cap)
 	return n
 }
 
 func (n *SliceHeaderExpr) Left() Node      { return n.Ptr }
 func (n *SliceHeaderExpr) SetLeft(x Node)  { n.Ptr = x }
-func (n *SliceHeaderExpr) List() Nodes     { return n.lenCap }
-func (n *SliceHeaderExpr) PtrList() *Nodes { return &n.lenCap }
-func (n *SliceHeaderExpr) SetList(x Nodes) { n.lenCap = x }
+func (n *SliceHeaderExpr) List() Nodes     { return n.LenCap_ }
+func (n *SliceHeaderExpr) PtrList() *Nodes { return &n.LenCap_ }
+func (n *SliceHeaderExpr) SetList(x Nodes) { n.LenCap_ = x }
 
 // A StarExpr is a dereference expression *X.
 // It may end up being a value or a type.
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 3bca25b504..8aa6daed6f 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -49,9 +49,9 @@ import (
 // pointer from the Func back to the OCALLPART.
 type Func struct {
 	miniNode
-	typ  *types.Type
-	body Nodes
-	iota int64
+	typ   *types.Type
+	Body_ Nodes
+	iota  int64
 
 	Nname    *Name        // ONAME node
 	OClosure *ClosureExpr // OCLOSURE node
@@ -117,9 +117,9 @@ func NewFunc(pos src.XPos) *Func {
 func (f *Func) isStmt() {}
 
 func (f *Func) Func() *Func           { return f }
-func (f *Func) Body() Nodes           { return f.body }
-func (f *Func) PtrBody() *Nodes       { return &f.body }
-func (f *Func) SetBody(x Nodes)       { f.body = x }
+func (f *Func) Body() Nodes           { return f.Body_ }
+func (f *Func) PtrBody() *Nodes       { return &f.Body_ }
+func (f *Func) SetBody(x Nodes)       { f.Body_ = x }
 func (f *Func) Type() *types.Type     { return f.typ }
 func (f *Func) SetType(x *types.Type) { f.typ = x }
 func (f *Func) Iota() int64           { return f.iota }
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index 4c47a4486e..b3fd89c367 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -9,18 +9,18 @@ func (n *AddStringExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *AddStringExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
-	c.list = c.list.Copy()
+	c.List_ = c.List_.Copy()
 	return &c
 }
 func (n *AddStringExpr) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
-	err = maybeDoList(n.list, err, do)
+	err = maybeDoList(n.List_, err, do)
 	return err
 }
 func (n *AddStringExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
-	editList(n.list, edit)
+	editList(n.List_, edit)
 }
 
 func (n *AddrExpr) String() string                { return fmt.Sprint(n) }
@@ -147,18 +147,18 @@ func (n *BlockStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *BlockStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
-	c.list = c.list.Copy()
+	c.List_ = c.List_.Copy()
 	return &c
 }
 func (n *BlockStmt) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
-	err = maybeDoList(n.list, err, do)
+	err = maybeDoList(n.List_, err, do)
 	return err
 }
 func (n *BlockStmt) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
-	editList(n.list, edit)
+	editList(n.List_, edit)
 }
 
 func (n *BranchStmt) String() string                { return fmt.Sprint(n) }
@@ -184,7 +184,7 @@ func (n *CallExpr) copy() Node {
 	c.init = c.init.Copy()
 	c.Args = c.Args.Copy()
 	c.Rargs = c.Rargs.Copy()
-	c.body = c.body.Copy()
+	c.Body_ = c.Body_.Copy()
 	return &c
 }
 func (n *CallExpr) doChildren(do func(Node) error) error {
@@ -193,7 +193,7 @@ func (n *CallExpr) doChildren(do func(Node) error) error {
 	err = maybeDo(n.X, err, do)
 	err = maybeDoList(n.Args, err, do)
 	err = maybeDoList(n.Rargs, err, do)
-	err = maybeDoList(n.body, err, do)
+	err = maybeDoList(n.Body_, err, do)
 	return err
 }
 func (n *CallExpr) editChildren(edit func(Node) Node) {
@@ -201,7 +201,7 @@ func (n *CallExpr) editChildren(edit func(Node) Node) {
 	n.X = maybeEdit(n.X, edit)
 	editList(n.Args, edit)
 	editList(n.Rargs, edit)
-	editList(n.body, edit)
+	editList(n.Body_, edit)
 }
 
 func (n *CallPartExpr) String() string                { return fmt.Sprint(n) }
@@ -228,25 +228,25 @@ func (n *CaseStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
 	c.Vars = c.Vars.Copy()
-	c.list = c.list.Copy()
-	c.body = c.body.Copy()
+	c.List_ = c.List_.Copy()
+	c.Body_ = c.Body_.Copy()
 	return &c
 }
 func (n *CaseStmt) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
 	err = maybeDoList(n.Vars, err, do)
-	err = maybeDoList(n.list, err, do)
+	err = maybeDoList(n.List_, err, do)
 	err = maybeDo(n.Comm, err, do)
-	err = maybeDoList(n.body, err, do)
+	err = maybeDoList(n.Body_, err, do)
 	return err
 }
 func (n *CaseStmt) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	editList(n.Vars, edit)
-	editList(n.list, edit)
+	editList(n.List_, edit)
 	n.Comm = maybeEdit(n.Comm, edit)
-	editList(n.body, edit)
+	editList(n.Body_, edit)
 }
 
 func (n *ChanType) String() string                { return fmt.Sprint(n) }
@@ -301,20 +301,20 @@ func (n *CompLitExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *CompLitExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
-	c.list = c.list.Copy()
+	c.List_ = c.List_.Copy()
 	return &c
 }
 func (n *CompLitExpr) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
 	err = maybeDo(n.Ntype, err, do)
-	err = maybeDoList(n.list, err, do)
+	err = maybeDoList(n.List_, err, do)
 	return err
 }
 func (n *CompLitExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	n.Ntype = toNtype(maybeEdit(n.Ntype, edit))
-	editList(n.list, edit)
+	editList(n.List_, edit)
 }
 
 func (n *ConstExpr) String() string                { return fmt.Sprint(n) }
@@ -390,7 +390,7 @@ func (n *ForStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
 	c.Late = c.Late.Copy()
-	c.body = c.body.Copy()
+	c.Body_ = c.Body_.Copy()
 	return &c
 }
 func (n *ForStmt) doChildren(do func(Node) error) error {
@@ -399,7 +399,7 @@ func (n *ForStmt) doChildren(do func(Node) error) error {
 	err = maybeDo(n.Cond, err, do)
 	err = maybeDoList(n.Late, err, do)
 	err = maybeDo(n.Post, err, do)
-	err = maybeDoList(n.body, err, do)
+	err = maybeDoList(n.Body_, err, do)
 	return err
 }
 func (n *ForStmt) editChildren(edit func(Node) Node) {
@@ -407,23 +407,23 @@ func (n *ForStmt) editChildren(edit func(Node) Node) {
 	n.Cond = maybeEdit(n.Cond, edit)
 	editList(n.Late, edit)
 	n.Post = maybeEdit(n.Post, edit)
-	editList(n.body, edit)
+	editList(n.Body_, edit)
 }
 
 func (n *Func) String() string                { return fmt.Sprint(n) }
 func (n *Func) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *Func) copy() Node {
 	c := *n
-	c.body = c.body.Copy()
+	c.Body_ = c.Body_.Copy()
 	return &c
 }
 func (n *Func) doChildren(do func(Node) error) error {
 	var err error
-	err = maybeDoList(n.body, err, do)
+	err = maybeDoList(n.Body_, err, do)
 	return err
 }
 func (n *Func) editChildren(edit func(Node) Node) {
-	editList(n.body, edit)
+	editList(n.Body_, edit)
 }
 
 func (n *FuncType) String() string                { return fmt.Sprint(n) }
@@ -473,7 +473,7 @@ func (n *IfStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *IfStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
-	c.body = c.body.Copy()
+	c.Body_ = c.Body_.Copy()
 	c.Else = c.Else.Copy()
 	return &c
 }
@@ -481,14 +481,14 @@ func (n *IfStmt) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
 	err = maybeDo(n.Cond, err, do)
-	err = maybeDoList(n.body, err, do)
+	err = maybeDoList(n.Body_, err, do)
 	err = maybeDoList(n.Else, err, do)
 	return err
 }
 func (n *IfStmt) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	n.Cond = maybeEdit(n.Cond, edit)
-	editList(n.body, edit)
+	editList(n.Body_, edit)
 	editList(n.Else, edit)
 }
 
@@ -533,20 +533,20 @@ func (n *InlinedCallExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *InlinedCallExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
-	c.body = c.body.Copy()
+	c.Body_ = c.Body_.Copy()
 	c.ReturnVars = c.ReturnVars.Copy()
 	return &c
 }
 func (n *InlinedCallExpr) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
-	err = maybeDoList(n.body, err, do)
+	err = maybeDoList(n.Body_, err, do)
 	err = maybeDoList(n.ReturnVars, err, do)
 	return err
 }
 func (n *InlinedCallExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
-	editList(n.body, edit)
+	editList(n.Body_, edit)
 	editList(n.ReturnVars, edit)
 }
 
@@ -725,7 +725,7 @@ func (n *RangeStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
 	c.Vars = c.Vars.Copy()
-	c.body = c.body.Copy()
+	c.Body_ = c.Body_.Copy()
 	return &c
 }
 func (n *RangeStmt) doChildren(do func(Node) error) error {
@@ -733,14 +733,14 @@ func (n *RangeStmt) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.init, err, do)
 	err = maybeDoList(n.Vars, err, do)
 	err = maybeDo(n.X, err, do)
-	err = maybeDoList(n.body, err, do)
+	err = maybeDoList(n.Body_, err, do)
 	return err
 }
 func (n *RangeStmt) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	editList(n.Vars, edit)
 	n.X = maybeEdit(n.X, edit)
-	editList(n.body, edit)
+	editList(n.Body_, edit)
 }
 
 func (n *ResultExpr) String() string                { return fmt.Sprint(n) }
@@ -843,20 +843,20 @@ func (n *SliceExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *SliceExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
-	c.list = c.list.Copy()
+	c.List_ = c.List_.Copy()
 	return &c
 }
 func (n *SliceExpr) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
 	err = maybeDo(n.X, err, do)
-	err = maybeDoList(n.list, err, do)
+	err = maybeDoList(n.List_, err, do)
 	return err
 }
 func (n *SliceExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	n.X = maybeEdit(n.X, edit)
-	editList(n.list, edit)
+	editList(n.List_, edit)
 }
 
 func (n *SliceHeaderExpr) String() string                { return fmt.Sprint(n) }
@@ -864,20 +864,20 @@ func (n *SliceHeaderExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *SliceHeaderExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
-	c.lenCap = c.lenCap.Copy()
+	c.LenCap_ = c.LenCap_.Copy()
 	return &c
 }
 func (n *SliceHeaderExpr) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
 	err = maybeDo(n.Ptr, err, do)
-	err = maybeDoList(n.lenCap, err, do)
+	err = maybeDoList(n.LenCap_, err, do)
 	return err
 }
 func (n *SliceHeaderExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	n.Ptr = maybeEdit(n.Ptr, edit)
-	editList(n.lenCap, edit)
+	editList(n.LenCap_, edit)
 }
 
 func (n *SliceType) String() string                { return fmt.Sprint(n) }
@@ -984,15 +984,15 @@ func (n *TypeSwitchGuard) copy() Node {
 }
 func (n *TypeSwitchGuard) doChildren(do func(Node) error) error {
 	var err error
-	if n.name != nil {
-		err = maybeDo(n.name, err, do)
+	if n.Name_ != nil {
+		err = maybeDo(n.Name_, err, do)
 	}
 	err = maybeDo(n.X, err, do)
 	return err
 }
 func (n *TypeSwitchGuard) editChildren(edit func(Node) Node) {
-	if n.name != nil {
-		n.name = edit(n.name).(*Name)
+	if n.Name_ != nil {
+		n.Name_ = edit(n.Name_).(*Name)
 	}
 	n.X = maybeEdit(n.X, edit)
 }
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index 836bbcb453..ccf46dfa73 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -161,20 +161,20 @@ func (n *AssignOpStmt) SetType(x *types.Type) { n.typ = x }
 // A BlockStmt is a block: { List }.
 type BlockStmt struct {
 	miniStmt
-	list Nodes
+	List_ Nodes
 }
 
 func NewBlockStmt(pos src.XPos, list []Node) *BlockStmt {
 	n := &BlockStmt{}
 	n.pos = pos
 	n.op = OBLOCK
-	n.list.Set(list)
+	n.List_.Set(list)
 	return n
 }
 
-func (n *BlockStmt) List() Nodes     { return n.list }
-func (n *BlockStmt) PtrList() *Nodes { return &n.list }
-func (n *BlockStmt) SetList(x Nodes) { n.list = x }
+func (n *BlockStmt) List() Nodes     { return n.List_ }
+func (n *BlockStmt) PtrList() *Nodes { return &n.List_ }
+func (n *BlockStmt) SetList(x Nodes) { n.List_ = x }
 
 // A BranchStmt is a break, continue, fallthrough, or goto statement.
 //
@@ -204,27 +204,27 @@ func (n *BranchStmt) SetSym(sym *types.Sym) { n.Label = sym }
 // A CaseStmt is a case statement in a switch or select: case List: Body.
 type CaseStmt struct {
 	miniStmt
-	Vars Nodes // declared variable for this case in type switch
-	list Nodes // list of expressions for switch, early select
-	Comm Node  // communication case (Exprs[0]) after select is type-checked
-	body Nodes
+	Vars  Nodes // declared variable for this case in type switch
+	List_ Nodes // list of expressions for switch, early select
+	Comm  Node  // communication case (Exprs[0]) after select is type-checked
+	Body_ Nodes
 }
 
 func NewCaseStmt(pos src.XPos, list, body []Node) *CaseStmt {
 	n := &CaseStmt{}
 	n.pos = pos
 	n.op = OCASE
-	n.list.Set(list)
-	n.body.Set(body)
+	n.List_.Set(list)
+	n.Body_.Set(body)
 	return n
 }
 
-func (n *CaseStmt) List() Nodes      { return n.list }
-func (n *CaseStmt) PtrList() *Nodes  { return &n.list }
-func (n *CaseStmt) SetList(x Nodes)  { n.list = x }
-func (n *CaseStmt) Body() Nodes      { return n.body }
-func (n *CaseStmt) PtrBody() *Nodes  { return &n.body }
-func (n *CaseStmt) SetBody(x Nodes)  { n.body = x }
+func (n *CaseStmt) List() Nodes      { return n.List_ }
+func (n *CaseStmt) PtrList() *Nodes  { return &n.List_ }
+func (n *CaseStmt) SetList(x Nodes)  { n.List_ = x }
+func (n *CaseStmt) Body() Nodes      { return n.Body_ }
+func (n *CaseStmt) PtrBody() *Nodes  { return &n.Body_ }
+func (n *CaseStmt) SetBody(x Nodes)  { n.Body_ = x }
 func (n *CaseStmt) Rlist() Nodes     { return n.Vars }
 func (n *CaseStmt) PtrRlist() *Nodes { return &n.Vars }
 func (n *CaseStmt) SetRlist(x Nodes) { n.Vars = x }
@@ -255,7 +255,7 @@ type ForStmt struct {
 	Cond     Node
 	Late     Nodes
 	Post     Node
-	body     Nodes
+	Body_    Nodes
 	hasBreak bool
 }
 
@@ -264,7 +264,7 @@ func NewForStmt(pos src.XPos, init []Node, cond, post Node, body []Node) *ForStm
 	n.pos = pos
 	n.op = OFOR
 	n.init.Set(init)
-	n.body.Set(body)
+	n.Body_.Set(body)
 	return n
 }
 
@@ -274,9 +274,9 @@ func (n *ForStmt) Left() Node          { return n.Cond }
 func (n *ForStmt) SetLeft(x Node)      { n.Cond = x }
 func (n *ForStmt) Right() Node         { return n.Post }
 func (n *ForStmt) SetRight(x Node)     { n.Post = x }
-func (n *ForStmt) Body() Nodes         { return n.body }
-func (n *ForStmt) PtrBody() *Nodes     { return &n.body }
-func (n *ForStmt) SetBody(x Nodes)     { n.body = x }
+func (n *ForStmt) Body() Nodes         { return n.Body_ }
+func (n *ForStmt) PtrBody() *Nodes     { return &n.Body_ }
+func (n *ForStmt) SetBody(x Nodes)     { n.Body_ = x }
 func (n *ForStmt) List() Nodes         { return n.Late }
 func (n *ForStmt) PtrList() *Nodes     { return &n.Late }
 func (n *ForStmt) SetList(x Nodes)     { n.Late = x }
@@ -310,7 +310,7 @@ func (n *GoStmt) SetLeft(x Node) { n.Call = x }
 type IfStmt struct {
 	miniStmt
 	Cond   Node
-	body   Nodes
+	Body_  Nodes
 	Else   Nodes
 	likely bool // code layout hint
 }
@@ -319,16 +319,16 @@ func NewIfStmt(pos src.XPos, cond Node, body, els []Node) *IfStmt {
 	n := &IfStmt{Cond: cond}
 	n.pos = pos
 	n.op = OIF
-	n.body.Set(body)
+	n.Body_.Set(body)
 	n.Else.Set(els)
 	return n
 }
 
 func (n *IfStmt) Left() Node       { return n.Cond }
 func (n *IfStmt) SetLeft(x Node)   { n.Cond = x }
-func (n *IfStmt) Body() Nodes      { return n.body }
-func (n *IfStmt) PtrBody() *Nodes  { return &n.body }
-func (n *IfStmt) SetBody(x Nodes)  { n.body = x }
+func (n *IfStmt) Body() Nodes      { return n.Body_ }
+func (n *IfStmt) PtrBody() *Nodes  { return &n.Body_ }
+func (n *IfStmt) SetBody(x Nodes)  { n.Body_ = x }
 func (n *IfStmt) Rlist() Nodes     { return n.Else }
 func (n *IfStmt) PtrRlist() *Nodes { return &n.Else }
 func (n *IfStmt) SetRlist(x Nodes) { n.Else = x }
@@ -375,7 +375,7 @@ type RangeStmt struct {
 	Vars     Nodes // TODO(rsc): Replace with Key, Value Node
 	Def      bool
 	X        Node
-	body     Nodes
+	Body_    Nodes
 	hasBreak bool
 	typ      *types.Type // TODO(rsc): Remove - use X.Type() instead
 }
@@ -385,7 +385,7 @@ func NewRangeStmt(pos src.XPos, vars []Node, x Node, body []Node) *RangeStmt {
 	n.pos = pos
 	n.op = ORANGE
 	n.Vars.Set(vars)
-	n.body.Set(body)
+	n.Body_.Set(body)
 	return n
 }
 
@@ -393,9 +393,9 @@ func (n *RangeStmt) Sym() *types.Sym       { return n.Label }
 func (n *RangeStmt) SetSym(x *types.Sym)   { n.Label = x }
 func (n *RangeStmt) Right() Node           { return n.X }
 func (n *RangeStmt) SetRight(x Node)       { n.X = x }
-func (n *RangeStmt) Body() Nodes           { return n.body }
-func (n *RangeStmt) PtrBody() *Nodes       { return &n.body }
-func (n *RangeStmt) SetBody(x Nodes)       { n.body = x }
+func (n *RangeStmt) Body() Nodes           { return n.Body_ }
+func (n *RangeStmt) PtrBody() *Nodes       { return &n.Body_ }
+func (n *RangeStmt) SetBody(x Nodes)       { n.Body_ = x }
 func (n *RangeStmt) List() Nodes           { return n.Vars }
 func (n *RangeStmt) PtrList() *Nodes       { return &n.Vars }
 func (n *RangeStmt) SetList(x Nodes)       { n.Vars = x }
@@ -514,14 +514,14 @@ func (n *SwitchStmt) SetHasBreak(x bool)  { n.hasBreak = x }
 // A TypeSwitchGuard is the [Name :=] X.(type) in a type switch.
 type TypeSwitchGuard struct {
 	miniNode
-	name *Name
-	X    Node
+	Name_ *Name
+	X     Node
 }
 
 func NewTypeSwitchGuard(pos src.XPos, name, x Node) *TypeSwitchGuard {
 	n := &TypeSwitchGuard{X: x}
 	if name != nil {
-		n.name = name.(*Name)
+		n.Name_ = name.(*Name)
 	}
 	n.pos = pos
 	n.op = OTYPESW
@@ -529,17 +529,17 @@ func NewTypeSwitchGuard(pos src.XPos, name, x Node) *TypeSwitchGuard {
 }
 
 func (n *TypeSwitchGuard) Left() Node {
-	if n.name == nil {
+	if n.Name_ == nil {
 		return nil
 	}
-	return n.name
+	return n.Name_
 }
 func (n *TypeSwitchGuard) SetLeft(x Node) {
 	if x == nil {
-		n.name = nil
+		n.Name_ = nil
 		return
 	}
-	n.name = x.(*Name)
+	n.Name_ = x.(*Name)
 }
 func (n *TypeSwitchGuard) Right() Node     { return n.X }
 func (n *TypeSwitchGuard) SetRight(x Node) { n.X = x }
-- 
GitLab


From 63722da46bbf320670e8f993490fe1431feeeb04 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Sat, 5 Dec 2020 17:24:48 -0800
Subject: [PATCH 0183/2400] [dev.regabi] cmd/compile: fix comment

Russ, is this what you meant?

Change-Id: I27d2847811c6eabd94358e435eb3eb4bc8cfaa9e
Reviewed-on: https://go-review.googlesource.com/c/go/+/275712
Trust: Keith Randall <khr@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/gc/typecheck.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index a7c05c6c0f..990921189a 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -3361,7 +3361,7 @@ out:
 
 // type check function definition
 // To be called by typecheck, not directly.
-// (Call typecheckfn instead.)
+// (Call typecheckFunc instead.)
 func typecheckfunc(n *ir.Func) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckfunc", n)(nil)
-- 
GitLab


From 1a98ab0e2dad7029d9db18fc1fae0b7e4fa4970c Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 7 Dec 2020 17:15:44 -0800
Subject: [PATCH 0184/2400] [dev.regabi] cmd/compile: add ssa.Aux tag interface
 for Value.Aux

It's currently hard to automate refactorings around the Value.Aux
field, because we don't have any static typing information for it.
Adding a tag interface will make subsequent CLs easier and safer.

Passes buildall w/ toolstash -cmp.

Updates #42982.

Change-Id: I41ae8e411a66bda3195a0957b60c2fe8a8002893
Reviewed-on: https://go-review.googlesource.com/c/go/+/275756
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/fmtmap_test.go                |  3 ++
 src/cmd/compile/internal/gc/ssa.go            | 22 +++++-----
 src/cmd/compile/internal/ir/mini.go           |  3 +-
 src/cmd/compile/internal/ir/node.go           |  1 +
 src/cmd/compile/internal/ssa/block.go         |  2 +-
 src/cmd/compile/internal/ssa/check.go         |  2 +-
 src/cmd/compile/internal/ssa/cse.go           |  2 +-
 src/cmd/compile/internal/ssa/cse_test.go      |  2 +
 src/cmd/compile/internal/ssa/debug.go         |  4 +-
 src/cmd/compile/internal/ssa/func.go          | 22 ++++------
 src/cmd/compile/internal/ssa/func_test.go     |  8 ++--
 src/cmd/compile/internal/ssa/nilcheck_test.go |  2 +-
 src/cmd/compile/internal/ssa/op.go            |  3 ++
 src/cmd/compile/internal/ssa/rewrite.go       | 42 ++++++++++++-------
 src/cmd/compile/internal/ssa/value.go         |  5 ++-
 src/cmd/compile/internal/ssa/zcse.go          |  2 +-
 src/cmd/compile/internal/types/type.go        |  2 +
 src/cmd/internal/obj/link.go                  |  4 +-
 src/cmd/internal/obj/s390x/condition_code.go  |  2 +
 src/cmd/internal/obj/s390x/rotate.go          |  2 +
 20 files changed, 79 insertions(+), 56 deletions(-)

diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
index 756320285c..e62b9613e1 100644
--- a/src/cmd/compile/fmtmap_test.go
+++ b/src/cmd/compile/fmtmap_test.go
@@ -43,6 +43,9 @@ var knownFormats = map[string]string{
 	"cmd/compile/internal/ir.Nodes %+v":            "",
 	"cmd/compile/internal/ir.Nodes %.v":            "",
 	"cmd/compile/internal/ir.Op %+v":               "",
+	"cmd/compile/internal/ssa.Aux %#v":             "",
+	"cmd/compile/internal/ssa.Aux %q":              "",
+	"cmd/compile/internal/ssa.Aux %s":              "",
 	"cmd/compile/internal/ssa.BranchPrediction %d": "",
 	"cmd/compile/internal/ssa.ID %d":               "",
 	"cmd/compile/internal/ssa.LocalSlot %s":        "",
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index add50c35d7..95650328b1 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -772,7 +772,7 @@ func (s *state) newValue0(op ssa.Op, t *types.Type) *ssa.Value {
 }
 
 // newValue0A adds a new value with no arguments and an aux value to the current block.
-func (s *state) newValue0A(op ssa.Op, t *types.Type, aux interface{}) *ssa.Value {
+func (s *state) newValue0A(op ssa.Op, t *types.Type, aux ssa.Aux) *ssa.Value {
 	return s.curBlock.NewValue0A(s.peekPos(), op, t, aux)
 }
 
@@ -787,14 +787,14 @@ func (s *state) newValue1(op ssa.Op, t *types.Type, arg *ssa.Value) *ssa.Value {
 }
 
 // newValue1A adds a new value with one argument and an aux value to the current block.
-func (s *state) newValue1A(op ssa.Op, t *types.Type, aux interface{}, arg *ssa.Value) *ssa.Value {
+func (s *state) newValue1A(op ssa.Op, t *types.Type, aux ssa.Aux, arg *ssa.Value) *ssa.Value {
 	return s.curBlock.NewValue1A(s.peekPos(), op, t, aux, arg)
 }
 
 // newValue1Apos adds a new value with one argument and an aux value to the current block.
 // isStmt determines whether the created values may be a statement or not
 // (i.e., false means never, yes means maybe).
-func (s *state) newValue1Apos(op ssa.Op, t *types.Type, aux interface{}, arg *ssa.Value, isStmt bool) *ssa.Value {
+func (s *state) newValue1Apos(op ssa.Op, t *types.Type, aux ssa.Aux, arg *ssa.Value, isStmt bool) *ssa.Value {
 	if isStmt {
 		return s.curBlock.NewValue1A(s.peekPos(), op, t, aux, arg)
 	}
@@ -812,14 +812,14 @@ func (s *state) newValue2(op ssa.Op, t *types.Type, arg0, arg1 *ssa.Value) *ssa.
 }
 
 // newValue2A adds a new value with two arguments and an aux value to the current block.
-func (s *state) newValue2A(op ssa.Op, t *types.Type, aux interface{}, arg0, arg1 *ssa.Value) *ssa.Value {
+func (s *state) newValue2A(op ssa.Op, t *types.Type, aux ssa.Aux, arg0, arg1 *ssa.Value) *ssa.Value {
 	return s.curBlock.NewValue2A(s.peekPos(), op, t, aux, arg0, arg1)
 }
 
 // newValue2Apos adds a new value with two arguments and an aux value to the current block.
 // isStmt determines whether the created values may be a statement or not
 // (i.e., false means never, yes means maybe).
-func (s *state) newValue2Apos(op ssa.Op, t *types.Type, aux interface{}, arg0, arg1 *ssa.Value, isStmt bool) *ssa.Value {
+func (s *state) newValue2Apos(op ssa.Op, t *types.Type, aux ssa.Aux, arg0, arg1 *ssa.Value, isStmt bool) *ssa.Value {
 	if isStmt {
 		return s.curBlock.NewValue2A(s.peekPos(), op, t, aux, arg0, arg1)
 	}
@@ -842,14 +842,14 @@ func (s *state) newValue3I(op ssa.Op, t *types.Type, aux int64, arg0, arg1, arg2
 }
 
 // newValue3A adds a new value with three arguments and an aux value to the current block.
-func (s *state) newValue3A(op ssa.Op, t *types.Type, aux interface{}, arg0, arg1, arg2 *ssa.Value) *ssa.Value {
+func (s *state) newValue3A(op ssa.Op, t *types.Type, aux ssa.Aux, arg0, arg1, arg2 *ssa.Value) *ssa.Value {
 	return s.curBlock.NewValue3A(s.peekPos(), op, t, aux, arg0, arg1, arg2)
 }
 
 // newValue3Apos adds a new value with three arguments and an aux value to the current block.
 // isStmt determines whether the created values may be a statement or not
 // (i.e., false means never, yes means maybe).
-func (s *state) newValue3Apos(op ssa.Op, t *types.Type, aux interface{}, arg0, arg1, arg2 *ssa.Value, isStmt bool) *ssa.Value {
+func (s *state) newValue3Apos(op ssa.Op, t *types.Type, aux ssa.Aux, arg0, arg1, arg2 *ssa.Value, isStmt bool) *ssa.Value {
 	if isStmt {
 		return s.curBlock.NewValue3A(s.peekPos(), op, t, aux, arg0, arg1, arg2)
 	}
@@ -872,7 +872,7 @@ func (s *state) entryNewValue0(op ssa.Op, t *types.Type) *ssa.Value {
 }
 
 // entryNewValue0A adds a new value with no arguments and an aux value to the entry block.
-func (s *state) entryNewValue0A(op ssa.Op, t *types.Type, aux interface{}) *ssa.Value {
+func (s *state) entryNewValue0A(op ssa.Op, t *types.Type, aux ssa.Aux) *ssa.Value {
 	return s.f.Entry.NewValue0A(src.NoXPos, op, t, aux)
 }
 
@@ -887,7 +887,7 @@ func (s *state) entryNewValue1I(op ssa.Op, t *types.Type, auxint int64, arg *ssa
 }
 
 // entryNewValue1A adds a new value with one argument and an aux value to the entry block.
-func (s *state) entryNewValue1A(op ssa.Op, t *types.Type, aux interface{}, arg *ssa.Value) *ssa.Value {
+func (s *state) entryNewValue1A(op ssa.Op, t *types.Type, aux ssa.Aux, arg *ssa.Value) *ssa.Value {
 	return s.f.Entry.NewValue1A(src.NoXPos, op, t, aux, arg)
 }
 
@@ -897,7 +897,7 @@ func (s *state) entryNewValue2(op ssa.Op, t *types.Type, arg0, arg1 *ssa.Value)
 }
 
 // entryNewValue2A adds a new value with two arguments and an aux value to the entry block.
-func (s *state) entryNewValue2A(op ssa.Op, t *types.Type, aux interface{}, arg0, arg1 *ssa.Value) *ssa.Value {
+func (s *state) entryNewValue2A(op ssa.Op, t *types.Type, aux ssa.Aux, arg0, arg1 *ssa.Value) *ssa.Value {
 	return s.f.Entry.NewValue2A(src.NoXPos, op, t, aux, arg0, arg1)
 }
 
@@ -2060,7 +2060,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 			if i == "" {
 				return s.constEmptyString(n.Type())
 			}
-			return s.entryNewValue0A(ssa.OpConstString, n.Type(), i)
+			return s.entryNewValue0A(ssa.OpConstString, n.Type(), ssa.StringToAux(i))
 		case constant.Bool:
 			return s.constBool(constant.BoolVal(u))
 		case constant.Float:
diff --git a/src/cmd/compile/internal/ir/mini.go b/src/cmd/compile/internal/ir/mini.go
index 612e7d62c3..edb3b197da 100644
--- a/src/cmd/compile/internal/ir/mini.go
+++ b/src/cmd/compile/internal/ir/mini.go
@@ -198,5 +198,6 @@ func (n *miniNode) MarkReadonly()             { panic(n.no("MarkReadonly")) }
 func (n *miniNode) TChanDir() types.ChanDir   { panic(n.no("TChanDir")) }
 func (n *miniNode) SetTChanDir(types.ChanDir) { panic(n.no("SetTChanDir")) }
 
-// TODO: Delete when CanBeAnSSASym is removed from Node itself.
+// TODO: Delete when these are removed from Node itself.
 func (*miniNode) CanBeAnSSASym() {}
+func (*miniNode) CanBeAnSSAAux() {}
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index ba7eaae1b9..b878b00546 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -113,6 +113,7 @@ type Node interface {
 	// Only for SSA and should be removed when SSA starts
 	// using a more specific type than Node.
 	CanBeAnSSASym()
+	CanBeAnSSAAux()
 }
 
 // Line returns n's position as a string. If n has been inlined,
diff --git a/src/cmd/compile/internal/ssa/block.go b/src/cmd/compile/internal/ssa/block.go
index 519ac214ca..937c757b21 100644
--- a/src/cmd/compile/internal/ssa/block.go
+++ b/src/cmd/compile/internal/ssa/block.go
@@ -52,7 +52,7 @@ type Block struct {
 	Controls [2]*Value
 
 	// Auxiliary info for the block. Its value depends on the Kind.
-	Aux    interface{}
+	Aux    Aux
 	AuxInt int64
 
 	// The unordered set of Values that define the operation of this block.
diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go
index 5f5dfc328a..4d57eef556 100644
--- a/src/cmd/compile/internal/ssa/check.go
+++ b/src/cmd/compile/internal/ssa/check.go
@@ -161,7 +161,7 @@ func checkFunc(f *Func) {
 					f.Fatalf("value %v has an AuxInt that encodes a NaN", v)
 				}
 			case auxString:
-				if _, ok := v.Aux.(string); !ok {
+				if _, ok := v.Aux.(stringAux); !ok {
 					f.Fatalf("value %v has Aux type %T, want string", v, v.Aux)
 				}
 				canHaveAux = true
diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go
index 3b4f2be37e..f78527410c 100644
--- a/src/cmd/compile/internal/ssa/cse.go
+++ b/src/cmd/compile/internal/ssa/cse.go
@@ -275,7 +275,7 @@ func lt2Cmp(isLt bool) types.Cmp {
 	return types.CMPgt
 }
 
-type auxmap map[interface{}]int32
+type auxmap map[Aux]int32
 
 func cmpVal(v, w *Value, auxIDs auxmap) types.Cmp {
 	// Try to order these comparison by cost (cheaper first)
diff --git a/src/cmd/compile/internal/ssa/cse_test.go b/src/cmd/compile/internal/ssa/cse_test.go
index 9e76645f54..8052016f3a 100644
--- a/src/cmd/compile/internal/ssa/cse_test.go
+++ b/src/cmd/compile/internal/ssa/cse_test.go
@@ -14,6 +14,8 @@ type tstAux struct {
 	s string
 }
 
+func (*tstAux) CanBeAnSSAAux() {}
+
 // This tests for a bug found when partitioning, but not sorting by the Aux value.
 func TestCSEAuxPartitionBug(t *testing.T) {
 	c := testConfig(t)
diff --git a/src/cmd/compile/internal/ssa/debug.go b/src/cmd/compile/internal/ssa/debug.go
index 0d660361b1..44e91270fa 100644
--- a/src/cmd/compile/internal/ssa/debug.go
+++ b/src/cmd/compile/internal/ssa/debug.go
@@ -143,13 +143,13 @@ func (loc VarLoc) absent() bool {
 var BlockStart = &Value{
 	ID:  -10000,
 	Op:  OpInvalid,
-	Aux: "BlockStart",
+	Aux: StringToAux("BlockStart"),
 }
 
 var BlockEnd = &Value{
 	ID:  -20000,
 	Op:  OpInvalid,
-	Aux: "BlockEnd",
+	Aux: StringToAux("BlockEnd"),
 }
 
 // RegisterSet is a bitmap of registers, indexed by Register.num.
diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go
index e6f899a2c7..e6c4798a78 100644
--- a/src/cmd/compile/internal/ssa/func.go
+++ b/src/cmd/compile/internal/ssa/func.go
@@ -377,13 +377,7 @@ func (b *Block) NewValue0I(pos src.XPos, op Op, t *types.Type, auxint int64) *Va
 }
 
 // NewValue returns a new value in the block with no arguments and an aux value.
-func (b *Block) NewValue0A(pos src.XPos, op Op, t *types.Type, aux interface{}) *Value {
-	if _, ok := aux.(int64); ok {
-		// Disallow int64 aux values. They should be in the auxint field instead.
-		// Maybe we want to allow this at some point, but for now we disallow it
-		// to prevent errors like using NewValue1A instead of NewValue1I.
-		b.Fatalf("aux field has int64 type op=%s type=%s aux=%v", op, t, aux)
-	}
+func (b *Block) NewValue0A(pos src.XPos, op Op, t *types.Type, aux Aux) *Value {
 	v := b.Func.newValue(op, t, b, pos)
 	v.AuxInt = 0
 	v.Aux = aux
@@ -392,7 +386,7 @@ func (b *Block) NewValue0A(pos src.XPos, op Op, t *types.Type, aux interface{})
 }
 
 // NewValue returns a new value in the block with no arguments and both an auxint and aux values.
-func (b *Block) NewValue0IA(pos src.XPos, op Op, t *types.Type, auxint int64, aux interface{}) *Value {
+func (b *Block) NewValue0IA(pos src.XPos, op Op, t *types.Type, auxint int64, aux Aux) *Value {
 	v := b.Func.newValue(op, t, b, pos)
 	v.AuxInt = auxint
 	v.Aux = aux
@@ -421,7 +415,7 @@ func (b *Block) NewValue1I(pos src.XPos, op Op, t *types.Type, auxint int64, arg
 }
 
 // NewValue1A returns a new value in the block with one argument and an aux value.
-func (b *Block) NewValue1A(pos src.XPos, op Op, t *types.Type, aux interface{}, arg *Value) *Value {
+func (b *Block) NewValue1A(pos src.XPos, op Op, t *types.Type, aux Aux, arg *Value) *Value {
 	v := b.Func.newValue(op, t, b, pos)
 	v.AuxInt = 0
 	v.Aux = aux
@@ -432,7 +426,7 @@ func (b *Block) NewValue1A(pos src.XPos, op Op, t *types.Type, aux interface{},
 }
 
 // NewValue1IA returns a new value in the block with one argument and both an auxint and aux values.
-func (b *Block) NewValue1IA(pos src.XPos, op Op, t *types.Type, auxint int64, aux interface{}, arg *Value) *Value {
+func (b *Block) NewValue1IA(pos src.XPos, op Op, t *types.Type, auxint int64, aux Aux, arg *Value) *Value {
 	v := b.Func.newValue(op, t, b, pos)
 	v.AuxInt = auxint
 	v.Aux = aux
@@ -455,7 +449,7 @@ func (b *Block) NewValue2(pos src.XPos, op Op, t *types.Type, arg0, arg1 *Value)
 }
 
 // NewValue2A returns a new value in the block with two arguments and one aux values.
-func (b *Block) NewValue2A(pos src.XPos, op Op, t *types.Type, aux interface{}, arg0, arg1 *Value) *Value {
+func (b *Block) NewValue2A(pos src.XPos, op Op, t *types.Type, aux Aux, arg0, arg1 *Value) *Value {
 	v := b.Func.newValue(op, t, b, pos)
 	v.AuxInt = 0
 	v.Aux = aux
@@ -480,7 +474,7 @@ func (b *Block) NewValue2I(pos src.XPos, op Op, t *types.Type, auxint int64, arg
 }
 
 // NewValue2IA returns a new value in the block with two arguments and both an auxint and aux values.
-func (b *Block) NewValue2IA(pos src.XPos, op Op, t *types.Type, auxint int64, aux interface{}, arg0, arg1 *Value) *Value {
+func (b *Block) NewValue2IA(pos src.XPos, op Op, t *types.Type, auxint int64, aux Aux, arg0, arg1 *Value) *Value {
 	v := b.Func.newValue(op, t, b, pos)
 	v.AuxInt = auxint
 	v.Aux = aux
@@ -521,7 +515,7 @@ func (b *Block) NewValue3I(pos src.XPos, op Op, t *types.Type, auxint int64, arg
 }
 
 // NewValue3A returns a new value in the block with three argument and an aux value.
-func (b *Block) NewValue3A(pos src.XPos, op Op, t *types.Type, aux interface{}, arg0, arg1, arg2 *Value) *Value {
+func (b *Block) NewValue3A(pos src.XPos, op Op, t *types.Type, aux Aux, arg0, arg1, arg2 *Value) *Value {
 	v := b.Func.newValue(op, t, b, pos)
 	v.AuxInt = 0
 	v.Aux = aux
@@ -633,7 +627,7 @@ func (f *Func) ConstNil(t *types.Type) *Value {
 }
 func (f *Func) ConstEmptyString(t *types.Type) *Value {
 	v := f.constVal(OpConstString, t, constEmptyStringMagic, false)
-	v.Aux = ""
+	v.Aux = StringToAux("")
 	return v
 }
 func (f *Func) ConstOffPtrSP(t *types.Type, c int64, sp *Value) *Value {
diff --git a/src/cmd/compile/internal/ssa/func_test.go b/src/cmd/compile/internal/ssa/func_test.go
index 568c6436f5..276c444b9a 100644
--- a/src/cmd/compile/internal/ssa/func_test.go
+++ b/src/cmd/compile/internal/ssa/func_test.go
@@ -232,7 +232,7 @@ func Bloc(name string, entries ...interface{}) bloc {
 }
 
 // Valu defines a value in a block.
-func Valu(name string, op Op, t *types.Type, auxint int64, aux interface{}, args ...string) valu {
+func Valu(name string, op Op, t *types.Type, auxint int64, aux Aux, args ...string) valu {
 	return valu{name, op, t, auxint, aux, args}
 }
 
@@ -277,7 +277,7 @@ type valu struct {
 	op     Op
 	t      *types.Type
 	auxint int64
-	aux    interface{}
+	aux    Aux
 	args   []string
 }
 
@@ -402,12 +402,12 @@ func TestEquiv(t *testing.T) {
 			cfg.Fun("entry",
 				Bloc("entry",
 					Valu("mem", OpInitMem, types.TypeMem, 0, nil),
-					Valu("a", OpConst64, cfg.config.Types.Int64, 0, 14),
+					Valu("a", OpConstString, cfg.config.Types.String, 0, StringToAux("foo")),
 					Exit("mem"))),
 			cfg.Fun("entry",
 				Bloc("entry",
 					Valu("mem", OpInitMem, types.TypeMem, 0, nil),
-					Valu("a", OpConst64, cfg.config.Types.Int64, 0, 26),
+					Valu("a", OpConstString, cfg.config.Types.String, 0, StringToAux("bar")),
 					Exit("mem"))),
 		},
 		// value args different
diff --git a/src/cmd/compile/internal/ssa/nilcheck_test.go b/src/cmd/compile/internal/ssa/nilcheck_test.go
index 16d94614d8..2e32afe2a6 100644
--- a/src/cmd/compile/internal/ssa/nilcheck_test.go
+++ b/src/cmd/compile/internal/ssa/nilcheck_test.go
@@ -212,7 +212,7 @@ func TestNilcheckPhi(t *testing.T) {
 			Valu("mem", OpInitMem, types.TypeMem, 0, nil),
 			Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
 			Valu("sp", OpSP, c.config.Types.Uintptr, 0, nil),
-			Valu("baddr", OpLocalAddr, c.config.Types.Bool, 0, "b", "sp", "mem"),
+			Valu("baddr", OpLocalAddr, c.config.Types.Bool, 0, StringToAux("b"), "sp", "mem"),
 			Valu("bool1", OpLoad, c.config.Types.Bool, 0, nil, "baddr", "mem"),
 			If("bool1", "b1", "b2")),
 		Bloc("b1",
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index 6f029a421e..97726a6f95 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -197,6 +197,8 @@ func ClosureAuxCall(args []Param, results []Param) *AuxCall {
 	return &AuxCall{Fn: nil, args: args, results: results}
 }
 
+func (*AuxCall) CanBeAnSSAAux() {}
+
 const (
 	auxNone         auxType = iota
 	auxBool                 // auxInt is 0/1 for false/true
@@ -248,6 +250,7 @@ const (
 type Sym interface {
 	String() string
 	CanBeAnSSASym()
+	CanBeAnSSAAux()
 }
 
 // A ValAndOff is used by the several opcodes. It holds
diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go
index 24efd38fb7..9abfe0938b 100644
--- a/src/cmd/compile/internal/ssa/rewrite.go
+++ b/src/cmd/compile/internal/ssa/rewrite.go
@@ -678,43 +678,53 @@ func opToAuxInt(o Op) int64 {
 	return int64(o)
 }
 
-func auxToString(i interface{}) string {
-	return i.(string)
+// Aux is an interface to hold miscellaneous data in Blocks and Values.
+type Aux interface {
+	CanBeAnSSAAux()
 }
-func auxToSym(i interface{}) Sym {
+
+// stringAux wraps string values for use in Aux.
+type stringAux string
+
+func (stringAux) CanBeAnSSAAux() {}
+
+func auxToString(i Aux) string {
+	return string(i.(stringAux))
+}
+func auxToSym(i Aux) Sym {
 	// TODO: kind of a hack - allows nil interface through
 	s, _ := i.(Sym)
 	return s
 }
-func auxToType(i interface{}) *types.Type {
+func auxToType(i Aux) *types.Type {
 	return i.(*types.Type)
 }
-func auxToCall(i interface{}) *AuxCall {
+func auxToCall(i Aux) *AuxCall {
 	return i.(*AuxCall)
 }
-func auxToS390xCCMask(i interface{}) s390x.CCMask {
+func auxToS390xCCMask(i Aux) s390x.CCMask {
 	return i.(s390x.CCMask)
 }
-func auxToS390xRotateParams(i interface{}) s390x.RotateParams {
+func auxToS390xRotateParams(i Aux) s390x.RotateParams {
 	return i.(s390x.RotateParams)
 }
 
-func stringToAux(s string) interface{} {
-	return s
+func StringToAux(s string) Aux {
+	return stringAux(s)
 }
-func symToAux(s Sym) interface{} {
+func symToAux(s Sym) Aux {
 	return s
 }
-func callToAux(s *AuxCall) interface{} {
+func callToAux(s *AuxCall) Aux {
 	return s
 }
-func typeToAux(t *types.Type) interface{} {
+func typeToAux(t *types.Type) Aux {
 	return t
 }
-func s390xCCMaskToAux(c s390x.CCMask) interface{} {
+func s390xCCMaskToAux(c s390x.CCMask) Aux {
 	return c
 }
-func s390xRotateParamsToAux(r s390x.RotateParams) interface{} {
+func s390xRotateParamsToAux(r s390x.RotateParams) Aux {
 	return r
 }
 
@@ -725,7 +735,7 @@ func uaddOvf(a, b int64) bool {
 
 // de-virtualize an InterCall
 // 'sym' is the symbol for the itab
-func devirt(v *Value, aux interface{}, sym Sym, offset int64) *AuxCall {
+func devirt(v *Value, aux Aux, sym Sym, offset int64) *AuxCall {
 	f := v.Block.Func
 	n, ok := sym.(*obj.LSym)
 	if !ok {
@@ -748,7 +758,7 @@ func devirt(v *Value, aux interface{}, sym Sym, offset int64) *AuxCall {
 
 // de-virtualize an InterLECall
 // 'sym' is the symbol for the itab
-func devirtLESym(v *Value, aux interface{}, sym Sym, offset int64) *obj.LSym {
+func devirtLESym(v *Value, aux Aux, sym Sym, offset int64) *obj.LSym {
 	n, ok := sym.(*obj.LSym)
 	if !ok {
 		return nil
diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go
index edc43aaae7..993c5a580f 100644
--- a/src/cmd/compile/internal/ssa/value.go
+++ b/src/cmd/compile/internal/ssa/value.go
@@ -36,7 +36,7 @@ type Value struct {
 	// Users of AuxInt which interpret AuxInt as unsigned (e.g. shifts) must be careful.
 	// Use Value.AuxUnsigned to get the zero-extended value of AuxInt.
 	AuxInt int64
-	Aux    interface{}
+	Aux    Aux
 
 	// Arguments of this value
 	Args []*Value
@@ -492,3 +492,6 @@ func (v *Value) removeable() bool {
 	}
 	return true
 }
+
+// TODO(mdempsky): Shouldn't be necessary; see discussion at golang.org/cl/275756
+func (*Value) CanBeAnSSAAux() {}
diff --git a/src/cmd/compile/internal/ssa/zcse.go b/src/cmd/compile/internal/ssa/zcse.go
index ec38b7d1ba..e08272c345 100644
--- a/src/cmd/compile/internal/ssa/zcse.go
+++ b/src/cmd/compile/internal/ssa/zcse.go
@@ -57,7 +57,7 @@ func zcse(f *Func) {
 type vkey struct {
 	op Op
 	ai int64       // aux int
-	ax interface{} // aux
+	ax Aux         // aux
 	t  *types.Type // type
 }
 
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index c5807af199..e968a799e3 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -164,6 +164,8 @@ type Type struct {
 	flags bitset8
 }
 
+func (*Type) CanBeAnSSAAux() {}
+
 const (
 	typeNotInHeap  = 1 << iota // type cannot be heap allocated
 	typeBroke                  // broken type definition
diff --git a/src/cmd/internal/obj/link.go b/src/cmd/internal/obj/link.go
index 8c8ff587ff..eaebfaf4b6 100644
--- a/src/cmd/internal/obj/link.go
+++ b/src/cmd/internal/obj/link.go
@@ -723,8 +723,8 @@ func (s *LSym) String() string {
 }
 
 // The compiler needs *LSym to be assignable to cmd/compile/internal/ssa.Sym.
-func (s *LSym) CanBeAnSSASym() {
-}
+func (*LSym) CanBeAnSSASym() {}
+func (*LSym) CanBeAnSSAAux() {}
 
 type Pcln struct {
 	// Aux symbols for pcln
diff --git a/src/cmd/internal/obj/s390x/condition_code.go b/src/cmd/internal/obj/s390x/condition_code.go
index 764fc5bc6a..f498fd6f77 100644
--- a/src/cmd/internal/obj/s390x/condition_code.go
+++ b/src/cmd/internal/obj/s390x/condition_code.go
@@ -124,3 +124,5 @@ func (c CCMask) String() string {
 	// invalid
 	return fmt.Sprintf("Invalid (%#x)", c)
 }
+
+func (CCMask) CanBeAnSSAAux() {}
diff --git a/src/cmd/internal/obj/s390x/rotate.go b/src/cmd/internal/obj/s390x/rotate.go
index 7dbc45e648..c999880492 100644
--- a/src/cmd/internal/obj/s390x/rotate.go
+++ b/src/cmd/internal/obj/s390x/rotate.go
@@ -113,3 +113,5 @@ func (r RotateParams) OutMerge(mask uint64) *RotateParams {
 func (r RotateParams) InMerge(mask uint64) *RotateParams {
 	return r.OutMerge(bits.RotateLeft64(mask, int(r.Amount)))
 }
+
+func (RotateParams) CanBeAnSSAAux() {}
-- 
GitLab


From dcec658f6c9798b226d2f1e72a7b22b613e95c00 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 6 Dec 2020 12:02:22 -0800
Subject: [PATCH 0185/2400] [dev.regabi] cmd/compile: change LocalSlot.N to
 *ir.Name

This was already documented as always being an ONAME, so it just
needed a few type assertion changes.

Passes buildall w/ toolstash -cmp.

Updates #42982.

Change-Id: I61f4b6ebd57c43b41977f4b37b81fe94fb11a723
Reviewed-on: https://go-review.googlesource.com/c/go/+/275757
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Russ Cox <rsc@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/ssa.go          | 7 +++----
 src/cmd/compile/internal/ssa/config.go      | 2 +-
 src/cmd/compile/internal/ssa/debug.go       | 2 +-
 src/cmd/compile/internal/ssa/export_test.go | 2 +-
 src/cmd/compile/internal/ssa/location.go    | 2 +-
 src/cmd/compile/internal/ssa/sizeof_test.go | 2 +-
 src/cmd/compile/internal/ssa/stackalloc.go  | 2 +-
 7 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 95650328b1..2378ea7711 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -6078,7 +6078,7 @@ func (s *state) addNamedValue(n ir.Node, v *ssa.Value) {
 	if n.Class() == ir.PAUTO && n.Offset() != 0 {
 		s.Fatalf("AUTO var with offset %v %d", n, n.Offset())
 	}
-	loc := ssa.LocalSlot{N: n, Type: n.Type(), Off: 0}
+	loc := ssa.LocalSlot{N: n.Name(), Type: n.Type(), Off: 0}
 	values, ok := s.f.NamedValues[loc]
 	if !ok {
 		s.f.Names = append(s.f.Names, loc)
@@ -6979,9 +6979,8 @@ func (e *ssafn) StringData(s string) *obj.LSym {
 	return data
 }
 
-func (e *ssafn) Auto(pos src.XPos, t *types.Type) ir.Node {
-	n := tempAt(pos, e.curfn, t) // Note: adds new auto to e.curfn.Func.Dcl list
-	return n
+func (e *ssafn) Auto(pos src.XPos, t *types.Type) *ir.Name {
+	return tempAt(pos, e.curfn, t) // Note: adds new auto to e.curfn.Func.Dcl list
 }
 
 func (e *ssafn) SplitString(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot) {
diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go
index eeabd81d03..8dc2ee8213 100644
--- a/src/cmd/compile/internal/ssa/config.go
+++ b/src/cmd/compile/internal/ssa/config.go
@@ -139,7 +139,7 @@ type Frontend interface {
 
 	// Auto returns a Node for an auto variable of the given type.
 	// The SSA compiler uses this function to allocate space for spills.
-	Auto(src.XPos, *types.Type) ir.Node
+	Auto(src.XPos, *types.Type) *ir.Name
 
 	// Given the name for a compound type, returns the name we should use
 	// for the parts of that compound type.
diff --git a/src/cmd/compile/internal/ssa/debug.go b/src/cmd/compile/internal/ssa/debug.go
index 44e91270fa..6123978e55 100644
--- a/src/cmd/compile/internal/ssa/debug.go
+++ b/src/cmd/compile/internal/ssa/debug.go
@@ -380,7 +380,7 @@ func BuildFuncDebug(ctxt *obj.Link, f *Func, loggingEnabled bool, stackOffset fu
 	for _, b := range f.Blocks {
 		for _, v := range b.Values {
 			if v.Op == OpVarDef || v.Op == OpVarKill {
-				n := v.Aux.(ir.Node)
+				n := v.Aux.(*ir.Name)
 				if ir.IsSynthetic(n) {
 					continue
 				}
diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go
index 55fce31088..644baa8548 100644
--- a/src/cmd/compile/internal/ssa/export_test.go
+++ b/src/cmd/compile/internal/ssa/export_test.go
@@ -68,7 +68,7 @@ type TestFrontend struct {
 func (TestFrontend) StringData(s string) *obj.LSym {
 	return nil
 }
-func (TestFrontend) Auto(pos src.XPos, t *types.Type) ir.Node {
+func (TestFrontend) Auto(pos src.XPos, t *types.Type) *ir.Name {
 	n := ir.NewNameAt(pos, &types.Sym{Name: "aFakeAuto"})
 	n.SetClass(ir.PAUTO)
 	return n
diff --git a/src/cmd/compile/internal/ssa/location.go b/src/cmd/compile/internal/ssa/location.go
index 3dc3a81703..69f90d9ab4 100644
--- a/src/cmd/compile/internal/ssa/location.go
+++ b/src/cmd/compile/internal/ssa/location.go
@@ -60,7 +60,7 @@ func (r *Register) GCNum() int16 {
 //                           { N: len, Type: int, Off: 0, SplitOf: parent, SplitOffset: 8}
 //                           parent = &{N: s, Type: string}
 type LocalSlot struct {
-	N    ir.Node     // an ONAME *gc.Node representing a stack location.
+	N    *ir.Name    // an ONAME *ir.Name representing a stack location.
 	Type *types.Type // type of slot
 	Off  int64       // offset of slot in N
 
diff --git a/src/cmd/compile/internal/ssa/sizeof_test.go b/src/cmd/compile/internal/ssa/sizeof_test.go
index 60ada011e3..a27002ee3a 100644
--- a/src/cmd/compile/internal/ssa/sizeof_test.go
+++ b/src/cmd/compile/internal/ssa/sizeof_test.go
@@ -22,7 +22,7 @@ func TestSizeof(t *testing.T) {
 	}{
 		{Value{}, 72, 112},
 		{Block{}, 164, 304},
-		{LocalSlot{}, 32, 48},
+		{LocalSlot{}, 28, 40},
 		{valState{}, 28, 40},
 	}
 
diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go
index 5257d44cfe..68a6f08a2a 100644
--- a/src/cmd/compile/internal/ssa/stackalloc.go
+++ b/src/cmd/compile/internal/ssa/stackalloc.go
@@ -157,7 +157,7 @@ func (s *stackAllocState) stackalloc() {
 		if v.Aux == nil {
 			f.Fatalf("%s has nil Aux\n", v.LongString())
 		}
-		loc := LocalSlot{N: v.Aux.(ir.Node), Type: v.Type, Off: v.AuxInt}
+		loc := LocalSlot{N: v.Aux.(*ir.Name), Type: v.Type, Off: v.AuxInt}
 		if f.pass.debug > stackDebug {
 			fmt.Printf("stackalloc %s to %s\n", v, loc)
 		}
-- 
GitLab


From 1c8943a6add218f6ffd86c0952372fe54b0672a4 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 6 Dec 2020 18:10:34 -0800
Subject: [PATCH 0186/2400] [dev.regabi] cmd/compile: introduce FwdRefAux for
 wrapping ir.Node as ssa.Aux

OpFwdRef is the only SSA value that needs the ability to store an
arbitrary ir.Node in its Aux field. Every other SSA value always uses
an *ir.Name.

This CL introduces FwdRefAux, which wraps an ir.Node and implements
the ssa.Aux tag interface, so that a subsequent refactoring can change
ir.Node to not implement ssa.Aux.

Passes buildall w/ toolstash -cmp.

Updates #42982.

Change-Id: Id1475b28847579573cd376e82f28761d84cd1c23
Reviewed-on: https://go-review.googlesource.com/c/go/+/275788
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/gc/phi.go | 18 +++++++++++++-----
 src/cmd/compile/internal/gc/ssa.go |  2 +-
 2 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/src/cmd/compile/internal/gc/phi.go b/src/cmd/compile/internal/gc/phi.go
index 677bfc92df..def11e1be0 100644
--- a/src/cmd/compile/internal/gc/phi.go
+++ b/src/cmd/compile/internal/gc/phi.go
@@ -23,6 +23,14 @@ const smallBlocks = 500
 
 const debugPhi = false
 
+// FwdRefAux wraps an arbitrary ir.Node as an ssa.Aux for use with OpFwdref.
+type FwdRefAux struct {
+	_ [0]func() // ensure ir.Node isn't compared for equality
+	N ir.Node
+}
+
+func (FwdRefAux) CanBeAnSSAAux() {}
+
 // insertPhis finds all the places in the function where a phi is
 // necessary and inserts them.
 // Uses FwdRef ops to find all uses of variables, and s.defvars to find
@@ -79,7 +87,7 @@ func (s *phiState) insertPhis() {
 			if v.Op != ssa.OpFwdRef {
 				continue
 			}
-			var_ := v.Aux.(ir.Node)
+			var_ := v.Aux.(FwdRefAux).N
 
 			// Optimization: look back 1 block for the definition.
 			if len(b.Preds) == 1 {
@@ -319,7 +327,7 @@ func (s *phiState) resolveFwdRefs() {
 			if v.Op != ssa.OpFwdRef {
 				continue
 			}
-			n := s.varnum[v.Aux.(ir.Node)]
+			n := s.varnum[v.Aux.(FwdRefAux).N]
 			v.Op = ssa.OpCopy
 			v.Aux = nil
 			v.AddArg(values[n])
@@ -450,7 +458,7 @@ func (s *simplePhiState) insertPhis() {
 				continue
 			}
 			s.fwdrefs = append(s.fwdrefs, v)
-			var_ := v.Aux.(ir.Node)
+			var_ := v.Aux.(FwdRefAux).N
 			if _, ok := s.defvars[b.ID][var_]; !ok {
 				s.defvars[b.ID][var_] = v // treat FwdDefs as definitions.
 			}
@@ -464,7 +472,7 @@ loop:
 		v := s.fwdrefs[len(s.fwdrefs)-1]
 		s.fwdrefs = s.fwdrefs[:len(s.fwdrefs)-1]
 		b := v.Block
-		var_ := v.Aux.(ir.Node)
+		var_ := v.Aux.(FwdRefAux).N
 		if b == s.f.Entry {
 			// No variable should be live at entry.
 			s.s.Fatalf("Value live at entry. It shouldn't be. func %s, node %v, value %v", s.f.Name, var_, v)
@@ -531,7 +539,7 @@ func (s *simplePhiState) lookupVarOutgoing(b *ssa.Block, t *types.Type, var_ ir.
 		}
 	}
 	// Generate a FwdRef for the variable and return that.
-	v := b.NewValue0A(line, ssa.OpFwdRef, t, var_)
+	v := b.NewValue0A(line, ssa.OpFwdRef, t, FwdRefAux{N: var_})
 	s.defvars[b.ID][var_] = v
 	s.s.addNamedValue(var_, v)
 	s.fwdrefs = append(s.fwdrefs, v)
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 2378ea7711..90c7546042 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -6051,7 +6051,7 @@ func (s *state) variable(name ir.Node, t *types.Type) *ssa.Value {
 	}
 	// Make a FwdRef, which records a value that's live on block input.
 	// We'll find the matching definition as part of insertPhis.
-	v = s.newValue0A(ssa.OpFwdRef, t, name)
+	v = s.newValue0A(ssa.OpFwdRef, t, FwdRefAux{N: name})
 	s.fwdVars[name] = v
 	s.addNamedValue(name, v)
 	return v
-- 
GitLab


From 6db970e20acd7caeed268fdff458609570f21c90 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 6 Dec 2020 18:13:43 -0800
Subject: [PATCH 0187/2400] [dev.regabi] cmd/compile: rewrite Aux uses of
 ir.Node to *ir.Name [generated]

Now that the only remaining ir.Node implementation that is stored
(directly) into ssa.Aux, we can rewrite all of the conversions between
ir.Node and ssa.Aux to use *ir.Name instead.

rf doesn't have a way to rewrite the type switch case clauses, so we
just use sed instead. There's only a handful, and they're the only
times that "case ir.Node" appears anyway.

The next CL will move the tag method declarations so that ir.Node no
longer implements ssa.Aux.

Passes buildall w/ toolstash -cmp.

Updates #42982.

[git-generate]
cd src/cmd/compile/internal
sed -i -e 's/case ir.Node/case *ir.Name/' gc/plive.go */ssa.go

cd ssa
rf '
ex . ../gc {
  import "cmd/compile/internal/ir"

  var v *Value
  v.Aux.(ir.Node) -> v.Aux.(*ir.Name)

  var n ir.Node
  var asAux func(Aux)
  strict n        # only match ir.Node-typed expressions; not *ir.Name
  implicit asAux  # match implicit assignments to ssa.Aux
  asAux(n)        -> n.(*ir.Name)
}
'

Change-Id: I3206ef5f12a7cfa37c5fecc67a1ca02ea4d52b32
Reviewed-on: https://go-review.googlesource.com/c/go/+/275789
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/arm/ssa.go       |  2 +-
 src/cmd/compile/internal/arm64/ssa.go     |  2 +-
 src/cmd/compile/internal/gc/pgen.go       |  2 +-
 src/cmd/compile/internal/gc/plive.go      |  6 ++--
 src/cmd/compile/internal/gc/ssa.go        | 40 +++++++++++------------
 src/cmd/compile/internal/mips/ssa.go      |  2 +-
 src/cmd/compile/internal/mips64/ssa.go    |  2 +-
 src/cmd/compile/internal/riscv64/ssa.go   |  2 +-
 src/cmd/compile/internal/ssa/deadstore.go | 10 +++---
 src/cmd/compile/internal/ssa/debug.go     |  2 +-
 src/cmd/compile/internal/ssa/nilcheck.go  |  2 +-
 src/cmd/compile/internal/ssa/regalloc.go  |  2 +-
 src/cmd/compile/internal/wasm/ssa.go      |  2 +-
 13 files changed, 38 insertions(+), 38 deletions(-)

diff --git a/src/cmd/compile/internal/arm/ssa.go b/src/cmd/compile/internal/arm/ssa.go
index b34e2973b2..8b155712aa 100644
--- a/src/cmd/compile/internal/arm/ssa.go
+++ b/src/cmd/compile/internal/arm/ssa.go
@@ -546,7 +546,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		case *obj.LSym:
 			wantreg = "SB"
 			gc.AddAux(&p.From, v)
-		case ir.Node:
+		case *ir.Name:
 			wantreg = "SP"
 			gc.AddAux(&p.From, v)
 		case nil:
diff --git a/src/cmd/compile/internal/arm64/ssa.go b/src/cmd/compile/internal/arm64/ssa.go
index d5bd9687cf..3eb0ae6557 100644
--- a/src/cmd/compile/internal/arm64/ssa.go
+++ b/src/cmd/compile/internal/arm64/ssa.go
@@ -396,7 +396,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		case *obj.LSym:
 			wantreg = "SB"
 			gc.AddAux(&p.From, v)
-		case ir.Node:
+		case *ir.Name:
 			wantreg = "SP"
 			gc.AddAux(&p.From, v)
 		case nil:
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index 1da0929290..a7b19953ba 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -128,7 +128,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 	scratchUsed := false
 	for _, b := range f.Blocks {
 		for _, v := range b.Values {
-			if n, ok := v.Aux.(ir.Node); ok {
+			if n, ok := v.Aux.(*ir.Name); ok {
 				switch n.Class() {
 				case ir.PPARAM, ir.PPARAMOUT:
 					// Don't modify nodfp; it is a global.
diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/gc/plive.go
index 06e423daa1..9952bfcf36 100644
--- a/src/cmd/compile/internal/gc/plive.go
+++ b/src/cmd/compile/internal/gc/plive.go
@@ -324,9 +324,9 @@ func affectedNode(v *ssa.Value) (ir.Node, ssa.SymEffect) {
 		return n, ssa.SymWrite
 
 	case ssa.OpVarLive:
-		return v.Aux.(ir.Node), ssa.SymRead
+		return v.Aux.(*ir.Name), ssa.SymRead
 	case ssa.OpVarDef, ssa.OpVarKill:
-		return v.Aux.(ir.Node), ssa.SymWrite
+		return v.Aux.(*ir.Name), ssa.SymWrite
 	case ssa.OpKeepAlive:
 		n, _ := AutoVar(v.Args[0])
 		return n, ssa.SymRead
@@ -341,7 +341,7 @@ func affectedNode(v *ssa.Value) (ir.Node, ssa.SymEffect) {
 	case nil, *obj.LSym:
 		// ok, but no node
 		return nil, e
-	case ir.Node:
+	case *ir.Name:
 		return a, e
 	default:
 		base.Fatalf("weird aux: %s", v.LongString())
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 90c7546042..e8f345d8f6 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -1504,7 +1504,7 @@ func (s *state) stmt(n ir.Node) {
 
 	case ir.OVARDEF:
 		if !s.canSSA(n.Left()) {
-			s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, n.Left(), s.mem(), false)
+			s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, n.Left().(*ir.Name), s.mem(), false)
 		}
 	case ir.OVARKILL:
 		// Insert a varkill op to record that a variable is no longer live.
@@ -1512,7 +1512,7 @@ func (s *state) stmt(n ir.Node) {
 		// varkill in the store chain is enough to keep it correctly ordered
 		// with respect to call ops.
 		if !s.canSSA(n.Left()) {
-			s.vars[memVar] = s.newValue1Apos(ssa.OpVarKill, types.TypeMem, n.Left(), s.mem(), false)
+			s.vars[memVar] = s.newValue1Apos(ssa.OpVarKill, types.TypeMem, n.Left().(*ir.Name), s.mem(), false)
 		}
 
 	case ir.OVARLIVE:
@@ -1525,7 +1525,7 @@ func (s *state) stmt(n ir.Node) {
 		default:
 			s.Fatalf("VARLIVE variable %v must be Auto or Arg", n.Left())
 		}
-		s.vars[memVar] = s.newValue1A(ssa.OpVarLive, types.TypeMem, n.Left(), s.mem())
+		s.vars[memVar] = s.newValue1A(ssa.OpVarLive, types.TypeMem, n.Left().(*ir.Name), s.mem())
 
 	case ir.OCHECKNIL:
 		p := s.expr(n.Left())
@@ -1571,7 +1571,7 @@ func (s *state) exit() *ssa.Block {
 	for _, n := range s.returns {
 		addr := s.decladdrs[n]
 		val := s.variable(n, n.Type())
-		s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
+		s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n.(*ir.Name), s.mem())
 		s.store(n.Type(), addr, val)
 		// TODO: if val is ever spilled, we'd like to use the
 		// PPARAMOUT slot for spilling it. That won't happen
@@ -2866,7 +2866,7 @@ func (s *state) append(n ir.Node, inplace bool) *ssa.Value {
 	if inplace {
 		if sn.Op() == ir.ONAME && sn.Class() != ir.PEXTERN {
 			// Tell liveness we're about to build a new slice
-			s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, sn, s.mem())
+			s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, sn.(*ir.Name), s.mem())
 		}
 		capaddr := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.IntPtr, sliceCapOffset, addr)
 		s.store(types.Types[types.TINT], capaddr, r[2])
@@ -3076,7 +3076,7 @@ func (s *state) assign(left ir.Node, right *ssa.Value, deref bool, skip skipMask
 	// If this assignment clobbers an entire local variable, then emit
 	// OpVarDef so liveness analysis knows the variable is redefined.
 	if base := clobberBase(left); base.Op() == ir.ONAME && base.Class() != ir.PEXTERN && skip == 0 {
-		s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, base, s.mem(), !ir.IsAutoTmp(base))
+		s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, base.(*ir.Name), s.mem(), !ir.IsAutoTmp(base))
 	}
 
 	// Left is not ssa-able. Compute its address.
@@ -4236,7 +4236,7 @@ func (s *state) openDeferRecord(n ir.Node) {
 		// call the function directly if it is a static function.
 		closureVal := s.expr(fn)
 		closure := s.openDeferSave(nil, fn.Type(), closureVal)
-		opendefer.closureNode = closure.Aux.(ir.Node)
+		opendefer.closureNode = closure.Aux.(*ir.Name)
 		if !(fn.Op() == ir.ONAME && fn.Class() == ir.PFUNC) {
 			opendefer.closure = closure
 		}
@@ -4249,7 +4249,7 @@ func (s *state) openDeferRecord(n ir.Node) {
 		// runtime panic code to use. But in the defer exit code, we will
 		// call the method directly.
 		closure := s.openDeferSave(nil, fn.Type(), closureVal)
-		opendefer.closureNode = closure.Aux.(ir.Node)
+		opendefer.closureNode = closure.Aux.(*ir.Name)
 	} else {
 		if fn.Op() != ir.ODOTINTER {
 			base.Fatalf("OCALLINTER: n.Left not an ODOTINTER: %v", fn.Op())
@@ -4259,8 +4259,8 @@ func (s *state) openDeferRecord(n ir.Node) {
 		// Important to get the receiver type correct, so it is recognized
 		// as a pointer for GC purposes.
 		opendefer.rcvr = s.openDeferSave(nil, fn.Type().Recv().Type, rcvr)
-		opendefer.closureNode = opendefer.closure.Aux.(ir.Node)
-		opendefer.rcvrNode = opendefer.rcvr.Aux.(ir.Node)
+		opendefer.closureNode = opendefer.closure.Aux.(*ir.Name)
+		opendefer.rcvrNode = opendefer.rcvr.Aux.(*ir.Name)
 	}
 	for _, argn := range n.Rlist().Slice() {
 		var v *ssa.Value
@@ -4270,7 +4270,7 @@ func (s *state) openDeferRecord(n ir.Node) {
 			v = s.openDeferSave(argn, argn.Type(), nil)
 		}
 		args = append(args, v)
-		argNodes = append(argNodes, v.Aux.(ir.Node))
+		argNodes = append(argNodes, v.Aux.(*ir.Name))
 	}
 	opendefer.argVals = args
 	opendefer.argNodes = argNodes
@@ -4458,16 +4458,16 @@ func (s *state) openDeferExit() {
 		// use the first call of the last defer exit to compute liveness
 		// for the deferreturn, so we want all stack slots to be live.
 		if r.closureNode != nil {
-			s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, r.closureNode, s.mem(), false)
+			s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, r.closureNode.(*ir.Name), s.mem(), false)
 		}
 		if r.rcvrNode != nil {
 			if r.rcvrNode.Type().HasPointers() {
-				s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, r.rcvrNode, s.mem(), false)
+				s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, r.rcvrNode.(*ir.Name), s.mem(), false)
 			}
 		}
 		for _, argNode := range r.argNodes {
 			if argNode.Type().HasPointers() {
-				s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, argNode, s.mem(), false)
+				s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, argNode.(*ir.Name), s.mem(), false)
 			}
 		}
 
@@ -4855,17 +4855,17 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 			}
 			if n == nodfp {
 				// Special arg that points to the frame pointer (Used by ORECOVER).
-				return s.entryNewValue2A(ssa.OpLocalAddr, t, n, s.sp, s.startmem)
+				return s.entryNewValue2A(ssa.OpLocalAddr, t, n.(*ir.Name), s.sp, s.startmem)
 			}
 			s.Fatalf("addr of undeclared ONAME %v. declared: %v", n, s.decladdrs)
 			return nil
 		case ir.PAUTO:
-			return s.newValue2Apos(ssa.OpLocalAddr, t, n, s.sp, s.mem(), !ir.IsAutoTmp(n))
+			return s.newValue2Apos(ssa.OpLocalAddr, t, n.(*ir.Name), s.sp, s.mem(), !ir.IsAutoTmp(n))
 
 		case ir.PPARAMOUT: // Same as PAUTO -- cannot generate LEA early.
 			// ensure that we reuse symbols for out parameters so
 			// that cse works on their addresses
-			return s.newValue2Apos(ssa.OpLocalAddr, t, n, s.sp, s.mem(), true)
+			return s.newValue2Apos(ssa.OpLocalAddr, t, n.(*ir.Name), s.sp, s.mem(), true)
 		default:
 			s.Fatalf("variable address class %v not implemented", n.Class())
 			return nil
@@ -5951,7 +5951,7 @@ func (s *state) dottype(n ir.Node, commaok bool) (res, resok *ssa.Value) {
 		// unSSAable type, use temporary.
 		// TODO: get rid of some of these temporaries.
 		tmp = tempAt(n.Pos(), s.curfn, n.Type())
-		s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, tmp, s.mem())
+		s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, tmp.(*ir.Name), s.mem())
 		addr = s.addr(tmp)
 	}
 
@@ -6027,7 +6027,7 @@ func (s *state) dottype(n ir.Node, commaok bool) (res, resok *ssa.Value) {
 		delete(s.vars, valVar)
 	} else {
 		res = s.load(n.Type(), addr)
-		s.vars[memVar] = s.newValue1A(ssa.OpVarKill, types.TypeMem, tmp, s.mem())
+		s.vars[memVar] = s.newValue1A(ssa.OpVarKill, types.TypeMem, tmp.(*ir.Name), s.mem())
 	}
 	resok = s.variable(okVar, types.Types[types.TBOOL])
 	delete(s.vars, okVar)
@@ -6680,7 +6680,7 @@ func AddAux2(a *obj.Addr, v *ssa.Value, offset int64) {
 	case *obj.LSym:
 		a.Name = obj.NAME_EXTERN
 		a.Sym = n
-	case ir.Node:
+	case *ir.Name:
 		if n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT {
 			a.Name = obj.NAME_PARAM
 			a.Sym = ir.Orig(n).Sym().Linksym()
diff --git a/src/cmd/compile/internal/mips/ssa.go b/src/cmd/compile/internal/mips/ssa.go
index bd71b2fcd8..10453c27d5 100644
--- a/src/cmd/compile/internal/mips/ssa.go
+++ b/src/cmd/compile/internal/mips/ssa.go
@@ -289,7 +289,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		case *obj.LSym:
 			wantreg = "SB"
 			gc.AddAux(&p.From, v)
-		case ir.Node:
+		case *ir.Name:
 			wantreg = "SP"
 			gc.AddAux(&p.From, v)
 		case nil:
diff --git a/src/cmd/compile/internal/mips64/ssa.go b/src/cmd/compile/internal/mips64/ssa.go
index bcadebde4e..9aaf8715de 100644
--- a/src/cmd/compile/internal/mips64/ssa.go
+++ b/src/cmd/compile/internal/mips64/ssa.go
@@ -263,7 +263,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		case *obj.LSym:
 			wantreg = "SB"
 			gc.AddAux(&p.From, v)
-		case ir.Node:
+		case *ir.Name:
 			wantreg = "SP"
 			gc.AddAux(&p.From, v)
 		case nil:
diff --git a/src/cmd/compile/internal/riscv64/ssa.go b/src/cmd/compile/internal/riscv64/ssa.go
index c81b6897a6..d382304d72 100644
--- a/src/cmd/compile/internal/riscv64/ssa.go
+++ b/src/cmd/compile/internal/riscv64/ssa.go
@@ -324,7 +324,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		case *obj.LSym:
 			wantreg = "SB"
 			gc.AddAux(&p.From, v)
-		case ir.Node:
+		case *ir.Name:
 			wantreg = "SP"
 			gc.AddAux(&p.From, v)
 		case nil:
diff --git a/src/cmd/compile/internal/ssa/deadstore.go b/src/cmd/compile/internal/ssa/deadstore.go
index f3ef33d670..d0446a0311 100644
--- a/src/cmd/compile/internal/ssa/deadstore.go
+++ b/src/cmd/compile/internal/ssa/deadstore.go
@@ -147,7 +147,7 @@ func elimDeadAutosGeneric(f *Func) {
 		switch v.Op {
 		case OpAddr, OpLocalAddr:
 			// Propagate the address if it points to an auto.
-			n, ok := v.Aux.(ir.Node)
+			n, ok := v.Aux.(*ir.Name)
 			if !ok || n.Class() != ir.PAUTO {
 				return
 			}
@@ -158,7 +158,7 @@ func elimDeadAutosGeneric(f *Func) {
 			return
 		case OpVarDef, OpVarKill:
 			// v should be eliminated if we eliminate the auto.
-			n, ok := v.Aux.(ir.Node)
+			n, ok := v.Aux.(*ir.Name)
 			if !ok || n.Class() != ir.PAUTO {
 				return
 			}
@@ -174,7 +174,7 @@ func elimDeadAutosGeneric(f *Func) {
 			// for open-coded defers from being removed (since they
 			// may not be used by the inline code, but will be used by
 			// panic processing).
-			n, ok := v.Aux.(ir.Node)
+			n, ok := v.Aux.(*ir.Name)
 			if !ok || n.Class() != ir.PAUTO {
 				return
 			}
@@ -303,7 +303,7 @@ func elimUnreadAutos(f *Func) {
 	var stores []*Value
 	for _, b := range f.Blocks {
 		for _, v := range b.Values {
-			n, ok := v.Aux.(ir.Node)
+			n, ok := v.Aux.(*ir.Name)
 			if !ok {
 				continue
 			}
@@ -335,7 +335,7 @@ func elimUnreadAutos(f *Func) {
 
 	// Eliminate stores to unread autos.
 	for _, store := range stores {
-		n, _ := store.Aux.(ir.Node)
+		n, _ := store.Aux.(*ir.Name)
 		if seen[n] {
 			continue
 		}
diff --git a/src/cmd/compile/internal/ssa/debug.go b/src/cmd/compile/internal/ssa/debug.go
index 6123978e55..405817dbe1 100644
--- a/src/cmd/compile/internal/ssa/debug.go
+++ b/src/cmd/compile/internal/ssa/debug.go
@@ -718,7 +718,7 @@ func (state *debugState) processValue(v *Value, vSlots []SlotID, vReg *Register)
 
 	switch {
 	case v.Op == OpVarDef, v.Op == OpVarKill:
-		n := v.Aux.(ir.Node)
+		n := v.Aux.(*ir.Name)
 		if ir.IsSynthetic(n) {
 			break
 		}
diff --git a/src/cmd/compile/internal/ssa/nilcheck.go b/src/cmd/compile/internal/ssa/nilcheck.go
index b36f6b97e1..bae50657c9 100644
--- a/src/cmd/compile/internal/ssa/nilcheck.go
+++ b/src/cmd/compile/internal/ssa/nilcheck.go
@@ -236,7 +236,7 @@ func nilcheckelim2(f *Func) {
 				continue
 			}
 			if v.Type.IsMemory() || v.Type.IsTuple() && v.Type.FieldType(1).IsMemory() {
-				if v.Op == OpVarKill || v.Op == OpVarLive || (v.Op == OpVarDef && !v.Aux.(ir.Node).Type().HasPointers()) {
+				if v.Op == OpVarKill || v.Op == OpVarLive || (v.Op == OpVarDef && !v.Aux.(*ir.Name).Type().HasPointers()) {
 					// These ops don't really change memory.
 					continue
 					// Note: OpVarDef requires that the defined variable not have pointers.
diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go
index 376ca97512..8c25b1c81d 100644
--- a/src/cmd/compile/internal/ssa/regalloc.go
+++ b/src/cmd/compile/internal/ssa/regalloc.go
@@ -1249,7 +1249,7 @@ func (s *regAllocState) regalloc(f *Func) {
 					// This forces later liveness analysis to make the
 					// value live at this point.
 					v.SetArg(0, s.makeSpill(a, b))
-				} else if _, ok := a.Aux.(ir.Node); ok && vi.rematerializeable {
+				} else if _, ok := a.Aux.(*ir.Name); ok && vi.rematerializeable {
 					// Rematerializeable value with a gc.Node. This is the address of
 					// a stack object (e.g. an LEAQ). Keep the object live.
 					// Change it to VarLive, which is what plive expects for locals.
diff --git a/src/cmd/compile/internal/wasm/ssa.go b/src/cmd/compile/internal/wasm/ssa.go
index e7451381b4..01ba721556 100644
--- a/src/cmd/compile/internal/wasm/ssa.go
+++ b/src/cmd/compile/internal/wasm/ssa.go
@@ -237,7 +237,7 @@ func ssaGenValueOnStack(s *gc.SSAGenState, v *ssa.Value, extend bool) {
 		switch v.Aux.(type) {
 		case *obj.LSym:
 			gc.AddAux(&p.From, v)
-		case ir.Node:
+		case *ir.Name:
 			p.From.Reg = v.Args[0].Reg()
 			gc.AddAux(&p.From, v)
 		default:
-- 
GitLab


From bb31c75343de2114f541cd66870ace3f33047550 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 6 Dec 2020 18:25:41 -0800
Subject: [PATCH 0188/2400] [dev.regabi] cmd/compile: ir.Node is no longer an
 ssa.Aux

After the previous rewrite, we can now remove CanBeAnSSASym and
CanBeAnSSAAux from the generic Node interface, and declare them just
on *ir.Name.

Updates #42982.

Change-Id: I865771fd30c95c009740410844f20ade08648343
Reviewed-on: https://go-review.googlesource.com/c/go/+/275790
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/ir/mini.go | 4 ----
 src/cmd/compile/internal/ir/name.go | 4 +++-
 src/cmd/compile/internal/ir/node.go | 5 -----
 3 files changed, 3 insertions(+), 10 deletions(-)

diff --git a/src/cmd/compile/internal/ir/mini.go b/src/cmd/compile/internal/ir/mini.go
index edb3b197da..7ecdcbf32f 100644
--- a/src/cmd/compile/internal/ir/mini.go
+++ b/src/cmd/compile/internal/ir/mini.go
@@ -197,7 +197,3 @@ func (n *miniNode) SetOpt(interface{})        { panic(n.no("SetOpt")) }
 func (n *miniNode) MarkReadonly()             { panic(n.no("MarkReadonly")) }
 func (n *miniNode) TChanDir() types.ChanDir   { panic(n.no("TChanDir")) }
 func (n *miniNode) SetTChanDir(types.ChanDir) { panic(n.no("SetTChanDir")) }
-
-// TODO: Delete when these are removed from Node itself.
-func (*miniNode) CanBeAnSSASym() {}
-func (*miniNode) CanBeAnSSAAux() {}
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index c527ba281d..319c40e4e9 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -165,7 +165,9 @@ func (n *Name) SetOffset(x int64)   { n.offset = x }
 func (n *Name) Iota() int64         { return n.offset }
 func (n *Name) SetIota(x int64)     { n.offset = x }
 
-func (*Name) CanBeNtype() {}
+func (*Name) CanBeNtype()    {}
+func (*Name) CanBeAnSSASym() {}
+func (*Name) CanBeAnSSAAux() {}
 
 func (n *Name) SetOp(op Op) {
 	if n.op != ONONAME {
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index b878b00546..d6dab0b9e2 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -109,11 +109,6 @@ type Node interface {
 	MarkNonNil()
 	HasCall() bool
 	SetHasCall(x bool)
-
-	// Only for SSA and should be removed when SSA starts
-	// using a more specific type than Node.
-	CanBeAnSSASym()
-	CanBeAnSSAAux()
 }
 
 // Line returns n's position as a string. If n has been inlined,
-- 
GitLab


From dbf2fc8cff5f7d6a5fcbeea0d4b0349cc7d158e2 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 6 Dec 2020 18:28:49 -0800
Subject: [PATCH 0189/2400] [dev.regabi] cmd/compile: replace many uses of
 ir.Node with *ir.Name

This commit adds exactly two "n := n.(*ir.Name)" statements, that are
each immediately preceded by a "case ir.ONAME:" clause in an n.Op()
switch. The rest of the changes are simply replacing "ir.Node" to
"*ir.Name" and removing now unnecessary "n.(*ir.Name)" type
assertions, exposing the latent typing details.

Passes buildall w/ toolstash -cmp.

Updates #42982.

Change-Id: I8ea3bbb7ddf0c7192245cafa49a19c0e7a556a39
Reviewed-on: https://go-review.googlesource.com/c/go/+/275791
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/gc/inl.go        |  5 ++--
 src/cmd/compile/internal/gc/order.go      |  6 ++---
 src/cmd/compile/internal/gc/pgen.go       | 28 +++++++++++-----------
 src/cmd/compile/internal/gc/ssa.go        | 29 ++++++++++++-----------
 src/cmd/compile/internal/ssa/deadstore.go | 10 ++++----
 src/cmd/compile/internal/ssa/debug.go     |  8 +++----
 6 files changed, 44 insertions(+), 42 deletions(-)

diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index f965fa6325..37e5167c25 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -205,7 +205,7 @@ func caninl(fn *ir.Func) {
 	visitor := hairyVisitor{
 		budget:        inlineMaxBudget,
 		extraCallCost: cc,
-		usedLocals:    make(map[ir.Node]bool),
+		usedLocals:    make(map[*ir.Name]bool),
 	}
 	if visitor.tooHairy(fn) {
 		reason = visitor.reason
@@ -292,7 +292,7 @@ type hairyVisitor struct {
 	budget        int32
 	reason        string
 	extraCallCost int32
-	usedLocals    map[ir.Node]bool
+	usedLocals    map[*ir.Name]bool
 	do            func(ir.Node) error
 }
 
@@ -431,6 +431,7 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 		}
 
 	case ir.ONAME:
+		n := n.(*ir.Name)
 		if n.Class() == ir.PAUTO {
 			v.usedLocals[n] = true
 		}
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 39b78c9819..c3645256a6 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -63,7 +63,7 @@ func order(fn *ir.Func) {
 // newTemp allocates a new temporary with the given type,
 // pushes it onto the temp stack, and returns it.
 // If clear is true, newTemp emits code to zero the temporary.
-func (o *Order) newTemp(t *types.Type, clear bool) ir.Node {
+func (o *Order) newTemp(t *types.Type, clear bool) *ir.Name {
 	var v *ir.Name
 	// Note: LongString is close to the type equality we want,
 	// but not exactly. We still need to double-check with types.Identical.
@@ -107,11 +107,11 @@ func (o *Order) copyExpr(n ir.Node) ir.Node {
 // (The other candidate would be map access, but map access
 // returns a pointer to the result data instead of taking a pointer
 // to be filled in.)
-func (o *Order) copyExprClear(n ir.Node) ir.Node {
+func (o *Order) copyExprClear(n ir.Node) *ir.Name {
 	return o.copyExpr1(n, true)
 }
 
-func (o *Order) copyExpr1(n ir.Node, clear bool) ir.Node {
+func (o *Order) copyExpr1(n ir.Node, clear bool) *ir.Name {
 	t := n.Type()
 	v := o.newTemp(t, clear)
 	a := ir.Nod(ir.OAS, v, n)
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index a7b19953ba..5b04e10657 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -438,7 +438,7 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 	// which used to use the ONAME form.
 	isODCLFUNC := infosym.Name == ""
 
-	var apdecls []ir.Node
+	var apdecls []*ir.Name
 	// Populate decls for fn.
 	if isODCLFUNC {
 		for _, n := range fn.Dcl {
@@ -495,7 +495,7 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 	return scopes, inlcalls
 }
 
-func declPos(decl ir.Node) src.XPos {
+func declPos(decl *ir.Name) src.XPos {
 	if decl.Name().Defn != nil && (decl.Name().Captured() || decl.Name().Byval()) {
 		// It's not clear which position is correct for captured variables here:
 		// * decl.Pos is the wrong position for captured variables, in the inner
@@ -518,10 +518,10 @@ func declPos(decl ir.Node) src.XPos {
 
 // createSimpleVars creates a DWARF entry for every variable declared in the
 // function, claiming that they are permanently on the stack.
-func createSimpleVars(fnsym *obj.LSym, apDecls []ir.Node) ([]ir.Node, []*dwarf.Var, map[ir.Node]bool) {
+func createSimpleVars(fnsym *obj.LSym, apDecls []*ir.Name) ([]*ir.Name, []*dwarf.Var, map[*ir.Name]bool) {
 	var vars []*dwarf.Var
-	var decls []ir.Node
-	selected := make(map[ir.Node]bool)
+	var decls []*ir.Name
+	selected := make(map[*ir.Name]bool)
 	for _, n := range apDecls {
 		if ir.IsAutoTmp(n) {
 			continue
@@ -534,7 +534,7 @@ func createSimpleVars(fnsym *obj.LSym, apDecls []ir.Node) ([]ir.Node, []*dwarf.V
 	return decls, vars, selected
 }
 
-func createSimpleVar(fnsym *obj.LSym, n ir.Node) *dwarf.Var {
+func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 	var abbrev int
 	offs := n.Offset()
 
@@ -585,13 +585,13 @@ func createSimpleVar(fnsym *obj.LSym, n ir.Node) *dwarf.Var {
 
 // createComplexVars creates recomposed DWARF vars with location lists,
 // suitable for describing optimized code.
-func createComplexVars(fnsym *obj.LSym, fn *ir.Func) ([]ir.Node, []*dwarf.Var, map[ir.Node]bool) {
+func createComplexVars(fnsym *obj.LSym, fn *ir.Func) ([]*ir.Name, []*dwarf.Var, map[*ir.Name]bool) {
 	debugInfo := fn.DebugInfo.(*ssa.FuncDebug)
 
 	// Produce a DWARF variable entry for each user variable.
-	var decls []ir.Node
+	var decls []*ir.Name
 	var vars []*dwarf.Var
-	ssaVars := make(map[ir.Node]bool)
+	ssaVars := make(map[*ir.Name]bool)
 
 	for varID, dvar := range debugInfo.Vars {
 		n := dvar
@@ -611,11 +611,11 @@ func createComplexVars(fnsym *obj.LSym, fn *ir.Func) ([]ir.Node, []*dwarf.Var, m
 
 // createDwarfVars process fn, returning a list of DWARF variables and the
 // Nodes they represent.
-func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []ir.Node) ([]ir.Node, []*dwarf.Var) {
+func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir.Name) ([]*ir.Name, []*dwarf.Var) {
 	// Collect a raw list of DWARF vars.
 	var vars []*dwarf.Var
-	var decls []ir.Node
-	var selected map[ir.Node]bool
+	var decls []*ir.Name
+	var selected map[*ir.Name]bool
 	if base.Ctxt.Flag_locationlists && base.Ctxt.Flag_optimize && fn.DebugInfo != nil && complexOK {
 		decls, vars, selected = createComplexVars(fnsym, fn)
 	} else {
@@ -714,9 +714,9 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []ir.
 // function that is not local to the package being compiled, then the
 // names of the variables may have been "versioned" to avoid conflicts
 // with local vars; disregard this versioning when sorting.
-func preInliningDcls(fnsym *obj.LSym) []ir.Node {
+func preInliningDcls(fnsym *obj.LSym) []*ir.Name {
 	fn := base.Ctxt.DwFixups.GetPrecursorFunc(fnsym).(*ir.Func)
-	var rdcl []ir.Node
+	var rdcl []*ir.Name
 	for _, n := range fn.Inl.Dcl {
 		c := n.Sym().Name[0]
 		// Avoid reporting "_" parameters, since if there are more than
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index e8f345d8f6..9539e9cc8a 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -410,7 +410,7 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 	}
 
 	// Generate addresses of local declarations
-	s.decladdrs = map[ir.Node]*ssa.Value{}
+	s.decladdrs = map[*ir.Name]*ssa.Value{}
 	var args []ssa.Param
 	var results []ssa.Param
 	for _, n := range fn.Dcl {
@@ -576,7 +576,7 @@ type openDeferInfo struct {
 	// function call are stored.
 	argVals []*ssa.Value
 	// The nodes representing the argtmps where the args of the defer are stored
-	argNodes []ir.Node
+	argNodes []*ir.Name
 }
 
 type state struct {
@@ -613,7 +613,7 @@ type state struct {
 	defvars []map[ir.Node]*ssa.Value
 
 	// addresses of PPARAM and PPARAMOUT variables.
-	decladdrs map[ir.Node]*ssa.Value
+	decladdrs map[*ir.Name]*ssa.Value
 
 	// starting values. Memory, stack pointer, and globals pointer
 	startmem *ssa.Value
@@ -633,7 +633,7 @@ type state struct {
 	panics map[funcLine]*ssa.Block
 
 	// list of PPARAMOUT (return) variables.
-	returns []ir.Node
+	returns []*ir.Name
 
 	cgoUnsafeArgs bool
 	hasdefer      bool // whether the function contains a defer statement
@@ -685,7 +685,7 @@ func (s *state) Fatalf(msg string, args ...interface{}) {
 func (s *state) Warnl(pos src.XPos, msg string, args ...interface{}) { s.f.Warnl(pos, msg, args...) }
 func (s *state) Debug_checknil() bool                                { return s.f.Frontend().Debug_checknil() }
 
-func ssaMarker(name string) ir.Node {
+func ssaMarker(name string) *ir.Name {
 	return NewName(&types.Sym{Name: name})
 }
 
@@ -1571,7 +1571,7 @@ func (s *state) exit() *ssa.Block {
 	for _, n := range s.returns {
 		addr := s.decladdrs[n]
 		val := s.variable(n, n.Type())
-		s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n.(*ir.Name), s.mem())
+		s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
 		s.store(n.Type(), addr, val)
 		// TODO: if val is ever spilled, we'd like to use the
 		// PPARAMOUT slot for spilling it. That won't happen
@@ -4224,7 +4224,7 @@ func (s *state) openDeferRecord(n ir.Node) {
 	s.stmtList(n.List())
 
 	var args []*ssa.Value
-	var argNodes []ir.Node
+	var argNodes []*ir.Name
 
 	opendefer := &openDeferInfo{
 		n: n,
@@ -4467,7 +4467,7 @@ func (s *state) openDeferExit() {
 		}
 		for _, argNode := range r.argNodes {
 			if argNode.Type().HasPointers() {
-				s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, argNode.(*ir.Name), s.mem(), false)
+				s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, argNode, s.mem(), false)
 			}
 		}
 
@@ -4838,6 +4838,7 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 	t := types.NewPtr(n.Type())
 	switch n.Op() {
 	case ir.ONAME:
+		n := n.(*ir.Name)
 		switch n.Class() {
 		case ir.PEXTERN:
 			// global variable
@@ -4855,17 +4856,17 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 			}
 			if n == nodfp {
 				// Special arg that points to the frame pointer (Used by ORECOVER).
-				return s.entryNewValue2A(ssa.OpLocalAddr, t, n.(*ir.Name), s.sp, s.startmem)
+				return s.entryNewValue2A(ssa.OpLocalAddr, t, n, s.sp, s.startmem)
 			}
 			s.Fatalf("addr of undeclared ONAME %v. declared: %v", n, s.decladdrs)
 			return nil
 		case ir.PAUTO:
-			return s.newValue2Apos(ssa.OpLocalAddr, t, n.(*ir.Name), s.sp, s.mem(), !ir.IsAutoTmp(n))
+			return s.newValue2Apos(ssa.OpLocalAddr, t, n, s.sp, s.mem(), !ir.IsAutoTmp(n))
 
 		case ir.PPARAMOUT: // Same as PAUTO -- cannot generate LEA early.
 			// ensure that we reuse symbols for out parameters so
 			// that cse works on their addresses
-			return s.newValue2Apos(ssa.OpLocalAddr, t, n.(*ir.Name), s.sp, s.mem(), true)
+			return s.newValue2Apos(ssa.OpLocalAddr, t, n, s.sp, s.mem(), true)
 		default:
 			s.Fatalf("variable address class %v not implemented", n.Class())
 			return nil
@@ -6196,15 +6197,15 @@ func (s *SSAGenState) DebugFriendlySetPosFrom(v *ssa.Value) {
 	}
 }
 
-// byXoffset implements sort.Interface for []*Node using Xoffset as the ordering.
-type byXoffset []ir.Node
+// byXoffset implements sort.Interface for []*ir.Name using Xoffset as the ordering.
+type byXoffset []*ir.Name
 
 func (s byXoffset) Len() int           { return len(s) }
 func (s byXoffset) Less(i, j int) bool { return s[i].Offset() < s[j].Offset() }
 func (s byXoffset) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 
 func emitStackObjects(e *ssafn, pp *Progs) {
-	var vars []ir.Node
+	var vars []*ir.Name
 	for _, n := range e.curfn.Dcl {
 		if livenessShouldTrack(n) && n.Addrtaken() {
 			vars = append(vars, n)
diff --git a/src/cmd/compile/internal/ssa/deadstore.go b/src/cmd/compile/internal/ssa/deadstore.go
index d0446a0311..a68c82ba97 100644
--- a/src/cmd/compile/internal/ssa/deadstore.go
+++ b/src/cmd/compile/internal/ssa/deadstore.go
@@ -137,9 +137,9 @@ func dse(f *Func) {
 // reaches stores then we delete all the stores. The other operations will then
 // be eliminated by the dead code elimination pass.
 func elimDeadAutosGeneric(f *Func) {
-	addr := make(map[*Value]ir.Node) // values that the address of the auto reaches
-	elim := make(map[*Value]ir.Node) // values that could be eliminated if the auto is
-	used := make(map[ir.Node]bool)   // used autos that must be kept
+	addr := make(map[*Value]*ir.Name) // values that the address of the auto reaches
+	elim := make(map[*Value]*ir.Name) // values that could be eliminated if the auto is
+	used := make(map[*ir.Name]bool)   // used autos that must be kept
 
 	// visit the value and report whether any of the maps are updated
 	visit := func(v *Value) (changed bool) {
@@ -222,7 +222,7 @@ func elimDeadAutosGeneric(f *Func) {
 		}
 
 		// Propagate any auto addresses through v.
-		var node ir.Node
+		var node *ir.Name
 		for _, a := range args {
 			if n, ok := addr[a]; ok && !used[n] {
 				if node == nil {
@@ -299,7 +299,7 @@ func elimUnreadAutos(f *Func) {
 	// Loop over all ops that affect autos taking note of which
 	// autos we need and also stores that we might be able to
 	// eliminate.
-	seen := make(map[ir.Node]bool)
+	seen := make(map[*ir.Name]bool)
 	var stores []*Value
 	for _, b := range f.Blocks {
 		for _, v := range b.Values {
diff --git a/src/cmd/compile/internal/ssa/debug.go b/src/cmd/compile/internal/ssa/debug.go
index 405817dbe1..68b6ab5fe9 100644
--- a/src/cmd/compile/internal/ssa/debug.go
+++ b/src/cmd/compile/internal/ssa/debug.go
@@ -25,7 +25,7 @@ type FuncDebug struct {
 	// Slots is all the slots used in the debug info, indexed by their SlotID.
 	Slots []LocalSlot
 	// The user variables, indexed by VarID.
-	Vars []ir.Node
+	Vars []*ir.Name
 	// The slots that make up each variable, indexed by VarID.
 	VarSlots [][]SlotID
 	// The location list data, indexed by VarID. Must be processed by PutLocationList.
@@ -166,7 +166,7 @@ func (s *debugState) logf(msg string, args ...interface{}) {
 type debugState struct {
 	// See FuncDebug.
 	slots    []LocalSlot
-	vars     []ir.Node
+	vars     []*ir.Name
 	varSlots [][]SlotID
 	lists    [][]byte
 
@@ -190,7 +190,7 @@ type debugState struct {
 	// The pending location list entry for each user variable, indexed by VarID.
 	pendingEntries []pendingEntry
 
-	varParts           map[ir.Node][]SlotID
+	varParts           map[*ir.Name][]SlotID
 	blockDebug         []BlockDebug
 	pendingSlotLocs    []VarLoc
 	liveSlots          []liveSlot
@@ -347,7 +347,7 @@ func BuildFuncDebug(ctxt *obj.Link, f *Func, loggingEnabled bool, stackOffset fu
 	}
 
 	if state.varParts == nil {
-		state.varParts = make(map[ir.Node][]SlotID)
+		state.varParts = make(map[*ir.Name][]SlotID)
 	} else {
 		for n := range state.varParts {
 			delete(state.varParts, n)
-- 
GitLab


From 14dc2d23456b3affec37e530f71a0987a7051c32 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Fri, 4 Dec 2020 12:39:38 -0500
Subject: [PATCH 0190/2400] [dev.typeparams] go/types: import the Type API from
 dev.go2go

Import the Type changes from the dev.go2go branch, as well as a minimal
set of related changes to the Checker code so that tests pass. This
involved making some decisions about which functionality to import, with
some parts of the Type API (for example instance.expand) carved out as
they pulled in too many additional changes.

Minimal changes were made from the dev.go2go version. Notably:
 + The aType helper struct is removed. It could have been removed in CL
   274852 but was missed.
 + writeTParamList was cleaned up for the bracketed parameter style.
 + Some interface iteration functions were simplified.

One observation along the way is that, especially with converter methods
removed from the Type interface, we should probably avoid storing the
Checker on Type instances for lazy evaluation. If a function is only
valid during a checking pass, we should make it a method on Checker
instead of a method on the Type instance. Rather than do this now, which
would make later changes harder to import, I left a couple TODOs to
address this later.

Change-Id: Ie669224614269874474d87e46c68216cb06b6d0e
Reviewed-on: https://go-review.googlesource.com/c/go/+/275441
Reviewed-by: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Robert Findley <rfindley@google.com>
---
 .../internal/gccgoimporter/importer_test.go   |   2 +-
 src/go/types/check.go                         |   1 +
 src/go/types/decl.go                          |  57 +-
 src/go/types/expr.go                          |   2 +-
 src/go/types/lookup.go                        |   8 +-
 src/go/types/predicates.go                    |   9 +-
 src/go/types/type.go                          | 520 ++++++++++++++++--
 src/go/types/typestring.go                    | 187 ++++++-
 src/go/types/typestring_test.go               |   4 +
 src/go/types/typexpr.go                       |  99 +++-
 10 files changed, 785 insertions(+), 104 deletions(-)

diff --git a/src/go/internal/gccgoimporter/importer_test.go b/src/go/internal/gccgoimporter/importer_test.go
index e4236a5867..e42684d107 100644
--- a/src/go/internal/gccgoimporter/importer_test.go
+++ b/src/go/internal/gccgoimporter/importer_test.go
@@ -95,7 +95,7 @@ var importerTests = [...]importerTest{
 	{pkgpath: "nointerface", name: "I", want: "type I int"},
 	{pkgpath: "issue29198", name: "FooServer", gccgoVersion: 7, want: "type FooServer struct{FooServer *FooServer; user string; ctx context.Context}"},
 	{pkgpath: "issue30628", name: "Apple", want: "type Apple struct{hey sync.RWMutex; x int; RQ [517]struct{Count uintptr; NumBytes uintptr; Last uintptr}}"},
-	{pkgpath: "issue31540", name: "S", gccgoVersion: 7, want: "type S struct{b int; map[Y]Z}"},
+	{pkgpath: "issue31540", name: "S", gccgoVersion: 7, want: "type S struct{b int; A2 /* = map[Y]Z */}"},
 	{pkgpath: "issue34182", name: "T1", want: "type T1 struct{f *T2}"},
 	{pkgpath: "notinheap", name: "S", want: "type S struct{}"},
 }
diff --git a/src/go/types/check.go b/src/go/types/check.go
index 5e7bd92076..8d9e9a217e 100644
--- a/src/go/types/check.go
+++ b/src/go/types/check.go
@@ -77,6 +77,7 @@ type Checker struct {
 	fset *token.FileSet
 	pkg  *Package
 	*Info
+	nextId uint64                     // unique Id for type parameters (first valid Id is 1)
 	objMap map[Object]*declInfo       // maps package-level objects and (non-interface) methods to declaration info
 	impMap map[importKey]*Package     // maps (import path, source directory) to (complete or fake) package
 	posMap map[*Interface][]token.Pos // maps interface types to lists of embedded interface positions
diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index 17b66ca387..cd610036b8 100644
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -544,36 +544,35 @@ func (check *Checker) varDecl(obj *Var, lhs []*Var, typ, init ast.Expr) {
 	check.initVars(lhs, []ast.Expr{init}, token.NoPos)
 }
 
-// underlying returns the underlying type of typ; possibly by following
-// forward chains of named types. Such chains only exist while named types
-// are incomplete. If an underlying type is found, resolve the chain by
-// setting the underlying type for each defined type in the chain before
-// returning it.
-//
-// If no underlying type is found, a cycle error is reported and Typ[Invalid]
-// is used as underlying type for each defined type in the chain and returned
-// as result.
-func (check *Checker) underlying(typ Type) Type {
-	// If typ is not a defined type, its underlying type is itself.
-	n0, _ := typ.(*Named)
-	if n0 == nil {
-		return typ // nothing to do
+// under returns the expanded underlying type of n0; possibly by following
+// forward chains of named types. If an underlying type is found, resolve
+// the chain by setting the underlying type for each defined type in the
+// chain before returning it. If no underlying type is found or a cycle
+// is detected, the result is Typ[Invalid]. If a cycle is detected and
+// n0.check != nil, the cycle is reported.
+func (n0 *Named) under() Type {
+	u := n0.underlying
+	if u == nil {
+		return Typ[Invalid]
 	}
 
 	// If the underlying type of a defined type is not a defined
 	// type, then that is the desired underlying type.
-	typ = n0.underlying
-	n, _ := typ.(*Named)
+	n := asNamed(u)
 	if n == nil {
-		return typ // common case
+		return u // common case
 	}
 
 	// Otherwise, follow the forward chain.
 	seen := map[*Named]int{n0: 0}
 	path := []Object{n0.obj}
 	for {
-		typ = n.underlying
-		n1, _ := typ.(*Named)
+		u = n.underlying
+		if u == nil {
+			u = Typ[Invalid]
+			break
+		}
+		n1 := asNamed(u)
 		if n1 == nil {
 			break // end of chain
 		}
@@ -584,8 +583,12 @@ func (check *Checker) underlying(typ Type) Type {
 
 		if i, ok := seen[n]; ok {
 			// cycle
-			check.cycleError(path[i:])
-			typ = Typ[Invalid]
+			// TODO(rFindley) revert this to a method on Checker. Having a possibly
+			// nil Checker on Named and TypeParam is too subtle.
+			if n0.check != nil {
+				n0.check.cycleError(path[i:])
+			}
+			u = Typ[Invalid]
 			break
 		}
 	}
@@ -594,13 +597,14 @@ func (check *Checker) underlying(typ Type) Type {
 		// We should never have to update the underlying type of an imported type;
 		// those underlying types should have been resolved during the import.
 		// Also, doing so would lead to a race condition (was issue #31749).
-		if n.obj.pkg != check.pkg {
+		// Do this check always, not just in debug more (it's cheap).
+		if n0.check != nil && n.obj.pkg != n0.check.pkg {
 			panic("internal error: imported type with unresolved underlying type")
 		}
-		n.underlying = typ
+		n.underlying = u
 	}
 
-	return typ
+	return u
 }
 
 func (n *Named) setUnderlying(typ Type) {
@@ -623,7 +627,7 @@ func (check *Checker) typeDecl(obj *TypeName, typ ast.Expr, def *Named, alias bo
 
 	} else {
 
-		named := &Named{obj: obj}
+		named := &Named{check: check, obj: obj}
 		def.setUnderlying(named)
 		obj.typ = named // make sure recursive type declarations terminate
 
@@ -643,8 +647,7 @@ func (check *Checker) typeDecl(obj *TypeName, typ ast.Expr, def *Named, alias bo
 		// and which has as its underlying type the named type B.
 		// Determine the (final, unnamed) underlying type by resolving
 		// any forward chain.
-		named.underlying = check.underlying(named)
-
+		named.underlying = under(named)
 	}
 
 	check.addMethodDecls(obj)
diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index eb2056125a..51714790cb 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -591,7 +591,7 @@ func (check *Checker) implicitType(x *operand, target Type) Type {
 			return Typ[UntypedNil]
 		}
 		// cannot assign untyped values to non-empty interfaces
-		check.completeInterface(t)
+		check.completeInterface(token.NoPos, t)
 		if !t.Empty() {
 			return nil
 		}
diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go
index 3c9ff182ec..2497843b21 100644
--- a/src/go/types/lookup.go
+++ b/src/go/types/lookup.go
@@ -6,6 +6,8 @@
 
 package types
 
+import "go/token"
+
 // LookupFieldOrMethod looks up a field or method with given package and name
 // in T and returns the corresponding *Var or *Func, an index sequence, and a
 // bool indicating if there were any pointer indirections on the path to the
@@ -175,7 +177,7 @@ func (check *Checker) rawLookupFieldOrMethod(T Type, addressable bool, pkg *Pack
 			case *Interface:
 				// look for a matching method
 				// TODO(gri) t.allMethods is sorted - use binary search
-				check.completeInterface(t)
+				check.completeInterface(token.NoPos, t)
 				if i, m := lookupMethod(t.allMethods, pkg, name); m != nil {
 					assert(m.typ != nil)
 					index = concat(e.index, i)
@@ -276,7 +278,7 @@ func MissingMethod(V Type, T *Interface, static bool) (method *Func, wrongType b
 // To improve error messages, also report the wrong signature
 // when the method exists on *V instead of V.
 func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method, wrongType *Func) {
-	check.completeInterface(T)
+	check.completeInterface(token.NoPos, T)
 
 	// fast path for common case
 	if T.Empty() {
@@ -284,7 +286,7 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
 	}
 
 	if ityp, _ := V.Underlying().(*Interface); ityp != nil {
-		check.completeInterface(ityp)
+		check.completeInterface(token.NoPos, ityp)
 		// TODO(gri) allMethods is sorted - can do this more efficiently
 		for _, m := range T.allMethods {
 			_, obj := lookupMethod(ityp.allMethods, m.pkg, m.name)
diff --git a/src/go/types/predicates.go b/src/go/types/predicates.go
index 057908eacd..a139a4eb09 100644
--- a/src/go/types/predicates.go
+++ b/src/go/types/predicates.go
@@ -6,7 +6,10 @@
 
 package types
 
-import "sort"
+import (
+	"go/token"
+	"sort"
+)
 
 func isNamed(typ Type) bool {
 	if _, ok := typ.(*Basic); ok {
@@ -225,8 +228,8 @@ func (check *Checker) identical0(x, y Type, cmpTags bool, p *ifacePair) bool {
 			// that case, interfaces are expected to be complete and lazy completion
 			// here is not needed.
 			if check != nil {
-				check.completeInterface(x)
-				check.completeInterface(y)
+				check.completeInterface(token.NoPos, x)
+				check.completeInterface(token.NoPos, y)
 			}
 			a := x.allMethods
 			b := y.allMethods
diff --git a/src/go/types/type.go b/src/go/types/type.go
index 087cda429d..e0cff1b976 100644
--- a/src/go/types/type.go
+++ b/src/go/types/type.go
@@ -4,12 +4,18 @@
 
 package types
 
-import "sort"
+import (
+	"fmt"
+	"go/token"
+	"sort"
+)
 
 // A Type represents a type of Go.
 // All types implement the Type interface.
 type Type interface {
-	// Underlying returns the underlying type of a type.
+	// Underlying returns the underlying type of a type
+	// w/o following forwarding chains. Only used by
+	// client packages (here for backward-compatibility).
 	Underlying() Type
 
 	// String returns a string representation of a type.
@@ -98,7 +104,7 @@ type Array struct {
 
 // NewArray returns a new array type for the given element type and length.
 // A negative length indicates an unknown length.
-func NewArray(elem Type, len int64) *Array { return &Array{len, elem} }
+func NewArray(elem Type, len int64) *Array { return &Array{len: len, elem: elem} }
 
 // Len returns the length of array a.
 // A negative result indicates an unknown length.
@@ -113,7 +119,7 @@ type Slice struct {
 }
 
 // NewSlice returns a new slice type for the given element type.
-func NewSlice(elem Type) *Slice { return &Slice{elem} }
+func NewSlice(elem Type) *Slice { return &Slice{elem: elem} }
 
 // Elem returns the element type of slice s.
 func (s *Slice) Elem() Type { return s.elem }
@@ -176,8 +182,10 @@ type Tuple struct {
 // NewTuple returns a new tuple for the given variables.
 func NewTuple(x ...*Var) *Tuple {
 	if len(x) > 0 {
-		return &Tuple{x}
+		return &Tuple{vars: x}
 	}
+	// TODO(gri) Don't represent empty tuples with a (*Tuple)(nil) pointer;
+	//           it's too subtle and causes problems.
 	return nil
 }
 
@@ -199,11 +207,13 @@ type Signature struct {
 	// and store it in the Func Object) because when type-checking a function
 	// literal we call the general type checker which returns a general Type.
 	// We then unpack the *Signature and use the scope for the literal body.
-	scope    *Scope // function scope, present for package-local signatures
-	recv     *Var   // nil if not a method
-	params   *Tuple // (incoming) parameters from left to right; or nil
-	results  *Tuple // (outgoing) results from left to right; or nil
-	variadic bool   // true if the last parameter's type is of the form ...T (or string, for append built-in only)
+	rparams  []*TypeName // receiver type parameters from left to right, or nil
+	tparams  []*TypeName // type parameters from left to right, or nil
+	scope    *Scope      // function scope, present for package-local signatures
+	recv     *Var        // nil if not a method
+	params   *Tuple      // (incoming) parameters from left to right; or nil
+	results  *Tuple      // (outgoing) results from left to right; or nil
+	variadic bool        // true if the last parameter's type is of the form ...T (or string, for append built-in only)
 }
 
 // NewSignature returns a new function type for the given receiver, parameters,
@@ -220,7 +230,7 @@ func NewSignature(recv *Var, params, results *Tuple, variadic bool) *Signature {
 			panic("types.NewSignature: variadic parameter must be of unnamed slice type")
 		}
 	}
-	return &Signature{nil, recv, params, results, variadic}
+	return &Signature{recv: recv, params: params, results: results, variadic: variadic}
 }
 
 // Recv returns the receiver of signature s (if a method), or nil if a
@@ -231,6 +241,12 @@ func NewSignature(recv *Var, params, results *Tuple, variadic bool) *Signature {
 // contain methods whose receiver type is a different interface.
 func (s *Signature) Recv() *Var { return s.recv }
 
+// TParams returns the type parameters of signature s, or nil.
+func (s *Signature) TParams() []*TypeName { return s.tparams }
+
+// SetTParams sets the type parameters of signature s.
+func (s *Signature) SetTParams(tparams []*TypeName) { s.tparams = tparams }
+
 // Params returns the parameters of signature s, or nil.
 func (s *Signature) Params() *Tuple { return s.params }
 
@@ -240,12 +256,89 @@ func (s *Signature) Results() *Tuple { return s.results }
 // Variadic reports whether the signature s is variadic.
 func (s *Signature) Variadic() bool { return s.variadic }
 
+// A Sum represents a set of possible types.
+// Sums are currently used to represent type lists of interfaces
+// and thus the underlying types of type parameters; they are not
+// first class types of Go.
+type Sum struct {
+	types []Type // types are unique
+}
+
+// NewSum returns a new Sum type consisting of the provided
+// types if there are more than one. If there is exactly one
+// type, it returns that type. If the list of types is empty
+// the result is nil.
+func NewSum(types []Type) Type {
+	if len(types) == 0 {
+		return nil
+	}
+
+	// What should happen if types contains a sum type?
+	// Do we flatten the types list? For now we check
+	// and panic. This should not be possible for the
+	// current use case of type lists.
+	// TODO(gri) Come up with the rules for sum types.
+	for _, t := range types {
+		if _, ok := t.(*Sum); ok {
+			panic("sum type contains sum type - unimplemented")
+		}
+	}
+
+	if len(types) == 1 {
+		return types[0]
+	}
+	return &Sum{types: types}
+}
+
+// is reports whether all types in t satisfy pred.
+func (s *Sum) is(pred func(Type) bool) bool {
+	if s == nil {
+		return false
+	}
+	for _, t := range s.types {
+		if !pred(t) {
+			return false
+		}
+	}
+	return true
+}
+
 // An Interface represents an interface type.
 type Interface struct {
 	methods   []*Func // ordered list of explicitly declared methods
+	types     Type    // (possibly a Sum) type declared with a type list (TODO(gri) need better field name)
 	embeddeds []Type  // ordered list of explicitly embedded types
 
 	allMethods []*Func // ordered list of methods declared with or embedded in this interface (TODO(gri): replace with mset)
+	allTypes   Type    // intersection of all embedded and locally declared types  (TODO(gri) need better field name)
+
+	obj Object // type declaration defining this interface; or nil (for better error messages)
+
+}
+
+// unpack unpacks a type into a list of types.
+// TODO(gri) Try to eliminate the need for this function.
+func unpackType(typ Type) []Type {
+	if typ == nil {
+		return nil
+	}
+	if sum := asSum(typ); sum != nil {
+		return sum.types
+	}
+	return []Type{typ}
+}
+
+// is reports whether interface t represents types that all satisfy pred.
+func (t *Interface) is(pred func(Type) bool) bool {
+	if t.allTypes == nil {
+		return false // we must have at least one type! (was bug)
+	}
+	for _, t := range unpackType(t.allTypes) {
+		if !pred(t) {
+			return false
+		}
+	}
+	return true
 }
 
 // emptyInterface represents the empty (completed) interface
@@ -344,8 +437,101 @@ func (t *Interface) assertCompleteness() {
 func (t *Interface) Method(i int) *Func { t.assertCompleteness(); return t.allMethods[i] }
 
 // Empty reports whether t is the empty interface.
-// The interface must have been completed.
-func (t *Interface) Empty() bool { t.assertCompleteness(); return len(t.allMethods) == 0 }
+func (t *Interface) Empty() bool {
+	if t.allMethods != nil {
+		// interface is complete - quick test
+		// A non-nil allTypes may still be empty and represents the bottom type.
+		return len(t.allMethods) == 0 && t.allTypes == nil
+	}
+	return !t.iterate(func(t *Interface) bool {
+		return len(t.methods) > 0 || t.types != nil
+	}, nil)
+}
+
+// HasTypeList reports whether interface t has a type list, possibly from an embedded type.
+func (t *Interface) HasTypeList() bool {
+	if t.allMethods != nil {
+		// interface is complete - quick test
+		return t.allTypes != nil
+	}
+
+	return t.iterate(func(t *Interface) bool {
+		return t.types != nil
+	}, nil)
+}
+
+// IsComparable reports whether interface t is or embeds the predeclared interface "comparable".
+func (t *Interface) IsComparable() bool {
+	if t.allMethods != nil {
+		// interface is complete - quick test
+		_, m := lookupMethod(t.allMethods, nil, "==")
+		return m != nil
+	}
+
+	return t.iterate(func(t *Interface) bool {
+		_, m := lookupMethod(t.methods, nil, "==")
+		return m != nil
+	}, nil)
+}
+
+// IsConstraint reports t.HasTypeList() || t.IsComparable().
+func (t *Interface) IsConstraint() bool {
+	if t.allMethods != nil {
+		// interface is complete - quick test
+		if t.allTypes != nil {
+			return true
+		}
+		_, m := lookupMethod(t.allMethods, nil, "==")
+		return m != nil
+	}
+
+	return t.iterate(func(t *Interface) bool {
+		if t.types != nil {
+			return true
+		}
+		_, m := lookupMethod(t.methods, nil, "==")
+		return m != nil
+	}, nil)
+}
+
+// iterate calls f with t and then with any embedded interface of t, recursively, until f returns true.
+// iterate reports whether any call to f returned true.
+func (t *Interface) iterate(f func(*Interface) bool, seen map[*Interface]bool) bool {
+	if f(t) {
+		return true
+	}
+	for _, e := range t.embeddeds {
+		// e should be an interface but be careful (it may be invalid)
+		if e := asInterface(e); e != nil {
+			// Cyclic interfaces such as "type E interface { E }" are not permitted
+			// but they are still constructed and we need to detect such cycles.
+			if seen[e] {
+				continue
+			}
+			if seen == nil {
+				seen = make(map[*Interface]bool)
+			}
+			seen[e] = true
+			if e.iterate(f, seen) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// isSatisfiedBy reports whether interface t's type list is satisfied by the type typ.
+// If the the type list is empty (absent), typ trivially satisfies the interface.
+// TODO(gri) This is not a great name. Eventually, we should have a more comprehensive
+//           "implements" predicate.
+func (t *Interface) isSatisfiedBy(typ Type) bool {
+	t.Complete()
+	if t.allTypes == nil {
+		return true
+	}
+	types := unpackType(t.allTypes)
+	return includes(types, typ) || includes(types, under(typ))
+}
 
 // Complete computes the interface's method set. It must be called by users of
 // NewInterfaceType and NewInterface after the interface's embedded types are
@@ -379,12 +565,22 @@ func (t *Interface) Complete() *Interface {
 		addMethod(m, true)
 	}
 
+	allTypes := t.types
+
 	for _, typ := range t.embeddeds {
-		typ := typ.Underlying().(*Interface)
-		typ.Complete()
-		for _, m := range typ.allMethods {
+		utyp := under(typ)
+		etyp := asInterface(utyp)
+		if etyp == nil {
+			if utyp != Typ[Invalid] {
+				panic(fmt.Sprintf("%s is not an interface", typ))
+			}
+			continue
+		}
+		etyp.Complete()
+		for _, m := range etyp.allMethods {
 			addMethod(m, false)
 		}
+		allTypes = intersect(allTypes, etyp.allTypes)
 	}
 
 	for i := 0; i < len(todo); i += 2 {
@@ -399,6 +595,7 @@ func (t *Interface) Complete() *Interface {
 		sort.Sort(byUniqueMethodName(methods))
 		t.allMethods = methods
 	}
+	t.allTypes = allTypes
 
 	return t
 }
@@ -410,7 +607,7 @@ type Map struct {
 
 // NewMap returns a new map for the given key and element types.
 func NewMap(key, elem Type) *Map {
-	return &Map{key, elem}
+	return &Map{key: key, elem: elem}
 }
 
 // Key returns the key type of map m.
@@ -437,7 +634,7 @@ const (
 
 // NewChan returns a new channel type for the given direction and element type.
 func NewChan(dir ChanDir, elem Type) *Chan {
-	return &Chan{dir, elem}
+	return &Chan{dir: dir, elem: elem}
 }
 
 // Dir returns the direction of channel c.
@@ -446,13 +643,16 @@ func (c *Chan) Dir() ChanDir { return c.dir }
 // Elem returns the element type of channel c.
 func (c *Chan) Elem() Type { return c.elem }
 
-// A Named represents a named type.
+// A Named represents a named (defined) type.
 type Named struct {
-	info       typeInfo  // for cycle detection
-	obj        *TypeName // corresponding declared object
-	orig       Type      // type (on RHS of declaration) this *Named type is derived of (for cycle reporting)
-	underlying Type      // possibly a *Named during setup; never a *Named once set up completely
-	methods    []*Func   // methods declared for this type (not the method set of this type); signatures are type-checked lazily
+	check      *Checker    // for Named.under implementation
+	info       typeInfo    // for cycle detection
+	obj        *TypeName   // corresponding declared object
+	orig       Type        // type (on RHS of declaration) this *Named type is derived of (for cycle reporting)
+	underlying Type        // possibly a *Named during setup; never a *Named once set up completely
+	tparams    []*TypeName // type parameters, or nil
+	targs      []Type      // type arguments (after instantiation), or nil
+	methods    []*Func     // methods declared for this type (not the method set of this type); signatures are type-checked lazily
 }
 
 // NewNamed returns a new named type for the given type name, underlying type, and associated methods.
@@ -472,6 +672,19 @@ func NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named {
 // Obj returns the type name for the named type t.
 func (t *Named) Obj() *TypeName { return t.obj }
 
+// TODO(gri) Come up with a better representation and API to distinguish
+//           between parameterized instantiated and non-instantiated types.
+
+// TParams returns the type parameters of the named type t, or nil.
+// The result is non-nil for an (originally) parameterized type even if it is instantiated.
+func (t *Named) TParams() []*TypeName { return t.tparams }
+
+// TArgs returns the type arguments after instantiation of the named type t, or nil if not instantiated.
+func (t *Named) TArgs() []Type { return t.targs }
+
+// SetTArgs sets the type arguments of Named.
+func (t *Named) SetTArgs(args []Type) { t.targs = args }
+
 // NumMethods returns the number of explicit methods whose receiver is named type t.
 func (t *Named) NumMethods() int { return len(t.methods) }
 
@@ -496,28 +709,251 @@ func (t *Named) AddMethod(m *Func) {
 	}
 }
 
-// Implementations for Type methods.
+// A TypeParam represents a type parameter type.
+type TypeParam struct {
+	check *Checker  // for lazy type bound completion
+	id    uint64    // unique id
+	ptr   bool      // pointer designation
+	obj   *TypeName // corresponding type name
+	index int       // parameter index
+	bound Type      // *Named or *Interface; underlying type is always *Interface
+}
+
+// NewTypeParam returns a new TypeParam.
+func (check *Checker) NewTypeParam(ptr bool, obj *TypeName, index int, bound Type) *TypeParam {
+	assert(bound != nil)
+	typ := &TypeParam{check: check, id: check.nextId, ptr: ptr, obj: obj, index: index, bound: bound}
+	check.nextId++
+	if obj.typ == nil {
+		obj.typ = typ
+	}
+	return typ
+}
+
+func (t *TypeParam) Bound() *Interface {
+	iface := asInterface(t.bound)
+	// use the type bound position if we have one
+	pos := token.NoPos
+	if n, _ := t.bound.(*Named); n != nil {
+		pos = n.obj.pos
+	}
+	// TODO(rFindley) switch this to an unexported method on Checker.
+	t.check.completeInterface(pos, iface)
+	return iface
+}
 
-func (b *Basic) Underlying() Type     { return b }
-func (a *Array) Underlying() Type     { return a }
-func (s *Slice) Underlying() Type     { return s }
-func (s *Struct) Underlying() Type    { return s }
-func (p *Pointer) Underlying() Type   { return p }
+// optype returns a type's operational type. Except for
+// type parameters, the operational type is the same
+// as the underlying type (as returned by under). For
+// Type parameters, the operational type is determined
+// by the corresponding type bound's type list. The
+// result may be the bottom or top type, but it is never
+// the incoming type parameter.
+func optype(typ Type) Type {
+	if t := asTypeParam(typ); t != nil {
+		// If the optype is typ, return the top type as we have
+		// no information. It also prevents infinite recursion
+		// via the asTypeParam converter function. This can happen
+		// for a type parameter list of the form:
+		// (type T interface { type T }).
+		// See also issue #39680.
+		if u := t.Bound().allTypes; u != nil && u != typ {
+			// u != typ and u is a type parameter => under(u) != typ, so this is ok
+			return under(u)
+		}
+		return theTop
+	}
+	return under(typ)
+}
+
+// An instance represents an instantiated generic type syntactically
+// (without expanding the instantiation). Type instances appear only
+// during type-checking and are replaced by their fully instantiated
+// (expanded) types before the end of type-checking.
+type instance struct {
+	check   *Checker    // for lazy instantiation
+	pos     token.Pos   // position of type instantiation; for error reporting only
+	base    *Named      // parameterized type to be instantiated
+	targs   []Type      // type arguments
+	poslist []token.Pos // position of each targ; for error reporting only
+	value   Type        // base(targs...) after instantiation or Typ[Invalid]; nil if not yet set
+}
+
+// expand returns the instantiated (= expanded) type of t.
+// The result is either an instantiated *Named type, or
+// Typ[Invalid] if there was an error.
+func (t *instance) expand() Type {
+	// TODO(rFindley) add this in a follow-up CL.
+	panic("not implemented")
+}
+
+// expand expands a type instance into its instantiated
+// type and leaves all other types alone. expand does
+// not recurse.
+func expand(typ Type) Type {
+	if t, _ := typ.(*instance); t != nil {
+		return t.expand()
+	}
+	return typ
+}
+
+// expandf is set to expand.
+// Call expandf when calling expand causes compile-time cycle error.
+var expandf func(Type) Type
+
+func init() { expandf = expand }
+
+// bottom represents the bottom of the type lattice.
+// It is the underlying type of a type parameter that
+// cannot be satisfied by any type, usually because
+// the intersection of type constraints left nothing).
+type bottom struct{}
+
+// theBottom is the singleton bottom type.
+var theBottom = &bottom{}
+
+// top represents the top of the type lattice.
+// It is the underlying type of a type parameter that
+// can be satisfied by any type (ignoring methods),
+// usually because the type constraint has no type
+// list.
+type top struct{}
+
+// theTop is the singleton top type.
+var theTop = &top{}
+
+// Type-specific implementations of Underlying.
+func (t *Basic) Underlying() Type     { return t }
+func (t *Array) Underlying() Type     { return t }
+func (t *Slice) Underlying() Type     { return t }
+func (t *Struct) Underlying() Type    { return t }
+func (t *Pointer) Underlying() Type   { return t }
 func (t *Tuple) Underlying() Type     { return t }
-func (s *Signature) Underlying() Type { return s }
+func (t *Signature) Underlying() Type { return t }
+func (t *Sum) Underlying() Type       { return t }
 func (t *Interface) Underlying() Type { return t }
-func (m *Map) Underlying() Type       { return m }
-func (c *Chan) Underlying() Type      { return c }
+func (t *Map) Underlying() Type       { return t }
+func (t *Chan) Underlying() Type      { return t }
 func (t *Named) Underlying() Type     { return t.underlying }
-
-func (b *Basic) String() string     { return TypeString(b, nil) }
-func (a *Array) String() string     { return TypeString(a, nil) }
-func (s *Slice) String() string     { return TypeString(s, nil) }
-func (s *Struct) String() string    { return TypeString(s, nil) }
-func (p *Pointer) String() string   { return TypeString(p, nil) }
+func (t *TypeParam) Underlying() Type { return t }
+func (t *instance) Underlying() Type  { return t }
+func (t *bottom) Underlying() Type    { return t }
+func (t *top) Underlying() Type       { return t }
+
+// Type-specific implementations of String.
+func (t *Basic) String() string     { return TypeString(t, nil) }
+func (t *Array) String() string     { return TypeString(t, nil) }
+func (t *Slice) String() string     { return TypeString(t, nil) }
+func (t *Struct) String() string    { return TypeString(t, nil) }
+func (t *Pointer) String() string   { return TypeString(t, nil) }
 func (t *Tuple) String() string     { return TypeString(t, nil) }
-func (s *Signature) String() string { return TypeString(s, nil) }
+func (t *Signature) String() string { return TypeString(t, nil) }
+func (t *Sum) String() string       { return TypeString(t, nil) }
 func (t *Interface) String() string { return TypeString(t, nil) }
-func (m *Map) String() string       { return TypeString(m, nil) }
-func (c *Chan) String() string      { return TypeString(c, nil) }
+func (t *Map) String() string       { return TypeString(t, nil) }
+func (t *Chan) String() string      { return TypeString(t, nil) }
 func (t *Named) String() string     { return TypeString(t, nil) }
+func (t *TypeParam) String() string { return TypeString(t, nil) }
+func (t *instance) String() string  { return TypeString(t, nil) }
+func (t *bottom) String() string    { return TypeString(t, nil) }
+func (t *top) String() string       { return TypeString(t, nil) }
+
+// under returns the true expanded underlying type.
+// If it doesn't exist, the result is Typ[Invalid].
+// under must only be called when a type is known
+// to be fully set up.
+func under(t Type) Type {
+	// TODO(gri) is this correct for *Sum?
+	if n := asNamed(t); n != nil {
+		return n.under()
+	}
+	return t
+}
+
+// Converters
+//
+// A converter must only be called when a type is
+// known to be fully set up. A converter returns
+// a type's operational type (see comment for optype)
+// or nil if the type argument is not of the
+// respective type.
+
+func asBasic(t Type) *Basic {
+	op, _ := optype(t).(*Basic)
+	return op
+}
+
+func asArray(t Type) *Array {
+	op, _ := optype(t).(*Array)
+	return op
+}
+
+func asSlice(t Type) *Slice {
+	op, _ := optype(t).(*Slice)
+	return op
+}
+
+// TODO (rFindley) delete this on the dev.typeparams branch. This is only
+// exported in the prototype for legacy compatibility.
+func AsStruct(t Type) *Struct {
+	return asStruct(t)
+}
+
+func asStruct(t Type) *Struct {
+	op, _ := optype(t).(*Struct)
+	return op
+}
+
+// TODO(rFindley) delete this on the dev.typeparams branch (see ToStruct).
+func AsPointer(t Type) *Pointer {
+	return asPointer(t)
+}
+
+func asPointer(t Type) *Pointer {
+	op, _ := optype(t).(*Pointer)
+	return op
+}
+
+func asTuple(t Type) *Tuple {
+	op, _ := optype(t).(*Tuple)
+	return op
+}
+
+func asSignature(t Type) *Signature {
+	op, _ := optype(t).(*Signature)
+	return op
+}
+
+func asSum(t Type) *Sum {
+	op, _ := optype(t).(*Sum)
+	return op
+}
+
+func asInterface(t Type) *Interface {
+	op, _ := optype(t).(*Interface)
+	return op
+}
+
+func asMap(t Type) *Map {
+	op, _ := optype(t).(*Map)
+	return op
+}
+
+func asChan(t Type) *Chan {
+	op, _ := optype(t).(*Chan)
+	return op
+}
+
+// If the argument to asNamed and asTypeParam is of the respective types
+// (possibly after expanding an instance type), these methods return that type.
+// Otherwise the result is nil.
+
+func asNamed(t Type) *Named {
+	e, _ := expand(t).(*Named)
+	return e
+}
+
+func asTypeParam(t Type) *TypeParam {
+	u, _ := under(t).(*TypeParam)
+	return u
+}
diff --git a/src/go/types/typestring.go b/src/go/types/typestring.go
index 31c572f83b..c82fa3395b 100644
--- a/src/go/types/typestring.go
+++ b/src/go/types/typestring.go
@@ -9,6 +9,7 @@ package types
 import (
 	"bytes"
 	"fmt"
+	"unicode/utf8"
 )
 
 // A Qualifier controls how named package-level objects are printed in
@@ -75,6 +76,10 @@ func WriteType(buf *bytes.Buffer, typ Type, qf Qualifier) {
 	writeType(buf, typ, qf, make([]Type, 0, 8))
 }
 
+// instanceMarker is the prefix for an instantiated type
+// in "non-evaluated" instance form.
+const instanceMarker = '#'
+
 func writeType(buf *bytes.Buffer, typ Type, qf Qualifier, visited []Type) {
 	// Theoretically, this is a quadratic lookup algorithm, but in
 	// practice deeply nested composite types with unnamed component
@@ -82,7 +87,7 @@ func writeType(buf *bytes.Buffer, typ Type, qf Qualifier, visited []Type) {
 	// using a map.
 	for _, t := range visited {
 		if t == typ {
-			fmt.Fprintf(buf, "○%T", typ) // cycle to typ
+			fmt.Fprintf(buf, "○%T", goTypeName(typ)) // cycle to typ
 			return
 		}
 	}
@@ -121,11 +126,19 @@ func writeType(buf *bytes.Buffer, typ Type, qf Qualifier, visited []Type) {
 			if i > 0 {
 				buf.WriteString("; ")
 			}
-			if !f.embedded {
-				buf.WriteString(f.name)
+			buf.WriteString(f.name)
+			if f.embedded {
+				// emphasize that the embedded field's name
+				// doesn't match the field's type name
+				if f.name != embeddedFieldName(f.typ) {
+					buf.WriteString(" /* = ")
+					writeType(buf, f.typ, qf, visited)
+					buf.WriteString(" */")
+				}
+			} else {
 				buf.WriteByte(' ')
+				writeType(buf, f.typ, qf, visited)
 			}
-			writeType(buf, f.typ, qf, visited)
 			if tag := t.Tag(i); tag != "" {
 				fmt.Fprintf(buf, " %q", tag)
 			}
@@ -143,6 +156,14 @@ func writeType(buf *bytes.Buffer, typ Type, qf Qualifier, visited []Type) {
 		buf.WriteString("func")
 		writeSignature(buf, t, qf, visited)
 
+	case *Sum:
+		for i, t := range t.types {
+			if i > 0 {
+				buf.WriteString(", ")
+			}
+			writeType(buf, t, qf, visited)
+		}
+
 	case *Interface:
 		// We write the source-level methods and embedded types rather
 		// than the actual method set since resolved method signatures
@@ -168,6 +189,13 @@ func writeType(buf *bytes.Buffer, typ Type, qf Qualifier, visited []Type) {
 				writeSignature(buf, m.typ.(*Signature), qf, visited)
 				empty = false
 			}
+			if !empty && t.allTypes != nil {
+				buf.WriteString("; ")
+			}
+			if t.allTypes != nil {
+				buf.WriteString("type ")
+				writeType(buf, t.allTypes, qf, visited)
+			}
 		} else {
 			// print explicit interface methods and embedded types
 			for i, m := range t.methods {
@@ -178,8 +206,19 @@ func writeType(buf *bytes.Buffer, typ Type, qf Qualifier, visited []Type) {
 				writeSignature(buf, m.typ.(*Signature), qf, visited)
 				empty = false
 			}
+			if !empty && t.types != nil {
+				buf.WriteString("; ")
+			}
+			if t.types != nil {
+				buf.WriteString("type ")
+				writeType(buf, t.types, qf, visited)
+				empty = false
+			}
+			if !empty && len(t.embeddeds) > 0 {
+				buf.WriteString("; ")
+			}
 			for i, typ := range t.embeddeds {
-				if i > 0 || len(t.methods) > 0 {
+				if i > 0 {
 					buf.WriteString("; ")
 				}
 				writeType(buf, typ, qf, visited)
@@ -227,17 +266,36 @@ func writeType(buf *bytes.Buffer, typ Type, qf Qualifier, visited []Type) {
 		}
 
 	case *Named:
-		s := "<Named w/o object>"
-		if obj := t.obj; obj != nil {
-			if obj.pkg != nil {
-				writePackage(buf, obj.pkg, qf)
-			}
-			// TODO(gri): function-local named types should be displayed
-			// differently from named types at package level to avoid
-			// ambiguity.
-			s = obj.name
+		writeTypeName(buf, t.obj, qf)
+		if t.targs != nil {
+			// instantiated type
+			buf.WriteByte('[')
+			writeTypeList(buf, t.targs, qf, visited)
+			buf.WriteByte(']')
+		} else if t.tparams != nil {
+			// parameterized type
+			writeTParamList(buf, t.tparams, qf, visited)
 		}
-		buf.WriteString(s)
+
+	case *TypeParam:
+		s := "?"
+		if t.obj != nil {
+			s = t.obj.name
+		}
+		buf.WriteString(s + subscript(t.id))
+
+	case *instance:
+		buf.WriteByte(instanceMarker) // indicate "non-evaluated" syntactic instance
+		writeTypeName(buf, t.base.obj, qf)
+		buf.WriteByte('[')
+		writeTypeList(buf, t.targs, qf, visited)
+		buf.WriteByte(']')
+
+	case *bottom:
+		buf.WriteString("⊥")
+
+	case *top:
+		buf.WriteString("⊤")
 
 	default:
 		// For externally defined implementations of Type.
@@ -245,6 +303,64 @@ func writeType(buf *bytes.Buffer, typ Type, qf Qualifier, visited []Type) {
 	}
 }
 
+func writeTypeList(buf *bytes.Buffer, list []Type, qf Qualifier, visited []Type) {
+	for i, typ := range list {
+		if i > 0 {
+			buf.WriteString(", ")
+		}
+		writeType(buf, typ, qf, visited)
+	}
+}
+
+func writeTParamList(buf *bytes.Buffer, list []*TypeName, qf Qualifier, visited []Type) {
+	buf.WriteString("[")
+	var prev Type
+	for i, p := range list {
+		// TODO(rFindley) support 'any' sugar here.
+		var b Type = &emptyInterface
+		if t, _ := p.typ.(*TypeParam); t != nil && t.bound != nil {
+			b = t.bound
+		}
+		if i > 0 {
+			if b != prev {
+				// type bound changed - write previous one before advancing
+				buf.WriteByte(' ')
+				writeType(buf, prev, qf, visited)
+			}
+			buf.WriteString(", ")
+		}
+		prev = b
+
+		if t, _ := p.typ.(*TypeParam); t != nil {
+			if t.ptr {
+				buf.WriteByte('*')
+			}
+			writeType(buf, t, qf, visited)
+		} else {
+			buf.WriteString(p.name)
+		}
+	}
+	if prev != nil {
+		buf.WriteByte(' ')
+		writeType(buf, prev, qf, visited)
+	}
+	buf.WriteByte(']')
+}
+
+func writeTypeName(buf *bytes.Buffer, obj *TypeName, qf Qualifier) {
+	s := "<Named w/o object>"
+	if obj != nil {
+		if obj.pkg != nil {
+			writePackage(buf, obj.pkg, qf)
+		}
+		// TODO(gri): function-local named types should be displayed
+		// differently from named types at package level to avoid
+		// ambiguity.
+		s = obj.name
+	}
+	buf.WriteString(s)
+}
+
 func writeTuple(buf *bytes.Buffer, tup *Tuple, variadic bool, qf Qualifier, visited []Type) {
 	buf.WriteByte('(')
 	if tup != nil {
@@ -264,7 +380,7 @@ func writeTuple(buf *bytes.Buffer, tup *Tuple, variadic bool, qf Qualifier, visi
 				} else {
 					// special case:
 					// append(s, "foo"...) leads to signature func([]byte, string...)
-					if t, ok := typ.Underlying().(*Basic); !ok || t.kind != String {
+					if t := asBasic(typ); t == nil || t.kind != String {
 						panic("internal error: string type expected")
 					}
 					writeType(buf, typ, qf, visited)
@@ -287,6 +403,10 @@ func WriteSignature(buf *bytes.Buffer, sig *Signature, qf Qualifier) {
 }
 
 func writeSignature(buf *bytes.Buffer, sig *Signature, qf Qualifier, visited []Type) {
+	if sig.tparams != nil {
+		writeTParamList(buf, sig.tparams, qf, visited)
+	}
+
 	writeTuple(buf, sig.params, sig.variadic, qf, visited)
 
 	n := sig.results.Len()
@@ -305,3 +425,38 @@ func writeSignature(buf *bytes.Buffer, sig *Signature, qf Qualifier, visited []T
 	// multiple or named result(s)
 	writeTuple(buf, sig.results, false, qf, visited)
 }
+
+// embeddedFieldName returns an embedded field's name given its type.
+// The result is "" if the type doesn't have an embedded field name.
+func embeddedFieldName(typ Type) string {
+	switch t := typ.(type) {
+	case *Basic:
+		return t.name
+	case *Named:
+		return t.obj.name
+	case *Pointer:
+		// *T is ok, but **T is not
+		if _, ok := t.base.(*Pointer); !ok {
+			return embeddedFieldName(t.base)
+		}
+	case *instance:
+		return t.base.obj.name
+	}
+	return "" // not a (pointer to) a defined type
+}
+
+// subscript returns the decimal (utf8) representation of x using subscript digits.
+func subscript(x uint64) string {
+	const w = len("₀") // all digits 0...9 have the same utf8 width
+	var buf [32 * w]byte
+	i := len(buf)
+	for {
+		i -= w
+		utf8.EncodeRune(buf[i:], '₀'+rune(x%10)) // '₀' == U+2080
+		x /= 10
+		if x == 0 {
+			break
+		}
+	}
+	return string(buf[i:])
+}
diff --git a/src/go/types/typestring_test.go b/src/go/types/typestring_test.go
index 5d9db39bfc..b16529dc64 100644
--- a/src/go/types/typestring_test.go
+++ b/src/go/types/typestring_test.go
@@ -96,6 +96,10 @@ var independentTestTypes = []testEntry{
 	dup("interface{m()}"),
 	dup(`interface{String() string; m(int) float32}`),
 
+	// TODO(rFindley) uncomment this once this AST is accepted, and add more test
+	// cases.
+	// dup(`interface{type int, float32, complex128}`),
+
 	// maps
 	dup("map[string]int"),
 	{"map[struct{x, y int}][]byte", "map[struct{x int; y int}][]byte"},
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index 2b398010f4..41ba7e9bca 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -7,11 +7,13 @@
 package types
 
 import (
+	"fmt"
 	"go/ast"
 	"go/constant"
 	"go/token"
 	"sort"
 	"strconv"
+	"strings"
 )
 
 // ident type-checks identifier e and initializes x with the value or type of e.
@@ -207,6 +209,12 @@ func (check *Checker) funcType(sig *Signature, recvPar *ast.FieldList, ftyp *ast
 	sig.variadic = variadic
 }
 
+// goTypeName returns the Go type name for typ and
+// removes any occurences of "types." from that name.
+func goTypeName(typ Type) string {
+	return strings.ReplaceAll(fmt.Sprintf("%T", typ), "types.", "")
+}
+
 // typInternal drives type checking of types.
 // Must only be called by definedType.
 //
@@ -498,7 +506,7 @@ func (check *Checker) interfaceType(ityp *Interface, iface *ast.InterfaceType, d
 			// it if it's a valid interface.
 			typ := check.typ(f.Type)
 
-			utyp := check.underlying(typ)
+			utyp := under(typ)
 			if _, ok := utyp.(*Interface); !ok {
 				if utyp != Typ[Invalid] {
 					check.errorf(f.Type, _InvalidIfaceEmbed, "%s is not an interface", typ)
@@ -521,10 +529,10 @@ func (check *Checker) interfaceType(ityp *Interface, iface *ast.InterfaceType, d
 	sort.Sort(byUniqueMethodName(ityp.methods))
 	sort.Stable(byUniqueTypeName(ityp.embeddeds))
 
-	check.later(func() { check.completeInterface(ityp) })
+	check.later(func() { check.completeInterface(iface.Pos(), ityp) })
 }
 
-func (check *Checker) completeInterface(ityp *Interface) {
+func (check *Checker) completeInterface(pos token.Pos, ityp *Interface) {
 	if ityp.allMethods != nil {
 		return
 	}
@@ -538,11 +546,18 @@ func (check *Checker) completeInterface(ityp *Interface) {
 	}
 
 	if trace {
-		check.trace(token.NoPos, "complete %s", ityp)
+		// Types don't generally have position information.
+		// If we don't have a valid pos provided, try to use
+		// one close enough.
+		if !pos.IsValid() && len(ityp.methods) > 0 {
+			pos = ityp.methods[0].pos
+		}
+
+		check.trace(pos, "complete %s", ityp)
 		check.indent++
 		defer func() {
 			check.indent--
-			check.trace(token.NoPos, "=> %s", ityp)
+			check.trace(pos, "=> %s (methods = %v, types = %v)", ityp, ityp.allMethods, ityp.allTypes)
 		}()
 	}
 
@@ -592,25 +607,77 @@ func (check *Checker) completeInterface(ityp *Interface) {
 		addMethod(m.pos, m, true)
 	}
 
+	// collect types
+	allTypes := ityp.types
+
 	posList := check.posMap[ityp]
 	for i, typ := range ityp.embeddeds {
 		pos := posList[i] // embedding position
-		typ, ok := check.underlying(typ).(*Interface)
-		if !ok {
-			// An error was reported when collecting the embedded types.
-			// Ignore it.
+		utyp := under(typ)
+		etyp := asInterface(utyp)
+		if etyp == nil {
+			if utyp != Typ[Invalid] {
+				var format string
+				if _, ok := utyp.(*TypeParam); ok {
+					format = "%s is a type parameter, not an interface"
+				} else {
+					format = "%s is not an interface"
+				}
+				// TODO: correct error code.
+				check.errorf(atPos(pos), 0, format, typ)
+			}
 			continue
 		}
-		check.completeInterface(typ)
-		for _, m := range typ.allMethods {
+		check.completeInterface(pos, etyp)
+		for _, m := range etyp.allMethods {
 			addMethod(pos, m, false) // use embedding position pos rather than m.pos
 		}
+		allTypes = intersect(allTypes, etyp.allTypes)
 	}
 
 	if methods != nil {
 		sort.Sort(byUniqueMethodName(methods))
 		ityp.allMethods = methods
 	}
+	ityp.allTypes = allTypes
+}
+
+// intersect computes the intersection of the types x and y.
+// Note: A incomming nil type stands for the top type. A top
+// type result is returned as nil.
+func intersect(x, y Type) (r Type) {
+	defer func() {
+		if r == theTop {
+			r = nil
+		}
+	}()
+
+	switch {
+	case x == theBottom || y == theBottom:
+		return theBottom
+	case x == nil || x == theTop:
+		return y
+	case y == nil || x == theTop:
+		return x
+	}
+
+	xtypes := unpackType(x)
+	ytypes := unpackType(y)
+	// Compute the list rtypes which includes only
+	// types that are in both xtypes and ytypes.
+	// Quadratic algorithm, but good enough for now.
+	// TODO(gri) fix this
+	var rtypes []Type
+	for _, x := range xtypes {
+		if includes(ytypes, x) {
+			rtypes = append(rtypes, x)
+		}
+	}
+
+	if rtypes == nil {
+		return theBottom
+	}
+	return NewSum(rtypes)
 }
 
 // byUniqueTypeName named type lists can be sorted by their unique type names.
@@ -762,3 +829,13 @@ func embeddedFieldIdent(e ast.Expr) *ast.Ident {
 	}
 	return nil // invalid embedded field
 }
+
+// includes reports whether typ is in list.
+func includes(list []Type, typ Type) bool {
+	for _, e := range list {
+		if Identical(typ, e) {
+			return true
+		}
+	}
+	return false
+}
-- 
GitLab


From b6e678573d33d59309dcbc012ea8db45fde7b9b1 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 8 Dec 2020 11:53:26 -0500
Subject: [PATCH 0191/2400] [dev.typeparams] go/types: import universe changes
 from dev.go2go

This is unmodified from the dev.go2go branch, except to remove the aType
embedding.

Change-Id: Id14d97a56d27ea609c43b453e8f9f1cf1a451406
Reviewed-on: https://go-review.googlesource.com/c/go/+/276252
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/universe.go | 58 +++++++++++++++++++++++++++++++++++-----
 1 file changed, 51 insertions(+), 7 deletions(-)

diff --git a/src/go/types/universe.go b/src/go/types/universe.go
index ff5b89118a..f2f444fd9d 100644
--- a/src/go/types/universe.go
+++ b/src/go/types/universe.go
@@ -24,6 +24,7 @@ var (
 	universeIota  *Const
 	universeByte  *Basic // uint8 alias, but has name "byte"
 	universeRune  *Basic // int32 alias, but has name "rune"
+	universeAny   *Named
 	universeError *Named
 )
 
@@ -77,13 +78,24 @@ func defPredeclaredTypes() {
 		def(NewTypeName(token.NoPos, nil, t.name, t))
 	}
 
+	// any
+	// (Predeclared and entered into universe scope so we do all the
+	// usual checks; but removed again from scope later since it's
+	// only visible as constraint in a type parameter list.)
+	{
+		typ := &Named{underlying: &emptyInterface}
+		def(NewTypeName(token.NoPos, nil, "any", typ))
+	}
+
 	// Error has a nil package in its qualified name since it is in no package
-	res := NewVar(token.NoPos, nil, "", Typ[String])
-	sig := &Signature{results: NewTuple(res)}
-	err := NewFunc(token.NoPos, nil, "Error", sig)
-	typ := &Named{underlying: NewInterfaceType([]*Func{err}, nil).Complete()}
-	sig.recv = NewVar(token.NoPos, nil, "", typ)
-	def(NewTypeName(token.NoPos, nil, "error", typ))
+	{
+		res := NewVar(token.NoPos, nil, "", Typ[String])
+		sig := &Signature{results: NewTuple(res)}
+		err := NewFunc(token.NoPos, nil, "Error", sig)
+		typ := &Named{underlying: NewInterfaceType([]*Func{err}, nil).Complete()}
+		sig.recv = NewVar(token.NoPos, nil, "", typ)
+		def(NewTypeName(token.NoPos, nil, "error", typ))
+	}
 }
 
 var predeclaredConsts = [...]struct {
@@ -188,6 +200,33 @@ func DefPredeclaredTestFuncs() {
 	def(newBuiltin(_Trace))
 }
 
+func defPredeclaredComparable() {
+	// The "comparable" interface can be imagined as defined like
+	//
+	// type comparable interface {
+	//         == () untyped bool
+	//         != () untyped bool
+	// }
+	//
+	// == and != cannot be user-declared but we can declare
+	// a magic method == and check for its presence when needed.
+
+	// Define interface { == () }. We don't care about the signature
+	// for == so leave it empty except for the receiver, which is
+	// set up later to match the usual interface method assumptions.
+	sig := new(Signature)
+	eql := NewFunc(token.NoPos, nil, "==", sig)
+	iface := NewInterfaceType([]*Func{eql}, nil).Complete()
+
+	// set up the defined type for the interface
+	obj := NewTypeName(token.NoPos, nil, "comparable", nil)
+	named := NewNamed(obj, iface, nil)
+	obj.color_ = black
+	sig.recv = NewVar(token.NoPos, nil, "", named) // complete == signature
+
+	def(obj)
+}
+
 func init() {
 	Universe = NewScope(nil, token.NoPos, token.NoPos, "universe")
 	Unsafe = NewPackage("unsafe", "unsafe")
@@ -197,11 +236,16 @@ func init() {
 	defPredeclaredConsts()
 	defPredeclaredNil()
 	defPredeclaredFuncs()
+	defPredeclaredComparable()
 
 	universeIota = Universe.Lookup("iota").(*Const)
 	universeByte = Universe.Lookup("byte").(*TypeName).typ.(*Basic)
 	universeRune = Universe.Lookup("rune").(*TypeName).typ.(*Basic)
+	universeAny = Universe.Lookup("any").(*TypeName).typ.(*Named)
 	universeError = Universe.Lookup("error").(*TypeName).typ.(*Named)
+
+	// "any" is only visible as constraint in a type parameter list
+	delete(Universe.elems, "any")
 }
 
 // Objects with names containing blanks are internal and not entered into
@@ -215,7 +259,7 @@ func def(obj Object) {
 		return // nothing to do
 	}
 	// fix Obj link for named types
-	if typ, ok := obj.Type().(*Named); ok {
+	if typ := asNamed(obj.Type()); typ != nil {
 		typ.obj = obj.(*TypeName)
 	}
 	// exported identifiers go into package unsafe
-- 
GitLab


From 6015c4e543bcf07c01a4221ecf7692162653fa24 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 8 Dec 2020 15:01:32 -0500
Subject: [PATCH 0192/2400] [dev.typeparams] go/*: add TODOs from CLs importing
 dev.go2go changes

With the plurality of CLs importing dev.go2go changes it's getting hard
to track all of the code review comments that were deferred for later
consideration. Add some TODOs to capture these comments in the source,
so that they may be more easily located.

Change-Id: I5caf085fec11ca8992b7affe6feb0a7aa202f21f
Reviewed-on: https://go-review.googlesource.com/c/go/+/276254
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/ast/ast.go          | 6 +++++-
 src/go/parser/parser.go    | 3 ++-
 src/go/types/typestring.go | 1 +
 3 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/go/ast/ast.go b/src/go/ast/ast.go
index 8195ec022f..2456020c5e 100644
--- a/src/go/ast/ast.go
+++ b/src/go/ast/ast.go
@@ -372,7 +372,9 @@ type (
 		Args     []Expr    // function arguments; or nil
 		Ellipsis token.Pos // position of "..." (token.NoPos if there is no "...")
 		Rparen   token.Pos // position of ")"
-		Brackets bool      // if set, "[" and "]" are used instead of "(" and ")"
+		// TODO(rFindley) use a new ListExpr type rather than overloading CallExpr
+		//                via Brackets, as is done in the syntax package
+		Brackets bool // if set, "[" and "]" are used instead of "(" and ")"
 	}
 
 	// A StarExpr node represents an expression of the form "*" Expression.
@@ -987,6 +989,8 @@ type (
 		Name *Ident        // function/method name
 		Type *FuncType     // function signature: type and value parameters, results, and position of "func" keyword
 		Body *BlockStmt    // function body; or nil for external (non-Go) function
+		// TODO(rFindley) consider storing TParams here, rather than FuncType, as
+		//                they are only valid for declared functions
 	}
 )
 
diff --git a/src/go/parser/parser.go b/src/go/parser/parser.go
index 9c414c411e..24e84d5103 100644
--- a/src/go/parser/parser.go
+++ b/src/go/parser/parser.go
@@ -798,7 +798,7 @@ func (p *parser) parseFieldDecl(scope *ast.Scope) *ast.Field {
 	} else {
 		// embedded, possibly generic type
 		// (using the enclosing parentheses to distinguish it from a named field declaration)
-		// TODO(gri) confirm that this doesn't allow parenthesized embedded type
+		// TODO(rFindley) confirm that this doesn't allow parenthesized embedded type
 		typ = p.parseType()
 	}
 
@@ -870,6 +870,7 @@ type field struct {
 }
 
 func (p *parser) parseParamDecl(name *ast.Ident) (f field) {
+	// TODO(rFindley) compare with parser.paramDeclOrNil in the syntax package
 	if p.trace {
 		defer un(trace(p, "ParamDeclOrNil"))
 	}
diff --git a/src/go/types/typestring.go b/src/go/types/typestring.go
index c82fa3395b..b9c227d460 100644
--- a/src/go/types/typestring.go
+++ b/src/go/types/typestring.go
@@ -313,6 +313,7 @@ func writeTypeList(buf *bytes.Buffer, list []Type, qf Qualifier, visited []Type)
 }
 
 func writeTParamList(buf *bytes.Buffer, list []*TypeName, qf Qualifier, visited []Type) {
+	// TODO(rFindley) compare this with the corresponding implementation in types2
 	buf.WriteString("[")
 	var prev Type
 	for i, p := range list {
-- 
GitLab


From c32566c336519f378c07575b0149507a261032e9 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 8 Dec 2020 16:58:00 -0800
Subject: [PATCH 0193/2400] [dev.typeparams] cmd/compile/internal/types2: avoid
 endless recursion in Comparable predicate

Use a map to detect recursive types.
With this we can now typecheck fixedbugs/issue8501.go.

Updates #43088.

Change-Id: I7fad6ccf6c94268473ff72b09a3158e13a7f4cc3
Reviewed-on: https://go-review.googlesource.com/c/go/+/276374
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 .../compile/internal/types2/issues_test.go    | 25 +++++++++++++++++++
 src/cmd/compile/internal/types2/predicates.go | 17 +++++++++++--
 test/fixedbugs/issue8507.go                   |  2 +-
 test/run.go                                   |  2 --
 4 files changed, 41 insertions(+), 5 deletions(-)

diff --git a/src/cmd/compile/internal/types2/issues_test.go b/src/cmd/compile/internal/types2/issues_test.go
index 6d39f99424..f33b7c4396 100644
--- a/src/cmd/compile/internal/types2/issues_test.go
+++ b/src/cmd/compile/internal/types2/issues_test.go
@@ -531,3 +531,28 @@ func TestIssue34921(t *testing.T) {
 		pkg = res // res is imported by the next package in this test
 	}
 }
+
+func TestIssue43088(t *testing.T) {
+	// type T1 struct {
+	//         x T2
+	// }
+	//
+	// type T2 struct {
+	//         x struct {
+	//                 x T2
+	//         }
+	// }
+	n1 := NewTypeName(syntax.Pos{}, nil, "T1", nil)
+	T1 := NewNamed(n1, nil, nil)
+	n2 := NewTypeName(syntax.Pos{}, nil, "T2", nil)
+	T2 := NewNamed(n2, nil, nil)
+	s1 := NewStruct([]*Var{NewField(syntax.Pos{}, nil, "x", T2, false)}, nil)
+	T1.SetUnderlying(s1)
+	s2 := NewStruct([]*Var{NewField(syntax.Pos{}, nil, "x", T2, false)}, nil)
+	s3 := NewStruct([]*Var{NewField(syntax.Pos{}, nil, "x", s2, false)}, nil)
+	T2.SetUnderlying(s3)
+
+	// These calls must terminate (no endless recursion).
+	Comparable(T1)
+	Comparable(T2)
+}
diff --git a/src/cmd/compile/internal/types2/predicates.go b/src/cmd/compile/internal/types2/predicates.go
index f3a5818b3f..048519471c 100644
--- a/src/cmd/compile/internal/types2/predicates.go
+++ b/src/cmd/compile/internal/types2/predicates.go
@@ -87,6 +87,11 @@ func IsInterface(typ Type) bool {
 
 // Comparable reports whether values of type T are comparable.
 func Comparable(T Type) bool {
+	return comparable(T, nil)
+}
+
+// comparable should only be called by Comparable.
+func comparable(T Type, seen map[Type]bool) bool {
 	// If T is a type parameter not constraint by any type
 	// list (i.e., it's underlying type is the top type),
 	// T is comparable if it has the == method. Otherwise,
@@ -99,6 +104,14 @@ func Comparable(T Type) bool {
 		return t.Bound().IsComparable()
 	}
 
+	if seen[T] {
+		return true
+	}
+	if seen == nil {
+		seen = make(map[Type]bool)
+	}
+	seen[T] = true
+
 	switch t := optype(T.Under()).(type) {
 	case *Basic:
 		// assume invalid types to be comparable
@@ -108,13 +121,13 @@ func Comparable(T Type) bool {
 		return true
 	case *Struct:
 		for _, f := range t.fields {
-			if !Comparable(f.typ) {
+			if !comparable(f.typ, seen) {
 				return false
 			}
 		}
 		return true
 	case *Array:
-		return Comparable(t.elem)
+		return comparable(t.elem, seen)
 	case *Sum:
 		return t.is(Comparable)
 	case *TypeParam:
diff --git a/test/fixedbugs/issue8507.go b/test/fixedbugs/issue8507.go
index ad6ba8ac68..277b3dc721 100644
--- a/test/fixedbugs/issue8507.go
+++ b/test/fixedbugs/issue8507.go
@@ -9,7 +9,7 @@
 
 package p
 
-type T struct{ T } // ERROR "invalid recursive type T"
+type T struct{ T } // ERROR "invalid recursive type T|cycle"
 
 func f() {
 	println(T{} == T{})
diff --git a/test/run.go b/test/run.go
index a3e2ac5e32..32c74e8210 100644
--- a/test/run.go
+++ b/test/run.go
@@ -2130,6 +2130,4 @@ var excluded = map[string]bool{
 	"fixedbugs/issue7525e.go":  true,
 	"fixedbugs/issue7742.go":   true, // type-checking doesn't terminate
 	"fixedbugs/issue7746.go":   true, // type-checking doesn't terminate
-	"fixedbugs/issue8501.go":   true, // crashes
-	"fixedbugs/issue8507.go":   true, // crashes
 }
-- 
GitLab


From e2d278bfeb2f0f117efc50b3f0f9dcb086a45ed2 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 7 Dec 2020 15:26:24 -0500
Subject: [PATCH 0194/2400] [dev.regabi] cmd/compile: two small fixes

Addressing comments from CL 275434 and CL 275444.
I forgot to run "git rw" to rebase the fixup CLs down before
running "git submit".

Change-Id: Ideaa2340a81511491c096555c6834cd9bdb267d8
Reviewed-on: https://go-review.googlesource.com/c/go/+/275881
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/mknode.go | 2 +-
 src/cmd/compile/internal/ir/stmt.go   | 7 ++++++-
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/ir/mknode.go b/src/cmd/compile/internal/ir/mknode.go
index 978b2de5a5..72034022cb 100644
--- a/src/cmd/compile/internal/ir/mknode.go
+++ b/src/cmd/compile/internal/ir/mknode.go
@@ -144,7 +144,7 @@ func forNodeFields(typName string, typ *types.Struct, f func(name string, is fun
 			if strings.ToLower(strings.TrimSuffix(v.Name(), "_")) != "body" {
 				continue
 			}
-		case "Name", "Pack":
+		case "Name":
 			continue
 		}
 		switch v.Name() {
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index ccf46dfa73..68f9b0bd7c 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -33,7 +33,12 @@ func (n *Decl) Left() Node     { return n.X }
 func (n *Decl) SetLeft(x Node) { n.X = x }
 
 // A Stmt is a Node that can appear as a statement.
-// This includes statement-like expressions such as <-c and f().
+// This includes statement-like expressions such as f().
+//
+// (It's possible it should include <-c, but that would require
+// splitting ORECV out of UnaryExpr, which hasn't yet been
+// necessary. Maybe instead we will introduce ExprStmt at
+// some point.)
 type Stmt interface {
 	Node
 	isStmt()
-- 
GitLab


From 4090af83c57c857de600ada68e7a27dffd37d8b1 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 6 Dec 2020 15:17:05 -0500
Subject: [PATCH 0195/2400] [dev.regabi] cmd/compile: use reflection in ir.Dump

ir.Dump is the final (I think!) piece of the compiler that was walking
nodes using Left, Right etc without knowing what they meant.
This CL uses reflection to walk nodes without knowing what they mean instead.
One benefit is that we can print actual meanings (field names).

While we are here, I could not resist fixing a long-standing mental TODO:
make the line number more clearly a line number. I've forgotten where the
line number is in the dumps far too many times in the last decade.

As a small example, here is a fragment of go tool compile -W test/235.go:

.   FOR l(28) tc(1)
.   .   LT-init
.   .   .   AS l(28) tc(1)
.   .   .   .   NAME-main..autotmp_4 l(28) x(0) class(PAUTO) esc(N) tc(1) assigned used int
.   .   .   .   LEN l(28) tc(1) int
.   .   .   .   .   NAME-main.xs g(2) l(26) x(0) class(PPARAM) esc(no) tc(1) used SLICE-[]uint64
.   .   LT l(28) tc(1) hascall bool
.   .   .   NAME-main.i g(4) l(28) x(0) class(PAUTO) esc(no) tc(1) assigned used int
.   .   .   NAME-main..autotmp_4 l(28) x(0) class(PAUTO) esc(N) tc(1) assigned used int
.   .   BLOCK l(28)
.   .   BLOCK-list
.   .   .   ASOP-ADD l(28) tc(1) implicit(true) int
.   .   .   .   NAME-main.i g(4) l(28) x(0) class(PAUTO) esc(no) tc(1) assigned used int
.   .   .   .   LITERAL-1 l(28) tc(1) int
.   FOR-body
.   .   VARKILL l(28) tc(1)
.   .   .   NAME-main..autotmp_4 l(28) x(0) class(PAUTO) esc(N) tc(1) assigned used int
.   .   IF l(29) tc(1)
.   .   .   LT l(29) tc(1) bool
.   .   .   .   INDEX l(29) tc(1) uint64
.   .   .   .   .   NAME-main.xs g(2) l(26) x(0) class(PPARAM) esc(no) tc(1) used SLICE-[]uint64
.   .   .   .   .   NAME-main.i g(4) l(28) x(0) class(PAUTO) esc(no) tc(1) assigned used int
.   .   .   .   NAME-main.m g(3) l(27) x(0) class(PAUTO) esc(no) tc(1) assigned used uint64
.   .   IF-body
.   .   .   AS l(30) tc(1)
.   .   .   .   NAME-main.m g(3) l(27) x(0) class(PAUTO) esc(no) tc(1) assigned used uint64
.   .   .   .   INDEX l(30) tc(1) uint64
.   .   .   .   .   NAME-main.xs g(2) l(26) x(0) class(PPARAM) esc(no) tc(1) used SLICE-[]uint64
.   .   .   .   .   NAME-main.i g(4) l(28) x(0) class(PAUTO) esc(no) tc(1) assigned used int

and here it is after this CL:

.   FOR tc(1) # 235.go:28
.   FOR-Cond
.   .   LT-init
.   .   .   AS tc(1) # 235.go:28
.   .   .   .   NAME-main..autotmp_4 x(0) class(PAUTO) esc(N) tc(1) assigned used int # 235.go:28
.   .   .   .   LEN tc(1) int # 235.go:28 int
.   .   .   .   .   NAME-main.xs g(2) x(0) class(PPARAM) esc(no) tc(1) used SLICE-[]uint64 # 235.go:26
.   .   LT tc(1) hascall bool # 235.go:28 bool
.   .   .   NAME-main.i g(4) x(0) class(PAUTO) esc(no) tc(1) assigned used int # 235.go:28
.   .   .   NAME-main..autotmp_4 x(0) class(PAUTO) esc(N) tc(1) assigned used int # 235.go:28
.   FOR-Post
.   .   BLOCK # 235.go:28
.   .   BLOCK-List
.   .   .   ASOP-ADD tc(1) implicit(true) int # 235.go:28 int
.   .   .   .   NAME-main.i g(4) x(0) class(PAUTO) esc(no) tc(1) assigned used int # 235.go:28
.   .   .   .   LITERAL-1 tc(1) int # 235.go:28
.   FOR-Body
.   .   VARKILL tc(1) # 235.go:28
.   .   .   NAME-main..autotmp_4 x(0) class(PAUTO) esc(N) tc(1) assigned used int # 235.go:28
.   .   IF tc(1) # 235.go:29
.   .   IF-Cond
.   .   .   LT tc(1) bool # 235.go:29 bool
.   .   .   .   INDEX tc(1) uint64 # 235.go:29 uint64
.   .   .   .   .   NAME-main.xs g(2) x(0) class(PPARAM) esc(no) tc(1) used SLICE-[]uint64 # 235.go:26
.   .   .   .   .   NAME-main.i g(4) x(0) class(PAUTO) esc(no) tc(1) assigned used int # 235.go:28
.   .   .   .   NAME-main.m g(3) x(0) class(PAUTO) esc(no) tc(1) assigned used uint64 # 235.go:27
.   .   IF-Body
.   .   .   AS tc(1) # 235.go:30
.   .   .   .   NAME-main.m g(3) x(0) class(PAUTO) esc(no) tc(1) assigned used uint64 # 235.go:27
.   .   .   .   INDEX tc(1) uint64 # 235.go:30 uint64
.   .   .   .   .   NAME-main.xs g(2) x(0) class(PPARAM) esc(no) tc(1) used SLICE-[]uint64 # 235.go:26
.   .   .   .   .   NAME-main.i g(4) x(0) class(PAUTO) esc(no) tc(1) assigned used int # 235.go:28

Note in particular the clear marking of FOR-Cond, FOR-Post, FOR-Body compared to the original.

The only changes to a few test files are the improved field name lines, and of course the line numbers.

Passes buildall w/ toolstash -cmp.

Change-Id: I5b654d9d8ee898976d4c387742ea688a082bac78
Reviewed-on: https://go-review.googlesource.com/c/go/+/275785
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/fmt.go | 149 +++++++++++++++++++----------
 1 file changed, 97 insertions(+), 52 deletions(-)

diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 68e425bdaa..4bea6e2ae0 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -10,6 +10,9 @@ import (
 	"go/constant"
 	"io"
 	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
 
 	"unicode/utf8"
 
@@ -957,17 +960,6 @@ func dumpNodeHeader(w io.Writer, n Node) {
 		fmt.Fprintf(w, " defn(%p)", n.Name().Defn)
 	}
 
-	if n.Pos().IsKnown() {
-		pfx := ""
-		switch n.Pos().IsStmt() {
-		case src.PosNotStmt:
-			pfx = "_" // "-" would be confusing
-		case src.PosIsStmt:
-			pfx = "+"
-		}
-		fmt.Fprintf(w, " l(%s%d)", pfx, n.Pos().Line())
-	}
-
 	if n.Offset() != types.BADWIDTH {
 		fmt.Fprintf(w, " x(%d)", n.Offset())
 	}
@@ -1029,6 +1021,32 @@ func dumpNodeHeader(w io.Writer, n Node) {
 	if n.Name() != nil && n.Name().Used() {
 		fmt.Fprint(w, " used")
 	}
+
+	if n.Op() == OCLOSURE {
+		if fn := n.Func(); fn != nil && fn.Nname.Sym() != nil {
+			fmt.Fprintf(w, " fnName(%+v)", fn.Nname.Sym())
+		}
+	}
+
+	if n.Type() != nil {
+		if n.Op() == OTYPE {
+			fmt.Fprintf(w, " type")
+		}
+		fmt.Fprintf(w, " %+v", n.Type())
+	}
+
+	if n.Pos().IsKnown() {
+		pfx := ""
+		switch n.Pos().IsStmt() {
+		case src.PosNotStmt:
+			pfx = "_" // "-" would be confusing
+		case src.PosIsStmt:
+			pfx = "+"
+		}
+		pos := base.Ctxt.PosTable.Pos(n.Pos())
+		file := filepath.Base(pos.Filename())
+		fmt.Fprintf(w, " # %s%s:%d", pfx, file, pos.Line())
+	}
 }
 
 func dumpNode(w io.Writer, n Node, depth int) {
@@ -1052,6 +1070,7 @@ func dumpNode(w io.Writer, n Node, depth int) {
 	case OLITERAL:
 		fmt.Fprintf(w, "%+v-%v", n.Op(), n.Val())
 		dumpNodeHeader(w, n)
+		return
 
 	case ONAME, ONONAME, OMETHEXPR:
 		if n.Sym() != nil {
@@ -1065,6 +1084,7 @@ func dumpNode(w io.Writer, n Node, depth int) {
 			fmt.Fprintf(w, "%+v-ntype", n.Op())
 			dumpNode(w, n.Name().Ntype, depth+1)
 		}
+		return
 
 	case OASOP:
 		fmt.Fprintf(w, "%+v-%+v", n.Op(), n.SubOp())
@@ -1073,61 +1093,86 @@ func dumpNode(w io.Writer, n Node, depth int) {
 	case OTYPE:
 		fmt.Fprintf(w, "%+v %+v", n.Op(), n.Sym())
 		dumpNodeHeader(w, n)
-		fmt.Fprintf(w, " type=%+v", n.Type())
 		if n.Type() == nil && n.Name() != nil && n.Name().Ntype != nil {
 			indent(w, depth)
 			fmt.Fprintf(w, "%+v-ntype", n.Op())
 			dumpNode(w, n.Name().Ntype, depth+1)
 		}
-	}
+		return
 
-	if n.Op() == OCLOSURE && n.Func() != nil && n.Func().Nname.Sym() != nil {
-		fmt.Fprintf(w, " fnName %+v", n.Func().Nname.Sym())
+	case OCLOSURE:
+		fmt.Fprintf(w, "%+v", n.Op())
+		dumpNodeHeader(w, n)
+
+	case ODCLFUNC:
+		// Func has many fields we don't want to print.
+		// Bypass reflection and just print what we want.
+		fmt.Fprintf(w, "%+v", n.Op())
+		dumpNodeHeader(w, n)
+		fn := n.Func()
+		if len(fn.Dcl) > 0 {
+			indent(w, depth)
+			fmt.Fprintf(w, "%+v-Dcl", n.Op())
+			for _, dcl := range n.Func().Dcl {
+				dumpNode(w, dcl, depth+1)
+			}
+		}
+		if fn.Body().Len() > 0 {
+			indent(w, depth)
+			fmt.Fprintf(w, "%+v-body", n.Op())
+			dumpNodes(w, n.Body(), depth+1)
+		}
+		return
 	}
-	if n.Sym() != nil && n.Op() != ONAME {
+
+	if n.Sym() != nil {
 		fmt.Fprintf(w, " %+v", n.Sym())
 	}
-
 	if n.Type() != nil {
 		fmt.Fprintf(w, " %+v", n.Type())
 	}
 
-	if n.Left() != nil {
-		dumpNode(w, n.Left(), depth+1)
-	}
-	if n.Right() != nil {
-		dumpNode(w, n.Right(), depth+1)
-	}
-	if n.Op() == OCLOSURE && n.Func() != nil && n.Func().Body().Len() != 0 {
-		indent(w, depth)
-		// The function associated with a closure
-		fmt.Fprintf(w, "%+v-clofunc", n.Op())
-		dumpNode(w, n.Func(), depth+1)
-	}
-	if n.Op() == ODCLFUNC && n.Func() != nil && n.Func().Dcl != nil && len(n.Func().Dcl) != 0 {
-		indent(w, depth)
-		// The dcls for a func or closure
-		fmt.Fprintf(w, "%+v-dcl", n.Op())
-		for _, dcl := range n.Func().Dcl {
-			dumpNode(w, dcl, depth+1)
+	v := reflect.ValueOf(n).Elem()
+	t := reflect.TypeOf(n).Elem()
+	nf := t.NumField()
+	for i := 0; i < nf; i++ {
+		tf := t.Field(i)
+		vf := v.Field(i)
+		if tf.PkgPath != "" {
+			// skip unexported field - Interface will fail
+			continue
+		}
+		switch tf.Type.Kind() {
+		case reflect.Interface, reflect.Ptr, reflect.Slice:
+			if vf.IsNil() {
+				continue
+			}
+		}
+		name := strings.TrimSuffix(tf.Name, "_")
+		// Do not bother with field name header lines for the
+		// most common positional arguments: unary, binary expr,
+		// index expr, send stmt, go and defer call expression.
+		switch name {
+		case "X", "Y", "Index", "Chan", "Value", "Call":
+			name = ""
+		}
+		switch val := vf.Interface().(type) {
+		case Node:
+			if name != "" {
+				indent(w, depth)
+				fmt.Fprintf(w, "%+v-%s", n.Op(), name)
+			}
+			dumpNode(w, val, depth+1)
+		case Nodes:
+			if val.Len() == 0 {
+				continue
+			}
+			if name != "" {
+				indent(w, depth)
+				fmt.Fprintf(w, "%+v-%s", n.Op(), name)
+			}
+			dumpNodes(w, val, depth+1)
 		}
-	}
-	if n.List().Len() != 0 {
-		indent(w, depth)
-		fmt.Fprintf(w, "%+v-list", n.Op())
-		dumpNodes(w, n.List(), depth+1)
-	}
-
-	if n.Rlist().Len() != 0 {
-		indent(w, depth)
-		fmt.Fprintf(w, "%+v-rlist", n.Op())
-		dumpNodes(w, n.Rlist(), depth+1)
-	}
-
-	if n.Body().Len() != 0 {
-		indent(w, depth)
-		fmt.Fprintf(w, "%+v-body", n.Op())
-		dumpNodes(w, n.Body(), depth+1)
 	}
 }
 
-- 
GitLab


From 0c4944066411c5570ad9e7b66ae414f409d5d826 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 7 Dec 2020 00:04:54 -0500
Subject: [PATCH 0196/2400] [dev.regabi] cmd/compile: arrange for walkstmt,
 walkexpr, to return from switch cases

Ending them in a returning switch makes it safe for each case
to do an appropriate type assertion.

Passes buildall w/ toolstash -cmp.

Change-Id: I55d8f0a555006104164d84d27822aa8c5ad68515
Reviewed-on: https://go-review.googlesource.com/c/go/+/275882
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/walk.go | 392 +++++++++++++++-------------
 1 file changed, 205 insertions(+), 187 deletions(-)

diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 4189d1a721..f35e9d768b 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -123,6 +123,7 @@ func walkstmt(n ir.Node) ir.Node {
 			base.Errorf("%v is not a top level statement", n.Op())
 		}
 		ir.Dump("nottop", n)
+		return n
 
 	case ir.OAS,
 		ir.OASOP,
@@ -166,6 +167,7 @@ func walkstmt(n ir.Node) ir.Node {
 				n = ir.NewBlockStmt(n.Pos(), init.Slice())
 			}
 		}
+		return n
 
 	// special case for a receive where we throw away
 	// the value received.
@@ -179,8 +181,7 @@ func walkstmt(n ir.Node) ir.Node {
 		n.SetLeft(walkexpr(n.Left(), &init))
 		n = mkcall1(chanfn("chanrecv1", 2, n.Left().Type()), nil, &init, n.Left(), nodnil())
 		n = walkexpr(n, &init)
-
-		n = initExpr(init.Slice(), n)
+		return initExpr(init.Slice(), n)
 
 	case ir.OBREAK,
 		ir.OCONTINUE,
@@ -193,7 +194,7 @@ func walkstmt(n ir.Node) ir.Node {
 		ir.OVARDEF,
 		ir.OVARKILL,
 		ir.OVARLIVE:
-		break
+		return n
 
 	case ir.ODCL:
 		v := n.Left()
@@ -209,12 +210,15 @@ func walkstmt(n ir.Node) ir.Node {
 			nn = typecheck(nn, ctxStmt)
 			return walkstmt(nn)
 		}
+		return n
 
 	case ir.OBLOCK:
 		walkstmtlist(n.List().Slice())
+		return n
 
 	case ir.OCASE:
 		base.Errorf("case statement out of place")
+		panic("unreachable")
 
 	case ir.ODEFER:
 		Curfn.SetHasDefer(true)
@@ -261,6 +265,7 @@ func walkstmt(n ir.Node) ir.Node {
 			init.Append(n)
 			n = ir.NewBlockStmt(n.Pos(), init.Slice())
 		}
+		return n
 
 	case ir.OFOR, ir.OFORUNTIL:
 		if n.Left() != nil {
@@ -276,16 +281,18 @@ func walkstmt(n ir.Node) ir.Node {
 			walkstmtlist(n.List().Slice())
 		}
 		walkstmtlist(n.Body().Slice())
+		return n
 
 	case ir.OIF:
 		n.SetLeft(walkexpr(n.Left(), n.PtrInit()))
 		walkstmtlist(n.Body().Slice())
 		walkstmtlist(n.Rlist().Slice())
+		return n
 
 	case ir.ORETURN:
 		Curfn.NumReturns++
 		if n.List().Len() == 0 {
-			break
+			return n
 		}
 		if (hasNamedResults(Curfn) && n.List().Len() > 1) || paramoutheap(Curfn) {
 			// assign to the function out parameters,
@@ -317,7 +324,7 @@ func walkstmt(n ir.Node) ir.Node {
 
 			ll := ascompatee(n.Op(), rl, n.List().Slice(), n.PtrInit())
 			n.PtrList().Set(reorder3(ll))
-			break
+			return n
 		}
 		walkexprlist(n.List().Slice(), n.PtrInit())
 
@@ -334,27 +341,29 @@ func walkstmt(n ir.Node) ir.Node {
 			res[i] = convas(a, n.PtrInit())
 		}
 		n.PtrList().Set(res)
+		return n
 
 	case ir.ORETJMP:
-		break
+		return n
 
 	case ir.OINLMARK:
-		break
+		return n
 
 	case ir.OSELECT:
 		walkselect(n)
+		return n
 
 	case ir.OSWITCH:
 		walkswitch(n)
+		return n
 
 	case ir.ORANGE:
-		n = walkrange(n)
+		return walkrange(n)
 	}
 
-	if n.Op() == ir.ONAME {
-		base.Fatalf("walkstmt ended up with name: %+v", n)
-	}
-	return n
+	// No return! Each case must return (or panic),
+	// to avoid confusion about what gets returned
+	// in the presence of type assertions.
 }
 
 // walk the whole tree of the body of an
@@ -477,31 +486,68 @@ func walkexpr(n ir.Node, init *ir.Nodes) ir.Node {
 		return nn
 	}
 
-opswitch:
+	n = walkexpr1(n, init)
+
+	// Expressions that are constant at run time but not
+	// considered const by the language spec are not turned into
+	// constants until walk. For example, if n is y%1 == 0, the
+	// walk of y%1 may have replaced it by 0.
+	// Check whether n with its updated args is itself now a constant.
+	t := n.Type()
+	n = evalConst(n)
+	if n.Type() != t {
+		base.Fatalf("evconst changed Type: %v had type %v, now %v", n, t, n.Type())
+	}
+	if n.Op() == ir.OLITERAL {
+		n = typecheck(n, ctxExpr)
+		// Emit string symbol now to avoid emitting
+		// any concurrently during the backend.
+		if v := n.Val(); v.Kind() == constant.String {
+			_ = stringsym(n.Pos(), constant.StringVal(v))
+		}
+	}
+
+	updateHasCall(n)
+
+	if base.Flag.LowerW != 0 && n != nil {
+		ir.Dump("after walk expr", n)
+	}
+
+	base.Pos = lno
+	return n
+}
+
+func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 	switch n.Op() {
 	default:
 		ir.Dump("walk", n)
 		base.Fatalf("walkexpr: switch 1 unknown op %+v", n.Op())
+		panic("unreachable")
 
 	case ir.ONONAME, ir.OGETG, ir.ONEWOBJ, ir.OMETHEXPR:
+		return n
 
 	case ir.OTYPE, ir.ONAME, ir.OLITERAL, ir.ONIL:
 		// TODO(mdempsky): Just return n; see discussion on CL 38655.
 		// Perhaps refactor to use Node.mayBeShared for these instead.
 		// If these return early, make sure to still call
 		// stringsym for constant strings.
+		return n
 
 	case ir.ONOT, ir.ONEG, ir.OPLUS, ir.OBITNOT, ir.OREAL, ir.OIMAG, ir.ODOTMETH, ir.ODOTINTER,
 		ir.ODEREF, ir.OSPTR, ir.OITAB, ir.OIDATA, ir.OADDR:
 		n.SetLeft(walkexpr(n.Left(), init))
+		return n
 
 	case ir.OEFACE, ir.OAND, ir.OANDNOT, ir.OSUB, ir.OMUL, ir.OADD, ir.OOR, ir.OXOR, ir.OLSH, ir.ORSH:
 		n.SetLeft(walkexpr(n.Left(), init))
 		n.SetRight(walkexpr(n.Right(), init))
+		return n
 
 	case ir.ODOT, ir.ODOTPTR:
 		usefield(n)
 		n.SetLeft(walkexpr(n.Left(), init))
+		return n
 
 	case ir.ODOTTYPE, ir.ODOTTYPE2:
 		n.SetLeft(walkexpr(n.Left(), init))
@@ -513,12 +559,12 @@ opswitch:
 		if !n.Type().IsInterface() && !n.Left().Type().IsEmptyInterface() {
 			n.PtrList().Set1(itabname(n.Type(), n.Left().Type()))
 		}
+		return n
 
 	case ir.OLEN, ir.OCAP:
 		if isRuneCount(n) {
 			// Replace len([]rune(string)) with runtime.countrunes(string).
-			n = mkcall("countrunes", n.Type(), init, conv(n.Left().Left(), types.Types[types.TSTRING]))
-			break
+			return mkcall("countrunes", n.Type(), init, conv(n.Left().Left(), types.Types[types.TSTRING]))
 		}
 
 		n.SetLeft(walkexpr(n.Left(), init))
@@ -535,6 +581,7 @@ opswitch:
 			n = origIntConst(n, t.NumElem())
 			n.SetTypecheck(1)
 		}
+		return n
 
 	case ir.OCOMPLEX:
 		// Use results from call expression as arguments for complex.
@@ -544,9 +591,10 @@ opswitch:
 		}
 		n.SetLeft(walkexpr(n.Left(), init))
 		n.SetRight(walkexpr(n.Right(), init))
+		return n
 
 	case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
-		n = walkcompare(n, init)
+		return walkcompare(n, init)
 
 	case ir.OANDAND, ir.OOROR:
 		n.SetLeft(walkexpr(n.Left(), init))
@@ -558,17 +606,19 @@ opswitch:
 
 		n.SetRight(walkexpr(n.Right(), &ll))
 		n.SetRight(initExpr(ll.Slice(), n.Right()))
+		return n
 
 	case ir.OPRINT, ir.OPRINTN:
-		n = walkprint(n, init)
+		return walkprint(n, init)
 
 	case ir.OPANIC:
-		n = mkcall("gopanic", nil, init, n.Left())
+		return mkcall("gopanic", nil, init, n.Left())
 
 	case ir.ORECOVER:
-		n = mkcall("gorecover", n.Type(), init, ir.Nod(ir.OADDR, nodfp, nil))
+		return mkcall("gorecover", n.Type(), init, ir.Nod(ir.OADDR, nodfp, nil))
 
 	case ir.OCLOSUREREAD, ir.OCFUNC:
+		return n
 
 	case ir.OCALLINTER, ir.OCALLFUNC, ir.OCALLMETH:
 		if n.Op() == ir.OCALLINTER {
@@ -597,6 +647,7 @@ opswitch:
 		}
 
 		walkCall(n, init)
+		return n
 
 	case ir.OAS, ir.OASOP:
 		init.AppendNodes(n.PtrInit())
@@ -622,17 +673,16 @@ opswitch:
 		}
 
 		if oaslit(n, init) {
-			n = ir.NodAt(n.Pos(), ir.OBLOCK, nil, nil)
-			break
+			return ir.NodAt(n.Pos(), ir.OBLOCK, nil, nil)
 		}
 
 		if n.Right() == nil {
 			// TODO(austin): Check all "implicit zeroing"
-			break
+			return n
 		}
 
 		if !instrumenting && isZero(n.Right()) {
-			break
+			return n
 		}
 
 		switch n.Right().Op() {
@@ -646,9 +696,7 @@ opswitch:
 
 			n1 := ir.Nod(ir.OADDR, n.Left(), nil)
 			r := n.Right().Left() // the channel
-			n = mkcall1(chanfn("chanrecv1", 2, r.Type()), nil, init, r, n1)
-			n = walkexpr(n, init)
-			break opswitch
+			return mkcall1(chanfn("chanrecv1", 2, r.Type()), nil, init, r, n1)
 
 		case ir.OAPPEND:
 			// x = append(...)
@@ -671,7 +719,7 @@ opswitch:
 				// Do not add a new write barrier.
 				// Set up address of type for back end.
 				r.SetLeft(typename(r.Type().Elem()))
-				break opswitch
+				return n
 			}
 			// Otherwise, lowered for race detector.
 			// Treat as ordinary assignment.
@@ -680,6 +728,7 @@ opswitch:
 		if n.Left() != nil && n.Right() != nil {
 			n = convas(n, init)
 		}
+		return n
 
 	case ir.OAS2:
 		init.AppendNodes(n.PtrInit())
@@ -687,7 +736,7 @@ opswitch:
 		walkexprlistsafe(n.Rlist().Slice(), init)
 		ll := ascompatee(ir.OAS, n.List().Slice(), n.Rlist().Slice(), init)
 		ll = reorder3(ll)
-		n = liststmt(ll)
+		return liststmt(ll)
 
 	// a,b,... = fn()
 	case ir.OAS2FUNC:
@@ -699,12 +748,12 @@ opswitch:
 
 		if isIntrinsicCall(r) {
 			n.PtrRlist().Set1(r)
-			break
+			return n
 		}
 		init.Append(r)
 
 		ll := ascompatet(n.List(), r.Type())
-		n = liststmt(ll)
+		return liststmt(ll)
 
 	// x, y = <-c
 	// order.stmt made sure x is addressable or blank.
@@ -724,7 +773,7 @@ opswitch:
 		ok := n.List().Second()
 		call := mkcall1(fn, types.Types[types.TBOOL], init, r.Left(), n1)
 		n = ir.Nod(ir.OAS, ok, call)
-		n = typecheck(n, ctxStmt)
+		return typecheck(n, ctxStmt)
 
 	// a,b = m[i]
 	case ir.OAS2MAPR:
@@ -784,7 +833,7 @@ opswitch:
 		}
 
 		n = typecheck(n, ctxStmt)
-		n = walkexpr(n, init)
+		return walkexpr(n, init)
 
 	case ir.ODELETE:
 		init.AppendNodes(n.PtrInit())
@@ -799,11 +848,12 @@ opswitch:
 			// order.stmt made sure key is addressable.
 			key = ir.Nod(ir.OADDR, key, nil)
 		}
-		n = mkcall1(mapfndel(mapdelete[fast], t), nil, init, typename(t), map_, key)
+		return mkcall1(mapfndel(mapdelete[fast], t), nil, init, typename(t), map_, key)
 
 	case ir.OAS2DOTTYPE:
 		walkexprlistsafe(n.List().Slice(), init)
 		n.PtrRlist().SetIndex(0, walkexpr(n.Rlist().First(), init))
+		return n
 
 	case ir.OCONVIFACE:
 		n.SetLeft(walkexpr(n.Left(), init))
@@ -828,8 +878,7 @@ opswitch:
 			l := ir.Nod(ir.OEFACE, typeword(), n.Left())
 			l.SetType(toType)
 			l.SetTypecheck(n.Typecheck())
-			n = l
-			break
+			return l
 		}
 
 		if staticuint64s == nil {
@@ -878,8 +927,7 @@ opswitch:
 			l := ir.Nod(ir.OEFACE, typeword(), typecheck(ir.Nod(ir.OADDR, value, nil), ctxExpr))
 			l.SetType(toType)
 			l.SetTypecheck(n.Typecheck())
-			n = l
-			break
+			return l
 		}
 
 		// Implement interface to empty interface conversion.
@@ -906,8 +954,7 @@ opswitch:
 			e := ir.Nod(ir.OEFACE, tmp, ifaceData(n.Pos(), c, types.NewPtr(types.Types[types.TUINT8])))
 			e.SetType(toType) // assign type manually, typecheck doesn't understand OEFACE.
 			e.SetTypecheck(1)
-			n = e
-			break
+			return e
 		}
 
 		fnname, needsaddr := convFuncName(fromType, toType)
@@ -928,8 +975,7 @@ opswitch:
 			e := ir.Nod(ir.OEFACE, typeword(), call)
 			e.SetType(toType)
 			e.SetTypecheck(1)
-			n = e
-			break
+			return e
 		}
 
 		var tab ir.Node
@@ -962,7 +1008,7 @@ opswitch:
 		n = ir.Nod(ir.OCALL, fn, nil)
 		n.PtrList().Set2(tab, v)
 		n = typecheck(n, ctxExpr)
-		n = walkexpr(n, init)
+		return walkexpr(n, init)
 
 	case ir.OCONV, ir.OCONVNOP:
 		n.SetLeft(walkexpr(n.Left(), init))
@@ -971,20 +1017,18 @@ opswitch:
 		}
 		if n.Op() == ir.OCONVNOP && checkPtr(Curfn, 1) {
 			if n.Type().IsPtr() && n.Left().Type().IsUnsafePtr() { // unsafe.Pointer to *T
-				n = walkCheckPtrAlignment(n, init, nil)
-				break
+				return walkCheckPtrAlignment(n, init, nil)
 			}
 			if n.Type().IsUnsafePtr() && n.Left().Type().IsUintptr() { // uintptr to unsafe.Pointer
-				n = walkCheckPtrArithmetic(n, init)
-				break
+				return walkCheckPtrArithmetic(n, init)
 			}
 		}
 		param, result := rtconvfn(n.Left().Type(), n.Type())
 		if param == types.Txxx {
-			break
+			return n
 		}
 		fn := types.BasicTypeNames[param] + "to" + types.BasicTypeNames[result]
-		n = conv(mkcall(fn, types.Types[result], init, conv(n.Left(), types.Types[param])), n.Type())
+		return conv(mkcall(fn, types.Types[result], init, conv(n.Left(), types.Types[param])), n.Type())
 
 	case ir.ODIV, ir.OMOD:
 		n.SetLeft(walkexpr(n.Left(), init))
@@ -996,13 +1040,12 @@ opswitch:
 		if isComplex[et] && n.Op() == ir.ODIV {
 			t := n.Type()
 			n = mkcall("complex128div", types.Types[types.TCOMPLEX128], init, conv(n.Left(), types.Types[types.TCOMPLEX128]), conv(n.Right(), types.Types[types.TCOMPLEX128]))
-			n = conv(n, t)
-			break
+			return conv(n, t)
 		}
 
 		// Nothing to do for float divisions.
 		if isFloat[et] {
-			break
+			return n
 		}
 
 		// rewrite 64-bit div and mod on 32-bit architectures.
@@ -1019,15 +1062,15 @@ opswitch:
 						c = -c
 					}
 					if c != 0 && c&(c-1) == 0 {
-						break opswitch
+						return n
 					}
 				case types.TUINT64:
 					c := ir.Uint64Val(n.Right())
 					if c < 1<<16 {
-						break opswitch
+						return n
 					}
 					if c != 0 && c&(c-1) == 0 {
-						break opswitch
+						return n
 					}
 				}
 			}
@@ -1042,8 +1085,9 @@ opswitch:
 			} else {
 				fn += "mod"
 			}
-			n = mkcall(fn, n.Type(), init, conv(n.Left(), types.Types[et]), conv(n.Right(), types.Types[et]))
+			return mkcall(fn, n.Type(), init, conv(n.Left(), types.Types[et]), conv(n.Right(), types.Types[et]))
 		}
+		return n
 
 	case ir.OINDEX:
 		n.SetLeft(walkexpr(n.Left(), init))
@@ -1057,7 +1101,7 @@ opswitch:
 		// if range of type cannot exceed static array bound,
 		// disable bounds check.
 		if n.Bounded() {
-			break
+			return n
 		}
 		t := n.Left().Type()
 		if t != nil && t.IsPtr() {
@@ -1086,6 +1130,7 @@ opswitch:
 				base.Errorf("index out of bounds")
 			}
 		}
+		return n
 
 	case ir.OINDEXMAP:
 		// Replace m[k] with *map{access1,assign}(maptype, m, &k)
@@ -1124,14 +1169,17 @@ opswitch:
 		n = ir.Nod(ir.ODEREF, n, nil)
 		n.SetType(t.Elem())
 		n.SetTypecheck(1)
+		return n
 
 	case ir.ORECV:
 		base.Fatalf("walkexpr ORECV") // should see inside OAS only
+		panic("unreachable")
 
 	case ir.OSLICEHEADER:
 		n.SetLeft(walkexpr(n.Left(), init))
 		n.List().SetFirst(walkexpr(n.List().First(), init))
 		n.List().SetSecond(walkexpr(n.List().Second(), init))
+		return n
 
 	case ir.OSLICE, ir.OSLICEARR, ir.OSLICESTR, ir.OSLICE3, ir.OSLICE3ARR:
 		checkSlice := checkPtr(Curfn, 1) && n.Op() == ir.OSLICE3ARR && n.Left().Op() == ir.OCONVNOP && n.Left().Left().Type().IsUnsafePtr()
@@ -1160,11 +1208,11 @@ opswitch:
 				} else {
 					n.SetOp(ir.OSLICEARR)
 				}
-				n = reduceSlice(n)
+				return reduceSlice(n)
 			}
-		} else {
-			n = reduceSlice(n)
+			return n
 		}
+		return reduceSlice(n)
 
 	case ir.ONEW:
 		if n.Type().Elem().NotInHeap() {
@@ -1179,28 +1227,26 @@ opswitch:
 			r = typecheck(r, ctxStmt)
 			init.Append(r)
 			r = ir.Nod(ir.OADDR, r.Left(), nil)
-			r = typecheck(r, ctxExpr)
-			n = r
-		} else {
-			n = callnew(n.Type().Elem())
+			return typecheck(r, ctxExpr)
 		}
+		return callnew(n.Type().Elem())
 
 	case ir.OADDSTR:
-		n = addstr(n, init)
+		return addstr(n, init)
 
 	case ir.OAPPEND:
 		// order should make sure we only see OAS(node, OAPPEND), which we handle above.
 		base.Fatalf("append outside assignment")
+		panic("unreachable")
 
 	case ir.OCOPY:
-		n = copyany(n, init, instrumenting && !base.Flag.CompilingRuntime)
+		return copyany(n, init, instrumenting && !base.Flag.CompilingRuntime)
 
-		// cannot use chanfn - closechan takes any, not chan any
 	case ir.OCLOSE:
+		// cannot use chanfn - closechan takes any, not chan any
 		fn := syslook("closechan")
-
 		fn = substArgTypes(fn, n.Left().Type())
-		n = mkcall1(fn, nil, init, n.Left())
+		return mkcall1(fn, nil, init, n.Left())
 
 	case ir.OMAKECHAN:
 		// When size fits into int, use makechan instead of
@@ -1217,7 +1263,7 @@ opswitch:
 			argtype = types.Types[types.TINT]
 		}
 
-		n = mkcall1(chanfn(fnname, 1, n.Type()), n.Type(), init, typename(n.Type()), conv(size, argtype))
+		return mkcall1(chanfn(fnname, 1, n.Type()), n.Type(), init, typename(n.Type()), conv(size, argtype))
 
 	case ir.OMAKEMAP:
 		t := n.Type()
@@ -1294,42 +1340,41 @@ opswitch:
 				a = typecheck(a, ctxStmt)
 				a = walkexpr(a, init)
 				init.Append(a)
-				n = convnop(h, t)
-			} else {
-				// Call runtime.makehmap to allocate an
-				// hmap on the heap and initialize hmap's hash0 field.
-				fn := syslook("makemap_small")
-				fn = substArgTypes(fn, t.Key(), t.Elem())
-				n = mkcall1(fn, n.Type(), init)
-			}
-		} else {
-			if n.Esc() != EscNone {
-				h = nodnil()
-			}
-			// Map initialization with a variable or large hint is
-			// more complicated. We therefore generate a call to
-			// runtime.makemap to initialize hmap and allocate the
-			// map buckets.
-
-			// When hint fits into int, use makemap instead of
-			// makemap64, which is faster and shorter on 32 bit platforms.
-			fnname := "makemap64"
-			argtype := types.Types[types.TINT64]
-
-			// Type checking guarantees that TIDEAL hint is positive and fits in an int.
-			// See checkmake call in TMAP case of OMAKE case in OpSwitch in typecheck1 function.
-			// The case of hint overflow when converting TUINT or TUINTPTR to TINT
-			// will be handled by the negative range checks in makemap during runtime.
-			if hint.Type().IsKind(types.TIDEAL) || hint.Type().Size() <= types.Types[types.TUINT].Size() {
-				fnname = "makemap"
-				argtype = types.Types[types.TINT]
+				return convnop(h, t)
 			}
+			// Call runtime.makehmap to allocate an
+			// hmap on the heap and initialize hmap's hash0 field.
+			fn := syslook("makemap_small")
+			fn = substArgTypes(fn, t.Key(), t.Elem())
+			return mkcall1(fn, n.Type(), init)
+		}
 
-			fn := syslook(fnname)
-			fn = substArgTypes(fn, hmapType, t.Key(), t.Elem())
-			n = mkcall1(fn, n.Type(), init, typename(n.Type()), conv(hint, argtype), h)
+		if n.Esc() != EscNone {
+			h = nodnil()
+		}
+		// Map initialization with a variable or large hint is
+		// more complicated. We therefore generate a call to
+		// runtime.makemap to initialize hmap and allocate the
+		// map buckets.
+
+		// When hint fits into int, use makemap instead of
+		// makemap64, which is faster and shorter on 32 bit platforms.
+		fnname := "makemap64"
+		argtype := types.Types[types.TINT64]
+
+		// Type checking guarantees that TIDEAL hint is positive and fits in an int.
+		// See checkmake call in TMAP case of OMAKE case in OpSwitch in typecheck1 function.
+		// The case of hint overflow when converting TUINT or TUINTPTR to TINT
+		// will be handled by the negative range checks in makemap during runtime.
+		if hint.Type().IsKind(types.TIDEAL) || hint.Type().Size() <= types.Types[types.TUINT].Size() {
+			fnname = "makemap"
+			argtype = types.Types[types.TINT]
 		}
 
+		fn := syslook(fnname)
+		fn = substArgTypes(fn, hmapType, t.Key(), t.Elem())
+		return mkcall1(fn, n.Type(), init, typename(n.Type()), conv(hint, argtype), h)
+
 	case ir.OMAKESLICE:
 		l := n.Left()
 		r := n.Right()
@@ -1376,39 +1421,39 @@ opswitch:
 			r = conv(r, n.Type()) // in case n.Type is named.
 			r = typecheck(r, ctxExpr)
 			r = walkexpr(r, init)
-			n = r
-		} else {
-			// n escapes; set up a call to makeslice.
-			// When len and cap can fit into int, use makeslice instead of
-			// makeslice64, which is faster and shorter on 32 bit platforms.
-
-			len, cap := l, r
-
-			fnname := "makeslice64"
-			argtype := types.Types[types.TINT64]
-
-			// Type checking guarantees that TIDEAL len/cap are positive and fit in an int.
-			// The case of len or cap overflow when converting TUINT or TUINTPTR to TINT
-			// will be handled by the negative range checks in makeslice during runtime.
-			if (len.Type().IsKind(types.TIDEAL) || len.Type().Size() <= types.Types[types.TUINT].Size()) &&
-				(cap.Type().IsKind(types.TIDEAL) || cap.Type().Size() <= types.Types[types.TUINT].Size()) {
-				fnname = "makeslice"
-				argtype = types.Types[types.TINT]
-			}
+			return r
+		}
 
-			m := ir.Nod(ir.OSLICEHEADER, nil, nil)
-			m.SetType(t)
+		// n escapes; set up a call to makeslice.
+		// When len and cap can fit into int, use makeslice instead of
+		// makeslice64, which is faster and shorter on 32 bit platforms.
 
-			fn := syslook(fnname)
-			m.SetLeft(mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), conv(len, argtype), conv(cap, argtype)))
-			m.Left().MarkNonNil()
-			m.PtrList().Set2(conv(len, types.Types[types.TINT]), conv(cap, types.Types[types.TINT]))
+		len, cap := l, r
+
+		fnname := "makeslice64"
+		argtype := types.Types[types.TINT64]
 
-			m = typecheck(m, ctxExpr)
-			m = walkexpr(m, init)
-			n = m
+		// Type checking guarantees that TIDEAL len/cap are positive and fit in an int.
+		// The case of len or cap overflow when converting TUINT or TUINTPTR to TINT
+		// will be handled by the negative range checks in makeslice during runtime.
+		if (len.Type().IsKind(types.TIDEAL) || len.Type().Size() <= types.Types[types.TUINT].Size()) &&
+			(cap.Type().IsKind(types.TIDEAL) || cap.Type().Size() <= types.Types[types.TUINT].Size()) {
+			fnname = "makeslice"
+			argtype = types.Types[types.TINT]
 		}
 
+		m := ir.Nod(ir.OSLICEHEADER, nil, nil)
+		m.SetType(t)
+
+		fn := syslook(fnname)
+		m.SetLeft(mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), conv(len, argtype), conv(cap, argtype)))
+		m.Left().MarkNonNil()
+		m.PtrList().Set2(conv(len, types.Types[types.TINT]), conv(cap, types.Types[types.TINT]))
+
+		m = typecheck(m, ctxExpr)
+		m = walkexpr(m, init)
+		return m
+
 	case ir.OMAKESLICECOPY:
 		if n.Esc() == EscNone {
 			base.Fatalf("OMAKESLICECOPY with EscNone: %v", n)
@@ -1453,18 +1498,18 @@ opswitch:
 			ncopy = walkexpr(ncopy, init)
 			init.Append(ncopy)
 
-			n = s
-		} else { // Replace make+copy with runtime.makeslicecopy.
-			// instantiate makeslicecopy(typ *byte, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointer
-			fn := syslook("makeslicecopy")
-			s := ir.Nod(ir.OSLICEHEADER, nil, nil)
-			s.SetLeft(mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), length, copylen, conv(copyptr, types.Types[types.TUNSAFEPTR])))
-			s.Left().MarkNonNil()
-			s.PtrList().Set2(length, length)
-			s.SetType(t)
-			n = typecheck(s, ctxExpr)
-			n = walkexpr(n, init)
+			return s
 		}
+		// Replace make+copy with runtime.makeslicecopy.
+		// instantiate makeslicecopy(typ *byte, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointer
+		fn := syslook("makeslicecopy")
+		s := ir.Nod(ir.OSLICEHEADER, nil, nil)
+		s.SetLeft(mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), length, copylen, conv(copyptr, types.Types[types.TUNSAFEPTR])))
+		s.Left().MarkNonNil()
+		s.PtrList().Set2(length, length)
+		s.SetType(t)
+		n = typecheck(s, ctxExpr)
+		return walkexpr(n, init)
 
 	case ir.ORUNESTR:
 		a := nodnil()
@@ -1473,7 +1518,7 @@ opswitch:
 			a = ir.Nod(ir.OADDR, temp(t), nil)
 		}
 		// intstring(*[4]byte, rune)
-		n = mkcall("intstring", n.Type(), init, a, conv(n.Left(), types.Types[types.TINT64]))
+		return mkcall("intstring", n.Type(), init, a, conv(n.Left(), types.Types[types.TINT64]))
 
 	case ir.OBYTES2STR, ir.ORUNES2STR:
 		a := nodnil()
@@ -1484,25 +1529,24 @@ opswitch:
 		}
 		if n.Op() == ir.ORUNES2STR {
 			// slicerunetostring(*[32]byte, []rune) string
-			n = mkcall("slicerunetostring", n.Type(), init, a, n.Left())
-		} else {
-			// slicebytetostring(*[32]byte, ptr *byte, n int) string
-			n.SetLeft(cheapexpr(n.Left(), init))
-			ptr, len := backingArrayPtrLen(n.Left())
-			n = mkcall("slicebytetostring", n.Type(), init, a, ptr, len)
+			return mkcall("slicerunetostring", n.Type(), init, a, n.Left())
 		}
+		// slicebytetostring(*[32]byte, ptr *byte, n int) string
+		n.SetLeft(cheapexpr(n.Left(), init))
+		ptr, len := backingArrayPtrLen(n.Left())
+		return mkcall("slicebytetostring", n.Type(), init, a, ptr, len)
 
 	case ir.OBYTES2STRTMP:
 		n.SetLeft(walkexpr(n.Left(), init))
 		if !instrumenting {
 			// Let the backend handle OBYTES2STRTMP directly
 			// to avoid a function call to slicebytetostringtmp.
-			break
+			return n
 		}
 		// slicebytetostringtmp(ptr *byte, n int) string
 		n.SetLeft(cheapexpr(n.Left(), init))
 		ptr, len := backingArrayPtrLen(n.Left())
-		n = mkcall("slicebytetostringtmp", n.Type(), init, ptr, len)
+		return mkcall("slicebytetostringtmp", n.Type(), init, ptr, len)
 
 	case ir.OSTR2BYTES:
 		s := n.Left()
@@ -1534,8 +1578,7 @@ opswitch:
 			slice := ir.NodAt(n.Pos(), ir.OSLICEARR, p, nil)
 			slice.SetType(n.Type())
 			slice.SetTypecheck(1)
-			n = walkexpr(slice, init)
-			break
+			return walkexpr(slice, init)
 		}
 
 		a := nodnil()
@@ -1545,7 +1588,7 @@ opswitch:
 			a = ir.Nod(ir.OADDR, temp(t), nil)
 		}
 		// stringtoslicebyte(*32[byte], string) []byte
-		n = mkcall("stringtoslicebyte", n.Type(), init, a, conv(s, types.Types[types.TSTRING]))
+		return mkcall("stringtoslicebyte", n.Type(), init, a, conv(s, types.Types[types.TSTRING]))
 
 	case ir.OSTR2BYTESTMP:
 		// []byte(string) conversion that creates a slice
@@ -1556,6 +1599,7 @@ opswitch:
 		// The only such case today is:
 		// for i, c := range []byte(string)
 		n.SetLeft(walkexpr(n.Left(), init))
+		return n
 
 	case ir.OSTR2RUNES:
 		a := nodnil()
@@ -1565,7 +1609,7 @@ opswitch:
 			a = ir.Nod(ir.OADDR, temp(t), nil)
 		}
 		// stringtoslicerune(*[32]rune, string) []rune
-		n = mkcall("stringtoslicerune", n.Type(), init, a, conv(n.Left(), types.Types[types.TSTRING]))
+		return mkcall("stringtoslicerune", n.Type(), init, a, conv(n.Left(), types.Types[types.TSTRING]))
 
 	case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT, ir.OSTRUCTLIT, ir.OPTRLIT:
 		if isStaticCompositeLiteral(n) && !canSSAType(n.Type()) {
@@ -1573,55 +1617,29 @@ opswitch:
 			// Make direct reference to the static data. See issue 12841.
 			vstat := readonlystaticname(n.Type())
 			fixedlit(inInitFunction, initKindStatic, n, vstat, init)
-			n = vstat
-			n = typecheck(n, ctxExpr)
-			break
+			return typecheck(vstat, ctxExpr)
 		}
 		var_ := temp(n.Type())
 		anylit(n, var_, init)
-		n = var_
+		return var_
 
 	case ir.OSEND:
 		n1 := n.Right()
 		n1 = assignconv(n1, n.Left().Type().Elem(), "chan send")
 		n1 = walkexpr(n1, init)
 		n1 = ir.Nod(ir.OADDR, n1, nil)
-		n = mkcall1(chanfn("chansend1", 2, n.Left().Type()), nil, init, n.Left(), n1)
+		return mkcall1(chanfn("chansend1", 2, n.Left().Type()), nil, init, n.Left(), n1)
 
 	case ir.OCLOSURE:
-		n = walkclosure(n, init)
+		return walkclosure(n, init)
 
 	case ir.OCALLPART:
-		n = walkpartialcall(n.(*ir.CallPartExpr), init)
-	}
-
-	// Expressions that are constant at run time but not
-	// considered const by the language spec are not turned into
-	// constants until walk. For example, if n is y%1 == 0, the
-	// walk of y%1 may have replaced it by 0.
-	// Check whether n with its updated args is itself now a constant.
-	t := n.Type()
-	n = evalConst(n)
-	if n.Type() != t {
-		base.Fatalf("evconst changed Type: %v had type %v, now %v", n, t, n.Type())
-	}
-	if n.Op() == ir.OLITERAL {
-		n = typecheck(n, ctxExpr)
-		// Emit string symbol now to avoid emitting
-		// any concurrently during the backend.
-		if v := n.Val(); v.Kind() == constant.String {
-			_ = stringsym(n.Pos(), constant.StringVal(v))
-		}
-	}
-
-	updateHasCall(n)
-
-	if base.Flag.LowerW != 0 && n != nil {
-		ir.Dump("after walk expr", n)
+		return walkpartialcall(n.(*ir.CallPartExpr), init)
 	}
 
-	base.Pos = lno
-	return n
+	// No return! Each case must return (or panic),
+	// to avoid confusion about what gets returned
+	// in the presence of type assertions.
 }
 
 // markTypeUsedInInterface marks that type t is converted to an interface.
-- 
GitLab


From 837b35cc55c258bb57ac9fa337ed0783a6fcc617 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 7 Dec 2020 09:14:44 -0500
Subject: [PATCH 0197/2400] [dev.regabi] cmd/compile: adjust IR representations

Based on actually using the IR when prototyping adding
type assertions, a few changes to improve it:

- Merge DeferStmt and GoStmt, since they are variants of one thing.
- Introduce LogicalExpr for && and ||, since they (alone) need an init list before Y.
- Add an explicit op to various constructors to make them easier to use.
- Add separate StructKeyExpr - it stores Value in a different abstract location (Left) than KeyExpr (Right).
- Export all fields for use by rewrites (and later reflection).

Passes buildall w/ toolstash -cmp.

Change-Id: Iefbff2386d2bb9ef511ce53b7f92ff6c709dc991
Reviewed-on: https://go-review.googlesource.com/c/go/+/275883
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/typecheck.go |  17 +--
 src/cmd/compile/internal/gc/universe.go  |   3 +-
 src/cmd/compile/internal/ir/expr.go      | 186 ++++++++++++++---------
 src/cmd/compile/internal/ir/name.go      |   8 +
 src/cmd/compile/internal/ir/node.go      |  51 +++----
 src/cmd/compile/internal/ir/node_gen.go  |  76 +++++----
 src/cmd/compile/internal/ir/stmt.go      | 139 ++++++++---------
 src/cmd/compile/internal/ir/val.go       |   2 +-
 8 files changed, 266 insertions(+), 216 deletions(-)

diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 990921189a..36526d4c2d 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -2010,18 +2010,13 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 		return n
 
-	case ir.ODEFER:
+	case ir.ODEFER, ir.OGO:
 		n.SetLeft(typecheck(n.Left(), ctxStmt|ctxExpr))
 		if !n.Left().Diag() {
 			checkdefergo(n)
 		}
 		return n
 
-	case ir.OGO:
-		n.SetLeft(typecheck(n.Left(), ctxStmt|ctxExpr))
-		checkdefergo(n)
-		return n
-
 	case ir.OFOR, ir.OFORUNTIL:
 		typecheckslice(n.Init().Slice(), ctxStmt)
 		decldepth++
@@ -2885,9 +2880,9 @@ func typecheckcomplit(n ir.Node) (res ir.Node) {
 				if l.Op() == ir.OKEY {
 					key := l.Left()
 
-					l.SetOp(ir.OSTRUCTKEY)
-					l.SetLeft(l.Right())
-					l.SetRight(nil)
+					sk := ir.NewStructKeyExpr(l.Pos(), nil, l.Right())
+					ls[i] = sk
+					l = sk
 
 					// An OXDOT uses the Sym field to hold
 					// the field to the right of the dot,
@@ -2895,7 +2890,7 @@ func typecheckcomplit(n ir.Node) (res ir.Node) {
 					// is never a valid struct literal key.
 					if key.Sym() == nil || key.Op() == ir.OXDOT || key.Sym().IsBlank() {
 						base.Errorf("invalid field name %v in struct initializer", key)
-						l.SetLeft(typecheck(l.Left(), ctxExpr))
+						sk.SetLeft(typecheck(sk.Left(), ctxExpr))
 						continue
 					}
 
@@ -2909,7 +2904,7 @@ func typecheckcomplit(n ir.Node) (res ir.Node) {
 							s = s1
 						}
 					}
-					l.SetSym(s)
+					sk.SetSym(s)
 				}
 
 				if l.Op() != ir.OSTRUCTKEY {
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index 42b996d88d..c592e37497 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -202,8 +202,7 @@ func initUniverse() {
 	ir.AsNode(s.Def).SetSym(s)
 
 	s = types.BuiltinPkg.Lookup("iota")
-	s.Def = ir.Nod(ir.OIOTA, nil, nil)
-	ir.AsNode(s.Def).SetSym(s)
+	s.Def = ir.NewIota(base.Pos, s)
 
 	for et := types.TINT8; et <= types.TUINT64; et++ {
 		isInt[et] = true
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index a74e0712b9..8ea31c1929 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -159,8 +159,8 @@ func (n *BinaryExpr) SetOp(op Op) {
 	switch op {
 	default:
 		panic(n.no("SetOp " + op.String()))
-	case OADD, OADDSTR, OAND, OANDAND, OANDNOT, ODIV, OEQ, OGE, OGT, OLE,
-		OLSH, OLT, OMOD, OMUL, ONE, OOR, OOROR, ORSH, OSUB, OXOR,
+	case OADD, OADDSTR, OAND, OANDNOT, ODIV, OEQ, OGE, OGT, OLE,
+		OLSH, OLT, OMOD, OMUL, ONE, OOR, ORSH, OSUB, OXOR,
 		OCOPY, OCOMPLEX,
 		OEFACE:
 		n.op = op
@@ -181,21 +181,21 @@ const (
 // A CallExpr is a function call X(Args).
 type CallExpr struct {
 	miniExpr
-	orig     Node
-	X        Node
-	Args     Nodes
-	Rargs    Nodes // TODO(rsc): Delete.
-	Body_    Nodes // TODO(rsc): Delete.
-	DDD      bool
-	Use      CallUse
-	noInline bool
+	orig      Node
+	X         Node
+	Args      Nodes
+	Rargs     Nodes // TODO(rsc): Delete.
+	Body_     Nodes // TODO(rsc): Delete.
+	DDD       bool
+	Use       CallUse
+	NoInline_ bool
 }
 
-func NewCallExpr(pos src.XPos, fun Node, args []Node) *CallExpr {
+func NewCallExpr(pos src.XPos, op Op, fun Node, args []Node) *CallExpr {
 	n := &CallExpr{X: fun}
 	n.pos = pos
 	n.orig = n
-	n.op = OCALL
+	n.SetOp(op)
 	n.Args.Set(args)
 	return n
 }
@@ -214,8 +214,8 @@ func (n *CallExpr) PtrRlist() *Nodes   { return &n.Rargs }
 func (n *CallExpr) SetRlist(x Nodes)   { n.Rargs = x }
 func (n *CallExpr) IsDDD() bool        { return n.DDD }
 func (n *CallExpr) SetIsDDD(x bool)    { n.DDD = x }
-func (n *CallExpr) NoInline() bool     { return n.noInline }
-func (n *CallExpr) SetNoInline(x bool) { n.noInline = x }
+func (n *CallExpr) NoInline() bool     { return n.NoInline_ }
+func (n *CallExpr) SetNoInline(x bool) { n.NoInline_ = x }
 func (n *CallExpr) Body() Nodes        { return n.Body_ }
 func (n *CallExpr) PtrBody() *Nodes    { return &n.Body_ }
 func (n *CallExpr) SetBody(x Nodes)    { n.Body_ = x }
@@ -233,21 +233,21 @@ func (n *CallExpr) SetOp(op Op) {
 // A CallPartExpr is a method expression X.Method (uncalled).
 type CallPartExpr struct {
 	miniExpr
-	fn     *Func
+	Func_  *Func
 	X      Node
 	Method *types.Field
 }
 
 func NewCallPartExpr(pos src.XPos, x Node, method *types.Field, fn *Func) *CallPartExpr {
-	n := &CallPartExpr{fn: fn, X: x, Method: method}
+	n := &CallPartExpr{Func_: fn, X: x, Method: method}
 	n.op = OCALLPART
 	n.pos = pos
 	n.typ = fn.Type()
-	n.fn = fn
+	n.Func_ = fn
 	return n
 }
 
-func (n *CallPartExpr) Func() *Func     { return n.fn }
+func (n *CallPartExpr) Func() *Func     { return n.Func_ }
 func (n *CallPartExpr) Left() Node      { return n.X }
 func (n *CallPartExpr) Sym() *types.Sym { return n.Method.Sym }
 func (n *CallPartExpr) SetLeft(x Node)  { n.X = x }
@@ -268,20 +268,20 @@ func NewClosureExpr(pos src.XPos, fn *Func) *ClosureExpr {
 func (n *ClosureExpr) Func() *Func { return n.Func_ }
 
 // A ClosureRead denotes reading a variable stored within a closure struct.
-type ClosureRead struct {
+type ClosureReadExpr struct {
 	miniExpr
-	offset int64
+	Offset_ int64
 }
 
-func NewClosureRead(typ *types.Type, offset int64) *ClosureRead {
-	n := &ClosureRead{offset: offset}
+func NewClosureRead(typ *types.Type, offset int64) *ClosureReadExpr {
+	n := &ClosureReadExpr{Offset_: offset}
 	n.typ = typ
 	n.op = OCLOSUREREAD
 	return n
 }
 
-func (n *ClosureRead) Type() *types.Type { return n.typ }
-func (n *ClosureRead) Offset() int64     { return n.offset }
+func (n *ClosureReadExpr) Type() *types.Type { return n.typ }
+func (n *ClosureReadExpr) Offset() int64     { return n.Offset_ }
 
 // A CompLitExpr is a composite literal Type{Vals}.
 // Before type-checking, the type is Ntype.
@@ -292,10 +292,10 @@ type CompLitExpr struct {
 	List_ Nodes // initialized values
 }
 
-func NewCompLitExpr(pos src.XPos, typ Ntype, list []Node) *CompLitExpr {
+func NewCompLitExpr(pos src.XPos, op Op, typ Ntype, list []Node) *CompLitExpr {
 	n := &CompLitExpr{Ntype: typ}
 	n.pos = pos
-	n.op = OCOMPLIT
+	n.SetOp(op)
 	n.List_.Set(list)
 	n.orig = n
 	return n
@@ -397,42 +397,48 @@ func (n *IndexExpr) SetOp(op Op) {
 	}
 }
 
-// A KeyExpr is an X:Y composite literal key.
-// After type-checking, a key for a struct sets Sym to the field.
+// A KeyExpr is a Key: Value composite literal key.
 type KeyExpr struct {
 	miniExpr
-	Key    Node
-	sym    *types.Sym
-	Value  Node
-	offset int64
+	Key   Node
+	Value Node
 }
 
 func NewKeyExpr(pos src.XPos, key, value Node) *KeyExpr {
 	n := &KeyExpr{Key: key, Value: value}
 	n.pos = pos
 	n.op = OKEY
-	n.offset = types.BADWIDTH
 	return n
 }
 
-func (n *KeyExpr) Left() Node          { return n.Key }
-func (n *KeyExpr) SetLeft(x Node)      { n.Key = x }
-func (n *KeyExpr) Right() Node         { return n.Value }
-func (n *KeyExpr) SetRight(y Node)     { n.Value = y }
-func (n *KeyExpr) Sym() *types.Sym     { return n.sym }
-func (n *KeyExpr) SetSym(x *types.Sym) { n.sym = x }
-func (n *KeyExpr) Offset() int64       { return n.offset }
-func (n *KeyExpr) SetOffset(x int64)   { n.offset = x }
+func (n *KeyExpr) Left() Node      { return n.Key }
+func (n *KeyExpr) SetLeft(x Node)  { n.Key = x }
+func (n *KeyExpr) Right() Node     { return n.Value }
+func (n *KeyExpr) SetRight(y Node) { n.Value = y }
 
-func (n *KeyExpr) SetOp(op Op) {
-	switch op {
-	default:
-		panic(n.no("SetOp " + op.String()))
-	case OKEY, OSTRUCTKEY:
-		n.op = op
-	}
+// A StructKeyExpr is an Field: Value composite literal key.
+type StructKeyExpr struct {
+	miniExpr
+	Field   *types.Sym
+	Value   Node
+	Offset_ int64
+}
+
+func NewStructKeyExpr(pos src.XPos, field *types.Sym, value Node) *StructKeyExpr {
+	n := &StructKeyExpr{Field: field, Value: value}
+	n.pos = pos
+	n.op = OSTRUCTKEY
+	n.Offset_ = types.BADWIDTH
+	return n
 }
 
+func (n *StructKeyExpr) Sym() *types.Sym     { return n.Field }
+func (n *StructKeyExpr) SetSym(x *types.Sym) { n.Field = x }
+func (n *StructKeyExpr) Left() Node          { return n.Value }
+func (n *StructKeyExpr) SetLeft(x Node)      { n.Value = x }
+func (n *StructKeyExpr) Offset() int64       { return n.Offset_ }
+func (n *StructKeyExpr) SetOffset(x int64)   { n.Offset_ = x }
+
 // An InlinedCallExpr is an inlined function call.
 type InlinedCallExpr struct {
 	miniExpr
@@ -456,6 +462,36 @@ func (n *InlinedCallExpr) Rlist() Nodes     { return n.ReturnVars }
 func (n *InlinedCallExpr) PtrRlist() *Nodes { return &n.ReturnVars }
 func (n *InlinedCallExpr) SetRlist(x Nodes) { n.ReturnVars = x }
 
+// A LogicalExpr is a expression X Op Y where Op is && or ||.
+// It is separate from BinaryExpr to make room for statements
+// that must be executed before Y but after X.
+type LogicalExpr struct {
+	miniExpr
+	X Node
+	Y Node
+}
+
+func NewLogicalExpr(pos src.XPos, op Op, x, y Node) *LogicalExpr {
+	n := &LogicalExpr{X: x, Y: y}
+	n.pos = pos
+	n.SetOp(op)
+	return n
+}
+
+func (n *LogicalExpr) Left() Node      { return n.X }
+func (n *LogicalExpr) SetLeft(x Node)  { n.X = x }
+func (n *LogicalExpr) Right() Node     { return n.Y }
+func (n *LogicalExpr) SetRight(y Node) { n.Y = y }
+
+func (n *LogicalExpr) SetOp(op Op) {
+	switch op {
+	default:
+		panic(n.no("SetOp " + op.String()))
+	case OANDAND, OOROR:
+		n.op = op
+	}
+}
+
 // A MakeExpr is a make expression: make(Type[, Len[, Cap]]).
 // Op is OMAKECHAN, OMAKEMAP, OMAKESLICE, or OMAKESLICECOPY,
 // but *not* OMAKE (that's a pre-typechecking CallExpr).
@@ -489,19 +525,19 @@ func (n *MakeExpr) SetOp(op Op) {
 // A MethodExpr is a method value X.M (where X is an expression, not a type).
 type MethodExpr struct {
 	miniExpr
-	X      Node
-	M      Node
-	sym    *types.Sym
-	offset int64
-	class  Class
-	Method *types.Field
+	X       Node
+	M       Node
+	Sym_    *types.Sym
+	Offset_ int64
+	Class_  Class
+	Method  *types.Field
 }
 
-func NewMethodExpr(pos src.XPos, op Op, x, m Node) *MethodExpr {
+func NewMethodExpr(pos src.XPos, x, m Node) *MethodExpr {
 	n := &MethodExpr{X: x, M: m}
 	n.pos = pos
 	n.op = OMETHEXPR
-	n.offset = types.BADWIDTH
+	n.Offset_ = types.BADWIDTH
 	return n
 }
 
@@ -509,18 +545,18 @@ func (n *MethodExpr) Left() Node          { return n.X }
 func (n *MethodExpr) SetLeft(x Node)      { n.X = x }
 func (n *MethodExpr) Right() Node         { return n.M }
 func (n *MethodExpr) SetRight(y Node)     { n.M = y }
-func (n *MethodExpr) Sym() *types.Sym     { return n.sym }
-func (n *MethodExpr) SetSym(x *types.Sym) { n.sym = x }
-func (n *MethodExpr) Offset() int64       { return n.offset }
-func (n *MethodExpr) SetOffset(x int64)   { n.offset = x }
-func (n *MethodExpr) Class() Class        { return n.class }
-func (n *MethodExpr) SetClass(x Class)    { n.class = x }
+func (n *MethodExpr) Sym() *types.Sym     { return n.Sym_ }
+func (n *MethodExpr) SetSym(x *types.Sym) { n.Sym_ = x }
+func (n *MethodExpr) Offset() int64       { return n.Offset_ }
+func (n *MethodExpr) SetOffset(x int64)   { n.Offset_ = x }
+func (n *MethodExpr) Class() Class        { return n.Class_ }
+func (n *MethodExpr) SetClass(x Class)    { n.Class_ = x }
 
 // A NilExpr represents the predefined untyped constant nil.
 // (It may be copied and assigned a type, though.)
 type NilExpr struct {
 	miniExpr
-	sym *types.Sym // TODO: Remove
+	Sym_ *types.Sym // TODO: Remove
 }
 
 func NewNilExpr(pos src.XPos) *NilExpr {
@@ -530,8 +566,8 @@ func NewNilExpr(pos src.XPos) *NilExpr {
 	return n
 }
 
-func (n *NilExpr) Sym() *types.Sym     { return n.sym }
-func (n *NilExpr) SetSym(x *types.Sym) { n.sym = x }
+func (n *NilExpr) Sym() *types.Sym     { return n.Sym_ }
+func (n *NilExpr) SetSym(x *types.Sym) { n.Sym_ = x }
 
 // A ParenExpr is a parenthesized expression (X).
 // It may end up being a value or a type.
@@ -563,34 +599,34 @@ func (n *ParenExpr) SetOTYPE(t *types.Type) {
 // A ResultExpr represents a direct access to a result slot on the stack frame.
 type ResultExpr struct {
 	miniExpr
-	offset int64
+	Offset_ int64
 }
 
 func NewResultExpr(pos src.XPos, typ *types.Type, offset int64) *ResultExpr {
-	n := &ResultExpr{offset: offset}
+	n := &ResultExpr{Offset_: offset}
 	n.pos = pos
 	n.op = ORESULT
 	n.typ = typ
 	return n
 }
 
-func (n *ResultExpr) Offset() int64     { return n.offset }
-func (n *ResultExpr) SetOffset(x int64) { n.offset = x }
+func (n *ResultExpr) Offset() int64     { return n.Offset_ }
+func (n *ResultExpr) SetOffset(x int64) { n.Offset_ = x }
 
 // A SelectorExpr is a selector expression X.Sym.
 type SelectorExpr struct {
 	miniExpr
 	X         Node
 	Sel       *types.Sym
-	offset    int64
+	Offset_   int64
 	Selection *types.Field
 }
 
-func NewSelectorExpr(pos src.XPos, x Node, sel *types.Sym) *SelectorExpr {
+func NewSelectorExpr(pos src.XPos, op Op, x Node, sel *types.Sym) *SelectorExpr {
 	n := &SelectorExpr{X: x, Sel: sel}
 	n.pos = pos
-	n.op = OXDOT
-	n.offset = types.BADWIDTH
+	n.Offset_ = types.BADWIDTH
+	n.SetOp(op)
 	return n
 }
 
@@ -607,8 +643,8 @@ func (n *SelectorExpr) Left() Node          { return n.X }
 func (n *SelectorExpr) SetLeft(x Node)      { n.X = x }
 func (n *SelectorExpr) Sym() *types.Sym     { return n.Sel }
 func (n *SelectorExpr) SetSym(x *types.Sym) { n.Sel = x }
-func (n *SelectorExpr) Offset() int64       { return n.offset }
-func (n *SelectorExpr) SetOffset(x int64)   { n.offset = x }
+func (n *SelectorExpr) Offset() int64       { return n.Offset_ }
+func (n *SelectorExpr) SetOffset(x int64)   { n.Offset_ = x }
 
 // Before type-checking, bytes.Buffer is a SelectorExpr.
 // After type-checking it becomes a Name.
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 319c40e4e9..4cf12f2c5d 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -132,6 +132,14 @@ func NewNameAt(pos src.XPos, sym *types.Sym) *Name {
 	return newNameAt(pos, ONAME, sym)
 }
 
+// NewIota returns a new OIOTA Node.
+func NewIota(pos src.XPos, sym *types.Sym) *Name {
+	if sym == nil {
+		base.Fatalf("NewIota nil")
+	}
+	return newNameAt(pos, OIOTA, sym)
+}
+
 // NewDeclNameAt returns a new ONONAME Node associated with symbol s at position pos.
 // The caller is responsible for setting Curfn.
 func NewDeclNameAt(pos src.XPos, sym *types.Sym) *Name {
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index d6dab0b9e2..0191014133 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -681,30 +681,31 @@ func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
 	switch op {
 	default:
 		panic("NodAt " + op.String())
-	case OADD, OAND, OANDAND, OANDNOT, ODIV, OEQ, OGE, OGT, OLE,
-		OLSH, OLT, OMOD, OMUL, ONE, OOR, OOROR, ORSH, OSUB, OXOR,
+	case OADD, OAND, OANDNOT, ODIV, OEQ, OGE, OGT, OLE,
+		OLSH, OLT, OMOD, OMUL, ONE, OOR, ORSH, OSUB, OXOR,
 		OCOPY, OCOMPLEX,
 		OEFACE:
 		return NewBinaryExpr(pos, op, nleft, nright)
-	case OADDR, OPTRLIT:
+	case OADDR:
 		return NewAddrExpr(pos, nleft)
 	case OADDSTR:
 		return NewAddStringExpr(pos, nil)
+	case OANDAND, OOROR:
+		return NewLogicalExpr(pos, op, nleft, nright)
 	case OARRAYLIT, OCOMPLIT, OMAPLIT, OSTRUCTLIT, OSLICELIT:
 		var typ Ntype
 		if nright != nil {
 			typ = nright.(Ntype)
 		}
-		n := NewCompLitExpr(pos, typ, nil)
-		n.SetOp(op)
-		return n
+		return NewCompLitExpr(pos, op, typ, nil)
 	case OAS, OSELRECV:
 		n := NewAssignStmt(pos, nleft, nright)
-		n.SetOp(op)
+		if op != OAS {
+			n.SetOp(op)
+		}
 		return n
 	case OAS2, OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV, OSELRECV2:
-		n := NewAssignListStmt(pos, nil, nil)
-		n.SetOp(op)
+		n := NewAssignListStmt(pos, op, nil, nil)
 		return n
 	case OASOP:
 		return NewAssignOpStmt(pos, OXXX, nleft, nright)
@@ -722,9 +723,7 @@ func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
 		return NewBranchStmt(pos, op, nil)
 	case OCALL, OCALLFUNC, OCALLINTER, OCALLMETH,
 		OAPPEND, ODELETE, OGETG, OMAKE, OPRINT, OPRINTN, ORECOVER:
-		n := NewCallExpr(pos, nleft, nil)
-		n.SetOp(op)
-		return n
+		return NewCallExpr(pos, op, nleft, nil)
 	case OCASE:
 		return NewCaseStmt(pos, nil, nil)
 	case OCONV, OCONVIFACE, OCONVNOP, ORUNESTR:
@@ -733,38 +732,38 @@ func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
 		return NewDecl(pos, op, nleft)
 	case ODCLFUNC:
 		return NewFunc(pos)
-	case ODEFER:
-		return NewDeferStmt(pos, nleft)
+	case ODEFER, OGO:
+		return NewGoDeferStmt(pos, op, nleft)
 	case ODEREF:
 		return NewStarExpr(pos, nleft)
 	case ODOT, ODOTPTR, ODOTMETH, ODOTINTER, OXDOT:
-		n := NewSelectorExpr(pos, nleft, nil)
-		n.SetOp(op)
-		return n
+		return NewSelectorExpr(pos, op, nleft, nil)
 	case ODOTTYPE, ODOTTYPE2:
 		var typ Ntype
 		if nright != nil {
 			typ = nright.(Ntype)
 		}
 		n := NewTypeAssertExpr(pos, nleft, typ)
-		n.SetOp(op)
+		if op != ODOTTYPE {
+			n.SetOp(op)
+		}
 		return n
 	case OFOR:
 		return NewForStmt(pos, nil, nleft, nright, nil)
-	case OGO:
-		return NewGoStmt(pos, nleft)
 	case OIF:
 		return NewIfStmt(pos, nleft, nil, nil)
 	case OINDEX, OINDEXMAP:
 		n := NewIndexExpr(pos, nleft, nright)
-		n.SetOp(op)
+		if op != OINDEX {
+			n.SetOp(op)
+		}
 		return n
 	case OINLMARK:
 		return NewInlineMarkStmt(pos, types.BADWIDTH)
-	case OKEY, OSTRUCTKEY:
-		n := NewKeyExpr(pos, nleft, nright)
-		n.SetOp(op)
-		return n
+	case OKEY:
+		return NewKeyExpr(pos, nleft, nright)
+	case OSTRUCTKEY:
+		return NewStructKeyExpr(pos, nil, nleft)
 	case OLABEL:
 		return NewLabelStmt(pos, nil)
 	case OLITERAL, OTYPE, OIOTA:
@@ -772,7 +771,7 @@ func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
 	case OMAKECHAN, OMAKEMAP, OMAKESLICE, OMAKESLICECOPY:
 		return NewMakeExpr(pos, op, nleft, nright)
 	case OMETHEXPR:
-		return NewMethodExpr(pos, op, nleft, nright)
+		return NewMethodExpr(pos, nleft, nright)
 	case ONIL:
 		return NewNilExpr(pos)
 	case OPACK:
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index b3fd89c367..4eedcfdd29 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -280,19 +280,19 @@ func (n *ClosureExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 }
 
-func (n *ClosureRead) String() string                { return fmt.Sprint(n) }
-func (n *ClosureRead) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *ClosureRead) copy() Node {
+func (n *ClosureReadExpr) String() string                { return fmt.Sprint(n) }
+func (n *ClosureReadExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ClosureReadExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
 	return &c
 }
-func (n *ClosureRead) doChildren(do func(Node) error) error {
+func (n *ClosureReadExpr) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
 	return err
 }
-func (n *ClosureRead) editChildren(edit func(Node) Node) {
+func (n *ClosureReadExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 }
 
@@ -366,24 +366,6 @@ func (n *Decl) editChildren(edit func(Node) Node) {
 	n.X = maybeEdit(n.X, edit)
 }
 
-func (n *DeferStmt) String() string                { return fmt.Sprint(n) }
-func (n *DeferStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *DeferStmt) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *DeferStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.Call, err, do)
-	return err
-}
-func (n *DeferStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.Call = maybeEdit(n.Call, edit)
-}
-
 func (n *ForStmt) String() string                { return fmt.Sprint(n) }
 func (n *ForStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *ForStmt) copy() Node {
@@ -450,20 +432,20 @@ func (n *FuncType) editChildren(edit func(Node) Node) {
 	editFields(n.Results, edit)
 }
 
-func (n *GoStmt) String() string                { return fmt.Sprint(n) }
-func (n *GoStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *GoStmt) copy() Node {
+func (n *GoDeferStmt) String() string                { return fmt.Sprint(n) }
+func (n *GoDeferStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *GoDeferStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
 	return &c
 }
-func (n *GoStmt) doChildren(do func(Node) error) error {
+func (n *GoDeferStmt) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
 	err = maybeDo(n.Call, err, do)
 	return err
 }
-func (n *GoStmt) editChildren(edit func(Node) Node) {
+func (n *GoDeferStmt) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	n.Call = maybeEdit(n.Call, edit)
 }
@@ -602,6 +584,26 @@ func (n *LabelStmt) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 }
 
+func (n *LogicalExpr) String() string                { return fmt.Sprint(n) }
+func (n *LogicalExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *LogicalExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *LogicalExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.X, err, do)
+	err = maybeDo(n.Y, err, do)
+	return err
+}
+func (n *LogicalExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.X = maybeEdit(n.X, edit)
+	n.Y = maybeEdit(n.Y, edit)
+}
+
 func (n *MakeExpr) String() string                { return fmt.Sprint(n) }
 func (n *MakeExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *MakeExpr) copy() Node {
@@ -913,6 +915,24 @@ func (n *StarExpr) editChildren(edit func(Node) Node) {
 	n.X = maybeEdit(n.X, edit)
 }
 
+func (n *StructKeyExpr) String() string                { return fmt.Sprint(n) }
+func (n *StructKeyExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *StructKeyExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *StructKeyExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDo(n.Value, err, do)
+	return err
+}
+func (n *StructKeyExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	n.Value = maybeEdit(n.Value, edit)
+}
+
 func (n *StructType) String() string                { return fmt.Sprint(n) }
 func (n *StructType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *StructType) copy() Node {
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index 68f9b0bd7c..28c40c0781 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -63,19 +63,19 @@ func (n *miniStmt) SetHasCall(b bool) { n.bits.set(miniHasCall, b) }
 // If Def is true, the assignment is a :=.
 type AssignListStmt struct {
 	miniStmt
-	Lhs    Nodes
-	Def    bool
-	Rhs    Nodes
-	offset int64 // for initorder
+	Lhs     Nodes
+	Def     bool
+	Rhs     Nodes
+	Offset_ int64 // for initorder
 }
 
-func NewAssignListStmt(pos src.XPos, lhs, rhs []Node) *AssignListStmt {
+func NewAssignListStmt(pos src.XPos, op Op, lhs, rhs []Node) *AssignListStmt {
 	n := &AssignListStmt{}
 	n.pos = pos
-	n.op = OAS2
+	n.SetOp(op)
 	n.Lhs.Set(lhs)
 	n.Rhs.Set(rhs)
-	n.offset = types.BADWIDTH
+	n.Offset_ = types.BADWIDTH
 	return n
 }
 
@@ -87,8 +87,8 @@ func (n *AssignListStmt) PtrRlist() *Nodes  { return &n.Rhs }
 func (n *AssignListStmt) SetRlist(x Nodes)  { n.Rhs = x }
 func (n *AssignListStmt) Colas() bool       { return n.Def }
 func (n *AssignListStmt) SetColas(x bool)   { n.Def = x }
-func (n *AssignListStmt) Offset() int64     { return n.offset }
-func (n *AssignListStmt) SetOffset(x int64) { n.offset = x }
+func (n *AssignListStmt) Offset() int64     { return n.Offset_ }
+func (n *AssignListStmt) SetOffset(x int64) { n.Offset_ = x }
 
 func (n *AssignListStmt) SetOp(op Op) {
 	switch op {
@@ -103,17 +103,17 @@ func (n *AssignListStmt) SetOp(op Op) {
 // If Def is true, the assignment is a :=.
 type AssignStmt struct {
 	miniStmt
-	X      Node
-	Def    bool
-	Y      Node
-	offset int64 // for initorder
+	X       Node
+	Def     bool
+	Y       Node
+	Offset_ int64 // for initorder
 }
 
 func NewAssignStmt(pos src.XPos, x, y Node) *AssignStmt {
 	n := &AssignStmt{X: x, Y: y}
 	n.pos = pos
 	n.op = OAS
-	n.offset = types.BADWIDTH
+	n.Offset_ = types.BADWIDTH
 	return n
 }
 
@@ -123,8 +123,8 @@ func (n *AssignStmt) Right() Node       { return n.Y }
 func (n *AssignStmt) SetRight(y Node)   { n.Y = y }
 func (n *AssignStmt) Colas() bool       { return n.Def }
 func (n *AssignStmt) SetColas(x bool)   { n.Def = x }
-func (n *AssignStmt) Offset() int64     { return n.offset }
-func (n *AssignStmt) SetOffset(x int64) { n.offset = x }
+func (n *AssignStmt) Offset() int64     { return n.Offset_ }
+func (n *AssignStmt) SetOffset(x int64) { n.Offset_ = x }
 
 func (n *AssignStmt) SetOp(op Op) {
 	switch op {
@@ -236,32 +236,16 @@ func (n *CaseStmt) SetRlist(x Nodes) { n.Vars = x }
 func (n *CaseStmt) Left() Node       { return n.Comm }
 func (n *CaseStmt) SetLeft(x Node)   { n.Comm = x }
 
-// A DeferStmt is a defer statement: defer Call.
-type DeferStmt struct {
-	miniStmt
-	Call Node
-}
-
-func NewDeferStmt(pos src.XPos, call Node) *DeferStmt {
-	n := &DeferStmt{Call: call}
-	n.pos = pos
-	n.op = ODEFER
-	return n
-}
-
-func (n *DeferStmt) Left() Node     { return n.Call }
-func (n *DeferStmt) SetLeft(x Node) { n.Call = x }
-
 // A ForStmt is a non-range for loop: for Init; Cond; Post { Body }
 // Op can be OFOR or OFORUNTIL (!Cond).
 type ForStmt struct {
 	miniStmt
-	Label    *types.Sym
-	Cond     Node
-	Late     Nodes
-	Post     Node
-	Body_    Nodes
-	hasBreak bool
+	Label     *types.Sym
+	Cond      Node
+	Late      Nodes
+	Post      Node
+	Body_     Nodes
+	HasBreak_ bool
 }
 
 func NewForStmt(pos src.XPos, init []Node, cond, post Node, body []Node) *ForStmt {
@@ -285,8 +269,8 @@ func (n *ForStmt) SetBody(x Nodes)     { n.Body_ = x }
 func (n *ForStmt) List() Nodes         { return n.Late }
 func (n *ForStmt) PtrList() *Nodes     { return &n.Late }
 func (n *ForStmt) SetList(x Nodes)     { n.Late = x }
-func (n *ForStmt) HasBreak() bool      { return n.hasBreak }
-func (n *ForStmt) SetHasBreak(b bool)  { n.hasBreak = b }
+func (n *ForStmt) HasBreak() bool      { return n.HasBreak_ }
+func (n *ForStmt) SetHasBreak(b bool)  { n.HasBreak_ = b }
 
 func (n *ForStmt) SetOp(op Op) {
 	if op != OFOR && op != OFORUNTIL {
@@ -295,29 +279,38 @@ func (n *ForStmt) SetOp(op Op) {
 	n.op = op
 }
 
-// A GoStmt is a go statement: go Call.
-type GoStmt struct {
+// A GoDeferStmt is a go or defer statement: go Call / defer Call.
+//
+// The two opcodes use a signle syntax because the implementations
+// are very similar: both are concerned with saving Call and running it
+// in a different context (a separate goroutine or a later time).
+type GoDeferStmt struct {
 	miniStmt
 	Call Node
 }
 
-func NewGoStmt(pos src.XPos, call Node) *GoStmt {
-	n := &GoStmt{Call: call}
+func NewGoDeferStmt(pos src.XPos, op Op, call Node) *GoDeferStmt {
+	n := &GoDeferStmt{Call: call}
 	n.pos = pos
-	n.op = OGO
+	switch op {
+	case ODEFER, OGO:
+		n.op = op
+	default:
+		panic("NewGoDeferStmt " + op.String())
+	}
 	return n
 }
 
-func (n *GoStmt) Left() Node     { return n.Call }
-func (n *GoStmt) SetLeft(x Node) { n.Call = x }
+func (n *GoDeferStmt) Left() Node     { return n.Call }
+func (n *GoDeferStmt) SetLeft(x Node) { n.Call = x }
 
 // A IfStmt is a return statement: if Init; Cond { Then } else { Else }.
 type IfStmt struct {
 	miniStmt
-	Cond   Node
-	Body_  Nodes
-	Else   Nodes
-	likely bool // code layout hint
+	Cond    Node
+	Body_   Nodes
+	Else    Nodes
+	Likely_ bool // code layout hint
 }
 
 func NewIfStmt(pos src.XPos, cond Node, body, els []Node) *IfStmt {
@@ -337,8 +330,8 @@ func (n *IfStmt) SetBody(x Nodes)  { n.Body_ = x }
 func (n *IfStmt) Rlist() Nodes     { return n.Else }
 func (n *IfStmt) PtrRlist() *Nodes { return &n.Else }
 func (n *IfStmt) SetRlist(x Nodes) { n.Else = x }
-func (n *IfStmt) Likely() bool     { return n.likely }
-func (n *IfStmt) SetLikely(x bool) { n.likely = x }
+func (n *IfStmt) Likely() bool     { return n.Likely_ }
+func (n *IfStmt) SetLikely(x bool) { n.Likely_ = x }
 
 // An InlineMarkStmt is a marker placed just before an inlined body.
 type InlineMarkStmt struct {
@@ -376,13 +369,13 @@ func (n *LabelStmt) SetSym(x *types.Sym) { n.Label = x }
 // Op can be OFOR or OFORUNTIL (!Cond).
 type RangeStmt struct {
 	miniStmt
-	Label    *types.Sym
-	Vars     Nodes // TODO(rsc): Replace with Key, Value Node
-	Def      bool
-	X        Node
-	Body_    Nodes
-	hasBreak bool
-	typ      *types.Type // TODO(rsc): Remove - use X.Type() instead
+	Label     *types.Sym
+	Vars      Nodes // TODO(rsc): Replace with Key, Value Node
+	Def       bool
+	X         Node
+	Body_     Nodes
+	HasBreak_ bool
+	typ       *types.Type // TODO(rsc): Remove - use X.Type() instead
 }
 
 func NewRangeStmt(pos src.XPos, vars []Node, x Node, body []Node) *RangeStmt {
@@ -404,8 +397,8 @@ func (n *RangeStmt) SetBody(x Nodes)       { n.Body_ = x }
 func (n *RangeStmt) List() Nodes           { return n.Vars }
 func (n *RangeStmt) PtrList() *Nodes       { return &n.Vars }
 func (n *RangeStmt) SetList(x Nodes)       { n.Vars = x }
-func (n *RangeStmt) HasBreak() bool        { return n.hasBreak }
-func (n *RangeStmt) SetHasBreak(b bool)    { n.hasBreak = b }
+func (n *RangeStmt) HasBreak() bool        { return n.HasBreak_ }
+func (n *RangeStmt) SetHasBreak(b bool)    { n.HasBreak_ = b }
 func (n *RangeStmt) Colas() bool           { return n.Def }
 func (n *RangeStmt) SetColas(b bool)       { n.Def = b }
 func (n *RangeStmt) Type() *types.Type     { return n.typ }
@@ -437,9 +430,9 @@ func (n *ReturnStmt) IsDDD() bool     { return false } // typecheckargs asks
 // A SelectStmt is a block: { Cases }.
 type SelectStmt struct {
 	miniStmt
-	Label    *types.Sym
-	Cases    Nodes
-	hasBreak bool
+	Label     *types.Sym
+	Cases     Nodes
+	HasBreak_ bool
 
 	// TODO(rsc): Instead of recording here, replace with a block?
 	Compiled Nodes // compiled form, after walkswitch
@@ -458,8 +451,8 @@ func (n *SelectStmt) PtrList() *Nodes     { return &n.Cases }
 func (n *SelectStmt) SetList(x Nodes)     { n.Cases = x }
 func (n *SelectStmt) Sym() *types.Sym     { return n.Label }
 func (n *SelectStmt) SetSym(x *types.Sym) { n.Label = x }
-func (n *SelectStmt) HasBreak() bool      { return n.hasBreak }
-func (n *SelectStmt) SetHasBreak(x bool)  { n.hasBreak = x }
+func (n *SelectStmt) HasBreak() bool      { return n.HasBreak_ }
+func (n *SelectStmt) SetHasBreak(x bool)  { n.HasBreak_ = x }
 func (n *SelectStmt) Body() Nodes         { return n.Compiled }
 func (n *SelectStmt) PtrBody() *Nodes     { return &n.Compiled }
 func (n *SelectStmt) SetBody(x Nodes)     { n.Compiled = x }
@@ -486,10 +479,10 @@ func (n *SendStmt) SetRight(y Node) { n.Value = y }
 // A SwitchStmt is a switch statement: switch Init; Expr { Cases }.
 type SwitchStmt struct {
 	miniStmt
-	Tag      Node
-	Cases    Nodes // list of *CaseStmt
-	Label    *types.Sym
-	hasBreak bool
+	Tag       Node
+	Cases     Nodes // list of *CaseStmt
+	Label     *types.Sym
+	HasBreak_ bool
 
 	// TODO(rsc): Instead of recording here, replace with a block?
 	Compiled Nodes // compiled form, after walkswitch
@@ -513,8 +506,8 @@ func (n *SwitchStmt) PtrBody() *Nodes     { return &n.Compiled }
 func (n *SwitchStmt) SetBody(x Nodes)     { n.Compiled = x }
 func (n *SwitchStmt) Sym() *types.Sym     { return n.Label }
 func (n *SwitchStmt) SetSym(x *types.Sym) { n.Label = x }
-func (n *SwitchStmt) HasBreak() bool      { return n.hasBreak }
-func (n *SwitchStmt) SetHasBreak(x bool)  { n.hasBreak = x }
+func (n *SwitchStmt) HasBreak() bool      { return n.HasBreak_ }
+func (n *SwitchStmt) SetHasBreak(x bool)  { n.HasBreak_ = x }
 
 // A TypeSwitchGuard is the [Name :=] X.(type) in a type switch.
 type TypeSwitchGuard struct {
diff --git a/src/cmd/compile/internal/ir/val.go b/src/cmd/compile/internal/ir/val.go
index ad0df5508d..5b0506c0d0 100644
--- a/src/cmd/compile/internal/ir/val.go
+++ b/src/cmd/compile/internal/ir/val.go
@@ -92,7 +92,7 @@ func ValidTypeForConst(t *types.Type, v constant.Value) bool {
 
 // nodlit returns a new untyped constant with value v.
 func NewLiteral(v constant.Value) Node {
-	n := Nod(OLITERAL, nil, nil)
+	n := newNameAt(base.Pos, OLITERAL, nil)
 	if k := v.Kind(); k != constant.Unknown {
 		n.SetType(idealType(k))
 		n.SetVal(v)
-- 
GitLab


From eae8fd519b2cbfa253f2f9068587e0ce765efced Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 8 Dec 2020 01:28:57 -0800
Subject: [PATCH 0198/2400] [dev.regabi] cmd/compile: iexport debug crumbs for
 toolstash

Prints offsets for declarations, inline bodies, and strings when -v is
used. Still not much, but hopefully useful for narrowing down the
cause of export data differences.

Change-Id: I9b2e4a3d55b92823fa45a39923e8c4b25303693c
Reviewed-on: https://go-review.googlesource.com/c/go/+/276112
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/gc/iexport.go | 26 +++++++++++++++++++++++---
 1 file changed, 23 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index b1cc9a3dd9..14356013de 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -290,6 +290,10 @@ func iexport(out *bufio.Writer) {
 	w.writeIndex(p.inlineIndex, false)
 	w.flush()
 
+	if *base.Flag.LowerV {
+		fmt.Printf("export: hdr strings %v, data %v, index %v\n", p.strings.Len(), dataLen, p.data0.Len())
+	}
+
 	// Assemble header.
 	var hdr intWriter
 	hdr.WriteByte('i')
@@ -389,6 +393,10 @@ func (p *iexporter) stringOff(s string) uint64 {
 		off = uint64(p.strings.Len())
 		p.stringIndex[s] = off
 
+		if *base.Flag.LowerV {
+			fmt.Printf("export: str %v %.40q\n", off, s)
+		}
+
 		p.strings.uint64(uint64(len(s)))
 		p.strings.WriteString(s)
 	}
@@ -511,20 +519,28 @@ func (p *iexporter) doDecl(n *ir.Name) {
 		base.Fatalf("unexpected node: %v", n)
 	}
 
-	p.declIndex[n.Sym()] = w.flush()
+	w.finish("dcl", p.declIndex, n.Sym())
 }
 
 func (w *exportWriter) tag(tag byte) {
 	w.data.WriteByte(tag)
 }
 
+func (w *exportWriter) finish(what string, index map[*types.Sym]uint64, sym *types.Sym) {
+	off := w.flush()
+	if *base.Flag.LowerV {
+		fmt.Printf("export: %v %v %v\n", what, off, sym)
+	}
+	index[sym] = off
+}
+
 func (p *iexporter) doInline(f *ir.Name) {
 	w := p.newWriter()
 	w.setPkg(fnpkg(f), false)
 
 	w.stmtList(ir.AsNodes(f.Func().Inl.Body))
 
-	p.inlineIndex[f.Sym()] = w.flush()
+	w.finish("inl", p.inlineIndex, f.Sym())
 }
 
 func (w *exportWriter) pos(pos src.XPos) {
@@ -625,7 +641,11 @@ func (p *iexporter) typOff(t *types.Type) uint64 {
 	if !ok {
 		w := p.newWriter()
 		w.doTyp(t)
-		off = predeclReserved + w.flush()
+		rawOff := w.flush()
+		if *base.Flag.LowerV {
+			fmt.Printf("export: typ %v %v\n", rawOff, t)
+		}
+		off = predeclReserved + rawOff
 		p.typIndex[t] = off
 	}
 	return off
-- 
GitLab


From 63bc23b5452f6605df3e40ce7ecdd8b0348792af Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 7 Dec 2020 21:56:58 -0800
Subject: [PATCH 0199/2400] [dev.regabi] cmd/compile: first start towards using
 Ident

This CL adds Ident, which will eventually replace *Name and *PkgName
within the AST for representing uses of declared names. (Originally, I
intended to call it "IdentExpr", but neither go/ast nor
cmd/compile/internal/syntax include the "Expr" suffix for their
respective types.)

To start, this CL converts two uses of *Name to *Ident: the tag
identifier in a TypeSwitchGuard (which doesn't actually declare a
variable by itself), and the not-yet-known placeholder ONONAME
returned by oldname to stand-in for identifiers that might be declared
later in the package.

The TypeSwitchGuard's Name's Used flag was previously used for
detecting whether none of the per-clause variables were used. To avoid
bloating all Idents for this rare use, a "Used" bool is added to
TypeSwitchGuard instead. Eventually it could maybe be packed into
miniNode.bits, but for now this is good enough.

Passes buildall w/ toolstash -cmp.

Change-Id: I393284d86757cbbebd26e1320c7354e2bdcb30b0
Reviewed-on: https://go-review.googlesource.com/c/go/+/276113
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/gc/dcl.go       |  2 +-
 src/cmd/compile/internal/gc/iimport.go   | 10 +++++-----
 src/cmd/compile/internal/gc/noder.go     | 10 +++++-----
 src/cmd/compile/internal/gc/typecheck.go |  8 ++++++--
 src/cmd/compile/internal/gc/walk.go      | 10 +++++-----
 src/cmd/compile/internal/ir/mknode.go    |  8 ++++----
 src/cmd/compile/internal/ir/name.go      | 19 +++++++++++++++++++
 src/cmd/compile/internal/ir/node.go      |  2 --
 src/cmd/compile/internal/ir/node_gen.go  | 24 ++++++++++++++++++++----
 src/cmd/compile/internal/ir/stmt.go      | 20 +++++++++-----------
 10 files changed, 74 insertions(+), 39 deletions(-)

diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 1c23c5a92f..1ebadd9213 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -215,7 +215,7 @@ func oldname(s *types.Sym) ir.Node {
 		// Maybe a top-level declaration will come along later to
 		// define s. resolve will check s.Def again once all input
 		// source has been processed.
-		return ir.NewDeclNameAt(base.Pos, s)
+		return ir.NewIdent(base.Pos, s)
 	}
 
 	if Curfn != nil && n.Op() == ir.ONAME && n.Name().Curfn != nil && n.Name().Curfn != Curfn {
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 1f75393b3e..3c9693e5fc 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -833,13 +833,13 @@ func (r *importReader) node() ir.Node {
 		return ir.TypeNode(r.typ())
 
 	case ir.OTYPESW:
-		n := ir.NodAt(r.pos(), ir.OTYPESW, nil, nil)
+		pos := r.pos()
+		var tag *ir.Ident
 		if s := r.ident(); s != nil {
-			n.SetLeft(ir.NewDeclNameAt(n.Pos(), s))
+			tag = ir.NewIdent(pos, s)
 		}
-		right, _ := r.exprsOrNil()
-		n.SetRight(right)
-		return n
+		expr, _ := r.exprsOrNil()
+		return ir.NewTypeSwitchGuard(pos, tag, expr)
 
 	// case OTARRAY, OTMAP, OTCHAN, OTSTRUCT, OTINTER, OTFUNC:
 	//      unreachable - should have been resolved by typechecking
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index f39bf2ff3c..8c765f9dfc 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -751,14 +751,14 @@ func (p *noder) expr(expr syntax.Expr) ir.Node {
 			p.typeExpr(expr.Elem), p.chanDir(expr.Dir))
 
 	case *syntax.TypeSwitchGuard:
-		n := p.nod(expr, ir.OTYPESW, nil, p.expr(expr.X))
+		var tag *ir.Ident
 		if expr.Lhs != nil {
-			n.SetLeft(p.declName(expr.Lhs))
-			if ir.IsBlank(n.Left()) {
-				base.Errorf("invalid variable name %v in type switch", n.Left())
+			tag = ir.NewIdent(p.pos(expr.Lhs), p.name(expr.Lhs))
+			if ir.IsBlank(tag) {
+				base.Errorf("invalid variable name %v in type switch", tag)
 			}
 		}
-		return n
+		return ir.NewTypeSwitchGuard(p.pos(expr), tag, p.expr(expr.X))
 	}
 	panic("unhandled Expr")
 }
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 36526d4c2d..d88989f83c 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -90,12 +90,16 @@ func resolve(n ir.Node) (res ir.Node) {
 		defer tracePrint("resolve", n)(&res)
 	}
 
-	if n.Sym().Pkg != types.LocalPkg {
+	// Stub ir.Name left for us by iimport.
+	if n, ok := n.(*ir.Name); ok {
+		if n.Sym().Pkg == types.LocalPkg {
+			base.Fatalf("unexpected Name: %+v", n)
+		}
 		if inimport {
 			base.Fatalf("recursive inimport")
 		}
 		inimport = true
-		expandDecl(n.(*ir.Name))
+		expandDecl(n)
 		inimport = false
 		return n
 	}
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index f35e9d768b..390719e441 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -44,7 +44,7 @@ func walk(fn *ir.Func) {
 	// Propagate the used flag for typeswitch variables up to the NONAME in its definition.
 	for _, ln := range fn.Dcl {
 		if ln.Op() == ir.ONAME && (ln.Class() == ir.PAUTO || ln.Class() == ir.PAUTOHEAP) && ln.Defn != nil && ln.Defn.Op() == ir.OTYPESW && ln.Used() {
-			ln.Defn.Left().Name().SetUsed(true)
+			ln.Defn.(*ir.TypeSwitchGuard).Used = true
 		}
 	}
 
@@ -52,12 +52,12 @@ func walk(fn *ir.Func) {
 		if ln.Op() != ir.ONAME || (ln.Class() != ir.PAUTO && ln.Class() != ir.PAUTOHEAP) || ln.Sym().Name[0] == '&' || ln.Used() {
 			continue
 		}
-		if defn := ln.Defn; defn != nil && defn.Op() == ir.OTYPESW {
-			if defn.Left().Name().Used() {
+		if defn, ok := ln.Defn.(*ir.TypeSwitchGuard); ok {
+			if defn.Used {
 				continue
 			}
-			base.ErrorfAt(defn.Left().Pos(), "%v declared but not used", ln.Sym())
-			defn.Left().Name().SetUsed(true) // suppress repeats
+			base.ErrorfAt(defn.Tag.Pos(), "%v declared but not used", ln.Sym())
+			defn.Used = true // suppress repeats
 		} else {
 			base.ErrorfAt(ln.Pos(), "%v declared but not used", ln.Sym())
 		}
diff --git a/src/cmd/compile/internal/ir/mknode.go b/src/cmd/compile/internal/ir/mknode.go
index 72034022cb..18d768ceb1 100644
--- a/src/cmd/compile/internal/ir/mknode.go
+++ b/src/cmd/compile/internal/ir/mknode.go
@@ -39,7 +39,7 @@ func main() {
 	nodesType := lookup("Nodes")
 	ptrFieldType := types.NewPointer(lookup("Field"))
 	slicePtrFieldType := types.NewSlice(ptrFieldType)
-	ptrNameType := types.NewPointer(lookup("Name"))
+	ptrIdentType := types.NewPointer(lookup("Ident"))
 
 	var buf bytes.Buffer
 	fmt.Fprintln(&buf, "// Code generated by mknode.go. DO NOT EDIT.")
@@ -84,7 +84,7 @@ func main() {
 		fmt.Fprintf(&buf, "func (n *%s) doChildren(do func(Node) error) error { var err error\n", name)
 		forNodeFields(typName, typ, func(name string, is func(types.Type) bool) {
 			switch {
-			case is(ptrNameType):
+			case is(ptrIdentType):
 				fmt.Fprintf(&buf, "if n.%s != nil { err = maybeDo(n.%s, err, do) }\n", name, name)
 			case is(nodeType), is(ntypeType):
 				fmt.Fprintf(&buf, "err = maybeDo(n.%s, err, do)\n", name)
@@ -101,8 +101,8 @@ func main() {
 		fmt.Fprintf(&buf, "func (n *%s) editChildren(edit func(Node) Node) {\n", name)
 		forNodeFields(typName, typ, func(name string, is func(types.Type) bool) {
 			switch {
-			case is(ptrNameType):
-				fmt.Fprintf(&buf, "if n.%s != nil { n.%s = edit(n.%s).(*Name) }\n", name, name, name)
+			case is(ptrIdentType):
+				fmt.Fprintf(&buf, "if n.%s != nil { n.%s = edit(n.%s).(*Ident) }\n", name, name, name)
 			case is(nodeType):
 				fmt.Fprintf(&buf, "n.%s = maybeEdit(n.%s, edit)\n", name, name)
 			case is(ntypeType):
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 4cf12f2c5d..2330838f1c 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -13,6 +13,25 @@ import (
 	"go/constant"
 )
 
+// An Ident is an identifier, possibly qualified.
+type Ident struct {
+	miniExpr
+	sym  *types.Sym
+	Used bool
+}
+
+func NewIdent(pos src.XPos, sym *types.Sym) *Ident {
+	n := new(Ident)
+	n.op = ONONAME
+	n.pos = pos
+	n.sym = sym
+	return n
+}
+
+func (n *Ident) Sym() *types.Sym { return n.sym }
+
+func (*Ident) CanBeNtype() {}
+
 // Name holds Node fields used only by named nodes (ONAME, OTYPE, some OLITERAL).
 type Name struct {
 	miniExpr
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 0191014133..598659a3db 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -794,8 +794,6 @@ func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
 		return NewSliceHeaderExpr(pos, nil, nleft, nil, nil)
 	case OSWITCH:
 		return NewSwitchStmt(pos, nleft, nil)
-	case OTYPESW:
-		return NewTypeSwitchGuard(pos, nleft, nright)
 	case OINLCALL:
 		return NewInlinedCallExpr(pos, nil, nil)
 	}
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index 4eedcfdd29..264171e797 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -450,6 +450,22 @@ func (n *GoDeferStmt) editChildren(edit func(Node) Node) {
 	n.Call = maybeEdit(n.Call, edit)
 }
 
+func (n *Ident) String() string                { return fmt.Sprint(n) }
+func (n *Ident) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *Ident) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *Ident) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	return err
+}
+func (n *Ident) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+}
+
 func (n *IfStmt) String() string                { return fmt.Sprint(n) }
 func (n *IfStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *IfStmt) copy() Node {
@@ -1004,15 +1020,15 @@ func (n *TypeSwitchGuard) copy() Node {
 }
 func (n *TypeSwitchGuard) doChildren(do func(Node) error) error {
 	var err error
-	if n.Name_ != nil {
-		err = maybeDo(n.Name_, err, do)
+	if n.Tag != nil {
+		err = maybeDo(n.Tag, err, do)
 	}
 	err = maybeDo(n.X, err, do)
 	return err
 }
 func (n *TypeSwitchGuard) editChildren(edit func(Node) Node) {
-	if n.Name_ != nil {
-		n.Name_ = edit(n.Name_).(*Name)
+	if n.Tag != nil {
+		n.Tag = edit(n.Tag).(*Ident)
 	}
 	n.X = maybeEdit(n.X, edit)
 }
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index 28c40c0781..f41c50c92b 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -512,32 +512,30 @@ func (n *SwitchStmt) SetHasBreak(x bool)  { n.HasBreak_ = x }
 // A TypeSwitchGuard is the [Name :=] X.(type) in a type switch.
 type TypeSwitchGuard struct {
 	miniNode
-	Name_ *Name
-	X     Node
+	Tag  *Ident
+	X    Node
+	Used bool
 }
 
-func NewTypeSwitchGuard(pos src.XPos, name, x Node) *TypeSwitchGuard {
-	n := &TypeSwitchGuard{X: x}
-	if name != nil {
-		n.Name_ = name.(*Name)
-	}
+func NewTypeSwitchGuard(pos src.XPos, tag *Ident, x Node) *TypeSwitchGuard {
+	n := &TypeSwitchGuard{Tag: tag, X: x}
 	n.pos = pos
 	n.op = OTYPESW
 	return n
 }
 
 func (n *TypeSwitchGuard) Left() Node {
-	if n.Name_ == nil {
+	if n.Tag == nil {
 		return nil
 	}
-	return n.Name_
+	return n.Tag
 }
 func (n *TypeSwitchGuard) SetLeft(x Node) {
 	if x == nil {
-		n.Name_ = nil
+		n.Tag = nil
 		return
 	}
-	n.Name_ = x.(*Name)
+	n.Tag = x.(*Ident)
 }
 func (n *TypeSwitchGuard) Right() Node     { return n.X }
 func (n *TypeSwitchGuard) SetRight(x Node) { n.X = x }
-- 
GitLab


From 810957b1555358fd22e6dfd75cdceb2117362f91 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 8 Dec 2020 17:48:39 -0800
Subject: [PATCH 0200/2400] [dev.typeparams] cmd/compile/internal/types2:
 adjusted array error message for compiler

Also: Triaged/adjusted some more test/fixedbugs tests.
Change-Id: Idaba1875273d6da6ef82dd8de8edd8daa885d32c
Reviewed-on: https://go-review.googlesource.com/c/go/+/276472
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/expr.go |  6 +++++-
 test/fixedbugs/issue6750.go             |  2 +-
 test/fixedbugs/issue6772.go             |  4 ++--
 test/fixedbugs/issue7129.go             |  6 +++---
 test/fixedbugs/issue7150.go             |  2 +-
 test/fixedbugs/issue7153.go             |  2 +-
 test/fixedbugs/issue7223.go             | 10 +++++-----
 test/fixedbugs/issue7310.go             |  6 +++---
 test/run.go                             | 19 ++++++-------------
 9 files changed, 27 insertions(+), 30 deletions(-)

diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index c68077547e..bede0c639d 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -1039,7 +1039,11 @@ func (check *Checker) index(index syntax.Expr, max int64) (typ Type, val int64)
 
 	v, valid := constant.Int64Val(constant.ToInt(x.val))
 	if !valid || max >= 0 && v >= max {
-		check.errorf(&x, "index %s is out of bounds", &x)
+		if check.conf.CompilerErrorMessages {
+			check.errorf(&x, "array index %s out of bounds [0:%d]", x.val.String(), max)
+		} else {
+			check.errorf(&x, "index %s is out of bounds", &x)
+		}
 		return
 	}
 
diff --git a/test/fixedbugs/issue6750.go b/test/fixedbugs/issue6750.go
index f62a85009c..fca4e66aaf 100644
--- a/test/fixedbugs/issue6750.go
+++ b/test/fixedbugs/issue6750.go
@@ -18,5 +18,5 @@ func printmany(nums ...int) {
 func main() {
 	printmany(1, 2, 3)
 	printmany([]int{1, 2, 3}...)
-	printmany(1, "abc", []int{2, 3}...) // ERROR "too many arguments in call to printmany\n\thave \(number, string, \.\.\.int\)\n\twant \(...int\)"
+	printmany(1, "abc", []int{2, 3}...) // ERROR "too many arguments in call( to printmany\n\thave \(number, string, \.\.\.int\)\n\twant \(...int\))?"
 }
diff --git a/test/fixedbugs/issue6772.go b/test/fixedbugs/issue6772.go
index 4d0001c870..cb8d0a11f2 100644
--- a/test/fixedbugs/issue6772.go
+++ b/test/fixedbugs/issue6772.go
@@ -7,14 +7,14 @@
 package p
 
 func f1() {
-	for a, a := range []int{1, 2, 3} { // ERROR "a repeated on left side of :="
+	for a, a := range []int{1, 2, 3} { // ERROR "a repeated on left side of :=|a redeclared"
 		println(a)
 	}
 }
 
 func f2() {
 	var a int
-	for a, a := range []int{1, 2, 3} { // ERROR "a repeated on left side of :="
+	for a, a := range []int{1, 2, 3} { // ERROR "a repeated on left side of :=|a redeclared"
 		println(a)
 	}
 	println(a)
diff --git a/test/fixedbugs/issue7129.go b/test/fixedbugs/issue7129.go
index 2425cbd343..14fc418150 100644
--- a/test/fixedbugs/issue7129.go
+++ b/test/fixedbugs/issue7129.go
@@ -15,7 +15,7 @@ func g() bool { return true }
 func h(int, int) {}
 
 func main() {
-	f(g())        // ERROR "in argument to f"
-	f(true)       // ERROR "in argument to f"
-	h(true, true) // ERROR "in argument to h"
+	f(g())        // ERROR "in argument to f|incompatible type"
+	f(true)       // ERROR "in argument to f|cannot convert"
+	h(true, true) // ERROR "in argument to h|cannot convert"
 }
diff --git a/test/fixedbugs/issue7150.go b/test/fixedbugs/issue7150.go
index 8a8a7d088f..4bd9de8645 100644
--- a/test/fixedbugs/issue7150.go
+++ b/test/fixedbugs/issue7150.go
@@ -9,7 +9,7 @@
 package main
 
 func main() {
-	_ = [0]int{-1: 50}              // ERROR "index must be non-negative integer constant"
+	_ = [0]int{-1: 50}              // ERROR "index must be non-negative integer constant|must not be negative"
 	_ = [0]int{0: 0}                // ERROR "index 0 out of bounds \[0:0\]"
 	_ = [0]int{5: 25}               // ERROR "index 5 out of bounds \[0:0\]"
 	_ = [10]int{2: 10, 15: 30}      // ERROR "index 15 out of bounds \[0:10\]"
diff --git a/test/fixedbugs/issue7153.go b/test/fixedbugs/issue7153.go
index 66b1338496..7a85fb8779 100644
--- a/test/fixedbugs/issue7153.go
+++ b/test/fixedbugs/issue7153.go
@@ -8,4 +8,4 @@
 
 package p
 
-var _ = []int{a: true, true} // ERROR "undefined: a" "cannot use true \(type untyped bool\) as type int in slice literal"
+var _ = []int{a: true, true} // ERROR "undefined: a" "cannot use true \(type untyped bool\) as type int in slice literal|cannot convert true"
diff --git a/test/fixedbugs/issue7223.go b/test/fixedbugs/issue7223.go
index 0ec3476403..c78de287ff 100644
--- a/test/fixedbugs/issue7223.go
+++ b/test/fixedbugs/issue7223.go
@@ -12,9 +12,9 @@ const bits2 uint = 10
 func main() {
 	_ = make([]byte, 1<<bits1)
 	_ = make([]byte, 1<<bits2)
-	_ = make([]byte, nil) // ERROR "non-integer.*len"
-	_ = make([]byte, nil, 2) // ERROR "non-integer.*len"
-	_ = make([]byte, 1, nil) // ERROR "non-integer.*cap"
-	_ = make([]byte, true) // ERROR "non-integer.*len"
-	_ = make([]byte, "abc") // ERROR "non-integer.*len"
+	_ = make([]byte, nil) // ERROR "non-integer.*len|untyped nil"
+	_ = make([]byte, nil, 2) // ERROR "non-integer.*len|untyped nil"
+	_ = make([]byte, 1, nil) // ERROR "non-integer.*cap|untyped nil"
+	_ = make([]byte, true) // ERROR "non-integer.*len|untyped bool"
+	_ = make([]byte, "abc") // ERROR "non-integer.*len|untyped string"
 }
diff --git a/test/fixedbugs/issue7310.go b/test/fixedbugs/issue7310.go
index 6829d5e126..ef099ce41e 100644
--- a/test/fixedbugs/issue7310.go
+++ b/test/fixedbugs/issue7310.go
@@ -9,7 +9,7 @@
 package main
 
 func main() {
-	_ = copy(nil, []int{}) // ERROR "use of untyped nil"
-	_ = copy([]int{}, nil) // ERROR "use of untyped nil"
-	_ = 1 + true           // ERROR "mismatched types untyped int and untyped bool"
+	_ = copy(nil, []int{}) // ERROR "use of untyped nil|untyped nil"
+	_ = copy([]int{}, nil) // ERROR "use of untyped nil|untyped nil"
+	_ = 1 + true           // ERROR "mismatched types untyped int and untyped bool|untyped int .* untyped bool"
 }
diff --git a/test/run.go b/test/run.go
index 32c74e8210..891b9572b7 100644
--- a/test/run.go
+++ b/test/run.go
@@ -2115,19 +2115,12 @@ var excluded = map[string]bool{
 	"fixedbugs/issue6703x.go":  true,
 	"fixedbugs/issue6703y.go":  true,
 	"fixedbugs/issue6703z.go":  true,
-	"fixedbugs/issue6750.go":   true,
-	"fixedbugs/issue6772.go":   true,
-	"fixedbugs/issue6889.go":   true,
-	"fixedbugs/issue7129.go":   true,
-	"fixedbugs/issue7150.go":   true,
-	"fixedbugs/issue7153.go":   true,
-	"fixedbugs/issue7223.go":   true,
-	"fixedbugs/issue7310.go":   true,
-	"fixedbugs/issue7525.go":   true,
-	"fixedbugs/issue7525b.go":  true,
-	"fixedbugs/issue7525c.go":  true,
-	"fixedbugs/issue7525d.go":  true,
-	"fixedbugs/issue7525e.go":  true,
+	"fixedbugs/issue6889.go":   true, // types2 can handle this without constant overflow
+	"fixedbugs/issue7525.go":   true, // init cycle error on different line - ok otherwise
+	"fixedbugs/issue7525b.go":  true, // init cycle error on different line - ok otherwise
+	"fixedbugs/issue7525c.go":  true, // init cycle error on different line - ok otherwise
+	"fixedbugs/issue7525d.go":  true, // init cycle error on different line - ok otherwise
+	"fixedbugs/issue7525e.go":  true, // init cycle error on different line - ok otherwise
 	"fixedbugs/issue7742.go":   true, // type-checking doesn't terminate
 	"fixedbugs/issue7746.go":   true, // type-checking doesn't terminate
 }
-- 
GitLab


From 6812eae2e2b9c69a4046a615f00c83fe9543ffe3 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 8 Dec 2020 17:56:35 -0800
Subject: [PATCH 0201/2400] [dev.typeparams] cmd/compile/internal/types2:
 adjust init cycle error message for compiler

Enabled some more test/fixedbugs tests.

Change-Id: I02102b698eedfbee582b3234850fb01418ebbf7c
Reviewed-on: https://go-review.googlesource.com/c/go/+/276453
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/initorder.go |  6 ++++-
 test/run.go                                  | 26 --------------------
 test/typecheckloop.go                        |  4 +--
 3 files changed, 7 insertions(+), 29 deletions(-)

diff --git a/src/cmd/compile/internal/types2/initorder.go b/src/cmd/compile/internal/types2/initorder.go
index 4ef24764a6..a9cabecdf2 100644
--- a/src/cmd/compile/internal/types2/initorder.go
+++ b/src/cmd/compile/internal/types2/initorder.go
@@ -151,7 +151,11 @@ func findPath(objMap map[Object]*declInfo, from, to Object, seen map[Object]bool
 // reportCycle reports an error for the given cycle.
 func (check *Checker) reportCycle(cycle []Object) {
 	obj := cycle[0]
-	check.errorf(obj, "initialization cycle for %s", obj.Name())
+	if check.conf.CompilerErrorMessages {
+		check.errorf(obj, "initialization loop for %s", obj.Name())
+	} else {
+		check.errorf(obj, "initialization cycle for %s", obj.Name())
+	}
 	// subtle loop: print cycle[i] for i = 0, n-1, n-2, ... 1 for len(cycle) = n
 	for i := len(cycle) - 1; i >= 0; i-- {
 		check.errorf(obj, "\t%s refers to", obj.Name()) // secondary error, \t indented
diff --git a/test/run.go b/test/run.go
index 891b9572b7..3c8a20712b 100644
--- a/test/run.go
+++ b/test/run.go
@@ -2089,32 +2089,6 @@ var excluded = map[string]bool{
 	"fixedbugs/issue6403.go":   true,
 	"fixedbugs/issue6500.go":   true,
 	"fixedbugs/issue6572.go":   true,
-	"fixedbugs/issue6703a.go":  true,
-	"fixedbugs/issue6703b.go":  true,
-	"fixedbugs/issue6703c.go":  true,
-	"fixedbugs/issue6703d.go":  true,
-	"fixedbugs/issue6703e.go":  true,
-	"fixedbugs/issue6703f.go":  true,
-	"fixedbugs/issue6703g.go":  true,
-	"fixedbugs/issue6703h.go":  true,
-	"fixedbugs/issue6703i.go":  true,
-	"fixedbugs/issue6703j.go":  true,
-	"fixedbugs/issue6703k.go":  true,
-	"fixedbugs/issue6703l.go":  true,
-	"fixedbugs/issue6703m.go":  true,
-	"fixedbugs/issue6703n.go":  true,
-	"fixedbugs/issue6703o.go":  true,
-	"fixedbugs/issue6703p.go":  true,
-	"fixedbugs/issue6703q.go":  true,
-	"fixedbugs/issue6703r.go":  true,
-	"fixedbugs/issue6703s.go":  true,
-	"fixedbugs/issue6703t.go":  true,
-	"fixedbugs/issue6703u.go":  true,
-	"fixedbugs/issue6703v.go":  true,
-	"fixedbugs/issue6703w.go":  true,
-	"fixedbugs/issue6703x.go":  true,
-	"fixedbugs/issue6703y.go":  true,
-	"fixedbugs/issue6703z.go":  true,
 	"fixedbugs/issue6889.go":   true, // types2 can handle this without constant overflow
 	"fixedbugs/issue7525.go":   true, // init cycle error on different line - ok otherwise
 	"fixedbugs/issue7525b.go":  true, // init cycle error on different line - ok otherwise
diff --git a/test/typecheckloop.go b/test/typecheckloop.go
index a143e0984c..13f413cfc9 100644
--- a/test/typecheckloop.go
+++ b/test/typecheckloop.go
@@ -9,6 +9,6 @@
 
 package main
 
-const A = 1 + B // ERROR "constant definition loop\n.*A uses B\n.*B uses C\n.*C uses A|initialization cycle"
-const B = C - 1 // ERROR "constant definition loop\n.*B uses C\n.*C uses B|initialization cycle"
+const A = 1 + B // ERROR "constant definition loop\n.*A uses B\n.*B uses C\n.*C uses A|initialization loop"
+const B = C - 1 // ERROR "constant definition loop\n.*B uses C\n.*C uses B|initialization loop"
 const C = A + B + 1
-- 
GitLab


From 43c7b214dba8b2a5bfd7d22b66b875865d0aa0f2 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 8 Dec 2020 22:01:22 -0800
Subject: [PATCH 0202/2400] [dev.typeparams] cmd/compile/internal/types2:
 adjusted qualified identifier error message for compiler

Also: Triaged/adjusted some more test/fixedbugs tests.
Change-Id: I050847b6dfccc7f301f8100bfdbe84e0487e33fc
Reviewed-on: https://go-review.googlesource.com/c/go/+/276512
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/types2/call.go |   6 +-
 test/fixedbugs/issue11326.go            |  16 ++--
 test/fixedbugs/issue11674.go            |  18 ++--
 test/fixedbugs/issue11737.go            |   2 +-
 test/fixedbugs/issue13365.go            |  12 +--
 test/fixedbugs/issue13471.go            |  22 ++---
 test/fixedbugs/issue13480.go            |  18 ++--
 test/fixedbugs/issue13485.go            |   4 +-
 test/fixedbugs/issue13539.go            |   2 +-
 test/fixedbugs/issue13559.go            | 114 ++++++++++++------------
 test/fixedbugs/issue14136.go            |   6 +-
 test/fixedbugs/issue14321.go            |   2 +-
 test/fixedbugs/issue14729.go            |   2 +-
 test/fixedbugs/issue15055.go            |  12 +--
 test/fixedbugs/issue15898.go            |   4 +-
 test/fixedbugs/issue16439.go            |   8 +-
 test/fixedbugs/issue16949.go            |  16 ++--
 test/fixedbugs/issue6402.go             |   2 +-
 test/fixedbugs/issue6572.go             |   3 +-
 test/initloop.go                        |   2 +-
 test/run.go                             |  33 ++-----
 test/runtime.go                         |   2 +-
 22 files changed, 147 insertions(+), 159 deletions(-)

diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index a29096322a..fe3c17fc6b 100644
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -490,7 +490,11 @@ func (check *Checker) selector(x *operand, e *syntax.SelectorExpr) {
 				exp = pkg.scope.Lookup(sel)
 				if exp == nil {
 					if !pkg.fake {
-						check.errorf(e.Sel, "%s not declared by package %s", sel, pkg.name)
+						if check.conf.CompilerErrorMessages {
+							check.errorf(e.Sel, "undefined: %s.%s", pkg.name, sel)
+						} else {
+							check.errorf(e.Sel, "%s not declared by package %s", sel, pkg.name)
+						}
 					}
 					goto Error
 				}
diff --git a/test/fixedbugs/issue11326.go b/test/fixedbugs/issue11326.go
index 82754c73fb..f6cb109ba7 100644
--- a/test/fixedbugs/issue11326.go
+++ b/test/fixedbugs/issue11326.go
@@ -18,14 +18,14 @@ func main() {
 
 	// Any implementation must be able to handle these constants at
 	// compile time (even though they cannot be assigned to a float64).
-	var _ = 1e646456992  // ERROR "1e\+646456992 overflows float64"
-	var _ = 1e64645699   // ERROR "1e\+64645699 overflows float64"
-	var _ = 1e6464569    // ERROR "1e\+6464569 overflows float64"
-	var _ = 1e646456     // ERROR "1e\+646456 overflows float64"
-	var _ = 1e64645      // ERROR "1e\+64645 overflows float64"
-	var _ = 1e6464       // ERROR "1e\+6464 overflows float64"
-	var _ = 1e646        // ERROR "1e\+646 overflows float64"
-	var _ = 1e309        // ERROR "1e\+309 overflows float64"
+	var _ = 1e646456992  // ERROR "1e\+?646456992 .*overflows float64"
+	var _ = 1e64645699   // ERROR "1e\+?64645699 .*overflows float64"
+	var _ = 1e6464569    // ERROR "1e\+?6464569 .*overflows float64"
+	var _ = 1e646456     // ERROR "1e\+?646456 .*overflows float64"
+	var _ = 1e64645      // ERROR "1e\+?64645 .*overflows float64"
+	var _ = 1e6464       // ERROR "1e\+?6464 .*overflows float64"
+	var _ = 1e646        // ERROR "1e\+?646 .*overflows float64"
+	var _ = 1e309        // ERROR "1e\+?309 .*overflows float64"
 
 	var _ = 1e308
 }
diff --git a/test/fixedbugs/issue11674.go b/test/fixedbugs/issue11674.go
index e7d0bf298b..62e8e8f962 100644
--- a/test/fixedbugs/issue11674.go
+++ b/test/fixedbugs/issue11674.go
@@ -13,28 +13,28 @@ const x complex64 = 0
 const y complex128 = 0
 
 var _ = x / 1e-20
-var _ = x / 1e-50   // ERROR "complex division by zero"
-var _ = x / 1e-1000 // ERROR "complex division by zero"
+var _ = x / 1e-50   // ERROR "(complex )?division by zero"
+var _ = x / 1e-1000 // ERROR "(complex )?division by zero"
 var _ = x / 1e-20i
-var _ = x / 1e-50i   // ERROR "complex division by zero"
-var _ = x / 1e-1000i // ERROR "complex division by zero"
+var _ = x / 1e-50i   // ERROR "(complex )?division by zero"
+var _ = x / 1e-1000i // ERROR "(complex )?division by zero"
 
 var _ = x / 1e-45 // smallest positive float32
 
 var _ = x / (1e-20 + 1e-20i)
 var _ = x / (1e-50 + 1e-20i)
 var _ = x / (1e-20 + 1e-50i)
-var _ = x / (1e-50 + 1e-50i)     // ERROR "complex division by zero"
-var _ = x / (1e-1000 + 1e-1000i) // ERROR "complex division by zero"
+var _ = x / (1e-50 + 1e-50i)     // ERROR "(complex )?division by zero"
+var _ = x / (1e-1000 + 1e-1000i) // ERROR "(complex )?division by zero"
 
 var _ = y / 1e-50
-var _ = y / 1e-1000 // ERROR "complex division by zero"
+var _ = y / 1e-1000 // ERROR "(complex )?division by zero"
 var _ = y / 1e-50i
-var _ = y / 1e-1000i // ERROR "complex division by zero"
+var _ = y / 1e-1000i // ERROR "(complex )?division by zero"
 
 var _ = y / 5e-324 // smallest positive float64
 
 var _ = y / (1e-50 + 1e-50)
 var _ = y / (1e-1000 + 1e-50i)
 var _ = y / (1e-50 + 1e-1000i)
-var _ = y / (1e-1000 + 1e-1000i) // ERROR "complex division by zero"
+var _ = y / (1e-1000 + 1e-1000i) // ERROR "(complex )?division by zero"
diff --git a/test/fixedbugs/issue11737.go b/test/fixedbugs/issue11737.go
index 86ecf9ac4b..eb4bfe8964 100644
--- a/test/fixedbugs/issue11737.go
+++ b/test/fixedbugs/issue11737.go
@@ -12,6 +12,6 @@ func f()
 
 func s(x interface{}) {
 	switch x {
-	case f: // ERROR "invalid case f \(type func\(\)\) in switch \(incomparable type\)"
+	case f: // ERROR "invalid case f \(type func\(\)\) in switch \(incomparable type\)|cannot compare"
 	}
 }
diff --git a/test/fixedbugs/issue13365.go b/test/fixedbugs/issue13365.go
index 4bd103e38d..5b07e1a6be 100644
--- a/test/fixedbugs/issue13365.go
+++ b/test/fixedbugs/issue13365.go
@@ -11,15 +11,15 @@ package main
 var t struct{}
 
 func main() {
-	_ = []int{-1: 0}    // ERROR "index must be non\-negative integer constant"
-	_ = [10]int{-1: 0}  // ERROR "index must be non\-negative integer constant"
-	_ = [...]int{-1: 0} // ERROR "index must be non\-negative integer constant"
+	_ = []int{-1: 0}    // ERROR "index must be non\-negative integer constant|must not be negative"
+	_ = [10]int{-1: 0}  // ERROR "index must be non\-negative integer constant|must not be negative"
+	_ = [...]int{-1: 0} // ERROR "index must be non\-negative integer constant|must not be negative"
 
 	_ = []int{100: 0}
 	_ = [10]int{100: 0} // ERROR "array index 100 out of bounds"
 	_ = [...]int{100: 0}
 
-	_ = []int{t}    // ERROR "cannot use .* as type int in slice literal"
-	_ = [10]int{t}  // ERROR "cannot use .* as type int in array literal"
-	_ = [...]int{t} // ERROR "cannot use .* as type int in array literal"
+	_ = []int{t}    // ERROR "cannot use .* as (type )?int( in slice literal)?"
+	_ = [10]int{t}  // ERROR "cannot use .* as (type )?int( in array literal)?"
+	_ = [...]int{t} // ERROR "cannot use .* as (type )?int( in array literal)?"
 }
diff --git a/test/fixedbugs/issue13471.go b/test/fixedbugs/issue13471.go
index 0bfed42616..8382c670ed 100644
--- a/test/fixedbugs/issue13471.go
+++ b/test/fixedbugs/issue13471.go
@@ -9,17 +9,17 @@
 package main
 
 func main() {
-	const _ int64 = 1e646456992 // ERROR "integer too large"
-	const _ int32 = 1e64645699  // ERROR "integer too large"
-	const _ int16 = 1e6464569   // ERROR "integer too large"
-	const _ int8 = 1e646456     // ERROR "integer too large"
-	const _ int = 1e64645       // ERROR "integer too large"
+	const _ int64 = 1e646456992 // ERROR "integer too large|truncated to .*"
+	const _ int32 = 1e64645699  // ERROR "integer too large|truncated to .*"
+	const _ int16 = 1e6464569   // ERROR "integer too large|truncated to .*"
+	const _ int8 = 1e646456     // ERROR "integer too large|truncated to .*"
+	const _ int = 1e64645       // ERROR "integer too large|truncated to .*"
 
-	const _ uint64 = 1e646456992 // ERROR "integer too large"
-	const _ uint32 = 1e64645699  // ERROR "integer too large"
-	const _ uint16 = 1e6464569   // ERROR "integer too large"
-	const _ uint8 = 1e646456     // ERROR "integer too large"
-	const _ uint = 1e64645       // ERROR "integer too large"
+	const _ uint64 = 1e646456992 // ERROR "integer too large|truncated to .*"
+	const _ uint32 = 1e64645699  // ERROR "integer too large|truncated to .*"
+	const _ uint16 = 1e6464569   // ERROR "integer too large|truncated to .*"
+	const _ uint8 = 1e646456     // ERROR "integer too large|truncated to .*"
+	const _ uint = 1e64645       // ERROR "integer too large|truncated to .*"
 
-	const _ rune = 1e64645 // ERROR "integer too large"
+	const _ rune = 1e64645 // ERROR "integer too large|truncated to .*"
 }
diff --git a/test/fixedbugs/issue13480.go b/test/fixedbugs/issue13480.go
index cd2f05de5f..8c2fc44922 100644
--- a/test/fixedbugs/issue13480.go
+++ b/test/fixedbugs/issue13480.go
@@ -18,21 +18,21 @@ func bug() {
 	var m M
 	var f F
 
-	_ = s == S(nil) // ERROR "compare.*to nil"
-	_ = S(nil) == s // ERROR "compare.*to nil"
+	_ = s == S(nil) // ERROR "compare.*to nil|operator \=\= not defined for ."
+	_ = S(nil) == s // ERROR "compare.*to nil|operator \=\= not defined for ."
 	switch s {
-	case S(nil): // ERROR "compare.*to nil"
+	case S(nil): // ERROR "compare.*to nil|operator \=\= not defined for ."
 	}
 
-	_ = m == M(nil) // ERROR "compare.*to nil"
-	_ = M(nil) == m // ERROR "compare.*to nil"
+	_ = m == M(nil) // ERROR "compare.*to nil|operator \=\= not defined for ."
+	_ = M(nil) == m // ERROR "compare.*to nil|operator \=\= not defined for ."
 	switch m {
-	case M(nil): // ERROR "compare.*to nil"
+	case M(nil): // ERROR "compare.*to nil|operator \=\= not defined for ."
 	}
 
-	_ = f == F(nil) // ERROR "compare.*to nil"
-	_ = F(nil) == f // ERROR "compare.*to nil"
+	_ = f == F(nil) // ERROR "compare.*to nil|operator \=\= not defined for ."
+	_ = F(nil) == f // ERROR "compare.*to nil|operator \=\= not defined for ."
 	switch f {
-	case F(nil): // ERROR "compare.*to nil"
+	case F(nil): // ERROR "compare.*to nil|operator \=\= not defined for ."
 	}
 }
diff --git a/test/fixedbugs/issue13485.go b/test/fixedbugs/issue13485.go
index a9beea1f7d..d928c1e1fa 100644
--- a/test/fixedbugs/issue13485.go
+++ b/test/fixedbugs/issue13485.go
@@ -9,10 +9,10 @@ package p
 var (
 	_ [10]int
 	_ [10.0]int
-	_ [float64(10)]int                // ERROR "invalid array bound"
+	_ [float64(10)]int                // ERROR "invalid array bound|must be integer"
 	_ [10 + 0i]int
 	_ [complex(10, 0)]int
-	_ [complex128(complex(10, 0))]int // ERROR "invalid array bound"
+	_ [complex128(complex(10, 0))]int // ERROR "invalid array bound|must be integer"
 	_ ['a']int
 	_ [rune(65)]int
 )
diff --git a/test/fixedbugs/issue13539.go b/test/fixedbugs/issue13539.go
index 72c3ab0ae0..181fbef9bf 100644
--- a/test/fixedbugs/issue13539.go
+++ b/test/fixedbugs/issue13539.go
@@ -10,7 +10,7 @@
 
 package main
 
-import "math" // ERROR "imported and not used"
+import "math" // ERROR "imported and not used|imported but not used"
 
 func main() {
 math:
diff --git a/test/fixedbugs/issue13559.go b/test/fixedbugs/issue13559.go
index 16de2a2e31..07cf2ca211 100644
--- a/test/fixedbugs/issue13559.go
+++ b/test/fixedbugs/issue13559.go
@@ -10,80 +10,80 @@
 package p
 
 // failure case in issue
-const _ int64 = 1e-10000 // ERROR "1e\-10000 truncated"
+const _ int64 = 1e-10000 // ERROR "1e\-10000 truncated|.* truncated to int64"
 
 const (
-	_ int64 = 1e10000000 // ERROR "integer too large"
-	_ int64 = 1e1000000  // ERROR "integer too large"
-	_ int64 = 1e100000   // ERROR "integer too large"
-	_ int64 = 1e10000    // ERROR "integer too large"
-	_ int64 = 1e1000     // ERROR "integer too large"
-	_ int64 = 1e100      // ERROR "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 overflows"
+	_ int64 = 1e10000000 // ERROR "integer too large|truncated to int64"
+	_ int64 = 1e1000000  // ERROR "integer too large|truncated to int64"
+	_ int64 = 1e100000   // ERROR "integer too large|truncated to int64"
+	_ int64 = 1e10000    // ERROR "integer too large|truncated to int64"
+	_ int64 = 1e1000     // ERROR "integer too large|truncated to int64"
+	_ int64 = 1e100      // ERROR "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 overflows|truncated to int64"
 	_ int64 = 1e10
 	_ int64 = 1e1
 	_ int64 = 1e0
-	_ int64 = 1e-1       // ERROR "0\.1 truncated"
-	_ int64 = 1e-10      // ERROR "1e\-10 truncated"
-	_ int64 = 1e-100     // ERROR "1e\-100 truncated"
-	_ int64 = 1e-1000    // ERROR "1e\-1000 truncated"
-	_ int64 = 1e-10000   // ERROR "1e\-10000 truncated"
-	_ int64 = 1e-100000  // ERROR "1e\-100000 truncated"
-	_ int64 = 1e-1000000 // ERROR "1e\-1000000 truncated"
+	_ int64 = 1e-1       // ERROR "0\.1 truncated|.* truncated to int64"
+	_ int64 = 1e-10      // ERROR "1e\-10 truncated|.* truncated to int64"
+	_ int64 = 1e-100     // ERROR "1e\-100 truncated|.* truncated to int64"
+	_ int64 = 1e-1000    // ERROR "1e\-1000 truncated|.* truncated to int64"
+	_ int64 = 1e-10000   // ERROR "1e\-10000 truncated|.* truncated to int64"
+	_ int64 = 1e-100000  // ERROR "1e\-100000 truncated|.* truncated to int64"
+	_ int64 = 1e-1000000 // ERROR "1e\-1000000 truncated|.* truncated to int64"
 )
 
 const (
-	_ int64 = -1e10000000 // ERROR "integer too large"
-	_ int64 = -1e1000000  // ERROR "integer too large"
-	_ int64 = -1e100000   // ERROR "integer too large"
-	_ int64 = -1e10000    // ERROR "integer too large"
-	_ int64 = -1e1000     // ERROR "integer too large"
-	_ int64 = -1e100      // ERROR "\-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 overflows"
+	_ int64 = -1e10000000 // ERROR "integer too large|truncated to int64"
+	_ int64 = -1e1000000  // ERROR "integer too large|truncated to int64"
+	_ int64 = -1e100000   // ERROR "integer too large|truncated to int64"
+	_ int64 = -1e10000    // ERROR "integer too large|truncated to int64"
+	_ int64 = -1e1000     // ERROR "integer too large|truncated to int64"
+	_ int64 = -1e100      // ERROR "\-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 overflows|truncated to int64"
 	_ int64 = -1e10
 	_ int64 = -1e1
 	_ int64 = -1e0
-	_ int64 = -1e-1       // ERROR "\-0\.1 truncated"
-	_ int64 = -1e-10      // ERROR "\-1e\-10 truncated"
-	_ int64 = -1e-100     // ERROR "\-1e\-100 truncated"
-	_ int64 = -1e-1000    // ERROR "\-1e\-1000 truncated"
-	_ int64 = -1e-10000   // ERROR "\-1e\-10000 truncated"
-	_ int64 = -1e-100000  // ERROR "\-1e\-100000 truncated"
-	_ int64 = -1e-1000000 // ERROR "\-1e\-1000000 truncated"
+	_ int64 = -1e-1       // ERROR "\-0\.1 truncated|.* truncated to int64"
+	_ int64 = -1e-10      // ERROR "\-1e\-10 truncated|.* truncated to int64"
+	_ int64 = -1e-100     // ERROR "\-1e\-100 truncated|.* truncated to int64"
+	_ int64 = -1e-1000    // ERROR "\-1e\-1000 truncated|.* truncated to int64"
+	_ int64 = -1e-10000   // ERROR "\-1e\-10000 truncated|.* truncated to int64"
+	_ int64 = -1e-100000  // ERROR "\-1e\-100000 truncated|.* truncated to int64"
+	_ int64 = -1e-1000000 // ERROR "\-1e\-1000000 truncated|.* truncated to int64"
 )
 
 const (
-	_ int64 = 1.23456789e10000000 // ERROR "integer too large"
-	_ int64 = 1.23456789e1000000  // ERROR "integer too large"
-	_ int64 = 1.23456789e100000   // ERROR "integer too large"
-	_ int64 = 1.23456789e10000    // ERROR "integer too large"
-	_ int64 = 1.23456789e1000     // ERROR "integer too large"
-	_ int64 = 1.23456789e100      // ERROR "12345678900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 overflows"
+	_ int64 = 1.23456789e10000000 // ERROR "integer too large|truncated to int64"
+	_ int64 = 1.23456789e1000000  // ERROR "integer too large|truncated to int64"
+	_ int64 = 1.23456789e100000   // ERROR "integer too large|truncated to int64"
+	_ int64 = 1.23456789e10000    // ERROR "integer too large|truncated to int64"
+	_ int64 = 1.23456789e1000     // ERROR "integer too large|truncated to int64"
+	_ int64 = 1.23456789e100      // ERROR "12345678900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 overflows|truncated to int64"
 	_ int64 = 1.23456789e10
-	_ int64 = 1.23456789e1        // ERROR "12\.3457 truncated"
-	_ int64 = 1.23456789e0        // ERROR "1\.23457 truncated"
-	_ int64 = 1.23456789e-1       // ERROR "0\.123457 truncated"
-	_ int64 = 1.23456789e-10      // ERROR "1\.23457e\-10 truncated"
-	_ int64 = 1.23456789e-100     // ERROR "1\.23457e\-100 truncated"
-	_ int64 = 1.23456789e-1000    // ERROR "1\.23457e\-1000 truncated"
-	_ int64 = 1.23456789e-10000   // ERROR "1\.23457e\-10000 truncated"
-	_ int64 = 1.23456789e-100000  // ERROR "1\.23457e\-100000 truncated"
-	_ int64 = 1.23456789e-1000000 // ERROR "1\.23457e\-1000000 truncated"
+	_ int64 = 1.23456789e1        // ERROR "12\.3457 truncated|.* truncated to int64"
+	_ int64 = 1.23456789e0        // ERROR "1\.23457 truncated|.* truncated to int64"
+	_ int64 = 1.23456789e-1       // ERROR "0\.123457 truncated|.* truncated to int64"
+	_ int64 = 1.23456789e-10      // ERROR "1\.23457e\-10 truncated|.* truncated to int64"
+	_ int64 = 1.23456789e-100     // ERROR "1\.23457e\-100 truncated|.* truncated to int64"
+	_ int64 = 1.23456789e-1000    // ERROR "1\.23457e\-1000 truncated|.* truncated to int64"
+	_ int64 = 1.23456789e-10000   // ERROR "1\.23457e\-10000 truncated|.* truncated to int64"
+	_ int64 = 1.23456789e-100000  // ERROR "1\.23457e\-100000 truncated|.* truncated to int64"
+	_ int64 = 1.23456789e-1000000 // ERROR "1\.23457e\-1000000 truncated|.* truncated to int64"
 )
 
 const (
-	_ int64 = -1.23456789e10000000 // ERROR "integer too large"
-	_ int64 = -1.23456789e1000000  // ERROR "integer too large"
-	_ int64 = -1.23456789e100000   // ERROR "integer too large"
-	_ int64 = -1.23456789e10000    // ERROR "integer too large"
-	_ int64 = -1.23456789e1000     // ERROR "integer too large"
-	_ int64 = -1.23456789e100      // ERROR "\-12345678900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 overflows"
+	_ int64 = -1.23456789e10000000 // ERROR "integer too large|truncated to int64"
+	_ int64 = -1.23456789e1000000  // ERROR "integer too large|truncated to int64"
+	_ int64 = -1.23456789e100000   // ERROR "integer too large|truncated to int64"
+	_ int64 = -1.23456789e10000    // ERROR "integer too large|truncated to int64"
+	_ int64 = -1.23456789e1000     // ERROR "integer too large|truncated to int64"
+	_ int64 = -1.23456789e100      // ERROR "\-12345678900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 overflows|truncated to int64"
 	_ int64 = -1.23456789e10
-	_ int64 = -1.23456789e1        // ERROR "\-12\.3457 truncated"
-	_ int64 = -1.23456789e0        // ERROR "\-1\.23457 truncated"
-	_ int64 = -1.23456789e-1       // ERROR "\-0\.123457 truncated"
-	_ int64 = -1.23456789e-10      // ERROR "\-1\.23457e\-10 truncated"
-	_ int64 = -1.23456789e-100     // ERROR "\-1\.23457e\-100 truncated"
-	_ int64 = -1.23456789e-1000    // ERROR "\-1\.23457e\-1000 truncated"
-	_ int64 = -1.23456789e-10000   // ERROR "\-1\.23457e\-10000 truncated"
-	_ int64 = -1.23456789e-100000  // ERROR "\-1\.23457e\-100000 truncated"
-	_ int64 = -1.23456789e-1000000 // ERROR "\-1\.23457e\-1000000 truncated"
+	_ int64 = -1.23456789e1        // ERROR "\-12\.3457 truncated|.* truncated to int64"
+	_ int64 = -1.23456789e0        // ERROR "\-1\.23457 truncated|.* truncated to int64"
+	_ int64 = -1.23456789e-1       // ERROR "\-0\.123457 truncated|.* truncated to int64"
+	_ int64 = -1.23456789e-10      // ERROR "\-1\.23457e\-10 truncated|.* truncated to int64"
+	_ int64 = -1.23456789e-100     // ERROR "\-1\.23457e\-100 truncated|.* truncated to int64"
+	_ int64 = -1.23456789e-1000    // ERROR "\-1\.23457e\-1000 truncated|.* truncated to int64"
+	_ int64 = -1.23456789e-10000   // ERROR "\-1\.23457e\-10000 truncated|.* truncated to int64"
+	_ int64 = -1.23456789e-100000  // ERROR "\-1\.23457e\-100000 truncated|.* truncated to int64"
+	_ int64 = -1.23456789e-1000000 // ERROR "\-1\.23457e\-1000000 truncated|.* truncated to int64"
 )
diff --git a/test/fixedbugs/issue14136.go b/test/fixedbugs/issue14136.go
index f9efd05f96..ff54a246f1 100644
--- a/test/fixedbugs/issue14136.go
+++ b/test/fixedbugs/issue14136.go
@@ -14,6 +14,8 @@ package main
 type T struct{}
 
 func main() {
-	t := T{X: 1, X: 1, X: 1, X: 1, X: 1, X: 1, X: 1, X: 1, X: 1, X: 1} // ERROR "unknown field 'X' in struct literal of type T"
-	var s string = 1 // ERROR "cannot use 1"
+	t := T{X: 1, X: 1, X: 1, X: 1, X: 1, X: 1, X: 1, X: 1, X: 1, X: 1} // ERROR "unknown field 'X' in struct literal of type T|unknown field X"
+	_ = t
+	var s string = 1 // ERROR "cannot use 1|cannot convert"
+	_ = s
 }
diff --git a/test/fixedbugs/issue14321.go b/test/fixedbugs/issue14321.go
index 058008c386..925b0b7a40 100644
--- a/test/fixedbugs/issue14321.go
+++ b/test/fixedbugs/issue14321.go
@@ -30,4 +30,4 @@ type C struct {
 var _ = C.F // ERROR "ambiguous selector"
 var _ = C.G // ERROR "ambiguous selector"
 var _ = C.H // ERROR "ambiguous selector"
-var _ = C.I // ERROR "no method I"
+var _ = C.I // ERROR "no method I|C.I undefined"
diff --git a/test/fixedbugs/issue14729.go b/test/fixedbugs/issue14729.go
index 88e01f9e16..52201f34e2 100644
--- a/test/fixedbugs/issue14729.go
+++ b/test/fixedbugs/issue14729.go
@@ -10,5 +10,5 @@ package main
 
 import "unsafe"
 
-type s struct { unsafe.Pointer } // ERROR "embedded type cannot be a pointer"
+type s struct { unsafe.Pointer } // ERROR "embedded type cannot be a pointer|embedded field type cannot be unsafe.Pointer"
 type s1 struct { p unsafe.Pointer }
diff --git a/test/fixedbugs/issue15055.go b/test/fixedbugs/issue15055.go
index e58047e411..b6c3d96da6 100644
--- a/test/fixedbugs/issue15055.go
+++ b/test/fixedbugs/issue15055.go
@@ -8,10 +8,10 @@ package main
 
 func main() {
 	type name string
-	_ = []byte("abc", "def", 12)    // ERROR "too many arguments to conversion to \[\]byte: \(\[\]byte\)\(.abc., .def., 12\)"
-	_ = string("a", "b", nil)       // ERROR "too many arguments to conversion to string: string\(.a., .b., nil\)"
-	_ = []byte()                    // ERROR "missing argument to conversion to \[\]byte: \(\[\]byte\)\(\)"
-	_ = string()                    // ERROR "missing argument to conversion to string: string\(\)"
-	_ = name("a", 1, 3.3)           // ERROR "too many arguments to conversion to name: name\(.a., 1, 3.3\)"
-	_ = map[string]string(nil, nil) // ERROR "too many arguments to conversion to map\[string\]string: \(map\[string\]string\)\(nil, nil\)"
+	_ = []byte("abc", "def", 12)    // ERROR "too many arguments (to conversion to \[\]byte: \(\[\]byte\)\(.abc., .def., 12\))?"
+	_ = string("a", "b", nil)       // ERROR "too many arguments (to conversion to string: string\(.a., .b., nil\))?"
+	_ = []byte()                    // ERROR "missing argument (to conversion to \[\]byte: \(\[\]byte\)\(\))?"
+	_ = string()                    // ERROR "missing argument (to conversion to string: string\(\))?"
+	_ = name("a", 1, 3.3)           // ERROR "too many arguments (to conversion to name: name\(.a., 1, 3.3\))?"
+	_ = map[string]string(nil, nil) // ERROR "too many arguments (to conversion to map\[string\]string: \(map\[string\]string\)\(nil, nil\))?"
 }
diff --git a/test/fixedbugs/issue15898.go b/test/fixedbugs/issue15898.go
index 7b66ea23dc..7739bafccc 100644
--- a/test/fixedbugs/issue15898.go
+++ b/test/fixedbugs/issue15898.go
@@ -8,11 +8,11 @@ package p
 
 func f(e interface{}) {
 	switch e.(type) {
-	case nil, nil: // ERROR "multiple nil cases in type switch"
+	case nil, nil: // ERROR "multiple nil cases in type switch|duplicate case nil in type switch"
 	}
 
 	switch e.(type) {
 	case nil:
-	case nil: // ERROR "multiple nil cases in type switch"
+	case nil: // ERROR "multiple nil cases in type switch|duplicate case nil in type switch"
 	}
 }
diff --git a/test/fixedbugs/issue16439.go b/test/fixedbugs/issue16439.go
index f9382bafcd..0a842ca1fb 100644
--- a/test/fixedbugs/issue16439.go
+++ b/test/fixedbugs/issue16439.go
@@ -7,12 +7,12 @@
 package p
 
 var a []int = []int{1: 1}
-var b []int = []int{-1: 1} // ERROR "must be non-negative integer constant"
+var b []int = []int{-1: 1} // ERROR "must be non-negative integer constant|must not be negative"
 
 var c []int = []int{2.0: 2}
-var d []int = []int{-2.0: 2} // ERROR "must be non-negative integer constant"
+var d []int = []int{-2.0: 2} // ERROR "must be non-negative integer constant|must not be negative"
 
 var e []int = []int{3 + 0i: 3}
-var f []int = []int{3i: 3} // ERROR "truncated to integer"
+var f []int = []int{3i: 3} // ERROR "truncated to integer|truncated to int"
 
-var g []int = []int{"a": 4} // ERROR "must be non-negative integer constant"
+var g []int = []int{"a": 4} // ERROR "must be non-negative integer constant|cannot convert"
diff --git a/test/fixedbugs/issue16949.go b/test/fixedbugs/issue16949.go
index 9ee3387e96..1007d701de 100644
--- a/test/fixedbugs/issue16949.go
+++ b/test/fixedbugs/issue16949.go
@@ -12,19 +12,19 @@ var sink []byte
 
 func main() {
 	sink = make([]byte, 1.0)
-	sink = make([]byte, float32(1.0)) // ERROR "non-integer.*len"
-	sink = make([]byte, float64(1.0)) // ERROR "non-integer.*len"
+	sink = make([]byte, float32(1.0)) // ERROR "non-integer.*len|must be integer"
+	sink = make([]byte, float64(1.0)) // ERROR "non-integer.*len|must be integer"
 
 	sink = make([]byte, 0, 1.0)
-	sink = make([]byte, 0, float32(1.0)) // ERROR "non-integer.*cap"
-	sink = make([]byte, 0, float64(1.0)) // ERROR "non-integer.*cap"
+	sink = make([]byte, 0, float32(1.0)) // ERROR "non-integer.*cap|must be integer"
+	sink = make([]byte, 0, float64(1.0)) // ERROR "non-integer.*cap|must be integer"
 
 	sink = make([]byte, 1+0i)
-	sink = make([]byte, complex64(1+0i))  // ERROR "non-integer.*len"
-	sink = make([]byte, complex128(1+0i)) // ERROR "non-integer.*len"
+	sink = make([]byte, complex64(1+0i))  // ERROR "non-integer.*len|must be integer"
+	sink = make([]byte, complex128(1+0i)) // ERROR "non-integer.*len|must be integer"
 
 	sink = make([]byte, 0, 1+0i)
-	sink = make([]byte, 0, complex64(1+0i))  // ERROR "non-integer.*cap"
-	sink = make([]byte, 0, complex128(1+0i)) // ERROR "non-integer.*cap"
+	sink = make([]byte, 0, complex64(1+0i))  // ERROR "non-integer.*cap|must be integer"
+	sink = make([]byte, 0, complex128(1+0i)) // ERROR "non-integer.*cap|must be integer"
 
 }
diff --git a/test/fixedbugs/issue6402.go b/test/fixedbugs/issue6402.go
index da5980c9ab..027291a0ea 100644
--- a/test/fixedbugs/issue6402.go
+++ b/test/fixedbugs/issue6402.go
@@ -9,5 +9,5 @@
 package p
 
 func f() uintptr {
-	return nil // ERROR "cannot use nil as type uintptr in return argument"
+	return nil // ERROR "cannot use nil as type uintptr in return argument|cannot convert nil"
 }
diff --git a/test/fixedbugs/issue6572.go b/test/fixedbugs/issue6572.go
index e4465e9d1e..9f4d2de0e3 100644
--- a/test/fixedbugs/issue6572.go
+++ b/test/fixedbugs/issue6572.go
@@ -17,5 +17,6 @@ func bar() (T, string, T) { // ERROR "undefined"
 func main() {
 	var x, y, z int
 	x, y = foo()
-	x, y, z = bar() // ERROR "cannot (use type|assign) string"
+	x, y, z = bar() // ERROR "cannot (use type|assign) string|incompatible type"
+	_, _, _ = x, y, z
 }
diff --git a/test/initloop.go b/test/initloop.go
index ca652f86f4..b1a8470b3a 100644
--- a/test/initloop.go
+++ b/test/initloop.go
@@ -11,7 +11,7 @@ package main
 
 var (
 	x int = a
-	a int = b // ERROR "a refers to\n.*b refers to\n.*c refers to\n.*a|initialization cycle"
+	a int = b // ERROR "a refers to\n.*b refers to\n.*c refers to\n.*a|initialization loop"
 	b int = c
 	c int = a
 )
diff --git a/test/run.go b/test/run.go
index 3c8a20712b..8e1b06974c 100644
--- a/test/run.go
+++ b/test/run.go
@@ -1981,30 +1981,14 @@ var excluded = map[string]bool{
 	"fixedbugs/bug462.go":      true,
 	"fixedbugs/bug463.go":      true,
 	"fixedbugs/bug487.go":      true,
-	"fixedbugs/issue11326.go":  true,
 	"fixedbugs/issue11362.go":  true,
 	"fixedbugs/issue11590.go":  true,
 	"fixedbugs/issue11610.go":  true,
-	"fixedbugs/issue11614.go":  true,
-	"fixedbugs/issue11674.go":  true,
-	"fixedbugs/issue11737.go":  true,
-	"fixedbugs/issue13365.go":  true,
-	"fixedbugs/issue13415.go":  true,
-	"fixedbugs/issue13471.go":  true,
-	"fixedbugs/issue13480.go":  true,
-	"fixedbugs/issue13485.go":  true,
-	"fixedbugs/issue13539.go":  true,
-	"fixedbugs/issue13559.go":  true,
-	"fixedbugs/issue14136.go":  true,
-	"fixedbugs/issue14321.go":  true,
-	"fixedbugs/issue14520.go":  true,
-	"fixedbugs/issue14540.go":  true,
-	"fixedbugs/issue14729.go":  true,
-	"fixedbugs/issue15055.go":  true,
-	"fixedbugs/issue15898.go":  true,
-	"fixedbugs/issue16428.go":  true,
-	"fixedbugs/issue16439.go":  true,
-	"fixedbugs/issue16949.go":  true,
+	"fixedbugs/issue11614.go":  true, // types2 reports an extra error
+	"fixedbugs/issue13415.go":  true, // declared but not used conflict
+	"fixedbugs/issue14520.go":  true, // missing import path error by types2
+	"fixedbugs/issue14540.go":  true, // types2 is missing a fallthrough error
+	"fixedbugs/issue16428.go":  true, // types2 reports two instead of one error
 	"fixedbugs/issue17038.go":  true,
 	"fixedbugs/issue17588.go":  true,
 	"fixedbugs/issue17631.go":  true,
@@ -2084,11 +2068,8 @@ var excluded = map[string]bool{
 	"fixedbugs/issue4517d.go":  true,
 	"fixedbugs/issue4847.go":   true,
 	"fixedbugs/issue4909a.go":  true,
-	"fixedbugs/issue5609.go":   true,
-	"fixedbugs/issue6402.go":   true,
-	"fixedbugs/issue6403.go":   true,
-	"fixedbugs/issue6500.go":   true,
-	"fixedbugs/issue6572.go":   true,
+	"fixedbugs/issue5609.go":   true, // types2 needs a better error message
+	"fixedbugs/issue6500.go":   true, // compiler -G is not reporting an error (but types2 does)
 	"fixedbugs/issue6889.go":   true, // types2 can handle this without constant overflow
 	"fixedbugs/issue7525.go":   true, // init cycle error on different line - ok otherwise
 	"fixedbugs/issue7525b.go":  true, // init cycle error on different line - ok otherwise
diff --git a/test/runtime.go b/test/runtime.go
index a833129dd6..58a5eee709 100644
--- a/test/runtime.go
+++ b/test/runtime.go
@@ -17,5 +17,5 @@ package main
 import "runtime"
 
 func main() {
-	runtime.printbool(true)	// ERROR "unexported|not declared"
+	runtime.printbool(true)	// ERROR "unexported|undefined"
 }
-- 
GitLab


From edf80c4209a03bc656edfa5222b8fbd7fd072401 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 9 Dec 2020 12:28:15 -0800
Subject: [PATCH 0203/2400] [dev.typeparams] cmd/compile/internal/types2:
 adjusted more error messages for compiler

Triaged and adjusted more test/fixedbugs/* tests.

Change-Id: I80b9ead2445bb8d126b7d79db4bea9ddcb225a84
Reviewed-on: https://go-review.googlesource.com/c/go/+/276812
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/types2/decl.go     |   6 +-
 src/cmd/compile/internal/types2/expr.go     |  18 +-
 src/cmd/compile/internal/types2/resolver.go |  18 +-
 test/fixedbugs/issue13480.go                |  18 +-
 test/fixedbugs/issue17588.go                |   2 +-
 test/fixedbugs/issue18392.go                |   2 +-
 test/fixedbugs/issue19323.go                |   4 +-
 test/fixedbugs/issue19482.go                |   8 +-
 test/fixedbugs/issue19699b.go               |   2 +-
 test/fixedbugs/issue19880.go                |   2 +-
 test/fixedbugs/issue19947.go                |   8 +-
 test/fixedbugs/issue20185.go                |   4 +-
 test/fixedbugs/issue20227.go                |  10 +-
 test/fixedbugs/issue20415.go                |   6 +-
 test/fixedbugs/issue20749.go                |   4 +-
 test/fixedbugs/issue22389.go                |   2 +-
 test/fixedbugs/issue22794.go                |   5 +-
 test/fixedbugs/issue22822.go                |   3 +-
 test/fixedbugs/issue22921.go                |   6 +-
 test/fixedbugs/issue23094.go                |   2 +-
 test/fixedbugs/issue23609.go                |   6 +-
 test/fixedbugs/issue23823.go                |   2 +-
 test/fixedbugs/issue24470.go                |   1 +
 test/fixedbugs/issue25727.go                |   6 +-
 test/fixedbugs/issue26416.go                |   6 +-
 test/fixedbugs/issue26616.go                |  10 +-
 test/fixedbugs/issue27595.go                |   6 +-
 test/fixedbugs/issue28079c.go               |   2 +-
 test/fixedbugs/issue28450.go                |  12 +-
 test/fixedbugs/issue30085.go                |   5 +-
 test/fixedbugs/issue30087.go                |   9 +-
 test/fixedbugs/issue35291.go                |   2 +-
 test/fixedbugs/issue38117.go                |   2 +-
 test/fixedbugs/issue38745.go                |   2 +-
 test/fixedbugs/issue3925.go                 |   2 +-
 test/fixedbugs/issue4085a.go                |   8 +-
 test/fixedbugs/issue41247.go                |   2 +-
 test/fixedbugs/issue41440.go                |   2 +-
 test/fixedbugs/issue41500.go                |   8 +-
 test/fixedbugs/issue4215.go                 |  22 +--
 test/fixedbugs/issue4251.go                 |   6 +-
 test/fixedbugs/issue4429.go                 |   2 +-
 test/fixedbugs/issue4458.go                 |   2 +-
 test/fixedbugs/issue4470.go                 |   1 +
 test/fixedbugs/issue4517d.go                |   2 +-
 test/fixedbugs/issue4909a.go                |   4 +-
 test/run.go                                 | 206 ++++++++------------
 47 files changed, 226 insertions(+), 242 deletions(-)

diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index bc3e665b71..de6f4df73e 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -364,7 +364,11 @@ func (check *Checker) cycleError(cycle []Object) {
 	//           cycle? That would be more consistent with other error messages.
 	i := firstInSrc(cycle)
 	obj := cycle[i]
-	check.errorf(obj.Pos(), "illegal cycle in declaration of %s", obj.Name())
+	if check.conf.CompilerErrorMessages {
+		check.errorf(obj.Pos(), "invalid recursive type %s", obj.Name())
+	} else {
+		check.errorf(obj.Pos(), "illegal cycle in declaration of %s", obj.Name())
+	}
 	for range cycle {
 		check.errorf(obj.Pos(), "\t%s refers to", obj.Name()) // secondary error, \t indented
 		i++
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index bede0c639d..2fabd9694e 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -69,7 +69,11 @@ var unaryOpPredicates = opPredicates{
 func (check *Checker) op(m opPredicates, x *operand, op syntax.Operator) bool {
 	if pred := m[op]; pred != nil {
 		if !pred(x.typ) {
-			check.invalidOpf(x, "operator %s not defined for %s", op, x)
+			if check.conf.CompilerErrorMessages {
+				check.invalidOpf(x, "operator %s not defined on %s", op, x)
+			} else {
+				check.invalidOpf(x, "operator %s not defined for %s", op, x)
+			}
 			return false
 		}
 	} else {
@@ -729,7 +733,11 @@ func (check *Checker) comparison(x, y *operand, op syntax.Operator) {
 			if x.isNil() {
 				typ = y.typ
 			}
-			err = check.sprintf("operator %s not defined for %s", op, typ)
+			if check.conf.CompilerErrorMessages {
+				err = check.sprintf("operator %s not defined on %s", op, typ)
+			} else {
+				err = check.sprintf("operator %s not defined for %s", op, typ)
+			}
 		}
 	} else {
 		err = check.sprintf("mismatched types %s and %s", x.typ, y.typ)
@@ -1268,7 +1276,11 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 					}
 					i := fieldIndex(utyp.fields, check.pkg, key.Value)
 					if i < 0 {
-						check.errorf(kv, "unknown field %s in struct literal", key.Value)
+						if check.conf.CompilerErrorMessages {
+							check.errorf(kv, "unknown field '%s' in struct literal of type %s", key.Value, base)
+						} else {
+							check.errorf(kv, "unknown field %s in struct literal", key.Value)
+						}
 						continue
 					}
 					fld := fields[i]
diff --git a/src/cmd/compile/internal/types2/resolver.go b/src/cmd/compile/internal/types2/resolver.go
index cf9893ca87..5cd0a3e198 100644
--- a/src/cmd/compile/internal/types2/resolver.go
+++ b/src/cmd/compile/internal/types2/resolver.go
@@ -677,9 +677,17 @@ func (check *Checker) unusedImports() {
 					path := obj.imported.path
 					base := pkgName(path)
 					if obj.name == base {
-						check.softErrorf(obj.pos, "%q imported but not used", path)
+						if check.conf.CompilerErrorMessages {
+							check.softErrorf(obj.pos, "%q imported and not used", path)
+						} else {
+							check.softErrorf(obj.pos, "%q imported but not used", path)
+						}
 					} else {
-						check.softErrorf(obj.pos, "%q imported but not used as %s", path, obj.name)
+						if check.conf.CompilerErrorMessages {
+							check.softErrorf(obj.pos, "%q imported and not used as %s", path, obj.name)
+						} else {
+							check.softErrorf(obj.pos, "%q imported but not used as %s", path, obj.name)
+						}
 					}
 				}
 			}
@@ -689,7 +697,11 @@ func (check *Checker) unusedImports() {
 	// check use of dot-imported packages
 	for _, unusedDotImports := range check.unusedDotImports {
 		for pkg, pos := range unusedDotImports {
-			check.softErrorf(pos, "%q imported but not used", pkg.path)
+			if check.conf.CompilerErrorMessages {
+				check.softErrorf(pos, "%q imported and not used", pkg.path)
+			} else {
+				check.softErrorf(pos, "%q imported but not used", pkg.path)
+			}
 		}
 	}
 }
diff --git a/test/fixedbugs/issue13480.go b/test/fixedbugs/issue13480.go
index 8c2fc44922..7e859c56c5 100644
--- a/test/fixedbugs/issue13480.go
+++ b/test/fixedbugs/issue13480.go
@@ -18,21 +18,21 @@ func bug() {
 	var m M
 	var f F
 
-	_ = s == S(nil) // ERROR "compare.*to nil|operator \=\= not defined for ."
-	_ = S(nil) == s // ERROR "compare.*to nil|operator \=\= not defined for ."
+	_ = s == S(nil) // ERROR "compare.*to nil|operator \=\= not defined for .|cannot compare"
+	_ = S(nil) == s // ERROR "compare.*to nil|operator \=\= not defined for .|cannot compare"
 	switch s {
-	case S(nil): // ERROR "compare.*to nil|operator \=\= not defined for ."
+	case S(nil): // ERROR "compare.*to nil|operator \=\= not defined for .|cannot compare"
 	}
 
-	_ = m == M(nil) // ERROR "compare.*to nil|operator \=\= not defined for ."
-	_ = M(nil) == m // ERROR "compare.*to nil|operator \=\= not defined for ."
+	_ = m == M(nil) // ERROR "compare.*to nil|operator \=\= not defined for .|cannot compare"
+	_ = M(nil) == m // ERROR "compare.*to nil|operator \=\= not defined for .|cannot compare"
 	switch m {
-	case M(nil): // ERROR "compare.*to nil|operator \=\= not defined for ."
+	case M(nil): // ERROR "compare.*to nil|operator \=\= not defined for .|cannot compare"
 	}
 
-	_ = f == F(nil) // ERROR "compare.*to nil|operator \=\= not defined for ."
-	_ = F(nil) == f // ERROR "compare.*to nil|operator \=\= not defined for ."
+	_ = f == F(nil) // ERROR "compare.*to nil|operator \=\= not defined for .|cannot compare"
+	_ = F(nil) == f // ERROR "compare.*to nil|operator \=\= not defined for .|cannot compare"
 	switch f {
-	case F(nil): // ERROR "compare.*to nil|operator \=\= not defined for ."
+	case F(nil): // ERROR "compare.*to nil|operator \=\= not defined for .|cannot compare"
 	}
 }
diff --git a/test/fixedbugs/issue17588.go b/test/fixedbugs/issue17588.go
index 1be57c6292..77efaf7ef1 100644
--- a/test/fixedbugs/issue17588.go
+++ b/test/fixedbugs/issue17588.go
@@ -11,7 +11,7 @@
 
 package p
 
-type F func(b T)  // ERROR "T is not a type"
+type F func(b T)  // ERROR "T .*is not a type"
 
 func T(fn F) {
     func() {
diff --git a/test/fixedbugs/issue18392.go b/test/fixedbugs/issue18392.go
index 053a337867..e0640ed2ee 100644
--- a/test/fixedbugs/issue18392.go
+++ b/test/fixedbugs/issue18392.go
@@ -10,5 +10,5 @@ type A interface {
 	// TODO(mdempsky): This should be an error, but this error is
 	// nonsense. The error should actually mention that there's a
 	// type loop.
-	Fn(A.Fn) // ERROR "type A has no method Fn"
+	Fn(A.Fn) // ERROR "type A has no method Fn|A.Fn undefined"
 }
diff --git a/test/fixedbugs/issue19323.go b/test/fixedbugs/issue19323.go
index f90af660d5..a225d157b2 100644
--- a/test/fixedbugs/issue19323.go
+++ b/test/fixedbugs/issue19323.go
@@ -9,11 +9,11 @@ package p
 func g() {}
 
 func f() {
-	g()[:] // ERROR "g.. used as value"
+	g()[:] // ERROR "g.* used as value"
 }
 
 func g2() ([]byte, []byte) { return nil, nil }
 
 func f2() {
-	g2()[:] // ERROR "multiple-value g2.. in single-value context"
+	g2()[:] // ERROR "multiple-value g2.. in single-value context|2-valued g"
 }
diff --git a/test/fixedbugs/issue19482.go b/test/fixedbugs/issue19482.go
index 97497a434c..d2a0edd0a9 100644
--- a/test/fixedbugs/issue19482.go
+++ b/test/fixedbugs/issue19482.go
@@ -22,13 +22,13 @@ func ok() {
 
 var (
 	y = T{"stare"}
-	w = T{_: "look"} // ERROR "invalid field name _ in struct initializer"
+	w = T{_: "look"} // ERROR "invalid field name _ in struct initializer|unknown field '_' in struct literal of type T"
 	_ = T{"page"}
-	_ = T{_: "out"} // ERROR "invalid field name _ in struct initializer"
+	_ = T{_: "out"} // ERROR "invalid field name _ in struct initializer|unknown field '_' in struct literal of type T"
 )
 
 func bad() {
-	var z = T{_: "verse"} // ERROR "invalid field name _ in struct initializer"
+	var z = T{_: "verse"} // ERROR "invalid field name _ in struct initializer|unknown field '_' in struct literal of type T"
 	_ = z
-	_ = T{_: "itinerary"} // ERROR "invalid field name _ in struct initializer"
+	_ = T{_: "itinerary"} // ERROR "invalid field name _ in struct initializer|unknown field '_' in struct literal of type T"
 }
diff --git a/test/fixedbugs/issue19699b.go b/test/fixedbugs/issue19699b.go
index 4afc0ca833..32ed30fd2b 100644
--- a/test/fixedbugs/issue19699b.go
+++ b/test/fixedbugs/issue19699b.go
@@ -11,4 +11,4 @@ func f() bool {
 	} else {
 		return true
 	}
-} // ERROR "missing return at end of function"
+} // ERROR "missing return( at end of function)?"
diff --git a/test/fixedbugs/issue19880.go b/test/fixedbugs/issue19880.go
index 629c95d960..c2d81e6631 100644
--- a/test/fixedbugs/issue19880.go
+++ b/test/fixedbugs/issue19880.go
@@ -11,7 +11,7 @@ type T struct {
 }
 
 func a() {
-	_ = T // ERROR "type T is not an expression"
+	_ = T // ERROR "type T is not an expression|T \(type\) is not an expression"
 }
 
 func b() {
diff --git a/test/fixedbugs/issue19947.go b/test/fixedbugs/issue19947.go
index 3233469e39..752cfc6bf6 100644
--- a/test/fixedbugs/issue19947.go
+++ b/test/fixedbugs/issue19947.go
@@ -8,8 +8,8 @@
 
 package issue19947
 
-var _ = float32(1) * 1e200 // ERROR "constant 1e\+200 overflows float32"
-var _ = float64(1) * 1e500 // ERROR "constant 1e\+500 overflows float64"
+var _ = float32(1) * 1e200 // ERROR "constant 1e\+200 overflows float32|1e200 .* overflows float32"
+var _ = float64(1) * 1e500 // ERROR "constant 1e\+500 overflows float64|1e500 .* overflows float64"
 
-var _ = complex64(1) * 1e200  // ERROR "constant 1e\+200 overflows complex64"
-var _ = complex128(1) * 1e500 // ERROR "constant 1e\+500 overflows complex128"
+var _ = complex64(1) * 1e200  // ERROR "constant 1e\+200 overflows complex64|1e200 .* overflows complex64"
+var _ = complex128(1) * 1e500 // ERROR "constant 1e\+500 overflows complex128|1e500 .* overflows complex128"
diff --git a/test/fixedbugs/issue20185.go b/test/fixedbugs/issue20185.go
index 2cbb143ed0..86fe0ef8c6 100644
--- a/test/fixedbugs/issue20185.go
+++ b/test/fixedbugs/issue20185.go
@@ -10,7 +10,7 @@
 package p
 
 func F() {
-	switch t := nil.(type) { // ERROR "cannot type switch on non-interface value nil"
+	switch t := nil.(type) { // ERROR "cannot type switch on non-interface value nil|not an interface"
 	default:
 		_ = t
 	}
@@ -19,7 +19,7 @@ func F() {
 const x = 1
 
 func G() {
-	switch t := x.(type) { // ERROR "cannot type switch on non-interface value x \(type untyped int\)"
+	switch t := x.(type) { // ERROR "cannot type switch on non-interface value x \(type untyped int\)|not an interface"
 	default:
 	}
 }
diff --git a/test/fixedbugs/issue20227.go b/test/fixedbugs/issue20227.go
index 4448eb5438..983203cd48 100644
--- a/test/fixedbugs/issue20227.go
+++ b/test/fixedbugs/issue20227.go
@@ -8,9 +8,9 @@
 
 package p
 
-var _ = 1 / 1e-600000000i  // ERROR "complex division by zero"
-var _ = 1i / 1e-600000000  // ERROR "complex division by zero"
-var _ = 1i / 1e-600000000i // ERROR "complex division by zero"
+var _ = 1 / 1e-600000000i  // ERROR "(complex )?division by zero"
+var _ = 1i / 1e-600000000  // ERROR "(complex )?division by zero"
+var _ = 1i / 1e-600000000i // ERROR "(complex )?division by zero"
 
-var _ = 1 / (1e-600000000 + 1e-600000000i)  // ERROR "complex division by zero"
-var _ = 1i / (1e-600000000 + 1e-600000000i) // ERROR "complex division by zero"
+var _ = 1 / (1e-600000000 + 1e-600000000i)  // ERROR "(complex )?division by zero"
+var _ = 1i / (1e-600000000 + 1e-600000000i) // ERROR "(complex )?division by zero"
diff --git a/test/fixedbugs/issue20415.go b/test/fixedbugs/issue20415.go
index 6f2c342ce4..8a4b528a89 100644
--- a/test/fixedbugs/issue20415.go
+++ b/test/fixedbugs/issue20415.go
@@ -11,7 +11,7 @@ package p
 // 1
 var f byte
 
-var f interface{} // ERROR "previous declaration at issue20415.go:12"
+var f interface{} // ERROR "previous declaration at issue20415.go:12|f redeclared"
 
 func _(f int) {
 }
@@ -22,7 +22,7 @@ var g byte
 func _(g int) {
 }
 
-var g interface{} // ERROR "previous declaration at issue20415.go:20"
+var g interface{} // ERROR "previous declaration at issue20415.go:20|g redeclared"
 
 // 3
 func _(h int) {
@@ -30,4 +30,4 @@ func _(h int) {
 
 var h byte
 
-var h interface{} // ERROR "previous declaration at issue20415.go:31"
+var h interface{} // ERROR "previous declaration at issue20415.go:31|h redeclared"
diff --git a/test/fixedbugs/issue20749.go b/test/fixedbugs/issue20749.go
index af9ff3fbed..a670d6ffcd 100644
--- a/test/fixedbugs/issue20749.go
+++ b/test/fixedbugs/issue20749.go
@@ -9,7 +9,7 @@ package p
 // Verify that the compiler complains even if the array
 // has length 0.
 var a [0]int
-var _ = a[2:] // ERROR "invalid slice index 2"
+var _ = a[2:] // ERROR "invalid slice index 2|index 2 out of bounds"
 
 var b [1]int
-var _ = b[2:] // ERROR "invalid slice index 2"
+var _ = b[2:] // ERROR "invalid slice index 2|index 2 out of bounds"
diff --git a/test/fixedbugs/issue22389.go b/test/fixedbugs/issue22389.go
index 706b44941c..75dc285403 100644
--- a/test/fixedbugs/issue22389.go
+++ b/test/fixedbugs/issue22389.go
@@ -14,5 +14,5 @@ func (f *Foo) Call(cb func(*Foo)) {
 
 func main() {
 	f := &Foo{}
-	f.Call(func(f) {}) // ERROR "f is not a type"
+	f.Call(func(f) {}) // ERROR "f .*is not a type"
 }
diff --git a/test/fixedbugs/issue22794.go b/test/fixedbugs/issue22794.go
index c7e9eb1224..0c10208d81 100644
--- a/test/fixedbugs/issue22794.go
+++ b/test/fixedbugs/issue22794.go
@@ -15,6 +15,7 @@ func main() {
 	i1 := it{Floats: true}
 	if i1.floats { // ERROR "(type it .* field or method floats, but does have Floats)"
 	}
-	i2 := &it{floats: false} // ERROR "(but does have Floats)"
-	_ = &it{InneR: "foo"}    // ERROR "(but does have inner)"
+	i2 := &it{floats: false} // ERROR "(but does have Floats)|unknown field"
+	_ = &it{InneR: "foo"}    // ERROR "(but does have inner)|unknown field"
+	_ = i2
 }
diff --git a/test/fixedbugs/issue22822.go b/test/fixedbugs/issue22822.go
index e449ddb186..554b534503 100644
--- a/test/fixedbugs/issue22822.go
+++ b/test/fixedbugs/issue22822.go
@@ -12,5 +12,6 @@ package main
 func F() {
 	slice := []int{1, 2, 3}
 	len := int(2)
-	println(len(slice)) // ERROR "cannot call non-function len .type int., declared at"
+	println(len(slice)) // ERROR "cannot call non-function len .type int., declared at|cannot call non-function len"
+	_ = slice
 }
diff --git a/test/fixedbugs/issue22921.go b/test/fixedbugs/issue22921.go
index 04f78b2c08..d5bb1ed122 100644
--- a/test/fixedbugs/issue22921.go
+++ b/test/fixedbugs/issue22921.go
@@ -8,11 +8,11 @@ package main
 
 import "bytes"
 
-type _ struct{ bytes.nonexist } // ERROR "unexported"
+type _ struct{ bytes.nonexist } // ERROR "unexported|undefined"
 
-type _ interface{ bytes.nonexist } // ERROR "unexported"
+type _ interface{ bytes.nonexist } // ERROR "unexported|undefined"
 
 func main() {
 	var _ bytes.Buffer
-	var _ bytes.buffer // ERROR "unexported"
+	var _ bytes.buffer // ERROR "unexported|undefined"
 }
diff --git a/test/fixedbugs/issue23094.go b/test/fixedbugs/issue23094.go
index 415556f300..853b19b92f 100644
--- a/test/fixedbugs/issue23094.go
+++ b/test/fixedbugs/issue23094.go
@@ -8,4 +8,4 @@
 
 package p
 
-var a [len(a)]int // ERROR "\[len\(a\)\]int"
+var a [len(a)]int // ERROR "\[len\(a\)\]int|initialization loop"
diff --git a/test/fixedbugs/issue23609.go b/test/fixedbugs/issue23609.go
index 7c17a98d32..9130e8dd16 100644
--- a/test/fixedbugs/issue23609.go
+++ b/test/fixedbugs/issue23609.go
@@ -21,7 +21,7 @@ type t3 struct {
 }
 
 var (
-	_ = t2{t1f1: 600} // ERROR "cannot use promoted field t1.t1f1 in struct literal of type t2"
-	_ = t3{t1f2: 800} // ERROR "cannot use promoted field t2.t1.t1f2 in struct literal of type t3"
-	_ = t3{t2f1: 900} // ERROR "cannot use promoted field t2.t2f1 in struct literal of type t3"
+	_ = t2{t1f1: 600} // ERROR "cannot use promoted field t1.t1f1 in struct literal of type t2|unknown field"
+	_ = t3{t1f2: 800} // ERROR "cannot use promoted field t2.t1.t1f2 in struct literal of type t3|unknown field"
+	_ = t3{t2f1: 900} // ERROR "cannot use promoted field t2.t2f1 in struct literal of type t3|unknown field"
 )
diff --git a/test/fixedbugs/issue23823.go b/test/fixedbugs/issue23823.go
index fe6cef1fb4..4e3cd163b6 100644
--- a/test/fixedbugs/issue23823.go
+++ b/test/fixedbugs/issue23823.go
@@ -11,6 +11,6 @@ type I1 = interface {
 }
 
 // BAD: type loop should mention I1; see also #41669
-type I2 interface { // ERROR "invalid recursive type I2\n\tLINE: I2 refers to\n\tLINE: I2$"
+type I2 interface { // ERROR "invalid recursive type I2\n\tLINE: I2 refers to\n\tLINE: I2$|invalid recursive type"
 	I1
 }
diff --git a/test/fixedbugs/issue24470.go b/test/fixedbugs/issue24470.go
index d0e5e23fa9..2805998cca 100644
--- a/test/fixedbugs/issue24470.go
+++ b/test/fixedbugs/issue24470.go
@@ -11,5 +11,6 @@ package p
 
 func f(i interface{}) {
 	if x, ok := i.(type); ok { // ERROR "outside type switch"
+		_ = x
 	}
 }
diff --git a/test/fixedbugs/issue25727.go b/test/fixedbugs/issue25727.go
index da7c94cc12..9e4da6ddba 100644
--- a/test/fixedbugs/issue25727.go
+++ b/test/fixedbugs/issue25727.go
@@ -9,13 +9,13 @@ package main
 import "net/http"
 
 var s = http.Server{}
-var _ = s.doneChan                  // ERROR "s.doneChan undefined .cannot refer to unexported field or method doneChan.$"
+var _ = s.doneChan                  // ERROR "s.doneChan undefined .cannot refer to unexported field or method doneChan.$|s.doneChan undefined"
 var _ = s.DoneChan                  // ERROR "s.DoneChan undefined .type http.Server has no field or method DoneChan.$"
-var _ = http.Server{tlsConfig: nil} // ERROR "unknown field 'tlsConfig' in struct literal.+ .but does have TLSConfig.$"
+var _ = http.Server{tlsConfig: nil} // ERROR "unknown field 'tlsConfig' in struct literal.+ .but does have TLSConfig.$|unknown field 'tlsConfig'"
 var _ = http.Server{DoneChan: nil}  // ERROR "unknown field 'DoneChan' in struct literal of type http.Server$"
 
 type foo struct {
 	bar int
 }
 
-var _ = &foo{bAr: 10} // ERROR "unknown field 'bAr' in struct literal.+ .but does have bar.$"
+var _ = &foo{bAr: 10} // ERROR "unknown field 'bAr' in struct literal.+ .but does have bar.$|unknown field 'bAr'"
diff --git a/test/fixedbugs/issue26416.go b/test/fixedbugs/issue26416.go
index bc37fd9d3a..44a4fc73b7 100644
--- a/test/fixedbugs/issue26416.go
+++ b/test/fixedbugs/issue26416.go
@@ -21,7 +21,7 @@ type t3 struct {
 }
 
 var (
-	_ = t2{t1f1: 600} // ERROR "cannot use promoted field t1.t1f1 in struct literal of type t2"
-	_ = t3{t1f2: 800} // ERROR "cannot use promoted field t2.t1.t1f2 in struct literal of type t3"
-	_ = t3{t2f1: 900} // ERROR "cannot use promoted field t2.t2f1 in struct literal of type t3"
+	_ = t2{t1f1: 600} // ERROR "cannot use promoted field t1.t1f1 in struct literal of type t2|unknown field"
+	_ = t3{t1f2: 800} // ERROR "cannot use promoted field t2.t1.t1f2 in struct literal of type t3|unknown field"
+	_ = t3{t2f1: 900} // ERROR "cannot use promoted field t2.t2f1 in struct literal of type t3|unknown field"
 )
diff --git a/test/fixedbugs/issue26616.go b/test/fixedbugs/issue26616.go
index e5565b68ca..d20d4518c0 100644
--- a/test/fixedbugs/issue26616.go
+++ b/test/fixedbugs/issue26616.go
@@ -6,13 +6,13 @@
 
 package p
 
-var x int = three() // ERROR "assignment mismatch: 1 variable but three returns 3 values"
+var x int = three() // ERROR "assignment mismatch: 1 variable but three returns 3 values|3\-valued"
 
 func f() {
-	var _ int = three() // ERROR "assignment mismatch: 1 variable but three returns 3 values"
-	var a int = three() // ERROR "assignment mismatch: 1 variable but three returns 3 values"
-	a = three()         // ERROR "assignment mismatch: 1 variable but three returns 3 values"
-	b := three()        // ERROR "assignment mismatch: 1 variable but three returns 3 values"
+	var _ int = three() // ERROR "assignment mismatch: 1 variable but three returns 3 values|3\-valued"
+	var a int = three() // ERROR "assignment mismatch: 1 variable but three returns 3 values|3\-valued"
+	a = three()         // ERROR "assignment mismatch: 1 variable but three returns 3 values|cannot assign"
+	b := three()        // ERROR "assignment mismatch: 1 variable but three returns 3 values|cannot initialize"
 
 	_, _ = a, b
 }
diff --git a/test/fixedbugs/issue27595.go b/test/fixedbugs/issue27595.go
index af5c7a10d9..8277145769 100644
--- a/test/fixedbugs/issue27595.go
+++ b/test/fixedbugs/issue27595.go
@@ -6,9 +6,9 @@
 
 package main
 
-var a = twoResults()       // ERROR "assignment mismatch: 1 variable but twoResults returns 2 values"
-var b, c, d = twoResults() // ERROR "assignment mismatch: 3 variables but twoResults returns 2 values"
-var e, f = oneResult()     // ERROR "assignment mismatch: 2 variables but oneResult returns 1 values"
+var a = twoResults()       // ERROR "assignment mismatch: 1 variable but twoResults returns 2 values|2\-valued"
+var b, c, d = twoResults() // ERROR "assignment mismatch: 3 variables but twoResults returns 2 values|cannot initialize"
+var e, f = oneResult()     // ERROR "assignment mismatch: 2 variables but oneResult returns 1 values|cannot initialize"
 
 func twoResults() (int, int) {
 	return 1, 2
diff --git a/test/fixedbugs/issue28079c.go b/test/fixedbugs/issue28079c.go
index bea1898304..ec650848ae 100644
--- a/test/fixedbugs/issue28079c.go
+++ b/test/fixedbugs/issue28079c.go
@@ -11,5 +11,5 @@ package p
 import "unsafe"
 
 func f() {
-	_ = complex(1<<uintptr(unsafe.Pointer(nil)), 0) // ERROR "invalid operation: .*shift of type float64.*"
+	_ = complex(1<<uintptr(unsafe.Pointer(nil)), 0) // ERROR "invalid operation: .*shift of type float64.*|shifted operand .* must be integer"
 }
diff --git a/test/fixedbugs/issue28450.go b/test/fixedbugs/issue28450.go
index 1a1183b291..1fae40ad08 100644
--- a/test/fixedbugs/issue28450.go
+++ b/test/fixedbugs/issue28450.go
@@ -6,13 +6,13 @@
 
 package p
 
-func f(a, b, c, d ...int)       {} // ERROR "non-final parameter a"
-func g(a ...int, b ...int)      {} // ERROR "non-final parameter a"
-func h(...int, ...int, float32) {} // ERROR "non-final parameter"
+func f(a, b, c, d ...int)       {} // ERROR "non-final parameter a|can only use ... with final parameter"
+func g(a ...int, b ...int)      {} // ERROR "non-final parameter a|can only use ... with final parameter"
+func h(...int, ...int, float32) {} // ERROR "non-final parameter|can only use ... with final parameter"
 
-type a func(...float32, ...interface{}) // ERROR "non-final parameter"
+type a func(...float32, ...interface{}) // ERROR "non-final parameter|can only use ... with final parameter"
 type b interface {
-	f(...int, ...int)                // ERROR "non-final parameter"
-	g(a ...int, b ...int, c float32) // ERROR "non-final parameter a"
+	f(...int, ...int)                // ERROR "non-final parameter|can only use ... with final parameter"
+	g(a ...int, b ...int, c float32) // ERROR "non-final parameter a|can only use ... with final parameter"
 	valid(...int)
 }
diff --git a/test/fixedbugs/issue30085.go b/test/fixedbugs/issue30085.go
index 8223c855cd..ae977e65f9 100644
--- a/test/fixedbugs/issue30085.go
+++ b/test/fixedbugs/issue30085.go
@@ -7,6 +7,7 @@
 package main
 
 func main() {
-	var c, d = 1, 2, 3 // ERROR "assignment mismatch: 2 variables but 3 values"
-	var e, f, g = 1, 2 // ERROR "assignment mismatch: 3 variables but 2 values"
+	var c, d = 1, 2, 3 // ERROR "assignment mismatch: 2 variables but 3 values|extra init expr"
+	var e, f, g = 1, 2 // ERROR "assignment mismatch: 3 variables but 2 values|missing init expr"
+	_, _, _, _ = c, d, e, f
 }
diff --git a/test/fixedbugs/issue30087.go b/test/fixedbugs/issue30087.go
index dc12364d80..c9280b689f 100644
--- a/test/fixedbugs/issue30087.go
+++ b/test/fixedbugs/issue30087.go
@@ -7,8 +7,9 @@
 package main
 
 func main() {
-	var a, b = 1    // ERROR "assignment mismatch: 2 variables but 1 values"
-	_ = 1, 2        // ERROR "assignment mismatch: 1 variables but 2 values"
-	c, d := 1       // ERROR "assignment mismatch: 2 variables but 1 values"
-	e, f := 1, 2, 3 // ERROR "assignment mismatch: 2 variables but 3 values"
+	var a, b = 1    // ERROR "assignment mismatch: 2 variables but 1 values|cannot initialize"
+	_ = 1, 2        // ERROR "assignment mismatch: 1 variables but 2 values|cannot assign"
+	c, d := 1       // ERROR "assignment mismatch: 2 variables but 1 values|cannot initialize"
+	e, f := 1, 2, 3 // ERROR "assignment mismatch: 2 variables but 3 values|cannot initialize"
+	_, _, _, _ = c, d, e, f
 }
diff --git a/test/fixedbugs/issue35291.go b/test/fixedbugs/issue35291.go
index 3cbdbf962a..eb6c4ce807 100644
--- a/test/fixedbugs/issue35291.go
+++ b/test/fixedbugs/issue35291.go
@@ -10,5 +10,5 @@ package p
 
 var s = []string{
 	1: "dup",
-	1: "dup", // ERROR "duplicate index in slice literal: 1"
+	1: "dup", // ERROR "duplicate index in slice literal: 1|duplicate index 1 in array or slice literal"
 }
diff --git a/test/fixedbugs/issue38117.go b/test/fixedbugs/issue38117.go
index 11edef7f25..c0707ef6dc 100644
--- a/test/fixedbugs/issue38117.go
+++ b/test/fixedbugs/issue38117.go
@@ -13,5 +13,5 @@ const (
 	_ = int(complex64(int(0)))
 	_ = float64(complex128(float64(0)))
 
-	_ = int8(complex128(1000)) // ERROR "overflow"
+	_ = int8(complex128(1000)) // ERROR "overflow|cannot convert"
 )
diff --git a/test/fixedbugs/issue38745.go b/test/fixedbugs/issue38745.go
index 83a3bc6fad..78a9165354 100644
--- a/test/fixedbugs/issue38745.go
+++ b/test/fixedbugs/issue38745.go
@@ -10,7 +10,7 @@ type t struct{ x int }
 
 func f1() {
 	t{}.M()     // ERROR "t{}.M undefined \(type t has no field or method M\)"
-	t{x: 1}.M() // ERROR "t{...}.M undefined \(type t has no field or method M\)"
+	t{x: 1}.M() // ERROR "t{(...|…)}.M undefined \(type t has no field or method M\)"
 }
 
 func f2() (*t, error) {
diff --git a/test/fixedbugs/issue3925.go b/test/fixedbugs/issue3925.go
index 628c222685..f0851878ec 100644
--- a/test/fixedbugs/issue3925.go
+++ b/test/fixedbugs/issue3925.go
@@ -18,6 +18,6 @@ var _ = map[string]string{
 var _ = []string{
 	"foo",
 	"bar",
-	20, // ERROR "cannot use|incompatible type"
+	20, // ERROR "cannot use|incompatible type|cannot convert"
 }
 
diff --git a/test/fixedbugs/issue4085a.go b/test/fixedbugs/issue4085a.go
index 200290a081..bf97c9e449 100644
--- a/test/fixedbugs/issue4085a.go
+++ b/test/fixedbugs/issue4085a.go
@@ -10,9 +10,9 @@ type T []int
 
 func main() {
 	_ = make(T, -1)    // ERROR "negative"
-	_ = make(T, 0.5)   // ERROR "constant 0.5 truncated to integer|non-integer len argument"
+	_ = make(T, 0.5)   // ERROR "constant 0.5 truncated to integer|non-integer len argument|truncated to int"
 	_ = make(T, 1.0)   // ok
-	_ = make(T, 1<<63) // ERROR "len argument too large"
-	_ = make(T, 0, -1) // ERROR "negative cap"
-	_ = make(T, 10, 0) // ERROR "len larger than cap"
+	_ = make(T, 1<<63) // ERROR "len argument too large|overflows int"
+	_ = make(T, 0, -1) // ERROR "negative cap|must not be negative"
+	_ = make(T, 10, 0) // ERROR "len larger than cap|length and capacity swapped"
 }
diff --git a/test/fixedbugs/issue41247.go b/test/fixedbugs/issue41247.go
index b8bd81274f..b501be2fbe 100644
--- a/test/fixedbugs/issue41247.go
+++ b/test/fixedbugs/issue41247.go
@@ -7,5 +7,5 @@
 package p
 
 func f() [2]int {
-	return [...]int{2: 0} // ERROR "cannot use \[\.\.\.\]int{...} \(type \[3\]int\)"
+	return [...]int{2: 0} // ERROR "cannot use \[\.\.\.\]int{...} \(type \[3\]int\)|cannot use"
 }
diff --git a/test/fixedbugs/issue41440.go b/test/fixedbugs/issue41440.go
index 2b441db803..51646540b7 100644
--- a/test/fixedbugs/issue41440.go
+++ b/test/fixedbugs/issue41440.go
@@ -10,5 +10,5 @@ func f(...int) {}
 
 func g() {
 	var x []int
-	f(x, x...) // ERROR "have \(\[\]int, \.\.\.int\)"
+	f(x, x...) // ERROR "have \(\[\]int, \.\.\.int\)|too many arguments in call to f"
 }
diff --git a/test/fixedbugs/issue41500.go b/test/fixedbugs/issue41500.go
index d1e4efc8fd..bd51de29be 100644
--- a/test/fixedbugs/issue41500.go
+++ b/test/fixedbugs/issue41500.go
@@ -13,8 +13,8 @@ type s struct {
 func f() {
 	var x *s
 
-	_ = x == nil || len(x.slice) // ERROR "invalid operation: .+ \(operator \|\| not defined on int\)"
-	_ = len(x.slice) || x == nil // ERROR "invalid operation: .+ \(operator \|\| not defined on int\)"
-	_ = x == nil && len(x.slice) // ERROR "invalid operation: .+ \(operator && not defined on int\)"
-	_ = len(x.slice) && x == nil // ERROR "invalid operation: .+ \(operator && not defined on int\)"
+	_ = x == nil || len(x.slice) // ERROR "invalid operation: .+ \(operator \|\| not defined on int\)|cannot convert x == nil"
+	_ = len(x.slice) || x == nil // ERROR "invalid operation: .+ \(operator \|\| not defined on int\)|cannot convert x == nil"
+	_ = x == nil && len(x.slice) // ERROR "invalid operation: .+ \(operator && not defined on int\)|cannot convert x == nil"
+	_ = len(x.slice) && x == nil // ERROR "invalid operation: .+ \(operator && not defined on int\)|cannot convert x == nil"
 }
diff --git a/test/fixedbugs/issue4215.go b/test/fixedbugs/issue4215.go
index 795d48d7f5..df986c179d 100644
--- a/test/fixedbugs/issue4215.go
+++ b/test/fixedbugs/issue4215.go
@@ -7,28 +7,28 @@
 package main
 
 func foo() (int, int) {
-	return 2.3 // ERROR "not enough arguments to return\n\thave \(number\)\n\twant \(int, int\)"
+	return 2.3 // ERROR "not enough arguments to return\n\thave \(number\)\n\twant \(int, int\)|wrong number of return values"
 }
 
 func foo2() {
-	return int(2), 2 // ERROR "too many arguments to return\n\thave \(int, number\)\n\twant \(\)"
+	return int(2), 2 // ERROR "too many arguments to return\n\thave \(int, number\)\n\twant \(\)|no result values expected"
 }
 
 func foo3(v int) (a, b, c, d int) {
 	if v >= 0 {
-		return 1 // ERROR "not enough arguments to return\n\thave \(number\)\n\twant \(int, int, int, int\)"
+		return 1 // ERROR "not enough arguments to return\n\thave \(number\)\n\twant \(int, int, int, int\)|wrong number of return values"
 	}
-	return 2, 3 // ERROR "not enough arguments to return\n\thave \(number, number\)\n\twant \(int, int, int, int\)"
+	return 2, 3 // ERROR "not enough arguments to return\n\thave \(number, number\)\n\twant \(int, int, int, int\)|wrong number of return values"
 }
 
 func foo4(name string) (string, int) {
 	switch name {
 	case "cow":
-		return "moo" // ERROR "not enough arguments to return\n\thave \(string\)\n\twant \(string, int\)"
+		return "moo" // ERROR "not enough arguments to return\n\thave \(string\)\n\twant \(string, int\)|wrong number of return values"
 	case "dog":
-		return "dog", 10, true // ERROR "too many arguments to return\n\thave \(string, number, bool\)\n\twant \(string, int\)"
+		return "dog", 10, true // ERROR "too many arguments to return\n\thave \(string, number, bool\)\n\twant \(string, int\)|wrong number of return values"
 	case "fish":
-		return "" // ERROR "not enough arguments to return\n\thave \(string\)\n\twant \(string, int\)"
+		return "" // ERROR "not enough arguments to return\n\thave \(string\)\n\twant \(string, int\)|wrong number of return values"
 	default:
 		return "lizard", 10
 	}
@@ -40,14 +40,14 @@ type U float64
 
 func foo5() (S, T, U) {
 	if false {
-		return "" // ERROR "not enough arguments to return\n\thave \(string\)\n\twant \(S, T, U\)"
+		return "" // ERROR "not enough arguments to return\n\thave \(string\)\n\twant \(S, T, U\)|wrong number of return values"
 	} else {
 		ptr := new(T)
-		return ptr // ERROR "not enough arguments to return\n\thave \(\*T\)\n\twant \(S, T, U\)"
+		return ptr // ERROR "not enough arguments to return\n\thave \(\*T\)\n\twant \(S, T, U\)|wrong number of return values"
 	}
-	return new(S), 12.34, 1 + 0i, 'r', true // ERROR "too many arguments to return\n\thave \(\*S, number, number, number, bool\)\n\twant \(S, T, U\)"
+	return new(S), 12.34, 1 + 0i, 'r', true // ERROR "too many arguments to return\n\thave \(\*S, number, number, number, bool\)\n\twant \(S, T, U\)|wrong number of return values"
 }
 
 func foo6() (T, string) {
-	return "T", true, true // ERROR "too many arguments to return\n\thave \(string, bool, bool\)\n\twant \(T, string\)"
+	return "T", true, true // ERROR "too many arguments to return\n\thave \(string, bool, bool\)\n\twant \(T, string\)|wrong number of return values"
 }
diff --git a/test/fixedbugs/issue4251.go b/test/fixedbugs/issue4251.go
index d11ce51b97..81e3edf5e3 100644
--- a/test/fixedbugs/issue4251.go
+++ b/test/fixedbugs/issue4251.go
@@ -9,13 +9,13 @@
 package p
 
 func F1(s []byte) []byte {
-	return s[2:1]		// ERROR "invalid slice index|inverted slice range"
+	return s[2:1]		// ERROR "invalid slice index|inverted slice range|invalid slice indices"
 }
 
 func F2(a [10]byte) []byte {
-	return a[2:1]		// ERROR "invalid slice index|inverted slice range"
+	return a[2:1]		// ERROR "invalid slice index|inverted slice range|invalid slice indices"
 }
 
 func F3(s string) string {
-	return s[2:1]		// ERROR "invalid slice index|inverted slice range"
+	return s[2:1]		// ERROR "invalid slice index|inverted slice range|invalid slice indices"
 }
diff --git a/test/fixedbugs/issue4429.go b/test/fixedbugs/issue4429.go
index 9eb2e0f9c2..3af6f9761b 100644
--- a/test/fixedbugs/issue4429.go
+++ b/test/fixedbugs/issue4429.go
@@ -12,5 +12,5 @@ type a struct {
 
 func main() {
   av := a{};
-  _ = *a(av); // ERROR "invalid indirect|expected pointer"
+  _ = *a(av); // ERROR "invalid indirect|expected pointer|cannot indirect"
 }
diff --git a/test/fixedbugs/issue4458.go b/test/fixedbugs/issue4458.go
index 98ffea79dc..3ae9910d9e 100644
--- a/test/fixedbugs/issue4458.go
+++ b/test/fixedbugs/issue4458.go
@@ -16,5 +16,5 @@ func (T) foo() {}
 func main() {
 	av := T{}
 	pav := &av
-	(**T).foo(&pav) // ERROR "no method foo|requires named type or pointer to named"
+	(**T).foo(&pav) // ERROR "no method foo|requires named type or pointer to named|undefined"
 }
diff --git a/test/fixedbugs/issue4470.go b/test/fixedbugs/issue4470.go
index d922478455..1dc556380e 100644
--- a/test/fixedbugs/issue4470.go
+++ b/test/fixedbugs/issue4470.go
@@ -13,4 +13,5 @@ func main() {
 	switch (i.(type)) { // ERROR "outside type switch"
 	default:
 	}
+	_ = i
 }
diff --git a/test/fixedbugs/issue4517d.go b/test/fixedbugs/issue4517d.go
index 197c225c6f..d732e1fa1d 100644
--- a/test/fixedbugs/issue4517d.go
+++ b/test/fixedbugs/issue4517d.go
@@ -6,4 +6,4 @@
 
 package p
 
-import init "fmt" // ERROR "cannot import package as init"
+import init "fmt" // ERROR "cannot import package as init|cannot declare init"
diff --git a/test/fixedbugs/issue4909a.go b/test/fixedbugs/issue4909a.go
index 09e1b85099..27ae29438f 100644
--- a/test/fixedbugs/issue4909a.go
+++ b/test/fixedbugs/issue4909a.go
@@ -27,8 +27,8 @@ type B struct {
 var t T
 var p *T
 
-const N1 = unsafe.Offsetof(t.X)      // ERROR "indirection"
-const N2 = unsafe.Offsetof(p.X)      // ERROR "indirection"
+const N1 = unsafe.Offsetof(t.X)      // ERROR "indirection|field X is embedded via a pointer in T"
+const N2 = unsafe.Offsetof(p.X)      // ERROR "indirection|field X is embedded via a pointer in T"
 const N3 = unsafe.Offsetof(t.B.X)    // valid
 const N4 = unsafe.Offsetof(p.B.X)    // valid
 const N5 = unsafe.Offsetof(t.Method) // ERROR "method value"
diff --git a/test/run.go b/test/run.go
index 8e1b06974c..1932c9e610 100644
--- a/test/run.go
+++ b/test/run.go
@@ -769,8 +769,10 @@ func (t *test) run() {
 			for _, pattern := range []string{
 				"-+",
 				"-0",
+				"-e=0",
 				"-m",
 				"-live",
+				"-std",
 				"wb",
 				"append",
 				"slice",
@@ -1942,140 +1944,88 @@ var excluded = map[string]bool{
 	"switch7.go":      true,
 	"typecheck.go":    true, // invalid function is not causing errors when called
 
-	"fixedbugs/bug163.go":      true,
-	"fixedbugs/bug176.go":      true,
-	"fixedbugs/bug192.go":      true,
-	"fixedbugs/bug193.go":      true,
-	"fixedbugs/bug195.go":      true,
-	"fixedbugs/bug213.go":      true,
-	"fixedbugs/bug228.go":      true,
-	"fixedbugs/bug229.go":      true,
-	"fixedbugs/bug231.go":      true,
-	"fixedbugs/bug251.go":      true,
-	"fixedbugs/bug255.go":      true,
-	"fixedbugs/bug256.go":      true,
-	"fixedbugs/bug325.go":      true,
-	"fixedbugs/bug326.go":      true,
-	"fixedbugs/bug340.go":      true,
-	"fixedbugs/bug342.go":      true,
-	"fixedbugs/bug350.go":      true,
-	"fixedbugs/bug351.go":      true,
-	"fixedbugs/bug353.go":      true,
-	"fixedbugs/bug357.go":      true,
-	"fixedbugs/bug362.go":      true,
-	"fixedbugs/bug371.go":      true,
-	"fixedbugs/bug374.go":      true,
-	"fixedbugs/bug379.go":      true,
-	"fixedbugs/bug383.go":      true,
-	"fixedbugs/bug385_64.go":   true,
-	"fixedbugs/bug386.go":      true,
-	"fixedbugs/bug388.go":      true,
-	"fixedbugs/bug389.go":      true,
-	"fixedbugs/bug390.go":      true,
-	"fixedbugs/bug397.go":      true,
-	"fixedbugs/bug412.go":      true,
-	"fixedbugs/bug413.go":      true,
-	"fixedbugs/bug416.go":      true,
-	"fixedbugs/bug418.go":      true,
-	"fixedbugs/bug459.go":      true,
-	"fixedbugs/bug462.go":      true,
-	"fixedbugs/bug463.go":      true,
-	"fixedbugs/bug487.go":      true,
-	"fixedbugs/issue11362.go":  true,
-	"fixedbugs/issue11590.go":  true,
-	"fixedbugs/issue11610.go":  true,
+	"fixedbugs/bug163.go":    true,
+	"fixedbugs/bug176.go":    true,
+	"fixedbugs/bug192.go":    true,
+	"fixedbugs/bug193.go":    true,
+	"fixedbugs/bug195.go":    true,
+	"fixedbugs/bug213.go":    true,
+	"fixedbugs/bug228.go":    true,
+	"fixedbugs/bug229.go":    true,
+	"fixedbugs/bug231.go":    true,
+	"fixedbugs/bug251.go":    true,
+	"fixedbugs/bug255.go":    true,
+	"fixedbugs/bug256.go":    true,
+	"fixedbugs/bug325.go":    true,
+	"fixedbugs/bug326.go":    true,
+	"fixedbugs/bug340.go":    true,
+	"fixedbugs/bug342.go":    true,
+	"fixedbugs/bug350.go":    true,
+	"fixedbugs/bug351.go":    true,
+	"fixedbugs/bug353.go":    true,
+	"fixedbugs/bug357.go":    true,
+	"fixedbugs/bug362.go":    true,
+	"fixedbugs/bug371.go":    true,
+	"fixedbugs/bug374.go":    true,
+	"fixedbugs/bug379.go":    true,
+	"fixedbugs/bug383.go":    true,
+	"fixedbugs/bug385_64.go": true,
+	"fixedbugs/bug386.go":    true,
+	"fixedbugs/bug388.go":    true,
+	"fixedbugs/bug389.go":    true,
+	"fixedbugs/bug390.go":    true,
+	"fixedbugs/bug397.go":    true,
+	"fixedbugs/bug412.go":    true,
+	"fixedbugs/bug413.go":    true,
+	"fixedbugs/bug416.go":    true,
+	"fixedbugs/bug418.go":    true,
+	"fixedbugs/bug459.go":    true,
+	"fixedbugs/bug462.go":    true,
+	"fixedbugs/bug463.go":    true,
+	"fixedbugs/bug487.go":    true,
+
+	"fixedbugs/issue11362.go":  true, // types2 import path handling
+	"fixedbugs/issue11590.go":  true, // types2 doesn't report a follow-on error (pref: types2)
+	"fixedbugs/issue11610.go":  true, // types2 not run after syntax errors
 	"fixedbugs/issue11614.go":  true, // types2 reports an extra error
 	"fixedbugs/issue13415.go":  true, // declared but not used conflict
 	"fixedbugs/issue14520.go":  true, // missing import path error by types2
 	"fixedbugs/issue14540.go":  true, // types2 is missing a fallthrough error
 	"fixedbugs/issue16428.go":  true, // types2 reports two instead of one error
-	"fixedbugs/issue17038.go":  true,
-	"fixedbugs/issue17588.go":  true,
-	"fixedbugs/issue17631.go":  true,
-	"fixedbugs/issue17645.go":  true,
-	"fixedbugs/issue18331.go":  true,
-	"fixedbugs/issue18392.go":  true,
-	"fixedbugs/issue18393.go":  true,
-	"fixedbugs/issue19012.go":  true,
-	"fixedbugs/issue19323.go":  true,
-	"fixedbugs/issue19482.go":  true,
-	"fixedbugs/issue19699b.go": true,
-	"fixedbugs/issue19880.go":  true,
-	"fixedbugs/issue19947.go":  true,
-	"fixedbugs/issue20185.go":  true,
-	"fixedbugs/issue20227.go":  true,
-	"fixedbugs/issue20233.go":  true,
-	"fixedbugs/issue20245.go":  true,
-	"fixedbugs/issue20298.go":  true,
-	"fixedbugs/issue20415.go":  true,
-	"fixedbugs/issue20529.go":  true,
-	"fixedbugs/issue20749.go":  true,
-	"fixedbugs/issue20780.go":  true,
-	"fixedbugs/issue21273.go":  true,
-	"fixedbugs/issue21882.go":  true,
-	"fixedbugs/issue21979.go":  true,
-	"fixedbugs/issue22200.go":  true,
-	"fixedbugs/issue22200b.go": true,
-	"fixedbugs/issue22389.go":  true,
-	"fixedbugs/issue22794.go":  true,
-	"fixedbugs/issue22822.go":  true,
-	"fixedbugs/issue22904.go":  true,
-	"fixedbugs/issue22921.go":  true,
-	"fixedbugs/issue23093.go":  true,
-	"fixedbugs/issue23094.go":  true,
-	"fixedbugs/issue23609.go":  true,
-	"fixedbugs/issue23732.go":  true,
-	"fixedbugs/issue23823.go":  true,
-	"fixedbugs/issue24339.go":  true,
-	"fixedbugs/issue24470.go":  true,
-	"fixedbugs/issue25507.go":  true,
-	"fixedbugs/issue25727.go":  true,
-	"fixedbugs/issue25958.go":  true,
-	"fixedbugs/issue26416.go":  true,
-	"fixedbugs/issue26616.go":  true,
-	"fixedbugs/issue27595.go":  true,
-	"fixedbugs/issue28079b.go": true,
-	"fixedbugs/issue28079c.go": true,
-	"fixedbugs/issue28268.go":  true,
-	"fixedbugs/issue28450.go":  true,
-	"fixedbugs/issue29855.go":  true,
-	"fixedbugs/issue30085.go":  true,
-	"fixedbugs/issue30087.go":  true,
-	"fixedbugs/issue31747.go":  true,
-	"fixedbugs/issue32133.go":  true,
-	"fixedbugs/issue32723.go":  true,
-	"fixedbugs/issue33460.go":  true,
-	"fixedbugs/issue34329.go":  true,
-	"fixedbugs/issue35291.go":  true,
-	"fixedbugs/issue38117.go":  true,
-	"fixedbugs/issue38745.go":  true,
-	"fixedbugs/issue3925.go":   true,
-	"fixedbugs/issue4085a.go":  true,
-	"fixedbugs/issue41247.go":  true,
-	"fixedbugs/issue41440.go":  true,
-	"fixedbugs/issue41500.go":  true,
-	"fixedbugs/issue41575.go":  true,
-	"fixedbugs/issue42058a.go": true,
-	"fixedbugs/issue42058b.go": true,
-	"fixedbugs/issue42075.go":  true,
-	"fixedbugs/issue4215.go":   true,
-	"fixedbugs/issue4232.go":   true,
-	"fixedbugs/issue4251.go":   true,
-	"fixedbugs/issue4429.go":   true,
-	"fixedbugs/issue4452.go":   true,
-	"fixedbugs/issue4458.go":   true,
-	"fixedbugs/issue4470.go":   true,
-	"fixedbugs/issue4517d.go":  true,
-	"fixedbugs/issue4847.go":   true,
-	"fixedbugs/issue4909a.go":  true,
+	"fixedbugs/issue17038.go":  true, // types2 doesn't report a follow-on error (pref: types2)
+	"fixedbugs/issue17645.go":  true, // multiple errors on same line
+	"fixedbugs/issue18393.go":  true, // types2 not run after syntax errors
+	"fixedbugs/issue19012.go":  true, // multiple errors on same line
+	"fixedbugs/issue20233.go":  true, // types2 reports two instead of one error (pref: compiler)
+	"fixedbugs/issue20245.go":  true, // types2 reports two instead of one error (pref: compiler)
+	"fixedbugs/issue20529.go":  true, // types2 doesn't produce "stack frame too large" error
+	"fixedbugs/issue20780.go":  true, // types2 doesn't produce "stack frame too large" error
+	"fixedbugs/issue21979.go":  true, // types2 doesn't report a follow-on error (pref: types2)
+	"fixedbugs/issue22200.go":  true, // types2 doesn't produce "stack frame too large" error
+	"fixedbugs/issue22200b.go": true, // types2 doesn't produce "stack frame too large" error
+	"fixedbugs/issue23732.go":  true, // types2 reports different (but ok) line numbers
+	"fixedbugs/issue24339.go":  true, // types2 reports wrong line number
+	"fixedbugs/issue25507.go":  true, // types2 doesn't produce "stack frame too large" error
+	"fixedbugs/issue25958.go":  true, // types2 doesn't report a follow-on error (pref: types2)
+	"fixedbugs/issue28079b.go": true, // types2 reports follow-on errors
+	"fixedbugs/issue28268.go":  true, // types2 reports follow-on errors
+	"fixedbugs/issue31747.go":  true, // types2 is missing support for -lang flag
+	"fixedbugs/issue32133.go":  true, // types2 line numbers off?
+	"fixedbugs/issue33460.go":  true, // types2 reports alternative positions in separate error
+	"fixedbugs/issue34329.go":  true, // types2 is missing support for -lang flag
+	"fixedbugs/issue41575.go":  true, // types2 reports alternative positions in separate error
+	"fixedbugs/issue42058a.go": true, // types2 doesn't report "channel element type too large"
+	"fixedbugs/issue42058b.go": true, // types2 doesn't report "channel element type too large"
+	"fixedbugs/issue4232.go":   true, // types2 reports (correct) extra errors
+	"fixedbugs/issue4452.go":   true, // types2 reports (correct) extra errors
 	"fixedbugs/issue5609.go":   true, // types2 needs a better error message
 	"fixedbugs/issue6500.go":   true, // compiler -G is not reporting an error (but types2 does)
 	"fixedbugs/issue6889.go":   true, // types2 can handle this without constant overflow
-	"fixedbugs/issue7525.go":   true, // init cycle error on different line - ok otherwise
-	"fixedbugs/issue7525b.go":  true, // init cycle error on different line - ok otherwise
-	"fixedbugs/issue7525c.go":  true, // init cycle error on different line - ok otherwise
-	"fixedbugs/issue7525d.go":  true, // init cycle error on different line - ok otherwise
-	"fixedbugs/issue7525e.go":  true, // init cycle error on different line - ok otherwise
-	"fixedbugs/issue7742.go":   true, // type-checking doesn't terminate
-	"fixedbugs/issue7746.go":   true, // type-checking doesn't terminate
+	"fixedbugs/issue7525.go":   true, // types2 reports init cycle error on different line - ok otherwise
+	"fixedbugs/issue7525b.go":  true, // types2 reports init cycle error on different line - ok otherwise
+	"fixedbugs/issue7525c.go":  true, // types2 reports init cycle error on different line - ok otherwise
+	"fixedbugs/issue7525d.go":  true, // types2 reports init cycle error on different line - ok otherwise
+	"fixedbugs/issue7525e.go":  true, // types2 reports init cycle error on different line - ok otherwise
+	"fixedbugs/issue7742.go":   true, // types2 type-checking doesn't terminate
+	"fixedbugs/issue7746.go":   true, // types2 type-checking doesn't terminate
 }
-- 
GitLab


From dbce27d29c8479d969aad5be4658fde32ff3f1e4 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 9 Dec 2020 15:49:04 -0800
Subject: [PATCH 0204/2400] [dev.typeparams] cmd/compile/internal/types2:
 report correct line number for missing key

Use the Key position of a syntax.KeyValueExpr (not the position of the
":") when reporting an error for a missing key.

(In go/types, the KeyValueExpr position is the start of the expression
not the ":", so there this works as expected.)

Change-Id: I74147d245927847274cf4e53b4f03dbb5110c324
Reviewed-on: https://go-review.googlesource.com/c/go/+/276813
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/expr.go | 4 ++--
 test/run.go                             | 1 -
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 2fabd9694e..252d4814cc 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -1277,9 +1277,9 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 					i := fieldIndex(utyp.fields, check.pkg, key.Value)
 					if i < 0 {
 						if check.conf.CompilerErrorMessages {
-							check.errorf(kv, "unknown field '%s' in struct literal of type %s", key.Value, base)
+							check.errorf(kv.Key, "unknown field '%s' in struct literal of type %s", key.Value, base)
 						} else {
-							check.errorf(kv, "unknown field %s in struct literal", key.Value)
+							check.errorf(kv.Key, "unknown field %s in struct literal", key.Value)
 						}
 						continue
 					}
diff --git a/test/run.go b/test/run.go
index 1932c9e610..db8bffc81f 100644
--- a/test/run.go
+++ b/test/run.go
@@ -2004,7 +2004,6 @@ var excluded = map[string]bool{
 	"fixedbugs/issue22200.go":  true, // types2 doesn't produce "stack frame too large" error
 	"fixedbugs/issue22200b.go": true, // types2 doesn't produce "stack frame too large" error
 	"fixedbugs/issue23732.go":  true, // types2 reports different (but ok) line numbers
-	"fixedbugs/issue24339.go":  true, // types2 reports wrong line number
 	"fixedbugs/issue25507.go":  true, // types2 doesn't produce "stack frame too large" error
 	"fixedbugs/issue25958.go":  true, // types2 doesn't report a follow-on error (pref: types2)
 	"fixedbugs/issue28079b.go": true, // types2 reports follow-on errors
-- 
GitLab


From ddf44904f125c964e81d7c3ec2612908f95a0fa3 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 9 Dec 2020 17:17:36 -0800
Subject: [PATCH 0205/2400] [dev.typeparams] test: exclude 32bit-specific test
 that fails on 32bit platforms (fix build)

Change-Id: I4f1d5d34dd9b26cea8e837a8ff7e833e02c913e1
Reviewed-on: https://go-review.googlesource.com/c/go/+/276815
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 test/run.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/run.go b/test/run.go
index db8bffc81f..3e0e7ab368 100644
--- a/test/run.go
+++ b/test/run.go
@@ -1969,7 +1969,8 @@ var excluded = map[string]bool{
 	"fixedbugs/bug374.go":    true,
 	"fixedbugs/bug379.go":    true,
 	"fixedbugs/bug383.go":    true,
-	"fixedbugs/bug385_64.go": true,
+	"fixedbugs/bug385_32.go": true, // types2 doesn't produce "stack frame too large" error (32-bit specific)
+	"fixedbugs/bug385_64.go": true, // types2 doesn't produce "stack frame too large" error
 	"fixedbugs/bug386.go":    true,
 	"fixedbugs/bug388.go":    true,
 	"fixedbugs/bug389.go":    true,
-- 
GitLab


From a20021227e987a24d3dbac5118a9dee4d90a96ff Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 9 Dec 2020 17:09:14 -0800
Subject: [PATCH 0206/2400] [dev.typeparams] cmd/compile/internal/types2: bring
 over subst.go changes from go/types

This CL make this code match closely with the go/types version
(see https://golang.org/cl/276253).

Change-Id: I2b7841309fdbda7e2c9533768bd98317729b13b4
Reviewed-on: https://go-review.googlesource.com/c/go/+/276814
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/subst.go | 26 +++++++++++-------------
 1 file changed, 12 insertions(+), 14 deletions(-)

diff --git a/src/cmd/compile/internal/types2/subst.go b/src/cmd/compile/internal/types2/subst.go
index e64e24a8a1..27405d8f41 100644
--- a/src/cmd/compile/internal/types2/subst.go
+++ b/src/cmd/compile/internal/types2/subst.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2018 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.
@@ -29,7 +28,7 @@ func makeSubstMap(tpars []*TypeName, targs []Type) *substMap {
 	assert(len(tpars) == len(targs))
 	proj := make(map[*TypeParam]Type, len(tpars))
 	for i, tpar := range tpars {
-		// We must expand type arguments otherwise *Instance
+		// We must expand type arguments otherwise *instance
 		// types end up as components in composite types.
 		// TODO(gri) explain why this causes problems, if it does
 		targ := expand(targs[i]) // possibly nil
@@ -71,7 +70,7 @@ func (check *Checker) instantiate(pos syntax.Pos, typ Type, targs []Type, poslis
 		}()
 	}
 
-	assert(poslist == nil || len(poslist) <= len(targs))
+	assert(len(poslist) <= len(targs))
 
 	// TODO(gri) What is better here: work with TypeParams, or work with TypeNames?
 	var tparams []*TypeName
@@ -81,9 +80,10 @@ func (check *Checker) instantiate(pos syntax.Pos, typ Type, targs []Type, poslis
 	case *Signature:
 		tparams = t.tparams
 		defer func() {
-			// If we had an unexpected failure somewhere don't
-			// panic below when asserting res.(*Signature).
-			if res == nil {
+			// If we had an unexpected failure somewhere don't panic below when
+			// asserting res.(*Signature). Check for *Signature in case Typ[Invalid]
+			// is returned.
+			if _, ok := res.(*Signature); !ok {
 				return
 			}
 			// If the signature doesn't use its type parameters, subst
@@ -153,6 +153,7 @@ func (check *Checker) instantiate(pos syntax.Pos, typ Type, targs []Type, poslis
 			if m, wrong := check.missingMethod(targ, iface, true); m != nil {
 				// TODO(gri) needs to print updated name to avoid major confusion in error message!
 				//           (print warning for now)
+				// Old warning:
 				// check.softErrorf(pos, "%s does not satisfy %s (warning: name not updated) = %s (missing method %s)", targ, tpar.bound, iface, m)
 				if m.name == "==" {
 					// We don't want to report "missing method ==".
@@ -175,7 +176,6 @@ func (check *Checker) instantiate(pos syntax.Pos, typ Type, targs []Type, poslis
 		if iface.allTypes == nil {
 			continue // nothing to do
 		}
-		// iface.allTypes != nil
 
 		// If targ is itself a type parameter, each of its possible types, but at least one, must be in the
 		// list of iface types (i.e., the targ type list must be a non-empty subset of the iface types).
@@ -278,7 +278,9 @@ func (subst *subster) typ(typ Type) Type {
 		results := subst.tuple(t.results)
 		if recv != t.recv || params != t.params || results != t.results {
 			return &Signature{
-				rparams:  t.rparams,
+				rparams: t.rparams,
+				// TODO(gri) Why can't we nil out tparams here, rather than in
+				//           instantiate above?
 				tparams:  t.tparams,
 				scope:    t.scope,
 				recv:     recv,
@@ -343,7 +345,6 @@ func (subst *subster) typ(typ Type) Type {
 		var new_targs []Type
 
 		if len(t.targs) > 0 {
-
 			// already instantiated
 			dump(">>> %s already instantiated", t)
 			assert(len(t.targs) == len(t.tparams))
@@ -367,13 +368,10 @@ func (subst *subster) typ(typ Type) Type {
 				dump(">>> nothing to substitute in %s", t)
 				return t // nothing to substitute
 			}
-
 		} else {
-
 			// not yet instantiated
 			dump(">>> first instantiation of %s", t)
 			new_targs = subst.smap.targs
-
 		}
 
 		// before creating a new named type, check if we have this one already
@@ -419,9 +417,9 @@ func (subst *subster) typ(typ Type) Type {
 func instantiatedHash(typ *Named, targs []Type) string {
 	var buf bytes.Buffer
 	writeTypeName(&buf, typ.obj, nil)
-	buf.WriteByte('(')
+	buf.WriteByte('[')
 	writeTypeList(&buf, targs, nil, nil)
-	buf.WriteByte(')')
+	buf.WriteByte(']')
 
 	// With respect to the represented type, whether a
 	// type is fully expanded or stored as instance
-- 
GitLab


From 9c5241e52020cf77683cd260a5fa3f3f029ed80c Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 7 Dec 2020 20:05:17 -0800
Subject: [PATCH 0207/2400] [dev.regabi] cmd/compile: remove unnecessary String
 methods

There were only a few places these were still used, none of which
justify generating all this code. Instead rewrite them to use
fmt.Sprint or simpler means.

Passes buildall w/ toolstash -cmp.

Change-Id: Ibd123a1696941a597f0cb4dcc96cda8ced672140
Reviewed-on: https://go-review.googlesource.com/c/go/+/276072
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/gc/const.go     |  2 +-
 src/cmd/compile/internal/gc/typecheck.go | 15 ++++---
 src/cmd/compile/internal/gc/universe.go  | 11 -----
 src/cmd/compile/internal/ir/mini.go      |  1 -
 src/cmd/compile/internal/ir/mknode.go    |  1 -
 src/cmd/compile/internal/ir/node.go      |  1 -
 src/cmd/compile/internal/ir/node_gen.go  | 56 ------------------------
 src/cmd/compile/internal/ssa/op.go       |  1 -
 test/fixedbugs/issue22822.go             |  4 +-
 9 files changed, 12 insertions(+), 80 deletions(-)

diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 80799580c6..677ed17dd9 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -887,7 +887,7 @@ func (s *constSet) add(pos src.XPos, n ir.Node, what, where string) {
 //
 // TODO(mdempsky): This could probably be a fmt.go flag.
 func nodeAndVal(n ir.Node) string {
-	show := n.String()
+	show := fmt.Sprint(n)
 	val := ir.ConstValue(n)
 	if s := fmt.Sprintf("%#v", val); show != s {
 		show += " (value " + s + ")"
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index d88989f83c..f187880e28 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -956,7 +956,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 		t := n.Left().Type()
 		if t == nil {
-			base.UpdateErrorDot(ir.Line(n), n.Left().String(), n.String())
+			base.UpdateErrorDot(ir.Line(n), fmt.Sprint(n.Left()), fmt.Sprint(n))
 			n.SetType(nil)
 			return n
 		}
@@ -1431,14 +1431,15 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		default:
 			n.SetOp(ir.OCALLFUNC)
 			if t.Kind() != types.TFUNC {
-				name := l.String()
-				if isBuiltinFuncName(name) && l.Name().Defn != nil {
-					// be more specific when the function
+				// TODO(mdempsky): Remove "o.Sym() != nil" once we stop
+				// using ir.Name for numeric literals.
+				if o := ir.Orig(l); o.Name() != nil && o.Sym() != nil && types.BuiltinPkg.Lookup(o.Sym().Name).Def != nil {
+					// be more specific when the non-function
 					// name matches a predeclared function
-					base.Errorf("cannot call non-function %s (type %v), declared at %s",
-						name, t, base.FmtPos(l.Name().Defn.Pos()))
+					base.Errorf("cannot call non-function %L, declared at %s",
+						l, base.FmtPos(o.Name().Pos()))
 				} else {
-					base.Errorf("cannot call non-function %s (type %v)", name, t)
+					base.Errorf("cannot call non-function %L", l)
 				}
 				n.SetType(nil)
 				return n
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index c592e37497..66ca0d01b3 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -65,17 +65,6 @@ var builtinFuncs = [...]struct {
 	{"recover", ir.ORECOVER},
 }
 
-// isBuiltinFuncName reports whether name matches a builtin function
-// name.
-func isBuiltinFuncName(name string) bool {
-	for _, fn := range &builtinFuncs {
-		if fn.name == name {
-			return true
-		}
-	}
-	return false
-}
-
 var unsafeFuncs = [...]struct {
 	name string
 	op   ir.Op
diff --git a/src/cmd/compile/internal/ir/mini.go b/src/cmd/compile/internal/ir/mini.go
index 7ecdcbf32f..bf221f75ed 100644
--- a/src/cmd/compile/internal/ir/mini.go
+++ b/src/cmd/compile/internal/ir/mini.go
@@ -35,7 +35,6 @@ type miniNode struct {
 	esc  uint16
 }
 
-func (n *miniNode) String() string                       { panic(1) }
 func (n *miniNode) Format(s fmt.State, verb rune)        { panic(1) }
 func (n *miniNode) copy() Node                           { panic(1) }
 func (n *miniNode) doChildren(do func(Node) error) error { panic(1) }
diff --git a/src/cmd/compile/internal/ir/mknode.go b/src/cmd/compile/internal/ir/mknode.go
index 18d768ceb1..f9b398fe28 100644
--- a/src/cmd/compile/internal/ir/mknode.go
+++ b/src/cmd/compile/internal/ir/mknode.go
@@ -65,7 +65,6 @@ func main() {
 		}
 
 		fmt.Fprintf(&buf, "\n")
-		fmt.Fprintf(&buf, "func (n *%s) String() string { return fmt.Sprint(n) }\n", name)
 		fmt.Fprintf(&buf, "func (n *%s) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }\n", name)
 
 		fmt.Fprintf(&buf, "func (n *%s) copy() Node { c := *n\n", name)
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 598659a3db..dc86b6c683 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -20,7 +20,6 @@ import (
 type Node interface {
 	// Formatting
 	Format(s fmt.State, verb rune)
-	String() string
 
 	// Source position.
 	Pos() src.XPos
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index 264171e797..39d8f03ddc 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -4,7 +4,6 @@ package ir
 
 import "fmt"
 
-func (n *AddStringExpr) String() string                { return fmt.Sprint(n) }
 func (n *AddStringExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *AddStringExpr) copy() Node {
 	c := *n
@@ -23,7 +22,6 @@ func (n *AddStringExpr) editChildren(edit func(Node) Node) {
 	editList(n.List_, edit)
 }
 
-func (n *AddrExpr) String() string                { return fmt.Sprint(n) }
 func (n *AddrExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *AddrExpr) copy() Node {
 	c := *n
@@ -43,7 +41,6 @@ func (n *AddrExpr) editChildren(edit func(Node) Node) {
 	n.Alloc = maybeEdit(n.Alloc, edit)
 }
 
-func (n *ArrayType) String() string                { return fmt.Sprint(n) }
 func (n *ArrayType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *ArrayType) copy() Node {
 	c := *n
@@ -60,7 +57,6 @@ func (n *ArrayType) editChildren(edit func(Node) Node) {
 	n.Elem = maybeEdit(n.Elem, edit)
 }
 
-func (n *AssignListStmt) String() string                { return fmt.Sprint(n) }
 func (n *AssignListStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *AssignListStmt) copy() Node {
 	c := *n
@@ -82,7 +78,6 @@ func (n *AssignListStmt) editChildren(edit func(Node) Node) {
 	editList(n.Rhs, edit)
 }
 
-func (n *AssignOpStmt) String() string                { return fmt.Sprint(n) }
 func (n *AssignOpStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *AssignOpStmt) copy() Node {
 	c := *n
@@ -102,7 +97,6 @@ func (n *AssignOpStmt) editChildren(edit func(Node) Node) {
 	n.Y = maybeEdit(n.Y, edit)
 }
 
-func (n *AssignStmt) String() string                { return fmt.Sprint(n) }
 func (n *AssignStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *AssignStmt) copy() Node {
 	c := *n
@@ -122,7 +116,6 @@ func (n *AssignStmt) editChildren(edit func(Node) Node) {
 	n.Y = maybeEdit(n.Y, edit)
 }
 
-func (n *BinaryExpr) String() string                { return fmt.Sprint(n) }
 func (n *BinaryExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *BinaryExpr) copy() Node {
 	c := *n
@@ -142,7 +135,6 @@ func (n *BinaryExpr) editChildren(edit func(Node) Node) {
 	n.Y = maybeEdit(n.Y, edit)
 }
 
-func (n *BlockStmt) String() string                { return fmt.Sprint(n) }
 func (n *BlockStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *BlockStmt) copy() Node {
 	c := *n
@@ -161,7 +153,6 @@ func (n *BlockStmt) editChildren(edit func(Node) Node) {
 	editList(n.List_, edit)
 }
 
-func (n *BranchStmt) String() string                { return fmt.Sprint(n) }
 func (n *BranchStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *BranchStmt) copy() Node {
 	c := *n
@@ -177,7 +168,6 @@ func (n *BranchStmt) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 }
 
-func (n *CallExpr) String() string                { return fmt.Sprint(n) }
 func (n *CallExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *CallExpr) copy() Node {
 	c := *n
@@ -204,7 +194,6 @@ func (n *CallExpr) editChildren(edit func(Node) Node) {
 	editList(n.Body_, edit)
 }
 
-func (n *CallPartExpr) String() string                { return fmt.Sprint(n) }
 func (n *CallPartExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *CallPartExpr) copy() Node {
 	c := *n
@@ -222,7 +211,6 @@ func (n *CallPartExpr) editChildren(edit func(Node) Node) {
 	n.X = maybeEdit(n.X, edit)
 }
 
-func (n *CaseStmt) String() string                { return fmt.Sprint(n) }
 func (n *CaseStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *CaseStmt) copy() Node {
 	c := *n
@@ -249,7 +237,6 @@ func (n *CaseStmt) editChildren(edit func(Node) Node) {
 	editList(n.Body_, edit)
 }
 
-func (n *ChanType) String() string                { return fmt.Sprint(n) }
 func (n *ChanType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *ChanType) copy() Node {
 	c := *n
@@ -264,7 +251,6 @@ func (n *ChanType) editChildren(edit func(Node) Node) {
 	n.Elem = maybeEdit(n.Elem, edit)
 }
 
-func (n *ClosureExpr) String() string                { return fmt.Sprint(n) }
 func (n *ClosureExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *ClosureExpr) copy() Node {
 	c := *n
@@ -280,7 +266,6 @@ func (n *ClosureExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 }
 
-func (n *ClosureReadExpr) String() string                { return fmt.Sprint(n) }
 func (n *ClosureReadExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *ClosureReadExpr) copy() Node {
 	c := *n
@@ -296,7 +281,6 @@ func (n *ClosureReadExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 }
 
-func (n *CompLitExpr) String() string                { return fmt.Sprint(n) }
 func (n *CompLitExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *CompLitExpr) copy() Node {
 	c := *n
@@ -317,7 +301,6 @@ func (n *CompLitExpr) editChildren(edit func(Node) Node) {
 	editList(n.List_, edit)
 }
 
-func (n *ConstExpr) String() string                { return fmt.Sprint(n) }
 func (n *ConstExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *ConstExpr) copy() Node {
 	c := *n
@@ -333,7 +316,6 @@ func (n *ConstExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 }
 
-func (n *ConvExpr) String() string                { return fmt.Sprint(n) }
 func (n *ConvExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *ConvExpr) copy() Node {
 	c := *n
@@ -351,7 +333,6 @@ func (n *ConvExpr) editChildren(edit func(Node) Node) {
 	n.X = maybeEdit(n.X, edit)
 }
 
-func (n *Decl) String() string                { return fmt.Sprint(n) }
 func (n *Decl) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *Decl) copy() Node {
 	c := *n
@@ -366,7 +347,6 @@ func (n *Decl) editChildren(edit func(Node) Node) {
 	n.X = maybeEdit(n.X, edit)
 }
 
-func (n *ForStmt) String() string                { return fmt.Sprint(n) }
 func (n *ForStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *ForStmt) copy() Node {
 	c := *n
@@ -392,7 +372,6 @@ func (n *ForStmt) editChildren(edit func(Node) Node) {
 	editList(n.Body_, edit)
 }
 
-func (n *Func) String() string                { return fmt.Sprint(n) }
 func (n *Func) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *Func) copy() Node {
 	c := *n
@@ -408,7 +387,6 @@ func (n *Func) editChildren(edit func(Node) Node) {
 	editList(n.Body_, edit)
 }
 
-func (n *FuncType) String() string                { return fmt.Sprint(n) }
 func (n *FuncType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *FuncType) copy() Node {
 	c := *n
@@ -432,7 +410,6 @@ func (n *FuncType) editChildren(edit func(Node) Node) {
 	editFields(n.Results, edit)
 }
 
-func (n *GoDeferStmt) String() string                { return fmt.Sprint(n) }
 func (n *GoDeferStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *GoDeferStmt) copy() Node {
 	c := *n
@@ -450,7 +427,6 @@ func (n *GoDeferStmt) editChildren(edit func(Node) Node) {
 	n.Call = maybeEdit(n.Call, edit)
 }
 
-func (n *Ident) String() string                { return fmt.Sprint(n) }
 func (n *Ident) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *Ident) copy() Node {
 	c := *n
@@ -466,7 +442,6 @@ func (n *Ident) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 }
 
-func (n *IfStmt) String() string                { return fmt.Sprint(n) }
 func (n *IfStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *IfStmt) copy() Node {
 	c := *n
@@ -490,7 +465,6 @@ func (n *IfStmt) editChildren(edit func(Node) Node) {
 	editList(n.Else, edit)
 }
 
-func (n *IndexExpr) String() string                { return fmt.Sprint(n) }
 func (n *IndexExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *IndexExpr) copy() Node {
 	c := *n
@@ -510,7 +484,6 @@ func (n *IndexExpr) editChildren(edit func(Node) Node) {
 	n.Index = maybeEdit(n.Index, edit)
 }
 
-func (n *InlineMarkStmt) String() string                { return fmt.Sprint(n) }
 func (n *InlineMarkStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *InlineMarkStmt) copy() Node {
 	c := *n
@@ -526,7 +499,6 @@ func (n *InlineMarkStmt) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 }
 
-func (n *InlinedCallExpr) String() string                { return fmt.Sprint(n) }
 func (n *InlinedCallExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *InlinedCallExpr) copy() Node {
 	c := *n
@@ -548,7 +520,6 @@ func (n *InlinedCallExpr) editChildren(edit func(Node) Node) {
 	editList(n.ReturnVars, edit)
 }
 
-func (n *InterfaceType) String() string                { return fmt.Sprint(n) }
 func (n *InterfaceType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *InterfaceType) copy() Node {
 	c := *n
@@ -564,7 +535,6 @@ func (n *InterfaceType) editChildren(edit func(Node) Node) {
 	editFields(n.Methods, edit)
 }
 
-func (n *KeyExpr) String() string                { return fmt.Sprint(n) }
 func (n *KeyExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *KeyExpr) copy() Node {
 	c := *n
@@ -584,7 +554,6 @@ func (n *KeyExpr) editChildren(edit func(Node) Node) {
 	n.Value = maybeEdit(n.Value, edit)
 }
 
-func (n *LabelStmt) String() string                { return fmt.Sprint(n) }
 func (n *LabelStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *LabelStmt) copy() Node {
 	c := *n
@@ -600,7 +569,6 @@ func (n *LabelStmt) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 }
 
-func (n *LogicalExpr) String() string                { return fmt.Sprint(n) }
 func (n *LogicalExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *LogicalExpr) copy() Node {
 	c := *n
@@ -620,7 +588,6 @@ func (n *LogicalExpr) editChildren(edit func(Node) Node) {
 	n.Y = maybeEdit(n.Y, edit)
 }
 
-func (n *MakeExpr) String() string                { return fmt.Sprint(n) }
 func (n *MakeExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *MakeExpr) copy() Node {
 	c := *n
@@ -640,7 +607,6 @@ func (n *MakeExpr) editChildren(edit func(Node) Node) {
 	n.Cap = maybeEdit(n.Cap, edit)
 }
 
-func (n *MapType) String() string                { return fmt.Sprint(n) }
 func (n *MapType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *MapType) copy() Node {
 	c := *n
@@ -657,7 +623,6 @@ func (n *MapType) editChildren(edit func(Node) Node) {
 	n.Elem = maybeEdit(n.Elem, edit)
 }
 
-func (n *MethodExpr) String() string                { return fmt.Sprint(n) }
 func (n *MethodExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *MethodExpr) copy() Node {
 	c := *n
@@ -677,7 +642,6 @@ func (n *MethodExpr) editChildren(edit func(Node) Node) {
 	n.M = maybeEdit(n.M, edit)
 }
 
-func (n *Name) String() string                { return fmt.Sprint(n) }
 func (n *Name) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *Name) copy() Node {
 	c := *n
@@ -690,7 +654,6 @@ func (n *Name) doChildren(do func(Node) error) error {
 func (n *Name) editChildren(edit func(Node) Node) {
 }
 
-func (n *NilExpr) String() string                { return fmt.Sprint(n) }
 func (n *NilExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *NilExpr) copy() Node {
 	c := *n
@@ -706,7 +669,6 @@ func (n *NilExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 }
 
-func (n *ParenExpr) String() string                { return fmt.Sprint(n) }
 func (n *ParenExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *ParenExpr) copy() Node {
 	c := *n
@@ -724,7 +686,6 @@ func (n *ParenExpr) editChildren(edit func(Node) Node) {
 	n.X = maybeEdit(n.X, edit)
 }
 
-func (n *PkgName) String() string                { return fmt.Sprint(n) }
 func (n *PkgName) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *PkgName) copy() Node {
 	c := *n
@@ -737,7 +698,6 @@ func (n *PkgName) doChildren(do func(Node) error) error {
 func (n *PkgName) editChildren(edit func(Node) Node) {
 }
 
-func (n *RangeStmt) String() string                { return fmt.Sprint(n) }
 func (n *RangeStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *RangeStmt) copy() Node {
 	c := *n
@@ -761,7 +721,6 @@ func (n *RangeStmt) editChildren(edit func(Node) Node) {
 	editList(n.Body_, edit)
 }
 
-func (n *ResultExpr) String() string                { return fmt.Sprint(n) }
 func (n *ResultExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *ResultExpr) copy() Node {
 	c := *n
@@ -777,7 +736,6 @@ func (n *ResultExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 }
 
-func (n *ReturnStmt) String() string                { return fmt.Sprint(n) }
 func (n *ReturnStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *ReturnStmt) copy() Node {
 	c := *n
@@ -796,7 +754,6 @@ func (n *ReturnStmt) editChildren(edit func(Node) Node) {
 	editList(n.Results, edit)
 }
 
-func (n *SelectStmt) String() string                { return fmt.Sprint(n) }
 func (n *SelectStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *SelectStmt) copy() Node {
 	c := *n
@@ -818,7 +775,6 @@ func (n *SelectStmt) editChildren(edit func(Node) Node) {
 	editList(n.Compiled, edit)
 }
 
-func (n *SelectorExpr) String() string                { return fmt.Sprint(n) }
 func (n *SelectorExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *SelectorExpr) copy() Node {
 	c := *n
@@ -836,7 +792,6 @@ func (n *SelectorExpr) editChildren(edit func(Node) Node) {
 	n.X = maybeEdit(n.X, edit)
 }
 
-func (n *SendStmt) String() string                { return fmt.Sprint(n) }
 func (n *SendStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *SendStmt) copy() Node {
 	c := *n
@@ -856,7 +811,6 @@ func (n *SendStmt) editChildren(edit func(Node) Node) {
 	n.Value = maybeEdit(n.Value, edit)
 }
 
-func (n *SliceExpr) String() string                { return fmt.Sprint(n) }
 func (n *SliceExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *SliceExpr) copy() Node {
 	c := *n
@@ -877,7 +831,6 @@ func (n *SliceExpr) editChildren(edit func(Node) Node) {
 	editList(n.List_, edit)
 }
 
-func (n *SliceHeaderExpr) String() string                { return fmt.Sprint(n) }
 func (n *SliceHeaderExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *SliceHeaderExpr) copy() Node {
 	c := *n
@@ -898,7 +851,6 @@ func (n *SliceHeaderExpr) editChildren(edit func(Node) Node) {
 	editList(n.LenCap_, edit)
 }
 
-func (n *SliceType) String() string                { return fmt.Sprint(n) }
 func (n *SliceType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *SliceType) copy() Node {
 	c := *n
@@ -913,7 +865,6 @@ func (n *SliceType) editChildren(edit func(Node) Node) {
 	n.Elem = maybeEdit(n.Elem, edit)
 }
 
-func (n *StarExpr) String() string                { return fmt.Sprint(n) }
 func (n *StarExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *StarExpr) copy() Node {
 	c := *n
@@ -931,7 +882,6 @@ func (n *StarExpr) editChildren(edit func(Node) Node) {
 	n.X = maybeEdit(n.X, edit)
 }
 
-func (n *StructKeyExpr) String() string                { return fmt.Sprint(n) }
 func (n *StructKeyExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *StructKeyExpr) copy() Node {
 	c := *n
@@ -949,7 +899,6 @@ func (n *StructKeyExpr) editChildren(edit func(Node) Node) {
 	n.Value = maybeEdit(n.Value, edit)
 }
 
-func (n *StructType) String() string                { return fmt.Sprint(n) }
 func (n *StructType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *StructType) copy() Node {
 	c := *n
@@ -965,7 +914,6 @@ func (n *StructType) editChildren(edit func(Node) Node) {
 	editFields(n.Fields, edit)
 }
 
-func (n *SwitchStmt) String() string                { return fmt.Sprint(n) }
 func (n *SwitchStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *SwitchStmt) copy() Node {
 	c := *n
@@ -989,7 +937,6 @@ func (n *SwitchStmt) editChildren(edit func(Node) Node) {
 	editList(n.Compiled, edit)
 }
 
-func (n *TypeAssertExpr) String() string                { return fmt.Sprint(n) }
 func (n *TypeAssertExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *TypeAssertExpr) copy() Node {
 	c := *n
@@ -1012,7 +959,6 @@ func (n *TypeAssertExpr) editChildren(edit func(Node) Node) {
 	editList(n.Itab, edit)
 }
 
-func (n *TypeSwitchGuard) String() string                { return fmt.Sprint(n) }
 func (n *TypeSwitchGuard) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *TypeSwitchGuard) copy() Node {
 	c := *n
@@ -1033,7 +979,6 @@ func (n *TypeSwitchGuard) editChildren(edit func(Node) Node) {
 	n.X = maybeEdit(n.X, edit)
 }
 
-func (n *UnaryExpr) String() string                { return fmt.Sprint(n) }
 func (n *UnaryExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *UnaryExpr) copy() Node {
 	c := *n
@@ -1051,7 +996,6 @@ func (n *UnaryExpr) editChildren(edit func(Node) Node) {
 	n.X = maybeEdit(n.X, edit)
 }
 
-func (n *typeNode) String() string                { return fmt.Sprint(n) }
 func (n *typeNode) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *typeNode) copy() Node {
 	c := *n
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index 97726a6f95..9bc5aaec02 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -248,7 +248,6 @@ const (
 //  - a *obj.LSym, for an offset from SB (the global pointer)
 //  - nil, for no offset
 type Sym interface {
-	String() string
 	CanBeAnSSASym()
 	CanBeAnSSAAux()
 }
diff --git a/test/fixedbugs/issue22822.go b/test/fixedbugs/issue22822.go
index e449ddb186..0e838cb597 100644
--- a/test/fixedbugs/issue22822.go
+++ b/test/fixedbugs/issue22822.go
@@ -12,5 +12,7 @@ package main
 func F() {
 	slice := []int{1, 2, 3}
 	len := int(2)
-	println(len(slice)) // ERROR "cannot call non-function len .type int., declared at"
+	println(len(slice)) // ERROR "cannot call non-function len .type int., declared at LINE-1"
+	const iota = 1
+	println(iota(slice)) // ERROR "cannot call non-function iota .type int., declared at LINE-1"
 }
-- 
GitLab


From 2b76429eb01ec1752f7622e3011babd7140ab870 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Tue, 24 Nov 2020 18:09:00 -0500
Subject: [PATCH 0208/2400] [dev.regabi] cmd/compile: refactor type
 initialization code into helper

Create a helper routine for initializing the types package, so as make
it easier to use in unit testing (in a follow-on patch).

Change-Id: I0f937788dfd34ac6641a4f28c16e47008aa08116
Reviewed-on: https://go-review.googlesource.com/c/go/+/273010
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Than McIntosh <thanm@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/main.go | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 503dc449d3..368fe1fcab 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -210,13 +210,7 @@ func Main(archInit func(*Arch)) {
 	// initialize types package
 	// (we need to do this to break dependencies that otherwise
 	// would lead to import cycles)
-	types.Widthptr = Widthptr
-	types.Dowidth = dowidth
-	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
-		return typenamesym(t).Linksym()
-	}
-
-	initUniverse()
+	initializeTypesPackage()
 
 	dclcontext = ir.PEXTERN
 
@@ -1125,3 +1119,13 @@ func parseLang(s string) (lang, error) {
 	}
 	return lang{major: major, minor: minor}, nil
 }
+
+func initializeTypesPackage() {
+	types.Widthptr = Widthptr
+	types.Dowidth = dowidth
+	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
+		return typenamesym(t).Linksym()
+	}
+
+	initUniverse()
+}
-- 
GitLab


From 7e17b46c58cbb0aff2b42490a73e807bb04757d7 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Wed, 2 Dec 2020 16:13:45 -0500
Subject: [PATCH 0209/2400] [dev.regabi] cmd/compile/internal/types: add
 IsScalar query method

Add method Type.IsScalar() method, which returns TRUE
for numeric and pointer-shaped types, false for composites
such as string/array/slice/struct.

Change-Id: Ie53c71c07c5b3fbae11b48addd172343dc6bf3fd
Reviewed-on: https://go-review.googlesource.com/c/go/+/274857
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Than McIntosh <thanm@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/types/type.go | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index e968a799e3..4d1d30133c 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -1335,6 +1335,20 @@ func (t *Type) IsEmptyInterface() bool {
 	return t.IsInterface() && t.NumFields() == 0
 }
 
+// IsScalar reports whether 't' is a scalar Go type, e.g.
+// bool/int/float/complex. Note that struct and array types consisting
+// of a single scalar element are not considered scalar, likewise
+// pointer types are also not considered scalar.
+func (t *Type) IsScalar() bool {
+	switch t.kind {
+	case TBOOL, TINT8, TUINT8, TINT16, TUINT16, TINT32,
+		TUINT32, TINT64, TUINT64, TINT, TUINT,
+		TUINTPTR, TCOMPLEX64, TCOMPLEX128, TFLOAT32, TFLOAT64:
+		return true
+	}
+	return false
+}
+
 func (t *Type) PtrTo() *Type {
 	return NewPtr(t)
 }
-- 
GitLab


From 8ce37e4110316030159972e17c67152e8f8e9359 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 10 Dec 2020 21:04:41 -0800
Subject: [PATCH 0210/2400] [dev.regabi] cmd/compile: fix noopt builder

The non-simple, phi-insertion algorithm can leave OpFwdRefs in the SSA
graph unresolved if they're in dead blocks. Normally, these would be
harmlessly removed later during SSA dead-code elimination, but those
passes are omitted for -N builds. And so they reach zcse, where the
Value.Aux is used within a hash map.

This became a problem after golang.org/cl/275788, which added
FwdRefAux to wrap OpFwdRef's ir.Node, and to ensure that it's not
compared for equality / used as a map key.

This CL adds a simple fix: if there are any OpFwdRefs remaining after
resolveFwdRef, then they must be dead code and we can simply replace
them with OpUnknown.

Change-Id: I72e4116d52d3f6441ebb0bf6160906617cd59513
Reviewed-on: https://go-review.googlesource.com/c/go/+/277075
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/gc/phi.go | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/cmd/compile/internal/gc/phi.go b/src/cmd/compile/internal/gc/phi.go
index def11e1be0..32c330b584 100644
--- a/src/cmd/compile/internal/gc/phi.go
+++ b/src/cmd/compile/internal/gc/phi.go
@@ -188,6 +188,11 @@ levels:
 			if v.Op == ssa.OpPhi {
 				v.AuxInt = 0
 			}
+			// Any remaining FwdRefs are dead code.
+			if v.Op == ssa.OpFwdRef {
+				v.Op = ssa.OpUnknown
+				v.Aux = nil
+			}
 		}
 	}
 }
-- 
GitLab


From 89f38323faa57d3f7475016f778be69fcffbe9fb Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Tue, 24 Nov 2020 18:10:11 -0500
Subject: [PATCH 0211/2400] [dev.regabi] cmd/compile: add register ABI analysis
 utilities

Introduce a new utility routine for analyzing a given function
signature to how its various input and output parameters will be
passed (in registers or on the stack) for a given ABI description,
along with some unit tests.

Change-Id: Id64a98a0a142e42dd9c2dc9f6607c0d827ef84fb
Reviewed-on: https://go-review.googlesource.com/c/go/+/273011
Run-TryBot: Than McIntosh <thanm@google.com>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
Trust: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/fmtmap_test.go                |   1 +
 src/cmd/compile/internal/gc/abiutils.go       | 351 ++++++++++++++++++
 src/cmd/compile/internal/gc/abiutils_test.go  | 270 ++++++++++++++
 .../compile/internal/gc/abiutilsaux_test.go   | 157 ++++++++
 4 files changed, 779 insertions(+)
 create mode 100644 src/cmd/compile/internal/gc/abiutils.go
 create mode 100644 src/cmd/compile/internal/gc/abiutils_test.go
 create mode 100644 src/cmd/compile/internal/gc/abiutilsaux_test.go

diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
index e62b9613e1..9bc059c2e4 100644
--- a/src/cmd/compile/fmtmap_test.go
+++ b/src/cmd/compile/fmtmap_test.go
@@ -36,6 +36,7 @@ var knownFormats = map[string]string{
 	"*math/big.Int %s":                             "",
 	"[]cmd/compile/internal/syntax.token %s":       "",
 	"cmd/compile/internal/arm.shift %d":            "",
+	"cmd/compile/internal/gc.RegIndex %d":          "",
 	"cmd/compile/internal/gc.initKind %d":          "",
 	"cmd/compile/internal/ir.Class %d":             "",
 	"cmd/compile/internal/ir.Node %+v":             "",
diff --git a/src/cmd/compile/internal/gc/abiutils.go b/src/cmd/compile/internal/gc/abiutils.go
new file mode 100644
index 0000000000..19de14d48c
--- /dev/null
+++ b/src/cmd/compile/internal/gc/abiutils.go
@@ -0,0 +1,351 @@
+// Copyright 2020 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 gc
+
+import (
+	"cmd/compile/internal/types"
+	"cmd/internal/src"
+	"fmt"
+	"sync"
+)
+
+//......................................................................
+//
+// Public/exported bits of the ABI utilities.
+//
+
+// ABIParamResultInfo stores the results of processing a given
+// function type to compute stack layout and register assignments. For
+// each input and output parameter we capture whether the param was
+// register-assigned (and to which register(s)) or the stack offset
+// for the param if is not going to be passed in registers according
+// to the rules in the Go internal ABI specification (1.17).
+type ABIParamResultInfo struct {
+	inparams          []ABIParamAssignment // Includes receiver for method calls.  Does NOT include hidden closure pointer.
+	outparams         []ABIParamAssignment
+	intSpillSlots     int
+	floatSpillSlots   int
+	offsetToSpillArea int64
+	config            ABIConfig // to enable String() method
+}
+
+// RegIndex stores the index into the set of machine registers used by
+// the ABI on a specific architecture for parameter passing.  RegIndex
+// values 0 through N-1 (where N is the number of integer registers
+// used for param passing according to the ABI rules) describe integer
+// registers; values N through M (where M is the number of floating
+// point registers used).  Thus if the ABI says there are 5 integer
+// registers and 7 floating point registers, then RegIndex value of 4
+// indicates the 5th integer register, and a RegIndex value of 11
+// indicates the 7th floating point register.
+type RegIndex uint8
+
+// ABIParamAssignment holds information about how a specific param or
+// result will be passed: in registers (in which case 'Registers' is
+// populated) or on the stack (in which case 'Offset' is set to a
+// non-negative stack offset. The values in 'Registers' are indices (as
+// described above), not architected registers.
+type ABIParamAssignment struct {
+	Type      *types.Type
+	Registers []RegIndex
+	Offset    int32
+}
+
+// RegAmounts holds a specified number of integer/float registers.
+type RegAmounts struct {
+	intRegs   int
+	floatRegs int
+}
+
+// ABIConfig captures the number of registers made available
+// by the ABI rules for parameter passing and result returning.
+type ABIConfig struct {
+	// Do we need anything more than this?
+	regAmounts RegAmounts
+}
+
+// ABIAnalyze takes a function type 't' and an ABI rules description
+// 'config' and analyzes the function to determine how its parameters
+// and results will be passed (in registers or on the stack), returning
+// an ABIParamResultInfo object that holds the results of the analysis.
+func ABIAnalyze(t *types.Type, config ABIConfig) ABIParamResultInfo {
+	setup()
+	s := assignState{
+		rTotal: config.regAmounts,
+	}
+	result := ABIParamResultInfo{config: config}
+
+	// Receiver
+	ft := t.FuncType()
+	if t.NumRecvs() != 0 {
+		rfsl := ft.Receiver.FieldSlice()
+		result.inparams = append(result.inparams,
+			s.assignParamOrReturn(rfsl[0].Type))
+	}
+
+	// Inputs
+	ifsl := ft.Params.FieldSlice()
+	for _, f := range ifsl {
+		result.inparams = append(result.inparams,
+			s.assignParamOrReturn(f.Type))
+	}
+	s.stackOffset = Rnd(s.stackOffset, int64(Widthreg))
+
+	// Record number of spill slots needed.
+	result.intSpillSlots = s.rUsed.intRegs
+	result.floatSpillSlots = s.rUsed.floatRegs
+
+	// Outputs
+	s.rUsed = RegAmounts{}
+	ofsl := ft.Results.FieldSlice()
+	for _, f := range ofsl {
+		result.outparams = append(result.outparams, s.assignParamOrReturn(f.Type))
+	}
+	result.offsetToSpillArea = s.stackOffset
+
+	return result
+}
+
+//......................................................................
+//
+// Non-public portions.
+
+// regString produces a human-readable version of a RegIndex.
+func (c *RegAmounts) regString(r RegIndex) string {
+	if int(r) < c.intRegs {
+		return fmt.Sprintf("I%d", int(r))
+	} else if int(r) < c.intRegs+c.floatRegs {
+		return fmt.Sprintf("F%d", int(r)-c.intRegs)
+	}
+	return fmt.Sprintf("<?>%d", r)
+}
+
+// toString method renders an ABIParamAssignment in human-readable
+// form, suitable for debugging or unit testing.
+func (ri *ABIParamAssignment) toString(config ABIConfig) string {
+	regs := "R{"
+	for _, r := range ri.Registers {
+		regs += " " + config.regAmounts.regString(r)
+	}
+	return fmt.Sprintf("%s } offset: %d typ: %v", regs, ri.Offset, ri.Type)
+}
+
+// toString method renders an ABIParamResultInfo in human-readable
+// form, suitable for debugging or unit testing.
+func (ri *ABIParamResultInfo) String() string {
+	res := ""
+	for k, p := range ri.inparams {
+		res += fmt.Sprintf("IN %d: %s\n", k, p.toString(ri.config))
+	}
+	for k, r := range ri.outparams {
+		res += fmt.Sprintf("OUT %d: %s\n", k, r.toString(ri.config))
+	}
+	res += fmt.Sprintf("intspill: %d floatspill: %d offsetToSpillArea: %d",
+		ri.intSpillSlots, ri.floatSpillSlots, ri.offsetToSpillArea)
+	return res
+}
+
+// assignState holds intermediate state during the register assigning process
+// for a given function signature.
+type assignState struct {
+	rTotal      RegAmounts // total reg amounts from ABI rules
+	rUsed       RegAmounts // regs used by params completely assigned so far
+	pUsed       RegAmounts // regs used by the current param (or pieces therein)
+	stackOffset int64      // current stack offset
+}
+
+// stackSlot returns a stack offset for a param or result of the
+// specified type.
+func (state *assignState) stackSlot(t *types.Type) int64 {
+	if t.Align > 0 {
+		state.stackOffset = Rnd(state.stackOffset, int64(t.Align))
+	}
+	rv := state.stackOffset
+	state.stackOffset += t.Width
+	return rv
+}
+
+// allocateRegs returns a set of register indices for a parameter or result
+// that we've just determined to be register-assignable. The number of registers
+// needed is assumed to be stored in state.pUsed.
+func (state *assignState) allocateRegs() []RegIndex {
+	regs := []RegIndex{}
+
+	// integer
+	for r := state.rUsed.intRegs; r < state.rUsed.intRegs+state.pUsed.intRegs; r++ {
+		regs = append(regs, RegIndex(r))
+	}
+	state.rUsed.intRegs += state.pUsed.intRegs
+
+	// floating
+	for r := state.rUsed.floatRegs; r < state.rUsed.floatRegs+state.pUsed.floatRegs; r++ {
+		regs = append(regs, RegIndex(r+state.rTotal.intRegs))
+	}
+	state.rUsed.floatRegs += state.pUsed.floatRegs
+
+	return regs
+}
+
+// regAllocate creates a register ABIParamAssignment object for a param
+// or result with the specified type, as a final step (this assumes
+// that all of the safety/suitability analysis is complete).
+func (state *assignState) regAllocate(t *types.Type) ABIParamAssignment {
+	return ABIParamAssignment{
+		Type:      t,
+		Registers: state.allocateRegs(),
+		Offset:    -1,
+	}
+}
+
+// stackAllocate creates a stack memory ABIParamAssignment object for
+// a param or result with the specified type, as a final step (this
+// assumes that all of the safety/suitability analysis is complete).
+func (state *assignState) stackAllocate(t *types.Type) ABIParamAssignment {
+	return ABIParamAssignment{
+		Type:   t,
+		Offset: int32(state.stackSlot(t)),
+	}
+}
+
+// intUsed returns the number of integer registers consumed
+// at a given point within an assignment stage.
+func (state *assignState) intUsed() int {
+	return state.rUsed.intRegs + state.pUsed.intRegs
+}
+
+// floatUsed returns the number of floating point registers consumed at
+// a given point within an assignment stage.
+func (state *assignState) floatUsed() int {
+	return state.rUsed.floatRegs + state.pUsed.floatRegs
+}
+
+// regassignIntegral examines a param/result of integral type 't' to
+// determines whether it can be register-assigned. Returns TRUE if we
+// can register allocate, FALSE otherwise (and updates state
+// accordingly).
+func (state *assignState) regassignIntegral(t *types.Type) bool {
+	regsNeeded := int(Rnd(t.Width, int64(Widthptr)) / int64(Widthptr))
+
+	// Floating point and complex.
+	if t.IsFloat() || t.IsComplex() {
+		if regsNeeded+state.floatUsed() > state.rTotal.floatRegs {
+			// not enough regs
+			return false
+		}
+		state.pUsed.floatRegs += regsNeeded
+		return true
+	}
+
+	// Non-floating point
+	if regsNeeded+state.intUsed() > state.rTotal.intRegs {
+		// not enough regs
+		return false
+	}
+	state.pUsed.intRegs += regsNeeded
+	return true
+}
+
+// regassignArray processes an array type (or array component within some
+// other enclosing type) to determine if it can be register assigned.
+// Returns TRUE if we can register allocate, FALSE otherwise.
+func (state *assignState) regassignArray(t *types.Type) bool {
+
+	nel := t.NumElem()
+	if nel == 0 {
+		return true
+	}
+	if nel > 1 {
+		// Not an array of length 1: stack assign
+		return false
+	}
+	// Visit element
+	return state.regassign(t.Elem())
+}
+
+// regassignStruct processes a struct type (or struct component within
+// some other enclosing type) to determine if it can be register
+// assigned. Returns TRUE if we can register allocate, FALSE otherwise.
+func (state *assignState) regassignStruct(t *types.Type) bool {
+	for _, field := range t.FieldSlice() {
+		if !state.regassign(field.Type) {
+			return false
+		}
+	}
+	return true
+}
+
+// synthOnce ensures that we only create the synth* fake types once.
+var synthOnce sync.Once
+
+// synthSlice, synthString, and syncIface are synthesized struct types
+// meant to capture the underlying implementations of string/slice/interface.
+var synthSlice *types.Type
+var synthString *types.Type
+var synthIface *types.Type
+
+// setup performs setup for the register assignment utilities, manufacturing
+// a small set of synthesized types that we'll need along the way.
+func setup() {
+	synthOnce.Do(func() {
+		fname := types.BuiltinPkg.Lookup
+		nxp := src.NoXPos
+		unsp := types.Types[types.TUNSAFEPTR]
+		ui := types.Types[types.TUINTPTR]
+		synthSlice = types.NewStruct(types.NoPkg, []*types.Field{
+			types.NewField(nxp, fname("ptr"), unsp),
+			types.NewField(nxp, fname("len"), ui),
+			types.NewField(nxp, fname("cap"), ui),
+		})
+		synthString = types.NewStruct(types.NoPkg, []*types.Field{
+			types.NewField(nxp, fname("data"), unsp),
+			types.NewField(nxp, fname("len"), ui),
+		})
+		synthIface = types.NewStruct(types.NoPkg, []*types.Field{
+			types.NewField(nxp, fname("f1"), unsp),
+			types.NewField(nxp, fname("f2"), unsp),
+		})
+	})
+}
+
+// regassign examines a given param type (or component within some
+// composite) to determine if it can be register assigned.  Returns
+// TRUE if we can register allocate, FALSE otherwise.
+func (state *assignState) regassign(pt *types.Type) bool {
+	typ := pt.Kind()
+	if pt.IsScalar() || pt.IsPtrShaped() {
+		return state.regassignIntegral(pt)
+	}
+	switch typ {
+	case types.TARRAY:
+		return state.regassignArray(pt)
+	case types.TSTRUCT:
+		return state.regassignStruct(pt)
+	case types.TSLICE:
+		return state.regassignStruct(synthSlice)
+	case types.TSTRING:
+		return state.regassignStruct(synthString)
+	case types.TINTER:
+		return state.regassignStruct(synthIface)
+	default:
+		panic("not expected")
+	}
+}
+
+// assignParamOrReturn processes a given receiver, param, or result
+// of type 'pt' to determine whether it can be register assigned.
+// The result of the analysis is recorded in the result
+// ABIParamResultInfo held in 'state'.
+func (state *assignState) assignParamOrReturn(pt *types.Type) ABIParamAssignment {
+	state.pUsed = RegAmounts{}
+	if pt.Width == types.BADWIDTH {
+		panic("should never happen")
+	} else if pt.Width == 0 {
+		return state.stackAllocate(pt)
+	} else if state.regassign(pt) {
+		return state.regAllocate(pt)
+	} else {
+		return state.stackAllocate(pt)
+	}
+}
diff --git a/src/cmd/compile/internal/gc/abiutils_test.go b/src/cmd/compile/internal/gc/abiutils_test.go
new file mode 100644
index 0000000000..16bd787bea
--- /dev/null
+++ b/src/cmd/compile/internal/gc/abiutils_test.go
@@ -0,0 +1,270 @@
+// Copyright 2020 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 gc
+
+import (
+	"bufio"
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/types"
+	"cmd/internal/obj"
+	"cmd/internal/obj/x86"
+	"cmd/internal/src"
+	"os"
+	"testing"
+)
+
+// AMD64 registers available:
+// - integer: RAX, RBX, RCX, RDI, RSI, R8, R9, r10, R11
+// - floating point: X0 - X14
+var configAMD64 = ABIConfig{
+	regAmounts: RegAmounts{
+		intRegs:   9,
+		floatRegs: 15,
+	},
+}
+
+func TestMain(m *testing.M) {
+	thearch.LinkArch = &x86.Linkamd64
+	thearch.REGSP = x86.REGSP
+	thearch.MAXWIDTH = 1 << 50
+	base.Ctxt = obj.Linknew(thearch.LinkArch)
+	base.Ctxt.DiagFunc = base.Errorf
+	base.Ctxt.DiagFlush = base.FlushErrors
+	base.Ctxt.Bso = bufio.NewWriter(os.Stdout)
+	Widthptr = thearch.LinkArch.PtrSize
+	Widthreg = thearch.LinkArch.RegSize
+	initializeTypesPackage()
+	os.Exit(m.Run())
+}
+
+func TestABIUtilsBasic1(t *testing.T) {
+
+	// func(x int32) int32
+	i32 := types.Types[types.TINT32]
+	ft := mkFuncType(nil, []*types.Type{i32}, []*types.Type{i32})
+
+	// expected results
+	exp := makeExpectedDump(`
+		IN 0: R{ I0 } offset: -1 typ: int32
+		OUT 0: R{ I0 } offset: -1 typ: int32
+		intspill: 1 floatspill: 0 offsetToSpillArea: 0
+`)
+
+	abitest(t, ft, exp)
+}
+
+func TestABIUtilsBasic2(t *testing.T) {
+	// func(x int32, y float64) (int32, float64, float64)
+	i8 := types.Types[types.TINT8]
+	i16 := types.Types[types.TINT16]
+	i32 := types.Types[types.TINT32]
+	i64 := types.Types[types.TINT64]
+	f32 := types.Types[types.TFLOAT32]
+	f64 := types.Types[types.TFLOAT64]
+	c64 := types.Types[types.TCOMPLEX64]
+	c128 := types.Types[types.TCOMPLEX128]
+	ft := mkFuncType(nil,
+		[]*types.Type{
+			i8, i16, i32, i64,
+			f32, f32, f64, f64,
+			i8, i16, i32, i64,
+			f32, f32, f64, f64,
+			c128, c128, c128, c128, c64,
+			i8, i16, i32, i64,
+			i8, i16, i32, i64},
+		[]*types.Type{i32, f64, f64})
+	exp := makeExpectedDump(`
+		IN 0: R{ I0 } offset: -1 typ: int8
+		IN 1: R{ I1 } offset: -1 typ: int16
+		IN 2: R{ I2 } offset: -1 typ: int32
+		IN 3: R{ I3 } offset: -1 typ: int64
+		IN 4: R{ F0 } offset: -1 typ: float32
+		IN 5: R{ F1 } offset: -1 typ: float32
+		IN 6: R{ F2 } offset: -1 typ: float64
+		IN 7: R{ F3 } offset: -1 typ: float64
+		IN 8: R{ I4 } offset: -1 typ: int8
+		IN 9: R{ I5 } offset: -1 typ: int16
+		IN 10: R{ I6 } offset: -1 typ: int32
+		IN 11: R{ I7 } offset: -1 typ: int64
+		IN 12: R{ F4 } offset: -1 typ: float32
+		IN 13: R{ F5 } offset: -1 typ: float32
+		IN 14: R{ F6 } offset: -1 typ: float64
+		IN 15: R{ F7 } offset: -1 typ: float64
+		IN 16: R{ F8 F9 } offset: -1 typ: complex128
+		IN 17: R{ F10 F11 } offset: -1 typ: complex128
+		IN 18: R{ F12 F13 } offset: -1 typ: complex128
+		IN 19: R{ } offset: 0 typ: complex128
+		IN 20: R{ F14 } offset: -1 typ: complex64
+		IN 21: R{ I8 } offset: -1 typ: int8
+		IN 22: R{ } offset: 16 typ: int16
+		IN 23: R{ } offset: 20 typ: int32
+		IN 24: R{ } offset: 24 typ: int64
+		IN 25: R{ } offset: 32 typ: int8
+		IN 26: R{ } offset: 34 typ: int16
+		IN 27: R{ } offset: 36 typ: int32
+		IN 28: R{ } offset: 40 typ: int64
+		OUT 0: R{ I0 } offset: -1 typ: int32
+		OUT 1: R{ F0 } offset: -1 typ: float64
+		OUT 2: R{ F1 } offset: -1 typ: float64
+		intspill: 9 floatspill: 15 offsetToSpillArea: 48
+`)
+
+	abitest(t, ft, exp)
+}
+
+func TestABIUtilsArrays(t *testing.T) {
+	i32 := types.Types[types.TINT32]
+	ae := types.NewArray(i32, 0)
+	a1 := types.NewArray(i32, 1)
+	a2 := types.NewArray(i32, 2)
+	aa1 := types.NewArray(a1, 1)
+	ft := mkFuncType(nil, []*types.Type{a1, ae, aa1, a2},
+		[]*types.Type{a2, a1, ae, aa1})
+
+	exp := makeExpectedDump(`
+		IN 0: R{ I0 } offset: -1 typ: [1]int32
+		IN 1: R{ } offset: 0 typ: [0]int32
+		IN 2: R{ I1 } offset: -1 typ: [1][1]int32
+		IN 3: R{ } offset: 0 typ: [2]int32
+		OUT 0: R{ } offset: 8 typ: [2]int32
+		OUT 1: R{ I0 } offset: -1 typ: [1]int32
+		OUT 2: R{ } offset: 16 typ: [0]int32
+		OUT 3: R{ I1 } offset: -1 typ: [1][1]int32
+		intspill: 2 floatspill: 0 offsetToSpillArea: 16
+`)
+
+	abitest(t, ft, exp)
+}
+
+func TestABIUtilsStruct1(t *testing.T) {
+	i8 := types.Types[types.TINT8]
+	i16 := types.Types[types.TINT16]
+	i32 := types.Types[types.TINT32]
+	i64 := types.Types[types.TINT64]
+	s := mkstruct([]*types.Type{i8, i8, mkstruct([]*types.Type{}), i8, i16})
+	ft := mkFuncType(nil, []*types.Type{i8, s, i64},
+		[]*types.Type{s, i8, i32})
+
+	exp := makeExpectedDump(`
+		IN 0: R{ I0 } offset: -1 typ: int8
+		IN 1: R{ I1 I2 I3 I4 } offset: -1 typ: struct { int8; int8; struct {}; int8; int16 }
+		IN 2: R{ I5 } offset: -1 typ: int64
+		OUT 0: R{ I0 I1 I2 I3 } offset: -1 typ: struct { int8; int8; struct {}; int8; int16 }
+		OUT 1: R{ I4 } offset: -1 typ: int8
+		OUT 2: R{ I5 } offset: -1 typ: int32
+		intspill: 6 floatspill: 0 offsetToSpillArea: 0
+`)
+
+	abitest(t, ft, exp)
+}
+
+func TestABIUtilsStruct2(t *testing.T) {
+	f64 := types.Types[types.TFLOAT64]
+	i64 := types.Types[types.TINT64]
+	s := mkstruct([]*types.Type{i64, mkstruct([]*types.Type{})})
+	fs := mkstruct([]*types.Type{f64, s, mkstruct([]*types.Type{})})
+	ft := mkFuncType(nil, []*types.Type{s, s, fs},
+		[]*types.Type{fs, fs})
+
+	exp := makeExpectedDump(`
+		IN 0: R{ I0 } offset: -1 typ: struct { int64; struct {} }
+		IN 1: R{ I1 } offset: -1 typ: struct { int64; struct {} }
+		IN 2: R{ I2 F0 } offset: -1 typ: struct { float64; struct { int64; struct {} }; struct {} }
+		OUT 0: R{ I0 F0 } offset: -1 typ: struct { float64; struct { int64; struct {} }; struct {} }
+		OUT 1: R{ I1 F1 } offset: -1 typ: struct { float64; struct { int64; struct {} }; struct {} }
+		intspill: 3 floatspill: 1 offsetToSpillArea: 0
+`)
+
+	abitest(t, ft, exp)
+}
+
+func TestABIUtilsSliceString(t *testing.T) {
+	i32 := types.Types[types.TINT32]
+	sli32 := types.NewSlice(i32)
+	str := types.New(types.TSTRING)
+	i8 := types.Types[types.TINT8]
+	i64 := types.Types[types.TINT64]
+	ft := mkFuncType(nil, []*types.Type{sli32, i8, sli32, i8, str, i8, i64, sli32},
+		[]*types.Type{str, i64, str, sli32})
+
+	exp := makeExpectedDump(`
+		IN 0: R{ I0 I1 I2 } offset: -1 typ: []int32
+		IN 1: R{ I3 } offset: -1 typ: int8
+		IN 2: R{ I4 I5 I6 } offset: -1 typ: []int32
+		IN 3: R{ I7 } offset: -1 typ: int8
+		IN 4: R{ } offset: 0 typ: string
+		IN 5: R{ I8 } offset: -1 typ: int8
+		IN 6: R{ } offset: 16 typ: int64
+		IN 7: R{ } offset: 24 typ: []int32
+		OUT 0: R{ I0 I1 } offset: -1 typ: string
+		OUT 1: R{ I2 } offset: -1 typ: int64
+		OUT 2: R{ I3 I4 } offset: -1 typ: string
+		OUT 3: R{ I5 I6 I7 } offset: -1 typ: []int32
+		intspill: 9 floatspill: 0 offsetToSpillArea: 48
+`)
+
+	abitest(t, ft, exp)
+}
+
+func TestABIUtilsMethod(t *testing.T) {
+	i16 := types.Types[types.TINT16]
+	i64 := types.Types[types.TINT64]
+	f64 := types.Types[types.TFLOAT64]
+
+	s1 := mkstruct([]*types.Type{i16, i16, i16})
+	ps1 := types.NewPtr(s1)
+	a7 := types.NewArray(ps1, 7)
+	ft := mkFuncType(s1, []*types.Type{ps1, a7, f64, i16, i16, i16},
+		[]*types.Type{a7, f64, i64})
+
+	exp := makeExpectedDump(`
+		IN 0: R{ I0 I1 I2 } offset: -1 typ: struct { int16; int16; int16 }
+		IN 1: R{ I3 } offset: -1 typ: *struct { int16; int16; int16 }
+		IN 2: R{ } offset: 0 typ: [7]*struct { int16; int16; int16 }
+		IN 3: R{ F0 } offset: -1 typ: float64
+		IN 4: R{ I4 } offset: -1 typ: int16
+		IN 5: R{ I5 } offset: -1 typ: int16
+		IN 6: R{ I6 } offset: -1 typ: int16
+		OUT 0: R{ } offset: 56 typ: [7]*struct { int16; int16; int16 }
+		OUT 1: R{ F0 } offset: -1 typ: float64
+		OUT 2: R{ I0 } offset: -1 typ: int64
+		intspill: 7 floatspill: 1 offsetToSpillArea: 112
+`)
+
+	abitest(t, ft, exp)
+}
+
+func TestABIUtilsInterfaces(t *testing.T) {
+	ei := types.Types[types.TINTER] // interface{}
+	pei := types.NewPtr(ei)         // *interface{}
+	fldt := mkFuncType(types.FakeRecvType(), []*types.Type{},
+		[]*types.Type{types.UntypedString})
+	field := types.NewField(src.NoXPos, nil, fldt)
+	// interface{ ...() string }
+	nei := types.NewInterface(types.LocalPkg, []*types.Field{field})
+
+	i16 := types.Types[types.TINT16]
+	tb := types.Types[types.TBOOL]
+	s1 := mkstruct([]*types.Type{i16, i16, tb})
+
+	ft := mkFuncType(nil, []*types.Type{s1, ei, ei, nei, pei, nei, i16},
+		[]*types.Type{ei, nei, pei})
+
+	exp := makeExpectedDump(`
+		IN 0: R{ I0 I1 I2 } offset: -1 typ: struct { int16; int16; bool }
+		IN 1: R{ I3 I4 } offset: -1 typ: interface {}
+		IN 2: R{ I5 I6 } offset: -1 typ: interface {}
+		IN 3: R{ I7 I8 } offset: -1 typ: interface { () untyped string }
+		IN 4: R{ } offset: 0 typ: *interface {}
+		IN 5: R{ } offset: 8 typ: interface { () untyped string }
+		IN 6: R{ } offset: 24 typ: int16
+		OUT 0: R{ I0 I1 } offset: -1 typ: interface {}
+		OUT 1: R{ I2 I3 } offset: -1 typ: interface { () untyped string }
+		OUT 2: R{ I4 } offset: -1 typ: *interface {}
+		intspill: 9 floatspill: 0 offsetToSpillArea: 32
+`)
+
+	abitest(t, ft, exp)
+}
diff --git a/src/cmd/compile/internal/gc/abiutilsaux_test.go b/src/cmd/compile/internal/gc/abiutilsaux_test.go
new file mode 100644
index 0000000000..d90d1d45a0
--- /dev/null
+++ b/src/cmd/compile/internal/gc/abiutilsaux_test.go
@@ -0,0 +1,157 @@
+// Copyright 2020 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 gc
+
+// This file contains utility routines and harness infrastructure used
+// by the ABI tests in "abiutils_test.go".
+
+import (
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
+	"cmd/internal/src"
+	"fmt"
+	"strings"
+	"testing"
+	"text/scanner"
+)
+
+func mkParamResultField(t *types.Type, s *types.Sym, which ir.Class) *types.Field {
+	field := types.NewField(src.NoXPos, s, t)
+	n := NewName(s)
+	n.SetClass(which)
+	field.Nname = n
+	n.SetType(t)
+	return field
+}
+
+// mkstruct is a helper routine to create a struct type with fields
+// of the types specified in 'fieldtypes'.
+func mkstruct(fieldtypes []*types.Type) *types.Type {
+	fields := make([]*types.Field, len(fieldtypes))
+	for k, t := range fieldtypes {
+		if t == nil {
+			panic("bad -- field has no type")
+		}
+		f := types.NewField(src.NoXPos, nil, t)
+		fields[k] = f
+	}
+	s := types.NewStruct(types.LocalPkg, fields)
+	return s
+}
+
+func mkFuncType(rcvr *types.Type, ins []*types.Type, outs []*types.Type) *types.Type {
+	q := lookup("?")
+	inf := []*types.Field{}
+	for _, it := range ins {
+		inf = append(inf, mkParamResultField(it, q, ir.PPARAM))
+	}
+	outf := []*types.Field{}
+	for _, ot := range outs {
+		outf = append(outf, mkParamResultField(ot, q, ir.PPARAMOUT))
+	}
+	var rf *types.Field
+	if rcvr != nil {
+		rf = mkParamResultField(rcvr, q, ir.PPARAM)
+	}
+	return types.NewSignature(types.LocalPkg, rf, inf, outf)
+}
+
+type expectedDump struct {
+	dump string
+	file string
+	line int
+}
+
+func tokenize(src string) []string {
+	var s scanner.Scanner
+	s.Init(strings.NewReader(src))
+	res := []string{}
+	for tok := s.Scan(); tok != scanner.EOF; tok = s.Scan() {
+		res = append(res, s.TokenText())
+	}
+	return res
+}
+
+func verifyParamResultOffset(t *testing.T, f *types.Field, r ABIParamAssignment, which string, idx int) int {
+	n := ir.AsNode(f.Nname)
+	if n == nil {
+		panic("not expected")
+	}
+	if n.Offset() != int64(r.Offset) {
+		t.Errorf("%s %d: got offset %d wanted %d t=%v",
+			which, idx, r.Offset, n.Offset(), f.Type)
+		return 1
+	}
+	return 0
+}
+
+func makeExpectedDump(e string) expectedDump {
+	return expectedDump{dump: e}
+}
+
+func difftokens(atoks []string, etoks []string) string {
+	if len(atoks) != len(etoks) {
+		return fmt.Sprintf("expected %d tokens got %d",
+			len(etoks), len(atoks))
+	}
+	for i := 0; i < len(etoks); i++ {
+		if etoks[i] == atoks[i] {
+			continue
+		}
+
+		return fmt.Sprintf("diff at token %d: expected %q got %q",
+			i, etoks[i], atoks[i])
+	}
+	return ""
+}
+
+func abitest(t *testing.T, ft *types.Type, exp expectedDump) {
+
+	dowidth(ft)
+
+	// Analyze with full set of registers.
+	regRes := ABIAnalyze(ft, configAMD64)
+	regResString := strings.TrimSpace(regRes.String())
+
+	// Check results.
+	reason := difftokens(tokenize(regResString), tokenize(exp.dump))
+	if reason != "" {
+		t.Errorf("\nexpected:\n%s\ngot:\n%s\nreason: %s",
+			strings.TrimSpace(exp.dump), regResString, reason)
+	}
+
+	// Analyze again with empty register set.
+	empty := ABIConfig{}
+	emptyRes := ABIAnalyze(ft, empty)
+	emptyResString := emptyRes.String()
+
+	// Walk the results and make sure the offsets assigned match
+	// up with those assiged by dowidth. This checks to make sure that
+	// when we have no available registers the ABI assignment degenerates
+	// back to the original ABI0.
+
+	// receiver
+	failed := 0
+	rfsl := ft.Recvs().Fields().Slice()
+	poff := 0
+	if len(rfsl) != 0 {
+		failed |= verifyParamResultOffset(t, rfsl[0], emptyRes.inparams[0], "receiver", 0)
+		poff = 1
+	}
+	// params
+	pfsl := ft.Params().Fields().Slice()
+	for k, f := range pfsl {
+		verifyParamResultOffset(t, f, emptyRes.inparams[k+poff], "param", k)
+	}
+	// results
+	ofsl := ft.Results().Fields().Slice()
+	for k, f := range ofsl {
+		failed |= verifyParamResultOffset(t, f, emptyRes.outparams[k], "result", k)
+	}
+
+	if failed != 0 {
+		t.Logf("emptyres:\n%s\n", emptyResString)
+	}
+}
-- 
GitLab


From df58f3368e62fbc290b419f0b33b97a984b9ca19 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 9 Dec 2020 19:15:15 -0800
Subject: [PATCH 0212/2400] [dev.typeparams] cmd/compile/internal/types2: don't
 report two errors for bad strings

If the parser reported an error for (string) literals, don't report
a second error during type checking.

This should have a couple of tests but they are tricky to arrange
with the current testing framework as the ERROR comment cannot be
on the line where the string. But the change is straightforward
and we have test/fixedbugs/issue32133.go that is passing now.

Change-Id: I0cd7f002b04e4092b8eb66009c7413288c8bfb23
Reviewed-on: https://go-review.googlesource.com/c/go/+/277993
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/types2/expr.go     | 2 +-
 src/cmd/compile/internal/types2/resolver.go | 3 +++
 src/cmd/compile/internal/types2/typexpr.go  | 3 ++-
 test/run.go                                 | 3 +--
 4 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 252d4814cc..34cbefc864 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -1188,7 +1188,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 
 	case *syntax.BasicLit:
 		if e.Bad {
-			goto Error // error was reported before
+			goto Error // error reported during parsing
 		}
 		x.setConst(e.Kind, e.Value)
 		if x.mode == invalid {
diff --git a/src/cmd/compile/internal/types2/resolver.go b/src/cmd/compile/internal/types2/resolver.go
index 5cd0a3e198..b57b41e2b0 100644
--- a/src/cmd/compile/internal/types2/resolver.go
+++ b/src/cmd/compile/internal/types2/resolver.go
@@ -236,6 +236,9 @@ func (check *Checker) collectObjects() {
 			switch s := decl.(type) {
 			case *syntax.ImportDecl:
 				// import package
+				if s.Path.Bad {
+					continue // error reported during parsing
+				}
 				path, err := validatedImportPath(s.Path.Value)
 				if err != nil {
 					check.errorf(s.Path, "invalid import path (%s)", err)
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 39bb3a6b14..22df01b3be 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -1045,7 +1045,8 @@ func (a byUniqueMethodName) Less(i, j int) bool { return a[i].Id() < a[j].Id() }
 func (a byUniqueMethodName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
 
 func (check *Checker) tag(t *syntax.BasicLit) string {
-	if t != nil {
+	// If t.Bad, an error was reported during parsing.
+	if t != nil && !t.Bad {
 		if t.Kind == syntax.StringLit {
 			if val, err := strconv.Unquote(t.Value); err == nil {
 				return val
diff --git a/test/run.go b/test/run.go
index 91bdd629bf..b6c9d6050c 100644
--- a/test/run.go
+++ b/test/run.go
@@ -2014,7 +2014,6 @@ var excluded = map[string]bool{
 	"fixedbugs/issue28079b.go": true, // types2 reports follow-on errors
 	"fixedbugs/issue28268.go":  true, // types2 reports follow-on errors
 	"fixedbugs/issue31747.go":  true, // types2 is missing support for -lang flag
-	"fixedbugs/issue32133.go":  true, // types2 line numbers off?
 	"fixedbugs/issue33460.go":  true, // types2 reports alternative positions in separate error
 	"fixedbugs/issue34329.go":  true, // types2 is missing support for -lang flag
 	"fixedbugs/issue41575.go":  true, // types2 reports alternative positions in separate error
@@ -2023,7 +2022,7 @@ var excluded = map[string]bool{
 	"fixedbugs/issue4232.go":   true, // types2 reports (correct) extra errors
 	"fixedbugs/issue4452.go":   true, // types2 reports (correct) extra errors
 	"fixedbugs/issue5609.go":   true, // types2 needs a better error message
-	"fixedbugs/issue6500.go":   true, // compiler -G is not reporting an error (but types2 does)
+	"fixedbugs/issue6500.go":   true, // error reported by noder (not running for types2 errorcheck test)
 	"fixedbugs/issue6889.go":   true, // types2 can handle this without constant overflow
 	"fixedbugs/issue7525.go":   true, // types2 reports init cycle error on different line - ok otherwise
 	"fixedbugs/issue7525b.go":  true, // types2 reports init cycle error on different line - ok otherwise
-- 
GitLab


From 5aca6e78570c4a4826e500613b1bc054bc95142a Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 9 Dec 2020 20:14:07 -0800
Subject: [PATCH 0213/2400] [dev.typeparams] test: finish triaging all
 outstanding failing tests

Also: Adjusted error patterns for passing test that have different
error messages.

Change-Id: I216294b4c4855aa93da22cdc3c0b3303e54a8420
Reviewed-on: https://go-review.googlesource.com/c/go/+/277994
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 test/convlit.go          | 14 ++++----
 test/fixedbugs/bug163.go |  4 +--
 test/fixedbugs/bug192.go |  4 ++-
 test/fixedbugs/bug229.go |  4 +--
 test/fixedbugs/bug325.go |  2 +-
 test/fixedbugs/bug326.go |  2 +-
 test/fixedbugs/bug340.go |  2 +-
 test/fixedbugs/bug342.go |  2 +-
 test/fixedbugs/bug350.go |  2 +-
 test/fixedbugs/bug357.go |  2 +-
 test/fixedbugs/bug362.go |  6 ++--
 test/fixedbugs/bug371.go |  4 +--
 test/fixedbugs/bug379.go |  2 +-
 test/fixedbugs/bug383.go |  4 +--
 test/fixedbugs/bug386.go |  4 +--
 test/fixedbugs/bug389.go |  2 +-
 test/fixedbugs/bug390.go |  2 +-
 test/fixedbugs/bug397.go |  2 +-
 test/fixedbugs/bug416.go |  2 +-
 test/fixedbugs/bug418.go |  4 +--
 test/fixedbugs/bug462.go |  4 ++-
 test/fixedbugs/bug463.go |  4 +--
 test/fixedbugs/bug487.go |  6 ++--
 test/makechan.go         | 14 ++++----
 test/makemap.go          | 18 +++++-----
 test/run.go              | 76 +++++++++++-----------------------------
 test/slice3err.go        | 66 +++++++++++++++++-----------------
 test/switch5.go          | 30 ++++++++--------
 test/switch6.go          |  8 ++---
 test/switch7.go          |  2 +-
 30 files changed, 133 insertions(+), 165 deletions(-)

diff --git a/test/convlit.go b/test/convlit.go
index 1c66c89e88..9d2eee79c5 100644
--- a/test/convlit.go
+++ b/test/convlit.go
@@ -17,8 +17,8 @@ var x2 string = string(1)
 var x3 = int(1.5)     // ERROR "convert|truncate"
 var x4 int = int(1.5) // ERROR "convert|truncate"
 var x5 = "a" + string(1)
-var x6 = int(1e100)      // ERROR "overflow"
-var x7 = float32(1e1000) // ERROR "overflow"
+var x6 = int(1e100)      // ERROR "overflow|cannot convert"
+var x7 = float32(1e1000) // ERROR "overflow|cannot convert"
 
 // unsafe.Pointer can only convert to/from uintptr
 var _ = string(unsafe.Pointer(uintptr(65)))  // ERROR "convert|conversion"
@@ -34,7 +34,7 @@ var bad4 = "a" + 1   // ERROR "literals|incompatible|convert|invalid"
 var bad5 = "a" + 'a' // ERROR "literals|incompatible|convert|invalid"
 
 var bad6 int = 1.5       // ERROR "convert|truncate"
-var bad7 int = 1e100     // ERROR "overflow"
+var bad7 int = 1e100     // ERROR "overflow|truncated to int"
 var bad8 float32 = 1e200 // ERROR "overflow"
 
 // but these implicit conversions are okay
@@ -48,8 +48,8 @@ var _ = []rune("abc")
 var _ = []byte("abc")
 
 // implicit is not
-var _ []int = "abc"  // ERROR "cannot use|incompatible|invalid"
-var _ []byte = "abc" // ERROR "cannot use|incompatible|invalid"
+var _ []int = "abc"  // ERROR "cannot use|incompatible|invalid|cannot convert"
+var _ []byte = "abc" // ERROR "cannot use|incompatible|invalid|cannot convert"
 
 // named string is okay
 type Tstring string
@@ -70,5 +70,5 @@ var _ = Trune("abc") // ok
 var _ = Tbyte("abc") // ok
 
 // implicit is still not
-var _ Trune = "abc" // ERROR "cannot use|incompatible|invalid"
-var _ Tbyte = "abc" // ERROR "cannot use|incompatible|invalid"
+var _ Trune = "abc" // ERROR "cannot use|incompatible|invalid|cannot convert"
+var _ Tbyte = "abc" // ERROR "cannot use|incompatible|invalid|cannot convert"
diff --git a/test/fixedbugs/bug163.go b/test/fixedbugs/bug163.go
index d69f6bef03..f3e0543cd7 100644
--- a/test/fixedbugs/bug163.go
+++ b/test/fixedbugs/bug163.go
@@ -6,6 +6,4 @@
 
 package main
 
-func main() {
-	x⊛y := 1;	// ERROR "identifier"
-}
+var x⊛y int	// ERROR "invalid character .* in identifier"
diff --git a/test/fixedbugs/bug192.go b/test/fixedbugs/bug192.go
index 679aaed1f2..a22e6a2482 100644
--- a/test/fixedbugs/bug192.go
+++ b/test/fixedbugs/bug192.go
@@ -8,4 +8,6 @@ package main
 
 import "fmt"	// GCCGO_ERROR "previous"
 
-var fmt int	// ERROR "redecl|redefinition"
+var _ = fmt.Println // avoid imported and not used error
+
+var fmt int	// ERROR "redecl|redefinition|fmt already declared"
diff --git a/test/fixedbugs/bug229.go b/test/fixedbugs/bug229.go
index a30202fa2c..3cf1142a24 100644
--- a/test/fixedbugs/bug229.go
+++ b/test/fixedbugs/bug229.go
@@ -14,7 +14,7 @@ func main() {
 	// make sure error mentions that
 	// name is unexported, not just "name not found".
 
-	t.common.name = nil // ERROR "unexported"
+	t.common.name = nil // ERROR "unexported|undefined"
 
-	println(testing.anyLowercaseName("asdf")) // ERROR "unexported"
+	println(testing.anyLowercaseName("asdf")) // ERROR "unexported|undefined"
 }
diff --git a/test/fixedbugs/bug325.go b/test/fixedbugs/bug325.go
index e6528ae46a..74d7bbb923 100644
--- a/test/fixedbugs/bug325.go
+++ b/test/fixedbugs/bug325.go
@@ -10,6 +10,6 @@ import "unsafe"
 
 func main() {
 	var x unsafe.Pointer
-	println(*x) // ERROR "invalid indirect.*unsafe.Pointer"
+	println(*x) // ERROR "invalid indirect.*unsafe.Pointer|cannot indirect"
 	var _ = (unsafe.Pointer)(nil).foo  // ERROR "foo"
 }
diff --git a/test/fixedbugs/bug326.go b/test/fixedbugs/bug326.go
index 75d620cde5..dfd8be8005 100644
--- a/test/fixedbugs/bug326.go
+++ b/test/fixedbugs/bug326.go
@@ -19,7 +19,7 @@ func h() (_ int, _ error) {
 }
 
 func i() (int, error) {
-	return // ERROR "not enough arguments to return"
+	return // ERROR "not enough arguments to return|wrong number of return values"
 }
 
 func f1() (_ int, err error) {
diff --git a/test/fixedbugs/bug340.go b/test/fixedbugs/bug340.go
index 542a6eab03..117b28647a 100644
--- a/test/fixedbugs/bug340.go
+++ b/test/fixedbugs/bug340.go
@@ -13,6 +13,6 @@ func main() {
 	switch t := x.(type) {
 	case 0:		// ERROR "type"
 		t.x = 1
-		x.x = 1 // ERROR "type interface \{\}|reference to undefined field or method|interface with no methods"
+		x.x = 1 // ERROR "type interface \{\}|reference to undefined field or method|interface with no methods|undefined"
 	}
 }
diff --git a/test/fixedbugs/bug342.go b/test/fixedbugs/bug342.go
index f90f6f32cc..ccf93a6d95 100644
--- a/test/fixedbugs/bug342.go
+++ b/test/fixedbugs/bug342.go
@@ -9,7 +9,7 @@
 package p
 
 type a interface {
-	foo(x int) (x int) // ERROR "duplicate argument|redefinition"
+	foo(x int) (x int) // ERROR "duplicate argument|redefinition|redeclared"
 }
 
 /*
diff --git a/test/fixedbugs/bug350.go b/test/fixedbugs/bug350.go
index cdce1cfbe2..39f91d43a9 100644
--- a/test/fixedbugs/bug350.go
+++ b/test/fixedbugs/bug350.go
@@ -12,4 +12,4 @@ func (T) m() {} // GCCGO_ERROR "previous"
 func (T) m() {} // ERROR "T[.]m redeclared|redefinition"
 
 func (*T) p() {} // GCCGO_ERROR "previous"
-func (*T) p() {} // ERROR "[(][*]T[)][.]p redeclared|redefinition"
+func (*T) p() {} // ERROR "[(][*]T[)][.]p redeclared|redefinition|redeclared"
diff --git a/test/fixedbugs/bug357.go b/test/fixedbugs/bug357.go
index e9db50e88e..0a4cbedd95 100644
--- a/test/fixedbugs/bug357.go
+++ b/test/fixedbugs/bug357.go
@@ -15,7 +15,7 @@ func bla1() bool {
 
 func bla5() bool {
 	_ = 1
-	false  // ERROR "false evaluated but not used|value computed is not used"
+	false  // ERROR "false evaluated but not used|value computed is not used|is not used"
 	_ = 2
 	return false
 }
diff --git a/test/fixedbugs/bug362.go b/test/fixedbugs/bug362.go
index 771d13d435..98d6b0c822 100644
--- a/test/fixedbugs/bug362.go
+++ b/test/fixedbugs/bug362.go
@@ -10,7 +10,7 @@
 package main
 
 var (
-	a = iota  // ERROR "undefined: iota|iota is only defined in const"
-	b = iota  // ERROR "undefined: iota|iota is only defined in const"
-	c = iota  // ERROR "undefined: iota|iota is only defined in const"
+	a = iota  // ERROR "undefined: iota|iota is only defined in const|cannot use iota outside constant declaration"
+	b = iota  // ERROR "undefined: iota|iota is only defined in const|cannot use iota outside constant declaration"
+	c = iota  // ERROR "undefined: iota|iota is only defined in const|cannot use iota outside constant declaration"
 )
diff --git a/test/fixedbugs/bug371.go b/test/fixedbugs/bug371.go
index 3a626e523c..eb51b9ee86 100644
--- a/test/fixedbugs/bug371.go
+++ b/test/fixedbugs/bug371.go
@@ -19,6 +19,6 @@ func main() {
 	p.m()
 
 	q := &p
-	q.m()  // ERROR "requires explicit dereference"
-	q.pm() // ERROR "requires explicit dereference"
+	q.m()  // ERROR "requires explicit dereference|undefined"
+	q.pm() // ERROR "requires explicit dereference|undefined"
 }
diff --git a/test/fixedbugs/bug379.go b/test/fixedbugs/bug379.go
index 5638123d50..aa078b6ff4 100644
--- a/test/fixedbugs/bug379.go
+++ b/test/fixedbugs/bug379.go
@@ -14,5 +14,5 @@
 package main
 
 func main() {
-	1 + 2 // ERROR "1 \+ 2 evaluated but not used|value computed is not used"
+	1 + 2 // ERROR "1 \+ 2 evaluated but not used|value computed is not used|is not used"
 }
diff --git a/test/fixedbugs/bug383.go b/test/fixedbugs/bug383.go
index dc2ecd61fb..543ee10ac6 100644
--- a/test/fixedbugs/bug383.go
+++ b/test/fixedbugs/bug383.go
@@ -8,6 +8,6 @@
 
 package main
 func main() {
-	if 2e9 { }      // ERROR "2e.09|expected bool"
-	if 3.14+1i { }  // ERROR "3.14 . 1i|expected bool"
+	if 2e9 { }      // ERROR "2e.09|expected bool|non-boolean condition in if statement"
+	if 3.14+1i { }  // ERROR "3.14 . 1i|expected bool|non-boolean condition in if statement"
 }
diff --git a/test/fixedbugs/bug386.go b/test/fixedbugs/bug386.go
index 889c8b0c12..0899d1fc21 100644
--- a/test/fixedbugs/bug386.go
+++ b/test/fixedbugs/bug386.go
@@ -7,6 +7,6 @@
 // Issue 2451, 2452 
 package foo
 
-func f() error { return 0 } // ERROR "cannot use 0 .type int.|has no methods"
+func f() error { return 0 } // ERROR "cannot use 0 (.type int.)?|has no methods"
 
-func g() error { return -1 }  // ERROR "cannot use -1 .type int.|has no methods"
+func g() error { return -1 }  // ERROR "cannot use -1 (.type int.)?|has no methods"
diff --git a/test/fixedbugs/bug389.go b/test/fixedbugs/bug389.go
index 14804c8471..167e64e72c 100644
--- a/test/fixedbugs/bug389.go
+++ b/test/fixedbugs/bug389.go
@@ -9,4 +9,4 @@ package foo
 
 func fn(a float32) {}
 
-var f func(arg int) = fn  // ERROR "cannot use fn .type func.float32.. as type func.int. in assignment|different parameter types"
+var f func(arg int) = fn  // ERROR "cannot use fn .type func.float32.. as type func.int. in assignment|different parameter types|incompatible type"
diff --git a/test/fixedbugs/bug390.go b/test/fixedbugs/bug390.go
index 7ce9e13703..4ab24fb521 100644
--- a/test/fixedbugs/bug390.go
+++ b/test/fixedbugs/bug390.go
@@ -12,5 +12,5 @@ import "unsafe"
 
 func main() {
 	var x *int
-	_ = unsafe.Pointer(x) - unsafe.Pointer(x) // ERROR "operator - not defined on unsafe.Pointer|expected integer, floating, or complex type"
+	_ = unsafe.Pointer(x) - unsafe.Pointer(x) // ERROR "(operator|operation) - not defined on unsafe.Pointer|expected integer, floating, or complex type"
 }
diff --git a/test/fixedbugs/bug397.go b/test/fixedbugs/bug397.go
index 6188e3ee0c..db8d652814 100644
--- a/test/fixedbugs/bug397.go
+++ b/test/fixedbugs/bug397.go
@@ -9,5 +9,5 @@ package main
 // Issue 2623
 var m = map[string]int {
 	"abc":1,
-	1:2, // ERROR "cannot use 1.*as type string in map key|incompatible type"
+	1:2, // ERROR "cannot use 1.*as type string in map key|incompatible type|cannot convert"
 }
diff --git a/test/fixedbugs/bug416.go b/test/fixedbugs/bug416.go
index 9fc3532f1d..74b55cce18 100644
--- a/test/fixedbugs/bug416.go
+++ b/test/fixedbugs/bug416.go
@@ -10,4 +10,4 @@ type T struct {
 	X int
 }
 
-func (t *T) X() {} // ERROR "type T has both field and method named X|redeclares struct field name"
+func (t *T) X() {} // ERROR "type T has both field and method named X|redeclares struct field name|field and method with the same name"
diff --git a/test/fixedbugs/bug418.go b/test/fixedbugs/bug418.go
index 64d86b3400..4e63e867b8 100644
--- a/test/fixedbugs/bug418.go
+++ b/test/fixedbugs/bug418.go
@@ -13,10 +13,10 @@ func Two() (a, b int)
 
 // F used to compile.
 func F() (x interface{}, y int) {
-	return Two(), 0 // ERROR "single-value context"
+	return Two(), 0 // ERROR "single-value context|2\-valued"
 }
 
 // Recursive used to trigger an internal compiler error.
 func Recursive() (x interface{}, y int) {
-	return Recursive(), 0 // ERROR "single-value context"
+	return Recursive(), 0 // ERROR "single-value context|2\-valued"
 }
diff --git a/test/fixedbugs/bug462.go b/test/fixedbugs/bug462.go
index 3df63b091d..d1577e2ed7 100644
--- a/test/fixedbugs/bug462.go
+++ b/test/fixedbugs/bug462.go
@@ -8,12 +8,14 @@ package main
 
 import "os"
 
+var _ = os.Open // avoid imported and not used error
+
 type T struct {
 	File int
 }
 
 func main() {
 	_ = T {
-		os.File: 1, // ERROR "unknown T? ?field"
+		os.File: 1, // ERROR "unknown T? ?field|invalid field"
 	}
 }
diff --git a/test/fixedbugs/bug463.go b/test/fixedbugs/bug463.go
index c7f92379c8..ed546bf741 100644
--- a/test/fixedbugs/bug463.go
+++ b/test/fixedbugs/bug463.go
@@ -9,11 +9,11 @@
 
 package main
 
-const a = a // ERROR "refers to itself|definition loop"
+const a = a // ERROR "refers to itself|definition loop|initialization loop"
 
 const (
 	X    = A
-	A    = B // ERROR "refers to itself|definition loop"
+	A    = B // ERROR "refers to itself|definition loop|initialization loop"
 	B    = D
 	C, D = 1, A
 )
diff --git a/test/fixedbugs/bug487.go b/test/fixedbugs/bug487.go
index e60af6c8e2..150d660abc 100644
--- a/test/fixedbugs/bug487.go
+++ b/test/fixedbugs/bug487.go
@@ -14,11 +14,11 @@ func G() (int, int, int) {
 }
 
 func F() {
-	a, b := G()	// ERROR "mismatch"
-	a, b = G()	// ERROR "mismatch"
+	a, b := G()	// ERROR "mismatch|cannot initialize"
+	a, b = G()	// ERROR "mismatch|cannot assign"
 	_, _ = a, b
 }
 
 func H() (int, int) {
-	return G()	// ERROR "too many|mismatch"
+	return G()	// ERROR "too many|mismatch|wrong number"
 }
diff --git a/test/makechan.go b/test/makechan.go
index 6608620db3..30a57456b3 100644
--- a/test/makechan.go
+++ b/test/makechan.go
@@ -15,14 +15,14 @@ type T chan byte
 var sink T
 
 func main() {
-	sink = make(T, -1)            // ERROR "negative buffer argument in make.*"
-	sink = make(T, uint64(1<<63)) // ERROR "buffer argument too large in make.*"
+	sink = make(T, -1)            // ERROR "negative buffer argument in make.*|must not be negative"
+	sink = make(T, uint64(1<<63)) // ERROR "buffer argument too large in make.*|out of bounds"
 
-	sink = make(T, 0.5) // ERROR "constant 0.5 truncated to integer"
+	sink = make(T, 0.5) // ERROR "constant 0.5 truncated to integer|truncated to int"
 	sink = make(T, 1.0)
-	sink = make(T, float32(1.0)) // ERROR "non-integer buffer argument in make.*"
-	sink = make(T, float64(1.0)) // ERROR "non-integer buffer argument in make.*"
+	sink = make(T, float32(1.0)) // ERROR "non-integer buffer argument in make.*|must be integer"
+	sink = make(T, float64(1.0)) // ERROR "non-integer buffer argument in make.*|must be integer"
 	sink = make(T, 1+0i)
-	sink = make(T, complex64(1+0i))  // ERROR "non-integer buffer argument in make.*"
-	sink = make(T, complex128(1+0i)) // ERROR "non-integer buffer argument in make.*"
+	sink = make(T, complex64(1+0i))  // ERROR "non-integer buffer argument in make.*|must be integer"
+	sink = make(T, complex128(1+0i)) // ERROR "non-integer buffer argument in make.*|must be integer"
 }
diff --git a/test/makemap.go b/test/makemap.go
index 63998d708c..a60f5b5ee5 100644
--- a/test/makemap.go
+++ b/test/makemap.go
@@ -15,20 +15,20 @@ type T map[int]int
 var sink T
 
 func main() {
-	sink = make(T, -1)            // ERROR "negative size argument in make.*"
-	sink = make(T, uint64(1<<63)) // ERROR "size argument too large in make.*"
+	sink = make(T, -1)            // ERROR "negative size argument in make.*|must not be negative"
+	sink = make(T, uint64(1<<63)) // ERROR "size argument too large in make.*|out of bounds"
 
 	// Test that errors are emitted at call sites, not const declarations
 	const x = -1
-	sink = make(T, x) // ERROR "negative size argument in make.*"
+	sink = make(T, x) // ERROR "negative size argument in make.*|must not be negative"
 	const y = uint64(1 << 63)
-	sink = make(T, y) // ERROR "size argument too large in make.*"
+	sink = make(T, y) // ERROR "size argument too large in make.*|out of bounds"
 
-	sink = make(T, 0.5) // ERROR "constant 0.5 truncated to integer"
+	sink = make(T, 0.5) // ERROR "constant 0.5 truncated to integer|truncated to int"
 	sink = make(T, 1.0)
-	sink = make(T, float32(1.0)) // ERROR "non-integer size argument in make.*"
-	sink = make(T, float64(1.0)) // ERROR "non-integer size argument in make.*"
+	sink = make(T, float32(1.0)) // ERROR "non-integer size argument in make.*|must be integer"
+	sink = make(T, float64(1.0)) // ERROR "non-integer size argument in make.*|must be integer"
 	sink = make(T, 1+0i)
-	sink = make(T, complex64(1+0i))  // ERROR "non-integer size argument in make.*"
-	sink = make(T, complex128(1+0i)) // ERROR "non-integer size argument in make.*"
+	sink = make(T, complex64(1+0i))  // ERROR "non-integer size argument in make.*|must be integer"
+	sink = make(T, complex128(1+0i)) // ERROR "non-integer size argument in make.*|must be integer"
 }
diff --git a/test/run.go b/test/run.go
index b6c9d6050c..9cfd13ae48 100644
--- a/test/run.go
+++ b/test/run.go
@@ -1926,68 +1926,34 @@ func overlayDir(dstRoot, srcRoot string) error {
 // List of files that the compiler cannot errorcheck with the new typechecker (compiler -G option).
 // Temporary scaffolding until we pass all the tests at which point this map can be removed.
 var excluded = map[string]bool{
-	"complit1.go":     true,
-	"const2.go":       true,
-	"convlit.go":      true,
+	"complit1.go":     true, // types2 reports extra errors
+	"const2.go":       true, // types2 not run after syntax errors
 	"ddd1.go":         true, // issue #42987
 	"directive.go":    true, // misplaced compiler directive checks
-	"float_lit3.go":   true,
-	"import1.go":      true,
+	"float_lit3.go":   true, // types2 reports extra errors
+	"import1.go":      true, // types2 reports extra errors
 	"import5.go":      true, // issue #42988
-	"import6.go":      true,
-	"initializerr.go": true,
-	"linkname2.go":    true,
-	"makechan.go":     true,
-	"makemap.go":      true,
+	"import6.go":      true, // issue #43109
+	"initializerr.go": true, // types2 reports extra errors
+	"linkname2.go":    true, // error reported by noder (not running for types2 errorcheck test)
 	"shift1.go":       true, // issue #42989
-	"slice3err.go":    true,
-	"switch3.go":      true,
-	"switch4.go":      true,
-	"switch5.go":      true,
-	"switch6.go":      true,
-	"switch7.go":      true,
+	"switch3.go":      true, // issue #43110
+	"switch4.go":      true, // error reported by noder (not running for types2 errorcheck test)
 	"typecheck.go":    true, // invalid function is not causing errors when called
 
-	"fixedbugs/bug163.go":    true,
-	"fixedbugs/bug176.go":    true,
-	"fixedbugs/bug192.go":    true,
-	"fixedbugs/bug193.go":    true,
-	"fixedbugs/bug195.go":    true,
-	"fixedbugs/bug213.go":    true,
-	"fixedbugs/bug228.go":    true,
-	"fixedbugs/bug229.go":    true,
-	"fixedbugs/bug231.go":    true,
-	"fixedbugs/bug251.go":    true,
-	"fixedbugs/bug255.go":    true,
-	"fixedbugs/bug256.go":    true,
-	"fixedbugs/bug325.go":    true,
-	"fixedbugs/bug326.go":    true,
-	"fixedbugs/bug340.go":    true,
-	"fixedbugs/bug342.go":    true,
-	"fixedbugs/bug350.go":    true,
-	"fixedbugs/bug351.go":    true,
-	"fixedbugs/bug353.go":    true,
-	"fixedbugs/bug357.go":    true,
-	"fixedbugs/bug362.go":    true,
-	"fixedbugs/bug371.go":    true,
-	"fixedbugs/bug374.go":    true,
-	"fixedbugs/bug379.go":    true,
-	"fixedbugs/bug383.go":    true,
+	"fixedbugs/bug176.go":    true, // types2 reports all errors (pref: types2)
+	"fixedbugs/bug193.go":    true, // types2 bug: shift error not reported (fixed in go/types)
+	"fixedbugs/bug195.go":    true, // types2 reports slightly different (but correct) bugs
+	"fixedbugs/bug213.go":    true, // error reported by noder (not running for types2 errorcheck test)
+	"fixedbugs/bug228.go":    true, // types2 not run after syntax errors
+	"fixedbugs/bug231.go":    true, // types2 bug? (same error reported twice)
+	"fixedbugs/bug255.go":    true, // types2 reports extra errors
+	"fixedbugs/bug351.go":    true, // types2 reports extra errors
+	"fixedbugs/bug374.go":    true, // types2 reports extra errors
 	"fixedbugs/bug385_32.go": true, // types2 doesn't produce "stack frame too large" error (32-bit specific)
 	"fixedbugs/bug385_64.go": true, // types2 doesn't produce "stack frame too large" error
-	"fixedbugs/bug386.go":    true,
-	"fixedbugs/bug388.go":    true,
-	"fixedbugs/bug389.go":    true,
-	"fixedbugs/bug390.go":    true,
-	"fixedbugs/bug397.go":    true,
-	"fixedbugs/bug412.go":    true,
-	"fixedbugs/bug413.go":    true,
-	"fixedbugs/bug416.go":    true,
-	"fixedbugs/bug418.go":    true,
-	"fixedbugs/bug459.go":    true,
-	"fixedbugs/bug462.go":    true,
-	"fixedbugs/bug463.go":    true,
-	"fixedbugs/bug487.go":    true,
+	"fixedbugs/bug388.go":    true, // types2 not run due to syntax errors
+	"fixedbugs/bug412.go":    true, // types2 produces a follow-on error
 
 	"fixedbugs/issue11362.go":  true, // types2 import path handling
 	"fixedbugs/issue11590.go":  true, // types2 doesn't report a follow-on error (pref: types2)
@@ -1995,7 +1961,7 @@ var excluded = map[string]bool{
 	"fixedbugs/issue11614.go":  true, // types2 reports an extra error
 	"fixedbugs/issue13415.go":  true, // declared but not used conflict
 	"fixedbugs/issue14520.go":  true, // missing import path error by types2
-	"fixedbugs/issue14540.go":  true, // types2 is missing a fallthrough error
+	"fixedbugs/issue14540.go":  true, // error reported by noder (not running for types2 errorcheck test)
 	"fixedbugs/issue16428.go":  true, // types2 reports two instead of one error
 	"fixedbugs/issue17038.go":  true, // types2 doesn't report a follow-on error (pref: types2)
 	"fixedbugs/issue17645.go":  true, // multiple errors on same line
diff --git a/test/slice3err.go b/test/slice3err.go
index 1309fdd56b..120ecbecce 100644
--- a/test/slice3err.go
+++ b/test/slice3err.go
@@ -17,12 +17,12 @@ func f() {
 	_ = array[i:]
 	_ = array[:j]
 	_ = array[i:j]
-	_ = array[::] // ERROR "middle index required in 3-index slice" "final index required in 3-index slice"
-	_ = array[i::] // ERROR "middle index required in 3-index slice" "final index required in 3-index slice"
-	_ = array[:j:] // ERROR "final index required in 3-index slice"
-	_ = array[i:j:] // ERROR "final index required in 3-index slice"
-	_ = array[::k] // ERROR "middle index required in 3-index slice"
-	_ = array[i::k] // ERROR "middle index required in 3-index slice"
+	_ = array[::] // ERROR "middle index required in 3-index slice|invalid slice indices" "final index required in 3-index slice"
+	_ = array[i::] // ERROR "middle index required in 3-index slice|invalid slice indices" "final index required in 3-index slice"
+	_ = array[:j:] // ERROR "final index required in 3-index slice|invalid slice indices"
+	_ = array[i:j:] // ERROR "final index required in 3-index slice|invalid slice indices"
+	_ = array[::k] // ERROR "middle index required in 3-index slice|invalid slice indices"
+	_ = array[i::k] // ERROR "middle index required in 3-index slice|invalid slice indices"
 	_ = array[:j:k]
 	_ = array[i:j:k]
 	
@@ -30,12 +30,12 @@ func f() {
 	_ = slice[i:]
 	_ = slice[:j]
 	_ = slice[i:j]
-	_ = slice[::] // ERROR "middle index required in 3-index slice" "final index required in 3-index slice"
-	_ = slice[i::] // ERROR "middle index required in 3-index slice" "final index required in 3-index slice"
-	_ = slice[:j:] // ERROR "final index required in 3-index slice"
-	_ = slice[i:j:] // ERROR "final index required in 3-index slice"
-	_ = slice[::k] // ERROR "middle index required in 3-index slice"
-	_ = slice[i::k] // ERROR "middle index required in 3-index slice"
+	_ = slice[::] // ERROR "middle index required in 3-index slice|invalid slice indices" "final index required in 3-index slice"
+	_ = slice[i::] // ERROR "middle index required in 3-index slice|invalid slice indices" "final index required in 3-index slice"
+	_ = slice[:j:] // ERROR "final index required in 3-index slice|invalid slice indices"
+	_ = slice[i:j:] // ERROR "final index required in 3-index slice|invalid slice indices"
+	_ = slice[::k] // ERROR "middle index required in 3-index slice|invalid slice indices"
+	_ = slice[i::k] // ERROR "middle index required in 3-index slice|invalid slice indices"
 	_ = slice[:j:k]
 	_ = slice[i:j:k]
 	
@@ -54,43 +54,43 @@ func f() {
 
 	// check invalid indices
 	_ = array[1:2]
-	_ = array[2:1] // ERROR "invalid slice index|inverted slice"
+	_ = array[2:1] // ERROR "invalid slice index|invalid slice indices|inverted slice"
 	_ = array[2:2]
 	_ = array[i:1]
 	_ = array[1:j]
 	_ = array[1:2:3]
-	_ = array[1:3:2] // ERROR "invalid slice index|inverted slice"
-	_ = array[2:1:3] // ERROR "invalid slice index|inverted slice"
-	_ = array[2:3:1] // ERROR "invalid slice index|inverted slice"
-	_ = array[3:1:2] // ERROR "invalid slice index|inverted slice"
-	_ = array[3:2:1] // ERROR "invalid slice index|inverted slice"
+	_ = array[1:3:2] // ERROR "invalid slice index|invalid slice indices|inverted slice"
+	_ = array[2:1:3] // ERROR "invalid slice index|invalid slice indices|inverted slice"
+	_ = array[2:3:1] // ERROR "invalid slice index|invalid slice indices|inverted slice"
+	_ = array[3:1:2] // ERROR "invalid slice index|invalid slice indices|inverted slice"
+	_ = array[3:2:1] // ERROR "invalid slice index|invalid slice indices|inverted slice"
 	_ = array[i:1:2]
-	_ = array[i:2:1] // ERROR "invalid slice index|inverted slice"
+	_ = array[i:2:1] // ERROR "invalid slice index|invalid slice indices|inverted slice"
 	_ = array[1:j:2]
-	_ = array[2:j:1] // ERROR "invalid slice index"
+	_ = array[2:j:1] // ERROR "invalid slice index|invalid slice indices"
 	_ = array[1:2:k]
-	_ = array[2:1:k] // ERROR "invalid slice index|inverted slice"
+	_ = array[2:1:k] // ERROR "invalid slice index|invalid slice indices|inverted slice"
 	
 	_ = slice[1:2]
-	_ = slice[2:1] // ERROR "invalid slice index|inverted slice"
+	_ = slice[2:1] // ERROR "invalid slice index|invalid slice indices|inverted slice"
 	_ = slice[2:2]
 	_ = slice[i:1]
 	_ = slice[1:j]
 	_ = slice[1:2:3]
-	_ = slice[1:3:2] // ERROR "invalid slice index|inverted slice"
-	_ = slice[2:1:3] // ERROR "invalid slice index|inverted slice"
-	_ = slice[2:3:1] // ERROR "invalid slice index|inverted slice"
-	_ = slice[3:1:2] // ERROR "invalid slice index|inverted slice"
-	_ = slice[3:2:1] // ERROR "invalid slice index|inverted slice"
+	_ = slice[1:3:2] // ERROR "invalid slice index|invalid slice indices|inverted slice"
+	_ = slice[2:1:3] // ERROR "invalid slice index|invalid slice indices|inverted slice"
+	_ = slice[2:3:1] // ERROR "invalid slice index|invalid slice indices|inverted slice"
+	_ = slice[3:1:2] // ERROR "invalid slice index|invalid slice indices|inverted slice"
+	_ = slice[3:2:1] // ERROR "invalid slice index|invalid slice indices|inverted slice"
 	_ = slice[i:1:2]
-	_ = slice[i:2:1] // ERROR "invalid slice index|inverted slice"
+	_ = slice[i:2:1] // ERROR "invalid slice index|invalid slice indices|inverted slice"
 	_ = slice[1:j:2]
-	_ = slice[2:j:1] // ERROR "invalid slice index"
+	_ = slice[2:j:1] // ERROR "invalid slice index|invalid slice indices"
 	_ = slice[1:2:k]
-	_ = slice[2:1:k] // ERROR "invalid slice index|inverted slice"
+	_ = slice[2:1:k] // ERROR "invalid slice index|invalid slice indices|inverted slice"
 	
 	_ = str[1:2]
-	_ = str[2:1] // ERROR "invalid slice index|inverted slice"
+	_ = str[2:1] // ERROR "invalid slice index|invalid slice indices|inverted slice"
 	_ = str[2:2]
 	_ = str[i:1]
 	_ = str[1:j]
@@ -115,7 +115,7 @@ func f() {
 	_ = slice[1:11]
 	_ = slice[1:11:12]
 	_ = slice[1:2:11]
-	_ = slice[1:11:3] // ERROR "invalid slice index"
-	_ = slice[11:2:3] // ERROR "invalid slice index|inverted slice"
+	_ = slice[1:11:3] // ERROR "invalid slice index|invalid slice indices"
+	_ = slice[11:2:3] // ERROR "invalid slice index|invalid slice indices|inverted slice"
 	_ = slice[11:12:13]
 }
diff --git a/test/switch5.go b/test/switch5.go
index ce95bf8d7b..dcf7ba0cf4 100644
--- a/test/switch5.go
+++ b/test/switch5.go
@@ -12,41 +12,41 @@ package main
 func f0(x int) {
 	switch x {
 	case 0:
-	case 0: // ERROR "duplicate case 0 in switch"
+	case 0: // ERROR "duplicate case (0 in switch)?"
 	}
 
 	switch x {
 	case 0:
-	case int(0): // ERROR "duplicate case int.0. .value 0. in switch"
+	case int(0): // ERROR "duplicate case (int.0. .value 0. in switch)?"
 	}
 }
 
 func f1(x float32) {
 	switch x {
 	case 5:
-	case 5: // ERROR "duplicate case 5 in switch"
-	case 5.0: // ERROR "duplicate case 5 in switch"
+	case 5: // ERROR "duplicate case (5 in switch)?"
+	case 5.0: // ERROR "duplicate case (5 in switch)?"
 	}
 }
 
 func f2(s string) {
 	switch s {
 	case "":
-	case "": // ERROR "duplicate case .. in switch"
+	case "": // ERROR "duplicate case (.. in switch)?"
 	case "abc":
-	case "abc": // ERROR "duplicate case .abc. in switch"
+	case "abc": // ERROR "duplicate case (.abc. in switch)?"
 	}
 }
 
 func f3(e interface{}) {
 	switch e {
 	case 0:
-	case 0: // ERROR "duplicate case 0 in switch"
+	case 0: // ERROR "duplicate case (0 in switch)?"
 	case int64(0):
 	case float32(10):
-	case float32(10): // ERROR "duplicate case float32\(10\) .value 10. in switch"
+	case float32(10): // ERROR "duplicate case (float32\(10\) .value 10. in switch)?"
 	case float64(10):
-	case float64(10): // ERROR "duplicate case float64\(10\) .value 10. in switch"
+	case float64(10): // ERROR "duplicate case (float64\(10\) .value 10. in switch)?"
 	}
 }
 
@@ -82,13 +82,13 @@ func f7(a int) {
 func f8(r rune) {
 	const x = 10
 	switch r {
-	case 33, 33: // ERROR "duplicate case 33 in switch"
+	case 33, 33: // ERROR "duplicate case (33 in switch)?"
 	case 34, '"': // ERROR "duplicate case '"' .value 34. in switch"
-	case 35, rune('#'): // ERROR "duplicate case rune.'#'. .value 35. in switch"
-	case 36, rune(36): // ERROR "duplicate case rune.36. .value 36. in switch"
-	case 37, '$'+1: // ERROR "duplicate case '\$' \+ 1 .value 37. in switch"
+	case 35, rune('#'): // ERROR "duplicate case (rune.'#'. .value 35. in switch)?"
+	case 36, rune(36): // ERROR "duplicate case (rune.36. .value 36. in switch)?"
+	case 37, '$'+1: // ERROR "duplicate case ('\$' \+ 1 .value 37. in switch)?"
 	case 'b':
-	case 'a', 'b', 'c', 'd': // ERROR "duplicate case 'b' .value 98."
-	case x, x: // ERROR "duplicate case x .value 10."
+	case 'a', 'b', 'c', 'd': // ERROR "duplicate case ('b' .value 98.)?"
+	case x, x: // ERROR "duplicate case (x .value 10.)?"
 	}
 }
diff --git a/test/switch6.go b/test/switch6.go
index 9d102fef51..4f95d02615 100644
--- a/test/switch6.go
+++ b/test/switch6.go
@@ -15,7 +15,7 @@ package main
 // Verify that type switch statements with impossible cases are detected by the compiler.
 func f0(e error) {
 	switch e.(type) {
-	case int: // ERROR "impossible type switch case: e \(type error\) cannot have dynamic type int \(missing Error method\)"
+	case int: // ERROR "impossible type switch case: e \(type error\) cannot have dynamic type int \(missing Error method\)|impossible type assertion"
 	}
 }
 
@@ -23,11 +23,11 @@ func f0(e error) {
 func f1(e interface{}) {
 	switch e {
 	default:
-	default: // ERROR "multiple defaults in switch"
+	default: // ERROR "multiple defaults( in switch)?"
 	}
 	switch e.(type) {
 	default:
-	default: // ERROR "multiple defaults in switch"
+	default: // ERROR "multiple defaults( in switch)?"
 	}
 }
 
@@ -41,6 +41,6 @@ func (*X) Foo() {}
 func f2() {
 	var i I
 	switch i.(type) {
-	case X: // ERROR "impossible type switch case: i \(type I\) cannot have dynamic type X \(Foo method has pointer receiver\)"
+	case X: // ERROR "impossible type switch case: i \(type I\) cannot have dynamic type X \(Foo method has pointer receiver\)|impossible type assertion"
 	}
 }
diff --git a/test/switch7.go b/test/switch7.go
index 75060669b3..3fb0129b15 100644
--- a/test/switch7.go
+++ b/test/switch7.go
@@ -27,7 +27,7 @@ func f4(e interface{}) {
 	case struct {
 		i int "tag2"
 	}:
-	case struct { // ERROR "duplicate case struct { i int .tag1. } in type switch"
+	case struct { // ERROR "duplicate case struct { i int .tag1. } in type switch|duplicate case"
 		i int "tag1"
 	}:
 	}
-- 
GitLab


From f8930a241301b9922beef925e4ca685f8c3e95a7 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 10 Dec 2020 11:30:18 -0800
Subject: [PATCH 0214/2400] [dev.typeparams] cmd/compile/internal/types2:
 report invalid ... in conversions

This fixes the bug below for types2.

Updates #43124.

Change-Id: Ic1962d41f321d8a08992d8529625bc133e526b0c
Reviewed-on: https://go-review.googlesource.com/c/go/+/278012
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/types2/call.go          |  4 ++++
 .../internal/types2/fixedbugs/issue43124.src     | 16 ++++++++++++++++
 2 files changed, 20 insertions(+)
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue43124.src

diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index fe3c17fc6b..5ecd54ab0b 100644
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -128,6 +128,10 @@ func (check *Checker) call(x *operand, call *syntax.CallExpr) exprKind {
 						break
 					}
 				}
+				if call.HasDots {
+					check.errorf(call.ArgList[0], "invalid use of ... in type conversion to %s)", T)
+					break
+				}
 				check.conversion(x, T)
 			}
 		default:
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue43124.src b/src/cmd/compile/internal/types2/fixedbugs/issue43124.src
new file mode 100644
index 0000000000..7e48c2211b
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue43124.src
@@ -0,0 +1,16 @@
+// Copyright 2020 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 p
+
+var _ = int(0 /* ERROR invalid use of \.\.\. in type conversion */ ...)
+
+// test case from issue
+
+type M []string
+
+var (
+	x = []string{"a", "b"}
+	_ = M(x /* ERROR invalid use of \.\.\. in type conversion */ ...)
+)
-- 
GitLab


From 8fe8e29c9f94d569586a6d8ae6798f82bb5b385b Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 10 Dec 2020 18:07:09 -0800
Subject: [PATCH 0215/2400] [dev.typeparams] cmd/compile/internal/types2:
 report error for invalid type expression

This bug was introduced by the change from go/ast to syntax which
represents pointer types as (unary) operations rather than dedicated
StarExpr nodes. Accordingly, this bug does not exist for go/types.
It's still ok to backport the test.

Fixes #43125.

Change-Id: Ic55d913f8afc92862856e1eb7c2861d07fc56cfb
Reviewed-on: https://go-review.googlesource.com/c/go/+/278013
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/types2/fixedbugs/issue43125.src | 8 ++++++++
 src/cmd/compile/internal/types2/typexpr.go               | 3 +++
 2 files changed, 11 insertions(+)
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue43125.src

diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue43125.src b/src/cmd/compile/internal/types2/fixedbugs/issue43125.src
new file mode 100644
index 0000000000..c2bd970e25
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue43125.src
@@ -0,0 +1,8 @@
+// Copyright 2020 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 p
+
+var _ = new(- /* ERROR not a type */ 1)
+var _ = new(1 /* ERROR not a type */ + 1)
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 22df01b3be..4231577a4f 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -535,6 +535,9 @@ func (check *Checker) typInternal(e0 syntax.Expr, def *Named) (T Type) {
 			return typ
 		}
 
+		check.errorf(e0, "%s is not a type", e0)
+		check.use(e0)
+
 	case *syntax.FuncType:
 		typ := new(Signature)
 		def.setUnderlying(typ)
-- 
GitLab


From 8ec9e890008e681dcebdae50379b785eb6f160bb Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Fri, 11 Dec 2020 16:29:08 -0500
Subject: [PATCH 0216/2400] [dev.typeparams] cmd/compile/internal/types2: fix
 stray ')' in error

I missed this in the review of CL 277072, but noticed it in CL 277352.

Change-Id: I432e3569eb4a935cee19805225f02c424d54011e
Reviewed-on: https://go-review.googlesource.com/c/go/+/277962
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/types2/call.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index 5ecd54ab0b..5a7ae221e6 100644
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -129,7 +129,7 @@ func (check *Checker) call(x *operand, call *syntax.CallExpr) exprKind {
 					}
 				}
 				if call.HasDots {
-					check.errorf(call.ArgList[0], "invalid use of ... in type conversion to %s)", T)
+					check.errorf(call.ArgList[0], "invalid use of ... in type conversion to %s", T)
 					break
 				}
 				check.conversion(x, T)
-- 
GitLab


From 617383377f0e870a9258230cf29fd11097b9229a Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Sat, 5 Dec 2020 17:25:28 -0800
Subject: [PATCH 0217/2400] [dev.regabi] cmd/compile: reorg generated array
 hash loop

The ORANGE structure that is being replaced by this CL was causing
trouble with another CL (CL 275695).

The problem occurs if you typecheck i in the middle of generating the
body of the ORANGE loop. If you typecheck i, it ends up typechecking
its definition, which secretly typechecks the containing ORANGE.  If
you then add other items to the ORANGE body, those items will never
get typechecked, as the ORANGE is already marked as typechecked.

Instead, just steal the loop we use for the equality code. Might as
well use the same pattern in both places.

Change-Id: Idb1ac77881d2cc9da08c7437a652b50d3ee45e2e
Reviewed-on: https://go-review.googlesource.com/c/go/+/275713
Trust: Keith Randall <khr@golang.org>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/gc/alg.go | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index c786a27415..ea57e7398d 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -310,13 +310,13 @@ func genhash(t *types.Type) *obj.LSym {
 		// pure memory.
 		hashel := hashfor(t.Elem())
 
-		n := ir.Nod(ir.ORANGE, nil, ir.Nod(ir.ODEREF, np, nil))
-		ni := ir.Node(NewName(lookup("i")))
-		ni.SetType(types.Types[types.TINT])
-		n.PtrList().Set1(ni)
-		n.SetColas(true)
-		colasdefn(n.List().Slice(), n)
-		ni = n.List().First()
+		// for i := 0; i < nelem; i++
+		ni := temp(types.Types[types.TINT])
+		init := ir.Nod(ir.OAS, ni, nodintconst(0))
+		cond := ir.Nod(ir.OLT, ni, nodintconst(t.NumElem()))
+		post := ir.Nod(ir.OAS, ni, ir.Nod(ir.OADD, ni, nodintconst(1)))
+		loop := ir.Nod(ir.OFOR, cond, post)
+		loop.PtrInit().Append(init)
 
 		// h = hashel(&p[i], h)
 		call := ir.Nod(ir.OCALL, hashel, nil)
@@ -326,9 +326,9 @@ func genhash(t *types.Type) *obj.LSym {
 		na := ir.Nod(ir.OADDR, nx, nil)
 		call.PtrList().Append(na)
 		call.PtrList().Append(nh)
-		n.PtrBody().Append(ir.Nod(ir.OAS, nh, call))
+		loop.PtrBody().Append(ir.Nod(ir.OAS, nh, call))
 
-		fn.PtrBody().Append(n)
+		fn.PtrBody().Append(loop)
 
 	case types.TSTRUCT:
 		// Walk the struct using memhash for runs of AMEM
-- 
GitLab


From 3a912f279fb6e3b6942a3a6c2449288a33351b69 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 10 Dec 2020 21:16:02 -0800
Subject: [PATCH 0218/2400] [dev.typeparams] cmd/compile/internal/syntax:
 export NewName and use it

Most syntax.Nodes are allocated in one place and there didn't
seem a need to provide factory methods - so as a matter of
API design, all nodes are "naked", without any constructors.

However, Name nodes are frequently used/replaced and also
are created as helper nodes in clients (types2). Make an
exception and export NewName.

Change-Id: I4b5c499d65bba74592dea68b0936c118b3edaca7
Reviewed-on: https://go-review.googlesource.com/c/go/+/277572
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/syntax/nodes.go    |  7 +++++++
 src/cmd/compile/internal/syntax/parser.go   | 23 ++++++---------------
 src/cmd/compile/internal/types2/resolver.go |  2 +-
 src/cmd/compile/internal/types2/stmt.go     | 10 +--------
 4 files changed, 15 insertions(+), 27 deletions(-)

diff --git a/src/cmd/compile/internal/syntax/nodes.go b/src/cmd/compile/internal/syntax/nodes.go
index 306e695a33..fe8f62c6e6 100644
--- a/src/cmd/compile/internal/syntax/nodes.go
+++ b/src/cmd/compile/internal/syntax/nodes.go
@@ -122,6 +122,13 @@ type Group struct {
 // ----------------------------------------------------------------------------
 // Expressions
 
+func NewName(pos Pos, value string) *Name {
+	n := new(Name)
+	n.pos = pos
+	n.Value = value
+	return n
+}
+
 type (
 	Expr interface {
 		Node
diff --git a/src/cmd/compile/internal/syntax/parser.go b/src/cmd/compile/internal/syntax/parser.go
index dbec462ab1..4af7e462ed 100644
--- a/src/cmd/compile/internal/syntax/parser.go
+++ b/src/cmd/compile/internal/syntax/parser.go
@@ -533,7 +533,7 @@ func (p *parser) importDecl(group *Group) Decl {
 	case _Name:
 		d.LocalPkgName = p.name()
 	case _Dot:
-		d.LocalPkgName = p.newName(".")
+		d.LocalPkgName = NewName(p.pos(), ".")
 		p.next()
 	}
 	d.Path = p.oliteral()
@@ -1409,9 +1409,7 @@ func (p *parser) interfaceType() *InterfaceType {
 		case _Type:
 			if p.mode&AllowGenerics != 0 {
 				// TODO(gri) factor this better
-				type_ := new(Name)
-				type_.pos = p.pos()
-				type_.Value = "type" // cannot have a method named "type"
+				type_ := NewName(p.pos(), "type") // cannot have a method named "type"
 				p.next()
 				if p.tok != _Semi && p.tok != _Rbrace {
 					f := new(Field)
@@ -1833,9 +1831,7 @@ func (p *parser) paramList(name *Name, close token) (list []*Field) {
 				typ = par.Type
 				if par.Name == nil {
 					pos = typ.Pos()
-					n := p.newName("_")
-					n.pos = pos // correct position
-					par.Name = n
+					par.Name = NewName(pos, "_")
 				}
 			} else if typ != nil {
 				par.Type = typ
@@ -2468,23 +2464,16 @@ func (p *parser) argList() (list []Expr, hasDots bool) {
 // ----------------------------------------------------------------------------
 // Common productions
 
-func (p *parser) newName(value string) *Name {
-	n := new(Name)
-	n.pos = p.pos()
-	n.Value = value
-	return n
-}
-
 func (p *parser) name() *Name {
 	// no tracing to avoid overly verbose output
 
 	if p.tok == _Name {
-		n := p.newName(p.lit)
+		n := NewName(p.pos(), p.lit)
 		p.next()
 		return n
 	}
 
-	n := p.newName("_")
+	n := NewName(p.pos(), "_")
 	p.syntaxError("expecting name")
 	p.advance()
 	return n
@@ -2522,7 +2511,7 @@ func (p *parser) qualifiedName(name *Name) Expr {
 	case p.tok == _Name:
 		x = p.name()
 	default:
-		x = p.newName("_")
+		x = NewName(p.pos(), "_")
 		p.syntaxError("expecting name")
 		p.advance(_Dot, _Semi, _Rbrace)
 	}
diff --git a/src/cmd/compile/internal/types2/resolver.go b/src/cmd/compile/internal/types2/resolver.go
index b57b41e2b0..2e90e5781c 100644
--- a/src/cmd/compile/internal/types2/resolver.go
+++ b/src/cmd/compile/internal/types2/resolver.go
@@ -523,7 +523,7 @@ L: // unpack receiver type
 					check.errorf(arg, "receiver type parameter %s must be an identifier", arg)
 				}
 				if par == nil {
-					par = newName(arg.Pos(), "_")
+					par = syntax.NewName(arg.Pos(), "_")
 				}
 				tparams = append(tparams, par)
 			}
diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go
index f1317fa0a3..477bc58bd0 100644
--- a/src/cmd/compile/internal/types2/stmt.go
+++ b/src/cmd/compile/internal/types2/stmt.go
@@ -596,14 +596,6 @@ func (check *Checker) stmt(ctxt stmtContext, s syntax.Stmt) {
 	}
 }
 
-func newName(pos syntax.Pos, value string) *syntax.Name {
-	n := new(syntax.Name)
-	// TODO(gri) why does this not work?
-	//n.pos = pos
-	n.Value = value
-	return n
-}
-
 func (check *Checker) switchStmt(inner stmtContext, s *syntax.SwitchStmt) {
 	// init statement already handled
 
@@ -624,7 +616,7 @@ func (check *Checker) switchStmt(inner stmtContext, s *syntax.SwitchStmt) {
 		if len(s.Body) > 0 {
 			pos = s.Body[0].Pos()
 		}
-		x.expr = newName(pos, "true")
+		x.expr = syntax.NewName(pos, "true")
 	}
 
 	check.multipleSwitchDefaults(s.Body)
-- 
GitLab


From c8e73489c32d5a45beca3f4810b6be64a2553ddb Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 8 Dec 2020 14:28:21 -0500
Subject: [PATCH 0219/2400] go/types: import instance.expand and subst.go from
 dev.go2go

Changes from dev.go2go:
 + A potentially latent bug is fixed when nilling out tparams in an
   instantiated signature (the resulting type could be Typ[Invalid])
 + Support for pointer designation is removed
 + instantiatedHash is updated to use '[]' rather than '()'
 + Several TODOs were added for me to follow-up on, rather than address
   in this CL
 + Error callsites are updated. Deciding on error codes and better error
   messages is punted to a later CL

These changes can be reviewed by comparing with Patchset #1 of this CL.

Change-Id: Ib5869586b8395419013010e2085cab877727d2ef
Reviewed-on: https://go-review.googlesource.com/c/go/+/276253
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Robert Findley <rfindley@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/check.go      |   2 +
 src/go/types/subst.go      | 542 +++++++++++++++++++++++++++++++++++++
 src/go/types/type.go       |  29 +-
 src/go/types/typestring.go |   3 -
 4 files changed, 567 insertions(+), 9 deletions(-)
 create mode 100644 src/go/types/subst.go

diff --git a/src/go/types/check.go b/src/go/types/check.go
index f82c7fdf7b..73330db6e4 100644
--- a/src/go/types/check.go
+++ b/src/go/types/check.go
@@ -82,6 +82,7 @@ type Checker struct {
 	objMap map[Object]*declInfo       // maps package-level objects and (non-interface) methods to declaration info
 	impMap map[importKey]*Package     // maps (import path, source directory) to (complete or fake) package
 	posMap map[*Interface][]token.Pos // maps interface types to lists of embedded interface positions
+	typMap map[string]*Named          // maps an instantiated named type hash to a *Named type
 	pkgCnt map[string]int             // counts number of imported packages with a given name (for better error messages)
 
 	// information collected during type-checking of a set of package files
@@ -194,6 +195,7 @@ func NewChecker(conf *Config, fset *token.FileSet, pkg *Package, info *Info) *Ch
 		objMap: make(map[Object]*declInfo),
 		impMap: make(map[importKey]*Package),
 		posMap: make(map[*Interface][]token.Pos),
+		typMap: make(map[string]*Named),
 		pkgCnt: make(map[string]int),
 	}
 }
diff --git a/src/go/types/subst.go b/src/go/types/subst.go
new file mode 100644
index 0000000000..ca9462dfda
--- /dev/null
+++ b/src/go/types/subst.go
@@ -0,0 +1,542 @@
+// Copyright 2018 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.
+
+// This file implements instantiation of generic types
+// through substitution of type parameters by actual
+// types.
+
+package types
+
+import (
+	"bytes"
+	"fmt"
+	"go/token"
+)
+
+// TODO(rFindley) decide error codes for the errors in this file, and check
+//                if error spans can be improved
+
+type substMap struct {
+	// The targs field is currently needed for *Named type substitution.
+	// TODO(gri) rewrite that code, get rid of this field, and make this
+	//           struct just the map (proj)
+	targs []Type
+	proj  map[*TypeParam]Type
+}
+
+// makeSubstMap creates a new substitution map mapping tpars[i] to targs[i].
+// If targs[i] is nil, tpars[i] is not substituted.
+func makeSubstMap(tpars []*TypeName, targs []Type) *substMap {
+	assert(len(tpars) == len(targs))
+	proj := make(map[*TypeParam]Type, len(tpars))
+	for i, tpar := range tpars {
+		// We must expand type arguments otherwise *instance
+		// types end up as components in composite types.
+		// TODO(gri) explain why this causes problems, if it does
+		targ := expand(targs[i]) // possibly nil
+		targs[i] = targ
+		proj[tpar.typ.(*TypeParam)] = targ
+	}
+	return &substMap{targs, proj}
+}
+
+func (m *substMap) String() string {
+	return fmt.Sprintf("%s", m.proj)
+}
+
+func (m *substMap) empty() bool {
+	return len(m.proj) == 0
+}
+
+func (m *substMap) lookup(tpar *TypeParam) Type {
+	if t := m.proj[tpar]; t != nil {
+		return t
+	}
+	return tpar
+}
+
+func (check *Checker) instantiate(pos token.Pos, typ Type, targs []Type, poslist []token.Pos) (res Type) {
+	if trace {
+		check.trace(pos, "-- instantiating %s with %s", typ, typeListString(targs))
+		check.indent++
+		defer func() {
+			check.indent--
+			var under Type
+			if res != nil {
+				// Calling under() here may lead to endless instantiations.
+				// Test case: type T[P any] T[P]
+				// TODO(gri) investigate if that's a bug or to be expected.
+				under = res.Underlying()
+			}
+			check.trace(pos, "=> %s (under = %s)", res, under)
+		}()
+	}
+
+	assert(len(poslist) <= len(targs))
+
+	// TODO(gri) What is better here: work with TypeParams, or work with TypeNames?
+	var tparams []*TypeName
+	switch t := typ.(type) {
+	case *Named:
+		tparams = t.tparams
+	case *Signature:
+		tparams = t.tparams
+		defer func() {
+			// If we had an unexpected failure somewhere don't panic below when
+			// asserting res.(*Signature). Check for *Signature in case Typ[Invalid]
+			// is returned.
+			if _, ok := res.(*Signature); !ok {
+				return
+			}
+			// If the signature doesn't use its type parameters, subst
+			// will not make a copy. In that case, make a copy now (so
+			// we can set tparams to nil w/o causing side-effects).
+			if t == res {
+				copy := *t
+				res = &copy
+			}
+			// After instantiating a generic signature, it is not generic
+			// anymore; we need to set tparams to nil.
+			res.(*Signature).tparams = nil
+		}()
+
+	default:
+		check.dump("%v: cannot instantiate %v", pos, typ)
+		unreachable() // only defined types and (defined) functions can be generic
+	}
+
+	// the number of supplied types must match the number of type parameters
+	if len(targs) != len(tparams) {
+		// TODO(gri) provide better error message
+		check.errorf(atPos(pos), 0, "got %d arguments but %d type parameters", len(targs), len(tparams))
+		return Typ[Invalid]
+	}
+
+	if len(tparams) == 0 {
+		return typ // nothing to do (minor optimization)
+	}
+
+	smap := makeSubstMap(tparams, targs)
+
+	// check bounds
+	for i, tname := range tparams {
+		tpar := tname.typ.(*TypeParam)
+		iface := tpar.Bound()
+		if iface.Empty() {
+			continue // no type bound
+		}
+
+		targ := targs[i]
+
+		// best position for error reporting
+		pos := pos
+		if i < len(poslist) {
+			pos = poslist[i]
+		}
+
+		// The type parameter bound is parameterized with the same type parameters
+		// as the instantiated type; before we can use it for bounds checking we
+		// need to instantiate it with the type arguments with which we instantiate
+		// the parameterized type.
+		iface = check.subst(pos, iface, smap).(*Interface)
+
+		// targ must implement iface (methods)
+		// - check only if we have methods
+		check.completeInterface(token.NoPos, iface)
+		if len(iface.allMethods) > 0 {
+			// If the type argument is a pointer to a type parameter, the type argument's
+			// method set is empty.
+			// TODO(gri) is this what we want? (spec question)
+			if base, isPtr := deref(targ); isPtr && asTypeParam(base) != nil {
+				check.errorf(atPos(pos), 0, "%s has no methods", targ)
+				break
+			}
+			if m, wrong := check.missingMethod(targ, iface, true); m != nil {
+				// TODO(gri) needs to print updated name to avoid major confusion in error message!
+				//           (print warning for now)
+				// Old warning:
+				// check.softErrorf(pos, "%s does not satisfy %s (warning: name not updated) = %s (missing method %s)", targ, tpar.bound, iface, m)
+				if m.name == "==" {
+					// We don't want to report "missing method ==".
+					check.softErrorf(atPos(pos), 0, "%s does not satisfy comparable", targ)
+				} else if wrong != nil {
+					// TODO(gri) This can still report uninstantiated types which makes the error message
+					//           more difficult to read then necessary.
+					check.softErrorf(atPos(pos), 0,
+						"%s does not satisfy %s: wrong method signature\n\tgot  %s\n\twant %s",
+						targ, tpar.bound, wrong, m,
+					)
+				} else {
+					check.softErrorf(atPos(pos), 0, "%s does not satisfy %s (missing method %s)", targ, tpar.bound, m.name)
+				}
+				break
+			}
+		}
+
+		// targ's underlying type must also be one of the interface types listed, if any
+		if iface.allTypes == nil {
+			continue // nothing to do
+		}
+
+		// If targ is itself a type parameter, each of its possible types, but at least one, must be in the
+		// list of iface types (i.e., the targ type list must be a non-empty subset of the iface types).
+		if targ := asTypeParam(targ); targ != nil {
+			targBound := targ.Bound()
+			if targBound.allTypes == nil {
+				check.softErrorf(atPos(pos), 0, "%s does not satisfy %s (%s has no type constraints)", targ, tpar.bound, targ)
+				break
+			}
+			for _, t := range unpackType(targBound.allTypes) {
+				if !iface.isSatisfiedBy(t) {
+					// TODO(gri) match this error message with the one below (or vice versa)
+					check.softErrorf(atPos(pos), 0, "%s does not satisfy %s (%s type constraint %s not found in %s)", targ, tpar.bound, targ, t, iface.allTypes)
+					break
+				}
+			}
+			break
+		}
+
+		// Otherwise, targ's type or underlying type must also be one of the interface types listed, if any.
+		if !iface.isSatisfiedBy(targ) {
+			check.softErrorf(atPos(pos), 0, "%s does not satisfy %s (%s or %s not found in %s)", targ, tpar.bound, targ, under(targ), iface.allTypes)
+			break
+		}
+	}
+
+	return check.subst(pos, typ, smap)
+}
+
+// subst returns the type typ with its type parameters tpars replaced by
+// the corresponding type arguments targs, recursively.
+// subst is functional in the sense that it doesn't modify the incoming
+// type. If a substitution took place, the result type is different from
+// from the incoming type.
+func (check *Checker) subst(pos token.Pos, typ Type, smap *substMap) Type {
+	if smap.empty() {
+		return typ
+	}
+
+	// common cases
+	switch t := typ.(type) {
+	case *Basic:
+		return typ // nothing to do
+	case *TypeParam:
+		return smap.lookup(t)
+	}
+
+	// general case
+	subst := subster{check, pos, make(map[Type]Type), smap}
+	return subst.typ(typ)
+}
+
+type subster struct {
+	check *Checker
+	pos   token.Pos
+	cache map[Type]Type
+	smap  *substMap
+}
+
+func (subst *subster) typ(typ Type) Type {
+	switch t := typ.(type) {
+	case nil:
+		// Call typOrNil if it's possible that typ is nil.
+		panic("nil typ")
+
+	case *Basic, *bottom, *top:
+		// nothing to do
+
+	case *Array:
+		elem := subst.typOrNil(t.elem)
+		if elem != t.elem {
+			return &Array{len: t.len, elem: elem}
+		}
+
+	case *Slice:
+		elem := subst.typOrNil(t.elem)
+		if elem != t.elem {
+			return &Slice{elem: elem}
+		}
+
+	case *Struct:
+		if fields, copied := subst.varList(t.fields); copied {
+			return &Struct{fields: fields, tags: t.tags}
+		}
+
+	case *Pointer:
+		base := subst.typ(t.base)
+		if base != t.base {
+			return &Pointer{base: base}
+		}
+
+	case *Tuple:
+		return subst.tuple(t)
+
+	case *Signature:
+		// TODO(gri) rethink the recv situation with respect to methods on parameterized types
+		// recv := subst.var_(t.recv) // TODO(gri) this causes a stack overflow - explain
+		recv := t.recv
+		params := subst.tuple(t.params)
+		results := subst.tuple(t.results)
+		if recv != t.recv || params != t.params || results != t.results {
+			return &Signature{
+				rparams: t.rparams,
+				// TODO(rFindley) why can't we nil out tparams here, rather than in
+				//                instantiate above?
+				tparams:  t.tparams,
+				scope:    t.scope,
+				recv:     recv,
+				params:   params,
+				results:  results,
+				variadic: t.variadic,
+			}
+		}
+
+	case *Sum:
+		types, copied := subst.typeList(t.types)
+		if copied {
+			// Don't do it manually, with a Sum literal: the new
+			// types list may not be unique and NewSum may remove
+			// duplicates.
+			return NewSum(types)
+		}
+
+	case *Interface:
+		methods, mcopied := subst.funcList(t.methods)
+		types := t.types
+		if t.types != nil {
+			types = subst.typ(t.types)
+		}
+		embeddeds, ecopied := subst.typeList(t.embeddeds)
+		if mcopied || types != t.types || ecopied {
+			iface := &Interface{methods: methods, types: types, embeddeds: embeddeds}
+			subst.check.posMap[iface] = subst.check.posMap[t] // satisfy completeInterface requirement
+			subst.check.completeInterface(token.NoPos, iface)
+			return iface
+		}
+
+	case *Map:
+		key := subst.typ(t.key)
+		elem := subst.typ(t.elem)
+		if key != t.key || elem != t.elem {
+			return &Map{key: key, elem: elem}
+		}
+
+	case *Chan:
+		elem := subst.typ(t.elem)
+		if elem != t.elem {
+			return &Chan{dir: t.dir, elem: elem}
+		}
+
+	case *Named:
+		subst.check.indent++
+		defer func() {
+			subst.check.indent--
+		}()
+		dump := func(format string, args ...interface{}) {
+			if trace {
+				subst.check.trace(subst.pos, format, args...)
+			}
+		}
+
+		if t.tparams == nil {
+			dump(">>> %s is not parameterized", t)
+			return t // type is not parameterized
+		}
+
+		var newTargs []Type
+
+		if len(t.targs) > 0 {
+			// already instantiated
+			dump(">>> %s already instantiated", t)
+			assert(len(t.targs) == len(t.tparams))
+			// For each (existing) type argument targ, determine if it needs
+			// to be substituted; i.e., if it is or contains a type parameter
+			// that has a type argument for it.
+			for i, targ := range t.targs {
+				dump(">>> %d targ = %s", i, targ)
+				newTarg := subst.typ(targ)
+				if newTarg != targ {
+					dump(">>> substituted %d targ %s => %s", i, targ, newTarg)
+					if newTargs == nil {
+						newTargs = make([]Type, len(t.tparams))
+						copy(newTargs, t.targs)
+					}
+					newTargs[i] = newTarg
+				}
+			}
+
+			if newTargs == nil {
+				dump(">>> nothing to substitute in %s", t)
+				return t // nothing to substitute
+			}
+		} else {
+			// not yet instantiated
+			dump(">>> first instantiation of %s", t)
+			// TODO(rFindley) can we instead subst the tparam types here?
+			newTargs = subst.smap.targs
+		}
+
+		// before creating a new named type, check if we have this one already
+		h := instantiatedHash(t, newTargs)
+		dump(">>> new type hash: %s", h)
+		if named, found := subst.check.typMap[h]; found {
+			dump(">>> found %s", named)
+			subst.cache[t] = named
+			return named
+		}
+
+		// create a new named type and populate caches to avoid endless recursion
+		tname := NewTypeName(subst.pos, t.obj.pkg, t.obj.name, nil)
+		named := subst.check.NewNamed(tname, t.underlying, t.methods) // method signatures are updated lazily
+		named.tparams = t.tparams                                     // new type is still parameterized
+		named.targs = newTargs
+		subst.check.typMap[h] = named
+		subst.cache[t] = named
+
+		// do the substitution
+		dump(">>> subst %s with %s (new: %s)", t.underlying, subst.smap, newTargs)
+		named.underlying = subst.typOrNil(t.underlying)
+		named.orig = named.underlying // for cycle detection (Checker.validType)
+
+		return named
+
+	case *TypeParam:
+		return subst.smap.lookup(t)
+
+	case *instance:
+		// TODO(gri) can we avoid the expansion here and just substitute the type parameters?
+		return subst.typ(t.expand())
+
+	default:
+		panic("unimplemented")
+	}
+
+	return typ
+}
+
+// TODO(gri) Eventually, this should be more sophisticated.
+//           It won't work correctly for locally declared types.
+func instantiatedHash(typ *Named, targs []Type) string {
+	var buf bytes.Buffer
+	writeTypeName(&buf, typ.obj, nil)
+	buf.WriteByte('[')
+	writeTypeList(&buf, targs, nil, nil)
+	buf.WriteByte(']')
+
+	// With respect to the represented type, whether a
+	// type is fully expanded or stored as instance
+	// does not matter - they are the same types.
+	// Remove the instanceMarkers printed for instances.
+	res := buf.Bytes()
+	i := 0
+	for _, b := range res {
+		if b != instanceMarker {
+			res[i] = b
+			i++
+		}
+	}
+
+	return string(res[:i])
+}
+
+func typeListString(list []Type) string {
+	var buf bytes.Buffer
+	writeTypeList(&buf, list, nil, nil)
+	return buf.String()
+}
+
+// typOrNil is like typ but if the argument is nil it is replaced with Typ[Invalid].
+// A nil type may appear in pathological cases such as type T[P any] []func(_ T([]_))
+// where an array/slice element is accessed before it is set up.
+func (subst *subster) typOrNil(typ Type) Type {
+	if typ == nil {
+		return Typ[Invalid]
+	}
+	return subst.typ(typ)
+}
+
+func (subst *subster) var_(v *Var) *Var {
+	if v != nil {
+		if typ := subst.typ(v.typ); typ != v.typ {
+			copy := *v
+			copy.typ = typ
+			return &copy
+		}
+	}
+	return v
+}
+
+func (subst *subster) tuple(t *Tuple) *Tuple {
+	if t != nil {
+		if vars, copied := subst.varList(t.vars); copied {
+			return &Tuple{vars: vars}
+		}
+	}
+	return t
+}
+
+func (subst *subster) varList(in []*Var) (out []*Var, copied bool) {
+	out = in
+	for i, v := range in {
+		if w := subst.var_(v); w != v {
+			if !copied {
+				// first variable that got substituted => allocate new out slice
+				// and copy all variables
+				new := make([]*Var, len(in))
+				copy(new, out)
+				out = new
+				copied = true
+			}
+			out[i] = w
+		}
+	}
+	return
+}
+
+func (subst *subster) func_(f *Func) *Func {
+	if f != nil {
+		if typ := subst.typ(f.typ); typ != f.typ {
+			copy := *f
+			copy.typ = typ
+			return &copy
+		}
+	}
+	return f
+}
+
+func (subst *subster) funcList(in []*Func) (out []*Func, copied bool) {
+	out = in
+	for i, f := range in {
+		if g := subst.func_(f); g != f {
+			if !copied {
+				// first function that got substituted => allocate new out slice
+				// and copy all functions
+				new := make([]*Func, len(in))
+				copy(new, out)
+				out = new
+				copied = true
+			}
+			out[i] = g
+		}
+	}
+	return
+}
+
+func (subst *subster) typeList(in []Type) (out []Type, copied bool) {
+	out = in
+	for i, t := range in {
+		if u := subst.typ(t); u != t {
+			if !copied {
+				// first function that got substituted => allocate new out slice
+				// and copy all functions
+				new := make([]Type, len(in))
+				copy(new, out)
+				out = new
+				copied = true
+			}
+			out[i] = u
+		}
+	}
+	return
+}
diff --git a/src/go/types/type.go b/src/go/types/type.go
index e0cff1b976..0fcefefb73 100644
--- a/src/go/types/type.go
+++ b/src/go/types/type.go
@@ -313,7 +313,6 @@ type Interface struct {
 	allTypes   Type    // intersection of all embedded and locally declared types  (TODO(gri) need better field name)
 
 	obj Object // type declaration defining this interface; or nil (for better error messages)
-
 }
 
 // unpack unpacks a type into a list of types.
@@ -669,6 +668,14 @@ func NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named {
 	return typ
 }
 
+func (check *Checker) NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named {
+	typ := &Named{check: check, obj: obj, orig: underlying, underlying: underlying, methods: methods}
+	if obj.typ == nil {
+		obj.typ = typ
+	}
+	return typ
+}
+
 // Obj returns the type name for the named type t.
 func (t *Named) Obj() *TypeName { return t.obj }
 
@@ -713,16 +720,15 @@ func (t *Named) AddMethod(m *Func) {
 type TypeParam struct {
 	check *Checker  // for lazy type bound completion
 	id    uint64    // unique id
-	ptr   bool      // pointer designation
 	obj   *TypeName // corresponding type name
 	index int       // parameter index
 	bound Type      // *Named or *Interface; underlying type is always *Interface
 }
 
 // NewTypeParam returns a new TypeParam.
-func (check *Checker) NewTypeParam(ptr bool, obj *TypeName, index int, bound Type) *TypeParam {
+func (check *Checker) NewTypeParam(obj *TypeName, index int, bound Type) *TypeParam {
 	assert(bound != nil)
-	typ := &TypeParam{check: check, id: check.nextId, ptr: ptr, obj: obj, index: index, bound: bound}
+	typ := &TypeParam{check: check, id: check.nextId, obj: obj, index: index, bound: bound}
 	check.nextId++
 	if obj.typ == nil {
 		obj.typ = typ
@@ -783,8 +789,19 @@ type instance struct {
 // The result is either an instantiated *Named type, or
 // Typ[Invalid] if there was an error.
 func (t *instance) expand() Type {
-	// TODO(rFindley) add this in a follow-up CL.
-	panic("not implemented")
+	v := t.value
+	if v == nil {
+		v = t.check.instantiate(t.pos, t.base, t.targs, t.poslist)
+		if v == nil {
+			v = Typ[Invalid]
+		}
+		t.value = v
+	}
+	// After instantiation we must have an invalid or a *Named type.
+	if debug && v != Typ[Invalid] {
+		_ = v.(*Named)
+	}
+	return v
 }
 
 // expand expands a type instance into its instantiated
diff --git a/src/go/types/typestring.go b/src/go/types/typestring.go
index b9c227d460..64bbb33505 100644
--- a/src/go/types/typestring.go
+++ b/src/go/types/typestring.go
@@ -333,9 +333,6 @@ func writeTParamList(buf *bytes.Buffer, list []*TypeName, qf Qualifier, visited
 		prev = b
 
 		if t, _ := p.typ.(*TypeParam); t != nil {
-			if t.ptr {
-				buf.WriteByte('*')
-			}
 			writeType(buf, t, qf, visited)
 		} else {
 			buf.WriteString(p.name)
-- 
GitLab


From fea898a4b0f02cee08ea978eb5ce541a85783690 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Sat, 28 Nov 2020 15:53:32 -0800
Subject: [PATCH 0220/2400] [dev.regabi] cmd/compile: intercept the making of
 OADDR nodes

This is a mechanical change to intercept the construction of
all OADDR nodes. We will use the new nodAddr and nodAddrAt
functions to compute the Addrtaken bit.

Change-Id: I90ee3acb8e32540a198a9999284573418729f422
Reviewed-on: https://go-review.googlesource.com/c/go/+/275694
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Keith Randall <khr@golang.org>
Trust: Dan Scales <danscales@google.com>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/gc/alg.go       | 10 +++---
 src/cmd/compile/internal/gc/closure.go   | 10 +++---
 src/cmd/compile/internal/gc/iimport.go   |  4 ++-
 src/cmd/compile/internal/gc/inl.go       |  2 +-
 src/cmd/compile/internal/gc/range.go     |  8 ++---
 src/cmd/compile/internal/gc/reflect.go   |  6 ++--
 src/cmd/compile/internal/gc/select.go    | 14 ++++----
 src/cmd/compile/internal/gc/sinit.go     |  6 ++--
 src/cmd/compile/internal/gc/subr.go      | 10 +++++-
 src/cmd/compile/internal/gc/typecheck.go |  6 ++--
 src/cmd/compile/internal/gc/walk.go      | 46 ++++++++++++------------
 11 files changed, 66 insertions(+), 56 deletions(-)

diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index ea57e7398d..7540944201 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -323,7 +323,7 @@ func genhash(t *types.Type) *obj.LSym {
 
 		nx := ir.Nod(ir.OINDEX, np, ni)
 		nx.SetBounded(true)
-		na := ir.Nod(ir.OADDR, nx, nil)
+		na := nodAddr(nx)
 		call.PtrList().Append(na)
 		call.PtrList().Append(nh)
 		loop.PtrBody().Append(ir.Nod(ir.OAS, nh, call))
@@ -347,7 +347,7 @@ func genhash(t *types.Type) *obj.LSym {
 				hashel := hashfor(f.Type)
 				call := ir.Nod(ir.OCALL, hashel, nil)
 				nx := nodSym(ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
-				na := ir.Nod(ir.OADDR, nx, nil)
+				na := nodAddr(nx)
 				call.PtrList().Append(na)
 				call.PtrList().Append(nh)
 				fn.PtrBody().Append(ir.Nod(ir.OAS, nh, call))
@@ -362,7 +362,7 @@ func genhash(t *types.Type) *obj.LSym {
 			hashel := hashmem(f.Type)
 			call := ir.Nod(ir.OCALL, hashel, nil)
 			nx := nodSym(ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
-			na := ir.Nod(ir.OADDR, nx, nil)
+			na := nodAddr(nx)
 			call.PtrList().Append(na)
 			call.PtrList().Append(nh)
 			call.PtrList().Append(nodintconst(size))
@@ -868,8 +868,8 @@ func eqinterface(s, t ir.Node) (eqtab, eqdata ir.Node) {
 // eqmem returns the node
 // 	memequal(&p.field, &q.field [, size])
 func eqmem(p ir.Node, q ir.Node, field *types.Sym, size int64) ir.Node {
-	nx := ir.Nod(ir.OADDR, nodSym(ir.OXDOT, p, field), nil)
-	ny := ir.Nod(ir.OADDR, nodSym(ir.OXDOT, q, field), nil)
+	nx := nodAddr(nodSym(ir.OXDOT, p, field))
+	ny := nodAddr(nodSym(ir.OXDOT, q, field))
 	nx = typecheck(nx, ctxExpr)
 	ny = typecheck(ny, ctxExpr)
 
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index b56e255d10..a3d8a46977 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -199,7 +199,7 @@ func capturevars(fn *ir.Func) {
 			v.SetByval(true)
 		} else {
 			outermost.Name().SetAddrtaken(true)
-			outer = ir.Nod(ir.OADDR, outer, nil)
+			outer = nodAddr(outer)
 		}
 
 		if base.Flag.LowerM > 1 {
@@ -309,7 +309,7 @@ func transformclosure(fn *ir.Func) {
 				v.Heapaddr = addr
 				var src ir.Node = cr
 				if v.Byval() {
-					src = ir.Nod(ir.OADDR, cr, nil)
+					src = nodAddr(cr)
 				}
 				body = append(body, ir.Nod(ir.OAS, addr, src))
 			}
@@ -396,7 +396,7 @@ func walkclosure(clo ir.Node, init *ir.Nodes) ir.Node {
 	clos.SetEsc(clo.Esc())
 	clos.PtrList().Set(append([]ir.Node{ir.Nod(ir.OCFUNC, fn.Nname, nil)}, fn.ClosureEnter.Slice()...))
 
-	clos = ir.Nod(ir.OADDR, clos, nil)
+	clos = nodAddr(clos)
 	clos.SetEsc(clo.Esc())
 
 	// Force type conversion from *struct to the func type.
@@ -475,7 +475,7 @@ func makepartialcall(dot ir.Node, t0 *types.Type, meth *types.Sym) *ir.Func {
 		body = append(body, ir.Nod(ir.OAS, ptr, cr))
 	} else {
 		ptr.SetType(types.NewPtr(rcvrtype))
-		body = append(body, ir.Nod(ir.OAS, ptr, ir.Nod(ir.OADDR, cr, nil)))
+		body = append(body, ir.Nod(ir.OAS, ptr, nodAddr(cr)))
 	}
 
 	call := ir.Nod(ir.OCALL, nodSym(ir.OXDOT, ptr, meth), nil)
@@ -544,7 +544,7 @@ func walkpartialcall(n *ir.CallPartExpr, init *ir.Nodes) ir.Node {
 	clos.SetEsc(n.Esc())
 	clos.PtrList().Set2(ir.Nod(ir.OCFUNC, n.Func().Nname, nil), n.Left())
 
-	clos = ir.Nod(ir.OADDR, clos, nil)
+	clos = nodAddr(clos)
 	clos.SetEsc(n.Esc())
 
 	// Force type conversion from *struct to the func type.
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 3c9693e5fc..194c7427f3 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -943,8 +943,10 @@ func (r *importReader) node() ir.Node {
 		return n
 
 	// unary expressions
-	case ir.OPLUS, ir.ONEG, ir.OADDR, ir.OBITNOT, ir.ODEREF, ir.ONOT, ir.ORECV:
+	case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ODEREF, ir.ONOT, ir.ORECV:
 		return ir.NodAt(r.pos(), op, r.expr(), nil)
+	case ir.OADDR:
+		return nodAddrAt(r.pos(), r.expr())
 
 	// binary expressions
 	case ir.OADD, ir.OAND, ir.OANDAND, ir.OANDNOT, ir.ODIV, ir.OEQ, ir.OGE, ir.OGT, ir.OLE, ir.OLT,
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 37e5167c25..3c17f7d87f 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -878,7 +878,7 @@ func mkinlcall(n ir.Node, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]bool,
 				addr.SetType(types.NewPtr(v.Type()))
 				ia := typecheck(inlvar(addr), ctxExpr)
 				ninit.Append(ir.Nod(ir.ODCL, ia, nil))
-				ninit.Append(typecheck(ir.Nod(ir.OAS, ia, ir.Nod(ir.OADDR, o, nil)), ctxStmt))
+				ninit.Append(typecheck(ir.Nod(ir.OAS, ia, nodAddr(o)), ctxStmt))
 				inlvars[addr] = ia
 
 				// When capturing by reference, all occurrence of the captured var
diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index 8025119c5e..2589da7b5d 100644
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -274,7 +274,7 @@ func walkrange(nrange ir.Node) ir.Node {
 		hp := temp(types.NewPtr(nrange.Type().Elem()))
 		tmp := ir.Nod(ir.OINDEX, ha, nodintconst(0))
 		tmp.SetBounded(true)
-		init = append(init, ir.Nod(ir.OAS, hp, ir.Nod(ir.OADDR, tmp, nil)))
+		init = append(init, ir.Nod(ir.OAS, hp, nodAddr(tmp)))
 
 		// Use OAS2 to correctly handle assignments
 		// of the form "v1, a[v1] := range".
@@ -305,12 +305,12 @@ func walkrange(nrange ir.Node) ir.Node {
 		fn := syslook("mapiterinit")
 
 		fn = substArgTypes(fn, t.Key(), t.Elem(), th)
-		init = append(init, mkcall1(fn, nil, nil, typename(t), ha, ir.Nod(ir.OADDR, hit, nil)))
+		init = append(init, mkcall1(fn, nil, nil, typename(t), ha, nodAddr(hit)))
 		nfor.SetLeft(ir.Nod(ir.ONE, nodSym(ir.ODOT, hit, keysym), nodnil()))
 
 		fn = syslook("mapiternext")
 		fn = substArgTypes(fn, th)
-		nfor.SetRight(mkcall1(fn, nil, nil, ir.Nod(ir.OADDR, hit, nil)))
+		nfor.SetRight(mkcall1(fn, nil, nil, nodAddr(hit)))
 
 		key := nodSym(ir.ODOT, hit, keysym)
 		key = ir.Nod(ir.ODEREF, key, nil)
@@ -572,7 +572,7 @@ func arrayClear(loop, v1, v2, a ir.Node) ir.Node {
 
 	tmp := ir.Nod(ir.OINDEX, a, nodintconst(0))
 	tmp.SetBounded(true)
-	tmp = ir.Nod(ir.OADDR, tmp, nil)
+	tmp = nodAddr(tmp)
 	tmp = convnop(tmp, types.Types[types.TUNSAFEPTR])
 	n.PtrBody().Append(ir.Nod(ir.OAS, hp, tmp))
 
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 9b8f26a84b..cfff1baad6 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -996,7 +996,7 @@ func typename(t *types.Type) ir.Node {
 		s.Def = n
 	}
 
-	n := ir.Nod(ir.OADDR, ir.AsNode(s.Def), nil)
+	n := nodAddr(ir.AsNode(s.Def))
 	n.SetType(types.NewPtr(s.Def.Type()))
 	n.SetTypecheck(1)
 	return n
@@ -1016,7 +1016,7 @@ func itabname(t, itype *types.Type) ir.Node {
 		itabs = append(itabs, itabEntry{t: t, itype: itype, lsym: s.Linksym()})
 	}
 
-	n := ir.Nod(ir.OADDR, ir.AsNode(s.Def), nil)
+	n := nodAddr(ir.AsNode(s.Def))
 	n.SetType(types.NewPtr(s.Def.Type()))
 	n.SetTypecheck(1)
 	return n
@@ -1880,7 +1880,7 @@ func zeroaddr(size int64) ir.Node {
 		x.SetTypecheck(1)
 		s.Def = x
 	}
-	z := ir.Nod(ir.OADDR, ir.AsNode(s.Def), nil)
+	z := nodAddr(ir.AsNode(s.Def))
 	z.SetType(types.NewPtr(types.Types[types.TUINT8]))
 	z.SetTypecheck(1)
 	return z
diff --git a/src/cmd/compile/internal/gc/select.go b/src/cmd/compile/internal/gc/select.go
index 3afcef69f8..ec59f08638 100644
--- a/src/cmd/compile/internal/gc/select.go
+++ b/src/cmd/compile/internal/gc/select.go
@@ -171,18 +171,18 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 
 		switch n.Op() {
 		case ir.OSEND:
-			n.SetRight(ir.Nod(ir.OADDR, n.Right(), nil))
+			n.SetRight(nodAddr(n.Right()))
 			n.SetRight(typecheck(n.Right(), ctxExpr))
 
 		case ir.OSELRECV:
 			if !ir.IsBlank(n.Left()) {
-				n.SetLeft(ir.Nod(ir.OADDR, n.Left(), nil))
+				n.SetLeft(nodAddr(n.Left()))
 				n.SetLeft(typecheck(n.Left(), ctxExpr))
 			}
 
 		case ir.OSELRECV2:
 			if !ir.IsBlank(n.List().First()) {
-				n.List().SetIndex(0, ir.Nod(ir.OADDR, n.List().First(), nil))
+				n.List().SetIndex(0, nodAddr(n.List().First()))
 				n.List().SetIndex(0, typecheck(n.List().First(), ctxExpr))
 			}
 		}
@@ -225,7 +225,7 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 			if ir.IsBlank(elem) {
 				elem = nodnil()
 			}
-			receivedp := ir.Nod(ir.OADDR, n.List().Second(), nil)
+			receivedp := nodAddr(n.List().Second())
 			receivedp = typecheck(receivedp, ctxExpr)
 			call = mkcall1(chanfn("selectnbrecv2", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), elem, receivedp, ch)
 		}
@@ -257,7 +257,7 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 	var pc0, pcs ir.Node
 	if base.Flag.Race {
 		pcs = temp(types.NewArray(types.Types[types.TUINTPTR], int64(ncas)))
-		pc0 = typecheck(ir.Nod(ir.OADDR, ir.Nod(ir.OINDEX, pcs, nodintconst(0)), nil), ctxExpr)
+		pc0 = typecheck(nodAddr(ir.Nod(ir.OINDEX, pcs, nodintconst(0))), ctxExpr)
 	} else {
 		pc0 = nodnil()
 	}
@@ -314,7 +314,7 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 		// TODO(mdempsky): There should be a cleaner way to
 		// handle this.
 		if base.Flag.Race {
-			r = mkcall("selectsetpc", nil, nil, ir.Nod(ir.OADDR, ir.Nod(ir.OINDEX, pcs, nodintconst(int64(i))), nil))
+			r = mkcall("selectsetpc", nil, nil, nodAddr(ir.Nod(ir.OINDEX, pcs, nodintconst(int64(i)))))
 			init = append(init, r)
 		}
 	}
@@ -372,7 +372,7 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 
 // bytePtrToIndex returns a Node representing "(*byte)(&n[i])".
 func bytePtrToIndex(n ir.Node, i int64) ir.Node {
-	s := ir.Nod(ir.OADDR, ir.Nod(ir.OINDEX, n, nodintconst(i)), nil)
+	s := nodAddr(ir.Nod(ir.OINDEX, n, nodintconst(i)))
 	t := types.NewPtr(types.Types[types.TUINT8])
 	return convnop(s, t)
 }
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 3c5f11c5ab..646c8dafce 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -675,7 +675,7 @@ func slicelit(ctxt initContext, n ir.Node, var_ ir.Node, init *ir.Nodes) {
 			init.Append(ir.Nod(ir.OVARDEF, x, nil))
 		}
 
-		a = ir.Nod(ir.OADDR, x, nil)
+		a = nodAddr(x)
 	} else if n.Esc() == EscNone {
 		a = temp(t)
 		if vstat == nil {
@@ -687,7 +687,7 @@ func slicelit(ctxt initContext, n ir.Node, var_ ir.Node, init *ir.Nodes) {
 			init.Append(ir.Nod(ir.OVARDEF, a, nil))
 		}
 
-		a = ir.Nod(ir.OADDR, a, nil)
+		a = nodAddr(a)
 	} else {
 		a = ir.Nod(ir.ONEW, ir.TypeNode(t), nil)
 	}
@@ -888,7 +888,7 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 		if n.Right() != nil {
 			// n.Right is stack temporary used as backing store.
 			init.Append(ir.Nod(ir.OAS, n.Right(), nil)) // zero backing store, just in case (#18410)
-			r = ir.Nod(ir.OADDR, n.Right(), nil)
+			r = nodAddr(n.Right())
 			r = typecheck(r, ctxExpr)
 		} else {
 			r = ir.Nod(ir.ONEW, ir.TypeNode(n.Left().Type()), nil)
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index e05a124b29..42f8982c80 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -135,6 +135,14 @@ func importdot(opkg *types.Pkg, pack *ir.PkgName) {
 	}
 }
 
+// nodAddr returns a node representing &n.
+func nodAddr(n ir.Node) ir.Node {
+	return ir.Nod(ir.OADDR, n, nil)
+}
+func nodAddrAt(pos src.XPos, n ir.Node) ir.Node {
+	return ir.NodAt(pos, ir.OADDR, n, nil)
+}
+
 // newname returns a new ONAME Node associated with symbol s.
 func NewName(s *types.Sym) *ir.Name {
 	n := ir.NewNameAt(base.Pos, s)
@@ -1158,7 +1166,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 		dot = dot.Left() // skip final .M
 		// TODO(mdempsky): Remove dependency on dotlist.
 		if !dotlist[0].field.Type.IsPtr() {
-			dot = ir.Nod(ir.OADDR, dot, nil)
+			dot = nodAddr(dot)
 		}
 		as := ir.Nod(ir.OAS, nthis, convnop(dot, rcvr))
 		fn.PtrBody().Append(as)
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index f187880e28..ad161b59f0 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -1274,7 +1274,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				return n
 			}
 
-			n.SetLeft(ir.Nod(ir.OADDR, n.Left(), nil))
+			n.SetLeft(nodAddr(n.Left()))
 			n.Left().SetImplicit(true)
 			n.SetLeft(typecheck(n.Left(), ctxExpr))
 			l = n.Left()
@@ -2462,7 +2462,7 @@ func lookdot(n ir.Node, t *types.Type, dostrcmp int) *types.Field {
 		if !types.Identical(rcvr, tt) {
 			if rcvr.IsPtr() && types.Identical(rcvr.Elem(), tt) {
 				checklvalue(n.Left(), "call pointer method on")
-				n.SetLeft(ir.Nod(ir.OADDR, n.Left(), nil))
+				n.SetLeft(nodAddr(n.Left()))
 				n.Left().SetImplicit(true)
 				n.SetLeft(typecheck(n.Left(), ctxType|ctxExpr))
 			} else if tt.IsPtr() && (!rcvr.IsPtr() || rcvr.IsPtr() && rcvr.Elem().NotInHeap()) && types.Identical(tt.Elem(), rcvr) {
@@ -2747,7 +2747,7 @@ func pushtype(n ir.Node, t *types.Type) ir.Node {
 		// For *T, return &T{...}.
 		n.SetRight(ir.TypeNode(t.Elem()))
 
-		n = ir.NodAt(n.Pos(), ir.OADDR, n, nil)
+		n = nodAddrAt(n.Pos(), n)
 		n.SetImplicit(true)
 	}
 
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 390719e441..bbd81de40e 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -615,7 +615,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return mkcall("gopanic", nil, init, n.Left())
 
 	case ir.ORECOVER:
-		return mkcall("gorecover", n.Type(), init, ir.Nod(ir.OADDR, nodfp, nil))
+		return mkcall("gorecover", n.Type(), init, nodAddr(nodfp))
 
 	case ir.OCLOSUREREAD, ir.OCFUNC:
 		return n
@@ -694,7 +694,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			// order.stmt made sure x is addressable.
 			n.Right().SetLeft(walkexpr(n.Right().Left(), init))
 
-			n1 := ir.Nod(ir.OADDR, n.Left(), nil)
+			n1 := nodAddr(n.Left())
 			r := n.Right().Left() // the channel
 			return mkcall1(chanfn("chanrecv1", 2, r.Type()), nil, init, r, n1)
 
@@ -767,7 +767,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		if ir.IsBlank(n.List().First()) {
 			n1 = nodnil()
 		} else {
-			n1 = ir.Nod(ir.OADDR, n.List().First(), nil)
+			n1 = nodAddr(n.List().First())
 		}
 		fn := chanfn("chanrecv2", 2, r.Left().Type())
 		ok := n.List().Second()
@@ -793,7 +793,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		} else {
 			// standard version takes key by reference
 			// order.expr made sure key is addressable.
-			key = ir.Nod(ir.OADDR, r.Right(), nil)
+			key = nodAddr(r.Right())
 		}
 
 		// from:
@@ -846,7 +846,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		fast := mapfast(t)
 		if fast == mapslow {
 			// order.stmt made sure key is addressable.
-			key = ir.Nod(ir.OADDR, key, nil)
+			key = nodAddr(key)
 		}
 		return mkcall1(mapfndel(mapdelete[fast], t), nil, init, typename(t), map_, key)
 
@@ -924,7 +924,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		if value != nil {
 			// Value is identical to n.Left.
 			// Construct the interface directly: {type/itab, &value}.
-			l := ir.Nod(ir.OEFACE, typeword(), typecheck(ir.Nod(ir.OADDR, value, nil), ctxExpr))
+			l := ir.Nod(ir.OEFACE, typeword(), typecheck(nodAddr(value), ctxExpr))
 			l.SetType(toType)
 			l.SetTypecheck(n.Typecheck())
 			return l
@@ -998,7 +998,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			if !islvalue(v) {
 				v = copyexpr(v, v.Type(), init)
 			}
-			v = ir.Nod(ir.OADDR, v, nil)
+			v = nodAddr(v)
 		}
 
 		dowidth(fromType)
@@ -1145,7 +1145,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			if fast == mapslow {
 				// standard version takes key by reference.
 				// order.expr made sure key is addressable.
-				key = ir.Nod(ir.OADDR, key, nil)
+				key = nodAddr(key)
 			}
 			n = mkcall1(mapfn(mapassign[fast], t), nil, init, typename(t), map_, key)
 		} else {
@@ -1154,7 +1154,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			if fast == mapslow {
 				// standard version takes key by reference.
 				// order.expr made sure key is addressable.
-				key = ir.Nod(ir.OADDR, key, nil)
+				key = nodAddr(key)
 			}
 
 			if w := t.Elem().Width; w <= zeroValSize {
@@ -1226,7 +1226,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			r = ir.Nod(ir.OAS, r, nil) // zero temp
 			r = typecheck(r, ctxStmt)
 			init.Append(r)
-			r = ir.Nod(ir.OADDR, r.Left(), nil)
+			r = nodAddr(r.Left())
 			return typecheck(r, ctxExpr)
 		}
 		return callnew(n.Type().Elem())
@@ -1281,7 +1281,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			zero = typecheck(zero, ctxStmt)
 			init.Append(zero)
 			// h = &hv
-			h = ir.Nod(ir.OADDR, hv, nil)
+			h = nodAddr(hv)
 
 			// Allocate one bucket pointed to by hmap.buckets on stack if hint
 			// is not larger than BUCKETSIZE. In case hint is larger than
@@ -1309,7 +1309,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 				nif.PtrBody().Append(zero)
 
 				// b = &bv
-				b := ir.Nod(ir.OADDR, bv, nil)
+				b := nodAddr(bv)
 
 				// h.buckets = b
 				bsym := hmapType.Field(5).Sym // hmap.buckets see reflect.go:hmap
@@ -1515,7 +1515,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		a := nodnil()
 		if n.Esc() == EscNone {
 			t := types.NewArray(types.Types[types.TUINT8], 4)
-			a = ir.Nod(ir.OADDR, temp(t), nil)
+			a = nodAddr(temp(t))
 		}
 		// intstring(*[4]byte, rune)
 		return mkcall("intstring", n.Type(), init, a, conv(n.Left(), types.Types[types.TINT64]))
@@ -1525,7 +1525,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		if n.Esc() == EscNone {
 			// Create temporary buffer for string on stack.
 			t := types.NewArray(types.Types[types.TUINT8], tmpstringbufsize)
-			a = ir.Nod(ir.OADDR, temp(t), nil)
+			a = nodAddr(temp(t))
 		}
 		if n.Op() == ir.ORUNES2STR {
 			// slicerunetostring(*[32]byte, []rune) string
@@ -1557,7 +1557,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			t := types.NewArray(types.Types[types.TUINT8], int64(len(sc)))
 			var a ir.Node
 			if n.Esc() == EscNone && len(sc) <= int(maxImplicitStackVarSize) {
-				a = ir.Nod(ir.OADDR, temp(t), nil)
+				a = nodAddr(temp(t))
 			} else {
 				a = callnew(t)
 			}
@@ -1585,7 +1585,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		if n.Esc() == EscNone {
 			// Create temporary buffer for slice on stack.
 			t := types.NewArray(types.Types[types.TUINT8], tmpstringbufsize)
-			a = ir.Nod(ir.OADDR, temp(t), nil)
+			a = nodAddr(temp(t))
 		}
 		// stringtoslicebyte(*32[byte], string) []byte
 		return mkcall("stringtoslicebyte", n.Type(), init, a, conv(s, types.Types[types.TSTRING]))
@@ -1606,7 +1606,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		if n.Esc() == EscNone {
 			// Create temporary buffer for slice on stack.
 			t := types.NewArray(types.Types[types.TINT32], tmpstringbufsize)
-			a = ir.Nod(ir.OADDR, temp(t), nil)
+			a = nodAddr(temp(t))
 		}
 		// stringtoslicerune(*[32]rune, string) []rune
 		return mkcall("stringtoslicerune", n.Type(), init, a, conv(n.Left(), types.Types[types.TSTRING]))
@@ -1627,7 +1627,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		n1 := n.Right()
 		n1 = assignconv(n1, n.Left().Type().Elem(), "chan send")
 		n1 = walkexpr(n1, init)
-		n1 = ir.Nod(ir.OADDR, n1, nil)
+		n1 = nodAddr(n1)
 		return mkcall1(chanfn("chansend1", 2, n.Left().Type()), nil, init, n.Left(), n1)
 
 	case ir.OCLOSURE:
@@ -2699,7 +2699,7 @@ func addstr(n ir.Node, init *ir.Nodes) ir.Node {
 		if sz < tmpstringbufsize {
 			// Create temporary buffer for result string on stack.
 			t := types.NewArray(types.Types[types.TUINT8], tmpstringbufsize)
-			buf = ir.Nod(ir.OADDR, temp(t), nil)
+			buf = nodAddr(temp(t))
 		}
 	}
 
@@ -2842,7 +2842,7 @@ func appendslice(n ir.Node, init *ir.Nodes) ir.Node {
 		// memmove(&s[len(l1)], &l2[0], len(l2)*sizeof(T))
 		nptr1 := ir.Nod(ir.OINDEX, s, ir.Nod(ir.OLEN, l1, nil))
 		nptr1.SetBounded(true)
-		nptr1 = ir.Nod(ir.OADDR, nptr1, nil)
+		nptr1 = nodAddr(nptr1)
 
 		nptr2 := ir.Nod(ir.OSPTR, l2, nil)
 
@@ -2988,7 +2988,7 @@ func extendslice(n ir.Node, init *ir.Nodes) ir.Node {
 	// hp := &s[len(l1)]
 	hp := ir.Nod(ir.OINDEX, s, ir.Nod(ir.OLEN, l1, nil))
 	hp.SetBounded(true)
-	hp = ir.Nod(ir.OADDR, hp, nil)
+	hp = nodAddr(hp)
 	hp = convnop(hp, types.Types[types.TUNSAFEPTR])
 
 	// hn := l2 * sizeof(elem(s))
@@ -3372,8 +3372,8 @@ func walkcompare(n ir.Node, init *ir.Nodes) ir.Node {
 
 		fn, needsize := eqfor(t)
 		call := ir.Nod(ir.OCALL, fn, nil)
-		call.PtrList().Append(ir.Nod(ir.OADDR, cmpl, nil))
-		call.PtrList().Append(ir.Nod(ir.OADDR, cmpr, nil))
+		call.PtrList().Append(nodAddr(cmpl))
+		call.PtrList().Append(nodAddr(cmpr))
 		if needsize {
 			call.PtrList().Append(nodintconst(t.Width))
 		}
-- 
GitLab


From 5aff757efc1562e14e53c74bb17b2374b45bc172 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 14 Dec 2020 16:07:05 -0800
Subject: [PATCH 0221/2400] [dev.typeparams] cmd/compile/internal/gc: provide
 types2 selection info to noder

Change-Id: I231e3a1c9f663e2a63c0ad73d571c7a00005f50b
Reviewed-on: https://go-review.googlesource.com/c/go/+/278092
Trust: Robert Griesemer <gri@golang.org>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/gc/noder.go | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 7ec81e34b0..8ae88a100c 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -114,9 +114,10 @@ func parseFiles(filenames []string) (lines uint) {
 			},
 		}
 		info := types2.Info{
-			Types: make(map[syntax.Expr]types2.TypeAndValue),
-			Defs:  make(map[*syntax.Name]types2.Object),
-			Uses:  make(map[*syntax.Name]types2.Object),
+			Types:      make(map[syntax.Expr]types2.TypeAndValue),
+			Defs:       make(map[*syntax.Name]types2.Object),
+			Uses:       make(map[*syntax.Name]types2.Object),
+			Selections: make(map[*syntax.SelectorExpr]*types2.Selection),
 			// expand as needed
 		}
 		conf.Check(base.Ctxt.Pkgpath, files, &info)
@@ -283,6 +284,11 @@ func (p *noder) use(x *syntax.Name) types2.Object {
 	return p.typeInfo.Uses[x]
 }
 
+// sel returns the selection information for the given selector expression.
+func (p *noder) sel(x *syntax.SelectorExpr) *types2.Selection {
+	return p.typeInfo.Selections[x]
+}
+
 func (p *noder) funcBody(fn *ir.Func, block *syntax.BlockStmt) {
 	oldScope := p.scope
 	p.scope = 0
-- 
GitLab


From 9f16620f46fc51ff1c8182b440bd60f97eb35278 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 13 Dec 2020 20:17:09 -0800
Subject: [PATCH 0222/2400] [dev.regabi] cmd/compile: fix latent Sym.SetPkgDef
 issue

Sym.pkgDefPtr is supposed to return a pointer to the types.Object
variable currently holding the Sym's package-scope
definition. However, in the case of identifiers that were shadowed in
the current scope, it was incorrectly returning a pointer to a stack
copy of the dclstack variable, rather than a pointer into the dclstack
itself.

This doesn't affect PkgDef, because it only reads from the variable,
so it got the same result anyway. It also happens to not affect our
usage of SetPkgDef today, because we currently only call SetPkgDef for
the builtin/runtime.go symbols, and those are never shadowed.

However, it does affect my upcoming CL to lazily create the ir.Names
for imported objects, as that depends on the ability to use SetPkgDef
to set shadowed identifiers.

Passes buildall w/ toolstash -cmp.

Change-Id: I54fc48b33da0670d31725faa1df1170a8730750a
Reviewed-on: https://go-review.googlesource.com/c/go/+/277712
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/types/scope.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/types/scope.go b/src/cmd/compile/internal/types/scope.go
index 04ea3c325f..d46918f73d 100644
--- a/src/cmd/compile/internal/types/scope.go
+++ b/src/cmd/compile/internal/types/scope.go
@@ -94,7 +94,8 @@ func (s *Sym) SetPkgDef(n Object) {
 func (s *Sym) pkgDefPtr() *Object {
 	// Look for outermost saved declaration, which must be the
 	// package scope definition, if present.
-	for _, d := range dclstack {
+	for i := range dclstack {
+		d := &dclstack[i]
 		if s == d.sym {
 			return &d.def
 		}
-- 
GitLab


From 305d93ef84aed971145b3aa1bce1f9f389bc90c0 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 13 Dec 2020 23:01:34 -0800
Subject: [PATCH 0223/2400] [dev.regabi] cmd/compile: type check externdcl
 earlier

The next CL requires externdcl to be type checked earlier, but this
causes toolstash -cmp to complain because it causes src.PosBases to
get added in a different order. So split out into a separate CL.

Change-Id: Icab4eadd3fa8acffbd3e980bd8100924378351b3
Reviewed-on: https://go-review.googlesource.com/c/go/+/277732
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/gc/main.go | 27 ++++++++++++---------------
 1 file changed, 12 insertions(+), 15 deletions(-)

diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 368fe1fcab..fa4dba4935 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -282,9 +282,18 @@ func Main(archInit func(*Arch)) {
 			fcount++
 		}
 	}
-	// With all types checked, it's now safe to verify map keys. One single
-	// check past phase 9 isn't sufficient, as we may exit with other errors
-	// before then, thus skipping map key errors.
+
+	// Phase 3.11: Check external declarations.
+	// TODO(mdempsky): This should be handled when type checking their
+	// corresponding ODCL nodes.
+	timings.Start("fe", "typecheck", "externdcls")
+	for i, n := range externdcl {
+		if n.Op() == ir.ONAME {
+			externdcl[i] = typecheck(externdcl[i], ctxExpr)
+		}
+	}
+
+	// Phase 3.14: With all user code type-checked, it's now safe to verify map keys.
 	checkMapKeys()
 	base.ExitIfErrors()
 
@@ -418,18 +427,6 @@ func Main(archInit func(*Arch)) {
 		base.Flag.GenDwarfInl = 0
 	}
 
-	// Phase 9: Check external declarations.
-	timings.Start("be", "externaldcls")
-	for i, n := range externdcl {
-		if n.Op() == ir.ONAME {
-			externdcl[i] = typecheck(externdcl[i], ctxExpr)
-		}
-	}
-	// Check the map keys again, since we typechecked the external
-	// declarations.
-	checkMapKeys()
-	base.ExitIfErrors()
-
 	// Write object data to disk.
 	timings.Start("be", "dumpobj")
 	dumpdata()
-- 
GitLab


From 4c2d66f642286647b640bced33581e8b1665bfe8 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 13 Dec 2020 10:35:20 -0800
Subject: [PATCH 0224/2400] [dev.regabi] cmd/compile: use ir.Ident for imported
 identifiers

This CL substantially reworks how imported declarations are handled,
and fixes a number of issues with dot imports. In particular:

1. It eliminates the stub ir.Name declarations that are created
upfront during import-declaration processing, allowing this to be
deferred to when the declarations are actually needed. (Eventually,
this can be deferred even further so we never have to create ir.Names
w/ ONONAME, but this CL is already invasive/subtle enough.)

2. During noding, we now use ir.Idents to represent uses of imported
declarations, including of dot-imported declarations.

3. Unused dot imports are now reported after type checking, so that we
can correctly distinguish whether composite literal keys are a simple
identifier (struct literals) or expressions (array/slice/map literals)
and whether it might be a use of a dot-imported declaration.

4. It changes the "redeclared" error messages to report the previous
position information in the same style as other compiler error
messages that reference other source lines.

Passes buildall w/ toolstash -cmp.

Fixes #6428.
Fixes #43164.
Fixes #43167.
Updates #42990.

Change-Id: I40a0a780ec40daf5700fbc3cfeeb7300e1055981
Reviewed-on: https://go-review.googlesource.com/c/go/+/277713
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/dcl.go            | 13 ++---
 src/cmd/compile/internal/gc/iimport.go        | 35 ++++++-------
 src/cmd/compile/internal/gc/init.go           |  4 +-
 src/cmd/compile/internal/gc/main.go           |  9 ++--
 src/cmd/compile/internal/gc/noder.go          |  2 +-
 src/cmd/compile/internal/gc/subr.go           | 50 +++++++++++++------
 src/cmd/compile/internal/gc/typecheck.go      | 48 ++++++++++--------
 src/cmd/compile/internal/ir/name.go           |  3 +-
 src/cmd/compile/internal/types/sizeof_test.go |  2 +-
 src/cmd/compile/internal/types/sym.go         |  3 +-
 test/fixedbugs/bug462.go                      |  4 +-
 test/fixedbugs/issue20415.go                  |  6 +--
 test/fixedbugs/issue43164.dir/a.go            | 13 +++++
 test/fixedbugs/issue43164.dir/b.go            | 11 ++++
 test/fixedbugs/issue43164.go                  |  7 +++
 test/fixedbugs/issue43167.go                  | 13 +++++
 test/fixedbugs/issue6428.go                   | 15 ++++++
 17 files changed, 159 insertions(+), 79 deletions(-)
 create mode 100644 test/fixedbugs/issue43164.dir/a.go
 create mode 100644 test/fixedbugs/issue43164.dir/b.go
 create mode 100644 test/fixedbugs/issue43164.go
 create mode 100644 test/fixedbugs/issue43167.go
 create mode 100644 test/fixedbugs/issue6428.go

diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 1ebadd9213..89873e2fac 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -28,12 +28,9 @@ func testdclstack() {
 // redeclare emits a diagnostic about symbol s being redeclared at pos.
 func redeclare(pos src.XPos, s *types.Sym, where string) {
 	if !s.Lastlineno.IsKnown() {
-		pkg := s.Origpkg
-		if pkg == nil {
-			pkg = s.Pkg
-		}
+		pkgName := dotImportRefs[s.Def.(*ir.Ident)]
 		base.ErrorfAt(pos, "%v redeclared %s\n"+
-			"\tprevious declaration during import %q", s, where, pkg.Path)
+			"\t%v: previous declaration during import %q", s, where, base.FmtPos(pkgName.Pos()), pkgName.Pkg.Path)
 	} else {
 		prevPos := s.Lastlineno
 
@@ -46,7 +43,7 @@ func redeclare(pos src.XPos, s *types.Sym, where string) {
 		}
 
 		base.ErrorfAt(pos, "%v redeclared %s\n"+
-			"\tprevious declaration at %v", s, where, base.FmtPos(prevPos))
+			"\t%v: previous declaration", s, where, base.FmtPos(prevPos))
 	}
 }
 
@@ -210,6 +207,10 @@ func symfield(s *types.Sym, typ *types.Type) *ir.Field {
 // Automatically creates a new closure variable if the referenced symbol was
 // declared in a different (containing) function.
 func oldname(s *types.Sym) ir.Node {
+	if s.Pkg != types.LocalPkg {
+		return ir.NewIdent(base.Pos, s)
+	}
+
 	n := ir.AsNode(s.Def)
 	if n == nil {
 		// Maybe a top-level declaration will come along later to
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 194c7427f3..0e2af562d0 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -165,17 +165,9 @@ func iimport(pkg *types.Pkg, in *bio.Reader) (fingerprint goobj.FingerprintType)
 			s := pkg.Lookup(p.stringAt(ird.uint64()))
 			off := ird.uint64()
 
-			if _, ok := declImporter[s]; ok {
-				continue
+			if _, ok := declImporter[s]; !ok {
+				declImporter[s] = iimporterAndOffset{p, off}
 			}
-			declImporter[s] = iimporterAndOffset{p, off}
-
-			// Create stub declaration. If used, this will
-			// be overwritten by expandDecl.
-			if s.Def != nil {
-				base.Fatalf("unexpected definition for %v: %v", s, ir.AsNode(s.Def))
-			}
-			s.Def = ir.NewDeclNameAt(src.NoXPos, s)
 		}
 	}
 
@@ -187,10 +179,9 @@ func iimport(pkg *types.Pkg, in *bio.Reader) (fingerprint goobj.FingerprintType)
 			s := pkg.Lookup(p.stringAt(ird.uint64()))
 			off := ird.uint64()
 
-			if _, ok := inlineImporter[s]; ok {
-				continue
+			if _, ok := inlineImporter[s]; !ok {
+				inlineImporter[s] = iimporterAndOffset{p, off}
 			}
-			inlineImporter[s] = iimporterAndOffset{p, off}
 		}
 	}
 
@@ -442,10 +433,16 @@ func (r *importReader) ident() *types.Sym {
 	return pkg.Lookup(name)
 }
 
-func (r *importReader) qualifiedIdent() *types.Sym {
+func (r *importReader) qualifiedIdent() *ir.Name {
 	name := r.string()
 	pkg := r.pkg()
-	return pkg.Lookup(name)
+	sym := pkg.Lookup(name)
+	n := sym.PkgDef()
+	if n == nil {
+		n = ir.NewDeclNameAt(src.NoXPos, sym)
+		sym.SetPkgDef(n)
+	}
+	return n.(*ir.Name)
 }
 
 func (r *importReader) pos() src.XPos {
@@ -501,9 +498,9 @@ func (r *importReader) typ1() *types.Type {
 		// support inlining functions with local defined
 		// types. Therefore, this must be a package-scope
 		// type.
-		n := ir.AsNode(r.qualifiedIdent().PkgDef())
+		n := r.qualifiedIdent()
 		if n.Op() == ir.ONONAME {
-			expandDecl(n.(*ir.Name))
+			expandDecl(n)
 		}
 		if n.Op() != ir.OTYPE {
 			base.Fatalf("expected OTYPE, got %v: %v, %v", n.Op(), n.Sym(), n)
@@ -821,10 +818,10 @@ func (r *importReader) node() ir.Node {
 		return n
 
 	case ir.ONONAME:
-		return mkname(r.qualifiedIdent())
+		return r.qualifiedIdent()
 
 	case ir.ONAME:
-		return mkname(r.ident())
+		return r.ident().Def.(*ir.Name)
 
 	// case OPACK, ONONAME:
 	// 	unreachable - should have been resolved by typechecking
diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index e0907f952c..2ef9d1ad35 100644
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -44,8 +44,8 @@ func fninit(n []ir.Node) {
 
 	// Find imported packages with init tasks.
 	for _, pkg := range sourceOrderImports {
-		n := resolve(ir.AsNode(pkg.Lookup(".inittask").Def))
-		if n == nil {
+		n := resolve(oldname(pkg.Lookup(".inittask")))
+		if n.Op() == ir.ONONAME {
 			continue
 		}
 		if n.Op() != ir.ONAME || n.Class() != ir.PEXTERN {
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index fa4dba4935..77b11c5d5d 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -293,8 +293,10 @@ func Main(archInit func(*Arch)) {
 		}
 	}
 
-	// Phase 3.14: With all user code type-checked, it's now safe to verify map keys.
+	// Phase 3.14: With all user code type-checked, it's now safe to verify map keys
+	// and unused dot imports.
 	checkMapKeys()
+	checkDotImports()
 	base.ExitIfErrors()
 
 	timings.AddEvent(fcount, "funcs")
@@ -953,10 +955,7 @@ func clearImports() {
 		if IsAlias(s) {
 			// throw away top-level name left over
 			// from previous import . "x"
-			if name := n.Name(); name != nil && name.PkgName != nil && !name.PkgName.Used && base.SyntaxErrors() == 0 {
-				unused = append(unused, importedPkg{name.PkgName.Pos(), name.PkgName.Pkg.Path, ""})
-				name.PkgName.Used = true
-			}
+			// We'll report errors after type checking in checkDotImports.
 			s.Def = nil
 			continue
 		}
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 8c765f9dfc..55628352bd 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -369,7 +369,7 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
 
 	switch my.Name {
 	case ".":
-		importdot(ipkg, pack)
+		importDot(pack)
 		return
 	case "init":
 		base.ErrorfAt(pack.Pos(), "cannot import package as init - init must be a func")
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 42f8982c80..2082544d08 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -100,13 +100,26 @@ func autolabel(prefix string) *types.Sym {
 	return lookupN(prefix, int(n))
 }
 
-// find all the exported symbols in package opkg
+// dotImports tracks all PkgNames that have been dot-imported.
+var dotImports []*ir.PkgName
+
+// dotImportRefs maps idents introduced by importDot back to the
+// ir.PkgName they were dot-imported through.
+var dotImportRefs map[*ir.Ident]*ir.PkgName
+
+// find all the exported symbols in package referenced by PkgName,
 // and make them available in the current package
-func importdot(opkg *types.Pkg, pack *ir.PkgName) {
-	n := 0
+func importDot(pack *ir.PkgName) {
+	if dotImportRefs == nil {
+		dotImportRefs = make(map[*ir.Ident]*ir.PkgName)
+	}
+
+	opkg := pack.Pkg
 	for _, s := range opkg.Syms {
 		if s.Def == nil {
-			continue
+			if _, ok := declImporter[s]; !ok {
+				continue
+			}
 		}
 		if !types.IsExported(s.Name) || strings.ContainsRune(s.Name, 0xb7) { // 0xb7 = center dot
 			continue
@@ -118,21 +131,26 @@ func importdot(opkg *types.Pkg, pack *ir.PkgName) {
 			continue
 		}
 
-		s1.Def = s.Def
-		s1.Block = s.Block
-		if ir.AsNode(s1.Def).Name() == nil {
-			ir.Dump("s1def", ir.AsNode(s1.Def))
-			base.Fatalf("missing Name")
-		}
-		ir.AsNode(s1.Def).Name().PkgName = pack
-		s1.Origpkg = opkg
-		n++
+		id := ir.NewIdent(src.NoXPos, s)
+		dotImportRefs[id] = pack
+		s1.Def = id
+		s1.Block = 1
 	}
 
-	if n == 0 {
-		// can't possibly be used - there were no symbols
-		base.ErrorfAt(pack.Pos(), "imported and not used: %q", opkg.Path)
+	dotImports = append(dotImports, pack)
+}
+
+// checkDotImports reports errors for any unused dot imports.
+func checkDotImports() {
+	for _, pack := range dotImports {
+		if !pack.Used {
+			base.ErrorfAt(pack.Pos(), "imported and not used: %q", pack.Pkg.Path)
+		}
 	}
+
+	// No longer needed; release memory.
+	dotImports = nil
+	dotImportRefs = nil
 }
 
 // nodAddr returns a node representing &n.
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index ad161b59f0..49e4289f14 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -8,6 +8,7 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
+	"cmd/internal/src"
 	"fmt"
 	"go/constant"
 	"go/token"
@@ -90,11 +91,24 @@ func resolve(n ir.Node) (res ir.Node) {
 		defer tracePrint("resolve", n)(&res)
 	}
 
-	// Stub ir.Name left for us by iimport.
-	if n, ok := n.(*ir.Name); ok {
-		if n.Sym().Pkg == types.LocalPkg {
-			base.Fatalf("unexpected Name: %+v", n)
+	if sym := n.Sym(); sym.Pkg != types.LocalPkg {
+		// We might have an ir.Ident from oldname or importDot.
+		if id, ok := n.(*ir.Ident); ok {
+			if pkgName := dotImportRefs[id]; pkgName != nil {
+				pkgName.Used = true
+			}
+
+			if sym.Def == nil {
+				if _, ok := declImporter[sym]; !ok {
+					return n // undeclared name
+				}
+				sym.Def = ir.NewDeclNameAt(src.NoXPos, sym)
+			}
+			n = ir.AsNode(sym.Def)
 		}
+
+		// Stub ir.Name left for us by iimport.
+		n := n.(*ir.Name)
 		if inimport {
 			base.Fatalf("recursive inimport")
 		}
@@ -2885,31 +2899,25 @@ func typecheckcomplit(n ir.Node) (res ir.Node) {
 				if l.Op() == ir.OKEY {
 					key := l.Left()
 
-					sk := ir.NewStructKeyExpr(l.Pos(), nil, l.Right())
-					ls[i] = sk
-					l = sk
+					// Sym might have resolved to name in other top-level
+					// package, because of import dot. Redirect to correct sym
+					// before we do the lookup.
+					s := key.Sym()
+					if id, ok := key.(*ir.Ident); ok && dotImportRefs[id] != nil {
+						s = lookup(s.Name)
+					}
 
 					// An OXDOT uses the Sym field to hold
 					// the field to the right of the dot,
 					// so s will be non-nil, but an OXDOT
 					// is never a valid struct literal key.
-					if key.Sym() == nil || key.Op() == ir.OXDOT || key.Sym().IsBlank() {
+					if s == nil || s.Pkg != types.LocalPkg || key.Op() == ir.OXDOT || s.IsBlank() {
 						base.Errorf("invalid field name %v in struct initializer", key)
-						sk.SetLeft(typecheck(sk.Left(), ctxExpr))
 						continue
 					}
 
-					// Sym might have resolved to name in other top-level
-					// package, because of import dot. Redirect to correct sym
-					// before we do the lookup.
-					s := key.Sym()
-					if s.Pkg != types.LocalPkg && types.IsExported(s.Name) {
-						s1 := lookup(s.Name)
-						if s1.Origpkg == s.Pkg {
-							s = s1
-						}
-					}
-					sk.SetSym(s)
+					l = ir.NewStructKeyExpr(l.Pos(), s, l.Right())
+					ls[i] = l
 				}
 
 				if l.Op() != ir.OSTRUCTKEY {
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 2330838f1c..7f1a47e13c 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -16,8 +16,7 @@ import (
 // An Ident is an identifier, possibly qualified.
 type Ident struct {
 	miniExpr
-	sym  *types.Sym
-	Used bool
+	sym *types.Sym
 }
 
 func NewIdent(pos src.XPos, sym *types.Sym) *Ident {
diff --git a/src/cmd/compile/internal/types/sizeof_test.go b/src/cmd/compile/internal/types/sizeof_test.go
index 72a35bc7da..1ca07b12c8 100644
--- a/src/cmd/compile/internal/types/sizeof_test.go
+++ b/src/cmd/compile/internal/types/sizeof_test.go
@@ -20,7 +20,7 @@ func TestSizeof(t *testing.T) {
 		_32bit uintptr     // size on 32bit platforms
 		_64bit uintptr     // size on 64bit platforms
 	}{
-		{Sym{}, 52, 88},
+		{Sym{}, 48, 80},
 		{Type{}, 56, 96},
 		{Map{}, 20, 40},
 		{Forward{}, 20, 32},
diff --git a/src/cmd/compile/internal/types/sym.go b/src/cmd/compile/internal/types/sym.go
index fcb095c53c..19f06fcf5b 100644
--- a/src/cmd/compile/internal/types/sym.go
+++ b/src/cmd/compile/internal/types/sym.go
@@ -38,8 +38,7 @@ type Sym struct {
 	Block      int32    // blocknumber to catch redeclaration
 	Lastlineno src.XPos // last declaration for diagnostic
 
-	flags   bitset8
-	Origpkg *Pkg // original package for . import
+	flags bitset8
 }
 
 const (
diff --git a/test/fixedbugs/bug462.go b/test/fixedbugs/bug462.go
index 3df63b091d..bae5ee0aeb 100644
--- a/test/fixedbugs/bug462.go
+++ b/test/fixedbugs/bug462.go
@@ -13,7 +13,7 @@ type T struct {
 }
 
 func main() {
-	_ = T {
-		os.File: 1, // ERROR "unknown T? ?field"
+	_ = T{
+		os.File: 1, // ERROR "invalid field name os.File|unknown field"
 	}
 }
diff --git a/test/fixedbugs/issue20415.go b/test/fixedbugs/issue20415.go
index 6f2c342ce4..5ad085564b 100644
--- a/test/fixedbugs/issue20415.go
+++ b/test/fixedbugs/issue20415.go
@@ -11,7 +11,7 @@ package p
 // 1
 var f byte
 
-var f interface{} // ERROR "previous declaration at issue20415.go:12"
+var f interface{} // ERROR "issue20415.go:12: previous declaration"
 
 func _(f int) {
 }
@@ -22,7 +22,7 @@ var g byte
 func _(g int) {
 }
 
-var g interface{} // ERROR "previous declaration at issue20415.go:20"
+var g interface{} // ERROR "issue20415.go:20: previous declaration"
 
 // 3
 func _(h int) {
@@ -30,4 +30,4 @@ func _(h int) {
 
 var h byte
 
-var h interface{} // ERROR "previous declaration at issue20415.go:31"
+var h interface{} // ERROR "issue20415.go:31: previous declaration"
diff --git a/test/fixedbugs/issue43164.dir/a.go b/test/fixedbugs/issue43164.dir/a.go
new file mode 100644
index 0000000000..fa10e85061
--- /dev/null
+++ b/test/fixedbugs/issue43164.dir/a.go
@@ -0,0 +1,13 @@
+// Copyright 2020 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 p
+
+import . "strings"
+
+var _ = Index // use strings
+
+type t struct{ Index int }
+
+var _ = t{Index: 0}
diff --git a/test/fixedbugs/issue43164.dir/b.go b/test/fixedbugs/issue43164.dir/b.go
new file mode 100644
index 0000000000..b025927a05
--- /dev/null
+++ b/test/fixedbugs/issue43164.dir/b.go
@@ -0,0 +1,11 @@
+// Copyright 2020 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 p
+
+import . "bytes"
+
+var _ = Index // use bytes
+
+var _ = t{Index: 0}
diff --git a/test/fixedbugs/issue43164.go b/test/fixedbugs/issue43164.go
new file mode 100644
index 0000000000..f21d1d5c58
--- /dev/null
+++ b/test/fixedbugs/issue43164.go
@@ -0,0 +1,7 @@
+// compiledir
+
+// Copyright 2020 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 ignored
diff --git a/test/fixedbugs/issue43167.go b/test/fixedbugs/issue43167.go
new file mode 100644
index 0000000000..1d1b69af58
--- /dev/null
+++ b/test/fixedbugs/issue43167.go
@@ -0,0 +1,13 @@
+// errorcheck
+
+// Copyright 2020 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 p
+
+import . "bytes"
+
+var _ Buffer // use package bytes
+
+var Index byte // ERROR "Index redeclared.*\n\tLINE-4: previous declaration during import .bytes.|already declared|redefinition"
diff --git a/test/fixedbugs/issue6428.go b/test/fixedbugs/issue6428.go
new file mode 100644
index 0000000000..c3f7b20a98
--- /dev/null
+++ b/test/fixedbugs/issue6428.go
@@ -0,0 +1,15 @@
+// errorcheck
+
+// Copyright 2020 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 p
+
+import . "testing" // ERROR "imported and not used"
+
+type S struct {
+	T int
+}
+
+var _ = S{T: 0}
-- 
GitLab


From 96999296e6dd8bccf1765d4fab1835436c1d758d Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 9 Dec 2020 14:31:39 -0500
Subject: [PATCH 0225/2400] [dev.typeparams] go/types: import unify.go and
 infer.go from dev.go2go

After review, the only non-superficial change was to delegate the call
to under(...) to structuralType. Otherwise, update a few stale comments:
 + correct indices in the documentation for tparamsList
 + update smap->substMap in a few places
 + update type parameter syntax in a couple places

I've spent a good amount of time reviewing this code, and it
fundamentally LGTM (though I wish we didn't have to copy the logic from
identical0). However, as demonstrated in #43056, this code is
complicated and not always easy to reason about, particularly in the
context of type checking where not all types may be complete.

To further understand and verify this code I'd like to write more tests,
but that must wait until the rest of the changes in go/types are
imported from dev.go2go.

Change-Id: Iabb9d3a6af988a2e1b3445cde6bc2431a80f8bfe
Reviewed-on: https://go-review.googlesource.com/c/go/+/276692
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Robert Findley <rfindley@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/infer.go | 359 +++++++++++++++++++++++++++++++++
 src/go/types/unify.go | 452 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 811 insertions(+)
 create mode 100644 src/go/types/infer.go
 create mode 100644 src/go/types/unify.go

diff --git a/src/go/types/infer.go b/src/go/types/infer.go
new file mode 100644
index 0000000000..c0b1a4b71a
--- /dev/null
+++ b/src/go/types/infer.go
@@ -0,0 +1,359 @@
+// Copyright 2018 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.
+
+// This file implements type parameter inference given
+// a list of concrete arguments and a parameter list.
+
+package types
+
+import (
+	"go/token"
+	"strings"
+)
+
+// infer returns the list of actual type arguments for the given list of type parameters tparams
+// by inferring them from the actual arguments args for the parameters params. If type inference
+// is impossible because unification fails, an error is reported and the resulting types list is
+// nil, and index is 0. Otherwise, types is the list of inferred type arguments, and index is
+// the index of the first type argument in that list that couldn't be inferred (and thus is nil).
+// If all type arguments were inferred successfully, index is < 0.
+func (check *Checker) infer(tparams []*TypeName, params *Tuple, args []*operand) (types []Type, index int) {
+	assert(params.Len() == len(args))
+
+	u := newUnifier(check, false)
+	u.x.init(tparams)
+
+	errorf := func(kind string, tpar, targ Type, arg *operand) {
+		// provide a better error message if we can
+		targs, failed := u.x.types()
+		if failed == 0 {
+			// The first type parameter couldn't be inferred.
+			// If none of them could be inferred, don't try
+			// to provide the inferred type in the error msg.
+			allFailed := true
+			for _, targ := range targs {
+				if targ != nil {
+					allFailed = false
+					break
+				}
+			}
+			if allFailed {
+				check.errorf(arg, 0, "%s %s of %s does not match %s (cannot infer %s)", kind, targ, arg.expr, tpar, typeNamesString(tparams))
+				return
+			}
+		}
+		smap := makeSubstMap(tparams, targs)
+		// TODO(rFindley): pass a positioner here, rather than arg.Pos().
+		inferred := check.subst(arg.Pos(), tpar, smap)
+		if inferred != tpar {
+			check.errorf(arg, 0, "%s %s of %s does not match inferred type %s for %s", kind, targ, arg.expr, inferred, tpar)
+		} else {
+			check.errorf(arg, 0, "%s %s of %s does not match %s", kind, targ, arg.expr, tpar)
+		}
+	}
+
+	// Terminology: generic parameter = function parameter with a type-parameterized type
+
+	// 1st pass: Unify parameter and argument types for generic parameters with typed arguments
+	//           and collect the indices of generic parameters with untyped arguments.
+	var indices []int
+	for i, arg := range args {
+		par := params.At(i)
+		// If we permit bidirectional unification, this conditional code needs to be
+		// executed even if par.typ is not parameterized since the argument may be a
+		// generic function (for which we want to infer // its type arguments).
+		if isParameterized(tparams, par.typ) {
+			if arg.mode == invalid {
+				// An error was reported earlier. Ignore this targ
+				// and continue, we may still be able to infer all
+				// targs resulting in fewer follon-on errors.
+				continue
+			}
+			if targ := arg.typ; isTyped(targ) {
+				// If we permit bidirectional unification, and targ is
+				// a generic function, we need to initialize u.y with
+				// the respective type parameters of targ.
+				if !u.unify(par.typ, targ) {
+					errorf("type", par.typ, targ, arg)
+					return nil, 0
+				}
+			} else {
+				indices = append(indices, i)
+			}
+		}
+	}
+
+	// Some generic parameters with untyped arguments may have been given a type
+	// indirectly through another generic parameter with a typed argument; we can
+	// ignore those now. (This only means that we know the types for those generic
+	// parameters; it doesn't mean untyped arguments can be passed safely. We still
+	// need to verify that assignment of those arguments is valid when we check
+	// function parameter passing external to infer.)
+	j := 0
+	for _, i := range indices {
+		par := params.At(i)
+		// Since untyped types are all basic (i.e., non-composite) types, an
+		// untyped argument will never match a composite parameter type; the
+		// only parameter type it can possibly match against is a *TypeParam.
+		// Thus, only keep the indices of generic parameters that are not of
+		// composite types and which don't have a type inferred yet.
+		if tpar, _ := par.typ.(*TypeParam); tpar != nil && u.x.at(tpar.index) == nil {
+			indices[j] = i
+			j++
+		}
+	}
+	indices = indices[:j]
+
+	// 2nd pass: Unify parameter and default argument types for remaining generic parameters.
+	for _, i := range indices {
+		par := params.At(i)
+		arg := args[i]
+		targ := Default(arg.typ)
+		// The default type for an untyped nil is untyped nil. We must not
+		// infer an untyped nil type as type parameter type. Ignore untyped
+		// nil by making sure all default argument types are typed.
+		if isTyped(targ) && !u.unify(par.typ, targ) {
+			errorf("default type", par.typ, targ, arg)
+			return nil, 0
+		}
+	}
+
+	return u.x.types()
+}
+
+// typeNamesString produces a string containing all the
+// type names in list suitable for human consumption.
+func typeNamesString(list []*TypeName) string {
+	// common cases
+	n := len(list)
+	switch n {
+	case 0:
+		return ""
+	case 1:
+		return list[0].name
+	case 2:
+		return list[0].name + " and " + list[1].name
+	}
+
+	// general case (n > 2)
+	var b strings.Builder
+	for i, tname := range list[:n-1] {
+		if i > 0 {
+			b.WriteString(", ")
+		}
+		b.WriteString(tname.name)
+	}
+	b.WriteString(", and ")
+	b.WriteString(list[n-1].name)
+	return b.String()
+}
+
+// IsParameterized reports whether typ contains any of the type parameters of tparams.
+func isParameterized(tparams []*TypeName, typ Type) bool {
+	w := tpWalker{
+		seen:    make(map[Type]bool),
+		tparams: tparams,
+	}
+	return w.isParameterized(typ)
+}
+
+type tpWalker struct {
+	seen    map[Type]bool
+	tparams []*TypeName
+}
+
+func (w *tpWalker) isParameterized(typ Type) (res bool) {
+	// detect cycles
+	if x, ok := w.seen[typ]; ok {
+		return x
+	}
+	w.seen[typ] = false
+	defer func() {
+		w.seen[typ] = res
+	}()
+
+	switch t := typ.(type) {
+	case nil, *Basic: // TODO(gri) should nil be handled here?
+		break
+
+	case *Array:
+		return w.isParameterized(t.elem)
+
+	case *Slice:
+		return w.isParameterized(t.elem)
+
+	case *Struct:
+		for _, fld := range t.fields {
+			if w.isParameterized(fld.typ) {
+				return true
+			}
+		}
+
+	case *Pointer:
+		return w.isParameterized(t.base)
+
+	case *Tuple:
+		n := t.Len()
+		for i := 0; i < n; i++ {
+			if w.isParameterized(t.At(i).typ) {
+				return true
+			}
+		}
+
+	case *Sum:
+		return w.isParameterizedList(t.types)
+
+	case *Signature:
+		// t.tparams may not be nil if we are looking at a signature
+		// of a generic function type (or an interface method) that is
+		// part of the type we're testing. We don't care about these type
+		// parameters.
+		// Similarly, the receiver of a method may declare (rather then
+		// use) type parameters, we don't care about those either.
+		// Thus, we only need to look at the input and result parameters.
+		return w.isParameterized(t.params) || w.isParameterized(t.results)
+
+	case *Interface:
+		if t.allMethods != nil {
+			// TODO(rFindley) at some point we should enforce completeness here
+			for _, m := range t.allMethods {
+				if w.isParameterized(m.typ) {
+					return true
+				}
+			}
+			return w.isParameterizedList(unpackType(t.allTypes))
+		}
+
+		return t.iterate(func(t *Interface) bool {
+			for _, m := range t.methods {
+				if w.isParameterized(m.typ) {
+					return true
+				}
+			}
+			return w.isParameterizedList(unpackType(t.types))
+		}, nil)
+
+	case *Map:
+		return w.isParameterized(t.key) || w.isParameterized(t.elem)
+
+	case *Chan:
+		return w.isParameterized(t.elem)
+
+	case *Named:
+		return w.isParameterizedList(t.targs)
+
+	case *TypeParam:
+		// t must be one of w.tparams
+		return t.index < len(w.tparams) && w.tparams[t.index].typ == t
+
+	case *instance:
+		return w.isParameterizedList(t.targs)
+
+	default:
+		unreachable()
+	}
+
+	return false
+}
+
+func (w *tpWalker) isParameterizedList(list []Type) bool {
+	for _, t := range list {
+		if w.isParameterized(t) {
+			return true
+		}
+	}
+	return false
+}
+
+// inferB returns the list of actual type arguments inferred from the type parameters'
+// bounds and an initial set of type arguments. If type inference is impossible because
+// unification fails, an error is reported, the resulting types list is nil, and index is 0.
+// Otherwise, types is the list of inferred type arguments, and index is the index of the
+// first type argument in that list that couldn't be inferred (and thus is nil). If all
+// type arguments where inferred successfully, index is < 0. The number of type arguments
+// provided may be less than the number of type parameters, but there must be at least one.
+func (check *Checker) inferB(tparams []*TypeName, targs []Type) (types []Type, index int) {
+	assert(len(tparams) >= len(targs) && len(targs) > 0)
+
+	// Setup bidirectional unification between those structural bounds
+	// and the corresponding type arguments (which may be nil!).
+	u := newUnifier(check, false)
+	u.x.init(tparams)
+	u.y = u.x // type parameters between LHS and RHS of unification are identical
+
+	// Set the type arguments which we know already.
+	for i, targ := range targs {
+		if targ != nil {
+			u.x.set(i, targ)
+		}
+	}
+
+	// Unify type parameters with their structural constraints, if any.
+	for _, tpar := range tparams {
+		typ := tpar.typ.(*TypeParam)
+		sbound := check.structuralType(typ.bound)
+		if sbound != nil {
+			if !u.unify(typ, sbound) {
+				check.errorf(tpar, 0, "%s does not match %s", tpar, sbound)
+				return nil, 0
+			}
+		}
+	}
+
+	// u.x.types() now contains the incoming type arguments plus any additional type
+	// arguments for which there were structural constraints. The newly inferred non-
+	// nil entries may still contain references to other type parameters. For instance,
+	// for [A any, B interface{type []C}, C interface{type *A}], if A == int
+	// was given, unification produced the type list [int, []C, *A]. We eliminate the
+	// remaining type parameters by substituting the type parameters in this type list
+	// until nothing changes anymore.
+	types, index = u.x.types()
+	if debug {
+		for i, targ := range targs {
+			assert(targ == nil || types[i] == targ)
+		}
+	}
+
+	// dirty tracks the indices of all types that may still contain type parameters.
+	// We know that nil type entries and entries corresponding to provided (non-nil)
+	// type arguments are clean, so exclude them from the start.
+	var dirty []int
+	for i, typ := range types {
+		if typ != nil && (i >= len(targs) || targs[i] == nil) {
+			dirty = append(dirty, i)
+		}
+	}
+
+	for len(dirty) > 0 {
+		// TODO(gri) Instead of creating a new substMap for each iteration,
+		// provide an update operation for substMaps and only change when
+		// needed. Optimization.
+		smap := makeSubstMap(tparams, types)
+		n := 0
+		for _, index := range dirty {
+			t0 := types[index]
+			if t1 := check.subst(token.NoPos, t0, smap); t1 != t0 {
+				types[index] = t1
+				dirty[n] = index
+				n++
+			}
+		}
+		dirty = dirty[:n]
+	}
+
+	return
+}
+
+// structuralType returns the structural type of a constraint, if any.
+func (check *Checker) structuralType(constraint Type) Type {
+	if iface, _ := under(constraint).(*Interface); iface != nil {
+		check.completeInterface(token.NoPos, iface)
+		types := unpackType(iface.allTypes)
+		if len(types) == 1 {
+			return types[0]
+		}
+		return nil
+	}
+	return constraint
+}
diff --git a/src/go/types/unify.go b/src/go/types/unify.go
new file mode 100644
index 0000000000..ab18febbdf
--- /dev/null
+++ b/src/go/types/unify.go
@@ -0,0 +1,452 @@
+// Copyright 2020 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.
+
+// This file implements type unification.
+
+package types
+
+import (
+	"go/token"
+	"sort"
+)
+
+// The unifier maintains two separate sets of type parameters x and y
+// which are used to resolve type parameters in the x and y arguments
+// provided to the unify call. For unidirectional unification, only
+// one of these sets (say x) is provided, and then type parameters are
+// only resolved for the x argument passed to unify, not the y argument
+// (even if that also contains possibly the same type parameters). This
+// is crucial to infer the type parameters of self-recursive calls:
+//
+//	func f[P any](a P) { f(a) }
+//
+// For the call f(a) we want to infer that the type argument for P is P.
+// During unification, the parameter type P must be resolved to the type
+// parameter P ("x" side), but the argument type P must be left alone so
+// that unification resolves the type parameter P to P.
+//
+// For bidirection unification, both sets are provided. This enables
+// unification to go from argument to parameter type and vice versa.
+// For constraint type inference, we use bidirectional unification
+// where both the x and y type parameters are identical. This is done
+// by setting up one of them (using init) and then assigning its value
+// to the other.
+
+// A unifier maintains the current type parameters for x and y
+// and the respective types inferred for each type parameter.
+// A unifier is created by calling newUnifier.
+type unifier struct {
+	check *Checker
+	exact bool
+	x, y  tparamsList // x and y must initialized via tparamsList.init
+	types []Type      // inferred types, shared by x and y
+}
+
+// newUnifier returns a new unifier.
+// If exact is set, unification requires unified types to match
+// exactly. If exact is not set, a named type's underlying type
+// is considered if unification would fail otherwise, and the
+// direction of channels is ignored.
+func newUnifier(check *Checker, exact bool) *unifier {
+	u := &unifier{check: check, exact: exact}
+	u.x.unifier = u
+	u.y.unifier = u
+	return u
+}
+
+// unify attempts to unify x and y and reports whether it succeeded.
+func (u *unifier) unify(x, y Type) bool {
+	return u.nify(x, y, nil)
+}
+
+// A tparamsList describes a list of type parameters and the types inferred for them.
+type tparamsList struct {
+	unifier *unifier
+	tparams []*TypeName
+	// For each tparams element, there is a corresponding type slot index in indices.
+	// index  < 0: unifier.types[-index-1] == nil
+	// index == 0: no type slot allocated yet
+	// index  > 0: unifier.types[index-1] == typ
+	// Joined tparams elements share the same type slot and thus have the same index.
+	// By using a negative index for nil types we don't need to check unifier.types
+	// to see if we have a type or not.
+	indices []int // len(d.indices) == len(d.tparams)
+}
+
+// init initializes d with the given type parameters.
+// The type parameters must be in the order in which they appear in their declaration
+// (this ensures that the tparams indices match the respective type parameter index).
+func (d *tparamsList) init(tparams []*TypeName) {
+	if len(tparams) == 0 {
+		return
+	}
+	if debug {
+		for i, tpar := range tparams {
+			assert(i == tpar.typ.(*TypeParam).index)
+		}
+	}
+	d.tparams = tparams
+	d.indices = make([]int, len(tparams))
+}
+
+// join unifies the i'th type parameter of x with the j'th type parameter of y.
+// If both type parameters already have a type associated with them and they are
+// not joined, join fails and return false.
+func (u *unifier) join(i, j int) bool {
+	ti := u.x.indices[i]
+	tj := u.y.indices[j]
+	switch {
+	case ti == 0 && tj == 0:
+		// Neither type parameter has a type slot associated with them.
+		// Allocate a new joined nil type slot (negative index).
+		u.types = append(u.types, nil)
+		u.x.indices[i] = -len(u.types)
+		u.y.indices[j] = -len(u.types)
+	case ti == 0:
+		// The type parameter for x has no type slot yet. Use slot of y.
+		u.x.indices[i] = tj
+	case tj == 0:
+		// The type parameter for y has no type slot yet. Use slot of x.
+		u.y.indices[j] = ti
+
+	// Both type parameters have a slot: ti != 0 && tj != 0.
+	case ti == tj:
+		// Both type parameters already share the same slot. Nothing to do.
+		break
+	case ti > 0 && tj > 0:
+		// Both type parameters have (possibly different) inferred types. Cannot join.
+		return false
+	case ti > 0:
+		// Only the type parameter for x has an inferred type. Use x slot for y.
+		u.y.setIndex(j, ti)
+	default:
+		// Either the type parameter for y has an inferred type, or neither type
+		// parameter has an inferred type. In either case, use y slot for x.
+		u.x.setIndex(i, tj)
+	}
+	return true
+}
+
+// If typ is a type parameter of d, index returns the type parameter index.
+// Otherwise, the result is < 0.
+func (d *tparamsList) index(typ Type) int {
+	if t, ok := typ.(*TypeParam); ok {
+		if i := t.index; i < len(d.tparams) && d.tparams[i].typ == t {
+			return i
+		}
+	}
+	return -1
+}
+
+// setIndex sets the type slot index for the i'th type parameter
+// (and all its joined parameters) to tj. The type parameter
+// must have a (possibly nil) type slot associated with it.
+func (d *tparamsList) setIndex(i, tj int) {
+	ti := d.indices[i]
+	assert(ti != 0 && tj != 0)
+	for k, tk := range d.indices {
+		if tk == ti {
+			d.indices[k] = tj
+		}
+	}
+}
+
+// at returns the type set for the i'th type parameter; or nil.
+func (d *tparamsList) at(i int) Type {
+	if ti := d.indices[i]; ti > 0 {
+		return d.unifier.types[ti-1]
+	}
+	return nil
+}
+
+// set sets the type typ for the i'th type parameter;
+// typ must not be nil and it must not have been set before.
+func (d *tparamsList) set(i int, typ Type) {
+	assert(typ != nil)
+	u := d.unifier
+	switch ti := d.indices[i]; {
+	case ti < 0:
+		u.types[-ti-1] = typ
+		d.setIndex(i, -ti)
+	case ti == 0:
+		u.types = append(u.types, typ)
+		d.indices[i] = len(u.types)
+	default:
+		panic("type already set")
+	}
+}
+
+// types returns the list of inferred types (via unification) for the type parameters
+// described by d, and an index. If all types were inferred, the returned index is < 0.
+// Otherwise, it is the index of the first type parameter which couldn't be inferred;
+// i.e., for which list[index] is nil.
+func (d *tparamsList) types() (list []Type, index int) {
+	list = make([]Type, len(d.tparams))
+	index = -1
+	for i := range d.tparams {
+		t := d.at(i)
+		list[i] = t
+		if index < 0 && t == nil {
+			index = i
+		}
+	}
+	return
+}
+
+func (u *unifier) nifyEq(x, y Type, p *ifacePair) bool {
+	return x == y || u.nify(x, y, p)
+}
+
+// nify implements the core unification algorithm which is an
+// adapted version of Checker.identical0. For changes to that
+// code the corresponding changes should be made here.
+// Must not be called directly from outside the unifier.
+func (u *unifier) nify(x, y Type, p *ifacePair) bool {
+	// types must be expanded for comparison
+	x = expand(x)
+	y = expand(y)
+
+	if !u.exact {
+		// If exact unification is known to fail because we attempt to
+		// match a type name against an unnamed type literal, consider
+		// the underlying type of the named type.
+		// (Subtle: We use isNamed to include any type with a name (incl.
+		// basic types and type parameters. We use asNamed() because we only
+		// want *Named types.)
+		switch {
+		case !isNamed(x) && y != nil && asNamed(y) != nil:
+			return u.nify(x, under(y), p)
+		case x != nil && asNamed(x) != nil && !isNamed(y):
+			return u.nify(under(x), y, p)
+		}
+	}
+
+	// Cases where at least one of x or y is a type parameter.
+	switch i, j := u.x.index(x), u.y.index(y); {
+	case i >= 0 && j >= 0:
+		// both x and y are type parameters
+		if u.join(i, j) {
+			return true
+		}
+		// both x and y have an inferred type - they must match
+		return u.nifyEq(u.x.at(i), u.y.at(j), p)
+
+	case i >= 0:
+		// x is a type parameter, y is not
+		if tx := u.x.at(i); tx != nil {
+			return u.nifyEq(tx, y, p)
+		}
+		// otherwise, infer type from y
+		u.x.set(i, y)
+		return true
+
+	case j >= 0:
+		// y is a type parameter, x is not
+		if ty := u.y.at(j); ty != nil {
+			return u.nifyEq(x, ty, p)
+		}
+		// otherwise, infer type from x
+		u.y.set(j, x)
+		return true
+	}
+
+	// For type unification, do not shortcut (x == y) for identical
+	// types. Instead keep comparing them element-wise to unify the
+	// matching (and equal type parameter types). A simple test case
+	// where this matters is: func f[P any](a P) { f(a) } .
+
+	switch x := x.(type) {
+	case *Basic:
+		// Basic types are singletons except for the rune and byte
+		// aliases, thus we cannot solely rely on the x == y check
+		// above. See also comment in TypeName.IsAlias.
+		if y, ok := y.(*Basic); ok {
+			return x.kind == y.kind
+		}
+
+	case *Array:
+		// Two array types are identical if they have identical element types
+		// and the same array length.
+		if y, ok := y.(*Array); ok {
+			// If one or both array lengths are unknown (< 0) due to some error,
+			// assume they are the same to avoid spurious follow-on errors.
+			return (x.len < 0 || y.len < 0 || x.len == y.len) && u.nify(x.elem, y.elem, p)
+		}
+
+	case *Slice:
+		// Two slice types are identical if they have identical element types.
+		if y, ok := y.(*Slice); ok {
+			return u.nify(x.elem, y.elem, p)
+		}
+
+	case *Struct:
+		// Two struct types are identical if they have the same sequence of fields,
+		// and if corresponding fields have the same names, and identical types,
+		// and identical tags. Two embedded fields are considered to have the same
+		// name. Lower-case field names from different packages are always different.
+		if y, ok := y.(*Struct); ok {
+			if x.NumFields() == y.NumFields() {
+				for i, f := range x.fields {
+					g := y.fields[i]
+					if f.embedded != g.embedded ||
+						x.Tag(i) != y.Tag(i) ||
+						!f.sameId(g.pkg, g.name) ||
+						!u.nify(f.typ, g.typ, p) {
+						return false
+					}
+				}
+				return true
+			}
+		}
+
+	case *Pointer:
+		// Two pointer types are identical if they have identical base types.
+		if y, ok := y.(*Pointer); ok {
+			return u.nify(x.base, y.base, p)
+		}
+
+	case *Tuple:
+		// Two tuples types are identical if they have the same number of elements
+		// and corresponding elements have identical types.
+		if y, ok := y.(*Tuple); ok {
+			if x.Len() == y.Len() {
+				if x != nil {
+					for i, v := range x.vars {
+						w := y.vars[i]
+						if !u.nify(v.typ, w.typ, p) {
+							return false
+						}
+					}
+				}
+				return true
+			}
+		}
+
+	case *Signature:
+		// Two function types are identical if they have the same number of parameters
+		// and result values, corresponding parameter and result types are identical,
+		// and either both functions are variadic or neither is. Parameter and result
+		// names are not required to match.
+		// TODO(gri) handle type parameters or document why we can ignore them.
+		if y, ok := y.(*Signature); ok {
+			return x.variadic == y.variadic &&
+				u.nify(x.params, y.params, p) &&
+				u.nify(x.results, y.results, p)
+		}
+
+	case *Sum:
+		// This should not happen with the current internal use of sum types.
+		panic("type inference across sum types not implemented")
+
+	case *Interface:
+		// Two interface types are identical if they have the same set of methods with
+		// the same names and identical function types. Lower-case method names from
+		// different packages are always different. The order of the methods is irrelevant.
+		if y, ok := y.(*Interface); ok {
+			// If identical0 is called (indirectly) via an external API entry point
+			// (such as Identical, IdenticalIgnoreTags, etc.), check is nil. But in
+			// that case, interfaces are expected to be complete and lazy completion
+			// here is not needed.
+			if u.check != nil {
+				u.check.completeInterface(token.NoPos, x)
+				u.check.completeInterface(token.NoPos, y)
+			}
+			a := x.allMethods
+			b := y.allMethods
+			if len(a) == len(b) {
+				// Interface types are the only types where cycles can occur
+				// that are not "terminated" via named types; and such cycles
+				// can only be created via method parameter types that are
+				// anonymous interfaces (directly or indirectly) embedding
+				// the current interface. Example:
+				//
+				//    type T interface {
+				//        m() interface{T}
+				//    }
+				//
+				// If two such (differently named) interfaces are compared,
+				// endless recursion occurs if the cycle is not detected.
+				//
+				// If x and y were compared before, they must be equal
+				// (if they were not, the recursion would have stopped);
+				// search the ifacePair stack for the same pair.
+				//
+				// This is a quadratic algorithm, but in practice these stacks
+				// are extremely short (bounded by the nesting depth of interface
+				// type declarations that recur via parameter types, an extremely
+				// rare occurrence). An alternative implementation might use a
+				// "visited" map, but that is probably less efficient overall.
+				q := &ifacePair{x, y, p}
+				for p != nil {
+					if p.identical(q) {
+						return true // same pair was compared before
+					}
+					p = p.prev
+				}
+				if debug {
+					assert(sort.IsSorted(byUniqueMethodName(a)))
+					assert(sort.IsSorted(byUniqueMethodName(b)))
+				}
+				for i, f := range a {
+					g := b[i]
+					if f.Id() != g.Id() || !u.nify(f.typ, g.typ, q) {
+						return false
+					}
+				}
+				return true
+			}
+		}
+
+	case *Map:
+		// Two map types are identical if they have identical key and value types.
+		if y, ok := y.(*Map); ok {
+			return u.nify(x.key, y.key, p) && u.nify(x.elem, y.elem, p)
+		}
+
+	case *Chan:
+		// Two channel types are identical if they have identical value types.
+		if y, ok := y.(*Chan); ok {
+			return (!u.exact || x.dir == y.dir) && u.nify(x.elem, y.elem, p)
+		}
+
+	case *Named:
+		// Two named types are identical if their type names originate
+		// in the same type declaration.
+		// if y, ok := y.(*Named); ok {
+		// 	return x.obj == y.obj
+		// }
+		if y, ok := y.(*Named); ok {
+			// TODO(gri) This is not always correct: two types may have the same names
+			//           in the same package if one of them is nested in a function.
+			//           Extremely unlikely but we need an always correct solution.
+			if x.obj.pkg == y.obj.pkg && x.obj.name == y.obj.name {
+				assert(len(x.targs) == len(y.targs))
+				for i, x := range x.targs {
+					if !u.nify(x, y.targs[i], p) {
+						return false
+					}
+				}
+				return true
+			}
+		}
+
+	case *TypeParam:
+		// Two type parameters (which are not part of the type parameters of the
+		// enclosing type as those are handled in the beginning of this function)
+		// are identical if they originate in the same declaration.
+		return x == y
+
+	// case *instance:
+	//	unreachable since types are expanded
+
+	case nil:
+		// avoid a crash in case of nil type
+
+	default:
+		u.check.dump("### u.nify(%s, %s), u.x.tparams = %s", x, y, u.x.tparams)
+		unreachable()
+	}
+
+	return false
+}
-- 
GitLab


From 14e4267c3446fe30bb1c7a1a874dc7e18c1d38d1 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 14 Dec 2020 16:58:46 -0800
Subject: [PATCH 0226/2400] [dev.typeparams] cmd/compile/internal/types2:
 report error for invalid (but empty) expr switch

Enable one more errorcheck test.

Updates #43110.
Updates #43200.

Change-Id: Ib7b971d5e9989c65320579f75d65266bbbbeec53
Reviewed-on: https://go-review.googlesource.com/c/go/+/278132
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 .../internal/types2/fixedbugs/issue43110.src  | 43 +++++++++++++++++++
 src/cmd/compile/internal/types2/stmt.go       |  4 ++
 test/run.go                                   |  1 -
 test/switch3.go                               |  6 +--
 4 files changed, 50 insertions(+), 4 deletions(-)
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue43110.src

diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue43110.src b/src/cmd/compile/internal/types2/fixedbugs/issue43110.src
new file mode 100644
index 0000000000..4a46945239
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue43110.src
@@ -0,0 +1,43 @@
+// Copyright 2020 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 p
+
+type P *struct{}
+
+func _() {
+	// want an error even if the switch is empty
+	var a struct{ _ func() }
+	switch a /* ERROR cannot switch on a */ {
+	}
+
+	switch a /* ERROR cannot switch on a */ {
+	case a: // no follow-on error here
+	}
+
+	// this is ok because f can be compared to nil
+	var f func()
+	switch f {
+	}
+
+	switch f {
+	case nil:
+	}
+
+	switch (func())(nil) {
+	case nil:
+	}
+
+	switch (func())(nil) {
+	case f /* ERROR cannot compare */ :
+	}
+
+	switch nil /* ERROR use of untyped nil in switch expression */ {
+	}
+
+	// this is ok
+	switch P(nil) {
+	case P(nil):
+	}
+}
diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go
index 477bc58bd0..3463cfdf57 100644
--- a/src/cmd/compile/internal/types2/stmt.go
+++ b/src/cmd/compile/internal/types2/stmt.go
@@ -605,6 +605,10 @@ func (check *Checker) switchStmt(inner stmtContext, s *syntax.SwitchStmt) {
 		// By checking assignment of x to an invisible temporary
 		// (as a compiler would), we get all the relevant checks.
 		check.assignment(&x, nil, "switch expression")
+		if x.mode != invalid && !Comparable(x.typ) && !hasNil(x.typ) {
+			check.errorf(&x, "cannot switch on %s (%s is not comparable)", &x, x.typ)
+			x.mode = invalid
+		}
 	} else {
 		// spec: "A missing switch expression is
 		// equivalent to the boolean value true."
diff --git a/test/run.go b/test/run.go
index 9cfd13ae48..01e67e8db8 100644
--- a/test/run.go
+++ b/test/run.go
@@ -1937,7 +1937,6 @@ var excluded = map[string]bool{
 	"initializerr.go": true, // types2 reports extra errors
 	"linkname2.go":    true, // error reported by noder (not running for types2 errorcheck test)
 	"shift1.go":       true, // issue #42989
-	"switch3.go":      true, // issue #43110
 	"switch4.go":      true, // error reported by noder (not running for types2 errorcheck test)
 	"typecheck.go":    true, // invalid function is not causing errors when called
 
diff --git a/test/switch3.go b/test/switch3.go
index 28705e464e..403563223c 100644
--- a/test/switch3.go
+++ b/test/switch3.go
@@ -28,21 +28,21 @@ func bad() {
 	var m, m1 map[int]int
 	switch m {
 	case nil:
-	case m1: // ERROR "can only compare map m to nil|map can only be compared to nil"
+	case m1: // ERROR "can only compare map m to nil|map can only be compared to nil|cannot compare"
 	default:
 	}
 
 	var a, a1 []int
 	switch a {
 	case nil:
-	case a1: // ERROR "can only compare slice a to nil|slice can only be compared to nil"
+	case a1: // ERROR "can only compare slice a to nil|slice can only be compared to nil|cannot compare"
 	default:
 	}
 
 	var f, f1 func()
 	switch f {
 	case nil:
-	case f1: // ERROR "can only compare func f to nil|func can only be compared to nil"
+	case f1: // ERROR "can only compare func f to nil|func can only be compared to nil|cannot compare"
 	default:
 	}
 
-- 
GitLab


From 6b18081d01f6f87b9af9e5b3910f1379d52a13eb Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 14 Dec 2020 17:23:00 -0800
Subject: [PATCH 0227/2400] [dev.typeparams] cmd/compile/internal/types2: don't
 crash if import path is missing

In package syntax:
- fix parser appendGroup to not add nil entries
- non-string paths are syntax errors per the spec; report in parser
- document ImportDecl.Path invariants

In package types2:
- guard against absent paths

In package gc:
- guard against absent paths

Fixes #43190.

Change-Id: Ic6a06f6a96b7f519feaa1ceaf4376fc5ab0f0129
Reviewed-on: https://go-review.googlesource.com/c/go/+/278114
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/gc/noder.go          |  2 +-
 src/cmd/compile/internal/syntax/nodes.go      |  4 ++--
 src/cmd/compile/internal/syntax/parser.go     | 22 +++++++++----------
 .../internal/types2/fixedbugs/issue43190.src  | 19 ++++++++++++++++
 src/cmd/compile/internal/types2/resolver.go   |  2 +-
 5 files changed, 34 insertions(+), 15 deletions(-)
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue43190.src

diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 8ae88a100c..65df405e24 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -463,7 +463,7 @@ func (p *noder) decls(decls []syntax.Decl) (l []ir.Node) {
 }
 
 func (p *noder) importDecl(imp *syntax.ImportDecl) {
-	if imp.Path.Bad {
+	if imp.Path == nil || imp.Path.Bad {
 		return // avoid follow-on errors if there was a syntax error
 	}
 
diff --git a/src/cmd/compile/internal/syntax/nodes.go b/src/cmd/compile/internal/syntax/nodes.go
index fe8f62c6e6..a06d6e85b1 100644
--- a/src/cmd/compile/internal/syntax/nodes.go
+++ b/src/cmd/compile/internal/syntax/nodes.go
@@ -55,8 +55,8 @@ type (
 	ImportDecl struct {
 		Group        *Group // nil means not part of a group
 		Pragma       Pragma
-		LocalPkgName *Name // including "."; nil means no rename present
-		Path         *BasicLit
+		LocalPkgName *Name     // including "."; nil means no rename present
+		Path         *BasicLit // Path.Bad || Path.Kind == StringLit; nil means no path
 		decl
 	}
 
diff --git a/src/cmd/compile/internal/syntax/parser.go b/src/cmd/compile/internal/syntax/parser.go
index 4af7e462ed..90b67def0f 100644
--- a/src/cmd/compile/internal/syntax/parser.go
+++ b/src/cmd/compile/internal/syntax/parser.go
@@ -499,21 +499,16 @@ func (p *parser) appendGroup(list []Decl, f func(*Group) Decl) []Decl {
 		p.clearPragma()
 		p.next() // must consume "(" after calling clearPragma!
 		p.list(_Semi, _Rparen, func() bool {
-			list = append(list, f(g))
+			if x := f(g); x != nil {
+				list = append(list, x)
+			}
 			return false
 		})
 	} else {
-		list = append(list, f(nil))
-	}
-
-	if debug {
-		for _, d := range list {
-			if d == nil {
-				panic("nil list entry")
-			}
+		if x := f(nil); x != nil {
+			list = append(list, x)
 		}
 	}
-
 	return list
 }
 
@@ -540,8 +535,13 @@ func (p *parser) importDecl(group *Group) Decl {
 	if d.Path == nil {
 		p.syntaxError("missing import path")
 		p.advance(_Semi, _Rparen)
-		return nil
+		return d
+	}
+	if !d.Path.Bad && d.Path.Kind != StringLit {
+		p.syntaxError("import path must be a string")
+		d.Path.Bad = true
 	}
+	// d.Path.Bad || d.Path.Kind == StringLit
 
 	return d
 }
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue43190.src b/src/cmd/compile/internal/types2/fixedbugs/issue43190.src
new file mode 100644
index 0000000000..ae42719ad7
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue43190.src
@@ -0,0 +1,19 @@
+// Copyright 2020 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 p
+
+import ; // ERROR missing import path
+import
+var /* ERROR missing import path */ _ int
+import .; // ERROR missing import path
+
+import ()
+import (.) // ERROR missing import path
+import (
+	"fmt"
+	.
+) // ERROR missing import path
+
+var _ = fmt.Println // avoid imported but not used error
diff --git a/src/cmd/compile/internal/types2/resolver.go b/src/cmd/compile/internal/types2/resolver.go
index 2e90e5781c..6765c21995 100644
--- a/src/cmd/compile/internal/types2/resolver.go
+++ b/src/cmd/compile/internal/types2/resolver.go
@@ -236,7 +236,7 @@ func (check *Checker) collectObjects() {
 			switch s := decl.(type) {
 			case *syntax.ImportDecl:
 				// import package
-				if s.Path.Bad {
+				if s.Path == nil || s.Path.Bad {
 					continue // error reported during parsing
 				}
 				path, err := validatedImportPath(s.Path.Value)
-- 
GitLab


From 1306435103558c4718e0ff3cba5ab2b8e2e34ec5 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 15 Dec 2020 09:49:10 -0500
Subject: [PATCH 0228/2400] [dev.typeparams] go/types: import changes to
 types.Info from dev.go2go

Import changes related to tracking type inferences and sanitizing
types.Info from the dev.go2go branch. Notably, the following were all
intentionally omitted from this import:
 + types.Error.Full is not imported, due to it being a public API that
   requires some further thought.
 + The Config.AcceptMethodTypeParams, InferFromConstraints, and Trace
   flag are not imported. The expectation is that we will not accept
   method type parameters for now, will always infer from constraints,
   and will continue to use the trace constant to guard tracing.
 + Some trace annotations are not imported to from the checking pass. We
   can add them back later, but for now they seemed verbose.
 + Checker.useBrackets is removed. This is no longer configurable.

Change-Id: I7f6315d66b200c92ffd1e55c9fd425a5d99149ed
Reviewed-on: https://go-review.googlesource.com/c/go/+/278312
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/api.go      |  13 ++++
 src/go/types/check.go    |  21 ++++--
 src/go/types/lookup.go   |   2 +-
 src/go/types/object.go   |   8 ++-
 src/go/types/sanitize.go | 150 +++++++++++++++++++++++++++++++++++++++
 5 files changed, 187 insertions(+), 7 deletions(-)
 create mode 100644 src/go/types/sanitize.go

diff --git a/src/go/types/api.go b/src/go/types/api.go
index d625959817..ec12fcf380 100644
--- a/src/go/types/api.go
+++ b/src/go/types/api.go
@@ -177,6 +177,12 @@ type Info struct {
 	// qualified identifiers are collected in the Uses map.
 	Types map[ast.Expr]TypeAndValue
 
+	// Inferred maps calls of parameterized functions that use
+	// type inference to the inferred type arguments and signature
+	// of the function called. The recorded "call" expression may be
+	// an *ast.CallExpr (as in f(x)), or an *ast.IndexExpr (s in f[T]).
+	Inferred map[ast.Expr]Inferred
+
 	// Defs maps identifiers to the objects they define (including
 	// package names, dots "." of dot-imports, and blank "_" identifiers).
 	// For identifiers that do not denote objects (e.g., the package name
@@ -333,6 +339,13 @@ func (tv TypeAndValue) HasOk() bool {
 	return tv.mode == commaok || tv.mode == mapindex
 }
 
+// Inferred reports the inferred type arguments and signature
+// for a parameterized function call that uses type inference.
+type Inferred struct {
+	Targs []Type
+	Sig   *Signature
+}
+
 // An Initializer describes a package-level variable, or a list of variables in case
 // of a multi-valued initialization expression, and the corresponding initialization
 // expression.
diff --git a/src/go/types/check.go b/src/go/types/check.go
index 73330db6e4..d1672837b8 100644
--- a/src/go/types/check.go
+++ b/src/go/types/check.go
@@ -19,18 +19,18 @@ const (
 	trace = false // turn on for detailed type resolution traces
 )
 
-// If Strict is set, the type-checker enforces additional
+// If forceStrict is set, the type-checker enforces additional
 // rules not specified by the Go 1 spec, but which will
 // catch guaranteed run-time errors if the respective
 // code is executed. In other words, programs passing in
-// Strict mode are Go 1 compliant, but not all Go 1 programs
-// will pass in Strict mode. The additional rules are:
+// strict mode are Go 1 compliant, but not all Go 1 programs
+// will pass in strict mode. The additional rules are:
 //
 // - A type assertion x.(T) where T is an interface type
 //   is invalid if any (statically known) method that exists
 //   for both x and T have different signatures.
 //
-const strict = false
+const forceStrict = false
 
 // exprInfo stores information about an untyped expression.
 type exprInfo struct {
@@ -192,6 +192,7 @@ func NewChecker(conf *Config, fset *token.FileSet, pkg *Package, info *Info) *Ch
 		fset:   fset,
 		pkg:    pkg,
 		Info:   info,
+		nextId: 1,
 		objMap: make(map[Object]*declInfo),
 		impMap: make(map[importKey]*Package),
 		posMap: make(map[*Interface][]token.Pos),
@@ -278,6 +279,10 @@ func (check *Checker) checkFiles(files []*ast.File) (err error) {
 
 	check.recordUntyped()
 
+	if check.Info != nil {
+		sanitizeInfo(check.Info)
+	}
+
 	check.pkg.complete = true
 	return
 }
@@ -380,6 +385,14 @@ func (check *Checker) recordCommaOkTypes(x ast.Expr, a [2]Type) {
 	}
 }
 
+func (check *Checker) recordInferred(call ast.Expr, targs []Type, sig *Signature) {
+	assert(call != nil)
+	assert(sig != nil)
+	if m := check.Inferred; m != nil {
+		m[call] = Inferred{targs, sig}
+	}
+}
+
 func (check *Checker) recordDef(id *ast.Ident, obj Object) {
 	assert(id != nil)
 	if m := check.Defs; m != nil {
diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go
index 2497843b21..e7091a63e5 100644
--- a/src/go/types/lookup.go
+++ b/src/go/types/lookup.go
@@ -343,7 +343,7 @@ func (check *Checker) assertableTo(V *Interface, T Type) (method, wrongType *Fun
 	// no static check is required if T is an interface
 	// spec: "If T is an interface type, x.(T) asserts that the
 	//        dynamic type of x implements the interface T."
-	if _, ok := T.Underlying().(*Interface); ok && !strict {
+	if _, ok := T.Underlying().(*Interface); ok && !forceStrict {
 		return
 	}
 	return check.missingMethod(T, V, false)
diff --git a/src/go/types/object.go b/src/go/types/object.go
index 374b24d1ac..50346ec691 100644
--- a/src/go/types/object.go
+++ b/src/go/types/object.go
@@ -36,6 +36,9 @@ type Object interface {
 	// color returns the object's color.
 	color() color
 
+	// setType sets the type of the object.
+	setType(Type)
+
 	// setOrder sets the order number of the object. It must be > 0.
 	setOrder(uint32)
 
@@ -149,6 +152,7 @@ func (obj *object) color() color        { return obj.color_ }
 func (obj *object) scopePos() token.Pos { return obj.scopePos_ }
 
 func (obj *object) setParent(parent *Scope)   { obj.parent = parent }
+func (obj *object) setType(typ Type)          { obj.typ = typ }
 func (obj *object) setOrder(order uint32)     { assert(order > 0); obj.order_ = order }
 func (obj *object) setColor(color color)      { assert(color != white); obj.color_ = color }
 func (obj *object) setScopePos(pos token.Pos) { obj.scopePos_ = pos }
@@ -299,7 +303,7 @@ type Func struct {
 // NewFunc returns a new function with the given signature, representing
 // the function's type.
 func NewFunc(pos token.Pos, pkg *Package, name string, sig *Signature) *Func {
-	// don't store a nil signature
+	// don't store a (typed) nil signature
 	var typ Type
 	if sig != nil {
 		typ = sig
@@ -420,7 +424,7 @@ func writeObject(buf *bytes.Buffer, obj Object, qf Qualifier) {
 		if tname.IsAlias() {
 			buf.WriteString(" =")
 		} else {
-			typ = typ.Underlying()
+			typ = under(typ)
 		}
 	}
 
diff --git a/src/go/types/sanitize.go b/src/go/types/sanitize.go
new file mode 100644
index 0000000000..c4e729ec9b
--- /dev/null
+++ b/src/go/types/sanitize.go
@@ -0,0 +1,150 @@
+// Copyright 2020 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 types
+
+// sanitizeInfo walks the types contained in info to ensure that all instances
+// are expanded.
+func sanitizeInfo(info *Info) {
+	var s sanitizer = make(map[Type]Type)
+
+	// Note: Some map entries are not references.
+	// If modified, they must be assigned back.
+
+	for e, tv := range info.Types {
+		tv.Type = s.typ(tv.Type)
+		info.Types[e] = tv
+	}
+
+	for e, inf := range info.Inferred {
+		for i, targ := range inf.Targs {
+			inf.Targs[i] = s.typ(targ)
+		}
+		inf.Sig = s.typ(inf.Sig).(*Signature)
+		info.Inferred[e] = inf
+	}
+
+	for _, obj := range info.Defs {
+		if obj != nil {
+			obj.setType(s.typ(obj.Type()))
+		}
+	}
+
+	for _, obj := range info.Uses {
+		if obj != nil {
+			obj.setType(s.typ(obj.Type()))
+		}
+	}
+
+	// TODO(gri) sanitize as needed
+	// - info.Implicits
+	// - info.Selections
+	// - info.Scopes
+	// - info.InitOrder
+}
+
+type sanitizer map[Type]Type
+
+func (s sanitizer) typ(typ Type) Type {
+	if t, found := s[typ]; found {
+		return t
+	}
+	s[typ] = typ
+
+	switch t := typ.(type) {
+	case nil, *Basic, *bottom, *top:
+		// nothing to do
+
+	case *Array:
+		t.elem = s.typ(t.elem)
+
+	case *Slice:
+		t.elem = s.typ(t.elem)
+
+	case *Struct:
+		s.varList(t.fields)
+
+	case *Pointer:
+		t.base = s.typ(t.base)
+
+	case *Tuple:
+		s.tuple(t)
+
+	case *Signature:
+		s.var_(t.recv)
+		s.tuple(t.params)
+		s.tuple(t.results)
+
+	case *Sum:
+		s.typeList(t.types)
+
+	case *Interface:
+		s.funcList(t.methods)
+		s.typ(t.types)
+		s.typeList(t.embeddeds)
+		s.funcList(t.allMethods)
+		s.typ(t.allTypes)
+
+	case *Map:
+		t.key = s.typ(t.key)
+		t.elem = s.typ(t.elem)
+
+	case *Chan:
+		t.elem = s.typ(t.elem)
+
+	case *Named:
+		t.orig = s.typ(t.orig)
+		t.underlying = s.typ(t.underlying)
+		s.typeList(t.targs)
+		s.funcList(t.methods)
+
+	case *TypeParam:
+		t.bound = s.typ(t.bound)
+
+	case *instance:
+		typ = t.expand()
+		s[t] = typ
+
+	default:
+		panic("unimplemented")
+	}
+
+	return typ
+}
+
+func (s sanitizer) var_(v *Var) {
+	if v != nil {
+		v.typ = s.typ(v.typ)
+	}
+}
+
+func (s sanitizer) varList(list []*Var) {
+	for _, v := range list {
+		s.var_(v)
+	}
+}
+
+func (s sanitizer) tuple(t *Tuple) {
+	if t != nil {
+		s.varList(t.vars)
+	}
+}
+
+func (s sanitizer) func_(f *Func) {
+	if f != nil {
+		f.typ = s.typ(f.typ)
+	}
+}
+
+func (s sanitizer) funcList(list []*Func) {
+	for _, f := range list {
+		s.func_(f)
+	}
+}
+
+func (s sanitizer) typeList(list []Type) {
+	for i, t := range list {
+		list[i] = s.typ(t)
+	}
+}
-- 
GitLab


From a4d4c10340957f5c1804134a75b3da36402fe8bb Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 15 Dec 2020 11:37:06 -0500
Subject: [PATCH 0229/2400] [dev.typeparams] go/types: import lookup logic from
 dev.go2go

Changes from dev.go2go:
 + Remove support for pointer designation.
 + Remove support for method type parameters in missingMethod. We could
   leave this logic in, but it looked sufficiently shaky that I'd rather
   not bring in the additional complexity.
 + Remove the strictness flag parameter to assertableTo, since it isn't
   used.

Change-Id: I812b8d1c49f3b714b166f061fbb7f2e683a0ce86
Reviewed-on: https://go-review.googlesource.com/c/go/+/278333
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/lookup.go    | 91 ++++++++++++++++++++++++++++++---------
 src/go/types/methodset.go |  5 ++-
 2 files changed, 75 insertions(+), 21 deletions(-)

diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go
index e7091a63e5..f385ac993f 100644
--- a/src/go/types/lookup.go
+++ b/src/go/types/lookup.go
@@ -55,7 +55,7 @@ func (check *Checker) lookupFieldOrMethod(T Type, addressable bool, pkg *Package
 	// Thus, if we have a named pointer type, proceed with the underlying
 	// pointer type but discard the result if it is a method since we would
 	// not have found it for T (see also issue 8590).
-	if t, _ := T.(*Named); t != nil {
+	if t := asNamed(T); t != nil {
 		if p, _ := t.underlying.(*Pointer); p != nil {
 			obj, index, indirect = check.rawLookupFieldOrMethod(p, false, pkg, name)
 			if _, ok := obj.(*Func); ok {
@@ -85,7 +85,8 @@ func (check *Checker) rawLookupFieldOrMethod(T Type, addressable bool, pkg *Pack
 	typ, isPtr := deref(T)
 
 	// *typ where typ is an interface has no methods.
-	if isPtr && IsInterface(typ) {
+	// Be cautious: typ may be nil (issue 39634, crash #3).
+	if typ == nil || isPtr && IsInterface(typ) {
 		return
 	}
 
@@ -106,12 +107,13 @@ func (check *Checker) rawLookupFieldOrMethod(T Type, addressable bool, pkg *Pack
 		var next []embeddedType // embedded types found at current depth
 
 		// look for (pkg, name) in all types at current depth
+		var tpar *TypeParam // set if obj receiver is a type parameter
 		for _, e := range current {
 			typ := e.typ
 
 			// If we have a named type, we may have associated methods.
 			// Look for those first.
-			if named, _ := typ.(*Named); named != nil {
+			if named := asNamed(typ); named != nil {
 				if seen[named] {
 					// We have seen this type before, at a more shallow depth
 					// (note that multiples of this type at the current depth
@@ -138,10 +140,15 @@ func (check *Checker) rawLookupFieldOrMethod(T Type, addressable bool, pkg *Pack
 					continue // we can't have a matching field or interface method
 				}
 
-				// continue with underlying type
-				typ = named.underlying
+				// continue with underlying type, but only if it's not a type parameter
+				// TODO(gri) is this what we want to do for type parameters? (spec question)
+				typ = named.under()
+				if asTypeParam(typ) != nil {
+					continue
+				}
 			}
 
+			tpar = nil
 			switch t := typ.(type) {
 			case *Struct:
 				// look for a matching field and collect embedded types
@@ -187,6 +194,20 @@ func (check *Checker) rawLookupFieldOrMethod(T Type, addressable bool, pkg *Pack
 					obj = m
 					indirect = e.indirect
 				}
+
+			case *TypeParam:
+				// only consider explicit methods in the type parameter bound, not
+				// methods that may be common to all types in the type list.
+				if i, m := lookupMethod(t.Bound().allMethods, pkg, name); m != nil {
+					assert(m.typ != nil)
+					index = concat(e.index, i)
+					if obj != nil || e.multiples {
+						return nil, index, false // collision
+					}
+					tpar = t
+					obj = m
+					indirect = e.indirect
+				}
 			}
 		}
 
@@ -196,8 +217,12 @@ func (check *Checker) rawLookupFieldOrMethod(T Type, addressable bool, pkg *Pack
 			//        contains m and the argument list can be assigned to the parameter
 			//        list of m. If x is addressable and &x's method set contains m, x.m()
 			//        is shorthand for (&x).m()".
-			if f, _ := obj.(*Func); f != nil && ptrRecv(f) && !indirect && !addressable {
-				return nil, nil, true // pointer/addressable receiver required
+			if f, _ := obj.(*Func); f != nil {
+				// determine if method has a pointer receiver
+				hasPtrRecv := tpar == nil && ptrRecv(f)
+				if hasPtrRecv && !indirect && !addressable {
+					return nil, nil, true // pointer/addressable receiver required
+				}
 			}
 			return
 		}
@@ -269,7 +294,8 @@ func MissingMethod(V Type, T *Interface, static bool) (method *Func, wrongType b
 	return m, typ != nil
 }
 
-// missingMethod is like MissingMethod but accepts a receiver.
+// missingMethod is like MissingMethod but accepts a *Checker as
+// receiver and an addressable flag.
 // The receiver may be nil if missingMethod is invoked through
 // an exported API call (such as MissingMethod), i.e., when all
 // methods have been type-checked.
@@ -285,25 +311,37 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
 		return
 	}
 
-	if ityp, _ := V.Underlying().(*Interface); ityp != nil {
+	if ityp := asInterface(V); ityp != nil {
 		check.completeInterface(token.NoPos, ityp)
 		// TODO(gri) allMethods is sorted - can do this more efficiently
 		for _, m := range T.allMethods {
-			_, obj := lookupMethod(ityp.allMethods, m.pkg, m.name)
-			switch {
-			case obj == nil:
-				if static {
-					return m, nil
+			_, f := lookupMethod(ityp.allMethods, m.pkg, m.name)
+
+			if f == nil {
+				// if m is the magic method == we're ok (interfaces are comparable)
+				if m.name == "==" || !static {
+					continue
 				}
-			case !check.identical(obj.Type(), m.typ):
-				return m, obj
+				return m, f
+			}
+
+			if !check.identical(f.Type(), m.Type()) {
+				return m, f
 			}
+
+			// TODO(rFindley) delete this note once the spec has stabilized to
+			//                exclude method type parameters.
+			// NOTE: if enabling method type parameters, we need to unify f.Type()
+			// and m.Type() here to verify that their type parameters align (assuming
+			// this behaves correctly with respect to type bounds).
 		}
+
 		return
 	}
 
 	// A concrete type implements T if it implements all methods of T.
 	for _, m := range T.allMethods {
+		// TODO(gri) should this be calling lookupFieldOrMethod instead (and why not)?
 		obj, _, _ := check.rawLookupFieldOrMethod(V, false, m.pkg, m.name)
 
 		// Check if *V implements this method of T.
@@ -318,6 +356,10 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
 		// we must have a method (not a field of matching function type)
 		f, _ := obj.(*Func)
 		if f == nil {
+			// if m is the magic method == and V is comparable, we're ok
+			if m.name == "==" && Comparable(V) {
+				continue
+			}
 			return m, nil
 		}
 
@@ -326,9 +368,16 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
 			check.objDecl(f, nil)
 		}
 
-		if !check.identical(f.typ, m.typ) {
+		if !check.identical(f.Type(), m.Type()) {
 			return m, f
 		}
+
+		// TODO(rFindley) delete this note once the spec has stabilized to exclude
+		//                method type parameters.
+		// NOTE: if enabling method type parameters, one needs to subst any
+		// receiver type parameters for V here, and unify f.Type() with m.Type() to
+		// verify that their type parameters align (assuming this behaves correctly
+		// with respect to type bounds).
 	}
 
 	return
@@ -339,11 +388,13 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
 // method required by V and whether it is missing or just has the wrong type.
 // The receiver may be nil if assertableTo is invoked through an exported API call
 // (such as AssertableTo), i.e., when all methods have been type-checked.
+// If the global constant forceStrict is set, assertions that are known to fail
+// are not permitted.
 func (check *Checker) assertableTo(V *Interface, T Type) (method, wrongType *Func) {
 	// no static check is required if T is an interface
 	// spec: "If T is an interface type, x.(T) asserts that the
 	//        dynamic type of x implements the interface T."
-	if _, ok := T.Underlying().(*Interface); ok && !forceStrict {
+	if asInterface(T) != nil && !forceStrict {
 		return
 	}
 	return check.missingMethod(T, V, false)
@@ -361,8 +412,8 @@ func deref(typ Type) (Type, bool) {
 // derefStructPtr dereferences typ if it is a (named or unnamed) pointer to a
 // (named or unnamed) struct and returns its base. Otherwise it returns typ.
 func derefStructPtr(typ Type) Type {
-	if p, _ := typ.Underlying().(*Pointer); p != nil {
-		if _, ok := p.base.Underlying().(*Struct); ok {
+	if p := asPointer(typ); p != nil {
+		if asStruct(p.base) != nil {
 			return p.base
 		}
 	}
diff --git a/src/go/types/methodset.go b/src/go/types/methodset.go
index c34d732b7a..c44009f1a5 100644
--- a/src/go/types/methodset.go
+++ b/src/go/types/methodset.go
@@ -73,6 +73,9 @@ func NewMethodSet(T Type) *MethodSet {
 	// WARNING: The code in this function is extremely subtle - do not modify casually!
 	//          This function and lookupFieldOrMethod should be kept in sync.
 
+	// TODO(gri) This code is out-of-sync with the lookup code at this point.
+	//           Need to update.
+
 	// method set up to the current depth, allocated lazily
 	var base methodSet
 
@@ -108,7 +111,7 @@ func NewMethodSet(T Type) *MethodSet {
 
 			// If we have a named type, we may have associated methods.
 			// Look for those first.
-			if named, _ := typ.(*Named); named != nil {
+			if named := asNamed(typ); named != nil {
 				if seen[named] {
 					// We have seen this type before, at a more shallow depth
 					// (note that multiples of this type at the current depth
-- 
GitLab


From ceb77db24f06584628cb02702cf8aa5998de1a66 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 15 Dec 2020 18:31:41 -0500
Subject: [PATCH 0230/2400] [dev.typeparams] go/types: import some support
 functions from dev.go2go

Import dev.go2go changes for exprstring.go, sizes.go, and scope.go.
These files have been reviewed, but are unmodified.

Change-Id: I9df9f8967bab73ce535a539b049346a872877572
Reviewed-on: https://go-review.googlesource.com/c/go/+/278593
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/go/types/exprstring.go | 74 +++++++++++++++++++++++++++-----------
 src/go/types/scope.go      | 34 ++++++++++++++++++
 src/go/types/sizes.go      |  8 +++--
 3 files changed, 93 insertions(+), 23 deletions(-)

diff --git a/src/go/types/exprstring.go b/src/go/types/exprstring.go
index 28d605f5ee..0d9ae58dfc 100644
--- a/src/go/types/exprstring.go
+++ b/src/go/types/exprstring.go
@@ -8,6 +8,7 @@ package types
 
 import (
 	"bytes"
+	"fmt"
 	"go/ast"
 )
 
@@ -31,7 +32,7 @@ func WriteExpr(buf *bytes.Buffer, x ast.Expr) {
 
 	switch x := x.(type) {
 	default:
-		buf.WriteString("(bad expr)") // nil, ast.BadExpr, ast.KeyValueExpr
+		buf.WriteString(fmt.Sprintf("(ast: %T)", x)) // nil, ast.BadExpr, ast.KeyValueExpr
 
 	case *ast.Ident:
 		buf.WriteString(x.Name)
@@ -97,17 +98,16 @@ func WriteExpr(buf *bytes.Buffer, x ast.Expr) {
 
 	case *ast.CallExpr:
 		WriteExpr(buf, x.Fun)
-		buf.WriteByte('(')
-		for i, arg := range x.Args {
-			if i > 0 {
-				buf.WriteString(", ")
-			}
-			WriteExpr(buf, arg)
+		var l, r byte = '(', ')'
+		if x.Brackets {
+			l, r = '[', ']'
 		}
+		buf.WriteByte(l)
+		writeExprList(buf, x.Args)
 		if x.Ellipsis.IsValid() {
 			buf.WriteString("...")
 		}
-		buf.WriteByte(')')
+		buf.WriteByte(r)
 
 	case *ast.StarExpr:
 		buf.WriteByte('*')
@@ -134,7 +134,7 @@ func WriteExpr(buf *bytes.Buffer, x ast.Expr) {
 
 	case *ast.StructType:
 		buf.WriteString("struct{")
-		writeFieldList(buf, x.Fields, "; ", false)
+		writeFieldList(buf, x.Fields.List, "; ", false)
 		buf.WriteByte('}')
 
 	case *ast.FuncType:
@@ -142,8 +142,29 @@ func WriteExpr(buf *bytes.Buffer, x ast.Expr) {
 		writeSigExpr(buf, x)
 
 	case *ast.InterfaceType:
+		// separate type list types from method list
+		// TODO(gri) we can get rid of this extra code if writeExprList does the separation
+		var types []ast.Expr
+		var methods []*ast.Field
+		for _, f := range x.Methods.List {
+			if len(f.Names) > 1 && f.Names[0].Name == "type" {
+				// type list type
+				types = append(types, f.Type)
+			} else {
+				// method or embedded interface
+				methods = append(methods, f)
+			}
+		}
+
 		buf.WriteString("interface{")
-		writeFieldList(buf, x.Methods, "; ", true)
+		writeFieldList(buf, methods, "; ", true)
+		if len(types) > 0 {
+			if len(methods) > 0 {
+				buf.WriteString("; ")
+			}
+			buf.WriteString("type ")
+			writeExprList(buf, types)
+		}
 		buf.WriteByte('}')
 
 	case *ast.MapType:
@@ -169,7 +190,7 @@ func WriteExpr(buf *bytes.Buffer, x ast.Expr) {
 
 func writeSigExpr(buf *bytes.Buffer, sig *ast.FuncType) {
 	buf.WriteByte('(')
-	writeFieldList(buf, sig.Params, ", ", false)
+	writeFieldList(buf, sig.Params.List, ", ", false)
 	buf.WriteByte(')')
 
 	res := sig.Results
@@ -188,23 +209,18 @@ func writeSigExpr(buf *bytes.Buffer, sig *ast.FuncType) {
 
 	// multiple or named result(s)
 	buf.WriteByte('(')
-	writeFieldList(buf, res, ", ", false)
+	writeFieldList(buf, res.List, ", ", false)
 	buf.WriteByte(')')
 }
 
-func writeFieldList(buf *bytes.Buffer, fields *ast.FieldList, sep string, iface bool) {
-	for i, f := range fields.List {
+func writeFieldList(buf *bytes.Buffer, list []*ast.Field, sep string, iface bool) {
+	for i, f := range list {
 		if i > 0 {
 			buf.WriteString(sep)
 		}
 
 		// field list names
-		for i, name := range f.Names {
-			if i > 0 {
-				buf.WriteString(", ")
-			}
-			buf.WriteString(name.Name)
-		}
+		writeIdentList(buf, f.Names)
 
 		// types of interface methods consist of signatures only
 		if sig, _ := f.Type.(*ast.FuncType); sig != nil && iface {
@@ -222,3 +238,21 @@ func writeFieldList(buf *bytes.Buffer, fields *ast.FieldList, sep string, iface
 		// ignore tag
 	}
 }
+
+func writeIdentList(buf *bytes.Buffer, list []*ast.Ident) {
+	for i, x := range list {
+		if i > 0 {
+			buf.WriteString(", ")
+		}
+		buf.WriteString(x.Name)
+	}
+}
+
+func writeExprList(buf *bytes.Buffer, list []ast.Expr) {
+	for i, x := range list {
+		if i > 0 {
+			buf.WriteString(", ")
+		}
+		WriteExpr(buf, x)
+	}
+}
diff --git a/src/go/types/scope.go b/src/go/types/scope.go
index 8c9d9ab8b8..157b1b7066 100644
--- a/src/go/types/scope.go
+++ b/src/go/types/scope.go
@@ -108,6 +108,40 @@ func (s *Scope) Insert(obj Object) Object {
 	return nil
 }
 
+// Squash merges s with its parent scope p by adding all
+// objects of s to p, adding all children of s to the
+// children of p, and removing s from p's children.
+// The function f is called for each object obj in s which
+// has an object alt in p. s should be discarded after
+// having been squashed.
+func (s *Scope) Squash(err func(obj, alt Object)) {
+	p := s.parent
+	assert(p != nil)
+	for _, obj := range s.elems {
+		obj.setParent(nil)
+		if alt := p.Insert(obj); alt != nil {
+			err(obj, alt)
+		}
+	}
+
+	j := -1 // index of s in p.children
+	for i, ch := range p.children {
+		if ch == s {
+			j = i
+			break
+		}
+	}
+	assert(j >= 0)
+	k := len(p.children) - 1
+	p.children[j] = p.children[k]
+	p.children = p.children[:k]
+
+	p.children = append(p.children, s.children...)
+
+	s.children = nil
+	s.elems = nil
+}
+
 // Pos and End describe the scope's source code extent [pos, end).
 // The results are guaranteed to be valid only if the type-checked
 // AST has complete position information. The extent is undefined
diff --git a/src/go/types/sizes.go b/src/go/types/sizes.go
index 6ab6157b82..e8377a4f92 100644
--- a/src/go/types/sizes.go
+++ b/src/go/types/sizes.go
@@ -48,7 +48,7 @@ type StdSizes struct {
 func (s *StdSizes) Alignof(T Type) int64 {
 	// For arrays and structs, alignment is defined in terms
 	// of alignment of the elements and fields, respectively.
-	switch t := T.Underlying().(type) {
+	switch t := optype(T).(type) {
 	case *Array:
 		// spec: "For a variable x of array type: unsafe.Alignof(x)
 		// is the same as unsafe.Alignof(x[0]), but at least 1."
@@ -118,7 +118,7 @@ var basicSizes = [...]byte{
 }
 
 func (s *StdSizes) Sizeof(T Type) int64 {
-	switch t := T.Underlying().(type) {
+	switch t := optype(T).(type) {
 	case *Basic:
 		assert(isTyped(T))
 		k := t.kind
@@ -148,6 +148,8 @@ func (s *StdSizes) Sizeof(T Type) int64 {
 		}
 		offsets := s.Offsetsof(t.fields)
 		return offsets[n-1] + s.Sizeof(t.fields[n-1].typ)
+	case *Sum:
+		panic("Sizeof unimplemented for type sum")
 	case *Interface:
 		return s.WordSize * 2
 	}
@@ -239,7 +241,7 @@ func (conf *Config) offsetsof(T *Struct) []int64 {
 func (conf *Config) offsetof(typ Type, index []int) int64 {
 	var o int64
 	for _, i := range index {
-		s := typ.Underlying().(*Struct)
+		s := asStruct(typ)
 		o += conf.offsetsof(s)[i]
 		typ = s.fields[i].typ
 	}
-- 
GitLab


From f38da2cbb66cadebd3b6887c48919269f37ca69d Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 15 Dec 2020 12:17:01 -0800
Subject: [PATCH 0231/2400] [dev.typeparams] cmd/compile/internal/types2:
 review of unify.go

Make unify.go match the corresponding and reviewed go/types version.
The remaining differences are due to other differences in the packages.
Also, this version of unify opted to preserve the longer comment around
case tj > 0.

$ diff $GOROOT/src/cmd/compile/internal/types2/unify.go $GOROOT/src/go/types/unify.go
7c7
< package types2
---
> package types
9c9,12
< import "sort"
---
> import (
> 	"go/token"
> 	"sort"
> )
120,123d122
< 	// This case is handled like the default case.
< 	// case tj > 0:
< 	// 	// Only the type parameter for y has an inferred type. Use y slot for x.
< 	// 	u.x.setIndex(i, tj)
125,126c124,125
< 		// Neither type parameter has an inferred type. Use y slot for x
< 		// (or x slot for y, it doesn't matter).
---
> 		// Either the type parameter for y has an inferred type, or neither type
> 		// parameter has an inferred type. In either case, use y slot for x.
216c215
< 		// basic types and type parameters. We use Named() because we only
---
> 		// basic types and type parameters. We use asNamed() because we only
219,222c218,221
< 		case !isNamed(x) && y != nil && y.Named() != nil:
< 			return u.nify(x, y.Under(), p)
< 		case x != nil && x.Named() != nil && !isNamed(y):
< 			return u.nify(x.Under(), y, p)
---
> 		case !isNamed(x) && y != nil && asNamed(y) != nil:
> 			return u.nify(x, under(y), p)
> 		case x != nil && asNamed(x) != nil && !isNamed(y):
> 			return u.nify(under(x), y, p)
353,354c352,353
< 				u.check.completeInterface(nopos, x)
< 				u.check.completeInterface(nopos, y)
---
> 				u.check.completeInterface(token.NoPos, x)
> 				u.check.completeInterface(token.NoPos, y)

Change-Id: Icb246d4befedfa82cc3dcfdb7dd162cd4127fbe9
Reviewed-on: https://go-review.googlesource.com/c/go/+/278572
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/unify.go | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/types2/unify.go b/src/cmd/compile/internal/types2/unify.go
index 7c639366ef..60ccf625b9 100644
--- a/src/cmd/compile/internal/types2/unify.go
+++ b/src/cmd/compile/internal/types2/unify.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2020 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.
@@ -17,7 +16,7 @@ import "sort"
 // (even if that also contains possibly the same type parameters). This
 // is crucial to infer the type parameters of self-recursive calls:
 //
-//	func f[type P](a P) { f(a) }
+//	func f[P any](a P) { f(a) }
 //
 // For the call f(a) we want to infer that the type argument for P is P.
 // During unification, the parameter type P must be resolved to the type
@@ -63,9 +62,9 @@ type tparamsList struct {
 	unifier *unifier
 	tparams []*TypeName
 	// For each tparams element, there is a corresponding type slot index in indices.
-	// index  < 0: unifier.types[-index] == nil
+	// index  < 0: unifier.types[-index-1] == nil
 	// index == 0: no type slot allocated yet
-	// index  > 0: unifier.types[index] == typ
+	// index  > 0: unifier.types[index-1] == typ
 	// Joined tparams elements share the same type slot and thus have the same index.
 	// By using a negative index for nil types we don't need to check unifier.types
 	// to see if we have a type or not.
-- 
GitLab


From 09abd23d9efecda2cec40ef6b8ca2cd93e220b40 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 15 Dec 2020 18:38:53 -0500
Subject: [PATCH 0232/2400] [dev.typeparams] go/types: import predicates.go
 from dev.go2go

Changes from dev.go2go:
 + Update some isComparable cases to use the seen map.
 + Tiny updates to comments.

Change-Id: Iafd85d60835f17a87f514d9774cae07c183ee6cc
Reviewed-on: https://go-review.googlesource.com/c/go/+/278594
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/expr.go       |  44 +++++----
 src/go/types/predicates.go | 184 +++++++++++++++++++++++++++----------
 2 files changed, 162 insertions(+), 66 deletions(-)

diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 51714790cb..c57edf8f0d 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -58,11 +58,16 @@ the type (and constant value, if any) is recorded via Info.Types, if present.
 
 type opPredicates map[token.Token]func(Type) bool
 
-var unaryOpPredicates = opPredicates{
-	token.ADD: isNumeric,
-	token.SUB: isNumeric,
-	token.XOR: isInteger,
-	token.NOT: isBoolean,
+var unaryOpPredicates opPredicates
+
+func init() {
+	// Setting unaryOpPredicates in init avoids declaration cycles.
+	unaryOpPredicates = opPredicates{
+		token.ADD: isNumeric,
+		token.SUB: isNumeric,
+		token.XOR: isInteger,
+		token.NOT: isBoolean,
+	}
 }
 
 func (check *Checker) op(m opPredicates, x *operand, op token.Token) bool {
@@ -785,20 +790,25 @@ func (check *Checker) shift(x, y *operand, e *ast.BinaryExpr, op token.Token) {
 	x.mode = value
 }
 
-var binaryOpPredicates = opPredicates{
-	token.ADD: func(typ Type) bool { return isNumeric(typ) || isString(typ) },
-	token.SUB: isNumeric,
-	token.MUL: isNumeric,
-	token.QUO: isNumeric,
-	token.REM: isInteger,
+var binaryOpPredicates opPredicates
+
+func init() {
+	// Setting binaryOpPredicates in init avoids declaration cycles.
+	binaryOpPredicates = opPredicates{
+		token.ADD: isNumericOrString,
+		token.SUB: isNumeric,
+		token.MUL: isNumeric,
+		token.QUO: isNumeric,
+		token.REM: isInteger,
 
-	token.AND:     isInteger,
-	token.OR:      isInteger,
-	token.XOR:     isInteger,
-	token.AND_NOT: isInteger,
+		token.AND:     isInteger,
+		token.OR:      isInteger,
+		token.XOR:     isInteger,
+		token.AND_NOT: isInteger,
 
-	token.LAND: isBoolean,
-	token.LOR:  isBoolean,
+		token.LAND: isBoolean,
+		token.LOR:  isBoolean,
+	}
 }
 
 // The binary expression e may be nil. It's passed in for better error messages only.
diff --git a/src/go/types/predicates.go b/src/go/types/predicates.go
index d580796d98..85e2b9a0ca 100644
--- a/src/go/types/predicates.go
+++ b/src/go/types/predicates.go
@@ -11,73 +11,79 @@ import (
 	"sort"
 )
 
+// isNamed reports whether typ has a name.
+// isNamed may be called with types that are not fully set up.
 func isNamed(typ Type) bool {
-	if _, ok := typ.(*Basic); ok {
-		return ok
+	switch typ.(type) {
+	case *Basic, *Named, *TypeParam, *instance:
+		return true
 	}
-	_, ok := typ.(*Named)
-	return ok
-}
-
-func isBoolean(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsBoolean != 0
-}
-
-func isInteger(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsInteger != 0
-}
-
-func isUnsigned(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsUnsigned != 0
-}
-
-func isFloat(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsFloat != 0
-}
-
-func isComplex(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsComplex != 0
+	return false
 }
 
-func isNumeric(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsNumeric != 0
+// isGeneric reports whether a type is a generic, uninstantiated type (generic
+// signatures are not included).
+func isGeneric(typ Type) bool {
+	// A parameterized type is only instantiated if it doesn't have an instantiation already.
+	named, _ := typ.(*Named)
+	return named != nil && named.obj != nil && named.tparams != nil && named.targs == nil
 }
 
-func isString(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsString != 0
+func is(typ Type, what BasicInfo) bool {
+	switch t := optype(typ).(type) {
+	case *Basic:
+		return t.info&what != 0
+	case *Sum:
+		return t.is(func(typ Type) bool { return is(typ, what) })
+	}
+	return false
 }
 
+func isBoolean(typ Type) bool  { return is(typ, IsBoolean) }
+func isInteger(typ Type) bool  { return is(typ, IsInteger) }
+func isUnsigned(typ Type) bool { return is(typ, IsUnsigned) }
+func isFloat(typ Type) bool    { return is(typ, IsFloat) }
+func isComplex(typ Type) bool  { return is(typ, IsComplex) }
+func isNumeric(typ Type) bool  { return is(typ, IsNumeric) }
+func isString(typ Type) bool   { return is(typ, IsString) }
+
+// Note that if typ is a type parameter, isInteger(typ) || isFloat(typ) does not
+// produce the expected result because a type list that contains both an integer
+// and a floating-point type is neither (all) integers, nor (all) floats.
+// Use isIntegerOrFloat instead.
+func isIntegerOrFloat(typ Type) bool { return is(typ, IsInteger|IsFloat) }
+
+// isNumericOrString is the equivalent of isIntegerOrFloat for isNumeric(typ) || isString(typ).
+func isNumericOrString(typ Type) bool { return is(typ, IsNumeric|IsString) }
+
+// isTyped reports whether typ is typed; i.e., not an untyped
+// constant or boolean. isTyped may be called with types that
+// are not fully set up.
 func isTyped(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return !ok || t.info&IsUntyped == 0
+	// isTyped is called with types that are not fully
+	// set up. Must not call asBasic()!
+	// A *Named or *instance type is always typed, so
+	// we only need to check if we have a true *Basic
+	// type.
+	t, _ := typ.(*Basic)
+	return t == nil || t.info&IsUntyped == 0
 }
 
+// isUntyped(typ) is the same as !isTyped(typ).
 func isUntyped(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsUntyped != 0
+	return !isTyped(typ)
 }
 
-func isOrdered(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsOrdered != 0
-}
+func isOrdered(typ Type) bool { return is(typ, IsOrdered) }
 
 func isConstType(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsConstType != 0
+	t := asBasic(typ)
+	return t != nil && t.info&IsConstType != 0
 }
 
 // IsInterface reports whether typ is an interface type.
 func IsInterface(typ Type) bool {
-	_, ok := typ.Underlying().(*Interface)
-	return ok
+	return asInterface(typ) != nil
 }
 
 // Comparable reports whether values of type T are comparable.
@@ -94,7 +100,19 @@ func comparable(T Type, seen map[Type]bool) bool {
 	}
 	seen[T] = true
 
-	switch t := T.Underlying().(type) {
+	// If T is a type parameter not constrained by any type
+	// list (i.e., it's underlying type is the top type),
+	// T is comparable if it has the == method. Otherwise,
+	// the underlying type "wins". For instance
+	//
+	//     interface{ comparable; type []byte }
+	//
+	// is not comparable because []byte is not comparable.
+	if t := asTypeParam(T); t != nil && optype(t) == theTop {
+		return t.Bound().IsComparable()
+	}
+
+	switch t := optype(T).(type) {
 	case *Basic:
 		// assume invalid types to be comparable
 		// to avoid follow-up errors
@@ -110,17 +128,26 @@ func comparable(T Type, seen map[Type]bool) bool {
 		return true
 	case *Array:
 		return comparable(t.elem, seen)
+	case *Sum:
+		pred := func(t Type) bool {
+			return comparable(t, seen)
+		}
+		return t.is(pred)
+	case *TypeParam:
+		return t.Bound().IsComparable()
 	}
 	return false
 }
 
 // hasNil reports whether a type includes the nil value.
 func hasNil(typ Type) bool {
-	switch t := typ.Underlying().(type) {
+	switch t := optype(typ).(type) {
 	case *Basic:
 		return t.kind == UnsafePointer
 	case *Slice, *Pointer, *Signature, *Interface, *Map, *Chan:
 		return true
+	case *Sum:
+		return t.is(hasNil)
 	}
 	return false
 }
@@ -147,7 +174,12 @@ func (p *ifacePair) identical(q *ifacePair) bool {
 	return p.x == q.x && p.y == q.y || p.x == q.y && p.y == q.x
 }
 
+// For changes to this code the corresponding changes should be made to unifier.nify.
 func (check *Checker) identical0(x, y Type, cmpTags bool, p *ifacePair) bool {
+	// types must be expanded for comparison
+	x = expandf(x)
+	y = expandf(y)
+
 	if x == y {
 		return true
 	}
@@ -224,12 +256,38 @@ func (check *Checker) identical0(x, y Type, cmpTags bool, p *ifacePair) bool {
 		// and result values, corresponding parameter and result types are identical,
 		// and either both functions are variadic or neither is. Parameter and result
 		// names are not required to match.
+		// Generic functions must also have matching type parameter lists, but for the
+		// parameter names.
 		if y, ok := y.(*Signature); ok {
 			return x.variadic == y.variadic &&
+				check.identicalTParams(x.tparams, y.tparams, cmpTags, p) &&
 				check.identical0(x.params, y.params, cmpTags, p) &&
 				check.identical0(x.results, y.results, cmpTags, p)
 		}
 
+	case *Sum:
+		// Two sum types are identical if they contain the same types.
+		// (Sum types always consist of at least two types. Also, the
+		// the set (list) of types in a sum type consists of unique
+		// types - each type appears exactly once. Thus, two sum types
+		// must contain the same number of types to have chance of
+		// being equal.
+		if y, ok := y.(*Sum); ok && len(x.types) == len(y.types) {
+			// Every type in x.types must be in y.types.
+			// Quadratic algorithm, but probably good enough for now.
+			// TODO(gri) we need a fast quick type ID/hash for all types.
+		L:
+			for _, x := range x.types {
+				for _, y := range y.types {
+					if Identical(x, y) {
+						continue L // x is in y.types
+					}
+				}
+				return false // x is not in y.types
+			}
+			return true
+		}
+
 	case *Interface:
 		// Two interface types are identical if they have the same set of methods with
 		// the same names and identical function types. Lower-case method names from
@@ -306,10 +364,25 @@ func (check *Checker) identical0(x, y Type, cmpTags bool, p *ifacePair) bool {
 		// Two named types are identical if their type names originate
 		// in the same type declaration.
 		if y, ok := y.(*Named); ok {
+			// TODO(gri) Why is x == y not sufficient? And if it is,
+			//           we can just return false here because x == y
+			//           is caught in the very beginning of this function.
 			return x.obj == y.obj
 		}
 
+	case *TypeParam:
+		// nothing to do (x and y being equal is caught in the very beginning of this function)
+
+	// case *instance:
+	//	unreachable since types are expanded
+
+	case *bottom, *top:
+		// Either both types are theBottom, or both are theTop in which
+		// case the initial x == y check will have caught them. Otherwise
+		// they are not identical.
+
 	case nil:
+		// avoid a crash in case of nil type
 
 	default:
 		unreachable()
@@ -318,6 +391,19 @@ func (check *Checker) identical0(x, y Type, cmpTags bool, p *ifacePair) bool {
 	return false
 }
 
+func (check *Checker) identicalTParams(x, y []*TypeName, cmpTags bool, p *ifacePair) bool {
+	if len(x) != len(y) {
+		return false
+	}
+	for i, x := range x {
+		y := y[i]
+		if !check.identical0(x.typ.(*TypeParam).bound, y.typ.(*TypeParam).bound, cmpTags, p) {
+			return false
+		}
+	}
+	return true
+}
+
 // Default returns the default "typed" type for an "untyped" type;
 // it returns the incoming type for all other types. The default type
 // for untyped nil is untyped nil.
-- 
GitLab


From 3b5918c757eb32b4a05a0b4ba4bbab001175ebf0 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 15 Dec 2020 17:48:51 -0800
Subject: [PATCH 0233/2400] [dev.typeparams] cmd/compile/internal/types2:
 review of predicates.go

Make predicates.go match the corresponding and reviewed go/types version.

The remaining diffs are due to the difference in the implementations
of the type conversion methods/functions:

$ diff $GOROOT/src/cmd/compile/internal/types2/predicates.go $GOROOT/src/go/types/predicates.go
7c7
< package types2
---
> package types
9a10
> 	"go/token"
32c33
< 	switch t := optype(typ.Under()).(type) {
---
> 	switch t := optype(typ).(type) {
63c64
< 	// set up. Must not call Basic()!
---
> 	// set up. Must not call asBasic()!
79c80
< 	t := typ.Basic()
---
> 	t := asBasic(typ)
85c86
< 	return typ.Interface() != nil
---
> 	return asInterface(typ) != nil
110c111
< 	if t := T.TypeParam(); t != nil && optype(t) == theTop {
---
> 	if t := asTypeParam(T); t != nil && optype(t) == theTop {
114c115
< 	switch t := optype(T.Under()).(type) {
---
> 	switch t := optype(T).(type) {
143c144
< 	switch t := optype(typ.Under()).(type) {
---
> 	switch t := optype(typ).(type) {
300,301c301,302
< 				check.completeInterface(nopos, x)
< 				check.completeInterface(nopos, y)
---
> 				check.completeInterface(token.NoPos, x)
> 				check.completeInterface(token.NoPos, y)

Change-Id: I174d8a8a22fbd8814ede25002cb2705588912329
Reviewed-on: https://go-review.googlesource.com/c/go/+/278474
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/predicates.go | 28 ++++++++++---------
 1 file changed, 15 insertions(+), 13 deletions(-)

diff --git a/src/cmd/compile/internal/types2/predicates.go b/src/cmd/compile/internal/types2/predicates.go
index 048519471c..b910d8d0ee 100644
--- a/src/cmd/compile/internal/types2/predicates.go
+++ b/src/cmd/compile/internal/types2/predicates.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2012 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.
@@ -21,7 +20,8 @@ func isNamed(typ Type) bool {
 	return false
 }
 
-// isGeneric reports whether a type is a generic, uninstantiated type (generic signatures are not included).
+// isGeneric reports whether a type is a generic, uninstantiated type (generic
+// signatures are not included).
 func isGeneric(typ Type) bool {
 	// A parameterized type is only instantiated if it doesn't have an instantiation already.
 	named, _ := typ.(*Named)
@@ -90,9 +90,16 @@ func Comparable(T Type) bool {
 	return comparable(T, nil)
 }
 
-// comparable should only be called by Comparable.
 func comparable(T Type, seen map[Type]bool) bool {
-	// If T is a type parameter not constraint by any type
+	if seen[T] {
+		return true
+	}
+	if seen == nil {
+		seen = make(map[Type]bool)
+	}
+	seen[T] = true
+
+	// If T is a type parameter not constrained by any type
 	// list (i.e., it's underlying type is the top type),
 	// T is comparable if it has the == method. Otherwise,
 	// the underlying type "wins". For instance
@@ -104,14 +111,6 @@ func comparable(T Type, seen map[Type]bool) bool {
 		return t.Bound().IsComparable()
 	}
 
-	if seen[T] {
-		return true
-	}
-	if seen == nil {
-		seen = make(map[Type]bool)
-	}
-	seen[T] = true
-
 	switch t := optype(T.Under()).(type) {
 	case *Basic:
 		// assume invalid types to be comparable
@@ -129,7 +128,10 @@ func comparable(T Type, seen map[Type]bool) bool {
 	case *Array:
 		return comparable(t.elem, seen)
 	case *Sum:
-		return t.is(Comparable)
+		pred := func(t Type) bool {
+			return comparable(t, seen)
+		}
+		return t.is(pred)
 	case *TypeParam:
 		return t.Bound().IsComparable()
 	}
-- 
GitLab


From 7909d6ec284da0e6a45bdf8fc2afdbb8bbcaeec2 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 15 Dec 2020 21:07:47 -0800
Subject: [PATCH 0234/2400] [dev.typeparams] cmd/compile/internal/syntax: type
 parameters must always be named

Report an error otherwise.

Change-Id: Ia76ea03a3f26b13dd9bca49f7bd42101d1ff1f9e
Reviewed-on: https://go-review.googlesource.com/c/go/+/278475
Trust: Robert Griesemer <gri@golang.org>
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/syntax/error_test.go |  6 +++-
 src/cmd/compile/internal/syntax/parser.go     | 34 +++++++++++++------
 .../internal/syntax/testdata/tparams.go2      | 22 ++++++++++++
 3 files changed, 51 insertions(+), 11 deletions(-)
 create mode 100644 src/cmd/compile/internal/syntax/testdata/tparams.go2

diff --git a/src/cmd/compile/internal/syntax/error_test.go b/src/cmd/compile/internal/syntax/error_test.go
index 72b1ad6333..919667f1d3 100644
--- a/src/cmd/compile/internal/syntax/error_test.go
+++ b/src/cmd/compile/internal/syntax/error_test.go
@@ -128,6 +128,10 @@ func testSyntaxErrors(t *testing.T, filename string) {
 	}
 	defer f.Close()
 
+	var mode Mode
+	if strings.HasSuffix(filename, ".go2") {
+		mode = AllowGenerics
+	}
 	ParseFile(filename, func(err error) {
 		e, ok := err.(Error)
 		if !ok {
@@ -162,7 +166,7 @@ func testSyntaxErrors(t *testing.T, filename string) {
 		} else {
 			t.Errorf("%s: unexpected error: %s", orig, e.Msg)
 		}
-	}, nil, 0)
+	}, nil, mode)
 
 	if *print {
 		fmt.Println()
diff --git a/src/cmd/compile/internal/syntax/parser.go b/src/cmd/compile/internal/syntax/parser.go
index 90b67def0f..e3fb1003a2 100644
--- a/src/cmd/compile/internal/syntax/parser.go
+++ b/src/cmd/compile/internal/syntax/parser.go
@@ -595,7 +595,7 @@ func (p *parser) typeDecl(group *Group) Decl {
 			p.xnest--
 			if name0, ok := x.(*Name); p.mode&AllowGenerics != 0 && ok && p.tok != _Rbrack {
 				// generic type
-				d.TParamList = p.paramList(name0, _Rbrack)
+				d.TParamList = p.paramList(name0, _Rbrack, true)
 				pos := p.pos()
 				if p.gotAssign() {
 					p.syntaxErrorAt(pos, "generic type cannot be alias")
@@ -664,7 +664,7 @@ func (p *parser) funcDeclOrNil() *FuncDecl {
 	f.Pragma = p.takePragma()
 
 	if p.got(_Lparen) {
-		rcvr := p.paramList(nil, _Rparen)
+		rcvr := p.paramList(nil, _Rparen, false)
 		switch len(rcvr) {
 		case 0:
 			p.error("method has no receiver")
@@ -688,7 +688,7 @@ func (p *parser) funcDeclOrNil() *FuncDecl {
 			p.syntaxError("empty type parameter list")
 			p.next()
 		} else {
-			f.TParamList = p.paramList(nil, _Rbrack)
+			f.TParamList = p.paramList(nil, _Rbrack, true)
 		}
 	}
 	f.Type = p.funcType()
@@ -1313,7 +1313,7 @@ func (p *parser) funcType() *FuncType {
 	typ := new(FuncType)
 	typ.pos = p.pos()
 	p.want(_Lparen)
-	typ.ParamList = p.paramList(nil, _Rparen)
+	typ.ParamList = p.paramList(nil, _Rparen, false)
 	typ.ResultList = p.funcResult()
 
 	return typ
@@ -1453,7 +1453,7 @@ func (p *parser) funcResult() []*Field {
 	}
 
 	if p.got(_Lparen) {
-		return p.paramList(nil, _Rparen)
+		return p.paramList(nil, _Rparen, false)
 	}
 
 	pos := p.pos()
@@ -1677,7 +1677,7 @@ func (p *parser) methodDecl() *Field {
 
 			// A type argument list looks like a parameter list with only
 			// types. Parse a parameter list and decide afterwards.
-			list := p.paramList(nil, _Rbrack)
+			list := p.paramList(nil, _Rbrack, false)
 			if len(list) == 0 {
 				// The type parameter list is not [] but we got nothing
 				// due to other errors (reported by paramList). Treat
@@ -1792,7 +1792,8 @@ func (p *parser) paramDeclOrNil(name *Name) *Field {
 // ParameterList = ParameterDecl { "," ParameterDecl } .
 // "(" or "[" has already been consumed.
 // If name != nil, it is the first name after "(" or "[".
-func (p *parser) paramList(name *Name, close token) (list []*Field) {
+// In the result list, either all fields have a name, or no field has a name.
+func (p *parser) paramList(name *Name, close token, requireNames bool) (list []*Field) {
 	if trace {
 		defer p.trace("paramList")()
 	}
@@ -1813,7 +1814,11 @@ func (p *parser) paramList(name *Name, close token) (list []*Field) {
 		return false
 	})
 
-	// distribute parameter types
+	if len(list) == 0 {
+		return
+	}
+
+	// distribute parameter types (len(list) > 0)
 	if named == 0 {
 		// all unnamed => found names are named types
 		for _, par := range list {
@@ -1822,9 +1827,12 @@ func (p *parser) paramList(name *Name, close token) (list []*Field) {
 				par.Name = nil
 			}
 		}
+		if requireNames {
+			p.syntaxErrorAt(list[0].Type.Pos(), "type parameters must be named")
+		}
 	} else if named != len(list) {
 		// some named => all must have names and types
-		var pos Pos // error position (or unknown)
+		var pos Pos // left-most error position (or unknown)
 		var typ Expr
 		for i := len(list) - 1; i >= 0; i-- {
 			if par := list[i]; par.Type != nil {
@@ -1844,7 +1852,13 @@ func (p *parser) paramList(name *Name, close token) (list []*Field) {
 			}
 		}
 		if pos.IsKnown() {
-			p.syntaxErrorAt(pos, "mixed named and unnamed parameters")
+			var msg string
+			if requireNames {
+				msg = "type parameters must be named"
+			} else {
+				msg = "mixed named and unnamed parameters"
+			}
+			p.syntaxErrorAt(pos, msg)
 		}
 	}
 
diff --git a/src/cmd/compile/internal/syntax/testdata/tparams.go2 b/src/cmd/compile/internal/syntax/testdata/tparams.go2
new file mode 100644
index 0000000000..42031c3277
--- /dev/null
+++ b/src/cmd/compile/internal/syntax/testdata/tparams.go2
@@ -0,0 +1,22 @@
+// Copyright 2020 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 p
+
+type t[ /* ERROR type parameters must be named */ a, b] struct{}
+type t[a t, b t, /* ERROR type parameters must be named */ c] struct{}
+type t struct {
+	t [n]byte
+	t[a]
+	t[a, b]
+}
+type t interface {
+	t[a]
+	m /* ERROR method cannot have type parameters */ [_ _, /* ERROR mixed */ _]()
+	t[a, b]
+}
+
+func f[ /* ERROR empty type parameter list */ ]()
+func f[ /* ERROR type parameters must be named */ a, b]()
+func f[a t, b t, /* ERROR type parameters must be named */ c]()
-- 
GitLab


From 068dd0470bb796f9497d3d069c0f3208fd4dda36 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 15 Dec 2020 21:55:28 -0800
Subject: [PATCH 0235/2400] [dev.typeparams] cmd/compile/internal/syntax: don't
 panic when providing -verify

The -verify flag is used to verify idempotent printing of syntax
trees. While syntax tree printing is not actively used at the
moment, the verification code still shouldn't panic.

Fixed the cause for the panic (after reading from a bytes.Buffer
that buffer is empty and so doesn't compare to the unread buffer),
and replaced the panic with a test error.

Added a test that makes sure the code invoked by -verify is run.

Change-Id: I38634ed7cfa8668deb0ea2ee9fb74a8f86cfc195
Reviewed-on: https://go-review.googlesource.com/c/go/+/278477
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 .../compile/internal/syntax/parser_test.go    | 23 ++++++++++++++-----
 1 file changed, 17 insertions(+), 6 deletions(-)

diff --git a/src/cmd/compile/internal/syntax/parser_test.go b/src/cmd/compile/internal/syntax/parser_test.go
index 70651efeae..ea9e9acc83 100644
--- a/src/cmd/compile/internal/syntax/parser_test.go
+++ b/src/cmd/compile/internal/syntax/parser_test.go
@@ -29,6 +29,14 @@ func TestParse(t *testing.T) {
 	ParseFile(*src_, func(err error) { t.Error(err) }, nil, AllowGenerics)
 }
 
+func TestVerify(t *testing.T) {
+	ast, err := ParseFile(*src_, func(err error) { t.Error(err) }, nil, AllowGenerics)
+	if err != nil {
+		return // error already reported
+	}
+	verifyPrint(t, *src_, ast)
+}
+
 func TestParseGo2(t *testing.T) {
 	dir := filepath.Join(testdata, "go2")
 	list, err := ioutil.ReadDir(dir)
@@ -91,7 +99,7 @@ func testStdLib(t *testing.T, mode Mode) {
 					return
 				}
 				if *verify {
-					verifyPrint(filename, ast)
+					verifyPrint(t, filename, ast)
 				}
 				results <- parseResult{filename, ast.EOF.Line()}
 			})
@@ -159,12 +167,13 @@ func walkDirs(t *testing.T, dir string, action func(string)) {
 	}
 }
 
-func verifyPrint(filename string, ast1 *File) {
+func verifyPrint(t *testing.T, filename string, ast1 *File) {
 	var buf1 bytes.Buffer
 	_, err := Fprint(&buf1, ast1, true)
 	if err != nil {
 		panic(err)
 	}
+	bytes1 := buf1.Bytes()
 
 	ast2, err := Parse(NewFileBase(filename), &buf1, nil, nil, 0)
 	if err != nil {
@@ -176,16 +185,18 @@ func verifyPrint(filename string, ast1 *File) {
 	if err != nil {
 		panic(err)
 	}
+	bytes2 := buf2.Bytes()
 
-	if bytes.Compare(buf1.Bytes(), buf2.Bytes()) != 0 {
+	if bytes.Compare(bytes1, bytes2) != 0 {
 		fmt.Printf("--- %s ---\n", filename)
-		fmt.Printf("%s\n", buf1.Bytes())
+		fmt.Printf("%s\n", bytes1)
 		fmt.Println()
 
 		fmt.Printf("--- %s ---\n", filename)
-		fmt.Printf("%s\n", buf2.Bytes())
+		fmt.Printf("%s\n", bytes2)
 		fmt.Println()
-		panic("not equal")
+
+		t.Error("printed syntax trees do not match")
 	}
 }
 
-- 
GitLab


From fa06894b36054e80e815ee538fb6f72c9e58f14a Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 7 Dec 2020 14:56:03 -0500
Subject: [PATCH 0236/2400] [dev.regabi] cmd/compile: cleanup preparing for
 concrete types

Avoid using the same variable for two different concrete
Node types in walk. This will smooth the introduction of
specific constructors, replacing ir.Nod and friends.

Passes buildall w/ toolstash -cmp.

Replay of CL 275884, lost to the bad-merge history rewrite.

Change-Id: I05628e20a19c9559ed7478526ef6cb2613f735e5
Reviewed-on: https://go-review.googlesource.com/c/go/+/277954
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/walk.go | 181 +++++++++++-----------------
 1 file changed, 70 insertions(+), 111 deletions(-)

diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index bbd81de40e..c9dbf91702 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -207,8 +207,7 @@ func walkstmt(n ir.Node) ir.Node {
 			}
 			nn := ir.Nod(ir.OAS, v.Name().Heapaddr, prealloc[v])
 			nn.SetColas(true)
-			nn = typecheck(nn, ctxStmt)
-			return walkstmt(nn)
+			return walkstmt(typecheck(nn, ctxStmt))
 		}
 		return n
 
@@ -480,10 +479,8 @@ func walkexpr(n ir.Node, init *ir.Nodes) ir.Node {
 
 	if n.Op() == ir.ONAME && n.Class() == ir.PAUTOHEAP {
 		nn := ir.Nod(ir.ODEREF, n.Name().Heapaddr, nil)
-		nn = typecheck(nn, ctxExpr)
-		nn = walkexpr(nn, init)
 		nn.Left().MarkNonNil()
-		return nn
+		return walkexpr(typecheck(nn, ctxExpr), init)
 	}
 
 	n = walkexpr1(n, init)
@@ -969,10 +966,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			dowidth(fn.Type())
 			call := ir.Nod(ir.OCALL, fn, nil)
 			call.PtrList().Set1(n.Left())
-			call = typecheck(call, ctxExpr)
-			call = walkexpr(call, init)
-			call = safeexpr(call, init)
-			e := ir.Nod(ir.OEFACE, typeword(), call)
+			e := ir.Nod(ir.OEFACE, typeword(), safeexpr(walkexpr(typecheck(call, ctxExpr), init), init))
 			e.SetType(toType)
 			e.SetTypecheck(1)
 			return e
@@ -1277,9 +1271,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 			// var hv hmap
 			hv := temp(hmapType)
-			zero := ir.Nod(ir.OAS, hv, nil)
-			zero = typecheck(zero, ctxStmt)
-			init.Append(zero)
+			init.Append(typecheck(ir.Nod(ir.OAS, hv, nil), ctxStmt))
 			// h = &hv
 			h = nodAddr(hv)
 
@@ -1305,8 +1297,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 				// var bv bmap
 				bv := temp(bmap(t))
-				zero = ir.Nod(ir.OAS, bv, nil)
-				nif.PtrBody().Append(zero)
+				nif.PtrBody().Append(ir.Nod(ir.OAS, bv, nil))
 
 				// b = &bv
 				b := nodAddr(bv)
@@ -1316,9 +1307,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 				na := ir.Nod(ir.OAS, nodSym(ir.ODOT, h, bsym), b)
 				nif.PtrBody().Append(na)
 
-				nif = typecheck(nif, ctxStmt)
-				nif = walkstmt(nif)
-				init.Append(nif)
+				init.Append(walkstmt(typecheck(nif, ctxStmt)))
 			}
 		}
 
@@ -1336,10 +1325,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 				// h.hash0 = fastrand()
 				rand := mkcall("fastrand", types.Types[types.TUINT32], init)
 				hashsym := hmapType.Field(4).Sym // hmap.hash0 see reflect.go:hmap
-				a := ir.Nod(ir.OAS, nodSym(ir.ODOT, h, hashsym), rand)
-				a = typecheck(a, ctxStmt)
-				a = walkexpr(a, init)
-				init.Append(a)
+				appendWalk(init, ir.Nod(ir.OAS, nodSym(ir.ODOT, h, hashsym), rand))
 				return convnop(h, t)
 			}
 			// Call runtime.makehmap to allocate an
@@ -1408,20 +1394,15 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			niflen := ir.Nod(ir.OIF, ir.Nod(ir.OLT, l, nodintconst(0)), nil)
 			niflen.PtrBody().Set1(mkcall("panicmakeslicelen", nil, init))
 			nif.PtrBody().Append(niflen, mkcall("panicmakeslicecap", nil, init))
-			nif = typecheck(nif, ctxStmt)
-			init.Append(nif)
+			init.Append(typecheck(nif, ctxStmt))
 
 			t = types.NewArray(t.Elem(), i) // [r]T
 			var_ := temp(t)
-			a := ir.Nod(ir.OAS, var_, nil) // zero temp
-			a = typecheck(a, ctxStmt)
-			init.Append(a)
-			r := ir.Nod(ir.OSLICE, var_, nil) // arr[:l]
+			appendWalk(init, ir.Nod(ir.OAS, var_, nil)) // zero temp
+			r := ir.Nod(ir.OSLICE, var_, nil)           // arr[:l]
 			r.SetSliceBounds(nil, l, nil)
-			r = conv(r, n.Type()) // in case n.Type is named.
-			r = typecheck(r, ctxExpr)
-			r = walkexpr(r, init)
-			return r
+			// The conv is necessary in case n.Type is named.
+			return walkexpr(typecheck(conv(r, n.Type()), ctxExpr), init)
 		}
 
 		// n escapes; set up a call to makeslice.
@@ -1449,10 +1430,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		m.SetLeft(mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), conv(len, argtype), conv(cap, argtype)))
 		m.Left().MarkNonNil()
 		m.PtrList().Set2(conv(len, types.Types[types.TINT]), conv(cap, types.Types[types.TINT]))
-
-		m = typecheck(m, ctxExpr)
-		m = walkexpr(m, init)
-		return m
+		return walkexpr(typecheck(m, ctxExpr), init)
 
 	case ir.OMAKESLICECOPY:
 		if n.Esc() == EscNone {
@@ -1569,9 +1547,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 				as := ir.Nod(ir.OAS,
 					ir.Nod(ir.ODEREF, p, nil),
 					ir.Nod(ir.ODEREF, convnop(ir.Nod(ir.OSPTR, s, nil), t.PtrTo()), nil))
-				as = typecheck(as, ctxStmt)
-				as = walkstmt(as)
-				init.Append(as)
+				appendWalk(init, as)
 			}
 
 			// Slice the [n]byte to a []byte.
@@ -1811,8 +1787,7 @@ func ascompatet(nl ir.Nodes, nr *types.Type) []ir.Node {
 		if fncall(l, r.Type) {
 			tmp := ir.Node(temp(r.Type))
 			tmp = typecheck(tmp, ctxExpr)
-			a := ir.Nod(ir.OAS, l, tmp)
-			a = convas(a, &mm)
+			a := convas(ir.Nod(ir.OAS, l, tmp), &mm)
 			mm.Append(a)
 			l = tmp
 		}
@@ -1822,8 +1797,7 @@ func ascompatet(nl ir.Nodes, nr *types.Type) []ir.Node {
 		res.SetType(r.Type)
 		res.SetTypecheck(1)
 
-		a := ir.Nod(ir.OAS, l, res)
-		a = convas(a, &nn)
+		a := convas(ir.Nod(ir.OAS, l, res), &nn)
 		updateHasCall(a)
 		if a.HasCall() {
 			ir.Dump("ascompatet ucount", a)
@@ -1917,8 +1891,7 @@ func walkCall(n ir.Node, init *ir.Nodes) {
 		if instrumenting || fncall(arg, t) {
 			// make assignment of fncall to tempAt
 			tmp := temp(t)
-			a := ir.Nod(ir.OAS, tmp, arg)
-			a = convas(a, init)
+			a := convas(ir.Nod(ir.OAS, tmp, arg), init)
 			tempAssigns = append(tempAssigns, a)
 			// replace arg with temp
 			args[i] = tmp
@@ -2067,10 +2040,8 @@ func walkprint(nn ir.Node, init *ir.Nodes) ir.Node {
 	walkexprlist(calls, init)
 
 	r := ir.Nod(ir.OBLOCK, nil, nil)
-	r = typecheck(r, ctxStmt)
-	r = walkstmt(r)
 	r.PtrList().Set(calls)
-	return r
+	return walkstmt(typecheck(r, ctxStmt))
 }
 
 func callnew(t *types.Type) ir.Node {
@@ -2527,16 +2498,15 @@ func vmkcall(fn ir.Node, t *types.Type, init *ir.Nodes, va []ir.Node) ir.Node {
 		base.Fatalf("vmkcall %v needs %v args got %v", fn, n, len(va))
 	}
 
-	r := ir.Nod(ir.OCALL, fn, nil)
-	r.PtrList().Set(va)
+	call := ir.Nod(ir.OCALL, fn, nil)
+	call.PtrList().Set(va)
+	ctx := ctxStmt
 	if fn.Type().NumResults() > 0 {
-		r = typecheck(r, ctxExpr|ctxMultiOK)
-	} else {
-		r = typecheck(r, ctxStmt)
+		ctx = ctxExpr | ctxMultiOK
 	}
-	r = walkexpr(r, init)
-	r.SetType(t)
-	return r
+	r1 := typecheck(call, ctx)
+	r1.SetType(t)
+	return walkexpr(r1, init)
 }
 
 func mkcall(name string, t *types.Type, init *ir.Nodes, args ...ir.Node) ir.Node {
@@ -2731,11 +2701,11 @@ func addstr(n ir.Node, init *ir.Nodes) ir.Node {
 	cat := syslook(fn)
 	r := ir.Nod(ir.OCALL, cat, nil)
 	r.PtrList().Set(args)
-	r = typecheck(r, ctxExpr)
-	r = walkexpr(r, init)
-	r.SetType(n.Type())
+	r1 := typecheck(r, ctxExpr)
+	r1 = walkexpr(r1, init)
+	r1.SetType(n.Type())
 
-	return r
+	return r1
 }
 
 func walkAppendArgs(n ir.Node, init *ir.Nodes) {
@@ -2807,44 +2777,39 @@ func appendslice(n ir.Node, init *ir.Nodes) ir.Node {
 	var ncopy ir.Node
 	if elemtype.HasPointers() {
 		// copy(s[len(l1):], l2)
-		nptr1 := ir.Nod(ir.OSLICE, s, nil)
-		nptr1.SetType(s.Type())
-		nptr1.SetSliceBounds(ir.Nod(ir.OLEN, l1, nil), nil, nil)
-		nptr1 = cheapexpr(nptr1, &nodes)
-
-		nptr2 := l2
+		slice := ir.Nod(ir.OSLICE, s, nil)
+		slice.SetType(s.Type())
+		slice.SetSliceBounds(ir.Nod(ir.OLEN, l1, nil), nil, nil)
 
 		Curfn.SetWBPos(n.Pos())
 
 		// instantiate typedslicecopy(typ *type, dstPtr *any, dstLen int, srcPtr *any, srcLen int) int
 		fn := syslook("typedslicecopy")
 		fn = substArgTypes(fn, l1.Type().Elem(), l2.Type().Elem())
-		ptr1, len1 := backingArrayPtrLen(nptr1)
-		ptr2, len2 := backingArrayPtrLen(nptr2)
+		ptr1, len1 := backingArrayPtrLen(cheapexpr(slice, &nodes))
+		ptr2, len2 := backingArrayPtrLen(l2)
 		ncopy = mkcall1(fn, types.Types[types.TINT], &nodes, typename(elemtype), ptr1, len1, ptr2, len2)
 	} else if instrumenting && !base.Flag.CompilingRuntime {
 		// rely on runtime to instrument:
 		//  copy(s[len(l1):], l2)
 		// l2 can be a slice or string.
-		nptr1 := ir.Nod(ir.OSLICE, s, nil)
-		nptr1.SetType(s.Type())
-		nptr1.SetSliceBounds(ir.Nod(ir.OLEN, l1, nil), nil, nil)
-		nptr1 = cheapexpr(nptr1, &nodes)
-		nptr2 := l2
+		slice := ir.Nod(ir.OSLICE, s, nil)
+		slice.SetType(s.Type())
+		slice.SetSliceBounds(ir.Nod(ir.OLEN, l1, nil), nil, nil)
 
-		ptr1, len1 := backingArrayPtrLen(nptr1)
-		ptr2, len2 := backingArrayPtrLen(nptr2)
+		ptr1, len1 := backingArrayPtrLen(cheapexpr(slice, &nodes))
+		ptr2, len2 := backingArrayPtrLen(l2)
 
 		fn := syslook("slicecopy")
 		fn = substArgTypes(fn, ptr1.Type().Elem(), ptr2.Type().Elem())
 		ncopy = mkcall1(fn, types.Types[types.TINT], &nodes, ptr1, len1, ptr2, len2, nodintconst(elemtype.Width))
 	} else {
 		// memmove(&s[len(l1)], &l2[0], len(l2)*sizeof(T))
-		nptr1 := ir.Nod(ir.OINDEX, s, ir.Nod(ir.OLEN, l1, nil))
-		nptr1.SetBounded(true)
-		nptr1 = nodAddr(nptr1)
+		ix := ir.Nod(ir.OINDEX, s, ir.Nod(ir.OLEN, l1, nil))
+		ix.SetBounded(true)
+		addr := ir.Nod(ir.OADDR, ix, nil)
 
-		nptr2 := ir.Nod(ir.OSPTR, l2, nil)
+		sptr := ir.Nod(ir.OSPTR, l2, nil)
 
 		nwid := cheapexpr(conv(ir.Nod(ir.OLEN, l2, nil), types.Types[types.TUINTPTR]), &nodes)
 		nwid = ir.Nod(ir.OMUL, nwid, nodintconst(elemtype.Width))
@@ -2852,7 +2817,7 @@ func appendslice(n ir.Node, init *ir.Nodes) ir.Node {
 		// instantiate func memmove(to *any, frm *any, length uintptr)
 		fn := syslook("memmove")
 		fn = substArgTypes(fn, elemtype, elemtype)
-		ncopy = mkcall1(fn, nil, &nodes, nptr1, nptr2, nwid)
+		ncopy = mkcall1(fn, nil, &nodes, addr, sptr, nwid)
 	}
 	ln := append(nodes.Slice(), ncopy)
 
@@ -2986,14 +2951,12 @@ func extendslice(n ir.Node, init *ir.Nodes) ir.Node {
 	nodes = append(nodes, ir.Nod(ir.OAS, sptr, tmp))
 
 	// hp := &s[len(l1)]
-	hp := ir.Nod(ir.OINDEX, s, ir.Nod(ir.OLEN, l1, nil))
-	hp.SetBounded(true)
-	hp = nodAddr(hp)
-	hp = convnop(hp, types.Types[types.TUNSAFEPTR])
+	ix := ir.Nod(ir.OINDEX, s, ir.Nod(ir.OLEN, l1, nil))
+	ix.SetBounded(true)
+	hp := convnop(ir.Nod(ir.OADDR, ix, nil), types.Types[types.TUNSAFEPTR])
 
 	// hn := l2 * sizeof(elem(s))
-	hn := ir.Nod(ir.OMUL, l2, nodintconst(elemtype.Width))
-	hn = conv(hn, types.Types[types.TUINTPTR])
+	hn := conv(ir.Nod(ir.OMUL, l2, nodintconst(elemtype.Width)), types.Types[types.TUINTPTR])
 
 	clrname := "memclrNoHeapPointers"
 	hasPointers := elemtype.HasPointers()
@@ -3083,32 +3046,32 @@ func walkappend(n ir.Node, init *ir.Nodes, dst ir.Node) ir.Node {
 	ns := temp(nsrc.Type())
 	l = append(l, ir.Nod(ir.OAS, ns, nsrc)) // s = src
 
-	na := nodintconst(int64(argc)) // const argc
-	nx := ir.Nod(ir.OIF, nil, nil) // if cap(s) - len(s) < argc
-	nx.SetLeft(ir.Nod(ir.OLT, ir.Nod(ir.OSUB, ir.Nod(ir.OCAP, ns, nil), ir.Nod(ir.OLEN, ns, nil)), na))
+	na := nodintconst(int64(argc))  // const argc
+	nif := ir.Nod(ir.OIF, nil, nil) // if cap(s) - len(s) < argc
+	nif.SetLeft(ir.Nod(ir.OLT, ir.Nod(ir.OSUB, ir.Nod(ir.OCAP, ns, nil), ir.Nod(ir.OLEN, ns, nil)), na))
 
 	fn := syslook("growslice") //   growslice(<type>, old []T, mincap int) (ret []T)
 	fn = substArgTypes(fn, ns.Type().Elem(), ns.Type().Elem())
 
-	nx.PtrBody().Set1(ir.Nod(ir.OAS, ns,
-		mkcall1(fn, ns.Type(), nx.PtrInit(), typename(ns.Type().Elem()), ns,
+	nif.PtrBody().Set1(ir.Nod(ir.OAS, ns,
+		mkcall1(fn, ns.Type(), nif.PtrInit(), typename(ns.Type().Elem()), ns,
 			ir.Nod(ir.OADD, ir.Nod(ir.OLEN, ns, nil), na))))
 
-	l = append(l, nx)
+	l = append(l, nif)
 
 	nn := temp(types.Types[types.TINT])
 	l = append(l, ir.Nod(ir.OAS, nn, ir.Nod(ir.OLEN, ns, nil))) // n = len(s)
 
-	nx = ir.Nod(ir.OSLICE, ns, nil) // ...s[:n+argc]
-	nx.SetSliceBounds(nil, ir.Nod(ir.OADD, nn, na), nil)
-	nx.SetBounded(true)
-	l = append(l, ir.Nod(ir.OAS, ns, nx)) // s = s[:n+argc]
+	slice := ir.Nod(ir.OSLICE, ns, nil) // ...s[:n+argc]
+	slice.SetSliceBounds(nil, ir.Nod(ir.OADD, nn, na), nil)
+	slice.SetBounded(true)
+	l = append(l, ir.Nod(ir.OAS, ns, slice)) // s = s[:n+argc]
 
 	ls = n.List().Slice()[1:]
 	for i, n := range ls {
-		nx = ir.Nod(ir.OINDEX, ns, nn) // s[n] ...
-		nx.SetBounded(true)
-		l = append(l, ir.Nod(ir.OAS, nx, n)) // s[n] = arg
+		ix := ir.Nod(ir.OINDEX, ns, nn) // s[n] ...
+		ix.SetBounded(true)
+		l = append(l, ir.Nod(ir.OAS, ix, n)) // s[n] = arg
 		if i+1 < len(ls) {
 			l = append(l, ir.Nod(ir.OAS, nn, ir.Nod(ir.OADD, nn, nodintconst(1)))) // n = n + 1
 		}
@@ -3377,7 +3340,7 @@ func walkcompare(n ir.Node, init *ir.Nodes) ir.Node {
 		if needsize {
 			call.PtrList().Append(nodintconst(t.Width))
 		}
-		res := call
+		res := ir.Node(call)
 		if n.Op() != ir.OEQ {
 			res = ir.Nod(ir.ONOT, res, nil)
 		}
@@ -3442,21 +3405,21 @@ func walkcompare(n ir.Node, init *ir.Nodes) ir.Node {
 				remains -= t.Elem().Width
 			} else {
 				elemType := t.Elem().ToUnsigned()
-				cmplw := ir.Nod(ir.OINDEX, cmpl, nodintconst(i))
+				cmplw := ir.Node(ir.Nod(ir.OINDEX, cmpl, nodintconst(i)))
 				cmplw = conv(cmplw, elemType) // convert to unsigned
 				cmplw = conv(cmplw, convType) // widen
-				cmprw := ir.Nod(ir.OINDEX, cmpr, nodintconst(i))
+				cmprw := ir.Node(ir.Nod(ir.OINDEX, cmpr, nodintconst(i)))
 				cmprw = conv(cmprw, elemType)
 				cmprw = conv(cmprw, convType)
 				// For code like this:  uint32(s[0]) | uint32(s[1])<<8 | uint32(s[2])<<16 ...
 				// ssa will generate a single large load.
 				for offset := int64(1); offset < step; offset++ {
-					lb := ir.Nod(ir.OINDEX, cmpl, nodintconst(i+offset))
+					lb := ir.Node(ir.Nod(ir.OINDEX, cmpl, nodintconst(i+offset)))
 					lb = conv(lb, elemType)
 					lb = conv(lb, convType)
 					lb = ir.Nod(ir.OLSH, lb, nodintconst(8*t.Elem().Width*offset))
 					cmplw = ir.Nod(ir.OOR, cmplw, lb)
-					rb := ir.Nod(ir.OINDEX, cmpr, nodintconst(i+offset))
+					rb := ir.Node(ir.Nod(ir.OINDEX, cmpr, nodintconst(i+offset)))
 					rb = conv(rb, elemType)
 					rb = conv(rb, convType)
 					rb = ir.Nod(ir.OLSH, rb, nodintconst(8*t.Elem().Width*offset))
@@ -3473,10 +3436,8 @@ func walkcompare(n ir.Node, init *ir.Nodes) ir.Node {
 		// We still need to use cmpl and cmpr, in case they contain
 		// an expression which might panic. See issue 23837.
 		t := temp(cmpl.Type())
-		a1 := ir.Nod(ir.OAS, t, cmpl)
-		a1 = typecheck(a1, ctxStmt)
-		a2 := ir.Nod(ir.OAS, t, cmpr)
-		a2 = typecheck(a2, ctxStmt)
+		a1 := typecheck(ir.Nod(ir.OAS, t, cmpl), ctxStmt)
+		a2 := typecheck(ir.Nod(ir.OAS, t, cmpr), ctxStmt)
 		init.Append(a1, a2)
 	}
 	n = finishcompare(n, expr, init)
@@ -3583,15 +3544,13 @@ func walkcompareString(n ir.Node, init *ir.Nodes) ir.Node {
 					convType = types.Types[types.TUINT16]
 					step = 2
 				}
-				ncsubstr := ir.Nod(ir.OINDEX, ncs, nodintconst(int64(i)))
-				ncsubstr = conv(ncsubstr, convType)
+				ncsubstr := conv(ir.Nod(ir.OINDEX, ncs, nodintconst(int64(i))), convType)
 				csubstr := int64(s[i])
 				// Calculate large constant from bytes as sequence of shifts and ors.
 				// Like this:  uint32(s[0]) | uint32(s[1])<<8 | uint32(s[2])<<16 ...
 				// ssa will combine this into a single large load.
 				for offset := 1; offset < step; offset++ {
-					b := ir.Nod(ir.OINDEX, ncs, nodintconst(int64(i+offset)))
-					b = conv(b, convType)
+					b := conv(ir.Nod(ir.OINDEX, ncs, nodintconst(int64(i+offset))), convType)
 					b = ir.Nod(ir.OLSH, b, nodintconst(int64(8*offset)))
 					ncsubstr = ir.Nod(ir.OOR, ncsubstr, b)
 					csubstr |= int64(s[i+offset]) << uint8(8*offset)
-- 
GitLab


From 5ae70b85c6c40adb4e785bf988799df9c0a57e16 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 7 Dec 2020 14:56:49 -0500
Subject: [PATCH 0237/2400] [dev.regabi] cmd/compile: cleanup preparing for
 concrete types, 2

Avoid using the same variable for two different concrete
Node types in other files (beyond walk). This will smooth the
introduction of specific constructors, replacing ir.Nod and friends.

Passes buildall w/ toolstash -cmp.

Replay of CL 275885, lost to the bad-merge history rewrite.

Change-Id: I0da89502a0bd636b8766f01b6f843c7821b3e9ab
Reviewed-on: https://go-review.googlesource.com/c/go/+/277955
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/alg.go       | 20 +++---
 src/cmd/compile/internal/gc/closure.go   | 32 ++++-----
 src/cmd/compile/internal/gc/inl.go       | 19 ++----
 src/cmd/compile/internal/gc/order.go     | 45 +++++--------
 src/cmd/compile/internal/gc/range.go     | 30 ++++-----
 src/cmd/compile/internal/gc/select.go    | 20 ++----
 src/cmd/compile/internal/gc/sinit.go     | 82 ++++++------------------
 src/cmd/compile/internal/gc/subr.go      | 26 ++++----
 src/cmd/compile/internal/gc/swt.go       |  4 +-
 src/cmd/compile/internal/gc/typecheck.go |  8 +--
 src/cmd/compile/internal/gc/walk.go      | 31 ++++++---
 11 files changed, 126 insertions(+), 191 deletions(-)

diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index 7540944201..8550edb9e0 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -819,12 +819,12 @@ func eqstring(s, t ir.Node) (eqlen, eqmem ir.Node) {
 	fn = substArgTypes(fn, types.Types[types.TUINT8], types.Types[types.TUINT8])
 	call := ir.Nod(ir.OCALL, fn, nil)
 	call.PtrList().Append(sptr, tptr, ir.Copy(slen))
-	call = typecheck(call, ctxExpr|ctxMultiOK)
+	call1 := typecheck(call, ctxExpr|ctxMultiOK)
 
 	cmp := ir.Nod(ir.OEQ, slen, tlen)
-	cmp = typecheck(cmp, ctxExpr)
+	cmp1 := typecheck(cmp, ctxExpr)
 	cmp.SetType(types.Types[types.TBOOL])
-	return cmp, call
+	return cmp1, call1
 }
 
 // eqinterface returns the nodes
@@ -857,21 +857,19 @@ func eqinterface(s, t ir.Node) (eqtab, eqdata ir.Node) {
 
 	call := ir.Nod(ir.OCALL, fn, nil)
 	call.PtrList().Append(stab, sdata, tdata)
-	call = typecheck(call, ctxExpr|ctxMultiOK)
+	call1 := typecheck(call, ctxExpr|ctxMultiOK)
 
 	cmp := ir.Nod(ir.OEQ, stab, ttab)
-	cmp = typecheck(cmp, ctxExpr)
-	cmp.SetType(types.Types[types.TBOOL])
-	return cmp, call
+	cmp1 := typecheck(cmp, ctxExpr)
+	cmp1.SetType(types.Types[types.TBOOL])
+	return cmp1, call1
 }
 
 // eqmem returns the node
 // 	memequal(&p.field, &q.field [, size])
 func eqmem(p ir.Node, q ir.Node, field *types.Sym, size int64) ir.Node {
-	nx := nodAddr(nodSym(ir.OXDOT, p, field))
-	ny := nodAddr(nodSym(ir.OXDOT, q, field))
-	nx = typecheck(nx, ctxExpr)
-	ny = typecheck(ny, ctxExpr)
+	nx := typecheck(nodAddr(nodSym(ir.OXDOT, p, field)), ctxExpr)
+	ny := typecheck(nodAddr(nodSym(ir.OXDOT, q, field)), ctxExpr)
 
 	fn, needsize := eqmemfunc(size, nx.Type().Elem())
 	call := ir.Nod(ir.OCALL, fn, nil)
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index a3d8a46977..954fa1a452 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -396,22 +396,22 @@ func walkclosure(clo ir.Node, init *ir.Nodes) ir.Node {
 	clos.SetEsc(clo.Esc())
 	clos.PtrList().Set(append([]ir.Node{ir.Nod(ir.OCFUNC, fn.Nname, nil)}, fn.ClosureEnter.Slice()...))
 
-	clos = nodAddr(clos)
-	clos.SetEsc(clo.Esc())
+	addr := nodAddr(clos)
+	addr.SetEsc(clo.Esc())
 
 	// Force type conversion from *struct to the func type.
-	clos = convnop(clos, clo.Type())
+	cfn := convnop(addr, clo.Type())
 
 	// non-escaping temp to use, if any.
 	if x := prealloc[clo]; x != nil {
 		if !types.Identical(typ, x.Type()) {
 			panic("closure type does not match order's assigned type")
 		}
-		clos.Left().SetRight(x)
+		addr.SetRight(x)
 		delete(prealloc, clo)
 	}
 
-	return walkexpr(clos, init)
+	return walkexpr(cfn, init)
 }
 
 func typecheckpartialcall(dot ir.Node, sym *types.Sym) *ir.CallPartExpr {
@@ -482,11 +482,12 @@ func makepartialcall(dot ir.Node, t0 *types.Type, meth *types.Sym) *ir.Func {
 	call.PtrList().Set(paramNnames(tfn.Type()))
 	call.SetIsDDD(tfn.Type().IsVariadic())
 	if t0.NumResults() != 0 {
-		n := ir.Nod(ir.ORETURN, nil, nil)
-		n.PtrList().Set1(call)
-		call = n
+		ret := ir.Nod(ir.ORETURN, nil, nil)
+		ret.PtrList().Set1(call)
+		body = append(body, ret)
+	} else {
+		body = append(body, call)
 	}
-	body = append(body, call)
 
 	fn.PtrBody().Set(body)
 	funcbody()
@@ -530,8 +531,7 @@ func walkpartialcall(n *ir.CallPartExpr, init *ir.Nodes) ir.Node {
 		n.SetLeft(cheapexpr(n.Left(), init))
 		n.SetLeft(walkexpr(n.Left(), nil))
 
-		tab := ir.Nod(ir.OITAB, n.Left(), nil)
-		tab = typecheck(tab, ctxExpr)
+		tab := typecheck(ir.Nod(ir.OITAB, n.Left(), nil), ctxExpr)
 
 		c := ir.Nod(ir.OCHECKNIL, tab, nil)
 		c.SetTypecheck(1)
@@ -544,22 +544,22 @@ func walkpartialcall(n *ir.CallPartExpr, init *ir.Nodes) ir.Node {
 	clos.SetEsc(n.Esc())
 	clos.PtrList().Set2(ir.Nod(ir.OCFUNC, n.Func().Nname, nil), n.Left())
 
-	clos = nodAddr(clos)
-	clos.SetEsc(n.Esc())
+	addr := nodAddr(clos)
+	addr.SetEsc(n.Esc())
 
 	// Force type conversion from *struct to the func type.
-	clos = convnop(clos, n.Type())
+	cfn := convnop(addr, n.Type())
 
 	// non-escaping temp to use, if any.
 	if x := prealloc[n]; x != nil {
 		if !types.Identical(typ, x.Type()) {
 			panic("partial call type does not match order's assigned type")
 		}
-		clos.Left().SetRight(x)
+		addr.SetRight(x)
 		delete(prealloc, n)
 	}
 
-	return walkexpr(clos, init)
+	return walkexpr(cfn, init)
 }
 
 // callpartMethod returns the *types.Field representing the method
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 3c17f7d87f..04256d5aeb 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -1005,13 +1005,11 @@ func mkinlcall(n ir.Node, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]bool,
 	}
 
 	if as.Rlist().Len() != 0 {
-		as = typecheck(as, ctxStmt)
-		ninit.Append(as)
+		ninit.Append(typecheck(as, ctxStmt))
 	}
 
 	if vas != nil {
-		vas = typecheck(vas, ctxStmt)
-		ninit.Append(vas)
+		ninit.Append(typecheck(vas, ctxStmt))
 	}
 
 	if !delayretvars {
@@ -1019,8 +1017,7 @@ func mkinlcall(n ir.Node, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]bool,
 		for _, n := range retvars {
 			ninit.Append(ir.Nod(ir.ODCL, n, nil))
 			ras := ir.Nod(ir.OAS, n, nil)
-			ras = typecheck(ras, ctxStmt)
-			ninit.Append(ras)
+			ninit.Append(typecheck(ras, ctxStmt))
 		}
 	}
 
@@ -1235,8 +1232,7 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 				}
 			}
 
-			as = typecheck(as, ctxStmt)
-			init = append(init, as)
+			init = append(init, typecheck(as, ctxStmt))
 		}
 		init = append(init, nodSym(ir.OGOTO, nil, subst.retlabel))
 		typecheckslice(init, ctxStmt)
@@ -1310,10 +1306,9 @@ func devirtualizeCall(call ir.Node) {
 		return
 	}
 
-	x := ir.NodAt(call.Left().Pos(), ir.ODOTTYPE, call.Left().Left(), nil)
-	x.SetType(typ)
-	x = nodlSym(call.Left().Pos(), ir.OXDOT, x, call.Left().Sym())
-	x = typecheck(x, ctxExpr|ctxCallee)
+	dt := ir.NodAt(call.Left().Pos(), ir.ODOTTYPE, call.Left().Left(), nil)
+	dt.SetType(typ)
+	x := typecheck(nodlSym(call.Left().Pos(), ir.OXDOT, dt, call.Left().Sym()), ctxExpr|ctxCallee)
 	switch x.Op() {
 	case ir.ODOTMETH:
 		if base.Flag.LowerM != 0 {
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index c3645256a6..56acdf7528 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -60,6 +60,11 @@ func order(fn *ir.Func) {
 	orderBlock(fn.PtrBody(), map[string][]*ir.Name{})
 }
 
+// append typechecks stmt and appends it to out.
+func (o *Order) append(stmt ir.Node) {
+	o.out = append(o.out, typecheck(stmt, ctxStmt))
+}
+
 // newTemp allocates a new temporary with the given type,
 // pushes it onto the temp stack, and returns it.
 // If clear is true, newTemp emits code to zero the temporary.
@@ -82,9 +87,7 @@ func (o *Order) newTemp(t *types.Type, clear bool) *ir.Name {
 		v = temp(t)
 	}
 	if clear {
-		a := ir.Nod(ir.OAS, v, nil)
-		a = typecheck(a, ctxStmt)
-		o.out = append(o.out, a)
+		o.append(ir.Nod(ir.OAS, v, nil))
 	}
 
 	o.temp = append(o.temp, v)
@@ -114,9 +117,7 @@ func (o *Order) copyExprClear(n ir.Node) *ir.Name {
 func (o *Order) copyExpr1(n ir.Node, clear bool) *ir.Name {
 	t := n.Type()
 	v := o.newTemp(t, clear)
-	a := ir.Nod(ir.OAS, v, n)
-	a = typecheck(a, ctxStmt)
-	o.out = append(o.out, a)
+	o.append(ir.Nod(ir.OAS, v, n))
 	return v
 }
 
@@ -306,9 +307,7 @@ func (o *Order) cleanTempNoPop(mark ordermarker) []ir.Node {
 	var out []ir.Node
 	for i := len(o.temp) - 1; i >= int(mark); i-- {
 		n := o.temp[i]
-		kill := ir.Nod(ir.OVARKILL, n, nil)
-		kill = typecheck(kill, ctxStmt)
-		out = append(out, kill)
+		out = append(out, typecheck(ir.Nod(ir.OVARKILL, n, nil), ctxStmt))
 	}
 	return out
 }
@@ -407,9 +406,7 @@ func (o *Order) edge() {
 	// counter += 1
 	incr := ir.Nod(ir.OASOP, counter, nodintconst(1))
 	incr.SetSubOp(ir.OADD)
-	incr = typecheck(incr, ctxStmt)
-
-	o.out = append(o.out, incr)
+	o.append(incr)
 }
 
 // orderBlock orders the block of statements in n into a new slice,
@@ -570,8 +567,7 @@ func (o *Order) mapAssign(n ir.Node) {
 				t := o.newTemp(m.Type(), false)
 				n.List().SetIndex(i, t)
 				a := ir.Nod(ir.OAS, m, t)
-				a = typecheck(a, ctxStmt)
-				post = append(post, a)
+				post = append(post, typecheck(a, ctxStmt))
 			}
 		}
 
@@ -918,27 +914,23 @@ func (o *Order) stmt(n ir.Node) {
 					// the conversion happens in the OAS instead.
 					if r.Colas() {
 						dcl := ir.Nod(ir.ODCL, dst, nil)
-						dcl = typecheck(dcl, ctxStmt)
-						n2.PtrInit().Append(dcl)
+						n2.PtrInit().Append(typecheck(dcl, ctxStmt))
 					}
 
 					tmp := o.newTemp(recv.Left().Type().Elem(), recv.Left().Type().Elem().HasPointers())
 					as := ir.Nod(ir.OAS, dst, tmp)
-					as = typecheck(as, ctxStmt)
-					n2.PtrInit().Append(as)
+					n2.PtrInit().Append(typecheck(as, ctxStmt))
 					dst = tmp
 				}
 				if !ir.IsBlank(ok) {
 					if r.Colas() {
 						dcl := ir.Nod(ir.ODCL, ok, nil)
-						dcl = typecheck(dcl, ctxStmt)
-						n2.PtrInit().Append(dcl)
+						n2.PtrInit().Append(typecheck(dcl, ctxStmt))
 					}
 
 					tmp := o.newTemp(types.Types[types.TBOOL], false)
 					as := ir.Nod(ir.OAS, ok, conv(tmp, ok.Type()))
-					as = typecheck(as, ctxStmt)
-					n2.PtrInit().Append(as)
+					n2.PtrInit().Append(typecheck(as, ctxStmt))
 					ok = tmp
 				}
 
@@ -1408,8 +1400,7 @@ func (o *Order) as2(n ir.Node) {
 	as := ir.Nod(ir.OAS2, nil, nil)
 	as.PtrList().Set(left)
 	as.PtrRlist().Set(tmplist)
-	as = typecheck(as, ctxStmt)
-	o.stmt(as)
+	o.stmt(typecheck(as, ctxStmt))
 }
 
 // okAs2 orders OAS2XXX with ok.
@@ -1429,14 +1420,12 @@ func (o *Order) okAs2(n ir.Node) {
 
 	if tmp1 != nil {
 		r := ir.Nod(ir.OAS, n.List().First(), tmp1)
-		r = typecheck(r, ctxStmt)
-		o.mapAssign(r)
+		o.mapAssign(typecheck(r, ctxStmt))
 		n.List().SetFirst(tmp1)
 	}
 	if tmp2 != nil {
 		r := ir.Nod(ir.OAS, n.List().Second(), conv(tmp2, n.List().Second().Type()))
-		r = typecheck(r, ctxStmt)
-		o.mapAssign(r)
+		o.mapAssign(typecheck(r, ctxStmt))
 		n.List().SetSecond(tmp2)
 	}
 }
diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index 2589da7b5d..453f5e2198 100644
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -288,9 +288,8 @@ func walkrange(nrange ir.Node) ir.Node {
 		// This runs *after* the condition check, so we know
 		// advancing the pointer is safe and won't go past the
 		// end of the allocation.
-		a = ir.Nod(ir.OAS, hp, addptr(hp, t.Elem().Width))
-		a = typecheck(a, ctxStmt)
-		nfor.PtrList().Set1(a)
+		as := ir.Nod(ir.OAS, hp, addptr(hp, t.Elem().Width))
+		nfor.PtrList().Set1(typecheck(as, ctxStmt))
 
 	case types.TMAP:
 		// order.stmt allocated the iterator for us.
@@ -312,15 +311,13 @@ func walkrange(nrange ir.Node) ir.Node {
 		fn = substArgTypes(fn, th)
 		nfor.SetRight(mkcall1(fn, nil, nil, nodAddr(hit)))
 
-		key := nodSym(ir.ODOT, hit, keysym)
-		key = ir.Nod(ir.ODEREF, key, nil)
+		key := ir.Nod(ir.ODEREF, nodSym(ir.ODOT, hit, keysym), nil)
 		if v1 == nil {
 			body = nil
 		} else if v2 == nil {
 			body = []ir.Node{ir.Nod(ir.OAS, v1, key)}
 		} else {
-			elem := nodSym(ir.ODOT, hit, elemsym)
-			elem = ir.Nod(ir.ODEREF, elem, nil)
+			elem := ir.Nod(ir.ODEREF, nodSym(ir.ODOT, hit, elemsym), nil)
 			a := ir.Nod(ir.OAS2, nil, nil)
 			a.PtrList().Set2(v1, v2)
 			a.PtrRlist().Set2(key, elem)
@@ -570,19 +567,15 @@ func arrayClear(loop, v1, v2, a ir.Node) ir.Node {
 	// hp = &a[0]
 	hp := temp(types.Types[types.TUNSAFEPTR])
 
-	tmp := ir.Nod(ir.OINDEX, a, nodintconst(0))
-	tmp.SetBounded(true)
-	tmp = nodAddr(tmp)
-	tmp = convnop(tmp, types.Types[types.TUNSAFEPTR])
-	n.PtrBody().Append(ir.Nod(ir.OAS, hp, tmp))
+	ix := ir.Nod(ir.OINDEX, a, nodintconst(0))
+	ix.SetBounded(true)
+	addr := convnop(nodAddr(ix), types.Types[types.TUNSAFEPTR])
+	n.PtrBody().Append(ir.Nod(ir.OAS, hp, addr))
 
 	// hn = len(a) * sizeof(elem(a))
 	hn := temp(types.Types[types.TUINTPTR])
-
-	tmp = ir.Nod(ir.OLEN, a, nil)
-	tmp = ir.Nod(ir.OMUL, tmp, nodintconst(elemsize))
-	tmp = conv(tmp, types.Types[types.TUINTPTR])
-	n.PtrBody().Append(ir.Nod(ir.OAS, hn, tmp))
+	mul := conv(ir.Nod(ir.OMUL, ir.Nod(ir.OLEN, a, nil), nodintconst(elemsize)), types.Types[types.TUINTPTR])
+	n.PtrBody().Append(ir.Nod(ir.OAS, hn, mul))
 
 	var fn ir.Node
 	if a.Type().Elem().HasPointers() {
@@ -604,8 +597,7 @@ func arrayClear(loop, v1, v2, a ir.Node) ir.Node {
 	n.SetLeft(typecheck(n.Left(), ctxExpr))
 	n.SetLeft(defaultlit(n.Left(), nil))
 	typecheckslice(n.Body().Slice(), ctxStmt)
-	n = walkstmt(n)
-	return n
+	return walkstmt(n)
 }
 
 // addptr returns (*T)(uintptr(p) + n).
diff --git a/src/cmd/compile/internal/gc/select.go b/src/cmd/compile/internal/gc/select.go
index ec59f08638..0c2f2a87a2 100644
--- a/src/cmd/compile/internal/gc/select.go
+++ b/src/cmd/compile/internal/gc/select.go
@@ -225,8 +225,7 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 			if ir.IsBlank(elem) {
 				elem = nodnil()
 			}
-			receivedp := nodAddr(n.List().Second())
-			receivedp = typecheck(receivedp, ctxExpr)
+			receivedp := typecheck(nodAddr(n.List().Second()), ctxExpr)
 			call = mkcall1(chanfn("selectnbrecv2", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), elem, receivedp, ch)
 		}
 
@@ -247,9 +246,7 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 	// generate sel-struct
 	base.Pos = sellineno
 	selv := temp(types.NewArray(scasetype(), int64(ncas)))
-	r := ir.Nod(ir.OAS, selv, nil)
-	r = typecheck(r, ctxStmt)
-	init = append(init, r)
+	init = append(init, typecheck(ir.Nod(ir.OAS, selv, nil), ctxStmt))
 
 	// No initialization for order; runtime.selectgo is responsible for that.
 	order := temp(types.NewArray(types.Types[types.TUINT16], 2*int64(ncas)))
@@ -300,8 +297,7 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 
 		setField := func(f string, val ir.Node) {
 			r := ir.Nod(ir.OAS, nodSym(ir.ODOT, ir.Nod(ir.OINDEX, selv, nodintconst(int64(i))), lookup(f)), val)
-			r = typecheck(r, ctxStmt)
-			init = append(init, r)
+			init = append(init, typecheck(r, ctxStmt))
 		}
 
 		c = convnop(c, types.Types[types.TUNSAFEPTR])
@@ -314,7 +310,7 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 		// TODO(mdempsky): There should be a cleaner way to
 		// handle this.
 		if base.Flag.Race {
-			r = mkcall("selectsetpc", nil, nil, nodAddr(ir.Nod(ir.OINDEX, pcs, nodintconst(int64(i)))))
+			r := mkcall("selectsetpc", nil, nil, nodAddr(ir.Nod(ir.OINDEX, pcs, nodintconst(int64(i)))))
 			init = append(init, r)
 		}
 	}
@@ -326,12 +322,11 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 	base.Pos = sellineno
 	chosen := temp(types.Types[types.TINT])
 	recvOK := temp(types.Types[types.TBOOL])
-	r = ir.Nod(ir.OAS2, nil, nil)
+	r := ir.Nod(ir.OAS2, nil, nil)
 	r.PtrList().Set2(chosen, recvOK)
 	fn := syslook("selectgo")
 	r.PtrRlist().Set1(mkcall1(fn, fn.Type().Results(), nil, bytePtrToIndex(selv, 0), bytePtrToIndex(order, 0), pc0, nodintconst(int64(nsends)), nodintconst(int64(nrecvs)), nodbool(dflt == nil)))
-	r = typecheck(r, ctxStmt)
-	init = append(init, r)
+	init = append(init, typecheck(r, ctxStmt))
 
 	// selv and order are no longer alive after selectgo.
 	init = append(init, ir.Nod(ir.OVARKILL, selv, nil))
@@ -349,8 +344,7 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 
 		if n := cas.Left(); n != nil && n.Op() == ir.OSELRECV2 {
 			x := ir.Nod(ir.OAS, n.List().Second(), recvOK)
-			x = typecheck(x, ctxStmt)
-			r.PtrBody().Append(x)
+			r.PtrBody().Append(typecheck(x, ctxStmt))
 		}
 
 		r.PtrBody().AppendNodes(cas.PtrBody())
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 646c8dafce..14ff853ee5 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -391,10 +391,7 @@ func isSimpleName(n ir.Node) bool {
 }
 
 func litas(l ir.Node, r ir.Node, init *ir.Nodes) {
-	a := ir.Nod(ir.OAS, l, r)
-	a = typecheck(a, ctxStmt)
-	a = walkexpr(a, init)
-	init.Append(a)
+	appendWalkStmt(init, ir.Nod(ir.OAS, l, r))
 }
 
 // initGenType is a bitmap indicating the types of generation that will occur for a static value.
@@ -528,7 +525,7 @@ func fixedlit(ctxt initContext, kind initKind, n ir.Node, var_ ir.Node, init *ir
 			a := ir.Nod(ir.OINDEX, var_, nodintconst(k))
 			k++
 			if isBlank {
-				a = ir.BlankNode
+				return ir.BlankNode, r
 			}
 			return a, r
 		}
@@ -691,20 +688,12 @@ func slicelit(ctxt initContext, n ir.Node, var_ ir.Node, init *ir.Nodes) {
 	} else {
 		a = ir.Nod(ir.ONEW, ir.TypeNode(t), nil)
 	}
-
-	a = ir.Nod(ir.OAS, vauto, a)
-	a = typecheck(a, ctxStmt)
-	a = walkexpr(a, init)
-	init.Append(a)
+	appendWalkStmt(init, ir.Nod(ir.OAS, vauto, a))
 
 	if vstat != nil {
 		// copy static to heap (4)
 		a = ir.Nod(ir.ODEREF, vauto, nil)
-
-		a = ir.Nod(ir.OAS, a, vstat)
-		a = typecheck(a, ctxStmt)
-		a = walkexpr(a, init)
-		init.Append(a)
+		appendWalkStmt(init, ir.Nod(ir.OAS, a, vstat))
 	}
 
 	// put dynamics into array (5)
@@ -744,12 +733,10 @@ func slicelit(ctxt initContext, n ir.Node, var_ ir.Node, init *ir.Nodes) {
 
 		// build list of vauto[c] = expr
 		setlineno(value)
-		a = ir.Nod(ir.OAS, a, value)
-
-		a = typecheck(a, ctxStmt)
-		a = orderStmtInPlace(a, map[string][]*ir.Name{})
-		a = walkstmt(a)
-		init.Append(a)
+		as := typecheck(ir.Nod(ir.OAS, a, value), ctxStmt)
+		as = orderStmtInPlace(as, map[string][]*ir.Name{})
+		as = walkstmt(as)
+		init.Append(as)
 	}
 
 	// make slice out of heap (6)
@@ -825,9 +812,7 @@ func maplit(n ir.Node, m ir.Node, init *ir.Nodes) {
 		loop.PtrBody().Set1(body)
 		loop.PtrInit().Set1(zero)
 
-		loop = typecheck(loop, ctxStmt)
-		loop = walkstmt(loop)
-		init.Append(loop)
+		appendWalkStmt(init, loop)
 		return
 	}
 	// For a small number of entries, just add them directly.
@@ -842,30 +827,17 @@ func maplit(n ir.Node, m ir.Node, init *ir.Nodes) {
 		index, elem := r.Left(), r.Right()
 
 		setlineno(index)
-		a := ir.Nod(ir.OAS, tmpkey, index)
-		a = typecheck(a, ctxStmt)
-		a = walkstmt(a)
-		init.Append(a)
+		appendWalkStmt(init, ir.Nod(ir.OAS, tmpkey, index))
 
 		setlineno(elem)
-		a = ir.Nod(ir.OAS, tmpelem, elem)
-		a = typecheck(a, ctxStmt)
-		a = walkstmt(a)
-		init.Append(a)
+		appendWalkStmt(init, ir.Nod(ir.OAS, tmpelem, elem))
 
 		setlineno(tmpelem)
-		a = ir.Nod(ir.OAS, ir.Nod(ir.OINDEX, m, tmpkey), tmpelem)
-		a = typecheck(a, ctxStmt)
-		a = walkstmt(a)
-		init.Append(a)
+		appendWalkStmt(init, ir.Nod(ir.OAS, ir.Nod(ir.OINDEX, m, tmpkey), tmpelem))
 	}
 
-	a = ir.Nod(ir.OVARKILL, tmpkey, nil)
-	a = typecheck(a, ctxStmt)
-	init.Append(a)
-	a = ir.Nod(ir.OVARKILL, tmpelem, nil)
-	a = typecheck(a, ctxStmt)
-	init.Append(a)
+	appendWalkStmt(init, ir.Nod(ir.OVARKILL, tmpkey, nil))
+	appendWalkStmt(init, ir.Nod(ir.OVARKILL, tmpelem, nil))
 }
 
 func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
@@ -875,9 +847,7 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 		base.Fatalf("anylit: not lit, op=%v node=%v", n.Op(), n)
 
 	case ir.ONAME, ir.OMETHEXPR:
-		a := ir.Nod(ir.OAS, var_, n)
-		a = typecheck(a, ctxStmt)
-		init.Append(a)
+		appendWalkStmt(init, ir.Nod(ir.OAS, var_, n))
 
 	case ir.OPTRLIT:
 		if !t.IsPtr() {
@@ -887,20 +857,13 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 		var r ir.Node
 		if n.Right() != nil {
 			// n.Right is stack temporary used as backing store.
-			init.Append(ir.Nod(ir.OAS, n.Right(), nil)) // zero backing store, just in case (#18410)
+			appendWalkStmt(init, ir.Nod(ir.OAS, n.Right(), nil)) // zero backing store, just in case (#18410)
 			r = nodAddr(n.Right())
-			r = typecheck(r, ctxExpr)
 		} else {
 			r = ir.Nod(ir.ONEW, ir.TypeNode(n.Left().Type()), nil)
-			r = typecheck(r, ctxExpr)
 			r.SetEsc(n.Esc())
 		}
-
-		r = walkexpr(r, init)
-		a := ir.Nod(ir.OAS, var_, r)
-
-		a = typecheck(a, ctxStmt)
-		init.Append(a)
+		appendWalkStmt(init, ir.Nod(ir.OAS, var_, r))
 
 		var_ = ir.Nod(ir.ODEREF, var_, nil)
 		var_ = typecheck(var_, ctxExpr|ctxAssign)
@@ -922,11 +885,7 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 			fixedlit(ctxt, initKindStatic, n, vstat, init)
 
 			// copy static to var
-			a := ir.Nod(ir.OAS, var_, vstat)
-
-			a = typecheck(a, ctxStmt)
-			a = walkexpr(a, init)
-			init.Append(a)
+			appendWalkStmt(init, ir.Nod(ir.OAS, var_, vstat))
 
 			// add expressions to automatic
 			fixedlit(inInitFunction, initKindDynamic, n, var_, init)
@@ -941,10 +900,7 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 		}
 		// initialization of an array or struct with unspecified components (missing fields or arrays)
 		if isSimpleName(var_) || int64(n.List().Len()) < components {
-			a := ir.Nod(ir.OAS, var_, nil)
-			a = typecheck(a, ctxStmt)
-			a = walkexpr(a, init)
-			init.Append(a)
+			appendWalkStmt(init, ir.Nod(ir.OAS, var_, nil))
 		}
 
 		fixedlit(inInitFunction, initKindLocalCode, n, var_, init)
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 2082544d08..ae100507f6 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -153,12 +153,14 @@ func checkDotImports() {
 	dotImportRefs = nil
 }
 
-// nodAddr returns a node representing &n.
-func nodAddr(n ir.Node) ir.Node {
-	return ir.Nod(ir.OADDR, n, nil)
+// nodAddr returns a node representing &n at base.Pos.
+func nodAddr(n ir.Node) *ir.AddrExpr {
+	return nodAddrAt(base.Pos, n)
 }
-func nodAddrAt(pos src.XPos, n ir.Node) ir.Node {
-	return ir.NodAt(pos, ir.OADDR, n, nil)
+
+// nodAddrPos returns a node representing &n at position pos.
+func nodAddrAt(pos src.XPos, n ir.Node) *ir.AddrExpr {
+	return ir.NewAddrExpr(pos, n)
 }
 
 // newname returns a new ONAME Node associated with symbol s.
@@ -774,10 +776,7 @@ func safeexpr(n ir.Node, init *ir.Nodes) ir.Node {
 
 func copyexpr(n ir.Node, t *types.Type, init *ir.Nodes) ir.Node {
 	l := temp(t)
-	a := ir.Nod(ir.OAS, l, n)
-	a = typecheck(a, ctxStmt)
-	a = walkexpr(a, init)
-	init.Append(a)
+	appendWalkStmt(init, ir.Nod(ir.OAS, l, n))
 	return l
 }
 
@@ -1195,11 +1194,12 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 		call.PtrList().Set(paramNnames(tfn.Type()))
 		call.SetIsDDD(tfn.Type().IsVariadic())
 		if method.Type.NumResults() > 0 {
-			n := ir.Nod(ir.ORETURN, nil, nil)
-			n.PtrList().Set1(call)
-			call = n
+			ret := ir.Nod(ir.ORETURN, nil, nil)
+			ret.PtrList().Set1(call)
+			fn.PtrBody().Append(ret)
+		} else {
+			fn.PtrBody().Append(call)
 		}
-		fn.PtrBody().Append(call)
 	}
 
 	if false && base.Flag.LowerR != 0 {
diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index e241721588..aa4574d334 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -654,9 +654,7 @@ func (s *typeSwitch) Add(pos src.XPos, typ *types.Type, caseVar, jmp ir.Node) {
 	dot := ir.NodAt(pos, ir.ODOTTYPE, s.facename, nil)
 	dot.SetType(typ) // iface.(type)
 	as.PtrRlist().Set1(dot)
-	as = typecheck(as, ctxStmt)
-	as = walkexpr(as, &body)
-	body.Append(as)
+	appendWalkStmt(&body, as)
 
 	// if ok { goto label }
 	nif := ir.NodAt(pos, ir.OIF, nil, nil)
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 49e4289f14..be868afcd8 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -2163,8 +2163,7 @@ func typecheckargs(n ir.Node) {
 		Curfn = nil
 	}
 
-	as = typecheck(as, ctxStmt)
-	n.PtrInit().Append(as)
+	n.PtrInit().Append(typecheck(as, ctxStmt))
 }
 
 func checksliceindex(l ir.Node, r ir.Node, tp *types.Type) bool {
@@ -2397,7 +2396,7 @@ func typecheckMethodExpr(n ir.Node) (res ir.Node) {
 	me.SetType(methodfunc(m.Type, n.Left().Type()))
 	me.SetOffset(0)
 	me.SetClass(ir.PFUNC)
-	me.(*ir.MethodExpr).Method = m
+	ir.Node(me).(*ir.MethodExpr).Method = m
 
 	// Issue 25065. Make sure that we emit the symbol for a local method.
 	if base.Ctxt.Flag_dynlink && !inimport && (t.Sym() == nil || t.Sym().Pkg == types.LocalPkg) {
@@ -3419,8 +3418,7 @@ func stringtoruneslit(n ir.Node) ir.Node {
 
 	nn := ir.Nod(ir.OCOMPLIT, nil, ir.TypeNode(n.Type()))
 	nn.PtrList().Set(l)
-	nn = typecheck(nn, ctxExpr)
-	return nn
+	return typecheck(nn, ctxExpr)
 }
 
 var mapqueue []*ir.MapType
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index c9dbf91702..790e51f1e6 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -1306,8 +1306,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 				bsym := hmapType.Field(5).Sym // hmap.buckets see reflect.go:hmap
 				na := ir.Nod(ir.OAS, nodSym(ir.ODOT, h, bsym), b)
 				nif.PtrBody().Append(na)
-
-				init.Append(walkstmt(typecheck(nif, ctxStmt)))
+				appendWalkStmt(init, nif)
 			}
 		}
 
@@ -1325,7 +1324,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 				// h.hash0 = fastrand()
 				rand := mkcall("fastrand", types.Types[types.TUINT32], init)
 				hashsym := hmapType.Field(4).Sym // hmap.hash0 see reflect.go:hmap
-				appendWalk(init, ir.Nod(ir.OAS, nodSym(ir.ODOT, h, hashsym), rand))
+				appendWalkStmt(init, ir.Nod(ir.OAS, nodSym(ir.ODOT, h, hashsym), rand))
 				return convnop(h, t)
 			}
 			// Call runtime.makehmap to allocate an
@@ -1398,8 +1397,8 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 			t = types.NewArray(t.Elem(), i) // [r]T
 			var_ := temp(t)
-			appendWalk(init, ir.Nod(ir.OAS, var_, nil)) // zero temp
-			r := ir.Nod(ir.OSLICE, var_, nil)           // arr[:l]
+			appendWalkStmt(init, ir.Nod(ir.OAS, var_, nil)) // zero temp
+			r := ir.Nod(ir.OSLICE, var_, nil)               // arr[:l]
 			r.SetSliceBounds(nil, l, nil)
 			// The conv is necessary in case n.Type is named.
 			return walkexpr(typecheck(conv(r, n.Type()), ctxExpr), init)
@@ -1547,7 +1546,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 				as := ir.Nod(ir.OAS,
 					ir.Nod(ir.ODEREF, p, nil),
 					ir.Nod(ir.ODEREF, convnop(ir.Nod(ir.OSPTR, s, nil), t.PtrTo()), nil))
-				appendWalk(init, as)
+				appendWalkStmt(init, as)
 			}
 
 			// Slice the [n]byte to a []byte.
@@ -2807,7 +2806,7 @@ func appendslice(n ir.Node, init *ir.Nodes) ir.Node {
 		// memmove(&s[len(l1)], &l2[0], len(l2)*sizeof(T))
 		ix := ir.Nod(ir.OINDEX, s, ir.Nod(ir.OLEN, l1, nil))
 		ix.SetBounded(true)
-		addr := ir.Nod(ir.OADDR, ix, nil)
+		addr := nodAddr(ix)
 
 		sptr := ir.Nod(ir.OSPTR, l2, nil)
 
@@ -2953,7 +2952,7 @@ func extendslice(n ir.Node, init *ir.Nodes) ir.Node {
 	// hp := &s[len(l1)]
 	ix := ir.Nod(ir.OINDEX, s, ir.Nod(ir.OLEN, l1, nil))
 	ix.SetBounded(true)
-	hp := convnop(ir.Nod(ir.OADDR, ix, nil), types.Types[types.TUNSAFEPTR])
+	hp := convnop(nodAddr(ix), types.Types[types.TUNSAFEPTR])
 
 	// hn := l2 * sizeof(elem(s))
 	hn := conv(ir.Nod(ir.OMUL, l2, nodintconst(elemtype.Width)), types.Types[types.TUINTPTR])
@@ -4071,3 +4070,19 @@ func walkCheckPtrArithmetic(n ir.Node, init *ir.Nodes) ir.Node {
 func checkPtr(fn *ir.Func, level int) bool {
 	return base.Debug.Checkptr >= level && fn.Pragma&ir.NoCheckPtr == 0
 }
+
+// appendWalkStmt typechecks and walks stmt and then appends it to init.
+func appendWalkStmt(init *ir.Nodes, stmt ir.Node) {
+	op := stmt.Op()
+	n := typecheck(stmt, ctxStmt)
+	if op == ir.OAS || op == ir.OAS2 {
+		// If the assignment has side effects, walkexpr will append them
+		// directly to init for us, while walkstmt will wrap it in an OBLOCK.
+		// We need to append them directly.
+		// TODO(rsc): Clean this up.
+		n = walkexpr(n, init)
+	} else {
+		n = walkstmt(n)
+	}
+	init.Append(n)
+}
-- 
GitLab


From 578fbbe3aa5cada6e32b686d71a5832d6ca846dc Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 7 Dec 2020 14:58:26 -0500
Subject: [PATCH 0238/2400] [dev.regabi] cmd/compile: rewrite some generic
 ir.Nod calls

An automated rewrite is going to remove the bulk of the calls
to ir.Nod and friends. This CL takes care of the ones that don't
have fixed opcodes and so aren't amenable to automatic rewriting.

Passes buildall w/ toolstash -cmp.

Replay of CL 275886, lost to the bad-merge history rewrite.

Change-Id: I5bf8d1d182f847f4ab44b7e278b752913e30e4c8
Reviewed-on: https://go-review.googlesource.com/c/go/+/277956
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/iimport.go   | 50 +++++++++++++++++-------
 src/cmd/compile/internal/gc/noder.go     | 27 +++++++++----
 src/cmd/compile/internal/gc/order.go     |  7 +---
 src/cmd/compile/internal/gc/select.go    |  6 ++-
 src/cmd/compile/internal/gc/subr.go      |  5 +--
 src/cmd/compile/internal/gc/typecheck.go | 20 ++++------
 src/cmd/compile/internal/gc/walk.go      | 42 ++++++++------------
 7 files changed, 89 insertions(+), 68 deletions(-)

diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 0e2af562d0..1096d7988e 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -894,10 +894,10 @@ func (r *importReader) node() ir.Node {
 	// 	unreachable - mapped to cases below by exporter
 
 	case ir.OINDEX:
-		return ir.NodAt(r.pos(), op, r.expr(), r.expr())
+		return ir.NodAt(r.pos(), ir.OINDEX, r.expr(), r.expr())
 
 	case ir.OSLICE, ir.OSLICE3:
-		n := ir.NodAt(r.pos(), op, r.expr(), nil)
+		n := ir.NewSliceExpr(r.pos(), op, r.expr())
 		low, high := r.exprsOrNil()
 		var max ir.Node
 		if n.Op().IsSlice3() {
@@ -940,15 +940,25 @@ func (r *importReader) node() ir.Node {
 		return n
 
 	// unary expressions
-	case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ODEREF, ir.ONOT, ir.ORECV:
-		return ir.NodAt(r.pos(), op, r.expr(), nil)
+	case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT, ir.ORECV:
+		return ir.NewUnaryExpr(r.pos(), op, r.expr())
+
 	case ir.OADDR:
 		return nodAddrAt(r.pos(), r.expr())
 
+	case ir.ODEREF:
+		return ir.NewStarExpr(r.pos(), r.expr())
+
 	// binary expressions
-	case ir.OADD, ir.OAND, ir.OANDAND, ir.OANDNOT, ir.ODIV, ir.OEQ, ir.OGE, ir.OGT, ir.OLE, ir.OLT,
-		ir.OLSH, ir.OMOD, ir.OMUL, ir.ONE, ir.OOR, ir.OOROR, ir.ORSH, ir.OSEND, ir.OSUB, ir.OXOR:
-		return ir.NodAt(r.pos(), op, r.expr(), r.expr())
+	case ir.OADD, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OEQ, ir.OGE, ir.OGT, ir.OLE, ir.OLT,
+		ir.OLSH, ir.OMOD, ir.OMUL, ir.ONE, ir.OOR, ir.ORSH, ir.OSUB, ir.OXOR:
+		return ir.NewBinaryExpr(r.pos(), op, r.expr(), r.expr())
+
+	case ir.OANDAND, ir.OOROR:
+		return ir.NewLogicalExpr(r.pos(), op, r.expr(), r.expr())
+
+	case ir.OSEND:
+		return ir.NewSendStmt(r.pos(), r.expr(), r.expr())
 
 	case ir.OADDSTR:
 		pos := r.pos()
@@ -1003,7 +1013,7 @@ func (r *importReader) node() ir.Node {
 	// 	unreachable - generated by compiler for trampolin routines (not exported)
 
 	case ir.OGO, ir.ODEFER:
-		return ir.NodAt(r.pos(), op, r.expr(), nil)
+		return ir.NewGoDeferStmt(r.pos(), op, r.expr())
 
 	case ir.OIF:
 		n := ir.NodAt(r.pos(), ir.OIF, nil, nil)
@@ -1029,8 +1039,16 @@ func (r *importReader) node() ir.Node {
 		n.PtrBody().Set(r.stmtList())
 		return n
 
-	case ir.OSELECT, ir.OSWITCH:
-		n := ir.NodAt(r.pos(), op, nil, nil)
+	case ir.OSELECT:
+		n := ir.NodAt(r.pos(), ir.OSELECT, nil, nil)
+		n.PtrInit().Set(r.stmtList())
+		left, _ := r.exprsOrNil()
+		n.SetLeft(left)
+		n.PtrList().Set(r.caseList(n))
+		return n
+
+	case ir.OSWITCH:
+		n := ir.NodAt(r.pos(), ir.OSWITCH, nil, nil)
 		n.PtrInit().Set(r.stmtList())
 		left, _ := r.exprsOrNil()
 		n.SetLeft(left)
@@ -1047,12 +1065,16 @@ func (r *importReader) node() ir.Node {
 	// case OEMPTY:
 	// 	unreachable - not emitted by exporter
 
-	case ir.OBREAK, ir.OCONTINUE, ir.OGOTO, ir.OLABEL:
-		n := ir.NodAt(r.pos(), op, nil, nil)
+	case ir.OBREAK, ir.OCONTINUE, ir.OGOTO:
+		var sym *types.Sym
+		pos := r.pos()
 		if label := r.string(); label != "" {
-			n.SetSym(lookup(label))
+			sym = lookup(label)
 		}
-		return n
+		return ir.NewBranchStmt(pos, op, sym)
+
+	case ir.OLABEL:
+		return ir.NewLabelStmt(r.pos(), lookup(r.string()))
 
 	case ir.OEND:
 		return nil
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 55628352bd..4c8e56731b 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -699,7 +699,7 @@ func (p *noder) expr(expr syntax.Expr) ir.Node {
 		if expr.Full {
 			op = ir.OSLICE3
 		}
-		n := p.nod(expr, op, p.expr(expr.X), nil)
+		n := ir.NewSliceExpr(p.pos(expr), op, p.expr(expr.X))
 		var index [3]ir.Node
 		for i, x := range &expr.Index {
 			if x != nil {
@@ -716,9 +716,22 @@ func (p *noder) expr(expr syntax.Expr) ir.Node {
 		}
 		x := p.expr(expr.X)
 		if expr.Y == nil {
-			return p.nod(expr, p.unOp(expr.Op), x, nil)
+			pos, op := p.pos(expr), p.unOp(expr.Op)
+			switch op {
+			case ir.OADDR:
+				return nodAddrAt(pos, x)
+			case ir.ODEREF:
+				return ir.NewStarExpr(pos, x)
+			}
+			return ir.NewUnaryExpr(pos, op, x)
+		}
+
+		pos, op, y := p.pos(expr), p.binOp(expr.Op), p.expr(expr.Y)
+		switch op {
+		case ir.OANDAND, ir.OOROR:
+			return ir.NewLogicalExpr(pos, op, x, y)
 		}
-		return p.nod(expr, p.binOp(expr.Op), x, p.expr(expr.Y))
+		return ir.NewBinaryExpr(pos, op, x, y)
 	case *syntax.CallExpr:
 		n := p.nod(expr, ir.OCALL, p.expr(expr.Fun), nil)
 		n.PtrList().Set(p.exprs(expr.ArgList))
@@ -1043,11 +1056,11 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) ir.Node {
 		default:
 			panic("unhandled BranchStmt")
 		}
-		n := p.nod(stmt, op, nil, nil)
+		var sym *types.Sym
 		if stmt.Label != nil {
-			n.SetSym(p.name(stmt.Label))
+			sym = p.name(stmt.Label)
 		}
-		return n
+		return ir.NewBranchStmt(p.pos(stmt), op, sym)
 	case *syntax.CallStmt:
 		var op ir.Op
 		switch stmt.Tok {
@@ -1058,7 +1071,7 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) ir.Node {
 		default:
 			panic("unhandled CallStmt")
 		}
-		return p.nod(stmt, op, p.expr(stmt.Call), nil)
+		return ir.NewGoDeferStmt(p.pos(stmt), op, p.expr(stmt.Call))
 	case *syntax.ReturnStmt:
 		var results []ir.Node
 		if stmt.Results != nil {
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 56acdf7528..fe64738856 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -619,11 +619,8 @@ func (o *Order) stmt(n ir.Node) {
 				l2.SetIndexMapLValue(false)
 			}
 			l2 = o.copyExpr(l2)
-			r := ir.NodAt(n.Pos(), n.SubOp(), l2, n.Right())
-			r = typecheck(r, ctxExpr)
-			r = o.expr(r, nil)
-			n = ir.NodAt(n.Pos(), ir.OAS, l1, r)
-			n = typecheck(n, ctxStmt)
+			r := o.expr(typecheck(ir.NewBinaryExpr(n.Pos(), n.SubOp(), l2, n.Right()), ctxExpr), nil)
+			n = typecheck(ir.NodAt(n.Pos(), ir.OAS, l1, r), ctxStmt)
 		}
 
 		o.mapAssign(n)
diff --git a/src/cmd/compile/internal/gc/select.go b/src/cmd/compile/internal/gc/select.go
index 0c2f2a87a2..dd08b77b92 100644
--- a/src/cmd/compile/internal/gc/select.go
+++ b/src/cmd/compile/internal/gc/select.go
@@ -70,7 +70,8 @@ func typecheckselect(sel ir.Node) {
 
 			case ir.ORECV:
 				// convert <-c into OSELRECV(_, <-c)
-				n = ir.NodAt(n.Pos(), ir.OSELRECV, ir.BlankNode, n)
+				n = ir.NodAt(n.Pos(), ir.OAS, ir.BlankNode, n)
+				n.SetOp(ir.OSELRECV)
 				n.SetTypecheck(1)
 				ncase.SetLeft(n)
 
@@ -164,7 +165,8 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 
 		// Lower x, _ = <-c to x = <-c.
 		if n.Op() == ir.OSELRECV2 && ir.IsBlank(n.List().Second()) {
-			n = ir.NodAt(n.Pos(), ir.OSELRECV, n.List().First(), n.Rlist().First())
+			n = ir.NodAt(n.Pos(), ir.OAS, n.List().First(), n.Rlist().First())
+			n.SetOp(ir.OSELRECV)
 			n.SetTypecheck(1)
 			cas.SetLeft(n)
 		}
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index ae100507f6..37e49d0544 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -547,8 +547,7 @@ func assignconvfn(n ir.Node, t *types.Type, context func() string) ir.Node {
 		op = ir.OCONV
 	}
 
-	r := ir.Nod(op, n, nil)
-	r.SetType(t)
+	r := ir.NewConvExpr(base.Pos, op, t, n)
 	r.SetTypecheck(1)
 	r.SetImplicit(true)
 	return r
@@ -1169,7 +1168,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 		fn.PtrBody().Append(n)
 	}
 
-	dot := adddot(nodSym(ir.OXDOT, nthis, method.Sym))
+	dot := adddot(ir.NewSelectorExpr(base.Pos, ir.OXDOT, nthis, method.Sym))
 
 	// generate call
 	// It's not possible to use a tail call when dynamic linking on ppc64le. The
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index be868afcd8..6dc9c5820d 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -766,8 +766,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 					dowidth(l.Type())
 					if r.Type().IsInterface() == l.Type().IsInterface() || l.Type().Width >= 1<<16 {
-						l = ir.Nod(aop, l, nil)
-						l.SetType(r.Type())
+						l = ir.NewConvExpr(base.Pos, aop, r.Type(), l)
 						l.SetTypecheck(1)
 						n.SetLeft(l)
 					}
@@ -788,8 +787,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 					dowidth(r.Type())
 					if r.Type().IsInterface() == l.Type().IsInterface() || r.Type().Width >= 1<<16 {
-						r = ir.Nod(aop, r, nil)
-						r.SetType(l.Type())
+						r = ir.NewConvExpr(base.Pos, aop, l.Type(), r)
 						r.SetTypecheck(1)
 						n.SetRight(r)
 					}
@@ -1361,12 +1359,12 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			switch l.SubOp() {
 			default:
 				base.Fatalf("unknown builtin %v", l)
-				return n
 
 			case ir.OAPPEND, ir.ODELETE, ir.OMAKE, ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
 				n.SetOp(l.SubOp())
 				n.SetLeft(nil)
 				n.SetTypecheck(0) // re-typechecking new op is OK, not a loop
+				return typecheck(n, top)
 
 			case ir.OCAP, ir.OCLOSE, ir.OIMAG, ir.OLEN, ir.OPANIC, ir.OREAL:
 				typecheckargs(n)
@@ -1377,9 +1375,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 					n.SetType(nil)
 					return n
 				}
-				old := n
-				n = ir.NodAt(n.Pos(), l.SubOp(), arg, nil)
-				n = initExpr(old.Init().Slice(), n) // typecheckargs can add to old.Init
+				u := ir.NewUnaryExpr(n.Pos(), l.SubOp(), arg)
+				return typecheck(initExpr(n.Init().Slice(), u), top) // typecheckargs can add to old.Init
 
 			case ir.OCOMPLEX, ir.OCOPY:
 				typecheckargs(n)
@@ -1388,11 +1385,10 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 					n.SetType(nil)
 					return n
 				}
-				old := n
-				n = ir.NodAt(n.Pos(), l.SubOp(), arg1, arg2)
-				n = initExpr(old.Init().Slice(), n) // typecheckargs can add to old.Init
+				b := ir.NewBinaryExpr(n.Pos(), l.SubOp(), arg1, arg2)
+				return typecheck(initExpr(n.Init().Slice(), b), top) // typecheckargs can add to old.Init
 			}
-			return typecheck(n, top)
+			panic("unreachable")
 		}
 
 		n.SetLeft(defaultlit(n.Left(), nil))
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 790e51f1e6..ad5103f851 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -666,7 +666,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		if n.Op() == ir.OASOP {
 			// Rewrite x op= y into x = x op y.
 			n = ir.Nod(ir.OAS, n.Left(),
-				typecheck(ir.Nod(n.SubOp(), n.Left(), n.Right()), ctxExpr))
+				typecheck(ir.NewBinaryExpr(base.Pos, n.SubOp(), n.Left(), n.Right()), ctxExpr))
 		}
 
 		if oaslit(n, init) {
@@ -3232,16 +3232,16 @@ func walkcompare(n ir.Node, init *ir.Nodes) ir.Node {
 		if l.Type().IsEmptyInterface() {
 			tab.SetType(types.NewPtr(types.Types[types.TUINT8]))
 			tab.SetTypecheck(1)
-			eqtype = ir.Nod(eq, tab, rtyp)
+			eqtype = ir.NewBinaryExpr(base.Pos, eq, tab, rtyp)
 		} else {
-			nonnil := ir.Nod(brcom(eq), nodnil(), tab)
-			match := ir.Nod(eq, itabType(tab), rtyp)
-			eqtype = ir.Nod(andor, nonnil, match)
+			nonnil := ir.NewBinaryExpr(base.Pos, brcom(eq), nodnil(), tab)
+			match := ir.NewBinaryExpr(base.Pos, eq, itabType(tab), rtyp)
+			eqtype = ir.NewLogicalExpr(base.Pos, andor, nonnil, match)
 		}
 		// Check for data equal.
-		eqdata := ir.Nod(eq, ifaceData(n.Pos(), l, r.Type()), r)
+		eqdata := ir.NewBinaryExpr(base.Pos, eq, ifaceData(n.Pos(), l, r.Type()), r)
 		// Put it all together.
-		expr := ir.Nod(andor, eqtype, eqdata)
+		expr := ir.NewLogicalExpr(base.Pos, andor, eqtype, eqdata)
 		n = finishcompare(n, expr, init)
 		return n
 	}
@@ -3354,11 +3354,11 @@ func walkcompare(n ir.Node, init *ir.Nodes) ir.Node {
 	}
 	var expr ir.Node
 	compare := func(el, er ir.Node) {
-		a := ir.Nod(n.Op(), el, er)
+		a := ir.NewBinaryExpr(base.Pos, n.Op(), el, er)
 		if expr == nil {
 			expr = a
 		} else {
-			expr = ir.Nod(andor, expr, a)
+			expr = ir.NewLogicalExpr(base.Pos, andor, expr, a)
 		}
 	}
 	cmpl = safeexpr(cmpl, init)
@@ -3519,13 +3519,13 @@ func walkcompareString(n ir.Node, init *ir.Nodes) ir.Node {
 			if len(s) > 0 {
 				ncs = safeexpr(ncs, init)
 			}
-			r := ir.Nod(cmp, ir.Nod(ir.OLEN, ncs, nil), nodintconst(int64(len(s))))
+			r := ir.Node(ir.NewBinaryExpr(base.Pos, cmp, ir.Nod(ir.OLEN, ncs, nil), nodintconst(int64(len(s)))))
 			remains := len(s)
 			for i := 0; remains > 0; {
 				if remains == 1 || !canCombineLoads {
 					cb := nodintconst(int64(s[i]))
 					ncb := ir.Nod(ir.OINDEX, ncs, nodintconst(int64(i)))
-					r = ir.Nod(and, r, ir.Nod(cmp, ncb, cb))
+					r = ir.NewLogicalExpr(base.Pos, and, r, ir.NewBinaryExpr(base.Pos, cmp, ncb, cb))
 					remains--
 					i++
 					continue
@@ -3556,7 +3556,7 @@ func walkcompareString(n ir.Node, init *ir.Nodes) ir.Node {
 				}
 				csubstrPart := nodintconst(csubstr)
 				// Compare "step" bytes as once
-				r = ir.Nod(and, r, ir.Nod(cmp, csubstrPart, ncsubstr))
+				r = ir.NewLogicalExpr(base.Pos, and, r, ir.NewBinaryExpr(base.Pos, cmp, csubstrPart, ncsubstr))
 				remains -= step
 				i += step
 			}
@@ -3583,7 +3583,7 @@ func walkcompareString(n ir.Node, init *ir.Nodes) ir.Node {
 	} else {
 		// sys_cmpstring(s1, s2) :: 0
 		r = mkcall("cmpstring", types.Types[types.TINT], init, conv(n.Left(), types.Types[types.TSTRING]), conv(n.Right(), types.Types[types.TSTRING]))
-		r = ir.Nod(n.Op(), r, nodintconst(0))
+		r = ir.NewBinaryExpr(base.Pos, n.Op(), r, nodintconst(0))
 	}
 
 	return finishcompare(n, r, init)
@@ -3909,17 +3909,13 @@ func wrapCall(n ir.Node, init *ir.Nodes) ir.Node {
 		if origArg == nil {
 			continue
 		}
-		arg := ir.Nod(origArg.Op(), args[i], nil)
-		arg.SetType(origArg.Type())
-		args[i] = arg
+		args[i] = ir.NewConvExpr(base.Pos, origArg.Op(), origArg.Type(), args[i])
 	}
-	call := ir.Nod(n.Op(), nil, nil)
+	call := ir.NewCallExpr(base.Pos, n.Op(), n.Left(), args)
 	if !isBuiltinCall {
 		call.SetOp(ir.OCALL)
-		call.SetLeft(n.Left())
 		call.SetIsDDD(n.IsDDD())
 	}
-	call.PtrList().Set(args)
 	fn.PtrBody().Set1(call)
 
 	funcbody()
@@ -3928,12 +3924,8 @@ func wrapCall(n ir.Node, init *ir.Nodes) ir.Node {
 	typecheckslice(fn.Body().Slice(), ctxStmt)
 	xtop = append(xtop, fn)
 
-	call = ir.Nod(ir.OCALL, nil, nil)
-	call.SetLeft(fn.Nname)
-	call.PtrList().Set(n.List().Slice())
-	call = typecheck(call, ctxStmt)
-	call = walkexpr(call, init)
-	return call
+	call = ir.NewCallExpr(base.Pos, ir.OCALL, fn.Nname, n.List().Slice())
+	return walkexpr(typecheck(call, ctxStmt), init)
 }
 
 // substArgTypes substitutes the given list of types for
-- 
GitLab


From a997543292df533f5951cd8fda39692a44077151 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 7 Dec 2020 16:07:38 -0500
Subject: [PATCH 0239/2400] [dev.regabi] cmd/compile: fix potential closure
 waste in Order

I haven't measured this, but it's the only use of EditChildren
where we aren't careful to allocate a closure once and use it
for the whole recursion. This one is allocating a closure at
every level of the recursion, and it was an oversight that it
wasn't cleaned up in the original CL.

Passes buildall w/ toolstash -cmp.

Change-Id: I5e3f1795c6f64c5867a19c077f797643aa1066a3
Reviewed-on: https://go-review.googlesource.com/c/go/+/277914
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/order.go | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index fe64738856..e0c0cabcde 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -47,6 +47,7 @@ type Order struct {
 	out  []ir.Node             // list of generated statements
 	temp []*ir.Name            // stack of temporary variables
 	free map[string][]*ir.Name // free list of unused temporaries, by type.LongString().
+	edit func(ir.Node) ir.Node // cached closure of o.exprNoLHS
 }
 
 // Order rewrites fn.Nbody to apply the ordering constraints
@@ -1072,7 +1073,10 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 
 	switch n.Op() {
 	default:
-		ir.EditChildren(n, o.exprNoLHS)
+		if o.edit == nil {
+			o.edit = o.exprNoLHS // create closure once
+		}
+		ir.EditChildren(n, o.edit)
 
 	// Addition of strings turns into a function call.
 	// Allocate a temporary to hold the strings.
-- 
GitLab


From 4dfc7333f4ebe67e0aa7f429ce73c9d58a2fc309 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 10 Dec 2020 20:55:10 -0500
Subject: [PATCH 0240/2400] [dev.regabi] cmd/compile: update ir/fmt for
 concrete types

An automated rewrite will add concrete type assertions after
a test of n.Op(), when n can be safely type-asserted
(meaning, n is not reassigned a different type, n is not reassigned
and then used outside the scope of the type assertion,
and so on).

This sequence of CLs handles the code that the automated
rewrite does not: adding specific types to function arguments,
adjusting code not to call n.Left() etc when n may have multiple
representations, and so on.

This CL handles package fmt. There are various type assertions
but also some rewriting to lean more heavily on reflection.

Passes buildall w/ toolstash -cmp.

Change-Id: I503467468b42ace11bff2ba014b03cfa345e6d03
Reviewed-on: https://go-review.googlesource.com/c/go/+/277915
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/fmt.go  | 285 +++++++++++++++++++---------
 src/cmd/compile/internal/ir/name.go |  22 +--
 test/escape_param.go                |   4 +-
 3 files changed, 208 insertions(+), 103 deletions(-)

diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 4bea6e2ae0..3cda9c8c38 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -9,6 +9,7 @@ import (
 	"fmt"
 	"go/constant"
 	"io"
+	"math"
 	"os"
 	"path/filepath"
 	"reflect"
@@ -141,7 +142,7 @@ func FmtNode(n Node, s fmt.State, verb rune) {
 	}
 
 	if n == nil {
-		fmt.Fprint(s, "<N>")
+		fmt.Fprint(s, "<nil>")
 		return
 	}
 
@@ -330,12 +331,14 @@ func stmtFmt(n Node, s fmt.State) {
 
 	switch n.Op() {
 	case ODCL:
+		n := n.(*Decl)
 		fmt.Fprintf(s, "var %v %v", n.Left().Sym(), n.Left().Type())
 
 	// Don't export "v = <N>" initializing statements, hope they're always
 	// preceded by the DCL which will be re-parsed and typechecked to reproduce
 	// the "v = <N>" again.
 	case OAS:
+		n := n.(*AssignStmt)
 		if n.Colas() && !complexinit {
 			fmt.Fprintf(s, "%v := %v", n.Left(), n.Right())
 		} else {
@@ -343,6 +346,7 @@ func stmtFmt(n Node, s fmt.State) {
 		}
 
 	case OASOP:
+		n := n.(*AssignOpStmt)
 		if n.Implicit() {
 			if n.SubOp() == OADD {
 				fmt.Fprintf(s, "%v++", n.Left())
@@ -355,6 +359,7 @@ func stmtFmt(n Node, s fmt.State) {
 		fmt.Fprintf(s, "%v %v= %v", n.Left(), n.SubOp(), n.Right())
 
 	case OAS2, OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV:
+		n := n.(*AssignListStmt)
 		if n.Colas() && !complexinit {
 			fmt.Fprintf(s, "%.v := %.v", n.List(), n.Rlist())
 		} else {
@@ -362,26 +367,33 @@ func stmtFmt(n Node, s fmt.State) {
 		}
 
 	case OBLOCK:
+		n := n.(*BlockStmt)
 		if n.List().Len() != 0 {
 			fmt.Fprintf(s, "%v", n.List())
 		}
 
 	case ORETURN:
+		n := n.(*ReturnStmt)
 		fmt.Fprintf(s, "return %.v", n.List())
 
 	case ORETJMP:
+		n := n.(*BranchStmt)
 		fmt.Fprintf(s, "retjmp %v", n.Sym())
 
 	case OINLMARK:
+		n := n.(*InlineMarkStmt)
 		fmt.Fprintf(s, "inlmark %d", n.Offset())
 
 	case OGO:
+		n := n.(*GoDeferStmt)
 		fmt.Fprintf(s, "go %v", n.Left())
 
 	case ODEFER:
+		n := n.(*GoDeferStmt)
 		fmt.Fprintf(s, "defer %v", n.Left())
 
 	case OIF:
+		n := n.(*IfStmt)
 		if simpleinit {
 			fmt.Fprintf(s, "if %v; %v { %v }", n.Init().First(), n.Left(), n.Body())
 		} else {
@@ -392,6 +404,7 @@ func stmtFmt(n Node, s fmt.State) {
 		}
 
 	case OFOR, OFORUNTIL:
+		n := n.(*ForStmt)
 		opname := "for"
 		if n.Op() == OFORUNTIL {
 			opname = "foruntil"
@@ -425,6 +438,7 @@ func stmtFmt(n Node, s fmt.State) {
 		fmt.Fprintf(s, " { %v }", n.Body())
 
 	case ORANGE:
+		n := n.(*RangeStmt)
 		if !exportFormat {
 			fmt.Fprint(s, "for loop")
 			break
@@ -437,23 +451,31 @@ func stmtFmt(n Node, s fmt.State) {
 
 		fmt.Fprintf(s, "for %.v = range %v { %v }", n.List(), n.Right(), n.Body())
 
-	case OSELECT, OSWITCH:
+	case OSELECT:
+		n := n.(*SelectStmt)
 		if !exportFormat {
 			fmt.Fprintf(s, "%v statement", n.Op())
 			break
 		}
+		fmt.Fprintf(s, "select { %v }", n.List())
 
-		fmt.Fprintf(s, "%v", n.Op())
+	case OSWITCH:
+		n := n.(*SwitchStmt)
+		if !exportFormat {
+			fmt.Fprintf(s, "%v statement", n.Op())
+			break
+		}
+		fmt.Fprintf(s, "switch")
 		if simpleinit {
 			fmt.Fprintf(s, " %v;", n.Init().First())
 		}
 		if n.Left() != nil {
 			fmt.Fprintf(s, " %v ", n.Left())
 		}
-
 		fmt.Fprintf(s, " { %v }", n.List())
 
 	case OCASE:
+		n := n.(*CaseStmt)
 		if n.List().Len() != 0 {
 			fmt.Fprintf(s, "case %.v", n.List())
 		} else {
@@ -462,6 +484,7 @@ func stmtFmt(n Node, s fmt.State) {
 		fmt.Fprintf(s, ": %v", n.Body())
 
 	case OBREAK, OCONTINUE, OGOTO, OFALL:
+		n := n.(*BranchStmt)
 		if n.Sym() != nil {
 			fmt.Fprintf(s, "%v %v", n.Op(), n.Sym())
 		} else {
@@ -469,6 +492,7 @@ func stmtFmt(n Node, s fmt.State) {
 		}
 
 	case OLABEL:
+		n := n.(*LabelStmt)
 		fmt.Fprintf(s, "%v: ", n.Sym())
 	}
 
@@ -488,7 +512,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 
 	for {
 		if n == nil {
-			fmt.Fprint(s, "<N>")
+			fmt.Fprint(s, "<nil>")
 			return
 		}
 
@@ -499,10 +523,23 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		}
 
 		// Skip implicit operations introduced during typechecking.
-		switch n.Op() {
-		case OADDR, ODEREF, OCONV, OCONVNOP, OCONVIFACE:
-			if n.Implicit() {
-				n = n.Left()
+		switch nn := n; nn.Op() {
+		case OADDR:
+			nn := nn.(*AddrExpr)
+			if nn.Implicit() {
+				n = nn.Left()
+				continue
+			}
+		case ODEREF:
+			nn := nn.(*StarExpr)
+			if nn.Implicit() {
+				n = nn.Left()
+				continue
+			}
+		case OCONV, OCONVNOP, OCONVIFACE:
+			nn := nn.(*ConvExpr)
+			if nn.Implicit() {
+				n = nn.Left()
 				continue
 			}
 		}
@@ -522,6 +559,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 
 	switch n.Op() {
 	case OPAREN:
+		n := n.(*ParenExpr)
 		fmt.Fprintf(s, "(%v)", n.Left())
 
 	case ONIL:
@@ -570,6 +608,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		}
 
 	case ODCLFUNC:
+		n := n.(*Func)
 		if sym := n.Sym(); sym != nil {
 			fmt.Fprint(s, sym)
 			return
@@ -577,6 +616,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		fmt.Fprintf(s, "<unnamed Func>")
 
 	case ONAME:
+		n := n.(*Name)
 		// Special case: name used as local variable in export.
 		// _ becomes ~b%d internally; print as _ for export
 		if !exportFormat && n.Sym() != nil && n.Sym().Name[0] == '~' && n.Sym().Name[1] == 'b' {
@@ -641,17 +681,15 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		fmt.Fprint(s, "<func>")
 
 	case OCLOSURE:
+		n := n.(*ClosureExpr)
 		if !exportFormat {
 			fmt.Fprint(s, "func literal")
 			return
 		}
-		if n.Body().Len() != 0 {
-			fmt.Fprintf(s, "%v { %v }", n.Type(), n.Body())
-			return
-		}
 		fmt.Fprintf(s, "%v { %v }", n.Type(), n.Func().Body())
 
 	case OCOMPLIT:
+		n := n.(*CompLitExpr)
 		if !exportFormat {
 			if n.Implicit() {
 				fmt.Fprintf(s, "... argument")
@@ -668,9 +706,11 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		fmt.Fprintf(s, "(%v{ %.v })", n.Right(), n.List())
 
 	case OPTRLIT:
+		n := n.(*AddrExpr)
 		fmt.Fprintf(s, "&%v", n.Left())
 
 	case OSTRUCTLIT, OARRAYLIT, OSLICELIT, OMAPLIT:
+		n := n.(*CompLitExpr)
 		if !exportFormat {
 			fmt.Fprintf(s, "%v{%s}", n.Type(), ellipsisIf(n.List().Len() != 0))
 			return
@@ -678,6 +718,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		fmt.Fprintf(s, "(%v{ %.v })", n.Type(), n.List())
 
 	case OKEY:
+		n := n.(*KeyExpr)
 		if n.Left() != nil && n.Right() != nil {
 			fmt.Fprintf(s, "%v:%v", n.Left(), n.Right())
 			return
@@ -694,9 +735,11 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		fmt.Fprint(s, ":")
 
 	case OSTRUCTKEY:
+		n := n.(*StructKeyExpr)
 		fmt.Fprintf(s, "%v:%v", n.Sym(), n.Left())
 
 	case OCALLPART:
+		n := n.(*CallPartExpr)
 		exprFmt(n.Left(), s, nprec)
 		if n.Sym() == nil {
 			fmt.Fprint(s, ".<nil>")
@@ -705,6 +748,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		fmt.Fprintf(s, ".%s", types.SymMethodName(n.Sym()))
 
 	case OXDOT, ODOT, ODOTPTR, ODOTINTER, ODOTMETH:
+		n := n.(*SelectorExpr)
 		exprFmt(n.Left(), s, nprec)
 		if n.Sym() == nil {
 			fmt.Fprint(s, ".<nil>")
@@ -713,6 +757,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		fmt.Fprintf(s, ".%s", types.SymMethodName(n.Sym()))
 
 	case ODOTTYPE, ODOTTYPE2:
+		n := n.(*TypeAssertExpr)
 		exprFmt(n.Left(), s, nprec)
 		if n.Right() != nil {
 			fmt.Fprintf(s, ".(%v)", n.Right())
@@ -721,10 +766,12 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		fmt.Fprintf(s, ".(%v)", n.Type())
 
 	case OINDEX, OINDEXMAP:
+		n := n.(*IndexExpr)
 		exprFmt(n.Left(), s, nprec)
 		fmt.Fprintf(s, "[%v]", n.Right())
 
 	case OSLICE, OSLICESTR, OSLICEARR, OSLICE3, OSLICE3ARR:
+		n := n.(*SliceExpr)
 		exprFmt(n.Left(), s, nprec)
 		fmt.Fprint(s, "[")
 		low, high, max := n.SliceBounds()
@@ -744,17 +791,15 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		fmt.Fprint(s, "]")
 
 	case OSLICEHEADER:
+		n := n.(*SliceHeaderExpr)
 		if n.List().Len() != 2 {
 			base.Fatalf("bad OSLICEHEADER list length %d", n.List().Len())
 		}
 		fmt.Fprintf(s, "sliceheader{%v,%v,%v}", n.Left(), n.List().First(), n.List().Second())
 
 	case OCOMPLEX, OCOPY:
-		if n.Left() != nil {
-			fmt.Fprintf(s, "%v(%v, %v)", n.Op(), n.Left(), n.Right())
-		} else {
-			fmt.Fprintf(s, "%v(%.v)", n.Op(), n.List())
-		}
+		n := n.(*BinaryExpr)
+		fmt.Fprintf(s, "%v(%v, %v)", n.Op(), n.Left(), n.Right())
 
 	case OCONV,
 		OCONVIFACE,
@@ -764,37 +809,34 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		OSTR2BYTES,
 		OSTR2RUNES,
 		ORUNESTR:
+		n := n.(*ConvExpr)
 		if n.Type() == nil || n.Type().Sym() == nil {
 			fmt.Fprintf(s, "(%v)", n.Type())
 		} else {
 			fmt.Fprintf(s, "%v", n.Type())
 		}
-		if n.Left() != nil {
-			fmt.Fprintf(s, "(%v)", n.Left())
-		} else {
-			fmt.Fprintf(s, "(%.v)", n.List())
-		}
+		fmt.Fprintf(s, "(%v)", n.Left())
 
 	case OREAL,
 		OIMAG,
-		OAPPEND,
 		OCAP,
 		OCLOSE,
-		ODELETE,
 		OLEN,
-		OMAKE,
 		ONEW,
 		OPANIC,
-		ORECOVER,
 		OALIGNOF,
 		OOFFSETOF,
-		OSIZEOF,
+		OSIZEOF:
+		n := n.(*UnaryExpr)
+		fmt.Fprintf(s, "%v(%v)", n.Op(), n.Left())
+
+	case OAPPEND,
+		ODELETE,
+		OMAKE,
+		ORECOVER,
 		OPRINT,
 		OPRINTN:
-		if n.Left() != nil {
-			fmt.Fprintf(s, "%v(%v)", n.Op(), n.Left())
-			return
-		}
+		n := n.(*CallExpr)
 		if n.IsDDD() {
 			fmt.Fprintf(s, "%v(%.v...)", n.Op(), n.List())
 			return
@@ -802,6 +844,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		fmt.Fprintf(s, "%v(%.v)", n.Op(), n.List())
 
 	case OCALL, OCALLFUNC, OCALLINTER, OCALLMETH, OGETG:
+		n := n.(*CallExpr)
 		exprFmt(n.Left(), s, nprec)
 		if n.IsDDD() {
 			fmt.Fprintf(s, "(%.v...)", n.List())
@@ -810,10 +853,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		fmt.Fprintf(s, "(%.v)", n.List())
 
 	case OMAKEMAP, OMAKECHAN, OMAKESLICE:
-		if n.List().Len() != 0 { // pre-typecheck
-			fmt.Fprintf(s, "make(%v, %.v)", n.Type(), n.List())
-			return
-		}
+		n := n.(*MakeExpr)
 		if n.Right() != nil {
 			fmt.Fprintf(s, "make(%v, %v, %v)", n.Type(), n.Left(), n.Right())
 			return
@@ -825,20 +865,34 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		fmt.Fprintf(s, "make(%v)", n.Type())
 
 	case OMAKESLICECOPY:
+		n := n.(*MakeExpr)
 		fmt.Fprintf(s, "makeslicecopy(%v, %v, %v)", n.Type(), n.Left(), n.Right())
 
-	case OPLUS, ONEG, OADDR, OBITNOT, ODEREF, ONOT, ORECV:
+	case OPLUS, ONEG, OBITNOT, ONOT, ORECV:
 		// Unary
+		n := n.(*UnaryExpr)
+		fmt.Fprintf(s, "%v", n.Op())
+		if n.Left() != nil && n.Left().Op() == n.Op() {
+			fmt.Fprint(s, " ")
+		}
+		exprFmt(n.Left(), s, nprec+1)
+
+	case OADDR:
+		n := n.(*AddrExpr)
 		fmt.Fprintf(s, "%v", n.Op())
 		if n.Left() != nil && n.Left().Op() == n.Op() {
 			fmt.Fprint(s, " ")
 		}
 		exprFmt(n.Left(), s, nprec+1)
 
+	case ODEREF:
+		n := n.(*StarExpr)
+		fmt.Fprintf(s, "%v", n.Op())
+		exprFmt(n.Left(), s, nprec+1)
+
 		// Binary
 	case OADD,
 		OAND,
-		OANDAND,
 		OANDNOT,
 		ODIV,
 		OEQ,
@@ -851,16 +905,29 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		OMUL,
 		ONE,
 		OOR,
-		OOROR,
 		ORSH,
-		OSEND,
 		OSUB,
 		OXOR:
+		n := n.(*BinaryExpr)
+		exprFmt(n.Left(), s, nprec)
+		fmt.Fprintf(s, " %v ", n.Op())
+		exprFmt(n.Right(), s, nprec+1)
+
+	case OANDAND,
+		OOROR:
+		n := n.(*LogicalExpr)
 		exprFmt(n.Left(), s, nprec)
 		fmt.Fprintf(s, " %v ", n.Op())
 		exprFmt(n.Right(), s, nprec+1)
 
+	case OSEND:
+		n := n.(*SendStmt)
+		exprFmt(n.Left(), s, nprec)
+		fmt.Fprintf(s, " <- ")
+		exprFmt(n.Right(), s, nprec+1)
+
 	case OADDSTR:
+		n := n.(*AddStringExpr)
 		for i, n1 := range n.List().Slice() {
 			if i != 0 {
 				fmt.Fprint(s, " + ")
@@ -951,27 +1018,12 @@ func dumpNodeHeader(w io.Writer, n Node) {
 	if base.Debug.DumpPtrs != 0 {
 		fmt.Fprintf(w, " p(%p)", n)
 	}
-	if n.Name() != nil && n.Name().Vargen != 0 {
-		fmt.Fprintf(w, " g(%d)", n.Name().Vargen)
-	}
 
 	if base.Debug.DumpPtrs != 0 && n.Name() != nil && n.Name().Defn != nil {
 		// Useful to see where Defn is set and what node it points to
 		fmt.Fprintf(w, " defn(%p)", n.Name().Defn)
 	}
 
-	if n.Offset() != types.BADWIDTH {
-		fmt.Fprintf(w, " x(%d)", n.Offset())
-	}
-
-	if n.Class() != 0 {
-		fmt.Fprintf(w, " class(%v)", n.Class())
-	}
-
-	if n.Colas() {
-		fmt.Fprintf(w, " colas(%v)", n.Colas())
-	}
-
 	if EscFmt != nil {
 		if esc := EscFmt(n); esc != "" {
 			fmt.Fprintf(w, " %s", esc)
@@ -982,47 +1034,62 @@ func dumpNodeHeader(w io.Writer, n Node) {
 		fmt.Fprintf(w, " tc(%d)", n.Typecheck())
 	}
 
-	if n.IsDDD() {
-		fmt.Fprintf(w, " isddd(%v)", n.IsDDD())
-	}
-
-	if n.Implicit() {
-		fmt.Fprintf(w, " implicit(%v)", n.Implicit())
-	}
-
-	if n.Op() == ONAME {
-		if n.Name().Addrtaken() {
-			fmt.Fprint(w, " addrtaken")
-		}
-		if n.Name().Assigned() {
-			fmt.Fprint(w, " assigned")
-		}
-		if n.Name().IsClosureVar() {
-			fmt.Fprint(w, " closurevar")
-		}
-		if n.Name().Captured() {
-			fmt.Fprint(w, " captured")
+	// Print Node-specific fields of basic type in header line.
+	v := reflect.ValueOf(n).Elem()
+	t := v.Type()
+	nf := t.NumField()
+	for i := 0; i < nf; i++ {
+		tf := t.Field(i)
+		if tf.PkgPath != "" {
+			// skip unexported field - Interface will fail
+			continue
 		}
-		if n.Name().IsOutputParamHeapAddr() {
-			fmt.Fprint(w, " outputparamheapaddr")
+		k := tf.Type.Kind()
+		if reflect.Bool <= k && k <= reflect.Complex128 {
+			name := strings.TrimSuffix(tf.Name, "_")
+			vf := v.Field(i)
+			vfi := vf.Interface()
+			if name == "Offset" && vfi == types.BADWIDTH || name != "Offset" && isZero(vf) {
+				continue
+			}
+			if vfi == true {
+				fmt.Fprintf(w, " %s", name)
+			} else {
+				fmt.Fprintf(w, " %s:%+v", name, vf.Interface())
+			}
 		}
 	}
-	if n.Bounded() {
-		fmt.Fprint(w, " bounded")
-	}
-	if n.NonNil() {
-		fmt.Fprint(w, " nonnil")
-	}
-
-	if n.HasCall() {
-		fmt.Fprint(w, " hascall")
-	}
 
-	if n.Name() != nil && n.Name().Used() {
-		fmt.Fprint(w, " used")
+	// Print Node-specific booleans by looking for methods.
+	// Different v, t from above - want *Struct not Struct, for methods.
+	v = reflect.ValueOf(n)
+	t = v.Type()
+	nm := t.NumMethod()
+	for i := 0; i < nm; i++ {
+		tm := t.Method(i)
+		if tm.PkgPath != "" {
+			// skip unexported method - call will fail
+			continue
+		}
+		m := v.Method(i)
+		mt := m.Type()
+		if mt.NumIn() == 0 && mt.NumOut() == 1 && mt.Out(0).Kind() == reflect.Bool {
+			// TODO(rsc): Remove the func/defer/recover wrapping,
+			// which is guarding against panics in miniExpr,
+			// once we get down to the simpler state in which
+			// nodes have no getter methods that aren't allowed to be called.
+			func() {
+				defer func() { recover() }()
+				if m.Call(nil)[0].Bool() {
+					name := strings.TrimSuffix(tm.Name, "_")
+					fmt.Fprintf(w, " %s", name)
+				}
+			}()
+		}
 	}
 
 	if n.Op() == OCLOSURE {
+		n := n.(*ClosureExpr)
 		if fn := n.Func(); fn != nil && fn.Nname.Sym() != nil {
 			fmt.Fprintf(w, " fnName(%+v)", fn.Nname.Sym())
 		}
@@ -1087,6 +1154,7 @@ func dumpNode(w io.Writer, n Node, depth int) {
 		return
 
 	case OASOP:
+		n := n.(*AssignOpStmt)
 		fmt.Fprintf(w, "%+v-%+v", n.Op(), n.SubOp())
 		dumpNodeHeader(w, n)
 
@@ -1120,7 +1188,7 @@ func dumpNode(w io.Writer, n Node, depth int) {
 		if fn.Body().Len() > 0 {
 			indent(w, depth)
 			fmt.Fprintf(w, "%+v-body", n.Op())
-			dumpNodes(w, n.Body(), depth+1)
+			dumpNodes(w, fn.Body(), depth+1)
 		}
 		return
 	}
@@ -1186,3 +1254,40 @@ func dumpNodes(w io.Writer, list Nodes, depth int) {
 		dumpNode(w, n, depth)
 	}
 }
+
+// reflect.IsZero is not available in Go 1.4 (added in Go 1.13), so we use this copy instead.
+func isZero(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.Bool:
+		return !v.Bool()
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return v.Int() == 0
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return v.Uint() == 0
+	case reflect.Float32, reflect.Float64:
+		return math.Float64bits(v.Float()) == 0
+	case reflect.Complex64, reflect.Complex128:
+		c := v.Complex()
+		return math.Float64bits(real(c)) == 0 && math.Float64bits(imag(c)) == 0
+	case reflect.Array:
+		for i := 0; i < v.Len(); i++ {
+			if !isZero(v.Index(i)) {
+				return false
+			}
+		}
+		return true
+	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice, reflect.UnsafePointer:
+		return v.IsNil()
+	case reflect.String:
+		return v.Len() == 0
+	case reflect.Struct:
+		for i := 0; i < v.NumField(); i++ {
+			if !isZero(v.Field(i)) {
+				return false
+			}
+		}
+		return true
+	default:
+		return false
+	}
+}
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 7f1a47e13c..96cb0ee054 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -34,13 +34,13 @@ func (*Ident) CanBeNtype() {}
 // Name holds Node fields used only by named nodes (ONAME, OTYPE, some OLITERAL).
 type Name struct {
 	miniExpr
-	subOp      Op    // uint8
-	class      Class // uint8
+	BuiltinOp  Op    // uint8
+	Class_     Class // uint8
 	flags      bitset16
 	pragma     PragmaFlag // int16
 	sym        *types.Sym
 	fn         *Func
-	offset     int64
+	Offset_    int64
 	val        constant.Value
 	orig       Node
 	embedFiles *[]string // list of embedded files, for ONAME var
@@ -180,16 +180,16 @@ func newNameAt(pos src.XPos, op Op, sym *types.Sym) *Name {
 func (n *Name) Name() *Name         { return n }
 func (n *Name) Sym() *types.Sym     { return n.sym }
 func (n *Name) SetSym(x *types.Sym) { n.sym = x }
-func (n *Name) SubOp() Op           { return n.subOp }
-func (n *Name) SetSubOp(x Op)       { n.subOp = x }
-func (n *Name) Class() Class        { return n.class }
-func (n *Name) SetClass(x Class)    { n.class = x }
+func (n *Name) SubOp() Op           { return n.BuiltinOp }
+func (n *Name) SetSubOp(x Op)       { n.BuiltinOp = x }
+func (n *Name) Class() Class        { return n.Class_ }
+func (n *Name) SetClass(x Class)    { n.Class_ = x }
 func (n *Name) Func() *Func         { return n.fn }
 func (n *Name) SetFunc(x *Func)     { n.fn = x }
-func (n *Name) Offset() int64       { return n.offset }
-func (n *Name) SetOffset(x int64)   { n.offset = x }
-func (n *Name) Iota() int64         { return n.offset }
-func (n *Name) SetIota(x int64)     { n.offset = x }
+func (n *Name) Offset() int64       { return n.Offset_ }
+func (n *Name) SetOffset(x int64)   { n.Offset_ = x }
+func (n *Name) Iota() int64         { return n.Offset_ }
+func (n *Name) SetIota(x int64)     { n.Offset_ = x }
 
 func (*Name) CanBeNtype()    {}
 func (*Name) CanBeAnSSASym() {}
diff --git a/test/escape_param.go b/test/escape_param.go
index 993e914e1d..dc93f689cf 100644
--- a/test/escape_param.go
+++ b/test/escape_param.go
@@ -212,7 +212,7 @@ func caller7() {
 
 // **in -> heap
 func param8(i **int) { // ERROR "i does not escape$"
-	sink = **i // ERROR "\* \(\*i\) escapes to heap"
+	sink = **i // ERROR "\*\(\*i\) escapes to heap"
 }
 
 func caller8() {
@@ -402,7 +402,7 @@ func caller13h() {
 	var p *int
 	v := &Val{&p} // ERROR "&Val{...} does not escape$"
 	v.param13(&i)
-	sink = **v.p // ERROR "\* \(\*v\.p\) escapes to heap"
+	sink = **v.p // ERROR "\*\(\*v\.p\) escapes to heap"
 }
 
 type Node struct {
-- 
GitLab


From 114af2a04408d0480bb3e9253bf15aae6b7ed23e Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 11 Dec 2020 21:29:53 -0500
Subject: [PATCH 0241/2400] [dev.regabi] cmd/compile: change Nodes to be a
 slice

The Nodes type originally served two purposes:
(1) It provided a representation optimized for empty slices,
allocating only a single word in that case instead of three,
at the cost of a non-empty slice being four words instead of three.
This was particularly important with the old Node representation,
in which most Nodes were full of unused fields.
(2) It provided a few useful helper methods beyond what can be
done with slices.

The downside of Nodes is that the API is a bit overwhelming,
with many ways to spell ordinary slice operations. For example,
reassigning the first node in the list can be done with:

	ns.Slice()[0] = n
	ns.SetIndex(0, n)
	ns.SetFirst(n)
	*ns.Addr(0) = n

And APIs must decide whether to use Nodes or []ir.Node and
then conversions must be inserted when crossing the boundary.

Now that Node structs are specialized to opcode and most Nodes
lists are actually non-empty, it makes sense to simplify Nodes
to make it actually a slice type, so that ordinary slice operations can
be used, and assignments can automatically convert between
Nodes and []ir.Node.

This CL changes the representation to be a slice and adds a new
Take method, which returns the old slice and clears the receiver.

In a future CL, the Nodes method set will simplify down to:

	Copy
	Take
	Append
	Prepend
	Format

with the current methods being rewritten:

	ns.Len() -> len(ns)
	ns.Slice() -> ns
	ns.First() -> ns[0]
	ns.Second() -> ns[1]
	ns.Index(i) -> ns[i]
	ns.Addr(i) -> &ns[i]
	ns.SetIndex(i, n) -> ns[i] = n
	ns.SetFirst(n) -> ns[0] = n
	ns.SetSecond(n) -> ns[1] = n
	ns.Set1(n) -> ns = []Node{n}
	ns.Set2(n, n2) -> ns = []Node{n, n2}
	ns.Set3(n, n2, n3) -> ns = []Node{n, n2, n3}
	AsNodes(slice) -> Nodes(slice)
	ns.AppendNodes(pns) -> ns.Append(pns.Take()...)
	ns.MoveNodes(pns) -> ns = pns.Take()

and then all those other methods will be deleted.

Simplifying the API down to just those five methods will also make it
more reasonable to introduce more specialized slices like Exprs and Stmts
at some point in the future.

But again this CL just changes the representation to a slice,
introduces Take, and leaves the rest alone.

Passes buildall w/ toolstash -cmp.

Change-Id: I309ab8335c69bb582d811c92c17f938dd6e0c4fe
Reviewed-on: https://go-review.googlesource.com/c/go/+/277916
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/copy.go        |  6 --
 src/cmd/compile/internal/ir/dump.go        | 11 +--
 src/cmd/compile/internal/ir/mini.go        |  8 +-
 src/cmd/compile/internal/ir/node.go        | 91 ++++++++--------------
 src/cmd/compile/internal/ir/sizeof_test.go |  4 +-
 5 files changed, 39 insertions(+), 81 deletions(-)

diff --git a/src/cmd/compile/internal/ir/copy.go b/src/cmd/compile/internal/ir/copy.go
index 7f5d313513..0ab355f767 100644
--- a/src/cmd/compile/internal/ir/copy.go
+++ b/src/cmd/compile/internal/ir/copy.go
@@ -64,12 +64,6 @@ func Copy(n Node) Node {
 	return c
 }
 
-func copyList(x Nodes) Nodes {
-	c := make([]Node, x.Len())
-	copy(c, x.Slice())
-	return AsNodes(c)
-}
-
 // DeepCopy returns a “deep” copy of n, with its entire structure copied
 // (except for shared nodes like ONAME, ONONAME, OLITERAL, and OTYPE).
 // If pos.IsKnown(), it sets the source position of newly allocated Nodes to pos.
diff --git a/src/cmd/compile/internal/ir/dump.go b/src/cmd/compile/internal/ir/dump.go
index bff3a40855..9d6042f78a 100644
--- a/src/cmd/compile/internal/ir/dump.go
+++ b/src/cmd/compile/internal/ir/dump.go
@@ -140,15 +140,8 @@ func (p *dumper) dump(x reflect.Value, depth int) {
 		return
 	}
 
-	// special cases
-	switch v := x.Interface().(type) {
-	case Nodes:
-		// unpack Nodes since reflect cannot look inside
-		// due to the unexported field in its struct
-		x = reflect.ValueOf(v.Slice())
-
-	case src.XPos:
-		p.printf("%s", base.FmtPos(v))
+	if pos, ok := x.Interface().(src.XPos); ok {
+		p.printf("%s", base.FmtPos(pos))
 		return
 	}
 
diff --git a/src/cmd/compile/internal/ir/mini.go b/src/cmd/compile/internal/ir/mini.go
index bf221f75ed..d1d2e266ed 100644
--- a/src/cmd/compile/internal/ir/mini.go
+++ b/src/cmd/compile/internal/ir/mini.go
@@ -114,22 +114,22 @@ func (n *miniNode) SetRight(x Node) {
 	}
 }
 func (n *miniNode) SetInit(x Nodes) {
-	if x != (Nodes{}) {
+	if x != nil {
 		panic(n.no("SetInit"))
 	}
 }
 func (n *miniNode) SetBody(x Nodes) {
-	if x != (Nodes{}) {
+	if x != nil {
 		panic(n.no("SetBody"))
 	}
 }
 func (n *miniNode) SetList(x Nodes) {
-	if x != (Nodes{}) {
+	if x != nil {
 		panic(n.no("SetList"))
 	}
 }
 func (n *miniNode) SetRlist(x Nodes) {
-	if x != (Nodes{}) {
+	if x != nil {
 		panic(n.no("SetRlist"))
 	}
 }
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index dc86b6c683..ccf3671085 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -359,7 +359,7 @@ const (
 // Nodes is a pointer to a slice of *Node.
 // For fields that are not used in most nodes, this is used instead of
 // a slice to save space.
-type Nodes struct{ slice *[]Node }
+type Nodes []Node
 
 // immutableEmptyNodes is an immutable, empty Nodes list.
 // The methods that would modify it panic instead.
@@ -367,43 +367,37 @@ var immutableEmptyNodes = Nodes{}
 
 // asNodes returns a slice of *Node as a Nodes value.
 func AsNodes(s []Node) Nodes {
-	return Nodes{&s}
+	return s
 }
 
 // Slice returns the entries in Nodes as a slice.
 // Changes to the slice entries (as in s[i] = n) will be reflected in
 // the Nodes.
 func (n Nodes) Slice() []Node {
-	if n.slice == nil {
-		return nil
-	}
-	return *n.slice
+	return n
 }
 
 // Len returns the number of entries in Nodes.
 func (n Nodes) Len() int {
-	if n.slice == nil {
-		return 0
-	}
-	return len(*n.slice)
+	return len(n)
 }
 
 // Index returns the i'th element of Nodes.
 // It panics if n does not have at least i+1 elements.
 func (n Nodes) Index(i int) Node {
-	return (*n.slice)[i]
+	return n[i]
 }
 
 // First returns the first element of Nodes (same as n.Index(0)).
 // It panics if n has no elements.
 func (n Nodes) First() Node {
-	return (*n.slice)[0]
+	return n[0]
 }
 
 // Second returns the second element of Nodes (same as n.Index(1)).
 // It panics if n has fewer than two elements.
 func (n Nodes) Second() Node {
-	return (*n.slice)[1]
+	return n[1]
 }
 
 func (n *Nodes) mutate() {
@@ -422,64 +416,56 @@ func (n *Nodes) Set(s []Node) {
 		}
 		n.mutate()
 	}
-	if len(s) == 0 {
-		n.slice = nil
-	} else {
-		// Copy s and take address of t rather than s to avoid
-		// allocation in the case where len(s) == 0 (which is
-		// over 3x more common, dynamically, for make.bash).
-		t := s
-		n.slice = &t
-	}
+	*n = s
 }
 
 // Set1 sets n to a slice containing a single node.
 func (n *Nodes) Set1(n1 Node) {
 	n.mutate()
-	n.slice = &[]Node{n1}
+	*n = []Node{n1}
 }
 
 // Set2 sets n to a slice containing two nodes.
 func (n *Nodes) Set2(n1, n2 Node) {
 	n.mutate()
-	n.slice = &[]Node{n1, n2}
+	*n = []Node{n1, n2}
 }
 
 // Set3 sets n to a slice containing three nodes.
 func (n *Nodes) Set3(n1, n2, n3 Node) {
 	n.mutate()
-	n.slice = &[]Node{n1, n2, n3}
+	*n = []Node{n1, n2, n3}
 }
 
 // MoveNodes sets n to the contents of n2, then clears n2.
 func (n *Nodes) MoveNodes(n2 *Nodes) {
 	n.mutate()
-	n.slice = n2.slice
-	n2.slice = nil
+	*n = *n2
+	*n2 = nil
 }
 
 // SetIndex sets the i'th element of Nodes to node.
 // It panics if n does not have at least i+1 elements.
 func (n Nodes) SetIndex(i int, node Node) {
-	(*n.slice)[i] = node
+	n[i] = node
 }
 
 // SetFirst sets the first element of Nodes to node.
 // It panics if n does not have at least one elements.
 func (n Nodes) SetFirst(node Node) {
-	(*n.slice)[0] = node
+	n[0] = node
 }
 
 // SetSecond sets the second element of Nodes to node.
 // It panics if n does not have at least two elements.
 func (n Nodes) SetSecond(node Node) {
-	(*n.slice)[1] = node
+	n[1] = node
 }
 
 // Addr returns the address of the i'th element of Nodes.
 // It panics if n does not have at least i+1 elements.
 func (n Nodes) Addr(i int) *Node {
-	return &(*n.slice)[i]
+	return &n[i]
 }
 
 // Append appends entries to Nodes.
@@ -488,13 +474,7 @@ func (n *Nodes) Append(a ...Node) {
 		return
 	}
 	n.mutate()
-	if n.slice == nil {
-		s := make([]Node, len(a))
-		copy(s, a)
-		n.slice = &s
-		return
-	}
-	*n.slice = append(*n.slice, a...)
+	*n = append(*n, a...)
 }
 
 // Prepend prepends entries to Nodes.
@@ -504,38 +484,29 @@ func (n *Nodes) Prepend(a ...Node) {
 		return
 	}
 	n.mutate()
-	if n.slice == nil {
-		n.slice = &a
-	} else {
-		*n.slice = append(a, *n.slice...)
-	}
+	*n = append(a, *n...)
+}
+
+// Take clears n, returning its former contents.
+func (n *Nodes) Take() []Node {
+	ret := *n
+	*n = nil
+	return ret
 }
 
 // AppendNodes appends the contents of *n2 to n, then clears n2.
 func (n *Nodes) AppendNodes(n2 *Nodes) {
 	n.mutate()
-	switch {
-	case n2.slice == nil:
-	case n.slice == nil:
-		n.slice = n2.slice
-	default:
-		*n.slice = append(*n.slice, *n2.slice...)
-	}
-	n2.slice = nil
+	*n = append(*n, n2.Take()...)
 }
 
 // Copy returns a copy of the content of the slice.
 func (n Nodes) Copy() Nodes {
-	var c Nodes
-	if n.slice == nil {
-		return c
-	}
-	c.slice = new([]Node)
-	if *n.slice == nil {
-		return c
+	if n == nil {
+		return nil
 	}
-	*c.slice = make([]Node, n.Len())
-	copy(*c.slice, n.Slice())
+	c := make(Nodes, n.Len())
+	copy(c, n)
 	return c
 }
 
diff --git a/src/cmd/compile/internal/ir/sizeof_test.go b/src/cmd/compile/internal/ir/sizeof_test.go
index 181f1462fe..2a618f85ed 100644
--- a/src/cmd/compile/internal/ir/sizeof_test.go
+++ b/src/cmd/compile/internal/ir/sizeof_test.go
@@ -20,8 +20,8 @@ func TestSizeof(t *testing.T) {
 		_32bit uintptr     // size on 32bit platforms
 		_64bit uintptr     // size on 64bit platforms
 	}{
-		{Func{}, 168, 288},
-		{Name{}, 124, 216},
+		{Func{}, 200, 352},
+		{Name{}, 132, 232},
 	}
 
 	for _, tt := range tests {
-- 
GitLab


From 7fde0d2b507b989cb9a23d6dbae9acaa13328c53 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 11 Dec 2020 12:55:14 -0500
Subject: [PATCH 0242/2400] [dev.regabi] cmd/compile: remove use of Initorder,
 Offset Node fields for initorder

The initorder pass is already making heavy use of maps,
and it is concerned with relatively few nodes (only the assignments
in package-level variable declarations). The tracking of init order
for these nodes can be done with another map instead of storing
the bits directly in the Node representations.

This will let us drop Offset_ from AssignStmt and AssignListStmt
and drop Initorder from all nodes.

Passes buildall w/ toolstash -cmp.

Change-Id: I151c64e84670292c2004da4e8e3d0660a88e3df3
Reviewed-on: https://go-review.googlesource.com/c/go/+/277917
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/initorder.go | 43 ++++++++++-----------
 src/cmd/compile/internal/ir/mini.go      | 12 +-----
 src/cmd/compile/internal/ir/node.go      |  2 -
 src/cmd/compile/internal/ir/stmt.go      | 48 ++++++++++--------------
 4 files changed, 44 insertions(+), 61 deletions(-)

diff --git a/src/cmd/compile/internal/gc/initorder.go b/src/cmd/compile/internal/gc/initorder.go
index 7f1f3cba92..d39e8189d7 100644
--- a/src/cmd/compile/internal/gc/initorder.go
+++ b/src/cmd/compile/internal/gc/initorder.go
@@ -11,7 +11,6 @@ import (
 
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
-	"cmd/compile/internal/types"
 )
 
 // Package initialization
@@ -69,6 +68,8 @@ type InitOrder struct {
 	// ready is the queue of Pending initialization assignments
 	// that are ready for initialization.
 	ready declOrder
+
+	order map[ir.Node]int
 }
 
 // initOrder computes initialization order for a list l of
@@ -82,6 +83,7 @@ func initOrder(l []ir.Node) []ir.Node {
 	}
 	o := InitOrder{
 		blocking: make(map[ir.Node][]ir.Node),
+		order:    make(map[ir.Node]int),
 	}
 
 	// Process all package-level assignment in declaration order.
@@ -102,7 +104,7 @@ func initOrder(l []ir.Node) []ir.Node {
 	for _, n := range l {
 		switch n.Op() {
 		case ir.OAS, ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV:
-			if n.Initorder() != InitDone {
+			if o.order[n] != orderDone {
 				// If there have already been errors
 				// printed, those errors may have
 				// confused us and there might not be
@@ -110,7 +112,7 @@ func initOrder(l []ir.Node) []ir.Node {
 				// first.
 				base.ExitIfErrors()
 
-				findInitLoopAndExit(firstLHS(n), new([]*ir.Name))
+				o.findInitLoopAndExit(firstLHS(n), new([]*ir.Name))
 				base.Fatalf("initialization unfinished, but failed to identify loop")
 			}
 		}
@@ -126,12 +128,10 @@ func initOrder(l []ir.Node) []ir.Node {
 }
 
 func (o *InitOrder) processAssign(n ir.Node) {
-	if n.Initorder() != InitNotStarted || n.Offset() != types.BADWIDTH {
-		base.Fatalf("unexpected state: %v, %v, %v", n, n.Initorder(), n.Offset())
+	if _, ok := o.order[n]; ok {
+		base.Fatalf("unexpected state: %v, %v", n, o.order[n])
 	}
-
-	n.SetInitorder(InitPending)
-	n.SetOffset(0)
+	o.order[n] = 0
 
 	// Compute number of variable dependencies and build the
 	// inverse dependency ("blocking") graph.
@@ -139,38 +139,38 @@ func (o *InitOrder) processAssign(n ir.Node) {
 		defn := dep.Defn
 		// Skip dependencies on functions (PFUNC) and
 		// variables already initialized (InitDone).
-		if dep.Class() != ir.PEXTERN || defn.Initorder() == InitDone {
+		if dep.Class() != ir.PEXTERN || o.order[defn] == orderDone {
 			continue
 		}
-		n.SetOffset(n.Offset() + 1)
+		o.order[n]++
 		o.blocking[defn] = append(o.blocking[defn], n)
 	}
 
-	if n.Offset() == 0 {
+	if o.order[n] == 0 {
 		heap.Push(&o.ready, n)
 	}
 }
 
+const orderDone = -1000
+
 // flushReady repeatedly applies initialize to the earliest (in
 // declaration order) assignment ready for initialization and updates
 // the inverse dependency ("blocking") graph.
 func (o *InitOrder) flushReady(initialize func(ir.Node)) {
 	for o.ready.Len() != 0 {
 		n := heap.Pop(&o.ready).(ir.Node)
-		if n.Initorder() != InitPending || n.Offset() != 0 {
-			base.Fatalf("unexpected state: %v, %v, %v", n, n.Initorder(), n.Offset())
+		if order, ok := o.order[n]; !ok || order != 0 {
+			base.Fatalf("unexpected state: %v, %v, %v", n, ok, order)
 		}
 
 		initialize(n)
-		n.SetInitorder(InitDone)
-		n.SetOffset(types.BADWIDTH)
+		o.order[n] = orderDone
 
 		blocked := o.blocking[n]
 		delete(o.blocking, n)
 
 		for _, m := range blocked {
-			m.SetOffset(m.Offset() - 1)
-			if m.Offset() == 0 {
+			if o.order[m]--; o.order[m] == 0 {
 				heap.Push(&o.ready, m)
 			}
 		}
@@ -183,7 +183,7 @@ func (o *InitOrder) flushReady(initialize func(ir.Node)) {
 // path points to a slice used for tracking the sequence of
 // variables/functions visited. Using a pointer to a slice allows the
 // slice capacity to grow and limit reallocations.
-func findInitLoopAndExit(n *ir.Name, path *[]*ir.Name) {
+func (o *InitOrder) findInitLoopAndExit(n *ir.Name, path *[]*ir.Name) {
 	// We implement a simple DFS loop-finding algorithm. This
 	// could be faster, but initialization cycles are rare.
 
@@ -203,11 +203,11 @@ func findInitLoopAndExit(n *ir.Name, path *[]*ir.Name) {
 	*path = append(*path, n)
 	for _, ref := range refers {
 		// Short-circuit variables that were initialized.
-		if ref.Class() == ir.PEXTERN && ref.Defn.Initorder() == InitDone {
+		if ref.Class() == ir.PEXTERN && o.order[ref.Defn] == orderDone {
 			continue
 		}
 
-		findInitLoopAndExit(ref, path)
+		o.findInitLoopAndExit(ref, path)
 	}
 	*path = (*path)[:len(*path)-1]
 }
@@ -282,9 +282,10 @@ func (d *initDeps) visit(n ir.Node) bool {
 		return false
 
 	case ir.ONAME:
+		n := n.(*ir.Name)
 		switch n.Class() {
 		case ir.PEXTERN, ir.PFUNC:
-			d.foundDep(n.(*ir.Name))
+			d.foundDep(n)
 		}
 
 	case ir.OCLOSURE:
diff --git a/src/cmd/compile/internal/ir/mini.go b/src/cmd/compile/internal/ir/mini.go
index d1d2e266ed..7a945c3690 100644
--- a/src/cmd/compile/internal/ir/mini.go
+++ b/src/cmd/compile/internal/ir/mini.go
@@ -61,14 +61,12 @@ func (n *miniNode) SetEsc(x uint16)   { n.esc = x }
 const (
 	miniWalkdefShift   = 0
 	miniTypecheckShift = 2
-	miniInitorderShift = 4
-	miniDiag           = 1 << 6
-	miniHasCall        = 1 << 7 // for miniStmt
+	miniDiag           = 1 << 4
+	miniHasCall        = 1 << 5 // for miniStmt
 )
 
 func (n *miniNode) Walkdef() uint8   { return n.bits.get2(miniWalkdefShift) }
 func (n *miniNode) Typecheck() uint8 { return n.bits.get2(miniTypecheckShift) }
-func (n *miniNode) Initorder() uint8 { return n.bits.get2(miniInitorderShift) }
 func (n *miniNode) SetWalkdef(x uint8) {
 	if x > 3 {
 		panic(fmt.Sprintf("cannot SetWalkdef %d", x))
@@ -81,12 +79,6 @@ func (n *miniNode) SetTypecheck(x uint8) {
 	}
 	n.bits.set2(miniTypecheckShift, x)
 }
-func (n *miniNode) SetInitorder(x uint8) {
-	if x > 3 {
-		panic(fmt.Sprintf("cannot SetInitorder %d", x))
-	}
-	n.bits.set2(miniInitorderShift, x)
-}
 
 func (n *miniNode) Diag() bool     { return n.bits&miniDiag != 0 }
 func (n *miniNode) SetDiag(x bool) { n.bits.set(miniDiag, x) }
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index ccf3671085..0e73731070 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -102,8 +102,6 @@ type Node interface {
 	SetBounded(x bool)
 	Typecheck() uint8
 	SetTypecheck(x uint8)
-	Initorder() uint8
-	SetInitorder(x uint8)
 	NonNil() bool
 	MarkNonNil()
 	HasCall() bool
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index f41c50c92b..b7d0c1adc4 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -63,10 +63,9 @@ func (n *miniStmt) SetHasCall(b bool) { n.bits.set(miniHasCall, b) }
 // If Def is true, the assignment is a :=.
 type AssignListStmt struct {
 	miniStmt
-	Lhs     Nodes
-	Def     bool
-	Rhs     Nodes
-	Offset_ int64 // for initorder
+	Lhs Nodes
+	Def bool
+	Rhs Nodes
 }
 
 func NewAssignListStmt(pos src.XPos, op Op, lhs, rhs []Node) *AssignListStmt {
@@ -75,20 +74,17 @@ func NewAssignListStmt(pos src.XPos, op Op, lhs, rhs []Node) *AssignListStmt {
 	n.SetOp(op)
 	n.Lhs.Set(lhs)
 	n.Rhs.Set(rhs)
-	n.Offset_ = types.BADWIDTH
 	return n
 }
 
-func (n *AssignListStmt) List() Nodes       { return n.Lhs }
-func (n *AssignListStmt) PtrList() *Nodes   { return &n.Lhs }
-func (n *AssignListStmt) SetList(x Nodes)   { n.Lhs = x }
-func (n *AssignListStmt) Rlist() Nodes      { return n.Rhs }
-func (n *AssignListStmt) PtrRlist() *Nodes  { return &n.Rhs }
-func (n *AssignListStmt) SetRlist(x Nodes)  { n.Rhs = x }
-func (n *AssignListStmt) Colas() bool       { return n.Def }
-func (n *AssignListStmt) SetColas(x bool)   { n.Def = x }
-func (n *AssignListStmt) Offset() int64     { return n.Offset_ }
-func (n *AssignListStmt) SetOffset(x int64) { n.Offset_ = x }
+func (n *AssignListStmt) List() Nodes      { return n.Lhs }
+func (n *AssignListStmt) PtrList() *Nodes  { return &n.Lhs }
+func (n *AssignListStmt) SetList(x Nodes)  { n.Lhs = x }
+func (n *AssignListStmt) Rlist() Nodes     { return n.Rhs }
+func (n *AssignListStmt) PtrRlist() *Nodes { return &n.Rhs }
+func (n *AssignListStmt) SetRlist(x Nodes) { n.Rhs = x }
+func (n *AssignListStmt) Colas() bool      { return n.Def }
+func (n *AssignListStmt) SetColas(x bool)  { n.Def = x }
 
 func (n *AssignListStmt) SetOp(op Op) {
 	switch op {
@@ -103,28 +99,24 @@ func (n *AssignListStmt) SetOp(op Op) {
 // If Def is true, the assignment is a :=.
 type AssignStmt struct {
 	miniStmt
-	X       Node
-	Def     bool
-	Y       Node
-	Offset_ int64 // for initorder
+	X   Node
+	Def bool
+	Y   Node
 }
 
 func NewAssignStmt(pos src.XPos, x, y Node) *AssignStmt {
 	n := &AssignStmt{X: x, Y: y}
 	n.pos = pos
 	n.op = OAS
-	n.Offset_ = types.BADWIDTH
 	return n
 }
 
-func (n *AssignStmt) Left() Node        { return n.X }
-func (n *AssignStmt) SetLeft(x Node)    { n.X = x }
-func (n *AssignStmt) Right() Node       { return n.Y }
-func (n *AssignStmt) SetRight(y Node)   { n.Y = y }
-func (n *AssignStmt) Colas() bool       { return n.Def }
-func (n *AssignStmt) SetColas(x bool)   { n.Def = x }
-func (n *AssignStmt) Offset() int64     { return n.Offset_ }
-func (n *AssignStmt) SetOffset(x int64) { n.Offset_ = x }
+func (n *AssignStmt) Left() Node      { return n.X }
+func (n *AssignStmt) SetLeft(x Node)  { n.X = x }
+func (n *AssignStmt) Right() Node     { return n.Y }
+func (n *AssignStmt) SetRight(y Node) { n.Y = y }
+func (n *AssignStmt) Colas() bool     { return n.Def }
+func (n *AssignStmt) SetColas(x bool) { n.Def = x }
 
 func (n *AssignStmt) SetOp(op Op) {
 	switch op {
-- 
GitLab


From f6d2834f8f78447a06fdb05f85a2c5690e915892 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 11 Dec 2020 16:52:21 -0500
Subject: [PATCH 0243/2400] [dev.regabi] cmd/compile: limit Implicit method to
 nodes where it is defined

The general concept of an "implicit" operation is provided by every
expr representation, but it really only makes sense for a few of them,
and worse the exact definition of what "implicit" means differs from
node to node.

This CL moves the method to each node implementation, although
they all share the same header bit instead of each defining a bool field
that would turn into 8 bytes on 64-bit systems.

Now we can say precisely which Nodes have a meaningful Implicit
method: AddrExpr, CompLitExpr, ConvExpr, ParenExpr, and StarExpr.

Passes buildall w/ toolstash -cmp.

Change-Id: I7d85cb0507a514cdcb6eed21347f362e5fb57a91
Reviewed-on: https://go-review.googlesource.com/c/go/+/277918
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/expr.go | 50 +++++++++++++++++------------
 1 file changed, 30 insertions(+), 20 deletions(-)

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 8ea31c1929..36a11dad9a 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -52,10 +52,10 @@ type miniExpr struct {
 
 const (
 	miniExprHasCall = 1 << iota
-	miniExprImplicit
 	miniExprNonNil
 	miniExprTransient
 	miniExprBounded
+	miniExprImplicit // for use by implementations; not supported by every Expr
 )
 
 func (*miniExpr) isExpr() {}
@@ -66,8 +66,6 @@ func (n *miniExpr) Opt() interface{}      { return n.opt }
 func (n *miniExpr) SetOpt(x interface{})  { n.opt = x }
 func (n *miniExpr) HasCall() bool         { return n.flags&miniExprHasCall != 0 }
 func (n *miniExpr) SetHasCall(b bool)     { n.flags.set(miniExprHasCall, b) }
-func (n *miniExpr) Implicit() bool        { return n.flags&miniExprImplicit != 0 }
-func (n *miniExpr) SetImplicit(b bool)    { n.flags.set(miniExprImplicit, b) }
 func (n *miniExpr) NonNil() bool          { return n.flags&miniExprNonNil != 0 }
 func (n *miniExpr) MarkNonNil()           { n.flags |= miniExprNonNil }
 func (n *miniExpr) Transient() bool       { return n.flags&miniExprTransient != 0 }
@@ -121,10 +119,12 @@ func NewAddrExpr(pos src.XPos, x Node) *AddrExpr {
 	return n
 }
 
-func (n *AddrExpr) Left() Node      { return n.X }
-func (n *AddrExpr) SetLeft(x Node)  { n.X = x }
-func (n *AddrExpr) Right() Node     { return n.Alloc }
-func (n *AddrExpr) SetRight(x Node) { n.Alloc = x }
+func (n *AddrExpr) Left() Node         { return n.X }
+func (n *AddrExpr) SetLeft(x Node)     { n.X = x }
+func (n *AddrExpr) Right() Node        { return n.Alloc }
+func (n *AddrExpr) SetRight(x Node)    { n.Alloc = x }
+func (n *AddrExpr) Implicit() bool     { return n.flags&miniExprImplicit != 0 }
+func (n *AddrExpr) SetImplicit(b bool) { n.flags.set(miniExprImplicit, b) }
 
 func (n *AddrExpr) SetOp(op Op) {
 	switch op {
@@ -301,13 +301,15 @@ func NewCompLitExpr(pos src.XPos, op Op, typ Ntype, list []Node) *CompLitExpr {
 	return n
 }
 
-func (n *CompLitExpr) Orig() Node      { return n.orig }
-func (n *CompLitExpr) SetOrig(x Node)  { n.orig = x }
-func (n *CompLitExpr) Right() Node     { return n.Ntype }
-func (n *CompLitExpr) SetRight(x Node) { n.Ntype = toNtype(x) }
-func (n *CompLitExpr) List() Nodes     { return n.List_ }
-func (n *CompLitExpr) PtrList() *Nodes { return &n.List_ }
-func (n *CompLitExpr) SetList(x Nodes) { n.List_ = x }
+func (n *CompLitExpr) Orig() Node         { return n.orig }
+func (n *CompLitExpr) SetOrig(x Node)     { n.orig = x }
+func (n *CompLitExpr) Right() Node        { return n.Ntype }
+func (n *CompLitExpr) SetRight(x Node)    { n.Ntype = toNtype(x) }
+func (n *CompLitExpr) List() Nodes        { return n.List_ }
+func (n *CompLitExpr) PtrList() *Nodes    { return &n.List_ }
+func (n *CompLitExpr) SetList(x Nodes)    { n.List_ = x }
+func (n *CompLitExpr) Implicit() bool     { return n.flags&miniExprImplicit != 0 }
+func (n *CompLitExpr) SetImplicit(b bool) { n.flags.set(miniExprImplicit, b) }
 
 func (n *CompLitExpr) SetOp(op Op) {
 	switch op {
@@ -354,8 +356,10 @@ func NewConvExpr(pos src.XPos, op Op, typ *types.Type, x Node) *ConvExpr {
 	return n
 }
 
-func (n *ConvExpr) Left() Node     { return n.X }
-func (n *ConvExpr) SetLeft(x Node) { n.X = x }
+func (n *ConvExpr) Left() Node         { return n.X }
+func (n *ConvExpr) SetLeft(x Node)     { n.X = x }
+func (n *ConvExpr) Implicit() bool     { return n.flags&miniExprImplicit != 0 }
+func (n *ConvExpr) SetImplicit(b bool) { n.flags.set(miniExprImplicit, b) }
 
 func (n *ConvExpr) SetOp(op Op) {
 	switch op {
@@ -583,8 +587,10 @@ func NewParenExpr(pos src.XPos, x Node) *ParenExpr {
 	return n
 }
 
-func (n *ParenExpr) Left() Node     { return n.X }
-func (n *ParenExpr) SetLeft(x Node) { n.X = x }
+func (n *ParenExpr) Left() Node         { return n.X }
+func (n *ParenExpr) SetLeft(x Node)     { n.X = x }
+func (n *ParenExpr) Implicit() bool     { return n.flags&miniExprImplicit != 0 }
+func (n *ParenExpr) SetImplicit(b bool) { n.flags.set(miniExprImplicit, b) }
 
 func (*ParenExpr) CanBeNtype() {}
 
@@ -645,6 +651,8 @@ func (n *SelectorExpr) Sym() *types.Sym     { return n.Sel }
 func (n *SelectorExpr) SetSym(x *types.Sym) { n.Sel = x }
 func (n *SelectorExpr) Offset() int64       { return n.Offset_ }
 func (n *SelectorExpr) SetOffset(x int64)   { n.Offset_ = x }
+func (n *SelectorExpr) Implicit() bool      { return n.flags&miniExprImplicit != 0 }
+func (n *SelectorExpr) SetImplicit(b bool)  { n.flags.set(miniExprImplicit, b) }
 
 // Before type-checking, bytes.Buffer is a SelectorExpr.
 // After type-checking it becomes a Name.
@@ -783,8 +791,10 @@ func NewStarExpr(pos src.XPos, x Node) *StarExpr {
 	return n
 }
 
-func (n *StarExpr) Left() Node     { return n.X }
-func (n *StarExpr) SetLeft(x Node) { n.X = x }
+func (n *StarExpr) Left() Node         { return n.X }
+func (n *StarExpr) SetLeft(x Node)     { n.X = x }
+func (n *StarExpr) Implicit() bool     { return n.flags&miniExprImplicit != 0 }
+func (n *StarExpr) SetImplicit(b bool) { n.flags.set(miniExprImplicit, b) }
 
 func (*StarExpr) CanBeNtype() {}
 
-- 
GitLab


From f6efa3d4a4a10c28d7bf13f8416022aa5fc4fa1c Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 12 Dec 2020 18:50:21 -0500
Subject: [PATCH 0244/2400] [dev.regabi] cmd/compile: simplify ir.Find, replace
 ir.Inspect with ir.Visit

It seems clear after using these for a week that Find need not return
anything other than a bool saying whether the target was found.
The main reason for not using the boolean earlier was to avoid confusion
with Inspect: for Find, returning true means "it was found! stop walking"
while for Inspect, returning true means "keep walking the children".

But it turns out that none of the uses of Inspect need the boolean.
This makes sense because types can contain expressions, expressions
can contain statements (inside function literals), and so on, so there
are essentially no times when you can say based on the current AST node
that the children are irrelevant to a particular operation.

So this CL makes two changes:

1) Change Find to return a boolean and to take a callback function
returning a boolean. This simplifies all existing calls to Find.

2) Rename Inspect to Visit and change it to take a callback with no
result at all. This simplifies all existing calls to Inspect.

Removing the boolean result from Inspect's callback avoids having
two callbacks with contradictory boolean results in different APIs.
Renaming Inspect to Visit avoids confusion with ast.Inspect.

Passes buildall w/ toolstash -cmp.

Change-Id: I344ebb5e00b6842012be33e779db483c28e5f350
Reviewed-on: https://go-review.googlesource.com/c/go/+/277919
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/alg.go       | 10 ++-
 src/cmd/compile/internal/gc/const.go     |  7 +-
 src/cmd/compile/internal/gc/dcl.go       | 11 ++-
 src/cmd/compile/internal/gc/escape.go    |  4 +-
 src/cmd/compile/internal/gc/initorder.go | 17 +++--
 src/cmd/compile/internal/gc/inl.go       | 28 +++-----
 src/cmd/compile/internal/gc/scc.go       |  3 +-
 src/cmd/compile/internal/gc/walk.go      | 15 ++--
 src/cmd/compile/internal/ir/visit.go     | 90 ++++++++++--------------
 9 files changed, 77 insertions(+), 108 deletions(-)

diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index 8550edb9e0..3938dce46c 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -783,13 +783,11 @@ func geneq(t *types.Type) *obj.LSym {
 }
 
 func hasCall(fn *ir.Func) bool {
-	found := ir.Find(fn, func(n ir.Node) interface{} {
-		if op := n.Op(); op == ir.OCALL || op == ir.OCALLFUNC {
-			return n
-		}
-		return nil
+	return ir.Find(fn, func(n ir.Node) bool {
+		// TODO(rsc): No methods?
+		op := n.Op()
+		return op == ir.OCALL || op == ir.OCALLFUNC
 	})
-	return found != nil
 }
 
 // eqfield returns the node
diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 677ed17dd9..1ef199c793 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -781,7 +781,7 @@ func isGoConst(n ir.Node) bool {
 
 // hasCallOrChan reports whether n contains any calls or channel operations.
 func hasCallOrChan(n ir.Node) bool {
-	found := ir.Find(n, func(n ir.Node) interface{} {
+	return ir.Find(n, func(n ir.Node) bool {
 		switch n.Op() {
 		case ir.OAPPEND,
 			ir.OCALL,
@@ -803,11 +803,10 @@ func hasCallOrChan(n ir.Node) bool {
 			ir.OREAL,
 			ir.ORECOVER,
 			ir.ORECV:
-			return n
+			return true
 		}
-		return nil
+		return false
 	})
-	return found != nil
 }
 
 // A constSet represents a set of Go constant expressions.
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 89873e2fac..ad2dc99f89 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -855,22 +855,22 @@ func newNowritebarrierrecChecker() *nowritebarrierrecChecker {
 			continue
 		}
 		c.curfn = n.(*ir.Func)
-		ir.Inspect(n, c.findExtraCalls)
+		ir.Visit(n, c.findExtraCalls)
 	}
 	c.curfn = nil
 	return c
 }
 
-func (c *nowritebarrierrecChecker) findExtraCalls(n ir.Node) bool {
+func (c *nowritebarrierrecChecker) findExtraCalls(n ir.Node) {
 	if n.Op() != ir.OCALLFUNC {
-		return true
+		return
 	}
 	fn := n.Left()
 	if fn == nil || fn.Op() != ir.ONAME || fn.Class() != ir.PFUNC || fn.Name().Defn == nil {
-		return true
+		return
 	}
 	if !isRuntimePkg(fn.Sym().Pkg) || fn.Sym().Name != "systemstack" {
-		return true
+		return
 	}
 
 	var callee *ir.Func
@@ -887,7 +887,6 @@ func (c *nowritebarrierrecChecker) findExtraCalls(n ir.Node) bool {
 		base.Fatalf("expected ODCLFUNC node, got %+v", callee)
 	}
 	c.extraCalls[c.curfn] = append(c.extraCalls[c.curfn], nowritebarrierrecCall{callee, n.Pos()})
-	return true
 }
 
 // recordCall records a call from ODCLFUNC node "from", to function
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index f317e9999c..5fce118448 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -225,7 +225,7 @@ func (e *Escape) walkFunc(fn *ir.Func) {
 	fn.SetEsc(EscFuncStarted)
 
 	// Identify labels that mark the head of an unstructured loop.
-	ir.InspectList(fn.Body(), func(n ir.Node) bool {
+	ir.Visit(fn, func(n ir.Node) {
 		switch n.Op() {
 		case ir.OLABEL:
 			if e.labels == nil {
@@ -240,8 +240,6 @@ func (e *Escape) walkFunc(fn *ir.Func) {
 				e.labels[n.Sym()] = looping
 			}
 		}
-
-		return true
 	})
 
 	e.curfn = fn
diff --git a/src/cmd/compile/internal/gc/initorder.go b/src/cmd/compile/internal/gc/initorder.go
index d39e8189d7..7870e00221 100644
--- a/src/cmd/compile/internal/gc/initorder.go
+++ b/src/cmd/compile/internal/gc/initorder.go
@@ -268,18 +268,25 @@ func collectDeps(n ir.Node, transitive bool) ir.NameSet {
 type initDeps struct {
 	transitive bool
 	seen       ir.NameSet
+	cvisit     func(ir.Node)
 }
 
-func (d *initDeps) inspect(n ir.Node)      { ir.Inspect(n, d.visit) }
-func (d *initDeps) inspectList(l ir.Nodes) { ir.InspectList(l, d.visit) }
+func (d *initDeps) cachedVisit() func(ir.Node) {
+	if d.cvisit == nil {
+		d.cvisit = d.visit // cache closure
+	}
+	return d.cvisit
+}
+
+func (d *initDeps) inspect(n ir.Node)      { ir.Visit(n, d.cachedVisit()) }
+func (d *initDeps) inspectList(l ir.Nodes) { ir.VisitList(l, d.cachedVisit()) }
 
 // visit calls foundDep on any package-level functions or variables
 // referenced by n, if any.
-func (d *initDeps) visit(n ir.Node) bool {
+func (d *initDeps) visit(n ir.Node) {
 	switch n.Op() {
 	case ir.OMETHEXPR:
 		d.foundDep(methodExprName(n))
-		return false
 
 	case ir.ONAME:
 		n := n.(*ir.Name)
@@ -294,8 +301,6 @@ func (d *initDeps) visit(n ir.Node) bool {
 	case ir.ODOTMETH, ir.OCALLPART:
 		d.foundDep(methodExprName(n))
 	}
-
-	return true
 }
 
 // foundDep records that we've found a dependency on n by adding it to
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 04256d5aeb..9342046dcc 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -255,7 +255,7 @@ func inlFlood(n *ir.Name) {
 	// Recursively identify all referenced functions for
 	// reexport. We want to include even non-called functions,
 	// because after inlining they might be callable.
-	ir.InspectList(ir.AsNodes(fn.Inl.Body), func(n ir.Node) bool {
+	ir.VisitList(ir.AsNodes(fn.Inl.Body), func(n ir.Node) {
 		switch n.Op() {
 		case ir.OMETHEXPR, ir.ODOTMETH:
 			inlFlood(methodExprName(n))
@@ -282,7 +282,6 @@ func inlFlood(n *ir.Name) {
 			//     inlFlood(n.Func.Closure.Func.Nname)
 			base.Fatalf("unexpected closure in inlinable function")
 		}
-		return true
 	})
 }
 
@@ -458,14 +457,10 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 
 func isBigFunc(fn *ir.Func) bool {
 	budget := inlineBigFunctionNodes
-	over := ir.Find(fn, func(n ir.Node) interface{} {
+	return ir.Find(fn, func(n ir.Node) bool {
 		budget--
-		if budget <= 0 {
-			return n
-		}
-		return nil
+		return budget <= 0
 	})
-	return over != nil
 }
 
 // Inlcalls/nodelist/node walks fn's statements and expressions and substitutes any
@@ -707,8 +702,6 @@ FindRHS:
 	return rhs
 }
 
-var errFound = errors.New("found")
-
 // reassigned takes an ONAME node, walks the function in which it is defined, and returns a boolean
 // indicating whether the name has any assignments other than its declaration.
 // The second return value is the first such assignment encountered in the walk, if any. It is mostly
@@ -723,22 +716,21 @@ func reassigned(name *ir.Name) bool {
 	if name.Curfn == nil {
 		return true
 	}
-	a := ir.Find(name.Curfn, func(n ir.Node) interface{} {
+	return ir.Find(name.Curfn, func(n ir.Node) bool {
 		switch n.Op() {
 		case ir.OAS:
 			if n.Left() == name && n != name.Defn {
-				return n
+				return true
 			}
 		case ir.OAS2, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2DOTTYPE:
 			for _, p := range n.List().Slice() {
 				if p == name && n != name.Defn {
-					return n
+					return true
 				}
 			}
 		}
-		return nil
+		return false
 	})
-	return a != nil
 }
 
 func inlParam(t *types.Field, as ir.Node, inlvars map[*ir.Name]ir.Node) ir.Node {
@@ -916,11 +908,10 @@ func mkinlcall(n ir.Node, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]bool,
 	}
 
 	nreturns := 0
-	ir.InspectList(ir.AsNodes(fn.Inl.Body), func(n ir.Node) bool {
+	ir.VisitList(ir.AsNodes(fn.Inl.Body), func(n ir.Node) {
 		if n != nil && n.Op() == ir.ORETURN {
 			nreturns++
 		}
-		return true
 	})
 
 	// We can delay declaring+initializing result parameters if:
@@ -1287,11 +1278,10 @@ func pruneUnusedAutos(ll []*ir.Name, vis *hairyVisitor) []*ir.Name {
 // concrete-type method calls where applicable.
 func devirtualize(fn *ir.Func) {
 	Curfn = fn
-	ir.InspectList(fn.Body(), func(n ir.Node) bool {
+	ir.VisitList(fn.Body(), func(n ir.Node) {
 		if n.Op() == ir.OCALLINTER {
 			devirtualizeCall(n)
 		}
-		return true
 	})
 }
 
diff --git a/src/cmd/compile/internal/gc/scc.go b/src/cmd/compile/internal/gc/scc.go
index 063aaa09bd..fa7af1274b 100644
--- a/src/cmd/compile/internal/gc/scc.go
+++ b/src/cmd/compile/internal/gc/scc.go
@@ -75,7 +75,7 @@ func (v *bottomUpVisitor) visit(n *ir.Func) uint32 {
 	min := v.visitgen
 	v.stack = append(v.stack, n)
 
-	ir.InspectList(n.Body(), func(n ir.Node) bool {
+	ir.Visit(n, func(n ir.Node) {
 		switch n.Op() {
 		case ir.ONAME:
 			if n.Class() == ir.PFUNC {
@@ -111,7 +111,6 @@ func (v *bottomUpVisitor) visit(n *ir.Func) uint32 {
 				min = m
 			}
 		}
-		return true
 	})
 
 	if (min == id || min == id+1) && !n.IsHiddenClosure() {
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index ad5103f851..041eb900c8 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -3764,11 +3764,11 @@ func usefield(n ir.Node) {
 
 // hasSideEffects reports whether n contains any operations that could have observable side effects.
 func hasSideEffects(n ir.Node) bool {
-	found := ir.Find(n, func(n ir.Node) interface{} {
+	return ir.Find(n, func(n ir.Node) bool {
 		switch n.Op() {
 		// Assume side effects unless we know otherwise.
 		default:
-			return n
+			return true
 
 		// No side effects here (arguments are checked separately).
 		case ir.ONAME,
@@ -3824,29 +3824,28 @@ func hasSideEffects(n ir.Node) bool {
 			ir.OREAL,
 			ir.OIMAG,
 			ir.OCOMPLEX:
-			return nil
+			return false
 
 		// Only possible side effect is division by zero.
 		case ir.ODIV, ir.OMOD:
 			if n.Right().Op() != ir.OLITERAL || constant.Sign(n.Right().Val()) == 0 {
-				return n
+				return true
 			}
 
 		// Only possible side effect is panic on invalid size,
 		// but many makechan and makemap use size zero, which is definitely OK.
 		case ir.OMAKECHAN, ir.OMAKEMAP:
 			if !ir.IsConst(n.Left(), constant.Int) || constant.Sign(n.Left().Val()) != 0 {
-				return n
+				return true
 			}
 
 		// Only possible side effect is panic on invalid size.
 		// TODO(rsc): Merge with previous case (probably breaks toolstash -cmp).
 		case ir.OMAKESLICE, ir.OMAKESLICECOPY:
-			return n
+			return true
 		}
-		return nil
+		return false
 	})
-	return found != nil
 }
 
 // Rewrite
diff --git a/src/cmd/compile/internal/ir/visit.go b/src/cmd/compile/internal/ir/visit.go
index 4f3575614d..bc2b8083ba 100644
--- a/src/cmd/compile/internal/ir/visit.go
+++ b/src/cmd/compile/internal/ir/visit.go
@@ -57,46 +57,40 @@ import (
 //	}
 //	do(root)
 //
-// The Inspect function illustrates a further simplification of the pattern,
-// only considering processing before visiting children, and letting
-// that processing decide whether children are visited at all:
+// The Visit function illustrates a further simplification of the pattern,
+// only processing before visiting children and never stopping:
 //
-//	func Inspect(n ir.Node, inspect func(ir.Node) bool) {
+//	func Visit(n ir.Node, visit func(ir.Node)) {
 //		var do func(ir.Node) error
 //		do = func(x ir.Node) error {
-//			if inspect(x) {
-//				ir.DoChildren(x, do)
-//			}
-//			return nil
+//			visit(x)
+//			return ir.DoChildren(x, do)
 //		}
 //		if n != nil {
-//			do(n)
+//			visit(n)
 //		}
 //	}
 //
 // The Find function illustrates a different simplification of the pattern,
 // visiting each node and then its children, recursively, until finding
-// a node x such that find(x) returns a non-nil result,
-// at which point the entire traversal stops:
+// a node x for which find(x) returns true, at which point the entire
+// traversal stops and returns true.
 //
-//	func Find(n ir.Node, find func(ir.Node) interface{}) interface{} {
+//	func Find(n ir.Node, find func(ir.Node)) bool {
 //		stop := errors.New("stop")
-//		var found interface{}
 //		var do func(ir.Node) error
 //		do = func(x ir.Node) error {
-//			if v := find(x); v != nil {
-//				found = v
+//			if find(x) {
 //				return stop
 //			}
 //			return ir.DoChildren(x, do)
 //		}
-//		do(n)
-//		return found
+//		return do(n) == stop
 //	}
 //
-// Inspect and Find are presented above as examples of how to use
+// Visit and Find are presented above as examples of how to use
 // DoChildren effectively, but of course, usage that fits within the
-// simplifications captured by Inspect or Find will be best served
+// simplifications captured by Visit or Find will be best served
 // by directly calling the ones provided by this package.
 func DoChildren(n Node, do func(Node) error) error {
 	if n == nil {
@@ -122,71 +116,59 @@ func DoList(list Nodes, do func(Node) error) error {
 	return nil
 }
 
-// Inspect visits each node x in the IR tree rooted at n
-// in a depth-first preorder traversal, calling inspect on each node visited.
-// If inspect(x) returns false, then Inspect skips over x's children.
-//
-// Note that the meaning of the boolean result in the callback function
-// passed to Inspect differs from that of Scan.
-// During Scan, if scan(x) returns false, then Scan stops the scan.
-// During Inspect, if inspect(x) returns false, then Inspect skips x's children
-// but continues with the remainder of the tree (x's siblings and so on).
-func Inspect(n Node, inspect func(Node) bool) {
+// Visit visits each non-nil node x in the IR tree rooted at n
+// in a depth-first preorder traversal, calling visit on each node visited.
+func Visit(n Node, visit func(Node)) {
 	var do func(Node) error
 	do = func(x Node) error {
-		if inspect(x) {
-			DoChildren(x, do)
-		}
-		return nil
+		visit(x)
+		return DoChildren(x, do)
 	}
 	if n != nil {
 		do(n)
 	}
 }
 
-// InspectList calls Inspect(x, inspect) for each node x in the list.
-func InspectList(list Nodes, inspect func(Node) bool) {
+// VisitList calls Visit(x, visit) for each node x in the list.
+func VisitList(list Nodes, visit func(Node)) {
 	for _, x := range list.Slice() {
-		Inspect(x, inspect)
+		Visit(x, visit)
 	}
 }
 
 var stop = errors.New("stop")
 
 // Find looks for a non-nil node x in the IR tree rooted at n
-// for which find(x) returns a non-nil value.
+// for which find(x) returns true.
 // Find considers nodes in a depth-first, preorder traversal.
-// When Find finds a node x such that find(x) != nil,
-// Find ends the traversal and returns the value of find(x) immediately.
-// Otherwise Find returns nil.
-func Find(n Node, find func(Node) interface{}) interface{} {
+// When Find finds a node x such that find(x) is true,
+// Find ends the traversal and returns true immediately.
+// Otherwise Find returns false after completing the entire traversal.
+func Find(n Node, find func(Node) bool) bool {
 	if n == nil {
-		return nil
+		return false
 	}
-	var found interface{}
 	var do func(Node) error
 	do = func(x Node) error {
-		if v := find(x); v != nil {
-			found = v
+		if find(x) {
 			return stop
 		}
 		return DoChildren(x, do)
 	}
-	do(n)
-	return found
+	return do(n) == stop
 }
 
-// FindList calls Find(x, ok) for each node x in the list, in order.
-// If any call find(x) returns a non-nil result, FindList stops and
+// FindList calls Find(x, find) for each node x in the list, in order.
+// If any call Find(x, find) returns true, FindList stops and
 // returns that result, skipping the remainder of the list.
-// Otherwise FindList returns nil.
-func FindList(list Nodes, find func(Node) interface{}) interface{} {
+// Otherwise FindList returns false.
+func FindList(list Nodes, find func(Node) bool) bool {
 	for _, x := range list.Slice() {
-		if v := Find(x, find); v != nil {
-			return v
+		if Find(x, find) {
+			return true
 		}
 	}
-	return nil
+	return false
 }
 
 // EditChildren edits the child nodes of n, replacing each child x with edit(x).
-- 
GitLab


From 4ac6a6317b0e4ecbcc789ba606708ff08871a1df Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 10 Dec 2020 18:42:42 -0500
Subject: [PATCH 0245/2400] [dev.regabi] cmd/compile: cleanup for concrete
 types - typecheck

An automated rewrite will add concrete type assertions after
a test of n.Op(), when n can be safely type-asserted
(meaning, n is not reassigned a different type, n is not reassigned
and then used outside the scope of the type assertion,
and so on).

This sequence of CLs handles the code that the automated
rewrite does not: adding specific types to function arguments,
adjusting code not to call n.Left() etc when n may have multiple
representations, and so on.

This CL focuses on typecheck.go.

Passes buildall w/ toolstash -cmp.

Change-Id: I32d1d3b813b0a088b1750c9fd28cd858ed813f1d
Reviewed-on: https://go-review.googlesource.com/c/go/+/277920
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/typecheck.go | 388 +++++++++++++++--------
 1 file changed, 248 insertions(+), 140 deletions(-)

diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 6dc9c5820d..ef1955e88b 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -250,7 +250,7 @@ func typecheck(n ir.Node, top int) (res ir.Node) {
 
 	// Skip over parens.
 	for n.Op() == ir.OPAREN {
-		n = n.Left()
+		n = n.(*ir.ParenExpr).Left()
 	}
 
 	// Resolve definition of name and value of iota lazily.
@@ -439,10 +439,12 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			return n
 		}
 
-		if n.Op() == ir.ONAME && n.SubOp() != 0 && top&ctxCallee == 0 {
-			base.Errorf("use of builtin %v not in function call", n.Sym())
-			n.SetType(nil)
-			return n
+		if n.Op() == ir.ONAME {
+			if n.SubOp() != 0 && top&ctxCallee == 0 {
+				base.Errorf("use of builtin %v not in function call", n.Sym())
+				n.SetType(nil)
+				return n
+			}
 		}
 
 		typecheckdef(n)
@@ -651,19 +653,29 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		ir.OOROR,
 		ir.OSUB,
 		ir.OXOR:
-		var l ir.Node
-		var op ir.Op
-		var r ir.Node
+		var l, r ir.Node
+		var setLR func()
+		switch n := n.(type) {
+		case *ir.AssignOpStmt:
+			l, r = n.Left(), n.Right()
+			setLR = func() { n.SetLeft(l); n.SetRight(r) }
+		case *ir.BinaryExpr:
+			l, r = n.Left(), n.Right()
+			setLR = func() { n.SetLeft(l); n.SetRight(r) }
+		case *ir.LogicalExpr:
+			l, r = n.Left(), n.Right()
+			setLR = func() { n.SetLeft(l); n.SetRight(r) }
+		}
+		l = typecheck(l, ctxExpr)
+		r = typecheck(r, ctxExpr)
+		setLR()
+		if l.Type() == nil || r.Type() == nil {
+			n.SetType(nil)
+			return n
+		}
+		op := n.Op()
 		if n.Op() == ir.OASOP {
-			n.SetLeft(typecheck(n.Left(), ctxExpr))
-			n.SetRight(typecheck(n.Right(), ctxExpr))
-			l = n.Left()
-			r = n.Right()
-			checkassign(n, n.Left())
-			if l.Type() == nil || r.Type() == nil {
-				n.SetType(nil)
-				return n
-			}
+			checkassign(n, l)
 			if n.Implicit() && !okforarith[l.Type().Kind()] {
 				base.Errorf("invalid operation: %v (non-numeric type %v)", n, l.Type())
 				n.SetType(nil)
@@ -671,20 +683,10 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			}
 			// TODO(marvin): Fix Node.EType type union.
 			op = n.SubOp()
-		} else {
-			n.SetLeft(typecheck(n.Left(), ctxExpr))
-			n.SetRight(typecheck(n.Right(), ctxExpr))
-			l = n.Left()
-			r = n.Right()
-			if l.Type() == nil || r.Type() == nil {
-				n.SetType(nil)
-				return n
-			}
-			op = n.Op()
 		}
 		if op == ir.OLSH || op == ir.ORSH {
 			r = defaultlit(r, types.Types[types.TUINT])
-			n.SetRight(r)
+			setLR()
 			t := r.Type()
 			if !t.IsInteger() {
 				base.Errorf("invalid operation: %v (shift count type %v, must be integer)", n, r.Type())
@@ -730,9 +732,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 		// ideal mixed with non-ideal
 		l, r = defaultlit2(l, r, false)
+		setLR()
 
-		n.SetLeft(l)
-		n.SetRight(r)
 		if l.Type() == nil || r.Type() == nil {
 			n.SetType(nil)
 			return n
@@ -768,7 +769,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 					if r.Type().IsInterface() == l.Type().IsInterface() || l.Type().Width >= 1<<16 {
 						l = ir.NewConvExpr(base.Pos, aop, r.Type(), l)
 						l.SetTypecheck(1)
-						n.SetLeft(l)
+						setLR()
 					}
 
 					t = r.Type()
@@ -789,7 +790,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 					if r.Type().IsInterface() == l.Type().IsInterface() || r.Type().Width >= 1<<16 {
 						r = ir.NewConvExpr(base.Pos, aop, l.Type(), r)
 						r.SetTypecheck(1)
-						n.SetRight(r)
+						setLR()
 					}
 
 					t = l.Type()
@@ -858,29 +859,30 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		if iscmp[n.Op()] {
 			t = types.UntypedBool
 			n.SetType(t)
-			n = evalConst(n)
-			if n.Op() != ir.OLITERAL {
-				l, r = defaultlit2(l, r, true)
-				n.SetLeft(l)
-				n.SetRight(r)
+			if con := evalConst(n); con.Op() == ir.OLITERAL {
+				return con
 			}
+			l, r = defaultlit2(l, r, true)
+			setLR()
+			return n
 		}
 
 		if et == types.TSTRING && n.Op() == ir.OADD {
 			// create or update OADDSTR node with list of strings in x + y + z + (w + v) + ...
+			var add *ir.AddStringExpr
 			if l.Op() == ir.OADDSTR {
-				orig := n
-				n = l
-				n.SetPos(orig.Pos())
+				add = l.(*ir.AddStringExpr)
+				add.SetPos(n.Pos())
 			} else {
-				n = ir.NodAt(n.Pos(), ir.OADDSTR, nil, nil)
-				n.PtrList().Set1(l)
+				add = ir.NewAddStringExpr(n.Pos(), []ir.Node{l})
 			}
 			if r.Op() == ir.OADDSTR {
-				n.PtrList().AppendNodes(r.PtrList())
+				add.PtrList().AppendNodes(r.PtrList())
 			} else {
-				n.PtrList().Append(r)
+				add.PtrList().Append(r)
 			}
+			add.SetType(t)
+			return add
 		}
 
 		if (op == ir.ODIV || op == ir.OMOD) && ir.IsConst(r, constant.Int) {
@@ -950,11 +952,12 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OCOMPLIT:
-		return typecheckcomplit(n)
+		return typecheckcomplit(n.(*ir.CompLitExpr))
 
 	case ir.OXDOT, ir.ODOT:
+		n := n.(*ir.SelectorExpr)
 		if n.Op() == ir.OXDOT {
-			n = adddot(n)
+			n = adddot(n).(*ir.SelectorExpr)
 			n.SetOp(ir.ODOT)
 			if n.Left() == nil {
 				n.SetType(nil)
@@ -1021,7 +1024,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 
 		if (n.Op() == ir.ODOTINTER || n.Op() == ir.ODOTMETH) && top&ctxCallee == 0 {
-			n = typecheckpartialcall(n, s)
+			return typecheckpartialcall(n, s)
 		}
 		return n
 
@@ -1286,9 +1289,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				return n
 			}
 
-			n.SetLeft(nodAddr(n.Left()))
-			n.Left().SetImplicit(true)
-			n.SetLeft(typecheck(n.Left(), ctxExpr))
+			addr := nodAddr(n.Left())
+			addr.SetImplicit(true)
+			n.SetLeft(typecheck(addr, ctxExpr))
 			l = n.Left()
 		}
 		t := l.Type()
@@ -1338,9 +1341,10 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	// call and call like
 	case ir.OCALL:
-		n.(*ir.CallExpr).Use = ir.CallUseExpr
+		n := n.(*ir.CallExpr)
+		n.Use = ir.CallUseExpr
 		if top == ctxStmt {
-			n.(*ir.CallExpr).Use = ir.CallUseStmt
+			n.Use = ir.CallUseStmt
 		}
 		typecheckslice(n.Init().Slice(), ctxStmt) // imported rewritten f(g()) calls (#30907)
 		n.SetLeft(typecheck(n.Left(), ctxExpr|ctxType|ctxCallee))
@@ -1350,7 +1354,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 		l := n.Left()
 
-		if l.Op() == ir.ONAME && l.SubOp() != 0 {
+		if l.Op() == ir.ONAME && l.(*ir.Name).SubOp() != 0 {
 			if n.IsDDD() && l.SubOp() != ir.OAPPEND {
 				base.Errorf("invalid use of ... with builtin %v", l)
 			}
@@ -1408,7 +1412,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				return n
 			}
 
-			n = ir.NodAt(n.Pos(), ir.OCONV, arg, nil)
+			n := ir.NodAt(n.Pos(), ir.OCONV, arg, nil)
 			n.SetType(l.Type())
 			return typecheck1(n, top)
 		}
@@ -1463,14 +1467,16 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		if t.NumResults() == 1 {
 			n.SetType(l.Type().Results().Field(0).Type)
 
-			if n.Op() == ir.OCALLFUNC && n.Left().Op() == ir.ONAME && isRuntimePkg(n.Left().Sym().Pkg) && n.Left().Sym().Name == "getg" {
-				// Emit code for runtime.getg() directly instead of calling function.
-				// Most such rewrites (for example the similar one for math.Sqrt) should be done in walk,
-				// so that the ordering pass can make sure to preserve the semantics of the original code
-				// (in particular, the exact time of the function call) by introducing temporaries.
-				// In this case, we know getg() always returns the same result within a given function
-				// and we want to avoid the temporaries, so we do the rewrite earlier than is typical.
-				n.SetOp(ir.OGETG)
+			if n.Op() == ir.OCALLFUNC && n.Left().Op() == ir.ONAME {
+				if sym := n.Left().(*ir.Name).Sym(); isRuntimePkg(sym.Pkg) && sym.Name == "getg" {
+					// Emit code for runtime.getg() directly instead of calling function.
+					// Most such rewrites (for example the similar one for math.Sqrt) should be done in walk,
+					// so that the ordering pass can make sure to preserve the semantics of the original code
+					// (in particular, the exact time of the function call) by introducing temporaries.
+					// In this case, we know getg() always returns the same result within a given function
+					// and we want to avoid the temporaries, so we do the rewrite earlier than is typical.
+					n.SetOp(ir.OGETG)
+				}
 			}
 			return n
 		}
@@ -1733,6 +1739,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OCONV:
+		n := n.(*ir.ConvExpr)
 		checkwidth(n.Type()) // ensure width is calculated for backend
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetLeft(convlit1(n.Left(), n.Type(), true, nil))
@@ -1771,7 +1778,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 		case ir.OSTR2RUNES:
 			if n.Left().Op() == ir.OLITERAL {
-				n = stringtoruneslit(n)
+				return stringtoruneslit(n)
 			}
 		}
 		return n
@@ -1881,8 +1888,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 
 		nn.SetType(t)
-		n = nn
-		return n
+		return nn
 
 	case ir.ONEW:
 		if n.Left() == nil {
@@ -1990,6 +1996,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	// statements
 	case ir.OAS:
+		n := n.(*ir.AssignStmt)
 		typecheckas(n)
 
 		// Code that creates temps does not bother to set defn, so do it here.
@@ -1999,7 +2006,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OAS2:
-		typecheckas2(n)
+		typecheckas2(n.(*ir.AssignListStmt))
 		return n
 
 	case ir.OBREAK,
@@ -2026,6 +2033,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.ODEFER, ir.OGO:
+		n := n.(*ir.GoDeferStmt)
 		n.SetLeft(typecheck(n.Left(), ctxStmt|ctxExpr))
 		if !n.Left().Diag() {
 			checkdefergo(n)
@@ -2083,15 +2091,15 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OSELECT:
-		typecheckselect(n)
+		typecheckselect(n.(*ir.SelectStmt))
 		return n
 
 	case ir.OSWITCH:
-		typecheckswitch(n)
+		typecheckswitch(n.(*ir.SwitchStmt))
 		return n
 
 	case ir.ORANGE:
-		typecheckrange(n)
+		typecheckrange(n.(*ir.RangeStmt))
 		return n
 
 	case ir.OTYPESW:
@@ -2119,13 +2127,26 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 }
 
 func typecheckargs(n ir.Node) {
-	if n.List().Len() != 1 || n.IsDDD() {
-		typecheckslice(n.List().Slice(), ctxExpr)
+	var list []ir.Node
+	switch n := n.(type) {
+	default:
+		base.Fatalf("typecheckargs %+v", n.Op())
+	case *ir.CallExpr:
+		list = n.List().Slice()
+		if n.IsDDD() {
+			typecheckslice(list, ctxExpr)
+			return
+		}
+	case *ir.ReturnStmt:
+		list = n.List().Slice()
+	}
+	if len(list) != 1 {
+		typecheckslice(list, ctxExpr)
 		return
 	}
 
-	typecheckslice(n.List().Slice(), ctxExpr|ctxMultiOK)
-	t := n.List().First().Type()
+	typecheckslice(list, ctxExpr|ctxMultiOK)
+	t := list[0].Type()
 	if t == nil || !t.IsFuncArgStruct() {
 		return
 	}
@@ -2138,7 +2159,7 @@ func typecheckargs(n ir.Node) {
 	}
 
 	as := ir.Nod(ir.OAS2, nil, nil)
-	as.PtrRlist().AppendNodes(n.PtrList())
+	as.PtrRlist().Append(list...)
 
 	// If we're outside of function context, then this call will
 	// be executed during the generated init function. However,
@@ -2149,16 +2170,24 @@ func typecheckargs(n ir.Node) {
 	if static {
 		Curfn = initTodo
 	}
+	list = nil
 	for _, f := range t.FieldSlice() {
 		t := temp(f.Type)
 		as.PtrInit().Append(ir.Nod(ir.ODCL, t, nil))
 		as.PtrList().Append(t)
-		n.PtrList().Append(t)
+		list = append(list, t)
 	}
 	if static {
 		Curfn = nil
 	}
 
+	switch n := n.(type) {
+	case *ir.CallExpr:
+		n.PtrList().Set(list)
+	case *ir.ReturnStmt:
+		n.PtrList().Set(list)
+	}
+
 	n.PtrInit().Append(typecheck(as, ctxStmt))
 }
 
@@ -2201,7 +2230,7 @@ func checksliceconst(lo ir.Node, hi ir.Node) bool {
 	return true
 }
 
-func checkdefergo(n ir.Node) {
+func checkdefergo(n *ir.GoDeferStmt) {
 	what := "defer"
 	if n.Op() == ir.OGO {
 		what = "go"
@@ -2269,13 +2298,12 @@ func implicitstar(n ir.Node) ir.Node {
 	if !t.IsArray() {
 		return n
 	}
-	n = ir.Nod(ir.ODEREF, n, nil)
-	n.SetImplicit(true)
-	n = typecheck(n, ctxExpr)
-	return n
+	star := ir.Nod(ir.ODEREF, n, nil)
+	star.SetImplicit(true)
+	return typecheck(star, ctxExpr)
 }
 
-func needOneArg(n ir.Node, f string, args ...interface{}) (ir.Node, bool) {
+func needOneArg(n *ir.CallExpr, f string, args ...interface{}) (ir.Node, bool) {
 	if n.List().Len() == 0 {
 		p := fmt.Sprintf(f, args...)
 		base.Errorf("missing argument to %s: %v", p, n)
@@ -2291,7 +2319,7 @@ func needOneArg(n ir.Node, f string, args ...interface{}) (ir.Node, bool) {
 	return n.List().First(), true
 }
 
-func needTwoArgs(n ir.Node) (ir.Node, ir.Node, bool) {
+func needTwoArgs(n *ir.CallExpr) (ir.Node, ir.Node, bool) {
 	if n.List().Len() != 2 {
 		if n.List().Len() < 2 {
 			base.Errorf("not enough arguments in call to %v", n)
@@ -2334,7 +2362,7 @@ func lookdot1(errnode ir.Node, s *types.Sym, t *types.Type, fs *types.Fields, do
 
 // typecheckMethodExpr checks selector expressions (ODOT) where the
 // base expression is a type expression (OTYPE).
-func typecheckMethodExpr(n ir.Node) (res ir.Node) {
+func typecheckMethodExpr(n *ir.SelectorExpr) (res ir.Node) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckMethodExpr", n)(&res)
 	}
@@ -2417,7 +2445,7 @@ func derefall(t *types.Type) *types.Type {
 	return t
 }
 
-func lookdot(n ir.Node, t *types.Type, dostrcmp int) *types.Field {
+func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 	s := n.Sym()
 
 	dowidth(t)
@@ -2449,14 +2477,14 @@ func lookdot(n ir.Node, t *types.Type, dostrcmp int) *types.Field {
 		n.SetType(f1.Type)
 		if t.IsInterface() {
 			if n.Left().Type().IsPtr() {
-				n.SetLeft(ir.Nod(ir.ODEREF, n.Left(), nil)) // implicitstar
-				n.Left().SetImplicit(true)
-				n.SetLeft(typecheck(n.Left(), ctxExpr))
+				star := ir.Nod(ir.ODEREF, n.Left(), nil)
+				star.SetImplicit(true)
+				n.SetLeft(typecheck(star, ctxExpr))
 			}
 
 			n.SetOp(ir.ODOTINTER)
 		}
-		n.(*ir.SelectorExpr).Selection = f1
+		n.Selection = f1
 		return f1
 	}
 
@@ -2471,13 +2499,13 @@ func lookdot(n ir.Node, t *types.Type, dostrcmp int) *types.Field {
 		if !types.Identical(rcvr, tt) {
 			if rcvr.IsPtr() && types.Identical(rcvr.Elem(), tt) {
 				checklvalue(n.Left(), "call pointer method on")
-				n.SetLeft(nodAddr(n.Left()))
-				n.Left().SetImplicit(true)
-				n.SetLeft(typecheck(n.Left(), ctxType|ctxExpr))
+				addr := nodAddr(n.Left())
+				addr.SetImplicit(true)
+				n.SetLeft(typecheck(addr, ctxType|ctxExpr))
 			} else if tt.IsPtr() && (!rcvr.IsPtr() || rcvr.IsPtr() && rcvr.Elem().NotInHeap()) && types.Identical(tt.Elem(), rcvr) {
-				n.SetLeft(ir.Nod(ir.ODEREF, n.Left(), nil))
-				n.Left().SetImplicit(true)
-				n.SetLeft(typecheck(n.Left(), ctxType|ctxExpr))
+				star := ir.Nod(ir.ODEREF, n.Left(), nil)
+				star.SetImplicit(true)
+				n.SetLeft(typecheck(star, ctxType|ctxExpr))
 			} else if tt.IsPtr() && tt.Elem().IsPtr() && types.Identical(derefall(tt), derefall(rcvr)) {
 				base.Errorf("calling method %v with receiver %L requires explicit dereference", n.Sym(), n.Left())
 				for tt.IsPtr() {
@@ -2485,9 +2513,9 @@ func lookdot(n ir.Node, t *types.Type, dostrcmp int) *types.Field {
 					if rcvr.IsPtr() && !tt.Elem().IsPtr() {
 						break
 					}
-					n.SetLeft(ir.Nod(ir.ODEREF, n.Left(), nil))
-					n.Left().SetImplicit(true)
-					n.SetLeft(typecheck(n.Left(), ctxType|ctxExpr))
+					star := ir.Nod(ir.ODEREF, n.Left(), nil)
+					star.SetImplicit(true)
+					n.SetLeft(typecheck(star, ctxType|ctxExpr))
 					tt = tt.Elem()
 				}
 			} else {
@@ -2495,13 +2523,16 @@ func lookdot(n ir.Node, t *types.Type, dostrcmp int) *types.Field {
 			}
 		}
 
-		pll := n
-		ll := n.Left()
-		for ll.Left() != nil && (ll.Op() == ir.ODOT || ll.Op() == ir.ODOTPTR || ll.Op() == ir.ODEREF) {
-			pll = ll
-			ll = ll.Left()
+		implicit, ll := n.Implicit(), n.Left()
+		for ll != nil && (ll.Op() == ir.ODOT || ll.Op() == ir.ODOTPTR || ll.Op() == ir.ODEREF) {
+			switch l := ll.(type) {
+			case *ir.SelectorExpr:
+				implicit, ll = l.Implicit(), l.Left()
+			case *ir.StarExpr:
+				implicit, ll = l.Implicit(), l.Left()
+			}
 		}
-		if pll.Implicit() && ll.Type().IsPtr() && ll.Type().Sym() != nil && ll.Type().Sym().Def != nil && ir.AsNode(ll.Type().Sym().Def).Op() == ir.OTYPE {
+		if implicit && ll.Type().IsPtr() && ll.Type().Sym() != nil && ll.Type().Sym().Def != nil && ir.AsNode(ll.Type().Sym().Def).Op() == ir.OTYPE {
 			// It is invalid to automatically dereference a named pointer type when selecting a method.
 			// Make n.Left == ll to clarify error message.
 			n.SetLeft(ll)
@@ -2512,7 +2543,7 @@ func lookdot(n ir.Node, t *types.Type, dostrcmp int) *types.Field {
 		n.SetOffset(f2.Offset)
 		n.SetType(f2.Type)
 		n.SetOp(ir.ODOTMETH)
-		n.(*ir.SelectorExpr).Selection = f2
+		n.Selection = f2
 
 		return f2
 	}
@@ -2742,8 +2773,12 @@ func iscomptype(t *types.Type) bool {
 
 // pushtype adds elided type information for composite literals if
 // appropriate, and returns the resulting expression.
-func pushtype(n ir.Node, t *types.Type) ir.Node {
-	if n == nil || n.Op() != ir.OCOMPLIT || n.Right() != nil {
+func pushtype(nn ir.Node, t *types.Type) ir.Node {
+	if nn == nil || nn.Op() != ir.OCOMPLIT {
+		return nn
+	}
+	n := nn.(*ir.CompLitExpr)
+	if n.Right() != nil {
 		return n
 	}
 
@@ -2756,16 +2791,16 @@ func pushtype(n ir.Node, t *types.Type) ir.Node {
 		// For *T, return &T{...}.
 		n.SetRight(ir.TypeNode(t.Elem()))
 
-		n = nodAddrAt(n.Pos(), n)
-		n.SetImplicit(true)
+		addr := ir.NodAt(n.Pos(), ir.OADDR, n, nil)
+		addr.SetImplicit(true)
+		return addr
 	}
-
 	return n
 }
 
 // The result of typecheckcomplit MUST be assigned back to n, e.g.
 // 	n.Left = typecheckcomplit(n.Left)
-func typecheckcomplit(n ir.Node) (res ir.Node) {
+func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckcomplit", n)(&res)
 	}
@@ -2782,7 +2817,7 @@ func typecheckcomplit(n ir.Node) (res ir.Node) {
 	}
 
 	// Save original node (including n.Right)
-	n.(ir.OrigNode).SetOrig(ir.Copy(n))
+	n.SetOrig(ir.Copy(n))
 
 	setlineno(n.Right())
 
@@ -2833,6 +2868,7 @@ func typecheckcomplit(n ir.Node) (res ir.Node) {
 				base.Errorf("missing key in map literal")
 				continue
 			}
+			l := l.(*ir.KeyExpr)
 
 			r := l.Left()
 			r = pushtype(r, t.Key())
@@ -2876,9 +2912,9 @@ func typecheckcomplit(n ir.Node) (res ir.Node) {
 				}
 				// No pushtype allowed here. Must name fields for that.
 				n1 = assignconv(n1, f.Type, "field value")
-				n1 = nodSym(ir.OSTRUCTKEY, n1, f.Sym)
-				n1.SetOffset(f.Offset)
-				ls[i] = n1
+				sk := nodSym(ir.OSTRUCTKEY, n1, f.Sym)
+				sk.SetOffset(f.Offset)
+				ls[i] = sk
 			}
 			if len(ls) < t.NumFields() {
 				base.Errorf("too few values in %v", n)
@@ -2892,7 +2928,8 @@ func typecheckcomplit(n ir.Node) (res ir.Node) {
 				setlineno(l)
 
 				if l.Op() == ir.OKEY {
-					key := l.Left()
+					kv := l.(*ir.KeyExpr)
+					key := kv.Left()
 
 					// Sym might have resolved to name in other top-level
 					// package, because of import dot. Redirect to correct sym
@@ -2911,7 +2948,7 @@ func typecheckcomplit(n ir.Node) (res ir.Node) {
 						continue
 					}
 
-					l = ir.NewStructKeyExpr(l.Pos(), s, l.Right())
+					l = ir.NewStructKeyExpr(l.Pos(), s, kv.Right())
 					ls[i] = l
 				}
 
@@ -2923,6 +2960,7 @@ func typecheckcomplit(n ir.Node) (res ir.Node) {
 					ls[i] = typecheck(ls[i], ctxExpr)
 					continue
 				}
+				l := l.(*ir.StructKeyExpr)
 
 				f := lookdot1(nil, l.Sym(), t, t.Fields(), 0)
 				if f == nil {
@@ -2983,8 +3021,9 @@ func typecheckarraylit(elemType *types.Type, bound int64, elts []ir.Node, ctx st
 	for i, elt := range elts {
 		setlineno(elt)
 		r := elts[i]
-		var kv ir.Node
+		var kv *ir.KeyExpr
 		if elt.Op() == ir.OKEY {
+			elt := elt.(*ir.KeyExpr)
 			elt.SetLeft(typecheck(elt.Left(), ctxExpr))
 			key = indexconst(elt.Left())
 			if key < 0 {
@@ -3104,9 +3143,9 @@ func checkassign(stmt ir.Node, n ir.Node) {
 	}
 
 	switch {
-	case n.Op() == ir.ODOT && n.Left().Op() == ir.OINDEXMAP:
+	case n.Op() == ir.ODOT && n.(*ir.SelectorExpr).Left().Op() == ir.OINDEXMAP:
 		base.Errorf("cannot assign to struct field %v in map", n)
-	case (n.Op() == ir.OINDEX && n.Left().Type().IsString()) || n.Op() == ir.OSLICESTR:
+	case (n.Op() == ir.OINDEX && n.(*ir.IndexExpr).Left().Type().IsString()) || n.Op() == ir.OSLICESTR:
 		base.Errorf("cannot assign to %v (strings are immutable)", n)
 	case n.Op() == ir.OLITERAL && n.Sym() != nil && isGoConst(n):
 		base.Errorf("cannot assign to %v (declared const)", n)
@@ -3147,19 +3186,40 @@ func samesafeexpr(l ir.Node, r ir.Node) bool {
 		return l == r
 
 	case ir.ODOT, ir.ODOTPTR:
+		l := l.(*ir.SelectorExpr)
+		r := r.(*ir.SelectorExpr)
 		return l.Sym() != nil && r.Sym() != nil && l.Sym() == r.Sym() && samesafeexpr(l.Left(), r.Left())
 
-	case ir.ODEREF, ir.OCONVNOP,
-		ir.ONOT, ir.OBITNOT, ir.OPLUS, ir.ONEG:
+	case ir.ODEREF:
+		l := l.(*ir.StarExpr)
+		r := r.(*ir.StarExpr)
+		return samesafeexpr(l.Left(), r.Left())
+
+	case ir.ONOT, ir.OBITNOT, ir.OPLUS, ir.ONEG:
+		l := l.(*ir.UnaryExpr)
+		r := r.(*ir.UnaryExpr)
+		return samesafeexpr(l.Left(), r.Left())
+
+	case ir.OCONVNOP:
+		l := l.(*ir.ConvExpr)
+		r := r.(*ir.ConvExpr)
 		return samesafeexpr(l.Left(), r.Left())
 
 	case ir.OCONV:
+		l := l.(*ir.ConvExpr)
+		r := r.(*ir.ConvExpr)
 		// Some conversions can't be reused, such as []byte(str).
 		// Allow only numeric-ish types. This is a bit conservative.
 		return issimple[l.Type().Kind()] && samesafeexpr(l.Left(), r.Left())
 
-	case ir.OINDEX, ir.OINDEXMAP,
-		ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.OLSH, ir.ORSH, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OMOD:
+	case ir.OINDEX, ir.OINDEXMAP:
+		l := l.(*ir.IndexExpr)
+		r := r.(*ir.IndexExpr)
+		return samesafeexpr(l.Left(), r.Left()) && samesafeexpr(l.Right(), r.Right())
+
+	case ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.OLSH, ir.ORSH, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OMOD:
+		l := l.(*ir.BinaryExpr)
+		r := r.(*ir.BinaryExpr)
 		return samesafeexpr(l.Left(), r.Left()) && samesafeexpr(l.Right(), r.Right())
 
 	case ir.OLITERAL:
@@ -3175,7 +3235,7 @@ func samesafeexpr(l ir.Node, r ir.Node) bool {
 // type check assignment.
 // if this assignment is the definition of a var on the left side,
 // fill in the var's type.
-func typecheckas(n ir.Node) {
+func typecheckas(n *ir.AssignStmt) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckas", n)(nil)
 	}
@@ -3199,7 +3259,7 @@ func typecheckas(n ir.Node) {
 	checkassign(n, n.Left())
 	if n.Right() != nil && n.Right().Type() != nil {
 		if n.Right().Type().IsFuncArgStruct() {
-			base.Errorf("assignment mismatch: 1 variable but %v returns %d values", n.Right().Left(), n.Right().Type().NumFields())
+			base.Errorf("assignment mismatch: 1 variable but %v returns %d values", n.Right().(*ir.CallExpr).Left(), n.Right().Type().NumFields())
 			// Multi-value RHS isn't actually valid for OAS; nil out
 			// to indicate failed typechecking.
 			n.Right().SetType(nil)
@@ -3233,7 +3293,7 @@ func checkassignto(src *types.Type, dst ir.Node) {
 	}
 }
 
-func typecheckas2(n ir.Node) {
+func typecheckas2(n *ir.AssignListStmt) {
 	if enableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckas2", n)(nil)
 	}
@@ -3400,7 +3460,7 @@ func typecheckfunc(n *ir.Func) {
 
 // The result of stringtoruneslit MUST be assigned back to n, e.g.
 // 	n.Left = stringtoruneslit(n.Left)
-func stringtoruneslit(n ir.Node) ir.Node {
+func stringtoruneslit(n *ir.ConvExpr) ir.Node {
 	if n.Left().Op() != ir.OLITERAL || n.Left().Val().Kind() != constant.String {
 		base.Fatalf("stringtoarraylit %v", n)
 	}
@@ -3683,19 +3743,25 @@ func markBreak(fn *ir.Func) {
 
 		case ir.OBREAK:
 			if n.Sym() == nil {
-				if implicit != nil {
-					implicit.SetHasBreak(true)
-				}
+				setHasBreak(implicit)
 			} else {
-				if lab := labels[n.Sym()]; lab != nil {
-					lab.SetHasBreak(true)
-				}
+				setHasBreak(labels[n.Sym()])
 			}
 
-		case ir.OFOR, ir.OFORUNTIL, ir.OSWITCH, ir.OTYPESW, ir.OSELECT, ir.ORANGE:
+		case ir.OFOR, ir.OFORUNTIL, ir.OSWITCH, ir.OSELECT, ir.ORANGE:
 			old := implicit
 			implicit = n
-			sym := n.Sym()
+			var sym *types.Sym
+			switch n := n.(type) {
+			case *ir.ForStmt:
+				sym = n.Sym()
+			case *ir.RangeStmt:
+				sym = n.Sym()
+			case *ir.SelectStmt:
+				sym = n.Sym()
+			case *ir.SwitchStmt:
+				sym = n.Sym()
+			}
 			if sym != nil {
 				if labels == nil {
 					// Map creation delayed until we need it - most functions don't.
@@ -3715,6 +3781,39 @@ func markBreak(fn *ir.Func) {
 	mark(fn)
 }
 
+func controlLabel(n ir.Node) *types.Sym {
+	switch n := n.(type) {
+	default:
+		base.Fatalf("controlLabel %+v", n.Op())
+		return nil
+	case *ir.ForStmt:
+		return n.Sym()
+	case *ir.RangeStmt:
+		return n.Sym()
+	case *ir.SelectStmt:
+		return n.Sym()
+	case *ir.SwitchStmt:
+		return n.Sym()
+	}
+}
+
+func setHasBreak(n ir.Node) {
+	switch n := n.(type) {
+	default:
+		base.Fatalf("setHasBreak %+v", n.Op())
+	case nil:
+		// ignore
+	case *ir.ForStmt:
+		n.SetHasBreak(true)
+	case *ir.RangeStmt:
+		n.SetHasBreak(true)
+	case *ir.SelectStmt:
+		n.SetHasBreak(true)
+	case *ir.SwitchStmt:
+		n.SetHasBreak(true)
+	}
+}
+
 // isTermNodes reports whether the Nodes list ends with a terminating statement.
 func isTermNodes(l ir.Nodes) bool {
 	s := l.Slice()
@@ -3752,23 +3851,32 @@ func isTermNode(n ir.Node) bool {
 	case ir.OIF:
 		return isTermNodes(n.Body()) && isTermNodes(n.Rlist())
 
-	case ir.OSWITCH, ir.OTYPESW, ir.OSELECT:
+	case ir.OSWITCH:
 		if n.HasBreak() {
 			return false
 		}
 		def := false
-		for _, n1 := range n.List().Slice() {
-			if !isTermNodes(n1.Body()) {
+		for _, cas := range n.List().Slice() {
+			cas := cas.(*ir.CaseStmt)
+			if !isTermNodes(cas.Body()) {
 				return false
 			}
-			if n1.List().Len() == 0 { // default
+			if cas.List().Len() == 0 { // default
 				def = true
 			}
 		}
+		return def
 
-		if n.Op() != ir.OSELECT && !def {
+	case ir.OSELECT:
+		if n.HasBreak() {
 			return false
 		}
+		for _, cas := range n.List().Slice() {
+			cas := cas.(*ir.CaseStmt)
+			if !isTermNodes(cas.Body()) {
+				return false
+			}
+		}
 		return true
 	}
 
-- 
GitLab


From bf9bbbd6ed1d58433019c145c10082f4d5c062c9 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 10 Dec 2020 18:45:35 -0500
Subject: [PATCH 0246/2400] [dev.regabi] cmd/compile: cleanup for concrete
 types - order

An automated rewrite will add concrete type assertions after
a test of n.Op(), when n can be safely type-asserted
(meaning, n is not reassigned a different type, n is not reassigned
and then used outside the scope of the type assertion,
and so on).

This sequence of CLs handles the code that the automated
rewrite does not: adding specific types to function arguments,
adjusting code not to call n.Left() etc when n may have multiple
representations, and so on.

This CL focuses on order.go.

Passes buildall w/ toolstash -cmp.

Change-Id: Ib5731905a620175a6fe978f512da593e0dae9d87
Reviewed-on: https://go-review.googlesource.com/c/go/+/277922
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/order.go | 369 +++++++++++++++------------
 src/cmd/compile/internal/ir/stmt.go  |   4 +-
 2 files changed, 210 insertions(+), 163 deletions(-)

diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index e0c0cabcde..b0a9c9be3e 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -139,7 +139,7 @@ func (o *Order) cheapExpr(n ir.Node) ir.Node {
 		if l == n.Left() {
 			return n
 		}
-		a := ir.SepCopy(n)
+		a := ir.SepCopy(n).(*ir.UnaryExpr)
 		a.SetLeft(l)
 		return typecheck(a, ctxExpr)
 	}
@@ -159,21 +159,39 @@ func (o *Order) safeExpr(n ir.Node) ir.Node {
 	case ir.ONAME, ir.OLITERAL, ir.ONIL:
 		return n
 
-	case ir.ODOT, ir.OLEN, ir.OCAP:
+	case ir.OLEN, ir.OCAP:
+		l := o.safeExpr(n.Left())
+		if l == n.Left() {
+			return n
+		}
+		a := ir.SepCopy(n).(*ir.UnaryExpr)
+		a.SetLeft(l)
+		return typecheck(a, ctxExpr)
+
+	case ir.ODOT:
 		l := o.safeExpr(n.Left())
 		if l == n.Left() {
 			return n
 		}
-		a := ir.SepCopy(n)
+		a := ir.SepCopy(n).(*ir.SelectorExpr)
+		a.SetLeft(l)
+		return typecheck(a, ctxExpr)
+
+	case ir.ODOTPTR:
+		l := o.cheapExpr(n.Left())
+		if l == n.Left() {
+			return n
+		}
+		a := ir.SepCopy(n).(*ir.SelectorExpr)
 		a.SetLeft(l)
 		return typecheck(a, ctxExpr)
 
-	case ir.ODOTPTR, ir.ODEREF:
+	case ir.ODEREF:
 		l := o.cheapExpr(n.Left())
 		if l == n.Left() {
 			return n
 		}
-		a := ir.SepCopy(n)
+		a := ir.SepCopy(n).(*ir.StarExpr)
 		a.SetLeft(l)
 		return typecheck(a, ctxExpr)
 
@@ -188,7 +206,7 @@ func (o *Order) safeExpr(n ir.Node) ir.Node {
 		if l == n.Left() && r == n.Right() {
 			return n
 		}
-		a := ir.SepCopy(n)
+		a := ir.SepCopy(n).(*ir.IndexExpr)
 		a.SetLeft(l)
 		a.SetRight(r)
 		return typecheck(a, ctxExpr)
@@ -206,7 +224,7 @@ func (o *Order) safeExpr(n ir.Node) ir.Node {
 // because we emit explicit VARKILL instructions marking the end of those
 // temporaries' lifetimes.
 func isaddrokay(n ir.Node) bool {
-	return islvalue(n) && (n.Op() != ir.ONAME || n.Class() == ir.PEXTERN || ir.IsAutoTmp(n))
+	return islvalue(n) && (n.Op() != ir.ONAME || n.(*ir.Name).Class() == ir.PEXTERN || ir.IsAutoTmp(n))
 }
 
 // addrTemp ensures that n is okay to pass by address to runtime routines.
@@ -225,7 +243,7 @@ func (o *Order) addrTemp(n ir.Node) ir.Node {
 		if s.out != nil {
 			base.Fatalf("staticassign of const generated code: %+v", n)
 		}
-		vstat = typecheck(vstat, ctxExpr)
+		vstat = typecheck(vstat, ctxExpr).(*ir.Name)
 		return vstat
 	}
 	if isaddrokay(n) {
@@ -267,6 +285,7 @@ func mapKeyReplaceStrConv(n ir.Node) bool {
 		replaced = true
 	case ir.OSTRUCTLIT:
 		for _, elem := range n.List().Slice() {
+			elem := elem.(*ir.StructKeyExpr)
 			if mapKeyReplaceStrConv(elem.Left()) {
 				replaced = true
 			}
@@ -274,7 +293,7 @@ func mapKeyReplaceStrConv(n ir.Node) bool {
 	case ir.OARRAYLIT:
 		for _, elem := range n.List().Slice() {
 			if elem.Op() == ir.OKEY {
-				elem = elem.Right()
+				elem = elem.(*ir.KeyExpr).Right()
 			}
 			if mapKeyReplaceStrConv(elem) {
 				replaced = true
@@ -337,60 +356,31 @@ func orderMakeSliceCopy(s []ir.Node) {
 	if base.Flag.N != 0 || instrumenting {
 		return
 	}
-
-	if len(s) < 2 {
+	if len(s) < 2 || s[0] == nil || s[0].Op() != ir.OAS || s[1] == nil || s[1].Op() != ir.OCOPY {
 		return
 	}
 
-	asn := s[0]
-	copyn := s[1]
-
-	if asn == nil || asn.Op() != ir.OAS {
-		return
-	}
-	if asn.Left().Op() != ir.ONAME {
-		return
-	}
-	if ir.IsBlank(asn.Left()) {
-		return
-	}
-	maken := asn.Right()
-	if maken == nil || maken.Op() != ir.OMAKESLICE {
-		return
-	}
-	if maken.Esc() == EscNone {
-		return
-	}
-	if maken.Left() == nil || maken.Right() != nil {
-		return
-	}
-	if copyn.Op() != ir.OCOPY {
-		return
-	}
-	if copyn.Left().Op() != ir.ONAME {
-		return
-	}
-	if asn.Left().Sym() != copyn.Left().Sym() {
-		return
-	}
-	if copyn.Right().Op() != ir.ONAME {
+	as := s[0].(*ir.AssignStmt)
+	cp := s[1].(*ir.BinaryExpr)
+	if as.Right() == nil || as.Right().Op() != ir.OMAKESLICE || ir.IsBlank(as.Left()) ||
+		as.Left().Op() != ir.ONAME || cp.Left().Op() != ir.ONAME || cp.Right().Op() != ir.ONAME ||
+		as.Left().Name() != cp.Left().Name() || cp.Left().Name() == cp.Right().Name() {
+		// The line above this one is correct with the differing equality operators:
+		// we want as.X and cp.X to be the same name,
+		// but we want the initial data to be coming from a different name.
 		return
 	}
 
-	if copyn.Left().Sym() == copyn.Right().Sym() {
+	mk := as.Right().(*ir.MakeExpr)
+	if mk.Esc() == EscNone || mk.Left() == nil || mk.Right() != nil {
 		return
 	}
-
-	maken.SetOp(ir.OMAKESLICECOPY)
-	maken.SetRight(copyn.Right())
+	mk.SetOp(ir.OMAKESLICECOPY)
+	mk.SetRight(cp.Right())
 	// Set bounded when m = OMAKESLICE([]T, len(s)); OCOPY(m, s)
-	maken.SetBounded(maken.Left().Op() == ir.OLEN && samesafeexpr(maken.Left().Left(), copyn.Right()))
-
-	maken = typecheck(maken, ctxExpr)
-
+	mk.SetBounded(mk.Left().Op() == ir.OLEN && samesafeexpr(mk.Left().(*ir.UnaryExpr).Left(), cp.Right()))
+	as.SetRight(typecheck(mk, ctxExpr))
 	s[1] = nil // remove separate copy call
-
-	return
 }
 
 // edge inserts coverage instrumentation for libfuzzer.
@@ -405,8 +395,7 @@ func (o *Order) edge() {
 	counter.Name().SetLibfuzzerExtraCounter(true)
 
 	// counter += 1
-	incr := ir.Nod(ir.OASOP, counter, nodintconst(1))
-	incr.SetSubOp(ir.OADD)
+	incr := ir.NewAssignOpStmt(base.Pos, ir.OADD, counter, nodintconst(1))
 	o.append(incr)
 }
 
@@ -469,20 +458,34 @@ func (o *Order) init(n ir.Node) {
 
 // call orders the call expression n.
 // n.Op is OCALLMETH/OCALLFUNC/OCALLINTER or a builtin like OCOPY.
-func (o *Order) call(n ir.Node) {
-	if n.Init().Len() > 0 {
-		// Caller should have already called o.init(n).
-		base.Fatalf("%v with unexpected ninit", n.Op())
+func (o *Order) call(nn ir.Node) {
+	if nn.Init().Len() > 0 {
+		// Caller should have already called o.init(nn).
+		base.Fatalf("%v with unexpected ninit", nn.Op())
 	}
 
 	// Builtin functions.
-	if n.Op() != ir.OCALLFUNC && n.Op() != ir.OCALLMETH && n.Op() != ir.OCALLINTER {
-		n.SetLeft(o.expr(n.Left(), nil))
-		n.SetRight(o.expr(n.Right(), nil))
-		o.exprList(n.List())
+	if nn.Op() != ir.OCALLFUNC && nn.Op() != ir.OCALLMETH && nn.Op() != ir.OCALLINTER {
+		switch n := nn.(type) {
+		default:
+			base.Fatalf("unexpected call: %+v", n)
+		case *ir.UnaryExpr:
+			n.SetLeft(o.expr(n.Left(), nil))
+		case *ir.ConvExpr:
+			n.SetLeft(o.expr(n.Left(), nil))
+		case *ir.BinaryExpr:
+			n.SetLeft(o.expr(n.Left(), nil))
+			n.SetRight(o.expr(n.Right(), nil))
+		case *ir.MakeExpr:
+			n.SetLeft(o.expr(n.Left(), nil))
+			n.SetRight(o.expr(n.Right(), nil))
+		case *ir.CallExpr:
+			o.exprList(n.List())
+		}
 		return
 	}
 
+	n := nn.(*ir.CallExpr)
 	fixVariadicCall(n)
 	n.SetLeft(o.expr(n.Left(), nil))
 	o.exprList(n.List())
@@ -495,11 +498,13 @@ func (o *Order) call(n ir.Node) {
 		// arrange for the pointer to be kept alive until the call returns,
 		// by copying it into a temp and marking that temp
 		// still alive when we pop the temp stack.
-		if arg.Op() == ir.OCONVNOP && arg.Left().Type().IsUnsafePtr() {
-			x := o.copyExpr(arg.Left())
-			arg.SetLeft(x)
-			x.Name().SetAddrtaken(true) // ensure SSA keeps the x variable
-			n.PtrBody().Append(typecheck(ir.Nod(ir.OVARLIVE, x, nil), ctxStmt))
+		if arg.Op() == ir.OCONVNOP {
+			if arg.Left().Type().IsUnsafePtr() {
+				x := o.copyExpr(arg.Left())
+				arg.SetLeft(x)
+				x.Name().SetAddrtaken(true) // ensure SSA keeps the x variable
+				n.PtrBody().Append(typecheck(ir.Nod(ir.OVARLIVE, x, nil), ctxStmt))
+			}
 		}
 	}
 
@@ -537,18 +542,14 @@ func (o *Order) mapAssign(n ir.Node) {
 	default:
 		base.Fatalf("order.mapAssign %v", n.Op())
 
-	case ir.OAS, ir.OASOP:
+	case ir.OAS:
 		if n.Left().Op() == ir.OINDEXMAP {
-			// Make sure we evaluate the RHS before starting the map insert.
-			// We need to make sure the RHS won't panic.  See issue 22881.
-			if n.Right().Op() == ir.OAPPEND {
-				s := n.Right().List().Slice()[1:]
-				for i, n := range s {
-					s[i] = o.cheapExpr(n)
-				}
-			} else {
-				n.SetRight(o.cheapExpr(n.Right()))
-			}
+			n.SetRight(o.safeMapRHS(n.Right()))
+		}
+		o.out = append(o.out, n)
+	case ir.OASOP:
+		if n.Left().Op() == ir.OINDEXMAP {
+			n.SetRight(o.safeMapRHS(n.Right()))
 		}
 		o.out = append(o.out, n)
 
@@ -557,6 +558,7 @@ func (o *Order) mapAssign(n ir.Node) {
 		for i, m := range n.List().Slice() {
 			switch {
 			case m.Op() == ir.OINDEXMAP:
+				m := m.(*ir.IndexExpr)
 				if !ir.IsAutoTmp(m.Left()) {
 					m.SetLeft(o.copyExpr(m.Left()))
 				}
@@ -577,6 +579,19 @@ func (o *Order) mapAssign(n ir.Node) {
 	}
 }
 
+func (o *Order) safeMapRHS(r ir.Node) ir.Node {
+	// Make sure we evaluate the RHS before starting the map insert.
+	// We need to make sure the RHS won't panic.  See issue 22881.
+	if r.Op() == ir.OAPPEND {
+		s := r.List().Slice()[1:]
+		for i, n := range s {
+			s[i] = o.cheapExpr(n)
+		}
+		return r
+	}
+	return o.cheapExpr(r)
+}
+
 // stmt orders the statement n, appending to o.out.
 // Temporaries created during the statement are cleaned
 // up using VARKILL instructions as possible.
@@ -616,12 +631,15 @@ func (o *Order) stmt(n ir.Node) {
 			// makes sure there is nothing too deep being copied.
 			l1 := o.safeExpr(n.Left())
 			l2 := ir.DeepCopy(src.NoXPos, l1)
-			if l1.Op() == ir.OINDEXMAP {
+			if l2.Op() == ir.OINDEXMAP {
 				l2.SetIndexMapLValue(false)
 			}
 			l2 = o.copyExpr(l2)
 			r := o.expr(typecheck(ir.NewBinaryExpr(n.Pos(), n.SubOp(), l2, n.Right()), ctxExpr), nil)
-			n = typecheck(ir.NodAt(n.Pos(), ir.OAS, l1, r), ctxStmt)
+			as := typecheck(ir.NodAt(n.Pos(), ir.OAS, l1, r), ctxStmt)
+			o.mapAssign(as)
+			o.cleanTemp(t)
+			return
 		}
 
 		o.mapAssign(n)
@@ -636,6 +654,7 @@ func (o *Order) stmt(n ir.Node) {
 
 	// Special: avoid copy of func call n.Right
 	case ir.OAS2FUNC:
+		n := n.(*ir.AssignListStmt)
 		t := o.markTemp()
 		o.exprList(n.List())
 		o.init(n.Rlist().First())
@@ -650,11 +669,14 @@ func (o *Order) stmt(n ir.Node) {
 	// OAS2MAPR: make sure key is addressable if needed,
 	//           and make sure OINDEXMAP is not copied out.
 	case ir.OAS2DOTTYPE, ir.OAS2RECV, ir.OAS2MAPR:
+		n := n.(*ir.AssignListStmt)
 		t := o.markTemp()
 		o.exprList(n.List())
 
 		switch r := n.Rlist().First(); r.Op() {
-		case ir.ODOTTYPE2, ir.ORECV:
+		case ir.ODOTTYPE2:
+			r.SetLeft(o.expr(r.Left(), nil))
+		case ir.ORECV:
 			r.SetLeft(o.expr(r.Left(), nil))
 		case ir.OINDEXMAP:
 			r.SetLeft(o.expr(r.Left(), nil))
@@ -692,17 +714,22 @@ func (o *Order) stmt(n ir.Node) {
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
 
-	case ir.OCLOSE,
-		ir.OCOPY,
-		ir.OPRINT,
-		ir.OPRINTN,
-		ir.ORECOVER,
-		ir.ORECV:
+	case ir.OCLOSE, ir.ORECV:
+		t := o.markTemp()
+		n.SetLeft(o.expr(n.Left(), nil))
+		o.out = append(o.out, n)
+		o.cleanTemp(t)
+
+	case ir.OCOPY:
 		t := o.markTemp()
 		n.SetLeft(o.expr(n.Left(), nil))
 		n.SetRight(o.expr(n.Right(), nil))
+		o.out = append(o.out, n)
+		o.cleanTemp(t)
+
+	case ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
+		t := o.markTemp()
 		o.exprList(n.List())
-		o.exprList(n.Rlist())
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
 
@@ -770,8 +797,9 @@ func (o *Order) stmt(n ir.Node) {
 
 		// Mark []byte(str) range expression to reuse string backing storage.
 		// It is safe because the storage cannot be mutated.
+		n := n.(*ir.RangeStmt)
 		if n.Right().Op() == ir.OSTR2BYTES {
-			n.Right().SetOp(ir.OSTR2BYTESTMP)
+			n.Right().(*ir.ConvExpr).SetOp(ir.OSTR2BYTESTMP)
 		}
 
 		t := o.markTemp()
@@ -845,16 +873,14 @@ func (o *Order) stmt(n ir.Node) {
 	case ir.OSELECT:
 		t := o.markTemp()
 
-		for _, n2 := range n.List().Slice() {
-			if n2.Op() != ir.OCASE {
-				base.Fatalf("order select case %v", n2.Op())
-			}
-			r := n2.Left()
-			setlineno(n2)
+		for _, cas := range n.List().Slice() {
+			cas := cas.(*ir.CaseStmt)
+			r := cas.Left()
+			setlineno(cas)
 
 			// Append any new body prologue to ninit.
 			// The next loop will insert ninit into nbody.
-			if n2.Init().Len() != 0 {
+			if cas.Init().Len() != 0 {
 				base.Fatalf("order select ninit")
 			}
 			if r == nil {
@@ -866,26 +892,29 @@ func (o *Order) stmt(n ir.Node) {
 				base.Fatalf("unknown op in select %v", r.Op())
 
 			case ir.OSELRECV, ir.OSELRECV2:
-				var dst, ok, recv ir.Node
+				var dst, ok ir.Node
+				var recv *ir.UnaryExpr
+				var def bool
 				if r.Op() == ir.OSELRECV {
 					// case x = <-c
 					// case <-c (dst is ir.BlankNode)
-					dst, ok, recv = r.Left(), ir.BlankNode, r.Right()
+					def, dst, ok, recv = r.Colas(), r.Left(), ir.BlankNode, r.Right().(*ir.UnaryExpr)
 				} else {
+					r := r.(*ir.AssignListStmt)
 					// case x, ok = <-c
-					dst, ok, recv = r.List().First(), r.List().Second(), r.Rlist().First()
+					def, dst, ok, recv = r.Colas(), r.List().First(), r.List().Second(), r.Rlist().First().(*ir.UnaryExpr)
 				}
 
 				// If this is case x := <-ch or case x, y := <-ch, the case has
 				// the ODCL nodes to declare x and y. We want to delay that
 				// declaration (and possible allocation) until inside the case body.
 				// Delete the ODCL nodes here and recreate them inside the body below.
-				if r.Colas() {
+				if def {
 					init := r.Init().Slice()
-					if len(init) > 0 && init[0].Op() == ir.ODCL && init[0].Left() == dst {
+					if len(init) > 0 && init[0].Op() == ir.ODCL && init[0].(*ir.Decl).Left() == dst {
 						init = init[1:]
 					}
-					if len(init) > 0 && init[0].Op() == ir.ODCL && init[0].Left() == ok {
+					if len(init) > 0 && init[0].Op() == ir.ODCL && init[0].(*ir.Decl).Left() == ok {
 						init = init[1:]
 					}
 					r.PtrInit().Set(init)
@@ -910,35 +939,36 @@ func (o *Order) stmt(n ir.Node) {
 					// use channel element type for temporary to avoid conversions,
 					// such as in case interfacevalue = <-intchan.
 					// the conversion happens in the OAS instead.
-					if r.Colas() {
+					if def {
 						dcl := ir.Nod(ir.ODCL, dst, nil)
-						n2.PtrInit().Append(typecheck(dcl, ctxStmt))
+						cas.PtrInit().Append(typecheck(dcl, ctxStmt))
 					}
 
 					tmp := o.newTemp(recv.Left().Type().Elem(), recv.Left().Type().Elem().HasPointers())
 					as := ir.Nod(ir.OAS, dst, tmp)
-					n2.PtrInit().Append(typecheck(as, ctxStmt))
+					cas.PtrInit().Append(typecheck(as, ctxStmt))
 					dst = tmp
 				}
 				if !ir.IsBlank(ok) {
-					if r.Colas() {
+					if def {
 						dcl := ir.Nod(ir.ODCL, ok, nil)
-						n2.PtrInit().Append(typecheck(dcl, ctxStmt))
+						cas.PtrInit().Append(typecheck(dcl, ctxStmt))
 					}
 
 					tmp := o.newTemp(types.Types[types.TBOOL], false)
 					as := ir.Nod(ir.OAS, ok, conv(tmp, ok.Type()))
-					n2.PtrInit().Append(typecheck(as, ctxStmt))
+					cas.PtrInit().Append(typecheck(as, ctxStmt))
 					ok = tmp
 				}
 
 				if r.Op() == ir.OSELRECV {
 					r.SetLeft(dst)
 				} else {
+					r := r.(*ir.AssignListStmt)
 					r.List().SetIndex(0, dst)
 					r.List().SetIndex(1, ok)
 				}
-				orderBlock(n2.PtrInit(), o.free)
+				orderBlock(cas.PtrInit(), o.free)
 
 			case ir.OSEND:
 				if r.Init().Len() != 0 {
@@ -962,14 +992,15 @@ func (o *Order) stmt(n ir.Node) {
 		// Now that we have accumulated all the temporaries, clean them.
 		// Also insert any ninit queued during the previous loop.
 		// (The temporary cleaning must follow that ninit work.)
-		for _, n3 := range n.List().Slice() {
-			orderBlock(n3.PtrBody(), o.free)
-			n3.PtrBody().Prepend(o.cleanTempNoPop(t)...)
+		for _, cas := range n.List().Slice() {
+			cas := cas.(*ir.CaseStmt)
+			orderBlock(cas.PtrBody(), o.free)
+			cas.PtrBody().Prepend(o.cleanTempNoPop(t)...)
 
 			// TODO(mdempsky): Is this actually necessary?
 			// walkselect appears to walk Ninit.
-			n3.PtrBody().Prepend(n3.Init().Slice()...)
-			n3.PtrInit().Set(nil)
+			cas.PtrBody().Prepend(cas.Init().Slice()...)
+			cas.PtrInit().Set(nil)
 		}
 
 		o.out = append(o.out, n)
@@ -998,6 +1029,7 @@ func (o *Order) stmt(n ir.Node) {
 	// For now just clean all the temporaries at the end.
 	// In practice that's fine.
 	case ir.OSWITCH:
+		n := n.(*ir.SwitchStmt)
 		if base.Debug.Libfuzzer != 0 && !hasDefaultCase(n) {
 			// Add empty "default:" case for instrumentation.
 			n.PtrList().Append(ir.Nod(ir.OCASE, nil, nil))
@@ -1006,9 +1038,7 @@ func (o *Order) stmt(n ir.Node) {
 		t := o.markTemp()
 		n.SetLeft(o.expr(n.Left(), nil))
 		for _, ncas := range n.List().Slice() {
-			if ncas.Op() != ir.OCASE {
-				base.Fatalf("order switch case %v", ncas.Op())
-			}
+			ncas := ncas.(*ir.CaseStmt)
 			o.exprListInPlace(ncas.List())
 			orderBlock(ncas.PtrBody(), o.free)
 		}
@@ -1020,11 +1050,9 @@ func (o *Order) stmt(n ir.Node) {
 	base.Pos = lno
 }
 
-func hasDefaultCase(n ir.Node) bool {
+func hasDefaultCase(n *ir.SwitchStmt) bool {
 	for _, ncas := range n.List().Slice() {
-		if ncas.Op() != ir.OCASE {
-			base.Fatalf("expected case, found %v", ncas.Op())
-		}
+		ncas := ncas.(*ir.CaseStmt)
 		if ncas.List().Len() == 0 {
 			return true
 		}
@@ -1067,8 +1095,13 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 	if n == nil {
 		return n
 	}
-
 	lno := setlineno(n)
+	n = o.expr1(n, lhs)
+	base.Pos = lno
+	return n
+}
+
+func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 	o.init(n)
 
 	switch n.Op() {
@@ -1077,6 +1110,7 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 			o.edit = o.exprNoLHS // create closure once
 		}
 		ir.EditChildren(n, o.edit)
+		return n
 
 	// Addition of strings turns into a function call.
 	// Allocate a temporary to hold the strings.
@@ -1111,6 +1145,7 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 				}
 			}
 		}
+		return n
 
 	case ir.OINDEXMAP:
 		n.SetLeft(o.expr(n.Left(), nil))
@@ -1133,15 +1168,16 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 		// key must be addressable
 		n.SetRight(o.mapKeyTemp(n.Left().Type(), n.Right()))
 		if needCopy {
-			n = o.copyExpr(n)
+			return o.copyExpr(n)
 		}
+		return n
 
 	// concrete type (not interface) argument might need an addressable
 	// temporary to pass to the runtime conversion routine.
 	case ir.OCONVIFACE:
 		n.SetLeft(o.expr(n.Left(), nil))
 		if n.Left().Type().IsInterface() {
-			break
+			return n
 		}
 		if _, needsaddr := convFuncName(n.Left().Type(), n.Type()); needsaddr || isStaticCompositeLiteral(n.Left()) {
 			// Need a temp if we need to pass the address to the conversion function.
@@ -1149,20 +1185,23 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 			// whose address we can put directly in an interface (see OCONVIFACE case in walk).
 			n.SetLeft(o.addrTemp(n.Left()))
 		}
+		return n
 
 	case ir.OCONVNOP:
 		if n.Type().IsKind(types.TUNSAFEPTR) && n.Left().Type().IsKind(types.TUINTPTR) && (n.Left().Op() == ir.OCALLFUNC || n.Left().Op() == ir.OCALLINTER || n.Left().Op() == ir.OCALLMETH) {
+			call := n.Left().(*ir.CallExpr)
 			// When reordering unsafe.Pointer(f()) into a separate
 			// statement, the conversion and function call must stay
 			// together. See golang.org/issue/15329.
-			o.init(n.Left())
-			o.call(n.Left())
+			o.init(call)
+			o.call(call)
 			if lhs == nil || lhs.Op() != ir.ONAME || instrumenting {
-				n = o.copyExpr(n)
+				return o.copyExpr(n)
 			}
 		} else {
 			n.SetLeft(o.expr(n.Left(), nil))
 		}
+		return n
 
 	case ir.OANDAND, ir.OOROR:
 		// ... = LHS && RHS
@@ -1199,7 +1238,7 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 			nif.PtrRlist().Set(gen)
 		}
 		o.out = append(o.out, nif)
-		n = r
+		return r
 
 	case ir.OCALLFUNC,
 		ir.OCALLINTER,
@@ -1222,27 +1261,31 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 
 		if isRuneCount(n) {
 			// len([]rune(s)) is rewritten to runtime.countrunes(s) later.
-			n.Left().SetLeft(o.expr(n.Left().Left(), nil))
+			conv := n.(*ir.UnaryExpr).Left().(*ir.ConvExpr)
+			conv.SetLeft(o.expr(conv.Left(), nil))
 		} else {
 			o.call(n)
 		}
 
 		if lhs == nil || lhs.Op() != ir.ONAME || instrumenting {
-			n = o.copyExpr(n)
+			return o.copyExpr(n)
 		}
+		return n
 
 	case ir.OAPPEND:
 		// Check for append(x, make([]T, y)...) .
 		if isAppendOfMake(n) {
-			n.List().SetFirst(o.expr(n.List().First(), nil))                 // order x
-			n.List().Second().SetLeft(o.expr(n.List().Second().Left(), nil)) // order y
+			n.List().SetFirst(o.expr(n.List().First(), nil)) // order x
+			mk := n.List().Second().(*ir.MakeExpr)
+			mk.SetLeft(o.expr(mk.Left(), nil)) // order y
 		} else {
 			o.exprList(n.List())
 		}
 
 		if lhs == nil || lhs.Op() != ir.ONAME && !samesafeexpr(lhs, n.List().First()) {
-			n = o.copyExpr(n)
+			return o.copyExpr(n)
 		}
+		return n
 
 	case ir.OSLICE, ir.OSLICEARR, ir.OSLICESTR, ir.OSLICE3, ir.OSLICE3ARR:
 		n.SetLeft(o.expr(n.Left(), nil))
@@ -1255,39 +1298,44 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 		max = o.cheapExpr(max)
 		n.SetSliceBounds(low, high, max)
 		if lhs == nil || lhs.Op() != ir.ONAME && !samesafeexpr(lhs, n.Left()) {
-			n = o.copyExpr(n)
+			return o.copyExpr(n)
 		}
+		return n
 
 	case ir.OCLOSURE:
+		n := n.(*ir.ClosureExpr)
 		if n.Transient() && len(n.Func().ClosureVars) > 0 {
 			prealloc[n] = o.newTemp(closureType(n), false)
 		}
+		return n
 
-	case ir.OSLICELIT, ir.OCALLPART:
+	case ir.OCALLPART:
+		n := n.(*ir.CallPartExpr)
 		n.SetLeft(o.expr(n.Left(), nil))
-		n.SetRight(o.expr(n.Right(), nil))
+		if n.Transient() {
+			t := partialCallType(n)
+			prealloc[n] = o.newTemp(t, false)
+		}
+		return n
+
+	case ir.OSLICELIT:
 		o.exprList(n.List())
-		o.exprList(n.Rlist())
 		if n.Transient() {
-			var t *types.Type
-			switch n.Op() {
-			case ir.OSLICELIT:
-				t = types.NewArray(n.Type().Elem(), ir.Int64Val(n.Right()))
-			case ir.OCALLPART:
-				t = partialCallType(n)
-			}
+			t := types.NewArray(n.Type().Elem(), ir.Int64Val(n.Right()))
 			prealloc[n] = o.newTemp(t, false)
 		}
+		return n
 
 	case ir.ODOTTYPE, ir.ODOTTYPE2:
 		n.SetLeft(o.expr(n.Left(), nil))
 		if !isdirectiface(n.Type()) || instrumenting {
-			n = o.copyExprClear(n)
+			return o.copyExprClear(n)
 		}
+		return n
 
 	case ir.ORECV:
 		n.SetLeft(o.expr(n.Left(), nil))
-		n = o.copyExprClear(n)
+		return o.copyExprClear(n)
 
 	case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
 		n.SetLeft(o.expr(n.Left(), nil))
@@ -1300,10 +1348,10 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 			// buffer during conversion. String comparison does not
 			// memorize the strings for later use, so it is safe.
 			if n.Left().Op() == ir.OBYTES2STR {
-				n.Left().SetOp(ir.OBYTES2STRTMP)
+				n.Left().(*ir.ConvExpr).SetOp(ir.OBYTES2STRTMP)
 			}
 			if n.Right().Op() == ir.OBYTES2STR {
-				n.Right().SetOp(ir.OBYTES2STRTMP)
+				n.Right().(*ir.ConvExpr).SetOp(ir.OBYTES2STRTMP)
 			}
 
 		case t.IsStruct() || t.IsArray():
@@ -1312,6 +1360,8 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 			n.SetLeft(o.addrTemp(n.Left()))
 			n.SetRight(o.addrTemp(n.Right()))
 		}
+		return n
+
 	case ir.OMAPLIT:
 		// Order map by converting:
 		//   map[int]int{
@@ -1330,11 +1380,9 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 		// See issue 26552.
 		entries := n.List().Slice()
 		statics := entries[:0]
-		var dynamics []ir.Node
+		var dynamics []*ir.KeyExpr
 		for _, r := range entries {
-			if r.Op() != ir.OKEY {
-				base.Fatalf("OMAPLIT entry not OKEY: %v\n", r)
-			}
+			r := r.(*ir.KeyExpr)
 
 			if !isStaticCompositeLiteral(r.Left()) || !isStaticCompositeLiteral(r.Right()) {
 				dynamics = append(dynamics, r)
@@ -1343,7 +1391,7 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 
 			// Recursively ordering some static entries can change them to dynamic;
 			// e.g., OCONVIFACE nodes. See #31777.
-			r = o.expr(r, nil)
+			r = o.expr(r, nil).(*ir.KeyExpr)
 			if !isStaticCompositeLiteral(r.Left()) || !isStaticCompositeLiteral(r.Right()) {
 				dynamics = append(dynamics, r)
 				continue
@@ -1354,7 +1402,7 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 		n.PtrList().Set(statics)
 
 		if len(dynamics) == 0 {
-			break
+			return n
 		}
 
 		// Emit the creation of the map (with all its static entries).
@@ -1362,18 +1410,17 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 		as := ir.Nod(ir.OAS, m, n)
 		typecheck(as, ctxStmt)
 		o.stmt(as)
-		n = m
 
 		// Emit eval+insert of dynamic entries, one at a time.
 		for _, r := range dynamics {
-			as := ir.Nod(ir.OAS, ir.Nod(ir.OINDEX, n, r.Left()), r.Right())
+			as := ir.Nod(ir.OAS, ir.Nod(ir.OINDEX, m, r.Left()), r.Right())
 			typecheck(as, ctxStmt) // Note: this converts the OINDEX to an OINDEXMAP
 			o.stmt(as)
 		}
+		return m
 	}
 
-	base.Pos = lno
-	return n
+	// No return - type-assertions above. Each case must return for itself.
 }
 
 // as2 orders OAS2XXXX nodes. It creates temporaries to ensure left-to-right assignment.
@@ -1384,7 +1431,7 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 //	tmp1, tmp2, tmp3 = ...
 // 	a, b, a = tmp1, tmp2, tmp3
 // This is necessary to ensure left to right assignment order.
-func (o *Order) as2(n ir.Node) {
+func (o *Order) as2(n *ir.AssignListStmt) {
 	tmplist := []ir.Node{}
 	left := []ir.Node{}
 	for ni, l := range n.List().Slice() {
@@ -1406,7 +1453,7 @@ func (o *Order) as2(n ir.Node) {
 
 // okAs2 orders OAS2XXX with ok.
 // Just like as2, this also adds temporaries to ensure left-to-right assignment.
-func (o *Order) okAs2(n ir.Node) {
+func (o *Order) okAs2(n *ir.AssignListStmt) {
 	var tmp1, tmp2 ir.Node
 	if !ir.IsBlank(n.List().First()) {
 		typ := n.Rlist().First().Type()
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index b7d0c1adc4..0302ffcc94 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -137,8 +137,8 @@ type AssignOpStmt struct {
 	IncDec bool // actually ++ or --
 }
 
-func NewAssignOpStmt(pos src.XPos, op Op, x, y Node) *AssignOpStmt {
-	n := &AssignOpStmt{AsOp: op, X: x, Y: y}
+func NewAssignOpStmt(pos src.XPos, asOp Op, x, y Node) *AssignOpStmt {
+	n := &AssignOpStmt{AsOp: asOp, X: x, Y: y}
 	n.pos = pos
 	n.op = OASOP
 	return n
-- 
GitLab


From 846740c17fe3f65fe4c004e07a7550cba7c028fb Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 10 Dec 2020 18:45:58 -0500
Subject: [PATCH 0247/2400] [dev.regabi] cmd/compile: cleanup for concrete
 types - ssa

An automated rewrite will add concrete type assertions after
a test of n.Op(), when n can be safely type-asserted
(meaning, n is not reassigned a different type, n is not reassigned
and then used outside the scope of the type assertion,
and so on).

This sequence of CLs handles the code that the automated
rewrite does not: adding specific types to function arguments,
adjusting code not to call n.Left() etc when n may have multiple
representations, and so on.

This CL focuses on ssa.go.

Passes buildall w/ toolstash -cmp.

Change-Id: Iefacc7104dd9469e3c574149791ab0bff29f7fee
Reviewed-on: https://go-review.googlesource.com/c/go/+/277923
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/inl.go   |   4 +-
 src/cmd/compile/internal/gc/phi.go   |   8 +-
 src/cmd/compile/internal/gc/plive.go |  10 +-
 src/cmd/compile/internal/gc/ssa.go   | 374 +++++++++++++++------------
 src/cmd/compile/internal/gc/walk.go  |   2 +-
 5 files changed, 229 insertions(+), 169 deletions(-)

diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 9342046dcc..3a19efd325 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -335,7 +335,7 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 			}
 		}
 
-		if isIntrinsicCall(n) {
+		if isIntrinsicCall(n.(*ir.CallExpr)) {
 			// Treat like any other node.
 			break
 		}
@@ -583,7 +583,7 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.No
 		if base.Flag.LowerM > 3 {
 			fmt.Printf("%v:call to func %+v\n", ir.Line(n), n.Left())
 		}
-		if isIntrinsicCall(n) {
+		if isIntrinsicCall(n.(*ir.CallExpr)) {
 			break
 		}
 		if fn := inlCallee(n.Left()); fn != nil && fn.Inl != nil {
diff --git a/src/cmd/compile/internal/gc/phi.go b/src/cmd/compile/internal/gc/phi.go
index 32c330b584..75ce18ff84 100644
--- a/src/cmd/compile/internal/gc/phi.go
+++ b/src/cmd/compile/internal/gc/phi.go
@@ -254,7 +254,9 @@ func (s *phiState) insertVarPhis(n int, var_ ir.Node, defs []*ssa.Block, typ *ty
 				hasPhi.add(c.ID)
 				v := c.NewValue0I(currentRoot.Pos, ssa.OpPhi, typ, int64(n)) // TODO: line number right?
 				// Note: we store the variable number in the phi's AuxInt field. Used temporarily by phi building.
-				s.s.addNamedValue(var_, v)
+				if var_.Op() == ir.ONAME {
+					s.s.addNamedValue(var_.(*ir.Name), v)
+				}
 				for range c.Preds {
 					v.AddArg(s.placeholder) // Actual args will be filled in by resolveFwdRefs.
 				}
@@ -546,7 +548,9 @@ func (s *simplePhiState) lookupVarOutgoing(b *ssa.Block, t *types.Type, var_ ir.
 	// Generate a FwdRef for the variable and return that.
 	v := b.NewValue0A(line, ssa.OpFwdRef, t, FwdRefAux{N: var_})
 	s.defvars[b.ID][var_] = v
-	s.s.addNamedValue(var_, v)
+	if var_.Op() == ir.ONAME {
+		s.s.addNamedValue(var_.(*ir.Name), v)
+	}
 	s.fwdrefs = append(s.fwdrefs, v)
 	return v
 }
diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/gc/plive.go
index 9952bfcf36..6deb3ecc7a 100644
--- a/src/cmd/compile/internal/gc/plive.go
+++ b/src/cmd/compile/internal/gc/plive.go
@@ -206,8 +206,12 @@ type progeffectscache struct {
 // nor do we care about non-local variables,
 // nor do we care about empty structs (handled by the pointer check),
 // nor do we care about the fake PAUTOHEAP variables.
-func livenessShouldTrack(n ir.Node) bool {
-	return n.Op() == ir.ONAME && (n.Class() == ir.PAUTO || n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT) && n.Type().HasPointers()
+func livenessShouldTrack(nn ir.Node) bool {
+	if nn.Op() != ir.ONAME {
+		return false
+	}
+	n := nn.(*ir.Name)
+	return (n.Class() == ir.PAUTO || n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT) && n.Type().HasPointers()
 }
 
 // getvariables returns the list of on-stack variables that we need to track
@@ -1165,7 +1169,7 @@ func (lv *Liveness) emit() (argsSym, liveSym *obj.LSym) {
 	// Size args bitmaps to be just large enough to hold the largest pointer.
 	// First, find the largest Xoffset node we care about.
 	// (Nodes without pointers aren't in lv.vars; see livenessShouldTrack.)
-	var maxArgNode ir.Node
+	var maxArgNode *ir.Name
 	for _, n := range lv.vars {
 		switch n.Class() {
 		case ir.PPARAM, ir.PPARAMOUT:
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index f13c45c2a6..4d9073a4b6 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -187,7 +187,7 @@ func initssaconfig() {
 // function/method/interface call), where the receiver of a method call is
 // considered as the 0th parameter. This does not include the receiver of an
 // interface call.
-func getParam(n ir.Node, i int) *types.Field {
+func getParam(n *ir.CallExpr, i int) *types.Field {
 	t := n.Left().Type()
 	if n.Op() == ir.OCALLMETH {
 		if i == 0 {
@@ -559,20 +559,20 @@ func (s *state) updateUnsetPredPos(b *ssa.Block) {
 
 // Information about each open-coded defer.
 type openDeferInfo struct {
-	// The ODEFER node representing the function call of the defer
-	n ir.Node
+	// The node representing the call of the defer
+	n *ir.CallExpr
 	// If defer call is closure call, the address of the argtmp where the
 	// closure is stored.
 	closure *ssa.Value
 	// The node representing the argtmp where the closure is stored - used for
 	// function, method, or interface call, to store a closure that panic
 	// processing can use for this defer.
-	closureNode ir.Node
+	closureNode *ir.Name
 	// If defer call is interface call, the address of the argtmp where the
 	// receiver is stored
 	rcvr *ssa.Value
 	// The node representing the argtmp where the receiver is stored
-	rcvrNode ir.Node
+	rcvrNode *ir.Name
 	// The addresses of the argtmps where the evaluated arguments of the defer
 	// function call are stored.
 	argVals []*ssa.Value
@@ -622,7 +622,7 @@ type state struct {
 	sb       *ssa.Value
 	// value representing address of where deferBits autotmp is stored
 	deferBitsAddr *ssa.Value
-	deferBitsTemp ir.Node
+	deferBitsTemp *ir.Name
 
 	// line number stack. The current line number is top of stack
 	line []src.XPos
@@ -1134,6 +1134,7 @@ func (s *state) stmt(n ir.Node) {
 
 	// Expression statements
 	case ir.OCALLFUNC:
+		n := n.(*ir.CallExpr)
 		if isIntrinsicCall(n) {
 			s.intrinsicCall(n)
 			return
@@ -1141,8 +1142,9 @@ func (s *state) stmt(n ir.Node) {
 		fallthrough
 
 	case ir.OCALLMETH, ir.OCALLINTER:
+		n := n.(*ir.CallExpr)
 		s.callResult(n, callNormal)
-		if n.Op() == ir.OCALLFUNC && n.Left().Op() == ir.ONAME && n.Left().Class() == ir.PFUNC {
+		if n.Op() == ir.OCALLFUNC && n.Left().Op() == ir.ONAME && n.Left().(*ir.Name).Class() == ir.PFUNC {
 			if fn := n.Left().Sym().Name; base.Flag.CompilingRuntime && fn == "throw" ||
 				n.Left().Sym().Pkg == Runtimepkg && (fn == "throwinit" || fn == "gopanic" || fn == "panicwrap" || fn == "block" || fn == "panicmakeslicelen" || fn == "panicmakeslicecap") {
 				m := s.mem()
@@ -1167,19 +1169,19 @@ func (s *state) stmt(n ir.Node) {
 			base.WarnfAt(n.Pos(), "%s defer", defertype)
 		}
 		if s.hasOpenDefers {
-			s.openDeferRecord(n.Left())
+			s.openDeferRecord(n.Left().(*ir.CallExpr))
 		} else {
 			d := callDefer
 			if n.Esc() == EscNever {
 				d = callDeferStack
 			}
-			s.callResult(n.Left(), d)
+			s.callResult(n.Left().(*ir.CallExpr), d)
 		}
 	case ir.OGO:
-		s.callResult(n.Left(), callGo)
+		s.callResult(n.Left().(*ir.CallExpr), callGo)
 
 	case ir.OAS2DOTTYPE:
-		res, resok := s.dottype(n.Rlist().First(), true)
+		res, resok := s.dottype(n.Rlist().First().(*ir.TypeAssertExpr), true)
 		deref := false
 		if !canSSAType(n.Rlist().First().Type()) {
 			if res.Op != ssa.OpLoad {
@@ -1201,10 +1203,11 @@ func (s *state) stmt(n ir.Node) {
 
 	case ir.OAS2FUNC:
 		// We come here only when it is an intrinsic call returning two values.
-		if !isIntrinsicCall(n.Rlist().First()) {
-			s.Fatalf("non-intrinsic AS2FUNC not expanded %v", n.Rlist().First())
+		call := n.Rlist().First().(*ir.CallExpr)
+		if !isIntrinsicCall(call) {
+			s.Fatalf("non-intrinsic AS2FUNC not expanded %v", call)
 		}
-		v := s.intrinsicCall(n.Rlist().First())
+		v := s.intrinsicCall(call)
 		v1 := s.newValue1(ssa.OpSelect0, n.List().First().Type(), v)
 		v2 := s.newValue1(ssa.OpSelect1, n.List().Second().Type(), v)
 		s.assign(n.List().First(), v1, false, 0)
@@ -1212,7 +1215,7 @@ func (s *state) stmt(n ir.Node) {
 		return
 
 	case ir.ODCL:
-		if n.Left().Class() == ir.PAUTOHEAP {
+		if n.Left().(*ir.Name).Class() == ir.PAUTOHEAP {
 			s.Fatalf("DCL %v", n)
 		}
 
@@ -1270,6 +1273,7 @@ func (s *state) stmt(n ir.Node) {
 				}
 				rhs = nil
 			case ir.OAPPEND:
+				rhs := rhs.(*ir.CallExpr)
 				// Check whether we're writing the result of an append back to the same slice.
 				// If so, we handle it specially to avoid write barriers on the fast
 				// (non-growth) path.
@@ -1326,7 +1330,7 @@ func (s *state) stmt(n ir.Node) {
 		}
 
 		var skip skipMask
-		if rhs != nil && (rhs.Op() == ir.OSLICE || rhs.Op() == ir.OSLICE3 || rhs.Op() == ir.OSLICESTR) && samesafeexpr(rhs.Left(), n.Left()) {
+		if rhs != nil && (rhs.Op() == ir.OSLICE || rhs.Op() == ir.OSLICE3 || rhs.Op() == ir.OSLICESTR) && samesafeexpr(rhs.(*ir.SliceExpr).Left(), n.Left()) {
 			// We're assigning a slicing operation back to its source.
 			// Don't write back fields we aren't changing. See issue #14855.
 			i, j, k := rhs.SliceBounds()
@@ -1409,7 +1413,6 @@ func (s *state) stmt(n ir.Node) {
 		b.Pos = s.lastPos.WithIsStmt()
 
 	case ir.ORETJMP:
-		s.stmtList(n.List())
 		b := s.exit()
 		b.Kind = ssa.BlockRetJmp // override BlockRet
 		b.Aux = n.Sym().Linksym()
@@ -1536,15 +1539,27 @@ func (s *state) stmt(n ir.Node) {
 
 		prevBreak := s.breakTo
 		s.breakTo = bEnd
+		var sym *types.Sym
+		var body ir.Nodes
+		if n.Op() == ir.OSWITCH {
+			n := n.(*ir.SwitchStmt)
+			sym = n.Sym()
+			body = n.Body()
+		} else {
+			n := n.(*ir.SelectStmt)
+			sym = n.Sym()
+			body = n.Body()
+		}
+
 		var lab *ssaLabel
-		if sym := n.Sym(); sym != nil {
+		if sym != nil {
 			// labeled
 			lab = s.label(sym)
 			lab.breakTarget = bEnd
 		}
 
 		// generate body code
-		s.stmtList(n.Body())
+		s.stmtList(body)
 
 		s.breakTo = prevBreak
 		if lab != nil {
@@ -1576,15 +1591,16 @@ func (s *state) stmt(n ir.Node) {
 
 	case ir.OVARLIVE:
 		// Insert a varlive op to record that a variable is still live.
-		if !n.Left().Name().Addrtaken() {
-			s.Fatalf("VARLIVE variable %v must have Addrtaken set", n.Left())
+		v := n.Left().(*ir.Name)
+		if !v.Addrtaken() {
+			s.Fatalf("VARLIVE variable %v must have Addrtaken set", v)
 		}
-		switch n.Left().Class() {
+		switch v.Class() {
 		case ir.PAUTO, ir.PPARAM, ir.PPARAMOUT:
 		default:
-			s.Fatalf("VARLIVE variable %v must be Auto or Arg", n.Left())
+			s.Fatalf("VARLIVE variable %v must be Auto or Arg", v)
 		}
-		s.vars[memVar] = s.newValue1A(ssa.OpVarLive, types.TypeMem, n.Left().(*ir.Name), s.mem())
+		s.vars[memVar] = s.newValue1A(ssa.OpVarLive, types.TypeMem, v, s.mem())
 
 	case ir.OCHECKNIL:
 		p := s.expr(n.Left())
@@ -2395,6 +2411,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		return nil
 
 	case ir.ODOTTYPE:
+		n := n.(*ir.TypeAssertExpr)
 		res, _ := s.dottype(n, false)
 		return res
 
@@ -2651,6 +2668,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		return s.load(n.Type(), p)
 
 	case ir.ODOT:
+		n := n.(*ir.SelectorExpr)
 		if n.Left().Op() == ir.OSTRUCTLIT {
 			// All literals with nonzero fields have already been
 			// rewritten during walk. Any that remain are just T{}
@@ -2726,6 +2744,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		}
 
 	case ir.OLEN, ir.OCAP:
+		n := n.(*ir.UnaryExpr)
 		switch {
 		case n.Left().Type().IsSlice():
 			op := ssa.OpSliceLen
@@ -2798,19 +2817,21 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		return s.newValue2(ssa.OpStringMake, n.Type(), p, l)
 
 	case ir.OCALLFUNC:
+		n := n.(*ir.CallExpr)
 		if isIntrinsicCall(n) {
 			return s.intrinsicCall(n)
 		}
 		fallthrough
 
 	case ir.OCALLINTER, ir.OCALLMETH:
+		n := n.(*ir.CallExpr)
 		return s.callResult(n, callNormal)
 
 	case ir.OGETG:
 		return s.newValue1(ssa.OpGetG, n.Type(), s.mem())
 
 	case ir.OAPPEND:
-		return s.append(n, false)
+		return s.append(n.(*ir.CallExpr), false)
 
 	case ir.OSTRUCTLIT, ir.OARRAYLIT:
 		// All literals with nonzero fields have already been
@@ -2841,7 +2862,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 // If inplace is true, it writes the result of the OAPPEND expression n
 // back to the slice being appended to, and returns nil.
 // inplace MUST be set to false if the slice can be SSA'd.
-func (s *state) append(n ir.Node, inplace bool) *ssa.Value {
+func (s *state) append(n *ir.CallExpr, inplace bool) *ssa.Value {
 	// If inplace is false, process as expression "append(s, e1, e2, e3)":
 	//
 	// ptr, len, cap := s
@@ -2923,9 +2944,12 @@ func (s *state) append(n ir.Node, inplace bool) *ssa.Value {
 	r := s.rtcall(growslice, true, []*types.Type{pt, types.Types[types.TINT], types.Types[types.TINT]}, taddr, p, l, c, nl)
 
 	if inplace {
-		if sn.Op() == ir.ONAME && sn.Class() != ir.PEXTERN {
-			// Tell liveness we're about to build a new slice
-			s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, sn.(*ir.Name), s.mem())
+		if sn.Op() == ir.ONAME {
+			sn := sn.(*ir.Name)
+			if sn.Class() != ir.PEXTERN {
+				// Tell liveness we're about to build a new slice
+				s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, sn, s.mem())
+			}
 		}
 		capaddr := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.IntPtr, sliceCapOffset, addr)
 		s.store(types.Types[types.TINT], capaddr, r[2])
@@ -3076,6 +3100,7 @@ func (s *state) assign(left ir.Node, right *ssa.Value, deref bool, skip skipMask
 			// For the x.b = 5 assignment we want to generate x = T{x.a, 5, x.c}
 
 			// Grab information about the structure type.
+			left := left.(*ir.SelectorExpr)
 			t := left.Left().Type()
 			nf := t.NumFields()
 			idx := fieldIdx(left)
@@ -3100,7 +3125,7 @@ func (s *state) assign(left ir.Node, right *ssa.Value, deref bool, skip skipMask
 			// TODO: do we need to update named values here?
 			return
 		}
-		if left.Op() == ir.OINDEX && left.Left().Type().IsArray() {
+		if left.Op() == ir.OINDEX && left.(*ir.IndexExpr).Left().Type().IsArray() {
 			s.pushLine(left.Pos())
 			defer s.popLine()
 			// We're assigning to an element of an ssa-able array.
@@ -3126,6 +3151,7 @@ func (s *state) assign(left ir.Node, right *ssa.Value, deref bool, skip skipMask
 			s.assign(left.Left(), v, false, 0)
 			return
 		}
+		left := left.(*ir.Name)
 		// Update variable assignment.
 		s.vars[left] = right
 		s.addNamedValue(left, right)
@@ -3134,7 +3160,7 @@ func (s *state) assign(left ir.Node, right *ssa.Value, deref bool, skip skipMask
 
 	// If this assignment clobbers an entire local variable, then emit
 	// OpVarDef so liveness analysis knows the variable is redefined.
-	if base := clobberBase(left); base.Op() == ir.ONAME && base.Class() != ir.PEXTERN && skip == 0 {
+	if base := clobberBase(left); base.Op() == ir.ONAME && base.(*ir.Name).Class() != ir.PEXTERN && skip == 0 {
 		s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, base.(*ir.Name), s.mem(), !ir.IsAutoTmp(base))
 	}
 
@@ -3309,7 +3335,7 @@ var intrinsics map[intrinsicKey]intrinsicBuilder
 
 // An intrinsicBuilder converts a call node n into an ssa value that
 // implements that call as an intrinsic. args is a list of arguments to the func.
-type intrinsicBuilder func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value
+type intrinsicBuilder func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value
 
 type intrinsicKey struct {
 	arch *sys.Arch
@@ -3374,7 +3400,7 @@ func init() {
 	/******** runtime ********/
 	if !instrumenting {
 		add("runtime", "slicebytetostringtmp",
-			func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+			func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 				// Compiler frontend optimizations emit OBYTES2STRTMP nodes
 				// for the backend instead of slicebytetostringtmp calls
 				// when not instrumenting.
@@ -3383,7 +3409,7 @@ func init() {
 			all...)
 	}
 	addF("runtime/internal/math", "MulUintptr",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			if s.config.PtrSize == 4 {
 				return s.newValue2(ssa.OpMul32uover, types.NewTuple(types.Types[types.TUINT], types.Types[types.TUINT]), args[0], args[1])
 			}
@@ -3391,90 +3417,90 @@ func init() {
 		},
 		sys.AMD64, sys.I386, sys.MIPS64)
 	add("runtime", "KeepAlive",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			data := s.newValue1(ssa.OpIData, s.f.Config.Types.BytePtr, args[0])
 			s.vars[memVar] = s.newValue2(ssa.OpKeepAlive, types.TypeMem, data, s.mem())
 			return nil
 		},
 		all...)
 	add("runtime", "getclosureptr",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue0(ssa.OpGetClosurePtr, s.f.Config.Types.Uintptr)
 		},
 		all...)
 
 	add("runtime", "getcallerpc",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue0(ssa.OpGetCallerPC, s.f.Config.Types.Uintptr)
 		},
 		all...)
 
 	add("runtime", "getcallersp",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue0(ssa.OpGetCallerSP, s.f.Config.Types.Uintptr)
 		},
 		all...)
 
 	/******** runtime/internal/sys ********/
 	addF("runtime/internal/sys", "Ctz32",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpCtz32, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64)
 	addF("runtime/internal/sys", "Ctz64",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpCtz64, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64)
 	addF("runtime/internal/sys", "Bswap32",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpBswap32, types.Types[types.TUINT32], args[0])
 		},
 		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X)
 	addF("runtime/internal/sys", "Bswap64",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpBswap64, types.Types[types.TUINT64], args[0])
 		},
 		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X)
 
 	/******** runtime/internal/atomic ********/
 	addF("runtime/internal/atomic", "Load",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			v := s.newValue2(ssa.OpAtomicLoad32, types.NewTuple(types.Types[types.TUINT32], types.TypeMem), args[0], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT32], v)
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Load8",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			v := s.newValue2(ssa.OpAtomicLoad8, types.NewTuple(types.Types[types.TUINT8], types.TypeMem), args[0], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT8], v)
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Load64",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			v := s.newValue2(ssa.OpAtomicLoad64, types.NewTuple(types.Types[types.TUINT64], types.TypeMem), args[0], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT64], v)
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "LoadAcq",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			v := s.newValue2(ssa.OpAtomicLoadAcq32, types.NewTuple(types.Types[types.TUINT32], types.TypeMem), args[0], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT32], v)
 		},
 		sys.PPC64, sys.S390X)
 	addF("runtime/internal/atomic", "LoadAcq64",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			v := s.newValue2(ssa.OpAtomicLoadAcq64, types.NewTuple(types.Types[types.TUINT64], types.TypeMem), args[0], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT64], v)
 		},
 		sys.PPC64)
 	addF("runtime/internal/atomic", "Loadp",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			v := s.newValue2(ssa.OpAtomicLoadPtr, types.NewTuple(s.f.Config.Types.BytePtr, types.TypeMem), args[0], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, s.f.Config.Types.BytePtr, v)
@@ -3482,62 +3508,62 @@ func init() {
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 
 	addF("runtime/internal/atomic", "Store",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicStore32, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Store8",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicStore8, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Store64",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicStore64, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "StorepNoWB",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicStorePtrNoWB, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.MIPS64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "StoreRel",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicStoreRel32, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.PPC64, sys.S390X)
 	addF("runtime/internal/atomic", "StoreRel64",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicStoreRel64, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.PPC64)
 
 	addF("runtime/internal/atomic", "Xchg",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			v := s.newValue3(ssa.OpAtomicExchange32, types.NewTuple(types.Types[types.TUINT32], types.TypeMem), args[0], args[1], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT32], v)
 		},
 		sys.AMD64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Xchg64",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			v := s.newValue3(ssa.OpAtomicExchange64, types.NewTuple(types.Types[types.TUINT64], types.TypeMem), args[0], args[1], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT64], v)
 		},
 		sys.AMD64, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 
-	type atomicOpEmitter func(s *state, n ir.Node, args []*ssa.Value, op ssa.Op, typ types.Kind)
+	type atomicOpEmitter func(s *state, n *ir.CallExpr, args []*ssa.Value, op ssa.Op, typ types.Kind)
 
 	makeAtomicGuardedIntrinsicARM64 := func(op0, op1 ssa.Op, typ, rtyp types.Kind, emit atomicOpEmitter) intrinsicBuilder {
 
-		return func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		return func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			// Target Atomic feature is identified by dynamic detection
 			addr := s.entryNewValue1A(ssa.OpAddr, types.Types[types.TBOOL].PtrTo(), arm64HasATOMICS, s.sb)
 			v := s.load(types.Types[types.TBOOL], addr)
@@ -3571,7 +3597,7 @@ func init() {
 		}
 	}
 
-	atomicXchgXaddEmitterARM64 := func(s *state, n ir.Node, args []*ssa.Value, op ssa.Op, typ types.Kind) {
+	atomicXchgXaddEmitterARM64 := func(s *state, n *ir.CallExpr, args []*ssa.Value, op ssa.Op, typ types.Kind) {
 		v := s.newValue3(op, types.NewTuple(types.Types[typ], types.TypeMem), args[0], args[1], s.mem())
 		s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 		s.vars[n] = s.newValue1(ssa.OpSelect0, types.Types[typ], v)
@@ -3584,14 +3610,14 @@ func init() {
 		sys.ARM64)
 
 	addF("runtime/internal/atomic", "Xadd",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			v := s.newValue3(ssa.OpAtomicAdd32, types.NewTuple(types.Types[types.TUINT32], types.TypeMem), args[0], args[1], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT32], v)
 		},
 		sys.AMD64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Xadd64",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			v := s.newValue3(ssa.OpAtomicAdd64, types.NewTuple(types.Types[types.TUINT64], types.TypeMem), args[0], args[1], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT64], v)
@@ -3606,28 +3632,28 @@ func init() {
 		sys.ARM64)
 
 	addF("runtime/internal/atomic", "Cas",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			v := s.newValue4(ssa.OpAtomicCompareAndSwap32, types.NewTuple(types.Types[types.TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TBOOL], v)
 		},
 		sys.AMD64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Cas64",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			v := s.newValue4(ssa.OpAtomicCompareAndSwap64, types.NewTuple(types.Types[types.TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TBOOL], v)
 		},
 		sys.AMD64, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "CasRel",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			v := s.newValue4(ssa.OpAtomicCompareAndSwap32, types.NewTuple(types.Types[types.TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
 			s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 			return s.newValue1(ssa.OpSelect0, types.Types[types.TBOOL], v)
 		},
 		sys.PPC64)
 
-	atomicCasEmitterARM64 := func(s *state, n ir.Node, args []*ssa.Value, op ssa.Op, typ types.Kind) {
+	atomicCasEmitterARM64 := func(s *state, n *ir.CallExpr, args []*ssa.Value, op ssa.Op, typ types.Kind) {
 		v := s.newValue4(op, types.NewTuple(types.Types[types.TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem())
 		s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v)
 		s.vars[n] = s.newValue1(ssa.OpSelect0, types.Types[typ], v)
@@ -3641,31 +3667,31 @@ func init() {
 		sys.ARM64)
 
 	addF("runtime/internal/atomic", "And8",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicAnd8, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.MIPS, sys.PPC64, sys.S390X)
 	addF("runtime/internal/atomic", "And",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicAnd32, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.MIPS, sys.PPC64, sys.S390X)
 	addF("runtime/internal/atomic", "Or8",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicOr8, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.ARM64, sys.MIPS, sys.PPC64, sys.S390X)
 	addF("runtime/internal/atomic", "Or",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicOr32, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
 		sys.AMD64, sys.MIPS, sys.PPC64, sys.S390X)
 
-	atomicAndOrEmitterARM64 := func(s *state, n ir.Node, args []*ssa.Value, op ssa.Op, typ types.Kind) {
+	atomicAndOrEmitterARM64 := func(s *state, n *ir.CallExpr, args []*ssa.Value, op ssa.Op, typ types.Kind) {
 		s.vars[memVar] = s.newValue3(op, types.TypeMem, args[0], args[1], s.mem())
 	}
 
@@ -3714,52 +3740,52 @@ func init() {
 
 	/******** math ********/
 	addF("math", "Sqrt",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpSqrt, types.Types[types.TFLOAT64], args[0])
 		},
 		sys.I386, sys.AMD64, sys.ARM, sys.ARM64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X, sys.Wasm)
 	addF("math", "Trunc",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpTrunc, types.Types[types.TFLOAT64], args[0])
 		},
 		sys.ARM64, sys.PPC64, sys.S390X, sys.Wasm)
 	addF("math", "Ceil",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpCeil, types.Types[types.TFLOAT64], args[0])
 		},
 		sys.ARM64, sys.PPC64, sys.S390X, sys.Wasm)
 	addF("math", "Floor",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpFloor, types.Types[types.TFLOAT64], args[0])
 		},
 		sys.ARM64, sys.PPC64, sys.S390X, sys.Wasm)
 	addF("math", "Round",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpRound, types.Types[types.TFLOAT64], args[0])
 		},
 		sys.ARM64, sys.PPC64, sys.S390X)
 	addF("math", "RoundToEven",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpRoundToEven, types.Types[types.TFLOAT64], args[0])
 		},
 		sys.ARM64, sys.S390X, sys.Wasm)
 	addF("math", "Abs",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpAbs, types.Types[types.TFLOAT64], args[0])
 		},
 		sys.ARM64, sys.ARM, sys.PPC64, sys.Wasm)
 	addF("math", "Copysign",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue2(ssa.OpCopysign, types.Types[types.TFLOAT64], args[0], args[1])
 		},
 		sys.PPC64, sys.Wasm)
 	addF("math", "FMA",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue3(ssa.OpFMA, types.Types[types.TFLOAT64], args[0], args[1], args[2])
 		},
 		sys.ARM64, sys.PPC64, sys.S390X)
 	addF("math", "FMA",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			if !s.config.UseFMA {
 				s.vars[n] = s.callResult(n, callNormal) // types.Types[TFLOAT64]
 				return s.variable(n, types.Types[types.TFLOAT64])
@@ -3791,7 +3817,7 @@ func init() {
 		},
 		sys.AMD64)
 	addF("math", "FMA",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			if !s.config.UseFMA {
 				s.vars[n] = s.callResult(n, callNormal) // types.Types[TFLOAT64]
 				return s.variable(n, types.Types[types.TFLOAT64])
@@ -3824,8 +3850,8 @@ func init() {
 		},
 		sys.ARM)
 
-	makeRoundAMD64 := func(op ssa.Op) func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
-		return func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+	makeRoundAMD64 := func(op ssa.Op) func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+		return func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			v := s.entryNewValue0A(ssa.OpHasCPUFeature, types.Types[types.TBOOL], x86HasSSE41)
 			b := s.endBlock()
 			b.Kind = ssa.BlockIf
@@ -3867,17 +3893,17 @@ func init() {
 
 	/******** math/bits ********/
 	addF("math/bits", "TrailingZeros64",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpCtz64, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
 	addF("math/bits", "TrailingZeros32",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpCtz32, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
 	addF("math/bits", "TrailingZeros16",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			x := s.newValue1(ssa.OpZeroExt16to32, types.Types[types.TUINT32], args[0])
 			c := s.constInt32(types.Types[types.TUINT32], 1<<16)
 			y := s.newValue2(ssa.OpOr32, types.Types[types.TUINT32], x, c)
@@ -3885,12 +3911,12 @@ func init() {
 		},
 		sys.MIPS)
 	addF("math/bits", "TrailingZeros16",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpCtz16, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.I386, sys.ARM, sys.ARM64, sys.Wasm)
 	addF("math/bits", "TrailingZeros16",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			x := s.newValue1(ssa.OpZeroExt16to64, types.Types[types.TUINT64], args[0])
 			c := s.constInt64(types.Types[types.TUINT64], 1<<16)
 			y := s.newValue2(ssa.OpOr64, types.Types[types.TUINT64], x, c)
@@ -3898,7 +3924,7 @@ func init() {
 		},
 		sys.S390X, sys.PPC64)
 	addF("math/bits", "TrailingZeros8",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			x := s.newValue1(ssa.OpZeroExt8to32, types.Types[types.TUINT32], args[0])
 			c := s.constInt32(types.Types[types.TUINT32], 1<<8)
 			y := s.newValue2(ssa.OpOr32, types.Types[types.TUINT32], x, c)
@@ -3906,12 +3932,12 @@ func init() {
 		},
 		sys.MIPS)
 	addF("math/bits", "TrailingZeros8",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpCtz8, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.ARM, sys.ARM64, sys.Wasm)
 	addF("math/bits", "TrailingZeros8",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			x := s.newValue1(ssa.OpZeroExt8to64, types.Types[types.TUINT64], args[0])
 			c := s.constInt64(types.Types[types.TUINT64], 1<<8)
 			y := s.newValue2(ssa.OpOr64, types.Types[types.TUINT64], x, c)
@@ -3923,17 +3949,17 @@ func init() {
 	// ReverseBytes inlines correctly, no need to intrinsify it.
 	// ReverseBytes16 lowers to a rotate, no need for anything special here.
 	addF("math/bits", "Len64",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpBitLen64, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
 	addF("math/bits", "Len32",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpBitLen32, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.ARM64)
 	addF("math/bits", "Len32",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			if s.config.PtrSize == 4 {
 				return s.newValue1(ssa.OpBitLen32, types.Types[types.TINT], args[0])
 			}
@@ -3942,7 +3968,7 @@ func init() {
 		},
 		sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
 	addF("math/bits", "Len16",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			if s.config.PtrSize == 4 {
 				x := s.newValue1(ssa.OpZeroExt16to32, types.Types[types.TUINT32], args[0])
 				return s.newValue1(ssa.OpBitLen32, types.Types[types.TINT], x)
@@ -3952,12 +3978,12 @@ func init() {
 		},
 		sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
 	addF("math/bits", "Len16",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpBitLen16, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64)
 	addF("math/bits", "Len8",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			if s.config.PtrSize == 4 {
 				x := s.newValue1(ssa.OpZeroExt8to32, types.Types[types.TUINT32], args[0])
 				return s.newValue1(ssa.OpBitLen32, types.Types[types.TINT], x)
@@ -3967,12 +3993,12 @@ func init() {
 		},
 		sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
 	addF("math/bits", "Len8",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpBitLen8, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64)
 	addF("math/bits", "Len",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			if s.config.PtrSize == 4 {
 				return s.newValue1(ssa.OpBitLen32, types.Types[types.TINT], args[0])
 			}
@@ -3981,27 +4007,27 @@ func init() {
 		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X, sys.MIPS, sys.PPC64, sys.Wasm)
 	// LeadingZeros is handled because it trivially calls Len.
 	addF("math/bits", "Reverse64",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpBitRev64, types.Types[types.TINT], args[0])
 		},
 		sys.ARM64)
 	addF("math/bits", "Reverse32",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpBitRev32, types.Types[types.TINT], args[0])
 		},
 		sys.ARM64)
 	addF("math/bits", "Reverse16",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpBitRev16, types.Types[types.TINT], args[0])
 		},
 		sys.ARM64)
 	addF("math/bits", "Reverse8",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpBitRev8, types.Types[types.TINT], args[0])
 		},
 		sys.ARM64)
 	addF("math/bits", "Reverse",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			if s.config.PtrSize == 4 {
 				return s.newValue1(ssa.OpBitRev32, types.Types[types.TINT], args[0])
 			}
@@ -4009,29 +4035,29 @@ func init() {
 		},
 		sys.ARM64)
 	addF("math/bits", "RotateLeft8",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue2(ssa.OpRotateLeft8, types.Types[types.TUINT8], args[0], args[1])
 		},
 		sys.AMD64)
 	addF("math/bits", "RotateLeft16",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue2(ssa.OpRotateLeft16, types.Types[types.TUINT16], args[0], args[1])
 		},
 		sys.AMD64)
 	addF("math/bits", "RotateLeft32",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue2(ssa.OpRotateLeft32, types.Types[types.TUINT32], args[0], args[1])
 		},
 		sys.AMD64, sys.ARM, sys.ARM64, sys.S390X, sys.PPC64, sys.Wasm)
 	addF("math/bits", "RotateLeft64",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue2(ssa.OpRotateLeft64, types.Types[types.TUINT64], args[0], args[1])
 		},
 		sys.AMD64, sys.ARM64, sys.S390X, sys.PPC64, sys.Wasm)
 	alias("math/bits", "RotateLeft", "math/bits", "RotateLeft64", p8...)
 
-	makeOnesCountAMD64 := func(op64 ssa.Op, op32 ssa.Op) func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
-		return func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+	makeOnesCountAMD64 := func(op64 ssa.Op, op32 ssa.Op) func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+		return func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			v := s.entryNewValue0A(ssa.OpHasCPUFeature, types.Types[types.TBOOL], x86HasPOPCNT)
 			b := s.endBlock()
 			b.Kind = ssa.BlockIf
@@ -4066,7 +4092,7 @@ func init() {
 		makeOnesCountAMD64(ssa.OpPopCount64, ssa.OpPopCount64),
 		sys.AMD64)
 	addF("math/bits", "OnesCount64",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpPopCount64, types.Types[types.TINT], args[0])
 		},
 		sys.PPC64, sys.ARM64, sys.S390X, sys.Wasm)
@@ -4074,7 +4100,7 @@ func init() {
 		makeOnesCountAMD64(ssa.OpPopCount32, ssa.OpPopCount32),
 		sys.AMD64)
 	addF("math/bits", "OnesCount32",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpPopCount32, types.Types[types.TINT], args[0])
 		},
 		sys.PPC64, sys.ARM64, sys.S390X, sys.Wasm)
@@ -4082,12 +4108,12 @@ func init() {
 		makeOnesCountAMD64(ssa.OpPopCount16, ssa.OpPopCount16),
 		sys.AMD64)
 	addF("math/bits", "OnesCount16",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpPopCount16, types.Types[types.TINT], args[0])
 		},
 		sys.ARM64, sys.S390X, sys.PPC64, sys.Wasm)
 	addF("math/bits", "OnesCount8",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpPopCount8, types.Types[types.TINT], args[0])
 		},
 		sys.S390X, sys.PPC64, sys.Wasm)
@@ -4095,25 +4121,25 @@ func init() {
 		makeOnesCountAMD64(ssa.OpPopCount64, ssa.OpPopCount32),
 		sys.AMD64)
 	addF("math/bits", "Mul64",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue2(ssa.OpMul64uhilo, types.NewTuple(types.Types[types.TUINT64], types.Types[types.TUINT64]), args[0], args[1])
 		},
 		sys.AMD64, sys.ARM64, sys.PPC64, sys.S390X, sys.MIPS64)
 	alias("math/bits", "Mul", "math/bits", "Mul64", sys.ArchAMD64, sys.ArchARM64, sys.ArchPPC64, sys.ArchS390X, sys.ArchMIPS64, sys.ArchMIPS64LE)
 	addF("math/bits", "Add64",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue3(ssa.OpAdd64carry, types.NewTuple(types.Types[types.TUINT64], types.Types[types.TUINT64]), args[0], args[1], args[2])
 		},
 		sys.AMD64, sys.ARM64, sys.PPC64, sys.S390X)
 	alias("math/bits", "Add", "math/bits", "Add64", sys.ArchAMD64, sys.ArchARM64, sys.ArchPPC64, sys.ArchS390X)
 	addF("math/bits", "Sub64",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue3(ssa.OpSub64borrow, types.NewTuple(types.Types[types.TUINT64], types.Types[types.TUINT64]), args[0], args[1], args[2])
 		},
 		sys.AMD64, sys.ARM64, sys.S390X)
 	alias("math/bits", "Sub", "math/bits", "Sub64", sys.ArchAMD64, sys.ArchARM64, sys.ArchS390X)
 	addF("math/bits", "Div64",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			// check for divide-by-zero/overflow and panic with appropriate message
 			cmpZero := s.newValue2(s.ssaOp(ir.ONE, types.Types[types.TUINT64]), types.Types[types.TBOOL], args[2], s.zeroVal(types.Types[types.TUINT64]))
 			s.check(cmpZero, panicdivide)
@@ -4173,7 +4199,7 @@ func init() {
 
 	/******** math/big ********/
 	add("math/big", "mulWW",
-		func(s *state, n ir.Node, args []*ssa.Value) *ssa.Value {
+		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue2(ssa.OpMul64uhilo, types.NewTuple(types.Types[types.TUINT64], types.Types[types.TUINT64]), args[0], args[1])
 		},
 		sys.ArchAMD64, sys.ArchARM64, sys.ArchPPC64LE, sys.ArchPPC64, sys.ArchS390X)
@@ -4211,7 +4237,7 @@ func findIntrinsic(sym *types.Sym) intrinsicBuilder {
 	return intrinsics[intrinsicKey{thearch.LinkArch.Arch, pkg, fn}]
 }
 
-func isIntrinsicCall(n ir.Node) bool {
+func isIntrinsicCall(n *ir.CallExpr) bool {
 	if n == nil {
 		return false
 	}
@@ -4223,7 +4249,7 @@ func isIntrinsicCall(n ir.Node) bool {
 }
 
 // intrinsicCall converts a call to a recognized intrinsic function into the intrinsic SSA operation.
-func (s *state) intrinsicCall(n ir.Node) *ssa.Value {
+func (s *state) intrinsicCall(n *ir.CallExpr) *ssa.Value {
 	v := findIntrinsic(n.Left().Sym())(s, n, s.intrinsicArgs(n))
 	if ssa.IntrinsicsDebug > 0 {
 		x := v
@@ -4239,13 +4265,14 @@ func (s *state) intrinsicCall(n ir.Node) *ssa.Value {
 }
 
 // intrinsicArgs extracts args from n, evaluates them to SSA values, and returns them.
-func (s *state) intrinsicArgs(n ir.Node) []*ssa.Value {
+func (s *state) intrinsicArgs(n *ir.CallExpr) []*ssa.Value {
 	// Construct map of temps; see comments in s.call about the structure of n.
 	temps := map[ir.Node]*ssa.Value{}
 	for _, a := range n.List().Slice() {
 		if a.Op() != ir.OAS {
 			s.Fatalf("non-assignment as a temp function argument %v", a.Op())
 		}
+		a := a.(*ir.AssignStmt)
 		l, r := a.Left(), a.Right()
 		if l.Op() != ir.ONAME {
 			s.Fatalf("non-ONAME temp function argument %v", a.Op())
@@ -4274,7 +4301,7 @@ func (s *state) intrinsicArgs(n ir.Node) []*ssa.Value {
 // call. We will also record funcdata information on where the args are stored
 // (as well as the deferBits variable), and this will enable us to run the proper
 // defer calls during panics.
-func (s *state) openDeferRecord(n ir.Node) {
+func (s *state) openDeferRecord(n *ir.CallExpr) {
 	// Do any needed expression evaluation for the args (including the
 	// receiver, if any). This may be evaluating something like 'autotmp_3 =
 	// once.mutex'. Such a statement will create a mapping in s.vars[] from
@@ -4296,13 +4323,14 @@ func (s *state) openDeferRecord(n ir.Node) {
 		closureVal := s.expr(fn)
 		closure := s.openDeferSave(nil, fn.Type(), closureVal)
 		opendefer.closureNode = closure.Aux.(*ir.Name)
-		if !(fn.Op() == ir.ONAME && fn.Class() == ir.PFUNC) {
+		if !(fn.Op() == ir.ONAME && fn.(*ir.Name).Class() == ir.PFUNC) {
 			opendefer.closure = closure
 		}
 	} else if n.Op() == ir.OCALLMETH {
 		if fn.Op() != ir.ODOTMETH {
 			base.Fatalf("OCALLMETH: n.Left not an ODOTMETH: %v", fn)
 		}
+		fn := fn.(*ir.SelectorExpr)
 		closureVal := s.getMethodClosure(fn)
 		// We must always store the function value in a stack slot for the
 		// runtime panic code to use. But in the defer exit code, we will
@@ -4313,6 +4341,7 @@ func (s *state) openDeferRecord(n ir.Node) {
 		if fn.Op() != ir.ODOTINTER {
 			base.Fatalf("OCALLINTER: n.Left not an ODOTINTER: %v", fn.Op())
 		}
+		fn := fn.(*ir.SelectorExpr)
 		closure, rcvr := s.getClosureAndRcvr(fn)
 		opendefer.closure = s.openDeferSave(nil, closure.Type, closure)
 		// Important to get the receiver type correct, so it is recognized
@@ -4517,11 +4546,11 @@ func (s *state) openDeferExit() {
 		// use the first call of the last defer exit to compute liveness
 		// for the deferreturn, so we want all stack slots to be live.
 		if r.closureNode != nil {
-			s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, r.closureNode.(*ir.Name), s.mem(), false)
+			s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, r.closureNode, s.mem(), false)
 		}
 		if r.rcvrNode != nil {
 			if r.rcvrNode.Type().HasPointers() {
-				s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, r.rcvrNode.(*ir.Name), s.mem(), false)
+				s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, r.rcvrNode, s.mem(), false)
 			}
 		}
 		for _, argNode := range r.argNodes {
@@ -4535,17 +4564,17 @@ func (s *state) openDeferExit() {
 	}
 }
 
-func (s *state) callResult(n ir.Node, k callKind) *ssa.Value {
+func (s *state) callResult(n *ir.CallExpr, k callKind) *ssa.Value {
 	return s.call(n, k, false)
 }
 
-func (s *state) callAddr(n ir.Node, k callKind) *ssa.Value {
+func (s *state) callAddr(n *ir.CallExpr, k callKind) *ssa.Value {
 	return s.call(n, k, true)
 }
 
 // Calls the function n using the specified call type.
 // Returns the address of the return value (or nil if none).
-func (s *state) call(n ir.Node, k callKind, returnResultAddr bool) *ssa.Value {
+func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Value {
 	s.prevCall = nil
 	var sym *types.Sym     // target symbol (if static)
 	var closure *ssa.Value // ptr to closure to run (if dynamic)
@@ -4569,7 +4598,7 @@ func (s *state) call(n ir.Node, k callKind, returnResultAddr bool) *ssa.Value {
 	switch n.Op() {
 	case ir.OCALLFUNC:
 		testLateExpansion = k != callDeferStack && ssa.LateCallExpansionEnabledWithin(s.f)
-		if k == callNormal && fn.Op() == ir.ONAME && fn.Class() == ir.PFUNC {
+		if k == callNormal && fn.Op() == ir.ONAME && fn.(*ir.Name).Class() == ir.PFUNC {
 			sym = fn.Sym()
 			break
 		}
@@ -4583,6 +4612,7 @@ func (s *state) call(n ir.Node, k callKind, returnResultAddr bool) *ssa.Value {
 		if fn.Op() != ir.ODOTMETH {
 			s.Fatalf("OCALLMETH: n.Left not an ODOTMETH: %v", fn)
 		}
+		fn := fn.(*ir.SelectorExpr)
 		testLateExpansion = k != callDeferStack && ssa.LateCallExpansionEnabledWithin(s.f)
 		if k == callNormal {
 			sym = fn.Sym()
@@ -4595,6 +4625,7 @@ func (s *state) call(n ir.Node, k callKind, returnResultAddr bool) *ssa.Value {
 		if fn.Op() != ir.ODOTINTER {
 			s.Fatalf("OCALLINTER: n.Left not an ODOTINTER: %v", fn.Op())
 		}
+		fn := fn.(*ir.SelectorExpr)
 		testLateExpansion = k != callDeferStack && ssa.LateCallExpansionEnabledWithin(s.f)
 		var iclosure *ssa.Value
 		iclosure, rcvr = s.getClosureAndRcvr(fn)
@@ -4847,7 +4878,7 @@ func (s *state) maybeNilCheckClosure(closure *ssa.Value, k callKind) {
 }
 
 // getMethodClosure returns a value representing the closure for a method call
-func (s *state) getMethodClosure(fn ir.Node) *ssa.Value {
+func (s *state) getMethodClosure(fn *ir.SelectorExpr) *ssa.Value {
 	// Make a name n2 for the function.
 	// fn.Sym might be sync.(*Mutex).Unlock.
 	// Make a PFUNC node out of that, then evaluate it.
@@ -4864,7 +4895,7 @@ func (s *state) getMethodClosure(fn ir.Node) *ssa.Value {
 
 // getClosureAndRcvr returns values for the appropriate closure and receiver of an
 // interface call
-func (s *state) getClosureAndRcvr(fn ir.Node) (*ssa.Value, *ssa.Value) {
+func (s *state) getClosureAndRcvr(fn *ir.SelectorExpr) (*ssa.Value, *ssa.Value) {
 	i := s.expr(fn.Left())
 	itab := s.newValue1(ssa.OpITab, types.Types[types.TUINTPTR], i)
 	s.nilCheck(itab)
@@ -4967,6 +4998,7 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 		p := s.exprPtr(n.Left(), n.Bounded(), n.Pos())
 		return s.newValue1I(ssa.OpOffPtr, t, n.Offset(), p)
 	case ir.OCLOSUREREAD:
+		n := n.(*ir.ClosureReadExpr)
 		return s.newValue1I(ssa.OpOffPtr, t, n.Offset(),
 			s.entryNewValue0(ssa.OpGetClosurePtr, s.f.Config.Types.BytePtr))
 	case ir.OCONVNOP:
@@ -4976,8 +5008,10 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 		addr := s.addr(n.Left())
 		return s.newValue1(ssa.OpCopy, t, addr) // ensure that addr has the right type
 	case ir.OCALLFUNC, ir.OCALLINTER, ir.OCALLMETH:
+		n := n.(*ir.CallExpr)
 		return s.callAddr(n, callNormal)
 	case ir.ODOTTYPE:
+		n := n.(*ir.TypeAssertExpr)
 		v, _ := s.dottype(n, false)
 		if v.Op != ssa.OpLoad {
 			s.Fatalf("dottype of non-load")
@@ -4998,22 +5032,34 @@ func (s *state) canSSA(n ir.Node) bool {
 	if base.Flag.N != 0 {
 		return false
 	}
-	for n.Op() == ir.ODOT || (n.Op() == ir.OINDEX && n.Left().Type().IsArray()) {
-		n = n.Left()
+	for {
+		nn := n
+		if nn.Op() == ir.ODOT {
+			n = nn.Left()
+			continue
+		}
+		if nn.Op() == ir.OINDEX {
+			if nn.Left().Type().IsArray() {
+				n = nn.Left()
+				continue
+			}
+		}
+		break
 	}
 	if n.Op() != ir.ONAME {
 		return false
 	}
-	if n.Name().Addrtaken() {
+	name := n.(*ir.Name)
+	if name.Addrtaken() {
 		return false
 	}
-	if isParamHeapCopy(n) {
+	if isParamHeapCopy(name) {
 		return false
 	}
-	if n.Class() == ir.PAUTOHEAP {
-		s.Fatalf("canSSA of PAUTOHEAP %v", n)
+	if name.Class() == ir.PAUTOHEAP {
+		s.Fatalf("canSSA of PAUTOHEAP %v", name)
 	}
-	switch n.Class() {
+	switch name.Class() {
 	case ir.PEXTERN:
 		return false
 	case ir.PPARAMOUT:
@@ -5031,13 +5077,13 @@ func (s *state) canSSA(n ir.Node) bool {
 			return false
 		}
 	}
-	if n.Class() == ir.PPARAM && n.Sym() != nil && n.Sym().Name == ".this" {
+	if name.Class() == ir.PPARAM && name.Sym() != nil && name.Sym().Name == ".this" {
 		// wrappers generated by genwrapper need to update
 		// the .this pointer in place.
 		// TODO: treat as a PPARAMOUT?
 		return false
 	}
-	return canSSAType(n.Type())
+	return canSSAType(name.Type())
 	// TODO: try to make more variables SSAable?
 }
 
@@ -5736,7 +5782,7 @@ func (s *state) uint32Tofloat(cvttab *u322fcvtTab, n ir.Node, x *ssa.Value, ft,
 }
 
 // referenceTypeBuiltin generates code for the len/cap builtins for maps and channels.
-func (s *state) referenceTypeBuiltin(n ir.Node, x *ssa.Value) *ssa.Value {
+func (s *state) referenceTypeBuiltin(n *ir.UnaryExpr, x *ssa.Value) *ssa.Value {
 	if !n.Left().Type().IsMap() && !n.Left().Type().IsChan() {
 		s.Fatalf("node must be a map or a channel")
 	}
@@ -5893,7 +5939,7 @@ func (s *state) floatToUint(cvttab *f2uCvtTab, n ir.Node, x *ssa.Value, ft, tt *
 // dottype generates SSA for a type assertion node.
 // commaok indicates whether to panic or return a bool.
 // If commaok is false, resok will be nil.
-func (s *state) dottype(n ir.Node, commaok bool) (res, resok *ssa.Value) {
+func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Value) {
 	iface := s.expr(n.Left())   // input interface
 	target := s.expr(n.Right()) // target type
 	byteptr := s.f.Config.Types.BytePtr
@@ -6029,7 +6075,7 @@ func (s *state) dottype(n ir.Node, commaok bool) (res, resok *ssa.Value) {
 	if !commaok {
 		// on failure, panic by calling panicdottype
 		s.startBlock(bFail)
-		taddr := s.expr(n.Right().Right())
+		taddr := s.expr(n.Right().(*ir.AddrExpr).Right())
 		if n.Left().Type().IsEmptyInterface() {
 			s.rtcall(panicdottypeE, false, nil, itab, target, taddr)
 		} else {
@@ -6095,25 +6141,27 @@ func (s *state) dottype(n ir.Node, commaok bool) (res, resok *ssa.Value) {
 }
 
 // variable returns the value of a variable at the current location.
-func (s *state) variable(name ir.Node, t *types.Type) *ssa.Value {
-	v := s.vars[name]
+func (s *state) variable(n ir.Node, t *types.Type) *ssa.Value {
+	v := s.vars[n]
 	if v != nil {
 		return v
 	}
-	v = s.fwdVars[name]
+	v = s.fwdVars[n]
 	if v != nil {
 		return v
 	}
 
 	if s.curBlock == s.f.Entry {
 		// No variable should be live at entry.
-		s.Fatalf("Value live at entry. It shouldn't be. func %s, node %v, value %v", s.f.Name, name, v)
+		s.Fatalf("Value live at entry. It shouldn't be. func %s, node %v, value %v", s.f.Name, n, v)
 	}
 	// Make a FwdRef, which records a value that's live on block input.
 	// We'll find the matching definition as part of insertPhis.
-	v = s.newValue0A(ssa.OpFwdRef, t, FwdRefAux{N: name})
-	s.fwdVars[name] = v
-	s.addNamedValue(name, v)
+	v = s.newValue0A(ssa.OpFwdRef, t, FwdRefAux{N: n})
+	s.fwdVars[n] = v
+	if n.Op() == ir.ONAME {
+		s.addNamedValue(n.(*ir.Name), v)
+	}
 	return v
 }
 
@@ -6121,7 +6169,7 @@ func (s *state) mem() *ssa.Value {
 	return s.variable(memVar, types.TypeMem)
 }
 
-func (s *state) addNamedValue(n ir.Node, v *ssa.Value) {
+func (s *state) addNamedValue(n *ir.Name, v *ssa.Value) {
 	if n.Class() == ir.Pxxx {
 		// Don't track our marker nodes (memVar etc.).
 		return
@@ -6174,7 +6222,7 @@ type SSAGenState struct {
 	bstart []*obj.Prog
 
 	// Some architectures require a 64-bit temporary for FP-related register shuffling. Examples include PPC and Sparc V8.
-	ScratchFpMem ir.Node
+	ScratchFpMem *ir.Name
 
 	maxarg int64 // largest frame size for arguments to calls made by the function
 
@@ -6877,9 +6925,9 @@ func CheckLoweredGetClosurePtr(v *ssa.Value) {
 	}
 }
 
-// AutoVar returns a *Node and int64 representing the auto variable and offset within it
+// AutoVar returns a *Name and int64 representing the auto variable and offset within it
 // where v should be spilled.
-func AutoVar(v *ssa.Value) (ir.Node, int64) {
+func AutoVar(v *ssa.Value) (*ir.Name, int64) {
 	loc := v.Block.Func.RegAlloc[v.ID].(ssa.LocalSlot)
 	if v.Type.Size() > loc.Type.Size() {
 		v.Fatalf("spill/restore type %s doesn't fit in slot type %s", v.Type, loc.Type)
@@ -6990,7 +7038,7 @@ func (s *SSAGenState) UseArgs(n int64) {
 }
 
 // fieldIdx finds the index of the field referred to by the ODOT node n.
-func fieldIdx(n ir.Node) int {
+func fieldIdx(n *ir.SelectorExpr) int {
 	t := n.Left().Type()
 	f := n.Sym()
 	if !t.IsStruct() {
@@ -7019,7 +7067,7 @@ func fieldIdx(n ir.Node) int {
 type ssafn struct {
 	curfn        *ir.Func
 	strings      map[string]*obj.LSym // map from constant string to data symbols
-	scratchFpMem ir.Node              // temp for floating point register / memory moves on some architectures
+	scratchFpMem *ir.Name             // temp for floating point register / memory moves on some architectures
 	stksize      int64                // stack size for current frame
 	stkptrsize   int64                // prefix of stack containing pointers
 	log          bool                 // print ssa debug to the stdout
@@ -7211,11 +7259,15 @@ func (e *ssafn) MyImportPath() string {
 }
 
 func clobberBase(n ir.Node) ir.Node {
-	if n.Op() == ir.ODOT && n.Left().Type().NumFields() == 1 {
-		return clobberBase(n.Left())
+	if n.Op() == ir.ODOT {
+		if n.Left().Type().NumFields() == 1 {
+			return clobberBase(n.Left())
+		}
 	}
-	if n.Op() == ir.OINDEX && n.Left().Type().IsArray() && n.Left().Type().NumElem() == 1 {
-		return clobberBase(n.Left())
+	if n.Op() == ir.OINDEX {
+		if n.Left().Type().IsArray() && n.Left().Type().NumElem() == 1 {
+			return clobberBase(n.Left())
+		}
 	}
 	return n
 }
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 041eb900c8..cc0b3d847d 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -743,7 +743,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		walkexprlistsafe(n.List().Slice(), init)
 		r = walkexpr(r, init)
 
-		if isIntrinsicCall(r) {
+		if isIntrinsicCall(r.(*ir.CallExpr)) {
 			n.PtrRlist().Set1(r)
 			return n
 		}
-- 
GitLab


From aa55d4e54bec7a3e3781c682f9948e9bf0c1df81 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 10 Dec 2020 18:46:13 -0500
Subject: [PATCH 0248/2400] [dev.regabi] cmd/compile: cleanup for concrete
 types - escape

An automated rewrite will add concrete type assertions after
a test of n.Op(), when n can be safely type-asserted
(meaning, n is not reassigned a different type, n is not reassigned
and then used outside the scope of the type assertion,
and so on).

This sequence of CLs handles the code that the automated
rewrite does not: adding specific types to function arguments,
adjusting code not to call n.Left() etc when n may have multiple
representations, and so on.

This CL focuses on escape.go.

Passes buildall w/ toolstash -cmp.

Change-Id: I3e76e1ef9b72f28e3adad9633929699635d852dd
Reviewed-on: https://go-review.googlesource.com/c/go/+/277924
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/escape.go | 204 ++++++++++++++++++++++----
 1 file changed, 173 insertions(+), 31 deletions(-)

diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 5fce118448..d009a55a96 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -228,6 +228,7 @@ func (e *Escape) walkFunc(fn *ir.Func) {
 	ir.Visit(fn, func(n ir.Node) {
 		switch n.Op() {
 		case ir.OLABEL:
+			n := n.(*ir.LabelStmt)
 			if e.labels == nil {
 				e.labels = make(map[*types.Sym]labelState)
 			}
@@ -236,6 +237,7 @@ func (e *Escape) walkFunc(fn *ir.Func) {
 		case ir.OGOTO:
 			// If we visited the label before the goto,
 			// then this is a looping label.
+			n := n.(*ir.BranchStmt)
 			if e.labels[n.Sym()] == nonlooping {
 				e.labels[n.Sym()] = looping
 			}
@@ -305,15 +307,18 @@ func (e *Escape) stmt(n ir.Node) {
 		// TODO(mdempsky): Handle dead code?
 
 	case ir.OBLOCK:
+		n := n.(*ir.BlockStmt)
 		e.stmts(n.List())
 
 	case ir.ODCL:
 		// Record loop depth at declaration.
+		n := n.(*ir.Decl)
 		if !ir.IsBlank(n.Left()) {
 			e.dcl(n.Left())
 		}
 
 	case ir.OLABEL:
+		n := n.(*ir.LabelStmt)
 		switch e.labels[n.Sym()] {
 		case nonlooping:
 			if base.Flag.LowerM > 2 {
@@ -330,11 +335,13 @@ func (e *Escape) stmt(n ir.Node) {
 		delete(e.labels, n.Sym())
 
 	case ir.OIF:
+		n := n.(*ir.IfStmt)
 		e.discard(n.Left())
 		e.block(n.Body())
 		e.block(n.Rlist())
 
 	case ir.OFOR, ir.OFORUNTIL:
+		n := n.(*ir.ForStmt)
 		e.loopDepth++
 		e.discard(n.Left())
 		e.stmt(n.Right())
@@ -343,6 +350,7 @@ func (e *Escape) stmt(n ir.Node) {
 
 	case ir.ORANGE:
 		// for List = range Right { Nbody }
+		n := n.(*ir.RangeStmt)
 		e.loopDepth++
 		ks := e.addrs(n.List())
 		e.block(n.Body())
@@ -360,11 +368,13 @@ func (e *Escape) stmt(n ir.Node) {
 		e.expr(e.later(k), n.Right())
 
 	case ir.OSWITCH:
+		n := n.(*ir.SwitchStmt)
 		typesw := n.Left() != nil && n.Left().Op() == ir.OTYPESW
 
 		var ks []EscHole
 		for _, cas := range n.List().Slice() { // cases
-			if typesw && n.Left().Left() != nil {
+			cas := cas.(*ir.CaseStmt)
+			if typesw && n.Left().(*ir.TypeSwitchGuard).Left() != nil {
 				cv := cas.Rlist().First()
 				k := e.dcl(cv) // type switch variables have no ODCL.
 				if cv.Type().HasPointers() {
@@ -377,50 +387,65 @@ func (e *Escape) stmt(n ir.Node) {
 		}
 
 		if typesw {
-			e.expr(e.teeHole(ks...), n.Left().Right())
+			e.expr(e.teeHole(ks...), n.Left().(*ir.TypeSwitchGuard).Right())
 		} else {
 			e.discard(n.Left())
 		}
 
 	case ir.OSELECT:
+		n := n.(*ir.SelectStmt)
 		for _, cas := range n.List().Slice() {
+			cas := cas.(*ir.CaseStmt)
 			e.stmt(cas.Left())
 			e.block(cas.Body())
 		}
 	case ir.OSELRECV:
+		n := n.(*ir.AssignStmt)
 		e.assign(n.Left(), n.Right(), "selrecv", n)
 	case ir.OSELRECV2:
+		n := n.(*ir.AssignListStmt)
 		e.assign(n.List().First(), n.Rlist().First(), "selrecv", n)
 		e.assign(n.List().Second(), nil, "selrecv", n)
 	case ir.ORECV:
 		// TODO(mdempsky): Consider e.discard(n.Left).
+		n := n.(*ir.UnaryExpr)
 		e.exprSkipInit(e.discardHole(), n) // already visited n.Ninit
 	case ir.OSEND:
+		n := n.(*ir.SendStmt)
 		e.discard(n.Left())
 		e.assignHeap(n.Right(), "send", n)
 
-	case ir.OAS, ir.OASOP:
+	case ir.OAS:
+		n := n.(*ir.AssignStmt)
+		e.assign(n.Left(), n.Right(), "assign", n)
+	case ir.OASOP:
+		n := n.(*ir.AssignOpStmt)
 		e.assign(n.Left(), n.Right(), "assign", n)
-
 	case ir.OAS2:
+		n := n.(*ir.AssignListStmt)
 		for i, nl := range n.List().Slice() {
 			e.assign(nl, n.Rlist().Index(i), "assign-pair", n)
 		}
 
 	case ir.OAS2DOTTYPE: // v, ok = x.(type)
+		n := n.(*ir.AssignListStmt)
 		e.assign(n.List().First(), n.Rlist().First(), "assign-pair-dot-type", n)
 		e.assign(n.List().Second(), nil, "assign-pair-dot-type", n)
 	case ir.OAS2MAPR: // v, ok = m[k]
+		n := n.(*ir.AssignListStmt)
 		e.assign(n.List().First(), n.Rlist().First(), "assign-pair-mapr", n)
 		e.assign(n.List().Second(), nil, "assign-pair-mapr", n)
 	case ir.OAS2RECV: // v, ok = <-ch
+		n := n.(*ir.AssignListStmt)
 		e.assign(n.List().First(), n.Rlist().First(), "assign-pair-receive", n)
 		e.assign(n.List().Second(), nil, "assign-pair-receive", n)
 
 	case ir.OAS2FUNC:
+		n := n.(*ir.AssignListStmt)
 		e.stmts(n.Rlist().First().Init())
 		e.call(e.addrs(n.List()), n.Rlist().First(), nil)
 	case ir.ORETURN:
+		n := n.(*ir.ReturnStmt)
 		results := e.curfn.Type().Results().FieldSlice()
 		for i, v := range n.List().Slice() {
 			e.assign(ir.AsNode(results[i].Nname), v, "return", n)
@@ -428,6 +453,7 @@ func (e *Escape) stmt(n ir.Node) {
 	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER, ir.OCLOSE, ir.OCOPY, ir.ODELETE, ir.OPANIC, ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
 		e.call(nil, n, nil)
 	case ir.OGO, ir.ODEFER:
+		n := n.(*ir.GoDeferStmt)
 		e.stmts(n.Left().Init())
 		e.call(nil, n.Left(), n)
 
@@ -472,7 +498,7 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 	uintptrEscapesHack := k.uintptrEscapesHack
 	k.uintptrEscapesHack = false
 
-	if uintptrEscapesHack && n.Op() == ir.OCONVNOP && n.Left().Type().IsUnsafePtr() {
+	if uintptrEscapesHack && n.Op() == ir.OCONVNOP && n.(*ir.ConvExpr).Left().Type().IsUnsafePtr() {
 		// nop
 	} else if k.derefs >= 0 && !n.Type().HasPointers() {
 		k = e.discardHole()
@@ -486,28 +512,40 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 		// nop
 
 	case ir.ONAME:
+		n := n.(*ir.Name)
 		if n.Class() == ir.PFUNC || n.Class() == ir.PEXTERN {
 			return
 		}
 		e.flow(k, e.oldLoc(n))
 
 	case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT:
+		n := n.(*ir.UnaryExpr)
 		e.discard(n.Left())
-	case ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.ODIV, ir.OMOD, ir.OLSH, ir.ORSH, ir.OAND, ir.OANDNOT, ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE, ir.OANDAND, ir.OOROR:
+	case ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.ODIV, ir.OMOD, ir.OLSH, ir.ORSH, ir.OAND, ir.OANDNOT, ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
+		n := n.(*ir.BinaryExpr)
+		e.discard(n.Left())
+		e.discard(n.Right())
+	case ir.OANDAND, ir.OOROR:
+		n := n.(*ir.LogicalExpr)
 		e.discard(n.Left())
 		e.discard(n.Right())
-
 	case ir.OADDR:
+		n := n.(*ir.AddrExpr)
 		e.expr(k.addr(n, "address-of"), n.Left()) // "address-of"
 	case ir.ODEREF:
+		n := n.(*ir.StarExpr)
 		e.expr(k.deref(n, "indirection"), n.Left()) // "indirection"
 	case ir.ODOT, ir.ODOTMETH, ir.ODOTINTER:
+		n := n.(*ir.SelectorExpr)
 		e.expr(k.note(n, "dot"), n.Left())
 	case ir.ODOTPTR:
+		n := n.(*ir.SelectorExpr)
 		e.expr(k.deref(n, "dot of pointer"), n.Left()) // "dot of pointer"
 	case ir.ODOTTYPE, ir.ODOTTYPE2:
+		n := n.(*ir.TypeAssertExpr)
 		e.expr(k.dotType(n.Type(), n, "dot"), n.Left())
 	case ir.OINDEX:
+		n := n.(*ir.IndexExpr)
 		if n.Left().Type().IsArray() {
 			e.expr(k.note(n, "fixed-array-index-of"), n.Left())
 		} else {
@@ -516,9 +554,11 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 		}
 		e.discard(n.Right())
 	case ir.OINDEXMAP:
+		n := n.(*ir.IndexExpr)
 		e.discard(n.Left())
 		e.discard(n.Right())
 	case ir.OSLICE, ir.OSLICEARR, ir.OSLICE3, ir.OSLICE3ARR, ir.OSLICESTR:
+		n := n.(*ir.SliceExpr)
 		e.expr(k.note(n, "slice"), n.Left())
 		low, high, max := n.SliceBounds()
 		e.discard(low)
@@ -526,6 +566,7 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 		e.discard(max)
 
 	case ir.OCONV, ir.OCONVNOP:
+		n := n.(*ir.ConvExpr)
 		if checkPtr(e.curfn, 2) && n.Type().IsUnsafePtr() && n.Left().Type().IsPtr() {
 			// When -d=checkptr=2 is enabled, treat
 			// conversions to unsafe.Pointer as an
@@ -540,27 +581,33 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 			e.expr(k, n.Left())
 		}
 	case ir.OCONVIFACE:
+		n := n.(*ir.ConvExpr)
 		if !n.Left().Type().IsInterface() && !isdirectiface(n.Left().Type()) {
 			k = e.spill(k, n)
 		}
 		e.expr(k.note(n, "interface-converted"), n.Left())
 
 	case ir.ORECV:
+		n := n.(*ir.UnaryExpr)
 		e.discard(n.Left())
 
 	case ir.OCALLMETH, ir.OCALLFUNC, ir.OCALLINTER, ir.OLEN, ir.OCAP, ir.OCOMPLEX, ir.OREAL, ir.OIMAG, ir.OAPPEND, ir.OCOPY:
 		e.call([]EscHole{k}, n, nil)
 
 	case ir.ONEW:
+		n := n.(*ir.UnaryExpr)
 		e.spill(k, n)
 
 	case ir.OMAKESLICE:
+		n := n.(*ir.MakeExpr)
 		e.spill(k, n)
 		e.discard(n.Left())
 		e.discard(n.Right())
 	case ir.OMAKECHAN:
+		n := n.(*ir.MakeExpr)
 		e.discard(n.Left())
 	case ir.OMAKEMAP:
+		n := n.(*ir.MakeExpr)
 		e.spill(k, n)
 		e.discard(n.Left())
 
@@ -571,6 +618,7 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 		// Flow the receiver argument to both the closure and
 		// to the receiver parameter.
 
+		n := n.(*ir.CallPartExpr)
 		closureK := e.spill(k, n)
 
 		m := callpartMethod(n)
@@ -591,37 +639,43 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 		e.expr(e.teeHole(paramK, closureK), n.Left())
 
 	case ir.OPTRLIT:
+		n := n.(*ir.AddrExpr)
 		e.expr(e.spill(k, n), n.Left())
 
 	case ir.OARRAYLIT:
+		n := n.(*ir.CompLitExpr)
 		for _, elt := range n.List().Slice() {
 			if elt.Op() == ir.OKEY {
-				elt = elt.Right()
+				elt = elt.(*ir.KeyExpr).Right()
 			}
 			e.expr(k.note(n, "array literal element"), elt)
 		}
 
 	case ir.OSLICELIT:
+		n := n.(*ir.CompLitExpr)
 		k = e.spill(k, n)
 		k.uintptrEscapesHack = uintptrEscapesHack // for ...uintptr parameters
 
 		for _, elt := range n.List().Slice() {
 			if elt.Op() == ir.OKEY {
-				elt = elt.Right()
+				elt = elt.(*ir.KeyExpr).Right()
 			}
 			e.expr(k.note(n, "slice-literal-element"), elt)
 		}
 
 	case ir.OSTRUCTLIT:
+		n := n.(*ir.CompLitExpr)
 		for _, elt := range n.List().Slice() {
-			e.expr(k.note(n, "struct literal element"), elt.Left())
+			e.expr(k.note(n, "struct literal element"), elt.(*ir.StructKeyExpr).Left())
 		}
 
 	case ir.OMAPLIT:
+		n := n.(*ir.CompLitExpr)
 		e.spill(k, n)
 
 		// Map keys and values are always stored in the heap.
 		for _, elt := range n.List().Slice() {
+			elt := elt.(*ir.KeyExpr)
 			e.assignHeap(elt.Left(), "map literal key", n)
 			e.assignHeap(elt.Right(), "map literal value", n)
 		}
@@ -640,10 +694,12 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 		}
 
 	case ir.ORUNES2STR, ir.OBYTES2STR, ir.OSTR2RUNES, ir.OSTR2BYTES, ir.ORUNESTR:
+		n := n.(*ir.ConvExpr)
 		e.spill(k, n)
 		e.discard(n.Left())
 
 	case ir.OADDSTR:
+		n := n.(*ir.AddStringExpr)
 		e.spill(k, n)
 
 		// Arguments of OADDSTR never escape;
@@ -663,23 +719,28 @@ func (e *Escape) unsafeValue(k EscHole, n ir.Node) {
 
 	switch n.Op() {
 	case ir.OCONV, ir.OCONVNOP:
+		n := n.(*ir.ConvExpr)
 		if n.Left().Type().IsUnsafePtr() {
 			e.expr(k, n.Left())
 		} else {
 			e.discard(n.Left())
 		}
 	case ir.ODOTPTR:
+		n := n.(*ir.SelectorExpr)
 		if isReflectHeaderDataField(n) {
 			e.expr(k.deref(n, "reflect.Header.Data"), n.Left())
 		} else {
 			e.discard(n.Left())
 		}
 	case ir.OPLUS, ir.ONEG, ir.OBITNOT:
+		n := n.(*ir.UnaryExpr)
 		e.unsafeValue(k, n.Left())
 	case ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.ODIV, ir.OMOD, ir.OAND, ir.OANDNOT:
+		n := n.(*ir.BinaryExpr)
 		e.unsafeValue(k, n.Left())
 		e.unsafeValue(k, n.Right())
 	case ir.OLSH, ir.ORSH:
+		n := n.(*ir.BinaryExpr)
 		e.unsafeValue(k, n.Left())
 		// RHS need not be uintptr-typed (#32959) and can't meaningfully
 		// flow pointers anyway.
@@ -715,13 +776,16 @@ func (e *Escape) addr(n ir.Node) EscHole {
 	default:
 		base.Fatalf("unexpected addr: %v", n)
 	case ir.ONAME:
+		n := n.(*ir.Name)
 		if n.Class() == ir.PEXTERN {
 			break
 		}
 		k = e.oldLoc(n).asHole()
 	case ir.ODOT:
+		n := n.(*ir.SelectorExpr)
 		k = e.addr(n.Left())
 	case ir.OINDEX:
+		n := n.(*ir.IndexExpr)
 		e.discard(n.Right())
 		if n.Left().Type().IsArray() {
 			k = e.addr(n.Left())
@@ -731,6 +795,7 @@ func (e *Escape) addr(n ir.Node) EscHole {
 	case ir.ODEREF, ir.ODOTPTR:
 		e.discard(n)
 	case ir.OINDEXMAP:
+		n := n.(*ir.IndexExpr)
 		e.discard(n.Left())
 		e.assignHeap(n.Right(), "key of map put", n)
 	}
@@ -803,6 +868,7 @@ func (e *Escape) call(ks []EscHole, call, where ir.Node) {
 		base.Fatalf("unexpected call op: %v", call.Op())
 
 	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
+		call := call.(*ir.CallExpr)
 		fixVariadicCall(call)
 
 		// Pick out the function callee, if statically known.
@@ -810,7 +876,7 @@ func (e *Escape) call(ks []EscHole, call, where ir.Node) {
 		switch call.Op() {
 		case ir.OCALLFUNC:
 			switch v := staticValue(call.Left()); {
-			case v.Op() == ir.ONAME && v.Class() == ir.PFUNC:
+			case v.Op() == ir.ONAME && v.(*ir.Name).Class() == ir.PFUNC:
 				fn = v.(*ir.Name)
 			case v.Op() == ir.OCLOSURE:
 				fn = v.Func().Nname
@@ -831,7 +897,7 @@ func (e *Escape) call(ks []EscHole, call, where ir.Node) {
 		}
 
 		if r := fntype.Recv(); r != nil {
-			argument(e.tagHole(ks, fn, r), call.Left().Left())
+			argument(e.tagHole(ks, fn, r), call.Left().(*ir.SelectorExpr).Left())
 		} else {
 			// Evaluate callee function expression.
 			argument(e.discardHole(), call.Left())
@@ -843,6 +909,7 @@ func (e *Escape) call(ks []EscHole, call, where ir.Node) {
 		}
 
 	case ir.OAPPEND:
+		call := call.(*ir.CallExpr)
 		args := call.List().Slice()
 
 		// Appendee slice may flow directly to the result, if
@@ -868,6 +935,7 @@ func (e *Escape) call(ks []EscHole, call, where ir.Node) {
 		}
 
 	case ir.OCOPY:
+		call := call.(*ir.BinaryExpr)
 		argument(e.discardHole(), call.Left())
 
 		copiedK := e.discardHole()
@@ -877,16 +945,20 @@ func (e *Escape) call(ks []EscHole, call, where ir.Node) {
 		argument(copiedK, call.Right())
 
 	case ir.OPANIC:
+		call := call.(*ir.UnaryExpr)
 		argument(e.heapHole(), call.Left())
 
 	case ir.OCOMPLEX:
+		call := call.(*ir.BinaryExpr)
 		argument(e.discardHole(), call.Left())
 		argument(e.discardHole(), call.Right())
 	case ir.ODELETE, ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
+		call := call.(*ir.CallExpr)
 		for _, arg := range call.List().Slice() {
 			argument(e.discardHole(), arg)
 		}
 	case ir.OLEN, ir.OCAP, ir.OREAL, ir.OIMAG, ir.OCLOSE:
+		call := call.(*ir.UnaryExpr)
 		argument(e.discardHole(), call.Left())
 	}
 }
@@ -1082,6 +1154,7 @@ func (e *Escape) newLoc(n ir.Node, transient bool) *EscLocation {
 	e.allLocs = append(e.allLocs, loc)
 	if n != nil {
 		if n.Op() == ir.ONAME && n.Name().Curfn != e.curfn {
+			n := n.(*ir.Name)
 			base.Fatalf("curfn mismatch: %v != %v", n.Name().Curfn, e.curfn)
 		}
 
@@ -1466,14 +1539,24 @@ func (e *Escape) finish(fns []*ir.Func) {
 			}
 			n.SetEsc(EscNone)
 			if loc.transient {
-				n.SetTransient(true)
+				switch n.Op() {
+				case ir.OCLOSURE:
+					n := n.(*ir.ClosureExpr)
+					n.SetTransient(true)
+				case ir.OCALLPART:
+					n := n.(*ir.CallPartExpr)
+					n.SetTransient(true)
+				case ir.OSLICELIT:
+					n := n.(*ir.CompLitExpr)
+					n.SetTransient(true)
+				}
 			}
 		}
 	}
 }
 
 func (l *EscLocation) isName(c ir.Class) bool {
-	return l.n != nil && l.n.Op() == ir.ONAME && l.n.Class() == c
+	return l.n != nil && l.n.Op() == ir.ONAME && l.n.(*ir.Name).Class() == c
 }
 
 const numEscResults = 7
@@ -1636,7 +1719,18 @@ func isSliceSelfAssign(dst, src ir.Node) bool {
 	// when we evaluate it for dst and for src.
 
 	// dst is ONAME dereference.
-	if dst.Op() != ir.ODEREF && dst.Op() != ir.ODOTPTR || dst.Left().Op() != ir.ONAME {
+	var dstX ir.Node
+	switch dst.Op() {
+	default:
+		return false
+	case ir.ODEREF:
+		dst := dst.(*ir.StarExpr)
+		dstX = dst.Left()
+	case ir.ODOTPTR:
+		dst := dst.(*ir.SelectorExpr)
+		dstX = dst.Left()
+	}
+	if dstX.Op() != ir.ONAME {
 		return false
 	}
 	// src is a slice operation.
@@ -1653,6 +1747,7 @@ func isSliceSelfAssign(dst, src ir.Node) bool {
 		// Pointer to an array is OK since it's not stored inside b directly.
 		// For slicing an array (not pointer to array), there is an implicit OADDR.
 		// We check that to determine non-pointer array slicing.
+		src := src.(*ir.SliceExpr)
 		if src.Left().Op() == ir.OADDR {
 			return false
 		}
@@ -1660,11 +1755,22 @@ func isSliceSelfAssign(dst, src ir.Node) bool {
 		return false
 	}
 	// slice is applied to ONAME dereference.
-	if src.Left().Op() != ir.ODEREF && src.Left().Op() != ir.ODOTPTR || src.Left().Left().Op() != ir.ONAME {
+	var baseX ir.Node
+	switch base := src.(*ir.SliceExpr).Left(); base.Op() {
+	default:
+		return false
+	case ir.ODEREF:
+		base := base.(*ir.StarExpr)
+		baseX = base.Left()
+	case ir.ODOTPTR:
+		base := base.(*ir.SelectorExpr)
+		baseX = base.Left()
+	}
+	if baseX.Op() != ir.ONAME {
 		return false
 	}
 	// dst and src reference the same base ONAME.
-	return dst.Left() == src.Left().Left()
+	return dstX.(*ir.Name) == baseX.(*ir.Name)
 }
 
 // isSelfAssign reports whether assignment from src to dst can
@@ -1688,19 +1794,23 @@ func isSelfAssign(dst, src ir.Node) bool {
 		return false
 	}
 
+	// The expression prefix must be both "safe" and identical.
 	switch dst.Op() {
 	case ir.ODOT, ir.ODOTPTR:
 		// Safe trailing accessors that are permitted to differ.
+		dst := dst.(*ir.SelectorExpr)
+		src := src.(*ir.SelectorExpr)
+		return samesafeexpr(dst.Left(), src.Left())
 	case ir.OINDEX:
+		dst := dst.(*ir.IndexExpr)
+		src := src.(*ir.IndexExpr)
 		if mayAffectMemory(dst.Right()) || mayAffectMemory(src.Right()) {
 			return false
 		}
+		return samesafeexpr(dst.Left(), src.Left())
 	default:
 		return false
 	}
-
-	// The expression prefix must be both "safe" and identical.
-	return samesafeexpr(dst.Left(), src.Left())
 }
 
 // mayAffectMemory reports whether evaluation of n may affect the program's
@@ -1713,17 +1823,36 @@ func mayAffectMemory(n ir.Node) bool {
 	//
 	// We're ignoring things like division by zero, index out of range,
 	// and nil pointer dereference here.
+
+	// TODO(rsc): It seems like it should be possible to replace this with
+	// an ir.Any looking for any op that's not the ones in the case statement.
+	// But that produces changes in the compiled output detected by buildall.
 	switch n.Op() {
 	case ir.ONAME, ir.OCLOSUREREAD, ir.OLITERAL, ir.ONIL:
 		return false
 
-	// Left+Right group.
-	case ir.OINDEX, ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.OLSH, ir.ORSH, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OMOD:
+	case ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.OLSH, ir.ORSH, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OMOD:
+		n := n.(*ir.BinaryExpr)
+		return mayAffectMemory(n.Left()) || mayAffectMemory(n.Right())
+
+	case ir.OINDEX:
+		n := n.(*ir.IndexExpr)
 		return mayAffectMemory(n.Left()) || mayAffectMemory(n.Right())
 
-	// Left group.
-	case ir.ODOT, ir.ODOTPTR, ir.ODEREF, ir.OCONVNOP, ir.OCONV, ir.OLEN, ir.OCAP,
-		ir.ONOT, ir.OBITNOT, ir.OPLUS, ir.ONEG, ir.OALIGNOF, ir.OOFFSETOF, ir.OSIZEOF:
+	case ir.OCONVNOP, ir.OCONV:
+		n := n.(*ir.ConvExpr)
+		return mayAffectMemory(n.Left())
+
+	case ir.OLEN, ir.OCAP, ir.ONOT, ir.OBITNOT, ir.OPLUS, ir.ONEG, ir.OALIGNOF, ir.OOFFSETOF, ir.OSIZEOF:
+		n := n.(*ir.UnaryExpr)
+		return mayAffectMemory(n.Left())
+
+	case ir.ODOT, ir.ODOTPTR:
+		n := n.(*ir.SelectorExpr)
+		return mayAffectMemory(n.Left())
+
+	case ir.ODEREF:
+		n := n.(*ir.StarExpr)
 		return mayAffectMemory(n.Left())
 
 	default:
@@ -1739,8 +1868,11 @@ func heapAllocReason(n ir.Node) string {
 	}
 
 	// Parameters are always passed via the stack.
-	if n.Op() == ir.ONAME && (n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT) {
-		return ""
+	if n.Op() == ir.ONAME {
+		n := n.(*ir.Name)
+		if n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT {
+			return ""
+		}
 	}
 
 	if n.Type().Width > maxStackVarSize {
@@ -1754,11 +1886,12 @@ func heapAllocReason(n ir.Node) string {
 	if n.Op() == ir.OCLOSURE && closureType(n).Size() >= maxImplicitStackVarSize {
 		return "too large for stack"
 	}
-	if n.Op() == ir.OCALLPART && partialCallType(n).Size() >= maxImplicitStackVarSize {
+	if n.Op() == ir.OCALLPART && partialCallType(n.(*ir.CallPartExpr)).Size() >= maxImplicitStackVarSize {
 		return "too large for stack"
 	}
 
 	if n.Op() == ir.OMAKESLICE {
+		n := n.(*ir.MakeExpr)
 		r := n.Right()
 		if r == nil {
 			r = n.Left()
@@ -1833,10 +1966,20 @@ func addrescapes(n ir.Node) {
 	// In &x[0], if x is a slice, then x does not
 	// escape--the pointer inside x does, but that
 	// is always a heap pointer anyway.
-	case ir.ODOT, ir.OINDEX, ir.OPAREN, ir.OCONVNOP:
+	case ir.ODOT:
+		n := n.(*ir.SelectorExpr)
+		addrescapes(n.Left())
+	case ir.OINDEX:
+		n := n.(*ir.IndexExpr)
 		if !n.Left().Type().IsSlice() {
 			addrescapes(n.Left())
 		}
+	case ir.OPAREN:
+		n := n.(*ir.ParenExpr)
+		addrescapes(n.Left())
+	case ir.OCONVNOP:
+		n := n.(*ir.ConvExpr)
+		addrescapes(n.Left())
 	}
 }
 
@@ -1857,7 +2000,6 @@ func moveToHeap(n *ir.Name) {
 	// temp will add it to the function declaration list automatically.
 	heapaddr := temp(types.NewPtr(n.Type()))
 	heapaddr.SetSym(lookup("&" + n.Sym().Name))
-	ir.Orig(heapaddr).SetSym(heapaddr.Sym())
 	heapaddr.SetPos(n.Pos())
 
 	// Unset AutoTemp to persist the &foo variable name through SSA to
@@ -1933,7 +2075,7 @@ const unsafeUintptrTag = "unsafe-uintptr"
 // marked go:uintptrescapes.
 const uintptrEscapesTag = "uintptr-escapes"
 
-func (e *Escape) paramTag(fn ir.Node, narg int, f *types.Field) string {
+func (e *Escape) paramTag(fn *ir.Func, narg int, f *types.Field) string {
 	name := func() string {
 		if f.Sym != nil {
 			return f.Sym.Name
-- 
GitLab


From 5fe64298a4a00a7fa1655e9ebffbec7a704eb554 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 10 Dec 2020 18:46:29 -0500
Subject: [PATCH 0249/2400] [dev.regabi] cmd/compile: cleanup for concrete
 types - import/export

An automated rewrite will add concrete type assertions after
a test of n.Op(), when n can be safely type-asserted
(meaning, n is not reassigned a different type, n is not reassigned
and then used outside the scope of the type assertion,
and so on).

This sequence of CLs handles the code that the automated
rewrite does not: adding specific types to function arguments,
adjusting code not to call n.Left() etc when n may have multiple
representations, and so on.

This CL focuses on iimport.go and iexport.go.

Passes buildall w/ toolstash -cmp.

Change-Id: I63edee54991ae5d982e99efa7a2894478d511910
Reviewed-on: https://go-review.googlesource.com/c/go/+/277925
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/bexport.go |   7 +-
 src/cmd/compile/internal/gc/bimport.go |  20 ----
 src/cmd/compile/internal/gc/iexport.go | 151 +++++++++++++++++--------
 src/cmd/compile/internal/gc/iimport.go |  22 ++--
 4 files changed, 122 insertions(+), 78 deletions(-)
 delete mode 100644 src/cmd/compile/internal/gc/bimport.go

diff --git a/src/cmd/compile/internal/gc/bexport.go b/src/cmd/compile/internal/gc/bexport.go
index 43c4ce7150..31fd251c5e 100644
--- a/src/cmd/compile/internal/gc/bexport.go
+++ b/src/cmd/compile/internal/gc/bexport.go
@@ -15,8 +15,11 @@ type exporter struct {
 
 // markObject visits a reachable object.
 func (p *exporter) markObject(n ir.Node) {
-	if n.Op() == ir.ONAME && n.Class() == ir.PFUNC {
-		inlFlood(n.(*ir.Name))
+	if n.Op() == ir.ONAME {
+		n := n.(*ir.Name)
+		if n.Class() == ir.PFUNC {
+			inlFlood(n)
+		}
 	}
 
 	p.markType(n.Type())
diff --git a/src/cmd/compile/internal/gc/bimport.go b/src/cmd/compile/internal/gc/bimport.go
deleted file mode 100644
index 5a7018d8e6..0000000000
--- a/src/cmd/compile/internal/gc/bimport.go
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright 2015 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 gc
-
-import (
-	"cmd/compile/internal/ir"
-	"cmd/compile/internal/types"
-	"cmd/internal/src"
-)
-
-func npos(pos src.XPos, n ir.Node) ir.Node {
-	n.SetPos(pos)
-	return n
-}
-
-func builtinCall(op ir.Op) ir.Node {
-	return ir.Nod(ir.OCALL, mkname(types.BuiltinPkg.Lookup(ir.OpNames[op])), nil)
-}
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index 14356013de..eac9f29e65 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -1069,7 +1069,7 @@ func (w *exportWriter) stmt(n ir.Node) {
 		}
 	}
 
-	switch op := n.Op(); op {
+	switch n.Op() {
 	case ir.OBLOCK:
 		// No OBLOCK in export data.
 		// Inline content into this statement list,
@@ -1084,7 +1084,7 @@ func (w *exportWriter) stmt(n ir.Node) {
 	case ir.ODCL:
 		w.op(ir.ODCL)
 		w.pos(n.Left().Pos())
-		w.localName(n.Left())
+		w.localName(n.Left().(*ir.Name))
 		w.typ(n.Left().Type())
 
 	case ir.OAS:
@@ -1099,9 +1099,10 @@ func (w *exportWriter) stmt(n ir.Node) {
 		}
 
 	case ir.OASOP:
+		n := n.(*ir.AssignOpStmt)
 		w.op(ir.OASOP)
 		w.pos(n.Pos())
-		w.op(n.SubOp())
+		w.op(n.AsOp)
 		w.expr(n.Left())
 		if w.bool(!n.Implicit()) {
 			w.expr(n.Right())
@@ -1122,7 +1123,7 @@ func (w *exportWriter) stmt(n ir.Node) {
 	// 	unreachable - generated by compiler for trampolin routines
 
 	case ir.OGO, ir.ODEFER:
-		w.op(op)
+		w.op(n.Op())
 		w.pos(n.Pos())
 		w.expr(n.Left())
 
@@ -1148,8 +1149,15 @@ func (w *exportWriter) stmt(n ir.Node) {
 		w.expr(n.Right())
 		w.stmtList(n.Body())
 
-	case ir.OSELECT, ir.OSWITCH:
-		w.op(op)
+	case ir.OSELECT:
+		w.op(n.Op())
+		w.pos(n.Pos())
+		w.stmtList(n.Init())
+		w.exprsOrNil(nil, nil) // TODO(rsc): Delete (and fix importer).
+		w.caseList(n)
+
+	case ir.OSWITCH:
+		w.op(n.Op())
 		w.pos(n.Pos())
 		w.stmtList(n.Init())
 		w.exprsOrNil(n.Left(), nil)
@@ -1163,7 +1171,7 @@ func (w *exportWriter) stmt(n ir.Node) {
 		w.pos(n.Pos())
 
 	case ir.OBREAK, ir.OCONTINUE, ir.OGOTO, ir.OLABEL:
-		w.op(op)
+		w.op(n.Op())
 		w.pos(n.Pos())
 		label := ""
 		if sym := n.Sym(); sym != nil {
@@ -1176,19 +1184,34 @@ func (w *exportWriter) stmt(n ir.Node) {
 	}
 }
 
+func isNamedTypeSwitch(n ir.Node) bool {
+	if n.Op() != ir.OSWITCH {
+		return false
+	}
+	sw := n.(*ir.SwitchStmt)
+	if sw.Left() == nil || sw.Left().Op() != ir.OTYPESW {
+		return false
+	}
+	guard := sw.Left().(*ir.TypeSwitchGuard)
+	return guard.Left() != nil
+}
+
 func (w *exportWriter) caseList(sw ir.Node) {
-	namedTypeSwitch := sw.Op() == ir.OSWITCH && sw.Left() != nil && sw.Left().Op() == ir.OTYPESW && sw.Left().Left() != nil
+	namedTypeSwitch := isNamedTypeSwitch(sw)
 
-	cases := sw.List().Slice()
+	var cases []ir.Node
+	if sw.Op() == ir.OSWITCH {
+		cases = sw.(*ir.SwitchStmt).List().Slice()
+	} else {
+		cases = sw.(*ir.SelectStmt).List().Slice()
+	}
 	w.uint64(uint64(len(cases)))
 	for _, cas := range cases {
-		if cas.Op() != ir.OCASE {
-			base.Fatalf("expected OCASE, got %v", cas)
-		}
+		cas := cas.(*ir.CaseStmt)
 		w.pos(cas.Pos())
 		w.stmtList(cas.List())
 		if namedTypeSwitch {
-			w.localName(cas.Rlist().First())
+			w.localName(cas.Rlist().First().(*ir.Name))
 		}
 		w.stmtList(cas.Body())
 	}
@@ -1201,22 +1224,29 @@ func (w *exportWriter) exprList(list ir.Nodes) {
 	w.op(ir.OEND)
 }
 
-func (w *exportWriter) expr(n ir.Node) {
-	// from nodefmt (fmt.go)
-	//
-	// nodefmt reverts nodes back to their original - we don't need to do
-	// it because we are not bound to produce valid Go syntax when exporting
-	//
-	// if (fmtmode != FExp || n.Op != OLITERAL) && n.Orig != nil {
-	// 	n = n.Orig
-	// }
-
-	// from exprfmt (fmt.go)
-	for n.Op() == ir.OPAREN || n.Implicit() && (n.Op() == ir.ODEREF || n.Op() == ir.OADDR || n.Op() == ir.ODOT || n.Op() == ir.ODOTPTR) {
-		n = n.Left()
+func simplifyForExport(n ir.Node) ir.Node {
+	switch n.Op() {
+	case ir.OPAREN:
+		return simplifyForExport(n.Left())
+	case ir.ODEREF:
+		if n.Implicit() {
+			return simplifyForExport(n.Left())
+		}
+	case ir.OADDR:
+		if n.Implicit() {
+			return simplifyForExport(n.Left())
+		}
+	case ir.ODOT, ir.ODOTPTR:
+		if n.Implicit() {
+			return simplifyForExport(n.Left())
+		}
 	}
+	return n
+}
 
-	switch op := n.Op(); op {
+func (w *exportWriter) expr(n ir.Node) {
+	n = simplifyForExport(n)
+	switch n.Op() {
 	// expressions
 	// (somewhat closely following the structure of exprfmt in fmt.go)
 	case ir.ONIL:
@@ -1243,6 +1273,7 @@ func (w *exportWriter) expr(n ir.Node) {
 
 	case ir.ONAME:
 		// Package scope name.
+		n := n.(*ir.Name)
 		if (n.Class() == ir.PEXTERN || n.Class() == ir.PFUNC) && !ir.IsBlank(n) {
 			w.op(ir.ONONAME)
 			w.qualifiedIdent(n)
@@ -1291,7 +1322,7 @@ func (w *exportWriter) expr(n ir.Node) {
 		w.op(ir.OSTRUCTLIT)
 		w.pos(n.Pos())
 		w.typ(n.Type())
-		w.elemList(n.List()) // special handling of field names
+		w.fieldList(n.List()) // special handling of field names
 
 	case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT:
 		w.op(ir.OCOMPLIT)
@@ -1349,7 +1380,7 @@ func (w *exportWriter) expr(n ir.Node) {
 
 	case ir.OCOPY, ir.OCOMPLEX:
 		// treated like other builtin calls (see e.g., OREAL)
-		w.op(op)
+		w.op(n.Op())
 		w.pos(n.Pos())
 		w.expr(n.Left())
 		w.expr(n.Right())
@@ -1361,20 +1392,21 @@ func (w *exportWriter) expr(n ir.Node) {
 		w.expr(n.Left())
 		w.typ(n.Type())
 
-	case ir.OREAL, ir.OIMAG, ir.OAPPEND, ir.OCAP, ir.OCLOSE, ir.ODELETE, ir.OLEN, ir.OMAKE, ir.ONEW, ir.OPANIC, ir.ORECOVER, ir.OPRINT, ir.OPRINTN:
-		w.op(op)
+	case ir.OREAL, ir.OIMAG, ir.OCAP, ir.OCLOSE, ir.OLEN, ir.ONEW, ir.OPANIC:
+		w.op(n.Op())
 		w.pos(n.Pos())
-		if n.Left() != nil {
-			w.expr(n.Left())
-			w.op(ir.OEND)
-		} else {
-			w.exprList(n.List()) // emits terminating OEND
-		}
+		w.expr(n.Left())
+		w.op(ir.OEND)
+
+	case ir.OAPPEND, ir.ODELETE, ir.ORECOVER, ir.OPRINT, ir.OPRINTN:
+		w.op(n.Op())
+		w.pos(n.Pos())
+		w.exprList(n.List()) // emits terminating OEND
 		// only append() calls may contain '...' arguments
-		if op == ir.OAPPEND {
+		if n.Op() == ir.OAPPEND {
 			w.bool(n.IsDDD())
 		} else if n.IsDDD() {
-			base.Fatalf("exporter: unexpected '...' with %v call", op)
+			base.Fatalf("exporter: unexpected '...' with %v call", n.Op())
 		}
 
 	case ir.OCALL, ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER, ir.OGETG:
@@ -1386,15 +1418,13 @@ func (w *exportWriter) expr(n ir.Node) {
 		w.bool(n.IsDDD())
 
 	case ir.OMAKEMAP, ir.OMAKECHAN, ir.OMAKESLICE:
-		w.op(op) // must keep separate from OMAKE for importer
+		w.op(n.Op()) // must keep separate from OMAKE for importer
 		w.pos(n.Pos())
 		w.typ(n.Type())
 		switch {
 		default:
 			// empty list
 			w.op(ir.OEND)
-		case n.List().Len() != 0: // pre-typecheck
-			w.exprList(n.List()) // emits terminating OEND
 		case n.Right() != nil:
 			w.expr(n.Left())
 			w.expr(n.Right())
@@ -1405,15 +1435,37 @@ func (w *exportWriter) expr(n ir.Node) {
 		}
 
 	// unary expressions
-	case ir.OPLUS, ir.ONEG, ir.OADDR, ir.OBITNOT, ir.ODEREF, ir.ONOT, ir.ORECV:
-		w.op(op)
+	case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT, ir.ORECV:
+		w.op(n.Op())
+		w.pos(n.Pos())
+		w.expr(n.Left())
+
+	case ir.OADDR:
+		w.op(n.Op())
 		w.pos(n.Pos())
 		w.expr(n.Left())
 
+	case ir.ODEREF:
+		w.op(n.Op())
+		w.pos(n.Pos())
+		w.expr(n.Left())
+
+	case ir.OSEND:
+		w.op(n.Op())
+		w.pos(n.Pos())
+		w.expr(n.Left())
+		w.expr(n.Right())
+
 	// binary expressions
-	case ir.OADD, ir.OAND, ir.OANDAND, ir.OANDNOT, ir.ODIV, ir.OEQ, ir.OGE, ir.OGT, ir.OLE, ir.OLT,
-		ir.OLSH, ir.OMOD, ir.OMUL, ir.ONE, ir.OOR, ir.OOROR, ir.ORSH, ir.OSEND, ir.OSUB, ir.OXOR:
-		w.op(op)
+	case ir.OADD, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OEQ, ir.OGE, ir.OGT, ir.OLE, ir.OLT,
+		ir.OLSH, ir.OMOD, ir.OMUL, ir.ONE, ir.OOR, ir.ORSH, ir.OSUB, ir.OXOR:
+		w.op(n.Op())
+		w.pos(n.Pos())
+		w.expr(n.Left())
+		w.expr(n.Right())
+
+	case ir.OANDAND, ir.OOROR:
+		w.op(n.Op())
 		w.pos(n.Pos())
 		w.expr(n.Left())
 		w.expr(n.Right())
@@ -1454,15 +1506,16 @@ func (w *exportWriter) exprsOrNil(a, b ir.Node) {
 	}
 }
 
-func (w *exportWriter) elemList(list ir.Nodes) {
+func (w *exportWriter) fieldList(list ir.Nodes) {
 	w.uint64(uint64(list.Len()))
 	for _, n := range list.Slice() {
+		n := n.(*ir.StructKeyExpr)
 		w.selector(n.Sym())
 		w.expr(n.Left())
 	}
 }
 
-func (w *exportWriter) localName(n ir.Node) {
+func (w *exportWriter) localName(n *ir.Name) {
 	// Escape analysis happens after inline bodies are saved, but
 	// we're using the same ONAME nodes, so we might still see
 	// PAUTOHEAP here.
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 1096d7988e..154c4e3a84 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -753,7 +753,7 @@ func (r *importReader) stmtList() []ir.Node {
 }
 
 func (r *importReader) caseList(sw ir.Node) []ir.Node {
-	namedTypeSwitch := sw.Op() == ir.OSWITCH && sw.Left() != nil && sw.Left().Op() == ir.OTYPESW && sw.Left().Left() != nil
+	namedTypeSwitch := isNamedTypeSwitch(sw)
 
 	cases := make([]ir.Node, r.uint64())
 	for i := range cases {
@@ -766,7 +766,7 @@ func (r *importReader) caseList(sw ir.Node) []ir.Node {
 			caseVar := ir.NewNameAt(cas.Pos(), r.ident())
 			declare(caseVar, dclcontext)
 			cas.PtrRlist().Set1(caseVar)
-			caseVar.Defn = sw.Left()
+			caseVar.Defn = sw.(*ir.SwitchStmt).Left()
 		}
 		cas.PtrBody().Set(r.stmtList())
 		cases[i] = cas
@@ -915,14 +915,14 @@ func (r *importReader) node() ir.Node {
 		return n
 
 	case ir.OCOPY, ir.OCOMPLEX, ir.OREAL, ir.OIMAG, ir.OAPPEND, ir.OCAP, ir.OCLOSE, ir.ODELETE, ir.OLEN, ir.OMAKE, ir.ONEW, ir.OPANIC, ir.ORECOVER, ir.OPRINT, ir.OPRINTN:
-		n := npos(r.pos(), builtinCall(op))
+		n := builtinCall(r.pos(), op)
 		n.PtrList().Set(r.exprList())
 		if op == ir.OAPPEND {
 			n.SetIsDDD(r.bool())
 		}
 		return n
 
-	// case OCALL, OCALLFUNC, OCALLMETH, OCALLINTER, OGETG:
+	// case OCALLFUNC, OCALLMETH, OCALLINTER, OGETG:
 	// 	unreachable - mapped to OCALL case below by exporter
 
 	case ir.OCALL:
@@ -934,7 +934,7 @@ func (r *importReader) node() ir.Node {
 		return n
 
 	case ir.OMAKEMAP, ir.OMAKECHAN, ir.OMAKESLICE:
-		n := npos(r.pos(), builtinCall(ir.OMAKE))
+		n := builtinCall(r.pos(), ir.OMAKE)
 		n.PtrList().Append(ir.TypeNode(r.typ()))
 		n.PtrList().Append(r.exprList()...)
 		return n
@@ -1042,8 +1042,7 @@ func (r *importReader) node() ir.Node {
 	case ir.OSELECT:
 		n := ir.NodAt(r.pos(), ir.OSELECT, nil, nil)
 		n.PtrInit().Set(r.stmtList())
-		left, _ := r.exprsOrNil()
-		n.SetLeft(left)
+		r.exprsOrNil() // TODO(rsc): Delete (and fix exporter). These are always nil.
 		n.PtrList().Set(r.caseList(n))
 		return n
 
@@ -1110,3 +1109,12 @@ func (r *importReader) exprsOrNil() (a, b ir.Node) {
 	}
 	return
 }
+
+func builtinCall(pos src.XPos, op ir.Op) *ir.CallExpr {
+	return ir.NewCallExpr(pos, ir.OCALL, mkname(types.BuiltinPkg.Lookup(ir.OpNames[op])), nil)
+}
+
+func npos(pos src.XPos, n ir.Node) ir.Node {
+	n.SetPos(pos)
+	return n
+}
-- 
GitLab


From 389ae3d5ba24ffec3df63e7e6704d813efc3d719 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 10 Dec 2020 18:46:45 -0500
Subject: [PATCH 0250/2400] [dev.regabi] cmd/compile: cleanup for concrete
 types - inl

An automated rewrite will add concrete type assertions after
a test of n.Op(), when n can be safely type-asserted
(meaning, n is not reassigned a different type, n is not reassigned
and then used outside the scope of the type assertion,
and so on).

This sequence of CLs handles the code that the automated
rewrite does not: adding specific types to function arguments,
adjusting code not to call n.Left() etc when n may have multiple
representations, and so on.

This CL focuses on inl.go.

Passes buildall w/ toolstash -cmp.

Change-Id: Iaaee7664cd43e264d9e49d252e3afa7cf719939b
Reviewed-on: https://go-review.googlesource.com/c/go/+/277926
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/inl.go | 155 +++++++++++++++++------------
 1 file changed, 92 insertions(+), 63 deletions(-)

diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 3a19efd325..e940e416fd 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -320,22 +320,26 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 	switch n.Op() {
 	// Call is okay if inlinable and we have the budget for the body.
 	case ir.OCALLFUNC:
+		n := n.(*ir.CallExpr)
 		// Functions that call runtime.getcaller{pc,sp} can not be inlined
 		// because getcaller{pc,sp} expect a pointer to the caller's first argument.
 		//
 		// runtime.throw is a "cheap call" like panic in normal code.
-		if n.Left().Op() == ir.ONAME && n.Left().Class() == ir.PFUNC && isRuntimePkg(n.Left().Sym().Pkg) {
-			fn := n.Left().Sym().Name
-			if fn == "getcallerpc" || fn == "getcallersp" {
-				return errors.New("call to " + fn)
-			}
-			if fn == "throw" {
-				v.budget -= inlineExtraThrowCost
-				break
+		if n.Left().Op() == ir.ONAME {
+			name := n.Left().(*ir.Name)
+			if name.Class() == ir.PFUNC && isRuntimePkg(name.Sym().Pkg) {
+				fn := name.Sym().Name
+				if fn == "getcallerpc" || fn == "getcallersp" {
+					return errors.New("call to " + fn)
+				}
+				if fn == "throw" {
+					v.budget -= inlineExtraThrowCost
+					break
+				}
 			}
 		}
 
-		if isIntrinsicCall(n.(*ir.CallExpr)) {
+		if isIntrinsicCall(n) {
 			// Treat like any other node.
 			break
 		}
@@ -401,11 +405,15 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 		// These nodes don't produce code; omit from inlining budget.
 		return nil
 
-	case ir.OFOR, ir.OFORUNTIL, ir.OSWITCH:
-		// ORANGE, OSELECT in "unhandled" above
+	case ir.OFOR, ir.OFORUNTIL:
 		if n.Sym() != nil {
 			return errors.New("labeled control")
 		}
+	case ir.OSWITCH:
+		if n.Sym() != nil {
+			return errors.New("labeled control")
+		}
+	// case ir.ORANGE, ir.OSELECT in "unhandled" above
 
 	case ir.OBREAK, ir.OCONTINUE:
 		if n.Sym() != nil {
@@ -488,7 +496,7 @@ func inlcalls(fn *ir.Func) {
 }
 
 // Turn an OINLCALL into a statement.
-func inlconv2stmt(inlcall ir.Node) ir.Node {
+func inlconv2stmt(inlcall *ir.InlinedCallExpr) ir.Node {
 	n := ir.NodAt(inlcall.Pos(), ir.OBLOCK, nil, nil)
 	n.SetList(inlcall.Init())
 	n.PtrList().AppendNodes(inlcall.PtrBody())
@@ -498,7 +506,7 @@ func inlconv2stmt(inlcall ir.Node) ir.Node {
 // Turn an OINLCALL into a single valued expression.
 // The result of inlconv2expr MUST be assigned back to n, e.g.
 // 	n.Left = inlconv2expr(n.Left)
-func inlconv2expr(n ir.Node) ir.Node {
+func inlconv2expr(n *ir.InlinedCallExpr) ir.Node {
 	r := n.Rlist().First()
 	return initExpr(append(n.Init().Slice(), n.Body().Slice()...), r)
 }
@@ -508,7 +516,7 @@ func inlconv2expr(n ir.Node) ir.Node {
 // containing the inlined statements on the first list element so
 // order will be preserved. Used in return, oas2func and call
 // statements.
-func inlconv2list(n ir.Node) []ir.Node {
+func inlconv2list(n *ir.InlinedCallExpr) []ir.Node {
 	if n.Op() != ir.OINLCALL || n.Rlist().Len() == 0 {
 		base.Fatalf("inlconv2list %+v\n", n)
 	}
@@ -538,9 +546,9 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.No
 
 	switch n.Op() {
 	case ir.ODEFER, ir.OGO:
-		switch n.Left().Op() {
+		switch call := n.Left(); call.Op() {
 		case ir.OCALLFUNC, ir.OCALLMETH:
-			n.Left().SetNoInline(true)
+			call.SetNoInline(true)
 		}
 
 	// TODO do them here (or earlier),
@@ -559,11 +567,13 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.No
 
 	ir.EditChildren(n, edit)
 
-	if n.Op() == ir.OAS2FUNC && n.Rlist().First().Op() == ir.OINLCALL {
-		n.PtrRlist().Set(inlconv2list(n.Rlist().First()))
-		n.SetOp(ir.OAS2)
-		n.SetTypecheck(0)
-		n = typecheck(n, ctxStmt)
+	if as := n; as.Op() == ir.OAS2FUNC {
+		if as.Rlist().First().Op() == ir.OINLCALL {
+			as.PtrRlist().Set(inlconv2list(as.Rlist().First().(*ir.InlinedCallExpr)))
+			as.SetOp(ir.OAS2)
+			as.SetTypecheck(0)
+			n = typecheck(as, ctxStmt)
+		}
 	}
 
 	// with all the branches out of the way, it is now time to
@@ -576,45 +586,46 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.No
 		}
 	}
 
-	var call ir.Node
+	var call *ir.CallExpr
 	switch n.Op() {
 	case ir.OCALLFUNC:
-		call = n
+		call = n.(*ir.CallExpr)
 		if base.Flag.LowerM > 3 {
-			fmt.Printf("%v:call to func %+v\n", ir.Line(n), n.Left())
+			fmt.Printf("%v:call to func %+v\n", ir.Line(n), call.Left())
 		}
-		if isIntrinsicCall(n.(*ir.CallExpr)) {
+		if isIntrinsicCall(call) {
 			break
 		}
-		if fn := inlCallee(n.Left()); fn != nil && fn.Inl != nil {
-			n = mkinlcall(n, fn, maxCost, inlMap, edit)
+		if fn := inlCallee(call.Left()); fn != nil && fn.Inl != nil {
+			n = mkinlcall(call, fn, maxCost, inlMap, edit)
 		}
 
 	case ir.OCALLMETH:
-		call = n
+		call = n.(*ir.CallExpr)
 		if base.Flag.LowerM > 3 {
-			fmt.Printf("%v:call to meth %L\n", ir.Line(n), n.Left().Right())
+			fmt.Printf("%v:call to meth %v\n", ir.Line(n), call.Left().(*ir.SelectorExpr).Sel)
 		}
 
 		// typecheck should have resolved ODOTMETH->type, whose nname points to the actual function.
-		if n.Left().Type() == nil {
-			base.Fatalf("no function type for [%p] %+v\n", n.Left(), n.Left())
+		if call.Left().Type() == nil {
+			base.Fatalf("no function type for [%p] %+v\n", call.Left(), call.Left())
 		}
 
-		n = mkinlcall(n, methodExprName(n.Left()).Func(), maxCost, inlMap, edit)
+		n = mkinlcall(call, methodExprName(call.Left()).Func(), maxCost, inlMap, edit)
 	}
 
 	base.Pos = lno
 
 	if n.Op() == ir.OINLCALL {
-		switch call.(*ir.CallExpr).Use {
+		ic := n.(*ir.InlinedCallExpr)
+		switch call.Use {
 		default:
 			ir.Dump("call", call)
 			base.Fatalf("call missing use")
 		case ir.CallUseExpr:
-			n = inlconv2expr(n)
+			n = inlconv2expr(ic)
 		case ir.CallUseStmt:
-			n = inlconv2stmt(n)
+			n = inlconv2stmt(ic)
 		case ir.CallUseList:
 			// leave for caller to convert
 		}
@@ -627,8 +638,8 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.No
 // that it refers to if statically known. Otherwise, it returns nil.
 func inlCallee(fn ir.Node) *ir.Func {
 	fn = staticValue(fn)
-	switch {
-	case fn.Op() == ir.OMETHEXPR:
+	switch fn.Op() {
+	case ir.OMETHEXPR:
 		n := methodExprName(fn)
 		// Check that receiver type matches fn.Left.
 		// TODO(mdempsky): Handle implicit dereference
@@ -637,9 +648,11 @@ func inlCallee(fn ir.Node) *ir.Func {
 			return nil
 		}
 		return n.Func()
-	case fn.Op() == ir.ONAME && fn.Class() == ir.PFUNC:
-		return fn.Func()
-	case fn.Op() == ir.OCLOSURE:
+	case ir.ONAME:
+		if fn.Class() == ir.PFUNC {
+			return fn.Func()
+		}
+	case ir.OCLOSURE:
 		c := fn.Func()
 		caninl(c)
 		return c
@@ -650,7 +663,7 @@ func inlCallee(fn ir.Node) *ir.Func {
 func staticValue(n ir.Node) ir.Node {
 	for {
 		if n.Op() == ir.OCONVNOP {
-			n = n.Left()
+			n = n.(*ir.ConvExpr).Left()
 			continue
 		}
 
@@ -665,8 +678,12 @@ func staticValue(n ir.Node) ir.Node {
 // staticValue1 implements a simple SSA-like optimization. If n is a local variable
 // that is initialized and never reassigned, staticValue1 returns the initializer
 // expression. Otherwise, it returns nil.
-func staticValue1(n ir.Node) ir.Node {
-	if n.Op() != ir.ONAME || n.Class() != ir.PAUTO || n.Name().Addrtaken() {
+func staticValue1(nn ir.Node) ir.Node {
+	if nn.Op() != ir.ONAME {
+		return nil
+	}
+	n := nn.(*ir.Name)
+	if n.Class() != ir.PAUTO || n.Name().Addrtaken() {
 		return nil
 	}
 
@@ -695,7 +712,7 @@ FindRHS:
 		base.Fatalf("RHS is nil: %v", defn)
 	}
 
-	if reassigned(n.(*ir.Name)) {
+	if reassigned(n) {
 		return nil
 	}
 
@@ -757,7 +774,7 @@ var inlgen int
 // parameters.
 // The result of mkinlcall MUST be assigned back to n, e.g.
 // 	n.Left = mkinlcall(n.Left, fn, isddd)
-func mkinlcall(n ir.Node, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.Node) ir.Node) ir.Node {
+func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.Node) ir.Node) ir.Node {
 	if fn.Inl == nil {
 		if logopt.Enabled() {
 			logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", ir.FuncName(Curfn),
@@ -830,8 +847,9 @@ func mkinlcall(n ir.Node, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]bool,
 	if n.Op() == ir.OCALLFUNC {
 		callee := n.Left()
 		for callee.Op() == ir.OCONVNOP {
-			ninit.AppendNodes(callee.PtrInit())
-			callee = callee.Left()
+			conv := callee.(*ir.ConvExpr)
+			ninit.AppendNodes(conv.PtrInit())
+			callee = conv.Left()
 		}
 		if callee.Op() != ir.ONAME && callee.Op() != ir.OCLOSURE && callee.Op() != ir.OMETHEXPR {
 			base.Fatalf("unexpected callee expression: %v", callee)
@@ -952,16 +970,17 @@ func mkinlcall(n ir.Node, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]bool,
 	as := ir.Nod(ir.OAS2, nil, nil)
 	as.SetColas(true)
 	if n.Op() == ir.OCALLMETH {
-		if n.Left().Left() == nil {
+		sel := n.Left().(*ir.SelectorExpr)
+		if sel.Left() == nil {
 			base.Fatalf("method call without receiver: %+v", n)
 		}
-		as.PtrRlist().Append(n.Left().Left())
+		as.PtrRlist().Append(sel.Left())
 	}
 	as.PtrRlist().Append(n.List().Slice()...)
 
 	// For non-dotted calls to variadic functions, we assign the
 	// variadic parameter's temp name separately.
-	var vas ir.Node
+	var vas *ir.AssignStmt
 
 	if recv := fn.Type().Recv(); recv != nil {
 		as.PtrList().Append(inlParam(recv, as, inlvars))
@@ -984,14 +1003,15 @@ func mkinlcall(n ir.Node, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]bool,
 		}
 		varargs := as.List().Slice()[x:]
 
-		vas = ir.Nod(ir.OAS, nil, nil)
+		vas = ir.NewAssignStmt(base.Pos, nil, nil)
 		vas.SetLeft(inlParam(param, vas, inlvars))
 		if len(varargs) == 0 {
 			vas.SetRight(nodnil())
 			vas.Right().SetType(param.Type)
 		} else {
-			vas.SetRight(ir.Nod(ir.OCOMPLIT, nil, ir.TypeNode(param.Type)))
-			vas.Right().PtrList().Set(varargs)
+			lit := ir.Nod(ir.OCOMPLIT, nil, ir.TypeNode(param.Type))
+			lit.PtrList().Set(varargs)
+			vas.SetRight(lit)
 		}
 	}
 
@@ -1229,13 +1249,20 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 		typecheckslice(init, ctxStmt)
 		return ir.NewBlockStmt(base.Pos, init)
 
-	case ir.OGOTO, ir.OLABEL:
-		m := ir.Copy(n)
+	case ir.OGOTO:
+		m := ir.Copy(n).(*ir.BranchStmt)
 		m.SetPos(subst.updatedPos(m.Pos()))
 		m.PtrInit().Set(nil)
 		p := fmt.Sprintf("%s·%d", n.Sym().Name, inlgen)
 		m.SetSym(lookup(p))
+		return m
 
+	case ir.OLABEL:
+		m := ir.Copy(n).(*ir.LabelStmt)
+		m.SetPos(subst.updatedPos(m.Pos()))
+		m.PtrInit().Set(nil)
+		p := fmt.Sprintf("%s·%d", n.Sym().Name, inlgen)
+		m.SetSym(lookup(p))
 		return m
 	}
 
@@ -1280,36 +1307,38 @@ func devirtualize(fn *ir.Func) {
 	Curfn = fn
 	ir.VisitList(fn.Body(), func(n ir.Node) {
 		if n.Op() == ir.OCALLINTER {
-			devirtualizeCall(n)
+			devirtualizeCall(n.(*ir.CallExpr))
 		}
 	})
 }
 
-func devirtualizeCall(call ir.Node) {
-	recv := staticValue(call.Left().Left())
-	if recv.Op() != ir.OCONVIFACE {
+func devirtualizeCall(call *ir.CallExpr) {
+	sel := call.Left().(*ir.SelectorExpr)
+	r := staticValue(sel.Left())
+	if r.Op() != ir.OCONVIFACE {
 		return
 	}
+	recv := r.(*ir.ConvExpr)
 
 	typ := recv.Left().Type()
 	if typ.IsInterface() {
 		return
 	}
 
-	dt := ir.NodAt(call.Left().Pos(), ir.ODOTTYPE, call.Left().Left(), nil)
+	dt := ir.NodAt(sel.Pos(), ir.ODOTTYPE, sel.Left(), nil)
 	dt.SetType(typ)
-	x := typecheck(nodlSym(call.Left().Pos(), ir.OXDOT, dt, call.Left().Sym()), ctxExpr|ctxCallee)
+	x := typecheck(nodlSym(sel.Pos(), ir.OXDOT, dt, sel.Sym()), ctxExpr|ctxCallee)
 	switch x.Op() {
 	case ir.ODOTMETH:
 		if base.Flag.LowerM != 0 {
-			base.WarnfAt(call.Pos(), "devirtualizing %v to %v", call.Left(), typ)
+			base.WarnfAt(call.Pos(), "devirtualizing %v to %v", sel, typ)
 		}
 		call.SetOp(ir.OCALLMETH)
 		call.SetLeft(x)
 	case ir.ODOTINTER:
 		// Promoted method from embedded interface-typed field (#42279).
 		if base.Flag.LowerM != 0 {
-			base.WarnfAt(call.Pos(), "partially devirtualizing %v to %v", call.Left(), typ)
+			base.WarnfAt(call.Pos(), "partially devirtualizing %v to %v", sel, typ)
 		}
 		call.SetOp(ir.OCALLINTER)
 		call.SetLeft(x)
-- 
GitLab


From 42fec2ded44a1bedf739dbc2b33f1b144616ec4c Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 10 Dec 2020 18:46:56 -0500
Subject: [PATCH 0251/2400] [dev.regabi] cmd/compile: cleanup for concrete
 types - const

An automated rewrite will add concrete type assertions after
a test of n.Op(), when n can be safely type-asserted
(meaning, n is not reassigned a different type, n is not reassigned
and then used outside the scope of the type assertion,
and so on).

This sequence of CLs handles the code that the automated
rewrite does not: adding specific types to function arguments,
adjusting code not to call n.Left() etc when n may have multiple
representations, and so on.

This CL focuses on const.go.

Passes buildall w/ toolstash -cmp.

Change-Id: I824f18fa0344ddde56df0522f9fa5e237114bbe2
Reviewed-on: https://go-review.googlesource.com/c/go/+/277927
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/const.go | 74 +++++++++++++++++++---------
 1 file changed, 50 insertions(+), 24 deletions(-)

diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 1ef199c793..358eefd9bb 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -162,6 +162,7 @@ func convlit1(n ir.Node, t *types.Type, explicit bool, context func() string) ir
 			break
 		}
 
+		n := n.(*ir.UnaryExpr)
 		n.SetLeft(convlit(n.Left(), ot))
 		if n.Left().Type() == nil {
 			n.SetType(nil)
@@ -177,14 +178,24 @@ func convlit1(n ir.Node, t *types.Type, explicit bool, context func() string) ir
 			break
 		}
 
-		n.SetLeft(convlit(n.Left(), ot))
-		n.SetRight(convlit(n.Right(), ot))
-		if n.Left().Type() == nil || n.Right().Type() == nil {
+		var l, r ir.Node
+		switch n := n.(type) {
+		case *ir.BinaryExpr:
+			n.SetLeft(convlit(n.Left(), ot))
+			n.SetRight(convlit(n.Right(), ot))
+			l, r = n.Left(), n.Right()
+		case *ir.LogicalExpr:
+			n.SetLeft(convlit(n.Left(), ot))
+			n.SetRight(convlit(n.Right(), ot))
+			l, r = n.Left(), n.Right()
+		}
+
+		if l.Type() == nil || r.Type() == nil {
 			n.SetType(nil)
 			return n
 		}
-		if !types.Identical(n.Left().Type(), n.Right().Type()) {
-			base.Errorf("invalid operation: %v (mismatched types %v and %v)", n, n.Left().Type(), n.Right().Type())
+		if !types.Identical(l.Type(), r.Type()) {
+			base.Errorf("invalid operation: %v (mismatched types %v and %v)", n, l.Type(), r.Type())
 			n.SetType(nil)
 			return n
 		}
@@ -435,48 +446,56 @@ var tokenForOp = [...]token.Token{
 // Otherwise, evalConst returns a new OLITERAL with the same value as n,
 // and with .Orig pointing back to n.
 func evalConst(n ir.Node) ir.Node {
-	nl, nr := n.Left(), n.Right()
-
 	// Pick off just the opcodes that can be constant evaluated.
-	switch op := n.Op(); op {
+	switch n.Op() {
 	case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT:
+		nl := n.Left()
 		if nl.Op() == ir.OLITERAL {
 			var prec uint
 			if n.Type().IsUnsigned() {
 				prec = uint(n.Type().Size() * 8)
 			}
-			return origConst(n, constant.UnaryOp(tokenForOp[op], nl.Val(), prec))
+			return origConst(n, constant.UnaryOp(tokenForOp[n.Op()], nl.Val(), prec))
 		}
 
-	case ir.OADD, ir.OSUB, ir.OMUL, ir.ODIV, ir.OMOD, ir.OOR, ir.OXOR, ir.OAND, ir.OANDNOT, ir.OOROR, ir.OANDAND:
+	case ir.OADD, ir.OSUB, ir.OMUL, ir.ODIV, ir.OMOD, ir.OOR, ir.OXOR, ir.OAND, ir.OANDNOT:
+		nl, nr := n.Left(), n.Right()
 		if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
 			rval := nr.Val()
 
 			// check for divisor underflow in complex division (see issue 20227)
-			if op == ir.ODIV && n.Type().IsComplex() && constant.Sign(square(constant.Real(rval))) == 0 && constant.Sign(square(constant.Imag(rval))) == 0 {
+			if n.Op() == ir.ODIV && n.Type().IsComplex() && constant.Sign(square(constant.Real(rval))) == 0 && constant.Sign(square(constant.Imag(rval))) == 0 {
 				base.Errorf("complex division by zero")
 				n.SetType(nil)
 				return n
 			}
-			if (op == ir.ODIV || op == ir.OMOD) && constant.Sign(rval) == 0 {
+			if (n.Op() == ir.ODIV || n.Op() == ir.OMOD) && constant.Sign(rval) == 0 {
 				base.Errorf("division by zero")
 				n.SetType(nil)
 				return n
 			}
 
-			tok := tokenForOp[op]
-			if op == ir.ODIV && n.Type().IsInteger() {
+			tok := tokenForOp[n.Op()]
+			if n.Op() == ir.ODIV && n.Type().IsInteger() {
 				tok = token.QUO_ASSIGN // integer division
 			}
 			return origConst(n, constant.BinaryOp(nl.Val(), tok, rval))
 		}
 
+	case ir.OOROR, ir.OANDAND:
+		nl, nr := n.Left(), n.Right()
+		if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
+			return origConst(n, constant.BinaryOp(nl.Val(), tokenForOp[n.Op()], nr.Val()))
+		}
+
 	case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
+		nl, nr := n.Left(), n.Right()
 		if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
-			return origBoolConst(n, constant.Compare(nl.Val(), tokenForOp[op], nr.Val()))
+			return origBoolConst(n, constant.Compare(nl.Val(), tokenForOp[n.Op()], nr.Val()))
 		}
 
 	case ir.OLSH, ir.ORSH:
+		nl, nr := n.Left(), n.Right()
 		if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
 			// shiftBound from go/types; "so we can express smallestFloat64"
 			const shiftBound = 1023 - 1 + 52
@@ -486,15 +505,17 @@ func evalConst(n ir.Node) ir.Node {
 				n.SetType(nil)
 				break
 			}
-			return origConst(n, constant.Shift(toint(nl.Val()), tokenForOp[op], uint(s)))
+			return origConst(n, constant.Shift(toint(nl.Val()), tokenForOp[n.Op()], uint(s)))
 		}
 
 	case ir.OCONV, ir.ORUNESTR:
+		nl := n.Left()
 		if ir.OKForConst[n.Type().Kind()] && nl.Op() == ir.OLITERAL {
 			return origConst(n, convertVal(nl.Val(), n.Type(), true))
 		}
 
 	case ir.OCONVNOP:
+		nl := n.Left()
 		if ir.OKForConst[n.Type().Kind()] && nl.Op() == ir.OLITERAL {
 			// set so n.Orig gets OCONV instead of OCONVNOP
 			n.SetOp(ir.OCONV)
@@ -532,21 +553,21 @@ func evalConst(n ir.Node) ir.Node {
 					i2++
 				}
 
-				nl := ir.Copy(n)
+				nl := ir.Copy(n).(*ir.AddStringExpr)
 				nl.PtrList().Set(s[i:i2])
-				nl = origConst(nl, constant.MakeString(strings.Join(strs, "")))
-				newList = append(newList, nl)
+				newList = append(newList, origConst(nl, constant.MakeString(strings.Join(strs, ""))))
 				i = i2 - 1
 			} else {
 				newList = append(newList, s[i])
 			}
 		}
 
-		n = ir.Copy(n)
-		n.PtrList().Set(newList)
-		return n
+		nn := ir.Copy(n).(*ir.AddStringExpr)
+		nn.PtrList().Set(newList)
+		return nn
 
 	case ir.OCAP, ir.OLEN:
+		nl := n.Left()
 		switch nl.Type().Kind() {
 		case types.TSTRING:
 			if ir.IsConst(nl, constant.String) {
@@ -562,16 +583,19 @@ func evalConst(n ir.Node) ir.Node {
 		return origIntConst(n, evalunsafe(n))
 
 	case ir.OREAL:
+		nl := n.Left()
 		if nl.Op() == ir.OLITERAL {
 			return origConst(n, constant.Real(nl.Val()))
 		}
 
 	case ir.OIMAG:
+		nl := n.Left()
 		if nl.Op() == ir.OLITERAL {
 			return origConst(n, constant.Imag(nl.Val()))
 		}
 
 	case ir.OCOMPLEX:
+		nl, nr := n.Left(), n.Right()
 		if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
 			return origConst(n, makeComplex(nl.Val(), nr.Val()))
 		}
@@ -829,8 +853,10 @@ type constSetKey struct {
 //
 // n must not be an untyped constant.
 func (s *constSet) add(pos src.XPos, n ir.Node, what, where string) {
-	if n.Op() == ir.OCONVIFACE && n.Implicit() {
-		n = n.Left()
+	if conv := n; conv.Op() == ir.OCONVIFACE {
+		if conv.Implicit() {
+			n = conv.Left()
+		}
 	}
 
 	if !isGoConst(n) {
-- 
GitLab


From dd67b13d07e6324c2b6d3330515c1f1e49fe5a9b Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 10 Dec 2020 18:47:32 -0500
Subject: [PATCH 0252/2400] [dev.regabi] cmd/compile: cleanup for concrete
 types - range, select, swt

An automated rewrite will add concrete type assertions after
a test of n.Op(), when n can be safely type-asserted
(meaning, n is not reassigned a different type, n is not reassigned
and then used outside the scope of the type assertion,
and so on).

This sequence of CLs handles the code that the automated
rewrite does not: adding specific types to function arguments,
adjusting code not to call n.Left() etc when n may have multiple
representations, and so on.

This CL focuses on range.go, select.go, and swt.go: the big
control structures.

Passes buildall w/ toolstash -cmp.

Change-Id: I033fe056a7b815edb6e8a06f45c12ffd990f4d45
Reviewed-on: https://go-review.googlesource.com/c/go/+/277929
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/range.go  | 35 ++++++------
 src/cmd/compile/internal/gc/select.go | 81 +++++++++++++++------------
 src/cmd/compile/internal/gc/swt.go    | 65 +++++++++++----------
 src/cmd/compile/internal/gc/walk.go   |  3 +
 4 files changed, 102 insertions(+), 82 deletions(-)

diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index 453f5e2198..90bee4fc74 100644
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -13,7 +13,7 @@ import (
 )
 
 // range
-func typecheckrange(n ir.Node) {
+func typecheckrange(n *ir.RangeStmt) {
 	// Typechecking order is important here:
 	// 0. first typecheck range expression (slice/map/chan),
 	//	it is evaluated only once and so logically it is not part of the loop.
@@ -39,7 +39,7 @@ func typecheckrange(n ir.Node) {
 	decldepth--
 }
 
-func typecheckrangeExpr(n ir.Node) {
+func typecheckrangeExpr(n *ir.RangeStmt) {
 	n.SetRight(typecheck(n.Right(), ctxExpr))
 
 	t := n.Right().Type()
@@ -157,7 +157,7 @@ func cheapComputableIndex(width int64) bool {
 // simpler forms.  The result must be assigned back to n.
 // Node n may also be modified in place, and may also be
 // the returned node.
-func walkrange(nrange ir.Node) ir.Node {
+func walkrange(nrange *ir.RangeStmt) ir.Node {
 	if isMapClear(nrange) {
 		m := nrange.Right()
 		lno := setlineno(m)
@@ -204,7 +204,7 @@ func walkrange(nrange ir.Node) ir.Node {
 		base.Fatalf("walkrange: v2 != nil while v1 == nil")
 	}
 
-	var ifGuard ir.Node
+	var ifGuard *ir.IfStmt
 
 	var body []ir.Node
 	var init []ir.Node
@@ -267,7 +267,7 @@ func walkrange(nrange ir.Node) ir.Node {
 		// TODO(austin): OFORUNTIL inhibits bounds-check
 		// elimination on the index variable (see #20711).
 		// Enhance the prove pass to understand this.
-		ifGuard = ir.Nod(ir.OIF, nil, nil)
+		ifGuard = ir.NewIfStmt(base.Pos, nil, nil, nil)
 		ifGuard.SetLeft(ir.Nod(ir.OLT, hv1, hn))
 		nfor.SetOp(ir.OFORUNTIL)
 
@@ -426,7 +426,7 @@ func walkrange(nrange ir.Node) ir.Node {
 
 	if ifGuard != nil {
 		ifGuard.PtrInit().Append(init...)
-		ifGuard = typecheck(ifGuard, ctxStmt)
+		ifGuard = typecheck(ifGuard, ctxStmt).(*ir.IfStmt)
 	} else {
 		nfor.PtrInit().Append(init...)
 	}
@@ -459,7 +459,7 @@ func walkrange(nrange ir.Node) ir.Node {
 // }
 //
 // where == for keys of map m is reflexive.
-func isMapClear(n ir.Node) bool {
+func isMapClear(n *ir.RangeStmt) bool {
 	if base.Flag.N != 0 || instrumenting {
 		return false
 	}
@@ -488,7 +488,7 @@ func isMapClear(n ir.Node) bool {
 	}
 
 	m := n.Right()
-	if !samesafeexpr(stmt.List().First(), m) || !samesafeexpr(stmt.List().Second(), k) {
+	if delete := stmt.(*ir.CallExpr); !samesafeexpr(delete.List().First(), m) || !samesafeexpr(delete.List().Second(), k) {
 		return false
 	}
 
@@ -508,11 +508,7 @@ func mapClear(m ir.Node) ir.Node {
 	fn := syslook("mapclear")
 	fn = substArgTypes(fn, t.Key(), t.Elem())
 	n := mkcall1(fn, nil, nil, typename(t), m)
-
-	n = typecheck(n, ctxStmt)
-	n = walkstmt(n)
-
-	return n
+	return walkstmt(typecheck(n, ctxStmt))
 }
 
 // Lower n into runtime·memclr if possible, for
@@ -526,7 +522,7 @@ func mapClear(m ir.Node) ir.Node {
 // in which the evaluation of a is side-effect-free.
 //
 // Parameters are as in walkrange: "for v1, v2 = range a".
-func arrayClear(loop, v1, v2, a ir.Node) ir.Node {
+func arrayClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
 	if base.Flag.N != 0 || instrumenting {
 		return nil
 	}
@@ -539,12 +535,17 @@ func arrayClear(loop, v1, v2, a ir.Node) ir.Node {
 		return nil
 	}
 
-	stmt := loop.Body().First() // only stmt in body
-	if stmt.Op() != ir.OAS || stmt.Left().Op() != ir.OINDEX {
+	stmt1 := loop.Body().First() // only stmt in body
+	if stmt1.Op() != ir.OAS {
+		return nil
+	}
+	stmt := stmt1.(*ir.AssignStmt)
+	if stmt.Left().Op() != ir.OINDEX {
 		return nil
 	}
+	lhs := stmt.Left().(*ir.IndexExpr)
 
-	if !samesafeexpr(stmt.Left().Left(), a) || !samesafeexpr(stmt.Left().Right(), v1) {
+	if !samesafeexpr(lhs.Left(), a) || !samesafeexpr(lhs.Right(), v1) {
 		return nil
 	}
 
diff --git a/src/cmd/compile/internal/gc/select.go b/src/cmd/compile/internal/gc/select.go
index dd08b77b92..a3ce14128c 100644
--- a/src/cmd/compile/internal/gc/select.go
+++ b/src/cmd/compile/internal/gc/select.go
@@ -11,15 +11,12 @@ import (
 )
 
 // select
-func typecheckselect(sel ir.Node) {
+func typecheckselect(sel *ir.SelectStmt) {
 	var def ir.Node
 	lno := setlineno(sel)
 	typecheckslice(sel.Init().Slice(), ctxStmt)
 	for _, ncase := range sel.List().Slice() {
-		if ncase.Op() != ir.OCASE {
-			setlineno(ncase)
-			base.Fatalf("typecheckselect %v", ncase.Op())
-		}
+		ncase := ncase.(*ir.CaseStmt)
 
 		if ncase.List().Len() == 0 {
 			// default
@@ -51,8 +48,10 @@ func typecheckselect(sel ir.Node) {
 				// convert x = <-c into OSELRECV(x, <-c).
 				// remove implicit conversions; the eventual assignment
 				// will reintroduce them.
-				if (n.Right().Op() == ir.OCONVNOP || n.Right().Op() == ir.OCONVIFACE) && n.Right().Implicit() {
-					n.SetRight(n.Right().Left())
+				if r := n.Right(); r.Op() == ir.OCONVNOP || r.Op() == ir.OCONVIFACE {
+					if r.Implicit() {
+						n.SetRight(r.Left())
+					}
 				}
 				if n.Right().Op() != ir.ORECV {
 					base.ErrorfAt(n.Pos(), "select assignment must have receive on right hand side")
@@ -70,9 +69,10 @@ func typecheckselect(sel ir.Node) {
 
 			case ir.ORECV:
 				// convert <-c into OSELRECV(_, <-c)
-				n = ir.NodAt(n.Pos(), ir.OAS, ir.BlankNode, n)
-				n.SetOp(ir.OSELRECV)
-				n.SetTypecheck(1)
+				as := ir.NewAssignStmt(n.Pos(), ir.BlankNode, n)
+				as.SetOp(ir.OSELRECV)
+				as.SetTypecheck(1)
+				n = as
 				ncase.SetLeft(n)
 
 			case ir.OSEND:
@@ -86,7 +86,7 @@ func typecheckselect(sel ir.Node) {
 	base.Pos = lno
 }
 
-func walkselect(sel ir.Node) {
+func walkselect(sel *ir.SelectStmt) {
 	lno := setlineno(sel)
 	if sel.Body().Len() != 0 {
 		base.Fatalf("double walkselect")
@@ -95,8 +95,8 @@ func walkselect(sel ir.Node) {
 	init := sel.Init().Slice()
 	sel.PtrInit().Set(nil)
 
-	init = append(init, walkselectcases(sel.PtrList())...)
-	sel.PtrList().Set(nil)
+	init = append(init, walkselectcases(sel.List())...)
+	sel.SetList(ir.Nodes{})
 
 	sel.PtrBody().Set(init)
 	walkstmtlist(sel.Body().Slice())
@@ -104,7 +104,7 @@ func walkselect(sel ir.Node) {
 	base.Pos = lno
 }
 
-func walkselectcases(cases *ir.Nodes) []ir.Node {
+func walkselectcases(cases ir.Nodes) []ir.Node {
 	ncas := cases.Len()
 	sellineno := base.Pos
 
@@ -115,7 +115,7 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 
 	// optimization: one-case select: single op.
 	if ncas == 1 {
-		cas := cases.First()
+		cas := cases.First().(*ir.CaseStmt)
 		setlineno(cas)
 		l := cas.Init().Slice()
 		if cas.Left() != nil { // not default:
@@ -130,18 +130,20 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 				// already ok
 
 			case ir.OSELRECV:
-				if ir.IsBlank(n.Left()) {
-					n = n.Right()
+				r := n.(*ir.AssignStmt)
+				if ir.IsBlank(r.Left()) {
+					n = r.Right()
 					break
 				}
-				n.SetOp(ir.OAS)
+				r.SetOp(ir.OAS)
 
 			case ir.OSELRECV2:
-				if ir.IsBlank(n.List().First()) && ir.IsBlank(n.List().Second()) {
-					n = n.Rlist().First()
+				r := n.(*ir.AssignListStmt)
+				if ir.IsBlank(r.List().First()) && ir.IsBlank(r.List().Second()) {
+					n = r.Rlist().First()
 					break
 				}
-				n.SetOp(ir.OAS2RECV)
+				r.SetOp(ir.OAS2RECV)
 			}
 
 			l = append(l, n)
@@ -154,8 +156,9 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 
 	// convert case value arguments to addresses.
 	// this rewrite is used by both the general code and the next optimization.
-	var dflt ir.Node
+	var dflt *ir.CaseStmt
 	for _, cas := range cases.Slice() {
+		cas := cas.(*ir.CaseStmt)
 		setlineno(cas)
 		n := cas.Left()
 		if n == nil {
@@ -164,11 +167,14 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 		}
 
 		// Lower x, _ = <-c to x = <-c.
-		if n.Op() == ir.OSELRECV2 && ir.IsBlank(n.List().Second()) {
-			n = ir.NodAt(n.Pos(), ir.OAS, n.List().First(), n.Rlist().First())
-			n.SetOp(ir.OSELRECV)
-			n.SetTypecheck(1)
-			cas.SetLeft(n)
+		if sel := n; sel.Op() == ir.OSELRECV2 {
+			if ir.IsBlank(sel.List().Second()) {
+				as := ir.NewAssignStmt(sel.Pos(), sel.List().First(), sel.Rlist().First())
+				as.SetOp(ir.OSELRECV)
+				as.SetTypecheck(1)
+				n = as
+				cas.SetLeft(n)
+			}
 		}
 
 		switch n.Op() {
@@ -192,9 +198,9 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 
 	// optimization: two-case select but one is default: single non-blocking op.
 	if ncas == 2 && dflt != nil {
-		cas := cases.First()
+		cas := cases.First().(*ir.CaseStmt)
 		if cas == dflt {
-			cas = cases.Second()
+			cas = cases.Second().(*ir.CaseStmt)
 		}
 
 		n := cas.Left()
@@ -213,7 +219,8 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 
 		case ir.OSELRECV:
 			// if selectnbrecv(&v, c) { body } else { default body }
-			ch := n.Right().Left()
+			recv := n.Right().(*ir.UnaryExpr)
+			ch := recv.Left()
 			elem := n.Left()
 			if ir.IsBlank(elem) {
 				elem = nodnil()
@@ -222,7 +229,8 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 
 		case ir.OSELRECV2:
 			// if selectnbrecv2(&v, &received, c) { body } else { default body }
-			ch := n.Rlist().First().Left()
+			recv := n.Rlist().First().(*ir.UnaryExpr)
+			ch := recv.Left()
 			elem := n.List().First()
 			if ir.IsBlank(elem) {
 				elem = nodnil()
@@ -240,7 +248,7 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 	if dflt != nil {
 		ncas--
 	}
-	casorder := make([]ir.Node, ncas)
+	casorder := make([]*ir.CaseStmt, ncas)
 	nsends, nrecvs := 0, 0
 
 	var init []ir.Node
@@ -263,6 +271,7 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 
 	// register cases
 	for _, cas := range cases.Slice() {
+		cas := cas.(*ir.CaseStmt)
 		setlineno(cas)
 
 		init = append(init, cas.Init().Slice()...)
@@ -286,12 +295,14 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 		case ir.OSELRECV:
 			nrecvs++
 			i = ncas - nrecvs
-			c = n.Right().Left()
+			recv := n.Right().(*ir.UnaryExpr)
+			c = recv.Left()
 			elem = n.Left()
 		case ir.OSELRECV2:
 			nrecvs++
 			i = ncas - nrecvs
-			c = n.Rlist().First().Left()
+			recv := n.Rlist().First().(*ir.UnaryExpr)
+			c = recv.Left()
 			elem = n.List().First()
 		}
 
@@ -338,7 +349,7 @@ func walkselectcases(cases *ir.Nodes) []ir.Node {
 	}
 
 	// dispatch cases
-	dispatch := func(cond, cas ir.Node) {
+	dispatch := func(cond ir.Node, cas *ir.CaseStmt) {
 		cond = typecheck(cond, ctxExpr)
 		cond = defaultlit(cond, nil)
 
diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index aa4574d334..fd76a0a60a 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -15,7 +15,7 @@ import (
 )
 
 // typecheckswitch typechecks a switch statement.
-func typecheckswitch(n ir.Node) {
+func typecheckswitch(n *ir.SwitchStmt) {
 	typecheckslice(n.Init().Slice(), ctxStmt)
 	if n.Left() != nil && n.Left().Op() == ir.OTYPESW {
 		typecheckTypeSwitch(n)
@@ -24,24 +24,26 @@ func typecheckswitch(n ir.Node) {
 	}
 }
 
-func typecheckTypeSwitch(n ir.Node) {
-	n.Left().SetRight(typecheck(n.Left().Right(), ctxExpr))
-	t := n.Left().Right().Type()
+func typecheckTypeSwitch(n *ir.SwitchStmt) {
+	guard := n.Left().(*ir.TypeSwitchGuard)
+	guard.SetRight(typecheck(guard.Right(), ctxExpr))
+	t := guard.Right().Type()
 	if t != nil && !t.IsInterface() {
-		base.ErrorfAt(n.Pos(), "cannot type switch on non-interface value %L", n.Left().Right())
+		base.ErrorfAt(n.Pos(), "cannot type switch on non-interface value %L", guard.Right())
 		t = nil
 	}
 
 	// We don't actually declare the type switch's guarded
 	// declaration itself. So if there are no cases, we won't
 	// notice that it went unused.
-	if v := n.Left().Left(); v != nil && !ir.IsBlank(v) && n.List().Len() == 0 {
+	if v := guard.Left(); v != nil && !ir.IsBlank(v) && n.List().Len() == 0 {
 		base.ErrorfAt(v.Pos(), "%v declared but not used", v.Sym())
 	}
 
 	var defCase, nilCase ir.Node
 	var ts typeSet
 	for _, ncase := range n.List().Slice() {
+		ncase := ncase.(*ir.CaseStmt)
 		ls := ncase.List().Slice()
 		if len(ls) == 0 { // default:
 			if defCase != nil {
@@ -60,31 +62,33 @@ func typecheckTypeSwitch(n ir.Node) {
 
 			var missing, have *types.Field
 			var ptr int
-			switch {
-			case ir.IsNil(n1): // case nil:
+			if ir.IsNil(n1) { // case nil:
 				if nilCase != nil {
 					base.ErrorfAt(ncase.Pos(), "multiple nil cases in type switch (first at %v)", ir.Line(nilCase))
 				} else {
 					nilCase = ncase
 				}
-			case n1.Op() != ir.OTYPE:
+				continue
+			}
+			if n1.Op() != ir.OTYPE {
 				base.ErrorfAt(ncase.Pos(), "%L is not a type", n1)
-			case !n1.Type().IsInterface() && !implements(n1.Type(), t, &missing, &have, &ptr) && !missing.Broke():
+				continue
+			}
+			if !n1.Type().IsInterface() && !implements(n1.Type(), t, &missing, &have, &ptr) && !missing.Broke() {
 				if have != nil && !have.Broke() {
 					base.ErrorfAt(ncase.Pos(), "impossible type switch case: %L cannot have dynamic type %v"+
-						" (wrong type for %v method)\n\thave %v%S\n\twant %v%S", n.Left().Right(), n1.Type(), missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
+						" (wrong type for %v method)\n\thave %v%S\n\twant %v%S", guard.Right(), n1.Type(), missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
 				} else if ptr != 0 {
 					base.ErrorfAt(ncase.Pos(), "impossible type switch case: %L cannot have dynamic type %v"+
-						" (%v method has pointer receiver)", n.Left().Right(), n1.Type(), missing.Sym)
+						" (%v method has pointer receiver)", guard.Right(), n1.Type(), missing.Sym)
 				} else {
 					base.ErrorfAt(ncase.Pos(), "impossible type switch case: %L cannot have dynamic type %v"+
-						" (missing %v method)", n.Left().Right(), n1.Type(), missing.Sym)
+						" (missing %v method)", guard.Right(), n1.Type(), missing.Sym)
 				}
+				continue
 			}
 
-			if n1.Op() == ir.OTYPE {
-				ts.add(ncase.Pos(), n1.Type())
-			}
+			ts.add(ncase.Pos(), n1.Type())
 		}
 
 		if ncase.Rlist().Len() != 0 {
@@ -144,7 +148,7 @@ func (s *typeSet) add(pos src.XPos, typ *types.Type) {
 	s.m[ls] = append(prevs, typeSetEntry{pos, typ})
 }
 
-func typecheckExprSwitch(n ir.Node) {
+func typecheckExprSwitch(n *ir.SwitchStmt) {
 	t := types.Types[types.TBOOL]
 	if n.Left() != nil {
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
@@ -175,6 +179,7 @@ func typecheckExprSwitch(n ir.Node) {
 	var defCase ir.Node
 	var cs constSet
 	for _, ncase := range n.List().Slice() {
+		ncase := ncase.(*ir.CaseStmt)
 		ls := ncase.List().Slice()
 		if len(ls) == 0 { // default:
 			if defCase != nil {
@@ -225,7 +230,7 @@ func typecheckExprSwitch(n ir.Node) {
 }
 
 // walkswitch walks a switch statement.
-func walkswitch(sw ir.Node) {
+func walkswitch(sw *ir.SwitchStmt) {
 	// Guard against double walk, see #25776.
 	if sw.List().Len() == 0 && sw.Body().Len() > 0 {
 		return // Was fatal, but eliminating every possible source of double-walking is hard
@@ -240,7 +245,7 @@ func walkswitch(sw ir.Node) {
 
 // walkExprSwitch generates an AST implementing sw.  sw is an
 // expression switch.
-func walkExprSwitch(sw ir.Node) {
+func walkExprSwitch(sw *ir.SwitchStmt) {
 	lno := setlineno(sw)
 
 	cond := sw.Left()
@@ -278,6 +283,7 @@ func walkExprSwitch(sw ir.Node) {
 	var defaultGoto ir.Node
 	var body ir.Nodes
 	for _, ncase := range sw.List().Slice() {
+		ncase := ncase.(*ir.CaseStmt)
 		label := autolabel(".s")
 		jmp := npos(ncase.Pos(), nodSym(ir.OGOTO, nil, label))
 
@@ -393,7 +399,7 @@ func (s *exprSwitch) flush() {
 			func(i int) ir.Node {
 				return ir.Nod(ir.OLE, ir.Nod(ir.OLEN, s.exprname, nil), nodintconst(runLen(runs[i-1])))
 			},
-			func(i int, nif ir.Node) {
+			func(i int, nif *ir.IfStmt) {
 				run := runs[i]
 				nif.SetLeft(ir.Nod(ir.OEQ, ir.Nod(ir.OLEN, s.exprname, nil), nodintconst(runLen(run))))
 				s.search(run, nif.PtrBody())
@@ -428,7 +434,7 @@ func (s *exprSwitch) search(cc []exprClause, out *ir.Nodes) {
 		func(i int) ir.Node {
 			return ir.Nod(ir.OLE, s.exprname, cc[i-1].hi)
 		},
-		func(i int, nif ir.Node) {
+		func(i int, nif *ir.IfStmt) {
 			c := &cc[i]
 			nif.SetLeft(c.test(s.exprname))
 			nif.PtrBody().Set1(c.jmp)
@@ -456,7 +462,7 @@ func (c *exprClause) test(exprname ir.Node) ir.Node {
 	return ir.NodAt(c.pos, ir.OEQ, exprname, c.lo)
 }
 
-func allCaseExprsAreSideEffectFree(sw ir.Node) bool {
+func allCaseExprsAreSideEffectFree(sw *ir.SwitchStmt) bool {
 	// In theory, we could be more aggressive, allowing any
 	// side-effect-free expressions in cases, but it's a bit
 	// tricky because some of that information is unavailable due
@@ -465,9 +471,7 @@ func allCaseExprsAreSideEffectFree(sw ir.Node) bool {
 	// enough.
 
 	for _, ncase := range sw.List().Slice() {
-		if ncase.Op() != ir.OCASE {
-			base.Fatalf("switch string(byteslice) bad op: %v", ncase.Op())
-		}
+		ncase := ncase.(*ir.CaseStmt)
 		for _, v := range ncase.List().Slice() {
 			if v.Op() != ir.OLITERAL {
 				return false
@@ -497,9 +501,9 @@ func hasFall(stmts []ir.Node) (bool, src.XPos) {
 
 // walkTypeSwitch generates an AST that implements sw, where sw is a
 // type switch.
-func walkTypeSwitch(sw ir.Node) {
+func walkTypeSwitch(sw *ir.SwitchStmt) {
 	var s typeSwitch
-	s.facename = sw.Left().Right()
+	s.facename = sw.Left().(*ir.TypeSwitchGuard).Right()
 	sw.SetLeft(nil)
 
 	s.facename = walkexpr(s.facename, sw.PtrInit())
@@ -541,6 +545,7 @@ func walkTypeSwitch(sw ir.Node) {
 	var defaultGoto, nilGoto ir.Node
 	var body ir.Nodes
 	for _, ncase := range sw.List().Slice() {
+		ncase := ncase.(*ir.CaseStmt)
 		var caseVar ir.Node
 		if ncase.Rlist().Len() != 0 {
 			caseVar = ncase.Rlist().First()
@@ -704,7 +709,7 @@ func (s *typeSwitch) flush() {
 		func(i int) ir.Node {
 			return ir.Nod(ir.OLE, s.hashname, nodintconst(int64(cc[i-1].hash)))
 		},
-		func(i int, nif ir.Node) {
+		func(i int, nif *ir.IfStmt) {
 			// TODO(mdempsky): Omit hash equality check if
 			// there's only one type.
 			c := cc[i]
@@ -723,7 +728,7 @@ func (s *typeSwitch) flush() {
 //
 // leaf(i, nif) should setup nif (an OIF node) to test case i. In
 // particular, it should set nif.Left and nif.Nbody.
-func binarySearch(n int, out *ir.Nodes, less func(i int) ir.Node, leaf func(i int, nif ir.Node)) {
+func binarySearch(n int, out *ir.Nodes, less func(i int) ir.Node, leaf func(i int, nif *ir.IfStmt)) {
 	const binarySearchMin = 4 // minimum number of cases for binary search
 
 	var do func(lo, hi int, out *ir.Nodes)
@@ -731,7 +736,7 @@ func binarySearch(n int, out *ir.Nodes, less func(i int) ir.Node, leaf func(i in
 		n := hi - lo
 		if n < binarySearchMin {
 			for i := lo; i < hi; i++ {
-				nif := ir.Nod(ir.OIF, nil, nil)
+				nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
 				leaf(i, nif)
 				base.Pos = base.Pos.WithNotStmt()
 				nif.SetLeft(typecheck(nif.Left(), ctxExpr))
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index cc0b3d847d..f2d93df988 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -349,14 +349,17 @@ func walkstmt(n ir.Node) ir.Node {
 		return n
 
 	case ir.OSELECT:
+		n := n.(*ir.SelectStmt)
 		walkselect(n)
 		return n
 
 	case ir.OSWITCH:
+		n := n.(*ir.SwitchStmt)
 		walkswitch(n)
 		return n
 
 	case ir.ORANGE:
+		n := n.(*ir.RangeStmt)
 		return walkrange(n)
 	}
 
-- 
GitLab


From 5024396563f9f544a3c6413026cf9b302fd83709 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 10 Dec 2020 18:47:58 -0500
Subject: [PATCH 0253/2400] [dev.regabi] cmd/compile: cleanup for concrete
 types - subr

An automated rewrite will add concrete type assertions after
a test of n.Op(), when n can be safely type-asserted
(meaning, n is not reassigned a different type, n is not reassigned
and then used outside the scope of the type assertion,
and so on).

This sequence of CLs handles the code that the automated
rewrite does not: adding specific types to function arguments,
adjusting code not to call n.Left() etc when n may have multiple
representations, and so on.

This CL focuses on subr.go.

Passes buildall w/ toolstash -cmp.

Change-Id: I435082167c91e20a4d490aa5d5945c7454f71d61
Reviewed-on: https://go-review.googlesource.com/c/go/+/277930
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/subr.go      | 119 ++++++++++++++++-------
 src/cmd/compile/internal/gc/typecheck.go |   2 +-
 2 files changed, 87 insertions(+), 34 deletions(-)

diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 37e49d0544..e519c57273 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -555,7 +555,7 @@ func assignconvfn(n ir.Node, t *types.Type, context func() string) ir.Node {
 
 // backingArrayPtrLen extracts the pointer and length from a slice or string.
 // This constructs two nodes referring to n, so n must be a cheapexpr.
-func backingArrayPtrLen(n ir.Node) (ptr, len ir.Node) {
+func backingArrayPtrLen(n ir.Node) (ptr, length ir.Node) {
 	var init ir.Nodes
 	c := cheapexpr(n, &init)
 	if c != n || init.Len() != 0 {
@@ -567,9 +567,9 @@ func backingArrayPtrLen(n ir.Node) (ptr, len ir.Node) {
 	} else {
 		ptr.SetType(n.Type().Elem().PtrTo())
 	}
-	len = ir.Nod(ir.OLEN, n, nil)
-	len.SetType(types.Types[types.TINT])
-	return ptr, len
+	length = ir.Nod(ir.OLEN, n, nil)
+	length.SetType(types.Types[types.TINT])
+	return ptr, length
 }
 
 func syslook(name string) ir.Node {
@@ -605,6 +605,10 @@ func calcHasCall(n ir.Node) bool {
 	}
 
 	switch n.Op() {
+	default:
+		base.Fatalf("calcHasCall %+v", n)
+		panic("unreachable")
+
 	case ir.OLITERAL, ir.ONIL, ir.ONAME, ir.OTYPE:
 		if n.HasCall() {
 			base.Fatalf("OLITERAL/ONAME/OTYPE should never have calls: %+v", n)
@@ -617,6 +621,7 @@ func calcHasCall(n ir.Node) bool {
 		if instrumenting {
 			return true
 		}
+		return n.Left().HasCall() || n.Right().HasCall()
 	case ir.OINDEX, ir.OSLICE, ir.OSLICEARR, ir.OSLICE3, ir.OSLICE3ARR, ir.OSLICESTR,
 		ir.ODEREF, ir.ODOTPTR, ir.ODOTTYPE, ir.ODIV, ir.OMOD:
 		// These ops might panic, make sure they are done
@@ -625,27 +630,68 @@ func calcHasCall(n ir.Node) bool {
 
 	// When using soft-float, these ops might be rewritten to function calls
 	// so we ensure they are evaluated first.
-	case ir.OADD, ir.OSUB, ir.ONEG, ir.OMUL:
+	case ir.OADD, ir.OSUB, ir.OMUL:
+		if thearch.SoftFloat && (isFloat[n.Type().Kind()] || isComplex[n.Type().Kind()]) {
+			return true
+		}
+		return n.Left().HasCall() || n.Right().HasCall()
+	case ir.ONEG:
 		if thearch.SoftFloat && (isFloat[n.Type().Kind()] || isComplex[n.Type().Kind()]) {
 			return true
 		}
+		return n.Left().HasCall()
 	case ir.OLT, ir.OEQ, ir.ONE, ir.OLE, ir.OGE, ir.OGT:
 		if thearch.SoftFloat && (isFloat[n.Left().Type().Kind()] || isComplex[n.Left().Type().Kind()]) {
 			return true
 		}
+		return n.Left().HasCall() || n.Right().HasCall()
 	case ir.OCONV:
 		if thearch.SoftFloat && ((isFloat[n.Type().Kind()] || isComplex[n.Type().Kind()]) || (isFloat[n.Left().Type().Kind()] || isComplex[n.Left().Type().Kind()])) {
 			return true
 		}
-	}
+		return n.Left().HasCall()
 
-	if n.Left() != nil && n.Left().HasCall() {
-		return true
-	}
-	if n.Right() != nil && n.Right().HasCall() {
-		return true
+	case ir.OAND, ir.OANDNOT, ir.OLSH, ir.OOR, ir.ORSH, ir.OXOR, ir.OCOPY, ir.OCOMPLEX, ir.OEFACE:
+		return n.Left().HasCall() || n.Right().HasCall()
+
+	case ir.OAS:
+		return n.Left().HasCall() || n.Right() != nil && n.Right().HasCall()
+
+	case ir.OADDR:
+		return n.Left().HasCall()
+	case ir.OPAREN:
+		return n.Left().HasCall()
+	case ir.OBITNOT, ir.ONOT, ir.OPLUS, ir.ORECV,
+		ir.OALIGNOF, ir.OCAP, ir.OCLOSE, ir.OIMAG, ir.OLEN, ir.ONEW,
+		ir.OOFFSETOF, ir.OPANIC, ir.OREAL, ir.OSIZEOF,
+		ir.OCHECKNIL, ir.OCFUNC, ir.OIDATA, ir.OITAB, ir.ONEWOBJ, ir.OSPTR, ir.OVARDEF, ir.OVARKILL, ir.OVARLIVE:
+		return n.Left().HasCall()
+	case ir.ODOT, ir.ODOTMETH, ir.ODOTINTER:
+		return n.Left().HasCall()
+
+	case ir.OGETG, ir.OCLOSUREREAD, ir.OMETHEXPR:
+		return false
+
+	// TODO(rsc): These look wrong in various ways but are what calcHasCall has always done.
+	case ir.OADDSTR:
+		// TODO(rsc): This used to check left and right, which are not part of OADDSTR.
+		return false
+	case ir.OBLOCK:
+		// TODO(rsc): Surely the block's statements matter.
+		return false
+	case ir.OCONVIFACE, ir.OCONVNOP, ir.OBYTES2STR, ir.OBYTES2STRTMP, ir.ORUNES2STR, ir.OSTR2BYTES, ir.OSTR2BYTESTMP, ir.OSTR2RUNES, ir.ORUNESTR:
+		// TODO(rsc): Some conversions are themselves calls, no?
+		return n.Left().HasCall()
+	case ir.ODOTTYPE2:
+		// TODO(rsc): Shouldn't this be up with ODOTTYPE above?
+		return n.Left().HasCall()
+	case ir.OSLICEHEADER:
+		// TODO(rsc): What about len and cap?
+		return n.Left().HasCall()
+	case ir.OAS2DOTTYPE, ir.OAS2FUNC:
+		// TODO(rsc): Surely we need to check List and Rlist.
+		return false
 	}
-	return false
 }
 
 func badtype(op ir.Op, tl, tr *types.Type) {
@@ -727,26 +773,32 @@ func safeexpr(n ir.Node, init *ir.Nodes) ir.Node {
 	case ir.ONAME, ir.OLITERAL, ir.ONIL:
 		return n
 
-	case ir.ODOT, ir.OLEN, ir.OCAP:
+	case ir.OLEN, ir.OCAP:
+		l := safeexpr(n.Left(), init)
+		if l == n.Left() {
+			return n
+		}
+		a := ir.Copy(n).(*ir.UnaryExpr)
+		a.SetLeft(l)
+		return walkexpr(typecheck(a, ctxExpr), init)
+
+	case ir.ODOT, ir.ODOTPTR:
 		l := safeexpr(n.Left(), init)
 		if l == n.Left() {
 			return n
 		}
-		r := ir.Copy(n)
-		r.SetLeft(l)
-		r = typecheck(r, ctxExpr)
-		r = walkexpr(r, init)
-		return r
+		a := ir.Copy(n).(*ir.SelectorExpr)
+		a.SetLeft(l)
+		return walkexpr(typecheck(a, ctxExpr), init)
 
-	case ir.ODOTPTR, ir.ODEREF:
+	case ir.ODEREF:
 		l := safeexpr(n.Left(), init)
 		if l == n.Left() {
 			return n
 		}
-		a := ir.Copy(n)
+		a := ir.Copy(n).(*ir.StarExpr)
 		a.SetLeft(l)
-		a = walkexpr(a, init)
-		return a
+		return walkexpr(typecheck(a, ctxExpr), init)
 
 	case ir.OINDEX, ir.OINDEXMAP:
 		l := safeexpr(n.Left(), init)
@@ -754,11 +806,10 @@ func safeexpr(n ir.Node, init *ir.Nodes) ir.Node {
 		if l == n.Left() && r == n.Right() {
 			return n
 		}
-		a := ir.Copy(n)
+		a := ir.Copy(n).(*ir.IndexExpr)
 		a.SetLeft(l)
 		a.SetRight(r)
-		a = walkexpr(a, init)
-		return a
+		return walkexpr(typecheck(a, ctxExpr), init)
 
 	case ir.OSTRUCTLIT, ir.OARRAYLIT, ir.OSLICELIT:
 		if isStaticCompositeLiteral(n) {
@@ -927,7 +978,7 @@ func dotpath(s *types.Sym, t *types.Type, save **types.Field, ignorecase bool) (
 // find missing fields that
 // will give shortest unique addressing.
 // modify the tree with missing type names.
-func adddot(n ir.Node) ir.Node {
+func adddot(n *ir.SelectorExpr) *ir.SelectorExpr {
 	n.SetLeft(typecheck(n.Left(), ctxType|ctxExpr))
 	if n.Left().Diag() {
 		n.SetDiag(true)
@@ -950,8 +1001,9 @@ func adddot(n ir.Node) ir.Node {
 	case path != nil:
 		// rebuild elided dots
 		for c := len(path) - 1; c >= 0; c-- {
-			n.SetLeft(nodSym(ir.ODOT, n.Left(), path[c].field.Sym))
-			n.Left().SetImplicit(true)
+			dot := nodSym(ir.ODOT, n.Left(), path[c].field.Sym)
+			dot.SetImplicit(true)
+			n.SetLeft(dot)
 		}
 	case ambig:
 		base.Errorf("ambiguous selector %v", n)
@@ -1179,12 +1231,12 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	// value for that function.
 	if !instrumenting && rcvr.IsPtr() && methodrcvr.IsPtr() && method.Embedded != 0 && !isifacemethod(method.Type) && !(thearch.LinkArch.Name == "ppc64le" && base.Ctxt.Flag_dynlink) {
 		// generate tail call: adjust pointer receiver and jump to embedded method.
-		dot = dot.Left() // skip final .M
+		left := dot.Left() // skip final .M
 		// TODO(mdempsky): Remove dependency on dotlist.
 		if !dotlist[0].field.Type.IsPtr() {
-			dot = nodAddr(dot)
+			left = ir.Nod(ir.OADDR, left, nil)
 		}
-		as := ir.Nod(ir.OAS, nthis, convnop(dot, rcvr))
+		as := ir.Nod(ir.OAS, nthis, convnop(left, rcvr))
 		fn.PtrBody().Append(as)
 		fn.PtrBody().Append(nodSym(ir.ORETJMP, nil, methodSym(methodrcvr, method.Sym)))
 	} else {
@@ -1387,8 +1439,9 @@ func initExpr(init []ir.Node, n ir.Node) ir.Node {
 	}
 	if ir.MayBeShared(n) {
 		// Introduce OCONVNOP to hold init list.
-		n = ir.Nod(ir.OCONVNOP, n, nil)
-		n.SetType(n.Left().Type())
+		old := n
+		n = ir.Nod(ir.OCONVNOP, old, nil)
+		n.SetType(old.Type())
 		n.SetTypecheck(1)
 	}
 
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index ef1955e88b..70f05236c0 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -957,7 +957,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 	case ir.OXDOT, ir.ODOT:
 		n := n.(*ir.SelectorExpr)
 		if n.Op() == ir.OXDOT {
-			n = adddot(n).(*ir.SelectorExpr)
+			n = adddot(n)
 			n.SetOp(ir.ODOT)
 			if n.Left() == nil {
 				n.SetType(nil)
-- 
GitLab


From be64c8becebace2304e6c16408f6988d1da55900 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 10 Dec 2020 18:48:18 -0500
Subject: [PATCH 0254/2400] [dev.regabi] cmd/compile: cleanup for concrete
 types - noder

An automated rewrite will add concrete type assertions after
a test of n.Op(), when n can be safely type-asserted
(meaning, n is not reassigned a different type, n is not reassigned
and then used outside the scope of the type assertion,
and so on).

This sequence of CLs handles the code that the automated
rewrite does not: adding specific types to function arguments,
adjusting code not to call n.Left() etc when n may have multiple
representations, and so on.

This CL focuses on noder.go.

Passes buildall w/ toolstash -cmp.

Change-Id: Ie870126b51558e83c738add8e91a2804ed6d7f92
Reviewed-on: https://go-review.googlesource.com/c/go/+/277931
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/noder.go | 79 ++++++++++++++++------------
 test/mainsig.go                      | 13 +++++
 2 files changed, 58 insertions(+), 34 deletions(-)
 create mode 100644 test/mainsig.go

diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 4c8e56731b..43ec2ce350 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -527,13 +527,13 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) ir.Node {
 	if fun.Recv == nil {
 		if name.Name == "init" {
 			name = renameinit()
-			if t.List().Len() > 0 || t.Rlist().Len() > 0 {
+			if len(t.Params) > 0 || len(t.Results) > 0 {
 				base.ErrorfAt(f.Pos(), "func init must have no arguments and no return values")
 			}
 		}
 
 		if types.LocalPkg.Name == "main" && name.Name == "main" {
-			if t.List().Len() > 0 || t.Rlist().Len() > 0 {
+			if len(t.Params) > 0 || len(t.Results) > 0 {
 				base.ErrorfAt(f.Pos(), "func main must have no arguments and no return values")
 			}
 		}
@@ -983,10 +983,10 @@ func (p *noder) stmtsFall(stmts []syntax.Stmt, fallOK bool) []ir.Node {
 	for i, stmt := range stmts {
 		s := p.stmtFall(stmt, fallOK && i+1 == len(stmts))
 		if s == nil {
-		} else if s.Op() == ir.OBLOCK && s.List().Len() > 0 {
+		} else if s.Op() == ir.OBLOCK && s.(*ir.BlockStmt).List().Len() > 0 {
 			// Inline non-empty block.
 			// Empty blocks must be preserved for checkreturn.
-			nodes = append(nodes, s.List().Slice()...)
+			nodes = append(nodes, s.(*ir.BlockStmt).List().Slice()...)
 		} else {
 			nodes = append(nodes, s)
 		}
@@ -1020,22 +1020,23 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) ir.Node {
 		return liststmt(p.decls(stmt.DeclList))
 	case *syntax.AssignStmt:
 		if stmt.Op != 0 && stmt.Op != syntax.Def {
-			n := p.nod(stmt, ir.OASOP, p.expr(stmt.Lhs), p.expr(stmt.Rhs))
+			n := ir.NewAssignOpStmt(p.pos(stmt), p.binOp(stmt.Op), p.expr(stmt.Lhs), p.expr(stmt.Rhs))
 			n.SetImplicit(stmt.Rhs == syntax.ImplicitOne)
-			n.SetSubOp(p.binOp(stmt.Op))
 			return n
 		}
 
 		rhs := p.exprList(stmt.Rhs)
 		if list, ok := stmt.Lhs.(*syntax.ListExpr); ok && len(list.ElemList) != 1 || len(rhs) != 1 {
 			n := p.nod(stmt, ir.OAS2, nil, nil)
-			n.PtrList().Set(p.assignList(stmt.Lhs, n, stmt.Op == syntax.Def))
+			n.SetColas(stmt.Op == syntax.Def)
+			n.PtrList().Set(p.assignList(stmt.Lhs, n, n.Colas()))
 			n.PtrRlist().Set(rhs)
 			return n
 		}
 
 		n := p.nod(stmt, ir.OAS, nil, nil)
-		n.SetLeft(p.assignList(stmt.Lhs, n, stmt.Op == syntax.Def)[0])
+		n.SetColas(stmt.Op == syntax.Def)
+		n.SetLeft(p.assignList(stmt.Lhs, n, n.Colas())[0])
 		n.SetRight(rhs[0])
 		return n
 
@@ -1110,8 +1111,6 @@ func (p *noder) assignList(expr syntax.Expr, defn ir.Node, colas bool) []ir.Node
 		return p.exprList(expr)
 	}
 
-	defn.SetColas(true)
-
 	var exprs []syntax.Expr
 	if list, ok := expr.(*syntax.ListExpr); ok {
 		exprs = list.ElemList
@@ -1196,27 +1195,30 @@ func (p *noder) ifStmt(stmt *syntax.IfStmt) ir.Node {
 
 func (p *noder) forStmt(stmt *syntax.ForStmt) ir.Node {
 	p.openScope(stmt.Pos())
-	var n ir.Node
 	if r, ok := stmt.Init.(*syntax.RangeClause); ok {
 		if stmt.Cond != nil || stmt.Post != nil {
 			panic("unexpected RangeClause")
 		}
 
-		n = p.nod(r, ir.ORANGE, nil, p.expr(r.X))
+		n := p.nod(r, ir.ORANGE, nil, p.expr(r.X))
 		if r.Lhs != nil {
-			n.PtrList().Set(p.assignList(r.Lhs, n, r.Def))
-		}
-	} else {
-		n = p.nod(stmt, ir.OFOR, nil, nil)
-		if stmt.Init != nil {
-			n.PtrInit().Set1(p.stmt(stmt.Init))
-		}
-		if stmt.Cond != nil {
-			n.SetLeft(p.expr(stmt.Cond))
-		}
-		if stmt.Post != nil {
-			n.SetRight(p.stmt(stmt.Post))
+			n.SetColas(r.Def)
+			n.PtrList().Set(p.assignList(r.Lhs, n, n.Colas()))
 		}
+		n.PtrBody().Set(p.blockStmt(stmt.Body))
+		p.closeAnotherScope()
+		return n
+	}
+
+	n := p.nod(stmt, ir.OFOR, nil, nil)
+	if stmt.Init != nil {
+		n.PtrInit().Set1(p.stmt(stmt.Init))
+	}
+	if stmt.Cond != nil {
+		n.SetLeft(p.expr(stmt.Cond))
+	}
+	if stmt.Post != nil {
+		n.SetRight(p.stmt(stmt.Post))
 	}
 	n.PtrBody().Set(p.blockStmt(stmt.Body))
 	p.closeAnotherScope()
@@ -1233,9 +1235,9 @@ func (p *noder) switchStmt(stmt *syntax.SwitchStmt) ir.Node {
 		n.SetLeft(p.expr(stmt.Tag))
 	}
 
-	tswitch := n.Left()
-	if tswitch != nil && tswitch.Op() != ir.OTYPESW {
-		tswitch = nil
+	var tswitch *ir.TypeSwitchGuard
+	if l := n.Left(); l != nil && l.Op() == ir.OTYPESW {
+		tswitch = l.(*ir.TypeSwitchGuard)
 	}
 	n.PtrList().Set(p.caseClauses(stmt.Body, tswitch, stmt.Rbrace))
 
@@ -1243,7 +1245,7 @@ func (p *noder) switchStmt(stmt *syntax.SwitchStmt) ir.Node {
 	return n
 }
 
-func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch ir.Node, rbrace syntax.Pos) []ir.Node {
+func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *ir.TypeSwitchGuard, rbrace syntax.Pos) []ir.Node {
 	nodes := make([]ir.Node, 0, len(clauses))
 	for i, clause := range clauses {
 		p.setlineno(clause)
@@ -1328,10 +1330,18 @@ func (p *noder) labeledStmt(label *syntax.LabeledStmt, fallOK bool) ir.Node {
 	var ls ir.Node
 	if label.Stmt != nil { // TODO(mdempsky): Should always be present.
 		ls = p.stmtFall(label.Stmt, fallOK)
-		switch label.Stmt.(type) {
-		case *syntax.ForStmt, *syntax.SwitchStmt, *syntax.SelectStmt:
-			// Attach label directly to control statement too.
-			ls.SetSym(sym)
+		// Attach label directly to control statement too.
+		if ls != nil {
+			switch ls.Op() {
+			case ir.OFOR:
+				ls.SetSym(sym)
+			case ir.ORANGE:
+				ls.SetSym(sym)
+			case ir.OSWITCH:
+				ls.SetSym(sym)
+			case ir.OSELECT:
+				ls.SetSym(sym)
+			}
 		}
 	}
 
@@ -1483,8 +1493,9 @@ func (p *noder) wrapname(n syntax.Node, x ir.Node) ir.Node {
 		}
 		fallthrough
 	case ir.ONAME, ir.ONONAME, ir.OPACK:
-		x = p.nod(n, ir.OPAREN, x, nil)
-		x.SetImplicit(true)
+		p := p.nod(n, ir.OPAREN, x, nil)
+		p.SetImplicit(true)
+		return p
 	}
 	return x
 }
diff --git a/test/mainsig.go b/test/mainsig.go
new file mode 100644
index 0000000000..d006d9cda3
--- /dev/null
+++ b/test/mainsig.go
@@ -0,0 +1,13 @@
+// errorcheck
+
+// Copyright 2020 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
+
+func main(int)  {}           // ERROR "func main must have no arguments and no return values"
+func main() int { return 1 } // ERROR "func main must have no arguments and no return values" "main redeclared in this block"
+
+func init(int)  {}           // ERROR "func init must have no arguments and no return values"
+func init() int { return 1 } // ERROR "func init must have no arguments and no return values"
-- 
GitLab


From 9c384e881e28d322b854ac702ce8f052868f5f41 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 10 Dec 2020 18:48:33 -0500
Subject: [PATCH 0255/2400] [dev.regabi] cmd/compile: cleanup for concrete
 types - mop-up

An automated rewrite will add concrete type assertions after
a test of n.Op(), when n can be safely type-asserted
(meaning, n is not reassigned a different type, n is not reassigned
and then used outside the scope of the type assertion,
and so on).

This sequence of CLs handles the code that the automated
rewrite does not: adding specific types to function arguments,
adjusting code not to call n.Left() etc when n may have multiple
representations, and so on.

This CL handles all the little files that are left.

Passes buildall w/ toolstash -cmp.

Change-Id: I6588c92dbbdd37342a77b365d70e02134a033d2a
Reviewed-on: https://go-review.googlesource.com/c/go/+/277932
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/align.go     |  1 +
 src/cmd/compile/internal/gc/closure.go   | 13 ++++++------
 src/cmd/compile/internal/gc/dcl.go       | 22 ++++++++++++---------
 src/cmd/compile/internal/gc/embed.go     |  2 +-
 src/cmd/compile/internal/gc/export.go    |  7 +++----
 src/cmd/compile/internal/gc/gen.go       | 12 ++++++++++--
 src/cmd/compile/internal/gc/init.go      |  8 ++++----
 src/cmd/compile/internal/gc/initorder.go |  2 +-
 src/cmd/compile/internal/gc/main.go      |  4 ++--
 src/cmd/compile/internal/gc/reflect.go   |  4 ++--
 src/cmd/compile/internal/gc/scc.go       |  8 +++++---
 src/cmd/compile/internal/gc/subr.go      |  2 +-
 src/cmd/compile/internal/gc/typecheck.go |  2 +-
 src/cmd/compile/internal/gc/universe.go  | 25 ++++++++++++++----------
 src/cmd/compile/internal/gc/unsafe.go    | 18 ++++++++++-------
 15 files changed, 77 insertions(+), 53 deletions(-)

diff --git a/src/cmd/compile/internal/gc/align.go b/src/cmd/compile/internal/gc/align.go
index 212e4c46ae..9944a3a38a 100644
--- a/src/cmd/compile/internal/gc/align.go
+++ b/src/cmd/compile/internal/gc/align.go
@@ -119,6 +119,7 @@ func widstruct(errtype *types.Type, t *types.Type, o int64, flag int) int64 {
 		}
 		f.Offset = o
 		if n := ir.AsNode(f.Nname); n != nil {
+			n := n.Name()
 			// addrescapes has similar code to update these offsets.
 			// Usually addrescapes runs after widstruct,
 			// in which case we could drop this,
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index 954fa1a452..6a3ee45a12 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -192,7 +192,7 @@ func capturevars(fn *ir.Func) {
 
 		var outer ir.Node
 		outer = v.Outer
-		outermost := v.Defn
+		outermost := v.Defn.(*ir.Name)
 
 		// out parameters will be assigned to implicitly upon return.
 		if outermost.Class() != ir.PPARAMOUT && !outermost.Name().Addrtaken() && !outermost.Name().Assigned() && v.Type().Width <= 128 {
@@ -414,25 +414,26 @@ func walkclosure(clo ir.Node, init *ir.Nodes) ir.Node {
 	return walkexpr(cfn, init)
 }
 
-func typecheckpartialcall(dot ir.Node, sym *types.Sym) *ir.CallPartExpr {
-	switch dot.Op() {
+func typecheckpartialcall(n ir.Node, sym *types.Sym) *ir.CallPartExpr {
+	switch n.Op() {
 	case ir.ODOTINTER, ir.ODOTMETH:
 		break
 
 	default:
 		base.Fatalf("invalid typecheckpartialcall")
 	}
+	dot := n.(*ir.SelectorExpr)
 
 	// Create top-level function.
 	fn := makepartialcall(dot, dot.Type(), sym)
 	fn.SetWrapper(true)
 
-	return ir.NewCallPartExpr(dot.Pos(), dot.Left(), dot.(*ir.SelectorExpr).Selection, fn)
+	return ir.NewCallPartExpr(dot.Pos(), dot.Left(), dot.Selection, fn)
 }
 
 // makepartialcall returns a DCLFUNC node representing the wrapper function (*-fm) needed
 // for partial calls.
-func makepartialcall(dot ir.Node, t0 *types.Type, meth *types.Sym) *ir.Func {
+func makepartialcall(dot *ir.SelectorExpr, t0 *types.Type, meth *types.Sym) *ir.Func {
 	rcvrtype := dot.Left().Type()
 	sym := methodSymSuffix(rcvrtype, meth, "-fm")
 
@@ -508,7 +509,7 @@ func makepartialcall(dot ir.Node, t0 *types.Type, meth *types.Sym) *ir.Func {
 // partialCallType returns the struct type used to hold all the information
 // needed in the closure for n (n must be a OCALLPART node).
 // The address of a variable of the returned type can be cast to a func.
-func partialCallType(n ir.Node) *types.Type {
+func partialCallType(n *ir.CallPartExpr) *types.Type {
 	t := tostruct([]*ir.Field{
 		namedfield("F", types.Types[types.TUINTPTR]),
 		namedfield("R", n.Left().Type()),
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index ad2dc99f89..a2c9edb481 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -165,10 +165,10 @@ func variter(vl []ir.Node, t ir.Ntype, el []ir.Node) []ir.Node {
 			if Curfn != nil {
 				init = append(init, ir.Nod(ir.ODCL, v, nil))
 			}
-			e = ir.Nod(ir.OAS, v, e)
-			init = append(init, e)
-			if e.Right() != nil {
-				v.Defn = e
+			as := ir.Nod(ir.OAS, v, e)
+			init = append(init, as)
+			if e != nil {
+				v.Defn = as
 			}
 		}
 	}
@@ -799,7 +799,7 @@ func makefuncsym(s *types.Sym) {
 }
 
 // setNodeNameFunc marks a node as a function.
-func setNodeNameFunc(n ir.Node) {
+func setNodeNameFunc(n *ir.Name) {
 	if n.Op() != ir.ONAME || n.Class() != ir.Pxxx {
 		base.Fatalf("expected ONAME/Pxxx node, got %v", n)
 	}
@@ -861,12 +861,16 @@ func newNowritebarrierrecChecker() *nowritebarrierrecChecker {
 	return c
 }
 
-func (c *nowritebarrierrecChecker) findExtraCalls(n ir.Node) {
-	if n.Op() != ir.OCALLFUNC {
+func (c *nowritebarrierrecChecker) findExtraCalls(nn ir.Node) {
+	if nn.Op() != ir.OCALLFUNC {
 		return
 	}
-	fn := n.Left()
-	if fn == nil || fn.Op() != ir.ONAME || fn.Class() != ir.PFUNC || fn.Name().Defn == nil {
+	n := nn.(*ir.CallExpr)
+	if n.Left() == nil || n.Left().Op() != ir.ONAME {
+		return
+	}
+	fn := n.Left().(*ir.Name)
+	if fn.Class() != ir.PFUNC || fn.Name().Defn == nil {
 		return
 	}
 	if !isRuntimePkg(fn.Sym().Pkg) || fn.Sym().Name != "systemstack" {
diff --git a/src/cmd/compile/internal/gc/embed.go b/src/cmd/compile/internal/gc/embed.go
index 7664bde1c5..b9c88c0d5b 100644
--- a/src/cmd/compile/internal/gc/embed.go
+++ b/src/cmd/compile/internal/gc/embed.go
@@ -110,7 +110,7 @@ func varEmbed(p *noder, names []ir.Node, typ ir.Ntype, exprs []ir.Node, embeds [
 		}
 	}
 
-	v := names[0]
+	v := names[0].(*ir.Name)
 	if dclcontext != ir.PEXTERN {
 		numLocalEmbed++
 		v = ir.NewNameAt(v.Pos(), lookupN("embed.", numLocalEmbed))
diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index 593dd3b2f8..16d45a00aa 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -74,7 +74,7 @@ func dumpexport(bout *bio.Writer) {
 	}
 }
 
-func importsym(ipkg *types.Pkg, s *types.Sym, op ir.Op) ir.Node {
+func importsym(ipkg *types.Pkg, s *types.Sym, op ir.Op) *ir.Name {
 	n := ir.AsNode(s.PkgDef())
 	if n == nil {
 		// iimport should have created a stub ONONAME
@@ -92,7 +92,7 @@ func importsym(ipkg *types.Pkg, s *types.Sym, op ir.Op) ir.Node {
 	if n.Op() != ir.ONONAME && n.Op() != op {
 		redeclare(base.Pos, s, fmt.Sprintf("during import %q", ipkg.Path))
 	}
-	return n
+	return n.(*ir.Name)
 }
 
 // importtype returns the named type declared by symbol s.
@@ -102,7 +102,6 @@ func importtype(ipkg *types.Pkg, pos src.XPos, s *types.Sym) *types.Type {
 	n := importsym(ipkg, s, ir.OTYPE)
 	if n.Op() != ir.OTYPE {
 		t := types.NewNamed(n)
-
 		n.SetOp(ir.OTYPE)
 		n.SetPos(pos)
 		n.SetType(t)
@@ -121,7 +120,7 @@ func importtype(ipkg *types.Pkg, pos src.XPos, s *types.Sym) *types.Type {
 func importobj(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op ir.Op, ctxt ir.Class, t *types.Type) ir.Node {
 	n := importsym(ipkg, s, op)
 	if n.Op() != ir.ONONAME {
-		if n.Op() == op && (n.Class() != ctxt || !types.Identical(n.Type(), t)) {
+		if n.Op() == op && (op == ir.ONAME && n.Class() != ctxt || !types.Identical(n.Type(), t)) {
 			redeclare(base.Pos, s, fmt.Sprintf("during import %q", ipkg.Path))
 		}
 		return nil
diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
index 39e9425978..25b241e236 100644
--- a/src/cmd/compile/internal/gc/gen.go
+++ b/src/cmd/compile/internal/gc/gen.go
@@ -31,13 +31,21 @@ func sysvar(name string) *obj.LSym {
 // isParamStackCopy reports whether this is the on-stack copy of a
 // function parameter that moved to the heap.
 func isParamStackCopy(n ir.Node) bool {
-	return n.Op() == ir.ONAME && (n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT) && n.Name().Heapaddr != nil
+	if n.Op() != ir.ONAME {
+		return false
+	}
+	name := n.(*ir.Name)
+	return (name.Class() == ir.PPARAM || name.Class() == ir.PPARAMOUT) && name.Heapaddr != nil
 }
 
 // isParamHeapCopy reports whether this is the on-heap copy of
 // a function parameter that moved to the heap.
 func isParamHeapCopy(n ir.Node) bool {
-	return n.Op() == ir.ONAME && n.Class() == ir.PAUTOHEAP && n.Name().Stackcopy != nil
+	if n.Op() != ir.ONAME {
+		return false
+	}
+	name := n.(*ir.Name)
+	return name.Class() == ir.PAUTOHEAP && name.Name().Stackcopy != nil
 }
 
 // autotmpname returns the name for an autotmp variable numbered n.
diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index 2ef9d1ad35..8de4d84f2d 100644
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -48,10 +48,10 @@ func fninit(n []ir.Node) {
 		if n.Op() == ir.ONONAME {
 			continue
 		}
-		if n.Op() != ir.ONAME || n.Class() != ir.PEXTERN {
+		if n.Op() != ir.ONAME || n.(*ir.Name).Class() != ir.PEXTERN {
 			base.Fatalf("bad inittask: %v", n)
 		}
-		deps = append(deps, n.Sym().Linksym())
+		deps = append(deps, n.(*ir.Name).Sym().Linksym())
 	}
 
 	// Make a function that contains all the initialization statements.
@@ -86,10 +86,10 @@ func fninit(n []ir.Node) {
 	// Record user init functions.
 	for i := 0; i < renameinitgen; i++ {
 		s := lookupN("init.", i)
-		fn := ir.AsNode(s.Def).Name().Defn
+		fn := ir.AsNode(s.Def).Name().Defn.(*ir.Func)
 		// Skip init functions with empty bodies.
 		if fn.Body().Len() == 1 {
-			if stmt := fn.Body().First(); stmt.Op() == ir.OBLOCK && stmt.List().Len() == 0 {
+			if stmt := fn.Body().First(); stmt.Op() == ir.OBLOCK && stmt.(*ir.BlockStmt).List().Len() == 0 {
 				continue
 			}
 		}
diff --git a/src/cmd/compile/internal/gc/initorder.go b/src/cmd/compile/internal/gc/initorder.go
index 7870e00221..9a07ca71bd 100644
--- a/src/cmd/compile/internal/gc/initorder.go
+++ b/src/cmd/compile/internal/gc/initorder.go
@@ -323,7 +323,7 @@ func (d *initDeps) foundDep(n *ir.Name) {
 	}
 	d.seen.Add(n)
 	if d.transitive && n.Class() == ir.PFUNC {
-		d.inspectList(n.Defn.Body())
+		d.inspectList(n.Defn.(*ir.Func).Body())
 	}
 }
 
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 77b11c5d5d..03e787f718 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -244,7 +244,7 @@ func Main(archInit func(*Arch)) {
 	timings.Start("fe", "typecheck", "top1")
 	for i := 0; i < len(xtop); i++ {
 		n := xtop[i]
-		if op := n.Op(); op != ir.ODCL && op != ir.OAS && op != ir.OAS2 && (op != ir.ODCLTYPE || !n.Left().Name().Alias()) {
+		if op := n.Op(); op != ir.ODCL && op != ir.OAS && op != ir.OAS2 && (op != ir.ODCLTYPE || !n.(*ir.Decl).Left().Name().Alias()) {
 			xtop[i] = typecheck(n, ctxStmt)
 		}
 	}
@@ -256,7 +256,7 @@ func Main(archInit func(*Arch)) {
 	timings.Start("fe", "typecheck", "top2")
 	for i := 0; i < len(xtop); i++ {
 		n := xtop[i]
-		if op := n.Op(); op == ir.ODCL || op == ir.OAS || op == ir.OAS2 || op == ir.ODCLTYPE && n.Left().Name().Alias() {
+		if op := n.Op(); op == ir.ODCL || op == ir.OAS || op == ir.OAS2 || op == ir.ODCLTYPE && n.(*ir.Decl).Left().Name().Alias() {
 			xtop[i] = typecheck(n, ctxStmt)
 		}
 	}
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index cfff1baad6..615b8bdbf1 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -986,7 +986,7 @@ func typenamesym(t *types.Type) *types.Sym {
 	return s
 }
 
-func typename(t *types.Type) ir.Node {
+func typename(t *types.Type) *ir.AddrExpr {
 	s := typenamesym(t)
 	if s.Def == nil {
 		n := ir.NewNameAt(src.NoXPos, s)
@@ -1002,7 +1002,7 @@ func typename(t *types.Type) ir.Node {
 	return n
 }
 
-func itabname(t, itype *types.Type) ir.Node {
+func itabname(t, itype *types.Type) *ir.AddrExpr {
 	if t == nil || (t.IsPtr() && t.Elem() == nil) || t.IsUntyped() || !itype.IsInterface() || itype.IsEmptyInterface() {
 		base.Fatalf("itabname(%v, %v)", t, itype)
 	}
diff --git a/src/cmd/compile/internal/gc/scc.go b/src/cmd/compile/internal/gc/scc.go
index fa7af1274b..6e63d5287a 100644
--- a/src/cmd/compile/internal/gc/scc.go
+++ b/src/cmd/compile/internal/gc/scc.go
@@ -101,9 +101,11 @@ func (v *bottomUpVisitor) visit(n *ir.Func) uint32 {
 			}
 		case ir.OCALLPART:
 			fn := ir.AsNode(callpartMethod(n).Nname)
-			if fn != nil && fn.Op() == ir.ONAME && fn.Class() == ir.PFUNC && fn.Name().Defn != nil {
-				if m := v.visit(fn.Name().Defn.(*ir.Func)); m < min {
-					min = m
+			if fn != nil && fn.Op() == ir.ONAME {
+				if fn := fn.(*ir.Name); fn.Class() == ir.PFUNC && fn.Name().Defn != nil {
+					if m := v.visit(fn.Name().Defn.(*ir.Func)); m < min {
+						min = m
+					}
 				}
 			}
 		case ir.OCLOSURE:
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index e519c57273..03998b99be 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -1234,7 +1234,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 		left := dot.Left() // skip final .M
 		// TODO(mdempsky): Remove dependency on dotlist.
 		if !dotlist[0].field.Type.IsPtr() {
-			left = ir.Nod(ir.OADDR, left, nil)
+			left = nodAddr(left)
 		}
 		as := ir.Nod(ir.OAS, nthis, convnop(left, rcvr))
 		fn.PtrBody().Append(as)
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 70f05236c0..2f3c876c77 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -2791,7 +2791,7 @@ func pushtype(nn ir.Node, t *types.Type) ir.Node {
 		// For *T, return &T{...}.
 		n.SetRight(ir.TypeNode(t.Elem()))
 
-		addr := ir.NodAt(n.Pos(), ir.OADDR, n, nil)
+		addr := nodAddrAt(n.Pos(), n)
 		addr.SetImplicit(true)
 		return addr
 	}
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index 66ca0d01b3..21ddc78089 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -152,23 +152,27 @@ func initUniverse() {
 
 	for _, s := range &builtinFuncs {
 		s2 := types.BuiltinPkg.Lookup(s.name)
-		s2.Def = NewName(s2)
-		ir.AsNode(s2.Def).SetSubOp(s.op)
+		def := NewName(s2)
+		def.SetSubOp(s.op)
+		s2.Def = def
 	}
 
 	for _, s := range &unsafeFuncs {
 		s2 := unsafepkg.Lookup(s.name)
-		s2.Def = NewName(s2)
-		ir.AsNode(s2.Def).SetSubOp(s.op)
+		def := NewName(s2)
+		def.SetSubOp(s.op)
+		s2.Def = def
 	}
 
 	s = types.BuiltinPkg.Lookup("true")
-	s.Def = nodbool(true)
-	ir.AsNode(s.Def).SetSym(lookup("true"))
+	b := nodbool(true)
+	b.(*ir.Name).SetSym(lookup("true"))
+	s.Def = b
 
 	s = types.BuiltinPkg.Lookup("false")
-	s.Def = nodbool(false)
-	ir.AsNode(s.Def).SetSym(lookup("false"))
+	b = nodbool(false)
+	b.(*ir.Name).SetSym(lookup("false"))
+	s.Def = b
 
 	s = lookup("_")
 	types.BlankSym = s
@@ -187,8 +191,9 @@ func initUniverse() {
 
 	types.Types[types.TNIL] = types.New(types.TNIL)
 	s = types.BuiltinPkg.Lookup("nil")
-	s.Def = nodnil()
-	ir.AsNode(s.Def).SetSym(s)
+	nnil := nodnil()
+	nnil.(*ir.NilExpr).SetSym(s)
+	s.Def = nnil
 
 	s = types.BuiltinPkg.Lookup("iota")
 	s.Def = ir.NewIota(base.Pos, s)
diff --git a/src/cmd/compile/internal/gc/unsafe.go b/src/cmd/compile/internal/gc/unsafe.go
index d7ae5d7aaa..02dd302975 100644
--- a/src/cmd/compile/internal/gc/unsafe.go
+++ b/src/cmd/compile/internal/gc/unsafe.go
@@ -31,18 +31,20 @@ func evalunsafe(n ir.Node) int64 {
 			base.Errorf("invalid expression %v", n)
 			return 0
 		}
+		sel := n.Left().(*ir.SelectorExpr)
 
 		// Remember base of selector to find it back after dot insertion.
 		// Since r->left may be mutated by typechecking, check it explicitly
 		// first to track it correctly.
-		n.Left().SetLeft(typecheck(n.Left().Left(), ctxExpr))
-		sbase := n.Left().Left()
+		sel.SetLeft(typecheck(sel.Left(), ctxExpr))
+		sbase := sel.Left()
 
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
-		if n.Left().Type() == nil {
+		tsel := typecheck(sel, ctxExpr)
+		n.SetLeft(tsel)
+		if tsel.Type() == nil {
 			return 0
 		}
-		switch n.Left().Op() {
+		switch tsel.Op() {
 		case ir.ODOT, ir.ODOTPTR:
 			break
 		case ir.OCALLPART:
@@ -55,7 +57,8 @@ func evalunsafe(n ir.Node) int64 {
 
 		// Sum offsets for dots until we reach sbase.
 		var v int64
-		for r := n.Left(); r != sbase; r = r.Left() {
+		var next ir.Node
+		for r := tsel; r != sbase; r = next {
 			switch r.Op() {
 			case ir.ODOTPTR:
 				// For Offsetof(s.f), s may itself be a pointer,
@@ -68,8 +71,9 @@ func evalunsafe(n ir.Node) int64 {
 				fallthrough
 			case ir.ODOT:
 				v += r.Offset()
+				next = r.Left()
 			default:
-				ir.Dump("unsafenmagic", n.Left())
+				ir.Dump("unsafenmagic", tsel)
 				base.Fatalf("impossible %v node after dot insertion", r.Op())
 			}
 		}
-- 
GitLab


From 88e1415d0896824e275fd39bd80cca47275358cc Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 14 Dec 2020 13:20:06 -0500
Subject: [PATCH 0256/2400] [dev.regabi] cmd/compile: add type assertion in
 regabi test

Change-Id: I7da5165f3679736040be5bfbcea3d4a85deaff2e
Reviewed-on: https://go-review.googlesource.com/c/go/+/277957
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/abiutilsaux_test.go | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/gc/abiutilsaux_test.go b/src/cmd/compile/internal/gc/abiutilsaux_test.go
index d90d1d45a0..5489a512d2 100644
--- a/src/cmd/compile/internal/gc/abiutilsaux_test.go
+++ b/src/cmd/compile/internal/gc/abiutilsaux_test.go
@@ -75,10 +75,7 @@ func tokenize(src string) []string {
 }
 
 func verifyParamResultOffset(t *testing.T, f *types.Field, r ABIParamAssignment, which string, idx int) int {
-	n := ir.AsNode(f.Nname)
-	if n == nil {
-		panic("not expected")
-	}
+	n := ir.AsNode(f.Nname).(*ir.Name)
 	if n.Offset() != int64(r.Offset) {
 		t.Errorf("%s %d: got offset %d wanted %d t=%v",
 			which, idx, r.Offset, n.Offset(), f.Type)
-- 
GitLab


From 0328c3b660bda2c4e72d0bc0f7b8058b780c9e19 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Mon, 7 Dec 2020 03:24:04 +0700
Subject: [PATCH 0257/2400] [dev.regabi] cmd/compile: use OSELRECV2 for all <-c
 variants

OSELRECV2 can represent all possible receive clauses that can appear
in a select statement, and it simplifies later code, so use it instead.

Follow up CL will remove OSELRECV.

Passes buildall w/ toolstash -cmp.

Change-Id: Ibbdae45287ffd888acd8dc89ca8d99e454277cd1
Reviewed-on: https://go-review.googlesource.com/c/go/+/275458
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/gc/escape.go |   3 -
 src/cmd/compile/internal/gc/order.go  | 115 +++++++++-----------------
 src/cmd/compile/internal/gc/select.go |  78 ++++++-----------
 3 files changed, 62 insertions(+), 134 deletions(-)

diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index d009a55a96..5124af945e 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -399,9 +399,6 @@ func (e *Escape) stmt(n ir.Node) {
 			e.stmt(cas.Left())
 			e.block(cas.Body())
 		}
-	case ir.OSELRECV:
-		n := n.(*ir.AssignStmt)
-		e.assign(n.Left(), n.Right(), "selrecv", n)
 	case ir.OSELRECV2:
 		n := n.(*ir.AssignListStmt)
 		e.assign(n.List().First(), n.Rlist().First(), "selrecv", n)
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index b0a9c9be3e..0034556995 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -872,15 +872,14 @@ func (o *Order) stmt(n ir.Node) {
 	// give this away).
 	case ir.OSELECT:
 		t := o.markTemp()
-
-		for _, cas := range n.List().Slice() {
-			cas := cas.(*ir.CaseStmt)
-			r := cas.Left()
-			setlineno(cas)
+		for _, ncas := range n.List().Slice() {
+			ncas := ncas.(*ir.CaseStmt)
+			r := ncas.Left()
+			setlineno(ncas)
 
 			// Append any new body prologue to ninit.
 			// The next loop will insert ninit into nbody.
-			if cas.Init().Len() != 0 {
+			if ncas.Init().Len() != 0 {
 				base.Fatalf("order select ninit")
 			}
 			if r == nil {
@@ -891,84 +890,48 @@ func (o *Order) stmt(n ir.Node) {
 				ir.Dump("select case", r)
 				base.Fatalf("unknown op in select %v", r.Op())
 
-			case ir.OSELRECV, ir.OSELRECV2:
-				var dst, ok ir.Node
-				var recv *ir.UnaryExpr
-				var def bool
-				if r.Op() == ir.OSELRECV {
-					// case x = <-c
-					// case <-c (dst is ir.BlankNode)
-					def, dst, ok, recv = r.Colas(), r.Left(), ir.BlankNode, r.Right().(*ir.UnaryExpr)
-				} else {
-					r := r.(*ir.AssignListStmt)
-					// case x, ok = <-c
-					def, dst, ok, recv = r.Colas(), r.List().First(), r.List().Second(), r.Rlist().First().(*ir.UnaryExpr)
-				}
-
-				// If this is case x := <-ch or case x, y := <-ch, the case has
-				// the ODCL nodes to declare x and y. We want to delay that
-				// declaration (and possible allocation) until inside the case body.
-				// Delete the ODCL nodes here and recreate them inside the body below.
-				if def {
-					init := r.Init().Slice()
-					if len(init) > 0 && init[0].Op() == ir.ODCL && init[0].(*ir.Decl).Left() == dst {
-						init = init[1:]
-					}
-					if len(init) > 0 && init[0].Op() == ir.ODCL && init[0].(*ir.Decl).Left() == ok {
-						init = init[1:]
-					}
-					r.PtrInit().Set(init)
-				}
-				if r.Init().Len() != 0 {
-					ir.DumpList("ninit", r.Init())
-					base.Fatalf("ninit on select recv")
-				}
-
+			case ir.OSELRECV2:
+				// case x, ok = <-c
+				recv := r.Rlist().First().(*ir.UnaryExpr)
 				recv.SetLeft(o.expr(recv.Left(), nil))
 				if recv.Left().Op() != ir.ONAME {
 					recv.SetLeft(o.copyExpr(recv.Left()))
 				}
-
-				// Introduce temporary for receive and move actual copy into case body.
-				// avoids problems with target being addressed, as usual.
-				// NOTE: If we wanted to be clever, we could arrange for just one
-				// temporary per distinct type, sharing the temp among all receives
-				// with that temp. Similarly one ok bool could be shared among all
-				// the x,ok receives. Not worth doing until there's a clear need.
-				if !ir.IsBlank(dst) {
-					// use channel element type for temporary to avoid conversions,
-					// such as in case interfacevalue = <-intchan.
-					// the conversion happens in the OAS instead.
-					if def {
-						dcl := ir.Nod(ir.ODCL, dst, nil)
-						cas.PtrInit().Append(typecheck(dcl, ctxStmt))
+				r := r.(*ir.AssignListStmt)
+				init := r.PtrInit().Slice()
+				r.PtrInit().Set(nil)
+
+				colas := r.Colas()
+				do := func(i int, t *types.Type) {
+					n := r.List().Index(i)
+					if ir.IsBlank(n) {
+						return
 					}
-
-					tmp := o.newTemp(recv.Left().Type().Elem(), recv.Left().Type().Elem().HasPointers())
-					as := ir.Nod(ir.OAS, dst, tmp)
-					cas.PtrInit().Append(typecheck(as, ctxStmt))
-					dst = tmp
-				}
-				if !ir.IsBlank(ok) {
-					if def {
-						dcl := ir.Nod(ir.ODCL, ok, nil)
-						cas.PtrInit().Append(typecheck(dcl, ctxStmt))
+					// If this is case x := <-ch or case x, y := <-ch, the case has
+					// the ODCL nodes to declare x and y. We want to delay that
+					// declaration (and possible allocation) until inside the case body.
+					// Delete the ODCL nodes here and recreate them inside the body below.
+					if colas {
+						if len(init) > 0 && init[0].Op() == ir.ODCL && init[0].(*ir.Decl).Left() == n {
+							init = init[1:]
+						}
+						dcl := ir.Nod(ir.ODCL, n, nil)
+						dcl = typecheck(dcl, ctxStmt)
+						ncas.PtrInit().Append(dcl)
 					}
-
-					tmp := o.newTemp(types.Types[types.TBOOL], false)
-					as := ir.Nod(ir.OAS, ok, conv(tmp, ok.Type()))
-					cas.PtrInit().Append(typecheck(as, ctxStmt))
-					ok = tmp
+					tmp := o.newTemp(t, t.HasPointers())
+					as := ir.Nod(ir.OAS, n, conv(tmp, n.Type()))
+					as = typecheck(as, ctxStmt)
+					ncas.PtrInit().Append(as)
+					r.PtrList().SetIndex(i, tmp)
 				}
-
-				if r.Op() == ir.OSELRECV {
-					r.SetLeft(dst)
-				} else {
-					r := r.(*ir.AssignListStmt)
-					r.List().SetIndex(0, dst)
-					r.List().SetIndex(1, ok)
+				do(0, recv.Left().Type().Elem())
+				do(1, types.Types[types.TBOOL])
+				if len(init) != 0 {
+					ir.DumpList("ninit", r.Init())
+					base.Fatalf("ninit on select recv")
 				}
-				orderBlock(cas.PtrInit(), o.free)
+				orderBlock(ncas.PtrInit(), o.free)
 
 			case ir.OSEND:
 				if r.Init().Len() != 0 {
diff --git a/src/cmd/compile/internal/gc/select.go b/src/cmd/compile/internal/gc/select.go
index a3ce14128c..c017b8e29a 100644
--- a/src/cmd/compile/internal/gc/select.go
+++ b/src/cmd/compile/internal/gc/select.go
@@ -32,6 +32,14 @@ func typecheckselect(sel *ir.SelectStmt) {
 			n := ncase.List().First()
 			ncase.SetLeft(n)
 			ncase.PtrList().Set(nil)
+			oselrecv2 := func(dst, recv ir.Node, colas bool) {
+				n := ir.NodAt(n.Pos(), ir.OSELRECV2, nil, nil)
+				n.PtrList().Set2(dst, ir.BlankNode)
+				n.PtrRlist().Set1(recv)
+				n.SetColas(colas)
+				n.SetTypecheck(1)
+				ncase.SetLeft(n)
+			}
 			switch n.Op() {
 			default:
 				pos := n.Pos()
@@ -45,7 +53,7 @@ func typecheckselect(sel *ir.SelectStmt) {
 				base.ErrorfAt(pos, "select case must be receive, send or assign recv")
 
 			case ir.OAS:
-				// convert x = <-c into OSELRECV(x, <-c).
+				// convert x = <-c into x, _ = <-c
 				// remove implicit conversions; the eventual assignment
 				// will reintroduce them.
 				if r := n.Right(); r.Op() == ir.OCONVNOP || r.Op() == ir.OCONVIFACE {
@@ -57,10 +65,9 @@ func typecheckselect(sel *ir.SelectStmt) {
 					base.ErrorfAt(n.Pos(), "select assignment must have receive on right hand side")
 					break
 				}
-				n.SetOp(ir.OSELRECV)
+				oselrecv2(n.Left(), n.Right(), n.Colas())
 
 			case ir.OAS2RECV:
-				// convert x, ok = <-c into OSELRECV2(x, <-c) with ntest=ok
 				if n.Rlist().First().Op() != ir.ORECV {
 					base.ErrorfAt(n.Pos(), "select assignment must have receive on right hand side")
 					break
@@ -68,12 +75,8 @@ func typecheckselect(sel *ir.SelectStmt) {
 				n.SetOp(ir.OSELRECV2)
 
 			case ir.ORECV:
-				// convert <-c into OSELRECV(_, <-c)
-				as := ir.NewAssignStmt(n.Pos(), ir.BlankNode, n)
-				as.SetOp(ir.OSELRECV)
-				as.SetTypecheck(1)
-				n = as
-				ncase.SetLeft(n)
+				// convert <-c into _, _ = <-c
+				oselrecv2(ir.BlankNode, n, false)
 
 			case ir.OSEND:
 				break
@@ -129,14 +132,6 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 			case ir.OSEND:
 				// already ok
 
-			case ir.OSELRECV:
-				r := n.(*ir.AssignStmt)
-				if ir.IsBlank(r.Left()) {
-					n = r.Right()
-					break
-				}
-				r.SetOp(ir.OAS)
-
 			case ir.OSELRECV2:
 				r := n.(*ir.AssignListStmt)
 				if ir.IsBlank(r.List().First()) && ir.IsBlank(r.List().Second()) {
@@ -165,29 +160,11 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 			dflt = cas
 			continue
 		}
-
-		// Lower x, _ = <-c to x = <-c.
-		if sel := n; sel.Op() == ir.OSELRECV2 {
-			if ir.IsBlank(sel.List().Second()) {
-				as := ir.NewAssignStmt(sel.Pos(), sel.List().First(), sel.Rlist().First())
-				as.SetOp(ir.OSELRECV)
-				as.SetTypecheck(1)
-				n = as
-				cas.SetLeft(n)
-			}
-		}
-
 		switch n.Op() {
 		case ir.OSEND:
 			n.SetRight(nodAddr(n.Right()))
 			n.SetRight(typecheck(n.Right(), ctxExpr))
 
-		case ir.OSELRECV:
-			if !ir.IsBlank(n.Left()) {
-				n.SetLeft(nodAddr(n.Left()))
-				n.SetLeft(typecheck(n.Left(), ctxExpr))
-			}
-
 		case ir.OSELRECV2:
 			if !ir.IsBlank(n.List().First()) {
 				n.List().SetIndex(0, nodAddr(n.List().First()))
@@ -217,26 +194,23 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 			ch := n.Left()
 			call = mkcall1(chanfn("selectnbsend", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), ch, n.Right())
 
-		case ir.OSELRECV:
-			// if selectnbrecv(&v, c) { body } else { default body }
-			recv := n.Right().(*ir.UnaryExpr)
-			ch := recv.Left()
-			elem := n.Left()
-			if ir.IsBlank(elem) {
-				elem = nodnil()
-			}
-			call = mkcall1(chanfn("selectnbrecv", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), elem, ch)
-
 		case ir.OSELRECV2:
-			// if selectnbrecv2(&v, &received, c) { body } else { default body }
 			recv := n.Rlist().First().(*ir.UnaryExpr)
 			ch := recv.Left()
 			elem := n.List().First()
 			if ir.IsBlank(elem) {
 				elem = nodnil()
 			}
-			receivedp := typecheck(nodAddr(n.List().Second()), ctxExpr)
-			call = mkcall1(chanfn("selectnbrecv2", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), elem, receivedp, ch)
+			if ir.IsBlank(n.List().Second()) {
+				// if selectnbrecv(&v, c) { body } else { default body }
+				call = mkcall1(chanfn("selectnbrecv", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), elem, ch)
+			} else {
+				// TODO(cuonglm): make this use selectnbrecv()
+				// if selectnbrecv2(&v, &received, c) { body } else { default body }
+				receivedp := ir.Nod(ir.OADDR, n.List().Second(), nil)
+				receivedp = typecheck(receivedp, ctxExpr)
+				call = mkcall1(chanfn("selectnbrecv2", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), elem, receivedp, ch)
+			}
 		}
 
 		r.SetLeft(typecheck(call, ctxExpr))
@@ -292,12 +266,6 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 			nsends++
 			c = n.Left()
 			elem = n.Right()
-		case ir.OSELRECV:
-			nrecvs++
-			i = ncas - nrecvs
-			recv := n.Right().(*ir.UnaryExpr)
-			c = recv.Left()
-			elem = n.Left()
 		case ir.OSELRECV2:
 			nrecvs++
 			i = ncas - nrecvs
@@ -355,7 +323,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 
 		r := ir.Nod(ir.OIF, cond, nil)
 
-		if n := cas.Left(); n != nil && n.Op() == ir.OSELRECV2 {
+		if n := cas.Left(); n != nil && n.Op() == ir.OSELRECV2 && !ir.IsBlank(n.List().Second()) {
 			x := ir.Nod(ir.OAS, n.List().Second(), recvOK)
 			r.PtrBody().Append(typecheck(x, ctxStmt))
 		}
-- 
GitLab


From aeedc9f804e929a8a1c4340f3306b5ef6df8d850 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Mon, 7 Dec 2020 10:51:44 +0700
Subject: [PATCH 0258/2400] [dev.regabi] cmd/compile: remove OSELRECV

Previous CL uses OSELRECV2 instead of OSELRECV, this CL removes it.

Make this a separated CL as it's not safe for toolstash.

Change-Id: I530ba33fd9311904545e40fe147829af629cf4a8
Reviewed-on: https://go-review.googlesource.com/c/go/+/275459
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/ir/node.go      |   9 +-
 src/cmd/compile/internal/ir/op_string.go | 105 +++++++++++------------
 src/cmd/compile/internal/ir/stmt.go      |   2 +-
 3 files changed, 55 insertions(+), 61 deletions(-)

diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 0e73731070..fe6dafe859 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -274,7 +274,6 @@ const (
 	ORECOVER     // recover()
 	ORECV        // <-Left
 	ORUNESTR     // Type(Left) (Type is string, Left is rune)
-	OSELRECV     // like OAS: Left = Right where Right.Op = ORECV (appears as .Left of OCASE)
 	OSELRECV2    // like OAS2: List = Rlist where len(List)=2, len(Rlist)=1, Rlist[0].Op = ORECV (appears as .Left of OCASE)
 	OIOTA        // iota
 	OREAL        // real(Left)
@@ -666,12 +665,8 @@ func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
 			typ = nright.(Ntype)
 		}
 		return NewCompLitExpr(pos, op, typ, nil)
-	case OAS, OSELRECV:
-		n := NewAssignStmt(pos, nleft, nright)
-		if op != OAS {
-			n.SetOp(op)
-		}
-		return n
+	case OAS:
+		return NewAssignStmt(pos, nleft, nright)
 	case OAS2, OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV, OSELRECV2:
 		n := NewAssignListStmt(pos, op, nil, nil)
 		return n
diff --git a/src/cmd/compile/internal/ir/op_string.go b/src/cmd/compile/internal/ir/op_string.go
index bb5e16fbbc..33b177d64f 100644
--- a/src/cmd/compile/internal/ir/op_string.go
+++ b/src/cmd/compile/internal/ir/op_string.go
@@ -111,62 +111,61 @@ func _() {
 	_ = x[ORECOVER-100]
 	_ = x[ORECV-101]
 	_ = x[ORUNESTR-102]
-	_ = x[OSELRECV-103]
-	_ = x[OSELRECV2-104]
-	_ = x[OIOTA-105]
-	_ = x[OREAL-106]
-	_ = x[OIMAG-107]
-	_ = x[OCOMPLEX-108]
-	_ = x[OALIGNOF-109]
-	_ = x[OOFFSETOF-110]
-	_ = x[OSIZEOF-111]
-	_ = x[OMETHEXPR-112]
-	_ = x[OSTMTEXPR-113]
-	_ = x[OBLOCK-114]
-	_ = x[OBREAK-115]
-	_ = x[OCASE-116]
-	_ = x[OCONTINUE-117]
-	_ = x[ODEFER-118]
-	_ = x[OFALL-119]
-	_ = x[OFOR-120]
-	_ = x[OFORUNTIL-121]
-	_ = x[OGOTO-122]
-	_ = x[OIF-123]
-	_ = x[OLABEL-124]
-	_ = x[OGO-125]
-	_ = x[ORANGE-126]
-	_ = x[ORETURN-127]
-	_ = x[OSELECT-128]
-	_ = x[OSWITCH-129]
-	_ = x[OTYPESW-130]
-	_ = x[OTCHAN-131]
-	_ = x[OTMAP-132]
-	_ = x[OTSTRUCT-133]
-	_ = x[OTINTER-134]
-	_ = x[OTFUNC-135]
-	_ = x[OTARRAY-136]
-	_ = x[OTSLICE-137]
-	_ = x[OINLCALL-138]
-	_ = x[OEFACE-139]
-	_ = x[OITAB-140]
-	_ = x[OIDATA-141]
-	_ = x[OSPTR-142]
-	_ = x[OCLOSUREREAD-143]
-	_ = x[OCFUNC-144]
-	_ = x[OCHECKNIL-145]
-	_ = x[OVARDEF-146]
-	_ = x[OVARKILL-147]
-	_ = x[OVARLIVE-148]
-	_ = x[ORESULT-149]
-	_ = x[OINLMARK-150]
-	_ = x[ORETJMP-151]
-	_ = x[OGETG-152]
-	_ = x[OEND-153]
+	_ = x[OSELRECV2-103]
+	_ = x[OIOTA-104]
+	_ = x[OREAL-105]
+	_ = x[OIMAG-106]
+	_ = x[OCOMPLEX-107]
+	_ = x[OALIGNOF-108]
+	_ = x[OOFFSETOF-109]
+	_ = x[OSIZEOF-110]
+	_ = x[OMETHEXPR-111]
+	_ = x[OSTMTEXPR-112]
+	_ = x[OBLOCK-113]
+	_ = x[OBREAK-114]
+	_ = x[OCASE-115]
+	_ = x[OCONTINUE-116]
+	_ = x[ODEFER-117]
+	_ = x[OFALL-118]
+	_ = x[OFOR-119]
+	_ = x[OFORUNTIL-120]
+	_ = x[OGOTO-121]
+	_ = x[OIF-122]
+	_ = x[OLABEL-123]
+	_ = x[OGO-124]
+	_ = x[ORANGE-125]
+	_ = x[ORETURN-126]
+	_ = x[OSELECT-127]
+	_ = x[OSWITCH-128]
+	_ = x[OTYPESW-129]
+	_ = x[OTCHAN-130]
+	_ = x[OTMAP-131]
+	_ = x[OTSTRUCT-132]
+	_ = x[OTINTER-133]
+	_ = x[OTFUNC-134]
+	_ = x[OTARRAY-135]
+	_ = x[OTSLICE-136]
+	_ = x[OINLCALL-137]
+	_ = x[OEFACE-138]
+	_ = x[OITAB-139]
+	_ = x[OIDATA-140]
+	_ = x[OSPTR-141]
+	_ = x[OCLOSUREREAD-142]
+	_ = x[OCFUNC-143]
+	_ = x[OCHECKNIL-144]
+	_ = x[OVARDEF-145]
+	_ = x[OVARKILL-146]
+	_ = x[OVARLIVE-147]
+	_ = x[ORESULT-148]
+	_ = x[OINLMARK-149]
+	_ = x[ORETJMP-150]
+	_ = x[OGETG-151]
+	_ = x[OEND-152]
 }
 
-const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNEWOBJNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECVSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCLOSUREREADCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKRETJMPGETGEND"
+const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNEWOBJNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCLOSUREREADCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKRETJMPGETGEND"
 
-var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 388, 391, 400, 403, 407, 415, 422, 431, 444, 447, 450, 453, 456, 459, 462, 468, 471, 477, 480, 486, 490, 493, 497, 502, 507, 513, 518, 522, 527, 535, 543, 549, 558, 569, 576, 580, 587, 594, 602, 606, 610, 614, 621, 628, 636, 642, 650, 658, 663, 668, 672, 680, 685, 689, 692, 700, 704, 706, 711, 713, 718, 724, 730, 736, 742, 747, 751, 758, 764, 769, 775, 781, 788, 793, 797, 802, 806, 817, 822, 830, 836, 843, 850, 856, 863, 869, 873, 876}
+var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 388, 391, 400, 403, 407, 415, 422, 431, 444, 447, 450, 453, 456, 459, 462, 468, 471, 477, 480, 486, 490, 493, 497, 502, 507, 513, 518, 522, 527, 535, 543, 549, 558, 569, 576, 580, 587, 595, 599, 603, 607, 614, 621, 629, 635, 643, 651, 656, 661, 665, 673, 678, 682, 685, 693, 697, 699, 704, 706, 711, 717, 723, 729, 735, 740, 744, 751, 757, 762, 768, 774, 781, 786, 790, 795, 799, 810, 815, 823, 829, 836, 843, 849, 856, 862, 866, 869}
 
 func (i Op) String() string {
 	if i >= Op(len(_Op_index)-1) {
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index 0302ffcc94..4dd1733074 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -122,7 +122,7 @@ func (n *AssignStmt) SetOp(op Op) {
 	switch op {
 	default:
 		panic(n.no("SetOp " + op.String()))
-	case OAS, OSELRECV:
+	case OAS:
 		n.op = op
 	}
 }
-- 
GitLab


From c4f0da5750e72e3c82ade212af024523b04f6f9a Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 16 Dec 2020 17:16:23 -0800
Subject: [PATCH 0259/2400] [dev.typeparams] cmd/compile/internal/types2:
 remove code for implicit type arguments

The design draft doesn't support this anymore.

Also: Fixed a potential bug in the receiver unpack code
      (found by rfindley@).

Change-Id: Ic52eedc686adcb4d5a98884ad0134679c3685c13
Reviewed-on: https://go-review.googlesource.com/c/go/+/278853
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/decl.go     | 41 +--------------------
 src/cmd/compile/internal/types2/resolver.go |  2 +
 2 files changed, 4 insertions(+), 39 deletions(-)

diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index de6f4df73e..0b7956f287 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -686,33 +686,24 @@ func (check *Checker) collectTypeParams(list []*syntax.Field) (tparams []*TypeNa
 	var bound Type
 	for i, j := 0, 0; i < len(list); i = j {
 		f := list[i]
-		ftype := f.Type
 
 		// determine the range of type parameters list[i:j] with identical type bound
 		// (declared as in (type a, b, c B))
 		j = i + 1
-		for j < len(list) && list[j].Type == ftype {
+		for j < len(list) && list[j].Type == f.Type {
 			j++
 		}
 
 		// this should never be the case, but be careful
-		if ftype == nil {
+		if f.Type == nil {
 			continue
 		}
 
-		// If the type bound expects exactly one type argument, permit leaving
-		// it away and use the corresponding type parameter as implicit argument.
-		// This allows us to write (type p b(p), q b(q), r b(r)) as (type p, q, r b).
-		// Enabled if enableImplicitTParam is set.
-		const enableImplicitTParam = false
-
 		// The predeclared identifier "any" is visible only as a constraint
 		// in a type parameter list. Look for it before general constraint
 		// resolution.
 		if tident, _ := f.Type.(*syntax.Name); tident != nil && tident.Value == "any" && check.lookup("any") == nil {
 			bound = universeAny
-		} else if enableImplicitTParam {
-			bound = check.anyType(f.Type)
 		} else {
 			bound = check.typ(f.Type)
 		}
@@ -723,34 +714,6 @@ func (check *Checker) collectTypeParams(list []*syntax.Field) (tparams []*TypeNa
 		//           type C(type T C) interface {}
 		//           (issue #39724).
 		if _, ok := bound.Under().(*Interface); ok {
-			if enableImplicitTParam && isGeneric(bound) {
-				base := bound.(*Named) // only a *Named type can be generic
-				if j-i != 1 || len(base.tparams) != 1 {
-					// TODO(gri) make this error message better
-					check.errorf(ftype, "cannot use generic type %s without instantiation (more than one type parameter)", bound)
-					bound = Typ[Invalid]
-					continue
-				}
-				// We have exactly one type parameter.
-				// "Manually" instantiate the bound with each type
-				// parameter the bound applies to.
-				// TODO(gri) this code (in more general form) is also in
-				// checker.typInternal for the *ast.CallExpr case. Factor?
-				typ := new(instance)
-				typ.check = check
-				typ.pos = ftype.Pos()
-				typ.base = base
-				typ.targs = []Type{tparams[i].typ}
-				typ.poslist = []syntax.Pos{f.Name.Pos()}
-				// Make sure we check instantiation works at least once
-				// and that the resulting type is valid.
-				check.atEnd(func() {
-					check.validType(typ.expand(), nil)
-				})
-				// update bound and recorded type
-				bound = typ
-				check.recordTypeAndValue(ftype, typexpr, typ, nil)
-			}
 			// set the type bounds
 			for i < j {
 				tparams[i].typ.(*TypeParam).bound = bound
diff --git a/src/cmd/compile/internal/types2/resolver.go b/src/cmd/compile/internal/types2/resolver.go
index 6765c21995..2c98ca20e3 100644
--- a/src/cmd/compile/internal/types2/resolver.go
+++ b/src/cmd/compile/internal/types2/resolver.go
@@ -495,11 +495,13 @@ L: // unpack receiver type
 		case *syntax.ParenExpr:
 			rtyp = t.X
 		// case *ast.StarExpr:
+		//      ptr = true
 		// 	rtyp = t.X
 		case *syntax.Operation:
 			if t.Op != syntax.Mul || t.Y != nil {
 				break
 			}
+			ptr = true
 			rtyp = t.X
 		default:
 			break L
-- 
GitLab


From 060cdbc7b57d1c4e97038e3ad259d2572a58047f Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 15 Dec 2020 23:43:30 -0500
Subject: [PATCH 0260/2400] [dev.typeparams] go/types: import object resolution
 from dev.go2go

Changes from dev.go2go:
 + Removed enableImplicitTParam
 + Fixed a bug in unpackRecv where pointer receivers were not being
   detected in the syntax. This didn't seem to actually matter, as I
   couldn't produce an incorrect test case as a result of this bug (I
   guess by the time method sets are considered, functions have already
   been type checked).
 + Updated to the new error API.
 + A line setting t.underlying to Typ[Invalid] was restored in
   Checker.validType when a cycle is detected. Though this didn't seem
   to matter, it preserves an invariant that invalid types are used to
   suppress error reporting.

Change-Id: I3b53b35368c244d67571f23d70fb991af50db540
Reviewed-on: https://go-review.googlesource.com/c/go/+/278595
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Robert Findley <rfindley@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/decl.go             | 142 ++++++++++++++++++++++++++-----
 src/go/types/resolver.go         | 139 +++++++++++++++++++++++-------
 src/go/types/stmt.go             |   2 +-
 src/go/types/testdata/decls0.src |  10 ++-
 src/go/types/typexpr.go          |  43 +++++++++-
 5 files changed, 280 insertions(+), 56 deletions(-)

diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index 8baf223322..a822e08b1e 100644
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -5,6 +5,7 @@
 package types
 
 import (
+	"fmt"
 	"go/ast"
 	"go/constant"
 	"go/token"
@@ -52,7 +53,10 @@ func pathString(path []Object) string {
 // objDecl type-checks the declaration of obj in its respective (file) context.
 // For the meaning of def, see Checker.definedType, in typexpr.go.
 func (check *Checker) objDecl(obj Object, def *Named) {
-	if trace {
+	if trace && obj.Type() == nil {
+		if check.indent == 0 {
+			fmt.Println() // empty line between top-level objects for readability
+		}
 		check.trace(obj.Pos(), "-- checking %s (%s, objPath = %s)", obj, obj.color(), pathString(check.objPath))
 		check.indent++
 		defer func() {
@@ -183,13 +187,14 @@ func (check *Checker) objDecl(obj Object, def *Named) {
 	switch obj := obj.(type) {
 	case *Const:
 		check.decl = d // new package-level const decl
-		check.constDecl(obj, d.typ, d.init, d.inherited)
+		check.constDecl(obj, d.vtyp, d.init, d.inherited)
 	case *Var:
 		check.decl = d // new package-level var decl
-		check.varDecl(obj, d.lhs, d.typ, d.init)
+		check.varDecl(obj, d.lhs, d.vtyp, d.init)
 	case *TypeName:
 		// invalid recursive types are detected via path
-		check.typeDecl(obj, d.typ, def, d.alias)
+		check.typeDecl(obj, d.tdecl, def)
+		check.collectMethods(obj) // methods can only be added to top-level types
 	case *Func:
 		// functions may be recursive - no need to track dependencies
 		check.funcDecl(obj, d)
@@ -234,7 +239,7 @@ func (check *Checker) cycle(obj Object) (isCycle bool) {
 			// this information explicitly in the object.
 			var alias bool
 			if d := check.objMap[obj]; d != nil {
-				alias = d.alias // package-level object
+				alias = d.tdecl.Assign.IsValid() // package-level object
 			} else {
 				alias = obj.IsAlias() // function local object
 			}
@@ -318,7 +323,7 @@ func (check *Checker) validType(typ Type, path []Object) typeInfo {
 		}
 
 		// don't report a 2nd error if we already know the type is invalid
-		// (e.g., if a cycle was detected earlier, via Checker.underlying).
+		// (e.g., if a cycle was detected earlier, via under).
 		if t.underlying == Typ[Invalid] {
 			t.info = invalid
 			return invalid
@@ -344,6 +349,9 @@ func (check *Checker) validType(typ Type, path []Object) typeInfo {
 			panic("internal error: cycle start not found")
 		}
 		return t.info
+
+	case *instance:
+		return check.validType(t.expand(), path)
 	}
 
 	return valid
@@ -475,7 +483,7 @@ func (check *Checker) constDecl(obj *Const, typ, init ast.Expr, inherited bool)
 		if !isConstType(t) {
 			// don't report an error if the type is an invalid C (defined) type
 			// (issue #22090)
-			if t.Underlying() != Typ[Invalid] {
+			if under(t) != Typ[Invalid] {
 				check.errorf(typ, _InvalidConstType, "invalid constant type %s", t)
 			}
 			obj.typ = Typ[Invalid]
@@ -506,7 +514,7 @@ func (check *Checker) varDecl(obj *Var, lhs []*Var, typ, init ast.Expr) {
 
 	// determine type, if any
 	if typ != nil {
-		obj.typ = check.typ(typ)
+		obj.typ = check.varType(typ)
 		// We cannot spread the type to all lhs variables if there
 		// are more than one since that would mark them as checked
 		// (see Checker.objDecl) and the assignment of init exprs,
@@ -630,26 +638,42 @@ func (n *Named) setUnderlying(typ Type) {
 	}
 }
 
-func (check *Checker) typeDecl(obj *TypeName, typ ast.Expr, def *Named, alias bool) {
+func (check *Checker) typeDecl(obj *TypeName, tdecl *ast.TypeSpec, def *Named) {
 	assert(obj.typ == nil)
 
 	check.later(func() {
 		check.validType(obj.typ, nil)
 	})
 
+	alias := tdecl.Assign.IsValid()
+	if alias && tdecl.TParams != nil {
+		// The parser will ensure this but we may still get an invalid AST.
+		// Complain and continue as regular type definition.
+		check.error(atPos(tdecl.Assign), 0, "generic type cannot be alias")
+		alias = false
+	}
+
 	if alias {
+		// type alias declaration
 
 		obj.typ = Typ[Invalid]
-		obj.typ = check.typ(typ)
+		obj.typ = check.anyType(tdecl.Type)
 
 	} else {
+		// defined type declaration
 
 		named := &Named{check: check, obj: obj}
 		def.setUnderlying(named)
 		obj.typ = named // make sure recursive type declarations terminate
 
+		if tdecl.TParams != nil {
+			check.openScope(tdecl, "type parameters")
+			defer check.closeScope()
+			named.tparams = check.collectTypeParams(tdecl.TParams)
+		}
+
 		// determine underlying type of named
-		named.orig = check.definedType(typ, named)
+		named.orig = check.definedType(tdecl.Type, named)
 
 		// The underlying type of named may be itself a named type that is
 		// incomplete:
@@ -664,13 +688,85 @@ func (check *Checker) typeDecl(obj *TypeName, typ ast.Expr, def *Named, alias bo
 		// and which has as its underlying type the named type B.
 		// Determine the (final, unnamed) underlying type by resolving
 		// any forward chain.
+		// TODO(gri) Investigate if we can just use named.origin here
+		//           and rely on lazy computation of the underlying type.
 		named.underlying = under(named)
 	}
 
-	check.addMethodDecls(obj)
 }
 
-func (check *Checker) addMethodDecls(obj *TypeName) {
+func (check *Checker) collectTypeParams(list *ast.FieldList) (tparams []*TypeName) {
+	// Type parameter lists should not be empty. The parser will
+	// complain but we still may get an incorrect AST: ignore it.
+	if list.NumFields() == 0 {
+		return
+	}
+
+	// Declare type parameters up-front, with empty interface as type bound.
+	// The scope of type parameters starts at the beginning of the type parameter
+	// list (so we can have mutually recursive parameterized interfaces).
+	for _, f := range list.List {
+		tparams = check.declareTypeParams(tparams, f.Names)
+	}
+
+	setBoundAt := func(at int, bound Type) {
+		assert(IsInterface(bound))
+		tparams[at].typ.(*TypeParam).bound = bound
+	}
+
+	index := 0
+	var bound Type
+	for _, f := range list.List {
+		if f.Type == nil {
+			goto next
+		}
+
+		// The predeclared identifier "any" is visible only as a constraint
+		// in a type parameter list. Look for it before general constraint
+		// resolution.
+		if tident, _ := f.Type.(*ast.Ident); tident != nil && tident.Name == "any" && check.lookup("any") == nil {
+			bound = universeAny
+		} else {
+			bound = check.typ(f.Type)
+		}
+
+		// type bound must be an interface
+		// TODO(gri) We should delay the interface check because
+		//           we may not have a complete interface yet:
+		//           type C(type T C) interface {}
+		//           (issue #39724).
+		if _, ok := under(bound).(*Interface); ok {
+			// Otherwise, set the bound for each type parameter.
+			for i := range f.Names {
+				setBoundAt(index+i, bound)
+			}
+		} else if bound != Typ[Invalid] {
+			check.errorf(f.Type, 0, "%s is not an interface", bound)
+		}
+
+	next:
+		index += len(f.Names)
+	}
+
+	return
+}
+
+func (check *Checker) declareTypeParams(tparams []*TypeName, names []*ast.Ident) []*TypeName {
+	for _, name := range names {
+		tpar := NewTypeName(name.Pos(), check.pkg, name.Name, nil)
+		check.NewTypeParam(tpar, len(tparams), &emptyInterface) // assigns type to tpar as a side-effect
+		check.declare(check.scope, name, tpar, check.scope.pos) // TODO(gri) check scope position
+		tparams = append(tparams, tpar)
+	}
+
+	if trace && len(names) > 0 {
+		check.trace(names[0].Pos(), "type params = %v", tparams[len(tparams)-len(names):])
+	}
+
+	return tparams
+}
+
+func (check *Checker) collectMethods(obj *TypeName) {
 	// get associated methods
 	// (Checker.collectObjects only collects methods with non-blank names;
 	// Checker.resolveBaseTypeName ensures that obj is not an alias name
@@ -680,14 +776,14 @@ func (check *Checker) addMethodDecls(obj *TypeName) {
 		return
 	}
 	delete(check.methods, obj)
-	assert(!check.objMap[obj].alias) // don't use TypeName.IsAlias (requires fully set up object)
+	assert(!check.objMap[obj].tdecl.Assign.IsValid()) // don't use TypeName.IsAlias (requires fully set up object)
 
 	// use an objset to check for name conflicts
 	var mset objset
 
 	// spec: "If the base type is a struct type, the non-blank method
 	// and field names must be distinct."
-	base, _ := obj.typ.(*Named) // shouldn't fail but be conservative
+	base := asNamed(obj.typ) // shouldn't fail but be conservative
 	if base != nil {
 		if t, _ := base.underlying.(*Struct); t != nil {
 			for _, fld := range t.fields {
@@ -738,12 +834,18 @@ func (check *Checker) funcDecl(obj *Func, decl *declInfo) {
 
 	sig := new(Signature)
 	obj.typ = sig // guard against cycles
+
+	// Avoid cycle error when referring to method while type-checking the signature.
+	// This avoids a nuisance in the best case (non-parameterized receiver type) and
+	// since the method is not a type, we get an error. If we have a parameterized
+	// receiver type, instantiating the receiver type leads to the instantiation of
+	// its methods, and we don't want a cycle error in that case.
+	// TODO(gri) review if this is correct and/or whether we still need this?
+	saved := obj.color_
+	obj.color_ = black
 	fdecl := decl.fdecl
 	check.funcType(sig, fdecl.Recv, fdecl.Type)
-	if sig.recv == nil && obj.name == "init" && (sig.params.Len() > 0 || sig.results.Len() > 0) {
-		check.errorf(fdecl, _InvalidInitSig, "func init must have no arguments and no return values")
-		// ok to continue
-	}
+	obj.color_ = saved
 
 	// function body must be type-checked after global declarations
 	// (functions implemented elsewhere have no body)
@@ -849,7 +951,7 @@ func (check *Checker) declStmt(d ast.Decl) {
 			check.declare(check.scope, d.spec.Name, obj, scopePos)
 			// mark and unmark type before calling typeDecl; its type is still nil (see Checker.objDecl)
 			obj.setColor(grey + color(check.push(obj)))
-			check.typeDecl(obj, d.spec.Type, nil, d.spec.Assign.IsValid())
+			check.typeDecl(obj, d.spec, nil)
 			check.pop().setColor(black)
 		default:
 			check.invalidAST(d.node(), "unknown ast.Decl node %T", d.node())
diff --git a/src/go/types/resolver.go b/src/go/types/resolver.go
index b637f8b8ca..9cd13987be 100644
--- a/src/go/types/resolver.go
+++ b/src/go/types/resolver.go
@@ -19,11 +19,11 @@ import (
 type declInfo struct {
 	file      *Scope        // scope of file containing this declaration
 	lhs       []*Var        // lhs of n:1 variable declarations, or nil
-	typ       ast.Expr      // type, or nil
-	init      ast.Expr      // init/orig expression, or nil
+	vtyp      ast.Expr      // type, or nil (for const and var declarations only)
+	init      ast.Expr      // init/orig expression, or nil (for const and var declarations only)
 	inherited bool          // if set, the init expression is inherited from a previous constant declaration
+	tdecl     *ast.TypeSpec // type declaration, or nil
 	fdecl     *ast.FuncDecl // func declaration, or nil
-	alias     bool          // type alias declaration
 
 	// The deps field tracks initialization expression dependencies.
 	deps map[Object]bool // lazily initialized
@@ -216,7 +216,13 @@ func (check *Checker) collectObjects() {
 		pkgImports[imp] = true
 	}
 
-	var methods []*Func // list of methods with non-blank _ names
+	type methodInfo struct {
+		obj  *Func      // method
+		ptr  bool       // true if pointer receiver
+		recv *ast.Ident // receiver type name
+	}
+	var methods []methodInfo // collected methods with valid receivers and non-blank _ names
+	var fileScopes []*Scope
 	for fileNo, file := range check.files {
 		// The package identifier denotes the current package,
 		// but there is no corresponding package object.
@@ -230,6 +236,7 @@ func (check *Checker) collectObjects() {
 			pos, end = token.Pos(f.Base()), token.Pos(f.Base()+f.Size())
 		}
 		fileScope := NewScope(check.pkg.scope, pos, end, check.filename(fileNo))
+		fileScopes = append(fileScopes, fileScope)
 		check.recordScope(file, fileScope)
 
 		// determine file directory, necessary to resolve imports
@@ -324,7 +331,7 @@ func (check *Checker) collectObjects() {
 						init = d.init[i]
 					}
 
-					d := &declInfo{file: fileScope, typ: d.typ, init: init, inherited: d.inherited}
+					d := &declInfo{file: fileScope, vtyp: d.typ, init: init, inherited: d.inherited}
 					check.declarePkgObj(name, obj, d)
 				}
 
@@ -339,7 +346,7 @@ func (check *Checker) collectObjects() {
 					// The lhs elements are only set up after the for loop below,
 					// but that's ok because declareVar only collects the declInfo
 					// for a later phase.
-					d1 = &declInfo{file: fileScope, lhs: lhs, typ: d.spec.Type, init: d.spec.Values[0]}
+					d1 = &declInfo{file: fileScope, lhs: lhs, vtyp: d.spec.Type, init: d.spec.Values[0]}
 				}
 
 				// declare all variables
@@ -354,26 +361,38 @@ func (check *Checker) collectObjects() {
 						if i < len(d.spec.Values) {
 							init = d.spec.Values[i]
 						}
-						di = &declInfo{file: fileScope, typ: d.spec.Type, init: init}
+						di = &declInfo{file: fileScope, vtyp: d.spec.Type, init: init}
 					}
 
 					check.declarePkgObj(name, obj, di)
 				}
 			case typeDecl:
 				obj := NewTypeName(d.spec.Name.Pos(), pkg, d.spec.Name.Name, nil)
-				check.declarePkgObj(d.spec.Name, obj, &declInfo{file: fileScope, typ: d.spec.Type, alias: d.spec.Assign.IsValid()})
+				check.declarePkgObj(d.spec.Name, obj, &declInfo{file: fileScope, tdecl: d.spec})
 			case funcDecl:
 				info := &declInfo{file: fileScope, fdecl: d.decl}
 				name := d.decl.Name.Name
 				obj := NewFunc(d.decl.Name.Pos(), pkg, name, nil)
-				if d.decl.Recv == nil {
+				if !d.decl.IsMethod() {
 					// regular function
+					if d.decl.Recv != nil {
+						check.error(d.decl.Recv, _BadRecv, "method is missing receiver")
+						// treat as function
+					}
 					if name == "init" {
+						if d.decl.Type.TParams != nil {
+							check.softErrorf(d.decl.Type.TParams, _InvalidInitSig, "func init must have no type parameters")
+						}
+						if t := d.decl.Type; t.Params.NumFields() != 0 || t.Results != nil {
+							// TODO(rFindley) Should this be a hard error?
+							check.softErrorf(d.decl, _InvalidInitSig, "func init must have no arguments and no return values")
+						}
 						// don't declare init functions in the package scope - they are invisible
 						obj.parent = pkg.scope
 						check.recordDef(d.decl.Name, obj)
 						// init functions must have a body
 						if d.decl.Body == nil {
+							// TODO(gri) make this error message consistent with the others above
 							check.softErrorf(obj, _MissingInitBody, "missing function body")
 						}
 					} else {
@@ -381,11 +400,15 @@ func (check *Checker) collectObjects() {
 					}
 				} else {
 					// method
-					// (Methods with blank _ names are never found; no need to collect
-					// them for later type association. They will still be type-checked
-					// with all the other functions.)
-					if name != "_" {
-						methods = append(methods, obj)
+					if d.decl.Type.TParams != nil {
+						check.invalidAST(d.decl.Type.TParams, "method must have no type parameters")
+					}
+					ptr, recv, _ := check.unpackRecv(d.decl.Recv.List[0].Type, false)
+					// (Methods with invalid receiver cannot be associated to a type, and
+					// methods with blank _ names are never found; no need to collect any
+					// of them. They will still be type-checked with all the other functions.)
+					if recv != nil && name != "_" {
+						methods = append(methods, methodInfo{obj, ptr, recv})
 					}
 					check.recordDef(d.decl.Name, obj)
 				}
@@ -400,7 +423,7 @@ func (check *Checker) collectObjects() {
 	}
 
 	// verify that objects in package and file scopes have different names
-	for _, scope := range check.pkg.scope.children /* file scopes */ {
+	for _, scope := range fileScopes {
 		for _, obj := range scope.elems {
 			if alt := pkg.scope.Lookup(obj.Name()); alt != nil {
 				if pkg, ok := obj.(*PkgName); ok {
@@ -423,31 +446,87 @@ func (check *Checker) collectObjects() {
 		return // nothing to do
 	}
 	check.methods = make(map[*TypeName][]*Func)
-	for _, f := range methods {
-		fdecl := check.objMap[f].fdecl
-		if list := fdecl.Recv.List; len(list) > 0 {
-			// f is a method.
-			// Determine the receiver base type and associate f with it.
-			ptr, base := check.resolveBaseTypeName(list[0].Type)
-			if base != nil {
-				f.hasPtrRecv = ptr
-				check.methods[base] = append(check.methods[base], f)
+	for i := range methods {
+		m := &methods[i]
+		// Determine the receiver base type and associate m with it.
+		ptr, base := check.resolveBaseTypeName(m.ptr, m.recv)
+		if base != nil {
+			m.obj.hasPtrRecv = ptr
+			check.methods[base] = append(check.methods[base], m.obj)
+		}
+	}
+}
+
+// unpackRecv unpacks a receiver type and returns its components: ptr indicates whether
+// rtyp is a pointer receiver, rname is the receiver type name, and tparams are its
+// type parameters, if any. The type parameters are only unpacked if unpackParams is
+// set. If rname is nil, the receiver is unusable (i.e., the source has a bug which we
+// cannot easily work around).
+func (check *Checker) unpackRecv(rtyp ast.Expr, unpackParams bool) (ptr bool, rname *ast.Ident, tparams []*ast.Ident) {
+L: // unpack receiver type
+	// This accepts invalid receivers such as ***T and does not
+	// work for other invalid receivers, but we don't care. The
+	// validity of receiver expressions is checked elsewhere.
+	for {
+		switch t := rtyp.(type) {
+		case *ast.ParenExpr:
+			rtyp = t.X
+		case *ast.StarExpr:
+			ptr = true
+			rtyp = t.X
+		default:
+			break L
+		}
+	}
+
+	// unpack type parameters, if any
+	switch ptyp := rtyp.(type) {
+	case *ast.IndexExpr:
+		panic("unimplemented")
+	case *ast.CallExpr:
+		rtyp = ptyp.Fun
+		if unpackParams {
+			for _, arg := range ptyp.Args {
+				var par *ast.Ident
+				switch arg := arg.(type) {
+				case *ast.Ident:
+					par = arg
+				case *ast.BadExpr:
+					// ignore - error already reported by parser
+				case nil:
+					check.invalidAST(ptyp, "parameterized receiver contains nil parameters")
+				default:
+					check.errorf(arg, 0, "receiver type parameter %s must be an identifier", arg)
+				}
+				if par == nil {
+					par = &ast.Ident{NamePos: arg.Pos(), Name: "_"}
+				}
+				tparams = append(tparams, par)
 			}
 		}
 	}
+
+	// unpack receiver name
+	if name, _ := rtyp.(*ast.Ident); name != nil {
+		rname = name
+	}
+
+	return
 }
 
 // resolveBaseTypeName returns the non-alias base type name for typ, and whether
 // there was a pointer indirection to get to it. The base type name must be declared
 // in package scope, and there can be at most one pointer indirection. If no such type
 // name exists, the returned base is nil.
-func (check *Checker) resolveBaseTypeName(typ ast.Expr) (ptr bool, base *TypeName) {
+func (check *Checker) resolveBaseTypeName(seenPtr bool, name *ast.Ident) (ptr bool, base *TypeName) {
 	// Algorithm: Starting from a type expression, which may be a name,
 	// we follow that type through alias declarations until we reach a
 	// non-alias type name. If we encounter anything but pointer types or
 	// parentheses we're done. If we encounter more than one pointer type
 	// we're done.
+	ptr = seenPtr
 	var seen map[*TypeName]bool
+	var typ ast.Expr = name
 	for {
 		typ = unparen(typ)
 
@@ -487,13 +566,13 @@ func (check *Checker) resolveBaseTypeName(typ ast.Expr) (ptr bool, base *TypeNam
 
 		// we're done if tdecl defined tname as a new type
 		// (rather than an alias)
-		tdecl := check.objMap[tname] // must exist for objects in package scope
-		if !tdecl.alias {
+		tdecl := check.objMap[tname].tdecl // must exist for objects in package scope
+		if !tdecl.Assign.IsValid() {
 			return ptr, tname
 		}
 
 		// otherwise, continue resolving
-		typ = tdecl.typ
+		typ = tdecl.Type
 		if seen == nil {
 			seen = make(map[*TypeName]bool)
 		}
@@ -515,7 +594,7 @@ func (check *Checker) packageObjects() {
 	// add new methods to already type-checked types (from a prior Checker.Files call)
 	for _, obj := range objList {
 		if obj, _ := obj.(*TypeName); obj != nil && obj.typ != nil {
-			check.addMethodDecls(obj)
+			check.collectMethods(obj)
 		}
 	}
 
@@ -529,7 +608,7 @@ func (check *Checker) packageObjects() {
 	// phase 1
 	for _, obj := range objList {
 		// If we have a type alias, collect it for the 2nd phase.
-		if tname, _ := obj.(*TypeName); tname != nil && check.objMap[tname].alias {
+		if tname, _ := obj.(*TypeName); tname != nil && check.objMap[tname].tdecl.Assign.IsValid() {
 			aliasList = append(aliasList, tname)
 			continue
 		}
diff --git a/src/go/types/stmt.go b/src/go/types/stmt.go
index 7b3f322ced..90cac75a68 100644
--- a/src/go/types/stmt.go
+++ b/src/go/types/stmt.go
@@ -147,7 +147,7 @@ func (check *Checker) multipleDefaults(list []ast.Stmt) {
 	}
 }
 
-func (check *Checker) openScope(s ast.Stmt, comment string) {
+func (check *Checker) openScope(s ast.Node, comment string) {
 	scope := NewScope(check.scope, s.Pos(), s.End(), comment)
 	check.recordScope(s, scope)
 	check.scope = scope
diff --git a/src/go/types/testdata/decls0.src b/src/go/types/testdata/decls0.src
index 5501b65915..5ad8f53f65 100644
--- a/src/go/types/testdata/decls0.src
+++ b/src/go/types/testdata/decls0.src
@@ -184,11 +184,13 @@ func f1(x f1 /* ERROR "not a type" */ ) {}
 func f2(x *f2 /* ERROR "not a type" */ ) {}
 func f3() (x f3 /* ERROR "not a type" */ ) { return }
 func f4() (x *f4 /* ERROR "not a type" */ ) { return }
+// TODO(#43215) this should be detected as a cycle error
+func f5([unsafe.Sizeof(f5)]int) {}
 
-func (S0) m1 /* ERROR illegal cycle */ (x S0 /* ERROR value .* is not a type */ .m1) {}
-func (S0) m2 /* ERROR illegal cycle */ (x *S0 /* ERROR value .* is not a type */ .m2) {}
-func (S0) m3 /* ERROR illegal cycle */ () (x S0 /* ERROR value .* is not a type */ .m3) { return }
-func (S0) m4 /* ERROR illegal cycle */ () (x *S0 /* ERROR value .* is not a type */ .m4) { return }
+func (S0) m1 (x S0 /* ERROR value .* is not a type */ .m1) {}
+func (S0) m2 (x *S0 /* ERROR value .* is not a type */ .m2) {}
+func (S0) m3 () (x S0 /* ERROR value .* is not a type */ .m3) { return }
+func (S0) m4 () (x *S0 /* ERROR value .* is not a type */ .m4) { return }
 
 // interfaces may not have any blank methods
 type BlankI interface {
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index 41ba7e9bca..24df33965d 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -122,6 +122,45 @@ func (check *Checker) typ(e ast.Expr) Type {
 	return check.definedType(e, nil)
 }
 
+// varType type-checks the type expression e and returns its type, or Typ[Invalid].
+// The type must not be an (uninstantiated) generic type and it must be ordinary
+// (see ordinaryType).
+func (check *Checker) varType(e ast.Expr) Type {
+	typ := check.definedType(e, nil)
+	check.ordinaryType(e, typ)
+	return typ
+}
+
+// ordinaryType reports an error if typ is an interface type containing
+// type lists or is (or embeds) the predeclared type comparable.
+func (check *Checker) ordinaryType(pos positioner, typ Type) {
+	// We don't want to call under() (via asInterface) or complete interfaces
+	// while we are in the middle of type-checking parameter declarations that
+	// might belong to interface methods. Delay this check to the end of
+	// type-checking.
+	check.atEnd(func() {
+		if t := asInterface(typ); t != nil {
+			check.completeInterface(pos.Pos(), t) // TODO(gri) is this the correct position?
+			if t.allTypes != nil {
+				check.softErrorf(pos, 0, "interface contains type constraints (%s)", t.allTypes)
+				return
+			}
+			if t.IsComparable() {
+				check.softErrorf(pos, 0, "interface is (or embeds) comparable")
+			}
+		}
+	})
+}
+
+// anyType type-checks the type expression e and returns its type, or Typ[Invalid].
+// The type may be generic or instantiated.
+func (check *Checker) anyType(e ast.Expr) Type {
+	typ := check.typInternal(e, nil)
+	assert(isTyped(typ))
+	check.recordTypeAndValue(e, typexpr, typ, nil)
+	return typ
+}
+
 // definedType is like typ but also accepts a type name def.
 // If def != nil, e is the type specification for the defined type def, declared
 // in a type declaration, and def.underlying will be set to the type of e before
@@ -161,7 +200,9 @@ func (check *Checker) funcType(sig *Signature, recvPar *ast.FieldList, ftyp *ast
 		var recv *Var
 		switch len(recvList) {
 		case 0:
-			check.error(recvPar, _BadRecv, "method is missing receiver")
+			// TODO(rFindley) this is now redundant with resolver.go. Clean up when
+			//                importing remaining typexpr.go changes.
+			// check.error(recvPar, _BadRecv, "method is missing receiver")
 			recv = NewParam(0, nil, "", Typ[Invalid]) // ignore recv below
 		default:
 			// more than one receiver
-- 
GitLab


From 0b9cb63b8df352e2cb34b32452d9645ae621f9a1 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 16 Dec 2020 10:53:20 -0500
Subject: [PATCH 0261/2400] [dev.regabi] cmd/compile: rename ir.Find to ir.Any
 and update uses

ir.Find is called "any" in C#, Dart, Haskell, Python, R, Ruby, and Rust,
and "any_of" in C++, "anyMatch" in Java, "some" in JavaScript,
"exists in OCaml, and "existsb" in Coq.
(Thanks to Matthew Dempsky for the research.)

This CL changes Find to Any to use the mostly standard name.

It also updates wrapper helpers to use the any terminology:
	hasCall -> anyCall
	hasCallOrChan -> anyCallOrChan
	hasSideEffects -> anySideEffects

Unchanged are "hasNamedResults", "hasUniquePos", and "hasDefaultCase",
which are all about a single node, not any node in the IR tree.

I also renamed hasFall to endsInFallthrough, since its semantics are
neither that of "any" nor that of the remaining "has" functions.

So the new terminology helps separate different kinds of predicates nicely.

Change-Id: I9bb3c9ebf060a30447224be09a5c34ad5244ea0d
Reviewed-on: https://go-review.googlesource.com/c/go/+/278912
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/alg.go   |  6 ++---
 src/cmd/compile/internal/gc/const.go |  8 +++---
 src/cmd/compile/internal/gc/inl.go   |  4 +--
 src/cmd/compile/internal/gc/sinit.go |  4 +--
 src/cmd/compile/internal/gc/swt.go   |  6 ++---
 src/cmd/compile/internal/gc/walk.go  |  6 ++---
 src/cmd/compile/internal/ir/visit.go | 40 ++++++++++++++--------------
 7 files changed, 37 insertions(+), 37 deletions(-)

diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index 3938dce46c..3ada2581f7 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -741,7 +741,7 @@ func geneq(t *types.Type) *obj.LSym {
 	//   return (or goto ret)
 	fn.PtrBody().Append(nodSym(ir.OLABEL, nil, neq))
 	fn.PtrBody().Append(ir.Nod(ir.OAS, nr, nodbool(false)))
-	if EqCanPanic(t) || hasCall(fn) {
+	if EqCanPanic(t) || anyCall(fn) {
 		// Epilogue is large, so share it with the equal case.
 		fn.PtrBody().Append(nodSym(ir.OGOTO, nil, ret))
 	} else {
@@ -782,8 +782,8 @@ func geneq(t *types.Type) *obj.LSym {
 	return closure
 }
 
-func hasCall(fn *ir.Func) bool {
-	return ir.Find(fn, func(n ir.Node) bool {
+func anyCall(fn *ir.Func) bool {
+	return ir.Any(fn, func(n ir.Node) bool {
 		// TODO(rsc): No methods?
 		op := n.Op()
 		return op == ir.OCALL || op == ir.OCALLFUNC
diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 358eefd9bb..f8e60ea0a3 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -574,7 +574,7 @@ func evalConst(n ir.Node) ir.Node {
 				return origIntConst(n, int64(len(ir.StringVal(nl))))
 			}
 		case types.TARRAY:
-			if !hasCallOrChan(nl) {
+			if !anyCallOrChan(nl) {
 				return origIntConst(n, nl.Type().NumElem())
 			}
 		}
@@ -803,9 +803,9 @@ func isGoConst(n ir.Node) bool {
 	return n.Op() == ir.OLITERAL
 }
 
-// hasCallOrChan reports whether n contains any calls or channel operations.
-func hasCallOrChan(n ir.Node) bool {
-	return ir.Find(n, func(n ir.Node) bool {
+// anyCallOrChan reports whether n contains any calls or channel operations.
+func anyCallOrChan(n ir.Node) bool {
+	return ir.Any(n, func(n ir.Node) bool {
 		switch n.Op() {
 		case ir.OAPPEND,
 			ir.OCALL,
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index e940e416fd..8467c20833 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -465,7 +465,7 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 
 func isBigFunc(fn *ir.Func) bool {
 	budget := inlineBigFunctionNodes
-	return ir.Find(fn, func(n ir.Node) bool {
+	return ir.Any(fn, func(n ir.Node) bool {
 		budget--
 		return budget <= 0
 	})
@@ -733,7 +733,7 @@ func reassigned(name *ir.Name) bool {
 	if name.Curfn == nil {
 		return true
 	}
-	return ir.Find(name.Curfn, func(n ir.Node) bool {
+	return ir.Any(name.Curfn, func(n ir.Node) bool {
 		switch n.Op() {
 		case ir.OAS:
 			if n.Left() == name && n != name.Defn {
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 14ff853ee5..6d7a8bc5c9 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -60,7 +60,7 @@ func (s *InitSchedule) tryStaticInit(n ir.Node) bool {
 	if n.Op() != ir.OAS {
 		return false
 	}
-	if ir.IsBlank(n.Left()) && !hasSideEffects(n.Right()) {
+	if ir.IsBlank(n.Left()) && !anySideEffects(n.Right()) {
 		// Discard.
 		return true
 	}
@@ -546,7 +546,7 @@ func fixedlit(ctxt initContext, kind initKind, n ir.Node, var_ ir.Node, init *ir
 
 	for _, r := range n.List().Slice() {
 		a, value := splitnode(r)
-		if a == ir.BlankNode && !hasSideEffects(value) {
+		if a == ir.BlankNode && !anySideEffects(value) {
 			// Discard.
 			continue
 		}
diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index fd76a0a60a..882feb47cc 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -302,7 +302,7 @@ func walkExprSwitch(sw *ir.SwitchStmt) {
 		// Process body.
 		body.Append(npos(ncase.Pos(), nodSym(ir.OLABEL, nil, label)))
 		body.Append(ncase.Body().Slice()...)
-		if fall, pos := hasFall(ncase.Body().Slice()); !fall {
+		if fall, pos := endsInFallthrough(ncase.Body().Slice()); !fall {
 			br := ir.Nod(ir.OBREAK, nil, nil)
 			br.SetPos(pos)
 			body.Append(br)
@@ -481,8 +481,8 @@ func allCaseExprsAreSideEffectFree(sw *ir.SwitchStmt) bool {
 	return true
 }
 
-// hasFall reports whether stmts ends with a "fallthrough" statement.
-func hasFall(stmts []ir.Node) (bool, src.XPos) {
+// endsInFallthrough reports whether stmts ends with a "fallthrough" statement.
+func endsInFallthrough(stmts []ir.Node) (bool, src.XPos) {
 	// Search backwards for the index of the fallthrough
 	// statement. Do not assume it'll be in the last
 	// position, since in some cases (e.g. when the statement
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index f2d93df988..420edd5694 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -3765,9 +3765,9 @@ func usefield(n ir.Node) {
 	Curfn.FieldTrack[sym] = struct{}{}
 }
 
-// hasSideEffects reports whether n contains any operations that could have observable side effects.
-func hasSideEffects(n ir.Node) bool {
-	return ir.Find(n, func(n ir.Node) bool {
+// anySideEffects reports whether n contains any operations that could have observable side effects.
+func anySideEffects(n ir.Node) bool {
+	return ir.Any(n, func(n ir.Node) bool {
 		switch n.Op() {
 		// Assume side effects unless we know otherwise.
 		default:
diff --git a/src/cmd/compile/internal/ir/visit.go b/src/cmd/compile/internal/ir/visit.go
index bc2b8083ba..3f5af4ea0e 100644
--- a/src/cmd/compile/internal/ir/visit.go
+++ b/src/cmd/compile/internal/ir/visit.go
@@ -71,16 +71,16 @@ import (
 //		}
 //	}
 //
-// The Find function illustrates a different simplification of the pattern,
+// The Any function illustrates a different simplification of the pattern,
 // visiting each node and then its children, recursively, until finding
-// a node x for which find(x) returns true, at which point the entire
+// a node x for which cond(x) returns true, at which point the entire
 // traversal stops and returns true.
 //
-//	func Find(n ir.Node, find func(ir.Node)) bool {
+//	func Any(n ir.Node, find cond(ir.Node)) bool {
 //		stop := errors.New("stop")
 //		var do func(ir.Node) error
 //		do = func(x ir.Node) error {
-//			if find(x) {
+//			if cond(x) {
 //				return stop
 //			}
 //			return ir.DoChildren(x, do)
@@ -88,9 +88,9 @@ import (
 //		return do(n) == stop
 //	}
 //
-// Visit and Find are presented above as examples of how to use
+// Visit and Any are presented above as examples of how to use
 // DoChildren effectively, but of course, usage that fits within the
-// simplifications captured by Visit or Find will be best served
+// simplifications captured by Visit or Any will be best served
 // by directly calling the ones provided by this package.
 func DoChildren(n Node, do func(Node) error) error {
 	if n == nil {
@@ -138,19 +138,19 @@ func VisitList(list Nodes, visit func(Node)) {
 
 var stop = errors.New("stop")
 
-// Find looks for a non-nil node x in the IR tree rooted at n
-// for which find(x) returns true.
-// Find considers nodes in a depth-first, preorder traversal.
-// When Find finds a node x such that find(x) is true,
-// Find ends the traversal and returns true immediately.
-// Otherwise Find returns false after completing the entire traversal.
-func Find(n Node, find func(Node) bool) bool {
+// Any looks for a non-nil node x in the IR tree rooted at n
+// for which cond(x) returns true.
+// Any considers nodes in a depth-first, preorder traversal.
+// When Any finds a node x such that cond(x) is true,
+// Any ends the traversal and returns true immediately.
+// Otherwise Any returns false after completing the entire traversal.
+func Any(n Node, cond func(Node) bool) bool {
 	if n == nil {
 		return false
 	}
 	var do func(Node) error
 	do = func(x Node) error {
-		if find(x) {
+		if cond(x) {
 			return stop
 		}
 		return DoChildren(x, do)
@@ -158,13 +158,13 @@ func Find(n Node, find func(Node) bool) bool {
 	return do(n) == stop
 }
 
-// FindList calls Find(x, find) for each node x in the list, in order.
-// If any call Find(x, find) returns true, FindList stops and
-// returns that result, skipping the remainder of the list.
-// Otherwise FindList returns false.
-func FindList(list Nodes, find func(Node) bool) bool {
+// 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.Slice() {
-		if Find(x, find) {
+		if Any(x, cond) {
 			return true
 		}
 	}
-- 
GitLab


From 27aba226518fd126f6dd3413298c919a1eeb9040 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 10 Dec 2020 18:45:14 -0500
Subject: [PATCH 0262/2400] [dev.regabi] cmd/compile: cleanup for concrete
 types - walk

An automated rewrite will add concrete type assertions after
a test of n.Op(), when n can be safely type-asserted
(meaning, n is not reassigned a different type, n is not reassigned
and then used outside the scope of the type assertion,
and so on).

This sequence of CLs handles the code that the automated
rewrite does not: adding specific types to function arguments,
adjusting code not to call n.Left() etc when n may have multiple
representations, and so on.

This CL focuses on walk.go.

Passes buildall w/ toolstash -cmp.

Change-Id: I7aab57e4077cf10da1994625575c5e42ad114a9c
Reviewed-on: https://go-review.googlesource.com/c/go/+/277921
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/alg.go   |  28 +-
 src/cmd/compile/internal/gc/go.go    |   4 +-
 src/cmd/compile/internal/gc/sinit.go |   2 +-
 src/cmd/compile/internal/gc/walk.go  | 645 ++++++++++++++-------------
 4 files changed, 350 insertions(+), 329 deletions(-)

diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index 3ada2581f7..25dadffc24 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -805,7 +805,7 @@ func eqfield(p ir.Node, q ir.Node, field *types.Sym) ir.Node {
 //   memequal(s.ptr, t.ptr, len(s))
 // which can be used to construct string equality comparison.
 // eqlen must be evaluated before eqmem, and shortcircuiting is required.
-func eqstring(s, t ir.Node) (eqlen, eqmem ir.Node) {
+func eqstring(s, t ir.Node) (eqlen *ir.BinaryExpr, eqmem *ir.CallExpr) {
 	s = conv(s, types.Types[types.TSTRING])
 	t = conv(t, types.Types[types.TSTRING])
 	sptr := ir.Nod(ir.OSPTR, s, nil)
@@ -815,14 +815,13 @@ func eqstring(s, t ir.Node) (eqlen, eqmem ir.Node) {
 
 	fn := syslook("memequal")
 	fn = substArgTypes(fn, types.Types[types.TUINT8], types.Types[types.TUINT8])
-	call := ir.Nod(ir.OCALL, fn, nil)
-	call.PtrList().Append(sptr, tptr, ir.Copy(slen))
-	call1 := typecheck(call, ctxExpr|ctxMultiOK)
+	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, []ir.Node{sptr, tptr, ir.Copy(slen)})
+	call = typecheck(call, ctxExpr|ctxMultiOK).(*ir.CallExpr)
 
-	cmp := ir.Nod(ir.OEQ, slen, tlen)
-	cmp1 := typecheck(cmp, ctxExpr)
+	cmp := ir.NewBinaryExpr(base.Pos, ir.OEQ, slen, tlen)
+	cmp = typecheck(cmp, ctxExpr).(*ir.BinaryExpr)
 	cmp.SetType(types.Types[types.TBOOL])
-	return cmp1, call1
+	return cmp, call
 }
 
 // eqinterface returns the nodes
@@ -831,7 +830,7 @@ func eqstring(s, t ir.Node) (eqlen, eqmem ir.Node) {
 //   ifaceeq(s.tab, s.data, t.data) (or efaceeq(s.typ, s.data, t.data), as appropriate)
 // which can be used to construct interface equality comparison.
 // eqtab must be evaluated before eqdata, and shortcircuiting is required.
-func eqinterface(s, t ir.Node) (eqtab, eqdata ir.Node) {
+func eqinterface(s, t ir.Node) (eqtab *ir.BinaryExpr, eqdata *ir.CallExpr) {
 	if !types.Identical(s.Type(), t.Type()) {
 		base.Fatalf("eqinterface %v %v", s.Type(), t.Type())
 	}
@@ -853,14 +852,13 @@ func eqinterface(s, t ir.Node) (eqtab, eqdata ir.Node) {
 	sdata.SetTypecheck(1)
 	tdata.SetTypecheck(1)
 
-	call := ir.Nod(ir.OCALL, fn, nil)
-	call.PtrList().Append(stab, sdata, tdata)
-	call1 := typecheck(call, ctxExpr|ctxMultiOK)
+	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, []ir.Node{stab, sdata, tdata})
+	call = typecheck(call, ctxExpr|ctxMultiOK).(*ir.CallExpr)
 
-	cmp := ir.Nod(ir.OEQ, stab, ttab)
-	cmp1 := typecheck(cmp, ctxExpr)
-	cmp1.SetType(types.Types[types.TBOOL])
-	return cmp1, call1
+	cmp := ir.NewBinaryExpr(base.Pos, ir.OEQ, stab, ttab)
+	cmp = typecheck(cmp, ctxExpr).(*ir.BinaryExpr)
+	cmp.SetType(types.Types[types.TBOOL])
+	return cmp, call
 }
 
 // eqmem returns the node
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index 5d4e880742..b00a7ca14c 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -192,8 +192,8 @@ type Arch struct {
 var thearch Arch
 
 var (
-	staticuint64s,
-	zerobase ir.Node
+	staticuint64s *ir.Name
+	zerobase      *ir.Name
 
 	assertE2I,
 	assertE2I2,
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 6d7a8bc5c9..b3f211ff75 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -943,7 +943,7 @@ func oaslit(n ir.Node, init *ir.Nodes) bool {
 		return false
 
 	case ir.OSTRUCTLIT, ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT:
-		if vmatch1(n.Left(), n.Right()) {
+		if refersToCommonName(n.Left(), n.Right()) {
 			// not a special composite literal assignment
 			return false
 		}
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 420edd5694..91d3ad215e 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -12,6 +12,7 @@ import (
 	"cmd/internal/objabi"
 	"cmd/internal/sys"
 	"encoding/binary"
+	"errors"
 	"fmt"
 	"go/constant"
 	"go/token"
@@ -179,9 +180,8 @@ func walkstmt(n ir.Node) ir.Node {
 		n.PtrInit().Set(nil)
 
 		n.SetLeft(walkexpr(n.Left(), &init))
-		n = mkcall1(chanfn("chanrecv1", 2, n.Left().Type()), nil, &init, n.Left(), nodnil())
-		n = walkexpr(n, &init)
-		return initExpr(init.Slice(), n)
+		call := walkexpr(mkcall1(chanfn("chanrecv1", 2, n.Left().Type()), nil, &init, n.Left(), nodnil()), &init)
+		return initExpr(init.Slice(), call)
 
 	case ir.OBREAK,
 		ir.OCONTINUE,
@@ -197,7 +197,7 @@ func walkstmt(n ir.Node) ir.Node {
 		return n
 
 	case ir.ODCL:
-		v := n.Left()
+		v := n.Left().(*ir.Name)
 		if v.Class() == ir.PAUTOHEAP {
 			if base.Flag.CompilingRuntime {
 				base.Errorf("%v escapes to heap, not allowed in runtime", v)
@@ -236,33 +236,37 @@ func walkstmt(n ir.Node) ir.Node {
 		fallthrough
 	case ir.OGO:
 		var init ir.Nodes
-		switch n.Left().Op() {
+		switch call := n.Left(); call.Op() {
 		case ir.OPRINT, ir.OPRINTN:
-			n.SetLeft(wrapCall(n.Left(), &init))
+			call := call.(*ir.CallExpr)
+			n.SetLeft(wrapCall(call, &init))
 
 		case ir.ODELETE:
-			if mapfast(n.Left().List().First().Type()) == mapslow {
-				n.SetLeft(wrapCall(n.Left(), &init))
+			call := call.(*ir.CallExpr)
+			if mapfast(call.List().First().Type()) == mapslow {
+				n.SetLeft(wrapCall(call, &init))
 			} else {
-				n.SetLeft(walkexpr(n.Left(), &init))
+				n.SetLeft(walkexpr(call, &init))
 			}
 
 		case ir.OCOPY:
-			n.SetLeft(copyany(n.Left(), &init, true))
+			call := call.(*ir.BinaryExpr)
+			n.SetLeft(copyany(call, &init, true))
 
 		case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
-			if n.Left().Body().Len() > 0 {
-				n.SetLeft(wrapCall(n.Left(), &init))
+			call := call.(*ir.CallExpr)
+			if call.Body().Len() > 0 {
+				n.SetLeft(wrapCall(call, &init))
 			} else {
-				n.SetLeft(walkexpr(n.Left(), &init))
+				n.SetLeft(walkexpr(call, &init))
 			}
 
 		default:
-			n.SetLeft(walkexpr(n.Left(), &init))
+			n.SetLeft(walkexpr(call, &init))
 		}
 		if init.Len() > 0 {
 			init.Append(n)
-			n = ir.NewBlockStmt(n.Pos(), init.Slice())
+			return ir.NewBlockStmt(n.Pos(), init.Slice())
 		}
 		return n
 
@@ -295,7 +299,7 @@ func walkstmt(n ir.Node) ir.Node {
 		}
 		if (hasNamedResults(Curfn) && n.List().Len() > 1) || paramoutheap(Curfn) {
 			// assign to the function out parameters,
-			// so that reorder3 can fix up conflicts
+			// so that ascompatee can fix up conflicts
 			var rl []ir.Node
 
 			for _, ln := range Curfn.Dcl {
@@ -318,11 +322,10 @@ func walkstmt(n ir.Node) ir.Node {
 				base.Fatalf("expected %v return arguments, have %v", want, got)
 			}
 
-			// move function calls out, to make reorder3's job easier.
+			// move function calls out, to make ascompatee's job easier.
 			walkexprlistsafe(n.List().Slice(), n.PtrInit())
 
-			ll := ascompatee(n.Op(), rl, n.List().Slice(), n.PtrInit())
-			n.PtrList().Set(reorder3(ll))
+			n.PtrList().Set(ascompatee(n.Op(), rl, n.List().Slice(), n.PtrInit()))
 			return n
 		}
 		walkexprlist(n.List().Slice(), n.PtrInit())
@@ -336,7 +339,7 @@ func walkstmt(n ir.Node) ir.Node {
 			if isParamHeapCopy(nname) {
 				nname = nname.Name().Stackcopy
 			}
-			a := ir.Nod(ir.OAS, nname, rhs[i])
+			a := ir.NewAssignStmt(base.Pos, nname, rhs[i])
 			res[i] = convas(a, n.PtrInit())
 		}
 		n.PtrList().Set(res)
@@ -480,7 +483,7 @@ func walkexpr(n ir.Node, init *ir.Nodes) ir.Node {
 		base.Fatalf("expression has untyped type: %+v", n)
 	}
 
-	if n.Op() == ir.ONAME && n.Class() == ir.PAUTOHEAP {
+	if n.Op() == ir.ONAME && n.(*ir.Name).Class() == ir.PAUTOHEAP {
 		nn := ir.Nod(ir.ODEREF, n.Name().Heapaddr, nil)
 		nn.Left().MarkNonNil()
 		return walkexpr(typecheck(nn, ctxExpr), init)
@@ -534,8 +537,19 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		// stringsym for constant strings.
 		return n
 
-	case ir.ONOT, ir.ONEG, ir.OPLUS, ir.OBITNOT, ir.OREAL, ir.OIMAG, ir.ODOTMETH, ir.ODOTINTER,
-		ir.ODEREF, ir.OSPTR, ir.OITAB, ir.OIDATA, ir.OADDR:
+	case ir.ONOT, ir.ONEG, ir.OPLUS, ir.OBITNOT, ir.OREAL, ir.OIMAG, ir.OSPTR, ir.OITAB, ir.OIDATA:
+		n.SetLeft(walkexpr(n.Left(), init))
+		return n
+
+	case ir.ODOTMETH, ir.ODOTINTER:
+		n.SetLeft(walkexpr(n.Left(), init))
+		return n
+
+	case ir.OADDR:
+		n.SetLeft(walkexpr(n.Left(), init))
+		return n
+
+	case ir.ODEREF:
 		n.SetLeft(walkexpr(n.Left(), init))
 		return n
 
@@ -545,6 +559,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return n
 
 	case ir.ODOT, ir.ODOTPTR:
+		n := n.(*ir.SelectorExpr)
 		usefield(n)
 		n.SetLeft(walkexpr(n.Left(), init))
 		return n
@@ -554,7 +569,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		// Set up interface type addresses for back end.
 		n.SetRight(typename(n.Type()))
 		if n.Op() == ir.ODOTTYPE {
-			n.Right().SetRight(typename(n.Left().Type()))
+			n.Right().(*ir.AddrExpr).SetRight(typename(n.Left().Type()))
 		}
 		if !n.Type().IsInterface() && !n.Left().Type().IsEmptyInterface() {
 			n.PtrList().Set1(itabname(n.Type(), n.Left().Type()))
@@ -564,7 +579,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 	case ir.OLEN, ir.OCAP:
 		if isRuneCount(n) {
 			// Replace len([]rune(string)) with runtime.countrunes(string).
-			return mkcall("countrunes", n.Type(), init, conv(n.Left().Left(), types.Types[types.TSTRING]))
+			return mkcall("countrunes", n.Type(), init, conv(n.Left().(*ir.ConvExpr).Left(), types.Types[types.TSTRING]))
 		}
 
 		n.SetLeft(walkexpr(n.Left(), init))
@@ -578,22 +593,19 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		}
 		if t.IsArray() {
 			safeexpr(n.Left(), init)
-			n = origIntConst(n, t.NumElem())
-			n.SetTypecheck(1)
+			con := origIntConst(n, t.NumElem())
+			con.SetTypecheck(1)
+			return con
 		}
 		return n
 
 	case ir.OCOMPLEX:
-		// Use results from call expression as arguments for complex.
-		if n.Left() == nil && n.Right() == nil {
-			n.SetLeft(n.List().First())
-			n.SetRight(n.List().Second())
-		}
 		n.SetLeft(walkexpr(n.Left(), init))
 		n.SetRight(walkexpr(n.Right(), init))
 		return n
 
 	case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
+		n := n.(*ir.BinaryExpr)
 		return walkcompare(n, init)
 
 	case ir.OANDAND, ir.OOROR:
@@ -609,7 +621,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return n
 
 	case ir.OPRINT, ir.OPRINTN:
-		return walkprint(n, init)
+		return walkprint(n.(*ir.CallExpr), init)
 
 	case ir.OPANIC:
 		return mkcall("gopanic", nil, init, n.Left())
@@ -621,6 +633,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return n
 
 	case ir.OCALLINTER, ir.OCALLFUNC, ir.OCALLMETH:
+		n := n.(*ir.CallExpr)
 		if n.Op() == ir.OCALLINTER {
 			usemethod(n)
 			markUsedIfaceMethod(n)
@@ -652,25 +665,38 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 	case ir.OAS, ir.OASOP:
 		init.AppendNodes(n.PtrInit())
 
+		var left, right ir.Node
+		switch n.Op() {
+		case ir.OAS:
+			left, right = n.Left(), n.Right()
+		case ir.OASOP:
+			left, right = n.Left(), n.Right()
+		}
+
 		// Recognize m[k] = append(m[k], ...) so we can reuse
 		// the mapassign call.
-		mapAppend := n.Left().Op() == ir.OINDEXMAP && n.Right().Op() == ir.OAPPEND
-		if mapAppend && !samesafeexpr(n.Left(), n.Right().List().First()) {
-			base.Fatalf("not same expressions: %v != %v", n.Left(), n.Right().List().First())
+		var mapAppend *ir.CallExpr
+		if left.Op() == ir.OINDEXMAP && right.Op() == ir.OAPPEND {
+			mapAppend = right.(*ir.CallExpr)
+			if !samesafeexpr(left, mapAppend.List().First()) {
+				base.Fatalf("not same expressions: %v != %v", left, mapAppend.List().First())
+			}
 		}
 
-		n.SetLeft(walkexpr(n.Left(), init))
-		n.SetLeft(safeexpr(n.Left(), init))
-
-		if mapAppend {
-			n.Right().List().SetFirst(n.Left())
+		left = walkexpr(left, init)
+		left = safeexpr(left, init)
+		if mapAppend != nil {
+			mapAppend.List().SetFirst(left)
 		}
 
 		if n.Op() == ir.OASOP {
 			// Rewrite x op= y into x = x op y.
-			n = ir.Nod(ir.OAS, n.Left(),
-				typecheck(ir.NewBinaryExpr(base.Pos, n.SubOp(), n.Left(), n.Right()), ctxExpr))
+			n = ir.Nod(ir.OAS, left,
+				typecheck(ir.NewBinaryExpr(base.Pos, n.(*ir.AssignOpStmt).SubOp(), left, right), ctxExpr))
+		} else {
+			n.(*ir.AssignStmt).SetLeft(left)
 		}
+		n := n.(*ir.AssignStmt)
 
 		if oaslit(n, init) {
 			return ir.NodAt(n.Pos(), ir.OBLOCK, nil, nil)
@@ -692,33 +718,35 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		case ir.ORECV:
 			// x = <-c; n.Left is x, n.Right.Left is c.
 			// order.stmt made sure x is addressable.
-			n.Right().SetLeft(walkexpr(n.Right().Left(), init))
+			recv := n.Right().(*ir.UnaryExpr)
+			recv.SetLeft(walkexpr(recv.Left(), init))
 
 			n1 := nodAddr(n.Left())
-			r := n.Right().Left() // the channel
+			r := recv.Left() // the channel
 			return mkcall1(chanfn("chanrecv1", 2, r.Type()), nil, init, r, n1)
 
 		case ir.OAPPEND:
 			// x = append(...)
-			r := n.Right()
-			if r.Type().Elem().NotInHeap() {
-				base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", r.Type().Elem())
+			call := n.Right().(*ir.CallExpr)
+			if call.Type().Elem().NotInHeap() {
+				base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", call.Type().Elem())
 			}
+			var r ir.Node
 			switch {
-			case isAppendOfMake(r):
+			case isAppendOfMake(call):
 				// x = append(y, make([]T, y)...)
-				r = extendslice(r, init)
-			case r.IsDDD():
-				r = appendslice(r, init) // also works for append(slice, string).
+				r = extendslice(call, init)
+			case call.IsDDD():
+				r = appendslice(call, init) // also works for append(slice, string).
 			default:
-				r = walkappend(r, init, n)
+				r = walkappend(call, init, n)
 			}
 			n.SetRight(r)
 			if r.Op() == ir.OAPPEND {
 				// Left in place for back end.
 				// Do not add a new write barrier.
 				// Set up address of type for back end.
-				r.SetLeft(typename(r.Type().Elem()))
+				r.(*ir.CallExpr).SetLeft(typename(r.Type().Elem()))
 				return n
 			}
 			// Otherwise, lowered for race detector.
@@ -726,7 +754,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		}
 
 		if n.Left() != nil && n.Right() != nil {
-			n = convas(n, init)
+			return convas(n, init)
 		}
 		return n
 
@@ -734,9 +762,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		init.AppendNodes(n.PtrInit())
 		walkexprlistsafe(n.List().Slice(), init)
 		walkexprlistsafe(n.Rlist().Slice(), init)
-		ll := ascompatee(ir.OAS, n.List().Slice(), n.Rlist().Slice(), init)
-		ll = reorder3(ll)
-		return liststmt(ll)
+		return liststmt(ascompatee(ir.OAS, n.List().Slice(), n.Rlist().Slice(), init))
 
 	// a,b,... = fn()
 	case ir.OAS2FUNC:
@@ -760,7 +786,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 	case ir.OAS2RECV:
 		init.AppendNodes(n.PtrInit())
 
-		r := n.Rlist().First()
+		r := n.Rlist().First().(*ir.UnaryExpr) // recv
 		walkexprlistsafe(n.List().Slice(), init)
 		r.SetLeft(walkexpr(r.Left(), init))
 		var n1 ir.Node
@@ -772,14 +798,13 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		fn := chanfn("chanrecv2", 2, r.Left().Type())
 		ok := n.List().Second()
 		call := mkcall1(fn, types.Types[types.TBOOL], init, r.Left(), n1)
-		n = ir.Nod(ir.OAS, ok, call)
-		return typecheck(n, ctxStmt)
+		return typecheck(ir.Nod(ir.OAS, ok, call), ctxStmt)
 
 	// a,b = m[i]
 	case ir.OAS2MAPR:
 		init.AppendNodes(n.PtrInit())
 
-		r := n.Rlist().First()
+		r := n.Rlist().First().(*ir.IndexExpr)
 		walkexprlistsafe(n.List().Slice(), init)
 		r.SetLeft(walkexpr(r.Left(), init))
 		r.SetRight(walkexpr(r.Right(), init))
@@ -803,37 +828,39 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		//   a = *var
 		a := n.List().First()
 
+		var call *ir.CallExpr
 		if w := t.Elem().Width; w <= zeroValSize {
 			fn := mapfn(mapaccess2[fast], t)
-			r = mkcall1(fn, fn.Type().Results(), init, typename(t), r.Left(), key)
+			call = mkcall1(fn, fn.Type().Results(), init, typename(t), r.Left(), key)
 		} else {
 			fn := mapfn("mapaccess2_fat", t)
 			z := zeroaddr(w)
-			r = mkcall1(fn, fn.Type().Results(), init, typename(t), r.Left(), key, z)
+			call = mkcall1(fn, fn.Type().Results(), init, typename(t), r.Left(), key, z)
 		}
 
 		// mapaccess2* returns a typed bool, but due to spec changes,
 		// the boolean result of i.(T) is now untyped so we make it the
 		// same type as the variable on the lhs.
 		if ok := n.List().Second(); !ir.IsBlank(ok) && ok.Type().IsBoolean() {
-			r.Type().Field(1).Type = ok.Type()
+			call.Type().Field(1).Type = ok.Type()
 		}
-		n.PtrRlist().Set1(r)
+		n.PtrRlist().Set1(call)
 		n.SetOp(ir.OAS2FUNC)
 
 		// don't generate a = *var if a is _
-		if !ir.IsBlank(a) {
-			var_ := temp(types.NewPtr(t.Elem()))
-			var_.SetTypecheck(1)
-			var_.MarkNonNil() // mapaccess always returns a non-nil pointer
-			n.List().SetFirst(var_)
-			n = walkexpr(n, init)
-			init.Append(n)
-			n = ir.Nod(ir.OAS, a, ir.Nod(ir.ODEREF, var_, nil))
+		if ir.IsBlank(a) {
+			return walkexpr(typecheck(n, ctxStmt), init)
 		}
 
-		n = typecheck(n, ctxStmt)
-		return walkexpr(n, init)
+		var_ := temp(types.NewPtr(t.Elem()))
+		var_.SetTypecheck(1)
+		var_.MarkNonNil() // mapaccess always returns a non-nil pointer
+
+		n.List().SetFirst(var_)
+		init.Append(walkexpr(n, init))
+
+		as := ir.Nod(ir.OAS, a, ir.Nod(ir.ODEREF, var_, nil))
+		return walkexpr(typecheck(as, ctxStmt), init)
 
 	case ir.ODELETE:
 		init.AppendNodes(n.PtrInit())
@@ -910,9 +937,10 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			if thearch.LinkArch.ByteOrder == binary.BigEndian {
 				index = ir.Nod(ir.OADD, index, nodintconst(7))
 			}
-			value = ir.Nod(ir.OINDEX, staticuint64s, index)
-			value.SetBounded(true)
-		case n.Left().Name() != nil && n.Left().Class() == ir.PEXTERN && n.Left().Name().Readonly():
+			xe := ir.Nod(ir.OINDEX, staticuint64s, index)
+			xe.SetBounded(true)
+			value = xe
+		case n.Left().Op() == ir.ONAME && n.Left().(*ir.Name).Class() == ir.PEXTERN && n.Left().(*ir.Name).Readonly():
 			// n.Left is a readonly global; use it directly.
 			value = n.Left()
 		case !fromType.IsInterface() && n.Esc() == EscNone && fromType.Width <= 1024:
@@ -1002,12 +1030,12 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		fn := syslook(fnname)
 		fn = substArgTypes(fn, fromType, toType)
 		dowidth(fn.Type())
-		n = ir.Nod(ir.OCALL, fn, nil)
-		n.PtrList().Set2(tab, v)
-		n = typecheck(n, ctxExpr)
-		return walkexpr(n, init)
+		call := ir.Nod(ir.OCALL, fn, nil)
+		call.PtrList().Set2(tab, v)
+		return walkexpr(typecheck(call, ctxExpr), init)
 
 	case ir.OCONV, ir.OCONVNOP:
+		n := n.(*ir.ConvExpr)
 		n.SetLeft(walkexpr(n.Left(), init))
 		if n.Op() == ir.OCONVNOP && n.Type() == n.Left().Type() {
 			return n.Left()
@@ -1036,8 +1064,8 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 		if isComplex[et] && n.Op() == ir.ODIV {
 			t := n.Type()
-			n = mkcall("complex128div", types.Types[types.TCOMPLEX128], init, conv(n.Left(), types.Types[types.TCOMPLEX128]), conv(n.Right(), types.Types[types.TCOMPLEX128]))
-			return conv(n, t)
+			call := mkcall("complex128div", types.Types[types.TCOMPLEX128], init, conv(n.Left(), types.Types[types.TCOMPLEX128]), conv(n.Right(), types.Types[types.TCOMPLEX128]))
+			return conv(call, t)
 		}
 
 		// Nothing to do for float divisions.
@@ -1136,6 +1164,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		map_ := n.Left()
 		key := n.Right()
 		t := map_.Type()
+		var call *ir.CallExpr
 		if n.IndexMapLValue() {
 			// This m[k] expression is on the left-hand side of an assignment.
 			fast := mapfast(t)
@@ -1144,7 +1173,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 				// order.expr made sure key is addressable.
 				key = nodAddr(key)
 			}
-			n = mkcall1(mapfn(mapassign[fast], t), nil, init, typename(t), map_, key)
+			call = mkcall1(mapfn(mapassign[fast], t), nil, init, typename(t), map_, key)
 		} else {
 			// m[k] is not the target of an assignment.
 			fast := mapfast(t)
@@ -1155,18 +1184,18 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			}
 
 			if w := t.Elem().Width; w <= zeroValSize {
-				n = mkcall1(mapfn(mapaccess1[fast], t), types.NewPtr(t.Elem()), init, typename(t), map_, key)
+				call = mkcall1(mapfn(mapaccess1[fast], t), types.NewPtr(t.Elem()), init, typename(t), map_, key)
 			} else {
 				z := zeroaddr(w)
-				n = mkcall1(mapfn("mapaccess1_fat", t), types.NewPtr(t.Elem()), init, typename(t), map_, key, z)
+				call = mkcall1(mapfn("mapaccess1_fat", t), types.NewPtr(t.Elem()), init, typename(t), map_, key, z)
 			}
 		}
-		n.SetType(types.NewPtr(t.Elem()))
-		n.MarkNonNil() // mapaccess1* and mapassign always return non-nil pointers.
-		n = ir.Nod(ir.ODEREF, n, nil)
-		n.SetType(t.Elem())
-		n.SetTypecheck(1)
-		return n
+		call.SetType(types.NewPtr(t.Elem()))
+		call.MarkNonNil() // mapaccess1* and mapassign always return non-nil pointers.
+		star := ir.Nod(ir.ODEREF, call, nil)
+		star.SetType(t.Elem())
+		star.SetTypecheck(1)
+		return star
 
 	case ir.ORECV:
 		base.Fatalf("walkexpr ORECV") // should see inside OAS only
@@ -1179,12 +1208,16 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return n
 
 	case ir.OSLICE, ir.OSLICEARR, ir.OSLICESTR, ir.OSLICE3, ir.OSLICE3ARR:
-		checkSlice := checkPtr(Curfn, 1) && n.Op() == ir.OSLICE3ARR && n.Left().Op() == ir.OCONVNOP && n.Left().Left().Type().IsUnsafePtr()
+		n := n.(*ir.SliceExpr)
+
+		checkSlice := checkPtr(Curfn, 1) && n.Op() == ir.OSLICE3ARR && n.Left().Op() == ir.OCONVNOP && n.Left().(*ir.ConvExpr).Left().Type().IsUnsafePtr()
 		if checkSlice {
-			n.Left().SetLeft(walkexpr(n.Left().Left(), init))
+			conv := n.Left().(*ir.ConvExpr)
+			conv.SetLeft(walkexpr(conv.Left(), init))
 		} else {
 			n.SetLeft(walkexpr(n.Left(), init))
 		}
+
 		low, high, max := n.SliceBounds()
 		low = walkexpr(low, init)
 		if low != nil && isZero(low) {
@@ -1195,10 +1228,11 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		max = walkexpr(max, init)
 		n.SetSliceBounds(low, high, max)
 		if checkSlice {
-			n.SetLeft(walkCheckPtrAlignment(n.Left(), init, max))
+			n.SetLeft(walkCheckPtrAlignment(n.Left().(*ir.ConvExpr), init, max))
 		}
+
 		if n.Op().IsSlice3() {
-			if max != nil && max.Op() == ir.OCAP && samesafeexpr(n.Left(), max.Left()) {
+			if max != nil && max.Op() == ir.OCAP && samesafeexpr(n.Left(), max.(*ir.UnaryExpr).Left()) {
 				// Reduce x[i:j:cap(x)] to x[i:j].
 				if n.Op() == ir.OSLICE3 {
 					n.SetOp(ir.OSLICE)
@@ -1219,17 +1253,14 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			if n.Type().Elem().Width >= maxImplicitStackVarSize {
 				base.Fatalf("large ONEW with EscNone: %v", n)
 			}
-			r := ir.Node(temp(n.Type().Elem()))
-			r = ir.Nod(ir.OAS, r, nil) // zero temp
-			r = typecheck(r, ctxStmt)
-			init.Append(r)
-			r = nodAddr(r.Left())
-			return typecheck(r, ctxExpr)
+			r := temp(n.Type().Elem())
+			init.Append(typecheck(ir.Nod(ir.OAS, r, nil), ctxStmt)) // zero temp
+			return typecheck(nodAddr(r), ctxExpr)
 		}
 		return callnew(n.Type().Elem())
 
 	case ir.OADDSTR:
-		return addstr(n, init)
+		return addstr(n.(*ir.AddStringExpr), init)
 
 	case ir.OAPPEND:
 		// order should make sure we only see OAS(node, OAPPEND), which we handle above.
@@ -1237,7 +1268,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		panic("unreachable")
 
 	case ir.OCOPY:
-		return copyany(n, init, instrumenting && !base.Flag.CompilingRuntime)
+		return copyany(n.(*ir.BinaryExpr), init, instrumenting && !base.Flag.CompilingRuntime)
 
 	case ir.OCLOSE:
 		// cannot use chanfn - closechan takes any, not chan any
@@ -1474,9 +1505,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			fn = syslook("memmove")
 			fn = substArgTypes(fn, t.Elem(), t.Elem())
 			ncopy := mkcall1(fn, nil, init, ir.Nod(ir.OSPTR, s, nil), copyptr, size)
-			ncopy = typecheck(ncopy, ctxStmt)
-			ncopy = walkexpr(ncopy, init)
-			init.Append(ncopy)
+			init.Append(walkexpr(typecheck(ncopy, ctxStmt), init))
 
 			return s
 		}
@@ -1488,8 +1517,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		s.Left().MarkNonNil()
 		s.PtrList().Set2(length, length)
 		s.SetType(t)
-		n = typecheck(s, ctxExpr)
-		return walkexpr(n, init)
+		return walkexpr(typecheck(s, ctxExpr), init)
 
 	case ir.ORUNESTR:
 		a := nodnil()
@@ -1591,6 +1619,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 	case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT, ir.OSTRUCTLIT, ir.OPTRLIT:
 		if isStaticCompositeLiteral(n) && !canSSAType(n.Type()) {
+			n := n.(*ir.CompLitExpr) // not OPTRLIT
 			// n can be directly represented in the read-only data section.
 			// Make direct reference to the static data. See issue 12841.
 			vstat := readonlystaticname(n.Type())
@@ -1633,14 +1662,15 @@ func markTypeUsedInInterface(t *types.Type, from *obj.LSym) {
 
 // markUsedIfaceMethod marks that an interface method is used in the current
 // function. n is OCALLINTER node.
-func markUsedIfaceMethod(n ir.Node) {
-	ityp := n.Left().Left().Type()
+func markUsedIfaceMethod(n *ir.CallExpr) {
+	dot := n.Left().(*ir.SelectorExpr)
+	ityp := dot.Left().Type()
 	tsym := typenamesym(ityp).Linksym()
 	r := obj.Addrel(Curfn.LSym)
 	r.Sym = tsym
-	// n.Left.Xoffset is the method index * Widthptr (the offset of code pointer
+	// dot.Xoffset is the method index * Widthptr (the offset of code pointer
 	// in itab).
-	midx := n.Left().Offset() / int64(Widthptr)
+	midx := dot.Offset() / int64(Widthptr)
 	r.Add = ifaceMethodOffset(ityp, midx)
 	r.Type = objabi.R_USEIFACEMETHOD
 }
@@ -1692,9 +1722,9 @@ func rtconvfn(src, dst *types.Type) (param, result types.Kind) {
 }
 
 // TODO(josharian): combine this with its caller and simplify
-func reduceSlice(n ir.Node) ir.Node {
+func reduceSlice(n *ir.SliceExpr) ir.Node {
 	low, high, max := n.SliceBounds()
-	if high != nil && high.Op() == ir.OLEN && samesafeexpr(n.Left(), high.Left()) {
+	if high != nil && high.Op() == ir.OLEN && samesafeexpr(n.Left(), high.(*ir.UnaryExpr).Left()) {
 		// Reduce x[i:len(x)] to x[i:].
 		high = nil
 	}
@@ -1709,10 +1739,10 @@ func reduceSlice(n ir.Node) ir.Node {
 	return n
 }
 
-func ascompatee1(l ir.Node, r ir.Node, init *ir.Nodes) ir.Node {
+func ascompatee1(l ir.Node, r ir.Node, init *ir.Nodes) *ir.AssignStmt {
 	// convas will turn map assigns into function calls,
 	// making it impossible for reorder3 to work.
-	n := ir.Nod(ir.OAS, l, r)
+	n := ir.NewAssignStmt(base.Pos, l, r)
 
 	if l.Op() == ir.OINDEXMAP {
 		return n
@@ -1734,7 +1764,7 @@ func ascompatee(op ir.Op, nl, nr []ir.Node, init *ir.Nodes) []ir.Node {
 		nr[i1] = safeexpr(nr[i1], init)
 	}
 
-	var nn []ir.Node
+	var nn []*ir.AssignStmt
 	i := 0
 	for ; i < len(nl); i++ {
 		if i >= len(nr) {
@@ -1754,7 +1784,7 @@ func ascompatee(op ir.Op, nl, nr []ir.Node, init *ir.Nodes) []ir.Node {
 		nrn.Set(nr)
 		base.Fatalf("error in shape across %+v %v %+v / %d %d [%s]", nln, op, nrn, len(nl), len(nr), ir.FuncName(Curfn))
 	}
-	return nn
+	return reorder3(nn)
 }
 
 // fncall reports whether assigning an rvalue of type rt to an lvalue l might involve a function call.
@@ -1789,7 +1819,7 @@ func ascompatet(nl ir.Nodes, nr *types.Type) []ir.Node {
 		if fncall(l, r.Type) {
 			tmp := ir.Node(temp(r.Type))
 			tmp = typecheck(tmp, ctxExpr)
-			a := convas(ir.Nod(ir.OAS, l, tmp), &mm)
+			a := convas(ir.NewAssignStmt(base.Pos, l, tmp), &mm)
 			mm.Append(a)
 			l = tmp
 		}
@@ -1799,7 +1829,7 @@ func ascompatet(nl ir.Nodes, nr *types.Type) []ir.Node {
 		res.SetType(r.Type)
 		res.SetTypecheck(1)
 
-		a := convas(ir.Nod(ir.OAS, l, res), &nn)
+		a := convas(ir.NewAssignStmt(base.Pos, l, res), &nn)
 		updateHasCall(a)
 		if a.HasCall() {
 			ir.Dump("ascompatet ucount", a)
@@ -1818,9 +1848,10 @@ func mkdotargslice(typ *types.Type, args []ir.Node) ir.Node {
 		n = nodnil()
 		n.SetType(typ)
 	} else {
-		n = ir.Nod(ir.OCOMPLIT, nil, ir.TypeNode(typ))
-		n.PtrList().Append(args...)
-		n.SetImplicit(true)
+		lit := ir.Nod(ir.OCOMPLIT, nil, ir.TypeNode(typ))
+		lit.PtrList().Append(args...)
+		lit.SetImplicit(true)
+		n = lit
 	}
 
 	n = typecheck(n, ctxExpr)
@@ -1832,7 +1863,7 @@ func mkdotargslice(typ *types.Type, args []ir.Node) ir.Node {
 
 // fixVariadicCall rewrites calls to variadic functions to use an
 // explicit ... argument if one is not already present.
-func fixVariadicCall(call ir.Node) {
+func fixVariadicCall(call *ir.CallExpr) {
 	fntype := call.Left().Type()
 	if !fntype.IsVariadic() || call.IsDDD() {
 		return
@@ -1852,7 +1883,7 @@ func fixVariadicCall(call ir.Node) {
 	call.SetIsDDD(true)
 }
 
-func walkCall(n ir.Node, init *ir.Nodes) {
+func walkCall(n *ir.CallExpr, init *ir.Nodes) {
 	if n.Rlist().Len() != 0 {
 		return // already walked
 	}
@@ -1866,8 +1897,9 @@ func walkCall(n ir.Node, init *ir.Nodes) {
 	// If this is a method call, add the receiver at the beginning of the args.
 	if n.Op() == ir.OCALLMETH {
 		withRecv := make([]ir.Node, len(args)+1)
-		withRecv[0] = n.Left().Left()
-		n.Left().SetLeft(nil)
+		dot := n.Left().(*ir.SelectorExpr)
+		withRecv[0] = dot.Left()
+		dot.SetLeft(nil)
 		copy(withRecv[1:], args)
 		args = withRecv
 	}
@@ -1893,7 +1925,7 @@ func walkCall(n ir.Node, init *ir.Nodes) {
 		if instrumenting || fncall(arg, t) {
 			// make assignment of fncall to tempAt
 			tmp := temp(t)
-			a := convas(ir.Nod(ir.OAS, tmp, arg), init)
+			a := convas(ir.NewAssignStmt(base.Pos, tmp, arg), init)
 			tempAssigns = append(tempAssigns, a)
 			// replace arg with temp
 			args[i] = tmp
@@ -1905,7 +1937,7 @@ func walkCall(n ir.Node, init *ir.Nodes) {
 }
 
 // generate code for print
-func walkprint(nn ir.Node, init *ir.Nodes) ir.Node {
+func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 	// Hoist all the argument evaluation up before the lock.
 	walkexprlistcheap(nn.List().Slice(), init)
 
@@ -2078,7 +2110,7 @@ func isReflectHeaderDataField(l ir.Node) bool {
 	return tsym.Name == "SliceHeader" || tsym.Name == "StringHeader"
 }
 
-func convas(n ir.Node, init *ir.Nodes) ir.Node {
+func convas(n *ir.AssignStmt, init *ir.Nodes) *ir.AssignStmt {
 	if n.Op() != ir.OAS {
 		base.Fatalf("convas: not OAS %v", n.Op())
 	}
@@ -2110,13 +2142,14 @@ func convas(n ir.Node, init *ir.Nodes) ir.Node {
 	return n
 }
 
-// from ascompat[ee]
+// reorder3
+// from ascompatee
 //	a,b = c,d
 // simultaneous assignment. there cannot
 // be later use of an earlier lvalue.
 //
 // function calls have been removed.
-func reorder3(all []ir.Node) []ir.Node {
+func reorder3(all []*ir.AssignStmt) []ir.Node {
 	// If a needed expression may be affected by an
 	// earlier assignment, make an early copy of that
 	// expression and use the copy instead.
@@ -2129,17 +2162,20 @@ func reorder3(all []ir.Node) []ir.Node {
 		// Save subexpressions needed on left side.
 		// Drill through non-dereferences.
 		for {
-			if l.Op() == ir.ODOT || l.Op() == ir.OPAREN {
-				l = l.Left()
+			switch ll := l; ll.Op() {
+			case ir.ODOT:
+				l = ll.Left()
 				continue
-			}
-
-			if l.Op() == ir.OINDEX && l.Left().Type().IsArray() {
-				l.SetRight(reorder3save(l.Right(), all, i, &early))
-				l = l.Left()
+			case ir.OPAREN:
+				l = ll.Left()
 				continue
+			case ir.OINDEX:
+				if ll.Left().Type().IsArray() {
+					ll.SetRight(reorder3save(ll.Right(), all, i, &early))
+					l = ll.Left()
+					continue
+				}
 			}
-
 			break
 		}
 
@@ -2157,7 +2193,9 @@ func reorder3(all []ir.Node) []ir.Node {
 				all[i] = convas(all[i], &mapinit)
 			}
 
-		case ir.ODEREF, ir.ODOTPTR:
+		case ir.ODEREF:
+			l.SetLeft(reorder3save(l.Left(), all, i, &early))
+		case ir.ODOTPTR:
 			l.SetLeft(reorder3save(l.Left(), all, i, &early))
 		}
 
@@ -2166,7 +2204,10 @@ func reorder3(all []ir.Node) []ir.Node {
 	}
 
 	early = append(mapinit.Slice(), early...)
-	return append(early, all...)
+	for _, as := range all {
+		early = append(early, as)
+	}
+	return early
 }
 
 // if the evaluation of *np would be affected by the
@@ -2175,31 +2216,36 @@ func reorder3(all []ir.Node) []ir.Node {
 // replace *np with that temp.
 // The result of reorder3save MUST be assigned back to n, e.g.
 // 	n.Left = reorder3save(n.Left, all, i, early)
-func reorder3save(n ir.Node, all []ir.Node, i int, early *[]ir.Node) ir.Node {
+func reorder3save(n ir.Node, all []*ir.AssignStmt, i int, early *[]ir.Node) ir.Node {
 	if !aliased(n, all[:i]) {
 		return n
 	}
 
 	q := ir.Node(temp(n.Type()))
-	q = ir.Nod(ir.OAS, q, n)
-	q = typecheck(q, ctxStmt)
-	*early = append(*early, q)
-	return q.Left()
+	as := typecheck(ir.Nod(ir.OAS, q, n), ctxStmt)
+	*early = append(*early, as)
+	return q
 }
 
 // what's the outer value that a write to n affects?
 // outer value means containing struct or array.
 func outervalue(n ir.Node) ir.Node {
 	for {
-		switch n.Op() {
+		switch nn := n; nn.Op() {
 		case ir.OXDOT:
 			base.Fatalf("OXDOT in walk")
-		case ir.ODOT, ir.OPAREN, ir.OCONVNOP:
-			n = n.Left()
+		case ir.ODOT:
+			n = nn.Left()
+			continue
+		case ir.OPAREN:
+			n = nn.Left()
+			continue
+		case ir.OCONVNOP:
+			n = nn.Left()
 			continue
 		case ir.OINDEX:
-			if n.Left().Type() != nil && n.Left().Type().IsArray() {
-				n = n.Left()
+			if nn.Left().Type() != nil && nn.Left().Type().IsArray() {
+				n = nn.Left()
 				continue
 			}
 		}
@@ -2210,7 +2256,7 @@ func outervalue(n ir.Node) ir.Node {
 
 // Is it possible that the computation of r might be
 // affected by assignments in all?
-func aliased(r ir.Node, all []ir.Node) bool {
+func aliased(r ir.Node, all []*ir.AssignStmt) bool {
 	if r == nil {
 		return false
 	}
@@ -2218,7 +2264,7 @@ func aliased(r ir.Node, all []ir.Node) bool {
 	// Treat all fields of a struct as referring to the whole struct.
 	// We could do better but we would have to keep track of the fields.
 	for r.Op() == ir.ODOT {
-		r = r.Left()
+		r = r.(*ir.SelectorExpr).Left()
 	}
 
 	// Look for obvious aliasing: a variable being assigned
@@ -2233,11 +2279,12 @@ func aliased(r ir.Node, all []ir.Node) bool {
 			continue
 		}
 
-		l := outervalue(as.Left())
-		if l.Op() != ir.ONAME {
+		lv := outervalue(as.Left())
+		if lv.Op() != ir.ONAME {
 			memwrite = true
 			continue
 		}
+		l := lv.(*ir.Name)
 
 		switch l.Class() {
 		default:
@@ -2253,7 +2300,7 @@ func aliased(r ir.Node, all []ir.Node) bool {
 				continue
 			}
 
-			if vmatch2(l, r) {
+			if refersToName(l, r) {
 				// Direct hit: l appears in r.
 				return true
 			}
@@ -2269,10 +2316,10 @@ func aliased(r ir.Node, all []ir.Node) bool {
 		return false
 	}
 
-	// If r does not refer to computed addresses
-	// (that is, if r only refers to variables whose addresses
-	// have not been taken), no aliasing.
-	if varexpr(r) {
+	// If r does not refer to any variables whose addresses have been taken,
+	// then the only possible writes to r would be directly to the variables,
+	// and we checked those above, so no aliasing problems.
+	if !anyAddrTaken(r) {
 		return false
 	}
 
@@ -2281,127 +2328,103 @@ func aliased(r ir.Node, all []ir.Node) bool {
 	return true
 }
 
-// does the evaluation of n only refer to variables
-// whose addresses have not been taken?
-// (and no other memory)
-func varexpr(n ir.Node) bool {
-	if n == nil {
-		return true
-	}
+// anyAddrTaken reports whether the evaluation n,
+// which appears on the left side of an assignment,
+// may refer to variables whose addresses have been taken.
+func anyAddrTaken(n ir.Node) bool {
+	return ir.Any(n, func(n ir.Node) bool {
+		switch n.Op() {
+		case ir.ONAME:
+			return n.Class() == ir.PEXTERN || n.Class() == ir.PAUTOHEAP || n.Name().Addrtaken()
 
-	switch n.Op() {
-	case ir.OLITERAL, ir.ONIL:
-		return true
+		case ir.ODOT: // but not ODOTPTR - should have been handled in aliased.
+			base.Fatalf("anyAddrTaken unexpected ODOT")
 
-	case ir.ONAME:
-		switch n.Class() {
-		case ir.PAUTO, ir.PPARAM, ir.PPARAMOUT:
-			if !n.Name().Addrtaken() {
-				return true
-			}
+		case ir.OADD,
+			ir.OAND,
+			ir.OANDAND,
+			ir.OANDNOT,
+			ir.OBITNOT,
+			ir.OCONV,
+			ir.OCONVIFACE,
+			ir.OCONVNOP,
+			ir.ODIV,
+			ir.ODOTTYPE,
+			ir.OLITERAL,
+			ir.OLSH,
+			ir.OMOD,
+			ir.OMUL,
+			ir.ONEG,
+			ir.ONIL,
+			ir.OOR,
+			ir.OOROR,
+			ir.OPAREN,
+			ir.OPLUS,
+			ir.ORSH,
+			ir.OSUB,
+			ir.OXOR:
+			return false
 		}
-
-		return false
-
-	case ir.OADD,
-		ir.OSUB,
-		ir.OOR,
-		ir.OXOR,
-		ir.OMUL,
-		ir.ODIV,
-		ir.OMOD,
-		ir.OLSH,
-		ir.ORSH,
-		ir.OAND,
-		ir.OANDNOT,
-		ir.OPLUS,
-		ir.ONEG,
-		ir.OBITNOT,
-		ir.OPAREN,
-		ir.OANDAND,
-		ir.OOROR,
-		ir.OCONV,
-		ir.OCONVNOP,
-		ir.OCONVIFACE,
-		ir.ODOTTYPE:
-		return varexpr(n.Left()) && varexpr(n.Right())
-
-	case ir.ODOT: // but not ODOTPTR
-		// Should have been handled in aliased.
-		base.Fatalf("varexpr unexpected ODOT")
-	}
-
-	// Be conservative.
-	return false
+		// Be conservative.
+		return true
+	})
 }
 
-// is the name l mentioned in r?
-func vmatch2(l ir.Node, r ir.Node) bool {
-	if r == nil {
-		return false
-	}
-	switch r.Op() {
-	// match each right given left
-	case ir.ONAME:
-		return l == r
-
-	case ir.OLITERAL, ir.ONIL:
-		return false
-	}
-
-	if vmatch2(l, r.Left()) {
-		return true
-	}
-	if vmatch2(l, r.Right()) {
-		return true
-	}
-	for _, n := range r.List().Slice() {
-		if vmatch2(l, n) {
-			return true
-		}
-	}
-	return false
+// refersToName reports whether r refers to name.
+func refersToName(name *ir.Name, r ir.Node) bool {
+	return ir.Any(r, func(r ir.Node) bool {
+		return r.Op() == ir.ONAME && r == name
+	})
 }
 
-// is any name mentioned in l also mentioned in r?
-// called by sinit.go
-func vmatch1(l ir.Node, r ir.Node) bool {
-	// isolate all left sides
+var stop = errors.New("stop")
+
+// refersToCommonName reports whether any name
+// appears in common between l and r.
+// This is called from sinit.go.
+func refersToCommonName(l ir.Node, r ir.Node) bool {
 	if l == nil || r == nil {
 		return false
 	}
-	switch l.Op() {
-	case ir.ONAME:
-		switch l.Class() {
-		case ir.PPARAM, ir.PAUTO:
-			break
 
-		default:
-			// assignment to non-stack variable must be
-			// delayed if right has function calls.
-			if r.HasCall() {
-				return true
+	// This could be written elegantly as a Find nested inside a Find:
+	//
+	//	found := ir.Find(l, func(l ir.Node) interface{} {
+	//		if l.Op() == ir.ONAME {
+	//			return ir.Find(r, func(r ir.Node) interface{} {
+	//				if r.Op() == ir.ONAME && l.Name() == r.Name() {
+	//					return r
+	//				}
+	//				return nil
+	//			})
+	//		}
+	//		return nil
+	//	})
+	//	return found != nil
+	//
+	// But that would allocate a new closure for the inner Find
+	// for each name found on the left side.
+	// It may not matter at all, but the below way of writing it
+	// only allocates two closures, not O(|L|) closures.
+
+	var doL, doR func(ir.Node) error
+	var targetL *ir.Name
+	doR = func(r ir.Node) error {
+		if r.Op() == ir.ONAME && r.Name() == targetL {
+			return stop
+		}
+		return ir.DoChildren(r, doR)
+	}
+	doL = func(l ir.Node) error {
+		if l.Op() == ir.ONAME {
+			targetL = l.Name()
+			if doR(r) == stop {
+				return stop
 			}
 		}
-
-		return vmatch2(l, r)
-
-	case ir.OLITERAL, ir.ONIL:
-		return false
-	}
-
-	if vmatch1(l.Left(), r) {
-		return true
-	}
-	if vmatch1(l.Right(), r) {
-		return true
-	}
-	for _, n := range l.List().Slice() {
-		if vmatch1(n, r) {
-			return true
-		}
+		return ir.DoChildren(l, doL)
 	}
-	return false
+	return doL(l) == stop
 }
 
 // paramstoheap returns code to allocate memory for heap-escaped parameters
@@ -2490,7 +2513,7 @@ func heapmoves() {
 	base.Pos = lno
 }
 
-func vmkcall(fn ir.Node, t *types.Type, init *ir.Nodes, va []ir.Node) ir.Node {
+func vmkcall(fn ir.Node, t *types.Type, init *ir.Nodes, va []ir.Node) *ir.CallExpr {
 	if fn.Type() == nil || fn.Type().Kind() != types.TFUNC {
 		base.Fatalf("mkcall %v %v", fn, fn.Type())
 	}
@@ -2508,14 +2531,14 @@ func vmkcall(fn ir.Node, t *types.Type, init *ir.Nodes, va []ir.Node) ir.Node {
 	}
 	r1 := typecheck(call, ctx)
 	r1.SetType(t)
-	return walkexpr(r1, init)
+	return walkexpr(r1, init).(*ir.CallExpr)
 }
 
-func mkcall(name string, t *types.Type, init *ir.Nodes, args ...ir.Node) ir.Node {
+func mkcall(name string, t *types.Type, init *ir.Nodes, args ...ir.Node) *ir.CallExpr {
 	return vmkcall(syslook(name), t, init, args)
 }
 
-func mkcall1(fn ir.Node, t *types.Type, init *ir.Nodes, args ...ir.Node) ir.Node {
+func mkcall1(fn ir.Node, t *types.Type, init *ir.Nodes, args ...ir.Node) *ir.CallExpr {
 	return vmkcall(fn, t, init, args)
 }
 
@@ -2650,8 +2673,7 @@ func writebarrierfn(name string, l *types.Type, r *types.Type) ir.Node {
 	return fn
 }
 
-func addstr(n ir.Node, init *ir.Nodes) ir.Node {
-	// order.expr rewrote OADDSTR to have a list of strings.
+func addstr(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
 	c := n.List().Len()
 
 	if c < 2 {
@@ -2710,7 +2732,7 @@ func addstr(n ir.Node, init *ir.Nodes) ir.Node {
 	return r1
 }
 
-func walkAppendArgs(n ir.Node, init *ir.Nodes) {
+func walkAppendArgs(n *ir.CallExpr, init *ir.Nodes) {
 	walkexprlistsafe(n.List().Slice(), init)
 
 	// walkexprlistsafe will leave OINDEX (s[n]) alone if both s
@@ -2736,7 +2758,7 @@ func walkAppendArgs(n ir.Node, init *ir.Nodes) {
 //   s
 //
 // l2 is allowed to be a string.
-func appendslice(n ir.Node, init *ir.Nodes) ir.Node {
+func appendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	walkAppendArgs(n, init)
 
 	l1 := n.List().First()
@@ -2840,12 +2862,16 @@ func isAppendOfMake(n ir.Node) bool {
 		base.Fatalf("missing typecheck: %+v", n)
 	}
 
-	if n.Op() != ir.OAPPEND || !n.IsDDD() || n.List().Len() != 2 {
+	if n.Op() != ir.OAPPEND {
+		return false
+	}
+	call := n.(*ir.CallExpr)
+	if !call.IsDDD() || call.List().Len() != 2 || call.List().Second().Op() != ir.OMAKESLICE {
 		return false
 	}
 
-	second := n.List().Second()
-	if second.Op() != ir.OMAKESLICE || second.Right() != nil {
+	mk := call.List().Second().(*ir.MakeExpr)
+	if mk.Right() != nil {
 		return false
 	}
 
@@ -2855,7 +2881,7 @@ func isAppendOfMake(n ir.Node) bool {
 	// typecheck made sure that constant arguments to make are not negative and fit into an int.
 
 	// The care of overflow of the len argument to make will be handled by an explicit check of int(len) < 0 during runtime.
-	y := second.Left()
+	y := mk.Left()
 	if !ir.IsConst(y, constant.Int) && y.Type().Size() > types.Types[types.TUINT].Size() {
 		return false
 	}
@@ -2890,11 +2916,11 @@ func isAppendOfMake(n ir.Node) bool {
 //     }
 //   }
 //   s
-func extendslice(n ir.Node, init *ir.Nodes) ir.Node {
+func extendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	// isAppendOfMake made sure all possible positive values of l2 fit into an uint.
 	// The case of l2 overflow when converting from e.g. uint to int is handled by an explicit
 	// check of l2 < 0 at runtime which is generated below.
-	l2 := conv(n.List().Second().Left(), types.Types[types.TINT])
+	l2 := conv(n.List().Second().(*ir.MakeExpr).Left(), types.Types[types.TINT])
 	l2 = typecheck(l2, ctxExpr)
 	n.List().SetSecond(l2) // walkAppendArgs expects l2 in n.List.Second().
 
@@ -3007,7 +3033,7 @@ func extendslice(n ir.Node, init *ir.Nodes) ir.Node {
 //     ...
 //   }
 //   s
-func walkappend(n ir.Node, init *ir.Nodes, dst ir.Node) ir.Node {
+func walkappend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
 	if !samesafeexpr(dst, n.List().First()) {
 		n.List().SetFirst(safeexpr(n.List().First(), init))
 		n.List().SetFirst(walkexpr(n.List().First(), init))
@@ -3096,7 +3122,7 @@ func walkappend(n ir.Node, init *ir.Nodes, dst ir.Node) ir.Node {
 //
 // Also works if b is a string.
 //
-func copyany(n ir.Node, init *ir.Nodes, runtimecall bool) ir.Node {
+func copyany(n *ir.BinaryExpr, init *ir.Nodes, runtimecall bool) ir.Node {
 	if n.Left().Type().Elem().HasPointers() {
 		Curfn.SetWBPos(n.Pos())
 		fn := writebarrierfn("typedslicecopy", n.Left().Type().Elem(), n.Right().Type().Elem())
@@ -3194,7 +3220,7 @@ func eqfor(t *types.Type) (n ir.Node, needsize bool) {
 
 // The result of walkcompare MUST be assigned back to n, e.g.
 // 	n.Left = walkcompare(n.Left, init)
-func walkcompare(n ir.Node, init *ir.Nodes) ir.Node {
+func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 	if n.Left().Type().IsInterface() && n.Right().Type().IsInterface() && n.Left().Op() != ir.ONIL && n.Right().Op() != ir.ONIL {
 		return walkcompareInterface(n, init)
 	}
@@ -3245,8 +3271,7 @@ func walkcompare(n ir.Node, init *ir.Nodes) ir.Node {
 		eqdata := ir.NewBinaryExpr(base.Pos, eq, ifaceData(n.Pos(), l, r.Type()), r)
 		// Put it all together.
 		expr := ir.NewLogicalExpr(base.Pos, andor, eqtype, eqdata)
-		n = finishcompare(n, expr, init)
-		return n
+		return finishcompare(n, expr, init)
 	}
 
 	// Must be comparison of array or struct.
@@ -3321,11 +3346,11 @@ func walkcompare(n ir.Node, init *ir.Nodes) ir.Node {
 
 	cmpl := n.Left()
 	for cmpl != nil && cmpl.Op() == ir.OCONVNOP {
-		cmpl = cmpl.Left()
+		cmpl = cmpl.(*ir.ConvExpr).Left()
 	}
 	cmpr := n.Right()
 	for cmpr != nil && cmpr.Op() == ir.OCONVNOP {
-		cmpr = cmpr.Left()
+		cmpr = cmpr.(*ir.ConvExpr).Left()
 	}
 
 	// Chose not to inline. Call equality function directly.
@@ -3346,8 +3371,7 @@ func walkcompare(n ir.Node, init *ir.Nodes) ir.Node {
 		if n.Op() != ir.OEQ {
 			res = ir.Nod(ir.ONOT, res, nil)
 		}
-		n = finishcompare(n, res, init)
-		return n
+		return finishcompare(n, res, init)
 	}
 
 	// inline: build boolean expression comparing element by element
@@ -3442,8 +3466,7 @@ func walkcompare(n ir.Node, init *ir.Nodes) ir.Node {
 		a2 := typecheck(ir.Nod(ir.OAS, t, cmpr), ctxStmt)
 		init.Append(a1, a2)
 	}
-	n = finishcompare(n, expr, init)
-	return n
+	return finishcompare(n, expr, init)
 }
 
 func tracecmpArg(n ir.Node, t *types.Type, init *ir.Nodes) ir.Node {
@@ -3455,7 +3478,7 @@ func tracecmpArg(n ir.Node, t *types.Type, init *ir.Nodes) ir.Node {
 	return conv(n, t)
 }
 
-func walkcompareInterface(n ir.Node, init *ir.Nodes) ir.Node {
+func walkcompareInterface(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 	n.SetRight(cheapexpr(n.Right(), init))
 	n.SetLeft(cheapexpr(n.Left(), init))
 	eqtab, eqdata := eqinterface(n.Left(), n.Right())
@@ -3469,7 +3492,7 @@ func walkcompareInterface(n ir.Node, init *ir.Nodes) ir.Node {
 	return finishcompare(n, cmp, init)
 }
 
-func walkcompareString(n ir.Node, init *ir.Nodes) ir.Node {
+func walkcompareString(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 	// Rewrite comparisons to short constant strings as length+byte-wise comparisons.
 	var cs, ncs ir.Node // const string, non-const string
 	switch {
@@ -3594,7 +3617,7 @@ func walkcompareString(n ir.Node, init *ir.Nodes) ir.Node {
 
 // The result of finishcompare MUST be assigned back to n, e.g.
 // 	n.Left = finishcompare(n.Left, x, r, init)
-func finishcompare(n, r ir.Node, init *ir.Nodes) ir.Node {
+func finishcompare(n *ir.BinaryExpr, r ir.Node, init *ir.Nodes) ir.Node {
 	r = typecheck(r, ctxExpr)
 	r = conv(r, n.Type())
 	r = walkexpr(r, init)
@@ -3669,7 +3692,7 @@ func bounded(n ir.Node, max int64) bool {
 }
 
 // usemethod checks interface method calls for uses of reflect.Type.Method.
-func usemethod(n ir.Node) {
+func usemethod(n *ir.CallExpr) {
 	t := n.Left().Type()
 
 	// Looking for either of:
@@ -3714,7 +3737,7 @@ func usemethod(n ir.Node) {
 	}
 }
 
-func usefield(n ir.Node) {
+func usefield(n *ir.SelectorExpr) {
 	if objabi.Fieldtrack_enabled == 0 {
 		return
 	}
@@ -3736,7 +3759,7 @@ func usefield(n ir.Node) {
 	if t.IsPtr() {
 		t = t.Elem()
 	}
-	field := n.(*ir.SelectorExpr).Selection
+	field := n.Selection
 	if field == nil {
 		base.Fatalf("usefield %v %v without paramfld", n.Left().Type(), n.Sym())
 	}
@@ -3871,7 +3894,7 @@ var wrapCall_prgen int
 
 // The result of wrapCall MUST be assigned back to n, e.g.
 // 	n.Left = wrapCall(n.Left, init)
-func wrapCall(n ir.Node, init *ir.Nodes) ir.Node {
+func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	if n.Init().Len() != 0 {
 		walkstmtlist(n.Init().Slice())
 		init.AppendNodes(n.PtrInit())
@@ -3893,9 +3916,9 @@ func wrapCall(n ir.Node, init *ir.Nodes) ir.Node {
 	var funcArgs []*ir.Field
 	for i, arg := range n.List().Slice() {
 		s := lookupN("a", i)
-		if !isBuiltinCall && arg.Op() == ir.OCONVNOP && arg.Type().IsUintptr() && arg.Left().Type().IsUnsafePtr() {
+		if !isBuiltinCall && arg.Op() == ir.OCONVNOP && arg.Type().IsUintptr() && arg.(*ir.ConvExpr).Left().Type().IsUnsafePtr() {
 			origArgs[i] = arg
-			arg = arg.Left()
+			arg = arg.(*ir.ConvExpr).Left()
 			n.List().SetIndex(i, arg)
 		}
 		funcArgs = append(funcArgs, symfield(s, arg.Type()))
@@ -3966,10 +3989,10 @@ func canMergeLoads() bool {
 // isRuneCount reports whether n is of the form len([]rune(string)).
 // These are optimized into a call to runtime.countrunes.
 func isRuneCount(n ir.Node) bool {
-	return base.Flag.N == 0 && !instrumenting && n.Op() == ir.OLEN && n.Left().Op() == ir.OSTR2RUNES
+	return base.Flag.N == 0 && !instrumenting && n.Op() == ir.OLEN && n.(*ir.UnaryExpr).Left().Op() == ir.OSTR2RUNES
 }
 
-func walkCheckPtrAlignment(n ir.Node, init *ir.Nodes, count ir.Node) ir.Node {
+func walkCheckPtrAlignment(n *ir.ConvExpr, init *ir.Nodes, count ir.Node) ir.Node {
 	if !n.Type().IsPtr() {
 		base.Fatalf("expected pointer type: %v", n.Type())
 	}
@@ -3997,7 +4020,7 @@ func walkCheckPtrAlignment(n ir.Node, init *ir.Nodes, count ir.Node) ir.Node {
 
 var walkCheckPtrArithmeticMarker byte
 
-func walkCheckPtrArithmetic(n ir.Node, init *ir.Nodes) ir.Node {
+func walkCheckPtrArithmetic(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 	// Calling cheapexpr(n, init) below leads to a recursive call
 	// to walkexpr, which leads us back here again. Use n.Opt to
 	// prevent infinite loops.
@@ -4046,16 +4069,16 @@ func walkCheckPtrArithmetic(n ir.Node, init *ir.Nodes) ir.Node {
 	}
 	walk(n.Left())
 
-	n = cheapexpr(n, init)
+	cheap := cheapexpr(n, init)
 
 	slice := mkdotargslice(types.NewSlice(types.Types[types.TUNSAFEPTR]), originals)
 	slice.SetEsc(EscNone)
 
-	init.Append(mkcall("checkptrArithmetic", nil, init, convnop(n, types.Types[types.TUNSAFEPTR]), slice))
+	init.Append(mkcall("checkptrArithmetic", nil, init, convnop(cheap, types.Types[types.TUNSAFEPTR]), slice))
 	// TODO(khr): Mark backing store of slice as dead. This will allow us to reuse
 	// the backing store for multiple calls to checkptrArithmetic.
 
-	return n
+	return cheap
 }
 
 // checkPtr reports whether pointer checking should be enabled for
-- 
GitLab


From 4e8f1e139f5c69a1d596a54b035d6fc4fb08b94d Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 10 Dec 2020 18:47:09 -0500
Subject: [PATCH 0263/2400] [dev.regabi] cmd/compile: cleanup for concrete
 types - sinit

An automated rewrite will add concrete type assertions after
a test of n.Op(), when n can be safely type-asserted
(meaning, n is not reassigned a different type, n is not reassigned
and then used outside the scope of the type assertion,
and so on).

This sequence of CLs handles the code that the automated
rewrite does not: adding specific types to function arguments,
adjusting code not to call n.Left() etc when n may have multiple
representations, and so on.

This CL focuses on sinit.go.

Passes buildall w/ toolstash -cmp.

Change-Id: I3e9458e69a7a9b3f2fe139382bf961bc4473cc42
Reviewed-on: https://go-review.googlesource.com/c/go/+/277928
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/iexport.go   |   6 +-
 src/cmd/compile/internal/gc/initorder.go |   2 +-
 src/cmd/compile/internal/gc/inl.go       |   3 +-
 src/cmd/compile/internal/gc/obj.go       |  25 +--
 src/cmd/compile/internal/gc/sinit.go     | 214 ++++++++++++++---------
 src/cmd/compile/internal/gc/ssa.go       |   3 +-
 src/cmd/compile/internal/gc/typecheck.go |  14 +-
 src/cmd/compile/internal/ir/expr.go      |  40 ++---
 src/cmd/compile/internal/ir/fmt.go       |  14 +-
 src/cmd/compile/internal/ir/node.go      |   2 -
 src/cmd/compile/internal/ir/node_gen.go  |   8 +-
 11 files changed, 194 insertions(+), 137 deletions(-)

diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index eac9f29e65..b54eeca7cb 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -1266,10 +1266,12 @@ func (w *exportWriter) expr(n ir.Node) {
 		// Special case: explicit name of func (*T) method(...) is turned into pkg.(*T).method,
 		// but for export, this should be rendered as (*pkg.T).meth.
 		// These nodes have the special property that they are names with a left OTYPE and a right ONAME.
+		n := n.(*ir.MethodExpr)
 		w.op(ir.OXDOT)
 		w.pos(n.Pos())
-		w.expr(n.Left()) // n.Left.Op == OTYPE
-		w.selector(n.Right().Sym())
+		w.op(ir.OTYPE)
+		w.typ(n.T) // n.Left.Op == OTYPE
+		w.selector(n.Method.Sym)
 
 	case ir.ONAME:
 		// Package scope name.
diff --git a/src/cmd/compile/internal/gc/initorder.go b/src/cmd/compile/internal/gc/initorder.go
index 9a07ca71bd..1b21d92f4b 100644
--- a/src/cmd/compile/internal/gc/initorder.go
+++ b/src/cmd/compile/internal/gc/initorder.go
@@ -79,7 +79,7 @@ type InitOrder struct {
 func initOrder(l []ir.Node) []ir.Node {
 	s := InitSchedule{
 		initplans: make(map[ir.Node]*InitPlan),
-		inittemps: make(map[ir.Node]ir.Node),
+		inittemps: make(map[ir.Node]*ir.Name),
 	}
 	o := InitOrder{
 		blocking: make(map[ir.Node][]ir.Node),
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 8467c20833..e1308718aa 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -640,11 +640,12 @@ func inlCallee(fn ir.Node) *ir.Func {
 	fn = staticValue(fn)
 	switch fn.Op() {
 	case ir.OMETHEXPR:
+		fn := fn.(*ir.MethodExpr)
 		n := methodExprName(fn)
 		// Check that receiver type matches fn.Left.
 		// TODO(mdempsky): Handle implicit dereference
 		// of pointer receiver argument?
-		if n == nil || !types.Identical(n.Type().Recv().Type, fn.Left().Type()) {
+		if n == nil || !types.Identical(n.Type().Recv().Type, fn.T) {
 			return nil
 		}
 		return n.Func()
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index c34a86d4eb..042b625fc9 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -205,13 +205,14 @@ func addptabs() {
 	}
 	for _, exportn := range exportlist {
 		s := exportn.Sym()
-		n := ir.AsNode(s.Def)
-		if n == nil {
+		nn := ir.AsNode(s.Def)
+		if nn == nil {
 			continue
 		}
-		if n.Op() != ir.ONAME {
+		if nn.Op() != ir.ONAME {
 			continue
 		}
+		n := nn.(*ir.Name)
 		if !types.IsExported(s.Name) {
 			continue
 		}
@@ -228,7 +229,7 @@ func addptabs() {
 	}
 }
 
-func dumpGlobal(n ir.Node) {
+func dumpGlobal(n *ir.Name) {
 	if n.Type() == nil {
 		base.Fatalf("external %v nil type\n", n)
 	}
@@ -271,7 +272,7 @@ func dumpglobls() {
 	for _, n := range externdcl {
 		switch n.Op() {
 		case ir.ONAME:
-			dumpGlobal(n)
+			dumpGlobal(n.(*ir.Name))
 		case ir.OLITERAL:
 			dumpGlobalConst(n)
 		}
@@ -475,7 +476,7 @@ func fileStringSym(pos src.XPos, file string, readonly bool, hash []byte) (*obj.
 
 var slicedataGen int
 
-func slicedata(pos src.XPos, s string) ir.Node {
+func slicedata(pos src.XPos, s string) *ir.Name {
 	slicedataGen++
 	symname := fmt.Sprintf(".gobytes.%d", slicedataGen)
 	sym := types.LocalPkg.Lookup(symname)
@@ -489,7 +490,7 @@ func slicedata(pos src.XPos, s string) ir.Node {
 	return symnode
 }
 
-func slicebytes(nam ir.Node, s string) {
+func slicebytes(nam *ir.Name, s string) {
 	if nam.Op() != ir.ONAME {
 		base.Fatalf("slicebytes %v", nam)
 	}
@@ -529,8 +530,8 @@ func dsymptrWeakOff(s *obj.LSym, off int, x *obj.LSym) int {
 }
 
 // slicesym writes a static slice symbol {&arr, lencap, lencap} to n.
-// arr must be an ONAME. slicesym does not modify n.
-func slicesym(n, arr ir.Node, lencap int64) {
+// slicesym does not modify n.
+func slicesym(n, arr *ir.Name, lencap int64) {
 	s := n.Sym().Linksym()
 	off := n.Offset()
 	if arr.Op() != ir.ONAME {
@@ -543,7 +544,7 @@ func slicesym(n, arr ir.Node, lencap int64) {
 
 // addrsym writes the static address of a to n. a must be an ONAME.
 // Neither n nor a is modified.
-func addrsym(n, a ir.Node) {
+func addrsym(n, a *ir.Name) {
 	if n.Op() != ir.ONAME {
 		base.Fatalf("addrsym n op %v", n.Op())
 	}
@@ -559,7 +560,7 @@ func addrsym(n, a ir.Node) {
 
 // pfuncsym writes the static address of f to n. f must be a global function.
 // Neither n nor f is modified.
-func pfuncsym(n, f ir.Node) {
+func pfuncsym(n, f *ir.Name) {
 	if n.Op() != ir.ONAME {
 		base.Fatalf("pfuncsym n op %v", n.Op())
 	}
@@ -575,7 +576,7 @@ func pfuncsym(n, f ir.Node) {
 
 // litsym writes the static literal c to n.
 // Neither n nor c is modified.
-func litsym(n, c ir.Node, wid int) {
+func litsym(n *ir.Name, c ir.Node, wid int) {
 	if n.Op() != ir.ONAME {
 		base.Fatalf("litsym n op %v", n.Op())
 	}
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index b3f211ff75..cfda4afcd8 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -32,7 +32,7 @@ type InitSchedule struct {
 	out []ir.Node
 
 	initplans map[ir.Node]*InitPlan
-	inittemps map[ir.Node]ir.Node
+	inittemps map[ir.Node]*ir.Name
 }
 
 func (s *InitSchedule) append(n ir.Node) {
@@ -51,55 +51,57 @@ func (s *InitSchedule) staticInit(n ir.Node) {
 
 // tryStaticInit attempts to statically execute an initialization
 // statement and reports whether it succeeded.
-func (s *InitSchedule) tryStaticInit(n ir.Node) bool {
+func (s *InitSchedule) tryStaticInit(nn ir.Node) bool {
 	// Only worry about simple "l = r" assignments. Multiple
 	// variable/expression OAS2 assignments have already been
 	// replaced by multiple simple OAS assignments, and the other
 	// OAS2* assignments mostly necessitate dynamic execution
 	// anyway.
-	if n.Op() != ir.OAS {
+	if nn.Op() != ir.OAS {
 		return false
 	}
+	n := nn.(*ir.AssignStmt)
 	if ir.IsBlank(n.Left()) && !anySideEffects(n.Right()) {
 		// Discard.
 		return true
 	}
 	lno := setlineno(n)
 	defer func() { base.Pos = lno }()
-	return s.staticassign(n.Left(), n.Right())
+	return s.staticassign(n.Left().(*ir.Name), n.Right())
 }
 
 // like staticassign but we are copying an already
 // initialized value r.
-func (s *InitSchedule) staticcopy(l ir.Node, r ir.Node) bool {
-	if r.Op() != ir.ONAME && r.Op() != ir.OMETHEXPR {
-		return false
-	}
-	if r.Class() == ir.PFUNC {
-		pfuncsym(l, r)
+func (s *InitSchedule) staticcopy(l *ir.Name, rn *ir.Name) bool {
+	if rn.Class() == ir.PFUNC {
+		pfuncsym(l, rn)
 		return true
 	}
-	if r.Class() != ir.PEXTERN || r.Sym().Pkg != types.LocalPkg {
+	if rn.Class() != ir.PEXTERN || rn.Sym().Pkg != types.LocalPkg {
 		return false
 	}
-	if r.Name().Defn == nil { // probably zeroed but perhaps supplied externally and of unknown value
+	if rn.Defn == nil { // probably zeroed but perhaps supplied externally and of unknown value
 		return false
 	}
-	if r.Name().Defn.Op() != ir.OAS {
+	if rn.Defn.Op() != ir.OAS {
 		return false
 	}
-	if r.Type().IsString() { // perhaps overwritten by cmd/link -X (#34675)
+	if rn.Type().IsString() { // perhaps overwritten by cmd/link -X (#34675)
 		return false
 	}
-	orig := r
-	r = r.Name().Defn.Right()
+	orig := rn
+	r := rn.Defn.(*ir.AssignStmt).Right()
 
 	for r.Op() == ir.OCONVNOP && !types.Identical(r.Type(), l.Type()) {
-		r = r.Left()
+		r = r.(*ir.ConvExpr).Left()
 	}
 
 	switch r.Op() {
-	case ir.ONAME, ir.OMETHEXPR:
+	case ir.OMETHEXPR:
+		r = r.(*ir.MethodExpr).FuncName()
+		fallthrough
+	case ir.ONAME:
+		r := r.(*ir.Name)
 		if s.staticcopy(l, r) {
 			return true
 		}
@@ -120,6 +122,7 @@ func (s *InitSchedule) staticcopy(l ir.Node, r ir.Node) bool {
 
 	case ir.OADDR:
 		if a := r.Left(); a.Op() == ir.ONAME {
+			a := a.(*ir.Name)
 			addrsym(l, a)
 			return true
 		}
@@ -141,7 +144,7 @@ func (s *InitSchedule) staticcopy(l ir.Node, r ir.Node) bool {
 	case ir.OARRAYLIT, ir.OSTRUCTLIT:
 		p := s.initplans[r]
 
-		n := ir.Copy(l)
+		n := ir.Copy(l).(*ir.Name)
 		for i := range p.E {
 			e := &p.E[i]
 			n.SetOffset(l.Offset() + e.Xoffset)
@@ -150,13 +153,17 @@ func (s *InitSchedule) staticcopy(l ir.Node, r ir.Node) bool {
 				litsym(n, e.Expr, int(n.Type().Width))
 				continue
 			}
-			ll := ir.SepCopy(n)
-			if s.staticcopy(ll, e.Expr) {
+			ll := ir.SepCopy(n).(*ir.Name)
+			x := e.Expr
+			if x.Op() == ir.OMETHEXPR {
+				x = x.(*ir.MethodExpr).FuncName()
+			}
+			if x.Op() == ir.ONAME && s.staticcopy(ll, x.(*ir.Name)) {
 				continue
 			}
 			// Requires computation, but we're
 			// copying someone else's computation.
-			rr := ir.SepCopy(orig)
+			rr := ir.SepCopy(orig).(*ir.Name)
 			rr.SetType(ll.Type())
 			rr.SetOffset(rr.Offset() + e.Xoffset)
 			setlineno(rr)
@@ -169,15 +176,20 @@ func (s *InitSchedule) staticcopy(l ir.Node, r ir.Node) bool {
 	return false
 }
 
-func (s *InitSchedule) staticassign(l ir.Node, r ir.Node) bool {
+func (s *InitSchedule) staticassign(l *ir.Name, r ir.Node) bool {
 	for r.Op() == ir.OCONVNOP {
-		r = r.Left()
+		r = r.(*ir.ConvExpr).Left()
 	}
 
 	switch r.Op() {
-	case ir.ONAME, ir.OMETHEXPR:
+	case ir.ONAME:
+		r := r.(*ir.Name)
 		return s.staticcopy(l, r)
 
+	case ir.OMETHEXPR:
+		r := r.(*ir.MethodExpr)
+		return s.staticcopy(l, r.FuncName())
+
 	case ir.ONIL:
 		return true
 
@@ -236,7 +248,7 @@ func (s *InitSchedule) staticassign(l ir.Node, r ir.Node) bool {
 		s.initplan(r)
 
 		p := s.initplans[r]
-		n := ir.Copy(l)
+		n := ir.Copy(l).(*ir.Name)
 		for i := range p.E {
 			e := &p.E[i]
 			n.SetOffset(l.Offset() + e.Xoffset)
@@ -246,7 +258,7 @@ func (s *InitSchedule) staticassign(l ir.Node, r ir.Node) bool {
 				continue
 			}
 			setlineno(e.Expr)
-			a := ir.SepCopy(n)
+			a := ir.SepCopy(n).(*ir.Name)
 			if !s.staticassign(a, e.Expr) {
 				s.append(ir.Nod(ir.OAS, a, e.Expr))
 			}
@@ -274,9 +286,9 @@ func (s *InitSchedule) staticassign(l ir.Node, r ir.Node) bool {
 		// If you change something here, change it there, and vice versa.
 
 		// Determine the underlying concrete type and value we are converting from.
-		val := r
+		val := ir.Node(r)
 		for val.Op() == ir.OCONVIFACE {
-			val = val.Left()
+			val = val.(*ir.ConvExpr).Left()
 		}
 
 		if val.Type().IsInterface() {
@@ -290,7 +302,7 @@ func (s *InitSchedule) staticassign(l ir.Node, r ir.Node) bool {
 
 		markTypeUsedInInterface(val.Type(), l.Sym().Linksym())
 
-		var itab ir.Node
+		var itab *ir.AddrExpr
 		if l.Type().IsEmptyInterface() {
 			itab = typename(val.Type())
 		} else {
@@ -298,10 +310,10 @@ func (s *InitSchedule) staticassign(l ir.Node, r ir.Node) bool {
 		}
 
 		// Create a copy of l to modify while we emit data.
-		n := ir.Copy(l)
+		n := ir.Copy(l).(*ir.Name)
 
 		// Emit itab, advance offset.
-		addrsym(n, itab.Left()) // itab is an OADDR node
+		addrsym(n, itab.Left().(*ir.Name))
 		n.SetOffset(n.Offset() + int64(Widthptr))
 
 		// Emit data.
@@ -313,7 +325,7 @@ func (s *InitSchedule) staticassign(l ir.Node, r ir.Node) bool {
 			// Copy val directly into n.
 			n.SetType(val.Type())
 			setlineno(val)
-			a := ir.SepCopy(n)
+			a := ir.SepCopy(n).(*ir.Name)
 			if !s.staticassign(a, val) {
 				s.append(ir.Nod(ir.OAS, a, val))
 			}
@@ -368,7 +380,7 @@ var statuniqgen int // name generator for static temps
 
 // staticname returns a name backed by a (writable) static data symbol.
 // Use readonlystaticname for read-only node.
-func staticname(t *types.Type) ir.Node {
+func staticname(t *types.Type) *ir.Name {
 	// Don't use lookupN; it interns the resulting string, but these are all unique.
 	n := NewName(lookup(fmt.Sprintf("%s%d", obj.StaticNamePref, statuniqgen)))
 	statuniqgen++
@@ -379,15 +391,19 @@ func staticname(t *types.Type) ir.Node {
 }
 
 // readonlystaticname returns a name backed by a (writable) static data symbol.
-func readonlystaticname(t *types.Type) ir.Node {
+func readonlystaticname(t *types.Type) *ir.Name {
 	n := staticname(t)
 	n.MarkReadonly()
 	n.Sym().Linksym().Set(obj.AttrContentAddressable, true)
 	return n
 }
 
-func isSimpleName(n ir.Node) bool {
-	return (n.Op() == ir.ONAME || n.Op() == ir.OMETHEXPR) && n.Class() != ir.PAUTOHEAP && n.Class() != ir.PEXTERN
+func isSimpleName(nn ir.Node) bool {
+	if nn.Op() != ir.ONAME {
+		return false
+	}
+	n := nn.(*ir.Name)
+	return n.Class() != ir.PAUTOHEAP && n.Class() != ir.PEXTERN
 }
 
 func litas(l ir.Node, r ir.Node, init *ir.Nodes) {
@@ -428,14 +444,15 @@ func getdyn(n ir.Node, top bool) initGenType {
 
 	case ir.OARRAYLIT, ir.OSTRUCTLIT:
 	}
+	lit := n.(*ir.CompLitExpr)
 
 	var mode initGenType
-	for _, n1 := range n.List().Slice() {
+	for _, n1 := range lit.List().Slice() {
 		switch n1.Op() {
 		case ir.OKEY:
-			n1 = n1.Right()
+			n1 = n1.(*ir.KeyExpr).Right()
 		case ir.OSTRUCTKEY:
-			n1 = n1.Left()
+			n1 = n1.(*ir.StructKeyExpr).Left()
 		}
 		mode |= getdyn(n1, false)
 		if mode == initDynamic|initConst {
@@ -453,7 +470,7 @@ func isStaticCompositeLiteral(n ir.Node) bool {
 	case ir.OARRAYLIT:
 		for _, r := range n.List().Slice() {
 			if r.Op() == ir.OKEY {
-				r = r.Right()
+				r = r.(*ir.KeyExpr).Right()
 			}
 			if !isStaticCompositeLiteral(r) {
 				return false
@@ -462,9 +479,7 @@ func isStaticCompositeLiteral(n ir.Node) bool {
 		return true
 	case ir.OSTRUCTLIT:
 		for _, r := range n.List().Slice() {
-			if r.Op() != ir.OSTRUCTKEY {
-				base.Fatalf("isStaticCompositeLiteral: rhs not OSTRUCTKEY: %v", r)
-			}
+			r := r.(*ir.StructKeyExpr)
 			if !isStaticCompositeLiteral(r.Left()) {
 				return false
 			}
@@ -474,9 +489,9 @@ func isStaticCompositeLiteral(n ir.Node) bool {
 		return true
 	case ir.OCONVIFACE:
 		// See staticassign's OCONVIFACE case for comments.
-		val := n
+		val := ir.Node(n)
 		for val.Op() == ir.OCONVIFACE {
-			val = val.Left()
+			val = val.(*ir.ConvExpr).Left()
 		}
 		if val.Type().IsInterface() {
 			return val.Op() == ir.ONIL
@@ -508,7 +523,7 @@ const (
 
 // fixedlit handles struct, array, and slice literals.
 // TODO: expand documentation.
-func fixedlit(ctxt initContext, kind initKind, n ir.Node, var_ ir.Node, init *ir.Nodes) {
+func fixedlit(ctxt initContext, kind initKind, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes) {
 	isBlank := var_ == ir.BlankNode
 	var splitnode func(ir.Node) (a ir.Node, value ir.Node)
 	switch n.Op() {
@@ -516,11 +531,12 @@ func fixedlit(ctxt initContext, kind initKind, n ir.Node, var_ ir.Node, init *ir
 		var k int64
 		splitnode = func(r ir.Node) (ir.Node, ir.Node) {
 			if r.Op() == ir.OKEY {
-				k = indexconst(r.Left())
+				kv := r.(*ir.KeyExpr)
+				k = indexconst(kv.Left())
 				if k < 0 {
-					base.Fatalf("fixedlit: invalid index %v", r.Left())
+					base.Fatalf("fixedlit: invalid index %v", kv.Left())
 				}
-				r = r.Right()
+				r = kv.Right()
 			}
 			a := ir.Nod(ir.OINDEX, var_, nodintconst(k))
 			k++
@@ -530,10 +546,8 @@ func fixedlit(ctxt initContext, kind initKind, n ir.Node, var_ ir.Node, init *ir
 			return a, r
 		}
 	case ir.OSTRUCTLIT:
-		splitnode = func(r ir.Node) (ir.Node, ir.Node) {
-			if r.Op() != ir.OSTRUCTKEY {
-				base.Fatalf("fixedlit: rhs not OSTRUCTKEY: %v", r)
-			}
+		splitnode = func(rn ir.Node) (ir.Node, ir.Node) {
+			r := rn.(*ir.StructKeyExpr)
 			if r.Sym().IsBlank() || isBlank {
 				return ir.BlankNode, r.Left()
 			}
@@ -553,12 +567,14 @@ func fixedlit(ctxt initContext, kind initKind, n ir.Node, var_ ir.Node, init *ir
 
 		switch value.Op() {
 		case ir.OSLICELIT:
+			value := value.(*ir.CompLitExpr)
 			if (kind == initKindStatic && ctxt == inNonInitFunction) || (kind == initKindDynamic && ctxt == inInitFunction) {
 				slicelit(ctxt, value, a, init)
 				continue
 			}
 
 		case ir.OARRAYLIT, ir.OSTRUCTLIT:
+			value := value.(*ir.CompLitExpr)
 			fixedlit(ctxt, kind, value, a, init)
 			continue
 		}
@@ -570,13 +586,13 @@ func fixedlit(ctxt initContext, kind initKind, n ir.Node, var_ ir.Node, init *ir
 
 		// build list of assignments: var[index] = expr
 		setlineno(a)
-		a = ir.Nod(ir.OAS, a, value)
-		a = typecheck(a, ctxStmt)
+		as := ir.NewAssignStmt(base.Pos, a, value)
+		as = typecheck(as, ctxStmt).(*ir.AssignStmt)
 		switch kind {
 		case initKindStatic:
-			genAsStatic(a)
+			genAsStatic(as)
 		case initKindDynamic, initKindLocalCode:
-			a = orderStmtInPlace(a, map[string][]*ir.Name{})
+			a = orderStmtInPlace(as, map[string][]*ir.Name{})
 			a = walkstmt(a)
 			init.Append(a)
 		default:
@@ -586,7 +602,7 @@ func fixedlit(ctxt initContext, kind initKind, n ir.Node, var_ ir.Node, init *ir
 	}
 }
 
-func isSmallSliceLit(n ir.Node) bool {
+func isSmallSliceLit(n *ir.CompLitExpr) bool {
 	if n.Op() != ir.OSLICELIT {
 		return false
 	}
@@ -596,7 +612,7 @@ func isSmallSliceLit(n ir.Node) bool {
 	return smallintconst(r) && (n.Type().Elem().Width == 0 || ir.Int64Val(r) <= smallArrayBytes/n.Type().Elem().Width)
 }
 
-func slicelit(ctxt initContext, n ir.Node, var_ ir.Node, init *ir.Nodes) {
+func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes) {
 	// make an array type corresponding the number of elements we have
 	t := types.NewArray(n.Type().Elem(), ir.Int64Val(n.Right()))
 	dowidth(t)
@@ -679,7 +695,7 @@ func slicelit(ctxt initContext, n ir.Node, var_ ir.Node, init *ir.Nodes) {
 			a = ir.Nod(ir.OAS, temp(t), nil)
 			a = typecheck(a, ctxStmt)
 			init.Append(a) // zero new temp
-			a = a.Left()
+			a = a.(*ir.AssignStmt).Left()
 		} else {
 			init.Append(ir.Nod(ir.OVARDEF, a, nil))
 		}
@@ -700,11 +716,12 @@ func slicelit(ctxt initContext, n ir.Node, var_ ir.Node, init *ir.Nodes) {
 	var index int64
 	for _, value := range n.List().Slice() {
 		if value.Op() == ir.OKEY {
-			index = indexconst(value.Left())
+			kv := value.(*ir.KeyExpr)
+			index = indexconst(kv.Left())
 			if index < 0 {
-				base.Fatalf("slicelit: invalid index %v", value.Left())
+				base.Fatalf("slicelit: invalid index %v", kv.Left())
 			}
-			value = value.Right()
+			value = kv.Right()
 		}
 		a := ir.Nod(ir.OINDEX, vauto, nodintconst(index))
 		a.SetBounded(true)
@@ -717,6 +734,7 @@ func slicelit(ctxt initContext, n ir.Node, var_ ir.Node, init *ir.Nodes) {
 			break
 
 		case ir.OARRAYLIT, ir.OSTRUCTLIT:
+			value := value.(*ir.CompLitExpr)
 			k := initKindDynamic
 			if vstat == nil {
 				// Generate both static and dynamic initializations.
@@ -748,7 +766,7 @@ func slicelit(ctxt initContext, n ir.Node, var_ ir.Node, init *ir.Nodes) {
 	init.Append(a)
 }
 
-func maplit(n ir.Node, m ir.Node, init *ir.Nodes) {
+func maplit(n *ir.CompLitExpr, m ir.Node, init *ir.Nodes) {
 	// make the map var
 	a := ir.Nod(ir.OMAKE, nil, nil)
 	a.SetEsc(n.Esc())
@@ -760,6 +778,7 @@ func maplit(n ir.Node, m ir.Node, init *ir.Nodes) {
 	// The order pass already removed any dynamic (runtime-computed) entries.
 	// All remaining entries are static. Double-check that.
 	for _, r := range entries {
+		r := r.(*ir.KeyExpr)
 		if !isStaticCompositeLiteral(r.Left()) || !isStaticCompositeLiteral(r.Right()) {
 			base.Fatalf("maplit: entry is not a literal: %v", r)
 		}
@@ -782,9 +801,10 @@ func maplit(n ir.Node, m ir.Node, init *ir.Nodes) {
 		vstatk := readonlystaticname(tk)
 		vstate := readonlystaticname(te)
 
-		datak := ir.Nod(ir.OARRAYLIT, nil, nil)
-		datae := ir.Nod(ir.OARRAYLIT, nil, nil)
+		datak := ir.NewCompLitExpr(base.Pos, ir.OARRAYLIT, nil, nil)
+		datae := ir.NewCompLitExpr(base.Pos, ir.OARRAYLIT, nil, nil)
 		for _, r := range entries {
+			r := r.(*ir.KeyExpr)
 			datak.PtrList().Append(r.Left())
 			datae.PtrList().Append(r.Right())
 		}
@@ -824,6 +844,7 @@ func maplit(n ir.Node, m ir.Node, init *ir.Nodes) {
 	tmpelem := temp(m.Type().Elem())
 
 	for _, r := range entries {
+		r := r.(*ir.KeyExpr)
 		index, elem := r.Left(), r.Right()
 
 		setlineno(index)
@@ -846,8 +867,12 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 	default:
 		base.Fatalf("anylit: not lit, op=%v node=%v", n.Op(), n)
 
-	case ir.ONAME, ir.OMETHEXPR:
-		appendWalkStmt(init, ir.Nod(ir.OAS, var_, n))
+	case ir.ONAME:
+		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, n))
+
+	case ir.OMETHEXPR:
+		n := n.(*ir.MethodExpr)
+		anylit(n.FuncName(), var_, init)
 
 	case ir.OPTRLIT:
 		if !t.IsPtr() {
@@ -870,6 +895,7 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 		anylit(n.Left(), var_, init)
 
 	case ir.OSTRUCTLIT, ir.OARRAYLIT:
+		n := n.(*ir.CompLitExpr)
 		if !t.IsStruct() && !t.IsArray() {
 			base.Fatalf("anylit: not struct/array")
 		}
@@ -906,9 +932,11 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 		fixedlit(inInitFunction, initKindLocalCode, n, var_, init)
 
 	case ir.OSLICELIT:
+		n := n.(*ir.CompLitExpr)
 		slicelit(inInitFunction, n, var_, init)
 
 	case ir.OMAPLIT:
+		n := n.(*ir.CompLitExpr)
 		if !t.IsMap() {
 			base.Fatalf("anylit: not map")
 		}
@@ -919,7 +947,7 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 // oaslit handles special composite literal assignments.
 // It returns true if n's effects have been added to init,
 // in which case n should be dropped from the program by the caller.
-func oaslit(n ir.Node, init *ir.Nodes) bool {
+func oaslit(n *ir.AssignStmt, init *ir.Nodes) bool {
 	if n.Left() == nil || n.Right() == nil {
 		// not a special composite literal assignment
 		return false
@@ -961,14 +989,18 @@ func getlit(lit ir.Node) int {
 }
 
 // stataddr returns the static address of n, if n has one, or else nil.
-func stataddr(n ir.Node) ir.Node {
+func stataddr(n ir.Node) *ir.Name {
 	if n == nil {
 		return nil
 	}
 
 	switch n.Op() {
-	case ir.ONAME, ir.OMETHEXPR:
-		return ir.SepCopy(n)
+	case ir.ONAME:
+		return ir.SepCopy(n).(*ir.Name)
+
+	case ir.OMETHEXPR:
+		n := n.(*ir.MethodExpr)
+		return stataddr(n.FuncName())
 
 	case ir.ODOT:
 		nam := stataddr(n.Left())
@@ -1018,11 +1050,12 @@ func (s *InitSchedule) initplan(n ir.Node) {
 		var k int64
 		for _, a := range n.List().Slice() {
 			if a.Op() == ir.OKEY {
-				k = indexconst(a.Left())
+				kv := a.(*ir.KeyExpr)
+				k = indexconst(kv.Left())
 				if k < 0 {
-					base.Fatalf("initplan arraylit: invalid index %v", a.Left())
+					base.Fatalf("initplan arraylit: invalid index %v", kv.Left())
 				}
-				a = a.Right()
+				a = kv.Right()
 			}
 			s.addvalue(p, k*n.Type().Elem().Width, a)
 			k++
@@ -1033,6 +1066,7 @@ func (s *InitSchedule) initplan(n ir.Node) {
 			if a.Op() != ir.OSTRUCTKEY {
 				base.Fatalf("initplan structlit")
 			}
+			a := a.(*ir.StructKeyExpr)
 			if a.Sym().IsBlank() {
 				continue
 			}
@@ -1044,6 +1078,7 @@ func (s *InitSchedule) initplan(n ir.Node) {
 			if a.Op() != ir.OKEY {
 				base.Fatalf("initplan maplit")
 			}
+			a := a.(*ir.KeyExpr)
 			s.addvalue(p, -1, a.Right())
 		}
 	}
@@ -1089,7 +1124,7 @@ func isZero(n ir.Node) bool {
 	case ir.OARRAYLIT:
 		for _, n1 := range n.List().Slice() {
 			if n1.Op() == ir.OKEY {
-				n1 = n1.Right()
+				n1 = n1.(*ir.KeyExpr).Right()
 			}
 			if !isZero(n1) {
 				return false
@@ -1099,6 +1134,7 @@ func isZero(n ir.Node) bool {
 
 	case ir.OSTRUCTLIT:
 		for _, n1 := range n.List().Slice() {
+			n1 := n1.(*ir.StructKeyExpr)
 			if !isZero(n1.Left()) {
 				return false
 			}
@@ -1113,7 +1149,7 @@ func isvaluelit(n ir.Node) bool {
 	return n.Op() == ir.OARRAYLIT || n.Op() == ir.OSTRUCTLIT
 }
 
-func genAsStatic(as ir.Node) {
+func genAsStatic(as *ir.AssignStmt) {
 	if as.Left().Type() == nil {
 		base.Fatalf("genAsStatic as.Left not typechecked")
 	}
@@ -1123,12 +1159,20 @@ func genAsStatic(as ir.Node) {
 		base.Fatalf("genAsStatic: lhs %v", as.Left())
 	}
 
-	switch {
-	case as.Right().Op() == ir.OLITERAL:
-		litsym(nam, as.Right(), int(as.Right().Type().Width))
-	case (as.Right().Op() == ir.ONAME || as.Right().Op() == ir.OMETHEXPR) && as.Right().Class() == ir.PFUNC:
-		pfuncsym(nam, as.Right())
-	default:
-		base.Fatalf("genAsStatic: rhs %v", as.Right())
+	switch r := as.Right(); r.Op() {
+	case ir.OLITERAL:
+		litsym(nam, r, int(r.Type().Width))
+		return
+	case ir.OMETHEXPR:
+		r := r.(*ir.MethodExpr)
+		pfuncsym(nam, r.FuncName())
+		return
+	case ir.ONAME:
+		r := r.(*ir.Name)
+		if r.Class() == ir.PFUNC {
+			pfuncsym(nam, r)
+			return
+		}
 	}
+	base.Fatalf("genAsStatic: rhs %v", as.Right())
 }
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 4d9073a4b6..2a0134703c 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -2087,7 +2087,8 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		aux := n.Left().Sym().Linksym()
 		return s.entryNewValue1A(ssa.OpAddr, n.Type(), aux, s.sb)
 	case ir.OMETHEXPR:
-		sym := funcsym(n.Sym()).Linksym()
+		n := n.(*ir.MethodExpr)
+		sym := funcsym(n.FuncName().Sym()).Linksym()
 		return s.entryNewValue1A(ssa.OpAddr, types.NewPtr(n.Type()), sym, s.sb)
 	case ir.ONAME:
 		if n.Class() == ir.PFUNC {
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 2f3c876c77..5e56ace7c7 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -2415,16 +2415,16 @@ func typecheckMethodExpr(n *ir.SelectorExpr) (res ir.Node) {
 		return n
 	}
 
-	me := ir.NodAt(n.Pos(), ir.OMETHEXPR, n.Left(), NewName(n.Sym()))
-	me.SetSym(methodSym(t, n.Sym()))
+	me := ir.NewMethodExpr(n.Pos(), n.Left().Type(), m)
 	me.SetType(methodfunc(m.Type, n.Left().Type()))
-	me.SetOffset(0)
-	me.SetClass(ir.PFUNC)
-	ir.Node(me).(*ir.MethodExpr).Method = m
+	f := NewName(methodSym(t, m.Sym))
+	f.SetClass(ir.PFUNC)
+	f.SetType(me.Type())
+	me.FuncName_ = f
 
 	// Issue 25065. Make sure that we emit the symbol for a local method.
 	if base.Ctxt.Flag_dynlink && !inimport && (t.Sym() == nil || t.Sym().Pkg == types.LocalPkg) {
-		makefuncsym(me.Sym())
+		makefuncsym(me.FuncName_.Sym())
 	}
 
 	return me
@@ -4023,7 +4023,7 @@ func deadcodeexpr(n ir.Node) ir.Node {
 func getIotaValue() int64 {
 	if i := len(typecheckdefstack); i > 0 {
 		if x := typecheckdefstack[i-1]; x.Op() == ir.OLITERAL {
-			return x.Iota()
+			return x.(*ir.Name).Iota()
 		}
 	}
 
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 36a11dad9a..51262d1e07 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -526,35 +526,35 @@ func (n *MakeExpr) SetOp(op Op) {
 	}
 }
 
-// A MethodExpr is a method value X.M (where X is an expression, not a type).
+// A MethodExpr is a method expression T.M (where T is a type).
 type MethodExpr struct {
 	miniExpr
-	X       Node
-	M       Node
-	Sym_    *types.Sym
-	Offset_ int64
-	Class_  Class
-	Method  *types.Field
+	T         *types.Type
+	X_Delete  Node
+	M_Delete  Node // TODO(rsc): Delete (breaks toolstash b/c inlining costs go down)
+	Method    *types.Field
+	FuncName_ *Name
 }
 
-func NewMethodExpr(pos src.XPos, x, m Node) *MethodExpr {
-	n := &MethodExpr{X: x, M: m}
+func NewMethodExpr(pos src.XPos, t *types.Type, method *types.Field) *MethodExpr {
+	n := &MethodExpr{T: t, Method: method}
 	n.pos = pos
 	n.op = OMETHEXPR
-	n.Offset_ = types.BADWIDTH
+	n.X_Delete = TypeNode(t)                // TODO(rsc): Delete.
+	n.M_Delete = NewNameAt(pos, method.Sym) // TODO(rsc): Delete.
 	return n
 }
 
-func (n *MethodExpr) Left() Node          { return n.X }
-func (n *MethodExpr) SetLeft(x Node)      { n.X = x }
-func (n *MethodExpr) Right() Node         { return n.M }
-func (n *MethodExpr) SetRight(y Node)     { n.M = y }
-func (n *MethodExpr) Sym() *types.Sym     { return n.Sym_ }
-func (n *MethodExpr) SetSym(x *types.Sym) { n.Sym_ = x }
-func (n *MethodExpr) Offset() int64       { return n.Offset_ }
-func (n *MethodExpr) SetOffset(x int64)   { n.Offset_ = x }
-func (n *MethodExpr) Class() Class        { return n.Class_ }
-func (n *MethodExpr) SetClass(x Class)    { n.Class_ = x }
+func (n *MethodExpr) FuncName() *Name   { return n.FuncName_ }
+func (n *MethodExpr) Left() Node        { panic("MethodExpr.Left") }
+func (n *MethodExpr) SetLeft(x Node)    { panic("MethodExpr.SetLeft") }
+func (n *MethodExpr) Right() Node       { panic("MethodExpr.Right") }
+func (n *MethodExpr) SetRight(x Node)   { panic("MethodExpr.SetRight") }
+func (n *MethodExpr) Sym() *types.Sym   { panic("MethodExpr.Sym") }
+func (n *MethodExpr) Offset() int64     { panic("MethodExpr.Offset") }
+func (n *MethodExpr) SetOffset(x int64) { panic("MethodExpr.SetOffset") }
+func (n *MethodExpr) Class() Class      { panic("MethodExpr.Class") }
+func (n *MethodExpr) SetClass(x Class)  { panic("MethodExpr.SetClass") }
 
 // A NilExpr represents the predefined untyped constant nil.
 // (It may be copied and assigned a type, though.)
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 3cda9c8c38..a6e90a899e 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -624,9 +624,13 @@ func exprFmt(n Node, s fmt.State, prec int) {
 			return
 		}
 		fallthrough
-	case OPACK, ONONAME, OMETHEXPR:
+	case OPACK, ONONAME:
 		fmt.Fprint(s, n.Sym())
 
+	case OMETHEXPR:
+		n := n.(*MethodExpr)
+		fmt.Fprint(s, n.FuncName().Sym())
+
 	case OTYPE:
 		if n.Type() == nil && n.Sym() != nil {
 			fmt.Fprint(s, n.Sym())
@@ -1139,7 +1143,7 @@ func dumpNode(w io.Writer, n Node, depth int) {
 		dumpNodeHeader(w, n)
 		return
 
-	case ONAME, ONONAME, OMETHEXPR:
+	case ONAME, ONONAME:
 		if n.Sym() != nil {
 			fmt.Fprintf(w, "%+v-%+v", n.Op(), n.Sym())
 		} else {
@@ -1153,6 +1157,12 @@ func dumpNode(w io.Writer, n Node, depth int) {
 		}
 		return
 
+	case OMETHEXPR:
+		n := n.(*MethodExpr)
+		fmt.Fprintf(w, "%+v-%+v", n.Op(), n.FuncName().Sym())
+		dumpNodeHeader(w, n)
+		return
+
 	case OASOP:
 		n := n.(*AssignOpStmt)
 		fmt.Fprintf(w, "%+v-%+v", n.Op(), n.SubOp())
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index fe6dafe859..bbe53d821e 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -733,8 +733,6 @@ func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
 		return newNameAt(pos, op, nil)
 	case OMAKECHAN, OMAKEMAP, OMAKESLICE, OMAKESLICECOPY:
 		return NewMakeExpr(pos, op, nleft, nright)
-	case OMETHEXPR:
-		return NewMethodExpr(pos, nleft, nright)
 	case ONIL:
 		return NewNilExpr(pos)
 	case OPACK:
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index 39d8f03ddc..80cc755d1a 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -632,14 +632,14 @@ func (n *MethodExpr) copy() Node {
 func (n *MethodExpr) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	err = maybeDo(n.M, err, do)
+	err = maybeDo(n.X_Delete, err, do)
+	err = maybeDo(n.M_Delete, err, do)
 	return err
 }
 func (n *MethodExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-	n.M = maybeEdit(n.M, edit)
+	n.X_Delete = maybeEdit(n.X_Delete, edit)
+	n.M_Delete = maybeEdit(n.M_Delete, edit)
 }
 
 func (n *Name) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-- 
GitLab


From c76be2a24eb1a07cf731c4a75652e2d5db61aa77 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 17 Dec 2020 00:59:35 -0500
Subject: [PATCH 0264/2400] [dev.regabi] cmd/compile: add ONAMEOFFSET, delete
 to-be-deleted fields

Breaks toolstash but clearly no effect.

Change-Id: Ic05bb7f74db170f140cf3b3cd7d629f159e3aae1
Reviewed-on: https://go-review.googlesource.com/c/go/+/278913
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/expr.go      | 19 +++++++++++++++----
 src/cmd/compile/internal/ir/node.go      |  1 +
 src/cmd/compile/internal/ir/node_gen.go  | 19 +++++++++++++++----
 src/cmd/compile/internal/ir/op_string.go | 11 ++++++-----
 4 files changed, 37 insertions(+), 13 deletions(-)

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 51262d1e07..b18975d063 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -530,8 +530,6 @@ func (n *MakeExpr) SetOp(op Op) {
 type MethodExpr struct {
 	miniExpr
 	T         *types.Type
-	X_Delete  Node
-	M_Delete  Node // TODO(rsc): Delete (breaks toolstash b/c inlining costs go down)
 	Method    *types.Field
 	FuncName_ *Name
 }
@@ -540,8 +538,6 @@ func NewMethodExpr(pos src.XPos, t *types.Type, method *types.Field) *MethodExpr
 	n := &MethodExpr{T: t, Method: method}
 	n.pos = pos
 	n.op = OMETHEXPR
-	n.X_Delete = TypeNode(t)                // TODO(rsc): Delete.
-	n.M_Delete = NewNameAt(pos, method.Sym) // TODO(rsc): Delete.
 	return n
 }
 
@@ -619,6 +615,21 @@ func NewResultExpr(pos src.XPos, typ *types.Type, offset int64) *ResultExpr {
 func (n *ResultExpr) Offset() int64     { return n.Offset_ }
 func (n *ResultExpr) SetOffset(x int64) { n.Offset_ = x }
 
+// A NameOffsetExpr refers to an offset within a variable.
+// It is like a SelectorExpr but without the field name.
+type NameOffsetExpr struct {
+	miniExpr
+	Name_   *Name
+	Offset_ int64
+}
+
+func NewNameOffsetExpr(pos src.XPos, name *Name, offset int64, typ *types.Type) *NameOffsetExpr {
+	n := &NameOffsetExpr{Name_: name, Offset_: offset}
+	n.typ = typ
+	n.op = ONAMEOFFSET
+	return n
+}
+
 // A SelectorExpr is a selector expression X.Sym.
 type SelectorExpr struct {
 	miniExpr
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index bbe53d821e..ca894cd5f1 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -345,6 +345,7 @@ const (
 	OVARLIVE     // variable is alive
 	ORESULT      // result of a function call; Xoffset is stack offset
 	OINLMARK     // start of an inlined body, with file/line of caller. Xoffset is an index into the inline tree.
+	ONAMEOFFSET  // offset within a name
 
 	// arch-specific opcodes
 	ORETJMP // return to other function
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index 80cc755d1a..10dfe3c927 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -632,14 +632,10 @@ func (n *MethodExpr) copy() Node {
 func (n *MethodExpr) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X_Delete, err, do)
-	err = maybeDo(n.M_Delete, err, do)
 	return err
 }
 func (n *MethodExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
-	n.X_Delete = maybeEdit(n.X_Delete, edit)
-	n.M_Delete = maybeEdit(n.M_Delete, edit)
 }
 
 func (n *Name) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
@@ -654,6 +650,21 @@ func (n *Name) doChildren(do func(Node) error) error {
 func (n *Name) editChildren(edit func(Node) Node) {
 }
 
+func (n *NameOffsetExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *NameOffsetExpr) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *NameOffsetExpr) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	return err
+}
+func (n *NameOffsetExpr) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+}
+
 func (n *NilExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *NilExpr) copy() Node {
 	c := *n
diff --git a/src/cmd/compile/internal/ir/op_string.go b/src/cmd/compile/internal/ir/op_string.go
index 33b177d64f..f23e08c47c 100644
--- a/src/cmd/compile/internal/ir/op_string.go
+++ b/src/cmd/compile/internal/ir/op_string.go
@@ -158,14 +158,15 @@ func _() {
 	_ = x[OVARLIVE-147]
 	_ = x[ORESULT-148]
 	_ = x[OINLMARK-149]
-	_ = x[ORETJMP-150]
-	_ = x[OGETG-151]
-	_ = x[OEND-152]
+	_ = x[ONAMEOFFSET-150]
+	_ = x[ORETJMP-151]
+	_ = x[OGETG-152]
+	_ = x[OEND-153]
 }
 
-const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNEWOBJNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCLOSUREREADCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKRETJMPGETGEND"
+const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNEWOBJNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCLOSUREREADCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKNAMEOFFSETRETJMPGETGEND"
 
-var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 388, 391, 400, 403, 407, 415, 422, 431, 444, 447, 450, 453, 456, 459, 462, 468, 471, 477, 480, 486, 490, 493, 497, 502, 507, 513, 518, 522, 527, 535, 543, 549, 558, 569, 576, 580, 587, 595, 599, 603, 607, 614, 621, 629, 635, 643, 651, 656, 661, 665, 673, 678, 682, 685, 693, 697, 699, 704, 706, 711, 717, 723, 729, 735, 740, 744, 751, 757, 762, 768, 774, 781, 786, 790, 795, 799, 810, 815, 823, 829, 836, 843, 849, 856, 862, 866, 869}
+var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 388, 391, 400, 403, 407, 415, 422, 431, 444, 447, 450, 453, 456, 459, 462, 468, 471, 477, 480, 486, 490, 493, 497, 502, 507, 513, 518, 522, 527, 535, 543, 549, 558, 569, 576, 580, 587, 595, 599, 603, 607, 614, 621, 629, 635, 643, 651, 656, 661, 665, 673, 678, 682, 685, 693, 697, 699, 704, 706, 711, 717, 723, 729, 735, 740, 744, 751, 757, 762, 768, 774, 781, 786, 790, 795, 799, 810, 815, 823, 829, 836, 843, 849, 856, 866, 872, 876, 879}
 
 func (i Op) String() string {
 	if i >= Op(len(_Op_index)-1) {
-- 
GitLab


From ffb0cb7044cb412ce8c2f88740d8c7ea2af05837 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 17 Dec 2020 02:56:26 -0500
Subject: [PATCH 0265/2400] [dev.regabi] cmd/compile: remove uses of
 Name.Offset, Name.copy

For globals, Name.Offset is used as a way to address a field within
a global during static initialization. This CL replaces that use with
a separate NameOffsetExpr (ONAMEOFFSET) node.

For locals, Name.Offset is the stack frame offset. This CL calls it
that (FrameOffset, SetFrameOffset).

Now there is no longer any use of Name.Offset or Name.SetOffset.

And now that copies of Names are not being made to change their
offsets, we can lock down use of ir.Copy on Names. The only
remaining uses are during inlining and in handling generic system
functions. At both those times you do want to create a new name
and that can be made explicit by calling the new CloneName method
instead. ir.Copy on a name now panics.

Passes buildall w/ toolstash -cmp.

Change-Id: I0b0a25b9d93aeff7cf4e4025ac53faec7dc8603b
Reviewed-on: https://go-review.googlesource.com/c/go/+/278914
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 .../compile/internal/gc/abiutilsaux_test.go   |   2 +-
 src/cmd/compile/internal/gc/alg.go            |   2 +-
 src/cmd/compile/internal/gc/align.go          |   6 +-
 src/cmd/compile/internal/gc/dcl.go            |   2 +-
 src/cmd/compile/internal/gc/escape.go         |  13 +-
 src/cmd/compile/internal/gc/inl.go            |  14 +-
 src/cmd/compile/internal/gc/obj.go            |  52 ++++---
 src/cmd/compile/internal/gc/order.go          |   2 +-
 src/cmd/compile/internal/gc/pgen.go           |  16 ++-
 src/cmd/compile/internal/gc/pgen_test.go      |   4 +-
 src/cmd/compile/internal/gc/plive.go          |   8 +-
 src/cmd/compile/internal/gc/racewalk.go       |   4 +-
 src/cmd/compile/internal/gc/sinit.go          | 136 +++++++++---------
 src/cmd/compile/internal/gc/ssa.go            |  57 +++++---
 src/cmd/compile/internal/gc/subr.go           |   8 +-
 src/cmd/compile/internal/gc/typecheck.go      |   7 +
 src/cmd/compile/internal/gc/walk.go           |   8 +-
 src/cmd/compile/internal/ir/fmt.go            |   4 +
 src/cmd/compile/internal/ir/mknode.go         |  29 ++--
 src/cmd/compile/internal/ir/name.go           |  20 ++-
 src/cmd/compile/internal/ir/node_gen.go       |   5 +-
 21 files changed, 223 insertions(+), 176 deletions(-)

diff --git a/src/cmd/compile/internal/gc/abiutilsaux_test.go b/src/cmd/compile/internal/gc/abiutilsaux_test.go
index 5489a512d2..fd0b197207 100644
--- a/src/cmd/compile/internal/gc/abiutilsaux_test.go
+++ b/src/cmd/compile/internal/gc/abiutilsaux_test.go
@@ -76,7 +76,7 @@ func tokenize(src string) []string {
 
 func verifyParamResultOffset(t *testing.T, f *types.Field, r ABIParamAssignment, which string, idx int) int {
 	n := ir.AsNode(f.Nname).(*ir.Name)
-	if n.Offset() != int64(r.Offset) {
+	if n.FrameOffset() != int64(r.Offset) {
 		t.Errorf("%s %d: got offset %d wanted %d t=%v",
 			which, idx, r.Offset, n.Offset(), f.Type)
 		return 1
diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index 25dadffc24..f03aec3237 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -878,7 +878,7 @@ func eqmem(p ir.Node, q ir.Node, field *types.Sym, size int64) ir.Node {
 	return call
 }
 
-func eqmemfunc(size int64, t *types.Type) (fn ir.Node, needsize bool) {
+func eqmemfunc(size int64, t *types.Type) (fn *ir.Name, needsize bool) {
 	switch size {
 	default:
 		fn = syslook("memequal")
diff --git a/src/cmd/compile/internal/gc/align.go b/src/cmd/compile/internal/gc/align.go
index 9944a3a38a..95a5dbef29 100644
--- a/src/cmd/compile/internal/gc/align.go
+++ b/src/cmd/compile/internal/gc/align.go
@@ -128,10 +128,10 @@ func widstruct(errtype *types.Type, t *types.Type, o int64, flag int) int64 {
 			// It's possible the ordering has changed and this is
 			// now the common case. I'm not sure.
 			if n.Name().Stackcopy != nil {
-				n.Name().Stackcopy.SetOffset(o)
-				n.SetOffset(0)
+				n.Name().Stackcopy.SetFrameOffset(o)
+				n.SetFrameOffset(0)
 			} else {
-				n.SetOffset(o)
+				n.SetFrameOffset(o)
 			}
 		}
 
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index a2c9edb481..34ba372843 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -96,7 +96,7 @@ func declare(n *ir.Name, ctxt ir.Class) {
 	}
 
 	if ctxt == ir.PAUTO {
-		n.SetOffset(0)
+		n.SetFrameOffset(0)
 	}
 
 	if s.Block == types.Block {
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 5124af945e..235cef47ea 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -515,6 +515,10 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 		}
 		e.flow(k, e.oldLoc(n))
 
+	case ir.ONAMEOFFSET:
+		n := n.(*ir.NameOffsetExpr)
+		e.expr(k, n.Name_)
+
 	case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT:
 		n := n.(*ir.UnaryExpr)
 		e.discard(n.Left())
@@ -778,6 +782,9 @@ func (e *Escape) addr(n ir.Node) EscHole {
 			break
 		}
 		k = e.oldLoc(n).asHole()
+	case ir.ONAMEOFFSET:
+		n := n.(*ir.NameOffsetExpr)
+		e.addr(n.Name_)
 	case ir.ODOT:
 		n := n.(*ir.SelectorExpr)
 		k = e.addr(n.Left())
@@ -2008,7 +2015,7 @@ func moveToHeap(n *ir.Name) {
 	// in addition to the copy in the heap that may live longer than
 	// the function.
 	if n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT {
-		if n.Offset() == types.BADWIDTH {
+		if n.FrameOffset() == types.BADWIDTH {
 			base.Fatalf("addrescapes before param assignment")
 		}
 
@@ -2018,7 +2025,7 @@ func moveToHeap(n *ir.Name) {
 		// so that analyses of the local (on-stack) variables use it.
 		stackcopy := NewName(n.Sym())
 		stackcopy.SetType(n.Type())
-		stackcopy.SetOffset(n.Offset())
+		stackcopy.SetFrameOffset(n.FrameOffset())
 		stackcopy.SetClass(n.Class())
 		stackcopy.Heapaddr = heapaddr
 		if n.Class() == ir.PPARAMOUT {
@@ -2055,7 +2062,7 @@ func moveToHeap(n *ir.Name) {
 
 	// Modify n in place so that uses of n now mean indirection of the heapaddr.
 	n.SetClass(ir.PAUTOHEAP)
-	n.SetOffset(0)
+	n.SetFrameOffset(0)
 	n.Heapaddr = heapaddr
 	n.SetEsc(EscHeap)
 	if base.Flag.LowerM != 0 {
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index e1308718aa..b571c2b914 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -1220,11 +1220,19 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 		if n.Sym() != nil {
 			return n
 		}
+		if n, ok := n.(*ir.Name); ok && n.Op() == ir.OLITERAL {
+			// This happens for unnamed OLITERAL.
+			// which should really not be a *Name, but for now it is.
+			// ir.Copy(n) is not allowed generally and would panic below,
+			// but it's OK in this situation.
+			n = n.CloneName()
+			n.SetPos(subst.updatedPos(n.Pos()))
+			return n
+		}
 
-		// Since we don't handle bodies with closures, this return is guaranteed to belong to the current inlined function.
-
-	//		dump("Return before substitution", n);
 	case ir.ORETURN:
+		// Since we don't handle bodies with closures,
+		// this return is guaranteed to belong to the current inlined function.
 		init := subst.list(n.Init())
 		if len(subst.retvars) != 0 && n.List().Len() != 0 {
 			as := ir.Nod(ir.OAS2, nil, nil)
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 042b625fc9..cd1500d1ed 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -490,11 +490,11 @@ func slicedata(pos src.XPos, s string) *ir.Name {
 	return symnode
 }
 
-func slicebytes(nam *ir.Name, s string) {
+func slicebytes(nam *ir.Name, off int64, s string) {
 	if nam.Op() != ir.ONAME {
 		base.Fatalf("slicebytes %v", nam)
 	}
-	slicesym(nam, slicedata(nam.Pos(), s), int64(len(s)))
+	slicesym(nam, off, slicedata(nam.Pos(), s), int64(len(s)))
 }
 
 func dstringdata(s *obj.LSym, off int, t string, pos src.XPos, what string) int {
@@ -529,22 +529,21 @@ func dsymptrWeakOff(s *obj.LSym, off int, x *obj.LSym) int {
 	return off
 }
 
-// slicesym writes a static slice symbol {&arr, lencap, lencap} to n.
+// slicesym writes a static slice symbol {&arr, lencap, lencap} to n+noff.
 // slicesym does not modify n.
-func slicesym(n, arr *ir.Name, lencap int64) {
+func slicesym(n *ir.Name, noff int64, arr *ir.Name, lencap int64) {
 	s := n.Sym().Linksym()
-	off := n.Offset()
 	if arr.Op() != ir.ONAME {
 		base.Fatalf("slicesym non-name arr %v", arr)
 	}
-	s.WriteAddr(base.Ctxt, off, Widthptr, arr.Sym().Linksym(), arr.Offset())
-	s.WriteInt(base.Ctxt, off+sliceLenOffset, Widthptr, lencap)
-	s.WriteInt(base.Ctxt, off+sliceCapOffset, Widthptr, lencap)
+	s.WriteAddr(base.Ctxt, noff, Widthptr, arr.Sym().Linksym(), 0)
+	s.WriteInt(base.Ctxt, noff+sliceLenOffset, Widthptr, lencap)
+	s.WriteInt(base.Ctxt, noff+sliceCapOffset, Widthptr, lencap)
 }
 
 // addrsym writes the static address of a to n. a must be an ONAME.
 // Neither n nor a is modified.
-func addrsym(n, a *ir.Name) {
+func addrsym(n *ir.Name, noff int64, a *ir.Name, aoff int64) {
 	if n.Op() != ir.ONAME {
 		base.Fatalf("addrsym n op %v", n.Op())
 	}
@@ -555,12 +554,12 @@ func addrsym(n, a *ir.Name) {
 		base.Fatalf("addrsym a op %v", a.Op())
 	}
 	s := n.Sym().Linksym()
-	s.WriteAddr(base.Ctxt, n.Offset(), Widthptr, a.Sym().Linksym(), a.Offset())
+	s.WriteAddr(base.Ctxt, noff, Widthptr, a.Sym().Linksym(), aoff)
 }
 
 // pfuncsym writes the static address of f to n. f must be a global function.
 // Neither n nor f is modified.
-func pfuncsym(n, f *ir.Name) {
+func pfuncsym(n *ir.Name, noff int64, f *ir.Name) {
 	if n.Op() != ir.ONAME {
 		base.Fatalf("pfuncsym n op %v", n.Op())
 	}
@@ -571,21 +570,18 @@ func pfuncsym(n, f *ir.Name) {
 		base.Fatalf("pfuncsym class not PFUNC %d", f.Class())
 	}
 	s := n.Sym().Linksym()
-	s.WriteAddr(base.Ctxt, n.Offset(), Widthptr, funcsym(f.Sym()).Linksym(), f.Offset())
+	s.WriteAddr(base.Ctxt, noff, Widthptr, funcsym(f.Sym()).Linksym(), 0)
 }
 
 // litsym writes the static literal c to n.
 // Neither n nor c is modified.
-func litsym(n *ir.Name, c ir.Node, wid int) {
+func litsym(n *ir.Name, noff int64, c ir.Node, wid int) {
 	if n.Op() != ir.ONAME {
 		base.Fatalf("litsym n op %v", n.Op())
 	}
 	if n.Sym() == nil {
 		base.Fatalf("litsym nil n sym")
 	}
-	if !types.Identical(n.Type(), c.Type()) {
-		base.Fatalf("litsym: type mismatch: %v has type %v, but %v has type %v", n, n.Type(), c, c.Type())
-	}
 	if c.Op() == ir.ONIL {
 		return
 	}
@@ -596,37 +592,37 @@ func litsym(n *ir.Name, c ir.Node, wid int) {
 	switch u := c.Val(); u.Kind() {
 	case constant.Bool:
 		i := int64(obj.Bool2int(constant.BoolVal(u)))
-		s.WriteInt(base.Ctxt, n.Offset(), wid, i)
+		s.WriteInt(base.Ctxt, noff, wid, i)
 
 	case constant.Int:
-		s.WriteInt(base.Ctxt, n.Offset(), wid, ir.IntVal(n.Type(), u))
+		s.WriteInt(base.Ctxt, noff, wid, ir.IntVal(c.Type(), u))
 
 	case constant.Float:
 		f, _ := constant.Float64Val(u)
-		switch n.Type().Kind() {
+		switch c.Type().Kind() {
 		case types.TFLOAT32:
-			s.WriteFloat32(base.Ctxt, n.Offset(), float32(f))
+			s.WriteFloat32(base.Ctxt, noff, float32(f))
 		case types.TFLOAT64:
-			s.WriteFloat64(base.Ctxt, n.Offset(), f)
+			s.WriteFloat64(base.Ctxt, noff, f)
 		}
 
 	case constant.Complex:
 		re, _ := constant.Float64Val(constant.Real(u))
 		im, _ := constant.Float64Val(constant.Imag(u))
-		switch n.Type().Kind() {
+		switch c.Type().Kind() {
 		case types.TCOMPLEX64:
-			s.WriteFloat32(base.Ctxt, n.Offset(), float32(re))
-			s.WriteFloat32(base.Ctxt, n.Offset()+4, float32(im))
+			s.WriteFloat32(base.Ctxt, noff, float32(re))
+			s.WriteFloat32(base.Ctxt, noff+4, float32(im))
 		case types.TCOMPLEX128:
-			s.WriteFloat64(base.Ctxt, n.Offset(), re)
-			s.WriteFloat64(base.Ctxt, n.Offset()+8, im)
+			s.WriteFloat64(base.Ctxt, noff, re)
+			s.WriteFloat64(base.Ctxt, noff+8, im)
 		}
 
 	case constant.String:
 		i := constant.StringVal(u)
 		symdata := stringsym(n.Pos(), i)
-		s.WriteAddr(base.Ctxt, n.Offset(), Widthptr, symdata, 0)
-		s.WriteInt(base.Ctxt, n.Offset()+int64(Widthptr), Widthptr, int64(len(i)))
+		s.WriteAddr(base.Ctxt, noff, Widthptr, symdata, 0)
+		s.WriteInt(base.Ctxt, noff+int64(Widthptr), Widthptr, int64(len(i)))
 
 	default:
 		base.Fatalf("litsym unhandled OLITERAL %v", c)
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 0034556995..174037e30a 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -239,7 +239,7 @@ func (o *Order) addrTemp(n ir.Node) ir.Node {
 		dowidth(n.Type())
 		vstat := readonlystaticname(n.Type())
 		var s InitSchedule
-		s.staticassign(vstat, n)
+		s.staticassign(vstat, 0, n, n.Type())
 		if s.out != nil {
 			base.Fatalf("staticassign of const generated code: %+v", n)
 		}
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index 5b04e10657..901af567fa 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -74,7 +74,7 @@ func cmpstackvarlt(a, b *ir.Name) bool {
 	}
 
 	if a.Class() != ir.PAUTO {
-		return a.Offset() < b.Offset()
+		return a.FrameOffset() < b.FrameOffset()
 	}
 
 	if a.Used() != b.Used() {
@@ -186,7 +186,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 		if thearch.LinkArch.InFamily(sys.MIPS, sys.MIPS64, sys.ARM, sys.ARM64, sys.PPC64, sys.S390X) {
 			s.stksize = Rnd(s.stksize, int64(Widthptr))
 		}
-		n.SetOffset(-s.stksize)
+		n.SetFrameOffset(-s.stksize)
 	}
 
 	s.stksize = Rnd(s.stksize, int64(Widthreg))
@@ -536,10 +536,11 @@ func createSimpleVars(fnsym *obj.LSym, apDecls []*ir.Name) ([]*ir.Name, []*dwarf
 
 func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 	var abbrev int
-	offs := n.Offset()
+	var offs int64
 
 	switch n.Class() {
 	case ir.PAUTO:
+		offs = n.FrameOffset()
 		abbrev = dwarf.DW_ABRV_AUTO
 		if base.Ctxt.FixedFrameSize() == 0 {
 			offs -= int64(Widthptr)
@@ -551,7 +552,7 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 
 	case ir.PPARAM, ir.PPARAMOUT:
 		abbrev = dwarf.DW_ABRV_PARAM
-		offs += base.Ctxt.FixedFrameSize()
+		offs = n.FrameOffset() + base.Ctxt.FixedFrameSize()
 	default:
 		base.Fatalf("createSimpleVar unexpected class %v for node %v", n.Class(), n)
 	}
@@ -693,7 +694,7 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 			Name:          n.Sym().Name,
 			IsReturnValue: isReturnValue,
 			Abbrev:        abbrev,
-			StackOffset:   int32(n.Offset()),
+			StackOffset:   int32(n.FrameOffset()),
 			Type:          base.Ctxt.Lookup(typename),
 			DeclFile:      declpos.RelFilename(),
 			DeclLine:      declpos.RelLine(),
@@ -737,6 +738,7 @@ func stackOffset(slot ssa.LocalSlot) int32 {
 	var off int64
 	switch n.Class() {
 	case ir.PAUTO:
+		off = n.FrameOffset()
 		if base.Ctxt.FixedFrameSize() == 0 {
 			off -= int64(Widthptr)
 		}
@@ -745,9 +747,9 @@ func stackOffset(slot ssa.LocalSlot) int32 {
 			off -= int64(Widthptr)
 		}
 	case ir.PPARAM, ir.PPARAMOUT:
-		off += base.Ctxt.FixedFrameSize()
+		off = n.FrameOffset() + base.Ctxt.FixedFrameSize()
 	}
-	return int32(off + n.Offset() + slot.Off)
+	return int32(off + slot.Off)
 }
 
 // createComplexVar builds a single DWARF variable entry and location list.
diff --git a/src/cmd/compile/internal/gc/pgen_test.go b/src/cmd/compile/internal/gc/pgen_test.go
index ad8b87c6f5..3875fb7223 100644
--- a/src/cmd/compile/internal/gc/pgen_test.go
+++ b/src/cmd/compile/internal/gc/pgen_test.go
@@ -43,7 +43,7 @@ func TestCmpstackvar(t *testing.T) {
 		}
 		n := NewName(s)
 		n.SetType(t)
-		n.SetOffset(xoffset)
+		n.SetFrameOffset(xoffset)
 		n.SetClass(cl)
 		return n
 	}
@@ -158,7 +158,7 @@ func TestStackvarSort(t *testing.T) {
 	nod := func(xoffset int64, t *types.Type, s *types.Sym, cl ir.Class) *ir.Name {
 		n := NewName(s)
 		n.SetType(t)
-		n.SetOffset(xoffset)
+		n.SetFrameOffset(xoffset)
 		n.SetClass(cl)
 		return n
 	}
diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/gc/plive.go
index 6deb3ecc7a..8e266d6599 100644
--- a/src/cmd/compile/internal/gc/plive.go
+++ b/src/cmd/compile/internal/gc/plive.go
@@ -496,10 +496,10 @@ func (lv *Liveness) pointerMap(liveout bvec, vars []*ir.Name, args, locals bvec)
 		node := vars[i]
 		switch node.Class() {
 		case ir.PAUTO:
-			onebitwalktype1(node.Type(), node.Offset()+lv.stkptrsize, locals)
+			onebitwalktype1(node.Type(), node.FrameOffset()+lv.stkptrsize, locals)
 
 		case ir.PPARAM, ir.PPARAMOUT:
-			onebitwalktype1(node.Type(), node.Offset(), args)
+			onebitwalktype1(node.Type(), node.FrameOffset(), args)
 		}
 	}
 }
@@ -1173,7 +1173,7 @@ func (lv *Liveness) emit() (argsSym, liveSym *obj.LSym) {
 	for _, n := range lv.vars {
 		switch n.Class() {
 		case ir.PPARAM, ir.PPARAMOUT:
-			if maxArgNode == nil || n.Offset() > maxArgNode.Offset() {
+			if maxArgNode == nil || n.FrameOffset() > maxArgNode.FrameOffset() {
 				maxArgNode = n
 			}
 		}
@@ -1181,7 +1181,7 @@ func (lv *Liveness) emit() (argsSym, liveSym *obj.LSym) {
 	// Next, find the offset of the largest pointer in the largest node.
 	var maxArgs int64
 	if maxArgNode != nil {
-		maxArgs = maxArgNode.Offset() + typeptrdata(maxArgNode.Type())
+		maxArgs = maxArgNode.FrameOffset() + typeptrdata(maxArgNode.Type())
 	}
 
 	// Size locals bitmaps to be stkptrsize sized.
diff --git a/src/cmd/compile/internal/gc/racewalk.go b/src/cmd/compile/internal/gc/racewalk.go
index 6b5d53e806..472deb16e3 100644
--- a/src/cmd/compile/internal/gc/racewalk.go
+++ b/src/cmd/compile/internal/gc/racewalk.go
@@ -83,9 +83,9 @@ func instrument(fn *ir.Func) {
 			// This only works for amd64. This will not
 			// work on arm or others that might support
 			// race in the future.
-			nodpc := ir.Copy(nodfp).(*ir.Name)
+			nodpc := nodfp.CloneName()
 			nodpc.SetType(types.Types[types.TUINTPTR])
-			nodpc.SetOffset(int64(-Widthptr))
+			nodpc.SetFrameOffset(int64(-Widthptr))
 			fn.Dcl = append(fn.Dcl, nodpc)
 			fn.Enter.Prepend(mkcall("racefuncenter", nil, nil, nodpc))
 			fn.Exit.Append(mkcall("racefuncexit", nil, nil))
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index cfda4afcd8..e2c31e4dd7 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -67,14 +67,16 @@ func (s *InitSchedule) tryStaticInit(nn ir.Node) bool {
 	}
 	lno := setlineno(n)
 	defer func() { base.Pos = lno }()
-	return s.staticassign(n.Left().(*ir.Name), n.Right())
+	nam := n.Left().(*ir.Name)
+	return s.staticassign(nam, 0, n.Right(), nam.Type())
 }
 
 // like staticassign but we are copying an already
 // initialized value r.
-func (s *InitSchedule) staticcopy(l *ir.Name, rn *ir.Name) bool {
+func (s *InitSchedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *types.Type) bool {
 	if rn.Class() == ir.PFUNC {
-		pfuncsym(l, rn)
+		// TODO if roff != 0 { panic }
+		pfuncsym(l, loff, rn)
 		return true
 	}
 	if rn.Class() != ir.PEXTERN || rn.Sym().Pkg != types.LocalPkg {
@@ -92,7 +94,7 @@ func (s *InitSchedule) staticcopy(l *ir.Name, rn *ir.Name) bool {
 	orig := rn
 	r := rn.Defn.(*ir.AssignStmt).Right()
 
-	for r.Op() == ir.OCONVNOP && !types.Identical(r.Type(), l.Type()) {
+	for r.Op() == ir.OCONVNOP && !types.Identical(r.Type(), typ) {
 		r = r.(*ir.ConvExpr).Left()
 	}
 
@@ -102,12 +104,16 @@ func (s *InitSchedule) staticcopy(l *ir.Name, rn *ir.Name) bool {
 		fallthrough
 	case ir.ONAME:
 		r := r.(*ir.Name)
-		if s.staticcopy(l, r) {
+		if s.staticcopy(l, loff, r, typ) {
 			return true
 		}
 		// We may have skipped past one or more OCONVNOPs, so
 		// use conv to ensure r is assignable to l (#13263).
-		s.append(ir.Nod(ir.OAS, l, conv(r, l.Type())))
+		dst := ir.Node(l)
+		if loff != 0 || !types.Identical(typ, l.Type()) {
+			dst = ir.NewNameOffsetExpr(base.Pos, l, loff, typ)
+		}
+		s.append(ir.Nod(ir.OAS, dst, conv(r, typ)))
 		return true
 
 	case ir.ONIL:
@@ -117,13 +123,13 @@ func (s *InitSchedule) staticcopy(l *ir.Name, rn *ir.Name) bool {
 		if isZero(r) {
 			return true
 		}
-		litsym(l, r, int(l.Type().Width))
+		litsym(l, loff, r, int(typ.Width))
 		return true
 
 	case ir.OADDR:
 		if a := r.Left(); a.Op() == ir.ONAME {
 			a := a.(*ir.Name)
-			addrsym(l, a)
+			addrsym(l, loff, a, 0)
 			return true
 		}
 
@@ -131,41 +137,35 @@ func (s *InitSchedule) staticcopy(l *ir.Name, rn *ir.Name) bool {
 		switch r.Left().Op() {
 		case ir.OARRAYLIT, ir.OSLICELIT, ir.OSTRUCTLIT, ir.OMAPLIT:
 			// copy pointer
-			addrsym(l, s.inittemps[r])
+			addrsym(l, loff, s.inittemps[r], 0)
 			return true
 		}
 
 	case ir.OSLICELIT:
 		// copy slice
-		a := s.inittemps[r]
-		slicesym(l, a, ir.Int64Val(r.Right()))
+		slicesym(l, loff, s.inittemps[r], ir.Int64Val(r.Right()))
 		return true
 
 	case ir.OARRAYLIT, ir.OSTRUCTLIT:
 		p := s.initplans[r]
-
-		n := ir.Copy(l).(*ir.Name)
 		for i := range p.E {
 			e := &p.E[i]
-			n.SetOffset(l.Offset() + e.Xoffset)
-			n.SetType(e.Expr.Type())
+			typ := e.Expr.Type()
 			if e.Expr.Op() == ir.OLITERAL || e.Expr.Op() == ir.ONIL {
-				litsym(n, e.Expr, int(n.Type().Width))
+				litsym(l, loff+e.Xoffset, e.Expr, int(typ.Width))
 				continue
 			}
-			ll := ir.SepCopy(n).(*ir.Name)
 			x := e.Expr
 			if x.Op() == ir.OMETHEXPR {
 				x = x.(*ir.MethodExpr).FuncName()
 			}
-			if x.Op() == ir.ONAME && s.staticcopy(ll, x.(*ir.Name)) {
+			if x.Op() == ir.ONAME && s.staticcopy(l, loff+e.Xoffset, x.(*ir.Name), typ) {
 				continue
 			}
 			// Requires computation, but we're
 			// copying someone else's computation.
-			rr := ir.SepCopy(orig).(*ir.Name)
-			rr.SetType(ll.Type())
-			rr.SetOffset(rr.Offset() + e.Xoffset)
+			ll := ir.NewNameOffsetExpr(base.Pos, l, loff+e.Xoffset, typ)
+			rr := ir.NewNameOffsetExpr(base.Pos, orig, e.Xoffset, typ)
 			setlineno(rr)
 			s.append(ir.Nod(ir.OAS, ll, rr))
 		}
@@ -176,7 +176,7 @@ func (s *InitSchedule) staticcopy(l *ir.Name, rn *ir.Name) bool {
 	return false
 }
 
-func (s *InitSchedule) staticassign(l *ir.Name, r ir.Node) bool {
+func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *types.Type) bool {
 	for r.Op() == ir.OCONVNOP {
 		r = r.(*ir.ConvExpr).Left()
 	}
@@ -184,11 +184,11 @@ func (s *InitSchedule) staticassign(l *ir.Name, r ir.Node) bool {
 	switch r.Op() {
 	case ir.ONAME:
 		r := r.(*ir.Name)
-		return s.staticcopy(l, r)
+		return s.staticcopy(l, loff, r, typ)
 
 	case ir.OMETHEXPR:
 		r := r.(*ir.MethodExpr)
-		return s.staticcopy(l, r.FuncName())
+		return s.staticcopy(l, loff, r.FuncName(), typ)
 
 	case ir.ONIL:
 		return true
@@ -197,12 +197,12 @@ func (s *InitSchedule) staticassign(l *ir.Name, r ir.Node) bool {
 		if isZero(r) {
 			return true
 		}
-		litsym(l, r, int(l.Type().Width))
+		litsym(l, loff, r, int(typ.Width))
 		return true
 
 	case ir.OADDR:
-		if nam := stataddr(r.Left()); nam != nil {
-			addrsym(l, nam)
+		if name, offset, ok := stataddr(r.Left()); ok {
+			addrsym(l, loff, name, offset)
 			return true
 		}
 		fallthrough
@@ -214,10 +214,10 @@ func (s *InitSchedule) staticassign(l *ir.Name, r ir.Node) bool {
 			a := staticname(r.Left().Type())
 
 			s.inittemps[r] = a
-			addrsym(l, a)
+			addrsym(l, loff, a, 0)
 
 			// Init underlying literal.
-			if !s.staticassign(a, r.Left()) {
+			if !s.staticassign(a, 0, r.Left(), a.Type()) {
 				s.append(ir.Nod(ir.OAS, a, r.Left()))
 			}
 			return true
@@ -227,7 +227,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, r ir.Node) bool {
 	case ir.OSTR2BYTES:
 		if l.Class() == ir.PEXTERN && r.Left().Op() == ir.OLITERAL {
 			sval := ir.StringVal(r.Left())
-			slicebytes(l, sval)
+			slicebytes(l, loff, sval)
 			return true
 		}
 
@@ -239,27 +239,25 @@ func (s *InitSchedule) staticassign(l *ir.Name, r ir.Node) bool {
 		ta.SetNoalg(true)
 		a := staticname(ta)
 		s.inittemps[r] = a
-		slicesym(l, a, bound)
+		slicesym(l, loff, a, bound)
 		// Fall through to init underlying array.
 		l = a
+		loff = 0
 		fallthrough
 
 	case ir.OARRAYLIT, ir.OSTRUCTLIT:
 		s.initplan(r)
 
 		p := s.initplans[r]
-		n := ir.Copy(l).(*ir.Name)
 		for i := range p.E {
 			e := &p.E[i]
-			n.SetOffset(l.Offset() + e.Xoffset)
-			n.SetType(e.Expr.Type())
 			if e.Expr.Op() == ir.OLITERAL || e.Expr.Op() == ir.ONIL {
-				litsym(n, e.Expr, int(n.Type().Width))
+				litsym(l, loff+e.Xoffset, e.Expr, int(e.Expr.Type().Width))
 				continue
 			}
 			setlineno(e.Expr)
-			a := ir.SepCopy(n).(*ir.Name)
-			if !s.staticassign(a, e.Expr) {
+			if !s.staticassign(l, loff+e.Xoffset, e.Expr, e.Expr.Type()) {
+				a := ir.NewNameOffsetExpr(base.Pos, l, loff+e.Xoffset, e.Expr.Type())
 				s.append(ir.Nod(ir.OAS, a, e.Expr))
 			}
 		}
@@ -276,7 +274,8 @@ func (s *InitSchedule) staticassign(l *ir.Name, r ir.Node) bool {
 			}
 			// Closures with no captured variables are globals,
 			// so the assignment can be done at link time.
-			pfuncsym(l, r.Func().Nname)
+			// TODO if roff != 0 { panic }
+			pfuncsym(l, loff, r.Func().Nname)
 			return true
 		}
 		closuredebugruntimecheck(r)
@@ -303,18 +302,16 @@ func (s *InitSchedule) staticassign(l *ir.Name, r ir.Node) bool {
 		markTypeUsedInInterface(val.Type(), l.Sym().Linksym())
 
 		var itab *ir.AddrExpr
-		if l.Type().IsEmptyInterface() {
+		if typ.IsEmptyInterface() {
 			itab = typename(val.Type())
 		} else {
-			itab = itabname(val.Type(), l.Type())
+			itab = itabname(val.Type(), typ)
 		}
 
 		// Create a copy of l to modify while we emit data.
-		n := ir.Copy(l).(*ir.Name)
 
 		// Emit itab, advance offset.
-		addrsym(n, itab.Left().(*ir.Name))
-		n.SetOffset(n.Offset() + int64(Widthptr))
+		addrsym(l, loff, itab.Left().(*ir.Name), 0)
 
 		// Emit data.
 		if isdirectiface(val.Type()) {
@@ -323,20 +320,19 @@ func (s *InitSchedule) staticassign(l *ir.Name, r ir.Node) bool {
 				return true
 			}
 			// Copy val directly into n.
-			n.SetType(val.Type())
 			setlineno(val)
-			a := ir.SepCopy(n).(*ir.Name)
-			if !s.staticassign(a, val) {
+			if !s.staticassign(l, loff+int64(Widthptr), val, val.Type()) {
+				a := ir.NewNameOffsetExpr(base.Pos, l, loff+int64(Widthptr), val.Type())
 				s.append(ir.Nod(ir.OAS, a, val))
 			}
 		} else {
 			// Construct temp to hold val, write pointer to temp into n.
 			a := staticname(val.Type())
 			s.inittemps[val] = a
-			if !s.staticassign(a, val) {
+			if !s.staticassign(a, 0, val, val.Type()) {
 				s.append(ir.Nod(ir.OAS, a, val))
 			}
-			addrsym(n, a)
+			addrsym(l, loff+int64(Widthptr), a, 0)
 		}
 
 		return true
@@ -626,11 +622,11 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 
 		// copy static to slice
 		var_ = typecheck(var_, ctxExpr|ctxAssign)
-		nam := stataddr(var_)
-		if nam == nil || nam.Class() != ir.PEXTERN {
+		name, offset, ok := stataddr(var_)
+		if !ok || name.Class() != ir.PEXTERN {
 			base.Fatalf("slicelit: %v", var_)
 		}
-		slicesym(nam, vstat, t.NumElem())
+		slicesym(name, offset, vstat, t.NumElem())
 		return
 	}
 
@@ -989,34 +985,32 @@ func getlit(lit ir.Node) int {
 }
 
 // stataddr returns the static address of n, if n has one, or else nil.
-func stataddr(n ir.Node) *ir.Name {
+func stataddr(n ir.Node) (name *ir.Name, offset int64, ok bool) {
 	if n == nil {
-		return nil
+		return nil, 0, false
 	}
 
 	switch n.Op() {
 	case ir.ONAME:
-		return ir.SepCopy(n).(*ir.Name)
+		n := n.(*ir.Name)
+		return n, 0, true
 
 	case ir.OMETHEXPR:
 		n := n.(*ir.MethodExpr)
 		return stataddr(n.FuncName())
 
 	case ir.ODOT:
-		nam := stataddr(n.Left())
-		if nam == nil {
+		if name, offset, ok = stataddr(n.Left()); !ok {
 			break
 		}
-		nam.SetOffset(nam.Offset() + n.Offset())
-		nam.SetType(n.Type())
-		return nam
+		offset += n.Offset()
+		return name, offset, true
 
 	case ir.OINDEX:
 		if n.Left().Type().IsSlice() {
 			break
 		}
-		nam := stataddr(n.Left())
-		if nam == nil {
+		if name, offset, ok = stataddr(n.Left()); !ok {
 			break
 		}
 		l := getlit(n.Right())
@@ -1028,12 +1022,11 @@ func stataddr(n ir.Node) *ir.Name {
 		if n.Type().Width != 0 && thearch.MAXWIDTH/n.Type().Width <= int64(l) {
 			break
 		}
-		nam.SetOffset(nam.Offset() + int64(l)*n.Type().Width)
-		nam.SetType(n.Type())
-		return nam
+		offset += int64(l) * n.Type().Width
+		return name, offset, true
 	}
 
-	return nil
+	return nil, 0, false
 }
 
 func (s *InitSchedule) initplan(n ir.Node) {
@@ -1154,23 +1147,26 @@ func genAsStatic(as *ir.AssignStmt) {
 		base.Fatalf("genAsStatic as.Left not typechecked")
 	}
 
-	nam := stataddr(as.Left())
-	if nam == nil || (nam.Class() != ir.PEXTERN && as.Left() != ir.BlankNode) {
+	name, offset, ok := stataddr(as.Left())
+	if !ok || (name.Class() != ir.PEXTERN && as.Left() != ir.BlankNode) {
 		base.Fatalf("genAsStatic: lhs %v", as.Left())
 	}
 
 	switch r := as.Right(); r.Op() {
 	case ir.OLITERAL:
-		litsym(nam, r, int(r.Type().Width))
+		litsym(name, offset, r, int(r.Type().Width))
 		return
 	case ir.OMETHEXPR:
 		r := r.(*ir.MethodExpr)
-		pfuncsym(nam, r.FuncName())
+		pfuncsym(name, offset, r.FuncName())
 		return
 	case ir.ONAME:
 		r := r.(*ir.Name)
+		if r.Offset() != 0 {
+			base.Fatalf("genAsStatic %+v", as)
+		}
 		if r.Class() == ir.PFUNC {
-			pfuncsym(nam, r)
+			pfuncsym(name, offset, r)
 			return
 		}
 	}
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 2a0134703c..fbfed0640d 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -258,14 +258,14 @@ func (s *state) emitOpenDeferInfo() {
 		}
 	}
 	off = dvarint(x, off, maxargsize)
-	off = dvarint(x, off, -s.deferBitsTemp.Offset())
+	off = dvarint(x, off, -s.deferBitsTemp.FrameOffset())
 	off = dvarint(x, off, int64(len(s.openDefers)))
 
 	// Write in reverse-order, for ease of running in that order at runtime
 	for i := len(s.openDefers) - 1; i >= 0; i-- {
 		r := s.openDefers[i]
 		off = dvarint(x, off, r.n.Left().Type().ArgWidth())
-		off = dvarint(x, off, -r.closureNode.Offset())
+		off = dvarint(x, off, -r.closureNode.FrameOffset())
 		numArgs := len(r.argNodes)
 		if r.rcvrNode != nil {
 			// If there's an interface receiver, treat/place it as the first
@@ -275,13 +275,13 @@ func (s *state) emitOpenDeferInfo() {
 		}
 		off = dvarint(x, off, int64(numArgs))
 		if r.rcvrNode != nil {
-			off = dvarint(x, off, -r.rcvrNode.Offset())
+			off = dvarint(x, off, -r.rcvrNode.FrameOffset())
 			off = dvarint(x, off, s.config.PtrSize)
 			off = dvarint(x, off, 0)
 		}
 		for j, arg := range r.argNodes {
 			f := getParam(r.n, j)
-			off = dvarint(x, off, -arg.Offset())
+			off = dvarint(x, off, -arg.FrameOffset())
 			off = dvarint(x, off, f.Type.Size())
 			off = dvarint(x, off, f.Offset)
 		}
@@ -418,10 +418,10 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 		switch n.Class() {
 		case ir.PPARAM:
 			s.decladdrs[n] = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(n.Type()), n, s.sp, s.startmem)
-			args = append(args, ssa.Param{Type: n.Type(), Offset: int32(n.Offset())})
+			args = append(args, ssa.Param{Type: n.Type(), Offset: int32(n.FrameOffset())})
 		case ir.PPARAMOUT:
 			s.decladdrs[n] = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(n.Type()), n, s.sp, s.startmem)
-			results = append(results, ssa.Param{Type: n.Type(), Offset: int32(n.Offset())})
+			results = append(results, ssa.Param{Type: n.Type(), Offset: int32(n.FrameOffset())})
 			if s.canSSA(n) {
 				// Save ssa-able PPARAMOUT variables so we can
 				// store them back to the stack at the end of
@@ -2101,6 +2101,13 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		}
 		addr := s.addr(n)
 		return s.load(n.Type(), addr)
+	case ir.ONAMEOFFSET:
+		n := n.(*ir.NameOffsetExpr)
+		if s.canSSAName(n.Name_) && canSSAType(n.Type()) {
+			return s.variable(n, n.Type())
+		}
+		addr := s.addr(n)
+		return s.load(n.Type(), addr)
 	case ir.OCLOSUREREAD:
 		addr := s.addr(n)
 		return s.load(n.Type(), addr)
@@ -4927,7 +4934,13 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 	}
 
 	t := types.NewPtr(n.Type())
+	var offset int64
 	switch n.Op() {
+	case ir.ONAMEOFFSET:
+		no := n.(*ir.NameOffsetExpr)
+		offset = no.Offset_
+		n = no.Name_
+		fallthrough
 	case ir.ONAME:
 		n := n.(*ir.Name)
 		switch n.Class() {
@@ -4935,8 +4948,8 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 			// global variable
 			v := s.entryNewValue1A(ssa.OpAddr, t, n.Sym().Linksym(), s.sb)
 			// TODO: Make OpAddr use AuxInt as well as Aux.
-			if n.Offset() != 0 {
-				v = s.entryNewValue1I(ssa.OpOffPtr, v.Type, n.Offset(), v)
+			if offset != 0 {
+				v = s.entryNewValue1I(ssa.OpOffPtr, v.Type, offset, v)
 			}
 			return v
 		case ir.PPARAM:
@@ -5050,7 +5063,10 @@ func (s *state) canSSA(n ir.Node) bool {
 	if n.Op() != ir.ONAME {
 		return false
 	}
-	name := n.(*ir.Name)
+	return s.canSSAName(n.(*ir.Name)) && canSSAType(n.Type())
+}
+
+func (s *state) canSSAName(name *ir.Name) bool {
 	if name.Addrtaken() {
 		return false
 	}
@@ -5084,7 +5100,7 @@ func (s *state) canSSA(n ir.Node) bool {
 		// TODO: treat as a PPARAMOUT?
 		return false
 	}
-	return canSSAType(name.Type())
+	return true
 	// TODO: try to make more variables SSAable?
 }
 
@@ -6184,9 +6200,6 @@ func (s *state) addNamedValue(n *ir.Name, v *ssa.Value) {
 		// from being assigned too early. See #14591 and #14762. TODO: allow this.
 		return
 	}
-	if n.Class() == ir.PAUTO && n.Offset() != 0 {
-		s.Fatalf("AUTO var with offset %v %d", n, n.Offset())
-	}
 	loc := ssa.LocalSlot{N: n.Name(), Type: n.Type(), Off: 0}
 	values, ok := s.f.NamedValues[loc]
 	if !ok {
@@ -6309,7 +6322,7 @@ func (s *SSAGenState) DebugFriendlySetPosFrom(v *ssa.Value) {
 type byXoffset []*ir.Name
 
 func (s byXoffset) Len() int           { return len(s) }
-func (s byXoffset) Less(i, j int) bool { return s[i].Offset() < s[j].Offset() }
+func (s byXoffset) Less(i, j int) bool { return s[i].FrameOffset() < s[j].FrameOffset() }
 func (s byXoffset) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 
 func emitStackObjects(e *ssafn, pp *Progs) {
@@ -6335,7 +6348,7 @@ func emitStackObjects(e *ssafn, pp *Progs) {
 		// Note: arguments and return values have non-negative Xoffset,
 		// in which case the offset is relative to argp.
 		// Locals have a negative Xoffset, in which case the offset is relative to varp.
-		off = duintptr(x, off, uint64(v.Offset()))
+		off = duintptr(x, off, uint64(v.FrameOffset()))
 		if !typesym(v.Type()).Siggen() {
 			e.Fatalf(v.Pos(), "stack object's type symbol not generated for type %s", v.Type())
 		}
@@ -6708,13 +6721,13 @@ func defframe(s *SSAGenState, e *ssafn) {
 		if n.Class() != ir.PAUTO {
 			e.Fatalf(n.Pos(), "needzero class %d", n.Class())
 		}
-		if n.Type().Size()%int64(Widthptr) != 0 || n.Offset()%int64(Widthptr) != 0 || n.Type().Size() == 0 {
+		if n.Type().Size()%int64(Widthptr) != 0 || n.FrameOffset()%int64(Widthptr) != 0 || n.Type().Size() == 0 {
 			e.Fatalf(n.Pos(), "var %L has size %d offset %d", n, n.Type().Size(), n.Offset())
 		}
 
-		if lo != hi && n.Offset()+n.Type().Size() >= lo-int64(2*Widthreg) {
+		if lo != hi && n.FrameOffset()+n.Type().Size() >= lo-int64(2*Widthreg) {
 			// Merge with range we already have.
-			lo = n.Offset()
+			lo = n.FrameOffset()
 			continue
 		}
 
@@ -6722,7 +6735,7 @@ func defframe(s *SSAGenState, e *ssafn) {
 		p = thearch.ZeroRange(pp, p, frame+lo, hi-lo, &state)
 
 		// Set new range.
-		lo = n.Offset()
+		lo = n.FrameOffset()
 		hi = lo + n.Type().Size()
 	}
 
@@ -6793,12 +6806,12 @@ func AddAux2(a *obj.Addr, v *ssa.Value, offset int64) {
 		if n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT {
 			a.Name = obj.NAME_PARAM
 			a.Sym = ir.Orig(n).Sym().Linksym()
-			a.Offset += n.Offset()
+			a.Offset += n.FrameOffset()
 			break
 		}
 		a.Name = obj.NAME_AUTO
 		a.Sym = n.Sym().Linksym()
-		a.Offset += n.Offset()
+		a.Offset += n.FrameOffset()
 	default:
 		v.Fatalf("aux in %s not implemented %#v", v, v.Aux)
 	}
@@ -6941,7 +6954,7 @@ func AddrAuto(a *obj.Addr, v *ssa.Value) {
 	a.Type = obj.TYPE_MEM
 	a.Sym = n.Sym().Linksym()
 	a.Reg = int16(thearch.REGSP)
-	a.Offset = n.Offset() + off
+	a.Offset = n.FrameOffset() + off
 	if n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT {
 		a.Name = obj.NAME_PARAM
 	} else {
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 03998b99be..9c26edf136 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -572,12 +572,12 @@ func backingArrayPtrLen(n ir.Node) (ptr, length ir.Node) {
 	return ptr, length
 }
 
-func syslook(name string) ir.Node {
+func syslook(name string) *ir.Name {
 	s := Runtimepkg.Lookup(name)
 	if s == nil || s.Def == nil {
 		base.Fatalf("syslook: can't find runtime.%s", name)
 	}
-	return ir.AsNode(s.Def)
+	return ir.AsNode(s.Def).(*ir.Name)
 }
 
 // typehash computes a hash value for type t to use in type switch statements.
@@ -609,7 +609,7 @@ func calcHasCall(n ir.Node) bool {
 		base.Fatalf("calcHasCall %+v", n)
 		panic("unreachable")
 
-	case ir.OLITERAL, ir.ONIL, ir.ONAME, ir.OTYPE:
+	case ir.OLITERAL, ir.ONIL, ir.ONAME, ir.OTYPE, ir.ONAMEOFFSET:
 		if n.HasCall() {
 			base.Fatalf("OLITERAL/ONAME/OTYPE should never have calls: %+v", n)
 		}
@@ -770,7 +770,7 @@ func safeexpr(n ir.Node, init *ir.Nodes) ir.Node {
 	}
 
 	switch n.Op() {
-	case ir.ONAME, ir.OLITERAL, ir.ONIL:
+	case ir.ONAME, ir.OLITERAL, ir.ONIL, ir.ONAMEOFFSET:
 		return n
 
 	case ir.OLEN, ir.OCAP:
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 5e56ace7c7..83939fd6bf 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -488,6 +488,10 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 		return n
 
+	case ir.ONAMEOFFSET:
+		// type already set
+		return n
+
 	case ir.OPACK:
 		base.Errorf("use of package %v without selector", n.Sym())
 		n.SetType(nil)
@@ -3106,6 +3110,9 @@ func islvalue(n ir.Node) bool {
 			return false
 		}
 		return true
+
+	case ir.ONAMEOFFSET:
+		return true
 	}
 
 	return false
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 91d3ad215e..23d1ce6003 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -530,7 +530,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 	case ir.ONONAME, ir.OGETG, ir.ONEWOBJ, ir.OMETHEXPR:
 		return n
 
-	case ir.OTYPE, ir.ONAME, ir.OLITERAL, ir.ONIL:
+	case ir.OTYPE, ir.ONAME, ir.OLITERAL, ir.ONIL, ir.ONAMEOFFSET:
 		// TODO(mdempsky): Just return n; see discussion on CL 38655.
 		// Perhaps refactor to use Node.mayBeShared for these instead.
 		// If these return early, make sure to still call
@@ -1999,7 +1999,7 @@ func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 			continue
 		}
 
-		var on ir.Node
+		var on *ir.Name
 		switch n.Type().Kind() {
 		case types.TINTER:
 			if n.Type().IsEmptyInterface() {
@@ -3958,8 +3958,8 @@ func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 // type syntax expression n.Type.
 // The result of substArgTypes MUST be assigned back to old, e.g.
 // 	n.Left = substArgTypes(n.Left, t1, t2)
-func substArgTypes(old ir.Node, types_ ...*types.Type) ir.Node {
-	n := ir.Copy(old)
+func substArgTypes(old *ir.Name, types_ ...*types.Type) *ir.Name {
+	n := old.CloneName()
 
 	for _, t := range types_ {
 		dowidth(t)
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index a6e90a899e..6f15645813 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -631,6 +631,10 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		n := n.(*MethodExpr)
 		fmt.Fprint(s, n.FuncName().Sym())
 
+	case ONAMEOFFSET:
+		n := n.(*NameOffsetExpr)
+		fmt.Fprintf(s, "(%v)(%v@%d)", n.Type(), n.Name_, n.Offset_)
+
 	case OTYPE:
 		if n.Type() == nil && n.Sym() != nil {
 			fmt.Fprint(s, n.Sym())
diff --git a/src/cmd/compile/internal/ir/mknode.go b/src/cmd/compile/internal/ir/mknode.go
index f9b398fe28..f5dacee622 100644
--- a/src/cmd/compile/internal/ir/mknode.go
+++ b/src/cmd/compile/internal/ir/mknode.go
@@ -67,18 +67,23 @@ func main() {
 		fmt.Fprintf(&buf, "\n")
 		fmt.Fprintf(&buf, "func (n *%s) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }\n", name)
 
-		fmt.Fprintf(&buf, "func (n *%s) copy() Node { c := *n\n", name)
-		forNodeFields(typName, typ, func(name string, is func(types.Type) bool) {
-			switch {
-			case is(nodesType):
-				fmt.Fprintf(&buf, "c.%s = c.%s.Copy()\n", name, name)
-			case is(ptrFieldType):
-				fmt.Fprintf(&buf, "if c.%s != nil { c.%s = c.%s.copy() }\n", name, name, name)
-			case is(slicePtrFieldType):
-				fmt.Fprintf(&buf, "c.%s = copyFields(c.%s)\n", name, name)
-			}
-		})
-		fmt.Fprintf(&buf, "return &c }\n")
+		switch name {
+		case "Name":
+			fmt.Fprintf(&buf, "func (n *%s) copy() Node {panic(\"%s.copy\")}\n", name, name)
+		default:
+			fmt.Fprintf(&buf, "func (n *%s) copy() Node { c := *n\n", name)
+			forNodeFields(typName, typ, func(name string, is func(types.Type) bool) {
+				switch {
+				case is(nodesType):
+					fmt.Fprintf(&buf, "c.%s = c.%s.Copy()\n", name, name)
+				case is(ptrFieldType):
+					fmt.Fprintf(&buf, "if c.%s != nil { c.%s = c.%s.copy() }\n", name, name, name)
+				case is(slicePtrFieldType):
+					fmt.Fprintf(&buf, "c.%s = copyFields(c.%s)\n", name, name)
+				}
+			})
+			fmt.Fprintf(&buf, "return &c }\n")
+		}
 
 		fmt.Fprintf(&buf, "func (n *%s) doChildren(do func(Node) error) error { var err error\n", name)
 		forNodeFields(typName, typ, func(name string, is func(types.Type) bool) {
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 96cb0ee054..0c36ffdf7a 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -139,6 +139,12 @@ type Name struct {
 	Outer     *Name
 }
 
+// CloneName makes a cloned copy of the name.
+// It's not ir.Copy(n) because in general that operation is a mistake on names,
+// which uniquely identify variables.
+// Callers must use n.CloneName to make clear they intend to create a separate name.
+func (n *Name) CloneName() *Name { c := *n; return &c }
+
 func (n *Name) isExpr() {}
 
 // NewNameAt returns a new ONAME Node associated with symbol s at position pos.
@@ -186,10 +192,16 @@ func (n *Name) Class() Class        { return n.Class_ }
 func (n *Name) SetClass(x Class)    { n.Class_ = x }
 func (n *Name) Func() *Func         { return n.fn }
 func (n *Name) SetFunc(x *Func)     { n.fn = x }
-func (n *Name) Offset() int64       { return n.Offset_ }
-func (n *Name) SetOffset(x int64)   { n.Offset_ = x }
-func (n *Name) Iota() int64         { return n.Offset_ }
-func (n *Name) SetIota(x int64)     { n.Offset_ = x }
+func (n *Name) Offset() int64       { panic("Name.Offset") }
+func (n *Name) SetOffset(x int64) {
+	if x != 0 {
+		panic("Name.SetOffset")
+	}
+}
+func (n *Name) FrameOffset() int64     { return n.Offset_ }
+func (n *Name) SetFrameOffset(x int64) { n.Offset_ = x }
+func (n *Name) Iota() int64            { return n.Offset_ }
+func (n *Name) SetIota(x int64)        { n.Offset_ = x }
 
 func (*Name) CanBeNtype()    {}
 func (*Name) CanBeAnSSASym() {}
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index 10dfe3c927..a0fae2b949 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -639,10 +639,7 @@ func (n *MethodExpr) editChildren(edit func(Node) Node) {
 }
 
 func (n *Name) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *Name) copy() Node {
-	c := *n
-	return &c
-}
+func (n *Name) copy() Node                    { panic("Name.copy") }
 func (n *Name) doChildren(do func(Node) error) error {
 	var err error
 	return err
-- 
GitLab


From c45313bf451591ab2f7a3ffbbd724bb36d51cba0 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 17 Dec 2020 08:49:22 -0500
Subject: [PATCH 0266/2400] [dev.regabi] cmd/compile: remove prealloc map

The prealloc map seems to exist to avoid adding a field to all nodes.
Now we can add a field to just the nodes that need the field,
so let's do that and avoid having a magic global with extra node state
that isn't preserved by operations like Copy nor printed by Dump.

This also makes clear which nodes can be prealloc'ed.
In particular, the code in walkstmt looked up an entry in
prealloc using an ONAME node, but there's no code that
ever stores such an entry, so the lookup never succeeded.
Having fields makes that kind of thing easier to see and fix.

Passes buildall w/ toolstash -cmp.

Change-Id: I418ad0e2847615c08868120c13ee719dc0b2eacb
Reviewed-on: https://go-review.googlesource.com/c/go/+/278915
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/closure.go | 10 +++++-----
 src/cmd/compile/internal/gc/order.go   | 17 ++++++++---------
 src/cmd/compile/internal/gc/range.go   |  2 +-
 src/cmd/compile/internal/gc/sinit.go   |  2 +-
 src/cmd/compile/internal/gc/walk.go    | 15 +++++----------
 src/cmd/compile/internal/ir/expr.go    | 20 ++++++++++++--------
 src/cmd/compile/internal/ir/stmt.go    |  1 +
 7 files changed, 33 insertions(+), 34 deletions(-)

diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index 6a3ee45a12..85c594787b 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -378,7 +378,7 @@ func closureType(clo ir.Node) *types.Type {
 	return typ
 }
 
-func walkclosure(clo ir.Node, init *ir.Nodes) ir.Node {
+func walkclosure(clo *ir.ClosureExpr, init *ir.Nodes) ir.Node {
 	fn := clo.Func()
 
 	// If no closure vars, don't bother wrapping.
@@ -403,12 +403,12 @@ func walkclosure(clo ir.Node, init *ir.Nodes) ir.Node {
 	cfn := convnop(addr, clo.Type())
 
 	// non-escaping temp to use, if any.
-	if x := prealloc[clo]; x != nil {
+	if x := clo.Prealloc; x != nil {
 		if !types.Identical(typ, x.Type()) {
 			panic("closure type does not match order's assigned type")
 		}
 		addr.SetRight(x)
-		delete(prealloc, clo)
+		clo.Prealloc = nil
 	}
 
 	return walkexpr(cfn, init)
@@ -552,12 +552,12 @@ func walkpartialcall(n *ir.CallPartExpr, init *ir.Nodes) ir.Node {
 	cfn := convnop(addr, n.Type())
 
 	// non-escaping temp to use, if any.
-	if x := prealloc[n]; x != nil {
+	if x := n.Prealloc; x != nil {
 		if !types.Identical(typ, x.Type()) {
 			panic("partial call type does not match order's assigned type")
 		}
 		addr.SetRight(x)
-		delete(prealloc, n)
+		n.Prealloc = nil
 	}
 
 	return walkexpr(cfn, init)
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 174037e30a..87d7cf3aa9 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -846,9 +846,9 @@ func (o *Order) stmt(n ir.Node) {
 			r := n.Right()
 			n.SetRight(o.copyExpr(r))
 
-			// prealloc[n] is the temp for the iterator.
+			// n.Prealloc is the temp for the iterator.
 			// hiter contains pointers and needs to be zeroed.
-			prealloc[n] = o.newTemp(hiter(n.Type()), true)
+			n.Prealloc = o.newTemp(hiter(n.Type()), true)
 		}
 		o.exprListInPlace(n.List())
 		if orderBody {
@@ -1040,9 +1040,6 @@ func (o *Order) exprListInPlace(l ir.Nodes) {
 	}
 }
 
-// prealloc[x] records the allocation to use for x.
-var prealloc = map[ir.Node]ir.Node{}
-
 func (o *Order) exprNoLHS(n ir.Node) ir.Node {
 	return o.expr(n, nil)
 }
@@ -1079,11 +1076,12 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 	// Allocate a temporary to hold the strings.
 	// Fewer than 5 strings use direct runtime helpers.
 	case ir.OADDSTR:
+		n := n.(*ir.AddStringExpr)
 		o.exprList(n.List())
 
 		if n.List().Len() > 5 {
 			t := types.NewArray(types.Types[types.TSTRING], int64(n.List().Len()))
-			prealloc[n] = o.newTemp(t, false)
+			n.Prealloc = o.newTemp(t, false)
 		}
 
 		// Mark string(byteSlice) arguments to reuse byteSlice backing
@@ -1268,7 +1266,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 	case ir.OCLOSURE:
 		n := n.(*ir.ClosureExpr)
 		if n.Transient() && len(n.Func().ClosureVars) > 0 {
-			prealloc[n] = o.newTemp(closureType(n), false)
+			n.Prealloc = o.newTemp(closureType(n), false)
 		}
 		return n
 
@@ -1277,15 +1275,16 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		n.SetLeft(o.expr(n.Left(), nil))
 		if n.Transient() {
 			t := partialCallType(n)
-			prealloc[n] = o.newTemp(t, false)
+			n.Prealloc = o.newTemp(t, false)
 		}
 		return n
 
 	case ir.OSLICELIT:
+		n := n.(*ir.CompLitExpr)
 		o.exprList(n.List())
 		if n.Transient() {
 			t := types.NewArray(n.Type().Elem(), ir.Int64Val(n.Right()))
-			prealloc[n] = o.newTemp(t, false)
+			n.Prealloc = o.newTemp(t, false)
 		}
 		return n
 
diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index 90bee4fc74..aa4f0358c9 100644
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -296,7 +296,7 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		// we only use a once, so no copy needed.
 		ha := a
 
-		hit := prealloc[nrange]
+		hit := nrange.Prealloc
 		th := hit.Type()
 		keysym := th.Field(0).Sym  // depends on layout of iterator struct.  See reflect.go:hiter
 		elemsym := th.Field(1).Sym // ditto
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index e2c31e4dd7..7b710fd511 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -668,7 +668,7 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 
 	// set auto to point at new temp or heap (3 assign)
 	var a ir.Node
-	if x := prealloc[n]; x != nil {
+	if x := n.Prealloc; x != nil {
 		// temp allocated during order.go for dddarg
 		if !types.Identical(t, x.Type()) {
 			panic("dotdotdot base type does not match order's assigned type")
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 23d1ce6003..a4ecc0c44d 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -202,10 +202,7 @@ func walkstmt(n ir.Node) ir.Node {
 			if base.Flag.CompilingRuntime {
 				base.Errorf("%v escapes to heap, not allowed in runtime", v)
 			}
-			if prealloc[v] == nil {
-				prealloc[v] = callnew(v.Type())
-			}
-			nn := ir.Nod(ir.OAS, v.Name().Heapaddr, prealloc[v])
+			nn := ir.Nod(ir.OAS, v.Name().Heapaddr, callnew(v.Type()))
 			nn.SetColas(true)
 			return walkstmt(typecheck(nn, ctxStmt))
 		}
@@ -1638,7 +1635,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return mkcall1(chanfn("chansend1", 2, n.Left().Type()), nil, init, n.Left(), n1)
 
 	case ir.OCLOSURE:
-		return walkclosure(n, init)
+		return walkclosure(n.(*ir.ClosureExpr), init)
 
 	case ir.OCALLPART:
 		return walkpartialcall(n.(*ir.CallPartExpr), init)
@@ -2713,11 +2710,9 @@ func addstr(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
 		fn = "concatstrings"
 
 		t := types.NewSlice(types.Types[types.TSTRING])
-		slice := ir.Nod(ir.OCOMPLIT, nil, ir.TypeNode(t))
-		if prealloc[n] != nil {
-			prealloc[slice] = prealloc[n]
-		}
-		slice.PtrList().Set(args[1:]) // skip buf arg
+		// args[1:] to skip buf arg
+		slice := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(t), args[1:])
+		slice.Prealloc = n.Prealloc
 		args = []ir.Node{buf, slice}
 		slice.SetEsc(EscNone)
 	}
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index b18975d063..8f43eb0fb2 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -89,7 +89,8 @@ func toNtype(x Node) Ntype {
 // An AddStringExpr is a string concatenation Expr[0] + Exprs[1] + ... + Expr[len(Expr)-1].
 type AddStringExpr struct {
 	miniExpr
-	List_ Nodes
+	List_    Nodes
+	Prealloc *Name
 }
 
 func NewAddStringExpr(pos src.XPos, list []Node) *AddStringExpr {
@@ -233,9 +234,10 @@ func (n *CallExpr) SetOp(op Op) {
 // A CallPartExpr is a method expression X.Method (uncalled).
 type CallPartExpr struct {
 	miniExpr
-	Func_  *Func
-	X      Node
-	Method *types.Field
+	Func_    *Func
+	X        Node
+	Method   *types.Field
+	Prealloc *Name
 }
 
 func NewCallPartExpr(pos src.XPos, x Node, method *types.Field, fn *Func) *CallPartExpr {
@@ -255,7 +257,8 @@ func (n *CallPartExpr) SetLeft(x Node)  { n.X = x }
 // A ClosureExpr is a function literal expression.
 type ClosureExpr struct {
 	miniExpr
-	Func_ *Func
+	Func_    *Func
+	Prealloc *Name
 }
 
 func NewClosureExpr(pos src.XPos, fn *Func) *ClosureExpr {
@@ -287,9 +290,10 @@ func (n *ClosureReadExpr) Offset() int64     { return n.Offset_ }
 // Before type-checking, the type is Ntype.
 type CompLitExpr struct {
 	miniExpr
-	orig  Node
-	Ntype Ntype
-	List_ Nodes // initialized values
+	orig     Node
+	Ntype    Ntype
+	List_    Nodes // initialized values
+	Prealloc *Name
 }
 
 func NewCompLitExpr(pos src.XPos, op Op, typ Ntype, list []Node) *CompLitExpr {
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index 4dd1733074..12811821ad 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -368,6 +368,7 @@ type RangeStmt struct {
 	Body_     Nodes
 	HasBreak_ bool
 	typ       *types.Type // TODO(rsc): Remove - use X.Type() instead
+	Prealloc  *Name
 }
 
 func NewRangeStmt(pos src.XPos, vars []Node, x Node, body []Node) *RangeStmt {
-- 
GitLab


From 0bb0baf68338496ded6837294866c8ace3a14e44 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 18 Dec 2020 11:29:49 -0500
Subject: [PATCH 0267/2400] [dev.regabi] cmd/compile: cleanup for concrete
 types - more

Accumulated fixes to recent changes, to make the code safe
for automated deinterfacing.

Change-Id: I200737046cea88f3356b2402f09e2ca477fb8456
Reviewed-on: https://go-review.googlesource.com/c/go/+/279232
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/order.go  |  8 +++-----
 src/cmd/compile/internal/gc/select.go | 11 ++++++-----
 2 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 87d7cf3aa9..7915e4b2f7 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -892,12 +892,12 @@ func (o *Order) stmt(n ir.Node) {
 
 			case ir.OSELRECV2:
 				// case x, ok = <-c
+				r := r.(*ir.AssignListStmt)
 				recv := r.Rlist().First().(*ir.UnaryExpr)
 				recv.SetLeft(o.expr(recv.Left(), nil))
 				if recv.Left().Op() != ir.ONAME {
 					recv.SetLeft(o.copyExpr(recv.Left()))
 				}
-				r := r.(*ir.AssignListStmt)
 				init := r.PtrInit().Slice()
 				r.PtrInit().Set(nil)
 
@@ -915,13 +915,11 @@ func (o *Order) stmt(n ir.Node) {
 						if len(init) > 0 && init[0].Op() == ir.ODCL && init[0].(*ir.Decl).Left() == n {
 							init = init[1:]
 						}
-						dcl := ir.Nod(ir.ODCL, n, nil)
-						dcl = typecheck(dcl, ctxStmt)
+						dcl := typecheck(ir.Nod(ir.ODCL, n, nil), ctxStmt)
 						ncas.PtrInit().Append(dcl)
 					}
 					tmp := o.newTemp(t, t.HasPointers())
-					as := ir.Nod(ir.OAS, n, conv(tmp, n.Type()))
-					as = typecheck(as, ctxStmt)
+					as := typecheck(ir.Nod(ir.OAS, n, conv(tmp, n.Type())), ctxStmt)
 					ncas.PtrInit().Append(as)
 					r.PtrList().SetIndex(i, tmp)
 				}
diff --git a/src/cmd/compile/internal/gc/select.go b/src/cmd/compile/internal/gc/select.go
index c017b8e29a..974c4b254e 100644
--- a/src/cmd/compile/internal/gc/select.go
+++ b/src/cmd/compile/internal/gc/select.go
@@ -207,8 +207,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 			} else {
 				// TODO(cuonglm): make this use selectnbrecv()
 				// if selectnbrecv2(&v, &received, c) { body } else { default body }
-				receivedp := ir.Nod(ir.OADDR, n.List().Second(), nil)
-				receivedp = typecheck(receivedp, ctxExpr)
+				receivedp := typecheck(nodAddr(n.List().Second()), ctxExpr)
 				call = mkcall1(chanfn("selectnbrecv2", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), elem, receivedp, ch)
 			}
 		}
@@ -323,9 +322,11 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 
 		r := ir.Nod(ir.OIF, cond, nil)
 
-		if n := cas.Left(); n != nil && n.Op() == ir.OSELRECV2 && !ir.IsBlank(n.List().Second()) {
-			x := ir.Nod(ir.OAS, n.List().Second(), recvOK)
-			r.PtrBody().Append(typecheck(x, ctxStmt))
+		if n := cas.Left(); n != nil && n.Op() == ir.OSELRECV2 {
+			if !ir.IsBlank(n.List().Second()) {
+				x := ir.Nod(ir.OAS, n.List().Second(), recvOK)
+				r.PtrBody().Append(typecheck(x, ctxStmt))
+			}
 		}
 
 		r.PtrBody().AppendNodes(cas.PtrBody())
-- 
GitLab


From 2153a99914c3c24b98cd4cfccd1d2f670273a4ac Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 21 Dec 2020 01:14:36 -0500
Subject: [PATCH 0268/2400] [dev.regabi] cmd/compile: setup to move Addrconst,
 Patch into cmd/internal/obj

Deleting the Pc assignment from Patch is safe because the actual PCs
are not assigned until well after the compiler is done patching jumps.
And it proves that replacing uses of Patch with SetTarget will be safe later.

Change-Id: Iffcbe03f0b5949ccd4c91e79c1272cd06be0f434
Reviewed-on: https://go-review.googlesource.com/c/go/+/279296
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/gsubr.go | 8 +-------
 src/cmd/internal/obj/link.go         | 6 ++++++
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go
index 79ca669dfb..ddb431d5ab 100644
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ b/src/cmd/compile/internal/gc/gsubr.go
@@ -321,15 +321,9 @@ func ggloblsym(s *obj.LSym, width int32, flags int16) {
 }
 
 func Addrconst(a *obj.Addr, v int64) {
-	a.Sym = nil
-	a.Type = obj.TYPE_CONST
-	a.Offset = v
+	a.SetConst(v)
 }
 
 func Patch(p *obj.Prog, to *obj.Prog) {
-	if p.To.Type != obj.TYPE_BRANCH {
-		base.Fatalf("patch: not a branch")
-	}
 	p.To.SetTarget(to)
-	p.To.Offset = to.Pc
 }
diff --git a/src/cmd/internal/obj/link.go b/src/cmd/internal/obj/link.go
index eaebfaf4b6..7b5c990a5d 100644
--- a/src/cmd/internal/obj/link.go
+++ b/src/cmd/internal/obj/link.go
@@ -250,6 +250,12 @@ func (a *Addr) SetTarget(t *Prog) {
 	a.Val = t
 }
 
+func (a *Addr) SetConst(v int64) {
+	a.Sym = nil
+	a.Type = TYPE_CONST
+	a.Offset = v
+}
+
 // Prog describes a single machine instruction.
 //
 // The general instruction form is:
-- 
GitLab


From 1a3b036b836d5b41871515ec350b203377e087a6 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 21 Dec 2020 01:29:02 -0500
Subject: [PATCH 0269/2400] [dev.regabi] cmd/compile: collect global
 compilation state

There are various global variables tracking the state of the
compilation. Collect them in a single global struct instead.
The struct definition is in package ir, but the struct itself is
still in package gc. It may eventually be threaded through the
code, but in the short term will end up in package typecheck.

Change-Id: I019db07aaedaed2c9b67dd45a4e138dc6028e54c
Reviewed-on: https://go-review.googlesource.com/c/go/+/279297
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/alg.go     |  4 +--
 src/cmd/compile/internal/gc/bexport.go |  2 +-
 src/cmd/compile/internal/gc/closure.go |  8 ++---
 src/cmd/compile/internal/gc/dcl.go     |  8 ++---
 src/cmd/compile/internal/gc/embed.go   |  8 ++---
 src/cmd/compile/internal/gc/export.go  |  8 ++---
 src/cmd/compile/internal/gc/go.go      |  4 ---
 src/cmd/compile/internal/gc/iexport.go |  4 +--
 src/cmd/compile/internal/gc/iimport.go |  2 +-
 src/cmd/compile/internal/gc/init.go    | 13 +++----
 src/cmd/compile/internal/gc/inl.go     |  6 ++--
 src/cmd/compile/internal/gc/main.go    | 49 ++++++++++++++------------
 src/cmd/compile/internal/gc/noder.go   |  9 ++---
 src/cmd/compile/internal/gc/obj.go     | 46 +++++++++++-------------
 src/cmd/compile/internal/gc/pgen.go    |  2 +-
 src/cmd/compile/internal/gc/subr.go    |  2 +-
 src/cmd/compile/internal/gc/walk.go    |  2 +-
 src/cmd/compile/internal/ir/package.go | 35 ++++++++++++++++++
 18 files changed, 116 insertions(+), 96 deletions(-)
 create mode 100644 src/cmd/compile/internal/ir/package.go

diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index f03aec3237..036a1e7491 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -394,7 +394,7 @@ func genhash(t *types.Type) *obj.LSym {
 	}
 
 	fn.SetNilCheckDisabled(true)
-	xtop = append(xtop, fn)
+	Target.Decls = append(Target.Decls, fn)
 
 	// Build closure. It doesn't close over any variables, so
 	// it contains just the function pointer.
@@ -774,7 +774,7 @@ func geneq(t *types.Type) *obj.LSym {
 	// neither of which can be nil, and our comparisons
 	// are shallow.
 	fn.SetNilCheckDisabled(true)
-	xtop = append(xtop, fn)
+	Target.Decls = append(Target.Decls, fn)
 
 	// Generate a closure which points at the function we just generated.
 	dsymptr(closure, 0, sym.Linksym(), 0)
diff --git a/src/cmd/compile/internal/gc/bexport.go b/src/cmd/compile/internal/gc/bexport.go
index 31fd251c5e..2347971fc2 100644
--- a/src/cmd/compile/internal/gc/bexport.go
+++ b/src/cmd/compile/internal/gc/bexport.go
@@ -18,7 +18,7 @@ func (p *exporter) markObject(n ir.Node) {
 	if n.Op() == ir.ONAME {
 		n := n.(*ir.Name)
 		if n.Class() == ir.PFUNC {
-			inlFlood(n)
+			inlFlood(n, exportsym)
 		}
 	}
 
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index 85c594787b..e07ed4cd24 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -89,7 +89,7 @@ func typecheckclosure(clo ir.Node, top int) {
 	fn.SetClosureCalled(top&ctxCallee != 0)
 
 	// Do not typecheck fn twice, otherwise, we will end up pushing
-	// fn to xtop multiple times, causing initLSym called twice.
+	// fn to Target.Decls multiple times, causing initLSym called twice.
 	// See #30709
 	if fn.Typecheck() == 1 {
 		return
@@ -118,7 +118,7 @@ func typecheckclosure(clo ir.Node, top int) {
 	// Type check the body now, but only if we're inside a function.
 	// At top level (in a variable initialization: curfn==nil) we're not
 	// ready to type check code yet; we'll check it later, because the
-	// underlying closure function we create is added to xtop.
+	// underlying closure function we create is added to Target.Decls.
 	if Curfn != nil && clo.Type() != nil {
 		oldfn := Curfn
 		Curfn = fn
@@ -129,7 +129,7 @@ func typecheckclosure(clo ir.Node, top int) {
 		Curfn = oldfn
 	}
 
-	xtop = append(xtop, fn)
+	Target.Decls = append(Target.Decls, fn)
 }
 
 // globClosgen is like Func.Closgen, but for the global scope.
@@ -499,7 +499,7 @@ func makepartialcall(dot *ir.SelectorExpr, t0 *types.Type, meth *types.Sym) *ir.
 	Curfn = fn
 	typecheckslice(fn.Body().Slice(), ctxStmt)
 	sym.Def = fn
-	xtop = append(xtop, fn)
+	Target.Decls = append(Target.Decls, fn)
 	Curfn = savecurfn
 	base.Pos = saveLineNo
 
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 34ba372843..20e5edc4cb 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -17,8 +17,6 @@ import (
 
 // Declaration stack & operations
 
-var externdcl []ir.Node
-
 func testdclstack() {
 	if !types.IsDclstackValid() {
 		base.Fatalf("mark left on the dclstack")
@@ -75,7 +73,7 @@ func declare(n *ir.Name, ctxt ir.Class) {
 		if s.Name == "main" && s.Pkg.Name == "main" {
 			base.ErrorfAt(n.Pos(), "cannot declare main - must be func")
 		}
-		externdcl = append(externdcl, n)
+		Target.Externs = append(Target.Externs, n)
 	} else {
 		if Curfn == nil && ctxt == ir.PAUTO {
 			base.Pos = n.Pos()
@@ -850,7 +848,7 @@ func newNowritebarrierrecChecker() *nowritebarrierrecChecker {
 	// important to handle it for this check, so we model it
 	// directly. This has to happen before transformclosure since
 	// it's a lot harder to work out the argument after.
-	for _, n := range xtop {
+	for _, n := range Target.Decls {
 		if n.Op() != ir.ODCLFUNC {
 			continue
 		}
@@ -925,7 +923,7 @@ func (c *nowritebarrierrecChecker) check() {
 	// q is the queue of ODCLFUNC Nodes to visit in BFS order.
 	var q ir.NameQueue
 
-	for _, n := range xtop {
+	for _, n := range Target.Decls {
 		if n.Op() != ir.ODCLFUNC {
 			continue
 		}
diff --git a/src/cmd/compile/internal/gc/embed.go b/src/cmd/compile/internal/gc/embed.go
index b9c88c0d5b..7d67d2dfd0 100644
--- a/src/cmd/compile/internal/gc/embed.go
+++ b/src/cmd/compile/internal/gc/embed.go
@@ -17,8 +17,6 @@ import (
 	"strings"
 )
 
-var embedlist []ir.Node
-
 const (
 	embedUnknown = iota
 	embedBytes
@@ -117,12 +115,12 @@ func varEmbed(p *noder, names []ir.Node, typ ir.Ntype, exprs []ir.Node, embeds [
 		v.Sym().Def = v
 		v.Name().Ntype = typ
 		v.SetClass(ir.PEXTERN)
-		externdcl = append(externdcl, v)
+		Target.Externs = append(Target.Externs, v)
 		exprs = []ir.Node{v}
 	}
 
 	v.Name().SetEmbedFiles(list)
-	embedlist = append(embedlist, v)
+	Target.Embeds = append(Target.Embeds, v)
 	return exprs
 }
 
@@ -187,7 +185,7 @@ func embedFileLess(x, y string) bool {
 }
 
 func dumpembeds() {
-	for _, v := range embedlist {
+	for _, v := range Target.Embeds {
 		initEmbed(v)
 	}
 }
diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index 16d45a00aa..42e0db2b20 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -21,8 +21,6 @@ func exportf(bout *bio.Writer, format string, args ...interface{}) {
 	}
 }
 
-var asmlist []ir.Node
-
 // exportsym marks n for export (or reexport).
 func exportsym(n *ir.Name) {
 	if n.Sym().OnExportList() {
@@ -34,7 +32,7 @@ func exportsym(n *ir.Name) {
 		fmt.Printf("export symbol %v\n", n.Sym())
 	}
 
-	exportlist = append(exportlist, n)
+	Target.Exports = append(Target.Exports, n)
 }
 
 func initname(s string) bool {
@@ -57,7 +55,7 @@ func autoexport(n *ir.Name, ctxt ir.Class) {
 	}
 	if base.Flag.AsmHdr != "" && !n.Sym().Asm() {
 		n.Sym().SetAsm(true)
-		asmlist = append(asmlist, n)
+		Target.Asms = append(Target.Asms, n)
 	}
 }
 
@@ -202,7 +200,7 @@ func dumpasmhdr() {
 		base.Fatalf("%v", err)
 	}
 	fmt.Fprintf(b, "// generated by compile -asmhdr from package %s\n\n", types.LocalPkg.Name)
-	for _, n := range asmlist {
+	for _, n := range Target.Asms {
 		if n.Sym().IsBlank() {
 			continue
 		}
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index b00a7ca14c..b092e6933c 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -128,10 +128,6 @@ var (
 	iscmp [ir.OEND]bool
 )
 
-var xtop []ir.Node
-
-var exportlist []*ir.Name
-
 var importlist []*ir.Func // imported functions and methods with inlinable bodies
 
 var (
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index b54eeca7cb..969f6bc3b2 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -251,7 +251,7 @@ func iexport(out *bufio.Writer) {
 	{
 		// TODO(mdempsky): Separate from bexport logic.
 		p := &exporter{marked: make(map[*types.Type]bool)}
-		for _, n := range exportlist {
+		for _, n := range Target.Exports {
 			p.markObject(n)
 		}
 	}
@@ -272,7 +272,7 @@ func iexport(out *bufio.Writer) {
 	}
 
 	// Initialize work queue with exported declarations.
-	for _, n := range exportlist {
+	for _, n := range Target.Exports {
 		p.pushDecl(n)
 	}
 
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 154c4e3a84..549751335e 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -1111,7 +1111,7 @@ func (r *importReader) exprsOrNil() (a, b ir.Node) {
 }
 
 func builtinCall(pos src.XPos, op ir.Op) *ir.CallExpr {
-	return ir.NewCallExpr(pos, ir.OCALL, mkname(types.BuiltinPkg.Lookup(ir.OpNames[op])), nil)
+	return ir.NewCallExpr(pos, ir.OCALL, ir.NewIdent(base.Pos, types.BuiltinPkg.Lookup(ir.OpNames[op])), nil)
 }
 
 func npos(pos src.XPos, n ir.Node) ir.Node {
diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index 8de4d84f2d..f1398f8644 100644
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -27,9 +27,6 @@ func renameinit() *types.Sym {
 	return s
 }
 
-// List of imported packages, in source code order. See #31636.
-var sourceOrderImports []*types.Pkg
-
 // fninit makes an initialization record for the package.
 // See runtime/proc.go:initTask for its layout.
 // The 3 tasks for initialization are:
@@ -43,7 +40,7 @@ func fninit(n []ir.Node) {
 	var fns []*obj.LSym  // functions to call for package initialization
 
 	// Find imported packages with init tasks.
-	for _, pkg := range sourceOrderImports {
+	for _, pkg := range Target.Imports {
 		n := resolve(oldname(pkg.Lookup(".inittask")))
 		if n.Op() == ir.ONONAME {
 			continue
@@ -72,7 +69,7 @@ func fninit(n []ir.Node) {
 		Curfn = fn
 		typecheckslice(nf, ctxStmt)
 		Curfn = nil
-		xtop = append(xtop, fn)
+		Target.Decls = append(Target.Decls, fn)
 		fns = append(fns, initializers.Linksym())
 	}
 	if initTodo.Dcl != nil {
@@ -84,16 +81,14 @@ func fninit(n []ir.Node) {
 	initTodo = nil
 
 	// Record user init functions.
-	for i := 0; i < renameinitgen; i++ {
-		s := lookupN("init.", i)
-		fn := ir.AsNode(s.Def).Name().Defn.(*ir.Func)
+	for _, fn := range Target.Inits {
 		// Skip init functions with empty bodies.
 		if fn.Body().Len() == 1 {
 			if stmt := fn.Body().First(); stmt.Op() == ir.OBLOCK && stmt.(*ir.BlockStmt).List().Len() == 0 {
 				continue
 			}
 		}
-		fns = append(fns, s.Linksym())
+		fns = append(fns, fn.Nname.Sym().Linksym())
 	}
 
 	if len(deps) == 0 && len(fns) == 0 && types.LocalPkg.Name != "main" && types.LocalPkg.Name != "runtime" {
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index b571c2b914..6c8f380d87 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -230,7 +230,7 @@ func caninl(fn *ir.Func) {
 
 // inlFlood marks n's inline body for export and recursively ensures
 // all called functions are marked too.
-func inlFlood(n *ir.Name) {
+func inlFlood(n *ir.Name, exportsym func(*ir.Name)) {
 	if n == nil {
 		return
 	}
@@ -258,13 +258,13 @@ func inlFlood(n *ir.Name) {
 	ir.VisitList(ir.AsNodes(fn.Inl.Body), func(n ir.Node) {
 		switch n.Op() {
 		case ir.OMETHEXPR, ir.ODOTMETH:
-			inlFlood(methodExprName(n))
+			inlFlood(methodExprName(n), exportsym)
 
 		case ir.ONAME:
 			n := n.(*ir.Name)
 			switch n.Class() {
 			case ir.PFUNC:
-				inlFlood(n)
+				inlFlood(n, exportsym)
 				exportsym(n)
 			case ir.PEXTERN:
 				exportsym(n)
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 03e787f718..2c598a2329 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -51,6 +51,9 @@ func hidePanic() {
 	}
 }
 
+// Target is the package being compiled.
+var Target *ir.Package
+
 // timing data for compiler phases
 var timings Timings
 
@@ -207,6 +210,8 @@ func Main(archInit func(*Arch)) {
 	Widthptr = thearch.LinkArch.PtrSize
 	Widthreg = thearch.LinkArch.RegSize
 
+	Target = new(ir.Package)
+
 	// initialize types package
 	// (we need to do this to break dependencies that otherwise
 	// would lead to import cycles)
@@ -240,33 +245,33 @@ func Main(archInit func(*Arch)) {
 	//   to avoid cycles like #18640.
 	//   TODO(gri) Remove this again once we have a fix for #25838.
 
-	// Don't use range--typecheck can add closures to xtop.
+	// Don't use range--typecheck can add closures to Target.Decls.
 	timings.Start("fe", "typecheck", "top1")
-	for i := 0; i < len(xtop); i++ {
-		n := xtop[i]
+	for i := 0; i < len(Target.Decls); i++ {
+		n := Target.Decls[i]
 		if op := n.Op(); op != ir.ODCL && op != ir.OAS && op != ir.OAS2 && (op != ir.ODCLTYPE || !n.(*ir.Decl).Left().Name().Alias()) {
-			xtop[i] = typecheck(n, ctxStmt)
+			Target.Decls[i] = typecheck(n, ctxStmt)
 		}
 	}
 
 	// Phase 2: Variable assignments.
 	//   To check interface assignments, depends on phase 1.
 
-	// Don't use range--typecheck can add closures to xtop.
+	// Don't use range--typecheck can add closures to Target.Decls.
 	timings.Start("fe", "typecheck", "top2")
-	for i := 0; i < len(xtop); i++ {
-		n := xtop[i]
+	for i := 0; i < len(Target.Decls); i++ {
+		n := Target.Decls[i]
 		if op := n.Op(); op == ir.ODCL || op == ir.OAS || op == ir.OAS2 || op == ir.ODCLTYPE && n.(*ir.Decl).Left().Name().Alias() {
-			xtop[i] = typecheck(n, ctxStmt)
+			Target.Decls[i] = typecheck(n, ctxStmt)
 		}
 	}
 
 	// Phase 3: Type check function bodies.
-	// Don't use range--typecheck can add closures to xtop.
+	// Don't use range--typecheck can add closures to Target.Decls.
 	timings.Start("fe", "typecheck", "func")
 	var fcount int64
-	for i := 0; i < len(xtop); i++ {
-		n := xtop[i]
+	for i := 0; i < len(Target.Decls); i++ {
+		n := Target.Decls[i]
 		if n.Op() == ir.ODCLFUNC {
 			Curfn = n.(*ir.Func)
 			decldepth = 1
@@ -287,9 +292,9 @@ func Main(archInit func(*Arch)) {
 	// TODO(mdempsky): This should be handled when type checking their
 	// corresponding ODCL nodes.
 	timings.Start("fe", "typecheck", "externdcls")
-	for i, n := range externdcl {
+	for i, n := range Target.Externs {
 		if n.Op() == ir.ONAME {
-			externdcl[i] = typecheck(externdcl[i], ctxExpr)
+			Target.Externs[i] = typecheck(Target.Externs[i], ctxExpr)
 		}
 	}
 
@@ -301,13 +306,13 @@ func Main(archInit func(*Arch)) {
 
 	timings.AddEvent(fcount, "funcs")
 
-	fninit(xtop)
+	fninit(Target.Decls)
 
 	// Phase 4: Decide how to capture closed variables.
 	// This needs to run before escape analysis,
 	// because variables captured by value do not escape.
 	timings.Start("fe", "capturevars")
-	for _, n := range xtop {
+	for _, n := range Target.Decls {
 		if n.Op() == ir.ODCLFUNC && n.Func().OClosure != nil {
 			Curfn = n.(*ir.Func)
 			capturevars(Curfn)
@@ -332,7 +337,7 @@ func Main(archInit func(*Arch)) {
 
 	if base.Flag.LowerL != 0 {
 		// Find functions that can be inlined and clone them before walk expands them.
-		visitBottomUp(xtop, func(list []*ir.Func, recursive bool) {
+		visitBottomUp(Target.Decls, func(list []*ir.Func, recursive bool) {
 			numfns := numNonClosures(list)
 			for _, n := range list {
 				if !recursive || numfns > 1 {
@@ -350,7 +355,7 @@ func Main(archInit func(*Arch)) {
 		})
 	}
 
-	for _, n := range xtop {
+	for _, n := range Target.Decls {
 		if n.Op() == ir.ODCLFUNC {
 			devirtualize(n.(*ir.Func))
 		}
@@ -366,7 +371,7 @@ func Main(archInit func(*Arch)) {
 	// Large values are also moved off stack in escape analysis;
 	// because large values may contain pointers, it must happen early.
 	timings.Start("fe", "escapes")
-	escapes(xtop)
+	escapes(Target.Decls)
 
 	// Collect information for go:nowritebarrierrec
 	// checking. This must happen before transformclosure.
@@ -380,7 +385,7 @@ func Main(archInit func(*Arch)) {
 	// This needs to happen before walk, because closures must be transformed
 	// before walk reaches a call of a closure.
 	timings.Start("fe", "xclosures")
-	for _, n := range xtop {
+	for _, n := range Target.Decls {
 		if n.Op() == ir.ODCLFUNC && n.Func().OClosure != nil {
 			Curfn = n.(*ir.Func)
 			transformclosure(Curfn)
@@ -399,11 +404,11 @@ func Main(archInit func(*Arch)) {
 	peekitabs()
 
 	// Phase 8: Compile top level functions.
-	// Don't use range--walk can add functions to xtop.
+	// Don't use range--walk can add functions to Target.Decls.
 	timings.Start("be", "compilefuncs")
 	fcount = 0
-	for i := 0; i < len(xtop); i++ {
-		n := xtop[i]
+	for i := 0; i < len(Target.Decls); i++ {
+		n := Target.Decls[i]
 		if n.Op() == ir.ODCLFUNC {
 			funccompile(n.(*ir.Func))
 			fcount++
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 43ec2ce350..10eac6e815 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -27,7 +27,7 @@ import (
 
 // parseFiles concurrently parses files into *syntax.File structures.
 // Each declaration in every *syntax.File is converted to a syntax tree
-// and its root represented by *Node is appended to xtop.
+// and its root represented by *Node is appended to Target.Decls.
 // Returns the total count of parsed lines.
 func parseFiles(filenames []string) uint {
 	noders := make([]*noder, 0, len(filenames))
@@ -260,7 +260,7 @@ func (p *noder) node() {
 		p.checkUnused(pragma)
 	}
 
-	xtop = append(xtop, p.decls(p.file.DeclList)...)
+	Target.Decls = append(Target.Decls, p.decls(p.file.DeclList)...)
 
 	base.Pos = src.NoXPos
 	clearImports()
@@ -297,7 +297,7 @@ func (p *noder) processPragmas() {
 		}
 	}
 
-	pragcgobuf = append(pragcgobuf, p.pragcgobuf...)
+	Target.CgoPragmas = append(Target.CgoPragmas, p.pragcgobuf...)
 }
 
 func (p *noder) decls(decls []syntax.Decl) (l []ir.Node) {
@@ -354,7 +354,7 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
 	}
 
 	if !ipkg.Direct {
-		sourceOrderImports = append(sourceOrderImports, ipkg)
+		Target.Imports = append(Target.Imports, ipkg)
 	}
 	ipkg.Direct = true
 
@@ -530,6 +530,7 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) ir.Node {
 			if len(t.Params) > 0 || len(t.Results) > 0 {
 				base.ErrorfAt(f.Pos(), "func init must have no arguments and no return values")
 			}
+			Target.Inits = append(Target.Inits, f)
 		}
 
 		if types.LocalPkg.Name == "main" && name.Name == "main" {
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index cd1500d1ed..094c386218 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -117,13 +117,14 @@ func dumpCompilerObj(bout *bio.Writer) {
 }
 
 func dumpdata() {
-	externs := len(externdcl)
-	xtops := len(xtop)
+	numExterns := len(Target.Externs)
+	numDecls := len(Target.Decls)
 
-	dumpglobls()
+	dumpglobls(Target.Externs)
+	dumpfuncsyms()
 	addptabs()
-	exportlistLen := len(exportlist)
-	addsignats(externdcl)
+	numExports := len(Target.Exports)
+	addsignats(Target.Externs)
 	dumpsignats()
 	dumptabs()
 	ptabsLen := len(ptabs)
@@ -140,28 +141,22 @@ func dumpdata() {
 	// In the typical case, we loop 0 or 1 times.
 	// It was not until issue 24761 that we found any code that required a loop at all.
 	for {
-		for i := xtops; i < len(xtop); i++ {
-			n := xtop[i]
+		for i := numDecls; i < len(Target.Decls); i++ {
+			n := Target.Decls[i]
 			if n.Op() == ir.ODCLFUNC {
 				funccompile(n.(*ir.Func))
 			}
 		}
-		xtops = len(xtop)
+		numDecls = len(Target.Decls)
 		compileFunctions()
 		dumpsignats()
-		if xtops == len(xtop) {
+		if numDecls == len(Target.Decls) {
 			break
 		}
 	}
 
 	// Dump extra globals.
-	tmp := externdcl
-
-	if externdcl != nil {
-		externdcl = externdcl[externs:]
-	}
-	dumpglobls()
-	externdcl = tmp
+	dumpglobls(Target.Externs[numExterns:])
 
 	if zerosize > 0 {
 		zero := mappkg.Lookup("zero")
@@ -170,8 +165,8 @@ func dumpdata() {
 
 	addGCLocals()
 
-	if exportlistLen != len(exportlist) {
-		base.Fatalf("exportlist changed after compile functions loop")
+	if numExports != len(Target.Exports) {
+		base.Fatalf("Target.Exports changed after compile functions loop")
 	}
 	if ptabsLen != len(ptabs) {
 		base.Fatalf("ptabs changed after compile functions loop")
@@ -184,11 +179,11 @@ func dumpdata() {
 func dumpLinkerObj(bout *bio.Writer) {
 	printObjHeader(bout)
 
-	if len(pragcgobuf) != 0 {
+	if len(Target.CgoPragmas) != 0 {
 		// write empty export section; must be before cgo section
 		fmt.Fprintf(bout, "\n$$\n\n$$\n\n")
 		fmt.Fprintf(bout, "\n$$  // cgo\n")
-		if err := json.NewEncoder(bout).Encode(pragcgobuf); err != nil {
+		if err := json.NewEncoder(bout).Encode(Target.CgoPragmas); err != nil {
 			base.Fatalf("serializing pragcgobuf: %v", err)
 		}
 		fmt.Fprintf(bout, "\n$$\n\n")
@@ -203,7 +198,7 @@ func addptabs() {
 	if !base.Ctxt.Flag_dynlink || types.LocalPkg.Name != "main" {
 		return
 	}
-	for _, exportn := range exportlist {
+	for _, exportn := range Target.Exports {
 		s := exportn.Sym()
 		nn := ir.AsNode(s.Def)
 		if nn == nil {
@@ -267,9 +262,9 @@ func dumpGlobalConst(n ir.Node) {
 	base.Ctxt.DwarfIntConst(base.Ctxt.Pkgpath, n.Sym().Name, typesymname(t), ir.IntVal(t, v))
 }
 
-func dumpglobls() {
+func dumpglobls(externs []ir.Node) {
 	// add globals
-	for _, n := range externdcl {
+	for _, n := range externs {
 		switch n.Op() {
 		case ir.ONAME:
 			dumpGlobal(n.(*ir.Name))
@@ -277,7 +272,9 @@ func dumpglobls() {
 			dumpGlobalConst(n)
 		}
 	}
+}
 
+func dumpfuncsyms() {
 	sort.Slice(funcsyms, func(i, j int) bool {
 		return funcsyms[i].LinksymName() < funcsyms[j].LinksymName()
 	})
@@ -286,9 +283,6 @@ func dumpglobls() {
 		dsymptr(sf, 0, s.Linksym(), 0)
 		ggloblsym(sf, int32(Widthptr), obj.DUPOK|obj.RODATA)
 	}
-
-	// Do not reprocess funcsyms on next dumpglobls call.
-	funcsyms = nil
 }
 
 // addGCLocals adds gcargs, gclocals, gcregs, and stack object symbols to Ctxt.Data.
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index 901af567fa..5b5288c389 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -287,7 +287,7 @@ func compilenow(fn *ir.Func) bool {
 	// candidate AND was not inlined (yet), put it onto the compile
 	// queue instead of compiling it immediately. This is in case we
 	// wind up inlining it into a method wrapper that is generated by
-	// compiling a function later on in the xtop list.
+	// compiling a function later on in the Target.Decls list.
 	if ir.IsMethod(fn) && isInlinableButNotInlined(fn) {
 		return false
 	}
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 9c26edf136..2b0047e150 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -1275,7 +1275,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	escapeFuncs([]*ir.Func{fn}, false)
 
 	Curfn = nil
-	xtop = append(xtop, fn)
+	Target.Decls = append(Target.Decls, fn)
 }
 
 func paramNnames(ft *types.Type) []ir.Node {
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index a4ecc0c44d..657a744e68 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -3942,7 +3942,7 @@ func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 
 	typecheckFunc(fn)
 	typecheckslice(fn.Body().Slice(), ctxStmt)
-	xtop = append(xtop, fn)
+	Target.Decls = append(Target.Decls, fn)
 
 	call = ir.NewCallExpr(base.Pos, ir.OCALL, fn.Nname, n.List().Slice())
 	return walkexpr(typecheck(call, ctxStmt), init)
diff --git a/src/cmd/compile/internal/ir/package.go b/src/cmd/compile/internal/ir/package.go
new file mode 100644
index 0000000000..3896e2b91b
--- /dev/null
+++ b/src/cmd/compile/internal/ir/package.go
@@ -0,0 +1,35 @@
+// Copyright 2020 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 ir
+
+import "cmd/compile/internal/types"
+
+// A Package holds information about the package being compiled.
+type Package struct {
+	// Imports, listed in source order.
+	// See golang.org/issue/31636.
+	Imports []*types.Pkg
+
+	// Init functions, listed in source order.
+	Inits []*Func
+
+	// Top-level declarations.
+	Decls []Node
+
+	// Extern (package global) declarations.
+	Externs []Node
+
+	// Assembly function declarations.
+	Asms []*Name
+
+	// Cgo directives.
+	CgoPragmas [][]string
+
+	// Variables with //go:embed lines.
+	Embeds []*Name
+
+	// Exported (or re-exported) symbols.
+	Exports []*Name
+}
-- 
GitLab


From 85ce6ecfe3c54075c7bc53538940f0319b57068b Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 21 Dec 2020 09:11:12 -0500
Subject: [PATCH 0270/2400] [dev.regabi] cmd/compile: separate exportsym more
 cleanly

Clean up a TODO (and make the package gc split easier)
by moving the exportsym walk out of iexport proper.

Also move exportsym call out of fninit.

Change-Id: Ie5887a68d325f7154201f4a35b9b4be4bf4b48dd
Reviewed-on: https://go-review.googlesource.com/c/go/+/279298
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/export.go  |  5 +++++
 src/cmd/compile/internal/gc/iexport.go | 10 ----------
 src/cmd/compile/internal/gc/init.go    | 20 ++++++++++----------
 src/cmd/compile/internal/gc/main.go    |  4 +++-
 4 files changed, 18 insertions(+), 21 deletions(-)

diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index 42e0db2b20..d26dd9af5d 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -60,6 +60,11 @@ func autoexport(n *ir.Name, ctxt ir.Class) {
 }
 
 func dumpexport(bout *bio.Writer) {
+	p := &exporter{marked: make(map[*types.Type]bool)}
+	for _, n := range Target.Exports {
+		p.markObject(n)
+	}
+
 	// The linker also looks for the $$ marker - use char after $$ to distinguish format.
 	exportf(bout, "\n$$B\n") // indicate binary export format
 	off := bout.Offset()
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index 969f6bc3b2..c03445044d 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -246,16 +246,6 @@ const (
 )
 
 func iexport(out *bufio.Writer) {
-	// Mark inline bodies that are reachable through exported objects.
-	// (Phase 0 of bexport.go.)
-	{
-		// TODO(mdempsky): Separate from bexport logic.
-		p := &exporter{marked: make(map[*types.Type]bool)}
-		for _, n := range Target.Exports {
-			p.markObject(n)
-		}
-	}
-
 	p := iexporter{
 		allPkgs:     map[*types.Pkg]bool{},
 		stringIndex: map[string]uint64{},
diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index f1398f8644..1c15ce1318 100644
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -27,21 +27,21 @@ func renameinit() *types.Sym {
 	return s
 }
 
-// fninit makes an initialization record for the package.
+// fninit makes and returns an initialization record for the package.
 // See runtime/proc.go:initTask for its layout.
 // The 3 tasks for initialization are:
 //   1) Initialize all of the packages the current package depends on.
 //   2) Initialize all the variables that have initializers.
 //   3) Run any init functions.
-func fninit(n []ir.Node) {
-	nf := initOrder(n)
+func fninit() *ir.Name {
+	nf := initOrder(Target.Decls)
 
 	var deps []*obj.LSym // initTask records for packages the current package depends on
 	var fns []*obj.LSym  // functions to call for package initialization
 
 	// Find imported packages with init tasks.
 	for _, pkg := range Target.Imports {
-		n := resolve(oldname(pkg.Lookup(".inittask")))
+		n := resolve(ir.NewIdent(base.Pos, pkg.Lookup(".inittask")))
 		if n.Op() == ir.ONONAME {
 			continue
 		}
@@ -92,16 +92,15 @@ func fninit(n []ir.Node) {
 	}
 
 	if len(deps) == 0 && len(fns) == 0 && types.LocalPkg.Name != "main" && types.LocalPkg.Name != "runtime" {
-		return // nothing to initialize
+		return nil // nothing to initialize
 	}
 
 	// Make an .inittask structure.
 	sym := lookup(".inittask")
-	nn := NewName(sym)
-	nn.SetType(types.Types[types.TUINT8]) // fake type
-	nn.SetClass(ir.PEXTERN)
-	sym.Def = nn
-	exportsym(nn)
+	task := NewName(sym)
+	task.SetType(types.Types[types.TUINT8]) // fake type
+	task.SetClass(ir.PEXTERN)
+	sym.Def = task
 	lsym := sym.Linksym()
 	ot := 0
 	ot = duintptr(lsym, ot, 0) // state: not initialized yet
@@ -116,4 +115,5 @@ func fninit(n []ir.Node) {
 	// An initTask has pointers, but none into the Go heap.
 	// It's not quite read only, the state field must be modifiable.
 	ggloblsym(lsym, int32(ot), obj.NOPTR)
+	return task
 }
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 2c598a2329..545491daa1 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -306,7 +306,9 @@ func Main(archInit func(*Arch)) {
 
 	timings.AddEvent(fcount, "funcs")
 
-	fninit(Target.Decls)
+	if initTask := fninit(); initTask != nil {
+		exportsym(initTask)
+	}
 
 	// Phase 4: Decide how to capture closed variables.
 	// This needs to run before escape analysis,
-- 
GitLab


From 4836e28ac0482183a3a6af88ee4295ffdbc94f62 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 21 Dec 2020 01:36:15 -0500
Subject: [PATCH 0271/2400] [dev.regabi] cmd/compile: separate noder more
 cleanly

Separate embed, cgo pragmas, and Main trackScopes variable
from noder more cleanly.

This lets us split embed and noder into new packages.
It also assumes that the local embedded variables will be
removed and deletes them now for simplicity.

Change-Id: I9638bcc2c5f0e76440de056c6285b6aa2f73a00d
Reviewed-on: https://go-review.googlesource.com/c/go/+/279299
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/embed.go        | 51 ++++++++++-----------
 src/cmd/compile/internal/gc/go.go           |  6 +--
 src/cmd/compile/internal/gc/main.go         | 17 ++++++-
 src/cmd/compile/internal/gc/noder.go        | 26 +++--------
 src/cmd/compile/internal/ir/name.go         | 50 +++++++-------------
 src/embed/internal/embedtest/embed_test.go  | 28 +++--------
 src/embed/internal/embedtest/embedx_test.go | 14 ------
 7 files changed, 72 insertions(+), 120 deletions(-)

diff --git a/src/cmd/compile/internal/gc/embed.go b/src/cmd/compile/internal/gc/embed.go
index 7d67d2dfd0..0d4ce83716 100644
--- a/src/cmd/compile/internal/gc/embed.go
+++ b/src/cmd/compile/internal/gc/embed.go
@@ -24,8 +24,6 @@ const (
 	embedFiles
 )
 
-var numLocalEmbed int
-
 func varEmbed(p *noder, names []ir.Node, typ ir.Ntype, exprs []ir.Node, embeds []PragmaEmbed) (newExprs []ir.Node) {
 	haveEmbed := false
 	for _, decl := range p.file.DeclList {
@@ -63,25 +61,39 @@ func varEmbed(p *noder, names []ir.Node, typ ir.Ntype, exprs []ir.Node, embeds [
 		p.errorAt(pos, "go:embed cannot apply to var without type")
 		return exprs
 	}
+	if dclcontext != ir.PEXTERN {
+		p.errorAt(pos, "go:embed cannot apply to var inside func")
+		return exprs
+	}
+
+	v := names[0].(*ir.Name)
+	Target.Embeds = append(Target.Embeds, v)
+	v.Embed = new([]ir.Embed)
+	for _, e := range embeds {
+		*v.Embed = append(*v.Embed, ir.Embed{Pos: p.makeXPos(e.Pos), Patterns: e.Patterns})
+	}
+	return exprs
+}
 
-	kind := embedKindApprox(typ)
+func embedFileList(v *ir.Name) []string {
+	kind := embedKind(v.Type())
 	if kind == embedUnknown {
-		p.errorAt(pos, "go:embed cannot apply to var of type %v", typ)
-		return exprs
+		base.ErrorfAt(v.Pos(), "go:embed cannot apply to var of type %v", v.Type())
+		return nil
 	}
 
 	// Build list of files to store.
 	have := make(map[string]bool)
 	var list []string
-	for _, e := range embeds {
+	for _, e := range *v.Embed {
 		for _, pattern := range e.Patterns {
 			files, ok := base.Flag.Cfg.Embed.Patterns[pattern]
 			if !ok {
-				p.errorAt(e.Pos, "invalid go:embed: build system did not map pattern: %s", pattern)
+				base.ErrorfAt(e.Pos, "invalid go:embed: build system did not map pattern: %s", pattern)
 			}
 			for _, file := range files {
 				if base.Flag.Cfg.Embed.Files[file] == "" {
-					p.errorAt(e.Pos, "invalid go:embed: build system did not map file: %s", file)
+					base.ErrorfAt(e.Pos, "invalid go:embed: build system did not map file: %s", file)
 					continue
 				}
 				if !have[file] {
@@ -103,25 +115,12 @@ func varEmbed(p *noder, names []ir.Node, typ ir.Ntype, exprs []ir.Node, embeds [
 
 	if kind == embedString || kind == embedBytes {
 		if len(list) > 1 {
-			p.errorAt(pos, "invalid go:embed: multiple files for type %v", typ)
-			return exprs
+			base.ErrorfAt(v.Pos(), "invalid go:embed: multiple files for type %v", v.Type())
+			return nil
 		}
 	}
 
-	v := names[0].(*ir.Name)
-	if dclcontext != ir.PEXTERN {
-		numLocalEmbed++
-		v = ir.NewNameAt(v.Pos(), lookupN("embed.", numLocalEmbed))
-		v.Sym().Def = v
-		v.Name().Ntype = typ
-		v.SetClass(ir.PEXTERN)
-		Target.Externs = append(Target.Externs, v)
-		exprs = []ir.Node{v}
-	}
-
-	v.Name().SetEmbedFiles(list)
-	Target.Embeds = append(Target.Embeds, v)
-	return exprs
+	return list
 }
 
 // embedKindApprox determines the kind of embedding variable, approximately.
@@ -192,8 +191,8 @@ func dumpembeds() {
 
 // initEmbed emits the init data for a //go:embed variable,
 // which is either a string, a []byte, or an embed.FS.
-func initEmbed(v ir.Node) {
-	files := v.Name().EmbedFiles()
+func initEmbed(v *ir.Name) {
+	files := embedFileList(v)
 	switch kind := embedKind(v.Type()); kind {
 	case embedUnknown:
 		base.ErrorfAt(v.Pos(), "go:embed cannot apply to var of type %v", v.Type())
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index b092e6933c..1707e6a11b 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -116,13 +116,14 @@ var (
 	okforadd   [types.NTYPE]bool
 	okforand   [types.NTYPE]bool
 	okfornone  [types.NTYPE]bool
-	okforcmp   [types.NTYPE]bool
 	okforbool  [types.NTYPE]bool
 	okforcap   [types.NTYPE]bool
 	okforlen   [types.NTYPE]bool
 	okforarith [types.NTYPE]bool
 )
 
+var okforcmp [types.NTYPE]bool
+
 var (
 	okfor [ir.OEND][]bool
 	iscmp [ir.OEND]bool
@@ -149,9 +150,6 @@ var typecheckok bool
 // when the race detector is enabled.
 var instrumenting bool
 
-// Whether we are tracking lexical scopes for DWARF.
-var trackScopes bool
-
 var nodfp *ir.Name
 
 var autogeneratedPos src.XPos
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 545491daa1..45880c5cde 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -205,8 +205,6 @@ func Main(archInit func(*Arch)) {
 		}
 	}
 
-	trackScopes = base.Flag.Dwarf
-
 	Widthptr = thearch.LinkArch.PtrSize
 	Widthreg = thearch.LinkArch.RegSize
 
@@ -226,6 +224,7 @@ func Main(archInit func(*Arch)) {
 
 	timings.Start("fe", "parse")
 	lines := parseFiles(flag.Args())
+	cgoSymABIs()
 	timings.Stop()
 	timings.AddEvent(int64(lines), "lines")
 
@@ -477,6 +476,20 @@ func Main(archInit func(*Arch)) {
 	}
 }
 
+func cgoSymABIs() {
+	// The linker expects an ABI0 wrapper for all cgo-exported
+	// functions.
+	for _, prag := range Target.CgoPragmas {
+		switch prag[0] {
+		case "cgo_export_static", "cgo_export_dynamic":
+			if symabiRefs == nil {
+				symabiRefs = make(map[string]obj.ABI)
+			}
+			symabiRefs[prag[1]] = obj.ABI0
+		}
+	}
+}
+
 // numNonClosures returns the number of functions in list which are not closures.
 func numNonClosures(list []*ir.Func) int {
 	count := 0
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 10eac6e815..ee01423833 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -20,7 +20,6 @@ import (
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/syntax"
 	"cmd/compile/internal/types"
-	"cmd/internal/obj"
 	"cmd/internal/objabi"
 	"cmd/internal/src"
 )
@@ -36,8 +35,9 @@ func parseFiles(filenames []string) uint {
 
 	for _, filename := range filenames {
 		p := &noder{
-			basemap: make(map[*syntax.PosBase]*src.PosBase),
-			err:     make(chan syntax.Error),
+			basemap:     make(map[*syntax.PosBase]*src.PosBase),
+			err:         make(chan syntax.Error),
+			trackScopes: base.Flag.Dwarf,
 		}
 		noders = append(noders, p)
 
@@ -151,7 +151,8 @@ type noder struct {
 
 	// scopeVars is a stack tracking the number of variables declared in the
 	// current function at the moment each open scope was opened.
-	scopeVars []int
+	trackScopes bool
+	scopeVars   []int
 
 	lastCloseScopePos syntax.Pos
 }
@@ -179,7 +180,7 @@ func (p *noder) funcBody(fn *ir.Func, block *syntax.BlockStmt) {
 func (p *noder) openScope(pos syntax.Pos) {
 	types.Markdcl()
 
-	if trackScopes {
+	if p.trackScopes {
 		Curfn.Parents = append(Curfn.Parents, p.scope)
 		p.scopeVars = append(p.scopeVars, len(Curfn.Dcl))
 		p.scope = ir.ScopeID(len(Curfn.Parents))
@@ -192,7 +193,7 @@ func (p *noder) closeScope(pos syntax.Pos) {
 	p.lastCloseScopePos = pos
 	types.Popdcl()
 
-	if trackScopes {
+	if p.trackScopes {
 		scopeVars := p.scopeVars[len(p.scopeVars)-1]
 		p.scopeVars = p.scopeVars[:len(p.scopeVars)-1]
 		if scopeVars == len(Curfn.Dcl) {
@@ -284,19 +285,6 @@ func (p *noder) processPragmas() {
 		}
 		n.Sym().Linkname = l.remote
 	}
-
-	// The linker expects an ABI0 wrapper for all cgo-exported
-	// functions.
-	for _, prag := range p.pragcgobuf {
-		switch prag[0] {
-		case "cgo_export_static", "cgo_export_dynamic":
-			if symabiRefs == nil {
-				symabiRefs = make(map[string]obj.ABI)
-			}
-			symabiRefs[prag[1]] = obj.ABI0
-		}
-	}
-
 	Target.CgoPragmas = append(Target.CgoPragmas, p.pragcgobuf...)
 }
 
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 0c36ffdf7a..f5f4280fd0 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -34,16 +34,16 @@ func (*Ident) CanBeNtype() {}
 // Name holds Node fields used only by named nodes (ONAME, OTYPE, some OLITERAL).
 type Name struct {
 	miniExpr
-	BuiltinOp  Op    // uint8
-	Class_     Class // uint8
-	flags      bitset16
-	pragma     PragmaFlag // int16
-	sym        *types.Sym
-	fn         *Func
-	Offset_    int64
-	val        constant.Value
-	orig       Node
-	embedFiles *[]string // list of embedded files, for ONAME var
+	BuiltinOp Op    // uint8
+	Class_    Class // uint8
+	flags     bitset16
+	pragma    PragmaFlag // int16
+	sym       *types.Sym
+	fn        *Func
+	Offset_   int64
+	val       constant.Value
+	orig      Node
+	Embed     *[]Embed // list of embedded files, for ONAME var
 
 	PkgName *PkgName // real package for import . names
 	// For a local variable (not param) or extern, the initializing assignment (OAS or OAS2).
@@ -139,14 +139,14 @@ type Name struct {
 	Outer     *Name
 }
 
+func (n *Name) isExpr() {}
+
 // CloneName makes a cloned copy of the name.
 // It's not ir.Copy(n) because in general that operation is a mistake on names,
 // which uniquely identify variables.
 // Callers must use n.CloneName to make clear they intend to create a separate name.
 func (n *Name) CloneName() *Name { c := *n; return &c }
 
-func (n *Name) isExpr() {}
-
 // NewNameAt returns a new ONAME Node associated with symbol s at position pos.
 // The caller is responsible for setting Curfn.
 func NewNameAt(pos src.XPos, sym *types.Sym) *Name {
@@ -231,27 +231,6 @@ func (n *Name) Alias() bool { return n.flags&nameAlias != 0 }
 // SetAlias sets whether p, which must be for an OTYPE, is a type alias.
 func (n *Name) SetAlias(alias bool) { n.flags.set(nameAlias, alias) }
 
-// EmbedFiles returns the list of embedded files for p,
-// which must be for an ONAME var.
-func (n *Name) EmbedFiles() []string {
-	if n.embedFiles == nil {
-		return nil
-	}
-	return *n.embedFiles
-}
-
-// SetEmbedFiles sets the list of embedded files for p,
-// which must be for an ONAME var.
-func (n *Name) SetEmbedFiles(list []string) {
-	if n.embedFiles == nil && list == nil {
-		return
-	}
-	if n.embedFiles == nil {
-		n.embedFiles = new([]string)
-	}
-	*n.embedFiles = list
-}
-
 const (
 	nameCaptured = 1 << iota // is the variable captured by a closure
 	nameReadonly
@@ -389,6 +368,11 @@ const (
 	_ = uint((1 << 3) - iota) // static assert for iota <= (1 << 3)
 )
 
+type Embed struct {
+	Pos      src.XPos
+	Patterns []string
+}
+
 // A Pack is an identifier referring to an imported package.
 type PkgName struct {
 	miniNode
diff --git a/src/embed/internal/embedtest/embed_test.go b/src/embed/internal/embedtest/embed_test.go
index c6a7bea7a3..04c23172c2 100644
--- a/src/embed/internal/embedtest/embed_test.go
+++ b/src/embed/internal/embedtest/embed_test.go
@@ -73,24 +73,14 @@ func TestGlobal(t *testing.T) {
 	testString(t, string(glass), "glass", "I can eat glass and it doesn't hurt me.\n")
 }
 
-func TestLocal(t *testing.T) {
-	//go:embed testdata/k*.txt
-	var local embed.FS
-	testFiles(t, local, "testdata/ken.txt", "If a program is too slow, it must have a loop.\n")
-
-	//go:embed testdata/k*.txt
-	var s string
-	testString(t, s, "local variable s", "If a program is too slow, it must have a loop.\n")
-
-	//go:embed testdata/h*.txt
-	var b []byte
-	testString(t, string(b), "local variable b", "hello, world\n")
-}
+//go:embed testdata
+var dir embed.FS
 
-func TestDir(t *testing.T) {
-	//go:embed testdata
-	var all embed.FS
+//go:embed testdata/*
+var star embed.FS
 
+func TestDir(t *testing.T) {
+	all := dir
 	testFiles(t, all, "testdata/hello.txt", "hello, world\n")
 	testFiles(t, all, "testdata/i/i18n.txt", "internationalization\n")
 	testFiles(t, all, "testdata/i/j/k/k8s.txt", "kubernetes\n")
@@ -103,12 +93,6 @@ func TestDir(t *testing.T) {
 }
 
 func TestHidden(t *testing.T) {
-	//go:embed testdata
-	var dir embed.FS
-
-	//go:embed testdata/*
-	var star embed.FS
-
 	t.Logf("//go:embed testdata")
 
 	testDir(t, dir, "testdata",
diff --git a/src/embed/internal/embedtest/embedx_test.go b/src/embed/internal/embedtest/embedx_test.go
index 20d5a28c11..27fa11614e 100644
--- a/src/embed/internal/embedtest/embedx_test.go
+++ b/src/embed/internal/embedtest/embedx_test.go
@@ -90,17 +90,3 @@ func TestXGlobal(t *testing.T) {
 	}
 	bbig[0] = old
 }
-
-func TestXLocal(t *testing.T) {
-	//go:embed testdata/*o.txt
-	var local embed.FS
-	testFiles(t, local, "testdata/hello.txt", "hello, world\n")
-
-	//go:embed testdata/k*.txt
-	var s string
-	testString(t, s, "local variable s", "If a program is too slow, it must have a loop.\n")
-
-	//go:embed testdata/h*.txt
-	var b []byte
-	testString(t, string(b), "local variable b", "hello, world\n")
-}
-- 
GitLab


From e999c1702250222b069691491d24dd5d020744de Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 21 Dec 2020 01:44:49 -0500
Subject: [PATCH 0272/2400] [dev.regabi] cmd/compile: separate ssa from other
 phases

isIntrinsicCall and ssaDumpInline are the only two "forward references"
to ssa by earlier phases. Make them a bit more explicit so that the
uses and the definitions can end up in different packages.

Change-Id: I02c7a27464fbedef9fee43c0e4094fa08b4d7a5c
Reviewed-on: https://go-review.googlesource.com/c/go/+/279300
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/inl.go   | 15 ++++++++++-----
 src/cmd/compile/internal/gc/main.go  |  3 +++
 src/cmd/compile/internal/gc/plive.go |  8 ++++----
 src/cmd/compile/internal/gc/ssa.go   | 14 ++++++++++----
 src/cmd/compile/internal/gc/walk.go  |  2 +-
 5 files changed, 28 insertions(+), 14 deletions(-)

diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 6c8f380d87..15df2584f0 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -39,6 +39,9 @@ import (
 	"strings"
 )
 
+// IsIntrinsicCall reports whether the compiler back end will treat the call as an intrinsic operation.
+var IsIntrinsicCall = func(*ir.CallExpr) bool { return false }
+
 // Inlining budget parameters, gathered in one place
 const (
 	inlineMaxBudget       = 80
@@ -339,7 +342,7 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 			}
 		}
 
-		if isIntrinsicCall(n) {
+		if IsIntrinsicCall(n) {
 			// Treat like any other node.
 			break
 		}
@@ -593,7 +596,7 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.No
 		if base.Flag.LowerM > 3 {
 			fmt.Printf("%v:call to func %+v\n", ir.Line(n), call.Left())
 		}
-		if isIntrinsicCall(call) {
+		if IsIntrinsicCall(call) {
 			break
 		}
 		if fn := inlCallee(call.Left()); fn != nil && fn.Inl != nil {
@@ -768,6 +771,10 @@ func inlParam(t *types.Field, as ir.Node, inlvars map[*ir.Name]ir.Node) ir.Node
 
 var inlgen int
 
+// SSADumpInline gives the SSA back end a chance to dump the function
+// when producing output for debugging the compiler itself.
+var SSADumpInline = func(*ir.Func) {}
+
 // If n is a call node (OCALLFUNC or OCALLMETH), and fn is an ONAME node for a
 // function with an inlinable body, return an OINLCALL node that can replace n.
 // The returned node's Ninit has the parameter assignments, the Nbody is the
@@ -835,9 +842,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 		fmt.Printf("%v: Before inlining: %+v\n", ir.Line(n), n)
 	}
 
-	if ssaDump != "" && ssaDump == ir.FuncName(Curfn) {
-		ssaDumpInlined = append(ssaDumpInlined, fn)
-	}
+	SSADumpInline(fn)
 
 	ninit := n.Init()
 
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 45880c5cde..afb47cf15d 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -191,6 +191,9 @@ func Main(archInit func(*Arch)) {
 		logopt.LogJsonOption(base.Flag.JSON)
 	}
 
+	IsIntrinsicCall = isIntrinsicCall
+	SSADumpInline = ssaDumpInline
+
 	ssaDump = os.Getenv("GOSSAFUNC")
 	ssaDir = os.Getenv("GOSSADIR")
 	if ssaDump != "" {
diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/gc/plive.go
index 8e266d6599..77cd9c5b19 100644
--- a/src/cmd/compile/internal/gc/plive.go
+++ b/src/cmd/compile/internal/gc/plive.go
@@ -1233,10 +1233,10 @@ func (lv *Liveness) emit() (argsSym, liveSym *obj.LSym) {
 // pointer variables in the function and emits a runtime data
 // structure read by the garbage collector.
 // Returns a map from GC safe points to their corresponding stack map index.
-func liveness(e *ssafn, f *ssa.Func, pp *Progs) LivenessMap {
+func liveness(curfn *ir.Func, f *ssa.Func, stkptrsize int64, pp *Progs) LivenessMap {
 	// Construct the global liveness state.
-	vars, idx := getvariables(e.curfn)
-	lv := newliveness(e.curfn, f, vars, idx, e.stkptrsize)
+	vars, idx := getvariables(curfn)
+	lv := newliveness(curfn, f, vars, idx, stkptrsize)
 
 	// Run the dataflow framework.
 	lv.prologue()
@@ -1271,7 +1271,7 @@ func liveness(e *ssafn, f *ssa.Func, pp *Progs) LivenessMap {
 	}
 
 	// Emit the live pointer map data structures
-	ls := e.curfn.LSym
+	ls := curfn.LSym
 	fninfo := ls.Func()
 	fninfo.GCArgs, fninfo.GCLocals = lv.emit()
 
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index fbfed0640d..4f4860869c 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -42,6 +42,12 @@ const maxOpenDefers = 8
 // ssaDumpInlined holds all inlined functions when ssaDump contains a function name.
 var ssaDumpInlined []*ir.Func
 
+func ssaDumpInline(fn *ir.Func) {
+	if ssaDump != "" && ssaDump == ir.FuncName(fn) {
+		ssaDumpInlined = append(ssaDumpInlined, fn)
+	}
+}
+
 func initssaconfig() {
 	types_ := ssa.NewTypes()
 
@@ -1135,7 +1141,7 @@ func (s *state) stmt(n ir.Node) {
 	// Expression statements
 	case ir.OCALLFUNC:
 		n := n.(*ir.CallExpr)
-		if isIntrinsicCall(n) {
+		if IsIntrinsicCall(n) {
 			s.intrinsicCall(n)
 			return
 		}
@@ -1204,7 +1210,7 @@ func (s *state) stmt(n ir.Node) {
 	case ir.OAS2FUNC:
 		// We come here only when it is an intrinsic call returning two values.
 		call := n.Rlist().First().(*ir.CallExpr)
-		if !isIntrinsicCall(call) {
+		if !IsIntrinsicCall(call) {
 			s.Fatalf("non-intrinsic AS2FUNC not expanded %v", call)
 		}
 		v := s.intrinsicCall(call)
@@ -2826,7 +2832,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 
 	case ir.OCALLFUNC:
 		n := n.(*ir.CallExpr)
-		if isIntrinsicCall(n) {
+		if IsIntrinsicCall(n) {
 			return s.intrinsicCall(n)
 		}
 		fallthrough
@@ -6375,7 +6381,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 
 	e := f.Frontend().(*ssafn)
 
-	s.livenessMap = liveness(e, f, pp)
+	s.livenessMap = liveness(e.curfn, f, e.stkptrsize, pp)
 	emitStackObjects(e, pp)
 
 	openDeferInfo := e.curfn.LSym.Func().OpenCodedDeferInfo
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 657a744e68..7651bbca10 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -769,7 +769,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		walkexprlistsafe(n.List().Slice(), init)
 		r = walkexpr(r, init)
 
-		if isIntrinsicCall(r.(*ir.CallExpr)) {
+		if IsIntrinsicCall(r.(*ir.CallExpr)) {
 			n.PtrRlist().Set1(r)
 			return n
 		}
-- 
GitLab


From 1a523c8ab08e95ddfb7c50e19ddd6c73bb45daf5 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 21 Dec 2020 01:56:46 -0500
Subject: [PATCH 0273/2400] [dev.regabi] cmd/compile: separate
 nowritebarrierrec from main

Main knows a bit too much about nowritebarrierrec.
Abstract the API a little bit to make the package split easier.

Change-Id: I4b76bdb1fed73dfb0d44e1a6c86de8c2d29a9488
Reviewed-on: https://go-review.googlesource.com/c/go/+/279301
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/dcl.go  | 13 ++++++++++++-
 src/cmd/compile/internal/gc/main.go | 12 ++++--------
 2 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 20e5edc4cb..64b15077cd 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -15,7 +15,18 @@ import (
 	"strings"
 )
 
-// Declaration stack & operations
+func EnableNoWriteBarrierRecCheck() {
+	nowritebarrierrecCheck = newNowritebarrierrecChecker()
+}
+
+func NoWriteBarrierRecCheck() {
+	// Write barriers are now known. Check the
+	// call graph.
+	nowritebarrierrecCheck.check()
+	nowritebarrierrecCheck = nil
+}
+
+var nowritebarrierrecCheck *nowritebarrierrecChecker
 
 func testdclstack() {
 	if !types.IsDclstackValid() {
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index afb47cf15d..7f7cd63cdf 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -57,8 +57,6 @@ var Target *ir.Package
 // timing data for compiler phases
 var timings Timings
 
-var nowritebarrierrecCheck *nowritebarrierrecChecker
-
 // Main parses flags and Go source files specified in the command-line
 // arguments, type-checks the parsed Go package, compiles functions to machine
 // code, and finally writes the compiled package definition to disk.
@@ -382,7 +380,7 @@ func Main(archInit func(*Arch)) {
 	// We'll do the final check after write barriers are
 	// inserted.
 	if base.Flag.CompilingRuntime {
-		nowritebarrierrecCheck = newNowritebarrierrecChecker()
+		EnableNoWriteBarrierRecCheck()
 	}
 
 	// Phase 7: Transform closure bodies to properly reference captured variables.
@@ -422,11 +420,9 @@ func Main(archInit func(*Arch)) {
 
 	compileFunctions()
 
-	if nowritebarrierrecCheck != nil {
-		// Write barriers are now known. Check the
-		// call graph.
-		nowritebarrierrecCheck.check()
-		nowritebarrierrecCheck = nil
+	if base.Flag.CompilingRuntime {
+		// Write barriers are now known. Check the call graph.
+		NoWriteBarrierRecCheck()
 	}
 
 	// Finalize DWARF inline routine DIEs, then explicitly turn off
-- 
GitLab


From 06915ac14dfb7c80f384e3446bc6fa474e6bfa94 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 19 Dec 2020 19:26:06 -0800
Subject: [PATCH 0274/2400] [dev.regabi] cmd/compile: move itabname call out of
 implements

We only need to call itabname when actually creating the OCONVIFACE
ops, not any time we test whether a type implements an
interface. Additionally, by moving this call out of implements, we
make it purely based on types, which makes it safe to move to package
types.

Does not pass toolstash -cmp, because it shuffles symbol creation
order.

Change-Id: Iea8e0c9374218f4d97b4339020ebd758d051bd03
Reviewed-on: https://go-review.googlesource.com/c/go/+/279333
Reviewed-by: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/subr.go | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 2b0047e150..48cbd2505e 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -304,6 +304,14 @@ func assignop(src, dst *types.Type) (ir.Op, string) {
 		var missing, have *types.Field
 		var ptr int
 		if implements(src, dst, &missing, &have, &ptr) {
+			// Call itabname so that (src, dst)
+			// gets added to itabs early, which allows
+			// us to de-virtualize calls through this
+			// type/interface pair later. See peekitabs in reflect.go
+			if isdirectiface(src) && !dst.IsEmptyInterface() {
+				itabname(src, dst)
+			}
+
 			return ir.OCONVIFACE, ""
 		}
 
@@ -1404,14 +1412,6 @@ func implements(t, iface *types.Type, m, samename **types.Field, ptr *int) bool
 		}
 	}
 
-	// We're going to emit an OCONVIFACE.
-	// Call itabname so that (t, iface)
-	// gets added to itabs early, which allows
-	// us to de-virtualize calls through this
-	// type/interface pair later. See peekitabs in reflect.go
-	if isdirectiface(t0) && !iface.IsEmptyInterface() {
-		itabname(t0, iface)
-	}
 	return true
 }
 
-- 
GitLab


From cb4898a77d79f457d75f601fad6908dd85bdc772 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 18 Dec 2020 19:38:13 -0800
Subject: [PATCH 0275/2400] [dev.regabi] cmd/compile: simplify declaration
 importing

Rather than creating Names w/ ONONAME earlier and later adding in the
details, this CL changes the import logic to create and add details at
the same time.

Passes buildall w/ toolstash -cmp.

Change-Id: Ifaabade3cef8cd80ddd6644bff79393b934255d9
Reviewed-on: https://go-review.googlesource.com/c/go/+/279313
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/gc/export.go    | 110 ++++++-----------------
 src/cmd/compile/internal/gc/iimport.go   |  62 +++++++------
 src/cmd/compile/internal/gc/typecheck.go |  13 +--
 3 files changed, 58 insertions(+), 127 deletions(-)

diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index d26dd9af5d..6ed4327a8f 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -77,126 +77,70 @@ func dumpexport(bout *bio.Writer) {
 	}
 }
 
-func importsym(ipkg *types.Pkg, s *types.Sym, op ir.Op) *ir.Name {
-	n := ir.AsNode(s.PkgDef())
-	if n == nil {
-		// iimport should have created a stub ONONAME
-		// declaration for all imported symbols. The exception
-		// is declarations for Runtimepkg, which are populated
-		// by loadsys instead.
-		if s.Pkg != Runtimepkg {
-			base.Fatalf("missing ONONAME for %v\n", s)
-		}
-
-		n = ir.NewDeclNameAt(src.NoXPos, s)
-		s.SetPkgDef(n)
-		s.Importdef = ipkg
-	}
-	if n.Op() != ir.ONONAME && n.Op() != op {
-		redeclare(base.Pos, s, fmt.Sprintf("during import %q", ipkg.Path))
+func importsym(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op ir.Op, ctxt ir.Class) *ir.Name {
+	if n := s.PkgDef(); n != nil {
+		base.Fatalf("importsym of symbol that already exists: %v", n)
 	}
-	return n.(*ir.Name)
+
+	n := ir.NewDeclNameAt(pos, s)
+	n.SetOp(op) // TODO(mdempsky): Add as argument to NewDeclNameAt.
+	n.SetClass(ctxt)
+	s.SetPkgDef(n)
+	s.Importdef = ipkg
+	return n
 }
 
 // importtype returns the named type declared by symbol s.
 // If no such type has been declared yet, a forward declaration is returned.
 // ipkg is the package being imported
-func importtype(ipkg *types.Pkg, pos src.XPos, s *types.Sym) *types.Type {
-	n := importsym(ipkg, s, ir.OTYPE)
-	if n.Op() != ir.OTYPE {
-		t := types.NewNamed(n)
-		n.SetOp(ir.OTYPE)
-		n.SetPos(pos)
-		n.SetType(t)
-		n.SetClass(ir.PEXTERN)
-	}
-
-	t := n.Type()
-	if t == nil {
-		base.Fatalf("importtype %v", s)
-	}
-	return t
+func importtype(ipkg *types.Pkg, pos src.XPos, s *types.Sym) *ir.Name {
+	n := importsym(ipkg, pos, s, ir.OTYPE, ir.PEXTERN)
+	n.SetType(types.NewNamed(n))
+	return n
 }
 
 // importobj declares symbol s as an imported object representable by op.
 // ipkg is the package being imported
-func importobj(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op ir.Op, ctxt ir.Class, t *types.Type) ir.Node {
-	n := importsym(ipkg, s, op)
-	if n.Op() != ir.ONONAME {
-		if n.Op() == op && (op == ir.ONAME && n.Class() != ctxt || !types.Identical(n.Type(), t)) {
-			redeclare(base.Pos, s, fmt.Sprintf("during import %q", ipkg.Path))
-		}
-		return nil
-	}
-
-	n.SetOp(op)
-	n.SetPos(pos)
-	n.SetClass(ctxt)
+func importobj(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op ir.Op, ctxt ir.Class, t *types.Type) *ir.Name {
+	n := importsym(ipkg, pos, s, op, ctxt)
+	n.SetType(t)
 	if ctxt == ir.PFUNC {
 		n.Sym().SetFunc(true)
 	}
-	n.SetType(t)
 	return n
 }
 
 // importconst declares symbol s as an imported constant with type t and value val.
 // ipkg is the package being imported
-func importconst(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type, val constant.Value) {
+func importconst(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type, val constant.Value) *ir.Name {
 	n := importobj(ipkg, pos, s, ir.OLITERAL, ir.PEXTERN, t)
-	if n == nil { // TODO: Check that value matches.
-		return
-	}
-
 	n.SetVal(val)
-
-	if base.Flag.E != 0 {
-		fmt.Printf("import const %v %L = %v\n", s, t, val)
-	}
+	return n
 }
 
 // importfunc declares symbol s as an imported function with type t.
 // ipkg is the package being imported
-func importfunc(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) {
+func importfunc(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) *ir.Name {
 	n := importobj(ipkg, pos, s, ir.ONAME, ir.PFUNC, t)
-	if n == nil {
-		return
-	}
-	name := n.(*ir.Name)
 
 	fn := ir.NewFunc(pos)
 	fn.SetType(t)
-	name.SetFunc(fn)
-	fn.Nname = name
+	n.SetFunc(fn)
+	fn.Nname = n
 
-	if base.Flag.E != 0 {
-		fmt.Printf("import func %v%S\n", s, t)
-	}
+	return n
 }
 
 // importvar declares symbol s as an imported variable with type t.
 // ipkg is the package being imported
-func importvar(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) {
-	n := importobj(ipkg, pos, s, ir.ONAME, ir.PEXTERN, t)
-	if n == nil {
-		return
-	}
-
-	if base.Flag.E != 0 {
-		fmt.Printf("import var %v %L\n", s, t)
-	}
+func importvar(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) *ir.Name {
+	return importobj(ipkg, pos, s, ir.ONAME, ir.PEXTERN, t)
 }
 
 // importalias declares symbol s as an imported type alias with type t.
 // ipkg is the package being imported
-func importalias(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) {
-	n := importobj(ipkg, pos, s, ir.OTYPE, ir.PEXTERN, t)
-	if n == nil {
-		return
-	}
-
-	if base.Flag.E != 0 {
-		fmt.Printf("import type %v = %L\n", s, t)
-	}
+func importalias(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) *ir.Name {
+	return importobj(ipkg, pos, s, ir.OTYPE, ir.PEXTERN, t)
 }
 
 func dumpasmhdr() {
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 549751335e..76f55a44e5 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -41,18 +41,23 @@ var (
 	inlineImporter = map[*types.Sym]iimporterAndOffset{}
 )
 
-func expandDecl(n *ir.Name) {
-	if n.Op() != ir.ONONAME {
-		return
+func expandDecl(n ir.Node) ir.Node {
+	if n, ok := n.(*ir.Name); ok {
+		return n
+	}
+
+	id := n.(*ir.Ident)
+	if n := id.Sym().PkgDef(); n != nil {
+		return n.(*ir.Name)
 	}
 
-	r := importReaderFor(n, declImporter)
+	r := importReaderFor(id.Sym(), declImporter)
 	if r == nil {
 		// Can happen if user tries to reference an undeclared name.
-		return
+		return n
 	}
 
-	r.doDecl(n)
+	return r.doDecl(n.Sym())
 }
 
 func expandInline(fn *ir.Func) {
@@ -60,7 +65,7 @@ func expandInline(fn *ir.Func) {
 		return
 	}
 
-	r := importReaderFor(fn.Nname, inlineImporter)
+	r := importReaderFor(fn.Nname.Sym(), inlineImporter)
 	if r == nil {
 		base.Fatalf("missing import reader for %v", fn)
 	}
@@ -68,13 +73,13 @@ func expandInline(fn *ir.Func) {
 	r.doInline(fn)
 }
 
-func importReaderFor(n *ir.Name, importers map[*types.Sym]iimporterAndOffset) *importReader {
-	x, ok := importers[n.Sym()]
+func importReaderFor(sym *types.Sym, importers map[*types.Sym]iimporterAndOffset) *importReader {
+	x, ok := importers[sym]
 	if !ok {
 		return nil
 	}
 
-	return x.p.newReader(x.off, n.Sym().Pkg)
+	return x.p.newReader(x.off, sym.Pkg)
 }
 
 type intReader struct {
@@ -272,11 +277,7 @@ func (r *importReader) setPkg() {
 	r.currPkg = r.pkg()
 }
 
-func (r *importReader) doDecl(n ir.Node) {
-	if n.Op() != ir.ONONAME {
-		base.Fatalf("doDecl: unexpected Op for %v: %v", n.Sym(), n.Op())
-	}
-
+func (r *importReader) doDecl(sym *types.Sym) *ir.Name {
 	tag := r.byte()
 	pos := r.pos()
 
@@ -284,24 +285,26 @@ func (r *importReader) doDecl(n ir.Node) {
 	case 'A':
 		typ := r.typ()
 
-		importalias(r.p.ipkg, pos, n.Sym(), typ)
+		return importalias(r.p.ipkg, pos, sym, typ)
 
 	case 'C':
 		typ := r.typ()
 		val := r.value(typ)
 
-		importconst(r.p.ipkg, pos, n.Sym(), typ, val)
+		return importconst(r.p.ipkg, pos, sym, typ, val)
 
 	case 'F':
 		typ := r.signature(nil)
 
-		importfunc(r.p.ipkg, pos, n.Sym(), typ)
+		n := importfunc(r.p.ipkg, pos, sym, typ)
 		r.funcExt(n)
+		return n
 
 	case 'T':
 		// Types can be recursive. We need to setup a stub
 		// declaration before recursing.
-		t := importtype(r.p.ipkg, pos, n.Sym())
+		n := importtype(r.p.ipkg, pos, sym)
+		t := n.Type()
 
 		// We also need to defer width calculations until
 		// after the underlying type has been assigned.
@@ -312,7 +315,7 @@ func (r *importReader) doDecl(n ir.Node) {
 
 		if underlying.IsInterface() {
 			r.typeExt(t)
-			break
+			return n
 		}
 
 		ms := make([]*types.Field, r.uint64())
@@ -339,15 +342,18 @@ func (r *importReader) doDecl(n ir.Node) {
 		for _, m := range ms {
 			r.methExt(m)
 		}
+		return n
 
 	case 'V':
 		typ := r.typ()
 
-		importvar(r.p.ipkg, pos, n.Sym(), typ)
+		n := importvar(r.p.ipkg, pos, sym, typ)
 		r.varExt(n)
+		return n
 
 	default:
 		base.Fatalf("unexpected tag: %v", tag)
+		panic("unreachable")
 	}
 }
 
@@ -433,16 +439,11 @@ func (r *importReader) ident() *types.Sym {
 	return pkg.Lookup(name)
 }
 
-func (r *importReader) qualifiedIdent() *ir.Name {
+func (r *importReader) qualifiedIdent() *ir.Ident {
 	name := r.string()
 	pkg := r.pkg()
 	sym := pkg.Lookup(name)
-	n := sym.PkgDef()
-	if n == nil {
-		n = ir.NewDeclNameAt(src.NoXPos, sym)
-		sym.SetPkgDef(n)
-	}
-	return n.(*ir.Name)
+	return ir.NewIdent(src.NoXPos, sym)
 }
 
 func (r *importReader) pos() src.XPos {
@@ -498,10 +499,7 @@ func (r *importReader) typ1() *types.Type {
 		// support inlining functions with local defined
 		// types. Therefore, this must be a package-scope
 		// type.
-		n := r.qualifiedIdent()
-		if n.Op() == ir.ONONAME {
-			expandDecl(n)
-		}
+		n := expandDecl(r.qualifiedIdent())
 		if n.Op() != ir.OTYPE {
 			base.Fatalf("expected OTYPE, got %v: %v, %v", n.Op(), n.Sym(), n)
 		}
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 83939fd6bf..4fae4a0819 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -8,7 +8,6 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
-	"cmd/internal/src"
 	"fmt"
 	"go/constant"
 	"go/token"
@@ -97,23 +96,13 @@ func resolve(n ir.Node) (res ir.Node) {
 			if pkgName := dotImportRefs[id]; pkgName != nil {
 				pkgName.Used = true
 			}
-
-			if sym.Def == nil {
-				if _, ok := declImporter[sym]; !ok {
-					return n // undeclared name
-				}
-				sym.Def = ir.NewDeclNameAt(src.NoXPos, sym)
-			}
-			n = ir.AsNode(sym.Def)
 		}
 
-		// Stub ir.Name left for us by iimport.
-		n := n.(*ir.Name)
 		if inimport {
 			base.Fatalf("recursive inimport")
 		}
 		inimport = true
-		expandDecl(n)
+		n = expandDecl(n)
 		inimport = false
 		return n
 	}
-- 
GitLab


From 94cfeca0a5b36a70a8bdd1a0015eb78c7e9a3311 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 18 Dec 2020 20:14:45 -0800
Subject: [PATCH 0276/2400] [dev.regabi] cmd/compile: stop using ONONAME with
 Name

This CL changes NewDeclNameAt to take an Op argument to set the Op up
front, and updates all callers to provide the appropriate Op. This
allows dropping the Name.SetOp method.

Passes buildall w/ toolstash -cmp.

Change-Id: I20e580f62d3c8a81223d1c162327c11b37bbf3f0
Reviewed-on: https://go-review.googlesource.com/c/go/+/279314
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/gc/dcl.go      |  2 --
 src/cmd/compile/internal/gc/export.go   |  5 ++---
 src/cmd/compile/internal/gc/iimport.go  |  2 +-
 src/cmd/compile/internal/gc/noder.go    | 17 +++++++----------
 src/cmd/compile/internal/gc/universe.go |  6 ++----
 src/cmd/compile/internal/ir/name.go     | 24 +++++++++---------------
 6 files changed, 21 insertions(+), 35 deletions(-)

diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 64b15077cd..04e3506dba 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -141,7 +141,6 @@ func variter(vl []ir.Node, t ir.Ntype, el []ir.Node) []ir.Node {
 		as2.PtrRlist().Set1(e)
 		for _, v := range vl {
 			v := v.(*ir.Name)
-			v.SetOp(ir.ONAME)
 			declare(v, dclcontext)
 			v.Ntype = t
 			v.Defn = as2
@@ -166,7 +165,6 @@ func variter(vl []ir.Node, t ir.Ntype, el []ir.Node) []ir.Node {
 			el = el[1:]
 		}
 
-		v.SetOp(ir.ONAME)
 		declare(v, dclcontext)
 		v.Ntype = t
 
diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index 6ed4327a8f..8a8295537c 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -82,9 +82,8 @@ func importsym(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op ir.Op, ctxt ir.Cl
 		base.Fatalf("importsym of symbol that already exists: %v", n)
 	}
 
-	n := ir.NewDeclNameAt(pos, s)
-	n.SetOp(op) // TODO(mdempsky): Add as argument to NewDeclNameAt.
-	n.SetClass(ctxt)
+	n := ir.NewDeclNameAt(pos, op, s)
+	n.SetClass(ctxt) // TODO(mdempsky): Move this into NewDeclNameAt too?
 	s.SetPkgDef(n)
 	s.Importdef = ipkg
 	return n
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 76f55a44e5..219ce4bdef 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -971,7 +971,7 @@ func (r *importReader) node() ir.Node {
 	// statements
 	case ir.ODCL:
 		pos := r.pos()
-		lhs := ir.NewDeclNameAt(pos, r.ident())
+		lhs := ir.NewDeclNameAt(pos, ir.ONAME, r.ident())
 		typ := ir.TypeNode(r.typ())
 		return npos(pos, liststmt(variter([]ir.Node{lhs}, typ, nil))) // TODO(gri) avoid list creation
 
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index ee01423833..b61f19ae2e 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -374,7 +374,7 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
 }
 
 func (p *noder) varDecl(decl *syntax.VarDecl) []ir.Node {
-	names := p.declNames(decl.NameList)
+	names := p.declNames(ir.ONAME, decl.NameList)
 	typ := p.typeExprOrNil(decl.Type)
 
 	var exprs []ir.Node
@@ -425,7 +425,7 @@ func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []ir.Node {
 		p.checkUnused(pragma)
 	}
 
-	names := p.declNames(decl.NameList)
+	names := p.declNames(ir.OLITERAL, decl.NameList)
 	typ := p.typeExprOrNil(decl.Type)
 
 	var values []ir.Node
@@ -450,8 +450,6 @@ func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []ir.Node {
 		if decl.Values == nil {
 			v = ir.DeepCopy(n.Pos(), v)
 		}
-
-		n.SetOp(ir.OLITERAL)
 		declare(n, dclcontext)
 
 		n.Ntype = typ
@@ -471,8 +469,7 @@ func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []ir.Node {
 }
 
 func (p *noder) typeDecl(decl *syntax.TypeDecl) ir.Node {
-	n := p.declName(decl.Name)
-	n.SetOp(ir.OTYPE)
+	n := p.declName(ir.OTYPE, decl.Name)
 	declare(n, dclcontext)
 
 	// decl.Type may be nil but in that case we got a syntax error during parsing
@@ -495,16 +492,16 @@ func (p *noder) typeDecl(decl *syntax.TypeDecl) ir.Node {
 	return nod
 }
 
-func (p *noder) declNames(names []*syntax.Name) []ir.Node {
+func (p *noder) declNames(op ir.Op, names []*syntax.Name) []ir.Node {
 	nodes := make([]ir.Node, 0, len(names))
 	for _, name := range names {
-		nodes = append(nodes, p.declName(name))
+		nodes = append(nodes, p.declName(op, name))
 	}
 	return nodes
 }
 
-func (p *noder) declName(name *syntax.Name) *ir.Name {
-	return ir.NewDeclNameAt(p.pos(name), p.name(name))
+func (p *noder) declName(op ir.Op, name *syntax.Name) *ir.Name {
+	return ir.NewDeclNameAt(p.pos(name), op, p.name(name))
 }
 
 func (p *noder) funcDecl(fun *syntax.FuncDecl) ir.Node {
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index 21ddc78089..c988c575dc 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -97,8 +97,7 @@ func initUniverse() {
 
 	defBasic := func(kind types.Kind, pkg *types.Pkg, name string) *types.Type {
 		sym := pkg.Lookup(name)
-		n := ir.NewDeclNameAt(src.NoXPos, sym)
-		n.SetOp(ir.OTYPE)
+		n := ir.NewDeclNameAt(src.NoXPos, ir.OTYPE, sym)
 		t := types.NewBasic(kind, n)
 		n.SetType(t)
 		sym.Def = n
@@ -134,8 +133,7 @@ func initUniverse() {
 
 	// error type
 	s := types.BuiltinPkg.Lookup("error")
-	n := ir.NewDeclNameAt(src.NoXPos, s)
-	n.SetOp(ir.OTYPE)
+	n := ir.NewDeclNameAt(src.NoXPos, ir.OTYPE, s)
 	types.ErrorType = types.NewNamed(n)
 	types.ErrorType.SetUnderlying(makeErrorInterface())
 	n.SetType(types.ErrorType)
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index f5f4280fd0..9cf959b23d 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -164,13 +164,19 @@ func NewIota(pos src.XPos, sym *types.Sym) *Name {
 	return newNameAt(pos, OIOTA, sym)
 }
 
-// NewDeclNameAt returns a new ONONAME Node associated with symbol s at position pos.
+// NewDeclNameAt returns a new Name associated with symbol s at position pos.
 // The caller is responsible for setting Curfn.
-func NewDeclNameAt(pos src.XPos, sym *types.Sym) *Name {
+func NewDeclNameAt(pos src.XPos, op Op, sym *types.Sym) *Name {
 	if sym == nil {
 		base.Fatalf("NewDeclNameAt nil")
 	}
-	return newNameAt(pos, ONONAME, sym)
+	switch op {
+	case ONAME, OTYPE, OLITERAL:
+		// ok
+	default:
+		base.Fatalf("NewDeclNameAt op %v", op)
+	}
+	return newNameAt(pos, op, sym)
 }
 
 // newNameAt is like NewNameAt but allows sym == nil.
@@ -207,18 +213,6 @@ func (*Name) CanBeNtype()    {}
 func (*Name) CanBeAnSSASym() {}
 func (*Name) CanBeAnSSAAux() {}
 
-func (n *Name) SetOp(op Op) {
-	if n.op != ONONAME {
-		base.Fatalf("%v already has Op %v", n, n.op)
-	}
-	switch op {
-	default:
-		panic(n.no("SetOp " + op.String()))
-	case OLITERAL, ONAME, OTYPE, OIOTA:
-		n.op = op
-	}
-}
-
 // Pragma returns the PragmaFlag for p, which must be for an OTYPE.
 func (n *Name) Pragma() PragmaFlag { return n.pragma }
 
-- 
GitLab


From 306b2451c849c9a5835069f317dfea851e526a00 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Mon, 14 Dec 2020 10:03:37 -0500
Subject: [PATCH 0277/2400] [dev.regabi] runtime: fix ABI targets in
 runtime.panic{Index,Slice} shims
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fix up the assembly shim routines runtime.panic{Index,Slice} and
friends so that their tail calls target ABIInternal and not ABI0
functions. This is so as to ensure that these calls don't go through
an ABI0->ABIInternal wrapper (which would throw off the machinery in
the called routines designed to detect whether the violation happened
in the runtime).

Note that when the compiler starts emitting real register calls to
these routines, we'll need to rewrite them to update the arg size and
ensure that args are in the correct registers. For example, the
current shim

TEXT runtime·panicIndex<ABIInternal>(SB),NOSPLIT,$0-16
	MOVQ	AX, x+0(FP)
	MOVQ	CX, y+8(FP)
	JMP	runtime·goPanicIndex<ABIInternal>(SB)

will need to change to

TEXT runtime·panicIndex<ABIInternal>(SB),NOSPLIT,$0
	// AX already set up properly
	MOVQ	CX, BX // second argument expected in BX
	JMP	runtime·goPanicIndex<ABIInternal>(SB)

Change-Id: I48d1b5138fb4d229380ad12735cfaca5c50e6cc3
Reviewed-on: https://go-review.googlesource.com/c/go/+/278755
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: Than McIntosh <thanm@google.com>
---
 src/runtime/asm_amd64.s | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index 196252e1dd..53d1f8e358 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -1728,67 +1728,67 @@ TEXT runtime·debugCallPanicked(SB),NOSPLIT,$16-16
 TEXT runtime·panicIndex<ABIInternal>(SB),NOSPLIT,$0-16
 	MOVQ	AX, x+0(FP)
 	MOVQ	CX, y+8(FP)
-	JMP	runtime·goPanicIndex(SB)
+	JMP	runtime·goPanicIndex<ABIInternal>(SB)
 TEXT runtime·panicIndexU<ABIInternal>(SB),NOSPLIT,$0-16
 	MOVQ	AX, x+0(FP)
 	MOVQ	CX, y+8(FP)
-	JMP	runtime·goPanicIndexU(SB)
+	JMP	runtime·goPanicIndexU<ABIInternal>(SB)
 TEXT runtime·panicSliceAlen<ABIInternal>(SB),NOSPLIT,$0-16
 	MOVQ	CX, x+0(FP)
 	MOVQ	DX, y+8(FP)
-	JMP	runtime·goPanicSliceAlen(SB)
+	JMP	runtime·goPanicSliceAlen<ABIInternal>(SB)
 TEXT runtime·panicSliceAlenU<ABIInternal>(SB),NOSPLIT,$0-16
 	MOVQ	CX, x+0(FP)
 	MOVQ	DX, y+8(FP)
-	JMP	runtime·goPanicSliceAlenU(SB)
+	JMP	runtime·goPanicSliceAlenU<ABIInternal>(SB)
 TEXT runtime·panicSliceAcap<ABIInternal>(SB),NOSPLIT,$0-16
 	MOVQ	CX, x+0(FP)
 	MOVQ	DX, y+8(FP)
-	JMP	runtime·goPanicSliceAcap(SB)
+	JMP	runtime·goPanicSliceAcap<ABIInternal>(SB)
 TEXT runtime·panicSliceAcapU<ABIInternal>(SB),NOSPLIT,$0-16
 	MOVQ	CX, x+0(FP)
 	MOVQ	DX, y+8(FP)
-	JMP	runtime·goPanicSliceAcapU(SB)
+	JMP	runtime·goPanicSliceAcapU<ABIInternal>(SB)
 TEXT runtime·panicSliceB<ABIInternal>(SB),NOSPLIT,$0-16
 	MOVQ	AX, x+0(FP)
 	MOVQ	CX, y+8(FP)
-	JMP	runtime·goPanicSliceB(SB)
+	JMP	runtime·goPanicSliceB<ABIInternal>(SB)
 TEXT runtime·panicSliceBU<ABIInternal>(SB),NOSPLIT,$0-16
 	MOVQ	AX, x+0(FP)
 	MOVQ	CX, y+8(FP)
-	JMP	runtime·goPanicSliceBU(SB)
+	JMP	runtime·goPanicSliceBU<ABIInternal>(SB)
 TEXT runtime·panicSlice3Alen<ABIInternal>(SB),NOSPLIT,$0-16
 	MOVQ	DX, x+0(FP)
 	MOVQ	BX, y+8(FP)
-	JMP	runtime·goPanicSlice3Alen(SB)
+	JMP	runtime·goPanicSlice3Alen<ABIInternal>(SB)
 TEXT runtime·panicSlice3AlenU<ABIInternal>(SB),NOSPLIT,$0-16
 	MOVQ	DX, x+0(FP)
 	MOVQ	BX, y+8(FP)
-	JMP	runtime·goPanicSlice3AlenU(SB)
+	JMP	runtime·goPanicSlice3AlenU<ABIInternal>(SB)
 TEXT runtime·panicSlice3Acap<ABIInternal>(SB),NOSPLIT,$0-16
 	MOVQ	DX, x+0(FP)
 	MOVQ	BX, y+8(FP)
-	JMP	runtime·goPanicSlice3Acap(SB)
+	JMP	runtime·goPanicSlice3Acap<ABIInternal>(SB)
 TEXT runtime·panicSlice3AcapU<ABIInternal>(SB),NOSPLIT,$0-16
 	MOVQ	DX, x+0(FP)
 	MOVQ	BX, y+8(FP)
-	JMP	runtime·goPanicSlice3AcapU(SB)
+	JMP	runtime·goPanicSlice3AcapU<ABIInternal>(SB)
 TEXT runtime·panicSlice3B<ABIInternal>(SB),NOSPLIT,$0-16
 	MOVQ	CX, x+0(FP)
 	MOVQ	DX, y+8(FP)
-	JMP	runtime·goPanicSlice3B(SB)
+	JMP	runtime·goPanicSlice3B<ABIInternal>(SB)
 TEXT runtime·panicSlice3BU<ABIInternal>(SB),NOSPLIT,$0-16
 	MOVQ	CX, x+0(FP)
 	MOVQ	DX, y+8(FP)
-	JMP	runtime·goPanicSlice3BU(SB)
+	JMP	runtime·goPanicSlice3BU<ABIInternal>(SB)
 TEXT runtime·panicSlice3C<ABIInternal>(SB),NOSPLIT,$0-16
 	MOVQ	AX, x+0(FP)
 	MOVQ	CX, y+8(FP)
-	JMP	runtime·goPanicSlice3C(SB)
+	JMP	runtime·goPanicSlice3C<ABIInternal>(SB)
 TEXT runtime·panicSlice3CU<ABIInternal>(SB),NOSPLIT,$0-16
 	MOVQ	AX, x+0(FP)
 	MOVQ	CX, y+8(FP)
-	JMP	runtime·goPanicSlice3CU(SB)
+	JMP	runtime·goPanicSlice3CU<ABIInternal>(SB)
 
 #ifdef GOOS_android
 // Use the free TLS_SLOT_APP slot #2 on Android Q.
-- 
GitLab


From 301af2cb71d2731baa55653df67850ce85032e16 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Wed, 16 Dec 2020 13:45:48 -0500
Subject: [PATCH 0278/2400] [dev.regabi] runtime/race: adjust test pattern
 match for ABI wrapper

Adjust the pattern matching in one of the race output test to allow
for the possible introduction of an ABI wrapper. Normally for tests
that match traceback output wrappers are not an issue since they
are screened out by Go's traceback mechanism, but in this case the
race runtime is doing the unwinding, so the wrapper may be visible.

Change-Id: I45413b5c4701d4c28cc760fccc8203493dbe2874
Reviewed-on: https://go-review.googlesource.com/c/go/+/278756
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: Than McIntosh <thanm@google.com>
---
 src/runtime/race/output_test.go | 82 +++++++++++++++++++++++----------
 1 file changed, 58 insertions(+), 24 deletions(-)

diff --git a/src/runtime/race/output_test.go b/src/runtime/race/output_test.go
index 69496874c6..17dc32013f 100644
--- a/src/runtime/race/output_test.go
+++ b/src/runtime/race/output_test.go
@@ -7,6 +7,7 @@
 package race_test
 
 import (
+	"fmt"
 	"internal/testenv"
 	"os"
 	"os/exec"
@@ -71,9 +72,24 @@ func TestOutput(t *testing.T) {
 			"GORACE="+test.gorace,
 		)
 		got, _ := cmd.CombinedOutput()
-		if !regexp.MustCompile(test.re).MatchString(string(got)) {
-			t.Fatalf("failed test case %v, expect:\n%v\ngot:\n%s",
-				test.name, test.re, got)
+		matched := false
+		for _, re := range test.re {
+			if regexp.MustCompile(re).MatchString(string(got)) {
+				matched = true
+				break
+			}
+		}
+		if !matched {
+			exp := fmt.Sprintf("expect:\n%v\n", test.re[0])
+			if len(test.re) > 1 {
+				exp = fmt.Sprintf("expected one of %d patterns:\n",
+					len(test.re))
+				for k, re := range test.re {
+					exp += fmt.Sprintf("pattern %d:\n%v\n", k, re)
+				}
+			}
+			t.Fatalf("failed test case %v, %sgot:\n%s",
+				test.name, exp, got)
 		}
 	}
 }
@@ -84,7 +100,7 @@ var tests = []struct {
 	goos   string
 	gorace string
 	source string
-	re     string
+	re     []string
 }{
 	{"simple", "run", "", "atexit_sleep_ms=0", `
 package main
@@ -107,7 +123,7 @@ func racer(x *int, done chan bool) {
 	store(x, 42)
 	done <- true
 }
-`, `==================
+`, []string{`==================
 WARNING: DATA RACE
 Write at 0x[0-9,a-f]+ by goroutine [0-9]:
   main\.store\(\)
@@ -129,7 +145,7 @@ Goroutine [0-9] \(running\) created at:
 ==================
 Found 1 data race\(s\)
 exit status 66
-`},
+`}},
 
 	{"exitcode", "run", "", "atexit_sleep_ms=0 exitcode=13", `
 package main
@@ -143,7 +159,7 @@ func main() {
 	x = 43
 	<-done
 }
-`, `exit status 13`},
+`, []string{`exit status 13`}},
 
 	{"strip_path_prefix", "run", "", "atexit_sleep_ms=0 strip_path_prefix=/main.", `
 package main
@@ -157,9 +173,9 @@ func main() {
 	x = 43
 	<-done
 }
-`, `
+`, []string{`
       go:7 \+0x[0-9,a-f]+
-`},
+`}},
 
 	{"halt_on_error", "run", "", "atexit_sleep_ms=0 halt_on_error=1", `
 package main
@@ -173,10 +189,10 @@ func main() {
 	x = 43
 	<-done
 }
-`, `
+`, []string{`
 ==================
 exit status 66
-`},
+`}},
 
 	{"test_fails_on_race", "test", "", "atexit_sleep_ms=0", `
 package main_test
@@ -193,12 +209,12 @@ func TestFail(t *testing.T) {
 	<-done
 	t.Log(t.Failed())
 }
-`, `
+`, []string{`
 ==================
 --- FAIL: TestFail \(0...s\)
 .*main_test.go:14: true
 .*testing.go:.*: race detected during execution of test
-FAIL`},
+FAIL`}},
 
 	{"slicebytetostring_pc", "run", "", "atexit_sleep_ms=0", `
 package main
@@ -211,11 +227,11 @@ func main() {
 	data[0] = 1
 	<-done
 }
-`, `
+`, []string{`
   runtime\.slicebytetostring\(\)
       .*/runtime/string\.go:.*
   main\.main\.func1\(\)
-      .*/main.go:7`},
+      .*/main.go:7`}},
 
 	// Test for https://golang.org/issue/33309
 	{"midstack_inlining_traceback", "run", "linux", "atexit_sleep_ms=0", `
@@ -241,7 +257,7 @@ func g(c chan int) {
 func h(c chan int) {
 	c <- x
 }
-`, `==================
+`, []string{`==================
 WARNING: DATA RACE
 Read at 0x[0-9,a-f]+ by goroutine [0-9]:
   main\.h\(\)
@@ -261,7 +277,7 @@ Goroutine [0-9] \(running\) created at:
 ==================
 Found 1 data race\(s\)
 exit status 66
-`},
+`}},
 
 	// Test for https://golang.org/issue/17190
 	{"external_cgo_thread", "run", "linux", "atexit_sleep_ms=0", `
@@ -300,7 +316,25 @@ func main() {
 	racy++
 	<- done
 }
-`, `==================
+`, []string{`==================
+WARNING: DATA RACE
+Read at 0x[0-9,a-f]+ by main goroutine:
+  main\.main\(\)
+      .*/main\.go:34 \+0x[0-9,a-f]+
+
+Previous write at 0x[0-9,a-f]+ by goroutine [0-9]:
+  main\.goCallback\(\)
+      .*/main\.go:27 \+0x[0-9,a-f]+
+  _cgoexp_[0-9a-z]+_goCallback\(\)
+      .*_cgo_gotypes\.go:[0-9]+ \+0x[0-9,a-f]+
+  _cgoexp_[0-9a-z]+_goCallback\(\)
+      <autogenerated>:1 \+0x[0-9,a-f]+
+
+Goroutine [0-9] \(running\) created at:
+  runtime\.newextram\(\)
+      .*/runtime/proc.go:[0-9]+ \+0x[0-9,a-f]+
+==================`,
+		`==================
 WARNING: DATA RACE
 Read at 0x[0-9,a-f]+ by .*:
   main\..*
@@ -313,7 +347,7 @@ Previous write at 0x[0-9,a-f]+ by .*:
 Goroutine [0-9] \(running\) created at:
   runtime\.newextram\(\)
       .*/runtime/proc.go:[0-9]+ \+0x[0-9,a-f]+
-==================`},
+==================`}},
 	{"second_test_passes", "test", "", "atexit_sleep_ms=0", `
 package main_test
 import "testing"
@@ -331,11 +365,11 @@ func TestFail(t *testing.T) {
 
 func TestPass(t *testing.T) {
 }
-`, `
+`, []string{`
 ==================
 --- FAIL: TestFail \(0...s\)
 .*testing.go:.*: race detected during execution of test
-FAIL`},
+FAIL`}},
 	{"mutex", "run", "", "atexit_sleep_ms=0", `
 package main
 import (
@@ -366,7 +400,7 @@ func main() {
 	}
 	wg.Wait()
 	if (data == iterations*(threads+1)) { fmt.Println("pass") }
-}`, `pass`},
+}`, []string{`pass`}},
 	// Test for https://github.com/golang/go/issues/37355
 	{"chanmm", "run", "", "atexit_sleep_ms=0", `
 package main
@@ -395,7 +429,7 @@ func main() {
 	wg.Wait()
 	_ = data
 }
-`, `==================
+`, []string{`==================
 WARNING: DATA RACE
 Write at 0x[0-9,a-f]+ by goroutine [0-9]:
   main\.main\.func2\(\)
@@ -408,5 +442,5 @@ Previous write at 0x[0-9,a-f]+ by main goroutine:
 Goroutine [0-9] \(running\) created at:
   main\.main\(\)
       .*/main.go:[0-9]+ \+0x[0-9,a-f]+
-==================`},
+==================`}},
 }
-- 
GitLab


From 2755361e6abfd3a58acd5f7ebbcd05c23bc8261a Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 18 Dec 2020 20:49:50 -0800
Subject: [PATCH 0279/2400] [dev.regabi] cmd/compile: change noder.declNames to
 returns ir.Names

declNames always returns a slice of *ir.Names, so return that directly
rather than as []ir.Node.

While here, also change iimport to directly create ir.ODCL/ir.OAS
statements, rather than calling variter. Allows eliminating a use of
ir.TypeNode.

Passes buildall w/ toolstash -cmp.

Change-Id: Icb75e993c4957b6050c797ba64ee71cfb7a19644
Reviewed-on: https://go-review.googlesource.com/c/go/+/279315
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/gc/dcl.go     | 20 ++++++++------------
 src/cmd/compile/internal/gc/embed.go   |  4 ++--
 src/cmd/compile/internal/gc/iimport.go | 10 ++++++++--
 src/cmd/compile/internal/gc/noder.go   |  5 ++---
 4 files changed, 20 insertions(+), 19 deletions(-)

diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 04e3506dba..09d2e7d8b7 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -130,17 +130,16 @@ func declare(n *ir.Name, ctxt ir.Class) {
 
 // declare variables from grammar
 // new_name_list (type | [type] = expr_list)
-func variter(vl []ir.Node, t ir.Ntype, el []ir.Node) []ir.Node {
+func variter(vl []*ir.Name, t ir.Ntype, el []ir.Node) []ir.Node {
 	var init []ir.Node
 	doexpr := len(el) > 0
 
 	if len(el) == 1 && len(vl) > 1 {
 		e := el[0]
 		as2 := ir.Nod(ir.OAS2, nil, nil)
-		as2.PtrList().Set(vl)
 		as2.PtrRlist().Set1(e)
 		for _, v := range vl {
-			v := v.(*ir.Name)
+			as2.PtrList().Append(v)
 			declare(v, dclcontext)
 			v.Ntype = t
 			v.Defn = as2
@@ -152,17 +151,14 @@ func variter(vl []ir.Node, t ir.Ntype, el []ir.Node) []ir.Node {
 		return append(init, as2)
 	}
 
-	nel := len(el)
-	for _, v := range vl {
-		v := v.(*ir.Name)
+	for i, v := range vl {
 		var e ir.Node
 		if doexpr {
-			if len(el) == 0 {
-				base.Errorf("assignment mismatch: %d variables but %d values", len(vl), nel)
+			if i >= len(el) {
+				base.Errorf("assignment mismatch: %d variables but %d values", len(vl), len(el))
 				break
 			}
-			e = el[0]
-			el = el[1:]
+			e = el[i]
 		}
 
 		declare(v, dclcontext)
@@ -180,8 +176,8 @@ func variter(vl []ir.Node, t ir.Ntype, el []ir.Node) []ir.Node {
 		}
 	}
 
-	if len(el) != 0 {
-		base.Errorf("assignment mismatch: %d variables but %d values", len(vl), nel)
+	if len(el) > len(vl) {
+		base.Errorf("assignment mismatch: %d variables but %d values", len(vl), len(el))
 	}
 	return init
 }
diff --git a/src/cmd/compile/internal/gc/embed.go b/src/cmd/compile/internal/gc/embed.go
index 0d4ce83716..ea23e26069 100644
--- a/src/cmd/compile/internal/gc/embed.go
+++ b/src/cmd/compile/internal/gc/embed.go
@@ -24,7 +24,7 @@ const (
 	embedFiles
 )
 
-func varEmbed(p *noder, names []ir.Node, typ ir.Ntype, exprs []ir.Node, embeds []PragmaEmbed) (newExprs []ir.Node) {
+func varEmbed(p *noder, names []*ir.Name, typ ir.Ntype, exprs []ir.Node, embeds []PragmaEmbed) (newExprs []ir.Node) {
 	haveEmbed := false
 	for _, decl := range p.file.DeclList {
 		imp, ok := decl.(*syntax.ImportDecl)
@@ -66,7 +66,7 @@ func varEmbed(p *noder, names []ir.Node, typ ir.Ntype, exprs []ir.Node, embeds [
 		return exprs
 	}
 
-	v := names[0].(*ir.Name)
+	v := names[0]
 	Target.Embeds = append(Target.Embeds, v)
 	v.Embed = new([]ir.Embed)
 	for _, e := range embeds {
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 219ce4bdef..cd66d39b66 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -972,8 +972,14 @@ func (r *importReader) node() ir.Node {
 	case ir.ODCL:
 		pos := r.pos()
 		lhs := ir.NewDeclNameAt(pos, ir.ONAME, r.ident())
-		typ := ir.TypeNode(r.typ())
-		return npos(pos, liststmt(variter([]ir.Node{lhs}, typ, nil))) // TODO(gri) avoid list creation
+		lhs.SetType(r.typ())
+
+		declare(lhs, ir.PAUTO)
+
+		var stmts ir.Nodes
+		stmts.Append(ir.Nod(ir.ODCL, lhs, nil))
+		stmts.Append(ir.Nod(ir.OAS, lhs, nil))
+		return npos(pos, liststmt(stmts.Slice()))
 
 	// case OAS, OASWB:
 	// 	unreachable - mapped to OAS case below by exporter
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index b61f19ae2e..97a9ac4396 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -441,7 +441,6 @@ func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []ir.Node {
 
 	nn := make([]ir.Node, 0, len(names))
 	for i, n := range names {
-		n := n.(*ir.Name)
 		if i >= len(values) {
 			base.Errorf("missing value in const declaration")
 			break
@@ -492,8 +491,8 @@ func (p *noder) typeDecl(decl *syntax.TypeDecl) ir.Node {
 	return nod
 }
 
-func (p *noder) declNames(op ir.Op, names []*syntax.Name) []ir.Node {
-	nodes := make([]ir.Node, 0, len(names))
+func (p *noder) declNames(op ir.Op, names []*syntax.Name) []*ir.Name {
+	nodes := make([]*ir.Name, 0, len(names))
 	for _, name := range names {
 		nodes = append(nodes, p.declName(op, name))
 	}
-- 
GitLab


From 3512cde10ac5e466527d69313b8250b2ea0146b1 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 17 Dec 2020 18:47:26 -0800
Subject: [PATCH 0280/2400] [dev.regabi] cmd/compile: stop reusing Ntype for
 OSLICELIT length

For OSLICELITs, we were reusing the Ntype field after type checking to
hold the length of the OSLICELIT's backing array. However, Ntype is
only meant for nodes that can represent types. Today, this works only
because we currently use Name for all OLITERAL constants (whether
declared or not), whereas we should be able to represent them more
compactly with a dedicated type that doesn't implement Ntype.

Passes buildall w/ toolstash -cmp.

Change-Id: I385f1d787c41b016f507a5bad9489d59ccfde7f2
Reviewed-on: https://go-review.googlesource.com/c/go/+/279152
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/gc/inl.go       |  2 +-
 src/cmd/compile/internal/gc/order.go     |  2 +-
 src/cmd/compile/internal/gc/sinit.go     | 18 +++++++++---------
 src/cmd/compile/internal/gc/typecheck.go |  3 ++-
 src/cmd/compile/internal/ir/expr.go      |  1 +
 5 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 33a309db87..5ada83b715 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -452,7 +452,7 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 		// and don't charge for the OBLOCK itself. The ++ undoes the -- below.
 		v.budget++
 
-	case ir.OCALLPART:
+	case ir.OCALLPART, ir.OSLICELIT:
 		v.budget-- // Hack for toolstash -cmp.
 	}
 
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 9c03a5843c..1a0f0066d0 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -1281,7 +1281,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		n := n.(*ir.CompLitExpr)
 		o.exprList(n.List())
 		if n.Transient() {
-			t := types.NewArray(n.Type().Elem(), ir.Int64Val(n.Right()))
+			t := types.NewArray(n.Type().Elem(), n.Len)
 			n.Prealloc = o.newTemp(t, false)
 		}
 		return n
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 7b710fd511..a845bc5d75 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -142,8 +142,9 @@ func (s *InitSchedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *type
 		}
 
 	case ir.OSLICELIT:
+		r := r.(*ir.CompLitExpr)
 		// copy slice
-		slicesym(l, loff, s.inittemps[r], ir.Int64Val(r.Right()))
+		slicesym(l, loff, s.inittemps[r], r.Len)
 		return true
 
 	case ir.OARRAYLIT, ir.OSTRUCTLIT:
@@ -232,14 +233,14 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 		}
 
 	case ir.OSLICELIT:
+		r := r.(*ir.CompLitExpr)
 		s.initplan(r)
 		// Init slice.
-		bound := ir.Int64Val(r.Right())
-		ta := types.NewArray(r.Type().Elem(), bound)
+		ta := types.NewArray(r.Type().Elem(), r.Len)
 		ta.SetNoalg(true)
 		a := staticname(ta)
 		s.inittemps[r] = a
-		slicesym(l, loff, a, bound)
+		slicesym(l, loff, a, r.Len)
 		// Fall through to init underlying array.
 		l = a
 		loff = 0
@@ -425,10 +426,11 @@ func getdyn(n ir.Node, top bool) initGenType {
 		return initDynamic
 
 	case ir.OSLICELIT:
+		n := n.(*ir.CompLitExpr)
 		if !top {
 			return initDynamic
 		}
-		if ir.Int64Val(n.Right())/4 > int64(n.List().Len()) {
+		if n.Len/4 > int64(n.List().Len()) {
 			// <25% of entries have explicit values.
 			// Very rough estimation, it takes 4 bytes of instructions
 			// to initialize 1 byte of result. So don't use a static
@@ -603,14 +605,12 @@ func isSmallSliceLit(n *ir.CompLitExpr) bool {
 		return false
 	}
 
-	r := n.Right()
-
-	return smallintconst(r) && (n.Type().Elem().Width == 0 || ir.Int64Val(r) <= smallArrayBytes/n.Type().Elem().Width)
+	return n.Type().Elem().Width == 0 || n.Len <= smallArrayBytes/n.Type().Elem().Width
 }
 
 func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes) {
 	// make an array type corresponding the number of elements we have
-	t := types.NewArray(n.Type().Elem(), ir.Int64Val(n.Right()))
+	t := types.NewArray(n.Type().Elem(), n.Len)
 	dowidth(t)
 
 	if ctxt == inNonInitFunction {
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 4fae4a0819..2d383ab49e 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -2850,7 +2850,8 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 	case types.TSLICE:
 		length := typecheckarraylit(t.Elem(), -1, n.List().Slice(), "slice literal")
 		n.SetOp(ir.OSLICELIT)
-		n.SetRight(nodintconst(length))
+		n.SetRight(nil)
+		n.Len = length
 
 	case types.TMAP:
 		var cs constSet
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 8f43eb0fb2..d74e7f8763 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -294,6 +294,7 @@ type CompLitExpr struct {
 	Ntype    Ntype
 	List_    Nodes // initialized values
 	Prealloc *Name
+	Len      int64 // backing array length for OSLICELIT
 }
 
 func NewCompLitExpr(pos src.XPos, op Op, typ Ntype, list []Node) *CompLitExpr {
-- 
GitLab


From c8610e4700bee51898197987de5335b8527079e8 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 17 Dec 2020 20:17:04 -0800
Subject: [PATCH 0281/2400] [dev.regabi] cmd/compile: add ir.BasicLit to
 represent literals

This CL changes so that all literals are represented with a new,
smaller ir.BasicLit type, so that ir.Name is only used to represent
declared constants.

Passes buildall w/ toolstash -cmp.

Change-Id: I4702b8e3fa945617bd05881d7a2be1205f229633
Reviewed-on: https://go-review.googlesource.com/c/go/+/279153
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/gc/universe.go |  9 +++------
 src/cmd/compile/internal/ir/expr.go     | 19 +++++++++++++++++++
 src/cmd/compile/internal/ir/name.go     | 11 +++++++++++
 src/cmd/compile/internal/ir/node_gen.go | 15 +++++++++++++++
 src/cmd/compile/internal/ir/val.go      |  7 +------
 5 files changed, 49 insertions(+), 12 deletions(-)

diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index c988c575dc..e11c0eb92c 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -11,6 +11,7 @@ import (
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
+	"go/constant"
 )
 
 var basicTypes = [...]struct {
@@ -163,14 +164,10 @@ func initUniverse() {
 	}
 
 	s = types.BuiltinPkg.Lookup("true")
-	b := nodbool(true)
-	b.(*ir.Name).SetSym(lookup("true"))
-	s.Def = b
+	s.Def = ir.NewConstAt(src.NoXPos, s, types.UntypedBool, constant.MakeBool(true))
 
 	s = types.BuiltinPkg.Lookup("false")
-	b = nodbool(false)
-	b.(*ir.Name).SetSym(lookup("false"))
-	s.Def = b
+	s.Def = ir.NewConstAt(src.NoXPos, s, types.UntypedBool, constant.MakeBool(false))
 
 	s = lookup("_")
 	types.BlankSym = s
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index d74e7f8763..5937798bd4 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -136,6 +136,25 @@ func (n *AddrExpr) SetOp(op Op) {
 	}
 }
 
+// A BasicLit is a literal of basic type.
+type BasicLit struct {
+	miniExpr
+	val constant.Value
+}
+
+func NewBasicLit(pos src.XPos, val constant.Value) Node {
+	n := &BasicLit{val: val}
+	n.op = OLITERAL
+	n.pos = pos
+	if k := val.Kind(); k != constant.Unknown {
+		n.SetType(idealType(k))
+	}
+	return n
+}
+
+func (n *BasicLit) Val() constant.Value       { return n.val }
+func (n *BasicLit) SetVal(val constant.Value) { n.val = val }
+
 // A BinaryExpr is a binary expression X Op Y,
 // or Op(X, Y) for builtin functions that do not become calls.
 type BinaryExpr struct {
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 9cf959b23d..b0b33cccfa 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -179,6 +179,17 @@ func NewDeclNameAt(pos src.XPos, op Op, sym *types.Sym) *Name {
 	return newNameAt(pos, op, sym)
 }
 
+// NewConstAt returns a new OLITERAL Node associated with symbol s at position pos.
+func NewConstAt(pos src.XPos, sym *types.Sym, typ *types.Type, val constant.Value) *Name {
+	if sym == nil {
+		base.Fatalf("NewConstAt nil")
+	}
+	n := newNameAt(pos, OLITERAL, sym)
+	n.SetType(typ)
+	n.SetVal(val)
+	return n
+}
+
 // newNameAt is like NewNameAt but allows sym == nil.
 func newNameAt(pos src.XPos, op Op, sym *types.Sym) *Name {
 	n := new(Name)
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index a0fae2b949..a5959ea26f 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -116,6 +116,21 @@ func (n *AssignStmt) editChildren(edit func(Node) Node) {
 	n.Y = maybeEdit(n.Y, edit)
 }
 
+func (n *BasicLit) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *BasicLit) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	return &c
+}
+func (n *BasicLit) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	return err
+}
+func (n *BasicLit) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+}
+
 func (n *BinaryExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *BinaryExpr) copy() Node {
 	c := *n
diff --git a/src/cmd/compile/internal/ir/val.go b/src/cmd/compile/internal/ir/val.go
index 5b0506c0d0..ff45f31074 100644
--- a/src/cmd/compile/internal/ir/val.go
+++ b/src/cmd/compile/internal/ir/val.go
@@ -92,12 +92,7 @@ func ValidTypeForConst(t *types.Type, v constant.Value) bool {
 
 // nodlit returns a new untyped constant with value v.
 func NewLiteral(v constant.Value) Node {
-	n := newNameAt(base.Pos, OLITERAL, nil)
-	if k := v.Kind(); k != constant.Unknown {
-		n.SetType(idealType(k))
-		n.SetVal(v)
-	}
-	return n
+	return NewBasicLit(base.Pos, v)
 }
 
 func idealType(ct constant.Kind) *types.Type {
-- 
GitLab


From 41e7901ca41de2211567fe2d3f73a8da9ae6189b Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 21 Dec 2020 16:48:58 -0800
Subject: [PATCH 0282/2400] [dev.typeparams] cmd/compile/internal/types2:
 report error for invalid main function signature

Updates #43308.

Change-Id: I2caff83f304c7e104edda76ac3623cce9fc94a8d
Reviewed-on: https://go-review.googlesource.com/c/go/+/279552
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/types2/resolver.go       | 11 ++++++-----
 src/cmd/compile/internal/types2/testdata/main.go2 |  7 +++++++
 src/cmd/compile/internal/types2/testdata/main.src |  9 +++++++++
 test/run.go                                       |  1 -
 4 files changed, 22 insertions(+), 6 deletions(-)
 create mode 100644 src/cmd/compile/internal/types2/testdata/main.go2
 create mode 100644 src/cmd/compile/internal/types2/testdata/main.src

diff --git a/src/cmd/compile/internal/types2/resolver.go b/src/cmd/compile/internal/types2/resolver.go
index 2c98ca20e3..7ea9bde5fa 100644
--- a/src/cmd/compile/internal/types2/resolver.go
+++ b/src/cmd/compile/internal/types2/resolver.go
@@ -397,15 +397,16 @@ func (check *Checker) collectObjects() {
 				obj := NewFunc(d.Name.Pos(), pkg, name, nil)
 				if d.Recv == nil {
 					// regular function
-					if name == "init" {
+					if name == "init" || name == "main" && pkg.name == "main" {
 						if d.TParamList != nil {
-							//check.softErrorf(d.TParamList.Pos(), "func init must have no type parameters")
-							check.softErrorf(d.Name, "func init must have no type parameters")
+							check.softErrorf(d, "func %s must have no type parameters", name)
 						}
 						if t := d.Type; len(t.ParamList) != 0 || len(t.ResultList) != 0 {
-							check.softErrorf(d, "func init must have no arguments and no return values")
+							check.softErrorf(d, "func %s must have no arguments and no return values", name)
 						}
-						// don't declare init functions in the package scope - they are invisible
+					}
+					// don't declare init functions in the package scope - they are invisible
+					if name == "init" {
 						obj.parent = pkg.scope
 						check.recordDef(d.Name, obj)
 						// init functions must have a body
diff --git a/src/cmd/compile/internal/types2/testdata/main.go2 b/src/cmd/compile/internal/types2/testdata/main.go2
new file mode 100644
index 0000000000..b7ddeaa1a8
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/main.go2
@@ -0,0 +1,7 @@
+// Copyright 2020 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
+
+func /* ERROR "func main must have no type parameters" */ main[T any]() {}
diff --git a/src/cmd/compile/internal/types2/testdata/main.src b/src/cmd/compile/internal/types2/testdata/main.src
new file mode 100644
index 0000000000..f892938d4a
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/main.src
@@ -0,0 +1,9 @@
+// Copyright 2020 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
+
+func main()
+func /* ERROR "no arguments and no return values" */ main /* ERROR redeclared */ (int)
+func /* ERROR "no arguments and no return values" */ main /* ERROR redeclared */ () int
diff --git a/test/run.go b/test/run.go
index 5ec33f16f2..fcf8a4fcc9 100644
--- a/test/run.go
+++ b/test/run.go
@@ -1936,7 +1936,6 @@ var excluded = map[string]bool{
 	"import6.go":      true, // issue #43109
 	"initializerr.go": true, // types2 reports extra errors
 	"linkname2.go":    true, // error reported by noder (not running for types2 errorcheck test)
-	"mainsig.go":      true, // issue #43308
 	"shift1.go":       true, // issue #42989
 	"switch4.go":      true, // error reported by noder (not running for types2 errorcheck test)
 	"typecheck.go":    true, // invalid function is not causing errors when called
-- 
GitLab


From cb28c96be8b8010dd979e0723bf5a94b11962a93 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Thu, 24 Sep 2020 13:14:46 -0400
Subject: [PATCH 0283/2400] [dev.regabi] cmd/compile,cmd/link: initial support
 for ABI wrappers

Add compiler support for emitting ABI wrappers by creating real IR as
opposed to introducing ABI aliases. At the moment these are "no-op"
wrappers in the sense that they make a simple call (using the existing
ABI) to their target. The assumption here is that once late call
expansion can handle both ABI0 and the "new" ABIInternal (register
version), it can expand the call to do the right thing.

Note that the runtime contains functions that do not strictly follow
the rules of the current Go ABI0; this has been handled in most cases
by treating these as ABIInternal instead (these changes have been made
in previous patches).

Generation of ABI wrappers (as opposed to ABI aliases) is currently
gated by GOEXPERIMENT=regabi -- wrapper generation is on by default if
GOEXPERIMENT=regabi is set and off otherwise (but can be turned on
using "-gcflags=all=-abiwrap -ldflags=-abiwrap"). Wrapper generation
currently only workd on AMD64; explicitly enabling wrapper for other
architectures (via the command line) is not supported.

Also in this patch are a few other command line options for debugging
(tracing and/or limiting wrapper creation). These will presumably go
away at some point.

Updates #27539, #40724.

Change-Id: I1ee3226fc15a3c32ca2087b8ef8e41dbe6df4a75
Reviewed-on: https://go-review.googlesource.com/c/go/+/270863
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/base/debug.go  |   1 +
 src/cmd/compile/internal/base/flag.go   |   3 +
 src/cmd/compile/internal/gc/gsubr.go    | 191 ++++++++++++++++++++----
 src/cmd/compile/internal/gc/main.go     |  23 +++
 src/cmd/compile/internal/gc/pgen.go     |   7 +-
 src/cmd/compile/internal/gc/racewalk.go |   2 +-
 src/cmd/compile/internal/gc/ssa.go      |  49 +++++-
 src/cmd/compile/internal/types/sym.go   |  17 +++
 src/cmd/internal/obj/link.go            |   6 +
 src/cmd/internal/obj/plist.go           |   6 +
 src/cmd/internal/obj/textflag.go        |   3 +
 src/cmd/internal/obj/x86/obj6.go        |   4 +-
 src/cmd/link/internal/ld/main.go        |  12 +-
 src/cmd/link/internal/ld/symtab.go      |  37 ++++-
 src/runtime/textflag.h                  |   2 +
 test/nosplit.go                         |   9 +-
 16 files changed, 328 insertions(+), 44 deletions(-)

diff --git a/src/cmd/compile/internal/base/debug.go b/src/cmd/compile/internal/base/debug.go
index 45a552a4d9..3acdcea846 100644
--- a/src/cmd/compile/internal/base/debug.go
+++ b/src/cmd/compile/internal/base/debug.go
@@ -51,6 +51,7 @@ type DebugFlags struct {
 	TypeAssert    int    `help:"print information about type assertion inlining"`
 	TypecheckInl  int    `help:"eager typechecking of inline function bodies"`
 	WB            int    `help:"print information about write barriers"`
+	ABIWrap       int    `help:"print information about ABI wrapper generation"`
 
 	any bool // set when any of the values have been set
 }
diff --git a/src/cmd/compile/internal/base/flag.go b/src/cmd/compile/internal/base/flag.go
index aadc70f496..ce87ff730e 100644
--- a/src/cmd/compile/internal/base/flag.go
+++ b/src/cmd/compile/internal/base/flag.go
@@ -81,6 +81,8 @@ type CmdFlags struct {
 	CompilingRuntime bool "flag:\"+\" help:\"compiling runtime\""
 
 	// Longer names
+	ABIWrap            bool         "help:\"enable generation of ABI wrappers\""
+	ABIWrapLimit       int          "help:\"emit at most N ABI wrappers (for debugging)\""
 	AsmHdr             string       "help:\"write assembly header to `file`\""
 	Bench              string       "help:\"append benchmark times to `file`\""
 	BlockProfile       string       "help:\"write block profile to `file`\""
@@ -140,6 +142,7 @@ func ParseFlags() {
 	Flag.LowerP = &Ctxt.Pkgpath
 	Flag.LowerV = &Ctxt.Debugvlog
 
+	Flag.ABIWrap = objabi.Regabi_enabled != 0
 	Flag.Dwarf = objabi.GOARCH != "wasm"
 	Flag.DwarfBASEntries = &Ctxt.UseBASEntries
 	Flag.DwarfLocationLists = &Ctxt.Flag_locationlists
diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go
index ddb431d5ab..f3ef14c99b 100644
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ b/src/cmd/compile/internal/gc/gsubr.go
@@ -34,9 +34,12 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
 	"cmd/internal/src"
+	"fmt"
+	"os"
 )
 
 var sharedProgArray = new([10000]obj.Prog) // *T instead of T to work around issue 19839
@@ -187,32 +190,154 @@ func (pp *Progs) settext(fn *ir.Func) {
 	ptxt.From.Sym = fn.LSym
 }
 
+// makeABIWrapper creates a new function that wraps a cross-ABI call
+// to "f".  The wrapper is marked as an ABIWRAPPER.
+func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
+
+	// Q: is this needed?
+	savepos := base.Pos
+	savedclcontext := dclcontext
+	savedcurfn := Curfn
+
+	base.Pos = autogeneratedPos
+	dclcontext = ir.PEXTERN
+
+	// At the moment we don't support wrapping a method, we'd need machinery
+	// below to handle the receiver. Panic if we see this scenario.
+	ft := f.Nname.Ntype.Type()
+	if ft.NumRecvs() != 0 {
+		panic("makeABIWrapper support for wrapping methods not implemented")
+	}
+
+	// Manufacture a new func type to use for the wrapper.
+	var noReceiver *ir.Field
+	tfn := ir.NewFuncType(base.Pos,
+		noReceiver,
+		structargs(ft.Params(), true),
+		structargs(ft.Results(), false))
+
+	// Reuse f's types.Sym to create a new ODCLFUNC/function.
+	fn := dclfunc(f.Nname.Sym(), tfn)
+	fn.SetDupok(true)
+	fn.SetWrapper(true) // ignore frame for panic+recover matching
+
+	// Select LSYM now.
+	asym := base.Ctxt.LookupABI(f.LSym.Name, wrapperABI)
+	asym.Type = objabi.STEXT
+	if fn.LSym != nil {
+		panic("unexpected")
+	}
+	fn.LSym = asym
+
+	// 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
+	// need to allocate stack space, so it should be OK to mark them
+	// as NOSPLIT in these cases. In addition, my assumption is that
+	// functions written in assembly are NOSPLIT in most (but not all)
+	// cases. In the case of an ABIInternal target that has too many
+	// parameters to fit into registers, the wrapper would need to
+	// allocate stack space, but this seems like an unlikely scenario.
+	// Hence: mark these wrappers NOSPLIT.
+	//
+	// ABIInternal-to-ABI0 wrappers on the other hand will be taking
+	// things in registers and pushing them onto the stack prior to
+	// the ABI0 call, meaning that they will always need to allocate
+	// stack space. If the compiler marks them as NOSPLIT this seems
+	// as though it could lead to situations where the the linker's
+	// nosplit-overflow analysis would trigger a link failure. On the
+	// other hand if they not tagged NOSPLIT then this could cause
+	// problems when building the runtime (since there may be calls to
+	// asm routine in cases where it's not safe to grow the stack). In
+	// most cases the wrapper would be (in effect) inlined, but are
+	// there (perhaps) indirect calls from the runtime that could run
+	// into trouble here.
+	// FIXME: at the moment all.bash does not pass when I leave out
+	// NOSPLIT for these wrappers, so all are currently tagged with NOSPLIT.
+	setupTextLSym(fn, obj.NOSPLIT|obj.ABIWRAPPER)
+
+	// Generate call. Use tail call if no params and no returns,
+	// but a regular call otherwise.
+	//
+	// Note: ideally we would be using a tail call in cases where
+	// there are params but no returns for ABI0->ABIInternal wrappers,
+	// provided that all params fit into registers (e.g. we don't have
+	// to allocate any stack space). Doing this will require some
+	// extra work in typecheck/walk/ssa, might want to add a new node
+	// OTAILCALL or something to this effect.
+	var call ir.Node
+	if tfn.Type().NumResults() == 0 && tfn.Type().NumParams() == 0 && tfn.Type().NumRecvs() == 0 {
+		call = nodSym(ir.ORETJMP, nil, f.Nname.Sym())
+	} else {
+		call = ir.Nod(ir.OCALL, f.Nname, nil)
+		call.PtrList().Set(paramNnames(tfn.Type()))
+		call.SetIsDDD(tfn.Type().IsVariadic())
+		if tfn.Type().NumResults() > 0 {
+			n := ir.Nod(ir.ORETURN, nil, nil)
+			n.PtrList().Set1(call)
+			call = n
+		}
+	}
+	fn.PtrBody().Append(call)
+
+	funcbody()
+	if base.Debug.DclStack != 0 {
+		testdclstack()
+	}
+
+	typecheckFunc(fn)
+	Curfn = fn
+	typecheckslice(fn.Body().Slice(), ctxStmt)
+
+	escapeFuncs([]*ir.Func{fn}, false)
+
+	Target.Decls = append(Target.Decls, fn)
+
+	// Restore previous context.
+	base.Pos = savepos
+	dclcontext = savedclcontext
+	Curfn = savedcurfn
+}
+
 // initLSym defines f's obj.LSym and initializes it based on the
 // properties of f. This includes setting the symbol flags and ABI and
 // creating and initializing related DWARF symbols.
 //
 // initLSym must be called exactly once per function and must be
 // called for both functions with bodies and functions without bodies.
+// For body-less functions, we only create the LSym; for functions
+// with bodies call a helper to setup up / populate the LSym.
 func initLSym(f *ir.Func, hasBody bool) {
+	// FIXME: for new-style ABI wrappers, we set up the lsym at the
+	// point the wrapper is created.
+	if f.LSym != nil && base.Flag.ABIWrap {
+		return
+	}
+	selectLSym(f, hasBody)
+	if hasBody {
+		setupTextLSym(f, 0)
+	}
+}
+
+// selectLSym sets up the LSym for a given function, and
+// makes calls to helpers to create ABI wrappers if needed.
+func selectLSym(f *ir.Func, hasBody bool) {
 	if f.LSym != nil {
 		base.Fatalf("Func.initLSym called twice")
 	}
 
 	if nam := f.Nname; !ir.IsBlank(nam) {
-		f.LSym = nam.Sym().Linksym()
-		if f.Pragma&ir.Systemstack != 0 {
-			f.LSym.Set(obj.AttrCFunc, true)
-		}
 
-		var aliasABI obj.ABI
-		needABIAlias := false
-		defABI, hasDefABI := symabiDefs[f.LSym.Name]
+		var wrapperABI obj.ABI
+		needABIWrapper := false
+		defABI, hasDefABI := symabiDefs[nam.Sym().LinksymName()]
 		if hasDefABI && defABI == obj.ABI0 {
 			// Symbol is defined as ABI0. Create an
 			// Internal -> ABI0 wrapper.
-			f.LSym.SetABI(obj.ABI0)
-			needABIAlias, aliasABI = true, obj.ABIInternal
+			f.LSym = nam.Sym().LinksymABI0()
+			needABIWrapper, wrapperABI = true, obj.ABIInternal
 		} else {
+			f.LSym = nam.Sym().Linksym()
 			// No ABI override. Check that the symbol is
 			// using the expected ABI.
 			want := obj.ABIInternal
@@ -220,6 +345,9 @@ func initLSym(f *ir.Func, hasBody bool) {
 				base.Fatalf("function symbol %s has the wrong ABI %v, expected %v", f.LSym.Name, f.LSym.ABI(), want)
 			}
 		}
+		if f.Pragma&ir.Systemstack != 0 {
+			f.LSym.Set(obj.AttrCFunc, true)
+		}
 
 		isLinknameExported := nam.Sym().Linkname != "" && (hasBody || hasDefABI)
 		if abi, ok := symabiRefs[f.LSym.Name]; (ok && abi == obj.ABI0) || isLinknameExported {
@@ -235,32 +363,39 @@ func initLSym(f *ir.Func, hasBody bool) {
 			// using linkname and we don't want to create
 			// duplicate ABI wrappers.
 			if f.LSym.ABI() != obj.ABI0 {
-				needABIAlias, aliasABI = true, obj.ABI0
+				needABIWrapper, wrapperABI = true, obj.ABI0
 			}
 		}
 
-		if needABIAlias {
-			// These LSyms have the same name as the
-			// native function, so we create them directly
-			// rather than looking them up. The uniqueness
-			// of f.lsym ensures uniqueness of asym.
-			asym := &obj.LSym{
-				Name: f.LSym.Name,
-				Type: objabi.SABIALIAS,
-				R:    []obj.Reloc{{Sym: f.LSym}}, // 0 size, so "informational"
+		if needABIWrapper {
+			if !useABIWrapGen(f) {
+				// Fallback: use alias instead. FIXME.
+
+				// These LSyms have the same name as the
+				// native function, so we create them directly
+				// rather than looking them up. The uniqueness
+				// of f.lsym ensures uniqueness of asym.
+				asym := &obj.LSym{
+					Name: f.LSym.Name,
+					Type: objabi.SABIALIAS,
+					R:    []obj.Reloc{{Sym: f.LSym}}, // 0 size, so "informational"
+				}
+				asym.SetABI(wrapperABI)
+				asym.Set(obj.AttrDuplicateOK, true)
+				base.Ctxt.ABIAliases = append(base.Ctxt.ABIAliases, asym)
+			} else {
+				if base.Debug.ABIWrap != 0 {
+					fmt.Fprintf(os.Stderr, "=-= %v to %v wrapper for %s.%s\n",
+						wrapperABI, 1-wrapperABI, types.LocalPkg.Path, f.LSym.Name)
+				}
+				makeABIWrapper(f, wrapperABI)
 			}
-			asym.SetABI(aliasABI)
-			asym.Set(obj.AttrDuplicateOK, true)
-			base.Ctxt.ABIAliases = append(base.Ctxt.ABIAliases, asym)
 		}
 	}
+}
 
-	if !hasBody {
-		// For body-less functions, we only create the LSym.
-		return
-	}
-
-	var flag int
+// setupTextLsym initializes the LSym for a with-body text symbol.
+func setupTextLSym(f *ir.Func, flag int) {
 	if f.Dupok() {
 		flag |= obj.DUPOK
 	}
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 7f7cd63cdf..de2b3db36a 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -1144,3 +1144,26 @@ func initializeTypesPackage() {
 
 	initUniverse()
 }
+
+// useNewABIWrapGen returns TRUE if the compiler should generate an
+// ABI wrapper for the function 'f'.
+func useABIWrapGen(f *ir.Func) bool {
+	if !base.Flag.ABIWrap {
+		return false
+	}
+
+	// Support limit option for bisecting.
+	if base.Flag.ABIWrapLimit == 1 {
+		return false
+	}
+	if base.Flag.ABIWrapLimit < 1 {
+		return true
+	}
+	base.Flag.ABIWrapLimit--
+	if base.Debug.ABIWrap != 0 && base.Flag.ABIWrapLimit == 1 {
+		fmt.Fprintf(os.Stderr, "=-= limit reached after new wrapper for %s\n",
+			f.LSym.Name)
+	}
+
+	return true
+}
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index 5b5288c389..dae9d79147 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -32,7 +32,6 @@ func emitptrargsmap(fn *ir.Func) {
 		return
 	}
 	lsym := base.Ctxt.Lookup(fn.LSym.Name + ".args_stackmap")
-
 	nptr := int(fn.Type().ArgWidth() / int64(Widthptr))
 	bv := bvalloc(int32(nptr) * 2)
 	nbitmap := 1
@@ -399,7 +398,11 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 	fn := curfn.(*ir.Func)
 
 	if fn.Nname != nil {
-		if expect := fn.Sym().Linksym(); fnsym != expect {
+		expect := fn.Sym().Linksym()
+		if fnsym.ABI() == obj.ABI0 {
+			expect = fn.Sym().LinksymABI0()
+		}
+		if fnsym != expect {
 			base.Fatalf("unexpected fnsym: %v != %v", fnsym, expect)
 		}
 	}
diff --git a/src/cmd/compile/internal/gc/racewalk.go b/src/cmd/compile/internal/gc/racewalk.go
index 472deb16e3..61a65368af 100644
--- a/src/cmd/compile/internal/gc/racewalk.go
+++ b/src/cmd/compile/internal/gc/racewalk.go
@@ -61,7 +61,7 @@ func ispkgin(pkgs []string) bool {
 }
 
 func instrument(fn *ir.Func) {
-	if fn.Pragma&ir.Norace != 0 {
+	if fn.Pragma&ir.Norace != 0 || (fn.Sym().Linksym() != nil && fn.Sym().Linksym().ABIWrapper()) {
 		return
 	}
 
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index a5340e7f11..b4cf8b6dc7 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -1421,7 +1421,7 @@ func (s *state) stmt(n ir.Node) {
 	case ir.ORETJMP:
 		b := s.exit()
 		b.Kind = ssa.BlockRetJmp // override BlockRet
-		b.Aux = n.Sym().Linksym()
+		b.Aux = callTargetLSym(n.Sym(), s.curfn.LSym)
 
 	case ir.OCONTINUE, ir.OBREAK:
 		var to *ssa.Block
@@ -4826,11 +4826,11 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			}
 		case sym != nil:
 			if testLateExpansion {
-				aux := ssa.StaticAuxCall(sym.Linksym(), ACArgs, ACResults)
+				aux := ssa.StaticAuxCall(callTargetLSym(sym, s.curfn.LSym), ACArgs, ACResults)
 				call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 				call.AddArgs(callArgs...)
 			} else {
-				call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, ssa.StaticAuxCall(sym.Linksym(), ACArgs, ACResults), s.mem())
+				call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, ssa.StaticAuxCall(callTargetLSym(sym, s.curfn.LSym), ACArgs, ACResults), s.mem())
 			}
 		default:
 			s.Fatalf("bad call type %v %v", n.Op(), n)
@@ -7291,3 +7291,46 @@ func clobberBase(n ir.Node) ir.Node {
 	}
 	return n
 }
+
+// callTargetLSym determines the correct LSym for 'callee' when called
+// from function 'caller'. There are a couple of different scenarios
+// to contend with here:
+//
+// 1. if 'caller' is an ABI wrapper, then we always want to use the
+//    LSym from the Func for the callee.
+//
+// 2. if 'caller' is not an ABI wrapper, then we looked at the callee
+//    to see if it corresponds to a "known" ABI0 symbol (e.g. assembly
+//    routine defined in the current package); if so, we want the call to
+//    directly target the ABI0 symbol (effectively bypassing the
+//    ABIInternal->ABI0 wrapper for 'callee').
+//
+// 3. in all other cases, want the regular ABIInternal linksym
+//
+func callTargetLSym(callee *types.Sym, callerLSym *obj.LSym) *obj.LSym {
+	lsym := callee.Linksym()
+	if !base.Flag.ABIWrap {
+		return lsym
+	}
+	if ir.AsNode(callee.Def) == nil {
+		return lsym
+	}
+	ndclfunc := ir.AsNode(callee.Def).Name().Defn
+	if ndclfunc == nil {
+		return lsym
+	}
+	// check for case 1 above
+	if callerLSym.ABIWrapper() {
+		if nlsym := ndclfunc.Func().LSym; nlsym != nil {
+			lsym = nlsym
+		}
+	} else {
+		// check for case 2 above
+		nam := ndclfunc.Func().Nname
+		defABI, hasDefABI := symabiDefs[nam.Sym().LinksymName()]
+		if hasDefABI && defABI == obj.ABI0 {
+			lsym = nam.Sym().LinksymABI0()
+		}
+	}
+	return lsym
+}
diff --git a/src/cmd/compile/internal/types/sym.go b/src/cmd/compile/internal/types/sym.go
index 19f06fcf5b..c512e3a003 100644
--- a/src/cmd/compile/internal/types/sym.go
+++ b/src/cmd/compile/internal/types/sym.go
@@ -93,6 +93,23 @@ func (sym *Sym) Linksym() *obj.LSym {
 	return base.Ctxt.LookupInit(sym.LinksymName(), initPkg)
 }
 
+// LinksymABI0 looks up or creates an ABI0 linker symbol for "sym",
+// in cases where we want to specifically select the ABI0 version of
+// a symbol (typically used only for ABI wrappers).
+func (sym *Sym) LinksymABI0() *obj.LSym {
+	if sym == nil {
+		return nil
+	}
+	initPkg := func(r *obj.LSym) {
+		if sym.Linkname != "" {
+			r.Pkg = "_"
+		} else {
+			r.Pkg = sym.Pkg.Prefix
+		}
+	}
+	return base.Ctxt.LookupABIInit(sym.LinksymName(), obj.ABI0, initPkg)
+}
+
 // Less reports whether symbol a is ordered before symbol b.
 //
 // Symbols are ordered exported before non-exported, then by name, and
diff --git a/src/cmd/internal/obj/link.go b/src/cmd/internal/obj/link.go
index 7b5c990a5d..977c5c3303 100644
--- a/src/cmd/internal/obj/link.go
+++ b/src/cmd/internal/obj/link.go
@@ -635,6 +635,10 @@ const (
 	// ContentAddressable indicates this is a content-addressable symbol.
 	AttrContentAddressable
 
+	// ABI wrapper is set for compiler-generated text symbols that
+	// convert between ABI0 and ABIInternal calling conventions.
+	AttrABIWrapper
+
 	// attrABIBase is the value at which the ABI is encoded in
 	// Attribute. This must be last; all bits after this are
 	// assumed to be an ABI value.
@@ -660,6 +664,7 @@ func (a Attribute) TopFrame() bool           { return a&AttrTopFrame != 0 }
 func (a Attribute) Indexed() bool            { return a&AttrIndexed != 0 }
 func (a Attribute) UsedInIface() bool        { return a&AttrUsedInIface != 0 }
 func (a Attribute) ContentAddressable() bool { return a&AttrContentAddressable != 0 }
+func (a Attribute) ABIWrapper() bool         { return a&AttrABIWrapper != 0 }
 
 func (a *Attribute) Set(flag Attribute, value bool) {
 	if value {
@@ -695,6 +700,7 @@ var textAttrStrings = [...]struct {
 	{bit: AttrTopFrame, s: "TOPFRAME"},
 	{bit: AttrIndexed, s: ""},
 	{bit: AttrContentAddressable, s: ""},
+	{bit: AttrABIWrapper, s: "ABIWRAPPER"},
 }
 
 // TextAttrString formats a for printing in as part of a TEXT prog.
diff --git a/src/cmd/internal/obj/plist.go b/src/cmd/internal/obj/plist.go
index 2b096996f7..679ce7eb8f 100644
--- a/src/cmd/internal/obj/plist.go
+++ b/src/cmd/internal/obj/plist.go
@@ -80,6 +80,11 @@ func Flushplist(ctxt *Link, plist *Plist, newprog ProgAlloc, myimportpath string
 		if !strings.HasPrefix(s.Name, "\"\".") {
 			continue
 		}
+		if s.ABIWrapper() {
+			// Don't create an args_stackmap symbol reference for an ABI
+			// wrapper function
+			continue
+		}
 		found := false
 		for p := s.Func().Text; p != nil; p = p.Link {
 			if p.As == AFUNCDATA && p.From.Type == TYPE_CONST && p.From.Offset == objabi.FUNCDATA_ArgsPointerMaps {
@@ -134,6 +139,7 @@ func (ctxt *Link) InitTextSym(s *LSym, flag int) {
 	s.Set(AttrNoSplit, flag&NOSPLIT != 0)
 	s.Set(AttrReflectMethod, flag&REFLECTMETHOD != 0)
 	s.Set(AttrWrapper, flag&WRAPPER != 0)
+	s.Set(AttrABIWrapper, flag&ABIWRAPPER != 0)
 	s.Set(AttrNeedCtxt, flag&NEEDCTXT != 0)
 	s.Set(AttrNoFrame, flag&NOFRAME != 0)
 	s.Set(AttrTopFrame, flag&TOPFRAME != 0)
diff --git a/src/cmd/internal/obj/textflag.go b/src/cmd/internal/obj/textflag.go
index d2cec734b1..fcc4014aa2 100644
--- a/src/cmd/internal/obj/textflag.go
+++ b/src/cmd/internal/obj/textflag.go
@@ -51,4 +51,7 @@ const (
 	// Function is the top of the call stack. Call stack unwinders should stop
 	// at this function.
 	TOPFRAME = 2048
+
+	// Function is an ABI wrapper.
+	ABIWRAPPER = 4096
 )
diff --git a/src/cmd/internal/obj/x86/obj6.go b/src/cmd/internal/obj/x86/obj6.go
index 184fb4308b..839aeb8fe3 100644
--- a/src/cmd/internal/obj/x86/obj6.go
+++ b/src/cmd/internal/obj/x86/obj6.go
@@ -637,7 +637,7 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 		}
 	}
 
-	if !p.From.Sym.NoSplit() || p.From.Sym.Wrapper() {
+	if !p.From.Sym.NoSplit() || (p.From.Sym.Wrapper() && !p.From.Sym.ABIWrapper()) {
 		p = obj.Appendp(p, newprog)
 		p = load_g_cx(ctxt, p, newprog) // load g into CX
 	}
@@ -690,7 +690,7 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 		p.To.Reg = REG_BP
 	}
 
-	if cursym.Func().Text.From.Sym.Wrapper() {
+	if cursym.Func().Text.From.Sym.Wrapper() && !cursym.Func().Text.From.Sym.ABIWrapper() {
 		// if g._panic != nil && g._panic.argp == FP {
 		//   g._panic.argp = bottom-of-frame
 		// }
diff --git a/src/cmd/link/internal/ld/main.go b/src/cmd/link/internal/ld/main.go
index 5c8293810f..1420030eec 100644
--- a/src/cmd/link/internal/ld/main.go
+++ b/src/cmd/link/internal/ld/main.go
@@ -92,11 +92,10 @@ var (
 	FlagRound         = flag.Int("R", -1, "set address rounding `quantum`")
 	FlagTextAddr      = flag.Int64("T", -1, "set text segment `address`")
 	flagEntrySymbol   = flag.String("E", "", "set `entry` symbol name")
-
-	cpuprofile     = flag.String("cpuprofile", "", "write cpu profile to `file`")
-	memprofile     = flag.String("memprofile", "", "write memory profile to `file`")
-	memprofilerate = flag.Int64("memprofilerate", 0, "set runtime.MemProfileRate to `rate`")
-
+	cpuprofile        = flag.String("cpuprofile", "", "write cpu profile to `file`")
+	memprofile        = flag.String("memprofile", "", "write memory profile to `file`")
+	memprofilerate    = flag.Int64("memprofilerate", 0, "set runtime.MemProfileRate to `rate`")
+	flagAbiWrap       = false
 	benchmarkFlag     = flag.String("benchmark", "", "set to 'mem' or 'cpu' to enable phase benchmarking")
 	benchmarkFileFlag = flag.String("benchmarkprofile", "", "emit phase profiles to `base`_phase.{cpu,mem}prof")
 )
@@ -135,6 +134,9 @@ func Main(arch *sys.Arch, theArch Arch) {
 	objabi.Flagfn1("X", "add string value `definition` of the form importpath.name=value", func(s string) { addstrdata1(ctxt, s) })
 	objabi.Flagcount("v", "print link trace", &ctxt.Debugvlog)
 	objabi.Flagfn1("importcfg", "read import configuration from `file`", ctxt.readImportCfg)
+	if objabi.Regabi_enabled != 0 {
+		flag.BoolVar(&flagAbiWrap, "abiwrap", true, "support ABI wrapper functions")
+	}
 
 	objabi.Flagparse(usage)
 
diff --git a/src/cmd/link/internal/ld/symtab.go b/src/cmd/link/internal/ld/symtab.go
index c98e4de03f..3b709baf75 100644
--- a/src/cmd/link/internal/ld/symtab.go
+++ b/src/cmd/link/internal/ld/symtab.go
@@ -102,6 +102,41 @@ func putelfsym(ctxt *Link, x loader.Sym, typ elf.SymType, curbind elf.SymBind) {
 		elfshnum = xosect.Elfsect.(*ElfShdr).shnum
 	}
 
+	sname := ldr.SymExtname(x)
+
+	// For functions with ABI wrappers, we have to make sure that we
+	// don't wind up with two elf symbol table entries with the same
+	// name (since this will generated an error from the external
+	// linker). In the CgoExportStatic case, we want the ABI0 symbol
+	// to have the primary symbol table entry (since it's going to be
+	// called from C), so we rename the ABIInternal symbol. In all
+	// other cases, we rename the ABI0 symbol, since we want
+	// cross-load-module calls to target ABIInternal.
+	//
+	// TODO: generalize this for non-ELF (put the rename code in the
+	// loader, and store the rename result in SymExtname).
+	//
+	// TODO: avoid the ldr.Lookup calls below by instead using an aux
+	// sym or marker relocation to associate the wrapper with the
+	// wrapped function.
+	//
+	if flagAbiWrap {
+		if !ldr.IsExternal(x) && ldr.SymType(x) == sym.STEXT {
+			// First case
+			if ldr.SymVersion(x) == sym.SymVerABIInternal {
+				if s2 := ldr.Lookup(sname, sym.SymVerABI0); s2 != 0 && ldr.AttrCgoExportStatic(s2) && ldr.SymType(s2) == sym.STEXT {
+					sname = sname + ".abiinternal"
+				}
+			}
+			// Second case
+			if ldr.SymVersion(x) == sym.SymVerABI0 && !ldr.AttrCgoExportStatic(x) {
+				if s2 := ldr.Lookup(sname, sym.SymVerABIInternal); s2 != 0 && ldr.SymType(s2) == sym.STEXT {
+					sname = sname + ".abi0"
+				}
+			}
+		}
+	}
+
 	// One pass for each binding: elf.STB_LOCAL, elf.STB_GLOBAL,
 	// maybe one day elf.STB_WEAK.
 	bind := elf.STB_GLOBAL
@@ -140,8 +175,6 @@ func putelfsym(ctxt *Link, x loader.Sym, typ elf.SymType, curbind elf.SymBind) {
 		other |= 3 << 5
 	}
 
-	sname := ldr.SymExtname(x)
-
 	// When dynamically linking, we create Symbols by reading the names from
 	// the symbol tables of the shared libraries and so the names need to
 	// match exactly. Tools like DTrace will have to wait for now.
diff --git a/src/runtime/textflag.h b/src/runtime/textflag.h
index daca36d948..e727208cd0 100644
--- a/src/runtime/textflag.h
+++ b/src/runtime/textflag.h
@@ -35,3 +35,5 @@
 // Function is the top of the call stack. Call stack unwinders should stop
 // at this function.
 #define TOPFRAME 2048
+// Function is an ABI wrapper.
+#define ABIWRAPPER 4096
diff --git a/test/nosplit.go b/test/nosplit.go
index faa7b8c2d8..8a3fa9bf35 100644
--- a/test/nosplit.go
+++ b/test/nosplit.go
@@ -353,7 +353,14 @@ TestCases:
 			log.Fatal(err)
 		}
 
-		cmd := exec.Command("go", "build")
+		// Turn off ABI0 wrapper generation for now. The problem here is
+		// that in these test cases main.main is an assembly routine,
+		// thus calls to it will have to go through an ABI wrapper. The
+		// ABI wrapper will consume some stack space, which throws off
+		// the numbers.
+		workaround := "-gcflags=-abiwrap=0"
+
+		cmd := exec.Command("go", "build", workaround)
 		cmd.Dir = dir
 		output, err := cmd.CombinedOutput()
 		if err == nil {
-- 
GitLab


From 7c8f5356abd7aadf32b028ce76a8a76cd5438258 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 21 Dec 2020 01:55:44 -0500
Subject: [PATCH 0284/2400] [dev.regabi] cmd/compile: separate dowidth better

Having a global MaxWidth lets us avoid needing to
refer to thearch from split-out packages when all
they need is thearch.MAXWIDTH.

And make a couple interface changes to let dowidth
avoid importing package ir directly.
Then it can move into package types.

Change-Id: I2c12e8e22252597530e648848320e19bdd490a01
Reviewed-on: https://go-review.googlesource.com/c/go/+/279302
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/abiutils_test.go |  1 +
 src/cmd/compile/internal/gc/align.go         | 29 +++++++++++---------
 src/cmd/compile/internal/gc/main.go          |  1 +
 src/cmd/compile/internal/gc/pgen.go          |  2 +-
 src/cmd/compile/internal/gc/reflect.go       |  3 +-
 src/cmd/compile/internal/gc/sinit.go         |  2 +-
 src/cmd/compile/internal/ir/name.go          | 18 ++++++++++++
 src/cmd/compile/internal/types/type.go       | 12 ++++++++
 8 files changed, 51 insertions(+), 17 deletions(-)

diff --git a/src/cmd/compile/internal/gc/abiutils_test.go b/src/cmd/compile/internal/gc/abiutils_test.go
index 16bd787bea..14bd7ff097 100644
--- a/src/cmd/compile/internal/gc/abiutils_test.go
+++ b/src/cmd/compile/internal/gc/abiutils_test.go
@@ -29,6 +29,7 @@ func TestMain(m *testing.M) {
 	thearch.LinkArch = &x86.Linkamd64
 	thearch.REGSP = x86.REGSP
 	thearch.MAXWIDTH = 1 << 50
+	MaxWidth = thearch.MAXWIDTH
 	base.Ctxt = obj.Linknew(thearch.LinkArch)
 	base.Ctxt.DiagFunc = base.Errorf
 	base.Ctxt.DiagFlush = base.FlushErrors
diff --git a/src/cmd/compile/internal/gc/align.go b/src/cmd/compile/internal/gc/align.go
index 95a5dbef29..a9cf7fb50a 100644
--- a/src/cmd/compile/internal/gc/align.go
+++ b/src/cmd/compile/internal/gc/align.go
@@ -7,12 +7,14 @@ package gc
 import (
 	"bytes"
 	"cmd/compile/internal/base"
-	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"fmt"
 	"sort"
 )
 
+// MaxWidth is the maximum size of a value on the target architecture.
+var MaxWidth int64
+
 // sizeCalculationDisabled indicates whether it is safe
 // to calculate Types' widths and alignments. See dowidth.
 var sizeCalculationDisabled bool
@@ -84,7 +86,7 @@ func expandiface(t *types.Type) {
 
 	sort.Sort(methcmp(methods))
 
-	if int64(len(methods)) >= thearch.MAXWIDTH/int64(Widthptr) {
+	if int64(len(methods)) >= MaxWidth/int64(Widthptr) {
 		base.ErrorfAt(typePos(t), "interface too large")
 	}
 	for i, m := range methods {
@@ -118,8 +120,7 @@ func widstruct(errtype *types.Type, t *types.Type, o int64, flag int) int64 {
 			o = Rnd(o, int64(f.Type.Align))
 		}
 		f.Offset = o
-		if n := ir.AsNode(f.Nname); n != nil {
-			n := n.Name()
+		if f.Nname != nil {
 			// addrescapes has similar code to update these offsets.
 			// Usually addrescapes runs after widstruct,
 			// in which case we could drop this,
@@ -127,12 +128,7 @@ func widstruct(errtype *types.Type, t *types.Type, o int64, flag int) int64 {
 			// NOTE(rsc): This comment may be stale.
 			// It's possible the ordering has changed and this is
 			// now the common case. I'm not sure.
-			if n.Name().Stackcopy != nil {
-				n.Name().Stackcopy.SetFrameOffset(o)
-				n.SetFrameOffset(0)
-			} else {
-				n.SetFrameOffset(o)
-			}
+			f.Nname.(types.VarObject).RecordFrameOffset(o)
 		}
 
 		w := f.Type.Width
@@ -143,7 +139,7 @@ func widstruct(errtype *types.Type, t *types.Type, o int64, flag int) int64 {
 			lastzero = o
 		}
 		o += w
-		maxwidth := thearch.MAXWIDTH
+		maxwidth := MaxWidth
 		// On 32-bit systems, reflect tables impose an additional constraint
 		// that each field start offset must fit in 31 bits.
 		if maxwidth < 1<<32 {
@@ -206,7 +202,7 @@ func findTypeLoop(t *types.Type, path *[]*types.Type) bool {
 		}
 
 		*path = append(*path, t)
-		if findTypeLoop(t.Obj().(*ir.Name).Ntype.Type(), path) {
+		if findTypeLoop(t.Obj().(types.TypeObject).TypeDefn(), path) {
 			return true
 		}
 		*path = (*path)[:len(*path)-1]
@@ -419,7 +415,7 @@ func dowidth(t *types.Type) {
 
 		dowidth(t.Elem())
 		if t.Elem().Width != 0 {
-			cap := (uint64(thearch.MAXWIDTH) - 1) / uint64(t.Elem().Width)
+			cap := (uint64(MaxWidth) - 1) / uint64(t.Elem().Width)
 			if uint64(t.NumElem()) > cap {
 				base.ErrorfAt(typePos(t), "type %L larger than address space", t)
 			}
@@ -479,6 +475,13 @@ func dowidth(t *types.Type) {
 	resumecheckwidth()
 }
 
+// CalcStructSize calculates the size of s,
+// filling in s.Width and s.Align,
+// even if size calculation is otherwise disabled.
+func CalcStructSize(s *types.Type) {
+	s.Width = widstruct(s, s, 0, 1) // sets align
+}
+
 // when a type's width should be known, we call checkwidth
 // to compute it.  during a declaration like
 //
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index de2b3db36a..343ad9d1d9 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -208,6 +208,7 @@ func Main(archInit func(*Arch)) {
 
 	Widthptr = thearch.LinkArch.PtrSize
 	Widthreg = thearch.LinkArch.RegSize
+	MaxWidth = thearch.MAXWIDTH
 
 	Target = new(ir.Package)
 
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index dae9d79147..8f7aa8e4e7 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -164,7 +164,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 
 		dowidth(n.Type())
 		w := n.Type().Width
-		if w >= thearch.MAXWIDTH || w < 0 {
+		if w >= MaxWidth || w < 0 {
 			base.Fatalf("bad width")
 		}
 		if w == 0 && lastHasPtr {
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 615b8bdbf1..8e2c6f62e1 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -331,8 +331,7 @@ func deferstruct(stksize int64) *types.Type {
 	// build struct holding the above fields
 	s := types.NewStruct(types.NoPkg, fields)
 	s.SetNoalg(true)
-	s.Width = widstruct(s, s, 0, 1)
-	s.Align = uint8(Widthptr)
+	CalcStructSize(s)
 	return s
 }
 
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index a845bc5d75..9ef2bd56eb 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -1019,7 +1019,7 @@ func stataddr(n ir.Node) (name *ir.Name, offset int64, ok bool) {
 		}
 
 		// Check for overflow.
-		if n.Type().Width != 0 && thearch.MAXWIDTH/n.Type().Width <= int64(l) {
+		if n.Type().Width != 0 && MaxWidth/n.Type().Width <= int64(l) {
 			break
 		}
 		offset += int64(l) * n.Type().Width
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index b0b33cccfa..64c60b93d8 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -147,6 +147,24 @@ func (n *Name) isExpr() {}
 // Callers must use n.CloneName to make clear they intend to create a separate name.
 func (n *Name) CloneName() *Name { c := *n; return &c }
 
+// TypeDefn returns the type definition for a named OTYPE.
+// That is, given "type T Defn", it returns Defn.
+// It is used by package types.
+func (n *Name) TypeDefn() *types.Type {
+	return n.Ntype.Type()
+}
+
+// RecordFrameOffset records the frame offset for the name.
+// It is used by package types when laying out function arguments.
+func (n *Name) RecordFrameOffset(offset int64) {
+	if n.Stackcopy != nil {
+		n.Stackcopy.SetFrameOffset(offset)
+		n.SetFrameOffset(0)
+	} else {
+		n.SetFrameOffset(offset)
+	}
+}
+
 // NewNameAt returns a new ONAME Node associated with symbol s at position pos.
 // The caller is responsible for setting Curfn.
 func NewNameAt(pos src.XPos, sym *types.Sym) *Name {
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 4d1d30133c..752c268fa2 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -20,6 +20,18 @@ type Object interface {
 	Type() *Type
 }
 
+// A TypeObject is an Object representing a named type.
+type TypeObject interface {
+	Object
+	TypeDefn() *Type // for "type T Defn", returns Defn
+}
+
+// A VarObject is an Object representing a function argument, variable, or struct field.
+type VarObject interface {
+	Object
+	RecordFrameOffset(int64) // save frame offset
+}
+
 //go:generate stringer -type EType -trimprefix T
 
 // EType describes a kind of type.
-- 
GitLab


From 3b12c6dc089f63d0fe2eeda27e65feb51c5e36d4 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 21 Dec 2020 02:22:42 -0500
Subject: [PATCH 0285/2400] [dev.regabi] cmd/compile: separate typecheck more
 cleanly

Abstract the typecheck API a bit more so that it is
easier to move into a new package.

Change-Id: Ia0a0146151fa7f6073113e68a2c3f6e42a5d0ad8
Reviewed-on: https://go-review.googlesource.com/c/go/+/279303
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/alg.go       |  4 +--
 src/cmd/compile/internal/gc/main.go      |  4 +++
 src/cmd/compile/internal/gc/subr.go      |  6 ++--
 src/cmd/compile/internal/gc/typecheck.go | 37 ++++++++++++++++++++++--
 src/cmd/compile/internal/gc/walk.go      | 13 +++------
 5 files changed, 47 insertions(+), 17 deletions(-)

diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index 036a1e7491..46ae76d58d 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -816,7 +816,7 @@ func eqstring(s, t ir.Node) (eqlen *ir.BinaryExpr, eqmem *ir.CallExpr) {
 	fn := syslook("memequal")
 	fn = substArgTypes(fn, types.Types[types.TUINT8], types.Types[types.TUINT8])
 	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, []ir.Node{sptr, tptr, ir.Copy(slen)})
-	call = typecheck(call, ctxExpr|ctxMultiOK).(*ir.CallExpr)
+	TypecheckCall(call)
 
 	cmp := ir.NewBinaryExpr(base.Pos, ir.OEQ, slen, tlen)
 	cmp = typecheck(cmp, ctxExpr).(*ir.BinaryExpr)
@@ -853,7 +853,7 @@ func eqinterface(s, t ir.Node) (eqtab *ir.BinaryExpr, eqdata *ir.CallExpr) {
 	tdata.SetTypecheck(1)
 
 	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, []ir.Node{stab, sdata, tdata})
-	call = typecheck(call, ctxExpr|ctxMultiOK).(*ir.CallExpr)
+	TypecheckCall(call)
 
 	cmp := ir.NewBinaryExpr(base.Pos, ir.OEQ, stab, ttab)
 	cmp = typecheck(cmp, ctxExpr).(*ir.BinaryExpr)
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 343ad9d1d9..2a5ff3f5fd 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -212,6 +212,10 @@ func Main(archInit func(*Arch)) {
 
 	Target = new(ir.Package)
 
+	NeedFuncSym = makefuncsym
+	NeedITab = func(t, iface *types.Type) { itabname(t, iface) }
+	NeedRuntimeType = addsignat // TODO(rsc): typenamesym for lock?
+
 	// initialize types package
 	// (we need to do this to break dependencies that otherwise
 	// would lead to import cycles)
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 48cbd2505e..0f6c7023f2 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -309,7 +309,7 @@ func assignop(src, dst *types.Type) (ir.Op, string) {
 			// us to de-virtualize calls through this
 			// type/interface pair later. See peekitabs in reflect.go
 			if isdirectiface(src) && !dst.IsEmptyInterface() {
-				itabname(src, dst)
+				NeedITab(src, dst)
 			}
 
 			return ir.OCONVIFACE, ""
@@ -1011,6 +1011,7 @@ func adddot(n *ir.SelectorExpr) *ir.SelectorExpr {
 		for c := len(path) - 1; c >= 0; c-- {
 			dot := nodSym(ir.ODOT, n.Left(), path[c].field.Sym)
 			dot.SetImplicit(true)
+			dot.SetType(path[c].field.Type)
 			n.SetLeft(dot)
 		}
 	case ambig:
@@ -1240,8 +1241,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	if !instrumenting && rcvr.IsPtr() && methodrcvr.IsPtr() && method.Embedded != 0 && !isifacemethod(method.Type) && !(thearch.LinkArch.Name == "ppc64le" && base.Ctxt.Flag_dynlink) {
 		// generate tail call: adjust pointer receiver and jump to embedded method.
 		left := dot.Left() // skip final .M
-		// TODO(mdempsky): Remove dependency on dotlist.
-		if !dotlist[0].field.Type.IsPtr() {
+		if !left.Type().IsPtr() {
 			left = nodAddr(left)
 		}
 		as := ir.Nod(ir.OAS, nthis, convnop(left, rcvr))
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 2d383ab49e..1aaa93fc3d 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -14,6 +14,37 @@ import (
 	"strings"
 )
 
+var (
+	NeedFuncSym     = func(*types.Sym) {}
+	NeedITab        = func(t, itype *types.Type) {}
+	NeedRuntimeType = func(*types.Type) {}
+)
+
+func TypecheckAssignExpr(n ir.Node) ir.Node { return typecheck(n, ctxExpr|ctxAssign) }
+func TypecheckExpr(n ir.Node) ir.Node       { return typecheck(n, ctxExpr) }
+func TypecheckStmt(n ir.Node) ir.Node       { return typecheck(n, ctxStmt) }
+
+func TypecheckExprs(exprs []ir.Node) { typecheckslice(exprs, ctxExpr) }
+func TypecheckStmts(stmts []ir.Node) { typecheckslice(stmts, ctxStmt) }
+
+func TypecheckCall(call *ir.CallExpr) {
+	t := call.X.Type()
+	if t == nil {
+		panic("misuse of Call")
+	}
+	ctx := ctxStmt
+	if t.NumResults() > 0 {
+		ctx = ctxExpr | ctxMultiOK
+	}
+	if typecheck(call, ctx) != call {
+		panic("bad typecheck")
+	}
+}
+
+func TypecheckCallee(n ir.Node) ir.Node {
+	return typecheck(n, ctxExpr|ctxCallee)
+}
+
 // To enable tracing support (-t flag), set enableTrace to true.
 const enableTrace = false
 
@@ -2384,7 +2415,7 @@ func typecheckMethodExpr(n *ir.SelectorExpr) (res ir.Node) {
 		// to make sure to generate wrappers for anonymous
 		// receiver types too.
 		if mt.Sym() == nil {
-			addsignat(t)
+			NeedRuntimeType(t)
 		}
 	}
 
@@ -2417,7 +2448,7 @@ func typecheckMethodExpr(n *ir.SelectorExpr) (res ir.Node) {
 
 	// Issue 25065. Make sure that we emit the symbol for a local method.
 	if base.Ctxt.Flag_dynlink && !inimport && (t.Sym() == nil || t.Sym().Pkg == types.LocalPkg) {
-		makefuncsym(me.FuncName_.Sym())
+		NeedFuncSym(me.FuncName_.Sym())
 	}
 
 	return me
@@ -3451,7 +3482,7 @@ func typecheckfunc(n *ir.Func) {
 	}
 
 	if base.Ctxt.Flag_dynlink && !inimport && n.Nname != nil {
-		makefuncsym(n.Sym())
+		NeedFuncSym(n.Sym())
 	}
 }
 
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 7651bbca10..410155b3ea 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -2520,15 +2520,10 @@ func vmkcall(fn ir.Node, t *types.Type, init *ir.Nodes, va []ir.Node) *ir.CallEx
 		base.Fatalf("vmkcall %v needs %v args got %v", fn, n, len(va))
 	}
 
-	call := ir.Nod(ir.OCALL, fn, nil)
-	call.PtrList().Set(va)
-	ctx := ctxStmt
-	if fn.Type().NumResults() > 0 {
-		ctx = ctxExpr | ctxMultiOK
-	}
-	r1 := typecheck(call, ctx)
-	r1.SetType(t)
-	return walkexpr(r1, init).(*ir.CallExpr)
+	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, va)
+	TypecheckCall(call)
+	call.SetType(t)
+	return walkexpr(call, init).(*ir.CallExpr)
 }
 
 func mkcall(name string, t *types.Type, init *ir.Nodes, args ...ir.Node) *ir.CallExpr {
-- 
GitLab


From 572f168ed26bb32e83562cffb336f2df3a651d9c Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 21 Dec 2020 02:08:34 -0500
Subject: [PATCH 0286/2400] [dev.regabi] cmd/compile: separate various from
 Main

Move various code out of Main itself and into helper functions
that can be moved into other packages as package gc splits up.

Similarly, move order and instrument inside walk to reduce the amount
of API surface needed from the eventual package walk.

Change-Id: I7849258038c6e39625a0385af9c0edd6a3b654a1
Reviewed-on: https://go-review.googlesource.com/c/go/+/279304
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/abiutils_test.go |   8 +-
 src/cmd/compile/internal/gc/dcl.go           |   6 +
 src/cmd/compile/internal/gc/go.go            |   2 -
 src/cmd/compile/internal/gc/inl.go           |  20 ++
 src/cmd/compile/internal/gc/main.go          | 203 ++++---------------
 src/cmd/compile/internal/gc/pgen.go          |  10 +-
 src/cmd/compile/internal/gc/ssa.go           |  19 +-
 src/cmd/compile/internal/gc/typecheck.go     | 114 +++++++++++
 src/cmd/compile/internal/gc/walk.go          |   8 +
 9 files changed, 211 insertions(+), 179 deletions(-)

diff --git a/src/cmd/compile/internal/gc/abiutils_test.go b/src/cmd/compile/internal/gc/abiutils_test.go
index 14bd7ff097..6ed27d794f 100644
--- a/src/cmd/compile/internal/gc/abiutils_test.go
+++ b/src/cmd/compile/internal/gc/abiutils_test.go
@@ -36,7 +36,13 @@ func TestMain(m *testing.M) {
 	base.Ctxt.Bso = bufio.NewWriter(os.Stdout)
 	Widthptr = thearch.LinkArch.PtrSize
 	Widthreg = thearch.LinkArch.RegSize
-	initializeTypesPackage()
+	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
+		return typenamesym(t).Linksym()
+	}
+	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
+		return typenamesym(t).Linksym()
+	}
+	TypecheckInit()
 	os.Exit(m.Run())
 }
 
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 09d2e7d8b7..bcd127b5f1 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -442,6 +442,12 @@ type funcStackEnt struct {
 	dclcontext ir.Class
 }
 
+func CheckFuncStack() {
+	if len(funcStack) != 0 {
+		base.Fatalf("funcStack is non-empty: %v", len(funcStack))
+	}
+}
+
 // finish the body.
 // called in auto-declaration context.
 // returns in extern-declaration context.
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index 1707e6a11b..df91f6f530 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -129,8 +129,6 @@ var (
 	iscmp [ir.OEND]bool
 )
 
-var importlist []*ir.Func // imported functions and methods with inlinable bodies
-
 var (
 	funcsymsmu sync.Mutex // protects funcsyms and associated package lookups (see func funcsym)
 	funcsyms   []*types.Sym
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 5ada83b715..fde4d6910a 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -55,6 +55,26 @@ const (
 	inlineBigFunctionMaxCost = 20   // Max cost of inlinee when inlining into a "big" function.
 )
 
+func InlinePackage() {
+	// Find functions that can be inlined and clone them before walk expands them.
+	visitBottomUp(Target.Decls, func(list []*ir.Func, recursive bool) {
+		numfns := numNonClosures(list)
+		for _, n := range list {
+			if !recursive || numfns > 1 {
+				// We allow inlining if there is no
+				// recursion, or the recursion cycle is
+				// across more than one function.
+				caninl(n)
+			} else {
+				if base.Flag.LowerM > 1 {
+					fmt.Printf("%v: cannot inline %v: recursive\n", ir.Line(n), n.Nname)
+				}
+			}
+			inlcalls(n)
+		}
+	})
+}
+
 // Get the function's package. For ordinary functions it's on the ->sym, but for imported methods
 // the ->sym can be re-used in the local package, so peel it off the receiver's type.
 func fnpkg(fn *ir.Name) *types.Pkg {
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 2a5ff3f5fd..4aa2a2ca47 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -191,24 +191,15 @@ func Main(archInit func(*Arch)) {
 
 	IsIntrinsicCall = isIntrinsicCall
 	SSADumpInline = ssaDumpInline
-
-	ssaDump = os.Getenv("GOSSAFUNC")
-	ssaDir = os.Getenv("GOSSADIR")
-	if ssaDump != "" {
-		if strings.HasSuffix(ssaDump, "+") {
-			ssaDump = ssaDump[:len(ssaDump)-1]
-			ssaDumpStdout = true
-		}
-		spl := strings.Split(ssaDump, ":")
-		if len(spl) > 1 {
-			ssaDump = spl[0]
-			ssaDumpCFG = spl[1]
-		}
-	}
+	initSSAEnv()
+	initSSATables()
 
 	Widthptr = thearch.LinkArch.PtrSize
 	Widthreg = thearch.LinkArch.RegSize
 	MaxWidth = thearch.MAXWIDTH
+	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
+		return typenamesym(t).Linksym()
+	}
 
 	Target = new(ir.Package)
 
@@ -216,152 +207,40 @@ func Main(archInit func(*Arch)) {
 	NeedITab = func(t, iface *types.Type) { itabname(t, iface) }
 	NeedRuntimeType = addsignat // TODO(rsc): typenamesym for lock?
 
-	// initialize types package
-	// (we need to do this to break dependencies that otherwise
-	// would lead to import cycles)
-	initializeTypesPackage()
-
-	dclcontext = ir.PEXTERN
-
 	autogeneratedPos = makePos(src.NewFileBase("<autogenerated>", "<autogenerated>"), 1, 0)
 
-	timings.Start("fe", "loadsys")
-	loadsys()
+	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
+		return typenamesym(t).Linksym()
+	}
+	TypecheckInit()
 
+	// Parse input.
 	timings.Start("fe", "parse")
 	lines := parseFiles(flag.Args())
 	cgoSymABIs()
 	timings.Stop()
 	timings.AddEvent(int64(lines), "lines")
-
-	finishUniverse()
-
 	recordPackageName()
 
-	typecheckok = true
-
-	// Process top-level declarations in phases.
-
-	// Phase 1: const, type, and names and types of funcs.
-	//   This will gather all the information about types
-	//   and methods but doesn't depend on any of it.
-	//
-	//   We also defer type alias declarations until phase 2
-	//   to avoid cycles like #18640.
-	//   TODO(gri) Remove this again once we have a fix for #25838.
-
-	// Don't use range--typecheck can add closures to Target.Decls.
-	timings.Start("fe", "typecheck", "top1")
-	for i := 0; i < len(Target.Decls); i++ {
-		n := Target.Decls[i]
-		if op := n.Op(); op != ir.ODCL && op != ir.OAS && op != ir.OAS2 && (op != ir.ODCLTYPE || !n.(*ir.Decl).Left().Name().Alias()) {
-			Target.Decls[i] = typecheck(n, ctxStmt)
-		}
-	}
+	// Typecheck.
+	TypecheckPackage()
 
-	// Phase 2: Variable assignments.
-	//   To check interface assignments, depends on phase 1.
-
-	// Don't use range--typecheck can add closures to Target.Decls.
-	timings.Start("fe", "typecheck", "top2")
-	for i := 0; i < len(Target.Decls); i++ {
-		n := Target.Decls[i]
-		if op := n.Op(); op == ir.ODCL || op == ir.OAS || op == ir.OAS2 || op == ir.ODCLTYPE && n.(*ir.Decl).Left().Name().Alias() {
-			Target.Decls[i] = typecheck(n, ctxStmt)
-		}
-	}
-
-	// Phase 3: Type check function bodies.
-	// Don't use range--typecheck can add closures to Target.Decls.
-	timings.Start("fe", "typecheck", "func")
-	var fcount int64
-	for i := 0; i < len(Target.Decls); i++ {
-		n := Target.Decls[i]
-		if n.Op() == ir.ODCLFUNC {
-			Curfn = n.(*ir.Func)
-			decldepth = 1
-			errorsBefore := base.Errors()
-			typecheckslice(Curfn.Body().Slice(), ctxStmt)
-			checkreturn(Curfn)
-			if base.Errors() > errorsBefore {
-				Curfn.PtrBody().Set(nil) // type errors; do not compile
-			}
-			// Now that we've checked whether n terminates,
-			// we can eliminate some obviously dead code.
-			deadcode(Curfn)
-			fcount++
-		}
-	}
-
-	// Phase 3.11: Check external declarations.
-	// TODO(mdempsky): This should be handled when type checking their
-	// corresponding ODCL nodes.
-	timings.Start("fe", "typecheck", "externdcls")
-	for i, n := range Target.Externs {
-		if n.Op() == ir.ONAME {
-			Target.Externs[i] = typecheck(Target.Externs[i], ctxExpr)
-		}
-	}
-
-	// Phase 3.14: With all user code type-checked, it's now safe to verify map keys
-	// and unused dot imports.
-	checkMapKeys()
+	// With all user code typechecked, it's now safe to verify unused dot imports.
 	checkDotImports()
 	base.ExitIfErrors()
 
-	timings.AddEvent(fcount, "funcs")
-
+	// Build init task.
 	if initTask := fninit(); initTask != nil {
 		exportsym(initTask)
 	}
 
-	// Phase 4: Decide how to capture closed variables.
-	// This needs to run before escape analysis,
-	// because variables captured by value do not escape.
-	timings.Start("fe", "capturevars")
-	for _, n := range Target.Decls {
-		if n.Op() == ir.ODCLFUNC && n.Func().OClosure != nil {
-			Curfn = n.(*ir.Func)
-			capturevars(Curfn)
-		}
-	}
-	capturevarscomplete = true
-	Curfn = nil
-	base.ExitIfErrors()
-
-	// Phase 5: Inlining
+	// Inlining
 	timings.Start("fe", "inlining")
-	if base.Debug.TypecheckInl != 0 {
-		// Typecheck imported function bodies if Debug.l > 1,
-		// otherwise lazily when used or re-exported.
-		for _, n := range importlist {
-			if n.Inl != nil {
-				typecheckinl(n)
-			}
-		}
-		base.ExitIfErrors()
-	}
-
 	if base.Flag.LowerL != 0 {
-		// Find functions that can be inlined and clone them before walk expands them.
-		visitBottomUp(Target.Decls, func(list []*ir.Func, recursive bool) {
-			numfns := numNonClosures(list)
-			for _, n := range list {
-				if !recursive || numfns > 1 {
-					// We allow inlining if there is no
-					// recursion, or the recursion cycle is
-					// across more than one function.
-					caninl(n)
-				} else {
-					if base.Flag.LowerM > 1 {
-						fmt.Printf("%v: cannot inline %v: recursive\n", ir.Line(n), n.Nname)
-					}
-				}
-				inlcalls(n)
-			}
-		})
+		InlinePackage()
 	}
 
+	// Devirtualize.
 	for _, n := range Target.Decls {
 		if n.Op() == ir.ODCLFUNC {
 			devirtualize(n.(*ir.Func))
@@ -369,7 +248,7 @@ func Main(archInit func(*Arch)) {
 	}
 	Curfn = nil
 
-	// Phase 6: Escape analysis.
+	// Escape analysis.
 	// Required for moving heap allocations onto stack,
 	// which in turn is required by the closure implementation,
 	// which stores the addresses of stack variables into the closure.
@@ -388,7 +267,7 @@ func Main(archInit func(*Arch)) {
 		EnableNoWriteBarrierRecCheck()
 	}
 
-	// Phase 7: Transform closure bodies to properly reference captured variables.
+	// Transform closure bodies to properly reference captured variables.
 	// This needs to happen before walk, because closures must be transformed
 	// before walk reaches a call of a closure.
 	timings.Start("fe", "xclosures")
@@ -410,10 +289,10 @@ func Main(archInit func(*Arch)) {
 	Curfn = nil
 	peekitabs()
 
-	// Phase 8: Compile top level functions.
+	// Compile top level functions.
 	// Don't use range--walk can add functions to Target.Decls.
 	timings.Start("be", "compilefuncs")
-	fcount = 0
+	fcount := int64(0)
 	for i := 0; i < len(Target.Decls); i++ {
 		n := Target.Decls[i]
 		if n.Op() == ir.ODCLFUNC {
@@ -448,21 +327,9 @@ func Main(archInit func(*Arch)) {
 		dumpasmhdr()
 	}
 
-	// Check whether any of the functions we have compiled have gigantic stack frames.
-	sort.Slice(largeStackFrames, func(i, j int) bool {
-		return largeStackFrames[i].pos.Before(largeStackFrames[j].pos)
-	})
-	for _, large := range largeStackFrames {
-		if large.callee != 0 {
-			base.ErrorfAt(large.pos, "stack frame too large (>1GB): %d MB locals + %d MB args + %d MB callee", large.locals>>20, large.args>>20, large.callee>>20)
-		} else {
-			base.ErrorfAt(large.pos, "stack frame too large (>1GB): %d MB locals + %d MB args", large.locals>>20, large.args>>20)
-		}
-	}
+	CheckLargeStacks()
+	CheckFuncStack()
 
-	if len(funcStack) != 0 {
-		base.Fatalf("funcStack is non-empty: %v", len(funcStack))
-	}
 	if len(compilequeue) != 0 {
 		base.Fatalf("%d uncompiled functions", len(compilequeue))
 	}
@@ -480,6 +347,20 @@ func Main(archInit func(*Arch)) {
 	}
 }
 
+func CheckLargeStacks() {
+	// Check whether any of the functions we have compiled have gigantic stack frames.
+	sort.Slice(largeStackFrames, func(i, j int) bool {
+		return largeStackFrames[i].pos.Before(largeStackFrames[j].pos)
+	})
+	for _, large := range largeStackFrames {
+		if large.callee != 0 {
+			base.ErrorfAt(large.pos, "stack frame too large (>1GB): %d MB locals + %d MB args + %d MB callee", large.locals>>20, large.args>>20, large.callee>>20)
+		} else {
+			base.ErrorfAt(large.pos, "stack frame too large (>1GB): %d MB locals + %d MB args", large.locals>>20, large.args>>20)
+		}
+	}
+}
+
 func cgoSymABIs() {
 	// The linker expects an ABI0 wrapper for all cgo-exported
 	// functions.
@@ -1140,16 +1021,6 @@ func parseLang(s string) (lang, error) {
 	return lang{major: major, minor: minor}, nil
 }
 
-func initializeTypesPackage() {
-	types.Widthptr = Widthptr
-	types.Dowidth = dowidth
-	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
-		return typenamesym(t).Linksym()
-	}
-
-	initUniverse()
-}
-
 // useNewABIWrapGen returns TRUE if the compiler should generate an
 // ABI wrapper for the function 'f'.
 func useABIWrapGen(f *ir.Func) bool {
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index 8f7aa8e4e7..e43471dbca 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -222,24 +222,16 @@ func funccompile(fn *ir.Func) {
 }
 
 func compile(fn *ir.Func) {
-	errorsBefore := base.Errors()
-	order(fn)
-	if base.Errors() > errorsBefore {
-		return
-	}
-
 	// Set up the function's LSym early to avoid data races with the assemblers.
 	// Do this before walk, as walk needs the LSym to set attributes/relocations
 	// (e.g. in markTypeUsedInInterface).
 	initLSym(fn, true)
 
+	errorsBefore := base.Errors()
 	walk(fn)
 	if base.Errors() > errorsBefore {
 		return
 	}
-	if instrumenting {
-		instrument(fn)
-	}
 
 	// From this point, there should be no uses of Curfn. Enforce that.
 	Curfn = nil
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index b4cf8b6dc7..1fc1feae67 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -12,6 +12,7 @@ import (
 	"os"
 	"path/filepath"
 	"sort"
+	"strings"
 
 	"bufio"
 	"bytes"
@@ -48,6 +49,22 @@ func ssaDumpInline(fn *ir.Func) {
 	}
 }
 
+func initSSAEnv() {
+	ssaDump = os.Getenv("GOSSAFUNC")
+	ssaDir = os.Getenv("GOSSADIR")
+	if ssaDump != "" {
+		if strings.HasSuffix(ssaDump, "+") {
+			ssaDump = ssaDump[:len(ssaDump)-1]
+			ssaDumpStdout = true
+		}
+		spl := strings.Split(ssaDump, ":")
+		if len(spl) > 1 {
+			ssaDump = spl[0]
+			ssaDumpCFG = spl[1]
+		}
+	}
+}
+
 func initssaconfig() {
 	types_ := ssa.NewTypes()
 
@@ -3357,7 +3374,7 @@ type intrinsicKey struct {
 	fn   string
 }
 
-func init() {
+func initSSATables() {
 	intrinsics = map[intrinsicKey]intrinsicBuilder{}
 
 	var all []*sys.Arch
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 1aaa93fc3d..cc5df3ebae 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -20,6 +20,96 @@ var (
 	NeedRuntimeType = func(*types.Type) {}
 )
 
+func TypecheckInit() {
+	types.Widthptr = Widthptr
+	types.Dowidth = dowidth
+	initUniverse()
+	dclcontext = ir.PEXTERN
+	timings.Start("fe", "loadsys")
+	loadsys()
+}
+
+func TypecheckPackage() {
+	finishUniverse()
+
+	typecheckok = true
+
+	// Process top-level declarations in phases.
+
+	// Phase 1: const, type, and names and types of funcs.
+	//   This will gather all the information about types
+	//   and methods but doesn't depend on any of it.
+	//
+	//   We also defer type alias declarations until phase 2
+	//   to avoid cycles like #18640.
+	//   TODO(gri) Remove this again once we have a fix for #25838.
+
+	// Don't use range--typecheck can add closures to Target.Decls.
+	timings.Start("fe", "typecheck", "top1")
+	for i := 0; i < len(Target.Decls); i++ {
+		n := Target.Decls[i]
+		if op := n.Op(); op != ir.ODCL && op != ir.OAS && op != ir.OAS2 && (op != ir.ODCLTYPE || !n.(*ir.Decl).Left().Name().Alias()) {
+			Target.Decls[i] = typecheck(n, ctxStmt)
+		}
+	}
+
+	// Phase 2: Variable assignments.
+	//   To check interface assignments, depends on phase 1.
+
+	// Don't use range--typecheck can add closures to Target.Decls.
+	timings.Start("fe", "typecheck", "top2")
+	for i := 0; i < len(Target.Decls); i++ {
+		n := Target.Decls[i]
+		if op := n.Op(); op == ir.ODCL || op == ir.OAS || op == ir.OAS2 || op == ir.ODCLTYPE && n.(*ir.Decl).Left().Name().Alias() {
+			Target.Decls[i] = typecheck(n, ctxStmt)
+		}
+	}
+
+	// Phase 3: Type check function bodies.
+	// Don't use range--typecheck can add closures to Target.Decls.
+	timings.Start("fe", "typecheck", "func")
+	var fcount int64
+	for i := 0; i < len(Target.Decls); i++ {
+		n := Target.Decls[i]
+		if n.Op() == ir.ODCLFUNC {
+			TypecheckFuncBody(n.(*ir.Func))
+			fcount++
+		}
+	}
+
+	// Phase 4: Check external declarations.
+	// TODO(mdempsky): This should be handled when type checking their
+	// corresponding ODCL nodes.
+	timings.Start("fe", "typecheck", "externdcls")
+	for i, n := range Target.Externs {
+		if n.Op() == ir.ONAME {
+			Target.Externs[i] = typecheck(Target.Externs[i], ctxExpr)
+		}
+	}
+
+	// Phase 5: With all user code type-checked, it's now safe to verify map keys.
+	checkMapKeys()
+
+	// Phase 6: Decide how to capture closed variables.
+	// This needs to run before escape analysis,
+	// because variables captured by value do not escape.
+	timings.Start("fe", "capturevars")
+	for _, n := range Target.Decls {
+		if n.Op() == ir.ODCLFUNC && n.Func().OClosure != nil {
+			Curfn = n.(*ir.Func)
+			capturevars(Curfn)
+		}
+	}
+	capturevarscomplete = true
+	Curfn = nil
+
+	if base.Debug.TypecheckInl != 0 {
+		// Typecheck imported function bodies if Debug.l > 1,
+		// otherwise lazily when used or re-exported.
+		TypecheckImports()
+	}
+}
+
 func TypecheckAssignExpr(n ir.Node) ir.Node { return typecheck(n, ctxExpr|ctxAssign) }
 func TypecheckExpr(n ir.Node) ir.Node       { return typecheck(n, ctxExpr) }
 func TypecheckStmt(n ir.Node) ir.Node       { return typecheck(n, ctxStmt) }
@@ -45,6 +135,30 @@ func TypecheckCallee(n ir.Node) ir.Node {
 	return typecheck(n, ctxExpr|ctxCallee)
 }
 
+func TypecheckFuncBody(n *ir.Func) {
+	Curfn = n
+	decldepth = 1
+	errorsBefore := base.Errors()
+	typecheckslice(n.Body(), ctxStmt)
+	checkreturn(n)
+	if base.Errors() > errorsBefore {
+		n.PtrBody().Set(nil) // type errors; do not compile
+	}
+	// Now that we've checked whether n terminates,
+	// we can eliminate some obviously dead code.
+	deadcode(n)
+}
+
+var importlist []*ir.Func
+
+func TypecheckImports() {
+	for _, n := range importlist {
+		if n.Inl != nil {
+			typecheckinl(n)
+		}
+	}
+}
+
 // To enable tracing support (-t flag), set enableTrace to true.
 const enableTrace = false
 
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 410155b3ea..5545dcb345 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -26,6 +26,10 @@ const zeroValSize = 1024 // must match value of runtime/map.go:maxZero
 func walk(fn *ir.Func) {
 	Curfn = fn
 	errorsBefore := base.Errors()
+	order(fn)
+	if base.Errors() > errorsBefore {
+		return
+	}
 
 	if base.Flag.W != 0 {
 		s := fmt.Sprintf("\nbefore walk %v", Curfn.Sym())
@@ -80,6 +84,10 @@ func walk(fn *ir.Func) {
 		s := fmt.Sprintf("enter %v", Curfn.Sym())
 		ir.DumpList(s, Curfn.Enter)
 	}
+
+	if instrumenting {
+		instrument(fn)
+	}
 }
 
 func walkstmtlist(s []ir.Node) {
-- 
GitLab


From 51ba53f5c2d58dd0c02b5ee1f4ef1db2577c4d3a Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 21 Dec 2020 01:20:20 -0500
Subject: [PATCH 0287/2400] [dev.regabi] cmd/compile: separate misc for gc
 split

Misc cleanup for splitting package gc: API tweaks
and boundary adjustments.

The change in ir.NewBlockStmt makes it a drop-in
replacement for liststmt.

Change-Id: I9455fe8ccae7d71fe8ccf390ac96672389bf4f3d
Reviewed-on: https://go-review.googlesource.com/c/go/+/279305
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/escape.go  |  4 ----
 src/cmd/compile/internal/gc/iimport.go | 15 +++++++++++++++
 src/cmd/compile/internal/gc/main.go    | 17 ++++++++++-------
 src/cmd/compile/internal/gc/obj.go     |  8 ++++----
 src/cmd/compile/internal/gc/reflect.go | 12 ++++++------
 src/cmd/compile/internal/gc/timings.go |  2 ++
 src/cmd/compile/internal/ir/stmt.go    |  7 +++++++
 7 files changed, 44 insertions(+), 21 deletions(-)

diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 235cef47ea..3351cfe968 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -143,10 +143,6 @@ type EscEdge struct {
 	notes  *EscNote
 }
 
-func init() {
-	ir.EscFmt = escFmt
-}
-
 // escFmt is called from node printing to print information about escape analysis results.
 func escFmt(n ir.Node) string {
 	text := ""
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index cd66d39b66..358fdef294 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -685,6 +685,21 @@ func (r *importReader) typeExt(t *types.Type) {
 // so we can use index to reference the symbol.
 var typeSymIdx = make(map[*types.Type][2]int64)
 
+func BaseTypeIndex(t *types.Type) int64 {
+	tbase := t
+	if t.IsPtr() && t.Sym() == nil && t.Elem().Sym() != nil {
+		tbase = t.Elem()
+	}
+	i, ok := typeSymIdx[tbase]
+	if !ok {
+		return -1
+	}
+	if t != tbase {
+		return i[1]
+	}
+	return i[0]
+}
+
 func (r *importReader) doInline(fn *ir.Func) {
 	if len(fn.Inl.Body) != 0 {
 		base.Fatalf("%v already has inline body", fn)
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 4aa2a2ca47..80b17ebbf8 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -54,9 +54,6 @@ func hidePanic() {
 // Target is the package being compiled.
 var Target *ir.Package
 
-// timing data for compiler phases
-var timings Timings
-
 // Main parses flags and Go source files specified in the command-line
 // arguments, type-checks the parsed Go package, compiles functions to machine
 // code, and finally writes the compiled package definition to disk.
@@ -189,6 +186,7 @@ func Main(archInit func(*Arch)) {
 		logopt.LogJsonOption(base.Flag.JSON)
 	}
 
+	ir.EscFmt = escFmt
 	IsIntrinsicCall = isIntrinsicCall
 	SSADumpInline = ssaDumpInline
 	initSSAEnv()
@@ -962,9 +960,11 @@ type lang struct {
 // any language version is supported.
 var langWant lang
 
-// langSupported reports whether language version major.minor is
-// supported in a particular package.
-func langSupported(major, minor int, pkg *types.Pkg) bool {
+// AllowsGoVersion reports whether a particular package
+// is allowed to use Go version major.minor.
+// We assume the imported packages have all been checked,
+// so we only have to check the local package against the -lang flag.
+func AllowsGoVersion(pkg *types.Pkg, major, minor int) bool {
 	if pkg == nil {
 		// TODO(mdempsky): Set Pkg for local types earlier.
 		pkg = types.LocalPkg
@@ -973,13 +973,16 @@ func langSupported(major, minor int, pkg *types.Pkg) bool {
 		// Assume imported packages passed type-checking.
 		return true
 	}
-
 	if langWant.major == 0 && langWant.minor == 0 {
 		return true
 	}
 	return langWant.major > major || (langWant.major == major && langWant.minor >= minor)
 }
 
+func langSupported(major, minor int, pkg *types.Pkg) bool {
+	return AllowsGoVersion(pkg, major, minor)
+}
+
 // checkLang verifies that the -lang flag holds a valid value, and
 // exits if not. It initializes data used by langSupported.
 func checkLang() {
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 094c386218..c6625da1da 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -127,8 +127,7 @@ func dumpdata() {
 	addsignats(Target.Externs)
 	dumpsignats()
 	dumptabs()
-	ptabsLen := len(ptabs)
-	itabsLen := len(itabs)
+	numPTabs, numITabs := CountTabs()
 	dumpimportstrings()
 	dumpbasictypes()
 	dumpembeds()
@@ -168,10 +167,11 @@ func dumpdata() {
 	if numExports != len(Target.Exports) {
 		base.Fatalf("Target.Exports changed after compile functions loop")
 	}
-	if ptabsLen != len(ptabs) {
+	newNumPTabs, newNumITabs := CountTabs()
+	if newNumPTabs != numPTabs {
 		base.Fatalf("ptabs changed after compile functions loop")
 	}
-	if itabsLen != len(itabs) {
+	if newNumITabs != numITabs {
 		base.Fatalf("itabs changed after compile functions loop")
 	}
 }
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 8e2c6f62e1..92b04f20d5 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -34,6 +34,10 @@ type ptabEntry struct {
 	t *types.Type
 }
 
+func CountTabs() (numPTabs, numITabs int) {
+	return len(ptabs), len(itabs)
+}
+
 // runtime interface and reflection data structures
 var (
 	signatmu    sync.Mutex // protects signatset and signatslice
@@ -1158,13 +1162,9 @@ func dtypesym(t *types.Type) *obj.LSym {
 	if base.Ctxt.Pkgpath != "runtime" || (tbase != types.Types[tbase.Kind()] && tbase != types.ByteType && tbase != types.RuneType && tbase != types.ErrorType) { // int, float, etc
 		// named types from other files are defined only by those files
 		if tbase.Sym() != nil && tbase.Sym().Pkg != types.LocalPkg {
-			if i, ok := typeSymIdx[tbase]; ok {
+			if i := BaseTypeIndex(t); i >= 0 {
 				lsym.Pkg = tbase.Sym().Pkg.Prefix
-				if t != tbase {
-					lsym.SymIdx = int32(i[1])
-				} else {
-					lsym.SymIdx = int32(i[0])
-				}
+				lsym.SymIdx = int32(i)
 				lsym.Set(obj.AttrIndexed, true)
 			}
 			return lsym
diff --git a/src/cmd/compile/internal/gc/timings.go b/src/cmd/compile/internal/gc/timings.go
index 56b3899e2f..ac12d78d1e 100644
--- a/src/cmd/compile/internal/gc/timings.go
+++ b/src/cmd/compile/internal/gc/timings.go
@@ -11,6 +11,8 @@ import (
 	"time"
 )
 
+var timings Timings
+
 // Timings collects the execution times of labeled phases
 // which are added trough a sequence of Start/Stop calls.
 // Events may be associated with each phase via AddEvent.
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index 12811821ad..e2543a5541 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -5,6 +5,7 @@
 package ir
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 )
@@ -164,6 +165,12 @@ type BlockStmt struct {
 func NewBlockStmt(pos src.XPos, list []Node) *BlockStmt {
 	n := &BlockStmt{}
 	n.pos = pos
+	if !pos.IsKnown() {
+		n.pos = base.Pos
+		if len(list) > 0 {
+			n.pos = list[0].Pos()
+		}
+	}
 	n.op = OBLOCK
 	n.List_.Set(list)
 	return n
-- 
GitLab


From 280e7fd1ee47ad92b0031bbc0fa103ac25552950 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 21 Dec 2020 15:10:26 -0500
Subject: [PATCH 0288/2400] [dev.regabi] cmd/compile: only access Func method
 on concrete types

Sets up for removing Func from Node interface.
That means that once the Name reorg is done,
which will let us remove Name, Sym, and Val,
Node will be basically a minimal interface.

Passes buildall w/ toolstash -cmp.

Change-Id: I6e87897572debd7f8e29b4f5167763dc2792b408
Reviewed-on: https://go-review.googlesource.com/c/go/+/279484
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/closure.go   |  8 +++----
 src/cmd/compile/internal/gc/dcl.go       |  1 +
 src/cmd/compile/internal/gc/escape.go    |  5 +++--
 src/cmd/compile/internal/gc/iimport.go   |  4 ++--
 src/cmd/compile/internal/gc/initorder.go |  1 +
 src/cmd/compile/internal/gc/inl.go       |  3 ++-
 src/cmd/compile/internal/gc/main.go      |  9 +++++---
 src/cmd/compile/internal/gc/scc.go       |  8 +++++--
 src/cmd/compile/internal/gc/scope.go     |  2 +-
 src/cmd/compile/internal/gc/sinit.go     |  1 +
 src/cmd/compile/internal/gc/typecheck.go | 10 ++++++---
 src/cmd/compile/internal/gc/walk.go      |  7 +++---
 src/cmd/compile/internal/ir/fmt.go       |  1 +
 src/cmd/compile/internal/ir/func.go      | 28 ++++++++++++++++++++----
 14 files changed, 63 insertions(+), 25 deletions(-)

diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index e07ed4cd24..1f4bf969ad 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -76,7 +76,7 @@ func (p *noder) funcLit(expr *syntax.FuncLit) ir.Node {
 // function associated with the closure.
 // TODO: This creation of the named function should probably really be done in a
 // separate pass from type-checking.
-func typecheckclosure(clo ir.Node, top int) {
+func typecheckclosure(clo *ir.ClosureExpr, top int) {
 	fn := clo.Func()
 	// Set current associated iota value, so iota can be used inside
 	// function in ConstSpec, see issue #22344
@@ -327,13 +327,13 @@ func transformclosure(fn *ir.Func) {
 
 // hasemptycvars reports whether closure clo has an
 // empty list of captured vars.
-func hasemptycvars(clo ir.Node) bool {
+func hasemptycvars(clo *ir.ClosureExpr) bool {
 	return len(clo.Func().ClosureVars) == 0
 }
 
 // closuredebugruntimecheck applies boilerplate checks for debug flags
 // and compiling runtime
-func closuredebugruntimecheck(clo ir.Node) {
+func closuredebugruntimecheck(clo *ir.ClosureExpr) {
 	if base.Debug.Closure > 0 {
 		if clo.Esc() == EscHeap {
 			base.WarnfAt(clo.Pos(), "heap closure, captured vars = %v", clo.Func().ClosureVars)
@@ -349,7 +349,7 @@ func closuredebugruntimecheck(clo ir.Node) {
 // closureType returns the struct type used to hold all the information
 // needed in the closure for clo (clo must be a OCLOSURE node).
 // The address of a variable of the returned type can be cast to a func.
-func closureType(clo ir.Node) *types.Type {
+func closureType(clo *ir.ClosureExpr) *types.Type {
 	// Create closure in the form of a composite literal.
 	// supposing the closure captures an int i and a string s
 	// and has one float64 argument and no results,
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index bcd127b5f1..558bdbef92 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -892,6 +892,7 @@ func (c *nowritebarrierrecChecker) findExtraCalls(nn ir.Node) {
 	case ir.ONAME:
 		callee = arg.Name().Defn.(*ir.Func)
 	case ir.OCLOSURE:
+		arg := arg.(*ir.ClosureExpr)
 		callee = arg.Func()
 	default:
 		base.Fatalf("expected ONAME or OCLOSURE node, got %+v", arg)
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 3351cfe968..6510dfc4b3 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -678,6 +678,7 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 		}
 
 	case ir.OCLOSURE:
+		n := n.(*ir.ClosureExpr)
 		k = e.spill(k, n)
 
 		// Link addresses of captured variables to closure.
@@ -879,7 +880,7 @@ func (e *Escape) call(ks []EscHole, call, where ir.Node) {
 			case v.Op() == ir.ONAME && v.(*ir.Name).Class() == ir.PFUNC:
 				fn = v.(*ir.Name)
 			case v.Op() == ir.OCLOSURE:
-				fn = v.Func().Nname
+				fn = v.(*ir.ClosureExpr).Func().Nname
 			}
 		case ir.OCALLMETH:
 			fn = methodExprName(call.Left())
@@ -1883,7 +1884,7 @@ func heapAllocReason(n ir.Node) string {
 		return "too large for stack"
 	}
 
-	if n.Op() == ir.OCLOSURE && closureType(n).Size() >= maxImplicitStackVarSize {
+	if n.Op() == ir.OCLOSURE && closureType(n.(*ir.ClosureExpr)).Size() >= maxImplicitStackVarSize {
 		return "too large for stack"
 	}
 	if n.Op() == ir.OCALLPART && partialCallType(n.(*ir.CallPartExpr)).Size() >= maxImplicitStackVarSize {
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 358fdef294..5f72cedb66 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -630,7 +630,7 @@ func (r *importReader) varExt(n ir.Node) {
 	r.symIdx(n.Sym())
 }
 
-func (r *importReader) funcExt(n ir.Node) {
+func (r *importReader) funcExt(n *ir.Name) {
 	r.linkname(n.Sym())
 	r.symIdx(n.Sym())
 
@@ -654,7 +654,7 @@ func (r *importReader) methExt(m *types.Field) {
 	if r.bool() {
 		m.SetNointerface(true)
 	}
-	r.funcExt(ir.AsNode(m.Nname))
+	r.funcExt(m.Nname.(*ir.Name))
 }
 
 func (r *importReader) linkname(s *types.Sym) {
diff --git a/src/cmd/compile/internal/gc/initorder.go b/src/cmd/compile/internal/gc/initorder.go
index 1b21d92f4b..c9c3361d3c 100644
--- a/src/cmd/compile/internal/gc/initorder.go
+++ b/src/cmd/compile/internal/gc/initorder.go
@@ -296,6 +296,7 @@ func (d *initDeps) visit(n ir.Node) {
 		}
 
 	case ir.OCLOSURE:
+		n := n.(*ir.ClosureExpr)
 		d.inspectList(n.Func().Body())
 
 	case ir.ODOTMETH, ir.OCALLPART:
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index fde4d6910a..fc020000c7 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -237,7 +237,7 @@ func caninl(fn *ir.Func) {
 
 	n.Func().Inl = &ir.Inline{
 		Cost: inlineMaxBudget - visitor.budget,
-		Dcl:  pruneUnusedAutos(n.Defn.Func().Dcl, &visitor),
+		Dcl:  pruneUnusedAutos(n.Defn.(*ir.Func).Func().Dcl, &visitor),
 		Body: ir.DeepCopyList(src.NoXPos, fn.Body().Slice()),
 	}
 
@@ -677,6 +677,7 @@ func inlCallee(fn ir.Node) *ir.Func {
 			return fn.Func()
 		}
 	case ir.OCLOSURE:
+		fn := fn.(*ir.ClosureExpr)
 		c := fn.Func()
 		caninl(c)
 		return c
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 80b17ebbf8..94b4e0e674 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -270,9 +270,12 @@ func Main(archInit func(*Arch)) {
 	// before walk reaches a call of a closure.
 	timings.Start("fe", "xclosures")
 	for _, n := range Target.Decls {
-		if n.Op() == ir.ODCLFUNC && n.Func().OClosure != nil {
-			Curfn = n.(*ir.Func)
-			transformclosure(Curfn)
+		if n.Op() == ir.ODCLFUNC {
+			n := n.(*ir.Func)
+			if n.Func().OClosure != nil {
+				Curfn = n
+				transformclosure(n)
+			}
 		}
 	}
 
diff --git a/src/cmd/compile/internal/gc/scc.go b/src/cmd/compile/internal/gc/scc.go
index 6e63d5287a..8fe20a80fd 100644
--- a/src/cmd/compile/internal/gc/scc.go
+++ b/src/cmd/compile/internal/gc/scc.go
@@ -56,8 +56,11 @@ func visitBottomUp(list []ir.Node, analyze func(list []*ir.Func, recursive bool)
 	v.analyze = analyze
 	v.nodeID = make(map[*ir.Func]uint32)
 	for _, n := range list {
-		if n.Op() == ir.ODCLFUNC && !n.Func().IsHiddenClosure() {
-			v.visit(n.(*ir.Func))
+		if n.Op() == ir.ODCLFUNC {
+			n := n.(*ir.Func)
+			if !n.Func().IsHiddenClosure() {
+				v.visit(n)
+			}
 		}
 	}
 }
@@ -109,6 +112,7 @@ func (v *bottomUpVisitor) visit(n *ir.Func) uint32 {
 				}
 			}
 		case ir.OCLOSURE:
+			n := n.(*ir.ClosureExpr)
 			if m := v.visit(n.Func()); m < min {
 				min = m
 			}
diff --git a/src/cmd/compile/internal/gc/scope.go b/src/cmd/compile/internal/gc/scope.go
index fe4e1d185a..8dd44b1dd4 100644
--- a/src/cmd/compile/internal/gc/scope.go
+++ b/src/cmd/compile/internal/gc/scope.go
@@ -28,7 +28,7 @@ func findScope(marks []ir.Mark, pos src.XPos) ir.ScopeID {
 	return marks[i-1].Scope
 }
 
-func assembleScopes(fnsym *obj.LSym, fn ir.Node, dwarfVars []*dwarf.Var, varScopes []ir.ScopeID) []dwarf.Scope {
+func assembleScopes(fnsym *obj.LSym, fn *ir.Func, dwarfVars []*dwarf.Var, varScopes []ir.ScopeID) []dwarf.Scope {
 	// Initialize the DWARF scope tree based on lexical scopes.
 	dwarfScopes := make([]dwarf.Scope, 1+len(fn.Func().Parents))
 	for i, parent := range fn.Func().Parents {
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 9ef2bd56eb..79c7215d4d 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -269,6 +269,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 		break
 
 	case ir.OCLOSURE:
+		r := r.(*ir.ClosureExpr)
 		if hasemptycvars(r) {
 			if base.Debug.Closure > 0 {
 				base.WarnfAt(r.Pos(), "closure converted to global")
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index cc5df3ebae..bb658999e5 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -95,9 +95,12 @@ func TypecheckPackage() {
 	// because variables captured by value do not escape.
 	timings.Start("fe", "capturevars")
 	for _, n := range Target.Decls {
-		if n.Op() == ir.ODCLFUNC && n.Func().OClosure != nil {
-			Curfn = n.(*ir.Func)
-			capturevars(Curfn)
+		if n.Op() == ir.ODCLFUNC {
+			n := n.(*ir.Func)
+			if n.Func().OClosure != nil {
+				Curfn = n
+				capturevars(n)
+			}
 		}
 	}
 	capturevarscomplete = true
@@ -2078,6 +2081,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OCLOSURE:
+		n := n.(*ir.ClosureExpr)
 		typecheckclosure(n, top)
 		if n.Type() == nil {
 			return n
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 5545dcb345..87f08f41c3 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -649,11 +649,12 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			// transformclosure already did all preparation work.
 
 			// Prepend captured variables to argument list.
-			n.PtrList().Prepend(n.Left().Func().ClosureEnter.Slice()...)
-			n.Left().Func().ClosureEnter.Set(nil)
+			clo := n.Left().(*ir.ClosureExpr)
+			n.PtrList().Prepend(clo.Func().ClosureEnter.Slice()...)
+			clo.Func().ClosureEnter.Set(nil)
 
 			// Replace OCLOSURE with ONAME/PFUNC.
-			n.SetLeft(n.Left().Func().Nname)
+			n.SetLeft(clo.Func().Nname)
 
 			// Update type of OCALLFUNC node.
 			// Output arguments had not changed, but their offsets could.
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 6f15645813..76bb35f971 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -1189,6 +1189,7 @@ func dumpNode(w io.Writer, n Node, depth int) {
 	case ODCLFUNC:
 		// Func has many fields we don't want to print.
 		// Bypass reflection and just print what we want.
+		n := n.(*Func)
 		fmt.Fprintf(w, "%+v", n.Op())
 		dumpNodeHeader(w, n)
 		fn := n.Func()
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 8aa6daed6f..62ac5791d1 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -213,10 +213,21 @@ func (f *Func) SetWBPos(pos src.XPos) {
 
 // funcname returns the name (without the package) of the function n.
 func FuncName(n Node) string {
-	if n == nil || n.Func() == nil || n.Func().Nname == nil {
+	var f *Func
+	switch n := n.(type) {
+	case *Func:
+		f = n
+	case *Name:
+		f = n.Func()
+	case *CallPartExpr:
+		f = n.Func()
+	case *ClosureExpr:
+		f = n.Func()
+	}
+	if f == nil || f.Nname == nil {
 		return "<nil>"
 	}
-	return n.Func().Nname.Sym().Name
+	return f.Nname.Sym().Name
 }
 
 // pkgFuncName returns the name of the function referenced by n, with package prepended.
@@ -231,10 +242,19 @@ func PkgFuncName(n Node) string {
 	if n.Op() == ONAME {
 		s = n.Sym()
 	} else {
-		if n.Func() == nil || n.Func().Nname == nil {
+		var f *Func
+		switch n := n.(type) {
+		case *CallPartExpr:
+			f = n.Func()
+		case *ClosureExpr:
+			f = n.Func()
+		case *Func:
+			f = n
+		}
+		if f == nil || f.Nname == nil {
 			return "<nil>"
 		}
-		s = n.Func().Nname.Sym()
+		s = f.Nname.Sym()
 	}
 	pkg := s.Pkg
 
-- 
GitLab


From c40934b33d4d9f85ef5e891f8d26c3035ccce5bb Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 22 Dec 2020 00:07:40 -0500
Subject: [PATCH 0289/2400] [dev.regabi] cmd/compile: adjust one case in
 walkexpr

The mid-case n := n.(*ir.AssignExpr) does not lend itself
well to pulling the code into a new function, because n will
be a function argument and will not be redeclarable.

Change-Id: I673f2aa37eea64b083725326ed3fa36447bcc7af
Reviewed-on: https://go-review.googlesource.com/c/go/+/279426
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/walk.go | 38 ++++++++++++++---------------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 87f08f41c3..d5d12453a7 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -702,38 +702,38 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		} else {
 			n.(*ir.AssignStmt).SetLeft(left)
 		}
-		n := n.(*ir.AssignStmt)
+		as := n.(*ir.AssignStmt)
 
-		if oaslit(n, init) {
-			return ir.NodAt(n.Pos(), ir.OBLOCK, nil, nil)
+		if oaslit(as, init) {
+			return ir.NodAt(as.Pos(), ir.OBLOCK, nil, nil)
 		}
 
-		if n.Right() == nil {
+		if as.Right() == nil {
 			// TODO(austin): Check all "implicit zeroing"
-			return n
+			return as
 		}
 
-		if !instrumenting && isZero(n.Right()) {
-			return n
+		if !instrumenting && isZero(as.Right()) {
+			return as
 		}
 
-		switch n.Right().Op() {
+		switch as.Right().Op() {
 		default:
-			n.SetRight(walkexpr(n.Right(), init))
+			as.SetRight(walkexpr(as.Right(), init))
 
 		case ir.ORECV:
-			// x = <-c; n.Left is x, n.Right.Left is c.
+			// x = <-c; as.Left is x, as.Right.Left is c.
 			// order.stmt made sure x is addressable.
-			recv := n.Right().(*ir.UnaryExpr)
+			recv := as.Right().(*ir.UnaryExpr)
 			recv.SetLeft(walkexpr(recv.Left(), init))
 
-			n1 := nodAddr(n.Left())
+			n1 := nodAddr(as.Left())
 			r := recv.Left() // the channel
 			return mkcall1(chanfn("chanrecv1", 2, r.Type()), nil, init, r, n1)
 
 		case ir.OAPPEND:
 			// x = append(...)
-			call := n.Right().(*ir.CallExpr)
+			call := as.Right().(*ir.CallExpr)
 			if call.Type().Elem().NotInHeap() {
 				base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", call.Type().Elem())
 			}
@@ -745,24 +745,24 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			case call.IsDDD():
 				r = appendslice(call, init) // also works for append(slice, string).
 			default:
-				r = walkappend(call, init, n)
+				r = walkappend(call, init, as)
 			}
-			n.SetRight(r)
+			as.SetRight(r)
 			if r.Op() == ir.OAPPEND {
 				// Left in place for back end.
 				// Do not add a new write barrier.
 				// Set up address of type for back end.
 				r.(*ir.CallExpr).SetLeft(typename(r.Type().Elem()))
-				return n
+				return as
 			}
 			// Otherwise, lowered for race detector.
 			// Treat as ordinary assignment.
 		}
 
-		if n.Left() != nil && n.Right() != nil {
-			return convas(n, init)
+		if as.Left() != nil && as.Right() != nil {
+			return convas(as, init)
 		}
-		return n
+		return as
 
 	case ir.OAS2:
 		init.AppendNodes(n.PtrInit())
-- 
GitLab


From acc32ea124957ad4b097186fb2f6da8122a9a5d1 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 22 Dec 2020 15:59:09 -0500
Subject: [PATCH 0290/2400] [dev.regabi] codereview.cfg: add config for
 dev.regabi

Change-Id: Ida5cae7475bc19388fa46ceca25d983f560fa4e8
Reviewed-on: https://go-review.googlesource.com/c/go/+/279524
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 codereview.cfg | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 codereview.cfg

diff --git a/codereview.cfg b/codereview.cfg
new file mode 100644
index 0000000000..a23b0a00d1
--- /dev/null
+++ b/codereview.cfg
@@ -0,0 +1,2 @@
+branch: dev.regabi
+parent-branch: master
-- 
GitLab


From e02a007ffdd374f38bc9a1cbf1b80a81b666df5a Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 22 Dec 2020 15:31:58 -0500
Subject: [PATCH 0291/2400] [dev.typeparams] codereview.cfg: add config for
 dev.typeparams

The codereview command will start using this to figure out
the origin branch for commands like "git pending",
and it will use the parent setting for the new "git branch-sync" (merge).

Change-Id: Ia74af18ae5a437fb45ea81d7d69e2ffe41987b64
Reviewed-on: https://go-review.googlesource.com/c/go/+/279523
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 codereview.cfg | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 codereview.cfg

diff --git a/codereview.cfg b/codereview.cfg
new file mode 100644
index 0000000000..d21d2ff61f
--- /dev/null
+++ b/codereview.cfg
@@ -0,0 +1,2 @@
+branch: dev.typeparams
+parent-branch: dev.regabi
-- 
GitLab


From d1d1099c917de7387db9c9435e35ff14c4a63a91 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 22 Dec 2020 17:22:28 -0500
Subject: [PATCH 0292/2400] [dev.regabi] cmd/compile: fixes for big rewrite

Adjust the new regabi code a bit to make the rewrites apply cleanly.

Change-Id: Ice5378e94d94ab45ca0572f44ab8c94b847271b8
Reviewed-on: https://go-review.googlesource.com/c/go/+/279530
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/gsubr.go | 11 ++++++-----
 src/cmd/compile/internal/gc/ssa.go   | 10 ++++++----
 2 files changed, 12 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go
index f3ef14c99b..aa498a0097 100644
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ b/src/cmd/compile/internal/gc/gsubr.go
@@ -265,20 +265,21 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 	// to allocate any stack space). Doing this will require some
 	// extra work in typecheck/walk/ssa, might want to add a new node
 	// OTAILCALL or something to this effect.
-	var call ir.Node
+	var tail ir.Node
 	if tfn.Type().NumResults() == 0 && tfn.Type().NumParams() == 0 && tfn.Type().NumRecvs() == 0 {
-		call = nodSym(ir.ORETJMP, nil, f.Nname.Sym())
+		tail = nodSym(ir.ORETJMP, nil, f.Nname.Sym())
 	} else {
-		call = ir.Nod(ir.OCALL, f.Nname, nil)
+		call := ir.Nod(ir.OCALL, f.Nname, nil)
 		call.PtrList().Set(paramNnames(tfn.Type()))
 		call.SetIsDDD(tfn.Type().IsVariadic())
+		tail = call
 		if tfn.Type().NumResults() > 0 {
 			n := ir.Nod(ir.ORETURN, nil, nil)
 			n.PtrList().Set1(call)
-			call = n
+			tail = n
 		}
 	}
-	fn.PtrBody().Append(call)
+	fn.PtrBody().Append(tail)
 
 	funcbody()
 	if base.Debug.DclStack != 0 {
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 1fc1feae67..cc5f9eeea6 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -7332,18 +7332,20 @@ func callTargetLSym(callee *types.Sym, callerLSym *obj.LSym) *obj.LSym {
 	if ir.AsNode(callee.Def) == nil {
 		return lsym
 	}
-	ndclfunc := ir.AsNode(callee.Def).Name().Defn
-	if ndclfunc == nil {
+	defn := ir.AsNode(callee.Def).Name().Defn
+	if defn == nil {
 		return lsym
 	}
+	ndclfunc := defn.(*ir.Func)
+
 	// check for case 1 above
 	if callerLSym.ABIWrapper() {
-		if nlsym := ndclfunc.Func().LSym; nlsym != nil {
+		if nlsym := ndclfunc.LSym; nlsym != nil {
 			lsym = nlsym
 		}
 	} else {
 		// check for case 2 above
-		nam := ndclfunc.Func().Nname
+		nam := ndclfunc.Nname
 		defABI, hasDefABI := symabiDefs[nam.Sym().LinksymName()]
 		if hasDefABI && defABI == obj.ABI0 {
 			lsym = nam.Sym().LinksymABI0()
-- 
GitLab


From 788dad53c5934f43e5be451d4a9b3f1cd75c7123 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 22 Dec 2020 17:12:49 -0500
Subject: [PATCH 0293/2400] [dev.typeparams] cmd/compile/internal/types2:
 disable external test temporarily

This is making rf unhappy for extremely subtle reasons,
so for now just disable the external test here. Will reenable
once the big rewrite is done.

Change-Id: Ifd1ba95e2843792427629d1660850fe531cdd0b9
Reviewed-on: https://go-review.googlesource.com/c/go/+/279531
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/types2/api_test.go        | 2 ++
 src/cmd/compile/internal/types2/builtins_test.go   | 2 ++
 src/cmd/compile/internal/types2/check_test.go      | 2 ++
 src/cmd/compile/internal/types2/example_test.go    | 2 ++
 src/cmd/compile/internal/types2/exprstring_test.go | 2 ++
 src/cmd/compile/internal/types2/hilbert_test.go    | 2 ++
 src/cmd/compile/internal/types2/importer_test.go   | 2 ++
 src/cmd/compile/internal/types2/issues_test.go     | 2 ++
 src/cmd/compile/internal/types2/resolver_test.go   | 2 ++
 src/cmd/compile/internal/types2/self_test.go       | 2 ++
 src/cmd/compile/internal/types2/sizes_test.go      | 2 ++
 src/cmd/compile/internal/types2/stdlib_test.go     | 2 ++
 src/cmd/compile/internal/types2/typestring_test.go | 2 ++
 13 files changed, 26 insertions(+)

diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go
index 58d7df2f1d..bda34fef1d 100644
--- a/src/cmd/compile/internal/types2/api_test.go
+++ b/src/cmd/compile/internal/types2/api_test.go
@@ -1,3 +1,5 @@
+// +build TODO_RSC_REMOVE_THIS
+
 // UNREVIEWED
 // Copyright 2013 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/src/cmd/compile/internal/types2/builtins_test.go b/src/cmd/compile/internal/types2/builtins_test.go
index 9f737bc9bb..b988b0d509 100644
--- a/src/cmd/compile/internal/types2/builtins_test.go
+++ b/src/cmd/compile/internal/types2/builtins_test.go
@@ -1,3 +1,5 @@
+// +build TODO_RSC_REMOVE_THIS
+
 // UNREVIEWED
 // Copyright 2013 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/src/cmd/compile/internal/types2/check_test.go b/src/cmd/compile/internal/types2/check_test.go
index 85bf0728c0..26144441e6 100644
--- a/src/cmd/compile/internal/types2/check_test.go
+++ b/src/cmd/compile/internal/types2/check_test.go
@@ -1,3 +1,5 @@
+// +build TODO_RSC_REMOVE_THIS
+
 // UNREVIEWED
 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/src/cmd/compile/internal/types2/example_test.go b/src/cmd/compile/internal/types2/example_test.go
index dcdeaca0c0..9ff3536746 100644
--- a/src/cmd/compile/internal/types2/example_test.go
+++ b/src/cmd/compile/internal/types2/example_test.go
@@ -1,3 +1,5 @@
+// +build TODO_RSC_REMOVE_THIS
+
 // UNREVIEWED
 // Copyright 2015 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/src/cmd/compile/internal/types2/exprstring_test.go b/src/cmd/compile/internal/types2/exprstring_test.go
index efb7c308b7..bccaa84f32 100644
--- a/src/cmd/compile/internal/types2/exprstring_test.go
+++ b/src/cmd/compile/internal/types2/exprstring_test.go
@@ -1,3 +1,5 @@
+// +build TODO_RSC_REMOVE_THIS
+
 // UNREVIEWED
 // Copyright 2013 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/src/cmd/compile/internal/types2/hilbert_test.go b/src/cmd/compile/internal/types2/hilbert_test.go
index 9f9dad6b64..b2b8257487 100644
--- a/src/cmd/compile/internal/types2/hilbert_test.go
+++ b/src/cmd/compile/internal/types2/hilbert_test.go
@@ -1,3 +1,5 @@
+// +build TODO_RSC_REMOVE_THIS
+
 // Copyright 2013 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.
diff --git a/src/cmd/compile/internal/types2/importer_test.go b/src/cmd/compile/internal/types2/importer_test.go
index 90476c4269..0d6c2f1d46 100644
--- a/src/cmd/compile/internal/types2/importer_test.go
+++ b/src/cmd/compile/internal/types2/importer_test.go
@@ -1,3 +1,5 @@
+// +build TODO_RSC_REMOVE_THIS
+
 // UNREVIEWED
 // Copyright 2020 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/src/cmd/compile/internal/types2/issues_test.go b/src/cmd/compile/internal/types2/issues_test.go
index f33b7c4396..e184200a1a 100644
--- a/src/cmd/compile/internal/types2/issues_test.go
+++ b/src/cmd/compile/internal/types2/issues_test.go
@@ -1,3 +1,5 @@
+// +build TODO_RSC_REMOVE_THIS
+
 // UNREVIEWED
 // Copyright 2013 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/src/cmd/compile/internal/types2/resolver_test.go b/src/cmd/compile/internal/types2/resolver_test.go
index cdfdba6b43..e939c677ee 100644
--- a/src/cmd/compile/internal/types2/resolver_test.go
+++ b/src/cmd/compile/internal/types2/resolver_test.go
@@ -1,3 +1,5 @@
+// +build TODO_RSC_REMOVE_THIS
+
 // UNREVIEWED
 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/src/cmd/compile/internal/types2/self_test.go b/src/cmd/compile/internal/types2/self_test.go
index 6d7971e50f..b03dc7f33a 100644
--- a/src/cmd/compile/internal/types2/self_test.go
+++ b/src/cmd/compile/internal/types2/self_test.go
@@ -1,3 +1,5 @@
+// +build TODO_RSC_REMOVE_THIS
+
 // UNREVIEWED
 // Copyright 2013 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/src/cmd/compile/internal/types2/sizes_test.go b/src/cmd/compile/internal/types2/sizes_test.go
index b246909d2a..f6d37a31ab 100644
--- a/src/cmd/compile/internal/types2/sizes_test.go
+++ b/src/cmd/compile/internal/types2/sizes_test.go
@@ -1,3 +1,5 @@
+// +build TODO_RSC_REMOVE_THIS
+
 // UNREVIEWED
 // Copyright 2016 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/src/cmd/compile/internal/types2/stdlib_test.go b/src/cmd/compile/internal/types2/stdlib_test.go
index ae573a4ec8..5ab24df776 100644
--- a/src/cmd/compile/internal/types2/stdlib_test.go
+++ b/src/cmd/compile/internal/types2/stdlib_test.go
@@ -1,3 +1,5 @@
+// +build TODO_RSC_REMOVE_THIS
+
 // UNREVIEWED
 // Copyright 2013 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/src/cmd/compile/internal/types2/typestring_test.go b/src/cmd/compile/internal/types2/typestring_test.go
index f1f7e34bf8..b9e593be72 100644
--- a/src/cmd/compile/internal/types2/typestring_test.go
+++ b/src/cmd/compile/internal/types2/typestring_test.go
@@ -1,3 +1,5 @@
+// +build TODO_RSC_REMOVE_THIS
+
 // UNREVIEWED
 // Copyright 2012 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
-- 
GitLab


From 6d03cde88a0599bd0a8d6cb1e5b08c5d0a06020a Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 22 Dec 2020 19:32:57 -0800
Subject: [PATCH 0294/2400] [dev.regabi] cmd/dist: automatically bootstrap cmd
 subdirs

We want almost all cmd subdirectories anyway, and relative to the cost
of the rest of toolchain bootstrapping, copying/rewriting a few extra
source files is way cheaper than the engineering cost of forgetting to
maintain these lists as we split out new packages.

While here, also add cmd/internal/archive (and make it compile with Go
1.4) because it'll be needed in subsequent refactorings anyway; and
skip files starting with # (emacs temporary files) and test files
ending with _test.go.

Change-Id: Ic86e680a5fdfaecd617c36d5d04413293b2d6f52
Reviewed-on: https://go-review.googlesource.com/c/go/+/279832
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Russ Cox <rsc@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/dist/buildtool.go           | 113 +++++++++++-----------------
 src/cmd/internal/archive/archive.go |  10 +--
 2 files changed, 49 insertions(+), 74 deletions(-)

diff --git a/src/cmd/dist/buildtool.go b/src/cmd/dist/buildtool.go
index 5e1647cbf0..eb8729149c 100644
--- a/src/cmd/dist/buildtool.go
+++ b/src/cmd/dist/buildtool.go
@@ -23,78 +23,35 @@ import (
 // compiled with a Go 1.4 toolchain to produce the bootstrapTargets.
 // All directories in this list are relative to and must be below $GOROOT/src.
 //
-// The list has have two kinds of entries: names beginning with cmd/ with
+// The list has two kinds of entries: names beginning with cmd/ with
 // no other slashes, which are commands, and other paths, which are packages
 // supporting the commands. Packages in the standard library can be listed
 // if a newer copy needs to be substituted for the Go 1.4 copy when used
-// by the command packages.
+// by the command packages. Paths ending with /... automatically
+// include all packages within subdirectories as well.
 // These will be imported during bootstrap as bootstrap/name, like bootstrap/math/big.
 var bootstrapDirs = []string{
 	"cmd/asm",
-	"cmd/asm/internal/arch",
-	"cmd/asm/internal/asm",
-	"cmd/asm/internal/flags",
-	"cmd/asm/internal/lex",
+	"cmd/asm/internal/...",
 	"cmd/cgo",
 	"cmd/compile",
-	"cmd/compile/internal/amd64",
-	"cmd/compile/internal/base",
-	"cmd/compile/internal/arm",
-	"cmd/compile/internal/arm64",
-	"cmd/compile/internal/gc",
-	"cmd/compile/internal/ir",
-	"cmd/compile/internal/logopt",
-	"cmd/compile/internal/mips",
-	"cmd/compile/internal/mips64",
-	"cmd/compile/internal/ppc64",
-	"cmd/compile/internal/riscv64",
-	"cmd/compile/internal/s390x",
-	"cmd/compile/internal/ssa",
-	"cmd/compile/internal/syntax",
-	"cmd/compile/internal/types",
-	"cmd/compile/internal/x86",
-	"cmd/compile/internal/wasm",
+	"cmd/compile/internal/...",
+	"cmd/internal/archive",
 	"cmd/internal/bio",
 	"cmd/internal/codesign",
-	"cmd/internal/gcprog",
 	"cmd/internal/dwarf",
 	"cmd/internal/edit",
+	"cmd/internal/gcprog",
 	"cmd/internal/goobj",
+	"cmd/internal/obj/...",
 	"cmd/internal/objabi",
-	"cmd/internal/obj",
-	"cmd/internal/obj/arm",
-	"cmd/internal/obj/arm64",
-	"cmd/internal/obj/mips",
-	"cmd/internal/obj/ppc64",
-	"cmd/internal/obj/riscv",
-	"cmd/internal/obj/s390x",
-	"cmd/internal/obj/x86",
-	"cmd/internal/obj/wasm",
 	"cmd/internal/pkgpath",
 	"cmd/internal/src",
 	"cmd/internal/sys",
 	"cmd/link",
-	"cmd/link/internal/amd64",
-	"cmd/compile/internal/base",
-	"cmd/link/internal/arm",
-	"cmd/link/internal/arm64",
-	"cmd/link/internal/benchmark",
-	"cmd/link/internal/ld",
-	"cmd/link/internal/loadelf",
-	"cmd/link/internal/loader",
-	"cmd/link/internal/loadmacho",
-	"cmd/link/internal/loadpe",
-	"cmd/link/internal/loadxcoff",
-	"cmd/link/internal/mips",
-	"cmd/link/internal/mips64",
-	"cmd/link/internal/ppc64",
-	"cmd/link/internal/riscv64",
-	"cmd/link/internal/s390x",
-	"cmd/link/internal/sym",
-	"cmd/link/internal/x86",
+	"cmd/link/internal/...",
 	"compress/flate",
 	"compress/zlib",
-	"cmd/link/internal/wasm",
 	"container/heap",
 	"debug/dwarf",
 	"debug/elf",
@@ -116,6 +73,7 @@ var bootstrapDirs = []string{
 var ignorePrefixes = []string{
 	".",
 	"_",
+	"#",
 }
 
 // File suffixes that use build tags introduced since Go 1.4.
@@ -129,6 +87,7 @@ var ignoreSuffixes = []string{
 	"_wasm.s",
 	"_wasm.go",
 	"_test.s",
+	"_test.go",
 }
 
 func bootstrapBuildTools() {
@@ -154,31 +113,47 @@ func bootstrapBuildTools() {
 	// Copy source code into $GOROOT/pkg/bootstrap and rewrite import paths.
 	writefile("module bootstrap\n", pathf("%s/%s", base, "go.mod"), 0)
 	for _, dir := range bootstrapDirs {
-		src := pathf("%s/src/%s", goroot, dir)
-		dst := pathf("%s/%s", base, dir)
-		xmkdirall(dst)
-		if dir == "cmd/cgo" {
-			// Write to src because we need the file both for bootstrap
-			// and for later in the main build.
-			mkzdefaultcc("", pathf("%s/zdefaultcc.go", src))
-		}
-	Dir:
-		for _, name := range xreaddirfiles(src) {
+		recurse := strings.HasSuffix(dir, "/...")
+		dir = strings.TrimSuffix(dir, "/...")
+		filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
+			if err != nil {
+				fatalf("walking bootstrap dirs failed: %v: %v", path, err)
+			}
+
+			name := filepath.Base(path)
+			src := pathf("%s/src/%s", goroot, path)
+			dst := pathf("%s/%s", base, path)
+
+			if info.IsDir() {
+				if !recurse && path != dir || name == "testdata" {
+					return filepath.SkipDir
+				}
+
+				xmkdirall(dst)
+				if path == "cmd/cgo" {
+					// Write to src because we need the file both for bootstrap
+					// and for later in the main build.
+					mkzdefaultcc("", pathf("%s/zdefaultcc.go", src))
+					mkzdefaultcc("", pathf("%s/zdefaultcc.go", dst))
+				}
+				return nil
+			}
+
 			for _, pre := range ignorePrefixes {
 				if strings.HasPrefix(name, pre) {
-					continue Dir
+					return nil
 				}
 			}
 			for _, suf := range ignoreSuffixes {
 				if strings.HasSuffix(name, suf) {
-					continue Dir
+					return nil
 				}
 			}
-			srcFile := pathf("%s/%s", src, name)
-			dstFile := pathf("%s/%s", dst, name)
-			text := bootstrapRewriteFile(srcFile)
-			writefile(text, dstFile, 0)
-		}
+
+			text := bootstrapRewriteFile(src)
+			writefile(text, dst, 0)
+			return nil
+		})
 	}
 
 	// Set up environment for invoking Go 1.4 go command.
diff --git a/src/cmd/internal/archive/archive.go b/src/cmd/internal/archive/archive.go
index c1661d7711..762e888a04 100644
--- a/src/cmd/internal/archive/archive.go
+++ b/src/cmd/internal/archive/archive.go
@@ -118,9 +118,9 @@ type objReader struct {
 
 func (r *objReader) init(f *os.File) {
 	r.a = &Archive{f, nil}
-	r.offset, _ = f.Seek(0, io.SeekCurrent)
-	r.limit, _ = f.Seek(0, io.SeekEnd)
-	f.Seek(r.offset, io.SeekStart)
+	r.offset, _ = f.Seek(0, os.SEEK_CUR)
+	r.limit, _ = f.Seek(0, os.SEEK_END)
+	f.Seek(r.offset, os.SEEK_SET)
 	r.b = bio.NewReader(f)
 }
 
@@ -221,7 +221,7 @@ func (r *objReader) skip(n int64) {
 		r.readFull(r.tmp[:n])
 	} else {
 		// Seek, giving up buffered data.
-		r.b.MustSeek(r.offset+n, io.SeekStart)
+		r.b.MustSeek(r.offset+n, os.SEEK_SET)
 		r.offset += n
 	}
 }
@@ -426,7 +426,7 @@ func (r *objReader) parseObject(o *GoObj, size int64) error {
 
 // AddEntry adds an entry to the end of a, with the content from r.
 func (a *Archive) AddEntry(typ EntryType, name string, mtime int64, uid, gid int, mode os.FileMode, size int64, r io.Reader) {
-	off, err := a.f.Seek(0, io.SeekEnd)
+	off, err := a.f.Seek(0, os.SEEK_END)
 	if err != nil {
 		log.Fatal(err)
 	}
-- 
GitLab


From 69cf39089f3e5e6e5356c90c1bd8f30f76658bd0 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 22 Dec 2020 23:46:07 -0500
Subject: [PATCH 0295/2400] [dev.regabi] cmd/compile: do not die in early
 base.FlushErrors

Change-Id: I72bac8a85db14494298059f8efddc5cbbf45f7ca
Reviewed-on: https://go-review.googlesource.com/c/go/+/279214
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/base/print.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/base/print.go b/src/cmd/compile/internal/base/print.go
index 6831b3ada3..ac7333ca4e 100644
--- a/src/cmd/compile/internal/base/print.go
+++ b/src/cmd/compile/internal/base/print.go
@@ -73,7 +73,9 @@ func (x byPos) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
 // FlushErrors sorts errors seen so far by line number, prints them to stdout,
 // and empties the errors array.
 func FlushErrors() {
-	Ctxt.Bso.Flush()
+	if Ctxt != nil && Ctxt.Bso != nil {
+		Ctxt.Bso.Flush()
+	}
 	if len(errorMsgs) == 0 {
 		return
 	}
-- 
GitLab


From 6f27d29be0b22e0e5e77972d00d24ef3d6d5fd49 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 22 Dec 2020 23:55:29 -0500
Subject: [PATCH 0296/2400] [dev.regabi] cmd/compile: remove ir.Nod [generated]

Rewrite all uses of ir.Nod and friends to call the IR constructors directly.
This gives the results a more specific type and will play nicely with
introduction of more specific types throughout the code in a followup CL.

Passes buildall w/ toolstash -cmp.

[git-generate]
cd src/cmd/compile/internal/gc
rf '
ex . ../ir {
	import "cmd/compile/internal/ir"
	import "cmd/compile/internal/types"
	import "cmd/compile/internal/syntax"
	import "cmd/internal/src"

	var p *noder
	var orig syntax.Node
	var op ir.Op
	var l, r ir.Node
	var sym *types.Sym
	p.nod(orig, op, l, r) -> ir.NodAt(p.pos(orig), op, l, r)
	p.nodSym(orig, op, l, sym) -> nodlSym(p.pos(orig), op, l, sym)

	var xpos src.XPos
	var ns ir.Nodes
	npos(xpos, nodSym(op, l, sym)) -> nodlSym(xpos, op, l, sym)
	npos(xpos, liststmt(ns)) -> ir.NewBlockStmt(xpos, ns)
}
ex . ../ir {
	import "cmd/compile/internal/base"
	import "cmd/compile/internal/ir"
	import "cmd/compile/internal/types"

	var op ir.Op
	var l, r ir.Node
	ir.Nod(op, l, r) -> ir.NodAt(base.Pos, op, l, r)

	var sym *types.Sym
	nodSym(op, l, sym) -> nodlSym(base.Pos, op, l, sym)
}
ex . ../ir {
	import "cmd/compile/internal/ir"
	import "cmd/internal/src"

	# rf overlapping match handling is not quite good enough
	# for certain nested rewrites, so handle these two - which often contain other ir.NodAt calls - early.
	var l, r ir.Node
	var xpos src.XPos
	ir.NodAt(xpos, ir.OAS, l, r)              -> ir.NewAssignStmt(xpos, l, r)
	ir.NodAt(xpos, ir.OIF, l, nil)            -> ir.NewIfStmt(xpos, l, nil, nil)
}
ex . ../ir {
	import "cmd/compile/internal/ir"
	import "cmd/compile/internal/types"
	import "cmd/internal/src"

	var l, r ir.Node
	var sym *types.Sym
	var xpos src.XPos

	nodlSym(xpos, ir.ODOT, l, sym)                   -> ir.NewSelectorExpr(xpos, ir.ODOT, l, sym)
	nodlSym(xpos, ir.OXDOT, l, sym)                  -> ir.NewSelectorExpr(xpos, ir.OXDOT, l, sym)
	nodlSym(xpos, ir.ODOTPTR, l, sym)                -> ir.NewSelectorExpr(xpos, ir.ODOTPTR, l, sym)
	nodlSym(xpos, ir.OGOTO, nil, sym)                -> ir.NewBranchStmt(xpos, ir.OGOTO, sym)
	nodlSym(xpos, ir.ORETJMP, nil, sym)              -> ir.NewBranchStmt(xpos, ir.ORETJMP, sym)
	nodlSym(xpos, ir.OLABEL, nil, sym)               -> ir.NewLabelStmt(xpos, sym)
	nodlSym(xpos, ir.OSTRUCTKEY, l, sym)             -> ir.NewStructKeyExpr(xpos, sym, l)

	ir.NodAt(xpos, ir.OADD, l, r)             -> ir.NewBinaryExpr(xpos, ir.OADD, l, r)
	ir.NodAt(xpos, ir.OAND, l, r)             -> ir.NewBinaryExpr(xpos, ir.OAND, l, r)
	ir.NodAt(xpos, ir.OANDNOT, l, r)          -> ir.NewBinaryExpr(xpos, ir.OANDNOT, l, r)
	ir.NodAt(xpos, ir.ODIV, l, r)             -> ir.NewBinaryExpr(xpos, ir.ODIV, l, r)
	ir.NodAt(xpos, ir.OEQ, l, r)              -> ir.NewBinaryExpr(xpos, ir.OEQ, l, r)
	ir.NodAt(xpos, ir.OGE, l, r)              -> ir.NewBinaryExpr(xpos, ir.OGE, l, r)
	ir.NodAt(xpos, ir.OGT, l, r)              -> ir.NewBinaryExpr(xpos, ir.OGT, l, r)
	ir.NodAt(xpos, ir.OLE, l, r)              -> ir.NewBinaryExpr(xpos, ir.OLE, l, r)
	ir.NodAt(xpos, ir.OLSH, l, r)             -> ir.NewBinaryExpr(xpos, ir.OLSH, l, r)
	ir.NodAt(xpos, ir.OLT, l, r)              -> ir.NewBinaryExpr(xpos, ir.OLT, l, r)
	ir.NodAt(xpos, ir.OMOD, l, r)             -> ir.NewBinaryExpr(xpos, ir.OMOD, l, r)
	ir.NodAt(xpos, ir.OMUL, l, r)             -> ir.NewBinaryExpr(xpos, ir.OMUL, l, r)
	ir.NodAt(xpos, ir.ONE, l, r)              -> ir.NewBinaryExpr(xpos, ir.ONE, l, r)
	ir.NodAt(xpos, ir.OOR, l, r)              -> ir.NewBinaryExpr(xpos, ir.OOR, l, r)
	ir.NodAt(xpos, ir.ORSH, l, r)             -> ir.NewBinaryExpr(xpos, ir.ORSH, l, r)
	ir.NodAt(xpos, ir.OSUB, l, r)             -> ir.NewBinaryExpr(xpos, ir.OSUB, l, r)
	ir.NodAt(xpos, ir.OXOR, l, r)             -> ir.NewBinaryExpr(xpos, ir.OXOR, l, r)
	ir.NodAt(xpos, ir.OCOPY, l, r)            -> ir.NewBinaryExpr(xpos, ir.OCOPY, l, r)
	ir.NodAt(xpos, ir.OCOMPLEX, l, r)         -> ir.NewBinaryExpr(xpos, ir.OCOMPLEX, l, r)
	ir.NodAt(xpos, ir.OEFACE, l, r)           -> ir.NewBinaryExpr(xpos, ir.OEFACE, l, r)
	ir.NodAt(xpos, ir.OADDR, l, nil)          -> ir.NewAddrExpr(xpos, l)
	ir.NodAt(xpos, ir.OADDSTR, nil, nil)      -> ir.NewAddStringExpr(xpos, nil)
	ir.NodAt(xpos, ir.OANDAND, l, r)          -> ir.NewLogicalExpr(xpos, ir.OANDAND, l, r)
	ir.NodAt(xpos, ir.OOROR, l, r)            -> ir.NewLogicalExpr(xpos, ir.OOROR, l, r)
	ir.NodAt(xpos, ir.OARRAYLIT, nil, nil)    -> ir.NewCompLitExpr(xpos, ir.OARRAYLIT, nil, nil)
	ir.NodAt(xpos, ir.OCOMPLIT, nil, nil)     -> ir.NewCompLitExpr(xpos, ir.OCOMPLIT, nil, nil)
	ir.NodAt(xpos, ir.OMAPLIT, nil, nil)      -> ir.NewCompLitExpr(xpos, ir.OMAPLIT, nil, nil)
	ir.NodAt(xpos, ir.OSTRUCTLIT, nil, nil)   -> ir.NewCompLitExpr(xpos, ir.OSTRUCTLIT, nil, nil)
	ir.NodAt(xpos, ir.OSLICELIT, nil, nil)    -> ir.NewCompLitExpr(xpos, ir.OSLICELIT, nil, nil)
	ir.NodAt(xpos, ir.OARRAYLIT, nil, r)      -> ir.NewCompLitExpr(xpos, ir.OARRAYLIT, r.(ir.Ntype), nil)
	ir.NodAt(xpos, ir.OCOMPLIT, nil, r)       -> ir.NewCompLitExpr(xpos, ir.OCOMPLIT, r.(ir.Ntype), nil)
	ir.NodAt(xpos, ir.OMAPLIT, nil, r)        -> ir.NewCompLitExpr(xpos, ir.OMAPLIT, r.(ir.Ntype), nil)
	ir.NodAt(xpos, ir.OSTRUCTLIT, nil, r)     -> ir.NewCompLitExpr(xpos, ir.OSTRUCTLIT, r.(ir.Ntype), nil)
	ir.NodAt(xpos, ir.OSLICELIT, nil, r)      -> ir.NewCompLitExpr(xpos, ir.OSLICELIT, r.(ir.Ntype), nil)
	ir.NodAt(xpos, ir.OAS2, nil, nil)         -> ir.NewAssignListStmt(xpos, ir.OAS2, nil, nil)
	ir.NodAt(xpos, ir.OAS2DOTTYPE, nil, nil)  -> ir.NewAssignListStmt(xpos, ir.OAS2DOTTYPE, nil, nil)
	ir.NodAt(xpos, ir.OAS2FUNC, nil, nil)     -> ir.NewAssignListStmt(xpos, ir.OAS2FUNC, nil, nil)
	ir.NodAt(xpos, ir.OAS2MAPR, nil, nil)     -> ir.NewAssignListStmt(xpos, ir.OAS2MAPR, nil, nil)
	ir.NodAt(xpos, ir.OAS2RECV, nil, nil)     -> ir.NewAssignListStmt(xpos, ir.OAS2RECV, nil, nil)
	ir.NodAt(xpos, ir.OSELRECV2, nil, nil)    -> ir.NewAssignListStmt(xpos, ir.OSELRECV2, nil, nil)
	ir.NodAt(xpos, ir.OASOP, l, r)            -> ir.NewAssignOpStmt(xpos, ir.OXXX, l, r)
	ir.NodAt(xpos, ir.OBITNOT, l, nil)        -> ir.NewUnaryExpr(xpos, ir.OBITNOT, l)
	ir.NodAt(xpos, ir.ONEG, l, nil)           -> ir.NewUnaryExpr(xpos, ir.ONEG, l)
	ir.NodAt(xpos, ir.ONOT, l, nil)           -> ir.NewUnaryExpr(xpos, ir.ONOT, l)
	ir.NodAt(xpos, ir.OPLUS, l, nil)          -> ir.NewUnaryExpr(xpos, ir.OPLUS, l)
	ir.NodAt(xpos, ir.ORECV, l, nil)          -> ir.NewUnaryExpr(xpos, ir.ORECV, l)
	ir.NodAt(xpos, ir.OALIGNOF, l, nil)       -> ir.NewUnaryExpr(xpos, ir.OALIGNOF, l)
	ir.NodAt(xpos, ir.OCAP, l, nil)           -> ir.NewUnaryExpr(xpos, ir.OCAP, l)
	ir.NodAt(xpos, ir.OCLOSE, l, nil)         -> ir.NewUnaryExpr(xpos, ir.OCLOSE, l)
	ir.NodAt(xpos, ir.OIMAG, l, nil)          -> ir.NewUnaryExpr(xpos, ir.OIMAG, l)
	ir.NodAt(xpos, ir.OLEN, l, nil)           -> ir.NewUnaryExpr(xpos, ir.OLEN, l)
	ir.NodAt(xpos, ir.ONEW, l, nil)           -> ir.NewUnaryExpr(xpos, ir.ONEW, l)
	ir.NodAt(xpos, ir.ONEWOBJ, l, nil)        -> ir.NewUnaryExpr(xpos, ir.ONEWOBJ, l)
	ir.NodAt(xpos, ir.OOFFSETOF, l, nil)      -> ir.NewUnaryExpr(xpos, ir.OOFFSETOF, l)
	ir.NodAt(xpos, ir.OPANIC, l, nil)         -> ir.NewUnaryExpr(xpos, ir.OPANIC, l)
	ir.NodAt(xpos, ir.OREAL, l, nil)          -> ir.NewUnaryExpr(xpos, ir.OREAL, l)
	ir.NodAt(xpos, ir.OSIZEOF, l, nil)        -> ir.NewUnaryExpr(xpos, ir.OSIZEOF, l)
	ir.NodAt(xpos, ir.OCHECKNIL, l, nil)      -> ir.NewUnaryExpr(xpos, ir.OCHECKNIL, l)
	ir.NodAt(xpos, ir.OCFUNC, l, nil)         -> ir.NewUnaryExpr(xpos, ir.OCFUNC, l)
	ir.NodAt(xpos, ir.OIDATA, l, nil)         -> ir.NewUnaryExpr(xpos, ir.OIDATA, l)
	ir.NodAt(xpos, ir.OITAB, l, nil)          -> ir.NewUnaryExpr(xpos, ir.OITAB, l)
	ir.NodAt(xpos, ir.OSPTR, l, nil)          -> ir.NewUnaryExpr(xpos, ir.OSPTR, l)
	ir.NodAt(xpos, ir.OVARDEF, l, nil)        -> ir.NewUnaryExpr(xpos, ir.OVARDEF, l)
	ir.NodAt(xpos, ir.OVARKILL, l, nil)       -> ir.NewUnaryExpr(xpos, ir.OVARKILL, l)
	ir.NodAt(xpos, ir.OVARLIVE, l, nil)       -> ir.NewUnaryExpr(xpos, ir.OVARLIVE, l)
	ir.NodAt(xpos, ir.OBLOCK, nil, nil)       -> ir.NewBlockStmt(xpos, nil)
	ir.NodAt(xpos, ir.OBREAK, nil, nil)       -> ir.NewBranchStmt(xpos, ir.OBREAK, nil)
	ir.NodAt(xpos, ir.OCONTINUE, nil, nil)    -> ir.NewBranchStmt(xpos, ir.OCONTINUE, nil)
	ir.NodAt(xpos, ir.OFALL, nil, nil)        -> ir.NewBranchStmt(xpos, ir.OFALL, nil)
	ir.NodAt(xpos, ir.OGOTO, nil, nil)        -> ir.NewBranchStmt(xpos, ir.OGOTO, nil)
	ir.NodAt(xpos, ir.ORETJMP, nil, nil)      -> ir.NewBranchStmt(xpos, ir.ORETJMP, nil)
	ir.NodAt(xpos, ir.OCALL, l, nil)          -> ir.NewCallExpr(xpos, ir.OCALL, l, nil)
	ir.NodAt(xpos, ir.OCALLFUNC, l, nil)      -> ir.NewCallExpr(xpos, ir.OCALLFUNC, l, nil)
	ir.NodAt(xpos, ir.OCALLINTER, l, nil)     -> ir.NewCallExpr(xpos, ir.OCALLINTER, l, nil)
	ir.NodAt(xpos, ir.OCALLMETH, l, nil)      -> ir.NewCallExpr(xpos, ir.OCALLMETH, l, nil)
	ir.NodAt(xpos, ir.OAPPEND, l, nil)        -> ir.NewCallExpr(xpos, ir.OAPPEND, l, nil)
	ir.NodAt(xpos, ir.ODELETE, l, nil)        -> ir.NewCallExpr(xpos, ir.ODELETE, l, nil)
	ir.NodAt(xpos, ir.OGETG, l, nil)          -> ir.NewCallExpr(xpos, ir.OGETG, l, nil)
	ir.NodAt(xpos, ir.OMAKE, l, nil)          -> ir.NewCallExpr(xpos, ir.OMAKE, l, nil)
	ir.NodAt(xpos, ir.OPRINT, l, nil)         -> ir.NewCallExpr(xpos, ir.OPRINT, l, nil)
	ir.NodAt(xpos, ir.OPRINTN, l, nil)        -> ir.NewCallExpr(xpos, ir.OPRINTN, l, nil)
	ir.NodAt(xpos, ir.ORECOVER, l, nil)       -> ir.NewCallExpr(xpos, ir.ORECOVER, l, nil)
	ir.NodAt(xpos, ir.OCASE, nil, nil)        -> ir.NewCaseStmt(xpos, nil, nil)
	ir.NodAt(xpos, ir.OCONV, l, nil)          -> ir.NewConvExpr(xpos, ir.OCONV, nil, l)
	ir.NodAt(xpos, ir.OCONVIFACE, l, nil)     -> ir.NewConvExpr(xpos, ir.OCONVIFACE, nil, l)
	ir.NodAt(xpos, ir.OCONVNOP, l, nil)       -> ir.NewConvExpr(xpos, ir.OCONVNOP, nil, l)
	ir.NodAt(xpos, ir.ORUNESTR, l, nil)       -> ir.NewConvExpr(xpos, ir.ORUNESTR, nil, l)
	ir.NodAt(xpos, ir.ODCL, l, nil)           -> ir.NewDecl(xpos, ir.ODCL, l)
	ir.NodAt(xpos, ir.ODCLCONST, l, nil)      -> ir.NewDecl(xpos, ir.ODCLCONST, l)
	ir.NodAt(xpos, ir.ODCLTYPE, l, nil)       -> ir.NewDecl(xpos, ir.ODCLTYPE, l)
	ir.NodAt(xpos, ir.ODCLFUNC, nil, nil)     -> ir.NewFunc(xpos)
	ir.NodAt(xpos, ir.ODEFER, l, nil)         -> ir.NewGoDeferStmt(xpos, ir.ODEFER, l)
	ir.NodAt(xpos, ir.OGO, l, nil)            -> ir.NewGoDeferStmt(xpos, ir.OGO, l)
	ir.NodAt(xpos, ir.ODEREF, l, nil)         -> ir.NewStarExpr(xpos, l)
	ir.NodAt(xpos, ir.ODOT, l, nil)           -> ir.NewSelectorExpr(xpos, ir.ODOT, l, nil)
	ir.NodAt(xpos, ir.ODOTPTR, l, nil)        -> ir.NewSelectorExpr(xpos, ir.ODOTPTR, l, nil)
	ir.NodAt(xpos, ir.ODOTMETH, l, nil)       -> ir.NewSelectorExpr(xpos, ir.ODOTMETH, l, nil)
	ir.NodAt(xpos, ir.ODOTINTER, l, nil)      -> ir.NewSelectorExpr(xpos, ir.ODOTINTER, l, nil)
	ir.NodAt(xpos, ir.OXDOT, l, nil)          -> ir.NewSelectorExpr(xpos, ir.OXDOT, l, nil)
	ir.NodAt(xpos, ir.ODOTTYPE, l, nil)       -> ir.NewTypeAssertExpr(xpos, l, nil)
	ir.NodAt(xpos, ir.ODOTTYPE, l, r)         -> ir.NewTypeAssertExpr(xpos, l, r.(ir.Ntype))
	ir.NodAt(xpos, ir.OFOR, l, r)             -> ir.NewForStmt(xpos, nil, l, r, nil)
	ir.NodAt(xpos, ir.OINDEX, l, r)           -> ir.NewIndexExpr(xpos, l, r)
	ir.NodAt(xpos, ir.OINLMARK, nil, nil)     -> ir.NewInlineMarkStmt(xpos, types.BADWIDTH)
	ir.NodAt(xpos, ir.OKEY, l, r)             -> ir.NewKeyExpr(xpos, l, r)
	ir.NodAt(xpos, ir.OLABEL, nil, nil)       -> ir.NewLabelStmt(xpos, nil)
	ir.NodAt(xpos, ir.OMAKECHAN, l, r)        -> ir.NewMakeExpr(xpos, ir.OMAKECHAN, l, r)
	ir.NodAt(xpos, ir.OMAKEMAP, l, r)         -> ir.NewMakeExpr(xpos, ir.OMAKEMAP, l, r)
	ir.NodAt(xpos, ir.OMAKESLICE, l, r)       -> ir.NewMakeExpr(xpos, ir.OMAKESLICE, l, r)
	ir.NodAt(xpos, ir.OMAKESLICECOPY, l, r)   -> ir.NewMakeExpr(xpos, ir.OMAKESLICECOPY, l, r)
	ir.NodAt(xpos, ir.ONIL, nil, nil)         -> ir.NewNilExpr(xpos)
	ir.NodAt(xpos, ir.OPACK, nil, nil)        -> ir.NewPkgName(xpos, nil, nil)
	ir.NodAt(xpos, ir.OPAREN, l, nil)         -> ir.NewParenExpr(xpos, l)
	ir.NodAt(xpos, ir.ORANGE, nil, r)         -> ir.NewRangeStmt(xpos, nil, r, nil)
	ir.NodAt(xpos, ir.ORESULT, nil, nil)      -> ir.NewResultExpr(xpos, nil, types.BADWIDTH)
	ir.NodAt(xpos, ir.ORETURN, nil, nil)      -> ir.NewReturnStmt(xpos, nil)
	ir.NodAt(xpos, ir.OSELECT, nil, nil)      -> ir.NewSelectStmt(xpos, nil)
	ir.NodAt(xpos, ir.OSEND, l, r)            -> ir.NewSendStmt(xpos, l, r)
	ir.NodAt(xpos, ir.OSLICE, l, nil)         -> ir.NewSliceExpr(xpos, ir.OSLICE, l)
	ir.NodAt(xpos, ir.OSLICEARR, l, nil)      -> ir.NewSliceExpr(xpos, ir.OSLICEARR, l)
	ir.NodAt(xpos, ir.OSLICESTR, l, nil)      -> ir.NewSliceExpr(xpos, ir.OSLICESTR, l)
	ir.NodAt(xpos, ir.OSLICE3, l, nil)        -> ir.NewSliceExpr(xpos, ir.OSLICE3, l)
	ir.NodAt(xpos, ir.OSLICE3ARR, l, nil)     -> ir.NewSliceExpr(xpos, ir.OSLICE3ARR, l)
	ir.NodAt(xpos, ir.OSLICEHEADER, l, nil)   -> ir.NewSliceHeaderExpr(xpos, nil, l, nil, nil)
	ir.NodAt(xpos, ir.OSWITCH, l, nil)        -> ir.NewSwitchStmt(xpos, l, nil)
	ir.NodAt(xpos, ir.OINLCALL, nil, nil)     -> ir.NewInlinedCallExpr(xpos, nil, nil)
}

rm noder.nod noder.nodSym nodSym nodlSym ir.NodAt ir.Nod
'

Change-Id: Ibf1eb708de8463ae74ccc47d7966cc263a18295e
Reviewed-on: https://go-review.googlesource.com/c/go/+/277933
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/alg.go       | 110 ++++-----
 src/cmd/compile/internal/gc/closure.go   |  24 +-
 src/cmd/compile/internal/gc/dcl.go       |  10 +-
 src/cmd/compile/internal/gc/gsubr.go     |   6 +-
 src/cmd/compile/internal/gc/iimport.go   |  48 ++--
 src/cmd/compile/internal/gc/inl.go       |  38 +--
 src/cmd/compile/internal/gc/noder.go     |  62 ++---
 src/cmd/compile/internal/gc/order.go     |  36 +--
 src/cmd/compile/internal/gc/range.go     |  92 +++----
 src/cmd/compile/internal/gc/select.go    |  36 +--
 src/cmd/compile/internal/gc/sinit.go     |  80 +++----
 src/cmd/compile/internal/gc/subr.go      |  50 ++--
 src/cmd/compile/internal/gc/swt.go       |  58 ++---
 src/cmd/compile/internal/gc/typecheck.go |  30 +--
 src/cmd/compile/internal/gc/walk.go      | 290 +++++++++++------------
 src/cmd/compile/internal/ir/node.go      | 120 ----------
 16 files changed, 471 insertions(+), 619 deletions(-)

diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index 46ae76d58d..730db9c1c9 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -312,21 +312,21 @@ func genhash(t *types.Type) *obj.LSym {
 
 		// for i := 0; i < nelem; i++
 		ni := temp(types.Types[types.TINT])
-		init := ir.Nod(ir.OAS, ni, nodintconst(0))
-		cond := ir.Nod(ir.OLT, ni, nodintconst(t.NumElem()))
-		post := ir.Nod(ir.OAS, ni, ir.Nod(ir.OADD, ni, nodintconst(1)))
-		loop := ir.Nod(ir.OFOR, cond, post)
+		init := ir.NewAssignStmt(base.Pos, ni, nodintconst(0))
+		cond := ir.NewBinaryExpr(base.Pos, ir.OLT, ni, nodintconst(t.NumElem()))
+		post := ir.NewAssignStmt(base.Pos, ni, ir.NewBinaryExpr(base.Pos, ir.OADD, ni, nodintconst(1)))
+		loop := ir.NewForStmt(base.Pos, nil, cond, post, nil)
 		loop.PtrInit().Append(init)
 
 		// h = hashel(&p[i], h)
-		call := ir.Nod(ir.OCALL, hashel, nil)
+		call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil)
 
-		nx := ir.Nod(ir.OINDEX, np, ni)
+		nx := ir.NewIndexExpr(base.Pos, np, ni)
 		nx.SetBounded(true)
 		na := nodAddr(nx)
 		call.PtrList().Append(na)
 		call.PtrList().Append(nh)
-		loop.PtrBody().Append(ir.Nod(ir.OAS, nh, call))
+		loop.PtrBody().Append(ir.NewAssignStmt(base.Pos, nh, call))
 
 		fn.PtrBody().Append(loop)
 
@@ -345,12 +345,12 @@ func genhash(t *types.Type) *obj.LSym {
 			// Hash non-memory fields with appropriate hash function.
 			if !IsRegularMemory(f.Type) {
 				hashel := hashfor(f.Type)
-				call := ir.Nod(ir.OCALL, hashel, nil)
-				nx := nodSym(ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
+				call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil)
+				nx := ir.NewSelectorExpr(base.Pos, ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
 				na := nodAddr(nx)
 				call.PtrList().Append(na)
 				call.PtrList().Append(nh)
-				fn.PtrBody().Append(ir.Nod(ir.OAS, nh, call))
+				fn.PtrBody().Append(ir.NewAssignStmt(base.Pos, nh, call))
 				i++
 				continue
 			}
@@ -360,19 +360,19 @@ func genhash(t *types.Type) *obj.LSym {
 
 			// h = hashel(&p.first, size, h)
 			hashel := hashmem(f.Type)
-			call := ir.Nod(ir.OCALL, hashel, nil)
-			nx := nodSym(ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
+			call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil)
+			nx := ir.NewSelectorExpr(base.Pos, ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
 			na := nodAddr(nx)
 			call.PtrList().Append(na)
 			call.PtrList().Append(nh)
 			call.PtrList().Append(nodintconst(size))
-			fn.PtrBody().Append(ir.Nod(ir.OAS, nh, call))
+			fn.PtrBody().Append(ir.NewAssignStmt(base.Pos, nh, call))
 
 			i = next
 		}
 	}
 
-	r := ir.Nod(ir.ORETURN, nil, nil)
+	r := ir.NewReturnStmt(base.Pos, nil)
 	r.PtrList().Append(nh)
 	fn.PtrBody().Append(r)
 
@@ -568,11 +568,11 @@ func geneq(t *types.Type) *obj.LSym {
 			// checkIdx generates a node to check for equality at index i.
 			checkIdx := func(i ir.Node) ir.Node {
 				// pi := p[i]
-				pi := ir.Nod(ir.OINDEX, np, i)
+				pi := ir.NewIndexExpr(base.Pos, np, i)
 				pi.SetBounded(true)
 				pi.SetType(t.Elem())
 				// qi := q[i]
-				qi := ir.Nod(ir.OINDEX, nq, i)
+				qi := ir.NewIndexExpr(base.Pos, nq, i)
 				qi.SetBounded(true)
 				qi.SetType(t.Elem())
 				return eq(pi, qi)
@@ -586,29 +586,29 @@ func geneq(t *types.Type) *obj.LSym {
 				// Generate a series of checks.
 				for i := int64(0); i < nelem; i++ {
 					// if check {} else { goto neq }
-					nif := ir.Nod(ir.OIF, checkIdx(nodintconst(i)), nil)
-					nif.PtrRlist().Append(nodSym(ir.OGOTO, nil, neq))
+					nif := ir.NewIfStmt(base.Pos, checkIdx(nodintconst(i)), nil, nil)
+					nif.PtrRlist().Append(ir.NewBranchStmt(base.Pos, ir.OGOTO, neq))
 					fn.PtrBody().Append(nif)
 				}
 				if last {
-					fn.PtrBody().Append(ir.Nod(ir.OAS, nr, checkIdx(nodintconst(nelem))))
+					fn.PtrBody().Append(ir.NewAssignStmt(base.Pos, nr, checkIdx(nodintconst(nelem))))
 				}
 			} else {
 				// Generate a for loop.
 				// for i := 0; i < nelem; i++
 				i := temp(types.Types[types.TINT])
-				init := ir.Nod(ir.OAS, i, nodintconst(0))
-				cond := ir.Nod(ir.OLT, i, nodintconst(nelem))
-				post := ir.Nod(ir.OAS, i, ir.Nod(ir.OADD, i, nodintconst(1)))
-				loop := ir.Nod(ir.OFOR, cond, post)
+				init := ir.NewAssignStmt(base.Pos, i, nodintconst(0))
+				cond := ir.NewBinaryExpr(base.Pos, ir.OLT, i, nodintconst(nelem))
+				post := ir.NewAssignStmt(base.Pos, i, ir.NewBinaryExpr(base.Pos, ir.OADD, i, nodintconst(1)))
+				loop := ir.NewForStmt(base.Pos, nil, cond, post, nil)
 				loop.PtrInit().Append(init)
 				// if eq(pi, qi) {} else { goto neq }
-				nif := ir.Nod(ir.OIF, checkIdx(i), nil)
-				nif.PtrRlist().Append(nodSym(ir.OGOTO, nil, neq))
+				nif := ir.NewIfStmt(base.Pos, checkIdx(i), nil, nil)
+				nif.PtrRlist().Append(ir.NewBranchStmt(base.Pos, ir.OGOTO, neq))
 				loop.PtrBody().Append(nif)
 				fn.PtrBody().Append(loop)
 				if last {
-					fn.PtrBody().Append(ir.Nod(ir.OAS, nr, nodbool(true)))
+					fn.PtrBody().Append(ir.NewAssignStmt(base.Pos, nr, nodbool(true)))
 				}
 			}
 		}
@@ -631,13 +631,13 @@ func geneq(t *types.Type) *obj.LSym {
 		case types.TFLOAT32, types.TFLOAT64:
 			checkAll(2, true, func(pi, qi ir.Node) ir.Node {
 				// p[i] == q[i]
-				return ir.Nod(ir.OEQ, pi, qi)
+				return ir.NewBinaryExpr(base.Pos, ir.OEQ, pi, qi)
 			})
 		// TODO: pick apart structs, do them piecemeal too
 		default:
 			checkAll(1, true, func(pi, qi ir.Node) ir.Node {
 				// p[i] == q[i]
-				return ir.Nod(ir.OEQ, pi, qi)
+				return ir.NewBinaryExpr(base.Pos, ir.OEQ, pi, qi)
 			})
 		}
 
@@ -669,15 +669,15 @@ func geneq(t *types.Type) *obj.LSym {
 					// Enforce ordering by starting a new set of reorderable conditions.
 					conds = append(conds, []ir.Node{})
 				}
-				p := nodSym(ir.OXDOT, np, f.Sym)
-				q := nodSym(ir.OXDOT, nq, f.Sym)
+				p := ir.NewSelectorExpr(base.Pos, ir.OXDOT, np, f.Sym)
+				q := ir.NewSelectorExpr(base.Pos, ir.OXDOT, nq, f.Sym)
 				switch {
 				case f.Type.IsString():
 					eqlen, eqmem := eqstring(p, q)
 					and(eqlen)
 					and(eqmem)
 				default:
-					and(ir.Nod(ir.OEQ, p, q))
+					and(ir.NewBinaryExpr(base.Pos, ir.OEQ, p, q))
 				}
 				if EqCanPanic(f.Type) {
 					// Also enforce ordering after something that can panic.
@@ -718,35 +718,35 @@ func geneq(t *types.Type) *obj.LSym {
 		}
 
 		if len(flatConds) == 0 {
-			fn.PtrBody().Append(ir.Nod(ir.OAS, nr, nodbool(true)))
+			fn.PtrBody().Append(ir.NewAssignStmt(base.Pos, nr, nodbool(true)))
 		} else {
 			for _, c := range flatConds[:len(flatConds)-1] {
 				// if cond {} else { goto neq }
-				n := ir.Nod(ir.OIF, c, nil)
-				n.PtrRlist().Append(nodSym(ir.OGOTO, nil, neq))
+				n := ir.NewIfStmt(base.Pos, c, nil, nil)
+				n.PtrRlist().Append(ir.NewBranchStmt(base.Pos, ir.OGOTO, neq))
 				fn.PtrBody().Append(n)
 			}
-			fn.PtrBody().Append(ir.Nod(ir.OAS, nr, flatConds[len(flatConds)-1]))
+			fn.PtrBody().Append(ir.NewAssignStmt(base.Pos, nr, flatConds[len(flatConds)-1]))
 		}
 	}
 
 	// ret:
 	//   return
 	ret := autolabel(".ret")
-	fn.PtrBody().Append(nodSym(ir.OLABEL, nil, ret))
-	fn.PtrBody().Append(ir.Nod(ir.ORETURN, nil, nil))
+	fn.PtrBody().Append(ir.NewLabelStmt(base.Pos, ret))
+	fn.PtrBody().Append(ir.NewReturnStmt(base.Pos, nil))
 
 	// neq:
 	//   r = false
 	//   return (or goto ret)
-	fn.PtrBody().Append(nodSym(ir.OLABEL, nil, neq))
-	fn.PtrBody().Append(ir.Nod(ir.OAS, nr, nodbool(false)))
+	fn.PtrBody().Append(ir.NewLabelStmt(base.Pos, neq))
+	fn.PtrBody().Append(ir.NewAssignStmt(base.Pos, nr, nodbool(false)))
 	if EqCanPanic(t) || anyCall(fn) {
 		// Epilogue is large, so share it with the equal case.
-		fn.PtrBody().Append(nodSym(ir.OGOTO, nil, ret))
+		fn.PtrBody().Append(ir.NewBranchStmt(base.Pos, ir.OGOTO, ret))
 	} else {
 		// Epilogue is small, so don't bother sharing.
-		fn.PtrBody().Append(ir.Nod(ir.ORETURN, nil, nil))
+		fn.PtrBody().Append(ir.NewReturnStmt(base.Pos, nil))
 	}
 	// TODO(khr): the epilogue size detection condition above isn't perfect.
 	// We should really do a generic CL that shares epilogues across
@@ -793,9 +793,9 @@ func anyCall(fn *ir.Func) bool {
 // eqfield returns the node
 // 	p.field == q.field
 func eqfield(p ir.Node, q ir.Node, field *types.Sym) ir.Node {
-	nx := nodSym(ir.OXDOT, p, field)
-	ny := nodSym(ir.OXDOT, q, field)
-	ne := ir.Nod(ir.OEQ, nx, ny)
+	nx := ir.NewSelectorExpr(base.Pos, ir.OXDOT, p, field)
+	ny := ir.NewSelectorExpr(base.Pos, ir.OXDOT, q, field)
+	ne := ir.NewBinaryExpr(base.Pos, ir.OEQ, nx, ny)
 	return ne
 }
 
@@ -808,10 +808,10 @@ func eqfield(p ir.Node, q ir.Node, field *types.Sym) ir.Node {
 func eqstring(s, t ir.Node) (eqlen *ir.BinaryExpr, eqmem *ir.CallExpr) {
 	s = conv(s, types.Types[types.TSTRING])
 	t = conv(t, types.Types[types.TSTRING])
-	sptr := ir.Nod(ir.OSPTR, s, nil)
-	tptr := ir.Nod(ir.OSPTR, t, nil)
-	slen := conv(ir.Nod(ir.OLEN, s, nil), types.Types[types.TUINTPTR])
-	tlen := conv(ir.Nod(ir.OLEN, t, nil), types.Types[types.TUINTPTR])
+	sptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, s)
+	tptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, t)
+	slen := conv(ir.NewUnaryExpr(base.Pos, ir.OLEN, s), types.Types[types.TUINTPTR])
+	tlen := conv(ir.NewUnaryExpr(base.Pos, ir.OLEN, t), types.Types[types.TUINTPTR])
 
 	fn := syslook("memequal")
 	fn = substArgTypes(fn, types.Types[types.TUINT8], types.Types[types.TUINT8])
@@ -843,10 +843,10 @@ func eqinterface(s, t ir.Node) (eqtab *ir.BinaryExpr, eqdata *ir.CallExpr) {
 		fn = syslook("ifaceeq")
 	}
 
-	stab := ir.Nod(ir.OITAB, s, nil)
-	ttab := ir.Nod(ir.OITAB, t, nil)
-	sdata := ir.Nod(ir.OIDATA, s, nil)
-	tdata := ir.Nod(ir.OIDATA, t, nil)
+	stab := ir.NewUnaryExpr(base.Pos, ir.OITAB, s)
+	ttab := ir.NewUnaryExpr(base.Pos, ir.OITAB, t)
+	sdata := ir.NewUnaryExpr(base.Pos, ir.OIDATA, s)
+	tdata := ir.NewUnaryExpr(base.Pos, ir.OIDATA, t)
 	sdata.SetType(types.Types[types.TUNSAFEPTR])
 	tdata.SetType(types.Types[types.TUNSAFEPTR])
 	sdata.SetTypecheck(1)
@@ -864,11 +864,11 @@ func eqinterface(s, t ir.Node) (eqtab *ir.BinaryExpr, eqdata *ir.CallExpr) {
 // eqmem returns the node
 // 	memequal(&p.field, &q.field [, size])
 func eqmem(p ir.Node, q ir.Node, field *types.Sym, size int64) ir.Node {
-	nx := typecheck(nodAddr(nodSym(ir.OXDOT, p, field)), ctxExpr)
-	ny := typecheck(nodAddr(nodSym(ir.OXDOT, q, field)), ctxExpr)
+	nx := typecheck(nodAddr(ir.NewSelectorExpr(base.Pos, ir.OXDOT, p, field)), ctxExpr)
+	ny := typecheck(nodAddr(ir.NewSelectorExpr(base.Pos, ir.OXDOT, q, field)), ctxExpr)
 
 	fn, needsize := eqmemfunc(size, nx.Type().Elem())
-	call := ir.Nod(ir.OCALL, fn, nil)
+	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
 	call.PtrList().Append(nx)
 	call.PtrList().Append(ny)
 	if needsize {
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index 1f4bf969ad..f47b2e2b07 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -296,7 +296,7 @@ func transformclosure(fn *ir.Func) {
 				// If it is a small variable captured by value, downgrade it to PAUTO.
 				v.SetClass(ir.PAUTO)
 				fn.Dcl = append(fn.Dcl, v)
-				body = append(body, ir.Nod(ir.OAS, v, cr))
+				body = append(body, ir.NewAssignStmt(base.Pos, v, cr))
 			} else {
 				// Declare variable holding addresses taken from closure
 				// and initialize in entry prologue.
@@ -311,7 +311,7 @@ func transformclosure(fn *ir.Func) {
 				if v.Byval() {
 					src = nodAddr(cr)
 				}
-				body = append(body, ir.Nod(ir.OAS, addr, src))
+				body = append(body, ir.NewAssignStmt(base.Pos, addr, src))
 			}
 		}
 
@@ -392,9 +392,9 @@ func walkclosure(clo *ir.ClosureExpr, init *ir.Nodes) ir.Node {
 
 	typ := closureType(clo)
 
-	clos := ir.Nod(ir.OCOMPLIT, nil, ir.TypeNode(typ))
+	clos := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ).(ir.Ntype), nil)
 	clos.SetEsc(clo.Esc())
-	clos.PtrList().Set(append([]ir.Node{ir.Nod(ir.OCFUNC, fn.Nname, nil)}, fn.ClosureEnter.Slice()...))
+	clos.PtrList().Set(append([]ir.Node{ir.NewUnaryExpr(base.Pos, ir.OCFUNC, fn.Nname)}, fn.ClosureEnter.Slice()...))
 
 	addr := nodAddr(clos)
 	addr.SetEsc(clo.Esc())
@@ -473,17 +473,17 @@ func makepartialcall(dot *ir.SelectorExpr, t0 *types.Type, meth *types.Sym) *ir.
 	var body []ir.Node
 	if rcvrtype.IsPtr() || rcvrtype.IsInterface() {
 		ptr.SetType(rcvrtype)
-		body = append(body, ir.Nod(ir.OAS, ptr, cr))
+		body = append(body, ir.NewAssignStmt(base.Pos, ptr, cr))
 	} else {
 		ptr.SetType(types.NewPtr(rcvrtype))
-		body = append(body, ir.Nod(ir.OAS, ptr, nodAddr(cr)))
+		body = append(body, ir.NewAssignStmt(base.Pos, ptr, nodAddr(cr)))
 	}
 
-	call := ir.Nod(ir.OCALL, nodSym(ir.OXDOT, ptr, meth), nil)
+	call := ir.NewCallExpr(base.Pos, ir.OCALL, ir.NewSelectorExpr(base.Pos, ir.OXDOT, ptr, meth), nil)
 	call.PtrList().Set(paramNnames(tfn.Type()))
 	call.SetIsDDD(tfn.Type().IsVariadic())
 	if t0.NumResults() != 0 {
-		ret := ir.Nod(ir.ORETURN, nil, nil)
+		ret := ir.NewReturnStmt(base.Pos, nil)
 		ret.PtrList().Set1(call)
 		body = append(body, ret)
 	} else {
@@ -532,18 +532,18 @@ func walkpartialcall(n *ir.CallPartExpr, init *ir.Nodes) ir.Node {
 		n.SetLeft(cheapexpr(n.Left(), init))
 		n.SetLeft(walkexpr(n.Left(), nil))
 
-		tab := typecheck(ir.Nod(ir.OITAB, n.Left(), nil), ctxExpr)
+		tab := typecheck(ir.NewUnaryExpr(base.Pos, ir.OITAB, n.Left()), ctxExpr)
 
-		c := ir.Nod(ir.OCHECKNIL, tab, nil)
+		c := ir.NewUnaryExpr(base.Pos, ir.OCHECKNIL, tab)
 		c.SetTypecheck(1)
 		init.Append(c)
 	}
 
 	typ := partialCallType(n)
 
-	clos := ir.Nod(ir.OCOMPLIT, nil, ir.TypeNode(typ))
+	clos := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ).(ir.Ntype), nil)
 	clos.SetEsc(n.Esc())
-	clos.PtrList().Set2(ir.Nod(ir.OCFUNC, n.Func().Nname, nil), n.Left())
+	clos.PtrList().Set2(ir.NewUnaryExpr(base.Pos, ir.OCFUNC, n.Func().Nname), n.Left())
 
 	addr := nodAddr(clos)
 	addr.SetEsc(n.Esc())
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 558bdbef92..3cfb24f2fc 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -136,7 +136,7 @@ func variter(vl []*ir.Name, t ir.Ntype, el []ir.Node) []ir.Node {
 
 	if len(el) == 1 && len(vl) > 1 {
 		e := el[0]
-		as2 := ir.Nod(ir.OAS2, nil, nil)
+		as2 := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
 		as2.PtrRlist().Set1(e)
 		for _, v := range vl {
 			as2.PtrList().Append(v)
@@ -144,7 +144,7 @@ func variter(vl []*ir.Name, t ir.Ntype, el []ir.Node) []ir.Node {
 			v.Ntype = t
 			v.Defn = as2
 			if Curfn != nil {
-				init = append(init, ir.Nod(ir.ODCL, v, nil))
+				init = append(init, ir.NewDecl(base.Pos, ir.ODCL, v))
 			}
 		}
 
@@ -166,9 +166,9 @@ func variter(vl []*ir.Name, t ir.Ntype, el []ir.Node) []ir.Node {
 
 		if e != nil || Curfn != nil || ir.IsBlank(v) {
 			if Curfn != nil {
-				init = append(init, ir.Nod(ir.ODCL, v, nil))
+				init = append(init, ir.NewDecl(base.Pos, ir.ODCL, v))
 			}
-			as := ir.Nod(ir.OAS, v, e)
+			as := ir.NewAssignStmt(base.Pos, v, e)
 			init = append(init, as)
 			if e != nil {
 				v.Defn = as
@@ -312,7 +312,7 @@ func colasdefn(left []ir.Node, defn ir.Node) {
 		n := NewName(n.Sym())
 		declare(n, dclcontext)
 		n.Defn = defn
-		defn.PtrInit().Append(ir.Nod(ir.ODCL, n, nil))
+		defn.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, n))
 		left[i] = n
 	}
 
diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go
index aa498a0097..b0ad01bc5d 100644
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ b/src/cmd/compile/internal/gc/gsubr.go
@@ -267,14 +267,14 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 	// OTAILCALL or something to this effect.
 	var tail ir.Node
 	if tfn.Type().NumResults() == 0 && tfn.Type().NumParams() == 0 && tfn.Type().NumRecvs() == 0 {
-		tail = nodSym(ir.ORETJMP, nil, f.Nname.Sym())
+		tail = ir.NewBranchStmt(base.Pos, ir.ORETJMP, f.Nname.Sym())
 	} else {
-		call := ir.Nod(ir.OCALL, f.Nname, nil)
+		call := ir.NewCallExpr(base.Pos, ir.OCALL, f.Nname, nil)
 		call.PtrList().Set(paramNnames(tfn.Type()))
 		call.SetIsDDD(tfn.Type().IsVariadic())
 		tail = call
 		if tfn.Type().NumResults() > 0 {
-			n := ir.Nod(ir.ORETURN, nil, nil)
+			n := ir.NewReturnStmt(base.Pos, nil)
 			n.PtrList().Set1(call)
 			tail = n
 		}
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 5f72cedb66..1148d329a3 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -770,7 +770,7 @@ func (r *importReader) caseList(sw ir.Node) []ir.Node {
 
 	cases := make([]ir.Node, r.uint64())
 	for i := range cases {
-		cas := ir.NodAt(r.pos(), ir.OCASE, nil, nil)
+		cas := ir.NewCaseStmt(r.pos(), nil, nil)
 		cas.PtrList().Set(r.stmtList())
 		if namedTypeSwitch {
 			// Note: per-case variables will have distinct, dotted
@@ -864,7 +864,7 @@ func (r *importReader) node() ir.Node {
 		// TODO(mdempsky): Export position information for OSTRUCTKEY nodes.
 		savedlineno := base.Pos
 		base.Pos = r.pos()
-		n := ir.NodAt(base.Pos, ir.OCOMPLIT, nil, ir.TypeNode(r.typ()))
+		n := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(r.typ()).(ir.Ntype), nil)
 		n.PtrList().Set(r.elemList()) // special handling of field names
 		base.Pos = savedlineno
 		return n
@@ -873,14 +873,14 @@ func (r *importReader) node() ir.Node {
 	// 	unreachable - mapped to case OCOMPLIT below by exporter
 
 	case ir.OCOMPLIT:
-		n := ir.NodAt(r.pos(), ir.OCOMPLIT, nil, ir.TypeNode(r.typ()))
+		n := ir.NewCompLitExpr(r.pos(), ir.OCOMPLIT, ir.TypeNode(r.typ()).(ir.Ntype), nil)
 		n.PtrList().Set(r.exprList())
 		return n
 
 	case ir.OKEY:
 		pos := r.pos()
 		left, right := r.exprsOrNil()
-		return ir.NodAt(pos, ir.OKEY, left, right)
+		return ir.NewKeyExpr(pos, left, right)
 
 	// case OSTRUCTKEY:
 	//	unreachable - handled in case OSTRUCTLIT by elemList
@@ -893,13 +893,13 @@ func (r *importReader) node() ir.Node {
 
 	case ir.OXDOT:
 		// see parser.new_dotname
-		return npos(r.pos(), nodSym(ir.OXDOT, r.expr(), r.ident()))
+		return ir.NewSelectorExpr(r.pos(), ir.OXDOT, r.expr(), r.ident())
 
 	// case ODOTTYPE, ODOTTYPE2:
 	// 	unreachable - mapped to case ODOTTYPE below by exporter
 
 	case ir.ODOTTYPE:
-		n := ir.NodAt(r.pos(), ir.ODOTTYPE, r.expr(), nil)
+		n := ir.NewTypeAssertExpr(r.pos(), r.expr(), nil)
 		n.SetType(r.typ())
 		return n
 
@@ -907,7 +907,7 @@ func (r *importReader) node() ir.Node {
 	// 	unreachable - mapped to cases below by exporter
 
 	case ir.OINDEX:
-		return ir.NodAt(r.pos(), ir.OINDEX, r.expr(), r.expr())
+		return ir.NewIndexExpr(r.pos(), r.expr(), r.expr())
 
 	case ir.OSLICE, ir.OSLICE3:
 		n := ir.NewSliceExpr(r.pos(), op, r.expr())
@@ -923,7 +923,7 @@ func (r *importReader) node() ir.Node {
 	// 	unreachable - mapped to OCONV case below by exporter
 
 	case ir.OCONV:
-		n := ir.NodAt(r.pos(), ir.OCONV, r.expr(), nil)
+		n := ir.NewConvExpr(r.pos(), ir.OCONV, nil, r.expr())
 		n.SetType(r.typ())
 		return n
 
@@ -939,7 +939,7 @@ func (r *importReader) node() ir.Node {
 	// 	unreachable - mapped to OCALL case below by exporter
 
 	case ir.OCALL:
-		n := ir.NodAt(r.pos(), ir.OCALL, nil, nil)
+		n := ir.NewCallExpr(r.pos(), ir.OCALL, nil, nil)
 		n.PtrInit().Set(r.stmtList())
 		n.SetLeft(r.expr())
 		n.PtrList().Set(r.exprList())
@@ -978,7 +978,7 @@ func (r *importReader) node() ir.Node {
 		list := r.exprList()
 		x := npos(pos, list[0])
 		for _, y := range list[1:] {
-			x = ir.NodAt(pos, ir.OADD, x, y)
+			x = ir.NewBinaryExpr(pos, ir.OADD, x, y)
 		}
 		return x
 
@@ -992,18 +992,18 @@ func (r *importReader) node() ir.Node {
 		declare(lhs, ir.PAUTO)
 
 		var stmts ir.Nodes
-		stmts.Append(ir.Nod(ir.ODCL, lhs, nil))
-		stmts.Append(ir.Nod(ir.OAS, lhs, nil))
-		return npos(pos, liststmt(stmts.Slice()))
+		stmts.Append(ir.NewDecl(base.Pos, ir.ODCL, lhs))
+		stmts.Append(ir.NewAssignStmt(base.Pos, lhs, nil))
+		return ir.NewBlockStmt(pos, stmts.Slice())
 
 	// case OAS, OASWB:
 	// 	unreachable - mapped to OAS case below by exporter
 
 	case ir.OAS:
-		return ir.NodAt(r.pos(), ir.OAS, r.expr(), r.expr())
+		return ir.NewAssignStmt(r.pos(), r.expr(), r.expr())
 
 	case ir.OASOP:
-		n := ir.NodAt(r.pos(), ir.OASOP, nil, nil)
+		n := ir.NewAssignOpStmt(r.pos(), ir.OXXX, nil, nil)
 		n.SetSubOp(r.op())
 		n.SetLeft(r.expr())
 		if !r.bool() {
@@ -1018,13 +1018,13 @@ func (r *importReader) node() ir.Node {
 	// 	unreachable - mapped to OAS2 case below by exporter
 
 	case ir.OAS2:
-		n := ir.NodAt(r.pos(), ir.OAS2, nil, nil)
+		n := ir.NewAssignListStmt(r.pos(), ir.OAS2, nil, nil)
 		n.PtrList().Set(r.exprList())
 		n.PtrRlist().Set(r.exprList())
 		return n
 
 	case ir.ORETURN:
-		n := ir.NodAt(r.pos(), ir.ORETURN, nil, nil)
+		n := ir.NewReturnStmt(r.pos(), nil)
 		n.PtrList().Set(r.exprList())
 		return n
 
@@ -1035,7 +1035,7 @@ func (r *importReader) node() ir.Node {
 		return ir.NewGoDeferStmt(r.pos(), op, r.expr())
 
 	case ir.OIF:
-		n := ir.NodAt(r.pos(), ir.OIF, nil, nil)
+		n := ir.NewIfStmt(r.pos(), nil, nil, nil)
 		n.PtrInit().Set(r.stmtList())
 		n.SetLeft(r.expr())
 		n.PtrBody().Set(r.stmtList())
@@ -1043,7 +1043,7 @@ func (r *importReader) node() ir.Node {
 		return n
 
 	case ir.OFOR:
-		n := ir.NodAt(r.pos(), ir.OFOR, nil, nil)
+		n := ir.NewForStmt(r.pos(), nil, nil, nil, nil)
 		n.PtrInit().Set(r.stmtList())
 		left, right := r.exprsOrNil()
 		n.SetLeft(left)
@@ -1052,21 +1052,21 @@ func (r *importReader) node() ir.Node {
 		return n
 
 	case ir.ORANGE:
-		n := ir.NodAt(r.pos(), ir.ORANGE, nil, nil)
+		n := ir.NewRangeStmt(r.pos(), nil, nil, nil)
 		n.PtrList().Set(r.stmtList())
 		n.SetRight(r.expr())
 		n.PtrBody().Set(r.stmtList())
 		return n
 
 	case ir.OSELECT:
-		n := ir.NodAt(r.pos(), ir.OSELECT, nil, nil)
+		n := ir.NewSelectStmt(r.pos(), nil)
 		n.PtrInit().Set(r.stmtList())
 		r.exprsOrNil() // TODO(rsc): Delete (and fix exporter). These are always nil.
 		n.PtrList().Set(r.caseList(n))
 		return n
 
 	case ir.OSWITCH:
-		n := ir.NodAt(r.pos(), ir.OSWITCH, nil, nil)
+		n := ir.NewSwitchStmt(r.pos(), nil, nil)
 		n.PtrInit().Set(r.stmtList())
 		left, _ := r.exprsOrNil()
 		n.SetLeft(left)
@@ -1077,7 +1077,7 @@ func (r *importReader) node() ir.Node {
 	//	handled by caseList
 
 	case ir.OFALL:
-		n := ir.NodAt(r.pos(), ir.OFALL, nil, nil)
+		n := ir.NewBranchStmt(r.pos(), ir.OFALL, nil)
 		return n
 
 	// case OEMPTY:
@@ -1113,7 +1113,7 @@ func (r *importReader) elemList() []ir.Node {
 	list := make([]ir.Node, c)
 	for i := range list {
 		s := r.ident()
-		list[i] = nodSym(ir.OSTRUCTKEY, r.expr(), s)
+		list[i] = ir.NewStructKeyExpr(base.Pos, s, r.expr())
 	}
 	return list
 }
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index fc020000c7..122c19f6df 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -520,7 +520,7 @@ func inlcalls(fn *ir.Func) {
 
 // Turn an OINLCALL into a statement.
 func inlconv2stmt(inlcall *ir.InlinedCallExpr) ir.Node {
-	n := ir.NodAt(inlcall.Pos(), ir.OBLOCK, nil, nil)
+	n := ir.NewBlockStmt(inlcall.Pos(), nil)
 	n.SetList(inlcall.Init())
 	n.PtrList().AppendNodes(inlcall.PtrBody())
 	return n
@@ -785,7 +785,7 @@ func inlParam(t *types.Field, as ir.Node, inlvars map[*ir.Name]ir.Node) ir.Node
 	if inlvar == nil {
 		base.Fatalf("missing inlvar for %v", n)
 	}
-	as.PtrInit().Append(ir.Nod(ir.ODCL, inlvar, nil))
+	as.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, inlvar))
 	inlvar.Name().Defn = as
 	return inlvar
 }
@@ -907,20 +907,20 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 
 			if v.Byval() {
 				iv := typecheck(inlvar(v), ctxExpr)
-				ninit.Append(ir.Nod(ir.ODCL, iv, nil))
-				ninit.Append(typecheck(ir.Nod(ir.OAS, iv, o), ctxStmt))
+				ninit.Append(ir.NewDecl(base.Pos, ir.ODCL, iv))
+				ninit.Append(typecheck(ir.NewAssignStmt(base.Pos, iv, o), ctxStmt))
 				inlvars[v] = iv
 			} else {
 				addr := NewName(lookup("&" + v.Sym().Name))
 				addr.SetType(types.NewPtr(v.Type()))
 				ia := typecheck(inlvar(addr), ctxExpr)
-				ninit.Append(ir.Nod(ir.ODCL, ia, nil))
-				ninit.Append(typecheck(ir.Nod(ir.OAS, ia, nodAddr(o)), ctxStmt))
+				ninit.Append(ir.NewDecl(base.Pos, ir.ODCL, ia))
+				ninit.Append(typecheck(ir.NewAssignStmt(base.Pos, ia, nodAddr(o)), ctxStmt))
 				inlvars[addr] = ia
 
 				// When capturing by reference, all occurrence of the captured var
 				// must be substituted with dereference of the temporary address
-				inlvars[v] = typecheck(ir.Nod(ir.ODEREF, ia, nil), ctxExpr)
+				inlvars[v] = typecheck(ir.NewStarExpr(base.Pos, ia), ctxExpr)
 			}
 		}
 	}
@@ -994,7 +994,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 	}
 
 	// Assign arguments to the parameters' temp names.
-	as := ir.Nod(ir.OAS2, nil, nil)
+	as := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
 	as.SetColas(true)
 	if n.Op() == ir.OCALLMETH {
 		sel := n.Left().(*ir.SelectorExpr)
@@ -1036,7 +1036,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 			vas.SetRight(nodnil())
 			vas.Right().SetType(param.Type)
 		} else {
-			lit := ir.Nod(ir.OCOMPLIT, nil, ir.TypeNode(param.Type))
+			lit := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(param.Type).(ir.Ntype), nil)
 			lit.PtrList().Set(varargs)
 			vas.SetRight(lit)
 		}
@@ -1053,8 +1053,8 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 	if !delayretvars {
 		// Zero the return parameters.
 		for _, n := range retvars {
-			ninit.Append(ir.Nod(ir.ODCL, n, nil))
-			ras := ir.Nod(ir.OAS, n, nil)
+			ninit.Append(ir.NewDecl(base.Pos, ir.ODCL, n))
+			ras := ir.NewAssignStmt(base.Pos, n, nil)
 			ninit.Append(typecheck(ras, ctxStmt))
 		}
 	}
@@ -1076,7 +1076,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 	// to put a breakpoint. Not sure if that's really necessary or not
 	// (in which case it could go at the end of the function instead).
 	// Note issue 28603.
-	inlMark := ir.Nod(ir.OINLMARK, nil, nil)
+	inlMark := ir.NewInlineMarkStmt(base.Pos, types.BADWIDTH)
 	inlMark.SetPos(n.Pos().WithIsStmt())
 	inlMark.SetOffset(int64(newIndex))
 	ninit.Append(inlMark)
@@ -1100,7 +1100,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 
 	body := subst.list(ir.AsNodes(fn.Inl.Body))
 
-	lab := nodSym(ir.OLABEL, nil, retlabel)
+	lab := ir.NewLabelStmt(base.Pos, retlabel)
 	body = append(body, lab)
 
 	typecheckslice(body, ctxStmt)
@@ -1113,7 +1113,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 
 	//dumplist("ninit post", ninit);
 
-	call := ir.Nod(ir.OINLCALL, nil, nil)
+	call := ir.NewInlinedCallExpr(base.Pos, nil, nil)
 	call.PtrInit().Set(ninit.Slice())
 	call.PtrBody().Set(body)
 	call.PtrRlist().Set(retvars)
@@ -1261,7 +1261,7 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 		// this return is guaranteed to belong to the current inlined function.
 		init := subst.list(n.Init())
 		if len(subst.retvars) != 0 && n.List().Len() != 0 {
-			as := ir.Nod(ir.OAS2, nil, nil)
+			as := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
 
 			// Make a shallow copy of retvars.
 			// Otherwise OINLCALL.Rlist will be the same list,
@@ -1273,14 +1273,14 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 
 			if subst.delayretvars {
 				for _, n := range as.List().Slice() {
-					as.PtrInit().Append(ir.Nod(ir.ODCL, n, nil))
+					as.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, n))
 					n.Name().Defn = as
 				}
 			}
 
 			init = append(init, typecheck(as, ctxStmt))
 		}
-		init = append(init, nodSym(ir.OGOTO, nil, subst.retlabel))
+		init = append(init, ir.NewBranchStmt(base.Pos, ir.OGOTO, subst.retlabel))
 		typecheckslice(init, ctxStmt)
 		return ir.NewBlockStmt(base.Pos, init)
 
@@ -1360,9 +1360,9 @@ func devirtualizeCall(call *ir.CallExpr) {
 		return
 	}
 
-	dt := ir.NodAt(sel.Pos(), ir.ODOTTYPE, sel.Left(), nil)
+	dt := ir.NewTypeAssertExpr(sel.Pos(), sel.Left(), nil)
 	dt.SetType(typ)
-	x := typecheck(nodlSym(sel.Pos(), ir.OXDOT, dt, sel.Sym()), ctxExpr|ctxCallee)
+	x := typecheck(ir.NewSelectorExpr(sel.Pos(), ir.OXDOT, dt, sel.Sym()), ctxExpr|ctxCallee)
 	switch x.Op() {
 	case ir.ODOTMETH:
 		if base.Flag.LowerM != 0 {
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 97a9ac4396..d2d908bf9f 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -165,7 +165,7 @@ func (p *noder) funcBody(fn *ir.Func, block *syntax.BlockStmt) {
 	if block != nil {
 		body := p.stmts(block.List)
 		if body == nil {
-			body = []ir.Node{ir.Nod(ir.OBLOCK, nil, nil)}
+			body = []ir.Node{ir.NewBlockStmt(base.Pos, nil)}
 		}
 		fn.PtrBody().Set(body)
 
@@ -455,7 +455,7 @@ func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []ir.Node {
 		n.Defn = v
 		n.SetIota(cs.iota)
 
-		nn = append(nn, p.nod(decl, ir.ODCLCONST, n, nil))
+		nn = append(nn, ir.NewDecl(p.pos(decl), ir.ODCLCONST, n))
 	}
 
 	if len(values) > len(names) {
@@ -484,7 +484,7 @@ func (p *noder) typeDecl(decl *syntax.TypeDecl) ir.Node {
 		p.checkUnused(pragma)
 	}
 
-	nod := p.nod(decl, ir.ODCLTYPE, n, nil)
+	nod := ir.NewDecl(p.pos(decl), ir.ODCLTYPE, n)
 	if n.Alias() && !langSupported(1, 9, types.LocalPkg) {
 		base.ErrorfAt(nod.Pos(), "type aliases only supported as of -lang=go1.9")
 	}
@@ -648,7 +648,7 @@ func (p *noder) expr(expr syntax.Expr) ir.Node {
 		n.SetDiag(expr.Bad) // avoid follow-on errors if there was a syntax error
 		return n
 	case *syntax.CompositeLit:
-		n := p.nod(expr, ir.OCOMPLIT, nil, nil)
+		n := ir.NewCompLitExpr(p.pos(expr), ir.OCOMPLIT, nil, nil)
 		if expr.Type != nil {
 			n.SetRight(p.expr(expr.Type))
 		}
@@ -661,11 +661,11 @@ func (p *noder) expr(expr syntax.Expr) ir.Node {
 		return n
 	case *syntax.KeyValueExpr:
 		// use position of expr.Key rather than of expr (which has position of ':')
-		return p.nod(expr.Key, ir.OKEY, p.expr(expr.Key), p.wrapname(expr.Value, p.expr(expr.Value)))
+		return ir.NewKeyExpr(p.pos(expr.Key), p.expr(expr.Key), p.wrapname(expr.Value, p.expr(expr.Value)))
 	case *syntax.FuncLit:
 		return p.funcLit(expr)
 	case *syntax.ParenExpr:
-		return p.nod(expr, ir.OPAREN, p.expr(expr.X), nil)
+		return ir.NewParenExpr(p.pos(expr), p.expr(expr.X))
 	case *syntax.SelectorExpr:
 		// parser.new_dotname
 		obj := p.expr(expr.X)
@@ -674,11 +674,11 @@ func (p *noder) expr(expr syntax.Expr) ir.Node {
 			pack.Used = true
 			return importName(pack.Pkg.Lookup(expr.Sel.Value))
 		}
-		n := nodSym(ir.OXDOT, obj, p.name(expr.Sel))
+		n := ir.NewSelectorExpr(base.Pos, ir.OXDOT, obj, p.name(expr.Sel))
 		n.SetPos(p.pos(expr)) // lineno may have been changed by p.expr(expr.X)
 		return n
 	case *syntax.IndexExpr:
-		return p.nod(expr, ir.OINDEX, p.expr(expr.X), p.expr(expr.Index))
+		return ir.NewIndexExpr(p.pos(expr), p.expr(expr.X), p.expr(expr.Index))
 	case *syntax.SliceExpr:
 		op := ir.OSLICE
 		if expr.Full {
@@ -694,7 +694,7 @@ func (p *noder) expr(expr syntax.Expr) ir.Node {
 		n.SetSliceBounds(index[0], index[1], index[2])
 		return n
 	case *syntax.AssertExpr:
-		return p.nod(expr, ir.ODOTTYPE, p.expr(expr.X), p.typeExpr(expr.Type))
+		return ir.NewTypeAssertExpr(p.pos(expr), p.expr(expr.X), p.typeExpr(expr.Type).(ir.Ntype))
 	case *syntax.Operation:
 		if expr.Op == syntax.Add && expr.Y != nil {
 			return p.sum(expr)
@@ -718,7 +718,7 @@ func (p *noder) expr(expr syntax.Expr) ir.Node {
 		}
 		return ir.NewBinaryExpr(pos, op, x, y)
 	case *syntax.CallExpr:
-		n := p.nod(expr, ir.OCALL, p.expr(expr.Fun), nil)
+		n := ir.NewCallExpr(p.pos(expr), ir.OCALL, p.expr(expr.Fun), nil)
 		n.PtrList().Set(p.exprs(expr.ArgList))
 		n.SetIsDDD(expr.HasDots)
 		return n
@@ -828,7 +828,7 @@ func (p *noder) sum(x syntax.Expr) ir.Node {
 			nstr = nil
 			chunks = chunks[:0]
 		}
-		n = p.nod(add, ir.OADD, n, r)
+		n = ir.NewBinaryExpr(p.pos(add), ir.OADD, n, r)
 	}
 	if len(chunks) > 1 {
 		nstr.SetVal(constant.MakeString(strings.Join(chunks, "")))
@@ -994,13 +994,13 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) ir.Node {
 		l := p.blockStmt(stmt)
 		if len(l) == 0 {
 			// TODO(mdempsky): Line number?
-			return ir.Nod(ir.OBLOCK, nil, nil)
+			return ir.NewBlockStmt(base.Pos, nil)
 		}
 		return liststmt(l)
 	case *syntax.ExprStmt:
 		return p.wrapname(stmt, p.expr(stmt.X))
 	case *syntax.SendStmt:
-		return p.nod(stmt, ir.OSEND, p.expr(stmt.Chan), p.expr(stmt.Value))
+		return ir.NewSendStmt(p.pos(stmt), p.expr(stmt.Chan), p.expr(stmt.Value))
 	case *syntax.DeclStmt:
 		return liststmt(p.decls(stmt.DeclList))
 	case *syntax.AssignStmt:
@@ -1012,14 +1012,14 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) ir.Node {
 
 		rhs := p.exprList(stmt.Rhs)
 		if list, ok := stmt.Lhs.(*syntax.ListExpr); ok && len(list.ElemList) != 1 || len(rhs) != 1 {
-			n := p.nod(stmt, ir.OAS2, nil, nil)
+			n := ir.NewAssignListStmt(p.pos(stmt), ir.OAS2, nil, nil)
 			n.SetColas(stmt.Op == syntax.Def)
 			n.PtrList().Set(p.assignList(stmt.Lhs, n, n.Colas()))
 			n.PtrRlist().Set(rhs)
 			return n
 		}
 
-		n := p.nod(stmt, ir.OAS, nil, nil)
+		n := ir.NewAssignStmt(p.pos(stmt), nil, nil)
 		n.SetColas(stmt.Op == syntax.Def)
 		n.SetLeft(p.assignList(stmt.Lhs, n, n.Colas())[0])
 		n.SetRight(rhs[0])
@@ -1063,7 +1063,7 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) ir.Node {
 		if stmt.Results != nil {
 			results = p.exprList(stmt.Results)
 		}
-		n := p.nod(stmt, ir.ORETURN, nil, nil)
+		n := ir.NewReturnStmt(p.pos(stmt), nil)
 		n.PtrList().Set(results)
 		if n.List().Len() == 0 && Curfn != nil {
 			for _, ln := range Curfn.Dcl {
@@ -1139,7 +1139,7 @@ func (p *noder) assignList(expr syntax.Expr, defn ir.Node, colas bool) []ir.Node
 		n := NewName(sym)
 		declare(n, dclcontext)
 		n.Defn = defn
-		defn.PtrInit().Append(ir.Nod(ir.ODCL, n, nil))
+		defn.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, n))
 		res[i] = n
 	}
 
@@ -1158,7 +1158,7 @@ func (p *noder) blockStmt(stmt *syntax.BlockStmt) []ir.Node {
 
 func (p *noder) ifStmt(stmt *syntax.IfStmt) ir.Node {
 	p.openScope(stmt.Pos())
-	n := p.nod(stmt, ir.OIF, nil, nil)
+	n := ir.NewIfStmt(p.pos(stmt), nil, nil, nil)
 	if stmt.Init != nil {
 		n.PtrInit().Set1(p.stmt(stmt.Init))
 	}
@@ -1185,7 +1185,7 @@ func (p *noder) forStmt(stmt *syntax.ForStmt) ir.Node {
 			panic("unexpected RangeClause")
 		}
 
-		n := p.nod(r, ir.ORANGE, nil, p.expr(r.X))
+		n := ir.NewRangeStmt(p.pos(r), nil, p.expr(r.X), nil)
 		if r.Lhs != nil {
 			n.SetColas(r.Def)
 			n.PtrList().Set(p.assignList(r.Lhs, n, n.Colas()))
@@ -1195,7 +1195,7 @@ func (p *noder) forStmt(stmt *syntax.ForStmt) ir.Node {
 		return n
 	}
 
-	n := p.nod(stmt, ir.OFOR, nil, nil)
+	n := ir.NewForStmt(p.pos(stmt), nil, nil, nil, nil)
 	if stmt.Init != nil {
 		n.PtrInit().Set1(p.stmt(stmt.Init))
 	}
@@ -1212,7 +1212,7 @@ func (p *noder) forStmt(stmt *syntax.ForStmt) ir.Node {
 
 func (p *noder) switchStmt(stmt *syntax.SwitchStmt) ir.Node {
 	p.openScope(stmt.Pos())
-	n := p.nod(stmt, ir.OSWITCH, nil, nil)
+	n := ir.NewSwitchStmt(p.pos(stmt), nil, nil)
 	if stmt.Init != nil {
 		n.PtrInit().Set1(p.stmt(stmt.Init))
 	}
@@ -1239,7 +1239,7 @@ func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *ir.TypeSwitch
 		}
 		p.openScope(clause.Pos())
 
-		n := p.nod(clause, ir.OCASE, nil, nil)
+		n := ir.NewCaseStmt(p.pos(clause), nil, nil)
 		if clause.Cases != nil {
 			n.PtrList().Set(p.exprList(clause.Cases))
 		}
@@ -1281,7 +1281,7 @@ func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *ir.TypeSwitch
 }
 
 func (p *noder) selectStmt(stmt *syntax.SelectStmt) ir.Node {
-	n := p.nod(stmt, ir.OSELECT, nil, nil)
+	n := ir.NewSelectStmt(p.pos(stmt), nil)
 	n.PtrList().Set(p.commClauses(stmt.Body, stmt.Rbrace))
 	return n
 }
@@ -1295,7 +1295,7 @@ func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []i
 		}
 		p.openScope(clause.Pos())
 
-		n := p.nod(clause, ir.OCASE, nil, nil)
+		n := ir.NewCaseStmt(p.pos(clause), nil, nil)
 		if clause.Comm != nil {
 			n.PtrList().Set1(p.stmt(clause.Comm))
 		}
@@ -1310,7 +1310,7 @@ func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []i
 
 func (p *noder) labeledStmt(label *syntax.LabeledStmt, fallOK bool) ir.Node {
 	sym := p.name(label.Label)
-	lhs := p.nodSym(label, ir.OLABEL, nil, sym)
+	lhs := ir.NewLabelStmt(p.pos(label), sym)
 
 	var ls ir.Node
 	if label.Stmt != nil { // TODO(mdempsky): Should always be present.
@@ -1478,23 +1478,13 @@ func (p *noder) wrapname(n syntax.Node, x ir.Node) ir.Node {
 		}
 		fallthrough
 	case ir.ONAME, ir.ONONAME, ir.OPACK:
-		p := p.nod(n, ir.OPAREN, x, nil)
+		p := ir.NewParenExpr(p.pos(n), x)
 		p.SetImplicit(true)
 		return p
 	}
 	return x
 }
 
-func (p *noder) nod(orig syntax.Node, op ir.Op, left, right ir.Node) ir.Node {
-	return ir.NodAt(p.pos(orig), op, left, right)
-}
-
-func (p *noder) nodSym(orig syntax.Node, op ir.Op, left ir.Node, sym *types.Sym) ir.Node {
-	n := nodSym(op, left, sym)
-	n.SetPos(p.pos(orig))
-	return n
-}
-
 func (p *noder) pos(n syntax.Node) src.XPos {
 	// TODO(gri): orig.Pos() should always be known - fix package syntax
 	xpos := base.Pos
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 1a0f0066d0..2e7838c252 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -88,7 +88,7 @@ func (o *Order) newTemp(t *types.Type, clear bool) *ir.Name {
 		v = temp(t)
 	}
 	if clear {
-		o.append(ir.Nod(ir.OAS, v, nil))
+		o.append(ir.NewAssignStmt(base.Pos, v, nil))
 	}
 
 	o.temp = append(o.temp, v)
@@ -118,7 +118,7 @@ func (o *Order) copyExprClear(n ir.Node) *ir.Name {
 func (o *Order) copyExpr1(n ir.Node, clear bool) *ir.Name {
 	t := n.Type()
 	v := o.newTemp(t, clear)
-	o.append(ir.Nod(ir.OAS, v, n))
+	o.append(ir.NewAssignStmt(base.Pos, v, n))
 	return v
 }
 
@@ -327,7 +327,7 @@ func (o *Order) cleanTempNoPop(mark ordermarker) []ir.Node {
 	var out []ir.Node
 	for i := len(o.temp) - 1; i >= int(mark); i-- {
 		n := o.temp[i]
-		out = append(out, typecheck(ir.Nod(ir.OVARKILL, n, nil), ctxStmt))
+		out = append(out, typecheck(ir.NewUnaryExpr(base.Pos, ir.OVARKILL, n), ctxStmt))
 	}
 	return out
 }
@@ -503,7 +503,7 @@ func (o *Order) call(nn ir.Node) {
 				x := o.copyExpr(arg.Left())
 				arg.SetLeft(x)
 				x.Name().SetAddrtaken(true) // ensure SSA keeps the x variable
-				n.PtrBody().Append(typecheck(ir.Nod(ir.OVARLIVE, x, nil), ctxStmt))
+				n.PtrBody().Append(typecheck(ir.NewUnaryExpr(base.Pos, ir.OVARLIVE, x), ctxStmt))
 			}
 		}
 	}
@@ -569,7 +569,7 @@ func (o *Order) mapAssign(n ir.Node) {
 			case instrumenting && n.Op() == ir.OAS2FUNC && !ir.IsBlank(m):
 				t := o.newTemp(m.Type(), false)
 				n.List().SetIndex(i, t)
-				a := ir.Nod(ir.OAS, m, t)
+				a := ir.NewAssignStmt(base.Pos, m, t)
 				post = append(post, typecheck(a, ctxStmt))
 			}
 		}
@@ -636,7 +636,7 @@ func (o *Order) stmt(n ir.Node) {
 			}
 			l2 = o.copyExpr(l2)
 			r := o.expr(typecheck(ir.NewBinaryExpr(n.Pos(), n.SubOp(), l2, n.Right()), ctxExpr), nil)
-			as := typecheck(ir.NodAt(n.Pos(), ir.OAS, l1, r), ctxStmt)
+			as := typecheck(ir.NewAssignStmt(n.Pos(), l1, r), ctxStmt)
 			o.mapAssign(as)
 			o.cleanTemp(t)
 			return
@@ -824,7 +824,7 @@ func (o *Order) stmt(n ir.Node) {
 			r := n.Right()
 
 			if r.Type().IsString() && r.Type() != types.Types[types.TSTRING] {
-				r = ir.Nod(ir.OCONV, r, nil)
+				r = ir.NewConvExpr(base.Pos, ir.OCONV, nil, r)
 				r.SetType(types.Types[types.TSTRING])
 				r = typecheck(r, ctxExpr)
 			}
@@ -915,11 +915,11 @@ func (o *Order) stmt(n ir.Node) {
 						if len(init) > 0 && init[0].Op() == ir.ODCL && init[0].(*ir.Decl).Left() == n {
 							init = init[1:]
 						}
-						dcl := typecheck(ir.Nod(ir.ODCL, n, nil), ctxStmt)
+						dcl := typecheck(ir.NewDecl(base.Pos, ir.ODCL, n), ctxStmt)
 						ncas.PtrInit().Append(dcl)
 					}
 					tmp := o.newTemp(t, t.HasPointers())
-					as := typecheck(ir.Nod(ir.OAS, n, conv(tmp, n.Type())), ctxStmt)
+					as := typecheck(ir.NewAssignStmt(base.Pos, n, conv(tmp, n.Type())), ctxStmt)
 					ncas.PtrInit().Append(as)
 					r.PtrList().SetIndex(i, tmp)
 				}
@@ -993,7 +993,7 @@ func (o *Order) stmt(n ir.Node) {
 		n := n.(*ir.SwitchStmt)
 		if base.Debug.Libfuzzer != 0 && !hasDefaultCase(n) {
 			// Add empty "default:" case for instrumentation.
-			n.PtrList().Append(ir.Nod(ir.OCASE, nil, nil))
+			n.PtrList().Append(ir.NewCaseStmt(base.Pos, nil, nil))
 		}
 
 		t := o.markTemp()
@@ -1176,7 +1176,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 
 		// Evaluate left-hand side.
 		lhs := o.expr(n.Left(), nil)
-		o.out = append(o.out, typecheck(ir.Nod(ir.OAS, r, lhs), ctxStmt))
+		o.out = append(o.out, typecheck(ir.NewAssignStmt(base.Pos, r, lhs), ctxStmt))
 
 		// Evaluate right-hand side, save generated code.
 		saveout := o.out
@@ -1184,13 +1184,13 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		t := o.markTemp()
 		o.edge()
 		rhs := o.expr(n.Right(), nil)
-		o.out = append(o.out, typecheck(ir.Nod(ir.OAS, r, rhs), ctxStmt))
+		o.out = append(o.out, typecheck(ir.NewAssignStmt(base.Pos, r, rhs), ctxStmt))
 		o.cleanTemp(t)
 		gen := o.out
 		o.out = saveout
 
 		// If left-hand side doesn't cause a short-circuit, issue right-hand side.
-		nif := ir.Nod(ir.OIF, r, nil)
+		nif := ir.NewIfStmt(base.Pos, r, nil, nil)
 		if n.Op() == ir.OANDAND {
 			nif.PtrBody().Set(gen)
 		} else {
@@ -1367,13 +1367,13 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 
 		// Emit the creation of the map (with all its static entries).
 		m := o.newTemp(n.Type(), false)
-		as := ir.Nod(ir.OAS, m, n)
+		as := ir.NewAssignStmt(base.Pos, m, n)
 		typecheck(as, ctxStmt)
 		o.stmt(as)
 
 		// Emit eval+insert of dynamic entries, one at a time.
 		for _, r := range dynamics {
-			as := ir.Nod(ir.OAS, ir.Nod(ir.OINDEX, m, r.Left()), r.Right())
+			as := ir.NewAssignStmt(base.Pos, ir.NewIndexExpr(base.Pos, m, r.Left()), r.Right())
 			typecheck(as, ctxStmt) // Note: this converts the OINDEX to an OINDEXMAP
 			o.stmt(as)
 		}
@@ -1405,7 +1405,7 @@ func (o *Order) as2(n *ir.AssignListStmt) {
 
 	o.out = append(o.out, n)
 
-	as := ir.Nod(ir.OAS2, nil, nil)
+	as := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
 	as.PtrList().Set(left)
 	as.PtrRlist().Set(tmplist)
 	o.stmt(typecheck(as, ctxStmt))
@@ -1427,12 +1427,12 @@ func (o *Order) okAs2(n *ir.AssignListStmt) {
 	o.out = append(o.out, n)
 
 	if tmp1 != nil {
-		r := ir.Nod(ir.OAS, n.List().First(), tmp1)
+		r := ir.NewAssignStmt(base.Pos, n.List().First(), tmp1)
 		o.mapAssign(typecheck(r, ctxStmt))
 		n.List().SetFirst(tmp1)
 	}
 	if tmp2 != nil {
-		r := ir.Nod(ir.OAS, n.List().Second(), conv(tmp2, n.List().Second().Type()))
+		r := ir.NewAssignStmt(base.Pos, n.List().Second(), conv(tmp2, n.List().Second().Type()))
 		o.mapAssign(typecheck(r, ctxStmt))
 		n.List().SetSecond(tmp2)
 	}
diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index aa4f0358c9..4a753328f2 100644
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -166,7 +166,7 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		return n
 	}
 
-	nfor := ir.NodAt(nrange.Pos(), ir.OFOR, nil, nil)
+	nfor := ir.NewForStmt(nrange.Pos(), nil, nil, nil, nil)
 	nfor.SetInit(nrange.Init())
 	nfor.SetSym(nrange.Sym())
 
@@ -224,11 +224,11 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		hv1 := temp(types.Types[types.TINT])
 		hn := temp(types.Types[types.TINT])
 
-		init = append(init, ir.Nod(ir.OAS, hv1, nil))
-		init = append(init, ir.Nod(ir.OAS, hn, ir.Nod(ir.OLEN, ha, nil)))
+		init = append(init, ir.NewAssignStmt(base.Pos, hv1, nil))
+		init = append(init, ir.NewAssignStmt(base.Pos, hn, ir.NewUnaryExpr(base.Pos, ir.OLEN, ha)))
 
-		nfor.SetLeft(ir.Nod(ir.OLT, hv1, hn))
-		nfor.SetRight(ir.Nod(ir.OAS, hv1, ir.Nod(ir.OADD, hv1, nodintconst(1))))
+		nfor.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OLT, hv1, hn))
+		nfor.SetRight(ir.NewAssignStmt(base.Pos, hv1, ir.NewBinaryExpr(base.Pos, ir.OADD, hv1, nodintconst(1))))
 
 		// for range ha { body }
 		if v1 == nil {
@@ -237,18 +237,18 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 
 		// for v1 := range ha { body }
 		if v2 == nil {
-			body = []ir.Node{ir.Nod(ir.OAS, v1, hv1)}
+			body = []ir.Node{ir.NewAssignStmt(base.Pos, v1, hv1)}
 			break
 		}
 
 		// for v1, v2 := range ha { body }
 		if cheapComputableIndex(nrange.Type().Elem().Width) {
 			// v1, v2 = hv1, ha[hv1]
-			tmp := ir.Nod(ir.OINDEX, ha, hv1)
+			tmp := ir.NewIndexExpr(base.Pos, ha, hv1)
 			tmp.SetBounded(true)
 			// Use OAS2 to correctly handle assignments
 			// of the form "v1, a[v1] := range".
-			a := ir.Nod(ir.OAS2, nil, nil)
+			a := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
 			a.PtrList().Set2(v1, v2)
 			a.PtrRlist().Set2(hv1, tmp)
 			body = []ir.Node{a}
@@ -268,19 +268,19 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		// elimination on the index variable (see #20711).
 		// Enhance the prove pass to understand this.
 		ifGuard = ir.NewIfStmt(base.Pos, nil, nil, nil)
-		ifGuard.SetLeft(ir.Nod(ir.OLT, hv1, hn))
+		ifGuard.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OLT, hv1, hn))
 		nfor.SetOp(ir.OFORUNTIL)
 
 		hp := temp(types.NewPtr(nrange.Type().Elem()))
-		tmp := ir.Nod(ir.OINDEX, ha, nodintconst(0))
+		tmp := ir.NewIndexExpr(base.Pos, ha, nodintconst(0))
 		tmp.SetBounded(true)
-		init = append(init, ir.Nod(ir.OAS, hp, nodAddr(tmp)))
+		init = append(init, ir.NewAssignStmt(base.Pos, hp, nodAddr(tmp)))
 
 		// Use OAS2 to correctly handle assignments
 		// of the form "v1, a[v1] := range".
-		a := ir.Nod(ir.OAS2, nil, nil)
+		a := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
 		a.PtrList().Set2(v1, v2)
-		a.PtrRlist().Set2(hv1, ir.Nod(ir.ODEREF, hp, nil))
+		a.PtrRlist().Set2(hv1, ir.NewStarExpr(base.Pos, hp))
 		body = append(body, a)
 
 		// Advance pointer as part of the late increment.
@@ -288,7 +288,7 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		// This runs *after* the condition check, so we know
 		// advancing the pointer is safe and won't go past the
 		// end of the allocation.
-		as := ir.Nod(ir.OAS, hp, addptr(hp, t.Elem().Width))
+		as := ir.NewAssignStmt(base.Pos, hp, addptr(hp, t.Elem().Width))
 		nfor.PtrList().Set1(typecheck(as, ctxStmt))
 
 	case types.TMAP:
@@ -305,20 +305,20 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 
 		fn = substArgTypes(fn, t.Key(), t.Elem(), th)
 		init = append(init, mkcall1(fn, nil, nil, typename(t), ha, nodAddr(hit)))
-		nfor.SetLeft(ir.Nod(ir.ONE, nodSym(ir.ODOT, hit, keysym), nodnil()))
+		nfor.SetLeft(ir.NewBinaryExpr(base.Pos, ir.ONE, ir.NewSelectorExpr(base.Pos, ir.ODOT, hit, keysym), nodnil()))
 
 		fn = syslook("mapiternext")
 		fn = substArgTypes(fn, th)
 		nfor.SetRight(mkcall1(fn, nil, nil, nodAddr(hit)))
 
-		key := ir.Nod(ir.ODEREF, nodSym(ir.ODOT, hit, keysym), nil)
+		key := ir.NewStarExpr(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, hit, keysym))
 		if v1 == nil {
 			body = nil
 		} else if v2 == nil {
-			body = []ir.Node{ir.Nod(ir.OAS, v1, key)}
+			body = []ir.Node{ir.NewAssignStmt(base.Pos, v1, key)}
 		} else {
-			elem := ir.Nod(ir.ODEREF, nodSym(ir.ODOT, hit, elemsym), nil)
-			a := ir.Nod(ir.OAS2, nil, nil)
+			elem := ir.NewStarExpr(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, hit, elemsym))
+			a := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
 			a.PtrList().Set2(v1, v2)
 			a.PtrRlist().Set2(key, elem)
 			body = []ir.Node{a}
@@ -331,25 +331,25 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		hv1 := temp(t.Elem())
 		hv1.SetTypecheck(1)
 		if t.Elem().HasPointers() {
-			init = append(init, ir.Nod(ir.OAS, hv1, nil))
+			init = append(init, ir.NewAssignStmt(base.Pos, hv1, nil))
 		}
 		hb := temp(types.Types[types.TBOOL])
 
-		nfor.SetLeft(ir.Nod(ir.ONE, hb, nodbool(false)))
-		a := ir.Nod(ir.OAS2RECV, nil, nil)
+		nfor.SetLeft(ir.NewBinaryExpr(base.Pos, ir.ONE, hb, nodbool(false)))
+		a := ir.NewAssignListStmt(base.Pos, ir.OAS2RECV, nil, nil)
 		a.SetTypecheck(1)
 		a.PtrList().Set2(hv1, hb)
-		a.PtrRlist().Set1(ir.Nod(ir.ORECV, ha, nil))
+		a.PtrRlist().Set1(ir.NewUnaryExpr(base.Pos, ir.ORECV, ha))
 		nfor.Left().PtrInit().Set1(a)
 		if v1 == nil {
 			body = nil
 		} else {
-			body = []ir.Node{ir.Nod(ir.OAS, v1, hv1)}
+			body = []ir.Node{ir.NewAssignStmt(base.Pos, v1, hv1)}
 		}
 		// Zero hv1. This prevents hv1 from being the sole, inaccessible
 		// reference to an otherwise GC-able value during the next channel receive.
 		// See issue 15281.
-		body = append(body, ir.Nod(ir.OAS, hv1, nil))
+		body = append(body, ir.NewAssignStmt(base.Pos, hv1, nil))
 
 	case types.TSTRING:
 		// Transform string range statements like "for v1, v2 = range a" into
@@ -375,30 +375,30 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		hv2 := temp(types.RuneType)
 
 		// hv1 := 0
-		init = append(init, ir.Nod(ir.OAS, hv1, nil))
+		init = append(init, ir.NewAssignStmt(base.Pos, hv1, nil))
 
 		// hv1 < len(ha)
-		nfor.SetLeft(ir.Nod(ir.OLT, hv1, ir.Nod(ir.OLEN, ha, nil)))
+		nfor.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OLT, hv1, ir.NewUnaryExpr(base.Pos, ir.OLEN, ha)))
 
 		if v1 != nil {
 			// hv1t = hv1
-			body = append(body, ir.Nod(ir.OAS, hv1t, hv1))
+			body = append(body, ir.NewAssignStmt(base.Pos, hv1t, hv1))
 		}
 
 		// hv2 := rune(ha[hv1])
-		nind := ir.Nod(ir.OINDEX, ha, hv1)
+		nind := ir.NewIndexExpr(base.Pos, ha, hv1)
 		nind.SetBounded(true)
-		body = append(body, ir.Nod(ir.OAS, hv2, conv(nind, types.RuneType)))
+		body = append(body, ir.NewAssignStmt(base.Pos, hv2, conv(nind, types.RuneType)))
 
 		// if hv2 < utf8.RuneSelf
-		nif := ir.Nod(ir.OIF, nil, nil)
-		nif.SetLeft(ir.Nod(ir.OLT, hv2, nodintconst(utf8.RuneSelf)))
+		nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
+		nif.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OLT, hv2, nodintconst(utf8.RuneSelf)))
 
 		// hv1++
-		nif.PtrBody().Set1(ir.Nod(ir.OAS, hv1, ir.Nod(ir.OADD, hv1, nodintconst(1))))
+		nif.PtrBody().Set1(ir.NewAssignStmt(base.Pos, hv1, ir.NewBinaryExpr(base.Pos, ir.OADD, hv1, nodintconst(1))))
 
 		// } else {
-		eif := ir.Nod(ir.OAS2, nil, nil)
+		eif := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
 		nif.PtrRlist().Set1(eif)
 
 		// hv2, hv1 = decoderune(ha, hv1)
@@ -411,13 +411,13 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		if v1 != nil {
 			if v2 != nil {
 				// v1, v2 = hv1t, hv2
-				a := ir.Nod(ir.OAS2, nil, nil)
+				a := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
 				a.PtrList().Set2(v1, v2)
 				a.PtrRlist().Set2(hv1t, hv2)
 				body = append(body, a)
 			} else {
 				// v1 = hv1t
-				body = append(body, ir.Nod(ir.OAS, v1, hv1t))
+				body = append(body, ir.NewAssignStmt(base.Pos, v1, hv1t))
 			}
 		}
 	}
@@ -561,22 +561,22 @@ func arrayClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
 	// 	memclr{NoHeap,Has}Pointers(hp, hn)
 	// 	i = len(a) - 1
 	// }
-	n := ir.Nod(ir.OIF, nil, nil)
+	n := ir.NewIfStmt(base.Pos, nil, nil, nil)
 	n.PtrBody().Set(nil)
-	n.SetLeft(ir.Nod(ir.ONE, ir.Nod(ir.OLEN, a, nil), nodintconst(0)))
+	n.SetLeft(ir.NewBinaryExpr(base.Pos, ir.ONE, ir.NewUnaryExpr(base.Pos, ir.OLEN, a), nodintconst(0)))
 
 	// hp = &a[0]
 	hp := temp(types.Types[types.TUNSAFEPTR])
 
-	ix := ir.Nod(ir.OINDEX, a, nodintconst(0))
+	ix := ir.NewIndexExpr(base.Pos, a, nodintconst(0))
 	ix.SetBounded(true)
 	addr := convnop(nodAddr(ix), types.Types[types.TUNSAFEPTR])
-	n.PtrBody().Append(ir.Nod(ir.OAS, hp, addr))
+	n.PtrBody().Append(ir.NewAssignStmt(base.Pos, hp, addr))
 
 	// hn = len(a) * sizeof(elem(a))
 	hn := temp(types.Types[types.TUINTPTR])
-	mul := conv(ir.Nod(ir.OMUL, ir.Nod(ir.OLEN, a, nil), nodintconst(elemsize)), types.Types[types.TUINTPTR])
-	n.PtrBody().Append(ir.Nod(ir.OAS, hn, mul))
+	mul := conv(ir.NewBinaryExpr(base.Pos, ir.OMUL, ir.NewUnaryExpr(base.Pos, ir.OLEN, a), nodintconst(elemsize)), types.Types[types.TUINTPTR])
+	n.PtrBody().Append(ir.NewAssignStmt(base.Pos, hn, mul))
 
 	var fn ir.Node
 	if a.Type().Elem().HasPointers() {
@@ -591,7 +591,7 @@ func arrayClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
 	n.PtrBody().Append(fn)
 
 	// i = len(a) - 1
-	v1 = ir.Nod(ir.OAS, v1, ir.Nod(ir.OSUB, ir.Nod(ir.OLEN, a, nil), nodintconst(1)))
+	v1 = ir.NewAssignStmt(base.Pos, v1, ir.NewBinaryExpr(base.Pos, ir.OSUB, ir.NewUnaryExpr(base.Pos, ir.OLEN, a), nodintconst(1)))
 
 	n.PtrBody().Append(v1)
 
@@ -605,12 +605,12 @@ func arrayClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
 func addptr(p ir.Node, n int64) ir.Node {
 	t := p.Type()
 
-	p = ir.Nod(ir.OCONVNOP, p, nil)
+	p = ir.NewConvExpr(base.Pos, ir.OCONVNOP, nil, p)
 	p.SetType(types.Types[types.TUINTPTR])
 
-	p = ir.Nod(ir.OADD, p, nodintconst(n))
+	p = ir.NewBinaryExpr(base.Pos, ir.OADD, p, nodintconst(n))
 
-	p = ir.Nod(ir.OCONVNOP, p, nil)
+	p = ir.NewConvExpr(base.Pos, ir.OCONVNOP, nil, p)
 	p.SetType(t)
 
 	return p
diff --git a/src/cmd/compile/internal/gc/select.go b/src/cmd/compile/internal/gc/select.go
index 974c4b254e..be2f688eb9 100644
--- a/src/cmd/compile/internal/gc/select.go
+++ b/src/cmd/compile/internal/gc/select.go
@@ -33,7 +33,7 @@ func typecheckselect(sel *ir.SelectStmt) {
 			ncase.SetLeft(n)
 			ncase.PtrList().Set(nil)
 			oselrecv2 := func(dst, recv ir.Node, colas bool) {
-				n := ir.NodAt(n.Pos(), ir.OSELRECV2, nil, nil)
+				n := ir.NewAssignListStmt(n.Pos(), ir.OSELRECV2, nil, nil)
 				n.PtrList().Set2(dst, ir.BlankNode)
 				n.PtrRlist().Set1(recv)
 				n.SetColas(colas)
@@ -145,7 +145,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 		}
 
 		l = append(l, cas.Body().Slice()...)
-		l = append(l, ir.Nod(ir.OBREAK, nil, nil))
+		l = append(l, ir.NewBranchStmt(base.Pos, ir.OBREAK, nil))
 		return l
 	}
 
@@ -182,7 +182,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 
 		n := cas.Left()
 		setlineno(n)
-		r := ir.Nod(ir.OIF, nil, nil)
+		r := ir.NewIfStmt(base.Pos, nil, nil, nil)
 		r.PtrInit().Set(cas.Init().Slice())
 		var call ir.Node
 		switch n.Op() {
@@ -215,7 +215,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 		r.SetLeft(typecheck(call, ctxExpr))
 		r.PtrBody().Set(cas.Body().Slice())
 		r.PtrRlist().Set(append(dflt.Init().Slice(), dflt.Body().Slice()...))
-		return []ir.Node{r, ir.Nod(ir.OBREAK, nil, nil)}
+		return []ir.Node{r, ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)}
 	}
 
 	if dflt != nil {
@@ -229,7 +229,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 	// generate sel-struct
 	base.Pos = sellineno
 	selv := temp(types.NewArray(scasetype(), int64(ncas)))
-	init = append(init, typecheck(ir.Nod(ir.OAS, selv, nil), ctxStmt))
+	init = append(init, typecheck(ir.NewAssignStmt(base.Pos, selv, nil), ctxStmt))
 
 	// No initialization for order; runtime.selectgo is responsible for that.
 	order := temp(types.NewArray(types.Types[types.TUINT16], 2*int64(ncas)))
@@ -237,7 +237,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 	var pc0, pcs ir.Node
 	if base.Flag.Race {
 		pcs = temp(types.NewArray(types.Types[types.TUINTPTR], int64(ncas)))
-		pc0 = typecheck(nodAddr(ir.Nod(ir.OINDEX, pcs, nodintconst(0))), ctxExpr)
+		pc0 = typecheck(nodAddr(ir.NewIndexExpr(base.Pos, pcs, nodintconst(0))), ctxExpr)
 	} else {
 		pc0 = nodnil()
 	}
@@ -276,7 +276,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 		casorder[i] = cas
 
 		setField := func(f string, val ir.Node) {
-			r := ir.Nod(ir.OAS, nodSym(ir.ODOT, ir.Nod(ir.OINDEX, selv, nodintconst(int64(i))), lookup(f)), val)
+			r := ir.NewAssignStmt(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, ir.NewIndexExpr(base.Pos, selv, nodintconst(int64(i))), lookup(f)), val)
 			init = append(init, typecheck(r, ctxStmt))
 		}
 
@@ -290,7 +290,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 		// TODO(mdempsky): There should be a cleaner way to
 		// handle this.
 		if base.Flag.Race {
-			r := mkcall("selectsetpc", nil, nil, nodAddr(ir.Nod(ir.OINDEX, pcs, nodintconst(int64(i)))))
+			r := mkcall("selectsetpc", nil, nil, nodAddr(ir.NewIndexExpr(base.Pos, pcs, nodintconst(int64(i)))))
 			init = append(init, r)
 		}
 	}
@@ -302,17 +302,17 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 	base.Pos = sellineno
 	chosen := temp(types.Types[types.TINT])
 	recvOK := temp(types.Types[types.TBOOL])
-	r := ir.Nod(ir.OAS2, nil, nil)
+	r := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
 	r.PtrList().Set2(chosen, recvOK)
 	fn := syslook("selectgo")
 	r.PtrRlist().Set1(mkcall1(fn, fn.Type().Results(), nil, bytePtrToIndex(selv, 0), bytePtrToIndex(order, 0), pc0, nodintconst(int64(nsends)), nodintconst(int64(nrecvs)), nodbool(dflt == nil)))
 	init = append(init, typecheck(r, ctxStmt))
 
 	// selv and order are no longer alive after selectgo.
-	init = append(init, ir.Nod(ir.OVARKILL, selv, nil))
-	init = append(init, ir.Nod(ir.OVARKILL, order, nil))
+	init = append(init, ir.NewUnaryExpr(base.Pos, ir.OVARKILL, selv))
+	init = append(init, ir.NewUnaryExpr(base.Pos, ir.OVARKILL, order))
 	if base.Flag.Race {
-		init = append(init, ir.Nod(ir.OVARKILL, pcs, nil))
+		init = append(init, ir.NewUnaryExpr(base.Pos, ir.OVARKILL, pcs))
 	}
 
 	// dispatch cases
@@ -320,27 +320,27 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 		cond = typecheck(cond, ctxExpr)
 		cond = defaultlit(cond, nil)
 
-		r := ir.Nod(ir.OIF, cond, nil)
+		r := ir.NewIfStmt(base.Pos, cond, nil, nil)
 
 		if n := cas.Left(); n != nil && n.Op() == ir.OSELRECV2 {
 			if !ir.IsBlank(n.List().Second()) {
-				x := ir.Nod(ir.OAS, n.List().Second(), recvOK)
+				x := ir.NewAssignStmt(base.Pos, n.List().Second(), recvOK)
 				r.PtrBody().Append(typecheck(x, ctxStmt))
 			}
 		}
 
 		r.PtrBody().AppendNodes(cas.PtrBody())
-		r.PtrBody().Append(ir.Nod(ir.OBREAK, nil, nil))
+		r.PtrBody().Append(ir.NewBranchStmt(base.Pos, ir.OBREAK, nil))
 		init = append(init, r)
 	}
 
 	if dflt != nil {
 		setlineno(dflt)
-		dispatch(ir.Nod(ir.OLT, chosen, nodintconst(0)), dflt)
+		dispatch(ir.NewBinaryExpr(base.Pos, ir.OLT, chosen, nodintconst(0)), dflt)
 	}
 	for i, cas := range casorder {
 		setlineno(cas)
-		dispatch(ir.Nod(ir.OEQ, chosen, nodintconst(int64(i))), cas)
+		dispatch(ir.NewBinaryExpr(base.Pos, ir.OEQ, chosen, nodintconst(int64(i))), cas)
 	}
 
 	return init
@@ -348,7 +348,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 
 // bytePtrToIndex returns a Node representing "(*byte)(&n[i])".
 func bytePtrToIndex(n ir.Node, i int64) ir.Node {
-	s := nodAddr(ir.Nod(ir.OINDEX, n, nodintconst(i)))
+	s := nodAddr(ir.NewIndexExpr(base.Pos, n, nodintconst(i)))
 	t := types.NewPtr(types.Types[types.TUINT8])
 	return convnop(s, t)
 }
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 79c7215d4d..5a96d4c320 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -113,7 +113,7 @@ func (s *InitSchedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *type
 		if loff != 0 || !types.Identical(typ, l.Type()) {
 			dst = ir.NewNameOffsetExpr(base.Pos, l, loff, typ)
 		}
-		s.append(ir.Nod(ir.OAS, dst, conv(r, typ)))
+		s.append(ir.NewAssignStmt(base.Pos, dst, conv(r, typ)))
 		return true
 
 	case ir.ONIL:
@@ -168,7 +168,7 @@ func (s *InitSchedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *type
 			ll := ir.NewNameOffsetExpr(base.Pos, l, loff+e.Xoffset, typ)
 			rr := ir.NewNameOffsetExpr(base.Pos, orig, e.Xoffset, typ)
 			setlineno(rr)
-			s.append(ir.Nod(ir.OAS, ll, rr))
+			s.append(ir.NewAssignStmt(base.Pos, ll, rr))
 		}
 
 		return true
@@ -219,7 +219,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 
 			// Init underlying literal.
 			if !s.staticassign(a, 0, r.Left(), a.Type()) {
-				s.append(ir.Nod(ir.OAS, a, r.Left()))
+				s.append(ir.NewAssignStmt(base.Pos, a, r.Left()))
 			}
 			return true
 		}
@@ -259,7 +259,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 			setlineno(e.Expr)
 			if !s.staticassign(l, loff+e.Xoffset, e.Expr, e.Expr.Type()) {
 				a := ir.NewNameOffsetExpr(base.Pos, l, loff+e.Xoffset, e.Expr.Type())
-				s.append(ir.Nod(ir.OAS, a, e.Expr))
+				s.append(ir.NewAssignStmt(base.Pos, a, e.Expr))
 			}
 		}
 
@@ -325,14 +325,14 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 			setlineno(val)
 			if !s.staticassign(l, loff+int64(Widthptr), val, val.Type()) {
 				a := ir.NewNameOffsetExpr(base.Pos, l, loff+int64(Widthptr), val.Type())
-				s.append(ir.Nod(ir.OAS, a, val))
+				s.append(ir.NewAssignStmt(base.Pos, a, val))
 			}
 		} else {
 			// Construct temp to hold val, write pointer to temp into n.
 			a := staticname(val.Type())
 			s.inittemps[val] = a
 			if !s.staticassign(a, 0, val, val.Type()) {
-				s.append(ir.Nod(ir.OAS, a, val))
+				s.append(ir.NewAssignStmt(base.Pos, a, val))
 			}
 			addrsym(l, loff+int64(Widthptr), a, 0)
 		}
@@ -405,7 +405,7 @@ func isSimpleName(nn ir.Node) bool {
 }
 
 func litas(l ir.Node, r ir.Node, init *ir.Nodes) {
-	appendWalkStmt(init, ir.Nod(ir.OAS, l, r))
+	appendWalkStmt(init, ir.NewAssignStmt(base.Pos, l, r))
 }
 
 // initGenType is a bitmap indicating the types of generation that will occur for a static value.
@@ -537,7 +537,7 @@ func fixedlit(ctxt initContext, kind initKind, n *ir.CompLitExpr, var_ ir.Node,
 				}
 				r = kv.Right()
 			}
-			a := ir.Nod(ir.OINDEX, var_, nodintconst(k))
+			a := ir.NewIndexExpr(base.Pos, var_, nodintconst(k))
 			k++
 			if isBlank {
 				return ir.BlankNode, r
@@ -551,7 +551,7 @@ func fixedlit(ctxt initContext, kind initKind, n *ir.CompLitExpr, var_ ir.Node,
 				return ir.BlankNode, r.Left()
 			}
 			setlineno(r)
-			return nodSym(ir.ODOT, var_, r.Sym()), r.Left()
+			return ir.NewSelectorExpr(base.Pos, ir.ODOT, var_, r.Sym()), r.Left()
 		}
 	default:
 		base.Fatalf("fixedlit bad op: %v", n.Op())
@@ -676,37 +676,37 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 		}
 
 		if vstat == nil {
-			a = ir.Nod(ir.OAS, x, nil)
+			a = ir.NewAssignStmt(base.Pos, x, nil)
 			a = typecheck(a, ctxStmt)
 			init.Append(a) // zero new temp
 		} else {
 			// Declare that we're about to initialize all of x.
 			// (Which happens at the *vauto = vstat below.)
-			init.Append(ir.Nod(ir.OVARDEF, x, nil))
+			init.Append(ir.NewUnaryExpr(base.Pos, ir.OVARDEF, x))
 		}
 
 		a = nodAddr(x)
 	} else if n.Esc() == EscNone {
 		a = temp(t)
 		if vstat == nil {
-			a = ir.Nod(ir.OAS, temp(t), nil)
+			a = ir.NewAssignStmt(base.Pos, temp(t), nil)
 			a = typecheck(a, ctxStmt)
 			init.Append(a) // zero new temp
 			a = a.(*ir.AssignStmt).Left()
 		} else {
-			init.Append(ir.Nod(ir.OVARDEF, a, nil))
+			init.Append(ir.NewUnaryExpr(base.Pos, ir.OVARDEF, a))
 		}
 
 		a = nodAddr(a)
 	} else {
-		a = ir.Nod(ir.ONEW, ir.TypeNode(t), nil)
+		a = ir.NewUnaryExpr(base.Pos, ir.ONEW, ir.TypeNode(t))
 	}
-	appendWalkStmt(init, ir.Nod(ir.OAS, vauto, a))
+	appendWalkStmt(init, ir.NewAssignStmt(base.Pos, vauto, a))
 
 	if vstat != nil {
 		// copy static to heap (4)
-		a = ir.Nod(ir.ODEREF, vauto, nil)
-		appendWalkStmt(init, ir.Nod(ir.OAS, a, vstat))
+		a = ir.NewStarExpr(base.Pos, vauto)
+		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, a, vstat))
 	}
 
 	// put dynamics into array (5)
@@ -720,7 +720,7 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 			}
 			value = kv.Right()
 		}
-		a := ir.Nod(ir.OINDEX, vauto, nodintconst(index))
+		a := ir.NewIndexExpr(base.Pos, vauto, nodintconst(index))
 		a.SetBounded(true)
 		index++
 
@@ -748,14 +748,14 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 
 		// build list of vauto[c] = expr
 		setlineno(value)
-		as := typecheck(ir.Nod(ir.OAS, a, value), ctxStmt)
+		as := typecheck(ir.NewAssignStmt(base.Pos, a, value), ctxStmt)
 		as = orderStmtInPlace(as, map[string][]*ir.Name{})
 		as = walkstmt(as)
 		init.Append(as)
 	}
 
 	// make slice out of heap (6)
-	a = ir.Nod(ir.OAS, var_, ir.Nod(ir.OSLICE, vauto, nil))
+	a = ir.NewAssignStmt(base.Pos, var_, ir.NewSliceExpr(base.Pos, ir.OSLICE, vauto))
 
 	a = typecheck(a, ctxStmt)
 	a = orderStmtInPlace(a, map[string][]*ir.Name{})
@@ -765,7 +765,7 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 
 func maplit(n *ir.CompLitExpr, m ir.Node, init *ir.Nodes) {
 	// make the map var
-	a := ir.Nod(ir.OMAKE, nil, nil)
+	a := ir.NewCallExpr(base.Pos, ir.OMAKE, nil, nil)
 	a.SetEsc(n.Esc())
 	a.PtrList().Set2(ir.TypeNode(n.Type()), nodintconst(int64(n.List().Len())))
 	litas(m, a, init)
@@ -813,19 +813,19 @@ func maplit(n *ir.CompLitExpr, m ir.Node, init *ir.Nodes) {
 		//	map[vstatk[i]] = vstate[i]
 		// }
 		i := temp(types.Types[types.TINT])
-		rhs := ir.Nod(ir.OINDEX, vstate, i)
+		rhs := ir.NewIndexExpr(base.Pos, vstate, i)
 		rhs.SetBounded(true)
 
-		kidx := ir.Nod(ir.OINDEX, vstatk, i)
+		kidx := ir.NewIndexExpr(base.Pos, vstatk, i)
 		kidx.SetBounded(true)
-		lhs := ir.Nod(ir.OINDEX, m, kidx)
+		lhs := ir.NewIndexExpr(base.Pos, m, kidx)
 
-		zero := ir.Nod(ir.OAS, i, nodintconst(0))
-		cond := ir.Nod(ir.OLT, i, nodintconst(tk.NumElem()))
-		incr := ir.Nod(ir.OAS, i, ir.Nod(ir.OADD, i, nodintconst(1)))
-		body := ir.Nod(ir.OAS, lhs, rhs)
+		zero := ir.NewAssignStmt(base.Pos, i, nodintconst(0))
+		cond := ir.NewBinaryExpr(base.Pos, ir.OLT, i, nodintconst(tk.NumElem()))
+		incr := ir.NewAssignStmt(base.Pos, i, ir.NewBinaryExpr(base.Pos, ir.OADD, i, nodintconst(1)))
+		body := ir.NewAssignStmt(base.Pos, lhs, rhs)
 
-		loop := ir.Nod(ir.OFOR, cond, incr)
+		loop := ir.NewForStmt(base.Pos, nil, cond, incr, nil)
 		loop.PtrBody().Set1(body)
 		loop.PtrInit().Set1(zero)
 
@@ -845,17 +845,17 @@ func maplit(n *ir.CompLitExpr, m ir.Node, init *ir.Nodes) {
 		index, elem := r.Left(), r.Right()
 
 		setlineno(index)
-		appendWalkStmt(init, ir.Nod(ir.OAS, tmpkey, index))
+		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, tmpkey, index))
 
 		setlineno(elem)
-		appendWalkStmt(init, ir.Nod(ir.OAS, tmpelem, elem))
+		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, tmpelem, elem))
 
 		setlineno(tmpelem)
-		appendWalkStmt(init, ir.Nod(ir.OAS, ir.Nod(ir.OINDEX, m, tmpkey), tmpelem))
+		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, ir.NewIndexExpr(base.Pos, m, tmpkey), tmpelem))
 	}
 
-	appendWalkStmt(init, ir.Nod(ir.OVARKILL, tmpkey, nil))
-	appendWalkStmt(init, ir.Nod(ir.OVARKILL, tmpelem, nil))
+	appendWalkStmt(init, ir.NewUnaryExpr(base.Pos, ir.OVARKILL, tmpkey))
+	appendWalkStmt(init, ir.NewUnaryExpr(base.Pos, ir.OVARKILL, tmpelem))
 }
 
 func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
@@ -879,15 +879,15 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 		var r ir.Node
 		if n.Right() != nil {
 			// n.Right is stack temporary used as backing store.
-			appendWalkStmt(init, ir.Nod(ir.OAS, n.Right(), nil)) // zero backing store, just in case (#18410)
+			appendWalkStmt(init, ir.NewAssignStmt(base.Pos, n.Right(), nil)) // zero backing store, just in case (#18410)
 			r = nodAddr(n.Right())
 		} else {
-			r = ir.Nod(ir.ONEW, ir.TypeNode(n.Left().Type()), nil)
+			r = ir.NewUnaryExpr(base.Pos, ir.ONEW, ir.TypeNode(n.Left().Type()))
 			r.SetEsc(n.Esc())
 		}
-		appendWalkStmt(init, ir.Nod(ir.OAS, var_, r))
+		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, r))
 
-		var_ = ir.Nod(ir.ODEREF, var_, nil)
+		var_ = ir.NewStarExpr(base.Pos, var_)
 		var_ = typecheck(var_, ctxExpr|ctxAssign)
 		anylit(n.Left(), var_, init)
 
@@ -908,7 +908,7 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 			fixedlit(ctxt, initKindStatic, n, vstat, init)
 
 			// copy static to var
-			appendWalkStmt(init, ir.Nod(ir.OAS, var_, vstat))
+			appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, vstat))
 
 			// add expressions to automatic
 			fixedlit(inInitFunction, initKindDynamic, n, var_, init)
@@ -923,7 +923,7 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 		}
 		// initialization of an array or struct with unspecified components (missing fields or arrays)
 		if isSimpleName(var_) || int64(n.List().Len()) < components {
-			appendWalkStmt(init, ir.Nod(ir.OAS, var_, nil))
+			appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, nil))
 		}
 
 		fixedlit(inInitFunction, initKindLocalCode, n, var_, init)
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 0f6c7023f2..174452def2 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -170,20 +170,6 @@ func NewName(s *types.Sym) *ir.Name {
 	return n
 }
 
-// nodSym makes a Node with Op op and with the Left field set to left
-// and the Sym field set to sym. This is for ODOT and friends.
-func nodSym(op ir.Op, left ir.Node, sym *types.Sym) ir.Node {
-	return nodlSym(base.Pos, op, left, sym)
-}
-
-// nodlSym makes a Node with position Pos, with Op op, and with the Left field set to left
-// and the Sym field set to sym. This is for ODOT and friends.
-func nodlSym(pos src.XPos, op ir.Op, left ir.Node, sym *types.Sym) ir.Node {
-	n := ir.NodAt(pos, op, left, nil)
-	n.SetSym(sym)
-	return n
-}
-
 // methcmp sorts methods by symbol.
 type methcmp []*types.Field
 
@@ -196,7 +182,7 @@ func nodintconst(v int64) ir.Node {
 }
 
 func nodnil() ir.Node {
-	n := ir.Nod(ir.ONIL, nil, nil)
+	n := ir.NewNilExpr(base.Pos)
 	n.SetType(types.Types[types.TNIL])
 	return n
 }
@@ -537,7 +523,7 @@ func assignconvfn(n ir.Node, t *types.Type, context func() string) ir.Node {
 	// if the next step is non-bool (like interface{}).
 	if n.Type() == types.UntypedBool && !t.IsBoolean() {
 		if n.Op() == ir.ONAME || n.Op() == ir.OLITERAL {
-			r := ir.Nod(ir.OCONVNOP, n, nil)
+			r := ir.NewConvExpr(base.Pos, ir.OCONVNOP, nil, n)
 			r.SetType(types.Types[types.TBOOL])
 			r.SetTypecheck(1)
 			r.SetImplicit(true)
@@ -569,13 +555,13 @@ func backingArrayPtrLen(n ir.Node) (ptr, length ir.Node) {
 	if c != n || init.Len() != 0 {
 		base.Fatalf("backingArrayPtrLen not cheap: %v", n)
 	}
-	ptr = ir.Nod(ir.OSPTR, n, nil)
+	ptr = ir.NewUnaryExpr(base.Pos, ir.OSPTR, n)
 	if n.Type().IsString() {
 		ptr.SetType(types.Types[types.TUINT8].PtrTo())
 	} else {
 		ptr.SetType(n.Type().Elem().PtrTo())
 	}
-	length = ir.Nod(ir.OLEN, n, nil)
+	length = ir.NewUnaryExpr(base.Pos, ir.OLEN, n)
 	length.SetType(types.Types[types.TINT])
 	return ptr, length
 }
@@ -834,7 +820,7 @@ func safeexpr(n ir.Node, init *ir.Nodes) ir.Node {
 
 func copyexpr(n ir.Node, t *types.Type, init *ir.Nodes) ir.Node {
 	l := temp(t)
-	appendWalkStmt(init, ir.Nod(ir.OAS, l, n))
+	appendWalkStmt(init, ir.NewAssignStmt(base.Pos, l, n))
 	return l
 }
 
@@ -1009,7 +995,7 @@ func adddot(n *ir.SelectorExpr) *ir.SelectorExpr {
 	case path != nil:
 		// rebuild elided dots
 		for c := len(path) - 1; c >= 0; c-- {
-			dot := nodSym(ir.ODOT, n.Left(), path[c].field.Sym)
+			dot := ir.NewSelectorExpr(base.Pos, ir.ODOT, n.Left(), path[c].field.Sym)
 			dot.SetImplicit(true)
 			dot.SetType(path[c].field.Type)
 			n.SetLeft(dot)
@@ -1222,9 +1208,9 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	// generate nil pointer check for better error
 	if rcvr.IsPtr() && rcvr.Elem() == methodrcvr {
 		// generating wrapper from *T to T.
-		n := ir.Nod(ir.OIF, nil, nil)
-		n.SetLeft(ir.Nod(ir.OEQ, nthis, nodnil()))
-		call := ir.Nod(ir.OCALL, syslook("panicwrap"), nil)
+		n := ir.NewIfStmt(base.Pos, nil, nil, nil)
+		n.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OEQ, nthis, nodnil()))
+		call := ir.NewCallExpr(base.Pos, ir.OCALL, syslook("panicwrap"), nil)
 		n.PtrBody().Set1(call)
 		fn.PtrBody().Append(n)
 	}
@@ -1244,16 +1230,16 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 		if !left.Type().IsPtr() {
 			left = nodAddr(left)
 		}
-		as := ir.Nod(ir.OAS, nthis, convnop(left, rcvr))
+		as := ir.NewAssignStmt(base.Pos, nthis, convnop(left, rcvr))
 		fn.PtrBody().Append(as)
-		fn.PtrBody().Append(nodSym(ir.ORETJMP, nil, methodSym(methodrcvr, method.Sym)))
+		fn.PtrBody().Append(ir.NewBranchStmt(base.Pos, ir.ORETJMP, methodSym(methodrcvr, method.Sym)))
 	} else {
 		fn.SetWrapper(true) // ignore frame for panic+recover matching
-		call := ir.Nod(ir.OCALL, dot, nil)
+		call := ir.NewCallExpr(base.Pos, ir.OCALL, dot, nil)
 		call.PtrList().Set(paramNnames(tfn.Type()))
 		call.SetIsDDD(tfn.Type().IsVariadic())
 		if method.Type.NumResults() > 0 {
-			ret := ir.Nod(ir.ORETURN, nil, nil)
+			ret := ir.NewReturnStmt(base.Pos, nil)
 			ret.PtrList().Set1(call)
 			fn.PtrBody().Append(ret)
 		} else {
@@ -1416,7 +1402,7 @@ func implements(t, iface *types.Type, m, samename **types.Field, ptr *int) bool
 }
 
 func liststmt(l []ir.Node) ir.Node {
-	n := ir.Nod(ir.OBLOCK, nil, nil)
+	n := ir.NewBlockStmt(base.Pos, nil)
 	n.PtrList().Set(l)
 	if len(l) != 0 {
 		n.SetPos(l[0].Pos())
@@ -1440,7 +1426,7 @@ func initExpr(init []ir.Node, n ir.Node) ir.Node {
 	if ir.MayBeShared(n) {
 		// Introduce OCONVNOP to hold init list.
 		old := n
-		n = ir.Nod(ir.OCONVNOP, old, nil)
+		n = ir.NewConvExpr(base.Pos, ir.OCONVNOP, nil, old)
 		n.SetType(old.Type())
 		n.SetTypecheck(1)
 	}
@@ -1534,7 +1520,7 @@ func isdirectiface(t *types.Type) bool {
 
 // itabType loads the _type field from a runtime.itab struct.
 func itabType(itab ir.Node) ir.Node {
-	typ := nodSym(ir.ODOTPTR, itab, nil)
+	typ := ir.NewSelectorExpr(base.Pos, ir.ODOTPTR, itab, nil)
 	typ.SetType(types.NewPtr(types.Types[types.TUINT8]))
 	typ.SetTypecheck(1)
 	typ.SetOffset(int64(Widthptr)) // offset of _type in runtime.itab
@@ -1549,7 +1535,7 @@ func ifaceData(pos src.XPos, n ir.Node, t *types.Type) ir.Node {
 	if t.IsInterface() {
 		base.Fatalf("ifaceData interface: %v", t)
 	}
-	ptr := ir.NodAt(pos, ir.OIDATA, n, nil)
+	ptr := ir.NewUnaryExpr(pos, ir.OIDATA, n)
 	if isdirectiface(t) {
 		ptr.SetType(t)
 		ptr.SetTypecheck(1)
@@ -1557,7 +1543,7 @@ func ifaceData(pos src.XPos, n ir.Node, t *types.Type) ir.Node {
 	}
 	ptr.SetType(types.NewPtr(t))
 	ptr.SetTypecheck(1)
-	ind := ir.NodAt(pos, ir.ODEREF, ptr, nil)
+	ind := ir.NewStarExpr(pos, ptr)
 	ind.SetType(t)
 	ind.SetTypecheck(1)
 	ind.SetBounded(true)
diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index 882feb47cc..1866a6a784 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -285,7 +285,7 @@ func walkExprSwitch(sw *ir.SwitchStmt) {
 	for _, ncase := range sw.List().Slice() {
 		ncase := ncase.(*ir.CaseStmt)
 		label := autolabel(".s")
-		jmp := npos(ncase.Pos(), nodSym(ir.OGOTO, nil, label))
+		jmp := ir.NewBranchStmt(ncase.Pos(), ir.OGOTO, label)
 
 		// Process case dispatch.
 		if ncase.List().Len() == 0 {
@@ -300,10 +300,10 @@ func walkExprSwitch(sw *ir.SwitchStmt) {
 		}
 
 		// Process body.
-		body.Append(npos(ncase.Pos(), nodSym(ir.OLABEL, nil, label)))
+		body.Append(ir.NewLabelStmt(ncase.Pos(), label))
 		body.Append(ncase.Body().Slice()...)
 		if fall, pos := endsInFallthrough(ncase.Body().Slice()); !fall {
-			br := ir.Nod(ir.OBREAK, nil, nil)
+			br := ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)
 			br.SetPos(pos)
 			body.Append(br)
 		}
@@ -311,7 +311,7 @@ func walkExprSwitch(sw *ir.SwitchStmt) {
 	sw.PtrList().Set(nil)
 
 	if defaultGoto == nil {
-		br := ir.Nod(ir.OBREAK, nil, nil)
+		br := ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)
 		br.SetPos(br.Pos().WithNotStmt())
 		defaultGoto = br
 	}
@@ -397,11 +397,11 @@ func (s *exprSwitch) flush() {
 		// Perform two-level binary search.
 		binarySearch(len(runs), &s.done,
 			func(i int) ir.Node {
-				return ir.Nod(ir.OLE, ir.Nod(ir.OLEN, s.exprname, nil), nodintconst(runLen(runs[i-1])))
+				return ir.NewBinaryExpr(base.Pos, ir.OLE, ir.NewUnaryExpr(base.Pos, ir.OLEN, s.exprname), nodintconst(runLen(runs[i-1])))
 			},
 			func(i int, nif *ir.IfStmt) {
 				run := runs[i]
-				nif.SetLeft(ir.Nod(ir.OEQ, ir.Nod(ir.OLEN, s.exprname, nil), nodintconst(runLen(run))))
+				nif.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OEQ, ir.NewUnaryExpr(base.Pos, ir.OLEN, s.exprname), nodintconst(runLen(run))))
 				s.search(run, nif.PtrBody())
 			},
 		)
@@ -432,7 +432,7 @@ func (s *exprSwitch) flush() {
 func (s *exprSwitch) search(cc []exprClause, out *ir.Nodes) {
 	binarySearch(len(cc), out,
 		func(i int) ir.Node {
-			return ir.Nod(ir.OLE, s.exprname, cc[i-1].hi)
+			return ir.NewBinaryExpr(base.Pos, ir.OLE, s.exprname, cc[i-1].hi)
 		},
 		func(i int, nif *ir.IfStmt) {
 			c := &cc[i]
@@ -445,9 +445,9 @@ func (s *exprSwitch) search(cc []exprClause, out *ir.Nodes) {
 func (c *exprClause) test(exprname ir.Node) ir.Node {
 	// Integer range.
 	if c.hi != c.lo {
-		low := ir.NodAt(c.pos, ir.OGE, exprname, c.lo)
-		high := ir.NodAt(c.pos, ir.OLE, exprname, c.hi)
-		return ir.NodAt(c.pos, ir.OANDAND, low, high)
+		low := ir.NewBinaryExpr(c.pos, ir.OGE, exprname, c.lo)
+		high := ir.NewBinaryExpr(c.pos, ir.OLE, exprname, c.hi)
+		return ir.NewLogicalExpr(c.pos, ir.OANDAND, low, high)
 	}
 
 	// Optimize "switch true { ...}" and "switch false { ... }".
@@ -455,11 +455,11 @@ func (c *exprClause) test(exprname ir.Node) ir.Node {
 		if ir.BoolVal(exprname) {
 			return c.lo
 		} else {
-			return ir.NodAt(c.pos, ir.ONOT, c.lo, nil)
+			return ir.NewUnaryExpr(c.pos, ir.ONOT, c.lo)
 		}
 	}
 
-	return ir.NodAt(c.pos, ir.OEQ, exprname, c.lo)
+	return ir.NewBinaryExpr(c.pos, ir.OEQ, exprname, c.lo)
 }
 
 func allCaseExprsAreSideEffectFree(sw *ir.SwitchStmt) bool {
@@ -513,7 +513,7 @@ func walkTypeSwitch(sw *ir.SwitchStmt) {
 	// Get interface descriptor word.
 	// For empty interfaces this will be the type.
 	// For non-empty interfaces this will be the itab.
-	itab := ir.Nod(ir.OITAB, s.facename, nil)
+	itab := ir.NewUnaryExpr(base.Pos, ir.OITAB, s.facename)
 
 	// For empty interfaces, do:
 	//     if e._type == nil {
@@ -521,8 +521,8 @@ func walkTypeSwitch(sw *ir.SwitchStmt) {
 	//     }
 	//     h := e._type.hash
 	// Use a similar strategy for non-empty interfaces.
-	ifNil := ir.Nod(ir.OIF, nil, nil)
-	ifNil.SetLeft(ir.Nod(ir.OEQ, itab, nodnil()))
+	ifNil := ir.NewIfStmt(base.Pos, nil, nil, nil)
+	ifNil.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OEQ, itab, nodnil()))
 	base.Pos = base.Pos.WithNotStmt() // disable statement marks after the first check.
 	ifNil.SetLeft(typecheck(ifNil.Left(), ctxExpr))
 	ifNil.SetLeft(defaultlit(ifNil.Left(), nil))
@@ -530,7 +530,7 @@ func walkTypeSwitch(sw *ir.SwitchStmt) {
 	sw.PtrBody().Append(ifNil)
 
 	// Load hash from type or itab.
-	dotHash := nodSym(ir.ODOTPTR, itab, nil)
+	dotHash := ir.NewSelectorExpr(base.Pos, ir.ODOTPTR, itab, nil)
 	dotHash.SetType(types.Types[types.TUINT32])
 	dotHash.SetTypecheck(1)
 	if s.facename.Type().IsEmptyInterface() {
@@ -541,7 +541,7 @@ func walkTypeSwitch(sw *ir.SwitchStmt) {
 	dotHash.SetBounded(true) // guaranteed not to fault
 	s.hashname = copyexpr(dotHash, dotHash.Type(), sw.PtrBody())
 
-	br := ir.Nod(ir.OBREAK, nil, nil)
+	br := ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)
 	var defaultGoto, nilGoto ir.Node
 	var body ir.Nodes
 	for _, ncase := range sw.List().Slice() {
@@ -561,7 +561,7 @@ func walkTypeSwitch(sw *ir.SwitchStmt) {
 		caseVarInitialized := false
 
 		label := autolabel(".s")
-		jmp := npos(ncase.Pos(), nodSym(ir.OGOTO, nil, label))
+		jmp := ir.NewBranchStmt(ncase.Pos(), ir.OGOTO, label)
 
 		if ncase.List().Len() == 0 { // default:
 			if defaultGoto != nil {
@@ -587,7 +587,7 @@ func walkTypeSwitch(sw *ir.SwitchStmt) {
 			}
 		}
 
-		body.Append(npos(ncase.Pos(), nodSym(ir.OLABEL, nil, label)))
+		body.Append(ir.NewLabelStmt(ncase.Pos(), label))
 		if caseVar != nil && !caseVarInitialized {
 			val := s.facename
 			if singleType != nil {
@@ -598,8 +598,8 @@ func walkTypeSwitch(sw *ir.SwitchStmt) {
 				val = ifaceData(ncase.Pos(), s.facename, singleType)
 			}
 			l := []ir.Node{
-				ir.NodAt(ncase.Pos(), ir.ODCL, caseVar, nil),
-				ir.NodAt(ncase.Pos(), ir.OAS, caseVar, val),
+				ir.NewDecl(ncase.Pos(), ir.ODCL, caseVar),
+				ir.NewAssignStmt(ncase.Pos(), caseVar, val),
 			}
 			typecheckslice(l, ctxStmt)
 			body.Append(l...)
@@ -644,8 +644,8 @@ func (s *typeSwitch) Add(pos src.XPos, typ *types.Type, caseVar, jmp ir.Node) {
 	var body ir.Nodes
 	if caseVar != nil {
 		l := []ir.Node{
-			ir.NodAt(pos, ir.ODCL, caseVar, nil),
-			ir.NodAt(pos, ir.OAS, caseVar, nil),
+			ir.NewDecl(pos, ir.ODCL, caseVar),
+			ir.NewAssignStmt(pos, caseVar, nil),
 		}
 		typecheckslice(l, ctxStmt)
 		body.Append(l...)
@@ -654,15 +654,15 @@ func (s *typeSwitch) Add(pos src.XPos, typ *types.Type, caseVar, jmp ir.Node) {
 	}
 
 	// cv, ok = iface.(type)
-	as := ir.NodAt(pos, ir.OAS2, nil, nil)
+	as := ir.NewAssignListStmt(pos, ir.OAS2, nil, nil)
 	as.PtrList().Set2(caseVar, s.okname) // cv, ok =
-	dot := ir.NodAt(pos, ir.ODOTTYPE, s.facename, nil)
+	dot := ir.NewTypeAssertExpr(pos, s.facename, nil)
 	dot.SetType(typ) // iface.(type)
 	as.PtrRlist().Set1(dot)
 	appendWalkStmt(&body, as)
 
 	// if ok { goto label }
-	nif := ir.NodAt(pos, ir.OIF, nil, nil)
+	nif := ir.NewIfStmt(pos, nil, nil, nil)
 	nif.SetLeft(s.okname)
 	nif.PtrBody().Set1(jmp)
 	body.Append(nif)
@@ -707,13 +707,13 @@ func (s *typeSwitch) flush() {
 
 	binarySearch(len(cc), &s.done,
 		func(i int) ir.Node {
-			return ir.Nod(ir.OLE, s.hashname, nodintconst(int64(cc[i-1].hash)))
+			return ir.NewBinaryExpr(base.Pos, ir.OLE, s.hashname, nodintconst(int64(cc[i-1].hash)))
 		},
 		func(i int, nif *ir.IfStmt) {
 			// TODO(mdempsky): Omit hash equality check if
 			// there's only one type.
 			c := cc[i]
-			nif.SetLeft(ir.Nod(ir.OEQ, s.hashname, nodintconst(int64(c.hash))))
+			nif.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OEQ, s.hashname, nodintconst(int64(c.hash))))
 			nif.PtrBody().AppendNodes(&c.body)
 		},
 	)
@@ -748,7 +748,7 @@ func binarySearch(n int, out *ir.Nodes, less func(i int) ir.Node, leaf func(i in
 		}
 
 		half := lo + n/2
-		nif := ir.Nod(ir.OIF, nil, nil)
+		nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
 		nif.SetLeft(less(half))
 		base.Pos = base.Pos.WithNotStmt()
 		nif.SetLeft(typecheck(nif.Left(), ctxExpr))
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index bb658999e5..db03fd9e75 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -1553,7 +1553,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				return n
 			}
 
-			n := ir.NodAt(n.Pos(), ir.OCONV, arg, nil)
+			n := ir.NewConvExpr(n.Pos(), ir.OCONV, nil, arg)
 			n.SetType(l.Type())
 			return typecheck1(n, top)
 		}
@@ -1979,7 +1979,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				n.SetType(nil)
 				return n
 			}
-			nn = ir.NodAt(n.Pos(), ir.OMAKESLICE, l, r)
+			nn = ir.NewMakeExpr(n.Pos(), ir.OMAKESLICE, l, r)
 
 		case types.TMAP:
 			if i < len(args) {
@@ -1998,7 +1998,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			} else {
 				l = nodintconst(0)
 			}
-			nn = ir.NodAt(n.Pos(), ir.OMAKEMAP, l, nil)
+			nn = ir.NewMakeExpr(n.Pos(), ir.OMAKEMAP, l, nil)
 			nn.SetEsc(n.Esc())
 
 		case types.TCHAN:
@@ -2019,7 +2019,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			} else {
 				l = nodintconst(0)
 			}
-			nn = ir.NodAt(n.Pos(), ir.OMAKECHAN, l, nil)
+			nn = ir.NewMakeExpr(n.Pos(), ir.OMAKECHAN, l, nil)
 		}
 
 		if i < len(args) {
@@ -2170,7 +2170,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			// Empty identifier is valid but useless.
 			// Eliminate now to simplify life later.
 			// See issues 7538, 11589, 11593.
-			n = ir.NodAt(n.Pos(), ir.OBLOCK, nil, nil)
+			n = ir.NewBlockStmt(n.Pos(), nil)
 		}
 		return n
 
@@ -2300,7 +2300,7 @@ func typecheckargs(n ir.Node) {
 		n.(ir.OrigNode).SetOrig(ir.SepCopy(n))
 	}
 
-	as := ir.Nod(ir.OAS2, nil, nil)
+	as := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
 	as.PtrRlist().Append(list...)
 
 	// If we're outside of function context, then this call will
@@ -2315,7 +2315,7 @@ func typecheckargs(n ir.Node) {
 	list = nil
 	for _, f := range t.FieldSlice() {
 		t := temp(f.Type)
-		as.PtrInit().Append(ir.Nod(ir.ODCL, t, nil))
+		as.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, t))
 		as.PtrList().Append(t)
 		list = append(list, t)
 	}
@@ -2440,7 +2440,7 @@ func implicitstar(n ir.Node) ir.Node {
 	if !t.IsArray() {
 		return n
 	}
-	star := ir.Nod(ir.ODEREF, n, nil)
+	star := ir.NewStarExpr(base.Pos, n)
 	star.SetImplicit(true)
 	return typecheck(star, ctxExpr)
 }
@@ -2619,7 +2619,7 @@ func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 		n.SetType(f1.Type)
 		if t.IsInterface() {
 			if n.Left().Type().IsPtr() {
-				star := ir.Nod(ir.ODEREF, n.Left(), nil)
+				star := ir.NewStarExpr(base.Pos, n.Left())
 				star.SetImplicit(true)
 				n.SetLeft(typecheck(star, ctxExpr))
 			}
@@ -2645,7 +2645,7 @@ func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 				addr.SetImplicit(true)
 				n.SetLeft(typecheck(addr, ctxType|ctxExpr))
 			} else if tt.IsPtr() && (!rcvr.IsPtr() || rcvr.IsPtr() && rcvr.Elem().NotInHeap()) && types.Identical(tt.Elem(), rcvr) {
-				star := ir.Nod(ir.ODEREF, n.Left(), nil)
+				star := ir.NewStarExpr(base.Pos, n.Left())
 				star.SetImplicit(true)
 				n.SetLeft(typecheck(star, ctxType|ctxExpr))
 			} else if tt.IsPtr() && tt.Elem().IsPtr() && types.Identical(derefall(tt), derefall(rcvr)) {
@@ -2655,7 +2655,7 @@ func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 					if rcvr.IsPtr() && !tt.Elem().IsPtr() {
 						break
 					}
-					star := ir.Nod(ir.ODEREF, n.Left(), nil)
+					star := ir.NewStarExpr(base.Pos, n.Left())
 					star.SetImplicit(true)
 					n.SetLeft(typecheck(star, ctxType|ctxExpr))
 					tt = tt.Elem()
@@ -3055,7 +3055,7 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 				}
 				// No pushtype allowed here. Must name fields for that.
 				n1 = assignconv(n1, f.Type, "field value")
-				sk := nodSym(ir.OSTRUCTKEY, n1, f.Sym)
+				sk := ir.NewStructKeyExpr(base.Pos, f.Sym, n1)
 				sk.SetOffset(f.Offset)
 				ls[i] = sk
 			}
@@ -3614,11 +3614,11 @@ func stringtoruneslit(n *ir.ConvExpr) ir.Node {
 	var l []ir.Node
 	i := 0
 	for _, r := range ir.StringVal(n.Left()) {
-		l = append(l, ir.Nod(ir.OKEY, nodintconst(int64(i)), nodintconst(int64(r))))
+		l = append(l, ir.NewKeyExpr(base.Pos, nodintconst(int64(i)), nodintconst(int64(r))))
 		i++
 	}
 
-	nn := ir.Nod(ir.OCOMPLIT, nil, ir.TypeNode(n.Type()))
+	nn := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(n.Type()).(ir.Ntype), nil)
 	nn.PtrList().Set(l)
 	return typecheck(nn, ctxExpr)
 }
@@ -4064,7 +4064,7 @@ func deadcode(fn *ir.Func) {
 		}
 	}
 
-	fn.PtrBody().Set([]ir.Node{ir.Nod(ir.OBLOCK, nil, nil)})
+	fn.PtrBody().Set([]ir.Node{ir.NewBlockStmt(base.Pos, nil)})
 }
 
 func deadcodeslice(nn *ir.Nodes) {
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index d5d12453a7..17269746e6 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -210,7 +210,7 @@ func walkstmt(n ir.Node) ir.Node {
 			if base.Flag.CompilingRuntime {
 				base.Errorf("%v escapes to heap, not allowed in runtime", v)
 			}
-			nn := ir.Nod(ir.OAS, v.Name().Heapaddr, callnew(v.Type()))
+			nn := ir.NewAssignStmt(base.Pos, v.Name().Heapaddr, callnew(v.Type()))
 			nn.SetColas(true)
 			return walkstmt(typecheck(nn, ctxStmt))
 		}
@@ -315,7 +315,7 @@ func walkstmt(n ir.Node) ir.Node {
 				if cl == ir.PPARAMOUT {
 					var ln ir.Node = ln
 					if isParamStackCopy(ln) {
-						ln = walkexpr(typecheck(ir.Nod(ir.ODEREF, ln.Name().Heapaddr, nil), ctxExpr), nil)
+						ln = walkexpr(typecheck(ir.NewStarExpr(base.Pos, ln.Name().Heapaddr), ctxExpr), nil)
 					}
 					rl = append(rl, ln)
 				}
@@ -489,7 +489,7 @@ func walkexpr(n ir.Node, init *ir.Nodes) ir.Node {
 	}
 
 	if n.Op() == ir.ONAME && n.(*ir.Name).Class() == ir.PAUTOHEAP {
-		nn := ir.Nod(ir.ODEREF, n.Name().Heapaddr, nil)
+		nn := ir.NewStarExpr(base.Pos, n.Name().Heapaddr)
 		nn.Left().MarkNonNil()
 		return walkexpr(typecheck(nn, ctxExpr), init)
 	}
@@ -697,15 +697,14 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 		if n.Op() == ir.OASOP {
 			// Rewrite x op= y into x = x op y.
-			n = ir.Nod(ir.OAS, left,
-				typecheck(ir.NewBinaryExpr(base.Pos, n.(*ir.AssignOpStmt).SubOp(), left, right), ctxExpr))
+			n = ir.NewAssignStmt(base.Pos, left, typecheck(ir.NewBinaryExpr(base.Pos, n.(*ir.AssignOpStmt).SubOp(), left, right), ctxExpr))
 		} else {
 			n.(*ir.AssignStmt).SetLeft(left)
 		}
 		as := n.(*ir.AssignStmt)
 
 		if oaslit(as, init) {
-			return ir.NodAt(as.Pos(), ir.OBLOCK, nil, nil)
+			return ir.NewBlockStmt(as.Pos(), nil)
 		}
 
 		if as.Right() == nil {
@@ -804,7 +803,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		fn := chanfn("chanrecv2", 2, r.Left().Type())
 		ok := n.List().Second()
 		call := mkcall1(fn, types.Types[types.TBOOL], init, r.Left(), n1)
-		return typecheck(ir.Nod(ir.OAS, ok, call), ctxStmt)
+		return typecheck(ir.NewAssignStmt(base.Pos, ok, call), ctxStmt)
 
 	// a,b = m[i]
 	case ir.OAS2MAPR:
@@ -865,7 +864,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		n.List().SetFirst(var_)
 		init.Append(walkexpr(n, init))
 
-		as := ir.Nod(ir.OAS, a, ir.Nod(ir.ODEREF, var_, nil))
+		as := ir.NewAssignStmt(base.Pos, a, ir.NewStarExpr(base.Pos, var_))
 		return walkexpr(typecheck(as, ctxStmt), init)
 
 	case ir.ODELETE:
@@ -908,7 +907,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 		// Optimize convT2E or convT2I as a two-word copy when T is pointer-shaped.
 		if isdirectiface(fromType) {
-			l := ir.Nod(ir.OEFACE, typeword(), n.Left())
+			l := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), n.Left())
 			l.SetType(toType)
 			l.SetTypecheck(n.Typecheck())
 			return l
@@ -939,11 +938,11 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			// and staticuint64s[n.Left * 8 + 7] on big-endian.
 			n.SetLeft(cheapexpr(n.Left(), init))
 			// byteindex widens n.Left so that the multiplication doesn't overflow.
-			index := ir.Nod(ir.OLSH, byteindex(n.Left()), nodintconst(3))
+			index := ir.NewBinaryExpr(base.Pos, ir.OLSH, byteindex(n.Left()), nodintconst(3))
 			if thearch.LinkArch.ByteOrder == binary.BigEndian {
-				index = ir.Nod(ir.OADD, index, nodintconst(7))
+				index = ir.NewBinaryExpr(base.Pos, ir.OADD, index, nodintconst(7))
 			}
-			xe := ir.Nod(ir.OINDEX, staticuint64s, index)
+			xe := ir.NewIndexExpr(base.Pos, staticuint64s, index)
 			xe.SetBounded(true)
 			value = xe
 		case n.Left().Op() == ir.ONAME && n.Left().(*ir.Name).Class() == ir.PEXTERN && n.Left().(*ir.Name).Readonly():
@@ -952,13 +951,13 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		case !fromType.IsInterface() && n.Esc() == EscNone && fromType.Width <= 1024:
 			// n.Left does not escape. Use a stack temporary initialized to n.Left.
 			value = temp(fromType)
-			init.Append(typecheck(ir.Nod(ir.OAS, value, n.Left()), ctxStmt))
+			init.Append(typecheck(ir.NewAssignStmt(base.Pos, value, n.Left()), ctxStmt))
 		}
 
 		if value != nil {
 			// Value is identical to n.Left.
 			// Construct the interface directly: {type/itab, &value}.
-			l := ir.Nod(ir.OEFACE, typeword(), typecheck(nodAddr(value), ctxExpr))
+			l := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), typecheck(nodAddr(value), ctxExpr))
 			l.SetType(toType)
 			l.SetTypecheck(n.Typecheck())
 			return l
@@ -973,19 +972,19 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		if toType.IsEmptyInterface() && fromType.IsInterface() && !fromType.IsEmptyInterface() {
 			// Evaluate the input interface.
 			c := temp(fromType)
-			init.Append(ir.Nod(ir.OAS, c, n.Left()))
+			init.Append(ir.NewAssignStmt(base.Pos, c, n.Left()))
 
 			// Get the itab out of the interface.
 			tmp := temp(types.NewPtr(types.Types[types.TUINT8]))
-			init.Append(ir.Nod(ir.OAS, tmp, typecheck(ir.Nod(ir.OITAB, c, nil), ctxExpr)))
+			init.Append(ir.NewAssignStmt(base.Pos, tmp, typecheck(ir.NewUnaryExpr(base.Pos, ir.OITAB, c), ctxExpr)))
 
 			// Get the type out of the itab.
-			nif := ir.Nod(ir.OIF, typecheck(ir.Nod(ir.ONE, tmp, nodnil()), ctxExpr), nil)
-			nif.PtrBody().Set1(ir.Nod(ir.OAS, tmp, itabType(tmp)))
+			nif := ir.NewIfStmt(base.Pos, typecheck(ir.NewBinaryExpr(base.Pos, ir.ONE, tmp, nodnil()), ctxExpr), nil, nil)
+			nif.PtrBody().Set1(ir.NewAssignStmt(base.Pos, tmp, itabType(tmp)))
 			init.Append(nif)
 
 			// Build the result.
-			e := ir.Nod(ir.OEFACE, tmp, ifaceData(n.Pos(), c, types.NewPtr(types.Types[types.TUINT8])))
+			e := ir.NewBinaryExpr(base.Pos, ir.OEFACE, tmp, ifaceData(n.Pos(), c, types.NewPtr(types.Types[types.TUINT8])))
 			e.SetType(toType) // assign type manually, typecheck doesn't understand OEFACE.
 			e.SetTypecheck(1)
 			return e
@@ -1001,9 +1000,9 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			dowidth(fromType)
 			fn = substArgTypes(fn, fromType)
 			dowidth(fn.Type())
-			call := ir.Nod(ir.OCALL, fn, nil)
+			call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
 			call.PtrList().Set1(n.Left())
-			e := ir.Nod(ir.OEFACE, typeword(), safeexpr(walkexpr(typecheck(call, ctxExpr), init), init))
+			e := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), safeexpr(walkexpr(typecheck(call, ctxExpr), init), init))
 			e.SetType(toType)
 			e.SetTypecheck(1)
 			return e
@@ -1036,7 +1035,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		fn := syslook(fnname)
 		fn = substArgTypes(fn, fromType, toType)
 		dowidth(fn.Type())
-		call := ir.Nod(ir.OCALL, fn, nil)
+		call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
 		call.PtrList().Set2(tab, v)
 		return walkexpr(typecheck(call, ctxExpr), init)
 
@@ -1198,7 +1197,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		}
 		call.SetType(types.NewPtr(t.Elem()))
 		call.MarkNonNil() // mapaccess1* and mapassign always return non-nil pointers.
-		star := ir.Nod(ir.ODEREF, call, nil)
+		star := ir.NewStarExpr(base.Pos, call)
 		star.SetType(t.Elem())
 		star.SetTypecheck(1)
 		return star
@@ -1260,7 +1259,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 				base.Fatalf("large ONEW with EscNone: %v", n)
 			}
 			r := temp(n.Type().Elem())
-			init.Append(typecheck(ir.Nod(ir.OAS, r, nil), ctxStmt)) // zero temp
+			init.Append(typecheck(ir.NewAssignStmt(base.Pos, r, nil), ctxStmt)) // zero temp
 			return typecheck(nodAddr(r), ctxExpr)
 		}
 		return callnew(n.Type().Elem())
@@ -1311,7 +1310,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 			// var hv hmap
 			hv := temp(hmapType)
-			init.Append(typecheck(ir.Nod(ir.OAS, hv, nil), ctxStmt))
+			init.Append(typecheck(ir.NewAssignStmt(base.Pos, hv, nil), ctxStmt))
 			// h = &hv
 			h = nodAddr(hv)
 
@@ -1332,19 +1331,19 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 				//     h.buckets = b
 				// }
 
-				nif := ir.Nod(ir.OIF, ir.Nod(ir.OLE, hint, nodintconst(BUCKETSIZE)), nil)
+				nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OLE, hint, nodintconst(BUCKETSIZE)), nil, nil)
 				nif.SetLikely(true)
 
 				// var bv bmap
 				bv := temp(bmap(t))
-				nif.PtrBody().Append(ir.Nod(ir.OAS, bv, nil))
+				nif.PtrBody().Append(ir.NewAssignStmt(base.Pos, bv, nil))
 
 				// b = &bv
 				b := nodAddr(bv)
 
 				// h.buckets = b
 				bsym := hmapType.Field(5).Sym // hmap.buckets see reflect.go:hmap
-				na := ir.Nod(ir.OAS, nodSym(ir.ODOT, h, bsym), b)
+				na := ir.NewAssignStmt(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, h, bsym), b)
 				nif.PtrBody().Append(na)
 				appendWalkStmt(init, nif)
 			}
@@ -1364,7 +1363,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 				// h.hash0 = fastrand()
 				rand := mkcall("fastrand", types.Types[types.TUINT32], init)
 				hashsym := hmapType.Field(4).Sym // hmap.hash0 see reflect.go:hmap
-				appendWalkStmt(init, ir.Nod(ir.OAS, nodSym(ir.ODOT, h, hashsym), rand))
+				appendWalkStmt(init, ir.NewAssignStmt(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, h, hashsym), rand))
 				return convnop(h, t)
 			}
 			// Call runtime.makehmap to allocate an
@@ -1429,16 +1428,16 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			//     if len < 0 { panicmakeslicelen() }
 			//     panicmakeslicecap()
 			// }
-			nif := ir.Nod(ir.OIF, ir.Nod(ir.OGT, conv(l, types.Types[types.TUINT64]), nodintconst(i)), nil)
-			niflen := ir.Nod(ir.OIF, ir.Nod(ir.OLT, l, nodintconst(0)), nil)
+			nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGT, conv(l, types.Types[types.TUINT64]), nodintconst(i)), nil, nil)
+			niflen := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OLT, l, nodintconst(0)), nil, nil)
 			niflen.PtrBody().Set1(mkcall("panicmakeslicelen", nil, init))
 			nif.PtrBody().Append(niflen, mkcall("panicmakeslicecap", nil, init))
 			init.Append(typecheck(nif, ctxStmt))
 
 			t = types.NewArray(t.Elem(), i) // [r]T
 			var_ := temp(t)
-			appendWalkStmt(init, ir.Nod(ir.OAS, var_, nil)) // zero temp
-			r := ir.Nod(ir.OSLICE, var_, nil)               // arr[:l]
+			appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, nil)) // zero temp
+			r := ir.NewSliceExpr(base.Pos, ir.OSLICE, var_)             // arr[:l]
 			r.SetSliceBounds(nil, l, nil)
 			// The conv is necessary in case n.Type is named.
 			return walkexpr(typecheck(conv(r, n.Type()), ctxExpr), init)
@@ -1462,7 +1461,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			argtype = types.Types[types.TINT]
 		}
 
-		m := ir.Nod(ir.OSLICEHEADER, nil, nil)
+		m := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
 		m.SetType(t)
 
 		fn := syslook(fnname)
@@ -1482,8 +1481,8 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		}
 
 		length := conv(n.Left(), types.Types[types.TINT])
-		copylen := ir.Nod(ir.OLEN, n.Right(), nil)
-		copyptr := ir.Nod(ir.OSPTR, n.Right(), nil)
+		copylen := ir.NewUnaryExpr(base.Pos, ir.OLEN, n.Right())
+		copyptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, n.Right())
 
 		if !t.Elem().HasPointers() && n.Bounded() {
 			// When len(to)==len(from) and elements have no pointers:
@@ -1492,25 +1491,25 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			// We do not check for overflow of len(to)*elem.Width here
 			// since len(from) is an existing checked slice capacity
 			// with same elem.Width for the from slice.
-			size := ir.Nod(ir.OMUL, conv(length, types.Types[types.TUINTPTR]), conv(nodintconst(t.Elem().Width), types.Types[types.TUINTPTR]))
+			size := ir.NewBinaryExpr(base.Pos, ir.OMUL, conv(length, types.Types[types.TUINTPTR]), conv(nodintconst(t.Elem().Width), types.Types[types.TUINTPTR]))
 
 			// instantiate mallocgc(size uintptr, typ *byte, needszero bool) unsafe.Pointer
 			fn := syslook("mallocgc")
-			sh := ir.Nod(ir.OSLICEHEADER, nil, nil)
+			sh := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
 			sh.SetLeft(mkcall1(fn, types.Types[types.TUNSAFEPTR], init, size, nodnil(), nodbool(false)))
 			sh.Left().MarkNonNil()
 			sh.PtrList().Set2(length, length)
 			sh.SetType(t)
 
 			s := temp(t)
-			r := typecheck(ir.Nod(ir.OAS, s, sh), ctxStmt)
+			r := typecheck(ir.NewAssignStmt(base.Pos, s, sh), ctxStmt)
 			r = walkexpr(r, init)
 			init.Append(r)
 
 			// instantiate memmove(to *any, frm *any, size uintptr)
 			fn = syslook("memmove")
 			fn = substArgTypes(fn, t.Elem(), t.Elem())
-			ncopy := mkcall1(fn, nil, init, ir.Nod(ir.OSPTR, s, nil), copyptr, size)
+			ncopy := mkcall1(fn, nil, init, ir.NewUnaryExpr(base.Pos, ir.OSPTR, s), copyptr, size)
 			init.Append(walkexpr(typecheck(ncopy, ctxStmt), init))
 
 			return s
@@ -1518,7 +1517,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		// Replace make+copy with runtime.makeslicecopy.
 		// instantiate makeslicecopy(typ *byte, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointer
 		fn := syslook("makeslicecopy")
-		s := ir.Nod(ir.OSLICEHEADER, nil, nil)
+		s := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
 		s.SetLeft(mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), length, copylen, conv(copyptr, types.Types[types.TUNSAFEPTR])))
 		s.Left().MarkNonNil()
 		s.PtrList().Set2(length, length)
@@ -1576,18 +1575,16 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 				a = callnew(t)
 			}
 			p := temp(t.PtrTo()) // *[n]byte
-			init.Append(typecheck(ir.Nod(ir.OAS, p, a), ctxStmt))
+			init.Append(typecheck(ir.NewAssignStmt(base.Pos, p, a), ctxStmt))
 
 			// Copy from the static string data to the [n]byte.
 			if len(sc) > 0 {
-				as := ir.Nod(ir.OAS,
-					ir.Nod(ir.ODEREF, p, nil),
-					ir.Nod(ir.ODEREF, convnop(ir.Nod(ir.OSPTR, s, nil), t.PtrTo()), nil))
+				as := ir.NewAssignStmt(base.Pos, ir.NewStarExpr(base.Pos, p), ir.NewStarExpr(base.Pos, convnop(ir.NewUnaryExpr(base.Pos, ir.OSPTR, s), t.PtrTo())))
 				appendWalkStmt(init, as)
 			}
 
 			// Slice the [n]byte to a []byte.
-			slice := ir.NodAt(n.Pos(), ir.OSLICEARR, p, nil)
+			slice := ir.NewSliceExpr(n.Pos(), ir.OSLICEARR, p)
 			slice.SetType(n.Type())
 			slice.SetTypecheck(1)
 			return walkexpr(slice, init)
@@ -1830,7 +1827,7 @@ func ascompatet(nl ir.Nodes, nr *types.Type) []ir.Node {
 			l = tmp
 		}
 
-		res := ir.Nod(ir.ORESULT, nil, nil)
+		res := ir.NewResultExpr(base.Pos, nil, types.BADWIDTH)
 		res.SetOffset(base.Ctxt.FixedFrameSize() + r.Offset)
 		res.SetType(r.Type)
 		res.SetTypecheck(1)
@@ -1854,7 +1851,7 @@ func mkdotargslice(typ *types.Type, args []ir.Node) ir.Node {
 		n = nodnil()
 		n.SetType(typ)
 	} else {
-		lit := ir.Nod(ir.OCOMPLIT, nil, ir.TypeNode(typ))
+		lit := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ).(ir.Ntype), nil)
 		lit.PtrList().Append(args...)
 		lit.SetImplicit(true)
 		n = lit
@@ -2017,9 +2014,9 @@ func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 		case types.TPTR:
 			if n.Type().Elem().NotInHeap() {
 				on = syslook("printuintptr")
-				n = ir.Nod(ir.OCONV, n, nil)
+				n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
 				n.SetType(types.Types[types.TUNSAFEPTR])
-				n = ir.Nod(ir.OCONV, n, nil)
+				n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
 				n.SetType(types.Types[types.TUINTPTR])
 				break
 			}
@@ -2062,11 +2059,11 @@ func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 			continue
 		}
 
-		r := ir.Nod(ir.OCALL, on, nil)
+		r := ir.NewCallExpr(base.Pos, ir.OCALL, on, nil)
 		if params := on.Type().Params().FieldSlice(); len(params) > 0 {
 			t := params[0].Type
 			if !types.Identical(t, n.Type()) {
-				n = ir.Nod(ir.OCONV, n, nil)
+				n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
 				n.SetType(t)
 			}
 			r.PtrList().Append(n)
@@ -2079,14 +2076,14 @@ func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 	typecheckslice(calls, ctxStmt)
 	walkexprlist(calls, init)
 
-	r := ir.Nod(ir.OBLOCK, nil, nil)
+	r := ir.NewBlockStmt(base.Pos, nil)
 	r.PtrList().Set(calls)
 	return walkstmt(typecheck(r, ctxStmt))
 }
 
 func callnew(t *types.Type) ir.Node {
 	dowidth(t)
-	n := ir.Nod(ir.ONEWOBJ, typename(t), nil)
+	n := ir.NewUnaryExpr(base.Pos, ir.ONEWOBJ, typename(t))
 	n.SetType(types.NewPtr(t))
 	n.SetTypecheck(1)
 	n.MarkNonNil()
@@ -2228,7 +2225,7 @@ func reorder3save(n ir.Node, all []*ir.AssignStmt, i int, early *[]ir.Node) ir.N
 	}
 
 	q := ir.Node(temp(n.Type()))
-	as := typecheck(ir.Nod(ir.OAS, q, n), ctxStmt)
+	as := typecheck(ir.NewAssignStmt(base.Pos, q, n), ctxStmt)
 	*early = append(*early, as)
 	return q
 }
@@ -2447,9 +2444,9 @@ func paramstoheap(params *types.Type) []ir.Node {
 		}
 
 		if stackcopy := v.Name().Stackcopy; stackcopy != nil {
-			nn = append(nn, walkstmt(ir.Nod(ir.ODCL, v, nil)))
+			nn = append(nn, walkstmt(ir.NewDecl(base.Pos, ir.ODCL, v)))
 			if stackcopy.Class() == ir.PPARAM {
-				nn = append(nn, walkstmt(typecheck(ir.Nod(ir.OAS, v, stackcopy), ctxStmt)))
+				nn = append(nn, walkstmt(typecheck(ir.NewAssignStmt(base.Pos, v, stackcopy), ctxStmt)))
 			}
 		}
 	}
@@ -2483,7 +2480,7 @@ func zeroResults() {
 			v = v.Name().Stackcopy
 		}
 		// Zero the stack location containing f.
-		Curfn.Enter.Append(ir.NodAt(Curfn.Pos(), ir.OAS, v, nil))
+		Curfn.Enter.Append(ir.NewAssignStmt(Curfn.Pos(), v, nil))
 	}
 }
 
@@ -2497,7 +2494,7 @@ func returnsfromheap(params *types.Type) []ir.Node {
 			continue
 		}
 		if stackcopy := v.Name().Stackcopy; stackcopy != nil && stackcopy.Class() == ir.PPARAMOUT {
-			nn = append(nn, walkstmt(typecheck(ir.Nod(ir.OAS, stackcopy, v), ctxStmt)))
+			nn = append(nn, walkstmt(typecheck(ir.NewAssignStmt(base.Pos, stackcopy, v), ctxStmt)))
 		}
 	}
 
@@ -2547,7 +2544,7 @@ func conv(n ir.Node, t *types.Type) ir.Node {
 	if types.Identical(n.Type(), t) {
 		return n
 	}
-	n = ir.Nod(ir.OCONV, n, nil)
+	n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
 	n.SetType(t)
 	n = typecheck(n, ctxExpr)
 	return n
@@ -2559,7 +2556,7 @@ func convnop(n ir.Node, t *types.Type) ir.Node {
 	if types.Identical(n.Type(), t) {
 		return n
 	}
-	n = ir.Nod(ir.OCONVNOP, n, nil)
+	n = ir.NewConvExpr(base.Pos, ir.OCONVNOP, nil, n)
 	n.SetType(t)
 	n = typecheck(n, ctxExpr)
 	return n
@@ -2574,11 +2571,11 @@ func byteindex(n ir.Node) ir.Node {
 	// the wrong result for negative values.
 	// Reinterpreting the value as an unsigned byte solves both cases.
 	if !types.Identical(n.Type(), types.Types[types.TUINT8]) {
-		n = ir.Nod(ir.OCONV, n, nil)
+		n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
 		n.SetType(types.Types[types.TUINT8])
 		n.SetTypecheck(1)
 	}
-	n = ir.Nod(ir.OCONV, n, nil)
+	n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
 	n.SetType(types.Types[types.TINT])
 	n.SetTypecheck(1)
 	return n
@@ -2722,7 +2719,7 @@ func addstr(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
 	}
 
 	cat := syslook(fn)
-	r := ir.Nod(ir.OCALL, cat, nil)
+	r := ir.NewCallExpr(base.Pos, ir.OCALL, cat, nil)
 	r.PtrList().Set(args)
 	r1 := typecheck(r, ctxExpr)
 	r1 = walkexpr(r1, init)
@@ -2769,40 +2766,40 @@ func appendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 
 	// var s []T
 	s := temp(l1.Type())
-	nodes.Append(ir.Nod(ir.OAS, s, l1)) // s = l1
+	nodes.Append(ir.NewAssignStmt(base.Pos, s, l1)) // s = l1
 
 	elemtype := s.Type().Elem()
 
 	// n := len(s) + len(l2)
 	nn := temp(types.Types[types.TINT])
-	nodes.Append(ir.Nod(ir.OAS, nn, ir.Nod(ir.OADD, ir.Nod(ir.OLEN, s, nil), ir.Nod(ir.OLEN, l2, nil))))
+	nodes.Append(ir.NewAssignStmt(base.Pos, nn, ir.NewBinaryExpr(base.Pos, ir.OADD, ir.NewUnaryExpr(base.Pos, ir.OLEN, s), ir.NewUnaryExpr(base.Pos, ir.OLEN, l2))))
 
 	// if uint(n) > uint(cap(s))
-	nif := ir.Nod(ir.OIF, nil, nil)
+	nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
 	nuint := conv(nn, types.Types[types.TUINT])
-	scapuint := conv(ir.Nod(ir.OCAP, s, nil), types.Types[types.TUINT])
-	nif.SetLeft(ir.Nod(ir.OGT, nuint, scapuint))
+	scapuint := conv(ir.NewUnaryExpr(base.Pos, ir.OCAP, s), types.Types[types.TUINT])
+	nif.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OGT, nuint, scapuint))
 
 	// instantiate growslice(typ *type, []any, int) []any
 	fn := syslook("growslice")
 	fn = substArgTypes(fn, elemtype, elemtype)
 
 	// s = growslice(T, s, n)
-	nif.PtrBody().Set1(ir.Nod(ir.OAS, s, mkcall1(fn, s.Type(), nif.PtrInit(), typename(elemtype), s, nn)))
+	nif.PtrBody().Set1(ir.NewAssignStmt(base.Pos, s, mkcall1(fn, s.Type(), nif.PtrInit(), typename(elemtype), s, nn)))
 	nodes.Append(nif)
 
 	// s = s[:n]
-	nt := ir.Nod(ir.OSLICE, s, nil)
+	nt := ir.NewSliceExpr(base.Pos, ir.OSLICE, s)
 	nt.SetSliceBounds(nil, nn, nil)
 	nt.SetBounded(true)
-	nodes.Append(ir.Nod(ir.OAS, s, nt))
+	nodes.Append(ir.NewAssignStmt(base.Pos, s, nt))
 
 	var ncopy ir.Node
 	if elemtype.HasPointers() {
 		// copy(s[len(l1):], l2)
-		slice := ir.Nod(ir.OSLICE, s, nil)
+		slice := ir.NewSliceExpr(base.Pos, ir.OSLICE, s)
 		slice.SetType(s.Type())
-		slice.SetSliceBounds(ir.Nod(ir.OLEN, l1, nil), nil, nil)
+		slice.SetSliceBounds(ir.NewUnaryExpr(base.Pos, ir.OLEN, l1), nil, nil)
 
 		Curfn.SetWBPos(n.Pos())
 
@@ -2816,9 +2813,9 @@ func appendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 		// rely on runtime to instrument:
 		//  copy(s[len(l1):], l2)
 		// l2 can be a slice or string.
-		slice := ir.Nod(ir.OSLICE, s, nil)
+		slice := ir.NewSliceExpr(base.Pos, ir.OSLICE, s)
 		slice.SetType(s.Type())
-		slice.SetSliceBounds(ir.Nod(ir.OLEN, l1, nil), nil, nil)
+		slice.SetSliceBounds(ir.NewUnaryExpr(base.Pos, ir.OLEN, l1), nil, nil)
 
 		ptr1, len1 := backingArrayPtrLen(cheapexpr(slice, &nodes))
 		ptr2, len2 := backingArrayPtrLen(l2)
@@ -2828,14 +2825,14 @@ func appendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 		ncopy = mkcall1(fn, types.Types[types.TINT], &nodes, ptr1, len1, ptr2, len2, nodintconst(elemtype.Width))
 	} else {
 		// memmove(&s[len(l1)], &l2[0], len(l2)*sizeof(T))
-		ix := ir.Nod(ir.OINDEX, s, ir.Nod(ir.OLEN, l1, nil))
+		ix := ir.NewIndexExpr(base.Pos, s, ir.NewUnaryExpr(base.Pos, ir.OLEN, l1))
 		ix.SetBounded(true)
 		addr := nodAddr(ix)
 
-		sptr := ir.Nod(ir.OSPTR, l2, nil)
+		sptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, l2)
 
-		nwid := cheapexpr(conv(ir.Nod(ir.OLEN, l2, nil), types.Types[types.TUINTPTR]), &nodes)
-		nwid = ir.Nod(ir.OMUL, nwid, nodintconst(elemtype.Width))
+		nwid := cheapexpr(conv(ir.NewUnaryExpr(base.Pos, ir.OLEN, l2), types.Types[types.TUINTPTR]), &nodes)
+		nwid = ir.NewBinaryExpr(base.Pos, ir.OMUL, nwid, nodintconst(elemtype.Width))
 
 		// instantiate func memmove(to *any, frm *any, length uintptr)
 		fn := syslook("memmove")
@@ -2931,7 +2928,7 @@ func extendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	var nodes []ir.Node
 
 	// if l2 >= 0 (likely happens), do nothing
-	nifneg := ir.Nod(ir.OIF, ir.Nod(ir.OGE, l2, nodintconst(0)), nil)
+	nifneg := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGE, l2, nodintconst(0)), nil, nil)
 	nifneg.SetLikely(true)
 
 	// else panicmakeslicelen()
@@ -2940,50 +2937,50 @@ func extendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 
 	// s := l1
 	s := temp(l1.Type())
-	nodes = append(nodes, ir.Nod(ir.OAS, s, l1))
+	nodes = append(nodes, ir.NewAssignStmt(base.Pos, s, l1))
 
 	elemtype := s.Type().Elem()
 
 	// n := len(s) + l2
 	nn := temp(types.Types[types.TINT])
-	nodes = append(nodes, ir.Nod(ir.OAS, nn, ir.Nod(ir.OADD, ir.Nod(ir.OLEN, s, nil), l2)))
+	nodes = append(nodes, ir.NewAssignStmt(base.Pos, nn, ir.NewBinaryExpr(base.Pos, ir.OADD, ir.NewUnaryExpr(base.Pos, ir.OLEN, s), l2)))
 
 	// if uint(n) > uint(cap(s))
 	nuint := conv(nn, types.Types[types.TUINT])
-	capuint := conv(ir.Nod(ir.OCAP, s, nil), types.Types[types.TUINT])
-	nif := ir.Nod(ir.OIF, ir.Nod(ir.OGT, nuint, capuint), nil)
+	capuint := conv(ir.NewUnaryExpr(base.Pos, ir.OCAP, s), types.Types[types.TUINT])
+	nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGT, nuint, capuint), nil, nil)
 
 	// instantiate growslice(typ *type, old []any, newcap int) []any
 	fn := syslook("growslice")
 	fn = substArgTypes(fn, elemtype, elemtype)
 
 	// s = growslice(T, s, n)
-	nif.PtrBody().Set1(ir.Nod(ir.OAS, s, mkcall1(fn, s.Type(), nif.PtrInit(), typename(elemtype), s, nn)))
+	nif.PtrBody().Set1(ir.NewAssignStmt(base.Pos, s, mkcall1(fn, s.Type(), nif.PtrInit(), typename(elemtype), s, nn)))
 	nodes = append(nodes, nif)
 
 	// s = s[:n]
-	nt := ir.Nod(ir.OSLICE, s, nil)
+	nt := ir.NewSliceExpr(base.Pos, ir.OSLICE, s)
 	nt.SetSliceBounds(nil, nn, nil)
 	nt.SetBounded(true)
-	nodes = append(nodes, ir.Nod(ir.OAS, s, nt))
+	nodes = append(nodes, ir.NewAssignStmt(base.Pos, s, nt))
 
 	// lptr := &l1[0]
 	l1ptr := temp(l1.Type().Elem().PtrTo())
-	tmp := ir.Nod(ir.OSPTR, l1, nil)
-	nodes = append(nodes, ir.Nod(ir.OAS, l1ptr, tmp))
+	tmp := ir.NewUnaryExpr(base.Pos, ir.OSPTR, l1)
+	nodes = append(nodes, ir.NewAssignStmt(base.Pos, l1ptr, tmp))
 
 	// sptr := &s[0]
 	sptr := temp(elemtype.PtrTo())
-	tmp = ir.Nod(ir.OSPTR, s, nil)
-	nodes = append(nodes, ir.Nod(ir.OAS, sptr, tmp))
+	tmp = ir.NewUnaryExpr(base.Pos, ir.OSPTR, s)
+	nodes = append(nodes, ir.NewAssignStmt(base.Pos, sptr, tmp))
 
 	// hp := &s[len(l1)]
-	ix := ir.Nod(ir.OINDEX, s, ir.Nod(ir.OLEN, l1, nil))
+	ix := ir.NewIndexExpr(base.Pos, s, ir.NewUnaryExpr(base.Pos, ir.OLEN, l1))
 	ix.SetBounded(true)
 	hp := convnop(nodAddr(ix), types.Types[types.TUNSAFEPTR])
 
 	// hn := l2 * sizeof(elem(s))
-	hn := conv(ir.Nod(ir.OMUL, l2, nodintconst(elemtype.Width)), types.Types[types.TUINTPTR])
+	hn := conv(ir.NewBinaryExpr(base.Pos, ir.OMUL, l2, nodintconst(elemtype.Width)), types.Types[types.TUINTPTR])
 
 	clrname := "memclrNoHeapPointers"
 	hasPointers := elemtype.HasPointers()
@@ -2998,7 +2995,7 @@ func extendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 
 	if hasPointers {
 		// if l1ptr == sptr
-		nifclr := ir.Nod(ir.OIF, ir.Nod(ir.OEQ, l1ptr, sptr), nil)
+		nifclr := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OEQ, l1ptr, sptr), nil, nil)
 		nifclr.SetBody(clr)
 		nodes = append(nodes, nifclr)
 	} else {
@@ -3071,36 +3068,35 @@ func walkappend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
 	var l []ir.Node
 
 	ns := temp(nsrc.Type())
-	l = append(l, ir.Nod(ir.OAS, ns, nsrc)) // s = src
+	l = append(l, ir.NewAssignStmt(base.Pos, ns, nsrc)) // s = src
 
-	na := nodintconst(int64(argc))  // const argc
-	nif := ir.Nod(ir.OIF, nil, nil) // if cap(s) - len(s) < argc
-	nif.SetLeft(ir.Nod(ir.OLT, ir.Nod(ir.OSUB, ir.Nod(ir.OCAP, ns, nil), ir.Nod(ir.OLEN, ns, nil)), na))
+	na := nodintconst(int64(argc))               // const argc
+	nif := ir.NewIfStmt(base.Pos, nil, nil, nil) // if cap(s) - len(s) < argc
+	nif.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OLT, ir.NewBinaryExpr(base.Pos, ir.OSUB, ir.NewUnaryExpr(base.Pos, ir.OCAP, ns), ir.NewUnaryExpr(base.Pos, ir.OLEN, ns)), na))
 
 	fn := syslook("growslice") //   growslice(<type>, old []T, mincap int) (ret []T)
 	fn = substArgTypes(fn, ns.Type().Elem(), ns.Type().Elem())
 
-	nif.PtrBody().Set1(ir.Nod(ir.OAS, ns,
-		mkcall1(fn, ns.Type(), nif.PtrInit(), typename(ns.Type().Elem()), ns,
-			ir.Nod(ir.OADD, ir.Nod(ir.OLEN, ns, nil), na))))
+	nif.PtrBody().Set1(ir.NewAssignStmt(base.Pos, ns, mkcall1(fn, ns.Type(), nif.PtrInit(), typename(ns.Type().Elem()), ns,
+		ir.NewBinaryExpr(base.Pos, ir.OADD, ir.NewUnaryExpr(base.Pos, ir.OLEN, ns), na))))
 
 	l = append(l, nif)
 
 	nn := temp(types.Types[types.TINT])
-	l = append(l, ir.Nod(ir.OAS, nn, ir.Nod(ir.OLEN, ns, nil))) // n = len(s)
+	l = append(l, ir.NewAssignStmt(base.Pos, nn, ir.NewUnaryExpr(base.Pos, ir.OLEN, ns))) // n = len(s)
 
-	slice := ir.Nod(ir.OSLICE, ns, nil) // ...s[:n+argc]
-	slice.SetSliceBounds(nil, ir.Nod(ir.OADD, nn, na), nil)
+	slice := ir.NewSliceExpr(base.Pos, ir.OSLICE, ns) // ...s[:n+argc]
+	slice.SetSliceBounds(nil, ir.NewBinaryExpr(base.Pos, ir.OADD, nn, na), nil)
 	slice.SetBounded(true)
-	l = append(l, ir.Nod(ir.OAS, ns, slice)) // s = s[:n+argc]
+	l = append(l, ir.NewAssignStmt(base.Pos, ns, slice)) // s = s[:n+argc]
 
 	ls = n.List().Slice()[1:]
 	for i, n := range ls {
-		ix := ir.Nod(ir.OINDEX, ns, nn) // s[n] ...
+		ix := ir.NewIndexExpr(base.Pos, ns, nn) // s[n] ...
 		ix.SetBounded(true)
-		l = append(l, ir.Nod(ir.OAS, ix, n)) // s[n] = arg
+		l = append(l, ir.NewAssignStmt(base.Pos, ix, n)) // s[n] = arg
 		if i+1 < len(ls) {
-			l = append(l, ir.Nod(ir.OAS, nn, ir.Nod(ir.OADD, nn, nodintconst(1)))) // n = n + 1
+			l = append(l, ir.NewAssignStmt(base.Pos, nn, ir.NewBinaryExpr(base.Pos, ir.OADD, nn, nodintconst(1)))) // n = n + 1
 		}
 	}
 
@@ -3153,35 +3149,35 @@ func copyany(n *ir.BinaryExpr, init *ir.Nodes, runtimecall bool) ir.Node {
 	nl := temp(n.Left().Type())
 	nr := temp(n.Right().Type())
 	var l []ir.Node
-	l = append(l, ir.Nod(ir.OAS, nl, n.Left()))
-	l = append(l, ir.Nod(ir.OAS, nr, n.Right()))
+	l = append(l, ir.NewAssignStmt(base.Pos, nl, n.Left()))
+	l = append(l, ir.NewAssignStmt(base.Pos, nr, n.Right()))
 
-	nfrm := ir.Nod(ir.OSPTR, nr, nil)
-	nto := ir.Nod(ir.OSPTR, nl, nil)
+	nfrm := ir.NewUnaryExpr(base.Pos, ir.OSPTR, nr)
+	nto := ir.NewUnaryExpr(base.Pos, ir.OSPTR, nl)
 
 	nlen := temp(types.Types[types.TINT])
 
 	// n = len(to)
-	l = append(l, ir.Nod(ir.OAS, nlen, ir.Nod(ir.OLEN, nl, nil)))
+	l = append(l, ir.NewAssignStmt(base.Pos, nlen, ir.NewUnaryExpr(base.Pos, ir.OLEN, nl)))
 
 	// if n > len(frm) { n = len(frm) }
-	nif := ir.Nod(ir.OIF, nil, nil)
+	nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
 
-	nif.SetLeft(ir.Nod(ir.OGT, nlen, ir.Nod(ir.OLEN, nr, nil)))
-	nif.PtrBody().Append(ir.Nod(ir.OAS, nlen, ir.Nod(ir.OLEN, nr, nil)))
+	nif.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OGT, nlen, ir.NewUnaryExpr(base.Pos, ir.OLEN, nr)))
+	nif.PtrBody().Append(ir.NewAssignStmt(base.Pos, nlen, ir.NewUnaryExpr(base.Pos, ir.OLEN, nr)))
 	l = append(l, nif)
 
 	// if to.ptr != frm.ptr { memmove( ... ) }
-	ne := ir.Nod(ir.OIF, ir.Nod(ir.ONE, nto, nfrm), nil)
+	ne := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.ONE, nto, nfrm), nil, nil)
 	ne.SetLikely(true)
 	l = append(l, ne)
 
 	fn := syslook("memmove")
 	fn = substArgTypes(fn, nl.Type().Elem(), nl.Type().Elem())
 	nwid := ir.Node(temp(types.Types[types.TUINTPTR]))
-	setwid := ir.Nod(ir.OAS, nwid, conv(nlen, types.Types[types.TUINTPTR]))
+	setwid := ir.NewAssignStmt(base.Pos, nwid, conv(nlen, types.Types[types.TUINTPTR]))
 	ne.PtrBody().Append(setwid)
-	nwid = ir.Nod(ir.OMUL, nwid, nodintconst(nl.Type().Elem().Width))
+	nwid = ir.NewBinaryExpr(base.Pos, ir.OMUL, nwid, nodintconst(nl.Type().Elem().Width))
 	call := mkcall1(fn, nil, init, nto, nfrm, nwid)
 	ne.PtrBody().Append(call)
 
@@ -3255,7 +3251,7 @@ func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 		// For non-empty interface, this is:
 		//   l.tab != nil && l.tab._type == type(r)
 		var eqtype ir.Node
-		tab := ir.Nod(ir.OITAB, l, nil)
+		tab := ir.NewUnaryExpr(base.Pos, ir.OITAB, l)
 		rtyp := typename(r.Type())
 		if l.Type().IsEmptyInterface() {
 			tab.SetType(types.NewPtr(types.Types[types.TUINT8]))
@@ -3360,7 +3356,7 @@ func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 		}
 
 		fn, needsize := eqfor(t)
-		call := ir.Nod(ir.OCALL, fn, nil)
+		call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
 		call.PtrList().Append(nodAddr(cmpl))
 		call.PtrList().Append(nodAddr(cmpr))
 		if needsize {
@@ -3368,7 +3364,7 @@ func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 		}
 		res := ir.Node(call)
 		if n.Op() != ir.OEQ {
-			res = ir.Nod(ir.ONOT, res, nil)
+			res = ir.NewUnaryExpr(base.Pos, ir.ONOT, res)
 		}
 		return finishcompare(n, res, init)
 	}
@@ -3396,8 +3392,8 @@ func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 				continue
 			}
 			compare(
-				nodSym(ir.OXDOT, cmpl, sym),
-				nodSym(ir.OXDOT, cmpr, sym),
+				ir.NewSelectorExpr(base.Pos, ir.OXDOT, cmpl, sym),
+				ir.NewSelectorExpr(base.Pos, ir.OXDOT, cmpr, sym),
 			)
 		}
 	} else {
@@ -3423,32 +3419,32 @@ func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 			}
 			if step == 1 {
 				compare(
-					ir.Nod(ir.OINDEX, cmpl, nodintconst(i)),
-					ir.Nod(ir.OINDEX, cmpr, nodintconst(i)),
+					ir.NewIndexExpr(base.Pos, cmpl, nodintconst(i)),
+					ir.NewIndexExpr(base.Pos, cmpr, nodintconst(i)),
 				)
 				i++
 				remains -= t.Elem().Width
 			} else {
 				elemType := t.Elem().ToUnsigned()
-				cmplw := ir.Node(ir.Nod(ir.OINDEX, cmpl, nodintconst(i)))
+				cmplw := ir.Node(ir.NewIndexExpr(base.Pos, cmpl, nodintconst(i)))
 				cmplw = conv(cmplw, elemType) // convert to unsigned
 				cmplw = conv(cmplw, convType) // widen
-				cmprw := ir.Node(ir.Nod(ir.OINDEX, cmpr, nodintconst(i)))
+				cmprw := ir.Node(ir.NewIndexExpr(base.Pos, cmpr, nodintconst(i)))
 				cmprw = conv(cmprw, elemType)
 				cmprw = conv(cmprw, convType)
 				// For code like this:  uint32(s[0]) | uint32(s[1])<<8 | uint32(s[2])<<16 ...
 				// ssa will generate a single large load.
 				for offset := int64(1); offset < step; offset++ {
-					lb := ir.Node(ir.Nod(ir.OINDEX, cmpl, nodintconst(i+offset)))
+					lb := ir.Node(ir.NewIndexExpr(base.Pos, cmpl, nodintconst(i+offset)))
 					lb = conv(lb, elemType)
 					lb = conv(lb, convType)
-					lb = ir.Nod(ir.OLSH, lb, nodintconst(8*t.Elem().Width*offset))
-					cmplw = ir.Nod(ir.OOR, cmplw, lb)
-					rb := ir.Node(ir.Nod(ir.OINDEX, cmpr, nodintconst(i+offset)))
+					lb = ir.NewBinaryExpr(base.Pos, ir.OLSH, lb, nodintconst(8*t.Elem().Width*offset))
+					cmplw = ir.NewBinaryExpr(base.Pos, ir.OOR, cmplw, lb)
+					rb := ir.Node(ir.NewIndexExpr(base.Pos, cmpr, nodintconst(i+offset)))
 					rb = conv(rb, elemType)
 					rb = conv(rb, convType)
-					rb = ir.Nod(ir.OLSH, rb, nodintconst(8*t.Elem().Width*offset))
-					cmprw = ir.Nod(ir.OOR, cmprw, rb)
+					rb = ir.NewBinaryExpr(base.Pos, ir.OLSH, rb, nodintconst(8*t.Elem().Width*offset))
+					cmprw = ir.NewBinaryExpr(base.Pos, ir.OOR, cmprw, rb)
 				}
 				compare(cmplw, cmprw)
 				i += step
@@ -3461,8 +3457,8 @@ func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 		// We still need to use cmpl and cmpr, in case they contain
 		// an expression which might panic. See issue 23837.
 		t := temp(cmpl.Type())
-		a1 := typecheck(ir.Nod(ir.OAS, t, cmpl), ctxStmt)
-		a2 := typecheck(ir.Nod(ir.OAS, t, cmpr), ctxStmt)
+		a1 := typecheck(ir.NewAssignStmt(base.Pos, t, cmpl), ctxStmt)
+		a2 := typecheck(ir.NewAssignStmt(base.Pos, t, cmpr), ctxStmt)
 		init.Append(a1, a2)
 	}
 	return finishcompare(n, expr, init)
@@ -3483,10 +3479,10 @@ func walkcompareInterface(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 	eqtab, eqdata := eqinterface(n.Left(), n.Right())
 	var cmp ir.Node
 	if n.Op() == ir.OEQ {
-		cmp = ir.Nod(ir.OANDAND, eqtab, eqdata)
+		cmp = ir.NewLogicalExpr(base.Pos, ir.OANDAND, eqtab, eqdata)
 	} else {
 		eqtab.SetOp(ir.ONE)
-		cmp = ir.Nod(ir.OOROR, eqtab, ir.Nod(ir.ONOT, eqdata, nil))
+		cmp = ir.NewLogicalExpr(base.Pos, ir.OOROR, eqtab, ir.NewUnaryExpr(base.Pos, ir.ONOT, eqdata))
 	}
 	return finishcompare(n, cmp, init)
 }
@@ -3544,12 +3540,12 @@ func walkcompareString(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 			if len(s) > 0 {
 				ncs = safeexpr(ncs, init)
 			}
-			r := ir.Node(ir.NewBinaryExpr(base.Pos, cmp, ir.Nod(ir.OLEN, ncs, nil), nodintconst(int64(len(s)))))
+			r := ir.Node(ir.NewBinaryExpr(base.Pos, cmp, ir.NewUnaryExpr(base.Pos, ir.OLEN, ncs), nodintconst(int64(len(s)))))
 			remains := len(s)
 			for i := 0; remains > 0; {
 				if remains == 1 || !canCombineLoads {
 					cb := nodintconst(int64(s[i]))
-					ncb := ir.Nod(ir.OINDEX, ncs, nodintconst(int64(i)))
+					ncb := ir.NewIndexExpr(base.Pos, ncs, nodintconst(int64(i)))
 					r = ir.NewLogicalExpr(base.Pos, and, r, ir.NewBinaryExpr(base.Pos, cmp, ncb, cb))
 					remains--
 					i++
@@ -3568,15 +3564,15 @@ func walkcompareString(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 					convType = types.Types[types.TUINT16]
 					step = 2
 				}
-				ncsubstr := conv(ir.Nod(ir.OINDEX, ncs, nodintconst(int64(i))), convType)
+				ncsubstr := conv(ir.NewIndexExpr(base.Pos, ncs, nodintconst(int64(i))), convType)
 				csubstr := int64(s[i])
 				// Calculate large constant from bytes as sequence of shifts and ors.
 				// Like this:  uint32(s[0]) | uint32(s[1])<<8 | uint32(s[2])<<16 ...
 				// ssa will combine this into a single large load.
 				for offset := 1; offset < step; offset++ {
-					b := conv(ir.Nod(ir.OINDEX, ncs, nodintconst(int64(i+offset))), convType)
-					b = ir.Nod(ir.OLSH, b, nodintconst(int64(8*offset)))
-					ncsubstr = ir.Nod(ir.OOR, ncsubstr, b)
+					b := conv(ir.NewIndexExpr(base.Pos, ncs, nodintconst(int64(i+offset))), convType)
+					b = ir.NewBinaryExpr(base.Pos, ir.OLSH, b, nodintconst(int64(8*offset)))
+					ncsubstr = ir.NewBinaryExpr(base.Pos, ir.OOR, ncsubstr, b)
 					csubstr |= int64(s[i+offset]) << uint8(8*offset)
 				}
 				csubstrPart := nodintconst(csubstr)
@@ -3599,11 +3595,11 @@ func walkcompareString(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 		// memequal then tests equality up to length len.
 		if n.Op() == ir.OEQ {
 			// len(left) == len(right) && memequal(left, right, len)
-			r = ir.Nod(ir.OANDAND, eqlen, eqmem)
+			r = ir.NewLogicalExpr(base.Pos, ir.OANDAND, eqlen, eqmem)
 		} else {
 			// len(left) != len(right) || !memequal(left, right, len)
 			eqlen.SetOp(ir.ONE)
-			r = ir.Nod(ir.OOROR, eqlen, ir.Nod(ir.ONOT, eqmem, nil))
+			r = ir.NewLogicalExpr(base.Pos, ir.OOROR, eqlen, ir.NewUnaryExpr(base.Pos, ir.ONOT, eqmem))
 		}
 	} else {
 		// sys_cmpstring(s1, s2) :: 0
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index ca894cd5f1..1679313c86 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -640,123 +640,3 @@ func IsBlank(n Node) bool {
 func IsMethod(n Node) bool {
 	return n.Type().Recv() != nil
 }
-
-func Nod(op Op, nleft, nright Node) Node {
-	return NodAt(base.Pos, op, nleft, nright)
-}
-
-func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
-	switch op {
-	default:
-		panic("NodAt " + op.String())
-	case OADD, OAND, OANDNOT, ODIV, OEQ, OGE, OGT, OLE,
-		OLSH, OLT, OMOD, OMUL, ONE, OOR, ORSH, OSUB, OXOR,
-		OCOPY, OCOMPLEX,
-		OEFACE:
-		return NewBinaryExpr(pos, op, nleft, nright)
-	case OADDR:
-		return NewAddrExpr(pos, nleft)
-	case OADDSTR:
-		return NewAddStringExpr(pos, nil)
-	case OANDAND, OOROR:
-		return NewLogicalExpr(pos, op, nleft, nright)
-	case OARRAYLIT, OCOMPLIT, OMAPLIT, OSTRUCTLIT, OSLICELIT:
-		var typ Ntype
-		if nright != nil {
-			typ = nright.(Ntype)
-		}
-		return NewCompLitExpr(pos, op, typ, nil)
-	case OAS:
-		return NewAssignStmt(pos, nleft, nright)
-	case OAS2, OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV, OSELRECV2:
-		n := NewAssignListStmt(pos, op, nil, nil)
-		return n
-	case OASOP:
-		return NewAssignOpStmt(pos, OXXX, nleft, nright)
-	case OBITNOT, ONEG, ONOT, OPLUS, ORECV,
-		OALIGNOF, OCAP, OCLOSE, OIMAG, OLEN, ONEW, ONEWOBJ,
-		OOFFSETOF, OPANIC, OREAL, OSIZEOF,
-		OCHECKNIL, OCFUNC, OIDATA, OITAB, OSPTR, OVARDEF, OVARKILL, OVARLIVE:
-		if nright != nil {
-			panic("unary nright")
-		}
-		return NewUnaryExpr(pos, op, nleft)
-	case OBLOCK:
-		return NewBlockStmt(pos, nil)
-	case OBREAK, OCONTINUE, OFALL, OGOTO, ORETJMP:
-		return NewBranchStmt(pos, op, nil)
-	case OCALL, OCALLFUNC, OCALLINTER, OCALLMETH,
-		OAPPEND, ODELETE, OGETG, OMAKE, OPRINT, OPRINTN, ORECOVER:
-		return NewCallExpr(pos, op, nleft, nil)
-	case OCASE:
-		return NewCaseStmt(pos, nil, nil)
-	case OCONV, OCONVIFACE, OCONVNOP, ORUNESTR:
-		return NewConvExpr(pos, op, nil, nleft)
-	case ODCL, ODCLCONST, ODCLTYPE:
-		return NewDecl(pos, op, nleft)
-	case ODCLFUNC:
-		return NewFunc(pos)
-	case ODEFER, OGO:
-		return NewGoDeferStmt(pos, op, nleft)
-	case ODEREF:
-		return NewStarExpr(pos, nleft)
-	case ODOT, ODOTPTR, ODOTMETH, ODOTINTER, OXDOT:
-		return NewSelectorExpr(pos, op, nleft, nil)
-	case ODOTTYPE, ODOTTYPE2:
-		var typ Ntype
-		if nright != nil {
-			typ = nright.(Ntype)
-		}
-		n := NewTypeAssertExpr(pos, nleft, typ)
-		if op != ODOTTYPE {
-			n.SetOp(op)
-		}
-		return n
-	case OFOR:
-		return NewForStmt(pos, nil, nleft, nright, nil)
-	case OIF:
-		return NewIfStmt(pos, nleft, nil, nil)
-	case OINDEX, OINDEXMAP:
-		n := NewIndexExpr(pos, nleft, nright)
-		if op != OINDEX {
-			n.SetOp(op)
-		}
-		return n
-	case OINLMARK:
-		return NewInlineMarkStmt(pos, types.BADWIDTH)
-	case OKEY:
-		return NewKeyExpr(pos, nleft, nright)
-	case OSTRUCTKEY:
-		return NewStructKeyExpr(pos, nil, nleft)
-	case OLABEL:
-		return NewLabelStmt(pos, nil)
-	case OLITERAL, OTYPE, OIOTA:
-		return newNameAt(pos, op, nil)
-	case OMAKECHAN, OMAKEMAP, OMAKESLICE, OMAKESLICECOPY:
-		return NewMakeExpr(pos, op, nleft, nright)
-	case ONIL:
-		return NewNilExpr(pos)
-	case OPACK:
-		return NewPkgName(pos, nil, nil)
-	case OPAREN:
-		return NewParenExpr(pos, nleft)
-	case ORANGE:
-		return NewRangeStmt(pos, nil, nright, nil)
-	case ORESULT:
-		return NewResultExpr(pos, nil, types.BADWIDTH)
-	case ORETURN:
-		return NewReturnStmt(pos, nil)
-	case OSELECT:
-		return NewSelectStmt(pos, nil)
-	case OSEND:
-		return NewSendStmt(pos, nleft, nright)
-	case OSLICE, OSLICEARR, OSLICESTR, OSLICE3, OSLICE3ARR:
-		return NewSliceExpr(pos, op, nleft)
-	case OSLICEHEADER:
-		return NewSliceHeaderExpr(pos, nil, nleft, nil, nil)
-	case OSWITCH:
-		return NewSwitchStmt(pos, nleft, nil)
-	case OINLCALL:
-		return NewInlinedCallExpr(pos, nil, nil)
-	}
-}
-- 
GitLab


From 14d667341f9c8c58a9fb38d4954766a230eacf3b Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 22 Dec 2020 23:56:32 -0500
Subject: [PATCH 0297/2400] [dev.regabi] cmd/compile: remove Node.Left etc
 [generated]

This automated CL adds type assertions on the true branches of
n.Op() equality tests, to redeclare n with a more specific type, when
it is safe to do so. (That is, when n is not reassigned with a more
general type, when n is not reassigned and then used outside the
scope, and so on.) All the "unsafe" times that the automated tool
would avoid have been removed or rewritten in earlier CLs, so that
after this CL and the next one, which removes the use of ir.Nod,
every use of the Left, Right, and so on methods is done using concrete
types, never the Node interface.

Having done that, the CL locks in the progress by deleting many of
the access methods, including Left, SetLeft and so on, from the
Node interface.

There are still uses of Name, Func, Sym, some of the tracking
bits, and a few other miscellaneous fields, but all the main access
methods are gone from the Node interface. The others will be cleaned
up in smaller CLs.

Passes buildall w/ toolstash -cmp.

[git-generate]
cd src/cmd/compile/internal/gc
rf 'typeassert {
        import "cmd/compile/internal/ir"
        var n ir.Node

        n.Op() == ir.OADD -> n.(*ir.BinaryExpr)
        n.Op() == ir.OADDR -> n.(*ir.AddrExpr)
        n.Op() == ir.OADDSTR -> n.(*ir.AddStringExpr)
        n.Op() == ir.OALIGNOF -> n.(*ir.UnaryExpr)
        n.Op() == ir.OAND -> n.(*ir.BinaryExpr)
        n.Op() == ir.OANDAND -> n.(*ir.LogicalExpr)
        n.Op() == ir.OANDNOT -> n.(*ir.BinaryExpr)
        n.Op() == ir.OAPPEND -> n.(*ir.CallExpr)
        n.Op() == ir.OARRAYLIT -> n.(*ir.CompLitExpr)
        n.Op() == ir.OAS -> n.(*ir.AssignStmt)
        n.Op() == ir.OAS2 -> n.(*ir.AssignListStmt)
        n.Op() == ir.OAS2DOTTYPE -> n.(*ir.AssignListStmt)
        n.Op() == ir.OAS2FUNC -> n.(*ir.AssignListStmt)
        n.Op() == ir.OAS2MAPR -> n.(*ir.AssignListStmt)
        n.Op() == ir.OAS2RECV -> n.(*ir.AssignListStmt)
        n.Op() == ir.OASOP -> n.(*ir.AssignOpStmt)
        n.Op() == ir.OBITNOT -> n.(*ir.UnaryExpr)
        n.Op() == ir.OBLOCK -> n.(*ir.BlockStmt)
        n.Op() == ir.OBREAK -> n.(*ir.BranchStmt)
        n.Op() == ir.OBYTES2STR -> n.(*ir.ConvExpr)
        n.Op() == ir.OBYTES2STRTMP -> n.(*ir.ConvExpr)
        n.Op() == ir.OCALL -> n.(*ir.CallExpr)
        n.Op() == ir.OCALLFUNC -> n.(*ir.CallExpr)
        n.Op() == ir.OCALLINTER -> n.(*ir.CallExpr)
        n.Op() == ir.OCALLMETH -> n.(*ir.CallExpr)
        n.Op() == ir.OCALLPART -> n.(*ir.CallPartExpr)
        n.Op() == ir.OCAP -> n.(*ir.UnaryExpr)
        n.Op() == ir.OCASE -> n.(*ir.CaseStmt)
        n.Op() == ir.OCFUNC -> n.(*ir.UnaryExpr)
        n.Op() == ir.OCHECKNIL -> n.(*ir.UnaryExpr)
        n.Op() == ir.OCLOSE -> n.(*ir.UnaryExpr)
        n.Op() == ir.OCOMPLEX -> n.(*ir.BinaryExpr)
        n.Op() == ir.OCOMPLIT -> n.(*ir.CompLitExpr)
        n.Op() == ir.OCONTINUE -> n.(*ir.BranchStmt)
        n.Op() == ir.OCONV -> n.(*ir.ConvExpr)
        n.Op() == ir.OCONVIFACE -> n.(*ir.ConvExpr)
        n.Op() == ir.OCONVNOP -> n.(*ir.ConvExpr)
        n.Op() == ir.OCOPY -> n.(*ir.BinaryExpr)
        n.Op() == ir.ODCL -> n.(*ir.Decl)
        n.Op() == ir.ODCLCONST -> n.(*ir.Decl)
        n.Op() == ir.ODCLFUNC -> n.(*ir.Func)
        n.Op() == ir.ODCLTYPE -> n.(*ir.Decl)
        n.Op() == ir.ODEFER -> n.(*ir.GoDeferStmt)
        n.Op() == ir.ODELETE -> n.(*ir.CallExpr)
        n.Op() == ir.ODEREF -> n.(*ir.StarExpr)
        n.Op() == ir.ODIV -> n.(*ir.BinaryExpr)
        n.Op() == ir.ODOT -> n.(*ir.SelectorExpr)
        n.Op() == ir.ODOTINTER -> n.(*ir.SelectorExpr)
        n.Op() == ir.ODOTMETH -> n.(*ir.SelectorExpr)
        n.Op() == ir.ODOTPTR -> n.(*ir.SelectorExpr)
        n.Op() == ir.ODOTTYPE -> n.(*ir.TypeAssertExpr)
        n.Op() == ir.ODOTTYPE2 -> n.(*ir.TypeAssertExpr)
        n.Op() == ir.OEFACE -> n.(*ir.BinaryExpr)
        n.Op() == ir.OEQ -> n.(*ir.BinaryExpr)
        n.Op() == ir.OFALL -> n.(*ir.BranchStmt)
        n.Op() == ir.OFOR -> n.(*ir.ForStmt)
        n.Op() == ir.OFORUNTIL -> n.(*ir.ForStmt)
        n.Op() == ir.OGE -> n.(*ir.BinaryExpr)
        n.Op() == ir.OGETG -> n.(*ir.CallExpr)
        n.Op() == ir.OGO -> n.(*ir.GoDeferStmt)
        n.Op() == ir.OGOTO -> n.(*ir.BranchStmt)
        n.Op() == ir.OGT -> n.(*ir.BinaryExpr)
        n.Op() == ir.OIDATA -> n.(*ir.UnaryExpr)
        n.Op() == ir.OIF -> n.(*ir.IfStmt)
        n.Op() == ir.OIMAG -> n.(*ir.UnaryExpr)
        n.Op() == ir.OINDEX -> n.(*ir.IndexExpr)
        n.Op() == ir.OINDEXMAP -> n.(*ir.IndexExpr)
        n.Op() == ir.OINLCALL -> n.(*ir.InlinedCallExpr)
        n.Op() == ir.OINLMARK -> n.(*ir.InlineMarkStmt)
        n.Op() == ir.OITAB -> n.(*ir.UnaryExpr)
        n.Op() == ir.OKEY -> n.(*ir.KeyExpr)
        n.Op() == ir.OLABEL -> n.(*ir.LabelStmt)
        n.Op() == ir.OLE -> n.(*ir.BinaryExpr)
        n.Op() == ir.OLEN -> n.(*ir.UnaryExpr)
        n.Op() == ir.OLSH -> n.(*ir.BinaryExpr)
        n.Op() == ir.OLT -> n.(*ir.BinaryExpr)
        n.Op() == ir.OMAKE -> n.(*ir.CallExpr)
        n.Op() == ir.OMAKECHAN -> n.(*ir.MakeExpr)
        n.Op() == ir.OMAKEMAP -> n.(*ir.MakeExpr)
        n.Op() == ir.OMAKESLICE -> n.(*ir.MakeExpr)
        n.Op() == ir.OMAKESLICECOPY -> n.(*ir.MakeExpr)
        n.Op() == ir.OMAPLIT -> n.(*ir.CompLitExpr)
        n.Op() == ir.OMETHEXPR -> n.(*ir.MethodExpr)
        n.Op() == ir.OMOD -> n.(*ir.BinaryExpr)
        n.Op() == ir.OMUL -> n.(*ir.BinaryExpr)
        n.Op() == ir.ONAME -> n.(*ir.Name)
        n.Op() == ir.ONE -> n.(*ir.BinaryExpr)
        n.Op() == ir.ONEG -> n.(*ir.UnaryExpr)
        n.Op() == ir.ONEW -> n.(*ir.UnaryExpr)
        n.Op() == ir.ONEWOBJ -> n.(*ir.UnaryExpr)
        n.Op() == ir.ONIL -> n.(*ir.NilExpr)
        n.Op() == ir.ONOT -> n.(*ir.UnaryExpr)
        n.Op() == ir.OOFFSETOF -> n.(*ir.UnaryExpr)
        n.Op() == ir.OOR -> n.(*ir.BinaryExpr)
        n.Op() == ir.OOROR -> n.(*ir.LogicalExpr)
        n.Op() == ir.OPACK -> n.(*ir.PkgName)
        n.Op() == ir.OPANIC -> n.(*ir.UnaryExpr)
        n.Op() == ir.OPAREN -> n.(*ir.ParenExpr)
        n.Op() == ir.OPLUS -> n.(*ir.UnaryExpr)
        n.Op() == ir.OPRINT -> n.(*ir.CallExpr)
        n.Op() == ir.OPRINTN -> n.(*ir.CallExpr)
        n.Op() == ir.OPTRLIT -> n.(*ir.AddrExpr)
        n.Op() == ir.ORANGE -> n.(*ir.RangeStmt)
        n.Op() == ir.OREAL -> n.(*ir.UnaryExpr)
        n.Op() == ir.ORECOVER -> n.(*ir.CallExpr)
        n.Op() == ir.ORECV -> n.(*ir.UnaryExpr)
        n.Op() == ir.ORESULT -> n.(*ir.ResultExpr)
        n.Op() == ir.ORETJMP -> n.(*ir.BranchStmt)
        n.Op() == ir.ORETURN -> n.(*ir.ReturnStmt)
        n.Op() == ir.ORSH -> n.(*ir.BinaryExpr)
        n.Op() == ir.ORUNES2STR -> n.(*ir.ConvExpr)
        n.Op() == ir.ORUNESTR -> n.(*ir.ConvExpr)
        n.Op() == ir.OSELECT -> n.(*ir.SelectStmt)
        n.Op() == ir.OSELRECV2 -> n.(*ir.AssignListStmt)
        n.Op() == ir.OSEND -> n.(*ir.SendStmt)
        n.Op() == ir.OSIZEOF -> n.(*ir.UnaryExpr)
        n.Op() == ir.OSLICE -> n.(*ir.SliceExpr)
        n.Op() == ir.OSLICE3 -> n.(*ir.SliceExpr)
        n.Op() == ir.OSLICE3ARR -> n.(*ir.SliceExpr)
        n.Op() == ir.OSLICEARR -> n.(*ir.SliceExpr)
        n.Op() == ir.OSLICEHEADER -> n.(*ir.SliceHeaderExpr)
        n.Op() == ir.OSLICELIT -> n.(*ir.CompLitExpr)
        n.Op() == ir.OSLICESTR -> n.(*ir.SliceExpr)
        n.Op() == ir.OSPTR -> n.(*ir.UnaryExpr)
        n.Op() == ir.OSTR2BYTES -> n.(*ir.ConvExpr)
        n.Op() == ir.OSTR2BYTESTMP -> n.(*ir.ConvExpr)
        n.Op() == ir.OSTR2RUNES -> n.(*ir.ConvExpr)
        n.Op() == ir.OSTRUCTLIT -> n.(*ir.CompLitExpr)
        n.Op() == ir.OSUB -> n.(*ir.BinaryExpr)
        n.Op() == ir.OSWITCH -> n.(*ir.SwitchStmt)
        n.Op() == ir.OTYPESW -> n.(*ir.TypeSwitchGuard)
        n.Op() == ir.OVARDEF -> n.(*ir.UnaryExpr)
        n.Op() == ir.OVARKILL -> n.(*ir.UnaryExpr)
        n.Op() == ir.OVARLIVE -> n.(*ir.UnaryExpr)
        n.Op() == ir.OXDOT -> n.(*ir.SelectorExpr)
        n.Op() == ir.OXOR -> n.(*ir.BinaryExpr)
}
'

cd ../ir
rf '
        rm \
                Node.SetOp \
                miniNode.SetOp \
                Node.Func \
                miniNode.Func \
                Node.Left Node.SetLeft \
                miniNode.Left miniNode.SetLeft \
                Node.Right Node.SetRight \
                miniNode.Right miniNode.SetRight \
                Node.List Node.PtrList Node.SetList \
                miniNode.List miniNode.PtrList miniNode.SetList \
                Node.Rlist Node.PtrRlist Node.SetRlist \
                miniNode.Rlist miniNode.PtrRlist miniNode.SetRlist \
                Node.Body Node.PtrBody Node.SetBody \
                miniNode.Body miniNode.PtrBody miniNode.SetBody \
                Node.SubOp Node.SetSubOp \
                miniNode.SubOp miniNode.SetSubOp \
                Node.SetSym \
                miniNode.SetSym \
                Node.Offset Node.SetOffset \
                miniNode.Offset miniNode.SetOffset \
                Node.Class Node.SetClass \
                miniNode.Class miniNode.SetClass \
                Node.Iota Node.SetIota \
                miniNode.Iota miniNode.SetIota \
                Node.Colas Node.SetColas \
                miniNode.Colas miniNode.SetColas \
                Node.Transient Node.SetTransient \
                miniNode.Transient miniNode.SetTransient \
                Node.Implicit Node.SetImplicit \
                miniNode.Implicit miniNode.SetImplicit \
                Node.IsDDD Node.SetIsDDD \
                miniNode.IsDDD miniNode.SetIsDDD \
                Node.MarkReadonly \
                miniNode.MarkReadonly \
                Node.Likely Node.SetLikely \
                miniNode.Likely miniNode.SetLikely \
                Node.SliceBounds Node.SetSliceBounds \
                miniNode.SliceBounds miniNode.SetSliceBounds \
                Node.NoInline Node.SetNoInline \
                miniNode.NoInline miniNode.SetNoInline \
                Node.IndexMapLValue Node.SetIndexMapLValue \
                miniNode.IndexMapLValue miniNode.SetIndexMapLValue \
                Node.ResetAux \
                miniNode.ResetAux \
                Node.HasBreak Node.SetHasBreak \
                miniNode.HasBreak miniNode.SetHasBreak \
                Node.Bounded Node.SetBounded \
                miniNode.Bounded miniNode.SetBounded \
                miniNode.Embedded miniNode.SetEmbedded \
                miniNode.Int64Val miniNode.Uint64Val miniNode.CanInt64 \
                miniNode.BoolVal miniNode.StringVal \
                miniNode.TChanDir miniNode.SetTChanDir \
                miniNode.Format \
                miniNode.copy miniNode.doChildren miniNode.editChildren \

'

Change-Id: I2a05b535963b43f83b1849fcf653f82b99af6035
Reviewed-on: https://go-review.googlesource.com/c/go/+/277934
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/const.go     |  16 ++++
 src/cmd/compile/internal/gc/dcl.go       |   2 +
 src/cmd/compile/internal/gc/iexport.go   |  41 +++++++++
 src/cmd/compile/internal/gc/iimport.go   |   2 +
 src/cmd/compile/internal/gc/initorder.go |   6 ++
 src/cmd/compile/internal/gc/inl.go       |  21 +++++
 src/cmd/compile/internal/gc/noder.go     |   6 ++
 src/cmd/compile/internal/gc/order.go     |  47 ++++++++++
 src/cmd/compile/internal/gc/scc.go       |   4 +
 src/cmd/compile/internal/gc/select.go    |  11 +++
 src/cmd/compile/internal/gc/sinit.go     |  20 ++++
 src/cmd/compile/internal/gc/ssa.go       |  72 +++++++++++++++
 src/cmd/compile/internal/gc/subr.go      |  19 ++++
 src/cmd/compile/internal/gc/swt.go       |   1 +
 src/cmd/compile/internal/gc/typecheck.go |  75 +++++++++++++++
 src/cmd/compile/internal/gc/unsafe.go    |   4 +
 src/cmd/compile/internal/gc/walk.go      |  74 +++++++++++++++
 src/cmd/compile/internal/ir/mini.go      | 112 +++--------------------
 src/cmd/compile/internal/ir/node.go      |  46 ----------
 19 files changed, 435 insertions(+), 144 deletions(-)

diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index f8e60ea0a3..e54cd0a102 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -204,6 +204,7 @@ func convlit1(n ir.Node, t *types.Type, explicit bool, context func() string) ir
 		return n
 
 	case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
+		n := n.(*ir.BinaryExpr)
 		if !t.IsBoolean() {
 			break
 		}
@@ -211,6 +212,7 @@ func convlit1(n ir.Node, t *types.Type, explicit bool, context func() string) ir
 		return n
 
 	case ir.OLSH, ir.ORSH:
+		n := n.(*ir.BinaryExpr)
 		n.SetLeft(convlit1(n.Left(), t, explicit, nil))
 		n.SetType(n.Left().Type())
 		if n.Type() != nil && !n.Type().IsInteger() {
@@ -449,6 +451,7 @@ func evalConst(n ir.Node) ir.Node {
 	// Pick off just the opcodes that can be constant evaluated.
 	switch n.Op() {
 	case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT:
+		n := n.(*ir.UnaryExpr)
 		nl := n.Left()
 		if nl.Op() == ir.OLITERAL {
 			var prec uint
@@ -459,6 +462,7 @@ func evalConst(n ir.Node) ir.Node {
 		}
 
 	case ir.OADD, ir.OSUB, ir.OMUL, ir.ODIV, ir.OMOD, ir.OOR, ir.OXOR, ir.OAND, ir.OANDNOT:
+		n := n.(*ir.BinaryExpr)
 		nl, nr := n.Left(), n.Right()
 		if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
 			rval := nr.Val()
@@ -483,18 +487,21 @@ func evalConst(n ir.Node) ir.Node {
 		}
 
 	case ir.OOROR, ir.OANDAND:
+		n := n.(*ir.LogicalExpr)
 		nl, nr := n.Left(), n.Right()
 		if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
 			return origConst(n, constant.BinaryOp(nl.Val(), tokenForOp[n.Op()], nr.Val()))
 		}
 
 	case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
+		n := n.(*ir.BinaryExpr)
 		nl, nr := n.Left(), n.Right()
 		if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
 			return origBoolConst(n, constant.Compare(nl.Val(), tokenForOp[n.Op()], nr.Val()))
 		}
 
 	case ir.OLSH, ir.ORSH:
+		n := n.(*ir.BinaryExpr)
 		nl, nr := n.Left(), n.Right()
 		if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
 			// shiftBound from go/types; "so we can express smallestFloat64"
@@ -509,12 +516,14 @@ func evalConst(n ir.Node) ir.Node {
 		}
 
 	case ir.OCONV, ir.ORUNESTR:
+		n := n.(*ir.ConvExpr)
 		nl := n.Left()
 		if ir.OKForConst[n.Type().Kind()] && nl.Op() == ir.OLITERAL {
 			return origConst(n, convertVal(nl.Val(), n.Type(), true))
 		}
 
 	case ir.OCONVNOP:
+		n := n.(*ir.ConvExpr)
 		nl := n.Left()
 		if ir.OKForConst[n.Type().Kind()] && nl.Op() == ir.OLITERAL {
 			// set so n.Orig gets OCONV instead of OCONVNOP
@@ -524,6 +533,7 @@ func evalConst(n ir.Node) ir.Node {
 
 	case ir.OADDSTR:
 		// Merge adjacent constants in the argument list.
+		n := n.(*ir.AddStringExpr)
 		s := n.List().Slice()
 		need := 0
 		for i := 0; i < len(s); i++ {
@@ -567,6 +577,7 @@ func evalConst(n ir.Node) ir.Node {
 		return nn
 
 	case ir.OCAP, ir.OLEN:
+		n := n.(*ir.UnaryExpr)
 		nl := n.Left()
 		switch nl.Type().Kind() {
 		case types.TSTRING:
@@ -580,21 +591,25 @@ func evalConst(n ir.Node) ir.Node {
 		}
 
 	case ir.OALIGNOF, ir.OOFFSETOF, ir.OSIZEOF:
+		n := n.(*ir.UnaryExpr)
 		return origIntConst(n, evalunsafe(n))
 
 	case ir.OREAL:
+		n := n.(*ir.UnaryExpr)
 		nl := n.Left()
 		if nl.Op() == ir.OLITERAL {
 			return origConst(n, constant.Real(nl.Val()))
 		}
 
 	case ir.OIMAG:
+		n := n.(*ir.UnaryExpr)
 		nl := n.Left()
 		if nl.Op() == ir.OLITERAL {
 			return origConst(n, constant.Imag(nl.Val()))
 		}
 
 	case ir.OCOMPLEX:
+		n := n.(*ir.BinaryExpr)
 		nl, nr := n.Left(), n.Right()
 		if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
 			return origConst(n, makeComplex(nl.Val(), nr.Val()))
@@ -854,6 +869,7 @@ type constSetKey struct {
 // n must not be an untyped constant.
 func (s *constSet) add(pos src.XPos, n ir.Node, what, where string) {
 	if conv := n; conv.Op() == ir.OCONVIFACE {
+		conv := conv.(*ir.ConvExpr)
 		if conv.Implicit() {
 			n = conv.Left()
 		}
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 3cfb24f2fc..d85f10faf3 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -229,6 +229,7 @@ func oldname(s *types.Sym) ir.Node {
 		// are parsing x := 5 inside the closure, until we get to
 		// the := it looks like a reference to the outer x so we'll
 		// make x a closure variable unnecessarily.
+		n := n.(*ir.Name)
 		c := n.Name().Innermost
 		if c == nil || c.Curfn != Curfn {
 			// Do not have a closure var for the active closure yet; make one.
@@ -890,6 +891,7 @@ func (c *nowritebarrierrecChecker) findExtraCalls(nn ir.Node) {
 	arg := n.List().First()
 	switch arg.Op() {
 	case ir.ONAME:
+		arg := arg.(*ir.Name)
 		callee = arg.Name().Defn.(*ir.Func)
 	case ir.OCLOSURE:
 		arg := arg.(*ir.ClosureExpr)
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index c03445044d..0f7d62c5bf 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -1067,11 +1067,13 @@ func (w *exportWriter) stmt(n ir.Node) {
 		// (At the moment neither the parser nor the typechecker
 		// generate OBLOCK nodes except to denote an empty
 		// function body, although that may change.)
+		n := n.(*ir.BlockStmt)
 		for _, n := range n.List().Slice() {
 			w.stmt(n)
 		}
 
 	case ir.ODCL:
+		n := n.(*ir.Decl)
 		w.op(ir.ODCL)
 		w.pos(n.Left().Pos())
 		w.localName(n.Left().(*ir.Name))
@@ -1081,6 +1083,7 @@ func (w *exportWriter) stmt(n ir.Node) {
 		// Don't export "v = <N>" initializing statements, hope they're always
 		// preceded by the DCL which will be re-parsed and typecheck to reproduce
 		// the "v = <N>" again.
+		n := n.(*ir.AssignStmt)
 		if n.Right() != nil {
 			w.op(ir.OAS)
 			w.pos(n.Pos())
@@ -1099,12 +1102,14 @@ func (w *exportWriter) stmt(n ir.Node) {
 		}
 
 	case ir.OAS2, ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV:
+		n := n.(*ir.AssignListStmt)
 		w.op(ir.OAS2)
 		w.pos(n.Pos())
 		w.exprList(n.List())
 		w.exprList(n.Rlist())
 
 	case ir.ORETURN:
+		n := n.(*ir.ReturnStmt)
 		w.op(ir.ORETURN)
 		w.pos(n.Pos())
 		w.exprList(n.List())
@@ -1113,11 +1118,13 @@ func (w *exportWriter) stmt(n ir.Node) {
 	// 	unreachable - generated by compiler for trampolin routines
 
 	case ir.OGO, ir.ODEFER:
+		n := n.(*ir.GoDeferStmt)
 		w.op(n.Op())
 		w.pos(n.Pos())
 		w.expr(n.Left())
 
 	case ir.OIF:
+		n := n.(*ir.IfStmt)
 		w.op(ir.OIF)
 		w.pos(n.Pos())
 		w.stmtList(n.Init())
@@ -1126,6 +1133,7 @@ func (w *exportWriter) stmt(n ir.Node) {
 		w.stmtList(n.Rlist())
 
 	case ir.OFOR:
+		n := n.(*ir.ForStmt)
 		w.op(ir.OFOR)
 		w.pos(n.Pos())
 		w.stmtList(n.Init())
@@ -1133,6 +1141,7 @@ func (w *exportWriter) stmt(n ir.Node) {
 		w.stmtList(n.Body())
 
 	case ir.ORANGE:
+		n := n.(*ir.RangeStmt)
 		w.op(ir.ORANGE)
 		w.pos(n.Pos())
 		w.stmtList(n.List())
@@ -1140,6 +1149,7 @@ func (w *exportWriter) stmt(n ir.Node) {
 		w.stmtList(n.Body())
 
 	case ir.OSELECT:
+		n := n.(*ir.SelectStmt)
 		w.op(n.Op())
 		w.pos(n.Pos())
 		w.stmtList(n.Init())
@@ -1147,6 +1157,7 @@ func (w *exportWriter) stmt(n ir.Node) {
 		w.caseList(n)
 
 	case ir.OSWITCH:
+		n := n.(*ir.SwitchStmt)
 		w.op(n.Op())
 		w.pos(n.Pos())
 		w.stmtList(n.Init())
@@ -1157,6 +1168,7 @@ func (w *exportWriter) stmt(n ir.Node) {
 	//	handled by caseList
 
 	case ir.OFALL:
+		n := n.(*ir.BranchStmt)
 		w.op(ir.OFALL)
 		w.pos(n.Pos())
 
@@ -1217,16 +1229,20 @@ func (w *exportWriter) exprList(list ir.Nodes) {
 func simplifyForExport(n ir.Node) ir.Node {
 	switch n.Op() {
 	case ir.OPAREN:
+		n := n.(*ir.ParenExpr)
 		return simplifyForExport(n.Left())
 	case ir.ODEREF:
+		n := n.(*ir.StarExpr)
 		if n.Implicit() {
 			return simplifyForExport(n.Left())
 		}
 	case ir.OADDR:
+		n := n.(*ir.AddrExpr)
 		if n.Implicit() {
 			return simplifyForExport(n.Left())
 		}
 	case ir.ODOT, ir.ODOTPTR:
+		n := n.(*ir.SelectorExpr)
 		if n.Implicit() {
 			return simplifyForExport(n.Left())
 		}
@@ -1240,6 +1256,7 @@ func (w *exportWriter) expr(n ir.Node) {
 	// expressions
 	// (somewhat closely following the structure of exprfmt in fmt.go)
 	case ir.ONIL:
+		n := n.(*ir.NilExpr)
 		if !n.Type().HasNil() {
 			base.Fatalf("unexpected type for nil: %v", n.Type())
 		}
@@ -1284,6 +1301,7 @@ func (w *exportWriter) expr(n ir.Node) {
 		w.typ(n.Type())
 
 	case ir.OTYPESW:
+		n := n.(*ir.TypeSwitchGuard)
 		w.op(ir.OTYPESW)
 		w.pos(n.Pos())
 		var s *types.Sym
@@ -1306,23 +1324,27 @@ func (w *exportWriter) expr(n ir.Node) {
 	// 	should have been resolved by typechecking - handled by default case
 
 	case ir.OPTRLIT:
+		n := n.(*ir.AddrExpr)
 		w.op(ir.OADDR)
 		w.pos(n.Pos())
 		w.expr(n.Left())
 
 	case ir.OSTRUCTLIT:
+		n := n.(*ir.CompLitExpr)
 		w.op(ir.OSTRUCTLIT)
 		w.pos(n.Pos())
 		w.typ(n.Type())
 		w.fieldList(n.List()) // special handling of field names
 
 	case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT:
+		n := n.(*ir.CompLitExpr)
 		w.op(ir.OCOMPLIT)
 		w.pos(n.Pos())
 		w.typ(n.Type())
 		w.exprList(n.List())
 
 	case ir.OKEY:
+		n := n.(*ir.KeyExpr)
 		w.op(ir.OKEY)
 		w.pos(n.Pos())
 		w.exprsOrNil(n.Left(), n.Right())
@@ -1332,30 +1354,35 @@ func (w *exportWriter) expr(n ir.Node) {
 
 	case ir.OCALLPART:
 		// An OCALLPART is an OXDOT before type checking.
+		n := n.(*ir.CallPartExpr)
 		w.op(ir.OXDOT)
 		w.pos(n.Pos())
 		w.expr(n.Left())
 		w.selector(n.Sym())
 
 	case ir.OXDOT, ir.ODOT, ir.ODOTPTR, ir.ODOTINTER, ir.ODOTMETH:
+		n := n.(*ir.SelectorExpr)
 		w.op(ir.OXDOT)
 		w.pos(n.Pos())
 		w.expr(n.Left())
 		w.selector(n.Sym())
 
 	case ir.ODOTTYPE, ir.ODOTTYPE2:
+		n := n.(*ir.TypeAssertExpr)
 		w.op(ir.ODOTTYPE)
 		w.pos(n.Pos())
 		w.expr(n.Left())
 		w.typ(n.Type())
 
 	case ir.OINDEX, ir.OINDEXMAP:
+		n := n.(*ir.IndexExpr)
 		w.op(ir.OINDEX)
 		w.pos(n.Pos())
 		w.expr(n.Left())
 		w.expr(n.Right())
 
 	case ir.OSLICE, ir.OSLICESTR, ir.OSLICEARR:
+		n := n.(*ir.SliceExpr)
 		w.op(ir.OSLICE)
 		w.pos(n.Pos())
 		w.expr(n.Left())
@@ -1363,6 +1390,7 @@ func (w *exportWriter) expr(n ir.Node) {
 		w.exprsOrNil(low, high)
 
 	case ir.OSLICE3, ir.OSLICE3ARR:
+		n := n.(*ir.SliceExpr)
 		w.op(ir.OSLICE3)
 		w.pos(n.Pos())
 		w.expr(n.Left())
@@ -1372,6 +1400,7 @@ func (w *exportWriter) expr(n ir.Node) {
 
 	case ir.OCOPY, ir.OCOMPLEX:
 		// treated like other builtin calls (see e.g., OREAL)
+		n := n.(*ir.BinaryExpr)
 		w.op(n.Op())
 		w.pos(n.Pos())
 		w.expr(n.Left())
@@ -1379,18 +1408,21 @@ func (w *exportWriter) expr(n ir.Node) {
 		w.op(ir.OEND)
 
 	case ir.OCONV, ir.OCONVIFACE, ir.OCONVNOP, ir.OBYTES2STR, ir.ORUNES2STR, ir.OSTR2BYTES, ir.OSTR2RUNES, ir.ORUNESTR:
+		n := n.(*ir.ConvExpr)
 		w.op(ir.OCONV)
 		w.pos(n.Pos())
 		w.expr(n.Left())
 		w.typ(n.Type())
 
 	case ir.OREAL, ir.OIMAG, ir.OCAP, ir.OCLOSE, ir.OLEN, ir.ONEW, ir.OPANIC:
+		n := n.(*ir.UnaryExpr)
 		w.op(n.Op())
 		w.pos(n.Pos())
 		w.expr(n.Left())
 		w.op(ir.OEND)
 
 	case ir.OAPPEND, ir.ODELETE, ir.ORECOVER, ir.OPRINT, ir.OPRINTN:
+		n := n.(*ir.CallExpr)
 		w.op(n.Op())
 		w.pos(n.Pos())
 		w.exprList(n.List()) // emits terminating OEND
@@ -1402,6 +1434,7 @@ func (w *exportWriter) expr(n ir.Node) {
 		}
 
 	case ir.OCALL, ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER, ir.OGETG:
+		n := n.(*ir.CallExpr)
 		w.op(ir.OCALL)
 		w.pos(n.Pos())
 		w.stmtList(n.Init())
@@ -1410,6 +1443,7 @@ func (w *exportWriter) expr(n ir.Node) {
 		w.bool(n.IsDDD())
 
 	case ir.OMAKEMAP, ir.OMAKECHAN, ir.OMAKESLICE:
+		n := n.(*ir.MakeExpr)
 		w.op(n.Op()) // must keep separate from OMAKE for importer
 		w.pos(n.Pos())
 		w.typ(n.Type())
@@ -1428,21 +1462,25 @@ func (w *exportWriter) expr(n ir.Node) {
 
 	// unary expressions
 	case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT, ir.ORECV:
+		n := n.(*ir.UnaryExpr)
 		w.op(n.Op())
 		w.pos(n.Pos())
 		w.expr(n.Left())
 
 	case ir.OADDR:
+		n := n.(*ir.AddrExpr)
 		w.op(n.Op())
 		w.pos(n.Pos())
 		w.expr(n.Left())
 
 	case ir.ODEREF:
+		n := n.(*ir.StarExpr)
 		w.op(n.Op())
 		w.pos(n.Pos())
 		w.expr(n.Left())
 
 	case ir.OSEND:
+		n := n.(*ir.SendStmt)
 		w.op(n.Op())
 		w.pos(n.Pos())
 		w.expr(n.Left())
@@ -1451,18 +1489,21 @@ func (w *exportWriter) expr(n ir.Node) {
 	// binary expressions
 	case ir.OADD, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OEQ, ir.OGE, ir.OGT, ir.OLE, ir.OLT,
 		ir.OLSH, ir.OMOD, ir.OMUL, ir.ONE, ir.OOR, ir.ORSH, ir.OSUB, ir.OXOR:
+		n := n.(*ir.BinaryExpr)
 		w.op(n.Op())
 		w.pos(n.Pos())
 		w.expr(n.Left())
 		w.expr(n.Right())
 
 	case ir.OANDAND, ir.OOROR:
+		n := n.(*ir.LogicalExpr)
 		w.op(n.Op())
 		w.pos(n.Pos())
 		w.expr(n.Left())
 		w.expr(n.Right())
 
 	case ir.OADDSTR:
+		n := n.(*ir.AddStringExpr)
 		w.op(ir.OADDSTR)
 		w.pos(n.Pos())
 		w.exprList(n.List())
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 1148d329a3..40f76cae7b 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -756,6 +756,7 @@ func (r *importReader) stmtList() []ir.Node {
 		// but the handling of ODCL calls liststmt, which creates one.
 		// Inline them into the statement list.
 		if n.Op() == ir.OBLOCK {
+			n := n.(*ir.BlockStmt)
 			list = append(list, n.List().Slice()...)
 		} else {
 			list = append(list, n)
@@ -802,6 +803,7 @@ func (r *importReader) exprList() []ir.Node {
 func (r *importReader) expr() ir.Node {
 	n := r.node()
 	if n != nil && n.Op() == ir.OBLOCK {
+		n := n.(*ir.BlockStmt)
 		base.Fatalf("unexpected block node: %v", n)
 	}
 	return n
diff --git a/src/cmd/compile/internal/gc/initorder.go b/src/cmd/compile/internal/gc/initorder.go
index c9c3361d3c..f99c6dd72c 100644
--- a/src/cmd/compile/internal/gc/initorder.go
+++ b/src/cmd/compile/internal/gc/initorder.go
@@ -254,10 +254,13 @@ func collectDeps(n ir.Node, transitive bool) ir.NameSet {
 	d := initDeps{transitive: transitive}
 	switch n.Op() {
 	case ir.OAS:
+		n := n.(*ir.AssignStmt)
 		d.inspect(n.Right())
 	case ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV:
+		n := n.(*ir.AssignListStmt)
 		d.inspect(n.Rlist().First())
 	case ir.ODCLFUNC:
+		n := n.(*ir.Func)
 		d.inspectList(n.Body())
 	default:
 		base.Fatalf("unexpected Op: %v", n.Op())
@@ -286,6 +289,7 @@ func (d *initDeps) inspectList(l ir.Nodes) { ir.VisitList(l, d.cachedVisit()) }
 func (d *initDeps) visit(n ir.Node) {
 	switch n.Op() {
 	case ir.OMETHEXPR:
+		n := n.(*ir.MethodExpr)
 		d.foundDep(methodExprName(n))
 
 	case ir.ONAME:
@@ -355,8 +359,10 @@ func (s *declOrder) Pop() interface{} {
 func firstLHS(n ir.Node) *ir.Name {
 	switch n.Op() {
 	case ir.OAS:
+		n := n.(*ir.AssignStmt)
 		return n.Left().Name()
 	case ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2RECV, ir.OAS2MAPR:
+		n := n.(*ir.AssignListStmt)
 		return n.List().First().Name()
 	}
 
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 122c19f6df..7cb7946806 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -377,6 +377,7 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 
 	// Call is okay if inlinable and we have the budget for the body.
 	case ir.OCALLMETH:
+		n := n.(*ir.CallExpr)
 		t := n.Left().Type()
 		if t == nil {
 			base.Fatalf("no function type for [%p] %+v\n", n.Left(), n.Left())
@@ -429,22 +430,26 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 		return nil
 
 	case ir.OFOR, ir.OFORUNTIL:
+		n := n.(*ir.ForStmt)
 		if n.Sym() != nil {
 			return errors.New("labeled control")
 		}
 	case ir.OSWITCH:
+		n := n.(*ir.SwitchStmt)
 		if n.Sym() != nil {
 			return errors.New("labeled control")
 		}
 	// case ir.ORANGE, ir.OSELECT in "unhandled" above
 
 	case ir.OBREAK, ir.OCONTINUE:
+		n := n.(*ir.BranchStmt)
 		if n.Sym() != nil {
 			// Should have short-circuited due to labeled control error above.
 			base.Fatalf("unexpected labeled break/continue: %v", n)
 		}
 
 	case ir.OIF:
+		n := n.(*ir.IfStmt)
 		if ir.IsConst(n.Left(), constant.Bool) {
 			// This if and the condition cost nothing.
 			// TODO(rsc): It seems strange that we visit the dead branch.
@@ -569,8 +574,10 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.No
 
 	switch n.Op() {
 	case ir.ODEFER, ir.OGO:
+		n := n.(*ir.GoDeferStmt)
 		switch call := n.Left(); call.Op() {
 		case ir.OCALLFUNC, ir.OCALLMETH:
+			call := call.(*ir.CallExpr)
 			call.SetNoInline(true)
 		}
 
@@ -581,6 +588,7 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.No
 	case ir.OCALLMETH:
 		// Prevent inlining some reflect.Value methods when using checkptr,
 		// even when package reflect was compiled without it (#35073).
+		n := n.(*ir.CallExpr)
 		if s := n.Left().Sym(); base.Debug.Checkptr != 0 && isReflectPkg(s.Pkg) && (s.Name == "Value.UnsafeAddr" || s.Name == "Value.Pointer") {
 			return n
 		}
@@ -591,6 +599,7 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.No
 	ir.EditChildren(n, edit)
 
 	if as := n; as.Op() == ir.OAS2FUNC {
+		as := as.(*ir.AssignListStmt)
 		if as.Rlist().First().Op() == ir.OINLCALL {
 			as.PtrRlist().Set(inlconv2list(as.Rlist().First().(*ir.InlinedCallExpr)))
 			as.SetOp(ir.OAS2)
@@ -604,6 +613,7 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.No
 	// switch at the top of this function.
 	switch n.Op() {
 	case ir.OCALLFUNC, ir.OCALLMETH:
+		n := n.(*ir.CallExpr)
 		if n.NoInline() {
 			return n
 		}
@@ -673,6 +683,7 @@ func inlCallee(fn ir.Node) *ir.Func {
 		}
 		return n.Func()
 	case ir.ONAME:
+		fn := fn.(*ir.Name)
 		if fn.Class() == ir.PFUNC {
 			return fn.Func()
 		}
@@ -721,8 +732,10 @@ func staticValue1(nn ir.Node) ir.Node {
 FindRHS:
 	switch defn.Op() {
 	case ir.OAS:
+		defn := defn.(*ir.AssignStmt)
 		rhs = defn.Right()
 	case ir.OAS2:
+		defn := defn.(*ir.AssignListStmt)
 		for i, lhs := range defn.List().Slice() {
 			if lhs == n {
 				rhs = defn.Rlist().Index(i)
@@ -761,10 +774,12 @@ func reassigned(name *ir.Name) bool {
 	return ir.Any(name.Curfn, func(n ir.Node) bool {
 		switch n.Op() {
 		case ir.OAS:
+			n := n.(*ir.AssignStmt)
 			if n.Left() == name && n != name.Defn {
 				return true
 			}
 		case ir.OAS2, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2DOTTYPE, ir.OAS2RECV, ir.OSELRECV2:
+			n := n.(*ir.AssignListStmt)
 			for _, p := range n.List().Slice() {
 				if p == name && n != name.Defn {
 					return true
@@ -1237,6 +1252,7 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 		return n
 
 	case ir.OMETHEXPR:
+		n := n.(*ir.MethodExpr)
 		return n
 
 	case ir.OLITERAL, ir.ONIL, ir.OTYPE:
@@ -1259,6 +1275,7 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 	case ir.ORETURN:
 		// Since we don't handle bodies with closures,
 		// this return is guaranteed to belong to the current inlined function.
+		n := n.(*ir.ReturnStmt)
 		init := subst.list(n.Init())
 		if len(subst.retvars) != 0 && n.List().Len() != 0 {
 			as := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
@@ -1285,6 +1302,7 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 		return ir.NewBlockStmt(base.Pos, init)
 
 	case ir.OGOTO:
+		n := n.(*ir.BranchStmt)
 		m := ir.Copy(n).(*ir.BranchStmt)
 		m.SetPos(subst.updatedPos(m.Pos()))
 		m.PtrInit().Set(nil)
@@ -1293,6 +1311,7 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 		return m
 
 	case ir.OLABEL:
+		n := n.(*ir.LabelStmt)
 		m := ir.Copy(n).(*ir.LabelStmt)
 		m.SetPos(subst.updatedPos(m.Pos()))
 		m.PtrInit().Set(nil)
@@ -1365,6 +1384,7 @@ func devirtualizeCall(call *ir.CallExpr) {
 	x := typecheck(ir.NewSelectorExpr(sel.Pos(), ir.OXDOT, dt, sel.Sym()), ctxExpr|ctxCallee)
 	switch x.Op() {
 	case ir.ODOTMETH:
+		x := x.(*ir.SelectorExpr)
 		if base.Flag.LowerM != 0 {
 			base.WarnfAt(call.Pos(), "devirtualizing %v to %v", sel, typ)
 		}
@@ -1372,6 +1392,7 @@ func devirtualizeCall(call *ir.CallExpr) {
 		call.SetLeft(x)
 	case ir.ODOTINTER:
 		// Promoted method from embedded interface-typed field (#42279).
+		x := x.(*ir.SelectorExpr)
 		if base.Flag.LowerM != 0 {
 			base.WarnfAt(call.Pos(), "partially devirtualizing %v to %v", sel, typ)
 		}
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index d2d908bf9f..4b7a22e654 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -1169,6 +1169,7 @@ func (p *noder) ifStmt(stmt *syntax.IfStmt) ir.Node {
 	if stmt.Else != nil {
 		e := p.stmt(stmt.Else)
 		if e.Op() == ir.OBLOCK {
+			e := e.(*ir.BlockStmt)
 			n.PtrRlist().Set(e.List().Slice())
 		} else {
 			n.PtrRlist().Set1(e)
@@ -1319,12 +1320,16 @@ func (p *noder) labeledStmt(label *syntax.LabeledStmt, fallOK bool) ir.Node {
 		if ls != nil {
 			switch ls.Op() {
 			case ir.OFOR:
+				ls := ls.(*ir.ForStmt)
 				ls.SetSym(sym)
 			case ir.ORANGE:
+				ls := ls.(*ir.RangeStmt)
 				ls.SetSym(sym)
 			case ir.OSWITCH:
+				ls := ls.(*ir.SwitchStmt)
 				ls.SetSym(sym)
 			case ir.OSELECT:
+				ls := ls.(*ir.SelectStmt)
 				ls.SetSym(sym)
 			}
 		}
@@ -1333,6 +1338,7 @@ func (p *noder) labeledStmt(label *syntax.LabeledStmt, fallOK bool) ir.Node {
 	l := []ir.Node{lhs}
 	if ls != nil {
 		if ls.Op() == ir.OBLOCK {
+			ls := ls.(*ir.BlockStmt)
 			l = append(l, ls.List().Slice()...)
 		} else {
 			l = append(l, ls)
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 2e7838c252..96164d09fd 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -135,6 +135,7 @@ func (o *Order) cheapExpr(n ir.Node) ir.Node {
 	case ir.ONAME, ir.OLITERAL, ir.ONIL:
 		return n
 	case ir.OLEN, ir.OCAP:
+		n := n.(*ir.UnaryExpr)
 		l := o.cheapExpr(n.Left())
 		if l == n.Left() {
 			return n
@@ -160,6 +161,7 @@ func (o *Order) safeExpr(n ir.Node) ir.Node {
 		return n
 
 	case ir.OLEN, ir.OCAP:
+		n := n.(*ir.UnaryExpr)
 		l := o.safeExpr(n.Left())
 		if l == n.Left() {
 			return n
@@ -169,6 +171,7 @@ func (o *Order) safeExpr(n ir.Node) ir.Node {
 		return typecheck(a, ctxExpr)
 
 	case ir.ODOT:
+		n := n.(*ir.SelectorExpr)
 		l := o.safeExpr(n.Left())
 		if l == n.Left() {
 			return n
@@ -178,6 +181,7 @@ func (o *Order) safeExpr(n ir.Node) ir.Node {
 		return typecheck(a, ctxExpr)
 
 	case ir.ODOTPTR:
+		n := n.(*ir.SelectorExpr)
 		l := o.cheapExpr(n.Left())
 		if l == n.Left() {
 			return n
@@ -187,6 +191,7 @@ func (o *Order) safeExpr(n ir.Node) ir.Node {
 		return typecheck(a, ctxExpr)
 
 	case ir.ODEREF:
+		n := n.(*ir.StarExpr)
 		l := o.cheapExpr(n.Left())
 		if l == n.Left() {
 			return n
@@ -196,6 +201,7 @@ func (o *Order) safeExpr(n ir.Node) ir.Node {
 		return typecheck(a, ctxExpr)
 
 	case ir.OINDEX, ir.OINDEXMAP:
+		n := n.(*ir.IndexExpr)
 		var l ir.Node
 		if n.Left().Type().IsArray() {
 			l = o.safeExpr(n.Left())
@@ -281,9 +287,11 @@ func mapKeyReplaceStrConv(n ir.Node) bool {
 	var replaced bool
 	switch n.Op() {
 	case ir.OBYTES2STR:
+		n := n.(*ir.ConvExpr)
 		n.SetOp(ir.OBYTES2STRTMP)
 		replaced = true
 	case ir.OSTRUCTLIT:
+		n := n.(*ir.CompLitExpr)
 		for _, elem := range n.List().Slice() {
 			elem := elem.(*ir.StructKeyExpr)
 			if mapKeyReplaceStrConv(elem.Left()) {
@@ -291,6 +299,7 @@ func mapKeyReplaceStrConv(n ir.Node) bool {
 			}
 		}
 	case ir.OARRAYLIT:
+		n := n.(*ir.CompLitExpr)
 		for _, elem := range n.List().Slice() {
 			if elem.Op() == ir.OKEY {
 				elem = elem.(*ir.KeyExpr).Right()
@@ -499,6 +508,7 @@ func (o *Order) call(nn ir.Node) {
 		// by copying it into a temp and marking that temp
 		// still alive when we pop the temp stack.
 		if arg.Op() == ir.OCONVNOP {
+			arg := arg.(*ir.ConvExpr)
 			if arg.Left().Type().IsUnsafePtr() {
 				x := o.copyExpr(arg.Left())
 				arg.SetLeft(x)
@@ -512,6 +522,7 @@ func (o *Order) call(nn ir.Node) {
 	for i, param := range n.Left().Type().Params().FieldSlice() {
 		if param.Note == unsafeUintptrTag || param.Note == uintptrEscapesTag {
 			if arg := n.List().Index(i); arg.Op() == ir.OSLICELIT {
+				arg := arg.(*ir.CompLitExpr)
 				for _, elt := range arg.List().Slice() {
 					keepAlive(elt)
 				}
@@ -543,17 +554,20 @@ func (o *Order) mapAssign(n ir.Node) {
 		base.Fatalf("order.mapAssign %v", n.Op())
 
 	case ir.OAS:
+		n := n.(*ir.AssignStmt)
 		if n.Left().Op() == ir.OINDEXMAP {
 			n.SetRight(o.safeMapRHS(n.Right()))
 		}
 		o.out = append(o.out, n)
 	case ir.OASOP:
+		n := n.(*ir.AssignOpStmt)
 		if n.Left().Op() == ir.OINDEXMAP {
 			n.SetRight(o.safeMapRHS(n.Right()))
 		}
 		o.out = append(o.out, n)
 
 	case ir.OAS2, ir.OAS2DOTTYPE, ir.OAS2MAPR, ir.OAS2FUNC:
+		n := n.(*ir.AssignListStmt)
 		var post []ir.Node
 		for i, m := range n.List().Slice() {
 			switch {
@@ -583,6 +597,7 @@ func (o *Order) safeMapRHS(r ir.Node) ir.Node {
 	// Make sure we evaluate the RHS before starting the map insert.
 	// We need to make sure the RHS won't panic.  See issue 22881.
 	if r.Op() == ir.OAPPEND {
+		r := r.(*ir.CallExpr)
 		s := r.List().Slice()[1:]
 		for i, n := range s {
 			s[i] = o.cheapExpr(n)
@@ -611,6 +626,7 @@ func (o *Order) stmt(n ir.Node) {
 		o.out = append(o.out, n)
 
 	case ir.OAS:
+		n := n.(*ir.AssignStmt)
 		t := o.markTemp()
 		n.SetLeft(o.expr(n.Left(), nil))
 		n.SetRight(o.expr(n.Right(), n.Left()))
@@ -618,6 +634,7 @@ func (o *Order) stmt(n ir.Node) {
 		o.cleanTemp(t)
 
 	case ir.OASOP:
+		n := n.(*ir.AssignOpStmt)
 		t := o.markTemp()
 		n.SetLeft(o.expr(n.Left(), nil))
 		n.SetRight(o.expr(n.Right(), nil))
@@ -632,6 +649,7 @@ func (o *Order) stmt(n ir.Node) {
 			l1 := o.safeExpr(n.Left())
 			l2 := ir.DeepCopy(src.NoXPos, l1)
 			if l2.Op() == ir.OINDEXMAP {
+				l2 := l2.(*ir.IndexExpr)
 				l2.SetIndexMapLValue(false)
 			}
 			l2 = o.copyExpr(l2)
@@ -646,6 +664,7 @@ func (o *Order) stmt(n ir.Node) {
 		o.cleanTemp(t)
 
 	case ir.OAS2:
+		n := n.(*ir.AssignListStmt)
 		t := o.markTemp()
 		o.exprList(n.List())
 		o.exprList(n.Rlist())
@@ -675,10 +694,13 @@ func (o *Order) stmt(n ir.Node) {
 
 		switch r := n.Rlist().First(); r.Op() {
 		case ir.ODOTTYPE2:
+			r := r.(*ir.TypeAssertExpr)
 			r.SetLeft(o.expr(r.Left(), nil))
 		case ir.ORECV:
+			r := r.(*ir.UnaryExpr)
 			r.SetLeft(o.expr(r.Left(), nil))
 		case ir.OINDEXMAP:
+			r := r.(*ir.IndexExpr)
 			r.SetLeft(o.expr(r.Left(), nil))
 			r.SetRight(o.expr(r.Right(), nil))
 			// See similar conversion for OINDEXMAP below.
@@ -693,6 +715,7 @@ func (o *Order) stmt(n ir.Node) {
 
 	// Special: does not save n onto out.
 	case ir.OBLOCK:
+		n := n.(*ir.BlockStmt)
 		o.stmtList(n.List())
 
 	// Special: n->left is not an expression; save as is.
@@ -709,18 +732,21 @@ func (o *Order) stmt(n ir.Node) {
 
 	// Special: handle call arguments.
 	case ir.OCALLFUNC, ir.OCALLINTER, ir.OCALLMETH:
+		n := n.(*ir.CallExpr)
 		t := o.markTemp()
 		o.call(n)
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
 
 	case ir.OCLOSE, ir.ORECV:
+		n := n.(*ir.UnaryExpr)
 		t := o.markTemp()
 		n.SetLeft(o.expr(n.Left(), nil))
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
 
 	case ir.OCOPY:
+		n := n.(*ir.BinaryExpr)
 		t := o.markTemp()
 		n.SetLeft(o.expr(n.Left(), nil))
 		n.SetRight(o.expr(n.Right(), nil))
@@ -728,6 +754,7 @@ func (o *Order) stmt(n ir.Node) {
 		o.cleanTemp(t)
 
 	case ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
+		n := n.(*ir.CallExpr)
 		t := o.markTemp()
 		o.exprList(n.List())
 		o.out = append(o.out, n)
@@ -735,6 +762,7 @@ func (o *Order) stmt(n ir.Node) {
 
 	// Special: order arguments to inner call but not call itself.
 	case ir.ODEFER, ir.OGO:
+		n := n.(*ir.GoDeferStmt)
 		t := o.markTemp()
 		o.init(n.Left())
 		o.call(n.Left())
@@ -742,6 +770,7 @@ func (o *Order) stmt(n ir.Node) {
 		o.cleanTemp(t)
 
 	case ir.ODELETE:
+		n := n.(*ir.CallExpr)
 		t := o.markTemp()
 		n.List().SetFirst(o.expr(n.List().First(), nil))
 		n.List().SetSecond(o.expr(n.List().Second(), nil))
@@ -752,6 +781,7 @@ func (o *Order) stmt(n ir.Node) {
 	// Clean temporaries from condition evaluation at
 	// beginning of loop body and after for statement.
 	case ir.OFOR:
+		n := n.(*ir.ForStmt)
 		t := o.markTemp()
 		n.SetLeft(o.exprInPlace(n.Left()))
 		n.PtrBody().Prepend(o.cleanTempNoPop(t)...)
@@ -763,6 +793,7 @@ func (o *Order) stmt(n ir.Node) {
 	// Clean temporaries from condition at
 	// beginning of both branches.
 	case ir.OIF:
+		n := n.(*ir.IfStmt)
 		t := o.markTemp()
 		n.SetLeft(o.exprInPlace(n.Left()))
 		n.PtrBody().Prepend(o.cleanTempNoPop(t)...)
@@ -775,6 +806,7 @@ func (o *Order) stmt(n ir.Node) {
 	// Special: argument will be converted to interface using convT2E
 	// so make sure it is an addressable temporary.
 	case ir.OPANIC:
+		n := n.(*ir.UnaryExpr)
 		t := o.markTemp()
 		n.SetLeft(o.expr(n.Left(), nil))
 		if !n.Left().Type().IsInterface() {
@@ -858,6 +890,7 @@ func (o *Order) stmt(n ir.Node) {
 		o.cleanTemp(t)
 
 	case ir.ORETURN:
+		n := n.(*ir.ReturnStmt)
 		o.exprList(n.List())
 		o.out = append(o.out, n)
 
@@ -871,6 +904,7 @@ func (o *Order) stmt(n ir.Node) {
 	// case (if p were nil, then the timing of the fault would
 	// give this away).
 	case ir.OSELECT:
+		n := n.(*ir.SelectStmt)
 		t := o.markTemp()
 		for _, ncas := range n.List().Slice() {
 			ncas := ncas.(*ir.CaseStmt)
@@ -932,6 +966,7 @@ func (o *Order) stmt(n ir.Node) {
 				orderBlock(ncas.PtrInit(), o.free)
 
 			case ir.OSEND:
+				r := r.(*ir.SendStmt)
 				if r.Init().Len() != 0 {
 					ir.DumpList("ninit", r.Init())
 					base.Fatalf("ninit on select send")
@@ -969,6 +1004,7 @@ func (o *Order) stmt(n ir.Node) {
 
 	// Special: value being sent is passed as a pointer; make it addressable.
 	case ir.OSEND:
+		n := n.(*ir.SendStmt)
 		t := o.markTemp()
 		n.SetLeft(o.expr(n.Left(), nil))
 		n.SetRight(o.expr(n.Right(), nil))
@@ -1100,6 +1136,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		if haslit && hasbyte {
 			for _, n2 := range n.List().Slice() {
 				if n2.Op() == ir.OBYTES2STR {
+					n2 := n2.(*ir.ConvExpr)
 					n2.SetOp(ir.OBYTES2STRTMP)
 				}
 			}
@@ -1107,6 +1144,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		return n
 
 	case ir.OINDEXMAP:
+		n := n.(*ir.IndexExpr)
 		n.SetLeft(o.expr(n.Left(), nil))
 		n.SetRight(o.expr(n.Right(), nil))
 		needCopy := false
@@ -1134,6 +1172,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 	// concrete type (not interface) argument might need an addressable
 	// temporary to pass to the runtime conversion routine.
 	case ir.OCONVIFACE:
+		n := n.(*ir.ConvExpr)
 		n.SetLeft(o.expr(n.Left(), nil))
 		if n.Left().Type().IsInterface() {
 			return n
@@ -1147,6 +1186,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		return n
 
 	case ir.OCONVNOP:
+		n := n.(*ir.ConvExpr)
 		if n.Type().IsKind(types.TUNSAFEPTR) && n.Left().Type().IsKind(types.TUINTPTR) && (n.Left().Op() == ir.OCALLFUNC || n.Left().Op() == ir.OCALLINTER || n.Left().Op() == ir.OCALLMETH) {
 			call := n.Left().(*ir.CallExpr)
 			// When reordering unsafe.Pointer(f()) into a separate
@@ -1172,6 +1212,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		// }
 		// ... = r
 
+		n := n.(*ir.LogicalExpr)
 		r := o.newTemp(n.Type(), false)
 
 		// Evaluate left-hand side.
@@ -1233,6 +1274,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 
 	case ir.OAPPEND:
 		// Check for append(x, make([]T, y)...) .
+		n := n.(*ir.CallExpr)
 		if isAppendOfMake(n) {
 			n.List().SetFirst(o.expr(n.List().First(), nil)) // order x
 			mk := n.List().Second().(*ir.MakeExpr)
@@ -1247,6 +1289,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		return n
 
 	case ir.OSLICE, ir.OSLICEARR, ir.OSLICESTR, ir.OSLICE3, ir.OSLICE3ARR:
+		n := n.(*ir.SliceExpr)
 		n.SetLeft(o.expr(n.Left(), nil))
 		low, high, max := n.SliceBounds()
 		low = o.expr(low, nil)
@@ -1287,6 +1330,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		return n
 
 	case ir.ODOTTYPE, ir.ODOTTYPE2:
+		n := n.(*ir.TypeAssertExpr)
 		n.SetLeft(o.expr(n.Left(), nil))
 		if !isdirectiface(n.Type()) || instrumenting {
 			return o.copyExprClear(n)
@@ -1294,10 +1338,12 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		return n
 
 	case ir.ORECV:
+		n := n.(*ir.UnaryExpr)
 		n.SetLeft(o.expr(n.Left(), nil))
 		return o.copyExprClear(n)
 
 	case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
+		n := n.(*ir.BinaryExpr)
 		n.SetLeft(o.expr(n.Left(), nil))
 		n.SetRight(o.expr(n.Right(), nil))
 
@@ -1338,6 +1384,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		// Without this special case, order would otherwise compute all
 		// the keys and values before storing any of them to the map.
 		// See issue 26552.
+		n := n.(*ir.CompLitExpr)
 		entries := n.List().Slice()
 		statics := entries[:0]
 		var dynamics []*ir.KeyExpr
diff --git a/src/cmd/compile/internal/gc/scc.go b/src/cmd/compile/internal/gc/scc.go
index 8fe20a80fd..f2d089fa4c 100644
--- a/src/cmd/compile/internal/gc/scc.go
+++ b/src/cmd/compile/internal/gc/scc.go
@@ -81,6 +81,7 @@ func (v *bottomUpVisitor) visit(n *ir.Func) uint32 {
 	ir.Visit(n, func(n ir.Node) {
 		switch n.Op() {
 		case ir.ONAME:
+			n := n.(*ir.Name)
 			if n.Class() == ir.PFUNC {
 				if n != nil && n.Name().Defn != nil {
 					if m := v.visit(n.Name().Defn.(*ir.Func)); m < min {
@@ -89,6 +90,7 @@ func (v *bottomUpVisitor) visit(n *ir.Func) uint32 {
 				}
 			}
 		case ir.OMETHEXPR:
+			n := n.(*ir.MethodExpr)
 			fn := methodExprName(n)
 			if fn != nil && fn.Defn != nil {
 				if m := v.visit(fn.Defn.(*ir.Func)); m < min {
@@ -96,6 +98,7 @@ func (v *bottomUpVisitor) visit(n *ir.Func) uint32 {
 				}
 			}
 		case ir.ODOTMETH:
+			n := n.(*ir.SelectorExpr)
 			fn := methodExprName(n)
 			if fn != nil && fn.Op() == ir.ONAME && fn.Class() == ir.PFUNC && fn.Defn != nil {
 				if m := v.visit(fn.Defn.(*ir.Func)); m < min {
@@ -103,6 +106,7 @@ func (v *bottomUpVisitor) visit(n *ir.Func) uint32 {
 				}
 			}
 		case ir.OCALLPART:
+			n := n.(*ir.CallPartExpr)
 			fn := ir.AsNode(callpartMethod(n).Nname)
 			if fn != nil && fn.Op() == ir.ONAME {
 				if fn := fn.(*ir.Name); fn.Class() == ir.PFUNC && fn.Name().Defn != nil {
diff --git a/src/cmd/compile/internal/gc/select.go b/src/cmd/compile/internal/gc/select.go
index be2f688eb9..64d3461dca 100644
--- a/src/cmd/compile/internal/gc/select.go
+++ b/src/cmd/compile/internal/gc/select.go
@@ -56,7 +56,9 @@ func typecheckselect(sel *ir.SelectStmt) {
 				// convert x = <-c into x, _ = <-c
 				// remove implicit conversions; the eventual assignment
 				// will reintroduce them.
+				n := n.(*ir.AssignStmt)
 				if r := n.Right(); r.Op() == ir.OCONVNOP || r.Op() == ir.OCONVIFACE {
+					r := r.(*ir.ConvExpr)
 					if r.Implicit() {
 						n.SetRight(r.Left())
 					}
@@ -68,6 +70,7 @@ func typecheckselect(sel *ir.SelectStmt) {
 				oselrecv2(n.Left(), n.Right(), n.Colas())
 
 			case ir.OAS2RECV:
+				n := n.(*ir.AssignListStmt)
 				if n.Rlist().First().Op() != ir.ORECV {
 					base.ErrorfAt(n.Pos(), "select assignment must have receive on right hand side")
 					break
@@ -76,6 +79,7 @@ func typecheckselect(sel *ir.SelectStmt) {
 
 			case ir.ORECV:
 				// convert <-c into _, _ = <-c
+				n := n.(*ir.UnaryExpr)
 				oselrecv2(ir.BlankNode, n, false)
 
 			case ir.OSEND:
@@ -162,10 +166,12 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 		}
 		switch n.Op() {
 		case ir.OSEND:
+			n := n.(*ir.SendStmt)
 			n.SetRight(nodAddr(n.Right()))
 			n.SetRight(typecheck(n.Right(), ctxExpr))
 
 		case ir.OSELRECV2:
+			n := n.(*ir.AssignListStmt)
 			if !ir.IsBlank(n.List().First()) {
 				n.List().SetIndex(0, nodAddr(n.List().First()))
 				n.List().SetIndex(0, typecheck(n.List().First(), ctxExpr))
@@ -191,10 +197,12 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 
 		case ir.OSEND:
 			// if selectnbsend(c, v) { body } else { default body }
+			n := n.(*ir.SendStmt)
 			ch := n.Left()
 			call = mkcall1(chanfn("selectnbsend", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), ch, n.Right())
 
 		case ir.OSELRECV2:
+			n := n.(*ir.AssignListStmt)
 			recv := n.Rlist().First().(*ir.UnaryExpr)
 			ch := recv.Left()
 			elem := n.List().First()
@@ -261,11 +269,13 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 		default:
 			base.Fatalf("select %v", n.Op())
 		case ir.OSEND:
+			n := n.(*ir.SendStmt)
 			i = nsends
 			nsends++
 			c = n.Left()
 			elem = n.Right()
 		case ir.OSELRECV2:
+			n := n.(*ir.AssignListStmt)
 			nrecvs++
 			i = ncas - nrecvs
 			recv := n.Rlist().First().(*ir.UnaryExpr)
@@ -323,6 +333,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 		r := ir.NewIfStmt(base.Pos, cond, nil, nil)
 
 		if n := cas.Left(); n != nil && n.Op() == ir.OSELRECV2 {
+			n := n.(*ir.AssignListStmt)
 			if !ir.IsBlank(n.List().Second()) {
 				x := ir.NewAssignStmt(base.Pos, n.List().Second(), recvOK)
 				r.PtrBody().Append(typecheck(x, ctxStmt))
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 5a96d4c320..f4988df9ac 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -127,6 +127,7 @@ func (s *InitSchedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *type
 		return true
 
 	case ir.OADDR:
+		r := r.(*ir.AddrExpr)
 		if a := r.Left(); a.Op() == ir.ONAME {
 			a := a.(*ir.Name)
 			addrsym(l, loff, a, 0)
@@ -134,6 +135,7 @@ func (s *InitSchedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *type
 		}
 
 	case ir.OPTRLIT:
+		r := r.(*ir.AddrExpr)
 		switch r.Left().Op() {
 		case ir.OARRAYLIT, ir.OSLICELIT, ir.OSTRUCTLIT, ir.OMAPLIT:
 			// copy pointer
@@ -148,6 +150,7 @@ func (s *InitSchedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *type
 		return true
 
 	case ir.OARRAYLIT, ir.OSTRUCTLIT:
+		r := r.(*ir.CompLitExpr)
 		p := s.initplans[r]
 		for i := range p.E {
 			e := &p.E[i]
@@ -202,6 +205,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 		return true
 
 	case ir.OADDR:
+		r := r.(*ir.AddrExpr)
 		if name, offset, ok := stataddr(r.Left()); ok {
 			addrsym(l, loff, name, offset)
 			return true
@@ -209,6 +213,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 		fallthrough
 
 	case ir.OPTRLIT:
+		r := r.(*ir.AddrExpr)
 		switch r.Left().Op() {
 		case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT, ir.OSTRUCTLIT:
 			// Init pointer.
@@ -226,6 +231,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 		//dump("not static ptrlit", r);
 
 	case ir.OSTR2BYTES:
+		r := r.(*ir.ConvExpr)
 		if l.Class() == ir.PEXTERN && r.Left().Op() == ir.OLITERAL {
 			sval := ir.StringVal(r.Left())
 			slicebytes(l, loff, sval)
@@ -247,6 +253,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 		fallthrough
 
 	case ir.OARRAYLIT, ir.OSTRUCTLIT:
+		r := r.(*ir.CompLitExpr)
 		s.initplan(r)
 
 		p := s.initplans[r]
@@ -287,6 +294,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 		// If you change something here, change it there, and vice versa.
 
 		// Determine the underlying concrete type and value we are converting from.
+		r := r.(*ir.ConvExpr)
 		val := ir.Node(r)
 		for val.Op() == ir.OCONVIFACE {
 			val = val.(*ir.ConvExpr).Left()
@@ -467,6 +475,7 @@ func isStaticCompositeLiteral(n ir.Node) bool {
 	case ir.OSLICELIT:
 		return false
 	case ir.OARRAYLIT:
+		n := n.(*ir.CompLitExpr)
 		for _, r := range n.List().Slice() {
 			if r.Op() == ir.OKEY {
 				r = r.(*ir.KeyExpr).Right()
@@ -477,6 +486,7 @@ func isStaticCompositeLiteral(n ir.Node) bool {
 		}
 		return true
 	case ir.OSTRUCTLIT:
+		n := n.(*ir.CompLitExpr)
 		for _, r := range n.List().Slice() {
 			r := r.(*ir.StructKeyExpr)
 			if !isStaticCompositeLiteral(r.Left()) {
@@ -488,6 +498,7 @@ func isStaticCompositeLiteral(n ir.Node) bool {
 		return true
 	case ir.OCONVIFACE:
 		// See staticassign's OCONVIFACE case for comments.
+		n := n.(*ir.ConvExpr)
 		val := ir.Node(n)
 		for val.Op() == ir.OCONVIFACE {
 			val = val.(*ir.ConvExpr).Left()
@@ -865,6 +876,7 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 		base.Fatalf("anylit: not lit, op=%v node=%v", n.Op(), n)
 
 	case ir.ONAME:
+		n := n.(*ir.Name)
 		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, n))
 
 	case ir.OMETHEXPR:
@@ -872,6 +884,7 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 		anylit(n.FuncName(), var_, init)
 
 	case ir.OPTRLIT:
+		n := n.(*ir.AddrExpr)
 		if !t.IsPtr() {
 			base.Fatalf("anylit: not ptr")
 		}
@@ -1001,6 +1014,7 @@ func stataddr(n ir.Node) (name *ir.Name, offset int64, ok bool) {
 		return stataddr(n.FuncName())
 
 	case ir.ODOT:
+		n := n.(*ir.SelectorExpr)
 		if name, offset, ok = stataddr(n.Left()); !ok {
 			break
 		}
@@ -1008,6 +1022,7 @@ func stataddr(n ir.Node) (name *ir.Name, offset int64, ok bool) {
 		return name, offset, true
 
 	case ir.OINDEX:
+		n := n.(*ir.IndexExpr)
 		if n.Left().Type().IsSlice() {
 			break
 		}
@@ -1041,6 +1056,7 @@ func (s *InitSchedule) initplan(n ir.Node) {
 		base.Fatalf("initplan")
 
 	case ir.OARRAYLIT, ir.OSLICELIT:
+		n := n.(*ir.CompLitExpr)
 		var k int64
 		for _, a := range n.List().Slice() {
 			if a.Op() == ir.OKEY {
@@ -1056,6 +1072,7 @@ func (s *InitSchedule) initplan(n ir.Node) {
 		}
 
 	case ir.OSTRUCTLIT:
+		n := n.(*ir.CompLitExpr)
 		for _, a := range n.List().Slice() {
 			if a.Op() != ir.OSTRUCTKEY {
 				base.Fatalf("initplan structlit")
@@ -1068,6 +1085,7 @@ func (s *InitSchedule) initplan(n ir.Node) {
 		}
 
 	case ir.OMAPLIT:
+		n := n.(*ir.CompLitExpr)
 		for _, a := range n.List().Slice() {
 			if a.Op() != ir.OKEY {
 				base.Fatalf("initplan maplit")
@@ -1116,6 +1134,7 @@ func isZero(n ir.Node) bool {
 		}
 
 	case ir.OARRAYLIT:
+		n := n.(*ir.CompLitExpr)
 		for _, n1 := range n.List().Slice() {
 			if n1.Op() == ir.OKEY {
 				n1 = n1.(*ir.KeyExpr).Right()
@@ -1127,6 +1146,7 @@ func isZero(n ir.Node) bool {
 		return true
 
 	case ir.OSTRUCTLIT:
+		n := n.(*ir.CompLitExpr)
 		for _, n1 := range n.List().Slice() {
 			n1 := n1.(*ir.StructKeyExpr)
 			if !isZero(n1.Left()) {
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index cc5f9eeea6..dc3ea4be9e 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -1150,6 +1150,7 @@ func (s *state) stmt(n ir.Node) {
 	switch n.Op() {
 
 	case ir.OBLOCK:
+		n := n.(*ir.BlockStmt)
 		s.stmtList(n.List())
 
 	// No-ops
@@ -1180,6 +1181,7 @@ func (s *state) stmt(n ir.Node) {
 			}
 		}
 	case ir.ODEFER:
+		n := n.(*ir.GoDeferStmt)
 		if base.Debug.Defer > 0 {
 			var defertype string
 			if s.hasOpenDefers {
@@ -1201,9 +1203,11 @@ func (s *state) stmt(n ir.Node) {
 			s.callResult(n.Left().(*ir.CallExpr), d)
 		}
 	case ir.OGO:
+		n := n.(*ir.GoDeferStmt)
 		s.callResult(n.Left().(*ir.CallExpr), callGo)
 
 	case ir.OAS2DOTTYPE:
+		n := n.(*ir.AssignListStmt)
 		res, resok := s.dottype(n.Rlist().First().(*ir.TypeAssertExpr), true)
 		deref := false
 		if !canSSAType(n.Rlist().First().Type()) {
@@ -1226,6 +1230,7 @@ func (s *state) stmt(n ir.Node) {
 
 	case ir.OAS2FUNC:
 		// We come here only when it is an intrinsic call returning two values.
+		n := n.(*ir.AssignListStmt)
 		call := n.Rlist().First().(*ir.CallExpr)
 		if !IsIntrinsicCall(call) {
 			s.Fatalf("non-intrinsic AS2FUNC not expanded %v", call)
@@ -1238,11 +1243,13 @@ func (s *state) stmt(n ir.Node) {
 		return
 
 	case ir.ODCL:
+		n := n.(*ir.Decl)
 		if n.Left().(*ir.Name).Class() == ir.PAUTOHEAP {
 			s.Fatalf("DCL %v", n)
 		}
 
 	case ir.OLABEL:
+		n := n.(*ir.LabelStmt)
 		sym := n.Sym()
 		lab := s.label(sym)
 
@@ -1260,6 +1267,7 @@ func (s *state) stmt(n ir.Node) {
 		s.startBlock(lab.target)
 
 	case ir.OGOTO:
+		n := n.(*ir.BranchStmt)
 		sym := n.Sym()
 
 		lab := s.label(sym)
@@ -1272,6 +1280,7 @@ func (s *state) stmt(n ir.Node) {
 		b.AddEdgeTo(lab.target)
 
 	case ir.OAS:
+		n := n.(*ir.AssignStmt)
 		if n.Left() == n.Right() && n.Left().Op() == ir.ONAME {
 			// An x=x assignment. No point in doing anything
 			// here. In addition, skipping this assignment
@@ -1356,6 +1365,7 @@ func (s *state) stmt(n ir.Node) {
 		if rhs != nil && (rhs.Op() == ir.OSLICE || rhs.Op() == ir.OSLICE3 || rhs.Op() == ir.OSLICESTR) && samesafeexpr(rhs.(*ir.SliceExpr).Left(), n.Left()) {
 			// We're assigning a slicing operation back to its source.
 			// Don't write back fields we aren't changing. See issue #14855.
+			rhs := rhs.(*ir.SliceExpr)
 			i, j, k := rhs.SliceBounds()
 			if i != nil && (i.Op() == ir.OLITERAL && i.Val().Kind() == constant.Int && ir.Int64Val(i) == 0) {
 				// [0:...] is the same as [:...]
@@ -1385,6 +1395,7 @@ func (s *state) stmt(n ir.Node) {
 		s.assign(n.Left(), r, deref, skip)
 
 	case ir.OIF:
+		n := n.(*ir.IfStmt)
 		if ir.IsConst(n.Left(), constant.Bool) {
 			s.stmtList(n.Left().Init())
 			if ir.BoolVal(n.Left()) {
@@ -1431,16 +1442,19 @@ func (s *state) stmt(n ir.Node) {
 		s.startBlock(bEnd)
 
 	case ir.ORETURN:
+		n := n.(*ir.ReturnStmt)
 		s.stmtList(n.List())
 		b := s.exit()
 		b.Pos = s.lastPos.WithIsStmt()
 
 	case ir.ORETJMP:
+		n := n.(*ir.BranchStmt)
 		b := s.exit()
 		b.Kind = ssa.BlockRetJmp // override BlockRet
 		b.Aux = callTargetLSym(n.Sym(), s.curfn.LSym)
 
 	case ir.OCONTINUE, ir.OBREAK:
+		n := n.(*ir.BranchStmt)
 		var to *ssa.Block
 		if n.Sym() == nil {
 			// plain break/continue
@@ -1472,6 +1486,7 @@ func (s *state) stmt(n ir.Node) {
 		//
 		// OFORUNTIL: for Ninit; Left; Right; List { Nbody }
 		// => body: { Nbody }; incr: Right; if Left { lateincr: List; goto body }; end:
+		n := n.(*ir.ForStmt)
 		bCond := s.f.NewBlock(ssa.BlockPlain)
 		bBody := s.f.NewBlock(ssa.BlockPlain)
 		bIncr := s.f.NewBlock(ssa.BlockPlain)
@@ -1600,6 +1615,7 @@ func (s *state) stmt(n ir.Node) {
 		s.startBlock(bEnd)
 
 	case ir.OVARDEF:
+		n := n.(*ir.UnaryExpr)
 		if !s.canSSA(n.Left()) {
 			s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, n.Left().(*ir.Name), s.mem(), false)
 		}
@@ -1608,12 +1624,14 @@ func (s *state) stmt(n ir.Node) {
 		// We only care about liveness info at call sites, so putting the
 		// varkill in the store chain is enough to keep it correctly ordered
 		// with respect to call ops.
+		n := n.(*ir.UnaryExpr)
 		if !s.canSSA(n.Left()) {
 			s.vars[memVar] = s.newValue1Apos(ssa.OpVarKill, types.TypeMem, n.Left().(*ir.Name), s.mem(), false)
 		}
 
 	case ir.OVARLIVE:
 		// Insert a varlive op to record that a variable is still live.
+		n := n.(*ir.UnaryExpr)
 		v := n.Left().(*ir.Name)
 		if !v.Addrtaken() {
 			s.Fatalf("VARLIVE variable %v must have Addrtaken set", v)
@@ -1626,10 +1644,12 @@ func (s *state) stmt(n ir.Node) {
 		s.vars[memVar] = s.newValue1A(ssa.OpVarLive, types.TypeMem, v, s.mem())
 
 	case ir.OCHECKNIL:
+		n := n.(*ir.UnaryExpr)
 		p := s.expr(n.Left())
 		s.nilCheck(p)
 
 	case ir.OINLMARK:
+		n := n.(*ir.InlineMarkStmt)
 		s.newValue1I(ssa.OpInlMark, types.TypeVoid, n.Offset(), s.mem())
 
 	default:
@@ -2097,16 +2117,19 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 	s.stmtList(n.Init())
 	switch n.Op() {
 	case ir.OBYTES2STRTMP:
+		n := n.(*ir.ConvExpr)
 		slice := s.expr(n.Left())
 		ptr := s.newValue1(ssa.OpSlicePtr, s.f.Config.Types.BytePtr, slice)
 		len := s.newValue1(ssa.OpSliceLen, types.Types[types.TINT], slice)
 		return s.newValue2(ssa.OpStringMake, n.Type(), ptr, len)
 	case ir.OSTR2BYTESTMP:
+		n := n.(*ir.ConvExpr)
 		str := s.expr(n.Left())
 		ptr := s.newValue1(ssa.OpStringPtr, s.f.Config.Types.BytePtr, str)
 		len := s.newValue1(ssa.OpStringLen, types.Types[types.TINT], str)
 		return s.newValue3(ssa.OpSliceMake, n.Type(), ptr, len, len)
 	case ir.OCFUNC:
+		n := n.(*ir.UnaryExpr)
 		aux := n.Left().Sym().Linksym()
 		return s.entryNewValue1A(ssa.OpAddr, n.Type(), aux, s.sb)
 	case ir.OMETHEXPR:
@@ -2114,6 +2137,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		sym := funcsym(n.FuncName().Sym()).Linksym()
 		return s.entryNewValue1A(ssa.OpAddr, types.NewPtr(n.Type()), sym, s.sb)
 	case ir.ONAME:
+		n := n.(*ir.Name)
 		if n.Class() == ir.PFUNC {
 			// "value" of a function is the address of the function's closure
 			sym := funcsym(n.Sym()).Linksym()
@@ -2135,6 +2159,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		addr := s.addr(n)
 		return s.load(n.Type(), addr)
 	case ir.ONIL:
+		n := n.(*ir.NilExpr)
 		t := n.Type()
 		switch {
 		case t.IsSlice():
@@ -2203,6 +2228,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 			return nil
 		}
 	case ir.OCONVNOP:
+		n := n.(*ir.ConvExpr)
 		to := n.Type()
 		from := n.Left().Type()
 
@@ -2271,6 +2297,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		return v
 
 	case ir.OCONV:
+		n := n.(*ir.ConvExpr)
 		x := s.expr(n.Left())
 		ft := n.Left().Type() // from type
 		tt := n.Type()        // to type
@@ -2448,6 +2475,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 
 	// binary ops
 	case ir.OLT, ir.OEQ, ir.ONE, ir.OLE, ir.OGE, ir.OGT:
+		n := n.(*ir.BinaryExpr)
 		a := s.expr(n.Left())
 		b := s.expr(n.Right())
 		if n.Left().Type().IsComplex() {
@@ -2481,6 +2509,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		// integer comparison
 		return s.newValue2(s.ssaOp(op, n.Left().Type()), types.Types[types.TBOOL], a, b)
 	case ir.OMUL:
+		n := n.(*ir.BinaryExpr)
 		a := s.expr(n.Left())
 		b := s.expr(n.Right())
 		if n.Type().IsComplex() {
@@ -2520,6 +2549,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		return s.newValue2(s.ssaOp(n.Op(), n.Type()), a.Type, a, b)
 
 	case ir.ODIV:
+		n := n.(*ir.BinaryExpr)
 		a := s.expr(n.Left())
 		b := s.expr(n.Right())
 		if n.Type().IsComplex() {
@@ -2567,10 +2597,12 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		}
 		return s.intDivide(n, a, b)
 	case ir.OMOD:
+		n := n.(*ir.BinaryExpr)
 		a := s.expr(n.Left())
 		b := s.expr(n.Right())
 		return s.intDivide(n, a, b)
 	case ir.OADD, ir.OSUB:
+		n := n.(*ir.BinaryExpr)
 		a := s.expr(n.Left())
 		b := s.expr(n.Right())
 		if n.Type().IsComplex() {
@@ -2585,15 +2617,18 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		}
 		return s.newValue2(s.ssaOp(n.Op(), n.Type()), a.Type, a, b)
 	case ir.OAND, ir.OOR, ir.OXOR:
+		n := n.(*ir.BinaryExpr)
 		a := s.expr(n.Left())
 		b := s.expr(n.Right())
 		return s.newValue2(s.ssaOp(n.Op(), n.Type()), a.Type, a, b)
 	case ir.OANDNOT:
+		n := n.(*ir.BinaryExpr)
 		a := s.expr(n.Left())
 		b := s.expr(n.Right())
 		b = s.newValue1(s.ssaOp(ir.OBITNOT, b.Type), b.Type, b)
 		return s.newValue2(s.ssaOp(ir.OAND, n.Type()), a.Type, a, b)
 	case ir.OLSH, ir.ORSH:
+		n := n.(*ir.BinaryExpr)
 		a := s.expr(n.Left())
 		b := s.expr(n.Right())
 		bt := b.Type
@@ -2617,6 +2652,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		//     }
 		// Using var in the subsequent block introduces the
 		// necessary phi variable.
+		n := n.(*ir.LogicalExpr)
 		el := s.expr(n.Left())
 		s.vars[n] = el
 
@@ -2648,12 +2684,14 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		s.startBlock(bResult)
 		return s.variable(n, types.Types[types.TBOOL])
 	case ir.OCOMPLEX:
+		n := n.(*ir.BinaryExpr)
 		r := s.expr(n.Left())
 		i := s.expr(n.Right())
 		return s.newValue2(ssa.OpComplexMake, n.Type(), r, i)
 
 	// unary ops
 	case ir.ONEG:
+		n := n.(*ir.UnaryExpr)
 		a := s.expr(n.Left())
 		if n.Type().IsComplex() {
 			tp := floatForComplex(n.Type())
@@ -2664,18 +2702,23 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		}
 		return s.newValue1(s.ssaOp(n.Op(), n.Type()), a.Type, a)
 	case ir.ONOT, ir.OBITNOT:
+		n := n.(*ir.UnaryExpr)
 		a := s.expr(n.Left())
 		return s.newValue1(s.ssaOp(n.Op(), n.Type()), a.Type, a)
 	case ir.OIMAG, ir.OREAL:
+		n := n.(*ir.UnaryExpr)
 		a := s.expr(n.Left())
 		return s.newValue1(s.ssaOp(n.Op(), n.Left().Type()), n.Type(), a)
 	case ir.OPLUS:
+		n := n.(*ir.UnaryExpr)
 		return s.expr(n.Left())
 
 	case ir.OADDR:
+		n := n.(*ir.AddrExpr)
 		return s.addr(n.Left())
 
 	case ir.ORESULT:
+		n := n.(*ir.ResultExpr)
 		if s.prevCall == nil || s.prevCall.Op != ssa.OpStaticLECall && s.prevCall.Op != ssa.OpInterLECall && s.prevCall.Op != ssa.OpClosureLECall {
 			// Do the old thing
 			addr := s.constOffPtrSP(types.NewPtr(n.Type()), n.Offset())
@@ -2695,6 +2738,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		}
 
 	case ir.ODEREF:
+		n := n.(*ir.StarExpr)
 		p := s.exprPtr(n.Left(), n.Bounded(), n.Pos())
 		return s.load(n.Type(), p)
 
@@ -2721,11 +2765,13 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		return s.newValue1I(ssa.OpStructSelect, n.Type(), int64(fieldIdx(n)), v)
 
 	case ir.ODOTPTR:
+		n := n.(*ir.SelectorExpr)
 		p := s.exprPtr(n.Left(), n.Bounded(), n.Pos())
 		p = s.newValue1I(ssa.OpOffPtr, types.NewPtr(n.Type()), n.Offset(), p)
 		return s.load(n.Type(), p)
 
 	case ir.OINDEX:
+		n := n.(*ir.IndexExpr)
 		switch {
 		case n.Left().Type().IsString():
 			if n.Bounded() && ir.IsConst(n.Left(), constant.String) && ir.IsConst(n.Right(), constant.Int) {
@@ -2792,6 +2838,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		}
 
 	case ir.OSPTR:
+		n := n.(*ir.UnaryExpr)
 		a := s.expr(n.Left())
 		if n.Left().Type().IsSlice() {
 			return s.newValue1(ssa.OpSlicePtr, n.Type(), a)
@@ -2800,25 +2847,30 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		}
 
 	case ir.OITAB:
+		n := n.(*ir.UnaryExpr)
 		a := s.expr(n.Left())
 		return s.newValue1(ssa.OpITab, n.Type(), a)
 
 	case ir.OIDATA:
+		n := n.(*ir.UnaryExpr)
 		a := s.expr(n.Left())
 		return s.newValue1(ssa.OpIData, n.Type(), a)
 
 	case ir.OEFACE:
+		n := n.(*ir.BinaryExpr)
 		tab := s.expr(n.Left())
 		data := s.expr(n.Right())
 		return s.newValue2(ssa.OpIMake, n.Type(), tab, data)
 
 	case ir.OSLICEHEADER:
+		n := n.(*ir.SliceHeaderExpr)
 		p := s.expr(n.Left())
 		l := s.expr(n.List().First())
 		c := s.expr(n.List().Second())
 		return s.newValue3(ssa.OpSliceMake, n.Type(), p, l, c)
 
 	case ir.OSLICE, ir.OSLICEARR, ir.OSLICE3, ir.OSLICE3ARR:
+		n := n.(*ir.SliceExpr)
 		v := s.expr(n.Left())
 		var i, j, k *ssa.Value
 		low, high, max := n.SliceBounds()
@@ -2835,6 +2887,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		return s.newValue3(ssa.OpSliceMake, n.Type(), p, l, c)
 
 	case ir.OSLICESTR:
+		n := n.(*ir.SliceExpr)
 		v := s.expr(n.Left())
 		var i, j *ssa.Value
 		low, high, _ := n.SliceBounds()
@@ -2859,6 +2912,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		return s.callResult(n, callNormal)
 
 	case ir.OGETG:
+		n := n.(*ir.CallExpr)
 		return s.newValue1(ssa.OpGetG, n.Type(), s.mem())
 
 	case ir.OAPPEND:
@@ -2868,12 +2922,14 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		// All literals with nonzero fields have already been
 		// rewritten during walk. Any that remain are just T{}
 		// or equivalents. Use the zero value.
+		n := n.(*ir.CompLitExpr)
 		if !isZero(n) {
 			s.Fatalf("literal with nonzero value in SSA: %v", n)
 		}
 		return s.zeroVal(n.Type())
 
 	case ir.ONEWOBJ:
+		n := n.(*ir.UnaryExpr)
 		if n.Type().Elem().Size() == 0 {
 			return s.newValue1A(ssa.OpAddr, n.Type(), zerobaseSym, s.sb)
 		}
@@ -3057,6 +3113,7 @@ func (s *state) append(n *ir.CallExpr, inplace bool) *ssa.Value {
 func (s *state) condBranch(cond ir.Node, yes, no *ssa.Block, likely int8) {
 	switch cond.Op() {
 	case ir.OANDAND:
+		cond := cond.(*ir.LogicalExpr)
 		mid := s.f.NewBlock(ssa.BlockPlain)
 		s.stmtList(cond.Init())
 		s.condBranch(cond.Left(), mid, no, max8(likely, 0))
@@ -3070,6 +3127,7 @@ func (s *state) condBranch(cond ir.Node, yes, no *ssa.Block, likely int8) {
 		// TODO: have the frontend give us branch prediction hints for
 		// OANDAND and OOROR nodes (if it ever has such info).
 	case ir.OOROR:
+		cond := cond.(*ir.LogicalExpr)
 		mid := s.f.NewBlock(ssa.BlockPlain)
 		s.stmtList(cond.Init())
 		s.condBranch(cond.Left(), yes, mid, min8(likely, 0))
@@ -3080,10 +3138,12 @@ func (s *state) condBranch(cond ir.Node, yes, no *ssa.Block, likely int8) {
 		// If likely==1, then we don't have enough info to decide
 		// the likelihood of the first branch.
 	case ir.ONOT:
+		cond := cond.(*ir.UnaryExpr)
 		s.stmtList(cond.Init())
 		s.condBranch(cond.Left(), no, yes, -likely)
 		return
 	case ir.OCONVNOP:
+		cond := cond.(*ir.ConvExpr)
 		s.stmtList(cond.Init())
 		s.condBranch(cond.Left(), yes, no, likely)
 		return
@@ -3157,6 +3217,7 @@ func (s *state) assign(left ir.Node, right *ssa.Value, deref bool, skip skipMask
 			return
 		}
 		if left.Op() == ir.OINDEX && left.(*ir.IndexExpr).Left().Type().IsArray() {
+			left := left.(*ir.IndexExpr)
 			s.pushLine(left.Pos())
 			defer s.popLine()
 			// We're assigning to an element of an ssa-able array.
@@ -4630,6 +4691,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 	case ir.OCALLFUNC:
 		testLateExpansion = k != callDeferStack && ssa.LateCallExpansionEnabledWithin(s.f)
 		if k == callNormal && fn.Op() == ir.ONAME && fn.(*ir.Name).Class() == ir.PFUNC {
+			fn := fn.(*ir.Name)
 			sym = fn.Sym()
 			break
 		}
@@ -5000,6 +5062,7 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 		}
 	case ir.ORESULT:
 		// load return from callee
+		n := n.(*ir.ResultExpr)
 		if s.prevCall == nil || s.prevCall.Op != ssa.OpStaticLECall && s.prevCall.Op != ssa.OpInterLECall && s.prevCall.Op != ssa.OpClosureLECall {
 			return s.constOffPtrSP(t, n.Offset())
 		}
@@ -5012,6 +5075,7 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 		return x
 
 	case ir.OINDEX:
+		n := n.(*ir.IndexExpr)
 		if n.Left().Type().IsSlice() {
 			a := s.expr(n.Left())
 			i := s.expr(n.Right())
@@ -5027,11 +5091,14 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 			return s.newValue2(ssa.OpPtrIndex, types.NewPtr(n.Left().Type().Elem()), a, i)
 		}
 	case ir.ODEREF:
+		n := n.(*ir.StarExpr)
 		return s.exprPtr(n.Left(), n.Bounded(), n.Pos())
 	case ir.ODOT:
+		n := n.(*ir.SelectorExpr)
 		p := s.addr(n.Left())
 		return s.newValue1I(ssa.OpOffPtr, t, n.Offset(), p)
 	case ir.ODOTPTR:
+		n := n.(*ir.SelectorExpr)
 		p := s.exprPtr(n.Left(), n.Bounded(), n.Pos())
 		return s.newValue1I(ssa.OpOffPtr, t, n.Offset(), p)
 	case ir.OCLOSUREREAD:
@@ -5039,6 +5106,7 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 		return s.newValue1I(ssa.OpOffPtr, t, n.Offset(),
 			s.entryNewValue0(ssa.OpGetClosurePtr, s.f.Config.Types.BytePtr))
 	case ir.OCONVNOP:
+		n := n.(*ir.ConvExpr)
 		if n.Type() == n.Left().Type() {
 			return s.addr(n.Left())
 		}
@@ -5072,10 +5140,12 @@ func (s *state) canSSA(n ir.Node) bool {
 	for {
 		nn := n
 		if nn.Op() == ir.ODOT {
+			nn := nn.(*ir.SelectorExpr)
 			n = nn.Left()
 			continue
 		}
 		if nn.Op() == ir.OINDEX {
+			nn := nn.(*ir.IndexExpr)
 			if nn.Left().Type().IsArray() {
 				n = nn.Left()
 				continue
@@ -7297,11 +7367,13 @@ func (e *ssafn) MyImportPath() string {
 
 func clobberBase(n ir.Node) ir.Node {
 	if n.Op() == ir.ODOT {
+		n := n.(*ir.SelectorExpr)
 		if n.Left().Type().NumFields() == 1 {
 			return clobberBase(n.Left())
 		}
 	}
 	if n.Op() == ir.OINDEX {
+		n := n.(*ir.IndexExpr)
 		if n.Left().Type().IsArray() && n.Left().Type().NumElem() == 1 {
 			return clobberBase(n.Left())
 		}
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 174452def2..5aebae0b18 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -612,6 +612,7 @@ func calcHasCall(n ir.Node) bool {
 		return true
 	case ir.OANDAND, ir.OOROR:
 		// hard with instrumented code
+		n := n.(*ir.LogicalExpr)
 		if instrumenting {
 			return true
 		}
@@ -625,42 +626,52 @@ func calcHasCall(n ir.Node) bool {
 	// When using soft-float, these ops might be rewritten to function calls
 	// so we ensure they are evaluated first.
 	case ir.OADD, ir.OSUB, ir.OMUL:
+		n := n.(*ir.BinaryExpr)
 		if thearch.SoftFloat && (isFloat[n.Type().Kind()] || isComplex[n.Type().Kind()]) {
 			return true
 		}
 		return n.Left().HasCall() || n.Right().HasCall()
 	case ir.ONEG:
+		n := n.(*ir.UnaryExpr)
 		if thearch.SoftFloat && (isFloat[n.Type().Kind()] || isComplex[n.Type().Kind()]) {
 			return true
 		}
 		return n.Left().HasCall()
 	case ir.OLT, ir.OEQ, ir.ONE, ir.OLE, ir.OGE, ir.OGT:
+		n := n.(*ir.BinaryExpr)
 		if thearch.SoftFloat && (isFloat[n.Left().Type().Kind()] || isComplex[n.Left().Type().Kind()]) {
 			return true
 		}
 		return n.Left().HasCall() || n.Right().HasCall()
 	case ir.OCONV:
+		n := n.(*ir.ConvExpr)
 		if thearch.SoftFloat && ((isFloat[n.Type().Kind()] || isComplex[n.Type().Kind()]) || (isFloat[n.Left().Type().Kind()] || isComplex[n.Left().Type().Kind()])) {
 			return true
 		}
 		return n.Left().HasCall()
 
 	case ir.OAND, ir.OANDNOT, ir.OLSH, ir.OOR, ir.ORSH, ir.OXOR, ir.OCOPY, ir.OCOMPLEX, ir.OEFACE:
+		n := n.(*ir.BinaryExpr)
 		return n.Left().HasCall() || n.Right().HasCall()
 
 	case ir.OAS:
+		n := n.(*ir.AssignStmt)
 		return n.Left().HasCall() || n.Right() != nil && n.Right().HasCall()
 
 	case ir.OADDR:
+		n := n.(*ir.AddrExpr)
 		return n.Left().HasCall()
 	case ir.OPAREN:
+		n := n.(*ir.ParenExpr)
 		return n.Left().HasCall()
 	case ir.OBITNOT, ir.ONOT, ir.OPLUS, ir.ORECV,
 		ir.OALIGNOF, ir.OCAP, ir.OCLOSE, ir.OIMAG, ir.OLEN, ir.ONEW,
 		ir.OOFFSETOF, ir.OPANIC, ir.OREAL, ir.OSIZEOF,
 		ir.OCHECKNIL, ir.OCFUNC, ir.OIDATA, ir.OITAB, ir.ONEWOBJ, ir.OSPTR, ir.OVARDEF, ir.OVARKILL, ir.OVARLIVE:
+		n := n.(*ir.UnaryExpr)
 		return n.Left().HasCall()
 	case ir.ODOT, ir.ODOTMETH, ir.ODOTINTER:
+		n := n.(*ir.SelectorExpr)
 		return n.Left().HasCall()
 
 	case ir.OGETG, ir.OCLOSUREREAD, ir.OMETHEXPR:
@@ -675,12 +686,15 @@ func calcHasCall(n ir.Node) bool {
 		return false
 	case ir.OCONVIFACE, ir.OCONVNOP, ir.OBYTES2STR, ir.OBYTES2STRTMP, ir.ORUNES2STR, ir.OSTR2BYTES, ir.OSTR2BYTESTMP, ir.OSTR2RUNES, ir.ORUNESTR:
 		// TODO(rsc): Some conversions are themselves calls, no?
+		n := n.(*ir.ConvExpr)
 		return n.Left().HasCall()
 	case ir.ODOTTYPE2:
 		// TODO(rsc): Shouldn't this be up with ODOTTYPE above?
+		n := n.(*ir.TypeAssertExpr)
 		return n.Left().HasCall()
 	case ir.OSLICEHEADER:
 		// TODO(rsc): What about len and cap?
+		n := n.(*ir.SliceHeaderExpr)
 		return n.Left().HasCall()
 	case ir.OAS2DOTTYPE, ir.OAS2FUNC:
 		// TODO(rsc): Surely we need to check List and Rlist.
@@ -768,6 +782,7 @@ func safeexpr(n ir.Node, init *ir.Nodes) ir.Node {
 		return n
 
 	case ir.OLEN, ir.OCAP:
+		n := n.(*ir.UnaryExpr)
 		l := safeexpr(n.Left(), init)
 		if l == n.Left() {
 			return n
@@ -777,6 +792,7 @@ func safeexpr(n ir.Node, init *ir.Nodes) ir.Node {
 		return walkexpr(typecheck(a, ctxExpr), init)
 
 	case ir.ODOT, ir.ODOTPTR:
+		n := n.(*ir.SelectorExpr)
 		l := safeexpr(n.Left(), init)
 		if l == n.Left() {
 			return n
@@ -786,6 +802,7 @@ func safeexpr(n ir.Node, init *ir.Nodes) ir.Node {
 		return walkexpr(typecheck(a, ctxExpr), init)
 
 	case ir.ODEREF:
+		n := n.(*ir.StarExpr)
 		l := safeexpr(n.Left(), init)
 		if l == n.Left() {
 			return n
@@ -795,6 +812,7 @@ func safeexpr(n ir.Node, init *ir.Nodes) ir.Node {
 		return walkexpr(typecheck(a, ctxExpr), init)
 
 	case ir.OINDEX, ir.OINDEXMAP:
+		n := n.(*ir.IndexExpr)
 		l := safeexpr(n.Left(), init)
 		r := safeexpr(n.Right(), init)
 		if l == n.Left() && r == n.Right() {
@@ -806,6 +824,7 @@ func safeexpr(n ir.Node, init *ir.Nodes) ir.Node {
 		return walkexpr(typecheck(a, ctxExpr), init)
 
 	case ir.OSTRUCTLIT, ir.OARRAYLIT, ir.OSLICELIT:
+		n := n.(*ir.CompLitExpr)
 		if isStaticCompositeLiteral(n) {
 			return n
 		}
diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index 1866a6a784..7cd1c16e00 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -266,6 +266,7 @@ func walkExprSwitch(sw *ir.SwitchStmt) {
 	// conversion into a runtime call.
 	// See issue 24937 for more discussion.
 	if cond.Op() == ir.OBYTES2STR && allCaseExprsAreSideEffectFree(sw) {
+		cond := cond.(*ir.ConvExpr)
 		cond.SetOp(ir.OBYTES2STRTMP)
 	}
 
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index db03fd9e75..bb5e9fad1e 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -412,6 +412,7 @@ func typecheck(n ir.Node, top int) (res ir.Node) {
 		switch n.Op() {
 		// We can already diagnose variables used as types.
 		case ir.ONAME:
+			n := n.(*ir.Name)
 			if top&(ctxExpr|ctxType) == ctxType {
 				base.Errorf("%v is not a type", n)
 			}
@@ -477,6 +478,7 @@ func typecheck(n ir.Node, top int) (res ir.Node) {
 	isMulti := false
 	switch n.Op() {
 	case ir.OCALLFUNC, ir.OCALLINTER, ir.OCALLMETH:
+		n := n.(*ir.CallExpr)
 		if t := n.Left().Type(); t != nil && t.Kind() == types.TFUNC {
 			nr := t.NumResults()
 			isMulti = nr > 1
@@ -577,6 +579,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 
 		if n.Op() == ir.ONAME {
+			n := n.(*ir.Name)
 			if n.SubOp() != 0 && top&ctxCallee == 0 {
 				base.Errorf("use of builtin %v not in function call", n.Sym())
 				n.SetType(nil)
@@ -608,6 +611,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.ONAME:
+		n := n.(*ir.Name)
 		if n.Name().Decldepth == 0 {
 			n.Name().Decldepth = decldepth
 		}
@@ -630,6 +634,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OPACK:
+		n := n.(*ir.PkgName)
 		base.Errorf("use of package %v without selector", n.Sym())
 		n.SetType(nil)
 		return n
@@ -816,6 +821,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 		op := n.Op()
 		if n.Op() == ir.OASOP {
+			n := n.(*ir.AssignOpStmt)
 			checkassign(n, l)
 			if n.Implicit() && !okforarith[l.Type().Kind()] {
 				base.Errorf("invalid operation: %v (non-numeric type %v)", n, l.Type())
@@ -859,6 +865,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		// can't be used with "&&" than to report that "x == x" (type untyped bool)
 		// can't be converted to int (see issue #41500).
 		if n.Op() == ir.OANDAND || n.Op() == ir.OOROR {
+			n := n.(*ir.LogicalExpr)
 			if !n.Left().Type().IsBoolean() {
 				base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op(), typekind(n.Left().Type()))
 				n.SetType(nil)
@@ -1010,6 +1017,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 		if et == types.TSTRING && n.Op() == ir.OADD {
 			// create or update OADDSTR node with list of strings in x + y + z + (w + v) + ...
+			n := n.(*ir.BinaryExpr)
 			var add *ir.AddStringExpr
 			if l.Op() == ir.OADDSTR {
 				add = l.(*ir.AddStringExpr)
@@ -1018,6 +1026,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				add = ir.NewAddStringExpr(n.Pos(), []ir.Node{l})
 			}
 			if r.Op() == ir.OADDSTR {
+				r := r.(*ir.AddStringExpr)
 				add.PtrList().AppendNodes(r.PtrList())
 			} else {
 				add.PtrList().Append(r)
@@ -1038,6 +1047,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OBITNOT, ir.ONEG, ir.ONOT, ir.OPLUS:
+		n := n.(*ir.UnaryExpr)
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		l := n.Left()
 		t := l.Type()
@@ -1056,6 +1066,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	// exprs
 	case ir.OADDR:
+		n := n.(*ir.AddrExpr)
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		if n.Left().Type() == nil {
 			n.SetType(nil)
@@ -1070,6 +1081,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			checklvalue(n.Left(), "take the address of")
 			r := outervalue(n.Left())
 			if r.Op() == ir.ONAME {
+				r := r.(*ir.Name)
 				if ir.Orig(r) != r {
 					base.Fatalf("found non-orig name node %v", r) // TODO(mdempsky): What does this mean?
 				}
@@ -1170,6 +1182,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.ODOTTYPE:
+		n := n.(*ir.TypeAssertExpr)
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetLeft(defaultlit(n.Left(), nil))
 		l := n.Left()
@@ -1215,6 +1228,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OINDEX:
+		n := n.(*ir.IndexExpr)
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetLeft(defaultlit(n.Left(), nil))
 		n.SetLeft(implicitstar(n.Left()))
@@ -1273,6 +1287,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.ORECV:
+		n := n.(*ir.UnaryExpr)
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetLeft(defaultlit(n.Left(), nil))
 		l := n.Left()
@@ -1297,6 +1312,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OSEND:
+		n := n.(*ir.SendStmt)
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetRight(typecheck(n.Right(), ctxExpr))
 		n.SetLeft(defaultlit(n.Left(), nil))
@@ -1325,6 +1341,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		// can construct an OSLICEHEADER node.
 		// Components used in OSLICEHEADER that are supplied by parsed source code
 		// have already been typechecked in e.g. OMAKESLICE earlier.
+		n := n.(*ir.SliceHeaderExpr)
 		t := n.Type()
 		if t == nil {
 			base.Fatalf("no type specified for OSLICEHEADER")
@@ -1369,6 +1386,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		// can construct an OMAKESLICECOPY node.
 		// Components used in OMAKESCLICECOPY that are supplied by parsed source code
 		// have already been typechecked in OMAKE and OCOPY earlier.
+		n := n.(*ir.MakeExpr)
 		t := n.Type()
 
 		if t == nil {
@@ -1407,6 +1425,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OSLICE, ir.OSLICE3:
+		n := n.(*ir.SliceExpr)
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		low, high, max := n.SliceBounds()
 		hasmax := n.Op().IsSlice3()
@@ -1496,6 +1515,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		l := n.Left()
 
 		if l.Op() == ir.ONAME && l.(*ir.Name).SubOp() != 0 {
+			l := l.(*ir.Name)
 			if n.IsDDD() && l.SubOp() != ir.OAPPEND {
 				base.Errorf("invalid use of ... with builtin %v", l)
 			}
@@ -1571,6 +1591,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			n.SetOp(ir.OCALLINTER)
 
 		case ir.ODOTMETH:
+			l := l.(*ir.SelectorExpr)
 			n.SetOp(ir.OCALLMETH)
 
 			// typecheckaste was used here but there wasn't enough
@@ -1632,10 +1653,12 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OALIGNOF, ir.OOFFSETOF, ir.OSIZEOF:
+		n := n.(*ir.UnaryExpr)
 		n.SetType(types.Types[types.TUINTPTR])
 		return n
 
 	case ir.OCAP, ir.OLEN:
+		n := n.(*ir.UnaryExpr)
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetLeft(defaultlit(n.Left(), nil))
 		n.SetLeft(implicitstar(n.Left()))
@@ -1662,6 +1685,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OREAL, ir.OIMAG:
+		n := n.(*ir.UnaryExpr)
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		l := n.Left()
 		t := l.Type()
@@ -1686,6 +1710,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OCOMPLEX:
+		n := n.(*ir.BinaryExpr)
 		l := typecheck(n.Left(), ctxExpr)
 		r := typecheck(n.Right(), ctxExpr)
 		if l.Type() == nil || r.Type() == nil {
@@ -1726,6 +1751,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OCLOSE:
+		n := n.(*ir.UnaryExpr)
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetLeft(defaultlit(n.Left(), nil))
 		l := n.Left()
@@ -1748,6 +1774,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.ODELETE:
+		n := n.(*ir.CallExpr)
 		typecheckargs(n)
 		args := n.List()
 		if args.Len() == 0 {
@@ -1780,6 +1807,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OAPPEND:
+		n := n.(*ir.CallExpr)
 		typecheckargs(n)
 		args := n.List()
 		if args.Len() == 0 {
@@ -1840,6 +1868,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OCOPY:
+		n := n.(*ir.BinaryExpr)
 		n.SetType(types.Types[types.TINT])
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetLeft(defaultlit(n.Left(), nil))
@@ -1925,6 +1954,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OMAKE:
+		n := n.(*ir.CallExpr)
 		args := n.List().Slice()
 		if len(args) == 0 {
 			base.Errorf("missing argument to make")
@@ -2032,6 +2062,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return nn
 
 	case ir.ONEW:
+		n := n.(*ir.UnaryExpr)
 		if n.Left() == nil {
 			// Fatalf because the OCALL above checked for us,
 			// so this must be an internally-generated mistake.
@@ -2049,6 +2080,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OPRINT, ir.OPRINTN:
+		n := n.(*ir.CallExpr)
 		typecheckargs(n)
 		ls := n.List().Slice()
 		for i1, n1 := range ls {
@@ -2062,6 +2094,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OPANIC:
+		n := n.(*ir.UnaryExpr)
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetLeft(defaultlit(n.Left(), types.Types[types.TINTER]))
 		if n.Left().Type() == nil {
@@ -2071,6 +2104,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.ORECOVER:
+		n := n.(*ir.CallExpr)
 		if n.List().Len() != 0 {
 			base.Errorf("too many arguments to recover")
 			n.SetType(nil)
@@ -2089,6 +2123,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OITAB:
+		n := n.(*ir.UnaryExpr)
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		t := n.Left().Type()
 		if t == nil {
@@ -2104,10 +2139,12 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 	case ir.OIDATA:
 		// Whoever creates the OIDATA node must know a priori the concrete type at that moment,
 		// usually by just having checked the OITAB.
+		n := n.(*ir.UnaryExpr)
 		base.Fatalf("cannot typecheck interface data %v", n)
 		panic("unreachable")
 
 	case ir.OSPTR:
+		n := n.(*ir.UnaryExpr)
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		t := n.Left().Type()
 		if t == nil {
@@ -2128,11 +2165,13 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OCFUNC:
+		n := n.(*ir.UnaryExpr)
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetType(types.Types[types.TUINTPTR])
 		return n
 
 	case ir.OCONVNOP:
+		n := n.(*ir.ConvExpr)
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		return n
 
@@ -2161,6 +2200,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OBLOCK:
+		n := n.(*ir.BlockStmt)
 		typecheckslice(n.List().Slice(), ctxStmt)
 		return n
 
@@ -2183,6 +2223,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OFOR, ir.OFORUNTIL:
+		n := n.(*ir.ForStmt)
 		typecheckslice(n.Init().Slice(), ctxStmt)
 		decldepth++
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
@@ -2202,6 +2243,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OIF:
+		n := n.(*ir.IfStmt)
 		typecheckslice(n.Init().Slice(), ctxStmt)
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetLeft(defaultlit(n.Left(), nil))
@@ -2216,6 +2258,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.ORETURN:
+		n := n.(*ir.ReturnStmt)
 		typecheckargs(n)
 		if Curfn == nil {
 			base.Errorf("return outside function")
@@ -2230,6 +2273,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.ORETJMP:
+		n := n.(*ir.BranchStmt)
 		return n
 
 	case ir.OSELECT:
@@ -2245,6 +2289,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OTYPESW:
+		n := n.(*ir.TypeSwitchGuard)
 		base.Errorf("use of .(type) outside type switch")
 		n.SetType(nil)
 		return n
@@ -2254,10 +2299,12 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.ODCLCONST:
+		n := n.(*ir.Decl)
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		return n
 
 	case ir.ODCLTYPE:
+		n := n.(*ir.Decl)
 		n.SetLeft(typecheck(n.Left(), ctxType))
 		checkwidth(n.Left().Type())
 		return n
@@ -2814,6 +2861,7 @@ notenough:
 			// Method expressions have the form T.M, and the compiler has
 			// rewritten those to ONAME nodes but left T in Left.
 			if call.Op() == ir.OMETHEXPR {
+				call := call.(*ir.MethodExpr)
 				base.Errorf("not enough arguments in call to method expression %v%s", call, details)
 			} else {
 				base.Errorf("not enough arguments in call to %v%s", call, details)
@@ -3231,6 +3279,7 @@ func nonexported(sym *types.Sym) bool {
 func islvalue(n ir.Node) bool {
 	switch n.Op() {
 	case ir.OINDEX:
+		n := n.(*ir.IndexExpr)
 		if n.Left().Type() != nil && n.Left().Type().IsArray() {
 			return islvalue(n.Left())
 		}
@@ -3242,9 +3291,11 @@ func islvalue(n ir.Node) bool {
 		return true
 
 	case ir.ODOT:
+		n := n.(*ir.SelectorExpr)
 		return islvalue(n.Left())
 
 	case ir.ONAME:
+		n := n.(*ir.Name)
 		if n.Class() == ir.PFUNC {
 			return false
 		}
@@ -3268,6 +3319,7 @@ func checkassign(stmt ir.Node, n ir.Node) {
 	if !ir.DeclaredBy(n, stmt) || stmt.Op() == ir.ORANGE {
 		r := outervalue(n)
 		if r.Op() == ir.ONAME {
+			r := r.(*ir.Name)
 			r.Name().SetAssigned(true)
 			if r.Name().IsClosureVar() {
 				r.Name().Defn.Name().SetAssigned(true)
@@ -3279,6 +3331,7 @@ func checkassign(stmt ir.Node, n ir.Node) {
 		return
 	}
 	if n.Op() == ir.OINDEXMAP {
+		n := n.(*ir.IndexExpr)
 		n.SetIndexMapLValue(true)
 		return
 	}
@@ -3529,6 +3582,7 @@ func typecheckas2(n *ir.AssignListStmt) {
 			case ir.ORECV:
 				n.SetOp(ir.OAS2RECV)
 			case ir.ODOTTYPE:
+				r := r.(*ir.TypeAssertExpr)
 				n.SetOp(ir.OAS2DOTTYPE)
 				r.SetOp(ir.ODOTTYPE2)
 			}
@@ -3554,6 +3608,7 @@ mismatch:
 	default:
 		base.Errorf("assignment mismatch: %d variables but %d values", cl, cr)
 	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
+		r := r.(*ir.CallExpr)
 		base.Errorf("assignment mismatch: %d variables but %v returns %d values", cl, r.Left(), cr)
 	}
 
@@ -3768,6 +3823,7 @@ func typecheckdef(n ir.Node) {
 		}
 
 	case ir.ONAME:
+		n := n.(*ir.Name)
 		if n.Name().Ntype != nil {
 			n.Name().Ntype = typecheckNtype(n.Name().Ntype)
 			n.SetType(n.Name().Ntype.Type())
@@ -3888,6 +3944,7 @@ func markBreak(fn *ir.Func) {
 			ir.DoChildren(n, mark)
 
 		case ir.OBREAK:
+			n := n.(*ir.BranchStmt)
 			if n.Sym() == nil {
 				setHasBreak(implicit)
 			} else {
@@ -3980,12 +4037,14 @@ func isTermNode(n ir.Node) bool {
 	// skipping over the label. No case OLABEL here.
 
 	case ir.OBLOCK:
+		n := n.(*ir.BlockStmt)
 		return isTermNodes(n.List())
 
 	case ir.OGOTO, ir.ORETURN, ir.ORETJMP, ir.OPANIC, ir.OFALL:
 		return true
 
 	case ir.OFOR, ir.OFORUNTIL:
+		n := n.(*ir.ForStmt)
 		if n.Left() != nil {
 			return false
 		}
@@ -3995,9 +4054,11 @@ func isTermNode(n ir.Node) bool {
 		return true
 
 	case ir.OIF:
+		n := n.(*ir.IfStmt)
 		return isTermNodes(n.Body()) && isTermNodes(n.Rlist())
 
 	case ir.OSWITCH:
+		n := n.(*ir.SwitchStmt)
 		if n.HasBreak() {
 			return false
 		}
@@ -4014,6 +4075,7 @@ func isTermNode(n ir.Node) bool {
 		return def
 
 	case ir.OSELECT:
+		n := n.(*ir.SelectStmt)
 		if n.HasBreak() {
 			return false
 		}
@@ -4052,10 +4114,12 @@ func deadcode(fn *ir.Func) {
 		}
 		switch n.Op() {
 		case ir.OIF:
+			n := n.(*ir.IfStmt)
 			if !ir.IsConst(n.Left(), constant.Bool) || n.Body().Len() > 0 || n.Rlist().Len() > 0 {
 				return
 			}
 		case ir.OFOR:
+			n := n.(*ir.ForStmt)
 			if !ir.IsConst(n.Left(), constant.Bool) || ir.BoolVal(n.Left()) {
 				return
 			}
@@ -4083,6 +4147,7 @@ func deadcodeslice(nn *ir.Nodes) {
 			continue
 		}
 		if n.Op() == ir.OIF {
+			n := n.(*ir.IfStmt)
 			n.SetLeft(deadcodeexpr(n.Left()))
 			if ir.IsConst(n.Left(), constant.Bool) {
 				var body ir.Nodes
@@ -4112,19 +4177,26 @@ func deadcodeslice(nn *ir.Nodes) {
 		deadcodeslice(n.PtrInit())
 		switch n.Op() {
 		case ir.OBLOCK:
+			n := n.(*ir.BlockStmt)
 			deadcodeslice(n.PtrList())
 		case ir.OCASE:
+			n := n.(*ir.CaseStmt)
 			deadcodeslice(n.PtrBody())
 		case ir.OFOR:
+			n := n.(*ir.ForStmt)
 			deadcodeslice(n.PtrBody())
 		case ir.OIF:
+			n := n.(*ir.IfStmt)
 			deadcodeslice(n.PtrBody())
 			deadcodeslice(n.PtrRlist())
 		case ir.ORANGE:
+			n := n.(*ir.RangeStmt)
 			deadcodeslice(n.PtrBody())
 		case ir.OSELECT:
+			n := n.(*ir.SelectStmt)
 			deadcodeslice(n.PtrList())
 		case ir.OSWITCH:
+			n := n.(*ir.SwitchStmt)
 			deadcodeslice(n.PtrList())
 		}
 
@@ -4141,6 +4213,7 @@ func deadcodeexpr(n ir.Node) ir.Node {
 	// producing a constant 'if' condition.
 	switch n.Op() {
 	case ir.OANDAND:
+		n := n.(*ir.LogicalExpr)
 		n.SetLeft(deadcodeexpr(n.Left()))
 		n.SetRight(deadcodeexpr(n.Right()))
 		if ir.IsConst(n.Left(), constant.Bool) {
@@ -4151,6 +4224,7 @@ func deadcodeexpr(n ir.Node) ir.Node {
 			}
 		}
 	case ir.OOROR:
+		n := n.(*ir.LogicalExpr)
 		n.SetLeft(deadcodeexpr(n.Left()))
 		n.SetRight(deadcodeexpr(n.Right()))
 		if ir.IsConst(n.Left(), constant.Bool) {
@@ -4206,6 +4280,7 @@ func methodExprFunc(n ir.Node) *types.Field {
 	case ir.OMETHEXPR:
 		return n.(*ir.MethodExpr).Method
 	case ir.OCALLPART:
+		n := n.(*ir.CallPartExpr)
 		return callpartMethod(n)
 	}
 	base.Fatalf("unexpected node: %v (%v)", n, n.Op())
diff --git a/src/cmd/compile/internal/gc/unsafe.go b/src/cmd/compile/internal/gc/unsafe.go
index 02dd302975..eeedea396e 100644
--- a/src/cmd/compile/internal/gc/unsafe.go
+++ b/src/cmd/compile/internal/gc/unsafe.go
@@ -13,6 +13,7 @@ import (
 func evalunsafe(n ir.Node) int64 {
 	switch n.Op() {
 	case ir.OALIGNOF, ir.OSIZEOF:
+		n := n.(*ir.UnaryExpr)
 		n.SetLeft(typecheck(n.Left(), ctxExpr))
 		n.SetLeft(defaultlit(n.Left(), nil))
 		tr := n.Left().Type()
@@ -27,6 +28,7 @@ func evalunsafe(n ir.Node) int64 {
 
 	case ir.OOFFSETOF:
 		// must be a selector.
+		n := n.(*ir.UnaryExpr)
 		if n.Left().Op() != ir.OXDOT {
 			base.Errorf("invalid expression %v", n)
 			return 0
@@ -64,12 +66,14 @@ func evalunsafe(n ir.Node) int64 {
 				// For Offsetof(s.f), s may itself be a pointer,
 				// but accessing f must not otherwise involve
 				// indirection via embedded pointer types.
+				r := r.(*ir.SelectorExpr)
 				if r.Left() != sbase {
 					base.Errorf("invalid expression %v: selector implies indirection of embedded %v", n, r.Left())
 					return 0
 				}
 				fallthrough
 			case ir.ODOT:
+				r := r.(*ir.SelectorExpr)
 				v += r.Offset()
 				next = r.Left()
 			default:
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 17269746e6..91b7a184cf 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -127,6 +127,7 @@ func walkstmt(n ir.Node) ir.Node {
 	switch n.Op() {
 	default:
 		if n.Op() == ir.ONAME {
+			n := n.(*ir.Name)
 			base.Errorf("%v is not a top level statement", n.Sym())
 		} else {
 			base.Errorf("%v is not a top level statement", n.Op())
@@ -181,6 +182,7 @@ func walkstmt(n ir.Node) ir.Node {
 	// special case for a receive where we throw away
 	// the value received.
 	case ir.ORECV:
+		n := n.(*ir.UnaryExpr)
 		if n.Typecheck() == 0 {
 			base.Fatalf("missing typecheck: %+v", n)
 		}
@@ -205,6 +207,7 @@ func walkstmt(n ir.Node) ir.Node {
 		return n
 
 	case ir.ODCL:
+		n := n.(*ir.Decl)
 		v := n.Left().(*ir.Name)
 		if v.Class() == ir.PAUTOHEAP {
 			if base.Flag.CompilingRuntime {
@@ -217,6 +220,7 @@ func walkstmt(n ir.Node) ir.Node {
 		return n
 
 	case ir.OBLOCK:
+		n := n.(*ir.BlockStmt)
 		walkstmtlist(n.List().Slice())
 		return n
 
@@ -225,6 +229,7 @@ func walkstmt(n ir.Node) ir.Node {
 		panic("unreachable")
 
 	case ir.ODEFER:
+		n := n.(*ir.GoDeferStmt)
 		Curfn.SetHasDefer(true)
 		Curfn.NumDefers++
 		if Curfn.NumDefers > maxOpenDefers {
@@ -240,6 +245,7 @@ func walkstmt(n ir.Node) ir.Node {
 		}
 		fallthrough
 	case ir.OGO:
+		n := n.(*ir.GoDeferStmt)
 		var init ir.Nodes
 		switch call := n.Left(); call.Op() {
 		case ir.OPRINT, ir.OPRINTN:
@@ -276,6 +282,7 @@ func walkstmt(n ir.Node) ir.Node {
 		return n
 
 	case ir.OFOR, ir.OFORUNTIL:
+		n := n.(*ir.ForStmt)
 		if n.Left() != nil {
 			walkstmtlist(n.Left().Init().Slice())
 			init := n.Left().Init()
@@ -292,12 +299,14 @@ func walkstmt(n ir.Node) ir.Node {
 		return n
 
 	case ir.OIF:
+		n := n.(*ir.IfStmt)
 		n.SetLeft(walkexpr(n.Left(), n.PtrInit()))
 		walkstmtlist(n.Body().Slice())
 		walkstmtlist(n.Rlist().Slice())
 		return n
 
 	case ir.ORETURN:
+		n := n.(*ir.ReturnStmt)
 		Curfn.NumReturns++
 		if n.List().Len() == 0 {
 			return n
@@ -351,9 +360,11 @@ func walkstmt(n ir.Node) ir.Node {
 		return n
 
 	case ir.ORETJMP:
+		n := n.(*ir.BranchStmt)
 		return n
 
 	case ir.OINLMARK:
+		n := n.(*ir.InlineMarkStmt)
 		return n
 
 	case ir.OSELECT:
@@ -489,6 +500,7 @@ func walkexpr(n ir.Node, init *ir.Nodes) ir.Node {
 	}
 
 	if n.Op() == ir.ONAME && n.(*ir.Name).Class() == ir.PAUTOHEAP {
+		n := n.(*ir.Name)
 		nn := ir.NewStarExpr(base.Pos, n.Name().Heapaddr)
 		nn.Left().MarkNonNil()
 		return walkexpr(typecheck(nn, ctxExpr), init)
@@ -543,22 +555,27 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return n
 
 	case ir.ONOT, ir.ONEG, ir.OPLUS, ir.OBITNOT, ir.OREAL, ir.OIMAG, ir.OSPTR, ir.OITAB, ir.OIDATA:
+		n := n.(*ir.UnaryExpr)
 		n.SetLeft(walkexpr(n.Left(), init))
 		return n
 
 	case ir.ODOTMETH, ir.ODOTINTER:
+		n := n.(*ir.SelectorExpr)
 		n.SetLeft(walkexpr(n.Left(), init))
 		return n
 
 	case ir.OADDR:
+		n := n.(*ir.AddrExpr)
 		n.SetLeft(walkexpr(n.Left(), init))
 		return n
 
 	case ir.ODEREF:
+		n := n.(*ir.StarExpr)
 		n.SetLeft(walkexpr(n.Left(), init))
 		return n
 
 	case ir.OEFACE, ir.OAND, ir.OANDNOT, ir.OSUB, ir.OMUL, ir.OADD, ir.OOR, ir.OXOR, ir.OLSH, ir.ORSH:
+		n := n.(*ir.BinaryExpr)
 		n.SetLeft(walkexpr(n.Left(), init))
 		n.SetRight(walkexpr(n.Right(), init))
 		return n
@@ -570,6 +587,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return n
 
 	case ir.ODOTTYPE, ir.ODOTTYPE2:
+		n := n.(*ir.TypeAssertExpr)
 		n.SetLeft(walkexpr(n.Left(), init))
 		// Set up interface type addresses for back end.
 		n.SetRight(typename(n.Type()))
@@ -582,6 +600,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return n
 
 	case ir.OLEN, ir.OCAP:
+		n := n.(*ir.UnaryExpr)
 		if isRuneCount(n) {
 			// Replace len([]rune(string)) with runtime.countrunes(string).
 			return mkcall("countrunes", n.Type(), init, conv(n.Left().(*ir.ConvExpr).Left(), types.Types[types.TSTRING]))
@@ -605,6 +624,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return n
 
 	case ir.OCOMPLEX:
+		n := n.(*ir.BinaryExpr)
 		n.SetLeft(walkexpr(n.Left(), init))
 		n.SetRight(walkexpr(n.Right(), init))
 		return n
@@ -614,6 +634,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return walkcompare(n, init)
 
 	case ir.OANDAND, ir.OOROR:
+		n := n.(*ir.LogicalExpr)
 		n.SetLeft(walkexpr(n.Left(), init))
 
 		// cannot put side effects from n.Right on init,
@@ -629,9 +650,11 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return walkprint(n.(*ir.CallExpr), init)
 
 	case ir.OPANIC:
+		n := n.(*ir.UnaryExpr)
 		return mkcall("gopanic", nil, init, n.Left())
 
 	case ir.ORECOVER:
+		n := n.(*ir.CallExpr)
 		return mkcall("gorecover", n.Type(), init, nodAddr(nodfp))
 
 	case ir.OCLOSUREREAD, ir.OCFUNC:
@@ -674,8 +697,10 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		var left, right ir.Node
 		switch n.Op() {
 		case ir.OAS:
+			n := n.(*ir.AssignStmt)
 			left, right = n.Left(), n.Right()
 		case ir.OASOP:
+			n := n.(*ir.AssignOpStmt)
 			left, right = n.Left(), n.Right()
 		}
 
@@ -683,6 +708,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		// the mapassign call.
 		var mapAppend *ir.CallExpr
 		if left.Op() == ir.OINDEXMAP && right.Op() == ir.OAPPEND {
+			left := left.(*ir.IndexExpr)
 			mapAppend = right.(*ir.CallExpr)
 			if !samesafeexpr(left, mapAppend.List().First()) {
 				base.Fatalf("not same expressions: %v != %v", left, mapAppend.List().First())
@@ -764,6 +790,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return as
 
 	case ir.OAS2:
+		n := n.(*ir.AssignListStmt)
 		init.AppendNodes(n.PtrInit())
 		walkexprlistsafe(n.List().Slice(), init)
 		walkexprlistsafe(n.Rlist().Slice(), init)
@@ -771,6 +798,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 	// a,b,... = fn()
 	case ir.OAS2FUNC:
+		n := n.(*ir.AssignListStmt)
 		init.AppendNodes(n.PtrInit())
 
 		r := n.Rlist().First()
@@ -789,6 +817,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 	// x, y = <-c
 	// order.stmt made sure x is addressable or blank.
 	case ir.OAS2RECV:
+		n := n.(*ir.AssignListStmt)
 		init.AppendNodes(n.PtrInit())
 
 		r := n.Rlist().First().(*ir.UnaryExpr) // recv
@@ -807,6 +836,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 	// a,b = m[i]
 	case ir.OAS2MAPR:
+		n := n.(*ir.AssignListStmt)
 		init.AppendNodes(n.PtrInit())
 
 		r := n.Rlist().First().(*ir.IndexExpr)
@@ -868,6 +898,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return walkexpr(typecheck(as, ctxStmt), init)
 
 	case ir.ODELETE:
+		n := n.(*ir.CallExpr)
 		init.AppendNodes(n.PtrInit())
 		map_ := n.List().First()
 		key := n.List().Second()
@@ -883,11 +914,13 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return mkcall1(mapfndel(mapdelete[fast], t), nil, init, typename(t), map_, key)
 
 	case ir.OAS2DOTTYPE:
+		n := n.(*ir.AssignListStmt)
 		walkexprlistsafe(n.List().Slice(), init)
 		n.PtrRlist().SetIndex(0, walkexpr(n.Rlist().First(), init))
 		return n
 
 	case ir.OCONVIFACE:
+		n := n.(*ir.ConvExpr)
 		n.SetLeft(walkexpr(n.Left(), init))
 
 		fromType := n.Left().Type()
@@ -1061,6 +1094,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return conv(mkcall(fn, types.Types[result], init, conv(n.Left(), types.Types[param])), n.Type())
 
 	case ir.ODIV, ir.OMOD:
+		n := n.(*ir.BinaryExpr)
 		n.SetLeft(walkexpr(n.Left(), init))
 		n.SetRight(walkexpr(n.Right(), init))
 
@@ -1120,6 +1154,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return n
 
 	case ir.OINDEX:
+		n := n.(*ir.IndexExpr)
 		n.SetLeft(walkexpr(n.Left(), init))
 
 		// save the original node for bounds checking elision.
@@ -1164,6 +1199,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 	case ir.OINDEXMAP:
 		// Replace m[k] with *map{access1,assign}(maptype, m, &k)
+		n := n.(*ir.IndexExpr)
 		n.SetLeft(walkexpr(n.Left(), init))
 		n.SetRight(walkexpr(n.Right(), init))
 		map_ := n.Left()
@@ -1207,6 +1243,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		panic("unreachable")
 
 	case ir.OSLICEHEADER:
+		n := n.(*ir.SliceHeaderExpr)
 		n.SetLeft(walkexpr(n.Left(), init))
 		n.List().SetFirst(walkexpr(n.List().First(), init))
 		n.List().SetSecond(walkexpr(n.List().Second(), init))
@@ -1251,6 +1288,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return reduceSlice(n)
 
 	case ir.ONEW:
+		n := n.(*ir.UnaryExpr)
 		if n.Type().Elem().NotInHeap() {
 			base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", n.Type().Elem())
 		}
@@ -1277,6 +1315,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 	case ir.OCLOSE:
 		// cannot use chanfn - closechan takes any, not chan any
+		n := n.(*ir.UnaryExpr)
 		fn := syslook("closechan")
 		fn = substArgTypes(fn, n.Left().Type())
 		return mkcall1(fn, nil, init, n.Left())
@@ -1284,6 +1323,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 	case ir.OMAKECHAN:
 		// When size fits into int, use makechan instead of
 		// makechan64, which is faster and shorter on 32 bit platforms.
+		n := n.(*ir.MakeExpr)
 		size := n.Left()
 		fnname := "makechan64"
 		argtype := types.Types[types.TINT64]
@@ -1299,6 +1339,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return mkcall1(chanfn(fnname, 1, n.Type()), n.Type(), init, typename(n.Type()), conv(size, argtype))
 
 	case ir.OMAKEMAP:
+		n := n.(*ir.MakeExpr)
 		t := n.Type()
 		hmapType := hmap(t)
 		hint := n.Left()
@@ -1400,6 +1441,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return mkcall1(fn, n.Type(), init, typename(n.Type()), conv(hint, argtype), h)
 
 	case ir.OMAKESLICE:
+		n := n.(*ir.MakeExpr)
 		l := n.Left()
 		r := n.Right()
 		if r == nil {
@@ -1471,6 +1513,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return walkexpr(typecheck(m, ctxExpr), init)
 
 	case ir.OMAKESLICECOPY:
+		n := n.(*ir.MakeExpr)
 		if n.Esc() == EscNone {
 			base.Fatalf("OMAKESLICECOPY with EscNone: %v", n)
 		}
@@ -1525,6 +1568,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return walkexpr(typecheck(s, ctxExpr), init)
 
 	case ir.ORUNESTR:
+		n := n.(*ir.ConvExpr)
 		a := nodnil()
 		if n.Esc() == EscNone {
 			t := types.NewArray(types.Types[types.TUINT8], 4)
@@ -1534,6 +1578,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return mkcall("intstring", n.Type(), init, a, conv(n.Left(), types.Types[types.TINT64]))
 
 	case ir.OBYTES2STR, ir.ORUNES2STR:
+		n := n.(*ir.ConvExpr)
 		a := nodnil()
 		if n.Esc() == EscNone {
 			// Create temporary buffer for string on stack.
@@ -1550,6 +1595,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return mkcall("slicebytetostring", n.Type(), init, a, ptr, len)
 
 	case ir.OBYTES2STRTMP:
+		n := n.(*ir.ConvExpr)
 		n.SetLeft(walkexpr(n.Left(), init))
 		if !instrumenting {
 			// Let the backend handle OBYTES2STRTMP directly
@@ -1562,6 +1608,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return mkcall("slicebytetostringtmp", n.Type(), init, ptr, len)
 
 	case ir.OSTR2BYTES:
+		n := n.(*ir.ConvExpr)
 		s := n.Left()
 		if ir.IsConst(s, constant.String) {
 			sc := ir.StringVal(s)
@@ -1607,10 +1654,12 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		// that know that the slice won't be mutated.
 		// The only such case today is:
 		// for i, c := range []byte(string)
+		n := n.(*ir.ConvExpr)
 		n.SetLeft(walkexpr(n.Left(), init))
 		return n
 
 	case ir.OSTR2RUNES:
+		n := n.(*ir.ConvExpr)
 		a := nodnil()
 		if n.Esc() == EscNone {
 			// Create temporary buffer for slice on stack.
@@ -1634,6 +1683,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return var_
 
 	case ir.OSEND:
+		n := n.(*ir.SendStmt)
 		n1 := n.Right()
 		n1 = assignconv(n1, n.Left().Type().Elem(), "chan send")
 		n1 = walkexpr(n1, init)
@@ -2100,8 +2150,10 @@ func isReflectHeaderDataField(l ir.Node) bool {
 	var tsym *types.Sym
 	switch l.Op() {
 	case ir.ODOT:
+		l := l.(*ir.SelectorExpr)
 		tsym = l.Left().Type().Sym()
 	case ir.ODOTPTR:
+		l := l.(*ir.SelectorExpr)
 		tsym = l.Left().Type().Elem().Sym()
 	default:
 		return false
@@ -2167,12 +2219,15 @@ func reorder3(all []*ir.AssignStmt) []ir.Node {
 		for {
 			switch ll := l; ll.Op() {
 			case ir.ODOT:
+				ll := ll.(*ir.SelectorExpr)
 				l = ll.Left()
 				continue
 			case ir.OPAREN:
+				ll := ll.(*ir.ParenExpr)
 				l = ll.Left()
 				continue
 			case ir.OINDEX:
+				ll := ll.(*ir.IndexExpr)
 				if ll.Left().Type().IsArray() {
 					ll.SetRight(reorder3save(ll.Right(), all, i, &early))
 					l = ll.Left()
@@ -2190,6 +2245,7 @@ func reorder3(all []*ir.AssignStmt) []ir.Node {
 			break
 
 		case ir.OINDEX, ir.OINDEXMAP:
+			l := l.(*ir.IndexExpr)
 			l.SetLeft(reorder3save(l.Left(), all, i, &early))
 			l.SetRight(reorder3save(l.Right(), all, i, &early))
 			if l.Op() == ir.OINDEXMAP {
@@ -2197,8 +2253,10 @@ func reorder3(all []*ir.AssignStmt) []ir.Node {
 			}
 
 		case ir.ODEREF:
+			l := l.(*ir.StarExpr)
 			l.SetLeft(reorder3save(l.Left(), all, i, &early))
 		case ir.ODOTPTR:
+			l := l.(*ir.SelectorExpr)
 			l.SetLeft(reorder3save(l.Left(), all, i, &early))
 		}
 
@@ -2238,15 +2296,19 @@ func outervalue(n ir.Node) ir.Node {
 		case ir.OXDOT:
 			base.Fatalf("OXDOT in walk")
 		case ir.ODOT:
+			nn := nn.(*ir.SelectorExpr)
 			n = nn.Left()
 			continue
 		case ir.OPAREN:
+			nn := nn.(*ir.ParenExpr)
 			n = nn.Left()
 			continue
 		case ir.OCONVNOP:
+			nn := nn.(*ir.ConvExpr)
 			n = nn.Left()
 			continue
 		case ir.OINDEX:
+			nn := nn.(*ir.IndexExpr)
 			if nn.Left().Type() != nil && nn.Left().Type().IsArray() {
 				n = nn.Left()
 				continue
@@ -2338,6 +2400,7 @@ func anyAddrTaken(n ir.Node) bool {
 	return ir.Any(n, func(n ir.Node) bool {
 		switch n.Op() {
 		case ir.ONAME:
+			n := n.(*ir.Name)
 			return n.Class() == ir.PEXTERN || n.Class() == ir.PAUTOHEAP || n.Name().Addrtaken()
 
 		case ir.ODOT: // but not ODOTPTR - should have been handled in aliased.
@@ -2420,6 +2483,7 @@ func refersToCommonName(l ir.Node, r ir.Node) bool {
 	}
 	doL = func(l ir.Node) error {
 		if l.Op() == ir.ONAME {
+			l := l.(*ir.Name)
 			targetL = l.Name()
 			if doR(r) == stop {
 				return stop
@@ -3635,6 +3699,7 @@ func bounded(n ir.Node, max int64) bool {
 
 	switch n.Op() {
 	case ir.OAND, ir.OANDNOT:
+		n := n.(*ir.BinaryExpr)
 		v := int64(-1)
 		switch {
 		case smallintconst(n.Left()):
@@ -3653,6 +3718,7 @@ func bounded(n ir.Node, max int64) bool {
 		}
 
 	case ir.OMOD:
+		n := n.(*ir.BinaryExpr)
 		if !sign && smallintconst(n.Right()) {
 			v := ir.Int64Val(n.Right())
 			if 0 <= v && v <= max {
@@ -3661,6 +3727,7 @@ func bounded(n ir.Node, max int64) bool {
 		}
 
 	case ir.ODIV:
+		n := n.(*ir.BinaryExpr)
 		if !sign && smallintconst(n.Right()) {
 			v := ir.Int64Val(n.Right())
 			for bits > 0 && v >= 2 {
@@ -3670,6 +3737,7 @@ func bounded(n ir.Node, max int64) bool {
 		}
 
 	case ir.ORSH:
+		n := n.(*ir.BinaryExpr)
 		if !sign && smallintconst(n.Right()) {
 			v := ir.Int64Val(n.Right())
 			if v > int64(bits) {
@@ -3849,6 +3917,7 @@ func anySideEffects(n ir.Node) bool {
 
 		// Only possible side effect is division by zero.
 		case ir.ODIV, ir.OMOD:
+			n := n.(*ir.BinaryExpr)
 			if n.Right().Op() != ir.OLITERAL || constant.Sign(n.Right().Val()) == 0 {
 				return true
 			}
@@ -3856,6 +3925,7 @@ func anySideEffects(n ir.Node) bool {
 		// Only possible side effect is panic on invalid size,
 		// but many makechan and makemap use size zero, which is definitely OK.
 		case ir.OMAKECHAN, ir.OMAKEMAP:
+			n := n.(*ir.MakeExpr)
 			if !ir.IsConst(n.Left(), constant.Int) || constant.Sign(n.Left().Val()) != 0 {
 				return true
 			}
@@ -3901,6 +3971,7 @@ func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	if !isBuiltinCall && n.IsDDD() {
 		last := n.List().Len() - 1
 		if va := n.List().Index(last); va.Op() == ir.OSLICELIT {
+			va := va.(*ir.CompLitExpr)
 			n.PtrList().Set(append(n.List().Slice()[:last], va.List().Slice()...))
 			n.SetIsDDD(false)
 		}
@@ -4051,11 +4122,14 @@ func walkCheckPtrArithmetic(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 	walk = func(n ir.Node) {
 		switch n.Op() {
 		case ir.OADD:
+			n := n.(*ir.BinaryExpr)
 			walk(n.Left())
 			walk(n.Right())
 		case ir.OSUB, ir.OANDNOT:
+			n := n.(*ir.BinaryExpr)
 			walk(n.Left())
 		case ir.OCONVNOP:
+			n := n.(*ir.ConvExpr)
 			if n.Left().Type().IsUnsafePtr() {
 				n.SetLeft(cheapexpr(n.Left(), init))
 				originals = append(originals, convnop(n.Left(), types.Types[types.TUNSAFEPTR]))
diff --git a/src/cmd/compile/internal/ir/mini.go b/src/cmd/compile/internal/ir/mini.go
index 7a945c3690..53a63afe9b 100644
--- a/src/cmd/compile/internal/ir/mini.go
+++ b/src/cmd/compile/internal/ir/mini.go
@@ -35,11 +35,6 @@ type miniNode struct {
 	esc  uint16
 }
 
-func (n *miniNode) Format(s fmt.State, verb rune)        { panic(1) }
-func (n *miniNode) copy() Node                           { panic(1) }
-func (n *miniNode) doChildren(do func(Node) error) error { panic(1) }
-func (n *miniNode) editChildren(edit func(Node) Node)    { panic(1) }
-
 // posOr returns pos if known, or else n.pos.
 // For use in DeepCopy.
 func (n *miniNode) posOr(pos src.XPos) src.XPos {
@@ -85,106 +80,27 @@ func (n *miniNode) SetDiag(x bool) { n.bits.set(miniDiag, x) }
 
 // Empty, immutable graph structure.
 
-func (n *miniNode) Left() Node       { return nil }
-func (n *miniNode) Right() Node      { return nil }
-func (n *miniNode) Init() Nodes      { return Nodes{} }
-func (n *miniNode) PtrInit() *Nodes  { return &immutableEmptyNodes }
-func (n *miniNode) Body() Nodes      { return Nodes{} }
-func (n *miniNode) PtrBody() *Nodes  { return &immutableEmptyNodes }
-func (n *miniNode) List() Nodes      { return Nodes{} }
-func (n *miniNode) PtrList() *Nodes  { return &immutableEmptyNodes }
-func (n *miniNode) Rlist() Nodes     { return Nodes{} }
-func (n *miniNode) PtrRlist() *Nodes { return &immutableEmptyNodes }
-func (n *miniNode) SetLeft(x Node) {
-	if x != nil {
-		panic(n.no("SetLeft"))
-	}
-}
-func (n *miniNode) SetRight(x Node) {
-	if x != nil {
-		panic(n.no("SetRight"))
-	}
-}
+func (n *miniNode) Init() Nodes     { return Nodes{} }
+func (n *miniNode) PtrInit() *Nodes { return &immutableEmptyNodes }
 func (n *miniNode) SetInit(x Nodes) {
 	if x != nil {
 		panic(n.no("SetInit"))
 	}
 }
-func (n *miniNode) SetBody(x Nodes) {
-	if x != nil {
-		panic(n.no("SetBody"))
-	}
-}
-func (n *miniNode) SetList(x Nodes) {
-	if x != nil {
-		panic(n.no("SetList"))
-	}
-}
-func (n *miniNode) SetRlist(x Nodes) {
-	if x != nil {
-		panic(n.no("SetRlist"))
-	}
-}
 
 // Additional functionality unavailable.
 
 func (n *miniNode) no(name string) string { return "cannot " + name + " on " + n.op.String() }
 
-func (n *miniNode) SetOp(Op)            { panic(n.no("SetOp")) }
-func (n *miniNode) SubOp() Op           { panic(n.no("SubOp")) }
-func (n *miniNode) SetSubOp(Op)         { panic(n.no("SetSubOp")) }
-func (n *miniNode) Type() *types.Type   { return nil }
-func (n *miniNode) SetType(*types.Type) { panic(n.no("SetType")) }
-func (n *miniNode) Func() *Func         { return nil }
-func (n *miniNode) Name() *Name         { return nil }
-func (n *miniNode) Sym() *types.Sym     { return nil }
-func (n *miniNode) SetSym(*types.Sym)   { panic(n.no("SetSym")) }
-func (n *miniNode) Offset() int64       { return types.BADWIDTH }
-func (n *miniNode) SetOffset(x int64)   { panic(n.no("SetOffset")) }
-func (n *miniNode) Class() Class        { return Pxxx }
-func (n *miniNode) SetClass(Class)      { panic(n.no("SetClass")) }
-func (n *miniNode) Likely() bool        { panic(n.no("Likely")) }
-func (n *miniNode) SetLikely(bool)      { panic(n.no("SetLikely")) }
-func (n *miniNode) SliceBounds() (low, high, max Node) {
-	panic(n.no("SliceBounds"))
-}
-func (n *miniNode) SetSliceBounds(low, high, max Node) {
-	panic(n.no("SetSliceBounds"))
-}
-func (n *miniNode) Iota() int64               { panic(n.no("Iota")) }
-func (n *miniNode) SetIota(int64)             { panic(n.no("SetIota")) }
-func (n *miniNode) Colas() bool               { return false }
-func (n *miniNode) SetColas(bool)             { panic(n.no("SetColas")) }
-func (n *miniNode) NoInline() bool            { panic(n.no("NoInline")) }
-func (n *miniNode) SetNoInline(bool)          { panic(n.no("SetNoInline")) }
-func (n *miniNode) Transient() bool           { panic(n.no("Transient")) }
-func (n *miniNode) SetTransient(bool)         { panic(n.no("SetTransient")) }
-func (n *miniNode) Implicit() bool            { return false }
-func (n *miniNode) SetImplicit(bool)          { panic(n.no("SetImplicit")) }
-func (n *miniNode) IsDDD() bool               { return false }
-func (n *miniNode) SetIsDDD(bool)             { panic(n.no("SetIsDDD")) }
-func (n *miniNode) Embedded() bool            { return false }
-func (n *miniNode) SetEmbedded(bool)          { panic(n.no("SetEmbedded")) }
-func (n *miniNode) IndexMapLValue() bool      { panic(n.no("IndexMapLValue")) }
-func (n *miniNode) SetIndexMapLValue(bool)    { panic(n.no("SetIndexMapLValue")) }
-func (n *miniNode) ResetAux()                 { panic(n.no("ResetAux")) }
-func (n *miniNode) HasBreak() bool            { panic(n.no("HasBreak")) }
-func (n *miniNode) SetHasBreak(bool)          { panic(n.no("SetHasBreak")) }
-func (n *miniNode) Val() constant.Value       { panic(n.no("Val")) }
-func (n *miniNode) SetVal(v constant.Value)   { panic(n.no("SetVal")) }
-func (n *miniNode) Int64Val() int64           { panic(n.no("Int64Val")) }
-func (n *miniNode) Uint64Val() uint64         { panic(n.no("Uint64Val")) }
-func (n *miniNode) CanInt64() bool            { panic(n.no("CanInt64")) }
-func (n *miniNode) BoolVal() bool             { panic(n.no("BoolVal")) }
-func (n *miniNode) StringVal() string         { panic(n.no("StringVal")) }
-func (n *miniNode) HasCall() bool             { return false }
-func (n *miniNode) SetHasCall(bool)           { panic(n.no("SetHasCall")) }
-func (n *miniNode) NonNil() bool              { return false }
-func (n *miniNode) MarkNonNil()               { panic(n.no("MarkNonNil")) }
-func (n *miniNode) Bounded() bool             { return false }
-func (n *miniNode) SetBounded(bool)           { panic(n.no("SetBounded")) }
-func (n *miniNode) Opt() interface{}          { return nil }
-func (n *miniNode) SetOpt(interface{})        { panic(n.no("SetOpt")) }
-func (n *miniNode) MarkReadonly()             { panic(n.no("MarkReadonly")) }
-func (n *miniNode) TChanDir() types.ChanDir   { panic(n.no("TChanDir")) }
-func (n *miniNode) SetTChanDir(types.ChanDir) { panic(n.no("SetTChanDir")) }
+func (n *miniNode) Type() *types.Type       { return nil }
+func (n *miniNode) SetType(*types.Type)     { panic(n.no("SetType")) }
+func (n *miniNode) Name() *Name             { return nil }
+func (n *miniNode) Sym() *types.Sym         { return nil }
+func (n *miniNode) Val() constant.Value     { panic(n.no("Val")) }
+func (n *miniNode) SetVal(v constant.Value) { panic(n.no("SetVal")) }
+func (n *miniNode) HasCall() bool           { return false }
+func (n *miniNode) SetHasCall(bool)         { panic(n.no("SetHasCall")) }
+func (n *miniNode) NonNil() bool            { return false }
+func (n *miniNode) MarkNonNil()             { panic(n.no("MarkNonNil")) }
+func (n *miniNode) Opt() interface{}        { return nil }
+func (n *miniNode) SetOpt(interface{})      { panic(n.no("SetOpt")) }
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 1679313c86..86ef600f26 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -33,59 +33,15 @@ type Node interface {
 
 	// Abstract graph structure, for generic traversals.
 	Op() Op
-	SetOp(x Op)
-	SubOp() Op
-	SetSubOp(x Op)
-	Left() Node
-	SetLeft(x Node)
-	Right() Node
-	SetRight(x Node)
 	Init() Nodes
 	PtrInit() *Nodes
 	SetInit(x Nodes)
-	Body() Nodes
-	PtrBody() *Nodes
-	SetBody(x Nodes)
-	List() Nodes
-	SetList(x Nodes)
-	PtrList() *Nodes
-	Rlist() Nodes
-	SetRlist(x Nodes)
-	PtrRlist() *Nodes
 
 	// Fields specific to certain Ops only.
 	Type() *types.Type
 	SetType(t *types.Type)
-	Func() *Func
 	Name() *Name
 	Sym() *types.Sym
-	SetSym(x *types.Sym)
-	Offset() int64
-	SetOffset(x int64)
-	Class() Class
-	SetClass(x Class)
-	Likely() bool
-	SetLikely(x bool)
-	SliceBounds() (low, high, max Node)
-	SetSliceBounds(low, high, max Node)
-	Iota() int64
-	SetIota(x int64)
-	Colas() bool
-	SetColas(x bool)
-	NoInline() bool
-	SetNoInline(x bool)
-	Transient() bool
-	SetTransient(x bool)
-	Implicit() bool
-	SetImplicit(x bool)
-	IsDDD() bool
-	SetIsDDD(x bool)
-	IndexMapLValue() bool
-	SetIndexMapLValue(x bool)
-	ResetAux()
-	HasBreak() bool
-	SetHasBreak(x bool)
-	MarkReadonly()
 	Val() constant.Value
 	SetVal(v constant.Value)
 
@@ -98,8 +54,6 @@ type Node interface {
 	SetOpt(x interface{})
 	Diag() bool
 	SetDiag(x bool)
-	Bounded() bool
-	SetBounded(x bool)
 	Typecheck() uint8
 	SetTypecheck(x uint8)
 	NonNil() bool
-- 
GitLab


From f9d373720e76a45cf2d0cb4507fe49dae33afd25 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 23 Dec 2020 00:02:08 -0500
Subject: [PATCH 0298/2400] [dev.regabi] cmd/compile: remove Left, Right etc
 methods [generated]

Now that the generic graph structure methods - Left, Right, and so on -
have been removed from the Node interface, each implementation's uses
can be replaced with direct field access, using more specific names,
and the methods themselves can be deleted.

Passes buildall w/ toolstash -cmp.

[git-generate]

cd src/cmd/compile/internal/ir
rf '
	mv Func.iota Func.Iota_
	mv Name.fn Name.Func_
'

cd ../gc
rf '
ex . ../ir {
        import "cmd/compile/internal/ir"
        import "cmd/compile/internal/types"

        var ns ir.Nodes
        var b bool
        var i64 int64
        var n ir.Node
        var op ir.Op
        var sym *types.Sym
        var class ir.Class

        var decl *ir.Decl
        decl.Left()         -> decl.X
        decl.SetLeft(n)     -> decl.X = n

        var asl *ir.AssignListStmt
        asl.List()          -> asl.Lhs
        asl.PtrList()       -> &asl.Lhs
        asl.SetList(ns)     -> asl.Lhs = ns
        asl.Rlist()         -> asl.Rhs
        asl.PtrRlist()      -> &asl.Rhs
        asl.SetRlist(ns)    -> asl.Rhs = ns
        asl.Colas()         -> asl.Def
        asl.SetColas(b)     -> asl.Def = b

        var as *ir.AssignStmt
        as.Left()           -> as.X
        as.SetLeft(n)       -> as.X = n
        as.Right()          -> as.Y
        as.SetRight(n)      -> as.Y = n
        as.Colas()          -> as.Def
        as.SetColas(b)      -> as.Def = b

        var ao *ir.AssignOpStmt
        ao.Left()           -> ao.X
        ao.SetLeft(n)       -> ao.X = n
        ao.Right()          -> ao.Y
        ao.SetRight(n)      -> ao.Y = n
        ao.SubOp()          -> ao.AsOp
        ao.SetSubOp(op)     -> ao.AsOp = op
        ao.Implicit()       -> ao.IncDec
        ao.SetImplicit(b)   -> ao.IncDec = b

        var bl *ir.BlockStmt
        bl.List()           -> bl.List_
        bl.PtrList()        -> &bl.List_
        bl.SetList(ns)      -> bl.List_ = ns

        var br *ir.BranchStmt
        br.Sym()            -> br.Label
        br.SetSym(sym)      -> br.Label = sym

        var cas *ir.CaseStmt
        cas.List()          -> cas.List_
        cas.PtrList()       -> &cas.List_
        cas.SetList(ns)     -> cas.List_ = ns
        cas.Body()          -> cas.Body_
        cas.PtrBody()       -> &cas.Body_
        cas.SetBody(ns)     -> cas.Body_ = ns
        cas.Rlist()         -> cas.Vars
        cas.PtrRlist()      -> &cas.Vars
        cas.SetRlist(ns)    -> cas.Vars = ns
        cas.Left()          -> cas.Comm
        cas.SetLeft(n)      -> cas.Comm = n

        var fr *ir.ForStmt
        fr.Sym()            -> fr.Label
        fr.SetSym(sym)      -> fr.Label = sym
        fr.Left()           -> fr.Cond
        fr.SetLeft(n)       -> fr.Cond = n
        fr.Right()          -> fr.Post
        fr.SetRight(n)      -> fr.Post = n
        fr.Body()           -> fr.Body_
        fr.PtrBody()        -> &fr.Body_
        fr.SetBody(ns)      -> fr.Body_ = ns
        fr.List()           -> fr.Late
        fr.PtrList()        -> &fr.Late
        fr.SetList(ns)      -> fr.Late = ns
        fr.HasBreak()       -> fr.HasBreak_
        fr.SetHasBreak(b)   -> fr.HasBreak_ = b

        var gs *ir.GoDeferStmt
        gs.Left()           -> gs.Call
        gs.SetLeft(n)       -> gs.Call = n

        var ifs *ir.IfStmt
        ifs.Left()          -> ifs.Cond
        ifs.SetLeft(n)      -> ifs.Cond = n
        ifs.Body()          -> ifs.Body_
        ifs.PtrBody()       -> &ifs.Body_
        ifs.SetBody(ns)     -> ifs.Body_ = ns
        ifs.Rlist()         -> ifs.Else
        ifs.PtrRlist()      -> &ifs.Else
        ifs.SetRlist(ns)    -> ifs.Else = ns
        ifs.Likely()        -> ifs.Likely_
        ifs.SetLikely(b)    -> ifs.Likely_ = b

        var im *ir.InlineMarkStmt
        im.Offset()         -> im.Index
        im.SetOffset(i64)   -> im.Index = i64

        var lab *ir.LabelStmt
        lab.Sym()           -> lab.Label
        lab.SetSym(sym)     -> lab.Label = sym

        var rng *ir.RangeStmt
        rng.Sym()           -> rng.Label
        rng.SetSym(sym)     -> rng.Label = sym
        rng.Right()         -> rng.X
        rng.SetRight(n)     -> rng.X = n
        rng.Body()          -> rng.Body_
        rng.PtrBody()       -> &rng.Body_
        rng.SetBody(ns)     -> rng.Body_ = ns
        rng.List()          -> rng.Vars
        rng.PtrList()       -> &rng.Vars
        rng.SetList(ns)     -> rng.Vars = ns
        rng.HasBreak()      -> rng.HasBreak_
        rng.SetHasBreak(b)  -> rng.HasBreak_ = b
        rng.Colas()         -> rng.Def
        rng.SetColas(b)     -> rng.Def = b

        var ret *ir.ReturnStmt
        ret.List()          -> ret.Results
        ret.PtrList()       -> &ret.Results
        ret.SetList(ns)     -> ret.Results = ns

        var sel *ir.SelectStmt
        sel.List()          -> sel.Cases
        sel.PtrList()       -> &sel.Cases
        sel.SetList(ns)     -> sel.Cases = ns
        sel.Sym()           -> sel.Label
        sel.SetSym(sym)     -> sel.Label = sym
        sel.HasBreak()      -> sel.HasBreak_
        sel.SetHasBreak(b)  -> sel.HasBreak_ = b
        sel.Body()          -> sel.Compiled
        sel.PtrBody()       -> &sel.Compiled
        sel.SetBody(ns)     -> sel.Compiled = ns

        var send *ir.SendStmt
        send.Left()         -> send.Chan
        send.SetLeft(n)     -> send.Chan = n
        send.Right()        -> send.Value
        send.SetRight(n)    -> send.Value = n

        var sw *ir.SwitchStmt
        sw.Left()           -> sw.Tag
        sw.SetLeft(n)       -> sw.Tag = n
        sw.List()           -> sw.Cases
        sw.PtrList()        -> &sw.Cases
        sw.SetList(ns)      -> sw.Cases = ns
        sw.Body()           -> sw.Compiled
        sw.PtrBody()        -> &sw.Compiled
        sw.SetBody(ns)      -> sw.Compiled = ns
        sw.Sym()            -> sw.Label
        sw.SetSym(sym)      -> sw.Label = sym
        sw.HasBreak()       -> sw.HasBreak_
        sw.SetHasBreak(b)   -> sw.HasBreak_ = b

        var tg *ir.TypeSwitchGuard
        tg.Left()           -> tg.Tag
        tg.SetLeft(nil)     -> tg.Tag = nil
        tg.SetLeft(n)       -> tg.Tag = n.(*ir.Ident)
        tg.Right()          -> tg.X
        tg.SetRight(n)      -> tg.X = n

        var adds *ir.AddStringExpr
        adds.List()         -> adds.List_
        adds.PtrList()      -> &adds.List_
        adds.SetList(ns)    -> adds.List_ = ns

        var addr *ir.AddrExpr
        addr.Left()         -> addr.X
        addr.SetLeft(n)     -> addr.X = n
        addr.Right()        -> addr.Alloc
        addr.SetRight(n)    -> addr.Alloc = n

        var bin *ir.BinaryExpr
        bin.Left()          -> bin.X
        bin.SetLeft(n)      -> bin.X = n
        bin.Right()         -> bin.Y
        bin.SetRight(n)     -> bin.Y = n

        var log *ir.LogicalExpr
        log.Left()          -> log.X
        log.SetLeft(n)      -> log.X = n
        log.Right()         -> log.Y
        log.SetRight(n)     -> log.Y = n

        var call *ir.CallExpr
        call.Left()         -> call.X
        call.SetLeft(n)     -> call.X = n
        call.List()         -> call.Args
        call.PtrList()      -> &call.Args
        call.SetList(ns)    -> call.Args = ns
        call.Rlist()        -> call.Rargs
        call.PtrRlist()     -> &call.Rargs
        call.SetRlist(ns)   -> call.Rargs = ns
        call.IsDDD()        -> call.DDD
        call.SetIsDDD(b)    -> call.DDD = b
        call.NoInline()     -> call.NoInline_
        call.SetNoInline(b) -> call.NoInline_ = b
        call.Body()         -> call.Body_
        call.PtrBody()      -> &call.Body_
        call.SetBody(ns)    -> call.Body_ = ns

        var cp *ir.CallPartExpr
        cp.Func()           -> cp.Func_
        cp.Left()           -> cp.X
        cp.SetLeft(n)       -> cp.X = n
        cp.Sym()            -> cp.Method.Sym

        var clo *ir.ClosureExpr
        clo.Func()          -> clo.Func_

        var cr *ir.ClosureReadExpr
        cr.Offset()         -> cr.Offset_

        var cl *ir.CompLitExpr
        cl.Right()          -> cl.Ntype
        cl.SetRight(nil)    -> cl.Ntype = nil
        cl.SetRight(n)      -> cl.Ntype = ir.Node(n).(ir.Ntype)
        cl.List()           -> cl.List_
        cl.PtrList()        -> &cl.List_
        cl.SetList(ns)      -> cl.List_ = ns

        var conv *ir.ConvExpr
        conv.Left()         -> conv.X
        conv.SetLeft(n)     -> conv.X = n

        var ix *ir.IndexExpr
        ix.Left()           -> ix.X
        ix.SetLeft(n)       -> ix.X = n
        ix.Right()          -> ix.Index
        ix.SetRight(n)      -> ix.Index = n
        ix.IndexMapLValue() -> ix.Assigned
        ix.SetIndexMapLValue(b) -> ix.Assigned = b

        var kv *ir.KeyExpr
        kv.Left()           -> kv.Key
        kv.SetLeft(n)       -> kv.Key = n
        kv.Right()          -> kv.Value
        kv.SetRight(n)      -> kv.Value = n

        var sk *ir.StructKeyExpr
        sk.Sym()            -> sk.Field
        sk.SetSym(sym)      -> sk.Field = sym
        sk.Left()           -> sk.Value
        sk.SetLeft(n)       -> sk.Value = n
        sk.Offset()         -> sk.Offset_
        sk.SetOffset(i64)   -> sk.Offset_ = i64

        var ic *ir.InlinedCallExpr
        ic.Body()           -> ic.Body_
        ic.PtrBody()        -> &ic.Body_
        ic.SetBody(ns)      -> ic.Body_ = ns
        ic.Rlist()          -> ic.ReturnVars
        ic.PtrRlist()       -> &ic.ReturnVars
        ic.SetRlist(ns)     -> ic.ReturnVars = ns

        var mak *ir.MakeExpr
        mak.Left()          -> mak.Len
        mak.SetLeft(n)      -> mak.Len = n
        mak.Right()         -> mak.Cap
        mak.SetRight(n)     -> mak.Cap = n

        var par *ir.ParenExpr
        par.Left()          -> par.X
        par.SetLeft(n)      -> par.X = n

        var res *ir.ResultExpr
        res.Offset()        -> res.Offset_
        res.SetOffset(i64)  -> res.Offset_ = i64

        var dot *ir.SelectorExpr
        dot.Left()          -> dot.X
        dot.SetLeft(n)      -> dot.X = n
        dot.Sym()           -> dot.Sel
        dot.SetSym(sym)     -> dot.Sel = sym
        dot.Offset()        -> dot.Offset_
        dot.SetOffset(i64)  -> dot.Offset_ = i64

        var sl *ir.SliceExpr
        sl.Left()           -> sl.X
        sl.SetLeft(n)       -> sl.X = n
        sl.List()           -> sl.List_
        sl.PtrList()        -> &sl.List_
        sl.SetList(ns)      -> sl.List_ = ns

        var sh *ir.SliceHeaderExpr
        sh.Left()           -> sh.Ptr
        sh.SetLeft(n)       -> sh.Ptr = n
        sh.List()           -> sh.LenCap_
        sh.PtrList()        -> &sh.LenCap_
        sh.SetList(ns)      -> sh.LenCap_ = ns

        var st *ir.StarExpr
        st.Left()           -> st.X
        st.SetLeft(n)       -> st.X = n

        var ta *ir.TypeAssertExpr
        ta.Left()           -> ta.X
        ta.SetLeft(n)       -> ta.X = n
        ta.Right()          -> ta.Ntype
        ta.SetRight(n)    -> ta.Ntype = n
        ta.List()           -> ta.Itab
        ta.PtrList()        -> &ta.Itab
        ta.SetList(ns)      -> ta.Itab = ns

        var u *ir.UnaryExpr
        u.Left()            -> u.X
        u.SetLeft(n)        -> u.X = n

        var fn *ir.Func
        fn.Body()           -> fn.Body_
        fn.PtrBody()        -> &fn.Body_
        fn.SetBody(ns)      -> fn.Body_ = ns
        fn.Iota()           -> fn.Iota_
        fn.SetIota(i64)     -> fn.Iota_ = i64
        fn.Func()           -> fn

        var nam *ir.Name
        nam.SubOp()         -> nam.BuiltinOp
        nam.SetSubOp(op)    -> nam.BuiltinOp = op
        nam.Class()         -> nam.Class_
        nam.SetClass(class) -> nam.Class_ = class
        nam.Func()          -> nam.Func_
        nam.Offset()        -> nam.Offset_
        nam.SetOffset(i64)  -> nam.Offset_ = i64
}

ex . ../ir {
        import "cmd/compile/internal/ir"

        var n ir.Nodes

        (&n).Append         -> n.Append
        (&n).AppendNodes    -> n.AppendNodes
        (&n).MoveNodes      -> n.MoveNodes
        (&n).Prepend        -> n.Prepend
        (&n).Set            -> n.Set
        (&n).Set1           -> n.Set1
        (&n).Set2           -> n.Set2
        (&n).Set3           -> n.Set3

        var ntype ir.Ntype
        ir.Node(ntype).(ir.Ntype) -> ntype
}
'

cd ../ir
rf '
rm \
        Decl.Left Decl.SetLeft \
        AssignListStmt.List AssignListStmt.PtrList AssignListStmt.SetList \
        AssignListStmt.Rlist AssignListStmt.PtrRlist AssignListStmt.SetRlist \
        AssignListStmt.Colas AssignListStmt.SetColas \
        AssignStmt.Left AssignStmt.SetLeft \
        AssignStmt.Right AssignStmt.SetRight \
        AssignStmt.Colas AssignStmt.SetColas \
        AssignOpStmt.Left AssignOpStmt.SetLeft \
        AssignOpStmt.Right AssignOpStmt.SetRight \
        AssignOpStmt.SubOp AssignOpStmt.SetSubOp \
        AssignOpStmt.Implicit AssignOpStmt.SetImplicit \
        BlockStmt.List BlockStmt.PtrList BlockStmt.SetList \
        BranchStmt.SetSym \
        CaseStmt.List CaseStmt.PtrList CaseStmt.SetList \
        CaseStmt.Body CaseStmt.PtrBody CaseStmt.SetBody \
        CaseStmt.Rlist CaseStmt.PtrRlist CaseStmt.SetRlist \
        CaseStmt.Left CaseStmt.SetLeft \
        ForStmt.Left ForStmt.SetLeft \
        ForStmt.Right ForStmt.SetRight \
        ForStmt.Body ForStmt.PtrBody ForStmt.SetBody \
        ForStmt.List ForStmt.PtrList ForStmt.SetList \
        ForStmt.HasBreak ForStmt.SetHasBreak \
        ForStmt.Sym ForStmt.SetSym \
        GoDeferStmt.Left GoDeferStmt.SetLeft \
        IfStmt.Left IfStmt.SetLeft \
        IfStmt.Body IfStmt.PtrBody IfStmt.SetBody \
        IfStmt.Rlist IfStmt.PtrRlist IfStmt.SetRlist \
        IfStmt.Likely IfStmt.SetLikely \
        LabelStmt.SetSym \
        RangeStmt.Right RangeStmt.SetRight \
        RangeStmt.Body RangeStmt.PtrBody RangeStmt.SetBody \
        RangeStmt.List RangeStmt.PtrList RangeStmt.SetList \
        RangeStmt.HasBreak RangeStmt.SetHasBreak \
        RangeStmt.Colas RangeStmt.SetColas \
        RangeStmt.Sym RangeStmt.SetSym \
        ReturnStmt.List ReturnStmt.PtrList ReturnStmt.SetList \
        SelectStmt.List SelectStmt.PtrList SelectStmt.SetList \
        SelectStmt.HasBreak SelectStmt.SetHasBreak \
        SelectStmt.Body SelectStmt.PtrBody SelectStmt.SetBody \
        SelectStmt.Sym SelectStmt.SetSym \
        SendStmt.Left SendStmt.SetLeft \
        SendStmt.Right SendStmt.SetRight \
        SwitchStmt.Left SwitchStmt.SetLeft \
        SwitchStmt.List SwitchStmt.PtrList SwitchStmt.SetList \
        SwitchStmt.Body SwitchStmt.PtrBody SwitchStmt.SetBody \
        SwitchStmt.HasBreak SwitchStmt.SetHasBreak \
        SwitchStmt.Sym SwitchStmt.SetSym \
        TypeSwitchGuard.Left TypeSwitchGuard.SetLeft \
        TypeSwitchGuard.Right TypeSwitchGuard.SetRight \
        AddStringExpr.List AddStringExpr.PtrList AddStringExpr.SetList \
        AddrExpr.Left AddrExpr.SetLeft \
        AddrExpr.Right AddrExpr.SetRight \
        BinaryExpr.Left BinaryExpr.SetLeft \
        BinaryExpr.Right BinaryExpr.SetRight \
        LogicalExpr.Left LogicalExpr.SetLeft \
        LogicalExpr.Right LogicalExpr.SetRight \
        CallExpr.Left CallExpr.SetLeft \
        CallExpr.List CallExpr.PtrList CallExpr.SetList \
        CallExpr.Rlist CallExpr.PtrRlist CallExpr.SetRlist \
        CallExpr.NoInline CallExpr.SetNoInline \
        CallExpr.Body CallExpr.PtrBody CallExpr.SetBody \
        CallExpr.IsDDD CallExpr.SetIsDDD \
        CallPartExpr.Left CallPartExpr.SetLeft \
        ClosureReadExpr.Offset \
        ClosureReadExpr.Type \ # provided by miniExpr already
        CompLitExpr.Right CompLitExpr.SetRight \
        CompLitExpr.List CompLitExpr.PtrList CompLitExpr.SetList \
        ConvExpr.Left ConvExpr.SetLeft \
        IndexExpr.Left IndexExpr.SetLeft \
        IndexExpr.Right IndexExpr.SetRight \
        IndexExpr.IndexMapLValue IndexExpr.SetIndexMapLValue \
        KeyExpr.Left KeyExpr.SetLeft \
        KeyExpr.Right KeyExpr.SetRight \
        StructKeyExpr.Left StructKeyExpr.SetLeft \
        StructKeyExpr.Offset StructKeyExpr.SetOffset \
        StructKeyExpr.SetSym \
        InlinedCallExpr.Body InlinedCallExpr.PtrBody InlinedCallExpr.SetBody \
        InlinedCallExpr.Rlist InlinedCallExpr.PtrRlist InlinedCallExpr.SetRlist \
        MakeExpr.Left MakeExpr.SetLeft \
        MakeExpr.Right MakeExpr.SetRight \
        MethodExpr.Left MethodExpr.SetLeft \
        MethodExpr.Right MethodExpr.SetRight \
        MethodExpr.Offset MethodExpr.SetOffset \
        MethodExpr.Class MethodExpr.SetClass \
        ParenExpr.Left ParenExpr.SetLeft \
        ResultExpr.Offset ResultExpr.SetOffset \
        ReturnStmt.IsDDD \
        SelectorExpr.Left SelectorExpr.SetLeft \
        SelectorExpr.Offset SelectorExpr.SetOffset \
        SelectorExpr.SetSym \
        SliceExpr.Left SliceExpr.SetLeft \
        SliceExpr.List SliceExpr.PtrList SliceExpr.SetList \
        SliceHeaderExpr.Left SliceHeaderExpr.SetLeft \
        SliceHeaderExpr.List SliceHeaderExpr.PtrList SliceHeaderExpr.SetList \
        StarExpr.Left StarExpr.SetLeft \
        TypeAssertExpr.Left TypeAssertExpr.SetLeft \
        TypeAssertExpr.Right TypeAssertExpr.SetRight \
        TypeAssertExpr.List TypeAssertExpr.PtrList TypeAssertExpr.SetList \
        UnaryExpr.Left UnaryExpr.SetLeft \
        Func.Body Func.PtrBody Func.SetBody \
        Func.Iota Func.SetIota \
        CallPartExpr.Func ClosureExpr.Func Func.Func Name.Func \

mv BlockStmt.List_ BlockStmt.List
mv CaseStmt.List_ CaseStmt.List
mv CaseStmt.Body_ CaseStmt.Body
mv ForStmt.Body_ ForStmt.Body
mv ForStmt.HasBreak_ ForStmt.HasBreak
mv Func.Iota_ Func.Iota
mv IfStmt.Body_ IfStmt.Body
mv IfStmt.Likely_ IfStmt.Likely
mv RangeStmt.Body_ RangeStmt.Body
mv RangeStmt.HasBreak_ RangeStmt.HasBreak
mv SelectStmt.HasBreak_ SelectStmt.HasBreak
mv SwitchStmt.HasBreak_ SwitchStmt.HasBreak
mv AddStringExpr.List_ AddStringExpr.List
mv CallExpr.NoInline_ CallExpr.NoInline
mv CallExpr.Body_ CallExpr.Body # TODO what is this?
mv CallExpr.DDD CallExpr.IsDDD
mv ClosureReadExpr.Offset_ ClosureReadExpr.Offset
mv CompLitExpr.List_ CompLitExpr.List
mv StructKeyExpr.Offset_ StructKeyExpr.Offset
mv InlinedCallExpr.Body_ InlinedCallExpr.Body
mv ResultExpr.Offset_ ResultExpr.Offset
mv SelectorExpr.Offset_ SelectorExpr.Offset
mv SliceExpr.List_ SliceExpr.List
mv SliceHeaderExpr.LenCap_ SliceHeaderExpr.LenCap
mv Func.Body_ Func.Body
mv CallPartExpr.Func_ CallPartExpr.Func
mv ClosureExpr.Func_ ClosureExpr.Func
mv Name.Func_ Name.Func
'

Change-Id: Ia2ee59649674f83eb123e63fda7a7781cf91cc56
Reviewed-on: https://go-review.googlesource.com/c/go/+/277935
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 .../compile/internal/gc/abiutilsaux_test.go   |   4 +-
 src/cmd/compile/internal/gc/alg.go            |  74 +-
 src/cmd/compile/internal/gc/bexport.go        |   2 +-
 src/cmd/compile/internal/gc/closure.go        |  56 +-
 src/cmd/compile/internal/gc/const.go          |  50 +-
 src/cmd/compile/internal/gc/dcl.go            |  24 +-
 src/cmd/compile/internal/gc/escape.go         | 330 +++----
 src/cmd/compile/internal/gc/export.go         |   2 +-
 src/cmd/compile/internal/gc/gen.go            |   6 +-
 src/cmd/compile/internal/gc/gsubr.go          |  10 +-
 src/cmd/compile/internal/gc/iexport.go        | 178 ++--
 src/cmd/compile/internal/gc/iimport.go        |  74 +-
 src/cmd/compile/internal/gc/init.go           |  10 +-
 src/cmd/compile/internal/gc/initorder.go      |  24 +-
 src/cmd/compile/internal/gc/inl.go            | 204 ++---
 src/cmd/compile/internal/gc/main.go           |   2 +-
 src/cmd/compile/internal/gc/noder.go          |  90 +-
 src/cmd/compile/internal/gc/obj.go            |   8 +-
 src/cmd/compile/internal/gc/order.go          | 420 ++++-----
 src/cmd/compile/internal/gc/pgen.go           |  44 +-
 src/cmd/compile/internal/gc/pgen_test.go      |   4 +-
 src/cmd/compile/internal/gc/plive.go          |  14 +-
 src/cmd/compile/internal/gc/range.go          | 144 +--
 src/cmd/compile/internal/gc/reflect.go        |   6 +-
 src/cmd/compile/internal/gc/scc.go            |  10 +-
 src/cmd/compile/internal/gc/scope.go          |   6 +-
 src/cmd/compile/internal/gc/select.go         | 116 +--
 src/cmd/compile/internal/gc/sinit.go          | 180 ++--
 src/cmd/compile/internal/gc/ssa.go            | 518 +++++------
 src/cmd/compile/internal/gc/subr.go           | 108 +--
 src/cmd/compile/internal/gc/swt.go            | 172 ++--
 src/cmd/compile/internal/gc/typecheck.go      | 816 ++++++++---------
 src/cmd/compile/internal/gc/universe.go       |   6 +-
 src/cmd/compile/internal/gc/unsafe.go         |  24 +-
 src/cmd/compile/internal/gc/walk.go           | 844 +++++++++---------
 src/cmd/compile/internal/ir/expr.go           | 218 +----
 src/cmd/compile/internal/ir/fmt.go            | 220 ++---
 src/cmd/compile/internal/ir/func.go           |  24 +-
 src/cmd/compile/internal/ir/name.go           |   5 +-
 src/cmd/compile/internal/ir/node_gen.go       |  78 +-
 src/cmd/compile/internal/ir/stmt.go           | 217 +----
 41 files changed, 2539 insertions(+), 2803 deletions(-)

diff --git a/src/cmd/compile/internal/gc/abiutilsaux_test.go b/src/cmd/compile/internal/gc/abiutilsaux_test.go
index fd0b197207..de35e8edd6 100644
--- a/src/cmd/compile/internal/gc/abiutilsaux_test.go
+++ b/src/cmd/compile/internal/gc/abiutilsaux_test.go
@@ -20,7 +20,7 @@ import (
 func mkParamResultField(t *types.Type, s *types.Sym, which ir.Class) *types.Field {
 	field := types.NewField(src.NoXPos, s, t)
 	n := NewName(s)
-	n.SetClass(which)
+	n.Class_ = which
 	field.Nname = n
 	n.SetType(t)
 	return field
@@ -78,7 +78,7 @@ func verifyParamResultOffset(t *testing.T, f *types.Field, r ABIParamAssignment,
 	n := ir.AsNode(f.Nname).(*ir.Name)
 	if n.FrameOffset() != int64(r.Offset) {
 		t.Errorf("%s %d: got offset %d wanted %d t=%v",
-			which, idx, r.Offset, n.Offset(), f.Type)
+			which, idx, r.Offset, n.Offset_, f.Type)
 		return 1
 	}
 	return 0
diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index 730db9c1c9..bb2717a8b5 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -324,11 +324,11 @@ func genhash(t *types.Type) *obj.LSym {
 		nx := ir.NewIndexExpr(base.Pos, np, ni)
 		nx.SetBounded(true)
 		na := nodAddr(nx)
-		call.PtrList().Append(na)
-		call.PtrList().Append(nh)
-		loop.PtrBody().Append(ir.NewAssignStmt(base.Pos, nh, call))
+		call.Args.Append(na)
+		call.Args.Append(nh)
+		loop.Body.Append(ir.NewAssignStmt(base.Pos, nh, call))
 
-		fn.PtrBody().Append(loop)
+		fn.Body.Append(loop)
 
 	case types.TSTRUCT:
 		// Walk the struct using memhash for runs of AMEM
@@ -348,9 +348,9 @@ func genhash(t *types.Type) *obj.LSym {
 				call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil)
 				nx := ir.NewSelectorExpr(base.Pos, ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
 				na := nodAddr(nx)
-				call.PtrList().Append(na)
-				call.PtrList().Append(nh)
-				fn.PtrBody().Append(ir.NewAssignStmt(base.Pos, nh, call))
+				call.Args.Append(na)
+				call.Args.Append(nh)
+				fn.Body.Append(ir.NewAssignStmt(base.Pos, nh, call))
 				i++
 				continue
 			}
@@ -363,21 +363,21 @@ func genhash(t *types.Type) *obj.LSym {
 			call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil)
 			nx := ir.NewSelectorExpr(base.Pos, ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
 			na := nodAddr(nx)
-			call.PtrList().Append(na)
-			call.PtrList().Append(nh)
-			call.PtrList().Append(nodintconst(size))
-			fn.PtrBody().Append(ir.NewAssignStmt(base.Pos, nh, call))
+			call.Args.Append(na)
+			call.Args.Append(nh)
+			call.Args.Append(nodintconst(size))
+			fn.Body.Append(ir.NewAssignStmt(base.Pos, nh, call))
 
 			i = next
 		}
 	}
 
 	r := ir.NewReturnStmt(base.Pos, nil)
-	r.PtrList().Append(nh)
-	fn.PtrBody().Append(r)
+	r.Results.Append(nh)
+	fn.Body.Append(r)
 
 	if base.Flag.LowerR != 0 {
-		ir.DumpList("genhash body", fn.Body())
+		ir.DumpList("genhash body", fn.Body)
 	}
 
 	funcbody()
@@ -386,7 +386,7 @@ func genhash(t *types.Type) *obj.LSym {
 	typecheckFunc(fn)
 
 	Curfn = fn
-	typecheckslice(fn.Body().Slice(), ctxStmt)
+	typecheckslice(fn.Body.Slice(), ctxStmt)
 	Curfn = nil
 
 	if base.Debug.DclStack != 0 {
@@ -587,11 +587,11 @@ func geneq(t *types.Type) *obj.LSym {
 				for i := int64(0); i < nelem; i++ {
 					// if check {} else { goto neq }
 					nif := ir.NewIfStmt(base.Pos, checkIdx(nodintconst(i)), nil, nil)
-					nif.PtrRlist().Append(ir.NewBranchStmt(base.Pos, ir.OGOTO, neq))
-					fn.PtrBody().Append(nif)
+					nif.Else.Append(ir.NewBranchStmt(base.Pos, ir.OGOTO, neq))
+					fn.Body.Append(nif)
 				}
 				if last {
-					fn.PtrBody().Append(ir.NewAssignStmt(base.Pos, nr, checkIdx(nodintconst(nelem))))
+					fn.Body.Append(ir.NewAssignStmt(base.Pos, nr, checkIdx(nodintconst(nelem))))
 				}
 			} else {
 				// Generate a for loop.
@@ -604,11 +604,11 @@ func geneq(t *types.Type) *obj.LSym {
 				loop.PtrInit().Append(init)
 				// if eq(pi, qi) {} else { goto neq }
 				nif := ir.NewIfStmt(base.Pos, checkIdx(i), nil, nil)
-				nif.PtrRlist().Append(ir.NewBranchStmt(base.Pos, ir.OGOTO, neq))
-				loop.PtrBody().Append(nif)
-				fn.PtrBody().Append(loop)
+				nif.Else.Append(ir.NewBranchStmt(base.Pos, ir.OGOTO, neq))
+				loop.Body.Append(nif)
+				fn.Body.Append(loop)
 				if last {
-					fn.PtrBody().Append(ir.NewAssignStmt(base.Pos, nr, nodbool(true)))
+					fn.Body.Append(ir.NewAssignStmt(base.Pos, nr, nodbool(true)))
 				}
 			}
 		}
@@ -718,42 +718,42 @@ func geneq(t *types.Type) *obj.LSym {
 		}
 
 		if len(flatConds) == 0 {
-			fn.PtrBody().Append(ir.NewAssignStmt(base.Pos, nr, nodbool(true)))
+			fn.Body.Append(ir.NewAssignStmt(base.Pos, nr, nodbool(true)))
 		} else {
 			for _, c := range flatConds[:len(flatConds)-1] {
 				// if cond {} else { goto neq }
 				n := ir.NewIfStmt(base.Pos, c, nil, nil)
-				n.PtrRlist().Append(ir.NewBranchStmt(base.Pos, ir.OGOTO, neq))
-				fn.PtrBody().Append(n)
+				n.Else.Append(ir.NewBranchStmt(base.Pos, ir.OGOTO, neq))
+				fn.Body.Append(n)
 			}
-			fn.PtrBody().Append(ir.NewAssignStmt(base.Pos, nr, flatConds[len(flatConds)-1]))
+			fn.Body.Append(ir.NewAssignStmt(base.Pos, nr, flatConds[len(flatConds)-1]))
 		}
 	}
 
 	// ret:
 	//   return
 	ret := autolabel(".ret")
-	fn.PtrBody().Append(ir.NewLabelStmt(base.Pos, ret))
-	fn.PtrBody().Append(ir.NewReturnStmt(base.Pos, nil))
+	fn.Body.Append(ir.NewLabelStmt(base.Pos, ret))
+	fn.Body.Append(ir.NewReturnStmt(base.Pos, nil))
 
 	// neq:
 	//   r = false
 	//   return (or goto ret)
-	fn.PtrBody().Append(ir.NewLabelStmt(base.Pos, neq))
-	fn.PtrBody().Append(ir.NewAssignStmt(base.Pos, nr, nodbool(false)))
+	fn.Body.Append(ir.NewLabelStmt(base.Pos, neq))
+	fn.Body.Append(ir.NewAssignStmt(base.Pos, nr, nodbool(false)))
 	if EqCanPanic(t) || anyCall(fn) {
 		// Epilogue is large, so share it with the equal case.
-		fn.PtrBody().Append(ir.NewBranchStmt(base.Pos, ir.OGOTO, ret))
+		fn.Body.Append(ir.NewBranchStmt(base.Pos, ir.OGOTO, ret))
 	} else {
 		// Epilogue is small, so don't bother sharing.
-		fn.PtrBody().Append(ir.NewReturnStmt(base.Pos, nil))
+		fn.Body.Append(ir.NewReturnStmt(base.Pos, nil))
 	}
 	// TODO(khr): the epilogue size detection condition above isn't perfect.
 	// We should really do a generic CL that shares epilogues across
 	// the board. See #24936.
 
 	if base.Flag.LowerR != 0 {
-		ir.DumpList("geneq body", fn.Body())
+		ir.DumpList("geneq body", fn.Body)
 	}
 
 	funcbody()
@@ -762,7 +762,7 @@ func geneq(t *types.Type) *obj.LSym {
 	typecheckFunc(fn)
 
 	Curfn = fn
-	typecheckslice(fn.Body().Slice(), ctxStmt)
+	typecheckslice(fn.Body.Slice(), ctxStmt)
 	Curfn = nil
 
 	if base.Debug.DclStack != 0 {
@@ -869,10 +869,10 @@ func eqmem(p ir.Node, q ir.Node, field *types.Sym, size int64) ir.Node {
 
 	fn, needsize := eqmemfunc(size, nx.Type().Elem())
 	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
-	call.PtrList().Append(nx)
-	call.PtrList().Append(ny)
+	call.Args.Append(nx)
+	call.Args.Append(ny)
 	if needsize {
-		call.PtrList().Append(nodintconst(size))
+		call.Args.Append(nodintconst(size))
 	}
 
 	return call
diff --git a/src/cmd/compile/internal/gc/bexport.go b/src/cmd/compile/internal/gc/bexport.go
index 2347971fc2..3c377d8ba3 100644
--- a/src/cmd/compile/internal/gc/bexport.go
+++ b/src/cmd/compile/internal/gc/bexport.go
@@ -17,7 +17,7 @@ type exporter struct {
 func (p *exporter) markObject(n ir.Node) {
 	if n.Op() == ir.ONAME {
 		n := n.(*ir.Name)
-		if n.Class() == ir.PFUNC {
+		if n.Class_ == ir.PFUNC {
 			inlFlood(n, exportsym)
 		}
 	}
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index f47b2e2b07..1019cff331 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -77,11 +77,11 @@ func (p *noder) funcLit(expr *syntax.FuncLit) ir.Node {
 // TODO: This creation of the named function should probably really be done in a
 // separate pass from type-checking.
 func typecheckclosure(clo *ir.ClosureExpr, top int) {
-	fn := clo.Func()
+	fn := clo.Func
 	// Set current associated iota value, so iota can be used inside
 	// function in ConstSpec, see issue #22344
 	if x := getIotaValue(); x >= 0 {
-		fn.SetIota(x)
+		fn.Iota = x
 	}
 
 	fn.ClosureType = typecheck(fn.ClosureType, ctxType)
@@ -124,7 +124,7 @@ func typecheckclosure(clo *ir.ClosureExpr, top int) {
 		Curfn = fn
 		olddd := decldepth
 		decldepth = 1
-		typecheckslice(fn.Body().Slice(), ctxStmt)
+		typecheckslice(fn.Body.Slice(), ctxStmt)
 		decldepth = olddd
 		Curfn = oldfn
 	}
@@ -195,7 +195,7 @@ func capturevars(fn *ir.Func) {
 		outermost := v.Defn.(*ir.Name)
 
 		// out parameters will be assigned to implicitly upon return.
-		if outermost.Class() != ir.PPARAMOUT && !outermost.Name().Addrtaken() && !outermost.Name().Assigned() && v.Type().Width <= 128 {
+		if outermost.Class_ != ir.PPARAMOUT && !outermost.Name().Addrtaken() && !outermost.Name().Assigned() && v.Type().Width <= 128 {
 			v.SetByval(true)
 		} else {
 			outermost.Name().SetAddrtaken(true)
@@ -262,7 +262,7 @@ func transformclosure(fn *ir.Func) {
 				v = addr
 			}
 
-			v.SetClass(ir.PPARAM)
+			v.Class_ = ir.PPARAM
 			decls = append(decls, v)
 
 			fld := types.NewField(src.NoXPos, v.Sym(), v.Type())
@@ -294,7 +294,7 @@ func transformclosure(fn *ir.Func) {
 
 			if v.Byval() && v.Type().Width <= int64(2*Widthptr) {
 				// If it is a small variable captured by value, downgrade it to PAUTO.
-				v.SetClass(ir.PAUTO)
+				v.Class_ = ir.PAUTO
 				fn.Dcl = append(fn.Dcl, v)
 				body = append(body, ir.NewAssignStmt(base.Pos, v, cr))
 			} else {
@@ -302,7 +302,7 @@ func transformclosure(fn *ir.Func) {
 				// and initialize in entry prologue.
 				addr := NewName(lookup("&" + v.Sym().Name))
 				addr.SetType(types.NewPtr(v.Type()))
-				addr.SetClass(ir.PAUTO)
+				addr.Class_ = ir.PAUTO
 				addr.SetUsed(true)
 				addr.Curfn = fn
 				fn.Dcl = append(fn.Dcl, addr)
@@ -328,7 +328,7 @@ func transformclosure(fn *ir.Func) {
 // hasemptycvars reports whether closure clo has an
 // empty list of captured vars.
 func hasemptycvars(clo *ir.ClosureExpr) bool {
-	return len(clo.Func().ClosureVars) == 0
+	return len(clo.Func.ClosureVars) == 0
 }
 
 // closuredebugruntimecheck applies boilerplate checks for debug flags
@@ -336,9 +336,9 @@ func hasemptycvars(clo *ir.ClosureExpr) bool {
 func closuredebugruntimecheck(clo *ir.ClosureExpr) {
 	if base.Debug.Closure > 0 {
 		if clo.Esc() == EscHeap {
-			base.WarnfAt(clo.Pos(), "heap closure, captured vars = %v", clo.Func().ClosureVars)
+			base.WarnfAt(clo.Pos(), "heap closure, captured vars = %v", clo.Func.ClosureVars)
 		} else {
-			base.WarnfAt(clo.Pos(), "stack closure, captured vars = %v", clo.Func().ClosureVars)
+			base.WarnfAt(clo.Pos(), "stack closure, captured vars = %v", clo.Func.ClosureVars)
 		}
 	}
 	if base.Flag.CompilingRuntime && clo.Esc() == EscHeap {
@@ -366,7 +366,7 @@ func closureType(clo *ir.ClosureExpr) *types.Type {
 	fields := []*ir.Field{
 		namedfield(".F", types.Types[types.TUINTPTR]),
 	}
-	for _, v := range clo.Func().ClosureVars {
+	for _, v := range clo.Func.ClosureVars {
 		typ := v.Type()
 		if !v.Byval() {
 			typ = types.NewPtr(typ)
@@ -379,7 +379,7 @@ func closureType(clo *ir.ClosureExpr) *types.Type {
 }
 
 func walkclosure(clo *ir.ClosureExpr, init *ir.Nodes) ir.Node {
-	fn := clo.Func()
+	fn := clo.Func
 
 	// If no closure vars, don't bother wrapping.
 	if hasemptycvars(clo) {
@@ -394,7 +394,7 @@ func walkclosure(clo *ir.ClosureExpr, init *ir.Nodes) ir.Node {
 
 	clos := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ).(ir.Ntype), nil)
 	clos.SetEsc(clo.Esc())
-	clos.PtrList().Set(append([]ir.Node{ir.NewUnaryExpr(base.Pos, ir.OCFUNC, fn.Nname)}, fn.ClosureEnter.Slice()...))
+	clos.List.Set(append([]ir.Node{ir.NewUnaryExpr(base.Pos, ir.OCFUNC, fn.Nname)}, fn.ClosureEnter.Slice()...))
 
 	addr := nodAddr(clos)
 	addr.SetEsc(clo.Esc())
@@ -407,7 +407,7 @@ func walkclosure(clo *ir.ClosureExpr, init *ir.Nodes) ir.Node {
 		if !types.Identical(typ, x.Type()) {
 			panic("closure type does not match order's assigned type")
 		}
-		addr.SetRight(x)
+		addr.Alloc = x
 		clo.Prealloc = nil
 	}
 
@@ -428,13 +428,13 @@ func typecheckpartialcall(n ir.Node, sym *types.Sym) *ir.CallPartExpr {
 	fn := makepartialcall(dot, dot.Type(), sym)
 	fn.SetWrapper(true)
 
-	return ir.NewCallPartExpr(dot.Pos(), dot.Left(), dot.Selection, fn)
+	return ir.NewCallPartExpr(dot.Pos(), dot.X, dot.Selection, fn)
 }
 
 // makepartialcall returns a DCLFUNC node representing the wrapper function (*-fm) needed
 // for partial calls.
 func makepartialcall(dot *ir.SelectorExpr, t0 *types.Type, meth *types.Sym) *ir.Func {
-	rcvrtype := dot.Left().Type()
+	rcvrtype := dot.X.Type()
 	sym := methodSymSuffix(rcvrtype, meth, "-fm")
 
 	if sym.Uniq() {
@@ -480,24 +480,24 @@ func makepartialcall(dot *ir.SelectorExpr, t0 *types.Type, meth *types.Sym) *ir.
 	}
 
 	call := ir.NewCallExpr(base.Pos, ir.OCALL, ir.NewSelectorExpr(base.Pos, ir.OXDOT, ptr, meth), nil)
-	call.PtrList().Set(paramNnames(tfn.Type()))
-	call.SetIsDDD(tfn.Type().IsVariadic())
+	call.Args.Set(paramNnames(tfn.Type()))
+	call.IsDDD = tfn.Type().IsVariadic()
 	if t0.NumResults() != 0 {
 		ret := ir.NewReturnStmt(base.Pos, nil)
-		ret.PtrList().Set1(call)
+		ret.Results.Set1(call)
 		body = append(body, ret)
 	} else {
 		body = append(body, call)
 	}
 
-	fn.PtrBody().Set(body)
+	fn.Body.Set(body)
 	funcbody()
 
 	typecheckFunc(fn)
 	// Need to typecheck the body of the just-generated wrapper.
 	// typecheckslice() requires that Curfn is set when processing an ORETURN.
 	Curfn = fn
-	typecheckslice(fn.Body().Slice(), ctxStmt)
+	typecheckslice(fn.Body.Slice(), ctxStmt)
 	sym.Def = fn
 	Target.Decls = append(Target.Decls, fn)
 	Curfn = savecurfn
@@ -512,7 +512,7 @@ func makepartialcall(dot *ir.SelectorExpr, t0 *types.Type, meth *types.Sym) *ir.
 func partialCallType(n *ir.CallPartExpr) *types.Type {
 	t := tostruct([]*ir.Field{
 		namedfield("F", types.Types[types.TUINTPTR]),
-		namedfield("R", n.Left().Type()),
+		namedfield("R", n.X.Type()),
 	})
 	t.SetNoalg(true)
 	return t
@@ -526,13 +526,13 @@ func walkpartialcall(n *ir.CallPartExpr, init *ir.Nodes) ir.Node {
 	//
 	// Like walkclosure above.
 
-	if n.Left().Type().IsInterface() {
+	if n.X.Type().IsInterface() {
 		// Trigger panic for method on nil interface now.
 		// Otherwise it happens in the wrapper and is confusing.
-		n.SetLeft(cheapexpr(n.Left(), init))
-		n.SetLeft(walkexpr(n.Left(), nil))
+		n.X = cheapexpr(n.X, init)
+		n.X = walkexpr(n.X, nil)
 
-		tab := typecheck(ir.NewUnaryExpr(base.Pos, ir.OITAB, n.Left()), ctxExpr)
+		tab := typecheck(ir.NewUnaryExpr(base.Pos, ir.OITAB, n.X), ctxExpr)
 
 		c := ir.NewUnaryExpr(base.Pos, ir.OCHECKNIL, tab)
 		c.SetTypecheck(1)
@@ -543,7 +543,7 @@ func walkpartialcall(n *ir.CallPartExpr, init *ir.Nodes) ir.Node {
 
 	clos := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ).(ir.Ntype), nil)
 	clos.SetEsc(n.Esc())
-	clos.PtrList().Set2(ir.NewUnaryExpr(base.Pos, ir.OCFUNC, n.Func().Nname), n.Left())
+	clos.List.Set2(ir.NewUnaryExpr(base.Pos, ir.OCFUNC, n.Func.Nname), n.X)
 
 	addr := nodAddr(clos)
 	addr.SetEsc(n.Esc())
@@ -556,7 +556,7 @@ func walkpartialcall(n *ir.CallPartExpr, init *ir.Nodes) ir.Node {
 		if !types.Identical(typ, x.Type()) {
 			panic("partial call type does not match order's assigned type")
 		}
-		addr.SetRight(x)
+		addr.Alloc = x
 		n.Prealloc = nil
 	}
 
diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index e54cd0a102..19eb8bc537 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -163,8 +163,8 @@ func convlit1(n ir.Node, t *types.Type, explicit bool, context func() string) ir
 		}
 
 		n := n.(*ir.UnaryExpr)
-		n.SetLeft(convlit(n.Left(), ot))
-		if n.Left().Type() == nil {
+		n.X = convlit(n.X, ot)
+		if n.X.Type() == nil {
 			n.SetType(nil)
 			return n
 		}
@@ -181,13 +181,13 @@ func convlit1(n ir.Node, t *types.Type, explicit bool, context func() string) ir
 		var l, r ir.Node
 		switch n := n.(type) {
 		case *ir.BinaryExpr:
-			n.SetLeft(convlit(n.Left(), ot))
-			n.SetRight(convlit(n.Right(), ot))
-			l, r = n.Left(), n.Right()
+			n.X = convlit(n.X, ot)
+			n.Y = convlit(n.Y, ot)
+			l, r = n.X, n.Y
 		case *ir.LogicalExpr:
-			n.SetLeft(convlit(n.Left(), ot))
-			n.SetRight(convlit(n.Right(), ot))
-			l, r = n.Left(), n.Right()
+			n.X = convlit(n.X, ot)
+			n.Y = convlit(n.Y, ot)
+			l, r = n.X, n.Y
 		}
 
 		if l.Type() == nil || r.Type() == nil {
@@ -213,8 +213,8 @@ func convlit1(n ir.Node, t *types.Type, explicit bool, context func() string) ir
 
 	case ir.OLSH, ir.ORSH:
 		n := n.(*ir.BinaryExpr)
-		n.SetLeft(convlit1(n.Left(), t, explicit, nil))
-		n.SetType(n.Left().Type())
+		n.X = convlit1(n.X, t, explicit, nil)
+		n.SetType(n.X.Type())
 		if n.Type() != nil && !n.Type().IsInteger() {
 			base.Errorf("invalid operation: %v (shift of type %v)", n, n.Type())
 			n.SetType(nil)
@@ -452,7 +452,7 @@ func evalConst(n ir.Node) ir.Node {
 	switch n.Op() {
 	case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT:
 		n := n.(*ir.UnaryExpr)
-		nl := n.Left()
+		nl := n.X
 		if nl.Op() == ir.OLITERAL {
 			var prec uint
 			if n.Type().IsUnsigned() {
@@ -463,7 +463,7 @@ func evalConst(n ir.Node) ir.Node {
 
 	case ir.OADD, ir.OSUB, ir.OMUL, ir.ODIV, ir.OMOD, ir.OOR, ir.OXOR, ir.OAND, ir.OANDNOT:
 		n := n.(*ir.BinaryExpr)
-		nl, nr := n.Left(), n.Right()
+		nl, nr := n.X, n.Y
 		if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
 			rval := nr.Val()
 
@@ -488,21 +488,21 @@ func evalConst(n ir.Node) ir.Node {
 
 	case ir.OOROR, ir.OANDAND:
 		n := n.(*ir.LogicalExpr)
-		nl, nr := n.Left(), n.Right()
+		nl, nr := n.X, n.Y
 		if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
 			return origConst(n, constant.BinaryOp(nl.Val(), tokenForOp[n.Op()], nr.Val()))
 		}
 
 	case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
 		n := n.(*ir.BinaryExpr)
-		nl, nr := n.Left(), n.Right()
+		nl, nr := n.X, n.Y
 		if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
 			return origBoolConst(n, constant.Compare(nl.Val(), tokenForOp[n.Op()], nr.Val()))
 		}
 
 	case ir.OLSH, ir.ORSH:
 		n := n.(*ir.BinaryExpr)
-		nl, nr := n.Left(), n.Right()
+		nl, nr := n.X, n.Y
 		if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
 			// shiftBound from go/types; "so we can express smallestFloat64"
 			const shiftBound = 1023 - 1 + 52
@@ -517,14 +517,14 @@ func evalConst(n ir.Node) ir.Node {
 
 	case ir.OCONV, ir.ORUNESTR:
 		n := n.(*ir.ConvExpr)
-		nl := n.Left()
+		nl := n.X
 		if ir.OKForConst[n.Type().Kind()] && nl.Op() == ir.OLITERAL {
 			return origConst(n, convertVal(nl.Val(), n.Type(), true))
 		}
 
 	case ir.OCONVNOP:
 		n := n.(*ir.ConvExpr)
-		nl := n.Left()
+		nl := n.X
 		if ir.OKForConst[n.Type().Kind()] && nl.Op() == ir.OLITERAL {
 			// set so n.Orig gets OCONV instead of OCONVNOP
 			n.SetOp(ir.OCONV)
@@ -534,7 +534,7 @@ func evalConst(n ir.Node) ir.Node {
 	case ir.OADDSTR:
 		// Merge adjacent constants in the argument list.
 		n := n.(*ir.AddStringExpr)
-		s := n.List().Slice()
+		s := n.List.Slice()
 		need := 0
 		for i := 0; i < len(s); i++ {
 			if i == 0 || !ir.IsConst(s[i-1], constant.String) || !ir.IsConst(s[i], constant.String) {
@@ -564,7 +564,7 @@ func evalConst(n ir.Node) ir.Node {
 				}
 
 				nl := ir.Copy(n).(*ir.AddStringExpr)
-				nl.PtrList().Set(s[i:i2])
+				nl.List.Set(s[i:i2])
 				newList = append(newList, origConst(nl, constant.MakeString(strings.Join(strs, ""))))
 				i = i2 - 1
 			} else {
@@ -573,12 +573,12 @@ func evalConst(n ir.Node) ir.Node {
 		}
 
 		nn := ir.Copy(n).(*ir.AddStringExpr)
-		nn.PtrList().Set(newList)
+		nn.List.Set(newList)
 		return nn
 
 	case ir.OCAP, ir.OLEN:
 		n := n.(*ir.UnaryExpr)
-		nl := n.Left()
+		nl := n.X
 		switch nl.Type().Kind() {
 		case types.TSTRING:
 			if ir.IsConst(nl, constant.String) {
@@ -596,21 +596,21 @@ func evalConst(n ir.Node) ir.Node {
 
 	case ir.OREAL:
 		n := n.(*ir.UnaryExpr)
-		nl := n.Left()
+		nl := n.X
 		if nl.Op() == ir.OLITERAL {
 			return origConst(n, constant.Real(nl.Val()))
 		}
 
 	case ir.OIMAG:
 		n := n.(*ir.UnaryExpr)
-		nl := n.Left()
+		nl := n.X
 		if nl.Op() == ir.OLITERAL {
 			return origConst(n, constant.Imag(nl.Val()))
 		}
 
 	case ir.OCOMPLEX:
 		n := n.(*ir.BinaryExpr)
-		nl, nr := n.Left(), n.Right()
+		nl, nr := n.X, n.Y
 		if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
 			return origConst(n, makeComplex(nl.Val(), nr.Val()))
 		}
@@ -871,7 +871,7 @@ func (s *constSet) add(pos src.XPos, n ir.Node, what, where string) {
 	if conv := n; conv.Op() == ir.OCONVIFACE {
 		conv := conv.(*ir.ConvExpr)
 		if conv.Implicit() {
-			n = conv.Left()
+			n = conv.X
 		}
 	}
 
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index d85f10faf3..9bd044c368 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -120,7 +120,7 @@ func declare(n *ir.Name, ctxt ir.Class) {
 	s.Lastlineno = base.Pos
 	s.Def = n
 	n.Vargen = int32(gen)
-	n.SetClass(ctxt)
+	n.Class_ = ctxt
 	if ctxt == ir.PFUNC {
 		n.Sym().SetFunc(true)
 	}
@@ -137,9 +137,9 @@ func variter(vl []*ir.Name, t ir.Ntype, el []ir.Node) []ir.Node {
 	if len(el) == 1 && len(vl) > 1 {
 		e := el[0]
 		as2 := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-		as2.PtrRlist().Set1(e)
+		as2.Rhs.Set1(e)
 		for _, v := range vl {
-			as2.PtrList().Append(v)
+			as2.Lhs.Append(v)
 			declare(v, dclcontext)
 			v.Ntype = t
 			v.Defn = as2
@@ -234,7 +234,7 @@ func oldname(s *types.Sym) ir.Node {
 		if c == nil || c.Curfn != Curfn {
 			// Do not have a closure var for the active closure yet; make one.
 			c = NewName(s)
-			c.SetClass(ir.PAUTOHEAP)
+			c.Class_ = ir.PAUTOHEAP
 			c.SetIsClosureVar(true)
 			c.SetIsDDD(n.IsDDD())
 			c.Defn = n
@@ -810,11 +810,11 @@ func makefuncsym(s *types.Sym) {
 
 // setNodeNameFunc marks a node as a function.
 func setNodeNameFunc(n *ir.Name) {
-	if n.Op() != ir.ONAME || n.Class() != ir.Pxxx {
+	if n.Op() != ir.ONAME || n.Class_ != ir.Pxxx {
 		base.Fatalf("expected ONAME/Pxxx node, got %v", n)
 	}
 
-	n.SetClass(ir.PFUNC)
+	n.Class_ = ir.PFUNC
 	n.Sym().SetFunc(true)
 }
 
@@ -876,11 +876,11 @@ func (c *nowritebarrierrecChecker) findExtraCalls(nn ir.Node) {
 		return
 	}
 	n := nn.(*ir.CallExpr)
-	if n.Left() == nil || n.Left().Op() != ir.ONAME {
+	if n.X == nil || n.X.Op() != ir.ONAME {
 		return
 	}
-	fn := n.Left().(*ir.Name)
-	if fn.Class() != ir.PFUNC || fn.Name().Defn == nil {
+	fn := n.X.(*ir.Name)
+	if fn.Class_ != ir.PFUNC || fn.Name().Defn == nil {
 		return
 	}
 	if !isRuntimePkg(fn.Sym().Pkg) || fn.Sym().Name != "systemstack" {
@@ -888,14 +888,14 @@ func (c *nowritebarrierrecChecker) findExtraCalls(nn ir.Node) {
 	}
 
 	var callee *ir.Func
-	arg := n.List().First()
+	arg := n.Args.First()
 	switch arg.Op() {
 	case ir.ONAME:
 		arg := arg.(*ir.Name)
 		callee = arg.Name().Defn.(*ir.Func)
 	case ir.OCLOSURE:
 		arg := arg.(*ir.ClosureExpr)
-		callee = arg.Func()
+		callee = arg.Func
 	default:
 		base.Fatalf("expected ONAME or OCLOSURE node, got %+v", arg)
 	}
@@ -973,7 +973,7 @@ func (c *nowritebarrierrecChecker) check() {
 		q.PushRight(target.Nname)
 	}
 	for !q.Empty() {
-		fn := q.PopLeft().Func()
+		fn := q.PopLeft().Func
 
 		// Check fn.
 		if fn.WBPos.IsKnown() {
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 6510dfc4b3..21f02e9471 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -228,21 +228,21 @@ func (e *Escape) walkFunc(fn *ir.Func) {
 			if e.labels == nil {
 				e.labels = make(map[*types.Sym]labelState)
 			}
-			e.labels[n.Sym()] = nonlooping
+			e.labels[n.Label] = nonlooping
 
 		case ir.OGOTO:
 			// If we visited the label before the goto,
 			// then this is a looping label.
 			n := n.(*ir.BranchStmt)
-			if e.labels[n.Sym()] == nonlooping {
-				e.labels[n.Sym()] = looping
+			if e.labels[n.Label] == nonlooping {
+				e.labels[n.Label] = looping
 			}
 		}
 	})
 
 	e.curfn = fn
 	e.loopDepth = 1
-	e.block(fn.Body())
+	e.block(fn.Body)
 
 	if len(e.labels) != 0 {
 		base.FatalfAt(fn.Pos(), "leftover labels after walkFunc")
@@ -304,18 +304,18 @@ func (e *Escape) stmt(n ir.Node) {
 
 	case ir.OBLOCK:
 		n := n.(*ir.BlockStmt)
-		e.stmts(n.List())
+		e.stmts(n.List)
 
 	case ir.ODCL:
 		// Record loop depth at declaration.
 		n := n.(*ir.Decl)
-		if !ir.IsBlank(n.Left()) {
-			e.dcl(n.Left())
+		if !ir.IsBlank(n.X) {
+			e.dcl(n.X)
 		}
 
 	case ir.OLABEL:
 		n := n.(*ir.LabelStmt)
-		switch e.labels[n.Sym()] {
+		switch e.labels[n.Label] {
 		case nonlooping:
 			if base.Flag.LowerM > 2 {
 				fmt.Printf("%v:%v non-looping label\n", base.FmtPos(base.Pos), n)
@@ -328,127 +328,127 @@ func (e *Escape) stmt(n ir.Node) {
 		default:
 			base.Fatalf("label missing tag")
 		}
-		delete(e.labels, n.Sym())
+		delete(e.labels, n.Label)
 
 	case ir.OIF:
 		n := n.(*ir.IfStmt)
-		e.discard(n.Left())
-		e.block(n.Body())
-		e.block(n.Rlist())
+		e.discard(n.Cond)
+		e.block(n.Body)
+		e.block(n.Else)
 
 	case ir.OFOR, ir.OFORUNTIL:
 		n := n.(*ir.ForStmt)
 		e.loopDepth++
-		e.discard(n.Left())
-		e.stmt(n.Right())
-		e.block(n.Body())
+		e.discard(n.Cond)
+		e.stmt(n.Post)
+		e.block(n.Body)
 		e.loopDepth--
 
 	case ir.ORANGE:
 		// for List = range Right { Nbody }
 		n := n.(*ir.RangeStmt)
 		e.loopDepth++
-		ks := e.addrs(n.List())
-		e.block(n.Body())
+		ks := e.addrs(n.Vars)
+		e.block(n.Body)
 		e.loopDepth--
 
 		// Right is evaluated outside the loop.
 		k := e.discardHole()
 		if len(ks) >= 2 {
-			if n.Right().Type().IsArray() {
+			if n.X.Type().IsArray() {
 				k = ks[1].note(n, "range")
 			} else {
 				k = ks[1].deref(n, "range-deref")
 			}
 		}
-		e.expr(e.later(k), n.Right())
+		e.expr(e.later(k), n.X)
 
 	case ir.OSWITCH:
 		n := n.(*ir.SwitchStmt)
-		typesw := n.Left() != nil && n.Left().Op() == ir.OTYPESW
+		typesw := n.Tag != nil && n.Tag.Op() == ir.OTYPESW
 
 		var ks []EscHole
-		for _, cas := range n.List().Slice() { // cases
+		for _, cas := range n.Cases.Slice() { // cases
 			cas := cas.(*ir.CaseStmt)
-			if typesw && n.Left().(*ir.TypeSwitchGuard).Left() != nil {
-				cv := cas.Rlist().First()
+			if typesw && n.Tag.(*ir.TypeSwitchGuard).Tag != nil {
+				cv := cas.Vars.First()
 				k := e.dcl(cv) // type switch variables have no ODCL.
 				if cv.Type().HasPointers() {
 					ks = append(ks, k.dotType(cv.Type(), cas, "switch case"))
 				}
 			}
 
-			e.discards(cas.List())
-			e.block(cas.Body())
+			e.discards(cas.List)
+			e.block(cas.Body)
 		}
 
 		if typesw {
-			e.expr(e.teeHole(ks...), n.Left().(*ir.TypeSwitchGuard).Right())
+			e.expr(e.teeHole(ks...), n.Tag.(*ir.TypeSwitchGuard).X)
 		} else {
-			e.discard(n.Left())
+			e.discard(n.Tag)
 		}
 
 	case ir.OSELECT:
 		n := n.(*ir.SelectStmt)
-		for _, cas := range n.List().Slice() {
+		for _, cas := range n.Cases.Slice() {
 			cas := cas.(*ir.CaseStmt)
-			e.stmt(cas.Left())
-			e.block(cas.Body())
+			e.stmt(cas.Comm)
+			e.block(cas.Body)
 		}
 	case ir.OSELRECV2:
 		n := n.(*ir.AssignListStmt)
-		e.assign(n.List().First(), n.Rlist().First(), "selrecv", n)
-		e.assign(n.List().Second(), nil, "selrecv", n)
+		e.assign(n.Lhs.First(), n.Rhs.First(), "selrecv", n)
+		e.assign(n.Lhs.Second(), nil, "selrecv", n)
 	case ir.ORECV:
 		// TODO(mdempsky): Consider e.discard(n.Left).
 		n := n.(*ir.UnaryExpr)
 		e.exprSkipInit(e.discardHole(), n) // already visited n.Ninit
 	case ir.OSEND:
 		n := n.(*ir.SendStmt)
-		e.discard(n.Left())
-		e.assignHeap(n.Right(), "send", n)
+		e.discard(n.Chan)
+		e.assignHeap(n.Value, "send", n)
 
 	case ir.OAS:
 		n := n.(*ir.AssignStmt)
-		e.assign(n.Left(), n.Right(), "assign", n)
+		e.assign(n.X, n.Y, "assign", n)
 	case ir.OASOP:
 		n := n.(*ir.AssignOpStmt)
-		e.assign(n.Left(), n.Right(), "assign", n)
+		e.assign(n.X, n.Y, "assign", n)
 	case ir.OAS2:
 		n := n.(*ir.AssignListStmt)
-		for i, nl := range n.List().Slice() {
-			e.assign(nl, n.Rlist().Index(i), "assign-pair", n)
+		for i, nl := range n.Lhs.Slice() {
+			e.assign(nl, n.Rhs.Index(i), "assign-pair", n)
 		}
 
 	case ir.OAS2DOTTYPE: // v, ok = x.(type)
 		n := n.(*ir.AssignListStmt)
-		e.assign(n.List().First(), n.Rlist().First(), "assign-pair-dot-type", n)
-		e.assign(n.List().Second(), nil, "assign-pair-dot-type", n)
+		e.assign(n.Lhs.First(), n.Rhs.First(), "assign-pair-dot-type", n)
+		e.assign(n.Lhs.Second(), nil, "assign-pair-dot-type", n)
 	case ir.OAS2MAPR: // v, ok = m[k]
 		n := n.(*ir.AssignListStmt)
-		e.assign(n.List().First(), n.Rlist().First(), "assign-pair-mapr", n)
-		e.assign(n.List().Second(), nil, "assign-pair-mapr", n)
+		e.assign(n.Lhs.First(), n.Rhs.First(), "assign-pair-mapr", n)
+		e.assign(n.Lhs.Second(), nil, "assign-pair-mapr", n)
 	case ir.OAS2RECV: // v, ok = <-ch
 		n := n.(*ir.AssignListStmt)
-		e.assign(n.List().First(), n.Rlist().First(), "assign-pair-receive", n)
-		e.assign(n.List().Second(), nil, "assign-pair-receive", n)
+		e.assign(n.Lhs.First(), n.Rhs.First(), "assign-pair-receive", n)
+		e.assign(n.Lhs.Second(), nil, "assign-pair-receive", n)
 
 	case ir.OAS2FUNC:
 		n := n.(*ir.AssignListStmt)
-		e.stmts(n.Rlist().First().Init())
-		e.call(e.addrs(n.List()), n.Rlist().First(), nil)
+		e.stmts(n.Rhs.First().Init())
+		e.call(e.addrs(n.Lhs), n.Rhs.First(), nil)
 	case ir.ORETURN:
 		n := n.(*ir.ReturnStmt)
 		results := e.curfn.Type().Results().FieldSlice()
-		for i, v := range n.List().Slice() {
+		for i, v := range n.Results.Slice() {
 			e.assign(ir.AsNode(results[i].Nname), v, "return", n)
 		}
 	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER, ir.OCLOSE, ir.OCOPY, ir.ODELETE, ir.OPANIC, ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
 		e.call(nil, n, nil)
 	case ir.OGO, ir.ODEFER:
 		n := n.(*ir.GoDeferStmt)
-		e.stmts(n.Left().Init())
-		e.call(nil, n.Left(), n)
+		e.stmts(n.Call.Init())
+		e.call(nil, n.Call, n)
 
 	case ir.ORETJMP:
 		// TODO(mdempsky): What do? esc.go just ignores it.
@@ -491,7 +491,7 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 	uintptrEscapesHack := k.uintptrEscapesHack
 	k.uintptrEscapesHack = false
 
-	if uintptrEscapesHack && n.Op() == ir.OCONVNOP && n.(*ir.ConvExpr).Left().Type().IsUnsafePtr() {
+	if uintptrEscapesHack && n.Op() == ir.OCONVNOP && n.(*ir.ConvExpr).X.Type().IsUnsafePtr() {
 		// nop
 	} else if k.derefs >= 0 && !n.Type().HasPointers() {
 		k = e.discardHole()
@@ -506,7 +506,7 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 
 	case ir.ONAME:
 		n := n.(*ir.Name)
-		if n.Class() == ir.PFUNC || n.Class() == ir.PEXTERN {
+		if n.Class_ == ir.PFUNC || n.Class_ == ir.PEXTERN {
 			return
 		}
 		e.flow(k, e.oldLoc(n))
@@ -517,46 +517,46 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 
 	case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT:
 		n := n.(*ir.UnaryExpr)
-		e.discard(n.Left())
+		e.discard(n.X)
 	case ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.ODIV, ir.OMOD, ir.OLSH, ir.ORSH, ir.OAND, ir.OANDNOT, ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
 		n := n.(*ir.BinaryExpr)
-		e.discard(n.Left())
-		e.discard(n.Right())
+		e.discard(n.X)
+		e.discard(n.Y)
 	case ir.OANDAND, ir.OOROR:
 		n := n.(*ir.LogicalExpr)
-		e.discard(n.Left())
-		e.discard(n.Right())
+		e.discard(n.X)
+		e.discard(n.Y)
 	case ir.OADDR:
 		n := n.(*ir.AddrExpr)
-		e.expr(k.addr(n, "address-of"), n.Left()) // "address-of"
+		e.expr(k.addr(n, "address-of"), n.X) // "address-of"
 	case ir.ODEREF:
 		n := n.(*ir.StarExpr)
-		e.expr(k.deref(n, "indirection"), n.Left()) // "indirection"
+		e.expr(k.deref(n, "indirection"), n.X) // "indirection"
 	case ir.ODOT, ir.ODOTMETH, ir.ODOTINTER:
 		n := n.(*ir.SelectorExpr)
-		e.expr(k.note(n, "dot"), n.Left())
+		e.expr(k.note(n, "dot"), n.X)
 	case ir.ODOTPTR:
 		n := n.(*ir.SelectorExpr)
-		e.expr(k.deref(n, "dot of pointer"), n.Left()) // "dot of pointer"
+		e.expr(k.deref(n, "dot of pointer"), n.X) // "dot of pointer"
 	case ir.ODOTTYPE, ir.ODOTTYPE2:
 		n := n.(*ir.TypeAssertExpr)
-		e.expr(k.dotType(n.Type(), n, "dot"), n.Left())
+		e.expr(k.dotType(n.Type(), n, "dot"), n.X)
 	case ir.OINDEX:
 		n := n.(*ir.IndexExpr)
-		if n.Left().Type().IsArray() {
-			e.expr(k.note(n, "fixed-array-index-of"), n.Left())
+		if n.X.Type().IsArray() {
+			e.expr(k.note(n, "fixed-array-index-of"), n.X)
 		} else {
 			// TODO(mdempsky): Fix why reason text.
-			e.expr(k.deref(n, "dot of pointer"), n.Left())
+			e.expr(k.deref(n, "dot of pointer"), n.X)
 		}
-		e.discard(n.Right())
+		e.discard(n.Index)
 	case ir.OINDEXMAP:
 		n := n.(*ir.IndexExpr)
-		e.discard(n.Left())
-		e.discard(n.Right())
+		e.discard(n.X)
+		e.discard(n.Index)
 	case ir.OSLICE, ir.OSLICEARR, ir.OSLICE3, ir.OSLICE3ARR, ir.OSLICESTR:
 		n := n.(*ir.SliceExpr)
-		e.expr(k.note(n, "slice"), n.Left())
+		e.expr(k.note(n, "slice"), n.X)
 		low, high, max := n.SliceBounds()
 		e.discard(low)
 		e.discard(high)
@@ -564,29 +564,29 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 
 	case ir.OCONV, ir.OCONVNOP:
 		n := n.(*ir.ConvExpr)
-		if checkPtr(e.curfn, 2) && n.Type().IsUnsafePtr() && n.Left().Type().IsPtr() {
+		if checkPtr(e.curfn, 2) && n.Type().IsUnsafePtr() && n.X.Type().IsPtr() {
 			// When -d=checkptr=2 is enabled, treat
 			// conversions to unsafe.Pointer as an
 			// escaping operation. This allows better
 			// runtime instrumentation, since we can more
 			// easily detect object boundaries on the heap
 			// than the stack.
-			e.assignHeap(n.Left(), "conversion to unsafe.Pointer", n)
-		} else if n.Type().IsUnsafePtr() && n.Left().Type().IsUintptr() {
-			e.unsafeValue(k, n.Left())
+			e.assignHeap(n.X, "conversion to unsafe.Pointer", n)
+		} else if n.Type().IsUnsafePtr() && n.X.Type().IsUintptr() {
+			e.unsafeValue(k, n.X)
 		} else {
-			e.expr(k, n.Left())
+			e.expr(k, n.X)
 		}
 	case ir.OCONVIFACE:
 		n := n.(*ir.ConvExpr)
-		if !n.Left().Type().IsInterface() && !isdirectiface(n.Left().Type()) {
+		if !n.X.Type().IsInterface() && !isdirectiface(n.X.Type()) {
 			k = e.spill(k, n)
 		}
-		e.expr(k.note(n, "interface-converted"), n.Left())
+		e.expr(k.note(n, "interface-converted"), n.X)
 
 	case ir.ORECV:
 		n := n.(*ir.UnaryExpr)
-		e.discard(n.Left())
+		e.discard(n.X)
 
 	case ir.OCALLMETH, ir.OCALLFUNC, ir.OCALLINTER, ir.OLEN, ir.OCAP, ir.OCOMPLEX, ir.OREAL, ir.OIMAG, ir.OAPPEND, ir.OCOPY:
 		e.call([]EscHole{k}, n, nil)
@@ -598,15 +598,15 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 	case ir.OMAKESLICE:
 		n := n.(*ir.MakeExpr)
 		e.spill(k, n)
-		e.discard(n.Left())
-		e.discard(n.Right())
+		e.discard(n.Len)
+		e.discard(n.Cap)
 	case ir.OMAKECHAN:
 		n := n.(*ir.MakeExpr)
-		e.discard(n.Left())
+		e.discard(n.Len)
 	case ir.OMAKEMAP:
 		n := n.(*ir.MakeExpr)
 		e.spill(k, n)
-		e.discard(n.Left())
+		e.discard(n.Len)
 
 	case ir.ORECOVER:
 		// nop
@@ -633,17 +633,17 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 		name, _ := m.Nname.(*ir.Name)
 		paramK := e.tagHole(ks, name, m.Type.Recv())
 
-		e.expr(e.teeHole(paramK, closureK), n.Left())
+		e.expr(e.teeHole(paramK, closureK), n.X)
 
 	case ir.OPTRLIT:
 		n := n.(*ir.AddrExpr)
-		e.expr(e.spill(k, n), n.Left())
+		e.expr(e.spill(k, n), n.X)
 
 	case ir.OARRAYLIT:
 		n := n.(*ir.CompLitExpr)
-		for _, elt := range n.List().Slice() {
+		for _, elt := range n.List.Slice() {
 			if elt.Op() == ir.OKEY {
-				elt = elt.(*ir.KeyExpr).Right()
+				elt = elt.(*ir.KeyExpr).Value
 			}
 			e.expr(k.note(n, "array literal element"), elt)
 		}
@@ -653,17 +653,17 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 		k = e.spill(k, n)
 		k.uintptrEscapesHack = uintptrEscapesHack // for ...uintptr parameters
 
-		for _, elt := range n.List().Slice() {
+		for _, elt := range n.List.Slice() {
 			if elt.Op() == ir.OKEY {
-				elt = elt.(*ir.KeyExpr).Right()
+				elt = elt.(*ir.KeyExpr).Value
 			}
 			e.expr(k.note(n, "slice-literal-element"), elt)
 		}
 
 	case ir.OSTRUCTLIT:
 		n := n.(*ir.CompLitExpr)
-		for _, elt := range n.List().Slice() {
-			e.expr(k.note(n, "struct literal element"), elt.(*ir.StructKeyExpr).Left())
+		for _, elt := range n.List.Slice() {
+			e.expr(k.note(n, "struct literal element"), elt.(*ir.StructKeyExpr).Value)
 		}
 
 	case ir.OMAPLIT:
@@ -671,10 +671,10 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 		e.spill(k, n)
 
 		// Map keys and values are always stored in the heap.
-		for _, elt := range n.List().Slice() {
+		for _, elt := range n.List.Slice() {
 			elt := elt.(*ir.KeyExpr)
-			e.assignHeap(elt.Left(), "map literal key", n)
-			e.assignHeap(elt.Right(), "map literal value", n)
+			e.assignHeap(elt.Key, "map literal key", n)
+			e.assignHeap(elt.Value, "map literal value", n)
 		}
 
 	case ir.OCLOSURE:
@@ -682,7 +682,7 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 		k = e.spill(k, n)
 
 		// Link addresses of captured variables to closure.
-		for _, v := range n.Func().ClosureVars {
+		for _, v := range n.Func.ClosureVars {
 			k := k
 			if !v.Byval() {
 				k = k.addr(v, "reference")
@@ -694,7 +694,7 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 	case ir.ORUNES2STR, ir.OBYTES2STR, ir.OSTR2RUNES, ir.OSTR2BYTES, ir.ORUNESTR:
 		n := n.(*ir.ConvExpr)
 		e.spill(k, n)
-		e.discard(n.Left())
+		e.discard(n.X)
 
 	case ir.OADDSTR:
 		n := n.(*ir.AddStringExpr)
@@ -702,7 +702,7 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 
 		// Arguments of OADDSTR never escape;
 		// runtime.concatstrings makes sure of that.
-		e.discards(n.List())
+		e.discards(n.List)
 	}
 }
 
@@ -718,31 +718,31 @@ func (e *Escape) unsafeValue(k EscHole, n ir.Node) {
 	switch n.Op() {
 	case ir.OCONV, ir.OCONVNOP:
 		n := n.(*ir.ConvExpr)
-		if n.Left().Type().IsUnsafePtr() {
-			e.expr(k, n.Left())
+		if n.X.Type().IsUnsafePtr() {
+			e.expr(k, n.X)
 		} else {
-			e.discard(n.Left())
+			e.discard(n.X)
 		}
 	case ir.ODOTPTR:
 		n := n.(*ir.SelectorExpr)
 		if isReflectHeaderDataField(n) {
-			e.expr(k.deref(n, "reflect.Header.Data"), n.Left())
+			e.expr(k.deref(n, "reflect.Header.Data"), n.X)
 		} else {
-			e.discard(n.Left())
+			e.discard(n.X)
 		}
 	case ir.OPLUS, ir.ONEG, ir.OBITNOT:
 		n := n.(*ir.UnaryExpr)
-		e.unsafeValue(k, n.Left())
+		e.unsafeValue(k, n.X)
 	case ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.ODIV, ir.OMOD, ir.OAND, ir.OANDNOT:
 		n := n.(*ir.BinaryExpr)
-		e.unsafeValue(k, n.Left())
-		e.unsafeValue(k, n.Right())
+		e.unsafeValue(k, n.X)
+		e.unsafeValue(k, n.Y)
 	case ir.OLSH, ir.ORSH:
 		n := n.(*ir.BinaryExpr)
-		e.unsafeValue(k, n.Left())
+		e.unsafeValue(k, n.X)
 		// RHS need not be uintptr-typed (#32959) and can't meaningfully
 		// flow pointers anyway.
-		e.discard(n.Right())
+		e.discard(n.Y)
 	default:
 		e.exprSkipInit(e.discardHole(), n)
 	}
@@ -775,7 +775,7 @@ func (e *Escape) addr(n ir.Node) EscHole {
 		base.Fatalf("unexpected addr: %v", n)
 	case ir.ONAME:
 		n := n.(*ir.Name)
-		if n.Class() == ir.PEXTERN {
+		if n.Class_ == ir.PEXTERN {
 			break
 		}
 		k = e.oldLoc(n).asHole()
@@ -784,21 +784,21 @@ func (e *Escape) addr(n ir.Node) EscHole {
 		e.addr(n.Name_)
 	case ir.ODOT:
 		n := n.(*ir.SelectorExpr)
-		k = e.addr(n.Left())
+		k = e.addr(n.X)
 	case ir.OINDEX:
 		n := n.(*ir.IndexExpr)
-		e.discard(n.Right())
-		if n.Left().Type().IsArray() {
-			k = e.addr(n.Left())
+		e.discard(n.Index)
+		if n.X.Type().IsArray() {
+			k = e.addr(n.X)
 		} else {
-			e.discard(n.Left())
+			e.discard(n.X)
 		}
 	case ir.ODEREF, ir.ODOTPTR:
 		e.discard(n)
 	case ir.OINDEXMAP:
 		n := n.(*ir.IndexExpr)
-		e.discard(n.Left())
-		e.assignHeap(n.Right(), "key of map put", n)
+		e.discard(n.X)
+		e.assignHeap(n.Index, "key of map put", n)
 	}
 
 	if !n.Type().HasPointers() {
@@ -876,17 +876,17 @@ func (e *Escape) call(ks []EscHole, call, where ir.Node) {
 		var fn *ir.Name
 		switch call.Op() {
 		case ir.OCALLFUNC:
-			switch v := staticValue(call.Left()); {
-			case v.Op() == ir.ONAME && v.(*ir.Name).Class() == ir.PFUNC:
+			switch v := staticValue(call.X); {
+			case v.Op() == ir.ONAME && v.(*ir.Name).Class_ == ir.PFUNC:
 				fn = v.(*ir.Name)
 			case v.Op() == ir.OCLOSURE:
-				fn = v.(*ir.ClosureExpr).Func().Nname
+				fn = v.(*ir.ClosureExpr).Func.Nname
 			}
 		case ir.OCALLMETH:
-			fn = methodExprName(call.Left())
+			fn = methodExprName(call.X)
 		}
 
-		fntype := call.Left().Type()
+		fntype := call.X.Type()
 		if fn != nil {
 			fntype = fn.Type()
 		}
@@ -898,20 +898,20 @@ func (e *Escape) call(ks []EscHole, call, where ir.Node) {
 		}
 
 		if r := fntype.Recv(); r != nil {
-			argument(e.tagHole(ks, fn, r), call.Left().(*ir.SelectorExpr).Left())
+			argument(e.tagHole(ks, fn, r), call.X.(*ir.SelectorExpr).X)
 		} else {
 			// Evaluate callee function expression.
-			argument(e.discardHole(), call.Left())
+			argument(e.discardHole(), call.X)
 		}
 
-		args := call.List().Slice()
+		args := call.Args.Slice()
 		for i, param := range fntype.Params().FieldSlice() {
 			argument(e.tagHole(ks, fn, param), args[i])
 		}
 
 	case ir.OAPPEND:
 		call := call.(*ir.CallExpr)
-		args := call.List().Slice()
+		args := call.Args.Slice()
 
 		// Appendee slice may flow directly to the result, if
 		// it has enough capacity. Alternatively, a new heap
@@ -923,7 +923,7 @@ func (e *Escape) call(ks []EscHole, call, where ir.Node) {
 		}
 		argument(appendeeK, args[0])
 
-		if call.IsDDD() {
+		if call.IsDDD {
 			appendedK := e.discardHole()
 			if args[1].Type().IsSlice() && args[1].Type().Elem().HasPointers() {
 				appendedK = e.heapHole().deref(call, "appended slice...")
@@ -937,30 +937,30 @@ func (e *Escape) call(ks []EscHole, call, where ir.Node) {
 
 	case ir.OCOPY:
 		call := call.(*ir.BinaryExpr)
-		argument(e.discardHole(), call.Left())
+		argument(e.discardHole(), call.X)
 
 		copiedK := e.discardHole()
-		if call.Right().Type().IsSlice() && call.Right().Type().Elem().HasPointers() {
+		if call.Y.Type().IsSlice() && call.Y.Type().Elem().HasPointers() {
 			copiedK = e.heapHole().deref(call, "copied slice")
 		}
-		argument(copiedK, call.Right())
+		argument(copiedK, call.Y)
 
 	case ir.OPANIC:
 		call := call.(*ir.UnaryExpr)
-		argument(e.heapHole(), call.Left())
+		argument(e.heapHole(), call.X)
 
 	case ir.OCOMPLEX:
 		call := call.(*ir.BinaryExpr)
-		argument(e.discardHole(), call.Left())
-		argument(e.discardHole(), call.Right())
+		argument(e.discardHole(), call.X)
+		argument(e.discardHole(), call.Y)
 	case ir.ODELETE, ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
 		call := call.(*ir.CallExpr)
-		for _, arg := range call.List().Slice() {
+		for _, arg := range call.Args.Slice() {
 			argument(e.discardHole(), arg)
 		}
 	case ir.OLEN, ir.OCAP, ir.OREAL, ir.OIMAG, ir.OCLOSE:
 		call := call.(*ir.UnaryExpr)
-		argument(e.discardHole(), call.Left())
+		argument(e.discardHole(), call.X)
 	}
 }
 
@@ -1557,7 +1557,7 @@ func (e *Escape) finish(fns []*ir.Func) {
 }
 
 func (l *EscLocation) isName(c ir.Class) bool {
-	return l.n != nil && l.n.Op() == ir.ONAME && l.n.(*ir.Name).Class() == c
+	return l.n != nil && l.n.Op() == ir.ONAME && l.n.(*ir.Name).Class_ == c
 }
 
 const numEscResults = 7
@@ -1726,10 +1726,10 @@ func isSliceSelfAssign(dst, src ir.Node) bool {
 		return false
 	case ir.ODEREF:
 		dst := dst.(*ir.StarExpr)
-		dstX = dst.Left()
+		dstX = dst.X
 	case ir.ODOTPTR:
 		dst := dst.(*ir.SelectorExpr)
-		dstX = dst.Left()
+		dstX = dst.X
 	}
 	if dstX.Op() != ir.ONAME {
 		return false
@@ -1749,7 +1749,7 @@ func isSliceSelfAssign(dst, src ir.Node) bool {
 		// For slicing an array (not pointer to array), there is an implicit OADDR.
 		// We check that to determine non-pointer array slicing.
 		src := src.(*ir.SliceExpr)
-		if src.Left().Op() == ir.OADDR {
+		if src.X.Op() == ir.OADDR {
 			return false
 		}
 	default:
@@ -1757,15 +1757,15 @@ func isSliceSelfAssign(dst, src ir.Node) bool {
 	}
 	// slice is applied to ONAME dereference.
 	var baseX ir.Node
-	switch base := src.(*ir.SliceExpr).Left(); base.Op() {
+	switch base := src.(*ir.SliceExpr).X; base.Op() {
 	default:
 		return false
 	case ir.ODEREF:
 		base := base.(*ir.StarExpr)
-		baseX = base.Left()
+		baseX = base.X
 	case ir.ODOTPTR:
 		base := base.(*ir.SelectorExpr)
-		baseX = base.Left()
+		baseX = base.X
 	}
 	if baseX.Op() != ir.ONAME {
 		return false
@@ -1801,14 +1801,14 @@ func isSelfAssign(dst, src ir.Node) bool {
 		// Safe trailing accessors that are permitted to differ.
 		dst := dst.(*ir.SelectorExpr)
 		src := src.(*ir.SelectorExpr)
-		return samesafeexpr(dst.Left(), src.Left())
+		return samesafeexpr(dst.X, src.X)
 	case ir.OINDEX:
 		dst := dst.(*ir.IndexExpr)
 		src := src.(*ir.IndexExpr)
-		if mayAffectMemory(dst.Right()) || mayAffectMemory(src.Right()) {
+		if mayAffectMemory(dst.Index) || mayAffectMemory(src.Index) {
 			return false
 		}
-		return samesafeexpr(dst.Left(), src.Left())
+		return samesafeexpr(dst.X, src.X)
 	default:
 		return false
 	}
@@ -1834,27 +1834,27 @@ func mayAffectMemory(n ir.Node) bool {
 
 	case ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.OLSH, ir.ORSH, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OMOD:
 		n := n.(*ir.BinaryExpr)
-		return mayAffectMemory(n.Left()) || mayAffectMemory(n.Right())
+		return mayAffectMemory(n.X) || mayAffectMemory(n.Y)
 
 	case ir.OINDEX:
 		n := n.(*ir.IndexExpr)
-		return mayAffectMemory(n.Left()) || mayAffectMemory(n.Right())
+		return mayAffectMemory(n.X) || mayAffectMemory(n.Index)
 
 	case ir.OCONVNOP, ir.OCONV:
 		n := n.(*ir.ConvExpr)
-		return mayAffectMemory(n.Left())
+		return mayAffectMemory(n.X)
 
 	case ir.OLEN, ir.OCAP, ir.ONOT, ir.OBITNOT, ir.OPLUS, ir.ONEG, ir.OALIGNOF, ir.OOFFSETOF, ir.OSIZEOF:
 		n := n.(*ir.UnaryExpr)
-		return mayAffectMemory(n.Left())
+		return mayAffectMemory(n.X)
 
 	case ir.ODOT, ir.ODOTPTR:
 		n := n.(*ir.SelectorExpr)
-		return mayAffectMemory(n.Left())
+		return mayAffectMemory(n.X)
 
 	case ir.ODEREF:
 		n := n.(*ir.StarExpr)
-		return mayAffectMemory(n.Left())
+		return mayAffectMemory(n.X)
 
 	default:
 		return true
@@ -1871,7 +1871,7 @@ func heapAllocReason(n ir.Node) string {
 	// Parameters are always passed via the stack.
 	if n.Op() == ir.ONAME {
 		n := n.(*ir.Name)
-		if n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT {
+		if n.Class_ == ir.PPARAM || n.Class_ == ir.PPARAMOUT {
 			return ""
 		}
 	}
@@ -1893,9 +1893,9 @@ func heapAllocReason(n ir.Node) string {
 
 	if n.Op() == ir.OMAKESLICE {
 		n := n.(*ir.MakeExpr)
-		r := n.Right()
+		r := n.Cap
 		if r == nil {
-			r = n.Left()
+			r = n.Len
 		}
 		if !smallintconst(r) {
 			return "non-constant size"
@@ -1928,7 +1928,7 @@ func addrescapes(n ir.Node) {
 
 		// if this is a tmpname (PAUTO), it was tagged by tmpname as not escaping.
 		// on PPARAM it means something different.
-		if n.Class() == ir.PAUTO && n.Esc() == EscNever {
+		if n.Class_ == ir.PAUTO && n.Esc() == EscNever {
 			break
 		}
 
@@ -1938,7 +1938,7 @@ func addrescapes(n ir.Node) {
 			break
 		}
 
-		if n.Class() != ir.PPARAM && n.Class() != ir.PPARAMOUT && n.Class() != ir.PAUTO {
+		if n.Class_ != ir.PPARAM && n.Class_ != ir.PPARAMOUT && n.Class_ != ir.PAUTO {
 			break
 		}
 
@@ -1969,18 +1969,18 @@ func addrescapes(n ir.Node) {
 	// is always a heap pointer anyway.
 	case ir.ODOT:
 		n := n.(*ir.SelectorExpr)
-		addrescapes(n.Left())
+		addrescapes(n.X)
 	case ir.OINDEX:
 		n := n.(*ir.IndexExpr)
-		if !n.Left().Type().IsSlice() {
-			addrescapes(n.Left())
+		if !n.X.Type().IsSlice() {
+			addrescapes(n.X)
 		}
 	case ir.OPAREN:
 		n := n.(*ir.ParenExpr)
-		addrescapes(n.Left())
+		addrescapes(n.X)
 	case ir.OCONVNOP:
 		n := n.(*ir.ConvExpr)
-		addrescapes(n.Left())
+		addrescapes(n.X)
 	}
 }
 
@@ -1992,7 +1992,7 @@ func moveToHeap(n *ir.Name) {
 	if base.Flag.CompilingRuntime {
 		base.Errorf("%v escapes to heap, not allowed in runtime", n)
 	}
-	if n.Class() == ir.PAUTOHEAP {
+	if n.Class_ == ir.PAUTOHEAP {
 		ir.Dump("n", n)
 		base.Fatalf("double move to heap")
 	}
@@ -2011,7 +2011,7 @@ func moveToHeap(n *ir.Name) {
 	// Parameters have a local stack copy used at function start/end
 	// in addition to the copy in the heap that may live longer than
 	// the function.
-	if n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT {
+	if n.Class_ == ir.PPARAM || n.Class_ == ir.PPARAMOUT {
 		if n.FrameOffset() == types.BADWIDTH {
 			base.Fatalf("addrescapes before param assignment")
 		}
@@ -2023,9 +2023,9 @@ func moveToHeap(n *ir.Name) {
 		stackcopy := NewName(n.Sym())
 		stackcopy.SetType(n.Type())
 		stackcopy.SetFrameOffset(n.FrameOffset())
-		stackcopy.SetClass(n.Class())
+		stackcopy.Class_ = n.Class_
 		stackcopy.Heapaddr = heapaddr
-		if n.Class() == ir.PPARAMOUT {
+		if n.Class_ == ir.PPARAMOUT {
 			// Make sure the pointer to the heap copy is kept live throughout the function.
 			// The function could panic at any point, and then a defer could recover.
 			// Thus, we need the pointer to the heap copy always available so the
@@ -2047,7 +2047,7 @@ func moveToHeap(n *ir.Name) {
 			}
 			// Parameters are before locals, so can stop early.
 			// This limits the search even in functions with many local variables.
-			if d.Class() == ir.PAUTO {
+			if d.Class_ == ir.PAUTO {
 				break
 			}
 		}
@@ -2058,7 +2058,7 @@ func moveToHeap(n *ir.Name) {
 	}
 
 	// Modify n in place so that uses of n now mean indirection of the heapaddr.
-	n.SetClass(ir.PAUTOHEAP)
+	n.Class_ = ir.PAUTOHEAP
 	n.SetFrameOffset(0)
 	n.Heapaddr = heapaddr
 	n.SetEsc(EscHeap)
@@ -2084,7 +2084,7 @@ func (e *Escape) paramTag(fn *ir.Func, narg int, f *types.Field) string {
 		return fmt.Sprintf("arg#%d", narg)
 	}
 
-	if fn.Body().Len() == 0 {
+	if fn.Body.Len() == 0 {
 		// Assume that uintptr arguments must be held live across the call.
 		// This is most important for syscall.Syscall.
 		// See golang.org/issue/13372.
@@ -2106,7 +2106,7 @@ func (e *Escape) paramTag(fn *ir.Func, narg int, f *types.Field) string {
 
 		// External functions are assumed unsafe, unless
 		// //go:noescape is given before the declaration.
-		if fn.Func().Pragma&ir.Noescape != 0 {
+		if fn.Pragma&ir.Noescape != 0 {
 			if base.Flag.LowerM != 0 && f.Sym != nil {
 				base.WarnfAt(f.Pos, "%v does not escape", name())
 			}
@@ -2120,7 +2120,7 @@ func (e *Escape) paramTag(fn *ir.Func, narg int, f *types.Field) string {
 		return esc.Encode()
 	}
 
-	if fn.Func().Pragma&ir.UintptrEscapes != 0 {
+	if fn.Pragma&ir.UintptrEscapes != 0 {
 		if f.Type.IsUintptr() {
 			if base.Flag.LowerM != 0 {
 				base.WarnfAt(f.Pos, "marking %v as escaping uintptr", name())
diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index 8a8295537c..2855f815be 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -83,7 +83,7 @@ func importsym(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op ir.Op, ctxt ir.Cl
 	}
 
 	n := ir.NewDeclNameAt(pos, op, s)
-	n.SetClass(ctxt) // TODO(mdempsky): Move this into NewDeclNameAt too?
+	n.Class_ = ctxt // TODO(mdempsky): Move this into NewDeclNameAt too?
 	s.SetPkgDef(n)
 	s.Importdef = ipkg
 	return n
diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
index 25b241e236..f83c636472 100644
--- a/src/cmd/compile/internal/gc/gen.go
+++ b/src/cmd/compile/internal/gc/gen.go
@@ -35,7 +35,7 @@ func isParamStackCopy(n ir.Node) bool {
 		return false
 	}
 	name := n.(*ir.Name)
-	return (name.Class() == ir.PPARAM || name.Class() == ir.PPARAMOUT) && name.Heapaddr != nil
+	return (name.Class_ == ir.PPARAM || name.Class_ == ir.PPARAMOUT) && name.Heapaddr != nil
 }
 
 // isParamHeapCopy reports whether this is the on-heap copy of
@@ -45,7 +45,7 @@ func isParamHeapCopy(n ir.Node) bool {
 		return false
 	}
 	name := n.(*ir.Name)
-	return name.Class() == ir.PAUTOHEAP && name.Name().Stackcopy != nil
+	return name.Class_ == ir.PAUTOHEAP && name.Name().Stackcopy != nil
 }
 
 // autotmpname returns the name for an autotmp variable numbered n.
@@ -79,7 +79,7 @@ func tempAt(pos src.XPos, curfn *ir.Func, t *types.Type) *ir.Name {
 	n := ir.NewNameAt(pos, s)
 	s.Def = n
 	n.SetType(t)
-	n.SetClass(ir.PAUTO)
+	n.Class_ = ir.PAUTO
 	n.SetEsc(EscNever)
 	n.Curfn = curfn
 	n.SetUsed(true)
diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go
index b0ad01bc5d..6008abeff8 100644
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ b/src/cmd/compile/internal/gc/gsubr.go
@@ -270,16 +270,16 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 		tail = ir.NewBranchStmt(base.Pos, ir.ORETJMP, f.Nname.Sym())
 	} else {
 		call := ir.NewCallExpr(base.Pos, ir.OCALL, f.Nname, nil)
-		call.PtrList().Set(paramNnames(tfn.Type()))
-		call.SetIsDDD(tfn.Type().IsVariadic())
+		call.Args.Set(paramNnames(tfn.Type()))
+		call.IsDDD = tfn.Type().IsVariadic()
 		tail = call
 		if tfn.Type().NumResults() > 0 {
 			n := ir.NewReturnStmt(base.Pos, nil)
-			n.PtrList().Set1(call)
+			n.Results.Set1(call)
 			tail = n
 		}
 	}
-	fn.PtrBody().Append(tail)
+	fn.Body.Append(tail)
 
 	funcbody()
 	if base.Debug.DclStack != 0 {
@@ -288,7 +288,7 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 
 	typecheckFunc(fn)
 	Curfn = fn
-	typecheckslice(fn.Body().Slice(), ctxStmt)
+	typecheckslice(fn.Body.Slice(), ctxStmt)
 
 	escapeFuncs([]*ir.Func{fn}, false)
 
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index 0f7d62c5bf..60aa2eae8b 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -429,7 +429,7 @@ func (p *iexporter) doDecl(n *ir.Name) {
 
 	switch n.Op() {
 	case ir.ONAME:
-		switch n.Class() {
+		switch n.Class_ {
 		case ir.PEXTERN:
 			// Variable.
 			w.tag('V')
@@ -449,7 +449,7 @@ func (p *iexporter) doDecl(n *ir.Name) {
 			w.funcExt(n)
 
 		default:
-			base.Fatalf("unexpected class: %v, %v", n, n.Class())
+			base.Fatalf("unexpected class: %v, %v", n, n.Class_)
 		}
 
 	case ir.OLITERAL:
@@ -528,7 +528,7 @@ func (p *iexporter) doInline(f *ir.Name) {
 	w := p.newWriter()
 	w.setPkg(fnpkg(f), false)
 
-	w.stmtList(ir.AsNodes(f.Func().Inl.Body))
+	w.stmtList(ir.AsNodes(f.Func.Inl.Body))
 
 	w.finish("inl", p.inlineIndex, f.Sym())
 }
@@ -983,14 +983,14 @@ func (w *exportWriter) funcExt(n *ir.Name) {
 	}
 
 	// Inline body.
-	if n.Func().Inl != nil {
-		w.uint64(1 + uint64(n.Func().Inl.Cost))
-		if n.Func().ExportInline() {
+	if n.Func.Inl != nil {
+		w.uint64(1 + uint64(n.Func.Inl.Cost))
+		if n.Func.ExportInline() {
 			w.p.doInline(n)
 		}
 
 		// Endlineno for inlined function.
-		w.pos(n.Func().Endlineno)
+		w.pos(n.Func.Endlineno)
 	} else {
 		w.uint64(0)
 	}
@@ -1068,27 +1068,27 @@ func (w *exportWriter) stmt(n ir.Node) {
 		// generate OBLOCK nodes except to denote an empty
 		// function body, although that may change.)
 		n := n.(*ir.BlockStmt)
-		for _, n := range n.List().Slice() {
+		for _, n := range n.List.Slice() {
 			w.stmt(n)
 		}
 
 	case ir.ODCL:
 		n := n.(*ir.Decl)
 		w.op(ir.ODCL)
-		w.pos(n.Left().Pos())
-		w.localName(n.Left().(*ir.Name))
-		w.typ(n.Left().Type())
+		w.pos(n.X.Pos())
+		w.localName(n.X.(*ir.Name))
+		w.typ(n.X.Type())
 
 	case ir.OAS:
 		// Don't export "v = <N>" initializing statements, hope they're always
 		// preceded by the DCL which will be re-parsed and typecheck to reproduce
 		// the "v = <N>" again.
 		n := n.(*ir.AssignStmt)
-		if n.Right() != nil {
+		if n.Y != nil {
 			w.op(ir.OAS)
 			w.pos(n.Pos())
-			w.expr(n.Left())
-			w.expr(n.Right())
+			w.expr(n.X)
+			w.expr(n.Y)
 		}
 
 	case ir.OASOP:
@@ -1096,23 +1096,23 @@ func (w *exportWriter) stmt(n ir.Node) {
 		w.op(ir.OASOP)
 		w.pos(n.Pos())
 		w.op(n.AsOp)
-		w.expr(n.Left())
-		if w.bool(!n.Implicit()) {
-			w.expr(n.Right())
+		w.expr(n.X)
+		if w.bool(!n.IncDec) {
+			w.expr(n.Y)
 		}
 
 	case ir.OAS2, ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV:
 		n := n.(*ir.AssignListStmt)
 		w.op(ir.OAS2)
 		w.pos(n.Pos())
-		w.exprList(n.List())
-		w.exprList(n.Rlist())
+		w.exprList(n.Lhs)
+		w.exprList(n.Rhs)
 
 	case ir.ORETURN:
 		n := n.(*ir.ReturnStmt)
 		w.op(ir.ORETURN)
 		w.pos(n.Pos())
-		w.exprList(n.List())
+		w.exprList(n.Results)
 
 	// case ORETJMP:
 	// 	unreachable - generated by compiler for trampolin routines
@@ -1121,32 +1121,32 @@ func (w *exportWriter) stmt(n ir.Node) {
 		n := n.(*ir.GoDeferStmt)
 		w.op(n.Op())
 		w.pos(n.Pos())
-		w.expr(n.Left())
+		w.expr(n.Call)
 
 	case ir.OIF:
 		n := n.(*ir.IfStmt)
 		w.op(ir.OIF)
 		w.pos(n.Pos())
 		w.stmtList(n.Init())
-		w.expr(n.Left())
-		w.stmtList(n.Body())
-		w.stmtList(n.Rlist())
+		w.expr(n.Cond)
+		w.stmtList(n.Body)
+		w.stmtList(n.Else)
 
 	case ir.OFOR:
 		n := n.(*ir.ForStmt)
 		w.op(ir.OFOR)
 		w.pos(n.Pos())
 		w.stmtList(n.Init())
-		w.exprsOrNil(n.Left(), n.Right())
-		w.stmtList(n.Body())
+		w.exprsOrNil(n.Cond, n.Post)
+		w.stmtList(n.Body)
 
 	case ir.ORANGE:
 		n := n.(*ir.RangeStmt)
 		w.op(ir.ORANGE)
 		w.pos(n.Pos())
-		w.stmtList(n.List())
-		w.expr(n.Right())
-		w.stmtList(n.Body())
+		w.stmtList(n.Vars)
+		w.expr(n.X)
+		w.stmtList(n.Body)
 
 	case ir.OSELECT:
 		n := n.(*ir.SelectStmt)
@@ -1161,7 +1161,7 @@ func (w *exportWriter) stmt(n ir.Node) {
 		w.op(n.Op())
 		w.pos(n.Pos())
 		w.stmtList(n.Init())
-		w.exprsOrNil(n.Left(), nil)
+		w.exprsOrNil(n.Tag, nil)
 		w.caseList(n)
 
 	// case OCASE:
@@ -1191,11 +1191,11 @@ func isNamedTypeSwitch(n ir.Node) bool {
 		return false
 	}
 	sw := n.(*ir.SwitchStmt)
-	if sw.Left() == nil || sw.Left().Op() != ir.OTYPESW {
+	if sw.Tag == nil || sw.Tag.Op() != ir.OTYPESW {
 		return false
 	}
-	guard := sw.Left().(*ir.TypeSwitchGuard)
-	return guard.Left() != nil
+	guard := sw.Tag.(*ir.TypeSwitchGuard)
+	return guard.Tag != nil
 }
 
 func (w *exportWriter) caseList(sw ir.Node) {
@@ -1203,19 +1203,19 @@ func (w *exportWriter) caseList(sw ir.Node) {
 
 	var cases []ir.Node
 	if sw.Op() == ir.OSWITCH {
-		cases = sw.(*ir.SwitchStmt).List().Slice()
+		cases = sw.(*ir.SwitchStmt).Cases.Slice()
 	} else {
-		cases = sw.(*ir.SelectStmt).List().Slice()
+		cases = sw.(*ir.SelectStmt).Cases.Slice()
 	}
 	w.uint64(uint64(len(cases)))
 	for _, cas := range cases {
 		cas := cas.(*ir.CaseStmt)
 		w.pos(cas.Pos())
-		w.stmtList(cas.List())
+		w.stmtList(cas.List)
 		if namedTypeSwitch {
-			w.localName(cas.Rlist().First().(*ir.Name))
+			w.localName(cas.Vars.First().(*ir.Name))
 		}
-		w.stmtList(cas.Body())
+		w.stmtList(cas.Body)
 	}
 }
 
@@ -1230,21 +1230,21 @@ func simplifyForExport(n ir.Node) ir.Node {
 	switch n.Op() {
 	case ir.OPAREN:
 		n := n.(*ir.ParenExpr)
-		return simplifyForExport(n.Left())
+		return simplifyForExport(n.X)
 	case ir.ODEREF:
 		n := n.(*ir.StarExpr)
 		if n.Implicit() {
-			return simplifyForExport(n.Left())
+			return simplifyForExport(n.X)
 		}
 	case ir.OADDR:
 		n := n.(*ir.AddrExpr)
 		if n.Implicit() {
-			return simplifyForExport(n.Left())
+			return simplifyForExport(n.X)
 		}
 	case ir.ODOT, ir.ODOTPTR:
 		n := n.(*ir.SelectorExpr)
 		if n.Implicit() {
-			return simplifyForExport(n.Left())
+			return simplifyForExport(n.X)
 		}
 	}
 	return n
@@ -1283,7 +1283,7 @@ func (w *exportWriter) expr(n ir.Node) {
 	case ir.ONAME:
 		// Package scope name.
 		n := n.(*ir.Name)
-		if (n.Class() == ir.PEXTERN || n.Class() == ir.PFUNC) && !ir.IsBlank(n) {
+		if (n.Class_ == ir.PEXTERN || n.Class_ == ir.PFUNC) && !ir.IsBlank(n) {
 			w.op(ir.ONONAME)
 			w.qualifiedIdent(n)
 			break
@@ -1305,14 +1305,14 @@ func (w *exportWriter) expr(n ir.Node) {
 		w.op(ir.OTYPESW)
 		w.pos(n.Pos())
 		var s *types.Sym
-		if n.Left() != nil {
-			if n.Left().Op() != ir.ONONAME {
-				base.Fatalf("expected ONONAME, got %v", n.Left())
+		if n.Tag != nil {
+			if n.Tag.Op() != ir.ONONAME {
+				base.Fatalf("expected ONONAME, got %v", n.Tag)
 			}
-			s = n.Left().Sym()
+			s = n.Tag.Sym()
 		}
 		w.localIdent(s, 0) // declared pseudo-variable, if any
-		w.exprsOrNil(n.Right(), nil)
+		w.exprsOrNil(n.X, nil)
 
 	// case OTARRAY, OTMAP, OTCHAN, OTSTRUCT, OTINTER, OTFUNC:
 	// 	should have been resolved by typechecking - handled by default case
@@ -1327,27 +1327,27 @@ func (w *exportWriter) expr(n ir.Node) {
 		n := n.(*ir.AddrExpr)
 		w.op(ir.OADDR)
 		w.pos(n.Pos())
-		w.expr(n.Left())
+		w.expr(n.X)
 
 	case ir.OSTRUCTLIT:
 		n := n.(*ir.CompLitExpr)
 		w.op(ir.OSTRUCTLIT)
 		w.pos(n.Pos())
 		w.typ(n.Type())
-		w.fieldList(n.List()) // special handling of field names
+		w.fieldList(n.List) // special handling of field names
 
 	case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT:
 		n := n.(*ir.CompLitExpr)
 		w.op(ir.OCOMPLIT)
 		w.pos(n.Pos())
 		w.typ(n.Type())
-		w.exprList(n.List())
+		w.exprList(n.List)
 
 	case ir.OKEY:
 		n := n.(*ir.KeyExpr)
 		w.op(ir.OKEY)
 		w.pos(n.Pos())
-		w.exprsOrNil(n.Left(), n.Right())
+		w.exprsOrNil(n.Key, n.Value)
 
 	// case OSTRUCTKEY:
 	//	unreachable - handled in case OSTRUCTLIT by elemList
@@ -1357,35 +1357,35 @@ func (w *exportWriter) expr(n ir.Node) {
 		n := n.(*ir.CallPartExpr)
 		w.op(ir.OXDOT)
 		w.pos(n.Pos())
-		w.expr(n.Left())
-		w.selector(n.Sym())
+		w.expr(n.X)
+		w.selector(n.Method.Sym)
 
 	case ir.OXDOT, ir.ODOT, ir.ODOTPTR, ir.ODOTINTER, ir.ODOTMETH:
 		n := n.(*ir.SelectorExpr)
 		w.op(ir.OXDOT)
 		w.pos(n.Pos())
-		w.expr(n.Left())
-		w.selector(n.Sym())
+		w.expr(n.X)
+		w.selector(n.Sel)
 
 	case ir.ODOTTYPE, ir.ODOTTYPE2:
 		n := n.(*ir.TypeAssertExpr)
 		w.op(ir.ODOTTYPE)
 		w.pos(n.Pos())
-		w.expr(n.Left())
+		w.expr(n.X)
 		w.typ(n.Type())
 
 	case ir.OINDEX, ir.OINDEXMAP:
 		n := n.(*ir.IndexExpr)
 		w.op(ir.OINDEX)
 		w.pos(n.Pos())
-		w.expr(n.Left())
-		w.expr(n.Right())
+		w.expr(n.X)
+		w.expr(n.Index)
 
 	case ir.OSLICE, ir.OSLICESTR, ir.OSLICEARR:
 		n := n.(*ir.SliceExpr)
 		w.op(ir.OSLICE)
 		w.pos(n.Pos())
-		w.expr(n.Left())
+		w.expr(n.X)
 		low, high, _ := n.SliceBounds()
 		w.exprsOrNil(low, high)
 
@@ -1393,7 +1393,7 @@ func (w *exportWriter) expr(n ir.Node) {
 		n := n.(*ir.SliceExpr)
 		w.op(ir.OSLICE3)
 		w.pos(n.Pos())
-		w.expr(n.Left())
+		w.expr(n.X)
 		low, high, max := n.SliceBounds()
 		w.exprsOrNil(low, high)
 		w.expr(max)
@@ -1403,33 +1403,33 @@ func (w *exportWriter) expr(n ir.Node) {
 		n := n.(*ir.BinaryExpr)
 		w.op(n.Op())
 		w.pos(n.Pos())
-		w.expr(n.Left())
-		w.expr(n.Right())
+		w.expr(n.X)
+		w.expr(n.Y)
 		w.op(ir.OEND)
 
 	case ir.OCONV, ir.OCONVIFACE, ir.OCONVNOP, ir.OBYTES2STR, ir.ORUNES2STR, ir.OSTR2BYTES, ir.OSTR2RUNES, ir.ORUNESTR:
 		n := n.(*ir.ConvExpr)
 		w.op(ir.OCONV)
 		w.pos(n.Pos())
-		w.expr(n.Left())
+		w.expr(n.X)
 		w.typ(n.Type())
 
 	case ir.OREAL, ir.OIMAG, ir.OCAP, ir.OCLOSE, ir.OLEN, ir.ONEW, ir.OPANIC:
 		n := n.(*ir.UnaryExpr)
 		w.op(n.Op())
 		w.pos(n.Pos())
-		w.expr(n.Left())
+		w.expr(n.X)
 		w.op(ir.OEND)
 
 	case ir.OAPPEND, ir.ODELETE, ir.ORECOVER, ir.OPRINT, ir.OPRINTN:
 		n := n.(*ir.CallExpr)
 		w.op(n.Op())
 		w.pos(n.Pos())
-		w.exprList(n.List()) // emits terminating OEND
+		w.exprList(n.Args) // emits terminating OEND
 		// only append() calls may contain '...' arguments
 		if n.Op() == ir.OAPPEND {
-			w.bool(n.IsDDD())
-		} else if n.IsDDD() {
+			w.bool(n.IsDDD)
+		} else if n.IsDDD {
 			base.Fatalf("exporter: unexpected '...' with %v call", n.Op())
 		}
 
@@ -1438,9 +1438,9 @@ func (w *exportWriter) expr(n ir.Node) {
 		w.op(ir.OCALL)
 		w.pos(n.Pos())
 		w.stmtList(n.Init())
-		w.expr(n.Left())
-		w.exprList(n.List())
-		w.bool(n.IsDDD())
+		w.expr(n.X)
+		w.exprList(n.Args)
+		w.bool(n.IsDDD)
 
 	case ir.OMAKEMAP, ir.OMAKECHAN, ir.OMAKESLICE:
 		n := n.(*ir.MakeExpr)
@@ -1451,12 +1451,12 @@ func (w *exportWriter) expr(n ir.Node) {
 		default:
 			// empty list
 			w.op(ir.OEND)
-		case n.Right() != nil:
-			w.expr(n.Left())
-			w.expr(n.Right())
+		case n.Cap != nil:
+			w.expr(n.Len)
+			w.expr(n.Cap)
 			w.op(ir.OEND)
-		case n.Left() != nil && (n.Op() == ir.OMAKESLICE || !n.Left().Type().IsUntyped()):
-			w.expr(n.Left())
+		case n.Len != nil && (n.Op() == ir.OMAKESLICE || !n.Len.Type().IsUntyped()):
+			w.expr(n.Len)
 			w.op(ir.OEND)
 		}
 
@@ -1465,26 +1465,26 @@ func (w *exportWriter) expr(n ir.Node) {
 		n := n.(*ir.UnaryExpr)
 		w.op(n.Op())
 		w.pos(n.Pos())
-		w.expr(n.Left())
+		w.expr(n.X)
 
 	case ir.OADDR:
 		n := n.(*ir.AddrExpr)
 		w.op(n.Op())
 		w.pos(n.Pos())
-		w.expr(n.Left())
+		w.expr(n.X)
 
 	case ir.ODEREF:
 		n := n.(*ir.StarExpr)
 		w.op(n.Op())
 		w.pos(n.Pos())
-		w.expr(n.Left())
+		w.expr(n.X)
 
 	case ir.OSEND:
 		n := n.(*ir.SendStmt)
 		w.op(n.Op())
 		w.pos(n.Pos())
-		w.expr(n.Left())
-		w.expr(n.Right())
+		w.expr(n.Chan)
+		w.expr(n.Value)
 
 	// binary expressions
 	case ir.OADD, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OEQ, ir.OGE, ir.OGT, ir.OLE, ir.OLT,
@@ -1492,21 +1492,21 @@ func (w *exportWriter) expr(n ir.Node) {
 		n := n.(*ir.BinaryExpr)
 		w.op(n.Op())
 		w.pos(n.Pos())
-		w.expr(n.Left())
-		w.expr(n.Right())
+		w.expr(n.X)
+		w.expr(n.Y)
 
 	case ir.OANDAND, ir.OOROR:
 		n := n.(*ir.LogicalExpr)
 		w.op(n.Op())
 		w.pos(n.Pos())
-		w.expr(n.Left())
-		w.expr(n.Right())
+		w.expr(n.X)
+		w.expr(n.Y)
 
 	case ir.OADDSTR:
 		n := n.(*ir.AddStringExpr)
 		w.op(ir.OADDSTR)
 		w.pos(n.Pos())
-		w.exprList(n.List())
+		w.exprList(n.List)
 
 	case ir.ODCLCONST:
 		// if exporting, DCLCONST should just be removed as its usage
@@ -1543,8 +1543,8 @@ func (w *exportWriter) fieldList(list ir.Nodes) {
 	w.uint64(uint64(list.Len()))
 	for _, n := range list.Slice() {
 		n := n.(*ir.StructKeyExpr)
-		w.selector(n.Sym())
-		w.expr(n.Left())
+		w.selector(n.Field)
+		w.expr(n.Value)
 	}
 }
 
@@ -1557,7 +1557,7 @@ func (w *exportWriter) localName(n *ir.Name) {
 	// PPARAM/PPARAMOUT, because we only want to include vargen in
 	// non-param names.
 	var v int32
-	if n.Class() == ir.PAUTO || (n.Class() == ir.PAUTOHEAP && n.Name().Stackcopy == nil) {
+	if n.Class_ == ir.PAUTO || (n.Class_ == ir.PAUTOHEAP && n.Name().Stackcopy == nil) {
 		v = n.Name().Vargen
 	}
 
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 40f76cae7b..4f460d54a2 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -329,7 +329,7 @@ func (r *importReader) doDecl(sym *types.Sym) *ir.Name {
 			fn.SetType(mtyp)
 			m := newFuncNameAt(mpos, methodSym(recv.Type, msym), fn)
 			m.SetType(mtyp)
-			m.SetClass(ir.PFUNC)
+			m.Class_ = ir.PFUNC
 			// methodSym already marked m.Sym as a function.
 
 			f := types.NewField(mpos, msym, mtyp)
@@ -643,10 +643,10 @@ func (r *importReader) funcExt(n *ir.Name) {
 
 	// Inline body.
 	if u := r.uint64(); u > 0 {
-		n.Func().Inl = &ir.Inline{
+		n.Func.Inl = &ir.Inline{
 			Cost: int32(u - 1),
 		}
-		n.Func().Endlineno = r.pos()
+		n.Func.Endlineno = r.pos()
 	}
 }
 
@@ -757,7 +757,7 @@ func (r *importReader) stmtList() []ir.Node {
 		// Inline them into the statement list.
 		if n.Op() == ir.OBLOCK {
 			n := n.(*ir.BlockStmt)
-			list = append(list, n.List().Slice()...)
+			list = append(list, n.List.Slice()...)
 		} else {
 			list = append(list, n)
 		}
@@ -772,17 +772,17 @@ func (r *importReader) caseList(sw ir.Node) []ir.Node {
 	cases := make([]ir.Node, r.uint64())
 	for i := range cases {
 		cas := ir.NewCaseStmt(r.pos(), nil, nil)
-		cas.PtrList().Set(r.stmtList())
+		cas.List.Set(r.stmtList())
 		if namedTypeSwitch {
 			// Note: per-case variables will have distinct, dotted
 			// names after import. That's okay: swt.go only needs
 			// Sym for diagnostics anyway.
 			caseVar := ir.NewNameAt(cas.Pos(), r.ident())
 			declare(caseVar, dclcontext)
-			cas.PtrRlist().Set1(caseVar)
-			caseVar.Defn = sw.(*ir.SwitchStmt).Left()
+			cas.Vars.Set1(caseVar)
+			caseVar.Defn = sw.(*ir.SwitchStmt).Tag
 		}
-		cas.PtrBody().Set(r.stmtList())
+		cas.Body.Set(r.stmtList())
 		cases[i] = cas
 	}
 	return cases
@@ -867,7 +867,7 @@ func (r *importReader) node() ir.Node {
 		savedlineno := base.Pos
 		base.Pos = r.pos()
 		n := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(r.typ()).(ir.Ntype), nil)
-		n.PtrList().Set(r.elemList()) // special handling of field names
+		n.List.Set(r.elemList()) // special handling of field names
 		base.Pos = savedlineno
 		return n
 
@@ -876,7 +876,7 @@ func (r *importReader) node() ir.Node {
 
 	case ir.OCOMPLIT:
 		n := ir.NewCompLitExpr(r.pos(), ir.OCOMPLIT, ir.TypeNode(r.typ()).(ir.Ntype), nil)
-		n.PtrList().Set(r.exprList())
+		n.List.Set(r.exprList())
 		return n
 
 	case ir.OKEY:
@@ -931,9 +931,9 @@ func (r *importReader) node() ir.Node {
 
 	case ir.OCOPY, ir.OCOMPLEX, ir.OREAL, ir.OIMAG, ir.OAPPEND, ir.OCAP, ir.OCLOSE, ir.ODELETE, ir.OLEN, ir.OMAKE, ir.ONEW, ir.OPANIC, ir.ORECOVER, ir.OPRINT, ir.OPRINTN:
 		n := builtinCall(r.pos(), op)
-		n.PtrList().Set(r.exprList())
+		n.Args.Set(r.exprList())
 		if op == ir.OAPPEND {
-			n.SetIsDDD(r.bool())
+			n.IsDDD = r.bool()
 		}
 		return n
 
@@ -943,15 +943,15 @@ func (r *importReader) node() ir.Node {
 	case ir.OCALL:
 		n := ir.NewCallExpr(r.pos(), ir.OCALL, nil, nil)
 		n.PtrInit().Set(r.stmtList())
-		n.SetLeft(r.expr())
-		n.PtrList().Set(r.exprList())
-		n.SetIsDDD(r.bool())
+		n.X = r.expr()
+		n.Args.Set(r.exprList())
+		n.IsDDD = r.bool()
 		return n
 
 	case ir.OMAKEMAP, ir.OMAKECHAN, ir.OMAKESLICE:
 		n := builtinCall(r.pos(), ir.OMAKE)
-		n.PtrList().Append(ir.TypeNode(r.typ()))
-		n.PtrList().Append(r.exprList()...)
+		n.Args.Append(ir.TypeNode(r.typ()))
+		n.Args.Append(r.exprList()...)
 		return n
 
 	// unary expressions
@@ -1006,13 +1006,13 @@ func (r *importReader) node() ir.Node {
 
 	case ir.OASOP:
 		n := ir.NewAssignOpStmt(r.pos(), ir.OXXX, nil, nil)
-		n.SetSubOp(r.op())
-		n.SetLeft(r.expr())
+		n.AsOp = r.op()
+		n.X = r.expr()
 		if !r.bool() {
-			n.SetRight(nodintconst(1))
-			n.SetImplicit(true)
+			n.Y = nodintconst(1)
+			n.IncDec = true
 		} else {
-			n.SetRight(r.expr())
+			n.Y = r.expr()
 		}
 		return n
 
@@ -1021,13 +1021,13 @@ func (r *importReader) node() ir.Node {
 
 	case ir.OAS2:
 		n := ir.NewAssignListStmt(r.pos(), ir.OAS2, nil, nil)
-		n.PtrList().Set(r.exprList())
-		n.PtrRlist().Set(r.exprList())
+		n.Lhs.Set(r.exprList())
+		n.Rhs.Set(r.exprList())
 		return n
 
 	case ir.ORETURN:
 		n := ir.NewReturnStmt(r.pos(), nil)
-		n.PtrList().Set(r.exprList())
+		n.Results.Set(r.exprList())
 		return n
 
 	// case ORETJMP:
@@ -1039,40 +1039,40 @@ func (r *importReader) node() ir.Node {
 	case ir.OIF:
 		n := ir.NewIfStmt(r.pos(), nil, nil, nil)
 		n.PtrInit().Set(r.stmtList())
-		n.SetLeft(r.expr())
-		n.PtrBody().Set(r.stmtList())
-		n.PtrRlist().Set(r.stmtList())
+		n.Cond = r.expr()
+		n.Body.Set(r.stmtList())
+		n.Else.Set(r.stmtList())
 		return n
 
 	case ir.OFOR:
 		n := ir.NewForStmt(r.pos(), nil, nil, nil, nil)
 		n.PtrInit().Set(r.stmtList())
 		left, right := r.exprsOrNil()
-		n.SetLeft(left)
-		n.SetRight(right)
-		n.PtrBody().Set(r.stmtList())
+		n.Cond = left
+		n.Post = right
+		n.Body.Set(r.stmtList())
 		return n
 
 	case ir.ORANGE:
 		n := ir.NewRangeStmt(r.pos(), nil, nil, nil)
-		n.PtrList().Set(r.stmtList())
-		n.SetRight(r.expr())
-		n.PtrBody().Set(r.stmtList())
+		n.Vars.Set(r.stmtList())
+		n.X = r.expr()
+		n.Body.Set(r.stmtList())
 		return n
 
 	case ir.OSELECT:
 		n := ir.NewSelectStmt(r.pos(), nil)
 		n.PtrInit().Set(r.stmtList())
 		r.exprsOrNil() // TODO(rsc): Delete (and fix exporter). These are always nil.
-		n.PtrList().Set(r.caseList(n))
+		n.Cases.Set(r.caseList(n))
 		return n
 
 	case ir.OSWITCH:
 		n := ir.NewSwitchStmt(r.pos(), nil, nil)
 		n.PtrInit().Set(r.stmtList())
 		left, _ := r.exprsOrNil()
-		n.SetLeft(left)
-		n.PtrList().Set(r.caseList(n))
+		n.Tag = left
+		n.Cases.Set(r.caseList(n))
 		return n
 
 	// case OCASE:
diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index 1c15ce1318..fbc88411cc 100644
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -45,7 +45,7 @@ func fninit() *ir.Name {
 		if n.Op() == ir.ONONAME {
 			continue
 		}
-		if n.Op() != ir.ONAME || n.(*ir.Name).Class() != ir.PEXTERN {
+		if n.Op() != ir.ONAME || n.(*ir.Name).Class_ != ir.PEXTERN {
 			base.Fatalf("bad inittask: %v", n)
 		}
 		deps = append(deps, n.(*ir.Name).Sym().Linksym())
@@ -62,7 +62,7 @@ func fninit() *ir.Name {
 		fn.Dcl = append(fn.Dcl, initTodo.Dcl...)
 		initTodo.Dcl = nil
 
-		fn.PtrBody().Set(nf)
+		fn.Body.Set(nf)
 		funcbody()
 
 		typecheckFunc(fn)
@@ -83,8 +83,8 @@ func fninit() *ir.Name {
 	// Record user init functions.
 	for _, fn := range Target.Inits {
 		// Skip init functions with empty bodies.
-		if fn.Body().Len() == 1 {
-			if stmt := fn.Body().First(); stmt.Op() == ir.OBLOCK && stmt.(*ir.BlockStmt).List().Len() == 0 {
+		if fn.Body.Len() == 1 {
+			if stmt := fn.Body.First(); stmt.Op() == ir.OBLOCK && stmt.(*ir.BlockStmt).List.Len() == 0 {
 				continue
 			}
 		}
@@ -99,7 +99,7 @@ func fninit() *ir.Name {
 	sym := lookup(".inittask")
 	task := NewName(sym)
 	task.SetType(types.Types[types.TUINT8]) // fake type
-	task.SetClass(ir.PEXTERN)
+	task.Class_ = ir.PEXTERN
 	sym.Def = task
 	lsym := sym.Linksym()
 	ot := 0
diff --git a/src/cmd/compile/internal/gc/initorder.go b/src/cmd/compile/internal/gc/initorder.go
index f99c6dd72c..ec3d7be45f 100644
--- a/src/cmd/compile/internal/gc/initorder.go
+++ b/src/cmd/compile/internal/gc/initorder.go
@@ -139,7 +139,7 @@ func (o *InitOrder) processAssign(n ir.Node) {
 		defn := dep.Defn
 		// Skip dependencies on functions (PFUNC) and
 		// variables already initialized (InitDone).
-		if dep.Class() != ir.PEXTERN || o.order[defn] == orderDone {
+		if dep.Class_ != ir.PEXTERN || o.order[defn] == orderDone {
 			continue
 		}
 		o.order[n]++
@@ -203,7 +203,7 @@ func (o *InitOrder) findInitLoopAndExit(n *ir.Name, path *[]*ir.Name) {
 	*path = append(*path, n)
 	for _, ref := range refers {
 		// Short-circuit variables that were initialized.
-		if ref.Class() == ir.PEXTERN && o.order[ref.Defn] == orderDone {
+		if ref.Class_ == ir.PEXTERN && o.order[ref.Defn] == orderDone {
 			continue
 		}
 
@@ -220,7 +220,7 @@ func reportInitLoopAndExit(l []*ir.Name) {
 	// the start.
 	i := -1
 	for j, n := range l {
-		if n.Class() == ir.PEXTERN && (i == -1 || n.Pos().Before(l[i].Pos())) {
+		if n.Class_ == ir.PEXTERN && (i == -1 || n.Pos().Before(l[i].Pos())) {
 			i = j
 		}
 	}
@@ -255,13 +255,13 @@ func collectDeps(n ir.Node, transitive bool) ir.NameSet {
 	switch n.Op() {
 	case ir.OAS:
 		n := n.(*ir.AssignStmt)
-		d.inspect(n.Right())
+		d.inspect(n.Y)
 	case ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV:
 		n := n.(*ir.AssignListStmt)
-		d.inspect(n.Rlist().First())
+		d.inspect(n.Rhs.First())
 	case ir.ODCLFUNC:
 		n := n.(*ir.Func)
-		d.inspectList(n.Body())
+		d.inspectList(n.Body)
 	default:
 		base.Fatalf("unexpected Op: %v", n.Op())
 	}
@@ -294,14 +294,14 @@ func (d *initDeps) visit(n ir.Node) {
 
 	case ir.ONAME:
 		n := n.(*ir.Name)
-		switch n.Class() {
+		switch n.Class_ {
 		case ir.PEXTERN, ir.PFUNC:
 			d.foundDep(n)
 		}
 
 	case ir.OCLOSURE:
 		n := n.(*ir.ClosureExpr)
-		d.inspectList(n.Func().Body())
+		d.inspectList(n.Func.Body)
 
 	case ir.ODOTMETH, ir.OCALLPART:
 		d.foundDep(methodExprName(n))
@@ -327,8 +327,8 @@ func (d *initDeps) foundDep(n *ir.Name) {
 		return
 	}
 	d.seen.Add(n)
-	if d.transitive && n.Class() == ir.PFUNC {
-		d.inspectList(n.Defn.(*ir.Func).Body())
+	if d.transitive && n.Class_ == ir.PFUNC {
+		d.inspectList(n.Defn.(*ir.Func).Body)
 	}
 }
 
@@ -360,10 +360,10 @@ func firstLHS(n ir.Node) *ir.Name {
 	switch n.Op() {
 	case ir.OAS:
 		n := n.(*ir.AssignStmt)
-		return n.Left().Name()
+		return n.X.Name()
 	case ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2RECV, ir.OAS2MAPR:
 		n := n.(*ir.AssignListStmt)
-		return n.List().First().Name()
+		return n.Lhs.First().Name()
 	}
 
 	base.Fatalf("unexpected Op: %v", n.Op())
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 7cb7946806..edb2c5bb42 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -196,7 +196,7 @@ func caninl(fn *ir.Func) {
 	}
 
 	// If fn has no body (is defined outside of Go), cannot inline it.
-	if fn.Body().Len() == 0 {
+	if fn.Body.Len() == 0 {
 		reason = "no function body"
 		return
 	}
@@ -206,10 +206,10 @@ func caninl(fn *ir.Func) {
 	}
 
 	n := fn.Nname
-	if n.Func().InlinabilityChecked() {
+	if n.Func.InlinabilityChecked() {
 		return
 	}
-	defer n.Func().SetInlinabilityChecked(true)
+	defer n.Func.SetInlinabilityChecked(true)
 
 	cc := int32(inlineExtraCallCost)
 	if base.Flag.LowerL == 4 {
@@ -235,14 +235,14 @@ func caninl(fn *ir.Func) {
 		return
 	}
 
-	n.Func().Inl = &ir.Inline{
+	n.Func.Inl = &ir.Inline{
 		Cost: inlineMaxBudget - visitor.budget,
-		Dcl:  pruneUnusedAutos(n.Defn.(*ir.Func).Func().Dcl, &visitor),
-		Body: ir.DeepCopyList(src.NoXPos, fn.Body().Slice()),
+		Dcl:  pruneUnusedAutos(n.Defn.(*ir.Func).Dcl, &visitor),
+		Body: ir.DeepCopyList(src.NoXPos, fn.Body.Slice()),
 	}
 
 	if base.Flag.LowerM > 1 {
-		fmt.Printf("%v: can inline %v with cost %d as: %v { %v }\n", ir.Line(fn), n, inlineMaxBudget-visitor.budget, fn.Type(), ir.AsNodes(n.Func().Inl.Body))
+		fmt.Printf("%v: can inline %v with cost %d as: %v { %v }\n", ir.Line(fn), n, inlineMaxBudget-visitor.budget, fn.Type(), ir.AsNodes(n.Func.Inl.Body))
 	} else if base.Flag.LowerM != 0 {
 		fmt.Printf("%v: can inline %v\n", ir.Line(fn), n)
 	}
@@ -257,10 +257,10 @@ func inlFlood(n *ir.Name, exportsym func(*ir.Name)) {
 	if n == nil {
 		return
 	}
-	if n.Op() != ir.ONAME || n.Class() != ir.PFUNC {
-		base.Fatalf("inlFlood: unexpected %v, %v, %v", n, n.Op(), n.Class())
+	if n.Op() != ir.ONAME || n.Class_ != ir.PFUNC {
+		base.Fatalf("inlFlood: unexpected %v, %v, %v", n, n.Op(), n.Class_)
 	}
-	fn := n.Func()
+	fn := n.Func
 	if fn == nil {
 		base.Fatalf("inlFlood: missing Func on %v", n)
 	}
@@ -285,7 +285,7 @@ func inlFlood(n *ir.Name, exportsym func(*ir.Name)) {
 
 		case ir.ONAME:
 			n := n.(*ir.Name)
-			switch n.Class() {
+			switch n.Class_ {
 			case ir.PFUNC:
 				inlFlood(n, exportsym)
 				exportsym(n)
@@ -348,9 +348,9 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 		// because getcaller{pc,sp} expect a pointer to the caller's first argument.
 		//
 		// runtime.throw is a "cheap call" like panic in normal code.
-		if n.Left().Op() == ir.ONAME {
-			name := n.Left().(*ir.Name)
-			if name.Class() == ir.PFUNC && isRuntimePkg(name.Sym().Pkg) {
+		if n.X.Op() == ir.ONAME {
+			name := n.X.(*ir.Name)
+			if name.Class_ == ir.PFUNC && isRuntimePkg(name.Sym().Pkg) {
 				fn := name.Sym().Name
 				if fn == "getcallerpc" || fn == "getcallersp" {
 					return errors.New("call to " + fn)
@@ -367,7 +367,7 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 			break
 		}
 
-		if fn := inlCallee(n.Left()); fn != nil && fn.Inl != nil {
+		if fn := inlCallee(n.X); fn != nil && fn.Inl != nil {
 			v.budget -= fn.Inl.Cost
 			break
 		}
@@ -378,12 +378,12 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 	// Call is okay if inlinable and we have the budget for the body.
 	case ir.OCALLMETH:
 		n := n.(*ir.CallExpr)
-		t := n.Left().Type()
+		t := n.X.Type()
 		if t == nil {
-			base.Fatalf("no function type for [%p] %+v\n", n.Left(), n.Left())
+			base.Fatalf("no function type for [%p] %+v\n", n.X, n.X)
 		}
-		if isRuntimePkg(n.Left().Sym().Pkg) {
-			fn := n.Left().Sym().Name
+		if isRuntimePkg(n.X.Sym().Pkg) {
+			fn := n.X.Sym().Name
 			if fn == "heapBits.nextArena" {
 				// Special case: explicitly allow
 				// mid-stack inlining of
@@ -393,7 +393,7 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 				break
 			}
 		}
-		if inlfn := methodExprName(n.Left()).Func(); inlfn.Inl != nil {
+		if inlfn := methodExprName(n.X).Func; inlfn.Inl != nil {
 			v.budget -= inlfn.Inl.Cost
 			break
 		}
@@ -431,35 +431,35 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 
 	case ir.OFOR, ir.OFORUNTIL:
 		n := n.(*ir.ForStmt)
-		if n.Sym() != nil {
+		if n.Label != nil {
 			return errors.New("labeled control")
 		}
 	case ir.OSWITCH:
 		n := n.(*ir.SwitchStmt)
-		if n.Sym() != nil {
+		if n.Label != nil {
 			return errors.New("labeled control")
 		}
 	// case ir.ORANGE, ir.OSELECT in "unhandled" above
 
 	case ir.OBREAK, ir.OCONTINUE:
 		n := n.(*ir.BranchStmt)
-		if n.Sym() != nil {
+		if n.Label != nil {
 			// Should have short-circuited due to labeled control error above.
 			base.Fatalf("unexpected labeled break/continue: %v", n)
 		}
 
 	case ir.OIF:
 		n := n.(*ir.IfStmt)
-		if ir.IsConst(n.Left(), constant.Bool) {
+		if ir.IsConst(n.Cond, constant.Bool) {
 			// This if and the condition cost nothing.
 			// TODO(rsc): It seems strange that we visit the dead branch.
 			if err := ir.DoList(n.Init(), v.do); err != nil {
 				return err
 			}
-			if err := ir.DoList(n.Body(), v.do); err != nil {
+			if err := ir.DoList(n.Body, v.do); err != nil {
 				return err
 			}
-			if err := ir.DoList(n.Rlist(), v.do); err != nil {
+			if err := ir.DoList(n.Else, v.do); err != nil {
 				return err
 			}
 			return nil
@@ -467,7 +467,7 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 
 	case ir.ONAME:
 		n := n.(*ir.Name)
-		if n.Class() == ir.PAUTO {
+		if n.Class_ == ir.PAUTO {
 			v.usedLocals[n] = true
 		}
 
@@ -526,8 +526,8 @@ func inlcalls(fn *ir.Func) {
 // Turn an OINLCALL into a statement.
 func inlconv2stmt(inlcall *ir.InlinedCallExpr) ir.Node {
 	n := ir.NewBlockStmt(inlcall.Pos(), nil)
-	n.SetList(inlcall.Init())
-	n.PtrList().AppendNodes(inlcall.PtrBody())
+	n.List = inlcall.Init()
+	n.List.AppendNodes(&inlcall.Body)
 	return n
 }
 
@@ -535,8 +535,8 @@ func inlconv2stmt(inlcall *ir.InlinedCallExpr) ir.Node {
 // The result of inlconv2expr MUST be assigned back to n, e.g.
 // 	n.Left = inlconv2expr(n.Left)
 func inlconv2expr(n *ir.InlinedCallExpr) ir.Node {
-	r := n.Rlist().First()
-	return initExpr(append(n.Init().Slice(), n.Body().Slice()...), r)
+	r := n.ReturnVars.First()
+	return initExpr(append(n.Init().Slice(), n.Body.Slice()...), r)
 }
 
 // Turn the rlist (with the return values) of the OINLCALL in
@@ -545,12 +545,12 @@ func inlconv2expr(n *ir.InlinedCallExpr) ir.Node {
 // order will be preserved. Used in return, oas2func and call
 // statements.
 func inlconv2list(n *ir.InlinedCallExpr) []ir.Node {
-	if n.Op() != ir.OINLCALL || n.Rlist().Len() == 0 {
+	if n.Op() != ir.OINLCALL || n.ReturnVars.Len() == 0 {
 		base.Fatalf("inlconv2list %+v\n", n)
 	}
 
-	s := n.Rlist().Slice()
-	s[0] = initExpr(append(n.Init().Slice(), n.Body().Slice()...), s[0])
+	s := n.ReturnVars.Slice()
+	s[0] = initExpr(append(n.Init().Slice(), n.Body.Slice()...), s[0])
 	return s
 }
 
@@ -575,10 +575,10 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.No
 	switch n.Op() {
 	case ir.ODEFER, ir.OGO:
 		n := n.(*ir.GoDeferStmt)
-		switch call := n.Left(); call.Op() {
+		switch call := n.Call; call.Op() {
 		case ir.OCALLFUNC, ir.OCALLMETH:
 			call := call.(*ir.CallExpr)
-			call.SetNoInline(true)
+			call.NoInline = true
 		}
 
 	// TODO do them here (or earlier),
@@ -589,7 +589,7 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.No
 		// Prevent inlining some reflect.Value methods when using checkptr,
 		// even when package reflect was compiled without it (#35073).
 		n := n.(*ir.CallExpr)
-		if s := n.Left().Sym(); base.Debug.Checkptr != 0 && isReflectPkg(s.Pkg) && (s.Name == "Value.UnsafeAddr" || s.Name == "Value.Pointer") {
+		if s := n.X.Sym(); base.Debug.Checkptr != 0 && isReflectPkg(s.Pkg) && (s.Name == "Value.UnsafeAddr" || s.Name == "Value.Pointer") {
 			return n
 		}
 	}
@@ -600,8 +600,8 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.No
 
 	if as := n; as.Op() == ir.OAS2FUNC {
 		as := as.(*ir.AssignListStmt)
-		if as.Rlist().First().Op() == ir.OINLCALL {
-			as.PtrRlist().Set(inlconv2list(as.Rlist().First().(*ir.InlinedCallExpr)))
+		if as.Rhs.First().Op() == ir.OINLCALL {
+			as.Rhs.Set(inlconv2list(as.Rhs.First().(*ir.InlinedCallExpr)))
 			as.SetOp(ir.OAS2)
 			as.SetTypecheck(0)
 			n = typecheck(as, ctxStmt)
@@ -614,7 +614,7 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.No
 	switch n.Op() {
 	case ir.OCALLFUNC, ir.OCALLMETH:
 		n := n.(*ir.CallExpr)
-		if n.NoInline() {
+		if n.NoInline {
 			return n
 		}
 	}
@@ -624,27 +624,27 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.No
 	case ir.OCALLFUNC:
 		call = n.(*ir.CallExpr)
 		if base.Flag.LowerM > 3 {
-			fmt.Printf("%v:call to func %+v\n", ir.Line(n), call.Left())
+			fmt.Printf("%v:call to func %+v\n", ir.Line(n), call.X)
 		}
 		if IsIntrinsicCall(call) {
 			break
 		}
-		if fn := inlCallee(call.Left()); fn != nil && fn.Inl != nil {
+		if fn := inlCallee(call.X); fn != nil && fn.Inl != nil {
 			n = mkinlcall(call, fn, maxCost, inlMap, edit)
 		}
 
 	case ir.OCALLMETH:
 		call = n.(*ir.CallExpr)
 		if base.Flag.LowerM > 3 {
-			fmt.Printf("%v:call to meth %v\n", ir.Line(n), call.Left().(*ir.SelectorExpr).Sel)
+			fmt.Printf("%v:call to meth %v\n", ir.Line(n), call.X.(*ir.SelectorExpr).Sel)
 		}
 
 		// typecheck should have resolved ODOTMETH->type, whose nname points to the actual function.
-		if call.Left().Type() == nil {
-			base.Fatalf("no function type for [%p] %+v\n", call.Left(), call.Left())
+		if call.X.Type() == nil {
+			base.Fatalf("no function type for [%p] %+v\n", call.X, call.X)
 		}
 
-		n = mkinlcall(call, methodExprName(call.Left()).Func(), maxCost, inlMap, edit)
+		n = mkinlcall(call, methodExprName(call.X).Func, maxCost, inlMap, edit)
 	}
 
 	base.Pos = lno
@@ -681,15 +681,15 @@ func inlCallee(fn ir.Node) *ir.Func {
 		if n == nil || !types.Identical(n.Type().Recv().Type, fn.T) {
 			return nil
 		}
-		return n.Func()
+		return n.Func
 	case ir.ONAME:
 		fn := fn.(*ir.Name)
-		if fn.Class() == ir.PFUNC {
-			return fn.Func()
+		if fn.Class_ == ir.PFUNC {
+			return fn.Func
 		}
 	case ir.OCLOSURE:
 		fn := fn.(*ir.ClosureExpr)
-		c := fn.Func()
+		c := fn.Func
 		caninl(c)
 		return c
 	}
@@ -699,7 +699,7 @@ func inlCallee(fn ir.Node) *ir.Func {
 func staticValue(n ir.Node) ir.Node {
 	for {
 		if n.Op() == ir.OCONVNOP {
-			n = n.(*ir.ConvExpr).Left()
+			n = n.(*ir.ConvExpr).X
 			continue
 		}
 
@@ -719,7 +719,7 @@ func staticValue1(nn ir.Node) ir.Node {
 		return nil
 	}
 	n := nn.(*ir.Name)
-	if n.Class() != ir.PAUTO || n.Name().Addrtaken() {
+	if n.Class_ != ir.PAUTO || n.Name().Addrtaken() {
 		return nil
 	}
 
@@ -733,12 +733,12 @@ FindRHS:
 	switch defn.Op() {
 	case ir.OAS:
 		defn := defn.(*ir.AssignStmt)
-		rhs = defn.Right()
+		rhs = defn.Y
 	case ir.OAS2:
 		defn := defn.(*ir.AssignListStmt)
-		for i, lhs := range defn.List().Slice() {
+		for i, lhs := range defn.Lhs.Slice() {
 			if lhs == n {
-				rhs = defn.Rlist().Index(i)
+				rhs = defn.Rhs.Index(i)
 				break FindRHS
 			}
 		}
@@ -775,12 +775,12 @@ func reassigned(name *ir.Name) bool {
 		switch n.Op() {
 		case ir.OAS:
 			n := n.(*ir.AssignStmt)
-			if n.Left() == name && n != name.Defn {
+			if n.X == name && n != name.Defn {
 				return true
 			}
 		case ir.OAS2, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2DOTTYPE, ir.OAS2RECV, ir.OSELRECV2:
 			n := n.(*ir.AssignListStmt)
-			for _, p := range n.List().Slice() {
+			for _, p := range n.Lhs.Slice() {
 				if p == name && n != name.Defn {
 					return true
 				}
@@ -887,11 +887,11 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 	// inlconv2expr or inlconv2list). Make sure to preserve these,
 	// if necessary (#42703).
 	if n.Op() == ir.OCALLFUNC {
-		callee := n.Left()
+		callee := n.X
 		for callee.Op() == ir.OCONVNOP {
 			conv := callee.(*ir.ConvExpr)
 			ninit.AppendNodes(conv.PtrInit())
-			callee = conv.Left()
+			callee = conv.X
 		}
 		if callee.Op() != ir.ONAME && callee.Op() != ir.OCLOSURE && callee.Op() != ir.OMETHEXPR {
 			base.Fatalf("unexpected callee expression: %v", callee)
@@ -944,7 +944,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 		if ln.Op() != ir.ONAME {
 			continue
 		}
-		if ln.Class() == ir.PPARAMOUT { // return values handled below.
+		if ln.Class_ == ir.PPARAMOUT { // return values handled below.
 			continue
 		}
 		if isParamStackCopy(ln) { // ignore the on-stack copy of a parameter that moved to the heap
@@ -957,7 +957,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 		inlf := typecheck(inlvar(ln), ctxExpr)
 		inlvars[ln] = inlf
 		if base.Flag.GenDwarfInl > 0 {
-			if ln.Class() == ir.PPARAM {
+			if ln.Class_ == ir.PPARAM {
 				inlf.Name().SetInlFormal(true)
 			} else {
 				inlf.Name().SetInlLocal(true)
@@ -1010,54 +1010,54 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 
 	// Assign arguments to the parameters' temp names.
 	as := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-	as.SetColas(true)
+	as.Def = true
 	if n.Op() == ir.OCALLMETH {
-		sel := n.Left().(*ir.SelectorExpr)
-		if sel.Left() == nil {
+		sel := n.X.(*ir.SelectorExpr)
+		if sel.X == nil {
 			base.Fatalf("method call without receiver: %+v", n)
 		}
-		as.PtrRlist().Append(sel.Left())
+		as.Rhs.Append(sel.X)
 	}
-	as.PtrRlist().Append(n.List().Slice()...)
+	as.Rhs.Append(n.Args.Slice()...)
 
 	// For non-dotted calls to variadic functions, we assign the
 	// variadic parameter's temp name separately.
 	var vas *ir.AssignStmt
 
 	if recv := fn.Type().Recv(); recv != nil {
-		as.PtrList().Append(inlParam(recv, as, inlvars))
+		as.Lhs.Append(inlParam(recv, as, inlvars))
 	}
 	for _, param := range fn.Type().Params().Fields().Slice() {
 		// For ordinary parameters or variadic parameters in
 		// dotted calls, just add the variable to the
 		// assignment list, and we're done.
-		if !param.IsDDD() || n.IsDDD() {
-			as.PtrList().Append(inlParam(param, as, inlvars))
+		if !param.IsDDD() || n.IsDDD {
+			as.Lhs.Append(inlParam(param, as, inlvars))
 			continue
 		}
 
 		// Otherwise, we need to collect the remaining values
 		// to pass as a slice.
 
-		x := as.List().Len()
-		for as.List().Len() < as.Rlist().Len() {
-			as.PtrList().Append(argvar(param.Type, as.List().Len()))
+		x := as.Lhs.Len()
+		for as.Lhs.Len() < as.Rhs.Len() {
+			as.Lhs.Append(argvar(param.Type, as.Lhs.Len()))
 		}
-		varargs := as.List().Slice()[x:]
+		varargs := as.Lhs.Slice()[x:]
 
 		vas = ir.NewAssignStmt(base.Pos, nil, nil)
-		vas.SetLeft(inlParam(param, vas, inlvars))
+		vas.X = inlParam(param, vas, inlvars)
 		if len(varargs) == 0 {
-			vas.SetRight(nodnil())
-			vas.Right().SetType(param.Type)
+			vas.Y = nodnil()
+			vas.Y.SetType(param.Type)
 		} else {
 			lit := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(param.Type).(ir.Ntype), nil)
-			lit.PtrList().Set(varargs)
-			vas.SetRight(lit)
+			lit.List.Set(varargs)
+			vas.Y = lit
 		}
 	}
 
-	if as.Rlist().Len() != 0 {
+	if as.Rhs.Len() != 0 {
 		ninit.Append(typecheck(as, ctxStmt))
 	}
 
@@ -1093,7 +1093,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 	// Note issue 28603.
 	inlMark := ir.NewInlineMarkStmt(base.Pos, types.BADWIDTH)
 	inlMark.SetPos(n.Pos().WithIsStmt())
-	inlMark.SetOffset(int64(newIndex))
+	inlMark.Index = int64(newIndex)
 	ninit.Append(inlMark)
 
 	if base.Flag.GenDwarfInl > 0 {
@@ -1130,8 +1130,8 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 
 	call := ir.NewInlinedCallExpr(base.Pos, nil, nil)
 	call.PtrInit().Set(ninit.Slice())
-	call.PtrBody().Set(body)
-	call.PtrRlist().Set(retvars)
+	call.Body.Set(body)
+	call.ReturnVars.Set(retvars)
 	call.SetType(n.Type())
 	call.SetTypecheck(1)
 
@@ -1160,7 +1160,7 @@ func inlvar(var_ ir.Node) ir.Node {
 
 	n := NewName(var_.Sym())
 	n.SetType(var_.Type())
-	n.SetClass(ir.PAUTO)
+	n.Class_ = ir.PAUTO
 	n.SetUsed(true)
 	n.Curfn = Curfn // the calling function, not the called one
 	n.SetAddrtaken(var_.Name().Addrtaken())
@@ -1173,7 +1173,7 @@ func inlvar(var_ ir.Node) ir.Node {
 func retvar(t *types.Field, i int) ir.Node {
 	n := NewName(lookupN("~R", i))
 	n.SetType(t.Type)
-	n.SetClass(ir.PAUTO)
+	n.Class_ = ir.PAUTO
 	n.SetUsed(true)
 	n.Curfn = Curfn // the calling function, not the called one
 	Curfn.Dcl = append(Curfn.Dcl, n)
@@ -1185,7 +1185,7 @@ func retvar(t *types.Field, i int) ir.Node {
 func argvar(t *types.Type, i int) ir.Node {
 	n := NewName(lookupN("~arg", i))
 	n.SetType(t.Elem())
-	n.SetClass(ir.PAUTO)
+	n.Class_ = ir.PAUTO
 	n.SetUsed(true)
 	n.Curfn = Curfn // the calling function, not the called one
 	Curfn.Dcl = append(Curfn.Dcl, n)
@@ -1277,19 +1277,19 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 		// this return is guaranteed to belong to the current inlined function.
 		n := n.(*ir.ReturnStmt)
 		init := subst.list(n.Init())
-		if len(subst.retvars) != 0 && n.List().Len() != 0 {
+		if len(subst.retvars) != 0 && n.Results.Len() != 0 {
 			as := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
 
 			// Make a shallow copy of retvars.
 			// Otherwise OINLCALL.Rlist will be the same list,
 			// and later walk and typecheck may clobber it.
 			for _, n := range subst.retvars {
-				as.PtrList().Append(n)
+				as.Lhs.Append(n)
 			}
-			as.PtrRlist().Set(subst.list(n.List()))
+			as.Rhs.Set(subst.list(n.Results))
 
 			if subst.delayretvars {
-				for _, n := range as.List().Slice() {
+				for _, n := range as.Lhs.Slice() {
 					as.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, n))
 					n.Name().Defn = as
 				}
@@ -1306,8 +1306,8 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 		m := ir.Copy(n).(*ir.BranchStmt)
 		m.SetPos(subst.updatedPos(m.Pos()))
 		m.PtrInit().Set(nil)
-		p := fmt.Sprintf("%s·%d", n.Sym().Name, inlgen)
-		m.SetSym(lookup(p))
+		p := fmt.Sprintf("%s·%d", n.Label.Name, inlgen)
+		m.Label = lookup(p)
 		return m
 
 	case ir.OLABEL:
@@ -1315,8 +1315,8 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 		m := ir.Copy(n).(*ir.LabelStmt)
 		m.SetPos(subst.updatedPos(m.Pos()))
 		m.PtrInit().Set(nil)
-		p := fmt.Sprintf("%s·%d", n.Sym().Name, inlgen)
-		m.SetSym(lookup(p))
+		p := fmt.Sprintf("%s·%d", n.Label.Name, inlgen)
+		m.Label = lookup(p)
 		return m
 	}
 
@@ -1345,7 +1345,7 @@ func (subst *inlsubst) updatedPos(xpos src.XPos) src.XPos {
 func pruneUnusedAutos(ll []*ir.Name, vis *hairyVisitor) []*ir.Name {
 	s := make([]*ir.Name, 0, len(ll))
 	for _, n := range ll {
-		if n.Class() == ir.PAUTO {
+		if n.Class_ == ir.PAUTO {
 			if _, found := vis.usedLocals[n]; !found {
 				continue
 			}
@@ -1359,7 +1359,7 @@ func pruneUnusedAutos(ll []*ir.Name, vis *hairyVisitor) []*ir.Name {
 // concrete-type method calls where applicable.
 func devirtualize(fn *ir.Func) {
 	Curfn = fn
-	ir.VisitList(fn.Body(), func(n ir.Node) {
+	ir.VisitList(fn.Body, func(n ir.Node) {
 		if n.Op() == ir.OCALLINTER {
 			devirtualizeCall(n.(*ir.CallExpr))
 		}
@@ -1367,21 +1367,21 @@ func devirtualize(fn *ir.Func) {
 }
 
 func devirtualizeCall(call *ir.CallExpr) {
-	sel := call.Left().(*ir.SelectorExpr)
-	r := staticValue(sel.Left())
+	sel := call.X.(*ir.SelectorExpr)
+	r := staticValue(sel.X)
 	if r.Op() != ir.OCONVIFACE {
 		return
 	}
 	recv := r.(*ir.ConvExpr)
 
-	typ := recv.Left().Type()
+	typ := recv.X.Type()
 	if typ.IsInterface() {
 		return
 	}
 
-	dt := ir.NewTypeAssertExpr(sel.Pos(), sel.Left(), nil)
+	dt := ir.NewTypeAssertExpr(sel.Pos(), sel.X, nil)
 	dt.SetType(typ)
-	x := typecheck(ir.NewSelectorExpr(sel.Pos(), ir.OXDOT, dt, sel.Sym()), ctxExpr|ctxCallee)
+	x := typecheck(ir.NewSelectorExpr(sel.Pos(), ir.OXDOT, dt, sel.Sel), ctxExpr|ctxCallee)
 	switch x.Op() {
 	case ir.ODOTMETH:
 		x := x.(*ir.SelectorExpr)
@@ -1389,7 +1389,7 @@ func devirtualizeCall(call *ir.CallExpr) {
 			base.WarnfAt(call.Pos(), "devirtualizing %v to %v", sel, typ)
 		}
 		call.SetOp(ir.OCALLMETH)
-		call.SetLeft(x)
+		call.X = x
 	case ir.ODOTINTER:
 		// Promoted method from embedded interface-typed field (#42279).
 		x := x.(*ir.SelectorExpr)
@@ -1397,7 +1397,7 @@ func devirtualizeCall(call *ir.CallExpr) {
 			base.WarnfAt(call.Pos(), "partially devirtualizing %v to %v", sel, typ)
 		}
 		call.SetOp(ir.OCALLINTER)
-		call.SetLeft(x)
+		call.X = x
 	default:
 		// TODO(mdempsky): Turn back into Fatalf after more testing.
 		if base.Flag.LowerM != 0 {
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 94b4e0e674..c1cc7ed377 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -272,7 +272,7 @@ func Main(archInit func(*Arch)) {
 	for _, n := range Target.Decls {
 		if n.Op() == ir.ODCLFUNC {
 			n := n.(*ir.Func)
-			if n.Func().OClosure != nil {
+			if n.OClosure != nil {
 				Curfn = n
 				transformclosure(n)
 			}
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 4b7a22e654..728c4b1316 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -167,7 +167,7 @@ func (p *noder) funcBody(fn *ir.Func, block *syntax.BlockStmt) {
 		if body == nil {
 			body = []ir.Node{ir.NewBlockStmt(base.Pos, nil)}
 		}
-		fn.PtrBody().Set(body)
+		fn.Body.Set(body)
 
 		base.Pos = p.makeXPos(block.Rbrace)
 		fn.Endlineno = base.Pos
@@ -650,13 +650,13 @@ func (p *noder) expr(expr syntax.Expr) ir.Node {
 	case *syntax.CompositeLit:
 		n := ir.NewCompLitExpr(p.pos(expr), ir.OCOMPLIT, nil, nil)
 		if expr.Type != nil {
-			n.SetRight(p.expr(expr.Type))
+			n.Ntype = ir.Node(p.expr(expr.Type)).(ir.Ntype)
 		}
 		l := p.exprs(expr.ElemList)
 		for i, e := range l {
 			l[i] = p.wrapname(expr.ElemList[i], e)
 		}
-		n.PtrList().Set(l)
+		n.List.Set(l)
 		base.Pos = p.makeXPos(expr.Rbrace)
 		return n
 	case *syntax.KeyValueExpr:
@@ -719,8 +719,8 @@ func (p *noder) expr(expr syntax.Expr) ir.Node {
 		return ir.NewBinaryExpr(pos, op, x, y)
 	case *syntax.CallExpr:
 		n := ir.NewCallExpr(p.pos(expr), ir.OCALL, p.expr(expr.Fun), nil)
-		n.PtrList().Set(p.exprs(expr.ArgList))
-		n.SetIsDDD(expr.HasDots)
+		n.Args.Set(p.exprs(expr.ArgList))
+		n.IsDDD = expr.HasDots
 		return n
 
 	case *syntax.ArrayType:
@@ -968,10 +968,10 @@ func (p *noder) stmtsFall(stmts []syntax.Stmt, fallOK bool) []ir.Node {
 	for i, stmt := range stmts {
 		s := p.stmtFall(stmt, fallOK && i+1 == len(stmts))
 		if s == nil {
-		} else if s.Op() == ir.OBLOCK && s.(*ir.BlockStmt).List().Len() > 0 {
+		} else if s.Op() == ir.OBLOCK && s.(*ir.BlockStmt).List.Len() > 0 {
 			// Inline non-empty block.
 			// Empty blocks must be preserved for checkreturn.
-			nodes = append(nodes, s.(*ir.BlockStmt).List().Slice()...)
+			nodes = append(nodes, s.(*ir.BlockStmt).List.Slice()...)
 		} else {
 			nodes = append(nodes, s)
 		}
@@ -1006,23 +1006,23 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) ir.Node {
 	case *syntax.AssignStmt:
 		if stmt.Op != 0 && stmt.Op != syntax.Def {
 			n := ir.NewAssignOpStmt(p.pos(stmt), p.binOp(stmt.Op), p.expr(stmt.Lhs), p.expr(stmt.Rhs))
-			n.SetImplicit(stmt.Rhs == syntax.ImplicitOne)
+			n.IncDec = stmt.Rhs == syntax.ImplicitOne
 			return n
 		}
 
 		rhs := p.exprList(stmt.Rhs)
 		if list, ok := stmt.Lhs.(*syntax.ListExpr); ok && len(list.ElemList) != 1 || len(rhs) != 1 {
 			n := ir.NewAssignListStmt(p.pos(stmt), ir.OAS2, nil, nil)
-			n.SetColas(stmt.Op == syntax.Def)
-			n.PtrList().Set(p.assignList(stmt.Lhs, n, n.Colas()))
-			n.PtrRlist().Set(rhs)
+			n.Def = stmt.Op == syntax.Def
+			n.Lhs.Set(p.assignList(stmt.Lhs, n, n.Def))
+			n.Rhs.Set(rhs)
 			return n
 		}
 
 		n := ir.NewAssignStmt(p.pos(stmt), nil, nil)
-		n.SetColas(stmt.Op == syntax.Def)
-		n.SetLeft(p.assignList(stmt.Lhs, n, n.Colas())[0])
-		n.SetRight(rhs[0])
+		n.Def = stmt.Op == syntax.Def
+		n.X = p.assignList(stmt.Lhs, n, n.Def)[0]
+		n.Y = rhs[0]
 		return n
 
 	case *syntax.BranchStmt:
@@ -1064,13 +1064,13 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) ir.Node {
 			results = p.exprList(stmt.Results)
 		}
 		n := ir.NewReturnStmt(p.pos(stmt), nil)
-		n.PtrList().Set(results)
-		if n.List().Len() == 0 && Curfn != nil {
+		n.Results.Set(results)
+		if n.Results.Len() == 0 && Curfn != nil {
 			for _, ln := range Curfn.Dcl {
-				if ln.Class() == ir.PPARAM {
+				if ln.Class_ == ir.PPARAM {
 					continue
 				}
-				if ln.Class() != ir.PPARAMOUT {
+				if ln.Class_ != ir.PPARAMOUT {
 					break
 				}
 				if ln.Sym().Def != ln {
@@ -1163,16 +1163,16 @@ func (p *noder) ifStmt(stmt *syntax.IfStmt) ir.Node {
 		n.PtrInit().Set1(p.stmt(stmt.Init))
 	}
 	if stmt.Cond != nil {
-		n.SetLeft(p.expr(stmt.Cond))
+		n.Cond = p.expr(stmt.Cond)
 	}
-	n.PtrBody().Set(p.blockStmt(stmt.Then))
+	n.Body.Set(p.blockStmt(stmt.Then))
 	if stmt.Else != nil {
 		e := p.stmt(stmt.Else)
 		if e.Op() == ir.OBLOCK {
 			e := e.(*ir.BlockStmt)
-			n.PtrRlist().Set(e.List().Slice())
+			n.Else.Set(e.List.Slice())
 		} else {
-			n.PtrRlist().Set1(e)
+			n.Else.Set1(e)
 		}
 	}
 	p.closeAnotherScope()
@@ -1188,10 +1188,10 @@ func (p *noder) forStmt(stmt *syntax.ForStmt) ir.Node {
 
 		n := ir.NewRangeStmt(p.pos(r), nil, p.expr(r.X), nil)
 		if r.Lhs != nil {
-			n.SetColas(r.Def)
-			n.PtrList().Set(p.assignList(r.Lhs, n, n.Colas()))
+			n.Def = r.Def
+			n.Vars.Set(p.assignList(r.Lhs, n, n.Def))
 		}
-		n.PtrBody().Set(p.blockStmt(stmt.Body))
+		n.Body.Set(p.blockStmt(stmt.Body))
 		p.closeAnotherScope()
 		return n
 	}
@@ -1201,12 +1201,12 @@ func (p *noder) forStmt(stmt *syntax.ForStmt) ir.Node {
 		n.PtrInit().Set1(p.stmt(stmt.Init))
 	}
 	if stmt.Cond != nil {
-		n.SetLeft(p.expr(stmt.Cond))
+		n.Cond = p.expr(stmt.Cond)
 	}
 	if stmt.Post != nil {
-		n.SetRight(p.stmt(stmt.Post))
+		n.Post = p.stmt(stmt.Post)
 	}
-	n.PtrBody().Set(p.blockStmt(stmt.Body))
+	n.Body.Set(p.blockStmt(stmt.Body))
 	p.closeAnotherScope()
 	return n
 }
@@ -1218,14 +1218,14 @@ func (p *noder) switchStmt(stmt *syntax.SwitchStmt) ir.Node {
 		n.PtrInit().Set1(p.stmt(stmt.Init))
 	}
 	if stmt.Tag != nil {
-		n.SetLeft(p.expr(stmt.Tag))
+		n.Tag = p.expr(stmt.Tag)
 	}
 
 	var tswitch *ir.TypeSwitchGuard
-	if l := n.Left(); l != nil && l.Op() == ir.OTYPESW {
+	if l := n.Tag; l != nil && l.Op() == ir.OTYPESW {
 		tswitch = l.(*ir.TypeSwitchGuard)
 	}
-	n.PtrList().Set(p.caseClauses(stmt.Body, tswitch, stmt.Rbrace))
+	n.Cases.Set(p.caseClauses(stmt.Body, tswitch, stmt.Rbrace))
 
 	p.closeScope(stmt.Rbrace)
 	return n
@@ -1242,12 +1242,12 @@ func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *ir.TypeSwitch
 
 		n := ir.NewCaseStmt(p.pos(clause), nil, nil)
 		if clause.Cases != nil {
-			n.PtrList().Set(p.exprList(clause.Cases))
+			n.List.Set(p.exprList(clause.Cases))
 		}
-		if tswitch != nil && tswitch.Left() != nil {
-			nn := NewName(tswitch.Left().Sym())
+		if tswitch != nil && tswitch.Tag != nil {
+			nn := NewName(tswitch.Tag.Sym())
 			declare(nn, dclcontext)
-			n.PtrRlist().Set1(nn)
+			n.Vars.Set1(nn)
 			// keep track of the instances for reporting unused
 			nn.Defn = tswitch
 		}
@@ -1263,8 +1263,8 @@ func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *ir.TypeSwitch
 			body = body[:len(body)-1]
 		}
 
-		n.PtrBody().Set(p.stmtsFall(body, true))
-		if l := n.Body().Len(); l > 0 && n.Body().Index(l-1).Op() == ir.OFALL {
+		n.Body.Set(p.stmtsFall(body, true))
+		if l := n.Body.Len(); l > 0 && n.Body.Index(l-1).Op() == ir.OFALL {
 			if tswitch != nil {
 				base.Errorf("cannot fallthrough in type switch")
 			}
@@ -1283,7 +1283,7 @@ func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *ir.TypeSwitch
 
 func (p *noder) selectStmt(stmt *syntax.SelectStmt) ir.Node {
 	n := ir.NewSelectStmt(p.pos(stmt), nil)
-	n.PtrList().Set(p.commClauses(stmt.Body, stmt.Rbrace))
+	n.Cases.Set(p.commClauses(stmt.Body, stmt.Rbrace))
 	return n
 }
 
@@ -1298,9 +1298,9 @@ func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []i
 
 		n := ir.NewCaseStmt(p.pos(clause), nil, nil)
 		if clause.Comm != nil {
-			n.PtrList().Set1(p.stmt(clause.Comm))
+			n.List.Set1(p.stmt(clause.Comm))
 		}
-		n.PtrBody().Set(p.stmts(clause.Body))
+		n.Body.Set(p.stmts(clause.Body))
 		nodes = append(nodes, n)
 	}
 	if len(clauses) > 0 {
@@ -1321,16 +1321,16 @@ func (p *noder) labeledStmt(label *syntax.LabeledStmt, fallOK bool) ir.Node {
 			switch ls.Op() {
 			case ir.OFOR:
 				ls := ls.(*ir.ForStmt)
-				ls.SetSym(sym)
+				ls.Label = sym
 			case ir.ORANGE:
 				ls := ls.(*ir.RangeStmt)
-				ls.SetSym(sym)
+				ls.Label = sym
 			case ir.OSWITCH:
 				ls := ls.(*ir.SwitchStmt)
-				ls.SetSym(sym)
+				ls.Label = sym
 			case ir.OSELECT:
 				ls := ls.(*ir.SelectStmt)
-				ls.SetSym(sym)
+				ls.Label = sym
 			}
 		}
 	}
@@ -1339,7 +1339,7 @@ func (p *noder) labeledStmt(label *syntax.LabeledStmt, fallOK bool) ir.Node {
 	if ls != nil {
 		if ls.Op() == ir.OBLOCK {
 			ls := ls.(*ir.BlockStmt)
-			l = append(l, ls.List().Slice()...)
+			l = append(l, ls.List.Slice()...)
 		} else {
 			l = append(l, ls)
 		}
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index c6625da1da..9634cd51ae 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -214,7 +214,7 @@ func addptabs() {
 		if s.Pkg.Name != "main" {
 			continue
 		}
-		if n.Type().Kind() == types.TFUNC && n.Class() == ir.PFUNC {
+		if n.Type().Kind() == types.TFUNC && n.Class_ == ir.PFUNC {
 			// function
 			ptabs = append(ptabs, ptabEntry{s: s, t: s.Def.Type()})
 		} else {
@@ -228,7 +228,7 @@ func dumpGlobal(n *ir.Name) {
 	if n.Type() == nil {
 		base.Fatalf("external %v nil type\n", n)
 	}
-	if n.Class() == ir.PFUNC {
+	if n.Class_ == ir.PFUNC {
 		return
 	}
 	if n.Sym().Pkg != types.LocalPkg {
@@ -560,8 +560,8 @@ func pfuncsym(n *ir.Name, noff int64, f *ir.Name) {
 	if n.Sym() == nil {
 		base.Fatalf("pfuncsym nil n sym")
 	}
-	if f.Class() != ir.PFUNC {
-		base.Fatalf("pfuncsym class not PFUNC %d", f.Class())
+	if f.Class_ != ir.PFUNC {
+		base.Fatalf("pfuncsym class not PFUNC %d", f.Class_)
 	}
 	s := n.Sym().Linksym()
 	s.WriteAddr(base.Ctxt, noff, Widthptr, funcsym(f.Sym()).Linksym(), 0)
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 96164d09fd..53d83c0ac8 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -55,10 +55,10 @@ type Order struct {
 func order(fn *ir.Func) {
 	if base.Flag.W > 1 {
 		s := fmt.Sprintf("\nbefore order %v", fn.Sym())
-		ir.DumpList(s, fn.Body())
+		ir.DumpList(s, fn.Body)
 	}
 
-	orderBlock(fn.PtrBody(), map[string][]*ir.Name{})
+	orderBlock(&fn.Body, map[string][]*ir.Name{})
 }
 
 // append typechecks stmt and appends it to out.
@@ -136,12 +136,12 @@ func (o *Order) cheapExpr(n ir.Node) ir.Node {
 		return n
 	case ir.OLEN, ir.OCAP:
 		n := n.(*ir.UnaryExpr)
-		l := o.cheapExpr(n.Left())
-		if l == n.Left() {
+		l := o.cheapExpr(n.X)
+		if l == n.X {
 			return n
 		}
 		a := ir.SepCopy(n).(*ir.UnaryExpr)
-		a.SetLeft(l)
+		a.X = l
 		return typecheck(a, ctxExpr)
 	}
 
@@ -162,59 +162,59 @@ func (o *Order) safeExpr(n ir.Node) ir.Node {
 
 	case ir.OLEN, ir.OCAP:
 		n := n.(*ir.UnaryExpr)
-		l := o.safeExpr(n.Left())
-		if l == n.Left() {
+		l := o.safeExpr(n.X)
+		if l == n.X {
 			return n
 		}
 		a := ir.SepCopy(n).(*ir.UnaryExpr)
-		a.SetLeft(l)
+		a.X = l
 		return typecheck(a, ctxExpr)
 
 	case ir.ODOT:
 		n := n.(*ir.SelectorExpr)
-		l := o.safeExpr(n.Left())
-		if l == n.Left() {
+		l := o.safeExpr(n.X)
+		if l == n.X {
 			return n
 		}
 		a := ir.SepCopy(n).(*ir.SelectorExpr)
-		a.SetLeft(l)
+		a.X = l
 		return typecheck(a, ctxExpr)
 
 	case ir.ODOTPTR:
 		n := n.(*ir.SelectorExpr)
-		l := o.cheapExpr(n.Left())
-		if l == n.Left() {
+		l := o.cheapExpr(n.X)
+		if l == n.X {
 			return n
 		}
 		a := ir.SepCopy(n).(*ir.SelectorExpr)
-		a.SetLeft(l)
+		a.X = l
 		return typecheck(a, ctxExpr)
 
 	case ir.ODEREF:
 		n := n.(*ir.StarExpr)
-		l := o.cheapExpr(n.Left())
-		if l == n.Left() {
+		l := o.cheapExpr(n.X)
+		if l == n.X {
 			return n
 		}
 		a := ir.SepCopy(n).(*ir.StarExpr)
-		a.SetLeft(l)
+		a.X = l
 		return typecheck(a, ctxExpr)
 
 	case ir.OINDEX, ir.OINDEXMAP:
 		n := n.(*ir.IndexExpr)
 		var l ir.Node
-		if n.Left().Type().IsArray() {
-			l = o.safeExpr(n.Left())
+		if n.X.Type().IsArray() {
+			l = o.safeExpr(n.X)
 		} else {
-			l = o.cheapExpr(n.Left())
+			l = o.cheapExpr(n.X)
 		}
-		r := o.cheapExpr(n.Right())
-		if l == n.Left() && r == n.Right() {
+		r := o.cheapExpr(n.Index)
+		if l == n.X && r == n.Index {
 			return n
 		}
 		a := ir.SepCopy(n).(*ir.IndexExpr)
-		a.SetLeft(l)
-		a.SetRight(r)
+		a.X = l
+		a.Index = r
 		return typecheck(a, ctxExpr)
 
 	default:
@@ -230,7 +230,7 @@ func (o *Order) safeExpr(n ir.Node) ir.Node {
 // because we emit explicit VARKILL instructions marking the end of those
 // temporaries' lifetimes.
 func isaddrokay(n ir.Node) bool {
-	return islvalue(n) && (n.Op() != ir.ONAME || n.(*ir.Name).Class() == ir.PEXTERN || ir.IsAutoTmp(n))
+	return islvalue(n) && (n.Op() != ir.ONAME || n.(*ir.Name).Class_ == ir.PEXTERN || ir.IsAutoTmp(n))
 }
 
 // addrTemp ensures that n is okay to pass by address to runtime routines.
@@ -292,17 +292,17 @@ func mapKeyReplaceStrConv(n ir.Node) bool {
 		replaced = true
 	case ir.OSTRUCTLIT:
 		n := n.(*ir.CompLitExpr)
-		for _, elem := range n.List().Slice() {
+		for _, elem := range n.List.Slice() {
 			elem := elem.(*ir.StructKeyExpr)
-			if mapKeyReplaceStrConv(elem.Left()) {
+			if mapKeyReplaceStrConv(elem.Value) {
 				replaced = true
 			}
 		}
 	case ir.OARRAYLIT:
 		n := n.(*ir.CompLitExpr)
-		for _, elem := range n.List().Slice() {
+		for _, elem := range n.List.Slice() {
 			if elem.Op() == ir.OKEY {
-				elem = elem.(*ir.KeyExpr).Right()
+				elem = elem.(*ir.KeyExpr).Value
 			}
 			if mapKeyReplaceStrConv(elem) {
 				replaced = true
@@ -371,24 +371,24 @@ func orderMakeSliceCopy(s []ir.Node) {
 
 	as := s[0].(*ir.AssignStmt)
 	cp := s[1].(*ir.BinaryExpr)
-	if as.Right() == nil || as.Right().Op() != ir.OMAKESLICE || ir.IsBlank(as.Left()) ||
-		as.Left().Op() != ir.ONAME || cp.Left().Op() != ir.ONAME || cp.Right().Op() != ir.ONAME ||
-		as.Left().Name() != cp.Left().Name() || cp.Left().Name() == cp.Right().Name() {
+	if as.Y == nil || as.Y.Op() != ir.OMAKESLICE || ir.IsBlank(as.X) ||
+		as.X.Op() != ir.ONAME || cp.X.Op() != ir.ONAME || cp.Y.Op() != ir.ONAME ||
+		as.X.Name() != cp.X.Name() || cp.X.Name() == cp.Y.Name() {
 		// The line above this one is correct with the differing equality operators:
 		// we want as.X and cp.X to be the same name,
 		// but we want the initial data to be coming from a different name.
 		return
 	}
 
-	mk := as.Right().(*ir.MakeExpr)
-	if mk.Esc() == EscNone || mk.Left() == nil || mk.Right() != nil {
+	mk := as.Y.(*ir.MakeExpr)
+	if mk.Esc() == EscNone || mk.Len == nil || mk.Cap != nil {
 		return
 	}
 	mk.SetOp(ir.OMAKESLICECOPY)
-	mk.SetRight(cp.Right())
+	mk.Cap = cp.Y
 	// Set bounded when m = OMAKESLICE([]T, len(s)); OCOPY(m, s)
-	mk.SetBounded(mk.Left().Op() == ir.OLEN && samesafeexpr(mk.Left().(*ir.UnaryExpr).Left(), cp.Right()))
-	as.SetRight(typecheck(mk, ctxExpr))
+	mk.SetBounded(mk.Len.Op() == ir.OLEN && samesafeexpr(mk.Len.(*ir.UnaryExpr).X, cp.Y))
+	as.Y = typecheck(mk, ctxExpr)
 	s[1] = nil // remove separate copy call
 }
 
@@ -479,25 +479,25 @@ func (o *Order) call(nn ir.Node) {
 		default:
 			base.Fatalf("unexpected call: %+v", n)
 		case *ir.UnaryExpr:
-			n.SetLeft(o.expr(n.Left(), nil))
+			n.X = o.expr(n.X, nil)
 		case *ir.ConvExpr:
-			n.SetLeft(o.expr(n.Left(), nil))
+			n.X = o.expr(n.X, nil)
 		case *ir.BinaryExpr:
-			n.SetLeft(o.expr(n.Left(), nil))
-			n.SetRight(o.expr(n.Right(), nil))
+			n.X = o.expr(n.X, nil)
+			n.Y = o.expr(n.Y, nil)
 		case *ir.MakeExpr:
-			n.SetLeft(o.expr(n.Left(), nil))
-			n.SetRight(o.expr(n.Right(), nil))
+			n.Len = o.expr(n.Len, nil)
+			n.Cap = o.expr(n.Cap, nil)
 		case *ir.CallExpr:
-			o.exprList(n.List())
+			o.exprList(n.Args)
 		}
 		return
 	}
 
 	n := nn.(*ir.CallExpr)
 	fixVariadicCall(n)
-	n.SetLeft(o.expr(n.Left(), nil))
-	o.exprList(n.List())
+	n.X = o.expr(n.X, nil)
+	o.exprList(n.Args)
 
 	if n.Op() == ir.OCALLINTER {
 		return
@@ -509,21 +509,21 @@ func (o *Order) call(nn ir.Node) {
 		// still alive when we pop the temp stack.
 		if arg.Op() == ir.OCONVNOP {
 			arg := arg.(*ir.ConvExpr)
-			if arg.Left().Type().IsUnsafePtr() {
-				x := o.copyExpr(arg.Left())
-				arg.SetLeft(x)
+			if arg.X.Type().IsUnsafePtr() {
+				x := o.copyExpr(arg.X)
+				arg.X = x
 				x.Name().SetAddrtaken(true) // ensure SSA keeps the x variable
-				n.PtrBody().Append(typecheck(ir.NewUnaryExpr(base.Pos, ir.OVARLIVE, x), ctxStmt))
+				n.Body.Append(typecheck(ir.NewUnaryExpr(base.Pos, ir.OVARLIVE, x), ctxStmt))
 			}
 		}
 	}
 
 	// Check for "unsafe-uintptr" tag provided by escape analysis.
-	for i, param := range n.Left().Type().Params().FieldSlice() {
+	for i, param := range n.X.Type().Params().FieldSlice() {
 		if param.Note == unsafeUintptrTag || param.Note == uintptrEscapesTag {
-			if arg := n.List().Index(i); arg.Op() == ir.OSLICELIT {
+			if arg := n.Args.Index(i); arg.Op() == ir.OSLICELIT {
 				arg := arg.(*ir.CompLitExpr)
-				for _, elt := range arg.List().Slice() {
+				for _, elt := range arg.List.Slice() {
 					keepAlive(elt)
 				}
 			} else {
@@ -555,34 +555,34 @@ func (o *Order) mapAssign(n ir.Node) {
 
 	case ir.OAS:
 		n := n.(*ir.AssignStmt)
-		if n.Left().Op() == ir.OINDEXMAP {
-			n.SetRight(o.safeMapRHS(n.Right()))
+		if n.X.Op() == ir.OINDEXMAP {
+			n.Y = o.safeMapRHS(n.Y)
 		}
 		o.out = append(o.out, n)
 	case ir.OASOP:
 		n := n.(*ir.AssignOpStmt)
-		if n.Left().Op() == ir.OINDEXMAP {
-			n.SetRight(o.safeMapRHS(n.Right()))
+		if n.X.Op() == ir.OINDEXMAP {
+			n.Y = o.safeMapRHS(n.Y)
 		}
 		o.out = append(o.out, n)
 
 	case ir.OAS2, ir.OAS2DOTTYPE, ir.OAS2MAPR, ir.OAS2FUNC:
 		n := n.(*ir.AssignListStmt)
 		var post []ir.Node
-		for i, m := range n.List().Slice() {
+		for i, m := range n.Lhs.Slice() {
 			switch {
 			case m.Op() == ir.OINDEXMAP:
 				m := m.(*ir.IndexExpr)
-				if !ir.IsAutoTmp(m.Left()) {
-					m.SetLeft(o.copyExpr(m.Left()))
+				if !ir.IsAutoTmp(m.X) {
+					m.X = o.copyExpr(m.X)
 				}
-				if !ir.IsAutoTmp(m.Right()) {
-					m.SetRight(o.copyExpr(m.Right()))
+				if !ir.IsAutoTmp(m.Index) {
+					m.Index = o.copyExpr(m.Index)
 				}
 				fallthrough
 			case instrumenting && n.Op() == ir.OAS2FUNC && !ir.IsBlank(m):
 				t := o.newTemp(m.Type(), false)
-				n.List().SetIndex(i, t)
+				n.Lhs.SetIndex(i, t)
 				a := ir.NewAssignStmt(base.Pos, m, t)
 				post = append(post, typecheck(a, ctxStmt))
 			}
@@ -598,7 +598,7 @@ func (o *Order) safeMapRHS(r ir.Node) ir.Node {
 	// We need to make sure the RHS won't panic.  See issue 22881.
 	if r.Op() == ir.OAPPEND {
 		r := r.(*ir.CallExpr)
-		s := r.List().Slice()[1:]
+		s := r.Args.Slice()[1:]
 		for i, n := range s {
 			s[i] = o.cheapExpr(n)
 		}
@@ -628,32 +628,32 @@ func (o *Order) stmt(n ir.Node) {
 	case ir.OAS:
 		n := n.(*ir.AssignStmt)
 		t := o.markTemp()
-		n.SetLeft(o.expr(n.Left(), nil))
-		n.SetRight(o.expr(n.Right(), n.Left()))
+		n.X = o.expr(n.X, nil)
+		n.Y = o.expr(n.Y, n.X)
 		o.mapAssign(n)
 		o.cleanTemp(t)
 
 	case ir.OASOP:
 		n := n.(*ir.AssignOpStmt)
 		t := o.markTemp()
-		n.SetLeft(o.expr(n.Left(), nil))
-		n.SetRight(o.expr(n.Right(), nil))
+		n.X = o.expr(n.X, nil)
+		n.Y = o.expr(n.Y, nil)
 
-		if instrumenting || n.Left().Op() == ir.OINDEXMAP && (n.SubOp() == ir.ODIV || n.SubOp() == ir.OMOD) {
+		if instrumenting || n.X.Op() == ir.OINDEXMAP && (n.AsOp == ir.ODIV || n.AsOp == ir.OMOD) {
 			// Rewrite m[k] op= r into m[k] = m[k] op r so
 			// that we can ensure that if op panics
 			// because r is zero, the panic happens before
 			// the map assignment.
 			// DeepCopy is a big hammer here, but safeExpr
 			// makes sure there is nothing too deep being copied.
-			l1 := o.safeExpr(n.Left())
+			l1 := o.safeExpr(n.X)
 			l2 := ir.DeepCopy(src.NoXPos, l1)
 			if l2.Op() == ir.OINDEXMAP {
 				l2 := l2.(*ir.IndexExpr)
-				l2.SetIndexMapLValue(false)
+				l2.Assigned = false
 			}
 			l2 = o.copyExpr(l2)
-			r := o.expr(typecheck(ir.NewBinaryExpr(n.Pos(), n.SubOp(), l2, n.Right()), ctxExpr), nil)
+			r := o.expr(typecheck(ir.NewBinaryExpr(n.Pos(), n.AsOp, l2, n.Y), ctxExpr), nil)
 			as := typecheck(ir.NewAssignStmt(n.Pos(), l1, r), ctxStmt)
 			o.mapAssign(as)
 			o.cleanTemp(t)
@@ -666,8 +666,8 @@ func (o *Order) stmt(n ir.Node) {
 	case ir.OAS2:
 		n := n.(*ir.AssignListStmt)
 		t := o.markTemp()
-		o.exprList(n.List())
-		o.exprList(n.Rlist())
+		o.exprList(n.Lhs)
+		o.exprList(n.Rhs)
 		o.mapAssign(n)
 		o.cleanTemp(t)
 
@@ -675,9 +675,9 @@ func (o *Order) stmt(n ir.Node) {
 	case ir.OAS2FUNC:
 		n := n.(*ir.AssignListStmt)
 		t := o.markTemp()
-		o.exprList(n.List())
-		o.init(n.Rlist().First())
-		o.call(n.Rlist().First())
+		o.exprList(n.Lhs)
+		o.init(n.Rhs.First())
+		o.call(n.Rhs.First())
 		o.as2(n)
 		o.cleanTemp(t)
 
@@ -690,22 +690,22 @@ func (o *Order) stmt(n ir.Node) {
 	case ir.OAS2DOTTYPE, ir.OAS2RECV, ir.OAS2MAPR:
 		n := n.(*ir.AssignListStmt)
 		t := o.markTemp()
-		o.exprList(n.List())
+		o.exprList(n.Lhs)
 
-		switch r := n.Rlist().First(); r.Op() {
+		switch r := n.Rhs.First(); r.Op() {
 		case ir.ODOTTYPE2:
 			r := r.(*ir.TypeAssertExpr)
-			r.SetLeft(o.expr(r.Left(), nil))
+			r.X = o.expr(r.X, nil)
 		case ir.ORECV:
 			r := r.(*ir.UnaryExpr)
-			r.SetLeft(o.expr(r.Left(), nil))
+			r.X = o.expr(r.X, nil)
 		case ir.OINDEXMAP:
 			r := r.(*ir.IndexExpr)
-			r.SetLeft(o.expr(r.Left(), nil))
-			r.SetRight(o.expr(r.Right(), nil))
+			r.X = o.expr(r.X, nil)
+			r.Index = o.expr(r.Index, nil)
 			// See similar conversion for OINDEXMAP below.
-			_ = mapKeyReplaceStrConv(r.Right())
-			r.SetRight(o.mapKeyTemp(r.Left().Type(), r.Right()))
+			_ = mapKeyReplaceStrConv(r.Index)
+			r.Index = o.mapKeyTemp(r.X.Type(), r.Index)
 		default:
 			base.Fatalf("order.stmt: %v", r.Op())
 		}
@@ -716,7 +716,7 @@ func (o *Order) stmt(n ir.Node) {
 	// Special: does not save n onto out.
 	case ir.OBLOCK:
 		n := n.(*ir.BlockStmt)
-		o.stmtList(n.List())
+		o.stmtList(n.List)
 
 	// Special: n->left is not an expression; save as is.
 	case ir.OBREAK,
@@ -741,22 +741,22 @@ func (o *Order) stmt(n ir.Node) {
 	case ir.OCLOSE, ir.ORECV:
 		n := n.(*ir.UnaryExpr)
 		t := o.markTemp()
-		n.SetLeft(o.expr(n.Left(), nil))
+		n.X = o.expr(n.X, nil)
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
 
 	case ir.OCOPY:
 		n := n.(*ir.BinaryExpr)
 		t := o.markTemp()
-		n.SetLeft(o.expr(n.Left(), nil))
-		n.SetRight(o.expr(n.Right(), nil))
+		n.X = o.expr(n.X, nil)
+		n.Y = o.expr(n.Y, nil)
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
 
 	case ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
 		n := n.(*ir.CallExpr)
 		t := o.markTemp()
-		o.exprList(n.List())
+		o.exprList(n.Args)
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
 
@@ -764,17 +764,17 @@ func (o *Order) stmt(n ir.Node) {
 	case ir.ODEFER, ir.OGO:
 		n := n.(*ir.GoDeferStmt)
 		t := o.markTemp()
-		o.init(n.Left())
-		o.call(n.Left())
+		o.init(n.Call)
+		o.call(n.Call)
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
 
 	case ir.ODELETE:
 		n := n.(*ir.CallExpr)
 		t := o.markTemp()
-		n.List().SetFirst(o.expr(n.List().First(), nil))
-		n.List().SetSecond(o.expr(n.List().Second(), nil))
-		n.List().SetSecond(o.mapKeyTemp(n.List().First().Type(), n.List().Second()))
+		n.Args.SetFirst(o.expr(n.Args.First(), nil))
+		n.Args.SetSecond(o.expr(n.Args.Second(), nil))
+		n.Args.SetSecond(o.mapKeyTemp(n.Args.First().Type(), n.Args.Second()))
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
 
@@ -783,10 +783,10 @@ func (o *Order) stmt(n ir.Node) {
 	case ir.OFOR:
 		n := n.(*ir.ForStmt)
 		t := o.markTemp()
-		n.SetLeft(o.exprInPlace(n.Left()))
-		n.PtrBody().Prepend(o.cleanTempNoPop(t)...)
-		orderBlock(n.PtrBody(), o.free)
-		n.SetRight(orderStmtInPlace(n.Right(), o.free))
+		n.Cond = o.exprInPlace(n.Cond)
+		n.Body.Prepend(o.cleanTempNoPop(t)...)
+		orderBlock(&n.Body, o.free)
+		n.Post = orderStmtInPlace(n.Post, o.free)
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
 
@@ -795,12 +795,12 @@ func (o *Order) stmt(n ir.Node) {
 	case ir.OIF:
 		n := n.(*ir.IfStmt)
 		t := o.markTemp()
-		n.SetLeft(o.exprInPlace(n.Left()))
-		n.PtrBody().Prepend(o.cleanTempNoPop(t)...)
-		n.PtrRlist().Prepend(o.cleanTempNoPop(t)...)
+		n.Cond = o.exprInPlace(n.Cond)
+		n.Body.Prepend(o.cleanTempNoPop(t)...)
+		n.Else.Prepend(o.cleanTempNoPop(t)...)
 		o.popTemp(t)
-		orderBlock(n.PtrBody(), o.free)
-		orderBlock(n.PtrRlist(), o.free)
+		orderBlock(&n.Body, o.free)
+		orderBlock(&n.Else, o.free)
 		o.out = append(o.out, n)
 
 	// Special: argument will be converted to interface using convT2E
@@ -808,9 +808,9 @@ func (o *Order) stmt(n ir.Node) {
 	case ir.OPANIC:
 		n := n.(*ir.UnaryExpr)
 		t := o.markTemp()
-		n.SetLeft(o.expr(n.Left(), nil))
-		if !n.Left().Type().IsInterface() {
-			n.SetLeft(o.addrTemp(n.Left()))
+		n.X = o.expr(n.X, nil)
+		if !n.X.Type().IsInterface() {
+			n.X = o.addrTemp(n.X)
 		}
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
@@ -830,12 +830,12 @@ func (o *Order) stmt(n ir.Node) {
 		// Mark []byte(str) range expression to reuse string backing storage.
 		// It is safe because the storage cannot be mutated.
 		n := n.(*ir.RangeStmt)
-		if n.Right().Op() == ir.OSTR2BYTES {
-			n.Right().(*ir.ConvExpr).SetOp(ir.OSTR2BYTESTMP)
+		if n.X.Op() == ir.OSTR2BYTES {
+			n.X.(*ir.ConvExpr).SetOp(ir.OSTR2BYTESTMP)
 		}
 
 		t := o.markTemp()
-		n.SetRight(o.expr(n.Right(), nil))
+		n.X = o.expr(n.X, nil)
 
 		orderBody := true
 		switch n.Type().Kind() {
@@ -843,7 +843,7 @@ func (o *Order) stmt(n ir.Node) {
 			base.Fatalf("order.stmt range %v", n.Type())
 
 		case types.TARRAY, types.TSLICE:
-			if n.List().Len() < 2 || ir.IsBlank(n.List().Second()) {
+			if n.Vars.Len() < 2 || ir.IsBlank(n.Vars.Second()) {
 				// for i := range x will only use x once, to compute len(x).
 				// No need to copy it.
 				break
@@ -853,7 +853,7 @@ func (o *Order) stmt(n ir.Node) {
 		case types.TCHAN, types.TSTRING:
 			// chan, string, slice, array ranges use value multiple times.
 			// make copy.
-			r := n.Right()
+			r := n.X
 
 			if r.Type().IsString() && r.Type() != types.Types[types.TSTRING] {
 				r = ir.NewConvExpr(base.Pos, ir.OCONV, nil, r)
@@ -861,7 +861,7 @@ func (o *Order) stmt(n ir.Node) {
 				r = typecheck(r, ctxExpr)
 			}
 
-			n.SetRight(o.copyExpr(r))
+			n.X = o.copyExpr(r)
 
 		case types.TMAP:
 			if isMapClear(n) {
@@ -875,23 +875,23 @@ func (o *Order) stmt(n ir.Node) {
 			// copy the map value in case it is a map literal.
 			// TODO(rsc): Make tmp = literal expressions reuse tmp.
 			// For maps tmp is just one word so it hardly matters.
-			r := n.Right()
-			n.SetRight(o.copyExpr(r))
+			r := n.X
+			n.X = o.copyExpr(r)
 
 			// n.Prealloc is the temp for the iterator.
 			// hiter contains pointers and needs to be zeroed.
 			n.Prealloc = o.newTemp(hiter(n.Type()), true)
 		}
-		o.exprListInPlace(n.List())
+		o.exprListInPlace(n.Vars)
 		if orderBody {
-			orderBlock(n.PtrBody(), o.free)
+			orderBlock(&n.Body, o.free)
 		}
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
 
 	case ir.ORETURN:
 		n := n.(*ir.ReturnStmt)
-		o.exprList(n.List())
+		o.exprList(n.Results)
 		o.out = append(o.out, n)
 
 	// Special: clean case temporaries in each block entry.
@@ -906,9 +906,9 @@ func (o *Order) stmt(n ir.Node) {
 	case ir.OSELECT:
 		n := n.(*ir.SelectStmt)
 		t := o.markTemp()
-		for _, ncas := range n.List().Slice() {
+		for _, ncas := range n.Cases.Slice() {
 			ncas := ncas.(*ir.CaseStmt)
-			r := ncas.Left()
+			r := ncas.Comm
 			setlineno(ncas)
 
 			// Append any new body prologue to ninit.
@@ -927,17 +927,17 @@ func (o *Order) stmt(n ir.Node) {
 			case ir.OSELRECV2:
 				// case x, ok = <-c
 				r := r.(*ir.AssignListStmt)
-				recv := r.Rlist().First().(*ir.UnaryExpr)
-				recv.SetLeft(o.expr(recv.Left(), nil))
-				if !ir.IsAutoTmp(recv.Left()) {
-					recv.SetLeft(o.copyExpr(recv.Left()))
+				recv := r.Rhs.First().(*ir.UnaryExpr)
+				recv.X = o.expr(recv.X, nil)
+				if !ir.IsAutoTmp(recv.X) {
+					recv.X = o.copyExpr(recv.X)
 				}
 				init := r.PtrInit().Slice()
 				r.PtrInit().Set(nil)
 
-				colas := r.Colas()
+				colas := r.Def
 				do := func(i int, t *types.Type) {
-					n := r.List().Index(i)
+					n := r.Lhs.Index(i)
 					if ir.IsBlank(n) {
 						return
 					}
@@ -946,7 +946,7 @@ func (o *Order) stmt(n ir.Node) {
 					// declaration (and possible allocation) until inside the case body.
 					// Delete the ODCL nodes here and recreate them inside the body below.
 					if colas {
-						if len(init) > 0 && init[0].Op() == ir.ODCL && init[0].(*ir.Decl).Left() == n {
+						if len(init) > 0 && init[0].Op() == ir.ODCL && init[0].(*ir.Decl).X == n {
 							init = init[1:]
 						}
 						dcl := typecheck(ir.NewDecl(base.Pos, ir.ODCL, n), ctxStmt)
@@ -955,9 +955,9 @@ func (o *Order) stmt(n ir.Node) {
 					tmp := o.newTemp(t, t.HasPointers())
 					as := typecheck(ir.NewAssignStmt(base.Pos, n, conv(tmp, n.Type())), ctxStmt)
 					ncas.PtrInit().Append(as)
-					r.PtrList().SetIndex(i, tmp)
+					(&r.Lhs).SetIndex(i, tmp)
 				}
-				do(0, recv.Left().Type().Elem())
+				do(0, recv.X.Type().Elem())
 				do(1, types.Types[types.TBOOL])
 				if len(init) != 0 {
 					ir.DumpList("ninit", r.Init())
@@ -974,28 +974,28 @@ func (o *Order) stmt(n ir.Node) {
 
 				// case c <- x
 				// r->left is c, r->right is x, both are always evaluated.
-				r.SetLeft(o.expr(r.Left(), nil))
+				r.Chan = o.expr(r.Chan, nil)
 
-				if !ir.IsAutoTmp(r.Left()) {
-					r.SetLeft(o.copyExpr(r.Left()))
+				if !ir.IsAutoTmp(r.Chan) {
+					r.Chan = o.copyExpr(r.Chan)
 				}
-				r.SetRight(o.expr(r.Right(), nil))
-				if !ir.IsAutoTmp(r.Right()) {
-					r.SetRight(o.copyExpr(r.Right()))
+				r.Value = o.expr(r.Value, nil)
+				if !ir.IsAutoTmp(r.Value) {
+					r.Value = o.copyExpr(r.Value)
 				}
 			}
 		}
 		// Now that we have accumulated all the temporaries, clean them.
 		// Also insert any ninit queued during the previous loop.
 		// (The temporary cleaning must follow that ninit work.)
-		for _, cas := range n.List().Slice() {
+		for _, cas := range n.Cases.Slice() {
 			cas := cas.(*ir.CaseStmt)
-			orderBlock(cas.PtrBody(), o.free)
-			cas.PtrBody().Prepend(o.cleanTempNoPop(t)...)
+			orderBlock(&cas.Body, o.free)
+			cas.Body.Prepend(o.cleanTempNoPop(t)...)
 
 			// TODO(mdempsky): Is this actually necessary?
 			// walkselect appears to walk Ninit.
-			cas.PtrBody().Prepend(cas.Init().Slice()...)
+			cas.Body.Prepend(cas.Init().Slice()...)
 			cas.PtrInit().Set(nil)
 		}
 
@@ -1006,14 +1006,14 @@ func (o *Order) stmt(n ir.Node) {
 	case ir.OSEND:
 		n := n.(*ir.SendStmt)
 		t := o.markTemp()
-		n.SetLeft(o.expr(n.Left(), nil))
-		n.SetRight(o.expr(n.Right(), nil))
+		n.Chan = o.expr(n.Chan, nil)
+		n.Value = o.expr(n.Value, nil)
 		if instrumenting {
 			// Force copying to the stack so that (chan T)(nil) <- x
 			// is still instrumented as a read of x.
-			n.SetRight(o.copyExpr(n.Right()))
+			n.Value = o.copyExpr(n.Value)
 		} else {
-			n.SetRight(o.addrTemp(n.Right()))
+			n.Value = o.addrTemp(n.Value)
 		}
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
@@ -1029,15 +1029,15 @@ func (o *Order) stmt(n ir.Node) {
 		n := n.(*ir.SwitchStmt)
 		if base.Debug.Libfuzzer != 0 && !hasDefaultCase(n) {
 			// Add empty "default:" case for instrumentation.
-			n.PtrList().Append(ir.NewCaseStmt(base.Pos, nil, nil))
+			n.Cases.Append(ir.NewCaseStmt(base.Pos, nil, nil))
 		}
 
 		t := o.markTemp()
-		n.SetLeft(o.expr(n.Left(), nil))
-		for _, ncas := range n.List().Slice() {
+		n.Tag = o.expr(n.Tag, nil)
+		for _, ncas := range n.Cases.Slice() {
 			ncas := ncas.(*ir.CaseStmt)
-			o.exprListInPlace(ncas.List())
-			orderBlock(ncas.PtrBody(), o.free)
+			o.exprListInPlace(ncas.List)
+			orderBlock(&ncas.Body, o.free)
 		}
 
 		o.out = append(o.out, n)
@@ -1048,9 +1048,9 @@ func (o *Order) stmt(n ir.Node) {
 }
 
 func hasDefaultCase(n *ir.SwitchStmt) bool {
-	for _, ncas := range n.List().Slice() {
+	for _, ncas := range n.Cases.Slice() {
 		ncas := ncas.(*ir.CaseStmt)
-		if ncas.List().Len() == 0 {
+		if ncas.List.Len() == 0 {
 			return true
 		}
 	}
@@ -1111,10 +1111,10 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 	// Fewer than 5 strings use direct runtime helpers.
 	case ir.OADDSTR:
 		n := n.(*ir.AddStringExpr)
-		o.exprList(n.List())
+		o.exprList(n.List)
 
-		if n.List().Len() > 5 {
-			t := types.NewArray(types.Types[types.TSTRING], int64(n.List().Len()))
+		if n.List.Len() > 5 {
+			t := types.NewArray(types.Types[types.TSTRING], int64(n.List.Len()))
 			n.Prealloc = o.newTemp(t, false)
 		}
 
@@ -1128,13 +1128,13 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		hasbyte := false
 
 		haslit := false
-		for _, n1 := range n.List().Slice() {
+		for _, n1 := range n.List.Slice() {
 			hasbyte = hasbyte || n1.Op() == ir.OBYTES2STR
 			haslit = haslit || n1.Op() == ir.OLITERAL && len(ir.StringVal(n1)) != 0
 		}
 
 		if haslit && hasbyte {
-			for _, n2 := range n.List().Slice() {
+			for _, n2 := range n.List.Slice() {
 				if n2.Op() == ir.OBYTES2STR {
 					n2 := n2.(*ir.ConvExpr)
 					n2.SetOp(ir.OBYTES2STRTMP)
@@ -1145,16 +1145,16 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 
 	case ir.OINDEXMAP:
 		n := n.(*ir.IndexExpr)
-		n.SetLeft(o.expr(n.Left(), nil))
-		n.SetRight(o.expr(n.Right(), nil))
+		n.X = o.expr(n.X, nil)
+		n.Index = o.expr(n.Index, nil)
 		needCopy := false
 
-		if !n.IndexMapLValue() {
+		if !n.Assigned {
 			// Enforce that any []byte slices we are not copying
 			// can not be changed before the map index by forcing
 			// the map index to happen immediately following the
 			// conversions. See copyExpr a few lines below.
-			needCopy = mapKeyReplaceStrConv(n.Right())
+			needCopy = mapKeyReplaceStrConv(n.Index)
 
 			if instrumenting {
 				// Race detector needs the copy.
@@ -1163,7 +1163,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		}
 
 		// key must be addressable
-		n.SetRight(o.mapKeyTemp(n.Left().Type(), n.Right()))
+		n.Index = o.mapKeyTemp(n.X.Type(), n.Index)
 		if needCopy {
 			return o.copyExpr(n)
 		}
@@ -1173,22 +1173,22 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 	// temporary to pass to the runtime conversion routine.
 	case ir.OCONVIFACE:
 		n := n.(*ir.ConvExpr)
-		n.SetLeft(o.expr(n.Left(), nil))
-		if n.Left().Type().IsInterface() {
+		n.X = o.expr(n.X, nil)
+		if n.X.Type().IsInterface() {
 			return n
 		}
-		if _, needsaddr := convFuncName(n.Left().Type(), n.Type()); needsaddr || isStaticCompositeLiteral(n.Left()) {
+		if _, needsaddr := convFuncName(n.X.Type(), n.Type()); needsaddr || isStaticCompositeLiteral(n.X) {
 			// Need a temp if we need to pass the address to the conversion function.
 			// We also process static composite literal node here, making a named static global
 			// whose address we can put directly in an interface (see OCONVIFACE case in walk).
-			n.SetLeft(o.addrTemp(n.Left()))
+			n.X = o.addrTemp(n.X)
 		}
 		return n
 
 	case ir.OCONVNOP:
 		n := n.(*ir.ConvExpr)
-		if n.Type().IsKind(types.TUNSAFEPTR) && n.Left().Type().IsKind(types.TUINTPTR) && (n.Left().Op() == ir.OCALLFUNC || n.Left().Op() == ir.OCALLINTER || n.Left().Op() == ir.OCALLMETH) {
-			call := n.Left().(*ir.CallExpr)
+		if n.Type().IsKind(types.TUNSAFEPTR) && n.X.Type().IsKind(types.TUINTPTR) && (n.X.Op() == ir.OCALLFUNC || n.X.Op() == ir.OCALLINTER || n.X.Op() == ir.OCALLMETH) {
+			call := n.X.(*ir.CallExpr)
 			// When reordering unsafe.Pointer(f()) into a separate
 			// statement, the conversion and function call must stay
 			// together. See golang.org/issue/15329.
@@ -1198,7 +1198,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 				return o.copyExpr(n)
 			}
 		} else {
-			n.SetLeft(o.expr(n.Left(), nil))
+			n.X = o.expr(n.X, nil)
 		}
 		return n
 
@@ -1216,7 +1216,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		r := o.newTemp(n.Type(), false)
 
 		// Evaluate left-hand side.
-		lhs := o.expr(n.Left(), nil)
+		lhs := o.expr(n.X, nil)
 		o.out = append(o.out, typecheck(ir.NewAssignStmt(base.Pos, r, lhs), ctxStmt))
 
 		// Evaluate right-hand side, save generated code.
@@ -1224,7 +1224,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		o.out = nil
 		t := o.markTemp()
 		o.edge()
-		rhs := o.expr(n.Right(), nil)
+		rhs := o.expr(n.Y, nil)
 		o.out = append(o.out, typecheck(ir.NewAssignStmt(base.Pos, r, rhs), ctxStmt))
 		o.cleanTemp(t)
 		gen := o.out
@@ -1233,9 +1233,9 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		// If left-hand side doesn't cause a short-circuit, issue right-hand side.
 		nif := ir.NewIfStmt(base.Pos, r, nil, nil)
 		if n.Op() == ir.OANDAND {
-			nif.PtrBody().Set(gen)
+			nif.Body.Set(gen)
 		} else {
-			nif.PtrRlist().Set(gen)
+			nif.Else.Set(gen)
 		}
 		o.out = append(o.out, nif)
 		return r
@@ -1261,8 +1261,8 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 
 		if isRuneCount(n) {
 			// len([]rune(s)) is rewritten to runtime.countrunes(s) later.
-			conv := n.(*ir.UnaryExpr).Left().(*ir.ConvExpr)
-			conv.SetLeft(o.expr(conv.Left(), nil))
+			conv := n.(*ir.UnaryExpr).X.(*ir.ConvExpr)
+			conv.X = o.expr(conv.X, nil)
 		} else {
 			o.call(n)
 		}
@@ -1276,21 +1276,21 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		// Check for append(x, make([]T, y)...) .
 		n := n.(*ir.CallExpr)
 		if isAppendOfMake(n) {
-			n.List().SetFirst(o.expr(n.List().First(), nil)) // order x
-			mk := n.List().Second().(*ir.MakeExpr)
-			mk.SetLeft(o.expr(mk.Left(), nil)) // order y
+			n.Args.SetFirst(o.expr(n.Args.First(), nil)) // order x
+			mk := n.Args.Second().(*ir.MakeExpr)
+			mk.Len = o.expr(mk.Len, nil) // order y
 		} else {
-			o.exprList(n.List())
+			o.exprList(n.Args)
 		}
 
-		if lhs == nil || lhs.Op() != ir.ONAME && !samesafeexpr(lhs, n.List().First()) {
+		if lhs == nil || lhs.Op() != ir.ONAME && !samesafeexpr(lhs, n.Args.First()) {
 			return o.copyExpr(n)
 		}
 		return n
 
 	case ir.OSLICE, ir.OSLICEARR, ir.OSLICESTR, ir.OSLICE3, ir.OSLICE3ARR:
 		n := n.(*ir.SliceExpr)
-		n.SetLeft(o.expr(n.Left(), nil))
+		n.X = o.expr(n.X, nil)
 		low, high, max := n.SliceBounds()
 		low = o.expr(low, nil)
 		low = o.cheapExpr(low)
@@ -1299,21 +1299,21 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		max = o.expr(max, nil)
 		max = o.cheapExpr(max)
 		n.SetSliceBounds(low, high, max)
-		if lhs == nil || lhs.Op() != ir.ONAME && !samesafeexpr(lhs, n.Left()) {
+		if lhs == nil || lhs.Op() != ir.ONAME && !samesafeexpr(lhs, n.X) {
 			return o.copyExpr(n)
 		}
 		return n
 
 	case ir.OCLOSURE:
 		n := n.(*ir.ClosureExpr)
-		if n.Transient() && len(n.Func().ClosureVars) > 0 {
+		if n.Transient() && len(n.Func.ClosureVars) > 0 {
 			n.Prealloc = o.newTemp(closureType(n), false)
 		}
 		return n
 
 	case ir.OCALLPART:
 		n := n.(*ir.CallPartExpr)
-		n.SetLeft(o.expr(n.Left(), nil))
+		n.X = o.expr(n.X, nil)
 		if n.Transient() {
 			t := partialCallType(n)
 			n.Prealloc = o.newTemp(t, false)
@@ -1322,7 +1322,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 
 	case ir.OSLICELIT:
 		n := n.(*ir.CompLitExpr)
-		o.exprList(n.List())
+		o.exprList(n.List)
 		if n.Transient() {
 			t := types.NewArray(n.Type().Elem(), n.Len)
 			n.Prealloc = o.newTemp(t, false)
@@ -1331,7 +1331,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 
 	case ir.ODOTTYPE, ir.ODOTTYPE2:
 		n := n.(*ir.TypeAssertExpr)
-		n.SetLeft(o.expr(n.Left(), nil))
+		n.X = o.expr(n.X, nil)
 		if !isdirectiface(n.Type()) || instrumenting {
 			return o.copyExprClear(n)
 		}
@@ -1339,32 +1339,32 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 
 	case ir.ORECV:
 		n := n.(*ir.UnaryExpr)
-		n.SetLeft(o.expr(n.Left(), nil))
+		n.X = o.expr(n.X, nil)
 		return o.copyExprClear(n)
 
 	case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
 		n := n.(*ir.BinaryExpr)
-		n.SetLeft(o.expr(n.Left(), nil))
-		n.SetRight(o.expr(n.Right(), nil))
+		n.X = o.expr(n.X, nil)
+		n.Y = o.expr(n.Y, nil)
 
-		t := n.Left().Type()
+		t := n.X.Type()
 		switch {
 		case t.IsString():
 			// Mark string(byteSlice) arguments to reuse byteSlice backing
 			// buffer during conversion. String comparison does not
 			// memorize the strings for later use, so it is safe.
-			if n.Left().Op() == ir.OBYTES2STR {
-				n.Left().(*ir.ConvExpr).SetOp(ir.OBYTES2STRTMP)
+			if n.X.Op() == ir.OBYTES2STR {
+				n.X.(*ir.ConvExpr).SetOp(ir.OBYTES2STRTMP)
 			}
-			if n.Right().Op() == ir.OBYTES2STR {
-				n.Right().(*ir.ConvExpr).SetOp(ir.OBYTES2STRTMP)
+			if n.Y.Op() == ir.OBYTES2STR {
+				n.Y.(*ir.ConvExpr).SetOp(ir.OBYTES2STRTMP)
 			}
 
 		case t.IsStruct() || t.IsArray():
 			// for complex comparisons, we need both args to be
 			// addressable so we can pass them to the runtime.
-			n.SetLeft(o.addrTemp(n.Left()))
-			n.SetRight(o.addrTemp(n.Right()))
+			n.X = o.addrTemp(n.X)
+			n.Y = o.addrTemp(n.Y)
 		}
 		return n
 
@@ -1385,13 +1385,13 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		// the keys and values before storing any of them to the map.
 		// See issue 26552.
 		n := n.(*ir.CompLitExpr)
-		entries := n.List().Slice()
+		entries := n.List.Slice()
 		statics := entries[:0]
 		var dynamics []*ir.KeyExpr
 		for _, r := range entries {
 			r := r.(*ir.KeyExpr)
 
-			if !isStaticCompositeLiteral(r.Left()) || !isStaticCompositeLiteral(r.Right()) {
+			if !isStaticCompositeLiteral(r.Key) || !isStaticCompositeLiteral(r.Value) {
 				dynamics = append(dynamics, r)
 				continue
 			}
@@ -1399,14 +1399,14 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 			// Recursively ordering some static entries can change them to dynamic;
 			// e.g., OCONVIFACE nodes. See #31777.
 			r = o.expr(r, nil).(*ir.KeyExpr)
-			if !isStaticCompositeLiteral(r.Left()) || !isStaticCompositeLiteral(r.Right()) {
+			if !isStaticCompositeLiteral(r.Key) || !isStaticCompositeLiteral(r.Value) {
 				dynamics = append(dynamics, r)
 				continue
 			}
 
 			statics = append(statics, r)
 		}
-		n.PtrList().Set(statics)
+		n.List.Set(statics)
 
 		if len(dynamics) == 0 {
 			return n
@@ -1420,7 +1420,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 
 		// Emit eval+insert of dynamic entries, one at a time.
 		for _, r := range dynamics {
-			as := ir.NewAssignStmt(base.Pos, ir.NewIndexExpr(base.Pos, m, r.Left()), r.Right())
+			as := ir.NewAssignStmt(base.Pos, ir.NewIndexExpr(base.Pos, m, r.Key), r.Value)
 			typecheck(as, ctxStmt) // Note: this converts the OINDEX to an OINDEXMAP
 			o.stmt(as)
 		}
@@ -1441,10 +1441,10 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 func (o *Order) as2(n *ir.AssignListStmt) {
 	tmplist := []ir.Node{}
 	left := []ir.Node{}
-	for ni, l := range n.List().Slice() {
+	for ni, l := range n.Lhs.Slice() {
 		if !ir.IsBlank(l) {
 			tmp := o.newTemp(l.Type(), l.Type().HasPointers())
-			n.List().SetIndex(ni, tmp)
+			n.Lhs.SetIndex(ni, tmp)
 			tmplist = append(tmplist, tmp)
 			left = append(left, l)
 		}
@@ -1453,8 +1453,8 @@ func (o *Order) as2(n *ir.AssignListStmt) {
 	o.out = append(o.out, n)
 
 	as := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-	as.PtrList().Set(left)
-	as.PtrRlist().Set(tmplist)
+	as.Lhs.Set(left)
+	as.Rhs.Set(tmplist)
 	o.stmt(typecheck(as, ctxStmt))
 }
 
@@ -1462,25 +1462,25 @@ func (o *Order) as2(n *ir.AssignListStmt) {
 // Just like as2, this also adds temporaries to ensure left-to-right assignment.
 func (o *Order) okAs2(n *ir.AssignListStmt) {
 	var tmp1, tmp2 ir.Node
-	if !ir.IsBlank(n.List().First()) {
-		typ := n.Rlist().First().Type()
+	if !ir.IsBlank(n.Lhs.First()) {
+		typ := n.Rhs.First().Type()
 		tmp1 = o.newTemp(typ, typ.HasPointers())
 	}
 
-	if !ir.IsBlank(n.List().Second()) {
+	if !ir.IsBlank(n.Lhs.Second()) {
 		tmp2 = o.newTemp(types.Types[types.TBOOL], false)
 	}
 
 	o.out = append(o.out, n)
 
 	if tmp1 != nil {
-		r := ir.NewAssignStmt(base.Pos, n.List().First(), tmp1)
+		r := ir.NewAssignStmt(base.Pos, n.Lhs.First(), tmp1)
 		o.mapAssign(typecheck(r, ctxStmt))
-		n.List().SetFirst(tmp1)
+		n.Lhs.SetFirst(tmp1)
 	}
 	if tmp2 != nil {
-		r := ir.NewAssignStmt(base.Pos, n.List().Second(), conv(tmp2, n.List().Second().Type()))
+		r := ir.NewAssignStmt(base.Pos, n.Lhs.Second(), conv(tmp2, n.Lhs.Second().Type()))
 		o.mapAssign(typecheck(r, ctxStmt))
-		n.List().SetSecond(tmp2)
+		n.Lhs.SetSecond(tmp2)
 	}
 }
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index e43471dbca..32550c8bd4 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -68,11 +68,11 @@ func emitptrargsmap(fn *ir.Func) {
 // the top of the stack and increasing in size.
 // Non-autos sort on offset.
 func cmpstackvarlt(a, b *ir.Name) bool {
-	if (a.Class() == ir.PAUTO) != (b.Class() == ir.PAUTO) {
-		return b.Class() == ir.PAUTO
+	if (a.Class_ == ir.PAUTO) != (b.Class_ == ir.PAUTO) {
+		return b.Class_ == ir.PAUTO
 	}
 
-	if a.Class() != ir.PAUTO {
+	if a.Class_ != ir.PAUTO {
 		return a.FrameOffset() < b.FrameOffset()
 	}
 
@@ -113,7 +113,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 
 	// Mark the PAUTO's unused.
 	for _, ln := range fn.Dcl {
-		if ln.Class() == ir.PAUTO {
+		if ln.Class_ == ir.PAUTO {
 			ln.SetUsed(false)
 		}
 	}
@@ -128,7 +128,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 	for _, b := range f.Blocks {
 		for _, v := range b.Values {
 			if n, ok := v.Aux.(*ir.Name); ok {
-				switch n.Class() {
+				switch n.Class_ {
 				case ir.PPARAM, ir.PPARAMOUT:
 					// Don't modify nodfp; it is a global.
 					if n != nodfp {
@@ -154,7 +154,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 	// Reassign stack offsets of the locals that are used.
 	lastHasPtr := false
 	for i, n := range fn.Dcl {
-		if n.Op() != ir.ONAME || n.Class() != ir.PAUTO {
+		if n.Op() != ir.ONAME || n.Class_ != ir.PAUTO {
 			continue
 		}
 		if !n.Used() {
@@ -207,7 +207,7 @@ func funccompile(fn *ir.Func) {
 	// assign parameter offsets
 	dowidth(fn.Type())
 
-	if fn.Body().Len() == 0 {
+	if fn.Body.Len() == 0 {
 		// Initialize ABI wrappers if necessary.
 		initLSym(fn, false)
 		emitptrargsmap(fn)
@@ -249,7 +249,7 @@ func compile(fn *ir.Func) {
 	// because symbols must be allocated before the parallel
 	// phase of the compiler.
 	for _, n := range fn.Dcl {
-		switch n.Class() {
+		switch n.Class_ {
 		case ir.PPARAM, ir.PPARAMOUT, ir.PAUTO:
 			if livenessShouldTrack(n) && n.Addrtaken() {
 				dtypesym(n.Type())
@@ -360,7 +360,7 @@ func compileFunctions() {
 			// since they're most likely to be the slowest.
 			// This helps avoid stragglers.
 			sort.Slice(compilequeue, func(i, j int) bool {
-				return compilequeue[i].Body().Len() > compilequeue[j].Body().Len()
+				return compilequeue[i].Body.Len() > compilequeue[j].Body.Len()
 			})
 		}
 		var wg sync.WaitGroup
@@ -440,7 +440,7 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 			if n.Op() != ir.ONAME { // might be OTYPE or OLITERAL
 				continue
 			}
-			switch n.Class() {
+			switch n.Class_ {
 			case ir.PAUTO:
 				if !n.Used() {
 					// Text == nil -> generating abstract function
@@ -533,7 +533,7 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 	var abbrev int
 	var offs int64
 
-	switch n.Class() {
+	switch n.Class_ {
 	case ir.PAUTO:
 		offs = n.FrameOffset()
 		abbrev = dwarf.DW_ABRV_AUTO
@@ -549,7 +549,7 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 		abbrev = dwarf.DW_ABRV_PARAM
 		offs = n.FrameOffset() + base.Ctxt.FixedFrameSize()
 	default:
-		base.Fatalf("createSimpleVar unexpected class %v for node %v", n.Class(), n)
+		base.Fatalf("createSimpleVar unexpected class %v for node %v", n.Class_, n)
 	}
 
 	typename := dwarf.InfoPrefix + typesymname(n.Type())
@@ -566,7 +566,7 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 	declpos := base.Ctxt.InnermostPos(declPos(n))
 	return &dwarf.Var{
 		Name:          n.Sym().Name,
-		IsReturnValue: n.Class() == ir.PPARAMOUT,
+		IsReturnValue: n.Class_ == ir.PPARAMOUT,
 		IsInlFormal:   n.Name().InlFormal(),
 		Abbrev:        abbrev,
 		StackOffset:   int32(offs),
@@ -643,7 +643,7 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 		if c == '.' || n.Type().IsUntyped() {
 			continue
 		}
-		if n.Class() == ir.PPARAM && !canSSAType(n.Type()) {
+		if n.Class_ == ir.PPARAM && !canSSAType(n.Type()) {
 			// SSA-able args get location lists, and may move in and
 			// out of registers, so those are handled elsewhere.
 			// Autos and named output params seem to get handled
@@ -658,10 +658,10 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 		typename := dwarf.InfoPrefix + typesymname(n.Type())
 		decls = append(decls, n)
 		abbrev := dwarf.DW_ABRV_AUTO_LOCLIST
-		isReturnValue := (n.Class() == ir.PPARAMOUT)
-		if n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT {
+		isReturnValue := (n.Class_ == ir.PPARAMOUT)
+		if n.Class_ == ir.PPARAM || n.Class_ == ir.PPARAMOUT {
 			abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
-		} else if n.Class() == ir.PAUTOHEAP {
+		} else if n.Class_ == ir.PAUTOHEAP {
 			// If dcl in question has been promoted to heap, do a bit
 			// of extra work to recover original class (auto or param);
 			// see issue 30908. This insures that we get the proper
@@ -670,9 +670,9 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 			// and not stack).
 			// TODO(thanm): generate a better location expression
 			stackcopy := n.Name().Stackcopy
-			if stackcopy != nil && (stackcopy.Class() == ir.PPARAM || stackcopy.Class() == ir.PPARAMOUT) {
+			if stackcopy != nil && (stackcopy.Class_ == ir.PPARAM || stackcopy.Class_ == ir.PPARAMOUT) {
 				abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
-				isReturnValue = (stackcopy.Class() == ir.PPARAMOUT)
+				isReturnValue = (stackcopy.Class_ == ir.PPARAMOUT)
 			}
 		}
 		inlIndex := 0
@@ -731,7 +731,7 @@ func preInliningDcls(fnsym *obj.LSym) []*ir.Name {
 func stackOffset(slot ssa.LocalSlot) int32 {
 	n := slot.N
 	var off int64
-	switch n.Class() {
+	switch n.Class_ {
 	case ir.PAUTO:
 		off = n.FrameOffset()
 		if base.Ctxt.FixedFrameSize() == 0 {
@@ -753,7 +753,7 @@ func createComplexVar(fnsym *obj.LSym, fn *ir.Func, varID ssa.VarID) *dwarf.Var
 	n := debug.Vars[varID]
 
 	var abbrev int
-	switch n.Class() {
+	switch n.Class_ {
 	case ir.PAUTO:
 		abbrev = dwarf.DW_ABRV_AUTO_LOCLIST
 	case ir.PPARAM, ir.PPARAMOUT:
@@ -777,7 +777,7 @@ func createComplexVar(fnsym *obj.LSym, fn *ir.Func, varID ssa.VarID) *dwarf.Var
 	declpos := base.Ctxt.InnermostPos(n.Pos())
 	dvar := &dwarf.Var{
 		Name:          n.Sym().Name,
-		IsReturnValue: n.Class() == ir.PPARAMOUT,
+		IsReturnValue: n.Class_ == ir.PPARAMOUT,
 		IsInlFormal:   n.Name().InlFormal(),
 		Abbrev:        abbrev,
 		Type:          base.Ctxt.Lookup(typename),
diff --git a/src/cmd/compile/internal/gc/pgen_test.go b/src/cmd/compile/internal/gc/pgen_test.go
index 3875fb7223..1170db2681 100644
--- a/src/cmd/compile/internal/gc/pgen_test.go
+++ b/src/cmd/compile/internal/gc/pgen_test.go
@@ -44,7 +44,7 @@ func TestCmpstackvar(t *testing.T) {
 		n := NewName(s)
 		n.SetType(t)
 		n.SetFrameOffset(xoffset)
-		n.SetClass(cl)
+		n.Class_ = cl
 		return n
 	}
 	testdata := []struct {
@@ -159,7 +159,7 @@ func TestStackvarSort(t *testing.T) {
 		n := NewName(s)
 		n.SetType(t)
 		n.SetFrameOffset(xoffset)
-		n.SetClass(cl)
+		n.Class_ = cl
 		return n
 	}
 	inp := []*ir.Name{
diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/gc/plive.go
index 77cd9c5b19..0b796ae7fa 100644
--- a/src/cmd/compile/internal/gc/plive.go
+++ b/src/cmd/compile/internal/gc/plive.go
@@ -211,7 +211,7 @@ func livenessShouldTrack(nn ir.Node) bool {
 		return false
 	}
 	n := nn.(*ir.Name)
-	return (n.Class() == ir.PAUTO || n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT) && n.Type().HasPointers()
+	return (n.Class_ == ir.PAUTO || n.Class_ == ir.PPARAM || n.Class_ == ir.PPARAMOUT) && n.Type().HasPointers()
 }
 
 // getvariables returns the list of on-stack variables that we need to track
@@ -238,7 +238,7 @@ func (lv *Liveness) initcache() {
 	lv.cache.initialized = true
 
 	for i, node := range lv.vars {
-		switch node.Class() {
+		switch node.Class_ {
 		case ir.PPARAM:
 			// A return instruction with a p.to is a tail return, which brings
 			// the stack pointer back up (if it ever went down) and then jumps
@@ -494,7 +494,7 @@ func (lv *Liveness) pointerMap(liveout bvec, vars []*ir.Name, args, locals bvec)
 			break
 		}
 		node := vars[i]
-		switch node.Class() {
+		switch node.Class_ {
 		case ir.PAUTO:
 			onebitwalktype1(node.Type(), node.FrameOffset()+lv.stkptrsize, locals)
 
@@ -795,7 +795,7 @@ func (lv *Liveness) epilogue() {
 	// don't need to keep the stack copy live?
 	if lv.fn.HasDefer() {
 		for i, n := range lv.vars {
-			if n.Class() == ir.PPARAMOUT {
+			if n.Class_ == ir.PPARAMOUT {
 				if n.Name().IsOutputParamHeapAddr() {
 					// Just to be paranoid.  Heap addresses are PAUTOs.
 					base.Fatalf("variable %v both output param and heap output param", n)
@@ -893,7 +893,7 @@ func (lv *Liveness) epilogue() {
 				if !liveout.Get(int32(i)) {
 					continue
 				}
-				if n.Class() == ir.PPARAM {
+				if n.Class_ == ir.PPARAM {
 					continue // ok
 				}
 				base.Fatalf("bad live variable at entry of %v: %L", lv.fn.Nname, n)
@@ -926,7 +926,7 @@ func (lv *Liveness) epilogue() {
 	// the only things that can possibly be live are the
 	// input parameters.
 	for j, n := range lv.vars {
-		if n.Class() != ir.PPARAM && lv.stackMaps[0].Get(int32(j)) {
+		if n.Class_ != ir.PPARAM && lv.stackMaps[0].Get(int32(j)) {
 			lv.f.Fatalf("%v %L recorded as live on entry", lv.fn.Nname, n)
 		}
 	}
@@ -1171,7 +1171,7 @@ func (lv *Liveness) emit() (argsSym, liveSym *obj.LSym) {
 	// (Nodes without pointers aren't in lv.vars; see livenessShouldTrack.)
 	var maxArgNode *ir.Name
 	for _, n := range lv.vars {
-		switch n.Class() {
+		switch n.Class_ {
 		case ir.PPARAM, ir.PPARAMOUT:
 			if maxArgNode == nil || n.FrameOffset() > maxArgNode.FrameOffset() {
 				maxArgNode = n
diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index 4a753328f2..3aa4ff71fa 100644
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -27,7 +27,7 @@ func typecheckrange(n *ir.RangeStmt) {
 
 	// second half of dance, the first half being typecheckrangeExpr
 	n.SetTypecheck(1)
-	ls := n.List().Slice()
+	ls := n.Vars.Slice()
 	for i1, n1 := range ls {
 		if n1.Typecheck() == 0 {
 			ls[i1] = typecheck(ls[i1], ctxExpr|ctxAssign)
@@ -35,19 +35,19 @@ func typecheckrange(n *ir.RangeStmt) {
 	}
 
 	decldepth++
-	typecheckslice(n.Body().Slice(), ctxStmt)
+	typecheckslice(n.Body.Slice(), ctxStmt)
 	decldepth--
 }
 
 func typecheckrangeExpr(n *ir.RangeStmt) {
-	n.SetRight(typecheck(n.Right(), ctxExpr))
+	n.X = typecheck(n.X, ctxExpr)
 
-	t := n.Right().Type()
+	t := n.X.Type()
 	if t == nil {
 		return
 	}
 	// delicate little dance.  see typecheckas2
-	ls := n.List().Slice()
+	ls := n.Vars.Slice()
 	for i1, n1 := range ls {
 		if !ir.DeclaredBy(n1, n) {
 			ls[i1] = typecheck(ls[i1], ctxExpr|ctxAssign)
@@ -63,7 +63,7 @@ func typecheckrangeExpr(n *ir.RangeStmt) {
 	toomany := false
 	switch t.Kind() {
 	default:
-		base.ErrorfAt(n.Pos(), "cannot range over %L", n.Right())
+		base.ErrorfAt(n.Pos(), "cannot range over %L", n.X)
 		return
 
 	case types.TARRAY, types.TSLICE:
@@ -76,13 +76,13 @@ func typecheckrangeExpr(n *ir.RangeStmt) {
 
 	case types.TCHAN:
 		if !t.ChanDir().CanRecv() {
-			base.ErrorfAt(n.Pos(), "invalid operation: range %v (receive from send-only type %v)", n.Right(), n.Right().Type())
+			base.ErrorfAt(n.Pos(), "invalid operation: range %v (receive from send-only type %v)", n.X, n.X.Type())
 			return
 		}
 
 		t1 = t.Elem()
 		t2 = nil
-		if n.List().Len() == 2 {
+		if n.Vars.Len() == 2 {
 			toomany = true
 		}
 
@@ -91,16 +91,16 @@ func typecheckrangeExpr(n *ir.RangeStmt) {
 		t2 = types.RuneType
 	}
 
-	if n.List().Len() > 2 || toomany {
+	if n.Vars.Len() > 2 || toomany {
 		base.ErrorfAt(n.Pos(), "too many variables in range")
 	}
 
 	var v1, v2 ir.Node
-	if n.List().Len() != 0 {
-		v1 = n.List().First()
+	if n.Vars.Len() != 0 {
+		v1 = n.Vars.First()
 	}
-	if n.List().Len() > 1 {
-		v2 = n.List().Second()
+	if n.Vars.Len() > 1 {
+		v2 = n.Vars.Second()
 	}
 
 	// this is not only an optimization but also a requirement in the spec.
@@ -109,7 +109,7 @@ func typecheckrangeExpr(n *ir.RangeStmt) {
 	// present."
 	if ir.IsBlank(v2) {
 		if v1 != nil {
-			n.PtrList().Set1(v1)
+			n.Vars.Set1(v1)
 		}
 		v2 = nil
 	}
@@ -159,7 +159,7 @@ func cheapComputableIndex(width int64) bool {
 // the returned node.
 func walkrange(nrange *ir.RangeStmt) ir.Node {
 	if isMapClear(nrange) {
-		m := nrange.Right()
+		m := nrange.X
 		lno := setlineno(m)
 		n := mapClear(m)
 		base.Pos = lno
@@ -168,7 +168,7 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 
 	nfor := ir.NewForStmt(nrange.Pos(), nil, nil, nil, nil)
 	nfor.SetInit(nrange.Init())
-	nfor.SetSym(nrange.Sym())
+	nfor.Label = nrange.Label
 
 	// variable name conventions:
 	//	ohv1, hv1, hv2: hidden (old) val 1, 2
@@ -179,17 +179,17 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 
 	t := nrange.Type()
 
-	a := nrange.Right()
+	a := nrange.X
 	lno := setlineno(a)
 
 	var v1, v2 ir.Node
-	l := nrange.List().Len()
+	l := nrange.Vars.Len()
 	if l > 0 {
-		v1 = nrange.List().First()
+		v1 = nrange.Vars.First()
 	}
 
 	if l > 1 {
-		v2 = nrange.List().Second()
+		v2 = nrange.Vars.Second()
 	}
 
 	if ir.IsBlank(v2) {
@@ -227,8 +227,8 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		init = append(init, ir.NewAssignStmt(base.Pos, hv1, nil))
 		init = append(init, ir.NewAssignStmt(base.Pos, hn, ir.NewUnaryExpr(base.Pos, ir.OLEN, ha)))
 
-		nfor.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OLT, hv1, hn))
-		nfor.SetRight(ir.NewAssignStmt(base.Pos, hv1, ir.NewBinaryExpr(base.Pos, ir.OADD, hv1, nodintconst(1))))
+		nfor.Cond = ir.NewBinaryExpr(base.Pos, ir.OLT, hv1, hn)
+		nfor.Post = ir.NewAssignStmt(base.Pos, hv1, ir.NewBinaryExpr(base.Pos, ir.OADD, hv1, nodintconst(1)))
 
 		// for range ha { body }
 		if v1 == nil {
@@ -249,8 +249,8 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 			// Use OAS2 to correctly handle assignments
 			// of the form "v1, a[v1] := range".
 			a := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-			a.PtrList().Set2(v1, v2)
-			a.PtrRlist().Set2(hv1, tmp)
+			a.Lhs.Set2(v1, v2)
+			a.Rhs.Set2(hv1, tmp)
 			body = []ir.Node{a}
 			break
 		}
@@ -268,7 +268,7 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		// elimination on the index variable (see #20711).
 		// Enhance the prove pass to understand this.
 		ifGuard = ir.NewIfStmt(base.Pos, nil, nil, nil)
-		ifGuard.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OLT, hv1, hn))
+		ifGuard.Cond = ir.NewBinaryExpr(base.Pos, ir.OLT, hv1, hn)
 		nfor.SetOp(ir.OFORUNTIL)
 
 		hp := temp(types.NewPtr(nrange.Type().Elem()))
@@ -279,8 +279,8 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		// Use OAS2 to correctly handle assignments
 		// of the form "v1, a[v1] := range".
 		a := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-		a.PtrList().Set2(v1, v2)
-		a.PtrRlist().Set2(hv1, ir.NewStarExpr(base.Pos, hp))
+		a.Lhs.Set2(v1, v2)
+		a.Rhs.Set2(hv1, ir.NewStarExpr(base.Pos, hp))
 		body = append(body, a)
 
 		// Advance pointer as part of the late increment.
@@ -289,7 +289,7 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		// advancing the pointer is safe and won't go past the
 		// end of the allocation.
 		as := ir.NewAssignStmt(base.Pos, hp, addptr(hp, t.Elem().Width))
-		nfor.PtrList().Set1(typecheck(as, ctxStmt))
+		nfor.Late.Set1(typecheck(as, ctxStmt))
 
 	case types.TMAP:
 		// order.stmt allocated the iterator for us.
@@ -305,11 +305,11 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 
 		fn = substArgTypes(fn, t.Key(), t.Elem(), th)
 		init = append(init, mkcall1(fn, nil, nil, typename(t), ha, nodAddr(hit)))
-		nfor.SetLeft(ir.NewBinaryExpr(base.Pos, ir.ONE, ir.NewSelectorExpr(base.Pos, ir.ODOT, hit, keysym), nodnil()))
+		nfor.Cond = ir.NewBinaryExpr(base.Pos, ir.ONE, ir.NewSelectorExpr(base.Pos, ir.ODOT, hit, keysym), nodnil())
 
 		fn = syslook("mapiternext")
 		fn = substArgTypes(fn, th)
-		nfor.SetRight(mkcall1(fn, nil, nil, nodAddr(hit)))
+		nfor.Post = mkcall1(fn, nil, nil, nodAddr(hit))
 
 		key := ir.NewStarExpr(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, hit, keysym))
 		if v1 == nil {
@@ -319,8 +319,8 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		} else {
 			elem := ir.NewStarExpr(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, hit, elemsym))
 			a := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-			a.PtrList().Set2(v1, v2)
-			a.PtrRlist().Set2(key, elem)
+			a.Lhs.Set2(v1, v2)
+			a.Rhs.Set2(key, elem)
 			body = []ir.Node{a}
 		}
 
@@ -335,12 +335,12 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		}
 		hb := temp(types.Types[types.TBOOL])
 
-		nfor.SetLeft(ir.NewBinaryExpr(base.Pos, ir.ONE, hb, nodbool(false)))
+		nfor.Cond = ir.NewBinaryExpr(base.Pos, ir.ONE, hb, nodbool(false))
 		a := ir.NewAssignListStmt(base.Pos, ir.OAS2RECV, nil, nil)
 		a.SetTypecheck(1)
-		a.PtrList().Set2(hv1, hb)
-		a.PtrRlist().Set1(ir.NewUnaryExpr(base.Pos, ir.ORECV, ha))
-		nfor.Left().PtrInit().Set1(a)
+		a.Lhs.Set2(hv1, hb)
+		a.Rhs.Set1(ir.NewUnaryExpr(base.Pos, ir.ORECV, ha))
+		nfor.Cond.PtrInit().Set1(a)
 		if v1 == nil {
 			body = nil
 		} else {
@@ -378,7 +378,7 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		init = append(init, ir.NewAssignStmt(base.Pos, hv1, nil))
 
 		// hv1 < len(ha)
-		nfor.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OLT, hv1, ir.NewUnaryExpr(base.Pos, ir.OLEN, ha)))
+		nfor.Cond = ir.NewBinaryExpr(base.Pos, ir.OLT, hv1, ir.NewUnaryExpr(base.Pos, ir.OLEN, ha))
 
 		if v1 != nil {
 			// hv1t = hv1
@@ -392,19 +392,19 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 
 		// if hv2 < utf8.RuneSelf
 		nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
-		nif.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OLT, hv2, nodintconst(utf8.RuneSelf)))
+		nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OLT, hv2, nodintconst(utf8.RuneSelf))
 
 		// hv1++
-		nif.PtrBody().Set1(ir.NewAssignStmt(base.Pos, hv1, ir.NewBinaryExpr(base.Pos, ir.OADD, hv1, nodintconst(1))))
+		nif.Body.Set1(ir.NewAssignStmt(base.Pos, hv1, ir.NewBinaryExpr(base.Pos, ir.OADD, hv1, nodintconst(1))))
 
 		// } else {
 		eif := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-		nif.PtrRlist().Set1(eif)
+		nif.Else.Set1(eif)
 
 		// hv2, hv1 = decoderune(ha, hv1)
-		eif.PtrList().Set2(hv2, hv1)
+		eif.Lhs.Set2(hv2, hv1)
 		fn := syslook("decoderune")
-		eif.PtrRlist().Set1(mkcall1(fn, fn.Type().Results(), nil, ha, hv1))
+		eif.Rhs.Set1(mkcall1(fn, fn.Type().Results(), nil, ha, hv1))
 
 		body = append(body, nif)
 
@@ -412,8 +412,8 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 			if v2 != nil {
 				// v1, v2 = hv1t, hv2
 				a := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-				a.PtrList().Set2(v1, v2)
-				a.PtrRlist().Set2(hv1t, hv2)
+				a.Lhs.Set2(v1, v2)
+				a.Rhs.Set2(hv1t, hv2)
 				body = append(body, a)
 			} else {
 				// v1 = hv1t
@@ -431,18 +431,18 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		nfor.PtrInit().Append(init...)
 	}
 
-	typecheckslice(nfor.Left().Init().Slice(), ctxStmt)
+	typecheckslice(nfor.Cond.Init().Slice(), ctxStmt)
 
-	nfor.SetLeft(typecheck(nfor.Left(), ctxExpr))
-	nfor.SetLeft(defaultlit(nfor.Left(), nil))
-	nfor.SetRight(typecheck(nfor.Right(), ctxStmt))
+	nfor.Cond = typecheck(nfor.Cond, ctxExpr)
+	nfor.Cond = defaultlit(nfor.Cond, nil)
+	nfor.Post = typecheck(nfor.Post, ctxStmt)
 	typecheckslice(body, ctxStmt)
-	nfor.PtrBody().Append(body...)
-	nfor.PtrBody().Append(nrange.Body().Slice()...)
+	nfor.Body.Append(body...)
+	nfor.Body.Append(nrange.Body.Slice()...)
 
 	var n ir.Node = nfor
 	if ifGuard != nil {
-		ifGuard.PtrBody().Set1(n)
+		ifGuard.Body.Set1(n)
 		n = ifGuard
 	}
 
@@ -464,11 +464,11 @@ func isMapClear(n *ir.RangeStmt) bool {
 		return false
 	}
 
-	if n.Op() != ir.ORANGE || n.Type().Kind() != types.TMAP || n.List().Len() != 1 {
+	if n.Op() != ir.ORANGE || n.Type().Kind() != types.TMAP || n.Vars.Len() != 1 {
 		return false
 	}
 
-	k := n.List().First()
+	k := n.Vars.First()
 	if k == nil || ir.IsBlank(k) {
 		return false
 	}
@@ -478,17 +478,17 @@ func isMapClear(n *ir.RangeStmt) bool {
 		return false
 	}
 
-	if n.Body().Len() != 1 {
+	if n.Body.Len() != 1 {
 		return false
 	}
 
-	stmt := n.Body().First() // only stmt in body
+	stmt := n.Body.First() // only stmt in body
 	if stmt == nil || stmt.Op() != ir.ODELETE {
 		return false
 	}
 
-	m := n.Right()
-	if delete := stmt.(*ir.CallExpr); !samesafeexpr(delete.List().First(), m) || !samesafeexpr(delete.List().Second(), k) {
+	m := n.X
+	if delete := stmt.(*ir.CallExpr); !samesafeexpr(delete.Args.First(), m) || !samesafeexpr(delete.Args.Second(), k) {
 		return false
 	}
 
@@ -531,26 +531,26 @@ func arrayClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
 		return nil
 	}
 
-	if loop.Body().Len() != 1 || loop.Body().First() == nil {
+	if loop.Body.Len() != 1 || loop.Body.First() == nil {
 		return nil
 	}
 
-	stmt1 := loop.Body().First() // only stmt in body
+	stmt1 := loop.Body.First() // only stmt in body
 	if stmt1.Op() != ir.OAS {
 		return nil
 	}
 	stmt := stmt1.(*ir.AssignStmt)
-	if stmt.Left().Op() != ir.OINDEX {
+	if stmt.X.Op() != ir.OINDEX {
 		return nil
 	}
-	lhs := stmt.Left().(*ir.IndexExpr)
+	lhs := stmt.X.(*ir.IndexExpr)
 
-	if !samesafeexpr(lhs.Left(), a) || !samesafeexpr(lhs.Right(), v1) {
+	if !samesafeexpr(lhs.X, a) || !samesafeexpr(lhs.Index, v1) {
 		return nil
 	}
 
 	elemsize := loop.Type().Elem().Width
-	if elemsize <= 0 || !isZero(stmt.Right()) {
+	if elemsize <= 0 || !isZero(stmt.Y) {
 		return nil
 	}
 
@@ -562,8 +562,8 @@ func arrayClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
 	// 	i = len(a) - 1
 	// }
 	n := ir.NewIfStmt(base.Pos, nil, nil, nil)
-	n.PtrBody().Set(nil)
-	n.SetLeft(ir.NewBinaryExpr(base.Pos, ir.ONE, ir.NewUnaryExpr(base.Pos, ir.OLEN, a), nodintconst(0)))
+	n.Body.Set(nil)
+	n.Cond = ir.NewBinaryExpr(base.Pos, ir.ONE, ir.NewUnaryExpr(base.Pos, ir.OLEN, a), nodintconst(0))
 
 	// hp = &a[0]
 	hp := temp(types.Types[types.TUNSAFEPTR])
@@ -571,12 +571,12 @@ func arrayClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
 	ix := ir.NewIndexExpr(base.Pos, a, nodintconst(0))
 	ix.SetBounded(true)
 	addr := convnop(nodAddr(ix), types.Types[types.TUNSAFEPTR])
-	n.PtrBody().Append(ir.NewAssignStmt(base.Pos, hp, addr))
+	n.Body.Append(ir.NewAssignStmt(base.Pos, hp, addr))
 
 	// hn = len(a) * sizeof(elem(a))
 	hn := temp(types.Types[types.TUINTPTR])
 	mul := conv(ir.NewBinaryExpr(base.Pos, ir.OMUL, ir.NewUnaryExpr(base.Pos, ir.OLEN, a), nodintconst(elemsize)), types.Types[types.TUINTPTR])
-	n.PtrBody().Append(ir.NewAssignStmt(base.Pos, hn, mul))
+	n.Body.Append(ir.NewAssignStmt(base.Pos, hn, mul))
 
 	var fn ir.Node
 	if a.Type().Elem().HasPointers() {
@@ -588,16 +588,16 @@ func arrayClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
 		fn = mkcall("memclrNoHeapPointers", nil, nil, hp, hn)
 	}
 
-	n.PtrBody().Append(fn)
+	n.Body.Append(fn)
 
 	// i = len(a) - 1
 	v1 = ir.NewAssignStmt(base.Pos, v1, ir.NewBinaryExpr(base.Pos, ir.OSUB, ir.NewUnaryExpr(base.Pos, ir.OLEN, a), nodintconst(1)))
 
-	n.PtrBody().Append(v1)
+	n.Body.Append(v1)
 
-	n.SetLeft(typecheck(n.Left(), ctxExpr))
-	n.SetLeft(defaultlit(n.Left(), nil))
-	typecheckslice(n.Body().Slice(), ctxStmt)
+	n.Cond = typecheck(n.Cond, ctxExpr)
+	n.Cond = defaultlit(n.Cond, nil)
+	typecheckslice(n.Body.Slice(), ctxStmt)
 	return walkstmt(n)
 }
 
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 92b04f20d5..07552e64b4 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -994,7 +994,7 @@ func typename(t *types.Type) *ir.AddrExpr {
 	if s.Def == nil {
 		n := ir.NewNameAt(src.NoXPos, s)
 		n.SetType(types.Types[types.TUINT8])
-		n.SetClass(ir.PEXTERN)
+		n.Class_ = ir.PEXTERN
 		n.SetTypecheck(1)
 		s.Def = n
 	}
@@ -1013,7 +1013,7 @@ func itabname(t, itype *types.Type) *ir.AddrExpr {
 	if s.Def == nil {
 		n := NewName(s)
 		n.SetType(types.Types[types.TUINT8])
-		n.SetClass(ir.PEXTERN)
+		n.Class_ = ir.PEXTERN
 		n.SetTypecheck(1)
 		s.Def = n
 		itabs = append(itabs, itabEntry{t: t, itype: itype, lsym: s.Linksym()})
@@ -1875,7 +1875,7 @@ func zeroaddr(size int64) ir.Node {
 	if s.Def == nil {
 		x := NewName(s)
 		x.SetType(types.Types[types.TUINT8])
-		x.SetClass(ir.PEXTERN)
+		x.Class_ = ir.PEXTERN
 		x.SetTypecheck(1)
 		s.Def = x
 	}
diff --git a/src/cmd/compile/internal/gc/scc.go b/src/cmd/compile/internal/gc/scc.go
index f2d089fa4c..a5a6480958 100644
--- a/src/cmd/compile/internal/gc/scc.go
+++ b/src/cmd/compile/internal/gc/scc.go
@@ -58,7 +58,7 @@ func visitBottomUp(list []ir.Node, analyze func(list []*ir.Func, recursive bool)
 	for _, n := range list {
 		if n.Op() == ir.ODCLFUNC {
 			n := n.(*ir.Func)
-			if !n.Func().IsHiddenClosure() {
+			if !n.IsHiddenClosure() {
 				v.visit(n)
 			}
 		}
@@ -82,7 +82,7 @@ func (v *bottomUpVisitor) visit(n *ir.Func) uint32 {
 		switch n.Op() {
 		case ir.ONAME:
 			n := n.(*ir.Name)
-			if n.Class() == ir.PFUNC {
+			if n.Class_ == ir.PFUNC {
 				if n != nil && n.Name().Defn != nil {
 					if m := v.visit(n.Name().Defn.(*ir.Func)); m < min {
 						min = m
@@ -100,7 +100,7 @@ func (v *bottomUpVisitor) visit(n *ir.Func) uint32 {
 		case ir.ODOTMETH:
 			n := n.(*ir.SelectorExpr)
 			fn := methodExprName(n)
-			if fn != nil && fn.Op() == ir.ONAME && fn.Class() == ir.PFUNC && fn.Defn != nil {
+			if fn != nil && fn.Op() == ir.ONAME && fn.Class_ == ir.PFUNC && fn.Defn != nil {
 				if m := v.visit(fn.Defn.(*ir.Func)); m < min {
 					min = m
 				}
@@ -109,7 +109,7 @@ func (v *bottomUpVisitor) visit(n *ir.Func) uint32 {
 			n := n.(*ir.CallPartExpr)
 			fn := ir.AsNode(callpartMethod(n).Nname)
 			if fn != nil && fn.Op() == ir.ONAME {
-				if fn := fn.(*ir.Name); fn.Class() == ir.PFUNC && fn.Name().Defn != nil {
+				if fn := fn.(*ir.Name); fn.Class_ == ir.PFUNC && fn.Name().Defn != nil {
 					if m := v.visit(fn.Name().Defn.(*ir.Func)); m < min {
 						min = m
 					}
@@ -117,7 +117,7 @@ func (v *bottomUpVisitor) visit(n *ir.Func) uint32 {
 			}
 		case ir.OCLOSURE:
 			n := n.(*ir.ClosureExpr)
-			if m := v.visit(n.Func()); m < min {
+			if m := v.visit(n.Func); m < min {
 				min = m
 			}
 		}
diff --git a/src/cmd/compile/internal/gc/scope.go b/src/cmd/compile/internal/gc/scope.go
index 8dd44b1dd4..9ab33583c8 100644
--- a/src/cmd/compile/internal/gc/scope.go
+++ b/src/cmd/compile/internal/gc/scope.go
@@ -30,13 +30,13 @@ func findScope(marks []ir.Mark, pos src.XPos) ir.ScopeID {
 
 func assembleScopes(fnsym *obj.LSym, fn *ir.Func, dwarfVars []*dwarf.Var, varScopes []ir.ScopeID) []dwarf.Scope {
 	// Initialize the DWARF scope tree based on lexical scopes.
-	dwarfScopes := make([]dwarf.Scope, 1+len(fn.Func().Parents))
-	for i, parent := range fn.Func().Parents {
+	dwarfScopes := make([]dwarf.Scope, 1+len(fn.Parents))
+	for i, parent := range fn.Parents {
 		dwarfScopes[i+1].Parent = int32(parent)
 	}
 
 	scopeVariables(dwarfVars, varScopes, dwarfScopes)
-	scopePCs(fnsym, fn.Func().Marks, dwarfScopes)
+	scopePCs(fnsym, fn.Marks, dwarfScopes)
 	return compactScopes(dwarfScopes)
 }
 
diff --git a/src/cmd/compile/internal/gc/select.go b/src/cmd/compile/internal/gc/select.go
index 64d3461dca..5c69be7e06 100644
--- a/src/cmd/compile/internal/gc/select.go
+++ b/src/cmd/compile/internal/gc/select.go
@@ -15,30 +15,30 @@ func typecheckselect(sel *ir.SelectStmt) {
 	var def ir.Node
 	lno := setlineno(sel)
 	typecheckslice(sel.Init().Slice(), ctxStmt)
-	for _, ncase := range sel.List().Slice() {
+	for _, ncase := range sel.Cases.Slice() {
 		ncase := ncase.(*ir.CaseStmt)
 
-		if ncase.List().Len() == 0 {
+		if ncase.List.Len() == 0 {
 			// default
 			if def != nil {
 				base.ErrorfAt(ncase.Pos(), "multiple defaults in select (first at %v)", ir.Line(def))
 			} else {
 				def = ncase
 			}
-		} else if ncase.List().Len() > 1 {
+		} else if ncase.List.Len() > 1 {
 			base.ErrorfAt(ncase.Pos(), "select cases cannot be lists")
 		} else {
-			ncase.List().SetFirst(typecheck(ncase.List().First(), ctxStmt))
-			n := ncase.List().First()
-			ncase.SetLeft(n)
-			ncase.PtrList().Set(nil)
+			ncase.List.SetFirst(typecheck(ncase.List.First(), ctxStmt))
+			n := ncase.List.First()
+			ncase.Comm = n
+			ncase.List.Set(nil)
 			oselrecv2 := func(dst, recv ir.Node, colas bool) {
 				n := ir.NewAssignListStmt(n.Pos(), ir.OSELRECV2, nil, nil)
-				n.PtrList().Set2(dst, ir.BlankNode)
-				n.PtrRlist().Set1(recv)
-				n.SetColas(colas)
+				n.Lhs.Set2(dst, ir.BlankNode)
+				n.Rhs.Set1(recv)
+				n.Def = colas
 				n.SetTypecheck(1)
-				ncase.SetLeft(n)
+				ncase.Comm = n
 			}
 			switch n.Op() {
 			default:
@@ -57,21 +57,21 @@ func typecheckselect(sel *ir.SelectStmt) {
 				// remove implicit conversions; the eventual assignment
 				// will reintroduce them.
 				n := n.(*ir.AssignStmt)
-				if r := n.Right(); r.Op() == ir.OCONVNOP || r.Op() == ir.OCONVIFACE {
+				if r := n.Y; r.Op() == ir.OCONVNOP || r.Op() == ir.OCONVIFACE {
 					r := r.(*ir.ConvExpr)
 					if r.Implicit() {
-						n.SetRight(r.Left())
+						n.Y = r.X
 					}
 				}
-				if n.Right().Op() != ir.ORECV {
+				if n.Y.Op() != ir.ORECV {
 					base.ErrorfAt(n.Pos(), "select assignment must have receive on right hand side")
 					break
 				}
-				oselrecv2(n.Left(), n.Right(), n.Colas())
+				oselrecv2(n.X, n.Y, n.Def)
 
 			case ir.OAS2RECV:
 				n := n.(*ir.AssignListStmt)
-				if n.Rlist().First().Op() != ir.ORECV {
+				if n.Rhs.First().Op() != ir.ORECV {
 					base.ErrorfAt(n.Pos(), "select assignment must have receive on right hand side")
 					break
 				}
@@ -87,7 +87,7 @@ func typecheckselect(sel *ir.SelectStmt) {
 			}
 		}
 
-		typecheckslice(ncase.Body().Slice(), ctxStmt)
+		typecheckslice(ncase.Body.Slice(), ctxStmt)
 	}
 
 	base.Pos = lno
@@ -95,18 +95,18 @@ func typecheckselect(sel *ir.SelectStmt) {
 
 func walkselect(sel *ir.SelectStmt) {
 	lno := setlineno(sel)
-	if sel.Body().Len() != 0 {
+	if sel.Compiled.Len() != 0 {
 		base.Fatalf("double walkselect")
 	}
 
 	init := sel.Init().Slice()
 	sel.PtrInit().Set(nil)
 
-	init = append(init, walkselectcases(sel.List())...)
-	sel.SetList(ir.Nodes{})
+	init = append(init, walkselectcases(sel.Cases)...)
+	sel.Cases = ir.Nodes{}
 
-	sel.PtrBody().Set(init)
-	walkstmtlist(sel.Body().Slice())
+	sel.Compiled.Set(init)
+	walkstmtlist(sel.Compiled.Slice())
 
 	base.Pos = lno
 }
@@ -125,8 +125,8 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 		cas := cases.First().(*ir.CaseStmt)
 		setlineno(cas)
 		l := cas.Init().Slice()
-		if cas.Left() != nil { // not default:
-			n := cas.Left()
+		if cas.Comm != nil { // not default:
+			n := cas.Comm
 			l = append(l, n.Init().Slice()...)
 			n.PtrInit().Set(nil)
 			switch n.Op() {
@@ -138,8 +138,8 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 
 			case ir.OSELRECV2:
 				r := n.(*ir.AssignListStmt)
-				if ir.IsBlank(r.List().First()) && ir.IsBlank(r.List().Second()) {
-					n = r.Rlist().First()
+				if ir.IsBlank(r.Lhs.First()) && ir.IsBlank(r.Lhs.Second()) {
+					n = r.Rhs.First()
 					break
 				}
 				r.SetOp(ir.OAS2RECV)
@@ -148,7 +148,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 			l = append(l, n)
 		}
 
-		l = append(l, cas.Body().Slice()...)
+		l = append(l, cas.Body.Slice()...)
 		l = append(l, ir.NewBranchStmt(base.Pos, ir.OBREAK, nil))
 		return l
 	}
@@ -159,7 +159,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 	for _, cas := range cases.Slice() {
 		cas := cas.(*ir.CaseStmt)
 		setlineno(cas)
-		n := cas.Left()
+		n := cas.Comm
 		if n == nil {
 			dflt = cas
 			continue
@@ -167,14 +167,14 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 		switch n.Op() {
 		case ir.OSEND:
 			n := n.(*ir.SendStmt)
-			n.SetRight(nodAddr(n.Right()))
-			n.SetRight(typecheck(n.Right(), ctxExpr))
+			n.Value = nodAddr(n.Value)
+			n.Value = typecheck(n.Value, ctxExpr)
 
 		case ir.OSELRECV2:
 			n := n.(*ir.AssignListStmt)
-			if !ir.IsBlank(n.List().First()) {
-				n.List().SetIndex(0, nodAddr(n.List().First()))
-				n.List().SetIndex(0, typecheck(n.List().First(), ctxExpr))
+			if !ir.IsBlank(n.Lhs.First()) {
+				n.Lhs.SetIndex(0, nodAddr(n.Lhs.First()))
+				n.Lhs.SetIndex(0, typecheck(n.Lhs.First(), ctxExpr))
 			}
 		}
 	}
@@ -186,7 +186,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 			cas = cases.Second().(*ir.CaseStmt)
 		}
 
-		n := cas.Left()
+		n := cas.Comm
 		setlineno(n)
 		r := ir.NewIfStmt(base.Pos, nil, nil, nil)
 		r.PtrInit().Set(cas.Init().Slice())
@@ -198,31 +198,31 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 		case ir.OSEND:
 			// if selectnbsend(c, v) { body } else { default body }
 			n := n.(*ir.SendStmt)
-			ch := n.Left()
-			call = mkcall1(chanfn("selectnbsend", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), ch, n.Right())
+			ch := n.Chan
+			call = mkcall1(chanfn("selectnbsend", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), ch, n.Value)
 
 		case ir.OSELRECV2:
 			n := n.(*ir.AssignListStmt)
-			recv := n.Rlist().First().(*ir.UnaryExpr)
-			ch := recv.Left()
-			elem := n.List().First()
+			recv := n.Rhs.First().(*ir.UnaryExpr)
+			ch := recv.X
+			elem := n.Lhs.First()
 			if ir.IsBlank(elem) {
 				elem = nodnil()
 			}
-			if ir.IsBlank(n.List().Second()) {
+			if ir.IsBlank(n.Lhs.Second()) {
 				// if selectnbrecv(&v, c) { body } else { default body }
 				call = mkcall1(chanfn("selectnbrecv", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), elem, ch)
 			} else {
 				// TODO(cuonglm): make this use selectnbrecv()
 				// if selectnbrecv2(&v, &received, c) { body } else { default body }
-				receivedp := typecheck(nodAddr(n.List().Second()), ctxExpr)
+				receivedp := typecheck(nodAddr(n.Lhs.Second()), ctxExpr)
 				call = mkcall1(chanfn("selectnbrecv2", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), elem, receivedp, ch)
 			}
 		}
 
-		r.SetLeft(typecheck(call, ctxExpr))
-		r.PtrBody().Set(cas.Body().Slice())
-		r.PtrRlist().Set(append(dflt.Init().Slice(), dflt.Body().Slice()...))
+		r.Cond = typecheck(call, ctxExpr)
+		r.Body.Set(cas.Body.Slice())
+		r.Else.Set(append(dflt.Init().Slice(), dflt.Body.Slice()...))
 		return []ir.Node{r, ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)}
 	}
 
@@ -258,7 +258,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 		init = append(init, cas.Init().Slice()...)
 		cas.PtrInit().Set(nil)
 
-		n := cas.Left()
+		n := cas.Comm
 		if n == nil { // default:
 			continue
 		}
@@ -272,15 +272,15 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 			n := n.(*ir.SendStmt)
 			i = nsends
 			nsends++
-			c = n.Left()
-			elem = n.Right()
+			c = n.Chan
+			elem = n.Value
 		case ir.OSELRECV2:
 			n := n.(*ir.AssignListStmt)
 			nrecvs++
 			i = ncas - nrecvs
-			recv := n.Rlist().First().(*ir.UnaryExpr)
-			c = recv.Left()
-			elem = n.List().First()
+			recv := n.Rhs.First().(*ir.UnaryExpr)
+			c = recv.X
+			elem = n.Lhs.First()
 		}
 
 		casorder[i] = cas
@@ -313,9 +313,9 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 	chosen := temp(types.Types[types.TINT])
 	recvOK := temp(types.Types[types.TBOOL])
 	r := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-	r.PtrList().Set2(chosen, recvOK)
+	r.Lhs.Set2(chosen, recvOK)
 	fn := syslook("selectgo")
-	r.PtrRlist().Set1(mkcall1(fn, fn.Type().Results(), nil, bytePtrToIndex(selv, 0), bytePtrToIndex(order, 0), pc0, nodintconst(int64(nsends)), nodintconst(int64(nrecvs)), nodbool(dflt == nil)))
+	r.Rhs.Set1(mkcall1(fn, fn.Type().Results(), nil, bytePtrToIndex(selv, 0), bytePtrToIndex(order, 0), pc0, nodintconst(int64(nsends)), nodintconst(int64(nrecvs)), nodbool(dflt == nil)))
 	init = append(init, typecheck(r, ctxStmt))
 
 	// selv and order are no longer alive after selectgo.
@@ -332,16 +332,16 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 
 		r := ir.NewIfStmt(base.Pos, cond, nil, nil)
 
-		if n := cas.Left(); n != nil && n.Op() == ir.OSELRECV2 {
+		if n := cas.Comm; n != nil && n.Op() == ir.OSELRECV2 {
 			n := n.(*ir.AssignListStmt)
-			if !ir.IsBlank(n.List().Second()) {
-				x := ir.NewAssignStmt(base.Pos, n.List().Second(), recvOK)
-				r.PtrBody().Append(typecheck(x, ctxStmt))
+			if !ir.IsBlank(n.Lhs.Second()) {
+				x := ir.NewAssignStmt(base.Pos, n.Lhs.Second(), recvOK)
+				r.Body.Append(typecheck(x, ctxStmt))
 			}
 		}
 
-		r.PtrBody().AppendNodes(cas.PtrBody())
-		r.PtrBody().Append(ir.NewBranchStmt(base.Pos, ir.OBREAK, nil))
+		r.Body.AppendNodes(&cas.Body)
+		r.Body.Append(ir.NewBranchStmt(base.Pos, ir.OBREAK, nil))
 		init = append(init, r)
 	}
 
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index f4988df9ac..0fc19a6989 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -61,25 +61,25 @@ func (s *InitSchedule) tryStaticInit(nn ir.Node) bool {
 		return false
 	}
 	n := nn.(*ir.AssignStmt)
-	if ir.IsBlank(n.Left()) && !anySideEffects(n.Right()) {
+	if ir.IsBlank(n.X) && !anySideEffects(n.Y) {
 		// Discard.
 		return true
 	}
 	lno := setlineno(n)
 	defer func() { base.Pos = lno }()
-	nam := n.Left().(*ir.Name)
-	return s.staticassign(nam, 0, n.Right(), nam.Type())
+	nam := n.X.(*ir.Name)
+	return s.staticassign(nam, 0, n.Y, nam.Type())
 }
 
 // like staticassign but we are copying an already
 // initialized value r.
 func (s *InitSchedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *types.Type) bool {
-	if rn.Class() == ir.PFUNC {
+	if rn.Class_ == ir.PFUNC {
 		// TODO if roff != 0 { panic }
 		pfuncsym(l, loff, rn)
 		return true
 	}
-	if rn.Class() != ir.PEXTERN || rn.Sym().Pkg != types.LocalPkg {
+	if rn.Class_ != ir.PEXTERN || rn.Sym().Pkg != types.LocalPkg {
 		return false
 	}
 	if rn.Defn == nil { // probably zeroed but perhaps supplied externally and of unknown value
@@ -92,10 +92,10 @@ func (s *InitSchedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *type
 		return false
 	}
 	orig := rn
-	r := rn.Defn.(*ir.AssignStmt).Right()
+	r := rn.Defn.(*ir.AssignStmt).Y
 
 	for r.Op() == ir.OCONVNOP && !types.Identical(r.Type(), typ) {
-		r = r.(*ir.ConvExpr).Left()
+		r = r.(*ir.ConvExpr).X
 	}
 
 	switch r.Op() {
@@ -128,7 +128,7 @@ func (s *InitSchedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *type
 
 	case ir.OADDR:
 		r := r.(*ir.AddrExpr)
-		if a := r.Left(); a.Op() == ir.ONAME {
+		if a := r.X; a.Op() == ir.ONAME {
 			a := a.(*ir.Name)
 			addrsym(l, loff, a, 0)
 			return true
@@ -136,7 +136,7 @@ func (s *InitSchedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *type
 
 	case ir.OPTRLIT:
 		r := r.(*ir.AddrExpr)
-		switch r.Left().Op() {
+		switch r.X.Op() {
 		case ir.OARRAYLIT, ir.OSLICELIT, ir.OSTRUCTLIT, ir.OMAPLIT:
 			// copy pointer
 			addrsym(l, loff, s.inittemps[r], 0)
@@ -182,7 +182,7 @@ func (s *InitSchedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *type
 
 func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *types.Type) bool {
 	for r.Op() == ir.OCONVNOP {
-		r = r.(*ir.ConvExpr).Left()
+		r = r.(*ir.ConvExpr).X
 	}
 
 	switch r.Op() {
@@ -206,7 +206,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 
 	case ir.OADDR:
 		r := r.(*ir.AddrExpr)
-		if name, offset, ok := stataddr(r.Left()); ok {
+		if name, offset, ok := stataddr(r.X); ok {
 			addrsym(l, loff, name, offset)
 			return true
 		}
@@ -214,17 +214,17 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 
 	case ir.OPTRLIT:
 		r := r.(*ir.AddrExpr)
-		switch r.Left().Op() {
+		switch r.X.Op() {
 		case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT, ir.OSTRUCTLIT:
 			// Init pointer.
-			a := staticname(r.Left().Type())
+			a := staticname(r.X.Type())
 
 			s.inittemps[r] = a
 			addrsym(l, loff, a, 0)
 
 			// Init underlying literal.
-			if !s.staticassign(a, 0, r.Left(), a.Type()) {
-				s.append(ir.NewAssignStmt(base.Pos, a, r.Left()))
+			if !s.staticassign(a, 0, r.X, a.Type()) {
+				s.append(ir.NewAssignStmt(base.Pos, a, r.X))
 			}
 			return true
 		}
@@ -232,8 +232,8 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 
 	case ir.OSTR2BYTES:
 		r := r.(*ir.ConvExpr)
-		if l.Class() == ir.PEXTERN && r.Left().Op() == ir.OLITERAL {
-			sval := ir.StringVal(r.Left())
+		if l.Class_ == ir.PEXTERN && r.X.Op() == ir.OLITERAL {
+			sval := ir.StringVal(r.X)
 			slicebytes(l, loff, sval)
 			return true
 		}
@@ -284,7 +284,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 			// Closures with no captured variables are globals,
 			// so the assignment can be done at link time.
 			// TODO if roff != 0 { panic }
-			pfuncsym(l, loff, r.Func().Nname)
+			pfuncsym(l, loff, r.Func.Nname)
 			return true
 		}
 		closuredebugruntimecheck(r)
@@ -297,7 +297,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 		r := r.(*ir.ConvExpr)
 		val := ir.Node(r)
 		for val.Op() == ir.OCONVIFACE {
-			val = val.(*ir.ConvExpr).Left()
+			val = val.(*ir.ConvExpr).X
 		}
 
 		if val.Type().IsInterface() {
@@ -321,7 +321,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 		// Create a copy of l to modify while we emit data.
 
 		// Emit itab, advance offset.
-		addrsym(l, loff, itab.Left().(*ir.Name), 0)
+		addrsym(l, loff, itab.X.(*ir.Name), 0)
 
 		// Emit data.
 		if isdirectiface(val.Type()) {
@@ -409,7 +409,7 @@ func isSimpleName(nn ir.Node) bool {
 		return false
 	}
 	n := nn.(*ir.Name)
-	return n.Class() != ir.PAUTOHEAP && n.Class() != ir.PEXTERN
+	return n.Class_ != ir.PAUTOHEAP && n.Class_ != ir.PEXTERN
 }
 
 func litas(l ir.Node, r ir.Node, init *ir.Nodes) {
@@ -439,7 +439,7 @@ func getdyn(n ir.Node, top bool) initGenType {
 		if !top {
 			return initDynamic
 		}
-		if n.Len/4 > int64(n.List().Len()) {
+		if n.Len/4 > int64(n.List.Len()) {
 			// <25% of entries have explicit values.
 			// Very rough estimation, it takes 4 bytes of instructions
 			// to initialize 1 byte of result. So don't use a static
@@ -454,12 +454,12 @@ func getdyn(n ir.Node, top bool) initGenType {
 	lit := n.(*ir.CompLitExpr)
 
 	var mode initGenType
-	for _, n1 := range lit.List().Slice() {
+	for _, n1 := range lit.List.Slice() {
 		switch n1.Op() {
 		case ir.OKEY:
-			n1 = n1.(*ir.KeyExpr).Right()
+			n1 = n1.(*ir.KeyExpr).Value
 		case ir.OSTRUCTKEY:
-			n1 = n1.(*ir.StructKeyExpr).Left()
+			n1 = n1.(*ir.StructKeyExpr).Value
 		}
 		mode |= getdyn(n1, false)
 		if mode == initDynamic|initConst {
@@ -476,9 +476,9 @@ func isStaticCompositeLiteral(n ir.Node) bool {
 		return false
 	case ir.OARRAYLIT:
 		n := n.(*ir.CompLitExpr)
-		for _, r := range n.List().Slice() {
+		for _, r := range n.List.Slice() {
 			if r.Op() == ir.OKEY {
-				r = r.(*ir.KeyExpr).Right()
+				r = r.(*ir.KeyExpr).Value
 			}
 			if !isStaticCompositeLiteral(r) {
 				return false
@@ -487,9 +487,9 @@ func isStaticCompositeLiteral(n ir.Node) bool {
 		return true
 	case ir.OSTRUCTLIT:
 		n := n.(*ir.CompLitExpr)
-		for _, r := range n.List().Slice() {
+		for _, r := range n.List.Slice() {
 			r := r.(*ir.StructKeyExpr)
-			if !isStaticCompositeLiteral(r.Left()) {
+			if !isStaticCompositeLiteral(r.Value) {
 				return false
 			}
 		}
@@ -501,7 +501,7 @@ func isStaticCompositeLiteral(n ir.Node) bool {
 		n := n.(*ir.ConvExpr)
 		val := ir.Node(n)
 		for val.Op() == ir.OCONVIFACE {
-			val = val.(*ir.ConvExpr).Left()
+			val = val.(*ir.ConvExpr).X
 		}
 		if val.Type().IsInterface() {
 			return val.Op() == ir.ONIL
@@ -542,11 +542,11 @@ func fixedlit(ctxt initContext, kind initKind, n *ir.CompLitExpr, var_ ir.Node,
 		splitnode = func(r ir.Node) (ir.Node, ir.Node) {
 			if r.Op() == ir.OKEY {
 				kv := r.(*ir.KeyExpr)
-				k = indexconst(kv.Left())
+				k = indexconst(kv.Key)
 				if k < 0 {
-					base.Fatalf("fixedlit: invalid index %v", kv.Left())
+					base.Fatalf("fixedlit: invalid index %v", kv.Key)
 				}
-				r = kv.Right()
+				r = kv.Value
 			}
 			a := ir.NewIndexExpr(base.Pos, var_, nodintconst(k))
 			k++
@@ -558,17 +558,17 @@ func fixedlit(ctxt initContext, kind initKind, n *ir.CompLitExpr, var_ ir.Node,
 	case ir.OSTRUCTLIT:
 		splitnode = func(rn ir.Node) (ir.Node, ir.Node) {
 			r := rn.(*ir.StructKeyExpr)
-			if r.Sym().IsBlank() || isBlank {
-				return ir.BlankNode, r.Left()
+			if r.Field.IsBlank() || isBlank {
+				return ir.BlankNode, r.Value
 			}
 			setlineno(r)
-			return ir.NewSelectorExpr(base.Pos, ir.ODOT, var_, r.Sym()), r.Left()
+			return ir.NewSelectorExpr(base.Pos, ir.ODOT, var_, r.Field), r.Value
 		}
 	default:
 		base.Fatalf("fixedlit bad op: %v", n.Op())
 	}
 
-	for _, r := range n.List().Slice() {
+	for _, r := range n.List.Slice() {
 		a, value := splitnode(r)
 		if a == ir.BlankNode && !anySideEffects(value) {
 			// Discard.
@@ -635,7 +635,7 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 		// copy static to slice
 		var_ = typecheck(var_, ctxExpr|ctxAssign)
 		name, offset, ok := stataddr(var_)
-		if !ok || name.Class() != ir.PEXTERN {
+		if !ok || name.Class_ != ir.PEXTERN {
 			base.Fatalf("slicelit: %v", var_)
 		}
 		slicesym(name, offset, vstat, t.NumElem())
@@ -703,7 +703,7 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 			a = ir.NewAssignStmt(base.Pos, temp(t), nil)
 			a = typecheck(a, ctxStmt)
 			init.Append(a) // zero new temp
-			a = a.(*ir.AssignStmt).Left()
+			a = a.(*ir.AssignStmt).X
 		} else {
 			init.Append(ir.NewUnaryExpr(base.Pos, ir.OVARDEF, a))
 		}
@@ -722,14 +722,14 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 
 	// put dynamics into array (5)
 	var index int64
-	for _, value := range n.List().Slice() {
+	for _, value := range n.List.Slice() {
 		if value.Op() == ir.OKEY {
 			kv := value.(*ir.KeyExpr)
-			index = indexconst(kv.Left())
+			index = indexconst(kv.Key)
 			if index < 0 {
-				base.Fatalf("slicelit: invalid index %v", kv.Left())
+				base.Fatalf("slicelit: invalid index %v", kv.Key)
 			}
-			value = kv.Right()
+			value = kv.Value
 		}
 		a := ir.NewIndexExpr(base.Pos, vauto, nodintconst(index))
 		a.SetBounded(true)
@@ -778,16 +778,16 @@ func maplit(n *ir.CompLitExpr, m ir.Node, init *ir.Nodes) {
 	// make the map var
 	a := ir.NewCallExpr(base.Pos, ir.OMAKE, nil, nil)
 	a.SetEsc(n.Esc())
-	a.PtrList().Set2(ir.TypeNode(n.Type()), nodintconst(int64(n.List().Len())))
+	a.Args.Set2(ir.TypeNode(n.Type()), nodintconst(int64(n.List.Len())))
 	litas(m, a, init)
 
-	entries := n.List().Slice()
+	entries := n.List.Slice()
 
 	// The order pass already removed any dynamic (runtime-computed) entries.
 	// All remaining entries are static. Double-check that.
 	for _, r := range entries {
 		r := r.(*ir.KeyExpr)
-		if !isStaticCompositeLiteral(r.Left()) || !isStaticCompositeLiteral(r.Right()) {
+		if !isStaticCompositeLiteral(r.Key) || !isStaticCompositeLiteral(r.Value) {
 			base.Fatalf("maplit: entry is not a literal: %v", r)
 		}
 	}
@@ -813,8 +813,8 @@ func maplit(n *ir.CompLitExpr, m ir.Node, init *ir.Nodes) {
 		datae := ir.NewCompLitExpr(base.Pos, ir.OARRAYLIT, nil, nil)
 		for _, r := range entries {
 			r := r.(*ir.KeyExpr)
-			datak.PtrList().Append(r.Left())
-			datae.PtrList().Append(r.Right())
+			datak.List.Append(r.Key)
+			datae.List.Append(r.Value)
 		}
 		fixedlit(inInitFunction, initKindStatic, datak, vstatk, init)
 		fixedlit(inInitFunction, initKindStatic, datae, vstate, init)
@@ -837,7 +837,7 @@ func maplit(n *ir.CompLitExpr, m ir.Node, init *ir.Nodes) {
 		body := ir.NewAssignStmt(base.Pos, lhs, rhs)
 
 		loop := ir.NewForStmt(base.Pos, nil, cond, incr, nil)
-		loop.PtrBody().Set1(body)
+		loop.Body.Set1(body)
 		loop.PtrInit().Set1(zero)
 
 		appendWalkStmt(init, loop)
@@ -853,7 +853,7 @@ func maplit(n *ir.CompLitExpr, m ir.Node, init *ir.Nodes) {
 
 	for _, r := range entries {
 		r := r.(*ir.KeyExpr)
-		index, elem := r.Left(), r.Right()
+		index, elem := r.Key, r.Value
 
 		setlineno(index)
 		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, tmpkey, index))
@@ -890,19 +890,19 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 		}
 
 		var r ir.Node
-		if n.Right() != nil {
+		if n.Alloc != nil {
 			// n.Right is stack temporary used as backing store.
-			appendWalkStmt(init, ir.NewAssignStmt(base.Pos, n.Right(), nil)) // zero backing store, just in case (#18410)
-			r = nodAddr(n.Right())
+			appendWalkStmt(init, ir.NewAssignStmt(base.Pos, n.Alloc, nil)) // zero backing store, just in case (#18410)
+			r = nodAddr(n.Alloc)
 		} else {
-			r = ir.NewUnaryExpr(base.Pos, ir.ONEW, ir.TypeNode(n.Left().Type()))
+			r = ir.NewUnaryExpr(base.Pos, ir.ONEW, ir.TypeNode(n.X.Type()))
 			r.SetEsc(n.Esc())
 		}
 		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, r))
 
 		var_ = ir.NewStarExpr(base.Pos, var_)
 		var_ = typecheck(var_, ctxExpr|ctxAssign)
-		anylit(n.Left(), var_, init)
+		anylit(n.X, var_, init)
 
 	case ir.OSTRUCTLIT, ir.OARRAYLIT:
 		n := n.(*ir.CompLitExpr)
@@ -910,7 +910,7 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 			base.Fatalf("anylit: not struct/array")
 		}
 
-		if isSimpleName(var_) && n.List().Len() > 4 {
+		if isSimpleName(var_) && n.List.Len() > 4 {
 			// lay out static data
 			vstat := readonlystaticname(t)
 
@@ -935,7 +935,7 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 			components = int64(t.NumFields())
 		}
 		// initialization of an array or struct with unspecified components (missing fields or arrays)
-		if isSimpleName(var_) || int64(n.List().Len()) < components {
+		if isSimpleName(var_) || int64(n.List.Len()) < components {
 			appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, nil))
 		}
 
@@ -958,34 +958,34 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 // It returns true if n's effects have been added to init,
 // in which case n should be dropped from the program by the caller.
 func oaslit(n *ir.AssignStmt, init *ir.Nodes) bool {
-	if n.Left() == nil || n.Right() == nil {
+	if n.X == nil || n.Y == nil {
 		// not a special composite literal assignment
 		return false
 	}
-	if n.Left().Type() == nil || n.Right().Type() == nil {
+	if n.X.Type() == nil || n.Y.Type() == nil {
 		// not a special composite literal assignment
 		return false
 	}
-	if !isSimpleName(n.Left()) {
+	if !isSimpleName(n.X) {
 		// not a special composite literal assignment
 		return false
 	}
-	if !types.Identical(n.Left().Type(), n.Right().Type()) {
+	if !types.Identical(n.X.Type(), n.Y.Type()) {
 		// not a special composite literal assignment
 		return false
 	}
 
-	switch n.Right().Op() {
+	switch n.Y.Op() {
 	default:
 		// not a special composite literal assignment
 		return false
 
 	case ir.OSTRUCTLIT, ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT:
-		if refersToCommonName(n.Left(), n.Right()) {
+		if refersToCommonName(n.X, n.Y) {
 			// not a special composite literal assignment
 			return false
 		}
-		anylit(n.Right(), n.Left(), init)
+		anylit(n.Y, n.X, init)
 	}
 
 	return true
@@ -1015,21 +1015,21 @@ func stataddr(n ir.Node) (name *ir.Name, offset int64, ok bool) {
 
 	case ir.ODOT:
 		n := n.(*ir.SelectorExpr)
-		if name, offset, ok = stataddr(n.Left()); !ok {
+		if name, offset, ok = stataddr(n.X); !ok {
 			break
 		}
-		offset += n.Offset()
+		offset += n.Offset
 		return name, offset, true
 
 	case ir.OINDEX:
 		n := n.(*ir.IndexExpr)
-		if n.Left().Type().IsSlice() {
+		if n.X.Type().IsSlice() {
 			break
 		}
-		if name, offset, ok = stataddr(n.Left()); !ok {
+		if name, offset, ok = stataddr(n.X); !ok {
 			break
 		}
-		l := getlit(n.Right())
+		l := getlit(n.Index)
 		if l < 0 {
 			break
 		}
@@ -1058,14 +1058,14 @@ func (s *InitSchedule) initplan(n ir.Node) {
 	case ir.OARRAYLIT, ir.OSLICELIT:
 		n := n.(*ir.CompLitExpr)
 		var k int64
-		for _, a := range n.List().Slice() {
+		for _, a := range n.List.Slice() {
 			if a.Op() == ir.OKEY {
 				kv := a.(*ir.KeyExpr)
-				k = indexconst(kv.Left())
+				k = indexconst(kv.Key)
 				if k < 0 {
-					base.Fatalf("initplan arraylit: invalid index %v", kv.Left())
+					base.Fatalf("initplan arraylit: invalid index %v", kv.Key)
 				}
-				a = kv.Right()
+				a = kv.Value
 			}
 			s.addvalue(p, k*n.Type().Elem().Width, a)
 			k++
@@ -1073,25 +1073,25 @@ func (s *InitSchedule) initplan(n ir.Node) {
 
 	case ir.OSTRUCTLIT:
 		n := n.(*ir.CompLitExpr)
-		for _, a := range n.List().Slice() {
+		for _, a := range n.List.Slice() {
 			if a.Op() != ir.OSTRUCTKEY {
 				base.Fatalf("initplan structlit")
 			}
 			a := a.(*ir.StructKeyExpr)
-			if a.Sym().IsBlank() {
+			if a.Field.IsBlank() {
 				continue
 			}
-			s.addvalue(p, a.Offset(), a.Left())
+			s.addvalue(p, a.Offset, a.Value)
 		}
 
 	case ir.OMAPLIT:
 		n := n.(*ir.CompLitExpr)
-		for _, a := range n.List().Slice() {
+		for _, a := range n.List.Slice() {
 			if a.Op() != ir.OKEY {
 				base.Fatalf("initplan maplit")
 			}
 			a := a.(*ir.KeyExpr)
-			s.addvalue(p, -1, a.Right())
+			s.addvalue(p, -1, a.Value)
 		}
 	}
 }
@@ -1135,9 +1135,9 @@ func isZero(n ir.Node) bool {
 
 	case ir.OARRAYLIT:
 		n := n.(*ir.CompLitExpr)
-		for _, n1 := range n.List().Slice() {
+		for _, n1 := range n.List.Slice() {
 			if n1.Op() == ir.OKEY {
-				n1 = n1.(*ir.KeyExpr).Right()
+				n1 = n1.(*ir.KeyExpr).Value
 			}
 			if !isZero(n1) {
 				return false
@@ -1147,9 +1147,9 @@ func isZero(n ir.Node) bool {
 
 	case ir.OSTRUCTLIT:
 		n := n.(*ir.CompLitExpr)
-		for _, n1 := range n.List().Slice() {
+		for _, n1 := range n.List.Slice() {
 			n1 := n1.(*ir.StructKeyExpr)
-			if !isZero(n1.Left()) {
+			if !isZero(n1.Value) {
 				return false
 			}
 		}
@@ -1164,16 +1164,16 @@ func isvaluelit(n ir.Node) bool {
 }
 
 func genAsStatic(as *ir.AssignStmt) {
-	if as.Left().Type() == nil {
+	if as.X.Type() == nil {
 		base.Fatalf("genAsStatic as.Left not typechecked")
 	}
 
-	name, offset, ok := stataddr(as.Left())
-	if !ok || (name.Class() != ir.PEXTERN && as.Left() != ir.BlankNode) {
-		base.Fatalf("genAsStatic: lhs %v", as.Left())
+	name, offset, ok := stataddr(as.X)
+	if !ok || (name.Class_ != ir.PEXTERN && as.X != ir.BlankNode) {
+		base.Fatalf("genAsStatic: lhs %v", as.X)
 	}
 
-	switch r := as.Right(); r.Op() {
+	switch r := as.Y; r.Op() {
 	case ir.OLITERAL:
 		litsym(name, offset, r, int(r.Type().Width))
 		return
@@ -1183,13 +1183,13 @@ func genAsStatic(as *ir.AssignStmt) {
 		return
 	case ir.ONAME:
 		r := r.(*ir.Name)
-		if r.Offset() != 0 {
+		if r.Offset_ != 0 {
 			base.Fatalf("genAsStatic %+v", as)
 		}
-		if r.Class() == ir.PFUNC {
+		if r.Class_ == ir.PFUNC {
 			pfuncsym(name, offset, r)
 			return
 		}
 	}
-	base.Fatalf("genAsStatic: rhs %v", as.Right())
+	base.Fatalf("genAsStatic: rhs %v", as.Y)
 }
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index dc3ea4be9e..4660da0456 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -211,7 +211,7 @@ func initssaconfig() {
 // considered as the 0th parameter. This does not include the receiver of an
 // interface call.
 func getParam(n *ir.CallExpr, i int) *types.Field {
-	t := n.Left().Type()
+	t := n.X.Type()
 	if n.Op() == ir.OCALLMETH {
 		if i == 0 {
 			return t.Recv()
@@ -275,7 +275,7 @@ func (s *state) emitOpenDeferInfo() {
 	var maxargsize int64
 	for i := len(s.openDefers) - 1; i >= 0; i-- {
 		r := s.openDefers[i]
-		argsize := r.n.Left().Type().ArgWidth()
+		argsize := r.n.X.Type().ArgWidth()
 		if argsize > maxargsize {
 			maxargsize = argsize
 		}
@@ -287,7 +287,7 @@ func (s *state) emitOpenDeferInfo() {
 	// Write in reverse-order, for ease of running in that order at runtime
 	for i := len(s.openDefers) - 1; i >= 0; i-- {
 		r := s.openDefers[i]
-		off = dvarint(x, off, r.n.Left().Type().ArgWidth())
+		off = dvarint(x, off, r.n.X.Type().ArgWidth())
 		off = dvarint(x, off, -r.closureNode.FrameOffset())
 		numArgs := len(r.argNodes)
 		if r.rcvrNode != nil {
@@ -323,7 +323,7 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 	if printssa {
 		astBuf = &bytes.Buffer{}
 		ir.FDumpList(astBuf, "buildssa-enter", fn.Enter)
-		ir.FDumpList(astBuf, "buildssa-body", fn.Body())
+		ir.FDumpList(astBuf, "buildssa-body", fn.Body)
 		ir.FDumpList(astBuf, "buildssa-exit", fn.Exit)
 		if ssaDumpStdout {
 			fmt.Println("generating SSA for", name)
@@ -438,7 +438,7 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 	var args []ssa.Param
 	var results []ssa.Param
 	for _, n := range fn.Dcl {
-		switch n.Class() {
+		switch n.Class_ {
 		case ir.PPARAM:
 			s.decladdrs[n] = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(n.Type()), n, s.sp, s.startmem)
 			args = append(args, ssa.Param{Type: n.Type(), Offset: int32(n.FrameOffset())})
@@ -459,13 +459,13 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 		case ir.PFUNC:
 			// local function - already handled by frontend
 		default:
-			s.Fatalf("local variable with class %v unimplemented", n.Class())
+			s.Fatalf("local variable with class %v unimplemented", n.Class_)
 		}
 	}
 
 	// Populate SSAable arguments.
 	for _, n := range fn.Dcl {
-		if n.Class() == ir.PPARAM && s.canSSA(n) {
+		if n.Class_ == ir.PPARAM && s.canSSA(n) {
 			v := s.newValue0A(ssa.OpArg, n.Type(), n)
 			s.vars[n] = v
 			s.addNamedValue(n, v) // This helps with debugging information, not needed for compilation itself.
@@ -474,7 +474,7 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 
 	// Convert the AST-based IR to the SSA-based IR
 	s.stmtList(fn.Enter)
-	s.stmtList(fn.Body())
+	s.stmtList(fn.Body)
 
 	// fallthrough to exit
 	if s.curBlock != nil {
@@ -1028,7 +1028,7 @@ func (s *state) instrumentMove(t *types.Type, dst, src *ssa.Value) {
 }
 
 func (s *state) instrument2(t *types.Type, addr, addr2 *ssa.Value, kind instrumentKind) {
-	if !s.curfn.Func().InstrumentBody() {
+	if !s.curfn.InstrumentBody() {
 		return
 	}
 
@@ -1151,7 +1151,7 @@ func (s *state) stmt(n ir.Node) {
 
 	case ir.OBLOCK:
 		n := n.(*ir.BlockStmt)
-		s.stmtList(n.List())
+		s.stmtList(n.List)
 
 	// No-ops
 	case ir.ODCLCONST, ir.ODCLTYPE, ir.OFALL:
@@ -1168,9 +1168,9 @@ func (s *state) stmt(n ir.Node) {
 	case ir.OCALLMETH, ir.OCALLINTER:
 		n := n.(*ir.CallExpr)
 		s.callResult(n, callNormal)
-		if n.Op() == ir.OCALLFUNC && n.Left().Op() == ir.ONAME && n.Left().(*ir.Name).Class() == ir.PFUNC {
-			if fn := n.Left().Sym().Name; base.Flag.CompilingRuntime && fn == "throw" ||
-				n.Left().Sym().Pkg == Runtimepkg && (fn == "throwinit" || fn == "gopanic" || fn == "panicwrap" || fn == "block" || fn == "panicmakeslicelen" || fn == "panicmakeslicecap") {
+		if n.Op() == ir.OCALLFUNC && n.X.Op() == ir.ONAME && n.X.(*ir.Name).Class_ == ir.PFUNC {
+			if fn := n.X.Sym().Name; base.Flag.CompilingRuntime && fn == "throw" ||
+				n.X.Sym().Pkg == Runtimepkg && (fn == "throwinit" || fn == "gopanic" || fn == "panicwrap" || fn == "block" || fn == "panicmakeslicelen" || fn == "panicmakeslicecap") {
 				m := s.mem()
 				b := s.endBlock()
 				b.Kind = ssa.BlockExit
@@ -1194,23 +1194,23 @@ func (s *state) stmt(n ir.Node) {
 			base.WarnfAt(n.Pos(), "%s defer", defertype)
 		}
 		if s.hasOpenDefers {
-			s.openDeferRecord(n.Left().(*ir.CallExpr))
+			s.openDeferRecord(n.Call.(*ir.CallExpr))
 		} else {
 			d := callDefer
 			if n.Esc() == EscNever {
 				d = callDeferStack
 			}
-			s.callResult(n.Left().(*ir.CallExpr), d)
+			s.callResult(n.Call.(*ir.CallExpr), d)
 		}
 	case ir.OGO:
 		n := n.(*ir.GoDeferStmt)
-		s.callResult(n.Left().(*ir.CallExpr), callGo)
+		s.callResult(n.Call.(*ir.CallExpr), callGo)
 
 	case ir.OAS2DOTTYPE:
 		n := n.(*ir.AssignListStmt)
-		res, resok := s.dottype(n.Rlist().First().(*ir.TypeAssertExpr), true)
+		res, resok := s.dottype(n.Rhs.First().(*ir.TypeAssertExpr), true)
 		deref := false
-		if !canSSAType(n.Rlist().First().Type()) {
+		if !canSSAType(n.Rhs.First().Type()) {
 			if res.Op != ssa.OpLoad {
 				s.Fatalf("dottype of non-load")
 			}
@@ -1224,33 +1224,33 @@ func (s *state) stmt(n ir.Node) {
 			deref = true
 			res = res.Args[0]
 		}
-		s.assign(n.List().First(), res, deref, 0)
-		s.assign(n.List().Second(), resok, false, 0)
+		s.assign(n.Lhs.First(), res, deref, 0)
+		s.assign(n.Lhs.Second(), resok, false, 0)
 		return
 
 	case ir.OAS2FUNC:
 		// We come here only when it is an intrinsic call returning two values.
 		n := n.(*ir.AssignListStmt)
-		call := n.Rlist().First().(*ir.CallExpr)
+		call := n.Rhs.First().(*ir.CallExpr)
 		if !IsIntrinsicCall(call) {
 			s.Fatalf("non-intrinsic AS2FUNC not expanded %v", call)
 		}
 		v := s.intrinsicCall(call)
-		v1 := s.newValue1(ssa.OpSelect0, n.List().First().Type(), v)
-		v2 := s.newValue1(ssa.OpSelect1, n.List().Second().Type(), v)
-		s.assign(n.List().First(), v1, false, 0)
-		s.assign(n.List().Second(), v2, false, 0)
+		v1 := s.newValue1(ssa.OpSelect0, n.Lhs.First().Type(), v)
+		v2 := s.newValue1(ssa.OpSelect1, n.Lhs.Second().Type(), v)
+		s.assign(n.Lhs.First(), v1, false, 0)
+		s.assign(n.Lhs.Second(), v2, false, 0)
 		return
 
 	case ir.ODCL:
 		n := n.(*ir.Decl)
-		if n.Left().(*ir.Name).Class() == ir.PAUTOHEAP {
+		if n.X.(*ir.Name).Class_ == ir.PAUTOHEAP {
 			s.Fatalf("DCL %v", n)
 		}
 
 	case ir.OLABEL:
 		n := n.(*ir.LabelStmt)
-		sym := n.Sym()
+		sym := n.Label
 		lab := s.label(sym)
 
 		// The label might already have a target block via a goto.
@@ -1268,7 +1268,7 @@ func (s *state) stmt(n ir.Node) {
 
 	case ir.OGOTO:
 		n := n.(*ir.BranchStmt)
-		sym := n.Sym()
+		sym := n.Label
 
 		lab := s.label(sym)
 		if lab.target == nil {
@@ -1281,7 +1281,7 @@ func (s *state) stmt(n ir.Node) {
 
 	case ir.OAS:
 		n := n.(*ir.AssignStmt)
-		if n.Left() == n.Right() && n.Left().Op() == ir.ONAME {
+		if n.X == n.Y && n.X.Op() == ir.ONAME {
 			// An x=x assignment. No point in doing anything
 			// here. In addition, skipping this assignment
 			// prevents generating:
@@ -1293,7 +1293,7 @@ func (s *state) stmt(n ir.Node) {
 		}
 
 		// Evaluate RHS.
-		rhs := n.Right()
+		rhs := n.Y
 		if rhs != nil {
 			switch rhs.Op() {
 			case ir.OSTRUCTLIT, ir.OARRAYLIT, ir.OSLICELIT:
@@ -1309,13 +1309,13 @@ func (s *state) stmt(n ir.Node) {
 				// Check whether we're writing the result of an append back to the same slice.
 				// If so, we handle it specially to avoid write barriers on the fast
 				// (non-growth) path.
-				if !samesafeexpr(n.Left(), rhs.List().First()) || base.Flag.N != 0 {
+				if !samesafeexpr(n.X, rhs.Args.First()) || base.Flag.N != 0 {
 					break
 				}
 				// If the slice can be SSA'd, it'll be on the stack,
 				// so there will be no write barriers,
 				// so there's no need to attempt to prevent them.
-				if s.canSSA(n.Left()) {
+				if s.canSSA(n.X) {
 					if base.Debug.Append > 0 { // replicating old diagnostic message
 						base.WarnfAt(n.Pos(), "append: len-only update (in local slice)")
 					}
@@ -1329,7 +1329,7 @@ func (s *state) stmt(n ir.Node) {
 			}
 		}
 
-		if ir.IsBlank(n.Left()) {
+		if ir.IsBlank(n.X) {
 			// _ = rhs
 			// Just evaluate rhs for side-effects.
 			if rhs != nil {
@@ -1339,10 +1339,10 @@ func (s *state) stmt(n ir.Node) {
 		}
 
 		var t *types.Type
-		if n.Right() != nil {
-			t = n.Right().Type()
+		if n.Y != nil {
+			t = n.Y.Type()
 		} else {
-			t = n.Left().Type()
+			t = n.X.Type()
 		}
 
 		var r *ssa.Value
@@ -1362,7 +1362,7 @@ func (s *state) stmt(n ir.Node) {
 		}
 
 		var skip skipMask
-		if rhs != nil && (rhs.Op() == ir.OSLICE || rhs.Op() == ir.OSLICE3 || rhs.Op() == ir.OSLICESTR) && samesafeexpr(rhs.(*ir.SliceExpr).Left(), n.Left()) {
+		if rhs != nil && (rhs.Op() == ir.OSLICE || rhs.Op() == ir.OSLICE3 || rhs.Op() == ir.OSLICESTR) && samesafeexpr(rhs.(*ir.SliceExpr).X, n.X) {
 			// We're assigning a slicing operation back to its source.
 			// Don't write back fields we aren't changing. See issue #14855.
 			rhs := rhs.(*ir.SliceExpr)
@@ -1392,49 +1392,49 @@ func (s *state) stmt(n ir.Node) {
 			}
 		}
 
-		s.assign(n.Left(), r, deref, skip)
+		s.assign(n.X, r, deref, skip)
 
 	case ir.OIF:
 		n := n.(*ir.IfStmt)
-		if ir.IsConst(n.Left(), constant.Bool) {
-			s.stmtList(n.Left().Init())
-			if ir.BoolVal(n.Left()) {
-				s.stmtList(n.Body())
+		if ir.IsConst(n.Cond, constant.Bool) {
+			s.stmtList(n.Cond.Init())
+			if ir.BoolVal(n.Cond) {
+				s.stmtList(n.Body)
 			} else {
-				s.stmtList(n.Rlist())
+				s.stmtList(n.Else)
 			}
 			break
 		}
 
 		bEnd := s.f.NewBlock(ssa.BlockPlain)
 		var likely int8
-		if n.Likely() {
+		if n.Likely {
 			likely = 1
 		}
 		var bThen *ssa.Block
-		if n.Body().Len() != 0 {
+		if n.Body.Len() != 0 {
 			bThen = s.f.NewBlock(ssa.BlockPlain)
 		} else {
 			bThen = bEnd
 		}
 		var bElse *ssa.Block
-		if n.Rlist().Len() != 0 {
+		if n.Else.Len() != 0 {
 			bElse = s.f.NewBlock(ssa.BlockPlain)
 		} else {
 			bElse = bEnd
 		}
-		s.condBranch(n.Left(), bThen, bElse, likely)
+		s.condBranch(n.Cond, bThen, bElse, likely)
 
-		if n.Body().Len() != 0 {
+		if n.Body.Len() != 0 {
 			s.startBlock(bThen)
-			s.stmtList(n.Body())
+			s.stmtList(n.Body)
 			if b := s.endBlock(); b != nil {
 				b.AddEdgeTo(bEnd)
 			}
 		}
-		if n.Rlist().Len() != 0 {
+		if n.Else.Len() != 0 {
 			s.startBlock(bElse)
-			s.stmtList(n.Rlist())
+			s.stmtList(n.Else)
 			if b := s.endBlock(); b != nil {
 				b.AddEdgeTo(bEnd)
 			}
@@ -1443,7 +1443,7 @@ func (s *state) stmt(n ir.Node) {
 
 	case ir.ORETURN:
 		n := n.(*ir.ReturnStmt)
-		s.stmtList(n.List())
+		s.stmtList(n.Results)
 		b := s.exit()
 		b.Pos = s.lastPos.WithIsStmt()
 
@@ -1451,12 +1451,12 @@ func (s *state) stmt(n ir.Node) {
 		n := n.(*ir.BranchStmt)
 		b := s.exit()
 		b.Kind = ssa.BlockRetJmp // override BlockRet
-		b.Aux = callTargetLSym(n.Sym(), s.curfn.LSym)
+		b.Aux = callTargetLSym(n.Label, s.curfn.LSym)
 
 	case ir.OCONTINUE, ir.OBREAK:
 		n := n.(*ir.BranchStmt)
 		var to *ssa.Block
-		if n.Sym() == nil {
+		if n.Label == nil {
 			// plain break/continue
 			switch n.Op() {
 			case ir.OCONTINUE:
@@ -1466,7 +1466,7 @@ func (s *state) stmt(n ir.Node) {
 			}
 		} else {
 			// labeled break/continue; look up the target
-			sym := n.Sym()
+			sym := n.Label
 			lab := s.label(sym)
 			switch n.Op() {
 			case ir.OCONTINUE:
@@ -1501,8 +1501,8 @@ func (s *state) stmt(n ir.Node) {
 			b.AddEdgeTo(bCond)
 			// generate code to test condition
 			s.startBlock(bCond)
-			if n.Left() != nil {
-				s.condBranch(n.Left(), bBody, bEnd, 1)
+			if n.Cond != nil {
+				s.condBranch(n.Cond, bBody, bEnd, 1)
 			} else {
 				b := s.endBlock()
 				b.Kind = ssa.BlockPlain
@@ -1519,7 +1519,7 @@ func (s *state) stmt(n ir.Node) {
 		s.continueTo = bIncr
 		s.breakTo = bEnd
 		var lab *ssaLabel
-		if sym := n.Sym(); sym != nil {
+		if sym := n.Label; sym != nil {
 			// labeled for loop
 			lab = s.label(sym)
 			lab.continueTarget = bIncr
@@ -1528,7 +1528,7 @@ func (s *state) stmt(n ir.Node) {
 
 		// generate body
 		s.startBlock(bBody)
-		s.stmtList(n.Body())
+		s.stmtList(n.Body)
 
 		// tear down continue/break
 		s.continueTo = prevContinue
@@ -1545,8 +1545,8 @@ func (s *state) stmt(n ir.Node) {
 
 		// generate incr (and, for OFORUNTIL, condition)
 		s.startBlock(bIncr)
-		if n.Right() != nil {
-			s.stmt(n.Right())
+		if n.Post != nil {
+			s.stmt(n.Post)
 		}
 		if n.Op() == ir.OFOR {
 			if b := s.endBlock(); b != nil {
@@ -1561,10 +1561,10 @@ func (s *state) stmt(n ir.Node) {
 			// bCond is unused in OFORUNTIL, so repurpose it.
 			bLateIncr := bCond
 			// test condition
-			s.condBranch(n.Left(), bLateIncr, bEnd, 1)
+			s.condBranch(n.Cond, bLateIncr, bEnd, 1)
 			// generate late increment
 			s.startBlock(bLateIncr)
-			s.stmtList(n.List())
+			s.stmtList(n.Late)
 			s.endBlock().AddEdgeTo(bBody)
 		}
 
@@ -1581,12 +1581,12 @@ func (s *state) stmt(n ir.Node) {
 		var body ir.Nodes
 		if n.Op() == ir.OSWITCH {
 			n := n.(*ir.SwitchStmt)
-			sym = n.Sym()
-			body = n.Body()
+			sym = n.Label
+			body = n.Compiled
 		} else {
 			n := n.(*ir.SelectStmt)
-			sym = n.Sym()
-			body = n.Body()
+			sym = n.Label
+			body = n.Compiled
 		}
 
 		var lab *ssaLabel
@@ -1616,8 +1616,8 @@ func (s *state) stmt(n ir.Node) {
 
 	case ir.OVARDEF:
 		n := n.(*ir.UnaryExpr)
-		if !s.canSSA(n.Left()) {
-			s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, n.Left().(*ir.Name), s.mem(), false)
+		if !s.canSSA(n.X) {
+			s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, n.X.(*ir.Name), s.mem(), false)
 		}
 	case ir.OVARKILL:
 		// Insert a varkill op to record that a variable is no longer live.
@@ -1625,18 +1625,18 @@ func (s *state) stmt(n ir.Node) {
 		// varkill in the store chain is enough to keep it correctly ordered
 		// with respect to call ops.
 		n := n.(*ir.UnaryExpr)
-		if !s.canSSA(n.Left()) {
-			s.vars[memVar] = s.newValue1Apos(ssa.OpVarKill, types.TypeMem, n.Left().(*ir.Name), s.mem(), false)
+		if !s.canSSA(n.X) {
+			s.vars[memVar] = s.newValue1Apos(ssa.OpVarKill, types.TypeMem, n.X.(*ir.Name), s.mem(), false)
 		}
 
 	case ir.OVARLIVE:
 		// Insert a varlive op to record that a variable is still live.
 		n := n.(*ir.UnaryExpr)
-		v := n.Left().(*ir.Name)
+		v := n.X.(*ir.Name)
 		if !v.Addrtaken() {
 			s.Fatalf("VARLIVE variable %v must have Addrtaken set", v)
 		}
-		switch v.Class() {
+		switch v.Class_ {
 		case ir.PAUTO, ir.PPARAM, ir.PPARAMOUT:
 		default:
 			s.Fatalf("VARLIVE variable %v must be Auto or Arg", v)
@@ -1645,12 +1645,12 @@ func (s *state) stmt(n ir.Node) {
 
 	case ir.OCHECKNIL:
 		n := n.(*ir.UnaryExpr)
-		p := s.expr(n.Left())
+		p := s.expr(n.X)
 		s.nilCheck(p)
 
 	case ir.OINLMARK:
 		n := n.(*ir.InlineMarkStmt)
-		s.newValue1I(ssa.OpInlMark, types.TypeVoid, n.Offset(), s.mem())
+		s.newValue1I(ssa.OpInlMark, types.TypeVoid, n.Index, s.mem())
 
 	default:
 		s.Fatalf("unhandled stmt %v", n.Op())
@@ -2118,19 +2118,19 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 	switch n.Op() {
 	case ir.OBYTES2STRTMP:
 		n := n.(*ir.ConvExpr)
-		slice := s.expr(n.Left())
+		slice := s.expr(n.X)
 		ptr := s.newValue1(ssa.OpSlicePtr, s.f.Config.Types.BytePtr, slice)
 		len := s.newValue1(ssa.OpSliceLen, types.Types[types.TINT], slice)
 		return s.newValue2(ssa.OpStringMake, n.Type(), ptr, len)
 	case ir.OSTR2BYTESTMP:
 		n := n.(*ir.ConvExpr)
-		str := s.expr(n.Left())
+		str := s.expr(n.X)
 		ptr := s.newValue1(ssa.OpStringPtr, s.f.Config.Types.BytePtr, str)
 		len := s.newValue1(ssa.OpStringLen, types.Types[types.TINT], str)
 		return s.newValue3(ssa.OpSliceMake, n.Type(), ptr, len, len)
 	case ir.OCFUNC:
 		n := n.(*ir.UnaryExpr)
-		aux := n.Left().Sym().Linksym()
+		aux := n.X.Sym().Linksym()
 		return s.entryNewValue1A(ssa.OpAddr, n.Type(), aux, s.sb)
 	case ir.OMETHEXPR:
 		n := n.(*ir.MethodExpr)
@@ -2138,7 +2138,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		return s.entryNewValue1A(ssa.OpAddr, types.NewPtr(n.Type()), sym, s.sb)
 	case ir.ONAME:
 		n := n.(*ir.Name)
-		if n.Class() == ir.PFUNC {
+		if n.Class_ == ir.PFUNC {
 			// "value" of a function is the address of the function's closure
 			sym := funcsym(n.Sym()).Linksym()
 			return s.entryNewValue1A(ssa.OpAddr, types.NewPtr(n.Type()), sym, s.sb)
@@ -2230,11 +2230,11 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 	case ir.OCONVNOP:
 		n := n.(*ir.ConvExpr)
 		to := n.Type()
-		from := n.Left().Type()
+		from := n.X.Type()
 
 		// Assume everything will work out, so set up our return value.
 		// Anything interesting that happens from here is a fatal.
-		x := s.expr(n.Left())
+		x := s.expr(n.X)
 		if to == from {
 			return x
 		}
@@ -2298,9 +2298,9 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 
 	case ir.OCONV:
 		n := n.(*ir.ConvExpr)
-		x := s.expr(n.Left())
-		ft := n.Left().Type() // from type
-		tt := n.Type()        // to type
+		x := s.expr(n.X)
+		ft := n.X.Type() // from type
+		tt := n.Type()   // to type
 		if ft.IsBoolean() && tt.IsKind(types.TUINT8) {
 			// Bool -> uint8 is generated internally when indexing into runtime.staticbyte.
 			return s.newValue1(ssa.OpCopy, n.Type(), x)
@@ -2465,7 +2465,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 				s.newValueOrSfCall1(op, ttp, s.newValue1(ssa.OpComplexImag, ftp, x)))
 		}
 
-		s.Fatalf("unhandled OCONV %s -> %s", n.Left().Type().Kind(), n.Type().Kind())
+		s.Fatalf("unhandled OCONV %s -> %s", n.X.Type().Kind(), n.Type().Kind())
 		return nil
 
 	case ir.ODOTTYPE:
@@ -2476,10 +2476,10 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 	// binary ops
 	case ir.OLT, ir.OEQ, ir.ONE, ir.OLE, ir.OGE, ir.OGT:
 		n := n.(*ir.BinaryExpr)
-		a := s.expr(n.Left())
-		b := s.expr(n.Right())
-		if n.Left().Type().IsComplex() {
-			pt := floatForComplex(n.Left().Type())
+		a := s.expr(n.X)
+		b := s.expr(n.Y)
+		if n.X.Type().IsComplex() {
+			pt := floatForComplex(n.X.Type())
 			op := s.ssaOp(ir.OEQ, pt)
 			r := s.newValueOrSfCall2(op, types.Types[types.TBOOL], s.newValue1(ssa.OpComplexReal, pt, a), s.newValue1(ssa.OpComplexReal, pt, b))
 			i := s.newValueOrSfCall2(op, types.Types[types.TBOOL], s.newValue1(ssa.OpComplexImag, pt, a), s.newValue1(ssa.OpComplexImag, pt, b))
@@ -2502,16 +2502,16 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		case ir.OGT:
 			op, a, b = ir.OLT, b, a
 		}
-		if n.Left().Type().IsFloat() {
+		if n.X.Type().IsFloat() {
 			// float comparison
-			return s.newValueOrSfCall2(s.ssaOp(op, n.Left().Type()), types.Types[types.TBOOL], a, b)
+			return s.newValueOrSfCall2(s.ssaOp(op, n.X.Type()), types.Types[types.TBOOL], a, b)
 		}
 		// integer comparison
-		return s.newValue2(s.ssaOp(op, n.Left().Type()), types.Types[types.TBOOL], a, b)
+		return s.newValue2(s.ssaOp(op, n.X.Type()), types.Types[types.TBOOL], a, b)
 	case ir.OMUL:
 		n := n.(*ir.BinaryExpr)
-		a := s.expr(n.Left())
-		b := s.expr(n.Right())
+		a := s.expr(n.X)
+		b := s.expr(n.Y)
 		if n.Type().IsComplex() {
 			mulop := ssa.OpMul64F
 			addop := ssa.OpAdd64F
@@ -2550,8 +2550,8 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 
 	case ir.ODIV:
 		n := n.(*ir.BinaryExpr)
-		a := s.expr(n.Left())
-		b := s.expr(n.Right())
+		a := s.expr(n.X)
+		b := s.expr(n.Y)
 		if n.Type().IsComplex() {
 			// TODO this is not executed because the front-end substitutes a runtime call.
 			// That probably ought to change; with modest optimization the widen/narrow
@@ -2598,13 +2598,13 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		return s.intDivide(n, a, b)
 	case ir.OMOD:
 		n := n.(*ir.BinaryExpr)
-		a := s.expr(n.Left())
-		b := s.expr(n.Right())
+		a := s.expr(n.X)
+		b := s.expr(n.Y)
 		return s.intDivide(n, a, b)
 	case ir.OADD, ir.OSUB:
 		n := n.(*ir.BinaryExpr)
-		a := s.expr(n.Left())
-		b := s.expr(n.Right())
+		a := s.expr(n.X)
+		b := s.expr(n.Y)
 		if n.Type().IsComplex() {
 			pt := floatForComplex(n.Type())
 			op := s.ssaOp(n.Op(), pt)
@@ -2618,19 +2618,19 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		return s.newValue2(s.ssaOp(n.Op(), n.Type()), a.Type, a, b)
 	case ir.OAND, ir.OOR, ir.OXOR:
 		n := n.(*ir.BinaryExpr)
-		a := s.expr(n.Left())
-		b := s.expr(n.Right())
+		a := s.expr(n.X)
+		b := s.expr(n.Y)
 		return s.newValue2(s.ssaOp(n.Op(), n.Type()), a.Type, a, b)
 	case ir.OANDNOT:
 		n := n.(*ir.BinaryExpr)
-		a := s.expr(n.Left())
-		b := s.expr(n.Right())
+		a := s.expr(n.X)
+		b := s.expr(n.Y)
 		b = s.newValue1(s.ssaOp(ir.OBITNOT, b.Type), b.Type, b)
 		return s.newValue2(s.ssaOp(ir.OAND, n.Type()), a.Type, a, b)
 	case ir.OLSH, ir.ORSH:
 		n := n.(*ir.BinaryExpr)
-		a := s.expr(n.Left())
-		b := s.expr(n.Right())
+		a := s.expr(n.X)
+		b := s.expr(n.Y)
 		bt := b.Type
 		if bt.IsSigned() {
 			cmp := s.newValue2(s.ssaOp(ir.OLE, bt), types.Types[types.TBOOL], s.zeroVal(bt), b)
@@ -2653,7 +2653,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		// Using var in the subsequent block introduces the
 		// necessary phi variable.
 		n := n.(*ir.LogicalExpr)
-		el := s.expr(n.Left())
+		el := s.expr(n.X)
 		s.vars[n] = el
 
 		b := s.endBlock()
@@ -2675,7 +2675,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		}
 
 		s.startBlock(bRight)
-		er := s.expr(n.Right())
+		er := s.expr(n.Y)
 		s.vars[n] = er
 
 		b = s.endBlock()
@@ -2685,14 +2685,14 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		return s.variable(n, types.Types[types.TBOOL])
 	case ir.OCOMPLEX:
 		n := n.(*ir.BinaryExpr)
-		r := s.expr(n.Left())
-		i := s.expr(n.Right())
+		r := s.expr(n.X)
+		i := s.expr(n.Y)
 		return s.newValue2(ssa.OpComplexMake, n.Type(), r, i)
 
 	// unary ops
 	case ir.ONEG:
 		n := n.(*ir.UnaryExpr)
-		a := s.expr(n.Left())
+		a := s.expr(n.X)
 		if n.Type().IsComplex() {
 			tp := floatForComplex(n.Type())
 			negop := s.ssaOp(n.Op(), tp)
@@ -2703,31 +2703,31 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		return s.newValue1(s.ssaOp(n.Op(), n.Type()), a.Type, a)
 	case ir.ONOT, ir.OBITNOT:
 		n := n.(*ir.UnaryExpr)
-		a := s.expr(n.Left())
+		a := s.expr(n.X)
 		return s.newValue1(s.ssaOp(n.Op(), n.Type()), a.Type, a)
 	case ir.OIMAG, ir.OREAL:
 		n := n.(*ir.UnaryExpr)
-		a := s.expr(n.Left())
-		return s.newValue1(s.ssaOp(n.Op(), n.Left().Type()), n.Type(), a)
+		a := s.expr(n.X)
+		return s.newValue1(s.ssaOp(n.Op(), n.X.Type()), n.Type(), a)
 	case ir.OPLUS:
 		n := n.(*ir.UnaryExpr)
-		return s.expr(n.Left())
+		return s.expr(n.X)
 
 	case ir.OADDR:
 		n := n.(*ir.AddrExpr)
-		return s.addr(n.Left())
+		return s.addr(n.X)
 
 	case ir.ORESULT:
 		n := n.(*ir.ResultExpr)
 		if s.prevCall == nil || s.prevCall.Op != ssa.OpStaticLECall && s.prevCall.Op != ssa.OpInterLECall && s.prevCall.Op != ssa.OpClosureLECall {
 			// Do the old thing
-			addr := s.constOffPtrSP(types.NewPtr(n.Type()), n.Offset())
+			addr := s.constOffPtrSP(types.NewPtr(n.Type()), n.Offset)
 			return s.rawLoad(n.Type(), addr)
 		}
-		which := s.prevCall.Aux.(*ssa.AuxCall).ResultForOffset(n.Offset())
+		which := s.prevCall.Aux.(*ssa.AuxCall).ResultForOffset(n.Offset)
 		if which == -1 {
 			// Do the old thing // TODO: Panic instead.
-			addr := s.constOffPtrSP(types.NewPtr(n.Type()), n.Offset())
+			addr := s.constOffPtrSP(types.NewPtr(n.Type()), n.Offset)
 			return s.rawLoad(n.Type(), addr)
 		}
 		if canSSAType(n.Type()) {
@@ -2739,17 +2739,17 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 
 	case ir.ODEREF:
 		n := n.(*ir.StarExpr)
-		p := s.exprPtr(n.Left(), n.Bounded(), n.Pos())
+		p := s.exprPtr(n.X, n.Bounded(), n.Pos())
 		return s.load(n.Type(), p)
 
 	case ir.ODOT:
 		n := n.(*ir.SelectorExpr)
-		if n.Left().Op() == ir.OSTRUCTLIT {
+		if n.X.Op() == ir.OSTRUCTLIT {
 			// All literals with nonzero fields have already been
 			// rewritten during walk. Any that remain are just T{}
 			// or equivalents. Use the zero value.
-			if !isZero(n.Left()) {
-				s.Fatalf("literal with nonzero value in SSA: %v", n.Left())
+			if !isZero(n.X) {
+				s.Fatalf("literal with nonzero value in SSA: %v", n.X)
 			}
 			return s.zeroVal(n.Type())
 		}
@@ -2761,46 +2761,46 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 			p := s.addr(n)
 			return s.load(n.Type(), p)
 		}
-		v := s.expr(n.Left())
+		v := s.expr(n.X)
 		return s.newValue1I(ssa.OpStructSelect, n.Type(), int64(fieldIdx(n)), v)
 
 	case ir.ODOTPTR:
 		n := n.(*ir.SelectorExpr)
-		p := s.exprPtr(n.Left(), n.Bounded(), n.Pos())
-		p = s.newValue1I(ssa.OpOffPtr, types.NewPtr(n.Type()), n.Offset(), p)
+		p := s.exprPtr(n.X, n.Bounded(), n.Pos())
+		p = s.newValue1I(ssa.OpOffPtr, types.NewPtr(n.Type()), n.Offset, p)
 		return s.load(n.Type(), p)
 
 	case ir.OINDEX:
 		n := n.(*ir.IndexExpr)
 		switch {
-		case n.Left().Type().IsString():
-			if n.Bounded() && ir.IsConst(n.Left(), constant.String) && ir.IsConst(n.Right(), constant.Int) {
+		case n.X.Type().IsString():
+			if n.Bounded() && ir.IsConst(n.X, constant.String) && ir.IsConst(n.Index, constant.Int) {
 				// Replace "abc"[1] with 'b'.
 				// Delayed until now because "abc"[1] is not an ideal constant.
 				// See test/fixedbugs/issue11370.go.
-				return s.newValue0I(ssa.OpConst8, types.Types[types.TUINT8], int64(int8(ir.StringVal(n.Left())[ir.Int64Val(n.Right())])))
+				return s.newValue0I(ssa.OpConst8, types.Types[types.TUINT8], int64(int8(ir.StringVal(n.X)[ir.Int64Val(n.Index)])))
 			}
-			a := s.expr(n.Left())
-			i := s.expr(n.Right())
+			a := s.expr(n.X)
+			i := s.expr(n.Index)
 			len := s.newValue1(ssa.OpStringLen, types.Types[types.TINT], a)
 			i = s.boundsCheck(i, len, ssa.BoundsIndex, n.Bounded())
 			ptrtyp := s.f.Config.Types.BytePtr
 			ptr := s.newValue1(ssa.OpStringPtr, ptrtyp, a)
-			if ir.IsConst(n.Right(), constant.Int) {
-				ptr = s.newValue1I(ssa.OpOffPtr, ptrtyp, ir.Int64Val(n.Right()), ptr)
+			if ir.IsConst(n.Index, constant.Int) {
+				ptr = s.newValue1I(ssa.OpOffPtr, ptrtyp, ir.Int64Val(n.Index), ptr)
 			} else {
 				ptr = s.newValue2(ssa.OpAddPtr, ptrtyp, ptr, i)
 			}
 			return s.load(types.Types[types.TUINT8], ptr)
-		case n.Left().Type().IsSlice():
+		case n.X.Type().IsSlice():
 			p := s.addr(n)
-			return s.load(n.Left().Type().Elem(), p)
-		case n.Left().Type().IsArray():
-			if canSSAType(n.Left().Type()) {
+			return s.load(n.X.Type().Elem(), p)
+		case n.X.Type().IsArray():
+			if canSSAType(n.X.Type()) {
 				// SSA can handle arrays of length at most 1.
-				bound := n.Left().Type().NumElem()
-				a := s.expr(n.Left())
-				i := s.expr(n.Right())
+				bound := n.X.Type().NumElem()
+				a := s.expr(n.X)
+				i := s.expr(n.Index)
 				if bound == 0 {
 					// Bounds check will never succeed.  Might as well
 					// use constants for the bounds check.
@@ -2814,33 +2814,33 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 				return s.newValue1I(ssa.OpArraySelect, n.Type(), 0, a)
 			}
 			p := s.addr(n)
-			return s.load(n.Left().Type().Elem(), p)
+			return s.load(n.X.Type().Elem(), p)
 		default:
-			s.Fatalf("bad type for index %v", n.Left().Type())
+			s.Fatalf("bad type for index %v", n.X.Type())
 			return nil
 		}
 
 	case ir.OLEN, ir.OCAP:
 		n := n.(*ir.UnaryExpr)
 		switch {
-		case n.Left().Type().IsSlice():
+		case n.X.Type().IsSlice():
 			op := ssa.OpSliceLen
 			if n.Op() == ir.OCAP {
 				op = ssa.OpSliceCap
 			}
-			return s.newValue1(op, types.Types[types.TINT], s.expr(n.Left()))
-		case n.Left().Type().IsString(): // string; not reachable for OCAP
-			return s.newValue1(ssa.OpStringLen, types.Types[types.TINT], s.expr(n.Left()))
-		case n.Left().Type().IsMap(), n.Left().Type().IsChan():
-			return s.referenceTypeBuiltin(n, s.expr(n.Left()))
+			return s.newValue1(op, types.Types[types.TINT], s.expr(n.X))
+		case n.X.Type().IsString(): // string; not reachable for OCAP
+			return s.newValue1(ssa.OpStringLen, types.Types[types.TINT], s.expr(n.X))
+		case n.X.Type().IsMap(), n.X.Type().IsChan():
+			return s.referenceTypeBuiltin(n, s.expr(n.X))
 		default: // array
-			return s.constInt(types.Types[types.TINT], n.Left().Type().NumElem())
+			return s.constInt(types.Types[types.TINT], n.X.Type().NumElem())
 		}
 
 	case ir.OSPTR:
 		n := n.(*ir.UnaryExpr)
-		a := s.expr(n.Left())
-		if n.Left().Type().IsSlice() {
+		a := s.expr(n.X)
+		if n.X.Type().IsSlice() {
 			return s.newValue1(ssa.OpSlicePtr, n.Type(), a)
 		} else {
 			return s.newValue1(ssa.OpStringPtr, n.Type(), a)
@@ -2848,30 +2848,30 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 
 	case ir.OITAB:
 		n := n.(*ir.UnaryExpr)
-		a := s.expr(n.Left())
+		a := s.expr(n.X)
 		return s.newValue1(ssa.OpITab, n.Type(), a)
 
 	case ir.OIDATA:
 		n := n.(*ir.UnaryExpr)
-		a := s.expr(n.Left())
+		a := s.expr(n.X)
 		return s.newValue1(ssa.OpIData, n.Type(), a)
 
 	case ir.OEFACE:
 		n := n.(*ir.BinaryExpr)
-		tab := s.expr(n.Left())
-		data := s.expr(n.Right())
+		tab := s.expr(n.X)
+		data := s.expr(n.Y)
 		return s.newValue2(ssa.OpIMake, n.Type(), tab, data)
 
 	case ir.OSLICEHEADER:
 		n := n.(*ir.SliceHeaderExpr)
-		p := s.expr(n.Left())
-		l := s.expr(n.List().First())
-		c := s.expr(n.List().Second())
+		p := s.expr(n.Ptr)
+		l := s.expr(n.LenCap.First())
+		c := s.expr(n.LenCap.Second())
 		return s.newValue3(ssa.OpSliceMake, n.Type(), p, l, c)
 
 	case ir.OSLICE, ir.OSLICEARR, ir.OSLICE3, ir.OSLICE3ARR:
 		n := n.(*ir.SliceExpr)
-		v := s.expr(n.Left())
+		v := s.expr(n.X)
 		var i, j, k *ssa.Value
 		low, high, max := n.SliceBounds()
 		if low != nil {
@@ -2888,7 +2888,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 
 	case ir.OSLICESTR:
 		n := n.(*ir.SliceExpr)
-		v := s.expr(n.Left())
+		v := s.expr(n.X)
 		var i, j *ssa.Value
 		low, high, _ := n.SliceBounds()
 		if low != nil {
@@ -2933,7 +2933,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		if n.Type().Elem().Size() == 0 {
 			return s.newValue1A(ssa.OpAddr, n.Type(), zerobaseSym, s.sb)
 		}
-		typ := s.expr(n.Left())
+		typ := s.expr(n.X)
 		vv := s.rtcall(newobject, true, []*types.Type{n.Type()}, typ)
 		return vv[0]
 
@@ -2987,7 +2987,7 @@ func (s *state) append(n *ir.CallExpr, inplace bool) *ssa.Value {
 	pt := types.NewPtr(et)
 
 	// Evaluate slice
-	sn := n.List().First() // the slice node is the first in the list
+	sn := n.Args.First() // the slice node is the first in the list
 
 	var slice, addr *ssa.Value
 	if inplace {
@@ -3002,7 +3002,7 @@ func (s *state) append(n *ir.CallExpr, inplace bool) *ssa.Value {
 	assign := s.f.NewBlock(ssa.BlockPlain)
 
 	// Decide if we need to grow
-	nargs := int64(n.List().Len() - 1)
+	nargs := int64(n.Args.Len() - 1)
 	p := s.newValue1(ssa.OpSlicePtr, pt, slice)
 	l := s.newValue1(ssa.OpSliceLen, types.Types[types.TINT], slice)
 	c := s.newValue1(ssa.OpSliceCap, types.Types[types.TINT], slice)
@@ -3027,13 +3027,13 @@ func (s *state) append(n *ir.CallExpr, inplace bool) *ssa.Value {
 
 	// Call growslice
 	s.startBlock(grow)
-	taddr := s.expr(n.Left())
+	taddr := s.expr(n.X)
 	r := s.rtcall(growslice, true, []*types.Type{pt, types.Types[types.TINT], types.Types[types.TINT]}, taddr, p, l, c, nl)
 
 	if inplace {
 		if sn.Op() == ir.ONAME {
 			sn := sn.(*ir.Name)
-			if sn.Class() != ir.PEXTERN {
+			if sn.Class_ != ir.PEXTERN {
 				// Tell liveness we're about to build a new slice
 				s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, sn, s.mem())
 			}
@@ -3071,7 +3071,7 @@ func (s *state) append(n *ir.CallExpr, inplace bool) *ssa.Value {
 		store bool
 	}
 	args := make([]argRec, 0, nargs)
-	for _, n := range n.List().Slice()[1:] {
+	for _, n := range n.Args.Slice()[1:] {
 		if canSSAType(n.Type()) {
 			args = append(args, argRec{v: s.expr(n), store: true})
 		} else {
@@ -3116,9 +3116,9 @@ func (s *state) condBranch(cond ir.Node, yes, no *ssa.Block, likely int8) {
 		cond := cond.(*ir.LogicalExpr)
 		mid := s.f.NewBlock(ssa.BlockPlain)
 		s.stmtList(cond.Init())
-		s.condBranch(cond.Left(), mid, no, max8(likely, 0))
+		s.condBranch(cond.X, mid, no, max8(likely, 0))
 		s.startBlock(mid)
-		s.condBranch(cond.Right(), yes, no, likely)
+		s.condBranch(cond.Y, yes, no, likely)
 		return
 		// Note: if likely==1, then both recursive calls pass 1.
 		// If likely==-1, then we don't have enough information to decide
@@ -3130,9 +3130,9 @@ func (s *state) condBranch(cond ir.Node, yes, no *ssa.Block, likely int8) {
 		cond := cond.(*ir.LogicalExpr)
 		mid := s.f.NewBlock(ssa.BlockPlain)
 		s.stmtList(cond.Init())
-		s.condBranch(cond.Left(), yes, mid, min8(likely, 0))
+		s.condBranch(cond.X, yes, mid, min8(likely, 0))
 		s.startBlock(mid)
-		s.condBranch(cond.Right(), yes, no, likely)
+		s.condBranch(cond.Y, yes, no, likely)
 		return
 		// Note: if likely==-1, then both recursive calls pass -1.
 		// If likely==1, then we don't have enough info to decide
@@ -3140,12 +3140,12 @@ func (s *state) condBranch(cond ir.Node, yes, no *ssa.Block, likely int8) {
 	case ir.ONOT:
 		cond := cond.(*ir.UnaryExpr)
 		s.stmtList(cond.Init())
-		s.condBranch(cond.Left(), no, yes, -likely)
+		s.condBranch(cond.X, no, yes, -likely)
 		return
 	case ir.OCONVNOP:
 		cond := cond.(*ir.ConvExpr)
 		s.stmtList(cond.Init())
-		s.condBranch(cond.Left(), yes, no, likely)
+		s.condBranch(cond.X, yes, no, likely)
 		return
 	}
 	c := s.expr(cond)
@@ -3192,12 +3192,12 @@ func (s *state) assign(left ir.Node, right *ssa.Value, deref bool, skip skipMask
 
 			// Grab information about the structure type.
 			left := left.(*ir.SelectorExpr)
-			t := left.Left().Type()
+			t := left.X.Type()
 			nf := t.NumFields()
 			idx := fieldIdx(left)
 
 			// Grab old value of structure.
-			old := s.expr(left.Left())
+			old := s.expr(left.X)
 
 			// Make new structure.
 			new := s.newValue0(ssa.StructMakeOp(t.NumFields()), t)
@@ -3212,20 +3212,20 @@ func (s *state) assign(left ir.Node, right *ssa.Value, deref bool, skip skipMask
 			}
 
 			// Recursively assign the new value we've made to the base of the dot op.
-			s.assign(left.Left(), new, false, 0)
+			s.assign(left.X, new, false, 0)
 			// TODO: do we need to update named values here?
 			return
 		}
-		if left.Op() == ir.OINDEX && left.(*ir.IndexExpr).Left().Type().IsArray() {
+		if left.Op() == ir.OINDEX && left.(*ir.IndexExpr).X.Type().IsArray() {
 			left := left.(*ir.IndexExpr)
 			s.pushLine(left.Pos())
 			defer s.popLine()
 			// We're assigning to an element of an ssa-able array.
 			// a[i] = v
-			t := left.Left().Type()
+			t := left.X.Type()
 			n := t.NumElem()
 
-			i := s.expr(left.Right()) // index
+			i := s.expr(left.Index) // index
 			if n == 0 {
 				// The bounds check must fail.  Might as well
 				// ignore the actual index and just use zeros.
@@ -3240,7 +3240,7 @@ func (s *state) assign(left ir.Node, right *ssa.Value, deref bool, skip skipMask
 			len := s.constInt(types.Types[types.TINT], 1)
 			s.boundsCheck(i, len, ssa.BoundsIndex, false) // checks i == 0
 			v := s.newValue1(ssa.OpArrayMake1, t, right)
-			s.assign(left.Left(), v, false, 0)
+			s.assign(left.X, v, false, 0)
 			return
 		}
 		left := left.(*ir.Name)
@@ -3252,7 +3252,7 @@ func (s *state) assign(left ir.Node, right *ssa.Value, deref bool, skip skipMask
 
 	// If this assignment clobbers an entire local variable, then emit
 	// OpVarDef so liveness analysis knows the variable is redefined.
-	if base := clobberBase(left); base.Op() == ir.ONAME && base.(*ir.Name).Class() != ir.PEXTERN && skip == 0 {
+	if base := clobberBase(left); base.Op() == ir.ONAME && base.(*ir.Name).Class_ != ir.PEXTERN && skip == 0 {
 		s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, base.(*ir.Name), s.mem(), !ir.IsAutoTmp(base))
 	}
 
@@ -4333,7 +4333,7 @@ func isIntrinsicCall(n *ir.CallExpr) bool {
 	if n == nil {
 		return false
 	}
-	name, ok := n.Left().(*ir.Name)
+	name, ok := n.X.(*ir.Name)
 	if !ok {
 		return false
 	}
@@ -4342,7 +4342,7 @@ func isIntrinsicCall(n *ir.CallExpr) bool {
 
 // intrinsicCall converts a call to a recognized intrinsic function into the intrinsic SSA operation.
 func (s *state) intrinsicCall(n *ir.CallExpr) *ssa.Value {
-	v := findIntrinsic(n.Left().Sym())(s, n, s.intrinsicArgs(n))
+	v := findIntrinsic(n.X.Sym())(s, n, s.intrinsicArgs(n))
 	if ssa.IntrinsicsDebug > 0 {
 		x := v
 		if x == nil {
@@ -4351,7 +4351,7 @@ func (s *state) intrinsicCall(n *ir.CallExpr) *ssa.Value {
 		if x.Op == ssa.OpSelect0 || x.Op == ssa.OpSelect1 {
 			x = x.Args[0]
 		}
-		base.WarnfAt(n.Pos(), "intrinsic substitution for %v with %s", n.Left().Sym().Name, x.LongString())
+		base.WarnfAt(n.Pos(), "intrinsic substitution for %v with %s", n.X.Sym().Name, x.LongString())
 	}
 	return v
 }
@@ -4360,12 +4360,12 @@ func (s *state) intrinsicCall(n *ir.CallExpr) *ssa.Value {
 func (s *state) intrinsicArgs(n *ir.CallExpr) []*ssa.Value {
 	// Construct map of temps; see comments in s.call about the structure of n.
 	temps := map[ir.Node]*ssa.Value{}
-	for _, a := range n.List().Slice() {
+	for _, a := range n.Args.Slice() {
 		if a.Op() != ir.OAS {
 			s.Fatalf("non-assignment as a temp function argument %v", a.Op())
 		}
 		a := a.(*ir.AssignStmt)
-		l, r := a.Left(), a.Right()
+		l, r := a.X, a.Y
 		if l.Op() != ir.ONAME {
 			s.Fatalf("non-ONAME temp function argument %v", a.Op())
 		}
@@ -4373,8 +4373,8 @@ func (s *state) intrinsicArgs(n *ir.CallExpr) []*ssa.Value {
 		// Walk ensures these temporaries are dead outside of n.
 		temps[l] = s.expr(r)
 	}
-	args := make([]*ssa.Value, n.Rlist().Len())
-	for i, n := range n.Rlist().Slice() {
+	args := make([]*ssa.Value, n.Rargs.Len())
+	for i, n := range n.Rargs.Slice() {
 		// Store a value to an argument slot.
 		if x, ok := temps[n]; ok {
 			// This is a previously computed temporary.
@@ -4399,7 +4399,7 @@ func (s *state) openDeferRecord(n *ir.CallExpr) {
 	// once.mutex'. Such a statement will create a mapping in s.vars[] from
 	// the autotmp name to the evaluated SSA arg value, but won't do any
 	// stores to the stack.
-	s.stmtList(n.List())
+	s.stmtList(n.Args)
 
 	var args []*ssa.Value
 	var argNodes []*ir.Name
@@ -4407,7 +4407,7 @@ func (s *state) openDeferRecord(n *ir.CallExpr) {
 	opendefer := &openDeferInfo{
 		n: n,
 	}
-	fn := n.Left()
+	fn := n.X
 	if n.Op() == ir.OCALLFUNC {
 		// We must always store the function value in a stack slot for the
 		// runtime panic code to use. But in the defer exit code, we will
@@ -4415,7 +4415,7 @@ func (s *state) openDeferRecord(n *ir.CallExpr) {
 		closureVal := s.expr(fn)
 		closure := s.openDeferSave(nil, fn.Type(), closureVal)
 		opendefer.closureNode = closure.Aux.(*ir.Name)
-		if !(fn.Op() == ir.ONAME && fn.(*ir.Name).Class() == ir.PFUNC) {
+		if !(fn.Op() == ir.ONAME && fn.(*ir.Name).Class_ == ir.PFUNC) {
 			opendefer.closure = closure
 		}
 	} else if n.Op() == ir.OCALLMETH {
@@ -4442,7 +4442,7 @@ func (s *state) openDeferRecord(n *ir.CallExpr) {
 		opendefer.closureNode = opendefer.closure.Aux.(*ir.Name)
 		opendefer.rcvrNode = opendefer.rcvr.Aux.(*ir.Name)
 	}
-	for _, argn := range n.Rlist().Slice() {
+	for _, argn := range n.Rargs.Slice() {
 		var v *ssa.Value
 		if canSSAType(argn.Type()) {
 			v = s.openDeferSave(nil, argn.Type(), s.expr(argn))
@@ -4565,7 +4565,7 @@ func (s *state) openDeferExit() {
 		// closure/receiver/args that were stored in argtmps at the point
 		// of the defer statement.
 		argStart := base.Ctxt.FixedFrameSize()
-		fn := r.n.Left()
+		fn := r.n.X
 		stksize := fn.Type().ArgWidth()
 		var ACArgs []ssa.Param
 		var ACResults []ssa.Param
@@ -4672,11 +4672,11 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 	var closure *ssa.Value // ptr to closure to run (if dynamic)
 	var codeptr *ssa.Value // ptr to target code (if dynamic)
 	var rcvr *ssa.Value    // receiver to set
-	fn := n.Left()
+	fn := n.X
 	var ACArgs []ssa.Param
 	var ACResults []ssa.Param
 	var callArgs []*ssa.Value
-	res := n.Left().Type().Results()
+	res := n.X.Type().Results()
 	if k == callNormal {
 		nf := res.NumFields()
 		for i := 0; i < nf; i++ {
@@ -4690,7 +4690,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 	switch n.Op() {
 	case ir.OCALLFUNC:
 		testLateExpansion = k != callDeferStack && ssa.LateCallExpansionEnabledWithin(s.f)
-		if k == callNormal && fn.Op() == ir.ONAME && fn.(*ir.Name).Class() == ir.PFUNC {
+		if k == callNormal && fn.Op() == ir.ONAME && fn.(*ir.Name).Class_ == ir.PFUNC {
 			fn := fn.(*ir.Name)
 			sym = fn.Sym()
 			break
@@ -4708,7 +4708,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		fn := fn.(*ir.SelectorExpr)
 		testLateExpansion = k != callDeferStack && ssa.LateCallExpansionEnabledWithin(s.f)
 		if k == callNormal {
-			sym = fn.Sym()
+			sym = fn.Sel
 			break
 		}
 		closure = s.getMethodClosure(fn)
@@ -4734,7 +4734,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 	// Run all assignments of temps.
 	// The temps are introduced to avoid overwriting argument
 	// slots when arguments themselves require function calls.
-	s.stmtList(n.List())
+	s.stmtList(n.Args)
 
 	var call *ssa.Value
 	if k == callDeferStack {
@@ -4769,7 +4769,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		// Then, store all the arguments of the defer call.
 		ft := fn.Type()
 		off := t.FieldOff(12)
-		args := n.Rlist().Slice()
+		args := n.Rargs.Slice()
 
 		// Set receiver (for interface calls). Always a pointer.
 		if rcvr != nil {
@@ -4845,8 +4845,8 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		}
 
 		// Write args.
-		t := n.Left().Type()
-		args := n.Rlist().Slice()
+		t := n.X.Type()
+		args := n.Rargs.Slice()
 		if n.Op() == ir.OCALLMETH {
 			f := t.Recv()
 			ACArg, arg := s.putArg(args[0], f.Type, argStart+f.Offset, testLateExpansion)
@@ -4923,7 +4923,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		s.vars[memVar] = call
 	}
 	// Insert OVARLIVE nodes
-	s.stmtList(n.Body())
+	s.stmtList(n.Body)
 
 	// Finish block for defers
 	if k == callDefer || k == callDeferStack {
@@ -4977,9 +4977,9 @@ func (s *state) getMethodClosure(fn *ir.SelectorExpr) *ssa.Value {
 	// Make a PFUNC node out of that, then evaluate it.
 	// We get back an SSA value representing &sync.(*Mutex).Unlock·f.
 	// We can then pass that to defer or go.
-	n2 := ir.NewNameAt(fn.Pos(), fn.Sym())
+	n2 := ir.NewNameAt(fn.Pos(), fn.Sel)
 	n2.Curfn = s.curfn
-	n2.SetClass(ir.PFUNC)
+	n2.Class_ = ir.PFUNC
 	// n2.Sym already existed, so it's already marked as a function.
 	n2.SetPos(fn.Pos())
 	n2.SetType(types.Types[types.TUINT8]) // fake type for a static closure. Could use runtime.funcval if we had it.
@@ -4989,10 +4989,10 @@ func (s *state) getMethodClosure(fn *ir.SelectorExpr) *ssa.Value {
 // getClosureAndRcvr returns values for the appropriate closure and receiver of an
 // interface call
 func (s *state) getClosureAndRcvr(fn *ir.SelectorExpr) (*ssa.Value, *ssa.Value) {
-	i := s.expr(fn.Left())
+	i := s.expr(fn.X)
 	itab := s.newValue1(ssa.OpITab, types.Types[types.TUINTPTR], i)
 	s.nilCheck(itab)
-	itabidx := fn.Offset() + 2*int64(Widthptr) + 8 // offset of fun field in runtime.itab
+	itabidx := fn.Offset + 2*int64(Widthptr) + 8 // offset of fun field in runtime.itab
 	closure := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.UintptrPtr, itabidx, itab)
 	rcvr := s.newValue1(ssa.OpIData, s.f.Config.Types.BytePtr, i)
 	return closure, rcvr
@@ -5028,7 +5028,7 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 		fallthrough
 	case ir.ONAME:
 		n := n.(*ir.Name)
-		switch n.Class() {
+		switch n.Class_ {
 		case ir.PEXTERN:
 			// global variable
 			v := s.entryNewValue1A(ssa.OpAddr, t, n.Sym().Linksym(), s.sb)
@@ -5057,60 +5057,60 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 			// that cse works on their addresses
 			return s.newValue2Apos(ssa.OpLocalAddr, t, n, s.sp, s.mem(), true)
 		default:
-			s.Fatalf("variable address class %v not implemented", n.Class())
+			s.Fatalf("variable address class %v not implemented", n.Class_)
 			return nil
 		}
 	case ir.ORESULT:
 		// load return from callee
 		n := n.(*ir.ResultExpr)
 		if s.prevCall == nil || s.prevCall.Op != ssa.OpStaticLECall && s.prevCall.Op != ssa.OpInterLECall && s.prevCall.Op != ssa.OpClosureLECall {
-			return s.constOffPtrSP(t, n.Offset())
+			return s.constOffPtrSP(t, n.Offset)
 		}
-		which := s.prevCall.Aux.(*ssa.AuxCall).ResultForOffset(n.Offset())
+		which := s.prevCall.Aux.(*ssa.AuxCall).ResultForOffset(n.Offset)
 		if which == -1 {
 			// Do the old thing // TODO: Panic instead.
-			return s.constOffPtrSP(t, n.Offset())
+			return s.constOffPtrSP(t, n.Offset)
 		}
 		x := s.newValue1I(ssa.OpSelectNAddr, t, which, s.prevCall)
 		return x
 
 	case ir.OINDEX:
 		n := n.(*ir.IndexExpr)
-		if n.Left().Type().IsSlice() {
-			a := s.expr(n.Left())
-			i := s.expr(n.Right())
+		if n.X.Type().IsSlice() {
+			a := s.expr(n.X)
+			i := s.expr(n.Index)
 			len := s.newValue1(ssa.OpSliceLen, types.Types[types.TINT], a)
 			i = s.boundsCheck(i, len, ssa.BoundsIndex, n.Bounded())
 			p := s.newValue1(ssa.OpSlicePtr, t, a)
 			return s.newValue2(ssa.OpPtrIndex, t, p, i)
 		} else { // array
-			a := s.addr(n.Left())
-			i := s.expr(n.Right())
-			len := s.constInt(types.Types[types.TINT], n.Left().Type().NumElem())
+			a := s.addr(n.X)
+			i := s.expr(n.Index)
+			len := s.constInt(types.Types[types.TINT], n.X.Type().NumElem())
 			i = s.boundsCheck(i, len, ssa.BoundsIndex, n.Bounded())
-			return s.newValue2(ssa.OpPtrIndex, types.NewPtr(n.Left().Type().Elem()), a, i)
+			return s.newValue2(ssa.OpPtrIndex, types.NewPtr(n.X.Type().Elem()), a, i)
 		}
 	case ir.ODEREF:
 		n := n.(*ir.StarExpr)
-		return s.exprPtr(n.Left(), n.Bounded(), n.Pos())
+		return s.exprPtr(n.X, n.Bounded(), n.Pos())
 	case ir.ODOT:
 		n := n.(*ir.SelectorExpr)
-		p := s.addr(n.Left())
-		return s.newValue1I(ssa.OpOffPtr, t, n.Offset(), p)
+		p := s.addr(n.X)
+		return s.newValue1I(ssa.OpOffPtr, t, n.Offset, p)
 	case ir.ODOTPTR:
 		n := n.(*ir.SelectorExpr)
-		p := s.exprPtr(n.Left(), n.Bounded(), n.Pos())
-		return s.newValue1I(ssa.OpOffPtr, t, n.Offset(), p)
+		p := s.exprPtr(n.X, n.Bounded(), n.Pos())
+		return s.newValue1I(ssa.OpOffPtr, t, n.Offset, p)
 	case ir.OCLOSUREREAD:
 		n := n.(*ir.ClosureReadExpr)
-		return s.newValue1I(ssa.OpOffPtr, t, n.Offset(),
+		return s.newValue1I(ssa.OpOffPtr, t, n.Offset,
 			s.entryNewValue0(ssa.OpGetClosurePtr, s.f.Config.Types.BytePtr))
 	case ir.OCONVNOP:
 		n := n.(*ir.ConvExpr)
-		if n.Type() == n.Left().Type() {
-			return s.addr(n.Left())
+		if n.Type() == n.X.Type() {
+			return s.addr(n.X)
 		}
-		addr := s.addr(n.Left())
+		addr := s.addr(n.X)
 		return s.newValue1(ssa.OpCopy, t, addr) // ensure that addr has the right type
 	case ir.OCALLFUNC, ir.OCALLINTER, ir.OCALLMETH:
 		n := n.(*ir.CallExpr)
@@ -5141,13 +5141,13 @@ func (s *state) canSSA(n ir.Node) bool {
 		nn := n
 		if nn.Op() == ir.ODOT {
 			nn := nn.(*ir.SelectorExpr)
-			n = nn.Left()
+			n = nn.X
 			continue
 		}
 		if nn.Op() == ir.OINDEX {
 			nn := nn.(*ir.IndexExpr)
-			if nn.Left().Type().IsArray() {
-				n = nn.Left()
+			if nn.X.Type().IsArray() {
+				n = nn.X
 				continue
 			}
 		}
@@ -5166,10 +5166,10 @@ func (s *state) canSSAName(name *ir.Name) bool {
 	if isParamHeapCopy(name) {
 		return false
 	}
-	if name.Class() == ir.PAUTOHEAP {
+	if name.Class_ == ir.PAUTOHEAP {
 		s.Fatalf("canSSA of PAUTOHEAP %v", name)
 	}
-	switch name.Class() {
+	switch name.Class_ {
 	case ir.PEXTERN:
 		return false
 	case ir.PPARAMOUT:
@@ -5187,7 +5187,7 @@ func (s *state) canSSAName(name *ir.Name) bool {
 			return false
 		}
 	}
-	if name.Class() == ir.PPARAM && name.Sym() != nil && name.Sym().Name == ".this" {
+	if name.Class_ == ir.PPARAM && name.Sym() != nil && name.Sym().Name == ".this" {
 		// wrappers generated by genwrapper need to update
 		// the .this pointer in place.
 		// TODO: treat as a PPARAMOUT?
@@ -5893,7 +5893,7 @@ func (s *state) uint32Tofloat(cvttab *u322fcvtTab, n ir.Node, x *ssa.Value, ft,
 
 // referenceTypeBuiltin generates code for the len/cap builtins for maps and channels.
 func (s *state) referenceTypeBuiltin(n *ir.UnaryExpr, x *ssa.Value) *ssa.Value {
-	if !n.Left().Type().IsMap() && !n.Left().Type().IsChan() {
+	if !n.X.Type().IsMap() && !n.X.Type().IsChan() {
 		s.Fatalf("node must be a map or a channel")
 	}
 	// if n == nil {
@@ -6050,8 +6050,8 @@ func (s *state) floatToUint(cvttab *f2uCvtTab, n ir.Node, x *ssa.Value, ft, tt *
 // commaok indicates whether to panic or return a bool.
 // If commaok is false, resok will be nil.
 func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Value) {
-	iface := s.expr(n.Left())   // input interface
-	target := s.expr(n.Right()) // target type
+	iface := s.expr(n.X)      // input interface
+	target := s.expr(n.Ntype) // target type
 	byteptr := s.f.Config.Types.BytePtr
 
 	if n.Type().IsInterface() {
@@ -6067,7 +6067,7 @@ func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Val
 			// Conversion succeeds iff that field is not nil.
 			cond := s.newValue2(ssa.OpNeqPtr, types.Types[types.TBOOL], itab, s.constNil(byteptr))
 
-			if n.Left().Type().IsEmptyInterface() && commaok {
+			if n.X.Type().IsEmptyInterface() && commaok {
 				// Converting empty interface to empty interface with ,ok is just a nil check.
 				return iface, cond
 			}
@@ -6089,7 +6089,7 @@ func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Val
 
 				// On success, return (perhaps modified) input interface.
 				s.startBlock(bOk)
-				if n.Left().Type().IsEmptyInterface() {
+				if n.X.Type().IsEmptyInterface() {
 					res = iface // Use input interface unchanged.
 					return
 				}
@@ -6128,7 +6128,7 @@ func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Val
 		if base.Debug.TypeAssert > 0 {
 			base.WarnfAt(n.Pos(), "type assertion not inlined")
 		}
-		if n.Left().Type().IsEmptyInterface() {
+		if n.X.Type().IsEmptyInterface() {
 			if commaok {
 				call := s.rtcall(assertE2I2, true, []*types.Type{n.Type(), types.Types[types.TBOOL]}, target, iface)
 				return call[0], call[1]
@@ -6153,12 +6153,12 @@ func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Val
 		base.WarnfAt(n.Pos(), "type assertion inlined")
 	}
 	var targetITab *ssa.Value
-	if n.Left().Type().IsEmptyInterface() {
+	if n.X.Type().IsEmptyInterface() {
 		// Looking for pointer to target type.
 		targetITab = target
 	} else {
 		// Looking for pointer to itab for target type and source interface.
-		targetITab = s.expr(n.List().First())
+		targetITab = s.expr(n.Itab.First())
 	}
 
 	var tmp ir.Node     // temporary for use with large types
@@ -6185,8 +6185,8 @@ func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Val
 	if !commaok {
 		// on failure, panic by calling panicdottype
 		s.startBlock(bFail)
-		taddr := s.expr(n.Right().(*ir.AddrExpr).Right())
-		if n.Left().Type().IsEmptyInterface() {
+		taddr := s.expr(n.Ntype.(*ir.AddrExpr).Alloc)
+		if n.X.Type().IsEmptyInterface() {
 			s.rtcall(panicdottypeE, false, nil, itab, target, taddr)
 		} else {
 			s.rtcall(panicdottypeI, false, nil, itab, target, taddr)
@@ -6280,7 +6280,7 @@ func (s *state) mem() *ssa.Value {
 }
 
 func (s *state) addNamedValue(n *ir.Name, v *ssa.Value) {
-	if n.Class() == ir.Pxxx {
+	if n.Class_ == ir.Pxxx {
 		// Don't track our marker nodes (memVar etc.).
 		return
 	}
@@ -6288,7 +6288,7 @@ func (s *state) addNamedValue(n *ir.Name, v *ssa.Value) {
 		// Don't track temporary variables.
 		return
 	}
-	if n.Class() == ir.PPARAMOUT {
+	if n.Class_ == ir.PPARAMOUT {
 		// Don't track named output values.  This prevents return values
 		// from being assigned too early. See #14591 and #14762. TODO: allow this.
 		return
@@ -6811,11 +6811,11 @@ func defframe(s *SSAGenState, e *ssafn) {
 		if !n.Needzero() {
 			continue
 		}
-		if n.Class() != ir.PAUTO {
-			e.Fatalf(n.Pos(), "needzero class %d", n.Class())
+		if n.Class_ != ir.PAUTO {
+			e.Fatalf(n.Pos(), "needzero class %d", n.Class_)
 		}
 		if n.Type().Size()%int64(Widthptr) != 0 || n.FrameOffset()%int64(Widthptr) != 0 || n.Type().Size() == 0 {
-			e.Fatalf(n.Pos(), "var %L has size %d offset %d", n, n.Type().Size(), n.Offset())
+			e.Fatalf(n.Pos(), "var %L has size %d offset %d", n, n.Type().Size(), n.Offset_)
 		}
 
 		if lo != hi && n.FrameOffset()+n.Type().Size() >= lo-int64(2*Widthreg) {
@@ -6896,7 +6896,7 @@ func AddAux2(a *obj.Addr, v *ssa.Value, offset int64) {
 		a.Name = obj.NAME_EXTERN
 		a.Sym = n
 	case *ir.Name:
-		if n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT {
+		if n.Class_ == ir.PPARAM || n.Class_ == ir.PPARAMOUT {
 			a.Name = obj.NAME_PARAM
 			a.Sym = ir.Orig(n).Sym().Linksym()
 			a.Offset += n.FrameOffset()
@@ -7048,7 +7048,7 @@ func AddrAuto(a *obj.Addr, v *ssa.Value) {
 	a.Sym = n.Sym().Linksym()
 	a.Reg = int16(thearch.REGSP)
 	a.Offset = n.FrameOffset() + off
-	if n.Class() == ir.PPARAM || n.Class() == ir.PPARAMOUT {
+	if n.Class_ == ir.PPARAM || n.Class_ == ir.PPARAMOUT {
 		a.Name = obj.NAME_PARAM
 	} else {
 		a.Name = obj.NAME_AUTO
@@ -7063,7 +7063,7 @@ func (s *SSAGenState) AddrScratch(a *obj.Addr) {
 	a.Name = obj.NAME_AUTO
 	a.Sym = s.ScratchFpMem.Sym().Linksym()
 	a.Reg = int16(thearch.REGSP)
-	a.Offset = s.ScratchFpMem.Offset()
+	a.Offset = s.ScratchFpMem.Offset_
 }
 
 // Call returns a new CALL instruction for the SSA value v.
@@ -7146,8 +7146,8 @@ func (s *SSAGenState) UseArgs(n int64) {
 
 // fieldIdx finds the index of the field referred to by the ODOT node n.
 func fieldIdx(n *ir.SelectorExpr) int {
-	t := n.Left().Type()
-	f := n.Sym()
+	t := n.X.Type()
+	f := n.Sel
 	if !t.IsStruct() {
 		panic("ODOT's LHS is not a struct")
 	}
@@ -7158,7 +7158,7 @@ func fieldIdx(n *ir.SelectorExpr) int {
 			i++
 			continue
 		}
-		if t1.Offset != n.Offset() {
+		if t1.Offset != n.Offset {
 			panic("field offset doesn't match")
 		}
 		return i
@@ -7282,7 +7282,7 @@ func (e *ssafn) DerefItab(it *obj.LSym, offset int64) *obj.LSym {
 func (e *ssafn) SplitSlot(parent *ssa.LocalSlot, suffix string, offset int64, t *types.Type) ssa.LocalSlot {
 	node := parent.N
 
-	if node.Class() != ir.PAUTO || node.Name().Addrtaken() {
+	if node.Class_ != ir.PAUTO || node.Name().Addrtaken() {
 		// addressed things and non-autos retain their parents (i.e., cannot truly be split)
 		return ssa.LocalSlot{N: node, Type: t, Off: parent.Off + offset}
 	}
@@ -7292,7 +7292,7 @@ func (e *ssafn) SplitSlot(parent *ssa.LocalSlot, suffix string, offset int64, t
 	s.Def = n
 	ir.AsNode(s.Def).Name().SetUsed(true)
 	n.SetType(t)
-	n.SetClass(ir.PAUTO)
+	n.Class_ = ir.PAUTO
 	n.SetEsc(EscNever)
 	n.Curfn = e.curfn
 	e.curfn.Dcl = append(e.curfn.Dcl, n)
@@ -7368,14 +7368,14 @@ func (e *ssafn) MyImportPath() string {
 func clobberBase(n ir.Node) ir.Node {
 	if n.Op() == ir.ODOT {
 		n := n.(*ir.SelectorExpr)
-		if n.Left().Type().NumFields() == 1 {
-			return clobberBase(n.Left())
+		if n.X.Type().NumFields() == 1 {
+			return clobberBase(n.X)
 		}
 	}
 	if n.Op() == ir.OINDEX {
 		n := n.(*ir.IndexExpr)
-		if n.Left().Type().IsArray() && n.Left().Type().NumElem() == 1 {
-			return clobberBase(n.Left())
+		if n.X.Type().IsArray() && n.X.Type().NumElem() == 1 {
+			return clobberBase(n.X)
 		}
 	}
 	return n
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 5aebae0b18..450b20e000 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -616,7 +616,7 @@ func calcHasCall(n ir.Node) bool {
 		if instrumenting {
 			return true
 		}
-		return n.Left().HasCall() || n.Right().HasCall()
+		return n.X.HasCall() || n.Y.HasCall()
 	case ir.OINDEX, ir.OSLICE, ir.OSLICEARR, ir.OSLICE3, ir.OSLICE3ARR, ir.OSLICESTR,
 		ir.ODEREF, ir.ODOTPTR, ir.ODOTTYPE, ir.ODIV, ir.OMOD:
 		// These ops might panic, make sure they are done
@@ -630,49 +630,49 @@ func calcHasCall(n ir.Node) bool {
 		if thearch.SoftFloat && (isFloat[n.Type().Kind()] || isComplex[n.Type().Kind()]) {
 			return true
 		}
-		return n.Left().HasCall() || n.Right().HasCall()
+		return n.X.HasCall() || n.Y.HasCall()
 	case ir.ONEG:
 		n := n.(*ir.UnaryExpr)
 		if thearch.SoftFloat && (isFloat[n.Type().Kind()] || isComplex[n.Type().Kind()]) {
 			return true
 		}
-		return n.Left().HasCall()
+		return n.X.HasCall()
 	case ir.OLT, ir.OEQ, ir.ONE, ir.OLE, ir.OGE, ir.OGT:
 		n := n.(*ir.BinaryExpr)
-		if thearch.SoftFloat && (isFloat[n.Left().Type().Kind()] || isComplex[n.Left().Type().Kind()]) {
+		if thearch.SoftFloat && (isFloat[n.X.Type().Kind()] || isComplex[n.X.Type().Kind()]) {
 			return true
 		}
-		return n.Left().HasCall() || n.Right().HasCall()
+		return n.X.HasCall() || n.Y.HasCall()
 	case ir.OCONV:
 		n := n.(*ir.ConvExpr)
-		if thearch.SoftFloat && ((isFloat[n.Type().Kind()] || isComplex[n.Type().Kind()]) || (isFloat[n.Left().Type().Kind()] || isComplex[n.Left().Type().Kind()])) {
+		if thearch.SoftFloat && ((isFloat[n.Type().Kind()] || isComplex[n.Type().Kind()]) || (isFloat[n.X.Type().Kind()] || isComplex[n.X.Type().Kind()])) {
 			return true
 		}
-		return n.Left().HasCall()
+		return n.X.HasCall()
 
 	case ir.OAND, ir.OANDNOT, ir.OLSH, ir.OOR, ir.ORSH, ir.OXOR, ir.OCOPY, ir.OCOMPLEX, ir.OEFACE:
 		n := n.(*ir.BinaryExpr)
-		return n.Left().HasCall() || n.Right().HasCall()
+		return n.X.HasCall() || n.Y.HasCall()
 
 	case ir.OAS:
 		n := n.(*ir.AssignStmt)
-		return n.Left().HasCall() || n.Right() != nil && n.Right().HasCall()
+		return n.X.HasCall() || n.Y != nil && n.Y.HasCall()
 
 	case ir.OADDR:
 		n := n.(*ir.AddrExpr)
-		return n.Left().HasCall()
+		return n.X.HasCall()
 	case ir.OPAREN:
 		n := n.(*ir.ParenExpr)
-		return n.Left().HasCall()
+		return n.X.HasCall()
 	case ir.OBITNOT, ir.ONOT, ir.OPLUS, ir.ORECV,
 		ir.OALIGNOF, ir.OCAP, ir.OCLOSE, ir.OIMAG, ir.OLEN, ir.ONEW,
 		ir.OOFFSETOF, ir.OPANIC, ir.OREAL, ir.OSIZEOF,
 		ir.OCHECKNIL, ir.OCFUNC, ir.OIDATA, ir.OITAB, ir.ONEWOBJ, ir.OSPTR, ir.OVARDEF, ir.OVARKILL, ir.OVARLIVE:
 		n := n.(*ir.UnaryExpr)
-		return n.Left().HasCall()
+		return n.X.HasCall()
 	case ir.ODOT, ir.ODOTMETH, ir.ODOTINTER:
 		n := n.(*ir.SelectorExpr)
-		return n.Left().HasCall()
+		return n.X.HasCall()
 
 	case ir.OGETG, ir.OCLOSUREREAD, ir.OMETHEXPR:
 		return false
@@ -687,15 +687,15 @@ func calcHasCall(n ir.Node) bool {
 	case ir.OCONVIFACE, ir.OCONVNOP, ir.OBYTES2STR, ir.OBYTES2STRTMP, ir.ORUNES2STR, ir.OSTR2BYTES, ir.OSTR2BYTESTMP, ir.OSTR2RUNES, ir.ORUNESTR:
 		// TODO(rsc): Some conversions are themselves calls, no?
 		n := n.(*ir.ConvExpr)
-		return n.Left().HasCall()
+		return n.X.HasCall()
 	case ir.ODOTTYPE2:
 		// TODO(rsc): Shouldn't this be up with ODOTTYPE above?
 		n := n.(*ir.TypeAssertExpr)
-		return n.Left().HasCall()
+		return n.X.HasCall()
 	case ir.OSLICEHEADER:
 		// TODO(rsc): What about len and cap?
 		n := n.(*ir.SliceHeaderExpr)
-		return n.Left().HasCall()
+		return n.Ptr.HasCall()
 	case ir.OAS2DOTTYPE, ir.OAS2FUNC:
 		// TODO(rsc): Surely we need to check List and Rlist.
 		return false
@@ -783,44 +783,44 @@ func safeexpr(n ir.Node, init *ir.Nodes) ir.Node {
 
 	case ir.OLEN, ir.OCAP:
 		n := n.(*ir.UnaryExpr)
-		l := safeexpr(n.Left(), init)
-		if l == n.Left() {
+		l := safeexpr(n.X, init)
+		if l == n.X {
 			return n
 		}
 		a := ir.Copy(n).(*ir.UnaryExpr)
-		a.SetLeft(l)
+		a.X = l
 		return walkexpr(typecheck(a, ctxExpr), init)
 
 	case ir.ODOT, ir.ODOTPTR:
 		n := n.(*ir.SelectorExpr)
-		l := safeexpr(n.Left(), init)
-		if l == n.Left() {
+		l := safeexpr(n.X, init)
+		if l == n.X {
 			return n
 		}
 		a := ir.Copy(n).(*ir.SelectorExpr)
-		a.SetLeft(l)
+		a.X = l
 		return walkexpr(typecheck(a, ctxExpr), init)
 
 	case ir.ODEREF:
 		n := n.(*ir.StarExpr)
-		l := safeexpr(n.Left(), init)
-		if l == n.Left() {
+		l := safeexpr(n.X, init)
+		if l == n.X {
 			return n
 		}
 		a := ir.Copy(n).(*ir.StarExpr)
-		a.SetLeft(l)
+		a.X = l
 		return walkexpr(typecheck(a, ctxExpr), init)
 
 	case ir.OINDEX, ir.OINDEXMAP:
 		n := n.(*ir.IndexExpr)
-		l := safeexpr(n.Left(), init)
-		r := safeexpr(n.Right(), init)
-		if l == n.Left() && r == n.Right() {
+		l := safeexpr(n.X, init)
+		r := safeexpr(n.Index, init)
+		if l == n.X && r == n.Index {
 			return n
 		}
 		a := ir.Copy(n).(*ir.IndexExpr)
-		a.SetLeft(l)
-		a.SetRight(r)
+		a.X = l
+		a.Index = r
 		return walkexpr(typecheck(a, ctxExpr), init)
 
 	case ir.OSTRUCTLIT, ir.OARRAYLIT, ir.OSLICELIT:
@@ -992,20 +992,20 @@ func dotpath(s *types.Sym, t *types.Type, save **types.Field, ignorecase bool) (
 // will give shortest unique addressing.
 // modify the tree with missing type names.
 func adddot(n *ir.SelectorExpr) *ir.SelectorExpr {
-	n.SetLeft(typecheck(n.Left(), ctxType|ctxExpr))
-	if n.Left().Diag() {
+	n.X = typecheck(n.X, ctxType|ctxExpr)
+	if n.X.Diag() {
 		n.SetDiag(true)
 	}
-	t := n.Left().Type()
+	t := n.X.Type()
 	if t == nil {
 		return n
 	}
 
-	if n.Left().Op() == ir.OTYPE {
+	if n.X.Op() == ir.OTYPE {
 		return n
 	}
 
-	s := n.Sym()
+	s := n.Sel
 	if s == nil {
 		return n
 	}
@@ -1014,14 +1014,14 @@ func adddot(n *ir.SelectorExpr) *ir.SelectorExpr {
 	case path != nil:
 		// rebuild elided dots
 		for c := len(path) - 1; c >= 0; c-- {
-			dot := ir.NewSelectorExpr(base.Pos, ir.ODOT, n.Left(), path[c].field.Sym)
+			dot := ir.NewSelectorExpr(base.Pos, ir.ODOT, n.X, path[c].field.Sym)
 			dot.SetImplicit(true)
 			dot.SetType(path[c].field.Type)
-			n.SetLeft(dot)
+			n.X = dot
 		}
 	case ambig:
 		base.Errorf("ambiguous selector %v", n)
-		n.SetLeft(nil)
+		n.X = nil
 	}
 
 	return n
@@ -1228,10 +1228,10 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	if rcvr.IsPtr() && rcvr.Elem() == methodrcvr {
 		// generating wrapper from *T to T.
 		n := ir.NewIfStmt(base.Pos, nil, nil, nil)
-		n.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OEQ, nthis, nodnil()))
+		n.Cond = ir.NewBinaryExpr(base.Pos, ir.OEQ, nthis, nodnil())
 		call := ir.NewCallExpr(base.Pos, ir.OCALL, syslook("panicwrap"), nil)
-		n.PtrBody().Set1(call)
-		fn.PtrBody().Append(n)
+		n.Body.Set1(call)
+		fn.Body.Append(n)
 	}
 
 	dot := adddot(ir.NewSelectorExpr(base.Pos, ir.OXDOT, nthis, method.Sym))
@@ -1245,29 +1245,29 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	// value for that function.
 	if !instrumenting && rcvr.IsPtr() && methodrcvr.IsPtr() && method.Embedded != 0 && !isifacemethod(method.Type) && !(thearch.LinkArch.Name == "ppc64le" && base.Ctxt.Flag_dynlink) {
 		// generate tail call: adjust pointer receiver and jump to embedded method.
-		left := dot.Left() // skip final .M
+		left := dot.X // skip final .M
 		if !left.Type().IsPtr() {
 			left = nodAddr(left)
 		}
 		as := ir.NewAssignStmt(base.Pos, nthis, convnop(left, rcvr))
-		fn.PtrBody().Append(as)
-		fn.PtrBody().Append(ir.NewBranchStmt(base.Pos, ir.ORETJMP, methodSym(methodrcvr, method.Sym)))
+		fn.Body.Append(as)
+		fn.Body.Append(ir.NewBranchStmt(base.Pos, ir.ORETJMP, methodSym(methodrcvr, method.Sym)))
 	} else {
 		fn.SetWrapper(true) // ignore frame for panic+recover matching
 		call := ir.NewCallExpr(base.Pos, ir.OCALL, dot, nil)
-		call.PtrList().Set(paramNnames(tfn.Type()))
-		call.SetIsDDD(tfn.Type().IsVariadic())
+		call.Args.Set(paramNnames(tfn.Type()))
+		call.IsDDD = tfn.Type().IsVariadic()
 		if method.Type.NumResults() > 0 {
 			ret := ir.NewReturnStmt(base.Pos, nil)
-			ret.PtrList().Set1(call)
-			fn.PtrBody().Append(ret)
+			ret.Results.Set1(call)
+			fn.Body.Append(ret)
 		} else {
-			fn.PtrBody().Append(call)
+			fn.Body.Append(call)
 		}
 	}
 
 	if false && base.Flag.LowerR != 0 {
-		ir.DumpList("genwrapper body", fn.Body())
+		ir.DumpList("genwrapper body", fn.Body)
 	}
 
 	funcbody()
@@ -1277,7 +1277,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 
 	typecheckFunc(fn)
 	Curfn = fn
-	typecheckslice(fn.Body().Slice(), ctxStmt)
+	typecheckslice(fn.Body.Slice(), ctxStmt)
 
 	// Inline calls within (*T).M wrappers. This is safe because we only
 	// generate those wrappers within the same compilation unit as (T).M.
@@ -1422,7 +1422,7 @@ func implements(t, iface *types.Type, m, samename **types.Field, ptr *int) bool
 
 func liststmt(l []ir.Node) ir.Node {
 	n := ir.NewBlockStmt(base.Pos, nil)
-	n.PtrList().Set(l)
+	n.List.Set(l)
 	if len(l) != 0 {
 		n.SetPos(l[0].Pos())
 	}
@@ -1542,8 +1542,8 @@ func itabType(itab ir.Node) ir.Node {
 	typ := ir.NewSelectorExpr(base.Pos, ir.ODOTPTR, itab, nil)
 	typ.SetType(types.NewPtr(types.Types[types.TUINT8]))
 	typ.SetTypecheck(1)
-	typ.SetOffset(int64(Widthptr)) // offset of _type in runtime.itab
-	typ.SetBounded(true)           // guaranteed not to fault
+	typ.Offset = int64(Widthptr) // offset of _type in runtime.itab
+	typ.SetBounded(true)         // guaranteed not to fault
 	return typ
 }
 
diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index 7cd1c16e00..da781e6f45 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -17,7 +17,7 @@ import (
 // typecheckswitch typechecks a switch statement.
 func typecheckswitch(n *ir.SwitchStmt) {
 	typecheckslice(n.Init().Slice(), ctxStmt)
-	if n.Left() != nil && n.Left().Op() == ir.OTYPESW {
+	if n.Tag != nil && n.Tag.Op() == ir.OTYPESW {
 		typecheckTypeSwitch(n)
 	} else {
 		typecheckExprSwitch(n)
@@ -25,26 +25,26 @@ func typecheckswitch(n *ir.SwitchStmt) {
 }
 
 func typecheckTypeSwitch(n *ir.SwitchStmt) {
-	guard := n.Left().(*ir.TypeSwitchGuard)
-	guard.SetRight(typecheck(guard.Right(), ctxExpr))
-	t := guard.Right().Type()
+	guard := n.Tag.(*ir.TypeSwitchGuard)
+	guard.X = typecheck(guard.X, ctxExpr)
+	t := guard.X.Type()
 	if t != nil && !t.IsInterface() {
-		base.ErrorfAt(n.Pos(), "cannot type switch on non-interface value %L", guard.Right())
+		base.ErrorfAt(n.Pos(), "cannot type switch on non-interface value %L", guard.X)
 		t = nil
 	}
 
 	// We don't actually declare the type switch's guarded
 	// declaration itself. So if there are no cases, we won't
 	// notice that it went unused.
-	if v := guard.Left(); v != nil && !ir.IsBlank(v) && n.List().Len() == 0 {
+	if v := guard.Tag; v != nil && !ir.IsBlank(v) && n.Cases.Len() == 0 {
 		base.ErrorfAt(v.Pos(), "%v declared but not used", v.Sym())
 	}
 
 	var defCase, nilCase ir.Node
 	var ts typeSet
-	for _, ncase := range n.List().Slice() {
+	for _, ncase := range n.Cases.Slice() {
 		ncase := ncase.(*ir.CaseStmt)
-		ls := ncase.List().Slice()
+		ls := ncase.List.Slice()
 		if len(ls) == 0 { // default:
 			if defCase != nil {
 				base.ErrorfAt(ncase.Pos(), "multiple defaults in switch (first at %v)", ir.Line(defCase))
@@ -77,13 +77,13 @@ func typecheckTypeSwitch(n *ir.SwitchStmt) {
 			if !n1.Type().IsInterface() && !implements(n1.Type(), t, &missing, &have, &ptr) && !missing.Broke() {
 				if have != nil && !have.Broke() {
 					base.ErrorfAt(ncase.Pos(), "impossible type switch case: %L cannot have dynamic type %v"+
-						" (wrong type for %v method)\n\thave %v%S\n\twant %v%S", guard.Right(), n1.Type(), missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
+						" (wrong type for %v method)\n\thave %v%S\n\twant %v%S", guard.X, n1.Type(), missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
 				} else if ptr != 0 {
 					base.ErrorfAt(ncase.Pos(), "impossible type switch case: %L cannot have dynamic type %v"+
-						" (%v method has pointer receiver)", guard.Right(), n1.Type(), missing.Sym)
+						" (%v method has pointer receiver)", guard.X, n1.Type(), missing.Sym)
 				} else {
 					base.ErrorfAt(ncase.Pos(), "impossible type switch case: %L cannot have dynamic type %v"+
-						" (missing %v method)", guard.Right(), n1.Type(), missing.Sym)
+						" (missing %v method)", guard.X, n1.Type(), missing.Sym)
 				}
 				continue
 			}
@@ -91,7 +91,7 @@ func typecheckTypeSwitch(n *ir.SwitchStmt) {
 			ts.add(ncase.Pos(), n1.Type())
 		}
 
-		if ncase.Rlist().Len() != 0 {
+		if ncase.Vars.Len() != 0 {
 			// Assign the clause variable's type.
 			vt := t
 			if len(ls) == 1 {
@@ -104,7 +104,7 @@ func typecheckTypeSwitch(n *ir.SwitchStmt) {
 				}
 			}
 
-			nvar := ncase.Rlist().First()
+			nvar := ncase.Vars.First()
 			nvar.SetType(vt)
 			if vt != nil {
 				nvar = typecheck(nvar, ctxExpr|ctxAssign)
@@ -113,10 +113,10 @@ func typecheckTypeSwitch(n *ir.SwitchStmt) {
 				nvar.SetTypecheck(1)
 				nvar.SetWalkdef(1)
 			}
-			ncase.Rlist().SetFirst(nvar)
+			ncase.Vars.SetFirst(nvar)
 		}
 
-		typecheckslice(ncase.Body().Slice(), ctxStmt)
+		typecheckslice(ncase.Body.Slice(), ctxStmt)
 	}
 }
 
@@ -150,10 +150,10 @@ func (s *typeSet) add(pos src.XPos, typ *types.Type) {
 
 func typecheckExprSwitch(n *ir.SwitchStmt) {
 	t := types.Types[types.TBOOL]
-	if n.Left() != nil {
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
-		n.SetLeft(defaultlit(n.Left(), nil))
-		t = n.Left().Type()
+	if n.Tag != nil {
+		n.Tag = typecheck(n.Tag, ctxExpr)
+		n.Tag = defaultlit(n.Tag, nil)
+		t = n.Tag.Type()
 	}
 
 	var nilonly string
@@ -168,9 +168,9 @@ func typecheckExprSwitch(n *ir.SwitchStmt) {
 
 		case !IsComparable(t):
 			if t.IsStruct() {
-				base.ErrorfAt(n.Pos(), "cannot switch on %L (struct containing %v cannot be compared)", n.Left(), IncomparableField(t).Type)
+				base.ErrorfAt(n.Pos(), "cannot switch on %L (struct containing %v cannot be compared)", n.Tag, IncomparableField(t).Type)
 			} else {
-				base.ErrorfAt(n.Pos(), "cannot switch on %L", n.Left())
+				base.ErrorfAt(n.Pos(), "cannot switch on %L", n.Tag)
 			}
 			t = nil
 		}
@@ -178,9 +178,9 @@ func typecheckExprSwitch(n *ir.SwitchStmt) {
 
 	var defCase ir.Node
 	var cs constSet
-	for _, ncase := range n.List().Slice() {
+	for _, ncase := range n.Cases.Slice() {
 		ncase := ncase.(*ir.CaseStmt)
-		ls := ncase.List().Slice()
+		ls := ncase.List.Slice()
 		if len(ls) == 0 { // default:
 			if defCase != nil {
 				base.ErrorfAt(ncase.Pos(), "multiple defaults in switch (first at %v)", ir.Line(defCase))
@@ -199,15 +199,15 @@ func typecheckExprSwitch(n *ir.SwitchStmt) {
 			}
 
 			if nilonly != "" && !ir.IsNil(n1) {
-				base.ErrorfAt(ncase.Pos(), "invalid case %v in switch (can only compare %s %v to nil)", n1, nilonly, n.Left())
+				base.ErrorfAt(ncase.Pos(), "invalid case %v in switch (can only compare %s %v to nil)", n1, nilonly, n.Tag)
 			} else if t.IsInterface() && !n1.Type().IsInterface() && !IsComparable(n1.Type()) {
 				base.ErrorfAt(ncase.Pos(), "invalid case %L in switch (incomparable type)", n1)
 			} else {
 				op1, _ := assignop(n1.Type(), t)
 				op2, _ := assignop(t, n1.Type())
 				if op1 == ir.OXXX && op2 == ir.OXXX {
-					if n.Left() != nil {
-						base.ErrorfAt(ncase.Pos(), "invalid case %v in switch on %v (mismatched types %v and %v)", n1, n.Left(), n1.Type(), t)
+					if n.Tag != nil {
+						base.ErrorfAt(ncase.Pos(), "invalid case %v in switch on %v (mismatched types %v and %v)", n1, n.Tag, n1.Type(), t)
 					} else {
 						base.ErrorfAt(ncase.Pos(), "invalid case %v in switch (mismatched types %v and bool)", n1, n1.Type())
 					}
@@ -225,18 +225,18 @@ func typecheckExprSwitch(n *ir.SwitchStmt) {
 			}
 		}
 
-		typecheckslice(ncase.Body().Slice(), ctxStmt)
+		typecheckslice(ncase.Body.Slice(), ctxStmt)
 	}
 }
 
 // walkswitch walks a switch statement.
 func walkswitch(sw *ir.SwitchStmt) {
 	// Guard against double walk, see #25776.
-	if sw.List().Len() == 0 && sw.Body().Len() > 0 {
+	if sw.Cases.Len() == 0 && sw.Compiled.Len() > 0 {
 		return // Was fatal, but eliminating every possible source of double-walking is hard
 	}
 
-	if sw.Left() != nil && sw.Left().Op() == ir.OTYPESW {
+	if sw.Tag != nil && sw.Tag.Op() == ir.OTYPESW {
 		walkTypeSwitch(sw)
 	} else {
 		walkExprSwitch(sw)
@@ -248,8 +248,8 @@ func walkswitch(sw *ir.SwitchStmt) {
 func walkExprSwitch(sw *ir.SwitchStmt) {
 	lno := setlineno(sw)
 
-	cond := sw.Left()
-	sw.SetLeft(nil)
+	cond := sw.Tag
+	sw.Tag = nil
 
 	// convert switch {...} to switch true {...}
 	if cond == nil {
@@ -272,7 +272,7 @@ func walkExprSwitch(sw *ir.SwitchStmt) {
 
 	cond = walkexpr(cond, sw.PtrInit())
 	if cond.Op() != ir.OLITERAL && cond.Op() != ir.ONIL {
-		cond = copyexpr(cond, cond.Type(), sw.PtrBody())
+		cond = copyexpr(cond, cond.Type(), &sw.Compiled)
 	}
 
 	base.Pos = lno
@@ -283,33 +283,33 @@ func walkExprSwitch(sw *ir.SwitchStmt) {
 
 	var defaultGoto ir.Node
 	var body ir.Nodes
-	for _, ncase := range sw.List().Slice() {
+	for _, ncase := range sw.Cases.Slice() {
 		ncase := ncase.(*ir.CaseStmt)
 		label := autolabel(".s")
 		jmp := ir.NewBranchStmt(ncase.Pos(), ir.OGOTO, label)
 
 		// Process case dispatch.
-		if ncase.List().Len() == 0 {
+		if ncase.List.Len() == 0 {
 			if defaultGoto != nil {
 				base.Fatalf("duplicate default case not detected during typechecking")
 			}
 			defaultGoto = jmp
 		}
 
-		for _, n1 := range ncase.List().Slice() {
+		for _, n1 := range ncase.List.Slice() {
 			s.Add(ncase.Pos(), n1, jmp)
 		}
 
 		// Process body.
 		body.Append(ir.NewLabelStmt(ncase.Pos(), label))
-		body.Append(ncase.Body().Slice()...)
-		if fall, pos := endsInFallthrough(ncase.Body().Slice()); !fall {
+		body.Append(ncase.Body.Slice()...)
+		if fall, pos := endsInFallthrough(ncase.Body.Slice()); !fall {
 			br := ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)
 			br.SetPos(pos)
 			body.Append(br)
 		}
 	}
-	sw.PtrList().Set(nil)
+	sw.Cases.Set(nil)
 
 	if defaultGoto == nil {
 		br := ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)
@@ -317,10 +317,10 @@ func walkExprSwitch(sw *ir.SwitchStmt) {
 		defaultGoto = br
 	}
 
-	s.Emit(sw.PtrBody())
-	sw.PtrBody().Append(defaultGoto)
-	sw.PtrBody().AppendNodes(&body)
-	walkstmtlist(sw.Body().Slice())
+	s.Emit(&sw.Compiled)
+	sw.Compiled.Append(defaultGoto)
+	sw.Compiled.AppendNodes(&body)
+	walkstmtlist(sw.Compiled.Slice())
 }
 
 // An exprSwitch walks an expression switch.
@@ -402,8 +402,8 @@ func (s *exprSwitch) flush() {
 			},
 			func(i int, nif *ir.IfStmt) {
 				run := runs[i]
-				nif.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OEQ, ir.NewUnaryExpr(base.Pos, ir.OLEN, s.exprname), nodintconst(runLen(run))))
-				s.search(run, nif.PtrBody())
+				nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OEQ, ir.NewUnaryExpr(base.Pos, ir.OLEN, s.exprname), nodintconst(runLen(run)))
+				s.search(run, &nif.Body)
 			},
 		)
 		return
@@ -437,8 +437,8 @@ func (s *exprSwitch) search(cc []exprClause, out *ir.Nodes) {
 		},
 		func(i int, nif *ir.IfStmt) {
 			c := &cc[i]
-			nif.SetLeft(c.test(s.exprname))
-			nif.PtrBody().Set1(c.jmp)
+			nif.Cond = c.test(s.exprname)
+			nif.Body.Set1(c.jmp)
 		},
 	)
 }
@@ -471,9 +471,9 @@ func allCaseExprsAreSideEffectFree(sw *ir.SwitchStmt) bool {
 	// Restricting to constants is simple and probably powerful
 	// enough.
 
-	for _, ncase := range sw.List().Slice() {
+	for _, ncase := range sw.Cases.Slice() {
 		ncase := ncase.(*ir.CaseStmt)
-		for _, v := range ncase.List().Slice() {
+		for _, v := range ncase.List.Slice() {
 			if v.Op() != ir.OLITERAL {
 				return false
 			}
@@ -504,11 +504,11 @@ func endsInFallthrough(stmts []ir.Node) (bool, src.XPos) {
 // type switch.
 func walkTypeSwitch(sw *ir.SwitchStmt) {
 	var s typeSwitch
-	s.facename = sw.Left().(*ir.TypeSwitchGuard).Right()
-	sw.SetLeft(nil)
+	s.facename = sw.Tag.(*ir.TypeSwitchGuard).X
+	sw.Tag = nil
 
 	s.facename = walkexpr(s.facename, sw.PtrInit())
-	s.facename = copyexpr(s.facename, s.facename.Type(), sw.PtrBody())
+	s.facename = copyexpr(s.facename, s.facename.Type(), &sw.Compiled)
 	s.okname = temp(types.Types[types.TBOOL])
 
 	// Get interface descriptor word.
@@ -523,55 +523,55 @@ func walkTypeSwitch(sw *ir.SwitchStmt) {
 	//     h := e._type.hash
 	// Use a similar strategy for non-empty interfaces.
 	ifNil := ir.NewIfStmt(base.Pos, nil, nil, nil)
-	ifNil.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OEQ, itab, nodnil()))
+	ifNil.Cond = ir.NewBinaryExpr(base.Pos, ir.OEQ, itab, nodnil())
 	base.Pos = base.Pos.WithNotStmt() // disable statement marks after the first check.
-	ifNil.SetLeft(typecheck(ifNil.Left(), ctxExpr))
-	ifNil.SetLeft(defaultlit(ifNil.Left(), nil))
+	ifNil.Cond = typecheck(ifNil.Cond, ctxExpr)
+	ifNil.Cond = defaultlit(ifNil.Cond, nil)
 	// ifNil.Nbody assigned at end.
-	sw.PtrBody().Append(ifNil)
+	sw.Compiled.Append(ifNil)
 
 	// Load hash from type or itab.
 	dotHash := ir.NewSelectorExpr(base.Pos, ir.ODOTPTR, itab, nil)
 	dotHash.SetType(types.Types[types.TUINT32])
 	dotHash.SetTypecheck(1)
 	if s.facename.Type().IsEmptyInterface() {
-		dotHash.SetOffset(int64(2 * Widthptr)) // offset of hash in runtime._type
+		dotHash.Offset = int64(2 * Widthptr) // offset of hash in runtime._type
 	} else {
-		dotHash.SetOffset(int64(2 * Widthptr)) // offset of hash in runtime.itab
+		dotHash.Offset = int64(2 * Widthptr) // offset of hash in runtime.itab
 	}
 	dotHash.SetBounded(true) // guaranteed not to fault
-	s.hashname = copyexpr(dotHash, dotHash.Type(), sw.PtrBody())
+	s.hashname = copyexpr(dotHash, dotHash.Type(), &sw.Compiled)
 
 	br := ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)
 	var defaultGoto, nilGoto ir.Node
 	var body ir.Nodes
-	for _, ncase := range sw.List().Slice() {
+	for _, ncase := range sw.Cases.Slice() {
 		ncase := ncase.(*ir.CaseStmt)
 		var caseVar ir.Node
-		if ncase.Rlist().Len() != 0 {
-			caseVar = ncase.Rlist().First()
+		if ncase.Vars.Len() != 0 {
+			caseVar = ncase.Vars.First()
 		}
 
 		// For single-type cases with an interface type,
 		// we initialize the case variable as part of the type assertion.
 		// In other cases, we initialize it in the body.
 		var singleType *types.Type
-		if ncase.List().Len() == 1 && ncase.List().First().Op() == ir.OTYPE {
-			singleType = ncase.List().First().Type()
+		if ncase.List.Len() == 1 && ncase.List.First().Op() == ir.OTYPE {
+			singleType = ncase.List.First().Type()
 		}
 		caseVarInitialized := false
 
 		label := autolabel(".s")
 		jmp := ir.NewBranchStmt(ncase.Pos(), ir.OGOTO, label)
 
-		if ncase.List().Len() == 0 { // default:
+		if ncase.List.Len() == 0 { // default:
 			if defaultGoto != nil {
 				base.Fatalf("duplicate default case not detected during typechecking")
 			}
 			defaultGoto = jmp
 		}
 
-		for _, n1 := range ncase.List().Slice() {
+		for _, n1 := range ncase.List.Slice() {
 			if ir.IsNil(n1) { // case nil:
 				if nilGoto != nil {
 					base.Fatalf("duplicate nil case not detected during typechecking")
@@ -605,10 +605,10 @@ func walkTypeSwitch(sw *ir.SwitchStmt) {
 			typecheckslice(l, ctxStmt)
 			body.Append(l...)
 		}
-		body.Append(ncase.Body().Slice()...)
+		body.Append(ncase.Body.Slice()...)
 		body.Append(br)
 	}
-	sw.PtrList().Set(nil)
+	sw.Cases.Set(nil)
 
 	if defaultGoto == nil {
 		defaultGoto = br
@@ -616,13 +616,13 @@ func walkTypeSwitch(sw *ir.SwitchStmt) {
 	if nilGoto == nil {
 		nilGoto = defaultGoto
 	}
-	ifNil.PtrBody().Set1(nilGoto)
+	ifNil.Body.Set1(nilGoto)
 
-	s.Emit(sw.PtrBody())
-	sw.PtrBody().Append(defaultGoto)
-	sw.PtrBody().AppendNodes(&body)
+	s.Emit(&sw.Compiled)
+	sw.Compiled.Append(defaultGoto)
+	sw.Compiled.AppendNodes(&body)
 
-	walkstmtlist(sw.Body().Slice())
+	walkstmtlist(sw.Compiled.Slice())
 }
 
 // A typeSwitch walks a type switch.
@@ -656,16 +656,16 @@ func (s *typeSwitch) Add(pos src.XPos, typ *types.Type, caseVar, jmp ir.Node) {
 
 	// cv, ok = iface.(type)
 	as := ir.NewAssignListStmt(pos, ir.OAS2, nil, nil)
-	as.PtrList().Set2(caseVar, s.okname) // cv, ok =
+	as.Lhs.Set2(caseVar, s.okname) // cv, ok =
 	dot := ir.NewTypeAssertExpr(pos, s.facename, nil)
 	dot.SetType(typ) // iface.(type)
-	as.PtrRlist().Set1(dot)
+	as.Rhs.Set1(dot)
 	appendWalkStmt(&body, as)
 
 	// if ok { goto label }
 	nif := ir.NewIfStmt(pos, nil, nil, nil)
-	nif.SetLeft(s.okname)
-	nif.PtrBody().Set1(jmp)
+	nif.Cond = s.okname
+	nif.Body.Set1(jmp)
 	body.Append(nif)
 
 	if !typ.IsInterface() {
@@ -714,8 +714,8 @@ func (s *typeSwitch) flush() {
 			// TODO(mdempsky): Omit hash equality check if
 			// there's only one type.
 			c := cc[i]
-			nif.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OEQ, s.hashname, nodintconst(int64(c.hash))))
-			nif.PtrBody().AppendNodes(&c.body)
+			nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OEQ, s.hashname, nodintconst(int64(c.hash)))
+			nif.Body.AppendNodes(&c.body)
 		},
 	)
 }
@@ -740,22 +740,22 @@ func binarySearch(n int, out *ir.Nodes, less func(i int) ir.Node, leaf func(i in
 				nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
 				leaf(i, nif)
 				base.Pos = base.Pos.WithNotStmt()
-				nif.SetLeft(typecheck(nif.Left(), ctxExpr))
-				nif.SetLeft(defaultlit(nif.Left(), nil))
+				nif.Cond = typecheck(nif.Cond, ctxExpr)
+				nif.Cond = defaultlit(nif.Cond, nil)
 				out.Append(nif)
-				out = nif.PtrRlist()
+				out = &nif.Else
 			}
 			return
 		}
 
 		half := lo + n/2
 		nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
-		nif.SetLeft(less(half))
+		nif.Cond = less(half)
 		base.Pos = base.Pos.WithNotStmt()
-		nif.SetLeft(typecheck(nif.Left(), ctxExpr))
-		nif.SetLeft(defaultlit(nif.Left(), nil))
-		do(lo, half, nif.PtrBody())
-		do(half, hi, nif.PtrRlist())
+		nif.Cond = typecheck(nif.Cond, ctxExpr)
+		nif.Cond = defaultlit(nif.Cond, nil)
+		do(lo, half, &nif.Body)
+		do(half, hi, &nif.Else)
 		out.Append(nif)
 	}
 
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index bb5e9fad1e..73fb6bb1c1 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -48,7 +48,7 @@ func TypecheckPackage() {
 	timings.Start("fe", "typecheck", "top1")
 	for i := 0; i < len(Target.Decls); i++ {
 		n := Target.Decls[i]
-		if op := n.Op(); op != ir.ODCL && op != ir.OAS && op != ir.OAS2 && (op != ir.ODCLTYPE || !n.(*ir.Decl).Left().Name().Alias()) {
+		if op := n.Op(); op != ir.ODCL && op != ir.OAS && op != ir.OAS2 && (op != ir.ODCLTYPE || !n.(*ir.Decl).X.Name().Alias()) {
 			Target.Decls[i] = typecheck(n, ctxStmt)
 		}
 	}
@@ -60,7 +60,7 @@ func TypecheckPackage() {
 	timings.Start("fe", "typecheck", "top2")
 	for i := 0; i < len(Target.Decls); i++ {
 		n := Target.Decls[i]
-		if op := n.Op(); op == ir.ODCL || op == ir.OAS || op == ir.OAS2 || op == ir.ODCLTYPE && n.(*ir.Decl).Left().Name().Alias() {
+		if op := n.Op(); op == ir.ODCL || op == ir.OAS || op == ir.OAS2 || op == ir.ODCLTYPE && n.(*ir.Decl).X.Name().Alias() {
 			Target.Decls[i] = typecheck(n, ctxStmt)
 		}
 	}
@@ -97,7 +97,7 @@ func TypecheckPackage() {
 	for _, n := range Target.Decls {
 		if n.Op() == ir.ODCLFUNC {
 			n := n.(*ir.Func)
-			if n.Func().OClosure != nil {
+			if n.OClosure != nil {
 				Curfn = n
 				capturevars(n)
 			}
@@ -142,10 +142,10 @@ func TypecheckFuncBody(n *ir.Func) {
 	Curfn = n
 	decldepth = 1
 	errorsBefore := base.Errors()
-	typecheckslice(n.Body(), ctxStmt)
+	typecheckslice(n.Body, ctxStmt)
 	checkreturn(n)
 	if base.Errors() > errorsBefore {
-		n.PtrBody().Set(nil) // type errors; do not compile
+		n.Body.Set(nil) // type errors; do not compile
 	}
 	// Now that we've checked whether n terminates,
 	// we can eliminate some obviously dead code.
@@ -387,7 +387,7 @@ func typecheck(n ir.Node, top int) (res ir.Node) {
 
 	// Skip over parens.
 	for n.Op() == ir.OPAREN {
-		n = n.(*ir.ParenExpr).Left()
+		n = n.(*ir.ParenExpr).X
 	}
 
 	// Resolve definition of name and value of iota lazily.
@@ -479,7 +479,7 @@ func typecheck(n ir.Node, top int) (res ir.Node) {
 	switch n.Op() {
 	case ir.OCALLFUNC, ir.OCALLINTER, ir.OCALLMETH:
 		n := n.(*ir.CallExpr)
-		if t := n.Left().Type(); t != nil && t.Kind() == types.TFUNC {
+		if t := n.X.Type(); t != nil && t.Kind() == types.TFUNC {
 			nr := t.NumResults()
 			isMulti = nr > 1
 			if nr == 0 {
@@ -580,7 +580,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 		if n.Op() == ir.ONAME {
 			n := n.(*ir.Name)
-			if n.SubOp() != 0 && top&ctxCallee == 0 {
+			if n.BuiltinOp != 0 && top&ctxCallee == 0 {
 				base.Errorf("use of builtin %v not in function call", n.Sym())
 				n.SetType(nil)
 				return n
@@ -615,7 +615,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		if n.Name().Decldepth == 0 {
 			n.Name().Decldepth = decldepth
 		}
-		if n.SubOp() != 0 {
+		if n.BuiltinOp != 0 {
 			return n
 		}
 		if top&ctxAssign == 0 {
@@ -767,7 +767,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 		if !t.IsPtr() {
 			if top&(ctxExpr|ctxStmt) != 0 {
-				base.Errorf("invalid indirect of %L", n.Left())
+				base.Errorf("invalid indirect of %L", n.X)
 				n.SetType(nil)
 				return n
 			}
@@ -803,14 +803,14 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		var setLR func()
 		switch n := n.(type) {
 		case *ir.AssignOpStmt:
-			l, r = n.Left(), n.Right()
-			setLR = func() { n.SetLeft(l); n.SetRight(r) }
+			l, r = n.X, n.Y
+			setLR = func() { n.X = l; n.Y = r }
 		case *ir.BinaryExpr:
-			l, r = n.Left(), n.Right()
-			setLR = func() { n.SetLeft(l); n.SetRight(r) }
+			l, r = n.X, n.Y
+			setLR = func() { n.X = l; n.Y = r }
 		case *ir.LogicalExpr:
-			l, r = n.Left(), n.Right()
-			setLR = func() { n.SetLeft(l); n.SetRight(r) }
+			l, r = n.X, n.Y
+			setLR = func() { n.X = l; n.Y = r }
 		}
 		l = typecheck(l, ctxExpr)
 		r = typecheck(r, ctxExpr)
@@ -823,13 +823,13 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		if n.Op() == ir.OASOP {
 			n := n.(*ir.AssignOpStmt)
 			checkassign(n, l)
-			if n.Implicit() && !okforarith[l.Type().Kind()] {
+			if n.IncDec && !okforarith[l.Type().Kind()] {
 				base.Errorf("invalid operation: %v (non-numeric type %v)", n, l.Type())
 				n.SetType(nil)
 				return n
 			}
 			// TODO(marvin): Fix Node.EType type union.
-			op = n.SubOp()
+			op = n.AsOp
 		}
 		if op == ir.OLSH || op == ir.ORSH {
 			r = defaultlit(r, types.Types[types.TUINT])
@@ -866,13 +866,13 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		// can't be converted to int (see issue #41500).
 		if n.Op() == ir.OANDAND || n.Op() == ir.OOROR {
 			n := n.(*ir.LogicalExpr)
-			if !n.Left().Type().IsBoolean() {
-				base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op(), typekind(n.Left().Type()))
+			if !n.X.Type().IsBoolean() {
+				base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op(), typekind(n.X.Type()))
 				n.SetType(nil)
 				return n
 			}
-			if !n.Right().Type().IsBoolean() {
-				base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op(), typekind(n.Right().Type()))
+			if !n.Y.Type().IsBoolean() {
+				base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op(), typekind(n.Y.Type()))
 				n.SetType(nil)
 				return n
 			}
@@ -1027,9 +1027,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			}
 			if r.Op() == ir.OADDSTR {
 				r := r.(*ir.AddStringExpr)
-				add.PtrList().AppendNodes(r.PtrList())
+				add.List.AppendNodes(&r.List)
 			} else {
-				add.PtrList().Append(r)
+				add.List.Append(r)
 			}
 			add.SetType(t)
 			return add
@@ -1048,8 +1048,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OBITNOT, ir.ONEG, ir.ONOT, ir.OPLUS:
 		n := n.(*ir.UnaryExpr)
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
-		l := n.Left()
+		n.X = typecheck(n.X, ctxExpr)
+		l := n.X
 		t := l.Type()
 		if t == nil {
 			n.SetType(nil)
@@ -1067,19 +1067,19 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 	// exprs
 	case ir.OADDR:
 		n := n.(*ir.AddrExpr)
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
-		if n.Left().Type() == nil {
+		n.X = typecheck(n.X, ctxExpr)
+		if n.X.Type() == nil {
 			n.SetType(nil)
 			return n
 		}
 
-		switch n.Left().Op() {
+		switch n.X.Op() {
 		case ir.OARRAYLIT, ir.OMAPLIT, ir.OSLICELIT, ir.OSTRUCTLIT:
 			n.SetOp(ir.OPTRLIT)
 
 		default:
-			checklvalue(n.Left(), "take the address of")
-			r := outervalue(n.Left())
+			checklvalue(n.X, "take the address of")
+			r := outervalue(n.X)
 			if r.Op() == ir.ONAME {
 				r := r.(*ir.Name)
 				if ir.Orig(r) != r {
@@ -1094,14 +1094,14 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 					r.Name().Defn.Name().SetAddrtaken(true)
 				}
 			}
-			n.SetLeft(defaultlit(n.Left(), nil))
-			if n.Left().Type() == nil {
+			n.X = defaultlit(n.X, nil)
+			if n.X.Type() == nil {
 				n.SetType(nil)
 				return n
 			}
 		}
 
-		n.SetType(types.NewPtr(n.Left().Type()))
+		n.SetType(types.NewPtr(n.X.Type()))
 		return n
 
 	case ir.OCOMPLIT:
@@ -1112,26 +1112,26 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		if n.Op() == ir.OXDOT {
 			n = adddot(n)
 			n.SetOp(ir.ODOT)
-			if n.Left() == nil {
+			if n.X == nil {
 				n.SetType(nil)
 				return n
 			}
 		}
 
-		n.SetLeft(typecheck(n.Left(), ctxExpr|ctxType))
+		n.X = typecheck(n.X, ctxExpr|ctxType)
 
-		n.SetLeft(defaultlit(n.Left(), nil))
+		n.X = defaultlit(n.X, nil)
 
-		t := n.Left().Type()
+		t := n.X.Type()
 		if t == nil {
-			base.UpdateErrorDot(ir.Line(n), fmt.Sprint(n.Left()), fmt.Sprint(n))
+			base.UpdateErrorDot(ir.Line(n), fmt.Sprint(n.X), fmt.Sprint(n))
 			n.SetType(nil)
 			return n
 		}
 
-		s := n.Sym()
+		s := n.Sel
 
-		if n.Left().Op() == ir.OTYPE {
+		if n.X.Op() == ir.OTYPE {
 			return typecheckMethodExpr(n)
 		}
 
@@ -1145,7 +1145,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			checkwidth(t)
 		}
 
-		if n.Sym().IsBlank() {
+		if n.Sel.IsBlank() {
 			base.Errorf("cannot refer to blank field or method")
 			n.SetType(nil)
 			return n
@@ -1155,21 +1155,21 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			// Legitimate field or method lookup failed, try to explain the error
 			switch {
 			case t.IsEmptyInterface():
-				base.Errorf("%v undefined (type %v is interface with no methods)", n, n.Left().Type())
+				base.Errorf("%v undefined (type %v is interface with no methods)", n, n.X.Type())
 
 			case t.IsPtr() && t.Elem().IsInterface():
 				// Pointer to interface is almost always a mistake.
-				base.Errorf("%v undefined (type %v is pointer to interface, not interface)", n, n.Left().Type())
+				base.Errorf("%v undefined (type %v is pointer to interface, not interface)", n, n.X.Type())
 
 			case lookdot(n, t, 1) != nil:
 				// Field or method matches by name, but it is not exported.
-				base.Errorf("%v undefined (cannot refer to unexported field or method %v)", n, n.Sym())
+				base.Errorf("%v undefined (cannot refer to unexported field or method %v)", n, n.Sel)
 
 			default:
 				if mt := lookdot(n, t, 2); mt != nil && visible(mt.Sym) { // Case-insensitive lookup.
-					base.Errorf("%v undefined (type %v has no field or method %v, but does have %v)", n, n.Left().Type(), n.Sym(), mt.Sym)
+					base.Errorf("%v undefined (type %v has no field or method %v, but does have %v)", n, n.X.Type(), n.Sel, mt.Sym)
 				} else {
-					base.Errorf("%v undefined (type %v has no field or method %v)", n, n.Left().Type(), n.Sym())
+					base.Errorf("%v undefined (type %v has no field or method %v)", n, n.X.Type(), n.Sel)
 				}
 			}
 			n.SetType(nil)
@@ -1183,9 +1183,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.ODOTTYPE:
 		n := n.(*ir.TypeAssertExpr)
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
-		n.SetLeft(defaultlit(n.Left(), nil))
-		l := n.Left()
+		n.X = typecheck(n.X, ctxExpr)
+		n.X = defaultlit(n.X, nil)
+		l := n.X
 		t := l.Type()
 		if t == nil {
 			n.SetType(nil)
@@ -1197,10 +1197,10 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			return n
 		}
 
-		if n.Right() != nil {
-			n.SetRight(typecheck(n.Right(), ctxType))
-			n.SetType(n.Right().Type())
-			n.SetRight(nil)
+		if n.Ntype != nil {
+			n.Ntype = typecheck(n.Ntype, ctxType)
+			n.SetType(n.Ntype.Type())
+			n.Ntype = nil
 			if n.Type() == nil {
 				return n
 			}
@@ -1229,12 +1229,12 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OINDEX:
 		n := n.(*ir.IndexExpr)
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
-		n.SetLeft(defaultlit(n.Left(), nil))
-		n.SetLeft(implicitstar(n.Left()))
-		l := n.Left()
-		n.SetRight(typecheck(n.Right(), ctxExpr))
-		r := n.Right()
+		n.X = typecheck(n.X, ctxExpr)
+		n.X = defaultlit(n.X, nil)
+		n.X = implicitstar(n.X)
+		l := n.X
+		n.Index = typecheck(n.Index, ctxExpr)
+		r := n.Index
 		t := l.Type()
 		if t == nil || r.Type() == nil {
 			n.SetType(nil)
@@ -1247,7 +1247,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			return n
 
 		case types.TSTRING, types.TARRAY, types.TSLICE:
-			n.SetRight(indexlit(n.Right()))
+			n.Index = indexlit(n.Index)
 			if t.IsString() {
 				n.SetType(types.ByteType)
 			} else {
@@ -1260,37 +1260,37 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				why = "slice"
 			}
 
-			if n.Right().Type() != nil && !n.Right().Type().IsInteger() {
-				base.Errorf("non-integer %s index %v", why, n.Right())
+			if n.Index.Type() != nil && !n.Index.Type().IsInteger() {
+				base.Errorf("non-integer %s index %v", why, n.Index)
 				return n
 			}
 
-			if !n.Bounded() && ir.IsConst(n.Right(), constant.Int) {
-				x := n.Right().Val()
+			if !n.Bounded() && ir.IsConst(n.Index, constant.Int) {
+				x := n.Index.Val()
 				if constant.Sign(x) < 0 {
-					base.Errorf("invalid %s index %v (index must be non-negative)", why, n.Right())
+					base.Errorf("invalid %s index %v (index must be non-negative)", why, n.Index)
 				} else if t.IsArray() && constant.Compare(x, token.GEQ, constant.MakeInt64(t.NumElem())) {
-					base.Errorf("invalid array index %v (out of bounds for %d-element array)", n.Right(), t.NumElem())
-				} else if ir.IsConst(n.Left(), constant.String) && constant.Compare(x, token.GEQ, constant.MakeInt64(int64(len(ir.StringVal(n.Left()))))) {
-					base.Errorf("invalid string index %v (out of bounds for %d-byte string)", n.Right(), len(ir.StringVal(n.Left())))
+					base.Errorf("invalid array index %v (out of bounds for %d-element array)", n.Index, t.NumElem())
+				} else if ir.IsConst(n.X, constant.String) && constant.Compare(x, token.GEQ, constant.MakeInt64(int64(len(ir.StringVal(n.X))))) {
+					base.Errorf("invalid string index %v (out of bounds for %d-byte string)", n.Index, len(ir.StringVal(n.X)))
 				} else if doesoverflow(x, types.Types[types.TINT]) {
-					base.Errorf("invalid %s index %v (index too large)", why, n.Right())
+					base.Errorf("invalid %s index %v (index too large)", why, n.Index)
 				}
 			}
 
 		case types.TMAP:
-			n.SetRight(assignconv(n.Right(), t.Key(), "map index"))
+			n.Index = assignconv(n.Index, t.Key(), "map index")
 			n.SetType(t.Elem())
 			n.SetOp(ir.OINDEXMAP)
-			n.SetIndexMapLValue(false)
+			n.Assigned = false
 		}
 		return n
 
 	case ir.ORECV:
 		n := n.(*ir.UnaryExpr)
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
-		n.SetLeft(defaultlit(n.Left(), nil))
-		l := n.Left()
+		n.X = typecheck(n.X, ctxExpr)
+		n.X = defaultlit(n.X, nil)
+		l := n.X
 		t := l.Type()
 		if t == nil {
 			n.SetType(nil)
@@ -1313,10 +1313,10 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OSEND:
 		n := n.(*ir.SendStmt)
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
-		n.SetRight(typecheck(n.Right(), ctxExpr))
-		n.SetLeft(defaultlit(n.Left(), nil))
-		t := n.Left().Type()
+		n.Chan = typecheck(n.Chan, ctxExpr)
+		n.Value = typecheck(n.Value, ctxExpr)
+		n.Chan = defaultlit(n.Chan, nil)
+		t := n.Chan.Type()
 		if t == nil {
 			return n
 		}
@@ -1330,8 +1330,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			return n
 		}
 
-		n.SetRight(assignconv(n.Right(), t.Elem(), "send"))
-		if n.Right().Type() == nil {
+		n.Value = assignconv(n.Value, t.Elem(), "send")
+		if n.Value.Type() == nil {
 			return n
 		}
 		return n
@@ -1351,17 +1351,17 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			base.Fatalf("invalid type %v for OSLICEHEADER", n.Type())
 		}
 
-		if n.Left() == nil || n.Left().Type() == nil || !n.Left().Type().IsUnsafePtr() {
+		if n.Ptr == nil || n.Ptr.Type() == nil || !n.Ptr.Type().IsUnsafePtr() {
 			base.Fatalf("need unsafe.Pointer for OSLICEHEADER")
 		}
 
-		if x := n.List().Len(); x != 2 {
+		if x := n.LenCap.Len(); x != 2 {
 			base.Fatalf("expected 2 params (len, cap) for OSLICEHEADER, got %d", x)
 		}
 
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
-		l := typecheck(n.List().First(), ctxExpr)
-		c := typecheck(n.List().Second(), ctxExpr)
+		n.Ptr = typecheck(n.Ptr, ctxExpr)
+		l := typecheck(n.LenCap.First(), ctxExpr)
+		c := typecheck(n.LenCap.Second(), ctxExpr)
 		l = defaultlit(l, types.Types[types.TINT])
 		c = defaultlit(c, types.Types[types.TINT])
 
@@ -1377,8 +1377,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			base.Fatalf("len larger than cap for OSLICEHEADER")
 		}
 
-		n.List().SetFirst(l)
-		n.List().SetSecond(c)
+		n.LenCap.SetFirst(l)
+		n.LenCap.SetSecond(c)
 		return n
 
 	case ir.OMAKESLICECOPY:
@@ -1397,28 +1397,28 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			base.Fatalf("invalid type %v for OMAKESLICECOPY", n.Type())
 		}
 
-		if n.Left() == nil {
+		if n.Len == nil {
 			base.Fatalf("missing len argument for OMAKESLICECOPY")
 		}
 
-		if n.Right() == nil {
+		if n.Cap == nil {
 			base.Fatalf("missing slice argument to copy for OMAKESLICECOPY")
 		}
 
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
-		n.SetRight(typecheck(n.Right(), ctxExpr))
+		n.Len = typecheck(n.Len, ctxExpr)
+		n.Cap = typecheck(n.Cap, ctxExpr)
 
-		n.SetLeft(defaultlit(n.Left(), types.Types[types.TINT]))
+		n.Len = defaultlit(n.Len, types.Types[types.TINT])
 
-		if !n.Left().Type().IsInteger() && n.Type().Kind() != types.TIDEAL {
+		if !n.Len.Type().IsInteger() && n.Type().Kind() != types.TIDEAL {
 			base.Errorf("non-integer len argument in OMAKESLICECOPY")
 		}
 
-		if ir.IsConst(n.Left(), constant.Int) {
-			if doesoverflow(n.Left().Val(), types.Types[types.TINT]) {
+		if ir.IsConst(n.Len, constant.Int) {
+			if doesoverflow(n.Len.Val(), types.Types[types.TINT]) {
 				base.Fatalf("len for OMAKESLICECOPY too large")
 			}
-			if constant.Sign(n.Left().Val()) < 0 {
+			if constant.Sign(n.Len.Val()) < 0 {
 				base.Fatalf("len for OMAKESLICECOPY must be non-negative")
 			}
 		}
@@ -1426,33 +1426,33 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OSLICE, ir.OSLICE3:
 		n := n.(*ir.SliceExpr)
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		n.X = typecheck(n.X, ctxExpr)
 		low, high, max := n.SliceBounds()
 		hasmax := n.Op().IsSlice3()
 		low = typecheck(low, ctxExpr)
 		high = typecheck(high, ctxExpr)
 		max = typecheck(max, ctxExpr)
-		n.SetLeft(defaultlit(n.Left(), nil))
+		n.X = defaultlit(n.X, nil)
 		low = indexlit(low)
 		high = indexlit(high)
 		max = indexlit(max)
 		n.SetSliceBounds(low, high, max)
-		l := n.Left()
+		l := n.X
 		if l.Type() == nil {
 			n.SetType(nil)
 			return n
 		}
 		if l.Type().IsArray() {
-			if !islvalue(n.Left()) {
+			if !islvalue(n.X) {
 				base.Errorf("invalid operation %v (slice of unaddressable value)", n)
 				n.SetType(nil)
 				return n
 			}
 
-			addr := nodAddr(n.Left())
+			addr := nodAddr(n.X)
 			addr.SetImplicit(true)
-			n.SetLeft(typecheck(addr, ctxExpr))
-			l = n.Left()
+			n.X = typecheck(addr, ctxExpr)
+			l = n.X
 		}
 		t := l.Type()
 		var tp *types.Type
@@ -1507,27 +1507,27 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			n.Use = ir.CallUseStmt
 		}
 		typecheckslice(n.Init().Slice(), ctxStmt) // imported rewritten f(g()) calls (#30907)
-		n.SetLeft(typecheck(n.Left(), ctxExpr|ctxType|ctxCallee))
-		if n.Left().Diag() {
+		n.X = typecheck(n.X, ctxExpr|ctxType|ctxCallee)
+		if n.X.Diag() {
 			n.SetDiag(true)
 		}
 
-		l := n.Left()
+		l := n.X
 
-		if l.Op() == ir.ONAME && l.(*ir.Name).SubOp() != 0 {
+		if l.Op() == ir.ONAME && l.(*ir.Name).BuiltinOp != 0 {
 			l := l.(*ir.Name)
-			if n.IsDDD() && l.SubOp() != ir.OAPPEND {
+			if n.IsDDD && l.BuiltinOp != ir.OAPPEND {
 				base.Errorf("invalid use of ... with builtin %v", l)
 			}
 
 			// builtin: OLEN, OCAP, etc.
-			switch l.SubOp() {
+			switch l.BuiltinOp {
 			default:
 				base.Fatalf("unknown builtin %v", l)
 
 			case ir.OAPPEND, ir.ODELETE, ir.OMAKE, ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
-				n.SetOp(l.SubOp())
-				n.SetLeft(nil)
+				n.SetOp(l.BuiltinOp)
+				n.X = nil
 				n.SetTypecheck(0) // re-typechecking new op is OK, not a loop
 				return typecheck(n, top)
 
@@ -1540,7 +1540,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 					n.SetType(nil)
 					return n
 				}
-				u := ir.NewUnaryExpr(n.Pos(), l.SubOp(), arg)
+				u := ir.NewUnaryExpr(n.Pos(), l.BuiltinOp, arg)
 				return typecheck(initExpr(n.Init().Slice(), u), top) // typecheckargs can add to old.Init
 
 			case ir.OCOMPLEX, ir.OCOPY:
@@ -1550,16 +1550,16 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 					n.SetType(nil)
 					return n
 				}
-				b := ir.NewBinaryExpr(n.Pos(), l.SubOp(), arg1, arg2)
+				b := ir.NewBinaryExpr(n.Pos(), l.BuiltinOp, arg1, arg2)
 				return typecheck(initExpr(n.Init().Slice(), b), top) // typecheckargs can add to old.Init
 			}
 			panic("unreachable")
 		}
 
-		n.SetLeft(defaultlit(n.Left(), nil))
-		l = n.Left()
+		n.X = defaultlit(n.X, nil)
+		l = n.X
 		if l.Op() == ir.OTYPE {
-			if n.IsDDD() {
+			if n.IsDDD {
 				if !l.Type().Broke() {
 					base.Errorf("invalid use of ... in type conversion to %v", l.Type())
 				}
@@ -1600,7 +1600,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			// It isn't necessary, so just do a sanity check.
 			tp := t.Recv().Type
 
-			if l.Left() == nil || !types.Identical(l.Left().Type(), tp) {
+			if l.X == nil || !types.Identical(l.X.Type(), tp) {
 				base.Fatalf("method receiver")
 			}
 
@@ -1622,15 +1622,15 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			}
 		}
 
-		typecheckaste(ir.OCALL, n.Left(), n.IsDDD(), t.Params(), n.List(), func() string { return fmt.Sprintf("argument to %v", n.Left()) })
+		typecheckaste(ir.OCALL, n.X, n.IsDDD, t.Params(), n.Args, func() string { return fmt.Sprintf("argument to %v", n.X) })
 		if t.NumResults() == 0 {
 			return n
 		}
 		if t.NumResults() == 1 {
 			n.SetType(l.Type().Results().Field(0).Type)
 
-			if n.Op() == ir.OCALLFUNC && n.Left().Op() == ir.ONAME {
-				if sym := n.Left().(*ir.Name).Sym(); isRuntimePkg(sym.Pkg) && sym.Name == "getg" {
+			if n.Op() == ir.OCALLFUNC && n.X.Op() == ir.ONAME {
+				if sym := n.X.(*ir.Name).Sym(); isRuntimePkg(sym.Pkg) && sym.Name == "getg" {
 					// Emit code for runtime.getg() directly instead of calling function.
 					// Most such rewrites (for example the similar one for math.Sqrt) should be done in walk,
 					// so that the ordering pass can make sure to preserve the semantics of the original code
@@ -1659,10 +1659,10 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OCAP, ir.OLEN:
 		n := n.(*ir.UnaryExpr)
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
-		n.SetLeft(defaultlit(n.Left(), nil))
-		n.SetLeft(implicitstar(n.Left()))
-		l := n.Left()
+		n.X = typecheck(n.X, ctxExpr)
+		n.X = defaultlit(n.X, nil)
+		n.X = implicitstar(n.X)
+		l := n.X
 		t := l.Type()
 		if t == nil {
 			n.SetType(nil)
@@ -1686,8 +1686,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OREAL, ir.OIMAG:
 		n := n.(*ir.UnaryExpr)
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
-		l := n.Left()
+		n.X = typecheck(n.X, ctxExpr)
+		l := n.X
 		t := l.Type()
 		if t == nil {
 			n.SetType(nil)
@@ -1711,8 +1711,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OCOMPLEX:
 		n := n.(*ir.BinaryExpr)
-		l := typecheck(n.Left(), ctxExpr)
-		r := typecheck(n.Right(), ctxExpr)
+		l := typecheck(n.X, ctxExpr)
+		r := typecheck(n.Y, ctxExpr)
 		if l.Type() == nil || r.Type() == nil {
 			n.SetType(nil)
 			return n
@@ -1722,8 +1722,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			n.SetType(nil)
 			return n
 		}
-		n.SetLeft(l)
-		n.SetRight(r)
+		n.X = l
+		n.Y = r
 
 		if !types.Identical(l.Type(), r.Type()) {
 			base.Errorf("invalid operation: %v (mismatched types %v and %v)", n, l.Type(), r.Type())
@@ -1752,9 +1752,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OCLOSE:
 		n := n.(*ir.UnaryExpr)
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
-		n.SetLeft(defaultlit(n.Left(), nil))
-		l := n.Left()
+		n.X = typecheck(n.X, ctxExpr)
+		n.X = defaultlit(n.X, nil)
+		l := n.X
 		t := l.Type()
 		if t == nil {
 			n.SetType(nil)
@@ -1776,7 +1776,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 	case ir.ODELETE:
 		n := n.(*ir.CallExpr)
 		typecheckargs(n)
-		args := n.List()
+		args := n.Args
 		if args.Len() == 0 {
 			base.Errorf("missing arguments to delete")
 			n.SetType(nil)
@@ -1809,7 +1809,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 	case ir.OAPPEND:
 		n := n.(*ir.CallExpr)
 		typecheckargs(n)
-		args := n.List()
+		args := n.Args
 		if args.Len() == 0 {
 			base.Errorf("missing arguments to append")
 			n.SetType(nil)
@@ -1835,7 +1835,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			return n
 		}
 
-		if n.IsDDD() {
+		if n.IsDDD {
 			if args.Len() == 1 {
 				base.Errorf("cannot use ... on first argument to append")
 				n.SetType(nil)
@@ -1870,39 +1870,39 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 	case ir.OCOPY:
 		n := n.(*ir.BinaryExpr)
 		n.SetType(types.Types[types.TINT])
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
-		n.SetLeft(defaultlit(n.Left(), nil))
-		n.SetRight(typecheck(n.Right(), ctxExpr))
-		n.SetRight(defaultlit(n.Right(), nil))
-		if n.Left().Type() == nil || n.Right().Type() == nil {
+		n.X = typecheck(n.X, ctxExpr)
+		n.X = defaultlit(n.X, nil)
+		n.Y = typecheck(n.Y, ctxExpr)
+		n.Y = defaultlit(n.Y, nil)
+		if n.X.Type() == nil || n.Y.Type() == nil {
 			n.SetType(nil)
 			return n
 		}
 
 		// copy([]byte, string)
-		if n.Left().Type().IsSlice() && n.Right().Type().IsString() {
-			if types.Identical(n.Left().Type().Elem(), types.ByteType) {
+		if n.X.Type().IsSlice() && n.Y.Type().IsString() {
+			if types.Identical(n.X.Type().Elem(), types.ByteType) {
 				return n
 			}
-			base.Errorf("arguments to copy have different element types: %L and string", n.Left().Type())
+			base.Errorf("arguments to copy have different element types: %L and string", n.X.Type())
 			n.SetType(nil)
 			return n
 		}
 
-		if !n.Left().Type().IsSlice() || !n.Right().Type().IsSlice() {
-			if !n.Left().Type().IsSlice() && !n.Right().Type().IsSlice() {
-				base.Errorf("arguments to copy must be slices; have %L, %L", n.Left().Type(), n.Right().Type())
-			} else if !n.Left().Type().IsSlice() {
-				base.Errorf("first argument to copy should be slice; have %L", n.Left().Type())
+		if !n.X.Type().IsSlice() || !n.Y.Type().IsSlice() {
+			if !n.X.Type().IsSlice() && !n.Y.Type().IsSlice() {
+				base.Errorf("arguments to copy must be slices; have %L, %L", n.X.Type(), n.Y.Type())
+			} else if !n.X.Type().IsSlice() {
+				base.Errorf("first argument to copy should be slice; have %L", n.X.Type())
 			} else {
-				base.Errorf("second argument to copy should be slice or string; have %L", n.Right().Type())
+				base.Errorf("second argument to copy should be slice or string; have %L", n.Y.Type())
 			}
 			n.SetType(nil)
 			return n
 		}
 
-		if !types.Identical(n.Left().Type().Elem(), n.Right().Type().Elem()) {
-			base.Errorf("arguments to copy have different element types: %L and %L", n.Left().Type(), n.Right().Type())
+		if !types.Identical(n.X.Type().Elem(), n.Y.Type().Elem()) {
+			base.Errorf("arguments to copy have different element types: %L and %L", n.X.Type(), n.Y.Type())
 			n.SetType(nil)
 			return n
 		}
@@ -1911,17 +1911,17 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 	case ir.OCONV:
 		n := n.(*ir.ConvExpr)
 		checkwidth(n.Type()) // ensure width is calculated for backend
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
-		n.SetLeft(convlit1(n.Left(), n.Type(), true, nil))
-		t := n.Left().Type()
+		n.X = typecheck(n.X, ctxExpr)
+		n.X = convlit1(n.X, n.Type(), true, nil)
+		t := n.X.Type()
 		if t == nil || n.Type() == nil {
 			n.SetType(nil)
 			return n
 		}
-		op, why := convertop(n.Left().Op() == ir.OLITERAL, t, n.Type())
+		op, why := convertop(n.X.Op() == ir.OLITERAL, t, n.Type())
 		if op == ir.OXXX {
-			if !n.Diag() && !n.Type().Broke() && !n.Left().Diag() {
-				base.Errorf("cannot convert %L to type %v%s", n.Left(), n.Type(), why)
+			if !n.Diag() && !n.Type().Broke() && !n.X.Diag() {
+				base.Errorf("cannot convert %L to type %v%s", n.X, n.Type(), why)
 				n.SetDiag(true)
 			}
 			n.SetOp(ir.OCONV)
@@ -1947,7 +1947,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			// ok
 
 		case ir.OSTR2RUNES:
-			if n.Left().Op() == ir.OLITERAL {
+			if n.X.Op() == ir.OLITERAL {
 				return stringtoruneslit(n)
 			}
 		}
@@ -1955,14 +1955,14 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OMAKE:
 		n := n.(*ir.CallExpr)
-		args := n.List().Slice()
+		args := n.Args.Slice()
 		if len(args) == 0 {
 			base.Errorf("missing argument to make")
 			n.SetType(nil)
 			return n
 		}
 
-		n.PtrList().Set(nil)
+		n.Args.Set(nil)
 		l := args[0]
 		l = typecheck(l, ctxType)
 		t := l.Type()
@@ -2063,26 +2063,26 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.ONEW:
 		n := n.(*ir.UnaryExpr)
-		if n.Left() == nil {
+		if n.X == nil {
 			// Fatalf because the OCALL above checked for us,
 			// so this must be an internally-generated mistake.
 			base.Fatalf("missing argument to new")
 		}
-		l := n.Left()
+		l := n.X
 		l = typecheck(l, ctxType)
 		t := l.Type()
 		if t == nil {
 			n.SetType(nil)
 			return n
 		}
-		n.SetLeft(l)
+		n.X = l
 		n.SetType(types.NewPtr(t))
 		return n
 
 	case ir.OPRINT, ir.OPRINTN:
 		n := n.(*ir.CallExpr)
 		typecheckargs(n)
-		ls := n.List().Slice()
+		ls := n.Args.Slice()
 		for i1, n1 := range ls {
 			// Special case for print: int constant is int64, not int.
 			if ir.IsConst(n1, constant.Int) {
@@ -2095,9 +2095,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OPANIC:
 		n := n.(*ir.UnaryExpr)
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
-		n.SetLeft(defaultlit(n.Left(), types.Types[types.TINTER]))
-		if n.Left().Type() == nil {
+		n.X = typecheck(n.X, ctxExpr)
+		n.X = defaultlit(n.X, types.Types[types.TINTER])
+		if n.X.Type() == nil {
 			n.SetType(nil)
 			return n
 		}
@@ -2105,7 +2105,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.ORECOVER:
 		n := n.(*ir.CallExpr)
-		if n.List().Len() != 0 {
+		if n.Args.Len() != 0 {
 			base.Errorf("too many arguments to recover")
 			n.SetType(nil)
 			return n
@@ -2124,8 +2124,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OITAB:
 		n := n.(*ir.UnaryExpr)
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
-		t := n.Left().Type()
+		n.X = typecheck(n.X, ctxExpr)
+		t := n.X.Type()
 		if t == nil {
 			n.SetType(nil)
 			return n
@@ -2145,8 +2145,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OSPTR:
 		n := n.(*ir.UnaryExpr)
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
-		t := n.Left().Type()
+		n.X = typecheck(n.X, ctxExpr)
+		t := n.X.Type()
 		if t == nil {
 			n.SetType(nil)
 			return n
@@ -2166,13 +2166,13 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OCFUNC:
 		n := n.(*ir.UnaryExpr)
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		n.X = typecheck(n.X, ctxExpr)
 		n.SetType(types.Types[types.TUINTPTR])
 		return n
 
 	case ir.OCONVNOP:
 		n := n.(*ir.ConvExpr)
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		n.X = typecheck(n.X, ctxExpr)
 		return n
 
 	// statements
@@ -2181,8 +2181,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		typecheckas(n)
 
 		// Code that creates temps does not bother to set defn, so do it here.
-		if n.Left().Op() == ir.ONAME && ir.IsAutoTmp(n.Left()) {
-			n.Left().Name().Defn = n
+		if n.X.Op() == ir.ONAME && ir.IsAutoTmp(n.X) {
+			n.X.Name().Defn = n
 		}
 		return n
 
@@ -2201,7 +2201,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OBLOCK:
 		n := n.(*ir.BlockStmt)
-		typecheckslice(n.List().Slice(), ctxStmt)
+		typecheckslice(n.List.Slice(), ctxStmt)
 		return n
 
 	case ir.OLABEL:
@@ -2216,8 +2216,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.ODEFER, ir.OGO:
 		n := n.(*ir.GoDeferStmt)
-		n.SetLeft(typecheck(n.Left(), ctxStmt|ctxExpr))
-		if !n.Left().Diag() {
+		n.Call = typecheck(n.Call, ctxStmt|ctxExpr)
+		if !n.Call.Diag() {
 			checkdefergo(n)
 		}
 		return n
@@ -2226,35 +2226,35 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		n := n.(*ir.ForStmt)
 		typecheckslice(n.Init().Slice(), ctxStmt)
 		decldepth++
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
-		n.SetLeft(defaultlit(n.Left(), nil))
-		if n.Left() != nil {
-			t := n.Left().Type()
+		n.Cond = typecheck(n.Cond, ctxExpr)
+		n.Cond = defaultlit(n.Cond, nil)
+		if n.Cond != nil {
+			t := n.Cond.Type()
 			if t != nil && !t.IsBoolean() {
-				base.Errorf("non-bool %L used as for condition", n.Left())
+				base.Errorf("non-bool %L used as for condition", n.Cond)
 			}
 		}
-		n.SetRight(typecheck(n.Right(), ctxStmt))
+		n.Post = typecheck(n.Post, ctxStmt)
 		if n.Op() == ir.OFORUNTIL {
-			typecheckslice(n.List().Slice(), ctxStmt)
+			typecheckslice(n.Late.Slice(), ctxStmt)
 		}
-		typecheckslice(n.Body().Slice(), ctxStmt)
+		typecheckslice(n.Body.Slice(), ctxStmt)
 		decldepth--
 		return n
 
 	case ir.OIF:
 		n := n.(*ir.IfStmt)
 		typecheckslice(n.Init().Slice(), ctxStmt)
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
-		n.SetLeft(defaultlit(n.Left(), nil))
-		if n.Left() != nil {
-			t := n.Left().Type()
+		n.Cond = typecheck(n.Cond, ctxExpr)
+		n.Cond = defaultlit(n.Cond, nil)
+		if n.Cond != nil {
+			t := n.Cond.Type()
 			if t != nil && !t.IsBoolean() {
-				base.Errorf("non-bool %L used as if condition", n.Left())
+				base.Errorf("non-bool %L used as if condition", n.Cond)
 			}
 		}
-		typecheckslice(n.Body().Slice(), ctxStmt)
-		typecheckslice(n.Rlist().Slice(), ctxStmt)
+		typecheckslice(n.Body.Slice(), ctxStmt)
+		typecheckslice(n.Else.Slice(), ctxStmt)
 		return n
 
 	case ir.ORETURN:
@@ -2266,10 +2266,10 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			return n
 		}
 
-		if hasNamedResults(Curfn) && n.List().Len() == 0 {
+		if hasNamedResults(Curfn) && n.Results.Len() == 0 {
 			return n
 		}
-		typecheckaste(ir.ORETURN, nil, false, Curfn.Type().Results(), n.List(), func() string { return "return argument" })
+		typecheckaste(ir.ORETURN, nil, false, Curfn.Type().Results(), n.Results, func() string { return "return argument" })
 		return n
 
 	case ir.ORETJMP:
@@ -2300,13 +2300,13 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.ODCLCONST:
 		n := n.(*ir.Decl)
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
+		n.X = typecheck(n.X, ctxExpr)
 		return n
 
 	case ir.ODCLTYPE:
 		n := n.(*ir.Decl)
-		n.SetLeft(typecheck(n.Left(), ctxType))
-		checkwidth(n.Left().Type())
+		n.X = typecheck(n.X, ctxType)
+		checkwidth(n.X.Type())
 		return n
 	}
 
@@ -2321,13 +2321,13 @@ func typecheckargs(n ir.Node) {
 	default:
 		base.Fatalf("typecheckargs %+v", n.Op())
 	case *ir.CallExpr:
-		list = n.List().Slice()
-		if n.IsDDD() {
+		list = n.Args.Slice()
+		if n.IsDDD {
 			typecheckslice(list, ctxExpr)
 			return
 		}
 	case *ir.ReturnStmt:
-		list = n.List().Slice()
+		list = n.Results.Slice()
 	}
 	if len(list) != 1 {
 		typecheckslice(list, ctxExpr)
@@ -2348,7 +2348,7 @@ func typecheckargs(n ir.Node) {
 	}
 
 	as := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-	as.PtrRlist().Append(list...)
+	as.Rhs.Append(list...)
 
 	// If we're outside of function context, then this call will
 	// be executed during the generated init function. However,
@@ -2363,7 +2363,7 @@ func typecheckargs(n ir.Node) {
 	for _, f := range t.FieldSlice() {
 		t := temp(f.Type)
 		as.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, t))
-		as.PtrList().Append(t)
+		as.Lhs.Append(t)
 		list = append(list, t)
 	}
 	if static {
@@ -2372,9 +2372,9 @@ func typecheckargs(n ir.Node) {
 
 	switch n := n.(type) {
 	case *ir.CallExpr:
-		n.PtrList().Set(list)
+		n.Args.Set(list)
 	case *ir.ReturnStmt:
-		n.PtrList().Set(list)
+		n.Results.Set(list)
 	}
 
 	n.PtrInit().Append(typecheck(as, ctxStmt))
@@ -2425,7 +2425,7 @@ func checkdefergo(n *ir.GoDeferStmt) {
 		what = "go"
 	}
 
-	switch n.Left().Op() {
+	switch n.Call.Op() {
 	// ok
 	case ir.OCALLINTER,
 		ir.OCALLMETH,
@@ -2451,16 +2451,16 @@ func checkdefergo(n *ir.GoDeferStmt) {
 		ir.ONEW,
 		ir.OREAL,
 		ir.OLITERAL: // conversion or unsafe.Alignof, Offsetof, Sizeof
-		if orig := ir.Orig(n.Left()); orig.Op() == ir.OCONV {
+		if orig := ir.Orig(n.Call); orig.Op() == ir.OCONV {
 			break
 		}
-		base.ErrorfAt(n.Pos(), "%s discards result of %v", what, n.Left())
+		base.ErrorfAt(n.Pos(), "%s discards result of %v", what, n.Call)
 		return
 	}
 
 	// type is broken or missing, most likely a method call on a broken type
 	// we will warn about the broken type elsewhere. no need to emit a potentially confusing error
-	if n.Left().Type() == nil || n.Left().Type().Broke() {
+	if n.Call.Type() == nil || n.Call.Type().Broke() {
 		return
 	}
 
@@ -2493,31 +2493,31 @@ func implicitstar(n ir.Node) ir.Node {
 }
 
 func needOneArg(n *ir.CallExpr, f string, args ...interface{}) (ir.Node, bool) {
-	if n.List().Len() == 0 {
+	if n.Args.Len() == 0 {
 		p := fmt.Sprintf(f, args...)
 		base.Errorf("missing argument to %s: %v", p, n)
 		return nil, false
 	}
 
-	if n.List().Len() > 1 {
+	if n.Args.Len() > 1 {
 		p := fmt.Sprintf(f, args...)
 		base.Errorf("too many arguments to %s: %v", p, n)
-		return n.List().First(), false
+		return n.Args.First(), false
 	}
 
-	return n.List().First(), true
+	return n.Args.First(), true
 }
 
 func needTwoArgs(n *ir.CallExpr) (ir.Node, ir.Node, bool) {
-	if n.List().Len() != 2 {
-		if n.List().Len() < 2 {
+	if n.Args.Len() != 2 {
+		if n.Args.Len() < 2 {
 			base.Errorf("not enough arguments in call to %v", n)
 		} else {
 			base.Errorf("too many arguments in call to %v", n)
 		}
 		return nil, nil, false
 	}
-	return n.List().First(), n.List().Second(), true
+	return n.Args.First(), n.Args.Second(), true
 }
 
 func lookdot1(errnode ir.Node, s *types.Sym, t *types.Type, fs *types.Fields, dostrcmp int) *types.Field {
@@ -2556,7 +2556,7 @@ func typecheckMethodExpr(n *ir.SelectorExpr) (res ir.Node) {
 		defer tracePrint("typecheckMethodExpr", n)(&res)
 	}
 
-	t := n.Left().Type()
+	t := n.X.Type()
 
 	// Compute the method set for t.
 	var ms *types.Fields
@@ -2565,7 +2565,7 @@ func typecheckMethodExpr(n *ir.SelectorExpr) (res ir.Node) {
 	} else {
 		mt := methtype(t)
 		if mt == nil {
-			base.Errorf("%v undefined (type %v has no method %v)", n, t, n.Sym())
+			base.Errorf("%v undefined (type %v has no method %v)", n, t, n.Sel)
 			n.SetType(nil)
 			return n
 		}
@@ -2584,7 +2584,7 @@ func typecheckMethodExpr(n *ir.SelectorExpr) (res ir.Node) {
 		}
 	}
 
-	s := n.Sym()
+	s := n.Sel
 	m := lookdot1(n, s, t, ms, 0)
 	if m == nil {
 		if lookdot1(n, s, t, ms, 1) != nil {
@@ -2604,10 +2604,10 @@ func typecheckMethodExpr(n *ir.SelectorExpr) (res ir.Node) {
 		return n
 	}
 
-	me := ir.NewMethodExpr(n.Pos(), n.Left().Type(), m)
-	me.SetType(methodfunc(m.Type, n.Left().Type()))
+	me := ir.NewMethodExpr(n.Pos(), n.X.Type(), m)
+	me.SetType(methodfunc(m.Type, n.X.Type()))
 	f := NewName(methodSym(t, m.Sym))
-	f.SetClass(ir.PFUNC)
+	f.Class_ = ir.PFUNC
 	f.SetType(me.Type())
 	me.FuncName_ = f
 
@@ -2635,7 +2635,7 @@ func derefall(t *types.Type) *types.Type {
 }
 
 func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
-	s := n.Sym()
+	s := n.Sel
 
 	dowidth(t)
 	var f1 *types.Field
@@ -2644,7 +2644,7 @@ func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 	}
 
 	var f2 *types.Field
-	if n.Left().Type() == t || n.Left().Type().Sym() == nil {
+	if n.X.Type() == t || n.X.Type().Sym() == nil {
 		mt := methtype(t)
 		if mt != nil {
 			f2 = lookdot1(n, s, mt, mt.Methods(), dostrcmp)
@@ -2657,18 +2657,18 @@ func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 			return f1
 		}
 		if f2 != nil {
-			base.Errorf("%v is both field and method", n.Sym())
+			base.Errorf("%v is both field and method", n.Sel)
 		}
 		if f1.Offset == types.BADWIDTH {
 			base.Fatalf("lookdot badwidth %v %p", f1, f1)
 		}
-		n.SetOffset(f1.Offset)
+		n.Offset = f1.Offset
 		n.SetType(f1.Type)
 		if t.IsInterface() {
-			if n.Left().Type().IsPtr() {
-				star := ir.NewStarExpr(base.Pos, n.Left())
+			if n.X.Type().IsPtr() {
+				star := ir.NewStarExpr(base.Pos, n.X)
 				star.SetImplicit(true)
-				n.SetLeft(typecheck(star, ctxExpr))
+				n.X = typecheck(star, ctxExpr)
 			}
 
 			n.SetOp(ir.ODOTINTER)
@@ -2682,29 +2682,29 @@ func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 			// Already in the process of diagnosing an error.
 			return f2
 		}
-		tt := n.Left().Type()
+		tt := n.X.Type()
 		dowidth(tt)
 		rcvr := f2.Type.Recv().Type
 		if !types.Identical(rcvr, tt) {
 			if rcvr.IsPtr() && types.Identical(rcvr.Elem(), tt) {
-				checklvalue(n.Left(), "call pointer method on")
-				addr := nodAddr(n.Left())
+				checklvalue(n.X, "call pointer method on")
+				addr := nodAddr(n.X)
 				addr.SetImplicit(true)
-				n.SetLeft(typecheck(addr, ctxType|ctxExpr))
+				n.X = typecheck(addr, ctxType|ctxExpr)
 			} else if tt.IsPtr() && (!rcvr.IsPtr() || rcvr.IsPtr() && rcvr.Elem().NotInHeap()) && types.Identical(tt.Elem(), rcvr) {
-				star := ir.NewStarExpr(base.Pos, n.Left())
+				star := ir.NewStarExpr(base.Pos, n.X)
 				star.SetImplicit(true)
-				n.SetLeft(typecheck(star, ctxType|ctxExpr))
+				n.X = typecheck(star, ctxType|ctxExpr)
 			} else if tt.IsPtr() && tt.Elem().IsPtr() && types.Identical(derefall(tt), derefall(rcvr)) {
-				base.Errorf("calling method %v with receiver %L requires explicit dereference", n.Sym(), n.Left())
+				base.Errorf("calling method %v with receiver %L requires explicit dereference", n.Sel, n.X)
 				for tt.IsPtr() {
 					// Stop one level early for method with pointer receiver.
 					if rcvr.IsPtr() && !tt.Elem().IsPtr() {
 						break
 					}
-					star := ir.NewStarExpr(base.Pos, n.Left())
+					star := ir.NewStarExpr(base.Pos, n.X)
 					star.SetImplicit(true)
-					n.SetLeft(typecheck(star, ctxType|ctxExpr))
+					n.X = typecheck(star, ctxType|ctxExpr)
 					tt = tt.Elem()
 				}
 			} else {
@@ -2712,24 +2712,24 @@ func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 			}
 		}
 
-		implicit, ll := n.Implicit(), n.Left()
+		implicit, ll := n.Implicit(), n.X
 		for ll != nil && (ll.Op() == ir.ODOT || ll.Op() == ir.ODOTPTR || ll.Op() == ir.ODEREF) {
 			switch l := ll.(type) {
 			case *ir.SelectorExpr:
-				implicit, ll = l.Implicit(), l.Left()
+				implicit, ll = l.Implicit(), l.X
 			case *ir.StarExpr:
-				implicit, ll = l.Implicit(), l.Left()
+				implicit, ll = l.Implicit(), l.X
 			}
 		}
 		if implicit && ll.Type().IsPtr() && ll.Type().Sym() != nil && ll.Type().Sym().Def != nil && ir.AsNode(ll.Type().Sym().Def).Op() == ir.OTYPE {
 			// It is invalid to automatically dereference a named pointer type when selecting a method.
 			// Make n.Left == ll to clarify error message.
-			n.SetLeft(ll)
+			n.X = ll
 			return nil
 		}
 
-		n.SetSym(methodSym(n.Left().Type(), f2.Sym))
-		n.SetOffset(f2.Offset)
+		n.Sel = methodSym(n.X.Type(), f2.Sym)
+		n.Offset = f2.Offset
 		n.SetType(f2.Type)
 		n.SetOp(ir.ODOTMETH)
 		n.Selection = f2
@@ -2968,18 +2968,18 @@ func pushtype(nn ir.Node, t *types.Type) ir.Node {
 		return nn
 	}
 	n := nn.(*ir.CompLitExpr)
-	if n.Right() != nil {
+	if n.Ntype != nil {
 		return n
 	}
 
 	switch {
 	case iscomptype(t):
 		// For T, return T{...}.
-		n.SetRight(ir.TypeNode(t))
+		n.Ntype = ir.TypeNode(t)
 
 	case t.IsPtr() && iscomptype(t.Elem()):
 		// For *T, return &T{...}.
-		n.SetRight(ir.TypeNode(t.Elem()))
+		n.Ntype = ir.TypeNode(t.Elem())
 
 		addr := nodAddrAt(n.Pos(), n)
 		addr.SetImplicit(true)
@@ -3000,7 +3000,7 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 		base.Pos = lno
 	}()
 
-	if n.Right() == nil {
+	if n.Ntype == nil {
 		base.ErrorfAt(n.Pos(), "missing type in composite literal")
 		n.SetType(nil)
 		return n
@@ -3009,25 +3009,25 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 	// Save original node (including n.Right)
 	n.SetOrig(ir.Copy(n))
 
-	setlineno(n.Right())
+	setlineno(n.Ntype)
 
 	// Need to handle [...]T arrays specially.
-	if array, ok := n.Right().(*ir.ArrayType); ok && array.Elem != nil && array.Len == nil {
+	if array, ok := n.Ntype.(*ir.ArrayType); ok && array.Elem != nil && array.Len == nil {
 		array.Elem = typecheck(array.Elem, ctxType)
 		elemType := array.Elem.Type()
 		if elemType == nil {
 			n.SetType(nil)
 			return n
 		}
-		length := typecheckarraylit(elemType, -1, n.List().Slice(), "array literal")
+		length := typecheckarraylit(elemType, -1, n.List.Slice(), "array literal")
 		n.SetOp(ir.OARRAYLIT)
 		n.SetType(types.NewArray(elemType, length))
-		n.SetRight(nil)
+		n.Ntype = nil
 		return n
 	}
 
-	n.SetRight(typecheck(n.Right(), ctxType))
-	t := n.Right().Type()
+	n.Ntype = ir.Node(typecheck(n.Ntype, ctxType)).(ir.Ntype)
+	t := n.Ntype.Type()
 	if t == nil {
 		n.SetType(nil)
 		return n
@@ -3040,50 +3040,50 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 		n.SetType(nil)
 
 	case types.TARRAY:
-		typecheckarraylit(t.Elem(), t.NumElem(), n.List().Slice(), "array literal")
+		typecheckarraylit(t.Elem(), t.NumElem(), n.List.Slice(), "array literal")
 		n.SetOp(ir.OARRAYLIT)
-		n.SetRight(nil)
+		n.Ntype = nil
 
 	case types.TSLICE:
-		length := typecheckarraylit(t.Elem(), -1, n.List().Slice(), "slice literal")
+		length := typecheckarraylit(t.Elem(), -1, n.List.Slice(), "slice literal")
 		n.SetOp(ir.OSLICELIT)
-		n.SetRight(nil)
+		n.Ntype = nil
 		n.Len = length
 
 	case types.TMAP:
 		var cs constSet
-		for i3, l := range n.List().Slice() {
+		for i3, l := range n.List.Slice() {
 			setlineno(l)
 			if l.Op() != ir.OKEY {
-				n.List().SetIndex(i3, typecheck(l, ctxExpr))
+				n.List.SetIndex(i3, typecheck(l, ctxExpr))
 				base.Errorf("missing key in map literal")
 				continue
 			}
 			l := l.(*ir.KeyExpr)
 
-			r := l.Left()
+			r := l.Key
 			r = pushtype(r, t.Key())
 			r = typecheck(r, ctxExpr)
-			l.SetLeft(assignconv(r, t.Key(), "map key"))
-			cs.add(base.Pos, l.Left(), "key", "map literal")
+			l.Key = assignconv(r, t.Key(), "map key")
+			cs.add(base.Pos, l.Key, "key", "map literal")
 
-			r = l.Right()
+			r = l.Value
 			r = pushtype(r, t.Elem())
 			r = typecheck(r, ctxExpr)
-			l.SetRight(assignconv(r, t.Elem(), "map value"))
+			l.Value = assignconv(r, t.Elem(), "map value")
 		}
 
 		n.SetOp(ir.OMAPLIT)
-		n.SetRight(nil)
+		n.Ntype = nil
 
 	case types.TSTRUCT:
 		// Need valid field offsets for Xoffset below.
 		dowidth(t)
 
 		errored := false
-		if n.List().Len() != 0 && nokeys(n.List()) {
+		if n.List.Len() != 0 && nokeys(n.List) {
 			// simple list of variables
-			ls := n.List().Slice()
+			ls := n.List.Slice()
 			for i, n1 := range ls {
 				setlineno(n1)
 				n1 = typecheck(n1, ctxExpr)
@@ -3104,7 +3104,7 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 				// No pushtype allowed here. Must name fields for that.
 				n1 = assignconv(n1, f.Type, "field value")
 				sk := ir.NewStructKeyExpr(base.Pos, f.Sym, n1)
-				sk.SetOffset(f.Offset)
+				sk.Offset = f.Offset
 				ls[i] = sk
 			}
 			if len(ls) < t.NumFields() {
@@ -3114,13 +3114,13 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 			hash := make(map[string]bool)
 
 			// keyed list
-			ls := n.List().Slice()
+			ls := n.List.Slice()
 			for i, l := range ls {
 				setlineno(l)
 
 				if l.Op() == ir.OKEY {
 					kv := l.(*ir.KeyExpr)
-					key := kv.Left()
+					key := kv.Key
 
 					// Sym might have resolved to name in other top-level
 					// package, because of import dot. Redirect to correct sym
@@ -3139,7 +3139,7 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 						continue
 					}
 
-					l = ir.NewStructKeyExpr(l.Pos(), s, kv.Right())
+					l = ir.NewStructKeyExpr(l.Pos(), s, kv.Value)
 					ls[i] = l
 				}
 
@@ -3153,22 +3153,22 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 				}
 				l := l.(*ir.StructKeyExpr)
 
-				f := lookdot1(nil, l.Sym(), t, t.Fields(), 0)
+				f := lookdot1(nil, l.Field, t, t.Fields(), 0)
 				if f == nil {
-					if ci := lookdot1(nil, l.Sym(), t, t.Fields(), 2); ci != nil { // Case-insensitive lookup.
+					if ci := lookdot1(nil, l.Field, t, t.Fields(), 2); ci != nil { // Case-insensitive lookup.
 						if visible(ci.Sym) {
-							base.Errorf("unknown field '%v' in struct literal of type %v (but does have %v)", l.Sym(), t, ci.Sym)
-						} else if nonexported(l.Sym()) && l.Sym().Name == ci.Sym.Name { // Ensure exactness before the suggestion.
-							base.Errorf("cannot refer to unexported field '%v' in struct literal of type %v", l.Sym(), t)
+							base.Errorf("unknown field '%v' in struct literal of type %v (but does have %v)", l.Field, t, ci.Sym)
+						} else if nonexported(l.Field) && l.Field.Name == ci.Sym.Name { // Ensure exactness before the suggestion.
+							base.Errorf("cannot refer to unexported field '%v' in struct literal of type %v", l.Field, t)
 						} else {
-							base.Errorf("unknown field '%v' in struct literal of type %v", l.Sym(), t)
+							base.Errorf("unknown field '%v' in struct literal of type %v", l.Field, t)
 						}
 						continue
 					}
 					var f *types.Field
-					p, _ := dotpath(l.Sym(), t, &f, true)
+					p, _ := dotpath(l.Field, t, &f, true)
 					if p == nil || f.IsMethod() {
-						base.Errorf("unknown field '%v' in struct literal of type %v", l.Sym(), t)
+						base.Errorf("unknown field '%v' in struct literal of type %v", l.Field, t)
 						continue
 					}
 					// dotpath returns the parent embedded types in reverse order.
@@ -3176,21 +3176,21 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 					for ei := len(p) - 1; ei >= 0; ei-- {
 						ep = append(ep, p[ei].field.Sym.Name)
 					}
-					ep = append(ep, l.Sym().Name)
+					ep = append(ep, l.Field.Name)
 					base.Errorf("cannot use promoted field %v in struct literal of type %v", strings.Join(ep, "."), t)
 					continue
 				}
 				fielddup(f.Sym.Name, hash)
-				l.SetOffset(f.Offset)
+				l.Offset = f.Offset
 
 				// No pushtype allowed here. Tried and rejected.
-				l.SetLeft(typecheck(l.Left(), ctxExpr))
-				l.SetLeft(assignconv(l.Left(), f.Type, "field value"))
+				l.Value = typecheck(l.Value, ctxExpr)
+				l.Value = assignconv(l.Value, f.Type, "field value")
 			}
 		}
 
 		n.SetOp(ir.OSTRUCTLIT)
-		n.SetRight(nil)
+		n.Ntype = nil
 	}
 
 	return n
@@ -3215,28 +3215,28 @@ func typecheckarraylit(elemType *types.Type, bound int64, elts []ir.Node, ctx st
 		var kv *ir.KeyExpr
 		if elt.Op() == ir.OKEY {
 			elt := elt.(*ir.KeyExpr)
-			elt.SetLeft(typecheck(elt.Left(), ctxExpr))
-			key = indexconst(elt.Left())
+			elt.Key = typecheck(elt.Key, ctxExpr)
+			key = indexconst(elt.Key)
 			if key < 0 {
-				if !elt.Left().Diag() {
+				if !elt.Key.Diag() {
 					if key == -2 {
 						base.Errorf("index too large")
 					} else {
 						base.Errorf("index must be non-negative integer constant")
 					}
-					elt.Left().SetDiag(true)
+					elt.Key.SetDiag(true)
 				}
 				key = -(1 << 30) // stay negative for a while
 			}
 			kv = elt
-			r = elt.Right()
+			r = elt.Value
 		}
 
 		r = pushtype(r, elemType)
 		r = typecheck(r, ctxExpr)
 		r = assignconv(r, elemType, ctx)
 		if kv != nil {
-			kv.SetRight(r)
+			kv.Value = r
 		} else {
 			elts[i] = r
 		}
@@ -3280,10 +3280,10 @@ func islvalue(n ir.Node) bool {
 	switch n.Op() {
 	case ir.OINDEX:
 		n := n.(*ir.IndexExpr)
-		if n.Left().Type() != nil && n.Left().Type().IsArray() {
-			return islvalue(n.Left())
+		if n.X.Type() != nil && n.X.Type().IsArray() {
+			return islvalue(n.X)
 		}
-		if n.Left().Type() != nil && n.Left().Type().IsString() {
+		if n.X.Type() != nil && n.X.Type().IsString() {
 			return false
 		}
 		fallthrough
@@ -3292,11 +3292,11 @@ func islvalue(n ir.Node) bool {
 
 	case ir.ODOT:
 		n := n.(*ir.SelectorExpr)
-		return islvalue(n.Left())
+		return islvalue(n.X)
 
 	case ir.ONAME:
 		n := n.(*ir.Name)
-		if n.Class() == ir.PFUNC {
+		if n.Class_ == ir.PFUNC {
 			return false
 		}
 		return true
@@ -3332,7 +3332,7 @@ func checkassign(stmt ir.Node, n ir.Node) {
 	}
 	if n.Op() == ir.OINDEXMAP {
 		n := n.(*ir.IndexExpr)
-		n.SetIndexMapLValue(true)
+		n.Assigned = true
 		return
 	}
 
@@ -3342,9 +3342,9 @@ func checkassign(stmt ir.Node, n ir.Node) {
 	}
 
 	switch {
-	case n.Op() == ir.ODOT && n.(*ir.SelectorExpr).Left().Op() == ir.OINDEXMAP:
+	case n.Op() == ir.ODOT && n.(*ir.SelectorExpr).X.Op() == ir.OINDEXMAP:
 		base.Errorf("cannot assign to struct field %v in map", n)
-	case (n.Op() == ir.OINDEX && n.(*ir.IndexExpr).Left().Type().IsString()) || n.Op() == ir.OSLICESTR:
+	case (n.Op() == ir.OINDEX && n.(*ir.IndexExpr).X.Type().IsString()) || n.Op() == ir.OSLICESTR:
 		base.Errorf("cannot assign to %v (strings are immutable)", n)
 	case n.Op() == ir.OLITERAL && n.Sym() != nil && isGoConst(n):
 		base.Errorf("cannot assign to %v (declared const)", n)
@@ -3387,39 +3387,39 @@ func samesafeexpr(l ir.Node, r ir.Node) bool {
 	case ir.ODOT, ir.ODOTPTR:
 		l := l.(*ir.SelectorExpr)
 		r := r.(*ir.SelectorExpr)
-		return l.Sym() != nil && r.Sym() != nil && l.Sym() == r.Sym() && samesafeexpr(l.Left(), r.Left())
+		return l.Sel != nil && r.Sel != nil && l.Sel == r.Sel && samesafeexpr(l.X, r.X)
 
 	case ir.ODEREF:
 		l := l.(*ir.StarExpr)
 		r := r.(*ir.StarExpr)
-		return samesafeexpr(l.Left(), r.Left())
+		return samesafeexpr(l.X, r.X)
 
 	case ir.ONOT, ir.OBITNOT, ir.OPLUS, ir.ONEG:
 		l := l.(*ir.UnaryExpr)
 		r := r.(*ir.UnaryExpr)
-		return samesafeexpr(l.Left(), r.Left())
+		return samesafeexpr(l.X, r.X)
 
 	case ir.OCONVNOP:
 		l := l.(*ir.ConvExpr)
 		r := r.(*ir.ConvExpr)
-		return samesafeexpr(l.Left(), r.Left())
+		return samesafeexpr(l.X, r.X)
 
 	case ir.OCONV:
 		l := l.(*ir.ConvExpr)
 		r := r.(*ir.ConvExpr)
 		// Some conversions can't be reused, such as []byte(str).
 		// Allow only numeric-ish types. This is a bit conservative.
-		return issimple[l.Type().Kind()] && samesafeexpr(l.Left(), r.Left())
+		return issimple[l.Type().Kind()] && samesafeexpr(l.X, r.X)
 
 	case ir.OINDEX, ir.OINDEXMAP:
 		l := l.(*ir.IndexExpr)
 		r := r.(*ir.IndexExpr)
-		return samesafeexpr(l.Left(), r.Left()) && samesafeexpr(l.Right(), r.Right())
+		return samesafeexpr(l.X, r.X) && samesafeexpr(l.Index, r.Index)
 
 	case ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.OLSH, ir.ORSH, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OMOD:
 		l := l.(*ir.BinaryExpr)
 		r := r.(*ir.BinaryExpr)
-		return samesafeexpr(l.Left(), r.Left()) && samesafeexpr(l.Right(), r.Right())
+		return samesafeexpr(l.X, r.X) && samesafeexpr(l.Y, r.Y)
 
 	case ir.OLITERAL:
 		return constant.Compare(l.Val(), token.EQL, r.Val())
@@ -3446,30 +3446,30 @@ func typecheckas(n *ir.AssignStmt) {
 	// if the variable has a type (ntype) then typechecking
 	// will not look at defn, so it is okay (and desirable,
 	// so that the conversion below happens).
-	n.SetLeft(resolve(n.Left()))
+	n.X = resolve(n.X)
 
-	if !ir.DeclaredBy(n.Left(), n) || n.Left().Name().Ntype != nil {
-		n.SetLeft(typecheck(n.Left(), ctxExpr|ctxAssign))
+	if !ir.DeclaredBy(n.X, n) || n.X.Name().Ntype != nil {
+		n.X = typecheck(n.X, ctxExpr|ctxAssign)
 	}
 
 	// Use ctxMultiOK so we can emit an "N variables but M values" error
 	// to be consistent with typecheckas2 (#26616).
-	n.SetRight(typecheck(n.Right(), ctxExpr|ctxMultiOK))
-	checkassign(n, n.Left())
-	if n.Right() != nil && n.Right().Type() != nil {
-		if n.Right().Type().IsFuncArgStruct() {
-			base.Errorf("assignment mismatch: 1 variable but %v returns %d values", n.Right().(*ir.CallExpr).Left(), n.Right().Type().NumFields())
+	n.Y = typecheck(n.Y, ctxExpr|ctxMultiOK)
+	checkassign(n, n.X)
+	if n.Y != nil && n.Y.Type() != nil {
+		if n.Y.Type().IsFuncArgStruct() {
+			base.Errorf("assignment mismatch: 1 variable but %v returns %d values", n.Y.(*ir.CallExpr).X, n.Y.Type().NumFields())
 			// Multi-value RHS isn't actually valid for OAS; nil out
 			// to indicate failed typechecking.
-			n.Right().SetType(nil)
-		} else if n.Left().Type() != nil {
-			n.SetRight(assignconv(n.Right(), n.Left().Type(), "assignment"))
+			n.Y.SetType(nil)
+		} else if n.X.Type() != nil {
+			n.Y = assignconv(n.Y, n.X.Type(), "assignment")
 		}
 	}
 
-	if ir.DeclaredBy(n.Left(), n) && n.Left().Name().Ntype == nil {
-		n.SetRight(defaultlit(n.Right(), nil))
-		n.Left().SetType(n.Right().Type())
+	if ir.DeclaredBy(n.X, n) && n.X.Name().Ntype == nil {
+		n.Y = defaultlit(n.Y, nil)
+		n.X.SetType(n.Y.Type())
 	}
 
 	// second half of dance.
@@ -3477,11 +3477,11 @@ func typecheckas(n *ir.AssignStmt) {
 	// just to get it over with.  see dance above.
 	n.SetTypecheck(1)
 
-	if n.Left().Typecheck() == 0 {
-		n.SetLeft(typecheck(n.Left(), ctxExpr|ctxAssign))
+	if n.X.Typecheck() == 0 {
+		n.X = typecheck(n.X, ctxExpr|ctxAssign)
 	}
-	if !ir.IsBlank(n.Left()) {
-		checkwidth(n.Left().Type()) // ensure width is calculated for backend
+	if !ir.IsBlank(n.X) {
+		checkwidth(n.X.Type()) // ensure width is calculated for backend
 	}
 }
 
@@ -3497,7 +3497,7 @@ func typecheckas2(n *ir.AssignListStmt) {
 		defer tracePrint("typecheckas2", n)(nil)
 	}
 
-	ls := n.List().Slice()
+	ls := n.Lhs.Slice()
 	for i1, n1 := range ls {
 		// delicate little dance.
 		n1 = resolve(n1)
@@ -3508,21 +3508,21 @@ func typecheckas2(n *ir.AssignListStmt) {
 		}
 	}
 
-	cl := n.List().Len()
-	cr := n.Rlist().Len()
+	cl := n.Lhs.Len()
+	cr := n.Rhs.Len()
 	if cl > 1 && cr == 1 {
-		n.Rlist().SetFirst(typecheck(n.Rlist().First(), ctxExpr|ctxMultiOK))
+		n.Rhs.SetFirst(typecheck(n.Rhs.First(), ctxExpr|ctxMultiOK))
 	} else {
-		typecheckslice(n.Rlist().Slice(), ctxExpr)
+		typecheckslice(n.Rhs.Slice(), ctxExpr)
 	}
-	checkassignlist(n, n.List())
+	checkassignlist(n, n.Lhs)
 
 	var l ir.Node
 	var r ir.Node
 	if cl == cr {
 		// easy
-		ls := n.List().Slice()
-		rs := n.Rlist().Slice()
+		ls := n.Lhs.Slice()
+		rs := n.Rhs.Slice()
 		for il, nl := range ls {
 			nr := rs[il]
 			if nl.Type() != nil && nr.Type() != nil {
@@ -3537,8 +3537,8 @@ func typecheckas2(n *ir.AssignListStmt) {
 		goto out
 	}
 
-	l = n.List().First()
-	r = n.Rlist().First()
+	l = n.Lhs.First()
+	r = n.Rhs.First()
 
 	// x,y,z = f()
 	if cr == 1 {
@@ -3556,7 +3556,7 @@ func typecheckas2(n *ir.AssignListStmt) {
 			}
 			r.(*ir.CallExpr).Use = ir.CallUseList
 			n.SetOp(ir.OAS2FUNC)
-			for i, l := range n.List().Slice() {
+			for i, l := range n.Lhs.Slice() {
 				f := r.Type().Field(i)
 				if f.Type != nil && l.Type() != nil {
 					checkassignto(f.Type, l)
@@ -3592,7 +3592,7 @@ func typecheckas2(n *ir.AssignListStmt) {
 			if ir.DeclaredBy(l, n) {
 				l.SetType(r.Type())
 			}
-			l := n.List().Second()
+			l := n.Lhs.Second()
 			if l.Type() != nil && !l.Type().IsBoolean() {
 				checkassignto(types.Types[types.TBOOL], l)
 			}
@@ -3609,13 +3609,13 @@ mismatch:
 		base.Errorf("assignment mismatch: %d variables but %d values", cl, cr)
 	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
 		r := r.(*ir.CallExpr)
-		base.Errorf("assignment mismatch: %d variables but %v returns %d values", cl, r.Left(), cr)
+		base.Errorf("assignment mismatch: %d variables but %v returns %d values", cl, r.X, cr)
 	}
 
 	// second half of dance
 out:
 	n.SetTypecheck(1)
-	ls = n.List().Slice()
+	ls = n.Lhs.Slice()
 	for i1, n1 := range ls {
 		if n1.Typecheck() == 0 {
 			ls[i1] = typecheck(ls[i1], ctxExpr|ctxAssign)
@@ -3632,7 +3632,7 @@ func typecheckfunc(n *ir.Func) {
 	}
 
 	for _, ln := range n.Dcl {
-		if ln.Op() == ir.ONAME && (ln.Class() == ir.PPARAM || ln.Class() == ir.PPARAMOUT) {
+		if ln.Op() == ir.ONAME && (ln.Class_ == ir.PPARAM || ln.Class_ == ir.PPARAMOUT) {
 			ln.Decldepth = 1
 		}
 	}
@@ -3662,19 +3662,19 @@ func typecheckfunc(n *ir.Func) {
 // The result of stringtoruneslit MUST be assigned back to n, e.g.
 // 	n.Left = stringtoruneslit(n.Left)
 func stringtoruneslit(n *ir.ConvExpr) ir.Node {
-	if n.Left().Op() != ir.OLITERAL || n.Left().Val().Kind() != constant.String {
+	if n.X.Op() != ir.OLITERAL || n.X.Val().Kind() != constant.String {
 		base.Fatalf("stringtoarraylit %v", n)
 	}
 
 	var l []ir.Node
 	i := 0
-	for _, r := range ir.StringVal(n.Left()) {
+	for _, r := range ir.StringVal(n.X) {
 		l = append(l, ir.NewKeyExpr(base.Pos, nodintconst(int64(i)), nodintconst(int64(r))))
 		i++
 	}
 
 	nn := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(n.Type()).(ir.Ntype), nil)
-	nn.PtrList().Set(l)
+	nn.List.Set(l)
 	return typecheck(nn, ctxExpr)
 }
 
@@ -3837,7 +3837,7 @@ func typecheckdef(n ir.Node) {
 			break
 		}
 		if n.Name().Defn == nil {
-			if n.SubOp() != 0 { // like OPRINTN
+			if n.BuiltinOp != 0 { // like OPRINTN
 				break
 			}
 			if base.Errors() > 0 {
@@ -3945,10 +3945,10 @@ func markBreak(fn *ir.Func) {
 
 		case ir.OBREAK:
 			n := n.(*ir.BranchStmt)
-			if n.Sym() == nil {
+			if n.Label == nil {
 				setHasBreak(implicit)
 			} else {
-				setHasBreak(labels[n.Sym()])
+				setHasBreak(labels[n.Label])
 			}
 
 		case ir.OFOR, ir.OFORUNTIL, ir.OSWITCH, ir.OSELECT, ir.ORANGE:
@@ -3957,13 +3957,13 @@ func markBreak(fn *ir.Func) {
 			var sym *types.Sym
 			switch n := n.(type) {
 			case *ir.ForStmt:
-				sym = n.Sym()
+				sym = n.Label
 			case *ir.RangeStmt:
-				sym = n.Sym()
+				sym = n.Label
 			case *ir.SelectStmt:
-				sym = n.Sym()
+				sym = n.Label
 			case *ir.SwitchStmt:
-				sym = n.Sym()
+				sym = n.Label
 			}
 			if sym != nil {
 				if labels == nil {
@@ -3990,13 +3990,13 @@ func controlLabel(n ir.Node) *types.Sym {
 		base.Fatalf("controlLabel %+v", n.Op())
 		return nil
 	case *ir.ForStmt:
-		return n.Sym()
+		return n.Label
 	case *ir.RangeStmt:
-		return n.Sym()
+		return n.Label
 	case *ir.SelectStmt:
-		return n.Sym()
+		return n.Label
 	case *ir.SwitchStmt:
-		return n.Sym()
+		return n.Label
 	}
 }
 
@@ -4007,13 +4007,13 @@ func setHasBreak(n ir.Node) {
 	case nil:
 		// ignore
 	case *ir.ForStmt:
-		n.SetHasBreak(true)
+		n.HasBreak = true
 	case *ir.RangeStmt:
-		n.SetHasBreak(true)
+		n.HasBreak = true
 	case *ir.SelectStmt:
-		n.SetHasBreak(true)
+		n.HasBreak = true
 	case *ir.SwitchStmt:
-		n.SetHasBreak(true)
+		n.HasBreak = true
 	}
 }
 
@@ -4038,37 +4038,37 @@ func isTermNode(n ir.Node) bool {
 
 	case ir.OBLOCK:
 		n := n.(*ir.BlockStmt)
-		return isTermNodes(n.List())
+		return isTermNodes(n.List)
 
 	case ir.OGOTO, ir.ORETURN, ir.ORETJMP, ir.OPANIC, ir.OFALL:
 		return true
 
 	case ir.OFOR, ir.OFORUNTIL:
 		n := n.(*ir.ForStmt)
-		if n.Left() != nil {
+		if n.Cond != nil {
 			return false
 		}
-		if n.HasBreak() {
+		if n.HasBreak {
 			return false
 		}
 		return true
 
 	case ir.OIF:
 		n := n.(*ir.IfStmt)
-		return isTermNodes(n.Body()) && isTermNodes(n.Rlist())
+		return isTermNodes(n.Body) && isTermNodes(n.Else)
 
 	case ir.OSWITCH:
 		n := n.(*ir.SwitchStmt)
-		if n.HasBreak() {
+		if n.HasBreak {
 			return false
 		}
 		def := false
-		for _, cas := range n.List().Slice() {
+		for _, cas := range n.Cases.Slice() {
 			cas := cas.(*ir.CaseStmt)
-			if !isTermNodes(cas.Body()) {
+			if !isTermNodes(cas.Body) {
 				return false
 			}
-			if cas.List().Len() == 0 { // default
+			if cas.List.Len() == 0 { // default
 				def = true
 			}
 		}
@@ -4076,12 +4076,12 @@ func isTermNode(n ir.Node) bool {
 
 	case ir.OSELECT:
 		n := n.(*ir.SelectStmt)
-		if n.HasBreak() {
+		if n.HasBreak {
 			return false
 		}
-		for _, cas := range n.List().Slice() {
+		for _, cas := range n.Cases.Slice() {
 			cas := cas.(*ir.CaseStmt)
-			if !isTermNodes(cas.Body()) {
+			if !isTermNodes(cas.Body) {
 				return false
 			}
 		}
@@ -4093,34 +4093,34 @@ func isTermNode(n ir.Node) bool {
 
 // checkreturn makes sure that fn terminates appropriately.
 func checkreturn(fn *ir.Func) {
-	if fn.Type().NumResults() != 0 && fn.Body().Len() != 0 {
+	if fn.Type().NumResults() != 0 && fn.Body.Len() != 0 {
 		markBreak(fn)
-		if !isTermNodes(fn.Body()) {
+		if !isTermNodes(fn.Body) {
 			base.ErrorfAt(fn.Endlineno, "missing return at end of function")
 		}
 	}
 }
 
 func deadcode(fn *ir.Func) {
-	deadcodeslice(fn.PtrBody())
+	deadcodeslice(&fn.Body)
 
-	if fn.Body().Len() == 0 {
+	if fn.Body.Len() == 0 {
 		return
 	}
 
-	for _, n := range fn.Body().Slice() {
+	for _, n := range fn.Body.Slice() {
 		if n.Init().Len() > 0 {
 			return
 		}
 		switch n.Op() {
 		case ir.OIF:
 			n := n.(*ir.IfStmt)
-			if !ir.IsConst(n.Left(), constant.Bool) || n.Body().Len() > 0 || n.Rlist().Len() > 0 {
+			if !ir.IsConst(n.Cond, constant.Bool) || n.Body.Len() > 0 || n.Else.Len() > 0 {
 				return
 			}
 		case ir.OFOR:
 			n := n.(*ir.ForStmt)
-			if !ir.IsConst(n.Left(), constant.Bool) || ir.BoolVal(n.Left()) {
+			if !ir.IsConst(n.Cond, constant.Bool) || ir.BoolVal(n.Cond) {
 				return
 			}
 		default:
@@ -4128,7 +4128,7 @@ func deadcode(fn *ir.Func) {
 		}
 	}
 
-	fn.PtrBody().Set([]ir.Node{ir.NewBlockStmt(base.Pos, nil)})
+	fn.Body.Set([]ir.Node{ir.NewBlockStmt(base.Pos, nil)})
 }
 
 func deadcodeslice(nn *ir.Nodes) {
@@ -4148,15 +4148,15 @@ func deadcodeslice(nn *ir.Nodes) {
 		}
 		if n.Op() == ir.OIF {
 			n := n.(*ir.IfStmt)
-			n.SetLeft(deadcodeexpr(n.Left()))
-			if ir.IsConst(n.Left(), constant.Bool) {
+			n.Cond = deadcodeexpr(n.Cond)
+			if ir.IsConst(n.Cond, constant.Bool) {
 				var body ir.Nodes
-				if ir.BoolVal(n.Left()) {
-					n.SetRlist(ir.Nodes{})
-					body = n.Body()
+				if ir.BoolVal(n.Cond) {
+					n.Else = ir.Nodes{}
+					body = n.Body
 				} else {
-					n.SetBody(ir.Nodes{})
-					body = n.Rlist()
+					n.Body = ir.Nodes{}
+					body = n.Else
 				}
 				// If "then" or "else" branch ends with panic or return statement,
 				// it is safe to remove all statements after this node.
@@ -4178,26 +4178,26 @@ func deadcodeslice(nn *ir.Nodes) {
 		switch n.Op() {
 		case ir.OBLOCK:
 			n := n.(*ir.BlockStmt)
-			deadcodeslice(n.PtrList())
+			deadcodeslice(&n.List)
 		case ir.OCASE:
 			n := n.(*ir.CaseStmt)
-			deadcodeslice(n.PtrBody())
+			deadcodeslice(&n.Body)
 		case ir.OFOR:
 			n := n.(*ir.ForStmt)
-			deadcodeslice(n.PtrBody())
+			deadcodeslice(&n.Body)
 		case ir.OIF:
 			n := n.(*ir.IfStmt)
-			deadcodeslice(n.PtrBody())
-			deadcodeslice(n.PtrRlist())
+			deadcodeslice(&n.Body)
+			deadcodeslice(&n.Else)
 		case ir.ORANGE:
 			n := n.(*ir.RangeStmt)
-			deadcodeslice(n.PtrBody())
+			deadcodeslice(&n.Body)
 		case ir.OSELECT:
 			n := n.(*ir.SelectStmt)
-			deadcodeslice(n.PtrList())
+			deadcodeslice(&n.Cases)
 		case ir.OSWITCH:
 			n := n.(*ir.SwitchStmt)
-			deadcodeslice(n.PtrList())
+			deadcodeslice(&n.Cases)
 		}
 
 		if cut {
@@ -4214,24 +4214,24 @@ func deadcodeexpr(n ir.Node) ir.Node {
 	switch n.Op() {
 	case ir.OANDAND:
 		n := n.(*ir.LogicalExpr)
-		n.SetLeft(deadcodeexpr(n.Left()))
-		n.SetRight(deadcodeexpr(n.Right()))
-		if ir.IsConst(n.Left(), constant.Bool) {
-			if ir.BoolVal(n.Left()) {
-				return n.Right() // true && x => x
+		n.X = deadcodeexpr(n.X)
+		n.Y = deadcodeexpr(n.Y)
+		if ir.IsConst(n.X, constant.Bool) {
+			if ir.BoolVal(n.X) {
+				return n.Y // true && x => x
 			} else {
-				return n.Left() // false && x => false
+				return n.X // false && x => false
 			}
 		}
 	case ir.OOROR:
 		n := n.(*ir.LogicalExpr)
-		n.SetLeft(deadcodeexpr(n.Left()))
-		n.SetRight(deadcodeexpr(n.Right()))
-		if ir.IsConst(n.Left(), constant.Bool) {
-			if ir.BoolVal(n.Left()) {
-				return n.Left() // true || x => true
+		n.X = deadcodeexpr(n.X)
+		n.Y = deadcodeexpr(n.Y)
+		if ir.IsConst(n.X, constant.Bool) {
+			if ir.BoolVal(n.X) {
+				return n.X // true || x => true
 			} else {
-				return n.Right() // false || x => x
+				return n.Y // false || x => x
 			}
 		}
 	}
@@ -4247,8 +4247,8 @@ func getIotaValue() int64 {
 		}
 	}
 
-	if Curfn != nil && Curfn.Iota() >= 0 {
-		return Curfn.Iota()
+	if Curfn != nil && Curfn.Iota >= 0 {
+		return Curfn.Iota
 	}
 
 	return -1
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index e11c0eb92c..cf20583042 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -152,14 +152,14 @@ func initUniverse() {
 	for _, s := range &builtinFuncs {
 		s2 := types.BuiltinPkg.Lookup(s.name)
 		def := NewName(s2)
-		def.SetSubOp(s.op)
+		def.BuiltinOp = s.op
 		s2.Def = def
 	}
 
 	for _, s := range &unsafeFuncs {
 		s2 := unsafepkg.Lookup(s.name)
 		def := NewName(s2)
-		def.SetSubOp(s.op)
+		def.BuiltinOp = s.op
 		s2.Def = def
 	}
 
@@ -342,6 +342,6 @@ func finishUniverse() {
 
 	nodfp = NewName(lookup(".fp"))
 	nodfp.SetType(types.Types[types.TINT32])
-	nodfp.SetClass(ir.PPARAM)
+	nodfp.Class_ = ir.PPARAM
 	nodfp.SetUsed(true)
 }
diff --git a/src/cmd/compile/internal/gc/unsafe.go b/src/cmd/compile/internal/gc/unsafe.go
index eeedea396e..cecc8720a9 100644
--- a/src/cmd/compile/internal/gc/unsafe.go
+++ b/src/cmd/compile/internal/gc/unsafe.go
@@ -14,9 +14,9 @@ func evalunsafe(n ir.Node) int64 {
 	switch n.Op() {
 	case ir.OALIGNOF, ir.OSIZEOF:
 		n := n.(*ir.UnaryExpr)
-		n.SetLeft(typecheck(n.Left(), ctxExpr))
-		n.SetLeft(defaultlit(n.Left(), nil))
-		tr := n.Left().Type()
+		n.X = typecheck(n.X, ctxExpr)
+		n.X = defaultlit(n.X, nil)
+		tr := n.X.Type()
 		if tr == nil {
 			return 0
 		}
@@ -29,20 +29,20 @@ func evalunsafe(n ir.Node) int64 {
 	case ir.OOFFSETOF:
 		// must be a selector.
 		n := n.(*ir.UnaryExpr)
-		if n.Left().Op() != ir.OXDOT {
+		if n.X.Op() != ir.OXDOT {
 			base.Errorf("invalid expression %v", n)
 			return 0
 		}
-		sel := n.Left().(*ir.SelectorExpr)
+		sel := n.X.(*ir.SelectorExpr)
 
 		// Remember base of selector to find it back after dot insertion.
 		// Since r->left may be mutated by typechecking, check it explicitly
 		// first to track it correctly.
-		sel.SetLeft(typecheck(sel.Left(), ctxExpr))
-		sbase := sel.Left()
+		sel.X = typecheck(sel.X, ctxExpr)
+		sbase := sel.X
 
 		tsel := typecheck(sel, ctxExpr)
-		n.SetLeft(tsel)
+		n.X = tsel
 		if tsel.Type() == nil {
 			return 0
 		}
@@ -67,15 +67,15 @@ func evalunsafe(n ir.Node) int64 {
 				// but accessing f must not otherwise involve
 				// indirection via embedded pointer types.
 				r := r.(*ir.SelectorExpr)
-				if r.Left() != sbase {
-					base.Errorf("invalid expression %v: selector implies indirection of embedded %v", n, r.Left())
+				if r.X != sbase {
+					base.Errorf("invalid expression %v: selector implies indirection of embedded %v", n, r.X)
 					return 0
 				}
 				fallthrough
 			case ir.ODOT:
 				r := r.(*ir.SelectorExpr)
-				v += r.Offset()
-				next = r.Left()
+				v += r.Offset
+				next = r.X
 			default:
 				ir.Dump("unsafenmagic", tsel)
 				base.Fatalf("impossible %v node after dot insertion", r.Op())
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 91b7a184cf..3fd6c97d68 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -33,14 +33,14 @@ func walk(fn *ir.Func) {
 
 	if base.Flag.W != 0 {
 		s := fmt.Sprintf("\nbefore walk %v", Curfn.Sym())
-		ir.DumpList(s, Curfn.Body())
+		ir.DumpList(s, Curfn.Body)
 	}
 
 	lno := base.Pos
 
 	// Final typecheck for any unused variables.
 	for i, ln := range fn.Dcl {
-		if ln.Op() == ir.ONAME && (ln.Class() == ir.PAUTO || ln.Class() == ir.PAUTOHEAP) {
+		if ln.Op() == ir.ONAME && (ln.Class_ == ir.PAUTO || ln.Class_ == ir.PAUTOHEAP) {
 			ln = typecheck(ln, ctxExpr|ctxAssign).(*ir.Name)
 			fn.Dcl[i] = ln
 		}
@@ -48,13 +48,13 @@ func walk(fn *ir.Func) {
 
 	// Propagate the used flag for typeswitch variables up to the NONAME in its definition.
 	for _, ln := range fn.Dcl {
-		if ln.Op() == ir.ONAME && (ln.Class() == ir.PAUTO || ln.Class() == ir.PAUTOHEAP) && ln.Defn != nil && ln.Defn.Op() == ir.OTYPESW && ln.Used() {
+		if ln.Op() == ir.ONAME && (ln.Class_ == ir.PAUTO || ln.Class_ == ir.PAUTOHEAP) && ln.Defn != nil && ln.Defn.Op() == ir.OTYPESW && ln.Used() {
 			ln.Defn.(*ir.TypeSwitchGuard).Used = true
 		}
 	}
 
 	for _, ln := range fn.Dcl {
-		if ln.Op() != ir.ONAME || (ln.Class() != ir.PAUTO && ln.Class() != ir.PAUTOHEAP) || ln.Sym().Name[0] == '&' || ln.Used() {
+		if ln.Op() != ir.ONAME || (ln.Class_ != ir.PAUTO && ln.Class_ != ir.PAUTOHEAP) || ln.Sym().Name[0] == '&' || ln.Used() {
 			continue
 		}
 		if defn, ok := ln.Defn.(*ir.TypeSwitchGuard); ok {
@@ -72,10 +72,10 @@ func walk(fn *ir.Func) {
 	if base.Errors() > errorsBefore {
 		return
 	}
-	walkstmtlist(Curfn.Body().Slice())
+	walkstmtlist(Curfn.Body.Slice())
 	if base.Flag.W != 0 {
 		s := fmt.Sprintf("after walk %v", Curfn.Sym())
-		ir.DumpList(s, Curfn.Body())
+		ir.DumpList(s, Curfn.Body)
 	}
 
 	zeroResults()
@@ -98,7 +98,7 @@ func walkstmtlist(s []ir.Node) {
 
 func paramoutheap(fn *ir.Func) bool {
 	for _, ln := range fn.Dcl {
-		switch ln.Class() {
+		switch ln.Class_ {
 		case ir.PPARAMOUT:
 			if isParamStackCopy(ln) || ln.Addrtaken() {
 				return true
@@ -189,8 +189,8 @@ func walkstmt(n ir.Node) ir.Node {
 		init := n.Init()
 		n.PtrInit().Set(nil)
 
-		n.SetLeft(walkexpr(n.Left(), &init))
-		call := walkexpr(mkcall1(chanfn("chanrecv1", 2, n.Left().Type()), nil, &init, n.Left(), nodnil()), &init)
+		n.X = walkexpr(n.X, &init)
+		call := walkexpr(mkcall1(chanfn("chanrecv1", 2, n.X.Type()), nil, &init, n.X, nodnil()), &init)
 		return initExpr(init.Slice(), call)
 
 	case ir.OBREAK,
@@ -208,20 +208,20 @@ func walkstmt(n ir.Node) ir.Node {
 
 	case ir.ODCL:
 		n := n.(*ir.Decl)
-		v := n.Left().(*ir.Name)
-		if v.Class() == ir.PAUTOHEAP {
+		v := n.X.(*ir.Name)
+		if v.Class_ == ir.PAUTOHEAP {
 			if base.Flag.CompilingRuntime {
 				base.Errorf("%v escapes to heap, not allowed in runtime", v)
 			}
 			nn := ir.NewAssignStmt(base.Pos, v.Name().Heapaddr, callnew(v.Type()))
-			nn.SetColas(true)
+			nn.Def = true
 			return walkstmt(typecheck(nn, ctxStmt))
 		}
 		return n
 
 	case ir.OBLOCK:
 		n := n.(*ir.BlockStmt)
-		walkstmtlist(n.List().Slice())
+		walkstmtlist(n.List.Slice())
 		return n
 
 	case ir.OCASE:
@@ -247,33 +247,33 @@ func walkstmt(n ir.Node) ir.Node {
 	case ir.OGO:
 		n := n.(*ir.GoDeferStmt)
 		var init ir.Nodes
-		switch call := n.Left(); call.Op() {
+		switch call := n.Call; call.Op() {
 		case ir.OPRINT, ir.OPRINTN:
 			call := call.(*ir.CallExpr)
-			n.SetLeft(wrapCall(call, &init))
+			n.Call = wrapCall(call, &init)
 
 		case ir.ODELETE:
 			call := call.(*ir.CallExpr)
-			if mapfast(call.List().First().Type()) == mapslow {
-				n.SetLeft(wrapCall(call, &init))
+			if mapfast(call.Args.First().Type()) == mapslow {
+				n.Call = wrapCall(call, &init)
 			} else {
-				n.SetLeft(walkexpr(call, &init))
+				n.Call = walkexpr(call, &init)
 			}
 
 		case ir.OCOPY:
 			call := call.(*ir.BinaryExpr)
-			n.SetLeft(copyany(call, &init, true))
+			n.Call = copyany(call, &init, true)
 
 		case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
 			call := call.(*ir.CallExpr)
-			if call.Body().Len() > 0 {
-				n.SetLeft(wrapCall(call, &init))
+			if call.Body.Len() > 0 {
+				n.Call = wrapCall(call, &init)
 			} else {
-				n.SetLeft(walkexpr(call, &init))
+				n.Call = walkexpr(call, &init)
 			}
 
 		default:
-			n.SetLeft(walkexpr(call, &init))
+			n.Call = walkexpr(call, &init)
 		}
 		if init.Len() > 0 {
 			init.Append(n)
@@ -283,41 +283,41 @@ func walkstmt(n ir.Node) ir.Node {
 
 	case ir.OFOR, ir.OFORUNTIL:
 		n := n.(*ir.ForStmt)
-		if n.Left() != nil {
-			walkstmtlist(n.Left().Init().Slice())
-			init := n.Left().Init()
-			n.Left().PtrInit().Set(nil)
-			n.SetLeft(walkexpr(n.Left(), &init))
-			n.SetLeft(initExpr(init.Slice(), n.Left()))
+		if n.Cond != nil {
+			walkstmtlist(n.Cond.Init().Slice())
+			init := n.Cond.Init()
+			n.Cond.PtrInit().Set(nil)
+			n.Cond = walkexpr(n.Cond, &init)
+			n.Cond = initExpr(init.Slice(), n.Cond)
 		}
 
-		n.SetRight(walkstmt(n.Right()))
+		n.Post = walkstmt(n.Post)
 		if n.Op() == ir.OFORUNTIL {
-			walkstmtlist(n.List().Slice())
+			walkstmtlist(n.Late.Slice())
 		}
-		walkstmtlist(n.Body().Slice())
+		walkstmtlist(n.Body.Slice())
 		return n
 
 	case ir.OIF:
 		n := n.(*ir.IfStmt)
-		n.SetLeft(walkexpr(n.Left(), n.PtrInit()))
-		walkstmtlist(n.Body().Slice())
-		walkstmtlist(n.Rlist().Slice())
+		n.Cond = walkexpr(n.Cond, n.PtrInit())
+		walkstmtlist(n.Body.Slice())
+		walkstmtlist(n.Else.Slice())
 		return n
 
 	case ir.ORETURN:
 		n := n.(*ir.ReturnStmt)
 		Curfn.NumReturns++
-		if n.List().Len() == 0 {
+		if n.Results.Len() == 0 {
 			return n
 		}
-		if (hasNamedResults(Curfn) && n.List().Len() > 1) || paramoutheap(Curfn) {
+		if (hasNamedResults(Curfn) && n.Results.Len() > 1) || paramoutheap(Curfn) {
 			// assign to the function out parameters,
 			// so that ascompatee can fix up conflicts
 			var rl []ir.Node
 
 			for _, ln := range Curfn.Dcl {
-				cl := ln.Class()
+				cl := ln.Class_
 				if cl == ir.PAUTO || cl == ir.PAUTOHEAP {
 					break
 				}
@@ -330,23 +330,23 @@ func walkstmt(n ir.Node) ir.Node {
 				}
 			}
 
-			if got, want := n.List().Len(), len(rl); got != want {
+			if got, want := n.Results.Len(), len(rl); got != want {
 				// order should have rewritten multi-value function calls
 				// with explicit OAS2FUNC nodes.
 				base.Fatalf("expected %v return arguments, have %v", want, got)
 			}
 
 			// move function calls out, to make ascompatee's job easier.
-			walkexprlistsafe(n.List().Slice(), n.PtrInit())
+			walkexprlistsafe(n.Results.Slice(), n.PtrInit())
 
-			n.PtrList().Set(ascompatee(n.Op(), rl, n.List().Slice(), n.PtrInit()))
+			n.Results.Set(ascompatee(n.Op(), rl, n.Results.Slice(), n.PtrInit()))
 			return n
 		}
-		walkexprlist(n.List().Slice(), n.PtrInit())
+		walkexprlist(n.Results.Slice(), n.PtrInit())
 
 		// For each return parameter (lhs), assign the corresponding result (rhs).
 		lhs := Curfn.Type().Results()
-		rhs := n.List().Slice()
+		rhs := n.Results.Slice()
 		res := make([]ir.Node, lhs.NumFields())
 		for i, nl := range lhs.FieldSlice() {
 			nname := ir.AsNode(nl.Nname)
@@ -356,7 +356,7 @@ func walkstmt(n ir.Node) ir.Node {
 			a := ir.NewAssignStmt(base.Pos, nname, rhs[i])
 			res[i] = convas(a, n.PtrInit())
 		}
-		n.PtrList().Set(res)
+		n.Results.Set(res)
 		return n
 
 	case ir.ORETJMP:
@@ -499,10 +499,10 @@ func walkexpr(n ir.Node, init *ir.Nodes) ir.Node {
 		base.Fatalf("expression has untyped type: %+v", n)
 	}
 
-	if n.Op() == ir.ONAME && n.(*ir.Name).Class() == ir.PAUTOHEAP {
+	if n.Op() == ir.ONAME && n.(*ir.Name).Class_ == ir.PAUTOHEAP {
 		n := n.(*ir.Name)
 		nn := ir.NewStarExpr(base.Pos, n.Name().Heapaddr)
-		nn.Left().MarkNonNil()
+		nn.X.MarkNonNil()
 		return walkexpr(typecheck(nn, ctxExpr), init)
 	}
 
@@ -556,46 +556,46 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 	case ir.ONOT, ir.ONEG, ir.OPLUS, ir.OBITNOT, ir.OREAL, ir.OIMAG, ir.OSPTR, ir.OITAB, ir.OIDATA:
 		n := n.(*ir.UnaryExpr)
-		n.SetLeft(walkexpr(n.Left(), init))
+		n.X = walkexpr(n.X, init)
 		return n
 
 	case ir.ODOTMETH, ir.ODOTINTER:
 		n := n.(*ir.SelectorExpr)
-		n.SetLeft(walkexpr(n.Left(), init))
+		n.X = walkexpr(n.X, init)
 		return n
 
 	case ir.OADDR:
 		n := n.(*ir.AddrExpr)
-		n.SetLeft(walkexpr(n.Left(), init))
+		n.X = walkexpr(n.X, init)
 		return n
 
 	case ir.ODEREF:
 		n := n.(*ir.StarExpr)
-		n.SetLeft(walkexpr(n.Left(), init))
+		n.X = walkexpr(n.X, init)
 		return n
 
 	case ir.OEFACE, ir.OAND, ir.OANDNOT, ir.OSUB, ir.OMUL, ir.OADD, ir.OOR, ir.OXOR, ir.OLSH, ir.ORSH:
 		n := n.(*ir.BinaryExpr)
-		n.SetLeft(walkexpr(n.Left(), init))
-		n.SetRight(walkexpr(n.Right(), init))
+		n.X = walkexpr(n.X, init)
+		n.Y = walkexpr(n.Y, init)
 		return n
 
 	case ir.ODOT, ir.ODOTPTR:
 		n := n.(*ir.SelectorExpr)
 		usefield(n)
-		n.SetLeft(walkexpr(n.Left(), init))
+		n.X = walkexpr(n.X, init)
 		return n
 
 	case ir.ODOTTYPE, ir.ODOTTYPE2:
 		n := n.(*ir.TypeAssertExpr)
-		n.SetLeft(walkexpr(n.Left(), init))
+		n.X = walkexpr(n.X, init)
 		// Set up interface type addresses for back end.
-		n.SetRight(typename(n.Type()))
+		n.Ntype = typename(n.Type())
 		if n.Op() == ir.ODOTTYPE {
-			n.Right().(*ir.AddrExpr).SetRight(typename(n.Left().Type()))
+			n.Ntype.(*ir.AddrExpr).Alloc = typename(n.X.Type())
 		}
-		if !n.Type().IsInterface() && !n.Left().Type().IsEmptyInterface() {
-			n.PtrList().Set1(itabname(n.Type(), n.Left().Type()))
+		if !n.Type().IsInterface() && !n.X.Type().IsEmptyInterface() {
+			n.Itab.Set1(itabname(n.Type(), n.X.Type()))
 		}
 		return n
 
@@ -603,20 +603,20 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		n := n.(*ir.UnaryExpr)
 		if isRuneCount(n) {
 			// Replace len([]rune(string)) with runtime.countrunes(string).
-			return mkcall("countrunes", n.Type(), init, conv(n.Left().(*ir.ConvExpr).Left(), types.Types[types.TSTRING]))
+			return mkcall("countrunes", n.Type(), init, conv(n.X.(*ir.ConvExpr).X, types.Types[types.TSTRING]))
 		}
 
-		n.SetLeft(walkexpr(n.Left(), init))
+		n.X = walkexpr(n.X, init)
 
 		// replace len(*[10]int) with 10.
 		// delayed until now to preserve side effects.
-		t := n.Left().Type()
+		t := n.X.Type()
 
 		if t.IsPtr() {
 			t = t.Elem()
 		}
 		if t.IsArray() {
-			safeexpr(n.Left(), init)
+			safeexpr(n.X, init)
 			con := origIntConst(n, t.NumElem())
 			con.SetTypecheck(1)
 			return con
@@ -625,8 +625,8 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 	case ir.OCOMPLEX:
 		n := n.(*ir.BinaryExpr)
-		n.SetLeft(walkexpr(n.Left(), init))
-		n.SetRight(walkexpr(n.Right(), init))
+		n.X = walkexpr(n.X, init)
+		n.Y = walkexpr(n.Y, init)
 		return n
 
 	case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
@@ -635,15 +635,15 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 	case ir.OANDAND, ir.OOROR:
 		n := n.(*ir.LogicalExpr)
-		n.SetLeft(walkexpr(n.Left(), init))
+		n.X = walkexpr(n.X, init)
 
 		// cannot put side effects from n.Right on init,
 		// because they cannot run before n.Left is checked.
 		// save elsewhere and store on the eventual n.Right.
 		var ll ir.Nodes
 
-		n.SetRight(walkexpr(n.Right(), &ll))
-		n.SetRight(initExpr(ll.Slice(), n.Right()))
+		n.Y = walkexpr(n.Y, &ll)
+		n.Y = initExpr(ll.Slice(), n.Y)
 		return n
 
 	case ir.OPRINT, ir.OPRINTN:
@@ -651,7 +651,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 	case ir.OPANIC:
 		n := n.(*ir.UnaryExpr)
-		return mkcall("gopanic", nil, init, n.Left())
+		return mkcall("gopanic", nil, init, n.X)
 
 	case ir.ORECOVER:
 		n := n.(*ir.CallExpr)
@@ -667,24 +667,24 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			markUsedIfaceMethod(n)
 		}
 
-		if n.Op() == ir.OCALLFUNC && n.Left().Op() == ir.OCLOSURE {
+		if n.Op() == ir.OCALLFUNC && n.X.Op() == ir.OCLOSURE {
 			// Transform direct call of a closure to call of a normal function.
 			// transformclosure already did all preparation work.
 
 			// Prepend captured variables to argument list.
-			clo := n.Left().(*ir.ClosureExpr)
-			n.PtrList().Prepend(clo.Func().ClosureEnter.Slice()...)
-			clo.Func().ClosureEnter.Set(nil)
+			clo := n.X.(*ir.ClosureExpr)
+			n.Args.Prepend(clo.Func.ClosureEnter.Slice()...)
+			clo.Func.ClosureEnter.Set(nil)
 
 			// Replace OCLOSURE with ONAME/PFUNC.
-			n.SetLeft(clo.Func().Nname)
+			n.X = clo.Func.Nname
 
 			// Update type of OCALLFUNC node.
 			// Output arguments had not changed, but their offsets could.
-			if n.Left().Type().NumResults() == 1 {
-				n.SetType(n.Left().Type().Results().Field(0).Type)
+			if n.X.Type().NumResults() == 1 {
+				n.SetType(n.X.Type().Results().Field(0).Type)
 			} else {
-				n.SetType(n.Left().Type().Results())
+				n.SetType(n.X.Type().Results())
 			}
 		}
 
@@ -698,10 +698,10 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		switch n.Op() {
 		case ir.OAS:
 			n := n.(*ir.AssignStmt)
-			left, right = n.Left(), n.Right()
+			left, right = n.X, n.Y
 		case ir.OASOP:
 			n := n.(*ir.AssignOpStmt)
-			left, right = n.Left(), n.Right()
+			left, right = n.X, n.Y
 		}
 
 		// Recognize m[k] = append(m[k], ...) so we can reuse
@@ -710,22 +710,22 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		if left.Op() == ir.OINDEXMAP && right.Op() == ir.OAPPEND {
 			left := left.(*ir.IndexExpr)
 			mapAppend = right.(*ir.CallExpr)
-			if !samesafeexpr(left, mapAppend.List().First()) {
-				base.Fatalf("not same expressions: %v != %v", left, mapAppend.List().First())
+			if !samesafeexpr(left, mapAppend.Args.First()) {
+				base.Fatalf("not same expressions: %v != %v", left, mapAppend.Args.First())
 			}
 		}
 
 		left = walkexpr(left, init)
 		left = safeexpr(left, init)
 		if mapAppend != nil {
-			mapAppend.List().SetFirst(left)
+			mapAppend.Args.SetFirst(left)
 		}
 
 		if n.Op() == ir.OASOP {
 			// Rewrite x op= y into x = x op y.
-			n = ir.NewAssignStmt(base.Pos, left, typecheck(ir.NewBinaryExpr(base.Pos, n.(*ir.AssignOpStmt).SubOp(), left, right), ctxExpr))
+			n = ir.NewAssignStmt(base.Pos, left, typecheck(ir.NewBinaryExpr(base.Pos, n.(*ir.AssignOpStmt).AsOp, left, right), ctxExpr))
 		} else {
-			n.(*ir.AssignStmt).SetLeft(left)
+			n.(*ir.AssignStmt).X = left
 		}
 		as := n.(*ir.AssignStmt)
 
@@ -733,32 +733,32 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			return ir.NewBlockStmt(as.Pos(), nil)
 		}
 
-		if as.Right() == nil {
+		if as.Y == nil {
 			// TODO(austin): Check all "implicit zeroing"
 			return as
 		}
 
-		if !instrumenting && isZero(as.Right()) {
+		if !instrumenting && isZero(as.Y) {
 			return as
 		}
 
-		switch as.Right().Op() {
+		switch as.Y.Op() {
 		default:
-			as.SetRight(walkexpr(as.Right(), init))
+			as.Y = walkexpr(as.Y, init)
 
 		case ir.ORECV:
 			// x = <-c; as.Left is x, as.Right.Left is c.
 			// order.stmt made sure x is addressable.
-			recv := as.Right().(*ir.UnaryExpr)
-			recv.SetLeft(walkexpr(recv.Left(), init))
+			recv := as.Y.(*ir.UnaryExpr)
+			recv.X = walkexpr(recv.X, init)
 
-			n1 := nodAddr(as.Left())
-			r := recv.Left() // the channel
+			n1 := nodAddr(as.X)
+			r := recv.X // the channel
 			return mkcall1(chanfn("chanrecv1", 2, r.Type()), nil, init, r, n1)
 
 		case ir.OAPPEND:
 			// x = append(...)
-			call := as.Right().(*ir.CallExpr)
+			call := as.Y.(*ir.CallExpr)
 			if call.Type().Elem().NotInHeap() {
 				base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", call.Type().Elem())
 			}
@@ -767,24 +767,24 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			case isAppendOfMake(call):
 				// x = append(y, make([]T, y)...)
 				r = extendslice(call, init)
-			case call.IsDDD():
+			case call.IsDDD:
 				r = appendslice(call, init) // also works for append(slice, string).
 			default:
 				r = walkappend(call, init, as)
 			}
-			as.SetRight(r)
+			as.Y = r
 			if r.Op() == ir.OAPPEND {
 				// Left in place for back end.
 				// Do not add a new write barrier.
 				// Set up address of type for back end.
-				r.(*ir.CallExpr).SetLeft(typename(r.Type().Elem()))
+				r.(*ir.CallExpr).X = typename(r.Type().Elem())
 				return as
 			}
 			// Otherwise, lowered for race detector.
 			// Treat as ordinary assignment.
 		}
 
-		if as.Left() != nil && as.Right() != nil {
+		if as.X != nil && as.Y != nil {
 			return convas(as, init)
 		}
 		return as
@@ -792,26 +792,26 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 	case ir.OAS2:
 		n := n.(*ir.AssignListStmt)
 		init.AppendNodes(n.PtrInit())
-		walkexprlistsafe(n.List().Slice(), init)
-		walkexprlistsafe(n.Rlist().Slice(), init)
-		return liststmt(ascompatee(ir.OAS, n.List().Slice(), n.Rlist().Slice(), init))
+		walkexprlistsafe(n.Lhs.Slice(), init)
+		walkexprlistsafe(n.Rhs.Slice(), init)
+		return liststmt(ascompatee(ir.OAS, n.Lhs.Slice(), n.Rhs.Slice(), init))
 
 	// a,b,... = fn()
 	case ir.OAS2FUNC:
 		n := n.(*ir.AssignListStmt)
 		init.AppendNodes(n.PtrInit())
 
-		r := n.Rlist().First()
-		walkexprlistsafe(n.List().Slice(), init)
+		r := n.Rhs.First()
+		walkexprlistsafe(n.Lhs.Slice(), init)
 		r = walkexpr(r, init)
 
 		if IsIntrinsicCall(r.(*ir.CallExpr)) {
-			n.PtrRlist().Set1(r)
+			n.Rhs.Set1(r)
 			return n
 		}
 		init.Append(r)
 
-		ll := ascompatet(n.List(), r.Type())
+		ll := ascompatet(n.Lhs, r.Type())
 		return liststmt(ll)
 
 	// x, y = <-c
@@ -820,18 +820,18 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		n := n.(*ir.AssignListStmt)
 		init.AppendNodes(n.PtrInit())
 
-		r := n.Rlist().First().(*ir.UnaryExpr) // recv
-		walkexprlistsafe(n.List().Slice(), init)
-		r.SetLeft(walkexpr(r.Left(), init))
+		r := n.Rhs.First().(*ir.UnaryExpr) // recv
+		walkexprlistsafe(n.Lhs.Slice(), init)
+		r.X = walkexpr(r.X, init)
 		var n1 ir.Node
-		if ir.IsBlank(n.List().First()) {
+		if ir.IsBlank(n.Lhs.First()) {
 			n1 = nodnil()
 		} else {
-			n1 = nodAddr(n.List().First())
+			n1 = nodAddr(n.Lhs.First())
 		}
-		fn := chanfn("chanrecv2", 2, r.Left().Type())
-		ok := n.List().Second()
-		call := mkcall1(fn, types.Types[types.TBOOL], init, r.Left(), n1)
+		fn := chanfn("chanrecv2", 2, r.X.Type())
+		ok := n.Lhs.Second()
+		call := mkcall1(fn, types.Types[types.TBOOL], init, r.X, n1)
 		return typecheck(ir.NewAssignStmt(base.Pos, ok, call), ctxStmt)
 
 	// a,b = m[i]
@@ -839,21 +839,21 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		n := n.(*ir.AssignListStmt)
 		init.AppendNodes(n.PtrInit())
 
-		r := n.Rlist().First().(*ir.IndexExpr)
-		walkexprlistsafe(n.List().Slice(), init)
-		r.SetLeft(walkexpr(r.Left(), init))
-		r.SetRight(walkexpr(r.Right(), init))
-		t := r.Left().Type()
+		r := n.Rhs.First().(*ir.IndexExpr)
+		walkexprlistsafe(n.Lhs.Slice(), init)
+		r.X = walkexpr(r.X, init)
+		r.Index = walkexpr(r.Index, init)
+		t := r.X.Type()
 
 		fast := mapfast(t)
 		var key ir.Node
 		if fast != mapslow {
 			// fast versions take key by value
-			key = r.Right()
+			key = r.Index
 		} else {
 			// standard version takes key by reference
 			// order.expr made sure key is addressable.
-			key = nodAddr(r.Right())
+			key = nodAddr(r.Index)
 		}
 
 		// from:
@@ -861,25 +861,25 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		// to:
 		//   var,b = mapaccess2*(t, m, i)
 		//   a = *var
-		a := n.List().First()
+		a := n.Lhs.First()
 
 		var call *ir.CallExpr
 		if w := t.Elem().Width; w <= zeroValSize {
 			fn := mapfn(mapaccess2[fast], t)
-			call = mkcall1(fn, fn.Type().Results(), init, typename(t), r.Left(), key)
+			call = mkcall1(fn, fn.Type().Results(), init, typename(t), r.X, key)
 		} else {
 			fn := mapfn("mapaccess2_fat", t)
 			z := zeroaddr(w)
-			call = mkcall1(fn, fn.Type().Results(), init, typename(t), r.Left(), key, z)
+			call = mkcall1(fn, fn.Type().Results(), init, typename(t), r.X, key, z)
 		}
 
 		// mapaccess2* returns a typed bool, but due to spec changes,
 		// the boolean result of i.(T) is now untyped so we make it the
 		// same type as the variable on the lhs.
-		if ok := n.List().Second(); !ir.IsBlank(ok) && ok.Type().IsBoolean() {
+		if ok := n.Lhs.Second(); !ir.IsBlank(ok) && ok.Type().IsBoolean() {
 			call.Type().Field(1).Type = ok.Type()
 		}
-		n.PtrRlist().Set1(call)
+		n.Rhs.Set1(call)
 		n.SetOp(ir.OAS2FUNC)
 
 		// don't generate a = *var if a is _
@@ -891,7 +891,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		var_.SetTypecheck(1)
 		var_.MarkNonNil() // mapaccess always returns a non-nil pointer
 
-		n.List().SetFirst(var_)
+		n.Lhs.SetFirst(var_)
 		init.Append(walkexpr(n, init))
 
 		as := ir.NewAssignStmt(base.Pos, a, ir.NewStarExpr(base.Pos, var_))
@@ -900,8 +900,8 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 	case ir.ODELETE:
 		n := n.(*ir.CallExpr)
 		init.AppendNodes(n.PtrInit())
-		map_ := n.List().First()
-		key := n.List().Second()
+		map_ := n.Args.First()
+		key := n.Args.Second()
 		map_ = walkexpr(map_, init)
 		key = walkexpr(key, init)
 
@@ -915,15 +915,15 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 	case ir.OAS2DOTTYPE:
 		n := n.(*ir.AssignListStmt)
-		walkexprlistsafe(n.List().Slice(), init)
-		n.PtrRlist().SetIndex(0, walkexpr(n.Rlist().First(), init))
+		walkexprlistsafe(n.Lhs.Slice(), init)
+		(&n.Rhs).SetIndex(0, walkexpr(n.Rhs.First(), init))
 		return n
 
 	case ir.OCONVIFACE:
 		n := n.(*ir.ConvExpr)
-		n.SetLeft(walkexpr(n.Left(), init))
+		n.X = walkexpr(n.X, init)
 
-		fromType := n.Left().Type()
+		fromType := n.X.Type()
 		toType := n.Type()
 
 		if !fromType.IsInterface() && !ir.IsBlank(Curfn.Nname) { // skip unnamed functions (func _())
@@ -940,7 +940,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 		// Optimize convT2E or convT2I as a two-word copy when T is pointer-shaped.
 		if isdirectiface(fromType) {
-			l := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), n.Left())
+			l := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), n.X)
 			l.SetType(toType)
 			l.SetTypecheck(n.Typecheck())
 			return l
@@ -948,12 +948,12 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 		if staticuint64s == nil {
 			staticuint64s = NewName(Runtimepkg.Lookup("staticuint64s"))
-			staticuint64s.SetClass(ir.PEXTERN)
+			staticuint64s.Class_ = ir.PEXTERN
 			// The actual type is [256]uint64, but we use [256*8]uint8 so we can address
 			// individual bytes.
 			staticuint64s.SetType(types.NewArray(types.Types[types.TUINT8], 256*8))
 			zerobase = NewName(Runtimepkg.Lookup("zerobase"))
-			zerobase.SetClass(ir.PEXTERN)
+			zerobase.Class_ = ir.PEXTERN
 			zerobase.SetType(types.Types[types.TUINTPTR])
 		}
 
@@ -964,27 +964,27 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		switch {
 		case fromType.Size() == 0:
 			// n.Left is zero-sized. Use zerobase.
-			cheapexpr(n.Left(), init) // Evaluate n.Left for side-effects. See issue 19246.
+			cheapexpr(n.X, init) // Evaluate n.Left for side-effects. See issue 19246.
 			value = zerobase
 		case fromType.IsBoolean() || (fromType.Size() == 1 && fromType.IsInteger()):
 			// n.Left is a bool/byte. Use staticuint64s[n.Left * 8] on little-endian
 			// and staticuint64s[n.Left * 8 + 7] on big-endian.
-			n.SetLeft(cheapexpr(n.Left(), init))
+			n.X = cheapexpr(n.X, init)
 			// byteindex widens n.Left so that the multiplication doesn't overflow.
-			index := ir.NewBinaryExpr(base.Pos, ir.OLSH, byteindex(n.Left()), nodintconst(3))
+			index := ir.NewBinaryExpr(base.Pos, ir.OLSH, byteindex(n.X), nodintconst(3))
 			if thearch.LinkArch.ByteOrder == binary.BigEndian {
 				index = ir.NewBinaryExpr(base.Pos, ir.OADD, index, nodintconst(7))
 			}
 			xe := ir.NewIndexExpr(base.Pos, staticuint64s, index)
 			xe.SetBounded(true)
 			value = xe
-		case n.Left().Op() == ir.ONAME && n.Left().(*ir.Name).Class() == ir.PEXTERN && n.Left().(*ir.Name).Readonly():
+		case n.X.Op() == ir.ONAME && n.X.(*ir.Name).Class_ == ir.PEXTERN && n.X.(*ir.Name).Readonly():
 			// n.Left is a readonly global; use it directly.
-			value = n.Left()
+			value = n.X
 		case !fromType.IsInterface() && n.Esc() == EscNone && fromType.Width <= 1024:
 			// n.Left does not escape. Use a stack temporary initialized to n.Left.
 			value = temp(fromType)
-			init.Append(typecheck(ir.NewAssignStmt(base.Pos, value, n.Left()), ctxStmt))
+			init.Append(typecheck(ir.NewAssignStmt(base.Pos, value, n.X), ctxStmt))
 		}
 
 		if value != nil {
@@ -1005,7 +1005,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		if toType.IsEmptyInterface() && fromType.IsInterface() && !fromType.IsEmptyInterface() {
 			// Evaluate the input interface.
 			c := temp(fromType)
-			init.Append(ir.NewAssignStmt(base.Pos, c, n.Left()))
+			init.Append(ir.NewAssignStmt(base.Pos, c, n.X))
 
 			// Get the itab out of the interface.
 			tmp := temp(types.NewPtr(types.Types[types.TUINT8]))
@@ -1013,7 +1013,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 			// Get the type out of the itab.
 			nif := ir.NewIfStmt(base.Pos, typecheck(ir.NewBinaryExpr(base.Pos, ir.ONE, tmp, nodnil()), ctxExpr), nil, nil)
-			nif.PtrBody().Set1(ir.NewAssignStmt(base.Pos, tmp, itabType(tmp)))
+			nif.Body.Set1(ir.NewAssignStmt(base.Pos, tmp, itabType(tmp)))
 			init.Append(nif)
 
 			// Build the result.
@@ -1034,7 +1034,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			fn = substArgTypes(fn, fromType)
 			dowidth(fn.Type())
 			call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
-			call.PtrList().Set1(n.Left())
+			call.Args.Set1(n.X)
 			e := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), safeexpr(walkexpr(typecheck(call, ctxExpr), init), init))
 			e.SetType(toType)
 			e.SetTypecheck(1)
@@ -1050,7 +1050,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			tab = typeword()
 		}
 
-		v := n.Left()
+		v := n.X
 		if needsaddr {
 			// Types of large or unknown size are passed by reference.
 			// Orderexpr arranged for n.Left to be a temporary for all
@@ -1069,41 +1069,41 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		fn = substArgTypes(fn, fromType, toType)
 		dowidth(fn.Type())
 		call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
-		call.PtrList().Set2(tab, v)
+		call.Args.Set2(tab, v)
 		return walkexpr(typecheck(call, ctxExpr), init)
 
 	case ir.OCONV, ir.OCONVNOP:
 		n := n.(*ir.ConvExpr)
-		n.SetLeft(walkexpr(n.Left(), init))
-		if n.Op() == ir.OCONVNOP && n.Type() == n.Left().Type() {
-			return n.Left()
+		n.X = walkexpr(n.X, init)
+		if n.Op() == ir.OCONVNOP && n.Type() == n.X.Type() {
+			return n.X
 		}
 		if n.Op() == ir.OCONVNOP && checkPtr(Curfn, 1) {
-			if n.Type().IsPtr() && n.Left().Type().IsUnsafePtr() { // unsafe.Pointer to *T
+			if n.Type().IsPtr() && n.X.Type().IsUnsafePtr() { // unsafe.Pointer to *T
 				return walkCheckPtrAlignment(n, init, nil)
 			}
-			if n.Type().IsUnsafePtr() && n.Left().Type().IsUintptr() { // uintptr to unsafe.Pointer
+			if n.Type().IsUnsafePtr() && n.X.Type().IsUintptr() { // uintptr to unsafe.Pointer
 				return walkCheckPtrArithmetic(n, init)
 			}
 		}
-		param, result := rtconvfn(n.Left().Type(), n.Type())
+		param, result := rtconvfn(n.X.Type(), n.Type())
 		if param == types.Txxx {
 			return n
 		}
 		fn := types.BasicTypeNames[param] + "to" + types.BasicTypeNames[result]
-		return conv(mkcall(fn, types.Types[result], init, conv(n.Left(), types.Types[param])), n.Type())
+		return conv(mkcall(fn, types.Types[result], init, conv(n.X, types.Types[param])), n.Type())
 
 	case ir.ODIV, ir.OMOD:
 		n := n.(*ir.BinaryExpr)
-		n.SetLeft(walkexpr(n.Left(), init))
-		n.SetRight(walkexpr(n.Right(), init))
+		n.X = walkexpr(n.X, init)
+		n.Y = walkexpr(n.Y, init)
 
 		// rewrite complex div into function call.
-		et := n.Left().Type().Kind()
+		et := n.X.Type().Kind()
 
 		if isComplex[et] && n.Op() == ir.ODIV {
 			t := n.Type()
-			call := mkcall("complex128div", types.Types[types.TCOMPLEX128], init, conv(n.Left(), types.Types[types.TCOMPLEX128]), conv(n.Right(), types.Types[types.TCOMPLEX128]))
+			call := mkcall("complex128div", types.Types[types.TCOMPLEX128], init, conv(n.X, types.Types[types.TCOMPLEX128]), conv(n.Y, types.Types[types.TCOMPLEX128]))
 			return conv(call, t)
 		}
 
@@ -1116,12 +1116,12 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		// TODO: Remove this code once we can introduce
 		// runtime calls late in SSA processing.
 		if Widthreg < 8 && (et == types.TINT64 || et == types.TUINT64) {
-			if n.Right().Op() == ir.OLITERAL {
+			if n.Y.Op() == ir.OLITERAL {
 				// Leave div/mod by constant powers of 2 or small 16-bit constants.
 				// The SSA backend will handle those.
 				switch et {
 				case types.TINT64:
-					c := ir.Int64Val(n.Right())
+					c := ir.Int64Val(n.Y)
 					if c < 0 {
 						c = -c
 					}
@@ -1129,7 +1129,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 						return n
 					}
 				case types.TUINT64:
-					c := ir.Uint64Val(n.Right())
+					c := ir.Uint64Val(n.Y)
 					if c < 1<<16 {
 						return n
 					}
@@ -1149,49 +1149,49 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			} else {
 				fn += "mod"
 			}
-			return mkcall(fn, n.Type(), init, conv(n.Left(), types.Types[et]), conv(n.Right(), types.Types[et]))
+			return mkcall(fn, n.Type(), init, conv(n.X, types.Types[et]), conv(n.Y, types.Types[et]))
 		}
 		return n
 
 	case ir.OINDEX:
 		n := n.(*ir.IndexExpr)
-		n.SetLeft(walkexpr(n.Left(), init))
+		n.X = walkexpr(n.X, init)
 
 		// save the original node for bounds checking elision.
 		// If it was a ODIV/OMOD walk might rewrite it.
-		r := n.Right()
+		r := n.Index
 
-		n.SetRight(walkexpr(n.Right(), init))
+		n.Index = walkexpr(n.Index, init)
 
 		// if range of type cannot exceed static array bound,
 		// disable bounds check.
 		if n.Bounded() {
 			return n
 		}
-		t := n.Left().Type()
+		t := n.X.Type()
 		if t != nil && t.IsPtr() {
 			t = t.Elem()
 		}
 		if t.IsArray() {
 			n.SetBounded(bounded(r, t.NumElem()))
-			if base.Flag.LowerM != 0 && n.Bounded() && !ir.IsConst(n.Right(), constant.Int) {
+			if base.Flag.LowerM != 0 && n.Bounded() && !ir.IsConst(n.Index, constant.Int) {
 				base.Warn("index bounds check elided")
 			}
-			if smallintconst(n.Right()) && !n.Bounded() {
+			if smallintconst(n.Index) && !n.Bounded() {
 				base.Errorf("index out of bounds")
 			}
-		} else if ir.IsConst(n.Left(), constant.String) {
-			n.SetBounded(bounded(r, int64(len(ir.StringVal(n.Left())))))
-			if base.Flag.LowerM != 0 && n.Bounded() && !ir.IsConst(n.Right(), constant.Int) {
+		} else if ir.IsConst(n.X, constant.String) {
+			n.SetBounded(bounded(r, int64(len(ir.StringVal(n.X)))))
+			if base.Flag.LowerM != 0 && n.Bounded() && !ir.IsConst(n.Index, constant.Int) {
 				base.Warn("index bounds check elided")
 			}
-			if smallintconst(n.Right()) && !n.Bounded() {
+			if smallintconst(n.Index) && !n.Bounded() {
 				base.Errorf("index out of bounds")
 			}
 		}
 
-		if ir.IsConst(n.Right(), constant.Int) {
-			if v := n.Right().Val(); constant.Sign(v) < 0 || doesoverflow(v, types.Types[types.TINT]) {
+		if ir.IsConst(n.Index, constant.Int) {
+			if v := n.Index.Val(); constant.Sign(v) < 0 || doesoverflow(v, types.Types[types.TINT]) {
 				base.Errorf("index out of bounds")
 			}
 		}
@@ -1200,13 +1200,13 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 	case ir.OINDEXMAP:
 		// Replace m[k] with *map{access1,assign}(maptype, m, &k)
 		n := n.(*ir.IndexExpr)
-		n.SetLeft(walkexpr(n.Left(), init))
-		n.SetRight(walkexpr(n.Right(), init))
-		map_ := n.Left()
-		key := n.Right()
+		n.X = walkexpr(n.X, init)
+		n.Index = walkexpr(n.Index, init)
+		map_ := n.X
+		key := n.Index
 		t := map_.Type()
 		var call *ir.CallExpr
-		if n.IndexMapLValue() {
+		if n.Assigned {
 			// This m[k] expression is on the left-hand side of an assignment.
 			fast := mapfast(t)
 			if fast == mapslow {
@@ -1244,20 +1244,20 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 	case ir.OSLICEHEADER:
 		n := n.(*ir.SliceHeaderExpr)
-		n.SetLeft(walkexpr(n.Left(), init))
-		n.List().SetFirst(walkexpr(n.List().First(), init))
-		n.List().SetSecond(walkexpr(n.List().Second(), init))
+		n.Ptr = walkexpr(n.Ptr, init)
+		n.LenCap.SetFirst(walkexpr(n.LenCap.First(), init))
+		n.LenCap.SetSecond(walkexpr(n.LenCap.Second(), init))
 		return n
 
 	case ir.OSLICE, ir.OSLICEARR, ir.OSLICESTR, ir.OSLICE3, ir.OSLICE3ARR:
 		n := n.(*ir.SliceExpr)
 
-		checkSlice := checkPtr(Curfn, 1) && n.Op() == ir.OSLICE3ARR && n.Left().Op() == ir.OCONVNOP && n.Left().(*ir.ConvExpr).Left().Type().IsUnsafePtr()
+		checkSlice := checkPtr(Curfn, 1) && n.Op() == ir.OSLICE3ARR && n.X.Op() == ir.OCONVNOP && n.X.(*ir.ConvExpr).X.Type().IsUnsafePtr()
 		if checkSlice {
-			conv := n.Left().(*ir.ConvExpr)
-			conv.SetLeft(walkexpr(conv.Left(), init))
+			conv := n.X.(*ir.ConvExpr)
+			conv.X = walkexpr(conv.X, init)
 		} else {
-			n.SetLeft(walkexpr(n.Left(), init))
+			n.X = walkexpr(n.X, init)
 		}
 
 		low, high, max := n.SliceBounds()
@@ -1270,11 +1270,11 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		max = walkexpr(max, init)
 		n.SetSliceBounds(low, high, max)
 		if checkSlice {
-			n.SetLeft(walkCheckPtrAlignment(n.Left().(*ir.ConvExpr), init, max))
+			n.X = walkCheckPtrAlignment(n.X.(*ir.ConvExpr), init, max)
 		}
 
 		if n.Op().IsSlice3() {
-			if max != nil && max.Op() == ir.OCAP && samesafeexpr(n.Left(), max.(*ir.UnaryExpr).Left()) {
+			if max != nil && max.Op() == ir.OCAP && samesafeexpr(n.X, max.(*ir.UnaryExpr).X) {
 				// Reduce x[i:j:cap(x)] to x[i:j].
 				if n.Op() == ir.OSLICE3 {
 					n.SetOp(ir.OSLICE)
@@ -1317,14 +1317,14 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		// cannot use chanfn - closechan takes any, not chan any
 		n := n.(*ir.UnaryExpr)
 		fn := syslook("closechan")
-		fn = substArgTypes(fn, n.Left().Type())
-		return mkcall1(fn, nil, init, n.Left())
+		fn = substArgTypes(fn, n.X.Type())
+		return mkcall1(fn, nil, init, n.X)
 
 	case ir.OMAKECHAN:
 		// When size fits into int, use makechan instead of
 		// makechan64, which is faster and shorter on 32 bit platforms.
 		n := n.(*ir.MakeExpr)
-		size := n.Left()
+		size := n.Len
 		fnname := "makechan64"
 		argtype := types.Types[types.TINT64]
 
@@ -1342,7 +1342,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		n := n.(*ir.MakeExpr)
 		t := n.Type()
 		hmapType := hmap(t)
-		hint := n.Left()
+		hint := n.Len
 
 		// var h *hmap
 		var h ir.Node
@@ -1373,11 +1373,11 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 				// }
 
 				nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OLE, hint, nodintconst(BUCKETSIZE)), nil, nil)
-				nif.SetLikely(true)
+				nif.Likely = true
 
 				// var bv bmap
 				bv := temp(bmap(t))
-				nif.PtrBody().Append(ir.NewAssignStmt(base.Pos, bv, nil))
+				nif.Body.Append(ir.NewAssignStmt(base.Pos, bv, nil))
 
 				// b = &bv
 				b := nodAddr(bv)
@@ -1385,7 +1385,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 				// h.buckets = b
 				bsym := hmapType.Field(5).Sym // hmap.buckets see reflect.go:hmap
 				na := ir.NewAssignStmt(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, h, bsym), b)
-				nif.PtrBody().Append(na)
+				nif.Body.Append(na)
 				appendWalkStmt(init, nif)
 			}
 		}
@@ -1442,8 +1442,8 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 	case ir.OMAKESLICE:
 		n := n.(*ir.MakeExpr)
-		l := n.Left()
-		r := n.Right()
+		l := n.Len
+		r := n.Cap
 		if r == nil {
 			r = safeexpr(l, init)
 			l = r
@@ -1472,8 +1472,8 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			// }
 			nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGT, conv(l, types.Types[types.TUINT64]), nodintconst(i)), nil, nil)
 			niflen := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OLT, l, nodintconst(0)), nil, nil)
-			niflen.PtrBody().Set1(mkcall("panicmakeslicelen", nil, init))
-			nif.PtrBody().Append(niflen, mkcall("panicmakeslicecap", nil, init))
+			niflen.Body.Set1(mkcall("panicmakeslicelen", nil, init))
+			nif.Body.Append(niflen, mkcall("panicmakeslicecap", nil, init))
 			init.Append(typecheck(nif, ctxStmt))
 
 			t = types.NewArray(t.Elem(), i) // [r]T
@@ -1507,9 +1507,9 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		m.SetType(t)
 
 		fn := syslook(fnname)
-		m.SetLeft(mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), conv(len, argtype), conv(cap, argtype)))
-		m.Left().MarkNonNil()
-		m.PtrList().Set2(conv(len, types.Types[types.TINT]), conv(cap, types.Types[types.TINT]))
+		m.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), conv(len, argtype), conv(cap, argtype))
+		m.Ptr.MarkNonNil()
+		m.LenCap.Set2(conv(len, types.Types[types.TINT]), conv(cap, types.Types[types.TINT]))
 		return walkexpr(typecheck(m, ctxExpr), init)
 
 	case ir.OMAKESLICECOPY:
@@ -1523,9 +1523,9 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", t.Elem())
 		}
 
-		length := conv(n.Left(), types.Types[types.TINT])
-		copylen := ir.NewUnaryExpr(base.Pos, ir.OLEN, n.Right())
-		copyptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, n.Right())
+		length := conv(n.Len, types.Types[types.TINT])
+		copylen := ir.NewUnaryExpr(base.Pos, ir.OLEN, n.Cap)
+		copyptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, n.Cap)
 
 		if !t.Elem().HasPointers() && n.Bounded() {
 			// When len(to)==len(from) and elements have no pointers:
@@ -1539,9 +1539,9 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			// instantiate mallocgc(size uintptr, typ *byte, needszero bool) unsafe.Pointer
 			fn := syslook("mallocgc")
 			sh := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
-			sh.SetLeft(mkcall1(fn, types.Types[types.TUNSAFEPTR], init, size, nodnil(), nodbool(false)))
-			sh.Left().MarkNonNil()
-			sh.PtrList().Set2(length, length)
+			sh.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, size, nodnil(), nodbool(false))
+			sh.Ptr.MarkNonNil()
+			sh.LenCap.Set2(length, length)
 			sh.SetType(t)
 
 			s := temp(t)
@@ -1561,9 +1561,9 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		// instantiate makeslicecopy(typ *byte, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointer
 		fn := syslook("makeslicecopy")
 		s := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
-		s.SetLeft(mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), length, copylen, conv(copyptr, types.Types[types.TUNSAFEPTR])))
-		s.Left().MarkNonNil()
-		s.PtrList().Set2(length, length)
+		s.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), length, copylen, conv(copyptr, types.Types[types.TUNSAFEPTR]))
+		s.Ptr.MarkNonNil()
+		s.LenCap.Set2(length, length)
 		s.SetType(t)
 		return walkexpr(typecheck(s, ctxExpr), init)
 
@@ -1575,7 +1575,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			a = nodAddr(temp(t))
 		}
 		// intstring(*[4]byte, rune)
-		return mkcall("intstring", n.Type(), init, a, conv(n.Left(), types.Types[types.TINT64]))
+		return mkcall("intstring", n.Type(), init, a, conv(n.X, types.Types[types.TINT64]))
 
 	case ir.OBYTES2STR, ir.ORUNES2STR:
 		n := n.(*ir.ConvExpr)
@@ -1587,29 +1587,29 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		}
 		if n.Op() == ir.ORUNES2STR {
 			// slicerunetostring(*[32]byte, []rune) string
-			return mkcall("slicerunetostring", n.Type(), init, a, n.Left())
+			return mkcall("slicerunetostring", n.Type(), init, a, n.X)
 		}
 		// slicebytetostring(*[32]byte, ptr *byte, n int) string
-		n.SetLeft(cheapexpr(n.Left(), init))
-		ptr, len := backingArrayPtrLen(n.Left())
+		n.X = cheapexpr(n.X, init)
+		ptr, len := backingArrayPtrLen(n.X)
 		return mkcall("slicebytetostring", n.Type(), init, a, ptr, len)
 
 	case ir.OBYTES2STRTMP:
 		n := n.(*ir.ConvExpr)
-		n.SetLeft(walkexpr(n.Left(), init))
+		n.X = walkexpr(n.X, init)
 		if !instrumenting {
 			// Let the backend handle OBYTES2STRTMP directly
 			// to avoid a function call to slicebytetostringtmp.
 			return n
 		}
 		// slicebytetostringtmp(ptr *byte, n int) string
-		n.SetLeft(cheapexpr(n.Left(), init))
-		ptr, len := backingArrayPtrLen(n.Left())
+		n.X = cheapexpr(n.X, init)
+		ptr, len := backingArrayPtrLen(n.X)
 		return mkcall("slicebytetostringtmp", n.Type(), init, ptr, len)
 
 	case ir.OSTR2BYTES:
 		n := n.(*ir.ConvExpr)
-		s := n.Left()
+		s := n.X
 		if ir.IsConst(s, constant.String) {
 			sc := ir.StringVal(s)
 
@@ -1655,7 +1655,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		// The only such case today is:
 		// for i, c := range []byte(string)
 		n := n.(*ir.ConvExpr)
-		n.SetLeft(walkexpr(n.Left(), init))
+		n.X = walkexpr(n.X, init)
 		return n
 
 	case ir.OSTR2RUNES:
@@ -1667,7 +1667,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			a = nodAddr(temp(t))
 		}
 		// stringtoslicerune(*[32]rune, string) []rune
-		return mkcall("stringtoslicerune", n.Type(), init, a, conv(n.Left(), types.Types[types.TSTRING]))
+		return mkcall("stringtoslicerune", n.Type(), init, a, conv(n.X, types.Types[types.TSTRING]))
 
 	case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT, ir.OSTRUCTLIT, ir.OPTRLIT:
 		if isStaticCompositeLiteral(n) && !canSSAType(n.Type()) {
@@ -1684,11 +1684,11 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 	case ir.OSEND:
 		n := n.(*ir.SendStmt)
-		n1 := n.Right()
-		n1 = assignconv(n1, n.Left().Type().Elem(), "chan send")
+		n1 := n.Value
+		n1 = assignconv(n1, n.Chan.Type().Elem(), "chan send")
 		n1 = walkexpr(n1, init)
 		n1 = nodAddr(n1)
-		return mkcall1(chanfn("chansend1", 2, n.Left().Type()), nil, init, n.Left(), n1)
+		return mkcall1(chanfn("chansend1", 2, n.Chan.Type()), nil, init, n.Chan, n1)
 
 	case ir.OCLOSURE:
 		return walkclosure(n.(*ir.ClosureExpr), init)
@@ -1716,14 +1716,14 @@ func markTypeUsedInInterface(t *types.Type, from *obj.LSym) {
 // markUsedIfaceMethod marks that an interface method is used in the current
 // function. n is OCALLINTER node.
 func markUsedIfaceMethod(n *ir.CallExpr) {
-	dot := n.Left().(*ir.SelectorExpr)
-	ityp := dot.Left().Type()
+	dot := n.X.(*ir.SelectorExpr)
+	ityp := dot.X.Type()
 	tsym := typenamesym(ityp).Linksym()
 	r := obj.Addrel(Curfn.LSym)
 	r.Sym = tsym
 	// dot.Xoffset is the method index * Widthptr (the offset of code pointer
 	// in itab).
-	midx := dot.Offset() / int64(Widthptr)
+	midx := dot.Offset / int64(Widthptr)
 	r.Add = ifaceMethodOffset(ityp, midx)
 	r.Type = objabi.R_USEIFACEMETHOD
 }
@@ -1777,7 +1777,7 @@ func rtconvfn(src, dst *types.Type) (param, result types.Kind) {
 // TODO(josharian): combine this with its caller and simplify
 func reduceSlice(n *ir.SliceExpr) ir.Node {
 	low, high, max := n.SliceBounds()
-	if high != nil && high.Op() == ir.OLEN && samesafeexpr(n.Left(), high.(*ir.UnaryExpr).Left()) {
+	if high != nil && high.Op() == ir.OLEN && samesafeexpr(n.X, high.(*ir.UnaryExpr).X) {
 		// Reduce x[i:len(x)] to x[i:].
 		high = nil
 	}
@@ -1787,7 +1787,7 @@ func reduceSlice(n *ir.SliceExpr) ir.Node {
 		if base.Debug.Slice > 0 {
 			base.Warn("slice: omit slice operation")
 		}
-		return n.Left()
+		return n.X
 	}
 	return n
 }
@@ -1878,7 +1878,7 @@ func ascompatet(nl ir.Nodes, nr *types.Type) []ir.Node {
 		}
 
 		res := ir.NewResultExpr(base.Pos, nil, types.BADWIDTH)
-		res.SetOffset(base.Ctxt.FixedFrameSize() + r.Offset)
+		res.Offset = base.Ctxt.FixedFrameSize() + r.Offset
 		res.SetType(r.Type)
 		res.SetTypecheck(1)
 
@@ -1902,7 +1902,7 @@ func mkdotargslice(typ *types.Type, args []ir.Node) ir.Node {
 		n.SetType(typ)
 	} else {
 		lit := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ).(ir.Ntype), nil)
-		lit.PtrList().Append(args...)
+		lit.List.Append(args...)
 		lit.SetImplicit(true)
 		n = lit
 	}
@@ -1917,42 +1917,42 @@ func mkdotargslice(typ *types.Type, args []ir.Node) ir.Node {
 // fixVariadicCall rewrites calls to variadic functions to use an
 // explicit ... argument if one is not already present.
 func fixVariadicCall(call *ir.CallExpr) {
-	fntype := call.Left().Type()
-	if !fntype.IsVariadic() || call.IsDDD() {
+	fntype := call.X.Type()
+	if !fntype.IsVariadic() || call.IsDDD {
 		return
 	}
 
 	vi := fntype.NumParams() - 1
 	vt := fntype.Params().Field(vi).Type
 
-	args := call.List().Slice()
+	args := call.Args.Slice()
 	extra := args[vi:]
 	slice := mkdotargslice(vt, extra)
 	for i := range extra {
 		extra[i] = nil // allow GC
 	}
 
-	call.PtrList().Set(append(args[:vi], slice))
-	call.SetIsDDD(true)
+	call.Args.Set(append(args[:vi], slice))
+	call.IsDDD = true
 }
 
 func walkCall(n *ir.CallExpr, init *ir.Nodes) {
-	if n.Rlist().Len() != 0 {
+	if n.Rargs.Len() != 0 {
 		return // already walked
 	}
 
-	params := n.Left().Type().Params()
-	args := n.List().Slice()
+	params := n.X.Type().Params()
+	args := n.Args.Slice()
 
-	n.SetLeft(walkexpr(n.Left(), init))
+	n.X = walkexpr(n.X, init)
 	walkexprlist(args, init)
 
 	// If this is a method call, add the receiver at the beginning of the args.
 	if n.Op() == ir.OCALLMETH {
 		withRecv := make([]ir.Node, len(args)+1)
-		dot := n.Left().(*ir.SelectorExpr)
-		withRecv[0] = dot.Left()
-		dot.SetLeft(nil)
+		dot := n.X.(*ir.SelectorExpr)
+		withRecv[0] = dot.X
+		dot.X = nil
 		copy(withRecv[1:], args)
 		args = withRecv
 	}
@@ -1968,7 +1968,7 @@ func walkCall(n *ir.CallExpr, init *ir.Nodes) {
 		var t *types.Type
 		if n.Op() == ir.OCALLMETH {
 			if i == 0 {
-				t = n.Left().Type().Recv().Type
+				t = n.X.Type().Recv().Type
 			} else {
 				t = params.Field(i - 1).Type
 			}
@@ -1985,18 +1985,18 @@ func walkCall(n *ir.CallExpr, init *ir.Nodes) {
 		}
 	}
 
-	n.PtrList().Set(tempAssigns)
-	n.PtrRlist().Set(args)
+	n.Args.Set(tempAssigns)
+	n.Rargs.Set(args)
 }
 
 // generate code for print
 func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 	// Hoist all the argument evaluation up before the lock.
-	walkexprlistcheap(nn.List().Slice(), init)
+	walkexprlistcheap(nn.Args.Slice(), init)
 
 	// For println, add " " between elements and "\n" at the end.
 	if nn.Op() == ir.OPRINTN {
-		s := nn.List().Slice()
+		s := nn.Args.Slice()
 		t := make([]ir.Node, 0, len(s)*2)
 		for i, n := range s {
 			if i != 0 {
@@ -2005,11 +2005,11 @@ func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 			t = append(t, n)
 		}
 		t = append(t, nodstr("\n"))
-		nn.PtrList().Set(t)
+		nn.Args.Set(t)
 	}
 
 	// Collapse runs of constant strings.
-	s := nn.List().Slice()
+	s := nn.Args.Slice()
 	t := make([]ir.Node, 0, len(s))
 	for i := 0; i < len(s); {
 		var strs []string
@@ -2025,10 +2025,10 @@ func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 			i++
 		}
 	}
-	nn.PtrList().Set(t)
+	nn.Args.Set(t)
 
 	calls := []ir.Node{mkcall("printlock", nil, init)}
-	for i, n := range nn.List().Slice() {
+	for i, n := range nn.Args.Slice() {
 		if n.Op() == ir.OLITERAL {
 			if n.Type() == types.UntypedRune {
 				n = defaultlit(n, types.RuneType)
@@ -2047,7 +2047,7 @@ func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 			n = defaultlit(n, types.Types[types.TINT64])
 		}
 		n = defaultlit(n, nil)
-		nn.List().SetIndex(i, n)
+		nn.Args.SetIndex(i, n)
 		if n.Type() == nil || n.Type().Kind() == types.TFORW {
 			continue
 		}
@@ -2116,7 +2116,7 @@ func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 				n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
 				n.SetType(t)
 			}
-			r.PtrList().Append(n)
+			r.Args.Append(n)
 		}
 		calls = append(calls, r)
 	}
@@ -2127,7 +2127,7 @@ func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 	walkexprlist(calls, init)
 
 	r := ir.NewBlockStmt(base.Pos, nil)
-	r.PtrList().Set(calls)
+	r.List.Set(calls)
 	return walkstmt(typecheck(r, ctxStmt))
 }
 
@@ -2151,10 +2151,10 @@ func isReflectHeaderDataField(l ir.Node) bool {
 	switch l.Op() {
 	case ir.ODOT:
 		l := l.(*ir.SelectorExpr)
-		tsym = l.Left().Type().Sym()
+		tsym = l.X.Type().Sym()
 	case ir.ODOTPTR:
 		l := l.(*ir.SelectorExpr)
-		tsym = l.Left().Type().Elem().Sym()
+		tsym = l.X.Type().Elem().Sym()
 	default:
 		return false
 	}
@@ -2173,26 +2173,26 @@ func convas(n *ir.AssignStmt, init *ir.Nodes) *ir.AssignStmt {
 
 	n.SetTypecheck(1)
 
-	if n.Left() == nil || n.Right() == nil {
+	if n.X == nil || n.Y == nil {
 		return n
 	}
 
-	lt := n.Left().Type()
-	rt := n.Right().Type()
+	lt := n.X.Type()
+	rt := n.Y.Type()
 	if lt == nil || rt == nil {
 		return n
 	}
 
-	if ir.IsBlank(n.Left()) {
-		n.SetRight(defaultlit(n.Right(), nil))
+	if ir.IsBlank(n.X) {
+		n.Y = defaultlit(n.Y, nil)
 		return n
 	}
 
 	if !types.Identical(lt, rt) {
-		n.SetRight(assignconv(n.Right(), lt, "assignment"))
-		n.SetRight(walkexpr(n.Right(), init))
+		n.Y = assignconv(n.Y, lt, "assignment")
+		n.Y = walkexpr(n.Y, init)
 	}
-	dowidth(n.Right().Type())
+	dowidth(n.Y.Type())
 
 	return n
 }
@@ -2212,7 +2212,7 @@ func reorder3(all []*ir.AssignStmt) []ir.Node {
 
 	var mapinit ir.Nodes
 	for i, n := range all {
-		l := n.Left()
+		l := n.X
 
 		// Save subexpressions needed on left side.
 		// Drill through non-dereferences.
@@ -2220,17 +2220,17 @@ func reorder3(all []*ir.AssignStmt) []ir.Node {
 			switch ll := l; ll.Op() {
 			case ir.ODOT:
 				ll := ll.(*ir.SelectorExpr)
-				l = ll.Left()
+				l = ll.X
 				continue
 			case ir.OPAREN:
 				ll := ll.(*ir.ParenExpr)
-				l = ll.Left()
+				l = ll.X
 				continue
 			case ir.OINDEX:
 				ll := ll.(*ir.IndexExpr)
-				if ll.Left().Type().IsArray() {
-					ll.SetRight(reorder3save(ll.Right(), all, i, &early))
-					l = ll.Left()
+				if ll.X.Type().IsArray() {
+					ll.Index = reorder3save(ll.Index, all, i, &early)
+					l = ll.X
 					continue
 				}
 			}
@@ -2246,22 +2246,22 @@ func reorder3(all []*ir.AssignStmt) []ir.Node {
 
 		case ir.OINDEX, ir.OINDEXMAP:
 			l := l.(*ir.IndexExpr)
-			l.SetLeft(reorder3save(l.Left(), all, i, &early))
-			l.SetRight(reorder3save(l.Right(), all, i, &early))
+			l.X = reorder3save(l.X, all, i, &early)
+			l.Index = reorder3save(l.Index, all, i, &early)
 			if l.Op() == ir.OINDEXMAP {
 				all[i] = convas(all[i], &mapinit)
 			}
 
 		case ir.ODEREF:
 			l := l.(*ir.StarExpr)
-			l.SetLeft(reorder3save(l.Left(), all, i, &early))
+			l.X = reorder3save(l.X, all, i, &early)
 		case ir.ODOTPTR:
 			l := l.(*ir.SelectorExpr)
-			l.SetLeft(reorder3save(l.Left(), all, i, &early))
+			l.X = reorder3save(l.X, all, i, &early)
 		}
 
 		// Save expression on right side.
-		all[i].SetRight(reorder3save(all[i].Right(), all, i, &early))
+		all[i].Y = reorder3save(all[i].Y, all, i, &early)
 	}
 
 	early = append(mapinit.Slice(), early...)
@@ -2297,20 +2297,20 @@ func outervalue(n ir.Node) ir.Node {
 			base.Fatalf("OXDOT in walk")
 		case ir.ODOT:
 			nn := nn.(*ir.SelectorExpr)
-			n = nn.Left()
+			n = nn.X
 			continue
 		case ir.OPAREN:
 			nn := nn.(*ir.ParenExpr)
-			n = nn.Left()
+			n = nn.X
 			continue
 		case ir.OCONVNOP:
 			nn := nn.(*ir.ConvExpr)
-			n = nn.Left()
+			n = nn.X
 			continue
 		case ir.OINDEX:
 			nn := nn.(*ir.IndexExpr)
-			if nn.Left().Type() != nil && nn.Left().Type().IsArray() {
-				n = nn.Left()
+			if nn.X.Type() != nil && nn.X.Type().IsArray() {
+				n = nn.X
 				continue
 			}
 		}
@@ -2329,7 +2329,7 @@ func aliased(r ir.Node, all []*ir.AssignStmt) bool {
 	// Treat all fields of a struct as referring to the whole struct.
 	// We could do better but we would have to keep track of the fields.
 	for r.Op() == ir.ODOT {
-		r = r.(*ir.SelectorExpr).Left()
+		r = r.(*ir.SelectorExpr).X
 	}
 
 	// Look for obvious aliasing: a variable being assigned
@@ -2340,20 +2340,20 @@ func aliased(r ir.Node, all []*ir.AssignStmt) bool {
 	memwrite := false
 	for _, as := range all {
 		// We can ignore assignments to blank.
-		if ir.IsBlank(as.Left()) {
+		if ir.IsBlank(as.X) {
 			continue
 		}
 
-		lv := outervalue(as.Left())
+		lv := outervalue(as.X)
 		if lv.Op() != ir.ONAME {
 			memwrite = true
 			continue
 		}
 		l := lv.(*ir.Name)
 
-		switch l.Class() {
+		switch l.Class_ {
 		default:
-			base.Fatalf("unexpected class: %v, %v", l, l.Class())
+			base.Fatalf("unexpected class: %v, %v", l, l.Class_)
 
 		case ir.PAUTOHEAP, ir.PEXTERN:
 			memwrite = true
@@ -2401,7 +2401,7 @@ func anyAddrTaken(n ir.Node) bool {
 		switch n.Op() {
 		case ir.ONAME:
 			n := n.(*ir.Name)
-			return n.Class() == ir.PEXTERN || n.Class() == ir.PAUTOHEAP || n.Name().Addrtaken()
+			return n.Class_ == ir.PEXTERN || n.Class_ == ir.PAUTOHEAP || n.Name().Addrtaken()
 
 		case ir.ODOT: // but not ODOTPTR - should have been handled in aliased.
 			base.Fatalf("anyAddrTaken unexpected ODOT")
@@ -2509,7 +2509,7 @@ func paramstoheap(params *types.Type) []ir.Node {
 
 		if stackcopy := v.Name().Stackcopy; stackcopy != nil {
 			nn = append(nn, walkstmt(ir.NewDecl(base.Pos, ir.ODCL, v)))
-			if stackcopy.Class() == ir.PPARAM {
+			if stackcopy.Class_ == ir.PPARAM {
 				nn = append(nn, walkstmt(typecheck(ir.NewAssignStmt(base.Pos, v, stackcopy), ctxStmt)))
 			}
 		}
@@ -2557,7 +2557,7 @@ func returnsfromheap(params *types.Type) []ir.Node {
 		if v == nil {
 			continue
 		}
-		if stackcopy := v.Name().Stackcopy; stackcopy != nil && stackcopy.Class() == ir.PPARAMOUT {
+		if stackcopy := v.Name().Stackcopy; stackcopy != nil && stackcopy.Class_ == ir.PPARAMOUT {
 			nn = append(nn, walkstmt(typecheck(ir.NewAssignStmt(base.Pos, stackcopy, v), ctxStmt)))
 		}
 	}
@@ -2736,7 +2736,7 @@ func writebarrierfn(name string, l *types.Type, r *types.Type) ir.Node {
 }
 
 func addstr(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
-	c := n.List().Len()
+	c := n.List.Len()
 
 	if c < 2 {
 		base.Fatalf("addstr count %d too small", c)
@@ -2745,7 +2745,7 @@ func addstr(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
 	buf := nodnil()
 	if n.Esc() == EscNone {
 		sz := int64(0)
-		for _, n1 := range n.List().Slice() {
+		for _, n1 := range n.List.Slice() {
 			if n1.Op() == ir.OLITERAL {
 				sz += int64(len(ir.StringVal(n1)))
 			}
@@ -2761,7 +2761,7 @@ func addstr(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
 
 	// build list of string arguments
 	args := []ir.Node{buf}
-	for _, n2 := range n.List().Slice() {
+	for _, n2 := range n.List.Slice() {
 		args = append(args, conv(n2, types.Types[types.TSTRING]))
 	}
 
@@ -2784,7 +2784,7 @@ func addstr(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
 
 	cat := syslook(fn)
 	r := ir.NewCallExpr(base.Pos, ir.OCALL, cat, nil)
-	r.PtrList().Set(args)
+	r.Args.Set(args)
 	r1 := typecheck(r, ctxExpr)
 	r1 = walkexpr(r1, init)
 	r1.SetType(n.Type())
@@ -2793,12 +2793,12 @@ func addstr(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
 }
 
 func walkAppendArgs(n *ir.CallExpr, init *ir.Nodes) {
-	walkexprlistsafe(n.List().Slice(), init)
+	walkexprlistsafe(n.Args.Slice(), init)
 
 	// walkexprlistsafe will leave OINDEX (s[n]) alone if both s
 	// and n are name or literal, but those may index the slice we're
 	// modifying here. Fix explicitly.
-	ls := n.List().Slice()
+	ls := n.Args.Slice()
 	for i1, n1 := range ls {
 		ls[i1] = cheapexpr(n1, init)
 	}
@@ -2821,10 +2821,10 @@ func walkAppendArgs(n *ir.CallExpr, init *ir.Nodes) {
 func appendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	walkAppendArgs(n, init)
 
-	l1 := n.List().First()
-	l2 := n.List().Second()
+	l1 := n.Args.First()
+	l2 := n.Args.Second()
 	l2 = cheapexpr(l2, init)
-	n.List().SetSecond(l2)
+	n.Args.SetSecond(l2)
 
 	var nodes ir.Nodes
 
@@ -2842,14 +2842,14 @@ func appendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
 	nuint := conv(nn, types.Types[types.TUINT])
 	scapuint := conv(ir.NewUnaryExpr(base.Pos, ir.OCAP, s), types.Types[types.TUINT])
-	nif.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OGT, nuint, scapuint))
+	nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OGT, nuint, scapuint)
 
 	// instantiate growslice(typ *type, []any, int) []any
 	fn := syslook("growslice")
 	fn = substArgTypes(fn, elemtype, elemtype)
 
 	// s = growslice(T, s, n)
-	nif.PtrBody().Set1(ir.NewAssignStmt(base.Pos, s, mkcall1(fn, s.Type(), nif.PtrInit(), typename(elemtype), s, nn)))
+	nif.Body.Set1(ir.NewAssignStmt(base.Pos, s, mkcall1(fn, s.Type(), nif.PtrInit(), typename(elemtype), s, nn)))
 	nodes.Append(nif)
 
 	// s = s[:n]
@@ -2926,12 +2926,12 @@ func isAppendOfMake(n ir.Node) bool {
 		return false
 	}
 	call := n.(*ir.CallExpr)
-	if !call.IsDDD() || call.List().Len() != 2 || call.List().Second().Op() != ir.OMAKESLICE {
+	if !call.IsDDD || call.Args.Len() != 2 || call.Args.Second().Op() != ir.OMAKESLICE {
 		return false
 	}
 
-	mk := call.List().Second().(*ir.MakeExpr)
-	if mk.Right() != nil {
+	mk := call.Args.Second().(*ir.MakeExpr)
+	if mk.Cap != nil {
 		return false
 	}
 
@@ -2941,7 +2941,7 @@ func isAppendOfMake(n ir.Node) bool {
 	// typecheck made sure that constant arguments to make are not negative and fit into an int.
 
 	// The care of overflow of the len argument to make will be handled by an explicit check of int(len) < 0 during runtime.
-	y := mk.Left()
+	y := mk.Len
 	if !ir.IsConst(y, constant.Int) && y.Type().Size() > types.Types[types.TUINT].Size() {
 		return false
 	}
@@ -2980,23 +2980,23 @@ func extendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	// isAppendOfMake made sure all possible positive values of l2 fit into an uint.
 	// The case of l2 overflow when converting from e.g. uint to int is handled by an explicit
 	// check of l2 < 0 at runtime which is generated below.
-	l2 := conv(n.List().Second().(*ir.MakeExpr).Left(), types.Types[types.TINT])
+	l2 := conv(n.Args.Second().(*ir.MakeExpr).Len, types.Types[types.TINT])
 	l2 = typecheck(l2, ctxExpr)
-	n.List().SetSecond(l2) // walkAppendArgs expects l2 in n.List.Second().
+	n.Args.SetSecond(l2) // walkAppendArgs expects l2 in n.List.Second().
 
 	walkAppendArgs(n, init)
 
-	l1 := n.List().First()
-	l2 = n.List().Second() // re-read l2, as it may have been updated by walkAppendArgs
+	l1 := n.Args.First()
+	l2 = n.Args.Second() // re-read l2, as it may have been updated by walkAppendArgs
 
 	var nodes []ir.Node
 
 	// if l2 >= 0 (likely happens), do nothing
 	nifneg := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGE, l2, nodintconst(0)), nil, nil)
-	nifneg.SetLikely(true)
+	nifneg.Likely = true
 
 	// else panicmakeslicelen()
-	nifneg.PtrRlist().Set1(mkcall("panicmakeslicelen", nil, init))
+	nifneg.Else.Set1(mkcall("panicmakeslicelen", nil, init))
 	nodes = append(nodes, nifneg)
 
 	// s := l1
@@ -3019,7 +3019,7 @@ func extendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	fn = substArgTypes(fn, elemtype, elemtype)
 
 	// s = growslice(T, s, n)
-	nif.PtrBody().Set1(ir.NewAssignStmt(base.Pos, s, mkcall1(fn, s.Type(), nif.PtrInit(), typename(elemtype), s, nn)))
+	nif.Body.Set1(ir.NewAssignStmt(base.Pos, s, mkcall1(fn, s.Type(), nif.PtrInit(), typename(elemtype), s, nn)))
 	nodes = append(nodes, nif)
 
 	// s = s[:n]
@@ -3060,7 +3060,7 @@ func extendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	if hasPointers {
 		// if l1ptr == sptr
 		nifclr := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OEQ, l1ptr, sptr), nil, nil)
-		nifclr.SetBody(clr)
+		nifclr.Body = clr
 		nodes = append(nodes, nifclr)
 	} else {
 		nodes = append(nodes, clr.Slice()...)
@@ -3094,13 +3094,13 @@ func extendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 //   }
 //   s
 func walkappend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
-	if !samesafeexpr(dst, n.List().First()) {
-		n.List().SetFirst(safeexpr(n.List().First(), init))
-		n.List().SetFirst(walkexpr(n.List().First(), init))
+	if !samesafeexpr(dst, n.Args.First()) {
+		n.Args.SetFirst(safeexpr(n.Args.First(), init))
+		n.Args.SetFirst(walkexpr(n.Args.First(), init))
 	}
-	walkexprlistsafe(n.List().Slice()[1:], init)
+	walkexprlistsafe(n.Args.Slice()[1:], init)
 
-	nsrc := n.List().First()
+	nsrc := n.Args.First()
 
 	// walkexprlistsafe will leave OINDEX (s[n]) alone if both s
 	// and n are name or literal, but those may index the slice we're
@@ -3108,7 +3108,7 @@ func walkappend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
 	// Using cheapexpr also makes sure that the evaluation
 	// of all arguments (and especially any panics) happen
 	// before we begin to modify the slice in a visible way.
-	ls := n.List().Slice()[1:]
+	ls := n.Args.Slice()[1:]
 	for i, n := range ls {
 		n = cheapexpr(n, init)
 		if !types.Identical(n.Type(), nsrc.Type().Elem()) {
@@ -3118,7 +3118,7 @@ func walkappend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
 		ls[i] = n
 	}
 
-	argc := n.List().Len() - 1
+	argc := n.Args.Len() - 1
 	if argc < 1 {
 		return nsrc
 	}
@@ -3136,12 +3136,12 @@ func walkappend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
 
 	na := nodintconst(int64(argc))               // const argc
 	nif := ir.NewIfStmt(base.Pos, nil, nil, nil) // if cap(s) - len(s) < argc
-	nif.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OLT, ir.NewBinaryExpr(base.Pos, ir.OSUB, ir.NewUnaryExpr(base.Pos, ir.OCAP, ns), ir.NewUnaryExpr(base.Pos, ir.OLEN, ns)), na))
+	nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OLT, ir.NewBinaryExpr(base.Pos, ir.OSUB, ir.NewUnaryExpr(base.Pos, ir.OCAP, ns), ir.NewUnaryExpr(base.Pos, ir.OLEN, ns)), na)
 
 	fn := syslook("growslice") //   growslice(<type>, old []T, mincap int) (ret []T)
 	fn = substArgTypes(fn, ns.Type().Elem(), ns.Type().Elem())
 
-	nif.PtrBody().Set1(ir.NewAssignStmt(base.Pos, ns, mkcall1(fn, ns.Type(), nif.PtrInit(), typename(ns.Type().Elem()), ns,
+	nif.Body.Set1(ir.NewAssignStmt(base.Pos, ns, mkcall1(fn, ns.Type(), nif.PtrInit(), typename(ns.Type().Elem()), ns,
 		ir.NewBinaryExpr(base.Pos, ir.OADD, ir.NewUnaryExpr(base.Pos, ir.OLEN, ns), na))))
 
 	l = append(l, nif)
@@ -3154,7 +3154,7 @@ func walkappend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
 	slice.SetBounded(true)
 	l = append(l, ir.NewAssignStmt(base.Pos, ns, slice)) // s = s[:n+argc]
 
-	ls = n.List().Slice()[1:]
+	ls = n.Args.Slice()[1:]
 	for i, n := range ls {
 		ix := ir.NewIndexExpr(base.Pos, ns, nn) // s[n] ...
 		ix.SetBounded(true)
@@ -3182,14 +3182,14 @@ func walkappend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
 // Also works if b is a string.
 //
 func copyany(n *ir.BinaryExpr, init *ir.Nodes, runtimecall bool) ir.Node {
-	if n.Left().Type().Elem().HasPointers() {
+	if n.X.Type().Elem().HasPointers() {
 		Curfn.SetWBPos(n.Pos())
-		fn := writebarrierfn("typedslicecopy", n.Left().Type().Elem(), n.Right().Type().Elem())
-		n.SetLeft(cheapexpr(n.Left(), init))
-		ptrL, lenL := backingArrayPtrLen(n.Left())
-		n.SetRight(cheapexpr(n.Right(), init))
-		ptrR, lenR := backingArrayPtrLen(n.Right())
-		return mkcall1(fn, n.Type(), init, typename(n.Left().Type().Elem()), ptrL, lenL, ptrR, lenR)
+		fn := writebarrierfn("typedslicecopy", n.X.Type().Elem(), n.Y.Type().Elem())
+		n.X = cheapexpr(n.X, init)
+		ptrL, lenL := backingArrayPtrLen(n.X)
+		n.Y = cheapexpr(n.Y, init)
+		ptrR, lenR := backingArrayPtrLen(n.Y)
+		return mkcall1(fn, n.Type(), init, typename(n.X.Type().Elem()), ptrL, lenL, ptrR, lenR)
 	}
 
 	if runtimecall {
@@ -3197,24 +3197,24 @@ func copyany(n *ir.BinaryExpr, init *ir.Nodes, runtimecall bool) ir.Node {
 		//  copy(n.Left, n.Right)
 		// n.Right can be a slice or string.
 
-		n.SetLeft(cheapexpr(n.Left(), init))
-		ptrL, lenL := backingArrayPtrLen(n.Left())
-		n.SetRight(cheapexpr(n.Right(), init))
-		ptrR, lenR := backingArrayPtrLen(n.Right())
+		n.X = cheapexpr(n.X, init)
+		ptrL, lenL := backingArrayPtrLen(n.X)
+		n.Y = cheapexpr(n.Y, init)
+		ptrR, lenR := backingArrayPtrLen(n.Y)
 
 		fn := syslook("slicecopy")
 		fn = substArgTypes(fn, ptrL.Type().Elem(), ptrR.Type().Elem())
 
-		return mkcall1(fn, n.Type(), init, ptrL, lenL, ptrR, lenR, nodintconst(n.Left().Type().Elem().Width))
+		return mkcall1(fn, n.Type(), init, ptrL, lenL, ptrR, lenR, nodintconst(n.X.Type().Elem().Width))
 	}
 
-	n.SetLeft(walkexpr(n.Left(), init))
-	n.SetRight(walkexpr(n.Right(), init))
-	nl := temp(n.Left().Type())
-	nr := temp(n.Right().Type())
+	n.X = walkexpr(n.X, init)
+	n.Y = walkexpr(n.Y, init)
+	nl := temp(n.X.Type())
+	nr := temp(n.Y.Type())
 	var l []ir.Node
-	l = append(l, ir.NewAssignStmt(base.Pos, nl, n.Left()))
-	l = append(l, ir.NewAssignStmt(base.Pos, nr, n.Right()))
+	l = append(l, ir.NewAssignStmt(base.Pos, nl, n.X))
+	l = append(l, ir.NewAssignStmt(base.Pos, nr, n.Y))
 
 	nfrm := ir.NewUnaryExpr(base.Pos, ir.OSPTR, nr)
 	nto := ir.NewUnaryExpr(base.Pos, ir.OSPTR, nl)
@@ -3227,23 +3227,23 @@ func copyany(n *ir.BinaryExpr, init *ir.Nodes, runtimecall bool) ir.Node {
 	// if n > len(frm) { n = len(frm) }
 	nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
 
-	nif.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OGT, nlen, ir.NewUnaryExpr(base.Pos, ir.OLEN, nr)))
-	nif.PtrBody().Append(ir.NewAssignStmt(base.Pos, nlen, ir.NewUnaryExpr(base.Pos, ir.OLEN, nr)))
+	nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OGT, nlen, ir.NewUnaryExpr(base.Pos, ir.OLEN, nr))
+	nif.Body.Append(ir.NewAssignStmt(base.Pos, nlen, ir.NewUnaryExpr(base.Pos, ir.OLEN, nr)))
 	l = append(l, nif)
 
 	// if to.ptr != frm.ptr { memmove( ... ) }
 	ne := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.ONE, nto, nfrm), nil, nil)
-	ne.SetLikely(true)
+	ne.Likely = true
 	l = append(l, ne)
 
 	fn := syslook("memmove")
 	fn = substArgTypes(fn, nl.Type().Elem(), nl.Type().Elem())
 	nwid := ir.Node(temp(types.Types[types.TUINTPTR]))
 	setwid := ir.NewAssignStmt(base.Pos, nwid, conv(nlen, types.Types[types.TUINTPTR]))
-	ne.PtrBody().Append(setwid)
+	ne.Body.Append(setwid)
 	nwid = ir.NewBinaryExpr(base.Pos, ir.OMUL, nwid, nodintconst(nl.Type().Elem().Width))
 	call := mkcall1(fn, nil, init, nto, nfrm, nwid)
-	ne.PtrBody().Append(call)
+	ne.Body.Append(call)
 
 	typecheckslice(l, ctxStmt)
 	walkstmtlist(l)
@@ -3280,26 +3280,26 @@ func eqfor(t *types.Type) (n ir.Node, needsize bool) {
 // The result of walkcompare MUST be assigned back to n, e.g.
 // 	n.Left = walkcompare(n.Left, init)
 func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
-	if n.Left().Type().IsInterface() && n.Right().Type().IsInterface() && n.Left().Op() != ir.ONIL && n.Right().Op() != ir.ONIL {
+	if n.X.Type().IsInterface() && n.Y.Type().IsInterface() && n.X.Op() != ir.ONIL && n.Y.Op() != ir.ONIL {
 		return walkcompareInterface(n, init)
 	}
 
-	if n.Left().Type().IsString() && n.Right().Type().IsString() {
+	if n.X.Type().IsString() && n.Y.Type().IsString() {
 		return walkcompareString(n, init)
 	}
 
-	n.SetLeft(walkexpr(n.Left(), init))
-	n.SetRight(walkexpr(n.Right(), init))
+	n.X = walkexpr(n.X, init)
+	n.Y = walkexpr(n.Y, init)
 
 	// Given mixed interface/concrete comparison,
 	// rewrite into types-equal && data-equal.
 	// This is efficient, avoids allocations, and avoids runtime calls.
-	if n.Left().Type().IsInterface() != n.Right().Type().IsInterface() {
+	if n.X.Type().IsInterface() != n.Y.Type().IsInterface() {
 		// Preserve side-effects in case of short-circuiting; see #32187.
-		l := cheapexpr(n.Left(), init)
-		r := cheapexpr(n.Right(), init)
+		l := cheapexpr(n.X, init)
+		r := cheapexpr(n.Y, init)
 		// Swap so that l is the interface value and r is the concrete value.
-		if n.Right().Type().IsInterface() {
+		if n.Y.Type().IsInterface() {
 			l, r = r, l
 		}
 
@@ -3337,7 +3337,7 @@ func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 	// Otherwise back end handles it.
 	// While we're here, decide whether to
 	// inline or call an eq alg.
-	t := n.Left().Type()
+	t := n.X.Type()
 	var inline bool
 
 	maxcmpsize := int64(4)
@@ -3350,14 +3350,14 @@ func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 	switch t.Kind() {
 	default:
 		if base.Debug.Libfuzzer != 0 && t.IsInteger() {
-			n.SetLeft(cheapexpr(n.Left(), init))
-			n.SetRight(cheapexpr(n.Right(), init))
+			n.X = cheapexpr(n.X, init)
+			n.Y = cheapexpr(n.Y, init)
 
 			// If exactly one comparison operand is
 			// constant, invoke the constcmp functions
 			// instead, and arrange for the constant
 			// operand to be the first argument.
-			l, r := n.Left(), n.Right()
+			l, r := n.X, n.Y
 			if r.Op() == ir.OLITERAL {
 				l, r = r, l
 			}
@@ -3403,13 +3403,13 @@ func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 		inline = t.NumComponents(types.IgnoreBlankFields) <= 4
 	}
 
-	cmpl := n.Left()
+	cmpl := n.X
 	for cmpl != nil && cmpl.Op() == ir.OCONVNOP {
-		cmpl = cmpl.(*ir.ConvExpr).Left()
+		cmpl = cmpl.(*ir.ConvExpr).X
 	}
-	cmpr := n.Right()
+	cmpr := n.Y
 	for cmpr != nil && cmpr.Op() == ir.OCONVNOP {
-		cmpr = cmpr.(*ir.ConvExpr).Left()
+		cmpr = cmpr.(*ir.ConvExpr).X
 	}
 
 	// Chose not to inline. Call equality function directly.
@@ -3421,10 +3421,10 @@ func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 
 		fn, needsize := eqfor(t)
 		call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
-		call.PtrList().Append(nodAddr(cmpl))
-		call.PtrList().Append(nodAddr(cmpr))
+		call.Args.Append(nodAddr(cmpl))
+		call.Args.Append(nodAddr(cmpr))
 		if needsize {
-			call.PtrList().Append(nodintconst(t.Width))
+			call.Args.Append(nodintconst(t.Width))
 		}
 		res := ir.Node(call)
 		if n.Op() != ir.OEQ {
@@ -3538,9 +3538,9 @@ func tracecmpArg(n ir.Node, t *types.Type, init *ir.Nodes) ir.Node {
 }
 
 func walkcompareInterface(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
-	n.SetRight(cheapexpr(n.Right(), init))
-	n.SetLeft(cheapexpr(n.Left(), init))
-	eqtab, eqdata := eqinterface(n.Left(), n.Right())
+	n.Y = cheapexpr(n.Y, init)
+	n.X = cheapexpr(n.X, init)
+	eqtab, eqdata := eqinterface(n.X, n.Y)
 	var cmp ir.Node
 	if n.Op() == ir.OEQ {
 		cmp = ir.NewLogicalExpr(base.Pos, ir.OANDAND, eqtab, eqdata)
@@ -3555,21 +3555,21 @@ func walkcompareString(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 	// Rewrite comparisons to short constant strings as length+byte-wise comparisons.
 	var cs, ncs ir.Node // const string, non-const string
 	switch {
-	case ir.IsConst(n.Left(), constant.String) && ir.IsConst(n.Right(), constant.String):
+	case ir.IsConst(n.X, constant.String) && ir.IsConst(n.Y, constant.String):
 		// ignore; will be constant evaluated
-	case ir.IsConst(n.Left(), constant.String):
-		cs = n.Left()
-		ncs = n.Right()
-	case ir.IsConst(n.Right(), constant.String):
-		cs = n.Right()
-		ncs = n.Left()
+	case ir.IsConst(n.X, constant.String):
+		cs = n.X
+		ncs = n.Y
+	case ir.IsConst(n.Y, constant.String):
+		cs = n.Y
+		ncs = n.X
 	}
 	if cs != nil {
 		cmp := n.Op()
 		// Our comparison below assumes that the non-constant string
 		// is on the left hand side, so rewrite "" cmp x to x cmp "".
 		// See issue 24817.
-		if ir.IsConst(n.Left(), constant.String) {
+		if ir.IsConst(n.X, constant.String) {
 			cmp = brrev(cmp)
 		}
 
@@ -3652,9 +3652,9 @@ func walkcompareString(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 	var r ir.Node
 	if n.Op() == ir.OEQ || n.Op() == ir.ONE {
 		// prepare for rewrite below
-		n.SetLeft(cheapexpr(n.Left(), init))
-		n.SetRight(cheapexpr(n.Right(), init))
-		eqlen, eqmem := eqstring(n.Left(), n.Right())
+		n.X = cheapexpr(n.X, init)
+		n.Y = cheapexpr(n.Y, init)
+		eqlen, eqmem := eqstring(n.X, n.Y)
 		// quick check of len before full compare for == or !=.
 		// memequal then tests equality up to length len.
 		if n.Op() == ir.OEQ {
@@ -3667,7 +3667,7 @@ func walkcompareString(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 		}
 	} else {
 		// sys_cmpstring(s1, s2) :: 0
-		r = mkcall("cmpstring", types.Types[types.TINT], init, conv(n.Left(), types.Types[types.TSTRING]), conv(n.Right(), types.Types[types.TSTRING]))
+		r = mkcall("cmpstring", types.Types[types.TINT], init, conv(n.X, types.Types[types.TSTRING]), conv(n.Y, types.Types[types.TSTRING]))
 		r = ir.NewBinaryExpr(base.Pos, n.Op(), r, nodintconst(0))
 	}
 
@@ -3702,10 +3702,10 @@ func bounded(n ir.Node, max int64) bool {
 		n := n.(*ir.BinaryExpr)
 		v := int64(-1)
 		switch {
-		case smallintconst(n.Left()):
-			v = ir.Int64Val(n.Left())
-		case smallintconst(n.Right()):
-			v = ir.Int64Val(n.Right())
+		case smallintconst(n.X):
+			v = ir.Int64Val(n.X)
+		case smallintconst(n.Y):
+			v = ir.Int64Val(n.Y)
 			if n.Op() == ir.OANDNOT {
 				v = ^v
 				if !sign {
@@ -3719,8 +3719,8 @@ func bounded(n ir.Node, max int64) bool {
 
 	case ir.OMOD:
 		n := n.(*ir.BinaryExpr)
-		if !sign && smallintconst(n.Right()) {
-			v := ir.Int64Val(n.Right())
+		if !sign && smallintconst(n.Y) {
+			v := ir.Int64Val(n.Y)
 			if 0 <= v && v <= max {
 				return true
 			}
@@ -3728,8 +3728,8 @@ func bounded(n ir.Node, max int64) bool {
 
 	case ir.ODIV:
 		n := n.(*ir.BinaryExpr)
-		if !sign && smallintconst(n.Right()) {
-			v := ir.Int64Val(n.Right())
+		if !sign && smallintconst(n.Y) {
+			v := ir.Int64Val(n.Y)
 			for bits > 0 && v >= 2 {
 				bits--
 				v >>= 1
@@ -3738,8 +3738,8 @@ func bounded(n ir.Node, max int64) bool {
 
 	case ir.ORSH:
 		n := n.(*ir.BinaryExpr)
-		if !sign && smallintconst(n.Right()) {
-			v := ir.Int64Val(n.Right())
+		if !sign && smallintconst(n.Y) {
+			v := ir.Int64Val(n.Y)
 			if v > int64(bits) {
 				return true
 			}
@@ -3756,7 +3756,7 @@ func bounded(n ir.Node, max int64) bool {
 
 // usemethod checks interface method calls for uses of reflect.Type.Method.
 func usemethod(n *ir.CallExpr) {
-	t := n.Left().Type()
+	t := n.X.Type()
 
 	// Looking for either of:
 	//	Method(int) reflect.Method
@@ -3812,28 +3812,28 @@ func usefield(n *ir.SelectorExpr) {
 	case ir.ODOT, ir.ODOTPTR:
 		break
 	}
-	if n.Sym() == nil {
+	if n.Sel == nil {
 		// No field name.  This DOTPTR was built by the compiler for access
 		// to runtime data structures.  Ignore.
 		return
 	}
 
-	t := n.Left().Type()
+	t := n.X.Type()
 	if t.IsPtr() {
 		t = t.Elem()
 	}
 	field := n.Selection
 	if field == nil {
-		base.Fatalf("usefield %v %v without paramfld", n.Left().Type(), n.Sym())
+		base.Fatalf("usefield %v %v without paramfld", n.X.Type(), n.Sel)
 	}
-	if field.Sym != n.Sym() || field.Offset != n.Offset() {
-		base.Fatalf("field inconsistency: %v,%v != %v,%v", field.Sym, field.Offset, n.Sym(), n.Offset())
+	if field.Sym != n.Sel || field.Offset != n.Offset {
+		base.Fatalf("field inconsistency: %v,%v != %v,%v", field.Sym, field.Offset, n.Sel, n.Offset)
 	}
 	if !strings.Contains(field.Note, "go:\"track\"") {
 		return
 	}
 
-	outer := n.Left().Type()
+	outer := n.X.Type()
 	if outer.IsPtr() {
 		outer = outer.Elem()
 	}
@@ -3918,7 +3918,7 @@ func anySideEffects(n ir.Node) bool {
 		// Only possible side effect is division by zero.
 		case ir.ODIV, ir.OMOD:
 			n := n.(*ir.BinaryExpr)
-			if n.Right().Op() != ir.OLITERAL || constant.Sign(n.Right().Val()) == 0 {
+			if n.Y.Op() != ir.OLITERAL || constant.Sign(n.Y.Val()) == 0 {
 				return true
 			}
 
@@ -3926,7 +3926,7 @@ func anySideEffects(n ir.Node) bool {
 		// but many makechan and makemap use size zero, which is definitely OK.
 		case ir.OMAKECHAN, ir.OMAKEMAP:
 			n := n.(*ir.MakeExpr)
-			if !ir.IsConst(n.Left(), constant.Int) || constant.Sign(n.Left().Val()) != 0 {
+			if !ir.IsConst(n.Len, constant.Int) || constant.Sign(n.Len.Val()) != 0 {
 				return true
 			}
 
@@ -3968,24 +3968,24 @@ func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	isBuiltinCall := n.Op() != ir.OCALLFUNC && n.Op() != ir.OCALLMETH && n.Op() != ir.OCALLINTER
 
 	// Turn f(a, b, []T{c, d, e}...) back into f(a, b, c, d, e).
-	if !isBuiltinCall && n.IsDDD() {
-		last := n.List().Len() - 1
-		if va := n.List().Index(last); va.Op() == ir.OSLICELIT {
+	if !isBuiltinCall && n.IsDDD {
+		last := n.Args.Len() - 1
+		if va := n.Args.Index(last); va.Op() == ir.OSLICELIT {
 			va := va.(*ir.CompLitExpr)
-			n.PtrList().Set(append(n.List().Slice()[:last], va.List().Slice()...))
-			n.SetIsDDD(false)
+			n.Args.Set(append(n.Args.Slice()[:last], va.List.Slice()...))
+			n.IsDDD = false
 		}
 	}
 
 	// origArgs keeps track of what argument is uintptr-unsafe/unsafe-uintptr conversion.
-	origArgs := make([]ir.Node, n.List().Len())
+	origArgs := make([]ir.Node, n.Args.Len())
 	var funcArgs []*ir.Field
-	for i, arg := range n.List().Slice() {
+	for i, arg := range n.Args.Slice() {
 		s := lookupN("a", i)
-		if !isBuiltinCall && arg.Op() == ir.OCONVNOP && arg.Type().IsUintptr() && arg.(*ir.ConvExpr).Left().Type().IsUnsafePtr() {
+		if !isBuiltinCall && arg.Op() == ir.OCONVNOP && arg.Type().IsUintptr() && arg.(*ir.ConvExpr).X.Type().IsUnsafePtr() {
 			origArgs[i] = arg
-			arg = arg.(*ir.ConvExpr).Left()
-			n.List().SetIndex(i, arg)
+			arg = arg.(*ir.ConvExpr).X
+			n.Args.SetIndex(i, arg)
 		}
 		funcArgs = append(funcArgs, symfield(s, arg.Type()))
 	}
@@ -4002,20 +4002,20 @@ func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 		}
 		args[i] = ir.NewConvExpr(base.Pos, origArg.Op(), origArg.Type(), args[i])
 	}
-	call := ir.NewCallExpr(base.Pos, n.Op(), n.Left(), args)
+	call := ir.NewCallExpr(base.Pos, n.Op(), n.X, args)
 	if !isBuiltinCall {
 		call.SetOp(ir.OCALL)
-		call.SetIsDDD(n.IsDDD())
+		call.IsDDD = n.IsDDD
 	}
-	fn.PtrBody().Set1(call)
+	fn.Body.Set1(call)
 
 	funcbody()
 
 	typecheckFunc(fn)
-	typecheckslice(fn.Body().Slice(), ctxStmt)
+	typecheckslice(fn.Body.Slice(), ctxStmt)
 	Target.Decls = append(Target.Decls, fn)
 
-	call = ir.NewCallExpr(base.Pos, ir.OCALL, fn.Nname, n.List().Slice())
+	call = ir.NewCallExpr(base.Pos, ir.OCALL, fn.Nname, n.Args.Slice())
 	return walkexpr(typecheck(call, ctxStmt), init)
 }
 
@@ -4055,7 +4055,7 @@ func canMergeLoads() bool {
 // isRuneCount reports whether n is of the form len([]rune(string)).
 // These are optimized into a call to runtime.countrunes.
 func isRuneCount(n ir.Node) bool {
-	return base.Flag.N == 0 && !instrumenting && n.Op() == ir.OLEN && n.(*ir.UnaryExpr).Left().Op() == ir.OSTR2RUNES
+	return base.Flag.N == 0 && !instrumenting && n.Op() == ir.OLEN && n.(*ir.UnaryExpr).X.Op() == ir.OSTR2RUNES
 }
 
 func walkCheckPtrAlignment(n *ir.ConvExpr, init *ir.Nodes, count ir.Node) ir.Node {
@@ -4079,8 +4079,8 @@ func walkCheckPtrAlignment(n *ir.ConvExpr, init *ir.Nodes, count ir.Node) ir.Nod
 		count = nodintconst(1)
 	}
 
-	n.SetLeft(cheapexpr(n.Left(), init))
-	init.Append(mkcall("checkptrAlignment", nil, init, convnop(n.Left(), types.Types[types.TUNSAFEPTR]), typename(elem), conv(count, types.Types[types.TUINTPTR])))
+	n.X = cheapexpr(n.X, init)
+	init.Append(mkcall("checkptrAlignment", nil, init, convnop(n.X, types.Types[types.TUNSAFEPTR]), typename(elem), conv(count, types.Types[types.TUINTPTR])))
 	return n
 }
 
@@ -4102,12 +4102,12 @@ func walkCheckPtrArithmetic(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 
 	// TODO(mdempsky): Make stricter. We only need to exempt
 	// reflect.Value.Pointer and reflect.Value.UnsafeAddr.
-	switch n.Left().Op() {
+	switch n.X.Op() {
 	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
 		return n
 	}
 
-	if n.Left().Op() == ir.ODOTPTR && isReflectHeaderDataField(n.Left()) {
+	if n.X.Op() == ir.ODOTPTR && isReflectHeaderDataField(n.X) {
 		return n
 	}
 
@@ -4123,20 +4123,20 @@ func walkCheckPtrArithmetic(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 		switch n.Op() {
 		case ir.OADD:
 			n := n.(*ir.BinaryExpr)
-			walk(n.Left())
-			walk(n.Right())
+			walk(n.X)
+			walk(n.Y)
 		case ir.OSUB, ir.OANDNOT:
 			n := n.(*ir.BinaryExpr)
-			walk(n.Left())
+			walk(n.X)
 		case ir.OCONVNOP:
 			n := n.(*ir.ConvExpr)
-			if n.Left().Type().IsUnsafePtr() {
-				n.SetLeft(cheapexpr(n.Left(), init))
-				originals = append(originals, convnop(n.Left(), types.Types[types.TUNSAFEPTR]))
+			if n.X.Type().IsUnsafePtr() {
+				n.X = cheapexpr(n.X, init)
+				originals = append(originals, convnop(n.X, types.Types[types.TUNSAFEPTR]))
 			}
 		}
 	}
-	walk(n.Left())
+	walk(n.X)
 
 	cheap := cheapexpr(n, init)
 
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 5937798bd4..63ccaa6550 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -89,7 +89,7 @@ func toNtype(x Node) Ntype {
 // An AddStringExpr is a string concatenation Expr[0] + Exprs[1] + ... + Expr[len(Expr)-1].
 type AddStringExpr struct {
 	miniExpr
-	List_    Nodes
+	List     Nodes
 	Prealloc *Name
 }
 
@@ -97,14 +97,10 @@ func NewAddStringExpr(pos src.XPos, list []Node) *AddStringExpr {
 	n := &AddStringExpr{}
 	n.pos = pos
 	n.op = OADDSTR
-	n.List_.Set(list)
+	n.List.Set(list)
 	return n
 }
 
-func (n *AddStringExpr) List() Nodes     { return n.List_ }
-func (n *AddStringExpr) PtrList() *Nodes { return &n.List_ }
-func (n *AddStringExpr) SetList(x Nodes) { n.List_ = x }
-
 // An AddrExpr is an address-of expression &X.
 // It may end up being a normal address-of or an allocation of a composite literal.
 type AddrExpr struct {
@@ -120,10 +116,6 @@ func NewAddrExpr(pos src.XPos, x Node) *AddrExpr {
 	return n
 }
 
-func (n *AddrExpr) Left() Node         { return n.X }
-func (n *AddrExpr) SetLeft(x Node)     { n.X = x }
-func (n *AddrExpr) Right() Node        { return n.Alloc }
-func (n *AddrExpr) SetRight(x Node)    { n.Alloc = x }
 func (n *AddrExpr) Implicit() bool     { return n.flags&miniExprImplicit != 0 }
 func (n *AddrExpr) SetImplicit(b bool) { n.flags.set(miniExprImplicit, b) }
 
@@ -170,11 +162,6 @@ func NewBinaryExpr(pos src.XPos, op Op, x, y Node) *BinaryExpr {
 	return n
 }
 
-func (n *BinaryExpr) Left() Node      { return n.X }
-func (n *BinaryExpr) SetLeft(x Node)  { n.X = x }
-func (n *BinaryExpr) Right() Node     { return n.Y }
-func (n *BinaryExpr) SetRight(y Node) { n.Y = y }
-
 func (n *BinaryExpr) SetOp(op Op) {
 	switch op {
 	default:
@@ -201,14 +188,14 @@ const (
 // A CallExpr is a function call X(Args).
 type CallExpr struct {
 	miniExpr
-	orig      Node
-	X         Node
-	Args      Nodes
-	Rargs     Nodes // TODO(rsc): Delete.
-	Body_     Nodes // TODO(rsc): Delete.
-	DDD       bool
-	Use       CallUse
-	NoInline_ bool
+	orig     Node
+	X        Node
+	Args     Nodes
+	Rargs    Nodes // TODO(rsc): Delete.
+	Body     Nodes // TODO(rsc): Delete.
+	IsDDD    bool
+	Use      CallUse
+	NoInline bool
 }
 
 func NewCallExpr(pos src.XPos, op Op, fun Node, args []Node) *CallExpr {
@@ -222,23 +209,8 @@ func NewCallExpr(pos src.XPos, op Op, fun Node, args []Node) *CallExpr {
 
 func (*CallExpr) isStmt() {}
 
-func (n *CallExpr) Orig() Node         { return n.orig }
-func (n *CallExpr) SetOrig(x Node)     { n.orig = x }
-func (n *CallExpr) Left() Node         { return n.X }
-func (n *CallExpr) SetLeft(x Node)     { n.X = x }
-func (n *CallExpr) List() Nodes        { return n.Args }
-func (n *CallExpr) PtrList() *Nodes    { return &n.Args }
-func (n *CallExpr) SetList(x Nodes)    { n.Args = x }
-func (n *CallExpr) Rlist() Nodes       { return n.Rargs }
-func (n *CallExpr) PtrRlist() *Nodes   { return &n.Rargs }
-func (n *CallExpr) SetRlist(x Nodes)   { n.Rargs = x }
-func (n *CallExpr) IsDDD() bool        { return n.DDD }
-func (n *CallExpr) SetIsDDD(x bool)    { n.DDD = x }
-func (n *CallExpr) NoInline() bool     { return n.NoInline_ }
-func (n *CallExpr) SetNoInline(x bool) { n.NoInline_ = x }
-func (n *CallExpr) Body() Nodes        { return n.Body_ }
-func (n *CallExpr) PtrBody() *Nodes    { return &n.Body_ }
-func (n *CallExpr) SetBody(x Nodes)    { n.Body_ = x }
+func (n *CallExpr) Orig() Node     { return n.orig }
+func (n *CallExpr) SetOrig(x Node) { n.orig = x }
 
 func (n *CallExpr) SetOp(op Op) {
 	switch op {
@@ -253,65 +225,57 @@ func (n *CallExpr) SetOp(op Op) {
 // A CallPartExpr is a method expression X.Method (uncalled).
 type CallPartExpr struct {
 	miniExpr
-	Func_    *Func
+	Func     *Func
 	X        Node
 	Method   *types.Field
 	Prealloc *Name
 }
 
 func NewCallPartExpr(pos src.XPos, x Node, method *types.Field, fn *Func) *CallPartExpr {
-	n := &CallPartExpr{Func_: fn, X: x, Method: method}
+	n := &CallPartExpr{Func: fn, X: x, Method: method}
 	n.op = OCALLPART
 	n.pos = pos
 	n.typ = fn.Type()
-	n.Func_ = fn
+	n.Func = fn
 	return n
 }
 
-func (n *CallPartExpr) Func() *Func     { return n.Func_ }
-func (n *CallPartExpr) Left() Node      { return n.X }
 func (n *CallPartExpr) Sym() *types.Sym { return n.Method.Sym }
-func (n *CallPartExpr) SetLeft(x Node)  { n.X = x }
 
 // A ClosureExpr is a function literal expression.
 type ClosureExpr struct {
 	miniExpr
-	Func_    *Func
+	Func     *Func
 	Prealloc *Name
 }
 
 func NewClosureExpr(pos src.XPos, fn *Func) *ClosureExpr {
-	n := &ClosureExpr{Func_: fn}
+	n := &ClosureExpr{Func: fn}
 	n.op = OCLOSURE
 	n.pos = pos
 	return n
 }
 
-func (n *ClosureExpr) Func() *Func { return n.Func_ }
-
 // A ClosureRead denotes reading a variable stored within a closure struct.
 type ClosureReadExpr struct {
 	miniExpr
-	Offset_ int64
+	Offset int64
 }
 
 func NewClosureRead(typ *types.Type, offset int64) *ClosureReadExpr {
-	n := &ClosureReadExpr{Offset_: offset}
+	n := &ClosureReadExpr{Offset: offset}
 	n.typ = typ
 	n.op = OCLOSUREREAD
 	return n
 }
 
-func (n *ClosureReadExpr) Type() *types.Type { return n.typ }
-func (n *ClosureReadExpr) Offset() int64     { return n.Offset_ }
-
 // A CompLitExpr is a composite literal Type{Vals}.
 // Before type-checking, the type is Ntype.
 type CompLitExpr struct {
 	miniExpr
 	orig     Node
 	Ntype    Ntype
-	List_    Nodes // initialized values
+	List     Nodes // initialized values
 	Prealloc *Name
 	Len      int64 // backing array length for OSLICELIT
 }
@@ -320,18 +284,13 @@ func NewCompLitExpr(pos src.XPos, op Op, typ Ntype, list []Node) *CompLitExpr {
 	n := &CompLitExpr{Ntype: typ}
 	n.pos = pos
 	n.SetOp(op)
-	n.List_.Set(list)
+	n.List.Set(list)
 	n.orig = n
 	return n
 }
 
 func (n *CompLitExpr) Orig() Node         { return n.orig }
 func (n *CompLitExpr) SetOrig(x Node)     { n.orig = x }
-func (n *CompLitExpr) Right() Node        { return n.Ntype }
-func (n *CompLitExpr) SetRight(x Node)    { n.Ntype = toNtype(x) }
-func (n *CompLitExpr) List() Nodes        { return n.List_ }
-func (n *CompLitExpr) PtrList() *Nodes    { return &n.List_ }
-func (n *CompLitExpr) SetList(x Nodes)    { n.List_ = x }
 func (n *CompLitExpr) Implicit() bool     { return n.flags&miniExprImplicit != 0 }
 func (n *CompLitExpr) SetImplicit(b bool) { n.flags.set(miniExprImplicit, b) }
 
@@ -380,8 +339,6 @@ func NewConvExpr(pos src.XPos, op Op, typ *types.Type, x Node) *ConvExpr {
 	return n
 }
 
-func (n *ConvExpr) Left() Node         { return n.X }
-func (n *ConvExpr) SetLeft(x Node)     { n.X = x }
 func (n *ConvExpr) Implicit() bool     { return n.flags&miniExprImplicit != 0 }
 func (n *ConvExpr) SetImplicit(b bool) { n.flags.set(miniExprImplicit, b) }
 
@@ -409,13 +366,6 @@ func NewIndexExpr(pos src.XPos, x, index Node) *IndexExpr {
 	return n
 }
 
-func (n *IndexExpr) Left() Node               { return n.X }
-func (n *IndexExpr) SetLeft(x Node)           { n.X = x }
-func (n *IndexExpr) Right() Node              { return n.Index }
-func (n *IndexExpr) SetRight(y Node)          { n.Index = y }
-func (n *IndexExpr) IndexMapLValue() bool     { return n.Assigned }
-func (n *IndexExpr) SetIndexMapLValue(x bool) { n.Assigned = x }
-
 func (n *IndexExpr) SetOp(op Op) {
 	switch op {
 	default:
@@ -439,38 +389,28 @@ func NewKeyExpr(pos src.XPos, key, value Node) *KeyExpr {
 	return n
 }
 
-func (n *KeyExpr) Left() Node      { return n.Key }
-func (n *KeyExpr) SetLeft(x Node)  { n.Key = x }
-func (n *KeyExpr) Right() Node     { return n.Value }
-func (n *KeyExpr) SetRight(y Node) { n.Value = y }
-
 // A StructKeyExpr is an Field: Value composite literal key.
 type StructKeyExpr struct {
 	miniExpr
-	Field   *types.Sym
-	Value   Node
-	Offset_ int64
+	Field  *types.Sym
+	Value  Node
+	Offset int64
 }
 
 func NewStructKeyExpr(pos src.XPos, field *types.Sym, value Node) *StructKeyExpr {
 	n := &StructKeyExpr{Field: field, Value: value}
 	n.pos = pos
 	n.op = OSTRUCTKEY
-	n.Offset_ = types.BADWIDTH
+	n.Offset = types.BADWIDTH
 	return n
 }
 
-func (n *StructKeyExpr) Sym() *types.Sym     { return n.Field }
-func (n *StructKeyExpr) SetSym(x *types.Sym) { n.Field = x }
-func (n *StructKeyExpr) Left() Node          { return n.Value }
-func (n *StructKeyExpr) SetLeft(x Node)      { n.Value = x }
-func (n *StructKeyExpr) Offset() int64       { return n.Offset_ }
-func (n *StructKeyExpr) SetOffset(x int64)   { n.Offset_ = x }
+func (n *StructKeyExpr) Sym() *types.Sym { return n.Field }
 
 // An InlinedCallExpr is an inlined function call.
 type InlinedCallExpr struct {
 	miniExpr
-	Body_      Nodes
+	Body       Nodes
 	ReturnVars Nodes
 }
 
@@ -478,18 +418,11 @@ func NewInlinedCallExpr(pos src.XPos, body, retvars []Node) *InlinedCallExpr {
 	n := &InlinedCallExpr{}
 	n.pos = pos
 	n.op = OINLCALL
-	n.Body_.Set(body)
+	n.Body.Set(body)
 	n.ReturnVars.Set(retvars)
 	return n
 }
 
-func (n *InlinedCallExpr) Body() Nodes      { return n.Body_ }
-func (n *InlinedCallExpr) PtrBody() *Nodes  { return &n.Body_ }
-func (n *InlinedCallExpr) SetBody(x Nodes)  { n.Body_ = x }
-func (n *InlinedCallExpr) Rlist() Nodes     { return n.ReturnVars }
-func (n *InlinedCallExpr) PtrRlist() *Nodes { return &n.ReturnVars }
-func (n *InlinedCallExpr) SetRlist(x Nodes) { n.ReturnVars = x }
-
 // A LogicalExpr is a expression X Op Y where Op is && or ||.
 // It is separate from BinaryExpr to make room for statements
 // that must be executed before Y but after X.
@@ -506,11 +439,6 @@ func NewLogicalExpr(pos src.XPos, op Op, x, y Node) *LogicalExpr {
 	return n
 }
 
-func (n *LogicalExpr) Left() Node      { return n.X }
-func (n *LogicalExpr) SetLeft(x Node)  { n.X = x }
-func (n *LogicalExpr) Right() Node     { return n.Y }
-func (n *LogicalExpr) SetRight(y Node) { n.Y = y }
-
 func (n *LogicalExpr) SetOp(op Op) {
 	switch op {
 	default:
@@ -536,11 +464,6 @@ func NewMakeExpr(pos src.XPos, op Op, len, cap Node) *MakeExpr {
 	return n
 }
 
-func (n *MakeExpr) Left() Node      { return n.Len }
-func (n *MakeExpr) SetLeft(x Node)  { n.Len = x }
-func (n *MakeExpr) Right() Node     { return n.Cap }
-func (n *MakeExpr) SetRight(x Node) { n.Cap = x }
-
 func (n *MakeExpr) SetOp(op Op) {
 	switch op {
 	default:
@@ -565,16 +488,8 @@ func NewMethodExpr(pos src.XPos, t *types.Type, method *types.Field) *MethodExpr
 	return n
 }
 
-func (n *MethodExpr) FuncName() *Name   { return n.FuncName_ }
-func (n *MethodExpr) Left() Node        { panic("MethodExpr.Left") }
-func (n *MethodExpr) SetLeft(x Node)    { panic("MethodExpr.SetLeft") }
-func (n *MethodExpr) Right() Node       { panic("MethodExpr.Right") }
-func (n *MethodExpr) SetRight(x Node)   { panic("MethodExpr.SetRight") }
-func (n *MethodExpr) Sym() *types.Sym   { panic("MethodExpr.Sym") }
-func (n *MethodExpr) Offset() int64     { panic("MethodExpr.Offset") }
-func (n *MethodExpr) SetOffset(x int64) { panic("MethodExpr.SetOffset") }
-func (n *MethodExpr) Class() Class      { panic("MethodExpr.Class") }
-func (n *MethodExpr) SetClass(x Class)  { panic("MethodExpr.SetClass") }
+func (n *MethodExpr) FuncName() *Name { return n.FuncName_ }
+func (n *MethodExpr) Sym() *types.Sym { panic("MethodExpr.Sym") }
 
 // A NilExpr represents the predefined untyped constant nil.
 // (It may be copied and assigned a type, though.)
@@ -607,8 +522,6 @@ func NewParenExpr(pos src.XPos, x Node) *ParenExpr {
 	return n
 }
 
-func (n *ParenExpr) Left() Node         { return n.X }
-func (n *ParenExpr) SetLeft(x Node)     { n.X = x }
 func (n *ParenExpr) Implicit() bool     { return n.flags&miniExprImplicit != 0 }
 func (n *ParenExpr) SetImplicit(b bool) { n.flags.set(miniExprImplicit, b) }
 
@@ -625,20 +538,17 @@ func (n *ParenExpr) SetOTYPE(t *types.Type) {
 // A ResultExpr represents a direct access to a result slot on the stack frame.
 type ResultExpr struct {
 	miniExpr
-	Offset_ int64
+	Offset int64
 }
 
 func NewResultExpr(pos src.XPos, typ *types.Type, offset int64) *ResultExpr {
-	n := &ResultExpr{Offset_: offset}
+	n := &ResultExpr{Offset: offset}
 	n.pos = pos
 	n.op = ORESULT
 	n.typ = typ
 	return n
 }
 
-func (n *ResultExpr) Offset() int64     { return n.Offset_ }
-func (n *ResultExpr) SetOffset(x int64) { n.Offset_ = x }
-
 // A NameOffsetExpr refers to an offset within a variable.
 // It is like a SelectorExpr but without the field name.
 type NameOffsetExpr struct {
@@ -659,14 +569,14 @@ type SelectorExpr struct {
 	miniExpr
 	X         Node
 	Sel       *types.Sym
-	Offset_   int64
+	Offset    int64
 	Selection *types.Field
 }
 
 func NewSelectorExpr(pos src.XPos, op Op, x Node, sel *types.Sym) *SelectorExpr {
 	n := &SelectorExpr{X: x, Sel: sel}
 	n.pos = pos
-	n.Offset_ = types.BADWIDTH
+	n.Offset = types.BADWIDTH
 	n.SetOp(op)
 	return n
 }
@@ -680,14 +590,9 @@ func (n *SelectorExpr) SetOp(op Op) {
 	}
 }
 
-func (n *SelectorExpr) Left() Node          { return n.X }
-func (n *SelectorExpr) SetLeft(x Node)      { n.X = x }
-func (n *SelectorExpr) Sym() *types.Sym     { return n.Sel }
-func (n *SelectorExpr) SetSym(x *types.Sym) { n.Sel = x }
-func (n *SelectorExpr) Offset() int64       { return n.Offset_ }
-func (n *SelectorExpr) SetOffset(x int64)   { n.Offset_ = x }
-func (n *SelectorExpr) Implicit() bool      { return n.flags&miniExprImplicit != 0 }
-func (n *SelectorExpr) SetImplicit(b bool)  { n.flags.set(miniExprImplicit, b) }
+func (n *SelectorExpr) Sym() *types.Sym    { return n.Sel }
+func (n *SelectorExpr) Implicit() bool     { return n.flags&miniExprImplicit != 0 }
+func (n *SelectorExpr) SetImplicit(b bool) { n.flags.set(miniExprImplicit, b) }
 
 // Before type-checking, bytes.Buffer is a SelectorExpr.
 // After type-checking it becomes a Name.
@@ -696,8 +601,8 @@ func (*SelectorExpr) CanBeNtype() {}
 // A SliceExpr is a slice expression X[Low:High] or X[Low:High:Max].
 type SliceExpr struct {
 	miniExpr
-	X     Node
-	List_ Nodes // TODO(rsc): Use separate Nodes
+	X    Node
+	List Nodes // TODO(rsc): Use separate Nodes
 }
 
 func NewSliceExpr(pos src.XPos, op Op, x Node) *SliceExpr {
@@ -707,12 +612,6 @@ func NewSliceExpr(pos src.XPos, op Op, x Node) *SliceExpr {
 	return n
 }
 
-func (n *SliceExpr) Left() Node      { return n.X }
-func (n *SliceExpr) SetLeft(x Node)  { n.X = x }
-func (n *SliceExpr) List() Nodes     { return n.List_ }
-func (n *SliceExpr) PtrList() *Nodes { return &n.List_ }
-func (n *SliceExpr) SetList(x Nodes) { n.List_ = x }
-
 func (n *SliceExpr) SetOp(op Op) {
 	switch op {
 	default:
@@ -725,16 +624,16 @@ func (n *SliceExpr) SetOp(op Op) {
 // SliceBounds returns n's slice bounds: low, high, and max in expr[low:high:max].
 // n must be a slice expression. max is nil if n is a simple slice expression.
 func (n *SliceExpr) SliceBounds() (low, high, max Node) {
-	if n.List_.Len() == 0 {
+	if n.List.Len() == 0 {
 		return nil, nil, nil
 	}
 
 	switch n.Op() {
 	case OSLICE, OSLICEARR, OSLICESTR:
-		s := n.List_.Slice()
+		s := n.List.Slice()
 		return s[0], s[1], nil
 	case OSLICE3, OSLICE3ARR:
-		s := n.List_.Slice()
+		s := n.List.Slice()
 		return s[0], s[1], s[2]
 	}
 	base.Fatalf("SliceBounds op %v: %v", n.Op(), n)
@@ -749,24 +648,24 @@ func (n *SliceExpr) SetSliceBounds(low, high, max Node) {
 		if max != nil {
 			base.Fatalf("SetSliceBounds %v given three bounds", n.Op())
 		}
-		s := n.List_.Slice()
+		s := n.List.Slice()
 		if s == nil {
 			if low == nil && high == nil {
 				return
 			}
-			n.List_.Set2(low, high)
+			n.List.Set2(low, high)
 			return
 		}
 		s[0] = low
 		s[1] = high
 		return
 	case OSLICE3, OSLICE3ARR:
-		s := n.List_.Slice()
+		s := n.List.Slice()
 		if s == nil {
 			if low == nil && high == nil && max == nil {
 				return
 			}
-			n.List_.Set3(low, high, max)
+			n.List.Set3(low, high, max)
 			return
 		}
 		s[0] = low
@@ -793,8 +692,8 @@ func (o Op) IsSlice3() bool {
 // A SliceHeader expression constructs a slice header from its parts.
 type SliceHeaderExpr struct {
 	miniExpr
-	Ptr     Node
-	LenCap_ Nodes // TODO(rsc): Split into two Node fields
+	Ptr    Node
+	LenCap Nodes // TODO(rsc): Split into two Node fields
 }
 
 func NewSliceHeaderExpr(pos src.XPos, typ *types.Type, ptr, len, cap Node) *SliceHeaderExpr {
@@ -802,16 +701,10 @@ func NewSliceHeaderExpr(pos src.XPos, typ *types.Type, ptr, len, cap Node) *Slic
 	n.pos = pos
 	n.op = OSLICEHEADER
 	n.typ = typ
-	n.LenCap_.Set2(len, cap)
+	n.LenCap.Set2(len, cap)
 	return n
 }
 
-func (n *SliceHeaderExpr) Left() Node      { return n.Ptr }
-func (n *SliceHeaderExpr) SetLeft(x Node)  { n.Ptr = x }
-func (n *SliceHeaderExpr) List() Nodes     { return n.LenCap_ }
-func (n *SliceHeaderExpr) PtrList() *Nodes { return &n.LenCap_ }
-func (n *SliceHeaderExpr) SetList(x Nodes) { n.LenCap_ = x }
-
 // A StarExpr is a dereference expression *X.
 // It may end up being a value or a type.
 type StarExpr struct {
@@ -826,8 +719,6 @@ func NewStarExpr(pos src.XPos, x Node) *StarExpr {
 	return n
 }
 
-func (n *StarExpr) Left() Node         { return n.X }
-func (n *StarExpr) SetLeft(x Node)     { n.X = x }
 func (n *StarExpr) Implicit() bool     { return n.flags&miniExprImplicit != 0 }
 func (n *StarExpr) SetImplicit(b bool) { n.flags.set(miniExprImplicit, b) }
 
@@ -858,14 +749,6 @@ func NewTypeAssertExpr(pos src.XPos, x Node, typ Ntype) *TypeAssertExpr {
 	return n
 }
 
-func (n *TypeAssertExpr) Left() Node      { return n.X }
-func (n *TypeAssertExpr) SetLeft(x Node)  { n.X = x }
-func (n *TypeAssertExpr) Right() Node     { return n.Ntype }
-func (n *TypeAssertExpr) SetRight(x Node) { n.Ntype = x } // TODO: toNtype(x)
-func (n *TypeAssertExpr) List() Nodes     { return n.Itab }
-func (n *TypeAssertExpr) PtrList() *Nodes { return &n.Itab }
-func (n *TypeAssertExpr) SetList(x Nodes) { n.Itab = x }
-
 func (n *TypeAssertExpr) SetOp(op Op) {
 	switch op {
 	default:
@@ -889,9 +772,6 @@ func NewUnaryExpr(pos src.XPos, op Op, x Node) *UnaryExpr {
 	return n
 }
 
-func (n *UnaryExpr) Left() Node     { return n.X }
-func (n *UnaryExpr) SetLeft(x Node) { n.X = x }
-
 func (n *UnaryExpr) SetOp(op Op) {
 	switch op {
 	default:
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 76bb35f971..49c4ac9a8d 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -332,75 +332,75 @@ func stmtFmt(n Node, s fmt.State) {
 	switch n.Op() {
 	case ODCL:
 		n := n.(*Decl)
-		fmt.Fprintf(s, "var %v %v", n.Left().Sym(), n.Left().Type())
+		fmt.Fprintf(s, "var %v %v", n.X.Sym(), n.X.Type())
 
 	// Don't export "v = <N>" initializing statements, hope they're always
 	// preceded by the DCL which will be re-parsed and typechecked to reproduce
 	// the "v = <N>" again.
 	case OAS:
 		n := n.(*AssignStmt)
-		if n.Colas() && !complexinit {
-			fmt.Fprintf(s, "%v := %v", n.Left(), n.Right())
+		if n.Def && !complexinit {
+			fmt.Fprintf(s, "%v := %v", n.X, n.Y)
 		} else {
-			fmt.Fprintf(s, "%v = %v", n.Left(), n.Right())
+			fmt.Fprintf(s, "%v = %v", n.X, n.Y)
 		}
 
 	case OASOP:
 		n := n.(*AssignOpStmt)
-		if n.Implicit() {
-			if n.SubOp() == OADD {
-				fmt.Fprintf(s, "%v++", n.Left())
+		if n.IncDec {
+			if n.AsOp == OADD {
+				fmt.Fprintf(s, "%v++", n.X)
 			} else {
-				fmt.Fprintf(s, "%v--", n.Left())
+				fmt.Fprintf(s, "%v--", n.X)
 			}
 			break
 		}
 
-		fmt.Fprintf(s, "%v %v= %v", n.Left(), n.SubOp(), n.Right())
+		fmt.Fprintf(s, "%v %v= %v", n.X, n.AsOp, n.Y)
 
 	case OAS2, OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV:
 		n := n.(*AssignListStmt)
-		if n.Colas() && !complexinit {
-			fmt.Fprintf(s, "%.v := %.v", n.List(), n.Rlist())
+		if n.Def && !complexinit {
+			fmt.Fprintf(s, "%.v := %.v", n.Lhs, n.Rhs)
 		} else {
-			fmt.Fprintf(s, "%.v = %.v", n.List(), n.Rlist())
+			fmt.Fprintf(s, "%.v = %.v", n.Lhs, n.Rhs)
 		}
 
 	case OBLOCK:
 		n := n.(*BlockStmt)
-		if n.List().Len() != 0 {
-			fmt.Fprintf(s, "%v", n.List())
+		if n.List.Len() != 0 {
+			fmt.Fprintf(s, "%v", n.List)
 		}
 
 	case ORETURN:
 		n := n.(*ReturnStmt)
-		fmt.Fprintf(s, "return %.v", n.List())
+		fmt.Fprintf(s, "return %.v", n.Results)
 
 	case ORETJMP:
 		n := n.(*BranchStmt)
-		fmt.Fprintf(s, "retjmp %v", n.Sym())
+		fmt.Fprintf(s, "retjmp %v", n.Label)
 
 	case OINLMARK:
 		n := n.(*InlineMarkStmt)
-		fmt.Fprintf(s, "inlmark %d", n.Offset())
+		fmt.Fprintf(s, "inlmark %d", n.Index)
 
 	case OGO:
 		n := n.(*GoDeferStmt)
-		fmt.Fprintf(s, "go %v", n.Left())
+		fmt.Fprintf(s, "go %v", n.Call)
 
 	case ODEFER:
 		n := n.(*GoDeferStmt)
-		fmt.Fprintf(s, "defer %v", n.Left())
+		fmt.Fprintf(s, "defer %v", n.Call)
 
 	case OIF:
 		n := n.(*IfStmt)
 		if simpleinit {
-			fmt.Fprintf(s, "if %v; %v { %v }", n.Init().First(), n.Left(), n.Body())
+			fmt.Fprintf(s, "if %v; %v { %v }", n.Init().First(), n.Cond, n.Body)
 		} else {
-			fmt.Fprintf(s, "if %v { %v }", n.Left(), n.Body())
+			fmt.Fprintf(s, "if %v { %v }", n.Cond, n.Body)
 		}
-		if n.Rlist().Len() != 0 {
-			fmt.Fprintf(s, " else { %v }", n.Rlist())
+		if n.Else.Len() != 0 {
+			fmt.Fprintf(s, " else { %v }", n.Else)
 		}
 
 	case OFOR, OFORUNTIL:
@@ -417,25 +417,25 @@ func stmtFmt(n Node, s fmt.State) {
 		fmt.Fprint(s, opname)
 		if simpleinit {
 			fmt.Fprintf(s, " %v;", n.Init().First())
-		} else if n.Right() != nil {
+		} else if n.Post != nil {
 			fmt.Fprint(s, " ;")
 		}
 
-		if n.Left() != nil {
-			fmt.Fprintf(s, " %v", n.Left())
+		if n.Cond != nil {
+			fmt.Fprintf(s, " %v", n.Cond)
 		}
 
-		if n.Right() != nil {
-			fmt.Fprintf(s, "; %v", n.Right())
+		if n.Post != nil {
+			fmt.Fprintf(s, "; %v", n.Post)
 		} else if simpleinit {
 			fmt.Fprint(s, ";")
 		}
 
-		if n.Op() == OFORUNTIL && n.List().Len() != 0 {
-			fmt.Fprintf(s, "; %v", n.List())
+		if n.Op() == OFORUNTIL && n.Late.Len() != 0 {
+			fmt.Fprintf(s, "; %v", n.Late)
 		}
 
-		fmt.Fprintf(s, " { %v }", n.Body())
+		fmt.Fprintf(s, " { %v }", n.Body)
 
 	case ORANGE:
 		n := n.(*RangeStmt)
@@ -444,12 +444,12 @@ func stmtFmt(n Node, s fmt.State) {
 			break
 		}
 
-		if n.List().Len() == 0 {
-			fmt.Fprintf(s, "for range %v { %v }", n.Right(), n.Body())
+		if n.Vars.Len() == 0 {
+			fmt.Fprintf(s, "for range %v { %v }", n.X, n.Body)
 			break
 		}
 
-		fmt.Fprintf(s, "for %.v = range %v { %v }", n.List(), n.Right(), n.Body())
+		fmt.Fprintf(s, "for %.v = range %v { %v }", n.Vars, n.X, n.Body)
 
 	case OSELECT:
 		n := n.(*SelectStmt)
@@ -457,7 +457,7 @@ func stmtFmt(n Node, s fmt.State) {
 			fmt.Fprintf(s, "%v statement", n.Op())
 			break
 		}
-		fmt.Fprintf(s, "select { %v }", n.List())
+		fmt.Fprintf(s, "select { %v }", n.Cases)
 
 	case OSWITCH:
 		n := n.(*SwitchStmt)
@@ -469,31 +469,31 @@ func stmtFmt(n Node, s fmt.State) {
 		if simpleinit {
 			fmt.Fprintf(s, " %v;", n.Init().First())
 		}
-		if n.Left() != nil {
-			fmt.Fprintf(s, " %v ", n.Left())
+		if n.Tag != nil {
+			fmt.Fprintf(s, " %v ", n.Tag)
 		}
-		fmt.Fprintf(s, " { %v }", n.List())
+		fmt.Fprintf(s, " { %v }", n.Cases)
 
 	case OCASE:
 		n := n.(*CaseStmt)
-		if n.List().Len() != 0 {
-			fmt.Fprintf(s, "case %.v", n.List())
+		if n.List.Len() != 0 {
+			fmt.Fprintf(s, "case %.v", n.List)
 		} else {
 			fmt.Fprint(s, "default")
 		}
-		fmt.Fprintf(s, ": %v", n.Body())
+		fmt.Fprintf(s, ": %v", n.Body)
 
 	case OBREAK, OCONTINUE, OGOTO, OFALL:
 		n := n.(*BranchStmt)
-		if n.Sym() != nil {
-			fmt.Fprintf(s, "%v %v", n.Op(), n.Sym())
+		if n.Label != nil {
+			fmt.Fprintf(s, "%v %v", n.Op(), n.Label)
 		} else {
 			fmt.Fprintf(s, "%v", n.Op())
 		}
 
 	case OLABEL:
 		n := n.(*LabelStmt)
-		fmt.Fprintf(s, "%v: ", n.Sym())
+		fmt.Fprintf(s, "%v: ", n.Label)
 	}
 
 	if extrablock {
@@ -527,19 +527,19 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		case OADDR:
 			nn := nn.(*AddrExpr)
 			if nn.Implicit() {
-				n = nn.Left()
+				n = nn.X
 				continue
 			}
 		case ODEREF:
 			nn := nn.(*StarExpr)
 			if nn.Implicit() {
-				n = nn.Left()
+				n = nn.X
 				continue
 			}
 		case OCONV, OCONVNOP, OCONVIFACE:
 			nn := nn.(*ConvExpr)
 			if nn.Implicit() {
-				n = nn.Left()
+				n = nn.X
 				continue
 			}
 		}
@@ -560,7 +560,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 	switch n.Op() {
 	case OPAREN:
 		n := n.(*ParenExpr)
-		fmt.Fprintf(s, "(%v)", n.Left())
+		fmt.Fprintf(s, "(%v)", n.X)
 
 	case ONIL:
 		fmt.Fprint(s, "nil")
@@ -694,7 +694,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 			fmt.Fprint(s, "func literal")
 			return
 		}
-		fmt.Fprintf(s, "%v { %v }", n.Type(), n.Func().Body())
+		fmt.Fprintf(s, "%v { %v }", n.Type(), n.Func.Body)
 
 	case OCOMPLIT:
 		n := n.(*CompLitExpr)
@@ -703,84 +703,84 @@ func exprFmt(n Node, s fmt.State, prec int) {
 				fmt.Fprintf(s, "... argument")
 				return
 			}
-			if n.Right() != nil {
-				fmt.Fprintf(s, "%v{%s}", n.Right(), ellipsisIf(n.List().Len() != 0))
+			if n.Ntype != nil {
+				fmt.Fprintf(s, "%v{%s}", n.Ntype, ellipsisIf(n.List.Len() != 0))
 				return
 			}
 
 			fmt.Fprint(s, "composite literal")
 			return
 		}
-		fmt.Fprintf(s, "(%v{ %.v })", n.Right(), n.List())
+		fmt.Fprintf(s, "(%v{ %.v })", n.Ntype, n.List)
 
 	case OPTRLIT:
 		n := n.(*AddrExpr)
-		fmt.Fprintf(s, "&%v", n.Left())
+		fmt.Fprintf(s, "&%v", n.X)
 
 	case OSTRUCTLIT, OARRAYLIT, OSLICELIT, OMAPLIT:
 		n := n.(*CompLitExpr)
 		if !exportFormat {
-			fmt.Fprintf(s, "%v{%s}", n.Type(), ellipsisIf(n.List().Len() != 0))
+			fmt.Fprintf(s, "%v{%s}", n.Type(), ellipsisIf(n.List.Len() != 0))
 			return
 		}
-		fmt.Fprintf(s, "(%v{ %.v })", n.Type(), n.List())
+		fmt.Fprintf(s, "(%v{ %.v })", n.Type(), n.List)
 
 	case OKEY:
 		n := n.(*KeyExpr)
-		if n.Left() != nil && n.Right() != nil {
-			fmt.Fprintf(s, "%v:%v", n.Left(), n.Right())
+		if n.Key != nil && n.Value != nil {
+			fmt.Fprintf(s, "%v:%v", n.Key, n.Value)
 			return
 		}
 
-		if n.Left() == nil && n.Right() != nil {
-			fmt.Fprintf(s, ":%v", n.Right())
+		if n.Key == nil && n.Value != nil {
+			fmt.Fprintf(s, ":%v", n.Value)
 			return
 		}
-		if n.Left() != nil && n.Right() == nil {
-			fmt.Fprintf(s, "%v:", n.Left())
+		if n.Key != nil && n.Value == nil {
+			fmt.Fprintf(s, "%v:", n.Key)
 			return
 		}
 		fmt.Fprint(s, ":")
 
 	case OSTRUCTKEY:
 		n := n.(*StructKeyExpr)
-		fmt.Fprintf(s, "%v:%v", n.Sym(), n.Left())
+		fmt.Fprintf(s, "%v:%v", n.Field, n.Value)
 
 	case OCALLPART:
 		n := n.(*CallPartExpr)
-		exprFmt(n.Left(), s, nprec)
-		if n.Sym() == nil {
+		exprFmt(n.X, s, nprec)
+		if n.Method.Sym == nil {
 			fmt.Fprint(s, ".<nil>")
 			return
 		}
-		fmt.Fprintf(s, ".%s", types.SymMethodName(n.Sym()))
+		fmt.Fprintf(s, ".%s", types.SymMethodName(n.Method.Sym))
 
 	case OXDOT, ODOT, ODOTPTR, ODOTINTER, ODOTMETH:
 		n := n.(*SelectorExpr)
-		exprFmt(n.Left(), s, nprec)
-		if n.Sym() == nil {
+		exprFmt(n.X, s, nprec)
+		if n.Sel == nil {
 			fmt.Fprint(s, ".<nil>")
 			return
 		}
-		fmt.Fprintf(s, ".%s", types.SymMethodName(n.Sym()))
+		fmt.Fprintf(s, ".%s", types.SymMethodName(n.Sel))
 
 	case ODOTTYPE, ODOTTYPE2:
 		n := n.(*TypeAssertExpr)
-		exprFmt(n.Left(), s, nprec)
-		if n.Right() != nil {
-			fmt.Fprintf(s, ".(%v)", n.Right())
+		exprFmt(n.X, s, nprec)
+		if n.Ntype != nil {
+			fmt.Fprintf(s, ".(%v)", n.Ntype)
 			return
 		}
 		fmt.Fprintf(s, ".(%v)", n.Type())
 
 	case OINDEX, OINDEXMAP:
 		n := n.(*IndexExpr)
-		exprFmt(n.Left(), s, nprec)
-		fmt.Fprintf(s, "[%v]", n.Right())
+		exprFmt(n.X, s, nprec)
+		fmt.Fprintf(s, "[%v]", n.Index)
 
 	case OSLICE, OSLICESTR, OSLICEARR, OSLICE3, OSLICE3ARR:
 		n := n.(*SliceExpr)
-		exprFmt(n.Left(), s, nprec)
+		exprFmt(n.X, s, nprec)
 		fmt.Fprint(s, "[")
 		low, high, max := n.SliceBounds()
 		if low != nil {
@@ -800,14 +800,14 @@ func exprFmt(n Node, s fmt.State, prec int) {
 
 	case OSLICEHEADER:
 		n := n.(*SliceHeaderExpr)
-		if n.List().Len() != 2 {
-			base.Fatalf("bad OSLICEHEADER list length %d", n.List().Len())
+		if n.LenCap.Len() != 2 {
+			base.Fatalf("bad OSLICEHEADER list length %d", n.LenCap.Len())
 		}
-		fmt.Fprintf(s, "sliceheader{%v,%v,%v}", n.Left(), n.List().First(), n.List().Second())
+		fmt.Fprintf(s, "sliceheader{%v,%v,%v}", n.Ptr, n.LenCap.First(), n.LenCap.Second())
 
 	case OCOMPLEX, OCOPY:
 		n := n.(*BinaryExpr)
-		fmt.Fprintf(s, "%v(%v, %v)", n.Op(), n.Left(), n.Right())
+		fmt.Fprintf(s, "%v(%v, %v)", n.Op(), n.X, n.Y)
 
 	case OCONV,
 		OCONVIFACE,
@@ -823,7 +823,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		} else {
 			fmt.Fprintf(s, "%v", n.Type())
 		}
-		fmt.Fprintf(s, "(%v)", n.Left())
+		fmt.Fprintf(s, "(%v)", n.X)
 
 	case OREAL,
 		OIMAG,
@@ -836,7 +836,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		OOFFSETOF,
 		OSIZEOF:
 		n := n.(*UnaryExpr)
-		fmt.Fprintf(s, "%v(%v)", n.Op(), n.Left())
+		fmt.Fprintf(s, "%v(%v)", n.Op(), n.X)
 
 	case OAPPEND,
 		ODELETE,
@@ -845,58 +845,58 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		OPRINT,
 		OPRINTN:
 		n := n.(*CallExpr)
-		if n.IsDDD() {
-			fmt.Fprintf(s, "%v(%.v...)", n.Op(), n.List())
+		if n.IsDDD {
+			fmt.Fprintf(s, "%v(%.v...)", n.Op(), n.Args)
 			return
 		}
-		fmt.Fprintf(s, "%v(%.v)", n.Op(), n.List())
+		fmt.Fprintf(s, "%v(%.v)", n.Op(), n.Args)
 
 	case OCALL, OCALLFUNC, OCALLINTER, OCALLMETH, OGETG:
 		n := n.(*CallExpr)
-		exprFmt(n.Left(), s, nprec)
-		if n.IsDDD() {
-			fmt.Fprintf(s, "(%.v...)", n.List())
+		exprFmt(n.X, s, nprec)
+		if n.IsDDD {
+			fmt.Fprintf(s, "(%.v...)", n.Args)
 			return
 		}
-		fmt.Fprintf(s, "(%.v)", n.List())
+		fmt.Fprintf(s, "(%.v)", n.Args)
 
 	case OMAKEMAP, OMAKECHAN, OMAKESLICE:
 		n := n.(*MakeExpr)
-		if n.Right() != nil {
-			fmt.Fprintf(s, "make(%v, %v, %v)", n.Type(), n.Left(), n.Right())
+		if n.Cap != nil {
+			fmt.Fprintf(s, "make(%v, %v, %v)", n.Type(), n.Len, n.Cap)
 			return
 		}
-		if n.Left() != nil && (n.Op() == OMAKESLICE || !n.Left().Type().IsUntyped()) {
-			fmt.Fprintf(s, "make(%v, %v)", n.Type(), n.Left())
+		if n.Len != nil && (n.Op() == OMAKESLICE || !n.Len.Type().IsUntyped()) {
+			fmt.Fprintf(s, "make(%v, %v)", n.Type(), n.Len)
 			return
 		}
 		fmt.Fprintf(s, "make(%v)", n.Type())
 
 	case OMAKESLICECOPY:
 		n := n.(*MakeExpr)
-		fmt.Fprintf(s, "makeslicecopy(%v, %v, %v)", n.Type(), n.Left(), n.Right())
+		fmt.Fprintf(s, "makeslicecopy(%v, %v, %v)", n.Type(), n.Len, n.Cap)
 
 	case OPLUS, ONEG, OBITNOT, ONOT, ORECV:
 		// Unary
 		n := n.(*UnaryExpr)
 		fmt.Fprintf(s, "%v", n.Op())
-		if n.Left() != nil && n.Left().Op() == n.Op() {
+		if n.X != nil && n.X.Op() == n.Op() {
 			fmt.Fprint(s, " ")
 		}
-		exprFmt(n.Left(), s, nprec+1)
+		exprFmt(n.X, s, nprec+1)
 
 	case OADDR:
 		n := n.(*AddrExpr)
 		fmt.Fprintf(s, "%v", n.Op())
-		if n.Left() != nil && n.Left().Op() == n.Op() {
+		if n.X != nil && n.X.Op() == n.Op() {
 			fmt.Fprint(s, " ")
 		}
-		exprFmt(n.Left(), s, nprec+1)
+		exprFmt(n.X, s, nprec+1)
 
 	case ODEREF:
 		n := n.(*StarExpr)
 		fmt.Fprintf(s, "%v", n.Op())
-		exprFmt(n.Left(), s, nprec+1)
+		exprFmt(n.X, s, nprec+1)
 
 		// Binary
 	case OADD,
@@ -917,26 +917,26 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		OSUB,
 		OXOR:
 		n := n.(*BinaryExpr)
-		exprFmt(n.Left(), s, nprec)
+		exprFmt(n.X, s, nprec)
 		fmt.Fprintf(s, " %v ", n.Op())
-		exprFmt(n.Right(), s, nprec+1)
+		exprFmt(n.Y, s, nprec+1)
 
 	case OANDAND,
 		OOROR:
 		n := n.(*LogicalExpr)
-		exprFmt(n.Left(), s, nprec)
+		exprFmt(n.X, s, nprec)
 		fmt.Fprintf(s, " %v ", n.Op())
-		exprFmt(n.Right(), s, nprec+1)
+		exprFmt(n.Y, s, nprec+1)
 
 	case OSEND:
 		n := n.(*SendStmt)
-		exprFmt(n.Left(), s, nprec)
+		exprFmt(n.Chan, s, nprec)
 		fmt.Fprintf(s, " <- ")
-		exprFmt(n.Right(), s, nprec+1)
+		exprFmt(n.Value, s, nprec+1)
 
 	case OADDSTR:
 		n := n.(*AddStringExpr)
-		for i, n1 := range n.List().Slice() {
+		for i, n1 := range n.List.Slice() {
 			if i != 0 {
 				fmt.Fprint(s, " + ")
 			}
@@ -1098,7 +1098,7 @@ func dumpNodeHeader(w io.Writer, n Node) {
 
 	if n.Op() == OCLOSURE {
 		n := n.(*ClosureExpr)
-		if fn := n.Func(); fn != nil && fn.Nname.Sym() != nil {
+		if fn := n.Func; fn != nil && fn.Nname.Sym() != nil {
 			fmt.Fprintf(w, " fnName(%+v)", fn.Nname.Sym())
 		}
 	}
@@ -1169,7 +1169,7 @@ func dumpNode(w io.Writer, n Node, depth int) {
 
 	case OASOP:
 		n := n.(*AssignOpStmt)
-		fmt.Fprintf(w, "%+v-%+v", n.Op(), n.SubOp())
+		fmt.Fprintf(w, "%+v-%+v", n.Op(), n.AsOp)
 		dumpNodeHeader(w, n)
 
 	case OTYPE:
@@ -1192,18 +1192,18 @@ func dumpNode(w io.Writer, n Node, depth int) {
 		n := n.(*Func)
 		fmt.Fprintf(w, "%+v", n.Op())
 		dumpNodeHeader(w, n)
-		fn := n.Func()
+		fn := n
 		if len(fn.Dcl) > 0 {
 			indent(w, depth)
 			fmt.Fprintf(w, "%+v-Dcl", n.Op())
-			for _, dcl := range n.Func().Dcl {
+			for _, dcl := range n.Dcl {
 				dumpNode(w, dcl, depth+1)
 			}
 		}
-		if fn.Body().Len() > 0 {
+		if fn.Body.Len() > 0 {
 			indent(w, depth)
 			fmt.Fprintf(w, "%+v-body", n.Op())
-			dumpNodes(w, fn.Body(), depth+1)
+			dumpNodes(w, fn.Body, depth+1)
 		}
 		return
 	}
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 62ac5791d1..57837e9e6b 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -49,9 +49,9 @@ import (
 // pointer from the Func back to the OCALLPART.
 type Func struct {
 	miniNode
-	typ   *types.Type
-	Body_ Nodes
-	iota  int64
+	typ  *types.Type
+	Body Nodes
+	Iota int64
 
 	Nname    *Name        // ONAME node
 	OClosure *ClosureExpr // OCLOSURE node
@@ -110,20 +110,14 @@ func NewFunc(pos src.XPos) *Func {
 	f := new(Func)
 	f.pos = pos
 	f.op = ODCLFUNC
-	f.iota = -1
+	f.Iota = -1
 	return f
 }
 
 func (f *Func) isStmt() {}
 
-func (f *Func) Func() *Func           { return f }
-func (f *Func) Body() Nodes           { return f.Body_ }
-func (f *Func) PtrBody() *Nodes       { return &f.Body_ }
-func (f *Func) SetBody(x Nodes)       { f.Body_ = x }
 func (f *Func) Type() *types.Type     { return f.typ }
 func (f *Func) SetType(x *types.Type) { f.typ = x }
-func (f *Func) Iota() int64           { return f.iota }
-func (f *Func) SetIota(x int64)       { f.iota = x }
 
 func (f *Func) Sym() *types.Sym {
 	if f.Nname != nil {
@@ -218,11 +212,11 @@ func FuncName(n Node) string {
 	case *Func:
 		f = n
 	case *Name:
-		f = n.Func()
+		f = n.Func
 	case *CallPartExpr:
-		f = n.Func()
+		f = n.Func
 	case *ClosureExpr:
-		f = n.Func()
+		f = n.Func
 	}
 	if f == nil || f.Nname == nil {
 		return "<nil>"
@@ -245,9 +239,9 @@ func PkgFuncName(n Node) string {
 		var f *Func
 		switch n := n.(type) {
 		case *CallPartExpr:
-			f = n.Func()
+			f = n.Func
 		case *ClosureExpr:
-			f = n.Func()
+			f = n.Func
 		case *Func:
 			f = n
 		}
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 64c60b93d8..770f8119e0 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -39,7 +39,7 @@ type Name struct {
 	flags     bitset16
 	pragma    PragmaFlag // int16
 	sym       *types.Sym
-	fn        *Func
+	Func      *Func
 	Offset_   int64
 	val       constant.Value
 	orig      Node
@@ -225,8 +225,7 @@ func (n *Name) SubOp() Op           { return n.BuiltinOp }
 func (n *Name) SetSubOp(x Op)       { n.BuiltinOp = x }
 func (n *Name) Class() Class        { return n.Class_ }
 func (n *Name) SetClass(x Class)    { n.Class_ = x }
-func (n *Name) Func() *Func         { return n.fn }
-func (n *Name) SetFunc(x *Func)     { n.fn = x }
+func (n *Name) SetFunc(x *Func)     { n.Func = x }
 func (n *Name) Offset() int64       { panic("Name.Offset") }
 func (n *Name) SetOffset(x int64) {
 	if x != 0 {
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index a5959ea26f..89b1c0ba23 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -8,18 +8,18 @@ func (n *AddStringExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *AddStringExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
-	c.List_ = c.List_.Copy()
+	c.List = c.List.Copy()
 	return &c
 }
 func (n *AddStringExpr) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
-	err = maybeDoList(n.List_, err, do)
+	err = maybeDoList(n.List, err, do)
 	return err
 }
 func (n *AddStringExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
-	editList(n.List_, edit)
+	editList(n.List, edit)
 }
 
 func (n *AddrExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
@@ -154,18 +154,18 @@ func (n *BlockStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *BlockStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
-	c.List_ = c.List_.Copy()
+	c.List = c.List.Copy()
 	return &c
 }
 func (n *BlockStmt) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
-	err = maybeDoList(n.List_, err, do)
+	err = maybeDoList(n.List, err, do)
 	return err
 }
 func (n *BlockStmt) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
-	editList(n.List_, edit)
+	editList(n.List, edit)
 }
 
 func (n *BranchStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
@@ -189,7 +189,7 @@ func (n *CallExpr) copy() Node {
 	c.init = c.init.Copy()
 	c.Args = c.Args.Copy()
 	c.Rargs = c.Rargs.Copy()
-	c.Body_ = c.Body_.Copy()
+	c.Body = c.Body.Copy()
 	return &c
 }
 func (n *CallExpr) doChildren(do func(Node) error) error {
@@ -198,7 +198,7 @@ func (n *CallExpr) doChildren(do func(Node) error) error {
 	err = maybeDo(n.X, err, do)
 	err = maybeDoList(n.Args, err, do)
 	err = maybeDoList(n.Rargs, err, do)
-	err = maybeDoList(n.Body_, err, do)
+	err = maybeDoList(n.Body, err, do)
 	return err
 }
 func (n *CallExpr) editChildren(edit func(Node) Node) {
@@ -206,7 +206,7 @@ func (n *CallExpr) editChildren(edit func(Node) Node) {
 	n.X = maybeEdit(n.X, edit)
 	editList(n.Args, edit)
 	editList(n.Rargs, edit)
-	editList(n.Body_, edit)
+	editList(n.Body, edit)
 }
 
 func (n *CallPartExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
@@ -231,25 +231,25 @@ func (n *CaseStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
 	c.Vars = c.Vars.Copy()
-	c.List_ = c.List_.Copy()
-	c.Body_ = c.Body_.Copy()
+	c.List = c.List.Copy()
+	c.Body = c.Body.Copy()
 	return &c
 }
 func (n *CaseStmt) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
 	err = maybeDoList(n.Vars, err, do)
-	err = maybeDoList(n.List_, err, do)
+	err = maybeDoList(n.List, err, do)
 	err = maybeDo(n.Comm, err, do)
-	err = maybeDoList(n.Body_, err, do)
+	err = maybeDoList(n.Body, err, do)
 	return err
 }
 func (n *CaseStmt) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	editList(n.Vars, edit)
-	editList(n.List_, edit)
+	editList(n.List, edit)
 	n.Comm = maybeEdit(n.Comm, edit)
-	editList(n.Body_, edit)
+	editList(n.Body, edit)
 }
 
 func (n *ChanType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
@@ -300,20 +300,20 @@ func (n *CompLitExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *CompLitExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
-	c.List_ = c.List_.Copy()
+	c.List = c.List.Copy()
 	return &c
 }
 func (n *CompLitExpr) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
 	err = maybeDo(n.Ntype, err, do)
-	err = maybeDoList(n.List_, err, do)
+	err = maybeDoList(n.List, err, do)
 	return err
 }
 func (n *CompLitExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	n.Ntype = toNtype(maybeEdit(n.Ntype, edit))
-	editList(n.List_, edit)
+	editList(n.List, edit)
 }
 
 func (n *ConstExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
@@ -367,7 +367,7 @@ func (n *ForStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
 	c.Late = c.Late.Copy()
-	c.Body_ = c.Body_.Copy()
+	c.Body = c.Body.Copy()
 	return &c
 }
 func (n *ForStmt) doChildren(do func(Node) error) error {
@@ -376,7 +376,7 @@ func (n *ForStmt) doChildren(do func(Node) error) error {
 	err = maybeDo(n.Cond, err, do)
 	err = maybeDoList(n.Late, err, do)
 	err = maybeDo(n.Post, err, do)
-	err = maybeDoList(n.Body_, err, do)
+	err = maybeDoList(n.Body, err, do)
 	return err
 }
 func (n *ForStmt) editChildren(edit func(Node) Node) {
@@ -384,22 +384,22 @@ func (n *ForStmt) editChildren(edit func(Node) Node) {
 	n.Cond = maybeEdit(n.Cond, edit)
 	editList(n.Late, edit)
 	n.Post = maybeEdit(n.Post, edit)
-	editList(n.Body_, edit)
+	editList(n.Body, edit)
 }
 
 func (n *Func) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *Func) copy() Node {
 	c := *n
-	c.Body_ = c.Body_.Copy()
+	c.Body = c.Body.Copy()
 	return &c
 }
 func (n *Func) doChildren(do func(Node) error) error {
 	var err error
-	err = maybeDoList(n.Body_, err, do)
+	err = maybeDoList(n.Body, err, do)
 	return err
 }
 func (n *Func) editChildren(edit func(Node) Node) {
-	editList(n.Body_, edit)
+	editList(n.Body, edit)
 }
 
 func (n *FuncType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
@@ -461,7 +461,7 @@ func (n *IfStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *IfStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
-	c.Body_ = c.Body_.Copy()
+	c.Body = c.Body.Copy()
 	c.Else = c.Else.Copy()
 	return &c
 }
@@ -469,14 +469,14 @@ func (n *IfStmt) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
 	err = maybeDo(n.Cond, err, do)
-	err = maybeDoList(n.Body_, err, do)
+	err = maybeDoList(n.Body, err, do)
 	err = maybeDoList(n.Else, err, do)
 	return err
 }
 func (n *IfStmt) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	n.Cond = maybeEdit(n.Cond, edit)
-	editList(n.Body_, edit)
+	editList(n.Body, edit)
 	editList(n.Else, edit)
 }
 
@@ -518,20 +518,20 @@ func (n *InlinedCallExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *InlinedCallExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
-	c.Body_ = c.Body_.Copy()
+	c.Body = c.Body.Copy()
 	c.ReturnVars = c.ReturnVars.Copy()
 	return &c
 }
 func (n *InlinedCallExpr) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
-	err = maybeDoList(n.Body_, err, do)
+	err = maybeDoList(n.Body, err, do)
 	err = maybeDoList(n.ReturnVars, err, do)
 	return err
 }
 func (n *InlinedCallExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
-	editList(n.Body_, edit)
+	editList(n.Body, edit)
 	editList(n.ReturnVars, edit)
 }
 
@@ -726,7 +726,7 @@ func (n *RangeStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
 	c.Vars = c.Vars.Copy()
-	c.Body_ = c.Body_.Copy()
+	c.Body = c.Body.Copy()
 	return &c
 }
 func (n *RangeStmt) doChildren(do func(Node) error) error {
@@ -734,14 +734,14 @@ func (n *RangeStmt) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.init, err, do)
 	err = maybeDoList(n.Vars, err, do)
 	err = maybeDo(n.X, err, do)
-	err = maybeDoList(n.Body_, err, do)
+	err = maybeDoList(n.Body, err, do)
 	return err
 }
 func (n *RangeStmt) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	editList(n.Vars, edit)
 	n.X = maybeEdit(n.X, edit)
-	editList(n.Body_, edit)
+	editList(n.Body, edit)
 }
 
 func (n *ResultExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
@@ -838,40 +838,40 @@ func (n *SliceExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *SliceExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
-	c.List_ = c.List_.Copy()
+	c.List = c.List.Copy()
 	return &c
 }
 func (n *SliceExpr) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
 	err = maybeDo(n.X, err, do)
-	err = maybeDoList(n.List_, err, do)
+	err = maybeDoList(n.List, err, do)
 	return err
 }
 func (n *SliceExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	n.X = maybeEdit(n.X, edit)
-	editList(n.List_, edit)
+	editList(n.List, edit)
 }
 
 func (n *SliceHeaderExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *SliceHeaderExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
-	c.LenCap_ = c.LenCap_.Copy()
+	c.LenCap = c.LenCap.Copy()
 	return &c
 }
 func (n *SliceHeaderExpr) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
 	err = maybeDo(n.Ptr, err, do)
-	err = maybeDoList(n.LenCap_, err, do)
+	err = maybeDoList(n.LenCap, err, do)
 	return err
 }
 func (n *SliceHeaderExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	n.Ptr = maybeEdit(n.Ptr, edit)
-	editList(n.LenCap_, edit)
+	editList(n.LenCap, edit)
 }
 
 func (n *SliceType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index e2543a5541..ad6db436a7 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -30,9 +30,6 @@ func NewDecl(pos src.XPos, op Op, x Node) *Decl {
 
 func (*Decl) isStmt() {}
 
-func (n *Decl) Left() Node     { return n.X }
-func (n *Decl) SetLeft(x Node) { n.X = x }
-
 // A Stmt is a Node that can appear as a statement.
 // This includes statement-like expressions such as f().
 //
@@ -78,15 +75,6 @@ func NewAssignListStmt(pos src.XPos, op Op, lhs, rhs []Node) *AssignListStmt {
 	return n
 }
 
-func (n *AssignListStmt) List() Nodes      { return n.Lhs }
-func (n *AssignListStmt) PtrList() *Nodes  { return &n.Lhs }
-func (n *AssignListStmt) SetList(x Nodes)  { n.Lhs = x }
-func (n *AssignListStmt) Rlist() Nodes     { return n.Rhs }
-func (n *AssignListStmt) PtrRlist() *Nodes { return &n.Rhs }
-func (n *AssignListStmt) SetRlist(x Nodes) { n.Rhs = x }
-func (n *AssignListStmt) Colas() bool      { return n.Def }
-func (n *AssignListStmt) SetColas(x bool)  { n.Def = x }
-
 func (n *AssignListStmt) SetOp(op Op) {
 	switch op {
 	default:
@@ -112,13 +100,6 @@ func NewAssignStmt(pos src.XPos, x, y Node) *AssignStmt {
 	return n
 }
 
-func (n *AssignStmt) Left() Node      { return n.X }
-func (n *AssignStmt) SetLeft(x Node)  { n.X = x }
-func (n *AssignStmt) Right() Node     { return n.Y }
-func (n *AssignStmt) SetRight(y Node) { n.Y = y }
-func (n *AssignStmt) Colas() bool     { return n.Def }
-func (n *AssignStmt) SetColas(x bool) { n.Def = x }
-
 func (n *AssignStmt) SetOp(op Op) {
 	switch op {
 	default:
@@ -145,21 +126,13 @@ func NewAssignOpStmt(pos src.XPos, asOp Op, x, y Node) *AssignOpStmt {
 	return n
 }
 
-func (n *AssignOpStmt) Left() Node            { return n.X }
-func (n *AssignOpStmt) SetLeft(x Node)        { n.X = x }
-func (n *AssignOpStmt) Right() Node           { return n.Y }
-func (n *AssignOpStmt) SetRight(y Node)       { n.Y = y }
-func (n *AssignOpStmt) SubOp() Op             { return n.AsOp }
-func (n *AssignOpStmt) SetSubOp(x Op)         { n.AsOp = x }
-func (n *AssignOpStmt) Implicit() bool        { return n.IncDec }
-func (n *AssignOpStmt) SetImplicit(b bool)    { n.IncDec = b }
 func (n *AssignOpStmt) Type() *types.Type     { return n.typ }
 func (n *AssignOpStmt) SetType(x *types.Type) { n.typ = x }
 
 // A BlockStmt is a block: { List }.
 type BlockStmt struct {
 	miniStmt
-	List_ Nodes
+	List Nodes
 }
 
 func NewBlockStmt(pos src.XPos, list []Node) *BlockStmt {
@@ -172,14 +145,10 @@ func NewBlockStmt(pos src.XPos, list []Node) *BlockStmt {
 		}
 	}
 	n.op = OBLOCK
-	n.List_.Set(list)
+	n.List.Set(list)
 	return n
 }
 
-func (n *BlockStmt) List() Nodes     { return n.List_ }
-func (n *BlockStmt) PtrList() *Nodes { return &n.List_ }
-func (n *BlockStmt) SetList(x Nodes) { n.List_ = x }
-
 // A BranchStmt is a break, continue, fallthrough, or goto statement.
 //
 // For back-end code generation, Op may also be RETJMP (return+jump),
@@ -202,49 +171,36 @@ func NewBranchStmt(pos src.XPos, op Op, label *types.Sym) *BranchStmt {
 	return n
 }
 
-func (n *BranchStmt) Sym() *types.Sym       { return n.Label }
-func (n *BranchStmt) SetSym(sym *types.Sym) { n.Label = sym }
+func (n *BranchStmt) Sym() *types.Sym { return n.Label }
 
 // A CaseStmt is a case statement in a switch or select: case List: Body.
 type CaseStmt struct {
 	miniStmt
-	Vars  Nodes // declared variable for this case in type switch
-	List_ Nodes // list of expressions for switch, early select
-	Comm  Node  // communication case (Exprs[0]) after select is type-checked
-	Body_ Nodes
+	Vars Nodes // declared variable for this case in type switch
+	List Nodes // list of expressions for switch, early select
+	Comm Node  // communication case (Exprs[0]) after select is type-checked
+	Body Nodes
 }
 
 func NewCaseStmt(pos src.XPos, list, body []Node) *CaseStmt {
 	n := &CaseStmt{}
 	n.pos = pos
 	n.op = OCASE
-	n.List_.Set(list)
-	n.Body_.Set(body)
+	n.List.Set(list)
+	n.Body.Set(body)
 	return n
 }
 
-func (n *CaseStmt) List() Nodes      { return n.List_ }
-func (n *CaseStmt) PtrList() *Nodes  { return &n.List_ }
-func (n *CaseStmt) SetList(x Nodes)  { n.List_ = x }
-func (n *CaseStmt) Body() Nodes      { return n.Body_ }
-func (n *CaseStmt) PtrBody() *Nodes  { return &n.Body_ }
-func (n *CaseStmt) SetBody(x Nodes)  { n.Body_ = x }
-func (n *CaseStmt) Rlist() Nodes     { return n.Vars }
-func (n *CaseStmt) PtrRlist() *Nodes { return &n.Vars }
-func (n *CaseStmt) SetRlist(x Nodes) { n.Vars = x }
-func (n *CaseStmt) Left() Node       { return n.Comm }
-func (n *CaseStmt) SetLeft(x Node)   { n.Comm = x }
-
 // A ForStmt is a non-range for loop: for Init; Cond; Post { Body }
 // Op can be OFOR or OFORUNTIL (!Cond).
 type ForStmt struct {
 	miniStmt
-	Label     *types.Sym
-	Cond      Node
-	Late      Nodes
-	Post      Node
-	Body_     Nodes
-	HasBreak_ bool
+	Label    *types.Sym
+	Cond     Node
+	Late     Nodes
+	Post     Node
+	Body     Nodes
+	HasBreak bool
 }
 
 func NewForStmt(pos src.XPos, init []Node, cond, post Node, body []Node) *ForStmt {
@@ -252,25 +208,10 @@ func NewForStmt(pos src.XPos, init []Node, cond, post Node, body []Node) *ForStm
 	n.pos = pos
 	n.op = OFOR
 	n.init.Set(init)
-	n.Body_.Set(body)
+	n.Body.Set(body)
 	return n
 }
 
-func (n *ForStmt) Sym() *types.Sym     { return n.Label }
-func (n *ForStmt) SetSym(x *types.Sym) { n.Label = x }
-func (n *ForStmt) Left() Node          { return n.Cond }
-func (n *ForStmt) SetLeft(x Node)      { n.Cond = x }
-func (n *ForStmt) Right() Node         { return n.Post }
-func (n *ForStmt) SetRight(x Node)     { n.Post = x }
-func (n *ForStmt) Body() Nodes         { return n.Body_ }
-func (n *ForStmt) PtrBody() *Nodes     { return &n.Body_ }
-func (n *ForStmt) SetBody(x Nodes)     { n.Body_ = x }
-func (n *ForStmt) List() Nodes         { return n.Late }
-func (n *ForStmt) PtrList() *Nodes     { return &n.Late }
-func (n *ForStmt) SetList(x Nodes)     { n.Late = x }
-func (n *ForStmt) HasBreak() bool      { return n.HasBreak_ }
-func (n *ForStmt) SetHasBreak(b bool)  { n.HasBreak_ = b }
-
 func (n *ForStmt) SetOp(op Op) {
 	if op != OFOR && op != OFORUNTIL {
 		panic(n.no("SetOp " + op.String()))
@@ -300,38 +241,24 @@ func NewGoDeferStmt(pos src.XPos, op Op, call Node) *GoDeferStmt {
 	return n
 }
 
-func (n *GoDeferStmt) Left() Node     { return n.Call }
-func (n *GoDeferStmt) SetLeft(x Node) { n.Call = x }
-
 // A IfStmt is a return statement: if Init; Cond { Then } else { Else }.
 type IfStmt struct {
 	miniStmt
-	Cond    Node
-	Body_   Nodes
-	Else    Nodes
-	Likely_ bool // code layout hint
+	Cond   Node
+	Body   Nodes
+	Else   Nodes
+	Likely bool // code layout hint
 }
 
 func NewIfStmt(pos src.XPos, cond Node, body, els []Node) *IfStmt {
 	n := &IfStmt{Cond: cond}
 	n.pos = pos
 	n.op = OIF
-	n.Body_.Set(body)
+	n.Body.Set(body)
 	n.Else.Set(els)
 	return n
 }
 
-func (n *IfStmt) Left() Node       { return n.Cond }
-func (n *IfStmt) SetLeft(x Node)   { n.Cond = x }
-func (n *IfStmt) Body() Nodes      { return n.Body_ }
-func (n *IfStmt) PtrBody() *Nodes  { return &n.Body_ }
-func (n *IfStmt) SetBody(x Nodes)  { n.Body_ = x }
-func (n *IfStmt) Rlist() Nodes     { return n.Else }
-func (n *IfStmt) PtrRlist() *Nodes { return &n.Else }
-func (n *IfStmt) SetRlist(x Nodes) { n.Else = x }
-func (n *IfStmt) Likely() bool     { return n.Likely_ }
-func (n *IfStmt) SetLikely(x bool) { n.Likely_ = x }
-
 // An InlineMarkStmt is a marker placed just before an inlined body.
 type InlineMarkStmt struct {
 	miniStmt
@@ -361,21 +288,20 @@ func NewLabelStmt(pos src.XPos, label *types.Sym) *LabelStmt {
 	return n
 }
 
-func (n *LabelStmt) Sym() *types.Sym     { return n.Label }
-func (n *LabelStmt) SetSym(x *types.Sym) { n.Label = x }
+func (n *LabelStmt) Sym() *types.Sym { return n.Label }
 
 // A RangeStmt is a range loop: for Vars = range X { Stmts }
 // Op can be OFOR or OFORUNTIL (!Cond).
 type RangeStmt struct {
 	miniStmt
-	Label     *types.Sym
-	Vars      Nodes // TODO(rsc): Replace with Key, Value Node
-	Def       bool
-	X         Node
-	Body_     Nodes
-	HasBreak_ bool
-	typ       *types.Type // TODO(rsc): Remove - use X.Type() instead
-	Prealloc  *Name
+	Label    *types.Sym
+	Vars     Nodes // TODO(rsc): Replace with Key, Value Node
+	Def      bool
+	X        Node
+	Body     Nodes
+	HasBreak bool
+	typ      *types.Type // TODO(rsc): Remove - use X.Type() instead
+	Prealloc *Name
 }
 
 func NewRangeStmt(pos src.XPos, vars []Node, x Node, body []Node) *RangeStmt {
@@ -383,24 +309,10 @@ func NewRangeStmt(pos src.XPos, vars []Node, x Node, body []Node) *RangeStmt {
 	n.pos = pos
 	n.op = ORANGE
 	n.Vars.Set(vars)
-	n.Body_.Set(body)
+	n.Body.Set(body)
 	return n
 }
 
-func (n *RangeStmt) Sym() *types.Sym       { return n.Label }
-func (n *RangeStmt) SetSym(x *types.Sym)   { n.Label = x }
-func (n *RangeStmt) Right() Node           { return n.X }
-func (n *RangeStmt) SetRight(x Node)       { n.X = x }
-func (n *RangeStmt) Body() Nodes           { return n.Body_ }
-func (n *RangeStmt) PtrBody() *Nodes       { return &n.Body_ }
-func (n *RangeStmt) SetBody(x Nodes)       { n.Body_ = x }
-func (n *RangeStmt) List() Nodes           { return n.Vars }
-func (n *RangeStmt) PtrList() *Nodes       { return &n.Vars }
-func (n *RangeStmt) SetList(x Nodes)       { n.Vars = x }
-func (n *RangeStmt) HasBreak() bool        { return n.HasBreak_ }
-func (n *RangeStmt) SetHasBreak(b bool)    { n.HasBreak_ = b }
-func (n *RangeStmt) Colas() bool           { return n.Def }
-func (n *RangeStmt) SetColas(b bool)       { n.Def = b }
 func (n *RangeStmt) Type() *types.Type     { return n.typ }
 func (n *RangeStmt) SetType(x *types.Type) { n.typ = x }
 
@@ -420,19 +332,15 @@ func NewReturnStmt(pos src.XPos, results []Node) *ReturnStmt {
 	return n
 }
 
-func (n *ReturnStmt) Orig() Node      { return n.orig }
-func (n *ReturnStmt) SetOrig(x Node)  { n.orig = x }
-func (n *ReturnStmt) List() Nodes     { return n.Results }
-func (n *ReturnStmt) PtrList() *Nodes { return &n.Results }
-func (n *ReturnStmt) SetList(x Nodes) { n.Results = x }
-func (n *ReturnStmt) IsDDD() bool     { return false } // typecheckargs asks
+func (n *ReturnStmt) Orig() Node     { return n.orig }
+func (n *ReturnStmt) SetOrig(x Node) { n.orig = x }
 
 // A SelectStmt is a block: { Cases }.
 type SelectStmt struct {
 	miniStmt
-	Label     *types.Sym
-	Cases     Nodes
-	HasBreak_ bool
+	Label    *types.Sym
+	Cases    Nodes
+	HasBreak bool
 
 	// TODO(rsc): Instead of recording here, replace with a block?
 	Compiled Nodes // compiled form, after walkswitch
@@ -446,17 +354,6 @@ func NewSelectStmt(pos src.XPos, cases []Node) *SelectStmt {
 	return n
 }
 
-func (n *SelectStmt) List() Nodes         { return n.Cases }
-func (n *SelectStmt) PtrList() *Nodes     { return &n.Cases }
-func (n *SelectStmt) SetList(x Nodes)     { n.Cases = x }
-func (n *SelectStmt) Sym() *types.Sym     { return n.Label }
-func (n *SelectStmt) SetSym(x *types.Sym) { n.Label = x }
-func (n *SelectStmt) HasBreak() bool      { return n.HasBreak_ }
-func (n *SelectStmt) SetHasBreak(x bool)  { n.HasBreak_ = x }
-func (n *SelectStmt) Body() Nodes         { return n.Compiled }
-func (n *SelectStmt) PtrBody() *Nodes     { return &n.Compiled }
-func (n *SelectStmt) SetBody(x Nodes)     { n.Compiled = x }
-
 // A SendStmt is a send statement: X <- Y.
 type SendStmt struct {
 	miniStmt
@@ -471,18 +368,13 @@ func NewSendStmt(pos src.XPos, ch, value Node) *SendStmt {
 	return n
 }
 
-func (n *SendStmt) Left() Node      { return n.Chan }
-func (n *SendStmt) SetLeft(x Node)  { n.Chan = x }
-func (n *SendStmt) Right() Node     { return n.Value }
-func (n *SendStmt) SetRight(y Node) { n.Value = y }
-
 // A SwitchStmt is a switch statement: switch Init; Expr { Cases }.
 type SwitchStmt struct {
 	miniStmt
-	Tag       Node
-	Cases     Nodes // list of *CaseStmt
-	Label     *types.Sym
-	HasBreak_ bool
+	Tag      Node
+	Cases    Nodes // list of *CaseStmt
+	Label    *types.Sym
+	HasBreak bool
 
 	// TODO(rsc): Instead of recording here, replace with a block?
 	Compiled Nodes // compiled form, after walkswitch
@@ -496,19 +388,6 @@ func NewSwitchStmt(pos src.XPos, tag Node, cases []Node) *SwitchStmt {
 	return n
 }
 
-func (n *SwitchStmt) Left() Node          { return n.Tag }
-func (n *SwitchStmt) SetLeft(x Node)      { n.Tag = x }
-func (n *SwitchStmt) List() Nodes         { return n.Cases }
-func (n *SwitchStmt) PtrList() *Nodes     { return &n.Cases }
-func (n *SwitchStmt) SetList(x Nodes)     { n.Cases = x }
-func (n *SwitchStmt) Body() Nodes         { return n.Compiled }
-func (n *SwitchStmt) PtrBody() *Nodes     { return &n.Compiled }
-func (n *SwitchStmt) SetBody(x Nodes)     { n.Compiled = x }
-func (n *SwitchStmt) Sym() *types.Sym     { return n.Label }
-func (n *SwitchStmt) SetSym(x *types.Sym) { n.Label = x }
-func (n *SwitchStmt) HasBreak() bool      { return n.HasBreak_ }
-func (n *SwitchStmt) SetHasBreak(x bool)  { n.HasBreak_ = x }
-
 // A TypeSwitchGuard is the [Name :=] X.(type) in a type switch.
 type TypeSwitchGuard struct {
 	miniNode
@@ -523,19 +402,3 @@ func NewTypeSwitchGuard(pos src.XPos, tag *Ident, x Node) *TypeSwitchGuard {
 	n.op = OTYPESW
 	return n
 }
-
-func (n *TypeSwitchGuard) Left() Node {
-	if n.Tag == nil {
-		return nil
-	}
-	return n.Tag
-}
-func (n *TypeSwitchGuard) SetLeft(x Node) {
-	if x == nil {
-		n.Tag = nil
-		return
-	}
-	n.Tag = x.(*Ident)
-}
-func (n *TypeSwitchGuard) Right() Node     { return n.X }
-func (n *TypeSwitchGuard) SetRight(x Node) { n.X = x }
-- 
GitLab


From 440308ffd7061e0eb386a9a8469575528b41dcd4 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 23 Dec 2020 00:03:33 -0500
Subject: [PATCH 0299/2400] [dev.regabi] cmd/compile: simplify Nodes usage
 [generated]

Now that Nodes is a slice, most of the methods can be removed
in favor of direct slice operations, reducing the new API that must
be understood to:

	Copy
	Take
	Append
	Prepend
	Format

Passes buildall w/ toolstash -cmp.

[git-generate]
cd src/cmd/compile/internal/ir
rf '
ex . ../gc {
	var ns Nodes
	var pns *Nodes
	var n, n2, n3 Node
	var i int
	var slice []Node

	ns.Len() -> len(ns)
	ns.Slice() -> ns
	ns.First() -> ns[0]
	ns.Second() -> ns[1]
	ns.Index(i) -> ns[i]
	ns.Addr(i) -> &ns[i]
	ns.SetIndex(i, n) -> ns[i] = n
	ns.SetFirst(n) -> ns[0] = n
	ns.SetSecond(n) -> ns[1] = n
	ns.Set1(n) -> ns = []Node{n}
	ns.Set2(n, n2) -> ns = []Node{n, n2}
	ns.Set3(n, n2, n3) -> ns = []Node{n, n2, n3}
	ns.Set1(n) -> ns = []Node{n}
	ns.Set2(n, n2) -> ns = []Node{n, n2}
	ns.Set3(n, n2, n3) -> ns = []Node{n, n2, n3}
	AsNodes(slice) -> Nodes(slice)
	ns.AppendNodes(pns) -> ns.Append(pns.Take()...)
	ns.MoveNodes(pns) -> ns = pns.Take()
}

rm \
	Nodes.Len Nodes.Slice \
	Nodes.First Nodes.Second Nodes.Index Nodes.Addr \
	Nodes.SetIndex Nodes.SetFirst Nodes.SetSecond \
	Nodes.Set1 Nodes.Set2 Nodes.Set3 \
	AsNodes \
	Nodes.AppendNodes Nodes.MoveNodes
'

Change-Id: Iee86434ced52e67861c3fa71bdd6d994a8cba735
Reviewed-on: https://go-review.googlesource.com/c/go/+/277936
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/alg.go       |   4 +-
 src/cmd/compile/internal/gc/closure.go   |  10 +-
 src/cmd/compile/internal/gc/const.go     |   2 +-
 src/cmd/compile/internal/gc/dcl.go       |   4 +-
 src/cmd/compile/internal/gc/escape.go    |  54 ++---
 src/cmd/compile/internal/gc/gsubr.go     |   4 +-
 src/cmd/compile/internal/gc/iexport.go   |  22 +-
 src/cmd/compile/internal/gc/iimport.go   |  10 +-
 src/cmd/compile/internal/gc/init.go      |   4 +-
 src/cmd/compile/internal/gc/initorder.go |   4 +-
 src/cmd/compile/internal/gc/inl.go       |  62 +++---
 src/cmd/compile/internal/gc/noder.go     |  24 +--
 src/cmd/compile/internal/gc/order.go     |  96 ++++-----
 src/cmd/compile/internal/gc/pgen.go      |   4 +-
 src/cmd/compile/internal/gc/range.go     |  80 ++++----
 src/cmd/compile/internal/gc/select.go    |  84 ++++----
 src/cmd/compile/internal/gc/sinit.go     |  34 +--
 src/cmd/compile/internal/gc/ssa.go       |  56 ++---
 src/cmd/compile/internal/gc/subr.go      |  16 +-
 src/cmd/compile/internal/gc/swt.go       |  82 ++++----
 src/cmd/compile/internal/gc/typecheck.go | 194 +++++++++---------
 src/cmd/compile/internal/gc/walk.go      | 250 +++++++++++------------
 src/cmd/compile/internal/ir/dump.go      |   2 +-
 src/cmd/compile/internal/ir/expr.go      |  16 +-
 src/cmd/compile/internal/ir/fmt.go       |  46 ++---
 src/cmd/compile/internal/ir/node.go      |  92 +--------
 src/cmd/compile/internal/ir/visit.go     |  10 +-
 27 files changed, 588 insertions(+), 678 deletions(-)

diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index bb2717a8b5..49ce14b026 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -386,7 +386,7 @@ func genhash(t *types.Type) *obj.LSym {
 	typecheckFunc(fn)
 
 	Curfn = fn
-	typecheckslice(fn.Body.Slice(), ctxStmt)
+	typecheckslice(fn.Body, ctxStmt)
 	Curfn = nil
 
 	if base.Debug.DclStack != 0 {
@@ -762,7 +762,7 @@ func geneq(t *types.Type) *obj.LSym {
 	typecheckFunc(fn)
 
 	Curfn = fn
-	typecheckslice(fn.Body.Slice(), ctxStmt)
+	typecheckslice(fn.Body, ctxStmt)
 	Curfn = nil
 
 	if base.Debug.DclStack != 0 {
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index 1019cff331..27a9bc7cf8 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -124,7 +124,7 @@ func typecheckclosure(clo *ir.ClosureExpr, top int) {
 		Curfn = fn
 		olddd := decldepth
 		decldepth = 1
-		typecheckslice(fn.Body.Slice(), ctxStmt)
+		typecheckslice(fn.Body, ctxStmt)
 		decldepth = olddd
 		Curfn = oldfn
 	}
@@ -394,7 +394,7 @@ func walkclosure(clo *ir.ClosureExpr, init *ir.Nodes) ir.Node {
 
 	clos := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ).(ir.Ntype), nil)
 	clos.SetEsc(clo.Esc())
-	clos.List.Set(append([]ir.Node{ir.NewUnaryExpr(base.Pos, ir.OCFUNC, fn.Nname)}, fn.ClosureEnter.Slice()...))
+	clos.List.Set(append([]ir.Node{ir.NewUnaryExpr(base.Pos, ir.OCFUNC, fn.Nname)}, fn.ClosureEnter...))
 
 	addr := nodAddr(clos)
 	addr.SetEsc(clo.Esc())
@@ -484,7 +484,7 @@ func makepartialcall(dot *ir.SelectorExpr, t0 *types.Type, meth *types.Sym) *ir.
 	call.IsDDD = tfn.Type().IsVariadic()
 	if t0.NumResults() != 0 {
 		ret := ir.NewReturnStmt(base.Pos, nil)
-		ret.Results.Set1(call)
+		ret.Results = []ir.Node{call}
 		body = append(body, ret)
 	} else {
 		body = append(body, call)
@@ -497,7 +497,7 @@ func makepartialcall(dot *ir.SelectorExpr, t0 *types.Type, meth *types.Sym) *ir.
 	// Need to typecheck the body of the just-generated wrapper.
 	// typecheckslice() requires that Curfn is set when processing an ORETURN.
 	Curfn = fn
-	typecheckslice(fn.Body.Slice(), ctxStmt)
+	typecheckslice(fn.Body, ctxStmt)
 	sym.Def = fn
 	Target.Decls = append(Target.Decls, fn)
 	Curfn = savecurfn
@@ -543,7 +543,7 @@ func walkpartialcall(n *ir.CallPartExpr, init *ir.Nodes) ir.Node {
 
 	clos := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ).(ir.Ntype), nil)
 	clos.SetEsc(n.Esc())
-	clos.List.Set2(ir.NewUnaryExpr(base.Pos, ir.OCFUNC, n.Func.Nname), n.X)
+	clos.List = []ir.Node{ir.NewUnaryExpr(base.Pos, ir.OCFUNC, n.Func.Nname), n.X}
 
 	addr := nodAddr(clos)
 	addr.SetEsc(n.Esc())
diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 19eb8bc537..94bcf63263 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -534,7 +534,7 @@ func evalConst(n ir.Node) ir.Node {
 	case ir.OADDSTR:
 		// Merge adjacent constants in the argument list.
 		n := n.(*ir.AddStringExpr)
-		s := n.List.Slice()
+		s := n.List
 		need := 0
 		for i := 0; i < len(s); i++ {
 			if i == 0 || !ir.IsConst(s[i-1], constant.String) || !ir.IsConst(s[i], constant.String) {
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 9bd044c368..62cdff6b8e 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -137,7 +137,7 @@ func variter(vl []*ir.Name, t ir.Ntype, el []ir.Node) []ir.Node {
 	if len(el) == 1 && len(vl) > 1 {
 		e := el[0]
 		as2 := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-		as2.Rhs.Set1(e)
+		as2.Rhs = []ir.Node{e}
 		for _, v := range vl {
 			as2.Lhs.Append(v)
 			declare(v, dclcontext)
@@ -888,7 +888,7 @@ func (c *nowritebarrierrecChecker) findExtraCalls(nn ir.Node) {
 	}
 
 	var callee *ir.Func
-	arg := n.Args.First()
+	arg := n.Args[0]
 	switch arg.Op() {
 	case ir.ONAME:
 		arg := arg.(*ir.Name)
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 21f02e9471..fb9cbf2d51 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -368,10 +368,10 @@ func (e *Escape) stmt(n ir.Node) {
 		typesw := n.Tag != nil && n.Tag.Op() == ir.OTYPESW
 
 		var ks []EscHole
-		for _, cas := range n.Cases.Slice() { // cases
+		for _, cas := range n.Cases { // cases
 			cas := cas.(*ir.CaseStmt)
 			if typesw && n.Tag.(*ir.TypeSwitchGuard).Tag != nil {
-				cv := cas.Vars.First()
+				cv := cas.Vars[0]
 				k := e.dcl(cv) // type switch variables have no ODCL.
 				if cv.Type().HasPointers() {
 					ks = append(ks, k.dotType(cv.Type(), cas, "switch case"))
@@ -390,15 +390,15 @@ func (e *Escape) stmt(n ir.Node) {
 
 	case ir.OSELECT:
 		n := n.(*ir.SelectStmt)
-		for _, cas := range n.Cases.Slice() {
+		for _, cas := range n.Cases {
 			cas := cas.(*ir.CaseStmt)
 			e.stmt(cas.Comm)
 			e.block(cas.Body)
 		}
 	case ir.OSELRECV2:
 		n := n.(*ir.AssignListStmt)
-		e.assign(n.Lhs.First(), n.Rhs.First(), "selrecv", n)
-		e.assign(n.Lhs.Second(), nil, "selrecv", n)
+		e.assign(n.Lhs[0], n.Rhs[0], "selrecv", n)
+		e.assign(n.Lhs[1], nil, "selrecv", n)
 	case ir.ORECV:
 		// TODO(mdempsky): Consider e.discard(n.Left).
 		n := n.(*ir.UnaryExpr)
@@ -416,31 +416,31 @@ func (e *Escape) stmt(n ir.Node) {
 		e.assign(n.X, n.Y, "assign", n)
 	case ir.OAS2:
 		n := n.(*ir.AssignListStmt)
-		for i, nl := range n.Lhs.Slice() {
-			e.assign(nl, n.Rhs.Index(i), "assign-pair", n)
+		for i, nl := range n.Lhs {
+			e.assign(nl, n.Rhs[i], "assign-pair", n)
 		}
 
 	case ir.OAS2DOTTYPE: // v, ok = x.(type)
 		n := n.(*ir.AssignListStmt)
-		e.assign(n.Lhs.First(), n.Rhs.First(), "assign-pair-dot-type", n)
-		e.assign(n.Lhs.Second(), nil, "assign-pair-dot-type", n)
+		e.assign(n.Lhs[0], n.Rhs[0], "assign-pair-dot-type", n)
+		e.assign(n.Lhs[1], nil, "assign-pair-dot-type", n)
 	case ir.OAS2MAPR: // v, ok = m[k]
 		n := n.(*ir.AssignListStmt)
-		e.assign(n.Lhs.First(), n.Rhs.First(), "assign-pair-mapr", n)
-		e.assign(n.Lhs.Second(), nil, "assign-pair-mapr", n)
+		e.assign(n.Lhs[0], n.Rhs[0], "assign-pair-mapr", n)
+		e.assign(n.Lhs[1], nil, "assign-pair-mapr", n)
 	case ir.OAS2RECV: // v, ok = <-ch
 		n := n.(*ir.AssignListStmt)
-		e.assign(n.Lhs.First(), n.Rhs.First(), "assign-pair-receive", n)
-		e.assign(n.Lhs.Second(), nil, "assign-pair-receive", n)
+		e.assign(n.Lhs[0], n.Rhs[0], "assign-pair-receive", n)
+		e.assign(n.Lhs[1], nil, "assign-pair-receive", n)
 
 	case ir.OAS2FUNC:
 		n := n.(*ir.AssignListStmt)
-		e.stmts(n.Rhs.First().Init())
-		e.call(e.addrs(n.Lhs), n.Rhs.First(), nil)
+		e.stmts(n.Rhs[0].Init())
+		e.call(e.addrs(n.Lhs), n.Rhs[0], nil)
 	case ir.ORETURN:
 		n := n.(*ir.ReturnStmt)
 		results := e.curfn.Type().Results().FieldSlice()
-		for i, v := range n.Results.Slice() {
+		for i, v := range n.Results {
 			e.assign(ir.AsNode(results[i].Nname), v, "return", n)
 		}
 	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER, ir.OCLOSE, ir.OCOPY, ir.ODELETE, ir.OPANIC, ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
@@ -456,7 +456,7 @@ func (e *Escape) stmt(n ir.Node) {
 }
 
 func (e *Escape) stmts(l ir.Nodes) {
-	for _, n := range l.Slice() {
+	for _, n := range l {
 		e.stmt(n)
 	}
 }
@@ -641,7 +641,7 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 
 	case ir.OARRAYLIT:
 		n := n.(*ir.CompLitExpr)
-		for _, elt := range n.List.Slice() {
+		for _, elt := range n.List {
 			if elt.Op() == ir.OKEY {
 				elt = elt.(*ir.KeyExpr).Value
 			}
@@ -653,7 +653,7 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 		k = e.spill(k, n)
 		k.uintptrEscapesHack = uintptrEscapesHack // for ...uintptr parameters
 
-		for _, elt := range n.List.Slice() {
+		for _, elt := range n.List {
 			if elt.Op() == ir.OKEY {
 				elt = elt.(*ir.KeyExpr).Value
 			}
@@ -662,7 +662,7 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 
 	case ir.OSTRUCTLIT:
 		n := n.(*ir.CompLitExpr)
-		for _, elt := range n.List.Slice() {
+		for _, elt := range n.List {
 			e.expr(k.note(n, "struct literal element"), elt.(*ir.StructKeyExpr).Value)
 		}
 
@@ -671,7 +671,7 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 		e.spill(k, n)
 
 		// Map keys and values are always stored in the heap.
-		for _, elt := range n.List.Slice() {
+		for _, elt := range n.List {
 			elt := elt.(*ir.KeyExpr)
 			e.assignHeap(elt.Key, "map literal key", n)
 			e.assignHeap(elt.Value, "map literal value", n)
@@ -755,7 +755,7 @@ func (e *Escape) discard(n ir.Node) {
 }
 
 func (e *Escape) discards(l ir.Nodes) {
-	for _, n := range l.Slice() {
+	for _, n := range l {
 		e.discard(n)
 	}
 }
@@ -810,7 +810,7 @@ func (e *Escape) addr(n ir.Node) EscHole {
 
 func (e *Escape) addrs(l ir.Nodes) []EscHole {
 	var ks []EscHole
-	for _, n := range l.Slice() {
+	for _, n := range l {
 		ks = append(ks, e.addr(n))
 	}
 	return ks
@@ -904,14 +904,14 @@ func (e *Escape) call(ks []EscHole, call, where ir.Node) {
 			argument(e.discardHole(), call.X)
 		}
 
-		args := call.Args.Slice()
+		args := call.Args
 		for i, param := range fntype.Params().FieldSlice() {
 			argument(e.tagHole(ks, fn, param), args[i])
 		}
 
 	case ir.OAPPEND:
 		call := call.(*ir.CallExpr)
-		args := call.Args.Slice()
+		args := call.Args
 
 		// Appendee slice may flow directly to the result, if
 		// it has enough capacity. Alternatively, a new heap
@@ -955,7 +955,7 @@ func (e *Escape) call(ks []EscHole, call, where ir.Node) {
 		argument(e.discardHole(), call.Y)
 	case ir.ODELETE, ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
 		call := call.(*ir.CallExpr)
-		for _, arg := range call.Args.Slice() {
+		for _, arg := range call.Args {
 			argument(e.discardHole(), arg)
 		}
 	case ir.OLEN, ir.OCAP, ir.OREAL, ir.OIMAG, ir.OCLOSE:
@@ -2084,7 +2084,7 @@ func (e *Escape) paramTag(fn *ir.Func, narg int, f *types.Field) string {
 		return fmt.Sprintf("arg#%d", narg)
 	}
 
-	if fn.Body.Len() == 0 {
+	if len(fn.Body) == 0 {
 		// Assume that uintptr arguments must be held live across the call.
 		// This is most important for syscall.Syscall.
 		// See golang.org/issue/13372.
diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go
index 6008abeff8..f4178db477 100644
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ b/src/cmd/compile/internal/gc/gsubr.go
@@ -275,7 +275,7 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 		tail = call
 		if tfn.Type().NumResults() > 0 {
 			n := ir.NewReturnStmt(base.Pos, nil)
-			n.Results.Set1(call)
+			n.Results = []ir.Node{call}
 			tail = n
 		}
 	}
@@ -288,7 +288,7 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 
 	typecheckFunc(fn)
 	Curfn = fn
-	typecheckslice(fn.Body.Slice(), ctxStmt)
+	typecheckslice(fn.Body, ctxStmt)
 
 	escapeFuncs([]*ir.Func{fn}, false)
 
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index 60aa2eae8b..d601331ee4 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -528,7 +528,7 @@ func (p *iexporter) doInline(f *ir.Name) {
 	w := p.newWriter()
 	w.setPkg(fnpkg(f), false)
 
-	w.stmtList(ir.AsNodes(f.Func.Inl.Body))
+	w.stmtList(ir.Nodes(f.Func.Inl.Body))
 
 	w.finish("inl", p.inlineIndex, f.Sym())
 }
@@ -1035,7 +1035,7 @@ func (w *exportWriter) typeExt(t *types.Type) {
 // Inline bodies.
 
 func (w *exportWriter) stmtList(list ir.Nodes) {
-	for _, n := range list.Slice() {
+	for _, n := range list {
 		w.node(n)
 	}
 	w.op(ir.OEND)
@@ -1052,9 +1052,9 @@ func (w *exportWriter) node(n ir.Node) {
 // Caution: stmt will emit more than one node for statement nodes n that have a non-empty
 // n.Ninit and where n cannot have a natural init section (such as in "if", "for", etc.).
 func (w *exportWriter) stmt(n ir.Node) {
-	if n.Init().Len() > 0 && !ir.StmtWithInit(n.Op()) {
+	if len(n.Init()) > 0 && !ir.StmtWithInit(n.Op()) {
 		// can't use stmtList here since we don't want the final OEND
-		for _, n := range n.Init().Slice() {
+		for _, n := range n.Init() {
 			w.stmt(n)
 		}
 	}
@@ -1068,7 +1068,7 @@ func (w *exportWriter) stmt(n ir.Node) {
 		// generate OBLOCK nodes except to denote an empty
 		// function body, although that may change.)
 		n := n.(*ir.BlockStmt)
-		for _, n := range n.List.Slice() {
+		for _, n := range n.List {
 			w.stmt(n)
 		}
 
@@ -1203,9 +1203,9 @@ func (w *exportWriter) caseList(sw ir.Node) {
 
 	var cases []ir.Node
 	if sw.Op() == ir.OSWITCH {
-		cases = sw.(*ir.SwitchStmt).Cases.Slice()
+		cases = sw.(*ir.SwitchStmt).Cases
 	} else {
-		cases = sw.(*ir.SelectStmt).Cases.Slice()
+		cases = sw.(*ir.SelectStmt).Cases
 	}
 	w.uint64(uint64(len(cases)))
 	for _, cas := range cases {
@@ -1213,14 +1213,14 @@ func (w *exportWriter) caseList(sw ir.Node) {
 		w.pos(cas.Pos())
 		w.stmtList(cas.List)
 		if namedTypeSwitch {
-			w.localName(cas.Vars.First().(*ir.Name))
+			w.localName(cas.Vars[0].(*ir.Name))
 		}
 		w.stmtList(cas.Body)
 	}
 }
 
 func (w *exportWriter) exprList(list ir.Nodes) {
-	for _, n := range list.Slice() {
+	for _, n := range list {
 		w.expr(n)
 	}
 	w.op(ir.OEND)
@@ -1540,8 +1540,8 @@ func (w *exportWriter) exprsOrNil(a, b ir.Node) {
 }
 
 func (w *exportWriter) fieldList(list ir.Nodes) {
-	w.uint64(uint64(list.Len()))
-	for _, n := range list.Slice() {
+	w.uint64(uint64(len(list)))
+	for _, n := range list {
 		n := n.(*ir.StructKeyExpr)
 		w.selector(n.Field)
 		w.expr(n.Value)
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 4f460d54a2..90a909d2a3 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -723,9 +723,9 @@ func (r *importReader) doInline(fn *ir.Func) {
 
 	if base.Flag.E > 0 && base.Flag.LowerM > 2 {
 		if base.Flag.LowerM > 3 {
-			fmt.Printf("inl body for %v %v: %+v\n", fn, fn.Type(), ir.AsNodes(fn.Inl.Body))
+			fmt.Printf("inl body for %v %v: %+v\n", fn, fn.Type(), ir.Nodes(fn.Inl.Body))
 		} else {
-			fmt.Printf("inl body for %v %v: %v\n", fn, fn.Type(), ir.AsNodes(fn.Inl.Body))
+			fmt.Printf("inl body for %v %v: %v\n", fn, fn.Type(), ir.Nodes(fn.Inl.Body))
 		}
 	}
 }
@@ -757,7 +757,7 @@ func (r *importReader) stmtList() []ir.Node {
 		// Inline them into the statement list.
 		if n.Op() == ir.OBLOCK {
 			n := n.(*ir.BlockStmt)
-			list = append(list, n.List.Slice()...)
+			list = append(list, n.List...)
 		} else {
 			list = append(list, n)
 		}
@@ -779,7 +779,7 @@ func (r *importReader) caseList(sw ir.Node) []ir.Node {
 			// Sym for diagnostics anyway.
 			caseVar := ir.NewNameAt(cas.Pos(), r.ident())
 			declare(caseVar, dclcontext)
-			cas.Vars.Set1(caseVar)
+			cas.Vars = []ir.Node{caseVar}
 			caseVar.Defn = sw.(*ir.SwitchStmt).Tag
 		}
 		cas.Body.Set(r.stmtList())
@@ -996,7 +996,7 @@ func (r *importReader) node() ir.Node {
 		var stmts ir.Nodes
 		stmts.Append(ir.NewDecl(base.Pos, ir.ODCL, lhs))
 		stmts.Append(ir.NewAssignStmt(base.Pos, lhs, nil))
-		return ir.NewBlockStmt(pos, stmts.Slice())
+		return ir.NewBlockStmt(pos, stmts)
 
 	// case OAS, OASWB:
 	// 	unreachable - mapped to OAS case below by exporter
diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index fbc88411cc..4495284a07 100644
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -83,8 +83,8 @@ func fninit() *ir.Name {
 	// Record user init functions.
 	for _, fn := range Target.Inits {
 		// Skip init functions with empty bodies.
-		if fn.Body.Len() == 1 {
-			if stmt := fn.Body.First(); stmt.Op() == ir.OBLOCK && stmt.(*ir.BlockStmt).List.Len() == 0 {
+		if len(fn.Body) == 1 {
+			if stmt := fn.Body[0]; stmt.Op() == ir.OBLOCK && len(stmt.(*ir.BlockStmt).List) == 0 {
 				continue
 			}
 		}
diff --git a/src/cmd/compile/internal/gc/initorder.go b/src/cmd/compile/internal/gc/initorder.go
index ec3d7be45f..fe131c32a6 100644
--- a/src/cmd/compile/internal/gc/initorder.go
+++ b/src/cmd/compile/internal/gc/initorder.go
@@ -258,7 +258,7 @@ func collectDeps(n ir.Node, transitive bool) ir.NameSet {
 		d.inspect(n.Y)
 	case ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV:
 		n := n.(*ir.AssignListStmt)
-		d.inspect(n.Rhs.First())
+		d.inspect(n.Rhs[0])
 	case ir.ODCLFUNC:
 		n := n.(*ir.Func)
 		d.inspectList(n.Body)
@@ -363,7 +363,7 @@ func firstLHS(n ir.Node) *ir.Name {
 		return n.X.Name()
 	case ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2RECV, ir.OAS2MAPR:
 		n := n.(*ir.AssignListStmt)
-		return n.Lhs.First().Name()
+		return n.Lhs[0].Name()
 	}
 
 	base.Fatalf("unexpected Op: %v", n.Op())
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index edb2c5bb42..2fb23f1a3f 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -113,7 +113,7 @@ func typecheckinl(fn *ir.Func) {
 	}
 
 	if base.Flag.LowerM > 2 || base.Debug.Export != 0 {
-		fmt.Printf("typecheck import [%v] %L { %v }\n", fn.Sym(), fn, ir.AsNodes(fn.Inl.Body))
+		fmt.Printf("typecheck import [%v] %L { %v }\n", fn.Sym(), fn, ir.Nodes(fn.Inl.Body))
 	}
 
 	savefn := Curfn
@@ -196,7 +196,7 @@ func caninl(fn *ir.Func) {
 	}
 
 	// If fn has no body (is defined outside of Go), cannot inline it.
-	if fn.Body.Len() == 0 {
+	if len(fn.Body) == 0 {
 		reason = "no function body"
 		return
 	}
@@ -238,11 +238,11 @@ func caninl(fn *ir.Func) {
 	n.Func.Inl = &ir.Inline{
 		Cost: inlineMaxBudget - visitor.budget,
 		Dcl:  pruneUnusedAutos(n.Defn.(*ir.Func).Dcl, &visitor),
-		Body: ir.DeepCopyList(src.NoXPos, fn.Body.Slice()),
+		Body: ir.DeepCopyList(src.NoXPos, fn.Body),
 	}
 
 	if base.Flag.LowerM > 1 {
-		fmt.Printf("%v: can inline %v with cost %d as: %v { %v }\n", ir.Line(fn), n, inlineMaxBudget-visitor.budget, fn.Type(), ir.AsNodes(n.Func.Inl.Body))
+		fmt.Printf("%v: can inline %v with cost %d as: %v { %v }\n", ir.Line(fn), n, inlineMaxBudget-visitor.budget, fn.Type(), ir.Nodes(n.Func.Inl.Body))
 	} else if base.Flag.LowerM != 0 {
 		fmt.Printf("%v: can inline %v\n", ir.Line(fn), n)
 	}
@@ -278,7 +278,7 @@ func inlFlood(n *ir.Name, exportsym func(*ir.Name)) {
 	// Recursively identify all referenced functions for
 	// reexport. We want to include even non-called functions,
 	// because after inlining they might be callable.
-	ir.VisitList(ir.AsNodes(fn.Inl.Body), func(n ir.Node) {
+	ir.VisitList(ir.Nodes(fn.Inl.Body), func(n ir.Node) {
 		switch n.Op() {
 		case ir.OMETHEXPR, ir.ODOTMETH:
 			inlFlood(methodExprName(n), exportsym)
@@ -527,7 +527,7 @@ func inlcalls(fn *ir.Func) {
 func inlconv2stmt(inlcall *ir.InlinedCallExpr) ir.Node {
 	n := ir.NewBlockStmt(inlcall.Pos(), nil)
 	n.List = inlcall.Init()
-	n.List.AppendNodes(&inlcall.Body)
+	n.List.Append(inlcall.Body.Take()...)
 	return n
 }
 
@@ -535,8 +535,8 @@ func inlconv2stmt(inlcall *ir.InlinedCallExpr) ir.Node {
 // The result of inlconv2expr MUST be assigned back to n, e.g.
 // 	n.Left = inlconv2expr(n.Left)
 func inlconv2expr(n *ir.InlinedCallExpr) ir.Node {
-	r := n.ReturnVars.First()
-	return initExpr(append(n.Init().Slice(), n.Body.Slice()...), r)
+	r := n.ReturnVars[0]
+	return initExpr(append(n.Init(), n.Body...), r)
 }
 
 // Turn the rlist (with the return values) of the OINLCALL in
@@ -545,12 +545,12 @@ func inlconv2expr(n *ir.InlinedCallExpr) ir.Node {
 // order will be preserved. Used in return, oas2func and call
 // statements.
 func inlconv2list(n *ir.InlinedCallExpr) []ir.Node {
-	if n.Op() != ir.OINLCALL || n.ReturnVars.Len() == 0 {
+	if n.Op() != ir.OINLCALL || len(n.ReturnVars) == 0 {
 		base.Fatalf("inlconv2list %+v\n", n)
 	}
 
-	s := n.ReturnVars.Slice()
-	s[0] = initExpr(append(n.Init().Slice(), n.Body.Slice()...), s[0])
+	s := n.ReturnVars
+	s[0] = initExpr(append(n.Init(), n.Body...), s[0])
 	return s
 }
 
@@ -600,8 +600,8 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.No
 
 	if as := n; as.Op() == ir.OAS2FUNC {
 		as := as.(*ir.AssignListStmt)
-		if as.Rhs.First().Op() == ir.OINLCALL {
-			as.Rhs.Set(inlconv2list(as.Rhs.First().(*ir.InlinedCallExpr)))
+		if as.Rhs[0].Op() == ir.OINLCALL {
+			as.Rhs.Set(inlconv2list(as.Rhs[0].(*ir.InlinedCallExpr)))
 			as.SetOp(ir.OAS2)
 			as.SetTypecheck(0)
 			n = typecheck(as, ctxStmt)
@@ -736,9 +736,9 @@ FindRHS:
 		rhs = defn.Y
 	case ir.OAS2:
 		defn := defn.(*ir.AssignListStmt)
-		for i, lhs := range defn.Lhs.Slice() {
+		for i, lhs := range defn.Lhs {
 			if lhs == n {
-				rhs = defn.Rhs.Index(i)
+				rhs = defn.Rhs[i]
 				break FindRHS
 			}
 		}
@@ -780,7 +780,7 @@ func reassigned(name *ir.Name) bool {
 			}
 		case ir.OAS2, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2DOTTYPE, ir.OAS2RECV, ir.OSELRECV2:
 			n := n.(*ir.AssignListStmt)
-			for _, p := range n.Lhs.Slice() {
+			for _, p := range n.Lhs {
 				if p == name && n != name.Defn {
 					return true
 				}
@@ -870,7 +870,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 
 	// We have a function node, and it has an inlineable body.
 	if base.Flag.LowerM > 1 {
-		fmt.Printf("%v: inlining call to %v %v { %v }\n", ir.Line(n), fn.Sym(), fn.Type(), ir.AsNodes(fn.Inl.Body))
+		fmt.Printf("%v: inlining call to %v %v { %v }\n", ir.Line(n), fn.Sym(), fn.Type(), ir.Nodes(fn.Inl.Body))
 	} else if base.Flag.LowerM != 0 {
 		fmt.Printf("%v: inlining call to %v\n", ir.Line(n), fn)
 	}
@@ -890,7 +890,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 		callee := n.X
 		for callee.Op() == ir.OCONVNOP {
 			conv := callee.(*ir.ConvExpr)
-			ninit.AppendNodes(conv.PtrInit())
+			ninit.Append(conv.PtrInit().Take()...)
 			callee = conv.X
 		}
 		if callee.Op() != ir.ONAME && callee.Op() != ir.OCLOSURE && callee.Op() != ir.OMETHEXPR {
@@ -968,7 +968,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 	}
 
 	nreturns := 0
-	ir.VisitList(ir.AsNodes(fn.Inl.Body), func(n ir.Node) {
+	ir.VisitList(ir.Nodes(fn.Inl.Body), func(n ir.Node) {
 		if n != nil && n.Op() == ir.ORETURN {
 			nreturns++
 		}
@@ -1018,7 +1018,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 		}
 		as.Rhs.Append(sel.X)
 	}
-	as.Rhs.Append(n.Args.Slice()...)
+	as.Rhs.Append(n.Args...)
 
 	// For non-dotted calls to variadic functions, we assign the
 	// variadic parameter's temp name separately.
@@ -1039,11 +1039,11 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 		// Otherwise, we need to collect the remaining values
 		// to pass as a slice.
 
-		x := as.Lhs.Len()
-		for as.Lhs.Len() < as.Rhs.Len() {
-			as.Lhs.Append(argvar(param.Type, as.Lhs.Len()))
+		x := len(as.Lhs)
+		for len(as.Lhs) < len(as.Rhs) {
+			as.Lhs.Append(argvar(param.Type, len(as.Lhs)))
 		}
-		varargs := as.Lhs.Slice()[x:]
+		varargs := as.Lhs[x:]
 
 		vas = ir.NewAssignStmt(base.Pos, nil, nil)
 		vas.X = inlParam(param, vas, inlvars)
@@ -1057,7 +1057,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 		}
 	}
 
-	if as.Rhs.Len() != 0 {
+	if len(as.Rhs) != 0 {
 		ninit.Append(typecheck(as, ctxStmt))
 	}
 
@@ -1113,7 +1113,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 	}
 	subst.edit = subst.node
 
-	body := subst.list(ir.AsNodes(fn.Inl.Body))
+	body := subst.list(ir.Nodes(fn.Inl.Body))
 
 	lab := ir.NewLabelStmt(base.Pos, retlabel)
 	body = append(body, lab)
@@ -1129,7 +1129,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 	//dumplist("ninit post", ninit);
 
 	call := ir.NewInlinedCallExpr(base.Pos, nil, nil)
-	call.PtrInit().Set(ninit.Slice())
+	call.PtrInit().Set(ninit)
 	call.Body.Set(body)
 	call.ReturnVars.Set(retvars)
 	call.SetType(n.Type())
@@ -1220,8 +1220,8 @@ type inlsubst struct {
 
 // list inlines a list of nodes.
 func (subst *inlsubst) list(ll ir.Nodes) []ir.Node {
-	s := make([]ir.Node, 0, ll.Len())
-	for _, n := range ll.Slice() {
+	s := make([]ir.Node, 0, len(ll))
+	for _, n := range ll {
 		s = append(s, subst.node(n))
 	}
 	return s
@@ -1277,7 +1277,7 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 		// this return is guaranteed to belong to the current inlined function.
 		n := n.(*ir.ReturnStmt)
 		init := subst.list(n.Init())
-		if len(subst.retvars) != 0 && n.Results.Len() != 0 {
+		if len(subst.retvars) != 0 && len(n.Results) != 0 {
 			as := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
 
 			// Make a shallow copy of retvars.
@@ -1289,7 +1289,7 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 			as.Rhs.Set(subst.list(n.Results))
 
 			if subst.delayretvars {
-				for _, n := range as.Lhs.Slice() {
+				for _, n := range as.Lhs {
 					as.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, n))
 					n.Name().Defn = as
 				}
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 728c4b1316..bed37efb87 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -968,10 +968,10 @@ func (p *noder) stmtsFall(stmts []syntax.Stmt, fallOK bool) []ir.Node {
 	for i, stmt := range stmts {
 		s := p.stmtFall(stmt, fallOK && i+1 == len(stmts))
 		if s == nil {
-		} else if s.Op() == ir.OBLOCK && s.(*ir.BlockStmt).List.Len() > 0 {
+		} else if s.Op() == ir.OBLOCK && len(s.(*ir.BlockStmt).List) > 0 {
 			// Inline non-empty block.
 			// Empty blocks must be preserved for checkreturn.
-			nodes = append(nodes, s.(*ir.BlockStmt).List.Slice()...)
+			nodes = append(nodes, s.(*ir.BlockStmt).List...)
 		} else {
 			nodes = append(nodes, s)
 		}
@@ -1065,7 +1065,7 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) ir.Node {
 		}
 		n := ir.NewReturnStmt(p.pos(stmt), nil)
 		n.Results.Set(results)
-		if n.Results.Len() == 0 && Curfn != nil {
+		if len(n.Results) == 0 && Curfn != nil {
 			for _, ln := range Curfn.Dcl {
 				if ln.Class_ == ir.PPARAM {
 					continue
@@ -1160,7 +1160,7 @@ func (p *noder) ifStmt(stmt *syntax.IfStmt) ir.Node {
 	p.openScope(stmt.Pos())
 	n := ir.NewIfStmt(p.pos(stmt), nil, nil, nil)
 	if stmt.Init != nil {
-		n.PtrInit().Set1(p.stmt(stmt.Init))
+		*n.PtrInit() = []ir.Node{p.stmt(stmt.Init)}
 	}
 	if stmt.Cond != nil {
 		n.Cond = p.expr(stmt.Cond)
@@ -1170,9 +1170,9 @@ func (p *noder) ifStmt(stmt *syntax.IfStmt) ir.Node {
 		e := p.stmt(stmt.Else)
 		if e.Op() == ir.OBLOCK {
 			e := e.(*ir.BlockStmt)
-			n.Else.Set(e.List.Slice())
+			n.Else.Set(e.List)
 		} else {
-			n.Else.Set1(e)
+			n.Else = []ir.Node{e}
 		}
 	}
 	p.closeAnotherScope()
@@ -1198,7 +1198,7 @@ func (p *noder) forStmt(stmt *syntax.ForStmt) ir.Node {
 
 	n := ir.NewForStmt(p.pos(stmt), nil, nil, nil, nil)
 	if stmt.Init != nil {
-		n.PtrInit().Set1(p.stmt(stmt.Init))
+		*n.PtrInit() = []ir.Node{p.stmt(stmt.Init)}
 	}
 	if stmt.Cond != nil {
 		n.Cond = p.expr(stmt.Cond)
@@ -1215,7 +1215,7 @@ func (p *noder) switchStmt(stmt *syntax.SwitchStmt) ir.Node {
 	p.openScope(stmt.Pos())
 	n := ir.NewSwitchStmt(p.pos(stmt), nil, nil)
 	if stmt.Init != nil {
-		n.PtrInit().Set1(p.stmt(stmt.Init))
+		*n.PtrInit() = []ir.Node{p.stmt(stmt.Init)}
 	}
 	if stmt.Tag != nil {
 		n.Tag = p.expr(stmt.Tag)
@@ -1247,7 +1247,7 @@ func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *ir.TypeSwitch
 		if tswitch != nil && tswitch.Tag != nil {
 			nn := NewName(tswitch.Tag.Sym())
 			declare(nn, dclcontext)
-			n.Vars.Set1(nn)
+			n.Vars = []ir.Node{nn}
 			// keep track of the instances for reporting unused
 			nn.Defn = tswitch
 		}
@@ -1264,7 +1264,7 @@ func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *ir.TypeSwitch
 		}
 
 		n.Body.Set(p.stmtsFall(body, true))
-		if l := n.Body.Len(); l > 0 && n.Body.Index(l-1).Op() == ir.OFALL {
+		if l := len(n.Body); l > 0 && n.Body[l-1].Op() == ir.OFALL {
 			if tswitch != nil {
 				base.Errorf("cannot fallthrough in type switch")
 			}
@@ -1298,7 +1298,7 @@ func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []i
 
 		n := ir.NewCaseStmt(p.pos(clause), nil, nil)
 		if clause.Comm != nil {
-			n.List.Set1(p.stmt(clause.Comm))
+			n.List = []ir.Node{p.stmt(clause.Comm)}
 		}
 		n.Body.Set(p.stmts(clause.Body))
 		nodes = append(nodes, n)
@@ -1339,7 +1339,7 @@ func (p *noder) labeledStmt(label *syntax.LabeledStmt, fallOK bool) ir.Node {
 	if ls != nil {
 		if ls.Op() == ir.OBLOCK {
 			ls := ls.(*ir.BlockStmt)
-			l = append(l, ls.List.Slice()...)
+			l = append(l, ls.List...)
 		} else {
 			l = append(l, ls)
 		}
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 53d83c0ac8..45a2e2a43e 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -292,7 +292,7 @@ func mapKeyReplaceStrConv(n ir.Node) bool {
 		replaced = true
 	case ir.OSTRUCTLIT:
 		n := n.(*ir.CompLitExpr)
-		for _, elem := range n.List.Slice() {
+		for _, elem := range n.List {
 			elem := elem.(*ir.StructKeyExpr)
 			if mapKeyReplaceStrConv(elem.Value) {
 				replaced = true
@@ -300,7 +300,7 @@ func mapKeyReplaceStrConv(n ir.Node) bool {
 		}
 	case ir.OARRAYLIT:
 		n := n.(*ir.CompLitExpr)
-		for _, elem := range n.List.Slice() {
+		for _, elem := range n.List {
 			if elem.Op() == ir.OKEY {
 				elem = elem.(*ir.KeyExpr).Value
 			}
@@ -350,7 +350,7 @@ func (o *Order) cleanTemp(top ordermarker) {
 
 // stmtList orders each of the statements in the list.
 func (o *Order) stmtList(l ir.Nodes) {
-	s := l.Slice()
+	s := l
 	for i := range s {
 		orderMakeSliceCopy(s[i:])
 		o.stmt(s[i])
@@ -456,7 +456,7 @@ func (o *Order) init(n ir.Node) {
 	if ir.MayBeShared(n) {
 		// For concurrency safety, don't mutate potentially shared nodes.
 		// First, ensure that no work is required here.
-		if n.Init().Len() > 0 {
+		if len(n.Init()) > 0 {
 			base.Fatalf("order.init shared node with ninit")
 		}
 		return
@@ -468,7 +468,7 @@ func (o *Order) init(n ir.Node) {
 // call orders the call expression n.
 // n.Op is OCALLMETH/OCALLFUNC/OCALLINTER or a builtin like OCOPY.
 func (o *Order) call(nn ir.Node) {
-	if nn.Init().Len() > 0 {
+	if len(nn.Init()) > 0 {
 		// Caller should have already called o.init(nn).
 		base.Fatalf("%v with unexpected ninit", nn.Op())
 	}
@@ -521,9 +521,9 @@ func (o *Order) call(nn ir.Node) {
 	// Check for "unsafe-uintptr" tag provided by escape analysis.
 	for i, param := range n.X.Type().Params().FieldSlice() {
 		if param.Note == unsafeUintptrTag || param.Note == uintptrEscapesTag {
-			if arg := n.Args.Index(i); arg.Op() == ir.OSLICELIT {
+			if arg := n.Args[i]; arg.Op() == ir.OSLICELIT {
 				arg := arg.(*ir.CompLitExpr)
-				for _, elt := range arg.List.Slice() {
+				for _, elt := range arg.List {
 					keepAlive(elt)
 				}
 			} else {
@@ -569,7 +569,7 @@ func (o *Order) mapAssign(n ir.Node) {
 	case ir.OAS2, ir.OAS2DOTTYPE, ir.OAS2MAPR, ir.OAS2FUNC:
 		n := n.(*ir.AssignListStmt)
 		var post []ir.Node
-		for i, m := range n.Lhs.Slice() {
+		for i, m := range n.Lhs {
 			switch {
 			case m.Op() == ir.OINDEXMAP:
 				m := m.(*ir.IndexExpr)
@@ -582,7 +582,7 @@ func (o *Order) mapAssign(n ir.Node) {
 				fallthrough
 			case instrumenting && n.Op() == ir.OAS2FUNC && !ir.IsBlank(m):
 				t := o.newTemp(m.Type(), false)
-				n.Lhs.SetIndex(i, t)
+				n.Lhs[i] = t
 				a := ir.NewAssignStmt(base.Pos, m, t)
 				post = append(post, typecheck(a, ctxStmt))
 			}
@@ -598,7 +598,7 @@ func (o *Order) safeMapRHS(r ir.Node) ir.Node {
 	// We need to make sure the RHS won't panic.  See issue 22881.
 	if r.Op() == ir.OAPPEND {
 		r := r.(*ir.CallExpr)
-		s := r.Args.Slice()[1:]
+		s := r.Args[1:]
 		for i, n := range s {
 			s[i] = o.cheapExpr(n)
 		}
@@ -676,8 +676,8 @@ func (o *Order) stmt(n ir.Node) {
 		n := n.(*ir.AssignListStmt)
 		t := o.markTemp()
 		o.exprList(n.Lhs)
-		o.init(n.Rhs.First())
-		o.call(n.Rhs.First())
+		o.init(n.Rhs[0])
+		o.call(n.Rhs[0])
 		o.as2(n)
 		o.cleanTemp(t)
 
@@ -692,7 +692,7 @@ func (o *Order) stmt(n ir.Node) {
 		t := o.markTemp()
 		o.exprList(n.Lhs)
 
-		switch r := n.Rhs.First(); r.Op() {
+		switch r := n.Rhs[0]; r.Op() {
 		case ir.ODOTTYPE2:
 			r := r.(*ir.TypeAssertExpr)
 			r.X = o.expr(r.X, nil)
@@ -772,9 +772,9 @@ func (o *Order) stmt(n ir.Node) {
 	case ir.ODELETE:
 		n := n.(*ir.CallExpr)
 		t := o.markTemp()
-		n.Args.SetFirst(o.expr(n.Args.First(), nil))
-		n.Args.SetSecond(o.expr(n.Args.Second(), nil))
-		n.Args.SetSecond(o.mapKeyTemp(n.Args.First().Type(), n.Args.Second()))
+		n.Args[0] = o.expr(n.Args[0], nil)
+		n.Args[1] = o.expr(n.Args[1], nil)
+		n.Args[1] = o.mapKeyTemp(n.Args[0].Type(), n.Args[1])
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
 
@@ -843,7 +843,7 @@ func (o *Order) stmt(n ir.Node) {
 			base.Fatalf("order.stmt range %v", n.Type())
 
 		case types.TARRAY, types.TSLICE:
-			if n.Vars.Len() < 2 || ir.IsBlank(n.Vars.Second()) {
+			if len(n.Vars) < 2 || ir.IsBlank(n.Vars[1]) {
 				// for i := range x will only use x once, to compute len(x).
 				// No need to copy it.
 				break
@@ -906,14 +906,14 @@ func (o *Order) stmt(n ir.Node) {
 	case ir.OSELECT:
 		n := n.(*ir.SelectStmt)
 		t := o.markTemp()
-		for _, ncas := range n.Cases.Slice() {
+		for _, ncas := range n.Cases {
 			ncas := ncas.(*ir.CaseStmt)
 			r := ncas.Comm
 			setlineno(ncas)
 
 			// Append any new body prologue to ninit.
 			// The next loop will insert ninit into nbody.
-			if ncas.Init().Len() != 0 {
+			if len(ncas.Init()) != 0 {
 				base.Fatalf("order select ninit")
 			}
 			if r == nil {
@@ -927,17 +927,17 @@ func (o *Order) stmt(n ir.Node) {
 			case ir.OSELRECV2:
 				// case x, ok = <-c
 				r := r.(*ir.AssignListStmt)
-				recv := r.Rhs.First().(*ir.UnaryExpr)
+				recv := r.Rhs[0].(*ir.UnaryExpr)
 				recv.X = o.expr(recv.X, nil)
 				if !ir.IsAutoTmp(recv.X) {
 					recv.X = o.copyExpr(recv.X)
 				}
-				init := r.PtrInit().Slice()
+				init := *r.PtrInit()
 				r.PtrInit().Set(nil)
 
 				colas := r.Def
 				do := func(i int, t *types.Type) {
-					n := r.Lhs.Index(i)
+					n := r.Lhs[i]
 					if ir.IsBlank(n) {
 						return
 					}
@@ -955,7 +955,7 @@ func (o *Order) stmt(n ir.Node) {
 					tmp := o.newTemp(t, t.HasPointers())
 					as := typecheck(ir.NewAssignStmt(base.Pos, n, conv(tmp, n.Type())), ctxStmt)
 					ncas.PtrInit().Append(as)
-					(&r.Lhs).SetIndex(i, tmp)
+					r.Lhs[i] = tmp
 				}
 				do(0, recv.X.Type().Elem())
 				do(1, types.Types[types.TBOOL])
@@ -967,7 +967,7 @@ func (o *Order) stmt(n ir.Node) {
 
 			case ir.OSEND:
 				r := r.(*ir.SendStmt)
-				if r.Init().Len() != 0 {
+				if len(r.Init()) != 0 {
 					ir.DumpList("ninit", r.Init())
 					base.Fatalf("ninit on select send")
 				}
@@ -988,14 +988,14 @@ func (o *Order) stmt(n ir.Node) {
 		// Now that we have accumulated all the temporaries, clean them.
 		// Also insert any ninit queued during the previous loop.
 		// (The temporary cleaning must follow that ninit work.)
-		for _, cas := range n.Cases.Slice() {
+		for _, cas := range n.Cases {
 			cas := cas.(*ir.CaseStmt)
 			orderBlock(&cas.Body, o.free)
 			cas.Body.Prepend(o.cleanTempNoPop(t)...)
 
 			// TODO(mdempsky): Is this actually necessary?
 			// walkselect appears to walk Ninit.
-			cas.Body.Prepend(cas.Init().Slice()...)
+			cas.Body.Prepend(cas.Init()...)
 			cas.PtrInit().Set(nil)
 		}
 
@@ -1034,7 +1034,7 @@ func (o *Order) stmt(n ir.Node) {
 
 		t := o.markTemp()
 		n.Tag = o.expr(n.Tag, nil)
-		for _, ncas := range n.Cases.Slice() {
+		for _, ncas := range n.Cases {
 			ncas := ncas.(*ir.CaseStmt)
 			o.exprListInPlace(ncas.List)
 			orderBlock(&ncas.Body, o.free)
@@ -1048,9 +1048,9 @@ func (o *Order) stmt(n ir.Node) {
 }
 
 func hasDefaultCase(n *ir.SwitchStmt) bool {
-	for _, ncas := range n.Cases.Slice() {
+	for _, ncas := range n.Cases {
 		ncas := ncas.(*ir.CaseStmt)
-		if ncas.List.Len() == 0 {
+		if len(ncas.List) == 0 {
 			return true
 		}
 	}
@@ -1059,7 +1059,7 @@ func hasDefaultCase(n *ir.SwitchStmt) bool {
 
 // exprList orders the expression list l into o.
 func (o *Order) exprList(l ir.Nodes) {
-	s := l.Slice()
+	s := l
 	for i := range s {
 		s[i] = o.expr(s[i], nil)
 	}
@@ -1068,7 +1068,7 @@ func (o *Order) exprList(l ir.Nodes) {
 // exprListInPlace orders the expression list l but saves
 // the side effects on the individual expression ninit lists.
 func (o *Order) exprListInPlace(l ir.Nodes) {
-	s := l.Slice()
+	s := l
 	for i := range s {
 		s[i] = o.exprInPlace(s[i])
 	}
@@ -1113,8 +1113,8 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		n := n.(*ir.AddStringExpr)
 		o.exprList(n.List)
 
-		if n.List.Len() > 5 {
-			t := types.NewArray(types.Types[types.TSTRING], int64(n.List.Len()))
+		if len(n.List) > 5 {
+			t := types.NewArray(types.Types[types.TSTRING], int64(len(n.List)))
 			n.Prealloc = o.newTemp(t, false)
 		}
 
@@ -1128,13 +1128,13 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		hasbyte := false
 
 		haslit := false
-		for _, n1 := range n.List.Slice() {
+		for _, n1 := range n.List {
 			hasbyte = hasbyte || n1.Op() == ir.OBYTES2STR
 			haslit = haslit || n1.Op() == ir.OLITERAL && len(ir.StringVal(n1)) != 0
 		}
 
 		if haslit && hasbyte {
-			for _, n2 := range n.List.Slice() {
+			for _, n2 := range n.List {
 				if n2.Op() == ir.OBYTES2STR {
 					n2 := n2.(*ir.ConvExpr)
 					n2.SetOp(ir.OBYTES2STRTMP)
@@ -1276,14 +1276,14 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		// Check for append(x, make([]T, y)...) .
 		n := n.(*ir.CallExpr)
 		if isAppendOfMake(n) {
-			n.Args.SetFirst(o.expr(n.Args.First(), nil)) // order x
-			mk := n.Args.Second().(*ir.MakeExpr)
+			n.Args[0] = o.expr(n.Args[0], nil) // order x
+			mk := n.Args[1].(*ir.MakeExpr)
 			mk.Len = o.expr(mk.Len, nil) // order y
 		} else {
 			o.exprList(n.Args)
 		}
 
-		if lhs == nil || lhs.Op() != ir.ONAME && !samesafeexpr(lhs, n.Args.First()) {
+		if lhs == nil || lhs.Op() != ir.ONAME && !samesafeexpr(lhs, n.Args[0]) {
 			return o.copyExpr(n)
 		}
 		return n
@@ -1385,7 +1385,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		// the keys and values before storing any of them to the map.
 		// See issue 26552.
 		n := n.(*ir.CompLitExpr)
-		entries := n.List.Slice()
+		entries := n.List
 		statics := entries[:0]
 		var dynamics []*ir.KeyExpr
 		for _, r := range entries {
@@ -1441,10 +1441,10 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 func (o *Order) as2(n *ir.AssignListStmt) {
 	tmplist := []ir.Node{}
 	left := []ir.Node{}
-	for ni, l := range n.Lhs.Slice() {
+	for ni, l := range n.Lhs {
 		if !ir.IsBlank(l) {
 			tmp := o.newTemp(l.Type(), l.Type().HasPointers())
-			n.Lhs.SetIndex(ni, tmp)
+			n.Lhs[ni] = tmp
 			tmplist = append(tmplist, tmp)
 			left = append(left, l)
 		}
@@ -1462,25 +1462,25 @@ func (o *Order) as2(n *ir.AssignListStmt) {
 // Just like as2, this also adds temporaries to ensure left-to-right assignment.
 func (o *Order) okAs2(n *ir.AssignListStmt) {
 	var tmp1, tmp2 ir.Node
-	if !ir.IsBlank(n.Lhs.First()) {
-		typ := n.Rhs.First().Type()
+	if !ir.IsBlank(n.Lhs[0]) {
+		typ := n.Rhs[0].Type()
 		tmp1 = o.newTemp(typ, typ.HasPointers())
 	}
 
-	if !ir.IsBlank(n.Lhs.Second()) {
+	if !ir.IsBlank(n.Lhs[1]) {
 		tmp2 = o.newTemp(types.Types[types.TBOOL], false)
 	}
 
 	o.out = append(o.out, n)
 
 	if tmp1 != nil {
-		r := ir.NewAssignStmt(base.Pos, n.Lhs.First(), tmp1)
+		r := ir.NewAssignStmt(base.Pos, n.Lhs[0], tmp1)
 		o.mapAssign(typecheck(r, ctxStmt))
-		n.Lhs.SetFirst(tmp1)
+		n.Lhs[0] = tmp1
 	}
 	if tmp2 != nil {
-		r := ir.NewAssignStmt(base.Pos, n.Lhs.Second(), conv(tmp2, n.Lhs.Second().Type()))
+		r := ir.NewAssignStmt(base.Pos, n.Lhs[1], conv(tmp2, n.Lhs[1].Type()))
 		o.mapAssign(typecheck(r, ctxStmt))
-		n.Lhs.SetSecond(tmp2)
+		n.Lhs[1] = tmp2
 	}
 }
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index 32550c8bd4..785e01663f 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -207,7 +207,7 @@ func funccompile(fn *ir.Func) {
 	// assign parameter offsets
 	dowidth(fn.Type())
 
-	if fn.Body.Len() == 0 {
+	if len(fn.Body) == 0 {
 		// Initialize ABI wrappers if necessary.
 		initLSym(fn, false)
 		emitptrargsmap(fn)
@@ -360,7 +360,7 @@ func compileFunctions() {
 			// since they're most likely to be the slowest.
 			// This helps avoid stragglers.
 			sort.Slice(compilequeue, func(i, j int) bool {
-				return compilequeue[i].Body.Len() > compilequeue[j].Body.Len()
+				return len(compilequeue[i].Body) > len(compilequeue[j].Body)
 			})
 		}
 		var wg sync.WaitGroup
diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index 3aa4ff71fa..4d2964591b 100644
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -27,7 +27,7 @@ func typecheckrange(n *ir.RangeStmt) {
 
 	// second half of dance, the first half being typecheckrangeExpr
 	n.SetTypecheck(1)
-	ls := n.Vars.Slice()
+	ls := n.Vars
 	for i1, n1 := range ls {
 		if n1.Typecheck() == 0 {
 			ls[i1] = typecheck(ls[i1], ctxExpr|ctxAssign)
@@ -35,7 +35,7 @@ func typecheckrange(n *ir.RangeStmt) {
 	}
 
 	decldepth++
-	typecheckslice(n.Body.Slice(), ctxStmt)
+	typecheckslice(n.Body, ctxStmt)
 	decldepth--
 }
 
@@ -47,7 +47,7 @@ func typecheckrangeExpr(n *ir.RangeStmt) {
 		return
 	}
 	// delicate little dance.  see typecheckas2
-	ls := n.Vars.Slice()
+	ls := n.Vars
 	for i1, n1 := range ls {
 		if !ir.DeclaredBy(n1, n) {
 			ls[i1] = typecheck(ls[i1], ctxExpr|ctxAssign)
@@ -82,7 +82,7 @@ func typecheckrangeExpr(n *ir.RangeStmt) {
 
 		t1 = t.Elem()
 		t2 = nil
-		if n.Vars.Len() == 2 {
+		if len(n.Vars) == 2 {
 			toomany = true
 		}
 
@@ -91,16 +91,16 @@ func typecheckrangeExpr(n *ir.RangeStmt) {
 		t2 = types.RuneType
 	}
 
-	if n.Vars.Len() > 2 || toomany {
+	if len(n.Vars) > 2 || toomany {
 		base.ErrorfAt(n.Pos(), "too many variables in range")
 	}
 
 	var v1, v2 ir.Node
-	if n.Vars.Len() != 0 {
-		v1 = n.Vars.First()
+	if len(n.Vars) != 0 {
+		v1 = n.Vars[0]
 	}
-	if n.Vars.Len() > 1 {
-		v2 = n.Vars.Second()
+	if len(n.Vars) > 1 {
+		v2 = n.Vars[1]
 	}
 
 	// this is not only an optimization but also a requirement in the spec.
@@ -109,7 +109,7 @@ func typecheckrangeExpr(n *ir.RangeStmt) {
 	// present."
 	if ir.IsBlank(v2) {
 		if v1 != nil {
-			n.Vars.Set1(v1)
+			n.Vars = []ir.Node{v1}
 		}
 		v2 = nil
 	}
@@ -183,13 +183,13 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 	lno := setlineno(a)
 
 	var v1, v2 ir.Node
-	l := nrange.Vars.Len()
+	l := len(nrange.Vars)
 	if l > 0 {
-		v1 = nrange.Vars.First()
+		v1 = nrange.Vars[0]
 	}
 
 	if l > 1 {
-		v2 = nrange.Vars.Second()
+		v2 = nrange.Vars[1]
 	}
 
 	if ir.IsBlank(v2) {
@@ -249,8 +249,8 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 			// Use OAS2 to correctly handle assignments
 			// of the form "v1, a[v1] := range".
 			a := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-			a.Lhs.Set2(v1, v2)
-			a.Rhs.Set2(hv1, tmp)
+			a.Lhs = []ir.Node{v1, v2}
+			a.Rhs = []ir.Node{hv1, tmp}
 			body = []ir.Node{a}
 			break
 		}
@@ -279,8 +279,8 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		// Use OAS2 to correctly handle assignments
 		// of the form "v1, a[v1] := range".
 		a := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-		a.Lhs.Set2(v1, v2)
-		a.Rhs.Set2(hv1, ir.NewStarExpr(base.Pos, hp))
+		a.Lhs = []ir.Node{v1, v2}
+		a.Rhs = []ir.Node{hv1, ir.NewStarExpr(base.Pos, hp)}
 		body = append(body, a)
 
 		// Advance pointer as part of the late increment.
@@ -289,7 +289,7 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		// advancing the pointer is safe and won't go past the
 		// end of the allocation.
 		as := ir.NewAssignStmt(base.Pos, hp, addptr(hp, t.Elem().Width))
-		nfor.Late.Set1(typecheck(as, ctxStmt))
+		nfor.Late = []ir.Node{typecheck(as, ctxStmt)}
 
 	case types.TMAP:
 		// order.stmt allocated the iterator for us.
@@ -319,8 +319,8 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		} else {
 			elem := ir.NewStarExpr(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, hit, elemsym))
 			a := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-			a.Lhs.Set2(v1, v2)
-			a.Rhs.Set2(key, elem)
+			a.Lhs = []ir.Node{v1, v2}
+			a.Rhs = []ir.Node{key, elem}
 			body = []ir.Node{a}
 		}
 
@@ -338,9 +338,9 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		nfor.Cond = ir.NewBinaryExpr(base.Pos, ir.ONE, hb, nodbool(false))
 		a := ir.NewAssignListStmt(base.Pos, ir.OAS2RECV, nil, nil)
 		a.SetTypecheck(1)
-		a.Lhs.Set2(hv1, hb)
-		a.Rhs.Set1(ir.NewUnaryExpr(base.Pos, ir.ORECV, ha))
-		nfor.Cond.PtrInit().Set1(a)
+		a.Lhs = []ir.Node{hv1, hb}
+		a.Rhs = []ir.Node{ir.NewUnaryExpr(base.Pos, ir.ORECV, ha)}
+		*nfor.Cond.PtrInit() = []ir.Node{a}
 		if v1 == nil {
 			body = nil
 		} else {
@@ -395,16 +395,16 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OLT, hv2, nodintconst(utf8.RuneSelf))
 
 		// hv1++
-		nif.Body.Set1(ir.NewAssignStmt(base.Pos, hv1, ir.NewBinaryExpr(base.Pos, ir.OADD, hv1, nodintconst(1))))
+		nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, hv1, ir.NewBinaryExpr(base.Pos, ir.OADD, hv1, nodintconst(1)))}
 
 		// } else {
 		eif := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-		nif.Else.Set1(eif)
+		nif.Else = []ir.Node{eif}
 
 		// hv2, hv1 = decoderune(ha, hv1)
-		eif.Lhs.Set2(hv2, hv1)
+		eif.Lhs = []ir.Node{hv2, hv1}
 		fn := syslook("decoderune")
-		eif.Rhs.Set1(mkcall1(fn, fn.Type().Results(), nil, ha, hv1))
+		eif.Rhs = []ir.Node{mkcall1(fn, fn.Type().Results(), nil, ha, hv1)}
 
 		body = append(body, nif)
 
@@ -412,8 +412,8 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 			if v2 != nil {
 				// v1, v2 = hv1t, hv2
 				a := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-				a.Lhs.Set2(v1, v2)
-				a.Rhs.Set2(hv1t, hv2)
+				a.Lhs = []ir.Node{v1, v2}
+				a.Rhs = []ir.Node{hv1t, hv2}
 				body = append(body, a)
 			} else {
 				// v1 = hv1t
@@ -431,18 +431,18 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		nfor.PtrInit().Append(init...)
 	}
 
-	typecheckslice(nfor.Cond.Init().Slice(), ctxStmt)
+	typecheckslice(nfor.Cond.Init(), ctxStmt)
 
 	nfor.Cond = typecheck(nfor.Cond, ctxExpr)
 	nfor.Cond = defaultlit(nfor.Cond, nil)
 	nfor.Post = typecheck(nfor.Post, ctxStmt)
 	typecheckslice(body, ctxStmt)
 	nfor.Body.Append(body...)
-	nfor.Body.Append(nrange.Body.Slice()...)
+	nfor.Body.Append(nrange.Body...)
 
 	var n ir.Node = nfor
 	if ifGuard != nil {
-		ifGuard.Body.Set1(n)
+		ifGuard.Body = []ir.Node{n}
 		n = ifGuard
 	}
 
@@ -464,11 +464,11 @@ func isMapClear(n *ir.RangeStmt) bool {
 		return false
 	}
 
-	if n.Op() != ir.ORANGE || n.Type().Kind() != types.TMAP || n.Vars.Len() != 1 {
+	if n.Op() != ir.ORANGE || n.Type().Kind() != types.TMAP || len(n.Vars) != 1 {
 		return false
 	}
 
-	k := n.Vars.First()
+	k := n.Vars[0]
 	if k == nil || ir.IsBlank(k) {
 		return false
 	}
@@ -478,17 +478,17 @@ func isMapClear(n *ir.RangeStmt) bool {
 		return false
 	}
 
-	if n.Body.Len() != 1 {
+	if len(n.Body) != 1 {
 		return false
 	}
 
-	stmt := n.Body.First() // only stmt in body
+	stmt := n.Body[0] // only stmt in body
 	if stmt == nil || stmt.Op() != ir.ODELETE {
 		return false
 	}
 
 	m := n.X
-	if delete := stmt.(*ir.CallExpr); !samesafeexpr(delete.Args.First(), m) || !samesafeexpr(delete.Args.Second(), k) {
+	if delete := stmt.(*ir.CallExpr); !samesafeexpr(delete.Args[0], m) || !samesafeexpr(delete.Args[1], k) {
 		return false
 	}
 
@@ -531,11 +531,11 @@ func arrayClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
 		return nil
 	}
 
-	if loop.Body.Len() != 1 || loop.Body.First() == nil {
+	if len(loop.Body) != 1 || loop.Body[0] == nil {
 		return nil
 	}
 
-	stmt1 := loop.Body.First() // only stmt in body
+	stmt1 := loop.Body[0] // only stmt in body
 	if stmt1.Op() != ir.OAS {
 		return nil
 	}
@@ -597,7 +597,7 @@ func arrayClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
 
 	n.Cond = typecheck(n.Cond, ctxExpr)
 	n.Cond = defaultlit(n.Cond, nil)
-	typecheckslice(n.Body.Slice(), ctxStmt)
+	typecheckslice(n.Body, ctxStmt)
 	return walkstmt(n)
 }
 
diff --git a/src/cmd/compile/internal/gc/select.go b/src/cmd/compile/internal/gc/select.go
index 5c69be7e06..0bf070aa87 100644
--- a/src/cmd/compile/internal/gc/select.go
+++ b/src/cmd/compile/internal/gc/select.go
@@ -14,28 +14,28 @@ import (
 func typecheckselect(sel *ir.SelectStmt) {
 	var def ir.Node
 	lno := setlineno(sel)
-	typecheckslice(sel.Init().Slice(), ctxStmt)
-	for _, ncase := range sel.Cases.Slice() {
+	typecheckslice(sel.Init(), ctxStmt)
+	for _, ncase := range sel.Cases {
 		ncase := ncase.(*ir.CaseStmt)
 
-		if ncase.List.Len() == 0 {
+		if len(ncase.List) == 0 {
 			// default
 			if def != nil {
 				base.ErrorfAt(ncase.Pos(), "multiple defaults in select (first at %v)", ir.Line(def))
 			} else {
 				def = ncase
 			}
-		} else if ncase.List.Len() > 1 {
+		} else if len(ncase.List) > 1 {
 			base.ErrorfAt(ncase.Pos(), "select cases cannot be lists")
 		} else {
-			ncase.List.SetFirst(typecheck(ncase.List.First(), ctxStmt))
-			n := ncase.List.First()
+			ncase.List[0] = typecheck(ncase.List[0], ctxStmt)
+			n := ncase.List[0]
 			ncase.Comm = n
 			ncase.List.Set(nil)
 			oselrecv2 := func(dst, recv ir.Node, colas bool) {
 				n := ir.NewAssignListStmt(n.Pos(), ir.OSELRECV2, nil, nil)
-				n.Lhs.Set2(dst, ir.BlankNode)
-				n.Rhs.Set1(recv)
+				n.Lhs = []ir.Node{dst, ir.BlankNode}
+				n.Rhs = []ir.Node{recv}
 				n.Def = colas
 				n.SetTypecheck(1)
 				ncase.Comm = n
@@ -71,7 +71,7 @@ func typecheckselect(sel *ir.SelectStmt) {
 
 			case ir.OAS2RECV:
 				n := n.(*ir.AssignListStmt)
-				if n.Rhs.First().Op() != ir.ORECV {
+				if n.Rhs[0].Op() != ir.ORECV {
 					base.ErrorfAt(n.Pos(), "select assignment must have receive on right hand side")
 					break
 				}
@@ -87,7 +87,7 @@ func typecheckselect(sel *ir.SelectStmt) {
 			}
 		}
 
-		typecheckslice(ncase.Body.Slice(), ctxStmt)
+		typecheckslice(ncase.Body, ctxStmt)
 	}
 
 	base.Pos = lno
@@ -95,24 +95,24 @@ func typecheckselect(sel *ir.SelectStmt) {
 
 func walkselect(sel *ir.SelectStmt) {
 	lno := setlineno(sel)
-	if sel.Compiled.Len() != 0 {
+	if len(sel.Compiled) != 0 {
 		base.Fatalf("double walkselect")
 	}
 
-	init := sel.Init().Slice()
+	init := sel.Init()
 	sel.PtrInit().Set(nil)
 
 	init = append(init, walkselectcases(sel.Cases)...)
 	sel.Cases = ir.Nodes{}
 
 	sel.Compiled.Set(init)
-	walkstmtlist(sel.Compiled.Slice())
+	walkstmtlist(sel.Compiled)
 
 	base.Pos = lno
 }
 
 func walkselectcases(cases ir.Nodes) []ir.Node {
-	ncas := cases.Len()
+	ncas := len(cases)
 	sellineno := base.Pos
 
 	// optimization: zero-case select
@@ -122,12 +122,12 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 
 	// optimization: one-case select: single op.
 	if ncas == 1 {
-		cas := cases.First().(*ir.CaseStmt)
+		cas := cases[0].(*ir.CaseStmt)
 		setlineno(cas)
-		l := cas.Init().Slice()
+		l := cas.Init()
 		if cas.Comm != nil { // not default:
 			n := cas.Comm
-			l = append(l, n.Init().Slice()...)
+			l = append(l, n.Init()...)
 			n.PtrInit().Set(nil)
 			switch n.Op() {
 			default:
@@ -138,8 +138,8 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 
 			case ir.OSELRECV2:
 				r := n.(*ir.AssignListStmt)
-				if ir.IsBlank(r.Lhs.First()) && ir.IsBlank(r.Lhs.Second()) {
-					n = r.Rhs.First()
+				if ir.IsBlank(r.Lhs[0]) && ir.IsBlank(r.Lhs[1]) {
+					n = r.Rhs[0]
 					break
 				}
 				r.SetOp(ir.OAS2RECV)
@@ -148,7 +148,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 			l = append(l, n)
 		}
 
-		l = append(l, cas.Body.Slice()...)
+		l = append(l, cas.Body...)
 		l = append(l, ir.NewBranchStmt(base.Pos, ir.OBREAK, nil))
 		return l
 	}
@@ -156,7 +156,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 	// convert case value arguments to addresses.
 	// this rewrite is used by both the general code and the next optimization.
 	var dflt *ir.CaseStmt
-	for _, cas := range cases.Slice() {
+	for _, cas := range cases {
 		cas := cas.(*ir.CaseStmt)
 		setlineno(cas)
 		n := cas.Comm
@@ -172,24 +172,24 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 
 		case ir.OSELRECV2:
 			n := n.(*ir.AssignListStmt)
-			if !ir.IsBlank(n.Lhs.First()) {
-				n.Lhs.SetIndex(0, nodAddr(n.Lhs.First()))
-				n.Lhs.SetIndex(0, typecheck(n.Lhs.First(), ctxExpr))
+			if !ir.IsBlank(n.Lhs[0]) {
+				n.Lhs[0] = nodAddr(n.Lhs[0])
+				n.Lhs[0] = typecheck(n.Lhs[0], ctxExpr)
 			}
 		}
 	}
 
 	// optimization: two-case select but one is default: single non-blocking op.
 	if ncas == 2 && dflt != nil {
-		cas := cases.First().(*ir.CaseStmt)
+		cas := cases[0].(*ir.CaseStmt)
 		if cas == dflt {
-			cas = cases.Second().(*ir.CaseStmt)
+			cas = cases[1].(*ir.CaseStmt)
 		}
 
 		n := cas.Comm
 		setlineno(n)
 		r := ir.NewIfStmt(base.Pos, nil, nil, nil)
-		r.PtrInit().Set(cas.Init().Slice())
+		r.PtrInit().Set(cas.Init())
 		var call ir.Node
 		switch n.Op() {
 		default:
@@ -203,26 +203,26 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 
 		case ir.OSELRECV2:
 			n := n.(*ir.AssignListStmt)
-			recv := n.Rhs.First().(*ir.UnaryExpr)
+			recv := n.Rhs[0].(*ir.UnaryExpr)
 			ch := recv.X
-			elem := n.Lhs.First()
+			elem := n.Lhs[0]
 			if ir.IsBlank(elem) {
 				elem = nodnil()
 			}
-			if ir.IsBlank(n.Lhs.Second()) {
+			if ir.IsBlank(n.Lhs[1]) {
 				// if selectnbrecv(&v, c) { body } else { default body }
 				call = mkcall1(chanfn("selectnbrecv", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), elem, ch)
 			} else {
 				// TODO(cuonglm): make this use selectnbrecv()
 				// if selectnbrecv2(&v, &received, c) { body } else { default body }
-				receivedp := typecheck(nodAddr(n.Lhs.Second()), ctxExpr)
+				receivedp := typecheck(nodAddr(n.Lhs[1]), ctxExpr)
 				call = mkcall1(chanfn("selectnbrecv2", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), elem, receivedp, ch)
 			}
 		}
 
 		r.Cond = typecheck(call, ctxExpr)
-		r.Body.Set(cas.Body.Slice())
-		r.Else.Set(append(dflt.Init().Slice(), dflt.Body.Slice()...))
+		r.Body.Set(cas.Body)
+		r.Else.Set(append(dflt.Init(), dflt.Body...))
 		return []ir.Node{r, ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)}
 	}
 
@@ -251,11 +251,11 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 	}
 
 	// register cases
-	for _, cas := range cases.Slice() {
+	for _, cas := range cases {
 		cas := cas.(*ir.CaseStmt)
 		setlineno(cas)
 
-		init = append(init, cas.Init().Slice()...)
+		init = append(init, cas.Init()...)
 		cas.PtrInit().Set(nil)
 
 		n := cas.Comm
@@ -278,9 +278,9 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 			n := n.(*ir.AssignListStmt)
 			nrecvs++
 			i = ncas - nrecvs
-			recv := n.Rhs.First().(*ir.UnaryExpr)
+			recv := n.Rhs[0].(*ir.UnaryExpr)
 			c = recv.X
-			elem = n.Lhs.First()
+			elem = n.Lhs[0]
 		}
 
 		casorder[i] = cas
@@ -313,9 +313,9 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 	chosen := temp(types.Types[types.TINT])
 	recvOK := temp(types.Types[types.TBOOL])
 	r := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-	r.Lhs.Set2(chosen, recvOK)
+	r.Lhs = []ir.Node{chosen, recvOK}
 	fn := syslook("selectgo")
-	r.Rhs.Set1(mkcall1(fn, fn.Type().Results(), nil, bytePtrToIndex(selv, 0), bytePtrToIndex(order, 0), pc0, nodintconst(int64(nsends)), nodintconst(int64(nrecvs)), nodbool(dflt == nil)))
+	r.Rhs = []ir.Node{mkcall1(fn, fn.Type().Results(), nil, bytePtrToIndex(selv, 0), bytePtrToIndex(order, 0), pc0, nodintconst(int64(nsends)), nodintconst(int64(nrecvs)), nodbool(dflt == nil))}
 	init = append(init, typecheck(r, ctxStmt))
 
 	// selv and order are no longer alive after selectgo.
@@ -334,13 +334,13 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 
 		if n := cas.Comm; n != nil && n.Op() == ir.OSELRECV2 {
 			n := n.(*ir.AssignListStmt)
-			if !ir.IsBlank(n.Lhs.Second()) {
-				x := ir.NewAssignStmt(base.Pos, n.Lhs.Second(), recvOK)
+			if !ir.IsBlank(n.Lhs[1]) {
+				x := ir.NewAssignStmt(base.Pos, n.Lhs[1], recvOK)
 				r.Body.Append(typecheck(x, ctxStmt))
 			}
 		}
 
-		r.Body.AppendNodes(&cas.Body)
+		r.Body.Append(cas.Body.Take()...)
 		r.Body.Append(ir.NewBranchStmt(base.Pos, ir.OBREAK, nil))
 		init = append(init, r)
 	}
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 0fc19a6989..9445627b41 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -439,7 +439,7 @@ func getdyn(n ir.Node, top bool) initGenType {
 		if !top {
 			return initDynamic
 		}
-		if n.Len/4 > int64(n.List.Len()) {
+		if n.Len/4 > int64(len(n.List)) {
 			// <25% of entries have explicit values.
 			// Very rough estimation, it takes 4 bytes of instructions
 			// to initialize 1 byte of result. So don't use a static
@@ -454,7 +454,7 @@ func getdyn(n ir.Node, top bool) initGenType {
 	lit := n.(*ir.CompLitExpr)
 
 	var mode initGenType
-	for _, n1 := range lit.List.Slice() {
+	for _, n1 := range lit.List {
 		switch n1.Op() {
 		case ir.OKEY:
 			n1 = n1.(*ir.KeyExpr).Value
@@ -476,7 +476,7 @@ func isStaticCompositeLiteral(n ir.Node) bool {
 		return false
 	case ir.OARRAYLIT:
 		n := n.(*ir.CompLitExpr)
-		for _, r := range n.List.Slice() {
+		for _, r := range n.List {
 			if r.Op() == ir.OKEY {
 				r = r.(*ir.KeyExpr).Value
 			}
@@ -487,7 +487,7 @@ func isStaticCompositeLiteral(n ir.Node) bool {
 		return true
 	case ir.OSTRUCTLIT:
 		n := n.(*ir.CompLitExpr)
-		for _, r := range n.List.Slice() {
+		for _, r := range n.List {
 			r := r.(*ir.StructKeyExpr)
 			if !isStaticCompositeLiteral(r.Value) {
 				return false
@@ -568,7 +568,7 @@ func fixedlit(ctxt initContext, kind initKind, n *ir.CompLitExpr, var_ ir.Node,
 		base.Fatalf("fixedlit bad op: %v", n.Op())
 	}
 
-	for _, r := range n.List.Slice() {
+	for _, r := range n.List {
 		a, value := splitnode(r)
 		if a == ir.BlankNode && !anySideEffects(value) {
 			// Discard.
@@ -722,7 +722,7 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 
 	// put dynamics into array (5)
 	var index int64
-	for _, value := range n.List.Slice() {
+	for _, value := range n.List {
 		if value.Op() == ir.OKEY {
 			kv := value.(*ir.KeyExpr)
 			index = indexconst(kv.Key)
@@ -778,10 +778,10 @@ func maplit(n *ir.CompLitExpr, m ir.Node, init *ir.Nodes) {
 	// make the map var
 	a := ir.NewCallExpr(base.Pos, ir.OMAKE, nil, nil)
 	a.SetEsc(n.Esc())
-	a.Args.Set2(ir.TypeNode(n.Type()), nodintconst(int64(n.List.Len())))
+	a.Args = []ir.Node{ir.TypeNode(n.Type()), nodintconst(int64(len(n.List)))}
 	litas(m, a, init)
 
-	entries := n.List.Slice()
+	entries := n.List
 
 	// The order pass already removed any dynamic (runtime-computed) entries.
 	// All remaining entries are static. Double-check that.
@@ -837,8 +837,8 @@ func maplit(n *ir.CompLitExpr, m ir.Node, init *ir.Nodes) {
 		body := ir.NewAssignStmt(base.Pos, lhs, rhs)
 
 		loop := ir.NewForStmt(base.Pos, nil, cond, incr, nil)
-		loop.Body.Set1(body)
-		loop.PtrInit().Set1(zero)
+		loop.Body = []ir.Node{body}
+		*loop.PtrInit() = []ir.Node{zero}
 
 		appendWalkStmt(init, loop)
 		return
@@ -910,7 +910,7 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 			base.Fatalf("anylit: not struct/array")
 		}
 
-		if isSimpleName(var_) && n.List.Len() > 4 {
+		if isSimpleName(var_) && len(n.List) > 4 {
 			// lay out static data
 			vstat := readonlystaticname(t)
 
@@ -935,7 +935,7 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 			components = int64(t.NumFields())
 		}
 		// initialization of an array or struct with unspecified components (missing fields or arrays)
-		if isSimpleName(var_) || int64(n.List.Len()) < components {
+		if isSimpleName(var_) || int64(len(n.List)) < components {
 			appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, nil))
 		}
 
@@ -1058,7 +1058,7 @@ func (s *InitSchedule) initplan(n ir.Node) {
 	case ir.OARRAYLIT, ir.OSLICELIT:
 		n := n.(*ir.CompLitExpr)
 		var k int64
-		for _, a := range n.List.Slice() {
+		for _, a := range n.List {
 			if a.Op() == ir.OKEY {
 				kv := a.(*ir.KeyExpr)
 				k = indexconst(kv.Key)
@@ -1073,7 +1073,7 @@ func (s *InitSchedule) initplan(n ir.Node) {
 
 	case ir.OSTRUCTLIT:
 		n := n.(*ir.CompLitExpr)
-		for _, a := range n.List.Slice() {
+		for _, a := range n.List {
 			if a.Op() != ir.OSTRUCTKEY {
 				base.Fatalf("initplan structlit")
 			}
@@ -1086,7 +1086,7 @@ func (s *InitSchedule) initplan(n ir.Node) {
 
 	case ir.OMAPLIT:
 		n := n.(*ir.CompLitExpr)
-		for _, a := range n.List.Slice() {
+		for _, a := range n.List {
 			if a.Op() != ir.OKEY {
 				base.Fatalf("initplan maplit")
 			}
@@ -1135,7 +1135,7 @@ func isZero(n ir.Node) bool {
 
 	case ir.OARRAYLIT:
 		n := n.(*ir.CompLitExpr)
-		for _, n1 := range n.List.Slice() {
+		for _, n1 := range n.List {
 			if n1.Op() == ir.OKEY {
 				n1 = n1.(*ir.KeyExpr).Value
 			}
@@ -1147,7 +1147,7 @@ func isZero(n ir.Node) bool {
 
 	case ir.OSTRUCTLIT:
 		n := n.(*ir.CompLitExpr)
-		for _, n1 := range n.List.Slice() {
+		for _, n1 := range n.List {
 			n1 := n1.(*ir.StructKeyExpr)
 			if !isZero(n1.Value) {
 				return false
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 4660da0456..6993b4b1c7 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -392,7 +392,7 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 		// that we don't track correctly.
 		s.hasOpenDefers = false
 	}
-	if s.hasOpenDefers && s.curfn.Exit.Len() > 0 {
+	if s.hasOpenDefers && len(s.curfn.Exit) > 0 {
 		// Skip doing open defers if there is any extra exit code (likely
 		// copying heap-allocated return values or race detection), since
 		// we will not generate that code in the case of the extra
@@ -1127,7 +1127,7 @@ func (s *state) move(t *types.Type, dst, src *ssa.Value) {
 
 // stmtList converts the statement list n to SSA and adds it to s.
 func (s *state) stmtList(l ir.Nodes) {
-	for _, n := range l.Slice() {
+	for _, n := range l {
 		s.stmt(n)
 	}
 }
@@ -1208,9 +1208,9 @@ func (s *state) stmt(n ir.Node) {
 
 	case ir.OAS2DOTTYPE:
 		n := n.(*ir.AssignListStmt)
-		res, resok := s.dottype(n.Rhs.First().(*ir.TypeAssertExpr), true)
+		res, resok := s.dottype(n.Rhs[0].(*ir.TypeAssertExpr), true)
 		deref := false
-		if !canSSAType(n.Rhs.First().Type()) {
+		if !canSSAType(n.Rhs[0].Type()) {
 			if res.Op != ssa.OpLoad {
 				s.Fatalf("dottype of non-load")
 			}
@@ -1224,22 +1224,22 @@ func (s *state) stmt(n ir.Node) {
 			deref = true
 			res = res.Args[0]
 		}
-		s.assign(n.Lhs.First(), res, deref, 0)
-		s.assign(n.Lhs.Second(), resok, false, 0)
+		s.assign(n.Lhs[0], res, deref, 0)
+		s.assign(n.Lhs[1], resok, false, 0)
 		return
 
 	case ir.OAS2FUNC:
 		// We come here only when it is an intrinsic call returning two values.
 		n := n.(*ir.AssignListStmt)
-		call := n.Rhs.First().(*ir.CallExpr)
+		call := n.Rhs[0].(*ir.CallExpr)
 		if !IsIntrinsicCall(call) {
 			s.Fatalf("non-intrinsic AS2FUNC not expanded %v", call)
 		}
 		v := s.intrinsicCall(call)
-		v1 := s.newValue1(ssa.OpSelect0, n.Lhs.First().Type(), v)
-		v2 := s.newValue1(ssa.OpSelect1, n.Lhs.Second().Type(), v)
-		s.assign(n.Lhs.First(), v1, false, 0)
-		s.assign(n.Lhs.Second(), v2, false, 0)
+		v1 := s.newValue1(ssa.OpSelect0, n.Lhs[0].Type(), v)
+		v2 := s.newValue1(ssa.OpSelect1, n.Lhs[1].Type(), v)
+		s.assign(n.Lhs[0], v1, false, 0)
+		s.assign(n.Lhs[1], v2, false, 0)
 		return
 
 	case ir.ODCL:
@@ -1309,7 +1309,7 @@ func (s *state) stmt(n ir.Node) {
 				// Check whether we're writing the result of an append back to the same slice.
 				// If so, we handle it specially to avoid write barriers on the fast
 				// (non-growth) path.
-				if !samesafeexpr(n.X, rhs.Args.First()) || base.Flag.N != 0 {
+				if !samesafeexpr(n.X, rhs.Args[0]) || base.Flag.N != 0 {
 					break
 				}
 				// If the slice can be SSA'd, it'll be on the stack,
@@ -1412,27 +1412,27 @@ func (s *state) stmt(n ir.Node) {
 			likely = 1
 		}
 		var bThen *ssa.Block
-		if n.Body.Len() != 0 {
+		if len(n.Body) != 0 {
 			bThen = s.f.NewBlock(ssa.BlockPlain)
 		} else {
 			bThen = bEnd
 		}
 		var bElse *ssa.Block
-		if n.Else.Len() != 0 {
+		if len(n.Else) != 0 {
 			bElse = s.f.NewBlock(ssa.BlockPlain)
 		} else {
 			bElse = bEnd
 		}
 		s.condBranch(n.Cond, bThen, bElse, likely)
 
-		if n.Body.Len() != 0 {
+		if len(n.Body) != 0 {
 			s.startBlock(bThen)
 			s.stmtList(n.Body)
 			if b := s.endBlock(); b != nil {
 				b.AddEdgeTo(bEnd)
 			}
 		}
-		if n.Else.Len() != 0 {
+		if len(n.Else) != 0 {
 			s.startBlock(bElse)
 			s.stmtList(n.Else)
 			if b := s.endBlock(); b != nil {
@@ -2865,8 +2865,8 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 	case ir.OSLICEHEADER:
 		n := n.(*ir.SliceHeaderExpr)
 		p := s.expr(n.Ptr)
-		l := s.expr(n.LenCap.First())
-		c := s.expr(n.LenCap.Second())
+		l := s.expr(n.LenCap[0])
+		c := s.expr(n.LenCap[1])
 		return s.newValue3(ssa.OpSliceMake, n.Type(), p, l, c)
 
 	case ir.OSLICE, ir.OSLICEARR, ir.OSLICE3, ir.OSLICE3ARR:
@@ -2987,7 +2987,7 @@ func (s *state) append(n *ir.CallExpr, inplace bool) *ssa.Value {
 	pt := types.NewPtr(et)
 
 	// Evaluate slice
-	sn := n.Args.First() // the slice node is the first in the list
+	sn := n.Args[0] // the slice node is the first in the list
 
 	var slice, addr *ssa.Value
 	if inplace {
@@ -3002,7 +3002,7 @@ func (s *state) append(n *ir.CallExpr, inplace bool) *ssa.Value {
 	assign := s.f.NewBlock(ssa.BlockPlain)
 
 	// Decide if we need to grow
-	nargs := int64(n.Args.Len() - 1)
+	nargs := int64(len(n.Args) - 1)
 	p := s.newValue1(ssa.OpSlicePtr, pt, slice)
 	l := s.newValue1(ssa.OpSliceLen, types.Types[types.TINT], slice)
 	c := s.newValue1(ssa.OpSliceCap, types.Types[types.TINT], slice)
@@ -3071,7 +3071,7 @@ func (s *state) append(n *ir.CallExpr, inplace bool) *ssa.Value {
 		store bool
 	}
 	args := make([]argRec, 0, nargs)
-	for _, n := range n.Args.Slice()[1:] {
+	for _, n := range n.Args[1:] {
 		if canSSAType(n.Type()) {
 			args = append(args, argRec{v: s.expr(n), store: true})
 		} else {
@@ -4360,7 +4360,7 @@ func (s *state) intrinsicCall(n *ir.CallExpr) *ssa.Value {
 func (s *state) intrinsicArgs(n *ir.CallExpr) []*ssa.Value {
 	// Construct map of temps; see comments in s.call about the structure of n.
 	temps := map[ir.Node]*ssa.Value{}
-	for _, a := range n.Args.Slice() {
+	for _, a := range n.Args {
 		if a.Op() != ir.OAS {
 			s.Fatalf("non-assignment as a temp function argument %v", a.Op())
 		}
@@ -4373,8 +4373,8 @@ func (s *state) intrinsicArgs(n *ir.CallExpr) []*ssa.Value {
 		// Walk ensures these temporaries are dead outside of n.
 		temps[l] = s.expr(r)
 	}
-	args := make([]*ssa.Value, n.Rargs.Len())
-	for i, n := range n.Rargs.Slice() {
+	args := make([]*ssa.Value, len(n.Rargs))
+	for i, n := range n.Rargs {
 		// Store a value to an argument slot.
 		if x, ok := temps[n]; ok {
 			// This is a previously computed temporary.
@@ -4442,7 +4442,7 @@ func (s *state) openDeferRecord(n *ir.CallExpr) {
 		opendefer.closureNode = opendefer.closure.Aux.(*ir.Name)
 		opendefer.rcvrNode = opendefer.rcvr.Aux.(*ir.Name)
 	}
-	for _, argn := range n.Rargs.Slice() {
+	for _, argn := range n.Rargs {
 		var v *ssa.Value
 		if canSSAType(argn.Type()) {
 			v = s.openDeferSave(nil, argn.Type(), s.expr(argn))
@@ -4769,7 +4769,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		// Then, store all the arguments of the defer call.
 		ft := fn.Type()
 		off := t.FieldOff(12)
-		args := n.Rargs.Slice()
+		args := n.Rargs
 
 		// Set receiver (for interface calls). Always a pointer.
 		if rcvr != nil {
@@ -4846,7 +4846,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 
 		// Write args.
 		t := n.X.Type()
-		args := n.Rargs.Slice()
+		args := n.Rargs
 		if n.Op() == ir.OCALLMETH {
 			f := t.Recv()
 			ACArg, arg := s.putArg(args[0], f.Type, argStart+f.Offset, testLateExpansion)
@@ -6158,7 +6158,7 @@ func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Val
 		targetITab = target
 	} else {
 		// Looking for pointer to itab for target type and source interface.
-		targetITab = s.expr(n.Itab.First())
+		targetITab = s.expr(n.Itab[0])
 	}
 
 	var tmp ir.Node     // temporary for use with large types
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 450b20e000..59763824fb 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -552,7 +552,7 @@ func assignconvfn(n ir.Node, t *types.Type, context func() string) ir.Node {
 func backingArrayPtrLen(n ir.Node) (ptr, length ir.Node) {
 	var init ir.Nodes
 	c := cheapexpr(n, &init)
-	if c != n || init.Len() != 0 {
+	if c != n || len(init) != 0 {
 		base.Fatalf("backingArrayPtrLen not cheap: %v", n)
 	}
 	ptr = ir.NewUnaryExpr(base.Pos, ir.OSPTR, n)
@@ -593,7 +593,7 @@ func updateHasCall(n ir.Node) {
 }
 
 func calcHasCall(n ir.Node) bool {
-	if n.Init().Len() != 0 {
+	if len(n.Init()) != 0 {
 		// TODO(mdempsky): This seems overly conservative.
 		return true
 	}
@@ -772,9 +772,9 @@ func safeexpr(n ir.Node, init *ir.Nodes) ir.Node {
 		return nil
 	}
 
-	if n.Init().Len() != 0 {
-		walkstmtlist(n.Init().Slice())
-		init.AppendNodes(n.PtrInit())
+	if len(n.Init()) != 0 {
+		walkstmtlist(n.Init())
+		init.Append(n.PtrInit().Take()...)
 	}
 
 	switch n.Op() {
@@ -1230,7 +1230,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 		n := ir.NewIfStmt(base.Pos, nil, nil, nil)
 		n.Cond = ir.NewBinaryExpr(base.Pos, ir.OEQ, nthis, nodnil())
 		call := ir.NewCallExpr(base.Pos, ir.OCALL, syslook("panicwrap"), nil)
-		n.Body.Set1(call)
+		n.Body = []ir.Node{call}
 		fn.Body.Append(n)
 	}
 
@@ -1259,7 +1259,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 		call.IsDDD = tfn.Type().IsVariadic()
 		if method.Type.NumResults() > 0 {
 			ret := ir.NewReturnStmt(base.Pos, nil)
-			ret.Results.Set1(call)
+			ret.Results = []ir.Node{call}
 			fn.Body.Append(ret)
 		} else {
 			fn.Body.Append(call)
@@ -1277,7 +1277,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 
 	typecheckFunc(fn)
 	Curfn = fn
-	typecheckslice(fn.Body.Slice(), ctxStmt)
+	typecheckslice(fn.Body, ctxStmt)
 
 	// Inline calls within (*T).M wrappers. This is safe because we only
 	// generate those wrappers within the same compilation unit as (T).M.
diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index da781e6f45..ab241a3813 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -16,7 +16,7 @@ import (
 
 // typecheckswitch typechecks a switch statement.
 func typecheckswitch(n *ir.SwitchStmt) {
-	typecheckslice(n.Init().Slice(), ctxStmt)
+	typecheckslice(n.Init(), ctxStmt)
 	if n.Tag != nil && n.Tag.Op() == ir.OTYPESW {
 		typecheckTypeSwitch(n)
 	} else {
@@ -36,15 +36,15 @@ func typecheckTypeSwitch(n *ir.SwitchStmt) {
 	// We don't actually declare the type switch's guarded
 	// declaration itself. So if there are no cases, we won't
 	// notice that it went unused.
-	if v := guard.Tag; v != nil && !ir.IsBlank(v) && n.Cases.Len() == 0 {
+	if v := guard.Tag; v != nil && !ir.IsBlank(v) && len(n.Cases) == 0 {
 		base.ErrorfAt(v.Pos(), "%v declared but not used", v.Sym())
 	}
 
 	var defCase, nilCase ir.Node
 	var ts typeSet
-	for _, ncase := range n.Cases.Slice() {
+	for _, ncase := range n.Cases {
 		ncase := ncase.(*ir.CaseStmt)
-		ls := ncase.List.Slice()
+		ls := ncase.List
 		if len(ls) == 0 { // default:
 			if defCase != nil {
 				base.ErrorfAt(ncase.Pos(), "multiple defaults in switch (first at %v)", ir.Line(defCase))
@@ -91,7 +91,7 @@ func typecheckTypeSwitch(n *ir.SwitchStmt) {
 			ts.add(ncase.Pos(), n1.Type())
 		}
 
-		if ncase.Vars.Len() != 0 {
+		if len(ncase.Vars) != 0 {
 			// Assign the clause variable's type.
 			vt := t
 			if len(ls) == 1 {
@@ -104,7 +104,7 @@ func typecheckTypeSwitch(n *ir.SwitchStmt) {
 				}
 			}
 
-			nvar := ncase.Vars.First()
+			nvar := ncase.Vars[0]
 			nvar.SetType(vt)
 			if vt != nil {
 				nvar = typecheck(nvar, ctxExpr|ctxAssign)
@@ -113,10 +113,10 @@ func typecheckTypeSwitch(n *ir.SwitchStmt) {
 				nvar.SetTypecheck(1)
 				nvar.SetWalkdef(1)
 			}
-			ncase.Vars.SetFirst(nvar)
+			ncase.Vars[0] = nvar
 		}
 
-		typecheckslice(ncase.Body.Slice(), ctxStmt)
+		typecheckslice(ncase.Body, ctxStmt)
 	}
 }
 
@@ -178,9 +178,9 @@ func typecheckExprSwitch(n *ir.SwitchStmt) {
 
 	var defCase ir.Node
 	var cs constSet
-	for _, ncase := range n.Cases.Slice() {
+	for _, ncase := range n.Cases {
 		ncase := ncase.(*ir.CaseStmt)
-		ls := ncase.List.Slice()
+		ls := ncase.List
 		if len(ls) == 0 { // default:
 			if defCase != nil {
 				base.ErrorfAt(ncase.Pos(), "multiple defaults in switch (first at %v)", ir.Line(defCase))
@@ -225,14 +225,14 @@ func typecheckExprSwitch(n *ir.SwitchStmt) {
 			}
 		}
 
-		typecheckslice(ncase.Body.Slice(), ctxStmt)
+		typecheckslice(ncase.Body, ctxStmt)
 	}
 }
 
 // walkswitch walks a switch statement.
 func walkswitch(sw *ir.SwitchStmt) {
 	// Guard against double walk, see #25776.
-	if sw.Cases.Len() == 0 && sw.Compiled.Len() > 0 {
+	if len(sw.Cases) == 0 && len(sw.Compiled) > 0 {
 		return // Was fatal, but eliminating every possible source of double-walking is hard
 	}
 
@@ -283,27 +283,27 @@ func walkExprSwitch(sw *ir.SwitchStmt) {
 
 	var defaultGoto ir.Node
 	var body ir.Nodes
-	for _, ncase := range sw.Cases.Slice() {
+	for _, ncase := range sw.Cases {
 		ncase := ncase.(*ir.CaseStmt)
 		label := autolabel(".s")
 		jmp := ir.NewBranchStmt(ncase.Pos(), ir.OGOTO, label)
 
 		// Process case dispatch.
-		if ncase.List.Len() == 0 {
+		if len(ncase.List) == 0 {
 			if defaultGoto != nil {
 				base.Fatalf("duplicate default case not detected during typechecking")
 			}
 			defaultGoto = jmp
 		}
 
-		for _, n1 := range ncase.List.Slice() {
+		for _, n1 := range ncase.List {
 			s.Add(ncase.Pos(), n1, jmp)
 		}
 
 		// Process body.
 		body.Append(ir.NewLabelStmt(ncase.Pos(), label))
-		body.Append(ncase.Body.Slice()...)
-		if fall, pos := endsInFallthrough(ncase.Body.Slice()); !fall {
+		body.Append(ncase.Body...)
+		if fall, pos := endsInFallthrough(ncase.Body); !fall {
 			br := ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)
 			br.SetPos(pos)
 			body.Append(br)
@@ -319,8 +319,8 @@ func walkExprSwitch(sw *ir.SwitchStmt) {
 
 	s.Emit(&sw.Compiled)
 	sw.Compiled.Append(defaultGoto)
-	sw.Compiled.AppendNodes(&body)
-	walkstmtlist(sw.Compiled.Slice())
+	sw.Compiled.Append(body.Take()...)
+	walkstmtlist(sw.Compiled)
 }
 
 // An exprSwitch walks an expression switch.
@@ -351,7 +351,7 @@ func (s *exprSwitch) Add(pos src.XPos, expr, jmp ir.Node) {
 
 func (s *exprSwitch) Emit(out *ir.Nodes) {
 	s.flush()
-	out.AppendNodes(&s.done)
+	out.Append(s.done.Take()...)
 }
 
 func (s *exprSwitch) flush() {
@@ -438,7 +438,7 @@ func (s *exprSwitch) search(cc []exprClause, out *ir.Nodes) {
 		func(i int, nif *ir.IfStmt) {
 			c := &cc[i]
 			nif.Cond = c.test(s.exprname)
-			nif.Body.Set1(c.jmp)
+			nif.Body = []ir.Node{c.jmp}
 		},
 	)
 }
@@ -471,9 +471,9 @@ func allCaseExprsAreSideEffectFree(sw *ir.SwitchStmt) bool {
 	// Restricting to constants is simple and probably powerful
 	// enough.
 
-	for _, ncase := range sw.Cases.Slice() {
+	for _, ncase := range sw.Cases {
 		ncase := ncase.(*ir.CaseStmt)
-		for _, v := range ncase.List.Slice() {
+		for _, v := range ncase.List {
 			if v.Op() != ir.OLITERAL {
 				return false
 			}
@@ -545,33 +545,33 @@ func walkTypeSwitch(sw *ir.SwitchStmt) {
 	br := ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)
 	var defaultGoto, nilGoto ir.Node
 	var body ir.Nodes
-	for _, ncase := range sw.Cases.Slice() {
+	for _, ncase := range sw.Cases {
 		ncase := ncase.(*ir.CaseStmt)
 		var caseVar ir.Node
-		if ncase.Vars.Len() != 0 {
-			caseVar = ncase.Vars.First()
+		if len(ncase.Vars) != 0 {
+			caseVar = ncase.Vars[0]
 		}
 
 		// For single-type cases with an interface type,
 		// we initialize the case variable as part of the type assertion.
 		// In other cases, we initialize it in the body.
 		var singleType *types.Type
-		if ncase.List.Len() == 1 && ncase.List.First().Op() == ir.OTYPE {
-			singleType = ncase.List.First().Type()
+		if len(ncase.List) == 1 && ncase.List[0].Op() == ir.OTYPE {
+			singleType = ncase.List[0].Type()
 		}
 		caseVarInitialized := false
 
 		label := autolabel(".s")
 		jmp := ir.NewBranchStmt(ncase.Pos(), ir.OGOTO, label)
 
-		if ncase.List.Len() == 0 { // default:
+		if len(ncase.List) == 0 { // default:
 			if defaultGoto != nil {
 				base.Fatalf("duplicate default case not detected during typechecking")
 			}
 			defaultGoto = jmp
 		}
 
-		for _, n1 := range ncase.List.Slice() {
+		for _, n1 := range ncase.List {
 			if ir.IsNil(n1) { // case nil:
 				if nilGoto != nil {
 					base.Fatalf("duplicate nil case not detected during typechecking")
@@ -605,7 +605,7 @@ func walkTypeSwitch(sw *ir.SwitchStmt) {
 			typecheckslice(l, ctxStmt)
 			body.Append(l...)
 		}
-		body.Append(ncase.Body.Slice()...)
+		body.Append(ncase.Body...)
 		body.Append(br)
 	}
 	sw.Cases.Set(nil)
@@ -616,13 +616,13 @@ func walkTypeSwitch(sw *ir.SwitchStmt) {
 	if nilGoto == nil {
 		nilGoto = defaultGoto
 	}
-	ifNil.Body.Set1(nilGoto)
+	ifNil.Body = []ir.Node{nilGoto}
 
 	s.Emit(&sw.Compiled)
 	sw.Compiled.Append(defaultGoto)
-	sw.Compiled.AppendNodes(&body)
+	sw.Compiled.Append(body.Take()...)
 
-	walkstmtlist(sw.Compiled.Slice())
+	walkstmtlist(sw.Compiled)
 }
 
 // A typeSwitch walks a type switch.
@@ -656,16 +656,16 @@ func (s *typeSwitch) Add(pos src.XPos, typ *types.Type, caseVar, jmp ir.Node) {
 
 	// cv, ok = iface.(type)
 	as := ir.NewAssignListStmt(pos, ir.OAS2, nil, nil)
-	as.Lhs.Set2(caseVar, s.okname) // cv, ok =
+	as.Lhs = []ir.Node{caseVar, s.okname} // cv, ok =
 	dot := ir.NewTypeAssertExpr(pos, s.facename, nil)
 	dot.SetType(typ) // iface.(type)
-	as.Rhs.Set1(dot)
+	as.Rhs = []ir.Node{dot}
 	appendWalkStmt(&body, as)
 
 	// if ok { goto label }
 	nif := ir.NewIfStmt(pos, nil, nil, nil)
 	nif.Cond = s.okname
-	nif.Body.Set1(jmp)
+	nif.Body = []ir.Node{jmp}
 	body.Append(nif)
 
 	if !typ.IsInterface() {
@@ -677,12 +677,12 @@ func (s *typeSwitch) Add(pos src.XPos, typ *types.Type, caseVar, jmp ir.Node) {
 	}
 
 	s.flush()
-	s.done.AppendNodes(&body)
+	s.done.Append(body.Take()...)
 }
 
 func (s *typeSwitch) Emit(out *ir.Nodes) {
 	s.flush()
-	out.AppendNodes(&s.done)
+	out.Append(s.done.Take()...)
 }
 
 func (s *typeSwitch) flush() {
@@ -699,7 +699,7 @@ func (s *typeSwitch) flush() {
 	for _, c := range cc[1:] {
 		last := &merged[len(merged)-1]
 		if last.hash == c.hash {
-			last.body.AppendNodes(&c.body)
+			last.body.Append(c.body.Take()...)
 		} else {
 			merged = append(merged, c)
 		}
@@ -715,7 +715,7 @@ func (s *typeSwitch) flush() {
 			// there's only one type.
 			c := cc[i]
 			nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OEQ, s.hashname, nodintconst(int64(c.hash)))
-			nif.Body.AppendNodes(&c.body)
+			nif.Body.Append(c.body.Take()...)
 		},
 	)
 }
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 73fb6bb1c1..f2e5728d80 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -1027,7 +1027,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			}
 			if r.Op() == ir.OADDSTR {
 				r := r.(*ir.AddStringExpr)
-				add.List.AppendNodes(&r.List)
+				add.List.Append(r.List.Take()...)
 			} else {
 				add.List.Append(r)
 			}
@@ -1355,13 +1355,13 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			base.Fatalf("need unsafe.Pointer for OSLICEHEADER")
 		}
 
-		if x := n.LenCap.Len(); x != 2 {
+		if x := len(n.LenCap); x != 2 {
 			base.Fatalf("expected 2 params (len, cap) for OSLICEHEADER, got %d", x)
 		}
 
 		n.Ptr = typecheck(n.Ptr, ctxExpr)
-		l := typecheck(n.LenCap.First(), ctxExpr)
-		c := typecheck(n.LenCap.Second(), ctxExpr)
+		l := typecheck(n.LenCap[0], ctxExpr)
+		c := typecheck(n.LenCap[1], ctxExpr)
 		l = defaultlit(l, types.Types[types.TINT])
 		c = defaultlit(c, types.Types[types.TINT])
 
@@ -1377,8 +1377,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			base.Fatalf("len larger than cap for OSLICEHEADER")
 		}
 
-		n.LenCap.SetFirst(l)
-		n.LenCap.SetSecond(c)
+		n.LenCap[0] = l
+		n.LenCap[1] = c
 		return n
 
 	case ir.OMAKESLICECOPY:
@@ -1506,7 +1506,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		if top == ctxStmt {
 			n.Use = ir.CallUseStmt
 		}
-		typecheckslice(n.Init().Slice(), ctxStmt) // imported rewritten f(g()) calls (#30907)
+		typecheckslice(n.Init(), ctxStmt) // imported rewritten f(g()) calls (#30907)
 		n.X = typecheck(n.X, ctxExpr|ctxType|ctxCallee)
 		if n.X.Diag() {
 			n.SetDiag(true)
@@ -1541,7 +1541,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 					return n
 				}
 				u := ir.NewUnaryExpr(n.Pos(), l.BuiltinOp, arg)
-				return typecheck(initExpr(n.Init().Slice(), u), top) // typecheckargs can add to old.Init
+				return typecheck(initExpr(n.Init(), u), top) // typecheckargs can add to old.Init
 
 			case ir.OCOMPLEX, ir.OCOPY:
 				typecheckargs(n)
@@ -1551,7 +1551,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 					return n
 				}
 				b := ir.NewBinaryExpr(n.Pos(), l.BuiltinOp, arg1, arg2)
-				return typecheck(initExpr(n.Init().Slice(), b), top) // typecheckargs can add to old.Init
+				return typecheck(initExpr(n.Init(), b), top) // typecheckargs can add to old.Init
 			}
 			panic("unreachable")
 		}
@@ -1777,46 +1777,46 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		n := n.(*ir.CallExpr)
 		typecheckargs(n)
 		args := n.Args
-		if args.Len() == 0 {
+		if len(args) == 0 {
 			base.Errorf("missing arguments to delete")
 			n.SetType(nil)
 			return n
 		}
 
-		if args.Len() == 1 {
+		if len(args) == 1 {
 			base.Errorf("missing second (key) argument to delete")
 			n.SetType(nil)
 			return n
 		}
 
-		if args.Len() != 2 {
+		if len(args) != 2 {
 			base.Errorf("too many arguments to delete")
 			n.SetType(nil)
 			return n
 		}
 
-		l := args.First()
-		r := args.Second()
+		l := args[0]
+		r := args[1]
 		if l.Type() != nil && !l.Type().IsMap() {
 			base.Errorf("first argument to delete must be map; have %L", l.Type())
 			n.SetType(nil)
 			return n
 		}
 
-		args.SetSecond(assignconv(r, l.Type().Key(), "delete"))
+		args[1] = assignconv(r, l.Type().Key(), "delete")
 		return n
 
 	case ir.OAPPEND:
 		n := n.(*ir.CallExpr)
 		typecheckargs(n)
 		args := n.Args
-		if args.Len() == 0 {
+		if len(args) == 0 {
 			base.Errorf("missing arguments to append")
 			n.SetType(nil)
 			return n
 		}
 
-		t := args.First().Type()
+		t := args[0].Type()
 		if t == nil {
 			n.SetType(nil)
 			return n
@@ -1824,7 +1824,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 		n.SetType(t)
 		if !t.IsSlice() {
-			if ir.IsNil(args.First()) {
+			if ir.IsNil(args[0]) {
 				base.Errorf("first argument to append must be typed slice; have untyped nil")
 				n.SetType(nil)
 				return n
@@ -1836,28 +1836,28 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 
 		if n.IsDDD {
-			if args.Len() == 1 {
+			if len(args) == 1 {
 				base.Errorf("cannot use ... on first argument to append")
 				n.SetType(nil)
 				return n
 			}
 
-			if args.Len() != 2 {
+			if len(args) != 2 {
 				base.Errorf("too many arguments to append")
 				n.SetType(nil)
 				return n
 			}
 
-			if t.Elem().IsKind(types.TUINT8) && args.Second().Type().IsString() {
-				args.SetSecond(defaultlit(args.Second(), types.Types[types.TSTRING]))
+			if t.Elem().IsKind(types.TUINT8) && args[1].Type().IsString() {
+				args[1] = defaultlit(args[1], types.Types[types.TSTRING])
 				return n
 			}
 
-			args.SetSecond(assignconv(args.Second(), t.Underlying(), "append"))
+			args[1] = assignconv(args[1], t.Underlying(), "append")
 			return n
 		}
 
-		as := args.Slice()[1:]
+		as := args[1:]
 		for i, n := range as {
 			if n.Type() == nil {
 				continue
@@ -1955,7 +1955,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OMAKE:
 		n := n.(*ir.CallExpr)
-		args := n.Args.Slice()
+		args := n.Args
 		if len(args) == 0 {
 			base.Errorf("missing argument to make")
 			n.SetType(nil)
@@ -2082,7 +2082,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 	case ir.OPRINT, ir.OPRINTN:
 		n := n.(*ir.CallExpr)
 		typecheckargs(n)
-		ls := n.Args.Slice()
+		ls := n.Args
 		for i1, n1 := range ls {
 			// Special case for print: int constant is int64, not int.
 			if ir.IsConst(n1, constant.Int) {
@@ -2105,7 +2105,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.ORECOVER:
 		n := n.(*ir.CallExpr)
-		if n.Args.Len() != 0 {
+		if len(n.Args) != 0 {
 			base.Errorf("too many arguments to recover")
 			n.SetType(nil)
 			return n
@@ -2201,7 +2201,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OBLOCK:
 		n := n.(*ir.BlockStmt)
-		typecheckslice(n.List.Slice(), ctxStmt)
+		typecheckslice(n.List, ctxStmt)
 		return n
 
 	case ir.OLABEL:
@@ -2224,7 +2224,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OFOR, ir.OFORUNTIL:
 		n := n.(*ir.ForStmt)
-		typecheckslice(n.Init().Slice(), ctxStmt)
+		typecheckslice(n.Init(), ctxStmt)
 		decldepth++
 		n.Cond = typecheck(n.Cond, ctxExpr)
 		n.Cond = defaultlit(n.Cond, nil)
@@ -2236,15 +2236,15 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 		n.Post = typecheck(n.Post, ctxStmt)
 		if n.Op() == ir.OFORUNTIL {
-			typecheckslice(n.Late.Slice(), ctxStmt)
+			typecheckslice(n.Late, ctxStmt)
 		}
-		typecheckslice(n.Body.Slice(), ctxStmt)
+		typecheckslice(n.Body, ctxStmt)
 		decldepth--
 		return n
 
 	case ir.OIF:
 		n := n.(*ir.IfStmt)
-		typecheckslice(n.Init().Slice(), ctxStmt)
+		typecheckslice(n.Init(), ctxStmt)
 		n.Cond = typecheck(n.Cond, ctxExpr)
 		n.Cond = defaultlit(n.Cond, nil)
 		if n.Cond != nil {
@@ -2253,8 +2253,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				base.Errorf("non-bool %L used as if condition", n.Cond)
 			}
 		}
-		typecheckslice(n.Body.Slice(), ctxStmt)
-		typecheckslice(n.Else.Slice(), ctxStmt)
+		typecheckslice(n.Body, ctxStmt)
+		typecheckslice(n.Else, ctxStmt)
 		return n
 
 	case ir.ORETURN:
@@ -2266,7 +2266,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			return n
 		}
 
-		if hasNamedResults(Curfn) && n.Results.Len() == 0 {
+		if hasNamedResults(Curfn) && len(n.Results) == 0 {
 			return n
 		}
 		typecheckaste(ir.ORETURN, nil, false, Curfn.Type().Results(), n.Results, func() string { return "return argument" })
@@ -2321,13 +2321,13 @@ func typecheckargs(n ir.Node) {
 	default:
 		base.Fatalf("typecheckargs %+v", n.Op())
 	case *ir.CallExpr:
-		list = n.Args.Slice()
+		list = n.Args
 		if n.IsDDD {
 			typecheckslice(list, ctxExpr)
 			return
 		}
 	case *ir.ReturnStmt:
-		list = n.Results.Slice()
+		list = n.Results
 	}
 	if len(list) != 1 {
 		typecheckslice(list, ctxExpr)
@@ -2493,31 +2493,31 @@ func implicitstar(n ir.Node) ir.Node {
 }
 
 func needOneArg(n *ir.CallExpr, f string, args ...interface{}) (ir.Node, bool) {
-	if n.Args.Len() == 0 {
+	if len(n.Args) == 0 {
 		p := fmt.Sprintf(f, args...)
 		base.Errorf("missing argument to %s: %v", p, n)
 		return nil, false
 	}
 
-	if n.Args.Len() > 1 {
+	if len(n.Args) > 1 {
 		p := fmt.Sprintf(f, args...)
 		base.Errorf("too many arguments to %s: %v", p, n)
-		return n.Args.First(), false
+		return n.Args[0], false
 	}
 
-	return n.Args.First(), true
+	return n.Args[0], true
 }
 
 func needTwoArgs(n *ir.CallExpr) (ir.Node, ir.Node, bool) {
-	if n.Args.Len() != 2 {
-		if n.Args.Len() < 2 {
+	if len(n.Args) != 2 {
+		if len(n.Args) < 2 {
 			base.Errorf("not enough arguments in call to %v", n)
 		} else {
 			base.Errorf("too many arguments in call to %v", n)
 		}
 		return nil, nil, false
 	}
-	return n.Args.First(), n.Args.Second(), true
+	return n.Args[0], n.Args[1], true
 }
 
 func lookdot1(errnode ir.Node, s *types.Sym, t *types.Type, fs *types.Fields, dostrcmp int) *types.Field {
@@ -2741,7 +2741,7 @@ func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 }
 
 func nokeys(l ir.Nodes) bool {
-	for _, n := range l.Slice() {
+	for _, n := range l {
 		if n.Op() == ir.OKEY || n.Op() == ir.OSTRUCTKEY {
 			return false
 		}
@@ -2772,12 +2772,12 @@ func typecheckaste(op ir.Op, call ir.Node, isddd bool, tstruct *types.Type, nl i
 	}
 
 	var n ir.Node
-	if nl.Len() == 1 {
-		n = nl.First()
+	if len(nl) == 1 {
+		n = nl[0]
 	}
 
 	n1 := tstruct.NumFields()
-	n2 := nl.Len()
+	n2 := len(nl)
 	if !hasddd(tstruct) {
 		if n2 > n1 {
 			goto toomany
@@ -2805,43 +2805,43 @@ func typecheckaste(op ir.Op, call ir.Node, isddd bool, tstruct *types.Type, nl i
 		t = tl.Type
 		if tl.IsDDD() {
 			if isddd {
-				if i >= nl.Len() {
+				if i >= len(nl) {
 					goto notenough
 				}
-				if nl.Len()-i > 1 {
+				if len(nl)-i > 1 {
 					goto toomany
 				}
-				n = nl.Index(i)
+				n = nl[i]
 				setlineno(n)
 				if n.Type() != nil {
-					nl.SetIndex(i, assignconvfn(n, t, desc))
+					nl[i] = assignconvfn(n, t, desc)
 				}
 				return
 			}
 
 			// TODO(mdempsky): Make into ... call with implicit slice.
-			for ; i < nl.Len(); i++ {
-				n = nl.Index(i)
+			for ; i < len(nl); i++ {
+				n = nl[i]
 				setlineno(n)
 				if n.Type() != nil {
-					nl.SetIndex(i, assignconvfn(n, t.Elem(), desc))
+					nl[i] = assignconvfn(n, t.Elem(), desc)
 				}
 			}
 			return
 		}
 
-		if i >= nl.Len() {
+		if i >= len(nl) {
 			goto notenough
 		}
-		n = nl.Index(i)
+		n = nl[i]
 		setlineno(n)
 		if n.Type() != nil {
-			nl.SetIndex(i, assignconvfn(n, t, desc))
+			nl[i] = assignconvfn(n, t, desc)
 		}
 		i++
 	}
 
-	if i < nl.Len() {
+	if i < len(nl) {
 		goto toomany
 	}
 	if isddd {
@@ -2891,7 +2891,7 @@ func errorDetails(nl ir.Nodes, tstruct *types.Type, isddd bool) string {
 		return ""
 	}
 	// If any node has an unknown type, suppress it as well
-	for _, n := range nl.Slice() {
+	for _, n := range nl {
 		if n.Type() == nil {
 			return ""
 		}
@@ -2929,13 +2929,13 @@ func sigrepr(t *types.Type, isddd bool) string {
 
 // sigerr returns the signature of the types at the call or return.
 func fmtSignature(nl ir.Nodes, isddd bool) string {
-	if nl.Len() < 1 {
+	if len(nl) < 1 {
 		return "()"
 	}
 
 	var typeStrings []string
-	for i, n := range nl.Slice() {
-		isdddArg := isddd && i == nl.Len()-1
+	for i, n := range nl {
+		isdddArg := isddd && i == len(nl)-1
 		typeStrings = append(typeStrings, sigrepr(n.Type(), isdddArg))
 	}
 
@@ -3019,7 +3019,7 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 			n.SetType(nil)
 			return n
 		}
-		length := typecheckarraylit(elemType, -1, n.List.Slice(), "array literal")
+		length := typecheckarraylit(elemType, -1, n.List, "array literal")
 		n.SetOp(ir.OARRAYLIT)
 		n.SetType(types.NewArray(elemType, length))
 		n.Ntype = nil
@@ -3040,22 +3040,22 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 		n.SetType(nil)
 
 	case types.TARRAY:
-		typecheckarraylit(t.Elem(), t.NumElem(), n.List.Slice(), "array literal")
+		typecheckarraylit(t.Elem(), t.NumElem(), n.List, "array literal")
 		n.SetOp(ir.OARRAYLIT)
 		n.Ntype = nil
 
 	case types.TSLICE:
-		length := typecheckarraylit(t.Elem(), -1, n.List.Slice(), "slice literal")
+		length := typecheckarraylit(t.Elem(), -1, n.List, "slice literal")
 		n.SetOp(ir.OSLICELIT)
 		n.Ntype = nil
 		n.Len = length
 
 	case types.TMAP:
 		var cs constSet
-		for i3, l := range n.List.Slice() {
+		for i3, l := range n.List {
 			setlineno(l)
 			if l.Op() != ir.OKEY {
-				n.List.SetIndex(i3, typecheck(l, ctxExpr))
+				n.List[i3] = typecheck(l, ctxExpr)
 				base.Errorf("missing key in map literal")
 				continue
 			}
@@ -3081,9 +3081,9 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 		dowidth(t)
 
 		errored := false
-		if n.List.Len() != 0 && nokeys(n.List) {
+		if len(n.List) != 0 && nokeys(n.List) {
 			// simple list of variables
-			ls := n.List.Slice()
+			ls := n.List
 			for i, n1 := range ls {
 				setlineno(n1)
 				n1 = typecheck(n1, ctxExpr)
@@ -3114,7 +3114,7 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 			hash := make(map[string]bool)
 
 			// keyed list
-			ls := n.List.Slice()
+			ls := n.List
 			for i, l := range ls {
 				setlineno(l)
 
@@ -3355,7 +3355,7 @@ func checkassign(stmt ir.Node, n ir.Node) {
 }
 
 func checkassignlist(stmt ir.Node, l ir.Nodes) {
-	for _, n := range l.Slice() {
+	for _, n := range l {
 		checkassign(stmt, n)
 	}
 }
@@ -3497,7 +3497,7 @@ func typecheckas2(n *ir.AssignListStmt) {
 		defer tracePrint("typecheckas2", n)(nil)
 	}
 
-	ls := n.Lhs.Slice()
+	ls := n.Lhs
 	for i1, n1 := range ls {
 		// delicate little dance.
 		n1 = resolve(n1)
@@ -3508,12 +3508,12 @@ func typecheckas2(n *ir.AssignListStmt) {
 		}
 	}
 
-	cl := n.Lhs.Len()
-	cr := n.Rhs.Len()
+	cl := len(n.Lhs)
+	cr := len(n.Rhs)
 	if cl > 1 && cr == 1 {
-		n.Rhs.SetFirst(typecheck(n.Rhs.First(), ctxExpr|ctxMultiOK))
+		n.Rhs[0] = typecheck(n.Rhs[0], ctxExpr|ctxMultiOK)
 	} else {
-		typecheckslice(n.Rhs.Slice(), ctxExpr)
+		typecheckslice(n.Rhs, ctxExpr)
 	}
 	checkassignlist(n, n.Lhs)
 
@@ -3521,8 +3521,8 @@ func typecheckas2(n *ir.AssignListStmt) {
 	var r ir.Node
 	if cl == cr {
 		// easy
-		ls := n.Lhs.Slice()
-		rs := n.Rhs.Slice()
+		ls := n.Lhs
+		rs := n.Rhs
 		for il, nl := range ls {
 			nr := rs[il]
 			if nl.Type() != nil && nr.Type() != nil {
@@ -3537,8 +3537,8 @@ func typecheckas2(n *ir.AssignListStmt) {
 		goto out
 	}
 
-	l = n.Lhs.First()
-	r = n.Rhs.First()
+	l = n.Lhs[0]
+	r = n.Rhs[0]
 
 	// x,y,z = f()
 	if cr == 1 {
@@ -3556,7 +3556,7 @@ func typecheckas2(n *ir.AssignListStmt) {
 			}
 			r.(*ir.CallExpr).Use = ir.CallUseList
 			n.SetOp(ir.OAS2FUNC)
-			for i, l := range n.Lhs.Slice() {
+			for i, l := range n.Lhs {
 				f := r.Type().Field(i)
 				if f.Type != nil && l.Type() != nil {
 					checkassignto(f.Type, l)
@@ -3592,7 +3592,7 @@ func typecheckas2(n *ir.AssignListStmt) {
 			if ir.DeclaredBy(l, n) {
 				l.SetType(r.Type())
 			}
-			l := n.Lhs.Second()
+			l := n.Lhs[1]
 			if l.Type() != nil && !l.Type().IsBoolean() {
 				checkassignto(types.Types[types.TBOOL], l)
 			}
@@ -3615,7 +3615,7 @@ mismatch:
 	// second half of dance
 out:
 	n.SetTypecheck(1)
-	ls = n.Lhs.Slice()
+	ls = n.Lhs
 	for i1, n1 := range ls {
 		if n1.Typecheck() == 0 {
 			ls[i1] = typecheck(ls[i1], ctxExpr|ctxAssign)
@@ -4019,7 +4019,7 @@ func setHasBreak(n ir.Node) {
 
 // isTermNodes reports whether the Nodes list ends with a terminating statement.
 func isTermNodes(l ir.Nodes) bool {
-	s := l.Slice()
+	s := l
 	c := len(s)
 	if c == 0 {
 		return false
@@ -4063,12 +4063,12 @@ func isTermNode(n ir.Node) bool {
 			return false
 		}
 		def := false
-		for _, cas := range n.Cases.Slice() {
+		for _, cas := range n.Cases {
 			cas := cas.(*ir.CaseStmt)
 			if !isTermNodes(cas.Body) {
 				return false
 			}
-			if cas.List.Len() == 0 { // default
+			if len(cas.List) == 0 { // default
 				def = true
 			}
 		}
@@ -4079,7 +4079,7 @@ func isTermNode(n ir.Node) bool {
 		if n.HasBreak {
 			return false
 		}
-		for _, cas := range n.Cases.Slice() {
+		for _, cas := range n.Cases {
 			cas := cas.(*ir.CaseStmt)
 			if !isTermNodes(cas.Body) {
 				return false
@@ -4093,7 +4093,7 @@ func isTermNode(n ir.Node) bool {
 
 // checkreturn makes sure that fn terminates appropriately.
 func checkreturn(fn *ir.Func) {
-	if fn.Type().NumResults() != 0 && fn.Body.Len() != 0 {
+	if fn.Type().NumResults() != 0 && len(fn.Body) != 0 {
 		markBreak(fn)
 		if !isTermNodes(fn.Body) {
 			base.ErrorfAt(fn.Endlineno, "missing return at end of function")
@@ -4104,18 +4104,18 @@ func checkreturn(fn *ir.Func) {
 func deadcode(fn *ir.Func) {
 	deadcodeslice(&fn.Body)
 
-	if fn.Body.Len() == 0 {
+	if len(fn.Body) == 0 {
 		return
 	}
 
-	for _, n := range fn.Body.Slice() {
-		if n.Init().Len() > 0 {
+	for _, n := range fn.Body {
+		if len(n.Init()) > 0 {
 			return
 		}
 		switch n.Op() {
 		case ir.OIF:
 			n := n.(*ir.IfStmt)
-			if !ir.IsConst(n.Cond, constant.Bool) || n.Body.Len() > 0 || n.Else.Len() > 0 {
+			if !ir.IsConst(n.Cond, constant.Bool) || len(n.Body) > 0 || len(n.Else) > 0 {
 				return
 			}
 		case ir.OFOR:
@@ -4133,12 +4133,12 @@ func deadcode(fn *ir.Func) {
 
 func deadcodeslice(nn *ir.Nodes) {
 	var lastLabel = -1
-	for i, n := range nn.Slice() {
+	for i, n := range *nn {
 		if n != nil && n.Op() == ir.OLABEL {
 			lastLabel = i
 		}
 	}
-	for i, n := range nn.Slice() {
+	for i, n := range *nn {
 		// Cut is set to true when all nodes after i'th position
 		// should be removed.
 		// In other words, it marks whole slice "tail" as dead.
@@ -4163,7 +4163,7 @@ func deadcodeslice(nn *ir.Nodes) {
 				// isterminating is not used to avoid goto-related complications.
 				// We must be careful not to deadcode-remove labels, as they
 				// might be the target of a goto. See issue 28616.
-				if body := body.Slice(); len(body) != 0 {
+				if body := body; len(body) != 0 {
 					switch body[(len(body) - 1)].Op() {
 					case ir.ORETURN, ir.ORETJMP, ir.OPANIC:
 						if i > lastLabel {
@@ -4201,7 +4201,7 @@ func deadcodeslice(nn *ir.Nodes) {
 		}
 
 		if cut {
-			nn.Set(nn.Slice()[:i+1])
+			nn.Set((*nn)[:i+1])
 			break
 		}
 	}
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 3fd6c97d68..610c6b6539 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -72,7 +72,7 @@ func walk(fn *ir.Func) {
 	if base.Errors() > errorsBefore {
 		return
 	}
-	walkstmtlist(Curfn.Body.Slice())
+	walkstmtlist(Curfn.Body)
 	if base.Flag.W != 0 {
 		s := fmt.Sprintf("after walk %v", Curfn.Sym())
 		ir.DumpList(s, Curfn.Body)
@@ -80,7 +80,7 @@ func walk(fn *ir.Func) {
 
 	zeroResults()
 	heapmoves()
-	if base.Flag.W != 0 && Curfn.Enter.Len() > 0 {
+	if base.Flag.W != 0 && len(Curfn.Enter) > 0 {
 		s := fmt.Sprintf("enter %v", Curfn.Sym())
 		ir.DumpList(s, Curfn.Enter)
 	}
@@ -122,7 +122,7 @@ func walkstmt(n ir.Node) ir.Node {
 
 	setlineno(n)
 
-	walkstmtlist(n.Init().Slice())
+	walkstmtlist(n.Init())
 
 	switch n.Op() {
 	default:
@@ -164,17 +164,17 @@ func walkstmt(n ir.Node) ir.Node {
 		if n.Op() == ir.ONAME {
 			// copy rewrote to a statement list and a temp for the length.
 			// Throw away the temp to avoid plain values as statements.
-			n = ir.NewBlockStmt(n.Pos(), init.Slice())
+			n = ir.NewBlockStmt(n.Pos(), init)
 			init.Set(nil)
 		}
-		if init.Len() > 0 {
+		if len(init) > 0 {
 			switch n.Op() {
 			case ir.OAS, ir.OAS2, ir.OBLOCK:
-				n.PtrInit().Prepend(init.Slice()...)
+				n.PtrInit().Prepend(init...)
 
 			default:
 				init.Append(n)
-				n = ir.NewBlockStmt(n.Pos(), init.Slice())
+				n = ir.NewBlockStmt(n.Pos(), init)
 			}
 		}
 		return n
@@ -191,7 +191,7 @@ func walkstmt(n ir.Node) ir.Node {
 
 		n.X = walkexpr(n.X, &init)
 		call := walkexpr(mkcall1(chanfn("chanrecv1", 2, n.X.Type()), nil, &init, n.X, nodnil()), &init)
-		return initExpr(init.Slice(), call)
+		return initExpr(init, call)
 
 	case ir.OBREAK,
 		ir.OCONTINUE,
@@ -221,7 +221,7 @@ func walkstmt(n ir.Node) ir.Node {
 
 	case ir.OBLOCK:
 		n := n.(*ir.BlockStmt)
-		walkstmtlist(n.List.Slice())
+		walkstmtlist(n.List)
 		return n
 
 	case ir.OCASE:
@@ -254,7 +254,7 @@ func walkstmt(n ir.Node) ir.Node {
 
 		case ir.ODELETE:
 			call := call.(*ir.CallExpr)
-			if mapfast(call.Args.First().Type()) == mapslow {
+			if mapfast(call.Args[0].Type()) == mapslow {
 				n.Call = wrapCall(call, &init)
 			} else {
 				n.Call = walkexpr(call, &init)
@@ -266,7 +266,7 @@ func walkstmt(n ir.Node) ir.Node {
 
 		case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
 			call := call.(*ir.CallExpr)
-			if call.Body.Len() > 0 {
+			if len(call.Body) > 0 {
 				n.Call = wrapCall(call, &init)
 			} else {
 				n.Call = walkexpr(call, &init)
@@ -275,43 +275,43 @@ func walkstmt(n ir.Node) ir.Node {
 		default:
 			n.Call = walkexpr(call, &init)
 		}
-		if init.Len() > 0 {
+		if len(init) > 0 {
 			init.Append(n)
-			return ir.NewBlockStmt(n.Pos(), init.Slice())
+			return ir.NewBlockStmt(n.Pos(), init)
 		}
 		return n
 
 	case ir.OFOR, ir.OFORUNTIL:
 		n := n.(*ir.ForStmt)
 		if n.Cond != nil {
-			walkstmtlist(n.Cond.Init().Slice())
+			walkstmtlist(n.Cond.Init())
 			init := n.Cond.Init()
 			n.Cond.PtrInit().Set(nil)
 			n.Cond = walkexpr(n.Cond, &init)
-			n.Cond = initExpr(init.Slice(), n.Cond)
+			n.Cond = initExpr(init, n.Cond)
 		}
 
 		n.Post = walkstmt(n.Post)
 		if n.Op() == ir.OFORUNTIL {
-			walkstmtlist(n.Late.Slice())
+			walkstmtlist(n.Late)
 		}
-		walkstmtlist(n.Body.Slice())
+		walkstmtlist(n.Body)
 		return n
 
 	case ir.OIF:
 		n := n.(*ir.IfStmt)
 		n.Cond = walkexpr(n.Cond, n.PtrInit())
-		walkstmtlist(n.Body.Slice())
-		walkstmtlist(n.Else.Slice())
+		walkstmtlist(n.Body)
+		walkstmtlist(n.Else)
 		return n
 
 	case ir.ORETURN:
 		n := n.(*ir.ReturnStmt)
 		Curfn.NumReturns++
-		if n.Results.Len() == 0 {
+		if len(n.Results) == 0 {
 			return n
 		}
-		if (hasNamedResults(Curfn) && n.Results.Len() > 1) || paramoutheap(Curfn) {
+		if (hasNamedResults(Curfn) && len(n.Results) > 1) || paramoutheap(Curfn) {
 			// assign to the function out parameters,
 			// so that ascompatee can fix up conflicts
 			var rl []ir.Node
@@ -330,23 +330,23 @@ func walkstmt(n ir.Node) ir.Node {
 				}
 			}
 
-			if got, want := n.Results.Len(), len(rl); got != want {
+			if got, want := len(n.Results), len(rl); got != want {
 				// order should have rewritten multi-value function calls
 				// with explicit OAS2FUNC nodes.
 				base.Fatalf("expected %v return arguments, have %v", want, got)
 			}
 
 			// move function calls out, to make ascompatee's job easier.
-			walkexprlistsafe(n.Results.Slice(), n.PtrInit())
+			walkexprlistsafe(n.Results, n.PtrInit())
 
-			n.Results.Set(ascompatee(n.Op(), rl, n.Results.Slice(), n.PtrInit()))
+			n.Results.Set(ascompatee(n.Op(), rl, n.Results, n.PtrInit()))
 			return n
 		}
-		walkexprlist(n.Results.Slice(), n.PtrInit())
+		walkexprlist(n.Results, n.PtrInit())
 
 		// For each return parameter (lhs), assign the corresponding result (rhs).
 		lhs := Curfn.Type().Results()
-		rhs := n.Results.Slice()
+		rhs := n.Results
 		res := make([]ir.Node, lhs.NumFields())
 		for i, nl := range lhs.FieldSlice() {
 			nname := ir.AsNode(nl.Nname)
@@ -480,9 +480,9 @@ func walkexpr(n ir.Node, init *ir.Nodes) ir.Node {
 		base.Fatalf("walkexpr init == &n->ninit")
 	}
 
-	if n.Init().Len() != 0 {
-		walkstmtlist(n.Init().Slice())
-		init.AppendNodes(n.PtrInit())
+	if len(n.Init()) != 0 {
+		walkstmtlist(n.Init())
+		init.Append(n.PtrInit().Take()...)
 	}
 
 	lno := setlineno(n)
@@ -595,7 +595,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			n.Ntype.(*ir.AddrExpr).Alloc = typename(n.X.Type())
 		}
 		if !n.Type().IsInterface() && !n.X.Type().IsEmptyInterface() {
-			n.Itab.Set1(itabname(n.Type(), n.X.Type()))
+			n.Itab = []ir.Node{itabname(n.Type(), n.X.Type())}
 		}
 		return n
 
@@ -643,7 +643,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		var ll ir.Nodes
 
 		n.Y = walkexpr(n.Y, &ll)
-		n.Y = initExpr(ll.Slice(), n.Y)
+		n.Y = initExpr(ll, n.Y)
 		return n
 
 	case ir.OPRINT, ir.OPRINTN:
@@ -673,7 +673,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 			// Prepend captured variables to argument list.
 			clo := n.X.(*ir.ClosureExpr)
-			n.Args.Prepend(clo.Func.ClosureEnter.Slice()...)
+			n.Args.Prepend(clo.Func.ClosureEnter...)
 			clo.Func.ClosureEnter.Set(nil)
 
 			// Replace OCLOSURE with ONAME/PFUNC.
@@ -692,7 +692,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return n
 
 	case ir.OAS, ir.OASOP:
-		init.AppendNodes(n.PtrInit())
+		init.Append(n.PtrInit().Take()...)
 
 		var left, right ir.Node
 		switch n.Op() {
@@ -710,15 +710,15 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		if left.Op() == ir.OINDEXMAP && right.Op() == ir.OAPPEND {
 			left := left.(*ir.IndexExpr)
 			mapAppend = right.(*ir.CallExpr)
-			if !samesafeexpr(left, mapAppend.Args.First()) {
-				base.Fatalf("not same expressions: %v != %v", left, mapAppend.Args.First())
+			if !samesafeexpr(left, mapAppend.Args[0]) {
+				base.Fatalf("not same expressions: %v != %v", left, mapAppend.Args[0])
 			}
 		}
 
 		left = walkexpr(left, init)
 		left = safeexpr(left, init)
 		if mapAppend != nil {
-			mapAppend.Args.SetFirst(left)
+			mapAppend.Args[0] = left
 		}
 
 		if n.Op() == ir.OASOP {
@@ -791,22 +791,22 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 	case ir.OAS2:
 		n := n.(*ir.AssignListStmt)
-		init.AppendNodes(n.PtrInit())
-		walkexprlistsafe(n.Lhs.Slice(), init)
-		walkexprlistsafe(n.Rhs.Slice(), init)
-		return liststmt(ascompatee(ir.OAS, n.Lhs.Slice(), n.Rhs.Slice(), init))
+		init.Append(n.PtrInit().Take()...)
+		walkexprlistsafe(n.Lhs, init)
+		walkexprlistsafe(n.Rhs, init)
+		return liststmt(ascompatee(ir.OAS, n.Lhs, n.Rhs, init))
 
 	// a,b,... = fn()
 	case ir.OAS2FUNC:
 		n := n.(*ir.AssignListStmt)
-		init.AppendNodes(n.PtrInit())
+		init.Append(n.PtrInit().Take()...)
 
-		r := n.Rhs.First()
-		walkexprlistsafe(n.Lhs.Slice(), init)
+		r := n.Rhs[0]
+		walkexprlistsafe(n.Lhs, init)
 		r = walkexpr(r, init)
 
 		if IsIntrinsicCall(r.(*ir.CallExpr)) {
-			n.Rhs.Set1(r)
+			n.Rhs = []ir.Node{r}
 			return n
 		}
 		init.Append(r)
@@ -818,29 +818,29 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 	// order.stmt made sure x is addressable or blank.
 	case ir.OAS2RECV:
 		n := n.(*ir.AssignListStmt)
-		init.AppendNodes(n.PtrInit())
+		init.Append(n.PtrInit().Take()...)
 
-		r := n.Rhs.First().(*ir.UnaryExpr) // recv
-		walkexprlistsafe(n.Lhs.Slice(), init)
+		r := n.Rhs[0].(*ir.UnaryExpr) // recv
+		walkexprlistsafe(n.Lhs, init)
 		r.X = walkexpr(r.X, init)
 		var n1 ir.Node
-		if ir.IsBlank(n.Lhs.First()) {
+		if ir.IsBlank(n.Lhs[0]) {
 			n1 = nodnil()
 		} else {
-			n1 = nodAddr(n.Lhs.First())
+			n1 = nodAddr(n.Lhs[0])
 		}
 		fn := chanfn("chanrecv2", 2, r.X.Type())
-		ok := n.Lhs.Second()
+		ok := n.Lhs[1]
 		call := mkcall1(fn, types.Types[types.TBOOL], init, r.X, n1)
 		return typecheck(ir.NewAssignStmt(base.Pos, ok, call), ctxStmt)
 
 	// a,b = m[i]
 	case ir.OAS2MAPR:
 		n := n.(*ir.AssignListStmt)
-		init.AppendNodes(n.PtrInit())
+		init.Append(n.PtrInit().Take()...)
 
-		r := n.Rhs.First().(*ir.IndexExpr)
-		walkexprlistsafe(n.Lhs.Slice(), init)
+		r := n.Rhs[0].(*ir.IndexExpr)
+		walkexprlistsafe(n.Lhs, init)
 		r.X = walkexpr(r.X, init)
 		r.Index = walkexpr(r.Index, init)
 		t := r.X.Type()
@@ -861,7 +861,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		// to:
 		//   var,b = mapaccess2*(t, m, i)
 		//   a = *var
-		a := n.Lhs.First()
+		a := n.Lhs[0]
 
 		var call *ir.CallExpr
 		if w := t.Elem().Width; w <= zeroValSize {
@@ -876,10 +876,10 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		// mapaccess2* returns a typed bool, but due to spec changes,
 		// the boolean result of i.(T) is now untyped so we make it the
 		// same type as the variable on the lhs.
-		if ok := n.Lhs.Second(); !ir.IsBlank(ok) && ok.Type().IsBoolean() {
+		if ok := n.Lhs[1]; !ir.IsBlank(ok) && ok.Type().IsBoolean() {
 			call.Type().Field(1).Type = ok.Type()
 		}
-		n.Rhs.Set1(call)
+		n.Rhs = []ir.Node{call}
 		n.SetOp(ir.OAS2FUNC)
 
 		// don't generate a = *var if a is _
@@ -891,7 +891,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		var_.SetTypecheck(1)
 		var_.MarkNonNil() // mapaccess always returns a non-nil pointer
 
-		n.Lhs.SetFirst(var_)
+		n.Lhs[0] = var_
 		init.Append(walkexpr(n, init))
 
 		as := ir.NewAssignStmt(base.Pos, a, ir.NewStarExpr(base.Pos, var_))
@@ -899,9 +899,9 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 	case ir.ODELETE:
 		n := n.(*ir.CallExpr)
-		init.AppendNodes(n.PtrInit())
-		map_ := n.Args.First()
-		key := n.Args.Second()
+		init.Append(n.PtrInit().Take()...)
+		map_ := n.Args[0]
+		key := n.Args[1]
 		map_ = walkexpr(map_, init)
 		key = walkexpr(key, init)
 
@@ -915,8 +915,8 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 	case ir.OAS2DOTTYPE:
 		n := n.(*ir.AssignListStmt)
-		walkexprlistsafe(n.Lhs.Slice(), init)
-		(&n.Rhs).SetIndex(0, walkexpr(n.Rhs.First(), init))
+		walkexprlistsafe(n.Lhs, init)
+		n.Rhs[0] = walkexpr(n.Rhs[0], init)
 		return n
 
 	case ir.OCONVIFACE:
@@ -1013,7 +1013,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 			// Get the type out of the itab.
 			nif := ir.NewIfStmt(base.Pos, typecheck(ir.NewBinaryExpr(base.Pos, ir.ONE, tmp, nodnil()), ctxExpr), nil, nil)
-			nif.Body.Set1(ir.NewAssignStmt(base.Pos, tmp, itabType(tmp)))
+			nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, tmp, itabType(tmp))}
 			init.Append(nif)
 
 			// Build the result.
@@ -1034,7 +1034,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			fn = substArgTypes(fn, fromType)
 			dowidth(fn.Type())
 			call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
-			call.Args.Set1(n.X)
+			call.Args = []ir.Node{n.X}
 			e := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), safeexpr(walkexpr(typecheck(call, ctxExpr), init), init))
 			e.SetType(toType)
 			e.SetTypecheck(1)
@@ -1069,7 +1069,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		fn = substArgTypes(fn, fromType, toType)
 		dowidth(fn.Type())
 		call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
-		call.Args.Set2(tab, v)
+		call.Args = []ir.Node{tab, v}
 		return walkexpr(typecheck(call, ctxExpr), init)
 
 	case ir.OCONV, ir.OCONVNOP:
@@ -1245,8 +1245,8 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 	case ir.OSLICEHEADER:
 		n := n.(*ir.SliceHeaderExpr)
 		n.Ptr = walkexpr(n.Ptr, init)
-		n.LenCap.SetFirst(walkexpr(n.LenCap.First(), init))
-		n.LenCap.SetSecond(walkexpr(n.LenCap.Second(), init))
+		n.LenCap[0] = walkexpr(n.LenCap[0], init)
+		n.LenCap[1] = walkexpr(n.LenCap[1], init)
 		return n
 
 	case ir.OSLICE, ir.OSLICEARR, ir.OSLICESTR, ir.OSLICE3, ir.OSLICE3ARR:
@@ -1472,7 +1472,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			// }
 			nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGT, conv(l, types.Types[types.TUINT64]), nodintconst(i)), nil, nil)
 			niflen := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OLT, l, nodintconst(0)), nil, nil)
-			niflen.Body.Set1(mkcall("panicmakeslicelen", nil, init))
+			niflen.Body = []ir.Node{mkcall("panicmakeslicelen", nil, init)}
 			nif.Body.Append(niflen, mkcall("panicmakeslicecap", nil, init))
 			init.Append(typecheck(nif, ctxStmt))
 
@@ -1509,7 +1509,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		fn := syslook(fnname)
 		m.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), conv(len, argtype), conv(cap, argtype))
 		m.Ptr.MarkNonNil()
-		m.LenCap.Set2(conv(len, types.Types[types.TINT]), conv(cap, types.Types[types.TINT]))
+		m.LenCap = []ir.Node{conv(len, types.Types[types.TINT]), conv(cap, types.Types[types.TINT])}
 		return walkexpr(typecheck(m, ctxExpr), init)
 
 	case ir.OMAKESLICECOPY:
@@ -1541,7 +1541,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			sh := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
 			sh.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, size, nodnil(), nodbool(false))
 			sh.Ptr.MarkNonNil()
-			sh.LenCap.Set2(length, length)
+			sh.LenCap = []ir.Node{length, length}
 			sh.SetType(t)
 
 			s := temp(t)
@@ -1563,7 +1563,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		s := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
 		s.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), length, copylen, conv(copyptr, types.Types[types.TUNSAFEPTR]))
 		s.Ptr.MarkNonNil()
-		s.LenCap.Set2(length, length)
+		s.LenCap = []ir.Node{length, length}
 		s.SetType(t)
 		return walkexpr(typecheck(s, ctxExpr), init)
 
@@ -1856,12 +1856,12 @@ func fncall(l ir.Node, rt *types.Type) bool {
 // an expression list. called in
 //	expr-list = func()
 func ascompatet(nl ir.Nodes, nr *types.Type) []ir.Node {
-	if nl.Len() != nr.NumFields() {
-		base.Fatalf("ascompatet: assignment count mismatch: %d = %d", nl.Len(), nr.NumFields())
+	if len(nl) != nr.NumFields() {
+		base.Fatalf("ascompatet: assignment count mismatch: %d = %d", len(nl), nr.NumFields())
 	}
 
 	var nn, mm ir.Nodes
-	for i, l := range nl.Slice() {
+	for i, l := range nl {
 		if ir.IsBlank(l) {
 			continue
 		}
@@ -1891,7 +1891,7 @@ func ascompatet(nl ir.Nodes, nr *types.Type) []ir.Node {
 
 		nn.Append(a)
 	}
-	return append(nn.Slice(), mm.Slice()...)
+	return append(nn, mm...)
 }
 
 // package all the arguments that match a ... T parameter into a []T.
@@ -1925,7 +1925,7 @@ func fixVariadicCall(call *ir.CallExpr) {
 	vi := fntype.NumParams() - 1
 	vt := fntype.Params().Field(vi).Type
 
-	args := call.Args.Slice()
+	args := call.Args
 	extra := args[vi:]
 	slice := mkdotargslice(vt, extra)
 	for i := range extra {
@@ -1937,12 +1937,12 @@ func fixVariadicCall(call *ir.CallExpr) {
 }
 
 func walkCall(n *ir.CallExpr, init *ir.Nodes) {
-	if n.Rargs.Len() != 0 {
+	if len(n.Rargs) != 0 {
 		return // already walked
 	}
 
 	params := n.X.Type().Params()
-	args := n.Args.Slice()
+	args := n.Args
 
 	n.X = walkexpr(n.X, init)
 	walkexprlist(args, init)
@@ -1992,11 +1992,11 @@ func walkCall(n *ir.CallExpr, init *ir.Nodes) {
 // generate code for print
 func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 	// Hoist all the argument evaluation up before the lock.
-	walkexprlistcheap(nn.Args.Slice(), init)
+	walkexprlistcheap(nn.Args, init)
 
 	// For println, add " " between elements and "\n" at the end.
 	if nn.Op() == ir.OPRINTN {
-		s := nn.Args.Slice()
+		s := nn.Args
 		t := make([]ir.Node, 0, len(s)*2)
 		for i, n := range s {
 			if i != 0 {
@@ -2009,7 +2009,7 @@ func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 	}
 
 	// Collapse runs of constant strings.
-	s := nn.Args.Slice()
+	s := nn.Args
 	t := make([]ir.Node, 0, len(s))
 	for i := 0; i < len(s); {
 		var strs []string
@@ -2028,7 +2028,7 @@ func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 	nn.Args.Set(t)
 
 	calls := []ir.Node{mkcall("printlock", nil, init)}
-	for i, n := range nn.Args.Slice() {
+	for i, n := range nn.Args {
 		if n.Op() == ir.OLITERAL {
 			if n.Type() == types.UntypedRune {
 				n = defaultlit(n, types.RuneType)
@@ -2047,7 +2047,7 @@ func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 			n = defaultlit(n, types.Types[types.TINT64])
 		}
 		n = defaultlit(n, nil)
-		nn.Args.SetIndex(i, n)
+		nn.Args[i] = n
 		if n.Type() == nil || n.Type().Kind() == types.TFORW {
 			continue
 		}
@@ -2264,7 +2264,7 @@ func reorder3(all []*ir.AssignStmt) []ir.Node {
 		all[i].Y = reorder3save(all[i].Y, all, i, &early)
 	}
 
-	early = append(mapinit.Slice(), early...)
+	early = append(mapinit, early...)
 	for _, as := range all {
 		early = append(early, as)
 	}
@@ -2736,7 +2736,7 @@ func writebarrierfn(name string, l *types.Type, r *types.Type) ir.Node {
 }
 
 func addstr(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
-	c := n.List.Len()
+	c := len(n.List)
 
 	if c < 2 {
 		base.Fatalf("addstr count %d too small", c)
@@ -2745,7 +2745,7 @@ func addstr(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
 	buf := nodnil()
 	if n.Esc() == EscNone {
 		sz := int64(0)
-		for _, n1 := range n.List.Slice() {
+		for _, n1 := range n.List {
 			if n1.Op() == ir.OLITERAL {
 				sz += int64(len(ir.StringVal(n1)))
 			}
@@ -2761,7 +2761,7 @@ func addstr(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
 
 	// build list of string arguments
 	args := []ir.Node{buf}
-	for _, n2 := range n.List.Slice() {
+	for _, n2 := range n.List {
 		args = append(args, conv(n2, types.Types[types.TSTRING]))
 	}
 
@@ -2793,12 +2793,12 @@ func addstr(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
 }
 
 func walkAppendArgs(n *ir.CallExpr, init *ir.Nodes) {
-	walkexprlistsafe(n.Args.Slice(), init)
+	walkexprlistsafe(n.Args, init)
 
 	// walkexprlistsafe will leave OINDEX (s[n]) alone if both s
 	// and n are name or literal, but those may index the slice we're
 	// modifying here. Fix explicitly.
-	ls := n.Args.Slice()
+	ls := n.Args
 	for i1, n1 := range ls {
 		ls[i1] = cheapexpr(n1, init)
 	}
@@ -2821,10 +2821,10 @@ func walkAppendArgs(n *ir.CallExpr, init *ir.Nodes) {
 func appendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	walkAppendArgs(n, init)
 
-	l1 := n.Args.First()
-	l2 := n.Args.Second()
+	l1 := n.Args[0]
+	l2 := n.Args[1]
 	l2 = cheapexpr(l2, init)
-	n.Args.SetSecond(l2)
+	n.Args[1] = l2
 
 	var nodes ir.Nodes
 
@@ -2849,7 +2849,7 @@ func appendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	fn = substArgTypes(fn, elemtype, elemtype)
 
 	// s = growslice(T, s, n)
-	nif.Body.Set1(ir.NewAssignStmt(base.Pos, s, mkcall1(fn, s.Type(), nif.PtrInit(), typename(elemtype), s, nn)))
+	nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, s, mkcall1(fn, s.Type(), nif.PtrInit(), typename(elemtype), s, nn))}
 	nodes.Append(nif)
 
 	// s = s[:n]
@@ -2903,7 +2903,7 @@ func appendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 		fn = substArgTypes(fn, elemtype, elemtype)
 		ncopy = mkcall1(fn, nil, &nodes, addr, sptr, nwid)
 	}
-	ln := append(nodes.Slice(), ncopy)
+	ln := append(nodes, ncopy)
 
 	typecheckslice(ln, ctxStmt)
 	walkstmtlist(ln)
@@ -2926,11 +2926,11 @@ func isAppendOfMake(n ir.Node) bool {
 		return false
 	}
 	call := n.(*ir.CallExpr)
-	if !call.IsDDD || call.Args.Len() != 2 || call.Args.Second().Op() != ir.OMAKESLICE {
+	if !call.IsDDD || len(call.Args) != 2 || call.Args[1].Op() != ir.OMAKESLICE {
 		return false
 	}
 
-	mk := call.Args.Second().(*ir.MakeExpr)
+	mk := call.Args[1].(*ir.MakeExpr)
 	if mk.Cap != nil {
 		return false
 	}
@@ -2980,14 +2980,14 @@ func extendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	// isAppendOfMake made sure all possible positive values of l2 fit into an uint.
 	// The case of l2 overflow when converting from e.g. uint to int is handled by an explicit
 	// check of l2 < 0 at runtime which is generated below.
-	l2 := conv(n.Args.Second().(*ir.MakeExpr).Len, types.Types[types.TINT])
+	l2 := conv(n.Args[1].(*ir.MakeExpr).Len, types.Types[types.TINT])
 	l2 = typecheck(l2, ctxExpr)
-	n.Args.SetSecond(l2) // walkAppendArgs expects l2 in n.List.Second().
+	n.Args[1] = l2 // walkAppendArgs expects l2 in n.List.Second().
 
 	walkAppendArgs(n, init)
 
-	l1 := n.Args.First()
-	l2 = n.Args.Second() // re-read l2, as it may have been updated by walkAppendArgs
+	l1 := n.Args[0]
+	l2 = n.Args[1] // re-read l2, as it may have been updated by walkAppendArgs
 
 	var nodes []ir.Node
 
@@ -2996,7 +2996,7 @@ func extendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	nifneg.Likely = true
 
 	// else panicmakeslicelen()
-	nifneg.Else.Set1(mkcall("panicmakeslicelen", nil, init))
+	nifneg.Else = []ir.Node{mkcall("panicmakeslicelen", nil, init)}
 	nodes = append(nodes, nifneg)
 
 	// s := l1
@@ -3019,7 +3019,7 @@ func extendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	fn = substArgTypes(fn, elemtype, elemtype)
 
 	// s = growslice(T, s, n)
-	nif.Body.Set1(ir.NewAssignStmt(base.Pos, s, mkcall1(fn, s.Type(), nif.PtrInit(), typename(elemtype), s, nn)))
+	nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, s, mkcall1(fn, s.Type(), nif.PtrInit(), typename(elemtype), s, nn))}
 	nodes = append(nodes, nif)
 
 	// s = s[:n]
@@ -3063,7 +3063,7 @@ func extendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 		nifclr.Body = clr
 		nodes = append(nodes, nifclr)
 	} else {
-		nodes = append(nodes, clr.Slice()...)
+		nodes = append(nodes, clr...)
 	}
 
 	typecheckslice(nodes, ctxStmt)
@@ -3094,13 +3094,13 @@ func extendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 //   }
 //   s
 func walkappend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
-	if !samesafeexpr(dst, n.Args.First()) {
-		n.Args.SetFirst(safeexpr(n.Args.First(), init))
-		n.Args.SetFirst(walkexpr(n.Args.First(), init))
+	if !samesafeexpr(dst, n.Args[0]) {
+		n.Args[0] = safeexpr(n.Args[0], init)
+		n.Args[0] = walkexpr(n.Args[0], init)
 	}
-	walkexprlistsafe(n.Args.Slice()[1:], init)
+	walkexprlistsafe(n.Args[1:], init)
 
-	nsrc := n.Args.First()
+	nsrc := n.Args[0]
 
 	// walkexprlistsafe will leave OINDEX (s[n]) alone if both s
 	// and n are name or literal, but those may index the slice we're
@@ -3108,7 +3108,7 @@ func walkappend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
 	// Using cheapexpr also makes sure that the evaluation
 	// of all arguments (and especially any panics) happen
 	// before we begin to modify the slice in a visible way.
-	ls := n.Args.Slice()[1:]
+	ls := n.Args[1:]
 	for i, n := range ls {
 		n = cheapexpr(n, init)
 		if !types.Identical(n.Type(), nsrc.Type().Elem()) {
@@ -3118,7 +3118,7 @@ func walkappend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
 		ls[i] = n
 	}
 
-	argc := n.Args.Len() - 1
+	argc := len(n.Args) - 1
 	if argc < 1 {
 		return nsrc
 	}
@@ -3141,8 +3141,8 @@ func walkappend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
 	fn := syslook("growslice") //   growslice(<type>, old []T, mincap int) (ret []T)
 	fn = substArgTypes(fn, ns.Type().Elem(), ns.Type().Elem())
 
-	nif.Body.Set1(ir.NewAssignStmt(base.Pos, ns, mkcall1(fn, ns.Type(), nif.PtrInit(), typename(ns.Type().Elem()), ns,
-		ir.NewBinaryExpr(base.Pos, ir.OADD, ir.NewUnaryExpr(base.Pos, ir.OLEN, ns), na))))
+	nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, ns, mkcall1(fn, ns.Type(), nif.PtrInit(), typename(ns.Type().Elem()), ns,
+		ir.NewBinaryExpr(base.Pos, ir.OADD, ir.NewUnaryExpr(base.Pos, ir.OLEN, ns), na)))}
 
 	l = append(l, nif)
 
@@ -3154,7 +3154,7 @@ func walkappend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
 	slice.SetBounded(true)
 	l = append(l, ir.NewAssignStmt(base.Pos, ns, slice)) // s = s[:n+argc]
 
-	ls = n.Args.Slice()[1:]
+	ls = n.Args[1:]
 	for i, n := range ls {
 		ix := ir.NewIndexExpr(base.Pos, ns, nn) // s[n] ...
 		ix.SetBounded(true)
@@ -3960,32 +3960,32 @@ var wrapCall_prgen int
 // The result of wrapCall MUST be assigned back to n, e.g.
 // 	n.Left = wrapCall(n.Left, init)
 func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
-	if n.Init().Len() != 0 {
-		walkstmtlist(n.Init().Slice())
-		init.AppendNodes(n.PtrInit())
+	if len(n.Init()) != 0 {
+		walkstmtlist(n.Init())
+		init.Append(n.PtrInit().Take()...)
 	}
 
 	isBuiltinCall := n.Op() != ir.OCALLFUNC && n.Op() != ir.OCALLMETH && n.Op() != ir.OCALLINTER
 
 	// Turn f(a, b, []T{c, d, e}...) back into f(a, b, c, d, e).
 	if !isBuiltinCall && n.IsDDD {
-		last := n.Args.Len() - 1
-		if va := n.Args.Index(last); va.Op() == ir.OSLICELIT {
+		last := len(n.Args) - 1
+		if va := n.Args[last]; va.Op() == ir.OSLICELIT {
 			va := va.(*ir.CompLitExpr)
-			n.Args.Set(append(n.Args.Slice()[:last], va.List.Slice()...))
+			n.Args.Set(append(n.Args[:last], va.List...))
 			n.IsDDD = false
 		}
 	}
 
 	// origArgs keeps track of what argument is uintptr-unsafe/unsafe-uintptr conversion.
-	origArgs := make([]ir.Node, n.Args.Len())
+	origArgs := make([]ir.Node, len(n.Args))
 	var funcArgs []*ir.Field
-	for i, arg := range n.Args.Slice() {
+	for i, arg := range n.Args {
 		s := lookupN("a", i)
 		if !isBuiltinCall && arg.Op() == ir.OCONVNOP && arg.Type().IsUintptr() && arg.(*ir.ConvExpr).X.Type().IsUnsafePtr() {
 			origArgs[i] = arg
 			arg = arg.(*ir.ConvExpr).X
-			n.Args.SetIndex(i, arg)
+			n.Args[i] = arg
 		}
 		funcArgs = append(funcArgs, symfield(s, arg.Type()))
 	}
@@ -4007,15 +4007,15 @@ func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 		call.SetOp(ir.OCALL)
 		call.IsDDD = n.IsDDD
 	}
-	fn.Body.Set1(call)
+	fn.Body = []ir.Node{call}
 
 	funcbody()
 
 	typecheckFunc(fn)
-	typecheckslice(fn.Body.Slice(), ctxStmt)
+	typecheckslice(fn.Body, ctxStmt)
 	Target.Decls = append(Target.Decls, fn)
 
-	call = ir.NewCallExpr(base.Pos, ir.OCALL, fn.Nname, n.Args.Slice())
+	call = ir.NewCallExpr(base.Pos, ir.OCALL, fn.Nname, n.Args)
 	return walkexpr(typecheck(call, ctxStmt), init)
 }
 
diff --git a/src/cmd/compile/internal/ir/dump.go b/src/cmd/compile/internal/ir/dump.go
index 9d6042f78a..fc995cee62 100644
--- a/src/cmd/compile/internal/ir/dump.go
+++ b/src/cmd/compile/internal/ir/dump.go
@@ -222,7 +222,7 @@ func (p *dumper) dump(x reflect.Value, depth int) {
 					omitted = true
 					continue // exclude zero-valued fields
 				}
-				if n, ok := x.Interface().(Nodes); ok && n.Len() == 0 {
+				if n, ok := x.Interface().(Nodes); ok && len(n) == 0 {
 					omitted = true
 					continue // exclude empty Nodes slices
 				}
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 63ccaa6550..39a408fdc7 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -624,16 +624,16 @@ func (n *SliceExpr) SetOp(op Op) {
 // SliceBounds returns n's slice bounds: low, high, and max in expr[low:high:max].
 // n must be a slice expression. max is nil if n is a simple slice expression.
 func (n *SliceExpr) SliceBounds() (low, high, max Node) {
-	if n.List.Len() == 0 {
+	if len(n.List) == 0 {
 		return nil, nil, nil
 	}
 
 	switch n.Op() {
 	case OSLICE, OSLICEARR, OSLICESTR:
-		s := n.List.Slice()
+		s := n.List
 		return s[0], s[1], nil
 	case OSLICE3, OSLICE3ARR:
-		s := n.List.Slice()
+		s := n.List
 		return s[0], s[1], s[2]
 	}
 	base.Fatalf("SliceBounds op %v: %v", n.Op(), n)
@@ -648,24 +648,24 @@ func (n *SliceExpr) SetSliceBounds(low, high, max Node) {
 		if max != nil {
 			base.Fatalf("SetSliceBounds %v given three bounds", n.Op())
 		}
-		s := n.List.Slice()
+		s := n.List
 		if s == nil {
 			if low == nil && high == nil {
 				return
 			}
-			n.List.Set2(low, high)
+			n.List = []Node{low, high}
 			return
 		}
 		s[0] = low
 		s[1] = high
 		return
 	case OSLICE3, OSLICE3ARR:
-		s := n.List.Slice()
+		s := n.List
 		if s == nil {
 			if low == nil && high == nil && max == nil {
 				return
 			}
-			n.List.Set3(low, high, max)
+			n.List = []Node{low, high, max}
 			return
 		}
 		s[0] = low
@@ -701,7 +701,7 @@ func NewSliceHeaderExpr(pos src.XPos, typ *types.Type, ptr, len, cap Node) *Slic
 	n.pos = pos
 	n.op = OSLICEHEADER
 	n.typ = typ
-	n.LenCap.Set2(len, cap)
+	n.LenCap = []Node{len, cap}
 	return n
 }
 
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 49c4ac9a8d..2682908539 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -313,10 +313,10 @@ func stmtFmt(n Node, s fmt.State) {
 	// block starting with the init statements.
 
 	// if we can just say "for" n->ninit; ... then do so
-	simpleinit := n.Init().Len() == 1 && n.Init().First().Init().Len() == 0 && StmtWithInit(n.Op())
+	simpleinit := len(n.Init()) == 1 && len(n.Init()[0].Init()) == 0 && StmtWithInit(n.Op())
 
 	// otherwise, print the inits as separate statements
-	complexinit := n.Init().Len() != 0 && !simpleinit && exportFormat
+	complexinit := len(n.Init()) != 0 && !simpleinit && exportFormat
 
 	// but if it was for if/for/switch, put in an extra surrounding block to limit the scope
 	extrablock := complexinit && StmtWithInit(n.Op())
@@ -368,7 +368,7 @@ func stmtFmt(n Node, s fmt.State) {
 
 	case OBLOCK:
 		n := n.(*BlockStmt)
-		if n.List.Len() != 0 {
+		if len(n.List) != 0 {
 			fmt.Fprintf(s, "%v", n.List)
 		}
 
@@ -395,11 +395,11 @@ func stmtFmt(n Node, s fmt.State) {
 	case OIF:
 		n := n.(*IfStmt)
 		if simpleinit {
-			fmt.Fprintf(s, "if %v; %v { %v }", n.Init().First(), n.Cond, n.Body)
+			fmt.Fprintf(s, "if %v; %v { %v }", n.Init()[0], n.Cond, n.Body)
 		} else {
 			fmt.Fprintf(s, "if %v { %v }", n.Cond, n.Body)
 		}
-		if n.Else.Len() != 0 {
+		if len(n.Else) != 0 {
 			fmt.Fprintf(s, " else { %v }", n.Else)
 		}
 
@@ -416,7 +416,7 @@ func stmtFmt(n Node, s fmt.State) {
 
 		fmt.Fprint(s, opname)
 		if simpleinit {
-			fmt.Fprintf(s, " %v;", n.Init().First())
+			fmt.Fprintf(s, " %v;", n.Init()[0])
 		} else if n.Post != nil {
 			fmt.Fprint(s, " ;")
 		}
@@ -431,7 +431,7 @@ func stmtFmt(n Node, s fmt.State) {
 			fmt.Fprint(s, ";")
 		}
 
-		if n.Op() == OFORUNTIL && n.Late.Len() != 0 {
+		if n.Op() == OFORUNTIL && len(n.Late) != 0 {
 			fmt.Fprintf(s, "; %v", n.Late)
 		}
 
@@ -444,7 +444,7 @@ func stmtFmt(n Node, s fmt.State) {
 			break
 		}
 
-		if n.Vars.Len() == 0 {
+		if len(n.Vars) == 0 {
 			fmt.Fprintf(s, "for range %v { %v }", n.X, n.Body)
 			break
 		}
@@ -467,7 +467,7 @@ func stmtFmt(n Node, s fmt.State) {
 		}
 		fmt.Fprintf(s, "switch")
 		if simpleinit {
-			fmt.Fprintf(s, " %v;", n.Init().First())
+			fmt.Fprintf(s, " %v;", n.Init()[0])
 		}
 		if n.Tag != nil {
 			fmt.Fprintf(s, " %v ", n.Tag)
@@ -476,7 +476,7 @@ func stmtFmt(n Node, s fmt.State) {
 
 	case OCASE:
 		n := n.(*CaseStmt)
-		if n.List.Len() != 0 {
+		if len(n.List) != 0 {
 			fmt.Fprintf(s, "case %.v", n.List)
 		} else {
 			fmt.Fprint(s, "default")
@@ -704,7 +704,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 				return
 			}
 			if n.Ntype != nil {
-				fmt.Fprintf(s, "%v{%s}", n.Ntype, ellipsisIf(n.List.Len() != 0))
+				fmt.Fprintf(s, "%v{%s}", n.Ntype, ellipsisIf(len(n.List) != 0))
 				return
 			}
 
@@ -720,7 +720,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 	case OSTRUCTLIT, OARRAYLIT, OSLICELIT, OMAPLIT:
 		n := n.(*CompLitExpr)
 		if !exportFormat {
-			fmt.Fprintf(s, "%v{%s}", n.Type(), ellipsisIf(n.List.Len() != 0))
+			fmt.Fprintf(s, "%v{%s}", n.Type(), ellipsisIf(len(n.List) != 0))
 			return
 		}
 		fmt.Fprintf(s, "(%v{ %.v })", n.Type(), n.List)
@@ -800,10 +800,10 @@ func exprFmt(n Node, s fmt.State, prec int) {
 
 	case OSLICEHEADER:
 		n := n.(*SliceHeaderExpr)
-		if n.LenCap.Len() != 2 {
-			base.Fatalf("bad OSLICEHEADER list length %d", n.LenCap.Len())
+		if len(n.LenCap) != 2 {
+			base.Fatalf("bad OSLICEHEADER list length %d", len(n.LenCap))
 		}
-		fmt.Fprintf(s, "sliceheader{%v,%v,%v}", n.Ptr, n.LenCap.First(), n.LenCap.Second())
+		fmt.Fprintf(s, "sliceheader{%v,%v,%v}", n.Ptr, n.LenCap[0], n.LenCap[1])
 
 	case OCOMPLEX, OCOPY:
 		n := n.(*BinaryExpr)
@@ -936,7 +936,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 
 	case OADDSTR:
 		n := n.(*AddStringExpr)
-		for i, n1 := range n.List.Slice() {
+		for i, n1 := range n.List {
 			if i != 0 {
 				fmt.Fprint(s, " + ")
 			}
@@ -980,9 +980,9 @@ func (l Nodes) Format(s fmt.State, verb rune) {
 		sep = ", "
 	}
 
-	for i, n := range l.Slice() {
+	for i, n := range l {
 		fmt.Fprint(s, n)
-		if i+1 < l.Len() {
+		if i+1 < len(l) {
 			fmt.Fprint(s, sep)
 		}
 	}
@@ -1131,7 +1131,7 @@ func dumpNode(w io.Writer, n Node, depth int) {
 		return
 	}
 
-	if n.Init().Len() != 0 {
+	if len(n.Init()) != 0 {
 		fmt.Fprintf(w, "%+v-init", n.Op())
 		dumpNodes(w, n.Init(), depth+1)
 		indent(w, depth)
@@ -1200,7 +1200,7 @@ func dumpNode(w io.Writer, n Node, depth int) {
 				dumpNode(w, dcl, depth+1)
 			}
 		}
-		if fn.Body.Len() > 0 {
+		if len(fn.Body) > 0 {
 			indent(w, depth)
 			fmt.Fprintf(w, "%+v-body", n.Op())
 			dumpNodes(w, fn.Body, depth+1)
@@ -1247,7 +1247,7 @@ func dumpNode(w io.Writer, n Node, depth int) {
 			}
 			dumpNode(w, val, depth+1)
 		case Nodes:
-			if val.Len() == 0 {
+			if len(val) == 0 {
 				continue
 			}
 			if name != "" {
@@ -1260,12 +1260,12 @@ func dumpNode(w io.Writer, n Node, depth int) {
 }
 
 func dumpNodes(w io.Writer, list Nodes, depth int) {
-	if list.Len() == 0 {
+	if len(list) == 0 {
 		fmt.Fprintf(w, " <nil>")
 		return
 	}
 
-	for _, n := range list.Slice() {
+	for _, n := range list {
 		dumpNode(w, n, depth)
 	}
 }
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 86ef600f26..34b89752ad 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -317,41 +317,6 @@ type Nodes []Node
 // The methods that would modify it panic instead.
 var immutableEmptyNodes = Nodes{}
 
-// asNodes returns a slice of *Node as a Nodes value.
-func AsNodes(s []Node) Nodes {
-	return s
-}
-
-// Slice returns the entries in Nodes as a slice.
-// Changes to the slice entries (as in s[i] = n) will be reflected in
-// the Nodes.
-func (n Nodes) Slice() []Node {
-	return n
-}
-
-// Len returns the number of entries in Nodes.
-func (n Nodes) Len() int {
-	return len(n)
-}
-
-// Index returns the i'th element of Nodes.
-// It panics if n does not have at least i+1 elements.
-func (n Nodes) Index(i int) Node {
-	return n[i]
-}
-
-// First returns the first element of Nodes (same as n.Index(0)).
-// It panics if n has no elements.
-func (n Nodes) First() Node {
-	return n[0]
-}
-
-// Second returns the second element of Nodes (same as n.Index(1)).
-// It panics if n has fewer than two elements.
-func (n Nodes) Second() Node {
-	return n[1]
-}
-
 func (n *Nodes) mutate() {
 	if n == &immutableEmptyNodes {
 		panic("immutable Nodes.Set")
@@ -371,55 +336,6 @@ func (n *Nodes) Set(s []Node) {
 	*n = s
 }
 
-// Set1 sets n to a slice containing a single node.
-func (n *Nodes) Set1(n1 Node) {
-	n.mutate()
-	*n = []Node{n1}
-}
-
-// Set2 sets n to a slice containing two nodes.
-func (n *Nodes) Set2(n1, n2 Node) {
-	n.mutate()
-	*n = []Node{n1, n2}
-}
-
-// Set3 sets n to a slice containing three nodes.
-func (n *Nodes) Set3(n1, n2, n3 Node) {
-	n.mutate()
-	*n = []Node{n1, n2, n3}
-}
-
-// MoveNodes sets n to the contents of n2, then clears n2.
-func (n *Nodes) MoveNodes(n2 *Nodes) {
-	n.mutate()
-	*n = *n2
-	*n2 = nil
-}
-
-// SetIndex sets the i'th element of Nodes to node.
-// It panics if n does not have at least i+1 elements.
-func (n Nodes) SetIndex(i int, node Node) {
-	n[i] = node
-}
-
-// SetFirst sets the first element of Nodes to node.
-// It panics if n does not have at least one elements.
-func (n Nodes) SetFirst(node Node) {
-	n[0] = node
-}
-
-// SetSecond sets the second element of Nodes to node.
-// It panics if n does not have at least two elements.
-func (n Nodes) SetSecond(node Node) {
-	n[1] = node
-}
-
-// Addr returns the address of the i'th element of Nodes.
-// It panics if n does not have at least i+1 elements.
-func (n Nodes) Addr(i int) *Node {
-	return &n[i]
-}
-
 // Append appends entries to Nodes.
 func (n *Nodes) Append(a ...Node) {
 	if len(a) == 0 {
@@ -446,18 +362,12 @@ func (n *Nodes) Take() []Node {
 	return ret
 }
 
-// AppendNodes appends the contents of *n2 to n, then clears n2.
-func (n *Nodes) AppendNodes(n2 *Nodes) {
-	n.mutate()
-	*n = append(*n, n2.Take()...)
-}
-
 // Copy returns a copy of the content of the slice.
 func (n Nodes) Copy() Nodes {
 	if n == nil {
 		return nil
 	}
-	c := make(Nodes, n.Len())
+	c := make(Nodes, len(n))
 	copy(c, n)
 	return c
 }
diff --git a/src/cmd/compile/internal/ir/visit.go b/src/cmd/compile/internal/ir/visit.go
index 3f5af4ea0e..a1c345968f 100644
--- a/src/cmd/compile/internal/ir/visit.go
+++ b/src/cmd/compile/internal/ir/visit.go
@@ -106,7 +106,7 @@ func DoChildren(n Node, do func(Node) error) error {
 // Note that DoList only calls do on the nodes in the list, not their children.
 // If x's children should be processed, do(x) must call DoChildren(x, do) itself.
 func DoList(list Nodes, do func(Node) error) error {
-	for _, x := range list.Slice() {
+	for _, x := range list {
 		if x != nil {
 			if err := do(x); err != nil {
 				return err
@@ -131,7 +131,7 @@ func Visit(n Node, visit func(Node)) {
 
 // VisitList calls Visit(x, visit) for each node x in the list.
 func VisitList(list Nodes, visit func(Node)) {
-	for _, x := range list.Slice() {
+	for _, x := range list {
 		Visit(x, visit)
 	}
 }
@@ -163,7 +163,7 @@ func Any(n Node, cond func(Node) bool) bool {
 // 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.Slice() {
+	for _, x := range list {
 		if Any(x, cond) {
 			return true
 		}
@@ -217,8 +217,8 @@ func EditChildren(n Node, edit func(Node) Node) {
 // Note that editList only calls edit on the nodes in the list, not their children.
 // If x's children should be processed, edit(x) must call EditChildren(x, edit) itself.
 func editList(list Nodes, edit func(Node) Node) {
-	s := list.Slice()
-	for i, x := range list.Slice() {
+	s := list
+	for i, x := range list {
 		if x != nil {
 			s[i] = edit(x)
 		}
-- 
GitLab


From ead4957892bc1975d9cc9c32777733c67e5a885e Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 23 Dec 2020 00:05:23 -0500
Subject: [PATCH 0300/2400] [dev.regabi] cmd/compile: move helpers into package
 base [generated]

[git-generate]
cd src/cmd/compile/internal/gc
rf '
	# Move EnableTrace constant into base, with the other flags.
	mv enableTrace EnableTrace
	mv EnableTrace base.go

	# Move compilation checks to base.
	mv instrumenting Instrumenting
	mv ispkgin Compiling
	mv omit_pkgs NoInstrumentPkgs
	mv norace_inst_pkgs NoRacePkgs
	mv Instrumenting Compiling NoInstrumentPkgs NoRacePkgs base.go

	# Move AutogeneratedPos to package base, next to Pos.
	mv autogeneratedPos AutogeneratedPos
	mv AutogeneratedPos print.go

	mv timings Timer

	mv base.go print.go timings.go cmd/compile/internal/base
'
cd ../base
rf '
	mv Instrumenting Flag.Cfg.Instrumenting
'

Change-Id: I534437fa75857d31531fc499d833c9930c0a06d0
Reviewed-on: https://go-review.googlesource.com/c/go/+/279420
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/base/base.go         | 51 +++++++++++++++++++
 src/cmd/compile/internal/base/flag.go         |  3 ++
 src/cmd/compile/internal/base/print.go        |  2 +
 .../compile/internal/{gc => base}/timings.go  |  4 +-
 src/cmd/compile/internal/gc/alg.go            |  4 +-
 src/cmd/compile/internal/gc/align.go          |  2 +-
 src/cmd/compile/internal/gc/go.go             |  7 ---
 src/cmd/compile/internal/gc/gsubr.go          |  2 +-
 src/cmd/compile/internal/gc/inl.go            |  2 +-
 src/cmd/compile/internal/gc/main.go           | 32 ++++++------
 src/cmd/compile/internal/gc/order.go          | 16 +++---
 src/cmd/compile/internal/gc/racewalk.go       | 50 +-----------------
 src/cmd/compile/internal/gc/range.go          |  4 +-
 src/cmd/compile/internal/gc/ssa.go            |  4 +-
 src/cmd/compile/internal/gc/subr.go           |  6 +--
 src/cmd/compile/internal/gc/typecheck.go      | 35 ++++++-------
 src/cmd/compile/internal/gc/walk.go           | 18 +++----
 17 files changed, 120 insertions(+), 122 deletions(-)
 rename src/cmd/compile/internal/{gc => base}/timings.go (99%)

diff --git a/src/cmd/compile/internal/base/base.go b/src/cmd/compile/internal/base/base.go
index e26b378472..5a30fa6a33 100644
--- a/src/cmd/compile/internal/base/base.go
+++ b/src/cmd/compile/internal/base/base.go
@@ -26,3 +26,54 @@ func Exit(code int) {
 	}
 	os.Exit(code)
 }
+
+// To enable tracing support (-t flag), set EnableTrace to true.
+const EnableTrace = false
+
+func Compiling(pkgs []string) bool {
+	if Ctxt.Pkgpath != "" {
+		for _, p := range pkgs {
+			if Ctxt.Pkgpath == p {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+// The racewalk pass is currently handled in three parts.
+//
+// First, for flag_race, it inserts calls to racefuncenter and
+// racefuncexit at the start and end (respectively) of each
+// function. This is handled below.
+//
+// Second, during buildssa, it inserts appropriate instrumentation
+// calls immediately before each memory load or store. This is handled
+// by the (*state).instrument method in ssa.go, so here we just set
+// the Func.InstrumentBody flag as needed. For background on why this
+// is done during SSA construction rather than a separate SSA pass,
+// see issue #19054.
+//
+// Third we remove calls to racefuncenter and racefuncexit, for leaf
+// functions without instrumented operations. This is done as part of
+// ssa opt pass via special rule.
+
+// TODO(dvyukov): do not instrument initialization as writes:
+// a := make([]int, 10)
+
+// Do not instrument the following packages at all,
+// at best instrumentation would cause infinite recursion.
+var NoInstrumentPkgs = []string{
+	"runtime/internal/atomic",
+	"runtime/internal/sys",
+	"runtime/internal/math",
+	"runtime",
+	"runtime/race",
+	"runtime/msan",
+	"internal/cpu",
+}
+
+// Don't insert racefuncenterfp/racefuncexit into the following packages.
+// Memory accesses in the packages are either uninteresting or will cause false positives.
+var NoRacePkgs = []string{"sync", "sync/atomic"}
diff --git a/src/cmd/compile/internal/base/flag.go b/src/cmd/compile/internal/base/flag.go
index ce87ff730e..d35b8452f9 100644
--- a/src/cmd/compile/internal/base/flag.go
+++ b/src/cmd/compile/internal/base/flag.go
@@ -130,6 +130,9 @@ type CmdFlags struct {
 		ImportMap    map[string]string // set by -importmap OR -importcfg
 		PackageFile  map[string]string // set by -importcfg; nil means not in use
 		SpectreIndex bool              // set by -spectre=index or -spectre=all
+		// Whether we are adding any sort of code instrumentation, such as
+		// when the race detector is enabled.
+		Instrumenting bool
 	}
 }
 
diff --git a/src/cmd/compile/internal/base/print.go b/src/cmd/compile/internal/base/print.go
index ac7333ca4e..9855dfdad0 100644
--- a/src/cmd/compile/internal/base/print.go
+++ b/src/cmd/compile/internal/base/print.go
@@ -260,3 +260,5 @@ func ExitIfErrors() {
 		ErrorExit()
 	}
 }
+
+var AutogeneratedPos src.XPos
diff --git a/src/cmd/compile/internal/gc/timings.go b/src/cmd/compile/internal/base/timings.go
similarity index 99%
rename from src/cmd/compile/internal/gc/timings.go
rename to src/cmd/compile/internal/base/timings.go
index ac12d78d1e..f599f4e05f 100644
--- a/src/cmd/compile/internal/gc/timings.go
+++ b/src/cmd/compile/internal/base/timings.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package base
 
 import (
 	"fmt"
@@ -11,7 +11,7 @@ import (
 	"time"
 )
 
-var timings Timings
+var Timer Timings
 
 // Timings collects the execution times of labeled phases
 // which are added trough a sequence of Start/Stop calls.
diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index 49ce14b026..8733c6198c 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -288,7 +288,7 @@ func genhash(t *types.Type) *obj.LSym {
 		fmt.Printf("genhash %v %v %v\n", closure, sym, t)
 	}
 
-	base.Pos = autogeneratedPos // less confusing than end of input
+	base.Pos = base.AutogeneratedPos // less confusing than end of input
 	dclcontext = ir.PEXTERN
 
 	// func sym(p *T, h uintptr) uintptr
@@ -517,7 +517,7 @@ func geneq(t *types.Type) *obj.LSym {
 
 	// Autogenerate code for equality of structs and arrays.
 
-	base.Pos = autogeneratedPos // less confusing than end of input
+	base.Pos = base.AutogeneratedPos // less confusing than end of input
 	dclcontext = ir.PEXTERN
 
 	// func sym(p, q *T) bool
diff --git a/src/cmd/compile/internal/gc/align.go b/src/cmd/compile/internal/gc/align.go
index a9cf7fb50a..f2f98bd51f 100644
--- a/src/cmd/compile/internal/gc/align.go
+++ b/src/cmd/compile/internal/gc/align.go
@@ -270,7 +270,7 @@ func reportTypeLoop(t *types.Type) {
 func dowidth(t *types.Type) {
 	// Calling dowidth when typecheck tracing enabled is not safe.
 	// See issue #33658.
-	if enableTrace && skipDowidthForTracing {
+	if base.EnableTrace && skipDowidthForTracing {
 		return
 	}
 	if Widthptr == 0 {
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index df91f6f530..46ddda0ba7 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -10,7 +10,6 @@ import (
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
-	"cmd/internal/src"
 	"sync"
 )
 
@@ -144,14 +143,8 @@ var Widthreg int
 
 var typecheckok bool
 
-// Whether we are adding any sort of code instrumentation, such as
-// when the race detector is enabled.
-var instrumenting bool
-
 var nodfp *ir.Name
 
-var autogeneratedPos src.XPos
-
 // interface to back end
 
 type Arch struct {
diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go
index f4178db477..db55b1035c 100644
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ b/src/cmd/compile/internal/gc/gsubr.go
@@ -199,7 +199,7 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 	savedclcontext := dclcontext
 	savedcurfn := Curfn
 
-	base.Pos = autogeneratedPos
+	base.Pos = base.AutogeneratedPos
 	dclcontext = ir.PEXTERN
 
 	// At the moment we don't support wrapping a method, we'd need machinery
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 2fb23f1a3f..49e0bcc470 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -844,7 +844,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 		return n
 	}
 
-	if instrumenting && isRuntimePkg(fn.Sym().Pkg) {
+	if base.Flag.Cfg.Instrumenting && isRuntimePkg(fn.Sym().Pkg) {
 		// Runtime package must not be instrumented.
 		// Instrument skips runtime package. However, some runtime code can be
 		// inlined into other packages and instrumented there. To avoid this,
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index c1cc7ed377..feded3f9b2 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -58,7 +58,7 @@ var Target *ir.Package
 // arguments, type-checks the parsed Go package, compiles functions to machine
 // code, and finally writes the compiled package definition to disk.
 func Main(archInit func(*Arch)) {
-	timings.Start("fe", "init")
+	base.Timer.Start("fe", "init")
 
 	defer hidePanic()
 
@@ -123,7 +123,7 @@ func Main(archInit func(*Arch)) {
 	// changes in the binary.)
 	recordFlags("B", "N", "l", "msan", "race", "shared", "dynlink", "dwarflocationlists", "dwarfbasentries", "smallframes", "spectre")
 
-	if !enableTrace && base.Flag.LowerT {
+	if !base.EnableTrace && base.Flag.LowerT {
 		log.Fatalf("compiler not built with support for -t")
 	}
 
@@ -159,7 +159,7 @@ func Main(archInit func(*Arch)) {
 		readSymABIs(base.Flag.SymABIs, base.Ctxt.Pkgpath)
 	}
 
-	if ispkgin(omit_pkgs) {
+	if base.Compiling(base.NoInstrumentPkgs) {
 		base.Flag.Race = false
 		base.Flag.MSan = false
 	}
@@ -173,7 +173,7 @@ func Main(archInit func(*Arch)) {
 		msanpkg = types.NewPkg("runtime/msan", "")
 	}
 	if base.Flag.Race || base.Flag.MSan {
-		instrumenting = true
+		base.Flag.Cfg.Instrumenting = true
 	}
 	if base.Flag.Dwarf {
 		dwarf.EnableLogging(base.Debug.DwarfInl != 0)
@@ -205,7 +205,7 @@ func Main(archInit func(*Arch)) {
 	NeedITab = func(t, iface *types.Type) { itabname(t, iface) }
 	NeedRuntimeType = addsignat // TODO(rsc): typenamesym for lock?
 
-	autogeneratedPos = makePos(src.NewFileBase("<autogenerated>", "<autogenerated>"), 1, 0)
+	base.AutogeneratedPos = makePos(src.NewFileBase("<autogenerated>", "<autogenerated>"), 1, 0)
 
 	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
 		return typenamesym(t).Linksym()
@@ -213,11 +213,11 @@ func Main(archInit func(*Arch)) {
 	TypecheckInit()
 
 	// Parse input.
-	timings.Start("fe", "parse")
+	base.Timer.Start("fe", "parse")
 	lines := parseFiles(flag.Args())
 	cgoSymABIs()
-	timings.Stop()
-	timings.AddEvent(int64(lines), "lines")
+	base.Timer.Stop()
+	base.Timer.AddEvent(int64(lines), "lines")
 	recordPackageName()
 
 	// Typecheck.
@@ -233,7 +233,7 @@ func Main(archInit func(*Arch)) {
 	}
 
 	// Inlining
-	timings.Start("fe", "inlining")
+	base.Timer.Start("fe", "inlining")
 	if base.Flag.LowerL != 0 {
 		InlinePackage()
 	}
@@ -254,7 +254,7 @@ func Main(archInit func(*Arch)) {
 	// or else the stack copier will not update it.
 	// Large values are also moved off stack in escape analysis;
 	// because large values may contain pointers, it must happen early.
-	timings.Start("fe", "escapes")
+	base.Timer.Start("fe", "escapes")
 	escapes(Target.Decls)
 
 	// Collect information for go:nowritebarrierrec
@@ -268,7 +268,7 @@ func Main(archInit func(*Arch)) {
 	// Transform closure bodies to properly reference captured variables.
 	// This needs to happen before walk, because closures must be transformed
 	// before walk reaches a call of a closure.
-	timings.Start("fe", "xclosures")
+	base.Timer.Start("fe", "xclosures")
 	for _, n := range Target.Decls {
 		if n.Op() == ir.ODCLFUNC {
 			n := n.(*ir.Func)
@@ -292,7 +292,7 @@ func Main(archInit func(*Arch)) {
 
 	// Compile top level functions.
 	// Don't use range--walk can add functions to Target.Decls.
-	timings.Start("be", "compilefuncs")
+	base.Timer.Start("be", "compilefuncs")
 	fcount := int64(0)
 	for i := 0; i < len(Target.Decls); i++ {
 		n := Target.Decls[i]
@@ -301,7 +301,7 @@ func Main(archInit func(*Arch)) {
 			fcount++
 		}
 	}
-	timings.AddEvent(fcount, "funcs")
+	base.Timer.AddEvent(fcount, "funcs")
 
 	compileFunctions()
 
@@ -320,7 +320,7 @@ func Main(archInit func(*Arch)) {
 	}
 
 	// Write object data to disk.
-	timings.Start("be", "dumpobj")
+	base.Timer.Start("be", "dumpobj")
 	dumpdata()
 	base.Ctxt.NumberSyms()
 	dumpobj()
@@ -339,7 +339,7 @@ func Main(archInit func(*Arch)) {
 	base.ExitIfErrors()
 
 	base.FlushErrors()
-	timings.Stop()
+	base.Timer.Stop()
 
 	if base.Flag.Bench != "" {
 		if err := writebench(base.Flag.Bench); err != nil {
@@ -397,7 +397,7 @@ func writebench(filename string) error {
 	fmt.Fprintln(&buf, "commit:", objabi.Version)
 	fmt.Fprintln(&buf, "goos:", runtime.GOOS)
 	fmt.Fprintln(&buf, "goarch:", runtime.GOARCH)
-	timings.Write(&buf, "BenchmarkCompile:"+base.Ctxt.Pkgpath+":")
+	base.Timer.Write(&buf, "BenchmarkCompile:"+base.Ctxt.Pkgpath+":")
 
 	n, err := f.Write(buf.Bytes())
 	if err != nil {
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 45a2e2a43e..738b403b99 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -362,7 +362,7 @@ func (o *Order) stmtList(l ir.Nodes) {
 // and rewrites it to:
 //  m = OMAKESLICECOPY([]T, x, s); nil
 func orderMakeSliceCopy(s []ir.Node) {
-	if base.Flag.N != 0 || instrumenting {
+	if base.Flag.N != 0 || base.Flag.Cfg.Instrumenting {
 		return
 	}
 	if len(s) < 2 || s[0] == nil || s[0].Op() != ir.OAS || s[1] == nil || s[1].Op() != ir.OCOPY {
@@ -580,7 +580,7 @@ func (o *Order) mapAssign(n ir.Node) {
 					m.Index = o.copyExpr(m.Index)
 				}
 				fallthrough
-			case instrumenting && n.Op() == ir.OAS2FUNC && !ir.IsBlank(m):
+			case base.Flag.Cfg.Instrumenting && n.Op() == ir.OAS2FUNC && !ir.IsBlank(m):
 				t := o.newTemp(m.Type(), false)
 				n.Lhs[i] = t
 				a := ir.NewAssignStmt(base.Pos, m, t)
@@ -639,7 +639,7 @@ func (o *Order) stmt(n ir.Node) {
 		n.X = o.expr(n.X, nil)
 		n.Y = o.expr(n.Y, nil)
 
-		if instrumenting || n.X.Op() == ir.OINDEXMAP && (n.AsOp == ir.ODIV || n.AsOp == ir.OMOD) {
+		if base.Flag.Cfg.Instrumenting || n.X.Op() == ir.OINDEXMAP && (n.AsOp == ir.ODIV || n.AsOp == ir.OMOD) {
 			// Rewrite m[k] op= r into m[k] = m[k] op r so
 			// that we can ensure that if op panics
 			// because r is zero, the panic happens before
@@ -1008,7 +1008,7 @@ func (o *Order) stmt(n ir.Node) {
 		t := o.markTemp()
 		n.Chan = o.expr(n.Chan, nil)
 		n.Value = o.expr(n.Value, nil)
-		if instrumenting {
+		if base.Flag.Cfg.Instrumenting {
 			// Force copying to the stack so that (chan T)(nil) <- x
 			// is still instrumented as a read of x.
 			n.Value = o.copyExpr(n.Value)
@@ -1156,7 +1156,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 			// conversions. See copyExpr a few lines below.
 			needCopy = mapKeyReplaceStrConv(n.Index)
 
-			if instrumenting {
+			if base.Flag.Cfg.Instrumenting {
 				// Race detector needs the copy.
 				needCopy = true
 			}
@@ -1194,7 +1194,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 			// together. See golang.org/issue/15329.
 			o.init(call)
 			o.call(call)
-			if lhs == nil || lhs.Op() != ir.ONAME || instrumenting {
+			if lhs == nil || lhs.Op() != ir.ONAME || base.Flag.Cfg.Instrumenting {
 				return o.copyExpr(n)
 			}
 		} else {
@@ -1267,7 +1267,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 			o.call(n)
 		}
 
-		if lhs == nil || lhs.Op() != ir.ONAME || instrumenting {
+		if lhs == nil || lhs.Op() != ir.ONAME || base.Flag.Cfg.Instrumenting {
 			return o.copyExpr(n)
 		}
 		return n
@@ -1332,7 +1332,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 	case ir.ODOTTYPE, ir.ODOTTYPE2:
 		n := n.(*ir.TypeAssertExpr)
 		n.X = o.expr(n.X, nil)
-		if !isdirectiface(n.Type()) || instrumenting {
+		if !isdirectiface(n.Type()) || base.Flag.Cfg.Instrumenting {
 			return o.copyExprClear(n)
 		}
 		return n
diff --git a/src/cmd/compile/internal/gc/racewalk.go b/src/cmd/compile/internal/gc/racewalk.go
index 61a65368af..67802fe917 100644
--- a/src/cmd/compile/internal/gc/racewalk.go
+++ b/src/cmd/compile/internal/gc/racewalk.go
@@ -12,60 +12,12 @@ import (
 	"cmd/internal/sys"
 )
 
-// The racewalk pass is currently handled in three parts.
-//
-// First, for flag_race, it inserts calls to racefuncenter and
-// racefuncexit at the start and end (respectively) of each
-// function. This is handled below.
-//
-// Second, during buildssa, it inserts appropriate instrumentation
-// calls immediately before each memory load or store. This is handled
-// by the (*state).instrument method in ssa.go, so here we just set
-// the Func.InstrumentBody flag as needed. For background on why this
-// is done during SSA construction rather than a separate SSA pass,
-// see issue #19054.
-//
-// Third we remove calls to racefuncenter and racefuncexit, for leaf
-// functions without instrumented operations. This is done as part of
-// ssa opt pass via special rule.
-
-// TODO(dvyukov): do not instrument initialization as writes:
-// a := make([]int, 10)
-
-// Do not instrument the following packages at all,
-// at best instrumentation would cause infinite recursion.
-var omit_pkgs = []string{
-	"runtime/internal/atomic",
-	"runtime/internal/sys",
-	"runtime/internal/math",
-	"runtime",
-	"runtime/race",
-	"runtime/msan",
-	"internal/cpu",
-}
-
-// Don't insert racefuncenterfp/racefuncexit into the following packages.
-// Memory accesses in the packages are either uninteresting or will cause false positives.
-var norace_inst_pkgs = []string{"sync", "sync/atomic"}
-
-func ispkgin(pkgs []string) bool {
-	if base.Ctxt.Pkgpath != "" {
-		for _, p := range pkgs {
-			if base.Ctxt.Pkgpath == p {
-				return true
-			}
-		}
-	}
-
-	return false
-}
-
 func instrument(fn *ir.Func) {
 	if fn.Pragma&ir.Norace != 0 || (fn.Sym().Linksym() != nil && fn.Sym().Linksym().ABIWrapper()) {
 		return
 	}
 
-	if !base.Flag.Race || !ispkgin(norace_inst_pkgs) {
+	if !base.Flag.Race || !base.Compiling(base.NoRacePkgs) {
 		fn.SetInstrumentBody(true)
 	}
 
diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index 4d2964591b..078f03bc68 100644
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -460,7 +460,7 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 //
 // where == for keys of map m is reflexive.
 func isMapClear(n *ir.RangeStmt) bool {
-	if base.Flag.N != 0 || instrumenting {
+	if base.Flag.N != 0 || base.Flag.Cfg.Instrumenting {
 		return false
 	}
 
@@ -523,7 +523,7 @@ func mapClear(m ir.Node) ir.Node {
 //
 // Parameters are as in walkrange: "for v1, v2 = range a".
 func arrayClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
-	if base.Flag.N != 0 || instrumenting {
+	if base.Flag.N != 0 || base.Flag.Cfg.Instrumenting {
 		return nil
 	}
 
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 6993b4b1c7..0bca2baa17 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -2281,7 +2281,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 			return nil
 		}
 
-		if instrumenting {
+		if base.Flag.Cfg.Instrumenting {
 			// These appear to be fine, but they fail the
 			// integer constraint below, so okay them here.
 			// Sample non-integer conversion: map[string]string -> *uint8
@@ -3490,7 +3490,7 @@ func initSSATables() {
 	}
 
 	/******** runtime ********/
-	if !instrumenting {
+	if !base.Flag.Cfg.Instrumenting {
 		add("runtime", "slicebytetostringtmp",
 			func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 				// Compiler frontend optimizations emit OBYTES2STRTMP nodes
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 59763824fb..6e130d4889 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -613,7 +613,7 @@ func calcHasCall(n ir.Node) bool {
 	case ir.OANDAND, ir.OOROR:
 		// hard with instrumented code
 		n := n.(*ir.LogicalExpr)
-		if instrumenting {
+		if base.Flag.Cfg.Instrumenting {
 			return true
 		}
 		return n.X.HasCall() || n.Y.HasCall()
@@ -1209,7 +1209,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 		return
 	}
 
-	base.Pos = autogeneratedPos
+	base.Pos = base.AutogeneratedPos
 	dclcontext = ir.PEXTERN
 
 	tfn := ir.NewFuncType(base.Pos,
@@ -1243,7 +1243,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	// the TOC to the appropriate value for that module. But if it returns
 	// directly to the wrapper's caller, nothing will reset it to the correct
 	// value for that function.
-	if !instrumenting && rcvr.IsPtr() && methodrcvr.IsPtr() && method.Embedded != 0 && !isifacemethod(method.Type) && !(thearch.LinkArch.Name == "ppc64le" && base.Ctxt.Flag_dynlink) {
+	if !base.Flag.Cfg.Instrumenting && rcvr.IsPtr() && methodrcvr.IsPtr() && method.Embedded != 0 && !isifacemethod(method.Type) && !(thearch.LinkArch.Name == "ppc64le" && base.Ctxt.Flag_dynlink) {
 		// generate tail call: adjust pointer receiver and jump to embedded method.
 		left := dot.X // skip final .M
 		if !left.Type().IsPtr() {
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index f2e5728d80..4f1fe240ec 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -25,7 +25,7 @@ func TypecheckInit() {
 	types.Dowidth = dowidth
 	initUniverse()
 	dclcontext = ir.PEXTERN
-	timings.Start("fe", "loadsys")
+	base.Timer.Start("fe", "loadsys")
 	loadsys()
 }
 
@@ -45,7 +45,7 @@ func TypecheckPackage() {
 	//   TODO(gri) Remove this again once we have a fix for #25838.
 
 	// Don't use range--typecheck can add closures to Target.Decls.
-	timings.Start("fe", "typecheck", "top1")
+	base.Timer.Start("fe", "typecheck", "top1")
 	for i := 0; i < len(Target.Decls); i++ {
 		n := Target.Decls[i]
 		if op := n.Op(); op != ir.ODCL && op != ir.OAS && op != ir.OAS2 && (op != ir.ODCLTYPE || !n.(*ir.Decl).X.Name().Alias()) {
@@ -57,7 +57,7 @@ func TypecheckPackage() {
 	//   To check interface assignments, depends on phase 1.
 
 	// Don't use range--typecheck can add closures to Target.Decls.
-	timings.Start("fe", "typecheck", "top2")
+	base.Timer.Start("fe", "typecheck", "top2")
 	for i := 0; i < len(Target.Decls); i++ {
 		n := Target.Decls[i]
 		if op := n.Op(); op == ir.ODCL || op == ir.OAS || op == ir.OAS2 || op == ir.ODCLTYPE && n.(*ir.Decl).X.Name().Alias() {
@@ -67,7 +67,7 @@ func TypecheckPackage() {
 
 	// Phase 3: Type check function bodies.
 	// Don't use range--typecheck can add closures to Target.Decls.
-	timings.Start("fe", "typecheck", "func")
+	base.Timer.Start("fe", "typecheck", "func")
 	var fcount int64
 	for i := 0; i < len(Target.Decls); i++ {
 		n := Target.Decls[i]
@@ -80,7 +80,7 @@ func TypecheckPackage() {
 	// Phase 4: Check external declarations.
 	// TODO(mdempsky): This should be handled when type checking their
 	// corresponding ODCL nodes.
-	timings.Start("fe", "typecheck", "externdcls")
+	base.Timer.Start("fe", "typecheck", "externdcls")
 	for i, n := range Target.Externs {
 		if n.Op() == ir.ONAME {
 			Target.Externs[i] = typecheck(Target.Externs[i], ctxExpr)
@@ -93,7 +93,7 @@ func TypecheckPackage() {
 	// Phase 6: Decide how to capture closed variables.
 	// This needs to run before escape analysis,
 	// because variables captured by value do not escape.
-	timings.Start("fe", "capturevars")
+	base.Timer.Start("fe", "capturevars")
 	for _, n := range Target.Decls {
 		if n.Op() == ir.ODCLFUNC {
 			n := n.(*ir.Func)
@@ -162,9 +162,6 @@ func TypecheckImports() {
 	}
 }
 
-// To enable tracing support (-t flag), set enableTrace to true.
-const enableTrace = false
-
 var traceIndent []byte
 var skipDowidthForTracing bool
 
@@ -234,7 +231,7 @@ func resolve(n ir.Node) (res ir.Node) {
 	}
 
 	// only trace if there's work to do
-	if enableTrace && base.Flag.LowerT {
+	if base.EnableTrace && base.Flag.LowerT {
 		defer tracePrint("resolve", n)(&res)
 	}
 
@@ -379,7 +376,7 @@ func typecheck(n ir.Node, top int) (res ir.Node) {
 	}
 
 	// only trace if there's work to do
-	if enableTrace && base.Flag.LowerT {
+	if base.EnableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheck", n)(&res)
 	}
 
@@ -568,7 +565,7 @@ func indexlit(n ir.Node) ir.Node {
 
 // typecheck1 should ONLY be called from typecheck.
 func typecheck1(n ir.Node, top int) (res ir.Node) {
-	if enableTrace && base.Flag.LowerT {
+	if base.EnableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheck1", n)(&res)
 	}
 
@@ -2552,7 +2549,7 @@ func lookdot1(errnode ir.Node, s *types.Sym, t *types.Type, fs *types.Fields, do
 // typecheckMethodExpr checks selector expressions (ODOT) where the
 // base expression is a type expression (OTYPE).
 func typecheckMethodExpr(n *ir.SelectorExpr) (res ir.Node) {
-	if enableTrace && base.Flag.LowerT {
+	if base.EnableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckMethodExpr", n)(&res)
 	}
 
@@ -2991,7 +2988,7 @@ func pushtype(nn ir.Node, t *types.Type) ir.Node {
 // The result of typecheckcomplit MUST be assigned back to n, e.g.
 // 	n.Left = typecheckcomplit(n.Left)
 func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
-	if enableTrace && base.Flag.LowerT {
+	if base.EnableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckcomplit", n)(&res)
 	}
 
@@ -3435,7 +3432,7 @@ func samesafeexpr(l ir.Node, r ir.Node) bool {
 // if this assignment is the definition of a var on the left side,
 // fill in the var's type.
 func typecheckas(n *ir.AssignStmt) {
-	if enableTrace && base.Flag.LowerT {
+	if base.EnableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckas", n)(nil)
 	}
 
@@ -3493,7 +3490,7 @@ func checkassignto(src *types.Type, dst ir.Node) {
 }
 
 func typecheckas2(n *ir.AssignListStmt) {
-	if enableTrace && base.Flag.LowerT {
+	if base.EnableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckas2", n)(nil)
 	}
 
@@ -3627,7 +3624,7 @@ out:
 // To be called by typecheck, not directly.
 // (Call typecheckFunc instead.)
 func typecheckfunc(n *ir.Func) {
-	if enableTrace && base.Flag.LowerT {
+	if base.EnableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckfunc", n)(nil)
 	}
 
@@ -3691,7 +3688,7 @@ func checkMapKeys() {
 }
 
 func typecheckdeftype(n *ir.Name) {
-	if enableTrace && base.Flag.LowerT {
+	if base.EnableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckdeftype", n)(nil)
 	}
 
@@ -3723,7 +3720,7 @@ func typecheckdeftype(n *ir.Name) {
 }
 
 func typecheckdef(n ir.Node) {
-	if enableTrace && base.Flag.LowerT {
+	if base.EnableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckdef", n)(nil)
 	}
 
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 610c6b6539..57edc43280 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -85,7 +85,7 @@ func walk(fn *ir.Func) {
 		ir.DumpList(s, Curfn.Enter)
 	}
 
-	if instrumenting {
+	if base.Flag.Cfg.Instrumenting {
 		instrument(fn)
 	}
 }
@@ -738,7 +738,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			return as
 		}
 
-		if !instrumenting && isZero(as.Y) {
+		if !base.Flag.Cfg.Instrumenting && isZero(as.Y) {
 			return as
 		}
 
@@ -1311,7 +1311,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		panic("unreachable")
 
 	case ir.OCOPY:
-		return copyany(n.(*ir.BinaryExpr), init, instrumenting && !base.Flag.CompilingRuntime)
+		return copyany(n.(*ir.BinaryExpr), init, base.Flag.Cfg.Instrumenting && !base.Flag.CompilingRuntime)
 
 	case ir.OCLOSE:
 		// cannot use chanfn - closechan takes any, not chan any
@@ -1597,7 +1597,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 	case ir.OBYTES2STRTMP:
 		n := n.(*ir.ConvExpr)
 		n.X = walkexpr(n.X, init)
-		if !instrumenting {
+		if !base.Flag.Cfg.Instrumenting {
 			// Let the backend handle OBYTES2STRTMP directly
 			// to avoid a function call to slicebytetostringtmp.
 			return n
@@ -1975,7 +1975,7 @@ func walkCall(n *ir.CallExpr, init *ir.Nodes) {
 		} else {
 			t = params.Field(i).Type
 		}
-		if instrumenting || fncall(arg, t) {
+		if base.Flag.Cfg.Instrumenting || fncall(arg, t) {
 			// make assignment of fncall to tempAt
 			tmp := temp(t)
 			a := convas(ir.NewAssignStmt(base.Pos, tmp, arg), init)
@@ -2873,7 +2873,7 @@ func appendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 		ptr1, len1 := backingArrayPtrLen(cheapexpr(slice, &nodes))
 		ptr2, len2 := backingArrayPtrLen(l2)
 		ncopy = mkcall1(fn, types.Types[types.TINT], &nodes, typename(elemtype), ptr1, len1, ptr2, len2)
-	} else if instrumenting && !base.Flag.CompilingRuntime {
+	} else if base.Flag.Cfg.Instrumenting && !base.Flag.CompilingRuntime {
 		// rely on runtime to instrument:
 		//  copy(s[len(l1):], l2)
 		// l2 can be a slice or string.
@@ -2914,7 +2914,7 @@ func appendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 // isAppendOfMake reports whether n is of the form append(x , make([]T, y)...).
 // isAppendOfMake assumes n has already been typechecked.
 func isAppendOfMake(n ir.Node) bool {
-	if base.Flag.N != 0 || instrumenting {
+	if base.Flag.N != 0 || base.Flag.Cfg.Instrumenting {
 		return false
 	}
 
@@ -3125,7 +3125,7 @@ func walkappend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
 
 	// General case, with no function calls left as arguments.
 	// Leave for gen, except that instrumentation requires old form.
-	if !instrumenting || base.Flag.CompilingRuntime {
+	if !base.Flag.Cfg.Instrumenting || base.Flag.CompilingRuntime {
 		return n
 	}
 
@@ -4055,7 +4055,7 @@ func canMergeLoads() bool {
 // isRuneCount reports whether n is of the form len([]rune(string)).
 // These are optimized into a call to runtime.countrunes.
 func isRuneCount(n ir.Node) bool {
-	return base.Flag.N == 0 && !instrumenting && n.Op() == ir.OLEN && n.(*ir.UnaryExpr).X.Op() == ir.OSTR2RUNES
+	return base.Flag.N == 0 && !base.Flag.Cfg.Instrumenting && n.Op() == ir.OLEN && n.(*ir.UnaryExpr).X.Op() == ir.OSTR2RUNES
 }
 
 func walkCheckPtrAlignment(n *ir.ConvExpr, init *ir.Nodes, count ir.Node) ir.Node {
-- 
GitLab


From 9ee309255a94499c6f4e6d3ac7653b5eeb4ae7b7 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 23 Dec 2020 00:08:03 -0500
Subject: [PATCH 0301/2400] [dev.regabi] cmd/compile: move helpers into package
 types [generated]

[git-generate]
cd src/cmd/compile/internal/gc
rf '
	# Type hash (formatting).
	mv typehash TypeHash
	mv TypeHash fmt.go

	# Method sorting.
	mv methcmp MethodsByName
	mv MethodsByName MethodsByName.Len MethodsByName.Swap \
		MethodsByName.Less sort.go

	# Move version check into types.
	# A little surprising, but its keyed off the types.Pkg.
	ex {
		import "cmd/compile/internal/types"
		var p *types.Pkg
		var major, minor int
		langSupported(major, minor, p) -> AllowsGoVersion(p, major, minor)
	}
	rm langSupported
	mv checkLang ParseLangFlag
	mv lang langWant AllowsGoVersion ParseLangFlag \
		parseLang currentLang goVersionRE goversion.go

	mv testdclstack CheckDclstack
	mv CheckDclstack scope.go

	mv algtype1 AlgType
	mv isComplex IsComplex
	mv isFloat IsFloat
	mv isInt IsInt
	mv issimple IsSimple
	mv okforcmp IsOrdered
	mv floatForComplex FloatForComplex
	mv complexForFloat ComplexForFloat
	mv isdirectiface IsDirectIface
	mv isifacemethod IsInterfaceMethod
	mv isMethodApplicable IsMethodApplicable
	mv ispaddedfield IsPaddedField
	mv isRuntimePkg IsRuntimePkg
	mv isReflectPkg IsReflectPkg
	mv methtype ReceiverBaseType
	mv typesymname TypeSymName
	mv typesym TypeSym
	mv typeLookup TypeSymLookup
	mv IsAlias IsDotAlias
	mv isreflexive IsReflexive
	mv simtype SimType

	# The type1.go here is to avoid an undiagnosed bug in rf
	# that does not get the follow-up typechecking right if we
	# move directly to type.go during the mv into package types below.
	mv \
		IsInt IsOrdered IsReflexive \
		IsDirectIface IsInterfaceMethod IsMethodApplicable IsPaddedField \
		IsRuntimePkg IsReflectPkg ReceiverBaseType \
		FloatForComplex ComplexForFloat \
		TypeSym TypeSymLookup TypeSymName \
		typepkg SimType \
		type1.go

	# The alg1.go here is because we are only moving part of alg.go.
	mv typeHasNoAlg TypeHasNoAlg
	mv AlgKind ANOEQ AlgType TypeHasNoAlg IsComparable IncomparableField IsPaddedField alg1.go

	mv IsDotAlias pkg.go

	mv alg1.go algkind_string.go fmt.go goversion.go pkg.go \
		CheckDclstack \ # scope.go
		sort.go type1.go \
		cmd/compile/internal/types
'
cd ../types
rf '
	mv IsDclstackValid isDclstackValid
	mv alg1.go alg.go
	mv type1.go type.go
'

Change-Id: I8bd53b21c7bdd1770e1b525de32f136833e84c9d
Reviewed-on: https://go-review.googlesource.com/c/go/+/279307
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/alg.go            | 271 ++++--------------
 src/cmd/compile/internal/gc/align.go          |   8 +-
 src/cmd/compile/internal/gc/const.go          |   6 +-
 src/cmd/compile/internal/gc/dcl.go            |  17 +-
 src/cmd/compile/internal/gc/escape.go         |   4 +-
 src/cmd/compile/internal/gc/go.go             |  28 --
 src/cmd/compile/internal/gc/gsubr.go          |   2 +-
 src/cmd/compile/internal/gc/iexport.go        |   6 +-
 src/cmd/compile/internal/gc/inl.go            |   8 +-
 src/cmd/compile/internal/gc/main.go           |  93 +-----
 src/cmd/compile/internal/gc/noder.go          |   6 +-
 src/cmd/compile/internal/gc/obj.go            |   2 +-
 src/cmd/compile/internal/gc/order.go          |   2 +-
 src/cmd/compile/internal/gc/pgen.go           |   4 +-
 src/cmd/compile/internal/gc/range.go          |   2 +-
 src/cmd/compile/internal/gc/reflect.go        | 108 +------
 src/cmd/compile/internal/gc/sinit.go          |   4 +-
 src/cmd/compile/internal/gc/ssa.go            |  44 +--
 src/cmd/compile/internal/gc/subr.go           | 112 +-------
 src/cmd/compile/internal/gc/swt.go            |  10 +-
 src/cmd/compile/internal/gc/typecheck.go      |  30 +-
 src/cmd/compile/internal/gc/universe.go       |  56 ++--
 src/cmd/compile/internal/gc/walk.go           |  24 +-
 src/cmd/compile/internal/types/alg.go         | 173 +++++++++++
 .../internal/{gc => types}/algkind_string.go  |   2 +-
 src/cmd/compile/internal/types/fmt.go         |  11 +
 src/cmd/compile/internal/types/goversion.go   |  96 +++++++
 src/cmd/compile/internal/types/pkg.go         |   4 +
 src/cmd/compile/internal/types/scope.go       |   8 +-
 src/cmd/compile/internal/types/sort.go        |  14 +
 src/cmd/compile/internal/types/type.go        | 202 +++++++++++++
 31 files changed, 691 insertions(+), 666 deletions(-)
 create mode 100644 src/cmd/compile/internal/types/alg.go
 rename src/cmd/compile/internal/{gc => types}/algkind_string.go (98%)
 create mode 100644 src/cmd/compile/internal/types/goversion.go
 create mode 100644 src/cmd/compile/internal/types/sort.go

diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index 8733c6198c..08237d4055 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -13,56 +13,10 @@ import (
 	"sort"
 )
 
-// AlgKind describes the kind of algorithms used for comparing and
-// hashing a Type.
-type AlgKind int
-
-//go:generate stringer -type AlgKind -trimprefix A
-
-const (
-	// These values are known by runtime.
-	ANOEQ AlgKind = iota
-	AMEM0
-	AMEM8
-	AMEM16
-	AMEM32
-	AMEM64
-	AMEM128
-	ASTRING
-	AINTER
-	ANILINTER
-	AFLOAT32
-	AFLOAT64
-	ACPLX64
-	ACPLX128
-
-	// Type can be compared/hashed as regular memory.
-	AMEM AlgKind = 100
-
-	// Type needs special comparison/hashing functions.
-	ASPECIAL AlgKind = -1
-)
-
-// IsComparable reports whether t is a comparable type.
-func IsComparable(t *types.Type) bool {
-	a, _ := algtype1(t)
-	return a != ANOEQ
-}
-
 // IsRegularMemory reports whether t can be compared/hashed as regular memory.
 func IsRegularMemory(t *types.Type) bool {
-	a, _ := algtype1(t)
-	return a == AMEM
-}
-
-// IncomparableField returns an incomparable Field of struct Type t, if any.
-func IncomparableField(t *types.Type) *types.Field {
-	for _, f := range t.FieldSlice() {
-		if !IsComparable(f.Type) {
-			return f
-		}
-	}
-	return nil
+	a, _ := types.AlgType(t)
+	return a == types.AMEM
 }
 
 // EqCanPanic reports whether == on type t could panic (has an interface somewhere).
@@ -87,128 +41,28 @@ func EqCanPanic(t *types.Type) bool {
 
 // algtype is like algtype1, except it returns the fixed-width AMEMxx variants
 // instead of the general AMEM kind when possible.
-func algtype(t *types.Type) AlgKind {
-	a, _ := algtype1(t)
-	if a == AMEM {
+func algtype(t *types.Type) types.AlgKind {
+	a, _ := types.AlgType(t)
+	if a == types.AMEM {
 		switch t.Width {
 		case 0:
-			return AMEM0
+			return types.AMEM0
 		case 1:
-			return AMEM8
+			return types.AMEM8
 		case 2:
-			return AMEM16
+			return types.AMEM16
 		case 4:
-			return AMEM32
+			return types.AMEM32
 		case 8:
-			return AMEM64
+			return types.AMEM64
 		case 16:
-			return AMEM128
+			return types.AMEM128
 		}
 	}
 
 	return a
 }
 
-// algtype1 returns the AlgKind used for comparing and hashing Type t.
-// If it returns ANOEQ, it also returns the component type of t that
-// makes it incomparable.
-func algtype1(t *types.Type) (AlgKind, *types.Type) {
-	if t.Broke() {
-		return AMEM, nil
-	}
-	if t.Noalg() {
-		return ANOEQ, t
-	}
-
-	switch t.Kind() {
-	case types.TANY, types.TFORW:
-		// will be defined later.
-		return ANOEQ, t
-
-	case types.TINT8, types.TUINT8, types.TINT16, types.TUINT16,
-		types.TINT32, types.TUINT32, types.TINT64, types.TUINT64,
-		types.TINT, types.TUINT, types.TUINTPTR,
-		types.TBOOL, types.TPTR,
-		types.TCHAN, types.TUNSAFEPTR:
-		return AMEM, nil
-
-	case types.TFUNC, types.TMAP:
-		return ANOEQ, t
-
-	case types.TFLOAT32:
-		return AFLOAT32, nil
-
-	case types.TFLOAT64:
-		return AFLOAT64, nil
-
-	case types.TCOMPLEX64:
-		return ACPLX64, nil
-
-	case types.TCOMPLEX128:
-		return ACPLX128, nil
-
-	case types.TSTRING:
-		return ASTRING, nil
-
-	case types.TINTER:
-		if t.IsEmptyInterface() {
-			return ANILINTER, nil
-		}
-		return AINTER, nil
-
-	case types.TSLICE:
-		return ANOEQ, t
-
-	case types.TARRAY:
-		a, bad := algtype1(t.Elem())
-		switch a {
-		case AMEM:
-			return AMEM, nil
-		case ANOEQ:
-			return ANOEQ, bad
-		}
-
-		switch t.NumElem() {
-		case 0:
-			// We checked above that the element type is comparable.
-			return AMEM, nil
-		case 1:
-			// Single-element array is same as its lone element.
-			return a, nil
-		}
-
-		return ASPECIAL, nil
-
-	case types.TSTRUCT:
-		fields := t.FieldSlice()
-
-		// One-field struct is same as that one field alone.
-		if len(fields) == 1 && !fields[0].Sym.IsBlank() {
-			return algtype1(fields[0].Type)
-		}
-
-		ret := AMEM
-		for i, f := range fields {
-			// All fields must be comparable.
-			a, bad := algtype1(f.Type)
-			if a == ANOEQ {
-				return ANOEQ, bad
-			}
-
-			// Blank fields, padded fields, fields with non-memory
-			// equality need special compare.
-			if a != AMEM || f.Sym.IsBlank() || ispaddedfield(t, i) {
-				ret = ASPECIAL
-			}
-		}
-
-		return ret, nil
-	}
-
-	base.Fatalf("algtype1: unexpected type %v", t)
-	return 0, nil
-}
-
 // genhash returns a symbol which is the closure used to compute
 // the hash of a value of type t.
 // Note: the generated function must match runtime.typehash exactly.
@@ -217,37 +71,37 @@ func genhash(t *types.Type) *obj.LSym {
 	default:
 		// genhash is only called for types that have equality
 		base.Fatalf("genhash %v", t)
-	case AMEM0:
+	case types.AMEM0:
 		return sysClosure("memhash0")
-	case AMEM8:
+	case types.AMEM8:
 		return sysClosure("memhash8")
-	case AMEM16:
+	case types.AMEM16:
 		return sysClosure("memhash16")
-	case AMEM32:
+	case types.AMEM32:
 		return sysClosure("memhash32")
-	case AMEM64:
+	case types.AMEM64:
 		return sysClosure("memhash64")
-	case AMEM128:
+	case types.AMEM128:
 		return sysClosure("memhash128")
-	case ASTRING:
+	case types.ASTRING:
 		return sysClosure("strhash")
-	case AINTER:
+	case types.AINTER:
 		return sysClosure("interhash")
-	case ANILINTER:
+	case types.ANILINTER:
 		return sysClosure("nilinterhash")
-	case AFLOAT32:
+	case types.AFLOAT32:
 		return sysClosure("f32hash")
-	case AFLOAT64:
+	case types.AFLOAT64:
 		return sysClosure("f64hash")
-	case ACPLX64:
+	case types.ACPLX64:
 		return sysClosure("c64hash")
-	case ACPLX128:
+	case types.ACPLX128:
 		return sysClosure("c128hash")
-	case AMEM:
+	case types.AMEM:
 		// For other sizes of plain memory, we build a closure
 		// that calls memhash_varlen. The size of the memory is
 		// encoded in the first slot of the closure.
-		closure := typeLookup(fmt.Sprintf(".hashfunc%d", t.Width)).Linksym()
+		closure := types.TypeSymLookup(fmt.Sprintf(".hashfunc%d", t.Width)).Linksym()
 		if len(closure.P) > 0 { // already generated
 			return closure
 		}
@@ -259,7 +113,7 @@ func genhash(t *types.Type) *obj.LSym {
 		ot = duintptr(closure, ot, uint64(t.Width)) // size encoded in closure
 		ggloblsym(closure, int32(ot), obj.DUPOK|obj.RODATA)
 		return closure
-	case ASPECIAL:
+	case types.ASPECIAL:
 		break
 	}
 
@@ -390,7 +244,7 @@ func genhash(t *types.Type) *obj.LSym {
 	Curfn = nil
 
 	if base.Debug.DclStack != 0 {
-		testdclstack()
+		types.CheckDclstack()
 	}
 
 	fn.SetNilCheckDisabled(true)
@@ -407,22 +261,22 @@ func genhash(t *types.Type) *obj.LSym {
 func hashfor(t *types.Type) ir.Node {
 	var sym *types.Sym
 
-	switch a, _ := algtype1(t); a {
-	case AMEM:
+	switch a, _ := types.AlgType(t); a {
+	case types.AMEM:
 		base.Fatalf("hashfor with AMEM type")
-	case AINTER:
+	case types.AINTER:
 		sym = Runtimepkg.Lookup("interhash")
-	case ANILINTER:
+	case types.ANILINTER:
 		sym = Runtimepkg.Lookup("nilinterhash")
-	case ASTRING:
+	case types.ASTRING:
 		sym = Runtimepkg.Lookup("strhash")
-	case AFLOAT32:
+	case types.AFLOAT32:
 		sym = Runtimepkg.Lookup("f32hash")
-	case AFLOAT64:
+	case types.AFLOAT64:
 		sym = Runtimepkg.Lookup("f64hash")
-	case ACPLX64:
+	case types.ACPLX64:
 		sym = Runtimepkg.Lookup("c64hash")
-	case ACPLX128:
+	case types.ACPLX128:
 		sym = Runtimepkg.Lookup("c128hash")
 	default:
 		// Note: the caller of hashfor ensured that this symbol
@@ -457,40 +311,40 @@ func sysClosure(name string) *obj.LSym {
 // equality for two objects of type t.
 func geneq(t *types.Type) *obj.LSym {
 	switch algtype(t) {
-	case ANOEQ:
+	case types.ANOEQ:
 		// The runtime will panic if it tries to compare
 		// a type with a nil equality function.
 		return nil
-	case AMEM0:
+	case types.AMEM0:
 		return sysClosure("memequal0")
-	case AMEM8:
+	case types.AMEM8:
 		return sysClosure("memequal8")
-	case AMEM16:
+	case types.AMEM16:
 		return sysClosure("memequal16")
-	case AMEM32:
+	case types.AMEM32:
 		return sysClosure("memequal32")
-	case AMEM64:
+	case types.AMEM64:
 		return sysClosure("memequal64")
-	case AMEM128:
+	case types.AMEM128:
 		return sysClosure("memequal128")
-	case ASTRING:
+	case types.ASTRING:
 		return sysClosure("strequal")
-	case AINTER:
+	case types.AINTER:
 		return sysClosure("interequal")
-	case ANILINTER:
+	case types.ANILINTER:
 		return sysClosure("nilinterequal")
-	case AFLOAT32:
+	case types.AFLOAT32:
 		return sysClosure("f32equal")
-	case AFLOAT64:
+	case types.AFLOAT64:
 		return sysClosure("f64equal")
-	case ACPLX64:
+	case types.ACPLX64:
 		return sysClosure("c64equal")
-	case ACPLX128:
+	case types.ACPLX128:
 		return sysClosure("c128equal")
-	case AMEM:
+	case types.AMEM:
 		// make equality closure. The size of the type
 		// is encoded in the closure.
-		closure := typeLookup(fmt.Sprintf(".eqfunc%d", t.Width)).Linksym()
+		closure := types.TypeSymLookup(fmt.Sprintf(".eqfunc%d", t.Width)).Linksym()
 		if len(closure.P) != 0 {
 			return closure
 		}
@@ -502,7 +356,7 @@ func geneq(t *types.Type) *obj.LSym {
 		ot = duintptr(closure, ot, uint64(t.Width))
 		ggloblsym(closure, int32(ot), obj.DUPOK|obj.RODATA)
 		return closure
-	case ASPECIAL:
+	case types.ASPECIAL:
 		break
 	}
 
@@ -766,7 +620,7 @@ func geneq(t *types.Type) *obj.LSym {
 	Curfn = nil
 
 	if base.Debug.DclStack != 0 {
-		testdclstack()
+		types.CheckDclstack()
 	}
 
 	// Disable checknils while compiling this code.
@@ -904,7 +758,7 @@ func memrun(t *types.Type, start int) (size int64, next int) {
 			break
 		}
 		// Stop run after a padded field.
-		if ispaddedfield(t, next-1) {
+		if types.IsPaddedField(t, next-1) {
 			break
 		}
 		// Also, stop before a blank or non-memory field.
@@ -914,16 +768,3 @@ func memrun(t *types.Type, start int) (size int64, next int) {
 	}
 	return t.Field(next-1).End() - t.Field(start).Offset, next
 }
-
-// ispaddedfield reports whether the i'th field of struct type t is followed
-// by padding.
-func ispaddedfield(t *types.Type, i int) bool {
-	if !t.IsStruct() {
-		base.Fatalf("ispaddedfield called non-struct %v", t)
-	}
-	end := t.Width
-	if i+1 < t.NumFields() {
-		end = t.Field(i + 1).Offset
-	}
-	return t.Field(i).End() != end
-}
diff --git a/src/cmd/compile/internal/gc/align.go b/src/cmd/compile/internal/gc/align.go
index f2f98bd51f..92826d003b 100644
--- a/src/cmd/compile/internal/gc/align.go
+++ b/src/cmd/compile/internal/gc/align.go
@@ -40,7 +40,7 @@ func expandiface(t *types.Type) {
 		switch prev := seen[m.Sym]; {
 		case prev == nil:
 			seen[m.Sym] = m
-		case langSupported(1, 14, t.Pkg()) && !explicit && types.Identical(m.Type, prev.Type):
+		case types.AllowsGoVersion(t.Pkg(), 1, 14) && !explicit && types.Identical(m.Type, prev.Type):
 			return
 		default:
 			base.ErrorfAt(m.Pos, "duplicate method %s", m.Sym.Name)
@@ -84,7 +84,7 @@ func expandiface(t *types.Type) {
 		}
 	}
 
-	sort.Sort(methcmp(methods))
+	sort.Sort(types.MethodsByName(methods))
 
 	if int64(len(methods)) >= MaxWidth/int64(Widthptr) {
 		base.ErrorfAt(typePos(t), "interface too large")
@@ -325,8 +325,8 @@ func dowidth(t *types.Type) {
 
 	// simtype == 0 during bootstrap
 	default:
-		if simtype[t.Kind()] != 0 {
-			et = simtype[t.Kind()]
+		if types.SimType[t.Kind()] != 0 {
+			et = types.SimType[t.Kind()]
 		}
 	}
 
diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 94bcf63263..553f06757f 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -242,11 +242,11 @@ func operandType(op ir.Op, t *types.Type) *types.Type {
 	switch op {
 	case ir.OCOMPLEX:
 		if t.IsComplex() {
-			return floatForComplex(t)
+			return types.FloatForComplex(t)
 		}
 	case ir.OREAL, ir.OIMAG:
 		if t.IsFloat() {
-			return complexForFloat(t)
+			return types.ComplexForFloat(t)
 		}
 	default:
 		if okfor[op][t.Kind()] {
@@ -377,7 +377,7 @@ func doesoverflow(v constant.Value, t *types.Type) bool {
 			return math.IsInf(f, 0)
 		}
 	case t.IsComplex():
-		ft := floatForComplex(t)
+		ft := types.FloatForComplex(t)
 		return doesoverflow(constant.Real(v), ft) || doesoverflow(constant.Imag(v), ft)
 	}
 	base.Fatalf("doesoverflow: %v, %v", v, t)
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 62cdff6b8e..5a5f670a08 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -28,12 +28,6 @@ func NoWriteBarrierRecCheck() {
 
 var nowritebarrierrecCheck *nowritebarrierrecChecker
 
-func testdclstack() {
-	if !types.IsDclstackValid() {
-		base.Fatalf("mark left on the dclstack")
-	}
-}
-
 // redeclare emits a diagnostic about symbol s being redeclared at pos.
 func redeclare(pos src.XPos, s *types.Sym, where string) {
 	if !s.Lastlineno.IsKnown() {
@@ -555,13 +549,6 @@ func fakeRecvField() *types.Field {
 	return types.NewField(src.NoXPos, nil, types.FakeRecvType())
 }
 
-// isifacemethod reports whether (field) m is
-// an interface method. Such methods have the
-// special receiver type types.FakeRecvType().
-func isifacemethod(f *types.Type) bool {
-	return f.Recv().Type == types.FakeRecvType()
-}
-
 // turn a parsed function declaration into a type
 func functype(nrecv *ir.Field, nparams, nresults []*ir.Field) *types.Type {
 	funarg := func(n *ir.Field) *types.Field {
@@ -685,7 +672,7 @@ func addmethod(n *ir.Func, msym *types.Sym, t *types.Type, local, nointerface bo
 		return nil
 	}
 
-	mt := methtype(rf.Type)
+	mt := types.ReceiverBaseType(rf.Type)
 	if mt == nil || mt.Sym() == nil {
 		pa := rf.Type
 		t := pa
@@ -883,7 +870,7 @@ func (c *nowritebarrierrecChecker) findExtraCalls(nn ir.Node) {
 	if fn.Class_ != ir.PFUNC || fn.Name().Defn == nil {
 		return
 	}
-	if !isRuntimePkg(fn.Sym().Pkg) || fn.Sym().Name != "systemstack" {
+	if !types.IsRuntimePkg(fn.Sym().Pkg) || fn.Sym().Name != "systemstack" {
 		return
 	}
 
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index fb9cbf2d51..4366a5cc2c 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -579,7 +579,7 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 		}
 	case ir.OCONVIFACE:
 		n := n.(*ir.ConvExpr)
-		if !n.X.Type().IsInterface() && !isdirectiface(n.X.Type()) {
+		if !n.X.Type().IsInterface() && !types.IsDirectIface(n.X.Type()) {
 			k = e.spill(k, n)
 		}
 		e.expr(k.note(n, "interface-converted"), n.X)
@@ -1064,7 +1064,7 @@ func (k EscHole) deref(where ir.Node, why string) EscHole { return k.shift(1).no
 func (k EscHole) addr(where ir.Node, why string) EscHole  { return k.shift(-1).note(where, why) }
 
 func (k EscHole) dotType(t *types.Type, where ir.Node, why string) EscHole {
-	if !t.IsInterface() && !isdirectiface(t) {
+	if !t.IsInterface() && !types.IsDirectIface(t) {
 		k = k.shift(1)
 	}
 	return k.note(where, why)
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index 46ddda0ba7..7ec59852ee 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -5,7 +5,6 @@
 package gc
 
 import (
-	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
@@ -34,22 +33,6 @@ var (
 	smallArrayBytes = int64(256)
 )
 
-// isRuntimePkg reports whether p is package runtime.
-func isRuntimePkg(p *types.Pkg) bool {
-	if base.Flag.CompilingRuntime && p == types.LocalPkg {
-		return true
-	}
-	return p.Path == "runtime"
-}
-
-// isReflectPkg reports whether p is package reflect.
-func isReflectPkg(p *types.Pkg) bool {
-	if p == types.LocalPkg {
-		return base.Ctxt.Pkgpath == "reflect"
-	}
-	return p.Path == "reflect"
-}
-
 // Slices in the runtime are represented by three components:
 //
 // type slice struct {
@@ -101,15 +84,6 @@ var gopkg *types.Pkg // pseudo-package for method symbols on anonymous receiver
 
 var zerosize int64
 
-var simtype [types.NTYPE]types.Kind
-
-var (
-	isInt     [types.NTYPE]bool
-	isFloat   [types.NTYPE]bool
-	isComplex [types.NTYPE]bool
-	issimple  [types.NTYPE]bool
-)
-
 var (
 	okforeq    [types.NTYPE]bool
 	okforadd   [types.NTYPE]bool
@@ -121,8 +95,6 @@ var (
 	okforarith [types.NTYPE]bool
 )
 
-var okforcmp [types.NTYPE]bool
-
 var (
 	okfor [ir.OEND][]bool
 	iscmp [ir.OEND]bool
diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go
index db55b1035c..da2345c289 100644
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ b/src/cmd/compile/internal/gc/gsubr.go
@@ -283,7 +283,7 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 
 	funcbody()
 	if base.Debug.DclStack != 0 {
-		testdclstack()
+		types.CheckDclstack()
 	}
 
 	typecheckFunc(fn)
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index d601331ee4..87db08e0d1 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -461,7 +461,7 @@ func (p *iexporter) doDecl(n *ir.Name) {
 		w.value(n.Type(), n.Val())
 
 	case ir.OTYPE:
-		if IsAlias(n.Sym()) {
+		if types.IsDotAlias(n.Sym()) {
 			// Alias.
 			w.tag('A')
 			w.pos(n.Pos())
@@ -1028,8 +1028,8 @@ func (w *exportWriter) typeExt(t *types.Type) {
 		w.int64(i[1])
 		return
 	}
-	w.symIdx(typesym(t))
-	w.symIdx(typesym(t.PtrTo()))
+	w.symIdx(types.TypeSym(t))
+	w.symIdx(types.TypeSym(t.PtrTo()))
 }
 
 // Inline bodies.
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 49e0bcc470..47fdc7b9b7 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -350,7 +350,7 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 		// runtime.throw is a "cheap call" like panic in normal code.
 		if n.X.Op() == ir.ONAME {
 			name := n.X.(*ir.Name)
-			if name.Class_ == ir.PFUNC && isRuntimePkg(name.Sym().Pkg) {
+			if name.Class_ == ir.PFUNC && types.IsRuntimePkg(name.Sym().Pkg) {
 				fn := name.Sym().Name
 				if fn == "getcallerpc" || fn == "getcallersp" {
 					return errors.New("call to " + fn)
@@ -382,7 +382,7 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 		if t == nil {
 			base.Fatalf("no function type for [%p] %+v\n", n.X, n.X)
 		}
-		if isRuntimePkg(n.X.Sym().Pkg) {
+		if types.IsRuntimePkg(n.X.Sym().Pkg) {
 			fn := n.X.Sym().Name
 			if fn == "heapBits.nextArena" {
 				// Special case: explicitly allow
@@ -589,7 +589,7 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.No
 		// Prevent inlining some reflect.Value methods when using checkptr,
 		// even when package reflect was compiled without it (#35073).
 		n := n.(*ir.CallExpr)
-		if s := n.X.Sym(); base.Debug.Checkptr != 0 && isReflectPkg(s.Pkg) && (s.Name == "Value.UnsafeAddr" || s.Name == "Value.Pointer") {
+		if s := n.X.Sym(); base.Debug.Checkptr != 0 && types.IsReflectPkg(s.Pkg) && (s.Name == "Value.UnsafeAddr" || s.Name == "Value.Pointer") {
 			return n
 		}
 	}
@@ -844,7 +844,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 		return n
 	}
 
-	if base.Flag.Cfg.Instrumenting && isRuntimePkg(fn.Sym().Pkg) {
+	if base.Flag.Cfg.Instrumenting && types.IsRuntimePkg(fn.Sym().Pkg) {
 		// Runtime package must not be instrumented.
 		// Instrument skips runtime package. However, some runtime code can be
 		// inlined into other packages and instrumented there. To avoid this,
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index feded3f9b2..15646ff8c7 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -23,13 +23,11 @@ import (
 	"flag"
 	"fmt"
 	"go/constant"
-	"internal/goversion"
 	"io"
 	"io/ioutil"
 	"log"
 	"os"
 	"path"
-	"regexp"
 	"runtime"
 	"sort"
 	"strconv"
@@ -153,7 +151,7 @@ func Main(archInit func(*Arch)) {
 		log.Fatalf("location lists requested but register mapping not available on %v", base.Ctxt.Arch.Name)
 	}
 
-	checkLang()
+	types.ParseLangFlag()
 
 	if base.Flag.SymABIs != "" {
 		readSymABIs(base.Flag.SymABIs, base.Ctxt.Pkgpath)
@@ -858,7 +856,7 @@ func clearImports() {
 			s.Def = nil
 			continue
 		}
-		if IsAlias(s) {
+		if types.IsDotAlias(s) {
 			// throw away top-level name left over
 			// from previous import . "x"
 			// We'll report errors after type checking in checkDotImports.
@@ -873,10 +871,6 @@ func clearImports() {
 	}
 }
 
-func IsAlias(sym *types.Sym) bool {
-	return sym.Def != nil && sym.Def.Sym() != sym
-}
-
 // recordFlags records the specified command-line flags to be placed
 // in the DWARF info.
 func recordFlags(flags ...string) {
@@ -944,89 +938,6 @@ func recordPackageName() {
 	s.P = []byte(types.LocalPkg.Name)
 }
 
-// currentLang returns the current language version.
-func currentLang() string {
-	return fmt.Sprintf("go1.%d", goversion.Version)
-}
-
-// goVersionRE is a regular expression that matches the valid
-// arguments to the -lang flag.
-var goVersionRE = regexp.MustCompile(`^go([1-9][0-9]*)\.(0|[1-9][0-9]*)$`)
-
-// A lang is a language version broken into major and minor numbers.
-type lang struct {
-	major, minor int
-}
-
-// langWant is the desired language version set by the -lang flag.
-// If the -lang flag is not set, this is the zero value, meaning that
-// any language version is supported.
-var langWant lang
-
-// AllowsGoVersion reports whether a particular package
-// is allowed to use Go version major.minor.
-// We assume the imported packages have all been checked,
-// so we only have to check the local package against the -lang flag.
-func AllowsGoVersion(pkg *types.Pkg, major, minor int) bool {
-	if pkg == nil {
-		// TODO(mdempsky): Set Pkg for local types earlier.
-		pkg = types.LocalPkg
-	}
-	if pkg != types.LocalPkg {
-		// Assume imported packages passed type-checking.
-		return true
-	}
-	if langWant.major == 0 && langWant.minor == 0 {
-		return true
-	}
-	return langWant.major > major || (langWant.major == major && langWant.minor >= minor)
-}
-
-func langSupported(major, minor int, pkg *types.Pkg) bool {
-	return AllowsGoVersion(pkg, major, minor)
-}
-
-// checkLang verifies that the -lang flag holds a valid value, and
-// exits if not. It initializes data used by langSupported.
-func checkLang() {
-	if base.Flag.Lang == "" {
-		return
-	}
-
-	var err error
-	langWant, err = parseLang(base.Flag.Lang)
-	if err != nil {
-		log.Fatalf("invalid value %q for -lang: %v", base.Flag.Lang, err)
-	}
-
-	if def := currentLang(); base.Flag.Lang != def {
-		defVers, err := parseLang(def)
-		if err != nil {
-			log.Fatalf("internal error parsing default lang %q: %v", def, err)
-		}
-		if langWant.major > defVers.major || (langWant.major == defVers.major && langWant.minor > defVers.minor) {
-			log.Fatalf("invalid value %q for -lang: max known version is %q", base.Flag.Lang, def)
-		}
-	}
-}
-
-// parseLang parses a -lang option into a langVer.
-func parseLang(s string) (lang, error) {
-	matches := goVersionRE.FindStringSubmatch(s)
-	if matches == nil {
-		return lang{}, fmt.Errorf(`should be something like "go1.12"`)
-	}
-	major, err := strconv.Atoi(matches[1])
-	if err != nil {
-		return lang{}, err
-	}
-	minor, err := strconv.Atoi(matches[2])
-	if err != nil {
-		return lang{}, err
-	}
-	return lang{major: major, minor: minor}, nil
-}
-
 // useNewABIWrapGen returns TRUE if the compiler should generate an
 // ABI wrapper for the function 'f'.
 func useABIWrapGen(f *ir.Func) bool {
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index bed37efb87..77a45f0023 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -72,7 +72,7 @@ func parseFiles(filenames []string) uint {
 			base.ErrorExit()
 		}
 		// Always run testdclstack here, even when debug_dclstack is not set, as a sanity measure.
-		testdclstack()
+		types.CheckDclstack()
 	}
 
 	for _, p := range noders {
@@ -485,7 +485,7 @@ func (p *noder) typeDecl(decl *syntax.TypeDecl) ir.Node {
 	}
 
 	nod := ir.NewDecl(p.pos(decl), ir.ODCLTYPE, n)
-	if n.Alias() && !langSupported(1, 9, types.LocalPkg) {
+	if n.Alias() && !types.AllowsGoVersion(types.LocalPkg, 1, 9) {
 		base.ErrorfAt(nod.Pos(), "type aliases only supported as of -lang=go1.9")
 	}
 	return nod
@@ -1401,7 +1401,7 @@ func (p *noder) binOp(op syntax.Operator) ir.Op {
 // literal is not compatible with the current language version.
 func checkLangCompat(lit *syntax.BasicLit) {
 	s := lit.Value
-	if len(s) <= 2 || langSupported(1, 13, types.LocalPkg) {
+	if len(s) <= 2 || types.AllowsGoVersion(types.LocalPkg, 1, 13) {
 		return
 	}
 	// len(s) > 2
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 9634cd51ae..883033e0c2 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -259,7 +259,7 @@ func dumpGlobalConst(n ir.Node) {
 			return
 		}
 	}
-	base.Ctxt.DwarfIntConst(base.Ctxt.Pkgpath, n.Sym().Name, typesymname(t), ir.IntVal(t, v))
+	base.Ctxt.DwarfIntConst(base.Ctxt.Pkgpath, n.Sym().Name, types.TypeSymName(t), ir.IntVal(t, v))
 }
 
 func dumpglobls(externs []ir.Node) {
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 738b403b99..9e792d153c 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -1332,7 +1332,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 	case ir.ODOTTYPE, ir.ODOTTYPE2:
 		n := n.(*ir.TypeAssertExpr)
 		n.X = o.expr(n.X, nil)
-		if !isdirectiface(n.Type()) || base.Flag.Cfg.Instrumenting {
+		if !types.IsDirectIface(n.Type()) || base.Flag.Cfg.Instrumenting {
 			return o.copyExprClear(n)
 		}
 		return n
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index 785e01663f..d6c15f113b 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -552,7 +552,7 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 		base.Fatalf("createSimpleVar unexpected class %v for node %v", n.Class_, n)
 	}
 
-	typename := dwarf.InfoPrefix + typesymname(n.Type())
+	typename := dwarf.InfoPrefix + types.TypeSymName(n.Type())
 	delete(fnsym.Func().Autot, ngotype(n).Linksym())
 	inlIndex := 0
 	if base.Flag.GenDwarfInl > 1 {
@@ -655,7 +655,7 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 			decls = append(decls, n)
 			continue
 		}
-		typename := dwarf.InfoPrefix + typesymname(n.Type())
+		typename := dwarf.InfoPrefix + types.TypeSymName(n.Type())
 		decls = append(decls, n)
 		abbrev := dwarf.DW_ABRV_AUTO_LOCLIST
 		isReturnValue := (n.Class_ == ir.PPARAMOUT)
diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index 078f03bc68..463d0c55bd 100644
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -493,7 +493,7 @@ func isMapClear(n *ir.RangeStmt) bool {
 	}
 
 	// Keys where equality is not reflexive can not be deleted from maps.
-	if !isreflexive(m.Type().Key()) {
+	if !types.IsReflexive(m.Type().Key()) {
 		return false
 	}
 
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 07552e64b4..12fc6b7fa7 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -135,7 +135,7 @@ func bmap(t *types.Type) *types.Type {
 	dowidth(bucket)
 
 	// Check invariants that map code depends on.
-	if !IsComparable(t.Key()) {
+	if !types.IsComparable(t.Key()) {
 		base.Fatalf("unsupported map key type for %v", t)
 	}
 	if BUCKETSIZE < 8 {
@@ -373,7 +373,7 @@ func methodfunc(f *types.Type, receiver *types.Type) *types.Type {
 // Generates stub functions as needed.
 func methods(t *types.Type) []*Sig {
 	// method type
-	mt := methtype(t)
+	mt := types.ReceiverBaseType(t)
 
 	if mt == nil {
 		return nil
@@ -383,7 +383,7 @@ func methods(t *types.Type) []*Sig {
 	// type stored in interface word
 	it := t
 
-	if !isdirectiface(it) {
+	if !types.IsDirectIface(it) {
 		it = types.NewPtr(t)
 	}
 
@@ -410,7 +410,7 @@ func methods(t *types.Type) []*Sig {
 		// if pointer receiver but non-pointer t and
 		// this is not an embedded pointer inside a struct,
 		// method does not apply.
-		if !isMethodApplicable(t, f) {
+		if !types.IsMethodApplicable(t, f) {
 			continue
 		}
 
@@ -848,7 +848,7 @@ func dcommontype(lsym *obj.LSym, t *types.Type) int {
 	ot := 0
 	ot = duintptr(lsym, ot, uint64(t.Width))
 	ot = duintptr(lsym, ot, uint64(ptrdata))
-	ot = duint32(lsym, ot, typehash(t))
+	ot = duint32(lsym, ot, types.TypeHash(t))
 
 	var tflag uint8
 	if uncommonSize(t) != 0 {
@@ -895,7 +895,7 @@ func dcommontype(lsym *obj.LSym, t *types.Type) int {
 	ot = duint8(lsym, ot, t.Align) // fieldAlign
 
 	i = kinds[t.Kind()]
-	if isdirectiface(t) {
+	if types.IsDirectIface(t) {
 		i |= objabi.KindDirectIface
 	}
 	if useGCProg {
@@ -923,40 +923,6 @@ func dcommontype(lsym *obj.LSym, t *types.Type) int {
 	return ot
 }
 
-// typeHasNoAlg reports whether t does not have any associated hash/eq
-// algorithms because t, or some component of t, is marked Noalg.
-func typeHasNoAlg(t *types.Type) bool {
-	a, bad := algtype1(t)
-	return a == ANOEQ && bad.Noalg()
-}
-
-func typesymname(t *types.Type) string {
-	name := t.ShortString()
-	// Use a separate symbol name for Noalg types for #17752.
-	if typeHasNoAlg(t) {
-		name = "noalg." + name
-	}
-	return name
-}
-
-// Fake package for runtime type info (headers)
-// Don't access directly, use typeLookup below.
-var (
-	typepkgmu sync.Mutex // protects typepkg lookups
-	typepkg   = types.NewPkg("type", "type")
-)
-
-func typeLookup(name string) *types.Sym {
-	typepkgmu.Lock()
-	s := typepkg.Lookup(name)
-	typepkgmu.Unlock()
-	return s
-}
-
-func typesym(t *types.Type) *types.Sym {
-	return typeLookup(typesymname(t))
-}
-
 // tracksym returns the symbol for tracking use of field/method f, assumed
 // to be a member of struct/interface type t.
 func tracksym(t *types.Type, f *types.Field) *types.Sym {
@@ -965,7 +931,7 @@ func tracksym(t *types.Type, f *types.Field) *types.Sym {
 
 func typesymprefix(prefix string, t *types.Type) *types.Sym {
 	p := prefix + "." + t.ShortString()
-	s := typeLookup(p)
+	s := types.TypeSymLookup(p)
 
 	// This function is for looking up type-related generated functions
 	// (e.g. eq and hash). Make sure they are indeed generated.
@@ -982,7 +948,7 @@ func typenamesym(t *types.Type) *types.Sym {
 	if t == nil || (t.IsPtr() && t.Elem() == nil) || t.IsUntyped() {
 		base.Fatalf("typenamesym %v", t)
 	}
-	s := typesym(t)
+	s := types.TypeSym(t)
 	signatmu.Lock()
 	addsignat(t)
 	signatmu.Unlock()
@@ -1025,52 +991,6 @@ func itabname(t, itype *types.Type) *ir.AddrExpr {
 	return n
 }
 
-// isreflexive reports whether t has a reflexive equality operator.
-// That is, if x==x for all x of type t.
-func isreflexive(t *types.Type) bool {
-	switch t.Kind() {
-	case types.TBOOL,
-		types.TINT,
-		types.TUINT,
-		types.TINT8,
-		types.TUINT8,
-		types.TINT16,
-		types.TUINT16,
-		types.TINT32,
-		types.TUINT32,
-		types.TINT64,
-		types.TUINT64,
-		types.TUINTPTR,
-		types.TPTR,
-		types.TUNSAFEPTR,
-		types.TSTRING,
-		types.TCHAN:
-		return true
-
-	case types.TFLOAT32,
-		types.TFLOAT64,
-		types.TCOMPLEX64,
-		types.TCOMPLEX128,
-		types.TINTER:
-		return false
-
-	case types.TARRAY:
-		return isreflexive(t.Elem())
-
-	case types.TSTRUCT:
-		for _, t1 := range t.Fields().Slice() {
-			if !isreflexive(t1.Type) {
-				return false
-			}
-		}
-		return true
-
-	default:
-		base.Fatalf("bad type for map key: %v", t)
-		return false
-	}
-}
-
 // needkeyupdate reports whether map updates with t as a key
 // need the key to be updated.
 func needkeyupdate(t *types.Type) bool {
@@ -1139,7 +1059,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 		base.Fatalf("dtypesym %v", t)
 	}
 
-	s := typesym(t)
+	s := types.TypeSym(t)
 	lsym := s.Linksym()
 	if s.Siggen() {
 		return lsym
@@ -1310,7 +1230,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 			ot = duint8(lsym, ot, uint8(t.Elem().Width))
 		}
 		ot = duint16(lsym, ot, uint16(bmap(t).Width))
-		if isreflexive(t.Key()) {
+		if types.IsReflexive(t.Key()) {
 			flags |= 4 // reflexive key
 		}
 		if needkeyupdate(t.Key()) {
@@ -1404,7 +1324,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 		}
 	}
 	// Do not put Noalg types in typelinks.  See issue #22605.
-	if typeHasNoAlg(t) {
+	if types.TypeHasNoAlg(t) {
 		keep = false
 	}
 	lsym.Set(obj.AttrMakeTypelink, keep)
@@ -1528,7 +1448,7 @@ func dumpsignats() {
 		signats = signats[:0]
 		// Transfer entries to a slice and sort, for reproducible builds.
 		for _, t := range signatslice {
-			signats = append(signats, typeAndStr{t: t, short: typesymname(t), regular: t.String()})
+			signats = append(signats, typeAndStr{t: t, short: types.TypeSymName(t), regular: t.String()})
 			delete(signatset, t)
 		}
 		signatslice = signatslice[:0]
@@ -1556,8 +1476,8 @@ func dumptabs() {
 		// }
 		o := dsymptr(i.lsym, 0, dtypesym(i.itype), 0)
 		o = dsymptr(i.lsym, o, dtypesym(i.t), 0)
-		o = duint32(i.lsym, o, typehash(i.t)) // copy of type hash
-		o += 4                                // skip unused field
+		o = duint32(i.lsym, o, types.TypeHash(i.t)) // copy of type hash
+		o += 4                                      // skip unused field
 		for _, fn := range genfun(i.t, i.itype) {
 			o = dsymptr(i.lsym, o, fn, 0) // method pointer for each method
 		}
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 9445627b41..c9a554079d 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -324,7 +324,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 		addrsym(l, loff, itab.X.(*ir.Name), 0)
 
 		// Emit data.
-		if isdirectiface(val.Type()) {
+		if types.IsDirectIface(val.Type()) {
 			if val.Op() == ir.ONIL {
 				// Nil is zero, nothing to do.
 				return true
@@ -506,7 +506,7 @@ func isStaticCompositeLiteral(n ir.Node) bool {
 		if val.Type().IsInterface() {
 			return val.Op() == ir.ONIL
 		}
-		if isdirectiface(val.Type()) && val.Op() == ir.ONIL {
+		if types.IsDirectIface(val.Type()) && val.Op() == ir.ONIL {
 			return true
 		}
 		return isStaticCompositeLiteral(val)
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 0bca2baa17..722a3257da 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -1916,28 +1916,6 @@ func (s *state) ssaOp(op ir.Op, t *types.Type) ssa.Op {
 	return x
 }
 
-func floatForComplex(t *types.Type) *types.Type {
-	switch t.Kind() {
-	case types.TCOMPLEX64:
-		return types.Types[types.TFLOAT32]
-	case types.TCOMPLEX128:
-		return types.Types[types.TFLOAT64]
-	}
-	base.Fatalf("unexpected type: %v", t)
-	return nil
-}
-
-func complexForFloat(t *types.Type) *types.Type {
-	switch t.Kind() {
-	case types.TFLOAT32:
-		return types.Types[types.TCOMPLEX64]
-	case types.TFLOAT64:
-		return types.Types[types.TCOMPLEX128]
-	}
-	base.Fatalf("unexpected type: %v", t)
-	return nil
-}
-
 type opAndTwoTypes struct {
 	op     ir.Op
 	etype1 types.Kind
@@ -2458,8 +2436,8 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 			} else {
 				s.Fatalf("weird complex conversion %v -> %v", ft, tt)
 			}
-			ftp := floatForComplex(ft)
-			ttp := floatForComplex(tt)
+			ftp := types.FloatForComplex(ft)
+			ttp := types.FloatForComplex(tt)
 			return s.newValue2(ssa.OpComplexMake, tt,
 				s.newValueOrSfCall1(op, ttp, s.newValue1(ssa.OpComplexReal, ftp, x)),
 				s.newValueOrSfCall1(op, ttp, s.newValue1(ssa.OpComplexImag, ftp, x)))
@@ -2479,7 +2457,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		a := s.expr(n.X)
 		b := s.expr(n.Y)
 		if n.X.Type().IsComplex() {
-			pt := floatForComplex(n.X.Type())
+			pt := types.FloatForComplex(n.X.Type())
 			op := s.ssaOp(ir.OEQ, pt)
 			r := s.newValueOrSfCall2(op, types.Types[types.TBOOL], s.newValue1(ssa.OpComplexReal, pt, a), s.newValue1(ssa.OpComplexReal, pt, b))
 			i := s.newValueOrSfCall2(op, types.Types[types.TBOOL], s.newValue1(ssa.OpComplexImag, pt, a), s.newValue1(ssa.OpComplexImag, pt, b))
@@ -2516,8 +2494,8 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 			mulop := ssa.OpMul64F
 			addop := ssa.OpAdd64F
 			subop := ssa.OpSub64F
-			pt := floatForComplex(n.Type())   // Could be Float32 or Float64
-			wt := types.Types[types.TFLOAT64] // Compute in Float64 to minimize cancellation error
+			pt := types.FloatForComplex(n.Type()) // Could be Float32 or Float64
+			wt := types.Types[types.TFLOAT64]     // Compute in Float64 to minimize cancellation error
 
 			areal := s.newValue1(ssa.OpComplexReal, pt, a)
 			breal := s.newValue1(ssa.OpComplexReal, pt, b)
@@ -2560,8 +2538,8 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 			addop := ssa.OpAdd64F
 			subop := ssa.OpSub64F
 			divop := ssa.OpDiv64F
-			pt := floatForComplex(n.Type())   // Could be Float32 or Float64
-			wt := types.Types[types.TFLOAT64] // Compute in Float64 to minimize cancellation error
+			pt := types.FloatForComplex(n.Type()) // Could be Float32 or Float64
+			wt := types.Types[types.TFLOAT64]     // Compute in Float64 to minimize cancellation error
 
 			areal := s.newValue1(ssa.OpComplexReal, pt, a)
 			breal := s.newValue1(ssa.OpComplexReal, pt, b)
@@ -2606,7 +2584,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		a := s.expr(n.X)
 		b := s.expr(n.Y)
 		if n.Type().IsComplex() {
-			pt := floatForComplex(n.Type())
+			pt := types.FloatForComplex(n.Type())
 			op := s.ssaOp(n.Op(), pt)
 			return s.newValue2(ssa.OpComplexMake, n.Type(),
 				s.newValueOrSfCall2(op, pt, s.newValue1(ssa.OpComplexReal, pt, a), s.newValue1(ssa.OpComplexReal, pt, b)),
@@ -2694,7 +2672,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		n := n.(*ir.UnaryExpr)
 		a := s.expr(n.X)
 		if n.Type().IsComplex() {
-			tp := floatForComplex(n.Type())
+			tp := types.FloatForComplex(n.Type())
 			negop := s.ssaOp(n.Op(), tp)
 			return s.newValue2(ssa.OpComplexMake, n.Type(),
 				s.newValue1(negop, tp, s.newValue1(ssa.OpComplexReal, tp, a)),
@@ -6147,7 +6125,7 @@ func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Val
 	}
 
 	// Converting to a concrete type.
-	direct := isdirectiface(n.Type())
+	direct := types.IsDirectIface(n.Type())
 	itab := s.newValue1(ssa.OpITab, byteptr, iface) // type word of interface
 	if base.Debug.TypeAssert > 0 {
 		base.WarnfAt(n.Pos(), "type assertion inlined")
@@ -6442,7 +6420,7 @@ func emitStackObjects(e *ssafn, pp *Progs) {
 		// in which case the offset is relative to argp.
 		// Locals have a negative Xoffset, in which case the offset is relative to varp.
 		off = duintptr(x, off, uint64(v.FrameOffset()))
-		if !typesym(v.Type()).Siggen() {
+		if !types.TypeSym(v.Type()).Siggen() {
 			e.Fatalf(v.Pos(), "stack object's type symbol not generated for type %s", v.Type())
 		}
 		off = dsymptr(x, off, dtypesym(v.Type()), 0)
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 6e130d4889..d8956633b2 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -9,8 +9,6 @@ import (
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
-	"crypto/md5"
-	"encoding/binary"
 	"fmt"
 	"go/constant"
 	"sort"
@@ -170,13 +168,6 @@ func NewName(s *types.Sym) *ir.Name {
 	return n
 }
 
-// methcmp sorts methods by symbol.
-type methcmp []*types.Field
-
-func (x methcmp) Len() int           { return len(x) }
-func (x methcmp) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
-func (x methcmp) Less(i, j int) bool { return x[i].Sym.Less(x[j].Sym) }
-
 func nodintconst(v int64) ir.Node {
 	return ir.NewLiteral(constant.MakeInt64(v))
 }
@@ -212,41 +203,6 @@ func isptrto(t *types.Type, et types.Kind) bool {
 	return true
 }
 
-// methtype returns the underlying type, if any,
-// that owns methods with receiver parameter t.
-// The result is either a named type or an anonymous struct.
-func methtype(t *types.Type) *types.Type {
-	if t == nil {
-		return nil
-	}
-
-	// Strip away pointer if it's there.
-	if t.IsPtr() {
-		if t.Sym() != nil {
-			return nil
-		}
-		t = t.Elem()
-		if t == nil {
-			return nil
-		}
-	}
-
-	// Must be a named type or anonymous struct.
-	if t.Sym() == nil && !t.IsStruct() {
-		return nil
-	}
-
-	// Check types.
-	if issimple[t.Kind()] {
-		return t
-	}
-	switch t.Kind() {
-	case types.TARRAY, types.TCHAN, types.TFUNC, types.TMAP, types.TSLICE, types.TSTRING, types.TSTRUCT:
-		return t
-	}
-	return nil
-}
-
 // Is type src assignment compatible to type dst?
 // If so, return op code to use in conversion.
 // If not, return OXXX. In this case, the string return parameter may
@@ -294,7 +250,7 @@ func assignop(src, dst *types.Type) (ir.Op, string) {
 			// gets added to itabs early, which allows
 			// us to de-virtualize calls through this
 			// type/interface pair later. See peekitabs in reflect.go
-			if isdirectiface(src) && !dst.IsEmptyInterface() {
+			if types.IsDirectIface(src) && !dst.IsEmptyInterface() {
 				NeedITab(src, dst)
 			}
 
@@ -429,7 +385,7 @@ func convertop(srcConstant bool, src, dst *types.Type) (ir.Op, string) {
 
 	// 4. src and dst are both integer or floating point types.
 	if (src.IsInteger() || src.IsFloat()) && (dst.IsInteger() || dst.IsFloat()) {
-		if simtype[src.Kind()] == simtype[dst.Kind()] {
+		if types.SimType[src.Kind()] == types.SimType[dst.Kind()] {
 			return ir.OCONVNOP, ""
 		}
 		return ir.OCONV, ""
@@ -437,7 +393,7 @@ func convertop(srcConstant bool, src, dst *types.Type) (ir.Op, string) {
 
 	// 5. src and dst are both complex types.
 	if src.IsComplex() && dst.IsComplex() {
-		if simtype[src.Kind()] == simtype[dst.Kind()] {
+		if types.SimType[src.Kind()] == types.SimType[dst.Kind()] {
 			return ir.OCONVNOP, ""
 		}
 		return ir.OCONV, ""
@@ -574,15 +530,6 @@ func syslook(name string) *ir.Name {
 	return ir.AsNode(s.Def).(*ir.Name)
 }
 
-// typehash computes a hash value for type t to use in type switch statements.
-func typehash(t *types.Type) uint32 {
-	p := t.LongString()
-
-	// Using MD5 is overkill, but reduces accidental collisions.
-	h := md5.Sum([]byte(p))
-	return binary.LittleEndian.Uint32(h[:4])
-}
-
 // updateHasCall checks whether expression n contains any function
 // calls and sets the n.HasCall flag if so.
 func updateHasCall(n ir.Node) {
@@ -627,25 +574,25 @@ func calcHasCall(n ir.Node) bool {
 	// so we ensure they are evaluated first.
 	case ir.OADD, ir.OSUB, ir.OMUL:
 		n := n.(*ir.BinaryExpr)
-		if thearch.SoftFloat && (isFloat[n.Type().Kind()] || isComplex[n.Type().Kind()]) {
+		if thearch.SoftFloat && (types.IsFloat[n.Type().Kind()] || types.IsComplex[n.Type().Kind()]) {
 			return true
 		}
 		return n.X.HasCall() || n.Y.HasCall()
 	case ir.ONEG:
 		n := n.(*ir.UnaryExpr)
-		if thearch.SoftFloat && (isFloat[n.Type().Kind()] || isComplex[n.Type().Kind()]) {
+		if thearch.SoftFloat && (types.IsFloat[n.Type().Kind()] || types.IsComplex[n.Type().Kind()]) {
 			return true
 		}
 		return n.X.HasCall()
 	case ir.OLT, ir.OEQ, ir.ONE, ir.OLE, ir.OGE, ir.OGT:
 		n := n.(*ir.BinaryExpr)
-		if thearch.SoftFloat && (isFloat[n.X.Type().Kind()] || isComplex[n.X.Type().Kind()]) {
+		if thearch.SoftFloat && (types.IsFloat[n.X.Type().Kind()] || types.IsComplex[n.X.Type().Kind()]) {
 			return true
 		}
 		return n.X.HasCall() || n.Y.HasCall()
 	case ir.OCONV:
 		n := n.(*ir.ConvExpr)
-		if thearch.SoftFloat && ((isFloat[n.Type().Kind()] || isComplex[n.Type().Kind()]) || (isFloat[n.X.Type().Kind()] || isComplex[n.X.Type().Kind()])) {
+		if thearch.SoftFloat && ((types.IsFloat[n.Type().Kind()] || types.IsComplex[n.Type().Kind()]) || (types.IsFloat[n.X.Type().Kind()] || types.IsComplex[n.X.Type().Kind()])) {
 			return true
 		}
 		return n.X.HasCall()
@@ -893,7 +840,7 @@ func lookdot0(s *types.Sym, t *types.Type, save **types.Field, ignorecase bool)
 		// If t is a defined pointer type, then x.m is shorthand for (*x).m.
 		u = t.Elem()
 	}
-	u = methtype(u)
+	u = types.ReceiverBaseType(u)
 	if u != nil {
 		for _, f := range u.Methods().Slice() {
 			if f.Embedded == 0 && (f.Sym == s || (ignorecase && strings.EqualFold(f.Sym.Name, s.Name))) {
@@ -1056,7 +1003,7 @@ func expand0(t *types.Type) {
 		return
 	}
 
-	u = methtype(t)
+	u = types.ReceiverBaseType(t)
 	if u != nil {
 		for _, f := range u.Methods().Slice() {
 			if f.Sym.Uniq() {
@@ -1147,7 +1094,7 @@ func expandmeth(t *types.Type) {
 	}
 
 	ms = append(ms, t.Methods().Slice()...)
-	sort.Sort(methcmp(ms))
+	sort.Sort(types.MethodsByName(ms))
 	t.AllMethods().Set(ms)
 }
 
@@ -1243,7 +1190,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	// the TOC to the appropriate value for that module. But if it returns
 	// directly to the wrapper's caller, nothing will reset it to the correct
 	// value for that function.
-	if !base.Flag.Cfg.Instrumenting && rcvr.IsPtr() && methodrcvr.IsPtr() && method.Embedded != 0 && !isifacemethod(method.Type) && !(thearch.LinkArch.Name == "ppc64le" && base.Ctxt.Flag_dynlink) {
+	if !base.Flag.Cfg.Instrumenting && rcvr.IsPtr() && methodrcvr.IsPtr() && method.Embedded != 0 && !types.IsInterfaceMethod(method.Type) && !(thearch.LinkArch.Name == "ppc64le" && base.Ctxt.Flag_dynlink) {
 		// generate tail call: adjust pointer receiver and jump to embedded method.
 		left := dot.X // skip final .M
 		if !left.Type().IsPtr() {
@@ -1272,7 +1219,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 
 	funcbody()
 	if base.Debug.DclStack != 0 {
-		testdclstack()
+		types.CheckDclstack()
 	}
 
 	typecheckFunc(fn)
@@ -1373,7 +1320,7 @@ func implements(t, iface *types.Type, m, samename **types.Field, ptr *int) bool
 		return true
 	}
 
-	t = methtype(t)
+	t = types.ReceiverBaseType(t)
 	var tms []*types.Field
 	if t != nil {
 		expandmeth(t)
@@ -1405,7 +1352,7 @@ func implements(t, iface *types.Type, m, samename **types.Field, ptr *int) bool
 		// if pointer receiver in method,
 		// the method does not exist for value types.
 		rcvr := tm.Type.Recv().Type
-		if rcvr.IsPtr() && !t0.IsPtr() && !followptr && !isifacemethod(tm.Type) {
+		if rcvr.IsPtr() && !t0.IsPtr() && !followptr && !types.IsInterfaceMethod(tm.Type) {
 			if false && base.Flag.LowerR != 0 {
 				base.Errorf("interface pointer mismatch")
 			}
@@ -1508,35 +1455,6 @@ func isbadimport(path string, allowSpace bool) bool {
 	return false
 }
 
-// Can this type be stored directly in an interface word?
-// Yes, if the representation is a single pointer.
-func isdirectiface(t *types.Type) bool {
-	if t.Broke() {
-		return false
-	}
-
-	switch t.Kind() {
-	case types.TPTR:
-		// Pointers to notinheap types must be stored indirectly. See issue 42076.
-		return !t.Elem().NotInHeap()
-	case types.TCHAN,
-		types.TMAP,
-		types.TFUNC,
-		types.TUNSAFEPTR:
-		return true
-
-	case types.TARRAY:
-		// Array of 1 direct iface type can be direct.
-		return t.NumElem() == 1 && isdirectiface(t.Elem())
-
-	case types.TSTRUCT:
-		// Struct with 1 field of direct iface type can be direct.
-		return t.NumFields() == 1 && isdirectiface(t.Field(0).Type)
-	}
-
-	return false
-}
-
 // itabType loads the _type field from a runtime.itab struct.
 func itabType(itab ir.Node) ir.Node {
 	typ := ir.NewSelectorExpr(base.Pos, ir.ODOTPTR, itab, nil)
@@ -1555,7 +1473,7 @@ func ifaceData(pos src.XPos, n ir.Node, t *types.Type) ir.Node {
 		base.Fatalf("ifaceData interface: %v", t)
 	}
 	ptr := ir.NewUnaryExpr(pos, ir.OIDATA, n)
-	if isdirectiface(t) {
+	if types.IsDirectIface(t) {
 		ptr.SetType(t)
 		ptr.SetTypecheck(1)
 		return ptr
diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index ab241a3813..513b890355 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -166,9 +166,9 @@ func typecheckExprSwitch(n *ir.SwitchStmt) {
 		case t.IsSlice():
 			nilonly = "slice"
 
-		case !IsComparable(t):
+		case !types.IsComparable(t):
 			if t.IsStruct() {
-				base.ErrorfAt(n.Pos(), "cannot switch on %L (struct containing %v cannot be compared)", n.Tag, IncomparableField(t).Type)
+				base.ErrorfAt(n.Pos(), "cannot switch on %L (struct containing %v cannot be compared)", n.Tag, types.IncomparableField(t).Type)
 			} else {
 				base.ErrorfAt(n.Pos(), "cannot switch on %L", n.Tag)
 			}
@@ -200,7 +200,7 @@ func typecheckExprSwitch(n *ir.SwitchStmt) {
 
 			if nilonly != "" && !ir.IsNil(n1) {
 				base.ErrorfAt(ncase.Pos(), "invalid case %v in switch (can only compare %s %v to nil)", n1, nilonly, n.Tag)
-			} else if t.IsInterface() && !n1.Type().IsInterface() && !IsComparable(n1.Type()) {
+			} else if t.IsInterface() && !n1.Type().IsInterface() && !types.IsComparable(n1.Type()) {
 				base.ErrorfAt(ncase.Pos(), "invalid case %L in switch (incomparable type)", n1)
 			} else {
 				op1, _ := assignop(n1.Type(), t)
@@ -339,7 +339,7 @@ type exprClause struct {
 
 func (s *exprSwitch) Add(pos src.XPos, expr, jmp ir.Node) {
 	c := exprClause{pos: pos, lo: expr, hi: expr, jmp: jmp}
-	if okforcmp[s.exprname.Type().Kind()] && expr.Op() == ir.OLITERAL {
+	if types.IsOrdered[s.exprname.Type().Kind()] && expr.Op() == ir.OLITERAL {
 		s.clauses = append(s.clauses, c)
 		return
 	}
@@ -670,7 +670,7 @@ func (s *typeSwitch) Add(pos src.XPos, typ *types.Type, caseVar, jmp ir.Node) {
 
 	if !typ.IsInterface() {
 		s.clauses = append(s.clauses, typeClause{
-			hash: typehash(typ),
+			hash: types.TypeHash(typ),
 			body: body,
 		})
 		return
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 4f1fe240ec..5e13facc4f 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -837,7 +837,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				n.SetType(nil)
 				return n
 			}
-			if t.IsSigned() && !langSupported(1, 13, curpkg()) {
+			if t.IsSigned() && !types.AllowsGoVersion(curpkg(), 1, 13) {
 				base.ErrorfVers("go1.13", "invalid operation: %v (signed shift count type %v)", n, r.Type())
 				n.SetType(nil)
 				return n
@@ -904,7 +904,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			if r.Type().Kind() != types.TBLANK {
 				aop, _ = assignop(l.Type(), r.Type())
 				if aop != ir.OXXX {
-					if r.Type().IsInterface() && !l.Type().IsInterface() && !IsComparable(l.Type()) {
+					if r.Type().IsInterface() && !l.Type().IsInterface() && !types.IsComparable(l.Type()) {
 						base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(l.Type()))
 						n.SetType(nil)
 						return n
@@ -925,7 +925,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			if !converted && l.Type().Kind() != types.TBLANK {
 				aop, _ = assignop(r.Type(), l.Type())
 				if aop != ir.OXXX {
-					if l.Type().IsInterface() && !r.Type().IsInterface() && !IsComparable(r.Type()) {
+					if l.Type().IsInterface() && !r.Type().IsInterface() && !types.IsComparable(r.Type()) {
 						base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(r.Type()))
 						n.SetType(nil)
 						return n
@@ -969,7 +969,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 		// okfor allows any array == array, map == map, func == func.
 		// restrict to slice/map/func == nil and nil == slice/map/func.
-		if l.Type().IsArray() && !IsComparable(l.Type()) {
+		if l.Type().IsArray() && !types.IsComparable(l.Type()) {
 			base.Errorf("invalid operation: %v (%v cannot be compared)", n, l.Type())
 			n.SetType(nil)
 			return n
@@ -994,7 +994,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 
 		if l.Type().IsStruct() {
-			if f := IncomparableField(l.Type()); f != nil {
+			if f := types.IncomparableField(l.Type()); f != nil {
 				base.Errorf("invalid operation: %v (struct containing %v cannot be compared)", n, f.Type)
 				n.SetType(nil)
 				return n
@@ -1627,7 +1627,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			n.SetType(l.Type().Results().Field(0).Type)
 
 			if n.Op() == ir.OCALLFUNC && n.X.Op() == ir.ONAME {
-				if sym := n.X.(*ir.Name).Sym(); isRuntimePkg(sym.Pkg) && sym.Name == "getg" {
+				if sym := n.X.(*ir.Name).Sym(); types.IsRuntimePkg(sym.Pkg) && sym.Name == "getg" {
 					// Emit code for runtime.getg() directly instead of calling function.
 					// Most such rewrites (for example the similar one for math.Sqrt) should be done in walk,
 					// so that the ordering pass can make sure to preserve the semantics of the original code
@@ -2560,7 +2560,7 @@ func typecheckMethodExpr(n *ir.SelectorExpr) (res ir.Node) {
 	if t.IsInterface() {
 		ms = t.Fields()
 	} else {
-		mt := methtype(t)
+		mt := types.ReceiverBaseType(t)
 		if mt == nil {
 			base.Errorf("%v undefined (type %v has no method %v)", n, t, n.Sel)
 			n.SetType(nil)
@@ -2595,7 +2595,7 @@ func typecheckMethodExpr(n *ir.SelectorExpr) (res ir.Node) {
 		return n
 	}
 
-	if !isMethodApplicable(t, m) {
+	if !types.IsMethodApplicable(t, m) {
 		base.Errorf("invalid method expression %v (needs pointer receiver: (*%v).%S)", n, t, s)
 		n.SetType(nil)
 		return n
@@ -2616,14 +2616,6 @@ func typecheckMethodExpr(n *ir.SelectorExpr) (res ir.Node) {
 	return me
 }
 
-// isMethodApplicable reports whether method m can be called on a
-// value of type t. This is necessary because we compute a single
-// method set for both T and *T, but some *T methods are not
-// applicable to T receivers.
-func isMethodApplicable(t *types.Type, m *types.Field) bool {
-	return t.IsPtr() || !m.Type.Recv().Type.IsPtr() || isifacemethod(m.Type) || m.Embedded == 2
-}
-
 func derefall(t *types.Type) *types.Type {
 	for t != nil && t.IsPtr() {
 		t = t.Elem()
@@ -2642,7 +2634,7 @@ func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 
 	var f2 *types.Field
 	if n.X.Type() == t || n.X.Type().Sym() == nil {
-		mt := methtype(t)
+		mt := types.ReceiverBaseType(t)
 		if mt != nil {
 			f2 = lookdot1(n, s, mt, mt.Methods(), dostrcmp)
 		}
@@ -3406,7 +3398,7 @@ func samesafeexpr(l ir.Node, r ir.Node) bool {
 		r := r.(*ir.ConvExpr)
 		// Some conversions can't be reused, such as []byte(str).
 		// Allow only numeric-ish types. This is a bit conservative.
-		return issimple[l.Type().Kind()] && samesafeexpr(l.X, r.X)
+		return types.IsSimple[l.Type().Kind()] && samesafeexpr(l.X, r.X)
 
 	case ir.OINDEX, ir.OINDEXMAP:
 		l := l.(*ir.IndexExpr)
@@ -3680,7 +3672,7 @@ var mapqueue []*ir.MapType
 func checkMapKeys() {
 	for _, n := range mapqueue {
 		k := n.Type().MapType().Key
-		if !k.Broke() && !IsComparable(k) {
+		if !k.Broke() && !types.IsComparable(k) {
 			base.ErrorfAt(n.Pos(), "invalid map key type %v", k)
 		}
 	}
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index cf20583042..f2c719db38 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -90,7 +90,7 @@ func initUniverse() {
 	sizeofString = Rnd(sliceLenOffset+int64(Widthptr), int64(Widthptr))
 
 	for et := types.Kind(0); et < types.NTYPE; et++ {
-		simtype[et] = et
+		types.SimType[et] = et
 	}
 
 	types.Types[types.TANY] = types.New(types.TANY)
@@ -117,7 +117,7 @@ func initUniverse() {
 		if Widthptr == 8 {
 			sameas = s.sameas64
 		}
-		simtype[s.etype] = sameas
+		types.SimType[s.etype] = sameas
 
 		types.Types[s.etype] = defBasic(s.etype, types.BuiltinPkg, s.name)
 	}
@@ -144,10 +144,10 @@ func initUniverse() {
 	types.Types[types.TUNSAFEPTR] = defBasic(types.TUNSAFEPTR, unsafepkg, "Pointer")
 
 	// simple aliases
-	simtype[types.TMAP] = types.TPTR
-	simtype[types.TCHAN] = types.TPTR
-	simtype[types.TFUNC] = types.TPTR
-	simtype[types.TUNSAFEPTR] = types.TPTR
+	types.SimType[types.TMAP] = types.TPTR
+	types.SimType[types.TCHAN] = types.TPTR
+	types.SimType[types.TFUNC] = types.TPTR
+	types.SimType[types.TUNSAFEPTR] = types.TPTR
 
 	for _, s := range &builtinFuncs {
 		s2 := types.BuiltinPkg.Lookup(s.name)
@@ -194,49 +194,49 @@ func initUniverse() {
 	s.Def = ir.NewIota(base.Pos, s)
 
 	for et := types.TINT8; et <= types.TUINT64; et++ {
-		isInt[et] = true
+		types.IsInt[et] = true
 	}
-	isInt[types.TINT] = true
-	isInt[types.TUINT] = true
-	isInt[types.TUINTPTR] = true
+	types.IsInt[types.TINT] = true
+	types.IsInt[types.TUINT] = true
+	types.IsInt[types.TUINTPTR] = true
 
-	isFloat[types.TFLOAT32] = true
-	isFloat[types.TFLOAT64] = true
+	types.IsFloat[types.TFLOAT32] = true
+	types.IsFloat[types.TFLOAT64] = true
 
-	isComplex[types.TCOMPLEX64] = true
-	isComplex[types.TCOMPLEX128] = true
+	types.IsComplex[types.TCOMPLEX64] = true
+	types.IsComplex[types.TCOMPLEX128] = true
 
 	// initialize okfor
 	for et := types.Kind(0); et < types.NTYPE; et++ {
-		if isInt[et] || et == types.TIDEAL {
+		if types.IsInt[et] || et == types.TIDEAL {
 			okforeq[et] = true
-			okforcmp[et] = true
+			types.IsOrdered[et] = true
 			okforarith[et] = true
 			okforadd[et] = true
 			okforand[et] = true
 			ir.OKForConst[et] = true
-			issimple[et] = true
+			types.IsSimple[et] = true
 		}
 
-		if isFloat[et] {
+		if types.IsFloat[et] {
 			okforeq[et] = true
-			okforcmp[et] = true
+			types.IsOrdered[et] = true
 			okforadd[et] = true
 			okforarith[et] = true
 			ir.OKForConst[et] = true
-			issimple[et] = true
+			types.IsSimple[et] = true
 		}
 
-		if isComplex[et] {
+		if types.IsComplex[et] {
 			okforeq[et] = true
 			okforadd[et] = true
 			okforarith[et] = true
 			ir.OKForConst[et] = true
-			issimple[et] = true
+			types.IsSimple[et] = true
 		}
 	}
 
-	issimple[types.TBOOL] = true
+	types.IsSimple[types.TBOOL] = true
 
 	okforadd[types.TSTRING] = true
 
@@ -267,7 +267,7 @@ func initUniverse() {
 	okforeq[types.TARRAY] = true  // only if element type is comparable; refined in typecheck
 	okforeq[types.TSTRUCT] = true // only if all struct fields are comparable; refined in typecheck
 
-	okforcmp[types.TSTRING] = true
+	types.IsOrdered[types.TSTRING] = true
 
 	for i := range okfor {
 		okfor[i] = okfornone[:]
@@ -280,10 +280,10 @@ func initUniverse() {
 	okfor[ir.OANDNOT] = okforand[:]
 	okfor[ir.ODIV] = okforarith[:]
 	okfor[ir.OEQ] = okforeq[:]
-	okfor[ir.OGE] = okforcmp[:]
-	okfor[ir.OGT] = okforcmp[:]
-	okfor[ir.OLE] = okforcmp[:]
-	okfor[ir.OLT] = okforcmp[:]
+	okfor[ir.OGE] = types.IsOrdered[:]
+	okfor[ir.OGT] = types.IsOrdered[:]
+	okfor[ir.OLE] = types.IsOrdered[:]
+	okfor[ir.OLT] = types.IsOrdered[:]
 	okfor[ir.OMOD] = okforand[:]
 	okfor[ir.OMUL] = okforarith[:]
 	okfor[ir.ONE] = okforeq[:]
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 57edc43280..7f68efeed1 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -939,7 +939,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		}
 
 		// Optimize convT2E or convT2I as a two-word copy when T is pointer-shaped.
-		if isdirectiface(fromType) {
+		if types.IsDirectIface(fromType) {
 			l := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), n.X)
 			l.SetType(toType)
 			l.SetTypecheck(n.Typecheck())
@@ -1101,14 +1101,14 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		// rewrite complex div into function call.
 		et := n.X.Type().Kind()
 
-		if isComplex[et] && n.Op() == ir.ODIV {
+		if types.IsComplex[et] && n.Op() == ir.ODIV {
 			t := n.Type()
 			call := mkcall("complex128div", types.Types[types.TCOMPLEX128], init, conv(n.X, types.Types[types.TCOMPLEX128]), conv(n.Y, types.Types[types.TCOMPLEX128]))
 			return conv(call, t)
 		}
 
 		// Nothing to do for float divisions.
-		if isFloat[et] {
+		if types.IsFloat[et] {
 			return n
 		}
 
@@ -2078,7 +2078,7 @@ func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 			on = syslook("printslice")
 			on = substArgTypes(on, n.Type()) // any-1
 		case types.TUINT, types.TUINT8, types.TUINT16, types.TUINT32, types.TUINT64, types.TUINTPTR:
-			if isRuntimePkg(n.Type().Sym().Pkg) && n.Type().Sym().Name == "hex" {
+			if types.IsRuntimePkg(n.Type().Sym().Pkg) && n.Type().Sym().Name == "hex" {
 				on = syslook("printhex")
 			} else {
 				on = syslook("printuint")
@@ -2706,7 +2706,7 @@ func mapfast(t *types.Type) int {
 		return mapslow
 	}
 	switch algtype(t.Key()) {
-	case AMEM32:
+	case types.AMEM32:
 		if !t.Key().HasPointers() {
 			return mapfast32
 		}
@@ -2714,7 +2714,7 @@ func mapfast(t *types.Type) int {
 			return mapfast32ptr
 		}
 		base.Fatalf("small pointer %v", t.Key())
-	case AMEM64:
+	case types.AMEM64:
 		if !t.Key().HasPointers() {
 			return mapfast64
 		}
@@ -2723,7 +2723,7 @@ func mapfast(t *types.Type) int {
 		}
 		// Two-word object, at least one of which is a pointer.
 		// Use the slow path.
-	case ASTRING:
+	case types.ASTRING:
 		return mapfaststr
 	}
 	return mapslow
@@ -3256,12 +3256,12 @@ func eqfor(t *types.Type) (n ir.Node, needsize bool) {
 	// a struct/array containing a non-memory field/element.
 	// Small memory is handled inline, and single non-memory
 	// is handled by walkcompare.
-	switch a, _ := algtype1(t); a {
-	case AMEM:
+	switch a, _ := types.AlgType(t); a {
+	case types.AMEM:
 		n := syslook("memequal")
 		n = substArgTypes(n, t, t)
 		return n, true
-	case ASPECIAL:
+	case types.ASPECIAL:
 		sym := typesymprefix(".eq", t)
 		n := NewName(sym)
 		setNodeNameFunc(n)
@@ -3398,7 +3398,7 @@ func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 		return n
 	case types.TARRAY:
 		// We can compare several elements at once with 2/4/8 byte integer compares
-		inline = t.NumElem() <= 1 || (issimple[t.Elem().Kind()] && (t.NumElem() <= 4 || t.Elem().Width*t.NumElem() <= maxcmpsize))
+		inline = t.NumElem() <= 1 || (types.IsSimple[t.Elem().Kind()] && (t.NumElem() <= 4 || t.Elem().Width*t.NumElem() <= maxcmpsize))
 	case types.TSTRUCT:
 		inline = t.NumComponents(types.IgnoreBlankFields) <= 4
 	}
@@ -3793,7 +3793,7 @@ func usemethod(n *ir.CallExpr) {
 	// Note: Don't rely on res0.Type.String() since its formatting depends on multiple factors
 	//       (including global variables such as numImports - was issue #19028).
 	// Also need to check for reflect package itself (see Issue #38515).
-	if s := res0.Type.Sym(); s != nil && s.Name == "Method" && isReflectPkg(s.Pkg) {
+	if s := res0.Type.Sym(); s != nil && s.Name == "Method" && types.IsReflectPkg(s.Pkg) {
 		Curfn.SetReflectMethod(true)
 		// The LSym is initialized at this point. We need to set the attribute on the LSym.
 		Curfn.LSym.Set(obj.AttrReflectMethod, true)
diff --git a/src/cmd/compile/internal/types/alg.go b/src/cmd/compile/internal/types/alg.go
new file mode 100644
index 0000000000..14200e0d16
--- /dev/null
+++ b/src/cmd/compile/internal/types/alg.go
@@ -0,0 +1,173 @@
+// Copyright 2016 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 types
+
+import "cmd/compile/internal/base"
+
+// AlgKind describes the kind of algorithms used for comparing and
+// hashing a Type.
+type AlgKind int
+
+//go:generate stringer -type AlgKind -trimprefix A
+
+const (
+	// These values are known by runtime.
+	ANOEQ AlgKind = iota
+	AMEM0
+	AMEM8
+	AMEM16
+	AMEM32
+	AMEM64
+	AMEM128
+	ASTRING
+	AINTER
+	ANILINTER
+	AFLOAT32
+	AFLOAT64
+	ACPLX64
+	ACPLX128
+
+	// Type can be compared/hashed as regular memory.
+	AMEM AlgKind = 100
+
+	// Type needs special comparison/hashing functions.
+	ASPECIAL AlgKind = -1
+)
+
+// AlgType returns the AlgKind used for comparing and hashing Type t.
+// If it returns ANOEQ, it also returns the component type of t that
+// makes it incomparable.
+func AlgType(t *Type) (AlgKind, *Type) {
+	if t.Broke() {
+		return AMEM, nil
+	}
+	if t.Noalg() {
+		return ANOEQ, t
+	}
+
+	switch t.Kind() {
+	case TANY, TFORW:
+		// will be defined later.
+		return ANOEQ, t
+
+	case TINT8, TUINT8, TINT16, TUINT16,
+		TINT32, TUINT32, TINT64, TUINT64,
+		TINT, TUINT, TUINTPTR,
+		TBOOL, TPTR,
+		TCHAN, TUNSAFEPTR:
+		return AMEM, nil
+
+	case TFUNC, TMAP:
+		return ANOEQ, t
+
+	case TFLOAT32:
+		return AFLOAT32, nil
+
+	case TFLOAT64:
+		return AFLOAT64, nil
+
+	case TCOMPLEX64:
+		return ACPLX64, nil
+
+	case TCOMPLEX128:
+		return ACPLX128, nil
+
+	case TSTRING:
+		return ASTRING, nil
+
+	case TINTER:
+		if t.IsEmptyInterface() {
+			return ANILINTER, nil
+		}
+		return AINTER, nil
+
+	case TSLICE:
+		return ANOEQ, t
+
+	case TARRAY:
+		a, bad := AlgType(t.Elem())
+		switch a {
+		case AMEM:
+			return AMEM, nil
+		case ANOEQ:
+			return ANOEQ, bad
+		}
+
+		switch t.NumElem() {
+		case 0:
+			// We checked above that the element type is comparable.
+			return AMEM, nil
+		case 1:
+			// Single-element array is same as its lone element.
+			return a, nil
+		}
+
+		return ASPECIAL, nil
+
+	case TSTRUCT:
+		fields := t.FieldSlice()
+
+		// One-field struct is same as that one field alone.
+		if len(fields) == 1 && !fields[0].Sym.IsBlank() {
+			return AlgType(fields[0].Type)
+		}
+
+		ret := AMEM
+		for i, f := range fields {
+			// All fields must be comparable.
+			a, bad := AlgType(f.Type)
+			if a == ANOEQ {
+				return ANOEQ, bad
+			}
+
+			// Blank fields, padded fields, fields with non-memory
+			// equality need special compare.
+			if a != AMEM || f.Sym.IsBlank() || IsPaddedField(t, i) {
+				ret = ASPECIAL
+			}
+		}
+
+		return ret, nil
+	}
+
+	base.Fatalf("algtype1: unexpected type %v", t)
+	return 0, nil
+}
+
+// TypeHasNoAlg reports whether t does not have any associated hash/eq
+// algorithms because t, or some component of t, is marked Noalg.
+func TypeHasNoAlg(t *Type) bool {
+	a, bad := AlgType(t)
+	return a == ANOEQ && bad.Noalg()
+}
+
+// IsComparable reports whether t is a comparable type.
+func IsComparable(t *Type) bool {
+	a, _ := AlgType(t)
+	return a != ANOEQ
+}
+
+// IncomparableField returns an incomparable Field of struct Type t, if any.
+func IncomparableField(t *Type) *Field {
+	for _, f := range t.FieldSlice() {
+		if !IsComparable(f.Type) {
+			return f
+		}
+	}
+	return nil
+}
+
+// IsPaddedField reports whether the i'th field of struct type t is followed
+// by padding.
+func IsPaddedField(t *Type, i int) bool {
+	if !t.IsStruct() {
+		base.Fatalf("ispaddedfield called non-struct %v", t)
+	}
+	end := t.Width
+	if i+1 < t.NumFields() {
+		end = t.Field(i + 1).Offset
+	}
+	return t.Field(i).End() != end
+}
diff --git a/src/cmd/compile/internal/gc/algkind_string.go b/src/cmd/compile/internal/types/algkind_string.go
similarity index 98%
rename from src/cmd/compile/internal/gc/algkind_string.go
rename to src/cmd/compile/internal/types/algkind_string.go
index 52b5399956..8c5a0bc287 100644
--- a/src/cmd/compile/internal/gc/algkind_string.go
+++ b/src/cmd/compile/internal/types/algkind_string.go
@@ -1,6 +1,6 @@
 // Code generated by "stringer -type AlgKind -trimprefix A"; DO NOT EDIT.
 
-package gc
+package types
 
 import "strconv"
 
diff --git a/src/cmd/compile/internal/types/fmt.go b/src/cmd/compile/internal/types/fmt.go
index d63f7a4f8d..bf37f01922 100644
--- a/src/cmd/compile/internal/types/fmt.go
+++ b/src/cmd/compile/internal/types/fmt.go
@@ -6,6 +6,8 @@ package types
 
 import (
 	"bytes"
+	"crypto/md5"
+	"encoding/binary"
 	"fmt"
 	"go/constant"
 	"strconv"
@@ -659,3 +661,12 @@ func FmtConst(v constant.Value, sharp bool) string {
 
 	return v.String()
 }
+
+// TypeHash computes a hash value for type t to use in type switch statements.
+func TypeHash(t *Type) uint32 {
+	p := t.LongString()
+
+	// Using MD5 is overkill, but reduces accidental collisions.
+	h := md5.Sum([]byte(p))
+	return binary.LittleEndian.Uint32(h[:4])
+}
diff --git a/src/cmd/compile/internal/types/goversion.go b/src/cmd/compile/internal/types/goversion.go
new file mode 100644
index 0000000000..2265f472cf
--- /dev/null
+++ b/src/cmd/compile/internal/types/goversion.go
@@ -0,0 +1,96 @@
+// Copyright 2009 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.
+
+//go:generate go run mkbuiltin.go
+
+package types
+
+import (
+	"fmt"
+	"internal/goversion"
+	"log"
+	"regexp"
+	"strconv"
+
+	"cmd/compile/internal/base"
+)
+
+// A lang is a language version broken into major and minor numbers.
+type lang struct {
+	major, minor int
+}
+
+// langWant is the desired language version set by the -lang flag.
+// If the -lang flag is not set, this is the zero value, meaning that
+// any language version is supported.
+var langWant lang
+
+// AllowsGoVersion reports whether a particular package
+// is allowed to use Go version major.minor.
+// We assume the imported packages have all been checked,
+// so we only have to check the local package against the -lang flag.
+func AllowsGoVersion(pkg *Pkg, major, minor int) bool {
+	if pkg == nil {
+		// TODO(mdempsky): Set Pkg for local types earlier.
+		pkg = LocalPkg
+	}
+	if pkg != LocalPkg {
+		// Assume imported packages passed type-checking.
+		return true
+	}
+	if langWant.major == 0 && langWant.minor == 0 {
+		return true
+	}
+	return langWant.major > major || (langWant.major == major && langWant.minor >= minor)
+}
+
+// ParseLangFlag verifies that the -lang flag holds a valid value, and
+// exits if not. It initializes data used by langSupported.
+func ParseLangFlag() {
+	if base.Flag.Lang == "" {
+		return
+	}
+
+	var err error
+	langWant, err = parseLang(base.Flag.Lang)
+	if err != nil {
+		log.Fatalf("invalid value %q for -lang: %v", base.Flag.Lang, err)
+	}
+
+	if def := currentLang(); base.Flag.Lang != def {
+		defVers, err := parseLang(def)
+		if err != nil {
+			log.Fatalf("internal error parsing default lang %q: %v", def, err)
+		}
+		if langWant.major > defVers.major || (langWant.major == defVers.major && langWant.minor > defVers.minor) {
+			log.Fatalf("invalid value %q for -lang: max known version is %q", base.Flag.Lang, def)
+		}
+	}
+}
+
+// parseLang parses a -lang option into a langVer.
+func parseLang(s string) (lang, error) {
+	matches := goVersionRE.FindStringSubmatch(s)
+	if matches == nil {
+		return lang{}, fmt.Errorf(`should be something like "go1.12"`)
+	}
+	major, err := strconv.Atoi(matches[1])
+	if err != nil {
+		return lang{}, err
+	}
+	minor, err := strconv.Atoi(matches[2])
+	if err != nil {
+		return lang{}, err
+	}
+	return lang{major: major, minor: minor}, nil
+}
+
+// currentLang returns the current language version.
+func currentLang() string {
+	return fmt.Sprintf("go1.%d", goversion.Version)
+}
+
+// goVersionRE is a regular expression that matches the valid
+// arguments to the -lang flag.
+var goVersionRE = regexp.MustCompile(`^go([1-9][0-9]*)\.(0|[1-9][0-9]*)$`)
diff --git a/src/cmd/compile/internal/types/pkg.go b/src/cmd/compile/internal/types/pkg.go
index bf90570b53..de45d32bfa 100644
--- a/src/cmd/compile/internal/types/pkg.go
+++ b/src/cmd/compile/internal/types/pkg.go
@@ -138,3 +138,7 @@ func CleanroomDo(f func()) {
 	f()
 	pkgMap = saved
 }
+
+func IsDotAlias(sym *Sym) bool {
+	return sym.Def != nil && sym.Def.Sym() != sym
+}
diff --git a/src/cmd/compile/internal/types/scope.go b/src/cmd/compile/internal/types/scope.go
index d46918f73d..a9669ffafc 100644
--- a/src/cmd/compile/internal/types/scope.go
+++ b/src/cmd/compile/internal/types/scope.go
@@ -72,7 +72,7 @@ func Markdcl() {
 	Block = blockgen
 }
 
-func IsDclstackValid() bool {
+func isDclstackValid() bool {
 	for _, d := range dclstack {
 		if d.sym == nil {
 			return false
@@ -105,3 +105,9 @@ func (s *Sym) pkgDefPtr() *Object {
 	// function scope.
 	return &s.Def
 }
+
+func CheckDclstack() {
+	if !isDclstackValid() {
+		base.Fatalf("mark left on the dclstack")
+	}
+}
diff --git a/src/cmd/compile/internal/types/sort.go b/src/cmd/compile/internal/types/sort.go
new file mode 100644
index 0000000000..dc59b06415
--- /dev/null
+++ b/src/cmd/compile/internal/types/sort.go
@@ -0,0 +1,14 @@
+// Copyright 2009 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 types
+
+// MethodsByName sorts methods by symbol.
+type MethodsByName []*Field
+
+func (x MethodsByName) Len() int { return len(x) }
+
+func (x MethodsByName) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
+
+func (x MethodsByName) Less(i, j int) bool { return x[i].Sym.Less(x[j].Sym) }
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 752c268fa2..21d96c430a 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -9,6 +9,7 @@ import (
 	"cmd/internal/obj"
 	"cmd/internal/src"
 	"fmt"
+	"sync"
 )
 
 // IRNode represents an ir.Node, but without needing to import cmd/compile/internal/ir,
@@ -1695,3 +1696,204 @@ func anyBroke(fields []*Field) bool {
 	}
 	return false
 }
+
+var (
+	IsInt     [NTYPE]bool
+	IsFloat   [NTYPE]bool
+	IsComplex [NTYPE]bool
+	IsSimple  [NTYPE]bool
+)
+
+var IsOrdered [NTYPE]bool
+
+// IsReflexive reports whether t has a reflexive equality operator.
+// That is, if x==x for all x of type t.
+func IsReflexive(t *Type) bool {
+	switch t.Kind() {
+	case TBOOL,
+		TINT,
+		TUINT,
+		TINT8,
+		TUINT8,
+		TINT16,
+		TUINT16,
+		TINT32,
+		TUINT32,
+		TINT64,
+		TUINT64,
+		TUINTPTR,
+		TPTR,
+		TUNSAFEPTR,
+		TSTRING,
+		TCHAN:
+		return true
+
+	case TFLOAT32,
+		TFLOAT64,
+		TCOMPLEX64,
+		TCOMPLEX128,
+		TINTER:
+		return false
+
+	case TARRAY:
+		return IsReflexive(t.Elem())
+
+	case TSTRUCT:
+		for _, t1 := range t.Fields().Slice() {
+			if !IsReflexive(t1.Type) {
+				return false
+			}
+		}
+		return true
+
+	default:
+		base.Fatalf("bad type for map key: %v", t)
+		return false
+	}
+}
+
+// Can this type be stored directly in an interface word?
+// Yes, if the representation is a single pointer.
+func IsDirectIface(t *Type) bool {
+	if t.Broke() {
+		return false
+	}
+
+	switch t.Kind() {
+	case TPTR:
+		// Pointers to notinheap types must be stored indirectly. See issue 42076.
+		return !t.Elem().NotInHeap()
+	case TCHAN,
+		TMAP,
+		TFUNC,
+		TUNSAFEPTR:
+		return true
+
+	case TARRAY:
+		// Array of 1 direct iface type can be direct.
+		return t.NumElem() == 1 && IsDirectIface(t.Elem())
+
+	case TSTRUCT:
+		// Struct with 1 field of direct iface type can be direct.
+		return t.NumFields() == 1 && IsDirectIface(t.Field(0).Type)
+	}
+
+	return false
+}
+
+// IsInterfaceMethod reports whether (field) m is
+// an interface method. Such methods have the
+// special receiver type types.FakeRecvType().
+func IsInterfaceMethod(f *Type) bool {
+	return f.Recv().Type == FakeRecvType()
+}
+
+// IsMethodApplicable reports whether method m can be called on a
+// value of type t. This is necessary because we compute a single
+// method set for both T and *T, but some *T methods are not
+// applicable to T receivers.
+func IsMethodApplicable(t *Type, m *Field) bool {
+	return t.IsPtr() || !m.Type.Recv().Type.IsPtr() || IsInterfaceMethod(m.Type) || m.Embedded == 2
+}
+
+// IsRuntimePkg reports whether p is package runtime.
+func IsRuntimePkg(p *Pkg) bool {
+	if base.Flag.CompilingRuntime && p == LocalPkg {
+		return true
+	}
+	return p.Path == "runtime"
+}
+
+// IsReflectPkg reports whether p is package reflect.
+func IsReflectPkg(p *Pkg) bool {
+	if p == LocalPkg {
+		return base.Ctxt.Pkgpath == "reflect"
+	}
+	return p.Path == "reflect"
+}
+
+// ReceiverBaseType returns the underlying type, if any,
+// that owns methods with receiver parameter t.
+// The result is either a named type or an anonymous struct.
+func ReceiverBaseType(t *Type) *Type {
+	if t == nil {
+		return nil
+	}
+
+	// Strip away pointer if it's there.
+	if t.IsPtr() {
+		if t.Sym() != nil {
+			return nil
+		}
+		t = t.Elem()
+		if t == nil {
+			return nil
+		}
+	}
+
+	// Must be a named type or anonymous struct.
+	if t.Sym() == nil && !t.IsStruct() {
+		return nil
+	}
+
+	// Check types.
+	if IsSimple[t.Kind()] {
+		return t
+	}
+	switch t.Kind() {
+	case TARRAY, TCHAN, TFUNC, TMAP, TSLICE, TSTRING, TSTRUCT:
+		return t
+	}
+	return nil
+}
+
+func FloatForComplex(t *Type) *Type {
+	switch t.Kind() {
+	case TCOMPLEX64:
+		return Types[TFLOAT32]
+	case TCOMPLEX128:
+		return Types[TFLOAT64]
+	}
+	base.Fatalf("unexpected type: %v", t)
+	return nil
+}
+
+func ComplexForFloat(t *Type) *Type {
+	switch t.Kind() {
+	case TFLOAT32:
+		return Types[TCOMPLEX64]
+	case TFLOAT64:
+		return Types[TCOMPLEX128]
+	}
+	base.Fatalf("unexpected type: %v", t)
+	return nil
+}
+
+func TypeSym(t *Type) *Sym {
+	return TypeSymLookup(TypeSymName(t))
+}
+
+func TypeSymLookup(name string) *Sym {
+	typepkgmu.Lock()
+	s := typepkg.Lookup(name)
+	typepkgmu.Unlock()
+	return s
+}
+
+func TypeSymName(t *Type) string {
+	name := t.ShortString()
+	// Use a separate symbol name for Noalg types for #17752.
+	if TypeHasNoAlg(t) {
+		name = "noalg." + name
+	}
+	return name
+}
+
+// Fake package for runtime type info (headers)
+// Don't access directly, use typeLookup below.
+var (
+	typepkgmu sync.Mutex // protects typepkg lookups
+	typepkg   = NewPkg("type", "type")
+)
+
+var SimType [NTYPE]Kind
-- 
GitLab


From 65c4c6dfb22c344415e27b72ccdc58d95ca8f6c2 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 23 Dec 2020 00:10:25 -0500
Subject: [PATCH 0302/2400] [dev.regabi] cmd/compile: group known symbols,
 packages, names [generated]

There are a handful of pre-computed magic symbols known by
package gc, and we need a place to store them.

If we keep them together, the need for type *ir.Name means that
package ir is the lowest package in the import hierarchy that they
can go in. And package ir needs gopkg for methodSymSuffix
(in a later CL), so they can't go any higher either, at least not all together.
So package ir it is.

Rather than dump them all into the top-level package ir
namespace, however, we introduce global structs, Syms, Pkgs, and Names,
and make the known symbols, packages, and names fields of those.

[git-generate]
cd src/cmd/compile/internal/gc

rf '
	add go.go:$ \
		// Names holds known names. \
		var Names struct{} \
		\
		// Syms holds known symbols. \
		var Syms struct {} \
		\
		// Pkgs holds known packages. \
		var Pkgs struct {} \

	mv staticuint64s Names.Staticuint64s
	mv zerobase Names.Zerobase

	mv assertE2I Syms.AssertE2I
	mv assertE2I2 Syms.AssertE2I2
	mv assertI2I Syms.AssertI2I
	mv assertI2I2 Syms.AssertI2I2
	mv deferproc Syms.Deferproc
	mv deferprocStack Syms.DeferprocStack
	mv Deferreturn Syms.Deferreturn
	mv Duffcopy Syms.Duffcopy
	mv Duffzero Syms.Duffzero
	mv gcWriteBarrier Syms.GCWriteBarrier
	mv goschedguarded Syms.Goschedguarded
	mv growslice Syms.Growslice
	mv msanread Syms.Msanread
	mv msanwrite Syms.Msanwrite
	mv msanmove Syms.Msanmove
	mv newobject Syms.Newobject
	mv newproc Syms.Newproc
	mv panicdivide Syms.Panicdivide
	mv panicshift Syms.Panicshift
	mv panicdottypeE Syms.PanicdottypeE
	mv panicdottypeI Syms.PanicdottypeI
	mv panicnildottype Syms.Panicnildottype
	mv panicoverflow Syms.Panicoverflow
	mv raceread Syms.Raceread
	mv racereadrange Syms.Racereadrange
	mv racewrite Syms.Racewrite
	mv racewriterange Syms.Racewriterange
	mv SigPanic Syms.SigPanic
	mv typedmemclr Syms.Typedmemclr
	mv typedmemmove Syms.Typedmemmove
	mv Udiv Syms.Udiv
	mv writeBarrier Syms.WriteBarrier
	mv zerobaseSym Syms.Zerobase
	mv arm64HasATOMICS Syms.ARM64HasATOMICS
	mv armHasVFPv4 Syms.ARMHasVFPv4
	mv x86HasFMA Syms.X86HasFMA
	mv x86HasPOPCNT Syms.X86HasPOPCNT
	mv x86HasSSE41 Syms.X86HasSSE41
	mv WasmDiv Syms.WasmDiv
	mv WasmMove Syms.WasmMove
	mv WasmZero Syms.WasmZero
	mv WasmTruncS Syms.WasmTruncS
	mv WasmTruncU Syms.WasmTruncU

	mv gopkg Pkgs.Go
	mv itabpkg Pkgs.Itab
	mv itablinkpkg Pkgs.Itablink
	mv mappkg Pkgs.Map
	mv msanpkg Pkgs.Msan
	mv racepkg Pkgs.Race
	mv Runtimepkg Pkgs.Runtime
	mv trackpkg Pkgs.Track
	mv unsafepkg Pkgs.Unsafe

	mv Names Syms Pkgs symtab.go
	mv symtab.go cmd/compile/internal/ir
'

Change-Id: Ic143862148569a3bcde8e70b26d75421aa2d00f3
Reviewed-on: https://go-review.googlesource.com/c/go/+/279235
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/amd64/ggen.go   |   3 +-
 src/cmd/compile/internal/amd64/ssa.go    |   5 +-
 src/cmd/compile/internal/arm/ggen.go     |   3 +-
 src/cmd/compile/internal/arm/ssa.go      |   6 +-
 src/cmd/compile/internal/arm64/ggen.go   |   3 +-
 src/cmd/compile/internal/arm64/ssa.go    |   4 +-
 src/cmd/compile/internal/gc/alg.go       |  14 +-
 src/cmd/compile/internal/gc/dcl.go       |   2 +-
 src/cmd/compile/internal/gc/gen.go       |   4 +-
 src/cmd/compile/internal/gc/go.go        |  67 ---------
 src/cmd/compile/internal/gc/iexport.go   |   4 +-
 src/cmd/compile/internal/gc/main.go      |  36 ++---
 src/cmd/compile/internal/gc/noder.go     |   2 +-
 src/cmd/compile/internal/gc/obj.go       |   2 +-
 src/cmd/compile/internal/gc/plive.go     |   4 +-
 src/cmd/compile/internal/gc/reflect.go   |  16 +--
 src/cmd/compile/internal/gc/ssa.go       | 164 +++++++++++------------
 src/cmd/compile/internal/gc/subr.go      |   4 +-
 src/cmd/compile/internal/gc/universe.go  |   4 +-
 src/cmd/compile/internal/gc/walk.go      |  18 +--
 src/cmd/compile/internal/ir/symtab.go    |  82 ++++++++++++
 src/cmd/compile/internal/mips64/ggen.go  |   3 +-
 src/cmd/compile/internal/mips64/ssa.go   |   4 +-
 src/cmd/compile/internal/ppc64/ggen.go   |   3 +-
 src/cmd/compile/internal/riscv64/ggen.go |   3 +-
 src/cmd/compile/internal/riscv64/ssa.go  |   4 +-
 src/cmd/compile/internal/wasm/ssa.go     |  14 +-
 src/cmd/compile/internal/x86/ggen.go     |   3 +-
 src/cmd/compile/internal/x86/ssa.go      |   5 +-
 29 files changed, 255 insertions(+), 231 deletions(-)
 create mode 100644 src/cmd/compile/internal/ir/symtab.go

diff --git a/src/cmd/compile/internal/amd64/ggen.go b/src/cmd/compile/internal/amd64/ggen.go
index ec98b8cca1..0bb0627f92 100644
--- a/src/cmd/compile/internal/amd64/ggen.go
+++ b/src/cmd/compile/internal/amd64/ggen.go
@@ -7,6 +7,7 @@ package amd64
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
+	"cmd/compile/internal/ir"
 	"cmd/internal/obj"
 	"cmd/internal/obj/x86"
 	"cmd/internal/objabi"
@@ -102,7 +103,7 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.Pr
 		}
 		p = pp.Appendpp(p, leaptr, obj.TYPE_MEM, x86.REG_SP, off+dzDI(cnt), obj.TYPE_REG, x86.REG_DI, 0)
 		p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_ADDR, 0, dzOff(cnt))
-		p.To.Sym = gc.Duffzero
+		p.To.Sym = ir.Syms.Duffzero
 
 		if cnt%16 != 0 {
 			p = pp.Appendpp(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_MEM, x86.REG_DI, -int64(8))
diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index 5e3b962076..055d1894d4 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -10,6 +10,7 @@ import (
 
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
@@ -912,7 +913,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		}
 		p = s.Prog(obj.ADUFFZERO)
 		p.To.Type = obj.TYPE_ADDR
-		p.To.Sym = gc.Duffzero
+		p.To.Sym = ir.Syms.Duffzero
 		p.To.Offset = off
 	case ssa.OpAMD64MOVOconst:
 		if v.AuxInt != 0 {
@@ -923,7 +924,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 	case ssa.OpAMD64DUFFCOPY:
 		p := s.Prog(obj.ADUFFCOPY)
 		p.To.Type = obj.TYPE_ADDR
-		p.To.Sym = gc.Duffcopy
+		p.To.Sym = ir.Syms.Duffcopy
 		if v.AuxInt%16 != 0 {
 			v.Fatalf("bad DUFFCOPY AuxInt %v", v.AuxInt)
 		}
diff --git a/src/cmd/compile/internal/arm/ggen.go b/src/cmd/compile/internal/arm/ggen.go
index bd8d7ff40b..2e4de9893b 100644
--- a/src/cmd/compile/internal/arm/ggen.go
+++ b/src/cmd/compile/internal/arm/ggen.go
@@ -6,6 +6,7 @@ package arm
 
 import (
 	"cmd/compile/internal/gc"
+	"cmd/compile/internal/ir"
 	"cmd/internal/obj"
 	"cmd/internal/obj/arm"
 )
@@ -28,7 +29,7 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, r0 *uint32) *obj.Prog
 		p.Reg = arm.REGSP
 		p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.Duffzero
+		p.To.Sym = ir.Syms.Duffzero
 		p.To.Offset = 4 * (128 - cnt/int64(gc.Widthptr))
 	} else {
 		p = pp.Appendpp(p, arm.AADD, obj.TYPE_CONST, 0, 4+off, obj.TYPE_REG, arm.REG_R1, 0)
diff --git a/src/cmd/compile/internal/arm/ssa.go b/src/cmd/compile/internal/arm/ssa.go
index 8b155712aa..ab7ec6176b 100644
--- a/src/cmd/compile/internal/arm/ssa.go
+++ b/src/cmd/compile/internal/arm/ssa.go
@@ -702,7 +702,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(obj.ACALL)
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.Udiv
+		p.To.Sym = ir.Syms.Udiv
 	case ssa.OpARMLoweredWB:
 		p := s.Prog(obj.ACALL)
 		p.To.Type = obj.TYPE_MEM
@@ -724,13 +724,13 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(obj.ADUFFZERO)
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.Duffzero
+		p.To.Sym = ir.Syms.Duffzero
 		p.To.Offset = v.AuxInt
 	case ssa.OpARMDUFFCOPY:
 		p := s.Prog(obj.ADUFFCOPY)
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.Duffcopy
+		p.To.Sym = ir.Syms.Duffcopy
 		p.To.Offset = v.AuxInt
 	case ssa.OpARMLoweredNilCheck:
 		// Issue a load which will fault if arg is nil.
diff --git a/src/cmd/compile/internal/arm64/ggen.go b/src/cmd/compile/internal/arm64/ggen.go
index f3fec03854..6c280267b6 100644
--- a/src/cmd/compile/internal/arm64/ggen.go
+++ b/src/cmd/compile/internal/arm64/ggen.go
@@ -6,6 +6,7 @@ package arm64
 
 import (
 	"cmd/compile/internal/gc"
+	"cmd/compile/internal/ir"
 	"cmd/internal/obj"
 	"cmd/internal/obj/arm64"
 	"cmd/internal/objabi"
@@ -41,7 +42,7 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 		p.Reg = arm64.REG_R20
 		p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.Duffzero
+		p.To.Sym = ir.Syms.Duffzero
 		p.To.Offset = 4 * (64 - cnt/(2*int64(gc.Widthptr)))
 	} else {
 		// Not using REGTMP, so this is async preemptible (async preemption clobbers REGTMP).
diff --git a/src/cmd/compile/internal/arm64/ssa.go b/src/cmd/compile/internal/arm64/ssa.go
index 3eb0ae6557..bb634cc38c 100644
--- a/src/cmd/compile/internal/arm64/ssa.go
+++ b/src/cmd/compile/internal/arm64/ssa.go
@@ -961,7 +961,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(obj.ADUFFZERO)
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.Duffzero
+		p.To.Sym = ir.Syms.Duffzero
 		p.To.Offset = v.AuxInt
 	case ssa.OpARM64LoweredZero:
 		// STP.P	(ZR,ZR), 16(R16)
@@ -987,7 +987,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(obj.ADUFFCOPY)
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.Duffcopy
+		p.To.Sym = ir.Syms.Duffcopy
 		p.To.Offset = v.AuxInt
 	case ssa.OpARM64LoweredMove:
 		// MOVD.P	8(R16), Rtmp
diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index 08237d4055..bcf992ba4b 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -265,19 +265,19 @@ func hashfor(t *types.Type) ir.Node {
 	case types.AMEM:
 		base.Fatalf("hashfor with AMEM type")
 	case types.AINTER:
-		sym = Runtimepkg.Lookup("interhash")
+		sym = ir.Pkgs.Runtime.Lookup("interhash")
 	case types.ANILINTER:
-		sym = Runtimepkg.Lookup("nilinterhash")
+		sym = ir.Pkgs.Runtime.Lookup("nilinterhash")
 	case types.ASTRING:
-		sym = Runtimepkg.Lookup("strhash")
+		sym = ir.Pkgs.Runtime.Lookup("strhash")
 	case types.AFLOAT32:
-		sym = Runtimepkg.Lookup("f32hash")
+		sym = ir.Pkgs.Runtime.Lookup("f32hash")
 	case types.AFLOAT64:
-		sym = Runtimepkg.Lookup("f64hash")
+		sym = ir.Pkgs.Runtime.Lookup("f64hash")
 	case types.ACPLX64:
-		sym = Runtimepkg.Lookup("c64hash")
+		sym = ir.Pkgs.Runtime.Lookup("c64hash")
 	case types.ACPLX128:
-		sym = Runtimepkg.Lookup("c128hash")
+		sym = ir.Pkgs.Runtime.Lookup("c128hash")
 	default:
 		// Note: the caller of hashfor ensured that this symbol
 		// exists and has a body by calling genhash for t.
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 5a5f670a08..c084565f3d 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -626,7 +626,7 @@ func methodSymSuffix(recv *types.Type, msym *types.Sym, suffix string) *types.Sy
 	// Find the package the receiver type appeared in. For
 	// anonymous receiver types (i.e., anonymous structs with
 	// embedded fields), use the "go" pseudo-package instead.
-	rpkg := gopkg
+	rpkg := ir.Pkgs.Go
 	if rsym != nil {
 		rpkg = rsym.Pkg
 	}
diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
index f83c636472..bcd58fd2c5 100644
--- a/src/cmd/compile/internal/gc/gen.go
+++ b/src/cmd/compile/internal/gc/gen.go
@@ -16,7 +16,7 @@ import (
 // sysfunc looks up Go function name in package runtime. This function
 // must follow the internal calling convention.
 func sysfunc(name string) *obj.LSym {
-	s := Runtimepkg.Lookup(name)
+	s := ir.Pkgs.Runtime.Lookup(name)
 	s.SetFunc(true)
 	return s.Linksym()
 }
@@ -25,7 +25,7 @@ func sysfunc(name string) *obj.LSym {
 // runtime. If this is a function, it may have a special calling
 // convention.
 func sysvar(name string) *obj.LSym {
-	return Runtimepkg.Lookup(name).Linksym()
+	return ir.Pkgs.Runtime.Lookup(name).Linksym()
 }
 
 // isParamStackCopy reports whether this is the on-stack copy of a
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index 7ec59852ee..4b6ffe58d1 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -64,24 +64,6 @@ var decldepth int32
 
 var inimport bool // set during import
 
-var itabpkg *types.Pkg // fake pkg for itab entries
-
-var itablinkpkg *types.Pkg // fake package for runtime itab entries
-
-var Runtimepkg *types.Pkg // fake package runtime
-
-var racepkg *types.Pkg // package runtime/race
-
-var msanpkg *types.Pkg // package runtime/msan
-
-var unsafepkg *types.Pkg // package unsafe
-
-var trackpkg *types.Pkg // fake package for field tracking
-
-var mappkg *types.Pkg // fake package for map zero value
-
-var gopkg *types.Pkg // pseudo-package for method symbols on anonymous receiver types
-
 var zerosize int64
 
 var (
@@ -149,57 +131,8 @@ type Arch struct {
 var thearch Arch
 
 var (
-	staticuint64s *ir.Name
-	zerobase      *ir.Name
-
-	assertE2I,
-	assertE2I2,
-	assertI2I,
-	assertI2I2,
-	deferproc,
-	deferprocStack,
-	Deferreturn,
-	Duffcopy,
-	Duffzero,
-	gcWriteBarrier,
-	goschedguarded,
-	growslice,
-	msanread,
-	msanwrite,
-	msanmove,
-	newobject,
-	newproc,
-	panicdivide,
-	panicshift,
-	panicdottypeE,
-	panicdottypeI,
-	panicnildottype,
-	panicoverflow,
-	raceread,
-	racereadrange,
-	racewrite,
-	racewriterange,
-	x86HasPOPCNT,
-	x86HasSSE41,
-	x86HasFMA,
-	armHasVFPv4,
-	arm64HasATOMICS,
-	typedmemclr,
-	typedmemmove,
-	Udiv,
-	writeBarrier,
-	zerobaseSym *obj.LSym
-
 	BoundsCheckFunc [ssa.BoundsKindCount]*obj.LSym
 	ExtendCheckFunc [ssa.BoundsKindCount]*obj.LSym
-
-	// Wasm
-	WasmMove,
-	WasmZero,
-	WasmDiv,
-	WasmTruncS,
-	WasmTruncU,
-	SigPanic *obj.LSym
 )
 
 // GCWriteBarrierReg maps from registers to gcWriteBarrier implementation LSyms.
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index 87db08e0d1..56d2e81df1 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -400,7 +400,7 @@ func (p *iexporter) pushDecl(n *ir.Name) {
 	}
 
 	// Don't export predeclared declarations.
-	if n.Sym().Pkg == types.BuiltinPkg || n.Sym().Pkg == unsafepkg {
+	if n.Sym().Pkg == types.BuiltinPkg || n.Sym().Pkg == ir.Pkgs.Unsafe {
 		return
 	}
 
@@ -647,7 +647,7 @@ func (w *exportWriter) startType(k itag) {
 
 func (w *exportWriter) doTyp(t *types.Type) {
 	if t.Sym() != nil {
-		if t.Sym().Pkg == types.BuiltinPkg || t.Sym().Pkg == unsafepkg {
+		if t.Sym().Pkg == types.BuiltinPkg || t.Sym().Pkg == ir.Pkgs.Unsafe {
 			base.Fatalf("builtin type missing from typIndex: %v", t)
 		}
 
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 15646ff8c7..1c52426802 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -86,32 +86,32 @@ func Main(archInit func(*Arch)) {
 	types.BuiltinPkg.Prefix = "go.builtin"            // not go%2ebuiltin
 
 	// pseudo-package, accessed by import "unsafe"
-	unsafepkg = types.NewPkg("unsafe", "unsafe")
+	ir.Pkgs.Unsafe = types.NewPkg("unsafe", "unsafe")
 
 	// Pseudo-package that contains the compiler's builtin
 	// declarations for package runtime. These are declared in a
 	// separate package to avoid conflicts with package runtime's
 	// actual declarations, which may differ intentionally but
 	// insignificantly.
-	Runtimepkg = types.NewPkg("go.runtime", "runtime")
-	Runtimepkg.Prefix = "runtime"
+	ir.Pkgs.Runtime = types.NewPkg("go.runtime", "runtime")
+	ir.Pkgs.Runtime.Prefix = "runtime"
 
 	// pseudo-packages used in symbol tables
-	itabpkg = types.NewPkg("go.itab", "go.itab")
-	itabpkg.Prefix = "go.itab" // not go%2eitab
+	ir.Pkgs.Itab = types.NewPkg("go.itab", "go.itab")
+	ir.Pkgs.Itab.Prefix = "go.itab" // not go%2eitab
 
-	itablinkpkg = types.NewPkg("go.itablink", "go.itablink")
-	itablinkpkg.Prefix = "go.itablink" // not go%2eitablink
+	ir.Pkgs.Itablink = types.NewPkg("go.itablink", "go.itablink")
+	ir.Pkgs.Itablink.Prefix = "go.itablink" // not go%2eitablink
 
-	trackpkg = types.NewPkg("go.track", "go.track")
-	trackpkg.Prefix = "go.track" // not go%2etrack
+	ir.Pkgs.Track = types.NewPkg("go.track", "go.track")
+	ir.Pkgs.Track.Prefix = "go.track" // not go%2etrack
 
 	// pseudo-package used for map zero values
-	mappkg = types.NewPkg("go.map", "go.map")
-	mappkg.Prefix = "go.map"
+	ir.Pkgs.Map = types.NewPkg("go.map", "go.map")
+	ir.Pkgs.Map.Prefix = "go.map"
 
 	// pseudo-package used for methods with anonymous receivers
-	gopkg = types.NewPkg("go", "")
+	ir.Pkgs.Go = types.NewPkg("go", "")
 
 	base.DebugSSA = ssa.PhaseOption
 	base.ParseFlags()
@@ -165,10 +165,10 @@ func Main(archInit func(*Arch)) {
 	thearch.LinkArch.Init(base.Ctxt)
 	startProfile()
 	if base.Flag.Race {
-		racepkg = types.NewPkg("runtime/race", "")
+		ir.Pkgs.Race = types.NewPkg("runtime/race", "")
 	}
 	if base.Flag.MSan {
-		msanpkg = types.NewPkg("runtime/msan", "")
+		ir.Pkgs.Msan = types.NewPkg("runtime/msan", "")
 	}
 	if base.Flag.Race || base.Flag.MSan {
 		base.Flag.Cfg.Instrumenting = true
@@ -592,13 +592,13 @@ func loadsys() {
 
 	typs := runtimeTypes()
 	for _, d := range &runtimeDecls {
-		sym := Runtimepkg.Lookup(d.name)
+		sym := ir.Pkgs.Runtime.Lookup(d.name)
 		typ := typs[d.typ]
 		switch d.tag {
 		case funcTag:
-			importfunc(Runtimepkg, src.NoXPos, sym, typ)
+			importfunc(ir.Pkgs.Runtime, src.NoXPos, sym, typ)
 		case varTag:
-			importvar(Runtimepkg, src.NoXPos, sym, typ)
+			importvar(ir.Pkgs.Runtime, src.NoXPos, sym, typ)
 		default:
 			base.Fatalf("unhandled declaration tag %v", d.tag)
 		}
@@ -647,7 +647,7 @@ func importfile(f constant.Value) *types.Pkg {
 	}
 
 	if path_ == "unsafe" {
-		return unsafepkg
+		return ir.Pkgs.Unsafe
 	}
 
 	if islocalname(path_) {
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 77a45f0023..799887d6b8 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -334,7 +334,7 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
 		return
 	}
 
-	if ipkg == unsafepkg {
+	if ipkg == ir.Pkgs.Unsafe {
 		p.importedUnsafe = true
 	}
 	if ipkg.Path == "embed" {
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 883033e0c2..897bcce36f 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -158,7 +158,7 @@ func dumpdata() {
 	dumpglobls(Target.Externs[numExterns:])
 
 	if zerosize > 0 {
-		zero := mappkg.Lookup("zero")
+		zero := ir.Pkgs.Map.Lookup("zero")
 		ggloblsym(zero.Linksym(), int32(zerosize), obj.DUPOK|obj.RODATA)
 	}
 
diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/gc/plive.go
index 0b796ae7fa..f13889efda 100644
--- a/src/cmd/compile/internal/gc/plive.go
+++ b/src/cmd/compile/internal/gc/plive.go
@@ -571,7 +571,7 @@ func (lv *Liveness) markUnsafePoints() {
 		var load *ssa.Value
 		v := wbBlock.Controls[0]
 		for {
-			if sym, ok := v.Aux.(*obj.LSym); ok && sym == writeBarrier {
+			if sym, ok := v.Aux.(*obj.LSym); ok && sym == ir.Syms.WriteBarrier {
 				load = v
 				break
 			}
@@ -690,7 +690,7 @@ func (lv *Liveness) hasStackMap(v *ssa.Value) bool {
 	// typedmemclr and typedmemmove are write barriers and
 	// deeply non-preemptible. They are unsafe points and
 	// hence should not have liveness maps.
-	if sym, ok := v.Aux.(*ssa.AuxCall); ok && (sym.Fn == typedmemclr || sym.Fn == typedmemmove) {
+	if sym, ok := v.Aux.(*ssa.AuxCall); ok && (sym.Fn == ir.Syms.Typedmemclr || sym.Fn == ir.Syms.Typedmemmove) {
 		return false
 	}
 	return true
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 12fc6b7fa7..41c9f93bf0 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -489,7 +489,7 @@ func dimportpath(p *types.Pkg) {
 	// If we are compiling the runtime package, there are two runtime packages around
 	// -- localpkg and Runtimepkg. We don't want to produce import path symbols for
 	// both of them, so just produce one for localpkg.
-	if base.Ctxt.Pkgpath == "runtime" && p == Runtimepkg {
+	if base.Ctxt.Pkgpath == "runtime" && p == ir.Pkgs.Runtime {
 		return
 	}
 
@@ -926,7 +926,7 @@ func dcommontype(lsym *obj.LSym, t *types.Type) int {
 // tracksym returns the symbol for tracking use of field/method f, assumed
 // to be a member of struct/interface type t.
 func tracksym(t *types.Type, f *types.Field) *types.Sym {
-	return trackpkg.Lookup(t.ShortString() + "." + f.Sym.Name)
+	return ir.Pkgs.Track.Lookup(t.ShortString() + "." + f.Sym.Name)
 }
 
 func typesymprefix(prefix string, t *types.Type) *types.Sym {
@@ -975,7 +975,7 @@ func itabname(t, itype *types.Type) *ir.AddrExpr {
 	if t == nil || (t.IsPtr() && t.Elem() == nil) || t.IsUntyped() || !itype.IsInterface() || itype.IsEmptyInterface() {
 		base.Fatalf("itabname(%v, %v)", t, itype)
 	}
-	s := itabpkg.Lookup(t.ShortString() + "," + itype.ShortString())
+	s := ir.Pkgs.Itab.Lookup(t.ShortString() + "," + itype.ShortString())
 	if s.Def == nil {
 		n := NewName(s)
 		n.SetType(types.Types[types.TUINT8])
@@ -1544,13 +1544,13 @@ func dumpbasictypes() {
 		dtypesym(functype(nil, []*ir.Field{anonfield(types.ErrorType)}, []*ir.Field{anonfield(types.Types[types.TSTRING])}))
 
 		// add paths for runtime and main, which 6l imports implicitly.
-		dimportpath(Runtimepkg)
+		dimportpath(ir.Pkgs.Runtime)
 
 		if base.Flag.Race {
-			dimportpath(racepkg)
+			dimportpath(ir.Pkgs.Race)
 		}
 		if base.Flag.MSan {
-			dimportpath(msanpkg)
+			dimportpath(ir.Pkgs.Msan)
 		}
 		dimportpath(types.NewPkg("main", ""))
 	}
@@ -1642,7 +1642,7 @@ func dgcptrmask(t *types.Type) *obj.LSym {
 	fillptrmask(t, ptrmask)
 	p := fmt.Sprintf("gcbits.%x", ptrmask)
 
-	sym := Runtimepkg.Lookup(p)
+	sym := ir.Pkgs.Runtime.Lookup(p)
 	lsym := sym.Linksym()
 	if !sym.Uniq() {
 		sym.SetUniq(true)
@@ -1791,7 +1791,7 @@ func zeroaddr(size int64) ir.Node {
 	if zerosize < size {
 		zerosize = size
 	}
-	s := mappkg.Lookup("zero")
+	s := ir.Pkgs.Map.Lookup("zero")
 	if s.Def == nil {
 		x := NewName(s)
 		x.SetType(types.Types[types.TUINT8])
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 722a3257da..22cc868f36 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -91,43 +91,43 @@ func initssaconfig() {
 	ssaCaches = make([]ssa.Cache, base.Flag.LowerC)
 
 	// Set up some runtime functions we'll need to call.
-	assertE2I = sysfunc("assertE2I")
-	assertE2I2 = sysfunc("assertE2I2")
-	assertI2I = sysfunc("assertI2I")
-	assertI2I2 = sysfunc("assertI2I2")
-	deferproc = sysfunc("deferproc")
-	deferprocStack = sysfunc("deferprocStack")
-	Deferreturn = sysfunc("deferreturn")
-	Duffcopy = sysfunc("duffcopy")
-	Duffzero = sysfunc("duffzero")
-	gcWriteBarrier = sysfunc("gcWriteBarrier")
-	goschedguarded = sysfunc("goschedguarded")
-	growslice = sysfunc("growslice")
-	msanread = sysfunc("msanread")
-	msanwrite = sysfunc("msanwrite")
-	msanmove = sysfunc("msanmove")
-	newobject = sysfunc("newobject")
-	newproc = sysfunc("newproc")
-	panicdivide = sysfunc("panicdivide")
-	panicdottypeE = sysfunc("panicdottypeE")
-	panicdottypeI = sysfunc("panicdottypeI")
-	panicnildottype = sysfunc("panicnildottype")
-	panicoverflow = sysfunc("panicoverflow")
-	panicshift = sysfunc("panicshift")
-	raceread = sysfunc("raceread")
-	racereadrange = sysfunc("racereadrange")
-	racewrite = sysfunc("racewrite")
-	racewriterange = sysfunc("racewriterange")
-	x86HasPOPCNT = sysvar("x86HasPOPCNT")       // bool
-	x86HasSSE41 = sysvar("x86HasSSE41")         // bool
-	x86HasFMA = sysvar("x86HasFMA")             // bool
-	armHasVFPv4 = sysvar("armHasVFPv4")         // bool
-	arm64HasATOMICS = sysvar("arm64HasATOMICS") // bool
-	typedmemclr = sysfunc("typedmemclr")
-	typedmemmove = sysfunc("typedmemmove")
-	Udiv = sysvar("udiv")                 // asm func with special ABI
-	writeBarrier = sysvar("writeBarrier") // struct { bool; ... }
-	zerobaseSym = sysvar("zerobase")
+	ir.Syms.AssertE2I = sysfunc("assertE2I")
+	ir.Syms.AssertE2I2 = sysfunc("assertE2I2")
+	ir.Syms.AssertI2I = sysfunc("assertI2I")
+	ir.Syms.AssertI2I2 = sysfunc("assertI2I2")
+	ir.Syms.Deferproc = sysfunc("deferproc")
+	ir.Syms.DeferprocStack = sysfunc("deferprocStack")
+	ir.Syms.Deferreturn = sysfunc("deferreturn")
+	ir.Syms.Duffcopy = sysfunc("duffcopy")
+	ir.Syms.Duffzero = sysfunc("duffzero")
+	ir.Syms.GCWriteBarrier = sysfunc("gcWriteBarrier")
+	ir.Syms.Goschedguarded = sysfunc("goschedguarded")
+	ir.Syms.Growslice = sysfunc("growslice")
+	ir.Syms.Msanread = sysfunc("msanread")
+	ir.Syms.Msanwrite = sysfunc("msanwrite")
+	ir.Syms.Msanmove = sysfunc("msanmove")
+	ir.Syms.Newobject = sysfunc("newobject")
+	ir.Syms.Newproc = sysfunc("newproc")
+	ir.Syms.Panicdivide = sysfunc("panicdivide")
+	ir.Syms.PanicdottypeE = sysfunc("panicdottypeE")
+	ir.Syms.PanicdottypeI = sysfunc("panicdottypeI")
+	ir.Syms.Panicnildottype = sysfunc("panicnildottype")
+	ir.Syms.Panicoverflow = sysfunc("panicoverflow")
+	ir.Syms.Panicshift = sysfunc("panicshift")
+	ir.Syms.Raceread = sysfunc("raceread")
+	ir.Syms.Racereadrange = sysfunc("racereadrange")
+	ir.Syms.Racewrite = sysfunc("racewrite")
+	ir.Syms.Racewriterange = sysfunc("racewriterange")
+	ir.Syms.X86HasPOPCNT = sysvar("x86HasPOPCNT")       // bool
+	ir.Syms.X86HasSSE41 = sysvar("x86HasSSE41")         // bool
+	ir.Syms.X86HasFMA = sysvar("x86HasFMA")             // bool
+	ir.Syms.ARMHasVFPv4 = sysvar("armHasVFPv4")         // bool
+	ir.Syms.ARM64HasATOMICS = sysvar("arm64HasATOMICS") // bool
+	ir.Syms.Typedmemclr = sysfunc("typedmemclr")
+	ir.Syms.Typedmemmove = sysfunc("typedmemmove")
+	ir.Syms.Udiv = sysvar("udiv")                 // asm func with special ABI
+	ir.Syms.WriteBarrier = sysvar("writeBarrier") // struct { bool; ... }
+	ir.Syms.Zerobase = sysvar("zerobase")
 
 	// asm funcs with special ABI
 	if thearch.LinkArch.Name == "amd64" {
@@ -198,12 +198,12 @@ func initssaconfig() {
 	}
 
 	// Wasm (all asm funcs with special ABIs)
-	WasmMove = sysvar("wasmMove")
-	WasmZero = sysvar("wasmZero")
-	WasmDiv = sysvar("wasmDiv")
-	WasmTruncS = sysvar("wasmTruncS")
-	WasmTruncU = sysvar("wasmTruncU")
-	SigPanic = sysfunc("sigpanic")
+	ir.Syms.WasmMove = sysvar("wasmMove")
+	ir.Syms.WasmZero = sysvar("wasmZero")
+	ir.Syms.WasmDiv = sysvar("wasmDiv")
+	ir.Syms.WasmTruncS = sysvar("wasmTruncS")
+	ir.Syms.WasmTruncU = sysvar("wasmTruncU")
+	ir.Syms.SigPanic = sysfunc("sigpanic")
 }
 
 // getParam returns the Field of ith param of node n (which is a
@@ -1051,11 +1051,11 @@ func (s *state) instrument2(t *types.Type, addr, addr2 *ssa.Value, kind instrume
 	if base.Flag.MSan {
 		switch kind {
 		case instrumentRead:
-			fn = msanread
+			fn = ir.Syms.Msanread
 		case instrumentWrite:
-			fn = msanwrite
+			fn = ir.Syms.Msanwrite
 		case instrumentMove:
-			fn = msanmove
+			fn = ir.Syms.Msanmove
 		default:
 			panic("unreachable")
 		}
@@ -1066,9 +1066,9 @@ func (s *state) instrument2(t *types.Type, addr, addr2 *ssa.Value, kind instrume
 		// composites with only one element don't have subobjects, though.
 		switch kind {
 		case instrumentRead:
-			fn = racereadrange
+			fn = ir.Syms.Racereadrange
 		case instrumentWrite:
-			fn = racewriterange
+			fn = ir.Syms.Racewriterange
 		default:
 			panic("unreachable")
 		}
@@ -1078,9 +1078,9 @@ func (s *state) instrument2(t *types.Type, addr, addr2 *ssa.Value, kind instrume
 		// address, as any write must write the first byte.
 		switch kind {
 		case instrumentRead:
-			fn = raceread
+			fn = ir.Syms.Raceread
 		case instrumentWrite:
-			fn = racewrite
+			fn = ir.Syms.Racewrite
 		default:
 			panic("unreachable")
 		}
@@ -1170,7 +1170,7 @@ func (s *state) stmt(n ir.Node) {
 		s.callResult(n, callNormal)
 		if n.Op() == ir.OCALLFUNC && n.X.Op() == ir.ONAME && n.X.(*ir.Name).Class_ == ir.PFUNC {
 			if fn := n.X.Sym().Name; base.Flag.CompilingRuntime && fn == "throw" ||
-				n.X.Sym().Pkg == Runtimepkg && (fn == "throwinit" || fn == "gopanic" || fn == "panicwrap" || fn == "block" || fn == "panicmakeslicelen" || fn == "panicmakeslicecap") {
+				n.X.Sym().Pkg == ir.Pkgs.Runtime && (fn == "throwinit" || fn == "gopanic" || fn == "panicwrap" || fn == "block" || fn == "panicmakeslicelen" || fn == "panicmakeslicecap") {
 				m := s.mem()
 				b := s.endBlock()
 				b.Kind = ssa.BlockExit
@@ -1677,7 +1677,7 @@ func (s *state) exit() *ssa.Block {
 			}
 			s.openDeferExit()
 		} else {
-			s.rtcall(Deferreturn, true, nil)
+			s.rtcall(ir.Syms.Deferreturn, true, nil)
 		}
 	}
 
@@ -2612,7 +2612,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		bt := b.Type
 		if bt.IsSigned() {
 			cmp := s.newValue2(s.ssaOp(ir.OLE, bt), types.Types[types.TBOOL], s.zeroVal(bt), b)
-			s.check(cmp, panicshift)
+			s.check(cmp, ir.Syms.Panicshift)
 			bt = bt.ToUnsigned()
 		}
 		return s.newValue2(s.ssaShiftOp(n.Op(), n.Type(), bt), a.Type, a, b)
@@ -2909,10 +2909,10 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 	case ir.ONEWOBJ:
 		n := n.(*ir.UnaryExpr)
 		if n.Type().Elem().Size() == 0 {
-			return s.newValue1A(ssa.OpAddr, n.Type(), zerobaseSym, s.sb)
+			return s.newValue1A(ssa.OpAddr, n.Type(), ir.Syms.Zerobase, s.sb)
 		}
 		typ := s.expr(n.X)
-		vv := s.rtcall(newobject, true, []*types.Type{n.Type()}, typ)
+		vv := s.rtcall(ir.Syms.Newobject, true, []*types.Type{n.Type()}, typ)
 		return vv[0]
 
 	default:
@@ -3006,7 +3006,7 @@ func (s *state) append(n *ir.CallExpr, inplace bool) *ssa.Value {
 	// Call growslice
 	s.startBlock(grow)
 	taddr := s.expr(n.X)
-	r := s.rtcall(growslice, true, []*types.Type{pt, types.Types[types.TINT], types.Types[types.TINT]}, taddr, p, l, c, nl)
+	r := s.rtcall(ir.Syms.Growslice, true, []*types.Type{pt, types.Types[types.TINT], types.Types[types.TINT]}, taddr, p, l, c, nl)
 
 	if inplace {
 		if sn.Op() == ir.ONAME {
@@ -3635,7 +3635,7 @@ func initSSATables() {
 
 		return func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			// Target Atomic feature is identified by dynamic detection
-			addr := s.entryNewValue1A(ssa.OpAddr, types.Types[types.TBOOL].PtrTo(), arm64HasATOMICS, s.sb)
+			addr := s.entryNewValue1A(ssa.OpAddr, types.Types[types.TBOOL].PtrTo(), ir.Syms.ARM64HasATOMICS, s.sb)
 			v := s.load(types.Types[types.TBOOL], addr)
 			b := s.endBlock()
 			b.Kind = ssa.BlockIf
@@ -3860,7 +3860,7 @@ func initSSATables() {
 				s.vars[n] = s.callResult(n, callNormal) // types.Types[TFLOAT64]
 				return s.variable(n, types.Types[types.TFLOAT64])
 			}
-			v := s.entryNewValue0A(ssa.OpHasCPUFeature, types.Types[types.TBOOL], x86HasFMA)
+			v := s.entryNewValue0A(ssa.OpHasCPUFeature, types.Types[types.TBOOL], ir.Syms.X86HasFMA)
 			b := s.endBlock()
 			b.Kind = ssa.BlockIf
 			b.SetControl(v)
@@ -3892,7 +3892,7 @@ func initSSATables() {
 				s.vars[n] = s.callResult(n, callNormal) // types.Types[TFLOAT64]
 				return s.variable(n, types.Types[types.TFLOAT64])
 			}
-			addr := s.entryNewValue1A(ssa.OpAddr, types.Types[types.TBOOL].PtrTo(), armHasVFPv4, s.sb)
+			addr := s.entryNewValue1A(ssa.OpAddr, types.Types[types.TBOOL].PtrTo(), ir.Syms.ARMHasVFPv4, s.sb)
 			v := s.load(types.Types[types.TBOOL], addr)
 			b := s.endBlock()
 			b.Kind = ssa.BlockIf
@@ -3922,7 +3922,7 @@ func initSSATables() {
 
 	makeRoundAMD64 := func(op ssa.Op) func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 		return func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
-			v := s.entryNewValue0A(ssa.OpHasCPUFeature, types.Types[types.TBOOL], x86HasSSE41)
+			v := s.entryNewValue0A(ssa.OpHasCPUFeature, types.Types[types.TBOOL], ir.Syms.X86HasSSE41)
 			b := s.endBlock()
 			b.Kind = ssa.BlockIf
 			b.SetControl(v)
@@ -4128,7 +4128,7 @@ func initSSATables() {
 
 	makeOnesCountAMD64 := func(op64 ssa.Op, op32 ssa.Op) func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 		return func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
-			v := s.entryNewValue0A(ssa.OpHasCPUFeature, types.Types[types.TBOOL], x86HasPOPCNT)
+			v := s.entryNewValue0A(ssa.OpHasCPUFeature, types.Types[types.TBOOL], ir.Syms.X86HasPOPCNT)
 			b := s.endBlock()
 			b.Kind = ssa.BlockIf
 			b.SetControl(v)
@@ -4212,9 +4212,9 @@ func initSSATables() {
 		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			// check for divide-by-zero/overflow and panic with appropriate message
 			cmpZero := s.newValue2(s.ssaOp(ir.ONE, types.Types[types.TUINT64]), types.Types[types.TBOOL], args[2], s.zeroVal(types.Types[types.TUINT64]))
-			s.check(cmpZero, panicdivide)
+			s.check(cmpZero, ir.Syms.Panicdivide)
 			cmpOverflow := s.newValue2(s.ssaOp(ir.OLT, types.Types[types.TUINT64]), types.Types[types.TBOOL], args[0], args[2])
-			s.check(cmpOverflow, panicoverflow)
+			s.check(cmpOverflow, ir.Syms.Panicoverflow)
 			return s.newValue3(ssa.OpDiv128u, types.NewTuple(types.Types[types.TUINT64], types.Types[types.TUINT64]), args[0], args[1], args[2])
 		},
 		sys.AMD64)
@@ -4768,7 +4768,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 
 		// Call runtime.deferprocStack with pointer to _defer record.
 		ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(base.Ctxt.FixedFrameSize())})
-		aux := ssa.StaticAuxCall(deferprocStack, ACArgs, ACResults)
+		aux := ssa.StaticAuxCall(ir.Syms.DeferprocStack, ACArgs, ACResults)
 		if testLateExpansion {
 			callArgs = append(callArgs, addr, s.mem())
 			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
@@ -4844,7 +4844,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		// call target
 		switch {
 		case k == callDefer:
-			aux := ssa.StaticAuxCall(deferproc, ACArgs, ACResults)
+			aux := ssa.StaticAuxCall(ir.Syms.Deferproc, ACArgs, ACResults)
 			if testLateExpansion {
 				call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 				call.AddArgs(callArgs...)
@@ -4852,7 +4852,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 				call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, aux, s.mem())
 			}
 		case k == callGo:
-			aux := ssa.StaticAuxCall(newproc, ACArgs, ACResults)
+			aux := ssa.StaticAuxCall(ir.Syms.Newproc, ACArgs, ACResults)
 			if testLateExpansion {
 				call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 				call.AddArgs(callArgs...)
@@ -5359,7 +5359,7 @@ func (s *state) intDivide(n ir.Node, a, b *ssa.Value) *ssa.Value {
 	if needcheck {
 		// do a size-appropriate check for zero
 		cmp := s.newValue2(s.ssaOp(ir.ONE, n.Type()), types.Types[types.TBOOL], b, s.zeroVal(n.Type()))
-		s.check(cmp, panicdivide)
+		s.check(cmp, ir.Syms.Panicdivide)
 	}
 	return s.newValue2(s.ssaOp(n.Op(), n.Type()), a.Type, a, b)
 }
@@ -6063,7 +6063,7 @@ func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Val
 			if !commaok {
 				// On failure, panic by calling panicnildottype.
 				s.startBlock(bFail)
-				s.rtcall(panicnildottype, false, nil, target)
+				s.rtcall(ir.Syms.Panicnildottype, false, nil, target)
 
 				// On success, return (perhaps modified) input interface.
 				s.startBlock(bOk)
@@ -6108,16 +6108,16 @@ func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Val
 		}
 		if n.X.Type().IsEmptyInterface() {
 			if commaok {
-				call := s.rtcall(assertE2I2, true, []*types.Type{n.Type(), types.Types[types.TBOOL]}, target, iface)
+				call := s.rtcall(ir.Syms.AssertE2I2, true, []*types.Type{n.Type(), types.Types[types.TBOOL]}, target, iface)
 				return call[0], call[1]
 			}
-			return s.rtcall(assertE2I, true, []*types.Type{n.Type()}, target, iface)[0], nil
+			return s.rtcall(ir.Syms.AssertE2I, true, []*types.Type{n.Type()}, target, iface)[0], nil
 		}
 		if commaok {
-			call := s.rtcall(assertI2I2, true, []*types.Type{n.Type(), types.Types[types.TBOOL]}, target, iface)
+			call := s.rtcall(ir.Syms.AssertI2I2, true, []*types.Type{n.Type(), types.Types[types.TBOOL]}, target, iface)
 			return call[0], call[1]
 		}
-		return s.rtcall(assertI2I, true, []*types.Type{n.Type()}, target, iface)[0], nil
+		return s.rtcall(ir.Syms.AssertI2I, true, []*types.Type{n.Type()}, target, iface)[0], nil
 	}
 
 	if base.Debug.TypeAssert > 0 {
@@ -6165,9 +6165,9 @@ func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Val
 		s.startBlock(bFail)
 		taddr := s.expr(n.Ntype.(*ir.AddrExpr).Alloc)
 		if n.X.Type().IsEmptyInterface() {
-			s.rtcall(panicdottypeE, false, nil, itab, target, taddr)
+			s.rtcall(ir.Syms.PanicdottypeE, false, nil, itab, target, taddr)
 		} else {
-			s.rtcall(panicdottypeI, false, nil, itab, target, taddr)
+			s.rtcall(ir.Syms.PanicdottypeI, false, nil, itab, target, taddr)
 		}
 
 		// on success, return data from interface
@@ -6623,7 +6623,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 		// deferreturn and a return. This will be used to during panic
 		// recovery to unwind the stack and return back to the runtime.
 		s.pp.nextLive = s.livenessMap.deferreturn
-		gencallret(pp, Deferreturn)
+		gencallret(pp, ir.Syms.Deferreturn)
 	}
 
 	if inlMarks != nil {
@@ -7082,14 +7082,14 @@ func (s *SSAGenState) PrepareCall(v *ssa.Value) {
 	idx := s.livenessMap.Get(v)
 	if !idx.StackMapValid() {
 		// See Liveness.hasStackMap.
-		if sym, ok := v.Aux.(*ssa.AuxCall); !ok || !(sym.Fn == typedmemclr || sym.Fn == typedmemmove) {
+		if sym, ok := v.Aux.(*ssa.AuxCall); !ok || !(sym.Fn == ir.Syms.Typedmemclr || sym.Fn == ir.Syms.Typedmemmove) {
 			base.Fatalf("missing stack map index for %v", v.LongString())
 		}
 	}
 
 	call, ok := v.Aux.(*ssa.AuxCall)
 
-	if ok && call.Fn == Deferreturn {
+	if ok && call.Fn == ir.Syms.Deferreturn {
 		// Deferred calls will appear to be returning to
 		// the CALL deferreturn(SB) that we are about to emit.
 		// However, the stack trace code will show the line
@@ -7321,15 +7321,15 @@ func (e *ssafn) UseWriteBarrier() bool {
 func (e *ssafn) Syslook(name string) *obj.LSym {
 	switch name {
 	case "goschedguarded":
-		return goschedguarded
+		return ir.Syms.Goschedguarded
 	case "writeBarrier":
-		return writeBarrier
+		return ir.Syms.WriteBarrier
 	case "gcWriteBarrier":
-		return gcWriteBarrier
+		return ir.Syms.GCWriteBarrier
 	case "typedmemmove":
-		return typedmemmove
+		return ir.Syms.Typedmemmove
 	case "typedmemclr":
-		return typedmemclr
+		return ir.Syms.Typedmemclr
 	}
 	e.Fatalf(src.NoXPos, "unknown Syslook func %v", name)
 	return nil
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index d8956633b2..a845abeb3a 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -523,7 +523,7 @@ func backingArrayPtrLen(n ir.Node) (ptr, length ir.Node) {
 }
 
 func syslook(name string) *ir.Name {
-	s := Runtimepkg.Lookup(name)
+	s := ir.Pkgs.Runtime.Lookup(name)
 	if s == nil || s.Def == nil {
 		base.Fatalf("syslook: can't find runtime.%s", name)
 	}
@@ -1247,7 +1247,7 @@ func paramNnames(ft *types.Type) []ir.Node {
 }
 
 func hashmem(t *types.Type) ir.Node {
-	sym := Runtimepkg.Lookup("memhash")
+	sym := ir.Pkgs.Runtime.Lookup("memhash")
 
 	n := NewName(sym)
 	setNodeNameFunc(n)
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index f2c719db38..c9cce4b488 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -141,7 +141,7 @@ func initUniverse() {
 	s.Def = n
 	dowidth(types.ErrorType)
 
-	types.Types[types.TUNSAFEPTR] = defBasic(types.TUNSAFEPTR, unsafepkg, "Pointer")
+	types.Types[types.TUNSAFEPTR] = defBasic(types.TUNSAFEPTR, ir.Pkgs.Unsafe, "Pointer")
 
 	// simple aliases
 	types.SimType[types.TMAP] = types.TPTR
@@ -157,7 +157,7 @@ func initUniverse() {
 	}
 
 	for _, s := range &unsafeFuncs {
-		s2 := unsafepkg.Lookup(s.name)
+		s2 := ir.Pkgs.Unsafe.Lookup(s.name)
 		def := NewName(s2)
 		def.BuiltinOp = s.op
 		s2.Def = def
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 7f68efeed1..5d812064b6 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -946,15 +946,15 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			return l
 		}
 
-		if staticuint64s == nil {
-			staticuint64s = NewName(Runtimepkg.Lookup("staticuint64s"))
-			staticuint64s.Class_ = ir.PEXTERN
+		if ir.Names.Staticuint64s == nil {
+			ir.Names.Staticuint64s = NewName(ir.Pkgs.Runtime.Lookup("staticuint64s"))
+			ir.Names.Staticuint64s.Class_ = ir.PEXTERN
 			// The actual type is [256]uint64, but we use [256*8]uint8 so we can address
 			// individual bytes.
-			staticuint64s.SetType(types.NewArray(types.Types[types.TUINT8], 256*8))
-			zerobase = NewName(Runtimepkg.Lookup("zerobase"))
-			zerobase.Class_ = ir.PEXTERN
-			zerobase.SetType(types.Types[types.TUINTPTR])
+			ir.Names.Staticuint64s.SetType(types.NewArray(types.Types[types.TUINT8], 256*8))
+			ir.Names.Zerobase = NewName(ir.Pkgs.Runtime.Lookup("zerobase"))
+			ir.Names.Zerobase.Class_ = ir.PEXTERN
+			ir.Names.Zerobase.SetType(types.Types[types.TUINTPTR])
 		}
 
 		// Optimize convT2{E,I} for many cases in which T is not pointer-shaped,
@@ -965,7 +965,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		case fromType.Size() == 0:
 			// n.Left is zero-sized. Use zerobase.
 			cheapexpr(n.X, init) // Evaluate n.Left for side-effects. See issue 19246.
-			value = zerobase
+			value = ir.Names.Zerobase
 		case fromType.IsBoolean() || (fromType.Size() == 1 && fromType.IsInteger()):
 			// n.Left is a bool/byte. Use staticuint64s[n.Left * 8] on little-endian
 			// and staticuint64s[n.Left * 8 + 7] on big-endian.
@@ -975,7 +975,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			if thearch.LinkArch.ByteOrder == binary.BigEndian {
 				index = ir.NewBinaryExpr(base.Pos, ir.OADD, index, nodintconst(7))
 			}
-			xe := ir.NewIndexExpr(base.Pos, staticuint64s, index)
+			xe := ir.NewIndexExpr(base.Pos, ir.Names.Staticuint64s, index)
 			xe.SetBounded(true)
 			value = xe
 		case n.X.Op() == ir.ONAME && n.X.(*ir.Name).Class_ == ir.PEXTERN && n.X.(*ir.Name).Readonly():
diff --git a/src/cmd/compile/internal/ir/symtab.go b/src/cmd/compile/internal/ir/symtab.go
new file mode 100644
index 0000000000..df694f6c84
--- /dev/null
+++ b/src/cmd/compile/internal/ir/symtab.go
@@ -0,0 +1,82 @@
+// Copyright 2009 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 ir
+
+import (
+	"cmd/compile/internal/types"
+	"cmd/internal/obj"
+)
+
+// Names holds known names.
+var Names struct {
+	Staticuint64s *Name
+	Zerobase      *Name
+}
+
+// Syms holds known symbols.
+var Syms struct {
+	AssertE2I       *obj.LSym
+	AssertE2I2      *obj.LSym
+	AssertI2I       *obj.LSym
+	AssertI2I2      *obj.LSym
+	Deferproc       *obj.LSym
+	DeferprocStack  *obj.LSym
+	Deferreturn     *obj.LSym
+	Duffcopy        *obj.LSym
+	Duffzero        *obj.LSym
+	GCWriteBarrier  *obj.LSym
+	Goschedguarded  *obj.LSym
+	Growslice       *obj.LSym
+	Msanread        *obj.LSym
+	Msanwrite       *obj.LSym
+	Msanmove        *obj.LSym
+	Newobject       *obj.LSym
+	Newproc         *obj.LSym
+	Panicdivide     *obj.LSym
+	Panicshift      *obj.LSym
+	PanicdottypeE   *obj.LSym
+	PanicdottypeI   *obj.LSym
+	Panicnildottype *obj.LSym
+	Panicoverflow   *obj.LSym
+	Raceread        *obj.LSym
+	Racereadrange   *obj.LSym
+	Racewrite       *obj.LSym
+	Racewriterange  *obj.LSym
+	// Wasm
+	SigPanic        *obj.LSym
+	Typedmemclr     *obj.LSym
+	Typedmemmove    *obj.LSym
+	Udiv            *obj.LSym
+	WriteBarrier    *obj.LSym
+	Zerobase        *obj.LSym
+	ARM64HasATOMICS *obj.LSym
+	ARMHasVFPv4     *obj.LSym
+	X86HasFMA       *obj.LSym
+	X86HasPOPCNT    *obj.LSym
+	X86HasSSE41     *obj.LSym
+	// Wasm
+	WasmDiv *obj.LSym
+	// Wasm
+	WasmMove *obj.LSym
+	// Wasm
+	WasmZero *obj.LSym
+	// Wasm
+	WasmTruncS *obj.LSym
+	// Wasm
+	WasmTruncU *obj.LSym
+}
+
+// Pkgs holds known packages.
+var Pkgs struct {
+	Go       *types.Pkg
+	Itab     *types.Pkg
+	Itablink *types.Pkg
+	Map      *types.Pkg
+	Msan     *types.Pkg
+	Race     *types.Pkg
+	Runtime  *types.Pkg
+	Track    *types.Pkg
+	Unsafe   *types.Pkg
+}
diff --git a/src/cmd/compile/internal/mips64/ggen.go b/src/cmd/compile/internal/mips64/ggen.go
index 04e7a66e41..4be5bc6f6e 100644
--- a/src/cmd/compile/internal/mips64/ggen.go
+++ b/src/cmd/compile/internal/mips64/ggen.go
@@ -6,6 +6,7 @@ package mips64
 
 import (
 	"cmd/compile/internal/gc"
+	"cmd/compile/internal/ir"
 	"cmd/internal/obj"
 	"cmd/internal/obj/mips"
 )
@@ -23,7 +24,7 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 		p.Reg = mips.REGSP
 		p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.Duffzero
+		p.To.Sym = ir.Syms.Duffzero
 		p.To.Offset = 8 * (128 - cnt/int64(gc.Widthptr))
 	} else {
 		//	ADDV	$(8+frame+lo-8), SP, r1
diff --git a/src/cmd/compile/internal/mips64/ssa.go b/src/cmd/compile/internal/mips64/ssa.go
index 9aaf8715de..0da5eebe8d 100644
--- a/src/cmd/compile/internal/mips64/ssa.go
+++ b/src/cmd/compile/internal/mips64/ssa.go
@@ -383,7 +383,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p = s.Prog(obj.ADUFFZERO)
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.Duffzero
+		p.To.Sym = ir.Syms.Duffzero
 		p.To.Offset = v.AuxInt
 	case ssa.OpMIPS64LoweredZero:
 		// SUBV	$8, R1
@@ -433,7 +433,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(obj.ADUFFCOPY)
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.Duffcopy
+		p.To.Sym = ir.Syms.Duffcopy
 		p.To.Offset = v.AuxInt
 	case ssa.OpMIPS64LoweredMove:
 		// SUBV	$8, R1
diff --git a/src/cmd/compile/internal/ppc64/ggen.go b/src/cmd/compile/internal/ppc64/ggen.go
index 8f5caf5f99..29376badf9 100644
--- a/src/cmd/compile/internal/ppc64/ggen.go
+++ b/src/cmd/compile/internal/ppc64/ggen.go
@@ -7,6 +7,7 @@ package ppc64
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
+	"cmd/compile/internal/ir"
 	"cmd/internal/obj"
 	"cmd/internal/obj/ppc64"
 )
@@ -24,7 +25,7 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 		p.Reg = ppc64.REGSP
 		p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.Duffzero
+		p.To.Sym = ir.Syms.Duffzero
 		p.To.Offset = 4 * (128 - cnt/int64(gc.Widthptr))
 	} else {
 		p = pp.Appendpp(p, ppc64.AMOVD, obj.TYPE_CONST, 0, base.Ctxt.FixedFrameSize()+off-8, obj.TYPE_REG, ppc64.REGTMP, 0)
diff --git a/src/cmd/compile/internal/riscv64/ggen.go b/src/cmd/compile/internal/riscv64/ggen.go
index 18905a4aea..c77640765f 100644
--- a/src/cmd/compile/internal/riscv64/ggen.go
+++ b/src/cmd/compile/internal/riscv64/ggen.go
@@ -7,6 +7,7 @@ package riscv64
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
+	"cmd/compile/internal/ir"
 	"cmd/internal/obj"
 	"cmd/internal/obj/riscv"
 )
@@ -31,7 +32,7 @@ func zeroRange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 		p.Reg = riscv.REG_SP
 		p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.Duffzero
+		p.To.Sym = ir.Syms.Duffzero
 		p.To.Offset = 8 * (128 - cnt/int64(gc.Widthptr))
 		return p
 	}
diff --git a/src/cmd/compile/internal/riscv64/ssa.go b/src/cmd/compile/internal/riscv64/ssa.go
index d382304d72..616b76e5f6 100644
--- a/src/cmd/compile/internal/riscv64/ssa.go
+++ b/src/cmd/compile/internal/riscv64/ssa.go
@@ -614,14 +614,14 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(obj.ADUFFZERO)
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.Duffzero
+		p.To.Sym = ir.Syms.Duffzero
 		p.To.Offset = v.AuxInt
 
 	case ssa.OpRISCV64DUFFCOPY:
 		p := s.Prog(obj.ADUFFCOPY)
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.Duffcopy
+		p.To.Sym = ir.Syms.Duffcopy
 		p.To.Offset = v.AuxInt
 
 	default:
diff --git a/src/cmd/compile/internal/wasm/ssa.go b/src/cmd/compile/internal/wasm/ssa.go
index c9a52a5f73..4e5aa433d9 100644
--- a/src/cmd/compile/internal/wasm/ssa.go
+++ b/src/cmd/compile/internal/wasm/ssa.go
@@ -124,7 +124,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 	switch v.Op {
 	case ssa.OpWasmLoweredStaticCall, ssa.OpWasmLoweredClosureCall, ssa.OpWasmLoweredInterCall:
 		s.PrepareCall(v)
-		if call, ok := v.Aux.(*ssa.AuxCall); ok && call.Fn == gc.Deferreturn {
+		if call, ok := v.Aux.(*ssa.AuxCall); ok && call.Fn == ir.Syms.Deferreturn {
 			// add a resume point before call to deferreturn so it can be called again via jmpdefer
 			s.Prog(wasm.ARESUMEPOINT)
 		}
@@ -149,20 +149,20 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		getValue32(s, v.Args[1])
 		i32Const(s, int32(v.AuxInt))
 		p := s.Prog(wasm.ACall)
-		p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: gc.WasmMove}
+		p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: ir.Syms.WasmMove}
 
 	case ssa.OpWasmLoweredZero:
 		getValue32(s, v.Args[0])
 		i32Const(s, int32(v.AuxInt))
 		p := s.Prog(wasm.ACall)
-		p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: gc.WasmZero}
+		p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: ir.Syms.WasmZero}
 
 	case ssa.OpWasmLoweredNilCheck:
 		getValue64(s, v.Args[0])
 		s.Prog(wasm.AI64Eqz)
 		s.Prog(wasm.AIf)
 		p := s.Prog(wasm.ACALLNORESUME)
-		p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: gc.SigPanic}
+		p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: ir.Syms.SigPanic}
 		s.Prog(wasm.AEnd)
 		if logopt.Enabled() {
 			logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
@@ -314,7 +314,7 @@ func ssaGenValueOnStack(s *gc.SSAGenState, v *ssa.Value, extend bool) {
 		if v.Type.Size() == 8 {
 			// Division of int64 needs helper function wasmDiv to handle the MinInt64 / -1 case.
 			p := s.Prog(wasm.ACall)
-			p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: gc.WasmDiv}
+			p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: ir.Syms.WasmDiv}
 			break
 		}
 		s.Prog(wasm.AI64DivS)
@@ -328,7 +328,7 @@ func ssaGenValueOnStack(s *gc.SSAGenState, v *ssa.Value, extend bool) {
 				s.Prog(wasm.AF64PromoteF32)
 			}
 			p := s.Prog(wasm.ACall)
-			p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: gc.WasmTruncS}
+			p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: ir.Syms.WasmTruncS}
 		}
 
 	case ssa.OpWasmI64TruncSatF32U, ssa.OpWasmI64TruncSatF64U:
@@ -340,7 +340,7 @@ func ssaGenValueOnStack(s *gc.SSAGenState, v *ssa.Value, extend bool) {
 				s.Prog(wasm.AF64PromoteF32)
 			}
 			p := s.Prog(wasm.ACall)
-			p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: gc.WasmTruncU}
+			p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: ir.Syms.WasmTruncU}
 		}
 
 	case ssa.OpWasmF32DemoteF64:
diff --git a/src/cmd/compile/internal/x86/ggen.go b/src/cmd/compile/internal/x86/ggen.go
index a33ddc81e3..f5d08a68ed 100644
--- a/src/cmd/compile/internal/x86/ggen.go
+++ b/src/cmd/compile/internal/x86/ggen.go
@@ -6,6 +6,7 @@ package x86
 
 import (
 	"cmd/compile/internal/gc"
+	"cmd/compile/internal/ir"
 	"cmd/internal/obj"
 	"cmd/internal/obj/x86"
 )
@@ -26,7 +27,7 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, ax *uint32) *obj.Prog
 	} else if cnt <= int64(128*gc.Widthreg) {
 		p = pp.Appendpp(p, x86.ALEAL, obj.TYPE_MEM, x86.REG_SP, off, obj.TYPE_REG, x86.REG_DI, 0)
 		p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_ADDR, 0, 1*(128-cnt/int64(gc.Widthreg)))
-		p.To.Sym = gc.Duffzero
+		p.To.Sym = ir.Syms.Duffzero
 	} else {
 		p = pp.Appendpp(p, x86.AMOVL, obj.TYPE_CONST, 0, cnt/int64(gc.Widthreg), obj.TYPE_REG, x86.REG_CX, 0)
 		p = pp.Appendpp(p, x86.ALEAL, obj.TYPE_MEM, x86.REG_SP, off, obj.TYPE_REG, x86.REG_DI, 0)
diff --git a/src/cmd/compile/internal/x86/ssa.go b/src/cmd/compile/internal/x86/ssa.go
index a3aaf03c95..d3d60591cc 100644
--- a/src/cmd/compile/internal/x86/ssa.go
+++ b/src/cmd/compile/internal/x86/ssa.go
@@ -10,6 +10,7 @@ import (
 
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
@@ -671,12 +672,12 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 	case ssa.Op386DUFFZERO:
 		p := s.Prog(obj.ADUFFZERO)
 		p.To.Type = obj.TYPE_ADDR
-		p.To.Sym = gc.Duffzero
+		p.To.Sym = ir.Syms.Duffzero
 		p.To.Offset = v.AuxInt
 	case ssa.Op386DUFFCOPY:
 		p := s.Prog(obj.ADUFFCOPY)
 		p.To.Type = obj.TYPE_ADDR
-		p.To.Sym = gc.Duffcopy
+		p.To.Sym = ir.Syms.Duffcopy
 		p.To.Offset = v.AuxInt
 
 	case ssa.OpCopy: // TODO: use MOVLreg for reg->reg copies instead of OpCopy?
-- 
GitLab


From 527a1895d675ec0384f564dd76e56b3631948dd4 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 23 Dec 2020 00:38:15 -0500
Subject: [PATCH 0303/2400] [dev.regabi] cmd/compile: move helpers into package
 ir [generated]

[git-generate]
cd src/cmd/compile/internal/gc
sed -i '' 's/TestBuiltin.*/& t.Skip("mkbuiltin needs fixing")/' builtin_test.go
gofmt -w builtin_test.go
rf '
	# Inline a few little-used constructors to avoid bringing them.
	ex {
		import "cmd/compile/internal/base"
		import "cmd/compile/internal/ir"
		import "cmd/compile/internal/types"
		import "cmd/internal/src"

		var typ *types.Type
		var sym *types.Sym
		var str string
		symfield(sym, typ) -> ir.NewField(base.Pos, sym, nil, typ)
		anonfield(typ) -> ir.NewField(base.Pos, nil, nil, typ)
		namedfield(str, typ) -> ir.NewField(base.Pos, lookup(str), nil, typ)

		var cp *ir.CallPartExpr
		callpartMethod(cp) -> cp.Method
		var n ir.Node
		callpartMethod(n) -> n.(*ir.CallPartExpr).Method

		var ns []ir.Node
		liststmt(ns) -> ir.NewBlockStmt(src.NoXPos, ns)
	}
	rm symfield anonfield namedfield liststmt callpartMethod

	mv maxStackVarSize MaxStackVarSize
	mv maxImplicitStackVarSize MaxImplicitStackVarSize
	mv smallArrayBytes MaxSmallArraySize
	mv MaxStackVarSize cfg.go

	mv nodbool NewBool
	mv nodintconst NewInt
	mv nodstr NewString
	mv NewBool NewInt NewString const.go

	mv Mpprec ConstPrec
	mv bigFloatVal BigFloat
	mv doesoverflow ConstOverflow
	mv isGoConst IsConstNode
	mv smallintconst IsSmallIntConst

	mv isZero IsZero
	mv islvalue IsAssignable
	mv staticValue StaticValue
	mv samesafeexpr SameSafeExpr
	mv checkPtr ShouldCheckPtr
	mv isReflectHeaderDataField IsReflectHeaderDataField
	mv paramNnames ParamNames
	mv methodSym MethodSym
	mv methodSymSuffix MethodSymSuffix
	mv methodExprFunc MethodExprFunc
	mv methodExprName MethodExprName
	mv IsZero IsAssignable StaticValue staticValue1 reassigned \
		IsIntrinsicCall \
		SameSafeExpr ShouldCheckPtr IsReflectHeaderDataField \
		ParamNames MethodSym MethodSymSuffix \
		MethodExprName MethodExprFunc \
		expr.go

	mv Curfn CurFunc
	mv funcsymname FuncSymName
	mv newFuncNameAt NewFuncNameAt
	mv setNodeNameFunc MarkFunc
	mv CurFunc FuncSymName NewFuncNameAt MarkFunc func.go

	mv isParamStackCopy IsParamStackCopy
	mv isParamHeapCopy IsParamHeapCopy
	mv nodfp RegFP
	mv IsParamStackCopy IsParamHeapCopy RegFP name.go

	mv hasUniquePos HasUniquePos
	mv setlineno SetPos
	mv initExpr InitExpr
	mv hasNamedResults HasNamedResults
	mv outervalue OuterValue
	mv HasNamedResults HasUniquePos SetPos InitExpr OuterValue EscNever node.go

	mv visitBottomUp VisitFuncsBottomUp # scc.go

	mv cfg.go \
		NewBool NewInt NewString \ # parts of const.go
		ConstPrec BigFloat ConstOverflow IsConstNode IsSmallIntConst \
		expr.go func.go name.go node.go scc.go \
		cmd/compile/internal/ir

'

Change-Id: I13402c5a2cedbf78d993a1eae2940718f23ac166
Reviewed-on: https://go-review.googlesource.com/c/go/+/279421
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/alg.go          |  52 +--
 src/cmd/compile/internal/gc/builtin.go      | 185 +++++-----
 src/cmd/compile/internal/gc/builtin_test.go |   1 +
 src/cmd/compile/internal/gc/closure.go      |  46 ++-
 src/cmd/compile/internal/gc/const.go        |  91 +----
 src/cmd/compile/internal/gc/dcl.go          | 141 +-------
 src/cmd/compile/internal/gc/escape.go       |  75 ++--
 src/cmd/compile/internal/gc/gen.go          |  24 +-
 src/cmd/compile/internal/gc/go.go           |  25 --
 src/cmd/compile/internal/gc/gsubr.go        |   8 +-
 src/cmd/compile/internal/gc/iexport.go      |   4 +-
 src/cmd/compile/internal/gc/iimport.go      |   4 +-
 src/cmd/compile/internal/gc/init.go         |   4 +-
 src/cmd/compile/internal/gc/initorder.go    |   4 +-
 src/cmd/compile/internal/gc/inl.go          | 163 ++-------
 src/cmd/compile/internal/gc/main.go         |  12 +-
 src/cmd/compile/internal/gc/noder.go        |  46 +--
 src/cmd/compile/internal/gc/obj.go          |   4 +-
 src/cmd/compile/internal/gc/order.go        |  22 +-
 src/cmd/compile/internal/gc/pgen.go         |  12 +-
 src/cmd/compile/internal/gc/racewalk.go     |   2 +-
 src/cmd/compile/internal/gc/range.go        |  32 +-
 src/cmd/compile/internal/gc/reflect.go      |  14 +-
 src/cmd/compile/internal/gc/select.go       |  34 +-
 src/cmd/compile/internal/gc/sinit.go        |  92 ++---
 src/cmd/compile/internal/gc/ssa.go          |  32 +-
 src/cmd/compile/internal/gc/subr.go         | 113 +-----
 src/cmd/compile/internal/gc/swt.go          |  14 +-
 src/cmd/compile/internal/gc/typecheck.go    | 213 +++--------
 src/cmd/compile/internal/gc/universe.go     |   8 +-
 src/cmd/compile/internal/gc/walk.go         | 332 +++++++-----------
 src/cmd/compile/internal/ir/cfg.go          |  26 ++
 src/cmd/compile/internal/ir/const.go        |  99 ++++++
 src/cmd/compile/internal/ir/expr.go         | 371 ++++++++++++++++++++
 src/cmd/compile/internal/ir/func.go         |  27 ++
 src/cmd/compile/internal/ir/name.go         |  22 ++
 src/cmd/compile/internal/ir/node.go         |  96 +++++
 src/cmd/compile/internal/{gc => ir}/scc.go  |  66 ++--
 38 files changed, 1255 insertions(+), 1261 deletions(-)
 create mode 100644 src/cmd/compile/internal/ir/cfg.go
 create mode 100644 src/cmd/compile/internal/ir/const.go
 rename src/cmd/compile/internal/{gc => ir}/scc.go (75%)

diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index bcf992ba4b..d21b0d492c 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -147,10 +147,10 @@ func genhash(t *types.Type) *obj.LSym {
 
 	// func sym(p *T, h uintptr) uintptr
 	args := []*ir.Field{
-		namedfield("p", types.NewPtr(t)),
-		namedfield("h", types.Types[types.TUINTPTR]),
+		ir.NewField(base.Pos, lookup("p"), nil, types.NewPtr(t)),
+		ir.NewField(base.Pos, lookup("h"), nil, types.Types[types.TUINTPTR]),
 	}
-	results := []*ir.Field{anonfield(types.Types[types.TUINTPTR])}
+	results := []*ir.Field{ir.NewField(base.Pos, nil, nil, types.Types[types.TUINTPTR])}
 	tfn := ir.NewFuncType(base.Pos, nil, args, results)
 
 	fn := dclfunc(sym, tfn)
@@ -166,9 +166,9 @@ func genhash(t *types.Type) *obj.LSym {
 
 		// for i := 0; i < nelem; i++
 		ni := temp(types.Types[types.TINT])
-		init := ir.NewAssignStmt(base.Pos, ni, nodintconst(0))
-		cond := ir.NewBinaryExpr(base.Pos, ir.OLT, ni, nodintconst(t.NumElem()))
-		post := ir.NewAssignStmt(base.Pos, ni, ir.NewBinaryExpr(base.Pos, ir.OADD, ni, nodintconst(1)))
+		init := ir.NewAssignStmt(base.Pos, ni, ir.NewInt(0))
+		cond := ir.NewBinaryExpr(base.Pos, ir.OLT, ni, ir.NewInt(t.NumElem()))
+		post := ir.NewAssignStmt(base.Pos, ni, ir.NewBinaryExpr(base.Pos, ir.OADD, ni, ir.NewInt(1)))
 		loop := ir.NewForStmt(base.Pos, nil, cond, post, nil)
 		loop.PtrInit().Append(init)
 
@@ -219,7 +219,7 @@ func genhash(t *types.Type) *obj.LSym {
 			na := nodAddr(nx)
 			call.Args.Append(na)
 			call.Args.Append(nh)
-			call.Args.Append(nodintconst(size))
+			call.Args.Append(ir.NewInt(size))
 			fn.Body.Append(ir.NewAssignStmt(base.Pos, nh, call))
 
 			i = next
@@ -239,9 +239,9 @@ func genhash(t *types.Type) *obj.LSym {
 	fn.SetDupok(true)
 	typecheckFunc(fn)
 
-	Curfn = fn
+	ir.CurFunc = fn
 	typecheckslice(fn.Body, ctxStmt)
-	Curfn = nil
+	ir.CurFunc = nil
 
 	if base.Debug.DclStack != 0 {
 		types.CheckDclstack()
@@ -285,12 +285,12 @@ func hashfor(t *types.Type) ir.Node {
 	}
 
 	n := NewName(sym)
-	setNodeNameFunc(n)
+	ir.MarkFunc(n)
 	n.SetType(functype(nil, []*ir.Field{
-		anonfield(types.NewPtr(t)),
-		anonfield(types.Types[types.TUINTPTR]),
+		ir.NewField(base.Pos, nil, nil, types.NewPtr(t)),
+		ir.NewField(base.Pos, nil, nil, types.Types[types.TUINTPTR]),
 	}, []*ir.Field{
-		anonfield(types.Types[types.TUINTPTR]),
+		ir.NewField(base.Pos, nil, nil, types.Types[types.TUINTPTR]),
 	}))
 	return n
 }
@@ -376,8 +376,8 @@ func geneq(t *types.Type) *obj.LSym {
 
 	// func sym(p, q *T) bool
 	tfn := ir.NewFuncType(base.Pos, nil,
-		[]*ir.Field{namedfield("p", types.NewPtr(t)), namedfield("q", types.NewPtr(t))},
-		[]*ir.Field{namedfield("r", types.Types[types.TBOOL])})
+		[]*ir.Field{ir.NewField(base.Pos, lookup("p"), nil, types.NewPtr(t)), ir.NewField(base.Pos, lookup("q"), nil, types.NewPtr(t))},
+		[]*ir.Field{ir.NewField(base.Pos, lookup("r"), nil, types.Types[types.TBOOL])})
 
 	fn := dclfunc(sym, tfn)
 	np := ir.AsNode(tfn.Type().Params().Field(0).Nname)
@@ -440,20 +440,20 @@ func geneq(t *types.Type) *obj.LSym {
 				// Generate a series of checks.
 				for i := int64(0); i < nelem; i++ {
 					// if check {} else { goto neq }
-					nif := ir.NewIfStmt(base.Pos, checkIdx(nodintconst(i)), nil, nil)
+					nif := ir.NewIfStmt(base.Pos, checkIdx(ir.NewInt(i)), nil, nil)
 					nif.Else.Append(ir.NewBranchStmt(base.Pos, ir.OGOTO, neq))
 					fn.Body.Append(nif)
 				}
 				if last {
-					fn.Body.Append(ir.NewAssignStmt(base.Pos, nr, checkIdx(nodintconst(nelem))))
+					fn.Body.Append(ir.NewAssignStmt(base.Pos, nr, checkIdx(ir.NewInt(nelem))))
 				}
 			} else {
 				// Generate a for loop.
 				// for i := 0; i < nelem; i++
 				i := temp(types.Types[types.TINT])
-				init := ir.NewAssignStmt(base.Pos, i, nodintconst(0))
-				cond := ir.NewBinaryExpr(base.Pos, ir.OLT, i, nodintconst(nelem))
-				post := ir.NewAssignStmt(base.Pos, i, ir.NewBinaryExpr(base.Pos, ir.OADD, i, nodintconst(1)))
+				init := ir.NewAssignStmt(base.Pos, i, ir.NewInt(0))
+				cond := ir.NewBinaryExpr(base.Pos, ir.OLT, i, ir.NewInt(nelem))
+				post := ir.NewAssignStmt(base.Pos, i, ir.NewBinaryExpr(base.Pos, ir.OADD, i, ir.NewInt(1)))
 				loop := ir.NewForStmt(base.Pos, nil, cond, post, nil)
 				loop.PtrInit().Append(init)
 				// if eq(pi, qi) {} else { goto neq }
@@ -462,7 +462,7 @@ func geneq(t *types.Type) *obj.LSym {
 				loop.Body.Append(nif)
 				fn.Body.Append(loop)
 				if last {
-					fn.Body.Append(ir.NewAssignStmt(base.Pos, nr, nodbool(true)))
+					fn.Body.Append(ir.NewAssignStmt(base.Pos, nr, ir.NewBool(true)))
 				}
 			}
 		}
@@ -572,7 +572,7 @@ func geneq(t *types.Type) *obj.LSym {
 		}
 
 		if len(flatConds) == 0 {
-			fn.Body.Append(ir.NewAssignStmt(base.Pos, nr, nodbool(true)))
+			fn.Body.Append(ir.NewAssignStmt(base.Pos, nr, ir.NewBool(true)))
 		} else {
 			for _, c := range flatConds[:len(flatConds)-1] {
 				// if cond {} else { goto neq }
@@ -594,7 +594,7 @@ func geneq(t *types.Type) *obj.LSym {
 	//   r = false
 	//   return (or goto ret)
 	fn.Body.Append(ir.NewLabelStmt(base.Pos, neq))
-	fn.Body.Append(ir.NewAssignStmt(base.Pos, nr, nodbool(false)))
+	fn.Body.Append(ir.NewAssignStmt(base.Pos, nr, ir.NewBool(false)))
 	if EqCanPanic(t) || anyCall(fn) {
 		// Epilogue is large, so share it with the equal case.
 		fn.Body.Append(ir.NewBranchStmt(base.Pos, ir.OGOTO, ret))
@@ -615,9 +615,9 @@ func geneq(t *types.Type) *obj.LSym {
 	fn.SetDupok(true)
 	typecheckFunc(fn)
 
-	Curfn = fn
+	ir.CurFunc = fn
 	typecheckslice(fn.Body, ctxStmt)
-	Curfn = nil
+	ir.CurFunc = nil
 
 	if base.Debug.DclStack != 0 {
 		types.CheckDclstack()
@@ -726,7 +726,7 @@ func eqmem(p ir.Node, q ir.Node, field *types.Sym, size int64) ir.Node {
 	call.Args.Append(nx)
 	call.Args.Append(ny)
 	if needsize {
-		call.Args.Append(nodintconst(size))
+		call.Args.Append(ir.NewInt(size))
 	}
 
 	return call
diff --git a/src/cmd/compile/internal/gc/builtin.go b/src/cmd/compile/internal/gc/builtin.go
index d3e3f9ade6..12c70fb6d4 100644
--- a/src/cmd/compile/internal/gc/builtin.go
+++ b/src/cmd/compile/internal/gc/builtin.go
@@ -3,6 +3,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 )
@@ -211,133 +212,133 @@ func runtimeTypes() []*types.Type {
 	typs[1] = types.NewPtr(typs[0])
 	typs[2] = types.Types[types.TANY]
 	typs[3] = types.NewPtr(typs[2])
-	typs[4] = functype(nil, []*ir.Field{anonfield(typs[1])}, []*ir.Field{anonfield(typs[3])})
+	typs[4] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3])})
 	typs[5] = types.Types[types.TUINTPTR]
 	typs[6] = types.Types[types.TBOOL]
 	typs[7] = types.Types[types.TUNSAFEPTR]
-	typs[8] = functype(nil, []*ir.Field{anonfield(typs[5]), anonfield(typs[1]), anonfield(typs[6])}, []*ir.Field{anonfield(typs[7])})
+	typs[8] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[5]), ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[6])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7])})
 	typs[9] = functype(nil, nil, nil)
 	typs[10] = types.Types[types.TINTER]
-	typs[11] = functype(nil, []*ir.Field{anonfield(typs[10])}, nil)
+	typs[11] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[10])}, nil)
 	typs[12] = types.Types[types.TINT32]
 	typs[13] = types.NewPtr(typs[12])
-	typs[14] = functype(nil, []*ir.Field{anonfield(typs[13])}, []*ir.Field{anonfield(typs[10])})
+	typs[14] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[13])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[10])})
 	typs[15] = types.Types[types.TINT]
-	typs[16] = functype(nil, []*ir.Field{anonfield(typs[15]), anonfield(typs[15])}, nil)
+	typs[16] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[15])}, nil)
 	typs[17] = types.Types[types.TUINT]
-	typs[18] = functype(nil, []*ir.Field{anonfield(typs[17]), anonfield(typs[15])}, nil)
-	typs[19] = functype(nil, []*ir.Field{anonfield(typs[6])}, nil)
+	typs[18] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[17]), ir.NewField(base.Pos, nil, nil, typs[15])}, nil)
+	typs[19] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])}, nil)
 	typs[20] = types.Types[types.TFLOAT64]
-	typs[21] = functype(nil, []*ir.Field{anonfield(typs[20])}, nil)
+	typs[21] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])}, nil)
 	typs[22] = types.Types[types.TINT64]
-	typs[23] = functype(nil, []*ir.Field{anonfield(typs[22])}, nil)
+	typs[23] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[22])}, nil)
 	typs[24] = types.Types[types.TUINT64]
-	typs[25] = functype(nil, []*ir.Field{anonfield(typs[24])}, nil)
+	typs[25] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[24])}, nil)
 	typs[26] = types.Types[types.TCOMPLEX128]
-	typs[27] = functype(nil, []*ir.Field{anonfield(typs[26])}, nil)
+	typs[27] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[26])}, nil)
 	typs[28] = types.Types[types.TSTRING]
-	typs[29] = functype(nil, []*ir.Field{anonfield(typs[28])}, nil)
-	typs[30] = functype(nil, []*ir.Field{anonfield(typs[2])}, nil)
-	typs[31] = functype(nil, []*ir.Field{anonfield(typs[5])}, nil)
+	typs[29] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])}, nil)
+	typs[30] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[2])}, nil)
+	typs[31] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[5])}, nil)
 	typs[32] = types.NewArray(typs[0], 32)
 	typs[33] = types.NewPtr(typs[32])
-	typs[34] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28])}, []*ir.Field{anonfield(typs[28])})
-	typs[35] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []*ir.Field{anonfield(typs[28])})
-	typs[36] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []*ir.Field{anonfield(typs[28])})
-	typs[37] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []*ir.Field{anonfield(typs[28])})
+	typs[34] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
+	typs[35] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
+	typs[36] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
+	typs[37] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
 	typs[38] = types.NewSlice(typs[28])
-	typs[39] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[38])}, []*ir.Field{anonfield(typs[28])})
-	typs[40] = functype(nil, []*ir.Field{anonfield(typs[28]), anonfield(typs[28])}, []*ir.Field{anonfield(typs[15])})
+	typs[39] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[38])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
+	typs[40] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[15])})
 	typs[41] = types.NewArray(typs[0], 4)
 	typs[42] = types.NewPtr(typs[41])
-	typs[43] = functype(nil, []*ir.Field{anonfield(typs[42]), anonfield(typs[22])}, []*ir.Field{anonfield(typs[28])})
-	typs[44] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[1]), anonfield(typs[15])}, []*ir.Field{anonfield(typs[28])})
-	typs[45] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[15])}, []*ir.Field{anonfield(typs[28])})
+	typs[43] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[42]), ir.NewField(base.Pos, nil, nil, typs[22])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
+	typs[44] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
+	typs[45] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
 	typs[46] = types.RuneType
 	typs[47] = types.NewSlice(typs[46])
-	typs[48] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[47])}, []*ir.Field{anonfield(typs[28])})
+	typs[48] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[47])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
 	typs[49] = types.NewSlice(typs[0])
-	typs[50] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[28])}, []*ir.Field{anonfield(typs[49])})
+	typs[50] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[49])})
 	typs[51] = types.NewArray(typs[46], 32)
 	typs[52] = types.NewPtr(typs[51])
-	typs[53] = functype(nil, []*ir.Field{anonfield(typs[52]), anonfield(typs[28])}, []*ir.Field{anonfield(typs[47])})
-	typs[54] = functype(nil, []*ir.Field{anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[5])}, []*ir.Field{anonfield(typs[15])})
-	typs[55] = functype(nil, []*ir.Field{anonfield(typs[28]), anonfield(typs[15])}, []*ir.Field{anonfield(typs[46]), anonfield(typs[15])})
-	typs[56] = functype(nil, []*ir.Field{anonfield(typs[28])}, []*ir.Field{anonfield(typs[15])})
-	typs[57] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[2])}, []*ir.Field{anonfield(typs[2])})
-	typs[58] = functype(nil, []*ir.Field{anonfield(typs[2])}, []*ir.Field{anonfield(typs[7])})
-	typs[59] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[3])}, []*ir.Field{anonfield(typs[2])})
-	typs[60] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[2])}, []*ir.Field{anonfield(typs[2]), anonfield(typs[6])})
-	typs[61] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[1]), anonfield(typs[1])}, nil)
-	typs[62] = functype(nil, []*ir.Field{anonfield(typs[1])}, nil)
+	typs[53] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[52]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[47])})
+	typs[54] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[5])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[15])})
+	typs[55] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[46]), ir.NewField(base.Pos, nil, nil, typs[15])})
+	typs[56] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[15])})
+	typs[57] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[2])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[2])})
+	typs[58] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[2])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7])})
+	typs[59] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[2])})
+	typs[60] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[2])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[2]), ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[61] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[1])}, nil)
+	typs[62] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1])}, nil)
 	typs[63] = types.NewPtr(typs[5])
-	typs[64] = functype(nil, []*ir.Field{anonfield(typs[63]), anonfield(typs[7]), anonfield(typs[7])}, []*ir.Field{anonfield(typs[6])})
+	typs[64] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[63]), ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[7])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
 	typs[65] = types.Types[types.TUINT32]
-	typs[66] = functype(nil, nil, []*ir.Field{anonfield(typs[65])})
+	typs[66] = functype(nil, nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[65])})
 	typs[67] = types.NewMap(typs[2], typs[2])
-	typs[68] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[22]), anonfield(typs[3])}, []*ir.Field{anonfield(typs[67])})
-	typs[69] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[3])}, []*ir.Field{anonfield(typs[67])})
-	typs[70] = functype(nil, nil, []*ir.Field{anonfield(typs[67])})
-	typs[71] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, []*ir.Field{anonfield(typs[3])})
-	typs[72] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, []*ir.Field{anonfield(typs[3])})
-	typs[73] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3]), anonfield(typs[1])}, []*ir.Field{anonfield(typs[3])})
-	typs[74] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, []*ir.Field{anonfield(typs[3]), anonfield(typs[6])})
-	typs[75] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, []*ir.Field{anonfield(typs[3]), anonfield(typs[6])})
-	typs[76] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3]), anonfield(typs[1])}, []*ir.Field{anonfield(typs[3]), anonfield(typs[6])})
-	typs[77] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, nil)
-	typs[78] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, nil)
-	typs[79] = functype(nil, []*ir.Field{anonfield(typs[3])}, nil)
-	typs[80] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67])}, nil)
+	typs[68] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[22]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[67])})
+	typs[69] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[67])})
+	typs[70] = functype(nil, nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[67])})
+	typs[71] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3])})
+	typs[72] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[2])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3])})
+	typs[73] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[1])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3])})
+	typs[74] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[75] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[2])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[76] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[1])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[77] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[3])}, nil)
+	typs[78] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[2])}, nil)
+	typs[79] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3])}, nil)
+	typs[80] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67])}, nil)
 	typs[81] = types.NewChan(typs[2], types.Cboth)
-	typs[82] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[22])}, []*ir.Field{anonfield(typs[81])})
-	typs[83] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[15])}, []*ir.Field{anonfield(typs[81])})
+	typs[82] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[22])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[81])})
+	typs[83] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[81])})
 	typs[84] = types.NewChan(typs[2], types.Crecv)
-	typs[85] = functype(nil, []*ir.Field{anonfield(typs[84]), anonfield(typs[3])}, nil)
-	typs[86] = functype(nil, []*ir.Field{anonfield(typs[84]), anonfield(typs[3])}, []*ir.Field{anonfield(typs[6])})
+	typs[85] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[84]), ir.NewField(base.Pos, nil, nil, typs[3])}, nil)
+	typs[86] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[84]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
 	typs[87] = types.NewChan(typs[2], types.Csend)
-	typs[88] = functype(nil, []*ir.Field{anonfield(typs[87]), anonfield(typs[3])}, nil)
+	typs[88] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[87]), ir.NewField(base.Pos, nil, nil, typs[3])}, nil)
 	typs[89] = types.NewArray(typs[0], 3)
-	typs[90] = tostruct([]*ir.Field{namedfield("enabled", typs[6]), namedfield("pad", typs[89]), namedfield("needed", typs[6]), namedfield("cgo", typs[6]), namedfield("alignme", typs[24])})
-	typs[91] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[3]), anonfield(typs[3])}, nil)
-	typs[92] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[3])}, nil)
-	typs[93] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[3]), anonfield(typs[15])}, []*ir.Field{anonfield(typs[15])})
-	typs[94] = functype(nil, []*ir.Field{anonfield(typs[87]), anonfield(typs[3])}, []*ir.Field{anonfield(typs[6])})
-	typs[95] = functype(nil, []*ir.Field{anonfield(typs[3]), anonfield(typs[84])}, []*ir.Field{anonfield(typs[6])})
+	typs[90] = tostruct([]*ir.Field{ir.NewField(base.Pos, lookup("enabled"), nil, typs[6]), ir.NewField(base.Pos, lookup("pad"), nil, typs[89]), ir.NewField(base.Pos, lookup("needed"), nil, typs[6]), ir.NewField(base.Pos, lookup("cgo"), nil, typs[6]), ir.NewField(base.Pos, lookup("alignme"), nil, typs[24])})
+	typs[91] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[3])}, nil)
+	typs[92] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[3])}, nil)
+	typs[93] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[15])})
+	typs[94] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[87]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[95] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[84])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
 	typs[96] = types.NewPtr(typs[6])
-	typs[97] = functype(nil, []*ir.Field{anonfield(typs[3]), anonfield(typs[96]), anonfield(typs[84])}, []*ir.Field{anonfield(typs[6])})
-	typs[98] = functype(nil, []*ir.Field{anonfield(typs[63])}, nil)
-	typs[99] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[1]), anonfield(typs[63]), anonfield(typs[15]), anonfield(typs[15]), anonfield(typs[6])}, []*ir.Field{anonfield(typs[15]), anonfield(typs[6])})
-	typs[100] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[15])}, []*ir.Field{anonfield(typs[7])})
-	typs[101] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[22]), anonfield(typs[22])}, []*ir.Field{anonfield(typs[7])})
-	typs[102] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[15]), anonfield(typs[7])}, []*ir.Field{anonfield(typs[7])})
+	typs[97] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[96]), ir.NewField(base.Pos, nil, nil, typs[84])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[98] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[63])}, nil)
+	typs[99] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[63]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[6])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[100] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7])})
+	typs[101] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[22]), ir.NewField(base.Pos, nil, nil, typs[22])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7])})
+	typs[102] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[7])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7])})
 	typs[103] = types.NewSlice(typs[2])
-	typs[104] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[103]), anonfield(typs[15])}, []*ir.Field{anonfield(typs[103])})
-	typs[105] = functype(nil, []*ir.Field{anonfield(typs[3]), anonfield(typs[3]), anonfield(typs[5])}, nil)
-	typs[106] = functype(nil, []*ir.Field{anonfield(typs[7]), anonfield(typs[5])}, nil)
-	typs[107] = functype(nil, []*ir.Field{anonfield(typs[3]), anonfield(typs[3]), anonfield(typs[5])}, []*ir.Field{anonfield(typs[6])})
-	typs[108] = functype(nil, []*ir.Field{anonfield(typs[3]), anonfield(typs[3])}, []*ir.Field{anonfield(typs[6])})
-	typs[109] = functype(nil, []*ir.Field{anonfield(typs[7]), anonfield(typs[7])}, []*ir.Field{anonfield(typs[6])})
-	typs[110] = functype(nil, []*ir.Field{anonfield(typs[7]), anonfield(typs[5]), anonfield(typs[5])}, []*ir.Field{anonfield(typs[5])})
-	typs[111] = functype(nil, []*ir.Field{anonfield(typs[7]), anonfield(typs[5])}, []*ir.Field{anonfield(typs[5])})
-	typs[112] = functype(nil, []*ir.Field{anonfield(typs[22]), anonfield(typs[22])}, []*ir.Field{anonfield(typs[22])})
-	typs[113] = functype(nil, []*ir.Field{anonfield(typs[24]), anonfield(typs[24])}, []*ir.Field{anonfield(typs[24])})
-	typs[114] = functype(nil, []*ir.Field{anonfield(typs[20])}, []*ir.Field{anonfield(typs[22])})
-	typs[115] = functype(nil, []*ir.Field{anonfield(typs[20])}, []*ir.Field{anonfield(typs[24])})
-	typs[116] = functype(nil, []*ir.Field{anonfield(typs[20])}, []*ir.Field{anonfield(typs[65])})
-	typs[117] = functype(nil, []*ir.Field{anonfield(typs[22])}, []*ir.Field{anonfield(typs[20])})
-	typs[118] = functype(nil, []*ir.Field{anonfield(typs[24])}, []*ir.Field{anonfield(typs[20])})
-	typs[119] = functype(nil, []*ir.Field{anonfield(typs[65])}, []*ir.Field{anonfield(typs[20])})
-	typs[120] = functype(nil, []*ir.Field{anonfield(typs[26]), anonfield(typs[26])}, []*ir.Field{anonfield(typs[26])})
-	typs[121] = functype(nil, []*ir.Field{anonfield(typs[5]), anonfield(typs[5])}, nil)
-	typs[122] = functype(nil, []*ir.Field{anonfield(typs[5]), anonfield(typs[5]), anonfield(typs[5])}, nil)
-	typs[123] = functype(nil, []*ir.Field{anonfield(typs[7]), anonfield(typs[1]), anonfield(typs[5])}, nil)
+	typs[104] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[103]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[103])})
+	typs[105] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[5])}, nil)
+	typs[106] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[5])}, nil)
+	typs[107] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[5])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[108] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[109] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[7])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[110] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[5]), ir.NewField(base.Pos, nil, nil, typs[5])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[5])})
+	typs[111] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[5])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[5])})
+	typs[112] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[22]), ir.NewField(base.Pos, nil, nil, typs[22])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[22])})
+	typs[113] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[24]), ir.NewField(base.Pos, nil, nil, typs[24])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[24])})
+	typs[114] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[22])})
+	typs[115] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[24])})
+	typs[116] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[65])})
+	typs[117] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[22])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])})
+	typs[118] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[24])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])})
+	typs[119] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[65])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])})
+	typs[120] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[26]), ir.NewField(base.Pos, nil, nil, typs[26])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[26])})
+	typs[121] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[5]), ir.NewField(base.Pos, nil, nil, typs[5])}, nil)
+	typs[122] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[5]), ir.NewField(base.Pos, nil, nil, typs[5]), ir.NewField(base.Pos, nil, nil, typs[5])}, nil)
+	typs[123] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[5])}, nil)
 	typs[124] = types.NewSlice(typs[7])
-	typs[125] = functype(nil, []*ir.Field{anonfield(typs[7]), anonfield(typs[124])}, nil)
+	typs[125] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[124])}, nil)
 	typs[126] = types.Types[types.TUINT8]
-	typs[127] = functype(nil, []*ir.Field{anonfield(typs[126]), anonfield(typs[126])}, nil)
+	typs[127] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[126]), ir.NewField(base.Pos, nil, nil, typs[126])}, nil)
 	typs[128] = types.Types[types.TUINT16]
-	typs[129] = functype(nil, []*ir.Field{anonfield(typs[128]), anonfield(typs[128])}, nil)
-	typs[130] = functype(nil, []*ir.Field{anonfield(typs[65]), anonfield(typs[65])}, nil)
-	typs[131] = functype(nil, []*ir.Field{anonfield(typs[24]), anonfield(typs[24])}, nil)
+	typs[129] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[128]), ir.NewField(base.Pos, nil, nil, typs[128])}, nil)
+	typs[130] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[65]), ir.NewField(base.Pos, nil, nil, typs[65])}, nil)
+	typs[131] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[24]), ir.NewField(base.Pos, nil, nil, typs[24])}, nil)
 	return typs[:]
 }
diff --git a/src/cmd/compile/internal/gc/builtin_test.go b/src/cmd/compile/internal/gc/builtin_test.go
index 57f24b2287..df15ca5c7d 100644
--- a/src/cmd/compile/internal/gc/builtin_test.go
+++ b/src/cmd/compile/internal/gc/builtin_test.go
@@ -13,6 +13,7 @@ import (
 )
 
 func TestBuiltin(t *testing.T) {
+	t.Skip("mkbuiltin needs fixing")
 	testenv.MustHaveGoRun(t)
 	t.Parallel()
 
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index 27a9bc7cf8..e758cf86d4 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -18,8 +18,8 @@ func (p *noder) funcLit(expr *syntax.FuncLit) ir.Node {
 	ntype := p.typeExpr(expr.Type)
 
 	fn := ir.NewFunc(p.pos(expr))
-	fn.SetIsHiddenClosure(Curfn != nil)
-	fn.Nname = newFuncNameAt(p.pos(expr), ir.BlankNode.Sym(), fn) // filled in by typecheckclosure
+	fn.SetIsHiddenClosure(ir.CurFunc != nil)
+	fn.Nname = ir.NewFuncNameAt(p.pos(expr), ir.BlankNode.Sym(), fn) // filled in by typecheckclosure
 	fn.Nname.Ntype = xtype
 	fn.Nname.Defn = fn
 
@@ -111,22 +111,22 @@ func typecheckclosure(clo *ir.ClosureExpr, top int) {
 		}
 	}
 
-	fn.Nname.SetSym(closurename(Curfn))
-	setNodeNameFunc(fn.Nname)
+	fn.Nname.SetSym(closurename(ir.CurFunc))
+	ir.MarkFunc(fn.Nname)
 	typecheckFunc(fn)
 
 	// Type check the body now, but only if we're inside a function.
 	// At top level (in a variable initialization: curfn==nil) we're not
 	// ready to type check code yet; we'll check it later, because the
 	// underlying closure function we create is added to Target.Decls.
-	if Curfn != nil && clo.Type() != nil {
-		oldfn := Curfn
-		Curfn = fn
+	if ir.CurFunc != nil && clo.Type() != nil {
+		oldfn := ir.CurFunc
+		ir.CurFunc = fn
 		olddd := decldepth
 		decldepth = 1
 		typecheckslice(fn.Body, ctxStmt)
 		decldepth = olddd
-		Curfn = oldfn
+		ir.CurFunc = oldfn
 	}
 
 	Target.Decls = append(Target.Decls, fn)
@@ -335,13 +335,13 @@ func hasemptycvars(clo *ir.ClosureExpr) bool {
 // and compiling runtime
 func closuredebugruntimecheck(clo *ir.ClosureExpr) {
 	if base.Debug.Closure > 0 {
-		if clo.Esc() == EscHeap {
+		if clo.Esc() == ir.EscHeap {
 			base.WarnfAt(clo.Pos(), "heap closure, captured vars = %v", clo.Func.ClosureVars)
 		} else {
 			base.WarnfAt(clo.Pos(), "stack closure, captured vars = %v", clo.Func.ClosureVars)
 		}
 	}
-	if base.Flag.CompilingRuntime && clo.Esc() == EscHeap {
+	if base.Flag.CompilingRuntime && clo.Esc() == ir.EscHeap {
 		base.ErrorfAt(clo.Pos(), "heap-allocated closure, not allowed in runtime")
 	}
 }
@@ -364,14 +364,14 @@ func closureType(clo *ir.ClosureExpr) *types.Type {
 	// the struct is unnamed so that closures in multiple packages with the
 	// same struct type can share the descriptor.
 	fields := []*ir.Field{
-		namedfield(".F", types.Types[types.TUINTPTR]),
+		ir.NewField(base.Pos, lookup(".F"), nil, types.Types[types.TUINTPTR]),
 	}
 	for _, v := range clo.Func.ClosureVars {
 		typ := v.Type()
 		if !v.Byval() {
 			typ = types.NewPtr(typ)
 		}
-		fields = append(fields, symfield(v.Sym(), typ))
+		fields = append(fields, ir.NewField(base.Pos, v.Sym(), nil, typ))
 	}
 	typ := tostruct(fields)
 	typ.SetNoalg(true)
@@ -435,16 +435,16 @@ func typecheckpartialcall(n ir.Node, sym *types.Sym) *ir.CallPartExpr {
 // for partial calls.
 func makepartialcall(dot *ir.SelectorExpr, t0 *types.Type, meth *types.Sym) *ir.Func {
 	rcvrtype := dot.X.Type()
-	sym := methodSymSuffix(rcvrtype, meth, "-fm")
+	sym := ir.MethodSymSuffix(rcvrtype, meth, "-fm")
 
 	if sym.Uniq() {
 		return sym.Def.(*ir.Func)
 	}
 	sym.SetUniq(true)
 
-	savecurfn := Curfn
+	savecurfn := ir.CurFunc
 	saveLineNo := base.Pos
-	Curfn = nil
+	ir.CurFunc = nil
 
 	// Set line number equal to the line number where the method is declared.
 	var m *types.Field
@@ -480,7 +480,7 @@ func makepartialcall(dot *ir.SelectorExpr, t0 *types.Type, meth *types.Sym) *ir.
 	}
 
 	call := ir.NewCallExpr(base.Pos, ir.OCALL, ir.NewSelectorExpr(base.Pos, ir.OXDOT, ptr, meth), nil)
-	call.Args.Set(paramNnames(tfn.Type()))
+	call.Args.Set(ir.ParamNames(tfn.Type()))
 	call.IsDDD = tfn.Type().IsVariadic()
 	if t0.NumResults() != 0 {
 		ret := ir.NewReturnStmt(base.Pos, nil)
@@ -496,11 +496,11 @@ func makepartialcall(dot *ir.SelectorExpr, t0 *types.Type, meth *types.Sym) *ir.
 	typecheckFunc(fn)
 	// Need to typecheck the body of the just-generated wrapper.
 	// typecheckslice() requires that Curfn is set when processing an ORETURN.
-	Curfn = fn
+	ir.CurFunc = fn
 	typecheckslice(fn.Body, ctxStmt)
 	sym.Def = fn
 	Target.Decls = append(Target.Decls, fn)
-	Curfn = savecurfn
+	ir.CurFunc = savecurfn
 	base.Pos = saveLineNo
 
 	return fn
@@ -511,8 +511,8 @@ func makepartialcall(dot *ir.SelectorExpr, t0 *types.Type, meth *types.Sym) *ir.
 // The address of a variable of the returned type can be cast to a func.
 func partialCallType(n *ir.CallPartExpr) *types.Type {
 	t := tostruct([]*ir.Field{
-		namedfield("F", types.Types[types.TUINTPTR]),
-		namedfield("R", n.X.Type()),
+		ir.NewField(base.Pos, lookup("F"), nil, types.Types[types.TUINTPTR]),
+		ir.NewField(base.Pos, lookup("R"), nil, n.X.Type()),
 	})
 	t.SetNoalg(true)
 	return t
@@ -562,9 +562,3 @@ func walkpartialcall(n *ir.CallPartExpr, init *ir.Nodes) ir.Node {
 
 	return walkexpr(cfn, init)
 }
-
-// callpartMethod returns the *types.Field representing the method
-// referenced by method value n.
-func callpartMethod(n ir.Node) *types.Field {
-	return n.(*ir.CallPartExpr).Method
-}
diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 553f06757f..ad27f3ea44 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -18,30 +18,6 @@ import (
 	"unicode"
 )
 
-const (
-	// Maximum size in bits for big.Ints before signalling
-	// overflow and also mantissa precision for big.Floats.
-	Mpprec = 512
-)
-
-func bigFloatVal(v constant.Value) *big.Float {
-	f := new(big.Float)
-	f.SetPrec(Mpprec)
-	switch u := constant.Val(v).(type) {
-	case int64:
-		f.SetInt64(u)
-	case *big.Int:
-		f.SetInt(u)
-	case *big.Float:
-		f.Set(u)
-	case *big.Rat:
-		f.SetRat(u)
-	default:
-		base.Fatalf("unexpected: %v", u)
-	}
-	return f
-}
-
 func roundFloat(v constant.Value, sz int64) constant.Value {
 	switch sz {
 	case 4:
@@ -334,8 +310,8 @@ func toint(v constant.Value) constant.Value {
 	// something that looks like an integer we omit the
 	// value from the error message.
 	// (See issue #11371).
-	f := bigFloatVal(v)
-	if f.MantExp(nil) > 2*Mpprec {
+	f := ir.BigFloat(v)
+	if f.MantExp(nil) > 2*ir.ConstPrec {
 		base.Errorf("integer too large")
 	} else {
 		var t big.Float
@@ -352,38 +328,6 @@ func toint(v constant.Value) constant.Value {
 	return constant.MakeInt64(1)
 }
 
-// doesoverflow reports whether constant value v is too large
-// to represent with type t.
-func doesoverflow(v constant.Value, t *types.Type) bool {
-	switch {
-	case t.IsInteger():
-		bits := uint(8 * t.Size())
-		if t.IsUnsigned() {
-			x, ok := constant.Uint64Val(v)
-			return !ok || x>>bits != 0
-		}
-		x, ok := constant.Int64Val(v)
-		if x < 0 {
-			x = ^x
-		}
-		return !ok || x>>(bits-1) != 0
-	case t.IsFloat():
-		switch t.Size() {
-		case 4:
-			f, _ := constant.Float32Val(v)
-			return math.IsInf(float64(f), 0)
-		case 8:
-			f, _ := constant.Float64Val(v)
-			return math.IsInf(f, 0)
-		}
-	case t.IsComplex():
-		ft := types.FloatForComplex(t)
-		return doesoverflow(constant.Real(v), ft) || doesoverflow(constant.Imag(v), ft)
-	}
-	base.Fatalf("doesoverflow: %v, %v", v, t)
-	panic("unreachable")
-}
-
 // overflow reports whether constant value v is too large
 // to represent with type t, and emits an error message if so.
 func overflow(v constant.Value, t *types.Type) bool {
@@ -392,11 +336,11 @@ func overflow(v constant.Value, t *types.Type) bool {
 	if t.IsUntyped() {
 		return false
 	}
-	if v.Kind() == constant.Int && constant.BitLen(v) > Mpprec {
+	if v.Kind() == constant.Int && constant.BitLen(v) > ir.ConstPrec {
 		base.Errorf("integer too large")
 		return true
 	}
-	if doesoverflow(v, t) {
+	if ir.ConstOverflow(v, t) {
 		base.Errorf("constant %v overflows %v", types.FmtConst(v, false), t)
 		return true
 	}
@@ -656,13 +600,13 @@ var overflowNames = [...]string{
 
 // origConst returns an OLITERAL with orig n and value v.
 func origConst(n ir.Node, v constant.Value) ir.Node {
-	lno := setlineno(n)
+	lno := ir.SetPos(n)
 	v = convertVal(v, n.Type(), false)
 	base.Pos = lno
 
 	switch v.Kind() {
 	case constant.Int:
-		if constant.BitLen(v) <= Mpprec {
+		if constant.BitLen(v) <= ir.ConstPrec {
 			break
 		}
 		fallthrough
@@ -778,14 +722,6 @@ func defaultType(t *types.Type) *types.Type {
 	return nil
 }
 
-func smallintconst(n ir.Node) bool {
-	if n.Op() == ir.OLITERAL {
-		v, ok := constant.Int64Val(n.Val())
-		return ok && int64(int32(v)) == v
-	}
-	return false
-}
-
 // indexconst checks if Node n contains a constant expression
 // representable as a non-negative int and returns its value.
 // If n is not a constant expression, not representable as an
@@ -803,21 +739,12 @@ func indexconst(n ir.Node) int64 {
 	if v.Kind() != constant.Int || constant.Sign(v) < 0 {
 		return -1
 	}
-	if doesoverflow(v, types.Types[types.TINT]) {
+	if ir.ConstOverflow(v, types.Types[types.TINT]) {
 		return -2
 	}
 	return ir.IntVal(types.Types[types.TINT], v)
 }
 
-// isGoConst reports whether n is a Go language constant (as opposed to a
-// compile-time constant).
-//
-// Expressions derived from nil, like string([]byte(nil)), while they
-// may be known at compile time, are not Go language constants.
-func isGoConst(n ir.Node) bool {
-	return n.Op() == ir.OLITERAL
-}
-
 // anyCallOrChan reports whether n contains any calls or channel operations.
 func anyCallOrChan(n ir.Node) bool {
 	return ir.Any(n, func(n ir.Node) bool {
@@ -875,7 +802,7 @@ func (s *constSet) add(pos src.XPos, n ir.Node, what, where string) {
 		}
 	}
 
-	if !isGoConst(n) {
+	if !ir.IsConstNode(n) {
 		return
 	}
 	if n.Type().IsUntyped() {
@@ -906,7 +833,7 @@ func (s *constSet) add(pos src.XPos, n ir.Node, what, where string) {
 	}
 	k := constSetKey{typ, ir.ConstValue(n)}
 
-	if hasUniquePos(n) {
+	if ir.HasUniquePos(n) {
 		pos = n.Pos()
 	}
 
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index c084565f3d..1189d0ec12 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -80,12 +80,12 @@ func declare(n *ir.Name, ctxt ir.Class) {
 		}
 		Target.Externs = append(Target.Externs, n)
 	} else {
-		if Curfn == nil && ctxt == ir.PAUTO {
+		if ir.CurFunc == nil && ctxt == ir.PAUTO {
 			base.Pos = n.Pos()
 			base.Fatalf("automatic outside function")
 		}
-		if Curfn != nil && ctxt != ir.PFUNC && n.Op() == ir.ONAME {
-			Curfn.Dcl = append(Curfn.Dcl, n)
+		if ir.CurFunc != nil && ctxt != ir.PFUNC && n.Op() == ir.ONAME {
+			ir.CurFunc.Dcl = append(ir.CurFunc.Dcl, n)
 		}
 		if n.Op() == ir.OTYPE {
 			declare_typegen++
@@ -95,7 +95,7 @@ func declare(n *ir.Name, ctxt ir.Class) {
 			gen = vargen
 		}
 		types.Pushdcl(s)
-		n.Curfn = Curfn
+		n.Curfn = ir.CurFunc
 	}
 
 	if ctxt == ir.PAUTO {
@@ -137,7 +137,7 @@ func variter(vl []*ir.Name, t ir.Ntype, el []ir.Node) []ir.Node {
 			declare(v, dclcontext)
 			v.Ntype = t
 			v.Defn = as2
-			if Curfn != nil {
+			if ir.CurFunc != nil {
 				init = append(init, ir.NewDecl(base.Pos, ir.ODCL, v))
 			}
 		}
@@ -158,8 +158,8 @@ func variter(vl []*ir.Name, t ir.Ntype, el []ir.Node) []ir.Node {
 		declare(v, dclcontext)
 		v.Ntype = t
 
-		if e != nil || Curfn != nil || ir.IsBlank(v) {
-			if Curfn != nil {
+		if e != nil || ir.CurFunc != nil || ir.IsBlank(v) {
+			if ir.CurFunc != nil {
 				init = append(init, ir.NewDecl(base.Pos, ir.ODCL, v))
 			}
 			as := ir.NewAssignStmt(base.Pos, v, e)
@@ -176,29 +176,6 @@ func variter(vl []*ir.Name, t ir.Ntype, el []ir.Node) []ir.Node {
 	return init
 }
 
-// newFuncNameAt generates a new name node for a function or method.
-func newFuncNameAt(pos src.XPos, s *types.Sym, fn *ir.Func) *ir.Name {
-	if fn.Nname != nil {
-		base.Fatalf("newFuncName - already have name")
-	}
-	n := ir.NewNameAt(pos, s)
-	n.SetFunc(fn)
-	fn.Nname = n
-	return n
-}
-
-func anonfield(typ *types.Type) *ir.Field {
-	return symfield(nil, typ)
-}
-
-func namedfield(s string, typ *types.Type) *ir.Field {
-	return symfield(lookup(s), typ)
-}
-
-func symfield(s *types.Sym, typ *types.Type) *ir.Field {
-	return ir.NewField(base.Pos, s, nil, typ)
-}
-
 // oldname returns the Node that declares symbol s in the current scope.
 // If no such Node currently exists, an ONONAME Node is returned instead.
 // Automatically creates a new closure variable if the referenced symbol was
@@ -216,7 +193,7 @@ func oldname(s *types.Sym) ir.Node {
 		return ir.NewIdent(base.Pos, s)
 	}
 
-	if Curfn != nil && n.Op() == ir.ONAME && n.Name().Curfn != nil && n.Name().Curfn != Curfn {
+	if ir.CurFunc != nil && n.Op() == ir.ONAME && n.Name().Curfn != nil && n.Name().Curfn != ir.CurFunc {
 		// Inner func is referring to var in outer func.
 		//
 		// TODO(rsc): If there is an outer variable x and we
@@ -225,7 +202,7 @@ func oldname(s *types.Sym) ir.Node {
 		// make x a closure variable unnecessarily.
 		n := n.(*ir.Name)
 		c := n.Name().Innermost
-		if c == nil || c.Curfn != Curfn {
+		if c == nil || c.Curfn != ir.CurFunc {
 			// Do not have a closure var for the active closure yet; make one.
 			c = NewName(s)
 			c.Class_ = ir.PAUTOHEAP
@@ -238,7 +215,7 @@ func oldname(s *types.Sym) ir.Node {
 			c.Outer = n.Name().Innermost
 			n.Name().Innermost = c
 
-			Curfn.ClosureVars = append(Curfn.ClosureVars, c)
+			ir.CurFunc.ClosureVars = append(ir.CurFunc.ClosureVars, c)
 		}
 
 		// return ref to closure var, not original
@@ -322,8 +299,8 @@ func colasdefn(left []ir.Node, defn ir.Node) {
 // returns in auto-declaration context.
 func funchdr(fn *ir.Func) {
 	// change the declaration context from extern to auto
-	funcStack = append(funcStack, funcStackEnt{Curfn, dclcontext})
-	Curfn = fn
+	funcStack = append(funcStack, funcStackEnt{ir.CurFunc, dclcontext})
+	ir.CurFunc = fn
 	dclcontext = ir.PAUTO
 
 	types.Markdcl()
@@ -451,7 +428,7 @@ func funcbody() {
 	types.Popdcl()
 	var e funcStackEnt
 	funcStack, e = funcStack[:len(funcStack)-1], funcStack[len(funcStack)-1]
-	Curfn, dclcontext = e.curfn, e.dclcontext
+	ir.CurFunc, dclcontext = e.curfn, e.dclcontext
 }
 
 // structs, functions, and methods.
@@ -542,7 +519,7 @@ func tointerface(nmethods []*ir.Field) *types.Type {
 }
 
 func fakeRecv() *ir.Field {
-	return anonfield(types.FakeRecvType())
+	return ir.NewField(base.Pos, nil, nil, types.FakeRecvType())
 }
 
 func fakeRecvField() *types.Field {
@@ -588,74 +565,6 @@ func functype(nrecv *ir.Field, nparams, nresults []*ir.Field) *types.Type {
 	return t
 }
 
-func hasNamedResults(fn *ir.Func) bool {
-	typ := fn.Type()
-	return typ.NumResults() > 0 && types.OrigSym(typ.Results().Field(0).Sym) != nil
-}
-
-// methodSym returns the method symbol representing a method name
-// associated with a specific receiver type.
-//
-// Method symbols can be used to distinguish the same method appearing
-// in different method sets. For example, T.M and (*T).M have distinct
-// method symbols.
-//
-// The returned symbol will be marked as a function.
-func methodSym(recv *types.Type, msym *types.Sym) *types.Sym {
-	sym := methodSymSuffix(recv, msym, "")
-	sym.SetFunc(true)
-	return sym
-}
-
-// methodSymSuffix is like methodsym, but allows attaching a
-// distinguisher suffix. To avoid collisions, the suffix must not
-// start with a letter, number, or period.
-func methodSymSuffix(recv *types.Type, msym *types.Sym, suffix string) *types.Sym {
-	if msym.IsBlank() {
-		base.Fatalf("blank method name")
-	}
-
-	rsym := recv.Sym()
-	if recv.IsPtr() {
-		if rsym != nil {
-			base.Fatalf("declared pointer receiver type: %v", recv)
-		}
-		rsym = recv.Elem().Sym()
-	}
-
-	// Find the package the receiver type appeared in. For
-	// anonymous receiver types (i.e., anonymous structs with
-	// embedded fields), use the "go" pseudo-package instead.
-	rpkg := ir.Pkgs.Go
-	if rsym != nil {
-		rpkg = rsym.Pkg
-	}
-
-	var b bytes.Buffer
-	if recv.IsPtr() {
-		// The parentheses aren't really necessary, but
-		// they're pretty traditional at this point.
-		fmt.Fprintf(&b, "(%-S)", recv)
-	} else {
-		fmt.Fprintf(&b, "%-S", recv)
-	}
-
-	// A particular receiver type may have multiple non-exported
-	// methods with the same name. To disambiguate them, include a
-	// package qualifier for names that came from a different
-	// package than the receiver type.
-	if !types.IsExported(msym.Name) && msym.Pkg != rpkg {
-		b.WriteString(".")
-		b.WriteString(msym.Pkg.Prefix)
-	}
-
-	b.WriteString(".")
-	b.WriteString(msym.Name)
-	b.WriteString(suffix)
-
-	return rpkg.LookupBytes(b.Bytes())
-}
-
 // Add a method, declared as a function.
 // - msym is the method symbol
 // - t is function type (with receiver)
@@ -740,10 +649,6 @@ func addmethod(n *ir.Func, msym *types.Sym, t *types.Type, local, nointerface bo
 	return f
 }
 
-func funcsymname(s *types.Sym) string {
-	return s.Name + "·f"
-}
-
 // funcsym returns s·f.
 func funcsym(s *types.Sym) *types.Sym {
 	// funcsymsmu here serves to protect not just mutations of funcsyms (below),
@@ -756,7 +661,7 @@ func funcsym(s *types.Sym) *types.Sym {
 	// Note makefuncsym also does package look-up of func sym names,
 	// but that it is only called serially, from the front end.
 	funcsymsmu.Lock()
-	sf, existed := s.Pkg.LookupOK(funcsymname(s))
+	sf, existed := s.Pkg.LookupOK(ir.FuncSymName(s))
 	// Don't export s·f when compiling for dynamic linking.
 	// When dynamically linking, the necessary function
 	// symbols will be created explicitly with makefuncsym.
@@ -790,31 +695,21 @@ func makefuncsym(s *types.Sym) {
 		// get funcsyms.
 		return
 	}
-	if _, existed := s.Pkg.LookupOK(funcsymname(s)); !existed {
+	if _, existed := s.Pkg.LookupOK(ir.FuncSymName(s)); !existed {
 		funcsyms = append(funcsyms, s)
 	}
 }
 
-// setNodeNameFunc marks a node as a function.
-func setNodeNameFunc(n *ir.Name) {
-	if n.Op() != ir.ONAME || n.Class_ != ir.Pxxx {
-		base.Fatalf("expected ONAME/Pxxx node, got %v", n)
-	}
-
-	n.Class_ = ir.PFUNC
-	n.Sym().SetFunc(true)
-}
-
 func dclfunc(sym *types.Sym, tfn ir.Ntype) *ir.Func {
 	if tfn.Op() != ir.OTFUNC {
 		base.Fatalf("expected OTFUNC node, got %v", tfn)
 	}
 
 	fn := ir.NewFunc(base.Pos)
-	fn.Nname = newFuncNameAt(base.Pos, sym, fn)
+	fn.Nname = ir.NewFuncNameAt(base.Pos, sym, fn)
 	fn.Nname.Defn = fn
 	fn.Nname.Ntype = tfn
-	setNodeNameFunc(fn.Nname)
+	ir.MarkFunc(fn.Nname)
 	funchdr(fn)
 	fn.Nname.Ntype = typecheckNtype(fn.Nname.Ntype)
 	return fn
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 4366a5cc2c..6843d8b00e 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -147,16 +147,16 @@ type EscEdge struct {
 func escFmt(n ir.Node) string {
 	text := ""
 	switch n.Esc() {
-	case EscUnknown:
+	case ir.EscUnknown:
 		break
 
-	case EscHeap:
+	case ir.EscHeap:
 		text = "esc(h)"
 
-	case EscNone:
+	case ir.EscNone:
 		text = "esc(no)"
 
-	case EscNever:
+	case ir.EscNever:
 		text = "esc(N)"
 
 	default:
@@ -281,7 +281,7 @@ func (e *Escape) stmt(n ir.Node) {
 		return
 	}
 
-	lno := setlineno(n)
+	lno := ir.SetPos(n)
 	defer func() {
 		base.Pos = lno
 	}()
@@ -483,7 +483,7 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 		return
 	}
 
-	lno := setlineno(n)
+	lno := ir.SetPos(n)
 	defer func() {
 		base.Pos = lno
 	}()
@@ -564,7 +564,7 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 
 	case ir.OCONV, ir.OCONVNOP:
 		n := n.(*ir.ConvExpr)
-		if checkPtr(e.curfn, 2) && n.Type().IsUnsafePtr() && n.X.Type().IsPtr() {
+		if ir.ShouldCheckPtr(e.curfn, 2) && n.Type().IsUnsafePtr() && n.X.Type().IsPtr() {
 			// When -d=checkptr=2 is enabled, treat
 			// conversions to unsafe.Pointer as an
 			// escaping operation. This allows better
@@ -618,7 +618,7 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 		n := n.(*ir.CallPartExpr)
 		closureK := e.spill(k, n)
 
-		m := callpartMethod(n)
+		m := n.Method
 
 		// We don't know how the method value will be called
 		// later, so conservatively assume the result
@@ -725,7 +725,7 @@ func (e *Escape) unsafeValue(k EscHole, n ir.Node) {
 		}
 	case ir.ODOTPTR:
 		n := n.(*ir.SelectorExpr)
-		if isReflectHeaderDataField(n) {
+		if ir.IsReflectHeaderDataField(n) {
 			e.expr(k.deref(n, "reflect.Header.Data"), n.X)
 		} else {
 			e.discard(n.X)
@@ -825,7 +825,7 @@ func (e *Escape) assign(dst, src ir.Node, why string, where ir.Node) {
 	}
 
 	k := e.addr(dst)
-	if dst != nil && dst.Op() == ir.ODOTPTR && isReflectHeaderDataField(dst) {
+	if dst != nil && dst.Op() == ir.ODOTPTR && ir.IsReflectHeaderDataField(dst) {
 		e.unsafeValue(e.heapHole().note(where, why), src)
 	} else {
 		if ignore {
@@ -847,7 +847,7 @@ func (e *Escape) call(ks []EscHole, call, where ir.Node) {
 	if topLevelDefer {
 		// force stack allocation of defer record, unless
 		// open-coded defers are used (see ssa.go)
-		where.SetEsc(EscNever)
+		where.SetEsc(ir.EscNever)
 	}
 
 	argument := func(k EscHole, arg ir.Node) {
@@ -876,14 +876,14 @@ func (e *Escape) call(ks []EscHole, call, where ir.Node) {
 		var fn *ir.Name
 		switch call.Op() {
 		case ir.OCALLFUNC:
-			switch v := staticValue(call.X); {
+			switch v := ir.StaticValue(call.X); {
 			case v.Op() == ir.ONAME && v.(*ir.Name).Class_ == ir.PFUNC:
 				fn = v.(*ir.Name)
 			case v.Op() == ir.OCLOSURE:
 				fn = v.(*ir.ClosureExpr).Func.Nname
 			}
 		case ir.OCALLMETH:
-			fn = methodExprName(call.X)
+			fn = ir.MethodExprName(call.X)
 		}
 
 		fntype := call.X.Type()
@@ -1532,13 +1532,13 @@ func (e *Escape) finish(fns []*ir.Func) {
 					logopt.LogOpt(n.Pos(), "escape", "escape", ir.FuncName(e.curfn))
 				}
 			}
-			n.SetEsc(EscHeap)
+			n.SetEsc(ir.EscHeap)
 			addrescapes(n)
 		} else {
 			if base.Flag.LowerM != 0 && n.Op() != ir.ONAME {
 				base.WarnfAt(n.Pos(), "%v does not escape", n)
 			}
-			n.SetEsc(EscNone)
+			n.SetEsc(ir.EscNone)
 			if loc.transient {
 				switch n.Op() {
 				case ir.OCLOSURE:
@@ -1656,7 +1656,7 @@ func ParseLeaks(s string) EscLeaks {
 }
 
 func escapes(all []ir.Node) {
-	visitBottomUp(all, escapeFuncs)
+	ir.VisitFuncsBottomUp(all, escapeFuncs)
 }
 
 const (
@@ -1680,13 +1680,6 @@ func max8(a, b int8) int8 {
 	return b
 }
 
-const (
-	EscUnknown = iota
-	EscNone    // Does not escape to heap, result, or parameters.
-	EscHeap    // Reachable from the heap
-	EscNever   // By construction will not escape.
-)
-
 // funcSym returns fn.Nname.Sym if no nils are encountered along the way.
 func funcSym(fn *ir.Func) *types.Sym {
 	if fn == nil || fn.Nname == nil {
@@ -1801,14 +1794,14 @@ func isSelfAssign(dst, src ir.Node) bool {
 		// Safe trailing accessors that are permitted to differ.
 		dst := dst.(*ir.SelectorExpr)
 		src := src.(*ir.SelectorExpr)
-		return samesafeexpr(dst.X, src.X)
+		return ir.SameSafeExpr(dst.X, src.X)
 	case ir.OINDEX:
 		dst := dst.(*ir.IndexExpr)
 		src := src.(*ir.IndexExpr)
 		if mayAffectMemory(dst.Index) || mayAffectMemory(src.Index) {
 			return false
 		}
-		return samesafeexpr(dst.X, src.X)
+		return ir.SameSafeExpr(dst.X, src.X)
 	default:
 		return false
 	}
@@ -1876,18 +1869,18 @@ func heapAllocReason(n ir.Node) string {
 		}
 	}
 
-	if n.Type().Width > maxStackVarSize {
+	if n.Type().Width > ir.MaxStackVarSize {
 		return "too large for stack"
 	}
 
-	if (n.Op() == ir.ONEW || n.Op() == ir.OPTRLIT) && n.Type().Elem().Width >= maxImplicitStackVarSize {
+	if (n.Op() == ir.ONEW || n.Op() == ir.OPTRLIT) && n.Type().Elem().Width >= ir.MaxImplicitStackVarSize {
 		return "too large for stack"
 	}
 
-	if n.Op() == ir.OCLOSURE && closureType(n.(*ir.ClosureExpr)).Size() >= maxImplicitStackVarSize {
+	if n.Op() == ir.OCLOSURE && closureType(n.(*ir.ClosureExpr)).Size() >= ir.MaxImplicitStackVarSize {
 		return "too large for stack"
 	}
-	if n.Op() == ir.OCALLPART && partialCallType(n.(*ir.CallPartExpr)).Size() >= maxImplicitStackVarSize {
+	if n.Op() == ir.OCALLPART && partialCallType(n.(*ir.CallPartExpr)).Size() >= ir.MaxImplicitStackVarSize {
 		return "too large for stack"
 	}
 
@@ -1897,10 +1890,10 @@ func heapAllocReason(n ir.Node) string {
 		if r == nil {
 			r = n.Len
 		}
-		if !smallintconst(r) {
+		if !ir.IsSmallIntConst(r) {
 			return "non-constant size"
 		}
-		if t := n.Type(); t.Elem().Width != 0 && ir.Int64Val(r) >= maxImplicitStackVarSize/t.Elem().Width {
+		if t := n.Type(); t.Elem().Width != 0 && ir.Int64Val(r) >= ir.MaxImplicitStackVarSize/t.Elem().Width {
 			return "too large for stack"
 		}
 	}
@@ -1922,13 +1915,13 @@ func addrescapes(n ir.Node) {
 
 	case ir.ONAME:
 		n := n.(*ir.Name)
-		if n == nodfp {
+		if n == ir.RegFP {
 			break
 		}
 
 		// if this is a tmpname (PAUTO), it was tagged by tmpname as not escaping.
 		// on PPARAM it means something different.
-		if n.Class_ == ir.PAUTO && n.Esc() == EscNever {
+		if n.Class_ == ir.PAUTO && n.Esc() == ir.EscNever {
 			break
 		}
 
@@ -1954,12 +1947,12 @@ func addrescapes(n ir.Node) {
 		//
 		// then we're analyzing the inner closure but we need to move x to the
 		// heap in f, not in the inner closure. Flip over to f before calling moveToHeap.
-		oldfn := Curfn
-		Curfn = n.Curfn
+		oldfn := ir.CurFunc
+		ir.CurFunc = n.Curfn
 		ln := base.Pos
-		base.Pos = Curfn.Pos()
+		base.Pos = ir.CurFunc.Pos()
 		moveToHeap(n)
-		Curfn = oldfn
+		ir.CurFunc = oldfn
 		base.Pos = ln
 
 	// ODOTPTR has already been introduced,
@@ -2039,9 +2032,9 @@ func moveToHeap(n *ir.Name) {
 		// liveness and other analyses use the underlying stack slot
 		// and not the now-pseudo-variable n.
 		found := false
-		for i, d := range Curfn.Dcl {
+		for i, d := range ir.CurFunc.Dcl {
 			if d == n {
-				Curfn.Dcl[i] = stackcopy
+				ir.CurFunc.Dcl[i] = stackcopy
 				found = true
 				break
 			}
@@ -2054,14 +2047,14 @@ func moveToHeap(n *ir.Name) {
 		if !found {
 			base.Fatalf("cannot find %v in local variable list", n)
 		}
-		Curfn.Dcl = append(Curfn.Dcl, n)
+		ir.CurFunc.Dcl = append(ir.CurFunc.Dcl, n)
 	}
 
 	// Modify n in place so that uses of n now mean indirection of the heapaddr.
 	n.Class_ = ir.PAUTOHEAP
 	n.SetFrameOffset(0)
 	n.Heapaddr = heapaddr
-	n.SetEsc(EscHeap)
+	n.SetEsc(ir.EscHeap)
 	if base.Flag.LowerM != 0 {
 		base.WarnfAt(n.Pos(), "moved to heap: %v", n)
 	}
diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
index bcd58fd2c5..53298c878d 100644
--- a/src/cmd/compile/internal/gc/gen.go
+++ b/src/cmd/compile/internal/gc/gen.go
@@ -28,26 +28,6 @@ func sysvar(name string) *obj.LSym {
 	return ir.Pkgs.Runtime.Lookup(name).Linksym()
 }
 
-// isParamStackCopy reports whether this is the on-stack copy of a
-// function parameter that moved to the heap.
-func isParamStackCopy(n ir.Node) bool {
-	if n.Op() != ir.ONAME {
-		return false
-	}
-	name := n.(*ir.Name)
-	return (name.Class_ == ir.PPARAM || name.Class_ == ir.PPARAMOUT) && name.Heapaddr != nil
-}
-
-// isParamHeapCopy reports whether this is the on-heap copy of
-// a function parameter that moved to the heap.
-func isParamHeapCopy(n ir.Node) bool {
-	if n.Op() != ir.ONAME {
-		return false
-	}
-	name := n.(*ir.Name)
-	return name.Class_ == ir.PAUTOHEAP && name.Name().Stackcopy != nil
-}
-
 // autotmpname returns the name for an autotmp variable numbered n.
 func autotmpname(n int) string {
 	// Give each tmp a different name so that they can be registerized.
@@ -80,7 +60,7 @@ func tempAt(pos src.XPos, curfn *ir.Func, t *types.Type) *ir.Name {
 	s.Def = n
 	n.SetType(t)
 	n.Class_ = ir.PAUTO
-	n.SetEsc(EscNever)
+	n.SetEsc(ir.EscNever)
 	n.Curfn = curfn
 	n.SetUsed(true)
 	n.SetAutoTemp(true)
@@ -92,5 +72,5 @@ func tempAt(pos src.XPos, curfn *ir.Func, t *types.Type) *ir.Name {
 }
 
 func temp(t *types.Type) *ir.Name {
-	return tempAt(base.Pos, Curfn, t)
+	return tempAt(base.Pos, ir.CurFunc, t)
 }
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index 4b6ffe58d1..4370a06839 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -12,27 +12,6 @@ import (
 	"sync"
 )
 
-var (
-	// maximum size variable which we will allocate on the stack.
-	// This limit is for explicit variable declarations like "var x T" or "x := ...".
-	// Note: the flag smallframes can update this value.
-	maxStackVarSize = int64(10 * 1024 * 1024)
-
-	// maximum size of implicit variables that we will allocate on the stack.
-	//   p := new(T)          allocating T on the stack
-	//   p := &T{}            allocating T on the stack
-	//   s := make([]T, n)    allocating [n]T on the stack
-	//   s := []byte("...")   allocating [n]byte on the stack
-	// Note: the flag smallframes can update this value.
-	maxImplicitStackVarSize = int64(64 * 1024)
-
-	// smallArrayBytes is the maximum size of an array which is considered small.
-	// Small arrays will be initialized directly with a sequence of constant stores.
-	// Large arrays will be initialized by copying from a static temp.
-	// 256 bytes was chosen to minimize generated code + statictmp size.
-	smallArrayBytes = int64(256)
-)
-
 // Slices in the runtime are represented by three components:
 //
 // type slice struct {
@@ -89,16 +68,12 @@ var (
 
 var dclcontext ir.Class // PEXTERN/PAUTO
 
-var Curfn *ir.Func
-
 var Widthptr int
 
 var Widthreg int
 
 var typecheckok bool
 
-var nodfp *ir.Name
-
 // interface to back end
 
 type Arch struct {
diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go
index da2345c289..6ea9b354ab 100644
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ b/src/cmd/compile/internal/gc/gsubr.go
@@ -197,7 +197,7 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 	// Q: is this needed?
 	savepos := base.Pos
 	savedclcontext := dclcontext
-	savedcurfn := Curfn
+	savedcurfn := ir.CurFunc
 
 	base.Pos = base.AutogeneratedPos
 	dclcontext = ir.PEXTERN
@@ -270,7 +270,7 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 		tail = ir.NewBranchStmt(base.Pos, ir.ORETJMP, f.Nname.Sym())
 	} else {
 		call := ir.NewCallExpr(base.Pos, ir.OCALL, f.Nname, nil)
-		call.Args.Set(paramNnames(tfn.Type()))
+		call.Args.Set(ir.ParamNames(tfn.Type()))
 		call.IsDDD = tfn.Type().IsVariadic()
 		tail = call
 		if tfn.Type().NumResults() > 0 {
@@ -287,7 +287,7 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 	}
 
 	typecheckFunc(fn)
-	Curfn = fn
+	ir.CurFunc = fn
 	typecheckslice(fn.Body, ctxStmt)
 
 	escapeFuncs([]*ir.Func{fn}, false)
@@ -297,7 +297,7 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 	// Restore previous context.
 	base.Pos = savepos
 	dclcontext = savedclcontext
-	Curfn = savedcurfn
+	ir.CurFunc = savedcurfn
 }
 
 // initLSym defines f's obj.LSym and initializes it based on the
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/gc/iexport.go
index 56d2e81df1..fd64b69077 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/gc/iexport.go
@@ -816,7 +816,7 @@ func (w *exportWriter) value(typ *types.Type, v constant.Value) {
 
 func intSize(typ *types.Type) (signed bool, maxBytes uint) {
 	if typ.IsUntyped() {
-		return true, Mpprec / 8
+		return true, ir.ConstPrec / 8
 	}
 
 	switch typ.Kind() {
@@ -927,7 +927,7 @@ func (w *exportWriter) mpint(x constant.Value, typ *types.Type) {
 // multi-precision integer) and then the exponent, except exponent is
 // omitted if mantissa is zero.
 func (w *exportWriter) mpfloat(v constant.Value, typ *types.Type) {
-	f := bigFloatVal(v)
+	f := ir.BigFloat(v)
 	if f.IsInf() {
 		base.Fatalf("infinite constant")
 	}
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 90a909d2a3..d04c432e5e 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -327,7 +327,7 @@ func (r *importReader) doDecl(sym *types.Sym) *ir.Name {
 
 			fn := ir.NewFunc(mpos)
 			fn.SetType(mtyp)
-			m := newFuncNameAt(mpos, methodSym(recv.Type, msym), fn)
+			m := ir.NewFuncNameAt(mpos, ir.MethodSym(recv.Type, msym), fn)
 			m.SetType(mtyp)
 			m.Class_ = ir.PFUNC
 			// methodSym already marked m.Sym as a function.
@@ -1009,7 +1009,7 @@ func (r *importReader) node() ir.Node {
 		n.AsOp = r.op()
 		n.X = r.expr()
 		if !r.bool() {
-			n.Y = nodintconst(1)
+			n.Y = ir.NewInt(1)
 			n.IncDec = true
 		} else {
 			n.Y = r.expr()
diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index 4495284a07..f22e49efba 100644
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -66,9 +66,9 @@ func fninit() *ir.Name {
 		funcbody()
 
 		typecheckFunc(fn)
-		Curfn = fn
+		ir.CurFunc = fn
 		typecheckslice(nf, ctxStmt)
-		Curfn = nil
+		ir.CurFunc = nil
 		Target.Decls = append(Target.Decls, fn)
 		fns = append(fns, initializers.Linksym())
 	}
diff --git a/src/cmd/compile/internal/gc/initorder.go b/src/cmd/compile/internal/gc/initorder.go
index fe131c32a6..5caa2e769f 100644
--- a/src/cmd/compile/internal/gc/initorder.go
+++ b/src/cmd/compile/internal/gc/initorder.go
@@ -290,7 +290,7 @@ func (d *initDeps) visit(n ir.Node) {
 	switch n.Op() {
 	case ir.OMETHEXPR:
 		n := n.(*ir.MethodExpr)
-		d.foundDep(methodExprName(n))
+		d.foundDep(ir.MethodExprName(n))
 
 	case ir.ONAME:
 		n := n.(*ir.Name)
@@ -304,7 +304,7 @@ func (d *initDeps) visit(n ir.Node) {
 		d.inspectList(n.Func.Body)
 
 	case ir.ODOTMETH, ir.OCALLPART:
-		d.foundDep(methodExprName(n))
+		d.foundDep(ir.MethodExprName(n))
 	}
 }
 
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 47fdc7b9b7..f21494b291 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -39,9 +39,6 @@ import (
 	"strings"
 )
 
-// IsIntrinsicCall reports whether the compiler back end will treat the call as an intrinsic operation.
-var IsIntrinsicCall = func(*ir.CallExpr) bool { return false }
-
 // Inlining budget parameters, gathered in one place
 const (
 	inlineMaxBudget       = 80
@@ -57,7 +54,7 @@ const (
 
 func InlinePackage() {
 	// Find functions that can be inlined and clone them before walk expands them.
-	visitBottomUp(Target.Decls, func(list []*ir.Func, recursive bool) {
+	ir.VisitFuncsBottomUp(Target.Decls, func(list []*ir.Func, recursive bool) {
 		numfns := numNonClosures(list)
 		for _, n := range list {
 			if !recursive || numfns > 1 {
@@ -98,7 +95,7 @@ func fnpkg(fn *ir.Name) *types.Pkg {
 // Lazy typechecking of imported bodies. For local functions, caninl will set ->typecheck
 // because they're a copy of an already checked body.
 func typecheckinl(fn *ir.Func) {
-	lno := setlineno(fn.Nname)
+	lno := ir.SetPos(fn.Nname)
 
 	expandInline(fn)
 
@@ -116,10 +113,10 @@ func typecheckinl(fn *ir.Func) {
 		fmt.Printf("typecheck import [%v] %L { %v }\n", fn.Sym(), fn, ir.Nodes(fn.Inl.Body))
 	}
 
-	savefn := Curfn
-	Curfn = fn
+	savefn := ir.CurFunc
+	ir.CurFunc = fn
 	typecheckslice(fn.Inl.Body, ctxStmt)
-	Curfn = savefn
+	ir.CurFunc = savefn
 
 	// During expandInline (which imports fn.Func.Inl.Body),
 	// declarations are added to fn.Func.Dcl by funcHdr(). Move them
@@ -281,7 +278,7 @@ func inlFlood(n *ir.Name, exportsym func(*ir.Name)) {
 	ir.VisitList(ir.Nodes(fn.Inl.Body), func(n ir.Node) {
 		switch n.Op() {
 		case ir.OMETHEXPR, ir.ODOTMETH:
-			inlFlood(methodExprName(n), exportsym)
+			inlFlood(ir.MethodExprName(n), exportsym)
 
 		case ir.ONAME:
 			n := n.(*ir.Name)
@@ -362,7 +359,7 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 			}
 		}
 
-		if IsIntrinsicCall(n) {
+		if ir.IsIntrinsicCall(n) {
 			// Treat like any other node.
 			break
 		}
@@ -393,7 +390,7 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 				break
 			}
 		}
-		if inlfn := methodExprName(n.X).Func; inlfn.Inl != nil {
+		if inlfn := ir.MethodExprName(n.X).Func; inlfn.Inl != nil {
 			v.budget -= inlfn.Inl.Cost
 			break
 		}
@@ -502,8 +499,8 @@ func isBigFunc(fn *ir.Func) bool {
 // Inlcalls/nodelist/node walks fn's statements and expressions and substitutes any
 // calls made to inlineable functions. This is the external entry point.
 func inlcalls(fn *ir.Func) {
-	savefn := Curfn
-	Curfn = fn
+	savefn := ir.CurFunc
+	ir.CurFunc = fn
 	maxCost := int32(inlineMaxBudget)
 	if isBigFunc(fn) {
 		maxCost = inlineBigFunctionMaxCost
@@ -520,7 +517,7 @@ func inlcalls(fn *ir.Func) {
 		return inlnode(n, maxCost, inlMap, edit)
 	}
 	ir.EditChildren(fn, edit)
-	Curfn = savefn
+	ir.CurFunc = savefn
 }
 
 // Turn an OINLCALL into a statement.
@@ -536,7 +533,7 @@ func inlconv2stmt(inlcall *ir.InlinedCallExpr) ir.Node {
 // 	n.Left = inlconv2expr(n.Left)
 func inlconv2expr(n *ir.InlinedCallExpr) ir.Node {
 	r := n.ReturnVars[0]
-	return initExpr(append(n.Init(), n.Body...), r)
+	return ir.InitExpr(append(n.Init(), n.Body...), r)
 }
 
 // Turn the rlist (with the return values) of the OINLCALL in
@@ -550,7 +547,7 @@ func inlconv2list(n *ir.InlinedCallExpr) []ir.Node {
 	}
 
 	s := n.ReturnVars
-	s[0] = initExpr(append(n.Init(), n.Body...), s[0])
+	s[0] = ir.InitExpr(append(n.Init(), n.Body...), s[0])
 	return s
 }
 
@@ -594,7 +591,7 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.No
 		}
 	}
 
-	lno := setlineno(n)
+	lno := ir.SetPos(n)
 
 	ir.EditChildren(n, edit)
 
@@ -626,7 +623,7 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.No
 		if base.Flag.LowerM > 3 {
 			fmt.Printf("%v:call to func %+v\n", ir.Line(n), call.X)
 		}
-		if IsIntrinsicCall(call) {
+		if ir.IsIntrinsicCall(call) {
 			break
 		}
 		if fn := inlCallee(call.X); fn != nil && fn.Inl != nil {
@@ -644,7 +641,7 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.No
 			base.Fatalf("no function type for [%p] %+v\n", call.X, call.X)
 		}
 
-		n = mkinlcall(call, methodExprName(call.X).Func, maxCost, inlMap, edit)
+		n = mkinlcall(call, ir.MethodExprName(call.X).Func, maxCost, inlMap, edit)
 	}
 
 	base.Pos = lno
@@ -670,11 +667,11 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.No
 // inlCallee takes a function-typed expression and returns the underlying function ONAME
 // that it refers to if statically known. Otherwise, it returns nil.
 func inlCallee(fn ir.Node) *ir.Func {
-	fn = staticValue(fn)
+	fn = ir.StaticValue(fn)
 	switch fn.Op() {
 	case ir.OMETHEXPR:
 		fn := fn.(*ir.MethodExpr)
-		n := methodExprName(fn)
+		n := ir.MethodExprName(fn)
 		// Check that receiver type matches fn.Left.
 		// TODO(mdempsky): Handle implicit dereference
 		// of pointer receiver argument?
@@ -696,100 +693,6 @@ func inlCallee(fn ir.Node) *ir.Func {
 	return nil
 }
 
-func staticValue(n ir.Node) ir.Node {
-	for {
-		if n.Op() == ir.OCONVNOP {
-			n = n.(*ir.ConvExpr).X
-			continue
-		}
-
-		n1 := staticValue1(n)
-		if n1 == nil {
-			return n
-		}
-		n = n1
-	}
-}
-
-// staticValue1 implements a simple SSA-like optimization. If n is a local variable
-// that is initialized and never reassigned, staticValue1 returns the initializer
-// expression. Otherwise, it returns nil.
-func staticValue1(nn ir.Node) ir.Node {
-	if nn.Op() != ir.ONAME {
-		return nil
-	}
-	n := nn.(*ir.Name)
-	if n.Class_ != ir.PAUTO || n.Name().Addrtaken() {
-		return nil
-	}
-
-	defn := n.Name().Defn
-	if defn == nil {
-		return nil
-	}
-
-	var rhs ir.Node
-FindRHS:
-	switch defn.Op() {
-	case ir.OAS:
-		defn := defn.(*ir.AssignStmt)
-		rhs = defn.Y
-	case ir.OAS2:
-		defn := defn.(*ir.AssignListStmt)
-		for i, lhs := range defn.Lhs {
-			if lhs == n {
-				rhs = defn.Rhs[i]
-				break FindRHS
-			}
-		}
-		base.Fatalf("%v missing from LHS of %v", n, defn)
-	default:
-		return nil
-	}
-	if rhs == nil {
-		base.Fatalf("RHS is nil: %v", defn)
-	}
-
-	if reassigned(n) {
-		return nil
-	}
-
-	return rhs
-}
-
-// reassigned takes an ONAME node, walks the function in which it is defined, and returns a boolean
-// indicating whether the name has any assignments other than its declaration.
-// The second return value is the first such assignment encountered in the walk, if any. It is mostly
-// useful for -m output documenting the reason for inhibited optimizations.
-// NB: global variables are always considered to be re-assigned.
-// TODO: handle initial declaration not including an assignment and followed by a single assignment?
-func reassigned(name *ir.Name) bool {
-	if name.Op() != ir.ONAME {
-		base.Fatalf("reassigned %v", name)
-	}
-	// no way to reliably check for no-reassignment of globals, assume it can be
-	if name.Curfn == nil {
-		return true
-	}
-	return ir.Any(name.Curfn, func(n ir.Node) bool {
-		switch n.Op() {
-		case ir.OAS:
-			n := n.(*ir.AssignStmt)
-			if n.X == name && n != name.Defn {
-				return true
-			}
-		case ir.OAS2, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2DOTTYPE, ir.OAS2RECV, ir.OSELRECV2:
-			n := n.(*ir.AssignListStmt)
-			for _, p := range n.Lhs {
-				if p == name && n != name.Defn {
-					return true
-				}
-			}
-		}
-		return false
-	})
-}
-
 func inlParam(t *types.Field, as ir.Node, inlvars map[*ir.Name]ir.Node) ir.Node {
 	n := ir.AsNode(t.Nname)
 	if n == nil || ir.IsBlank(n) {
@@ -821,7 +724,7 @@ var SSADumpInline = func(*ir.Func) {}
 func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.Node) ir.Node) ir.Node {
 	if fn.Inl == nil {
 		if logopt.Enabled() {
-			logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", ir.FuncName(Curfn),
+			logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", ir.FuncName(ir.CurFunc),
 				fmt.Sprintf("%s cannot be inlined", ir.PkgFuncName(fn)))
 		}
 		return n
@@ -830,16 +733,16 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 		// The inlined function body is too big. Typically we use this check to restrict
 		// inlining into very big functions.  See issue 26546 and 17566.
 		if logopt.Enabled() {
-			logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", ir.FuncName(Curfn),
+			logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", ir.FuncName(ir.CurFunc),
 				fmt.Sprintf("cost %d of %s exceeds max large caller cost %d", fn.Inl.Cost, ir.PkgFuncName(fn), maxCost))
 		}
 		return n
 	}
 
-	if fn == Curfn {
+	if fn == ir.CurFunc {
 		// Can't recursively inline a function into itself.
 		if logopt.Enabled() {
-			logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", fmt.Sprintf("recursive call to %s", ir.FuncName(Curfn)))
+			logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", fmt.Sprintf("recursive call to %s", ir.FuncName(ir.CurFunc)))
 		}
 		return n
 	}
@@ -856,7 +759,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 
 	if inlMap[fn] {
 		if base.Flag.LowerM > 1 {
-			fmt.Printf("%v: cannot inline %v into %v: repeated recursive cycle\n", ir.Line(n), fn, ir.FuncName(Curfn))
+			fmt.Printf("%v: cannot inline %v into %v: repeated recursive cycle\n", ir.Line(n), fn, ir.FuncName(ir.CurFunc))
 		}
 		return n
 	}
@@ -916,7 +819,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 			// NB: if we enabled inlining of functions containing OCLOSURE or refined
 			// the reassigned check via some sort of copy propagation this would most
 			// likely need to be changed to a loop to walk up to the correct Param
-			if o == nil || o.Curfn != Curfn {
+			if o == nil || o.Curfn != ir.CurFunc {
 				base.Fatalf("%v: unresolvable capture %v %v\n", ir.Line(n), fn, v)
 			}
 
@@ -947,7 +850,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 		if ln.Class_ == ir.PPARAMOUT { // return values handled below.
 			continue
 		}
-		if isParamStackCopy(ln) { // ignore the on-stack copy of a parameter that moved to the heap
+		if ir.IsParamStackCopy(ln) { // ignore the on-stack copy of a parameter that moved to the heap
 			// TODO(mdempsky): Remove once I'm confident
 			// this never actually happens. We currently
 			// perform inlining before escape analysis, so
@@ -1162,10 +1065,10 @@ func inlvar(var_ ir.Node) ir.Node {
 	n.SetType(var_.Type())
 	n.Class_ = ir.PAUTO
 	n.SetUsed(true)
-	n.Curfn = Curfn // the calling function, not the called one
+	n.Curfn = ir.CurFunc // the calling function, not the called one
 	n.SetAddrtaken(var_.Name().Addrtaken())
 
-	Curfn.Dcl = append(Curfn.Dcl, n)
+	ir.CurFunc.Dcl = append(ir.CurFunc.Dcl, n)
 	return n
 }
 
@@ -1175,8 +1078,8 @@ func retvar(t *types.Field, i int) ir.Node {
 	n.SetType(t.Type)
 	n.Class_ = ir.PAUTO
 	n.SetUsed(true)
-	n.Curfn = Curfn // the calling function, not the called one
-	Curfn.Dcl = append(Curfn.Dcl, n)
+	n.Curfn = ir.CurFunc // the calling function, not the called one
+	ir.CurFunc.Dcl = append(ir.CurFunc.Dcl, n)
 	return n
 }
 
@@ -1187,8 +1090,8 @@ func argvar(t *types.Type, i int) ir.Node {
 	n.SetType(t.Elem())
 	n.Class_ = ir.PAUTO
 	n.SetUsed(true)
-	n.Curfn = Curfn // the calling function, not the called one
-	Curfn.Dcl = append(Curfn.Dcl, n)
+	n.Curfn = ir.CurFunc // the calling function, not the called one
+	ir.CurFunc.Dcl = append(ir.CurFunc.Dcl, n)
 	return n
 }
 
@@ -1358,7 +1261,7 @@ func pruneUnusedAutos(ll []*ir.Name, vis *hairyVisitor) []*ir.Name {
 // devirtualize replaces interface method calls within fn with direct
 // concrete-type method calls where applicable.
 func devirtualize(fn *ir.Func) {
-	Curfn = fn
+	ir.CurFunc = fn
 	ir.VisitList(fn.Body, func(n ir.Node) {
 		if n.Op() == ir.OCALLINTER {
 			devirtualizeCall(n.(*ir.CallExpr))
@@ -1368,7 +1271,7 @@ func devirtualize(fn *ir.Func) {
 
 func devirtualizeCall(call *ir.CallExpr) {
 	sel := call.X.(*ir.SelectorExpr)
-	r := staticValue(sel.X)
+	r := ir.StaticValue(sel.X)
 	if r.Op() != ir.OCONVIFACE {
 		return
 	}
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 1c52426802..d55a8b0a7c 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -134,8 +134,8 @@ func Main(archInit func(*Arch)) {
 	}
 
 	if base.Flag.SmallFrames {
-		maxStackVarSize = 128 * 1024
-		maxImplicitStackVarSize = 16 * 1024
+		ir.MaxStackVarSize = 128 * 1024
+		ir.MaxImplicitStackVarSize = 16 * 1024
 	}
 
 	if base.Flag.Dwarf {
@@ -185,7 +185,7 @@ func Main(archInit func(*Arch)) {
 	}
 
 	ir.EscFmt = escFmt
-	IsIntrinsicCall = isIntrinsicCall
+	ir.IsIntrinsicCall = isIntrinsicCall
 	SSADumpInline = ssaDumpInline
 	initSSAEnv()
 	initSSATables()
@@ -242,7 +242,7 @@ func Main(archInit func(*Arch)) {
 			devirtualize(n.(*ir.Func))
 		}
 	}
-	Curfn = nil
+	ir.CurFunc = nil
 
 	// Escape analysis.
 	// Required for moving heap allocations onto stack,
@@ -271,7 +271,7 @@ func Main(archInit func(*Arch)) {
 		if n.Op() == ir.ODCLFUNC {
 			n := n.(*ir.Func)
 			if n.OClosure != nil {
-				Curfn = n
+				ir.CurFunc = n
 				transformclosure(n)
 			}
 		}
@@ -285,7 +285,7 @@ func Main(archInit func(*Arch)) {
 	// Just before compilation, compile itabs found on
 	// the right side of OCONVIFACE so that methods
 	// can be de-virtualized during compilation.
-	Curfn = nil
+	ir.CurFunc = nil
 	peekitabs()
 
 	// Compile top level functions.
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 799887d6b8..c83b60dcd4 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -181,9 +181,9 @@ func (p *noder) openScope(pos syntax.Pos) {
 	types.Markdcl()
 
 	if p.trackScopes {
-		Curfn.Parents = append(Curfn.Parents, p.scope)
-		p.scopeVars = append(p.scopeVars, len(Curfn.Dcl))
-		p.scope = ir.ScopeID(len(Curfn.Parents))
+		ir.CurFunc.Parents = append(ir.CurFunc.Parents, p.scope)
+		p.scopeVars = append(p.scopeVars, len(ir.CurFunc.Dcl))
+		p.scope = ir.ScopeID(len(ir.CurFunc.Parents))
 
 		p.markScope(pos)
 	}
@@ -196,29 +196,29 @@ func (p *noder) closeScope(pos syntax.Pos) {
 	if p.trackScopes {
 		scopeVars := p.scopeVars[len(p.scopeVars)-1]
 		p.scopeVars = p.scopeVars[:len(p.scopeVars)-1]
-		if scopeVars == len(Curfn.Dcl) {
+		if scopeVars == len(ir.CurFunc.Dcl) {
 			// no variables were declared in this scope, so we can retract it.
 
-			if int(p.scope) != len(Curfn.Parents) {
+			if int(p.scope) != len(ir.CurFunc.Parents) {
 				base.Fatalf("scope tracking inconsistency, no variables declared but scopes were not retracted")
 			}
 
-			p.scope = Curfn.Parents[p.scope-1]
-			Curfn.Parents = Curfn.Parents[:len(Curfn.Parents)-1]
+			p.scope = ir.CurFunc.Parents[p.scope-1]
+			ir.CurFunc.Parents = ir.CurFunc.Parents[:len(ir.CurFunc.Parents)-1]
 
-			nmarks := len(Curfn.Marks)
-			Curfn.Marks[nmarks-1].Scope = p.scope
+			nmarks := len(ir.CurFunc.Marks)
+			ir.CurFunc.Marks[nmarks-1].Scope = p.scope
 			prevScope := ir.ScopeID(0)
 			if nmarks >= 2 {
-				prevScope = Curfn.Marks[nmarks-2].Scope
+				prevScope = ir.CurFunc.Marks[nmarks-2].Scope
 			}
-			if Curfn.Marks[nmarks-1].Scope == prevScope {
-				Curfn.Marks = Curfn.Marks[:nmarks-1]
+			if ir.CurFunc.Marks[nmarks-1].Scope == prevScope {
+				ir.CurFunc.Marks = ir.CurFunc.Marks[:nmarks-1]
 			}
 			return
 		}
 
-		p.scope = Curfn.Parents[p.scope-1]
+		p.scope = ir.CurFunc.Parents[p.scope-1]
 
 		p.markScope(pos)
 	}
@@ -226,10 +226,10 @@ func (p *noder) closeScope(pos syntax.Pos) {
 
 func (p *noder) markScope(pos syntax.Pos) {
 	xpos := p.makeXPos(pos)
-	if i := len(Curfn.Marks); i > 0 && Curfn.Marks[i-1].Pos == xpos {
-		Curfn.Marks[i-1].Scope = p.scope
+	if i := len(ir.CurFunc.Marks); i > 0 && ir.CurFunc.Marks[i-1].Pos == xpos {
+		ir.CurFunc.Marks[i-1].Scope = p.scope
 	} else {
-		Curfn.Marks = append(Curfn.Marks, ir.Mark{Pos: xpos, Scope: p.scope})
+		ir.CurFunc.Marks = append(ir.CurFunc.Marks, ir.Mark{Pos: xpos, Scope: p.scope})
 	}
 }
 
@@ -527,7 +527,7 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) ir.Node {
 		name = ir.BlankNode.Sym() // filled in by typecheckfunc
 	}
 
-	f.Nname = newFuncNameAt(p.pos(fun.Name), name, f)
+	f.Nname = ir.NewFuncNameAt(p.pos(fun.Name), name, f)
 	f.Nname.Defn = f
 	f.Nname.Ntype = t
 
@@ -996,13 +996,13 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) ir.Node {
 			// TODO(mdempsky): Line number?
 			return ir.NewBlockStmt(base.Pos, nil)
 		}
-		return liststmt(l)
+		return ir.NewBlockStmt(src.NoXPos, l)
 	case *syntax.ExprStmt:
 		return p.wrapname(stmt, p.expr(stmt.X))
 	case *syntax.SendStmt:
 		return ir.NewSendStmt(p.pos(stmt), p.expr(stmt.Chan), p.expr(stmt.Value))
 	case *syntax.DeclStmt:
-		return liststmt(p.decls(stmt.DeclList))
+		return ir.NewBlockStmt(src.NoXPos, p.decls(stmt.DeclList))
 	case *syntax.AssignStmt:
 		if stmt.Op != 0 && stmt.Op != syntax.Def {
 			n := ir.NewAssignOpStmt(p.pos(stmt), p.binOp(stmt.Op), p.expr(stmt.Lhs), p.expr(stmt.Rhs))
@@ -1065,8 +1065,8 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) ir.Node {
 		}
 		n := ir.NewReturnStmt(p.pos(stmt), nil)
 		n.Results.Set(results)
-		if len(n.Results) == 0 && Curfn != nil {
-			for _, ln := range Curfn.Dcl {
+		if len(n.Results) == 0 && ir.CurFunc != nil {
+			for _, ln := range ir.CurFunc.Dcl {
 				if ln.Class_ == ir.PPARAM {
 					continue
 				}
@@ -1344,7 +1344,7 @@ func (p *noder) labeledStmt(label *syntax.LabeledStmt, fallOK bool) ir.Node {
 			l = append(l, ls)
 		}
 	}
-	return liststmt(l)
+	return ir.NewBlockStmt(src.NoXPos, l)
 }
 
 var unOps = [...]ir.Op{
@@ -1451,7 +1451,7 @@ func (p *noder) basicLit(lit *syntax.BasicLit) constant.Value {
 	// to big.Float to match cmd/compile's historical precision.
 	// TODO(mdempsky): Remove.
 	if v.Kind() == constant.Float {
-		v = constant.Make(bigFloatVal(v))
+		v = constant.Make(ir.BigFloat(v))
 	}
 
 	return v
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 897bcce36f..e56e34a7a1 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -255,7 +255,7 @@ func dumpGlobalConst(n ir.Node) {
 	if t.IsUntyped() {
 		// Export untyped integers as int (if they fit).
 		t = types.Types[types.TINT]
-		if doesoverflow(v, t) {
+		if ir.ConstOverflow(v, t) {
 			return
 		}
 	}
@@ -279,7 +279,7 @@ func dumpfuncsyms() {
 		return funcsyms[i].LinksymName() < funcsyms[j].LinksymName()
 	})
 	for _, s := range funcsyms {
-		sf := s.Pkg.Lookup(funcsymname(s)).Linksym()
+		sf := s.Pkg.Lookup(ir.FuncSymName(s)).Linksym()
 		dsymptr(sf, 0, s.Linksym(), 0)
 		ggloblsym(sf, int32(Widthptr), obj.DUPOK|obj.RODATA)
 	}
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 9e792d153c..1cd33b2cb5 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -230,7 +230,7 @@ func (o *Order) safeExpr(n ir.Node) ir.Node {
 // because we emit explicit VARKILL instructions marking the end of those
 // temporaries' lifetimes.
 func isaddrokay(n ir.Node) bool {
-	return islvalue(n) && (n.Op() != ir.ONAME || n.(*ir.Name).Class_ == ir.PEXTERN || ir.IsAutoTmp(n))
+	return ir.IsAssignable(n) && (n.Op() != ir.ONAME || n.(*ir.Name).Class_ == ir.PEXTERN || ir.IsAutoTmp(n))
 }
 
 // addrTemp ensures that n is okay to pass by address to runtime routines.
@@ -381,13 +381,13 @@ func orderMakeSliceCopy(s []ir.Node) {
 	}
 
 	mk := as.Y.(*ir.MakeExpr)
-	if mk.Esc() == EscNone || mk.Len == nil || mk.Cap != nil {
+	if mk.Esc() == ir.EscNone || mk.Len == nil || mk.Cap != nil {
 		return
 	}
 	mk.SetOp(ir.OMAKESLICECOPY)
 	mk.Cap = cp.Y
 	// Set bounded when m = OMAKESLICE([]T, len(s)); OCOPY(m, s)
-	mk.SetBounded(mk.Len.Op() == ir.OLEN && samesafeexpr(mk.Len.(*ir.UnaryExpr).X, cp.Y))
+	mk.SetBounded(mk.Len.Op() == ir.OLEN && ir.SameSafeExpr(mk.Len.(*ir.UnaryExpr).X, cp.Y))
 	as.Y = typecheck(mk, ctxExpr)
 	s[1] = nil // remove separate copy call
 }
@@ -404,7 +404,7 @@ func (o *Order) edge() {
 	counter.Name().SetLibfuzzerExtraCounter(true)
 
 	// counter += 1
-	incr := ir.NewAssignOpStmt(base.Pos, ir.OADD, counter, nodintconst(1))
+	incr := ir.NewAssignOpStmt(base.Pos, ir.OADD, counter, ir.NewInt(1))
 	o.append(incr)
 }
 
@@ -429,7 +429,7 @@ func (o *Order) exprInPlace(n ir.Node) ir.Node {
 	var order Order
 	order.free = o.free
 	n = order.expr(n, nil)
-	n = initExpr(order.out, n)
+	n = ir.InitExpr(order.out, n)
 
 	// insert new temporaries from order
 	// at head of outer list.
@@ -448,7 +448,7 @@ func orderStmtInPlace(n ir.Node, free map[string][]*ir.Name) ir.Node {
 	mark := order.markTemp()
 	order.stmt(n)
 	order.cleanTemp(mark)
-	return liststmt(order.out)
+	return ir.NewBlockStmt(src.NoXPos, order.out)
 }
 
 // init moves n's init list to o.out.
@@ -615,7 +615,7 @@ func (o *Order) stmt(n ir.Node) {
 		return
 	}
 
-	lno := setlineno(n)
+	lno := ir.SetPos(n)
 	o.init(n)
 
 	switch n.Op() {
@@ -909,7 +909,7 @@ func (o *Order) stmt(n ir.Node) {
 		for _, ncas := range n.Cases {
 			ncas := ncas.(*ir.CaseStmt)
 			r := ncas.Comm
-			setlineno(ncas)
+			ir.SetPos(ncas)
 
 			// Append any new body prologue to ninit.
 			// The next loop will insert ninit into nbody.
@@ -1089,7 +1089,7 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 	if n == nil {
 		return n
 	}
-	lno := setlineno(n)
+	lno := ir.SetPos(n)
 	n = o.expr1(n, lhs)
 	base.Pos = lno
 	return n
@@ -1283,7 +1283,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 			o.exprList(n.Args)
 		}
 
-		if lhs == nil || lhs.Op() != ir.ONAME && !samesafeexpr(lhs, n.Args[0]) {
+		if lhs == nil || lhs.Op() != ir.ONAME && !ir.SameSafeExpr(lhs, n.Args[0]) {
 			return o.copyExpr(n)
 		}
 		return n
@@ -1299,7 +1299,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		max = o.expr(max, nil)
 		max = o.cheapExpr(max)
 		n.SetSliceBounds(low, high, max)
-		if lhs == nil || lhs.Op() != ir.ONAME && !samesafeexpr(lhs, n.X) {
+		if lhs == nil || lhs.Op() != ir.ONAME && !ir.SameSafeExpr(lhs, n.X) {
 			return o.copyExpr(n)
 		}
 		return n
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index d6c15f113b..44b614ba70 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -131,7 +131,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 				switch n.Class_ {
 				case ir.PPARAM, ir.PPARAMOUT:
 					// Don't modify nodfp; it is a global.
-					if n != nodfp {
+					if n != ir.RegFP {
 						n.Name().SetUsed(true)
 					}
 				case ir.PAUTO:
@@ -193,8 +193,8 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 }
 
 func funccompile(fn *ir.Func) {
-	if Curfn != nil {
-		base.Fatalf("funccompile %v inside %v", fn.Sym(), Curfn.Sym())
+	if ir.CurFunc != nil {
+		base.Fatalf("funccompile %v inside %v", fn.Sym(), ir.CurFunc.Sym())
 	}
 
 	if fn.Type() == nil {
@@ -215,9 +215,9 @@ func funccompile(fn *ir.Func) {
 	}
 
 	dclcontext = ir.PAUTO
-	Curfn = fn
+	ir.CurFunc = fn
 	compile(fn)
-	Curfn = nil
+	ir.CurFunc = nil
 	dclcontext = ir.PEXTERN
 }
 
@@ -234,7 +234,7 @@ func compile(fn *ir.Func) {
 	}
 
 	// From this point, there should be no uses of Curfn. Enforce that.
-	Curfn = nil
+	ir.CurFunc = nil
 
 	if ir.FuncName(fn) == "_" {
 		// We don't need to generate code for this function, just report errors in its body.
diff --git a/src/cmd/compile/internal/gc/racewalk.go b/src/cmd/compile/internal/gc/racewalk.go
index 67802fe917..e73e7fbbe1 100644
--- a/src/cmd/compile/internal/gc/racewalk.go
+++ b/src/cmd/compile/internal/gc/racewalk.go
@@ -35,7 +35,7 @@ func instrument(fn *ir.Func) {
 			// This only works for amd64. This will not
 			// work on arm or others that might support
 			// race in the future.
-			nodpc := nodfp.CloneName()
+			nodpc := ir.RegFP.CloneName()
 			nodpc.SetType(types.Types[types.TUINTPTR])
 			nodpc.SetFrameOffset(int64(-Widthptr))
 			fn.Dcl = append(fn.Dcl, nodpc)
diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index 463d0c55bd..a9447189c2 100644
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -160,7 +160,7 @@ func cheapComputableIndex(width int64) bool {
 func walkrange(nrange *ir.RangeStmt) ir.Node {
 	if isMapClear(nrange) {
 		m := nrange.X
-		lno := setlineno(m)
+		lno := ir.SetPos(m)
 		n := mapClear(m)
 		base.Pos = lno
 		return n
@@ -180,7 +180,7 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 	t := nrange.Type()
 
 	a := nrange.X
-	lno := setlineno(a)
+	lno := ir.SetPos(a)
 
 	var v1, v2 ir.Node
 	l := len(nrange.Vars)
@@ -228,7 +228,7 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		init = append(init, ir.NewAssignStmt(base.Pos, hn, ir.NewUnaryExpr(base.Pos, ir.OLEN, ha)))
 
 		nfor.Cond = ir.NewBinaryExpr(base.Pos, ir.OLT, hv1, hn)
-		nfor.Post = ir.NewAssignStmt(base.Pos, hv1, ir.NewBinaryExpr(base.Pos, ir.OADD, hv1, nodintconst(1)))
+		nfor.Post = ir.NewAssignStmt(base.Pos, hv1, ir.NewBinaryExpr(base.Pos, ir.OADD, hv1, ir.NewInt(1)))
 
 		// for range ha { body }
 		if v1 == nil {
@@ -272,7 +272,7 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		nfor.SetOp(ir.OFORUNTIL)
 
 		hp := temp(types.NewPtr(nrange.Type().Elem()))
-		tmp := ir.NewIndexExpr(base.Pos, ha, nodintconst(0))
+		tmp := ir.NewIndexExpr(base.Pos, ha, ir.NewInt(0))
 		tmp.SetBounded(true)
 		init = append(init, ir.NewAssignStmt(base.Pos, hp, nodAddr(tmp)))
 
@@ -335,7 +335,7 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		}
 		hb := temp(types.Types[types.TBOOL])
 
-		nfor.Cond = ir.NewBinaryExpr(base.Pos, ir.ONE, hb, nodbool(false))
+		nfor.Cond = ir.NewBinaryExpr(base.Pos, ir.ONE, hb, ir.NewBool(false))
 		a := ir.NewAssignListStmt(base.Pos, ir.OAS2RECV, nil, nil)
 		a.SetTypecheck(1)
 		a.Lhs = []ir.Node{hv1, hb}
@@ -392,10 +392,10 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 
 		// if hv2 < utf8.RuneSelf
 		nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
-		nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OLT, hv2, nodintconst(utf8.RuneSelf))
+		nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OLT, hv2, ir.NewInt(utf8.RuneSelf))
 
 		// hv1++
-		nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, hv1, ir.NewBinaryExpr(base.Pos, ir.OADD, hv1, nodintconst(1)))}
+		nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, hv1, ir.NewBinaryExpr(base.Pos, ir.OADD, hv1, ir.NewInt(1)))}
 
 		// } else {
 		eif := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
@@ -488,7 +488,7 @@ func isMapClear(n *ir.RangeStmt) bool {
 	}
 
 	m := n.X
-	if delete := stmt.(*ir.CallExpr); !samesafeexpr(delete.Args[0], m) || !samesafeexpr(delete.Args[1], k) {
+	if delete := stmt.(*ir.CallExpr); !ir.SameSafeExpr(delete.Args[0], m) || !ir.SameSafeExpr(delete.Args[1], k) {
 		return false
 	}
 
@@ -545,12 +545,12 @@ func arrayClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
 	}
 	lhs := stmt.X.(*ir.IndexExpr)
 
-	if !samesafeexpr(lhs.X, a) || !samesafeexpr(lhs.Index, v1) {
+	if !ir.SameSafeExpr(lhs.X, a) || !ir.SameSafeExpr(lhs.Index, v1) {
 		return nil
 	}
 
 	elemsize := loop.Type().Elem().Width
-	if elemsize <= 0 || !isZero(stmt.Y) {
+	if elemsize <= 0 || !ir.IsZero(stmt.Y) {
 		return nil
 	}
 
@@ -563,25 +563,25 @@ func arrayClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
 	// }
 	n := ir.NewIfStmt(base.Pos, nil, nil, nil)
 	n.Body.Set(nil)
-	n.Cond = ir.NewBinaryExpr(base.Pos, ir.ONE, ir.NewUnaryExpr(base.Pos, ir.OLEN, a), nodintconst(0))
+	n.Cond = ir.NewBinaryExpr(base.Pos, ir.ONE, ir.NewUnaryExpr(base.Pos, ir.OLEN, a), ir.NewInt(0))
 
 	// hp = &a[0]
 	hp := temp(types.Types[types.TUNSAFEPTR])
 
-	ix := ir.NewIndexExpr(base.Pos, a, nodintconst(0))
+	ix := ir.NewIndexExpr(base.Pos, a, ir.NewInt(0))
 	ix.SetBounded(true)
 	addr := convnop(nodAddr(ix), types.Types[types.TUNSAFEPTR])
 	n.Body.Append(ir.NewAssignStmt(base.Pos, hp, addr))
 
 	// hn = len(a) * sizeof(elem(a))
 	hn := temp(types.Types[types.TUINTPTR])
-	mul := conv(ir.NewBinaryExpr(base.Pos, ir.OMUL, ir.NewUnaryExpr(base.Pos, ir.OLEN, a), nodintconst(elemsize)), types.Types[types.TUINTPTR])
+	mul := conv(ir.NewBinaryExpr(base.Pos, ir.OMUL, ir.NewUnaryExpr(base.Pos, ir.OLEN, a), ir.NewInt(elemsize)), types.Types[types.TUINTPTR])
 	n.Body.Append(ir.NewAssignStmt(base.Pos, hn, mul))
 
 	var fn ir.Node
 	if a.Type().Elem().HasPointers() {
 		// memclrHasPointers(hp, hn)
-		Curfn.SetWBPos(stmt.Pos())
+		ir.CurFunc.SetWBPos(stmt.Pos())
 		fn = mkcall("memclrHasPointers", nil, nil, hp, hn)
 	} else {
 		// memclrNoHeapPointers(hp, hn)
@@ -591,7 +591,7 @@ func arrayClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
 	n.Body.Append(fn)
 
 	// i = len(a) - 1
-	v1 = ir.NewAssignStmt(base.Pos, v1, ir.NewBinaryExpr(base.Pos, ir.OSUB, ir.NewUnaryExpr(base.Pos, ir.OLEN, a), nodintconst(1)))
+	v1 = ir.NewAssignStmt(base.Pos, v1, ir.NewBinaryExpr(base.Pos, ir.OSUB, ir.NewUnaryExpr(base.Pos, ir.OLEN, a), ir.NewInt(1)))
 
 	n.Body.Append(v1)
 
@@ -608,7 +608,7 @@ func addptr(p ir.Node, n int64) ir.Node {
 	p = ir.NewConvExpr(base.Pos, ir.OCONVNOP, nil, p)
 	p.SetType(types.Types[types.TUINTPTR])
 
-	p = ir.NewBinaryExpr(base.Pos, ir.OADD, p, nodintconst(n))
+	p = ir.NewBinaryExpr(base.Pos, ir.OADD, p, ir.NewInt(n))
 
 	p = ir.NewConvExpr(base.Pos, ir.OCONVNOP, nil, p)
 	p.SetType(t)
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 41c9f93bf0..8b393a8979 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -349,12 +349,12 @@ func methodfunc(f *types.Type, receiver *types.Type) *types.Type {
 	in := make([]*ir.Field, 0, inLen)
 
 	if receiver != nil {
-		d := anonfield(receiver)
+		d := ir.NewField(base.Pos, nil, nil, receiver)
 		in = append(in, d)
 	}
 
 	for _, t := range f.Params().Fields().Slice() {
-		d := anonfield(t.Type)
+		d := ir.NewField(base.Pos, nil, nil, t.Type)
 		d.IsDDD = t.IsDDD()
 		in = append(in, d)
 	}
@@ -362,7 +362,7 @@ func methodfunc(f *types.Type, receiver *types.Type) *types.Type {
 	outLen := f.Results().Fields().Len()
 	out := make([]*ir.Field, 0, outLen)
 	for _, t := range f.Results().Fields().Slice() {
-		d := anonfield(t.Type)
+		d := ir.NewField(base.Pos, nil, nil, t.Type)
 		out = append(out, d)
 	}
 
@@ -416,8 +416,8 @@ func methods(t *types.Type) []*Sig {
 
 		sig := &Sig{
 			name:  method,
-			isym:  methodSym(it, method),
-			tsym:  methodSym(t, method),
+			isym:  ir.MethodSym(it, method),
+			tsym:  ir.MethodSym(t, method),
 			type_: methodfunc(f.Type, t),
 			mtype: methodfunc(f.Type, nil),
 		}
@@ -471,7 +471,7 @@ func imethods(t *types.Type) []*Sig {
 		// IfaceType.Method is not in the reflect data.
 		// Generate the method body, so that compiled
 		// code can refer to it.
-		isym := methodSym(t, f.Sym)
+		isym := ir.MethodSym(t, f.Sym)
 		if !isym.Siggen() {
 			isym.SetSiggen(true)
 			genwrapper(t, f, isym)
@@ -1541,7 +1541,7 @@ func dumpbasictypes() {
 		// The latter is the type of an auto-generated wrapper.
 		dtypesym(types.NewPtr(types.ErrorType))
 
-		dtypesym(functype(nil, []*ir.Field{anonfield(types.ErrorType)}, []*ir.Field{anonfield(types.Types[types.TSTRING])}))
+		dtypesym(functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, types.ErrorType)}, []*ir.Field{ir.NewField(base.Pos, nil, nil, types.Types[types.TSTRING])}))
 
 		// add paths for runtime and main, which 6l imports implicitly.
 		dimportpath(ir.Pkgs.Runtime)
diff --git a/src/cmd/compile/internal/gc/select.go b/src/cmd/compile/internal/gc/select.go
index 0bf070aa87..67a2cfd312 100644
--- a/src/cmd/compile/internal/gc/select.go
+++ b/src/cmd/compile/internal/gc/select.go
@@ -13,7 +13,7 @@ import (
 // select
 func typecheckselect(sel *ir.SelectStmt) {
 	var def ir.Node
-	lno := setlineno(sel)
+	lno := ir.SetPos(sel)
 	typecheckslice(sel.Init(), ctxStmt)
 	for _, ncase := range sel.Cases {
 		ncase := ncase.(*ir.CaseStmt)
@@ -94,7 +94,7 @@ func typecheckselect(sel *ir.SelectStmt) {
 }
 
 func walkselect(sel *ir.SelectStmt) {
-	lno := setlineno(sel)
+	lno := ir.SetPos(sel)
 	if len(sel.Compiled) != 0 {
 		base.Fatalf("double walkselect")
 	}
@@ -123,7 +123,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 	// optimization: one-case select: single op.
 	if ncas == 1 {
 		cas := cases[0].(*ir.CaseStmt)
-		setlineno(cas)
+		ir.SetPos(cas)
 		l := cas.Init()
 		if cas.Comm != nil { // not default:
 			n := cas.Comm
@@ -158,7 +158,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 	var dflt *ir.CaseStmt
 	for _, cas := range cases {
 		cas := cas.(*ir.CaseStmt)
-		setlineno(cas)
+		ir.SetPos(cas)
 		n := cas.Comm
 		if n == nil {
 			dflt = cas
@@ -187,7 +187,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 		}
 
 		n := cas.Comm
-		setlineno(n)
+		ir.SetPos(n)
 		r := ir.NewIfStmt(base.Pos, nil, nil, nil)
 		r.PtrInit().Set(cas.Init())
 		var call ir.Node
@@ -245,7 +245,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 	var pc0, pcs ir.Node
 	if base.Flag.Race {
 		pcs = temp(types.NewArray(types.Types[types.TUINTPTR], int64(ncas)))
-		pc0 = typecheck(nodAddr(ir.NewIndexExpr(base.Pos, pcs, nodintconst(0))), ctxExpr)
+		pc0 = typecheck(nodAddr(ir.NewIndexExpr(base.Pos, pcs, ir.NewInt(0))), ctxExpr)
 	} else {
 		pc0 = nodnil()
 	}
@@ -253,7 +253,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 	// register cases
 	for _, cas := range cases {
 		cas := cas.(*ir.CaseStmt)
-		setlineno(cas)
+		ir.SetPos(cas)
 
 		init = append(init, cas.Init()...)
 		cas.PtrInit().Set(nil)
@@ -286,7 +286,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 		casorder[i] = cas
 
 		setField := func(f string, val ir.Node) {
-			r := ir.NewAssignStmt(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, ir.NewIndexExpr(base.Pos, selv, nodintconst(int64(i))), lookup(f)), val)
+			r := ir.NewAssignStmt(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, ir.NewIndexExpr(base.Pos, selv, ir.NewInt(int64(i))), lookup(f)), val)
 			init = append(init, typecheck(r, ctxStmt))
 		}
 
@@ -300,7 +300,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 		// TODO(mdempsky): There should be a cleaner way to
 		// handle this.
 		if base.Flag.Race {
-			r := mkcall("selectsetpc", nil, nil, nodAddr(ir.NewIndexExpr(base.Pos, pcs, nodintconst(int64(i)))))
+			r := mkcall("selectsetpc", nil, nil, nodAddr(ir.NewIndexExpr(base.Pos, pcs, ir.NewInt(int64(i)))))
 			init = append(init, r)
 		}
 	}
@@ -315,7 +315,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 	r := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
 	r.Lhs = []ir.Node{chosen, recvOK}
 	fn := syslook("selectgo")
-	r.Rhs = []ir.Node{mkcall1(fn, fn.Type().Results(), nil, bytePtrToIndex(selv, 0), bytePtrToIndex(order, 0), pc0, nodintconst(int64(nsends)), nodintconst(int64(nrecvs)), nodbool(dflt == nil))}
+	r.Rhs = []ir.Node{mkcall1(fn, fn.Type().Results(), nil, bytePtrToIndex(selv, 0), bytePtrToIndex(order, 0), pc0, ir.NewInt(int64(nsends)), ir.NewInt(int64(nrecvs)), ir.NewBool(dflt == nil))}
 	init = append(init, typecheck(r, ctxStmt))
 
 	// selv and order are no longer alive after selectgo.
@@ -346,12 +346,12 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 	}
 
 	if dflt != nil {
-		setlineno(dflt)
-		dispatch(ir.NewBinaryExpr(base.Pos, ir.OLT, chosen, nodintconst(0)), dflt)
+		ir.SetPos(dflt)
+		dispatch(ir.NewBinaryExpr(base.Pos, ir.OLT, chosen, ir.NewInt(0)), dflt)
 	}
 	for i, cas := range casorder {
-		setlineno(cas)
-		dispatch(ir.NewBinaryExpr(base.Pos, ir.OEQ, chosen, nodintconst(int64(i))), cas)
+		ir.SetPos(cas)
+		dispatch(ir.NewBinaryExpr(base.Pos, ir.OEQ, chosen, ir.NewInt(int64(i))), cas)
 	}
 
 	return init
@@ -359,7 +359,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 
 // bytePtrToIndex returns a Node representing "(*byte)(&n[i])".
 func bytePtrToIndex(n ir.Node, i int64) ir.Node {
-	s := nodAddr(ir.NewIndexExpr(base.Pos, n, nodintconst(i)))
+	s := nodAddr(ir.NewIndexExpr(base.Pos, n, ir.NewInt(i)))
 	t := types.NewPtr(types.Types[types.TUINT8])
 	return convnop(s, t)
 }
@@ -370,8 +370,8 @@ var scase *types.Type
 func scasetype() *types.Type {
 	if scase == nil {
 		scase = tostruct([]*ir.Field{
-			namedfield("c", types.Types[types.TUNSAFEPTR]),
-			namedfield("elem", types.Types[types.TUNSAFEPTR]),
+			ir.NewField(base.Pos, lookup("c"), nil, types.Types[types.TUNSAFEPTR]),
+			ir.NewField(base.Pos, lookup("elem"), nil, types.Types[types.TUNSAFEPTR]),
 		})
 		scase.SetNoalg(true)
 	}
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index c9a554079d..936edb3d70 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -10,7 +10,6 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"fmt"
-	"go/constant"
 )
 
 type InitEntry struct {
@@ -65,7 +64,7 @@ func (s *InitSchedule) tryStaticInit(nn ir.Node) bool {
 		// Discard.
 		return true
 	}
-	lno := setlineno(n)
+	lno := ir.SetPos(n)
 	defer func() { base.Pos = lno }()
 	nam := n.X.(*ir.Name)
 	return s.staticassign(nam, 0, n.Y, nam.Type())
@@ -120,7 +119,7 @@ func (s *InitSchedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *type
 		return true
 
 	case ir.OLITERAL:
-		if isZero(r) {
+		if ir.IsZero(r) {
 			return true
 		}
 		litsym(l, loff, r, int(typ.Width))
@@ -170,7 +169,7 @@ func (s *InitSchedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *type
 			// copying someone else's computation.
 			ll := ir.NewNameOffsetExpr(base.Pos, l, loff+e.Xoffset, typ)
 			rr := ir.NewNameOffsetExpr(base.Pos, orig, e.Xoffset, typ)
-			setlineno(rr)
+			ir.SetPos(rr)
 			s.append(ir.NewAssignStmt(base.Pos, ll, rr))
 		}
 
@@ -198,7 +197,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 		return true
 
 	case ir.OLITERAL:
-		if isZero(r) {
+		if ir.IsZero(r) {
 			return true
 		}
 		litsym(l, loff, r, int(typ.Width))
@@ -263,7 +262,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 				litsym(l, loff+e.Xoffset, e.Expr, int(e.Expr.Type().Width))
 				continue
 			}
-			setlineno(e.Expr)
+			ir.SetPos(e.Expr)
 			if !s.staticassign(l, loff+e.Xoffset, e.Expr, e.Expr.Type()) {
 				a := ir.NewNameOffsetExpr(base.Pos, l, loff+e.Xoffset, e.Expr.Type())
 				s.append(ir.NewAssignStmt(base.Pos, a, e.Expr))
@@ -330,7 +329,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 				return true
 			}
 			// Copy val directly into n.
-			setlineno(val)
+			ir.SetPos(val)
 			if !s.staticassign(l, loff+int64(Widthptr), val, val.Type()) {
 				a := ir.NewNameOffsetExpr(base.Pos, l, loff+int64(Widthptr), val.Type())
 				s.append(ir.NewAssignStmt(base.Pos, a, val))
@@ -429,7 +428,7 @@ const (
 func getdyn(n ir.Node, top bool) initGenType {
 	switch n.Op() {
 	default:
-		if isGoConst(n) {
+		if ir.IsConstNode(n) {
 			return initConst
 		}
 		return initDynamic
@@ -548,7 +547,7 @@ func fixedlit(ctxt initContext, kind initKind, n *ir.CompLitExpr, var_ ir.Node,
 				}
 				r = kv.Value
 			}
-			a := ir.NewIndexExpr(base.Pos, var_, nodintconst(k))
+			a := ir.NewIndexExpr(base.Pos, var_, ir.NewInt(k))
 			k++
 			if isBlank {
 				return ir.BlankNode, r
@@ -561,7 +560,7 @@ func fixedlit(ctxt initContext, kind initKind, n *ir.CompLitExpr, var_ ir.Node,
 			if r.Field.IsBlank() || isBlank {
 				return ir.BlankNode, r.Value
 			}
-			setlineno(r)
+			ir.SetPos(r)
 			return ir.NewSelectorExpr(base.Pos, ir.ODOT, var_, r.Field), r.Value
 		}
 	default:
@@ -589,13 +588,13 @@ func fixedlit(ctxt initContext, kind initKind, n *ir.CompLitExpr, var_ ir.Node,
 			continue
 		}
 
-		islit := isGoConst(value)
+		islit := ir.IsConstNode(value)
 		if (kind == initKindStatic && !islit) || (kind == initKindDynamic && islit) {
 			continue
 		}
 
 		// build list of assignments: var[index] = expr
-		setlineno(a)
+		ir.SetPos(a)
 		as := ir.NewAssignStmt(base.Pos, a, value)
 		as = typecheck(as, ctxStmt).(*ir.AssignStmt)
 		switch kind {
@@ -617,7 +616,7 @@ func isSmallSliceLit(n *ir.CompLitExpr) bool {
 		return false
 	}
 
-	return n.Type().Elem().Width == 0 || n.Len <= smallArrayBytes/n.Type().Elem().Width
+	return n.Type().Elem().Width == 0 || n.Len <= ir.MaxSmallArraySize/n.Type().Elem().Width
 }
 
 func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes) {
@@ -697,7 +696,7 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 		}
 
 		a = nodAddr(x)
-	} else if n.Esc() == EscNone {
+	} else if n.Esc() == ir.EscNone {
 		a = temp(t)
 		if vstat == nil {
 			a = ir.NewAssignStmt(base.Pos, temp(t), nil)
@@ -731,7 +730,7 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 			}
 			value = kv.Value
 		}
-		a := ir.NewIndexExpr(base.Pos, vauto, nodintconst(index))
+		a := ir.NewIndexExpr(base.Pos, vauto, ir.NewInt(index))
 		a.SetBounded(true)
 		index++
 
@@ -753,12 +752,12 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 			continue
 		}
 
-		if vstat != nil && isGoConst(value) { // already set by copy from static value
+		if vstat != nil && ir.IsConstNode(value) { // already set by copy from static value
 			continue
 		}
 
 		// build list of vauto[c] = expr
-		setlineno(value)
+		ir.SetPos(value)
 		as := typecheck(ir.NewAssignStmt(base.Pos, a, value), ctxStmt)
 		as = orderStmtInPlace(as, map[string][]*ir.Name{})
 		as = walkstmt(as)
@@ -778,7 +777,7 @@ func maplit(n *ir.CompLitExpr, m ir.Node, init *ir.Nodes) {
 	// make the map var
 	a := ir.NewCallExpr(base.Pos, ir.OMAKE, nil, nil)
 	a.SetEsc(n.Esc())
-	a.Args = []ir.Node{ir.TypeNode(n.Type()), nodintconst(int64(len(n.List)))}
+	a.Args = []ir.Node{ir.TypeNode(n.Type()), ir.NewInt(int64(len(n.List)))}
 	litas(m, a, init)
 
 	entries := n.List
@@ -831,9 +830,9 @@ func maplit(n *ir.CompLitExpr, m ir.Node, init *ir.Nodes) {
 		kidx.SetBounded(true)
 		lhs := ir.NewIndexExpr(base.Pos, m, kidx)
 
-		zero := ir.NewAssignStmt(base.Pos, i, nodintconst(0))
-		cond := ir.NewBinaryExpr(base.Pos, ir.OLT, i, nodintconst(tk.NumElem()))
-		incr := ir.NewAssignStmt(base.Pos, i, ir.NewBinaryExpr(base.Pos, ir.OADD, i, nodintconst(1)))
+		zero := ir.NewAssignStmt(base.Pos, i, ir.NewInt(0))
+		cond := ir.NewBinaryExpr(base.Pos, ir.OLT, i, ir.NewInt(tk.NumElem()))
+		incr := ir.NewAssignStmt(base.Pos, i, ir.NewBinaryExpr(base.Pos, ir.OADD, i, ir.NewInt(1)))
 		body := ir.NewAssignStmt(base.Pos, lhs, rhs)
 
 		loop := ir.NewForStmt(base.Pos, nil, cond, incr, nil)
@@ -855,13 +854,13 @@ func maplit(n *ir.CompLitExpr, m ir.Node, init *ir.Nodes) {
 		r := r.(*ir.KeyExpr)
 		index, elem := r.Key, r.Value
 
-		setlineno(index)
+		ir.SetPos(index)
 		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, tmpkey, index))
 
-		setlineno(elem)
+		ir.SetPos(elem)
 		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, tmpelem, elem))
 
-		setlineno(tmpelem)
+		ir.SetPos(tmpelem)
 		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, ir.NewIndexExpr(base.Pos, m, tmpkey), tmpelem))
 	}
 
@@ -992,7 +991,7 @@ func oaslit(n *ir.AssignStmt, init *ir.Nodes) bool {
 }
 
 func getlit(lit ir.Node) int {
-	if smallintconst(lit) {
+	if ir.IsSmallIntConst(lit) {
 		return int(ir.Int64Val(lit))
 	}
 	return -1
@@ -1098,7 +1097,7 @@ func (s *InitSchedule) initplan(n ir.Node) {
 
 func (s *InitSchedule) addvalue(p *InitPlan, xoffset int64, n ir.Node) {
 	// special case: zero can be dropped entirely
-	if isZero(n) {
+	if ir.IsZero(n) {
 		return
 	}
 
@@ -1118,47 +1117,6 @@ func (s *InitSchedule) addvalue(p *InitPlan, xoffset int64, n ir.Node) {
 	p.E = append(p.E, InitEntry{Xoffset: xoffset, Expr: n})
 }
 
-func isZero(n ir.Node) bool {
-	switch n.Op() {
-	case ir.ONIL:
-		return true
-
-	case ir.OLITERAL:
-		switch u := n.Val(); u.Kind() {
-		case constant.String:
-			return constant.StringVal(u) == ""
-		case constant.Bool:
-			return !constant.BoolVal(u)
-		default:
-			return constant.Sign(u) == 0
-		}
-
-	case ir.OARRAYLIT:
-		n := n.(*ir.CompLitExpr)
-		for _, n1 := range n.List {
-			if n1.Op() == ir.OKEY {
-				n1 = n1.(*ir.KeyExpr).Value
-			}
-			if !isZero(n1) {
-				return false
-			}
-		}
-		return true
-
-	case ir.OSTRUCTLIT:
-		n := n.(*ir.CompLitExpr)
-		for _, n1 := range n.List {
-			n1 := n1.(*ir.StructKeyExpr)
-			if !isZero(n1.Value) {
-				return false
-			}
-		}
-		return true
-	}
-
-	return false
-}
-
 func isvaluelit(n ir.Node) bool {
 	return n.Op() == ir.OARRAYLIT || n.Op() == ir.OSTRUCTLIT
 }
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 22cc868f36..f879d8b86d 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -1159,7 +1159,7 @@ func (s *state) stmt(n ir.Node) {
 	// Expression statements
 	case ir.OCALLFUNC:
 		n := n.(*ir.CallExpr)
-		if IsIntrinsicCall(n) {
+		if ir.IsIntrinsicCall(n) {
 			s.intrinsicCall(n)
 			return
 		}
@@ -1186,7 +1186,7 @@ func (s *state) stmt(n ir.Node) {
 			var defertype string
 			if s.hasOpenDefers {
 				defertype = "open-coded"
-			} else if n.Esc() == EscNever {
+			} else if n.Esc() == ir.EscNever {
 				defertype = "stack-allocated"
 			} else {
 				defertype = "heap-allocated"
@@ -1197,7 +1197,7 @@ func (s *state) stmt(n ir.Node) {
 			s.openDeferRecord(n.Call.(*ir.CallExpr))
 		} else {
 			d := callDefer
-			if n.Esc() == EscNever {
+			if n.Esc() == ir.EscNever {
 				d = callDeferStack
 			}
 			s.callResult(n.Call.(*ir.CallExpr), d)
@@ -1232,7 +1232,7 @@ func (s *state) stmt(n ir.Node) {
 		// We come here only when it is an intrinsic call returning two values.
 		n := n.(*ir.AssignListStmt)
 		call := n.Rhs[0].(*ir.CallExpr)
-		if !IsIntrinsicCall(call) {
+		if !ir.IsIntrinsicCall(call) {
 			s.Fatalf("non-intrinsic AS2FUNC not expanded %v", call)
 		}
 		v := s.intrinsicCall(call)
@@ -1300,7 +1300,7 @@ func (s *state) stmt(n ir.Node) {
 				// All literals with nonzero fields have already been
 				// rewritten during walk. Any that remain are just T{}
 				// or equivalents. Use the zero value.
-				if !isZero(rhs) {
+				if !ir.IsZero(rhs) {
 					s.Fatalf("literal with nonzero value in SSA: %v", rhs)
 				}
 				rhs = nil
@@ -1309,7 +1309,7 @@ func (s *state) stmt(n ir.Node) {
 				// Check whether we're writing the result of an append back to the same slice.
 				// If so, we handle it specially to avoid write barriers on the fast
 				// (non-growth) path.
-				if !samesafeexpr(n.X, rhs.Args[0]) || base.Flag.N != 0 {
+				if !ir.SameSafeExpr(n.X, rhs.Args[0]) || base.Flag.N != 0 {
 					break
 				}
 				// If the slice can be SSA'd, it'll be on the stack,
@@ -1362,7 +1362,7 @@ func (s *state) stmt(n ir.Node) {
 		}
 
 		var skip skipMask
-		if rhs != nil && (rhs.Op() == ir.OSLICE || rhs.Op() == ir.OSLICE3 || rhs.Op() == ir.OSLICESTR) && samesafeexpr(rhs.(*ir.SliceExpr).X, n.X) {
+		if rhs != nil && (rhs.Op() == ir.OSLICE || rhs.Op() == ir.OSLICE3 || rhs.Op() == ir.OSLICESTR) && ir.SameSafeExpr(rhs.(*ir.SliceExpr).X, n.X) {
 			// We're assigning a slicing operation back to its source.
 			// Don't write back fields we aren't changing. See issue #14855.
 			rhs := rhs.(*ir.SliceExpr)
@@ -2085,7 +2085,7 @@ func (s *state) ssaShiftOp(op ir.Op, t *types.Type, u *types.Type) ssa.Op {
 
 // expr converts the expression n to ssa, adds it to s and returns the ssa result.
 func (s *state) expr(n ir.Node) *ssa.Value {
-	if hasUniquePos(n) {
+	if ir.HasUniquePos(n) {
 		// ONAMEs and named OLITERALs have the line number
 		// of the decl, not the use. See issue 14742.
 		s.pushLine(n.Pos())
@@ -2726,7 +2726,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 			// All literals with nonzero fields have already been
 			// rewritten during walk. Any that remain are just T{}
 			// or equivalents. Use the zero value.
-			if !isZero(n.X) {
+			if !ir.IsZero(n.X) {
 				s.Fatalf("literal with nonzero value in SSA: %v", n.X)
 			}
 			return s.zeroVal(n.Type())
@@ -2735,7 +2735,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		// SSA, then load just the selected field. This
 		// prevents false memory dependencies in race/msan
 		// instrumentation.
-		if islvalue(n) && !s.canSSA(n) {
+		if ir.IsAssignable(n) && !s.canSSA(n) {
 			p := s.addr(n)
 			return s.load(n.Type(), p)
 		}
@@ -2880,7 +2880,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 
 	case ir.OCALLFUNC:
 		n := n.(*ir.CallExpr)
-		if IsIntrinsicCall(n) {
+		if ir.IsIntrinsicCall(n) {
 			return s.intrinsicCall(n)
 		}
 		fallthrough
@@ -2901,7 +2901,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		// rewritten during walk. Any that remain are just T{}
 		// or equivalents. Use the zero value.
 		n := n.(*ir.CompLitExpr)
-		if !isZero(n) {
+		if !ir.IsZero(n) {
 			s.Fatalf("literal with nonzero value in SSA: %v", n)
 		}
 		return s.zeroVal(n.Type())
@@ -3236,7 +3236,7 @@ func (s *state) assign(left ir.Node, right *ssa.Value, deref bool, skip skipMask
 
 	// Left is not ssa-able. Compute its address.
 	addr := s.addr(left)
-	if isReflectHeaderDataField(left) {
+	if ir.IsReflectHeaderDataField(left) {
 		// Package unsafe's documentation says storing pointers into
 		// reflect.SliceHeader and reflect.StringHeader's Data fields
 		// is valid, even though they have type uintptr (#19168).
@@ -5021,7 +5021,7 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 			if v != nil {
 				return v
 			}
-			if n == nodfp {
+			if n == ir.RegFP {
 				// Special arg that points to the frame pointer (Used by ORECOVER).
 				return s.entryNewValue2A(ssa.OpLocalAddr, t, n, s.sp, s.startmem)
 			}
@@ -5141,7 +5141,7 @@ func (s *state) canSSAName(name *ir.Name) bool {
 	if name.Addrtaken() {
 		return false
 	}
-	if isParamHeapCopy(name) {
+	if ir.IsParamHeapCopy(name) {
 		return false
 	}
 	if name.Class_ == ir.PAUTOHEAP {
@@ -7271,7 +7271,7 @@ func (e *ssafn) SplitSlot(parent *ssa.LocalSlot, suffix string, offset int64, t
 	ir.AsNode(s.Def).Name().SetUsed(true)
 	n.SetType(t)
 	n.Class_ = ir.PAUTO
-	n.SetEsc(EscNever)
+	n.SetEsc(ir.EscNever)
 	n.Curfn = e.curfn
 	e.curfn.Dcl = append(e.curfn.Dcl, n)
 	dowidth(t)
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index a845abeb3a..bcf17e42d6 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -10,7 +10,6 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"fmt"
-	"go/constant"
 	"sort"
 	"strconv"
 	"strings"
@@ -32,40 +31,6 @@ var (
 	largeStackFrames   []largeStack
 )
 
-// hasUniquePos reports whether n has a unique position that can be
-// used for reporting error messages.
-//
-// It's primarily used to distinguish references to named objects,
-// whose Pos will point back to their declaration position rather than
-// their usage position.
-func hasUniquePos(n ir.Node) bool {
-	switch n.Op() {
-	case ir.ONAME, ir.OPACK:
-		return false
-	case ir.OLITERAL, ir.ONIL, ir.OTYPE:
-		if n.Sym() != nil {
-			return false
-		}
-	}
-
-	if !n.Pos().IsKnown() {
-		if base.Flag.K != 0 {
-			base.Warn("setlineno: unknown position (line 0)")
-		}
-		return false
-	}
-
-	return true
-}
-
-func setlineno(n ir.Node) src.XPos {
-	lno := base.Pos
-	if n != nil && hasUniquePos(n) {
-		base.Pos = n.Pos()
-	}
-	return lno
-}
-
 func lookup(name string) *types.Sym {
 	return types.LocalPkg.Lookup(name)
 }
@@ -89,8 +54,8 @@ func autolabel(prefix string) *types.Sym {
 	if prefix[0] != '.' {
 		base.Fatalf("autolabel prefix must start with '.', have %q", prefix)
 	}
-	fn := Curfn
-	if Curfn == nil {
+	fn := ir.CurFunc
+	if ir.CurFunc == nil {
 		base.Fatalf("autolabel outside function")
 	}
 	n := fn.Label
@@ -164,28 +129,16 @@ func nodAddrAt(pos src.XPos, n ir.Node) *ir.AddrExpr {
 // newname returns a new ONAME Node associated with symbol s.
 func NewName(s *types.Sym) *ir.Name {
 	n := ir.NewNameAt(base.Pos, s)
-	n.Curfn = Curfn
+	n.Curfn = ir.CurFunc
 	return n
 }
 
-func nodintconst(v int64) ir.Node {
-	return ir.NewLiteral(constant.MakeInt64(v))
-}
-
 func nodnil() ir.Node {
 	n := ir.NewNilExpr(base.Pos)
 	n.SetType(types.Types[types.TNIL])
 	return n
 }
 
-func nodbool(b bool) ir.Node {
-	return ir.NewLiteral(constant.MakeBool(b))
-}
-
-func nodstr(s string) ir.Node {
-	return ir.NewLiteral(constant.MakeString(s))
-}
-
 func isptrto(t *types.Type, et types.Kind) bool {
 	if t == nil {
 		return false
@@ -778,7 +731,7 @@ func safeexpr(n ir.Node, init *ir.Nodes) ir.Node {
 	}
 
 	// make a copy; must not be used as an lvalue
-	if islvalue(n) {
+	if ir.IsAssignable(n) {
 		base.Fatalf("missing lvalue case in safeexpr: %v", n)
 	}
 	return cheapexpr(n, init)
@@ -1109,7 +1062,7 @@ func structargs(tl *types.Type, mustname bool) []*ir.Field {
 			s = lookupN(".anon", gen)
 			gen++
 		}
-		a := symfield(s, t.Type)
+		a := ir.NewField(base.Pos, s, nil, t.Type)
 		a.Pos = t.Pos
 		a.IsDDD = t.IsDDD()
 		args = append(args, a)
@@ -1160,7 +1113,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	dclcontext = ir.PEXTERN
 
 	tfn := ir.NewFuncType(base.Pos,
-		namedfield(".this", rcvr),
+		ir.NewField(base.Pos, lookup(".this"), nil, rcvr),
 		structargs(method.Type.Params(), true),
 		structargs(method.Type.Results(), false))
 
@@ -1198,11 +1151,11 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 		}
 		as := ir.NewAssignStmt(base.Pos, nthis, convnop(left, rcvr))
 		fn.Body.Append(as)
-		fn.Body.Append(ir.NewBranchStmt(base.Pos, ir.ORETJMP, methodSym(methodrcvr, method.Sym)))
+		fn.Body.Append(ir.NewBranchStmt(base.Pos, ir.ORETJMP, ir.MethodSym(methodrcvr, method.Sym)))
 	} else {
 		fn.SetWrapper(true) // ignore frame for panic+recover matching
 		call := ir.NewCallExpr(base.Pos, ir.OCALL, dot, nil)
-		call.Args.Set(paramNnames(tfn.Type()))
+		call.Args.Set(ir.ParamNames(tfn.Type()))
 		call.IsDDD = tfn.Type().IsVariadic()
 		if method.Type.NumResults() > 0 {
 			ret := ir.NewReturnStmt(base.Pos, nil)
@@ -1223,7 +1176,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	}
 
 	typecheckFunc(fn)
-	Curfn = fn
+	ir.CurFunc = fn
 	typecheckslice(fn.Body, ctxStmt)
 
 	// Inline calls within (*T).M wrappers. This is safe because we only
@@ -1234,29 +1187,21 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	}
 	escapeFuncs([]*ir.Func{fn}, false)
 
-	Curfn = nil
+	ir.CurFunc = nil
 	Target.Decls = append(Target.Decls, fn)
 }
 
-func paramNnames(ft *types.Type) []ir.Node {
-	args := make([]ir.Node, ft.NumParams())
-	for i, f := range ft.Params().FieldSlice() {
-		args[i] = ir.AsNode(f.Nname)
-	}
-	return args
-}
-
 func hashmem(t *types.Type) ir.Node {
 	sym := ir.Pkgs.Runtime.Lookup("memhash")
 
 	n := NewName(sym)
-	setNodeNameFunc(n)
+	ir.MarkFunc(n)
 	n.SetType(functype(nil, []*ir.Field{
-		anonfield(types.NewPtr(t)),
-		anonfield(types.Types[types.TUINTPTR]),
-		anonfield(types.Types[types.TUINTPTR]),
+		ir.NewField(base.Pos, nil, nil, types.NewPtr(t)),
+		ir.NewField(base.Pos, nil, nil, types.Types[types.TUINTPTR]),
+		ir.NewField(base.Pos, nil, nil, types.Types[types.TUINTPTR]),
 	}, []*ir.Field{
-		anonfield(types.Types[types.TUINTPTR]),
+		ir.NewField(base.Pos, nil, nil, types.Types[types.TUINTPTR]),
 	}))
 	return n
 }
@@ -1367,15 +1312,6 @@ func implements(t, iface *types.Type, m, samename **types.Field, ptr *int) bool
 	return true
 }
 
-func liststmt(l []ir.Node) ir.Node {
-	n := ir.NewBlockStmt(base.Pos, nil)
-	n.List.Set(l)
-	if len(l) != 0 {
-		n.SetPos(l[0].Pos())
-	}
-	return n
-}
-
 func ngotype(n ir.Node) *types.Sym {
 	if n.Type() != nil {
 		return typenamesym(n.Type())
@@ -1383,25 +1319,6 @@ func ngotype(n ir.Node) *types.Sym {
 	return nil
 }
 
-// The result of initExpr MUST be assigned back to n, e.g.
-// 	n.Left = initExpr(init, n.Left)
-func initExpr(init []ir.Node, n ir.Node) ir.Node {
-	if len(init) == 0 {
-		return n
-	}
-	if ir.MayBeShared(n) {
-		// Introduce OCONVNOP to hold init list.
-		old := n
-		n = ir.NewConvExpr(base.Pos, ir.OCONVNOP, nil, old)
-		n.SetType(old.Type())
-		n.SetTypecheck(1)
-	}
-
-	n.PtrInit().Prepend(init...)
-	n.SetHasCall(true)
-	return n
-}
-
 // The linker uses the magic symbol prefixes "go." and "type."
 // Avoid potential confusion between import paths and symbols
 // by rejecting these reserved imports for now. Also, people
diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index 513b890355..5bbc91fcc1 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -190,7 +190,7 @@ func typecheckExprSwitch(n *ir.SwitchStmt) {
 		}
 
 		for i := range ls {
-			setlineno(ncase)
+			ir.SetPos(ncase)
 			ls[i] = typecheck(ls[i], ctxExpr)
 			ls[i] = defaultlit(ls[i], t)
 			n1 := ls[i]
@@ -246,14 +246,14 @@ func walkswitch(sw *ir.SwitchStmt) {
 // walkExprSwitch generates an AST implementing sw.  sw is an
 // expression switch.
 func walkExprSwitch(sw *ir.SwitchStmt) {
-	lno := setlineno(sw)
+	lno := ir.SetPos(sw)
 
 	cond := sw.Tag
 	sw.Tag = nil
 
 	// convert switch {...} to switch true {...}
 	if cond == nil {
-		cond = nodbool(true)
+		cond = ir.NewBool(true)
 		cond = typecheck(cond, ctxExpr)
 		cond = defaultlit(cond, nil)
 	}
@@ -398,11 +398,11 @@ func (s *exprSwitch) flush() {
 		// Perform two-level binary search.
 		binarySearch(len(runs), &s.done,
 			func(i int) ir.Node {
-				return ir.NewBinaryExpr(base.Pos, ir.OLE, ir.NewUnaryExpr(base.Pos, ir.OLEN, s.exprname), nodintconst(runLen(runs[i-1])))
+				return ir.NewBinaryExpr(base.Pos, ir.OLE, ir.NewUnaryExpr(base.Pos, ir.OLEN, s.exprname), ir.NewInt(runLen(runs[i-1])))
 			},
 			func(i int, nif *ir.IfStmt) {
 				run := runs[i]
-				nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OEQ, ir.NewUnaryExpr(base.Pos, ir.OLEN, s.exprname), nodintconst(runLen(run)))
+				nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OEQ, ir.NewUnaryExpr(base.Pos, ir.OLEN, s.exprname), ir.NewInt(runLen(run)))
 				s.search(run, &nif.Body)
 			},
 		)
@@ -708,13 +708,13 @@ func (s *typeSwitch) flush() {
 
 	binarySearch(len(cc), &s.done,
 		func(i int) ir.Node {
-			return ir.NewBinaryExpr(base.Pos, ir.OLE, s.hashname, nodintconst(int64(cc[i-1].hash)))
+			return ir.NewBinaryExpr(base.Pos, ir.OLE, s.hashname, ir.NewInt(int64(cc[i-1].hash)))
 		},
 		func(i int, nif *ir.IfStmt) {
 			// TODO(mdempsky): Omit hash equality check if
 			// there's only one type.
 			c := cc[i]
-			nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OEQ, s.hashname, nodintconst(int64(c.hash)))
+			nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OEQ, s.hashname, ir.NewInt(int64(c.hash)))
 			nif.Body.Append(c.body.Take()...)
 		},
 	)
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 5e13facc4f..0beb5712d4 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -98,13 +98,13 @@ func TypecheckPackage() {
 		if n.Op() == ir.ODCLFUNC {
 			n := n.(*ir.Func)
 			if n.OClosure != nil {
-				Curfn = n
+				ir.CurFunc = n
 				capturevars(n)
 			}
 		}
 	}
 	capturevarscomplete = true
-	Curfn = nil
+	ir.CurFunc = nil
 
 	if base.Debug.TypecheckInl != 0 {
 		// Typecheck imported function bodies if Debug.l > 1,
@@ -139,7 +139,7 @@ func TypecheckCallee(n ir.Node) ir.Node {
 }
 
 func TypecheckFuncBody(n *ir.Func) {
-	Curfn = n
+	ir.CurFunc = n
 	decldepth = 1
 	errorsBefore := base.Errors()
 	typecheckslice(n.Body, ctxStmt)
@@ -259,7 +259,7 @@ func resolve(n ir.Node) (res ir.Node) {
 
 	if r.Op() == ir.OIOTA {
 		if x := getIotaValue(); x >= 0 {
-			return nodintconst(x)
+			return ir.NewInt(x)
 		}
 		return n
 	}
@@ -380,7 +380,7 @@ func typecheck(n ir.Node, top int) (res ir.Node) {
 		defer tracePrint("typecheck", n)(&res)
 	}
 
-	lno := setlineno(n)
+	lno := ir.SetPos(n)
 
 	// Skip over parens.
 	for n.Op() == ir.OPAREN {
@@ -682,7 +682,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 
 		v := size.Val()
-		if doesoverflow(v, types.Types[types.TINT]) {
+		if ir.ConstOverflow(v, types.Types[types.TINT]) {
 			base.Errorf("array bound is too large")
 			return n
 		}
@@ -1076,7 +1076,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 		default:
 			checklvalue(n.X, "take the address of")
-			r := outervalue(n.X)
+			r := ir.OuterValue(n.X)
 			if r.Op() == ir.ONAME {
 				r := r.(*ir.Name)
 				if ir.Orig(r) != r {
@@ -1270,7 +1270,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 					base.Errorf("invalid array index %v (out of bounds for %d-element array)", n.Index, t.NumElem())
 				} else if ir.IsConst(n.X, constant.String) && constant.Compare(x, token.GEQ, constant.MakeInt64(int64(len(ir.StringVal(n.X))))) {
 					base.Errorf("invalid string index %v (out of bounds for %d-byte string)", n.Index, len(ir.StringVal(n.X)))
-				} else if doesoverflow(x, types.Types[types.TINT]) {
+				} else if ir.ConstOverflow(x, types.Types[types.TINT]) {
 					base.Errorf("invalid %s index %v (index too large)", why, n.Index)
 				}
 			}
@@ -1412,7 +1412,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 
 		if ir.IsConst(n.Len, constant.Int) {
-			if doesoverflow(n.Len.Val(), types.Types[types.TINT]) {
+			if ir.ConstOverflow(n.Len.Val(), types.Types[types.TINT]) {
 				base.Fatalf("len for OMAKESLICECOPY too large")
 			}
 			if constant.Sign(n.Len.Val()) < 0 {
@@ -1440,7 +1440,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			return n
 		}
 		if l.Type().IsArray() {
-			if !islvalue(n.X) {
+			if !ir.IsAssignable(n.X) {
 				base.Errorf("invalid operation %v (slice of unaddressable value)", n)
 				n.SetType(nil)
 				return n
@@ -1538,7 +1538,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 					return n
 				}
 				u := ir.NewUnaryExpr(n.Pos(), l.BuiltinOp, arg)
-				return typecheck(initExpr(n.Init(), u), top) // typecheckargs can add to old.Init
+				return typecheck(ir.InitExpr(n.Init(), u), top) // typecheckargs can add to old.Init
 
 			case ir.OCOMPLEX, ir.OCOPY:
 				typecheckargs(n)
@@ -1548,7 +1548,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 					return n
 				}
 				b := ir.NewBinaryExpr(n.Pos(), l.BuiltinOp, arg1, arg2)
-				return typecheck(initExpr(n.Init(), b), top) // typecheckargs can add to old.Init
+				return typecheck(ir.InitExpr(n.Init(), b), top) // typecheckargs can add to old.Init
 			}
 			panic("unreachable")
 		}
@@ -2023,7 +2023,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 					return n
 				}
 			} else {
-				l = nodintconst(0)
+				l = ir.NewInt(0)
 			}
 			nn = ir.NewMakeExpr(n.Pos(), ir.OMAKEMAP, l, nil)
 			nn.SetEsc(n.Esc())
@@ -2044,7 +2044,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 					return n
 				}
 			} else {
-				l = nodintconst(0)
+				l = ir.NewInt(0)
 			}
 			nn = ir.NewMakeExpr(n.Pos(), ir.OMAKECHAN, l, nil)
 		}
@@ -2257,16 +2257,16 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 	case ir.ORETURN:
 		n := n.(*ir.ReturnStmt)
 		typecheckargs(n)
-		if Curfn == nil {
+		if ir.CurFunc == nil {
 			base.Errorf("return outside function")
 			n.SetType(nil)
 			return n
 		}
 
-		if hasNamedResults(Curfn) && len(n.Results) == 0 {
+		if ir.HasNamedResults(ir.CurFunc) && len(n.Results) == 0 {
 			return n
 		}
-		typecheckaste(ir.ORETURN, nil, false, Curfn.Type().Results(), n.Results, func() string { return "return argument" })
+		typecheckaste(ir.ORETURN, nil, false, ir.CurFunc.Type().Results(), n.Results, func() string { return "return argument" })
 		return n
 
 	case ir.ORETJMP:
@@ -2352,9 +2352,9 @@ func typecheckargs(n ir.Node) {
 	// init.go hasn't yet created it. Instead, associate the
 	// temporary variables with initTodo for now, and init.go
 	// will reassociate them later when it's appropriate.
-	static := Curfn == nil
+	static := ir.CurFunc == nil
 	if static {
-		Curfn = initTodo
+		ir.CurFunc = initTodo
 	}
 	list = nil
 	for _, f := range t.FieldSlice() {
@@ -2364,7 +2364,7 @@ func typecheckargs(n ir.Node) {
 		list = append(list, t)
 	}
 	if static {
-		Curfn = nil
+		ir.CurFunc = nil
 	}
 
 	switch n := n.(type) {
@@ -2398,7 +2398,7 @@ func checksliceindex(l ir.Node, r ir.Node, tp *types.Type) bool {
 		} else if ir.IsConst(l, constant.String) && constant.Compare(x, token.GTR, constant.MakeInt64(int64(len(ir.StringVal(l))))) {
 			base.Errorf("invalid slice index %v (out of bounds for %d-byte string)", r, len(ir.StringVal(l)))
 			return false
-		} else if doesoverflow(x, types.Types[types.TINT]) {
+		} else if ir.ConstOverflow(x, types.Types[types.TINT]) {
 			base.Errorf("invalid slice index %v (index too large)", r)
 			return false
 		}
@@ -2603,7 +2603,7 @@ func typecheckMethodExpr(n *ir.SelectorExpr) (res ir.Node) {
 
 	me := ir.NewMethodExpr(n.Pos(), n.X.Type(), m)
 	me.SetType(methodfunc(m.Type, n.X.Type()))
-	f := NewName(methodSym(t, m.Sym))
+	f := NewName(ir.MethodSym(t, m.Sym))
 	f.Class_ = ir.PFUNC
 	f.SetType(me.Type())
 	me.FuncName_ = f
@@ -2717,7 +2717,7 @@ func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 			return nil
 		}
 
-		n.Sel = methodSym(n.X.Type(), f2.Sym)
+		n.Sel = ir.MethodSym(n.X.Type(), f2.Sym)
 		n.Offset = f2.Offset
 		n.SetType(f2.Type)
 		n.SetOp(ir.ODOTMETH)
@@ -2801,7 +2801,7 @@ func typecheckaste(op ir.Op, call ir.Node, isddd bool, tstruct *types.Type, nl i
 					goto toomany
 				}
 				n = nl[i]
-				setlineno(n)
+				ir.SetPos(n)
 				if n.Type() != nil {
 					nl[i] = assignconvfn(n, t, desc)
 				}
@@ -2811,7 +2811,7 @@ func typecheckaste(op ir.Op, call ir.Node, isddd bool, tstruct *types.Type, nl i
 			// TODO(mdempsky): Make into ... call with implicit slice.
 			for ; i < len(nl); i++ {
 				n = nl[i]
-				setlineno(n)
+				ir.SetPos(n)
 				if n.Type() != nil {
 					nl[i] = assignconvfn(n, t.Elem(), desc)
 				}
@@ -2823,7 +2823,7 @@ func typecheckaste(op ir.Op, call ir.Node, isddd bool, tstruct *types.Type, nl i
 			goto notenough
 		}
 		n = nl[i]
-		setlineno(n)
+		ir.SetPos(n)
 		if n.Type() != nil {
 			nl[i] = assignconvfn(n, t, desc)
 		}
@@ -2998,7 +2998,7 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 	// Save original node (including n.Right)
 	n.SetOrig(ir.Copy(n))
 
-	setlineno(n.Ntype)
+	ir.SetPos(n.Ntype)
 
 	// Need to handle [...]T arrays specially.
 	if array, ok := n.Ntype.(*ir.ArrayType); ok && array.Elem != nil && array.Len == nil {
@@ -3042,7 +3042,7 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 	case types.TMAP:
 		var cs constSet
 		for i3, l := range n.List {
-			setlineno(l)
+			ir.SetPos(l)
 			if l.Op() != ir.OKEY {
 				n.List[i3] = typecheck(l, ctxExpr)
 				base.Errorf("missing key in map literal")
@@ -3074,7 +3074,7 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 			// simple list of variables
 			ls := n.List
 			for i, n1 := range ls {
-				setlineno(n1)
+				ir.SetPos(n1)
 				n1 = typecheck(n1, ctxExpr)
 				ls[i] = n1
 				if i >= t.NumFields() {
@@ -3105,7 +3105,7 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 			// keyed list
 			ls := n.List
 			for i, l := range ls {
-				setlineno(l)
+				ir.SetPos(l)
 
 				if l.Op() == ir.OKEY {
 					kv := l.(*ir.KeyExpr)
@@ -3199,7 +3199,7 @@ func typecheckarraylit(elemType *types.Type, bound int64, elts []ir.Node, ctx st
 
 	var key, length int64
 	for i, elt := range elts {
-		setlineno(elt)
+		ir.SetPos(elt)
 		r := elts[i]
 		var kv *ir.KeyExpr
 		if elt.Op() == ir.OKEY {
@@ -3264,41 +3264,8 @@ func nonexported(sym *types.Sym) bool {
 	return sym != nil && !types.IsExported(sym.Name)
 }
 
-// lvalue etc
-func islvalue(n ir.Node) bool {
-	switch n.Op() {
-	case ir.OINDEX:
-		n := n.(*ir.IndexExpr)
-		if n.X.Type() != nil && n.X.Type().IsArray() {
-			return islvalue(n.X)
-		}
-		if n.X.Type() != nil && n.X.Type().IsString() {
-			return false
-		}
-		fallthrough
-	case ir.ODEREF, ir.ODOTPTR, ir.OCLOSUREREAD:
-		return true
-
-	case ir.ODOT:
-		n := n.(*ir.SelectorExpr)
-		return islvalue(n.X)
-
-	case ir.ONAME:
-		n := n.(*ir.Name)
-		if n.Class_ == ir.PFUNC {
-			return false
-		}
-		return true
-
-	case ir.ONAMEOFFSET:
-		return true
-	}
-
-	return false
-}
-
 func checklvalue(n ir.Node, verb string) {
-	if !islvalue(n) {
+	if !ir.IsAssignable(n) {
 		base.Errorf("cannot %s %v", verb, n)
 	}
 }
@@ -3306,7 +3273,7 @@ func checklvalue(n ir.Node, verb string) {
 func checkassign(stmt ir.Node, n ir.Node) {
 	// Variables declared in ORANGE are assigned on every iteration.
 	if !ir.DeclaredBy(n, stmt) || stmt.Op() == ir.ORANGE {
-		r := outervalue(n)
+		r := ir.OuterValue(n)
 		if r.Op() == ir.ONAME {
 			r := r.(*ir.Name)
 			r.Name().SetAssigned(true)
@@ -3316,7 +3283,7 @@ func checkassign(stmt ir.Node, n ir.Node) {
 		}
 	}
 
-	if islvalue(n) {
+	if ir.IsAssignable(n) {
 		return
 	}
 	if n.Op() == ir.OINDEXMAP {
@@ -3335,7 +3302,7 @@ func checkassign(stmt ir.Node, n ir.Node) {
 		base.Errorf("cannot assign to struct field %v in map", n)
 	case (n.Op() == ir.OINDEX && n.(*ir.IndexExpr).X.Type().IsString()) || n.Op() == ir.OSLICESTR:
 		base.Errorf("cannot assign to %v (strings are immutable)", n)
-	case n.Op() == ir.OLITERAL && n.Sym() != nil && isGoConst(n):
+	case n.Op() == ir.OLITERAL && n.Sym() != nil && ir.IsConstNode(n):
 		base.Errorf("cannot assign to %v (declared const)", n)
 	default:
 		base.Errorf("cannot assign to %v", n)
@@ -3349,77 +3316,6 @@ func checkassignlist(stmt ir.Node, l ir.Nodes) {
 	}
 }
 
-// samesafeexpr checks whether it is safe to reuse one of l and r
-// instead of computing both. samesafeexpr assumes that l and r are
-// used in the same statement or expression. In order for it to be
-// safe to reuse l or r, they must:
-// * be the same expression
-// * not have side-effects (no function calls, no channel ops);
-//   however, panics are ok
-// * not cause inappropriate aliasing; e.g. two string to []byte
-//   conversions, must result in two distinct slices
-//
-// The handling of OINDEXMAP is subtle. OINDEXMAP can occur both
-// as an lvalue (map assignment) and an rvalue (map access). This is
-// currently OK, since the only place samesafeexpr gets used on an
-// lvalue expression is for OSLICE and OAPPEND optimizations, and it
-// is correct in those settings.
-func samesafeexpr(l ir.Node, r ir.Node) bool {
-	if l.Op() != r.Op() || !types.Identical(l.Type(), r.Type()) {
-		return false
-	}
-
-	switch l.Op() {
-	case ir.ONAME, ir.OCLOSUREREAD:
-		return l == r
-
-	case ir.ODOT, ir.ODOTPTR:
-		l := l.(*ir.SelectorExpr)
-		r := r.(*ir.SelectorExpr)
-		return l.Sel != nil && r.Sel != nil && l.Sel == r.Sel && samesafeexpr(l.X, r.X)
-
-	case ir.ODEREF:
-		l := l.(*ir.StarExpr)
-		r := r.(*ir.StarExpr)
-		return samesafeexpr(l.X, r.X)
-
-	case ir.ONOT, ir.OBITNOT, ir.OPLUS, ir.ONEG:
-		l := l.(*ir.UnaryExpr)
-		r := r.(*ir.UnaryExpr)
-		return samesafeexpr(l.X, r.X)
-
-	case ir.OCONVNOP:
-		l := l.(*ir.ConvExpr)
-		r := r.(*ir.ConvExpr)
-		return samesafeexpr(l.X, r.X)
-
-	case ir.OCONV:
-		l := l.(*ir.ConvExpr)
-		r := r.(*ir.ConvExpr)
-		// Some conversions can't be reused, such as []byte(str).
-		// Allow only numeric-ish types. This is a bit conservative.
-		return types.IsSimple[l.Type().Kind()] && samesafeexpr(l.X, r.X)
-
-	case ir.OINDEX, ir.OINDEXMAP:
-		l := l.(*ir.IndexExpr)
-		r := r.(*ir.IndexExpr)
-		return samesafeexpr(l.X, r.X) && samesafeexpr(l.Index, r.Index)
-
-	case ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.OLSH, ir.ORSH, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OMOD:
-		l := l.(*ir.BinaryExpr)
-		r := r.(*ir.BinaryExpr)
-		return samesafeexpr(l.X, r.X) && samesafeexpr(l.Y, r.Y)
-
-	case ir.OLITERAL:
-		return constant.Compare(l.Val(), token.EQL, r.Val())
-
-	case ir.ONIL:
-		return true
-	}
-
-	return false
-}
-
 // type check assignment.
 // if this assignment is the definition of a var on the left side,
 // fill in the var's type.
@@ -3639,7 +3535,7 @@ func typecheckfunc(n *ir.Func) {
 			return
 		}
 
-		n.Nname.SetSym(methodSym(rcvr.Type, n.Shortname))
+		n.Nname.SetSym(ir.MethodSym(rcvr.Type, n.Shortname))
 		declare(n.Nname, ir.PFUNC)
 	}
 
@@ -3658,7 +3554,7 @@ func stringtoruneslit(n *ir.ConvExpr) ir.Node {
 	var l []ir.Node
 	i := 0
 	for _, r := range ir.StringVal(n.X) {
-		l = append(l, ir.NewKeyExpr(base.Pos, nodintconst(int64(i)), nodintconst(int64(r))))
+		l = append(l, ir.NewKeyExpr(base.Pos, ir.NewInt(int64(i)), ir.NewInt(int64(r))))
 		i++
 	}
 
@@ -3716,7 +3612,7 @@ func typecheckdef(n ir.Node) {
 		defer tracePrint("typecheckdef", n)(nil)
 	}
 
-	lno := setlineno(n)
+	lno := ir.SetPos(n)
 
 	if n.Op() == ir.ONONAME {
 		if !n.Diag() {
@@ -3779,7 +3675,7 @@ func typecheckdef(n ir.Node) {
 		if e.Type() == nil {
 			goto ret
 		}
-		if !isGoConst(e) {
+		if !ir.IsConstNode(e) {
 			if !e.Diag() {
 				if e.Op() == ir.ONIL {
 					base.ErrorfAt(n.Pos(), "const initializer cannot be nil")
@@ -3904,7 +3800,7 @@ func checkmake(t *types.Type, arg string, np *ir.Node) bool {
 			base.Errorf("negative %s argument in make(%v)", arg, t)
 			return false
 		}
-		if doesoverflow(v, types.Types[types.TINT]) {
+		if ir.ConstOverflow(v, types.Types[types.TINT]) {
 			base.Errorf("%s argument too large in make(%v)", arg, t)
 			return false
 		}
@@ -4236,8 +4132,8 @@ func getIotaValue() int64 {
 		}
 	}
 
-	if Curfn != nil && Curfn.Iota >= 0 {
-		return Curfn.Iota
+	if ir.CurFunc != nil && ir.CurFunc.Iota >= 0 {
+		return ir.CurFunc.Iota
 	}
 
 	return -1
@@ -4245,33 +4141,10 @@ func getIotaValue() int64 {
 
 // curpkg returns the current package, based on Curfn.
 func curpkg() *types.Pkg {
-	fn := Curfn
+	fn := ir.CurFunc
 	if fn == nil {
 		// Initialization expressions for package-scope variables.
 		return types.LocalPkg
 	}
 	return fnpkg(fn.Nname)
 }
-
-// MethodName returns the ONAME representing the method
-// referenced by expression n, which must be a method selector,
-// method expression, or method value.
-func methodExprName(n ir.Node) *ir.Name {
-	name, _ := methodExprFunc(n).Nname.(*ir.Name)
-	return name
-}
-
-// MethodFunc is like MethodName, but returns the types.Field instead.
-func methodExprFunc(n ir.Node) *types.Field {
-	switch n.Op() {
-	case ir.ODOTMETH:
-		return n.(*ir.SelectorExpr).Selection
-	case ir.OMETHEXPR:
-		return n.(*ir.MethodExpr).Method
-	case ir.OCALLPART:
-		n := n.(*ir.CallPartExpr)
-		return callpartMethod(n)
-	}
-	base.Fatalf("unexpected node: %v (%v)", n, n.Op())
-	panic("unreachable")
-}
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index c9cce4b488..b7472ede0f 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -340,8 +340,8 @@ func finishUniverse() {
 		s1.Block = s.Block
 	}
 
-	nodfp = NewName(lookup(".fp"))
-	nodfp.SetType(types.Types[types.TINT32])
-	nodfp.Class_ = ir.PPARAM
-	nodfp.SetUsed(true)
+	ir.RegFP = NewName(lookup(".fp"))
+	ir.RegFP.SetType(types.Types[types.TINT32])
+	ir.RegFP.Class_ = ir.PPARAM
+	ir.RegFP.SetUsed(true)
 }
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 5d812064b6..dd376a8835 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -10,6 +10,7 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
+	"cmd/internal/src"
 	"cmd/internal/sys"
 	"encoding/binary"
 	"errors"
@@ -24,7 +25,7 @@ const tmpstringbufsize = 32
 const zeroValSize = 1024 // must match value of runtime/map.go:maxZero
 
 func walk(fn *ir.Func) {
-	Curfn = fn
+	ir.CurFunc = fn
 	errorsBefore := base.Errors()
 	order(fn)
 	if base.Errors() > errorsBefore {
@@ -32,8 +33,8 @@ func walk(fn *ir.Func) {
 	}
 
 	if base.Flag.W != 0 {
-		s := fmt.Sprintf("\nbefore walk %v", Curfn.Sym())
-		ir.DumpList(s, Curfn.Body)
+		s := fmt.Sprintf("\nbefore walk %v", ir.CurFunc.Sym())
+		ir.DumpList(s, ir.CurFunc.Body)
 	}
 
 	lno := base.Pos
@@ -72,17 +73,17 @@ func walk(fn *ir.Func) {
 	if base.Errors() > errorsBefore {
 		return
 	}
-	walkstmtlist(Curfn.Body)
+	walkstmtlist(ir.CurFunc.Body)
 	if base.Flag.W != 0 {
-		s := fmt.Sprintf("after walk %v", Curfn.Sym())
-		ir.DumpList(s, Curfn.Body)
+		s := fmt.Sprintf("after walk %v", ir.CurFunc.Sym())
+		ir.DumpList(s, ir.CurFunc.Body)
 	}
 
 	zeroResults()
 	heapmoves()
-	if base.Flag.W != 0 && len(Curfn.Enter) > 0 {
-		s := fmt.Sprintf("enter %v", Curfn.Sym())
-		ir.DumpList(s, Curfn.Enter)
+	if base.Flag.W != 0 && len(ir.CurFunc.Enter) > 0 {
+		s := fmt.Sprintf("enter %v", ir.CurFunc.Sym())
+		ir.DumpList(s, ir.CurFunc.Enter)
 	}
 
 	if base.Flag.Cfg.Instrumenting {
@@ -100,7 +101,7 @@ func paramoutheap(fn *ir.Func) bool {
 	for _, ln := range fn.Dcl {
 		switch ln.Class_ {
 		case ir.PPARAMOUT:
-			if isParamStackCopy(ln) || ln.Addrtaken() {
+			if ir.IsParamStackCopy(ln) || ln.Addrtaken() {
 				return true
 			}
 
@@ -120,7 +121,7 @@ func walkstmt(n ir.Node) ir.Node {
 		return n
 	}
 
-	setlineno(n)
+	ir.SetPos(n)
 
 	walkstmtlist(n.Init())
 
@@ -191,7 +192,7 @@ func walkstmt(n ir.Node) ir.Node {
 
 		n.X = walkexpr(n.X, &init)
 		call := walkexpr(mkcall1(chanfn("chanrecv1", 2, n.X.Type()), nil, &init, n.X, nodnil()), &init)
-		return initExpr(init, call)
+		return ir.InitExpr(init, call)
 
 	case ir.OBREAK,
 		ir.OCONTINUE,
@@ -230,18 +231,18 @@ func walkstmt(n ir.Node) ir.Node {
 
 	case ir.ODEFER:
 		n := n.(*ir.GoDeferStmt)
-		Curfn.SetHasDefer(true)
-		Curfn.NumDefers++
-		if Curfn.NumDefers > maxOpenDefers {
+		ir.CurFunc.SetHasDefer(true)
+		ir.CurFunc.NumDefers++
+		if ir.CurFunc.NumDefers > maxOpenDefers {
 			// Don't allow open-coded defers if there are more than
 			// 8 defers in the function, since we use a single
 			// byte to record active defers.
-			Curfn.SetOpenCodedDeferDisallowed(true)
+			ir.CurFunc.SetOpenCodedDeferDisallowed(true)
 		}
-		if n.Esc() != EscNever {
+		if n.Esc() != ir.EscNever {
 			// If n.Esc is not EscNever, then this defer occurs in a loop,
 			// so open-coded defers cannot be used in this function.
-			Curfn.SetOpenCodedDeferDisallowed(true)
+			ir.CurFunc.SetOpenCodedDeferDisallowed(true)
 		}
 		fallthrough
 	case ir.OGO:
@@ -288,7 +289,7 @@ func walkstmt(n ir.Node) ir.Node {
 			init := n.Cond.Init()
 			n.Cond.PtrInit().Set(nil)
 			n.Cond = walkexpr(n.Cond, &init)
-			n.Cond = initExpr(init, n.Cond)
+			n.Cond = ir.InitExpr(init, n.Cond)
 		}
 
 		n.Post = walkstmt(n.Post)
@@ -307,23 +308,23 @@ func walkstmt(n ir.Node) ir.Node {
 
 	case ir.ORETURN:
 		n := n.(*ir.ReturnStmt)
-		Curfn.NumReturns++
+		ir.CurFunc.NumReturns++
 		if len(n.Results) == 0 {
 			return n
 		}
-		if (hasNamedResults(Curfn) && len(n.Results) > 1) || paramoutheap(Curfn) {
+		if (ir.HasNamedResults(ir.CurFunc) && len(n.Results) > 1) || paramoutheap(ir.CurFunc) {
 			// assign to the function out parameters,
 			// so that ascompatee can fix up conflicts
 			var rl []ir.Node
 
-			for _, ln := range Curfn.Dcl {
+			for _, ln := range ir.CurFunc.Dcl {
 				cl := ln.Class_
 				if cl == ir.PAUTO || cl == ir.PAUTOHEAP {
 					break
 				}
 				if cl == ir.PPARAMOUT {
 					var ln ir.Node = ln
-					if isParamStackCopy(ln) {
+					if ir.IsParamStackCopy(ln) {
 						ln = walkexpr(typecheck(ir.NewStarExpr(base.Pos, ln.Name().Heapaddr), ctxExpr), nil)
 					}
 					rl = append(rl, ln)
@@ -345,12 +346,12 @@ func walkstmt(n ir.Node) ir.Node {
 		walkexprlist(n.Results, n.PtrInit())
 
 		// For each return parameter (lhs), assign the corresponding result (rhs).
-		lhs := Curfn.Type().Results()
+		lhs := ir.CurFunc.Type().Results()
 		rhs := n.Results
 		res := make([]ir.Node, lhs.NumFields())
 		for i, nl := range lhs.FieldSlice() {
 			nname := ir.AsNode(nl.Nname)
-			if isParamHeapCopy(nname) {
+			if ir.IsParamHeapCopy(nname) {
 				nname = nname.Name().Stackcopy
 			}
 			a := ir.NewAssignStmt(base.Pos, nname, rhs[i])
@@ -485,7 +486,7 @@ func walkexpr(n ir.Node, init *ir.Nodes) ir.Node {
 		init.Append(n.PtrInit().Take()...)
 	}
 
-	lno := setlineno(n)
+	lno := ir.SetPos(n)
 
 	if base.Flag.LowerW > 1 {
 		ir.Dump("before walk expr", n)
@@ -643,7 +644,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		var ll ir.Nodes
 
 		n.Y = walkexpr(n.Y, &ll)
-		n.Y = initExpr(ll, n.Y)
+		n.Y = ir.InitExpr(ll, n.Y)
 		return n
 
 	case ir.OPRINT, ir.OPRINTN:
@@ -655,7 +656,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 	case ir.ORECOVER:
 		n := n.(*ir.CallExpr)
-		return mkcall("gorecover", n.Type(), init, nodAddr(nodfp))
+		return mkcall("gorecover", n.Type(), init, nodAddr(ir.RegFP))
 
 	case ir.OCLOSUREREAD, ir.OCFUNC:
 		return n
@@ -710,7 +711,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		if left.Op() == ir.OINDEXMAP && right.Op() == ir.OAPPEND {
 			left := left.(*ir.IndexExpr)
 			mapAppend = right.(*ir.CallExpr)
-			if !samesafeexpr(left, mapAppend.Args[0]) {
+			if !ir.SameSafeExpr(left, mapAppend.Args[0]) {
 				base.Fatalf("not same expressions: %v != %v", left, mapAppend.Args[0])
 			}
 		}
@@ -738,7 +739,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			return as
 		}
 
-		if !base.Flag.Cfg.Instrumenting && isZero(as.Y) {
+		if !base.Flag.Cfg.Instrumenting && ir.IsZero(as.Y) {
 			return as
 		}
 
@@ -794,7 +795,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		init.Append(n.PtrInit().Take()...)
 		walkexprlistsafe(n.Lhs, init)
 		walkexprlistsafe(n.Rhs, init)
-		return liststmt(ascompatee(ir.OAS, n.Lhs, n.Rhs, init))
+		return ir.NewBlockStmt(src.NoXPos, ascompatee(ir.OAS, n.Lhs, n.Rhs, init))
 
 	// a,b,... = fn()
 	case ir.OAS2FUNC:
@@ -805,14 +806,14 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		walkexprlistsafe(n.Lhs, init)
 		r = walkexpr(r, init)
 
-		if IsIntrinsicCall(r.(*ir.CallExpr)) {
+		if ir.IsIntrinsicCall(r.(*ir.CallExpr)) {
 			n.Rhs = []ir.Node{r}
 			return n
 		}
 		init.Append(r)
 
 		ll := ascompatet(n.Lhs, r.Type())
-		return liststmt(ll)
+		return ir.NewBlockStmt(src.NoXPos, ll)
 
 	// x, y = <-c
 	// order.stmt made sure x is addressable or blank.
@@ -926,8 +927,8 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		fromType := n.X.Type()
 		toType := n.Type()
 
-		if !fromType.IsInterface() && !ir.IsBlank(Curfn.Nname) { // skip unnamed functions (func _())
-			markTypeUsedInInterface(fromType, Curfn.LSym)
+		if !fromType.IsInterface() && !ir.IsBlank(ir.CurFunc.Nname) { // skip unnamed functions (func _())
+			markTypeUsedInInterface(fromType, ir.CurFunc.LSym)
 		}
 
 		// typeword generates the type word of the interface value.
@@ -971,9 +972,9 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			// and staticuint64s[n.Left * 8 + 7] on big-endian.
 			n.X = cheapexpr(n.X, init)
 			// byteindex widens n.Left so that the multiplication doesn't overflow.
-			index := ir.NewBinaryExpr(base.Pos, ir.OLSH, byteindex(n.X), nodintconst(3))
+			index := ir.NewBinaryExpr(base.Pos, ir.OLSH, byteindex(n.X), ir.NewInt(3))
 			if thearch.LinkArch.ByteOrder == binary.BigEndian {
-				index = ir.NewBinaryExpr(base.Pos, ir.OADD, index, nodintconst(7))
+				index = ir.NewBinaryExpr(base.Pos, ir.OADD, index, ir.NewInt(7))
 			}
 			xe := ir.NewIndexExpr(base.Pos, ir.Names.Staticuint64s, index)
 			xe.SetBounded(true)
@@ -981,7 +982,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		case n.X.Op() == ir.ONAME && n.X.(*ir.Name).Class_ == ir.PEXTERN && n.X.(*ir.Name).Readonly():
 			// n.Left is a readonly global; use it directly.
 			value = n.X
-		case !fromType.IsInterface() && n.Esc() == EscNone && fromType.Width <= 1024:
+		case !fromType.IsInterface() && n.Esc() == ir.EscNone && fromType.Width <= 1024:
 			// n.Left does not escape. Use a stack temporary initialized to n.Left.
 			value = temp(fromType)
 			init.Append(typecheck(ir.NewAssignStmt(base.Pos, value, n.X), ctxStmt))
@@ -1058,7 +1059,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			// with a non-interface, especially in a switch on interface value
 			// with non-interface cases, is not visible to order.stmt, so we
 			// have to fall back on allocating a temp here.
-			if !islvalue(v) {
+			if !ir.IsAssignable(v) {
 				v = copyexpr(v, v.Type(), init)
 			}
 			v = nodAddr(v)
@@ -1078,7 +1079,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		if n.Op() == ir.OCONVNOP && n.Type() == n.X.Type() {
 			return n.X
 		}
-		if n.Op() == ir.OCONVNOP && checkPtr(Curfn, 1) {
+		if n.Op() == ir.OCONVNOP && ir.ShouldCheckPtr(ir.CurFunc, 1) {
 			if n.Type().IsPtr() && n.X.Type().IsUnsafePtr() { // unsafe.Pointer to *T
 				return walkCheckPtrAlignment(n, init, nil)
 			}
@@ -1177,7 +1178,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			if base.Flag.LowerM != 0 && n.Bounded() && !ir.IsConst(n.Index, constant.Int) {
 				base.Warn("index bounds check elided")
 			}
-			if smallintconst(n.Index) && !n.Bounded() {
+			if ir.IsSmallIntConst(n.Index) && !n.Bounded() {
 				base.Errorf("index out of bounds")
 			}
 		} else if ir.IsConst(n.X, constant.String) {
@@ -1185,13 +1186,13 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			if base.Flag.LowerM != 0 && n.Bounded() && !ir.IsConst(n.Index, constant.Int) {
 				base.Warn("index bounds check elided")
 			}
-			if smallintconst(n.Index) && !n.Bounded() {
+			if ir.IsSmallIntConst(n.Index) && !n.Bounded() {
 				base.Errorf("index out of bounds")
 			}
 		}
 
 		if ir.IsConst(n.Index, constant.Int) {
-			if v := n.Index.Val(); constant.Sign(v) < 0 || doesoverflow(v, types.Types[types.TINT]) {
+			if v := n.Index.Val(); constant.Sign(v) < 0 || ir.ConstOverflow(v, types.Types[types.TINT]) {
 				base.Errorf("index out of bounds")
 			}
 		}
@@ -1252,7 +1253,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 	case ir.OSLICE, ir.OSLICEARR, ir.OSLICESTR, ir.OSLICE3, ir.OSLICE3ARR:
 		n := n.(*ir.SliceExpr)
 
-		checkSlice := checkPtr(Curfn, 1) && n.Op() == ir.OSLICE3ARR && n.X.Op() == ir.OCONVNOP && n.X.(*ir.ConvExpr).X.Type().IsUnsafePtr()
+		checkSlice := ir.ShouldCheckPtr(ir.CurFunc, 1) && n.Op() == ir.OSLICE3ARR && n.X.Op() == ir.OCONVNOP && n.X.(*ir.ConvExpr).X.Type().IsUnsafePtr()
 		if checkSlice {
 			conv := n.X.(*ir.ConvExpr)
 			conv.X = walkexpr(conv.X, init)
@@ -1262,7 +1263,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 		low, high, max := n.SliceBounds()
 		low = walkexpr(low, init)
-		if low != nil && isZero(low) {
+		if low != nil && ir.IsZero(low) {
 			// Reduce x[0:j] to x[:j] and x[0:j:k] to x[:j:k].
 			low = nil
 		}
@@ -1274,7 +1275,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		}
 
 		if n.Op().IsSlice3() {
-			if max != nil && max.Op() == ir.OCAP && samesafeexpr(n.X, max.(*ir.UnaryExpr).X) {
+			if max != nil && max.Op() == ir.OCAP && ir.SameSafeExpr(n.X, max.(*ir.UnaryExpr).X) {
 				// Reduce x[i:j:cap(x)] to x[i:j].
 				if n.Op() == ir.OSLICE3 {
 					n.SetOp(ir.OSLICE)
@@ -1292,8 +1293,8 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		if n.Type().Elem().NotInHeap() {
 			base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", n.Type().Elem())
 		}
-		if n.Esc() == EscNone {
-			if n.Type().Elem().Width >= maxImplicitStackVarSize {
+		if n.Esc() == ir.EscNone {
+			if n.Type().Elem().Width >= ir.MaxImplicitStackVarSize {
 				base.Fatalf("large ONEW with EscNone: %v", n)
 			}
 			r := temp(n.Type().Elem())
@@ -1346,7 +1347,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 		// var h *hmap
 		var h ir.Node
-		if n.Esc() == EscNone {
+		if n.Esc() == ir.EscNone {
 			// Allocate hmap on stack.
 
 			// var hv hmap
@@ -1372,7 +1373,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 				//     h.buckets = b
 				// }
 
-				nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OLE, hint, nodintconst(BUCKETSIZE)), nil, nil)
+				nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OLE, hint, ir.NewInt(BUCKETSIZE)), nil, nil)
 				nif.Likely = true
 
 				// var bv bmap
@@ -1398,7 +1399,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			// For hint <= BUCKETSIZE overLoadFactor(hint, 0) is false
 			// and no buckets will be allocated by makemap. Therefore,
 			// no buckets need to be allocated in this code path.
-			if n.Esc() == EscNone {
+			if n.Esc() == ir.EscNone {
 				// Only need to initialize h.hash0 since
 				// hmap h has been allocated on the stack already.
 				// h.hash0 = fastrand()
@@ -1414,7 +1415,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			return mkcall1(fn, n.Type(), init)
 		}
 
-		if n.Esc() != EscNone {
+		if n.Esc() != ir.EscNone {
 			h = nodnil()
 		}
 		// Map initialization with a variable or large hint is
@@ -1452,7 +1453,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		if t.Elem().NotInHeap() {
 			base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", t.Elem())
 		}
-		if n.Esc() == EscNone {
+		if n.Esc() == ir.EscNone {
 			if why := heapAllocReason(n); why != "" {
 				base.Fatalf("%v has EscNone, but %v", n, why)
 			}
@@ -1470,8 +1471,8 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			//     if len < 0 { panicmakeslicelen() }
 			//     panicmakeslicecap()
 			// }
-			nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGT, conv(l, types.Types[types.TUINT64]), nodintconst(i)), nil, nil)
-			niflen := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OLT, l, nodintconst(0)), nil, nil)
+			nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGT, conv(l, types.Types[types.TUINT64]), ir.NewInt(i)), nil, nil)
+			niflen := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OLT, l, ir.NewInt(0)), nil, nil)
 			niflen.Body = []ir.Node{mkcall("panicmakeslicelen", nil, init)}
 			nif.Body.Append(niflen, mkcall("panicmakeslicecap", nil, init))
 			init.Append(typecheck(nif, ctxStmt))
@@ -1514,7 +1515,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 	case ir.OMAKESLICECOPY:
 		n := n.(*ir.MakeExpr)
-		if n.Esc() == EscNone {
+		if n.Esc() == ir.EscNone {
 			base.Fatalf("OMAKESLICECOPY with EscNone: %v", n)
 		}
 
@@ -1534,12 +1535,12 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			// We do not check for overflow of len(to)*elem.Width here
 			// since len(from) is an existing checked slice capacity
 			// with same elem.Width for the from slice.
-			size := ir.NewBinaryExpr(base.Pos, ir.OMUL, conv(length, types.Types[types.TUINTPTR]), conv(nodintconst(t.Elem().Width), types.Types[types.TUINTPTR]))
+			size := ir.NewBinaryExpr(base.Pos, ir.OMUL, conv(length, types.Types[types.TUINTPTR]), conv(ir.NewInt(t.Elem().Width), types.Types[types.TUINTPTR]))
 
 			// instantiate mallocgc(size uintptr, typ *byte, needszero bool) unsafe.Pointer
 			fn := syslook("mallocgc")
 			sh := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
-			sh.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, size, nodnil(), nodbool(false))
+			sh.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, size, nodnil(), ir.NewBool(false))
 			sh.Ptr.MarkNonNil()
 			sh.LenCap = []ir.Node{length, length}
 			sh.SetType(t)
@@ -1570,7 +1571,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 	case ir.ORUNESTR:
 		n := n.(*ir.ConvExpr)
 		a := nodnil()
-		if n.Esc() == EscNone {
+		if n.Esc() == ir.EscNone {
 			t := types.NewArray(types.Types[types.TUINT8], 4)
 			a = nodAddr(temp(t))
 		}
@@ -1580,7 +1581,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 	case ir.OBYTES2STR, ir.ORUNES2STR:
 		n := n.(*ir.ConvExpr)
 		a := nodnil()
-		if n.Esc() == EscNone {
+		if n.Esc() == ir.EscNone {
 			// Create temporary buffer for string on stack.
 			t := types.NewArray(types.Types[types.TUINT8], tmpstringbufsize)
 			a = nodAddr(temp(t))
@@ -1616,7 +1617,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			// Allocate a [n]byte of the right size.
 			t := types.NewArray(types.Types[types.TUINT8], int64(len(sc)))
 			var a ir.Node
-			if n.Esc() == EscNone && len(sc) <= int(maxImplicitStackVarSize) {
+			if n.Esc() == ir.EscNone && len(sc) <= int(ir.MaxImplicitStackVarSize) {
 				a = nodAddr(temp(t))
 			} else {
 				a = callnew(t)
@@ -1638,7 +1639,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		}
 
 		a := nodnil()
-		if n.Esc() == EscNone {
+		if n.Esc() == ir.EscNone {
 			// Create temporary buffer for slice on stack.
 			t := types.NewArray(types.Types[types.TUINT8], tmpstringbufsize)
 			a = nodAddr(temp(t))
@@ -1661,7 +1662,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 	case ir.OSTR2RUNES:
 		n := n.(*ir.ConvExpr)
 		a := nodnil()
-		if n.Esc() == EscNone {
+		if n.Esc() == ir.EscNone {
 			// Create temporary buffer for slice on stack.
 			t := types.NewArray(types.Types[types.TINT32], tmpstringbufsize)
 			a = nodAddr(temp(t))
@@ -1719,7 +1720,7 @@ func markUsedIfaceMethod(n *ir.CallExpr) {
 	dot := n.X.(*ir.SelectorExpr)
 	ityp := dot.X.Type()
 	tsym := typenamesym(ityp).Linksym()
-	r := obj.Addrel(Curfn.LSym)
+	r := obj.Addrel(ir.CurFunc.LSym)
 	r.Sym = tsym
 	// dot.Xoffset is the method index * Widthptr (the offset of code pointer
 	// in itab).
@@ -1777,7 +1778,7 @@ func rtconvfn(src, dst *types.Type) (param, result types.Kind) {
 // TODO(josharian): combine this with its caller and simplify
 func reduceSlice(n *ir.SliceExpr) ir.Node {
 	low, high, max := n.SliceBounds()
-	if high != nil && high.Op() == ir.OLEN && samesafeexpr(n.X, high.(*ir.UnaryExpr).X) {
+	if high != nil && high.Op() == ir.OLEN && ir.SameSafeExpr(n.X, high.(*ir.UnaryExpr).X) {
 		// Reduce x[i:len(x)] to x[i:].
 		high = nil
 	}
@@ -1824,7 +1825,7 @@ func ascompatee(op ir.Op, nl, nr []ir.Node, init *ir.Nodes) []ir.Node {
 			break
 		}
 		// Do not generate 'x = x' during return. See issue 4014.
-		if op == ir.ORETURN && samesafeexpr(nl[i], nr[i]) {
+		if op == ir.ORETURN && ir.SameSafeExpr(nl[i], nr[i]) {
 			continue
 		}
 		nn = append(nn, ascompatee1(nl[i], nr[i], init))
@@ -1835,7 +1836,7 @@ func ascompatee(op ir.Op, nl, nr []ir.Node, init *ir.Nodes) []ir.Node {
 		var nln, nrn ir.Nodes
 		nln.Set(nl)
 		nrn.Set(nr)
-		base.Fatalf("error in shape across %+v %v %+v / %d %d [%s]", nln, op, nrn, len(nl), len(nr), ir.FuncName(Curfn))
+		base.Fatalf("error in shape across %+v %v %+v / %d %d [%s]", nln, op, nrn, len(nl), len(nr), ir.FuncName(ir.CurFunc))
 	}
 	return reorder3(nn)
 }
@@ -2000,11 +2001,11 @@ func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 		t := make([]ir.Node, 0, len(s)*2)
 		for i, n := range s {
 			if i != 0 {
-				t = append(t, nodstr(" "))
+				t = append(t, ir.NewString(" "))
 			}
 			t = append(t, n)
 		}
-		t = append(t, nodstr("\n"))
+		t = append(t, ir.NewString("\n"))
 		nn.Args.Set(t)
 	}
 
@@ -2018,7 +2019,7 @@ func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 			i++
 		}
 		if len(strs) > 0 {
-			t = append(t, nodstr(strings.Join(strs, "")))
+			t = append(t, ir.NewString(strings.Join(strs, "")))
 		}
 		if i < len(s) {
 			t = append(t, s[i])
@@ -2140,31 +2141,6 @@ func callnew(t *types.Type) ir.Node {
 	return n
 }
 
-// isReflectHeaderDataField reports whether l is an expression p.Data
-// where p has type reflect.SliceHeader or reflect.StringHeader.
-func isReflectHeaderDataField(l ir.Node) bool {
-	if l.Type() != types.Types[types.TUINTPTR] {
-		return false
-	}
-
-	var tsym *types.Sym
-	switch l.Op() {
-	case ir.ODOT:
-		l := l.(*ir.SelectorExpr)
-		tsym = l.X.Type().Sym()
-	case ir.ODOTPTR:
-		l := l.(*ir.SelectorExpr)
-		tsym = l.X.Type().Elem().Sym()
-	default:
-		return false
-	}
-
-	if tsym == nil || l.Sym().Name != "Data" || tsym.Pkg.Path != "reflect" {
-		return false
-	}
-	return tsym.Name == "SliceHeader" || tsym.Name == "StringHeader"
-}
-
 func convas(n *ir.AssignStmt, init *ir.Nodes) *ir.AssignStmt {
 	if n.Op() != ir.OAS {
 		base.Fatalf("convas: not OAS %v", n.Op())
@@ -2288,37 +2264,6 @@ func reorder3save(n ir.Node, all []*ir.AssignStmt, i int, early *[]ir.Node) ir.N
 	return q
 }
 
-// what's the outer value that a write to n affects?
-// outer value means containing struct or array.
-func outervalue(n ir.Node) ir.Node {
-	for {
-		switch nn := n; nn.Op() {
-		case ir.OXDOT:
-			base.Fatalf("OXDOT in walk")
-		case ir.ODOT:
-			nn := nn.(*ir.SelectorExpr)
-			n = nn.X
-			continue
-		case ir.OPAREN:
-			nn := nn.(*ir.ParenExpr)
-			n = nn.X
-			continue
-		case ir.OCONVNOP:
-			nn := nn.(*ir.ConvExpr)
-			n = nn.X
-			continue
-		case ir.OINDEX:
-			nn := nn.(*ir.IndexExpr)
-			if nn.X.Type() != nil && nn.X.Type().IsArray() {
-				n = nn.X
-				continue
-			}
-		}
-
-		return n
-	}
-}
-
 // Is it possible that the computation of r might be
 // affected by assignments in all?
 func aliased(r ir.Node, all []*ir.AssignStmt) bool {
@@ -2344,7 +2289,7 @@ func aliased(r ir.Node, all []*ir.AssignStmt) bool {
 			continue
 		}
 
-		lv := outervalue(as.X)
+		lv := ir.OuterValue(as.X)
 		if lv.Op() != ir.ONAME {
 			memwrite = true
 			continue
@@ -2526,7 +2471,7 @@ func paramstoheap(params *types.Type) []ir.Node {
 // even allocations to move params/results to the heap.
 // The generated code is added to Curfn's Enter list.
 func zeroResults() {
-	for _, f := range Curfn.Type().Results().Fields().Slice() {
+	for _, f := range ir.CurFunc.Type().Results().Fields().Slice() {
 		v := ir.AsNode(f.Nname)
 		if v != nil && v.Name().Heapaddr != nil {
 			// The local which points to the return value is the
@@ -2534,7 +2479,7 @@ func zeroResults() {
 			// by a Needzero annotation in plive.go:livenessepilogue.
 			continue
 		}
-		if isParamHeapCopy(v) {
+		if ir.IsParamHeapCopy(v) {
 			// TODO(josharian/khr): Investigate whether we can switch to "continue" here,
 			// and document more in either case.
 			// In the review of CL 114797, Keith wrote (roughly):
@@ -2544,7 +2489,7 @@ func zeroResults() {
 			v = v.Name().Stackcopy
 		}
 		// Zero the stack location containing f.
-		Curfn.Enter.Append(ir.NewAssignStmt(Curfn.Pos(), v, nil))
+		ir.CurFunc.Enter.Append(ir.NewAssignStmt(ir.CurFunc.Pos(), v, nil))
 	}
 }
 
@@ -2570,13 +2515,13 @@ func returnsfromheap(params *types.Type) []ir.Node {
 // Enter and Exit lists.
 func heapmoves() {
 	lno := base.Pos
-	base.Pos = Curfn.Pos()
-	nn := paramstoheap(Curfn.Type().Recvs())
-	nn = append(nn, paramstoheap(Curfn.Type().Params())...)
-	nn = append(nn, paramstoheap(Curfn.Type().Results())...)
-	Curfn.Enter.Append(nn...)
-	base.Pos = Curfn.Endlineno
-	Curfn.Exit.Append(returnsfromheap(Curfn.Type().Results())...)
+	base.Pos = ir.CurFunc.Pos()
+	nn := paramstoheap(ir.CurFunc.Type().Recvs())
+	nn = append(nn, paramstoheap(ir.CurFunc.Type().Params())...)
+	nn = append(nn, paramstoheap(ir.CurFunc.Type().Results())...)
+	ir.CurFunc.Enter.Append(nn...)
+	base.Pos = ir.CurFunc.Endlineno
+	ir.CurFunc.Exit.Append(returnsfromheap(ir.CurFunc.Type().Results())...)
 	base.Pos = lno
 }
 
@@ -2743,7 +2688,7 @@ func addstr(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
 	}
 
 	buf := nodnil()
-	if n.Esc() == EscNone {
+	if n.Esc() == ir.EscNone {
 		sz := int64(0)
 		for _, n1 := range n.List {
 			if n1.Op() == ir.OLITERAL {
@@ -2779,7 +2724,7 @@ func addstr(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
 		slice := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(t), args[1:])
 		slice.Prealloc = n.Prealloc
 		args = []ir.Node{buf, slice}
-		slice.SetEsc(EscNone)
+		slice.SetEsc(ir.EscNone)
 	}
 
 	cat := syslook(fn)
@@ -2865,7 +2810,7 @@ func appendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 		slice.SetType(s.Type())
 		slice.SetSliceBounds(ir.NewUnaryExpr(base.Pos, ir.OLEN, l1), nil, nil)
 
-		Curfn.SetWBPos(n.Pos())
+		ir.CurFunc.SetWBPos(n.Pos())
 
 		// instantiate typedslicecopy(typ *type, dstPtr *any, dstLen int, srcPtr *any, srcLen int) int
 		fn := syslook("typedslicecopy")
@@ -2886,7 +2831,7 @@ func appendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 
 		fn := syslook("slicecopy")
 		fn = substArgTypes(fn, ptr1.Type().Elem(), ptr2.Type().Elem())
-		ncopy = mkcall1(fn, types.Types[types.TINT], &nodes, ptr1, len1, ptr2, len2, nodintconst(elemtype.Width))
+		ncopy = mkcall1(fn, types.Types[types.TINT], &nodes, ptr1, len1, ptr2, len2, ir.NewInt(elemtype.Width))
 	} else {
 		// memmove(&s[len(l1)], &l2[0], len(l2)*sizeof(T))
 		ix := ir.NewIndexExpr(base.Pos, s, ir.NewUnaryExpr(base.Pos, ir.OLEN, l1))
@@ -2896,7 +2841,7 @@ func appendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 		sptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, l2)
 
 		nwid := cheapexpr(conv(ir.NewUnaryExpr(base.Pos, ir.OLEN, l2), types.Types[types.TUINTPTR]), &nodes)
-		nwid = ir.NewBinaryExpr(base.Pos, ir.OMUL, nwid, nodintconst(elemtype.Width))
+		nwid = ir.NewBinaryExpr(base.Pos, ir.OMUL, nwid, ir.NewInt(elemtype.Width))
 
 		// instantiate func memmove(to *any, frm *any, length uintptr)
 		fn := syslook("memmove")
@@ -2992,7 +2937,7 @@ func extendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	var nodes []ir.Node
 
 	// if l2 >= 0 (likely happens), do nothing
-	nifneg := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGE, l2, nodintconst(0)), nil, nil)
+	nifneg := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGE, l2, ir.NewInt(0)), nil, nil)
 	nifneg.Likely = true
 
 	// else panicmakeslicelen()
@@ -3044,13 +2989,13 @@ func extendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	hp := convnop(nodAddr(ix), types.Types[types.TUNSAFEPTR])
 
 	// hn := l2 * sizeof(elem(s))
-	hn := conv(ir.NewBinaryExpr(base.Pos, ir.OMUL, l2, nodintconst(elemtype.Width)), types.Types[types.TUINTPTR])
+	hn := conv(ir.NewBinaryExpr(base.Pos, ir.OMUL, l2, ir.NewInt(elemtype.Width)), types.Types[types.TUINTPTR])
 
 	clrname := "memclrNoHeapPointers"
 	hasPointers := elemtype.HasPointers()
 	if hasPointers {
 		clrname = "memclrHasPointers"
-		Curfn.SetWBPos(n.Pos())
+		ir.CurFunc.SetWBPos(n.Pos())
 	}
 
 	var clr ir.Nodes
@@ -3094,7 +3039,7 @@ func extendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 //   }
 //   s
 func walkappend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
-	if !samesafeexpr(dst, n.Args[0]) {
+	if !ir.SameSafeExpr(dst, n.Args[0]) {
 		n.Args[0] = safeexpr(n.Args[0], init)
 		n.Args[0] = walkexpr(n.Args[0], init)
 	}
@@ -3134,7 +3079,7 @@ func walkappend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
 	ns := temp(nsrc.Type())
 	l = append(l, ir.NewAssignStmt(base.Pos, ns, nsrc)) // s = src
 
-	na := nodintconst(int64(argc))               // const argc
+	na := ir.NewInt(int64(argc))                 // const argc
 	nif := ir.NewIfStmt(base.Pos, nil, nil, nil) // if cap(s) - len(s) < argc
 	nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OLT, ir.NewBinaryExpr(base.Pos, ir.OSUB, ir.NewUnaryExpr(base.Pos, ir.OCAP, ns), ir.NewUnaryExpr(base.Pos, ir.OLEN, ns)), na)
 
@@ -3160,7 +3105,7 @@ func walkappend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
 		ix.SetBounded(true)
 		l = append(l, ir.NewAssignStmt(base.Pos, ix, n)) // s[n] = arg
 		if i+1 < len(ls) {
-			l = append(l, ir.NewAssignStmt(base.Pos, nn, ir.NewBinaryExpr(base.Pos, ir.OADD, nn, nodintconst(1)))) // n = n + 1
+			l = append(l, ir.NewAssignStmt(base.Pos, nn, ir.NewBinaryExpr(base.Pos, ir.OADD, nn, ir.NewInt(1)))) // n = n + 1
 		}
 	}
 
@@ -3183,7 +3128,7 @@ func walkappend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
 //
 func copyany(n *ir.BinaryExpr, init *ir.Nodes, runtimecall bool) ir.Node {
 	if n.X.Type().Elem().HasPointers() {
-		Curfn.SetWBPos(n.Pos())
+		ir.CurFunc.SetWBPos(n.Pos())
 		fn := writebarrierfn("typedslicecopy", n.X.Type().Elem(), n.Y.Type().Elem())
 		n.X = cheapexpr(n.X, init)
 		ptrL, lenL := backingArrayPtrLen(n.X)
@@ -3205,7 +3150,7 @@ func copyany(n *ir.BinaryExpr, init *ir.Nodes, runtimecall bool) ir.Node {
 		fn := syslook("slicecopy")
 		fn = substArgTypes(fn, ptrL.Type().Elem(), ptrR.Type().Elem())
 
-		return mkcall1(fn, n.Type(), init, ptrL, lenL, ptrR, lenR, nodintconst(n.X.Type().Elem().Width))
+		return mkcall1(fn, n.Type(), init, ptrL, lenL, ptrR, lenR, ir.NewInt(n.X.Type().Elem().Width))
 	}
 
 	n.X = walkexpr(n.X, init)
@@ -3241,7 +3186,7 @@ func copyany(n *ir.BinaryExpr, init *ir.Nodes, runtimecall bool) ir.Node {
 	nwid := ir.Node(temp(types.Types[types.TUINTPTR]))
 	setwid := ir.NewAssignStmt(base.Pos, nwid, conv(nlen, types.Types[types.TUINTPTR]))
 	ne.Body.Append(setwid)
-	nwid = ir.NewBinaryExpr(base.Pos, ir.OMUL, nwid, nodintconst(nl.Type().Elem().Width))
+	nwid = ir.NewBinaryExpr(base.Pos, ir.OMUL, nwid, ir.NewInt(nl.Type().Elem().Width))
 	call := mkcall1(fn, nil, init, nto, nfrm, nwid)
 	ne.Body.Append(call)
 
@@ -3264,12 +3209,12 @@ func eqfor(t *types.Type) (n ir.Node, needsize bool) {
 	case types.ASPECIAL:
 		sym := typesymprefix(".eq", t)
 		n := NewName(sym)
-		setNodeNameFunc(n)
+		ir.MarkFunc(n)
 		n.SetType(functype(nil, []*ir.Field{
-			anonfield(types.NewPtr(t)),
-			anonfield(types.NewPtr(t)),
+			ir.NewField(base.Pos, nil, nil, types.NewPtr(t)),
+			ir.NewField(base.Pos, nil, nil, types.NewPtr(t)),
 		}, []*ir.Field{
-			anonfield(types.Types[types.TBOOL]),
+			ir.NewField(base.Pos, nil, nil, types.Types[types.TBOOL]),
 		}))
 		return n, false
 	}
@@ -3415,7 +3360,7 @@ func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 	// Chose not to inline. Call equality function directly.
 	if !inline {
 		// eq algs take pointers; cmpl and cmpr must be addressable
-		if !islvalue(cmpl) || !islvalue(cmpr) {
+		if !ir.IsAssignable(cmpl) || !ir.IsAssignable(cmpr) {
 			base.Fatalf("arguments of comparison must be lvalues - %v %v", cmpl, cmpr)
 		}
 
@@ -3424,7 +3369,7 @@ func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 		call.Args.Append(nodAddr(cmpl))
 		call.Args.Append(nodAddr(cmpr))
 		if needsize {
-			call.Args.Append(nodintconst(t.Width))
+			call.Args.Append(ir.NewInt(t.Width))
 		}
 		res := ir.Node(call)
 		if n.Op() != ir.OEQ {
@@ -3483,31 +3428,31 @@ func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 			}
 			if step == 1 {
 				compare(
-					ir.NewIndexExpr(base.Pos, cmpl, nodintconst(i)),
-					ir.NewIndexExpr(base.Pos, cmpr, nodintconst(i)),
+					ir.NewIndexExpr(base.Pos, cmpl, ir.NewInt(i)),
+					ir.NewIndexExpr(base.Pos, cmpr, ir.NewInt(i)),
 				)
 				i++
 				remains -= t.Elem().Width
 			} else {
 				elemType := t.Elem().ToUnsigned()
-				cmplw := ir.Node(ir.NewIndexExpr(base.Pos, cmpl, nodintconst(i)))
+				cmplw := ir.Node(ir.NewIndexExpr(base.Pos, cmpl, ir.NewInt(i)))
 				cmplw = conv(cmplw, elemType) // convert to unsigned
 				cmplw = conv(cmplw, convType) // widen
-				cmprw := ir.Node(ir.NewIndexExpr(base.Pos, cmpr, nodintconst(i)))
+				cmprw := ir.Node(ir.NewIndexExpr(base.Pos, cmpr, ir.NewInt(i)))
 				cmprw = conv(cmprw, elemType)
 				cmprw = conv(cmprw, convType)
 				// For code like this:  uint32(s[0]) | uint32(s[1])<<8 | uint32(s[2])<<16 ...
 				// ssa will generate a single large load.
 				for offset := int64(1); offset < step; offset++ {
-					lb := ir.Node(ir.NewIndexExpr(base.Pos, cmpl, nodintconst(i+offset)))
+					lb := ir.Node(ir.NewIndexExpr(base.Pos, cmpl, ir.NewInt(i+offset)))
 					lb = conv(lb, elemType)
 					lb = conv(lb, convType)
-					lb = ir.NewBinaryExpr(base.Pos, ir.OLSH, lb, nodintconst(8*t.Elem().Width*offset))
+					lb = ir.NewBinaryExpr(base.Pos, ir.OLSH, lb, ir.NewInt(8*t.Elem().Width*offset))
 					cmplw = ir.NewBinaryExpr(base.Pos, ir.OOR, cmplw, lb)
-					rb := ir.Node(ir.NewIndexExpr(base.Pos, cmpr, nodintconst(i+offset)))
+					rb := ir.Node(ir.NewIndexExpr(base.Pos, cmpr, ir.NewInt(i+offset)))
 					rb = conv(rb, elemType)
 					rb = conv(rb, convType)
-					rb = ir.NewBinaryExpr(base.Pos, ir.OLSH, rb, nodintconst(8*t.Elem().Width*offset))
+					rb = ir.NewBinaryExpr(base.Pos, ir.OLSH, rb, ir.NewInt(8*t.Elem().Width*offset))
 					cmprw = ir.NewBinaryExpr(base.Pos, ir.OOR, cmprw, rb)
 				}
 				compare(cmplw, cmprw)
@@ -3517,7 +3462,7 @@ func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 		}
 	}
 	if expr == nil {
-		expr = nodbool(n.Op() == ir.OEQ)
+		expr = ir.NewBool(n.Op() == ir.OEQ)
 		// We still need to use cmpl and cmpr, in case they contain
 		// an expression which might panic. See issue 23837.
 		t := temp(cmpl.Type())
@@ -3604,12 +3549,12 @@ func walkcompareString(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 			if len(s) > 0 {
 				ncs = safeexpr(ncs, init)
 			}
-			r := ir.Node(ir.NewBinaryExpr(base.Pos, cmp, ir.NewUnaryExpr(base.Pos, ir.OLEN, ncs), nodintconst(int64(len(s)))))
+			r := ir.Node(ir.NewBinaryExpr(base.Pos, cmp, ir.NewUnaryExpr(base.Pos, ir.OLEN, ncs), ir.NewInt(int64(len(s)))))
 			remains := len(s)
 			for i := 0; remains > 0; {
 				if remains == 1 || !canCombineLoads {
-					cb := nodintconst(int64(s[i]))
-					ncb := ir.NewIndexExpr(base.Pos, ncs, nodintconst(int64(i)))
+					cb := ir.NewInt(int64(s[i]))
+					ncb := ir.NewIndexExpr(base.Pos, ncs, ir.NewInt(int64(i)))
 					r = ir.NewLogicalExpr(base.Pos, and, r, ir.NewBinaryExpr(base.Pos, cmp, ncb, cb))
 					remains--
 					i++
@@ -3628,18 +3573,18 @@ func walkcompareString(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 					convType = types.Types[types.TUINT16]
 					step = 2
 				}
-				ncsubstr := conv(ir.NewIndexExpr(base.Pos, ncs, nodintconst(int64(i))), convType)
+				ncsubstr := conv(ir.NewIndexExpr(base.Pos, ncs, ir.NewInt(int64(i))), convType)
 				csubstr := int64(s[i])
 				// Calculate large constant from bytes as sequence of shifts and ors.
 				// Like this:  uint32(s[0]) | uint32(s[1])<<8 | uint32(s[2])<<16 ...
 				// ssa will combine this into a single large load.
 				for offset := 1; offset < step; offset++ {
-					b := conv(ir.NewIndexExpr(base.Pos, ncs, nodintconst(int64(i+offset))), convType)
-					b = ir.NewBinaryExpr(base.Pos, ir.OLSH, b, nodintconst(int64(8*offset)))
+					b := conv(ir.NewIndexExpr(base.Pos, ncs, ir.NewInt(int64(i+offset))), convType)
+					b = ir.NewBinaryExpr(base.Pos, ir.OLSH, b, ir.NewInt(int64(8*offset)))
 					ncsubstr = ir.NewBinaryExpr(base.Pos, ir.OOR, ncsubstr, b)
 					csubstr |= int64(s[i+offset]) << uint8(8*offset)
 				}
-				csubstrPart := nodintconst(csubstr)
+				csubstrPart := ir.NewInt(csubstr)
 				// Compare "step" bytes as once
 				r = ir.NewLogicalExpr(base.Pos, and, r, ir.NewBinaryExpr(base.Pos, cmp, csubstrPart, ncsubstr))
 				remains -= step
@@ -3668,7 +3613,7 @@ func walkcompareString(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 	} else {
 		// sys_cmpstring(s1, s2) :: 0
 		r = mkcall("cmpstring", types.Types[types.TINT], init, conv(n.X, types.Types[types.TSTRING]), conv(n.Y, types.Types[types.TSTRING]))
-		r = ir.NewBinaryExpr(base.Pos, n.Op(), r, nodintconst(0))
+		r = ir.NewBinaryExpr(base.Pos, n.Op(), r, ir.NewInt(0))
 	}
 
 	return finishcompare(n, r, init)
@@ -3692,7 +3637,7 @@ func bounded(n ir.Node, max int64) bool {
 	sign := n.Type().IsSigned()
 	bits := int32(8 * n.Type().Width)
 
-	if smallintconst(n) {
+	if ir.IsSmallIntConst(n) {
 		v := ir.Int64Val(n)
 		return 0 <= v && v < max
 	}
@@ -3702,9 +3647,9 @@ func bounded(n ir.Node, max int64) bool {
 		n := n.(*ir.BinaryExpr)
 		v := int64(-1)
 		switch {
-		case smallintconst(n.X):
+		case ir.IsSmallIntConst(n.X):
 			v = ir.Int64Val(n.X)
-		case smallintconst(n.Y):
+		case ir.IsSmallIntConst(n.Y):
 			v = ir.Int64Val(n.Y)
 			if n.Op() == ir.OANDNOT {
 				v = ^v
@@ -3719,7 +3664,7 @@ func bounded(n ir.Node, max int64) bool {
 
 	case ir.OMOD:
 		n := n.(*ir.BinaryExpr)
-		if !sign && smallintconst(n.Y) {
+		if !sign && ir.IsSmallIntConst(n.Y) {
 			v := ir.Int64Val(n.Y)
 			if 0 <= v && v <= max {
 				return true
@@ -3728,7 +3673,7 @@ func bounded(n ir.Node, max int64) bool {
 
 	case ir.ODIV:
 		n := n.(*ir.BinaryExpr)
-		if !sign && smallintconst(n.Y) {
+		if !sign && ir.IsSmallIntConst(n.Y) {
 			v := ir.Int64Val(n.Y)
 			for bits > 0 && v >= 2 {
 				bits--
@@ -3738,7 +3683,7 @@ func bounded(n ir.Node, max int64) bool {
 
 	case ir.ORSH:
 		n := n.(*ir.BinaryExpr)
-		if !sign && smallintconst(n.Y) {
+		if !sign && ir.IsSmallIntConst(n.Y) {
 			v := ir.Int64Val(n.Y)
 			if v > int64(bits) {
 				return true
@@ -3794,9 +3739,9 @@ func usemethod(n *ir.CallExpr) {
 	//       (including global variables such as numImports - was issue #19028).
 	// Also need to check for reflect package itself (see Issue #38515).
 	if s := res0.Type.Sym(); s != nil && s.Name == "Method" && types.IsReflectPkg(s.Pkg) {
-		Curfn.SetReflectMethod(true)
+		ir.CurFunc.SetReflectMethod(true)
 		// The LSym is initialized at this point. We need to set the attribute on the LSym.
-		Curfn.LSym.Set(obj.AttrReflectMethod, true)
+		ir.CurFunc.LSym.Set(obj.AttrReflectMethod, true)
 	}
 }
 
@@ -3845,10 +3790,10 @@ func usefield(n *ir.SelectorExpr) {
 	}
 
 	sym := tracksym(outer, field)
-	if Curfn.FieldTrack == nil {
-		Curfn.FieldTrack = make(map[*types.Sym]struct{})
+	if ir.CurFunc.FieldTrack == nil {
+		ir.CurFunc.FieldTrack = make(map[*types.Sym]struct{})
 	}
-	Curfn.FieldTrack[sym] = struct{}{}
+	ir.CurFunc.FieldTrack[sym] = struct{}{}
 }
 
 // anySideEffects reports whether n contains any operations that could have observable side effects.
@@ -3987,7 +3932,7 @@ func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 			arg = arg.(*ir.ConvExpr).X
 			n.Args[i] = arg
 		}
-		funcArgs = append(funcArgs, symfield(s, arg.Type()))
+		funcArgs = append(funcArgs, ir.NewField(base.Pos, s, nil, arg.Type()))
 	}
 	t := ir.NewFuncType(base.Pos, nil, funcArgs, nil)
 
@@ -3995,7 +3940,7 @@ func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	sym := lookupN("wrap·", wrapCall_prgen)
 	fn := dclfunc(sym, t)
 
-	args := paramNnames(t.Type())
+	args := ir.ParamNames(t.Type())
 	for i, origArg := range origArgs {
 		if origArg == nil {
 			continue
@@ -4076,7 +4021,7 @@ func walkCheckPtrAlignment(n *ir.ConvExpr, init *ir.Nodes, count ir.Node) ir.Nod
 	}
 
 	if count == nil {
-		count = nodintconst(1)
+		count = ir.NewInt(1)
 	}
 
 	n.X = cheapexpr(n.X, init)
@@ -4107,7 +4052,7 @@ func walkCheckPtrArithmetic(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 		return n
 	}
 
-	if n.X.Op() == ir.ODOTPTR && isReflectHeaderDataField(n.X) {
+	if n.X.Op() == ir.ODOTPTR && ir.IsReflectHeaderDataField(n.X) {
 		return n
 	}
 
@@ -4141,7 +4086,7 @@ func walkCheckPtrArithmetic(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 	cheap := cheapexpr(n, init)
 
 	slice := mkdotargslice(types.NewSlice(types.Types[types.TUNSAFEPTR]), originals)
-	slice.SetEsc(EscNone)
+	slice.SetEsc(ir.EscNone)
 
 	init.Append(mkcall("checkptrArithmetic", nil, init, convnop(cheap, types.Types[types.TUNSAFEPTR]), slice))
 	// TODO(khr): Mark backing store of slice as dead. This will allow us to reuse
@@ -4150,13 +4095,6 @@ func walkCheckPtrArithmetic(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 	return cheap
 }
 
-// checkPtr reports whether pointer checking should be enabled for
-// function fn at a given level. See debugHelpFooter for defined
-// levels.
-func checkPtr(fn *ir.Func, level int) bool {
-	return base.Debug.Checkptr >= level && fn.Pragma&ir.NoCheckPtr == 0
-}
-
 // appendWalkStmt typechecks and walks stmt and then appends it to init.
 func appendWalkStmt(init *ir.Nodes, stmt ir.Node) {
 	op := stmt.Op()
diff --git a/src/cmd/compile/internal/ir/cfg.go b/src/cmd/compile/internal/ir/cfg.go
new file mode 100644
index 0000000000..d986ac3a1e
--- /dev/null
+++ b/src/cmd/compile/internal/ir/cfg.go
@@ -0,0 +1,26 @@
+// Copyright 2009 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 ir
+
+var (
+	// maximum size variable which we will allocate on the stack.
+	// This limit is for explicit variable declarations like "var x T" or "x := ...".
+	// Note: the flag smallframes can update this value.
+	MaxStackVarSize = int64(10 * 1024 * 1024)
+
+	// maximum size of implicit variables that we will allocate on the stack.
+	//   p := new(T)          allocating T on the stack
+	//   p := &T{}            allocating T on the stack
+	//   s := make([]T, n)    allocating [n]T on the stack
+	//   s := []byte("...")   allocating [n]byte on the stack
+	// Note: the flag smallframes can update this value.
+	MaxImplicitStackVarSize = int64(64 * 1024)
+
+	// MaxSmallArraySize is the maximum size of an array which is considered small.
+	// Small arrays will be initialized directly with a sequence of constant stores.
+	// Large arrays will be initialized by copying from a static temp.
+	// 256 bytes was chosen to minimize generated code + statictmp size.
+	MaxSmallArraySize = int64(256)
+)
diff --git a/src/cmd/compile/internal/ir/const.go b/src/cmd/compile/internal/ir/const.go
new file mode 100644
index 0000000000..bfa0136232
--- /dev/null
+++ b/src/cmd/compile/internal/ir/const.go
@@ -0,0 +1,99 @@
+// Copyright 2009 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 ir
+
+import (
+	"go/constant"
+	"math"
+	"math/big"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/types"
+)
+
+func NewBool(b bool) Node {
+	return NewLiteral(constant.MakeBool(b))
+}
+
+func NewInt(v int64) Node {
+	return NewLiteral(constant.MakeInt64(v))
+}
+
+func NewString(s string) Node {
+	return NewLiteral(constant.MakeString(s))
+}
+
+const (
+	// Maximum size in bits for big.Ints before signalling
+	// overflow and also mantissa precision for big.Floats.
+	ConstPrec = 512
+)
+
+func BigFloat(v constant.Value) *big.Float {
+	f := new(big.Float)
+	f.SetPrec(ConstPrec)
+	switch u := constant.Val(v).(type) {
+	case int64:
+		f.SetInt64(u)
+	case *big.Int:
+		f.SetInt(u)
+	case *big.Float:
+		f.Set(u)
+	case *big.Rat:
+		f.SetRat(u)
+	default:
+		base.Fatalf("unexpected: %v", u)
+	}
+	return f
+}
+
+// ConstOverflow reports whether constant value v is too large
+// to represent with type t.
+func ConstOverflow(v constant.Value, t *types.Type) bool {
+	switch {
+	case t.IsInteger():
+		bits := uint(8 * t.Size())
+		if t.IsUnsigned() {
+			x, ok := constant.Uint64Val(v)
+			return !ok || x>>bits != 0
+		}
+		x, ok := constant.Int64Val(v)
+		if x < 0 {
+			x = ^x
+		}
+		return !ok || x>>(bits-1) != 0
+	case t.IsFloat():
+		switch t.Size() {
+		case 4:
+			f, _ := constant.Float32Val(v)
+			return math.IsInf(float64(f), 0)
+		case 8:
+			f, _ := constant.Float64Val(v)
+			return math.IsInf(f, 0)
+		}
+	case t.IsComplex():
+		ft := types.FloatForComplex(t)
+		return ConstOverflow(constant.Real(v), ft) || ConstOverflow(constant.Imag(v), ft)
+	}
+	base.Fatalf("doesoverflow: %v, %v", v, t)
+	panic("unreachable")
+}
+
+// IsConstNode reports whether n is a Go language constant (as opposed to a
+// compile-time constant).
+//
+// Expressions derived from nil, like string([]byte(nil)), while they
+// may be known at compile time, are not Go language constants.
+func IsConstNode(n Node) bool {
+	return n.Op() == OLITERAL
+}
+
+func IsSmallIntConst(n Node) bool {
+	if n.Op() == OLITERAL {
+		v, ok := constant.Int64Val(n.Val())
+		return ok && int64(int32(v)) == v
+	}
+	return false
+}
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 39a408fdc7..640cc03954 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -5,10 +5,13 @@
 package ir
 
 import (
+	"bytes"
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
+	"fmt"
 	"go/constant"
+	"go/token"
 )
 
 func maybeDo(x Node, err error, do func(Node) error) error {
@@ -783,3 +786,371 @@ func (n *UnaryExpr) SetOp(op Op) {
 		n.op = op
 	}
 }
+
+func IsZero(n Node) bool {
+	switch n.Op() {
+	case ONIL:
+		return true
+
+	case OLITERAL:
+		switch u := n.Val(); u.Kind() {
+		case constant.String:
+			return constant.StringVal(u) == ""
+		case constant.Bool:
+			return !constant.BoolVal(u)
+		default:
+			return constant.Sign(u) == 0
+		}
+
+	case OARRAYLIT:
+		n := n.(*CompLitExpr)
+		for _, n1 := range n.List {
+			if n1.Op() == OKEY {
+				n1 = n1.(*KeyExpr).Value
+			}
+			if !IsZero(n1) {
+				return false
+			}
+		}
+		return true
+
+	case OSTRUCTLIT:
+		n := n.(*CompLitExpr)
+		for _, n1 := range n.List {
+			n1 := n1.(*StructKeyExpr)
+			if !IsZero(n1.Value) {
+				return false
+			}
+		}
+		return true
+	}
+
+	return false
+}
+
+// lvalue etc
+func IsAssignable(n Node) bool {
+	switch n.Op() {
+	case OINDEX:
+		n := n.(*IndexExpr)
+		if n.X.Type() != nil && n.X.Type().IsArray() {
+			return IsAssignable(n.X)
+		}
+		if n.X.Type() != nil && n.X.Type().IsString() {
+			return false
+		}
+		fallthrough
+	case ODEREF, ODOTPTR, OCLOSUREREAD:
+		return true
+
+	case ODOT:
+		n := n.(*SelectorExpr)
+		return IsAssignable(n.X)
+
+	case ONAME:
+		n := n.(*Name)
+		if n.Class_ == PFUNC {
+			return false
+		}
+		return true
+
+	case ONAMEOFFSET:
+		return true
+	}
+
+	return false
+}
+
+func StaticValue(n Node) Node {
+	for {
+		if n.Op() == OCONVNOP {
+			n = n.(*ConvExpr).X
+			continue
+		}
+
+		n1 := staticValue1(n)
+		if n1 == nil {
+			return n
+		}
+		n = n1
+	}
+}
+
+// staticValue1 implements a simple SSA-like optimization. If n is a local variable
+// that is initialized and never reassigned, staticValue1 returns the initializer
+// expression. Otherwise, it returns nil.
+func staticValue1(nn Node) Node {
+	if nn.Op() != ONAME {
+		return nil
+	}
+	n := nn.(*Name)
+	if n.Class_ != PAUTO || n.Name().Addrtaken() {
+		return nil
+	}
+
+	defn := n.Name().Defn
+	if defn == nil {
+		return nil
+	}
+
+	var rhs Node
+FindRHS:
+	switch defn.Op() {
+	case OAS:
+		defn := defn.(*AssignStmt)
+		rhs = defn.Y
+	case OAS2:
+		defn := defn.(*AssignListStmt)
+		for i, lhs := range defn.Lhs {
+			if lhs == n {
+				rhs = defn.Rhs[i]
+				break FindRHS
+			}
+		}
+		base.Fatalf("%v missing from LHS of %v", n, defn)
+	default:
+		return nil
+	}
+	if rhs == nil {
+		base.Fatalf("RHS is nil: %v", defn)
+	}
+
+	if reassigned(n) {
+		return nil
+	}
+
+	return rhs
+}
+
+// reassigned takes an ONAME node, walks the function in which it is defined, and returns a boolean
+// indicating whether the name has any assignments other than its declaration.
+// The second return value is the first such assignment encountered in the walk, if any. It is mostly
+// useful for -m output documenting the reason for inhibited optimizations.
+// NB: global variables are always considered to be re-assigned.
+// TODO: handle initial declaration not including an assignment and followed by a single assignment?
+func reassigned(name *Name) bool {
+	if name.Op() != ONAME {
+		base.Fatalf("reassigned %v", name)
+	}
+	// no way to reliably check for no-reassignment of globals, assume it can be
+	if name.Curfn == nil {
+		return true
+	}
+	return Any(name.Curfn, func(n Node) bool {
+		switch n.Op() {
+		case OAS:
+			n := n.(*AssignStmt)
+			if n.X == name && n != name.Defn {
+				return true
+			}
+		case OAS2, OAS2FUNC, OAS2MAPR, OAS2DOTTYPE, OAS2RECV, OSELRECV2:
+			n := n.(*AssignListStmt)
+			for _, p := range n.Lhs {
+				if p == name && n != name.Defn {
+					return true
+				}
+			}
+		}
+		return false
+	})
+}
+
+// IsIntrinsicCall reports whether the compiler back end will treat the call as an intrinsic operation.
+var IsIntrinsicCall = func(*CallExpr) bool { return false }
+
+// SameSafeExpr checks whether it is safe to reuse one of l and r
+// instead of computing both. SameSafeExpr assumes that l and r are
+// used in the same statement or expression. In order for it to be
+// safe to reuse l or r, they must:
+// * be the same expression
+// * not have side-effects (no function calls, no channel ops);
+//   however, panics are ok
+// * not cause inappropriate aliasing; e.g. two string to []byte
+//   conversions, must result in two distinct slices
+//
+// The handling of OINDEXMAP is subtle. OINDEXMAP can occur both
+// as an lvalue (map assignment) and an rvalue (map access). This is
+// currently OK, since the only place SameSafeExpr gets used on an
+// lvalue expression is for OSLICE and OAPPEND optimizations, and it
+// is correct in those settings.
+func SameSafeExpr(l Node, r Node) bool {
+	if l.Op() != r.Op() || !types.Identical(l.Type(), r.Type()) {
+		return false
+	}
+
+	switch l.Op() {
+	case ONAME, OCLOSUREREAD:
+		return l == r
+
+	case ODOT, ODOTPTR:
+		l := l.(*SelectorExpr)
+		r := r.(*SelectorExpr)
+		return l.Sel != nil && r.Sel != nil && l.Sel == r.Sel && SameSafeExpr(l.X, r.X)
+
+	case ODEREF:
+		l := l.(*StarExpr)
+		r := r.(*StarExpr)
+		return SameSafeExpr(l.X, r.X)
+
+	case ONOT, OBITNOT, OPLUS, ONEG:
+		l := l.(*UnaryExpr)
+		r := r.(*UnaryExpr)
+		return SameSafeExpr(l.X, r.X)
+
+	case OCONVNOP:
+		l := l.(*ConvExpr)
+		r := r.(*ConvExpr)
+		return SameSafeExpr(l.X, r.X)
+
+	case OCONV:
+		l := l.(*ConvExpr)
+		r := r.(*ConvExpr)
+		// Some conversions can't be reused, such as []byte(str).
+		// Allow only numeric-ish types. This is a bit conservative.
+		return types.IsSimple[l.Type().Kind()] && SameSafeExpr(l.X, r.X)
+
+	case OINDEX, OINDEXMAP:
+		l := l.(*IndexExpr)
+		r := r.(*IndexExpr)
+		return SameSafeExpr(l.X, r.X) && SameSafeExpr(l.Index, r.Index)
+
+	case OADD, OSUB, OOR, OXOR, OMUL, OLSH, ORSH, OAND, OANDNOT, ODIV, OMOD:
+		l := l.(*BinaryExpr)
+		r := r.(*BinaryExpr)
+		return SameSafeExpr(l.X, r.X) && SameSafeExpr(l.Y, r.Y)
+
+	case OLITERAL:
+		return constant.Compare(l.Val(), token.EQL, r.Val())
+
+	case ONIL:
+		return true
+	}
+
+	return false
+}
+
+// ShouldCheckPtr reports whether pointer checking should be enabled for
+// function fn at a given level. See debugHelpFooter for defined
+// levels.
+func ShouldCheckPtr(fn *Func, level int) bool {
+	return base.Debug.Checkptr >= level && fn.Pragma&NoCheckPtr == 0
+}
+
+// IsReflectHeaderDataField reports whether l is an expression p.Data
+// where p has type reflect.SliceHeader or reflect.StringHeader.
+func IsReflectHeaderDataField(l Node) bool {
+	if l.Type() != types.Types[types.TUINTPTR] {
+		return false
+	}
+
+	var tsym *types.Sym
+	switch l.Op() {
+	case ODOT:
+		l := l.(*SelectorExpr)
+		tsym = l.X.Type().Sym()
+	case ODOTPTR:
+		l := l.(*SelectorExpr)
+		tsym = l.X.Type().Elem().Sym()
+	default:
+		return false
+	}
+
+	if tsym == nil || l.Sym().Name != "Data" || tsym.Pkg.Path != "reflect" {
+		return false
+	}
+	return tsym.Name == "SliceHeader" || tsym.Name == "StringHeader"
+}
+
+func ParamNames(ft *types.Type) []Node {
+	args := make([]Node, ft.NumParams())
+	for i, f := range ft.Params().FieldSlice() {
+		args[i] = AsNode(f.Nname)
+	}
+	return args
+}
+
+// MethodSym returns the method symbol representing a method name
+// associated with a specific receiver type.
+//
+// Method symbols can be used to distinguish the same method appearing
+// in different method sets. For example, T.M and (*T).M have distinct
+// method symbols.
+//
+// The returned symbol will be marked as a function.
+func MethodSym(recv *types.Type, msym *types.Sym) *types.Sym {
+	sym := MethodSymSuffix(recv, msym, "")
+	sym.SetFunc(true)
+	return sym
+}
+
+// MethodSymSuffix is like methodsym, but allows attaching a
+// distinguisher suffix. To avoid collisions, the suffix must not
+// start with a letter, number, or period.
+func MethodSymSuffix(recv *types.Type, msym *types.Sym, suffix string) *types.Sym {
+	if msym.IsBlank() {
+		base.Fatalf("blank method name")
+	}
+
+	rsym := recv.Sym()
+	if recv.IsPtr() {
+		if rsym != nil {
+			base.Fatalf("declared pointer receiver type: %v", recv)
+		}
+		rsym = recv.Elem().Sym()
+	}
+
+	// Find the package the receiver type appeared in. For
+	// anonymous receiver types (i.e., anonymous structs with
+	// embedded fields), use the "go" pseudo-package instead.
+	rpkg := Pkgs.Go
+	if rsym != nil {
+		rpkg = rsym.Pkg
+	}
+
+	var b bytes.Buffer
+	if recv.IsPtr() {
+		// The parentheses aren't really necessary, but
+		// they're pretty traditional at this point.
+		fmt.Fprintf(&b, "(%-S)", recv)
+	} else {
+		fmt.Fprintf(&b, "%-S", recv)
+	}
+
+	// A particular receiver type may have multiple non-exported
+	// methods with the same name. To disambiguate them, include a
+	// package qualifier for names that came from a different
+	// package than the receiver type.
+	if !types.IsExported(msym.Name) && msym.Pkg != rpkg {
+		b.WriteString(".")
+		b.WriteString(msym.Pkg.Prefix)
+	}
+
+	b.WriteString(".")
+	b.WriteString(msym.Name)
+	b.WriteString(suffix)
+
+	return rpkg.LookupBytes(b.Bytes())
+}
+
+// MethodName returns the ONAME representing the method
+// referenced by expression n, which must be a method selector,
+// method expression, or method value.
+func MethodExprName(n Node) *Name {
+	name, _ := MethodExprFunc(n).Nname.(*Name)
+	return name
+}
+
+// MethodFunc is like MethodName, but returns the types.Field instead.
+func MethodExprFunc(n Node) *types.Field {
+	switch n.Op() {
+	case ODOTMETH:
+		return n.(*SelectorExpr).Selection
+	case OMETHEXPR:
+		return n.(*MethodExpr).Method
+	case OCALLPART:
+		n := n.(*CallPartExpr)
+		return n.Method
+	}
+	base.Fatalf("unexpected node: %v (%v)", n, n.Op())
+	panic("unreachable")
+}
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 57837e9e6b..a93516d716 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -261,3 +261,30 @@ func PkgFuncName(n Node) string {
 	}
 	return p + "." + s.Name
 }
+
+var CurFunc *Func
+
+func FuncSymName(s *types.Sym) string {
+	return s.Name + "·f"
+}
+
+// NewFuncNameAt generates a new name node for a function or method.
+func NewFuncNameAt(pos src.XPos, s *types.Sym, fn *Func) *Name {
+	if fn.Nname != nil {
+		base.Fatalf("newFuncName - already have name")
+	}
+	n := NewNameAt(pos, s)
+	n.SetFunc(fn)
+	fn.Nname = n
+	return n
+}
+
+// MarkFunc marks a node as a function.
+func MarkFunc(n *Name) {
+	if n.Op() != ONAME || n.Class_ != Pxxx {
+		base.Fatalf("expected ONAME/Pxxx node, got %v", n)
+	}
+
+	n.Class_ = PFUNC
+	n.Sym().SetFunc(true)
+}
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 770f8119e0..93535f4cee 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -413,3 +413,25 @@ func NewPkgName(pos src.XPos, sym *types.Sym, pkg *types.Pkg) *PkgName {
 	p.pos = pos
 	return p
 }
+
+// IsParamStackCopy reports whether this is the on-stack copy of a
+// function parameter that moved to the heap.
+func IsParamStackCopy(n Node) bool {
+	if n.Op() != ONAME {
+		return false
+	}
+	name := n.(*Name)
+	return (name.Class_ == PPARAM || name.Class_ == PPARAMOUT) && name.Heapaddr != nil
+}
+
+// IsParamHeapCopy reports whether this is the on-heap copy of
+// a function parameter that moved to the heap.
+func IsParamHeapCopy(n Node) bool {
+	if n.Op() != ONAME {
+		return false
+	}
+	name := n.(*Name)
+	return name.Class_ == PAUTOHEAP && name.Name().Stackcopy != nil
+}
+
+var RegFP *Name
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 34b89752ad..b4a557f290 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -504,3 +504,99 @@ func IsBlank(n Node) bool {
 func IsMethod(n Node) bool {
 	return n.Type().Recv() != nil
 }
+
+func HasNamedResults(fn *Func) bool {
+	typ := fn.Type()
+	return typ.NumResults() > 0 && types.OrigSym(typ.Results().Field(0).Sym) != nil
+}
+
+// HasUniquePos reports whether n has a unique position that can be
+// used for reporting error messages.
+//
+// It's primarily used to distinguish references to named objects,
+// whose Pos will point back to their declaration position rather than
+// their usage position.
+func HasUniquePos(n Node) bool {
+	switch n.Op() {
+	case ONAME, OPACK:
+		return false
+	case OLITERAL, ONIL, OTYPE:
+		if n.Sym() != nil {
+			return false
+		}
+	}
+
+	if !n.Pos().IsKnown() {
+		if base.Flag.K != 0 {
+			base.Warn("setlineno: unknown position (line 0)")
+		}
+		return false
+	}
+
+	return true
+}
+
+func SetPos(n Node) src.XPos {
+	lno := base.Pos
+	if n != nil && HasUniquePos(n) {
+		base.Pos = n.Pos()
+	}
+	return lno
+}
+
+// The result of InitExpr MUST be assigned back to n, e.g.
+// 	n.Left = InitExpr(init, n.Left)
+func InitExpr(init []Node, n Node) Node {
+	if len(init) == 0 {
+		return n
+	}
+	if MayBeShared(n) {
+		// Introduce OCONVNOP to hold init list.
+		old := n
+		n = NewConvExpr(base.Pos, OCONVNOP, nil, old)
+		n.SetType(old.Type())
+		n.SetTypecheck(1)
+	}
+
+	n.PtrInit().Prepend(init...)
+	n.SetHasCall(true)
+	return n
+}
+
+// what's the outer value that a write to n affects?
+// outer value means containing struct or array.
+func OuterValue(n Node) Node {
+	for {
+		switch nn := n; nn.Op() {
+		case OXDOT:
+			base.Fatalf("OXDOT in walk")
+		case ODOT:
+			nn := nn.(*SelectorExpr)
+			n = nn.X
+			continue
+		case OPAREN:
+			nn := nn.(*ParenExpr)
+			n = nn.X
+			continue
+		case OCONVNOP:
+			nn := nn.(*ConvExpr)
+			n = nn.X
+			continue
+		case OINDEX:
+			nn := nn.(*IndexExpr)
+			if nn.X.Type() != nil && nn.X.Type().IsArray() {
+				n = nn.X
+				continue
+			}
+		}
+
+		return n
+	}
+}
+
+const (
+	EscUnknown = iota
+	EscNone    // Does not escape to heap, result, or parameters.
+	EscHeap    // Reachable from the heap
+	EscNever   // By construction will not escape.
+)
diff --git a/src/cmd/compile/internal/gc/scc.go b/src/cmd/compile/internal/ir/scc.go
similarity index 75%
rename from src/cmd/compile/internal/gc/scc.go
rename to src/cmd/compile/internal/ir/scc.go
index a5a6480958..4f646e22b5 100644
--- a/src/cmd/compile/internal/gc/scc.go
+++ b/src/cmd/compile/internal/ir/scc.go
@@ -2,9 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
-
-import "cmd/compile/internal/ir"
+package ir
 
 // Strongly connected components.
 //
@@ -32,13 +30,13 @@ import "cmd/compile/internal/ir"
 // when analyzing a set of mutually recursive functions.
 
 type bottomUpVisitor struct {
-	analyze  func([]*ir.Func, bool)
+	analyze  func([]*Func, bool)
 	visitgen uint32
-	nodeID   map[*ir.Func]uint32
-	stack    []*ir.Func
+	nodeID   map[*Func]uint32
+	stack    []*Func
 }
 
-// visitBottomUp invokes analyze on the ODCLFUNC nodes listed in list.
+// VisitFuncsBottomUp invokes analyze on the ODCLFUNC nodes listed in list.
 // It calls analyze with successive groups of functions, working from
 // the bottom of the call graph upward. Each time analyze is called with
 // a list of functions, every function on that list only calls other functions
@@ -51,13 +49,13 @@ type bottomUpVisitor struct {
 // If recursive is false, the list consists of only a single function and its closures.
 // If recursive is true, the list may still contain only a single function,
 // if that function is itself recursive.
-func visitBottomUp(list []ir.Node, analyze func(list []*ir.Func, recursive bool)) {
+func VisitFuncsBottomUp(list []Node, analyze func(list []*Func, recursive bool)) {
 	var v bottomUpVisitor
 	v.analyze = analyze
-	v.nodeID = make(map[*ir.Func]uint32)
+	v.nodeID = make(map[*Func]uint32)
 	for _, n := range list {
-		if n.Op() == ir.ODCLFUNC {
-			n := n.(*ir.Func)
+		if n.Op() == ODCLFUNC {
+			n := n.(*Func)
 			if !n.IsHiddenClosure() {
 				v.visit(n)
 			}
@@ -65,7 +63,7 @@ func visitBottomUp(list []ir.Node, analyze func(list []*ir.Func, recursive bool)
 	}
 }
 
-func (v *bottomUpVisitor) visit(n *ir.Func) uint32 {
+func (v *bottomUpVisitor) visit(n *Func) uint32 {
 	if id := v.nodeID[n]; id > 0 {
 		// already visited
 		return id
@@ -78,45 +76,45 @@ func (v *bottomUpVisitor) visit(n *ir.Func) uint32 {
 	min := v.visitgen
 	v.stack = append(v.stack, n)
 
-	ir.Visit(n, func(n ir.Node) {
+	Visit(n, func(n Node) {
 		switch n.Op() {
-		case ir.ONAME:
-			n := n.(*ir.Name)
-			if n.Class_ == ir.PFUNC {
+		case ONAME:
+			n := n.(*Name)
+			if n.Class_ == PFUNC {
 				if n != nil && n.Name().Defn != nil {
-					if m := v.visit(n.Name().Defn.(*ir.Func)); m < min {
+					if m := v.visit(n.Name().Defn.(*Func)); m < min {
 						min = m
 					}
 				}
 			}
-		case ir.OMETHEXPR:
-			n := n.(*ir.MethodExpr)
-			fn := methodExprName(n)
+		case OMETHEXPR:
+			n := n.(*MethodExpr)
+			fn := MethodExprName(n)
 			if fn != nil && fn.Defn != nil {
-				if m := v.visit(fn.Defn.(*ir.Func)); m < min {
+				if m := v.visit(fn.Defn.(*Func)); m < min {
 					min = m
 				}
 			}
-		case ir.ODOTMETH:
-			n := n.(*ir.SelectorExpr)
-			fn := methodExprName(n)
-			if fn != nil && fn.Op() == ir.ONAME && fn.Class_ == ir.PFUNC && fn.Defn != nil {
-				if m := v.visit(fn.Defn.(*ir.Func)); m < min {
+		case ODOTMETH:
+			n := n.(*SelectorExpr)
+			fn := MethodExprName(n)
+			if fn != nil && fn.Op() == ONAME && fn.Class_ == PFUNC && fn.Defn != nil {
+				if m := v.visit(fn.Defn.(*Func)); m < min {
 					min = m
 				}
 			}
-		case ir.OCALLPART:
-			n := n.(*ir.CallPartExpr)
-			fn := ir.AsNode(callpartMethod(n).Nname)
-			if fn != nil && fn.Op() == ir.ONAME {
-				if fn := fn.(*ir.Name); fn.Class_ == ir.PFUNC && fn.Name().Defn != nil {
-					if m := v.visit(fn.Name().Defn.(*ir.Func)); m < min {
+		case OCALLPART:
+			n := n.(*CallPartExpr)
+			fn := AsNode(n.Method.Nname)
+			if fn != nil && fn.Op() == ONAME {
+				if fn := fn.(*Name); fn.Class_ == PFUNC && fn.Name().Defn != nil {
+					if m := v.visit(fn.Name().Defn.(*Func)); m < min {
 						min = m
 					}
 				}
 			}
-		case ir.OCLOSURE:
-			n := n.(*ir.ClosureExpr)
+		case OCLOSURE:
+			n := n.(*ClosureExpr)
 			if m := v.visit(n.Func); m < min {
 				min = m
 			}
-- 
GitLab


From dac0de3748cc816352da56f516506f80c33db4a5 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 23 Dec 2020 00:39:45 -0500
Subject: [PATCH 0304/2400] [dev.regabi] cmd/compile: move type size
 calculations into package types [generated]

To break up package gc, we need to put these calculations somewhere
lower in the import graph, either an existing or new package. Package types
already needs this code and is using hacks to get it without an import cycle.
We can remove the hacks and set up for the new package gc by moving the
code into package types itself.

[git-generate]
cd src/cmd/compile/internal/gc
rf '
	# Remove old import cycle hacks in gc.
	rm TypecheckInit:/types.Widthptr =/-0,/types.Dowidth =/+0 \
		../ssa/export_test.go:/types.Dowidth =/-+
	ex {
		import "cmd/compile/internal/types"
		types.Widthptr -> Widthptr
		types.Dowidth -> dowidth
	}

	# Disable CalcSize in tests instead of base.Fatalf
	sub dowidth:/base.Fatalf\("dowidth without betypeinit"\)/ \
		// Assume this is a test. \
		return

	# Move size calculation into cmd/compile/internal/types
	mv Widthptr PtrSize
	mv Widthreg RegSize
	mv slicePtrOffset SlicePtrOffset
	mv sliceLenOffset SliceLenOffset
	mv sliceCapOffset SliceCapOffset
	mv sizeofSlice SliceSize
	mv sizeofString StringSize
	mv skipDowidthForTracing SkipSizeForTracing
	mv dowidth CalcSize
	mv checkwidth CheckSize
	mv widstruct calcStructOffset
	mv sizeCalculationDisabled CalcSizeDisabled
	mv defercheckwidth DeferCheckSize
	mv resumecheckwidth ResumeCheckSize
	mv typeptrdata PtrDataSize
	mv \
		PtrSize RegSize SlicePtrOffset SkipSizeForTracing typePos align.go PtrDataSize \
		size.go
	mv size.go cmd/compile/internal/types
'

: # Remove old import cycle hacks in types.
cd ../types
rf '
	ex {
		Widthptr -> PtrSize
		Dowidth -> CalcSize
	}
	rm Widthptr Dowidth
'

Change-Id: Ib96cdc6bda2617235480c29392ea5cfb20f60cd8
Reviewed-on: https://go-review.googlesource.com/c/go/+/279234
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/amd64/ggen.go        |  15 +-
 src/cmd/compile/internal/amd64/ssa.go         |   4 +-
 src/cmd/compile/internal/arm/ggen.go          |   9 +-
 src/cmd/compile/internal/arm64/ggen.go        |  17 +-
 src/cmd/compile/internal/gc/abiutils.go       |   6 +-
 src/cmd/compile/internal/gc/abiutils_test.go  |   6 +-
 .../compile/internal/gc/abiutilsaux_test.go   |   2 +-
 src/cmd/compile/internal/gc/alg.go            |   6 +-
 src/cmd/compile/internal/gc/closure.go        |  12 +-
 src/cmd/compile/internal/gc/embed.go          |   2 +-
 src/cmd/compile/internal/gc/gen.go            |   2 +-
 src/cmd/compile/internal/gc/go.go             |  29 --
 src/cmd/compile/internal/gc/iimport.go        |   6 +-
 src/cmd/compile/internal/gc/inl.go            |   2 +-
 src/cmd/compile/internal/gc/main.go           |   6 +-
 src/cmd/compile/internal/gc/obj.go            |  26 +-
 src/cmd/compile/internal/gc/order.go          |   2 +-
 src/cmd/compile/internal/gc/pgen.go           |  28 +-
 src/cmd/compile/internal/gc/plive.go          |  22 +-
 src/cmd/compile/internal/gc/racewalk.go       |   2 +-
 src/cmd/compile/internal/gc/reflect.go        | 127 +++-----
 src/cmd/compile/internal/gc/sinit.go          |  14 +-
 src/cmd/compile/internal/gc/ssa.go            |  56 ++--
 src/cmd/compile/internal/gc/subr.go           |  14 +-
 src/cmd/compile/internal/gc/swt.go            |   4 +-
 src/cmd/compile/internal/gc/typecheck.go      |  47 ++-
 src/cmd/compile/internal/gc/universe.go       |  18 +-
 src/cmd/compile/internal/gc/unsafe.go         |   3 +-
 src/cmd/compile/internal/gc/walk.go           |  26 +-
 src/cmd/compile/internal/mips/ggen.go         |   9 +-
 src/cmd/compile/internal/mips64/ggen.go       |  13 +-
 src/cmd/compile/internal/ppc64/ggen.go        |  11 +-
 src/cmd/compile/internal/riscv64/ggen.go      |  11 +-
 src/cmd/compile/internal/ssa/export_test.go   |   1 -
 .../internal/{gc/align.go => types/size.go}   | 289 ++++++++++++------
 src/cmd/compile/internal/types/type.go        |  10 +-
 src/cmd/compile/internal/types/utils.go       |   2 -
 src/cmd/compile/internal/x86/ggen.go          |  11 +-
 38 files changed, 439 insertions(+), 431 deletions(-)
 rename src/cmd/compile/internal/{gc/align.go => types/size.go} (66%)

diff --git a/src/cmd/compile/internal/amd64/ggen.go b/src/cmd/compile/internal/amd64/ggen.go
index 0bb0627f92..48b00b3da9 100644
--- a/src/cmd/compile/internal/amd64/ggen.go
+++ b/src/cmd/compile/internal/amd64/ggen.go
@@ -8,6 +8,7 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/x86"
 	"cmd/internal/objabi"
@@ -63,9 +64,9 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.Pr
 		return p
 	}
 
-	if cnt%int64(gc.Widthreg) != 0 {
+	if cnt%int64(types.RegSize) != 0 {
 		// should only happen with nacl
-		if cnt%int64(gc.Widthptr) != 0 {
+		if cnt%int64(types.PtrSize) != 0 {
 			base.Fatalf("zerorange count not a multiple of widthptr %d", cnt)
 		}
 		if *state&ax == 0 {
@@ -73,8 +74,8 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.Pr
 			*state |= ax
 		}
 		p = pp.Appendpp(p, x86.AMOVL, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_MEM, x86.REG_SP, off)
-		off += int64(gc.Widthptr)
-		cnt -= int64(gc.Widthptr)
+		off += int64(types.PtrSize)
+		cnt -= int64(types.PtrSize)
 	}
 
 	if cnt == 8 {
@@ -83,7 +84,7 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.Pr
 			*state |= ax
 		}
 		p = pp.Appendpp(p, x86.AMOVQ, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_MEM, x86.REG_SP, off)
-	} else if !isPlan9 && cnt <= int64(8*gc.Widthreg) {
+	} else if !isPlan9 && cnt <= int64(8*types.RegSize) {
 		if *state&x0 == 0 {
 			p = pp.Appendpp(p, x86.AXORPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_REG, x86.REG_X0, 0)
 			*state |= x0
@@ -96,7 +97,7 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.Pr
 		if cnt%16 != 0 {
 			p = pp.Appendpp(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_MEM, x86.REG_SP, off+cnt-int64(16))
 		}
-	} else if !isPlan9 && (cnt <= int64(128*gc.Widthreg)) {
+	} else if !isPlan9 && (cnt <= int64(128*types.RegSize)) {
 		if *state&x0 == 0 {
 			p = pp.Appendpp(p, x86.AXORPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_REG, x86.REG_X0, 0)
 			*state |= x0
@@ -114,7 +115,7 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.Pr
 			*state |= ax
 		}
 
-		p = pp.Appendpp(p, x86.AMOVQ, obj.TYPE_CONST, 0, cnt/int64(gc.Widthreg), obj.TYPE_REG, x86.REG_CX, 0)
+		p = pp.Appendpp(p, x86.AMOVQ, obj.TYPE_CONST, 0, cnt/int64(types.RegSize), obj.TYPE_REG, x86.REG_CX, 0)
 		p = pp.Appendpp(p, leaptr, obj.TYPE_MEM, x86.REG_SP, off, obj.TYPE_REG, x86.REG_DI, 0)
 		p = pp.Appendpp(p, x86.AREP, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
 		p = pp.Appendpp(p, x86.ASTOSQ, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index 055d1894d4..0150bd296a 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -1014,7 +1014,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 	case ssa.OpAMD64LoweredGetCallerSP:
 		// caller's SP is the address of the first arg
 		mov := x86.AMOVQ
-		if gc.Widthptr == 4 {
+		if types.PtrSize == 4 {
 			mov = x86.AMOVL
 		}
 		p := s.Prog(mov)
@@ -1036,7 +1036,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
 		p.To.Sym = gc.BoundsCheckFunc[v.AuxInt]
-		s.UseArgs(int64(2 * gc.Widthptr)) // space used in callee args area by assembly stubs
+		s.UseArgs(int64(2 * types.PtrSize)) // space used in callee args area by assembly stubs
 
 	case ssa.OpAMD64NEGQ, ssa.OpAMD64NEGL,
 		ssa.OpAMD64BSWAPQ, ssa.OpAMD64BSWAPL,
diff --git a/src/cmd/compile/internal/arm/ggen.go b/src/cmd/compile/internal/arm/ggen.go
index 2e4de9893b..2363d76346 100644
--- a/src/cmd/compile/internal/arm/ggen.go
+++ b/src/cmd/compile/internal/arm/ggen.go
@@ -7,6 +7,7 @@ package arm
 import (
 	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/arm"
 )
@@ -20,17 +21,17 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, r0 *uint32) *obj.Prog
 		*r0 = 1
 	}
 
-	if cnt < int64(4*gc.Widthptr) {
-		for i := int64(0); i < cnt; i += int64(gc.Widthptr) {
+	if cnt < int64(4*types.PtrSize) {
+		for i := int64(0); i < cnt; i += int64(types.PtrSize) {
 			p = pp.Appendpp(p, arm.AMOVW, obj.TYPE_REG, arm.REG_R0, 0, obj.TYPE_MEM, arm.REGSP, 4+off+i)
 		}
-	} else if cnt <= int64(128*gc.Widthptr) {
+	} else if cnt <= int64(128*types.PtrSize) {
 		p = pp.Appendpp(p, arm.AADD, obj.TYPE_CONST, 0, 4+off, obj.TYPE_REG, arm.REG_R1, 0)
 		p.Reg = arm.REGSP
 		p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
 		p.To.Name = obj.NAME_EXTERN
 		p.To.Sym = ir.Syms.Duffzero
-		p.To.Offset = 4 * (128 - cnt/int64(gc.Widthptr))
+		p.To.Offset = 4 * (128 - cnt/int64(types.PtrSize))
 	} else {
 		p = pp.Appendpp(p, arm.AADD, obj.TYPE_CONST, 0, 4+off, obj.TYPE_REG, arm.REG_R1, 0)
 		p.Reg = arm.REGSP
diff --git a/src/cmd/compile/internal/arm64/ggen.go b/src/cmd/compile/internal/arm64/ggen.go
index 6c280267b6..37f11e0ff6 100644
--- a/src/cmd/compile/internal/arm64/ggen.go
+++ b/src/cmd/compile/internal/arm64/ggen.go
@@ -7,6 +7,7 @@ package arm64
 import (
 	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/arm64"
 	"cmd/internal/objabi"
@@ -27,15 +28,15 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 	if cnt == 0 {
 		return p
 	}
-	if cnt < int64(4*gc.Widthptr) {
-		for i := int64(0); i < cnt; i += int64(gc.Widthptr) {
+	if cnt < int64(4*types.PtrSize) {
+		for i := int64(0); i < cnt; i += int64(types.PtrSize) {
 			p = pp.Appendpp(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGZERO, 0, obj.TYPE_MEM, arm64.REGSP, 8+off+i)
 		}
-	} else if cnt <= int64(128*gc.Widthptr) && !darwin { // darwin ld64 cannot handle BR26 reloc with non-zero addend
-		if cnt%(2*int64(gc.Widthptr)) != 0 {
+	} else if cnt <= int64(128*types.PtrSize) && !darwin { // darwin ld64 cannot handle BR26 reloc with non-zero addend
+		if cnt%(2*int64(types.PtrSize)) != 0 {
 			p = pp.Appendpp(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGZERO, 0, obj.TYPE_MEM, arm64.REGSP, 8+off)
-			off += int64(gc.Widthptr)
-			cnt -= int64(gc.Widthptr)
+			off += int64(types.PtrSize)
+			cnt -= int64(types.PtrSize)
 		}
 		p = pp.Appendpp(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGSP, 0, obj.TYPE_REG, arm64.REG_R20, 0)
 		p = pp.Appendpp(p, arm64.AADD, obj.TYPE_CONST, 0, 8+off, obj.TYPE_REG, arm64.REG_R20, 0)
@@ -43,7 +44,7 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 		p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
 		p.To.Name = obj.NAME_EXTERN
 		p.To.Sym = ir.Syms.Duffzero
-		p.To.Offset = 4 * (64 - cnt/(2*int64(gc.Widthptr)))
+		p.To.Offset = 4 * (64 - cnt/(2*int64(types.PtrSize)))
 	} else {
 		// Not using REGTMP, so this is async preemptible (async preemption clobbers REGTMP).
 		// We are at the function entry, where no register is live, so it is okay to clobber
@@ -56,7 +57,7 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 		p = pp.Appendpp(p, arm64.AMOVD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, rtmp, 0)
 		p = pp.Appendpp(p, arm64.AADD, obj.TYPE_REG, rtmp, 0, obj.TYPE_REG, arm64.REGRT2, 0)
 		p.Reg = arm64.REGRT1
-		p = pp.Appendpp(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGZERO, 0, obj.TYPE_MEM, arm64.REGRT1, int64(gc.Widthptr))
+		p = pp.Appendpp(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGZERO, 0, obj.TYPE_MEM, arm64.REGRT1, int64(types.PtrSize))
 		p.Scond = arm64.C_XPRE
 		p1 := p
 		p = pp.Appendpp(p, arm64.ACMP, obj.TYPE_REG, arm64.REGRT1, 0, obj.TYPE_NONE, 0, 0)
diff --git a/src/cmd/compile/internal/gc/abiutils.go b/src/cmd/compile/internal/gc/abiutils.go
index 19de14d48c..5822c088f9 100644
--- a/src/cmd/compile/internal/gc/abiutils.go
+++ b/src/cmd/compile/internal/gc/abiutils.go
@@ -91,7 +91,7 @@ func ABIAnalyze(t *types.Type, config ABIConfig) ABIParamResultInfo {
 		result.inparams = append(result.inparams,
 			s.assignParamOrReturn(f.Type))
 	}
-	s.stackOffset = Rnd(s.stackOffset, int64(Widthreg))
+	s.stackOffset = types.Rnd(s.stackOffset, int64(types.RegSize))
 
 	// Record number of spill slots needed.
 	result.intSpillSlots = s.rUsed.intRegs
@@ -160,7 +160,7 @@ type assignState struct {
 // specified type.
 func (state *assignState) stackSlot(t *types.Type) int64 {
 	if t.Align > 0 {
-		state.stackOffset = Rnd(state.stackOffset, int64(t.Align))
+		state.stackOffset = types.Rnd(state.stackOffset, int64(t.Align))
 	}
 	rv := state.stackOffset
 	state.stackOffset += t.Width
@@ -226,7 +226,7 @@ func (state *assignState) floatUsed() int {
 // can register allocate, FALSE otherwise (and updates state
 // accordingly).
 func (state *assignState) regassignIntegral(t *types.Type) bool {
-	regsNeeded := int(Rnd(t.Width, int64(Widthptr)) / int64(Widthptr))
+	regsNeeded := int(types.Rnd(t.Width, int64(types.PtrSize)) / int64(types.PtrSize))
 
 	// Floating point and complex.
 	if t.IsFloat() || t.IsComplex() {
diff --git a/src/cmd/compile/internal/gc/abiutils_test.go b/src/cmd/compile/internal/gc/abiutils_test.go
index 6ed27d794f..5a88332de8 100644
--- a/src/cmd/compile/internal/gc/abiutils_test.go
+++ b/src/cmd/compile/internal/gc/abiutils_test.go
@@ -29,13 +29,13 @@ func TestMain(m *testing.M) {
 	thearch.LinkArch = &x86.Linkamd64
 	thearch.REGSP = x86.REGSP
 	thearch.MAXWIDTH = 1 << 50
-	MaxWidth = thearch.MAXWIDTH
+	types.MaxWidth = thearch.MAXWIDTH
 	base.Ctxt = obj.Linknew(thearch.LinkArch)
 	base.Ctxt.DiagFunc = base.Errorf
 	base.Ctxt.DiagFlush = base.FlushErrors
 	base.Ctxt.Bso = bufio.NewWriter(os.Stdout)
-	Widthptr = thearch.LinkArch.PtrSize
-	Widthreg = thearch.LinkArch.RegSize
+	types.PtrSize = thearch.LinkArch.PtrSize
+	types.RegSize = thearch.LinkArch.RegSize
 	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
 		return typenamesym(t).Linksym()
 	}
diff --git a/src/cmd/compile/internal/gc/abiutilsaux_test.go b/src/cmd/compile/internal/gc/abiutilsaux_test.go
index de35e8edd6..8585ab9a30 100644
--- a/src/cmd/compile/internal/gc/abiutilsaux_test.go
+++ b/src/cmd/compile/internal/gc/abiutilsaux_test.go
@@ -106,7 +106,7 @@ func difftokens(atoks []string, etoks []string) string {
 
 func abitest(t *testing.T, ft *types.Type, exp expectedDump) {
 
-	dowidth(ft)
+	types.CalcSize(ft)
 
 	// Analyze with full set of registers.
 	regRes := ABIAnalyze(ft, configAMD64)
diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index d21b0d492c..dab27b4929 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -253,7 +253,7 @@ func genhash(t *types.Type) *obj.LSym {
 	// Build closure. It doesn't close over any variables, so
 	// it contains just the function pointer.
 	dsymptr(closure, 0, sym.Linksym(), 0)
-	ggloblsym(closure, int32(Widthptr), obj.DUPOK|obj.RODATA)
+	ggloblsym(closure, int32(types.PtrSize), obj.DUPOK|obj.RODATA)
 
 	return closure
 }
@@ -302,7 +302,7 @@ func sysClosure(name string) *obj.LSym {
 	if len(s.P) == 0 {
 		f := sysfunc(name)
 		dsymptr(s, 0, f, 0)
-		ggloblsym(s, int32(Widthptr), obj.DUPOK|obj.RODATA)
+		ggloblsym(s, int32(types.PtrSize), obj.DUPOK|obj.RODATA)
 	}
 	return s
 }
@@ -632,7 +632,7 @@ func geneq(t *types.Type) *obj.LSym {
 
 	// Generate a closure which points at the function we just generated.
 	dsymptr(closure, 0, sym.Linksym(), 0)
-	ggloblsym(closure, int32(Widthptr), obj.DUPOK|obj.RODATA)
+	ggloblsym(closure, int32(types.PtrSize), obj.DUPOK|obj.RODATA)
 	return closure
 }
 
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index e758cf86d4..454d97e17f 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -188,7 +188,7 @@ func capturevars(fn *ir.Func) {
 
 		// type check the & of closed variables outside the closure,
 		// so that the outer frame also grabs them and knows they escape.
-		dowidth(v.Type())
+		types.CalcSize(v.Type())
 
 		var outer ir.Node
 		outer = v.Outer
@@ -276,23 +276,23 @@ func transformclosure(fn *ir.Func) {
 			fn.Dcl = append(decls, fn.Dcl...)
 		}
 
-		dowidth(f.Type())
+		types.CalcSize(f.Type())
 		fn.SetType(f.Type()) // update type of ODCLFUNC
 	} else {
 		// The closure is not called, so it is going to stay as closure.
 		var body []ir.Node
-		offset := int64(Widthptr)
+		offset := int64(types.PtrSize)
 		for _, v := range fn.ClosureVars {
 			// cv refers to the field inside of closure OSTRUCTLIT.
 			typ := v.Type()
 			if !v.Byval() {
 				typ = types.NewPtr(typ)
 			}
-			offset = Rnd(offset, int64(typ.Align))
+			offset = types.Rnd(offset, int64(typ.Align))
 			cr := ir.NewClosureRead(typ, offset)
 			offset += typ.Width
 
-			if v.Byval() && v.Type().Width <= int64(2*Widthptr) {
+			if v.Byval() && v.Type().Width <= int64(2*types.PtrSize) {
 				// If it is a small variable captured by value, downgrade it to PAUTO.
 				v.Class_ = ir.PAUTO
 				fn.Dcl = append(fn.Dcl, v)
@@ -466,7 +466,7 @@ func makepartialcall(dot *ir.SelectorExpr, t0 *types.Type, meth *types.Sym) *ir.
 	fn.SetNeedctxt(true)
 
 	// Declare and initialize variable holding receiver.
-	cr := ir.NewClosureRead(rcvrtype, Rnd(int64(Widthptr), int64(rcvrtype.Align)))
+	cr := ir.NewClosureRead(rcvrtype, types.Rnd(int64(types.PtrSize), int64(rcvrtype.Align)))
 	ptr := NewName(lookup(".this"))
 	declare(ptr, ir.PAUTO)
 	ptr.SetUsed(true)
diff --git a/src/cmd/compile/internal/gc/embed.go b/src/cmd/compile/internal/gc/embed.go
index ea23e26069..70c5c2a25a 100644
--- a/src/cmd/compile/internal/gc/embed.go
+++ b/src/cmd/compile/internal/gc/embed.go
@@ -215,7 +215,7 @@ func initEmbed(v *ir.Name) {
 		slicedata := base.Ctxt.Lookup(`"".` + v.Sym().Name + `.files`)
 		off := 0
 		// []files pointed at by Files
-		off = dsymptr(slicedata, off, slicedata, 3*Widthptr) // []file, pointing just past slice
+		off = dsymptr(slicedata, off, slicedata, 3*types.PtrSize) // []file, pointing just past slice
 		off = duintptr(slicedata, off, uint64(len(files)))
 		off = duintptr(slicedata, off, uint64(len(files)))
 
diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
index 53298c878d..1084ff883f 100644
--- a/src/cmd/compile/internal/gc/gen.go
+++ b/src/cmd/compile/internal/gc/gen.go
@@ -66,7 +66,7 @@ func tempAt(pos src.XPos, curfn *ir.Func, t *types.Type) *ir.Name {
 	n.SetAutoTemp(true)
 	curfn.Dcl = append(curfn.Dcl, n)
 
-	dowidth(t)
+	types.CalcSize(t)
 
 	return n
 }
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index 4370a06839..a2587b3361 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -12,31 +12,6 @@ import (
 	"sync"
 )
 
-// Slices in the runtime are represented by three components:
-//
-// type slice struct {
-// 	ptr unsafe.Pointer
-// 	len int
-// 	cap int
-// }
-//
-// Strings in the runtime are represented by two components:
-//
-// type string struct {
-// 	ptr unsafe.Pointer
-// 	len int
-// }
-//
-// These variables are the offsets of fields and sizes of these structs.
-var (
-	slicePtrOffset int64
-	sliceLenOffset int64
-	sliceCapOffset int64
-
-	sizeofSlice  int64
-	sizeofString int64
-)
-
 var pragcgobuf [][]string
 
 var decldepth int32
@@ -68,10 +43,6 @@ var (
 
 var dclcontext ir.Class // PEXTERN/PAUTO
 
-var Widthptr int
-
-var Widthreg int
-
 var typecheckok bool
 
 // interface to back end
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index d04c432e5e..e9dc2a3248 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -308,10 +308,10 @@ func (r *importReader) doDecl(sym *types.Sym) *ir.Name {
 
 		// We also need to defer width calculations until
 		// after the underlying type has been assigned.
-		defercheckwidth()
+		types.DeferCheckSize()
 		underlying := r.typ()
 		t.SetUnderlying(underlying)
-		resumecheckwidth()
+		types.ResumeCheckSize()
 
 		if underlying.IsInterface() {
 			r.typeExt(t)
@@ -565,7 +565,7 @@ func (r *importReader) typ1() *types.Type {
 		t := types.NewInterface(r.currPkg, append(embeddeds, methods...))
 
 		// Ensure we expand the interface in the frontend (#25055).
-		checkwidth(t)
+		types.CheckSize(t)
 		return t
 	}
 }
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index f21494b291..b9e19da43f 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -1315,7 +1315,7 @@ func devirtualizeCall(call *ir.CallExpr) {
 	// Receiver parameter size may have changed; need to update
 	// call.Type to get correct stack offsets for result
 	// parameters.
-	checkwidth(x.Type())
+	types.CheckSize(x.Type())
 	switch ft := x.Type(); ft.NumResults() {
 	case 0:
 	case 1:
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index d55a8b0a7c..69ec5c8f2f 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -190,9 +190,9 @@ func Main(archInit func(*Arch)) {
 	initSSAEnv()
 	initSSATables()
 
-	Widthptr = thearch.LinkArch.PtrSize
-	Widthreg = thearch.LinkArch.RegSize
-	MaxWidth = thearch.MAXWIDTH
+	types.PtrSize = thearch.LinkArch.PtrSize
+	types.RegSize = thearch.LinkArch.RegSize
+	types.MaxWidth = thearch.MAXWIDTH
 	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
 		return typenamesym(t).Linksym()
 	}
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index e56e34a7a1..372277552f 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -234,7 +234,7 @@ func dumpGlobal(n *ir.Name) {
 	if n.Sym().Pkg != types.LocalPkg {
 		return
 	}
-	dowidth(n.Type())
+	types.CalcSize(n.Type())
 	ggloblnod(n)
 }
 
@@ -281,7 +281,7 @@ func dumpfuncsyms() {
 	for _, s := range funcsyms {
 		sf := s.Pkg.Lookup(ir.FuncSymName(s)).Linksym()
 		dsymptr(sf, 0, s.Linksym(), 0)
-		ggloblsym(sf, int32(Widthptr), obj.DUPOK|obj.RODATA)
+		ggloblsym(sf, int32(types.PtrSize), obj.DUPOK|obj.RODATA)
 	}
 }
 
@@ -332,7 +332,7 @@ func duint32(s *obj.LSym, off int, v uint32) int {
 }
 
 func duintptr(s *obj.LSym, off int, v uint64) int {
-	return duintxx(s, off, v, Widthptr)
+	return duintxx(s, off, v, types.PtrSize)
 }
 
 func dbvec(s *obj.LSym, off int, bv bvec) int {
@@ -505,9 +505,9 @@ func dstringdata(s *obj.LSym, off int, t string, pos src.XPos, what string) int
 }
 
 func dsymptr(s *obj.LSym, off int, x *obj.LSym, xoff int) int {
-	off = int(Rnd(int64(off), int64(Widthptr)))
-	s.WriteAddr(base.Ctxt, int64(off), Widthptr, x, int64(xoff))
-	off += Widthptr
+	off = int(types.Rnd(int64(off), int64(types.PtrSize)))
+	s.WriteAddr(base.Ctxt, int64(off), types.PtrSize, x, int64(xoff))
+	off += types.PtrSize
 	return off
 }
 
@@ -530,9 +530,9 @@ func slicesym(n *ir.Name, noff int64, arr *ir.Name, lencap int64) {
 	if arr.Op() != ir.ONAME {
 		base.Fatalf("slicesym non-name arr %v", arr)
 	}
-	s.WriteAddr(base.Ctxt, noff, Widthptr, arr.Sym().Linksym(), 0)
-	s.WriteInt(base.Ctxt, noff+sliceLenOffset, Widthptr, lencap)
-	s.WriteInt(base.Ctxt, noff+sliceCapOffset, Widthptr, lencap)
+	s.WriteAddr(base.Ctxt, noff, types.PtrSize, arr.Sym().Linksym(), 0)
+	s.WriteInt(base.Ctxt, noff+types.SliceLenOffset, types.PtrSize, lencap)
+	s.WriteInt(base.Ctxt, noff+types.SliceCapOffset, types.PtrSize, lencap)
 }
 
 // addrsym writes the static address of a to n. a must be an ONAME.
@@ -548,7 +548,7 @@ func addrsym(n *ir.Name, noff int64, a *ir.Name, aoff int64) {
 		base.Fatalf("addrsym a op %v", a.Op())
 	}
 	s := n.Sym().Linksym()
-	s.WriteAddr(base.Ctxt, noff, Widthptr, a.Sym().Linksym(), aoff)
+	s.WriteAddr(base.Ctxt, noff, types.PtrSize, a.Sym().Linksym(), aoff)
 }
 
 // pfuncsym writes the static address of f to n. f must be a global function.
@@ -564,7 +564,7 @@ func pfuncsym(n *ir.Name, noff int64, f *ir.Name) {
 		base.Fatalf("pfuncsym class not PFUNC %d", f.Class_)
 	}
 	s := n.Sym().Linksym()
-	s.WriteAddr(base.Ctxt, noff, Widthptr, funcsym(f.Sym()).Linksym(), 0)
+	s.WriteAddr(base.Ctxt, noff, types.PtrSize, funcsym(f.Sym()).Linksym(), 0)
 }
 
 // litsym writes the static literal c to n.
@@ -615,8 +615,8 @@ func litsym(n *ir.Name, noff int64, c ir.Node, wid int) {
 	case constant.String:
 		i := constant.StringVal(u)
 		symdata := stringsym(n.Pos(), i)
-		s.WriteAddr(base.Ctxt, noff, Widthptr, symdata, 0)
-		s.WriteInt(base.Ctxt, noff+int64(Widthptr), Widthptr, int64(len(i)))
+		s.WriteAddr(base.Ctxt, noff, types.PtrSize, symdata, 0)
+		s.WriteInt(base.Ctxt, noff+int64(types.PtrSize), types.PtrSize, int64(len(i)))
 
 	default:
 		base.Fatalf("litsym unhandled OLITERAL %v", c)
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 1cd33b2cb5..3d35094a58 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -242,7 +242,7 @@ func (o *Order) addrTemp(n ir.Node) ir.Node {
 	if n.Op() == ir.OLITERAL || n.Op() == ir.ONIL {
 		// TODO: expand this to all static composite literal nodes?
 		n = defaultlit(n, nil)
-		dowidth(n.Type())
+		types.CalcSize(n.Type())
 		vstat := readonlystaticname(n.Type())
 		var s InitSchedule
 		s.staticassign(vstat, 0, n, n.Type())
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index 44b614ba70..337556ea41 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -32,7 +32,7 @@ func emitptrargsmap(fn *ir.Func) {
 		return
 	}
 	lsym := base.Ctxt.Lookup(fn.LSym.Name + ".args_stackmap")
-	nptr := int(fn.Type().ArgWidth() / int64(Widthptr))
+	nptr := int(fn.Type().ArgWidth() / int64(types.PtrSize))
 	bv := bvalloc(int32(nptr) * 2)
 	nbitmap := 1
 	if fn.Type().NumResults() > 0 {
@@ -162,9 +162,9 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 			break
 		}
 
-		dowidth(n.Type())
+		types.CalcSize(n.Type())
 		w := n.Type().Width
-		if w >= MaxWidth || w < 0 {
+		if w >= types.MaxWidth || w < 0 {
 			base.Fatalf("bad width")
 		}
 		if w == 0 && lastHasPtr {
@@ -175,7 +175,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 			w = 1
 		}
 		s.stksize += w
-		s.stksize = Rnd(s.stksize, int64(n.Type().Align))
+		s.stksize = types.Rnd(s.stksize, int64(n.Type().Align))
 		if n.Type().HasPointers() {
 			s.stkptrsize = s.stksize
 			lastHasPtr = true
@@ -183,13 +183,13 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 			lastHasPtr = false
 		}
 		if thearch.LinkArch.InFamily(sys.MIPS, sys.MIPS64, sys.ARM, sys.ARM64, sys.PPC64, sys.S390X) {
-			s.stksize = Rnd(s.stksize, int64(Widthptr))
+			s.stksize = types.Rnd(s.stksize, int64(types.PtrSize))
 		}
 		n.SetFrameOffset(-s.stksize)
 	}
 
-	s.stksize = Rnd(s.stksize, int64(Widthreg))
-	s.stkptrsize = Rnd(s.stkptrsize, int64(Widthreg))
+	s.stksize = types.Rnd(s.stksize, int64(types.RegSize))
+	s.stkptrsize = types.Rnd(s.stkptrsize, int64(types.RegSize))
 }
 
 func funccompile(fn *ir.Func) {
@@ -205,7 +205,7 @@ func funccompile(fn *ir.Func) {
 	}
 
 	// assign parameter offsets
-	dowidth(fn.Type())
+	types.CalcSize(fn.Type())
 
 	if len(fn.Body) == 0 {
 		// Initialize ABI wrappers if necessary.
@@ -346,7 +346,7 @@ func init() {
 // and waits for them to complete.
 func compileFunctions() {
 	if len(compilequeue) != 0 {
-		sizeCalculationDisabled = true // not safe to calculate sizes concurrently
+		types.CalcSizeDisabled = true // not safe to calculate sizes concurrently
 		if race.Enabled {
 			// Randomize compilation order to try to shake out races.
 			tmp := make([]*ir.Func, len(compilequeue))
@@ -382,7 +382,7 @@ func compileFunctions() {
 		compilequeue = nil
 		wg.Wait()
 		base.Ctxt.InParallel = false
-		sizeCalculationDisabled = false
+		types.CalcSizeDisabled = false
 	}
 }
 
@@ -538,11 +538,11 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 		offs = n.FrameOffset()
 		abbrev = dwarf.DW_ABRV_AUTO
 		if base.Ctxt.FixedFrameSize() == 0 {
-			offs -= int64(Widthptr)
+			offs -= int64(types.PtrSize)
 		}
 		if objabi.Framepointer_enabled || objabi.GOARCH == "arm64" {
 			// There is a word space for FP on ARM64 even if the frame pointer is disabled
-			offs -= int64(Widthptr)
+			offs -= int64(types.PtrSize)
 		}
 
 	case ir.PPARAM, ir.PPARAMOUT:
@@ -735,11 +735,11 @@ func stackOffset(slot ssa.LocalSlot) int32 {
 	case ir.PAUTO:
 		off = n.FrameOffset()
 		if base.Ctxt.FixedFrameSize() == 0 {
-			off -= int64(Widthptr)
+			off -= int64(types.PtrSize)
 		}
 		if objabi.Framepointer_enabled || objabi.GOARCH == "arm64" {
 			// There is a word space for FP on ARM64 even if the frame pointer is disabled
-			off -= int64(Widthptr)
+			off -= int64(types.PtrSize)
 		}
 	case ir.PPARAM, ir.PPARAMOUT:
 		off = n.FrameOffset() + base.Ctxt.FixedFrameSize()
diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/gc/plive.go
index f13889efda..ac3b4bcd31 100644
--- a/src/cmd/compile/internal/gc/plive.go
+++ b/src/cmd/compile/internal/gc/plive.go
@@ -423,23 +423,23 @@ func onebitwalktype1(t *types.Type, off int64, bv bvec) {
 
 	switch t.Kind() {
 	case types.TPTR, types.TUNSAFEPTR, types.TFUNC, types.TCHAN, types.TMAP:
-		if off&int64(Widthptr-1) != 0 {
+		if off&int64(types.PtrSize-1) != 0 {
 			base.Fatalf("onebitwalktype1: invalid alignment, %v", t)
 		}
-		bv.Set(int32(off / int64(Widthptr))) // pointer
+		bv.Set(int32(off / int64(types.PtrSize))) // pointer
 
 	case types.TSTRING:
 		// struct { byte *str; intgo len; }
-		if off&int64(Widthptr-1) != 0 {
+		if off&int64(types.PtrSize-1) != 0 {
 			base.Fatalf("onebitwalktype1: invalid alignment, %v", t)
 		}
-		bv.Set(int32(off / int64(Widthptr))) //pointer in first slot
+		bv.Set(int32(off / int64(types.PtrSize))) //pointer in first slot
 
 	case types.TINTER:
 		// struct { Itab *tab;	void *data; }
 		// or, when isnilinter(t)==true:
 		// struct { Type *type; void *data; }
-		if off&int64(Widthptr-1) != 0 {
+		if off&int64(types.PtrSize-1) != 0 {
 			base.Fatalf("onebitwalktype1: invalid alignment, %v", t)
 		}
 		// The first word of an interface is a pointer, but we don't
@@ -454,14 +454,14 @@ func onebitwalktype1(t *types.Type, off int64, bv bvec) {
 		//      the underlying type so it won't be GCd.
 		// If we ever have a moving GC, we need to change this for 2b (as
 		// well as scan itabs to update their itab._type fields).
-		bv.Set(int32(off/int64(Widthptr) + 1)) // pointer in second slot
+		bv.Set(int32(off/int64(types.PtrSize) + 1)) // pointer in second slot
 
 	case types.TSLICE:
 		// struct { byte *array; uintgo len; uintgo cap; }
-		if off&int64(Widthptr-1) != 0 {
+		if off&int64(types.PtrSize-1) != 0 {
 			base.Fatalf("onebitwalktype1: invalid TARRAY alignment, %v", t)
 		}
-		bv.Set(int32(off / int64(Widthptr))) // pointer in first slot (BitsPointer)
+		bv.Set(int32(off / int64(types.PtrSize))) // pointer in first slot (BitsPointer)
 
 	case types.TARRAY:
 		elt := t.Elem()
@@ -1181,7 +1181,7 @@ func (lv *Liveness) emit() (argsSym, liveSym *obj.LSym) {
 	// Next, find the offset of the largest pointer in the largest node.
 	var maxArgs int64
 	if maxArgNode != nil {
-		maxArgs = maxArgNode.FrameOffset() + typeptrdata(maxArgNode.Type())
+		maxArgs = maxArgNode.FrameOffset() + types.PtrDataSize(maxArgNode.Type())
 	}
 
 	// Size locals bitmaps to be stkptrsize sized.
@@ -1196,11 +1196,11 @@ func (lv *Liveness) emit() (argsSym, liveSym *obj.LSym) {
 	// Temporary symbols for encoding bitmaps.
 	var argsSymTmp, liveSymTmp obj.LSym
 
-	args := bvalloc(int32(maxArgs / int64(Widthptr)))
+	args := bvalloc(int32(maxArgs / int64(types.PtrSize)))
 	aoff := duint32(&argsSymTmp, 0, uint32(len(lv.stackMaps))) // number of bitmaps
 	aoff = duint32(&argsSymTmp, aoff, uint32(args.n))          // number of bits in each bitmap
 
-	locals := bvalloc(int32(maxLocals / int64(Widthptr)))
+	locals := bvalloc(int32(maxLocals / int64(types.PtrSize)))
 	loff := duint32(&liveSymTmp, 0, uint32(len(lv.stackMaps))) // number of bitmaps
 	loff = duint32(&liveSymTmp, loff, uint32(locals.n))        // number of bits in each bitmap
 
diff --git a/src/cmd/compile/internal/gc/racewalk.go b/src/cmd/compile/internal/gc/racewalk.go
index e73e7fbbe1..1ad3b9b422 100644
--- a/src/cmd/compile/internal/gc/racewalk.go
+++ b/src/cmd/compile/internal/gc/racewalk.go
@@ -37,7 +37,7 @@ func instrument(fn *ir.Func) {
 			// race in the future.
 			nodpc := ir.RegFP.CloneName()
 			nodpc.SetType(types.Types[types.TUINTPTR])
-			nodpc.SetFrameOffset(int64(-Widthptr))
+			nodpc.SetFrameOffset(int64(-types.PtrSize))
 			fn.Dcl = append(fn.Dcl, nodpc)
 			fn.Enter.Prepend(mkcall("racefuncenter", nil, nil, nodpc))
 			fn.Exit.Append(mkcall("racefuncexit", nil, nil))
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 8b393a8979..987b2d6ee2 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -67,9 +67,9 @@ const (
 	MAXELEMSIZE = 128
 )
 
-func structfieldSize() int { return 3 * Widthptr }       // Sizeof(runtime.structfield{})
-func imethodSize() int     { return 4 + 4 }              // Sizeof(runtime.imethod{})
-func commonSize() int      { return 4*Widthptr + 8 + 8 } // Sizeof(runtime._type{})
+func structfieldSize() int { return 3 * types.PtrSize }       // Sizeof(runtime.structfield{})
+func imethodSize() int     { return 4 + 4 }                   // Sizeof(runtime.imethod{})
+func commonSize() int      { return 4*types.PtrSize + 8 + 8 } // Sizeof(runtime._type{})
 
 func uncommonSize(t *types.Type) int { // Sizeof(runtime.uncommontype{})
 	if t.Sym() == nil && len(methods(t)) == 0 {
@@ -91,8 +91,8 @@ func bmap(t *types.Type) *types.Type {
 
 	keytype := t.Key()
 	elemtype := t.Elem()
-	dowidth(keytype)
-	dowidth(elemtype)
+	types.CalcSize(keytype)
+	types.CalcSize(elemtype)
 	if keytype.Width > MAXKEYSIZE {
 		keytype = types.NewPtr(keytype)
 	}
@@ -132,7 +132,7 @@ func bmap(t *types.Type) *types.Type {
 	// link up fields
 	bucket := types.NewStruct(types.NoPkg, field[:])
 	bucket.SetNoalg(true)
-	dowidth(bucket)
+	types.CalcSize(bucket)
 
 	// Check invariants that map code depends on.
 	if !types.IsComparable(t.Key()) {
@@ -180,7 +180,7 @@ func bmap(t *types.Type) *types.Type {
 
 	// Double-check that overflow field is final memory in struct,
 	// with no padding at end.
-	if overflow.Offset != bucket.Width-int64(Widthptr) {
+	if overflow.Offset != bucket.Width-int64(types.PtrSize) {
 		base.Fatalf("bad offset of overflow in bmap for %v", t)
 	}
 
@@ -226,11 +226,11 @@ func hmap(t *types.Type) *types.Type {
 
 	hmap := types.NewStruct(types.NoPkg, fields)
 	hmap.SetNoalg(true)
-	dowidth(hmap)
+	types.CalcSize(hmap)
 
 	// The size of hmap should be 48 bytes on 64 bit
 	// and 28 bytes on 32 bit platforms.
-	if size := int64(8 + 5*Widthptr); hmap.Width != size {
+	if size := int64(8 + 5*types.PtrSize); hmap.Width != size {
 		base.Fatalf("hmap size not correct: got %d, want %d", hmap.Width, size)
 	}
 
@@ -289,9 +289,9 @@ func hiter(t *types.Type) *types.Type {
 	// build iterator struct holding the above fields
 	hiter := types.NewStruct(types.NoPkg, fields)
 	hiter.SetNoalg(true)
-	dowidth(hiter)
-	if hiter.Width != int64(12*Widthptr) {
-		base.Fatalf("hash_iter size not correct %d %d", hiter.Width, 12*Widthptr)
+	types.CalcSize(hiter)
+	if hiter.Width != int64(12*types.PtrSize) {
+		base.Fatalf("hash_iter size not correct %d %d", hiter.Width, 12*types.PtrSize)
 	}
 	t.MapType().Hiter = hiter
 	hiter.StructType().Map = t
@@ -335,7 +335,7 @@ func deferstruct(stksize int64) *types.Type {
 	// build struct holding the above fields
 	s := types.NewStruct(types.NoPkg, fields)
 	s.SetNoalg(true)
-	CalcStructSize(s)
+	types.CalcStructSize(s)
 	return s
 }
 
@@ -642,7 +642,7 @@ func dextratype(lsym *obj.LSym, ot int, t *types.Type, dataAdd int) int {
 	if t.Sym() == nil && len(m) == 0 {
 		return ot
 	}
-	noff := int(Rnd(int64(ot), int64(Widthptr)))
+	noff := int(types.Rnd(int64(ot), int64(types.PtrSize)))
 	if noff != ot {
 		base.Fatalf("unexpected alignment in dextratype for %v", t)
 	}
@@ -745,55 +745,6 @@ var kinds = []int{
 	types.TUNSAFEPTR:  objabi.KindUnsafePointer,
 }
 
-// typeptrdata returns the length in bytes of the prefix of t
-// containing pointer data. Anything after this offset is scalar data.
-func typeptrdata(t *types.Type) int64 {
-	if !t.HasPointers() {
-		return 0
-	}
-
-	switch t.Kind() {
-	case types.TPTR,
-		types.TUNSAFEPTR,
-		types.TFUNC,
-		types.TCHAN,
-		types.TMAP:
-		return int64(Widthptr)
-
-	case types.TSTRING:
-		// struct { byte *str; intgo len; }
-		return int64(Widthptr)
-
-	case types.TINTER:
-		// struct { Itab *tab;	void *data; } or
-		// struct { Type *type; void *data; }
-		// Note: see comment in plive.go:onebitwalktype1.
-		return 2 * int64(Widthptr)
-
-	case types.TSLICE:
-		// struct { byte *array; uintgo len; uintgo cap; }
-		return int64(Widthptr)
-
-	case types.TARRAY:
-		// haspointers already eliminated t.NumElem() == 0.
-		return (t.NumElem()-1)*t.Elem().Width + typeptrdata(t.Elem())
-
-	case types.TSTRUCT:
-		// Find the last field that has pointers.
-		var lastPtrField *types.Field
-		for _, t1 := range t.Fields().Slice() {
-			if t1.Type.HasPointers() {
-				lastPtrField = t1
-			}
-		}
-		return lastPtrField.Offset + typeptrdata(lastPtrField.Type)
-
-	default:
-		base.Fatalf("typeptrdata: unexpected type, %v", t)
-		return 0
-	}
-}
-
 // tflag is documented in reflect/type.go.
 //
 // tflag values must be kept in sync with copies in:
@@ -815,7 +766,7 @@ var (
 
 // dcommontype dumps the contents of a reflect.rtype (runtime._type).
 func dcommontype(lsym *obj.LSym, t *types.Type) int {
-	dowidth(t)
+	types.CalcSize(t)
 	eqfunc := geneq(t)
 
 	sptrWeak := true
@@ -1148,11 +1099,11 @@ func dtypesym(t *types.Type) *obj.LSym {
 		}
 		ot = duint16(lsym, ot, uint16(inCount))
 		ot = duint16(lsym, ot, uint16(outCount))
-		if Widthptr == 8 {
+		if types.PtrSize == 8 {
 			ot += 4 // align for *rtype
 		}
 
-		dataAdd := (inCount + t.NumResults()) * Widthptr
+		dataAdd := (inCount + t.NumResults()) * types.PtrSize
 		ot = dextratype(lsym, ot, t, dataAdd)
 
 		// Array of rtype pointers follows funcType.
@@ -1182,7 +1133,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 		}
 		ot = dgopkgpath(lsym, ot, tpkg)
 
-		ot = dsymptr(lsym, ot, lsym, ot+3*Widthptr+uncommonSize(t))
+		ot = dsymptr(lsym, ot, lsym, ot+3*types.PtrSize+uncommonSize(t))
 		ot = duintptr(lsym, ot, uint64(n))
 		ot = duintptr(lsym, ot, uint64(n))
 		dataAdd := imethodSize() * n
@@ -1217,14 +1168,14 @@ func dtypesym(t *types.Type) *obj.LSym {
 		// Note: flags must match maptype accessors in ../../../../runtime/type.go
 		// and maptype builder in ../../../../reflect/type.go:MapOf.
 		if t.Key().Width > MAXKEYSIZE {
-			ot = duint8(lsym, ot, uint8(Widthptr))
+			ot = duint8(lsym, ot, uint8(types.PtrSize))
 			flags |= 1 // indirect key
 		} else {
 			ot = duint8(lsym, ot, uint8(t.Key().Width))
 		}
 
 		if t.Elem().Width > MAXELEMSIZE {
-			ot = duint8(lsym, ot, uint8(Widthptr))
+			ot = duint8(lsym, ot, uint8(types.PtrSize))
 			flags |= 2 // indirect value
 		} else {
 			ot = duint8(lsym, ot, uint8(t.Elem().Width))
@@ -1281,7 +1232,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 
 		ot = dcommontype(lsym, t)
 		ot = dgopkgpath(lsym, ot, spkg)
-		ot = dsymptr(lsym, ot, lsym, ot+3*Widthptr+uncommonSize(t))
+		ot = dsymptr(lsym, ot, lsym, ot+3*types.PtrSize+uncommonSize(t))
 		ot = duintptr(lsym, ot, uint64(len(fields)))
 		ot = duintptr(lsym, ot, uint64(len(fields)))
 
@@ -1343,7 +1294,7 @@ func ifaceMethodOffset(ityp *types.Type, i int64) int64 {
 	//   [...]imethod
 	// }
 	// The size of imethod is 8.
-	return int64(commonSize()+4*Widthptr+uncommonSize(ityp)) + i*8
+	return int64(commonSize()+4*types.PtrSize+uncommonSize(ityp)) + i*8
 }
 
 // for each itabEntry, gather the methods on
@@ -1416,7 +1367,7 @@ func itabsym(it *obj.LSym, offset int64) *obj.LSym {
 	}
 
 	// keep this arithmetic in sync with *itab layout
-	methodnum := int((offset - 2*int64(Widthptr) - 8) / int64(Widthptr))
+	methodnum := int((offset - 2*int64(types.PtrSize) - 8) / int64(types.PtrSize))
 	if methodnum >= len(syms) {
 		return nil
 	}
@@ -1625,8 +1576,8 @@ const maxPtrmaskBytes = 2048
 // along with a boolean reporting whether the UseGCProg bit should be set in
 // the type kind, and the ptrdata field to record in the reflect type information.
 func dgcsym(t *types.Type) (lsym *obj.LSym, useGCProg bool, ptrdata int64) {
-	ptrdata = typeptrdata(t)
-	if ptrdata/int64(Widthptr) <= maxPtrmaskBytes*8 {
+	ptrdata = types.PtrDataSize(t)
+	if ptrdata/int64(types.PtrSize) <= maxPtrmaskBytes*8 {
 		lsym = dgcptrmask(t)
 		return
 	}
@@ -1638,7 +1589,7 @@ func dgcsym(t *types.Type) (lsym *obj.LSym, useGCProg bool, ptrdata int64) {
 
 // dgcptrmask emits and returns the symbol containing a pointer mask for type t.
 func dgcptrmask(t *types.Type) *obj.LSym {
-	ptrmask := make([]byte, (typeptrdata(t)/int64(Widthptr)+7)/8)
+	ptrmask := make([]byte, (types.PtrDataSize(t)/int64(types.PtrSize)+7)/8)
 	fillptrmask(t, ptrmask)
 	p := fmt.Sprintf("gcbits.%x", ptrmask)
 
@@ -1669,7 +1620,7 @@ func fillptrmask(t *types.Type, ptrmask []byte) {
 	vec := bvalloc(8 * int32(len(ptrmask)))
 	onebitwalktype1(t, 0, vec)
 
-	nptr := typeptrdata(t) / int64(Widthptr)
+	nptr := types.PtrDataSize(t) / int64(types.PtrSize)
 	for i := int64(0); i < nptr; i++ {
 		if vec.Get(int32(i)) {
 			ptrmask[i/8] |= 1 << (uint(i) % 8)
@@ -1682,7 +1633,7 @@ func fillptrmask(t *types.Type, ptrmask []byte) {
 // In practice, the size is typeptrdata(t) except for non-trivial arrays.
 // For non-trivial arrays, the program describes the full t.Width size.
 func dgcprog(t *types.Type) (*obj.LSym, int64) {
-	dowidth(t)
+	types.CalcSize(t)
 	if t.Width == types.BADWIDTH {
 		base.Fatalf("dgcprog: %v badwidth", t)
 	}
@@ -1690,9 +1641,9 @@ func dgcprog(t *types.Type) (*obj.LSym, int64) {
 	var p GCProg
 	p.init(lsym)
 	p.emit(t, 0)
-	offset := p.w.BitIndex() * int64(Widthptr)
+	offset := p.w.BitIndex() * int64(types.PtrSize)
 	p.end()
-	if ptrdata := typeptrdata(t); offset < ptrdata || offset > t.Width {
+	if ptrdata := types.PtrDataSize(t); offset < ptrdata || offset > t.Width {
 		base.Fatalf("dgcprog: %v: offset=%d but ptrdata=%d size=%d", t, offset, ptrdata, t.Width)
 	}
 	return lsym, offset
@@ -1728,12 +1679,12 @@ func (p *GCProg) end() {
 }
 
 func (p *GCProg) emit(t *types.Type, offset int64) {
-	dowidth(t)
+	types.CalcSize(t)
 	if !t.HasPointers() {
 		return
 	}
-	if t.Width == int64(Widthptr) {
-		p.w.Ptr(offset / int64(Widthptr))
+	if t.Width == int64(types.PtrSize) {
+		p.w.Ptr(offset / int64(types.PtrSize))
 		return
 	}
 	switch t.Kind() {
@@ -1741,14 +1692,14 @@ func (p *GCProg) emit(t *types.Type, offset int64) {
 		base.Fatalf("GCProg.emit: unexpected type %v", t)
 
 	case types.TSTRING:
-		p.w.Ptr(offset / int64(Widthptr))
+		p.w.Ptr(offset / int64(types.PtrSize))
 
 	case types.TINTER:
 		// Note: the first word isn't a pointer. See comment in plive.go:onebitwalktype1.
-		p.w.Ptr(offset/int64(Widthptr) + 1)
+		p.w.Ptr(offset/int64(types.PtrSize) + 1)
 
 	case types.TSLICE:
-		p.w.Ptr(offset / int64(Widthptr))
+		p.w.Ptr(offset / int64(types.PtrSize))
 
 	case types.TARRAY:
 		if t.NumElem() == 0 {
@@ -1764,7 +1715,7 @@ func (p *GCProg) emit(t *types.Type, offset int64) {
 			elem = elem.Elem()
 		}
 
-		if !p.w.ShouldRepeat(elem.Width/int64(Widthptr), count) {
+		if !p.w.ShouldRepeat(elem.Width/int64(types.PtrSize), count) {
 			// Cheaper to just emit the bits.
 			for i := int64(0); i < count; i++ {
 				p.emit(elem, offset+i*elem.Width)
@@ -1772,8 +1723,8 @@ func (p *GCProg) emit(t *types.Type, offset int64) {
 			return
 		}
 		p.emit(elem, offset)
-		p.w.ZeroUntil((offset + elem.Width) / int64(Widthptr))
-		p.w.Repeat(elem.Width/int64(Widthptr), count-1)
+		p.w.ZeroUntil((offset + elem.Width) / int64(types.PtrSize))
+		p.w.Repeat(elem.Width/int64(types.PtrSize), count-1)
 
 	case types.TSTRUCT:
 		for _, t1 := range t.Fields().Slice() {
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 936edb3d70..e9a4590043 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -330,8 +330,8 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 			}
 			// Copy val directly into n.
 			ir.SetPos(val)
-			if !s.staticassign(l, loff+int64(Widthptr), val, val.Type()) {
-				a := ir.NewNameOffsetExpr(base.Pos, l, loff+int64(Widthptr), val.Type())
+			if !s.staticassign(l, loff+int64(types.PtrSize), val, val.Type()) {
+				a := ir.NewNameOffsetExpr(base.Pos, l, loff+int64(types.PtrSize), val.Type())
 				s.append(ir.NewAssignStmt(base.Pos, a, val))
 			}
 		} else {
@@ -341,7 +341,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 			if !s.staticassign(a, 0, val, val.Type()) {
 				s.append(ir.NewAssignStmt(base.Pos, a, val))
 			}
-			addrsym(l, loff+int64(Widthptr), a, 0)
+			addrsym(l, loff+int64(types.PtrSize), a, 0)
 		}
 
 		return true
@@ -622,7 +622,7 @@ func isSmallSliceLit(n *ir.CompLitExpr) bool {
 func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes) {
 	// make an array type corresponding the number of elements we have
 	t := types.NewArray(n.Type().Elem(), n.Len)
-	dowidth(t)
+	types.CalcSize(t)
 
 	if ctxt == inNonInitFunction {
 		// put everything into static array
@@ -801,8 +801,8 @@ func maplit(n *ir.CompLitExpr, m ir.Node, init *ir.Nodes) {
 		tk.SetNoalg(true)
 		te.SetNoalg(true)
 
-		dowidth(tk)
-		dowidth(te)
+		types.CalcSize(tk)
+		types.CalcSize(te)
 
 		// make and initialize static arrays
 		vstatk := readonlystaticname(tk)
@@ -1034,7 +1034,7 @@ func stataddr(n ir.Node) (name *ir.Name, offset int64, ok bool) {
 		}
 
 		// Check for overflow.
-		if n.Type().Width != 0 && MaxWidth/n.Type().Width <= int64(l) {
+		if n.Type().Width != 0 && types.MaxWidth/n.Type().Width <= int64(l) {
 			break
 		}
 		offset += int64(l) * n.Type().Width
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index f879d8b86d..21925a0d65 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -2248,8 +2248,8 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 			return v
 		}
 
-		dowidth(from)
-		dowidth(to)
+		types.CalcSize(from)
+		types.CalcSize(to)
 		if from.Width != to.Width {
 			s.Fatalf("CONVNOP width mismatch %v (%d) -> %v (%d)\n", from, from.Width, to, to.Width)
 			return nil
@@ -3016,7 +3016,7 @@ func (s *state) append(n *ir.CallExpr, inplace bool) *ssa.Value {
 				s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, sn, s.mem())
 			}
 		}
-		capaddr := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.IntPtr, sliceCapOffset, addr)
+		capaddr := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.IntPtr, types.SliceCapOffset, addr)
 		s.store(types.Types[types.TINT], capaddr, r[2])
 		s.store(pt, addr, r[0])
 		// load the value we just stored to avoid having to spill it
@@ -3037,7 +3037,7 @@ func (s *state) append(n *ir.CallExpr, inplace bool) *ssa.Value {
 	if inplace {
 		l = s.variable(lenVar, types.Types[types.TINT]) // generates phi for len
 		nl = s.newValue2(s.ssaOp(ir.OADD, types.Types[types.TINT]), types.Types[types.TINT], l, s.constInt(types.Types[types.TINT], nargs))
-		lenaddr := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.IntPtr, sliceLenOffset, addr)
+		lenaddr := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.IntPtr, types.SliceLenOffset, addr)
 		s.store(types.Types[types.TINT], lenaddr, nl)
 	}
 
@@ -3153,7 +3153,7 @@ func (s *state) assign(left ir.Node, right *ssa.Value, deref bool, skip skipMask
 		return
 	}
 	t := left.Type()
-	dowidth(t)
+	types.CalcSize(t)
 	if s.canSSA(left) {
 		if deref {
 			s.Fatalf("can SSA LHS %v but not RHS %s", left, right)
@@ -4706,7 +4706,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			closure = iclosure
 		}
 	}
-	dowidth(fn.Type())
+	types.CalcSize(fn.Type())
 	stksize := fn.Type().ArgWidth() // includes receiver, args, and results
 
 	// Run all assignments of temps.
@@ -4778,11 +4778,11 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			s.store(types.Types[types.TUINTPTR], arg0, addr)
 			call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, aux, s.mem())
 		}
-		if stksize < int64(Widthptr) {
+		if stksize < int64(types.PtrSize) {
 			// We need room for both the call to deferprocStack and the call to
 			// the deferred function.
 			// TODO Revisit this if/when we pass args in registers.
-			stksize = int64(Widthptr)
+			stksize = int64(types.PtrSize)
 		}
 		call.AuxInt = stksize
 	} else {
@@ -4800,15 +4800,15 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 				addr := s.constOffPtrSP(s.f.Config.Types.UInt32Ptr, argStart)
 				s.store(types.Types[types.TUINT32], addr, argsize)
 			}
-			ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(argStart) + int32(Widthptr)})
+			ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(argStart) + int32(types.PtrSize)})
 			if testLateExpansion {
 				callArgs = append(callArgs, closure)
 			} else {
-				addr := s.constOffPtrSP(s.f.Config.Types.UintptrPtr, argStart+int64(Widthptr))
+				addr := s.constOffPtrSP(s.f.Config.Types.UintptrPtr, argStart+int64(types.PtrSize))
 				s.store(types.Types[types.TUINTPTR], addr, closure)
 			}
-			stksize += 2 * int64(Widthptr)
-			argStart += 2 * int64(Widthptr)
+			stksize += 2 * int64(types.PtrSize)
+			argStart += 2 * int64(types.PtrSize)
 		}
 
 		// Set receiver (for interface calls).
@@ -4970,7 +4970,7 @@ func (s *state) getClosureAndRcvr(fn *ir.SelectorExpr) (*ssa.Value, *ssa.Value)
 	i := s.expr(fn.X)
 	itab := s.newValue1(ssa.OpITab, types.Types[types.TUINTPTR], i)
 	s.nilCheck(itab)
-	itabidx := fn.Offset + 2*int64(Widthptr) + 8 // offset of fun field in runtime.itab
+	itabidx := fn.Offset + 2*int64(types.PtrSize) + 8 // offset of fun field in runtime.itab
 	closure := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.UintptrPtr, itabidx, itab)
 	rcvr := s.newValue1(ssa.OpIData, s.f.Config.Types.BytePtr, i)
 	return closure, rcvr
@@ -5177,8 +5177,8 @@ func (s *state) canSSAName(name *ir.Name) bool {
 
 // canSSA reports whether variables of type t are SSA-able.
 func canSSAType(t *types.Type) bool {
-	dowidth(t)
-	if t.Width > int64(4*Widthptr) {
+	types.CalcSize(t)
+	if t.Width > int64(4*types.PtrSize) {
 		// 4*Widthptr is an arbitrary constant. We want it
 		// to be at least 3*Widthptr so slices can be registerized.
 		// Too big and we'll introduce too much register pressure.
@@ -5379,7 +5379,7 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
 
 	for _, arg := range args {
 		t := arg.Type
-		off = Rnd(off, t.Alignment())
+		off = types.Rnd(off, t.Alignment())
 		size := t.Size()
 		ACArgs = append(ACArgs, ssa.Param{Type: t, Offset: int32(off)})
 		if testLateExpansion {
@@ -5390,12 +5390,12 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
 		}
 		off += size
 	}
-	off = Rnd(off, int64(Widthreg))
+	off = types.Rnd(off, int64(types.RegSize))
 
 	// Accumulate results types and offsets
 	offR := off
 	for _, t := range results {
-		offR = Rnd(offR, t.Alignment())
+		offR = types.Rnd(offR, t.Alignment())
 		ACResults = append(ACResults, ssa.Param{Type: t, Offset: int32(offR)})
 		offR += t.Size()
 	}
@@ -5429,7 +5429,7 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
 	res := make([]*ssa.Value, len(results))
 	if testLateExpansion {
 		for i, t := range results {
-			off = Rnd(off, t.Alignment())
+			off = types.Rnd(off, t.Alignment())
 			if canSSAType(t) {
 				res[i] = s.newValue1I(ssa.OpSelectN, t, int64(i), call)
 			} else {
@@ -5440,13 +5440,13 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
 		}
 	} else {
 		for i, t := range results {
-			off = Rnd(off, t.Alignment())
+			off = types.Rnd(off, t.Alignment())
 			ptr := s.constOffPtrSP(types.NewPtr(t), off)
 			res[i] = s.load(t, ptr)
 			off += t.Size()
 		}
 	}
-	off = Rnd(off, int64(Widthptr))
+	off = types.Rnd(off, int64(types.PtrSize))
 
 	// Remember how much callee stack space we needed.
 	call.AuxInt = off
@@ -6072,7 +6072,7 @@ func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Val
 					return
 				}
 				// Load type out of itab, build interface with existing idata.
-				off := s.newValue1I(ssa.OpOffPtr, byteptr, int64(Widthptr), itab)
+				off := s.newValue1I(ssa.OpOffPtr, byteptr, int64(types.PtrSize), itab)
 				typ := s.load(byteptr, off)
 				idata := s.newValue1(ssa.OpIData, byteptr, iface)
 				res = s.newValue2(ssa.OpIMake, n.Type(), typ, idata)
@@ -6082,7 +6082,7 @@ func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Val
 			s.startBlock(bOk)
 			// nonempty -> empty
 			// Need to load type from itab
-			off := s.newValue1I(ssa.OpOffPtr, byteptr, int64(Widthptr), itab)
+			off := s.newValue1I(ssa.OpOffPtr, byteptr, int64(types.PtrSize), itab)
 			s.vars[typVar] = s.load(byteptr, off)
 			s.endBlock()
 
@@ -6764,14 +6764,14 @@ func genssa(f *ssa.Func, pp *Progs) {
 func defframe(s *SSAGenState, e *ssafn) {
 	pp := s.pp
 
-	frame := Rnd(s.maxarg+e.stksize, int64(Widthreg))
+	frame := types.Rnd(s.maxarg+e.stksize, int64(types.RegSize))
 	if thearch.PadFrame != nil {
 		frame = thearch.PadFrame(frame)
 	}
 
 	// Fill in argument and frame size.
 	pp.Text.To.Type = obj.TYPE_TEXTSIZE
-	pp.Text.To.Val = int32(Rnd(e.curfn.Type().ArgWidth(), int64(Widthreg)))
+	pp.Text.To.Val = int32(types.Rnd(e.curfn.Type().ArgWidth(), int64(types.RegSize)))
 	pp.Text.To.Offset = frame
 
 	// Insert code to zero ambiguously live variables so that the
@@ -6792,11 +6792,11 @@ func defframe(s *SSAGenState, e *ssafn) {
 		if n.Class_ != ir.PAUTO {
 			e.Fatalf(n.Pos(), "needzero class %d", n.Class_)
 		}
-		if n.Type().Size()%int64(Widthptr) != 0 || n.FrameOffset()%int64(Widthptr) != 0 || n.Type().Size() == 0 {
+		if n.Type().Size()%int64(types.PtrSize) != 0 || n.FrameOffset()%int64(types.PtrSize) != 0 || n.Type().Size() == 0 {
 			e.Fatalf(n.Pos(), "var %L has size %d offset %d", n, n.Type().Size(), n.Offset_)
 		}
 
-		if lo != hi && n.FrameOffset()+n.Type().Size() >= lo-int64(2*Widthreg) {
+		if lo != hi && n.FrameOffset()+n.Type().Size() >= lo-int64(2*types.RegSize) {
 			// Merge with range we already have.
 			lo = n.FrameOffset()
 			continue
@@ -7274,7 +7274,7 @@ func (e *ssafn) SplitSlot(parent *ssa.LocalSlot, suffix string, offset int64, t
 	n.SetEsc(ir.EscNever)
 	n.Curfn = e.curfn
 	e.curfn.Dcl = append(e.curfn.Dcl, n)
-	dowidth(t)
+	types.CalcSize(t)
 	return ssa.LocalSlot{N: n, Type: t, Off: 0, SplitOf: parent, SplitOffset: offset}
 }
 
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index bcf17e42d6..d4c7c6db1a 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -1377,8 +1377,8 @@ func itabType(itab ir.Node) ir.Node {
 	typ := ir.NewSelectorExpr(base.Pos, ir.ODOTPTR, itab, nil)
 	typ.SetType(types.NewPtr(types.Types[types.TUINT8]))
 	typ.SetTypecheck(1)
-	typ.Offset = int64(Widthptr) // offset of _type in runtime.itab
-	typ.SetBounded(true)         // guaranteed not to fault
+	typ.Offset = int64(types.PtrSize) // offset of _type in runtime.itab
+	typ.SetBounded(true)              // guaranteed not to fault
 	return typ
 }
 
@@ -1403,13 +1403,3 @@ func ifaceData(pos src.XPos, n ir.Node, t *types.Type) ir.Node {
 	ind.SetBounded(true)
 	return ind
 }
-
-// typePos returns the position associated with t.
-// This is where t was declared or where it appeared as a type expression.
-func typePos(t *types.Type) src.XPos {
-	if pos := t.Pos(); pos.IsKnown() {
-		return pos
-	}
-	base.Fatalf("bad type: %v", t)
-	panic("unreachable")
-}
diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index 5bbc91fcc1..4e7ff00434 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -535,9 +535,9 @@ func walkTypeSwitch(sw *ir.SwitchStmt) {
 	dotHash.SetType(types.Types[types.TUINT32])
 	dotHash.SetTypecheck(1)
 	if s.facename.Type().IsEmptyInterface() {
-		dotHash.Offset = int64(2 * Widthptr) // offset of hash in runtime._type
+		dotHash.Offset = int64(2 * types.PtrSize) // offset of hash in runtime._type
 	} else {
-		dotHash.Offset = int64(2 * Widthptr) // offset of hash in runtime.itab
+		dotHash.Offset = int64(2 * types.PtrSize) // offset of hash in runtime.itab
 	}
 	dotHash.SetBounded(true) // guaranteed not to fault
 	s.hashname = copyexpr(dotHash, dotHash.Type(), &sw.Compiled)
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 0beb5712d4..0552dd180f 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -21,8 +21,6 @@ var (
 )
 
 func TypecheckInit() {
-	types.Widthptr = Widthptr
-	types.Dowidth = dowidth
 	initUniverse()
 	dclcontext = ir.PEXTERN
 	base.Timer.Start("fe", "loadsys")
@@ -163,7 +161,6 @@ func TypecheckImports() {
 }
 
 var traceIndent []byte
-var skipDowidthForTracing bool
 
 func tracePrint(title string, n ir.Node) func(np *ir.Node) {
 	indent := traceIndent
@@ -177,8 +174,8 @@ func tracePrint(title string, n ir.Node) func(np *ir.Node) {
 		tc = n.Typecheck()
 	}
 
-	skipDowidthForTracing = true
-	defer func() { skipDowidthForTracing = false }()
+	types.SkipSizeForTracing = true
+	defer func() { types.SkipSizeForTracing = false }()
 	fmt.Printf("%s: %s%s %p %s %v tc=%d\n", pos, indent, title, n, op, n, tc)
 	traceIndent = append(traceIndent, ". "...)
 
@@ -201,8 +198,8 @@ func tracePrint(title string, n ir.Node) func(np *ir.Node) {
 			typ = n.Type()
 		}
 
-		skipDowidthForTracing = true
-		defer func() { skipDowidthForTracing = false }()
+		types.SkipSizeForTracing = true
+		defer func() { types.SkipSizeForTracing = false }()
 		fmt.Printf("%s: %s=> %p %s %v tc=%d type=%L\n", pos, indent, n, op, n, tc, typ)
 	}
 }
@@ -503,7 +500,7 @@ func typecheck(n ir.Node, top int) (res ir.Node) {
 			break
 
 		default:
-			checkwidth(t)
+			types.CheckSize(t)
 		}
 	}
 	if t != nil {
@@ -651,7 +648,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 		t := types.NewSlice(n.Elem.Type())
 		n.SetOTYPE(t)
-		checkwidth(t)
+		types.CheckSize(t)
 		return n
 
 	case ir.OTARRAY:
@@ -695,7 +692,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		bound, _ := constant.Int64Val(v)
 		t := types.NewArray(n.Elem.Type(), bound)
 		n.SetOTYPE(t)
-		checkwidth(t)
+		types.CheckSize(t)
 		return n
 
 	case ir.OTMAP:
@@ -758,7 +755,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		if l.Op() == ir.OTYPE {
 			n.SetOTYPE(types.NewPtr(l.Type()))
 			// Ensure l.Type gets dowidth'd for the backend. Issue 20174.
-			checkwidth(l.Type())
+			types.CheckSize(l.Type())
 			return n
 		}
 
@@ -910,7 +907,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 						return n
 					}
 
-					dowidth(l.Type())
+					types.CalcSize(l.Type())
 					if r.Type().IsInterface() == l.Type().IsInterface() || l.Type().Width >= 1<<16 {
 						l = ir.NewConvExpr(base.Pos, aop, r.Type(), l)
 						l.SetTypecheck(1)
@@ -931,7 +928,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 						return n
 					}
 
-					dowidth(r.Type())
+					types.CalcSize(r.Type())
 					if r.Type().IsInterface() == l.Type().IsInterface() || r.Type().Width >= 1<<16 {
 						r = ir.NewConvExpr(base.Pos, aop, l.Type(), r)
 						r.SetTypecheck(1)
@@ -1139,7 +1136,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				return n
 			}
 			n.SetOp(ir.ODOTPTR)
-			checkwidth(t)
+			types.CheckSize(t)
 		}
 
 		if n.Sel.IsBlank() {
@@ -1464,7 +1461,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		} else if t.IsPtr() && t.Elem().IsArray() {
 			tp = t.Elem()
 			n.SetType(types.NewSlice(tp.Elem()))
-			dowidth(n.Type())
+			types.CalcSize(n.Type())
 			if hasmax {
 				n.SetOp(ir.OSLICE3ARR)
 			} else {
@@ -1581,7 +1578,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			n.SetType(nil)
 			return n
 		}
-		checkwidth(t)
+		types.CheckSize(t)
 
 		switch l.Op() {
 		case ir.ODOTINTER:
@@ -1860,7 +1857,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				continue
 			}
 			as[i] = assignconv(n, t.Elem(), "append")
-			checkwidth(as[i].Type()) // ensure width is calculated for backend
+			types.CheckSize(as[i].Type()) // ensure width is calculated for backend
 		}
 		return n
 
@@ -1907,7 +1904,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OCONV:
 		n := n.(*ir.ConvExpr)
-		checkwidth(n.Type()) // ensure width is calculated for backend
+		types.CheckSize(n.Type()) // ensure width is calculated for backend
 		n.X = typecheck(n.X, ctxExpr)
 		n.X = convlit1(n.X, n.Type(), true, nil)
 		t := n.X.Type()
@@ -2303,7 +2300,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 	case ir.ODCLTYPE:
 		n := n.(*ir.Decl)
 		n.X = typecheck(n.X, ctxType)
-		checkwidth(n.X.Type())
+		types.CheckSize(n.X.Type())
 		return n
 	}
 
@@ -2626,7 +2623,7 @@ func derefall(t *types.Type) *types.Type {
 func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 	s := n.Sel
 
-	dowidth(t)
+	types.CalcSize(t)
 	var f1 *types.Field
 	if t.IsStruct() || t.IsInterface() {
 		f1 = lookdot1(n, s, t, t.Fields(), dostrcmp)
@@ -2672,7 +2669,7 @@ func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 			return f2
 		}
 		tt := n.X.Type()
-		dowidth(tt)
+		types.CalcSize(tt)
 		rcvr := f2.Type.Recv().Type
 		if !types.Identical(rcvr, tt) {
 			if rcvr.IsPtr() && types.Identical(rcvr.Elem(), tt) {
@@ -3067,7 +3064,7 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 
 	case types.TSTRUCT:
 		// Need valid field offsets for Xoffset below.
-		dowidth(t)
+		types.CalcSize(t)
 
 		errored := false
 		if len(n.List) != 0 && nokeys(n.List) {
@@ -3366,7 +3363,7 @@ func typecheckas(n *ir.AssignStmt) {
 		n.X = typecheck(n.X, ctxExpr|ctxAssign)
 	}
 	if !ir.IsBlank(n.X) {
-		checkwidth(n.X.Type()) // ensure width is calculated for backend
+		types.CheckSize(n.X.Type()) // ensure width is calculated for backend
 	}
 }
 
@@ -3590,7 +3587,7 @@ func typecheckdeftype(n *ir.Name) {
 	n.SetTypecheck(1)
 	n.SetWalkdef(1)
 
-	defercheckwidth()
+	types.DeferCheckSize()
 	errorsBefore := base.Errors()
 	n.Ntype = typecheckNtype(n.Ntype)
 	if underlying := n.Ntype.Type(); underlying != nil {
@@ -3604,7 +3601,7 @@ func typecheckdeftype(n *ir.Name) {
 		// but it was reported. Silence future errors.
 		t.SetBroke(true)
 	}
-	resumecheckwidth()
+	types.ResumeCheckSize()
 }
 
 func typecheckdef(n ir.Node) {
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index b7472ede0f..5d59fdbbc5 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -77,17 +77,17 @@ var unsafeFuncs = [...]struct {
 
 // initUniverse initializes the universe block.
 func initUniverse() {
-	if Widthptr == 0 {
+	if types.PtrSize == 0 {
 		base.Fatalf("typeinit before betypeinit")
 	}
 
-	slicePtrOffset = 0
-	sliceLenOffset = Rnd(slicePtrOffset+int64(Widthptr), int64(Widthptr))
-	sliceCapOffset = Rnd(sliceLenOffset+int64(Widthptr), int64(Widthptr))
-	sizeofSlice = Rnd(sliceCapOffset+int64(Widthptr), int64(Widthptr))
+	types.SlicePtrOffset = 0
+	types.SliceLenOffset = types.Rnd(types.SlicePtrOffset+int64(types.PtrSize), int64(types.PtrSize))
+	types.SliceCapOffset = types.Rnd(types.SliceLenOffset+int64(types.PtrSize), int64(types.PtrSize))
+	types.SliceSize = types.Rnd(types.SliceCapOffset+int64(types.PtrSize), int64(types.PtrSize))
 
 	// string is same as slice wo the cap
-	sizeofString = Rnd(sliceLenOffset+int64(Widthptr), int64(Widthptr))
+	types.StringSize = types.Rnd(types.SliceLenOffset+int64(types.PtrSize), int64(types.PtrSize))
 
 	for et := types.Kind(0); et < types.NTYPE; et++ {
 		types.SimType[et] = et
@@ -103,7 +103,7 @@ func initUniverse() {
 		n.SetType(t)
 		sym.Def = n
 		if kind != types.TANY {
-			dowidth(t)
+			types.CalcSize(t)
 		}
 		return t
 	}
@@ -114,7 +114,7 @@ func initUniverse() {
 
 	for _, s := range &typedefs {
 		sameas := s.sameas32
-		if Widthptr == 8 {
+		if types.PtrSize == 8 {
 			sameas = s.sameas64
 		}
 		types.SimType[s.etype] = sameas
@@ -139,7 +139,7 @@ func initUniverse() {
 	types.ErrorType.SetUnderlying(makeErrorInterface())
 	n.SetType(types.ErrorType)
 	s.Def = n
-	dowidth(types.ErrorType)
+	types.CalcSize(types.ErrorType)
 
 	types.Types[types.TUNSAFEPTR] = defBasic(types.TUNSAFEPTR, ir.Pkgs.Unsafe, "Pointer")
 
diff --git a/src/cmd/compile/internal/gc/unsafe.go b/src/cmd/compile/internal/gc/unsafe.go
index cecc8720a9..d37ebfff31 100644
--- a/src/cmd/compile/internal/gc/unsafe.go
+++ b/src/cmd/compile/internal/gc/unsafe.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
 )
 
 // evalunsafe evaluates a package unsafe operation and returns the result.
@@ -20,7 +21,7 @@ func evalunsafe(n ir.Node) int64 {
 		if tr == nil {
 			return 0
 		}
-		dowidth(tr)
+		types.CalcSize(tr)
 		if n.Op() == ir.OALIGNOF {
 			return int64(tr.Align)
 		}
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index dd376a8835..764c5c41b0 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -470,7 +470,7 @@ func walkexpr(n ir.Node, init *ir.Nodes) ir.Node {
 		switch n.Type().Kind() {
 		case types.TBLANK, types.TNIL, types.TIDEAL:
 		default:
-			checkwidth(n.Type())
+			types.CheckSize(n.Type())
 		}
 	}
 
@@ -1031,9 +1031,9 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			// ptr = convT2X(val)
 			// e = iface{typ/tab, ptr}
 			fn := syslook(fnname)
-			dowidth(fromType)
+			types.CalcSize(fromType)
 			fn = substArgTypes(fn, fromType)
-			dowidth(fn.Type())
+			types.CalcSize(fn.Type())
 			call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
 			call.Args = []ir.Node{n.X}
 			e := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), safeexpr(walkexpr(typecheck(call, ctxExpr), init), init))
@@ -1065,10 +1065,10 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			v = nodAddr(v)
 		}
 
-		dowidth(fromType)
+		types.CalcSize(fromType)
 		fn := syslook(fnname)
 		fn = substArgTypes(fn, fromType, toType)
-		dowidth(fn.Type())
+		types.CalcSize(fn.Type())
 		call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
 		call.Args = []ir.Node{tab, v}
 		return walkexpr(typecheck(call, ctxExpr), init)
@@ -1116,7 +1116,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		// rewrite 64-bit div and mod on 32-bit architectures.
 		// TODO: Remove this code once we can introduce
 		// runtime calls late in SSA processing.
-		if Widthreg < 8 && (et == types.TINT64 || et == types.TUINT64) {
+		if types.RegSize < 8 && (et == types.TINT64 || et == types.TUINT64) {
 			if n.Y.Op() == ir.OLITERAL {
 				// Leave div/mod by constant powers of 2 or small 16-bit constants.
 				// The SSA backend will handle those.
@@ -1724,7 +1724,7 @@ func markUsedIfaceMethod(n *ir.CallExpr) {
 	r.Sym = tsym
 	// dot.Xoffset is the method index * Widthptr (the offset of code pointer
 	// in itab).
-	midx := dot.Offset / int64(Widthptr)
+	midx := dot.Offset / int64(types.PtrSize)
 	r.Add = ifaceMethodOffset(ityp, midx)
 	r.Type = objabi.R_USEIFACEMETHOD
 }
@@ -2133,7 +2133,7 @@ func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 }
 
 func callnew(t *types.Type) ir.Node {
-	dowidth(t)
+	types.CalcSize(t)
 	n := ir.NewUnaryExpr(base.Pos, ir.ONEWOBJ, typename(t))
 	n.SetType(types.NewPtr(t))
 	n.SetTypecheck(1)
@@ -2168,7 +2168,7 @@ func convas(n *ir.AssignStmt, init *ir.Nodes) *ir.AssignStmt {
 		n.Y = assignconv(n.Y, lt, "assignment")
 		n.Y = walkexpr(n.Y, init)
 	}
-	dowidth(n.Y.Type())
+	types.CalcSize(n.Y.Type())
 
 	return n
 }
@@ -2655,7 +2655,7 @@ func mapfast(t *types.Type) int {
 		if !t.Key().HasPointers() {
 			return mapfast32
 		}
-		if Widthptr == 4 {
+		if types.PtrSize == 4 {
 			return mapfast32ptr
 		}
 		base.Fatalf("small pointer %v", t.Key())
@@ -2663,7 +2663,7 @@ func mapfast(t *types.Type) int {
 		if !t.Key().HasPointers() {
 			return mapfast64
 		}
-		if Widthptr == 8 {
+		if types.PtrSize == 8 {
 			return mapfast64ptr
 		}
 		// Two-word object, at least one of which is a pointer.
@@ -3408,7 +3408,7 @@ func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 	} else {
 		step := int64(1)
 		remains := t.NumElem() * t.Elem().Width
-		combine64bit := unalignedLoad && Widthreg == 8 && t.Elem().Width <= 4 && t.Elem().IsInteger()
+		combine64bit := unalignedLoad && types.RegSize == 8 && t.Elem().Width <= 4 && t.Elem().IsInteger()
 		combine32bit := unalignedLoad && t.Elem().Width <= 2 && t.Elem().IsInteger()
 		combine16bit := unalignedLoad && t.Elem().Width == 1 && t.Elem().IsInteger()
 		for i := int64(0); remains > 0; {
@@ -3973,7 +3973,7 @@ func substArgTypes(old *ir.Name, types_ ...*types.Type) *ir.Name {
 	n := old.CloneName()
 
 	for _, t := range types_ {
-		dowidth(t)
+		types.CalcSize(t)
 	}
 	n.SetType(types.SubstAny(n.Type(), &types_))
 	if len(types_) > 0 {
diff --git a/src/cmd/compile/internal/mips/ggen.go b/src/cmd/compile/internal/mips/ggen.go
index 2356267df7..9cce68821b 100644
--- a/src/cmd/compile/internal/mips/ggen.go
+++ b/src/cmd/compile/internal/mips/ggen.go
@@ -7,6 +7,7 @@ package mips
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
+	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/mips"
 )
@@ -17,8 +18,8 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 	if cnt == 0 {
 		return p
 	}
-	if cnt < int64(4*gc.Widthptr) {
-		for i := int64(0); i < cnt; i += int64(gc.Widthptr) {
+	if cnt < int64(4*types.PtrSize) {
+		for i := int64(0); i < cnt; i += int64(types.PtrSize) {
 			p = pp.Appendpp(p, mips.AMOVW, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGSP, base.Ctxt.FixedFrameSize()+off+i)
 		}
 	} else {
@@ -33,9 +34,9 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 		p.Reg = mips.REGSP
 		p = pp.Appendpp(p, mips.AADD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, mips.REGRT2, 0)
 		p.Reg = mips.REGRT1
-		p = pp.Appendpp(p, mips.AMOVW, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGRT1, int64(gc.Widthptr))
+		p = pp.Appendpp(p, mips.AMOVW, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGRT1, int64(types.PtrSize))
 		p1 := p
-		p = pp.Appendpp(p, mips.AADD, obj.TYPE_CONST, 0, int64(gc.Widthptr), obj.TYPE_REG, mips.REGRT1, 0)
+		p = pp.Appendpp(p, mips.AADD, obj.TYPE_CONST, 0, int64(types.PtrSize), obj.TYPE_REG, mips.REGRT1, 0)
 		p = pp.Appendpp(p, mips.ABNE, obj.TYPE_REG, mips.REGRT1, 0, obj.TYPE_BRANCH, 0, 0)
 		p.Reg = mips.REGRT2
 		gc.Patch(p, p1)
diff --git a/src/cmd/compile/internal/mips64/ggen.go b/src/cmd/compile/internal/mips64/ggen.go
index 4be5bc6f6e..dc5f95960d 100644
--- a/src/cmd/compile/internal/mips64/ggen.go
+++ b/src/cmd/compile/internal/mips64/ggen.go
@@ -7,6 +7,7 @@ package mips64
 import (
 	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/mips"
 )
@@ -15,17 +16,17 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 	if cnt == 0 {
 		return p
 	}
-	if cnt < int64(4*gc.Widthptr) {
-		for i := int64(0); i < cnt; i += int64(gc.Widthptr) {
+	if cnt < int64(4*types.PtrSize) {
+		for i := int64(0); i < cnt; i += int64(types.PtrSize) {
 			p = pp.Appendpp(p, mips.AMOVV, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGSP, 8+off+i)
 		}
-	} else if cnt <= int64(128*gc.Widthptr) {
+	} else if cnt <= int64(128*types.PtrSize) {
 		p = pp.Appendpp(p, mips.AADDV, obj.TYPE_CONST, 0, 8+off-8, obj.TYPE_REG, mips.REGRT1, 0)
 		p.Reg = mips.REGSP
 		p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
 		p.To.Name = obj.NAME_EXTERN
 		p.To.Sym = ir.Syms.Duffzero
-		p.To.Offset = 8 * (128 - cnt/int64(gc.Widthptr))
+		p.To.Offset = 8 * (128 - cnt/int64(types.PtrSize))
 	} else {
 		//	ADDV	$(8+frame+lo-8), SP, r1
 		//	ADDV	$cnt, r1, r2
@@ -37,9 +38,9 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 		p.Reg = mips.REGSP
 		p = pp.Appendpp(p, mips.AADDV, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, mips.REGRT2, 0)
 		p.Reg = mips.REGRT1
-		p = pp.Appendpp(p, mips.AMOVV, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGRT1, int64(gc.Widthptr))
+		p = pp.Appendpp(p, mips.AMOVV, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGRT1, int64(types.PtrSize))
 		p1 := p
-		p = pp.Appendpp(p, mips.AADDV, obj.TYPE_CONST, 0, int64(gc.Widthptr), obj.TYPE_REG, mips.REGRT1, 0)
+		p = pp.Appendpp(p, mips.AADDV, obj.TYPE_CONST, 0, int64(types.PtrSize), obj.TYPE_REG, mips.REGRT1, 0)
 		p = pp.Appendpp(p, mips.ABNE, obj.TYPE_REG, mips.REGRT1, 0, obj.TYPE_BRANCH, 0, 0)
 		p.Reg = mips.REGRT2
 		gc.Patch(p, p1)
diff --git a/src/cmd/compile/internal/ppc64/ggen.go b/src/cmd/compile/internal/ppc64/ggen.go
index 29376badf9..9e57231863 100644
--- a/src/cmd/compile/internal/ppc64/ggen.go
+++ b/src/cmd/compile/internal/ppc64/ggen.go
@@ -8,6 +8,7 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/ppc64"
 )
@@ -16,17 +17,17 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 	if cnt == 0 {
 		return p
 	}
-	if cnt < int64(4*gc.Widthptr) {
-		for i := int64(0); i < cnt; i += int64(gc.Widthptr) {
+	if cnt < int64(4*types.PtrSize) {
+		for i := int64(0); i < cnt; i += int64(types.PtrSize) {
 			p = pp.Appendpp(p, ppc64.AMOVD, obj.TYPE_REG, ppc64.REGZERO, 0, obj.TYPE_MEM, ppc64.REGSP, base.Ctxt.FixedFrameSize()+off+i)
 		}
-	} else if cnt <= int64(128*gc.Widthptr) {
+	} else if cnt <= int64(128*types.PtrSize) {
 		p = pp.Appendpp(p, ppc64.AADD, obj.TYPE_CONST, 0, base.Ctxt.FixedFrameSize()+off-8, obj.TYPE_REG, ppc64.REGRT1, 0)
 		p.Reg = ppc64.REGSP
 		p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
 		p.To.Name = obj.NAME_EXTERN
 		p.To.Sym = ir.Syms.Duffzero
-		p.To.Offset = 4 * (128 - cnt/int64(gc.Widthptr))
+		p.To.Offset = 4 * (128 - cnt/int64(types.PtrSize))
 	} else {
 		p = pp.Appendpp(p, ppc64.AMOVD, obj.TYPE_CONST, 0, base.Ctxt.FixedFrameSize()+off-8, obj.TYPE_REG, ppc64.REGTMP, 0)
 		p = pp.Appendpp(p, ppc64.AADD, obj.TYPE_REG, ppc64.REGTMP, 0, obj.TYPE_REG, ppc64.REGRT1, 0)
@@ -34,7 +35,7 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 		p = pp.Appendpp(p, ppc64.AMOVD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, ppc64.REGTMP, 0)
 		p = pp.Appendpp(p, ppc64.AADD, obj.TYPE_REG, ppc64.REGTMP, 0, obj.TYPE_REG, ppc64.REGRT2, 0)
 		p.Reg = ppc64.REGRT1
-		p = pp.Appendpp(p, ppc64.AMOVDU, obj.TYPE_REG, ppc64.REGZERO, 0, obj.TYPE_MEM, ppc64.REGRT1, int64(gc.Widthptr))
+		p = pp.Appendpp(p, ppc64.AMOVDU, obj.TYPE_REG, ppc64.REGZERO, 0, obj.TYPE_MEM, ppc64.REGRT1, int64(types.PtrSize))
 		p1 := p
 		p = pp.Appendpp(p, ppc64.ACMP, obj.TYPE_REG, ppc64.REGRT1, 0, obj.TYPE_REG, ppc64.REGRT2, 0)
 		p = pp.Appendpp(p, ppc64.ABNE, obj.TYPE_NONE, 0, 0, obj.TYPE_BRANCH, 0, 0)
diff --git a/src/cmd/compile/internal/riscv64/ggen.go b/src/cmd/compile/internal/riscv64/ggen.go
index c77640765f..d18644bb1b 100644
--- a/src/cmd/compile/internal/riscv64/ggen.go
+++ b/src/cmd/compile/internal/riscv64/ggen.go
@@ -8,6 +8,7 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/riscv"
 )
@@ -20,20 +21,20 @@ func zeroRange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 	// Adjust the frame to account for LR.
 	off += base.Ctxt.FixedFrameSize()
 
-	if cnt < int64(4*gc.Widthptr) {
-		for i := int64(0); i < cnt; i += int64(gc.Widthptr) {
+	if cnt < int64(4*types.PtrSize) {
+		for i := int64(0); i < cnt; i += int64(types.PtrSize) {
 			p = pp.Appendpp(p, riscv.AMOV, obj.TYPE_REG, riscv.REG_ZERO, 0, obj.TYPE_MEM, riscv.REG_SP, off+i)
 		}
 		return p
 	}
 
-	if cnt <= int64(128*gc.Widthptr) {
+	if cnt <= int64(128*types.PtrSize) {
 		p = pp.Appendpp(p, riscv.AADDI, obj.TYPE_CONST, 0, off, obj.TYPE_REG, riscv.REG_A0, 0)
 		p.Reg = riscv.REG_SP
 		p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
 		p.To.Name = obj.NAME_EXTERN
 		p.To.Sym = ir.Syms.Duffzero
-		p.To.Offset = 8 * (128 - cnt/int64(gc.Widthptr))
+		p.To.Offset = 8 * (128 - cnt/int64(types.PtrSize))
 		return p
 	}
 
@@ -50,7 +51,7 @@ func zeroRange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 	p.Reg = riscv.REG_T0
 	p = pp.Appendpp(p, riscv.AMOV, obj.TYPE_REG, riscv.REG_ZERO, 0, obj.TYPE_MEM, riscv.REG_T0, 0)
 	loop := p
-	p = pp.Appendpp(p, riscv.AADD, obj.TYPE_CONST, 0, int64(gc.Widthptr), obj.TYPE_REG, riscv.REG_T0, 0)
+	p = pp.Appendpp(p, riscv.AADD, obj.TYPE_CONST, 0, int64(types.PtrSize), obj.TYPE_REG, riscv.REG_T0, 0)
 	p = pp.Appendpp(p, riscv.ABNE, obj.TYPE_REG, riscv.REG_T0, 0, obj.TYPE_BRANCH, 0, 0)
 	p.Reg = riscv.REG_T1
 	gc.Patch(p, loop)
diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go
index 644baa8548..8712ff78c1 100644
--- a/src/cmd/compile/internal/ssa/export_test.go
+++ b/src/cmd/compile/internal/ssa/export_test.go
@@ -137,7 +137,6 @@ func init() {
 	// Initialize just enough of the universe and the types package to make our tests function.
 	// TODO(josharian): move universe initialization to the types package,
 	// so this test setup can share it.
-	types.Dowidth = func(t *types.Type) {}
 
 	for _, typ := range [...]struct {
 		width int64
diff --git a/src/cmd/compile/internal/gc/align.go b/src/cmd/compile/internal/types/size.go
similarity index 66%
rename from src/cmd/compile/internal/gc/align.go
rename to src/cmd/compile/internal/types/size.go
index 92826d003b..a54c086ded 100644
--- a/src/cmd/compile/internal/gc/align.go
+++ b/src/cmd/compile/internal/types/size.go
@@ -2,22 +2,64 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package types
 
 import (
 	"bytes"
-	"cmd/compile/internal/base"
-	"cmd/compile/internal/types"
 	"fmt"
 	"sort"
+
+	"cmd/compile/internal/base"
+	"cmd/internal/src"
 )
 
+var PtrSize int
+
+var RegSize int
+
+// Slices in the runtime are represented by three components:
+//
+// type slice struct {
+// 	ptr unsafe.Pointer
+// 	len int
+// 	cap int
+// }
+//
+// Strings in the runtime are represented by two components:
+//
+// type string struct {
+// 	ptr unsafe.Pointer
+// 	len int
+// }
+//
+// These variables are the offsets of fields and sizes of these structs.
+var (
+	SlicePtrOffset int64
+	SliceLenOffset int64
+	SliceCapOffset int64
+
+	SliceSize  int64
+	StringSize int64
+)
+
+var SkipSizeForTracing bool
+
+// typePos returns the position associated with t.
+// This is where t was declared or where it appeared as a type expression.
+func typePos(t *Type) src.XPos {
+	if pos := t.Pos(); pos.IsKnown() {
+		return pos
+	}
+	base.Fatalf("bad type: %v", t)
+	panic("unreachable")
+}
+
 // MaxWidth is the maximum size of a value on the target architecture.
 var MaxWidth int64
 
-// sizeCalculationDisabled indicates whether it is safe
+// CalcSizeDisabled indicates whether it is safe
 // to calculate Types' widths and alignments. See dowidth.
-var sizeCalculationDisabled bool
+var CalcSizeDisabled bool
 
 // machine size and rounding alignment is dictated around
 // the size of a pointer, set in betypeinit (see ../amd64/galign.go).
@@ -32,15 +74,15 @@ func Rnd(o int64, r int64) int64 {
 
 // expandiface computes the method set for interface type t by
 // expanding embedded interfaces.
-func expandiface(t *types.Type) {
-	seen := make(map[*types.Sym]*types.Field)
-	var methods []*types.Field
+func expandiface(t *Type) {
+	seen := make(map[*Sym]*Field)
+	var methods []*Field
 
-	addMethod := func(m *types.Field, explicit bool) {
+	addMethod := func(m *Field, explicit bool) {
 		switch prev := seen[m.Sym]; {
 		case prev == nil:
 			seen[m.Sym] = m
-		case types.AllowsGoVersion(t.Pkg(), 1, 14) && !explicit && types.Identical(m.Type, prev.Type):
+		case AllowsGoVersion(t.Pkg(), 1, 14) && !explicit && Identical(m.Type, prev.Type):
 			return
 		default:
 			base.ErrorfAt(m.Pos, "duplicate method %s", m.Sym.Name)
@@ -53,7 +95,7 @@ func expandiface(t *types.Type) {
 			continue
 		}
 
-		checkwidth(m.Type)
+		CheckSize(m.Type)
 		addMethod(m, true)
 	}
 
@@ -79,26 +121,26 @@ func expandiface(t *types.Type) {
 		// method set.
 		for _, t1 := range m.Type.Fields().Slice() {
 			// Use m.Pos rather than t1.Pos to preserve embedding position.
-			f := types.NewField(m.Pos, t1.Sym, t1.Type)
+			f := NewField(m.Pos, t1.Sym, t1.Type)
 			addMethod(f, false)
 		}
 	}
 
-	sort.Sort(types.MethodsByName(methods))
+	sort.Sort(MethodsByName(methods))
 
-	if int64(len(methods)) >= MaxWidth/int64(Widthptr) {
+	if int64(len(methods)) >= MaxWidth/int64(PtrSize) {
 		base.ErrorfAt(typePos(t), "interface too large")
 	}
 	for i, m := range methods {
-		m.Offset = int64(i) * int64(Widthptr)
+		m.Offset = int64(i) * int64(PtrSize)
 	}
 
 	// Access fields directly to avoid recursively calling dowidth
 	// within Type.Fields().
-	t.Extra.(*types.Interface).Fields.Set(methods)
+	t.Extra.(*Interface).Fields.Set(methods)
 }
 
-func widstruct(errtype *types.Type, t *types.Type, o int64, flag int) int64 {
+func calcStructOffset(errtype *Type, t *Type, o int64, flag int) int64 {
 	starto := o
 	maxalign := int32(flag)
 	if maxalign < 1 {
@@ -112,7 +154,7 @@ func widstruct(errtype *types.Type, t *types.Type, o int64, flag int) int64 {
 			continue
 		}
 
-		dowidth(f.Type)
+		CalcSize(f.Type)
 		if int32(f.Type.Align) > maxalign {
 			maxalign = int32(f.Type.Align)
 		}
@@ -128,7 +170,7 @@ func widstruct(errtype *types.Type, t *types.Type, o int64, flag int) int64 {
 			// NOTE(rsc): This comment may be stale.
 			// It's possible the ordering has changed and this is
 			// now the common case. I'm not sure.
-			f.Nname.(types.VarObject).RecordFrameOffset(o)
+			f.Nname.(VarObject).RecordFrameOffset(o)
 		}
 
 		w := f.Type.Width
@@ -178,7 +220,7 @@ func widstruct(errtype *types.Type, t *types.Type, o int64, flag int) int64 {
 // path points to a slice used for tracking the sequence of types
 // visited. Using a pointer to a slice allows the slice capacity to
 // grow and limit reallocations.
-func findTypeLoop(t *types.Type, path *[]*types.Type) bool {
+func findTypeLoop(t *Type, path *[]*Type) bool {
 	// We implement a simple DFS loop-finding algorithm. This
 	// could be faster, but type cycles are rare.
 
@@ -190,7 +232,7 @@ func findTypeLoop(t *types.Type, path *[]*types.Type) bool {
 		// Type imported from package, so it can't be part of
 		// a type loop (otherwise that package should have
 		// failed to compile).
-		if t.Sym().Pkg != types.LocalPkg {
+		if t.Sym().Pkg != LocalPkg {
 			return false
 		}
 
@@ -202,7 +244,7 @@ func findTypeLoop(t *types.Type, path *[]*types.Type) bool {
 		}
 
 		*path = append(*path, t)
-		if findTypeLoop(t.Obj().(types.TypeObject).TypeDefn(), path) {
+		if findTypeLoop(t.Obj().(TypeObject).TypeDefn(), path) {
 			return true
 		}
 		*path = (*path)[:len(*path)-1]
@@ -210,17 +252,17 @@ func findTypeLoop(t *types.Type, path *[]*types.Type) bool {
 		// Anonymous type. Recurse on contained types.
 
 		switch t.Kind() {
-		case types.TARRAY:
+		case TARRAY:
 			if findTypeLoop(t.Elem(), path) {
 				return true
 			}
-		case types.TSTRUCT:
+		case TSTRUCT:
 			for _, f := range t.Fields().Slice() {
 				if findTypeLoop(f.Type, path) {
 					return true
 				}
 			}
-		case types.TINTER:
+		case TINTER:
 			for _, m := range t.Methods().Slice() {
 				if m.Type.IsInterface() { // embedded interface
 					if findTypeLoop(m.Type, path) {
@@ -234,12 +276,12 @@ func findTypeLoop(t *types.Type, path *[]*types.Type) bool {
 	return false
 }
 
-func reportTypeLoop(t *types.Type) {
+func reportTypeLoop(t *Type) {
 	if t.Broke() {
 		return
 	}
 
-	var l []*types.Type
+	var l []*Type
 	if !findTypeLoop(t, &l) {
 		base.Fatalf("failed to find type loop for: %v", t)
 	}
@@ -263,18 +305,20 @@ func reportTypeLoop(t *types.Type) {
 	base.ErrorfAt(typePos(l[0]), msg.String())
 }
 
-// dowidth calculates and stores the size and alignment for t.
+// CalcSize calculates and stores the size and alignment for t.
 // If sizeCalculationDisabled is set, and the size/alignment
 // have not already been calculated, it calls Fatal.
 // This is used to prevent data races in the back end.
-func dowidth(t *types.Type) {
+func CalcSize(t *Type) {
 	// Calling dowidth when typecheck tracing enabled is not safe.
 	// See issue #33658.
-	if base.EnableTrace && skipDowidthForTracing {
+	if base.EnableTrace && SkipSizeForTracing {
 		return
 	}
-	if Widthptr == 0 {
-		base.Fatalf("dowidth without betypeinit")
+	if PtrSize == 0 {
+
+		// Assume this is a test.
+		return
 	}
 
 	if t == nil {
@@ -292,7 +336,7 @@ func dowidth(t *types.Type) {
 		return
 	}
 
-	if sizeCalculationDisabled {
+	if CalcSizeDisabled {
 		if t.Broke() {
 			// break infinite recursion from Fatal call below
 			return
@@ -308,7 +352,7 @@ func dowidth(t *types.Type) {
 	}
 
 	// defer checkwidth calls until after we're done
-	defercheckwidth()
+	DeferCheckSize()
 
 	lno := base.Pos
 	if pos := t.Pos(); pos.IsKnown() {
@@ -320,13 +364,13 @@ func dowidth(t *types.Type) {
 
 	et := t.Kind()
 	switch et {
-	case types.TFUNC, types.TCHAN, types.TMAP, types.TSTRING:
+	case TFUNC, TCHAN, TMAP, TSTRING:
 		break
 
 	// simtype == 0 during bootstrap
 	default:
-		if types.SimType[t.Kind()] != 0 {
-			et = types.SimType[t.Kind()]
+		if SimType[t.Kind()] != 0 {
+			et = SimType[t.Kind()]
 		}
 	}
 
@@ -336,84 +380,84 @@ func dowidth(t *types.Type) {
 		base.Fatalf("dowidth: unknown type: %v", t)
 
 	// compiler-specific stuff
-	case types.TINT8, types.TUINT8, types.TBOOL:
+	case TINT8, TUINT8, TBOOL:
 		// bool is int8
 		w = 1
 
-	case types.TINT16, types.TUINT16:
+	case TINT16, TUINT16:
 		w = 2
 
-	case types.TINT32, types.TUINT32, types.TFLOAT32:
+	case TINT32, TUINT32, TFLOAT32:
 		w = 4
 
-	case types.TINT64, types.TUINT64, types.TFLOAT64:
+	case TINT64, TUINT64, TFLOAT64:
 		w = 8
-		t.Align = uint8(Widthreg)
+		t.Align = uint8(RegSize)
 
-	case types.TCOMPLEX64:
+	case TCOMPLEX64:
 		w = 8
 		t.Align = 4
 
-	case types.TCOMPLEX128:
+	case TCOMPLEX128:
 		w = 16
-		t.Align = uint8(Widthreg)
+		t.Align = uint8(RegSize)
 
-	case types.TPTR:
-		w = int64(Widthptr)
-		checkwidth(t.Elem())
+	case TPTR:
+		w = int64(PtrSize)
+		CheckSize(t.Elem())
 
-	case types.TUNSAFEPTR:
-		w = int64(Widthptr)
+	case TUNSAFEPTR:
+		w = int64(PtrSize)
 
-	case types.TINTER: // implemented as 2 pointers
-		w = 2 * int64(Widthptr)
-		t.Align = uint8(Widthptr)
+	case TINTER: // implemented as 2 pointers
+		w = 2 * int64(PtrSize)
+		t.Align = uint8(PtrSize)
 		expandiface(t)
 
-	case types.TCHAN: // implemented as pointer
-		w = int64(Widthptr)
+	case TCHAN: // implemented as pointer
+		w = int64(PtrSize)
 
-		checkwidth(t.Elem())
+		CheckSize(t.Elem())
 
 		// make fake type to check later to
 		// trigger channel argument check.
-		t1 := types.NewChanArgs(t)
-		checkwidth(t1)
+		t1 := NewChanArgs(t)
+		CheckSize(t1)
 
-	case types.TCHANARGS:
+	case TCHANARGS:
 		t1 := t.ChanArgs()
-		dowidth(t1) // just in case
+		CalcSize(t1) // just in case
 		if t1.Elem().Width >= 1<<16 {
 			base.ErrorfAt(typePos(t1), "channel element type too large (>64kB)")
 		}
 		w = 1 // anything will do
 
-	case types.TMAP: // implemented as pointer
-		w = int64(Widthptr)
-		checkwidth(t.Elem())
-		checkwidth(t.Key())
+	case TMAP: // implemented as pointer
+		w = int64(PtrSize)
+		CheckSize(t.Elem())
+		CheckSize(t.Key())
 
-	case types.TFORW: // should have been filled in
+	case TFORW: // should have been filled in
 		reportTypeLoop(t)
 		w = 1 // anything will do
 
-	case types.TANY:
+	case TANY:
 		// not a real type; should be replaced before use.
 		base.Fatalf("dowidth any")
 
-	case types.TSTRING:
-		if sizeofString == 0 {
+	case TSTRING:
+		if StringSize == 0 {
 			base.Fatalf("early dowidth string")
 		}
-		w = sizeofString
-		t.Align = uint8(Widthptr)
+		w = StringSize
+		t.Align = uint8(PtrSize)
 
-	case types.TARRAY:
+	case TARRAY:
 		if t.Elem() == nil {
 			break
 		}
 
-		dowidth(t.Elem())
+		CalcSize(t.Elem())
 		if t.Elem().Width != 0 {
 			cap := (uint64(MaxWidth) - 1) / uint64(t.Elem().Width)
 			if uint64(t.NumElem()) > cap {
@@ -423,42 +467,42 @@ func dowidth(t *types.Type) {
 		w = t.NumElem() * t.Elem().Width
 		t.Align = t.Elem().Align
 
-	case types.TSLICE:
+	case TSLICE:
 		if t.Elem() == nil {
 			break
 		}
-		w = sizeofSlice
-		checkwidth(t.Elem())
-		t.Align = uint8(Widthptr)
+		w = SliceSize
+		CheckSize(t.Elem())
+		t.Align = uint8(PtrSize)
 
-	case types.TSTRUCT:
+	case TSTRUCT:
 		if t.IsFuncArgStruct() {
 			base.Fatalf("dowidth fn struct %v", t)
 		}
-		w = widstruct(t, t, 0, 1)
+		w = calcStructOffset(t, t, 0, 1)
 
 	// make fake type to check later to
 	// trigger function argument computation.
-	case types.TFUNC:
-		t1 := types.NewFuncArgs(t)
-		checkwidth(t1)
-		w = int64(Widthptr) // width of func type is pointer
+	case TFUNC:
+		t1 := NewFuncArgs(t)
+		CheckSize(t1)
+		w = int64(PtrSize) // width of func type is pointer
 
 	// function is 3 cated structures;
 	// compute their widths as side-effect.
-	case types.TFUNCARGS:
+	case TFUNCARGS:
 		t1 := t.FuncArgs()
-		w = widstruct(t1, t1.Recvs(), 0, 0)
-		w = widstruct(t1, t1.Params(), w, Widthreg)
-		w = widstruct(t1, t1.Results(), w, Widthreg)
-		t1.Extra.(*types.Func).Argwid = w
-		if w%int64(Widthreg) != 0 {
+		w = calcStructOffset(t1, t1.Recvs(), 0, 0)
+		w = calcStructOffset(t1, t1.Params(), w, RegSize)
+		w = calcStructOffset(t1, t1.Results(), w, RegSize)
+		t1.Extra.(*Func).Argwid = w
+		if w%int64(RegSize) != 0 {
 			base.Warn("bad type %v %d\n", t1, w)
 		}
 		t.Align = 1
 	}
 
-	if Widthptr == 4 && w != int64(int32(w)) {
+	if PtrSize == 4 && w != int64(int32(w)) {
 		base.ErrorfAt(typePos(t), "type %v too large", t)
 	}
 
@@ -472,14 +516,14 @@ func dowidth(t *types.Type) {
 
 	base.Pos = lno
 
-	resumecheckwidth()
+	ResumeCheckSize()
 }
 
 // CalcStructSize calculates the size of s,
 // filling in s.Width and s.Align,
 // even if size calculation is otherwise disabled.
-func CalcStructSize(s *types.Type) {
-	s.Width = widstruct(s, s, 0, 1) // sets align
+func CalcStructSize(s *Type) {
+	s.Width = calcStructOffset(s, s, 0, 1) // sets align
 }
 
 // when a type's width should be known, we call checkwidth
@@ -498,9 +542,9 @@ func CalcStructSize(s *types.Type) {
 // is needed immediately.  checkwidth makes sure the
 // size is evaluated eventually.
 
-var deferredTypeStack []*types.Type
+var deferredTypeStack []*Type
 
-func checkwidth(t *types.Type) {
+func CheckSize(t *Type) {
 	if t == nil {
 		return
 	}
@@ -512,7 +556,7 @@ func checkwidth(t *types.Type) {
 	}
 
 	if defercalc == 0 {
-		dowidth(t)
+		CalcSize(t)
 		return
 	}
 
@@ -523,19 +567,68 @@ func checkwidth(t *types.Type) {
 	}
 }
 
-func defercheckwidth() {
+func DeferCheckSize() {
 	defercalc++
 }
 
-func resumecheckwidth() {
+func ResumeCheckSize() {
 	if defercalc == 1 {
 		for len(deferredTypeStack) > 0 {
 			t := deferredTypeStack[len(deferredTypeStack)-1]
 			deferredTypeStack = deferredTypeStack[:len(deferredTypeStack)-1]
 			t.SetDeferwidth(false)
-			dowidth(t)
+			CalcSize(t)
 		}
 	}
 
 	defercalc--
 }
+
+// PtrDataSize returns the length in bytes of the prefix of t
+// containing pointer data. Anything after this offset is scalar data.
+func PtrDataSize(t *Type) int64 {
+	if !t.HasPointers() {
+		return 0
+	}
+
+	switch t.Kind() {
+	case TPTR,
+		TUNSAFEPTR,
+		TFUNC,
+		TCHAN,
+		TMAP:
+		return int64(PtrSize)
+
+	case TSTRING:
+		// struct { byte *str; intgo len; }
+		return int64(PtrSize)
+
+	case TINTER:
+		// struct { Itab *tab;	void *data; } or
+		// struct { Type *type; void *data; }
+		// Note: see comment in plive.go:onebitwalktype1.
+		return 2 * int64(PtrSize)
+
+	case TSLICE:
+		// struct { byte *array; uintgo len; uintgo cap; }
+		return int64(PtrSize)
+
+	case TARRAY:
+		// haspointers already eliminated t.NumElem() == 0.
+		return (t.NumElem()-1)*t.Elem().Width + PtrDataSize(t.Elem())
+
+	case TSTRUCT:
+		// Find the last field that has pointers.
+		var lastPtrField *Field
+		for _, t1 := range t.Fields().Slice() {
+			if t1.Type.HasPointers() {
+				lastPtrField = t1
+			}
+		}
+		return lastPtrField.Offset + PtrDataSize(lastPtrField.Type)
+
+	default:
+		base.Fatalf("typeptrdata: unexpected type, %v", t)
+		return 0
+	}
+}
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 21d96c430a..b5557b492e 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -596,8 +596,8 @@ func NewPtr(elem *Type) *Type {
 
 	t := New(TPTR)
 	t.Extra = Ptr{Elem: elem}
-	t.Width = int64(Widthptr)
-	t.Align = uint8(Widthptr)
+	t.Width = int64(PtrSize)
+	t.Align = uint8(PtrSize)
 	if NewPtrCacheEnabled {
 		elem.cache.ptr = t
 	}
@@ -862,7 +862,7 @@ func (t *Type) Fields() *Fields {
 	case TSTRUCT:
 		return &t.Extra.(*Struct).fields
 	case TINTER:
-		Dowidth(t)
+		CalcSize(t)
 		return &t.Extra.(*Interface).Fields
 	}
 	base.Fatalf("Fields: type %v does not have fields", t)
@@ -929,12 +929,12 @@ func (t *Type) Size() int64 {
 		}
 		return 0
 	}
-	Dowidth(t)
+	CalcSize(t)
 	return t.Width
 }
 
 func (t *Type) Alignment() int64 {
-	Dowidth(t)
+	CalcSize(t)
 	return int64(t.Align)
 }
 
diff --git a/src/cmd/compile/internal/types/utils.go b/src/cmd/compile/internal/types/utils.go
index 531f3ea1ca..2477f1da66 100644
--- a/src/cmd/compile/internal/types/utils.go
+++ b/src/cmd/compile/internal/types/utils.go
@@ -14,8 +14,6 @@ const BADWIDTH = -1000000000
 // They are here to break import cycles.
 // TODO(gri) eliminate these dependencies.
 var (
-	Widthptr    int
-	Dowidth     func(*Type)
 	TypeLinkSym func(*Type) *obj.LSym
 )
 
diff --git a/src/cmd/compile/internal/x86/ggen.go b/src/cmd/compile/internal/x86/ggen.go
index f5d08a68ed..de43594e88 100644
--- a/src/cmd/compile/internal/x86/ggen.go
+++ b/src/cmd/compile/internal/x86/ggen.go
@@ -7,6 +7,7 @@ package x86
 import (
 	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/x86"
 )
@@ -20,16 +21,16 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, ax *uint32) *obj.Prog
 		*ax = 1
 	}
 
-	if cnt <= int64(4*gc.Widthreg) {
-		for i := int64(0); i < cnt; i += int64(gc.Widthreg) {
+	if cnt <= int64(4*types.RegSize) {
+		for i := int64(0); i < cnt; i += int64(types.RegSize) {
 			p = pp.Appendpp(p, x86.AMOVL, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_MEM, x86.REG_SP, off+i)
 		}
-	} else if cnt <= int64(128*gc.Widthreg) {
+	} else if cnt <= int64(128*types.RegSize) {
 		p = pp.Appendpp(p, x86.ALEAL, obj.TYPE_MEM, x86.REG_SP, off, obj.TYPE_REG, x86.REG_DI, 0)
-		p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_ADDR, 0, 1*(128-cnt/int64(gc.Widthreg)))
+		p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_ADDR, 0, 1*(128-cnt/int64(types.RegSize)))
 		p.To.Sym = ir.Syms.Duffzero
 	} else {
-		p = pp.Appendpp(p, x86.AMOVL, obj.TYPE_CONST, 0, cnt/int64(gc.Widthreg), obj.TYPE_REG, x86.REG_CX, 0)
+		p = pp.Appendpp(p, x86.AMOVL, obj.TYPE_CONST, 0, cnt/int64(types.RegSize), obj.TYPE_REG, x86.REG_CX, 0)
 		p = pp.Appendpp(p, x86.ALEAL, obj.TYPE_MEM, x86.REG_SP, off, obj.TYPE_REG, x86.REG_DI, 0)
 		p = pp.Appendpp(p, x86.AREP, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
 		p = pp.Appendpp(p, x86.ASTOSL, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
-- 
GitLab


From b9693d7627089204e6c2448f543c3512d86dae70 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 23 Dec 2020 00:41:49 -0500
Subject: [PATCH 0305/2400] [dev.regabi] cmd/compile: split out package
 typecheck [generated]

This commit splits the typechecking logic into its own package,
the first of a sequence of CLs to break package gc into more
manageable units.

[git-generate]
cd src/cmd/compile/internal/gc
rf '
	# The binary import/export has to be part of typechecking,
	# because we load inlined function bodies lazily, but "exporter"
	# should not be. Move that out of bexport.go.
	mv exporter exporter.markObject exporter.markType export.go

	# Use the typechecking helpers, so that the calls left behind
	# in package gc do not need access to ctxExpr etc.
	ex {
		import "cmd/compile/internal/ir"

		# TODO(rsc): Should not be necessary.
		avoid TypecheckExpr
		avoid TypecheckStmt
		avoid TypecheckExprs
		avoid TypecheckStmts
		avoid TypecheckAssignExpr
		avoid TypecheckCallee

		var n ir.Node
		var ns []ir.Node
		typecheck(n, ctxExpr) -> TypecheckExpr(n)
		typecheck(n, ctxStmt) -> TypecheckStmt(n)
		typecheckslice(ns, ctxExpr) -> TypecheckExprs(ns)
		typecheckslice(ns, ctxStmt) -> TypecheckStmts(ns)
		typecheck(n, ctxExpr|ctxAssign) -> TypecheckAssignExpr(n)
		typecheck(n, ctxExpr|ctxCallee) -> TypecheckCallee(n)
	}

	# Move some typechecking API to typecheck.
	mv syslook LookupRuntime
	mv substArgTypes SubstArgTypes
	mv LookupRuntime SubstArgTypes syms.go

	mv conv Conv
	mv convnop ConvNop
	mv Conv ConvNop typecheck.go

	mv colasdefn AssignDefn
	mv colasname assignableName

	mv Target target.go

	mv initname autoexport exportsym dcl.go
	mv exportsym Export

	# Export API to be called from outside typecheck.
	# The ones with "Typecheck" prefixes will be renamed later to drop the prefix.
	mv adddot AddImplicitDots
	mv assignconv AssignConv
	mv expandmeth CalcMethods
	mv capturevarscomplete CaptureVarsComplete
	mv checkMapKeys CheckMapKeys
	mv checkreturn CheckReturn
	mv dclcontext DeclContext
	mv dclfunc DeclFunc
	mv declare Declare
	mv dotImportRefs DotImportRefs
	mv declImporter DeclImporter
	mv variter DeclVars
	mv defaultlit DefaultLit
	mv evalConst EvalConst
	mv expandInline ImportBody
	mv finishUniverse declareUniverse
	mv funcbody FinishFuncBody
	mv funchdr StartFuncBody
	mv indexconst IndexConst
	mv initTodo InitTodoFunc
	mv lookup Lookup
	mv resolve Resolve
	mv lookupN LookupNum
	mv nodAddr NodAddr
	mv nodAddrAt NodAddrAt
	mv nodnil NodNil
	mv origBoolConst OrigBool
	mv origConst OrigConst
	mv origIntConst OrigInt
	mv redeclare Redeclared
	mv tostruct NewStructType
	mv functype NewFuncType
	mv methodfunc NewMethodType
	mv structargs NewFuncParams
	mv temp Temp
	mv tempAt TempAt
	mv typecheckok TypecheckAllowed
	mv typecheck _typecheck # make room for typecheck pkg
	mv typecheckinl TypecheckImportedBody
	mv typecheckFunc TypecheckFunc
	mv iimport ReadImports
	mv iexport WriteExports
	mv sysfunc LookupRuntimeFunc
	mv sysvar LookupRuntimeVar

	# Move function constructors to typecheck.
	mv mkdotargslice MakeDotArgs
	mv fixVariadicCall FixVariadicCall
	mv closureType ClosureType
	mv partialCallType PartialCallType
	mv capturevars CaptureVars
	mv MakeDotArgs FixVariadicCall ClosureType PartialCallType CaptureVars typecheckclosure func.go

	mv autolabel AutoLabel
	mv AutoLabel syms.go

	mv Dlist dlist
	mv Symlink symlink

	mv \
		AssignDefn assignableName \
		AssignConv \
		CaptureVarsComplete \
		DeclContext \
		DeclFunc \
		DeclImporter \
		DeclVars \
		Declare \
		DotImportRefs \
		Export \
		InitTodoFunc \
		Lookup \
		LookupNum \
		LookupRuntimeFunc \
		LookupRuntimeVar \
		NewFuncParams \
		NewName \
		NodAddr \
		NodAddrAt \
		NodNil \
		Redeclared \
		StartFuncBody \
		FinishFuncBody \
		TypecheckImportedBody \
		AddImplicitDots \
		CalcMethods \
		CheckFuncStack \
		NewFuncType \
		NewMethodType \
		NewStructType \
		TypecheckAllowed \
		Temp \
		TempAt \
		adddot1 \
		dotlist \
		addmethod \
		assignconvfn \
		assignop \
		autotmpname \
		autoexport \
		bexport.go \
		checkdupfields \
		checkembeddedtype \
		closurename \
		convertop \
		declare_typegen \
		decldepth \
		dlist \
		dotpath \
		expand0 \
		expand1 \
		expandDecl \
		fakeRecvField \
		fnpkg \
		funcStack \
		funcStackEnt \
		funcarg \
		funcarg2 \
		funcargs \
		funcargs2 \
		globClosgen \
		ifacelookdot \
		implements \
		importalias \
		importconst \
		importfunc \
		importobj \
		importsym \
		importtype \
		importvar \
		inimport \
		initname \
		isptrto \
		loadsys \
		lookdot0 \
		lookdot1 \
		makepartialcall \
		okfor \
		okforlen \
		operandType \
		slist \
		symlink \
		tointerface \
		typeSet \
		typeSet.add \
		typeSetEntry \
		typecheckExprSwitch \
		typecheckTypeSwitch \
		typecheckpartialcall \
		typecheckrange \
		typecheckrangeExpr \
		typecheckselect \
		typecheckswitch \
		vargen \
		builtin.go \
		builtin_test.go \
		const.go \
		func.go \
		iexport.go \
		iimport.go \
		mapfile_mmap.go \
		syms.go \
		target.go \
		typecheck.go \
		unsafe.go \
		universe.go \
		cmd/compile/internal/typecheck
'
rm gen.go types.go types_acc.go

sed -i '' 's/package gc/package typecheck/' mapfile_read.go mkbuiltin.go
mv mapfile_read.go ../typecheck # not part of default build
mv mkbuiltin.go ../typecheck # package main helper
mv builtin ../typecheck

cd ../typecheck
mv dcl.go dcl1.go
mv typecheck.go typecheck1.go
mv universe.go universe1.go
rf '
	# Sweep some small files into larger ones.
	# "mv sym... file1.go file.go" (after the mv file1.go file.go above)
	# lets us insert sym... at the top of file.go.
	mv okfor okforeq universe1.go universe.go
	mv DeclContext vargen dcl1.go Temp TempAt autotmpname NewMethodType dcl.go
	mv InitTodoFunc inimport decldepth TypecheckAllowed typecheck1.go typecheck.go
	mv inl.go closure.go func.go
	mv range.go select.go swt.go stmt.go
	mv Lookup loadsys LookupRuntimeFunc LookupRuntimeVar syms.go
	mv unsafe.go const.go

	mv TypecheckAssignExpr AssignExpr
	mv TypecheckExpr Expr
	mv TypecheckStmt Stmt
	mv TypecheckExprs Exprs
	mv TypecheckStmts Stmts
	mv TypecheckCall Call
	mv TypecheckCallee Callee
	mv _typecheck check
	mv TypecheckFunc Func
	mv TypecheckFuncBody FuncBody
	mv TypecheckImports AllImportedBodies
	mv TypecheckImportedBody ImportedBody
	mv TypecheckInit Init
	mv TypecheckPackage Package
'
rm gen.go go.go init.go main.go reflect.go

Change-Id: Iea6a7aaf6407d690670ec58aeb36cc0b280f80b0
Reviewed-on: https://go-review.googlesource.com/c/go/+/279236
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/abiutils_test.go  |   3 +-
 .../compile/internal/gc/abiutilsaux_test.go   |   5 +-
 src/cmd/compile/internal/gc/alg.go            |  93 +-
 src/cmd/compile/internal/gc/bexport.go        | 185 ----
 src/cmd/compile/internal/gc/builtin.go        | 344 -------
 src/cmd/compile/internal/gc/closure.go        | 310 +------
 src/cmd/compile/internal/gc/dcl.go            | 580 +-----------
 src/cmd/compile/internal/gc/embed.go          |   7 +-
 src/cmd/compile/internal/gc/escape.go         |  13 +-
 src/cmd/compile/internal/gc/export.go         | 191 ++--
 src/cmd/compile/internal/gc/gen.go            |  76 --
 src/cmd/compile/internal/gc/go.go             |  25 -
 src/cmd/compile/internal/gc/gsubr.go          |  21 +-
 src/cmd/compile/internal/gc/init.go           |  41 +-
 src/cmd/compile/internal/gc/inl.go            | 110 +--
 src/cmd/compile/internal/gc/main.go           |  61 +-
 src/cmd/compile/internal/gc/noder.go          |  41 +-
 src/cmd/compile/internal/gc/obj.go            |  31 +-
 src/cmd/compile/internal/gc/order.go          |  61 +-
 src/cmd/compile/internal/gc/pgen.go           |   7 +-
 src/cmd/compile/internal/gc/pgen_test.go      |   5 +-
 src/cmd/compile/internal/gc/range.go          | 198 +---
 src/cmd/compile/internal/gc/reflect.go        |  53 +-
 src/cmd/compile/internal/gc/select.go         | 144 +--
 src/cmd/compile/internal/gc/sinit.go          |  45 +-
 src/cmd/compile/internal/gc/ssa.go            | 275 +++---
 src/cmd/compile/internal/gc/subr.go           | 866 +-----------------
 src/cmd/compile/internal/gc/swt.go            | 244 +----
 src/cmd/compile/internal/gc/types_acc.go      |   8 -
 src/cmd/compile/internal/gc/unsafe.go         |  90 --
 src/cmd/compile/internal/gc/walk.go           | 543 +++++------
 src/cmd/compile/internal/typecheck/bexport.go | 102 +++
 src/cmd/compile/internal/typecheck/builtin.go | 344 +++++++
 .../{gc => typecheck}/builtin/runtime.go      |   0
 .../{gc => typecheck}/builtin_test.go         |   2 +-
 .../internal/{gc => typecheck}/const.go       | 150 ++-
 src/cmd/compile/internal/typecheck/dcl.go     | 705 ++++++++++++++
 src/cmd/compile/internal/typecheck/export.go  |  79 ++
 src/cmd/compile/internal/typecheck/func.go    | 398 ++++++++
 .../internal/{gc => typecheck}/iexport.go     |  17 +-
 .../internal/{gc => typecheck}/iimport.go     |  47 +-
 .../{gc => typecheck}/mapfile_mmap.go         |   2 +-
 .../{gc => typecheck}/mapfile_read.go         |   2 +-
 .../internal/{gc => typecheck}/mkbuiltin.go   |   2 +-
 src/cmd/compile/internal/typecheck/stmt.go    | 435 +++++++++
 src/cmd/compile/internal/typecheck/subr.go    | 793 ++++++++++++++++
 src/cmd/compile/internal/typecheck/syms.go    | 104 +++
 .../{gc/types.go => typecheck/target.go}      |   9 +-
 .../internal/{gc => typecheck}/typecheck.go   | 437 +++++----
 .../internal/{gc => typecheck}/universe.go    |  37 +-
 50 files changed, 4208 insertions(+), 4133 deletions(-)
 delete mode 100644 src/cmd/compile/internal/gc/bexport.go
 delete mode 100644 src/cmd/compile/internal/gc/builtin.go
 delete mode 100644 src/cmd/compile/internal/gc/gen.go
 delete mode 100644 src/cmd/compile/internal/gc/types_acc.go
 delete mode 100644 src/cmd/compile/internal/gc/unsafe.go
 create mode 100644 src/cmd/compile/internal/typecheck/bexport.go
 create mode 100644 src/cmd/compile/internal/typecheck/builtin.go
 rename src/cmd/compile/internal/{gc => typecheck}/builtin/runtime.go (100%)
 rename src/cmd/compile/internal/{gc => typecheck}/builtin_test.go (97%)
 rename src/cmd/compile/internal/{gc => typecheck}/const.go (85%)
 create mode 100644 src/cmd/compile/internal/typecheck/dcl.go
 create mode 100644 src/cmd/compile/internal/typecheck/export.go
 create mode 100644 src/cmd/compile/internal/typecheck/func.go
 rename src/cmd/compile/internal/{gc => typecheck}/iexport.go (99%)
 rename src/cmd/compile/internal/{gc => typecheck}/iimport.go (97%)
 rename src/cmd/compile/internal/{gc => typecheck}/mapfile_mmap.go (98%)
 rename src/cmd/compile/internal/{gc => typecheck}/mapfile_read.go (96%)
 rename src/cmd/compile/internal/{gc => typecheck}/mkbuiltin.go (99%)
 create mode 100644 src/cmd/compile/internal/typecheck/stmt.go
 create mode 100644 src/cmd/compile/internal/typecheck/subr.go
 create mode 100644 src/cmd/compile/internal/typecheck/syms.go
 rename src/cmd/compile/internal/{gc/types.go => typecheck/target.go} (51%)
 rename src/cmd/compile/internal/{gc => typecheck}/typecheck.go (92%)
 rename src/cmd/compile/internal/{gc => typecheck}/universe.go (93%)

diff --git a/src/cmd/compile/internal/gc/abiutils_test.go b/src/cmd/compile/internal/gc/abiutils_test.go
index 5a88332de8..fe9a838688 100644
--- a/src/cmd/compile/internal/gc/abiutils_test.go
+++ b/src/cmd/compile/internal/gc/abiutils_test.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"bufio"
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/x86"
@@ -42,7 +43,7 @@ func TestMain(m *testing.M) {
 	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
 		return typenamesym(t).Linksym()
 	}
-	TypecheckInit()
+	typecheck.Init()
 	os.Exit(m.Run())
 }
 
diff --git a/src/cmd/compile/internal/gc/abiutilsaux_test.go b/src/cmd/compile/internal/gc/abiutilsaux_test.go
index 8585ab9a30..e6590beac0 100644
--- a/src/cmd/compile/internal/gc/abiutilsaux_test.go
+++ b/src/cmd/compile/internal/gc/abiutilsaux_test.go
@@ -9,6 +9,7 @@ package gc
 
 import (
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"fmt"
@@ -19,7 +20,7 @@ import (
 
 func mkParamResultField(t *types.Type, s *types.Sym, which ir.Class) *types.Field {
 	field := types.NewField(src.NoXPos, s, t)
-	n := NewName(s)
+	n := typecheck.NewName(s)
 	n.Class_ = which
 	field.Nname = n
 	n.SetType(t)
@@ -42,7 +43,7 @@ func mkstruct(fieldtypes []*types.Type) *types.Type {
 }
 
 func mkFuncType(rcvr *types.Type, ins []*types.Type, outs []*types.Type) *types.Type {
-	q := lookup("?")
+	q := typecheck.Lookup("?")
 	inf := []*types.Field{}
 	for _, it := range ins {
 		inf = append(inf, mkParamResultField(it, q, ir.PPARAM))
diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index dab27b4929..b0d46eab2f 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"fmt"
@@ -106,7 +107,7 @@ func genhash(t *types.Type) *obj.LSym {
 			return closure
 		}
 		if memhashvarlen == nil {
-			memhashvarlen = sysfunc("memhash_varlen")
+			memhashvarlen = typecheck.LookupRuntimeFunc("memhash_varlen")
 		}
 		ot := 0
 		ot = dsymptr(closure, ot, memhashvarlen, 0)
@@ -143,17 +144,17 @@ func genhash(t *types.Type) *obj.LSym {
 	}
 
 	base.Pos = base.AutogeneratedPos // less confusing than end of input
-	dclcontext = ir.PEXTERN
+	typecheck.DeclContext = ir.PEXTERN
 
 	// func sym(p *T, h uintptr) uintptr
 	args := []*ir.Field{
-		ir.NewField(base.Pos, lookup("p"), nil, types.NewPtr(t)),
-		ir.NewField(base.Pos, lookup("h"), nil, types.Types[types.TUINTPTR]),
+		ir.NewField(base.Pos, typecheck.Lookup("p"), nil, types.NewPtr(t)),
+		ir.NewField(base.Pos, typecheck.Lookup("h"), nil, types.Types[types.TUINTPTR]),
 	}
 	results := []*ir.Field{ir.NewField(base.Pos, nil, nil, types.Types[types.TUINTPTR])}
 	tfn := ir.NewFuncType(base.Pos, nil, args, results)
 
-	fn := dclfunc(sym, tfn)
+	fn := typecheck.DeclFunc(sym, tfn)
 	np := ir.AsNode(tfn.Type().Params().Field(0).Nname)
 	nh := ir.AsNode(tfn.Type().Params().Field(1).Nname)
 
@@ -165,7 +166,7 @@ func genhash(t *types.Type) *obj.LSym {
 		hashel := hashfor(t.Elem())
 
 		// for i := 0; i < nelem; i++
-		ni := temp(types.Types[types.TINT])
+		ni := typecheck.Temp(types.Types[types.TINT])
 		init := ir.NewAssignStmt(base.Pos, ni, ir.NewInt(0))
 		cond := ir.NewBinaryExpr(base.Pos, ir.OLT, ni, ir.NewInt(t.NumElem()))
 		post := ir.NewAssignStmt(base.Pos, ni, ir.NewBinaryExpr(base.Pos, ir.OADD, ni, ir.NewInt(1)))
@@ -177,7 +178,7 @@ func genhash(t *types.Type) *obj.LSym {
 
 		nx := ir.NewIndexExpr(base.Pos, np, ni)
 		nx.SetBounded(true)
-		na := nodAddr(nx)
+		na := typecheck.NodAddr(nx)
 		call.Args.Append(na)
 		call.Args.Append(nh)
 		loop.Body.Append(ir.NewAssignStmt(base.Pos, nh, call))
@@ -201,7 +202,7 @@ func genhash(t *types.Type) *obj.LSym {
 				hashel := hashfor(f.Type)
 				call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil)
 				nx := ir.NewSelectorExpr(base.Pos, ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
-				na := nodAddr(nx)
+				na := typecheck.NodAddr(nx)
 				call.Args.Append(na)
 				call.Args.Append(nh)
 				fn.Body.Append(ir.NewAssignStmt(base.Pos, nh, call))
@@ -216,7 +217,7 @@ func genhash(t *types.Type) *obj.LSym {
 			hashel := hashmem(f.Type)
 			call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil)
 			nx := ir.NewSelectorExpr(base.Pos, ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
-			na := nodAddr(nx)
+			na := typecheck.NodAddr(nx)
 			call.Args.Append(na)
 			call.Args.Append(nh)
 			call.Args.Append(ir.NewInt(size))
@@ -234,13 +235,13 @@ func genhash(t *types.Type) *obj.LSym {
 		ir.DumpList("genhash body", fn.Body)
 	}
 
-	funcbody()
+	typecheck.FinishFuncBody()
 
 	fn.SetDupok(true)
-	typecheckFunc(fn)
+	typecheck.Func(fn)
 
 	ir.CurFunc = fn
-	typecheckslice(fn.Body, ctxStmt)
+	typecheck.Stmts(fn.Body)
 	ir.CurFunc = nil
 
 	if base.Debug.DclStack != 0 {
@@ -248,7 +249,7 @@ func genhash(t *types.Type) *obj.LSym {
 	}
 
 	fn.SetNilCheckDisabled(true)
-	Target.Decls = append(Target.Decls, fn)
+	typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
 
 	// Build closure. It doesn't close over any variables, so
 	// it contains just the function pointer.
@@ -284,9 +285,9 @@ func hashfor(t *types.Type) ir.Node {
 		sym = typesymprefix(".hash", t)
 	}
 
-	n := NewName(sym)
+	n := typecheck.NewName(sym)
 	ir.MarkFunc(n)
-	n.SetType(functype(nil, []*ir.Field{
+	n.SetType(typecheck.NewFuncType(nil, []*ir.Field{
 		ir.NewField(base.Pos, nil, nil, types.NewPtr(t)),
 		ir.NewField(base.Pos, nil, nil, types.Types[types.TUINTPTR]),
 	}, []*ir.Field{
@@ -298,9 +299,9 @@ func hashfor(t *types.Type) ir.Node {
 // sysClosure returns a closure which will call the
 // given runtime function (with no closed-over variables).
 func sysClosure(name string) *obj.LSym {
-	s := sysvar(name + "·f")
+	s := typecheck.LookupRuntimeVar(name + "·f")
 	if len(s.P) == 0 {
-		f := sysfunc(name)
+		f := typecheck.LookupRuntimeFunc(name)
 		dsymptr(s, 0, f, 0)
 		ggloblsym(s, int32(types.PtrSize), obj.DUPOK|obj.RODATA)
 	}
@@ -349,7 +350,7 @@ func geneq(t *types.Type) *obj.LSym {
 			return closure
 		}
 		if memequalvarlen == nil {
-			memequalvarlen = sysvar("memequal_varlen") // asm func
+			memequalvarlen = typecheck.LookupRuntimeVar("memequal_varlen") // asm func
 		}
 		ot := 0
 		ot = dsymptr(closure, ot, memequalvarlen, 0)
@@ -372,20 +373,20 @@ func geneq(t *types.Type) *obj.LSym {
 	// Autogenerate code for equality of structs and arrays.
 
 	base.Pos = base.AutogeneratedPos // less confusing than end of input
-	dclcontext = ir.PEXTERN
+	typecheck.DeclContext = ir.PEXTERN
 
 	// func sym(p, q *T) bool
 	tfn := ir.NewFuncType(base.Pos, nil,
-		[]*ir.Field{ir.NewField(base.Pos, lookup("p"), nil, types.NewPtr(t)), ir.NewField(base.Pos, lookup("q"), nil, types.NewPtr(t))},
-		[]*ir.Field{ir.NewField(base.Pos, lookup("r"), nil, types.Types[types.TBOOL])})
+		[]*ir.Field{ir.NewField(base.Pos, typecheck.Lookup("p"), nil, types.NewPtr(t)), ir.NewField(base.Pos, typecheck.Lookup("q"), nil, types.NewPtr(t))},
+		[]*ir.Field{ir.NewField(base.Pos, typecheck.Lookup("r"), nil, types.Types[types.TBOOL])})
 
-	fn := dclfunc(sym, tfn)
+	fn := typecheck.DeclFunc(sym, tfn)
 	np := ir.AsNode(tfn.Type().Params().Field(0).Nname)
 	nq := ir.AsNode(tfn.Type().Params().Field(1).Nname)
 	nr := ir.AsNode(tfn.Type().Results().Field(0).Nname)
 
 	// Label to jump to if an equality test fails.
-	neq := autolabel(".neq")
+	neq := typecheck.AutoLabel(".neq")
 
 	// We reach here only for types that have equality but
 	// cannot be handled by the standard algorithms,
@@ -450,7 +451,7 @@ func geneq(t *types.Type) *obj.LSym {
 			} else {
 				// Generate a for loop.
 				// for i := 0; i < nelem; i++
-				i := temp(types.Types[types.TINT])
+				i := typecheck.Temp(types.Types[types.TINT])
 				init := ir.NewAssignStmt(base.Pos, i, ir.NewInt(0))
 				cond := ir.NewBinaryExpr(base.Pos, ir.OLT, i, ir.NewInt(nelem))
 				post := ir.NewAssignStmt(base.Pos, i, ir.NewBinaryExpr(base.Pos, ir.OADD, i, ir.NewInt(1)))
@@ -586,7 +587,7 @@ func geneq(t *types.Type) *obj.LSym {
 
 	// ret:
 	//   return
-	ret := autolabel(".ret")
+	ret := typecheck.AutoLabel(".ret")
 	fn.Body.Append(ir.NewLabelStmt(base.Pos, ret))
 	fn.Body.Append(ir.NewReturnStmt(base.Pos, nil))
 
@@ -610,13 +611,13 @@ func geneq(t *types.Type) *obj.LSym {
 		ir.DumpList("geneq body", fn.Body)
 	}
 
-	funcbody()
+	typecheck.FinishFuncBody()
 
 	fn.SetDupok(true)
-	typecheckFunc(fn)
+	typecheck.Func(fn)
 
 	ir.CurFunc = fn
-	typecheckslice(fn.Body, ctxStmt)
+	typecheck.Stmts(fn.Body)
 	ir.CurFunc = nil
 
 	if base.Debug.DclStack != 0 {
@@ -628,7 +629,7 @@ func geneq(t *types.Type) *obj.LSym {
 	// neither of which can be nil, and our comparisons
 	// are shallow.
 	fn.SetNilCheckDisabled(true)
-	Target.Decls = append(Target.Decls, fn)
+	typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
 
 	// Generate a closure which points at the function we just generated.
 	dsymptr(closure, 0, sym.Linksym(), 0)
@@ -660,20 +661,20 @@ func eqfield(p ir.Node, q ir.Node, field *types.Sym) ir.Node {
 // which can be used to construct string equality comparison.
 // eqlen must be evaluated before eqmem, and shortcircuiting is required.
 func eqstring(s, t ir.Node) (eqlen *ir.BinaryExpr, eqmem *ir.CallExpr) {
-	s = conv(s, types.Types[types.TSTRING])
-	t = conv(t, types.Types[types.TSTRING])
+	s = typecheck.Conv(s, types.Types[types.TSTRING])
+	t = typecheck.Conv(t, types.Types[types.TSTRING])
 	sptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, s)
 	tptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, t)
-	slen := conv(ir.NewUnaryExpr(base.Pos, ir.OLEN, s), types.Types[types.TUINTPTR])
-	tlen := conv(ir.NewUnaryExpr(base.Pos, ir.OLEN, t), types.Types[types.TUINTPTR])
+	slen := typecheck.Conv(ir.NewUnaryExpr(base.Pos, ir.OLEN, s), types.Types[types.TUINTPTR])
+	tlen := typecheck.Conv(ir.NewUnaryExpr(base.Pos, ir.OLEN, t), types.Types[types.TUINTPTR])
 
-	fn := syslook("memequal")
-	fn = substArgTypes(fn, types.Types[types.TUINT8], types.Types[types.TUINT8])
+	fn := typecheck.LookupRuntime("memequal")
+	fn = typecheck.SubstArgTypes(fn, types.Types[types.TUINT8], types.Types[types.TUINT8])
 	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, []ir.Node{sptr, tptr, ir.Copy(slen)})
-	TypecheckCall(call)
+	typecheck.Call(call)
 
 	cmp := ir.NewBinaryExpr(base.Pos, ir.OEQ, slen, tlen)
-	cmp = typecheck(cmp, ctxExpr).(*ir.BinaryExpr)
+	cmp = typecheck.Expr(cmp).(*ir.BinaryExpr)
 	cmp.SetType(types.Types[types.TBOOL])
 	return cmp, call
 }
@@ -692,9 +693,9 @@ func eqinterface(s, t ir.Node) (eqtab *ir.BinaryExpr, eqdata *ir.CallExpr) {
 	// func efaceeq(typ *uintptr, x, y unsafe.Pointer) (ret bool)
 	var fn ir.Node
 	if s.Type().IsEmptyInterface() {
-		fn = syslook("efaceeq")
+		fn = typecheck.LookupRuntime("efaceeq")
 	} else {
-		fn = syslook("ifaceeq")
+		fn = typecheck.LookupRuntime("ifaceeq")
 	}
 
 	stab := ir.NewUnaryExpr(base.Pos, ir.OITAB, s)
@@ -707,10 +708,10 @@ func eqinterface(s, t ir.Node) (eqtab *ir.BinaryExpr, eqdata *ir.CallExpr) {
 	tdata.SetTypecheck(1)
 
 	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, []ir.Node{stab, sdata, tdata})
-	TypecheckCall(call)
+	typecheck.Call(call)
 
 	cmp := ir.NewBinaryExpr(base.Pos, ir.OEQ, stab, ttab)
-	cmp = typecheck(cmp, ctxExpr).(*ir.BinaryExpr)
+	cmp = typecheck.Expr(cmp).(*ir.BinaryExpr)
 	cmp.SetType(types.Types[types.TBOOL])
 	return cmp, call
 }
@@ -718,8 +719,8 @@ func eqinterface(s, t ir.Node) (eqtab *ir.BinaryExpr, eqdata *ir.CallExpr) {
 // eqmem returns the node
 // 	memequal(&p.field, &q.field [, size])
 func eqmem(p ir.Node, q ir.Node, field *types.Sym, size int64) ir.Node {
-	nx := typecheck(nodAddr(ir.NewSelectorExpr(base.Pos, ir.OXDOT, p, field)), ctxExpr)
-	ny := typecheck(nodAddr(ir.NewSelectorExpr(base.Pos, ir.OXDOT, q, field)), ctxExpr)
+	nx := typecheck.Expr(typecheck.NodAddr(ir.NewSelectorExpr(base.Pos, ir.OXDOT, p, field)))
+	ny := typecheck.Expr(typecheck.NodAddr(ir.NewSelectorExpr(base.Pos, ir.OXDOT, q, field)))
 
 	fn, needsize := eqmemfunc(size, nx.Type().Elem())
 	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
@@ -735,14 +736,14 @@ func eqmem(p ir.Node, q ir.Node, field *types.Sym, size int64) ir.Node {
 func eqmemfunc(size int64, t *types.Type) (fn *ir.Name, needsize bool) {
 	switch size {
 	default:
-		fn = syslook("memequal")
+		fn = typecheck.LookupRuntime("memequal")
 		needsize = true
 	case 1, 2, 4, 8, 16:
 		buf := fmt.Sprintf("memequal%d", int(size)*8)
-		fn = syslook(buf)
+		fn = typecheck.LookupRuntime(buf)
 	}
 
-	fn = substArgTypes(fn, t, t)
+	fn = typecheck.SubstArgTypes(fn, t, t)
 	return fn, needsize
 }
 
diff --git a/src/cmd/compile/internal/gc/bexport.go b/src/cmd/compile/internal/gc/bexport.go
deleted file mode 100644
index 3c377d8ba3..0000000000
--- a/src/cmd/compile/internal/gc/bexport.go
+++ /dev/null
@@ -1,185 +0,0 @@
-// Copyright 2015 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 gc
-
-import (
-	"cmd/compile/internal/ir"
-	"cmd/compile/internal/types"
-)
-
-type exporter struct {
-	marked map[*types.Type]bool // types already seen by markType
-}
-
-// markObject visits a reachable object.
-func (p *exporter) markObject(n ir.Node) {
-	if n.Op() == ir.ONAME {
-		n := n.(*ir.Name)
-		if n.Class_ == ir.PFUNC {
-			inlFlood(n, exportsym)
-		}
-	}
-
-	p.markType(n.Type())
-}
-
-// markType recursively visits types reachable from t to identify
-// functions whose inline bodies may be needed.
-func (p *exporter) markType(t *types.Type) {
-	if p.marked[t] {
-		return
-	}
-	p.marked[t] = true
-
-	// If this is a named type, mark all of its associated
-	// methods. Skip interface types because t.Methods contains
-	// only their unexpanded method set (i.e., exclusive of
-	// interface embeddings), and the switch statement below
-	// handles their full method set.
-	if t.Sym() != nil && t.Kind() != types.TINTER {
-		for _, m := range t.Methods().Slice() {
-			if types.IsExported(m.Sym.Name) {
-				p.markObject(ir.AsNode(m.Nname))
-			}
-		}
-	}
-
-	// Recursively mark any types that can be produced given a
-	// value of type t: dereferencing a pointer; indexing or
-	// iterating over an array, slice, or map; receiving from a
-	// channel; accessing a struct field or interface method; or
-	// calling a function.
-	//
-	// Notably, we don't mark function parameter types, because
-	// the user already needs some way to construct values of
-	// those types.
-	switch t.Kind() {
-	case types.TPTR, types.TARRAY, types.TSLICE:
-		p.markType(t.Elem())
-
-	case types.TCHAN:
-		if t.ChanDir().CanRecv() {
-			p.markType(t.Elem())
-		}
-
-	case types.TMAP:
-		p.markType(t.Key())
-		p.markType(t.Elem())
-
-	case types.TSTRUCT:
-		for _, f := range t.FieldSlice() {
-			if types.IsExported(f.Sym.Name) || f.Embedded != 0 {
-				p.markType(f.Type)
-			}
-		}
-
-	case types.TFUNC:
-		for _, f := range t.Results().FieldSlice() {
-			p.markType(f.Type)
-		}
-
-	case types.TINTER:
-		for _, f := range t.FieldSlice() {
-			if types.IsExported(f.Sym.Name) {
-				p.markType(f.Type)
-			}
-		}
-	}
-}
-
-// ----------------------------------------------------------------------------
-// Export format
-
-// Tags. Must be < 0.
-const (
-	// Objects
-	packageTag = -(iota + 1)
-	constTag
-	typeTag
-	varTag
-	funcTag
-	endTag
-
-	// Types
-	namedTag
-	arrayTag
-	sliceTag
-	dddTag
-	structTag
-	pointerTag
-	signatureTag
-	interfaceTag
-	mapTag
-	chanTag
-
-	// Values
-	falseTag
-	trueTag
-	int64Tag
-	floatTag
-	fractionTag // not used by gc
-	complexTag
-	stringTag
-	nilTag
-	unknownTag // not used by gc (only appears in packages with errors)
-
-	// Type aliases
-	aliasTag
-)
-
-var predecl []*types.Type // initialized lazily
-
-func predeclared() []*types.Type {
-	if predecl == nil {
-		// initialize lazily to be sure that all
-		// elements have been initialized before
-		predecl = []*types.Type{
-			// basic types
-			types.Types[types.TBOOL],
-			types.Types[types.TINT],
-			types.Types[types.TINT8],
-			types.Types[types.TINT16],
-			types.Types[types.TINT32],
-			types.Types[types.TINT64],
-			types.Types[types.TUINT],
-			types.Types[types.TUINT8],
-			types.Types[types.TUINT16],
-			types.Types[types.TUINT32],
-			types.Types[types.TUINT64],
-			types.Types[types.TUINTPTR],
-			types.Types[types.TFLOAT32],
-			types.Types[types.TFLOAT64],
-			types.Types[types.TCOMPLEX64],
-			types.Types[types.TCOMPLEX128],
-			types.Types[types.TSTRING],
-
-			// basic type aliases
-			types.ByteType,
-			types.RuneType,
-
-			// error
-			types.ErrorType,
-
-			// untyped types
-			types.UntypedBool,
-			types.UntypedInt,
-			types.UntypedRune,
-			types.UntypedFloat,
-			types.UntypedComplex,
-			types.UntypedString,
-			types.Types[types.TNIL],
-
-			// package unsafe
-			types.Types[types.TUNSAFEPTR],
-
-			// invalid type (package contains errors)
-			types.Types[types.Txxx],
-
-			// any type, for builtin export data
-			types.Types[types.TANY],
-		}
-	}
-	return predecl
-}
diff --git a/src/cmd/compile/internal/gc/builtin.go b/src/cmd/compile/internal/gc/builtin.go
deleted file mode 100644
index 12c70fb6d4..0000000000
--- a/src/cmd/compile/internal/gc/builtin.go
+++ /dev/null
@@ -1,344 +0,0 @@
-// Code generated by mkbuiltin.go. DO NOT EDIT.
-
-package gc
-
-import (
-	"cmd/compile/internal/base"
-	"cmd/compile/internal/ir"
-	"cmd/compile/internal/types"
-)
-
-var runtimeDecls = [...]struct {
-	name string
-	tag  int
-	typ  int
-}{
-	{"newobject", funcTag, 4},
-	{"mallocgc", funcTag, 8},
-	{"panicdivide", funcTag, 9},
-	{"panicshift", funcTag, 9},
-	{"panicmakeslicelen", funcTag, 9},
-	{"panicmakeslicecap", funcTag, 9},
-	{"throwinit", funcTag, 9},
-	{"panicwrap", funcTag, 9},
-	{"gopanic", funcTag, 11},
-	{"gorecover", funcTag, 14},
-	{"goschedguarded", funcTag, 9},
-	{"goPanicIndex", funcTag, 16},
-	{"goPanicIndexU", funcTag, 18},
-	{"goPanicSliceAlen", funcTag, 16},
-	{"goPanicSliceAlenU", funcTag, 18},
-	{"goPanicSliceAcap", funcTag, 16},
-	{"goPanicSliceAcapU", funcTag, 18},
-	{"goPanicSliceB", funcTag, 16},
-	{"goPanicSliceBU", funcTag, 18},
-	{"goPanicSlice3Alen", funcTag, 16},
-	{"goPanicSlice3AlenU", funcTag, 18},
-	{"goPanicSlice3Acap", funcTag, 16},
-	{"goPanicSlice3AcapU", funcTag, 18},
-	{"goPanicSlice3B", funcTag, 16},
-	{"goPanicSlice3BU", funcTag, 18},
-	{"goPanicSlice3C", funcTag, 16},
-	{"goPanicSlice3CU", funcTag, 18},
-	{"printbool", funcTag, 19},
-	{"printfloat", funcTag, 21},
-	{"printint", funcTag, 23},
-	{"printhex", funcTag, 25},
-	{"printuint", funcTag, 25},
-	{"printcomplex", funcTag, 27},
-	{"printstring", funcTag, 29},
-	{"printpointer", funcTag, 30},
-	{"printuintptr", funcTag, 31},
-	{"printiface", funcTag, 30},
-	{"printeface", funcTag, 30},
-	{"printslice", funcTag, 30},
-	{"printnl", funcTag, 9},
-	{"printsp", funcTag, 9},
-	{"printlock", funcTag, 9},
-	{"printunlock", funcTag, 9},
-	{"concatstring2", funcTag, 34},
-	{"concatstring3", funcTag, 35},
-	{"concatstring4", funcTag, 36},
-	{"concatstring5", funcTag, 37},
-	{"concatstrings", funcTag, 39},
-	{"cmpstring", funcTag, 40},
-	{"intstring", funcTag, 43},
-	{"slicebytetostring", funcTag, 44},
-	{"slicebytetostringtmp", funcTag, 45},
-	{"slicerunetostring", funcTag, 48},
-	{"stringtoslicebyte", funcTag, 50},
-	{"stringtoslicerune", funcTag, 53},
-	{"slicecopy", funcTag, 54},
-	{"decoderune", funcTag, 55},
-	{"countrunes", funcTag, 56},
-	{"convI2I", funcTag, 57},
-	{"convT16", funcTag, 58},
-	{"convT32", funcTag, 58},
-	{"convT64", funcTag, 58},
-	{"convTstring", funcTag, 58},
-	{"convTslice", funcTag, 58},
-	{"convT2E", funcTag, 59},
-	{"convT2Enoptr", funcTag, 59},
-	{"convT2I", funcTag, 59},
-	{"convT2Inoptr", funcTag, 59},
-	{"assertE2I", funcTag, 57},
-	{"assertE2I2", funcTag, 60},
-	{"assertI2I", funcTag, 57},
-	{"assertI2I2", funcTag, 60},
-	{"panicdottypeE", funcTag, 61},
-	{"panicdottypeI", funcTag, 61},
-	{"panicnildottype", funcTag, 62},
-	{"ifaceeq", funcTag, 64},
-	{"efaceeq", funcTag, 64},
-	{"fastrand", funcTag, 66},
-	{"makemap64", funcTag, 68},
-	{"makemap", funcTag, 69},
-	{"makemap_small", funcTag, 70},
-	{"mapaccess1", funcTag, 71},
-	{"mapaccess1_fast32", funcTag, 72},
-	{"mapaccess1_fast64", funcTag, 72},
-	{"mapaccess1_faststr", funcTag, 72},
-	{"mapaccess1_fat", funcTag, 73},
-	{"mapaccess2", funcTag, 74},
-	{"mapaccess2_fast32", funcTag, 75},
-	{"mapaccess2_fast64", funcTag, 75},
-	{"mapaccess2_faststr", funcTag, 75},
-	{"mapaccess2_fat", funcTag, 76},
-	{"mapassign", funcTag, 71},
-	{"mapassign_fast32", funcTag, 72},
-	{"mapassign_fast32ptr", funcTag, 72},
-	{"mapassign_fast64", funcTag, 72},
-	{"mapassign_fast64ptr", funcTag, 72},
-	{"mapassign_faststr", funcTag, 72},
-	{"mapiterinit", funcTag, 77},
-	{"mapdelete", funcTag, 77},
-	{"mapdelete_fast32", funcTag, 78},
-	{"mapdelete_fast64", funcTag, 78},
-	{"mapdelete_faststr", funcTag, 78},
-	{"mapiternext", funcTag, 79},
-	{"mapclear", funcTag, 80},
-	{"makechan64", funcTag, 82},
-	{"makechan", funcTag, 83},
-	{"chanrecv1", funcTag, 85},
-	{"chanrecv2", funcTag, 86},
-	{"chansend1", funcTag, 88},
-	{"closechan", funcTag, 30},
-	{"writeBarrier", varTag, 90},
-	{"typedmemmove", funcTag, 91},
-	{"typedmemclr", funcTag, 92},
-	{"typedslicecopy", funcTag, 93},
-	{"selectnbsend", funcTag, 94},
-	{"selectnbrecv", funcTag, 95},
-	{"selectnbrecv2", funcTag, 97},
-	{"selectsetpc", funcTag, 98},
-	{"selectgo", funcTag, 99},
-	{"block", funcTag, 9},
-	{"makeslice", funcTag, 100},
-	{"makeslice64", funcTag, 101},
-	{"makeslicecopy", funcTag, 102},
-	{"growslice", funcTag, 104},
-	{"memmove", funcTag, 105},
-	{"memclrNoHeapPointers", funcTag, 106},
-	{"memclrHasPointers", funcTag, 106},
-	{"memequal", funcTag, 107},
-	{"memequal0", funcTag, 108},
-	{"memequal8", funcTag, 108},
-	{"memequal16", funcTag, 108},
-	{"memequal32", funcTag, 108},
-	{"memequal64", funcTag, 108},
-	{"memequal128", funcTag, 108},
-	{"f32equal", funcTag, 109},
-	{"f64equal", funcTag, 109},
-	{"c64equal", funcTag, 109},
-	{"c128equal", funcTag, 109},
-	{"strequal", funcTag, 109},
-	{"interequal", funcTag, 109},
-	{"nilinterequal", funcTag, 109},
-	{"memhash", funcTag, 110},
-	{"memhash0", funcTag, 111},
-	{"memhash8", funcTag, 111},
-	{"memhash16", funcTag, 111},
-	{"memhash32", funcTag, 111},
-	{"memhash64", funcTag, 111},
-	{"memhash128", funcTag, 111},
-	{"f32hash", funcTag, 111},
-	{"f64hash", funcTag, 111},
-	{"c64hash", funcTag, 111},
-	{"c128hash", funcTag, 111},
-	{"strhash", funcTag, 111},
-	{"interhash", funcTag, 111},
-	{"nilinterhash", funcTag, 111},
-	{"int64div", funcTag, 112},
-	{"uint64div", funcTag, 113},
-	{"int64mod", funcTag, 112},
-	{"uint64mod", funcTag, 113},
-	{"float64toint64", funcTag, 114},
-	{"float64touint64", funcTag, 115},
-	{"float64touint32", funcTag, 116},
-	{"int64tofloat64", funcTag, 117},
-	{"uint64tofloat64", funcTag, 118},
-	{"uint32tofloat64", funcTag, 119},
-	{"complex128div", funcTag, 120},
-	{"racefuncenter", funcTag, 31},
-	{"racefuncenterfp", funcTag, 9},
-	{"racefuncexit", funcTag, 9},
-	{"raceread", funcTag, 31},
-	{"racewrite", funcTag, 31},
-	{"racereadrange", funcTag, 121},
-	{"racewriterange", funcTag, 121},
-	{"msanread", funcTag, 121},
-	{"msanwrite", funcTag, 121},
-	{"msanmove", funcTag, 122},
-	{"checkptrAlignment", funcTag, 123},
-	{"checkptrArithmetic", funcTag, 125},
-	{"libfuzzerTraceCmp1", funcTag, 127},
-	{"libfuzzerTraceCmp2", funcTag, 129},
-	{"libfuzzerTraceCmp4", funcTag, 130},
-	{"libfuzzerTraceCmp8", funcTag, 131},
-	{"libfuzzerTraceConstCmp1", funcTag, 127},
-	{"libfuzzerTraceConstCmp2", funcTag, 129},
-	{"libfuzzerTraceConstCmp4", funcTag, 130},
-	{"libfuzzerTraceConstCmp8", funcTag, 131},
-	{"x86HasPOPCNT", varTag, 6},
-	{"x86HasSSE41", varTag, 6},
-	{"x86HasFMA", varTag, 6},
-	{"armHasVFPv4", varTag, 6},
-	{"arm64HasATOMICS", varTag, 6},
-}
-
-func runtimeTypes() []*types.Type {
-	var typs [132]*types.Type
-	typs[0] = types.ByteType
-	typs[1] = types.NewPtr(typs[0])
-	typs[2] = types.Types[types.TANY]
-	typs[3] = types.NewPtr(typs[2])
-	typs[4] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3])})
-	typs[5] = types.Types[types.TUINTPTR]
-	typs[6] = types.Types[types.TBOOL]
-	typs[7] = types.Types[types.TUNSAFEPTR]
-	typs[8] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[5]), ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[6])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7])})
-	typs[9] = functype(nil, nil, nil)
-	typs[10] = types.Types[types.TINTER]
-	typs[11] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[10])}, nil)
-	typs[12] = types.Types[types.TINT32]
-	typs[13] = types.NewPtr(typs[12])
-	typs[14] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[13])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[10])})
-	typs[15] = types.Types[types.TINT]
-	typs[16] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[15])}, nil)
-	typs[17] = types.Types[types.TUINT]
-	typs[18] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[17]), ir.NewField(base.Pos, nil, nil, typs[15])}, nil)
-	typs[19] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])}, nil)
-	typs[20] = types.Types[types.TFLOAT64]
-	typs[21] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])}, nil)
-	typs[22] = types.Types[types.TINT64]
-	typs[23] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[22])}, nil)
-	typs[24] = types.Types[types.TUINT64]
-	typs[25] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[24])}, nil)
-	typs[26] = types.Types[types.TCOMPLEX128]
-	typs[27] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[26])}, nil)
-	typs[28] = types.Types[types.TSTRING]
-	typs[29] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])}, nil)
-	typs[30] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[2])}, nil)
-	typs[31] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[5])}, nil)
-	typs[32] = types.NewArray(typs[0], 32)
-	typs[33] = types.NewPtr(typs[32])
-	typs[34] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
-	typs[35] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
-	typs[36] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
-	typs[37] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
-	typs[38] = types.NewSlice(typs[28])
-	typs[39] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[38])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
-	typs[40] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[15])})
-	typs[41] = types.NewArray(typs[0], 4)
-	typs[42] = types.NewPtr(typs[41])
-	typs[43] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[42]), ir.NewField(base.Pos, nil, nil, typs[22])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
-	typs[44] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
-	typs[45] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
-	typs[46] = types.RuneType
-	typs[47] = types.NewSlice(typs[46])
-	typs[48] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[47])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
-	typs[49] = types.NewSlice(typs[0])
-	typs[50] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[49])})
-	typs[51] = types.NewArray(typs[46], 32)
-	typs[52] = types.NewPtr(typs[51])
-	typs[53] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[52]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[47])})
-	typs[54] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[5])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[15])})
-	typs[55] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[46]), ir.NewField(base.Pos, nil, nil, typs[15])})
-	typs[56] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[15])})
-	typs[57] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[2])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[2])})
-	typs[58] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[2])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7])})
-	typs[59] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[2])})
-	typs[60] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[2])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[2]), ir.NewField(base.Pos, nil, nil, typs[6])})
-	typs[61] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[1])}, nil)
-	typs[62] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1])}, nil)
-	typs[63] = types.NewPtr(typs[5])
-	typs[64] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[63]), ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[7])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
-	typs[65] = types.Types[types.TUINT32]
-	typs[66] = functype(nil, nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[65])})
-	typs[67] = types.NewMap(typs[2], typs[2])
-	typs[68] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[22]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[67])})
-	typs[69] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[67])})
-	typs[70] = functype(nil, nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[67])})
-	typs[71] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3])})
-	typs[72] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[2])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3])})
-	typs[73] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[1])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3])})
-	typs[74] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[6])})
-	typs[75] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[2])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[6])})
-	typs[76] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[1])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[6])})
-	typs[77] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[3])}, nil)
-	typs[78] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[2])}, nil)
-	typs[79] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3])}, nil)
-	typs[80] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67])}, nil)
-	typs[81] = types.NewChan(typs[2], types.Cboth)
-	typs[82] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[22])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[81])})
-	typs[83] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[81])})
-	typs[84] = types.NewChan(typs[2], types.Crecv)
-	typs[85] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[84]), ir.NewField(base.Pos, nil, nil, typs[3])}, nil)
-	typs[86] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[84]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
-	typs[87] = types.NewChan(typs[2], types.Csend)
-	typs[88] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[87]), ir.NewField(base.Pos, nil, nil, typs[3])}, nil)
-	typs[89] = types.NewArray(typs[0], 3)
-	typs[90] = tostruct([]*ir.Field{ir.NewField(base.Pos, lookup("enabled"), nil, typs[6]), ir.NewField(base.Pos, lookup("pad"), nil, typs[89]), ir.NewField(base.Pos, lookup("needed"), nil, typs[6]), ir.NewField(base.Pos, lookup("cgo"), nil, typs[6]), ir.NewField(base.Pos, lookup("alignme"), nil, typs[24])})
-	typs[91] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[3])}, nil)
-	typs[92] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[3])}, nil)
-	typs[93] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[15])})
-	typs[94] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[87]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
-	typs[95] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[84])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
-	typs[96] = types.NewPtr(typs[6])
-	typs[97] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[96]), ir.NewField(base.Pos, nil, nil, typs[84])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
-	typs[98] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[63])}, nil)
-	typs[99] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[63]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[6])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[6])})
-	typs[100] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7])})
-	typs[101] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[22]), ir.NewField(base.Pos, nil, nil, typs[22])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7])})
-	typs[102] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[7])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7])})
-	typs[103] = types.NewSlice(typs[2])
-	typs[104] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[103]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[103])})
-	typs[105] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[5])}, nil)
-	typs[106] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[5])}, nil)
-	typs[107] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[5])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
-	typs[108] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
-	typs[109] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[7])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
-	typs[110] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[5]), ir.NewField(base.Pos, nil, nil, typs[5])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[5])})
-	typs[111] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[5])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[5])})
-	typs[112] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[22]), ir.NewField(base.Pos, nil, nil, typs[22])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[22])})
-	typs[113] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[24]), ir.NewField(base.Pos, nil, nil, typs[24])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[24])})
-	typs[114] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[22])})
-	typs[115] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[24])})
-	typs[116] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[65])})
-	typs[117] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[22])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])})
-	typs[118] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[24])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])})
-	typs[119] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[65])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])})
-	typs[120] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[26]), ir.NewField(base.Pos, nil, nil, typs[26])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[26])})
-	typs[121] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[5]), ir.NewField(base.Pos, nil, nil, typs[5])}, nil)
-	typs[122] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[5]), ir.NewField(base.Pos, nil, nil, typs[5]), ir.NewField(base.Pos, nil, nil, typs[5])}, nil)
-	typs[123] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[5])}, nil)
-	typs[124] = types.NewSlice(typs[7])
-	typs[125] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[124])}, nil)
-	typs[126] = types.Types[types.TUINT8]
-	typs[127] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[126]), ir.NewField(base.Pos, nil, nil, typs[126])}, nil)
-	typs[128] = types.Types[types.TUINT16]
-	typs[129] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[128]), ir.NewField(base.Pos, nil, nil, typs[128])}, nil)
-	typs[130] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[65]), ir.NewField(base.Pos, nil, nil, typs[65])}, nil)
-	typs[131] = functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[24]), ir.NewField(base.Pos, nil, nil, typs[24])}, nil)
-	return typs[:]
-}
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index 454d97e17f..29455bffd8 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -8,9 +8,9 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/syntax"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
-	"fmt"
 )
 
 func (p *noder) funcLit(expr *syntax.FuncLit) ir.Node {
@@ -72,156 +72,6 @@ func (p *noder) funcLit(expr *syntax.FuncLit) ir.Node {
 	return clo
 }
 
-// typecheckclosure typechecks an OCLOSURE node. It also creates the named
-// function associated with the closure.
-// TODO: This creation of the named function should probably really be done in a
-// separate pass from type-checking.
-func typecheckclosure(clo *ir.ClosureExpr, top int) {
-	fn := clo.Func
-	// Set current associated iota value, so iota can be used inside
-	// function in ConstSpec, see issue #22344
-	if x := getIotaValue(); x >= 0 {
-		fn.Iota = x
-	}
-
-	fn.ClosureType = typecheck(fn.ClosureType, ctxType)
-	clo.SetType(fn.ClosureType.Type())
-	fn.SetClosureCalled(top&ctxCallee != 0)
-
-	// Do not typecheck fn twice, otherwise, we will end up pushing
-	// fn to Target.Decls multiple times, causing initLSym called twice.
-	// See #30709
-	if fn.Typecheck() == 1 {
-		return
-	}
-
-	for _, ln := range fn.ClosureVars {
-		n := ln.Defn
-		if !n.Name().Captured() {
-			n.Name().SetCaptured(true)
-			if n.Name().Decldepth == 0 {
-				base.Fatalf("typecheckclosure: var %v does not have decldepth assigned", n)
-			}
-
-			// Ignore assignments to the variable in straightline code
-			// preceding the first capturing by a closure.
-			if n.Name().Decldepth == decldepth {
-				n.Name().SetAssigned(false)
-			}
-		}
-	}
-
-	fn.Nname.SetSym(closurename(ir.CurFunc))
-	ir.MarkFunc(fn.Nname)
-	typecheckFunc(fn)
-
-	// Type check the body now, but only if we're inside a function.
-	// At top level (in a variable initialization: curfn==nil) we're not
-	// ready to type check code yet; we'll check it later, because the
-	// underlying closure function we create is added to Target.Decls.
-	if ir.CurFunc != nil && clo.Type() != nil {
-		oldfn := ir.CurFunc
-		ir.CurFunc = fn
-		olddd := decldepth
-		decldepth = 1
-		typecheckslice(fn.Body, ctxStmt)
-		decldepth = olddd
-		ir.CurFunc = oldfn
-	}
-
-	Target.Decls = append(Target.Decls, fn)
-}
-
-// globClosgen is like Func.Closgen, but for the global scope.
-var globClosgen int32
-
-// closurename generates a new unique name for a closure within
-// outerfunc.
-func closurename(outerfunc *ir.Func) *types.Sym {
-	outer := "glob."
-	prefix := "func"
-	gen := &globClosgen
-
-	if outerfunc != nil {
-		if outerfunc.OClosure != nil {
-			prefix = ""
-		}
-
-		outer = ir.FuncName(outerfunc)
-
-		// There may be multiple functions named "_". In those
-		// cases, we can't use their individual Closgens as it
-		// would lead to name clashes.
-		if !ir.IsBlank(outerfunc.Nname) {
-			gen = &outerfunc.Closgen
-		}
-	}
-
-	*gen++
-	return lookup(fmt.Sprintf("%s.%s%d", outer, prefix, *gen))
-}
-
-// capturevarscomplete is set to true when the capturevars phase is done.
-var capturevarscomplete bool
-
-// capturevars is called in a separate phase after all typechecking is done.
-// It decides whether each variable captured by a closure should be captured
-// by value or by reference.
-// We use value capturing for values <= 128 bytes that are never reassigned
-// after capturing (effectively constant).
-func capturevars(fn *ir.Func) {
-	lno := base.Pos
-	base.Pos = fn.Pos()
-	cvars := fn.ClosureVars
-	out := cvars[:0]
-	for _, v := range cvars {
-		if v.Type() == nil {
-			// If v.Type is nil, it means v looked like it
-			// was going to be used in the closure, but
-			// isn't. This happens in struct literals like
-			// s{f: x} where we can't distinguish whether
-			// f is a field identifier or expression until
-			// resolving s.
-			continue
-		}
-		out = append(out, v)
-
-		// type check the & of closed variables outside the closure,
-		// so that the outer frame also grabs them and knows they escape.
-		types.CalcSize(v.Type())
-
-		var outer ir.Node
-		outer = v.Outer
-		outermost := v.Defn.(*ir.Name)
-
-		// out parameters will be assigned to implicitly upon return.
-		if outermost.Class_ != ir.PPARAMOUT && !outermost.Name().Addrtaken() && !outermost.Name().Assigned() && v.Type().Width <= 128 {
-			v.SetByval(true)
-		} else {
-			outermost.Name().SetAddrtaken(true)
-			outer = nodAddr(outer)
-		}
-
-		if base.Flag.LowerM > 1 {
-			var name *types.Sym
-			if v.Curfn != nil && v.Curfn.Nname != nil {
-				name = v.Curfn.Sym()
-			}
-			how := "ref"
-			if v.Byval() {
-				how = "value"
-			}
-			base.WarnfAt(v.Pos(), "%v capturing by %s: %v (addr=%v assign=%v width=%d)", name, how, v.Sym(), outermost.Name().Addrtaken(), outermost.Name().Assigned(), int32(v.Type().Width))
-		}
-
-		outer = typecheck(outer, ctxExpr)
-		fn.ClosureEnter.Append(outer)
-	}
-
-	fn.ClosureVars = out
-	base.Pos = lno
-}
-
 // transformclosure is called in a separate phase after escape analysis.
 // It transform closure bodies to properly reference captured variables.
 func transformclosure(fn *ir.Func) {
@@ -256,7 +106,7 @@ func transformclosure(fn *ir.Func) {
 				// we introduce function param &v *T
 				// and v remains PAUTOHEAP with &v heapaddr
 				// (accesses will implicitly deref &v).
-				addr := NewName(lookup("&" + v.Sym().Name))
+				addr := typecheck.NewName(typecheck.Lookup("&" + v.Sym().Name))
 				addr.SetType(types.NewPtr(v.Type()))
 				v.Heapaddr = addr
 				v = addr
@@ -300,7 +150,7 @@ func transformclosure(fn *ir.Func) {
 			} else {
 				// Declare variable holding addresses taken from closure
 				// and initialize in entry prologue.
-				addr := NewName(lookup("&" + v.Sym().Name))
+				addr := typecheck.NewName(typecheck.Lookup("&" + v.Sym().Name))
 				addr.SetType(types.NewPtr(v.Type()))
 				addr.Class_ = ir.PAUTO
 				addr.SetUsed(true)
@@ -309,14 +159,14 @@ func transformclosure(fn *ir.Func) {
 				v.Heapaddr = addr
 				var src ir.Node = cr
 				if v.Byval() {
-					src = nodAddr(cr)
+					src = typecheck.NodAddr(cr)
 				}
 				body = append(body, ir.NewAssignStmt(base.Pos, addr, src))
 			}
 		}
 
 		if len(body) > 0 {
-			typecheckslice(body, ctxStmt)
+			typecheck.Stmts(body)
 			fn.Enter.Set(body)
 			fn.SetNeedctxt(true)
 		}
@@ -346,38 +196,6 @@ func closuredebugruntimecheck(clo *ir.ClosureExpr) {
 	}
 }
 
-// closureType returns the struct type used to hold all the information
-// needed in the closure for clo (clo must be a OCLOSURE node).
-// The address of a variable of the returned type can be cast to a func.
-func closureType(clo *ir.ClosureExpr) *types.Type {
-	// Create closure in the form of a composite literal.
-	// supposing the closure captures an int i and a string s
-	// and has one float64 argument and no results,
-	// the generated code looks like:
-	//
-	//	clos = &struct{.F uintptr; i *int; s *string}{func.1, &i, &s}
-	//
-	// The use of the struct provides type information to the garbage
-	// collector so that it can walk the closure. We could use (in this case)
-	// [3]unsafe.Pointer instead, but that would leave the gc in the dark.
-	// The information appears in the binary in the form of type descriptors;
-	// the struct is unnamed so that closures in multiple packages with the
-	// same struct type can share the descriptor.
-	fields := []*ir.Field{
-		ir.NewField(base.Pos, lookup(".F"), nil, types.Types[types.TUINTPTR]),
-	}
-	for _, v := range clo.Func.ClosureVars {
-		typ := v.Type()
-		if !v.Byval() {
-			typ = types.NewPtr(typ)
-		}
-		fields = append(fields, ir.NewField(base.Pos, v.Sym(), nil, typ))
-	}
-	typ := tostruct(fields)
-	typ.SetNoalg(true)
-	return typ
-}
-
 func walkclosure(clo *ir.ClosureExpr, init *ir.Nodes) ir.Node {
 	fn := clo.Func
 
@@ -390,17 +208,17 @@ func walkclosure(clo *ir.ClosureExpr, init *ir.Nodes) ir.Node {
 	}
 	closuredebugruntimecheck(clo)
 
-	typ := closureType(clo)
+	typ := typecheck.ClosureType(clo)
 
 	clos := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ).(ir.Ntype), nil)
 	clos.SetEsc(clo.Esc())
 	clos.List.Set(append([]ir.Node{ir.NewUnaryExpr(base.Pos, ir.OCFUNC, fn.Nname)}, fn.ClosureEnter...))
 
-	addr := nodAddr(clos)
+	addr := typecheck.NodAddr(clos)
 	addr.SetEsc(clo.Esc())
 
 	// Force type conversion from *struct to the func type.
-	cfn := convnop(addr, clo.Type())
+	cfn := typecheck.ConvNop(addr, clo.Type())
 
 	// non-escaping temp to use, if any.
 	if x := clo.Prealloc; x != nil {
@@ -414,110 +232,6 @@ func walkclosure(clo *ir.ClosureExpr, init *ir.Nodes) ir.Node {
 	return walkexpr(cfn, init)
 }
 
-func typecheckpartialcall(n ir.Node, sym *types.Sym) *ir.CallPartExpr {
-	switch n.Op() {
-	case ir.ODOTINTER, ir.ODOTMETH:
-		break
-
-	default:
-		base.Fatalf("invalid typecheckpartialcall")
-	}
-	dot := n.(*ir.SelectorExpr)
-
-	// Create top-level function.
-	fn := makepartialcall(dot, dot.Type(), sym)
-	fn.SetWrapper(true)
-
-	return ir.NewCallPartExpr(dot.Pos(), dot.X, dot.Selection, fn)
-}
-
-// makepartialcall returns a DCLFUNC node representing the wrapper function (*-fm) needed
-// for partial calls.
-func makepartialcall(dot *ir.SelectorExpr, t0 *types.Type, meth *types.Sym) *ir.Func {
-	rcvrtype := dot.X.Type()
-	sym := ir.MethodSymSuffix(rcvrtype, meth, "-fm")
-
-	if sym.Uniq() {
-		return sym.Def.(*ir.Func)
-	}
-	sym.SetUniq(true)
-
-	savecurfn := ir.CurFunc
-	saveLineNo := base.Pos
-	ir.CurFunc = nil
-
-	// Set line number equal to the line number where the method is declared.
-	var m *types.Field
-	if lookdot0(meth, rcvrtype, &m, false) == 1 && m.Pos.IsKnown() {
-		base.Pos = m.Pos
-	}
-	// Note: !m.Pos.IsKnown() happens for method expressions where
-	// the method is implicitly declared. The Error method of the
-	// built-in error type is one such method.  We leave the line
-	// number at the use of the method expression in this
-	// case. See issue 29389.
-
-	tfn := ir.NewFuncType(base.Pos, nil,
-		structargs(t0.Params(), true),
-		structargs(t0.Results(), false))
-
-	fn := dclfunc(sym, tfn)
-	fn.SetDupok(true)
-	fn.SetNeedctxt(true)
-
-	// Declare and initialize variable holding receiver.
-	cr := ir.NewClosureRead(rcvrtype, types.Rnd(int64(types.PtrSize), int64(rcvrtype.Align)))
-	ptr := NewName(lookup(".this"))
-	declare(ptr, ir.PAUTO)
-	ptr.SetUsed(true)
-	var body []ir.Node
-	if rcvrtype.IsPtr() || rcvrtype.IsInterface() {
-		ptr.SetType(rcvrtype)
-		body = append(body, ir.NewAssignStmt(base.Pos, ptr, cr))
-	} else {
-		ptr.SetType(types.NewPtr(rcvrtype))
-		body = append(body, ir.NewAssignStmt(base.Pos, ptr, nodAddr(cr)))
-	}
-
-	call := ir.NewCallExpr(base.Pos, ir.OCALL, ir.NewSelectorExpr(base.Pos, ir.OXDOT, ptr, meth), nil)
-	call.Args.Set(ir.ParamNames(tfn.Type()))
-	call.IsDDD = tfn.Type().IsVariadic()
-	if t0.NumResults() != 0 {
-		ret := ir.NewReturnStmt(base.Pos, nil)
-		ret.Results = []ir.Node{call}
-		body = append(body, ret)
-	} else {
-		body = append(body, call)
-	}
-
-	fn.Body.Set(body)
-	funcbody()
-
-	typecheckFunc(fn)
-	// Need to typecheck the body of the just-generated wrapper.
-	// typecheckslice() requires that Curfn is set when processing an ORETURN.
-	ir.CurFunc = fn
-	typecheckslice(fn.Body, ctxStmt)
-	sym.Def = fn
-	Target.Decls = append(Target.Decls, fn)
-	ir.CurFunc = savecurfn
-	base.Pos = saveLineNo
-
-	return fn
-}
-
-// partialCallType returns the struct type used to hold all the information
-// needed in the closure for n (n must be a OCALLPART node).
-// The address of a variable of the returned type can be cast to a func.
-func partialCallType(n *ir.CallPartExpr) *types.Type {
-	t := tostruct([]*ir.Field{
-		ir.NewField(base.Pos, lookup("F"), nil, types.Types[types.TUINTPTR]),
-		ir.NewField(base.Pos, lookup("R"), nil, n.X.Type()),
-	})
-	t.SetNoalg(true)
-	return t
-}
-
 func walkpartialcall(n *ir.CallPartExpr, init *ir.Nodes) ir.Node {
 	// Create closure in the form of a composite literal.
 	// For x.M with receiver (x) type T, the generated code looks like:
@@ -532,24 +246,24 @@ func walkpartialcall(n *ir.CallPartExpr, init *ir.Nodes) ir.Node {
 		n.X = cheapexpr(n.X, init)
 		n.X = walkexpr(n.X, nil)
 
-		tab := typecheck(ir.NewUnaryExpr(base.Pos, ir.OITAB, n.X), ctxExpr)
+		tab := typecheck.Expr(ir.NewUnaryExpr(base.Pos, ir.OITAB, n.X))
 
 		c := ir.NewUnaryExpr(base.Pos, ir.OCHECKNIL, tab)
 		c.SetTypecheck(1)
 		init.Append(c)
 	}
 
-	typ := partialCallType(n)
+	typ := typecheck.PartialCallType(n)
 
 	clos := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ).(ir.Ntype), nil)
 	clos.SetEsc(n.Esc())
 	clos.List = []ir.Node{ir.NewUnaryExpr(base.Pos, ir.OCFUNC, n.Func.Nname), n.X}
 
-	addr := nodAddr(clos)
+	addr := typecheck.NodAddr(clos)
 	addr.SetEsc(n.Esc())
 
 	// Force type conversion from *struct to the func type.
-	cfn := convnop(addr, n.Type())
+	cfn := typecheck.ConvNop(addr, n.Type())
 
 	// non-escaping temp to use, if any.
 	if x := n.Prealloc; x != nil {
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 1189d0ec12..e53bba44ad 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -8,11 +8,11 @@ import (
 	"bytes"
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/src"
 	"fmt"
-	"strings"
 )
 
 func EnableNoWriteBarrierRecCheck() {
@@ -28,154 +28,6 @@ func NoWriteBarrierRecCheck() {
 
 var nowritebarrierrecCheck *nowritebarrierrecChecker
 
-// redeclare emits a diagnostic about symbol s being redeclared at pos.
-func redeclare(pos src.XPos, s *types.Sym, where string) {
-	if !s.Lastlineno.IsKnown() {
-		pkgName := dotImportRefs[s.Def.(*ir.Ident)]
-		base.ErrorfAt(pos, "%v redeclared %s\n"+
-			"\t%v: previous declaration during import %q", s, where, base.FmtPos(pkgName.Pos()), pkgName.Pkg.Path)
-	} else {
-		prevPos := s.Lastlineno
-
-		// When an import and a declaration collide in separate files,
-		// present the import as the "redeclared", because the declaration
-		// is visible where the import is, but not vice versa.
-		// See issue 4510.
-		if s.Def == nil {
-			pos, prevPos = prevPos, pos
-		}
-
-		base.ErrorfAt(pos, "%v redeclared %s\n"+
-			"\t%v: previous declaration", s, where, base.FmtPos(prevPos))
-	}
-}
-
-var vargen int
-
-// declare individual names - var, typ, const
-
-var declare_typegen int
-
-// declare records that Node n declares symbol n.Sym in the specified
-// declaration context.
-func declare(n *ir.Name, ctxt ir.Class) {
-	if ir.IsBlank(n) {
-		return
-	}
-
-	s := n.Sym()
-
-	// kludgy: typecheckok means we're past parsing. Eg genwrapper may declare out of package names later.
-	if !inimport && !typecheckok && s.Pkg != types.LocalPkg {
-		base.ErrorfAt(n.Pos(), "cannot declare name %v", s)
-	}
-
-	gen := 0
-	if ctxt == ir.PEXTERN {
-		if s.Name == "init" {
-			base.ErrorfAt(n.Pos(), "cannot declare init - must be func")
-		}
-		if s.Name == "main" && s.Pkg.Name == "main" {
-			base.ErrorfAt(n.Pos(), "cannot declare main - must be func")
-		}
-		Target.Externs = append(Target.Externs, n)
-	} else {
-		if ir.CurFunc == nil && ctxt == ir.PAUTO {
-			base.Pos = n.Pos()
-			base.Fatalf("automatic outside function")
-		}
-		if ir.CurFunc != nil && ctxt != ir.PFUNC && n.Op() == ir.ONAME {
-			ir.CurFunc.Dcl = append(ir.CurFunc.Dcl, n)
-		}
-		if n.Op() == ir.OTYPE {
-			declare_typegen++
-			gen = declare_typegen
-		} else if n.Op() == ir.ONAME && ctxt == ir.PAUTO && !strings.Contains(s.Name, "·") {
-			vargen++
-			gen = vargen
-		}
-		types.Pushdcl(s)
-		n.Curfn = ir.CurFunc
-	}
-
-	if ctxt == ir.PAUTO {
-		n.SetFrameOffset(0)
-	}
-
-	if s.Block == types.Block {
-		// functype will print errors about duplicate function arguments.
-		// Don't repeat the error here.
-		if ctxt != ir.PPARAM && ctxt != ir.PPARAMOUT {
-			redeclare(n.Pos(), s, "in this block")
-		}
-	}
-
-	s.Block = types.Block
-	s.Lastlineno = base.Pos
-	s.Def = n
-	n.Vargen = int32(gen)
-	n.Class_ = ctxt
-	if ctxt == ir.PFUNC {
-		n.Sym().SetFunc(true)
-	}
-
-	autoexport(n, ctxt)
-}
-
-// declare variables from grammar
-// new_name_list (type | [type] = expr_list)
-func variter(vl []*ir.Name, t ir.Ntype, el []ir.Node) []ir.Node {
-	var init []ir.Node
-	doexpr := len(el) > 0
-
-	if len(el) == 1 && len(vl) > 1 {
-		e := el[0]
-		as2 := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-		as2.Rhs = []ir.Node{e}
-		for _, v := range vl {
-			as2.Lhs.Append(v)
-			declare(v, dclcontext)
-			v.Ntype = t
-			v.Defn = as2
-			if ir.CurFunc != nil {
-				init = append(init, ir.NewDecl(base.Pos, ir.ODCL, v))
-			}
-		}
-
-		return append(init, as2)
-	}
-
-	for i, v := range vl {
-		var e ir.Node
-		if doexpr {
-			if i >= len(el) {
-				base.Errorf("assignment mismatch: %d variables but %d values", len(vl), len(el))
-				break
-			}
-			e = el[i]
-		}
-
-		declare(v, dclcontext)
-		v.Ntype = t
-
-		if e != nil || ir.CurFunc != nil || ir.IsBlank(v) {
-			if ir.CurFunc != nil {
-				init = append(init, ir.NewDecl(base.Pos, ir.ODCL, v))
-			}
-			as := ir.NewAssignStmt(base.Pos, v, e)
-			init = append(init, as)
-			if e != nil {
-				v.Defn = as
-			}
-		}
-	}
-
-	if len(el) > len(vl) {
-		base.Errorf("assignment mismatch: %d variables but %d values", len(vl), len(el))
-	}
-	return init
-}
-
 // oldname returns the Node that declares symbol s in the current scope.
 // If no such Node currently exists, an ONONAME Node is returned instead.
 // Automatically creates a new closure variable if the referenced symbol was
@@ -204,7 +56,7 @@ func oldname(s *types.Sym) ir.Node {
 		c := n.Name().Innermost
 		if c == nil || c.Curfn != ir.CurFunc {
 			// Do not have a closure var for the active closure yet; make one.
-			c = NewName(s)
+			c = typecheck.NewName(s)
 			c.Class_ = ir.PAUTOHEAP
 			c.SetIsClosureVar(true)
 			c.SetIsDDD(n.IsDDD())
@@ -236,419 +88,10 @@ func importName(sym *types.Sym) ir.Node {
 	return n
 }
 
-// := declarations
-func colasname(n ir.Node) bool {
-	switch n.Op() {
-	case ir.ONAME,
-		ir.ONONAME,
-		ir.OPACK,
-		ir.OTYPE,
-		ir.OLITERAL:
-		return n.Sym() != nil
-	}
-
-	return false
-}
-
-func colasdefn(left []ir.Node, defn ir.Node) {
-	for _, n := range left {
-		if n.Sym() != nil {
-			n.Sym().SetUniq(true)
-		}
-	}
-
-	var nnew, nerr int
-	for i, n := range left {
-		if ir.IsBlank(n) {
-			continue
-		}
-		if !colasname(n) {
-			base.ErrorfAt(defn.Pos(), "non-name %v on left side of :=", n)
-			nerr++
-			continue
-		}
-
-		if !n.Sym().Uniq() {
-			base.ErrorfAt(defn.Pos(), "%v repeated on left side of :=", n.Sym())
-			n.SetDiag(true)
-			nerr++
-			continue
-		}
-
-		n.Sym().SetUniq(false)
-		if n.Sym().Block == types.Block {
-			continue
-		}
-
-		nnew++
-		n := NewName(n.Sym())
-		declare(n, dclcontext)
-		n.Defn = defn
-		defn.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, n))
-		left[i] = n
-	}
-
-	if nnew == 0 && nerr == 0 {
-		base.ErrorfAt(defn.Pos(), "no new variables on left side of :=")
-	}
-}
-
-// declare the function proper
-// and declare the arguments.
-// called in extern-declaration context
-// returns in auto-declaration context.
-func funchdr(fn *ir.Func) {
-	// change the declaration context from extern to auto
-	funcStack = append(funcStack, funcStackEnt{ir.CurFunc, dclcontext})
-	ir.CurFunc = fn
-	dclcontext = ir.PAUTO
-
-	types.Markdcl()
-
-	if fn.Nname.Ntype != nil {
-		funcargs(fn.Nname.Ntype.(*ir.FuncType))
-	} else {
-		funcargs2(fn.Type())
-	}
-}
-
-func funcargs(nt *ir.FuncType) {
-	if nt.Op() != ir.OTFUNC {
-		base.Fatalf("funcargs %v", nt.Op())
-	}
-
-	// re-start the variable generation number
-	// we want to use small numbers for the return variables,
-	// so let them have the chunk starting at 1.
-	//
-	// TODO(mdempsky): This is ugly, and only necessary because
-	// esc.go uses Vargen to figure out result parameters' index
-	// within the result tuple.
-	vargen = len(nt.Results)
-
-	// declare the receiver and in arguments.
-	if nt.Recv != nil {
-		funcarg(nt.Recv, ir.PPARAM)
-	}
-	for _, n := range nt.Params {
-		funcarg(n, ir.PPARAM)
-	}
-
-	oldvargen := vargen
-	vargen = 0
-
-	// declare the out arguments.
-	gen := len(nt.Params)
-	for _, n := range nt.Results {
-		if n.Sym == nil {
-			// Name so that escape analysis can track it. ~r stands for 'result'.
-			n.Sym = lookupN("~r", gen)
-			gen++
-		}
-		if n.Sym.IsBlank() {
-			// Give it a name so we can assign to it during return. ~b stands for 'blank'.
-			// The name must be different from ~r above because if you have
-			//	func f() (_ int)
-			//	func g() int
-			// f is allowed to use a plain 'return' with no arguments, while g is not.
-			// So the two cases must be distinguished.
-			n.Sym = lookupN("~b", gen)
-			gen++
-		}
-
-		funcarg(n, ir.PPARAMOUT)
-	}
-
-	vargen = oldvargen
-}
-
-func funcarg(n *ir.Field, ctxt ir.Class) {
-	if n.Sym == nil {
-		return
-	}
-
-	name := ir.NewNameAt(n.Pos, n.Sym)
-	n.Decl = name
-	name.Ntype = n.Ntype
-	name.SetIsDDD(n.IsDDD)
-	declare(name, ctxt)
-
-	vargen++
-	n.Decl.Vargen = int32(vargen)
-}
-
-// Same as funcargs, except run over an already constructed TFUNC.
-// This happens during import, where the hidden_fndcl rule has
-// used functype directly to parse the function's type.
-func funcargs2(t *types.Type) {
-	if t.Kind() != types.TFUNC {
-		base.Fatalf("funcargs2 %v", t)
-	}
-
-	for _, f := range t.Recvs().Fields().Slice() {
-		funcarg2(f, ir.PPARAM)
-	}
-	for _, f := range t.Params().Fields().Slice() {
-		funcarg2(f, ir.PPARAM)
-	}
-	for _, f := range t.Results().Fields().Slice() {
-		funcarg2(f, ir.PPARAMOUT)
-	}
-}
-
-func funcarg2(f *types.Field, ctxt ir.Class) {
-	if f.Sym == nil {
-		return
-	}
-	n := ir.NewNameAt(f.Pos, f.Sym)
-	f.Nname = n
-	n.SetType(f.Type)
-	n.SetIsDDD(f.IsDDD())
-	declare(n, ctxt)
-}
-
-var funcStack []funcStackEnt // stack of previous values of Curfn/dclcontext
-
-type funcStackEnt struct {
-	curfn      *ir.Func
-	dclcontext ir.Class
-}
-
-func CheckFuncStack() {
-	if len(funcStack) != 0 {
-		base.Fatalf("funcStack is non-empty: %v", len(funcStack))
-	}
-}
-
-// finish the body.
-// called in auto-declaration context.
-// returns in extern-declaration context.
-func funcbody() {
-	// change the declaration context from auto to previous context
-	types.Popdcl()
-	var e funcStackEnt
-	funcStack, e = funcStack[:len(funcStack)-1], funcStack[len(funcStack)-1]
-	ir.CurFunc, dclcontext = e.curfn, e.dclcontext
-}
-
-// structs, functions, and methods.
-// they don't belong here, but where do they belong?
-func checkembeddedtype(t *types.Type) {
-	if t == nil {
-		return
-	}
-
-	if t.Sym() == nil && t.IsPtr() {
-		t = t.Elem()
-		if t.IsInterface() {
-			base.Errorf("embedded type cannot be a pointer to interface")
-		}
-	}
-
-	if t.IsPtr() || t.IsUnsafePtr() {
-		base.Errorf("embedded type cannot be a pointer")
-	} else if t.Kind() == types.TFORW && !t.ForwardType().Embedlineno.IsKnown() {
-		t.ForwardType().Embedlineno = base.Pos
-	}
-}
-
-// checkdupfields emits errors for duplicately named fields or methods in
-// a list of struct or interface types.
-func checkdupfields(what string, fss ...[]*types.Field) {
-	seen := make(map[*types.Sym]bool)
-	for _, fs := range fss {
-		for _, f := range fs {
-			if f.Sym == nil || f.Sym.IsBlank() {
-				continue
-			}
-			if seen[f.Sym] {
-				base.ErrorfAt(f.Pos, "duplicate %s %s", what, f.Sym.Name)
-				continue
-			}
-			seen[f.Sym] = true
-		}
-	}
-}
-
-// convert a parsed id/type list into
-// a type for struct/interface/arglist
-func tostruct(l []*ir.Field) *types.Type {
-	lno := base.Pos
-
-	fields := make([]*types.Field, len(l))
-	for i, n := range l {
-		base.Pos = n.Pos
-
-		if n.Ntype != nil {
-			n.Type = typecheckNtype(n.Ntype).Type()
-			n.Ntype = nil
-		}
-		f := types.NewField(n.Pos, n.Sym, n.Type)
-		if n.Embedded {
-			checkembeddedtype(n.Type)
-			f.Embedded = 1
-		}
-		f.Note = n.Note
-		fields[i] = f
-	}
-	checkdupfields("field", fields)
-
-	base.Pos = lno
-	return types.NewStruct(types.LocalPkg, fields)
-}
-
-func tointerface(nmethods []*ir.Field) *types.Type {
-	if len(nmethods) == 0 {
-		return types.Types[types.TINTER]
-	}
-
-	lno := base.Pos
-
-	methods := make([]*types.Field, len(nmethods))
-	for i, n := range nmethods {
-		base.Pos = n.Pos
-		if n.Ntype != nil {
-			n.Type = typecheckNtype(n.Ntype).Type()
-			n.Ntype = nil
-		}
-		methods[i] = types.NewField(n.Pos, n.Sym, n.Type)
-	}
-
-	base.Pos = lno
-	return types.NewInterface(types.LocalPkg, methods)
-}
-
 func fakeRecv() *ir.Field {
 	return ir.NewField(base.Pos, nil, nil, types.FakeRecvType())
 }
 
-func fakeRecvField() *types.Field {
-	return types.NewField(src.NoXPos, nil, types.FakeRecvType())
-}
-
-// turn a parsed function declaration into a type
-func functype(nrecv *ir.Field, nparams, nresults []*ir.Field) *types.Type {
-	funarg := func(n *ir.Field) *types.Field {
-		lno := base.Pos
-		base.Pos = n.Pos
-
-		if n.Ntype != nil {
-			n.Type = typecheckNtype(n.Ntype).Type()
-			n.Ntype = nil
-		}
-
-		f := types.NewField(n.Pos, n.Sym, n.Type)
-		f.SetIsDDD(n.IsDDD)
-		if n.Decl != nil {
-			n.Decl.SetType(f.Type)
-			f.Nname = n.Decl
-		}
-
-		base.Pos = lno
-		return f
-	}
-	funargs := func(nn []*ir.Field) []*types.Field {
-		res := make([]*types.Field, len(nn))
-		for i, n := range nn {
-			res[i] = funarg(n)
-		}
-		return res
-	}
-
-	var recv *types.Field
-	if nrecv != nil {
-		recv = funarg(nrecv)
-	}
-
-	t := types.NewSignature(types.LocalPkg, recv, funargs(nparams), funargs(nresults))
-	checkdupfields("argument", t.Recvs().FieldSlice(), t.Params().FieldSlice(), t.Results().FieldSlice())
-	return t
-}
-
-// Add a method, declared as a function.
-// - msym is the method symbol
-// - t is function type (with receiver)
-// Returns a pointer to the existing or added Field; or nil if there's an error.
-func addmethod(n *ir.Func, msym *types.Sym, t *types.Type, local, nointerface bool) *types.Field {
-	if msym == nil {
-		base.Fatalf("no method symbol")
-	}
-
-	// get parent type sym
-	rf := t.Recv() // ptr to this structure
-	if rf == nil {
-		base.Errorf("missing receiver")
-		return nil
-	}
-
-	mt := types.ReceiverBaseType(rf.Type)
-	if mt == nil || mt.Sym() == nil {
-		pa := rf.Type
-		t := pa
-		if t != nil && t.IsPtr() {
-			if t.Sym() != nil {
-				base.Errorf("invalid receiver type %v (%v is a pointer type)", pa, t)
-				return nil
-			}
-			t = t.Elem()
-		}
-
-		switch {
-		case t == nil || t.Broke():
-			// rely on typecheck having complained before
-		case t.Sym() == nil:
-			base.Errorf("invalid receiver type %v (%v is not a defined type)", pa, t)
-		case t.IsPtr():
-			base.Errorf("invalid receiver type %v (%v is a pointer type)", pa, t)
-		case t.IsInterface():
-			base.Errorf("invalid receiver type %v (%v is an interface type)", pa, t)
-		default:
-			// Should have picked off all the reasons above,
-			// but just in case, fall back to generic error.
-			base.Errorf("invalid receiver type %v (%L / %L)", pa, pa, t)
-		}
-		return nil
-	}
-
-	if local && mt.Sym().Pkg != types.LocalPkg {
-		base.Errorf("cannot define new methods on non-local type %v", mt)
-		return nil
-	}
-
-	if msym.IsBlank() {
-		return nil
-	}
-
-	if mt.IsStruct() {
-		for _, f := range mt.Fields().Slice() {
-			if f.Sym == msym {
-				base.Errorf("type %v has both field and method named %v", mt, msym)
-				f.SetBroke(true)
-				return nil
-			}
-		}
-	}
-
-	for _, f := range mt.Methods().Slice() {
-		if msym.Name != f.Sym.Name {
-			continue
-		}
-		// types.Identical only checks that incoming and result parameters match,
-		// so explicitly check that the receiver parameters match too.
-		if !types.Identical(t, f.Type) || !types.Identical(t.Recv().Type, f.Type.Recv().Type) {
-			base.Errorf("method redeclared: %v.%v\n\t%v\n\t%v", mt, msym, f.Type, t)
-		}
-		return f
-	}
-
-	f := types.NewField(base.Pos, msym, t)
-	f.Nname = n.Nname
-	f.SetNointerface(nointerface)
-
-	mt.Methods().Append(f)
-	return f
-}
-
 // funcsym returns s·f.
 func funcsym(s *types.Sym) *types.Sym {
 	// funcsymsmu here serves to protect not just mutations of funcsyms (below),
@@ -700,21 +143,6 @@ func makefuncsym(s *types.Sym) {
 	}
 }
 
-func dclfunc(sym *types.Sym, tfn ir.Ntype) *ir.Func {
-	if tfn.Op() != ir.OTFUNC {
-		base.Fatalf("expected OTFUNC node, got %v", tfn)
-	}
-
-	fn := ir.NewFunc(base.Pos)
-	fn.Nname = ir.NewFuncNameAt(base.Pos, sym, fn)
-	fn.Nname.Defn = fn
-	fn.Nname.Ntype = tfn
-	ir.MarkFunc(fn.Nname)
-	funchdr(fn)
-	fn.Nname.Ntype = typecheckNtype(fn.Nname.Ntype)
-	return fn
-}
-
 type nowritebarrierrecChecker struct {
 	// extraCalls contains extra function calls that may not be
 	// visible during later analysis. It maps from the ODCLFUNC of
@@ -742,7 +170,7 @@ func newNowritebarrierrecChecker() *nowritebarrierrecChecker {
 	// important to handle it for this check, so we model it
 	// directly. This has to happen before transformclosure since
 	// it's a lot harder to work out the argument after.
-	for _, n := range Target.Decls {
+	for _, n := range typecheck.Target.Decls {
 		if n.Op() != ir.ODCLFUNC {
 			continue
 		}
@@ -819,7 +247,7 @@ func (c *nowritebarrierrecChecker) check() {
 	// q is the queue of ODCLFUNC Nodes to visit in BFS order.
 	var q ir.NameQueue
 
-	for _, n := range Target.Decls {
+	for _, n := range typecheck.Target.Decls {
 		if n.Op() != ir.ODCLFUNC {
 			continue
 		}
diff --git a/src/cmd/compile/internal/gc/embed.go b/src/cmd/compile/internal/gc/embed.go
index 70c5c2a25a..bcfec3cad3 100644
--- a/src/cmd/compile/internal/gc/embed.go
+++ b/src/cmd/compile/internal/gc/embed.go
@@ -8,6 +8,7 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/syntax"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 
@@ -61,13 +62,13 @@ func varEmbed(p *noder, names []*ir.Name, typ ir.Ntype, exprs []ir.Node, embeds
 		p.errorAt(pos, "go:embed cannot apply to var without type")
 		return exprs
 	}
-	if dclcontext != ir.PEXTERN {
+	if typecheck.DeclContext != ir.PEXTERN {
 		p.errorAt(pos, "go:embed cannot apply to var inside func")
 		return exprs
 	}
 
 	v := names[0]
-	Target.Embeds = append(Target.Embeds, v)
+	typecheck.Target.Embeds = append(typecheck.Target.Embeds, v)
 	v.Embed = new([]ir.Embed)
 	for _, e := range embeds {
 		*v.Embed = append(*v.Embed, ir.Embed{Pos: p.makeXPos(e.Pos), Patterns: e.Patterns})
@@ -184,7 +185,7 @@ func embedFileLess(x, y string) bool {
 }
 
 func dumpembeds() {
-	for _, v := range Target.Embeds {
+	for _, v := range typecheck.Target.Embeds {
 		initEmbed(v)
 	}
 }
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 6843d8b00e..187313695f 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -8,6 +8,7 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"fmt"
@@ -870,7 +871,7 @@ func (e *Escape) call(ks []EscHole, call, where ir.Node) {
 
 	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
 		call := call.(*ir.CallExpr)
-		fixVariadicCall(call)
+		typecheck.FixVariadicCall(call)
 
 		// Pick out the function callee, if statically known.
 		var fn *ir.Name
@@ -1877,10 +1878,10 @@ func heapAllocReason(n ir.Node) string {
 		return "too large for stack"
 	}
 
-	if n.Op() == ir.OCLOSURE && closureType(n.(*ir.ClosureExpr)).Size() >= ir.MaxImplicitStackVarSize {
+	if n.Op() == ir.OCLOSURE && typecheck.ClosureType(n.(*ir.ClosureExpr)).Size() >= ir.MaxImplicitStackVarSize {
 		return "too large for stack"
 	}
-	if n.Op() == ir.OCALLPART && partialCallType(n.(*ir.CallPartExpr)).Size() >= ir.MaxImplicitStackVarSize {
+	if n.Op() == ir.OCALLPART && typecheck.PartialCallType(n.(*ir.CallPartExpr)).Size() >= ir.MaxImplicitStackVarSize {
 		return "too large for stack"
 	}
 
@@ -1992,8 +1993,8 @@ func moveToHeap(n *ir.Name) {
 
 	// Allocate a local stack variable to hold the pointer to the heap copy.
 	// temp will add it to the function declaration list automatically.
-	heapaddr := temp(types.NewPtr(n.Type()))
-	heapaddr.SetSym(lookup("&" + n.Sym().Name))
+	heapaddr := typecheck.Temp(types.NewPtr(n.Type()))
+	heapaddr.SetSym(typecheck.Lookup("&" + n.Sym().Name))
 	heapaddr.SetPos(n.Pos())
 
 	// Unset AutoTemp to persist the &foo variable name through SSA to
@@ -2013,7 +2014,7 @@ func moveToHeap(n *ir.Name) {
 		// Preserve a copy so we can still write code referring to the original,
 		// and substitute that copy into the function declaration list
 		// so that analyses of the local (on-stack) variables use it.
-		stackcopy := NewName(n.Sym())
+		stackcopy := typecheck.NewName(n.Sym())
 		stackcopy.SetType(n.Type())
 		stackcopy.SetFrameOffset(n.FrameOffset())
 		stackcopy.Class_ = n.Class_
diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index 2855f815be..a414962431 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -7,9 +7,9 @@ package gc
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/bio"
-	"cmd/internal/src"
 	"fmt"
 	"go/constant"
 )
@@ -21,54 +21,16 @@ func exportf(bout *bio.Writer, format string, args ...interface{}) {
 	}
 }
 
-// exportsym marks n for export (or reexport).
-func exportsym(n *ir.Name) {
-	if n.Sym().OnExportList() {
-		return
-	}
-	n.Sym().SetOnExportList(true)
-
-	if base.Flag.E != 0 {
-		fmt.Printf("export symbol %v\n", n.Sym())
-	}
-
-	Target.Exports = append(Target.Exports, n)
-}
-
-func initname(s string) bool {
-	return s == "init"
-}
-
-func autoexport(n *ir.Name, ctxt ir.Class) {
-	if n.Sym().Pkg != types.LocalPkg {
-		return
-	}
-	if (ctxt != ir.PEXTERN && ctxt != ir.PFUNC) || dclcontext != ir.PEXTERN {
-		return
-	}
-	if n.Type() != nil && n.Type().IsKind(types.TFUNC) && ir.IsMethod(n) {
-		return
-	}
-
-	if types.IsExported(n.Sym().Name) || initname(n.Sym().Name) {
-		exportsym(n)
-	}
-	if base.Flag.AsmHdr != "" && !n.Sym().Asm() {
-		n.Sym().SetAsm(true)
-		Target.Asms = append(Target.Asms, n)
-	}
-}
-
 func dumpexport(bout *bio.Writer) {
 	p := &exporter{marked: make(map[*types.Type]bool)}
-	for _, n := range Target.Exports {
+	for _, n := range typecheck.Target.Exports {
 		p.markObject(n)
 	}
 
 	// The linker also looks for the $$ marker - use char after $$ to distinguish format.
 	exportf(bout, "\n$$B\n") // indicate binary export format
 	off := bout.Offset()
-	iexport(bout.Writer)
+	typecheck.WriteExports(bout.Writer)
 	size := bout.Offset() - off
 	exportf(bout, "\n$$\n")
 
@@ -77,78 +39,13 @@ func dumpexport(bout *bio.Writer) {
 	}
 }
 
-func importsym(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op ir.Op, ctxt ir.Class) *ir.Name {
-	if n := s.PkgDef(); n != nil {
-		base.Fatalf("importsym of symbol that already exists: %v", n)
-	}
-
-	n := ir.NewDeclNameAt(pos, op, s)
-	n.Class_ = ctxt // TODO(mdempsky): Move this into NewDeclNameAt too?
-	s.SetPkgDef(n)
-	s.Importdef = ipkg
-	return n
-}
-
-// importtype returns the named type declared by symbol s.
-// If no such type has been declared yet, a forward declaration is returned.
-// ipkg is the package being imported
-func importtype(ipkg *types.Pkg, pos src.XPos, s *types.Sym) *ir.Name {
-	n := importsym(ipkg, pos, s, ir.OTYPE, ir.PEXTERN)
-	n.SetType(types.NewNamed(n))
-	return n
-}
-
-// importobj declares symbol s as an imported object representable by op.
-// ipkg is the package being imported
-func importobj(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op ir.Op, ctxt ir.Class, t *types.Type) *ir.Name {
-	n := importsym(ipkg, pos, s, op, ctxt)
-	n.SetType(t)
-	if ctxt == ir.PFUNC {
-		n.Sym().SetFunc(true)
-	}
-	return n
-}
-
-// importconst declares symbol s as an imported constant with type t and value val.
-// ipkg is the package being imported
-func importconst(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type, val constant.Value) *ir.Name {
-	n := importobj(ipkg, pos, s, ir.OLITERAL, ir.PEXTERN, t)
-	n.SetVal(val)
-	return n
-}
-
-// importfunc declares symbol s as an imported function with type t.
-// ipkg is the package being imported
-func importfunc(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) *ir.Name {
-	n := importobj(ipkg, pos, s, ir.ONAME, ir.PFUNC, t)
-
-	fn := ir.NewFunc(pos)
-	fn.SetType(t)
-	n.SetFunc(fn)
-	fn.Nname = n
-
-	return n
-}
-
-// importvar declares symbol s as an imported variable with type t.
-// ipkg is the package being imported
-func importvar(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) *ir.Name {
-	return importobj(ipkg, pos, s, ir.ONAME, ir.PEXTERN, t)
-}
-
-// importalias declares symbol s as an imported type alias with type t.
-// ipkg is the package being imported
-func importalias(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) *ir.Name {
-	return importobj(ipkg, pos, s, ir.OTYPE, ir.PEXTERN, t)
-}
-
 func dumpasmhdr() {
 	b, err := bio.Create(base.Flag.AsmHdr)
 	if err != nil {
 		base.Fatalf("%v", err)
 	}
 	fmt.Fprintf(b, "// generated by compile -asmhdr from package %s\n\n", types.LocalPkg.Name)
-	for _, n := range Target.Asms {
+	for _, n := range typecheck.Target.Asms {
 		if n.Sym().IsBlank() {
 			continue
 		}
@@ -176,3 +73,83 @@ func dumpasmhdr() {
 
 	b.Close()
 }
+
+type exporter struct {
+	marked map[*types.Type]bool // types already seen by markType
+}
+
+// markObject visits a reachable object.
+func (p *exporter) markObject(n ir.Node) {
+	if n.Op() == ir.ONAME {
+		n := n.(*ir.Name)
+		if n.Class_ == ir.PFUNC {
+			inlFlood(n, typecheck.Export)
+		}
+	}
+
+	p.markType(n.Type())
+}
+
+// markType recursively visits types reachable from t to identify
+// functions whose inline bodies may be needed.
+func (p *exporter) markType(t *types.Type) {
+	if p.marked[t] {
+		return
+	}
+	p.marked[t] = true
+
+	// If this is a named type, mark all of its associated
+	// methods. Skip interface types because t.Methods contains
+	// only their unexpanded method set (i.e., exclusive of
+	// interface embeddings), and the switch statement below
+	// handles their full method set.
+	if t.Sym() != nil && t.Kind() != types.TINTER {
+		for _, m := range t.Methods().Slice() {
+			if types.IsExported(m.Sym.Name) {
+				p.markObject(ir.AsNode(m.Nname))
+			}
+		}
+	}
+
+	// Recursively mark any types that can be produced given a
+	// value of type t: dereferencing a pointer; indexing or
+	// iterating over an array, slice, or map; receiving from a
+	// channel; accessing a struct field or interface method; or
+	// calling a function.
+	//
+	// Notably, we don't mark function parameter types, because
+	// the user already needs some way to construct values of
+	// those types.
+	switch t.Kind() {
+	case types.TPTR, types.TARRAY, types.TSLICE:
+		p.markType(t.Elem())
+
+	case types.TCHAN:
+		if t.ChanDir().CanRecv() {
+			p.markType(t.Elem())
+		}
+
+	case types.TMAP:
+		p.markType(t.Key())
+		p.markType(t.Elem())
+
+	case types.TSTRUCT:
+		for _, f := range t.FieldSlice() {
+			if types.IsExported(f.Sym.Name) || f.Embedded != 0 {
+				p.markType(f.Type)
+			}
+		}
+
+	case types.TFUNC:
+		for _, f := range t.Results().FieldSlice() {
+			p.markType(f.Type)
+		}
+
+	case types.TINTER:
+		for _, f := range t.FieldSlice() {
+			if types.IsExported(f.Sym.Name) {
+				p.markType(f.Type)
+			}
+		}
+	}
+}
diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
deleted file mode 100644
index 1084ff883f..0000000000
--- a/src/cmd/compile/internal/gc/gen.go
+++ /dev/null
@@ -1,76 +0,0 @@
-// Copyright 2009 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 gc
-
-import (
-	"cmd/compile/internal/base"
-	"cmd/compile/internal/ir"
-	"cmd/compile/internal/types"
-	"cmd/internal/obj"
-	"cmd/internal/src"
-	"strconv"
-)
-
-// sysfunc looks up Go function name in package runtime. This function
-// must follow the internal calling convention.
-func sysfunc(name string) *obj.LSym {
-	s := ir.Pkgs.Runtime.Lookup(name)
-	s.SetFunc(true)
-	return s.Linksym()
-}
-
-// sysvar looks up a variable (or assembly function) name in package
-// runtime. If this is a function, it may have a special calling
-// convention.
-func sysvar(name string) *obj.LSym {
-	return ir.Pkgs.Runtime.Lookup(name).Linksym()
-}
-
-// autotmpname returns the name for an autotmp variable numbered n.
-func autotmpname(n int) string {
-	// Give each tmp a different name so that they can be registerized.
-	// Add a preceding . to avoid clashing with legal names.
-	const prefix = ".autotmp_"
-	// Start with a buffer big enough to hold a large n.
-	b := []byte(prefix + "      ")[:len(prefix)]
-	b = strconv.AppendInt(b, int64(n), 10)
-	return types.InternString(b)
-}
-
-// make a new Node off the books
-func tempAt(pos src.XPos, curfn *ir.Func, t *types.Type) *ir.Name {
-	if curfn == nil {
-		base.Fatalf("no curfn for tempAt")
-	}
-	if curfn.Op() == ir.OCLOSURE {
-		ir.Dump("tempAt", curfn)
-		base.Fatalf("adding tempAt to wrong closure function")
-	}
-	if t == nil {
-		base.Fatalf("tempAt called with nil type")
-	}
-
-	s := &types.Sym{
-		Name: autotmpname(len(curfn.Dcl)),
-		Pkg:  types.LocalPkg,
-	}
-	n := ir.NewNameAt(pos, s)
-	s.Def = n
-	n.SetType(t)
-	n.Class_ = ir.PAUTO
-	n.SetEsc(ir.EscNever)
-	n.Curfn = curfn
-	n.SetUsed(true)
-	n.SetAutoTemp(true)
-	curfn.Dcl = append(curfn.Dcl, n)
-
-	types.CalcSize(t)
-
-	return n
-}
-
-func temp(t *types.Type) *ir.Name {
-	return tempAt(base.Pos, ir.CurFunc, t)
-}
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index a2587b3361..7648e910d5 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -5,7 +5,6 @@
 package gc
 
 import (
-	"cmd/compile/internal/ir"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -14,37 +13,13 @@ import (
 
 var pragcgobuf [][]string
 
-var decldepth int32
-
-var inimport bool // set during import
-
 var zerosize int64
 
-var (
-	okforeq    [types.NTYPE]bool
-	okforadd   [types.NTYPE]bool
-	okforand   [types.NTYPE]bool
-	okfornone  [types.NTYPE]bool
-	okforbool  [types.NTYPE]bool
-	okforcap   [types.NTYPE]bool
-	okforlen   [types.NTYPE]bool
-	okforarith [types.NTYPE]bool
-)
-
-var (
-	okfor [ir.OEND][]bool
-	iscmp [ir.OEND]bool
-)
-
 var (
 	funcsymsmu sync.Mutex // protects funcsyms and associated package lookups (see func funcsym)
 	funcsyms   []*types.Sym
 )
 
-var dclcontext ir.Class // PEXTERN/PAUTO
-
-var typecheckok bool
-
 // interface to back end
 
 type Arch struct {
diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go
index 6ea9b354ab..f24687ec0f 100644
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ b/src/cmd/compile/internal/gc/gsubr.go
@@ -34,6 +34,7 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
@@ -196,11 +197,11 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 
 	// Q: is this needed?
 	savepos := base.Pos
-	savedclcontext := dclcontext
+	savedclcontext := typecheck.DeclContext
 	savedcurfn := ir.CurFunc
 
 	base.Pos = base.AutogeneratedPos
-	dclcontext = ir.PEXTERN
+	typecheck.DeclContext = ir.PEXTERN
 
 	// At the moment we don't support wrapping a method, we'd need machinery
 	// below to handle the receiver. Panic if we see this scenario.
@@ -213,11 +214,11 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 	var noReceiver *ir.Field
 	tfn := ir.NewFuncType(base.Pos,
 		noReceiver,
-		structargs(ft.Params(), true),
-		structargs(ft.Results(), false))
+		typecheck.NewFuncParams(ft.Params(), true),
+		typecheck.NewFuncParams(ft.Results(), false))
 
 	// Reuse f's types.Sym to create a new ODCLFUNC/function.
-	fn := dclfunc(f.Nname.Sym(), tfn)
+	fn := typecheck.DeclFunc(f.Nname.Sym(), tfn)
 	fn.SetDupok(true)
 	fn.SetWrapper(true) // ignore frame for panic+recover matching
 
@@ -281,22 +282,22 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 	}
 	fn.Body.Append(tail)
 
-	funcbody()
+	typecheck.FinishFuncBody()
 	if base.Debug.DclStack != 0 {
 		types.CheckDclstack()
 	}
 
-	typecheckFunc(fn)
+	typecheck.Func(fn)
 	ir.CurFunc = fn
-	typecheckslice(fn.Body, ctxStmt)
+	typecheck.Stmts(fn.Body)
 
 	escapeFuncs([]*ir.Func{fn}, false)
 
-	Target.Decls = append(Target.Decls, fn)
+	typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
 
 	// Restore previous context.
 	base.Pos = savepos
-	dclcontext = savedclcontext
+	typecheck.DeclContext = savedclcontext
 	ir.CurFunc = savedcurfn
 }
 
diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index f22e49efba..ed61c11522 100644
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 )
@@ -17,12 +18,8 @@ import (
 // the name, normally "pkg.init", is altered to "pkg.init.0".
 var renameinitgen int
 
-// Function collecting autotmps generated during typechecking,
-// to be included in the package-level init function.
-var initTodo = ir.NewFunc(base.Pos)
-
 func renameinit() *types.Sym {
-	s := lookupN("init.", renameinitgen)
+	s := typecheck.LookupNum("init.", renameinitgen)
 	renameinitgen++
 	return s
 }
@@ -34,14 +31,14 @@ func renameinit() *types.Sym {
 //   2) Initialize all the variables that have initializers.
 //   3) Run any init functions.
 func fninit() *ir.Name {
-	nf := initOrder(Target.Decls)
+	nf := initOrder(typecheck.Target.Decls)
 
 	var deps []*obj.LSym // initTask records for packages the current package depends on
 	var fns []*obj.LSym  // functions to call for package initialization
 
 	// Find imported packages with init tasks.
-	for _, pkg := range Target.Imports {
-		n := resolve(ir.NewIdent(base.Pos, pkg.Lookup(".inittask")))
+	for _, pkg := range typecheck.Target.Imports {
+		n := typecheck.Resolve(ir.NewIdent(base.Pos, pkg.Lookup(".inittask")))
 		if n.Op() == ir.ONONAME {
 			continue
 		}
@@ -54,34 +51,34 @@ func fninit() *ir.Name {
 	// Make a function that contains all the initialization statements.
 	if len(nf) > 0 {
 		base.Pos = nf[0].Pos() // prolog/epilog gets line number of first init stmt
-		initializers := lookup("init")
-		fn := dclfunc(initializers, ir.NewFuncType(base.Pos, nil, nil, nil))
-		for _, dcl := range initTodo.Dcl {
+		initializers := typecheck.Lookup("init")
+		fn := typecheck.DeclFunc(initializers, ir.NewFuncType(base.Pos, nil, nil, nil))
+		for _, dcl := range typecheck.InitTodoFunc.Dcl {
 			dcl.Curfn = fn
 		}
-		fn.Dcl = append(fn.Dcl, initTodo.Dcl...)
-		initTodo.Dcl = nil
+		fn.Dcl = append(fn.Dcl, typecheck.InitTodoFunc.Dcl...)
+		typecheck.InitTodoFunc.Dcl = nil
 
 		fn.Body.Set(nf)
-		funcbody()
+		typecheck.FinishFuncBody()
 
-		typecheckFunc(fn)
+		typecheck.Func(fn)
 		ir.CurFunc = fn
-		typecheckslice(nf, ctxStmt)
+		typecheck.Stmts(nf)
 		ir.CurFunc = nil
-		Target.Decls = append(Target.Decls, fn)
+		typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
 		fns = append(fns, initializers.Linksym())
 	}
-	if initTodo.Dcl != nil {
+	if typecheck.InitTodoFunc.Dcl != nil {
 		// We only generate temps using initTodo if there
 		// are package-scope initialization statements, so
 		// something's weird if we get here.
 		base.Fatalf("initTodo still has declarations")
 	}
-	initTodo = nil
+	typecheck.InitTodoFunc = nil
 
 	// Record user init functions.
-	for _, fn := range Target.Inits {
+	for _, fn := range typecheck.Target.Inits {
 		// Skip init functions with empty bodies.
 		if len(fn.Body) == 1 {
 			if stmt := fn.Body[0]; stmt.Op() == ir.OBLOCK && len(stmt.(*ir.BlockStmt).List) == 0 {
@@ -96,8 +93,8 @@ func fninit() *ir.Name {
 	}
 
 	// Make an .inittask structure.
-	sym := lookup(".inittask")
-	task := NewName(sym)
+	sym := typecheck.Lookup(".inittask")
+	task := typecheck.NewName(sym)
 	task.SetType(types.Types[types.TUINT8]) // fake type
 	task.Class_ = ir.PEXTERN
 	sym.Def = task
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index b9e19da43f..9cf23caf0e 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -30,6 +30,7 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/src"
@@ -54,7 +55,7 @@ const (
 
 func InlinePackage() {
 	// Find functions that can be inlined and clone them before walk expands them.
-	ir.VisitFuncsBottomUp(Target.Decls, func(list []*ir.Func, recursive bool) {
+	ir.VisitFuncsBottomUp(typecheck.Target.Decls, func(list []*ir.Func, recursive bool) {
 		numfns := numNonClosures(list)
 		for _, n := range list {
 			if !recursive || numfns > 1 {
@@ -72,63 +73,6 @@ func InlinePackage() {
 	})
 }
 
-// Get the function's package. For ordinary functions it's on the ->sym, but for imported methods
-// the ->sym can be re-used in the local package, so peel it off the receiver's type.
-func fnpkg(fn *ir.Name) *types.Pkg {
-	if ir.IsMethod(fn) {
-		// method
-		rcvr := fn.Type().Recv().Type
-
-		if rcvr.IsPtr() {
-			rcvr = rcvr.Elem()
-		}
-		if rcvr.Sym() == nil {
-			base.Fatalf("receiver with no sym: [%v] %L  (%v)", fn.Sym(), fn, rcvr)
-		}
-		return rcvr.Sym().Pkg
-	}
-
-	// non-method
-	return fn.Sym().Pkg
-}
-
-// Lazy typechecking of imported bodies. For local functions, caninl will set ->typecheck
-// because they're a copy of an already checked body.
-func typecheckinl(fn *ir.Func) {
-	lno := ir.SetPos(fn.Nname)
-
-	expandInline(fn)
-
-	// typecheckinl is only for imported functions;
-	// their bodies may refer to unsafe as long as the package
-	// was marked safe during import (which was checked then).
-	// the ->inl of a local function has been typechecked before caninl copied it.
-	pkg := fnpkg(fn.Nname)
-
-	if pkg == types.LocalPkg || pkg == nil {
-		return // typecheckinl on local function
-	}
-
-	if base.Flag.LowerM > 2 || base.Debug.Export != 0 {
-		fmt.Printf("typecheck import [%v] %L { %v }\n", fn.Sym(), fn, ir.Nodes(fn.Inl.Body))
-	}
-
-	savefn := ir.CurFunc
-	ir.CurFunc = fn
-	typecheckslice(fn.Inl.Body, ctxStmt)
-	ir.CurFunc = savefn
-
-	// During expandInline (which imports fn.Func.Inl.Body),
-	// declarations are added to fn.Func.Dcl by funcHdr(). Move them
-	// to fn.Func.Inl.Dcl for consistency with how local functions
-	// behave. (Append because typecheckinl may be called multiple
-	// times.)
-	fn.Inl.Dcl = append(fn.Inl.Dcl, fn.Dcl...)
-	fn.Dcl = nil
-
-	base.Pos = lno
-}
-
 // Caninl determines whether fn is inlineable.
 // If so, caninl saves fn->nbody in fn->inl and substitutes it with a copy.
 // fn and ->nbody will already have been typechecked.
@@ -270,7 +214,7 @@ func inlFlood(n *ir.Name, exportsym func(*ir.Name)) {
 	}
 	fn.SetExportInline(true)
 
-	typecheckinl(fn)
+	typecheck.ImportedBody(fn)
 
 	// Recursively identify all referenced functions for
 	// reexport. We want to include even non-called functions,
@@ -601,7 +545,7 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.No
 			as.Rhs.Set(inlconv2list(as.Rhs[0].(*ir.InlinedCallExpr)))
 			as.SetOp(ir.OAS2)
 			as.SetTypecheck(0)
-			n = typecheck(as, ctxStmt)
+			n = typecheck.Stmt(as)
 		}
 	}
 
@@ -768,7 +712,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 		inlMap[fn] = false
 	}()
 	if base.Debug.TypecheckInl == 0 {
-		typecheckinl(fn)
+		typecheck.ImportedBody(fn)
 	}
 
 	// We have a function node, and it has an inlineable body.
@@ -824,21 +768,21 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 			}
 
 			if v.Byval() {
-				iv := typecheck(inlvar(v), ctxExpr)
+				iv := typecheck.Expr(inlvar(v))
 				ninit.Append(ir.NewDecl(base.Pos, ir.ODCL, iv))
-				ninit.Append(typecheck(ir.NewAssignStmt(base.Pos, iv, o), ctxStmt))
+				ninit.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, iv, o)))
 				inlvars[v] = iv
 			} else {
-				addr := NewName(lookup("&" + v.Sym().Name))
+				addr := typecheck.NewName(typecheck.Lookup("&" + v.Sym().Name))
 				addr.SetType(types.NewPtr(v.Type()))
-				ia := typecheck(inlvar(addr), ctxExpr)
+				ia := typecheck.Expr(inlvar(addr))
 				ninit.Append(ir.NewDecl(base.Pos, ir.ODCL, ia))
-				ninit.Append(typecheck(ir.NewAssignStmt(base.Pos, ia, nodAddr(o)), ctxStmt))
+				ninit.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, ia, typecheck.NodAddr(o))))
 				inlvars[addr] = ia
 
 				// When capturing by reference, all occurrence of the captured var
 				// must be substituted with dereference of the temporary address
-				inlvars[v] = typecheck(ir.NewStarExpr(base.Pos, ia), ctxExpr)
+				inlvars[v] = typecheck.Expr(ir.NewStarExpr(base.Pos, ia))
 			}
 		}
 	}
@@ -857,7 +801,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 			// nothing should have moved to the heap yet.
 			base.Fatalf("impossible: %v", ln)
 		}
-		inlf := typecheck(inlvar(ln), ctxExpr)
+		inlf := typecheck.Expr(inlvar(ln))
 		inlvars[ln] = inlf
 		if base.Flag.GenDwarfInl > 0 {
 			if ln.Class_ == ir.PPARAM {
@@ -889,7 +833,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 		if n := ir.AsNode(t.Nname); n != nil && !ir.IsBlank(n) && !strings.HasPrefix(n.Sym().Name, "~r") {
 			n := n.(*ir.Name)
 			m = inlvar(n)
-			m = typecheck(m, ctxExpr)
+			m = typecheck.Expr(m)
 			inlvars[n] = m
 			delayretvars = false // found a named result parameter
 		} else {
@@ -951,7 +895,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 		vas = ir.NewAssignStmt(base.Pos, nil, nil)
 		vas.X = inlParam(param, vas, inlvars)
 		if len(varargs) == 0 {
-			vas.Y = nodnil()
+			vas.Y = typecheck.NodNil()
 			vas.Y.SetType(param.Type)
 		} else {
 			lit := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(param.Type).(ir.Ntype), nil)
@@ -961,11 +905,11 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 	}
 
 	if len(as.Rhs) != 0 {
-		ninit.Append(typecheck(as, ctxStmt))
+		ninit.Append(typecheck.Stmt(as))
 	}
 
 	if vas != nil {
-		ninit.Append(typecheck(vas, ctxStmt))
+		ninit.Append(typecheck.Stmt(vas))
 	}
 
 	if !delayretvars {
@@ -973,11 +917,11 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 		for _, n := range retvars {
 			ninit.Append(ir.NewDecl(base.Pos, ir.ODCL, n))
 			ras := ir.NewAssignStmt(base.Pos, n, nil)
-			ninit.Append(typecheck(ras, ctxStmt))
+			ninit.Append(typecheck.Stmt(ras))
 		}
 	}
 
-	retlabel := autolabel(".i")
+	retlabel := typecheck.AutoLabel(".i")
 
 	inlgen++
 
@@ -1021,7 +965,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 	lab := ir.NewLabelStmt(base.Pos, retlabel)
 	body = append(body, lab)
 
-	typecheckslice(body, ctxStmt)
+	typecheck.Stmts(body)
 
 	if base.Flag.GenDwarfInl > 0 {
 		for _, v := range inlfvars {
@@ -1061,7 +1005,7 @@ func inlvar(var_ ir.Node) ir.Node {
 		fmt.Printf("inlvar %+v\n", var_)
 	}
 
-	n := NewName(var_.Sym())
+	n := typecheck.NewName(var_.Sym())
 	n.SetType(var_.Type())
 	n.Class_ = ir.PAUTO
 	n.SetUsed(true)
@@ -1074,7 +1018,7 @@ func inlvar(var_ ir.Node) ir.Node {
 
 // Synthesize a variable to store the inlined function's results in.
 func retvar(t *types.Field, i int) ir.Node {
-	n := NewName(lookupN("~R", i))
+	n := typecheck.NewName(typecheck.LookupNum("~R", i))
 	n.SetType(t.Type)
 	n.Class_ = ir.PAUTO
 	n.SetUsed(true)
@@ -1086,7 +1030,7 @@ func retvar(t *types.Field, i int) ir.Node {
 // Synthesize a variable to store the inlined function's arguments
 // when they come from a multiple return call.
 func argvar(t *types.Type, i int) ir.Node {
-	n := NewName(lookupN("~arg", i))
+	n := typecheck.NewName(typecheck.LookupNum("~arg", i))
 	n.SetType(t.Elem())
 	n.Class_ = ir.PAUTO
 	n.SetUsed(true)
@@ -1198,10 +1142,10 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 				}
 			}
 
-			init = append(init, typecheck(as, ctxStmt))
+			init = append(init, typecheck.Stmt(as))
 		}
 		init = append(init, ir.NewBranchStmt(base.Pos, ir.OGOTO, subst.retlabel))
-		typecheckslice(init, ctxStmt)
+		typecheck.Stmts(init)
 		return ir.NewBlockStmt(base.Pos, init)
 
 	case ir.OGOTO:
@@ -1210,7 +1154,7 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 		m.SetPos(subst.updatedPos(m.Pos()))
 		m.PtrInit().Set(nil)
 		p := fmt.Sprintf("%s·%d", n.Label.Name, inlgen)
-		m.Label = lookup(p)
+		m.Label = typecheck.Lookup(p)
 		return m
 
 	case ir.OLABEL:
@@ -1219,7 +1163,7 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 		m.SetPos(subst.updatedPos(m.Pos()))
 		m.PtrInit().Set(nil)
 		p := fmt.Sprintf("%s·%d", n.Label.Name, inlgen)
-		m.Label = lookup(p)
+		m.Label = typecheck.Lookup(p)
 		return m
 	}
 
@@ -1284,7 +1228,7 @@ func devirtualizeCall(call *ir.CallExpr) {
 
 	dt := ir.NewTypeAssertExpr(sel.Pos(), sel.X, nil)
 	dt.SetType(typ)
-	x := typecheck(ir.NewSelectorExpr(sel.Pos(), ir.OXDOT, dt, sel.Sel), ctxExpr|ctxCallee)
+	x := typecheck.Callee(ir.NewSelectorExpr(sel.Pos(), ir.OXDOT, dt, sel.Sel))
 	switch x.Op() {
 	case ir.ODOTMETH:
 		x := x.(*ir.SelectorExpr)
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 69ec5c8f2f..b98d1f2e10 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -13,6 +13,7 @@ import (
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/bio"
 	"cmd/internal/dwarf"
@@ -49,9 +50,6 @@ func hidePanic() {
 	}
 }
 
-// Target is the package being compiled.
-var Target *ir.Package
-
 // Main parses flags and Go source files specified in the command-line
 // arguments, type-checks the parsed Go package, compiles functions to machine
 // code, and finally writes the compiled package definition to disk.
@@ -197,18 +195,18 @@ func Main(archInit func(*Arch)) {
 		return typenamesym(t).Linksym()
 	}
 
-	Target = new(ir.Package)
+	typecheck.Target = new(ir.Package)
 
-	NeedFuncSym = makefuncsym
-	NeedITab = func(t, iface *types.Type) { itabname(t, iface) }
-	NeedRuntimeType = addsignat // TODO(rsc): typenamesym for lock?
+	typecheck.NeedFuncSym = makefuncsym
+	typecheck.NeedITab = func(t, iface *types.Type) { itabname(t, iface) }
+	typecheck.NeedRuntimeType = addsignat // TODO(rsc): typenamesym for lock?
 
 	base.AutogeneratedPos = makePos(src.NewFileBase("<autogenerated>", "<autogenerated>"), 1, 0)
 
 	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
 		return typenamesym(t).Linksym()
 	}
-	TypecheckInit()
+	typecheck.Init()
 
 	// Parse input.
 	base.Timer.Start("fe", "parse")
@@ -219,7 +217,7 @@ func Main(archInit func(*Arch)) {
 	recordPackageName()
 
 	// Typecheck.
-	TypecheckPackage()
+	typecheck.Package()
 
 	// With all user code typechecked, it's now safe to verify unused dot imports.
 	checkDotImports()
@@ -227,7 +225,7 @@ func Main(archInit func(*Arch)) {
 
 	// Build init task.
 	if initTask := fninit(); initTask != nil {
-		exportsym(initTask)
+		typecheck.Export(initTask)
 	}
 
 	// Inlining
@@ -237,7 +235,7 @@ func Main(archInit func(*Arch)) {
 	}
 
 	// Devirtualize.
-	for _, n := range Target.Decls {
+	for _, n := range typecheck.Target.Decls {
 		if n.Op() == ir.ODCLFUNC {
 			devirtualize(n.(*ir.Func))
 		}
@@ -253,7 +251,7 @@ func Main(archInit func(*Arch)) {
 	// Large values are also moved off stack in escape analysis;
 	// because large values may contain pointers, it must happen early.
 	base.Timer.Start("fe", "escapes")
-	escapes(Target.Decls)
+	escapes(typecheck.Target.Decls)
 
 	// Collect information for go:nowritebarrierrec
 	// checking. This must happen before transformclosure.
@@ -267,7 +265,7 @@ func Main(archInit func(*Arch)) {
 	// This needs to happen before walk, because closures must be transformed
 	// before walk reaches a call of a closure.
 	base.Timer.Start("fe", "xclosures")
-	for _, n := range Target.Decls {
+	for _, n := range typecheck.Target.Decls {
 		if n.Op() == ir.ODCLFUNC {
 			n := n.(*ir.Func)
 			if n.OClosure != nil {
@@ -292,8 +290,8 @@ func Main(archInit func(*Arch)) {
 	// Don't use range--walk can add functions to Target.Decls.
 	base.Timer.Start("be", "compilefuncs")
 	fcount := int64(0)
-	for i := 0; i < len(Target.Decls); i++ {
-		n := Target.Decls[i]
+	for i := 0; i < len(typecheck.Target.Decls); i++ {
+		n := typecheck.Target.Decls[i]
 		if n.Op() == ir.ODCLFUNC {
 			funccompile(n.(*ir.Func))
 			fcount++
@@ -327,7 +325,7 @@ func Main(archInit func(*Arch)) {
 	}
 
 	CheckLargeStacks()
-	CheckFuncStack()
+	typecheck.CheckFuncStack()
 
 	if len(compilequeue) != 0 {
 		base.Fatalf("%d uncompiled functions", len(compilequeue))
@@ -363,7 +361,7 @@ func CheckLargeStacks() {
 func cgoSymABIs() {
 	// The linker expects an ABI0 wrapper for all cgo-exported
 	// functions.
-	for _, prag := range Target.CgoPragmas {
+	for _, prag := range typecheck.Target.CgoPragmas {
 		switch prag[0] {
 		case "cgo_export_static", "cgo_export_dynamic":
 			if symabiRefs == nil {
@@ -581,33 +579,6 @@ func findpkg(name string) (file string, ok bool) {
 	return "", false
 }
 
-// loadsys loads the definitions for the low-level runtime functions,
-// so that the compiler can generate calls to them,
-// but does not make them visible to user code.
-func loadsys() {
-	types.Block = 1
-
-	inimport = true
-	typecheckok = true
-
-	typs := runtimeTypes()
-	for _, d := range &runtimeDecls {
-		sym := ir.Pkgs.Runtime.Lookup(d.name)
-		typ := typs[d.typ]
-		switch d.tag {
-		case funcTag:
-			importfunc(ir.Pkgs.Runtime, src.NoXPos, sym, typ)
-		case varTag:
-			importvar(ir.Pkgs.Runtime, src.NoXPos, sym, typ)
-		default:
-			base.Fatalf("unhandled declaration tag %v", d.tag)
-		}
-	}
-
-	typecheckok = false
-	inimport = false
-}
-
 // myheight tracks the local package's height based on packages
 // imported so far.
 var myheight int
@@ -776,7 +747,7 @@ func importfile(f constant.Value) *types.Pkg {
 			base.Errorf("import %s: unexpected package format byte: %v", file, c)
 			base.ErrorExit()
 		}
-		fingerprint = iimport(importpkg, imp)
+		fingerprint = typecheck.ReadImports(importpkg, imp)
 
 	default:
 		base.Errorf("no import in %q", path_)
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index c83b60dcd4..3e8703f050 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -19,6 +19,7 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/syntax"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/objabi"
 	"cmd/internal/src"
@@ -160,7 +161,7 @@ type noder struct {
 func (p *noder) funcBody(fn *ir.Func, block *syntax.BlockStmt) {
 	oldScope := p.scope
 	p.scope = 0
-	funchdr(fn)
+	typecheck.StartFuncBody(fn)
 
 	if block != nil {
 		body := p.stmts(block.List)
@@ -173,7 +174,7 @@ func (p *noder) funcBody(fn *ir.Func, block *syntax.BlockStmt) {
 		fn.Endlineno = base.Pos
 	}
 
-	funcbody()
+	typecheck.FinishFuncBody()
 	p.scope = oldScope
 }
 
@@ -261,7 +262,7 @@ func (p *noder) node() {
 		p.checkUnused(pragma)
 	}
 
-	Target.Decls = append(Target.Decls, p.decls(p.file.DeclList)...)
+	typecheck.Target.Decls = append(typecheck.Target.Decls, p.decls(p.file.DeclList)...)
 
 	base.Pos = src.NoXPos
 	clearImports()
@@ -273,7 +274,7 @@ func (p *noder) processPragmas() {
 			p.errorAt(l.pos, "//go:linkname only allowed in Go files that import \"unsafe\"")
 			continue
 		}
-		n := ir.AsNode(lookup(l.local).Def)
+		n := ir.AsNode(typecheck.Lookup(l.local).Def)
 		if n == nil || n.Op() != ir.ONAME {
 			// TODO(mdempsky): Change to p.errorAt before Go 1.17 release.
 			// base.WarnfAt(p.makeXPos(l.pos), "//go:linkname must refer to declared function or variable (will be an error in Go 1.17)")
@@ -285,7 +286,7 @@ func (p *noder) processPragmas() {
 		}
 		n.Sym().Linkname = l.remote
 	}
-	Target.CgoPragmas = append(Target.CgoPragmas, p.pragcgobuf...)
+	typecheck.Target.CgoPragmas = append(typecheck.Target.CgoPragmas, p.pragcgobuf...)
 }
 
 func (p *noder) decls(decls []syntax.Decl) (l []ir.Node) {
@@ -342,7 +343,7 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
 	}
 
 	if !ipkg.Direct {
-		Target.Imports = append(Target.Imports, ipkg)
+		typecheck.Target.Imports = append(typecheck.Target.Imports, ipkg)
 	}
 	ipkg.Direct = true
 
@@ -350,7 +351,7 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
 	if imp.LocalPkgName != nil {
 		my = p.name(imp.LocalPkgName)
 	} else {
-		my = lookup(ipkg.Name)
+		my = typecheck.Lookup(ipkg.Name)
 	}
 
 	pack := ir.NewPkgName(p.pos(imp), my, ipkg)
@@ -366,7 +367,7 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
 		return
 	}
 	if my.Def != nil {
-		redeclare(pack.Pos(), my, "as imported package name")
+		typecheck.Redeclared(pack.Pos(), my, "as imported package name")
 	}
 	my.Def = pack
 	my.Lastlineno = pack.Pos()
@@ -401,7 +402,7 @@ func (p *noder) varDecl(decl *syntax.VarDecl) []ir.Node {
 	}
 
 	p.setlineno(decl)
-	return variter(names, typ, exprs)
+	return typecheck.DeclVars(names, typ, exprs)
 }
 
 // constState tracks state between constant specifiers within a
@@ -449,7 +450,7 @@ func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []ir.Node {
 		if decl.Values == nil {
 			v = ir.DeepCopy(n.Pos(), v)
 		}
-		declare(n, dclcontext)
+		typecheck.Declare(n, typecheck.DeclContext)
 
 		n.Ntype = typ
 		n.Defn = v
@@ -469,7 +470,7 @@ func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []ir.Node {
 
 func (p *noder) typeDecl(decl *syntax.TypeDecl) ir.Node {
 	n := p.declName(ir.OTYPE, decl.Name)
-	declare(n, dclcontext)
+	typecheck.Declare(n, typecheck.DeclContext)
 
 	// decl.Type may be nil but in that case we got a syntax error during parsing
 	typ := p.typeExprOrNil(decl.Type)
@@ -514,7 +515,7 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) ir.Node {
 			if len(t.Params) > 0 || len(t.Results) > 0 {
 				base.ErrorfAt(f.Pos(), "func init must have no arguments and no return values")
 			}
-			Target.Inits = append(Target.Inits, f)
+			typecheck.Target.Inits = append(typecheck.Target.Inits, f)
 		}
 
 		if types.LocalPkg.Name == "main" && name.Name == "main" {
@@ -541,7 +542,7 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) ir.Node {
 	}
 
 	if fun.Recv == nil {
-		declare(f.Nname, ir.PFUNC)
+		typecheck.Declare(f.Nname, ir.PFUNC)
 	}
 
 	p.funcBody(f, fun.Body)
@@ -704,7 +705,7 @@ func (p *noder) expr(expr syntax.Expr) ir.Node {
 			pos, op := p.pos(expr), p.unOp(expr.Op)
 			switch op {
 			case ir.OADDR:
-				return nodAddrAt(pos, x)
+				return typecheck.NodAddrAt(pos, x)
 			case ir.ODEREF:
 				return ir.NewStarExpr(pos, x)
 			}
@@ -950,7 +951,7 @@ func (p *noder) embedded(typ syntax.Expr) *ir.Field {
 	}
 
 	sym := p.packname(typ)
-	n := ir.NewField(p.pos(typ), lookup(sym.Name), importName(sym).(ir.Ntype), nil)
+	n := ir.NewField(p.pos(typ), typecheck.Lookup(sym.Name), importName(sym).(ir.Ntype), nil)
 	n.Embedded = true
 
 	if isStar {
@@ -1136,8 +1137,8 @@ func (p *noder) assignList(expr syntax.Expr, defn ir.Node, colas bool) []ir.Node
 		}
 
 		newOrErr = true
-		n := NewName(sym)
-		declare(n, dclcontext)
+		n := typecheck.NewName(sym)
+		typecheck.Declare(n, typecheck.DeclContext)
 		n.Defn = defn
 		defn.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, n))
 		res[i] = n
@@ -1245,8 +1246,8 @@ func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *ir.TypeSwitch
 			n.List.Set(p.exprList(clause.Cases))
 		}
 		if tswitch != nil && tswitch.Tag != nil {
-			nn := NewName(tswitch.Tag.Sym())
-			declare(nn, dclcontext)
+			nn := typecheck.NewName(tswitch.Tag.Sym())
+			typecheck.Declare(nn, typecheck.DeclContext)
 			n.Vars = []ir.Node{nn}
 			// keep track of the instances for reporting unused
 			nn.Defn = tswitch
@@ -1466,7 +1467,7 @@ var tokenForLitKind = [...]token.Token{
 }
 
 func (p *noder) name(name *syntax.Name) *types.Sym {
-	return lookup(name.Value)
+	return typecheck.Lookup(name.Value)
 }
 
 func (p *noder) mkname(name *syntax.Name) ir.Node {
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 372277552f..1b4ba50e6b 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/bio"
 	"cmd/internal/obj"
@@ -117,14 +118,14 @@ func dumpCompilerObj(bout *bio.Writer) {
 }
 
 func dumpdata() {
-	numExterns := len(Target.Externs)
-	numDecls := len(Target.Decls)
+	numExterns := len(typecheck.Target.Externs)
+	numDecls := len(typecheck.Target.Decls)
 
-	dumpglobls(Target.Externs)
+	dumpglobls(typecheck.Target.Externs)
 	dumpfuncsyms()
 	addptabs()
-	numExports := len(Target.Exports)
-	addsignats(Target.Externs)
+	numExports := len(typecheck.Target.Exports)
+	addsignats(typecheck.Target.Externs)
 	dumpsignats()
 	dumptabs()
 	numPTabs, numITabs := CountTabs()
@@ -140,22 +141,22 @@ func dumpdata() {
 	// In the typical case, we loop 0 or 1 times.
 	// It was not until issue 24761 that we found any code that required a loop at all.
 	for {
-		for i := numDecls; i < len(Target.Decls); i++ {
-			n := Target.Decls[i]
+		for i := numDecls; i < len(typecheck.Target.Decls); i++ {
+			n := typecheck.Target.Decls[i]
 			if n.Op() == ir.ODCLFUNC {
 				funccompile(n.(*ir.Func))
 			}
 		}
-		numDecls = len(Target.Decls)
+		numDecls = len(typecheck.Target.Decls)
 		compileFunctions()
 		dumpsignats()
-		if numDecls == len(Target.Decls) {
+		if numDecls == len(typecheck.Target.Decls) {
 			break
 		}
 	}
 
 	// Dump extra globals.
-	dumpglobls(Target.Externs[numExterns:])
+	dumpglobls(typecheck.Target.Externs[numExterns:])
 
 	if zerosize > 0 {
 		zero := ir.Pkgs.Map.Lookup("zero")
@@ -164,7 +165,7 @@ func dumpdata() {
 
 	addGCLocals()
 
-	if numExports != len(Target.Exports) {
+	if numExports != len(typecheck.Target.Exports) {
 		base.Fatalf("Target.Exports changed after compile functions loop")
 	}
 	newNumPTabs, newNumITabs := CountTabs()
@@ -179,11 +180,11 @@ func dumpdata() {
 func dumpLinkerObj(bout *bio.Writer) {
 	printObjHeader(bout)
 
-	if len(Target.CgoPragmas) != 0 {
+	if len(typecheck.Target.CgoPragmas) != 0 {
 		// write empty export section; must be before cgo section
 		fmt.Fprintf(bout, "\n$$\n\n$$\n\n")
 		fmt.Fprintf(bout, "\n$$  // cgo\n")
-		if err := json.NewEncoder(bout).Encode(Target.CgoPragmas); err != nil {
+		if err := json.NewEncoder(bout).Encode(typecheck.Target.CgoPragmas); err != nil {
 			base.Fatalf("serializing pragcgobuf: %v", err)
 		}
 		fmt.Fprintf(bout, "\n$$\n\n")
@@ -198,7 +199,7 @@ func addptabs() {
 	if !base.Ctxt.Flag_dynlink || types.LocalPkg.Name != "main" {
 		return
 	}
-	for _, exportn := range Target.Exports {
+	for _, exportn := range typecheck.Target.Exports {
 		s := exportn.Sym()
 		nn := ir.AsNode(s.Def)
 		if nn == nil {
@@ -474,7 +475,7 @@ func slicedata(pos src.XPos, s string) *ir.Name {
 	slicedataGen++
 	symname := fmt.Sprintf(".gobytes.%d", slicedataGen)
 	sym := types.LocalPkg.Lookup(symname)
-	symnode := NewName(sym)
+	symnode := typecheck.NewName(sym)
 	sym.Def = symnode
 
 	lsym := sym.Linksym()
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 3d35094a58..075bcea92c 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"fmt"
@@ -63,7 +64,7 @@ func order(fn *ir.Func) {
 
 // append typechecks stmt and appends it to out.
 func (o *Order) append(stmt ir.Node) {
-	o.out = append(o.out, typecheck(stmt, ctxStmt))
+	o.out = append(o.out, typecheck.Stmt(stmt))
 }
 
 // newTemp allocates a new temporary with the given type,
@@ -85,7 +86,7 @@ func (o *Order) newTemp(t *types.Type, clear bool) *ir.Name {
 		}
 	}
 	if v == nil {
-		v = temp(t)
+		v = typecheck.Temp(t)
 	}
 	if clear {
 		o.append(ir.NewAssignStmt(base.Pos, v, nil))
@@ -142,7 +143,7 @@ func (o *Order) cheapExpr(n ir.Node) ir.Node {
 		}
 		a := ir.SepCopy(n).(*ir.UnaryExpr)
 		a.X = l
-		return typecheck(a, ctxExpr)
+		return typecheck.Expr(a)
 	}
 
 	return o.copyExpr(n)
@@ -168,7 +169,7 @@ func (o *Order) safeExpr(n ir.Node) ir.Node {
 		}
 		a := ir.SepCopy(n).(*ir.UnaryExpr)
 		a.X = l
-		return typecheck(a, ctxExpr)
+		return typecheck.Expr(a)
 
 	case ir.ODOT:
 		n := n.(*ir.SelectorExpr)
@@ -178,7 +179,7 @@ func (o *Order) safeExpr(n ir.Node) ir.Node {
 		}
 		a := ir.SepCopy(n).(*ir.SelectorExpr)
 		a.X = l
-		return typecheck(a, ctxExpr)
+		return typecheck.Expr(a)
 
 	case ir.ODOTPTR:
 		n := n.(*ir.SelectorExpr)
@@ -188,7 +189,7 @@ func (o *Order) safeExpr(n ir.Node) ir.Node {
 		}
 		a := ir.SepCopy(n).(*ir.SelectorExpr)
 		a.X = l
-		return typecheck(a, ctxExpr)
+		return typecheck.Expr(a)
 
 	case ir.ODEREF:
 		n := n.(*ir.StarExpr)
@@ -198,7 +199,7 @@ func (o *Order) safeExpr(n ir.Node) ir.Node {
 		}
 		a := ir.SepCopy(n).(*ir.StarExpr)
 		a.X = l
-		return typecheck(a, ctxExpr)
+		return typecheck.Expr(a)
 
 	case ir.OINDEX, ir.OINDEXMAP:
 		n := n.(*ir.IndexExpr)
@@ -215,7 +216,7 @@ func (o *Order) safeExpr(n ir.Node) ir.Node {
 		a := ir.SepCopy(n).(*ir.IndexExpr)
 		a.X = l
 		a.Index = r
-		return typecheck(a, ctxExpr)
+		return typecheck.Expr(a)
 
 	default:
 		base.Fatalf("order.safeExpr %v", n.Op())
@@ -241,7 +242,7 @@ func isaddrokay(n ir.Node) bool {
 func (o *Order) addrTemp(n ir.Node) ir.Node {
 	if n.Op() == ir.OLITERAL || n.Op() == ir.ONIL {
 		// TODO: expand this to all static composite literal nodes?
-		n = defaultlit(n, nil)
+		n = typecheck.DefaultLit(n, nil)
 		types.CalcSize(n.Type())
 		vstat := readonlystaticname(n.Type())
 		var s InitSchedule
@@ -249,7 +250,7 @@ func (o *Order) addrTemp(n ir.Node) ir.Node {
 		if s.out != nil {
 			base.Fatalf("staticassign of const generated code: %+v", n)
 		}
-		vstat = typecheck(vstat, ctxExpr).(*ir.Name)
+		vstat = typecheck.Expr(vstat).(*ir.Name)
 		return vstat
 	}
 	if isaddrokay(n) {
@@ -336,7 +337,7 @@ func (o *Order) cleanTempNoPop(mark ordermarker) []ir.Node {
 	var out []ir.Node
 	for i := len(o.temp) - 1; i >= int(mark); i-- {
 		n := o.temp[i]
-		out = append(out, typecheck(ir.NewUnaryExpr(base.Pos, ir.OVARKILL, n), ctxStmt))
+		out = append(out, typecheck.Stmt(ir.NewUnaryExpr(base.Pos, ir.OVARKILL, n)))
 	}
 	return out
 }
@@ -388,7 +389,7 @@ func orderMakeSliceCopy(s []ir.Node) {
 	mk.Cap = cp.Y
 	// Set bounded when m = OMAKESLICE([]T, len(s)); OCOPY(m, s)
 	mk.SetBounded(mk.Len.Op() == ir.OLEN && ir.SameSafeExpr(mk.Len.(*ir.UnaryExpr).X, cp.Y))
-	as.Y = typecheck(mk, ctxExpr)
+	as.Y = typecheck.Expr(mk)
 	s[1] = nil // remove separate copy call
 }
 
@@ -495,7 +496,7 @@ func (o *Order) call(nn ir.Node) {
 	}
 
 	n := nn.(*ir.CallExpr)
-	fixVariadicCall(n)
+	typecheck.FixVariadicCall(n)
 	n.X = o.expr(n.X, nil)
 	o.exprList(n.Args)
 
@@ -513,7 +514,7 @@ func (o *Order) call(nn ir.Node) {
 				x := o.copyExpr(arg.X)
 				arg.X = x
 				x.Name().SetAddrtaken(true) // ensure SSA keeps the x variable
-				n.Body.Append(typecheck(ir.NewUnaryExpr(base.Pos, ir.OVARLIVE, x), ctxStmt))
+				n.Body.Append(typecheck.Stmt(ir.NewUnaryExpr(base.Pos, ir.OVARLIVE, x)))
 			}
 		}
 	}
@@ -584,7 +585,7 @@ func (o *Order) mapAssign(n ir.Node) {
 				t := o.newTemp(m.Type(), false)
 				n.Lhs[i] = t
 				a := ir.NewAssignStmt(base.Pos, m, t)
-				post = append(post, typecheck(a, ctxStmt))
+				post = append(post, typecheck.Stmt(a))
 			}
 		}
 
@@ -653,8 +654,8 @@ func (o *Order) stmt(n ir.Node) {
 				l2.Assigned = false
 			}
 			l2 = o.copyExpr(l2)
-			r := o.expr(typecheck(ir.NewBinaryExpr(n.Pos(), n.AsOp, l2, n.Y), ctxExpr), nil)
-			as := typecheck(ir.NewAssignStmt(n.Pos(), l1, r), ctxStmt)
+			r := o.expr(typecheck.Expr(ir.NewBinaryExpr(n.Pos(), n.AsOp, l2, n.Y)), nil)
+			as := typecheck.Stmt(ir.NewAssignStmt(n.Pos(), l1, r))
 			o.mapAssign(as)
 			o.cleanTemp(t)
 			return
@@ -858,7 +859,7 @@ func (o *Order) stmt(n ir.Node) {
 			if r.Type().IsString() && r.Type() != types.Types[types.TSTRING] {
 				r = ir.NewConvExpr(base.Pos, ir.OCONV, nil, r)
 				r.SetType(types.Types[types.TSTRING])
-				r = typecheck(r, ctxExpr)
+				r = typecheck.Expr(r)
 			}
 
 			n.X = o.copyExpr(r)
@@ -949,11 +950,11 @@ func (o *Order) stmt(n ir.Node) {
 						if len(init) > 0 && init[0].Op() == ir.ODCL && init[0].(*ir.Decl).X == n {
 							init = init[1:]
 						}
-						dcl := typecheck(ir.NewDecl(base.Pos, ir.ODCL, n), ctxStmt)
+						dcl := typecheck.Stmt(ir.NewDecl(base.Pos, ir.ODCL, n))
 						ncas.PtrInit().Append(dcl)
 					}
 					tmp := o.newTemp(t, t.HasPointers())
-					as := typecheck(ir.NewAssignStmt(base.Pos, n, conv(tmp, n.Type())), ctxStmt)
+					as := typecheck.Stmt(ir.NewAssignStmt(base.Pos, n, typecheck.Conv(tmp, n.Type())))
 					ncas.PtrInit().Append(as)
 					r.Lhs[i] = tmp
 				}
@@ -1217,7 +1218,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 
 		// Evaluate left-hand side.
 		lhs := o.expr(n.X, nil)
-		o.out = append(o.out, typecheck(ir.NewAssignStmt(base.Pos, r, lhs), ctxStmt))
+		o.out = append(o.out, typecheck.Stmt(ir.NewAssignStmt(base.Pos, r, lhs)))
 
 		// Evaluate right-hand side, save generated code.
 		saveout := o.out
@@ -1225,7 +1226,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		t := o.markTemp()
 		o.edge()
 		rhs := o.expr(n.Y, nil)
-		o.out = append(o.out, typecheck(ir.NewAssignStmt(base.Pos, r, rhs), ctxStmt))
+		o.out = append(o.out, typecheck.Stmt(ir.NewAssignStmt(base.Pos, r, rhs)))
 		o.cleanTemp(t)
 		gen := o.out
 		o.out = saveout
@@ -1307,7 +1308,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 	case ir.OCLOSURE:
 		n := n.(*ir.ClosureExpr)
 		if n.Transient() && len(n.Func.ClosureVars) > 0 {
-			n.Prealloc = o.newTemp(closureType(n), false)
+			n.Prealloc = o.newTemp(typecheck.ClosureType(n), false)
 		}
 		return n
 
@@ -1315,7 +1316,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		n := n.(*ir.CallPartExpr)
 		n.X = o.expr(n.X, nil)
 		if n.Transient() {
-			t := partialCallType(n)
+			t := typecheck.PartialCallType(n)
 			n.Prealloc = o.newTemp(t, false)
 		}
 		return n
@@ -1415,13 +1416,13 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 		// Emit the creation of the map (with all its static entries).
 		m := o.newTemp(n.Type(), false)
 		as := ir.NewAssignStmt(base.Pos, m, n)
-		typecheck(as, ctxStmt)
+		typecheck.Stmt(as)
 		o.stmt(as)
 
 		// Emit eval+insert of dynamic entries, one at a time.
 		for _, r := range dynamics {
 			as := ir.NewAssignStmt(base.Pos, ir.NewIndexExpr(base.Pos, m, r.Key), r.Value)
-			typecheck(as, ctxStmt) // Note: this converts the OINDEX to an OINDEXMAP
+			typecheck.Stmt(as) // Note: this converts the OINDEX to an OINDEXMAP
 			o.stmt(as)
 		}
 		return m
@@ -1455,7 +1456,7 @@ func (o *Order) as2(n *ir.AssignListStmt) {
 	as := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
 	as.Lhs.Set(left)
 	as.Rhs.Set(tmplist)
-	o.stmt(typecheck(as, ctxStmt))
+	o.stmt(typecheck.Stmt(as))
 }
 
 // okAs2 orders OAS2XXX with ok.
@@ -1475,12 +1476,12 @@ func (o *Order) okAs2(n *ir.AssignListStmt) {
 
 	if tmp1 != nil {
 		r := ir.NewAssignStmt(base.Pos, n.Lhs[0], tmp1)
-		o.mapAssign(typecheck(r, ctxStmt))
+		o.mapAssign(typecheck.Stmt(r))
 		n.Lhs[0] = tmp1
 	}
 	if tmp2 != nil {
-		r := ir.NewAssignStmt(base.Pos, n.Lhs[1], conv(tmp2, n.Lhs[1].Type()))
-		o.mapAssign(typecheck(r, ctxStmt))
+		r := ir.NewAssignStmt(base.Pos, n.Lhs[1], typecheck.Conv(tmp2, n.Lhs[1].Type()))
+		o.mapAssign(typecheck.Stmt(r))
 		n.Lhs[1] = tmp2
 	}
 }
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index 337556ea41..c0f3326454 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -8,6 +8,7 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/dwarf"
 	"cmd/internal/obj"
@@ -146,7 +147,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 	}
 
 	if f.Config.NeedsFpScratch && scratchUsed {
-		s.scratchFpMem = tempAt(src.NoXPos, s.curfn, types.Types[types.TUINT64])
+		s.scratchFpMem = typecheck.TempAt(src.NoXPos, s.curfn, types.Types[types.TUINT64])
 	}
 
 	sort.Sort(byStackVar(fn.Dcl))
@@ -214,11 +215,11 @@ func funccompile(fn *ir.Func) {
 		return
 	}
 
-	dclcontext = ir.PAUTO
+	typecheck.DeclContext = ir.PAUTO
 	ir.CurFunc = fn
 	compile(fn)
 	ir.CurFunc = nil
-	dclcontext = ir.PEXTERN
+	typecheck.DeclContext = ir.PEXTERN
 }
 
 func compile(fn *ir.Func) {
diff --git a/src/cmd/compile/internal/gc/pgen_test.go b/src/cmd/compile/internal/gc/pgen_test.go
index 1170db2681..95c4b24fa1 100644
--- a/src/cmd/compile/internal/gc/pgen_test.go
+++ b/src/cmd/compile/internal/gc/pgen_test.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"reflect"
@@ -41,7 +42,7 @@ func TestCmpstackvar(t *testing.T) {
 		if s == nil {
 			s = &types.Sym{Name: "."}
 		}
-		n := NewName(s)
+		n := typecheck.NewName(s)
 		n.SetType(t)
 		n.SetFrameOffset(xoffset)
 		n.Class_ = cl
@@ -156,7 +157,7 @@ func TestCmpstackvar(t *testing.T) {
 
 func TestStackvarSort(t *testing.T) {
 	nod := func(xoffset int64, t *types.Type, s *types.Sym, cl ir.Class) *ir.Name {
-		n := NewName(s)
+		n := typecheck.NewName(s)
 		n.SetType(t)
 		n.SetFrameOffset(xoffset)
 		n.Class_ = cl
diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index a9447189c2..c040811932 100644
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -7,136 +7,12 @@ package gc
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/sys"
 	"unicode/utf8"
 )
 
-// range
-func typecheckrange(n *ir.RangeStmt) {
-	// Typechecking order is important here:
-	// 0. first typecheck range expression (slice/map/chan),
-	//	it is evaluated only once and so logically it is not part of the loop.
-	// 1. typecheck produced values,
-	//	this part can declare new vars and so it must be typechecked before body,
-	//	because body can contain a closure that captures the vars.
-	// 2. decldepth++ to denote loop body.
-	// 3. typecheck body.
-	// 4. decldepth--.
-	typecheckrangeExpr(n)
-
-	// second half of dance, the first half being typecheckrangeExpr
-	n.SetTypecheck(1)
-	ls := n.Vars
-	for i1, n1 := range ls {
-		if n1.Typecheck() == 0 {
-			ls[i1] = typecheck(ls[i1], ctxExpr|ctxAssign)
-		}
-	}
-
-	decldepth++
-	typecheckslice(n.Body, ctxStmt)
-	decldepth--
-}
-
-func typecheckrangeExpr(n *ir.RangeStmt) {
-	n.X = typecheck(n.X, ctxExpr)
-
-	t := n.X.Type()
-	if t == nil {
-		return
-	}
-	// delicate little dance.  see typecheckas2
-	ls := n.Vars
-	for i1, n1 := range ls {
-		if !ir.DeclaredBy(n1, n) {
-			ls[i1] = typecheck(ls[i1], ctxExpr|ctxAssign)
-		}
-	}
-
-	if t.IsPtr() && t.Elem().IsArray() {
-		t = t.Elem()
-	}
-	n.SetType(t)
-
-	var t1, t2 *types.Type
-	toomany := false
-	switch t.Kind() {
-	default:
-		base.ErrorfAt(n.Pos(), "cannot range over %L", n.X)
-		return
-
-	case types.TARRAY, types.TSLICE:
-		t1 = types.Types[types.TINT]
-		t2 = t.Elem()
-
-	case types.TMAP:
-		t1 = t.Key()
-		t2 = t.Elem()
-
-	case types.TCHAN:
-		if !t.ChanDir().CanRecv() {
-			base.ErrorfAt(n.Pos(), "invalid operation: range %v (receive from send-only type %v)", n.X, n.X.Type())
-			return
-		}
-
-		t1 = t.Elem()
-		t2 = nil
-		if len(n.Vars) == 2 {
-			toomany = true
-		}
-
-	case types.TSTRING:
-		t1 = types.Types[types.TINT]
-		t2 = types.RuneType
-	}
-
-	if len(n.Vars) > 2 || toomany {
-		base.ErrorfAt(n.Pos(), "too many variables in range")
-	}
-
-	var v1, v2 ir.Node
-	if len(n.Vars) != 0 {
-		v1 = n.Vars[0]
-	}
-	if len(n.Vars) > 1 {
-		v2 = n.Vars[1]
-	}
-
-	// this is not only an optimization but also a requirement in the spec.
-	// "if the second iteration variable is the blank identifier, the range
-	// clause is equivalent to the same clause with only the first variable
-	// present."
-	if ir.IsBlank(v2) {
-		if v1 != nil {
-			n.Vars = []ir.Node{v1}
-		}
-		v2 = nil
-	}
-
-	if v1 != nil {
-		if ir.DeclaredBy(v1, n) {
-			v1.SetType(t1)
-		} else if v1.Type() != nil {
-			if op, why := assignop(t1, v1.Type()); op == ir.OXXX {
-				base.ErrorfAt(n.Pos(), "cannot assign type %v to %L in range%s", t1, v1, why)
-			}
-		}
-		checkassign(n, v1)
-	}
-
-	if v2 != nil {
-		if ir.DeclaredBy(v2, n) {
-			v2.SetType(t2)
-		} else if v2.Type() != nil {
-			if op, why := assignop(t2, v2.Type()); op == ir.OXXX {
-				base.ErrorfAt(n.Pos(), "cannot assign type %v to %L in range%s", t2, v2, why)
-			}
-		}
-		checkassign(n, v2)
-	}
-}
-
 func cheapComputableIndex(width int64) bool {
 	switch thearch.LinkArch.Family {
 	// MIPS does not have R+R addressing
@@ -221,8 +97,8 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		// order.stmt arranged for a copy of the array/slice variable if needed.
 		ha := a
 
-		hv1 := temp(types.Types[types.TINT])
-		hn := temp(types.Types[types.TINT])
+		hv1 := typecheck.Temp(types.Types[types.TINT])
+		hn := typecheck.Temp(types.Types[types.TINT])
 
 		init = append(init, ir.NewAssignStmt(base.Pos, hv1, nil))
 		init = append(init, ir.NewAssignStmt(base.Pos, hn, ir.NewUnaryExpr(base.Pos, ir.OLEN, ha)))
@@ -271,10 +147,10 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		ifGuard.Cond = ir.NewBinaryExpr(base.Pos, ir.OLT, hv1, hn)
 		nfor.SetOp(ir.OFORUNTIL)
 
-		hp := temp(types.NewPtr(nrange.Type().Elem()))
+		hp := typecheck.Temp(types.NewPtr(nrange.Type().Elem()))
 		tmp := ir.NewIndexExpr(base.Pos, ha, ir.NewInt(0))
 		tmp.SetBounded(true)
-		init = append(init, ir.NewAssignStmt(base.Pos, hp, nodAddr(tmp)))
+		init = append(init, ir.NewAssignStmt(base.Pos, hp, typecheck.NodAddr(tmp)))
 
 		// Use OAS2 to correctly handle assignments
 		// of the form "v1, a[v1] := range".
@@ -289,7 +165,7 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		// advancing the pointer is safe and won't go past the
 		// end of the allocation.
 		as := ir.NewAssignStmt(base.Pos, hp, addptr(hp, t.Elem().Width))
-		nfor.Late = []ir.Node{typecheck(as, ctxStmt)}
+		nfor.Late = []ir.Node{typecheck.Stmt(as)}
 
 	case types.TMAP:
 		// order.stmt allocated the iterator for us.
@@ -301,15 +177,15 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		keysym := th.Field(0).Sym  // depends on layout of iterator struct.  See reflect.go:hiter
 		elemsym := th.Field(1).Sym // ditto
 
-		fn := syslook("mapiterinit")
+		fn := typecheck.LookupRuntime("mapiterinit")
 
-		fn = substArgTypes(fn, t.Key(), t.Elem(), th)
-		init = append(init, mkcall1(fn, nil, nil, typename(t), ha, nodAddr(hit)))
-		nfor.Cond = ir.NewBinaryExpr(base.Pos, ir.ONE, ir.NewSelectorExpr(base.Pos, ir.ODOT, hit, keysym), nodnil())
+		fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem(), th)
+		init = append(init, mkcall1(fn, nil, nil, typename(t), ha, typecheck.NodAddr(hit)))
+		nfor.Cond = ir.NewBinaryExpr(base.Pos, ir.ONE, ir.NewSelectorExpr(base.Pos, ir.ODOT, hit, keysym), typecheck.NodNil())
 
-		fn = syslook("mapiternext")
-		fn = substArgTypes(fn, th)
-		nfor.Post = mkcall1(fn, nil, nil, nodAddr(hit))
+		fn = typecheck.LookupRuntime("mapiternext")
+		fn = typecheck.SubstArgTypes(fn, th)
+		nfor.Post = mkcall1(fn, nil, nil, typecheck.NodAddr(hit))
 
 		key := ir.NewStarExpr(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, hit, keysym))
 		if v1 == nil {
@@ -328,12 +204,12 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		// order.stmt arranged for a copy of the channel variable.
 		ha := a
 
-		hv1 := temp(t.Elem())
+		hv1 := typecheck.Temp(t.Elem())
 		hv1.SetTypecheck(1)
 		if t.Elem().HasPointers() {
 			init = append(init, ir.NewAssignStmt(base.Pos, hv1, nil))
 		}
-		hb := temp(types.Types[types.TBOOL])
+		hb := typecheck.Temp(types.Types[types.TBOOL])
 
 		nfor.Cond = ir.NewBinaryExpr(base.Pos, ir.ONE, hb, ir.NewBool(false))
 		a := ir.NewAssignListStmt(base.Pos, ir.OAS2RECV, nil, nil)
@@ -370,9 +246,9 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		// order.stmt arranged for a copy of the string variable.
 		ha := a
 
-		hv1 := temp(types.Types[types.TINT])
-		hv1t := temp(types.Types[types.TINT])
-		hv2 := temp(types.RuneType)
+		hv1 := typecheck.Temp(types.Types[types.TINT])
+		hv1t := typecheck.Temp(types.Types[types.TINT])
+		hv2 := typecheck.Temp(types.RuneType)
 
 		// hv1 := 0
 		init = append(init, ir.NewAssignStmt(base.Pos, hv1, nil))
@@ -388,7 +264,7 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		// hv2 := rune(ha[hv1])
 		nind := ir.NewIndexExpr(base.Pos, ha, hv1)
 		nind.SetBounded(true)
-		body = append(body, ir.NewAssignStmt(base.Pos, hv2, conv(nind, types.RuneType)))
+		body = append(body, ir.NewAssignStmt(base.Pos, hv2, typecheck.Conv(nind, types.RuneType)))
 
 		// if hv2 < utf8.RuneSelf
 		nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
@@ -403,7 +279,7 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 
 		// hv2, hv1 = decoderune(ha, hv1)
 		eif.Lhs = []ir.Node{hv2, hv1}
-		fn := syslook("decoderune")
+		fn := typecheck.LookupRuntime("decoderune")
 		eif.Rhs = []ir.Node{mkcall1(fn, fn.Type().Results(), nil, ha, hv1)}
 
 		body = append(body, nif)
@@ -422,21 +298,21 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		}
 	}
 
-	typecheckslice(init, ctxStmt)
+	typecheck.Stmts(init)
 
 	if ifGuard != nil {
 		ifGuard.PtrInit().Append(init...)
-		ifGuard = typecheck(ifGuard, ctxStmt).(*ir.IfStmt)
+		ifGuard = typecheck.Stmt(ifGuard).(*ir.IfStmt)
 	} else {
 		nfor.PtrInit().Append(init...)
 	}
 
-	typecheckslice(nfor.Cond.Init(), ctxStmt)
+	typecheck.Stmts(nfor.Cond.Init())
 
-	nfor.Cond = typecheck(nfor.Cond, ctxExpr)
-	nfor.Cond = defaultlit(nfor.Cond, nil)
-	nfor.Post = typecheck(nfor.Post, ctxStmt)
-	typecheckslice(body, ctxStmt)
+	nfor.Cond = typecheck.Expr(nfor.Cond)
+	nfor.Cond = typecheck.DefaultLit(nfor.Cond, nil)
+	nfor.Post = typecheck.Stmt(nfor.Post)
+	typecheck.Stmts(body)
 	nfor.Body.Append(body...)
 	nfor.Body.Append(nrange.Body...)
 
@@ -505,10 +381,10 @@ func mapClear(m ir.Node) ir.Node {
 	t := m.Type()
 
 	// instantiate mapclear(typ *type, hmap map[any]any)
-	fn := syslook("mapclear")
-	fn = substArgTypes(fn, t.Key(), t.Elem())
+	fn := typecheck.LookupRuntime("mapclear")
+	fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem())
 	n := mkcall1(fn, nil, nil, typename(t), m)
-	return walkstmt(typecheck(n, ctxStmt))
+	return walkstmt(typecheck.Stmt(n))
 }
 
 // Lower n into runtime·memclr if possible, for
@@ -566,16 +442,16 @@ func arrayClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
 	n.Cond = ir.NewBinaryExpr(base.Pos, ir.ONE, ir.NewUnaryExpr(base.Pos, ir.OLEN, a), ir.NewInt(0))
 
 	// hp = &a[0]
-	hp := temp(types.Types[types.TUNSAFEPTR])
+	hp := typecheck.Temp(types.Types[types.TUNSAFEPTR])
 
 	ix := ir.NewIndexExpr(base.Pos, a, ir.NewInt(0))
 	ix.SetBounded(true)
-	addr := convnop(nodAddr(ix), types.Types[types.TUNSAFEPTR])
+	addr := typecheck.ConvNop(typecheck.NodAddr(ix), types.Types[types.TUNSAFEPTR])
 	n.Body.Append(ir.NewAssignStmt(base.Pos, hp, addr))
 
 	// hn = len(a) * sizeof(elem(a))
-	hn := temp(types.Types[types.TUINTPTR])
-	mul := conv(ir.NewBinaryExpr(base.Pos, ir.OMUL, ir.NewUnaryExpr(base.Pos, ir.OLEN, a), ir.NewInt(elemsize)), types.Types[types.TUINTPTR])
+	hn := typecheck.Temp(types.Types[types.TUINTPTR])
+	mul := typecheck.Conv(ir.NewBinaryExpr(base.Pos, ir.OMUL, ir.NewUnaryExpr(base.Pos, ir.OLEN, a), ir.NewInt(elemsize)), types.Types[types.TUINTPTR])
 	n.Body.Append(ir.NewAssignStmt(base.Pos, hn, mul))
 
 	var fn ir.Node
@@ -595,9 +471,9 @@ func arrayClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
 
 	n.Body.Append(v1)
 
-	n.Cond = typecheck(n.Cond, ctxExpr)
-	n.Cond = defaultlit(n.Cond, nil)
-	typecheckslice(n.Body, ctxStmt)
+	n.Cond = typecheck.Expr(n.Cond)
+	n.Cond = typecheck.DefaultLit(n.Cond, nil)
+	typecheck.Stmts(n.Body)
 	return walkstmt(n)
 }
 
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 987b2d6ee2..7594884f9f 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/gcprog"
 	"cmd/internal/obj"
@@ -339,36 +340,6 @@ func deferstruct(stksize int64) *types.Type {
 	return s
 }
 
-// f is method type, with receiver.
-// return function type, receiver as first argument (or not).
-func methodfunc(f *types.Type, receiver *types.Type) *types.Type {
-	inLen := f.Params().Fields().Len()
-	if receiver != nil {
-		inLen++
-	}
-	in := make([]*ir.Field, 0, inLen)
-
-	if receiver != nil {
-		d := ir.NewField(base.Pos, nil, nil, receiver)
-		in = append(in, d)
-	}
-
-	for _, t := range f.Params().Fields().Slice() {
-		d := ir.NewField(base.Pos, nil, nil, t.Type)
-		d.IsDDD = t.IsDDD()
-		in = append(in, d)
-	}
-
-	outLen := f.Results().Fields().Len()
-	out := make([]*ir.Field, 0, outLen)
-	for _, t := range f.Results().Fields().Slice() {
-		d := ir.NewField(base.Pos, nil, nil, t.Type)
-		out = append(out, d)
-	}
-
-	return functype(nil, in, out)
-}
-
 // methods returns the methods of the non-interface type t, sorted by name.
 // Generates stub functions as needed.
 func methods(t *types.Type) []*Sig {
@@ -378,7 +349,7 @@ func methods(t *types.Type) []*Sig {
 	if mt == nil {
 		return nil
 	}
-	expandmeth(mt)
+	typecheck.CalcMethods(mt)
 
 	// type stored in interface word
 	it := t
@@ -418,8 +389,8 @@ func methods(t *types.Type) []*Sig {
 			name:  method,
 			isym:  ir.MethodSym(it, method),
 			tsym:  ir.MethodSym(t, method),
-			type_: methodfunc(f.Type, t),
-			mtype: methodfunc(f.Type, nil),
+			type_: typecheck.NewMethodType(f.Type, t),
+			mtype: typecheck.NewMethodType(f.Type, nil),
 		}
 		ms = append(ms, sig)
 
@@ -463,7 +434,7 @@ func imethods(t *types.Type) []*Sig {
 		sig := &Sig{
 			name:  f.Sym,
 			mtype: f.Type,
-			type_: methodfunc(f.Type, nil),
+			type_: typecheck.NewMethodType(f.Type, nil),
 		}
 		methods = append(methods, sig)
 
@@ -916,7 +887,7 @@ func typename(t *types.Type) *ir.AddrExpr {
 		s.Def = n
 	}
 
-	n := nodAddr(ir.AsNode(s.Def))
+	n := typecheck.NodAddr(ir.AsNode(s.Def))
 	n.SetType(types.NewPtr(s.Def.Type()))
 	n.SetTypecheck(1)
 	return n
@@ -928,7 +899,7 @@ func itabname(t, itype *types.Type) *ir.AddrExpr {
 	}
 	s := ir.Pkgs.Itab.Lookup(t.ShortString() + "," + itype.ShortString())
 	if s.Def == nil {
-		n := NewName(s)
+		n := typecheck.NewName(s)
 		n.SetType(types.Types[types.TUINT8])
 		n.Class_ = ir.PEXTERN
 		n.SetTypecheck(1)
@@ -936,7 +907,7 @@ func itabname(t, itype *types.Type) *ir.AddrExpr {
 		itabs = append(itabs, itabEntry{t: t, itype: itype, lsym: s.Linksym()})
 	}
 
-	n := nodAddr(ir.AsNode(s.Def))
+	n := typecheck.NodAddr(ir.AsNode(s.Def))
 	n.SetType(types.NewPtr(s.Def.Type()))
 	n.SetTypecheck(1)
 	return n
@@ -1033,7 +1004,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 	if base.Ctxt.Pkgpath != "runtime" || (tbase != types.Types[tbase.Kind()] && tbase != types.ByteType && tbase != types.RuneType && tbase != types.ErrorType) { // int, float, etc
 		// named types from other files are defined only by those files
 		if tbase.Sym() != nil && tbase.Sym().Pkg != types.LocalPkg {
-			if i := BaseTypeIndex(t); i >= 0 {
+			if i := typecheck.BaseTypeIndex(t); i >= 0 {
 				lsym.Pkg = tbase.Sym().Pkg.Prefix
 				lsym.SymIdx = int32(i)
 				lsym.Set(obj.AttrIndexed, true)
@@ -1492,7 +1463,7 @@ func dumpbasictypes() {
 		// The latter is the type of an auto-generated wrapper.
 		dtypesym(types.NewPtr(types.ErrorType))
 
-		dtypesym(functype(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, types.ErrorType)}, []*ir.Field{ir.NewField(base.Pos, nil, nil, types.Types[types.TSTRING])}))
+		dtypesym(typecheck.NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, types.ErrorType)}, []*ir.Field{ir.NewField(base.Pos, nil, nil, types.Types[types.TSTRING])}))
 
 		// add paths for runtime and main, which 6l imports implicitly.
 		dimportpath(ir.Pkgs.Runtime)
@@ -1744,13 +1715,13 @@ func zeroaddr(size int64) ir.Node {
 	}
 	s := ir.Pkgs.Map.Lookup("zero")
 	if s.Def == nil {
-		x := NewName(s)
+		x := typecheck.NewName(s)
 		x.SetType(types.Types[types.TUINT8])
 		x.Class_ = ir.PEXTERN
 		x.SetTypecheck(1)
 		s.Def = x
 	}
-	z := nodAddr(ir.AsNode(s.Def))
+	z := typecheck.NodAddr(ir.AsNode(s.Def))
 	z.SetType(types.NewPtr(types.Types[types.TUINT8]))
 	z.SetTypecheck(1)
 	return z
diff --git a/src/cmd/compile/internal/gc/select.go b/src/cmd/compile/internal/gc/select.go
index 67a2cfd312..51bb1e5355 100644
--- a/src/cmd/compile/internal/gc/select.go
+++ b/src/cmd/compile/internal/gc/select.go
@@ -7,92 +7,10 @@ package gc
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 )
 
-// select
-func typecheckselect(sel *ir.SelectStmt) {
-	var def ir.Node
-	lno := ir.SetPos(sel)
-	typecheckslice(sel.Init(), ctxStmt)
-	for _, ncase := range sel.Cases {
-		ncase := ncase.(*ir.CaseStmt)
-
-		if len(ncase.List) == 0 {
-			// default
-			if def != nil {
-				base.ErrorfAt(ncase.Pos(), "multiple defaults in select (first at %v)", ir.Line(def))
-			} else {
-				def = ncase
-			}
-		} else if len(ncase.List) > 1 {
-			base.ErrorfAt(ncase.Pos(), "select cases cannot be lists")
-		} else {
-			ncase.List[0] = typecheck(ncase.List[0], ctxStmt)
-			n := ncase.List[0]
-			ncase.Comm = n
-			ncase.List.Set(nil)
-			oselrecv2 := func(dst, recv ir.Node, colas bool) {
-				n := ir.NewAssignListStmt(n.Pos(), ir.OSELRECV2, nil, nil)
-				n.Lhs = []ir.Node{dst, ir.BlankNode}
-				n.Rhs = []ir.Node{recv}
-				n.Def = colas
-				n.SetTypecheck(1)
-				ncase.Comm = n
-			}
-			switch n.Op() {
-			default:
-				pos := n.Pos()
-				if n.Op() == ir.ONAME {
-					// We don't have the right position for ONAME nodes (see #15459 and
-					// others). Using ncase.Pos for now as it will provide the correct
-					// line number (assuming the expression follows the "case" keyword
-					// on the same line). This matches the approach before 1.10.
-					pos = ncase.Pos()
-				}
-				base.ErrorfAt(pos, "select case must be receive, send or assign recv")
-
-			case ir.OAS:
-				// convert x = <-c into x, _ = <-c
-				// remove implicit conversions; the eventual assignment
-				// will reintroduce them.
-				n := n.(*ir.AssignStmt)
-				if r := n.Y; r.Op() == ir.OCONVNOP || r.Op() == ir.OCONVIFACE {
-					r := r.(*ir.ConvExpr)
-					if r.Implicit() {
-						n.Y = r.X
-					}
-				}
-				if n.Y.Op() != ir.ORECV {
-					base.ErrorfAt(n.Pos(), "select assignment must have receive on right hand side")
-					break
-				}
-				oselrecv2(n.X, n.Y, n.Def)
-
-			case ir.OAS2RECV:
-				n := n.(*ir.AssignListStmt)
-				if n.Rhs[0].Op() != ir.ORECV {
-					base.ErrorfAt(n.Pos(), "select assignment must have receive on right hand side")
-					break
-				}
-				n.SetOp(ir.OSELRECV2)
-
-			case ir.ORECV:
-				// convert <-c into _, _ = <-c
-				n := n.(*ir.UnaryExpr)
-				oselrecv2(ir.BlankNode, n, false)
-
-			case ir.OSEND:
-				break
-			}
-		}
-
-		typecheckslice(ncase.Body, ctxStmt)
-	}
-
-	base.Pos = lno
-}
-
 func walkselect(sel *ir.SelectStmt) {
 	lno := ir.SetPos(sel)
 	if len(sel.Compiled) != 0 {
@@ -167,14 +85,14 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 		switch n.Op() {
 		case ir.OSEND:
 			n := n.(*ir.SendStmt)
-			n.Value = nodAddr(n.Value)
-			n.Value = typecheck(n.Value, ctxExpr)
+			n.Value = typecheck.NodAddr(n.Value)
+			n.Value = typecheck.Expr(n.Value)
 
 		case ir.OSELRECV2:
 			n := n.(*ir.AssignListStmt)
 			if !ir.IsBlank(n.Lhs[0]) {
-				n.Lhs[0] = nodAddr(n.Lhs[0])
-				n.Lhs[0] = typecheck(n.Lhs[0], ctxExpr)
+				n.Lhs[0] = typecheck.NodAddr(n.Lhs[0])
+				n.Lhs[0] = typecheck.Expr(n.Lhs[0])
 			}
 		}
 	}
@@ -207,7 +125,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 			ch := recv.X
 			elem := n.Lhs[0]
 			if ir.IsBlank(elem) {
-				elem = nodnil()
+				elem = typecheck.NodNil()
 			}
 			if ir.IsBlank(n.Lhs[1]) {
 				// if selectnbrecv(&v, c) { body } else { default body }
@@ -215,12 +133,12 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 			} else {
 				// TODO(cuonglm): make this use selectnbrecv()
 				// if selectnbrecv2(&v, &received, c) { body } else { default body }
-				receivedp := typecheck(nodAddr(n.Lhs[1]), ctxExpr)
+				receivedp := typecheck.Expr(typecheck.NodAddr(n.Lhs[1]))
 				call = mkcall1(chanfn("selectnbrecv2", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), elem, receivedp, ch)
 			}
 		}
 
-		r.Cond = typecheck(call, ctxExpr)
+		r.Cond = typecheck.Expr(call)
 		r.Body.Set(cas.Body)
 		r.Else.Set(append(dflt.Init(), dflt.Body...))
 		return []ir.Node{r, ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)}
@@ -236,18 +154,18 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 
 	// generate sel-struct
 	base.Pos = sellineno
-	selv := temp(types.NewArray(scasetype(), int64(ncas)))
-	init = append(init, typecheck(ir.NewAssignStmt(base.Pos, selv, nil), ctxStmt))
+	selv := typecheck.Temp(types.NewArray(scasetype(), int64(ncas)))
+	init = append(init, typecheck.Stmt(ir.NewAssignStmt(base.Pos, selv, nil)))
 
 	// No initialization for order; runtime.selectgo is responsible for that.
-	order := temp(types.NewArray(types.Types[types.TUINT16], 2*int64(ncas)))
+	order := typecheck.Temp(types.NewArray(types.Types[types.TUINT16], 2*int64(ncas)))
 
 	var pc0, pcs ir.Node
 	if base.Flag.Race {
-		pcs = temp(types.NewArray(types.Types[types.TUINTPTR], int64(ncas)))
-		pc0 = typecheck(nodAddr(ir.NewIndexExpr(base.Pos, pcs, ir.NewInt(0))), ctxExpr)
+		pcs = typecheck.Temp(types.NewArray(types.Types[types.TUINTPTR], int64(ncas)))
+		pc0 = typecheck.Expr(typecheck.NodAddr(ir.NewIndexExpr(base.Pos, pcs, ir.NewInt(0))))
 	} else {
-		pc0 = nodnil()
+		pc0 = typecheck.NodNil()
 	}
 
 	// register cases
@@ -286,21 +204,21 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 		casorder[i] = cas
 
 		setField := func(f string, val ir.Node) {
-			r := ir.NewAssignStmt(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, ir.NewIndexExpr(base.Pos, selv, ir.NewInt(int64(i))), lookup(f)), val)
-			init = append(init, typecheck(r, ctxStmt))
+			r := ir.NewAssignStmt(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, ir.NewIndexExpr(base.Pos, selv, ir.NewInt(int64(i))), typecheck.Lookup(f)), val)
+			init = append(init, typecheck.Stmt(r))
 		}
 
-		c = convnop(c, types.Types[types.TUNSAFEPTR])
+		c = typecheck.ConvNop(c, types.Types[types.TUNSAFEPTR])
 		setField("c", c)
 		if !ir.IsBlank(elem) {
-			elem = convnop(elem, types.Types[types.TUNSAFEPTR])
+			elem = typecheck.ConvNop(elem, types.Types[types.TUNSAFEPTR])
 			setField("elem", elem)
 		}
 
 		// TODO(mdempsky): There should be a cleaner way to
 		// handle this.
 		if base.Flag.Race {
-			r := mkcall("selectsetpc", nil, nil, nodAddr(ir.NewIndexExpr(base.Pos, pcs, ir.NewInt(int64(i)))))
+			r := mkcall("selectsetpc", nil, nil, typecheck.NodAddr(ir.NewIndexExpr(base.Pos, pcs, ir.NewInt(int64(i)))))
 			init = append(init, r)
 		}
 	}
@@ -310,13 +228,13 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 
 	// run the select
 	base.Pos = sellineno
-	chosen := temp(types.Types[types.TINT])
-	recvOK := temp(types.Types[types.TBOOL])
+	chosen := typecheck.Temp(types.Types[types.TINT])
+	recvOK := typecheck.Temp(types.Types[types.TBOOL])
 	r := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
 	r.Lhs = []ir.Node{chosen, recvOK}
-	fn := syslook("selectgo")
+	fn := typecheck.LookupRuntime("selectgo")
 	r.Rhs = []ir.Node{mkcall1(fn, fn.Type().Results(), nil, bytePtrToIndex(selv, 0), bytePtrToIndex(order, 0), pc0, ir.NewInt(int64(nsends)), ir.NewInt(int64(nrecvs)), ir.NewBool(dflt == nil))}
-	init = append(init, typecheck(r, ctxStmt))
+	init = append(init, typecheck.Stmt(r))
 
 	// selv and order are no longer alive after selectgo.
 	init = append(init, ir.NewUnaryExpr(base.Pos, ir.OVARKILL, selv))
@@ -327,8 +245,8 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 
 	// dispatch cases
 	dispatch := func(cond ir.Node, cas *ir.CaseStmt) {
-		cond = typecheck(cond, ctxExpr)
-		cond = defaultlit(cond, nil)
+		cond = typecheck.Expr(cond)
+		cond = typecheck.DefaultLit(cond, nil)
 
 		r := ir.NewIfStmt(base.Pos, cond, nil, nil)
 
@@ -336,7 +254,7 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 			n := n.(*ir.AssignListStmt)
 			if !ir.IsBlank(n.Lhs[1]) {
 				x := ir.NewAssignStmt(base.Pos, n.Lhs[1], recvOK)
-				r.Body.Append(typecheck(x, ctxStmt))
+				r.Body.Append(typecheck.Stmt(x))
 			}
 		}
 
@@ -359,9 +277,9 @@ func walkselectcases(cases ir.Nodes) []ir.Node {
 
 // bytePtrToIndex returns a Node representing "(*byte)(&n[i])".
 func bytePtrToIndex(n ir.Node, i int64) ir.Node {
-	s := nodAddr(ir.NewIndexExpr(base.Pos, n, ir.NewInt(i)))
+	s := typecheck.NodAddr(ir.NewIndexExpr(base.Pos, n, ir.NewInt(i)))
 	t := types.NewPtr(types.Types[types.TUINT8])
-	return convnop(s, t)
+	return typecheck.ConvNop(s, t)
 }
 
 var scase *types.Type
@@ -369,9 +287,9 @@ var scase *types.Type
 // Keep in sync with src/runtime/select.go.
 func scasetype() *types.Type {
 	if scase == nil {
-		scase = tostruct([]*ir.Field{
-			ir.NewField(base.Pos, lookup("c"), nil, types.Types[types.TUNSAFEPTR]),
-			ir.NewField(base.Pos, lookup("elem"), nil, types.Types[types.TUNSAFEPTR]),
+		scase = typecheck.NewStructType([]*ir.Field{
+			ir.NewField(base.Pos, typecheck.Lookup("c"), nil, types.Types[types.TUNSAFEPTR]),
+			ir.NewField(base.Pos, typecheck.Lookup("elem"), nil, types.Types[types.TUNSAFEPTR]),
 		})
 		scase.SetNoalg(true)
 	}
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index e9a4590043..26591ad5ab 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"fmt"
@@ -112,7 +113,7 @@ func (s *InitSchedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *type
 		if loff != 0 || !types.Identical(typ, l.Type()) {
 			dst = ir.NewNameOffsetExpr(base.Pos, l, loff, typ)
 		}
-		s.append(ir.NewAssignStmt(base.Pos, dst, conv(r, typ)))
+		s.append(ir.NewAssignStmt(base.Pos, dst, typecheck.Conv(r, typ)))
 		return true
 
 	case ir.ONIL:
@@ -387,9 +388,9 @@ var statuniqgen int // name generator for static temps
 // Use readonlystaticname for read-only node.
 func staticname(t *types.Type) *ir.Name {
 	// Don't use lookupN; it interns the resulting string, but these are all unique.
-	n := NewName(lookup(fmt.Sprintf("%s%d", obj.StaticNamePref, statuniqgen)))
+	n := typecheck.NewName(typecheck.Lookup(fmt.Sprintf("%s%d", obj.StaticNamePref, statuniqgen)))
 	statuniqgen++
-	declare(n, ir.PEXTERN)
+	typecheck.Declare(n, ir.PEXTERN)
 	n.SetType(t)
 	n.Sym().Linksym().Set(obj.AttrLocal, true)
 	return n
@@ -541,7 +542,7 @@ func fixedlit(ctxt initContext, kind initKind, n *ir.CompLitExpr, var_ ir.Node,
 		splitnode = func(r ir.Node) (ir.Node, ir.Node) {
 			if r.Op() == ir.OKEY {
 				kv := r.(*ir.KeyExpr)
-				k = indexconst(kv.Key)
+				k = typecheck.IndexConst(kv.Key)
 				if k < 0 {
 					base.Fatalf("fixedlit: invalid index %v", kv.Key)
 				}
@@ -596,7 +597,7 @@ func fixedlit(ctxt initContext, kind initKind, n *ir.CompLitExpr, var_ ir.Node,
 		// build list of assignments: var[index] = expr
 		ir.SetPos(a)
 		as := ir.NewAssignStmt(base.Pos, a, value)
-		as = typecheck(as, ctxStmt).(*ir.AssignStmt)
+		as = typecheck.Stmt(as).(*ir.AssignStmt)
 		switch kind {
 		case initKindStatic:
 			genAsStatic(as)
@@ -632,7 +633,7 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 		fixedlit(ctxt, initKindDynamic, n, vstat, init)
 
 		// copy static to slice
-		var_ = typecheck(var_, ctxExpr|ctxAssign)
+		var_ = typecheck.AssignExpr(var_)
 		name, offset, ok := stataddr(var_)
 		if !ok || name.Class_ != ir.PEXTERN {
 			base.Fatalf("slicelit: %v", var_)
@@ -675,7 +676,7 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 	}
 
 	// make new auto *array (3 declare)
-	vauto := temp(types.NewPtr(t))
+	vauto := typecheck.Temp(types.NewPtr(t))
 
 	// set auto to point at new temp or heap (3 assign)
 	var a ir.Node
@@ -687,7 +688,7 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 
 		if vstat == nil {
 			a = ir.NewAssignStmt(base.Pos, x, nil)
-			a = typecheck(a, ctxStmt)
+			a = typecheck.Stmt(a)
 			init.Append(a) // zero new temp
 		} else {
 			// Declare that we're about to initialize all of x.
@@ -695,19 +696,19 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 			init.Append(ir.NewUnaryExpr(base.Pos, ir.OVARDEF, x))
 		}
 
-		a = nodAddr(x)
+		a = typecheck.NodAddr(x)
 	} else if n.Esc() == ir.EscNone {
-		a = temp(t)
+		a = typecheck.Temp(t)
 		if vstat == nil {
-			a = ir.NewAssignStmt(base.Pos, temp(t), nil)
-			a = typecheck(a, ctxStmt)
+			a = ir.NewAssignStmt(base.Pos, typecheck.Temp(t), nil)
+			a = typecheck.Stmt(a)
 			init.Append(a) // zero new temp
 			a = a.(*ir.AssignStmt).X
 		} else {
 			init.Append(ir.NewUnaryExpr(base.Pos, ir.OVARDEF, a))
 		}
 
-		a = nodAddr(a)
+		a = typecheck.NodAddr(a)
 	} else {
 		a = ir.NewUnaryExpr(base.Pos, ir.ONEW, ir.TypeNode(t))
 	}
@@ -724,7 +725,7 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 	for _, value := range n.List {
 		if value.Op() == ir.OKEY {
 			kv := value.(*ir.KeyExpr)
-			index = indexconst(kv.Key)
+			index = typecheck.IndexConst(kv.Key)
 			if index < 0 {
 				base.Fatalf("slicelit: invalid index %v", kv.Key)
 			}
@@ -758,7 +759,7 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 
 		// build list of vauto[c] = expr
 		ir.SetPos(value)
-		as := typecheck(ir.NewAssignStmt(base.Pos, a, value), ctxStmt)
+		as := typecheck.Stmt(ir.NewAssignStmt(base.Pos, a, value))
 		as = orderStmtInPlace(as, map[string][]*ir.Name{})
 		as = walkstmt(as)
 		init.Append(as)
@@ -767,7 +768,7 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 	// make slice out of heap (6)
 	a = ir.NewAssignStmt(base.Pos, var_, ir.NewSliceExpr(base.Pos, ir.OSLICE, vauto))
 
-	a = typecheck(a, ctxStmt)
+	a = typecheck.Stmt(a)
 	a = orderStmtInPlace(a, map[string][]*ir.Name{})
 	a = walkstmt(a)
 	init.Append(a)
@@ -822,7 +823,7 @@ func maplit(n *ir.CompLitExpr, m ir.Node, init *ir.Nodes) {
 		// for i = 0; i < len(vstatk); i++ {
 		//	map[vstatk[i]] = vstate[i]
 		// }
-		i := temp(types.Types[types.TINT])
+		i := typecheck.Temp(types.Types[types.TINT])
 		rhs := ir.NewIndexExpr(base.Pos, vstate, i)
 		rhs.SetBounded(true)
 
@@ -847,8 +848,8 @@ func maplit(n *ir.CompLitExpr, m ir.Node, init *ir.Nodes) {
 	// Build list of var[c] = expr.
 	// Use temporaries so that mapassign1 can have addressable key, elem.
 	// TODO(josharian): avoid map key temporaries for mapfast_* assignments with literal keys.
-	tmpkey := temp(m.Type().Key())
-	tmpelem := temp(m.Type().Elem())
+	tmpkey := typecheck.Temp(m.Type().Key())
+	tmpelem := typecheck.Temp(m.Type().Elem())
 
 	for _, r := range entries {
 		r := r.(*ir.KeyExpr)
@@ -892,7 +893,7 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 		if n.Alloc != nil {
 			// n.Right is stack temporary used as backing store.
 			appendWalkStmt(init, ir.NewAssignStmt(base.Pos, n.Alloc, nil)) // zero backing store, just in case (#18410)
-			r = nodAddr(n.Alloc)
+			r = typecheck.NodAddr(n.Alloc)
 		} else {
 			r = ir.NewUnaryExpr(base.Pos, ir.ONEW, ir.TypeNode(n.X.Type()))
 			r.SetEsc(n.Esc())
@@ -900,7 +901,7 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, r))
 
 		var_ = ir.NewStarExpr(base.Pos, var_)
-		var_ = typecheck(var_, ctxExpr|ctxAssign)
+		var_ = typecheck.AssignExpr(var_)
 		anylit(n.X, var_, init)
 
 	case ir.OSTRUCTLIT, ir.OARRAYLIT:
@@ -1060,7 +1061,7 @@ func (s *InitSchedule) initplan(n ir.Node) {
 		for _, a := range n.List {
 			if a.Op() == ir.OKEY {
 				kv := a.(*ir.KeyExpr)
-				k = indexconst(kv.Key)
+				k = typecheck.IndexConst(kv.Key)
 				if k < 0 {
 					base.Fatalf("initplan arraylit: invalid index %v", kv.Key)
 				}
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 21925a0d65..382e4d4320 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -19,6 +19,7 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/x86"
@@ -91,119 +92,119 @@ func initssaconfig() {
 	ssaCaches = make([]ssa.Cache, base.Flag.LowerC)
 
 	// Set up some runtime functions we'll need to call.
-	ir.Syms.AssertE2I = sysfunc("assertE2I")
-	ir.Syms.AssertE2I2 = sysfunc("assertE2I2")
-	ir.Syms.AssertI2I = sysfunc("assertI2I")
-	ir.Syms.AssertI2I2 = sysfunc("assertI2I2")
-	ir.Syms.Deferproc = sysfunc("deferproc")
-	ir.Syms.DeferprocStack = sysfunc("deferprocStack")
-	ir.Syms.Deferreturn = sysfunc("deferreturn")
-	ir.Syms.Duffcopy = sysfunc("duffcopy")
-	ir.Syms.Duffzero = sysfunc("duffzero")
-	ir.Syms.GCWriteBarrier = sysfunc("gcWriteBarrier")
-	ir.Syms.Goschedguarded = sysfunc("goschedguarded")
-	ir.Syms.Growslice = sysfunc("growslice")
-	ir.Syms.Msanread = sysfunc("msanread")
-	ir.Syms.Msanwrite = sysfunc("msanwrite")
-	ir.Syms.Msanmove = sysfunc("msanmove")
-	ir.Syms.Newobject = sysfunc("newobject")
-	ir.Syms.Newproc = sysfunc("newproc")
-	ir.Syms.Panicdivide = sysfunc("panicdivide")
-	ir.Syms.PanicdottypeE = sysfunc("panicdottypeE")
-	ir.Syms.PanicdottypeI = sysfunc("panicdottypeI")
-	ir.Syms.Panicnildottype = sysfunc("panicnildottype")
-	ir.Syms.Panicoverflow = sysfunc("panicoverflow")
-	ir.Syms.Panicshift = sysfunc("panicshift")
-	ir.Syms.Raceread = sysfunc("raceread")
-	ir.Syms.Racereadrange = sysfunc("racereadrange")
-	ir.Syms.Racewrite = sysfunc("racewrite")
-	ir.Syms.Racewriterange = sysfunc("racewriterange")
-	ir.Syms.X86HasPOPCNT = sysvar("x86HasPOPCNT")       // bool
-	ir.Syms.X86HasSSE41 = sysvar("x86HasSSE41")         // bool
-	ir.Syms.X86HasFMA = sysvar("x86HasFMA")             // bool
-	ir.Syms.ARMHasVFPv4 = sysvar("armHasVFPv4")         // bool
-	ir.Syms.ARM64HasATOMICS = sysvar("arm64HasATOMICS") // bool
-	ir.Syms.Typedmemclr = sysfunc("typedmemclr")
-	ir.Syms.Typedmemmove = sysfunc("typedmemmove")
-	ir.Syms.Udiv = sysvar("udiv")                 // asm func with special ABI
-	ir.Syms.WriteBarrier = sysvar("writeBarrier") // struct { bool; ... }
-	ir.Syms.Zerobase = sysvar("zerobase")
+	ir.Syms.AssertE2I = typecheck.LookupRuntimeFunc("assertE2I")
+	ir.Syms.AssertE2I2 = typecheck.LookupRuntimeFunc("assertE2I2")
+	ir.Syms.AssertI2I = typecheck.LookupRuntimeFunc("assertI2I")
+	ir.Syms.AssertI2I2 = typecheck.LookupRuntimeFunc("assertI2I2")
+	ir.Syms.Deferproc = typecheck.LookupRuntimeFunc("deferproc")
+	ir.Syms.DeferprocStack = typecheck.LookupRuntimeFunc("deferprocStack")
+	ir.Syms.Deferreturn = typecheck.LookupRuntimeFunc("deferreturn")
+	ir.Syms.Duffcopy = typecheck.LookupRuntimeFunc("duffcopy")
+	ir.Syms.Duffzero = typecheck.LookupRuntimeFunc("duffzero")
+	ir.Syms.GCWriteBarrier = typecheck.LookupRuntimeFunc("gcWriteBarrier")
+	ir.Syms.Goschedguarded = typecheck.LookupRuntimeFunc("goschedguarded")
+	ir.Syms.Growslice = typecheck.LookupRuntimeFunc("growslice")
+	ir.Syms.Msanread = typecheck.LookupRuntimeFunc("msanread")
+	ir.Syms.Msanwrite = typecheck.LookupRuntimeFunc("msanwrite")
+	ir.Syms.Msanmove = typecheck.LookupRuntimeFunc("msanmove")
+	ir.Syms.Newobject = typecheck.LookupRuntimeFunc("newobject")
+	ir.Syms.Newproc = typecheck.LookupRuntimeFunc("newproc")
+	ir.Syms.Panicdivide = typecheck.LookupRuntimeFunc("panicdivide")
+	ir.Syms.PanicdottypeE = typecheck.LookupRuntimeFunc("panicdottypeE")
+	ir.Syms.PanicdottypeI = typecheck.LookupRuntimeFunc("panicdottypeI")
+	ir.Syms.Panicnildottype = typecheck.LookupRuntimeFunc("panicnildottype")
+	ir.Syms.Panicoverflow = typecheck.LookupRuntimeFunc("panicoverflow")
+	ir.Syms.Panicshift = typecheck.LookupRuntimeFunc("panicshift")
+	ir.Syms.Raceread = typecheck.LookupRuntimeFunc("raceread")
+	ir.Syms.Racereadrange = typecheck.LookupRuntimeFunc("racereadrange")
+	ir.Syms.Racewrite = typecheck.LookupRuntimeFunc("racewrite")
+	ir.Syms.Racewriterange = typecheck.LookupRuntimeFunc("racewriterange")
+	ir.Syms.X86HasPOPCNT = typecheck.LookupRuntimeVar("x86HasPOPCNT")       // bool
+	ir.Syms.X86HasSSE41 = typecheck.LookupRuntimeVar("x86HasSSE41")         // bool
+	ir.Syms.X86HasFMA = typecheck.LookupRuntimeVar("x86HasFMA")             // bool
+	ir.Syms.ARMHasVFPv4 = typecheck.LookupRuntimeVar("armHasVFPv4")         // bool
+	ir.Syms.ARM64HasATOMICS = typecheck.LookupRuntimeVar("arm64HasATOMICS") // bool
+	ir.Syms.Typedmemclr = typecheck.LookupRuntimeFunc("typedmemclr")
+	ir.Syms.Typedmemmove = typecheck.LookupRuntimeFunc("typedmemmove")
+	ir.Syms.Udiv = typecheck.LookupRuntimeVar("udiv")                 // asm func with special ABI
+	ir.Syms.WriteBarrier = typecheck.LookupRuntimeVar("writeBarrier") // struct { bool; ... }
+	ir.Syms.Zerobase = typecheck.LookupRuntimeVar("zerobase")
 
 	// asm funcs with special ABI
 	if thearch.LinkArch.Name == "amd64" {
 		GCWriteBarrierReg = map[int16]*obj.LSym{
-			x86.REG_AX: sysfunc("gcWriteBarrier"),
-			x86.REG_CX: sysfunc("gcWriteBarrierCX"),
-			x86.REG_DX: sysfunc("gcWriteBarrierDX"),
-			x86.REG_BX: sysfunc("gcWriteBarrierBX"),
-			x86.REG_BP: sysfunc("gcWriteBarrierBP"),
-			x86.REG_SI: sysfunc("gcWriteBarrierSI"),
-			x86.REG_R8: sysfunc("gcWriteBarrierR8"),
-			x86.REG_R9: sysfunc("gcWriteBarrierR9"),
+			x86.REG_AX: typecheck.LookupRuntimeFunc("gcWriteBarrier"),
+			x86.REG_CX: typecheck.LookupRuntimeFunc("gcWriteBarrierCX"),
+			x86.REG_DX: typecheck.LookupRuntimeFunc("gcWriteBarrierDX"),
+			x86.REG_BX: typecheck.LookupRuntimeFunc("gcWriteBarrierBX"),
+			x86.REG_BP: typecheck.LookupRuntimeFunc("gcWriteBarrierBP"),
+			x86.REG_SI: typecheck.LookupRuntimeFunc("gcWriteBarrierSI"),
+			x86.REG_R8: typecheck.LookupRuntimeFunc("gcWriteBarrierR8"),
+			x86.REG_R9: typecheck.LookupRuntimeFunc("gcWriteBarrierR9"),
 		}
 	}
 
 	if thearch.LinkArch.Family == sys.Wasm {
-		BoundsCheckFunc[ssa.BoundsIndex] = sysfunc("goPanicIndex")
-		BoundsCheckFunc[ssa.BoundsIndexU] = sysfunc("goPanicIndexU")
-		BoundsCheckFunc[ssa.BoundsSliceAlen] = sysfunc("goPanicSliceAlen")
-		BoundsCheckFunc[ssa.BoundsSliceAlenU] = sysfunc("goPanicSliceAlenU")
-		BoundsCheckFunc[ssa.BoundsSliceAcap] = sysfunc("goPanicSliceAcap")
-		BoundsCheckFunc[ssa.BoundsSliceAcapU] = sysfunc("goPanicSliceAcapU")
-		BoundsCheckFunc[ssa.BoundsSliceB] = sysfunc("goPanicSliceB")
-		BoundsCheckFunc[ssa.BoundsSliceBU] = sysfunc("goPanicSliceBU")
-		BoundsCheckFunc[ssa.BoundsSlice3Alen] = sysfunc("goPanicSlice3Alen")
-		BoundsCheckFunc[ssa.BoundsSlice3AlenU] = sysfunc("goPanicSlice3AlenU")
-		BoundsCheckFunc[ssa.BoundsSlice3Acap] = sysfunc("goPanicSlice3Acap")
-		BoundsCheckFunc[ssa.BoundsSlice3AcapU] = sysfunc("goPanicSlice3AcapU")
-		BoundsCheckFunc[ssa.BoundsSlice3B] = sysfunc("goPanicSlice3B")
-		BoundsCheckFunc[ssa.BoundsSlice3BU] = sysfunc("goPanicSlice3BU")
-		BoundsCheckFunc[ssa.BoundsSlice3C] = sysfunc("goPanicSlice3C")
-		BoundsCheckFunc[ssa.BoundsSlice3CU] = sysfunc("goPanicSlice3CU")
+		BoundsCheckFunc[ssa.BoundsIndex] = typecheck.LookupRuntimeFunc("goPanicIndex")
+		BoundsCheckFunc[ssa.BoundsIndexU] = typecheck.LookupRuntimeFunc("goPanicIndexU")
+		BoundsCheckFunc[ssa.BoundsSliceAlen] = typecheck.LookupRuntimeFunc("goPanicSliceAlen")
+		BoundsCheckFunc[ssa.BoundsSliceAlenU] = typecheck.LookupRuntimeFunc("goPanicSliceAlenU")
+		BoundsCheckFunc[ssa.BoundsSliceAcap] = typecheck.LookupRuntimeFunc("goPanicSliceAcap")
+		BoundsCheckFunc[ssa.BoundsSliceAcapU] = typecheck.LookupRuntimeFunc("goPanicSliceAcapU")
+		BoundsCheckFunc[ssa.BoundsSliceB] = typecheck.LookupRuntimeFunc("goPanicSliceB")
+		BoundsCheckFunc[ssa.BoundsSliceBU] = typecheck.LookupRuntimeFunc("goPanicSliceBU")
+		BoundsCheckFunc[ssa.BoundsSlice3Alen] = typecheck.LookupRuntimeFunc("goPanicSlice3Alen")
+		BoundsCheckFunc[ssa.BoundsSlice3AlenU] = typecheck.LookupRuntimeFunc("goPanicSlice3AlenU")
+		BoundsCheckFunc[ssa.BoundsSlice3Acap] = typecheck.LookupRuntimeFunc("goPanicSlice3Acap")
+		BoundsCheckFunc[ssa.BoundsSlice3AcapU] = typecheck.LookupRuntimeFunc("goPanicSlice3AcapU")
+		BoundsCheckFunc[ssa.BoundsSlice3B] = typecheck.LookupRuntimeFunc("goPanicSlice3B")
+		BoundsCheckFunc[ssa.BoundsSlice3BU] = typecheck.LookupRuntimeFunc("goPanicSlice3BU")
+		BoundsCheckFunc[ssa.BoundsSlice3C] = typecheck.LookupRuntimeFunc("goPanicSlice3C")
+		BoundsCheckFunc[ssa.BoundsSlice3CU] = typecheck.LookupRuntimeFunc("goPanicSlice3CU")
 	} else {
-		BoundsCheckFunc[ssa.BoundsIndex] = sysfunc("panicIndex")
-		BoundsCheckFunc[ssa.BoundsIndexU] = sysfunc("panicIndexU")
-		BoundsCheckFunc[ssa.BoundsSliceAlen] = sysfunc("panicSliceAlen")
-		BoundsCheckFunc[ssa.BoundsSliceAlenU] = sysfunc("panicSliceAlenU")
-		BoundsCheckFunc[ssa.BoundsSliceAcap] = sysfunc("panicSliceAcap")
-		BoundsCheckFunc[ssa.BoundsSliceAcapU] = sysfunc("panicSliceAcapU")
-		BoundsCheckFunc[ssa.BoundsSliceB] = sysfunc("panicSliceB")
-		BoundsCheckFunc[ssa.BoundsSliceBU] = sysfunc("panicSliceBU")
-		BoundsCheckFunc[ssa.BoundsSlice3Alen] = sysfunc("panicSlice3Alen")
-		BoundsCheckFunc[ssa.BoundsSlice3AlenU] = sysfunc("panicSlice3AlenU")
-		BoundsCheckFunc[ssa.BoundsSlice3Acap] = sysfunc("panicSlice3Acap")
-		BoundsCheckFunc[ssa.BoundsSlice3AcapU] = sysfunc("panicSlice3AcapU")
-		BoundsCheckFunc[ssa.BoundsSlice3B] = sysfunc("panicSlice3B")
-		BoundsCheckFunc[ssa.BoundsSlice3BU] = sysfunc("panicSlice3BU")
-		BoundsCheckFunc[ssa.BoundsSlice3C] = sysfunc("panicSlice3C")
-		BoundsCheckFunc[ssa.BoundsSlice3CU] = sysfunc("panicSlice3CU")
+		BoundsCheckFunc[ssa.BoundsIndex] = typecheck.LookupRuntimeFunc("panicIndex")
+		BoundsCheckFunc[ssa.BoundsIndexU] = typecheck.LookupRuntimeFunc("panicIndexU")
+		BoundsCheckFunc[ssa.BoundsSliceAlen] = typecheck.LookupRuntimeFunc("panicSliceAlen")
+		BoundsCheckFunc[ssa.BoundsSliceAlenU] = typecheck.LookupRuntimeFunc("panicSliceAlenU")
+		BoundsCheckFunc[ssa.BoundsSliceAcap] = typecheck.LookupRuntimeFunc("panicSliceAcap")
+		BoundsCheckFunc[ssa.BoundsSliceAcapU] = typecheck.LookupRuntimeFunc("panicSliceAcapU")
+		BoundsCheckFunc[ssa.BoundsSliceB] = typecheck.LookupRuntimeFunc("panicSliceB")
+		BoundsCheckFunc[ssa.BoundsSliceBU] = typecheck.LookupRuntimeFunc("panicSliceBU")
+		BoundsCheckFunc[ssa.BoundsSlice3Alen] = typecheck.LookupRuntimeFunc("panicSlice3Alen")
+		BoundsCheckFunc[ssa.BoundsSlice3AlenU] = typecheck.LookupRuntimeFunc("panicSlice3AlenU")
+		BoundsCheckFunc[ssa.BoundsSlice3Acap] = typecheck.LookupRuntimeFunc("panicSlice3Acap")
+		BoundsCheckFunc[ssa.BoundsSlice3AcapU] = typecheck.LookupRuntimeFunc("panicSlice3AcapU")
+		BoundsCheckFunc[ssa.BoundsSlice3B] = typecheck.LookupRuntimeFunc("panicSlice3B")
+		BoundsCheckFunc[ssa.BoundsSlice3BU] = typecheck.LookupRuntimeFunc("panicSlice3BU")
+		BoundsCheckFunc[ssa.BoundsSlice3C] = typecheck.LookupRuntimeFunc("panicSlice3C")
+		BoundsCheckFunc[ssa.BoundsSlice3CU] = typecheck.LookupRuntimeFunc("panicSlice3CU")
 	}
 	if thearch.LinkArch.PtrSize == 4 {
-		ExtendCheckFunc[ssa.BoundsIndex] = sysvar("panicExtendIndex")
-		ExtendCheckFunc[ssa.BoundsIndexU] = sysvar("panicExtendIndexU")
-		ExtendCheckFunc[ssa.BoundsSliceAlen] = sysvar("panicExtendSliceAlen")
-		ExtendCheckFunc[ssa.BoundsSliceAlenU] = sysvar("panicExtendSliceAlenU")
-		ExtendCheckFunc[ssa.BoundsSliceAcap] = sysvar("panicExtendSliceAcap")
-		ExtendCheckFunc[ssa.BoundsSliceAcapU] = sysvar("panicExtendSliceAcapU")
-		ExtendCheckFunc[ssa.BoundsSliceB] = sysvar("panicExtendSliceB")
-		ExtendCheckFunc[ssa.BoundsSliceBU] = sysvar("panicExtendSliceBU")
-		ExtendCheckFunc[ssa.BoundsSlice3Alen] = sysvar("panicExtendSlice3Alen")
-		ExtendCheckFunc[ssa.BoundsSlice3AlenU] = sysvar("panicExtendSlice3AlenU")
-		ExtendCheckFunc[ssa.BoundsSlice3Acap] = sysvar("panicExtendSlice3Acap")
-		ExtendCheckFunc[ssa.BoundsSlice3AcapU] = sysvar("panicExtendSlice3AcapU")
-		ExtendCheckFunc[ssa.BoundsSlice3B] = sysvar("panicExtendSlice3B")
-		ExtendCheckFunc[ssa.BoundsSlice3BU] = sysvar("panicExtendSlice3BU")
-		ExtendCheckFunc[ssa.BoundsSlice3C] = sysvar("panicExtendSlice3C")
-		ExtendCheckFunc[ssa.BoundsSlice3CU] = sysvar("panicExtendSlice3CU")
+		ExtendCheckFunc[ssa.BoundsIndex] = typecheck.LookupRuntimeVar("panicExtendIndex")
+		ExtendCheckFunc[ssa.BoundsIndexU] = typecheck.LookupRuntimeVar("panicExtendIndexU")
+		ExtendCheckFunc[ssa.BoundsSliceAlen] = typecheck.LookupRuntimeVar("panicExtendSliceAlen")
+		ExtendCheckFunc[ssa.BoundsSliceAlenU] = typecheck.LookupRuntimeVar("panicExtendSliceAlenU")
+		ExtendCheckFunc[ssa.BoundsSliceAcap] = typecheck.LookupRuntimeVar("panicExtendSliceAcap")
+		ExtendCheckFunc[ssa.BoundsSliceAcapU] = typecheck.LookupRuntimeVar("panicExtendSliceAcapU")
+		ExtendCheckFunc[ssa.BoundsSliceB] = typecheck.LookupRuntimeVar("panicExtendSliceB")
+		ExtendCheckFunc[ssa.BoundsSliceBU] = typecheck.LookupRuntimeVar("panicExtendSliceBU")
+		ExtendCheckFunc[ssa.BoundsSlice3Alen] = typecheck.LookupRuntimeVar("panicExtendSlice3Alen")
+		ExtendCheckFunc[ssa.BoundsSlice3AlenU] = typecheck.LookupRuntimeVar("panicExtendSlice3AlenU")
+		ExtendCheckFunc[ssa.BoundsSlice3Acap] = typecheck.LookupRuntimeVar("panicExtendSlice3Acap")
+		ExtendCheckFunc[ssa.BoundsSlice3AcapU] = typecheck.LookupRuntimeVar("panicExtendSlice3AcapU")
+		ExtendCheckFunc[ssa.BoundsSlice3B] = typecheck.LookupRuntimeVar("panicExtendSlice3B")
+		ExtendCheckFunc[ssa.BoundsSlice3BU] = typecheck.LookupRuntimeVar("panicExtendSlice3BU")
+		ExtendCheckFunc[ssa.BoundsSlice3C] = typecheck.LookupRuntimeVar("panicExtendSlice3C")
+		ExtendCheckFunc[ssa.BoundsSlice3CU] = typecheck.LookupRuntimeVar("panicExtendSlice3CU")
 	}
 
 	// Wasm (all asm funcs with special ABIs)
-	ir.Syms.WasmMove = sysvar("wasmMove")
-	ir.Syms.WasmZero = sysvar("wasmZero")
-	ir.Syms.WasmDiv = sysvar("wasmDiv")
-	ir.Syms.WasmTruncS = sysvar("wasmTruncS")
-	ir.Syms.WasmTruncU = sysvar("wasmTruncU")
-	ir.Syms.SigPanic = sysfunc("sigpanic")
+	ir.Syms.WasmMove = typecheck.LookupRuntimeVar("wasmMove")
+	ir.Syms.WasmZero = typecheck.LookupRuntimeVar("wasmZero")
+	ir.Syms.WasmDiv = typecheck.LookupRuntimeVar("wasmDiv")
+	ir.Syms.WasmTruncS = typecheck.LookupRuntimeVar("wasmTruncS")
+	ir.Syms.WasmTruncU = typecheck.LookupRuntimeVar("wasmTruncU")
+	ir.Syms.SigPanic = typecheck.LookupRuntimeFunc("sigpanic")
 }
 
 // getParam returns the Field of ith param of node n (which is a
@@ -418,7 +419,7 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 		// Create the deferBits variable and stack slot.  deferBits is a
 		// bitmask showing which of the open-coded defers in this function
 		// have been activated.
-		deferBitsTemp := tempAt(src.NoXPos, s.curfn, types.Types[types.TUINT8])
+		deferBitsTemp := typecheck.TempAt(src.NoXPos, s.curfn, types.Types[types.TUINT8])
 		s.deferBitsTemp = deferBitsTemp
 		// For this value, AuxInt is initialized to zero by default
 		startDeferBits := s.entryNewValue0(ssa.OpConst8, types.Types[types.TUINT8])
@@ -710,7 +711,7 @@ func (s *state) Warnl(pos src.XPos, msg string, args ...interface{}) { s.f.Warnl
 func (s *state) Debug_checknil() bool                                { return s.f.Frontend().Debug_checknil() }
 
 func ssaMarker(name string) *ir.Name {
-	return NewName(&types.Sym{Name: name})
+	return typecheck.NewName(&types.Sym{Name: name})
 }
 
 var (
@@ -3342,38 +3343,38 @@ var softFloatOps map[ssa.Op]sfRtCallDef
 func softfloatInit() {
 	// Some of these operations get transformed by sfcall.
 	softFloatOps = map[ssa.Op]sfRtCallDef{
-		ssa.OpAdd32F: sfRtCallDef{sysfunc("fadd32"), types.TFLOAT32},
-		ssa.OpAdd64F: sfRtCallDef{sysfunc("fadd64"), types.TFLOAT64},
-		ssa.OpSub32F: sfRtCallDef{sysfunc("fadd32"), types.TFLOAT32},
-		ssa.OpSub64F: sfRtCallDef{sysfunc("fadd64"), types.TFLOAT64},
-		ssa.OpMul32F: sfRtCallDef{sysfunc("fmul32"), types.TFLOAT32},
-		ssa.OpMul64F: sfRtCallDef{sysfunc("fmul64"), types.TFLOAT64},
-		ssa.OpDiv32F: sfRtCallDef{sysfunc("fdiv32"), types.TFLOAT32},
-		ssa.OpDiv64F: sfRtCallDef{sysfunc("fdiv64"), types.TFLOAT64},
-
-		ssa.OpEq64F:   sfRtCallDef{sysfunc("feq64"), types.TBOOL},
-		ssa.OpEq32F:   sfRtCallDef{sysfunc("feq32"), types.TBOOL},
-		ssa.OpNeq64F:  sfRtCallDef{sysfunc("feq64"), types.TBOOL},
-		ssa.OpNeq32F:  sfRtCallDef{sysfunc("feq32"), types.TBOOL},
-		ssa.OpLess64F: sfRtCallDef{sysfunc("fgt64"), types.TBOOL},
-		ssa.OpLess32F: sfRtCallDef{sysfunc("fgt32"), types.TBOOL},
-		ssa.OpLeq64F:  sfRtCallDef{sysfunc("fge64"), types.TBOOL},
-		ssa.OpLeq32F:  sfRtCallDef{sysfunc("fge32"), types.TBOOL},
-
-		ssa.OpCvt32to32F:  sfRtCallDef{sysfunc("fint32to32"), types.TFLOAT32},
-		ssa.OpCvt32Fto32:  sfRtCallDef{sysfunc("f32toint32"), types.TINT32},
-		ssa.OpCvt64to32F:  sfRtCallDef{sysfunc("fint64to32"), types.TFLOAT32},
-		ssa.OpCvt32Fto64:  sfRtCallDef{sysfunc("f32toint64"), types.TINT64},
-		ssa.OpCvt64Uto32F: sfRtCallDef{sysfunc("fuint64to32"), types.TFLOAT32},
-		ssa.OpCvt32Fto64U: sfRtCallDef{sysfunc("f32touint64"), types.TUINT64},
-		ssa.OpCvt32to64F:  sfRtCallDef{sysfunc("fint32to64"), types.TFLOAT64},
-		ssa.OpCvt64Fto32:  sfRtCallDef{sysfunc("f64toint32"), types.TINT32},
-		ssa.OpCvt64to64F:  sfRtCallDef{sysfunc("fint64to64"), types.TFLOAT64},
-		ssa.OpCvt64Fto64:  sfRtCallDef{sysfunc("f64toint64"), types.TINT64},
-		ssa.OpCvt64Uto64F: sfRtCallDef{sysfunc("fuint64to64"), types.TFLOAT64},
-		ssa.OpCvt64Fto64U: sfRtCallDef{sysfunc("f64touint64"), types.TUINT64},
-		ssa.OpCvt32Fto64F: sfRtCallDef{sysfunc("f32to64"), types.TFLOAT64},
-		ssa.OpCvt64Fto32F: sfRtCallDef{sysfunc("f64to32"), types.TFLOAT32},
+		ssa.OpAdd32F: sfRtCallDef{typecheck.LookupRuntimeFunc("fadd32"), types.TFLOAT32},
+		ssa.OpAdd64F: sfRtCallDef{typecheck.LookupRuntimeFunc("fadd64"), types.TFLOAT64},
+		ssa.OpSub32F: sfRtCallDef{typecheck.LookupRuntimeFunc("fadd32"), types.TFLOAT32},
+		ssa.OpSub64F: sfRtCallDef{typecheck.LookupRuntimeFunc("fadd64"), types.TFLOAT64},
+		ssa.OpMul32F: sfRtCallDef{typecheck.LookupRuntimeFunc("fmul32"), types.TFLOAT32},
+		ssa.OpMul64F: sfRtCallDef{typecheck.LookupRuntimeFunc("fmul64"), types.TFLOAT64},
+		ssa.OpDiv32F: sfRtCallDef{typecheck.LookupRuntimeFunc("fdiv32"), types.TFLOAT32},
+		ssa.OpDiv64F: sfRtCallDef{typecheck.LookupRuntimeFunc("fdiv64"), types.TFLOAT64},
+
+		ssa.OpEq64F:   sfRtCallDef{typecheck.LookupRuntimeFunc("feq64"), types.TBOOL},
+		ssa.OpEq32F:   sfRtCallDef{typecheck.LookupRuntimeFunc("feq32"), types.TBOOL},
+		ssa.OpNeq64F:  sfRtCallDef{typecheck.LookupRuntimeFunc("feq64"), types.TBOOL},
+		ssa.OpNeq32F:  sfRtCallDef{typecheck.LookupRuntimeFunc("feq32"), types.TBOOL},
+		ssa.OpLess64F: sfRtCallDef{typecheck.LookupRuntimeFunc("fgt64"), types.TBOOL},
+		ssa.OpLess32F: sfRtCallDef{typecheck.LookupRuntimeFunc("fgt32"), types.TBOOL},
+		ssa.OpLeq64F:  sfRtCallDef{typecheck.LookupRuntimeFunc("fge64"), types.TBOOL},
+		ssa.OpLeq32F:  sfRtCallDef{typecheck.LookupRuntimeFunc("fge32"), types.TBOOL},
+
+		ssa.OpCvt32to32F:  sfRtCallDef{typecheck.LookupRuntimeFunc("fint32to32"), types.TFLOAT32},
+		ssa.OpCvt32Fto32:  sfRtCallDef{typecheck.LookupRuntimeFunc("f32toint32"), types.TINT32},
+		ssa.OpCvt64to32F:  sfRtCallDef{typecheck.LookupRuntimeFunc("fint64to32"), types.TFLOAT32},
+		ssa.OpCvt32Fto64:  sfRtCallDef{typecheck.LookupRuntimeFunc("f32toint64"), types.TINT64},
+		ssa.OpCvt64Uto32F: sfRtCallDef{typecheck.LookupRuntimeFunc("fuint64to32"), types.TFLOAT32},
+		ssa.OpCvt32Fto64U: sfRtCallDef{typecheck.LookupRuntimeFunc("f32touint64"), types.TUINT64},
+		ssa.OpCvt32to64F:  sfRtCallDef{typecheck.LookupRuntimeFunc("fint32to64"), types.TFLOAT64},
+		ssa.OpCvt64Fto32:  sfRtCallDef{typecheck.LookupRuntimeFunc("f64toint32"), types.TINT32},
+		ssa.OpCvt64to64F:  sfRtCallDef{typecheck.LookupRuntimeFunc("fint64to64"), types.TFLOAT64},
+		ssa.OpCvt64Fto64:  sfRtCallDef{typecheck.LookupRuntimeFunc("f64toint64"), types.TINT64},
+		ssa.OpCvt64Uto64F: sfRtCallDef{typecheck.LookupRuntimeFunc("fuint64to64"), types.TFLOAT64},
+		ssa.OpCvt64Fto64U: sfRtCallDef{typecheck.LookupRuntimeFunc("f64touint64"), types.TUINT64},
+		ssa.OpCvt32Fto64F: sfRtCallDef{typecheck.LookupRuntimeFunc("f32to64"), types.TFLOAT64},
+		ssa.OpCvt64Fto32F: sfRtCallDef{typecheck.LookupRuntimeFunc("f64to32"), types.TFLOAT32},
 	}
 }
 
@@ -4458,7 +4459,7 @@ func (s *state) openDeferSave(n ir.Node, t *types.Type, val *ssa.Value) *ssa.Val
 	} else {
 		pos = n.Pos()
 	}
-	argTemp := tempAt(pos.WithNotStmt(), s.curfn, t)
+	argTemp := typecheck.TempAt(pos.WithNotStmt(), s.curfn, t)
 	argTemp.SetOpenDeferSlot(true)
 	var addrArgTemp *ssa.Value
 	// Use OpVarLive to make sure stack slots for the args, etc. are not
@@ -4719,7 +4720,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		testLateExpansion = ssa.LateCallExpansionEnabledWithin(s.f)
 		// Make a defer struct d on the stack.
 		t := deferstruct(stksize)
-		d := tempAt(n.Pos(), s.curfn, t)
+		d := typecheck.TempAt(n.Pos(), s.curfn, t)
 
 		s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, d, s.mem())
 		addr := s.addr(d)
@@ -6144,7 +6145,7 @@ func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Val
 	if commaok && !canSSAType(n.Type()) {
 		// unSSAable type, use temporary.
 		// TODO: get rid of some of these temporaries.
-		tmp = tempAt(n.Pos(), s.curfn, n.Type())
+		tmp = typecheck.TempAt(n.Pos(), s.curfn, n.Type())
 		s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, tmp.(*ir.Name), s.mem())
 		addr = s.addr(tmp)
 	}
@@ -7173,7 +7174,7 @@ func (e *ssafn) StringData(s string) *obj.LSym {
 }
 
 func (e *ssafn) Auto(pos src.XPos, t *types.Type) *ir.Name {
-	return tempAt(pos, e.curfn, t) // Note: adds new auto to e.curfn.Func.Dcl list
+	return typecheck.TempAt(pos, e.curfn, t) // Note: adds new auto to e.curfn.Func.Dcl list
 }
 
 func (e *ssafn) SplitString(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot) {
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index d4c7c6db1a..8e2093d488 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -7,11 +7,10 @@ package gc
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"fmt"
-	"sort"
-	"strconv"
 	"strings"
 	"sync"
 	"unicode"
@@ -31,71 +30,35 @@ var (
 	largeStackFrames   []largeStack
 )
 
-func lookup(name string) *types.Sym {
-	return types.LocalPkg.Lookup(name)
-}
-
-// lookupN looks up the symbol starting with prefix and ending with
-// the decimal n. If prefix is too long, lookupN panics.
-func lookupN(prefix string, n int) *types.Sym {
-	var buf [20]byte // plenty long enough for all current users
-	copy(buf[:], prefix)
-	b := strconv.AppendInt(buf[:len(prefix)], int64(n), 10)
-	return types.LocalPkg.LookupBytes(b)
-}
-
-// autolabel generates a new Name node for use with
-// an automatically generated label.
-// prefix is a short mnemonic (e.g. ".s" for switch)
-// to help with debugging.
-// It should begin with "." to avoid conflicts with
-// user labels.
-func autolabel(prefix string) *types.Sym {
-	if prefix[0] != '.' {
-		base.Fatalf("autolabel prefix must start with '.', have %q", prefix)
-	}
-	fn := ir.CurFunc
-	if ir.CurFunc == nil {
-		base.Fatalf("autolabel outside function")
-	}
-	n := fn.Label
-	fn.Label++
-	return lookupN(prefix, int(n))
-}
-
 // dotImports tracks all PkgNames that have been dot-imported.
 var dotImports []*ir.PkgName
 
-// dotImportRefs maps idents introduced by importDot back to the
-// ir.PkgName they were dot-imported through.
-var dotImportRefs map[*ir.Ident]*ir.PkgName
-
 // find all the exported symbols in package referenced by PkgName,
 // and make them available in the current package
 func importDot(pack *ir.PkgName) {
-	if dotImportRefs == nil {
-		dotImportRefs = make(map[*ir.Ident]*ir.PkgName)
+	if typecheck.DotImportRefs == nil {
+		typecheck.DotImportRefs = make(map[*ir.Ident]*ir.PkgName)
 	}
 
 	opkg := pack.Pkg
 	for _, s := range opkg.Syms {
 		if s.Def == nil {
-			if _, ok := declImporter[s]; !ok {
+			if _, ok := typecheck.DeclImporter[s]; !ok {
 				continue
 			}
 		}
 		if !types.IsExported(s.Name) || strings.ContainsRune(s.Name, 0xb7) { // 0xb7 = center dot
 			continue
 		}
-		s1 := lookup(s.Name)
+		s1 := typecheck.Lookup(s.Name)
 		if s1.Def != nil {
 			pkgerror := fmt.Sprintf("during import %q", opkg.Path)
-			redeclare(base.Pos, s1, pkgerror)
+			typecheck.Redeclared(base.Pos, s1, pkgerror)
 			continue
 		}
 
 		id := ir.NewIdent(src.NoXPos, s)
-		dotImportRefs[id] = pack
+		typecheck.DotImportRefs[id] = pack
 		s1.Def = id
 		s1.Block = 1
 	}
@@ -113,347 +76,7 @@ func checkDotImports() {
 
 	// No longer needed; release memory.
 	dotImports = nil
-	dotImportRefs = nil
-}
-
-// nodAddr returns a node representing &n at base.Pos.
-func nodAddr(n ir.Node) *ir.AddrExpr {
-	return nodAddrAt(base.Pos, n)
-}
-
-// nodAddrPos returns a node representing &n at position pos.
-func nodAddrAt(pos src.XPos, n ir.Node) *ir.AddrExpr {
-	return ir.NewAddrExpr(pos, n)
-}
-
-// newname returns a new ONAME Node associated with symbol s.
-func NewName(s *types.Sym) *ir.Name {
-	n := ir.NewNameAt(base.Pos, s)
-	n.Curfn = ir.CurFunc
-	return n
-}
-
-func nodnil() ir.Node {
-	n := ir.NewNilExpr(base.Pos)
-	n.SetType(types.Types[types.TNIL])
-	return n
-}
-
-func isptrto(t *types.Type, et types.Kind) bool {
-	if t == nil {
-		return false
-	}
-	if !t.IsPtr() {
-		return false
-	}
-	t = t.Elem()
-	if t == nil {
-		return false
-	}
-	if t.Kind() != et {
-		return false
-	}
-	return true
-}
-
-// Is type src assignment compatible to type dst?
-// If so, return op code to use in conversion.
-// If not, return OXXX. In this case, the string return parameter may
-// hold a reason why. In all other cases, it'll be the empty string.
-func assignop(src, dst *types.Type) (ir.Op, string) {
-	if src == dst {
-		return ir.OCONVNOP, ""
-	}
-	if src == nil || dst == nil || src.Kind() == types.TFORW || dst.Kind() == types.TFORW || src.Underlying() == nil || dst.Underlying() == nil {
-		return ir.OXXX, ""
-	}
-
-	// 1. src type is identical to dst.
-	if types.Identical(src, dst) {
-		return ir.OCONVNOP, ""
-	}
-
-	// 2. src and dst have identical underlying types
-	// and either src or dst is not a named type or
-	// both are empty interface types.
-	// For assignable but different non-empty interface types,
-	// we want to recompute the itab. Recomputing the itab ensures
-	// that itabs are unique (thus an interface with a compile-time
-	// type I has an itab with interface type I).
-	if types.Identical(src.Underlying(), dst.Underlying()) {
-		if src.IsEmptyInterface() {
-			// Conversion between two empty interfaces
-			// requires no code.
-			return ir.OCONVNOP, ""
-		}
-		if (src.Sym() == nil || dst.Sym() == nil) && !src.IsInterface() {
-			// Conversion between two types, at least one unnamed,
-			// needs no conversion. The exception is nonempty interfaces
-			// which need to have their itab updated.
-			return ir.OCONVNOP, ""
-		}
-	}
-
-	// 3. dst is an interface type and src implements dst.
-	if dst.IsInterface() && src.Kind() != types.TNIL {
-		var missing, have *types.Field
-		var ptr int
-		if implements(src, dst, &missing, &have, &ptr) {
-			// Call itabname so that (src, dst)
-			// gets added to itabs early, which allows
-			// us to de-virtualize calls through this
-			// type/interface pair later. See peekitabs in reflect.go
-			if types.IsDirectIface(src) && !dst.IsEmptyInterface() {
-				NeedITab(src, dst)
-			}
-
-			return ir.OCONVIFACE, ""
-		}
-
-		// we'll have complained about this method anyway, suppress spurious messages.
-		if have != nil && have.Sym == missing.Sym && (have.Type.Broke() || missing.Type.Broke()) {
-			return ir.OCONVIFACE, ""
-		}
-
-		var why string
-		if isptrto(src, types.TINTER) {
-			why = fmt.Sprintf(":\n\t%v is pointer to interface, not interface", src)
-		} else if have != nil && have.Sym == missing.Sym && have.Nointerface() {
-			why = fmt.Sprintf(":\n\t%v does not implement %v (%v method is marked 'nointerface')", src, dst, missing.Sym)
-		} else if have != nil && have.Sym == missing.Sym {
-			why = fmt.Sprintf(":\n\t%v does not implement %v (wrong type for %v method)\n"+
-				"\t\thave %v%S\n\t\twant %v%S", src, dst, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
-		} else if ptr != 0 {
-			why = fmt.Sprintf(":\n\t%v does not implement %v (%v method has pointer receiver)", src, dst, missing.Sym)
-		} else if have != nil {
-			why = fmt.Sprintf(":\n\t%v does not implement %v (missing %v method)\n"+
-				"\t\thave %v%S\n\t\twant %v%S", src, dst, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
-		} else {
-			why = fmt.Sprintf(":\n\t%v does not implement %v (missing %v method)", src, dst, missing.Sym)
-		}
-
-		return ir.OXXX, why
-	}
-
-	if isptrto(dst, types.TINTER) {
-		why := fmt.Sprintf(":\n\t%v is pointer to interface, not interface", dst)
-		return ir.OXXX, why
-	}
-
-	if src.IsInterface() && dst.Kind() != types.TBLANK {
-		var missing, have *types.Field
-		var ptr int
-		var why string
-		if implements(dst, src, &missing, &have, &ptr) {
-			why = ": need type assertion"
-		}
-		return ir.OXXX, why
-	}
-
-	// 4. src is a bidirectional channel value, dst is a channel type,
-	// src and dst have identical element types, and
-	// either src or dst is not a named type.
-	if src.IsChan() && src.ChanDir() == types.Cboth && dst.IsChan() {
-		if types.Identical(src.Elem(), dst.Elem()) && (src.Sym() == nil || dst.Sym() == nil) {
-			return ir.OCONVNOP, ""
-		}
-	}
-
-	// 5. src is the predeclared identifier nil and dst is a nillable type.
-	if src.Kind() == types.TNIL {
-		switch dst.Kind() {
-		case types.TPTR,
-			types.TFUNC,
-			types.TMAP,
-			types.TCHAN,
-			types.TINTER,
-			types.TSLICE:
-			return ir.OCONVNOP, ""
-		}
-	}
-
-	// 6. rule about untyped constants - already converted by defaultlit.
-
-	// 7. Any typed value can be assigned to the blank identifier.
-	if dst.Kind() == types.TBLANK {
-		return ir.OCONVNOP, ""
-	}
-
-	return ir.OXXX, ""
-}
-
-// Can we convert a value of type src to a value of type dst?
-// If so, return op code to use in conversion (maybe OCONVNOP).
-// If not, return OXXX. In this case, the string return parameter may
-// hold a reason why. In all other cases, it'll be the empty string.
-// srcConstant indicates whether the value of type src is a constant.
-func convertop(srcConstant bool, src, dst *types.Type) (ir.Op, string) {
-	if src == dst {
-		return ir.OCONVNOP, ""
-	}
-	if src == nil || dst == nil {
-		return ir.OXXX, ""
-	}
-
-	// Conversions from regular to go:notinheap are not allowed
-	// (unless it's unsafe.Pointer). These are runtime-specific
-	// rules.
-	// (a) Disallow (*T) to (*U) where T is go:notinheap but U isn't.
-	if src.IsPtr() && dst.IsPtr() && dst.Elem().NotInHeap() && !src.Elem().NotInHeap() {
-		why := fmt.Sprintf(":\n\t%v is incomplete (or unallocatable), but %v is not", dst.Elem(), src.Elem())
-		return ir.OXXX, why
-	}
-	// (b) Disallow string to []T where T is go:notinheap.
-	if src.IsString() && dst.IsSlice() && dst.Elem().NotInHeap() && (dst.Elem().Kind() == types.ByteType.Kind() || dst.Elem().Kind() == types.RuneType.Kind()) {
-		why := fmt.Sprintf(":\n\t%v is incomplete (or unallocatable)", dst.Elem())
-		return ir.OXXX, why
-	}
-
-	// 1. src can be assigned to dst.
-	op, why := assignop(src, dst)
-	if op != ir.OXXX {
-		return op, why
-	}
-
-	// The rules for interfaces are no different in conversions
-	// than assignments. If interfaces are involved, stop now
-	// with the good message from assignop.
-	// Otherwise clear the error.
-	if src.IsInterface() || dst.IsInterface() {
-		return ir.OXXX, why
-	}
-
-	// 2. Ignoring struct tags, src and dst have identical underlying types.
-	if types.IdenticalIgnoreTags(src.Underlying(), dst.Underlying()) {
-		return ir.OCONVNOP, ""
-	}
-
-	// 3. src and dst are unnamed pointer types and, ignoring struct tags,
-	// their base types have identical underlying types.
-	if src.IsPtr() && dst.IsPtr() && src.Sym() == nil && dst.Sym() == nil {
-		if types.IdenticalIgnoreTags(src.Elem().Underlying(), dst.Elem().Underlying()) {
-			return ir.OCONVNOP, ""
-		}
-	}
-
-	// 4. src and dst are both integer or floating point types.
-	if (src.IsInteger() || src.IsFloat()) && (dst.IsInteger() || dst.IsFloat()) {
-		if types.SimType[src.Kind()] == types.SimType[dst.Kind()] {
-			return ir.OCONVNOP, ""
-		}
-		return ir.OCONV, ""
-	}
-
-	// 5. src and dst are both complex types.
-	if src.IsComplex() && dst.IsComplex() {
-		if types.SimType[src.Kind()] == types.SimType[dst.Kind()] {
-			return ir.OCONVNOP, ""
-		}
-		return ir.OCONV, ""
-	}
-
-	// Special case for constant conversions: any numeric
-	// conversion is potentially okay. We'll validate further
-	// within evconst. See #38117.
-	if srcConstant && (src.IsInteger() || src.IsFloat() || src.IsComplex()) && (dst.IsInteger() || dst.IsFloat() || dst.IsComplex()) {
-		return ir.OCONV, ""
-	}
-
-	// 6. src is an integer or has type []byte or []rune
-	// and dst is a string type.
-	if src.IsInteger() && dst.IsString() {
-		return ir.ORUNESTR, ""
-	}
-
-	if src.IsSlice() && dst.IsString() {
-		if src.Elem().Kind() == types.ByteType.Kind() {
-			return ir.OBYTES2STR, ""
-		}
-		if src.Elem().Kind() == types.RuneType.Kind() {
-			return ir.ORUNES2STR, ""
-		}
-	}
-
-	// 7. src is a string and dst is []byte or []rune.
-	// String to slice.
-	if src.IsString() && dst.IsSlice() {
-		if dst.Elem().Kind() == types.ByteType.Kind() {
-			return ir.OSTR2BYTES, ""
-		}
-		if dst.Elem().Kind() == types.RuneType.Kind() {
-			return ir.OSTR2RUNES, ""
-		}
-	}
-
-	// 8. src is a pointer or uintptr and dst is unsafe.Pointer.
-	if (src.IsPtr() || src.IsUintptr()) && dst.IsUnsafePtr() {
-		return ir.OCONVNOP, ""
-	}
-
-	// 9. src is unsafe.Pointer and dst is a pointer or uintptr.
-	if src.IsUnsafePtr() && (dst.IsPtr() || dst.IsUintptr()) {
-		return ir.OCONVNOP, ""
-	}
-
-	// src is map and dst is a pointer to corresponding hmap.
-	// This rule is needed for the implementation detail that
-	// go gc maps are implemented as a pointer to a hmap struct.
-	if src.Kind() == types.TMAP && dst.IsPtr() &&
-		src.MapType().Hmap == dst.Elem() {
-		return ir.OCONVNOP, ""
-	}
-
-	return ir.OXXX, ""
-}
-
-func assignconv(n ir.Node, t *types.Type, context string) ir.Node {
-	return assignconvfn(n, t, func() string { return context })
-}
-
-// Convert node n for assignment to type t.
-func assignconvfn(n ir.Node, t *types.Type, context func() string) ir.Node {
-	if n == nil || n.Type() == nil || n.Type().Broke() {
-		return n
-	}
-
-	if t.Kind() == types.TBLANK && n.Type().Kind() == types.TNIL {
-		base.Errorf("use of untyped nil")
-	}
-
-	n = convlit1(n, t, false, context)
-	if n.Type() == nil {
-		return n
-	}
-	if t.Kind() == types.TBLANK {
-		return n
-	}
-
-	// Convert ideal bool from comparison to plain bool
-	// if the next step is non-bool (like interface{}).
-	if n.Type() == types.UntypedBool && !t.IsBoolean() {
-		if n.Op() == ir.ONAME || n.Op() == ir.OLITERAL {
-			r := ir.NewConvExpr(base.Pos, ir.OCONVNOP, nil, n)
-			r.SetType(types.Types[types.TBOOL])
-			r.SetTypecheck(1)
-			r.SetImplicit(true)
-			n = r
-		}
-	}
-
-	if types.Identical(n.Type(), t) {
-		return n
-	}
-
-	op, why := assignop(n.Type(), t)
-	if op == ir.OXXX {
-		base.Errorf("cannot use %L as type %v in %s%s", n, t, context(), why)
-		op = ir.OCONV
-	}
-
-	r := ir.NewConvExpr(base.Pos, op, t, n)
-	r.SetTypecheck(1)
-	r.SetImplicit(true)
-	return r
+	typecheck.DotImportRefs = nil
 }
 
 // backingArrayPtrLen extracts the pointer and length from a slice or string.
@@ -475,14 +98,6 @@ func backingArrayPtrLen(n ir.Node) (ptr, length ir.Node) {
 	return ptr, length
 }
 
-func syslook(name string) *ir.Name {
-	s := ir.Pkgs.Runtime.Lookup(name)
-	if s == nil || s.Def == nil {
-		base.Fatalf("syslook: can't find runtime.%s", name)
-	}
-	return ir.AsNode(s.Def).(*ir.Name)
-}
-
 // updateHasCall checks whether expression n contains any function
 // calls and sets the n.HasCall flag if so.
 func updateHasCall(n ir.Node) {
@@ -689,7 +304,7 @@ func safeexpr(n ir.Node, init *ir.Nodes) ir.Node {
 		}
 		a := ir.Copy(n).(*ir.UnaryExpr)
 		a.X = l
-		return walkexpr(typecheck(a, ctxExpr), init)
+		return walkexpr(typecheck.Expr(a), init)
 
 	case ir.ODOT, ir.ODOTPTR:
 		n := n.(*ir.SelectorExpr)
@@ -699,7 +314,7 @@ func safeexpr(n ir.Node, init *ir.Nodes) ir.Node {
 		}
 		a := ir.Copy(n).(*ir.SelectorExpr)
 		a.X = l
-		return walkexpr(typecheck(a, ctxExpr), init)
+		return walkexpr(typecheck.Expr(a), init)
 
 	case ir.ODEREF:
 		n := n.(*ir.StarExpr)
@@ -709,7 +324,7 @@ func safeexpr(n ir.Node, init *ir.Nodes) ir.Node {
 		}
 		a := ir.Copy(n).(*ir.StarExpr)
 		a.X = l
-		return walkexpr(typecheck(a, ctxExpr), init)
+		return walkexpr(typecheck.Expr(a), init)
 
 	case ir.OINDEX, ir.OINDEXMAP:
 		n := n.(*ir.IndexExpr)
@@ -721,7 +336,7 @@ func safeexpr(n ir.Node, init *ir.Nodes) ir.Node {
 		a := ir.Copy(n).(*ir.IndexExpr)
 		a.X = l
 		a.Index = r
-		return walkexpr(typecheck(a, ctxExpr), init)
+		return walkexpr(typecheck.Expr(a), init)
 
 	case ir.OSTRUCTLIT, ir.OARRAYLIT, ir.OSLICELIT:
 		n := n.(*ir.CompLitExpr)
@@ -738,7 +353,7 @@ func safeexpr(n ir.Node, init *ir.Nodes) ir.Node {
 }
 
 func copyexpr(n ir.Node, t *types.Type, init *ir.Nodes) ir.Node {
-	l := temp(t)
+	l := typecheck.Temp(t)
 	appendWalkStmt(init, ir.NewAssignStmt(base.Pos, l, n))
 	return l
 }
@@ -754,323 +369,6 @@ func cheapexpr(n ir.Node, init *ir.Nodes) ir.Node {
 	return copyexpr(n, n.Type(), init)
 }
 
-// Code to resolve elided DOTs in embedded types.
-
-// A Dlist stores a pointer to a TFIELD Type embedded within
-// a TSTRUCT or TINTER Type.
-type Dlist struct {
-	field *types.Field
-}
-
-// dotlist is used by adddot1 to record the path of embedded fields
-// used to access a target field or method.
-// Must be non-nil so that dotpath returns a non-nil slice even if d is zero.
-var dotlist = make([]Dlist, 10)
-
-// lookdot0 returns the number of fields or methods named s associated
-// with Type t. If exactly one exists, it will be returned in *save
-// (if save is not nil).
-func lookdot0(s *types.Sym, t *types.Type, save **types.Field, ignorecase bool) int {
-	u := t
-	if u.IsPtr() {
-		u = u.Elem()
-	}
-
-	c := 0
-	if u.IsStruct() || u.IsInterface() {
-		for _, f := range u.Fields().Slice() {
-			if f.Sym == s || (ignorecase && f.IsMethod() && strings.EqualFold(f.Sym.Name, s.Name)) {
-				if save != nil {
-					*save = f
-				}
-				c++
-			}
-		}
-	}
-
-	u = t
-	if t.Sym() != nil && t.IsPtr() && !t.Elem().IsPtr() {
-		// If t is a defined pointer type, then x.m is shorthand for (*x).m.
-		u = t.Elem()
-	}
-	u = types.ReceiverBaseType(u)
-	if u != nil {
-		for _, f := range u.Methods().Slice() {
-			if f.Embedded == 0 && (f.Sym == s || (ignorecase && strings.EqualFold(f.Sym.Name, s.Name))) {
-				if save != nil {
-					*save = f
-				}
-				c++
-			}
-		}
-	}
-
-	return c
-}
-
-// adddot1 returns the number of fields or methods named s at depth d in Type t.
-// If exactly one exists, it will be returned in *save (if save is not nil),
-// and dotlist will contain the path of embedded fields traversed to find it,
-// in reverse order. If none exist, more will indicate whether t contains any
-// embedded fields at depth d, so callers can decide whether to retry at
-// a greater depth.
-func adddot1(s *types.Sym, t *types.Type, d int, save **types.Field, ignorecase bool) (c int, more bool) {
-	if t.Recur() {
-		return
-	}
-	t.SetRecur(true)
-	defer t.SetRecur(false)
-
-	var u *types.Type
-	d--
-	if d < 0 {
-		// We've reached our target depth. If t has any fields/methods
-		// named s, then we're done. Otherwise, we still need to check
-		// below for embedded fields.
-		c = lookdot0(s, t, save, ignorecase)
-		if c != 0 {
-			return c, false
-		}
-	}
-
-	u = t
-	if u.IsPtr() {
-		u = u.Elem()
-	}
-	if !u.IsStruct() && !u.IsInterface() {
-		return c, false
-	}
-
-	for _, f := range u.Fields().Slice() {
-		if f.Embedded == 0 || f.Sym == nil {
-			continue
-		}
-		if d < 0 {
-			// Found an embedded field at target depth.
-			return c, true
-		}
-		a, more1 := adddot1(s, f.Type, d, save, ignorecase)
-		if a != 0 && c == 0 {
-			dotlist[d].field = f
-		}
-		c += a
-		if more1 {
-			more = true
-		}
-	}
-
-	return c, more
-}
-
-// dotpath computes the unique shortest explicit selector path to fully qualify
-// a selection expression x.f, where x is of type t and f is the symbol s.
-// If no such path exists, dotpath returns nil.
-// If there are multiple shortest paths to the same depth, ambig is true.
-func dotpath(s *types.Sym, t *types.Type, save **types.Field, ignorecase bool) (path []Dlist, ambig bool) {
-	// The embedding of types within structs imposes a tree structure onto
-	// types: structs parent the types they embed, and types parent their
-	// fields or methods. Our goal here is to find the shortest path to
-	// a field or method named s in the subtree rooted at t. To accomplish
-	// that, we iteratively perform depth-first searches of increasing depth
-	// until we either find the named field/method or exhaust the tree.
-	for d := 0; ; d++ {
-		if d > len(dotlist) {
-			dotlist = append(dotlist, Dlist{})
-		}
-		if c, more := adddot1(s, t, d, save, ignorecase); c == 1 {
-			return dotlist[:d], false
-		} else if c > 1 {
-			return nil, true
-		} else if !more {
-			return nil, false
-		}
-	}
-}
-
-// in T.field
-// find missing fields that
-// will give shortest unique addressing.
-// modify the tree with missing type names.
-func adddot(n *ir.SelectorExpr) *ir.SelectorExpr {
-	n.X = typecheck(n.X, ctxType|ctxExpr)
-	if n.X.Diag() {
-		n.SetDiag(true)
-	}
-	t := n.X.Type()
-	if t == nil {
-		return n
-	}
-
-	if n.X.Op() == ir.OTYPE {
-		return n
-	}
-
-	s := n.Sel
-	if s == nil {
-		return n
-	}
-
-	switch path, ambig := dotpath(s, t, nil, false); {
-	case path != nil:
-		// rebuild elided dots
-		for c := len(path) - 1; c >= 0; c-- {
-			dot := ir.NewSelectorExpr(base.Pos, ir.ODOT, n.X, path[c].field.Sym)
-			dot.SetImplicit(true)
-			dot.SetType(path[c].field.Type)
-			n.X = dot
-		}
-	case ambig:
-		base.Errorf("ambiguous selector %v", n)
-		n.X = nil
-	}
-
-	return n
-}
-
-// Code to help generate trampoline functions for methods on embedded
-// types. These are approx the same as the corresponding adddot
-// routines except that they expect to be called with unique tasks and
-// they return the actual methods.
-
-type Symlink struct {
-	field *types.Field
-}
-
-var slist []Symlink
-
-func expand0(t *types.Type) {
-	u := t
-	if u.IsPtr() {
-		u = u.Elem()
-	}
-
-	if u.IsInterface() {
-		for _, f := range u.Fields().Slice() {
-			if f.Sym.Uniq() {
-				continue
-			}
-			f.Sym.SetUniq(true)
-			slist = append(slist, Symlink{field: f})
-		}
-
-		return
-	}
-
-	u = types.ReceiverBaseType(t)
-	if u != nil {
-		for _, f := range u.Methods().Slice() {
-			if f.Sym.Uniq() {
-				continue
-			}
-			f.Sym.SetUniq(true)
-			slist = append(slist, Symlink{field: f})
-		}
-	}
-}
-
-func expand1(t *types.Type, top bool) {
-	if t.Recur() {
-		return
-	}
-	t.SetRecur(true)
-
-	if !top {
-		expand0(t)
-	}
-
-	u := t
-	if u.IsPtr() {
-		u = u.Elem()
-	}
-
-	if u.IsStruct() || u.IsInterface() {
-		for _, f := range u.Fields().Slice() {
-			if f.Embedded == 0 {
-				continue
-			}
-			if f.Sym == nil {
-				continue
-			}
-			expand1(f.Type, false)
-		}
-	}
-
-	t.SetRecur(false)
-}
-
-func expandmeth(t *types.Type) {
-	if t == nil || t.AllMethods().Len() != 0 {
-		return
-	}
-
-	// mark top-level method symbols
-	// so that expand1 doesn't consider them.
-	for _, f := range t.Methods().Slice() {
-		f.Sym.SetUniq(true)
-	}
-
-	// generate all reachable methods
-	slist = slist[:0]
-	expand1(t, true)
-
-	// check each method to be uniquely reachable
-	var ms []*types.Field
-	for i, sl := range slist {
-		slist[i].field = nil
-		sl.field.Sym.SetUniq(false)
-
-		var f *types.Field
-		path, _ := dotpath(sl.field.Sym, t, &f, false)
-		if path == nil {
-			continue
-		}
-
-		// dotpath may have dug out arbitrary fields, we only want methods.
-		if !f.IsMethod() {
-			continue
-		}
-
-		// add it to the base type method list
-		f = f.Copy()
-		f.Embedded = 1 // needs a trampoline
-		for _, d := range path {
-			if d.field.Type.IsPtr() {
-				f.Embedded = 2
-				break
-			}
-		}
-		ms = append(ms, f)
-	}
-
-	for _, f := range t.Methods().Slice() {
-		f.Sym.SetUniq(false)
-	}
-
-	ms = append(ms, t.Methods().Slice()...)
-	sort.Sort(types.MethodsByName(ms))
-	t.AllMethods().Set(ms)
-}
-
-// Given funarg struct list, return list of fn args.
-func structargs(tl *types.Type, mustname bool) []*ir.Field {
-	var args []*ir.Field
-	gen := 0
-	for _, t := range tl.Fields().Slice() {
-		s := t.Sym
-		if mustname && (s == nil || s.Name == "_") {
-			// invent a name so that we can refer to it in the trampoline
-			s = lookupN(".anon", gen)
-			gen++
-		}
-		a := ir.NewField(base.Pos, s, nil, t.Type)
-		a.Pos = t.Pos
-		a.IsDDD = t.IsDDD()
-		args = append(args, a)
-	}
-
-	return args
-}
-
 // Generate a wrapper function to convert from
 // a receiver of type T to a receiver of type U.
 // That is,
@@ -1110,14 +408,14 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	}
 
 	base.Pos = base.AutogeneratedPos
-	dclcontext = ir.PEXTERN
+	typecheck.DeclContext = ir.PEXTERN
 
 	tfn := ir.NewFuncType(base.Pos,
-		ir.NewField(base.Pos, lookup(".this"), nil, rcvr),
-		structargs(method.Type.Params(), true),
-		structargs(method.Type.Results(), false))
+		ir.NewField(base.Pos, typecheck.Lookup(".this"), nil, rcvr),
+		typecheck.NewFuncParams(method.Type.Params(), true),
+		typecheck.NewFuncParams(method.Type.Results(), false))
 
-	fn := dclfunc(newnam, tfn)
+	fn := typecheck.DeclFunc(newnam, tfn)
 	fn.SetDupok(true)
 
 	nthis := ir.AsNode(tfn.Type().Recv().Nname)
@@ -1128,13 +426,13 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	if rcvr.IsPtr() && rcvr.Elem() == methodrcvr {
 		// generating wrapper from *T to T.
 		n := ir.NewIfStmt(base.Pos, nil, nil, nil)
-		n.Cond = ir.NewBinaryExpr(base.Pos, ir.OEQ, nthis, nodnil())
-		call := ir.NewCallExpr(base.Pos, ir.OCALL, syslook("panicwrap"), nil)
+		n.Cond = ir.NewBinaryExpr(base.Pos, ir.OEQ, nthis, typecheck.NodNil())
+		call := ir.NewCallExpr(base.Pos, ir.OCALL, typecheck.LookupRuntime("panicwrap"), nil)
 		n.Body = []ir.Node{call}
 		fn.Body.Append(n)
 	}
 
-	dot := adddot(ir.NewSelectorExpr(base.Pos, ir.OXDOT, nthis, method.Sym))
+	dot := typecheck.AddImplicitDots(ir.NewSelectorExpr(base.Pos, ir.OXDOT, nthis, method.Sym))
 
 	// generate call
 	// It's not possible to use a tail call when dynamic linking on ppc64le. The
@@ -1147,9 +445,9 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 		// generate tail call: adjust pointer receiver and jump to embedded method.
 		left := dot.X // skip final .M
 		if !left.Type().IsPtr() {
-			left = nodAddr(left)
+			left = typecheck.NodAddr(left)
 		}
-		as := ir.NewAssignStmt(base.Pos, nthis, convnop(left, rcvr))
+		as := ir.NewAssignStmt(base.Pos, nthis, typecheck.ConvNop(left, rcvr))
 		fn.Body.Append(as)
 		fn.Body.Append(ir.NewBranchStmt(base.Pos, ir.ORETJMP, ir.MethodSym(methodrcvr, method.Sym)))
 	} else {
@@ -1170,14 +468,14 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 		ir.DumpList("genwrapper body", fn.Body)
 	}
 
-	funcbody()
+	typecheck.FinishFuncBody()
 	if base.Debug.DclStack != 0 {
 		types.CheckDclstack()
 	}
 
-	typecheckFunc(fn)
+	typecheck.Func(fn)
 	ir.CurFunc = fn
-	typecheckslice(fn.Body, ctxStmt)
+	typecheck.Stmts(fn.Body)
 
 	// Inline calls within (*T).M wrappers. This is safe because we only
 	// generate those wrappers within the same compilation unit as (T).M.
@@ -1188,15 +486,15 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	escapeFuncs([]*ir.Func{fn}, false)
 
 	ir.CurFunc = nil
-	Target.Decls = append(Target.Decls, fn)
+	typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
 }
 
 func hashmem(t *types.Type) ir.Node {
 	sym := ir.Pkgs.Runtime.Lookup("memhash")
 
-	n := NewName(sym)
+	n := typecheck.NewName(sym)
 	ir.MarkFunc(n)
-	n.SetType(functype(nil, []*ir.Field{
+	n.SetType(typecheck.NewFuncType(nil, []*ir.Field{
 		ir.NewField(base.Pos, nil, nil, types.NewPtr(t)),
 		ir.NewField(base.Pos, nil, nil, types.Types[types.TUINTPTR]),
 		ir.NewField(base.Pos, nil, nil, types.Types[types.TUINTPTR]),
@@ -1206,112 +504,6 @@ func hashmem(t *types.Type) ir.Node {
 	return n
 }
 
-func ifacelookdot(s *types.Sym, t *types.Type, ignorecase bool) (m *types.Field, followptr bool) {
-	if t == nil {
-		return nil, false
-	}
-
-	path, ambig := dotpath(s, t, &m, ignorecase)
-	if path == nil {
-		if ambig {
-			base.Errorf("%v.%v is ambiguous", t, s)
-		}
-		return nil, false
-	}
-
-	for _, d := range path {
-		if d.field.Type.IsPtr() {
-			followptr = true
-			break
-		}
-	}
-
-	if !m.IsMethod() {
-		base.Errorf("%v.%v is a field, not a method", t, s)
-		return nil, followptr
-	}
-
-	return m, followptr
-}
-
-func implements(t, iface *types.Type, m, samename **types.Field, ptr *int) bool {
-	t0 := t
-	if t == nil {
-		return false
-	}
-
-	if t.IsInterface() {
-		i := 0
-		tms := t.Fields().Slice()
-		for _, im := range iface.Fields().Slice() {
-			for i < len(tms) && tms[i].Sym != im.Sym {
-				i++
-			}
-			if i == len(tms) {
-				*m = im
-				*samename = nil
-				*ptr = 0
-				return false
-			}
-			tm := tms[i]
-			if !types.Identical(tm.Type, im.Type) {
-				*m = im
-				*samename = tm
-				*ptr = 0
-				return false
-			}
-		}
-
-		return true
-	}
-
-	t = types.ReceiverBaseType(t)
-	var tms []*types.Field
-	if t != nil {
-		expandmeth(t)
-		tms = t.AllMethods().Slice()
-	}
-	i := 0
-	for _, im := range iface.Fields().Slice() {
-		if im.Broke() {
-			continue
-		}
-		for i < len(tms) && tms[i].Sym != im.Sym {
-			i++
-		}
-		if i == len(tms) {
-			*m = im
-			*samename, _ = ifacelookdot(im.Sym, t, true)
-			*ptr = 0
-			return false
-		}
-		tm := tms[i]
-		if tm.Nointerface() || !types.Identical(tm.Type, im.Type) {
-			*m = im
-			*samename = tm
-			*ptr = 0
-			return false
-		}
-		followptr := tm.Embedded == 2
-
-		// if pointer receiver in method,
-		// the method does not exist for value types.
-		rcvr := tm.Type.Recv().Type
-		if rcvr.IsPtr() && !t0.IsPtr() && !followptr && !types.IsInterfaceMethod(tm.Type) {
-			if false && base.Flag.LowerR != 0 {
-				base.Errorf("interface pointer mismatch")
-			}
-
-			*m = im
-			*samename = nil
-			*ptr = 1
-			return false
-		}
-	}
-
-	return true
-}
-
 func ngotype(n ir.Node) *types.Sym {
 	if n.Type() != nil {
 		return typenamesym(n.Type())
diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index 4e7ff00434..9ffa8b67bb 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"go/constant"
@@ -14,221 +15,6 @@ import (
 	"sort"
 )
 
-// typecheckswitch typechecks a switch statement.
-func typecheckswitch(n *ir.SwitchStmt) {
-	typecheckslice(n.Init(), ctxStmt)
-	if n.Tag != nil && n.Tag.Op() == ir.OTYPESW {
-		typecheckTypeSwitch(n)
-	} else {
-		typecheckExprSwitch(n)
-	}
-}
-
-func typecheckTypeSwitch(n *ir.SwitchStmt) {
-	guard := n.Tag.(*ir.TypeSwitchGuard)
-	guard.X = typecheck(guard.X, ctxExpr)
-	t := guard.X.Type()
-	if t != nil && !t.IsInterface() {
-		base.ErrorfAt(n.Pos(), "cannot type switch on non-interface value %L", guard.X)
-		t = nil
-	}
-
-	// We don't actually declare the type switch's guarded
-	// declaration itself. So if there are no cases, we won't
-	// notice that it went unused.
-	if v := guard.Tag; v != nil && !ir.IsBlank(v) && len(n.Cases) == 0 {
-		base.ErrorfAt(v.Pos(), "%v declared but not used", v.Sym())
-	}
-
-	var defCase, nilCase ir.Node
-	var ts typeSet
-	for _, ncase := range n.Cases {
-		ncase := ncase.(*ir.CaseStmt)
-		ls := ncase.List
-		if len(ls) == 0 { // default:
-			if defCase != nil {
-				base.ErrorfAt(ncase.Pos(), "multiple defaults in switch (first at %v)", ir.Line(defCase))
-			} else {
-				defCase = ncase
-			}
-		}
-
-		for i := range ls {
-			ls[i] = typecheck(ls[i], ctxExpr|ctxType)
-			n1 := ls[i]
-			if t == nil || n1.Type() == nil {
-				continue
-			}
-
-			var missing, have *types.Field
-			var ptr int
-			if ir.IsNil(n1) { // case nil:
-				if nilCase != nil {
-					base.ErrorfAt(ncase.Pos(), "multiple nil cases in type switch (first at %v)", ir.Line(nilCase))
-				} else {
-					nilCase = ncase
-				}
-				continue
-			}
-			if n1.Op() != ir.OTYPE {
-				base.ErrorfAt(ncase.Pos(), "%L is not a type", n1)
-				continue
-			}
-			if !n1.Type().IsInterface() && !implements(n1.Type(), t, &missing, &have, &ptr) && !missing.Broke() {
-				if have != nil && !have.Broke() {
-					base.ErrorfAt(ncase.Pos(), "impossible type switch case: %L cannot have dynamic type %v"+
-						" (wrong type for %v method)\n\thave %v%S\n\twant %v%S", guard.X, n1.Type(), missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
-				} else if ptr != 0 {
-					base.ErrorfAt(ncase.Pos(), "impossible type switch case: %L cannot have dynamic type %v"+
-						" (%v method has pointer receiver)", guard.X, n1.Type(), missing.Sym)
-				} else {
-					base.ErrorfAt(ncase.Pos(), "impossible type switch case: %L cannot have dynamic type %v"+
-						" (missing %v method)", guard.X, n1.Type(), missing.Sym)
-				}
-				continue
-			}
-
-			ts.add(ncase.Pos(), n1.Type())
-		}
-
-		if len(ncase.Vars) != 0 {
-			// Assign the clause variable's type.
-			vt := t
-			if len(ls) == 1 {
-				if ls[0].Op() == ir.OTYPE {
-					vt = ls[0].Type()
-				} else if !ir.IsNil(ls[0]) {
-					// Invalid single-type case;
-					// mark variable as broken.
-					vt = nil
-				}
-			}
-
-			nvar := ncase.Vars[0]
-			nvar.SetType(vt)
-			if vt != nil {
-				nvar = typecheck(nvar, ctxExpr|ctxAssign)
-			} else {
-				// Clause variable is broken; prevent typechecking.
-				nvar.SetTypecheck(1)
-				nvar.SetWalkdef(1)
-			}
-			ncase.Vars[0] = nvar
-		}
-
-		typecheckslice(ncase.Body, ctxStmt)
-	}
-}
-
-type typeSet struct {
-	m map[string][]typeSetEntry
-}
-
-type typeSetEntry struct {
-	pos src.XPos
-	typ *types.Type
-}
-
-func (s *typeSet) add(pos src.XPos, typ *types.Type) {
-	if s.m == nil {
-		s.m = make(map[string][]typeSetEntry)
-	}
-
-	// LongString does not uniquely identify types, so we need to
-	// disambiguate collisions with types.Identical.
-	// TODO(mdempsky): Add a method that *is* unique.
-	ls := typ.LongString()
-	prevs := s.m[ls]
-	for _, prev := range prevs {
-		if types.Identical(typ, prev.typ) {
-			base.ErrorfAt(pos, "duplicate case %v in type switch\n\tprevious case at %s", typ, base.FmtPos(prev.pos))
-			return
-		}
-	}
-	s.m[ls] = append(prevs, typeSetEntry{pos, typ})
-}
-
-func typecheckExprSwitch(n *ir.SwitchStmt) {
-	t := types.Types[types.TBOOL]
-	if n.Tag != nil {
-		n.Tag = typecheck(n.Tag, ctxExpr)
-		n.Tag = defaultlit(n.Tag, nil)
-		t = n.Tag.Type()
-	}
-
-	var nilonly string
-	if t != nil {
-		switch {
-		case t.IsMap():
-			nilonly = "map"
-		case t.Kind() == types.TFUNC:
-			nilonly = "func"
-		case t.IsSlice():
-			nilonly = "slice"
-
-		case !types.IsComparable(t):
-			if t.IsStruct() {
-				base.ErrorfAt(n.Pos(), "cannot switch on %L (struct containing %v cannot be compared)", n.Tag, types.IncomparableField(t).Type)
-			} else {
-				base.ErrorfAt(n.Pos(), "cannot switch on %L", n.Tag)
-			}
-			t = nil
-		}
-	}
-
-	var defCase ir.Node
-	var cs constSet
-	for _, ncase := range n.Cases {
-		ncase := ncase.(*ir.CaseStmt)
-		ls := ncase.List
-		if len(ls) == 0 { // default:
-			if defCase != nil {
-				base.ErrorfAt(ncase.Pos(), "multiple defaults in switch (first at %v)", ir.Line(defCase))
-			} else {
-				defCase = ncase
-			}
-		}
-
-		for i := range ls {
-			ir.SetPos(ncase)
-			ls[i] = typecheck(ls[i], ctxExpr)
-			ls[i] = defaultlit(ls[i], t)
-			n1 := ls[i]
-			if t == nil || n1.Type() == nil {
-				continue
-			}
-
-			if nilonly != "" && !ir.IsNil(n1) {
-				base.ErrorfAt(ncase.Pos(), "invalid case %v in switch (can only compare %s %v to nil)", n1, nilonly, n.Tag)
-			} else if t.IsInterface() && !n1.Type().IsInterface() && !types.IsComparable(n1.Type()) {
-				base.ErrorfAt(ncase.Pos(), "invalid case %L in switch (incomparable type)", n1)
-			} else {
-				op1, _ := assignop(n1.Type(), t)
-				op2, _ := assignop(t, n1.Type())
-				if op1 == ir.OXXX && op2 == ir.OXXX {
-					if n.Tag != nil {
-						base.ErrorfAt(ncase.Pos(), "invalid case %v in switch on %v (mismatched types %v and %v)", n1, n.Tag, n1.Type(), t)
-					} else {
-						base.ErrorfAt(ncase.Pos(), "invalid case %v in switch (mismatched types %v and bool)", n1, n1.Type())
-					}
-				}
-			}
-
-			// Don't check for duplicate bools. Although the spec allows it,
-			// (1) the compiler hasn't checked it in the past, so compatibility mandates it, and
-			// (2) it would disallow useful things like
-			//       case GOARCH == "arm" && GOARM == "5":
-			//       case GOARCH == "arm":
-			//     which would both evaluate to false for non-ARM compiles.
-			if !n1.Type().IsBoolean() {
-				cs.add(ncase.Pos(), n1, "case", "switch")
-			}
-		}
-
-		typecheckslice(ncase.Body, ctxStmt)
-	}
-}
-
 // walkswitch walks a switch statement.
 func walkswitch(sw *ir.SwitchStmt) {
 	// Guard against double walk, see #25776.
@@ -254,8 +40,8 @@ func walkExprSwitch(sw *ir.SwitchStmt) {
 	// convert switch {...} to switch true {...}
 	if cond == nil {
 		cond = ir.NewBool(true)
-		cond = typecheck(cond, ctxExpr)
-		cond = defaultlit(cond, nil)
+		cond = typecheck.Expr(cond)
+		cond = typecheck.DefaultLit(cond, nil)
 	}
 
 	// Given "switch string(byteslice)",
@@ -285,7 +71,7 @@ func walkExprSwitch(sw *ir.SwitchStmt) {
 	var body ir.Nodes
 	for _, ncase := range sw.Cases {
 		ncase := ncase.(*ir.CaseStmt)
-		label := autolabel(".s")
+		label := typecheck.AutoLabel(".s")
 		jmp := ir.NewBranchStmt(ncase.Pos(), ir.OGOTO, label)
 
 		// Process case dispatch.
@@ -509,7 +295,7 @@ func walkTypeSwitch(sw *ir.SwitchStmt) {
 
 	s.facename = walkexpr(s.facename, sw.PtrInit())
 	s.facename = copyexpr(s.facename, s.facename.Type(), &sw.Compiled)
-	s.okname = temp(types.Types[types.TBOOL])
+	s.okname = typecheck.Temp(types.Types[types.TBOOL])
 
 	// Get interface descriptor word.
 	// For empty interfaces this will be the type.
@@ -523,10 +309,10 @@ func walkTypeSwitch(sw *ir.SwitchStmt) {
 	//     h := e._type.hash
 	// Use a similar strategy for non-empty interfaces.
 	ifNil := ir.NewIfStmt(base.Pos, nil, nil, nil)
-	ifNil.Cond = ir.NewBinaryExpr(base.Pos, ir.OEQ, itab, nodnil())
+	ifNil.Cond = ir.NewBinaryExpr(base.Pos, ir.OEQ, itab, typecheck.NodNil())
 	base.Pos = base.Pos.WithNotStmt() // disable statement marks after the first check.
-	ifNil.Cond = typecheck(ifNil.Cond, ctxExpr)
-	ifNil.Cond = defaultlit(ifNil.Cond, nil)
+	ifNil.Cond = typecheck.Expr(ifNil.Cond)
+	ifNil.Cond = typecheck.DefaultLit(ifNil.Cond, nil)
 	// ifNil.Nbody assigned at end.
 	sw.Compiled.Append(ifNil)
 
@@ -561,7 +347,7 @@ func walkTypeSwitch(sw *ir.SwitchStmt) {
 		}
 		caseVarInitialized := false
 
-		label := autolabel(".s")
+		label := typecheck.AutoLabel(".s")
 		jmp := ir.NewBranchStmt(ncase.Pos(), ir.OGOTO, label)
 
 		if len(ncase.List) == 0 { // default:
@@ -602,7 +388,7 @@ func walkTypeSwitch(sw *ir.SwitchStmt) {
 				ir.NewDecl(ncase.Pos(), ir.ODCL, caseVar),
 				ir.NewAssignStmt(ncase.Pos(), caseVar, val),
 			}
-			typecheckslice(l, ctxStmt)
+			typecheck.Stmts(l)
 			body.Append(l...)
 		}
 		body.Append(ncase.Body...)
@@ -648,7 +434,7 @@ func (s *typeSwitch) Add(pos src.XPos, typ *types.Type, caseVar, jmp ir.Node) {
 			ir.NewDecl(pos, ir.ODCL, caseVar),
 			ir.NewAssignStmt(pos, caseVar, nil),
 		}
-		typecheckslice(l, ctxStmt)
+		typecheck.Stmts(l)
 		body.Append(l...)
 	} else {
 		caseVar = ir.BlankNode
@@ -740,8 +526,8 @@ func binarySearch(n int, out *ir.Nodes, less func(i int) ir.Node, leaf func(i in
 				nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
 				leaf(i, nif)
 				base.Pos = base.Pos.WithNotStmt()
-				nif.Cond = typecheck(nif.Cond, ctxExpr)
-				nif.Cond = defaultlit(nif.Cond, nil)
+				nif.Cond = typecheck.Expr(nif.Cond)
+				nif.Cond = typecheck.DefaultLit(nif.Cond, nil)
 				out.Append(nif)
 				out = &nif.Else
 			}
@@ -752,8 +538,8 @@ func binarySearch(n int, out *ir.Nodes, less func(i int) ir.Node, leaf func(i in
 		nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
 		nif.Cond = less(half)
 		base.Pos = base.Pos.WithNotStmt()
-		nif.Cond = typecheck(nif.Cond, ctxExpr)
-		nif.Cond = defaultlit(nif.Cond, nil)
+		nif.Cond = typecheck.Expr(nif.Cond)
+		nif.Cond = typecheck.DefaultLit(nif.Cond, nil)
 		do(lo, half, &nif.Body)
 		do(half, hi, &nif.Else)
 		out.Append(nif)
diff --git a/src/cmd/compile/internal/gc/types_acc.go b/src/cmd/compile/internal/gc/types_acc.go
deleted file mode 100644
index d6d53f05cc..0000000000
--- a/src/cmd/compile/internal/gc/types_acc.go
+++ /dev/null
@@ -1,8 +0,0 @@
-// Copyright 2017 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.
-
-// This file implements convertions between *types.Node and *Node.
-// TODO(gri) try to eliminate these soon
-
-package gc
diff --git a/src/cmd/compile/internal/gc/unsafe.go b/src/cmd/compile/internal/gc/unsafe.go
deleted file mode 100644
index d37ebfff31..0000000000
--- a/src/cmd/compile/internal/gc/unsafe.go
+++ /dev/null
@@ -1,90 +0,0 @@
-// Copyright 2009 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 gc
-
-import (
-	"cmd/compile/internal/base"
-	"cmd/compile/internal/ir"
-	"cmd/compile/internal/types"
-)
-
-// evalunsafe evaluates a package unsafe operation and returns the result.
-func evalunsafe(n ir.Node) int64 {
-	switch n.Op() {
-	case ir.OALIGNOF, ir.OSIZEOF:
-		n := n.(*ir.UnaryExpr)
-		n.X = typecheck(n.X, ctxExpr)
-		n.X = defaultlit(n.X, nil)
-		tr := n.X.Type()
-		if tr == nil {
-			return 0
-		}
-		types.CalcSize(tr)
-		if n.Op() == ir.OALIGNOF {
-			return int64(tr.Align)
-		}
-		return tr.Width
-
-	case ir.OOFFSETOF:
-		// must be a selector.
-		n := n.(*ir.UnaryExpr)
-		if n.X.Op() != ir.OXDOT {
-			base.Errorf("invalid expression %v", n)
-			return 0
-		}
-		sel := n.X.(*ir.SelectorExpr)
-
-		// Remember base of selector to find it back after dot insertion.
-		// Since r->left may be mutated by typechecking, check it explicitly
-		// first to track it correctly.
-		sel.X = typecheck(sel.X, ctxExpr)
-		sbase := sel.X
-
-		tsel := typecheck(sel, ctxExpr)
-		n.X = tsel
-		if tsel.Type() == nil {
-			return 0
-		}
-		switch tsel.Op() {
-		case ir.ODOT, ir.ODOTPTR:
-			break
-		case ir.OCALLPART:
-			base.Errorf("invalid expression %v: argument is a method value", n)
-			return 0
-		default:
-			base.Errorf("invalid expression %v", n)
-			return 0
-		}
-
-		// Sum offsets for dots until we reach sbase.
-		var v int64
-		var next ir.Node
-		for r := tsel; r != sbase; r = next {
-			switch r.Op() {
-			case ir.ODOTPTR:
-				// For Offsetof(s.f), s may itself be a pointer,
-				// but accessing f must not otherwise involve
-				// indirection via embedded pointer types.
-				r := r.(*ir.SelectorExpr)
-				if r.X != sbase {
-					base.Errorf("invalid expression %v: selector implies indirection of embedded %v", n, r.X)
-					return 0
-				}
-				fallthrough
-			case ir.ODOT:
-				r := r.(*ir.SelectorExpr)
-				v += r.Offset
-				next = r.X
-			default:
-				ir.Dump("unsafenmagic", tsel)
-				base.Fatalf("impossible %v node after dot insertion", r.Op())
-			}
-		}
-		return v
-	}
-
-	base.Fatalf("unexpected op %v", n.Op())
-	return 0
-}
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 764c5c41b0..73f82f333c 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
@@ -42,7 +43,7 @@ func walk(fn *ir.Func) {
 	// Final typecheck for any unused variables.
 	for i, ln := range fn.Dcl {
 		if ln.Op() == ir.ONAME && (ln.Class_ == ir.PAUTO || ln.Class_ == ir.PAUTOHEAP) {
-			ln = typecheck(ln, ctxExpr|ctxAssign).(*ir.Name)
+			ln = typecheck.AssignExpr(ln).(*ir.Name)
 			fn.Dcl[i] = ln
 		}
 	}
@@ -191,7 +192,7 @@ func walkstmt(n ir.Node) ir.Node {
 		n.PtrInit().Set(nil)
 
 		n.X = walkexpr(n.X, &init)
-		call := walkexpr(mkcall1(chanfn("chanrecv1", 2, n.X.Type()), nil, &init, n.X, nodnil()), &init)
+		call := walkexpr(mkcall1(chanfn("chanrecv1", 2, n.X.Type()), nil, &init, n.X, typecheck.NodNil()), &init)
 		return ir.InitExpr(init, call)
 
 	case ir.OBREAK,
@@ -216,7 +217,7 @@ func walkstmt(n ir.Node) ir.Node {
 			}
 			nn := ir.NewAssignStmt(base.Pos, v.Name().Heapaddr, callnew(v.Type()))
 			nn.Def = true
-			return walkstmt(typecheck(nn, ctxStmt))
+			return walkstmt(typecheck.Stmt(nn))
 		}
 		return n
 
@@ -325,7 +326,7 @@ func walkstmt(n ir.Node) ir.Node {
 				if cl == ir.PPARAMOUT {
 					var ln ir.Node = ln
 					if ir.IsParamStackCopy(ln) {
-						ln = walkexpr(typecheck(ir.NewStarExpr(base.Pos, ln.Name().Heapaddr), ctxExpr), nil)
+						ln = walkexpr(typecheck.Expr(ir.NewStarExpr(base.Pos, ln.Name().Heapaddr)), nil)
 					}
 					rl = append(rl, ln)
 				}
@@ -504,7 +505,7 @@ func walkexpr(n ir.Node, init *ir.Nodes) ir.Node {
 		n := n.(*ir.Name)
 		nn := ir.NewStarExpr(base.Pos, n.Name().Heapaddr)
 		nn.X.MarkNonNil()
-		return walkexpr(typecheck(nn, ctxExpr), init)
+		return walkexpr(typecheck.Expr(nn), init)
 	}
 
 	n = walkexpr1(n, init)
@@ -515,12 +516,12 @@ func walkexpr(n ir.Node, init *ir.Nodes) ir.Node {
 	// walk of y%1 may have replaced it by 0.
 	// Check whether n with its updated args is itself now a constant.
 	t := n.Type()
-	n = evalConst(n)
+	n = typecheck.EvalConst(n)
 	if n.Type() != t {
 		base.Fatalf("evconst changed Type: %v had type %v, now %v", n, t, n.Type())
 	}
 	if n.Op() == ir.OLITERAL {
-		n = typecheck(n, ctxExpr)
+		n = typecheck.Expr(n)
 		// Emit string symbol now to avoid emitting
 		// any concurrently during the backend.
 		if v := n.Val(); v.Kind() == constant.String {
@@ -604,7 +605,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		n := n.(*ir.UnaryExpr)
 		if isRuneCount(n) {
 			// Replace len([]rune(string)) with runtime.countrunes(string).
-			return mkcall("countrunes", n.Type(), init, conv(n.X.(*ir.ConvExpr).X, types.Types[types.TSTRING]))
+			return mkcall("countrunes", n.Type(), init, typecheck.Conv(n.X.(*ir.ConvExpr).X, types.Types[types.TSTRING]))
 		}
 
 		n.X = walkexpr(n.X, init)
@@ -618,7 +619,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		}
 		if t.IsArray() {
 			safeexpr(n.X, init)
-			con := origIntConst(n, t.NumElem())
+			con := typecheck.OrigInt(n, t.NumElem())
 			con.SetTypecheck(1)
 			return con
 		}
@@ -656,7 +657,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 	case ir.ORECOVER:
 		n := n.(*ir.CallExpr)
-		return mkcall("gorecover", n.Type(), init, nodAddr(ir.RegFP))
+		return mkcall("gorecover", n.Type(), init, typecheck.NodAddr(ir.RegFP))
 
 	case ir.OCLOSUREREAD, ir.OCFUNC:
 		return n
@@ -724,7 +725,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 		if n.Op() == ir.OASOP {
 			// Rewrite x op= y into x = x op y.
-			n = ir.NewAssignStmt(base.Pos, left, typecheck(ir.NewBinaryExpr(base.Pos, n.(*ir.AssignOpStmt).AsOp, left, right), ctxExpr))
+			n = ir.NewAssignStmt(base.Pos, left, typecheck.Expr(ir.NewBinaryExpr(base.Pos, n.(*ir.AssignOpStmt).AsOp, left, right)))
 		} else {
 			n.(*ir.AssignStmt).X = left
 		}
@@ -753,7 +754,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			recv := as.Y.(*ir.UnaryExpr)
 			recv.X = walkexpr(recv.X, init)
 
-			n1 := nodAddr(as.X)
+			n1 := typecheck.NodAddr(as.X)
 			r := recv.X // the channel
 			return mkcall1(chanfn("chanrecv1", 2, r.Type()), nil, init, r, n1)
 
@@ -826,14 +827,14 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		r.X = walkexpr(r.X, init)
 		var n1 ir.Node
 		if ir.IsBlank(n.Lhs[0]) {
-			n1 = nodnil()
+			n1 = typecheck.NodNil()
 		} else {
-			n1 = nodAddr(n.Lhs[0])
+			n1 = typecheck.NodAddr(n.Lhs[0])
 		}
 		fn := chanfn("chanrecv2", 2, r.X.Type())
 		ok := n.Lhs[1]
 		call := mkcall1(fn, types.Types[types.TBOOL], init, r.X, n1)
-		return typecheck(ir.NewAssignStmt(base.Pos, ok, call), ctxStmt)
+		return typecheck.Stmt(ir.NewAssignStmt(base.Pos, ok, call))
 
 	// a,b = m[i]
 	case ir.OAS2MAPR:
@@ -854,7 +855,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		} else {
 			// standard version takes key by reference
 			// order.expr made sure key is addressable.
-			key = nodAddr(r.Index)
+			key = typecheck.NodAddr(r.Index)
 		}
 
 		// from:
@@ -885,10 +886,10 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 		// don't generate a = *var if a is _
 		if ir.IsBlank(a) {
-			return walkexpr(typecheck(n, ctxStmt), init)
+			return walkexpr(typecheck.Stmt(n), init)
 		}
 
-		var_ := temp(types.NewPtr(t.Elem()))
+		var_ := typecheck.Temp(types.NewPtr(t.Elem()))
 		var_.SetTypecheck(1)
 		var_.MarkNonNil() // mapaccess always returns a non-nil pointer
 
@@ -896,7 +897,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		init.Append(walkexpr(n, init))
 
 		as := ir.NewAssignStmt(base.Pos, a, ir.NewStarExpr(base.Pos, var_))
-		return walkexpr(typecheck(as, ctxStmt), init)
+		return walkexpr(typecheck.Stmt(as), init)
 
 	case ir.ODELETE:
 		n := n.(*ir.CallExpr)
@@ -910,7 +911,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		fast := mapfast(t)
 		if fast == mapslow {
 			// order.stmt made sure key is addressable.
-			key = nodAddr(key)
+			key = typecheck.NodAddr(key)
 		}
 		return mkcall1(mapfndel(mapdelete[fast], t), nil, init, typename(t), map_, key)
 
@@ -948,12 +949,12 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		}
 
 		if ir.Names.Staticuint64s == nil {
-			ir.Names.Staticuint64s = NewName(ir.Pkgs.Runtime.Lookup("staticuint64s"))
+			ir.Names.Staticuint64s = typecheck.NewName(ir.Pkgs.Runtime.Lookup("staticuint64s"))
 			ir.Names.Staticuint64s.Class_ = ir.PEXTERN
 			// The actual type is [256]uint64, but we use [256*8]uint8 so we can address
 			// individual bytes.
 			ir.Names.Staticuint64s.SetType(types.NewArray(types.Types[types.TUINT8], 256*8))
-			ir.Names.Zerobase = NewName(ir.Pkgs.Runtime.Lookup("zerobase"))
+			ir.Names.Zerobase = typecheck.NewName(ir.Pkgs.Runtime.Lookup("zerobase"))
 			ir.Names.Zerobase.Class_ = ir.PEXTERN
 			ir.Names.Zerobase.SetType(types.Types[types.TUINTPTR])
 		}
@@ -984,14 +985,14 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			value = n.X
 		case !fromType.IsInterface() && n.Esc() == ir.EscNone && fromType.Width <= 1024:
 			// n.Left does not escape. Use a stack temporary initialized to n.Left.
-			value = temp(fromType)
-			init.Append(typecheck(ir.NewAssignStmt(base.Pos, value, n.X), ctxStmt))
+			value = typecheck.Temp(fromType)
+			init.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, value, n.X)))
 		}
 
 		if value != nil {
 			// Value is identical to n.Left.
 			// Construct the interface directly: {type/itab, &value}.
-			l := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), typecheck(nodAddr(value), ctxExpr))
+			l := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), typecheck.Expr(typecheck.NodAddr(value)))
 			l.SetType(toType)
 			l.SetTypecheck(n.Typecheck())
 			return l
@@ -1005,15 +1006,15 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		// e = iface{tmp, i.data}
 		if toType.IsEmptyInterface() && fromType.IsInterface() && !fromType.IsEmptyInterface() {
 			// Evaluate the input interface.
-			c := temp(fromType)
+			c := typecheck.Temp(fromType)
 			init.Append(ir.NewAssignStmt(base.Pos, c, n.X))
 
 			// Get the itab out of the interface.
-			tmp := temp(types.NewPtr(types.Types[types.TUINT8]))
-			init.Append(ir.NewAssignStmt(base.Pos, tmp, typecheck(ir.NewUnaryExpr(base.Pos, ir.OITAB, c), ctxExpr)))
+			tmp := typecheck.Temp(types.NewPtr(types.Types[types.TUINT8]))
+			init.Append(ir.NewAssignStmt(base.Pos, tmp, typecheck.Expr(ir.NewUnaryExpr(base.Pos, ir.OITAB, c))))
 
 			// Get the type out of the itab.
-			nif := ir.NewIfStmt(base.Pos, typecheck(ir.NewBinaryExpr(base.Pos, ir.ONE, tmp, nodnil()), ctxExpr), nil, nil)
+			nif := ir.NewIfStmt(base.Pos, typecheck.Expr(ir.NewBinaryExpr(base.Pos, ir.ONE, tmp, typecheck.NodNil())), nil, nil)
 			nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, tmp, itabType(tmp))}
 			init.Append(nif)
 
@@ -1030,13 +1031,13 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			// Use a specialized conversion routine that only returns a data pointer.
 			// ptr = convT2X(val)
 			// e = iface{typ/tab, ptr}
-			fn := syslook(fnname)
+			fn := typecheck.LookupRuntime(fnname)
 			types.CalcSize(fromType)
-			fn = substArgTypes(fn, fromType)
+			fn = typecheck.SubstArgTypes(fn, fromType)
 			types.CalcSize(fn.Type())
 			call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
 			call.Args = []ir.Node{n.X}
-			e := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), safeexpr(walkexpr(typecheck(call, ctxExpr), init), init))
+			e := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), safeexpr(walkexpr(typecheck.Expr(call), init), init))
 			e.SetType(toType)
 			e.SetTypecheck(1)
 			return e
@@ -1062,16 +1063,16 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			if !ir.IsAssignable(v) {
 				v = copyexpr(v, v.Type(), init)
 			}
-			v = nodAddr(v)
+			v = typecheck.NodAddr(v)
 		}
 
 		types.CalcSize(fromType)
-		fn := syslook(fnname)
-		fn = substArgTypes(fn, fromType, toType)
+		fn := typecheck.LookupRuntime(fnname)
+		fn = typecheck.SubstArgTypes(fn, fromType, toType)
 		types.CalcSize(fn.Type())
 		call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
 		call.Args = []ir.Node{tab, v}
-		return walkexpr(typecheck(call, ctxExpr), init)
+		return walkexpr(typecheck.Expr(call), init)
 
 	case ir.OCONV, ir.OCONVNOP:
 		n := n.(*ir.ConvExpr)
@@ -1092,7 +1093,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			return n
 		}
 		fn := types.BasicTypeNames[param] + "to" + types.BasicTypeNames[result]
-		return conv(mkcall(fn, types.Types[result], init, conv(n.X, types.Types[param])), n.Type())
+		return typecheck.Conv(mkcall(fn, types.Types[result], init, typecheck.Conv(n.X, types.Types[param])), n.Type())
 
 	case ir.ODIV, ir.OMOD:
 		n := n.(*ir.BinaryExpr)
@@ -1104,8 +1105,8 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 		if types.IsComplex[et] && n.Op() == ir.ODIV {
 			t := n.Type()
-			call := mkcall("complex128div", types.Types[types.TCOMPLEX128], init, conv(n.X, types.Types[types.TCOMPLEX128]), conv(n.Y, types.Types[types.TCOMPLEX128]))
-			return conv(call, t)
+			call := mkcall("complex128div", types.Types[types.TCOMPLEX128], init, typecheck.Conv(n.X, types.Types[types.TCOMPLEX128]), typecheck.Conv(n.Y, types.Types[types.TCOMPLEX128]))
+			return typecheck.Conv(call, t)
 		}
 
 		// Nothing to do for float divisions.
@@ -1150,7 +1151,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			} else {
 				fn += "mod"
 			}
-			return mkcall(fn, n.Type(), init, conv(n.X, types.Types[et]), conv(n.Y, types.Types[et]))
+			return mkcall(fn, n.Type(), init, typecheck.Conv(n.X, types.Types[et]), typecheck.Conv(n.Y, types.Types[et]))
 		}
 		return n
 
@@ -1213,7 +1214,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			if fast == mapslow {
 				// standard version takes key by reference.
 				// order.expr made sure key is addressable.
-				key = nodAddr(key)
+				key = typecheck.NodAddr(key)
 			}
 			call = mkcall1(mapfn(mapassign[fast], t), nil, init, typename(t), map_, key)
 		} else {
@@ -1222,7 +1223,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			if fast == mapslow {
 				// standard version takes key by reference.
 				// order.expr made sure key is addressable.
-				key = nodAddr(key)
+				key = typecheck.NodAddr(key)
 			}
 
 			if w := t.Elem().Width; w <= zeroValSize {
@@ -1297,9 +1298,9 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			if n.Type().Elem().Width >= ir.MaxImplicitStackVarSize {
 				base.Fatalf("large ONEW with EscNone: %v", n)
 			}
-			r := temp(n.Type().Elem())
-			init.Append(typecheck(ir.NewAssignStmt(base.Pos, r, nil), ctxStmt)) // zero temp
-			return typecheck(nodAddr(r), ctxExpr)
+			r := typecheck.Temp(n.Type().Elem())
+			init.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, r, nil))) // zero temp
+			return typecheck.Expr(typecheck.NodAddr(r))
 		}
 		return callnew(n.Type().Elem())
 
@@ -1317,8 +1318,8 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 	case ir.OCLOSE:
 		// cannot use chanfn - closechan takes any, not chan any
 		n := n.(*ir.UnaryExpr)
-		fn := syslook("closechan")
-		fn = substArgTypes(fn, n.X.Type())
+		fn := typecheck.LookupRuntime("closechan")
+		fn = typecheck.SubstArgTypes(fn, n.X.Type())
 		return mkcall1(fn, nil, init, n.X)
 
 	case ir.OMAKECHAN:
@@ -1337,7 +1338,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			argtype = types.Types[types.TINT]
 		}
 
-		return mkcall1(chanfn(fnname, 1, n.Type()), n.Type(), init, typename(n.Type()), conv(size, argtype))
+		return mkcall1(chanfn(fnname, 1, n.Type()), n.Type(), init, typename(n.Type()), typecheck.Conv(size, argtype))
 
 	case ir.OMAKEMAP:
 		n := n.(*ir.MakeExpr)
@@ -1351,10 +1352,10 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			// Allocate hmap on stack.
 
 			// var hv hmap
-			hv := temp(hmapType)
-			init.Append(typecheck(ir.NewAssignStmt(base.Pos, hv, nil), ctxStmt))
+			hv := typecheck.Temp(hmapType)
+			init.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, hv, nil)))
 			// h = &hv
-			h = nodAddr(hv)
+			h = typecheck.NodAddr(hv)
 
 			// Allocate one bucket pointed to by hmap.buckets on stack if hint
 			// is not larger than BUCKETSIZE. In case hint is larger than
@@ -1377,11 +1378,11 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 				nif.Likely = true
 
 				// var bv bmap
-				bv := temp(bmap(t))
+				bv := typecheck.Temp(bmap(t))
 				nif.Body.Append(ir.NewAssignStmt(base.Pos, bv, nil))
 
 				// b = &bv
-				b := nodAddr(bv)
+				b := typecheck.NodAddr(bv)
 
 				// h.buckets = b
 				bsym := hmapType.Field(5).Sym // hmap.buckets see reflect.go:hmap
@@ -1406,17 +1407,17 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 				rand := mkcall("fastrand", types.Types[types.TUINT32], init)
 				hashsym := hmapType.Field(4).Sym // hmap.hash0 see reflect.go:hmap
 				appendWalkStmt(init, ir.NewAssignStmt(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, h, hashsym), rand))
-				return convnop(h, t)
+				return typecheck.ConvNop(h, t)
 			}
 			// Call runtime.makehmap to allocate an
 			// hmap on the heap and initialize hmap's hash0 field.
-			fn := syslook("makemap_small")
-			fn = substArgTypes(fn, t.Key(), t.Elem())
+			fn := typecheck.LookupRuntime("makemap_small")
+			fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem())
 			return mkcall1(fn, n.Type(), init)
 		}
 
 		if n.Esc() != ir.EscNone {
-			h = nodnil()
+			h = typecheck.NodNil()
 		}
 		// Map initialization with a variable or large hint is
 		// more complicated. We therefore generate a call to
@@ -1437,9 +1438,9 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			argtype = types.Types[types.TINT]
 		}
 
-		fn := syslook(fnname)
-		fn = substArgTypes(fn, hmapType, t.Key(), t.Elem())
-		return mkcall1(fn, n.Type(), init, typename(n.Type()), conv(hint, argtype), h)
+		fn := typecheck.LookupRuntime(fnname)
+		fn = typecheck.SubstArgTypes(fn, hmapType, t.Key(), t.Elem())
+		return mkcall1(fn, n.Type(), init, typename(n.Type()), typecheck.Conv(hint, argtype), h)
 
 	case ir.OMAKESLICE:
 		n := n.(*ir.MakeExpr)
@@ -1459,7 +1460,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			}
 			// var arr [r]T
 			// n = arr[:l]
-			i := indexconst(r)
+			i := typecheck.IndexConst(r)
 			if i < 0 {
 				base.Fatalf("walkexpr: invalid index %v", r)
 			}
@@ -1471,19 +1472,19 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			//     if len < 0 { panicmakeslicelen() }
 			//     panicmakeslicecap()
 			// }
-			nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGT, conv(l, types.Types[types.TUINT64]), ir.NewInt(i)), nil, nil)
+			nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGT, typecheck.Conv(l, types.Types[types.TUINT64]), ir.NewInt(i)), nil, nil)
 			niflen := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OLT, l, ir.NewInt(0)), nil, nil)
 			niflen.Body = []ir.Node{mkcall("panicmakeslicelen", nil, init)}
 			nif.Body.Append(niflen, mkcall("panicmakeslicecap", nil, init))
-			init.Append(typecheck(nif, ctxStmt))
+			init.Append(typecheck.Stmt(nif))
 
 			t = types.NewArray(t.Elem(), i) // [r]T
-			var_ := temp(t)
+			var_ := typecheck.Temp(t)
 			appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, nil)) // zero temp
 			r := ir.NewSliceExpr(base.Pos, ir.OSLICE, var_)             // arr[:l]
 			r.SetSliceBounds(nil, l, nil)
 			// The conv is necessary in case n.Type is named.
-			return walkexpr(typecheck(conv(r, n.Type()), ctxExpr), init)
+			return walkexpr(typecheck.Expr(typecheck.Conv(r, n.Type())), init)
 		}
 
 		// n escapes; set up a call to makeslice.
@@ -1507,11 +1508,11 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		m := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
 		m.SetType(t)
 
-		fn := syslook(fnname)
-		m.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), conv(len, argtype), conv(cap, argtype))
+		fn := typecheck.LookupRuntime(fnname)
+		m.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), typecheck.Conv(len, argtype), typecheck.Conv(cap, argtype))
 		m.Ptr.MarkNonNil()
-		m.LenCap = []ir.Node{conv(len, types.Types[types.TINT]), conv(cap, types.Types[types.TINT])}
-		return walkexpr(typecheck(m, ctxExpr), init)
+		m.LenCap = []ir.Node{typecheck.Conv(len, types.Types[types.TINT]), typecheck.Conv(cap, types.Types[types.TINT])}
+		return walkexpr(typecheck.Expr(m), init)
 
 	case ir.OMAKESLICECOPY:
 		n := n.(*ir.MakeExpr)
@@ -1524,7 +1525,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", t.Elem())
 		}
 
-		length := conv(n.Len, types.Types[types.TINT])
+		length := typecheck.Conv(n.Len, types.Types[types.TINT])
 		copylen := ir.NewUnaryExpr(base.Pos, ir.OLEN, n.Cap)
 		copyptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, n.Cap)
 
@@ -1535,56 +1536,56 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			// We do not check for overflow of len(to)*elem.Width here
 			// since len(from) is an existing checked slice capacity
 			// with same elem.Width for the from slice.
-			size := ir.NewBinaryExpr(base.Pos, ir.OMUL, conv(length, types.Types[types.TUINTPTR]), conv(ir.NewInt(t.Elem().Width), types.Types[types.TUINTPTR]))
+			size := ir.NewBinaryExpr(base.Pos, ir.OMUL, typecheck.Conv(length, types.Types[types.TUINTPTR]), typecheck.Conv(ir.NewInt(t.Elem().Width), types.Types[types.TUINTPTR]))
 
 			// instantiate mallocgc(size uintptr, typ *byte, needszero bool) unsafe.Pointer
-			fn := syslook("mallocgc")
+			fn := typecheck.LookupRuntime("mallocgc")
 			sh := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
-			sh.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, size, nodnil(), ir.NewBool(false))
+			sh.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, size, typecheck.NodNil(), ir.NewBool(false))
 			sh.Ptr.MarkNonNil()
 			sh.LenCap = []ir.Node{length, length}
 			sh.SetType(t)
 
-			s := temp(t)
-			r := typecheck(ir.NewAssignStmt(base.Pos, s, sh), ctxStmt)
+			s := typecheck.Temp(t)
+			r := typecheck.Stmt(ir.NewAssignStmt(base.Pos, s, sh))
 			r = walkexpr(r, init)
 			init.Append(r)
 
 			// instantiate memmove(to *any, frm *any, size uintptr)
-			fn = syslook("memmove")
-			fn = substArgTypes(fn, t.Elem(), t.Elem())
+			fn = typecheck.LookupRuntime("memmove")
+			fn = typecheck.SubstArgTypes(fn, t.Elem(), t.Elem())
 			ncopy := mkcall1(fn, nil, init, ir.NewUnaryExpr(base.Pos, ir.OSPTR, s), copyptr, size)
-			init.Append(walkexpr(typecheck(ncopy, ctxStmt), init))
+			init.Append(walkexpr(typecheck.Stmt(ncopy), init))
 
 			return s
 		}
 		// Replace make+copy with runtime.makeslicecopy.
 		// instantiate makeslicecopy(typ *byte, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointer
-		fn := syslook("makeslicecopy")
+		fn := typecheck.LookupRuntime("makeslicecopy")
 		s := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
-		s.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), length, copylen, conv(copyptr, types.Types[types.TUNSAFEPTR]))
+		s.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), length, copylen, typecheck.Conv(copyptr, types.Types[types.TUNSAFEPTR]))
 		s.Ptr.MarkNonNil()
 		s.LenCap = []ir.Node{length, length}
 		s.SetType(t)
-		return walkexpr(typecheck(s, ctxExpr), init)
+		return walkexpr(typecheck.Expr(s), init)
 
 	case ir.ORUNESTR:
 		n := n.(*ir.ConvExpr)
-		a := nodnil()
+		a := typecheck.NodNil()
 		if n.Esc() == ir.EscNone {
 			t := types.NewArray(types.Types[types.TUINT8], 4)
-			a = nodAddr(temp(t))
+			a = typecheck.NodAddr(typecheck.Temp(t))
 		}
 		// intstring(*[4]byte, rune)
-		return mkcall("intstring", n.Type(), init, a, conv(n.X, types.Types[types.TINT64]))
+		return mkcall("intstring", n.Type(), init, a, typecheck.Conv(n.X, types.Types[types.TINT64]))
 
 	case ir.OBYTES2STR, ir.ORUNES2STR:
 		n := n.(*ir.ConvExpr)
-		a := nodnil()
+		a := typecheck.NodNil()
 		if n.Esc() == ir.EscNone {
 			// Create temporary buffer for string on stack.
 			t := types.NewArray(types.Types[types.TUINT8], tmpstringbufsize)
-			a = nodAddr(temp(t))
+			a = typecheck.NodAddr(typecheck.Temp(t))
 		}
 		if n.Op() == ir.ORUNES2STR {
 			// slicerunetostring(*[32]byte, []rune) string
@@ -1618,16 +1619,16 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			t := types.NewArray(types.Types[types.TUINT8], int64(len(sc)))
 			var a ir.Node
 			if n.Esc() == ir.EscNone && len(sc) <= int(ir.MaxImplicitStackVarSize) {
-				a = nodAddr(temp(t))
+				a = typecheck.NodAddr(typecheck.Temp(t))
 			} else {
 				a = callnew(t)
 			}
-			p := temp(t.PtrTo()) // *[n]byte
-			init.Append(typecheck(ir.NewAssignStmt(base.Pos, p, a), ctxStmt))
+			p := typecheck.Temp(t.PtrTo()) // *[n]byte
+			init.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, p, a)))
 
 			// Copy from the static string data to the [n]byte.
 			if len(sc) > 0 {
-				as := ir.NewAssignStmt(base.Pos, ir.NewStarExpr(base.Pos, p), ir.NewStarExpr(base.Pos, convnop(ir.NewUnaryExpr(base.Pos, ir.OSPTR, s), t.PtrTo())))
+				as := ir.NewAssignStmt(base.Pos, ir.NewStarExpr(base.Pos, p), ir.NewStarExpr(base.Pos, typecheck.ConvNop(ir.NewUnaryExpr(base.Pos, ir.OSPTR, s), t.PtrTo())))
 				appendWalkStmt(init, as)
 			}
 
@@ -1638,14 +1639,14 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			return walkexpr(slice, init)
 		}
 
-		a := nodnil()
+		a := typecheck.NodNil()
 		if n.Esc() == ir.EscNone {
 			// Create temporary buffer for slice on stack.
 			t := types.NewArray(types.Types[types.TUINT8], tmpstringbufsize)
-			a = nodAddr(temp(t))
+			a = typecheck.NodAddr(typecheck.Temp(t))
 		}
 		// stringtoslicebyte(*32[byte], string) []byte
-		return mkcall("stringtoslicebyte", n.Type(), init, a, conv(s, types.Types[types.TSTRING]))
+		return mkcall("stringtoslicebyte", n.Type(), init, a, typecheck.Conv(s, types.Types[types.TSTRING]))
 
 	case ir.OSTR2BYTESTMP:
 		// []byte(string) conversion that creates a slice
@@ -1661,14 +1662,14 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 	case ir.OSTR2RUNES:
 		n := n.(*ir.ConvExpr)
-		a := nodnil()
+		a := typecheck.NodNil()
 		if n.Esc() == ir.EscNone {
 			// Create temporary buffer for slice on stack.
 			t := types.NewArray(types.Types[types.TINT32], tmpstringbufsize)
-			a = nodAddr(temp(t))
+			a = typecheck.NodAddr(typecheck.Temp(t))
 		}
 		// stringtoslicerune(*[32]rune, string) []rune
-		return mkcall("stringtoslicerune", n.Type(), init, a, conv(n.X, types.Types[types.TSTRING]))
+		return mkcall("stringtoslicerune", n.Type(), init, a, typecheck.Conv(n.X, types.Types[types.TSTRING]))
 
 	case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT, ir.OSTRUCTLIT, ir.OPTRLIT:
 		if isStaticCompositeLiteral(n) && !canSSAType(n.Type()) {
@@ -1677,18 +1678,18 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			// Make direct reference to the static data. See issue 12841.
 			vstat := readonlystaticname(n.Type())
 			fixedlit(inInitFunction, initKindStatic, n, vstat, init)
-			return typecheck(vstat, ctxExpr)
+			return typecheck.Expr(vstat)
 		}
-		var_ := temp(n.Type())
+		var_ := typecheck.Temp(n.Type())
 		anylit(n, var_, init)
 		return var_
 
 	case ir.OSEND:
 		n := n.(*ir.SendStmt)
 		n1 := n.Value
-		n1 = assignconv(n1, n.Chan.Type().Elem(), "chan send")
+		n1 = typecheck.AssignConv(n1, n.Chan.Type().Elem(), "chan send")
 		n1 = walkexpr(n1, init)
-		n1 = nodAddr(n1)
+		n1 = typecheck.NodAddr(n1)
 		return mkcall1(chanfn("chansend1", 2, n.Chan.Type()), nil, init, n.Chan, n1)
 
 	case ir.OCLOSURE:
@@ -1871,8 +1872,8 @@ func ascompatet(nl ir.Nodes, nr *types.Type) []ir.Node {
 		// Any assignment to an lvalue that might cause a function call must be
 		// deferred until all the returned values have been read.
 		if fncall(l, r.Type) {
-			tmp := ir.Node(temp(r.Type))
-			tmp = typecheck(tmp, ctxExpr)
+			tmp := ir.Node(typecheck.Temp(r.Type))
+			tmp = typecheck.Expr(tmp)
 			a := convas(ir.NewAssignStmt(base.Pos, l, tmp), &mm)
 			mm.Append(a)
 			l = tmp
@@ -1895,48 +1896,6 @@ func ascompatet(nl ir.Nodes, nr *types.Type) []ir.Node {
 	return append(nn, mm...)
 }
 
-// package all the arguments that match a ... T parameter into a []T.
-func mkdotargslice(typ *types.Type, args []ir.Node) ir.Node {
-	var n ir.Node
-	if len(args) == 0 {
-		n = nodnil()
-		n.SetType(typ)
-	} else {
-		lit := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ).(ir.Ntype), nil)
-		lit.List.Append(args...)
-		lit.SetImplicit(true)
-		n = lit
-	}
-
-	n = typecheck(n, ctxExpr)
-	if n.Type() == nil {
-		base.Fatalf("mkdotargslice: typecheck failed")
-	}
-	return n
-}
-
-// fixVariadicCall rewrites calls to variadic functions to use an
-// explicit ... argument if one is not already present.
-func fixVariadicCall(call *ir.CallExpr) {
-	fntype := call.X.Type()
-	if !fntype.IsVariadic() || call.IsDDD {
-		return
-	}
-
-	vi := fntype.NumParams() - 1
-	vt := fntype.Params().Field(vi).Type
-
-	args := call.Args
-	extra := args[vi:]
-	slice := mkdotargslice(vt, extra)
-	for i := range extra {
-		extra[i] = nil // allow GC
-	}
-
-	call.Args.Set(append(args[:vi], slice))
-	call.IsDDD = true
-}
-
 func walkCall(n *ir.CallExpr, init *ir.Nodes) {
 	if len(n.Rargs) != 0 {
 		return // already walked
@@ -1978,7 +1937,7 @@ func walkCall(n *ir.CallExpr, init *ir.Nodes) {
 		}
 		if base.Flag.Cfg.Instrumenting || fncall(arg, t) {
 			// make assignment of fncall to tempAt
-			tmp := temp(t)
+			tmp := typecheck.Temp(t)
 			a := convas(ir.NewAssignStmt(base.Pos, tmp, arg), init)
 			tempAssigns = append(tempAssigns, a)
 			// replace arg with temp
@@ -2032,22 +1991,22 @@ func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 	for i, n := range nn.Args {
 		if n.Op() == ir.OLITERAL {
 			if n.Type() == types.UntypedRune {
-				n = defaultlit(n, types.RuneType)
+				n = typecheck.DefaultLit(n, types.RuneType)
 			}
 
 			switch n.Val().Kind() {
 			case constant.Int:
-				n = defaultlit(n, types.Types[types.TINT64])
+				n = typecheck.DefaultLit(n, types.Types[types.TINT64])
 
 			case constant.Float:
-				n = defaultlit(n, types.Types[types.TFLOAT64])
+				n = typecheck.DefaultLit(n, types.Types[types.TFLOAT64])
 			}
 		}
 
 		if n.Op() != ir.OLITERAL && n.Type() != nil && n.Type().Kind() == types.TIDEAL {
-			n = defaultlit(n, types.Types[types.TINT64])
+			n = typecheck.DefaultLit(n, types.Types[types.TINT64])
 		}
-		n = defaultlit(n, nil)
+		n = typecheck.DefaultLit(n, nil)
 		nn.Args[i] = n
 		if n.Type() == nil || n.Type().Kind() == types.TFORW {
 			continue
@@ -2057,14 +2016,14 @@ func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 		switch n.Type().Kind() {
 		case types.TINTER:
 			if n.Type().IsEmptyInterface() {
-				on = syslook("printeface")
+				on = typecheck.LookupRuntime("printeface")
 			} else {
-				on = syslook("printiface")
+				on = typecheck.LookupRuntime("printiface")
 			}
-			on = substArgTypes(on, n.Type()) // any-1
+			on = typecheck.SubstArgTypes(on, n.Type()) // any-1
 		case types.TPTR:
 			if n.Type().Elem().NotInHeap() {
-				on = syslook("printuintptr")
+				on = typecheck.LookupRuntime("printuintptr")
 				n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
 				n.SetType(types.Types[types.TUNSAFEPTR])
 				n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
@@ -2073,25 +2032,25 @@ func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 			}
 			fallthrough
 		case types.TCHAN, types.TMAP, types.TFUNC, types.TUNSAFEPTR:
-			on = syslook("printpointer")
-			on = substArgTypes(on, n.Type()) // any-1
+			on = typecheck.LookupRuntime("printpointer")
+			on = typecheck.SubstArgTypes(on, n.Type()) // any-1
 		case types.TSLICE:
-			on = syslook("printslice")
-			on = substArgTypes(on, n.Type()) // any-1
+			on = typecheck.LookupRuntime("printslice")
+			on = typecheck.SubstArgTypes(on, n.Type()) // any-1
 		case types.TUINT, types.TUINT8, types.TUINT16, types.TUINT32, types.TUINT64, types.TUINTPTR:
 			if types.IsRuntimePkg(n.Type().Sym().Pkg) && n.Type().Sym().Name == "hex" {
-				on = syslook("printhex")
+				on = typecheck.LookupRuntime("printhex")
 			} else {
-				on = syslook("printuint")
+				on = typecheck.LookupRuntime("printuint")
 			}
 		case types.TINT, types.TINT8, types.TINT16, types.TINT32, types.TINT64:
-			on = syslook("printint")
+			on = typecheck.LookupRuntime("printint")
 		case types.TFLOAT32, types.TFLOAT64:
-			on = syslook("printfloat")
+			on = typecheck.LookupRuntime("printfloat")
 		case types.TCOMPLEX64, types.TCOMPLEX128:
-			on = syslook("printcomplex")
+			on = typecheck.LookupRuntime("printcomplex")
 		case types.TBOOL:
-			on = syslook("printbool")
+			on = typecheck.LookupRuntime("printbool")
 		case types.TSTRING:
 			cs := ""
 			if ir.IsConst(n, constant.String) {
@@ -2099,11 +2058,11 @@ func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 			}
 			switch cs {
 			case " ":
-				on = syslook("printsp")
+				on = typecheck.LookupRuntime("printsp")
 			case "\n":
-				on = syslook("printnl")
+				on = typecheck.LookupRuntime("printnl")
 			default:
-				on = syslook("printstring")
+				on = typecheck.LookupRuntime("printstring")
 			}
 		default:
 			badtype(ir.OPRINT, n.Type(), nil)
@@ -2124,12 +2083,12 @@ func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 
 	calls = append(calls, mkcall("printunlock", nil, init))
 
-	typecheckslice(calls, ctxStmt)
+	typecheck.Stmts(calls)
 	walkexprlist(calls, init)
 
 	r := ir.NewBlockStmt(base.Pos, nil)
 	r.List.Set(calls)
-	return walkstmt(typecheck(r, ctxStmt))
+	return walkstmt(typecheck.Stmt(r))
 }
 
 func callnew(t *types.Type) ir.Node {
@@ -2160,12 +2119,12 @@ func convas(n *ir.AssignStmt, init *ir.Nodes) *ir.AssignStmt {
 	}
 
 	if ir.IsBlank(n.X) {
-		n.Y = defaultlit(n.Y, nil)
+		n.Y = typecheck.DefaultLit(n.Y, nil)
 		return n
 	}
 
 	if !types.Identical(lt, rt) {
-		n.Y = assignconv(n.Y, lt, "assignment")
+		n.Y = typecheck.AssignConv(n.Y, lt, "assignment")
 		n.Y = walkexpr(n.Y, init)
 	}
 	types.CalcSize(n.Y.Type())
@@ -2258,8 +2217,8 @@ func reorder3save(n ir.Node, all []*ir.AssignStmt, i int, early *[]ir.Node) ir.N
 		return n
 	}
 
-	q := ir.Node(temp(n.Type()))
-	as := typecheck(ir.NewAssignStmt(base.Pos, q, n), ctxStmt)
+	q := ir.Node(typecheck.Temp(n.Type()))
+	as := typecheck.Stmt(ir.NewAssignStmt(base.Pos, q, n))
 	*early = append(*early, as)
 	return q
 }
@@ -2455,7 +2414,7 @@ func paramstoheap(params *types.Type) []ir.Node {
 		if stackcopy := v.Name().Stackcopy; stackcopy != nil {
 			nn = append(nn, walkstmt(ir.NewDecl(base.Pos, ir.ODCL, v)))
 			if stackcopy.Class_ == ir.PPARAM {
-				nn = append(nn, walkstmt(typecheck(ir.NewAssignStmt(base.Pos, v, stackcopy), ctxStmt)))
+				nn = append(nn, walkstmt(typecheck.Stmt(ir.NewAssignStmt(base.Pos, v, stackcopy))))
 			}
 		}
 	}
@@ -2503,7 +2462,7 @@ func returnsfromheap(params *types.Type) []ir.Node {
 			continue
 		}
 		if stackcopy := v.Name().Stackcopy; stackcopy != nil && stackcopy.Class_ == ir.PPARAMOUT {
-			nn = append(nn, walkstmt(typecheck(ir.NewAssignStmt(base.Pos, stackcopy, v), ctxStmt)))
+			nn = append(nn, walkstmt(typecheck.Stmt(ir.NewAssignStmt(base.Pos, stackcopy, v))))
 		}
 	}
 
@@ -2536,41 +2495,19 @@ func vmkcall(fn ir.Node, t *types.Type, init *ir.Nodes, va []ir.Node) *ir.CallEx
 	}
 
 	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, va)
-	TypecheckCall(call)
+	typecheck.Call(call)
 	call.SetType(t)
 	return walkexpr(call, init).(*ir.CallExpr)
 }
 
 func mkcall(name string, t *types.Type, init *ir.Nodes, args ...ir.Node) *ir.CallExpr {
-	return vmkcall(syslook(name), t, init, args)
+	return vmkcall(typecheck.LookupRuntime(name), t, init, args)
 }
 
 func mkcall1(fn ir.Node, t *types.Type, init *ir.Nodes, args ...ir.Node) *ir.CallExpr {
 	return vmkcall(fn, t, init, args)
 }
 
-func conv(n ir.Node, t *types.Type) ir.Node {
-	if types.Identical(n.Type(), t) {
-		return n
-	}
-	n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
-	n.SetType(t)
-	n = typecheck(n, ctxExpr)
-	return n
-}
-
-// convnop converts node n to type t using the OCONVNOP op
-// and typechecks the result with ctxExpr.
-func convnop(n ir.Node, t *types.Type) ir.Node {
-	if types.Identical(n.Type(), t) {
-		return n
-	}
-	n = ir.NewConvExpr(base.Pos, ir.OCONVNOP, nil, n)
-	n.SetType(t)
-	n = typecheck(n, ctxExpr)
-	return n
-}
-
 // byteindex converts n, which is byte-sized, to an int used to index into an array.
 // We cannot use conv, because we allow converting bool to int here,
 // which is forbidden in user code.
@@ -2594,14 +2531,14 @@ func chanfn(name string, n int, t *types.Type) ir.Node {
 	if !t.IsChan() {
 		base.Fatalf("chanfn %v", t)
 	}
-	fn := syslook(name)
+	fn := typecheck.LookupRuntime(name)
 	switch n {
 	default:
 		base.Fatalf("chanfn %d", n)
 	case 1:
-		fn = substArgTypes(fn, t.Elem())
+		fn = typecheck.SubstArgTypes(fn, t.Elem())
 	case 2:
-		fn = substArgTypes(fn, t.Elem(), t.Elem())
+		fn = typecheck.SubstArgTypes(fn, t.Elem(), t.Elem())
 	}
 	return fn
 }
@@ -2610,8 +2547,8 @@ func mapfn(name string, t *types.Type) ir.Node {
 	if !t.IsMap() {
 		base.Fatalf("mapfn %v", t)
 	}
-	fn := syslook(name)
-	fn = substArgTypes(fn, t.Key(), t.Elem(), t.Key(), t.Elem())
+	fn := typecheck.LookupRuntime(name)
+	fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem(), t.Key(), t.Elem())
 	return fn
 }
 
@@ -2619,8 +2556,8 @@ func mapfndel(name string, t *types.Type) ir.Node {
 	if !t.IsMap() {
 		base.Fatalf("mapfn %v", t)
 	}
-	fn := syslook(name)
-	fn = substArgTypes(fn, t.Key(), t.Elem(), t.Key())
+	fn := typecheck.LookupRuntime(name)
+	fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem(), t.Key())
 	return fn
 }
 
@@ -2675,8 +2612,8 @@ func mapfast(t *types.Type) int {
 }
 
 func writebarrierfn(name string, l *types.Type, r *types.Type) ir.Node {
-	fn := syslook(name)
-	fn = substArgTypes(fn, l, r)
+	fn := typecheck.LookupRuntime(name)
+	fn = typecheck.SubstArgTypes(fn, l, r)
 	return fn
 }
 
@@ -2687,7 +2624,7 @@ func addstr(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
 		base.Fatalf("addstr count %d too small", c)
 	}
 
-	buf := nodnil()
+	buf := typecheck.NodNil()
 	if n.Esc() == ir.EscNone {
 		sz := int64(0)
 		for _, n1 := range n.List {
@@ -2700,14 +2637,14 @@ func addstr(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
 		if sz < tmpstringbufsize {
 			// Create temporary buffer for result string on stack.
 			t := types.NewArray(types.Types[types.TUINT8], tmpstringbufsize)
-			buf = nodAddr(temp(t))
+			buf = typecheck.NodAddr(typecheck.Temp(t))
 		}
 	}
 
 	// build list of string arguments
 	args := []ir.Node{buf}
 	for _, n2 := range n.List {
-		args = append(args, conv(n2, types.Types[types.TSTRING]))
+		args = append(args, typecheck.Conv(n2, types.Types[types.TSTRING]))
 	}
 
 	var fn string
@@ -2727,10 +2664,10 @@ func addstr(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
 		slice.SetEsc(ir.EscNone)
 	}
 
-	cat := syslook(fn)
+	cat := typecheck.LookupRuntime(fn)
 	r := ir.NewCallExpr(base.Pos, ir.OCALL, cat, nil)
 	r.Args.Set(args)
-	r1 := typecheck(r, ctxExpr)
+	r1 := typecheck.Expr(r)
 	r1 = walkexpr(r1, init)
 	r1.SetType(n.Type())
 
@@ -2774,24 +2711,24 @@ func appendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	var nodes ir.Nodes
 
 	// var s []T
-	s := temp(l1.Type())
+	s := typecheck.Temp(l1.Type())
 	nodes.Append(ir.NewAssignStmt(base.Pos, s, l1)) // s = l1
 
 	elemtype := s.Type().Elem()
 
 	// n := len(s) + len(l2)
-	nn := temp(types.Types[types.TINT])
+	nn := typecheck.Temp(types.Types[types.TINT])
 	nodes.Append(ir.NewAssignStmt(base.Pos, nn, ir.NewBinaryExpr(base.Pos, ir.OADD, ir.NewUnaryExpr(base.Pos, ir.OLEN, s), ir.NewUnaryExpr(base.Pos, ir.OLEN, l2))))
 
 	// if uint(n) > uint(cap(s))
 	nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
-	nuint := conv(nn, types.Types[types.TUINT])
-	scapuint := conv(ir.NewUnaryExpr(base.Pos, ir.OCAP, s), types.Types[types.TUINT])
+	nuint := typecheck.Conv(nn, types.Types[types.TUINT])
+	scapuint := typecheck.Conv(ir.NewUnaryExpr(base.Pos, ir.OCAP, s), types.Types[types.TUINT])
 	nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OGT, nuint, scapuint)
 
 	// instantiate growslice(typ *type, []any, int) []any
-	fn := syslook("growslice")
-	fn = substArgTypes(fn, elemtype, elemtype)
+	fn := typecheck.LookupRuntime("growslice")
+	fn = typecheck.SubstArgTypes(fn, elemtype, elemtype)
 
 	// s = growslice(T, s, n)
 	nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, s, mkcall1(fn, s.Type(), nif.PtrInit(), typename(elemtype), s, nn))}
@@ -2813,8 +2750,8 @@ func appendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 		ir.CurFunc.SetWBPos(n.Pos())
 
 		// instantiate typedslicecopy(typ *type, dstPtr *any, dstLen int, srcPtr *any, srcLen int) int
-		fn := syslook("typedslicecopy")
-		fn = substArgTypes(fn, l1.Type().Elem(), l2.Type().Elem())
+		fn := typecheck.LookupRuntime("typedslicecopy")
+		fn = typecheck.SubstArgTypes(fn, l1.Type().Elem(), l2.Type().Elem())
 		ptr1, len1 := backingArrayPtrLen(cheapexpr(slice, &nodes))
 		ptr2, len2 := backingArrayPtrLen(l2)
 		ncopy = mkcall1(fn, types.Types[types.TINT], &nodes, typename(elemtype), ptr1, len1, ptr2, len2)
@@ -2829,28 +2766,28 @@ func appendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 		ptr1, len1 := backingArrayPtrLen(cheapexpr(slice, &nodes))
 		ptr2, len2 := backingArrayPtrLen(l2)
 
-		fn := syslook("slicecopy")
-		fn = substArgTypes(fn, ptr1.Type().Elem(), ptr2.Type().Elem())
+		fn := typecheck.LookupRuntime("slicecopy")
+		fn = typecheck.SubstArgTypes(fn, ptr1.Type().Elem(), ptr2.Type().Elem())
 		ncopy = mkcall1(fn, types.Types[types.TINT], &nodes, ptr1, len1, ptr2, len2, ir.NewInt(elemtype.Width))
 	} else {
 		// memmove(&s[len(l1)], &l2[0], len(l2)*sizeof(T))
 		ix := ir.NewIndexExpr(base.Pos, s, ir.NewUnaryExpr(base.Pos, ir.OLEN, l1))
 		ix.SetBounded(true)
-		addr := nodAddr(ix)
+		addr := typecheck.NodAddr(ix)
 
 		sptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, l2)
 
-		nwid := cheapexpr(conv(ir.NewUnaryExpr(base.Pos, ir.OLEN, l2), types.Types[types.TUINTPTR]), &nodes)
+		nwid := cheapexpr(typecheck.Conv(ir.NewUnaryExpr(base.Pos, ir.OLEN, l2), types.Types[types.TUINTPTR]), &nodes)
 		nwid = ir.NewBinaryExpr(base.Pos, ir.OMUL, nwid, ir.NewInt(elemtype.Width))
 
 		// instantiate func memmove(to *any, frm *any, length uintptr)
-		fn := syslook("memmove")
-		fn = substArgTypes(fn, elemtype, elemtype)
+		fn := typecheck.LookupRuntime("memmove")
+		fn = typecheck.SubstArgTypes(fn, elemtype, elemtype)
 		ncopy = mkcall1(fn, nil, &nodes, addr, sptr, nwid)
 	}
 	ln := append(nodes, ncopy)
 
-	typecheckslice(ln, ctxStmt)
+	typecheck.Stmts(ln)
 	walkstmtlist(ln)
 	init.Append(ln...)
 	return s
@@ -2925,8 +2862,8 @@ func extendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	// isAppendOfMake made sure all possible positive values of l2 fit into an uint.
 	// The case of l2 overflow when converting from e.g. uint to int is handled by an explicit
 	// check of l2 < 0 at runtime which is generated below.
-	l2 := conv(n.Args[1].(*ir.MakeExpr).Len, types.Types[types.TINT])
-	l2 = typecheck(l2, ctxExpr)
+	l2 := typecheck.Conv(n.Args[1].(*ir.MakeExpr).Len, types.Types[types.TINT])
+	l2 = typecheck.Expr(l2)
 	n.Args[1] = l2 // walkAppendArgs expects l2 in n.List.Second().
 
 	walkAppendArgs(n, init)
@@ -2945,23 +2882,23 @@ func extendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	nodes = append(nodes, nifneg)
 
 	// s := l1
-	s := temp(l1.Type())
+	s := typecheck.Temp(l1.Type())
 	nodes = append(nodes, ir.NewAssignStmt(base.Pos, s, l1))
 
 	elemtype := s.Type().Elem()
 
 	// n := len(s) + l2
-	nn := temp(types.Types[types.TINT])
+	nn := typecheck.Temp(types.Types[types.TINT])
 	nodes = append(nodes, ir.NewAssignStmt(base.Pos, nn, ir.NewBinaryExpr(base.Pos, ir.OADD, ir.NewUnaryExpr(base.Pos, ir.OLEN, s), l2)))
 
 	// if uint(n) > uint(cap(s))
-	nuint := conv(nn, types.Types[types.TUINT])
-	capuint := conv(ir.NewUnaryExpr(base.Pos, ir.OCAP, s), types.Types[types.TUINT])
+	nuint := typecheck.Conv(nn, types.Types[types.TUINT])
+	capuint := typecheck.Conv(ir.NewUnaryExpr(base.Pos, ir.OCAP, s), types.Types[types.TUINT])
 	nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGT, nuint, capuint), nil, nil)
 
 	// instantiate growslice(typ *type, old []any, newcap int) []any
-	fn := syslook("growslice")
-	fn = substArgTypes(fn, elemtype, elemtype)
+	fn := typecheck.LookupRuntime("growslice")
+	fn = typecheck.SubstArgTypes(fn, elemtype, elemtype)
 
 	// s = growslice(T, s, n)
 	nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, s, mkcall1(fn, s.Type(), nif.PtrInit(), typename(elemtype), s, nn))}
@@ -2974,22 +2911,22 @@ func extendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	nodes = append(nodes, ir.NewAssignStmt(base.Pos, s, nt))
 
 	// lptr := &l1[0]
-	l1ptr := temp(l1.Type().Elem().PtrTo())
+	l1ptr := typecheck.Temp(l1.Type().Elem().PtrTo())
 	tmp := ir.NewUnaryExpr(base.Pos, ir.OSPTR, l1)
 	nodes = append(nodes, ir.NewAssignStmt(base.Pos, l1ptr, tmp))
 
 	// sptr := &s[0]
-	sptr := temp(elemtype.PtrTo())
+	sptr := typecheck.Temp(elemtype.PtrTo())
 	tmp = ir.NewUnaryExpr(base.Pos, ir.OSPTR, s)
 	nodes = append(nodes, ir.NewAssignStmt(base.Pos, sptr, tmp))
 
 	// hp := &s[len(l1)]
 	ix := ir.NewIndexExpr(base.Pos, s, ir.NewUnaryExpr(base.Pos, ir.OLEN, l1))
 	ix.SetBounded(true)
-	hp := convnop(nodAddr(ix), types.Types[types.TUNSAFEPTR])
+	hp := typecheck.ConvNop(typecheck.NodAddr(ix), types.Types[types.TUNSAFEPTR])
 
 	// hn := l2 * sizeof(elem(s))
-	hn := conv(ir.NewBinaryExpr(base.Pos, ir.OMUL, l2, ir.NewInt(elemtype.Width)), types.Types[types.TUINTPTR])
+	hn := typecheck.Conv(ir.NewBinaryExpr(base.Pos, ir.OMUL, l2, ir.NewInt(elemtype.Width)), types.Types[types.TUINTPTR])
 
 	clrname := "memclrNoHeapPointers"
 	hasPointers := elemtype.HasPointers()
@@ -3011,7 +2948,7 @@ func extendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 		nodes = append(nodes, clr...)
 	}
 
-	typecheckslice(nodes, ctxStmt)
+	typecheck.Stmts(nodes)
 	walkstmtlist(nodes)
 	init.Append(nodes...)
 	return s
@@ -3057,7 +2994,7 @@ func walkappend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
 	for i, n := range ls {
 		n = cheapexpr(n, init)
 		if !types.Identical(n.Type(), nsrc.Type().Elem()) {
-			n = assignconv(n, nsrc.Type().Elem(), "append")
+			n = typecheck.AssignConv(n, nsrc.Type().Elem(), "append")
 			n = walkexpr(n, init)
 		}
 		ls[i] = n
@@ -3076,22 +3013,22 @@ func walkappend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
 
 	var l []ir.Node
 
-	ns := temp(nsrc.Type())
+	ns := typecheck.Temp(nsrc.Type())
 	l = append(l, ir.NewAssignStmt(base.Pos, ns, nsrc)) // s = src
 
 	na := ir.NewInt(int64(argc))                 // const argc
 	nif := ir.NewIfStmt(base.Pos, nil, nil, nil) // if cap(s) - len(s) < argc
 	nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OLT, ir.NewBinaryExpr(base.Pos, ir.OSUB, ir.NewUnaryExpr(base.Pos, ir.OCAP, ns), ir.NewUnaryExpr(base.Pos, ir.OLEN, ns)), na)
 
-	fn := syslook("growslice") //   growslice(<type>, old []T, mincap int) (ret []T)
-	fn = substArgTypes(fn, ns.Type().Elem(), ns.Type().Elem())
+	fn := typecheck.LookupRuntime("growslice") //   growslice(<type>, old []T, mincap int) (ret []T)
+	fn = typecheck.SubstArgTypes(fn, ns.Type().Elem(), ns.Type().Elem())
 
 	nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, ns, mkcall1(fn, ns.Type(), nif.PtrInit(), typename(ns.Type().Elem()), ns,
 		ir.NewBinaryExpr(base.Pos, ir.OADD, ir.NewUnaryExpr(base.Pos, ir.OLEN, ns), na)))}
 
 	l = append(l, nif)
 
-	nn := temp(types.Types[types.TINT])
+	nn := typecheck.Temp(types.Types[types.TINT])
 	l = append(l, ir.NewAssignStmt(base.Pos, nn, ir.NewUnaryExpr(base.Pos, ir.OLEN, ns))) // n = len(s)
 
 	slice := ir.NewSliceExpr(base.Pos, ir.OSLICE, ns) // ...s[:n+argc]
@@ -3109,7 +3046,7 @@ func walkappend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
 		}
 	}
 
-	typecheckslice(l, ctxStmt)
+	typecheck.Stmts(l)
 	walkstmtlist(l)
 	init.Append(l...)
 	return ns
@@ -3147,16 +3084,16 @@ func copyany(n *ir.BinaryExpr, init *ir.Nodes, runtimecall bool) ir.Node {
 		n.Y = cheapexpr(n.Y, init)
 		ptrR, lenR := backingArrayPtrLen(n.Y)
 
-		fn := syslook("slicecopy")
-		fn = substArgTypes(fn, ptrL.Type().Elem(), ptrR.Type().Elem())
+		fn := typecheck.LookupRuntime("slicecopy")
+		fn = typecheck.SubstArgTypes(fn, ptrL.Type().Elem(), ptrR.Type().Elem())
 
 		return mkcall1(fn, n.Type(), init, ptrL, lenL, ptrR, lenR, ir.NewInt(n.X.Type().Elem().Width))
 	}
 
 	n.X = walkexpr(n.X, init)
 	n.Y = walkexpr(n.Y, init)
-	nl := temp(n.X.Type())
-	nr := temp(n.Y.Type())
+	nl := typecheck.Temp(n.X.Type())
+	nr := typecheck.Temp(n.Y.Type())
 	var l []ir.Node
 	l = append(l, ir.NewAssignStmt(base.Pos, nl, n.X))
 	l = append(l, ir.NewAssignStmt(base.Pos, nr, n.Y))
@@ -3164,7 +3101,7 @@ func copyany(n *ir.BinaryExpr, init *ir.Nodes, runtimecall bool) ir.Node {
 	nfrm := ir.NewUnaryExpr(base.Pos, ir.OSPTR, nr)
 	nto := ir.NewUnaryExpr(base.Pos, ir.OSPTR, nl)
 
-	nlen := temp(types.Types[types.TINT])
+	nlen := typecheck.Temp(types.Types[types.TINT])
 
 	// n = len(to)
 	l = append(l, ir.NewAssignStmt(base.Pos, nlen, ir.NewUnaryExpr(base.Pos, ir.OLEN, nl)))
@@ -3181,16 +3118,16 @@ func copyany(n *ir.BinaryExpr, init *ir.Nodes, runtimecall bool) ir.Node {
 	ne.Likely = true
 	l = append(l, ne)
 
-	fn := syslook("memmove")
-	fn = substArgTypes(fn, nl.Type().Elem(), nl.Type().Elem())
-	nwid := ir.Node(temp(types.Types[types.TUINTPTR]))
-	setwid := ir.NewAssignStmt(base.Pos, nwid, conv(nlen, types.Types[types.TUINTPTR]))
+	fn := typecheck.LookupRuntime("memmove")
+	fn = typecheck.SubstArgTypes(fn, nl.Type().Elem(), nl.Type().Elem())
+	nwid := ir.Node(typecheck.Temp(types.Types[types.TUINTPTR]))
+	setwid := ir.NewAssignStmt(base.Pos, nwid, typecheck.Conv(nlen, types.Types[types.TUINTPTR]))
 	ne.Body.Append(setwid)
 	nwid = ir.NewBinaryExpr(base.Pos, ir.OMUL, nwid, ir.NewInt(nl.Type().Elem().Width))
 	call := mkcall1(fn, nil, init, nto, nfrm, nwid)
 	ne.Body.Append(call)
 
-	typecheckslice(l, ctxStmt)
+	typecheck.Stmts(l)
 	walkstmtlist(l)
 	init.Append(l...)
 	return nlen
@@ -3203,14 +3140,14 @@ func eqfor(t *types.Type) (n ir.Node, needsize bool) {
 	// is handled by walkcompare.
 	switch a, _ := types.AlgType(t); a {
 	case types.AMEM:
-		n := syslook("memequal")
-		n = substArgTypes(n, t, t)
+		n := typecheck.LookupRuntime("memequal")
+		n = typecheck.SubstArgTypes(n, t, t)
 		return n, true
 	case types.ASPECIAL:
 		sym := typesymprefix(".eq", t)
-		n := NewName(sym)
+		n := typecheck.NewName(sym)
 		ir.MarkFunc(n)
-		n.SetType(functype(nil, []*ir.Field{
+		n.SetType(typecheck.NewFuncType(nil, []*ir.Field{
 			ir.NewField(base.Pos, nil, nil, types.NewPtr(t)),
 			ir.NewField(base.Pos, nil, nil, types.NewPtr(t)),
 		}, []*ir.Field{
@@ -3267,7 +3204,7 @@ func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 			tab.SetTypecheck(1)
 			eqtype = ir.NewBinaryExpr(base.Pos, eq, tab, rtyp)
 		} else {
-			nonnil := ir.NewBinaryExpr(base.Pos, brcom(eq), nodnil(), tab)
+			nonnil := ir.NewBinaryExpr(base.Pos, brcom(eq), typecheck.NodNil(), tab)
 			match := ir.NewBinaryExpr(base.Pos, eq, itabType(tab), rtyp)
 			eqtype = ir.NewLogicalExpr(base.Pos, andor, nonnil, match)
 		}
@@ -3366,8 +3303,8 @@ func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 
 		fn, needsize := eqfor(t)
 		call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
-		call.Args.Append(nodAddr(cmpl))
-		call.Args.Append(nodAddr(cmpr))
+		call.Args.Append(typecheck.NodAddr(cmpl))
+		call.Args.Append(typecheck.NodAddr(cmpr))
 		if needsize {
 			call.Args.Append(ir.NewInt(t.Width))
 		}
@@ -3436,22 +3373,22 @@ func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 			} else {
 				elemType := t.Elem().ToUnsigned()
 				cmplw := ir.Node(ir.NewIndexExpr(base.Pos, cmpl, ir.NewInt(i)))
-				cmplw = conv(cmplw, elemType) // convert to unsigned
-				cmplw = conv(cmplw, convType) // widen
+				cmplw = typecheck.Conv(cmplw, elemType) // convert to unsigned
+				cmplw = typecheck.Conv(cmplw, convType) // widen
 				cmprw := ir.Node(ir.NewIndexExpr(base.Pos, cmpr, ir.NewInt(i)))
-				cmprw = conv(cmprw, elemType)
-				cmprw = conv(cmprw, convType)
+				cmprw = typecheck.Conv(cmprw, elemType)
+				cmprw = typecheck.Conv(cmprw, convType)
 				// For code like this:  uint32(s[0]) | uint32(s[1])<<8 | uint32(s[2])<<16 ...
 				// ssa will generate a single large load.
 				for offset := int64(1); offset < step; offset++ {
 					lb := ir.Node(ir.NewIndexExpr(base.Pos, cmpl, ir.NewInt(i+offset)))
-					lb = conv(lb, elemType)
-					lb = conv(lb, convType)
+					lb = typecheck.Conv(lb, elemType)
+					lb = typecheck.Conv(lb, convType)
 					lb = ir.NewBinaryExpr(base.Pos, ir.OLSH, lb, ir.NewInt(8*t.Elem().Width*offset))
 					cmplw = ir.NewBinaryExpr(base.Pos, ir.OOR, cmplw, lb)
 					rb := ir.Node(ir.NewIndexExpr(base.Pos, cmpr, ir.NewInt(i+offset)))
-					rb = conv(rb, elemType)
-					rb = conv(rb, convType)
+					rb = typecheck.Conv(rb, elemType)
+					rb = typecheck.Conv(rb, convType)
 					rb = ir.NewBinaryExpr(base.Pos, ir.OLSH, rb, ir.NewInt(8*t.Elem().Width*offset))
 					cmprw = ir.NewBinaryExpr(base.Pos, ir.OOR, cmprw, rb)
 				}
@@ -3465,9 +3402,9 @@ func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 		expr = ir.NewBool(n.Op() == ir.OEQ)
 		// We still need to use cmpl and cmpr, in case they contain
 		// an expression which might panic. See issue 23837.
-		t := temp(cmpl.Type())
-		a1 := typecheck(ir.NewAssignStmt(base.Pos, t, cmpl), ctxStmt)
-		a2 := typecheck(ir.NewAssignStmt(base.Pos, t, cmpr), ctxStmt)
+		t := typecheck.Temp(cmpl.Type())
+		a1 := typecheck.Stmt(ir.NewAssignStmt(base.Pos, t, cmpl))
+		a2 := typecheck.Stmt(ir.NewAssignStmt(base.Pos, t, cmpr))
 		init.Append(a1, a2)
 	}
 	return finishcompare(n, expr, init)
@@ -3479,7 +3416,7 @@ func tracecmpArg(n ir.Node, t *types.Type, init *ir.Nodes) ir.Node {
 		n = copyexpr(n, n.Type(), init)
 	}
 
-	return conv(n, t)
+	return typecheck.Conv(n, t)
 }
 
 func walkcompareInterface(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
@@ -3573,13 +3510,13 @@ func walkcompareString(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 					convType = types.Types[types.TUINT16]
 					step = 2
 				}
-				ncsubstr := conv(ir.NewIndexExpr(base.Pos, ncs, ir.NewInt(int64(i))), convType)
+				ncsubstr := typecheck.Conv(ir.NewIndexExpr(base.Pos, ncs, ir.NewInt(int64(i))), convType)
 				csubstr := int64(s[i])
 				// Calculate large constant from bytes as sequence of shifts and ors.
 				// Like this:  uint32(s[0]) | uint32(s[1])<<8 | uint32(s[2])<<16 ...
 				// ssa will combine this into a single large load.
 				for offset := 1; offset < step; offset++ {
-					b := conv(ir.NewIndexExpr(base.Pos, ncs, ir.NewInt(int64(i+offset))), convType)
+					b := typecheck.Conv(ir.NewIndexExpr(base.Pos, ncs, ir.NewInt(int64(i+offset))), convType)
 					b = ir.NewBinaryExpr(base.Pos, ir.OLSH, b, ir.NewInt(int64(8*offset)))
 					ncsubstr = ir.NewBinaryExpr(base.Pos, ir.OOR, ncsubstr, b)
 					csubstr |= int64(s[i+offset]) << uint8(8*offset)
@@ -3612,7 +3549,7 @@ func walkcompareString(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 		}
 	} else {
 		// sys_cmpstring(s1, s2) :: 0
-		r = mkcall("cmpstring", types.Types[types.TINT], init, conv(n.X, types.Types[types.TSTRING]), conv(n.Y, types.Types[types.TSTRING]))
+		r = mkcall("cmpstring", types.Types[types.TINT], init, typecheck.Conv(n.X, types.Types[types.TSTRING]), typecheck.Conv(n.Y, types.Types[types.TSTRING]))
 		r = ir.NewBinaryExpr(base.Pos, n.Op(), r, ir.NewInt(0))
 	}
 
@@ -3622,8 +3559,8 @@ func walkcompareString(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 // The result of finishcompare MUST be assigned back to n, e.g.
 // 	n.Left = finishcompare(n.Left, x, r, init)
 func finishcompare(n *ir.BinaryExpr, r ir.Node, init *ir.Nodes) ir.Node {
-	r = typecheck(r, ctxExpr)
-	r = conv(r, n.Type())
+	r = typecheck.Expr(r)
+	r = typecheck.Conv(r, n.Type())
 	r = walkexpr(r, init)
 	return r
 }
@@ -3926,7 +3863,7 @@ func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	origArgs := make([]ir.Node, len(n.Args))
 	var funcArgs []*ir.Field
 	for i, arg := range n.Args {
-		s := lookupN("a", i)
+		s := typecheck.LookupNum("a", i)
 		if !isBuiltinCall && arg.Op() == ir.OCONVNOP && arg.Type().IsUintptr() && arg.(*ir.ConvExpr).X.Type().IsUnsafePtr() {
 			origArgs[i] = arg
 			arg = arg.(*ir.ConvExpr).X
@@ -3937,8 +3874,8 @@ func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	t := ir.NewFuncType(base.Pos, nil, funcArgs, nil)
 
 	wrapCall_prgen++
-	sym := lookupN("wrap·", wrapCall_prgen)
-	fn := dclfunc(sym, t)
+	sym := typecheck.LookupNum("wrap·", wrapCall_prgen)
+	fn := typecheck.DeclFunc(sym, t)
 
 	args := ir.ParamNames(t.Type())
 	for i, origArg := range origArgs {
@@ -3954,32 +3891,14 @@ func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	}
 	fn.Body = []ir.Node{call}
 
-	funcbody()
+	typecheck.FinishFuncBody()
 
-	typecheckFunc(fn)
-	typecheckslice(fn.Body, ctxStmt)
-	Target.Decls = append(Target.Decls, fn)
+	typecheck.Func(fn)
+	typecheck.Stmts(fn.Body)
+	typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
 
 	call = ir.NewCallExpr(base.Pos, ir.OCALL, fn.Nname, n.Args)
-	return walkexpr(typecheck(call, ctxStmt), init)
-}
-
-// substArgTypes substitutes the given list of types for
-// successive occurrences of the "any" placeholder in the
-// type syntax expression n.Type.
-// The result of substArgTypes MUST be assigned back to old, e.g.
-// 	n.Left = substArgTypes(n.Left, t1, t2)
-func substArgTypes(old *ir.Name, types_ ...*types.Type) *ir.Name {
-	n := old.CloneName()
-
-	for _, t := range types_ {
-		types.CalcSize(t)
-	}
-	n.SetType(types.SubstAny(n.Type(), &types_))
-	if len(types_) > 0 {
-		base.Fatalf("substArgTypes: too many argument types")
-	}
-	return n
+	return walkexpr(typecheck.Stmt(call), init)
 }
 
 // canMergeLoads reports whether the backend optimization passes for
@@ -4025,7 +3944,7 @@ func walkCheckPtrAlignment(n *ir.ConvExpr, init *ir.Nodes, count ir.Node) ir.Nod
 	}
 
 	n.X = cheapexpr(n.X, init)
-	init.Append(mkcall("checkptrAlignment", nil, init, convnop(n.X, types.Types[types.TUNSAFEPTR]), typename(elem), conv(count, types.Types[types.TUINTPTR])))
+	init.Append(mkcall("checkptrAlignment", nil, init, typecheck.ConvNop(n.X, types.Types[types.TUNSAFEPTR]), typename(elem), typecheck.Conv(count, types.Types[types.TUINTPTR])))
 	return n
 }
 
@@ -4077,7 +3996,7 @@ func walkCheckPtrArithmetic(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 			n := n.(*ir.ConvExpr)
 			if n.X.Type().IsUnsafePtr() {
 				n.X = cheapexpr(n.X, init)
-				originals = append(originals, convnop(n.X, types.Types[types.TUNSAFEPTR]))
+				originals = append(originals, typecheck.ConvNop(n.X, types.Types[types.TUNSAFEPTR]))
 			}
 		}
 	}
@@ -4085,10 +4004,10 @@ func walkCheckPtrArithmetic(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 
 	cheap := cheapexpr(n, init)
 
-	slice := mkdotargslice(types.NewSlice(types.Types[types.TUNSAFEPTR]), originals)
+	slice := typecheck.MakeDotArgs(types.NewSlice(types.Types[types.TUNSAFEPTR]), originals)
 	slice.SetEsc(ir.EscNone)
 
-	init.Append(mkcall("checkptrArithmetic", nil, init, convnop(cheap, types.Types[types.TUNSAFEPTR]), slice))
+	init.Append(mkcall("checkptrArithmetic", nil, init, typecheck.ConvNop(cheap, types.Types[types.TUNSAFEPTR]), slice))
 	// TODO(khr): Mark backing store of slice as dead. This will allow us to reuse
 	// the backing store for multiple calls to checkptrArithmetic.
 
@@ -4098,7 +4017,7 @@ func walkCheckPtrArithmetic(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 // appendWalkStmt typechecks and walks stmt and then appends it to init.
 func appendWalkStmt(init *ir.Nodes, stmt ir.Node) {
 	op := stmt.Op()
-	n := typecheck(stmt, ctxStmt)
+	n := typecheck.Stmt(stmt)
 	if op == ir.OAS || op == ir.OAS2 {
 		// If the assignment has side effects, walkexpr will append them
 		// directly to init for us, while walkstmt will wrap it in an OBLOCK.
diff --git a/src/cmd/compile/internal/typecheck/bexport.go b/src/cmd/compile/internal/typecheck/bexport.go
new file mode 100644
index 0000000000..4a84bb13fa
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/bexport.go
@@ -0,0 +1,102 @@
+// Copyright 2015 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 typecheck
+
+import "cmd/compile/internal/types"
+
+// ----------------------------------------------------------------------------
+// Export format
+
+// Tags. Must be < 0.
+const (
+	// Objects
+	packageTag = -(iota + 1)
+	constTag
+	typeTag
+	varTag
+	funcTag
+	endTag
+
+	// Types
+	namedTag
+	arrayTag
+	sliceTag
+	dddTag
+	structTag
+	pointerTag
+	signatureTag
+	interfaceTag
+	mapTag
+	chanTag
+
+	// Values
+	falseTag
+	trueTag
+	int64Tag
+	floatTag
+	fractionTag // not used by gc
+	complexTag
+	stringTag
+	nilTag
+	unknownTag // not used by gc (only appears in packages with errors)
+
+	// Type aliases
+	aliasTag
+)
+
+var predecl []*types.Type // initialized lazily
+
+func predeclared() []*types.Type {
+	if predecl == nil {
+		// initialize lazily to be sure that all
+		// elements have been initialized before
+		predecl = []*types.Type{
+			// basic types
+			types.Types[types.TBOOL],
+			types.Types[types.TINT],
+			types.Types[types.TINT8],
+			types.Types[types.TINT16],
+			types.Types[types.TINT32],
+			types.Types[types.TINT64],
+			types.Types[types.TUINT],
+			types.Types[types.TUINT8],
+			types.Types[types.TUINT16],
+			types.Types[types.TUINT32],
+			types.Types[types.TUINT64],
+			types.Types[types.TUINTPTR],
+			types.Types[types.TFLOAT32],
+			types.Types[types.TFLOAT64],
+			types.Types[types.TCOMPLEX64],
+			types.Types[types.TCOMPLEX128],
+			types.Types[types.TSTRING],
+
+			// basic type aliases
+			types.ByteType,
+			types.RuneType,
+
+			// error
+			types.ErrorType,
+
+			// untyped types
+			types.UntypedBool,
+			types.UntypedInt,
+			types.UntypedRune,
+			types.UntypedFloat,
+			types.UntypedComplex,
+			types.UntypedString,
+			types.Types[types.TNIL],
+
+			// package unsafe
+			types.Types[types.TUNSAFEPTR],
+
+			// invalid type (package contains errors)
+			types.Types[types.Txxx],
+
+			// any type, for builtin export data
+			types.Types[types.TANY],
+		}
+	}
+	return predecl
+}
diff --git a/src/cmd/compile/internal/typecheck/builtin.go b/src/cmd/compile/internal/typecheck/builtin.go
new file mode 100644
index 0000000000..d3c30fbf50
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/builtin.go
@@ -0,0 +1,344 @@
+// Code generated by mkbuiltin.go. DO NOT EDIT.
+
+package typecheck
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
+)
+
+var runtimeDecls = [...]struct {
+	name string
+	tag  int
+	typ  int
+}{
+	{"newobject", funcTag, 4},
+	{"mallocgc", funcTag, 8},
+	{"panicdivide", funcTag, 9},
+	{"panicshift", funcTag, 9},
+	{"panicmakeslicelen", funcTag, 9},
+	{"panicmakeslicecap", funcTag, 9},
+	{"throwinit", funcTag, 9},
+	{"panicwrap", funcTag, 9},
+	{"gopanic", funcTag, 11},
+	{"gorecover", funcTag, 14},
+	{"goschedguarded", funcTag, 9},
+	{"goPanicIndex", funcTag, 16},
+	{"goPanicIndexU", funcTag, 18},
+	{"goPanicSliceAlen", funcTag, 16},
+	{"goPanicSliceAlenU", funcTag, 18},
+	{"goPanicSliceAcap", funcTag, 16},
+	{"goPanicSliceAcapU", funcTag, 18},
+	{"goPanicSliceB", funcTag, 16},
+	{"goPanicSliceBU", funcTag, 18},
+	{"goPanicSlice3Alen", funcTag, 16},
+	{"goPanicSlice3AlenU", funcTag, 18},
+	{"goPanicSlice3Acap", funcTag, 16},
+	{"goPanicSlice3AcapU", funcTag, 18},
+	{"goPanicSlice3B", funcTag, 16},
+	{"goPanicSlice3BU", funcTag, 18},
+	{"goPanicSlice3C", funcTag, 16},
+	{"goPanicSlice3CU", funcTag, 18},
+	{"printbool", funcTag, 19},
+	{"printfloat", funcTag, 21},
+	{"printint", funcTag, 23},
+	{"printhex", funcTag, 25},
+	{"printuint", funcTag, 25},
+	{"printcomplex", funcTag, 27},
+	{"printstring", funcTag, 29},
+	{"printpointer", funcTag, 30},
+	{"printuintptr", funcTag, 31},
+	{"printiface", funcTag, 30},
+	{"printeface", funcTag, 30},
+	{"printslice", funcTag, 30},
+	{"printnl", funcTag, 9},
+	{"printsp", funcTag, 9},
+	{"printlock", funcTag, 9},
+	{"printunlock", funcTag, 9},
+	{"concatstring2", funcTag, 34},
+	{"concatstring3", funcTag, 35},
+	{"concatstring4", funcTag, 36},
+	{"concatstring5", funcTag, 37},
+	{"concatstrings", funcTag, 39},
+	{"cmpstring", funcTag, 40},
+	{"intstring", funcTag, 43},
+	{"slicebytetostring", funcTag, 44},
+	{"slicebytetostringtmp", funcTag, 45},
+	{"slicerunetostring", funcTag, 48},
+	{"stringtoslicebyte", funcTag, 50},
+	{"stringtoslicerune", funcTag, 53},
+	{"slicecopy", funcTag, 54},
+	{"decoderune", funcTag, 55},
+	{"countrunes", funcTag, 56},
+	{"convI2I", funcTag, 57},
+	{"convT16", funcTag, 58},
+	{"convT32", funcTag, 58},
+	{"convT64", funcTag, 58},
+	{"convTstring", funcTag, 58},
+	{"convTslice", funcTag, 58},
+	{"convT2E", funcTag, 59},
+	{"convT2Enoptr", funcTag, 59},
+	{"convT2I", funcTag, 59},
+	{"convT2Inoptr", funcTag, 59},
+	{"assertE2I", funcTag, 57},
+	{"assertE2I2", funcTag, 60},
+	{"assertI2I", funcTag, 57},
+	{"assertI2I2", funcTag, 60},
+	{"panicdottypeE", funcTag, 61},
+	{"panicdottypeI", funcTag, 61},
+	{"panicnildottype", funcTag, 62},
+	{"ifaceeq", funcTag, 64},
+	{"efaceeq", funcTag, 64},
+	{"fastrand", funcTag, 66},
+	{"makemap64", funcTag, 68},
+	{"makemap", funcTag, 69},
+	{"makemap_small", funcTag, 70},
+	{"mapaccess1", funcTag, 71},
+	{"mapaccess1_fast32", funcTag, 72},
+	{"mapaccess1_fast64", funcTag, 72},
+	{"mapaccess1_faststr", funcTag, 72},
+	{"mapaccess1_fat", funcTag, 73},
+	{"mapaccess2", funcTag, 74},
+	{"mapaccess2_fast32", funcTag, 75},
+	{"mapaccess2_fast64", funcTag, 75},
+	{"mapaccess2_faststr", funcTag, 75},
+	{"mapaccess2_fat", funcTag, 76},
+	{"mapassign", funcTag, 71},
+	{"mapassign_fast32", funcTag, 72},
+	{"mapassign_fast32ptr", funcTag, 72},
+	{"mapassign_fast64", funcTag, 72},
+	{"mapassign_fast64ptr", funcTag, 72},
+	{"mapassign_faststr", funcTag, 72},
+	{"mapiterinit", funcTag, 77},
+	{"mapdelete", funcTag, 77},
+	{"mapdelete_fast32", funcTag, 78},
+	{"mapdelete_fast64", funcTag, 78},
+	{"mapdelete_faststr", funcTag, 78},
+	{"mapiternext", funcTag, 79},
+	{"mapclear", funcTag, 80},
+	{"makechan64", funcTag, 82},
+	{"makechan", funcTag, 83},
+	{"chanrecv1", funcTag, 85},
+	{"chanrecv2", funcTag, 86},
+	{"chansend1", funcTag, 88},
+	{"closechan", funcTag, 30},
+	{"writeBarrier", varTag, 90},
+	{"typedmemmove", funcTag, 91},
+	{"typedmemclr", funcTag, 92},
+	{"typedslicecopy", funcTag, 93},
+	{"selectnbsend", funcTag, 94},
+	{"selectnbrecv", funcTag, 95},
+	{"selectnbrecv2", funcTag, 97},
+	{"selectsetpc", funcTag, 98},
+	{"selectgo", funcTag, 99},
+	{"block", funcTag, 9},
+	{"makeslice", funcTag, 100},
+	{"makeslice64", funcTag, 101},
+	{"makeslicecopy", funcTag, 102},
+	{"growslice", funcTag, 104},
+	{"memmove", funcTag, 105},
+	{"memclrNoHeapPointers", funcTag, 106},
+	{"memclrHasPointers", funcTag, 106},
+	{"memequal", funcTag, 107},
+	{"memequal0", funcTag, 108},
+	{"memequal8", funcTag, 108},
+	{"memequal16", funcTag, 108},
+	{"memequal32", funcTag, 108},
+	{"memequal64", funcTag, 108},
+	{"memequal128", funcTag, 108},
+	{"f32equal", funcTag, 109},
+	{"f64equal", funcTag, 109},
+	{"c64equal", funcTag, 109},
+	{"c128equal", funcTag, 109},
+	{"strequal", funcTag, 109},
+	{"interequal", funcTag, 109},
+	{"nilinterequal", funcTag, 109},
+	{"memhash", funcTag, 110},
+	{"memhash0", funcTag, 111},
+	{"memhash8", funcTag, 111},
+	{"memhash16", funcTag, 111},
+	{"memhash32", funcTag, 111},
+	{"memhash64", funcTag, 111},
+	{"memhash128", funcTag, 111},
+	{"f32hash", funcTag, 111},
+	{"f64hash", funcTag, 111},
+	{"c64hash", funcTag, 111},
+	{"c128hash", funcTag, 111},
+	{"strhash", funcTag, 111},
+	{"interhash", funcTag, 111},
+	{"nilinterhash", funcTag, 111},
+	{"int64div", funcTag, 112},
+	{"uint64div", funcTag, 113},
+	{"int64mod", funcTag, 112},
+	{"uint64mod", funcTag, 113},
+	{"float64toint64", funcTag, 114},
+	{"float64touint64", funcTag, 115},
+	{"float64touint32", funcTag, 116},
+	{"int64tofloat64", funcTag, 117},
+	{"uint64tofloat64", funcTag, 118},
+	{"uint32tofloat64", funcTag, 119},
+	{"complex128div", funcTag, 120},
+	{"racefuncenter", funcTag, 31},
+	{"racefuncenterfp", funcTag, 9},
+	{"racefuncexit", funcTag, 9},
+	{"raceread", funcTag, 31},
+	{"racewrite", funcTag, 31},
+	{"racereadrange", funcTag, 121},
+	{"racewriterange", funcTag, 121},
+	{"msanread", funcTag, 121},
+	{"msanwrite", funcTag, 121},
+	{"msanmove", funcTag, 122},
+	{"checkptrAlignment", funcTag, 123},
+	{"checkptrArithmetic", funcTag, 125},
+	{"libfuzzerTraceCmp1", funcTag, 127},
+	{"libfuzzerTraceCmp2", funcTag, 129},
+	{"libfuzzerTraceCmp4", funcTag, 130},
+	{"libfuzzerTraceCmp8", funcTag, 131},
+	{"libfuzzerTraceConstCmp1", funcTag, 127},
+	{"libfuzzerTraceConstCmp2", funcTag, 129},
+	{"libfuzzerTraceConstCmp4", funcTag, 130},
+	{"libfuzzerTraceConstCmp8", funcTag, 131},
+	{"x86HasPOPCNT", varTag, 6},
+	{"x86HasSSE41", varTag, 6},
+	{"x86HasFMA", varTag, 6},
+	{"armHasVFPv4", varTag, 6},
+	{"arm64HasATOMICS", varTag, 6},
+}
+
+func runtimeTypes() []*types.Type {
+	var typs [132]*types.Type
+	typs[0] = types.ByteType
+	typs[1] = types.NewPtr(typs[0])
+	typs[2] = types.Types[types.TANY]
+	typs[3] = types.NewPtr(typs[2])
+	typs[4] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3])})
+	typs[5] = types.Types[types.TUINTPTR]
+	typs[6] = types.Types[types.TBOOL]
+	typs[7] = types.Types[types.TUNSAFEPTR]
+	typs[8] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[5]), ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[6])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7])})
+	typs[9] = NewFuncType(nil, nil, nil)
+	typs[10] = types.Types[types.TINTER]
+	typs[11] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[10])}, nil)
+	typs[12] = types.Types[types.TINT32]
+	typs[13] = types.NewPtr(typs[12])
+	typs[14] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[13])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[10])})
+	typs[15] = types.Types[types.TINT]
+	typs[16] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[15])}, nil)
+	typs[17] = types.Types[types.TUINT]
+	typs[18] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[17]), ir.NewField(base.Pos, nil, nil, typs[15])}, nil)
+	typs[19] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])}, nil)
+	typs[20] = types.Types[types.TFLOAT64]
+	typs[21] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])}, nil)
+	typs[22] = types.Types[types.TINT64]
+	typs[23] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[22])}, nil)
+	typs[24] = types.Types[types.TUINT64]
+	typs[25] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[24])}, nil)
+	typs[26] = types.Types[types.TCOMPLEX128]
+	typs[27] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[26])}, nil)
+	typs[28] = types.Types[types.TSTRING]
+	typs[29] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])}, nil)
+	typs[30] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[2])}, nil)
+	typs[31] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[5])}, nil)
+	typs[32] = types.NewArray(typs[0], 32)
+	typs[33] = types.NewPtr(typs[32])
+	typs[34] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
+	typs[35] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
+	typs[36] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
+	typs[37] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
+	typs[38] = types.NewSlice(typs[28])
+	typs[39] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[38])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
+	typs[40] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[15])})
+	typs[41] = types.NewArray(typs[0], 4)
+	typs[42] = types.NewPtr(typs[41])
+	typs[43] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[42]), ir.NewField(base.Pos, nil, nil, typs[22])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
+	typs[44] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
+	typs[45] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
+	typs[46] = types.RuneType
+	typs[47] = types.NewSlice(typs[46])
+	typs[48] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[47])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
+	typs[49] = types.NewSlice(typs[0])
+	typs[50] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[49])})
+	typs[51] = types.NewArray(typs[46], 32)
+	typs[52] = types.NewPtr(typs[51])
+	typs[53] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[52]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[47])})
+	typs[54] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[5])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[15])})
+	typs[55] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[46]), ir.NewField(base.Pos, nil, nil, typs[15])})
+	typs[56] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[15])})
+	typs[57] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[2])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[2])})
+	typs[58] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[2])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7])})
+	typs[59] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[2])})
+	typs[60] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[2])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[2]), ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[61] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[1])}, nil)
+	typs[62] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1])}, nil)
+	typs[63] = types.NewPtr(typs[5])
+	typs[64] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[63]), ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[7])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[65] = types.Types[types.TUINT32]
+	typs[66] = NewFuncType(nil, nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[65])})
+	typs[67] = types.NewMap(typs[2], typs[2])
+	typs[68] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[22]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[67])})
+	typs[69] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[67])})
+	typs[70] = NewFuncType(nil, nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[67])})
+	typs[71] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3])})
+	typs[72] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[2])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3])})
+	typs[73] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[1])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3])})
+	typs[74] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[75] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[2])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[76] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[1])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[77] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[3])}, nil)
+	typs[78] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[2])}, nil)
+	typs[79] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3])}, nil)
+	typs[80] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67])}, nil)
+	typs[81] = types.NewChan(typs[2], types.Cboth)
+	typs[82] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[22])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[81])})
+	typs[83] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[81])})
+	typs[84] = types.NewChan(typs[2], types.Crecv)
+	typs[85] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[84]), ir.NewField(base.Pos, nil, nil, typs[3])}, nil)
+	typs[86] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[84]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[87] = types.NewChan(typs[2], types.Csend)
+	typs[88] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[87]), ir.NewField(base.Pos, nil, nil, typs[3])}, nil)
+	typs[89] = types.NewArray(typs[0], 3)
+	typs[90] = NewStructType([]*ir.Field{ir.NewField(base.Pos, Lookup("enabled"), nil, typs[6]), ir.NewField(base.Pos, Lookup("pad"), nil, typs[89]), ir.NewField(base.Pos, Lookup("needed"), nil, typs[6]), ir.NewField(base.Pos, Lookup("cgo"), nil, typs[6]), ir.NewField(base.Pos, Lookup("alignme"), nil, typs[24])})
+	typs[91] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[3])}, nil)
+	typs[92] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[3])}, nil)
+	typs[93] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[15])})
+	typs[94] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[87]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[95] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[84])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[96] = types.NewPtr(typs[6])
+	typs[97] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[96]), ir.NewField(base.Pos, nil, nil, typs[84])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[98] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[63])}, nil)
+	typs[99] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[63]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[6])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[100] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7])})
+	typs[101] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[22]), ir.NewField(base.Pos, nil, nil, typs[22])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7])})
+	typs[102] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[7])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7])})
+	typs[103] = types.NewSlice(typs[2])
+	typs[104] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[103]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[103])})
+	typs[105] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[5])}, nil)
+	typs[106] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[5])}, nil)
+	typs[107] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[5])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[108] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[109] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[7])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[110] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[5]), ir.NewField(base.Pos, nil, nil, typs[5])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[5])})
+	typs[111] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[5])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[5])})
+	typs[112] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[22]), ir.NewField(base.Pos, nil, nil, typs[22])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[22])})
+	typs[113] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[24]), ir.NewField(base.Pos, nil, nil, typs[24])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[24])})
+	typs[114] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[22])})
+	typs[115] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[24])})
+	typs[116] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[65])})
+	typs[117] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[22])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])})
+	typs[118] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[24])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])})
+	typs[119] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[65])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])})
+	typs[120] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[26]), ir.NewField(base.Pos, nil, nil, typs[26])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[26])})
+	typs[121] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[5]), ir.NewField(base.Pos, nil, nil, typs[5])}, nil)
+	typs[122] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[5]), ir.NewField(base.Pos, nil, nil, typs[5]), ir.NewField(base.Pos, nil, nil, typs[5])}, nil)
+	typs[123] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[5])}, nil)
+	typs[124] = types.NewSlice(typs[7])
+	typs[125] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[124])}, nil)
+	typs[126] = types.Types[types.TUINT8]
+	typs[127] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[126]), ir.NewField(base.Pos, nil, nil, typs[126])}, nil)
+	typs[128] = types.Types[types.TUINT16]
+	typs[129] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[128]), ir.NewField(base.Pos, nil, nil, typs[128])}, nil)
+	typs[130] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[65]), ir.NewField(base.Pos, nil, nil, typs[65])}, nil)
+	typs[131] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[24]), ir.NewField(base.Pos, nil, nil, typs[24])}, nil)
+	return typs[:]
+}
diff --git a/src/cmd/compile/internal/gc/builtin/runtime.go b/src/cmd/compile/internal/typecheck/builtin/runtime.go
similarity index 100%
rename from src/cmd/compile/internal/gc/builtin/runtime.go
rename to src/cmd/compile/internal/typecheck/builtin/runtime.go
diff --git a/src/cmd/compile/internal/gc/builtin_test.go b/src/cmd/compile/internal/typecheck/builtin_test.go
similarity index 97%
rename from src/cmd/compile/internal/gc/builtin_test.go
rename to src/cmd/compile/internal/typecheck/builtin_test.go
index df15ca5c7d..cc8d49730a 100644
--- a/src/cmd/compile/internal/gc/builtin_test.go
+++ b/src/cmd/compile/internal/typecheck/builtin_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc_test
+package typecheck
 
 import (
 	"bytes"
diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/typecheck/const.go
similarity index 85%
rename from src/cmd/compile/internal/gc/const.go
rename to src/cmd/compile/internal/typecheck/const.go
index ad27f3ea44..54d70cb835 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/typecheck/const.go
@@ -2,13 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package typecheck
 
 import (
-	"cmd/compile/internal/base"
-	"cmd/compile/internal/ir"
-	"cmd/compile/internal/types"
-	"cmd/internal/src"
 	"fmt"
 	"go/constant"
 	"go/token"
@@ -16,6 +12,11 @@ import (
 	"math/big"
 	"strings"
 	"unicode"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
+	"cmd/internal/src"
 )
 
 func roundFloat(v constant.Value, sz int64) constant.Value {
@@ -61,7 +62,7 @@ func trunccmplxlit(v constant.Value, t *types.Type) constant.Value {
 
 // TODO(mdempsky): Replace these with better APIs.
 func convlit(n ir.Node, t *types.Type) ir.Node    { return convlit1(n, t, false, nil) }
-func defaultlit(n ir.Node, t *types.Type) ir.Node { return convlit1(n, t, false, nil) }
+func DefaultLit(n ir.Node, t *types.Type) ir.Node { return convlit1(n, t, false, nil) }
 
 // convlit1 converts an untyped expression n to type t. If n already
 // has a type, convlit1 has no effect.
@@ -134,7 +135,7 @@ func convlit1(n ir.Node, t *types.Type, explicit bool, context func() string) ir
 	case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT, ir.OREAL, ir.OIMAG:
 		ot := operandType(n.Op(), t)
 		if ot == nil {
-			n = defaultlit(n, nil)
+			n = DefaultLit(n, nil)
 			break
 		}
 
@@ -150,7 +151,7 @@ func convlit1(n ir.Node, t *types.Type, explicit bool, context func() string) ir
 	case ir.OADD, ir.OSUB, ir.OMUL, ir.ODIV, ir.OMOD, ir.OOR, ir.OXOR, ir.OAND, ir.OANDNOT, ir.OOROR, ir.OANDAND, ir.OCOMPLEX:
 		ot := operandType(n.Op(), t)
 		if ot == nil {
-			n = defaultlit(n, nil)
+			n = DefaultLit(n, nil)
 			break
 		}
 
@@ -387,11 +388,11 @@ var tokenForOp = [...]token.Token{
 	ir.ORSH: token.SHR,
 }
 
-// evalConst returns a constant-evaluated expression equivalent to n.
-// If n is not a constant, evalConst returns n.
-// Otherwise, evalConst returns a new OLITERAL with the same value as n,
+// EvalConst returns a constant-evaluated expression equivalent to n.
+// If n is not a constant, EvalConst returns n.
+// Otherwise, EvalConst returns a new OLITERAL with the same value as n,
 // and with .Orig pointing back to n.
-func evalConst(n ir.Node) ir.Node {
+func EvalConst(n ir.Node) ir.Node {
 	// Pick off just the opcodes that can be constant evaluated.
 	switch n.Op() {
 	case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT:
@@ -402,7 +403,7 @@ func evalConst(n ir.Node) ir.Node {
 			if n.Type().IsUnsigned() {
 				prec = uint(n.Type().Size() * 8)
 			}
-			return origConst(n, constant.UnaryOp(tokenForOp[n.Op()], nl.Val(), prec))
+			return OrigConst(n, constant.UnaryOp(tokenForOp[n.Op()], nl.Val(), prec))
 		}
 
 	case ir.OADD, ir.OSUB, ir.OMUL, ir.ODIV, ir.OMOD, ir.OOR, ir.OXOR, ir.OAND, ir.OANDNOT:
@@ -427,21 +428,21 @@ func evalConst(n ir.Node) ir.Node {
 			if n.Op() == ir.ODIV && n.Type().IsInteger() {
 				tok = token.QUO_ASSIGN // integer division
 			}
-			return origConst(n, constant.BinaryOp(nl.Val(), tok, rval))
+			return OrigConst(n, constant.BinaryOp(nl.Val(), tok, rval))
 		}
 
 	case ir.OOROR, ir.OANDAND:
 		n := n.(*ir.LogicalExpr)
 		nl, nr := n.X, n.Y
 		if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
-			return origConst(n, constant.BinaryOp(nl.Val(), tokenForOp[n.Op()], nr.Val()))
+			return OrigConst(n, constant.BinaryOp(nl.Val(), tokenForOp[n.Op()], nr.Val()))
 		}
 
 	case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
 		n := n.(*ir.BinaryExpr)
 		nl, nr := n.X, n.Y
 		if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
-			return origBoolConst(n, constant.Compare(nl.Val(), tokenForOp[n.Op()], nr.Val()))
+			return OrigBool(n, constant.Compare(nl.Val(), tokenForOp[n.Op()], nr.Val()))
 		}
 
 	case ir.OLSH, ir.ORSH:
@@ -456,14 +457,14 @@ func evalConst(n ir.Node) ir.Node {
 				n.SetType(nil)
 				break
 			}
-			return origConst(n, constant.Shift(toint(nl.Val()), tokenForOp[n.Op()], uint(s)))
+			return OrigConst(n, constant.Shift(toint(nl.Val()), tokenForOp[n.Op()], uint(s)))
 		}
 
 	case ir.OCONV, ir.ORUNESTR:
 		n := n.(*ir.ConvExpr)
 		nl := n.X
 		if ir.OKForConst[n.Type().Kind()] && nl.Op() == ir.OLITERAL {
-			return origConst(n, convertVal(nl.Val(), n.Type(), true))
+			return OrigConst(n, convertVal(nl.Val(), n.Type(), true))
 		}
 
 	case ir.OCONVNOP:
@@ -472,7 +473,7 @@ func evalConst(n ir.Node) ir.Node {
 		if ir.OKForConst[n.Type().Kind()] && nl.Op() == ir.OLITERAL {
 			// set so n.Orig gets OCONV instead of OCONVNOP
 			n.SetOp(ir.OCONV)
-			return origConst(n, nl.Val())
+			return OrigConst(n, nl.Val())
 		}
 
 	case ir.OADDSTR:
@@ -494,7 +495,7 @@ func evalConst(n ir.Node) ir.Node {
 			for _, c := range s {
 				strs = append(strs, ir.StringVal(c))
 			}
-			return origConst(n, constant.MakeString(strings.Join(strs, "")))
+			return OrigConst(n, constant.MakeString(strings.Join(strs, "")))
 		}
 		newList := make([]ir.Node, 0, need)
 		for i := 0; i < len(s); i++ {
@@ -509,7 +510,7 @@ func evalConst(n ir.Node) ir.Node {
 
 				nl := ir.Copy(n).(*ir.AddStringExpr)
 				nl.List.Set(s[i:i2])
-				newList = append(newList, origConst(nl, constant.MakeString(strings.Join(strs, ""))))
+				newList = append(newList, OrigConst(nl, constant.MakeString(strings.Join(strs, ""))))
 				i = i2 - 1
 			} else {
 				newList = append(newList, s[i])
@@ -526,37 +527,37 @@ func evalConst(n ir.Node) ir.Node {
 		switch nl.Type().Kind() {
 		case types.TSTRING:
 			if ir.IsConst(nl, constant.String) {
-				return origIntConst(n, int64(len(ir.StringVal(nl))))
+				return OrigInt(n, int64(len(ir.StringVal(nl))))
 			}
 		case types.TARRAY:
 			if !anyCallOrChan(nl) {
-				return origIntConst(n, nl.Type().NumElem())
+				return OrigInt(n, nl.Type().NumElem())
 			}
 		}
 
 	case ir.OALIGNOF, ir.OOFFSETOF, ir.OSIZEOF:
 		n := n.(*ir.UnaryExpr)
-		return origIntConst(n, evalunsafe(n))
+		return OrigInt(n, evalunsafe(n))
 
 	case ir.OREAL:
 		n := n.(*ir.UnaryExpr)
 		nl := n.X
 		if nl.Op() == ir.OLITERAL {
-			return origConst(n, constant.Real(nl.Val()))
+			return OrigConst(n, constant.Real(nl.Val()))
 		}
 
 	case ir.OIMAG:
 		n := n.(*ir.UnaryExpr)
 		nl := n.X
 		if nl.Op() == ir.OLITERAL {
-			return origConst(n, constant.Imag(nl.Val()))
+			return OrigConst(n, constant.Imag(nl.Val()))
 		}
 
 	case ir.OCOMPLEX:
 		n := n.(*ir.BinaryExpr)
 		nl, nr := n.X, n.Y
 		if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
-			return origConst(n, makeComplex(nl.Val(), nr.Val()))
+			return OrigConst(n, makeComplex(nl.Val(), nr.Val()))
 		}
 	}
 
@@ -598,8 +599,8 @@ var overflowNames = [...]string{
 	ir.OBITNOT: "bitwise complement",
 }
 
-// origConst returns an OLITERAL with orig n and value v.
-func origConst(n ir.Node, v constant.Value) ir.Node {
+// OrigConst returns an OLITERAL with orig n and value v.
+func OrigConst(n ir.Node, v constant.Value) ir.Node {
 	lno := ir.SetPos(n)
 	v = convertVal(v, n.Type(), false)
 	base.Pos = lno
@@ -623,12 +624,12 @@ func origConst(n ir.Node, v constant.Value) ir.Node {
 	return ir.NewConstExpr(v, n)
 }
 
-func origBoolConst(n ir.Node, v bool) ir.Node {
-	return origConst(n, constant.MakeBool(v))
+func OrigBool(n ir.Node, v bool) ir.Node {
+	return OrigConst(n, constant.MakeBool(v))
 }
 
-func origIntConst(n ir.Node, v int64) ir.Node {
-	return origConst(n, constant.MakeInt64(v))
+func OrigInt(n ir.Node, v int64) ir.Node {
+	return OrigConst(n, constant.MakeInt64(v))
 }
 
 // defaultlit on both nodes simultaneously;
@@ -722,12 +723,12 @@ func defaultType(t *types.Type) *types.Type {
 	return nil
 }
 
-// indexconst checks if Node n contains a constant expression
+// IndexConst checks if Node n contains a constant expression
 // representable as a non-negative int and returns its value.
 // If n is not a constant expression, not representable as an
 // integer, or negative, it returns -1. If n is too large, it
 // returns -2.
-func indexconst(n ir.Node) int64 {
+func IndexConst(n ir.Node) int64 {
 	if n.Op() != ir.OLITERAL {
 		return -1
 	}
@@ -862,3 +863,82 @@ func nodeAndVal(n ir.Node) string {
 	}
 	return show
 }
+
+// evalunsafe evaluates a package unsafe operation and returns the result.
+func evalunsafe(n ir.Node) int64 {
+	switch n.Op() {
+	case ir.OALIGNOF, ir.OSIZEOF:
+		n := n.(*ir.UnaryExpr)
+		n.X = Expr(n.X)
+		n.X = DefaultLit(n.X, nil)
+		tr := n.X.Type()
+		if tr == nil {
+			return 0
+		}
+		types.CalcSize(tr)
+		if n.Op() == ir.OALIGNOF {
+			return int64(tr.Align)
+		}
+		return tr.Width
+
+	case ir.OOFFSETOF:
+		// must be a selector.
+		n := n.(*ir.UnaryExpr)
+		if n.X.Op() != ir.OXDOT {
+			base.Errorf("invalid expression %v", n)
+			return 0
+		}
+		sel := n.X.(*ir.SelectorExpr)
+
+		// Remember base of selector to find it back after dot insertion.
+		// Since r->left may be mutated by typechecking, check it explicitly
+		// first to track it correctly.
+		sel.X = Expr(sel.X)
+		sbase := sel.X
+
+		tsel := Expr(sel)
+		n.X = tsel
+		if tsel.Type() == nil {
+			return 0
+		}
+		switch tsel.Op() {
+		case ir.ODOT, ir.ODOTPTR:
+			break
+		case ir.OCALLPART:
+			base.Errorf("invalid expression %v: argument is a method value", n)
+			return 0
+		default:
+			base.Errorf("invalid expression %v", n)
+			return 0
+		}
+
+		// Sum offsets for dots until we reach sbase.
+		var v int64
+		var next ir.Node
+		for r := tsel; r != sbase; r = next {
+			switch r.Op() {
+			case ir.ODOTPTR:
+				// For Offsetof(s.f), s may itself be a pointer,
+				// but accessing f must not otherwise involve
+				// indirection via embedded pointer types.
+				r := r.(*ir.SelectorExpr)
+				if r.X != sbase {
+					base.Errorf("invalid expression %v: selector implies indirection of embedded %v", n, r.X)
+					return 0
+				}
+				fallthrough
+			case ir.ODOT:
+				r := r.(*ir.SelectorExpr)
+				v += r.Offset
+				next = r.X
+			default:
+				ir.Dump("unsafenmagic", tsel)
+				base.Fatalf("impossible %v node after dot insertion", r.Op())
+			}
+		}
+		return v
+	}
+
+	base.Fatalf("unexpected op %v", n.Op())
+	return 0
+}
diff --git a/src/cmd/compile/internal/typecheck/dcl.go b/src/cmd/compile/internal/typecheck/dcl.go
new file mode 100644
index 0000000000..9f66d0fa17
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/dcl.go
@@ -0,0 +1,705 @@
+// Copyright 2009 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 typecheck
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
+	"cmd/internal/src"
+)
+
+var DeclContext ir.Class // PEXTERN/PAUTO
+
+func AssignDefn(left []ir.Node, defn ir.Node) {
+	for _, n := range left {
+		if n.Sym() != nil {
+			n.Sym().SetUniq(true)
+		}
+	}
+
+	var nnew, nerr int
+	for i, n := range left {
+		if ir.IsBlank(n) {
+			continue
+		}
+		if !assignableName(n) {
+			base.ErrorfAt(defn.Pos(), "non-name %v on left side of :=", n)
+			nerr++
+			continue
+		}
+
+		if !n.Sym().Uniq() {
+			base.ErrorfAt(defn.Pos(), "%v repeated on left side of :=", n.Sym())
+			n.SetDiag(true)
+			nerr++
+			continue
+		}
+
+		n.Sym().SetUniq(false)
+		if n.Sym().Block == types.Block {
+			continue
+		}
+
+		nnew++
+		n := NewName(n.Sym())
+		Declare(n, DeclContext)
+		n.Defn = defn
+		defn.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, n))
+		left[i] = n
+	}
+
+	if nnew == 0 && nerr == 0 {
+		base.ErrorfAt(defn.Pos(), "no new variables on left side of :=")
+	}
+}
+
+// := declarations
+func assignableName(n ir.Node) bool {
+	switch n.Op() {
+	case ir.ONAME,
+		ir.ONONAME,
+		ir.OPACK,
+		ir.OTYPE,
+		ir.OLITERAL:
+		return n.Sym() != nil
+	}
+
+	return false
+}
+
+func DeclFunc(sym *types.Sym, tfn ir.Ntype) *ir.Func {
+	if tfn.Op() != ir.OTFUNC {
+		base.Fatalf("expected OTFUNC node, got %v", tfn)
+	}
+
+	fn := ir.NewFunc(base.Pos)
+	fn.Nname = ir.NewFuncNameAt(base.Pos, sym, fn)
+	fn.Nname.Defn = fn
+	fn.Nname.Ntype = tfn
+	ir.MarkFunc(fn.Nname)
+	StartFuncBody(fn)
+	fn.Nname.Ntype = typecheckNtype(fn.Nname.Ntype)
+	return fn
+}
+
+// declare variables from grammar
+// new_name_list (type | [type] = expr_list)
+func DeclVars(vl []*ir.Name, t ir.Ntype, el []ir.Node) []ir.Node {
+	var init []ir.Node
+	doexpr := len(el) > 0
+
+	if len(el) == 1 && len(vl) > 1 {
+		e := el[0]
+		as2 := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
+		as2.Rhs = []ir.Node{e}
+		for _, v := range vl {
+			as2.Lhs.Append(v)
+			Declare(v, DeclContext)
+			v.Ntype = t
+			v.Defn = as2
+			if ir.CurFunc != nil {
+				init = append(init, ir.NewDecl(base.Pos, ir.ODCL, v))
+			}
+		}
+
+		return append(init, as2)
+	}
+
+	for i, v := range vl {
+		var e ir.Node
+		if doexpr {
+			if i >= len(el) {
+				base.Errorf("assignment mismatch: %d variables but %d values", len(vl), len(el))
+				break
+			}
+			e = el[i]
+		}
+
+		Declare(v, DeclContext)
+		v.Ntype = t
+
+		if e != nil || ir.CurFunc != nil || ir.IsBlank(v) {
+			if ir.CurFunc != nil {
+				init = append(init, ir.NewDecl(base.Pos, ir.ODCL, v))
+			}
+			as := ir.NewAssignStmt(base.Pos, v, e)
+			init = append(init, as)
+			if e != nil {
+				v.Defn = as
+			}
+		}
+	}
+
+	if len(el) > len(vl) {
+		base.Errorf("assignment mismatch: %d variables but %d values", len(vl), len(el))
+	}
+	return init
+}
+
+// Declare records that Node n declares symbol n.Sym in the specified
+// declaration context.
+func Declare(n *ir.Name, ctxt ir.Class) {
+	if ir.IsBlank(n) {
+		return
+	}
+
+	s := n.Sym()
+
+	// kludgy: typecheckok means we're past parsing. Eg genwrapper may declare out of package names later.
+	if !inimport && !TypecheckAllowed && s.Pkg != types.LocalPkg {
+		base.ErrorfAt(n.Pos(), "cannot declare name %v", s)
+	}
+
+	gen := 0
+	if ctxt == ir.PEXTERN {
+		if s.Name == "init" {
+			base.ErrorfAt(n.Pos(), "cannot declare init - must be func")
+		}
+		if s.Name == "main" && s.Pkg.Name == "main" {
+			base.ErrorfAt(n.Pos(), "cannot declare main - must be func")
+		}
+		Target.Externs = append(Target.Externs, n)
+	} else {
+		if ir.CurFunc == nil && ctxt == ir.PAUTO {
+			base.Pos = n.Pos()
+			base.Fatalf("automatic outside function")
+		}
+		if ir.CurFunc != nil && ctxt != ir.PFUNC && n.Op() == ir.ONAME {
+			ir.CurFunc.Dcl = append(ir.CurFunc.Dcl, n)
+		}
+		if n.Op() == ir.OTYPE {
+			declare_typegen++
+			gen = declare_typegen
+		} else if n.Op() == ir.ONAME && ctxt == ir.PAUTO && !strings.Contains(s.Name, "·") {
+			vargen++
+			gen = vargen
+		}
+		types.Pushdcl(s)
+		n.Curfn = ir.CurFunc
+	}
+
+	if ctxt == ir.PAUTO {
+		n.SetFrameOffset(0)
+	}
+
+	if s.Block == types.Block {
+		// functype will print errors about duplicate function arguments.
+		// Don't repeat the error here.
+		if ctxt != ir.PPARAM && ctxt != ir.PPARAMOUT {
+			Redeclared(n.Pos(), s, "in this block")
+		}
+	}
+
+	s.Block = types.Block
+	s.Lastlineno = base.Pos
+	s.Def = n
+	n.Vargen = int32(gen)
+	n.Class_ = ctxt
+	if ctxt == ir.PFUNC {
+		n.Sym().SetFunc(true)
+	}
+
+	autoexport(n, ctxt)
+}
+
+// Export marks n for export (or reexport).
+func Export(n *ir.Name) {
+	if n.Sym().OnExportList() {
+		return
+	}
+	n.Sym().SetOnExportList(true)
+
+	if base.Flag.E != 0 {
+		fmt.Printf("export symbol %v\n", n.Sym())
+	}
+
+	Target.Exports = append(Target.Exports, n)
+}
+
+// Redeclared emits a diagnostic about symbol s being redeclared at pos.
+func Redeclared(pos src.XPos, s *types.Sym, where string) {
+	if !s.Lastlineno.IsKnown() {
+		pkgName := DotImportRefs[s.Def.(*ir.Ident)]
+		base.ErrorfAt(pos, "%v redeclared %s\n"+
+			"\t%v: previous declaration during import %q", s, where, base.FmtPos(pkgName.Pos()), pkgName.Pkg.Path)
+	} else {
+		prevPos := s.Lastlineno
+
+		// When an import and a declaration collide in separate files,
+		// present the import as the "redeclared", because the declaration
+		// is visible where the import is, but not vice versa.
+		// See issue 4510.
+		if s.Def == nil {
+			pos, prevPos = prevPos, pos
+		}
+
+		base.ErrorfAt(pos, "%v redeclared %s\n"+
+			"\t%v: previous declaration", s, where, base.FmtPos(prevPos))
+	}
+}
+
+// declare the function proper
+// and declare the arguments.
+// called in extern-declaration context
+// returns in auto-declaration context.
+func StartFuncBody(fn *ir.Func) {
+	// change the declaration context from extern to auto
+	funcStack = append(funcStack, funcStackEnt{ir.CurFunc, DeclContext})
+	ir.CurFunc = fn
+	DeclContext = ir.PAUTO
+
+	types.Markdcl()
+
+	if fn.Nname.Ntype != nil {
+		funcargs(fn.Nname.Ntype.(*ir.FuncType))
+	} else {
+		funcargs2(fn.Type())
+	}
+}
+
+// finish the body.
+// called in auto-declaration context.
+// returns in extern-declaration context.
+func FinishFuncBody() {
+	// change the declaration context from auto to previous context
+	types.Popdcl()
+	var e funcStackEnt
+	funcStack, e = funcStack[:len(funcStack)-1], funcStack[len(funcStack)-1]
+	ir.CurFunc, DeclContext = e.curfn, e.dclcontext
+}
+
+func CheckFuncStack() {
+	if len(funcStack) != 0 {
+		base.Fatalf("funcStack is non-empty: %v", len(funcStack))
+	}
+}
+
+// turn a parsed function declaration into a type
+func NewFuncType(nrecv *ir.Field, nparams, nresults []*ir.Field) *types.Type {
+	funarg := func(n *ir.Field) *types.Field {
+		lno := base.Pos
+		base.Pos = n.Pos
+
+		if n.Ntype != nil {
+			n.Type = typecheckNtype(n.Ntype).Type()
+			n.Ntype = nil
+		}
+
+		f := types.NewField(n.Pos, n.Sym, n.Type)
+		f.SetIsDDD(n.IsDDD)
+		if n.Decl != nil {
+			n.Decl.SetType(f.Type)
+			f.Nname = n.Decl
+		}
+
+		base.Pos = lno
+		return f
+	}
+	funargs := func(nn []*ir.Field) []*types.Field {
+		res := make([]*types.Field, len(nn))
+		for i, n := range nn {
+			res[i] = funarg(n)
+		}
+		return res
+	}
+
+	var recv *types.Field
+	if nrecv != nil {
+		recv = funarg(nrecv)
+	}
+
+	t := types.NewSignature(types.LocalPkg, recv, funargs(nparams), funargs(nresults))
+	checkdupfields("argument", t.Recvs().FieldSlice(), t.Params().FieldSlice(), t.Results().FieldSlice())
+	return t
+}
+
+// convert a parsed id/type list into
+// a type for struct/interface/arglist
+func NewStructType(l []*ir.Field) *types.Type {
+	lno := base.Pos
+
+	fields := make([]*types.Field, len(l))
+	for i, n := range l {
+		base.Pos = n.Pos
+
+		if n.Ntype != nil {
+			n.Type = typecheckNtype(n.Ntype).Type()
+			n.Ntype = nil
+		}
+		f := types.NewField(n.Pos, n.Sym, n.Type)
+		if n.Embedded {
+			checkembeddedtype(n.Type)
+			f.Embedded = 1
+		}
+		f.Note = n.Note
+		fields[i] = f
+	}
+	checkdupfields("field", fields)
+
+	base.Pos = lno
+	return types.NewStruct(types.LocalPkg, fields)
+}
+
+// Add a method, declared as a function.
+// - msym is the method symbol
+// - t is function type (with receiver)
+// Returns a pointer to the existing or added Field; or nil if there's an error.
+func addmethod(n *ir.Func, msym *types.Sym, t *types.Type, local, nointerface bool) *types.Field {
+	if msym == nil {
+		base.Fatalf("no method symbol")
+	}
+
+	// get parent type sym
+	rf := t.Recv() // ptr to this structure
+	if rf == nil {
+		base.Errorf("missing receiver")
+		return nil
+	}
+
+	mt := types.ReceiverBaseType(rf.Type)
+	if mt == nil || mt.Sym() == nil {
+		pa := rf.Type
+		t := pa
+		if t != nil && t.IsPtr() {
+			if t.Sym() != nil {
+				base.Errorf("invalid receiver type %v (%v is a pointer type)", pa, t)
+				return nil
+			}
+			t = t.Elem()
+		}
+
+		switch {
+		case t == nil || t.Broke():
+			// rely on typecheck having complained before
+		case t.Sym() == nil:
+			base.Errorf("invalid receiver type %v (%v is not a defined type)", pa, t)
+		case t.IsPtr():
+			base.Errorf("invalid receiver type %v (%v is a pointer type)", pa, t)
+		case t.IsInterface():
+			base.Errorf("invalid receiver type %v (%v is an interface type)", pa, t)
+		default:
+			// Should have picked off all the reasons above,
+			// but just in case, fall back to generic error.
+			base.Errorf("invalid receiver type %v (%L / %L)", pa, pa, t)
+		}
+		return nil
+	}
+
+	if local && mt.Sym().Pkg != types.LocalPkg {
+		base.Errorf("cannot define new methods on non-local type %v", mt)
+		return nil
+	}
+
+	if msym.IsBlank() {
+		return nil
+	}
+
+	if mt.IsStruct() {
+		for _, f := range mt.Fields().Slice() {
+			if f.Sym == msym {
+				base.Errorf("type %v has both field and method named %v", mt, msym)
+				f.SetBroke(true)
+				return nil
+			}
+		}
+	}
+
+	for _, f := range mt.Methods().Slice() {
+		if msym.Name != f.Sym.Name {
+			continue
+		}
+		// types.Identical only checks that incoming and result parameters match,
+		// so explicitly check that the receiver parameters match too.
+		if !types.Identical(t, f.Type) || !types.Identical(t.Recv().Type, f.Type.Recv().Type) {
+			base.Errorf("method redeclared: %v.%v\n\t%v\n\t%v", mt, msym, f.Type, t)
+		}
+		return f
+	}
+
+	f := types.NewField(base.Pos, msym, t)
+	f.Nname = n.Nname
+	f.SetNointerface(nointerface)
+
+	mt.Methods().Append(f)
+	return f
+}
+
+func autoexport(n *ir.Name, ctxt ir.Class) {
+	if n.Sym().Pkg != types.LocalPkg {
+		return
+	}
+	if (ctxt != ir.PEXTERN && ctxt != ir.PFUNC) || DeclContext != ir.PEXTERN {
+		return
+	}
+	if n.Type() != nil && n.Type().IsKind(types.TFUNC) && ir.IsMethod(n) {
+		return
+	}
+
+	if types.IsExported(n.Sym().Name) || initname(n.Sym().Name) {
+		Export(n)
+	}
+	if base.Flag.AsmHdr != "" && !n.Sym().Asm() {
+		n.Sym().SetAsm(true)
+		Target.Asms = append(Target.Asms, n)
+	}
+}
+
+// checkdupfields emits errors for duplicately named fields or methods in
+// a list of struct or interface types.
+func checkdupfields(what string, fss ...[]*types.Field) {
+	seen := make(map[*types.Sym]bool)
+	for _, fs := range fss {
+		for _, f := range fs {
+			if f.Sym == nil || f.Sym.IsBlank() {
+				continue
+			}
+			if seen[f.Sym] {
+				base.ErrorfAt(f.Pos, "duplicate %s %s", what, f.Sym.Name)
+				continue
+			}
+			seen[f.Sym] = true
+		}
+	}
+}
+
+// structs, functions, and methods.
+// they don't belong here, but where do they belong?
+func checkembeddedtype(t *types.Type) {
+	if t == nil {
+		return
+	}
+
+	if t.Sym() == nil && t.IsPtr() {
+		t = t.Elem()
+		if t.IsInterface() {
+			base.Errorf("embedded type cannot be a pointer to interface")
+		}
+	}
+
+	if t.IsPtr() || t.IsUnsafePtr() {
+		base.Errorf("embedded type cannot be a pointer")
+	} else if t.Kind() == types.TFORW && !t.ForwardType().Embedlineno.IsKnown() {
+		t.ForwardType().Embedlineno = base.Pos
+	}
+}
+
+// declare individual names - var, typ, const
+
+var declare_typegen int
+
+func fakeRecvField() *types.Field {
+	return types.NewField(src.NoXPos, nil, types.FakeRecvType())
+}
+
+var funcStack []funcStackEnt // stack of previous values of Curfn/dclcontext
+
+type funcStackEnt struct {
+	curfn      *ir.Func
+	dclcontext ir.Class
+}
+
+func funcarg(n *ir.Field, ctxt ir.Class) {
+	if n.Sym == nil {
+		return
+	}
+
+	name := ir.NewNameAt(n.Pos, n.Sym)
+	n.Decl = name
+	name.Ntype = n.Ntype
+	name.SetIsDDD(n.IsDDD)
+	Declare(name, ctxt)
+
+	vargen++
+	n.Decl.Vargen = int32(vargen)
+}
+
+func funcarg2(f *types.Field, ctxt ir.Class) {
+	if f.Sym == nil {
+		return
+	}
+	n := ir.NewNameAt(f.Pos, f.Sym)
+	f.Nname = n
+	n.SetType(f.Type)
+	n.SetIsDDD(f.IsDDD())
+	Declare(n, ctxt)
+}
+
+func funcargs(nt *ir.FuncType) {
+	if nt.Op() != ir.OTFUNC {
+		base.Fatalf("funcargs %v", nt.Op())
+	}
+
+	// re-start the variable generation number
+	// we want to use small numbers for the return variables,
+	// so let them have the chunk starting at 1.
+	//
+	// TODO(mdempsky): This is ugly, and only necessary because
+	// esc.go uses Vargen to figure out result parameters' index
+	// within the result tuple.
+	vargen = len(nt.Results)
+
+	// declare the receiver and in arguments.
+	if nt.Recv != nil {
+		funcarg(nt.Recv, ir.PPARAM)
+	}
+	for _, n := range nt.Params {
+		funcarg(n, ir.PPARAM)
+	}
+
+	oldvargen := vargen
+	vargen = 0
+
+	// declare the out arguments.
+	gen := len(nt.Params)
+	for _, n := range nt.Results {
+		if n.Sym == nil {
+			// Name so that escape analysis can track it. ~r stands for 'result'.
+			n.Sym = LookupNum("~r", gen)
+			gen++
+		}
+		if n.Sym.IsBlank() {
+			// Give it a name so we can assign to it during return. ~b stands for 'blank'.
+			// The name must be different from ~r above because if you have
+			//	func f() (_ int)
+			//	func g() int
+			// f is allowed to use a plain 'return' with no arguments, while g is not.
+			// So the two cases must be distinguished.
+			n.Sym = LookupNum("~b", gen)
+			gen++
+		}
+
+		funcarg(n, ir.PPARAMOUT)
+	}
+
+	vargen = oldvargen
+}
+
+// Same as funcargs, except run over an already constructed TFUNC.
+// This happens during import, where the hidden_fndcl rule has
+// used functype directly to parse the function's type.
+func funcargs2(t *types.Type) {
+	if t.Kind() != types.TFUNC {
+		base.Fatalf("funcargs2 %v", t)
+	}
+
+	for _, f := range t.Recvs().Fields().Slice() {
+		funcarg2(f, ir.PPARAM)
+	}
+	for _, f := range t.Params().Fields().Slice() {
+		funcarg2(f, ir.PPARAM)
+	}
+	for _, f := range t.Results().Fields().Slice() {
+		funcarg2(f, ir.PPARAMOUT)
+	}
+}
+
+func initname(s string) bool {
+	return s == "init"
+}
+
+func tointerface(nmethods []*ir.Field) *types.Type {
+	if len(nmethods) == 0 {
+		return types.Types[types.TINTER]
+	}
+
+	lno := base.Pos
+
+	methods := make([]*types.Field, len(nmethods))
+	for i, n := range nmethods {
+		base.Pos = n.Pos
+		if n.Ntype != nil {
+			n.Type = typecheckNtype(n.Ntype).Type()
+			n.Ntype = nil
+		}
+		methods[i] = types.NewField(n.Pos, n.Sym, n.Type)
+	}
+
+	base.Pos = lno
+	return types.NewInterface(types.LocalPkg, methods)
+}
+
+var vargen int
+
+func Temp(t *types.Type) *ir.Name {
+	return TempAt(base.Pos, ir.CurFunc, t)
+}
+
+// make a new Node off the books
+func TempAt(pos src.XPos, curfn *ir.Func, t *types.Type) *ir.Name {
+	if curfn == nil {
+		base.Fatalf("no curfn for tempAt")
+	}
+	if curfn.Op() == ir.OCLOSURE {
+		ir.Dump("tempAt", curfn)
+		base.Fatalf("adding tempAt to wrong closure function")
+	}
+	if t == nil {
+		base.Fatalf("tempAt called with nil type")
+	}
+
+	s := &types.Sym{
+		Name: autotmpname(len(curfn.Dcl)),
+		Pkg:  types.LocalPkg,
+	}
+	n := ir.NewNameAt(pos, s)
+	s.Def = n
+	n.SetType(t)
+	n.Class_ = ir.PAUTO
+	n.SetEsc(ir.EscNever)
+	n.Curfn = curfn
+	n.SetUsed(true)
+	n.SetAutoTemp(true)
+	curfn.Dcl = append(curfn.Dcl, n)
+
+	types.CalcSize(t)
+
+	return n
+}
+
+// autotmpname returns the name for an autotmp variable numbered n.
+func autotmpname(n int) string {
+	// Give each tmp a different name so that they can be registerized.
+	// Add a preceding . to avoid clashing with legal names.
+	const prefix = ".autotmp_"
+	// Start with a buffer big enough to hold a large n.
+	b := []byte(prefix + "      ")[:len(prefix)]
+	b = strconv.AppendInt(b, int64(n), 10)
+	return types.InternString(b)
+}
+
+// f is method type, with receiver.
+// return function type, receiver as first argument (or not).
+func NewMethodType(f *types.Type, receiver *types.Type) *types.Type {
+	inLen := f.Params().Fields().Len()
+	if receiver != nil {
+		inLen++
+	}
+	in := make([]*ir.Field, 0, inLen)
+
+	if receiver != nil {
+		d := ir.NewField(base.Pos, nil, nil, receiver)
+		in = append(in, d)
+	}
+
+	for _, t := range f.Params().Fields().Slice() {
+		d := ir.NewField(base.Pos, nil, nil, t.Type)
+		d.IsDDD = t.IsDDD()
+		in = append(in, d)
+	}
+
+	outLen := f.Results().Fields().Len()
+	out := make([]*ir.Field, 0, outLen)
+	for _, t := range f.Results().Fields().Slice() {
+		d := ir.NewField(base.Pos, nil, nil, t.Type)
+		out = append(out, d)
+	}
+
+	return NewFuncType(nil, in, out)
+}
diff --git a/src/cmd/compile/internal/typecheck/export.go b/src/cmd/compile/internal/typecheck/export.go
new file mode 100644
index 0000000000..381a28e3ed
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/export.go
@@ -0,0 +1,79 @@
+// Copyright 2009 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 typecheck
+
+import (
+	"go/constant"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
+	"cmd/internal/src"
+)
+
+// importalias declares symbol s as an imported type alias with type t.
+// ipkg is the package being imported
+func importalias(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) *ir.Name {
+	return importobj(ipkg, pos, s, ir.OTYPE, ir.PEXTERN, t)
+}
+
+// importconst declares symbol s as an imported constant with type t and value val.
+// ipkg is the package being imported
+func importconst(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type, val constant.Value) *ir.Name {
+	n := importobj(ipkg, pos, s, ir.OLITERAL, ir.PEXTERN, t)
+	n.SetVal(val)
+	return n
+}
+
+// importfunc declares symbol s as an imported function with type t.
+// ipkg is the package being imported
+func importfunc(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) *ir.Name {
+	n := importobj(ipkg, pos, s, ir.ONAME, ir.PFUNC, t)
+
+	fn := ir.NewFunc(pos)
+	fn.SetType(t)
+	n.SetFunc(fn)
+	fn.Nname = n
+
+	return n
+}
+
+// importobj declares symbol s as an imported object representable by op.
+// ipkg is the package being imported
+func importobj(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op ir.Op, ctxt ir.Class, t *types.Type) *ir.Name {
+	n := importsym(ipkg, pos, s, op, ctxt)
+	n.SetType(t)
+	if ctxt == ir.PFUNC {
+		n.Sym().SetFunc(true)
+	}
+	return n
+}
+
+func importsym(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op ir.Op, ctxt ir.Class) *ir.Name {
+	if n := s.PkgDef(); n != nil {
+		base.Fatalf("importsym of symbol that already exists: %v", n)
+	}
+
+	n := ir.NewDeclNameAt(pos, op, s)
+	n.Class_ = ctxt // TODO(mdempsky): Move this into NewDeclNameAt too?
+	s.SetPkgDef(n)
+	s.Importdef = ipkg
+	return n
+}
+
+// importtype returns the named type declared by symbol s.
+// If no such type has been declared yet, a forward declaration is returned.
+// ipkg is the package being imported
+func importtype(ipkg *types.Pkg, pos src.XPos, s *types.Sym) *ir.Name {
+	n := importsym(ipkg, pos, s, ir.OTYPE, ir.PEXTERN)
+	n.SetType(types.NewNamed(n))
+	return n
+}
+
+// importvar declares symbol s as an imported variable with type t.
+// ipkg is the package being imported
+func importvar(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) *ir.Name {
+	return importobj(ipkg, pos, s, ir.ONAME, ir.PEXTERN, t)
+}
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
new file mode 100644
index 0000000000..4675de6cad
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -0,0 +1,398 @@
+// Copyright 2009 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 typecheck
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
+
+	"fmt"
+)
+
+// package all the arguments that match a ... T parameter into a []T.
+func MakeDotArgs(typ *types.Type, args []ir.Node) ir.Node {
+	var n ir.Node
+	if len(args) == 0 {
+		n = NodNil()
+		n.SetType(typ)
+	} else {
+		lit := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ).(ir.Ntype), nil)
+		lit.List.Append(args...)
+		lit.SetImplicit(true)
+		n = lit
+	}
+
+	n = Expr(n)
+	if n.Type() == nil {
+		base.Fatalf("mkdotargslice: typecheck failed")
+	}
+	return n
+}
+
+// FixVariadicCall rewrites calls to variadic functions to use an
+// explicit ... argument if one is not already present.
+func FixVariadicCall(call *ir.CallExpr) {
+	fntype := call.X.Type()
+	if !fntype.IsVariadic() || call.IsDDD {
+		return
+	}
+
+	vi := fntype.NumParams() - 1
+	vt := fntype.Params().Field(vi).Type
+
+	args := call.Args
+	extra := args[vi:]
+	slice := MakeDotArgs(vt, extra)
+	for i := range extra {
+		extra[i] = nil // allow GC
+	}
+
+	call.Args.Set(append(args[:vi], slice))
+	call.IsDDD = true
+}
+
+// ClosureType returns the struct type used to hold all the information
+// needed in the closure for clo (clo must be a OCLOSURE node).
+// The address of a variable of the returned type can be cast to a func.
+func ClosureType(clo *ir.ClosureExpr) *types.Type {
+	// Create closure in the form of a composite literal.
+	// supposing the closure captures an int i and a string s
+	// and has one float64 argument and no results,
+	// the generated code looks like:
+	//
+	//	clos = &struct{.F uintptr; i *int; s *string}{func.1, &i, &s}
+	//
+	// The use of the struct provides type information to the garbage
+	// collector so that it can walk the closure. We could use (in this case)
+	// [3]unsafe.Pointer instead, but that would leave the gc in the dark.
+	// The information appears in the binary in the form of type descriptors;
+	// the struct is unnamed so that closures in multiple packages with the
+	// same struct type can share the descriptor.
+	fields := []*ir.Field{
+		ir.NewField(base.Pos, Lookup(".F"), nil, types.Types[types.TUINTPTR]),
+	}
+	for _, v := range clo.Func.ClosureVars {
+		typ := v.Type()
+		if !v.Byval() {
+			typ = types.NewPtr(typ)
+		}
+		fields = append(fields, ir.NewField(base.Pos, v.Sym(), nil, typ))
+	}
+	typ := NewStructType(fields)
+	typ.SetNoalg(true)
+	return typ
+}
+
+// PartialCallType returns the struct type used to hold all the information
+// needed in the closure for n (n must be a OCALLPART node).
+// The address of a variable of the returned type can be cast to a func.
+func PartialCallType(n *ir.CallPartExpr) *types.Type {
+	t := NewStructType([]*ir.Field{
+		ir.NewField(base.Pos, Lookup("F"), nil, types.Types[types.TUINTPTR]),
+		ir.NewField(base.Pos, Lookup("R"), nil, n.X.Type()),
+	})
+	t.SetNoalg(true)
+	return t
+}
+
+// CaptureVars is called in a separate phase after all typechecking is done.
+// It decides whether each variable captured by a closure should be captured
+// by value or by reference.
+// We use value capturing for values <= 128 bytes that are never reassigned
+// after capturing (effectively constant).
+func CaptureVars(fn *ir.Func) {
+	lno := base.Pos
+	base.Pos = fn.Pos()
+	cvars := fn.ClosureVars
+	out := cvars[:0]
+	for _, v := range cvars {
+		if v.Type() == nil {
+			// If v.Type is nil, it means v looked like it
+			// was going to be used in the closure, but
+			// isn't. This happens in struct literals like
+			// s{f: x} where we can't distinguish whether
+			// f is a field identifier or expression until
+			// resolving s.
+			continue
+		}
+		out = append(out, v)
+
+		// type check the & of closed variables outside the closure,
+		// so that the outer frame also grabs them and knows they escape.
+		types.CalcSize(v.Type())
+
+		var outer ir.Node
+		outer = v.Outer
+		outermost := v.Defn.(*ir.Name)
+
+		// out parameters will be assigned to implicitly upon return.
+		if outermost.Class_ != ir.PPARAMOUT && !outermost.Name().Addrtaken() && !outermost.Name().Assigned() && v.Type().Width <= 128 {
+			v.SetByval(true)
+		} else {
+			outermost.Name().SetAddrtaken(true)
+			outer = NodAddr(outer)
+		}
+
+		if base.Flag.LowerM > 1 {
+			var name *types.Sym
+			if v.Curfn != nil && v.Curfn.Nname != nil {
+				name = v.Curfn.Sym()
+			}
+			how := "ref"
+			if v.Byval() {
+				how = "value"
+			}
+			base.WarnfAt(v.Pos(), "%v capturing by %s: %v (addr=%v assign=%v width=%d)", name, how, v.Sym(), outermost.Name().Addrtaken(), outermost.Name().Assigned(), int32(v.Type().Width))
+		}
+
+		outer = Expr(outer)
+		fn.ClosureEnter.Append(outer)
+	}
+
+	fn.ClosureVars = out
+	base.Pos = lno
+}
+
+// typecheckclosure typechecks an OCLOSURE node. It also creates the named
+// function associated with the closure.
+// TODO: This creation of the named function should probably really be done in a
+// separate pass from type-checking.
+func typecheckclosure(clo *ir.ClosureExpr, top int) {
+	fn := clo.Func
+	// Set current associated iota value, so iota can be used inside
+	// function in ConstSpec, see issue #22344
+	if x := getIotaValue(); x >= 0 {
+		fn.Iota = x
+	}
+
+	fn.ClosureType = check(fn.ClosureType, ctxType)
+	clo.SetType(fn.ClosureType.Type())
+	fn.SetClosureCalled(top&ctxCallee != 0)
+
+	// Do not typecheck fn twice, otherwise, we will end up pushing
+	// fn to Target.Decls multiple times, causing initLSym called twice.
+	// See #30709
+	if fn.Typecheck() == 1 {
+		return
+	}
+
+	for _, ln := range fn.ClosureVars {
+		n := ln.Defn
+		if !n.Name().Captured() {
+			n.Name().SetCaptured(true)
+			if n.Name().Decldepth == 0 {
+				base.Fatalf("typecheckclosure: var %v does not have decldepth assigned", n)
+			}
+
+			// Ignore assignments to the variable in straightline code
+			// preceding the first capturing by a closure.
+			if n.Name().Decldepth == decldepth {
+				n.Name().SetAssigned(false)
+			}
+		}
+	}
+
+	fn.Nname.SetSym(closurename(ir.CurFunc))
+	ir.MarkFunc(fn.Nname)
+	Func(fn)
+
+	// Type check the body now, but only if we're inside a function.
+	// At top level (in a variable initialization: curfn==nil) we're not
+	// ready to type check code yet; we'll check it later, because the
+	// underlying closure function we create is added to Target.Decls.
+	if ir.CurFunc != nil && clo.Type() != nil {
+		oldfn := ir.CurFunc
+		ir.CurFunc = fn
+		olddd := decldepth
+		decldepth = 1
+		Stmts(fn.Body)
+		decldepth = olddd
+		ir.CurFunc = oldfn
+	}
+
+	Target.Decls = append(Target.Decls, fn)
+}
+
+// Lazy typechecking of imported bodies. For local functions, caninl will set ->typecheck
+// because they're a copy of an already checked body.
+func ImportedBody(fn *ir.Func) {
+	lno := ir.SetPos(fn.Nname)
+
+	ImportBody(fn)
+
+	// typecheckinl is only for imported functions;
+	// their bodies may refer to unsafe as long as the package
+	// was marked safe during import (which was checked then).
+	// the ->inl of a local function has been typechecked before caninl copied it.
+	pkg := fnpkg(fn.Nname)
+
+	if pkg == types.LocalPkg || pkg == nil {
+		return // typecheckinl on local function
+	}
+
+	if base.Flag.LowerM > 2 || base.Debug.Export != 0 {
+		fmt.Printf("typecheck import [%v] %L { %v }\n", fn.Sym(), fn, ir.Nodes(fn.Inl.Body))
+	}
+
+	savefn := ir.CurFunc
+	ir.CurFunc = fn
+	Stmts(fn.Inl.Body)
+	ir.CurFunc = savefn
+
+	// During expandInline (which imports fn.Func.Inl.Body),
+	// declarations are added to fn.Func.Dcl by funcHdr(). Move them
+	// to fn.Func.Inl.Dcl for consistency with how local functions
+	// behave. (Append because typecheckinl may be called multiple
+	// times.)
+	fn.Inl.Dcl = append(fn.Inl.Dcl, fn.Dcl...)
+	fn.Dcl = nil
+
+	base.Pos = lno
+}
+
+// Get the function's package. For ordinary functions it's on the ->sym, but for imported methods
+// the ->sym can be re-used in the local package, so peel it off the receiver's type.
+func fnpkg(fn *ir.Name) *types.Pkg {
+	if ir.IsMethod(fn) {
+		// method
+		rcvr := fn.Type().Recv().Type
+
+		if rcvr.IsPtr() {
+			rcvr = rcvr.Elem()
+		}
+		if rcvr.Sym() == nil {
+			base.Fatalf("receiver with no sym: [%v] %L  (%v)", fn.Sym(), fn, rcvr)
+		}
+		return rcvr.Sym().Pkg
+	}
+
+	// non-method
+	return fn.Sym().Pkg
+}
+
+// CaptureVarsComplete is set to true when the capturevars phase is done.
+var CaptureVarsComplete bool
+
+// closurename generates a new unique name for a closure within
+// outerfunc.
+func closurename(outerfunc *ir.Func) *types.Sym {
+	outer := "glob."
+	prefix := "func"
+	gen := &globClosgen
+
+	if outerfunc != nil {
+		if outerfunc.OClosure != nil {
+			prefix = ""
+		}
+
+		outer = ir.FuncName(outerfunc)
+
+		// There may be multiple functions named "_". In those
+		// cases, we can't use their individual Closgens as it
+		// would lead to name clashes.
+		if !ir.IsBlank(outerfunc.Nname) {
+			gen = &outerfunc.Closgen
+		}
+	}
+
+	*gen++
+	return Lookup(fmt.Sprintf("%s.%s%d", outer, prefix, *gen))
+}
+
+// globClosgen is like Func.Closgen, but for the global scope.
+var globClosgen int32
+
+// makepartialcall returns a DCLFUNC node representing the wrapper function (*-fm) needed
+// for partial calls.
+func makepartialcall(dot *ir.SelectorExpr, t0 *types.Type, meth *types.Sym) *ir.Func {
+	rcvrtype := dot.X.Type()
+	sym := ir.MethodSymSuffix(rcvrtype, meth, "-fm")
+
+	if sym.Uniq() {
+		return sym.Def.(*ir.Func)
+	}
+	sym.SetUniq(true)
+
+	savecurfn := ir.CurFunc
+	saveLineNo := base.Pos
+	ir.CurFunc = nil
+
+	// Set line number equal to the line number where the method is declared.
+	var m *types.Field
+	if lookdot0(meth, rcvrtype, &m, false) == 1 && m.Pos.IsKnown() {
+		base.Pos = m.Pos
+	}
+	// Note: !m.Pos.IsKnown() happens for method expressions where
+	// the method is implicitly declared. The Error method of the
+	// built-in error type is one such method.  We leave the line
+	// number at the use of the method expression in this
+	// case. See issue 29389.
+
+	tfn := ir.NewFuncType(base.Pos, nil,
+		NewFuncParams(t0.Params(), true),
+		NewFuncParams(t0.Results(), false))
+
+	fn := DeclFunc(sym, tfn)
+	fn.SetDupok(true)
+	fn.SetNeedctxt(true)
+
+	// Declare and initialize variable holding receiver.
+	cr := ir.NewClosureRead(rcvrtype, types.Rnd(int64(types.PtrSize), int64(rcvrtype.Align)))
+	ptr := NewName(Lookup(".this"))
+	Declare(ptr, ir.PAUTO)
+	ptr.SetUsed(true)
+	var body []ir.Node
+	if rcvrtype.IsPtr() || rcvrtype.IsInterface() {
+		ptr.SetType(rcvrtype)
+		body = append(body, ir.NewAssignStmt(base.Pos, ptr, cr))
+	} else {
+		ptr.SetType(types.NewPtr(rcvrtype))
+		body = append(body, ir.NewAssignStmt(base.Pos, ptr, NodAddr(cr)))
+	}
+
+	call := ir.NewCallExpr(base.Pos, ir.OCALL, ir.NewSelectorExpr(base.Pos, ir.OXDOT, ptr, meth), nil)
+	call.Args.Set(ir.ParamNames(tfn.Type()))
+	call.IsDDD = tfn.Type().IsVariadic()
+	if t0.NumResults() != 0 {
+		ret := ir.NewReturnStmt(base.Pos, nil)
+		ret.Results = []ir.Node{call}
+		body = append(body, ret)
+	} else {
+		body = append(body, call)
+	}
+
+	fn.Body.Set(body)
+	FinishFuncBody()
+
+	Func(fn)
+	// Need to typecheck the body of the just-generated wrapper.
+	// typecheckslice() requires that Curfn is set when processing an ORETURN.
+	ir.CurFunc = fn
+	Stmts(fn.Body)
+	sym.Def = fn
+	Target.Decls = append(Target.Decls, fn)
+	ir.CurFunc = savecurfn
+	base.Pos = saveLineNo
+
+	return fn
+}
+
+func typecheckpartialcall(n ir.Node, sym *types.Sym) *ir.CallPartExpr {
+	switch n.Op() {
+	case ir.ODOTINTER, ir.ODOTMETH:
+		break
+
+	default:
+		base.Fatalf("invalid typecheckpartialcall")
+	}
+	dot := n.(*ir.SelectorExpr)
+
+	// Create top-level function.
+	fn := makepartialcall(dot, dot.Type(), sym)
+	fn.SetWrapper(true)
+
+	return ir.NewCallPartExpr(dot.Pos(), dot.X, dot.Selection, fn)
+}
diff --git a/src/cmd/compile/internal/gc/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
similarity index 99%
rename from src/cmd/compile/internal/gc/iexport.go
rename to src/cmd/compile/internal/typecheck/iexport.go
index fd64b69077..4ddee01b5a 100644
--- a/src/cmd/compile/internal/gc/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -199,16 +199,11 @@
 // they're expected to change much more rapidly, so they're omitted
 // here. See exportWriter's varExt/funcExt/etc methods for details.
 
-package gc
+package typecheck
 
 import (
 	"bufio"
 	"bytes"
-	"cmd/compile/internal/base"
-	"cmd/compile/internal/ir"
-	"cmd/compile/internal/types"
-	"cmd/internal/goobj"
-	"cmd/internal/src"
 	"crypto/md5"
 	"encoding/binary"
 	"fmt"
@@ -217,6 +212,12 @@ import (
 	"math/big"
 	"sort"
 	"strings"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
+	"cmd/internal/goobj"
+	"cmd/internal/src"
 )
 
 // Current indexed export format version. Increase with each format change.
@@ -245,7 +246,7 @@ const (
 	interfaceType
 )
 
-func iexport(out *bufio.Writer) {
+func WriteExports(out *bufio.Writer) {
 	p := iexporter{
 		allPkgs:     map[*types.Pkg]bool{},
 		stringIndex: map[string]uint64{},
@@ -455,7 +456,7 @@ func (p *iexporter) doDecl(n *ir.Name) {
 	case ir.OLITERAL:
 		// Constant.
 		// TODO(mdempsky): Do we still need this typecheck? If so, why?
-		n = typecheck(n, ctxExpr).(*ir.Name)
+		n = Expr(n).(*ir.Name)
 		w.tag('C')
 		w.pos(n.Pos())
 		w.value(n.Type(), n.Val())
diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
similarity index 97%
rename from src/cmd/compile/internal/gc/iimport.go
rename to src/cmd/compile/internal/typecheck/iimport.go
index e9dc2a3248..ab43d4f71b 100644
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -5,16 +5,9 @@
 // Indexed package import.
 // See iexport.go for the export data format.
 
-package gc
+package typecheck
 
 import (
-	"cmd/compile/internal/base"
-	"cmd/compile/internal/ir"
-	"cmd/compile/internal/types"
-	"cmd/internal/bio"
-	"cmd/internal/goobj"
-	"cmd/internal/obj"
-	"cmd/internal/src"
 	"encoding/binary"
 	"fmt"
 	"go/constant"
@@ -22,6 +15,14 @@ import (
 	"math/big"
 	"os"
 	"strings"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
+	"cmd/internal/bio"
+	"cmd/internal/goobj"
+	"cmd/internal/obj"
+	"cmd/internal/src"
 )
 
 // An iimporterAndOffset identifies an importer and an offset within
@@ -32,9 +33,9 @@ type iimporterAndOffset struct {
 }
 
 var (
-	// declImporter maps from imported identifiers to an importer
+	// DeclImporter maps from imported identifiers to an importer
 	// and offset where that identifier's declaration can be read.
-	declImporter = map[*types.Sym]iimporterAndOffset{}
+	DeclImporter = map[*types.Sym]iimporterAndOffset{}
 
 	// inlineImporter is like declImporter, but for inline bodies
 	// for function and method symbols.
@@ -51,7 +52,7 @@ func expandDecl(n ir.Node) ir.Node {
 		return n.(*ir.Name)
 	}
 
-	r := importReaderFor(id.Sym(), declImporter)
+	r := importReaderFor(id.Sym(), DeclImporter)
 	if r == nil {
 		// Can happen if user tries to reference an undeclared name.
 		return n
@@ -60,7 +61,7 @@ func expandDecl(n ir.Node) ir.Node {
 	return r.doDecl(n.Sym())
 }
 
-func expandInline(fn *ir.Func) {
+func ImportBody(fn *ir.Func) {
 	if fn.Inl.Body != nil {
 		return
 	}
@@ -105,7 +106,7 @@ func (r *intReader) uint64() uint64 {
 	return i
 }
 
-func iimport(pkg *types.Pkg, in *bio.Reader) (fingerprint goobj.FingerprintType) {
+func ReadImports(pkg *types.Pkg, in *bio.Reader) (fingerprint goobj.FingerprintType) {
 	ird := &intReader{in, pkg}
 
 	version := ird.uint64()
@@ -170,8 +171,8 @@ func iimport(pkg *types.Pkg, in *bio.Reader) (fingerprint goobj.FingerprintType)
 			s := pkg.Lookup(p.stringAt(ird.uint64()))
 			off := ird.uint64()
 
-			if _, ok := declImporter[s]; !ok {
-				declImporter[s] = iimporterAndOffset{p, off}
+			if _, ok := DeclImporter[s]; !ok {
+				DeclImporter[s] = iimporterAndOffset{p, off}
 			}
 		}
 	}
@@ -705,9 +706,9 @@ func (r *importReader) doInline(fn *ir.Func) {
 		base.Fatalf("%v already has inline body", fn)
 	}
 
-	funchdr(fn)
+	StartFuncBody(fn)
 	body := r.stmtList()
-	funcbody()
+	FinishFuncBody()
 	if body == nil {
 		//
 		// Make sure empty body is not interpreted as
@@ -778,7 +779,7 @@ func (r *importReader) caseList(sw ir.Node) []ir.Node {
 			// names after import. That's okay: swt.go only needs
 			// Sym for diagnostics anyway.
 			caseVar := ir.NewNameAt(cas.Pos(), r.ident())
-			declare(caseVar, dclcontext)
+			Declare(caseVar, DeclContext)
 			cas.Vars = []ir.Node{caseVar}
 			caseVar.Defn = sw.(*ir.SwitchStmt).Tag
 		}
@@ -820,7 +821,7 @@ func (r *importReader) node() ir.Node {
 		pos := r.pos()
 		typ := r.typ()
 
-		n := npos(pos, nodnil())
+		n := npos(pos, NodNil())
 		n.SetType(typ)
 		return n
 
@@ -959,7 +960,7 @@ func (r *importReader) node() ir.Node {
 		return ir.NewUnaryExpr(r.pos(), op, r.expr())
 
 	case ir.OADDR:
-		return nodAddrAt(r.pos(), r.expr())
+		return NodAddrAt(r.pos(), r.expr())
 
 	case ir.ODEREF:
 		return ir.NewStarExpr(r.pos(), r.expr())
@@ -991,7 +992,7 @@ func (r *importReader) node() ir.Node {
 		lhs := ir.NewDeclNameAt(pos, ir.ONAME, r.ident())
 		lhs.SetType(r.typ())
 
-		declare(lhs, ir.PAUTO)
+		Declare(lhs, ir.PAUTO)
 
 		var stmts ir.Nodes
 		stmts.Append(ir.NewDecl(base.Pos, ir.ODCL, lhs))
@@ -1089,12 +1090,12 @@ func (r *importReader) node() ir.Node {
 		var sym *types.Sym
 		pos := r.pos()
 		if label := r.string(); label != "" {
-			sym = lookup(label)
+			sym = Lookup(label)
 		}
 		return ir.NewBranchStmt(pos, op, sym)
 
 	case ir.OLABEL:
-		return ir.NewLabelStmt(r.pos(), lookup(r.string()))
+		return ir.NewLabelStmt(r.pos(), Lookup(r.string()))
 
 	case ir.OEND:
 		return nil
diff --git a/src/cmd/compile/internal/gc/mapfile_mmap.go b/src/cmd/compile/internal/typecheck/mapfile_mmap.go
similarity index 98%
rename from src/cmd/compile/internal/gc/mapfile_mmap.go
rename to src/cmd/compile/internal/typecheck/mapfile_mmap.go
index 9483688d68..2f3aa16dec 100644
--- a/src/cmd/compile/internal/gc/mapfile_mmap.go
+++ b/src/cmd/compile/internal/typecheck/mapfile_mmap.go
@@ -4,7 +4,7 @@
 
 // +build darwin dragonfly freebsd linux netbsd openbsd
 
-package gc
+package typecheck
 
 import (
 	"os"
diff --git a/src/cmd/compile/internal/gc/mapfile_read.go b/src/cmd/compile/internal/typecheck/mapfile_read.go
similarity index 96%
rename from src/cmd/compile/internal/gc/mapfile_read.go
rename to src/cmd/compile/internal/typecheck/mapfile_read.go
index c6f68ed5df..4059f261d4 100644
--- a/src/cmd/compile/internal/gc/mapfile_read.go
+++ b/src/cmd/compile/internal/typecheck/mapfile_read.go
@@ -4,7 +4,7 @@
 
 // +build !darwin,!dragonfly,!freebsd,!linux,!netbsd,!openbsd
 
-package gc
+package typecheck
 
 import (
 	"io"
diff --git a/src/cmd/compile/internal/gc/mkbuiltin.go b/src/cmd/compile/internal/typecheck/mkbuiltin.go
similarity index 99%
rename from src/cmd/compile/internal/gc/mkbuiltin.go
rename to src/cmd/compile/internal/typecheck/mkbuiltin.go
index 38aa601645..2a208d960f 100644
--- a/src/cmd/compile/internal/gc/mkbuiltin.go
+++ b/src/cmd/compile/internal/typecheck/mkbuiltin.go
@@ -33,7 +33,7 @@ func main() {
 	var b bytes.Buffer
 	fmt.Fprintln(&b, "// Code generated by mkbuiltin.go. DO NOT EDIT.")
 	fmt.Fprintln(&b)
-	fmt.Fprintln(&b, "package gc")
+	fmt.Fprintln(&b, "package typecheck")
 	fmt.Fprintln(&b)
 	fmt.Fprintln(&b, `import (`)
 	fmt.Fprintln(&b, `      "cmd/compile/internal/ir"`)
diff --git a/src/cmd/compile/internal/typecheck/stmt.go b/src/cmd/compile/internal/typecheck/stmt.go
new file mode 100644
index 0000000000..889ee06d6e
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/stmt.go
@@ -0,0 +1,435 @@
+// Copyright 2009 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 typecheck
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
+	"cmd/internal/src"
+)
+
+// range
+func typecheckrange(n *ir.RangeStmt) {
+	// Typechecking order is important here:
+	// 0. first typecheck range expression (slice/map/chan),
+	//	it is evaluated only once and so logically it is not part of the loop.
+	// 1. typecheck produced values,
+	//	this part can declare new vars and so it must be typechecked before body,
+	//	because body can contain a closure that captures the vars.
+	// 2. decldepth++ to denote loop body.
+	// 3. typecheck body.
+	// 4. decldepth--.
+	typecheckrangeExpr(n)
+
+	// second half of dance, the first half being typecheckrangeExpr
+	n.SetTypecheck(1)
+	ls := n.Vars
+	for i1, n1 := range ls {
+		if n1.Typecheck() == 0 {
+			ls[i1] = AssignExpr(ls[i1])
+		}
+	}
+
+	decldepth++
+	Stmts(n.Body)
+	decldepth--
+}
+
+func typecheckrangeExpr(n *ir.RangeStmt) {
+	n.X = Expr(n.X)
+
+	t := n.X.Type()
+	if t == nil {
+		return
+	}
+	// delicate little dance.  see typecheckas2
+	ls := n.Vars
+	for i1, n1 := range ls {
+		if !ir.DeclaredBy(n1, n) {
+			ls[i1] = AssignExpr(ls[i1])
+		}
+	}
+
+	if t.IsPtr() && t.Elem().IsArray() {
+		t = t.Elem()
+	}
+	n.SetType(t)
+
+	var t1, t2 *types.Type
+	toomany := false
+	switch t.Kind() {
+	default:
+		base.ErrorfAt(n.Pos(), "cannot range over %L", n.X)
+		return
+
+	case types.TARRAY, types.TSLICE:
+		t1 = types.Types[types.TINT]
+		t2 = t.Elem()
+
+	case types.TMAP:
+		t1 = t.Key()
+		t2 = t.Elem()
+
+	case types.TCHAN:
+		if !t.ChanDir().CanRecv() {
+			base.ErrorfAt(n.Pos(), "invalid operation: range %v (receive from send-only type %v)", n.X, n.X.Type())
+			return
+		}
+
+		t1 = t.Elem()
+		t2 = nil
+		if len(n.Vars) == 2 {
+			toomany = true
+		}
+
+	case types.TSTRING:
+		t1 = types.Types[types.TINT]
+		t2 = types.RuneType
+	}
+
+	if len(n.Vars) > 2 || toomany {
+		base.ErrorfAt(n.Pos(), "too many variables in range")
+	}
+
+	var v1, v2 ir.Node
+	if len(n.Vars) != 0 {
+		v1 = n.Vars[0]
+	}
+	if len(n.Vars) > 1 {
+		v2 = n.Vars[1]
+	}
+
+	// this is not only an optimization but also a requirement in the spec.
+	// "if the second iteration variable is the blank identifier, the range
+	// clause is equivalent to the same clause with only the first variable
+	// present."
+	if ir.IsBlank(v2) {
+		if v1 != nil {
+			n.Vars = []ir.Node{v1}
+		}
+		v2 = nil
+	}
+
+	if v1 != nil {
+		if ir.DeclaredBy(v1, n) {
+			v1.SetType(t1)
+		} else if v1.Type() != nil {
+			if op, why := assignop(t1, v1.Type()); op == ir.OXXX {
+				base.ErrorfAt(n.Pos(), "cannot assign type %v to %L in range%s", t1, v1, why)
+			}
+		}
+		checkassign(n, v1)
+	}
+
+	if v2 != nil {
+		if ir.DeclaredBy(v2, n) {
+			v2.SetType(t2)
+		} else if v2.Type() != nil {
+			if op, why := assignop(t2, v2.Type()); op == ir.OXXX {
+				base.ErrorfAt(n.Pos(), "cannot assign type %v to %L in range%s", t2, v2, why)
+			}
+		}
+		checkassign(n, v2)
+	}
+}
+
+// select
+func typecheckselect(sel *ir.SelectStmt) {
+	var def ir.Node
+	lno := ir.SetPos(sel)
+	Stmts(sel.Init())
+	for _, ncase := range sel.Cases {
+		ncase := ncase.(*ir.CaseStmt)
+
+		if len(ncase.List) == 0 {
+			// default
+			if def != nil {
+				base.ErrorfAt(ncase.Pos(), "multiple defaults in select (first at %v)", ir.Line(def))
+			} else {
+				def = ncase
+			}
+		} else if len(ncase.List) > 1 {
+			base.ErrorfAt(ncase.Pos(), "select cases cannot be lists")
+		} else {
+			ncase.List[0] = Stmt(ncase.List[0])
+			n := ncase.List[0]
+			ncase.Comm = n
+			ncase.List.Set(nil)
+			oselrecv2 := func(dst, recv ir.Node, colas bool) {
+				n := ir.NewAssignListStmt(n.Pos(), ir.OSELRECV2, nil, nil)
+				n.Lhs = []ir.Node{dst, ir.BlankNode}
+				n.Rhs = []ir.Node{recv}
+				n.Def = colas
+				n.SetTypecheck(1)
+				ncase.Comm = n
+			}
+			switch n.Op() {
+			default:
+				pos := n.Pos()
+				if n.Op() == ir.ONAME {
+					// We don't have the right position for ONAME nodes (see #15459 and
+					// others). Using ncase.Pos for now as it will provide the correct
+					// line number (assuming the expression follows the "case" keyword
+					// on the same line). This matches the approach before 1.10.
+					pos = ncase.Pos()
+				}
+				base.ErrorfAt(pos, "select case must be receive, send or assign recv")
+
+			case ir.OAS:
+				// convert x = <-c into x, _ = <-c
+				// remove implicit conversions; the eventual assignment
+				// will reintroduce them.
+				n := n.(*ir.AssignStmt)
+				if r := n.Y; r.Op() == ir.OCONVNOP || r.Op() == ir.OCONVIFACE {
+					r := r.(*ir.ConvExpr)
+					if r.Implicit() {
+						n.Y = r.X
+					}
+				}
+				if n.Y.Op() != ir.ORECV {
+					base.ErrorfAt(n.Pos(), "select assignment must have receive on right hand side")
+					break
+				}
+				oselrecv2(n.X, n.Y, n.Def)
+
+			case ir.OAS2RECV:
+				n := n.(*ir.AssignListStmt)
+				if n.Rhs[0].Op() != ir.ORECV {
+					base.ErrorfAt(n.Pos(), "select assignment must have receive on right hand side")
+					break
+				}
+				n.SetOp(ir.OSELRECV2)
+
+			case ir.ORECV:
+				// convert <-c into _, _ = <-c
+				n := n.(*ir.UnaryExpr)
+				oselrecv2(ir.BlankNode, n, false)
+
+			case ir.OSEND:
+				break
+			}
+		}
+
+		Stmts(ncase.Body)
+	}
+
+	base.Pos = lno
+}
+
+type typeSet struct {
+	m map[string][]typeSetEntry
+}
+
+func (s *typeSet) add(pos src.XPos, typ *types.Type) {
+	if s.m == nil {
+		s.m = make(map[string][]typeSetEntry)
+	}
+
+	// LongString does not uniquely identify types, so we need to
+	// disambiguate collisions with types.Identical.
+	// TODO(mdempsky): Add a method that *is* unique.
+	ls := typ.LongString()
+	prevs := s.m[ls]
+	for _, prev := range prevs {
+		if types.Identical(typ, prev.typ) {
+			base.ErrorfAt(pos, "duplicate case %v in type switch\n\tprevious case at %s", typ, base.FmtPos(prev.pos))
+			return
+		}
+	}
+	s.m[ls] = append(prevs, typeSetEntry{pos, typ})
+}
+
+type typeSetEntry struct {
+	pos src.XPos
+	typ *types.Type
+}
+
+func typecheckExprSwitch(n *ir.SwitchStmt) {
+	t := types.Types[types.TBOOL]
+	if n.Tag != nil {
+		n.Tag = Expr(n.Tag)
+		n.Tag = DefaultLit(n.Tag, nil)
+		t = n.Tag.Type()
+	}
+
+	var nilonly string
+	if t != nil {
+		switch {
+		case t.IsMap():
+			nilonly = "map"
+		case t.Kind() == types.TFUNC:
+			nilonly = "func"
+		case t.IsSlice():
+			nilonly = "slice"
+
+		case !types.IsComparable(t):
+			if t.IsStruct() {
+				base.ErrorfAt(n.Pos(), "cannot switch on %L (struct containing %v cannot be compared)", n.Tag, types.IncomparableField(t).Type)
+			} else {
+				base.ErrorfAt(n.Pos(), "cannot switch on %L", n.Tag)
+			}
+			t = nil
+		}
+	}
+
+	var defCase ir.Node
+	var cs constSet
+	for _, ncase := range n.Cases {
+		ncase := ncase.(*ir.CaseStmt)
+		ls := ncase.List
+		if len(ls) == 0 { // default:
+			if defCase != nil {
+				base.ErrorfAt(ncase.Pos(), "multiple defaults in switch (first at %v)", ir.Line(defCase))
+			} else {
+				defCase = ncase
+			}
+		}
+
+		for i := range ls {
+			ir.SetPos(ncase)
+			ls[i] = Expr(ls[i])
+			ls[i] = DefaultLit(ls[i], t)
+			n1 := ls[i]
+			if t == nil || n1.Type() == nil {
+				continue
+			}
+
+			if nilonly != "" && !ir.IsNil(n1) {
+				base.ErrorfAt(ncase.Pos(), "invalid case %v in switch (can only compare %s %v to nil)", n1, nilonly, n.Tag)
+			} else if t.IsInterface() && !n1.Type().IsInterface() && !types.IsComparable(n1.Type()) {
+				base.ErrorfAt(ncase.Pos(), "invalid case %L in switch (incomparable type)", n1)
+			} else {
+				op1, _ := assignop(n1.Type(), t)
+				op2, _ := assignop(t, n1.Type())
+				if op1 == ir.OXXX && op2 == ir.OXXX {
+					if n.Tag != nil {
+						base.ErrorfAt(ncase.Pos(), "invalid case %v in switch on %v (mismatched types %v and %v)", n1, n.Tag, n1.Type(), t)
+					} else {
+						base.ErrorfAt(ncase.Pos(), "invalid case %v in switch (mismatched types %v and bool)", n1, n1.Type())
+					}
+				}
+			}
+
+			// Don't check for duplicate bools. Although the spec allows it,
+			// (1) the compiler hasn't checked it in the past, so compatibility mandates it, and
+			// (2) it would disallow useful things like
+			//       case GOARCH == "arm" && GOARM == "5":
+			//       case GOARCH == "arm":
+			//     which would both evaluate to false for non-ARM compiles.
+			if !n1.Type().IsBoolean() {
+				cs.add(ncase.Pos(), n1, "case", "switch")
+			}
+		}
+
+		Stmts(ncase.Body)
+	}
+}
+
+func typecheckTypeSwitch(n *ir.SwitchStmt) {
+	guard := n.Tag.(*ir.TypeSwitchGuard)
+	guard.X = Expr(guard.X)
+	t := guard.X.Type()
+	if t != nil && !t.IsInterface() {
+		base.ErrorfAt(n.Pos(), "cannot type switch on non-interface value %L", guard.X)
+		t = nil
+	}
+
+	// We don't actually declare the type switch's guarded
+	// declaration itself. So if there are no cases, we won't
+	// notice that it went unused.
+	if v := guard.Tag; v != nil && !ir.IsBlank(v) && len(n.Cases) == 0 {
+		base.ErrorfAt(v.Pos(), "%v declared but not used", v.Sym())
+	}
+
+	var defCase, nilCase ir.Node
+	var ts typeSet
+	for _, ncase := range n.Cases {
+		ncase := ncase.(*ir.CaseStmt)
+		ls := ncase.List
+		if len(ls) == 0 { // default:
+			if defCase != nil {
+				base.ErrorfAt(ncase.Pos(), "multiple defaults in switch (first at %v)", ir.Line(defCase))
+			} else {
+				defCase = ncase
+			}
+		}
+
+		for i := range ls {
+			ls[i] = check(ls[i], ctxExpr|ctxType)
+			n1 := ls[i]
+			if t == nil || n1.Type() == nil {
+				continue
+			}
+
+			var missing, have *types.Field
+			var ptr int
+			if ir.IsNil(n1) { // case nil:
+				if nilCase != nil {
+					base.ErrorfAt(ncase.Pos(), "multiple nil cases in type switch (first at %v)", ir.Line(nilCase))
+				} else {
+					nilCase = ncase
+				}
+				continue
+			}
+			if n1.Op() != ir.OTYPE {
+				base.ErrorfAt(ncase.Pos(), "%L is not a type", n1)
+				continue
+			}
+			if !n1.Type().IsInterface() && !implements(n1.Type(), t, &missing, &have, &ptr) && !missing.Broke() {
+				if have != nil && !have.Broke() {
+					base.ErrorfAt(ncase.Pos(), "impossible type switch case: %L cannot have dynamic type %v"+
+						" (wrong type for %v method)\n\thave %v%S\n\twant %v%S", guard.X, n1.Type(), missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
+				} else if ptr != 0 {
+					base.ErrorfAt(ncase.Pos(), "impossible type switch case: %L cannot have dynamic type %v"+
+						" (%v method has pointer receiver)", guard.X, n1.Type(), missing.Sym)
+				} else {
+					base.ErrorfAt(ncase.Pos(), "impossible type switch case: %L cannot have dynamic type %v"+
+						" (missing %v method)", guard.X, n1.Type(), missing.Sym)
+				}
+				continue
+			}
+
+			ts.add(ncase.Pos(), n1.Type())
+		}
+
+		if len(ncase.Vars) != 0 {
+			// Assign the clause variable's type.
+			vt := t
+			if len(ls) == 1 {
+				if ls[0].Op() == ir.OTYPE {
+					vt = ls[0].Type()
+				} else if !ir.IsNil(ls[0]) {
+					// Invalid single-type case;
+					// mark variable as broken.
+					vt = nil
+				}
+			}
+
+			nvar := ncase.Vars[0]
+			nvar.SetType(vt)
+			if vt != nil {
+				nvar = AssignExpr(nvar)
+			} else {
+				// Clause variable is broken; prevent typechecking.
+				nvar.SetTypecheck(1)
+				nvar.SetWalkdef(1)
+			}
+			ncase.Vars[0] = nvar
+		}
+
+		Stmts(ncase.Body)
+	}
+}
+
+// typecheckswitch typechecks a switch statement.
+func typecheckswitch(n *ir.SwitchStmt) {
+	Stmts(n.Init())
+	if n.Tag != nil && n.Tag.Op() == ir.OTYPESW {
+		typecheckTypeSwitch(n)
+	} else {
+		typecheckExprSwitch(n)
+	}
+}
diff --git a/src/cmd/compile/internal/typecheck/subr.go b/src/cmd/compile/internal/typecheck/subr.go
new file mode 100644
index 0000000000..22ebf2a4b3
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/subr.go
@@ -0,0 +1,793 @@
+// Copyright 2009 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 typecheck
+
+import (
+	"fmt"
+	"sort"
+	"strconv"
+	"strings"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
+	"cmd/internal/src"
+)
+
+func AssignConv(n ir.Node, t *types.Type, context string) ir.Node {
+	return assignconvfn(n, t, func() string { return context })
+}
+
+// DotImportRefs maps idents introduced by importDot back to the
+// ir.PkgName they were dot-imported through.
+var DotImportRefs map[*ir.Ident]*ir.PkgName
+
+// LookupNum looks up the symbol starting with prefix and ending with
+// the decimal n. If prefix is too long, LookupNum panics.
+func LookupNum(prefix string, n int) *types.Sym {
+	var buf [20]byte // plenty long enough for all current users
+	copy(buf[:], prefix)
+	b := strconv.AppendInt(buf[:len(prefix)], int64(n), 10)
+	return types.LocalPkg.LookupBytes(b)
+}
+
+// Given funarg struct list, return list of fn args.
+func NewFuncParams(tl *types.Type, mustname bool) []*ir.Field {
+	var args []*ir.Field
+	gen := 0
+	for _, t := range tl.Fields().Slice() {
+		s := t.Sym
+		if mustname && (s == nil || s.Name == "_") {
+			// invent a name so that we can refer to it in the trampoline
+			s = LookupNum(".anon", gen)
+			gen++
+		}
+		a := ir.NewField(base.Pos, s, nil, t.Type)
+		a.Pos = t.Pos
+		a.IsDDD = t.IsDDD()
+		args = append(args, a)
+	}
+
+	return args
+}
+
+// newname returns a new ONAME Node associated with symbol s.
+func NewName(s *types.Sym) *ir.Name {
+	n := ir.NewNameAt(base.Pos, s)
+	n.Curfn = ir.CurFunc
+	return n
+}
+
+// NodAddr returns a node representing &n at base.Pos.
+func NodAddr(n ir.Node) *ir.AddrExpr {
+	return NodAddrAt(base.Pos, n)
+}
+
+// nodAddrPos returns a node representing &n at position pos.
+func NodAddrAt(pos src.XPos, n ir.Node) *ir.AddrExpr {
+	return ir.NewAddrExpr(pos, n)
+}
+
+func NodNil() ir.Node {
+	n := ir.NewNilExpr(base.Pos)
+	n.SetType(types.Types[types.TNIL])
+	return n
+}
+
+// in T.field
+// find missing fields that
+// will give shortest unique addressing.
+// modify the tree with missing type names.
+func AddImplicitDots(n *ir.SelectorExpr) *ir.SelectorExpr {
+	n.X = check(n.X, ctxType|ctxExpr)
+	if n.X.Diag() {
+		n.SetDiag(true)
+	}
+	t := n.X.Type()
+	if t == nil {
+		return n
+	}
+
+	if n.X.Op() == ir.OTYPE {
+		return n
+	}
+
+	s := n.Sel
+	if s == nil {
+		return n
+	}
+
+	switch path, ambig := dotpath(s, t, nil, false); {
+	case path != nil:
+		// rebuild elided dots
+		for c := len(path) - 1; c >= 0; c-- {
+			dot := ir.NewSelectorExpr(base.Pos, ir.ODOT, n.X, path[c].field.Sym)
+			dot.SetImplicit(true)
+			dot.SetType(path[c].field.Type)
+			n.X = dot
+		}
+	case ambig:
+		base.Errorf("ambiguous selector %v", n)
+		n.X = nil
+	}
+
+	return n
+}
+
+func CalcMethods(t *types.Type) {
+	if t == nil || t.AllMethods().Len() != 0 {
+		return
+	}
+
+	// mark top-level method symbols
+	// so that expand1 doesn't consider them.
+	for _, f := range t.Methods().Slice() {
+		f.Sym.SetUniq(true)
+	}
+
+	// generate all reachable methods
+	slist = slist[:0]
+	expand1(t, true)
+
+	// check each method to be uniquely reachable
+	var ms []*types.Field
+	for i, sl := range slist {
+		slist[i].field = nil
+		sl.field.Sym.SetUniq(false)
+
+		var f *types.Field
+		path, _ := dotpath(sl.field.Sym, t, &f, false)
+		if path == nil {
+			continue
+		}
+
+		// dotpath may have dug out arbitrary fields, we only want methods.
+		if !f.IsMethod() {
+			continue
+		}
+
+		// add it to the base type method list
+		f = f.Copy()
+		f.Embedded = 1 // needs a trampoline
+		for _, d := range path {
+			if d.field.Type.IsPtr() {
+				f.Embedded = 2
+				break
+			}
+		}
+		ms = append(ms, f)
+	}
+
+	for _, f := range t.Methods().Slice() {
+		f.Sym.SetUniq(false)
+	}
+
+	ms = append(ms, t.Methods().Slice()...)
+	sort.Sort(types.MethodsByName(ms))
+	t.AllMethods().Set(ms)
+}
+
+// adddot1 returns the number of fields or methods named s at depth d in Type t.
+// If exactly one exists, it will be returned in *save (if save is not nil),
+// and dotlist will contain the path of embedded fields traversed to find it,
+// in reverse order. If none exist, more will indicate whether t contains any
+// embedded fields at depth d, so callers can decide whether to retry at
+// a greater depth.
+func adddot1(s *types.Sym, t *types.Type, d int, save **types.Field, ignorecase bool) (c int, more bool) {
+	if t.Recur() {
+		return
+	}
+	t.SetRecur(true)
+	defer t.SetRecur(false)
+
+	var u *types.Type
+	d--
+	if d < 0 {
+		// We've reached our target depth. If t has any fields/methods
+		// named s, then we're done. Otherwise, we still need to check
+		// below for embedded fields.
+		c = lookdot0(s, t, save, ignorecase)
+		if c != 0 {
+			return c, false
+		}
+	}
+
+	u = t
+	if u.IsPtr() {
+		u = u.Elem()
+	}
+	if !u.IsStruct() && !u.IsInterface() {
+		return c, false
+	}
+
+	for _, f := range u.Fields().Slice() {
+		if f.Embedded == 0 || f.Sym == nil {
+			continue
+		}
+		if d < 0 {
+			// Found an embedded field at target depth.
+			return c, true
+		}
+		a, more1 := adddot1(s, f.Type, d, save, ignorecase)
+		if a != 0 && c == 0 {
+			dotlist[d].field = f
+		}
+		c += a
+		if more1 {
+			more = true
+		}
+	}
+
+	return c, more
+}
+
+// dotlist is used by adddot1 to record the path of embedded fields
+// used to access a target field or method.
+// Must be non-nil so that dotpath returns a non-nil slice even if d is zero.
+var dotlist = make([]dlist, 10)
+
+// Convert node n for assignment to type t.
+func assignconvfn(n ir.Node, t *types.Type, context func() string) ir.Node {
+	if n == nil || n.Type() == nil || n.Type().Broke() {
+		return n
+	}
+
+	if t.Kind() == types.TBLANK && n.Type().Kind() == types.TNIL {
+		base.Errorf("use of untyped nil")
+	}
+
+	n = convlit1(n, t, false, context)
+	if n.Type() == nil {
+		return n
+	}
+	if t.Kind() == types.TBLANK {
+		return n
+	}
+
+	// Convert ideal bool from comparison to plain bool
+	// if the next step is non-bool (like interface{}).
+	if n.Type() == types.UntypedBool && !t.IsBoolean() {
+		if n.Op() == ir.ONAME || n.Op() == ir.OLITERAL {
+			r := ir.NewConvExpr(base.Pos, ir.OCONVNOP, nil, n)
+			r.SetType(types.Types[types.TBOOL])
+			r.SetTypecheck(1)
+			r.SetImplicit(true)
+			n = r
+		}
+	}
+
+	if types.Identical(n.Type(), t) {
+		return n
+	}
+
+	op, why := assignop(n.Type(), t)
+	if op == ir.OXXX {
+		base.Errorf("cannot use %L as type %v in %s%s", n, t, context(), why)
+		op = ir.OCONV
+	}
+
+	r := ir.NewConvExpr(base.Pos, op, t, n)
+	r.SetTypecheck(1)
+	r.SetImplicit(true)
+	return r
+}
+
+// Is type src assignment compatible to type dst?
+// If so, return op code to use in conversion.
+// If not, return OXXX. In this case, the string return parameter may
+// hold a reason why. In all other cases, it'll be the empty string.
+func assignop(src, dst *types.Type) (ir.Op, string) {
+	if src == dst {
+		return ir.OCONVNOP, ""
+	}
+	if src == nil || dst == nil || src.Kind() == types.TFORW || dst.Kind() == types.TFORW || src.Underlying() == nil || dst.Underlying() == nil {
+		return ir.OXXX, ""
+	}
+
+	// 1. src type is identical to dst.
+	if types.Identical(src, dst) {
+		return ir.OCONVNOP, ""
+	}
+
+	// 2. src and dst have identical underlying types
+	// and either src or dst is not a named type or
+	// both are empty interface types.
+	// For assignable but different non-empty interface types,
+	// we want to recompute the itab. Recomputing the itab ensures
+	// that itabs are unique (thus an interface with a compile-time
+	// type I has an itab with interface type I).
+	if types.Identical(src.Underlying(), dst.Underlying()) {
+		if src.IsEmptyInterface() {
+			// Conversion between two empty interfaces
+			// requires no code.
+			return ir.OCONVNOP, ""
+		}
+		if (src.Sym() == nil || dst.Sym() == nil) && !src.IsInterface() {
+			// Conversion between two types, at least one unnamed,
+			// needs no conversion. The exception is nonempty interfaces
+			// which need to have their itab updated.
+			return ir.OCONVNOP, ""
+		}
+	}
+
+	// 3. dst is an interface type and src implements dst.
+	if dst.IsInterface() && src.Kind() != types.TNIL {
+		var missing, have *types.Field
+		var ptr int
+		if implements(src, dst, &missing, &have, &ptr) {
+			// Call itabname so that (src, dst)
+			// gets added to itabs early, which allows
+			// us to de-virtualize calls through this
+			// type/interface pair later. See peekitabs in reflect.go
+			if types.IsDirectIface(src) && !dst.IsEmptyInterface() {
+				NeedITab(src, dst)
+			}
+
+			return ir.OCONVIFACE, ""
+		}
+
+		// we'll have complained about this method anyway, suppress spurious messages.
+		if have != nil && have.Sym == missing.Sym && (have.Type.Broke() || missing.Type.Broke()) {
+			return ir.OCONVIFACE, ""
+		}
+
+		var why string
+		if isptrto(src, types.TINTER) {
+			why = fmt.Sprintf(":\n\t%v is pointer to interface, not interface", src)
+		} else if have != nil && have.Sym == missing.Sym && have.Nointerface() {
+			why = fmt.Sprintf(":\n\t%v does not implement %v (%v method is marked 'nointerface')", src, dst, missing.Sym)
+		} else if have != nil && have.Sym == missing.Sym {
+			why = fmt.Sprintf(":\n\t%v does not implement %v (wrong type for %v method)\n"+
+				"\t\thave %v%S\n\t\twant %v%S", src, dst, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
+		} else if ptr != 0 {
+			why = fmt.Sprintf(":\n\t%v does not implement %v (%v method has pointer receiver)", src, dst, missing.Sym)
+		} else if have != nil {
+			why = fmt.Sprintf(":\n\t%v does not implement %v (missing %v method)\n"+
+				"\t\thave %v%S\n\t\twant %v%S", src, dst, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
+		} else {
+			why = fmt.Sprintf(":\n\t%v does not implement %v (missing %v method)", src, dst, missing.Sym)
+		}
+
+		return ir.OXXX, why
+	}
+
+	if isptrto(dst, types.TINTER) {
+		why := fmt.Sprintf(":\n\t%v is pointer to interface, not interface", dst)
+		return ir.OXXX, why
+	}
+
+	if src.IsInterface() && dst.Kind() != types.TBLANK {
+		var missing, have *types.Field
+		var ptr int
+		var why string
+		if implements(dst, src, &missing, &have, &ptr) {
+			why = ": need type assertion"
+		}
+		return ir.OXXX, why
+	}
+
+	// 4. src is a bidirectional channel value, dst is a channel type,
+	// src and dst have identical element types, and
+	// either src or dst is not a named type.
+	if src.IsChan() && src.ChanDir() == types.Cboth && dst.IsChan() {
+		if types.Identical(src.Elem(), dst.Elem()) && (src.Sym() == nil || dst.Sym() == nil) {
+			return ir.OCONVNOP, ""
+		}
+	}
+
+	// 5. src is the predeclared identifier nil and dst is a nillable type.
+	if src.Kind() == types.TNIL {
+		switch dst.Kind() {
+		case types.TPTR,
+			types.TFUNC,
+			types.TMAP,
+			types.TCHAN,
+			types.TINTER,
+			types.TSLICE:
+			return ir.OCONVNOP, ""
+		}
+	}
+
+	// 6. rule about untyped constants - already converted by defaultlit.
+
+	// 7. Any typed value can be assigned to the blank identifier.
+	if dst.Kind() == types.TBLANK {
+		return ir.OCONVNOP, ""
+	}
+
+	return ir.OXXX, ""
+}
+
+// Can we convert a value of type src to a value of type dst?
+// If so, return op code to use in conversion (maybe OCONVNOP).
+// If not, return OXXX. In this case, the string return parameter may
+// hold a reason why. In all other cases, it'll be the empty string.
+// srcConstant indicates whether the value of type src is a constant.
+func convertop(srcConstant bool, src, dst *types.Type) (ir.Op, string) {
+	if src == dst {
+		return ir.OCONVNOP, ""
+	}
+	if src == nil || dst == nil {
+		return ir.OXXX, ""
+	}
+
+	// Conversions from regular to go:notinheap are not allowed
+	// (unless it's unsafe.Pointer). These are runtime-specific
+	// rules.
+	// (a) Disallow (*T) to (*U) where T is go:notinheap but U isn't.
+	if src.IsPtr() && dst.IsPtr() && dst.Elem().NotInHeap() && !src.Elem().NotInHeap() {
+		why := fmt.Sprintf(":\n\t%v is incomplete (or unallocatable), but %v is not", dst.Elem(), src.Elem())
+		return ir.OXXX, why
+	}
+	// (b) Disallow string to []T where T is go:notinheap.
+	if src.IsString() && dst.IsSlice() && dst.Elem().NotInHeap() && (dst.Elem().Kind() == types.ByteType.Kind() || dst.Elem().Kind() == types.RuneType.Kind()) {
+		why := fmt.Sprintf(":\n\t%v is incomplete (or unallocatable)", dst.Elem())
+		return ir.OXXX, why
+	}
+
+	// 1. src can be assigned to dst.
+	op, why := assignop(src, dst)
+	if op != ir.OXXX {
+		return op, why
+	}
+
+	// The rules for interfaces are no different in conversions
+	// than assignments. If interfaces are involved, stop now
+	// with the good message from assignop.
+	// Otherwise clear the error.
+	if src.IsInterface() || dst.IsInterface() {
+		return ir.OXXX, why
+	}
+
+	// 2. Ignoring struct tags, src and dst have identical underlying types.
+	if types.IdenticalIgnoreTags(src.Underlying(), dst.Underlying()) {
+		return ir.OCONVNOP, ""
+	}
+
+	// 3. src and dst are unnamed pointer types and, ignoring struct tags,
+	// their base types have identical underlying types.
+	if src.IsPtr() && dst.IsPtr() && src.Sym() == nil && dst.Sym() == nil {
+		if types.IdenticalIgnoreTags(src.Elem().Underlying(), dst.Elem().Underlying()) {
+			return ir.OCONVNOP, ""
+		}
+	}
+
+	// 4. src and dst are both integer or floating point types.
+	if (src.IsInteger() || src.IsFloat()) && (dst.IsInteger() || dst.IsFloat()) {
+		if types.SimType[src.Kind()] == types.SimType[dst.Kind()] {
+			return ir.OCONVNOP, ""
+		}
+		return ir.OCONV, ""
+	}
+
+	// 5. src and dst are both complex types.
+	if src.IsComplex() && dst.IsComplex() {
+		if types.SimType[src.Kind()] == types.SimType[dst.Kind()] {
+			return ir.OCONVNOP, ""
+		}
+		return ir.OCONV, ""
+	}
+
+	// Special case for constant conversions: any numeric
+	// conversion is potentially okay. We'll validate further
+	// within evconst. See #38117.
+	if srcConstant && (src.IsInteger() || src.IsFloat() || src.IsComplex()) && (dst.IsInteger() || dst.IsFloat() || dst.IsComplex()) {
+		return ir.OCONV, ""
+	}
+
+	// 6. src is an integer or has type []byte or []rune
+	// and dst is a string type.
+	if src.IsInteger() && dst.IsString() {
+		return ir.ORUNESTR, ""
+	}
+
+	if src.IsSlice() && dst.IsString() {
+		if src.Elem().Kind() == types.ByteType.Kind() {
+			return ir.OBYTES2STR, ""
+		}
+		if src.Elem().Kind() == types.RuneType.Kind() {
+			return ir.ORUNES2STR, ""
+		}
+	}
+
+	// 7. src is a string and dst is []byte or []rune.
+	// String to slice.
+	if src.IsString() && dst.IsSlice() {
+		if dst.Elem().Kind() == types.ByteType.Kind() {
+			return ir.OSTR2BYTES, ""
+		}
+		if dst.Elem().Kind() == types.RuneType.Kind() {
+			return ir.OSTR2RUNES, ""
+		}
+	}
+
+	// 8. src is a pointer or uintptr and dst is unsafe.Pointer.
+	if (src.IsPtr() || src.IsUintptr()) && dst.IsUnsafePtr() {
+		return ir.OCONVNOP, ""
+	}
+
+	// 9. src is unsafe.Pointer and dst is a pointer or uintptr.
+	if src.IsUnsafePtr() && (dst.IsPtr() || dst.IsUintptr()) {
+		return ir.OCONVNOP, ""
+	}
+
+	// src is map and dst is a pointer to corresponding hmap.
+	// This rule is needed for the implementation detail that
+	// go gc maps are implemented as a pointer to a hmap struct.
+	if src.Kind() == types.TMAP && dst.IsPtr() &&
+		src.MapType().Hmap == dst.Elem() {
+		return ir.OCONVNOP, ""
+	}
+
+	return ir.OXXX, ""
+}
+
+// Code to resolve elided DOTs in embedded types.
+
+// A dlist stores a pointer to a TFIELD Type embedded within
+// a TSTRUCT or TINTER Type.
+type dlist struct {
+	field *types.Field
+}
+
+// dotpath computes the unique shortest explicit selector path to fully qualify
+// a selection expression x.f, where x is of type t and f is the symbol s.
+// If no such path exists, dotpath returns nil.
+// If there are multiple shortest paths to the same depth, ambig is true.
+func dotpath(s *types.Sym, t *types.Type, save **types.Field, ignorecase bool) (path []dlist, ambig bool) {
+	// The embedding of types within structs imposes a tree structure onto
+	// types: structs parent the types they embed, and types parent their
+	// fields or methods. Our goal here is to find the shortest path to
+	// a field or method named s in the subtree rooted at t. To accomplish
+	// that, we iteratively perform depth-first searches of increasing depth
+	// until we either find the named field/method or exhaust the tree.
+	for d := 0; ; d++ {
+		if d > len(dotlist) {
+			dotlist = append(dotlist, dlist{})
+		}
+		if c, more := adddot1(s, t, d, save, ignorecase); c == 1 {
+			return dotlist[:d], false
+		} else if c > 1 {
+			return nil, true
+		} else if !more {
+			return nil, false
+		}
+	}
+}
+
+func expand0(t *types.Type) {
+	u := t
+	if u.IsPtr() {
+		u = u.Elem()
+	}
+
+	if u.IsInterface() {
+		for _, f := range u.Fields().Slice() {
+			if f.Sym.Uniq() {
+				continue
+			}
+			f.Sym.SetUniq(true)
+			slist = append(slist, symlink{field: f})
+		}
+
+		return
+	}
+
+	u = types.ReceiverBaseType(t)
+	if u != nil {
+		for _, f := range u.Methods().Slice() {
+			if f.Sym.Uniq() {
+				continue
+			}
+			f.Sym.SetUniq(true)
+			slist = append(slist, symlink{field: f})
+		}
+	}
+}
+
+func expand1(t *types.Type, top bool) {
+	if t.Recur() {
+		return
+	}
+	t.SetRecur(true)
+
+	if !top {
+		expand0(t)
+	}
+
+	u := t
+	if u.IsPtr() {
+		u = u.Elem()
+	}
+
+	if u.IsStruct() || u.IsInterface() {
+		for _, f := range u.Fields().Slice() {
+			if f.Embedded == 0 {
+				continue
+			}
+			if f.Sym == nil {
+				continue
+			}
+			expand1(f.Type, false)
+		}
+	}
+
+	t.SetRecur(false)
+}
+
+func ifacelookdot(s *types.Sym, t *types.Type, ignorecase bool) (m *types.Field, followptr bool) {
+	if t == nil {
+		return nil, false
+	}
+
+	path, ambig := dotpath(s, t, &m, ignorecase)
+	if path == nil {
+		if ambig {
+			base.Errorf("%v.%v is ambiguous", t, s)
+		}
+		return nil, false
+	}
+
+	for _, d := range path {
+		if d.field.Type.IsPtr() {
+			followptr = true
+			break
+		}
+	}
+
+	if !m.IsMethod() {
+		base.Errorf("%v.%v is a field, not a method", t, s)
+		return nil, followptr
+	}
+
+	return m, followptr
+}
+
+func implements(t, iface *types.Type, m, samename **types.Field, ptr *int) bool {
+	t0 := t
+	if t == nil {
+		return false
+	}
+
+	if t.IsInterface() {
+		i := 0
+		tms := t.Fields().Slice()
+		for _, im := range iface.Fields().Slice() {
+			for i < len(tms) && tms[i].Sym != im.Sym {
+				i++
+			}
+			if i == len(tms) {
+				*m = im
+				*samename = nil
+				*ptr = 0
+				return false
+			}
+			tm := tms[i]
+			if !types.Identical(tm.Type, im.Type) {
+				*m = im
+				*samename = tm
+				*ptr = 0
+				return false
+			}
+		}
+
+		return true
+	}
+
+	t = types.ReceiverBaseType(t)
+	var tms []*types.Field
+	if t != nil {
+		CalcMethods(t)
+		tms = t.AllMethods().Slice()
+	}
+	i := 0
+	for _, im := range iface.Fields().Slice() {
+		if im.Broke() {
+			continue
+		}
+		for i < len(tms) && tms[i].Sym != im.Sym {
+			i++
+		}
+		if i == len(tms) {
+			*m = im
+			*samename, _ = ifacelookdot(im.Sym, t, true)
+			*ptr = 0
+			return false
+		}
+		tm := tms[i]
+		if tm.Nointerface() || !types.Identical(tm.Type, im.Type) {
+			*m = im
+			*samename = tm
+			*ptr = 0
+			return false
+		}
+		followptr := tm.Embedded == 2
+
+		// if pointer receiver in method,
+		// the method does not exist for value types.
+		rcvr := tm.Type.Recv().Type
+		if rcvr.IsPtr() && !t0.IsPtr() && !followptr && !types.IsInterfaceMethod(tm.Type) {
+			if false && base.Flag.LowerR != 0 {
+				base.Errorf("interface pointer mismatch")
+			}
+
+			*m = im
+			*samename = nil
+			*ptr = 1
+			return false
+		}
+	}
+
+	return true
+}
+
+func isptrto(t *types.Type, et types.Kind) bool {
+	if t == nil {
+		return false
+	}
+	if !t.IsPtr() {
+		return false
+	}
+	t = t.Elem()
+	if t == nil {
+		return false
+	}
+	if t.Kind() != et {
+		return false
+	}
+	return true
+}
+
+// lookdot0 returns the number of fields or methods named s associated
+// with Type t. If exactly one exists, it will be returned in *save
+// (if save is not nil).
+func lookdot0(s *types.Sym, t *types.Type, save **types.Field, ignorecase bool) int {
+	u := t
+	if u.IsPtr() {
+		u = u.Elem()
+	}
+
+	c := 0
+	if u.IsStruct() || u.IsInterface() {
+		for _, f := range u.Fields().Slice() {
+			if f.Sym == s || (ignorecase && f.IsMethod() && strings.EqualFold(f.Sym.Name, s.Name)) {
+				if save != nil {
+					*save = f
+				}
+				c++
+			}
+		}
+	}
+
+	u = t
+	if t.Sym() != nil && t.IsPtr() && !t.Elem().IsPtr() {
+		// If t is a defined pointer type, then x.m is shorthand for (*x).m.
+		u = t.Elem()
+	}
+	u = types.ReceiverBaseType(u)
+	if u != nil {
+		for _, f := range u.Methods().Slice() {
+			if f.Embedded == 0 && (f.Sym == s || (ignorecase && strings.EqualFold(f.Sym.Name, s.Name))) {
+				if save != nil {
+					*save = f
+				}
+				c++
+			}
+		}
+	}
+
+	return c
+}
+
+var slist []symlink
+
+// Code to help generate trampoline functions for methods on embedded
+// types. These are approx the same as the corresponding adddot
+// routines except that they expect to be called with unique tasks and
+// they return the actual methods.
+
+type symlink struct {
+	field *types.Field
+}
diff --git a/src/cmd/compile/internal/typecheck/syms.go b/src/cmd/compile/internal/typecheck/syms.go
new file mode 100644
index 0000000000..ab3384bf90
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/syms.go
@@ -0,0 +1,104 @@
+// Copyright 2009 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 typecheck
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
+	"cmd/internal/obj"
+	"cmd/internal/src"
+)
+
+func LookupRuntime(name string) *ir.Name {
+	s := ir.Pkgs.Runtime.Lookup(name)
+	if s == nil || s.Def == nil {
+		base.Fatalf("syslook: can't find runtime.%s", name)
+	}
+	return ir.AsNode(s.Def).(*ir.Name)
+}
+
+// SubstArgTypes substitutes the given list of types for
+// successive occurrences of the "any" placeholder in the
+// type syntax expression n.Type.
+// The result of SubstArgTypes MUST be assigned back to old, e.g.
+// 	n.Left = SubstArgTypes(n.Left, t1, t2)
+func SubstArgTypes(old *ir.Name, types_ ...*types.Type) *ir.Name {
+	n := old.CloneName()
+
+	for _, t := range types_ {
+		types.CalcSize(t)
+	}
+	n.SetType(types.SubstAny(n.Type(), &types_))
+	if len(types_) > 0 {
+		base.Fatalf("substArgTypes: too many argument types")
+	}
+	return n
+}
+
+// AutoLabel generates a new Name node for use with
+// an automatically generated label.
+// prefix is a short mnemonic (e.g. ".s" for switch)
+// to help with debugging.
+// It should begin with "." to avoid conflicts with
+// user labels.
+func AutoLabel(prefix string) *types.Sym {
+	if prefix[0] != '.' {
+		base.Fatalf("autolabel prefix must start with '.', have %q", prefix)
+	}
+	fn := ir.CurFunc
+	if ir.CurFunc == nil {
+		base.Fatalf("autolabel outside function")
+	}
+	n := fn.Label
+	fn.Label++
+	return LookupNum(prefix, int(n))
+}
+
+func Lookup(name string) *types.Sym {
+	return types.LocalPkg.Lookup(name)
+}
+
+// loadsys loads the definitions for the low-level runtime functions,
+// so that the compiler can generate calls to them,
+// but does not make them visible to user code.
+func loadsys() {
+	types.Block = 1
+
+	inimport = true
+	TypecheckAllowed = true
+
+	typs := runtimeTypes()
+	for _, d := range &runtimeDecls {
+		sym := ir.Pkgs.Runtime.Lookup(d.name)
+		typ := typs[d.typ]
+		switch d.tag {
+		case funcTag:
+			importfunc(ir.Pkgs.Runtime, src.NoXPos, sym, typ)
+		case varTag:
+			importvar(ir.Pkgs.Runtime, src.NoXPos, sym, typ)
+		default:
+			base.Fatalf("unhandled declaration tag %v", d.tag)
+		}
+	}
+
+	TypecheckAllowed = false
+	inimport = false
+}
+
+// LookupRuntimeFunc looks up Go function name in package runtime. This function
+// must follow the internal calling convention.
+func LookupRuntimeFunc(name string) *obj.LSym {
+	s := ir.Pkgs.Runtime.Lookup(name)
+	s.SetFunc(true)
+	return s.Linksym()
+}
+
+// LookupRuntimeVar looks up a variable (or assembly function) name in package
+// runtime. If this is a function, it may have a special calling
+// convention.
+func LookupRuntimeVar(name string) *obj.LSym {
+	return ir.Pkgs.Runtime.Lookup(name).Linksym()
+}
diff --git a/src/cmd/compile/internal/gc/types.go b/src/cmd/compile/internal/typecheck/target.go
similarity index 51%
rename from src/cmd/compile/internal/gc/types.go
rename to src/cmd/compile/internal/typecheck/target.go
index e46735df28..018614d68b 100644
--- a/src/cmd/compile/internal/gc/types.go
+++ b/src/cmd/compile/internal/typecheck/target.go
@@ -2,4 +2,11 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+//go:generate go run mkbuiltin.go
+
+package typecheck
+
+import "cmd/compile/internal/ir"
+
+// Target is the package being compiled.
+var Target *ir.Package
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
similarity index 92%
rename from src/cmd/compile/internal/gc/typecheck.go
rename to src/cmd/compile/internal/typecheck/typecheck.go
index 0552dd180f..2abf0a7824 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -2,35 +2,46 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package typecheck
 
 import (
-	"cmd/compile/internal/base"
-	"cmd/compile/internal/ir"
-	"cmd/compile/internal/types"
 	"fmt"
 	"go/constant"
 	"go/token"
 	"strings"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
 )
 
+// Function collecting autotmps generated during typechecking,
+// to be included in the package-level init function.
+var InitTodoFunc = ir.NewFunc(base.Pos)
+
+var inimport bool // set during import
+
+var decldepth int32
+
+var TypecheckAllowed bool
+
 var (
 	NeedFuncSym     = func(*types.Sym) {}
 	NeedITab        = func(t, itype *types.Type) {}
 	NeedRuntimeType = func(*types.Type) {}
 )
 
-func TypecheckInit() {
+func Init() {
 	initUniverse()
-	dclcontext = ir.PEXTERN
+	DeclContext = ir.PEXTERN
 	base.Timer.Start("fe", "loadsys")
 	loadsys()
 }
 
-func TypecheckPackage() {
-	finishUniverse()
+func Package() {
+	declareUniverse()
 
-	typecheckok = true
+	TypecheckAllowed = true
 
 	// Process top-level declarations in phases.
 
@@ -47,7 +58,7 @@ func TypecheckPackage() {
 	for i := 0; i < len(Target.Decls); i++ {
 		n := Target.Decls[i]
 		if op := n.Op(); op != ir.ODCL && op != ir.OAS && op != ir.OAS2 && (op != ir.ODCLTYPE || !n.(*ir.Decl).X.Name().Alias()) {
-			Target.Decls[i] = typecheck(n, ctxStmt)
+			Target.Decls[i] = Stmt(n)
 		}
 	}
 
@@ -59,7 +70,7 @@ func TypecheckPackage() {
 	for i := 0; i < len(Target.Decls); i++ {
 		n := Target.Decls[i]
 		if op := n.Op(); op == ir.ODCL || op == ir.OAS || op == ir.OAS2 || op == ir.ODCLTYPE && n.(*ir.Decl).X.Name().Alias() {
-			Target.Decls[i] = typecheck(n, ctxStmt)
+			Target.Decls[i] = Stmt(n)
 		}
 	}
 
@@ -70,7 +81,7 @@ func TypecheckPackage() {
 	for i := 0; i < len(Target.Decls); i++ {
 		n := Target.Decls[i]
 		if n.Op() == ir.ODCLFUNC {
-			TypecheckFuncBody(n.(*ir.Func))
+			FuncBody(n.(*ir.Func))
 			fcount++
 		}
 	}
@@ -81,12 +92,12 @@ func TypecheckPackage() {
 	base.Timer.Start("fe", "typecheck", "externdcls")
 	for i, n := range Target.Externs {
 		if n.Op() == ir.ONAME {
-			Target.Externs[i] = typecheck(Target.Externs[i], ctxExpr)
+			Target.Externs[i] = Expr(Target.Externs[i])
 		}
 	}
 
 	// Phase 5: With all user code type-checked, it's now safe to verify map keys.
-	checkMapKeys()
+	CheckMapKeys()
 
 	// Phase 6: Decide how to capture closed variables.
 	// This needs to run before escape analysis,
@@ -97,28 +108,28 @@ func TypecheckPackage() {
 			n := n.(*ir.Func)
 			if n.OClosure != nil {
 				ir.CurFunc = n
-				capturevars(n)
+				CaptureVars(n)
 			}
 		}
 	}
-	capturevarscomplete = true
+	CaptureVarsComplete = true
 	ir.CurFunc = nil
 
 	if base.Debug.TypecheckInl != 0 {
 		// Typecheck imported function bodies if Debug.l > 1,
 		// otherwise lazily when used or re-exported.
-		TypecheckImports()
+		AllImportedBodies()
 	}
 }
 
-func TypecheckAssignExpr(n ir.Node) ir.Node { return typecheck(n, ctxExpr|ctxAssign) }
-func TypecheckExpr(n ir.Node) ir.Node       { return typecheck(n, ctxExpr) }
-func TypecheckStmt(n ir.Node) ir.Node       { return typecheck(n, ctxStmt) }
+func AssignExpr(n ir.Node) ir.Node { return check(n, ctxExpr|ctxAssign) }
+func Expr(n ir.Node) ir.Node       { return check(n, ctxExpr) }
+func Stmt(n ir.Node) ir.Node       { return check(n, ctxStmt) }
 
-func TypecheckExprs(exprs []ir.Node) { typecheckslice(exprs, ctxExpr) }
-func TypecheckStmts(stmts []ir.Node) { typecheckslice(stmts, ctxStmt) }
+func Exprs(exprs []ir.Node) { typecheckslice(exprs, ctxExpr) }
+func Stmts(stmts []ir.Node) { typecheckslice(stmts, ctxStmt) }
 
-func TypecheckCall(call *ir.CallExpr) {
+func Call(call *ir.CallExpr) {
 	t := call.X.Type()
 	if t == nil {
 		panic("misuse of Call")
@@ -127,21 +138,21 @@ func TypecheckCall(call *ir.CallExpr) {
 	if t.NumResults() > 0 {
 		ctx = ctxExpr | ctxMultiOK
 	}
-	if typecheck(call, ctx) != call {
+	if check(call, ctx) != call {
 		panic("bad typecheck")
 	}
 }
 
-func TypecheckCallee(n ir.Node) ir.Node {
-	return typecheck(n, ctxExpr|ctxCallee)
+func Callee(n ir.Node) ir.Node {
+	return check(n, ctxExpr|ctxCallee)
 }
 
-func TypecheckFuncBody(n *ir.Func) {
+func FuncBody(n *ir.Func) {
 	ir.CurFunc = n
 	decldepth = 1
 	errorsBefore := base.Errors()
-	typecheckslice(n.Body, ctxStmt)
-	checkreturn(n)
+	Stmts(n.Body)
+	CheckReturn(n)
 	if base.Errors() > errorsBefore {
 		n.Body.Set(nil) // type errors; do not compile
 	}
@@ -152,10 +163,10 @@ func TypecheckFuncBody(n *ir.Func) {
 
 var importlist []*ir.Func
 
-func TypecheckImports() {
+func AllImportedBodies() {
 	for _, n := range importlist {
 		if n.Inl != nil {
-			typecheckinl(n)
+			ImportedBody(n)
 		}
 	}
 }
@@ -221,8 +232,8 @@ const (
 
 var typecheckdefstack []ir.Node
 
-// resolve ONONAME to definition, if any.
-func resolve(n ir.Node) (res ir.Node) {
+// Resolve ONONAME to definition, if any.
+func Resolve(n ir.Node) (res ir.Node) {
 	if n == nil || n.Op() != ir.ONONAME {
 		return n
 	}
@@ -235,7 +246,7 @@ func resolve(n ir.Node) (res ir.Node) {
 	if sym := n.Sym(); sym.Pkg != types.LocalPkg {
 		// We might have an ir.Ident from oldname or importDot.
 		if id, ok := n.(*ir.Ident); ok {
-			if pkgName := dotImportRefs[id]; pkgName != nil {
+			if pkgName := DotImportRefs[id]; pkgName != nil {
 				pkgName.Used = true
 			}
 		}
@@ -266,7 +277,7 @@ func resolve(n ir.Node) (res ir.Node) {
 
 func typecheckslice(l []ir.Node, top int) {
 	for i := range l {
-		l[i] = typecheck(l[i], top)
+		l[i] = check(l[i], top)
 	}
 }
 
@@ -348,23 +359,23 @@ func cycleTrace(cycle []ir.Node) string {
 
 var typecheck_tcstack []ir.Node
 
-func typecheckFunc(fn *ir.Func) {
-	new := typecheck(fn, ctxStmt)
+func Func(fn *ir.Func) {
+	new := Stmt(fn)
 	if new != fn {
 		base.Fatalf("typecheck changed func")
 	}
 }
 
 func typecheckNtype(n ir.Ntype) ir.Ntype {
-	return typecheck(n, ctxType).(ir.Ntype)
+	return check(n, ctxType).(ir.Ntype)
 }
 
-// typecheck type checks node n.
-// The result of typecheck MUST be assigned back to n, e.g.
-// 	n.Left = typecheck(n.Left, top)
-func typecheck(n ir.Node, top int) (res ir.Node) {
+// check type checks node n.
+// The result of check MUST be assigned back to n, e.g.
+// 	n.Left = check(n.Left, top)
+func check(n ir.Node, top int) (res ir.Node) {
 	// cannot type check until all the source has been parsed
-	if !typecheckok {
+	if !TypecheckAllowed {
 		base.Fatalf("early typecheck")
 	}
 
@@ -385,7 +396,7 @@ func typecheck(n ir.Node, top int) (res ir.Node) {
 	}
 
 	// Resolve definition of name and value of iota lazily.
-	n = resolve(n)
+	n = Resolve(n)
 
 	// Skip typecheck if already done.
 	// But re-typecheck ONAME/OTYPE/OLITERAL/OPACK node in case context has changed.
@@ -504,7 +515,7 @@ func typecheck(n ir.Node, top int) (res ir.Node) {
 		}
 	}
 	if t != nil {
-		n = evalConst(n)
+		n = EvalConst(n)
 		t = n.Type()
 	}
 
@@ -555,7 +566,7 @@ func typecheck(n ir.Node, top int) (res ir.Node) {
 // 	n.Left = indexlit(n.Left)
 func indexlit(n ir.Node) ir.Node {
 	if n != nil && n.Type() != nil && n.Type().Kind() == types.TIDEAL {
-		return defaultlit(n, types.Types[types.TINT])
+		return DefaultLit(n, types.Types[types.TINT])
 	}
 	return n
 }
@@ -642,7 +653,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OTSLICE:
 		n := n.(*ir.SliceType)
-		n.Elem = typecheck(n.Elem, ctxType)
+		n.Elem = check(n.Elem, ctxType)
 		if n.Elem.Type() == nil {
 			return n
 		}
@@ -653,7 +664,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OTARRAY:
 		n := n.(*ir.ArrayType)
-		n.Elem = typecheck(n.Elem, ctxType)
+		n.Elem = check(n.Elem, ctxType)
 		if n.Elem.Type() == nil {
 			return n
 		}
@@ -664,7 +675,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			}
 			return n
 		}
-		n.Len = indexlit(typecheck(n.Len, ctxExpr))
+		n.Len = indexlit(Expr(n.Len))
 		size := n.Len
 		if ir.ConstType(size) != constant.Int {
 			switch {
@@ -697,8 +708,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OTMAP:
 		n := n.(*ir.MapType)
-		n.Key = typecheck(n.Key, ctxType)
-		n.Elem = typecheck(n.Elem, ctxType)
+		n.Key = check(n.Key, ctxType)
+		n.Elem = check(n.Elem, ctxType)
 		l := n.Key
 		r := n.Elem
 		if l.Type() == nil || r.Type() == nil {
@@ -716,7 +727,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OTCHAN:
 		n := n.(*ir.ChanType)
-		n.Elem = typecheck(n.Elem, ctxType)
+		n.Elem = check(n.Elem, ctxType)
 		l := n.Elem
 		if l.Type() == nil {
 			return n
@@ -729,7 +740,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OTSTRUCT:
 		n := n.(*ir.StructType)
-		n.SetOTYPE(tostruct(n.Fields))
+		n.SetOTYPE(NewStructType(n.Fields))
 		return n
 
 	case ir.OTINTER:
@@ -739,13 +750,13 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OTFUNC:
 		n := n.(*ir.FuncType)
-		n.SetOTYPE(functype(n.Recv, n.Params, n.Results))
+		n.SetOTYPE(NewFuncType(n.Recv, n.Params, n.Results))
 		return n
 
 	// type or expr
 	case ir.ODEREF:
 		n := n.(*ir.StarExpr)
-		n.X = typecheck(n.X, ctxExpr|ctxType)
+		n.X = check(n.X, ctxExpr|ctxType)
 		l := n.X
 		t := l.Type()
 		if t == nil {
@@ -806,8 +817,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			l, r = n.X, n.Y
 			setLR = func() { n.X = l; n.Y = r }
 		}
-		l = typecheck(l, ctxExpr)
-		r = typecheck(r, ctxExpr)
+		l = Expr(l)
+		r = Expr(r)
 		setLR()
 		if l.Type() == nil || r.Type() == nil {
 			n.SetType(nil)
@@ -826,7 +837,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			op = n.AsOp
 		}
 		if op == ir.OLSH || op == ir.ORSH {
-			r = defaultlit(r, types.Types[types.TUINT])
+			r = DefaultLit(r, types.Types[types.TUINT])
 			setLR()
 			t := r.Type()
 			if !t.IsInteger() {
@@ -1001,7 +1012,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		if iscmp[n.Op()] {
 			t = types.UntypedBool
 			n.SetType(t)
-			if con := evalConst(n); con.Op() == ir.OLITERAL {
+			if con := EvalConst(n); con.Op() == ir.OLITERAL {
 				return con
 			}
 			l, r = defaultlit2(l, r, true)
@@ -1042,7 +1053,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OBITNOT, ir.ONEG, ir.ONOT, ir.OPLUS:
 		n := n.(*ir.UnaryExpr)
-		n.X = typecheck(n.X, ctxExpr)
+		n.X = Expr(n.X)
 		l := n.X
 		t := l.Type()
 		if t == nil {
@@ -1061,7 +1072,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 	// exprs
 	case ir.OADDR:
 		n := n.(*ir.AddrExpr)
-		n.X = typecheck(n.X, ctxExpr)
+		n.X = Expr(n.X)
 		if n.X.Type() == nil {
 			n.SetType(nil)
 			return n
@@ -1080,7 +1091,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 					base.Fatalf("found non-orig name node %v", r) // TODO(mdempsky): What does this mean?
 				}
 				r.Name().SetAddrtaken(true)
-				if r.Name().IsClosureVar() && !capturevarscomplete {
+				if r.Name().IsClosureVar() && !CaptureVarsComplete {
 					// Mark the original variable as Addrtaken so that capturevars
 					// knows not to pass it by value.
 					// But if the capturevars phase is complete, don't touch it,
@@ -1088,7 +1099,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 					r.Name().Defn.Name().SetAddrtaken(true)
 				}
 			}
-			n.X = defaultlit(n.X, nil)
+			n.X = DefaultLit(n.X, nil)
 			if n.X.Type() == nil {
 				n.SetType(nil)
 				return n
@@ -1104,7 +1115,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 	case ir.OXDOT, ir.ODOT:
 		n := n.(*ir.SelectorExpr)
 		if n.Op() == ir.OXDOT {
-			n = adddot(n)
+			n = AddImplicitDots(n)
 			n.SetOp(ir.ODOT)
 			if n.X == nil {
 				n.SetType(nil)
@@ -1112,9 +1123,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			}
 		}
 
-		n.X = typecheck(n.X, ctxExpr|ctxType)
+		n.X = check(n.X, ctxExpr|ctxType)
 
-		n.X = defaultlit(n.X, nil)
+		n.X = DefaultLit(n.X, nil)
 
 		t := n.X.Type()
 		if t == nil {
@@ -1177,8 +1188,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.ODOTTYPE:
 		n := n.(*ir.TypeAssertExpr)
-		n.X = typecheck(n.X, ctxExpr)
-		n.X = defaultlit(n.X, nil)
+		n.X = Expr(n.X)
+		n.X = DefaultLit(n.X, nil)
 		l := n.X
 		t := l.Type()
 		if t == nil {
@@ -1192,7 +1203,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		}
 
 		if n.Ntype != nil {
-			n.Ntype = typecheck(n.Ntype, ctxType)
+			n.Ntype = check(n.Ntype, ctxType)
 			n.SetType(n.Ntype.Type())
 			n.Ntype = nil
 			if n.Type() == nil {
@@ -1223,11 +1234,11 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OINDEX:
 		n := n.(*ir.IndexExpr)
-		n.X = typecheck(n.X, ctxExpr)
-		n.X = defaultlit(n.X, nil)
+		n.X = Expr(n.X)
+		n.X = DefaultLit(n.X, nil)
 		n.X = implicitstar(n.X)
 		l := n.X
-		n.Index = typecheck(n.Index, ctxExpr)
+		n.Index = Expr(n.Index)
 		r := n.Index
 		t := l.Type()
 		if t == nil || r.Type() == nil {
@@ -1273,7 +1284,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			}
 
 		case types.TMAP:
-			n.Index = assignconv(n.Index, t.Key(), "map index")
+			n.Index = AssignConv(n.Index, t.Key(), "map index")
 			n.SetType(t.Elem())
 			n.SetOp(ir.OINDEXMAP)
 			n.Assigned = false
@@ -1282,8 +1293,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.ORECV:
 		n := n.(*ir.UnaryExpr)
-		n.X = typecheck(n.X, ctxExpr)
-		n.X = defaultlit(n.X, nil)
+		n.X = Expr(n.X)
+		n.X = DefaultLit(n.X, nil)
 		l := n.X
 		t := l.Type()
 		if t == nil {
@@ -1307,9 +1318,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OSEND:
 		n := n.(*ir.SendStmt)
-		n.Chan = typecheck(n.Chan, ctxExpr)
-		n.Value = typecheck(n.Value, ctxExpr)
-		n.Chan = defaultlit(n.Chan, nil)
+		n.Chan = Expr(n.Chan)
+		n.Value = Expr(n.Value)
+		n.Chan = DefaultLit(n.Chan, nil)
 		t := n.Chan.Type()
 		if t == nil {
 			return n
@@ -1324,7 +1335,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			return n
 		}
 
-		n.Value = assignconv(n.Value, t.Elem(), "send")
+		n.Value = AssignConv(n.Value, t.Elem(), "send")
 		if n.Value.Type() == nil {
 			return n
 		}
@@ -1353,11 +1364,11 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			base.Fatalf("expected 2 params (len, cap) for OSLICEHEADER, got %d", x)
 		}
 
-		n.Ptr = typecheck(n.Ptr, ctxExpr)
-		l := typecheck(n.LenCap[0], ctxExpr)
-		c := typecheck(n.LenCap[1], ctxExpr)
-		l = defaultlit(l, types.Types[types.TINT])
-		c = defaultlit(c, types.Types[types.TINT])
+		n.Ptr = Expr(n.Ptr)
+		l := Expr(n.LenCap[0])
+		c := Expr(n.LenCap[1])
+		l = DefaultLit(l, types.Types[types.TINT])
+		c = DefaultLit(c, types.Types[types.TINT])
 
 		if ir.IsConst(l, constant.Int) && ir.Int64Val(l) < 0 {
 			base.Fatalf("len for OSLICEHEADER must be non-negative")
@@ -1399,10 +1410,10 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			base.Fatalf("missing slice argument to copy for OMAKESLICECOPY")
 		}
 
-		n.Len = typecheck(n.Len, ctxExpr)
-		n.Cap = typecheck(n.Cap, ctxExpr)
+		n.Len = Expr(n.Len)
+		n.Cap = Expr(n.Cap)
 
-		n.Len = defaultlit(n.Len, types.Types[types.TINT])
+		n.Len = DefaultLit(n.Len, types.Types[types.TINT])
 
 		if !n.Len.Type().IsInteger() && n.Type().Kind() != types.TIDEAL {
 			base.Errorf("non-integer len argument in OMAKESLICECOPY")
@@ -1420,13 +1431,13 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OSLICE, ir.OSLICE3:
 		n := n.(*ir.SliceExpr)
-		n.X = typecheck(n.X, ctxExpr)
+		n.X = Expr(n.X)
 		low, high, max := n.SliceBounds()
 		hasmax := n.Op().IsSlice3()
-		low = typecheck(low, ctxExpr)
-		high = typecheck(high, ctxExpr)
-		max = typecheck(max, ctxExpr)
-		n.X = defaultlit(n.X, nil)
+		low = Expr(low)
+		high = Expr(high)
+		max = Expr(max)
+		n.X = DefaultLit(n.X, nil)
 		low = indexlit(low)
 		high = indexlit(high)
 		max = indexlit(max)
@@ -1443,9 +1454,9 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				return n
 			}
 
-			addr := nodAddr(n.X)
+			addr := NodAddr(n.X)
 			addr.SetImplicit(true)
-			n.X = typecheck(addr, ctxExpr)
+			n.X = Expr(addr)
 			l = n.X
 		}
 		t := l.Type()
@@ -1500,8 +1511,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		if top == ctxStmt {
 			n.Use = ir.CallUseStmt
 		}
-		typecheckslice(n.Init(), ctxStmt) // imported rewritten f(g()) calls (#30907)
-		n.X = typecheck(n.X, ctxExpr|ctxType|ctxCallee)
+		Stmts(n.Init()) // imported rewritten f(g()) calls (#30907)
+		n.X = check(n.X, ctxExpr|ctxType|ctxCallee)
 		if n.X.Diag() {
 			n.SetDiag(true)
 		}
@@ -1523,7 +1534,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 				n.SetOp(l.BuiltinOp)
 				n.X = nil
 				n.SetTypecheck(0) // re-typechecking new op is OK, not a loop
-				return typecheck(n, top)
+				return check(n, top)
 
 			case ir.OCAP, ir.OCLOSE, ir.OIMAG, ir.OLEN, ir.OPANIC, ir.OREAL:
 				typecheckargs(n)
@@ -1535,7 +1546,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 					return n
 				}
 				u := ir.NewUnaryExpr(n.Pos(), l.BuiltinOp, arg)
-				return typecheck(ir.InitExpr(n.Init(), u), top) // typecheckargs can add to old.Init
+				return check(ir.InitExpr(n.Init(), u), top) // typecheckargs can add to old.Init
 
 			case ir.OCOMPLEX, ir.OCOPY:
 				typecheckargs(n)
@@ -1545,12 +1556,12 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 					return n
 				}
 				b := ir.NewBinaryExpr(n.Pos(), l.BuiltinOp, arg1, arg2)
-				return typecheck(ir.InitExpr(n.Init(), b), top) // typecheckargs can add to old.Init
+				return check(ir.InitExpr(n.Init(), b), top) // typecheckargs can add to old.Init
 			}
 			panic("unreachable")
 		}
 
-		n.X = defaultlit(n.X, nil)
+		n.X = DefaultLit(n.X, nil)
 		l = n.X
 		if l.Op() == ir.OTYPE {
 			if n.IsDDD {
@@ -1653,8 +1664,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OCAP, ir.OLEN:
 		n := n.(*ir.UnaryExpr)
-		n.X = typecheck(n.X, ctxExpr)
-		n.X = defaultlit(n.X, nil)
+		n.X = Expr(n.X)
+		n.X = DefaultLit(n.X, nil)
 		n.X = implicitstar(n.X)
 		l := n.X
 		t := l.Type()
@@ -1680,7 +1691,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OREAL, ir.OIMAG:
 		n := n.(*ir.UnaryExpr)
-		n.X = typecheck(n.X, ctxExpr)
+		n.X = Expr(n.X)
 		l := n.X
 		t := l.Type()
 		if t == nil {
@@ -1705,8 +1716,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OCOMPLEX:
 		n := n.(*ir.BinaryExpr)
-		l := typecheck(n.X, ctxExpr)
-		r := typecheck(n.Y, ctxExpr)
+		l := Expr(n.X)
+		r := Expr(n.Y)
 		if l.Type() == nil || r.Type() == nil {
 			n.SetType(nil)
 			return n
@@ -1746,8 +1757,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OCLOSE:
 		n := n.(*ir.UnaryExpr)
-		n.X = typecheck(n.X, ctxExpr)
-		n.X = defaultlit(n.X, nil)
+		n.X = Expr(n.X)
+		n.X = DefaultLit(n.X, nil)
 		l := n.X
 		t := l.Type()
 		if t == nil {
@@ -1797,7 +1808,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			return n
 		}
 
-		args[1] = assignconv(r, l.Type().Key(), "delete")
+		args[1] = AssignConv(r, l.Type().Key(), "delete")
 		return n
 
 	case ir.OAPPEND:
@@ -1843,11 +1854,11 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			}
 
 			if t.Elem().IsKind(types.TUINT8) && args[1].Type().IsString() {
-				args[1] = defaultlit(args[1], types.Types[types.TSTRING])
+				args[1] = DefaultLit(args[1], types.Types[types.TSTRING])
 				return n
 			}
 
-			args[1] = assignconv(args[1], t.Underlying(), "append")
+			args[1] = AssignConv(args[1], t.Underlying(), "append")
 			return n
 		}
 
@@ -1856,7 +1867,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			if n.Type() == nil {
 				continue
 			}
-			as[i] = assignconv(n, t.Elem(), "append")
+			as[i] = AssignConv(n, t.Elem(), "append")
 			types.CheckSize(as[i].Type()) // ensure width is calculated for backend
 		}
 		return n
@@ -1864,10 +1875,10 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 	case ir.OCOPY:
 		n := n.(*ir.BinaryExpr)
 		n.SetType(types.Types[types.TINT])
-		n.X = typecheck(n.X, ctxExpr)
-		n.X = defaultlit(n.X, nil)
-		n.Y = typecheck(n.Y, ctxExpr)
-		n.Y = defaultlit(n.Y, nil)
+		n.X = Expr(n.X)
+		n.X = DefaultLit(n.X, nil)
+		n.Y = Expr(n.Y)
+		n.Y = DefaultLit(n.Y, nil)
 		if n.X.Type() == nil || n.Y.Type() == nil {
 			n.SetType(nil)
 			return n
@@ -1905,7 +1916,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 	case ir.OCONV:
 		n := n.(*ir.ConvExpr)
 		types.CheckSize(n.Type()) // ensure width is calculated for backend
-		n.X = typecheck(n.X, ctxExpr)
+		n.X = Expr(n.X)
 		n.X = convlit1(n.X, n.Type(), true, nil)
 		t := n.X.Type()
 		if t == nil || n.Type() == nil {
@@ -1958,7 +1969,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 		n.Args.Set(nil)
 		l := args[0]
-		l = typecheck(l, ctxType)
+		l = check(l, ctxType)
 		t := l.Type()
 		if t == nil {
 			n.SetType(nil)
@@ -1982,12 +1993,12 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 			l = args[i]
 			i++
-			l = typecheck(l, ctxExpr)
+			l = Expr(l)
 			var r ir.Node
 			if i < len(args) {
 				r = args[i]
 				i++
-				r = typecheck(r, ctxExpr)
+				r = Expr(r)
 			}
 
 			if l.Type() == nil || (r != nil && r.Type() == nil) {
@@ -2009,8 +2020,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			if i < len(args) {
 				l = args[i]
 				i++
-				l = typecheck(l, ctxExpr)
-				l = defaultlit(l, types.Types[types.TINT])
+				l = Expr(l)
+				l = DefaultLit(l, types.Types[types.TINT])
 				if l.Type() == nil {
 					n.SetType(nil)
 					return n
@@ -2030,8 +2041,8 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			if i < len(args) {
 				l = args[i]
 				i++
-				l = typecheck(l, ctxExpr)
-				l = defaultlit(l, types.Types[types.TINT])
+				l = Expr(l)
+				l = DefaultLit(l, types.Types[types.TINT])
 				if l.Type() == nil {
 					n.SetType(nil)
 					return n
@@ -2063,7 +2074,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 			base.Fatalf("missing argument to new")
 		}
 		l := n.X
-		l = typecheck(l, ctxType)
+		l = check(l, ctxType)
 		t := l.Type()
 		if t == nil {
 			n.SetType(nil)
@@ -2080,17 +2091,17 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		for i1, n1 := range ls {
 			// Special case for print: int constant is int64, not int.
 			if ir.IsConst(n1, constant.Int) {
-				ls[i1] = defaultlit(ls[i1], types.Types[types.TINT64])
+				ls[i1] = DefaultLit(ls[i1], types.Types[types.TINT64])
 			} else {
-				ls[i1] = defaultlit(ls[i1], nil)
+				ls[i1] = DefaultLit(ls[i1], nil)
 			}
 		}
 		return n
 
 	case ir.OPANIC:
 		n := n.(*ir.UnaryExpr)
-		n.X = typecheck(n.X, ctxExpr)
-		n.X = defaultlit(n.X, types.Types[types.TINTER])
+		n.X = Expr(n.X)
+		n.X = DefaultLit(n.X, types.Types[types.TINTER])
 		if n.X.Type() == nil {
 			n.SetType(nil)
 			return n
@@ -2118,7 +2129,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OITAB:
 		n := n.(*ir.UnaryExpr)
-		n.X = typecheck(n.X, ctxExpr)
+		n.X = Expr(n.X)
 		t := n.X.Type()
 		if t == nil {
 			n.SetType(nil)
@@ -2139,7 +2150,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OSPTR:
 		n := n.(*ir.UnaryExpr)
-		n.X = typecheck(n.X, ctxExpr)
+		n.X = Expr(n.X)
 		t := n.X.Type()
 		if t == nil {
 			n.SetType(nil)
@@ -2160,13 +2171,13 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OCFUNC:
 		n := n.(*ir.UnaryExpr)
-		n.X = typecheck(n.X, ctxExpr)
+		n.X = Expr(n.X)
 		n.SetType(types.Types[types.TUINTPTR])
 		return n
 
 	case ir.OCONVNOP:
 		n := n.(*ir.ConvExpr)
-		n.X = typecheck(n.X, ctxExpr)
+		n.X = Expr(n.X)
 		return n
 
 	// statements
@@ -2195,7 +2206,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OBLOCK:
 		n := n.(*ir.BlockStmt)
-		typecheckslice(n.List, ctxStmt)
+		Stmts(n.List)
 		return n
 
 	case ir.OLABEL:
@@ -2210,7 +2221,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.ODEFER, ir.OGO:
 		n := n.(*ir.GoDeferStmt)
-		n.Call = typecheck(n.Call, ctxStmt|ctxExpr)
+		n.Call = check(n.Call, ctxStmt|ctxExpr)
 		if !n.Call.Diag() {
 			checkdefergo(n)
 		}
@@ -2218,37 +2229,37 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OFOR, ir.OFORUNTIL:
 		n := n.(*ir.ForStmt)
-		typecheckslice(n.Init(), ctxStmt)
+		Stmts(n.Init())
 		decldepth++
-		n.Cond = typecheck(n.Cond, ctxExpr)
-		n.Cond = defaultlit(n.Cond, nil)
+		n.Cond = Expr(n.Cond)
+		n.Cond = DefaultLit(n.Cond, nil)
 		if n.Cond != nil {
 			t := n.Cond.Type()
 			if t != nil && !t.IsBoolean() {
 				base.Errorf("non-bool %L used as for condition", n.Cond)
 			}
 		}
-		n.Post = typecheck(n.Post, ctxStmt)
+		n.Post = Stmt(n.Post)
 		if n.Op() == ir.OFORUNTIL {
-			typecheckslice(n.Late, ctxStmt)
+			Stmts(n.Late)
 		}
-		typecheckslice(n.Body, ctxStmt)
+		Stmts(n.Body)
 		decldepth--
 		return n
 
 	case ir.OIF:
 		n := n.(*ir.IfStmt)
-		typecheckslice(n.Init(), ctxStmt)
-		n.Cond = typecheck(n.Cond, ctxExpr)
-		n.Cond = defaultlit(n.Cond, nil)
+		Stmts(n.Init())
+		n.Cond = Expr(n.Cond)
+		n.Cond = DefaultLit(n.Cond, nil)
 		if n.Cond != nil {
 			t := n.Cond.Type()
 			if t != nil && !t.IsBoolean() {
 				base.Errorf("non-bool %L used as if condition", n.Cond)
 			}
 		}
-		typecheckslice(n.Body, ctxStmt)
-		typecheckslice(n.Else, ctxStmt)
+		Stmts(n.Body)
+		Stmts(n.Else)
 		return n
 
 	case ir.ORETURN:
@@ -2294,12 +2305,12 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.ODCLCONST:
 		n := n.(*ir.Decl)
-		n.X = typecheck(n.X, ctxExpr)
+		n.X = Expr(n.X)
 		return n
 
 	case ir.ODCLTYPE:
 		n := n.(*ir.Decl)
-		n.X = typecheck(n.X, ctxType)
+		n.X = check(n.X, ctxType)
 		types.CheckSize(n.X.Type())
 		return n
 	}
@@ -2317,14 +2328,14 @@ func typecheckargs(n ir.Node) {
 	case *ir.CallExpr:
 		list = n.Args
 		if n.IsDDD {
-			typecheckslice(list, ctxExpr)
+			Exprs(list)
 			return
 		}
 	case *ir.ReturnStmt:
 		list = n.Results
 	}
 	if len(list) != 1 {
-		typecheckslice(list, ctxExpr)
+		Exprs(list)
 		return
 	}
 
@@ -2351,11 +2362,11 @@ func typecheckargs(n ir.Node) {
 	// will reassociate them later when it's appropriate.
 	static := ir.CurFunc == nil
 	if static {
-		ir.CurFunc = initTodo
+		ir.CurFunc = InitTodoFunc
 	}
 	list = nil
 	for _, f := range t.FieldSlice() {
-		t := temp(f.Type)
+		t := Temp(f.Type)
 		as.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, t))
 		as.Lhs.Append(t)
 		list = append(list, t)
@@ -2371,7 +2382,7 @@ func typecheckargs(n ir.Node) {
 		n.Results.Set(list)
 	}
 
-	n.PtrInit().Append(typecheck(as, ctxStmt))
+	n.PtrInit().Append(Stmt(as))
 }
 
 func checksliceindex(l ir.Node, r ir.Node, tp *types.Type) bool {
@@ -2483,7 +2494,7 @@ func implicitstar(n ir.Node) ir.Node {
 	}
 	star := ir.NewStarExpr(base.Pos, n)
 	star.SetImplicit(true)
-	return typecheck(star, ctxExpr)
+	return Expr(star)
 }
 
 func needOneArg(n *ir.CallExpr, f string, args ...interface{}) (ir.Node, bool) {
@@ -2563,7 +2574,7 @@ func typecheckMethodExpr(n *ir.SelectorExpr) (res ir.Node) {
 			n.SetType(nil)
 			return n
 		}
-		expandmeth(mt)
+		CalcMethods(mt)
 		ms = mt.AllMethods()
 
 		// The method expression T.m requires a wrapper when T
@@ -2599,7 +2610,7 @@ func typecheckMethodExpr(n *ir.SelectorExpr) (res ir.Node) {
 	}
 
 	me := ir.NewMethodExpr(n.Pos(), n.X.Type(), m)
-	me.SetType(methodfunc(m.Type, n.X.Type()))
+	me.SetType(NewMethodType(m.Type, n.X.Type()))
 	f := NewName(ir.MethodSym(t, m.Sym))
 	f.Class_ = ir.PFUNC
 	f.SetType(me.Type())
@@ -2654,7 +2665,7 @@ func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 			if n.X.Type().IsPtr() {
 				star := ir.NewStarExpr(base.Pos, n.X)
 				star.SetImplicit(true)
-				n.X = typecheck(star, ctxExpr)
+				n.X = Expr(star)
 			}
 
 			n.SetOp(ir.ODOTINTER)
@@ -2674,13 +2685,13 @@ func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 		if !types.Identical(rcvr, tt) {
 			if rcvr.IsPtr() && types.Identical(rcvr.Elem(), tt) {
 				checklvalue(n.X, "call pointer method on")
-				addr := nodAddr(n.X)
+				addr := NodAddr(n.X)
 				addr.SetImplicit(true)
-				n.X = typecheck(addr, ctxType|ctxExpr)
+				n.X = check(addr, ctxType|ctxExpr)
 			} else if tt.IsPtr() && (!rcvr.IsPtr() || rcvr.IsPtr() && rcvr.Elem().NotInHeap()) && types.Identical(tt.Elem(), rcvr) {
 				star := ir.NewStarExpr(base.Pos, n.X)
 				star.SetImplicit(true)
-				n.X = typecheck(star, ctxType|ctxExpr)
+				n.X = check(star, ctxType|ctxExpr)
 			} else if tt.IsPtr() && tt.Elem().IsPtr() && types.Identical(derefall(tt), derefall(rcvr)) {
 				base.Errorf("calling method %v with receiver %L requires explicit dereference", n.Sel, n.X)
 				for tt.IsPtr() {
@@ -2690,7 +2701,7 @@ func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 					}
 					star := ir.NewStarExpr(base.Pos, n.X)
 					star.SetImplicit(true)
-					n.X = typecheck(star, ctxType|ctxExpr)
+					n.X = check(star, ctxType|ctxExpr)
 					tt = tt.Elem()
 				}
 			} else {
@@ -2967,7 +2978,7 @@ func pushtype(nn ir.Node, t *types.Type) ir.Node {
 		// For *T, return &T{...}.
 		n.Ntype = ir.TypeNode(t.Elem())
 
-		addr := nodAddrAt(n.Pos(), n)
+		addr := NodAddrAt(n.Pos(), n)
 		addr.SetImplicit(true)
 		return addr
 	}
@@ -2999,7 +3010,7 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 
 	// Need to handle [...]T arrays specially.
 	if array, ok := n.Ntype.(*ir.ArrayType); ok && array.Elem != nil && array.Len == nil {
-		array.Elem = typecheck(array.Elem, ctxType)
+		array.Elem = check(array.Elem, ctxType)
 		elemType := array.Elem.Type()
 		if elemType == nil {
 			n.SetType(nil)
@@ -3012,7 +3023,7 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 		return n
 	}
 
-	n.Ntype = ir.Node(typecheck(n.Ntype, ctxType)).(ir.Ntype)
+	n.Ntype = ir.Node(check(n.Ntype, ctxType)).(ir.Ntype)
 	t := n.Ntype.Type()
 	if t == nil {
 		n.SetType(nil)
@@ -3041,7 +3052,7 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 		for i3, l := range n.List {
 			ir.SetPos(l)
 			if l.Op() != ir.OKEY {
-				n.List[i3] = typecheck(l, ctxExpr)
+				n.List[i3] = Expr(l)
 				base.Errorf("missing key in map literal")
 				continue
 			}
@@ -3049,14 +3060,14 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 
 			r := l.Key
 			r = pushtype(r, t.Key())
-			r = typecheck(r, ctxExpr)
-			l.Key = assignconv(r, t.Key(), "map key")
+			r = Expr(r)
+			l.Key = AssignConv(r, t.Key(), "map key")
 			cs.add(base.Pos, l.Key, "key", "map literal")
 
 			r = l.Value
 			r = pushtype(r, t.Elem())
-			r = typecheck(r, ctxExpr)
-			l.Value = assignconv(r, t.Elem(), "map value")
+			r = Expr(r)
+			l.Value = AssignConv(r, t.Elem(), "map value")
 		}
 
 		n.SetOp(ir.OMAPLIT)
@@ -3072,7 +3083,7 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 			ls := n.List
 			for i, n1 := range ls {
 				ir.SetPos(n1)
-				n1 = typecheck(n1, ctxExpr)
+				n1 = Expr(n1)
 				ls[i] = n1
 				if i >= t.NumFields() {
 					if !errored {
@@ -3088,7 +3099,7 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 					base.Errorf("implicit assignment of unexported field '%s' in %v literal", s.Name, t)
 				}
 				// No pushtype allowed here. Must name fields for that.
-				n1 = assignconv(n1, f.Type, "field value")
+				n1 = AssignConv(n1, f.Type, "field value")
 				sk := ir.NewStructKeyExpr(base.Pos, f.Sym, n1)
 				sk.Offset = f.Offset
 				ls[i] = sk
@@ -3112,8 +3123,8 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 					// package, because of import dot. Redirect to correct sym
 					// before we do the lookup.
 					s := key.Sym()
-					if id, ok := key.(*ir.Ident); ok && dotImportRefs[id] != nil {
-						s = lookup(s.Name)
+					if id, ok := key.(*ir.Ident); ok && DotImportRefs[id] != nil {
+						s = Lookup(s.Name)
 					}
 
 					// An OXDOT uses the Sym field to hold
@@ -3134,7 +3145,7 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 						base.Errorf("mixture of field:value and value initializers")
 						errored = true
 					}
-					ls[i] = typecheck(ls[i], ctxExpr)
+					ls[i] = Expr(ls[i])
 					continue
 				}
 				l := l.(*ir.StructKeyExpr)
@@ -3170,8 +3181,8 @@ func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
 				l.Offset = f.Offset
 
 				// No pushtype allowed here. Tried and rejected.
-				l.Value = typecheck(l.Value, ctxExpr)
-				l.Value = assignconv(l.Value, f.Type, "field value")
+				l.Value = Expr(l.Value)
+				l.Value = AssignConv(l.Value, f.Type, "field value")
 			}
 		}
 
@@ -3201,8 +3212,8 @@ func typecheckarraylit(elemType *types.Type, bound int64, elts []ir.Node, ctx st
 		var kv *ir.KeyExpr
 		if elt.Op() == ir.OKEY {
 			elt := elt.(*ir.KeyExpr)
-			elt.Key = typecheck(elt.Key, ctxExpr)
-			key = indexconst(elt.Key)
+			elt.Key = Expr(elt.Key)
+			key = IndexConst(elt.Key)
 			if key < 0 {
 				if !elt.Key.Diag() {
 					if key == -2 {
@@ -3219,8 +3230,8 @@ func typecheckarraylit(elemType *types.Type, bound int64, elts []ir.Node, ctx st
 		}
 
 		r = pushtype(r, elemType)
-		r = typecheck(r, ctxExpr)
-		r = assignconv(r, elemType, ctx)
+		r = Expr(r)
+		r = AssignConv(r, elemType, ctx)
 		if kv != nil {
 			kv.Value = r
 		} else {
@@ -3328,15 +3339,15 @@ func typecheckas(n *ir.AssignStmt) {
 	// if the variable has a type (ntype) then typechecking
 	// will not look at defn, so it is okay (and desirable,
 	// so that the conversion below happens).
-	n.X = resolve(n.X)
+	n.X = Resolve(n.X)
 
 	if !ir.DeclaredBy(n.X, n) || n.X.Name().Ntype != nil {
-		n.X = typecheck(n.X, ctxExpr|ctxAssign)
+		n.X = AssignExpr(n.X)
 	}
 
 	// Use ctxMultiOK so we can emit an "N variables but M values" error
 	// to be consistent with typecheckas2 (#26616).
-	n.Y = typecheck(n.Y, ctxExpr|ctxMultiOK)
+	n.Y = check(n.Y, ctxExpr|ctxMultiOK)
 	checkassign(n, n.X)
 	if n.Y != nil && n.Y.Type() != nil {
 		if n.Y.Type().IsFuncArgStruct() {
@@ -3345,12 +3356,12 @@ func typecheckas(n *ir.AssignStmt) {
 			// to indicate failed typechecking.
 			n.Y.SetType(nil)
 		} else if n.X.Type() != nil {
-			n.Y = assignconv(n.Y, n.X.Type(), "assignment")
+			n.Y = AssignConv(n.Y, n.X.Type(), "assignment")
 		}
 	}
 
 	if ir.DeclaredBy(n.X, n) && n.X.Name().Ntype == nil {
-		n.Y = defaultlit(n.Y, nil)
+		n.Y = DefaultLit(n.Y, nil)
 		n.X.SetType(n.Y.Type())
 	}
 
@@ -3360,7 +3371,7 @@ func typecheckas(n *ir.AssignStmt) {
 	n.SetTypecheck(1)
 
 	if n.X.Typecheck() == 0 {
-		n.X = typecheck(n.X, ctxExpr|ctxAssign)
+		n.X = AssignExpr(n.X)
 	}
 	if !ir.IsBlank(n.X) {
 		types.CheckSize(n.X.Type()) // ensure width is calculated for backend
@@ -3382,20 +3393,20 @@ func typecheckas2(n *ir.AssignListStmt) {
 	ls := n.Lhs
 	for i1, n1 := range ls {
 		// delicate little dance.
-		n1 = resolve(n1)
+		n1 = Resolve(n1)
 		ls[i1] = n1
 
 		if !ir.DeclaredBy(n1, n) || n1.Name().Ntype != nil {
-			ls[i1] = typecheck(ls[i1], ctxExpr|ctxAssign)
+			ls[i1] = AssignExpr(ls[i1])
 		}
 	}
 
 	cl := len(n.Lhs)
 	cr := len(n.Rhs)
 	if cl > 1 && cr == 1 {
-		n.Rhs[0] = typecheck(n.Rhs[0], ctxExpr|ctxMultiOK)
+		n.Rhs[0] = check(n.Rhs[0], ctxExpr|ctxMultiOK)
 	} else {
-		typecheckslice(n.Rhs, ctxExpr)
+		Exprs(n.Rhs)
 	}
 	checkassignlist(n, n.Lhs)
 
@@ -3408,10 +3419,10 @@ func typecheckas2(n *ir.AssignListStmt) {
 		for il, nl := range ls {
 			nr := rs[il]
 			if nl.Type() != nil && nr.Type() != nil {
-				rs[il] = assignconv(nr, nl.Type(), "assignment")
+				rs[il] = AssignConv(nr, nl.Type(), "assignment")
 			}
 			if ir.DeclaredBy(nl, n) && nl.Name().Ntype == nil {
-				rs[il] = defaultlit(rs[il], nil)
+				rs[il] = DefaultLit(rs[il], nil)
 				nl.SetType(rs[il].Type())
 			}
 		}
@@ -3500,7 +3511,7 @@ out:
 	ls = n.Lhs
 	for i1, n1 := range ls {
 		if n1.Typecheck() == 0 {
-			ls[i1] = typecheck(ls[i1], ctxExpr|ctxAssign)
+			ls[i1] = AssignExpr(ls[i1])
 		}
 	}
 }
@@ -3519,7 +3530,7 @@ func typecheckfunc(n *ir.Func) {
 		}
 	}
 
-	n.Nname = typecheck(n.Nname, ctxExpr|ctxAssign).(*ir.Name)
+	n.Nname = AssignExpr(n.Nname).(*ir.Name)
 	t := n.Nname.Type()
 	if t == nil {
 		return
@@ -3533,7 +3544,7 @@ func typecheckfunc(n *ir.Func) {
 		}
 
 		n.Nname.SetSym(ir.MethodSym(rcvr.Type, n.Shortname))
-		declare(n.Nname, ir.PFUNC)
+		Declare(n.Nname, ir.PFUNC)
 	}
 
 	if base.Ctxt.Flag_dynlink && !inimport && n.Nname != nil {
@@ -3557,12 +3568,12 @@ func stringtoruneslit(n *ir.ConvExpr) ir.Node {
 
 	nn := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(n.Type()).(ir.Ntype), nil)
 	nn.List.Set(l)
-	return typecheck(nn, ctxExpr)
+	return Expr(nn)
 }
 
 var mapqueue []*ir.MapType
 
-func checkMapKeys() {
+func CheckMapKeys() {
 	for _, n := range mapqueue {
 		k := n.Type().MapType().Key
 		if !k.Broke() && !types.IsComparable(k) {
@@ -3668,7 +3679,7 @@ func typecheckdef(n ir.Node) {
 			base.ErrorfAt(n.Pos(), "xxx")
 		}
 
-		e = typecheck(e, ctxExpr)
+		e = Expr(e)
 		if e.Type() == nil {
 			goto ret
 		}
@@ -3734,12 +3745,12 @@ func typecheckdef(n ir.Node) {
 		}
 
 		if n.Name().Defn.Op() == ir.ONAME {
-			n.Name().Defn = typecheck(n.Name().Defn, ctxExpr)
+			n.Name().Defn = Expr(n.Name().Defn)
 			n.SetType(n.Name().Defn.Type())
 			break
 		}
 
-		n.Name().Defn = typecheck(n.Name().Defn, ctxStmt) // fills in n.Type
+		n.Name().Defn = Stmt(n.Name().Defn) // fills in n.Type
 
 	case ir.OTYPE:
 		n := n.(*ir.Name)
@@ -3808,7 +3819,7 @@ func checkmake(t *types.Type, arg string, np *ir.Node) bool {
 	// are the same as for index expressions. Factor the code better;
 	// for instance, indexlit might be called here and incorporate some
 	// of the bounds checks done for make.
-	n = defaultlit(n, types.Types[types.TINT])
+	n = DefaultLit(n, types.Types[types.TINT])
 	*np = n
 
 	return true
@@ -3973,8 +3984,8 @@ func isTermNode(n ir.Node) bool {
 	return false
 }
 
-// checkreturn makes sure that fn terminates appropriately.
-func checkreturn(fn *ir.Func) {
+// CheckReturn makes sure that fn terminates appropriately.
+func CheckReturn(fn *ir.Func) {
 	if fn.Type().NumResults() != 0 && len(fn.Body) != 0 {
 		markBreak(fn)
 		if !isTermNodes(fn.Body) {
@@ -4145,3 +4156,25 @@ func curpkg() *types.Pkg {
 	}
 	return fnpkg(fn.Nname)
 }
+
+func Conv(n ir.Node, t *types.Type) ir.Node {
+	if types.Identical(n.Type(), t) {
+		return n
+	}
+	n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
+	n.SetType(t)
+	n = Expr(n)
+	return n
+}
+
+// ConvNop converts node n to type t using the OCONVNOP op
+// and typechecks the result with ctxExpr.
+func ConvNop(n ir.Node, t *types.Type) ir.Node {
+	if types.Identical(n.Type(), t) {
+		return n
+	}
+	n = ir.NewConvExpr(base.Pos, ir.OCONVNOP, nil, n)
+	n.SetType(t)
+	n = Expr(n)
+	return n
+}
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/typecheck/universe.go
similarity index 93%
rename from src/cmd/compile/internal/gc/universe.go
rename to src/cmd/compile/internal/typecheck/universe.go
index 5d59fdbbc5..fc8e962e28 100644
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/typecheck/universe.go
@@ -2,16 +2,31 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// TODO(gri) This file should probably become part of package types.
-
-package gc
+package typecheck
 
 import (
+	"go/constant"
+
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
-	"go/constant"
+)
+
+var (
+	okfor [ir.OEND][]bool
+	iscmp [ir.OEND]bool
+)
+
+var (
+	okforeq    [types.NTYPE]bool
+	okforadd   [types.NTYPE]bool
+	okforand   [types.NTYPE]bool
+	okfornone  [types.NTYPE]bool
+	okforbool  [types.NTYPE]bool
+	okforcap   [types.NTYPE]bool
+	okforlen   [types.NTYPE]bool
+	okforarith [types.NTYPE]bool
 )
 
 var basicTypes = [...]struct {
@@ -169,7 +184,7 @@ func initUniverse() {
 	s = types.BuiltinPkg.Lookup("false")
 	s.Def = ir.NewConstAt(src.NoXPos, s, types.UntypedBool, constant.MakeBool(false))
 
-	s = lookup("_")
+	s = Lookup("_")
 	types.BlankSym = s
 	s.Block = -100
 	s.Def = NewName(s)
@@ -186,7 +201,7 @@ func initUniverse() {
 
 	types.Types[types.TNIL] = types.New(types.TNIL)
 	s = types.BuiltinPkg.Lookup("nil")
-	nnil := nodnil()
+	nnil := NodNil()
 	nnil.(*ir.NilExpr).SetSym(s)
 	s.Def = nnil
 
@@ -317,12 +332,12 @@ func makeErrorInterface() *types.Type {
 	sig := types.NewSignature(types.NoPkg, fakeRecvField(), nil, []*types.Field{
 		types.NewField(src.NoXPos, nil, types.Types[types.TSTRING]),
 	})
-	method := types.NewField(src.NoXPos, lookup("Error"), sig)
+	method := types.NewField(src.NoXPos, Lookup("Error"), sig)
 	return types.NewInterface(types.NoPkg, []*types.Field{method})
 }
 
-// finishUniverse makes the universe block visible within the current package.
-func finishUniverse() {
+// declareUniverse makes the universe block visible within the current package.
+func declareUniverse() {
 	// Operationally, this is similar to a dot import of builtinpkg, except
 	// that we silently skip symbols that are already declared in the
 	// package block rather than emitting a redeclared symbol error.
@@ -331,7 +346,7 @@ func finishUniverse() {
 		if s.Def == nil {
 			continue
 		}
-		s1 := lookup(s.Name)
+		s1 := Lookup(s.Name)
 		if s1.Def != nil {
 			continue
 		}
@@ -340,7 +355,7 @@ func finishUniverse() {
 		s1.Block = s.Block
 	}
 
-	ir.RegFP = NewName(lookup(".fp"))
+	ir.RegFP = NewName(Lookup(".fp"))
 	ir.RegFP.SetType(types.Types[types.TINT32])
 	ir.RegFP.Class_ = ir.PPARAM
 	ir.RegFP.SetUsed(true)
-- 
GitLab


From 0256ba99a893f2faf870105fc93fff94e5caf241 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 23 Dec 2020 00:43:42 -0500
Subject: [PATCH 0306/2400] [dev.regabi] cmd/compile: split up typecheck1
 [generated]

typecheck1 is the largest non-machine-generated function in the compiler.
weighing in at 1,747 lines. Since we are destroying the git blame history
anyway, now is a good time to split each different case into its own function,
making future work on this function more manageable.

[git-generate]
cd src/cmd/compile/internal/typecheck
rf '
	# Remove tracing print from typecheck1 - the one in typecheck is fine.
	# Removing it lets us remove the named result.
	# That lets all the cut-out functions not have named results.
	rm typecheck.go:/^func typecheck1/+0,/^func typecheck1/+4
	sub typecheck.go:/^func typecheck1/+/\(res ir\.Node\)/ ir.Node

	mv typecheckselect tcSelect
	mv typecheckswitch tcSwitch
	mv typecheckrange tcRange
	mv typecheckfunc tcFunc
	mv checkdefergo tcGoDefer
	mv typecheckclosure tcClosure
	mv check typecheck
	mv typecheckcomplit tcCompLit
	mv typecheckas tcAssign
	mv typecheckas2 tcAssignList
	mv typecheckpartialcall tcCallPart
	mv typecheckExprSwitch tcSwitchExpr
	mv typecheckTypeSwitch tcSwitchType

	mv typecheck1:/^\tcase ir.ORETURN:/+2,/^\tcase /-2 tcReturn
	add typecheck.go:/^func tcReturn/-0 \
		// tcReturn typechecks an ORETURN node.
	mv typecheck1:/^\tcase ir.OIF:/+2,/^\tcase /-2 tcIf
	add typecheck.go:/^func tcIf/-0 \
		// tcIf typechecks an OIF node.
	mv typecheck1:/^\tcase ir.OFOR,/+2,/^\tcase /-2 tcFor
	add typecheck.go:/^func tcFor/-0 \
		// tcFor typechecks an OFOR node.
	mv typecheck1:/^\tcase ir.OSPTR:/+2,/^\tcase /-2 tcSPtr
	add typecheck.go:/^func tcSPtr/-0 \
		// tcSPtr typechecks an OSPTR node.
	mv typecheck1:/^\tcase ir.OITAB:/+2,/^\tcase /-2 tcITab
	add typecheck.go:/^func tcITab/-0 \
		// tcITab typechecks an OITAB node.
	mv typecheck1:/^\tcase ir.ORECOVER:/+2,/^\tcase /-2 tcRecover
	add typecheck.go:/^func tcRecover/-0 \
		// tcRecover typechecks an ORECOVER node.
	mv typecheck1:/^\tcase ir.OPANIC:/+2,/^\tcase /-2 tcPanic
	add typecheck.go:/^func tcPanic/-0 \
		// tcPanic typechecks an OPANIC node.
	mv typecheck1:/^\tcase ir.OPRINT,/+2,/^\tcase /-2 tcPrint
	add typecheck.go:/^func tcPrint/-0 \
		// tcPrint typechecks an OPRINT or OPRINTN node.
	mv typecheck1:/^\tcase ir.ONEW:/+2,/^\tcase /-2 tcNew
	add typecheck.go:/^func tcNew/-0 \
		// tcNew typechecks an ONEW node.
	mv typecheck1:/^\tcase ir.OMAKE:/+2,/^\tcase /-2 tcMake
	add typecheck.go:/^func tcMake/-0 \
		// tcMake typechecks an OMAKE node.
	mv typecheck1:/^\tcase ir.OCONV:/+2,/^\tcase /-2 tcConv
	add typecheck.go:/^func tcConv/-0 \
		// tcConv typechecks an OCONV node.
	mv typecheck1:/^\tcase ir.OCOPY:/+2,/^\tcase /-2 tcCopy
	add typecheck.go:/^func tcCopy/-0 \
		// tcCopy typechecks an OCOPY node.
	mv typecheck1:/^\tcase ir.OAPPEND:/+2,/^\tcase /-2 tcAppend
	add typecheck.go:/^func tcAppend/-0 \
		// tcAppend typechecks an OAPPEND node.
	mv typecheck1:/^\tcase ir.ODELETE:/+2,/^\tcase /-2 tcDelete
	add typecheck.go:/^func tcDelete/-0 \
		// tcDelete typechecks an ODELETE node.
	mv typecheck1:/^\tcase ir.OCLOSE:/+2,/^\tcase /-2 tcClose
	add typecheck.go:/^func tcClose/-0 \
		// tcClose typechecks an OCLOSE node.
	mv typecheck1:/^\tcase ir.OCOMPLEX:/+2,/^\tcase /-2 tcComplex
	add typecheck.go:/^func tcComplex/-0 \
		// tcComplex typechecks an OCOMPLEX node.
	mv typecheck1:/^\tcase ir.OREAL,/+2,/^\tcase /-2 tcRealImag
	add typecheck.go:/^func tcRealImag/-0 \
		// tcRealImag typechecks an OREAL or OIMAG node.
	mv typecheck1:/^\tcase ir.OCAP,/+2,/^\tcase /-2 tcLenCap
	add typecheck.go:/^func tcLenCap/-0 \
		// tcLenCap typechecks an OLEN or OCAP node.
	mv typecheck1:/^\tcase ir.OCALL:/+2,/^\tcase /-2 tcCall
	add typecheck.go:/^func tcCall/-0 \
		// tcCall typechecks an OCALL node.
	mv typecheck1:/^\tcase ir.OSLICE,/+2,/^\tcase /-3 tcSlice
	add typecheck.go:/^func tcSlice/-0 \
		// tcSlice typechecks an OSLICE or OSLICE3 node.
	# move type assertion above comment
	mv typecheck1:/^\tcase ir.OMAKESLICECOPY:/+/n := n/-+ typecheck1:/^\tcase ir.OMAKESLICECOPY:/+0
	mv typecheck1:/^\tcase ir.OMAKESLICECOPY:/+2,/^\tcase /-2 tcMakeSliceCopy
	add typecheck.go:/^func tcMakeSliceCopy/-0 \
		// tcMakeSliceCopy typechecks an OMAKESLICECOPY node.
	# move type assertion above comment
	mv typecheck1:/^\tcase ir.OSLICEHEADER:/+/n := n/-+ typecheck1:/^\tcase ir.OSLICEHEADER:/+0
	mv typecheck1:/^\tcase ir.OSLICEHEADER:/+2,/^\tcase /-2 tcSliceHeader
	add typecheck.go:/^func tcSliceHeader/-0 \
		// tcSliceHeader typechecks an OSLICEHEADER node.
	mv typecheck1:/^\tcase ir.OSEND:/+2,/^\tcase /-2 tcSend
	add typecheck.go:/^func tcSend/-0 \
		// tcSend typechecks an OSEND node.
	mv typecheck1:/^\tcase ir.ORECV:/+2,/^\tcase /-2 tcRecv
	add typecheck.go:/^func tcRecv/-0 \
		// tcRecv typechecks an ORECV node.
	mv typecheck1:/^\tcase ir.OINDEX:/+2,/^\tcase /-2 tcIndex
	add typecheck.go:/^func tcIndex/-0 \
		// tcIndex typechecks an OINDEX node.
	mv typecheck1:/^\tcase ir.ODOTTYPE:/+2,/^\tcase /-2 tcDotType
	add typecheck.go:/^func tcDotType/-0 \
		// tcDotType typechecks an ODOTTYPE node.
	mv typecheck1:/^\tcase ir.OXDOT,/+2,/^\tcase /-2 tcDot
	add typecheck.go:/^func tcDot/-0 \
		// tcDot typechecks an OXDOT or ODOT node.
	mv typecheck1:/^\tcase ir.OADDR:/+2,/^\tcase /-2 tcAddr
	add typecheck.go:/^func tcAddr/-0 \
		// tcAddr typechecks an OADDR node.
	mv typecheck1:/^\tcase ir.OBITNOT,/+2,/^\tcase /-3 tcUnaryArith
	add typecheck.go:/^func tcUnaryArith/-0 \
		// tcUnaryArith typechecks a unary arithmetic expression.
	mv typecheck1:/^\t\tir.OXOR:/+1,/^\tcase /-2 tcArith
	add typecheck.go:/^func tcArith/-0 \
		// tcArith typechecks a binary arithmetic expression.
	mv typecheck1:/^\tcase ir.ODEREF:/+2,/^\tcase /-2 tcStar
	add typecheck.go:/^func tcStar/-0 \
		// tcStar typechecks an ODEREF node, which may be an expression or a type.
	mv typecheck1:/^\tcase ir.OTFUNC:/+2,/^\tcase /-2 tcFuncType
	add typecheck.go:/^func tcFuncType/-0 \
		// tcFuncType typechecks an OTFUNC node.
	mv typecheck1:/^\tcase ir.OTINTER:/+2,/^\tcase /-2 tcInterfaceType
	add typecheck.go:/^func tcInterfaceType/-0 \
		// tcInterfaceType typechecks an OTINTER node.
	mv typecheck1:/^\tcase ir.OTSTRUCT:/+2,/^\tcase /-2 tcStructType
	add typecheck.go:/^func tcStructType/-0 \
		// tcStructType typechecks an OTSTRUCT node.
	mv typecheck1:/^\tcase ir.OTCHAN:/+2,/^\tcase /-2 tcChanType
	add typecheck.go:/^func tcChanType/-0 \
		// tcChanType typechecks an OTCHAN node.
	mv typecheck1:/^\tcase ir.OTMAP:/+2,/^\tcase /-2 tcMapType
	add typecheck.go:/^func tcMapType/-0 \
		// tcMapType typechecks an OTMAP node.
	mv typecheck1:/^\tcase ir.OTARRAY:/+2,/^\tcase /-2 tcArrayType
	add typecheck.go:/^func tcArrayType/-0 \
		// tcArrayType typechecks an OTARRAY node.
	mv typecheck1:/^\tcase ir.OTSLICE:/+2,/^\tcase /-2 tcSliceType
	add typecheck.go:/^func tcSliceType/-0 \
		// tcSliceType typechecks an OTSLICE node.
	mv \
		tcAssign \
		tcAssignList \
		tcFor \
		tcGoDefer \
		tcIf \
		tcRange \
		tcReturn \
		tcSelect \
		tcSend \
		tcSwitch \
		tcSwitchExpr \
		tcSwitchType \
		typeSet \
		typeSetEntry \
		typeSet.add \
		stmt1.go
	mv stmt1.go stmt.go

	mv \
		tcAddr \
		tcArith \
		tcArrayType \
		tcChanType \
		tcClosure \
		tcCompLit \
		tcConv \
		tcDot \
		tcDotType \
		tcFuncType \
		tcITab \
		tcIndex \
		tcInterfaceType \
		tcLenCap \
		tcMapType \
		tcRecv \
		tcSPtr \
		tcSlice \
		tcSliceHeader \
		tcSliceType \
		tcStar \
		tcStructType \
		tcUnaryArith \
		expr.go

	mv \
		tcClosure \
		tcCallPart \
		tcFunc \
		tcCall \
		tcAppend \
		tcClose \
		tcComplex \
		tcCopy \
		tcDelete \
		tcMake \
		tcMakeSliceCopy \
		tcNew \
		tcPanic \
		tcPrint \
		tcRealImag \
		tcRecover \
		func1.go
	mv func1.go func.go

	mv \
		tcArrayType \
		tcChanType \
		tcFuncType \
		tcInterfaceType \
		tcMapType \
		tcSliceType \
		tcStructType \
		type.go
'

Change-Id: I0fb0a3039005bc1783575291daff1e6c306895ff
Reviewed-on: https://go-review.googlesource.com/c/go/+/279429
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/typecheck/expr.go    | 1001 ++++++++
 src/cmd/compile/internal/typecheck/func.go    |  753 +++++-
 src/cmd/compile/internal/typecheck/stmt.go    |  433 +++-
 src/cmd/compile/internal/typecheck/subr.go    |    2 +-
 src/cmd/compile/internal/typecheck/type.go    |  122 +
 .../compile/internal/typecheck/typecheck.go   | 2036 +----------------
 6 files changed, 2281 insertions(+), 2066 deletions(-)
 create mode 100644 src/cmd/compile/internal/typecheck/expr.go
 create mode 100644 src/cmd/compile/internal/typecheck/type.go

diff --git a/src/cmd/compile/internal/typecheck/expr.go b/src/cmd/compile/internal/typecheck/expr.go
new file mode 100644
index 0000000000..f940a2e73d
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/expr.go
@@ -0,0 +1,1001 @@
+// Copyright 2009 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 typecheck
+
+import (
+	"fmt"
+	"go/constant"
+	"go/token"
+	"strings"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
+)
+
+// tcAddr typechecks an OADDR node.
+func tcAddr(n *ir.AddrExpr) ir.Node {
+	n.X = Expr(n.X)
+	if n.X.Type() == nil {
+		n.SetType(nil)
+		return n
+	}
+
+	switch n.X.Op() {
+	case ir.OARRAYLIT, ir.OMAPLIT, ir.OSLICELIT, ir.OSTRUCTLIT:
+		n.SetOp(ir.OPTRLIT)
+
+	default:
+		checklvalue(n.X, "take the address of")
+		r := ir.OuterValue(n.X)
+		if r.Op() == ir.ONAME {
+			r := r.(*ir.Name)
+			if ir.Orig(r) != r {
+				base.Fatalf("found non-orig name node %v", r) // TODO(mdempsky): What does this mean?
+			}
+			r.Name().SetAddrtaken(true)
+			if r.Name().IsClosureVar() && !CaptureVarsComplete {
+				// Mark the original variable as Addrtaken so that capturevars
+				// knows not to pass it by value.
+				// But if the capturevars phase is complete, don't touch it,
+				// in case l.Name's containing function has not yet been compiled.
+				r.Name().Defn.Name().SetAddrtaken(true)
+			}
+		}
+		n.X = DefaultLit(n.X, nil)
+		if n.X.Type() == nil {
+			n.SetType(nil)
+			return n
+		}
+	}
+
+	n.SetType(types.NewPtr(n.X.Type()))
+	return n
+}
+
+// tcArith typechecks a binary arithmetic expression.
+func tcArith(n ir.Node) ir.Node {
+	var l, r ir.Node
+	var setLR func()
+	switch n := n.(type) {
+	case *ir.AssignOpStmt:
+		l, r = n.X, n.Y
+		setLR = func() { n.X = l; n.Y = r }
+	case *ir.BinaryExpr:
+		l, r = n.X, n.Y
+		setLR = func() { n.X = l; n.Y = r }
+	case *ir.LogicalExpr:
+		l, r = n.X, n.Y
+		setLR = func() { n.X = l; n.Y = r }
+	}
+	l = Expr(l)
+	r = Expr(r)
+	setLR()
+	if l.Type() == nil || r.Type() == nil {
+		n.SetType(nil)
+		return n
+	}
+	op := n.Op()
+	if n.Op() == ir.OASOP {
+		n := n.(*ir.AssignOpStmt)
+		checkassign(n, l)
+		if n.IncDec && !okforarith[l.Type().Kind()] {
+			base.Errorf("invalid operation: %v (non-numeric type %v)", n, l.Type())
+			n.SetType(nil)
+			return n
+		}
+		// TODO(marvin): Fix Node.EType type union.
+		op = n.AsOp
+	}
+	if op == ir.OLSH || op == ir.ORSH {
+		r = DefaultLit(r, types.Types[types.TUINT])
+		setLR()
+		t := r.Type()
+		if !t.IsInteger() {
+			base.Errorf("invalid operation: %v (shift count type %v, must be integer)", n, r.Type())
+			n.SetType(nil)
+			return n
+		}
+		if t.IsSigned() && !types.AllowsGoVersion(curpkg(), 1, 13) {
+			base.ErrorfVers("go1.13", "invalid operation: %v (signed shift count type %v)", n, r.Type())
+			n.SetType(nil)
+			return n
+		}
+		t = l.Type()
+		if t != nil && t.Kind() != types.TIDEAL && !t.IsInteger() {
+			base.Errorf("invalid operation: %v (shift of type %v)", n, t)
+			n.SetType(nil)
+			return n
+		}
+
+		// no defaultlit for left
+		// the outer context gives the type
+		n.SetType(l.Type())
+		if (l.Type() == types.UntypedFloat || l.Type() == types.UntypedComplex) && r.Op() == ir.OLITERAL {
+			n.SetType(types.UntypedInt)
+		}
+		return n
+	}
+
+	// For "x == x && len(s)", it's better to report that "len(s)" (type int)
+	// can't be used with "&&" than to report that "x == x" (type untyped bool)
+	// can't be converted to int (see issue #41500).
+	if n.Op() == ir.OANDAND || n.Op() == ir.OOROR {
+		n := n.(*ir.LogicalExpr)
+		if !n.X.Type().IsBoolean() {
+			base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op(), typekind(n.X.Type()))
+			n.SetType(nil)
+			return n
+		}
+		if !n.Y.Type().IsBoolean() {
+			base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op(), typekind(n.Y.Type()))
+			n.SetType(nil)
+			return n
+		}
+	}
+
+	// ideal mixed with non-ideal
+	l, r = defaultlit2(l, r, false)
+	setLR()
+
+	if l.Type() == nil || r.Type() == nil {
+		n.SetType(nil)
+		return n
+	}
+	t := l.Type()
+	if t.Kind() == types.TIDEAL {
+		t = r.Type()
+	}
+	et := t.Kind()
+	if et == types.TIDEAL {
+		et = types.TINT
+	}
+	aop := ir.OXXX
+	if iscmp[n.Op()] && t.Kind() != types.TIDEAL && !types.Identical(l.Type(), r.Type()) {
+		// comparison is okay as long as one side is
+		// assignable to the other.  convert so they have
+		// the same type.
+		//
+		// the only conversion that isn't a no-op is concrete == interface.
+		// in that case, check comparability of the concrete type.
+		// The conversion allocates, so only do it if the concrete type is huge.
+		converted := false
+		if r.Type().Kind() != types.TBLANK {
+			aop, _ = assignop(l.Type(), r.Type())
+			if aop != ir.OXXX {
+				if r.Type().IsInterface() && !l.Type().IsInterface() && !types.IsComparable(l.Type()) {
+					base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(l.Type()))
+					n.SetType(nil)
+					return n
+				}
+
+				types.CalcSize(l.Type())
+				if r.Type().IsInterface() == l.Type().IsInterface() || l.Type().Width >= 1<<16 {
+					l = ir.NewConvExpr(base.Pos, aop, r.Type(), l)
+					l.SetTypecheck(1)
+					setLR()
+				}
+
+				t = r.Type()
+				converted = true
+			}
+		}
+
+		if !converted && l.Type().Kind() != types.TBLANK {
+			aop, _ = assignop(r.Type(), l.Type())
+			if aop != ir.OXXX {
+				if l.Type().IsInterface() && !r.Type().IsInterface() && !types.IsComparable(r.Type()) {
+					base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(r.Type()))
+					n.SetType(nil)
+					return n
+				}
+
+				types.CalcSize(r.Type())
+				if r.Type().IsInterface() == l.Type().IsInterface() || r.Type().Width >= 1<<16 {
+					r = ir.NewConvExpr(base.Pos, aop, l.Type(), r)
+					r.SetTypecheck(1)
+					setLR()
+				}
+
+				t = l.Type()
+			}
+		}
+
+		et = t.Kind()
+	}
+
+	if t.Kind() != types.TIDEAL && !types.Identical(l.Type(), r.Type()) {
+		l, r = defaultlit2(l, r, true)
+		if l.Type() == nil || r.Type() == nil {
+			n.SetType(nil)
+			return n
+		}
+		if l.Type().IsInterface() == r.Type().IsInterface() || aop == 0 {
+			base.Errorf("invalid operation: %v (mismatched types %v and %v)", n, l.Type(), r.Type())
+			n.SetType(nil)
+			return n
+		}
+	}
+
+	if t.Kind() == types.TIDEAL {
+		t = mixUntyped(l.Type(), r.Type())
+	}
+	if dt := defaultType(t); !okfor[op][dt.Kind()] {
+		base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(t))
+		n.SetType(nil)
+		return n
+	}
+
+	// okfor allows any array == array, map == map, func == func.
+	// restrict to slice/map/func == nil and nil == slice/map/func.
+	if l.Type().IsArray() && !types.IsComparable(l.Type()) {
+		base.Errorf("invalid operation: %v (%v cannot be compared)", n, l.Type())
+		n.SetType(nil)
+		return n
+	}
+
+	if l.Type().IsSlice() && !ir.IsNil(l) && !ir.IsNil(r) {
+		base.Errorf("invalid operation: %v (slice can only be compared to nil)", n)
+		n.SetType(nil)
+		return n
+	}
+
+	if l.Type().IsMap() && !ir.IsNil(l) && !ir.IsNil(r) {
+		base.Errorf("invalid operation: %v (map can only be compared to nil)", n)
+		n.SetType(nil)
+		return n
+	}
+
+	if l.Type().Kind() == types.TFUNC && !ir.IsNil(l) && !ir.IsNil(r) {
+		base.Errorf("invalid operation: %v (func can only be compared to nil)", n)
+		n.SetType(nil)
+		return n
+	}
+
+	if l.Type().IsStruct() {
+		if f := types.IncomparableField(l.Type()); f != nil {
+			base.Errorf("invalid operation: %v (struct containing %v cannot be compared)", n, f.Type)
+			n.SetType(nil)
+			return n
+		}
+	}
+
+	if iscmp[n.Op()] {
+		t = types.UntypedBool
+		n.SetType(t)
+		if con := EvalConst(n); con.Op() == ir.OLITERAL {
+			return con
+		}
+		l, r = defaultlit2(l, r, true)
+		setLR()
+		return n
+	}
+
+	if et == types.TSTRING && n.Op() == ir.OADD {
+		// create or update OADDSTR node with list of strings in x + y + z + (w + v) + ...
+		n := n.(*ir.BinaryExpr)
+		var add *ir.AddStringExpr
+		if l.Op() == ir.OADDSTR {
+			add = l.(*ir.AddStringExpr)
+			add.SetPos(n.Pos())
+		} else {
+			add = ir.NewAddStringExpr(n.Pos(), []ir.Node{l})
+		}
+		if r.Op() == ir.OADDSTR {
+			r := r.(*ir.AddStringExpr)
+			add.List.Append(r.List.Take()...)
+		} else {
+			add.List.Append(r)
+		}
+		add.SetType(t)
+		return add
+	}
+
+	if (op == ir.ODIV || op == ir.OMOD) && ir.IsConst(r, constant.Int) {
+		if constant.Sign(r.Val()) == 0 {
+			base.Errorf("division by zero")
+			n.SetType(nil)
+			return n
+		}
+	}
+
+	n.SetType(t)
+	return n
+}
+
+// The result of tcCompLit MUST be assigned back to n, e.g.
+// 	n.Left = tcCompLit(n.Left)
+func tcCompLit(n *ir.CompLitExpr) (res ir.Node) {
+	if base.EnableTrace && base.Flag.LowerT {
+		defer tracePrint("typecheckcomplit", n)(&res)
+	}
+
+	lno := base.Pos
+	defer func() {
+		base.Pos = lno
+	}()
+
+	if n.Ntype == nil {
+		base.ErrorfAt(n.Pos(), "missing type in composite literal")
+		n.SetType(nil)
+		return n
+	}
+
+	// Save original node (including n.Right)
+	n.SetOrig(ir.Copy(n))
+
+	ir.SetPos(n.Ntype)
+
+	// Need to handle [...]T arrays specially.
+	if array, ok := n.Ntype.(*ir.ArrayType); ok && array.Elem != nil && array.Len == nil {
+		array.Elem = typecheck(array.Elem, ctxType)
+		elemType := array.Elem.Type()
+		if elemType == nil {
+			n.SetType(nil)
+			return n
+		}
+		length := typecheckarraylit(elemType, -1, n.List, "array literal")
+		n.SetOp(ir.OARRAYLIT)
+		n.SetType(types.NewArray(elemType, length))
+		n.Ntype = nil
+		return n
+	}
+
+	n.Ntype = ir.Node(typecheck(n.Ntype, ctxType)).(ir.Ntype)
+	t := n.Ntype.Type()
+	if t == nil {
+		n.SetType(nil)
+		return n
+	}
+	n.SetType(t)
+
+	switch t.Kind() {
+	default:
+		base.Errorf("invalid composite literal type %v", t)
+		n.SetType(nil)
+
+	case types.TARRAY:
+		typecheckarraylit(t.Elem(), t.NumElem(), n.List, "array literal")
+		n.SetOp(ir.OARRAYLIT)
+		n.Ntype = nil
+
+	case types.TSLICE:
+		length := typecheckarraylit(t.Elem(), -1, n.List, "slice literal")
+		n.SetOp(ir.OSLICELIT)
+		n.Ntype = nil
+		n.Len = length
+
+	case types.TMAP:
+		var cs constSet
+		for i3, l := range n.List {
+			ir.SetPos(l)
+			if l.Op() != ir.OKEY {
+				n.List[i3] = Expr(l)
+				base.Errorf("missing key in map literal")
+				continue
+			}
+			l := l.(*ir.KeyExpr)
+
+			r := l.Key
+			r = pushtype(r, t.Key())
+			r = Expr(r)
+			l.Key = AssignConv(r, t.Key(), "map key")
+			cs.add(base.Pos, l.Key, "key", "map literal")
+
+			r = l.Value
+			r = pushtype(r, t.Elem())
+			r = Expr(r)
+			l.Value = AssignConv(r, t.Elem(), "map value")
+		}
+
+		n.SetOp(ir.OMAPLIT)
+		n.Ntype = nil
+
+	case types.TSTRUCT:
+		// Need valid field offsets for Xoffset below.
+		types.CalcSize(t)
+
+		errored := false
+		if len(n.List) != 0 && nokeys(n.List) {
+			// simple list of variables
+			ls := n.List
+			for i, n1 := range ls {
+				ir.SetPos(n1)
+				n1 = Expr(n1)
+				ls[i] = n1
+				if i >= t.NumFields() {
+					if !errored {
+						base.Errorf("too many values in %v", n)
+						errored = true
+					}
+					continue
+				}
+
+				f := t.Field(i)
+				s := f.Sym
+				if s != nil && !types.IsExported(s.Name) && s.Pkg != types.LocalPkg {
+					base.Errorf("implicit assignment of unexported field '%s' in %v literal", s.Name, t)
+				}
+				// No pushtype allowed here. Must name fields for that.
+				n1 = AssignConv(n1, f.Type, "field value")
+				sk := ir.NewStructKeyExpr(base.Pos, f.Sym, n1)
+				sk.Offset = f.Offset
+				ls[i] = sk
+			}
+			if len(ls) < t.NumFields() {
+				base.Errorf("too few values in %v", n)
+			}
+		} else {
+			hash := make(map[string]bool)
+
+			// keyed list
+			ls := n.List
+			for i, l := range ls {
+				ir.SetPos(l)
+
+				if l.Op() == ir.OKEY {
+					kv := l.(*ir.KeyExpr)
+					key := kv.Key
+
+					// Sym might have resolved to name in other top-level
+					// package, because of import dot. Redirect to correct sym
+					// before we do the lookup.
+					s := key.Sym()
+					if id, ok := key.(*ir.Ident); ok && DotImportRefs[id] != nil {
+						s = Lookup(s.Name)
+					}
+
+					// An OXDOT uses the Sym field to hold
+					// the field to the right of the dot,
+					// so s will be non-nil, but an OXDOT
+					// is never a valid struct literal key.
+					if s == nil || s.Pkg != types.LocalPkg || key.Op() == ir.OXDOT || s.IsBlank() {
+						base.Errorf("invalid field name %v in struct initializer", key)
+						continue
+					}
+
+					l = ir.NewStructKeyExpr(l.Pos(), s, kv.Value)
+					ls[i] = l
+				}
+
+				if l.Op() != ir.OSTRUCTKEY {
+					if !errored {
+						base.Errorf("mixture of field:value and value initializers")
+						errored = true
+					}
+					ls[i] = Expr(ls[i])
+					continue
+				}
+				l := l.(*ir.StructKeyExpr)
+
+				f := lookdot1(nil, l.Field, t, t.Fields(), 0)
+				if f == nil {
+					if ci := lookdot1(nil, l.Field, t, t.Fields(), 2); ci != nil { // Case-insensitive lookup.
+						if visible(ci.Sym) {
+							base.Errorf("unknown field '%v' in struct literal of type %v (but does have %v)", l.Field, t, ci.Sym)
+						} else if nonexported(l.Field) && l.Field.Name == ci.Sym.Name { // Ensure exactness before the suggestion.
+							base.Errorf("cannot refer to unexported field '%v' in struct literal of type %v", l.Field, t)
+						} else {
+							base.Errorf("unknown field '%v' in struct literal of type %v", l.Field, t)
+						}
+						continue
+					}
+					var f *types.Field
+					p, _ := dotpath(l.Field, t, &f, true)
+					if p == nil || f.IsMethod() {
+						base.Errorf("unknown field '%v' in struct literal of type %v", l.Field, t)
+						continue
+					}
+					// dotpath returns the parent embedded types in reverse order.
+					var ep []string
+					for ei := len(p) - 1; ei >= 0; ei-- {
+						ep = append(ep, p[ei].field.Sym.Name)
+					}
+					ep = append(ep, l.Field.Name)
+					base.Errorf("cannot use promoted field %v in struct literal of type %v", strings.Join(ep, "."), t)
+					continue
+				}
+				fielddup(f.Sym.Name, hash)
+				l.Offset = f.Offset
+
+				// No pushtype allowed here. Tried and rejected.
+				l.Value = Expr(l.Value)
+				l.Value = AssignConv(l.Value, f.Type, "field value")
+			}
+		}
+
+		n.SetOp(ir.OSTRUCTLIT)
+		n.Ntype = nil
+	}
+
+	return n
+}
+
+// tcConv typechecks an OCONV node.
+func tcConv(n *ir.ConvExpr) ir.Node {
+	types.CheckSize(n.Type()) // ensure width is calculated for backend
+	n.X = Expr(n.X)
+	n.X = convlit1(n.X, n.Type(), true, nil)
+	t := n.X.Type()
+	if t == nil || n.Type() == nil {
+		n.SetType(nil)
+		return n
+	}
+	op, why := convertop(n.X.Op() == ir.OLITERAL, t, n.Type())
+	if op == ir.OXXX {
+		if !n.Diag() && !n.Type().Broke() && !n.X.Diag() {
+			base.Errorf("cannot convert %L to type %v%s", n.X, n.Type(), why)
+			n.SetDiag(true)
+		}
+		n.SetOp(ir.OCONV)
+		n.SetType(nil)
+		return n
+	}
+
+	n.SetOp(op)
+	switch n.Op() {
+	case ir.OCONVNOP:
+		if t.Kind() == n.Type().Kind() {
+			switch t.Kind() {
+			case types.TFLOAT32, types.TFLOAT64, types.TCOMPLEX64, types.TCOMPLEX128:
+				// Floating point casts imply rounding and
+				// so the conversion must be kept.
+				n.SetOp(ir.OCONV)
+			}
+		}
+
+	// do not convert to []byte literal. See CL 125796.
+	// generated code and compiler memory footprint is better without it.
+	case ir.OSTR2BYTES:
+		// ok
+
+	case ir.OSTR2RUNES:
+		if n.X.Op() == ir.OLITERAL {
+			return stringtoruneslit(n)
+		}
+	}
+	return n
+}
+
+// tcDot typechecks an OXDOT or ODOT node.
+func tcDot(n *ir.SelectorExpr, top int) ir.Node {
+	if n.Op() == ir.OXDOT {
+		n = AddImplicitDots(n)
+		n.SetOp(ir.ODOT)
+		if n.X == nil {
+			n.SetType(nil)
+			return n
+		}
+	}
+
+	n.X = typecheck(n.X, ctxExpr|ctxType)
+
+	n.X = DefaultLit(n.X, nil)
+
+	t := n.X.Type()
+	if t == nil {
+		base.UpdateErrorDot(ir.Line(n), fmt.Sprint(n.X), fmt.Sprint(n))
+		n.SetType(nil)
+		return n
+	}
+
+	s := n.Sel
+
+	if n.X.Op() == ir.OTYPE {
+		return typecheckMethodExpr(n)
+	}
+
+	if t.IsPtr() && !t.Elem().IsInterface() {
+		t = t.Elem()
+		if t == nil {
+			n.SetType(nil)
+			return n
+		}
+		n.SetOp(ir.ODOTPTR)
+		types.CheckSize(t)
+	}
+
+	if n.Sel.IsBlank() {
+		base.Errorf("cannot refer to blank field or method")
+		n.SetType(nil)
+		return n
+	}
+
+	if lookdot(n, t, 0) == nil {
+		// Legitimate field or method lookup failed, try to explain the error
+		switch {
+		case t.IsEmptyInterface():
+			base.Errorf("%v undefined (type %v is interface with no methods)", n, n.X.Type())
+
+		case t.IsPtr() && t.Elem().IsInterface():
+			// Pointer to interface is almost always a mistake.
+			base.Errorf("%v undefined (type %v is pointer to interface, not interface)", n, n.X.Type())
+
+		case lookdot(n, t, 1) != nil:
+			// Field or method matches by name, but it is not exported.
+			base.Errorf("%v undefined (cannot refer to unexported field or method %v)", n, n.Sel)
+
+		default:
+			if mt := lookdot(n, t, 2); mt != nil && visible(mt.Sym) { // Case-insensitive lookup.
+				base.Errorf("%v undefined (type %v has no field or method %v, but does have %v)", n, n.X.Type(), n.Sel, mt.Sym)
+			} else {
+				base.Errorf("%v undefined (type %v has no field or method %v)", n, n.X.Type(), n.Sel)
+			}
+		}
+		n.SetType(nil)
+		return n
+	}
+
+	if (n.Op() == ir.ODOTINTER || n.Op() == ir.ODOTMETH) && top&ctxCallee == 0 {
+		return tcCallPart(n, s)
+	}
+	return n
+}
+
+// tcDotType typechecks an ODOTTYPE node.
+func tcDotType(n *ir.TypeAssertExpr) ir.Node {
+	n.X = Expr(n.X)
+	n.X = DefaultLit(n.X, nil)
+	l := n.X
+	t := l.Type()
+	if t == nil {
+		n.SetType(nil)
+		return n
+	}
+	if !t.IsInterface() {
+		base.Errorf("invalid type assertion: %v (non-interface type %v on left)", n, t)
+		n.SetType(nil)
+		return n
+	}
+
+	if n.Ntype != nil {
+		n.Ntype = typecheck(n.Ntype, ctxType)
+		n.SetType(n.Ntype.Type())
+		n.Ntype = nil
+		if n.Type() == nil {
+			return n
+		}
+	}
+
+	if n.Type() != nil && !n.Type().IsInterface() {
+		var missing, have *types.Field
+		var ptr int
+		if !implements(n.Type(), t, &missing, &have, &ptr) {
+			if have != nil && have.Sym == missing.Sym {
+				base.Errorf("impossible type assertion:\n\t%v does not implement %v (wrong type for %v method)\n"+
+					"\t\thave %v%S\n\t\twant %v%S", n.Type(), t, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
+			} else if ptr != 0 {
+				base.Errorf("impossible type assertion:\n\t%v does not implement %v (%v method has pointer receiver)", n.Type(), t, missing.Sym)
+			} else if have != nil {
+				base.Errorf("impossible type assertion:\n\t%v does not implement %v (missing %v method)\n"+
+					"\t\thave %v%S\n\t\twant %v%S", n.Type(), t, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
+			} else {
+				base.Errorf("impossible type assertion:\n\t%v does not implement %v (missing %v method)", n.Type(), t, missing.Sym)
+			}
+			n.SetType(nil)
+			return n
+		}
+	}
+	return n
+}
+
+// tcITab typechecks an OITAB node.
+func tcITab(n *ir.UnaryExpr) ir.Node {
+	n.X = Expr(n.X)
+	t := n.X.Type()
+	if t == nil {
+		n.SetType(nil)
+		return n
+	}
+	if !t.IsInterface() {
+		base.Fatalf("OITAB of %v", t)
+	}
+	n.SetType(types.NewPtr(types.Types[types.TUINTPTR]))
+	return n
+}
+
+// tcIndex typechecks an OINDEX node.
+func tcIndex(n *ir.IndexExpr) ir.Node {
+	n.X = Expr(n.X)
+	n.X = DefaultLit(n.X, nil)
+	n.X = implicitstar(n.X)
+	l := n.X
+	n.Index = Expr(n.Index)
+	r := n.Index
+	t := l.Type()
+	if t == nil || r.Type() == nil {
+		n.SetType(nil)
+		return n
+	}
+	switch t.Kind() {
+	default:
+		base.Errorf("invalid operation: %v (type %v does not support indexing)", n, t)
+		n.SetType(nil)
+		return n
+
+	case types.TSTRING, types.TARRAY, types.TSLICE:
+		n.Index = indexlit(n.Index)
+		if t.IsString() {
+			n.SetType(types.ByteType)
+		} else {
+			n.SetType(t.Elem())
+		}
+		why := "string"
+		if t.IsArray() {
+			why = "array"
+		} else if t.IsSlice() {
+			why = "slice"
+		}
+
+		if n.Index.Type() != nil && !n.Index.Type().IsInteger() {
+			base.Errorf("non-integer %s index %v", why, n.Index)
+			return n
+		}
+
+		if !n.Bounded() && ir.IsConst(n.Index, constant.Int) {
+			x := n.Index.Val()
+			if constant.Sign(x) < 0 {
+				base.Errorf("invalid %s index %v (index must be non-negative)", why, n.Index)
+			} else if t.IsArray() && constant.Compare(x, token.GEQ, constant.MakeInt64(t.NumElem())) {
+				base.Errorf("invalid array index %v (out of bounds for %d-element array)", n.Index, t.NumElem())
+			} else if ir.IsConst(n.X, constant.String) && constant.Compare(x, token.GEQ, constant.MakeInt64(int64(len(ir.StringVal(n.X))))) {
+				base.Errorf("invalid string index %v (out of bounds for %d-byte string)", n.Index, len(ir.StringVal(n.X)))
+			} else if ir.ConstOverflow(x, types.Types[types.TINT]) {
+				base.Errorf("invalid %s index %v (index too large)", why, n.Index)
+			}
+		}
+
+	case types.TMAP:
+		n.Index = AssignConv(n.Index, t.Key(), "map index")
+		n.SetType(t.Elem())
+		n.SetOp(ir.OINDEXMAP)
+		n.Assigned = false
+	}
+	return n
+}
+
+// tcLenCap typechecks an OLEN or OCAP node.
+func tcLenCap(n *ir.UnaryExpr) ir.Node {
+	n.X = Expr(n.X)
+	n.X = DefaultLit(n.X, nil)
+	n.X = implicitstar(n.X)
+	l := n.X
+	t := l.Type()
+	if t == nil {
+		n.SetType(nil)
+		return n
+	}
+
+	var ok bool
+	if n.Op() == ir.OLEN {
+		ok = okforlen[t.Kind()]
+	} else {
+		ok = okforcap[t.Kind()]
+	}
+	if !ok {
+		base.Errorf("invalid argument %L for %v", l, n.Op())
+		n.SetType(nil)
+		return n
+	}
+
+	n.SetType(types.Types[types.TINT])
+	return n
+}
+
+// tcRecv typechecks an ORECV node.
+func tcRecv(n *ir.UnaryExpr) ir.Node {
+	n.X = Expr(n.X)
+	n.X = DefaultLit(n.X, nil)
+	l := n.X
+	t := l.Type()
+	if t == nil {
+		n.SetType(nil)
+		return n
+	}
+	if !t.IsChan() {
+		base.Errorf("invalid operation: %v (receive from non-chan type %v)", n, t)
+		n.SetType(nil)
+		return n
+	}
+
+	if !t.ChanDir().CanRecv() {
+		base.Errorf("invalid operation: %v (receive from send-only type %v)", n, t)
+		n.SetType(nil)
+		return n
+	}
+
+	n.SetType(t.Elem())
+	return n
+}
+
+// tcSPtr typechecks an OSPTR node.
+func tcSPtr(n *ir.UnaryExpr) ir.Node {
+	n.X = Expr(n.X)
+	t := n.X.Type()
+	if t == nil {
+		n.SetType(nil)
+		return n
+	}
+	if !t.IsSlice() && !t.IsString() {
+		base.Fatalf("OSPTR of %v", t)
+	}
+	if t.IsString() {
+		n.SetType(types.NewPtr(types.Types[types.TUINT8]))
+	} else {
+		n.SetType(types.NewPtr(t.Elem()))
+	}
+	return n
+}
+
+// tcSlice typechecks an OSLICE or OSLICE3 node.
+func tcSlice(n *ir.SliceExpr) ir.Node {
+	n.X = Expr(n.X)
+	low, high, max := n.SliceBounds()
+	hasmax := n.Op().IsSlice3()
+	low = Expr(low)
+	high = Expr(high)
+	max = Expr(max)
+	n.X = DefaultLit(n.X, nil)
+	low = indexlit(low)
+	high = indexlit(high)
+	max = indexlit(max)
+	n.SetSliceBounds(low, high, max)
+	l := n.X
+	if l.Type() == nil {
+		n.SetType(nil)
+		return n
+	}
+	if l.Type().IsArray() {
+		if !ir.IsAssignable(n.X) {
+			base.Errorf("invalid operation %v (slice of unaddressable value)", n)
+			n.SetType(nil)
+			return n
+		}
+
+		addr := NodAddr(n.X)
+		addr.SetImplicit(true)
+		n.X = Expr(addr)
+		l = n.X
+	}
+	t := l.Type()
+	var tp *types.Type
+	if t.IsString() {
+		if hasmax {
+			base.Errorf("invalid operation %v (3-index slice of string)", n)
+			n.SetType(nil)
+			return n
+		}
+		n.SetType(t)
+		n.SetOp(ir.OSLICESTR)
+	} else if t.IsPtr() && t.Elem().IsArray() {
+		tp = t.Elem()
+		n.SetType(types.NewSlice(tp.Elem()))
+		types.CalcSize(n.Type())
+		if hasmax {
+			n.SetOp(ir.OSLICE3ARR)
+		} else {
+			n.SetOp(ir.OSLICEARR)
+		}
+	} else if t.IsSlice() {
+		n.SetType(t)
+	} else {
+		base.Errorf("cannot slice %v (type %v)", l, t)
+		n.SetType(nil)
+		return n
+	}
+
+	if low != nil && !checksliceindex(l, low, tp) {
+		n.SetType(nil)
+		return n
+	}
+	if high != nil && !checksliceindex(l, high, tp) {
+		n.SetType(nil)
+		return n
+	}
+	if max != nil && !checksliceindex(l, max, tp) {
+		n.SetType(nil)
+		return n
+	}
+	if !checksliceconst(low, high) || !checksliceconst(low, max) || !checksliceconst(high, max) {
+		n.SetType(nil)
+		return n
+	}
+	return n
+}
+
+// tcSliceHeader typechecks an OSLICEHEADER node.
+func tcSliceHeader(n *ir.SliceHeaderExpr) ir.Node {
+	// Errors here are Fatalf instead of Errorf because only the compiler
+	// can construct an OSLICEHEADER node.
+	// Components used in OSLICEHEADER that are supplied by parsed source code
+	// have already been typechecked in e.g. OMAKESLICE earlier.
+	t := n.Type()
+	if t == nil {
+		base.Fatalf("no type specified for OSLICEHEADER")
+	}
+
+	if !t.IsSlice() {
+		base.Fatalf("invalid type %v for OSLICEHEADER", n.Type())
+	}
+
+	if n.Ptr == nil || n.Ptr.Type() == nil || !n.Ptr.Type().IsUnsafePtr() {
+		base.Fatalf("need unsafe.Pointer for OSLICEHEADER")
+	}
+
+	if x := len(n.LenCap); x != 2 {
+		base.Fatalf("expected 2 params (len, cap) for OSLICEHEADER, got %d", x)
+	}
+
+	n.Ptr = Expr(n.Ptr)
+	l := Expr(n.LenCap[0])
+	c := Expr(n.LenCap[1])
+	l = DefaultLit(l, types.Types[types.TINT])
+	c = DefaultLit(c, types.Types[types.TINT])
+
+	if ir.IsConst(l, constant.Int) && ir.Int64Val(l) < 0 {
+		base.Fatalf("len for OSLICEHEADER must be non-negative")
+	}
+
+	if ir.IsConst(c, constant.Int) && ir.Int64Val(c) < 0 {
+		base.Fatalf("cap for OSLICEHEADER must be non-negative")
+	}
+
+	if ir.IsConst(l, constant.Int) && ir.IsConst(c, constant.Int) && constant.Compare(l.Val(), token.GTR, c.Val()) {
+		base.Fatalf("len larger than cap for OSLICEHEADER")
+	}
+
+	n.LenCap[0] = l
+	n.LenCap[1] = c
+	return n
+}
+
+// tcStar typechecks an ODEREF node, which may be an expression or a type.
+func tcStar(n *ir.StarExpr, top int) ir.Node {
+	n.X = typecheck(n.X, ctxExpr|ctxType)
+	l := n.X
+	t := l.Type()
+	if t == nil {
+		n.SetType(nil)
+		return n
+	}
+	if l.Op() == ir.OTYPE {
+		n.SetOTYPE(types.NewPtr(l.Type()))
+		// Ensure l.Type gets dowidth'd for the backend. Issue 20174.
+		types.CheckSize(l.Type())
+		return n
+	}
+
+	if !t.IsPtr() {
+		if top&(ctxExpr|ctxStmt) != 0 {
+			base.Errorf("invalid indirect of %L", n.X)
+			n.SetType(nil)
+			return n
+		}
+		base.Errorf("%v is not a type", l)
+		return n
+	}
+
+	n.SetType(t.Elem())
+	return n
+}
+
+// tcUnaryArith typechecks a unary arithmetic expression.
+func tcUnaryArith(n *ir.UnaryExpr) ir.Node {
+	n.X = Expr(n.X)
+	l := n.X
+	t := l.Type()
+	if t == nil {
+		n.SetType(nil)
+		return n
+	}
+	if !okfor[n.Op()][defaultType(t).Kind()] {
+		base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op(), typekind(t))
+		n.SetType(nil)
+		return n
+	}
+
+	n.SetType(t)
+	return n
+}
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index 4675de6cad..99d81dcede 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -10,6 +10,8 @@ import (
 	"cmd/compile/internal/types"
 
 	"fmt"
+	"go/constant"
+	"go/token"
 )
 
 // package all the arguments that match a ... T parameter into a []T.
@@ -156,66 +158,6 @@ func CaptureVars(fn *ir.Func) {
 	base.Pos = lno
 }
 
-// typecheckclosure typechecks an OCLOSURE node. It also creates the named
-// function associated with the closure.
-// TODO: This creation of the named function should probably really be done in a
-// separate pass from type-checking.
-func typecheckclosure(clo *ir.ClosureExpr, top int) {
-	fn := clo.Func
-	// Set current associated iota value, so iota can be used inside
-	// function in ConstSpec, see issue #22344
-	if x := getIotaValue(); x >= 0 {
-		fn.Iota = x
-	}
-
-	fn.ClosureType = check(fn.ClosureType, ctxType)
-	clo.SetType(fn.ClosureType.Type())
-	fn.SetClosureCalled(top&ctxCallee != 0)
-
-	// Do not typecheck fn twice, otherwise, we will end up pushing
-	// fn to Target.Decls multiple times, causing initLSym called twice.
-	// See #30709
-	if fn.Typecheck() == 1 {
-		return
-	}
-
-	for _, ln := range fn.ClosureVars {
-		n := ln.Defn
-		if !n.Name().Captured() {
-			n.Name().SetCaptured(true)
-			if n.Name().Decldepth == 0 {
-				base.Fatalf("typecheckclosure: var %v does not have decldepth assigned", n)
-			}
-
-			// Ignore assignments to the variable in straightline code
-			// preceding the first capturing by a closure.
-			if n.Name().Decldepth == decldepth {
-				n.Name().SetAssigned(false)
-			}
-		}
-	}
-
-	fn.Nname.SetSym(closurename(ir.CurFunc))
-	ir.MarkFunc(fn.Nname)
-	Func(fn)
-
-	// Type check the body now, but only if we're inside a function.
-	// At top level (in a variable initialization: curfn==nil) we're not
-	// ready to type check code yet; we'll check it later, because the
-	// underlying closure function we create is added to Target.Decls.
-	if ir.CurFunc != nil && clo.Type() != nil {
-		oldfn := ir.CurFunc
-		ir.CurFunc = fn
-		olddd := decldepth
-		decldepth = 1
-		Stmts(fn.Body)
-		decldepth = olddd
-		ir.CurFunc = oldfn
-	}
-
-	Target.Decls = append(Target.Decls, fn)
-}
-
 // Lazy typechecking of imported bodies. For local functions, caninl will set ->typecheck
 // because they're a copy of an already checked body.
 func ImportedBody(fn *ir.Func) {
@@ -380,7 +322,67 @@ func makepartialcall(dot *ir.SelectorExpr, t0 *types.Type, meth *types.Sym) *ir.
 	return fn
 }
 
-func typecheckpartialcall(n ir.Node, sym *types.Sym) *ir.CallPartExpr {
+// tcClosure typechecks an OCLOSURE node. It also creates the named
+// function associated with the closure.
+// TODO: This creation of the named function should probably really be done in a
+// separate pass from type-checking.
+func tcClosure(clo *ir.ClosureExpr, top int) {
+	fn := clo.Func
+	// Set current associated iota value, so iota can be used inside
+	// function in ConstSpec, see issue #22344
+	if x := getIotaValue(); x >= 0 {
+		fn.Iota = x
+	}
+
+	fn.ClosureType = typecheck(fn.ClosureType, ctxType)
+	clo.SetType(fn.ClosureType.Type())
+	fn.SetClosureCalled(top&ctxCallee != 0)
+
+	// Do not typecheck fn twice, otherwise, we will end up pushing
+	// fn to Target.Decls multiple times, causing initLSym called twice.
+	// See #30709
+	if fn.Typecheck() == 1 {
+		return
+	}
+
+	for _, ln := range fn.ClosureVars {
+		n := ln.Defn
+		if !n.Name().Captured() {
+			n.Name().SetCaptured(true)
+			if n.Name().Decldepth == 0 {
+				base.Fatalf("typecheckclosure: var %v does not have decldepth assigned", n)
+			}
+
+			// Ignore assignments to the variable in straightline code
+			// preceding the first capturing by a closure.
+			if n.Name().Decldepth == decldepth {
+				n.Name().SetAssigned(false)
+			}
+		}
+	}
+
+	fn.Nname.SetSym(closurename(ir.CurFunc))
+	ir.MarkFunc(fn.Nname)
+	Func(fn)
+
+	// Type check the body now, but only if we're inside a function.
+	// At top level (in a variable initialization: curfn==nil) we're not
+	// ready to type check code yet; we'll check it later, because the
+	// underlying closure function we create is added to Target.Decls.
+	if ir.CurFunc != nil && clo.Type() != nil {
+		oldfn := ir.CurFunc
+		ir.CurFunc = fn
+		olddd := decldepth
+		decldepth = 1
+		Stmts(fn.Body)
+		decldepth = olddd
+		ir.CurFunc = oldfn
+	}
+
+	Target.Decls = append(Target.Decls, fn)
+}
+
+func tcCallPart(n ir.Node, sym *types.Sym) *ir.CallPartExpr {
 	switch n.Op() {
 	case ir.ODOTINTER, ir.ODOTMETH:
 		break
@@ -396,3 +398,632 @@ func typecheckpartialcall(n ir.Node, sym *types.Sym) *ir.CallPartExpr {
 
 	return ir.NewCallPartExpr(dot.Pos(), dot.X, dot.Selection, fn)
 }
+
+// type check function definition
+// To be called by typecheck, not directly.
+// (Call typecheckFunc instead.)
+func tcFunc(n *ir.Func) {
+	if base.EnableTrace && base.Flag.LowerT {
+		defer tracePrint("typecheckfunc", n)(nil)
+	}
+
+	for _, ln := range n.Dcl {
+		if ln.Op() == ir.ONAME && (ln.Class_ == ir.PPARAM || ln.Class_ == ir.PPARAMOUT) {
+			ln.Decldepth = 1
+		}
+	}
+
+	n.Nname = AssignExpr(n.Nname).(*ir.Name)
+	t := n.Nname.Type()
+	if t == nil {
+		return
+	}
+	n.SetType(t)
+	rcvr := t.Recv()
+	if rcvr != nil && n.Shortname != nil {
+		m := addmethod(n, n.Shortname, t, true, n.Pragma&ir.Nointerface != 0)
+		if m == nil {
+			return
+		}
+
+		n.Nname.SetSym(ir.MethodSym(rcvr.Type, n.Shortname))
+		Declare(n.Nname, ir.PFUNC)
+	}
+
+	if base.Ctxt.Flag_dynlink && !inimport && n.Nname != nil {
+		NeedFuncSym(n.Sym())
+	}
+}
+
+// tcCall typechecks an OCALL node.
+func tcCall(n *ir.CallExpr, top int) ir.Node {
+	n.Use = ir.CallUseExpr
+	if top == ctxStmt {
+		n.Use = ir.CallUseStmt
+	}
+	Stmts(n.Init()) // imported rewritten f(g()) calls (#30907)
+	n.X = typecheck(n.X, ctxExpr|ctxType|ctxCallee)
+	if n.X.Diag() {
+		n.SetDiag(true)
+	}
+
+	l := n.X
+
+	if l.Op() == ir.ONAME && l.(*ir.Name).BuiltinOp != 0 {
+		l := l.(*ir.Name)
+		if n.IsDDD && l.BuiltinOp != ir.OAPPEND {
+			base.Errorf("invalid use of ... with builtin %v", l)
+		}
+
+		// builtin: OLEN, OCAP, etc.
+		switch l.BuiltinOp {
+		default:
+			base.Fatalf("unknown builtin %v", l)
+
+		case ir.OAPPEND, ir.ODELETE, ir.OMAKE, ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
+			n.SetOp(l.BuiltinOp)
+			n.X = nil
+			n.SetTypecheck(0) // re-typechecking new op is OK, not a loop
+			return typecheck(n, top)
+
+		case ir.OCAP, ir.OCLOSE, ir.OIMAG, ir.OLEN, ir.OPANIC, ir.OREAL:
+			typecheckargs(n)
+			fallthrough
+		case ir.ONEW, ir.OALIGNOF, ir.OOFFSETOF, ir.OSIZEOF:
+			arg, ok := needOneArg(n, "%v", n.Op())
+			if !ok {
+				n.SetType(nil)
+				return n
+			}
+			u := ir.NewUnaryExpr(n.Pos(), l.BuiltinOp, arg)
+			return typecheck(ir.InitExpr(n.Init(), u), top) // typecheckargs can add to old.Init
+
+		case ir.OCOMPLEX, ir.OCOPY:
+			typecheckargs(n)
+			arg1, arg2, ok := needTwoArgs(n)
+			if !ok {
+				n.SetType(nil)
+				return n
+			}
+			b := ir.NewBinaryExpr(n.Pos(), l.BuiltinOp, arg1, arg2)
+			return typecheck(ir.InitExpr(n.Init(), b), top) // typecheckargs can add to old.Init
+		}
+		panic("unreachable")
+	}
+
+	n.X = DefaultLit(n.X, nil)
+	l = n.X
+	if l.Op() == ir.OTYPE {
+		if n.IsDDD {
+			if !l.Type().Broke() {
+				base.Errorf("invalid use of ... in type conversion to %v", l.Type())
+			}
+			n.SetDiag(true)
+		}
+
+		// pick off before type-checking arguments
+		arg, ok := needOneArg(n, "conversion to %v", l.Type())
+		if !ok {
+			n.SetType(nil)
+			return n
+		}
+
+		n := ir.NewConvExpr(n.Pos(), ir.OCONV, nil, arg)
+		n.SetType(l.Type())
+		return typecheck1(n, top)
+	}
+
+	typecheckargs(n)
+	t := l.Type()
+	if t == nil {
+		n.SetType(nil)
+		return n
+	}
+	types.CheckSize(t)
+
+	switch l.Op() {
+	case ir.ODOTINTER:
+		n.SetOp(ir.OCALLINTER)
+
+	case ir.ODOTMETH:
+		l := l.(*ir.SelectorExpr)
+		n.SetOp(ir.OCALLMETH)
+
+		// typecheckaste was used here but there wasn't enough
+		// information further down the call chain to know if we
+		// were testing a method receiver for unexported fields.
+		// It isn't necessary, so just do a sanity check.
+		tp := t.Recv().Type
+
+		if l.X == nil || !types.Identical(l.X.Type(), tp) {
+			base.Fatalf("method receiver")
+		}
+
+	default:
+		n.SetOp(ir.OCALLFUNC)
+		if t.Kind() != types.TFUNC {
+			// TODO(mdempsky): Remove "o.Sym() != nil" once we stop
+			// using ir.Name for numeric literals.
+			if o := ir.Orig(l); o.Name() != nil && o.Sym() != nil && types.BuiltinPkg.Lookup(o.Sym().Name).Def != nil {
+				// be more specific when the non-function
+				// name matches a predeclared function
+				base.Errorf("cannot call non-function %L, declared at %s",
+					l, base.FmtPos(o.Name().Pos()))
+			} else {
+				base.Errorf("cannot call non-function %L", l)
+			}
+			n.SetType(nil)
+			return n
+		}
+	}
+
+	typecheckaste(ir.OCALL, n.X, n.IsDDD, t.Params(), n.Args, func() string { return fmt.Sprintf("argument to %v", n.X) })
+	if t.NumResults() == 0 {
+		return n
+	}
+	if t.NumResults() == 1 {
+		n.SetType(l.Type().Results().Field(0).Type)
+
+		if n.Op() == ir.OCALLFUNC && n.X.Op() == ir.ONAME {
+			if sym := n.X.(*ir.Name).Sym(); types.IsRuntimePkg(sym.Pkg) && sym.Name == "getg" {
+				// Emit code for runtime.getg() directly instead of calling function.
+				// Most such rewrites (for example the similar one for math.Sqrt) should be done in walk,
+				// so that the ordering pass can make sure to preserve the semantics of the original code
+				// (in particular, the exact time of the function call) by introducing temporaries.
+				// In this case, we know getg() always returns the same result within a given function
+				// and we want to avoid the temporaries, so we do the rewrite earlier than is typical.
+				n.SetOp(ir.OGETG)
+			}
+		}
+		return n
+	}
+
+	// multiple return
+	if top&(ctxMultiOK|ctxStmt) == 0 {
+		base.Errorf("multiple-value %v() in single-value context", l)
+		return n
+	}
+
+	n.SetType(l.Type().Results())
+	return n
+}
+
+// tcAppend typechecks an OAPPEND node.
+func tcAppend(n *ir.CallExpr) ir.Node {
+	typecheckargs(n)
+	args := n.Args
+	if len(args) == 0 {
+		base.Errorf("missing arguments to append")
+		n.SetType(nil)
+		return n
+	}
+
+	t := args[0].Type()
+	if t == nil {
+		n.SetType(nil)
+		return n
+	}
+
+	n.SetType(t)
+	if !t.IsSlice() {
+		if ir.IsNil(args[0]) {
+			base.Errorf("first argument to append must be typed slice; have untyped nil")
+			n.SetType(nil)
+			return n
+		}
+
+		base.Errorf("first argument to append must be slice; have %L", t)
+		n.SetType(nil)
+		return n
+	}
+
+	if n.IsDDD {
+		if len(args) == 1 {
+			base.Errorf("cannot use ... on first argument to append")
+			n.SetType(nil)
+			return n
+		}
+
+		if len(args) != 2 {
+			base.Errorf("too many arguments to append")
+			n.SetType(nil)
+			return n
+		}
+
+		if t.Elem().IsKind(types.TUINT8) && args[1].Type().IsString() {
+			args[1] = DefaultLit(args[1], types.Types[types.TSTRING])
+			return n
+		}
+
+		args[1] = AssignConv(args[1], t.Underlying(), "append")
+		return n
+	}
+
+	as := args[1:]
+	for i, n := range as {
+		if n.Type() == nil {
+			continue
+		}
+		as[i] = AssignConv(n, t.Elem(), "append")
+		types.CheckSize(as[i].Type()) // ensure width is calculated for backend
+	}
+	return n
+}
+
+// tcClose typechecks an OCLOSE node.
+func tcClose(n *ir.UnaryExpr) ir.Node {
+	n.X = Expr(n.X)
+	n.X = DefaultLit(n.X, nil)
+	l := n.X
+	t := l.Type()
+	if t == nil {
+		n.SetType(nil)
+		return n
+	}
+	if !t.IsChan() {
+		base.Errorf("invalid operation: %v (non-chan type %v)", n, t)
+		n.SetType(nil)
+		return n
+	}
+
+	if !t.ChanDir().CanSend() {
+		base.Errorf("invalid operation: %v (cannot close receive-only channel)", n)
+		n.SetType(nil)
+		return n
+	}
+	return n
+}
+
+// tcComplex typechecks an OCOMPLEX node.
+func tcComplex(n *ir.BinaryExpr) ir.Node {
+	l := Expr(n.X)
+	r := Expr(n.Y)
+	if l.Type() == nil || r.Type() == nil {
+		n.SetType(nil)
+		return n
+	}
+	l, r = defaultlit2(l, r, false)
+	if l.Type() == nil || r.Type() == nil {
+		n.SetType(nil)
+		return n
+	}
+	n.X = l
+	n.Y = r
+
+	if !types.Identical(l.Type(), r.Type()) {
+		base.Errorf("invalid operation: %v (mismatched types %v and %v)", n, l.Type(), r.Type())
+		n.SetType(nil)
+		return n
+	}
+
+	var t *types.Type
+	switch l.Type().Kind() {
+	default:
+		base.Errorf("invalid operation: %v (arguments have type %v, expected floating-point)", n, l.Type())
+		n.SetType(nil)
+		return n
+
+	case types.TIDEAL:
+		t = types.UntypedComplex
+
+	case types.TFLOAT32:
+		t = types.Types[types.TCOMPLEX64]
+
+	case types.TFLOAT64:
+		t = types.Types[types.TCOMPLEX128]
+	}
+	n.SetType(t)
+	return n
+}
+
+// tcCopy typechecks an OCOPY node.
+func tcCopy(n *ir.BinaryExpr) ir.Node {
+	n.SetType(types.Types[types.TINT])
+	n.X = Expr(n.X)
+	n.X = DefaultLit(n.X, nil)
+	n.Y = Expr(n.Y)
+	n.Y = DefaultLit(n.Y, nil)
+	if n.X.Type() == nil || n.Y.Type() == nil {
+		n.SetType(nil)
+		return n
+	}
+
+	// copy([]byte, string)
+	if n.X.Type().IsSlice() && n.Y.Type().IsString() {
+		if types.Identical(n.X.Type().Elem(), types.ByteType) {
+			return n
+		}
+		base.Errorf("arguments to copy have different element types: %L and string", n.X.Type())
+		n.SetType(nil)
+		return n
+	}
+
+	if !n.X.Type().IsSlice() || !n.Y.Type().IsSlice() {
+		if !n.X.Type().IsSlice() && !n.Y.Type().IsSlice() {
+			base.Errorf("arguments to copy must be slices; have %L, %L", n.X.Type(), n.Y.Type())
+		} else if !n.X.Type().IsSlice() {
+			base.Errorf("first argument to copy should be slice; have %L", n.X.Type())
+		} else {
+			base.Errorf("second argument to copy should be slice or string; have %L", n.Y.Type())
+		}
+		n.SetType(nil)
+		return n
+	}
+
+	if !types.Identical(n.X.Type().Elem(), n.Y.Type().Elem()) {
+		base.Errorf("arguments to copy have different element types: %L and %L", n.X.Type(), n.Y.Type())
+		n.SetType(nil)
+		return n
+	}
+	return n
+}
+
+// tcDelete typechecks an ODELETE node.
+func tcDelete(n *ir.CallExpr) ir.Node {
+	typecheckargs(n)
+	args := n.Args
+	if len(args) == 0 {
+		base.Errorf("missing arguments to delete")
+		n.SetType(nil)
+		return n
+	}
+
+	if len(args) == 1 {
+		base.Errorf("missing second (key) argument to delete")
+		n.SetType(nil)
+		return n
+	}
+
+	if len(args) != 2 {
+		base.Errorf("too many arguments to delete")
+		n.SetType(nil)
+		return n
+	}
+
+	l := args[0]
+	r := args[1]
+	if l.Type() != nil && !l.Type().IsMap() {
+		base.Errorf("first argument to delete must be map; have %L", l.Type())
+		n.SetType(nil)
+		return n
+	}
+
+	args[1] = AssignConv(r, l.Type().Key(), "delete")
+	return n
+}
+
+// tcMake typechecks an OMAKE node.
+func tcMake(n *ir.CallExpr) ir.Node {
+	args := n.Args
+	if len(args) == 0 {
+		base.Errorf("missing argument to make")
+		n.SetType(nil)
+		return n
+	}
+
+	n.Args.Set(nil)
+	l := args[0]
+	l = typecheck(l, ctxType)
+	t := l.Type()
+	if t == nil {
+		n.SetType(nil)
+		return n
+	}
+
+	i := 1
+	var nn ir.Node
+	switch t.Kind() {
+	default:
+		base.Errorf("cannot make type %v", t)
+		n.SetType(nil)
+		return n
+
+	case types.TSLICE:
+		if i >= len(args) {
+			base.Errorf("missing len argument to make(%v)", t)
+			n.SetType(nil)
+			return n
+		}
+
+		l = args[i]
+		i++
+		l = Expr(l)
+		var r ir.Node
+		if i < len(args) {
+			r = args[i]
+			i++
+			r = Expr(r)
+		}
+
+		if l.Type() == nil || (r != nil && r.Type() == nil) {
+			n.SetType(nil)
+			return n
+		}
+		if !checkmake(t, "len", &l) || r != nil && !checkmake(t, "cap", &r) {
+			n.SetType(nil)
+			return n
+		}
+		if ir.IsConst(l, constant.Int) && r != nil && ir.IsConst(r, constant.Int) && constant.Compare(l.Val(), token.GTR, r.Val()) {
+			base.Errorf("len larger than cap in make(%v)", t)
+			n.SetType(nil)
+			return n
+		}
+		nn = ir.NewMakeExpr(n.Pos(), ir.OMAKESLICE, l, r)
+
+	case types.TMAP:
+		if i < len(args) {
+			l = args[i]
+			i++
+			l = Expr(l)
+			l = DefaultLit(l, types.Types[types.TINT])
+			if l.Type() == nil {
+				n.SetType(nil)
+				return n
+			}
+			if !checkmake(t, "size", &l) {
+				n.SetType(nil)
+				return n
+			}
+		} else {
+			l = ir.NewInt(0)
+		}
+		nn = ir.NewMakeExpr(n.Pos(), ir.OMAKEMAP, l, nil)
+		nn.SetEsc(n.Esc())
+
+	case types.TCHAN:
+		l = nil
+		if i < len(args) {
+			l = args[i]
+			i++
+			l = Expr(l)
+			l = DefaultLit(l, types.Types[types.TINT])
+			if l.Type() == nil {
+				n.SetType(nil)
+				return n
+			}
+			if !checkmake(t, "buffer", &l) {
+				n.SetType(nil)
+				return n
+			}
+		} else {
+			l = ir.NewInt(0)
+		}
+		nn = ir.NewMakeExpr(n.Pos(), ir.OMAKECHAN, l, nil)
+	}
+
+	if i < len(args) {
+		base.Errorf("too many arguments to make(%v)", t)
+		n.SetType(nil)
+		return n
+	}
+
+	nn.SetType(t)
+	return nn
+}
+
+// tcMakeSliceCopy typechecks an OMAKESLICECOPY node.
+func tcMakeSliceCopy(n *ir.MakeExpr) ir.Node {
+	// Errors here are Fatalf instead of Errorf because only the compiler
+	// can construct an OMAKESLICECOPY node.
+	// Components used in OMAKESCLICECOPY that are supplied by parsed source code
+	// have already been typechecked in OMAKE and OCOPY earlier.
+	t := n.Type()
+
+	if t == nil {
+		base.Fatalf("no type specified for OMAKESLICECOPY")
+	}
+
+	if !t.IsSlice() {
+		base.Fatalf("invalid type %v for OMAKESLICECOPY", n.Type())
+	}
+
+	if n.Len == nil {
+		base.Fatalf("missing len argument for OMAKESLICECOPY")
+	}
+
+	if n.Cap == nil {
+		base.Fatalf("missing slice argument to copy for OMAKESLICECOPY")
+	}
+
+	n.Len = Expr(n.Len)
+	n.Cap = Expr(n.Cap)
+
+	n.Len = DefaultLit(n.Len, types.Types[types.TINT])
+
+	if !n.Len.Type().IsInteger() && n.Type().Kind() != types.TIDEAL {
+		base.Errorf("non-integer len argument in OMAKESLICECOPY")
+	}
+
+	if ir.IsConst(n.Len, constant.Int) {
+		if ir.ConstOverflow(n.Len.Val(), types.Types[types.TINT]) {
+			base.Fatalf("len for OMAKESLICECOPY too large")
+		}
+		if constant.Sign(n.Len.Val()) < 0 {
+			base.Fatalf("len for OMAKESLICECOPY must be non-negative")
+		}
+	}
+	return n
+}
+
+// tcNew typechecks an ONEW node.
+func tcNew(n *ir.UnaryExpr) ir.Node {
+	if n.X == nil {
+		// Fatalf because the OCALL above checked for us,
+		// so this must be an internally-generated mistake.
+		base.Fatalf("missing argument to new")
+	}
+	l := n.X
+	l = typecheck(l, ctxType)
+	t := l.Type()
+	if t == nil {
+		n.SetType(nil)
+		return n
+	}
+	n.X = l
+	n.SetType(types.NewPtr(t))
+	return n
+}
+
+// tcPanic typechecks an OPANIC node.
+func tcPanic(n *ir.UnaryExpr) ir.Node {
+	n.X = Expr(n.X)
+	n.X = DefaultLit(n.X, types.Types[types.TINTER])
+	if n.X.Type() == nil {
+		n.SetType(nil)
+		return n
+	}
+	return n
+}
+
+// tcPrint typechecks an OPRINT or OPRINTN node.
+func tcPrint(n *ir.CallExpr) ir.Node {
+	typecheckargs(n)
+	ls := n.Args
+	for i1, n1 := range ls {
+		// Special case for print: int constant is int64, not int.
+		if ir.IsConst(n1, constant.Int) {
+			ls[i1] = DefaultLit(ls[i1], types.Types[types.TINT64])
+		} else {
+			ls[i1] = DefaultLit(ls[i1], nil)
+		}
+	}
+	return n
+}
+
+// tcRealImag typechecks an OREAL or OIMAG node.
+func tcRealImag(n *ir.UnaryExpr) ir.Node {
+	n.X = Expr(n.X)
+	l := n.X
+	t := l.Type()
+	if t == nil {
+		n.SetType(nil)
+		return n
+	}
+
+	// Determine result type.
+	switch t.Kind() {
+	case types.TIDEAL:
+		n.SetType(types.UntypedFloat)
+	case types.TCOMPLEX64:
+		n.SetType(types.Types[types.TFLOAT32])
+	case types.TCOMPLEX128:
+		n.SetType(types.Types[types.TFLOAT64])
+	default:
+		base.Errorf("invalid argument %L for %v", l, n.Op())
+		n.SetType(nil)
+		return n
+	}
+	return n
+}
+
+// tcRecover typechecks an ORECOVER node.
+func tcRecover(n *ir.CallExpr) ir.Node {
+	if len(n.Args) != 0 {
+		base.Errorf("too many arguments to recover")
+		n.SetType(nil)
+		return n
+	}
+
+	n.SetType(types.Types[types.TINTER])
+	return n
+}
diff --git a/src/cmd/compile/internal/typecheck/stmt.go b/src/cmd/compile/internal/typecheck/stmt.go
index 889ee06d6e..bf3801eea2 100644
--- a/src/cmd/compile/internal/typecheck/stmt.go
+++ b/src/cmd/compile/internal/typecheck/stmt.go
@@ -11,33 +11,6 @@ import (
 	"cmd/internal/src"
 )
 
-// range
-func typecheckrange(n *ir.RangeStmt) {
-	// Typechecking order is important here:
-	// 0. first typecheck range expression (slice/map/chan),
-	//	it is evaluated only once and so logically it is not part of the loop.
-	// 1. typecheck produced values,
-	//	this part can declare new vars and so it must be typechecked before body,
-	//	because body can contain a closure that captures the vars.
-	// 2. decldepth++ to denote loop body.
-	// 3. typecheck body.
-	// 4. decldepth--.
-	typecheckrangeExpr(n)
-
-	// second half of dance, the first half being typecheckrangeExpr
-	n.SetTypecheck(1)
-	ls := n.Vars
-	for i1, n1 := range ls {
-		if n1.Typecheck() == 0 {
-			ls[i1] = AssignExpr(ls[i1])
-		}
-	}
-
-	decldepth++
-	Stmts(n.Body)
-	decldepth--
-}
-
 func typecheckrangeExpr(n *ir.RangeStmt) {
 	n.X = Expr(n.X)
 
@@ -136,8 +109,326 @@ func typecheckrangeExpr(n *ir.RangeStmt) {
 	}
 }
 
+// type check assignment.
+// if this assignment is the definition of a var on the left side,
+// fill in the var's type.
+func tcAssign(n *ir.AssignStmt) {
+	if base.EnableTrace && base.Flag.LowerT {
+		defer tracePrint("typecheckas", n)(nil)
+	}
+
+	// delicate little dance.
+	// the definition of n may refer to this assignment
+	// as its definition, in which case it will call typecheckas.
+	// in that case, do not call typecheck back, or it will cycle.
+	// if the variable has a type (ntype) then typechecking
+	// will not look at defn, so it is okay (and desirable,
+	// so that the conversion below happens).
+	n.X = Resolve(n.X)
+
+	if !ir.DeclaredBy(n.X, n) || n.X.Name().Ntype != nil {
+		n.X = AssignExpr(n.X)
+	}
+
+	// Use ctxMultiOK so we can emit an "N variables but M values" error
+	// to be consistent with typecheckas2 (#26616).
+	n.Y = typecheck(n.Y, ctxExpr|ctxMultiOK)
+	checkassign(n, n.X)
+	if n.Y != nil && n.Y.Type() != nil {
+		if n.Y.Type().IsFuncArgStruct() {
+			base.Errorf("assignment mismatch: 1 variable but %v returns %d values", n.Y.(*ir.CallExpr).X, n.Y.Type().NumFields())
+			// Multi-value RHS isn't actually valid for OAS; nil out
+			// to indicate failed typechecking.
+			n.Y.SetType(nil)
+		} else if n.X.Type() != nil {
+			n.Y = AssignConv(n.Y, n.X.Type(), "assignment")
+		}
+	}
+
+	if ir.DeclaredBy(n.X, n) && n.X.Name().Ntype == nil {
+		n.Y = DefaultLit(n.Y, nil)
+		n.X.SetType(n.Y.Type())
+	}
+
+	// second half of dance.
+	// now that right is done, typecheck the left
+	// just to get it over with.  see dance above.
+	n.SetTypecheck(1)
+
+	if n.X.Typecheck() == 0 {
+		n.X = AssignExpr(n.X)
+	}
+	if !ir.IsBlank(n.X) {
+		types.CheckSize(n.X.Type()) // ensure width is calculated for backend
+	}
+}
+
+func tcAssignList(n *ir.AssignListStmt) {
+	if base.EnableTrace && base.Flag.LowerT {
+		defer tracePrint("typecheckas2", n)(nil)
+	}
+
+	ls := n.Lhs
+	for i1, n1 := range ls {
+		// delicate little dance.
+		n1 = Resolve(n1)
+		ls[i1] = n1
+
+		if !ir.DeclaredBy(n1, n) || n1.Name().Ntype != nil {
+			ls[i1] = AssignExpr(ls[i1])
+		}
+	}
+
+	cl := len(n.Lhs)
+	cr := len(n.Rhs)
+	if cl > 1 && cr == 1 {
+		n.Rhs[0] = typecheck(n.Rhs[0], ctxExpr|ctxMultiOK)
+	} else {
+		Exprs(n.Rhs)
+	}
+	checkassignlist(n, n.Lhs)
+
+	var l ir.Node
+	var r ir.Node
+	if cl == cr {
+		// easy
+		ls := n.Lhs
+		rs := n.Rhs
+		for il, nl := range ls {
+			nr := rs[il]
+			if nl.Type() != nil && nr.Type() != nil {
+				rs[il] = AssignConv(nr, nl.Type(), "assignment")
+			}
+			if ir.DeclaredBy(nl, n) && nl.Name().Ntype == nil {
+				rs[il] = DefaultLit(rs[il], nil)
+				nl.SetType(rs[il].Type())
+			}
+		}
+
+		goto out
+	}
+
+	l = n.Lhs[0]
+	r = n.Rhs[0]
+
+	// x,y,z = f()
+	if cr == 1 {
+		if r.Type() == nil {
+			goto out
+		}
+		switch r.Op() {
+		case ir.OCALLMETH, ir.OCALLINTER, ir.OCALLFUNC:
+			if !r.Type().IsFuncArgStruct() {
+				break
+			}
+			cr = r.Type().NumFields()
+			if cr != cl {
+				goto mismatch
+			}
+			r.(*ir.CallExpr).Use = ir.CallUseList
+			n.SetOp(ir.OAS2FUNC)
+			for i, l := range n.Lhs {
+				f := r.Type().Field(i)
+				if f.Type != nil && l.Type() != nil {
+					checkassignto(f.Type, l)
+				}
+				if ir.DeclaredBy(l, n) && l.Name().Ntype == nil {
+					l.SetType(f.Type)
+				}
+			}
+			goto out
+		}
+	}
+
+	// x, ok = y
+	if cl == 2 && cr == 1 {
+		if r.Type() == nil {
+			goto out
+		}
+		switch r.Op() {
+		case ir.OINDEXMAP, ir.ORECV, ir.ODOTTYPE:
+			switch r.Op() {
+			case ir.OINDEXMAP:
+				n.SetOp(ir.OAS2MAPR)
+			case ir.ORECV:
+				n.SetOp(ir.OAS2RECV)
+			case ir.ODOTTYPE:
+				r := r.(*ir.TypeAssertExpr)
+				n.SetOp(ir.OAS2DOTTYPE)
+				r.SetOp(ir.ODOTTYPE2)
+			}
+			if l.Type() != nil {
+				checkassignto(r.Type(), l)
+			}
+			if ir.DeclaredBy(l, n) {
+				l.SetType(r.Type())
+			}
+			l := n.Lhs[1]
+			if l.Type() != nil && !l.Type().IsBoolean() {
+				checkassignto(types.Types[types.TBOOL], l)
+			}
+			if ir.DeclaredBy(l, n) && l.Name().Ntype == nil {
+				l.SetType(types.Types[types.TBOOL])
+			}
+			goto out
+		}
+	}
+
+mismatch:
+	switch r.Op() {
+	default:
+		base.Errorf("assignment mismatch: %d variables but %d values", cl, cr)
+	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
+		r := r.(*ir.CallExpr)
+		base.Errorf("assignment mismatch: %d variables but %v returns %d values", cl, r.X, cr)
+	}
+
+	// second half of dance
+out:
+	n.SetTypecheck(1)
+	ls = n.Lhs
+	for i1, n1 := range ls {
+		if n1.Typecheck() == 0 {
+			ls[i1] = AssignExpr(ls[i1])
+		}
+	}
+}
+
+// tcFor typechecks an OFOR node.
+func tcFor(n *ir.ForStmt) ir.Node {
+	Stmts(n.Init())
+	decldepth++
+	n.Cond = Expr(n.Cond)
+	n.Cond = DefaultLit(n.Cond, nil)
+	if n.Cond != nil {
+		t := n.Cond.Type()
+		if t != nil && !t.IsBoolean() {
+			base.Errorf("non-bool %L used as for condition", n.Cond)
+		}
+	}
+	n.Post = Stmt(n.Post)
+	if n.Op() == ir.OFORUNTIL {
+		Stmts(n.Late)
+	}
+	Stmts(n.Body)
+	decldepth--
+	return n
+}
+
+func tcGoDefer(n *ir.GoDeferStmt) {
+	what := "defer"
+	if n.Op() == ir.OGO {
+		what = "go"
+	}
+
+	switch n.Call.Op() {
+	// ok
+	case ir.OCALLINTER,
+		ir.OCALLMETH,
+		ir.OCALLFUNC,
+		ir.OCLOSE,
+		ir.OCOPY,
+		ir.ODELETE,
+		ir.OPANIC,
+		ir.OPRINT,
+		ir.OPRINTN,
+		ir.ORECOVER:
+		return
+
+	case ir.OAPPEND,
+		ir.OCAP,
+		ir.OCOMPLEX,
+		ir.OIMAG,
+		ir.OLEN,
+		ir.OMAKE,
+		ir.OMAKESLICE,
+		ir.OMAKECHAN,
+		ir.OMAKEMAP,
+		ir.ONEW,
+		ir.OREAL,
+		ir.OLITERAL: // conversion or unsafe.Alignof, Offsetof, Sizeof
+		if orig := ir.Orig(n.Call); orig.Op() == ir.OCONV {
+			break
+		}
+		base.ErrorfAt(n.Pos(), "%s discards result of %v", what, n.Call)
+		return
+	}
+
+	// type is broken or missing, most likely a method call on a broken type
+	// we will warn about the broken type elsewhere. no need to emit a potentially confusing error
+	if n.Call.Type() == nil || n.Call.Type().Broke() {
+		return
+	}
+
+	if !n.Diag() {
+		// The syntax made sure it was a call, so this must be
+		// a conversion.
+		n.SetDiag(true)
+		base.ErrorfAt(n.Pos(), "%s requires function call, not conversion", what)
+	}
+}
+
+// tcIf typechecks an OIF node.
+func tcIf(n *ir.IfStmt) ir.Node {
+	Stmts(n.Init())
+	n.Cond = Expr(n.Cond)
+	n.Cond = DefaultLit(n.Cond, nil)
+	if n.Cond != nil {
+		t := n.Cond.Type()
+		if t != nil && !t.IsBoolean() {
+			base.Errorf("non-bool %L used as if condition", n.Cond)
+		}
+	}
+	Stmts(n.Body)
+	Stmts(n.Else)
+	return n
+}
+
+// range
+func tcRange(n *ir.RangeStmt) {
+	// Typechecking order is important here:
+	// 0. first typecheck range expression (slice/map/chan),
+	//	it is evaluated only once and so logically it is not part of the loop.
+	// 1. typecheck produced values,
+	//	this part can declare new vars and so it must be typechecked before body,
+	//	because body can contain a closure that captures the vars.
+	// 2. decldepth++ to denote loop body.
+	// 3. typecheck body.
+	// 4. decldepth--.
+	typecheckrangeExpr(n)
+
+	// second half of dance, the first half being typecheckrangeExpr
+	n.SetTypecheck(1)
+	ls := n.Vars
+	for i1, n1 := range ls {
+		if n1.Typecheck() == 0 {
+			ls[i1] = AssignExpr(ls[i1])
+		}
+	}
+
+	decldepth++
+	Stmts(n.Body)
+	decldepth--
+}
+
+// tcReturn typechecks an ORETURN node.
+func tcReturn(n *ir.ReturnStmt) ir.Node {
+	typecheckargs(n)
+	if ir.CurFunc == nil {
+		base.Errorf("return outside function")
+		n.SetType(nil)
+		return n
+	}
+
+	if ir.HasNamedResults(ir.CurFunc) && len(n.Results) == 0 {
+		return n
+	}
+	typecheckaste(ir.ORETURN, nil, false, ir.CurFunc.Type().Results(), n.Results, func() string { return "return argument" })
+	return n
+}
+
 // select
-func typecheckselect(sel *ir.SelectStmt) {
+func tcSelect(sel *ir.SelectStmt) {
 	var def ir.Node
 	lno := ir.SetPos(sel)
 	Stmts(sel.Init())
@@ -219,35 +510,43 @@ func typecheckselect(sel *ir.SelectStmt) {
 	base.Pos = lno
 }
 
-type typeSet struct {
-	m map[string][]typeSetEntry
-}
+// tcSend typechecks an OSEND node.
+func tcSend(n *ir.SendStmt) ir.Node {
+	n.Chan = Expr(n.Chan)
+	n.Value = Expr(n.Value)
+	n.Chan = DefaultLit(n.Chan, nil)
+	t := n.Chan.Type()
+	if t == nil {
+		return n
+	}
+	if !t.IsChan() {
+		base.Errorf("invalid operation: %v (send to non-chan type %v)", n, t)
+		return n
+	}
 
-func (s *typeSet) add(pos src.XPos, typ *types.Type) {
-	if s.m == nil {
-		s.m = make(map[string][]typeSetEntry)
+	if !t.ChanDir().CanSend() {
+		base.Errorf("invalid operation: %v (send to receive-only type %v)", n, t)
+		return n
 	}
 
-	// LongString does not uniquely identify types, so we need to
-	// disambiguate collisions with types.Identical.
-	// TODO(mdempsky): Add a method that *is* unique.
-	ls := typ.LongString()
-	prevs := s.m[ls]
-	for _, prev := range prevs {
-		if types.Identical(typ, prev.typ) {
-			base.ErrorfAt(pos, "duplicate case %v in type switch\n\tprevious case at %s", typ, base.FmtPos(prev.pos))
-			return
-		}
+	n.Value = AssignConv(n.Value, t.Elem(), "send")
+	if n.Value.Type() == nil {
+		return n
 	}
-	s.m[ls] = append(prevs, typeSetEntry{pos, typ})
+	return n
 }
 
-type typeSetEntry struct {
-	pos src.XPos
-	typ *types.Type
+// tcSwitch typechecks a switch statement.
+func tcSwitch(n *ir.SwitchStmt) {
+	Stmts(n.Init())
+	if n.Tag != nil && n.Tag.Op() == ir.OTYPESW {
+		tcSwitchType(n)
+	} else {
+		tcSwitchExpr(n)
+	}
 }
 
-func typecheckExprSwitch(n *ir.SwitchStmt) {
+func tcSwitchExpr(n *ir.SwitchStmt) {
 	t := types.Types[types.TBOOL]
 	if n.Tag != nil {
 		n.Tag = Expr(n.Tag)
@@ -328,7 +627,7 @@ func typecheckExprSwitch(n *ir.SwitchStmt) {
 	}
 }
 
-func typecheckTypeSwitch(n *ir.SwitchStmt) {
+func tcSwitchType(n *ir.SwitchStmt) {
 	guard := n.Tag.(*ir.TypeSwitchGuard)
 	guard.X = Expr(guard.X)
 	t := guard.X.Type()
@@ -358,7 +657,7 @@ func typecheckTypeSwitch(n *ir.SwitchStmt) {
 		}
 
 		for i := range ls {
-			ls[i] = check(ls[i], ctxExpr|ctxType)
+			ls[i] = typecheck(ls[i], ctxExpr|ctxType)
 			n1 := ls[i]
 			if t == nil || n1.Type() == nil {
 				continue
@@ -424,12 +723,30 @@ func typecheckTypeSwitch(n *ir.SwitchStmt) {
 	}
 }
 
-// typecheckswitch typechecks a switch statement.
-func typecheckswitch(n *ir.SwitchStmt) {
-	Stmts(n.Init())
-	if n.Tag != nil && n.Tag.Op() == ir.OTYPESW {
-		typecheckTypeSwitch(n)
-	} else {
-		typecheckExprSwitch(n)
+type typeSet struct {
+	m map[string][]typeSetEntry
+}
+
+type typeSetEntry struct {
+	pos src.XPos
+	typ *types.Type
+}
+
+func (s *typeSet) add(pos src.XPos, typ *types.Type) {
+	if s.m == nil {
+		s.m = make(map[string][]typeSetEntry)
 	}
+
+	// LongString does not uniquely identify types, so we need to
+	// disambiguate collisions with types.Identical.
+	// TODO(mdempsky): Add a method that *is* unique.
+	ls := typ.LongString()
+	prevs := s.m[ls]
+	for _, prev := range prevs {
+		if types.Identical(typ, prev.typ) {
+			base.ErrorfAt(pos, "duplicate case %v in type switch\n\tprevious case at %s", typ, base.FmtPos(prev.pos))
+			return
+		}
+	}
+	s.m[ls] = append(prevs, typeSetEntry{pos, typ})
 }
diff --git a/src/cmd/compile/internal/typecheck/subr.go b/src/cmd/compile/internal/typecheck/subr.go
index 22ebf2a4b3..178eba4484 100644
--- a/src/cmd/compile/internal/typecheck/subr.go
+++ b/src/cmd/compile/internal/typecheck/subr.go
@@ -81,7 +81,7 @@ func NodNil() ir.Node {
 // will give shortest unique addressing.
 // modify the tree with missing type names.
 func AddImplicitDots(n *ir.SelectorExpr) *ir.SelectorExpr {
-	n.X = check(n.X, ctxType|ctxExpr)
+	n.X = typecheck(n.X, ctxType|ctxExpr)
 	if n.X.Diag() {
 		n.SetDiag(true)
 	}
diff --git a/src/cmd/compile/internal/typecheck/type.go b/src/cmd/compile/internal/typecheck/type.go
new file mode 100644
index 0000000000..4782bb9c31
--- /dev/null
+++ b/src/cmd/compile/internal/typecheck/type.go
@@ -0,0 +1,122 @@
+// Copyright 2009 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 typecheck
+
+import (
+	"go/constant"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
+)
+
+// tcArrayType typechecks an OTARRAY node.
+func tcArrayType(n *ir.ArrayType) ir.Node {
+	n.Elem = typecheck(n.Elem, ctxType)
+	if n.Elem.Type() == nil {
+		return n
+	}
+	if n.Len == nil { // [...]T
+		if !n.Diag() {
+			n.SetDiag(true)
+			base.Errorf("use of [...] array outside of array literal")
+		}
+		return n
+	}
+	n.Len = indexlit(Expr(n.Len))
+	size := n.Len
+	if ir.ConstType(size) != constant.Int {
+		switch {
+		case size.Type() == nil:
+			// Error already reported elsewhere.
+		case size.Type().IsInteger() && size.Op() != ir.OLITERAL:
+			base.Errorf("non-constant array bound %v", size)
+		default:
+			base.Errorf("invalid array bound %v", size)
+		}
+		return n
+	}
+
+	v := size.Val()
+	if ir.ConstOverflow(v, types.Types[types.TINT]) {
+		base.Errorf("array bound is too large")
+		return n
+	}
+
+	if constant.Sign(v) < 0 {
+		base.Errorf("array bound must be non-negative")
+		return n
+	}
+
+	bound, _ := constant.Int64Val(v)
+	t := types.NewArray(n.Elem.Type(), bound)
+	n.SetOTYPE(t)
+	types.CheckSize(t)
+	return n
+}
+
+// tcChanType typechecks an OTCHAN node.
+func tcChanType(n *ir.ChanType) ir.Node {
+	n.Elem = typecheck(n.Elem, ctxType)
+	l := n.Elem
+	if l.Type() == nil {
+		return n
+	}
+	if l.Type().NotInHeap() {
+		base.Errorf("chan of incomplete (or unallocatable) type not allowed")
+	}
+	n.SetOTYPE(types.NewChan(l.Type(), n.Dir))
+	return n
+}
+
+// tcFuncType typechecks an OTFUNC node.
+func tcFuncType(n *ir.FuncType) ir.Node {
+	n.SetOTYPE(NewFuncType(n.Recv, n.Params, n.Results))
+	return n
+}
+
+// tcInterfaceType typechecks an OTINTER node.
+func tcInterfaceType(n *ir.InterfaceType) ir.Node {
+	n.SetOTYPE(tointerface(n.Methods))
+	return n
+}
+
+// tcMapType typechecks an OTMAP node.
+func tcMapType(n *ir.MapType) ir.Node {
+	n.Key = typecheck(n.Key, ctxType)
+	n.Elem = typecheck(n.Elem, ctxType)
+	l := n.Key
+	r := n.Elem
+	if l.Type() == nil || r.Type() == nil {
+		return n
+	}
+	if l.Type().NotInHeap() {
+		base.Errorf("incomplete (or unallocatable) map key not allowed")
+	}
+	if r.Type().NotInHeap() {
+		base.Errorf("incomplete (or unallocatable) map value not allowed")
+	}
+	n.SetOTYPE(types.NewMap(l.Type(), r.Type()))
+	mapqueue = append(mapqueue, n) // check map keys when all types are settled
+	return n
+}
+
+// tcSliceType typechecks an OTSLICE node.
+func tcSliceType(n *ir.SliceType) ir.Node {
+	n.Elem = typecheck(n.Elem, ctxType)
+	if n.Elem.Type() == nil {
+		return n
+	}
+	t := types.NewSlice(n.Elem.Type())
+	n.SetOTYPE(t)
+	types.CheckSize(t)
+	return n
+}
+
+// tcStructType typechecks an OTSTRUCT node.
+func tcStructType(n *ir.StructType) ir.Node {
+	n.SetOTYPE(NewStructType(n.Fields))
+	return n
+}
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 2abf0a7824..bf43402d3d 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -122,9 +122,9 @@ func Package() {
 	}
 }
 
-func AssignExpr(n ir.Node) ir.Node { return check(n, ctxExpr|ctxAssign) }
-func Expr(n ir.Node) ir.Node       { return check(n, ctxExpr) }
-func Stmt(n ir.Node) ir.Node       { return check(n, ctxStmt) }
+func AssignExpr(n ir.Node) ir.Node { return typecheck(n, ctxExpr|ctxAssign) }
+func Expr(n ir.Node) ir.Node       { return typecheck(n, ctxExpr) }
+func Stmt(n ir.Node) ir.Node       { return typecheck(n, ctxStmt) }
 
 func Exprs(exprs []ir.Node) { typecheckslice(exprs, ctxExpr) }
 func Stmts(stmts []ir.Node) { typecheckslice(stmts, ctxStmt) }
@@ -138,13 +138,13 @@ func Call(call *ir.CallExpr) {
 	if t.NumResults() > 0 {
 		ctx = ctxExpr | ctxMultiOK
 	}
-	if check(call, ctx) != call {
+	if typecheck(call, ctx) != call {
 		panic("bad typecheck")
 	}
 }
 
 func Callee(n ir.Node) ir.Node {
-	return check(n, ctxExpr|ctxCallee)
+	return typecheck(n, ctxExpr|ctxCallee)
 }
 
 func FuncBody(n *ir.Func) {
@@ -277,7 +277,7 @@ func Resolve(n ir.Node) (res ir.Node) {
 
 func typecheckslice(l []ir.Node, top int) {
 	for i := range l {
-		l[i] = check(l[i], top)
+		l[i] = typecheck(l[i], top)
 	}
 }
 
@@ -367,13 +367,13 @@ func Func(fn *ir.Func) {
 }
 
 func typecheckNtype(n ir.Ntype) ir.Ntype {
-	return check(n, ctxType).(ir.Ntype)
+	return typecheck(n, ctxType).(ir.Ntype)
 }
 
-// check type checks node n.
-// The result of check MUST be assigned back to n, e.g.
-// 	n.Left = check(n.Left, top)
-func check(n ir.Node, top int) (res ir.Node) {
+// typecheck type checks node n.
+// The result of typecheck MUST be assigned back to n, e.g.
+// 	n.Left = typecheck(n.Left, top)
+func typecheck(n ir.Node, top int) (res ir.Node) {
 	// cannot type check until all the source has been parsed
 	if !TypecheckAllowed {
 		base.Fatalf("early typecheck")
@@ -572,11 +572,7 @@ func indexlit(n ir.Node) ir.Node {
 }
 
 // typecheck1 should ONLY be called from typecheck.
-func typecheck1(n ir.Node, top int) (res ir.Node) {
-	if base.EnableTrace && base.Flag.LowerT {
-		defer tracePrint("typecheck1", n)(&res)
-	}
-
+func typecheck1(n ir.Node, top int) ir.Node {
 	switch n.Op() {
 	case ir.OLITERAL, ir.ONAME, ir.ONONAME, ir.OTYPE:
 		if n.Sym() == nil {
@@ -653,136 +649,35 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OTSLICE:
 		n := n.(*ir.SliceType)
-		n.Elem = check(n.Elem, ctxType)
-		if n.Elem.Type() == nil {
-			return n
-		}
-		t := types.NewSlice(n.Elem.Type())
-		n.SetOTYPE(t)
-		types.CheckSize(t)
-		return n
+		return tcSliceType(n)
 
 	case ir.OTARRAY:
 		n := n.(*ir.ArrayType)
-		n.Elem = check(n.Elem, ctxType)
-		if n.Elem.Type() == nil {
-			return n
-		}
-		if n.Len == nil { // [...]T
-			if !n.Diag() {
-				n.SetDiag(true)
-				base.Errorf("use of [...] array outside of array literal")
-			}
-			return n
-		}
-		n.Len = indexlit(Expr(n.Len))
-		size := n.Len
-		if ir.ConstType(size) != constant.Int {
-			switch {
-			case size.Type() == nil:
-				// Error already reported elsewhere.
-			case size.Type().IsInteger() && size.Op() != ir.OLITERAL:
-				base.Errorf("non-constant array bound %v", size)
-			default:
-				base.Errorf("invalid array bound %v", size)
-			}
-			return n
-		}
-
-		v := size.Val()
-		if ir.ConstOverflow(v, types.Types[types.TINT]) {
-			base.Errorf("array bound is too large")
-			return n
-		}
-
-		if constant.Sign(v) < 0 {
-			base.Errorf("array bound must be non-negative")
-			return n
-		}
-
-		bound, _ := constant.Int64Val(v)
-		t := types.NewArray(n.Elem.Type(), bound)
-		n.SetOTYPE(t)
-		types.CheckSize(t)
-		return n
+		return tcArrayType(n)
 
 	case ir.OTMAP:
 		n := n.(*ir.MapType)
-		n.Key = check(n.Key, ctxType)
-		n.Elem = check(n.Elem, ctxType)
-		l := n.Key
-		r := n.Elem
-		if l.Type() == nil || r.Type() == nil {
-			return n
-		}
-		if l.Type().NotInHeap() {
-			base.Errorf("incomplete (or unallocatable) map key not allowed")
-		}
-		if r.Type().NotInHeap() {
-			base.Errorf("incomplete (or unallocatable) map value not allowed")
-		}
-		n.SetOTYPE(types.NewMap(l.Type(), r.Type()))
-		mapqueue = append(mapqueue, n) // check map keys when all types are settled
-		return n
+		return tcMapType(n)
 
 	case ir.OTCHAN:
 		n := n.(*ir.ChanType)
-		n.Elem = check(n.Elem, ctxType)
-		l := n.Elem
-		if l.Type() == nil {
-			return n
-		}
-		if l.Type().NotInHeap() {
-			base.Errorf("chan of incomplete (or unallocatable) type not allowed")
-		}
-		n.SetOTYPE(types.NewChan(l.Type(), n.Dir))
-		return n
+		return tcChanType(n)
 
 	case ir.OTSTRUCT:
 		n := n.(*ir.StructType)
-		n.SetOTYPE(NewStructType(n.Fields))
-		return n
+		return tcStructType(n)
 
 	case ir.OTINTER:
 		n := n.(*ir.InterfaceType)
-		n.SetOTYPE(tointerface(n.Methods))
-		return n
+		return tcInterfaceType(n)
 
 	case ir.OTFUNC:
 		n := n.(*ir.FuncType)
-		n.SetOTYPE(NewFuncType(n.Recv, n.Params, n.Results))
-		return n
-
+		return tcFuncType(n)
 	// type or expr
 	case ir.ODEREF:
 		n := n.(*ir.StarExpr)
-		n.X = check(n.X, ctxExpr|ctxType)
-		l := n.X
-		t := l.Type()
-		if t == nil {
-			n.SetType(nil)
-			return n
-		}
-		if l.Op() == ir.OTYPE {
-			n.SetOTYPE(types.NewPtr(l.Type()))
-			// Ensure l.Type gets dowidth'd for the backend. Issue 20174.
-			types.CheckSize(l.Type())
-			return n
-		}
-
-		if !t.IsPtr() {
-			if top&(ctxExpr|ctxStmt) != 0 {
-				base.Errorf("invalid indirect of %L", n.X)
-				n.SetType(nil)
-				return n
-			}
-			base.Errorf("%v is not a type", l)
-			return n
-		}
-
-		n.SetType(t.Elem())
-		return n
-
+		return tcStar(n, top)
 	// arithmetic exprs
 	case ir.OASOP,
 		ir.OADD,
@@ -804,1324 +699,117 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		ir.OOROR,
 		ir.OSUB,
 		ir.OXOR:
-		var l, r ir.Node
-		var setLR func()
-		switch n := n.(type) {
-		case *ir.AssignOpStmt:
-			l, r = n.X, n.Y
-			setLR = func() { n.X = l; n.Y = r }
-		case *ir.BinaryExpr:
-			l, r = n.X, n.Y
-			setLR = func() { n.X = l; n.Y = r }
-		case *ir.LogicalExpr:
-			l, r = n.X, n.Y
-			setLR = func() { n.X = l; n.Y = r }
-		}
-		l = Expr(l)
-		r = Expr(r)
-		setLR()
-		if l.Type() == nil || r.Type() == nil {
-			n.SetType(nil)
-			return n
-		}
-		op := n.Op()
-		if n.Op() == ir.OASOP {
-			n := n.(*ir.AssignOpStmt)
-			checkassign(n, l)
-			if n.IncDec && !okforarith[l.Type().Kind()] {
-				base.Errorf("invalid operation: %v (non-numeric type %v)", n, l.Type())
-				n.SetType(nil)
-				return n
-			}
-			// TODO(marvin): Fix Node.EType type union.
-			op = n.AsOp
-		}
-		if op == ir.OLSH || op == ir.ORSH {
-			r = DefaultLit(r, types.Types[types.TUINT])
-			setLR()
-			t := r.Type()
-			if !t.IsInteger() {
-				base.Errorf("invalid operation: %v (shift count type %v, must be integer)", n, r.Type())
-				n.SetType(nil)
-				return n
-			}
-			if t.IsSigned() && !types.AllowsGoVersion(curpkg(), 1, 13) {
-				base.ErrorfVers("go1.13", "invalid operation: %v (signed shift count type %v)", n, r.Type())
-				n.SetType(nil)
-				return n
-			}
-			t = l.Type()
-			if t != nil && t.Kind() != types.TIDEAL && !t.IsInteger() {
-				base.Errorf("invalid operation: %v (shift of type %v)", n, t)
-				n.SetType(nil)
-				return n
-			}
-
-			// no defaultlit for left
-			// the outer context gives the type
-			n.SetType(l.Type())
-			if (l.Type() == types.UntypedFloat || l.Type() == types.UntypedComplex) && r.Op() == ir.OLITERAL {
-				n.SetType(types.UntypedInt)
-			}
-			return n
-		}
-
-		// For "x == x && len(s)", it's better to report that "len(s)" (type int)
-		// can't be used with "&&" than to report that "x == x" (type untyped bool)
-		// can't be converted to int (see issue #41500).
-		if n.Op() == ir.OANDAND || n.Op() == ir.OOROR {
-			n := n.(*ir.LogicalExpr)
-			if !n.X.Type().IsBoolean() {
-				base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op(), typekind(n.X.Type()))
-				n.SetType(nil)
-				return n
-			}
-			if !n.Y.Type().IsBoolean() {
-				base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op(), typekind(n.Y.Type()))
-				n.SetType(nil)
-				return n
-			}
-		}
-
-		// ideal mixed with non-ideal
-		l, r = defaultlit2(l, r, false)
-		setLR()
-
-		if l.Type() == nil || r.Type() == nil {
-			n.SetType(nil)
-			return n
-		}
-		t := l.Type()
-		if t.Kind() == types.TIDEAL {
-			t = r.Type()
-		}
-		et := t.Kind()
-		if et == types.TIDEAL {
-			et = types.TINT
-		}
-		aop := ir.OXXX
-		if iscmp[n.Op()] && t.Kind() != types.TIDEAL && !types.Identical(l.Type(), r.Type()) {
-			// comparison is okay as long as one side is
-			// assignable to the other.  convert so they have
-			// the same type.
-			//
-			// the only conversion that isn't a no-op is concrete == interface.
-			// in that case, check comparability of the concrete type.
-			// The conversion allocates, so only do it if the concrete type is huge.
-			converted := false
-			if r.Type().Kind() != types.TBLANK {
-				aop, _ = assignop(l.Type(), r.Type())
-				if aop != ir.OXXX {
-					if r.Type().IsInterface() && !l.Type().IsInterface() && !types.IsComparable(l.Type()) {
-						base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(l.Type()))
-						n.SetType(nil)
-						return n
-					}
-
-					types.CalcSize(l.Type())
-					if r.Type().IsInterface() == l.Type().IsInterface() || l.Type().Width >= 1<<16 {
-						l = ir.NewConvExpr(base.Pos, aop, r.Type(), l)
-						l.SetTypecheck(1)
-						setLR()
-					}
-
-					t = r.Type()
-					converted = true
-				}
-			}
-
-			if !converted && l.Type().Kind() != types.TBLANK {
-				aop, _ = assignop(r.Type(), l.Type())
-				if aop != ir.OXXX {
-					if l.Type().IsInterface() && !r.Type().IsInterface() && !types.IsComparable(r.Type()) {
-						base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(r.Type()))
-						n.SetType(nil)
-						return n
-					}
-
-					types.CalcSize(r.Type())
-					if r.Type().IsInterface() == l.Type().IsInterface() || r.Type().Width >= 1<<16 {
-						r = ir.NewConvExpr(base.Pos, aop, l.Type(), r)
-						r.SetTypecheck(1)
-						setLR()
-					}
-
-					t = l.Type()
-				}
-			}
-
-			et = t.Kind()
-		}
-
-		if t.Kind() != types.TIDEAL && !types.Identical(l.Type(), r.Type()) {
-			l, r = defaultlit2(l, r, true)
-			if l.Type() == nil || r.Type() == nil {
-				n.SetType(nil)
-				return n
-			}
-			if l.Type().IsInterface() == r.Type().IsInterface() || aop == 0 {
-				base.Errorf("invalid operation: %v (mismatched types %v and %v)", n, l.Type(), r.Type())
-				n.SetType(nil)
-				return n
-			}
-		}
-
-		if t.Kind() == types.TIDEAL {
-			t = mixUntyped(l.Type(), r.Type())
-		}
-		if dt := defaultType(t); !okfor[op][dt.Kind()] {
-			base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(t))
-			n.SetType(nil)
-			return n
-		}
-
-		// okfor allows any array == array, map == map, func == func.
-		// restrict to slice/map/func == nil and nil == slice/map/func.
-		if l.Type().IsArray() && !types.IsComparable(l.Type()) {
-			base.Errorf("invalid operation: %v (%v cannot be compared)", n, l.Type())
-			n.SetType(nil)
-			return n
-		}
-
-		if l.Type().IsSlice() && !ir.IsNil(l) && !ir.IsNil(r) {
-			base.Errorf("invalid operation: %v (slice can only be compared to nil)", n)
-			n.SetType(nil)
-			return n
-		}
-
-		if l.Type().IsMap() && !ir.IsNil(l) && !ir.IsNil(r) {
-			base.Errorf("invalid operation: %v (map can only be compared to nil)", n)
-			n.SetType(nil)
-			return n
-		}
-
-		if l.Type().Kind() == types.TFUNC && !ir.IsNil(l) && !ir.IsNil(r) {
-			base.Errorf("invalid operation: %v (func can only be compared to nil)", n)
-			n.SetType(nil)
-			return n
-		}
-
-		if l.Type().IsStruct() {
-			if f := types.IncomparableField(l.Type()); f != nil {
-				base.Errorf("invalid operation: %v (struct containing %v cannot be compared)", n, f.Type)
-				n.SetType(nil)
-				return n
-			}
-		}
-
-		if iscmp[n.Op()] {
-			t = types.UntypedBool
-			n.SetType(t)
-			if con := EvalConst(n); con.Op() == ir.OLITERAL {
-				return con
-			}
-			l, r = defaultlit2(l, r, true)
-			setLR()
-			return n
-		}
-
-		if et == types.TSTRING && n.Op() == ir.OADD {
-			// create or update OADDSTR node with list of strings in x + y + z + (w + v) + ...
-			n := n.(*ir.BinaryExpr)
-			var add *ir.AddStringExpr
-			if l.Op() == ir.OADDSTR {
-				add = l.(*ir.AddStringExpr)
-				add.SetPos(n.Pos())
-			} else {
-				add = ir.NewAddStringExpr(n.Pos(), []ir.Node{l})
-			}
-			if r.Op() == ir.OADDSTR {
-				r := r.(*ir.AddStringExpr)
-				add.List.Append(r.List.Take()...)
-			} else {
-				add.List.Append(r)
-			}
-			add.SetType(t)
-			return add
-		}
-
-		if (op == ir.ODIV || op == ir.OMOD) && ir.IsConst(r, constant.Int) {
-			if constant.Sign(r.Val()) == 0 {
-				base.Errorf("division by zero")
-				n.SetType(nil)
-				return n
-			}
-		}
-
-		n.SetType(t)
-		return n
+		return tcArith(n)
 
 	case ir.OBITNOT, ir.ONEG, ir.ONOT, ir.OPLUS:
 		n := n.(*ir.UnaryExpr)
-		n.X = Expr(n.X)
-		l := n.X
-		t := l.Type()
-		if t == nil {
-			n.SetType(nil)
-			return n
-		}
-		if !okfor[n.Op()][defaultType(t).Kind()] {
-			base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op(), typekind(t))
-			n.SetType(nil)
-			return n
-		}
-
-		n.SetType(t)
-		return n
+		return tcUnaryArith(n)
 
 	// exprs
 	case ir.OADDR:
 		n := n.(*ir.AddrExpr)
-		n.X = Expr(n.X)
-		if n.X.Type() == nil {
-			n.SetType(nil)
-			return n
-		}
-
-		switch n.X.Op() {
-		case ir.OARRAYLIT, ir.OMAPLIT, ir.OSLICELIT, ir.OSTRUCTLIT:
-			n.SetOp(ir.OPTRLIT)
-
-		default:
-			checklvalue(n.X, "take the address of")
-			r := ir.OuterValue(n.X)
-			if r.Op() == ir.ONAME {
-				r := r.(*ir.Name)
-				if ir.Orig(r) != r {
-					base.Fatalf("found non-orig name node %v", r) // TODO(mdempsky): What does this mean?
-				}
-				r.Name().SetAddrtaken(true)
-				if r.Name().IsClosureVar() && !CaptureVarsComplete {
-					// Mark the original variable as Addrtaken so that capturevars
-					// knows not to pass it by value.
-					// But if the capturevars phase is complete, don't touch it,
-					// in case l.Name's containing function has not yet been compiled.
-					r.Name().Defn.Name().SetAddrtaken(true)
-				}
-			}
-			n.X = DefaultLit(n.X, nil)
-			if n.X.Type() == nil {
-				n.SetType(nil)
-				return n
-			}
-		}
-
-		n.SetType(types.NewPtr(n.X.Type()))
-		return n
+		return tcAddr(n)
 
 	case ir.OCOMPLIT:
-		return typecheckcomplit(n.(*ir.CompLitExpr))
+		return tcCompLit(n.(*ir.CompLitExpr))
 
 	case ir.OXDOT, ir.ODOT:
 		n := n.(*ir.SelectorExpr)
-		if n.Op() == ir.OXDOT {
-			n = AddImplicitDots(n)
-			n.SetOp(ir.ODOT)
-			if n.X == nil {
-				n.SetType(nil)
-				return n
-			}
-		}
-
-		n.X = check(n.X, ctxExpr|ctxType)
-
-		n.X = DefaultLit(n.X, nil)
-
-		t := n.X.Type()
-		if t == nil {
-			base.UpdateErrorDot(ir.Line(n), fmt.Sprint(n.X), fmt.Sprint(n))
-			n.SetType(nil)
-			return n
-		}
-
-		s := n.Sel
-
-		if n.X.Op() == ir.OTYPE {
-			return typecheckMethodExpr(n)
-		}
-
-		if t.IsPtr() && !t.Elem().IsInterface() {
-			t = t.Elem()
-			if t == nil {
-				n.SetType(nil)
-				return n
-			}
-			n.SetOp(ir.ODOTPTR)
-			types.CheckSize(t)
-		}
-
-		if n.Sel.IsBlank() {
-			base.Errorf("cannot refer to blank field or method")
-			n.SetType(nil)
-			return n
-		}
-
-		if lookdot(n, t, 0) == nil {
-			// Legitimate field or method lookup failed, try to explain the error
-			switch {
-			case t.IsEmptyInterface():
-				base.Errorf("%v undefined (type %v is interface with no methods)", n, n.X.Type())
-
-			case t.IsPtr() && t.Elem().IsInterface():
-				// Pointer to interface is almost always a mistake.
-				base.Errorf("%v undefined (type %v is pointer to interface, not interface)", n, n.X.Type())
-
-			case lookdot(n, t, 1) != nil:
-				// Field or method matches by name, but it is not exported.
-				base.Errorf("%v undefined (cannot refer to unexported field or method %v)", n, n.Sel)
-
-			default:
-				if mt := lookdot(n, t, 2); mt != nil && visible(mt.Sym) { // Case-insensitive lookup.
-					base.Errorf("%v undefined (type %v has no field or method %v, but does have %v)", n, n.X.Type(), n.Sel, mt.Sym)
-				} else {
-					base.Errorf("%v undefined (type %v has no field or method %v)", n, n.X.Type(), n.Sel)
-				}
-			}
-			n.SetType(nil)
-			return n
-		}
-
-		if (n.Op() == ir.ODOTINTER || n.Op() == ir.ODOTMETH) && top&ctxCallee == 0 {
-			return typecheckpartialcall(n, s)
-		}
-		return n
+		return tcDot(n, top)
 
 	case ir.ODOTTYPE:
 		n := n.(*ir.TypeAssertExpr)
-		n.X = Expr(n.X)
-		n.X = DefaultLit(n.X, nil)
-		l := n.X
-		t := l.Type()
-		if t == nil {
-			n.SetType(nil)
-			return n
-		}
-		if !t.IsInterface() {
-			base.Errorf("invalid type assertion: %v (non-interface type %v on left)", n, t)
-			n.SetType(nil)
-			return n
-		}
-
-		if n.Ntype != nil {
-			n.Ntype = check(n.Ntype, ctxType)
-			n.SetType(n.Ntype.Type())
-			n.Ntype = nil
-			if n.Type() == nil {
-				return n
-			}
-		}
-
-		if n.Type() != nil && !n.Type().IsInterface() {
-			var missing, have *types.Field
-			var ptr int
-			if !implements(n.Type(), t, &missing, &have, &ptr) {
-				if have != nil && have.Sym == missing.Sym {
-					base.Errorf("impossible type assertion:\n\t%v does not implement %v (wrong type for %v method)\n"+
-						"\t\thave %v%S\n\t\twant %v%S", n.Type(), t, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
-				} else if ptr != 0 {
-					base.Errorf("impossible type assertion:\n\t%v does not implement %v (%v method has pointer receiver)", n.Type(), t, missing.Sym)
-				} else if have != nil {
-					base.Errorf("impossible type assertion:\n\t%v does not implement %v (missing %v method)\n"+
-						"\t\thave %v%S\n\t\twant %v%S", n.Type(), t, missing.Sym, have.Sym, have.Type, missing.Sym, missing.Type)
-				} else {
-					base.Errorf("impossible type assertion:\n\t%v does not implement %v (missing %v method)", n.Type(), t, missing.Sym)
-				}
-				n.SetType(nil)
-				return n
-			}
-		}
-		return n
+		return tcDotType(n)
 
 	case ir.OINDEX:
 		n := n.(*ir.IndexExpr)
-		n.X = Expr(n.X)
-		n.X = DefaultLit(n.X, nil)
-		n.X = implicitstar(n.X)
-		l := n.X
-		n.Index = Expr(n.Index)
-		r := n.Index
-		t := l.Type()
-		if t == nil || r.Type() == nil {
-			n.SetType(nil)
-			return n
-		}
-		switch t.Kind() {
-		default:
-			base.Errorf("invalid operation: %v (type %v does not support indexing)", n, t)
-			n.SetType(nil)
-			return n
+		return tcIndex(n)
 
-		case types.TSTRING, types.TARRAY, types.TSLICE:
-			n.Index = indexlit(n.Index)
-			if t.IsString() {
-				n.SetType(types.ByteType)
-			} else {
-				n.SetType(t.Elem())
-			}
-			why := "string"
-			if t.IsArray() {
-				why = "array"
-			} else if t.IsSlice() {
-				why = "slice"
-			}
+	case ir.ORECV:
+		n := n.(*ir.UnaryExpr)
+		return tcRecv(n)
 
-			if n.Index.Type() != nil && !n.Index.Type().IsInteger() {
-				base.Errorf("non-integer %s index %v", why, n.Index)
-				return n
-			}
-
-			if !n.Bounded() && ir.IsConst(n.Index, constant.Int) {
-				x := n.Index.Val()
-				if constant.Sign(x) < 0 {
-					base.Errorf("invalid %s index %v (index must be non-negative)", why, n.Index)
-				} else if t.IsArray() && constant.Compare(x, token.GEQ, constant.MakeInt64(t.NumElem())) {
-					base.Errorf("invalid array index %v (out of bounds for %d-element array)", n.Index, t.NumElem())
-				} else if ir.IsConst(n.X, constant.String) && constant.Compare(x, token.GEQ, constant.MakeInt64(int64(len(ir.StringVal(n.X))))) {
-					base.Errorf("invalid string index %v (out of bounds for %d-byte string)", n.Index, len(ir.StringVal(n.X)))
-				} else if ir.ConstOverflow(x, types.Types[types.TINT]) {
-					base.Errorf("invalid %s index %v (index too large)", why, n.Index)
-				}
-			}
-
-		case types.TMAP:
-			n.Index = AssignConv(n.Index, t.Key(), "map index")
-			n.SetType(t.Elem())
-			n.SetOp(ir.OINDEXMAP)
-			n.Assigned = false
-		}
-		return n
-
-	case ir.ORECV:
-		n := n.(*ir.UnaryExpr)
-		n.X = Expr(n.X)
-		n.X = DefaultLit(n.X, nil)
-		l := n.X
-		t := l.Type()
-		if t == nil {
-			n.SetType(nil)
-			return n
-		}
-		if !t.IsChan() {
-			base.Errorf("invalid operation: %v (receive from non-chan type %v)", n, t)
-			n.SetType(nil)
-			return n
-		}
-
-		if !t.ChanDir().CanRecv() {
-			base.Errorf("invalid operation: %v (receive from send-only type %v)", n, t)
-			n.SetType(nil)
-			return n
-		}
-
-		n.SetType(t.Elem())
-		return n
-
-	case ir.OSEND:
-		n := n.(*ir.SendStmt)
-		n.Chan = Expr(n.Chan)
-		n.Value = Expr(n.Value)
-		n.Chan = DefaultLit(n.Chan, nil)
-		t := n.Chan.Type()
-		if t == nil {
-			return n
-		}
-		if !t.IsChan() {
-			base.Errorf("invalid operation: %v (send to non-chan type %v)", n, t)
-			return n
-		}
-
-		if !t.ChanDir().CanSend() {
-			base.Errorf("invalid operation: %v (send to receive-only type %v)", n, t)
-			return n
-		}
-
-		n.Value = AssignConv(n.Value, t.Elem(), "send")
-		if n.Value.Type() == nil {
-			return n
-		}
-		return n
+	case ir.OSEND:
+		n := n.(*ir.SendStmt)
+		return tcSend(n)
 
 	case ir.OSLICEHEADER:
-		// Errors here are Fatalf instead of Errorf because only the compiler
-		// can construct an OSLICEHEADER node.
-		// Components used in OSLICEHEADER that are supplied by parsed source code
-		// have already been typechecked in e.g. OMAKESLICE earlier.
 		n := n.(*ir.SliceHeaderExpr)
-		t := n.Type()
-		if t == nil {
-			base.Fatalf("no type specified for OSLICEHEADER")
-		}
-
-		if !t.IsSlice() {
-			base.Fatalf("invalid type %v for OSLICEHEADER", n.Type())
-		}
-
-		if n.Ptr == nil || n.Ptr.Type() == nil || !n.Ptr.Type().IsUnsafePtr() {
-			base.Fatalf("need unsafe.Pointer for OSLICEHEADER")
-		}
-
-		if x := len(n.LenCap); x != 2 {
-			base.Fatalf("expected 2 params (len, cap) for OSLICEHEADER, got %d", x)
-		}
-
-		n.Ptr = Expr(n.Ptr)
-		l := Expr(n.LenCap[0])
-		c := Expr(n.LenCap[1])
-		l = DefaultLit(l, types.Types[types.TINT])
-		c = DefaultLit(c, types.Types[types.TINT])
-
-		if ir.IsConst(l, constant.Int) && ir.Int64Val(l) < 0 {
-			base.Fatalf("len for OSLICEHEADER must be non-negative")
-		}
-
-		if ir.IsConst(c, constant.Int) && ir.Int64Val(c) < 0 {
-			base.Fatalf("cap for OSLICEHEADER must be non-negative")
-		}
-
-		if ir.IsConst(l, constant.Int) && ir.IsConst(c, constant.Int) && constant.Compare(l.Val(), token.GTR, c.Val()) {
-			base.Fatalf("len larger than cap for OSLICEHEADER")
-		}
-
-		n.LenCap[0] = l
-		n.LenCap[1] = c
-		return n
+		return tcSliceHeader(n)
 
 	case ir.OMAKESLICECOPY:
-		// Errors here are Fatalf instead of Errorf because only the compiler
-		// can construct an OMAKESLICECOPY node.
-		// Components used in OMAKESCLICECOPY that are supplied by parsed source code
-		// have already been typechecked in OMAKE and OCOPY earlier.
 		n := n.(*ir.MakeExpr)
-		t := n.Type()
-
-		if t == nil {
-			base.Fatalf("no type specified for OMAKESLICECOPY")
-		}
-
-		if !t.IsSlice() {
-			base.Fatalf("invalid type %v for OMAKESLICECOPY", n.Type())
-		}
-
-		if n.Len == nil {
-			base.Fatalf("missing len argument for OMAKESLICECOPY")
-		}
-
-		if n.Cap == nil {
-			base.Fatalf("missing slice argument to copy for OMAKESLICECOPY")
-		}
-
-		n.Len = Expr(n.Len)
-		n.Cap = Expr(n.Cap)
-
-		n.Len = DefaultLit(n.Len, types.Types[types.TINT])
-
-		if !n.Len.Type().IsInteger() && n.Type().Kind() != types.TIDEAL {
-			base.Errorf("non-integer len argument in OMAKESLICECOPY")
-		}
-
-		if ir.IsConst(n.Len, constant.Int) {
-			if ir.ConstOverflow(n.Len.Val(), types.Types[types.TINT]) {
-				base.Fatalf("len for OMAKESLICECOPY too large")
-			}
-			if constant.Sign(n.Len.Val()) < 0 {
-				base.Fatalf("len for OMAKESLICECOPY must be non-negative")
-			}
-		}
-		return n
+		return tcMakeSliceCopy(n)
 
 	case ir.OSLICE, ir.OSLICE3:
 		n := n.(*ir.SliceExpr)
-		n.X = Expr(n.X)
-		low, high, max := n.SliceBounds()
-		hasmax := n.Op().IsSlice3()
-		low = Expr(low)
-		high = Expr(high)
-		max = Expr(max)
-		n.X = DefaultLit(n.X, nil)
-		low = indexlit(low)
-		high = indexlit(high)
-		max = indexlit(max)
-		n.SetSliceBounds(low, high, max)
-		l := n.X
-		if l.Type() == nil {
-			n.SetType(nil)
-			return n
-		}
-		if l.Type().IsArray() {
-			if !ir.IsAssignable(n.X) {
-				base.Errorf("invalid operation %v (slice of unaddressable value)", n)
-				n.SetType(nil)
-				return n
-			}
-
-			addr := NodAddr(n.X)
-			addr.SetImplicit(true)
-			n.X = Expr(addr)
-			l = n.X
-		}
-		t := l.Type()
-		var tp *types.Type
-		if t.IsString() {
-			if hasmax {
-				base.Errorf("invalid operation %v (3-index slice of string)", n)
-				n.SetType(nil)
-				return n
-			}
-			n.SetType(t)
-			n.SetOp(ir.OSLICESTR)
-		} else if t.IsPtr() && t.Elem().IsArray() {
-			tp = t.Elem()
-			n.SetType(types.NewSlice(tp.Elem()))
-			types.CalcSize(n.Type())
-			if hasmax {
-				n.SetOp(ir.OSLICE3ARR)
-			} else {
-				n.SetOp(ir.OSLICEARR)
-			}
-		} else if t.IsSlice() {
-			n.SetType(t)
-		} else {
-			base.Errorf("cannot slice %v (type %v)", l, t)
-			n.SetType(nil)
-			return n
-		}
-
-		if low != nil && !checksliceindex(l, low, tp) {
-			n.SetType(nil)
-			return n
-		}
-		if high != nil && !checksliceindex(l, high, tp) {
-			n.SetType(nil)
-			return n
-		}
-		if max != nil && !checksliceindex(l, max, tp) {
-			n.SetType(nil)
-			return n
-		}
-		if !checksliceconst(low, high) || !checksliceconst(low, max) || !checksliceconst(high, max) {
-			n.SetType(nil)
-			return n
-		}
-		return n
+		return tcSlice(n)
 
 	// call and call like
 	case ir.OCALL:
 		n := n.(*ir.CallExpr)
-		n.Use = ir.CallUseExpr
-		if top == ctxStmt {
-			n.Use = ir.CallUseStmt
-		}
-		Stmts(n.Init()) // imported rewritten f(g()) calls (#30907)
-		n.X = check(n.X, ctxExpr|ctxType|ctxCallee)
-		if n.X.Diag() {
-			n.SetDiag(true)
-		}
-
-		l := n.X
-
-		if l.Op() == ir.ONAME && l.(*ir.Name).BuiltinOp != 0 {
-			l := l.(*ir.Name)
-			if n.IsDDD && l.BuiltinOp != ir.OAPPEND {
-				base.Errorf("invalid use of ... with builtin %v", l)
-			}
-
-			// builtin: OLEN, OCAP, etc.
-			switch l.BuiltinOp {
-			default:
-				base.Fatalf("unknown builtin %v", l)
-
-			case ir.OAPPEND, ir.ODELETE, ir.OMAKE, ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
-				n.SetOp(l.BuiltinOp)
-				n.X = nil
-				n.SetTypecheck(0) // re-typechecking new op is OK, not a loop
-				return check(n, top)
-
-			case ir.OCAP, ir.OCLOSE, ir.OIMAG, ir.OLEN, ir.OPANIC, ir.OREAL:
-				typecheckargs(n)
-				fallthrough
-			case ir.ONEW, ir.OALIGNOF, ir.OOFFSETOF, ir.OSIZEOF:
-				arg, ok := needOneArg(n, "%v", n.Op())
-				if !ok {
-					n.SetType(nil)
-					return n
-				}
-				u := ir.NewUnaryExpr(n.Pos(), l.BuiltinOp, arg)
-				return check(ir.InitExpr(n.Init(), u), top) // typecheckargs can add to old.Init
-
-			case ir.OCOMPLEX, ir.OCOPY:
-				typecheckargs(n)
-				arg1, arg2, ok := needTwoArgs(n)
-				if !ok {
-					n.SetType(nil)
-					return n
-				}
-				b := ir.NewBinaryExpr(n.Pos(), l.BuiltinOp, arg1, arg2)
-				return check(ir.InitExpr(n.Init(), b), top) // typecheckargs can add to old.Init
-			}
-			panic("unreachable")
-		}
-
-		n.X = DefaultLit(n.X, nil)
-		l = n.X
-		if l.Op() == ir.OTYPE {
-			if n.IsDDD {
-				if !l.Type().Broke() {
-					base.Errorf("invalid use of ... in type conversion to %v", l.Type())
-				}
-				n.SetDiag(true)
-			}
-
-			// pick off before type-checking arguments
-			arg, ok := needOneArg(n, "conversion to %v", l.Type())
-			if !ok {
-				n.SetType(nil)
-				return n
-			}
+		return tcCall(n, top)
 
-			n := ir.NewConvExpr(n.Pos(), ir.OCONV, nil, arg)
-			n.SetType(l.Type())
-			return typecheck1(n, top)
-		}
-
-		typecheckargs(n)
-		t := l.Type()
-		if t == nil {
-			n.SetType(nil)
-			return n
-		}
-		types.CheckSize(t)
-
-		switch l.Op() {
-		case ir.ODOTINTER:
-			n.SetOp(ir.OCALLINTER)
-
-		case ir.ODOTMETH:
-			l := l.(*ir.SelectorExpr)
-			n.SetOp(ir.OCALLMETH)
-
-			// typecheckaste was used here but there wasn't enough
-			// information further down the call chain to know if we
-			// were testing a method receiver for unexported fields.
-			// It isn't necessary, so just do a sanity check.
-			tp := t.Recv().Type
-
-			if l.X == nil || !types.Identical(l.X.Type(), tp) {
-				base.Fatalf("method receiver")
-			}
-
-		default:
-			n.SetOp(ir.OCALLFUNC)
-			if t.Kind() != types.TFUNC {
-				// TODO(mdempsky): Remove "o.Sym() != nil" once we stop
-				// using ir.Name for numeric literals.
-				if o := ir.Orig(l); o.Name() != nil && o.Sym() != nil && types.BuiltinPkg.Lookup(o.Sym().Name).Def != nil {
-					// be more specific when the non-function
-					// name matches a predeclared function
-					base.Errorf("cannot call non-function %L, declared at %s",
-						l, base.FmtPos(o.Name().Pos()))
-				} else {
-					base.Errorf("cannot call non-function %L", l)
-				}
-				n.SetType(nil)
-				return n
-			}
-		}
-
-		typecheckaste(ir.OCALL, n.X, n.IsDDD, t.Params(), n.Args, func() string { return fmt.Sprintf("argument to %v", n.X) })
-		if t.NumResults() == 0 {
-			return n
-		}
-		if t.NumResults() == 1 {
-			n.SetType(l.Type().Results().Field(0).Type)
-
-			if n.Op() == ir.OCALLFUNC && n.X.Op() == ir.ONAME {
-				if sym := n.X.(*ir.Name).Sym(); types.IsRuntimePkg(sym.Pkg) && sym.Name == "getg" {
-					// Emit code for runtime.getg() directly instead of calling function.
-					// Most such rewrites (for example the similar one for math.Sqrt) should be done in walk,
-					// so that the ordering pass can make sure to preserve the semantics of the original code
-					// (in particular, the exact time of the function call) by introducing temporaries.
-					// In this case, we know getg() always returns the same result within a given function
-					// and we want to avoid the temporaries, so we do the rewrite earlier than is typical.
-					n.SetOp(ir.OGETG)
-				}
-			}
-			return n
-		}
-
-		// multiple return
-		if top&(ctxMultiOK|ctxStmt) == 0 {
-			base.Errorf("multiple-value %v() in single-value context", l)
-			return n
-		}
-
-		n.SetType(l.Type().Results())
-		return n
-
-	case ir.OALIGNOF, ir.OOFFSETOF, ir.OSIZEOF:
-		n := n.(*ir.UnaryExpr)
-		n.SetType(types.Types[types.TUINTPTR])
-		return n
-
-	case ir.OCAP, ir.OLEN:
-		n := n.(*ir.UnaryExpr)
-		n.X = Expr(n.X)
-		n.X = DefaultLit(n.X, nil)
-		n.X = implicitstar(n.X)
-		l := n.X
-		t := l.Type()
-		if t == nil {
-			n.SetType(nil)
-			return n
-		}
-
-		var ok bool
-		if n.Op() == ir.OLEN {
-			ok = okforlen[t.Kind()]
-		} else {
-			ok = okforcap[t.Kind()]
-		}
-		if !ok {
-			base.Errorf("invalid argument %L for %v", l, n.Op())
-			n.SetType(nil)
-			return n
-		}
-
-		n.SetType(types.Types[types.TINT])
-		return n
-
-	case ir.OREAL, ir.OIMAG:
-		n := n.(*ir.UnaryExpr)
-		n.X = Expr(n.X)
-		l := n.X
-		t := l.Type()
-		if t == nil {
-			n.SetType(nil)
-			return n
-		}
-
-		// Determine result type.
-		switch t.Kind() {
-		case types.TIDEAL:
-			n.SetType(types.UntypedFloat)
-		case types.TCOMPLEX64:
-			n.SetType(types.Types[types.TFLOAT32])
-		case types.TCOMPLEX128:
-			n.SetType(types.Types[types.TFLOAT64])
-		default:
-			base.Errorf("invalid argument %L for %v", l, n.Op())
-			n.SetType(nil)
-			return n
-		}
-		return n
-
-	case ir.OCOMPLEX:
-		n := n.(*ir.BinaryExpr)
-		l := Expr(n.X)
-		r := Expr(n.Y)
-		if l.Type() == nil || r.Type() == nil {
-			n.SetType(nil)
-			return n
-		}
-		l, r = defaultlit2(l, r, false)
-		if l.Type() == nil || r.Type() == nil {
-			n.SetType(nil)
-			return n
-		}
-		n.X = l
-		n.Y = r
-
-		if !types.Identical(l.Type(), r.Type()) {
-			base.Errorf("invalid operation: %v (mismatched types %v and %v)", n, l.Type(), r.Type())
-			n.SetType(nil)
-			return n
-		}
-
-		var t *types.Type
-		switch l.Type().Kind() {
-		default:
-			base.Errorf("invalid operation: %v (arguments have type %v, expected floating-point)", n, l.Type())
-			n.SetType(nil)
-			return n
-
-		case types.TIDEAL:
-			t = types.UntypedComplex
-
-		case types.TFLOAT32:
-			t = types.Types[types.TCOMPLEX64]
-
-		case types.TFLOAT64:
-			t = types.Types[types.TCOMPLEX128]
-		}
-		n.SetType(t)
-		return n
-
-	case ir.OCLOSE:
-		n := n.(*ir.UnaryExpr)
-		n.X = Expr(n.X)
-		n.X = DefaultLit(n.X, nil)
-		l := n.X
-		t := l.Type()
-		if t == nil {
-			n.SetType(nil)
-			return n
-		}
-		if !t.IsChan() {
-			base.Errorf("invalid operation: %v (non-chan type %v)", n, t)
-			n.SetType(nil)
-			return n
-		}
-
-		if !t.ChanDir().CanSend() {
-			base.Errorf("invalid operation: %v (cannot close receive-only channel)", n)
-			n.SetType(nil)
-			return n
-		}
-		return n
-
-	case ir.ODELETE:
-		n := n.(*ir.CallExpr)
-		typecheckargs(n)
-		args := n.Args
-		if len(args) == 0 {
-			base.Errorf("missing arguments to delete")
-			n.SetType(nil)
-			return n
-		}
-
-		if len(args) == 1 {
-			base.Errorf("missing second (key) argument to delete")
-			n.SetType(nil)
-			return n
-		}
-
-		if len(args) != 2 {
-			base.Errorf("too many arguments to delete")
-			n.SetType(nil)
-			return n
-		}
-
-		l := args[0]
-		r := args[1]
-		if l.Type() != nil && !l.Type().IsMap() {
-			base.Errorf("first argument to delete must be map; have %L", l.Type())
-			n.SetType(nil)
-			return n
-		}
-
-		args[1] = AssignConv(r, l.Type().Key(), "delete")
-		return n
-
-	case ir.OAPPEND:
-		n := n.(*ir.CallExpr)
-		typecheckargs(n)
-		args := n.Args
-		if len(args) == 0 {
-			base.Errorf("missing arguments to append")
-			n.SetType(nil)
-			return n
-		}
-
-		t := args[0].Type()
-		if t == nil {
-			n.SetType(nil)
-			return n
-		}
-
-		n.SetType(t)
-		if !t.IsSlice() {
-			if ir.IsNil(args[0]) {
-				base.Errorf("first argument to append must be typed slice; have untyped nil")
-				n.SetType(nil)
-				return n
-			}
-
-			base.Errorf("first argument to append must be slice; have %L", t)
-			n.SetType(nil)
-			return n
-		}
-
-		if n.IsDDD {
-			if len(args) == 1 {
-				base.Errorf("cannot use ... on first argument to append")
-				n.SetType(nil)
-				return n
-			}
-
-			if len(args) != 2 {
-				base.Errorf("too many arguments to append")
-				n.SetType(nil)
-				return n
-			}
-
-			if t.Elem().IsKind(types.TUINT8) && args[1].Type().IsString() {
-				args[1] = DefaultLit(args[1], types.Types[types.TSTRING])
-				return n
-			}
-
-			args[1] = AssignConv(args[1], t.Underlying(), "append")
-			return n
-		}
-
-		as := args[1:]
-		for i, n := range as {
-			if n.Type() == nil {
-				continue
-			}
-			as[i] = AssignConv(n, t.Elem(), "append")
-			types.CheckSize(as[i].Type()) // ensure width is calculated for backend
-		}
-		return n
-
-	case ir.OCOPY:
-		n := n.(*ir.BinaryExpr)
-		n.SetType(types.Types[types.TINT])
-		n.X = Expr(n.X)
-		n.X = DefaultLit(n.X, nil)
-		n.Y = Expr(n.Y)
-		n.Y = DefaultLit(n.Y, nil)
-		if n.X.Type() == nil || n.Y.Type() == nil {
-			n.SetType(nil)
-			return n
-		}
-
-		// copy([]byte, string)
-		if n.X.Type().IsSlice() && n.Y.Type().IsString() {
-			if types.Identical(n.X.Type().Elem(), types.ByteType) {
-				return n
-			}
-			base.Errorf("arguments to copy have different element types: %L and string", n.X.Type())
-			n.SetType(nil)
-			return n
-		}
-
-		if !n.X.Type().IsSlice() || !n.Y.Type().IsSlice() {
-			if !n.X.Type().IsSlice() && !n.Y.Type().IsSlice() {
-				base.Errorf("arguments to copy must be slices; have %L, %L", n.X.Type(), n.Y.Type())
-			} else if !n.X.Type().IsSlice() {
-				base.Errorf("first argument to copy should be slice; have %L", n.X.Type())
-			} else {
-				base.Errorf("second argument to copy should be slice or string; have %L", n.Y.Type())
-			}
-			n.SetType(nil)
-			return n
-		}
-
-		if !types.Identical(n.X.Type().Elem(), n.Y.Type().Elem()) {
-			base.Errorf("arguments to copy have different element types: %L and %L", n.X.Type(), n.Y.Type())
-			n.SetType(nil)
-			return n
-		}
-		return n
-
-	case ir.OCONV:
-		n := n.(*ir.ConvExpr)
-		types.CheckSize(n.Type()) // ensure width is calculated for backend
-		n.X = Expr(n.X)
-		n.X = convlit1(n.X, n.Type(), true, nil)
-		t := n.X.Type()
-		if t == nil || n.Type() == nil {
-			n.SetType(nil)
-			return n
-		}
-		op, why := convertop(n.X.Op() == ir.OLITERAL, t, n.Type())
-		if op == ir.OXXX {
-			if !n.Diag() && !n.Type().Broke() && !n.X.Diag() {
-				base.Errorf("cannot convert %L to type %v%s", n.X, n.Type(), why)
-				n.SetDiag(true)
-			}
-			n.SetOp(ir.OCONV)
-			n.SetType(nil)
-			return n
-		}
-
-		n.SetOp(op)
-		switch n.Op() {
-		case ir.OCONVNOP:
-			if t.Kind() == n.Type().Kind() {
-				switch t.Kind() {
-				case types.TFLOAT32, types.TFLOAT64, types.TCOMPLEX64, types.TCOMPLEX128:
-					// Floating point casts imply rounding and
-					// so the conversion must be kept.
-					n.SetOp(ir.OCONV)
-				}
-			}
-
-		// do not convert to []byte literal. See CL 125796.
-		// generated code and compiler memory footprint is better without it.
-		case ir.OSTR2BYTES:
-			// ok
-
-		case ir.OSTR2RUNES:
-			if n.X.Op() == ir.OLITERAL {
-				return stringtoruneslit(n)
-			}
-		}
+	case ir.OALIGNOF, ir.OOFFSETOF, ir.OSIZEOF:
+		n := n.(*ir.UnaryExpr)
+		n.SetType(types.Types[types.TUINTPTR])
 		return n
 
-	case ir.OMAKE:
-		n := n.(*ir.CallExpr)
-		args := n.Args
-		if len(args) == 0 {
-			base.Errorf("missing argument to make")
-			n.SetType(nil)
-			return n
-		}
+	case ir.OCAP, ir.OLEN:
+		n := n.(*ir.UnaryExpr)
+		return tcLenCap(n)
 
-		n.Args.Set(nil)
-		l := args[0]
-		l = check(l, ctxType)
-		t := l.Type()
-		if t == nil {
-			n.SetType(nil)
-			return n
-		}
+	case ir.OREAL, ir.OIMAG:
+		n := n.(*ir.UnaryExpr)
+		return tcRealImag(n)
 
-		i := 1
-		var nn ir.Node
-		switch t.Kind() {
-		default:
-			base.Errorf("cannot make type %v", t)
-			n.SetType(nil)
-			return n
+	case ir.OCOMPLEX:
+		n := n.(*ir.BinaryExpr)
+		return tcComplex(n)
 
-		case types.TSLICE:
-			if i >= len(args) {
-				base.Errorf("missing len argument to make(%v)", t)
-				n.SetType(nil)
-				return n
-			}
+	case ir.OCLOSE:
+		n := n.(*ir.UnaryExpr)
+		return tcClose(n)
 
-			l = args[i]
-			i++
-			l = Expr(l)
-			var r ir.Node
-			if i < len(args) {
-				r = args[i]
-				i++
-				r = Expr(r)
-			}
+	case ir.ODELETE:
+		n := n.(*ir.CallExpr)
+		return tcDelete(n)
 
-			if l.Type() == nil || (r != nil && r.Type() == nil) {
-				n.SetType(nil)
-				return n
-			}
-			if !checkmake(t, "len", &l) || r != nil && !checkmake(t, "cap", &r) {
-				n.SetType(nil)
-				return n
-			}
-			if ir.IsConst(l, constant.Int) && r != nil && ir.IsConst(r, constant.Int) && constant.Compare(l.Val(), token.GTR, r.Val()) {
-				base.Errorf("len larger than cap in make(%v)", t)
-				n.SetType(nil)
-				return n
-			}
-			nn = ir.NewMakeExpr(n.Pos(), ir.OMAKESLICE, l, r)
-
-		case types.TMAP:
-			if i < len(args) {
-				l = args[i]
-				i++
-				l = Expr(l)
-				l = DefaultLit(l, types.Types[types.TINT])
-				if l.Type() == nil {
-					n.SetType(nil)
-					return n
-				}
-				if !checkmake(t, "size", &l) {
-					n.SetType(nil)
-					return n
-				}
-			} else {
-				l = ir.NewInt(0)
-			}
-			nn = ir.NewMakeExpr(n.Pos(), ir.OMAKEMAP, l, nil)
-			nn.SetEsc(n.Esc())
-
-		case types.TCHAN:
-			l = nil
-			if i < len(args) {
-				l = args[i]
-				i++
-				l = Expr(l)
-				l = DefaultLit(l, types.Types[types.TINT])
-				if l.Type() == nil {
-					n.SetType(nil)
-					return n
-				}
-				if !checkmake(t, "buffer", &l) {
-					n.SetType(nil)
-					return n
-				}
-			} else {
-				l = ir.NewInt(0)
-			}
-			nn = ir.NewMakeExpr(n.Pos(), ir.OMAKECHAN, l, nil)
-		}
+	case ir.OAPPEND:
+		n := n.(*ir.CallExpr)
+		return tcAppend(n)
 
-		if i < len(args) {
-			base.Errorf("too many arguments to make(%v)", t)
-			n.SetType(nil)
-			return n
-		}
+	case ir.OCOPY:
+		n := n.(*ir.BinaryExpr)
+		return tcCopy(n)
 
-		nn.SetType(t)
-		return nn
+	case ir.OCONV:
+		n := n.(*ir.ConvExpr)
+		return tcConv(n)
+
+	case ir.OMAKE:
+		n := n.(*ir.CallExpr)
+		return tcMake(n)
 
 	case ir.ONEW:
 		n := n.(*ir.UnaryExpr)
-		if n.X == nil {
-			// Fatalf because the OCALL above checked for us,
-			// so this must be an internally-generated mistake.
-			base.Fatalf("missing argument to new")
-		}
-		l := n.X
-		l = check(l, ctxType)
-		t := l.Type()
-		if t == nil {
-			n.SetType(nil)
-			return n
-		}
-		n.X = l
-		n.SetType(types.NewPtr(t))
-		return n
+		return tcNew(n)
 
 	case ir.OPRINT, ir.OPRINTN:
 		n := n.(*ir.CallExpr)
-		typecheckargs(n)
-		ls := n.Args
-		for i1, n1 := range ls {
-			// Special case for print: int constant is int64, not int.
-			if ir.IsConst(n1, constant.Int) {
-				ls[i1] = DefaultLit(ls[i1], types.Types[types.TINT64])
-			} else {
-				ls[i1] = DefaultLit(ls[i1], nil)
-			}
-		}
-		return n
+		return tcPrint(n)
 
 	case ir.OPANIC:
 		n := n.(*ir.UnaryExpr)
-		n.X = Expr(n.X)
-		n.X = DefaultLit(n.X, types.Types[types.TINTER])
-		if n.X.Type() == nil {
-			n.SetType(nil)
-			return n
-		}
-		return n
+		return tcPanic(n)
 
 	case ir.ORECOVER:
 		n := n.(*ir.CallExpr)
-		if len(n.Args) != 0 {
-			base.Errorf("too many arguments to recover")
-			n.SetType(nil)
-			return n
-		}
-
-		n.SetType(types.Types[types.TINTER])
-		return n
+		return tcRecover(n)
 
 	case ir.OCLOSURE:
 		n := n.(*ir.ClosureExpr)
-		typecheckclosure(n, top)
+		tcClosure(n, top)
 		if n.Type() == nil {
 			return n
 		}
@@ -2129,17 +817,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OITAB:
 		n := n.(*ir.UnaryExpr)
-		n.X = Expr(n.X)
-		t := n.X.Type()
-		if t == nil {
-			n.SetType(nil)
-			return n
-		}
-		if !t.IsInterface() {
-			base.Fatalf("OITAB of %v", t)
-		}
-		n.SetType(types.NewPtr(types.Types[types.TUINTPTR]))
-		return n
+		return tcITab(n)
 
 	case ir.OIDATA:
 		// Whoever creates the OIDATA node must know a priori the concrete type at that moment,
@@ -2150,21 +828,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.OSPTR:
 		n := n.(*ir.UnaryExpr)
-		n.X = Expr(n.X)
-		t := n.X.Type()
-		if t == nil {
-			n.SetType(nil)
-			return n
-		}
-		if !t.IsSlice() && !t.IsString() {
-			base.Fatalf("OSPTR of %v", t)
-		}
-		if t.IsString() {
-			n.SetType(types.NewPtr(types.Types[types.TUINT8]))
-		} else {
-			n.SetType(types.NewPtr(t.Elem()))
-		}
-		return n
+		return tcSPtr(n)
 
 	case ir.OCLOSUREREAD:
 		return n
@@ -2183,7 +847,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 	// statements
 	case ir.OAS:
 		n := n.(*ir.AssignStmt)
-		typecheckas(n)
+		tcAssign(n)
 
 		// Code that creates temps does not bother to set defn, so do it here.
 		if n.X.Op() == ir.ONAME && ir.IsAutoTmp(n.X) {
@@ -2192,7 +856,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.OAS2:
-		typecheckas2(n.(*ir.AssignListStmt))
+		tcAssignList(n.(*ir.AssignListStmt))
 		return n
 
 	case ir.OBREAK,
@@ -2221,76 +885,38 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.ODEFER, ir.OGO:
 		n := n.(*ir.GoDeferStmt)
-		n.Call = check(n.Call, ctxStmt|ctxExpr)
+		n.Call = typecheck(n.Call, ctxStmt|ctxExpr)
 		if !n.Call.Diag() {
-			checkdefergo(n)
+			tcGoDefer(n)
 		}
 		return n
 
 	case ir.OFOR, ir.OFORUNTIL:
 		n := n.(*ir.ForStmt)
-		Stmts(n.Init())
-		decldepth++
-		n.Cond = Expr(n.Cond)
-		n.Cond = DefaultLit(n.Cond, nil)
-		if n.Cond != nil {
-			t := n.Cond.Type()
-			if t != nil && !t.IsBoolean() {
-				base.Errorf("non-bool %L used as for condition", n.Cond)
-			}
-		}
-		n.Post = Stmt(n.Post)
-		if n.Op() == ir.OFORUNTIL {
-			Stmts(n.Late)
-		}
-		Stmts(n.Body)
-		decldepth--
-		return n
+		return tcFor(n)
 
 	case ir.OIF:
 		n := n.(*ir.IfStmt)
-		Stmts(n.Init())
-		n.Cond = Expr(n.Cond)
-		n.Cond = DefaultLit(n.Cond, nil)
-		if n.Cond != nil {
-			t := n.Cond.Type()
-			if t != nil && !t.IsBoolean() {
-				base.Errorf("non-bool %L used as if condition", n.Cond)
-			}
-		}
-		Stmts(n.Body)
-		Stmts(n.Else)
-		return n
+		return tcIf(n)
 
 	case ir.ORETURN:
 		n := n.(*ir.ReturnStmt)
-		typecheckargs(n)
-		if ir.CurFunc == nil {
-			base.Errorf("return outside function")
-			n.SetType(nil)
-			return n
-		}
-
-		if ir.HasNamedResults(ir.CurFunc) && len(n.Results) == 0 {
-			return n
-		}
-		typecheckaste(ir.ORETURN, nil, false, ir.CurFunc.Type().Results(), n.Results, func() string { return "return argument" })
-		return n
+		return tcReturn(n)
 
 	case ir.ORETJMP:
 		n := n.(*ir.BranchStmt)
 		return n
 
 	case ir.OSELECT:
-		typecheckselect(n.(*ir.SelectStmt))
+		tcSelect(n.(*ir.SelectStmt))
 		return n
 
 	case ir.OSWITCH:
-		typecheckswitch(n.(*ir.SwitchStmt))
+		tcSwitch(n.(*ir.SwitchStmt))
 		return n
 
 	case ir.ORANGE:
-		typecheckrange(n.(*ir.RangeStmt))
+		tcRange(n.(*ir.RangeStmt))
 		return n
 
 	case ir.OTYPESW:
@@ -2300,7 +926,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 		return n
 
 	case ir.ODCLFUNC:
-		typecheckfunc(n.(*ir.Func))
+		tcFunc(n.(*ir.Func))
 		return n
 
 	case ir.ODCLCONST:
@@ -2310,7 +936,7 @@ func typecheck1(n ir.Node, top int) (res ir.Node) {
 
 	case ir.ODCLTYPE:
 		n := n.(*ir.Decl)
-		n.X = check(n.X, ctxType)
+		n.X = typecheck(n.X, ctxType)
 		types.CheckSize(n.X.Type())
 		return n
 	}
@@ -2424,59 +1050,6 @@ func checksliceconst(lo ir.Node, hi ir.Node) bool {
 	return true
 }
 
-func checkdefergo(n *ir.GoDeferStmt) {
-	what := "defer"
-	if n.Op() == ir.OGO {
-		what = "go"
-	}
-
-	switch n.Call.Op() {
-	// ok
-	case ir.OCALLINTER,
-		ir.OCALLMETH,
-		ir.OCALLFUNC,
-		ir.OCLOSE,
-		ir.OCOPY,
-		ir.ODELETE,
-		ir.OPANIC,
-		ir.OPRINT,
-		ir.OPRINTN,
-		ir.ORECOVER:
-		return
-
-	case ir.OAPPEND,
-		ir.OCAP,
-		ir.OCOMPLEX,
-		ir.OIMAG,
-		ir.OLEN,
-		ir.OMAKE,
-		ir.OMAKESLICE,
-		ir.OMAKECHAN,
-		ir.OMAKEMAP,
-		ir.ONEW,
-		ir.OREAL,
-		ir.OLITERAL: // conversion or unsafe.Alignof, Offsetof, Sizeof
-		if orig := ir.Orig(n.Call); orig.Op() == ir.OCONV {
-			break
-		}
-		base.ErrorfAt(n.Pos(), "%s discards result of %v", what, n.Call)
-		return
-	}
-
-	// type is broken or missing, most likely a method call on a broken type
-	// we will warn about the broken type elsewhere. no need to emit a potentially confusing error
-	if n.Call.Type() == nil || n.Call.Type().Broke() {
-		return
-	}
-
-	if !n.Diag() {
-		// The syntax made sure it was a call, so this must be
-		// a conversion.
-		n.SetDiag(true)
-		base.ErrorfAt(n.Pos(), "%s requires function call, not conversion", what)
-	}
-}
-
 // The result of implicitstar MUST be assigned back to n, e.g.
 // 	n.Left = implicitstar(n.Left)
 func implicitstar(n ir.Node) ir.Node {
@@ -2687,11 +1260,11 @@ func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 				checklvalue(n.X, "call pointer method on")
 				addr := NodAddr(n.X)
 				addr.SetImplicit(true)
-				n.X = check(addr, ctxType|ctxExpr)
+				n.X = typecheck(addr, ctxType|ctxExpr)
 			} else if tt.IsPtr() && (!rcvr.IsPtr() || rcvr.IsPtr() && rcvr.Elem().NotInHeap()) && types.Identical(tt.Elem(), rcvr) {
 				star := ir.NewStarExpr(base.Pos, n.X)
 				star.SetImplicit(true)
-				n.X = check(star, ctxType|ctxExpr)
+				n.X = typecheck(star, ctxType|ctxExpr)
 			} else if tt.IsPtr() && tt.Elem().IsPtr() && types.Identical(derefall(tt), derefall(rcvr)) {
 				base.Errorf("calling method %v with receiver %L requires explicit dereference", n.Sel, n.X)
 				for tt.IsPtr() {
@@ -2701,7 +1274,7 @@ func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 					}
 					star := ir.NewStarExpr(base.Pos, n.X)
 					star.SetImplicit(true)
-					n.X = check(star, ctxType|ctxExpr)
+					n.X = typecheck(star, ctxType|ctxExpr)
 					tt = tt.Elem()
 				}
 			} else {
@@ -2985,214 +1558,6 @@ func pushtype(nn ir.Node, t *types.Type) ir.Node {
 	return n
 }
 
-// The result of typecheckcomplit MUST be assigned back to n, e.g.
-// 	n.Left = typecheckcomplit(n.Left)
-func typecheckcomplit(n *ir.CompLitExpr) (res ir.Node) {
-	if base.EnableTrace && base.Flag.LowerT {
-		defer tracePrint("typecheckcomplit", n)(&res)
-	}
-
-	lno := base.Pos
-	defer func() {
-		base.Pos = lno
-	}()
-
-	if n.Ntype == nil {
-		base.ErrorfAt(n.Pos(), "missing type in composite literal")
-		n.SetType(nil)
-		return n
-	}
-
-	// Save original node (including n.Right)
-	n.SetOrig(ir.Copy(n))
-
-	ir.SetPos(n.Ntype)
-
-	// Need to handle [...]T arrays specially.
-	if array, ok := n.Ntype.(*ir.ArrayType); ok && array.Elem != nil && array.Len == nil {
-		array.Elem = check(array.Elem, ctxType)
-		elemType := array.Elem.Type()
-		if elemType == nil {
-			n.SetType(nil)
-			return n
-		}
-		length := typecheckarraylit(elemType, -1, n.List, "array literal")
-		n.SetOp(ir.OARRAYLIT)
-		n.SetType(types.NewArray(elemType, length))
-		n.Ntype = nil
-		return n
-	}
-
-	n.Ntype = ir.Node(check(n.Ntype, ctxType)).(ir.Ntype)
-	t := n.Ntype.Type()
-	if t == nil {
-		n.SetType(nil)
-		return n
-	}
-	n.SetType(t)
-
-	switch t.Kind() {
-	default:
-		base.Errorf("invalid composite literal type %v", t)
-		n.SetType(nil)
-
-	case types.TARRAY:
-		typecheckarraylit(t.Elem(), t.NumElem(), n.List, "array literal")
-		n.SetOp(ir.OARRAYLIT)
-		n.Ntype = nil
-
-	case types.TSLICE:
-		length := typecheckarraylit(t.Elem(), -1, n.List, "slice literal")
-		n.SetOp(ir.OSLICELIT)
-		n.Ntype = nil
-		n.Len = length
-
-	case types.TMAP:
-		var cs constSet
-		for i3, l := range n.List {
-			ir.SetPos(l)
-			if l.Op() != ir.OKEY {
-				n.List[i3] = Expr(l)
-				base.Errorf("missing key in map literal")
-				continue
-			}
-			l := l.(*ir.KeyExpr)
-
-			r := l.Key
-			r = pushtype(r, t.Key())
-			r = Expr(r)
-			l.Key = AssignConv(r, t.Key(), "map key")
-			cs.add(base.Pos, l.Key, "key", "map literal")
-
-			r = l.Value
-			r = pushtype(r, t.Elem())
-			r = Expr(r)
-			l.Value = AssignConv(r, t.Elem(), "map value")
-		}
-
-		n.SetOp(ir.OMAPLIT)
-		n.Ntype = nil
-
-	case types.TSTRUCT:
-		// Need valid field offsets for Xoffset below.
-		types.CalcSize(t)
-
-		errored := false
-		if len(n.List) != 0 && nokeys(n.List) {
-			// simple list of variables
-			ls := n.List
-			for i, n1 := range ls {
-				ir.SetPos(n1)
-				n1 = Expr(n1)
-				ls[i] = n1
-				if i >= t.NumFields() {
-					if !errored {
-						base.Errorf("too many values in %v", n)
-						errored = true
-					}
-					continue
-				}
-
-				f := t.Field(i)
-				s := f.Sym
-				if s != nil && !types.IsExported(s.Name) && s.Pkg != types.LocalPkg {
-					base.Errorf("implicit assignment of unexported field '%s' in %v literal", s.Name, t)
-				}
-				// No pushtype allowed here. Must name fields for that.
-				n1 = AssignConv(n1, f.Type, "field value")
-				sk := ir.NewStructKeyExpr(base.Pos, f.Sym, n1)
-				sk.Offset = f.Offset
-				ls[i] = sk
-			}
-			if len(ls) < t.NumFields() {
-				base.Errorf("too few values in %v", n)
-			}
-		} else {
-			hash := make(map[string]bool)
-
-			// keyed list
-			ls := n.List
-			for i, l := range ls {
-				ir.SetPos(l)
-
-				if l.Op() == ir.OKEY {
-					kv := l.(*ir.KeyExpr)
-					key := kv.Key
-
-					// Sym might have resolved to name in other top-level
-					// package, because of import dot. Redirect to correct sym
-					// before we do the lookup.
-					s := key.Sym()
-					if id, ok := key.(*ir.Ident); ok && DotImportRefs[id] != nil {
-						s = Lookup(s.Name)
-					}
-
-					// An OXDOT uses the Sym field to hold
-					// the field to the right of the dot,
-					// so s will be non-nil, but an OXDOT
-					// is never a valid struct literal key.
-					if s == nil || s.Pkg != types.LocalPkg || key.Op() == ir.OXDOT || s.IsBlank() {
-						base.Errorf("invalid field name %v in struct initializer", key)
-						continue
-					}
-
-					l = ir.NewStructKeyExpr(l.Pos(), s, kv.Value)
-					ls[i] = l
-				}
-
-				if l.Op() != ir.OSTRUCTKEY {
-					if !errored {
-						base.Errorf("mixture of field:value and value initializers")
-						errored = true
-					}
-					ls[i] = Expr(ls[i])
-					continue
-				}
-				l := l.(*ir.StructKeyExpr)
-
-				f := lookdot1(nil, l.Field, t, t.Fields(), 0)
-				if f == nil {
-					if ci := lookdot1(nil, l.Field, t, t.Fields(), 2); ci != nil { // Case-insensitive lookup.
-						if visible(ci.Sym) {
-							base.Errorf("unknown field '%v' in struct literal of type %v (but does have %v)", l.Field, t, ci.Sym)
-						} else if nonexported(l.Field) && l.Field.Name == ci.Sym.Name { // Ensure exactness before the suggestion.
-							base.Errorf("cannot refer to unexported field '%v' in struct literal of type %v", l.Field, t)
-						} else {
-							base.Errorf("unknown field '%v' in struct literal of type %v", l.Field, t)
-						}
-						continue
-					}
-					var f *types.Field
-					p, _ := dotpath(l.Field, t, &f, true)
-					if p == nil || f.IsMethod() {
-						base.Errorf("unknown field '%v' in struct literal of type %v", l.Field, t)
-						continue
-					}
-					// dotpath returns the parent embedded types in reverse order.
-					var ep []string
-					for ei := len(p) - 1; ei >= 0; ei-- {
-						ep = append(ep, p[ei].field.Sym.Name)
-					}
-					ep = append(ep, l.Field.Name)
-					base.Errorf("cannot use promoted field %v in struct literal of type %v", strings.Join(ep, "."), t)
-					continue
-				}
-				fielddup(f.Sym.Name, hash)
-				l.Offset = f.Offset
-
-				// No pushtype allowed here. Tried and rejected.
-				l.Value = Expr(l.Value)
-				l.Value = AssignConv(l.Value, f.Type, "field value")
-			}
-		}
-
-		n.SetOp(ir.OSTRUCTLIT)
-		n.Ntype = nil
-	}
-
-	return n
-}
-
 // typecheckarraylit type-checks a sequence of slice/array literal elements.
 func typecheckarraylit(elemType *types.Type, bound int64, elts []ir.Node, ctx string) int64 {
 	// If there are key/value pairs, create a map to keep seen
@@ -3324,60 +1689,6 @@ func checkassignlist(stmt ir.Node, l ir.Nodes) {
 	}
 }
 
-// type check assignment.
-// if this assignment is the definition of a var on the left side,
-// fill in the var's type.
-func typecheckas(n *ir.AssignStmt) {
-	if base.EnableTrace && base.Flag.LowerT {
-		defer tracePrint("typecheckas", n)(nil)
-	}
-
-	// delicate little dance.
-	// the definition of n may refer to this assignment
-	// as its definition, in which case it will call typecheckas.
-	// in that case, do not call typecheck back, or it will cycle.
-	// if the variable has a type (ntype) then typechecking
-	// will not look at defn, so it is okay (and desirable,
-	// so that the conversion below happens).
-	n.X = Resolve(n.X)
-
-	if !ir.DeclaredBy(n.X, n) || n.X.Name().Ntype != nil {
-		n.X = AssignExpr(n.X)
-	}
-
-	// Use ctxMultiOK so we can emit an "N variables but M values" error
-	// to be consistent with typecheckas2 (#26616).
-	n.Y = check(n.Y, ctxExpr|ctxMultiOK)
-	checkassign(n, n.X)
-	if n.Y != nil && n.Y.Type() != nil {
-		if n.Y.Type().IsFuncArgStruct() {
-			base.Errorf("assignment mismatch: 1 variable but %v returns %d values", n.Y.(*ir.CallExpr).X, n.Y.Type().NumFields())
-			// Multi-value RHS isn't actually valid for OAS; nil out
-			// to indicate failed typechecking.
-			n.Y.SetType(nil)
-		} else if n.X.Type() != nil {
-			n.Y = AssignConv(n.Y, n.X.Type(), "assignment")
-		}
-	}
-
-	if ir.DeclaredBy(n.X, n) && n.X.Name().Ntype == nil {
-		n.Y = DefaultLit(n.Y, nil)
-		n.X.SetType(n.Y.Type())
-	}
-
-	// second half of dance.
-	// now that right is done, typecheck the left
-	// just to get it over with.  see dance above.
-	n.SetTypecheck(1)
-
-	if n.X.Typecheck() == 0 {
-		n.X = AssignExpr(n.X)
-	}
-	if !ir.IsBlank(n.X) {
-		types.CheckSize(n.X.Type()) // ensure width is calculated for backend
-	}
-}
-
 func checkassignto(src *types.Type, dst ir.Node) {
 	if op, why := assignop(src, dst.Type()); op == ir.OXXX {
 		base.Errorf("cannot assign %v to %L in multiple assignment%s", src, dst, why)
@@ -3385,173 +1696,6 @@ func checkassignto(src *types.Type, dst ir.Node) {
 	}
 }
 
-func typecheckas2(n *ir.AssignListStmt) {
-	if base.EnableTrace && base.Flag.LowerT {
-		defer tracePrint("typecheckas2", n)(nil)
-	}
-
-	ls := n.Lhs
-	for i1, n1 := range ls {
-		// delicate little dance.
-		n1 = Resolve(n1)
-		ls[i1] = n1
-
-		if !ir.DeclaredBy(n1, n) || n1.Name().Ntype != nil {
-			ls[i1] = AssignExpr(ls[i1])
-		}
-	}
-
-	cl := len(n.Lhs)
-	cr := len(n.Rhs)
-	if cl > 1 && cr == 1 {
-		n.Rhs[0] = check(n.Rhs[0], ctxExpr|ctxMultiOK)
-	} else {
-		Exprs(n.Rhs)
-	}
-	checkassignlist(n, n.Lhs)
-
-	var l ir.Node
-	var r ir.Node
-	if cl == cr {
-		// easy
-		ls := n.Lhs
-		rs := n.Rhs
-		for il, nl := range ls {
-			nr := rs[il]
-			if nl.Type() != nil && nr.Type() != nil {
-				rs[il] = AssignConv(nr, nl.Type(), "assignment")
-			}
-			if ir.DeclaredBy(nl, n) && nl.Name().Ntype == nil {
-				rs[il] = DefaultLit(rs[il], nil)
-				nl.SetType(rs[il].Type())
-			}
-		}
-
-		goto out
-	}
-
-	l = n.Lhs[0]
-	r = n.Rhs[0]
-
-	// x,y,z = f()
-	if cr == 1 {
-		if r.Type() == nil {
-			goto out
-		}
-		switch r.Op() {
-		case ir.OCALLMETH, ir.OCALLINTER, ir.OCALLFUNC:
-			if !r.Type().IsFuncArgStruct() {
-				break
-			}
-			cr = r.Type().NumFields()
-			if cr != cl {
-				goto mismatch
-			}
-			r.(*ir.CallExpr).Use = ir.CallUseList
-			n.SetOp(ir.OAS2FUNC)
-			for i, l := range n.Lhs {
-				f := r.Type().Field(i)
-				if f.Type != nil && l.Type() != nil {
-					checkassignto(f.Type, l)
-				}
-				if ir.DeclaredBy(l, n) && l.Name().Ntype == nil {
-					l.SetType(f.Type)
-				}
-			}
-			goto out
-		}
-	}
-
-	// x, ok = y
-	if cl == 2 && cr == 1 {
-		if r.Type() == nil {
-			goto out
-		}
-		switch r.Op() {
-		case ir.OINDEXMAP, ir.ORECV, ir.ODOTTYPE:
-			switch r.Op() {
-			case ir.OINDEXMAP:
-				n.SetOp(ir.OAS2MAPR)
-			case ir.ORECV:
-				n.SetOp(ir.OAS2RECV)
-			case ir.ODOTTYPE:
-				r := r.(*ir.TypeAssertExpr)
-				n.SetOp(ir.OAS2DOTTYPE)
-				r.SetOp(ir.ODOTTYPE2)
-			}
-			if l.Type() != nil {
-				checkassignto(r.Type(), l)
-			}
-			if ir.DeclaredBy(l, n) {
-				l.SetType(r.Type())
-			}
-			l := n.Lhs[1]
-			if l.Type() != nil && !l.Type().IsBoolean() {
-				checkassignto(types.Types[types.TBOOL], l)
-			}
-			if ir.DeclaredBy(l, n) && l.Name().Ntype == nil {
-				l.SetType(types.Types[types.TBOOL])
-			}
-			goto out
-		}
-	}
-
-mismatch:
-	switch r.Op() {
-	default:
-		base.Errorf("assignment mismatch: %d variables but %d values", cl, cr)
-	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
-		r := r.(*ir.CallExpr)
-		base.Errorf("assignment mismatch: %d variables but %v returns %d values", cl, r.X, cr)
-	}
-
-	// second half of dance
-out:
-	n.SetTypecheck(1)
-	ls = n.Lhs
-	for i1, n1 := range ls {
-		if n1.Typecheck() == 0 {
-			ls[i1] = AssignExpr(ls[i1])
-		}
-	}
-}
-
-// type check function definition
-// To be called by typecheck, not directly.
-// (Call typecheckFunc instead.)
-func typecheckfunc(n *ir.Func) {
-	if base.EnableTrace && base.Flag.LowerT {
-		defer tracePrint("typecheckfunc", n)(nil)
-	}
-
-	for _, ln := range n.Dcl {
-		if ln.Op() == ir.ONAME && (ln.Class_ == ir.PPARAM || ln.Class_ == ir.PPARAMOUT) {
-			ln.Decldepth = 1
-		}
-	}
-
-	n.Nname = AssignExpr(n.Nname).(*ir.Name)
-	t := n.Nname.Type()
-	if t == nil {
-		return
-	}
-	n.SetType(t)
-	rcvr := t.Recv()
-	if rcvr != nil && n.Shortname != nil {
-		m := addmethod(n, n.Shortname, t, true, n.Pragma&ir.Nointerface != 0)
-		if m == nil {
-			return
-		}
-
-		n.Nname.SetSym(ir.MethodSym(rcvr.Type, n.Shortname))
-		Declare(n.Nname, ir.PFUNC)
-	}
-
-	if base.Ctxt.Flag_dynlink && !inimport && n.Nname != nil {
-		NeedFuncSym(n.Sym())
-	}
-}
-
 // The result of stringtoruneslit MUST be assigned back to n, e.g.
 // 	n.Left = stringtoruneslit(n.Left)
 func stringtoruneslit(n *ir.ConvExpr) ir.Node {
-- 
GitLab


From 575fd6ff0a886675412f1c24b390500b8413cebc Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 23 Dec 2020 00:44:42 -0500
Subject: [PATCH 0307/2400] [dev.regabi] cmd/compile: split out package inline
 [generated]

[git-generate]

cd src/cmd/compile/internal/gc
rf '
	mv numNonClosures inl.go
	mv inlFlood Inline_Flood
	mv inlcalls InlineCalls
	mv devirtualize Devirtualize
	mv caninl CanInline

	mv inl.go cmd/compile/internal/inline
'

Change-Id: Iee1f5b1e82d5cea6be4ecd91e6920500810f21de
Reviewed-on: https://go-review.googlesource.com/c/go/+/279309
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/export.go         |  3 +-
 src/cmd/compile/internal/gc/main.go           | 18 ++------
 src/cmd/compile/internal/gc/subr.go           |  3 +-
 .../compile/internal/{gc => inline}/inl.go    | 46 ++++++++++++-------
 4 files changed, 37 insertions(+), 33 deletions(-)
 rename src/cmd/compile/internal/{gc => inline}/inl.go (97%)

diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index a414962431..c65c6c8335 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/inline"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
@@ -83,7 +84,7 @@ func (p *exporter) markObject(n ir.Node) {
 	if n.Op() == ir.ONAME {
 		n := n.(*ir.Name)
 		if n.Class_ == ir.PFUNC {
-			inlFlood(n, typecheck.Export)
+			inline.Inline_Flood(n, typecheck.Export)
 		}
 	}
 
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index b98d1f2e10..7f20d6b8a5 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -10,6 +10,7 @@ import (
 	"bufio"
 	"bytes"
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/inline"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
@@ -184,7 +185,7 @@ func Main(archInit func(*Arch)) {
 
 	ir.EscFmt = escFmt
 	ir.IsIntrinsicCall = isIntrinsicCall
-	SSADumpInline = ssaDumpInline
+	inline.SSADumpInline = ssaDumpInline
 	initSSAEnv()
 	initSSATables()
 
@@ -231,13 +232,13 @@ func Main(archInit func(*Arch)) {
 	// Inlining
 	base.Timer.Start("fe", "inlining")
 	if base.Flag.LowerL != 0 {
-		InlinePackage()
+		inline.InlinePackage()
 	}
 
 	// Devirtualize.
 	for _, n := range typecheck.Target.Decls {
 		if n.Op() == ir.ODCLFUNC {
-			devirtualize(n.(*ir.Func))
+			inline.Devirtualize(n.(*ir.Func))
 		}
 	}
 	ir.CurFunc = nil
@@ -372,17 +373,6 @@ func cgoSymABIs() {
 	}
 }
 
-// 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 writebench(filename string) error {
 	f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
 	if err != nil {
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 8e2093d488..f76fb8e24a 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/inline"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
@@ -481,7 +482,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	// generate those wrappers within the same compilation unit as (T).M.
 	// TODO(mdempsky): Investigate why we can't enable this more generally.
 	if rcvr.IsPtr() && rcvr.Elem() == method.Type.Recv().Type && rcvr.Elem().Sym() != nil {
-		inlcalls(fn)
+		inline.InlineCalls(fn)
 	}
 	escapeFuncs([]*ir.Func{fn}, false)
 
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/inline/inl.go
similarity index 97%
rename from src/cmd/compile/internal/gc/inl.go
rename to src/cmd/compile/internal/inline/inl.go
index 9cf23caf0e..222e62d0cc 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -24,9 +24,14 @@
 // The Debug.m flag enables diagnostic output.  a single -m is useful for verifying
 // which calls get inlined or not, more is for debugging, and may go away at any point.
 
-package gc
+package inline
 
 import (
+	"errors"
+	"fmt"
+	"go/constant"
+	"strings"
+
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
@@ -34,10 +39,6 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/src"
-	"errors"
-	"fmt"
-	"go/constant"
-	"strings"
 )
 
 // Inlining budget parameters, gathered in one place
@@ -62,21 +63,21 @@ func InlinePackage() {
 				// We allow inlining if there is no
 				// recursion, or the recursion cycle is
 				// across more than one function.
-				caninl(n)
+				CanInline(n)
 			} else {
 				if base.Flag.LowerM > 1 {
 					fmt.Printf("%v: cannot inline %v: recursive\n", ir.Line(n), n.Nname)
 				}
 			}
-			inlcalls(n)
+			InlineCalls(n)
 		}
 	})
 }
 
 // Caninl determines whether fn is inlineable.
-// If so, caninl saves fn->nbody in fn->inl and substitutes it with a copy.
+// If so, CanInline saves fn->nbody in fn->inl and substitutes it with a copy.
 // fn and ->nbody will already have been typechecked.
-func caninl(fn *ir.Func) {
+func CanInline(fn *ir.Func) {
 	if fn.Nname == nil {
 		base.Fatalf("caninl no nname %+v", fn)
 	}
@@ -192,9 +193,9 @@ func caninl(fn *ir.Func) {
 	}
 }
 
-// inlFlood marks n's inline body for export and recursively ensures
+// Inline_Flood marks n's inline body for export and recursively ensures
 // all called functions are marked too.
-func inlFlood(n *ir.Name, exportsym func(*ir.Name)) {
+func Inline_Flood(n *ir.Name, exportsym func(*ir.Name)) {
 	if n == nil {
 		return
 	}
@@ -222,13 +223,13 @@ func inlFlood(n *ir.Name, exportsym func(*ir.Name)) {
 	ir.VisitList(ir.Nodes(fn.Inl.Body), func(n ir.Node) {
 		switch n.Op() {
 		case ir.OMETHEXPR, ir.ODOTMETH:
-			inlFlood(ir.MethodExprName(n), exportsym)
+			Inline_Flood(ir.MethodExprName(n), exportsym)
 
 		case ir.ONAME:
 			n := n.(*ir.Name)
 			switch n.Class_ {
 			case ir.PFUNC:
-				inlFlood(n, exportsym)
+				Inline_Flood(n, exportsym)
 				exportsym(n)
 			case ir.PEXTERN:
 				exportsym(n)
@@ -442,7 +443,7 @@ func isBigFunc(fn *ir.Func) bool {
 
 // Inlcalls/nodelist/node walks fn's statements and expressions and substitutes any
 // calls made to inlineable functions. This is the external entry point.
-func inlcalls(fn *ir.Func) {
+func InlineCalls(fn *ir.Func) {
 	savefn := ir.CurFunc
 	ir.CurFunc = fn
 	maxCost := int32(inlineMaxBudget)
@@ -631,7 +632,7 @@ func inlCallee(fn ir.Node) *ir.Func {
 	case ir.OCLOSURE:
 		fn := fn.(*ir.ClosureExpr)
 		c := fn.Func
-		caninl(c)
+		CanInline(c)
 		return c
 	}
 	return nil
@@ -1202,9 +1203,9 @@ func pruneUnusedAutos(ll []*ir.Name, vis *hairyVisitor) []*ir.Name {
 	return s
 }
 
-// devirtualize replaces interface method calls within fn with direct
+// Devirtualize replaces interface method calls within fn with direct
 // concrete-type method calls where applicable.
-func devirtualize(fn *ir.Func) {
+func Devirtualize(fn *ir.Func) {
 	ir.CurFunc = fn
 	ir.VisitList(fn.Body, func(n ir.Node) {
 		if n.Op() == ir.OCALLINTER {
@@ -1268,3 +1269,14 @@ func devirtualizeCall(call *ir.CallExpr) {
 		call.SetType(ft.Results())
 	}
 }
+
+// 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
+}
-- 
GitLab


From 0ced54062e9d58f8ff6b3beff0c8694e799d47a8 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 23 Dec 2020 00:46:27 -0500
Subject: [PATCH 0308/2400] [dev.regabi] cmd/compile: split out package objw
 [generated]

Object file writing routines are used not just at the end
of the compilation but also during static data layout in walk.
Split them into their own package.

[git-generate]

cd src/cmd/compile/internal/gc
rf '
	# Move bit vector to new package bitvec
	mv bvec.n bvec.N
	mv bvec.b bvec.B
	mv bvec BitVec
	mv bvalloc New
	mv bvbulkalloc NewBulk
	mv bulkBvec.next bulkBvec.Next
	mv bulkBvec Bulk
	mv H0 h0
	mv Hp hp

	# Leave bvecSet and bitmap hashes behind - not needed as broadly.
	mv bvecSet.extractUniqe bvecSet.extractUnique
	mv h0 bvecSet bvecSet.grow bvecSet.add \
		bvecSet.extractUnique hashbitmap bvset.go

	mv bv.go cmd/compile/internal/bitvec

	ex . ../arm ../arm64 ../mips ../mips64 ../ppc64 ../s390x ../riscv64 {
		import "cmd/internal/obj"
		var a *obj.Addr
		var i int64
		Addrconst(a, i) -> a.SetConst(i)
		var p, to *obj.Prog
		Patch(p, to) -> p.To.SetTarget(to)
	}
	rm Addrconst Patch

	# Move object-writing API to new package objw
	mv duint8 Objw_Uint8
	mv duint16 Objw_Uint16
	mv duint32 Objw_Uint32
	mv duintptr Objw_Uintptr
	mv duintxx Objw_UintN
	mv dsymptr Objw_SymPtr
	mv dsymptrOff Objw_SymPtrOff
	mv dsymptrWeakOff Objw_SymPtrWeakOff
	mv ggloblsym Objw_Global
	mv dbvec Objw_BitVec
	mv newProgs NewProgs
	mv Progs.clearp Progs.Clear
	mv Progs.settext Progs.SetText
	mv Progs.next Progs.Next
	mv Progs.pc Progs.PC
	mv Progs.pos Progs.Pos
	mv Progs.curfn Progs.CurFunc
	mv Progs.progcache Progs.Cache
	mv Progs.cacheidx Progs.CacheIndex
	mv Progs.nextLive Progs.NextLive
	mv Progs.prevLive Progs.PrevLive
	mv Progs.Appendpp Progs.Append
	mv LivenessIndex.stackMapIndex LivenessIndex.StackMapIndex
	mv LivenessIndex.isUnsafePoint LivenessIndex.IsUnsafePoint

	mv Objw_Uint8 Objw_Uint16 Objw_Uint32 Objw_Uintptr Objw_UintN \
		Objw_SymPtr Objw_SymPtrOff Objw_SymPtrWeakOff Objw_Global \
		Objw_BitVec \
		objw.go
	mv sharedProgArray NewProgs Progs \
		LivenessIndex StackMapDontCare \
		LivenessDontCare LivenessIndex.StackMapValid \
		Progs.NewProg Progs.Flush Progs.Free Progs.Prog Progs.Clear Progs.Append Progs.SetText \
		prog.go
	mv prog.go objw.go cmd/compile/internal/objw

	# Move ggloblnod to obj with the rest of the non-objw higher-level writing.
	mv ggloblnod obj.go
'

cd ../objw
rf '
	mv Objw_Uint8 Uint8
	mv Objw_Uint16 Uint16
	mv Objw_Uint32 Uint32
	mv Objw_Uintptr Uintptr
	mv Objw_UintN UintN
	mv Objw_SymPtr SymPtr
	mv Objw_SymPtrOff SymPtrOff
	mv Objw_SymPtrWeakOff SymPtrWeakOff
	mv Objw_Global Global
	mv Objw_BitVec BitVec
'

Change-Id: I2b87085aa788564fb322e9c55bddd73347b4d5fd
Reviewed-on: https://go-review.googlesource.com/c/go/+/279310
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/amd64/ggen.go    |  38 +--
 src/cmd/compile/internal/arm/ggen.go      |  26 +-
 src/cmd/compile/internal/arm/ssa.go       |   4 +-
 src/cmd/compile/internal/arm64/ggen.go    |  34 +--
 src/cmd/compile/internal/arm64/ssa.go     |  14 +-
 src/cmd/compile/internal/bitvec/bv.go     | 190 +++++++++++++++
 src/cmd/compile/internal/gc/alg.go        |  25 +-
 src/cmd/compile/internal/gc/bv.go         | 280 ----------------------
 src/cmd/compile/internal/gc/bvset.go      |  97 ++++++++
 src/cmd/compile/internal/gc/embed.go      |  29 +--
 src/cmd/compile/internal/gc/go.go         |   7 +-
 src/cmd/compile/internal/gc/gsubr.go      | 188 ---------------
 src/cmd/compile/internal/gc/init.go       |  13 +-
 src/cmd/compile/internal/gc/obj.go        |  93 +++----
 src/cmd/compile/internal/gc/pgen.go       |  16 +-
 src/cmd/compile/internal/gc/plive.go      | 142 +++++------
 src/cmd/compile/internal/gc/reflect.go    | 160 +++++++------
 src/cmd/compile/internal/gc/ssa.go        |  73 +++---
 src/cmd/compile/internal/mips/ggen.go     |  20 +-
 src/cmd/compile/internal/mips/ssa.go      |  16 +-
 src/cmd/compile/internal/mips64/ggen.go   |  24 +-
 src/cmd/compile/internal/mips64/ssa.go    |  16 +-
 src/cmd/compile/internal/objw/objw.go     |  72 ++++++
 src/cmd/compile/internal/objw/prog.go     | 218 +++++++++++++++++
 src/cmd/compile/internal/ppc64/ggen.go    |  30 +--
 src/cmd/compile/internal/ppc64/ssa.go     |  32 +--
 src/cmd/compile/internal/riscv64/ggen.go  |  22 +-
 src/cmd/compile/internal/riscv64/gsubr.go |   4 +-
 src/cmd/compile/internal/riscv64/ssa.go   |   8 +-
 src/cmd/compile/internal/s390x/ggen.go    |  22 +-
 src/cmd/compile/internal/s390x/ssa.go     |   8 +-
 src/cmd/compile/internal/wasm/ssa.go      |  11 +-
 src/cmd/compile/internal/x86/ggen.go      |  22 +-
 33 files changed, 1008 insertions(+), 946 deletions(-)
 create mode 100644 src/cmd/compile/internal/bitvec/bv.go
 delete mode 100644 src/cmd/compile/internal/gc/bv.go
 create mode 100644 src/cmd/compile/internal/gc/bvset.go
 create mode 100644 src/cmd/compile/internal/objw/objw.go
 create mode 100644 src/cmd/compile/internal/objw/prog.go

diff --git a/src/cmd/compile/internal/amd64/ggen.go b/src/cmd/compile/internal/amd64/ggen.go
index 48b00b3da9..dacdb07a38 100644
--- a/src/cmd/compile/internal/amd64/ggen.go
+++ b/src/cmd/compile/internal/amd64/ggen.go
@@ -6,8 +6,8 @@ package amd64
 
 import (
 	"cmd/compile/internal/base"
-	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/objw"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/x86"
@@ -54,7 +54,7 @@ func dzDI(b int64) int64 {
 	return -dzClearStep * (dzBlockLen - tailSteps)
 }
 
-func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.Prog {
+func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.Prog {
 	const (
 		ax = 1 << iota
 		x0
@@ -70,61 +70,61 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.Pr
 			base.Fatalf("zerorange count not a multiple of widthptr %d", cnt)
 		}
 		if *state&ax == 0 {
-			p = pp.Appendpp(p, x86.AMOVQ, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
+			p = pp.Append(p, x86.AMOVQ, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
 			*state |= ax
 		}
-		p = pp.Appendpp(p, x86.AMOVL, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_MEM, x86.REG_SP, off)
+		p = pp.Append(p, x86.AMOVL, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_MEM, x86.REG_SP, off)
 		off += int64(types.PtrSize)
 		cnt -= int64(types.PtrSize)
 	}
 
 	if cnt == 8 {
 		if *state&ax == 0 {
-			p = pp.Appendpp(p, x86.AMOVQ, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
+			p = pp.Append(p, x86.AMOVQ, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
 			*state |= ax
 		}
-		p = pp.Appendpp(p, x86.AMOVQ, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_MEM, x86.REG_SP, off)
+		p = pp.Append(p, x86.AMOVQ, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_MEM, x86.REG_SP, off)
 	} else if !isPlan9 && cnt <= int64(8*types.RegSize) {
 		if *state&x0 == 0 {
-			p = pp.Appendpp(p, x86.AXORPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_REG, x86.REG_X0, 0)
+			p = pp.Append(p, x86.AXORPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_REG, x86.REG_X0, 0)
 			*state |= x0
 		}
 
 		for i := int64(0); i < cnt/16; i++ {
-			p = pp.Appendpp(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_MEM, x86.REG_SP, off+i*16)
+			p = pp.Append(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_MEM, x86.REG_SP, off+i*16)
 		}
 
 		if cnt%16 != 0 {
-			p = pp.Appendpp(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_MEM, x86.REG_SP, off+cnt-int64(16))
+			p = pp.Append(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_MEM, x86.REG_SP, off+cnt-int64(16))
 		}
 	} else if !isPlan9 && (cnt <= int64(128*types.RegSize)) {
 		if *state&x0 == 0 {
-			p = pp.Appendpp(p, x86.AXORPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_REG, x86.REG_X0, 0)
+			p = pp.Append(p, x86.AXORPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_REG, x86.REG_X0, 0)
 			*state |= x0
 		}
-		p = pp.Appendpp(p, leaptr, obj.TYPE_MEM, x86.REG_SP, off+dzDI(cnt), obj.TYPE_REG, x86.REG_DI, 0)
-		p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_ADDR, 0, dzOff(cnt))
+		p = pp.Append(p, leaptr, obj.TYPE_MEM, x86.REG_SP, off+dzDI(cnt), obj.TYPE_REG, x86.REG_DI, 0)
+		p = pp.Append(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_ADDR, 0, dzOff(cnt))
 		p.To.Sym = ir.Syms.Duffzero
 
 		if cnt%16 != 0 {
-			p = pp.Appendpp(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_MEM, x86.REG_DI, -int64(8))
+			p = pp.Append(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_MEM, x86.REG_DI, -int64(8))
 		}
 	} else {
 		if *state&ax == 0 {
-			p = pp.Appendpp(p, x86.AMOVQ, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
+			p = pp.Append(p, x86.AMOVQ, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
 			*state |= ax
 		}
 
-		p = pp.Appendpp(p, x86.AMOVQ, obj.TYPE_CONST, 0, cnt/int64(types.RegSize), obj.TYPE_REG, x86.REG_CX, 0)
-		p = pp.Appendpp(p, leaptr, obj.TYPE_MEM, x86.REG_SP, off, obj.TYPE_REG, x86.REG_DI, 0)
-		p = pp.Appendpp(p, x86.AREP, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
-		p = pp.Appendpp(p, x86.ASTOSQ, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
+		p = pp.Append(p, x86.AMOVQ, obj.TYPE_CONST, 0, cnt/int64(types.RegSize), obj.TYPE_REG, x86.REG_CX, 0)
+		p = pp.Append(p, leaptr, obj.TYPE_MEM, x86.REG_SP, off, obj.TYPE_REG, x86.REG_DI, 0)
+		p = pp.Append(p, x86.AREP, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
+		p = pp.Append(p, x86.ASTOSQ, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
 	}
 
 	return p
 }
 
-func ginsnop(pp *gc.Progs) *obj.Prog {
+func ginsnop(pp *objw.Progs) *obj.Prog {
 	// This is a hardware nop (1-byte 0x90) instruction,
 	// even though we describe it as an explicit XCHGL here.
 	// Particularly, this does not zero the high 32 bits
diff --git a/src/cmd/compile/internal/arm/ggen.go b/src/cmd/compile/internal/arm/ggen.go
index 2363d76346..f2c676300a 100644
--- a/src/cmd/compile/internal/arm/ggen.go
+++ b/src/cmd/compile/internal/arm/ggen.go
@@ -5,51 +5,51 @@
 package arm
 
 import (
-	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/objw"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/arm"
 )
 
-func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, r0 *uint32) *obj.Prog {
+func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, r0 *uint32) *obj.Prog {
 	if cnt == 0 {
 		return p
 	}
 	if *r0 == 0 {
-		p = pp.Appendpp(p, arm.AMOVW, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, arm.REG_R0, 0)
+		p = pp.Append(p, arm.AMOVW, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, arm.REG_R0, 0)
 		*r0 = 1
 	}
 
 	if cnt < int64(4*types.PtrSize) {
 		for i := int64(0); i < cnt; i += int64(types.PtrSize) {
-			p = pp.Appendpp(p, arm.AMOVW, obj.TYPE_REG, arm.REG_R0, 0, obj.TYPE_MEM, arm.REGSP, 4+off+i)
+			p = pp.Append(p, arm.AMOVW, obj.TYPE_REG, arm.REG_R0, 0, obj.TYPE_MEM, arm.REGSP, 4+off+i)
 		}
 	} else if cnt <= int64(128*types.PtrSize) {
-		p = pp.Appendpp(p, arm.AADD, obj.TYPE_CONST, 0, 4+off, obj.TYPE_REG, arm.REG_R1, 0)
+		p = pp.Append(p, arm.AADD, obj.TYPE_CONST, 0, 4+off, obj.TYPE_REG, arm.REG_R1, 0)
 		p.Reg = arm.REGSP
-		p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
+		p = pp.Append(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
 		p.To.Name = obj.NAME_EXTERN
 		p.To.Sym = ir.Syms.Duffzero
 		p.To.Offset = 4 * (128 - cnt/int64(types.PtrSize))
 	} else {
-		p = pp.Appendpp(p, arm.AADD, obj.TYPE_CONST, 0, 4+off, obj.TYPE_REG, arm.REG_R1, 0)
+		p = pp.Append(p, arm.AADD, obj.TYPE_CONST, 0, 4+off, obj.TYPE_REG, arm.REG_R1, 0)
 		p.Reg = arm.REGSP
-		p = pp.Appendpp(p, arm.AADD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, arm.REG_R2, 0)
+		p = pp.Append(p, arm.AADD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, arm.REG_R2, 0)
 		p.Reg = arm.REG_R1
-		p = pp.Appendpp(p, arm.AMOVW, obj.TYPE_REG, arm.REG_R0, 0, obj.TYPE_MEM, arm.REG_R1, 4)
+		p = pp.Append(p, arm.AMOVW, obj.TYPE_REG, arm.REG_R0, 0, obj.TYPE_MEM, arm.REG_R1, 4)
 		p1 := p
 		p.Scond |= arm.C_PBIT
-		p = pp.Appendpp(p, arm.ACMP, obj.TYPE_REG, arm.REG_R1, 0, obj.TYPE_NONE, 0, 0)
+		p = pp.Append(p, arm.ACMP, obj.TYPE_REG, arm.REG_R1, 0, obj.TYPE_NONE, 0, 0)
 		p.Reg = arm.REG_R2
-		p = pp.Appendpp(p, arm.ABNE, obj.TYPE_NONE, 0, 0, obj.TYPE_BRANCH, 0, 0)
-		gc.Patch(p, p1)
+		p = pp.Append(p, arm.ABNE, obj.TYPE_NONE, 0, 0, obj.TYPE_BRANCH, 0, 0)
+		p.To.SetTarget(p1)
 	}
 
 	return p
 }
 
-func ginsnop(pp *gc.Progs) *obj.Prog {
+func ginsnop(pp *objw.Progs) *obj.Prog {
 	p := pp.Prog(arm.AAND)
 	p.From.Type = obj.TYPE_REG
 	p.From.Reg = arm.REG_R0
diff --git a/src/cmd/compile/internal/arm/ssa.go b/src/cmd/compile/internal/arm/ssa.go
index ab7ec6176b..30eae59331 100644
--- a/src/cmd/compile/internal/arm/ssa.go
+++ b/src/cmd/compile/internal/arm/ssa.go
@@ -779,7 +779,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p2.Reg = arm.REG_R1
 		p3 := s.Prog(arm.ABLE)
 		p3.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p3, p)
+		p3.To.SetTarget(p)
 	case ssa.OpARMLoweredMove:
 		// MOVW.P	4(R1), Rtmp
 		// MOVW.P	Rtmp, 4(R2)
@@ -820,7 +820,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p3.Reg = arm.REG_R1
 		p4 := s.Prog(arm.ABLE)
 		p4.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p4, p)
+		p4.To.SetTarget(p)
 	case ssa.OpARMEqual,
 		ssa.OpARMNotEqual,
 		ssa.OpARMLessThan,
diff --git a/src/cmd/compile/internal/arm64/ggen.go b/src/cmd/compile/internal/arm64/ggen.go
index 37f11e0ff6..8364535f63 100644
--- a/src/cmd/compile/internal/arm64/ggen.go
+++ b/src/cmd/compile/internal/arm64/ggen.go
@@ -5,8 +5,8 @@
 package arm64
 
 import (
-	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/objw"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/arm64"
@@ -24,24 +24,24 @@ func padframe(frame int64) int64 {
 	return frame
 }
 
-func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
+func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 	if cnt == 0 {
 		return p
 	}
 	if cnt < int64(4*types.PtrSize) {
 		for i := int64(0); i < cnt; i += int64(types.PtrSize) {
-			p = pp.Appendpp(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGZERO, 0, obj.TYPE_MEM, arm64.REGSP, 8+off+i)
+			p = pp.Append(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGZERO, 0, obj.TYPE_MEM, arm64.REGSP, 8+off+i)
 		}
 	} else if cnt <= int64(128*types.PtrSize) && !darwin { // darwin ld64 cannot handle BR26 reloc with non-zero addend
 		if cnt%(2*int64(types.PtrSize)) != 0 {
-			p = pp.Appendpp(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGZERO, 0, obj.TYPE_MEM, arm64.REGSP, 8+off)
+			p = pp.Append(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGZERO, 0, obj.TYPE_MEM, arm64.REGSP, 8+off)
 			off += int64(types.PtrSize)
 			cnt -= int64(types.PtrSize)
 		}
-		p = pp.Appendpp(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGSP, 0, obj.TYPE_REG, arm64.REG_R20, 0)
-		p = pp.Appendpp(p, arm64.AADD, obj.TYPE_CONST, 0, 8+off, obj.TYPE_REG, arm64.REG_R20, 0)
+		p = pp.Append(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGSP, 0, obj.TYPE_REG, arm64.REG_R20, 0)
+		p = pp.Append(p, arm64.AADD, obj.TYPE_CONST, 0, 8+off, obj.TYPE_REG, arm64.REG_R20, 0)
 		p.Reg = arm64.REG_R20
-		p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
+		p = pp.Append(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
 		p.To.Name = obj.NAME_EXTERN
 		p.To.Sym = ir.Syms.Duffzero
 		p.To.Offset = 4 * (64 - cnt/(2*int64(types.PtrSize)))
@@ -50,26 +50,26 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 		// We are at the function entry, where no register is live, so it is okay to clobber
 		// other registers
 		const rtmp = arm64.REG_R20
-		p = pp.Appendpp(p, arm64.AMOVD, obj.TYPE_CONST, 0, 8+off-8, obj.TYPE_REG, rtmp, 0)
-		p = pp.Appendpp(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGSP, 0, obj.TYPE_REG, arm64.REGRT1, 0)
-		p = pp.Appendpp(p, arm64.AADD, obj.TYPE_REG, rtmp, 0, obj.TYPE_REG, arm64.REGRT1, 0)
+		p = pp.Append(p, arm64.AMOVD, obj.TYPE_CONST, 0, 8+off-8, obj.TYPE_REG, rtmp, 0)
+		p = pp.Append(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGSP, 0, obj.TYPE_REG, arm64.REGRT1, 0)
+		p = pp.Append(p, arm64.AADD, obj.TYPE_REG, rtmp, 0, obj.TYPE_REG, arm64.REGRT1, 0)
 		p.Reg = arm64.REGRT1
-		p = pp.Appendpp(p, arm64.AMOVD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, rtmp, 0)
-		p = pp.Appendpp(p, arm64.AADD, obj.TYPE_REG, rtmp, 0, obj.TYPE_REG, arm64.REGRT2, 0)
+		p = pp.Append(p, arm64.AMOVD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, rtmp, 0)
+		p = pp.Append(p, arm64.AADD, obj.TYPE_REG, rtmp, 0, obj.TYPE_REG, arm64.REGRT2, 0)
 		p.Reg = arm64.REGRT1
-		p = pp.Appendpp(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGZERO, 0, obj.TYPE_MEM, arm64.REGRT1, int64(types.PtrSize))
+		p = pp.Append(p, arm64.AMOVD, obj.TYPE_REG, arm64.REGZERO, 0, obj.TYPE_MEM, arm64.REGRT1, int64(types.PtrSize))
 		p.Scond = arm64.C_XPRE
 		p1 := p
-		p = pp.Appendpp(p, arm64.ACMP, obj.TYPE_REG, arm64.REGRT1, 0, obj.TYPE_NONE, 0, 0)
+		p = pp.Append(p, arm64.ACMP, obj.TYPE_REG, arm64.REGRT1, 0, obj.TYPE_NONE, 0, 0)
 		p.Reg = arm64.REGRT2
-		p = pp.Appendpp(p, arm64.ABNE, obj.TYPE_NONE, 0, 0, obj.TYPE_BRANCH, 0, 0)
-		gc.Patch(p, p1)
+		p = pp.Append(p, arm64.ABNE, obj.TYPE_NONE, 0, 0, obj.TYPE_BRANCH, 0, 0)
+		p.To.SetTarget(p1)
 	}
 
 	return p
 }
 
-func ginsnop(pp *gc.Progs) *obj.Prog {
+func ginsnop(pp *objw.Progs) *obj.Prog {
 	p := pp.Prog(arm64.AHINT)
 	p.From.Type = obj.TYPE_CONST
 	return p
diff --git a/src/cmd/compile/internal/arm64/ssa.go b/src/cmd/compile/internal/arm64/ssa.go
index bb634cc38c..9bdea3ee2a 100644
--- a/src/cmd/compile/internal/arm64/ssa.go
+++ b/src/cmd/compile/internal/arm64/ssa.go
@@ -582,7 +582,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p2.From.Type = obj.TYPE_REG
 		p2.From.Reg = arm64.REGTMP
 		p2.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p2, p)
+		p2.To.SetTarget(p)
 	case ssa.OpARM64LoweredAtomicExchange64Variant,
 		ssa.OpARM64LoweredAtomicExchange32Variant:
 		swap := arm64.ASWPALD
@@ -636,7 +636,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p3.From.Type = obj.TYPE_REG
 		p3.From.Reg = arm64.REGTMP
 		p3.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p3, p)
+		p3.To.SetTarget(p)
 	case ssa.OpARM64LoweredAtomicAdd64Variant,
 		ssa.OpARM64LoweredAtomicAdd32Variant:
 		// LDADDAL	Rarg1, (Rarg0), Rout
@@ -700,13 +700,13 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p4.From.Type = obj.TYPE_REG
 		p4.From.Reg = arm64.REGTMP
 		p4.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p4, p)
+		p4.To.SetTarget(p)
 		p5 := s.Prog(arm64.ACSET)
 		p5.From.Type = obj.TYPE_REG // assembler encodes conditional bits in Reg
 		p5.From.Reg = arm64.COND_EQ
 		p5.To.Type = obj.TYPE_REG
 		p5.To.Reg = out
-		gc.Patch(p2, p5)
+		p2.To.SetTarget(p5)
 	case ssa.OpARM64LoweredAtomicCas64Variant,
 		ssa.OpARM64LoweredAtomicCas32Variant:
 		// Rarg0: ptr
@@ -794,7 +794,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p3.From.Type = obj.TYPE_REG
 		p3.From.Reg = arm64.REGTMP
 		p3.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p3, p)
+		p3.To.SetTarget(p)
 	case ssa.OpARM64LoweredAtomicAnd8Variant,
 		ssa.OpARM64LoweredAtomicAnd32Variant:
 		atomic_clear := arm64.ALDCLRALW
@@ -982,7 +982,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p2.Reg = arm64.REG_R16
 		p3 := s.Prog(arm64.ABLE)
 		p3.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p3, p)
+		p3.To.SetTarget(p)
 	case ssa.OpARM64DUFFCOPY:
 		p := s.Prog(obj.ADUFFCOPY)
 		p.To.Type = obj.TYPE_MEM
@@ -1015,7 +1015,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p3.Reg = arm64.REG_R16
 		p4 := s.Prog(arm64.ABLE)
 		p4.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p4, p)
+		p4.To.SetTarget(p)
 	case ssa.OpARM64CALLstatic, ssa.OpARM64CALLclosure, ssa.OpARM64CALLinter:
 		s.Call(v)
 	case ssa.OpARM64LoweredWB:
diff --git a/src/cmd/compile/internal/bitvec/bv.go b/src/cmd/compile/internal/bitvec/bv.go
new file mode 100644
index 0000000000..1e084576d1
--- /dev/null
+++ b/src/cmd/compile/internal/bitvec/bv.go
@@ -0,0 +1,190 @@
+// Copyright 2013 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 bitvec
+
+import (
+	"math/bits"
+
+	"cmd/compile/internal/base"
+)
+
+const (
+	wordBits  = 32
+	wordMask  = wordBits - 1
+	wordShift = 5
+)
+
+// A BitVec is a bit vector.
+type BitVec struct {
+	N int32    // number of bits in vector
+	B []uint32 // words holding bits
+}
+
+func New(n int32) BitVec {
+	nword := (n + wordBits - 1) / wordBits
+	return BitVec{n, make([]uint32, nword)}
+}
+
+type Bulk struct {
+	words []uint32
+	nbit  int32
+	nword int32
+}
+
+func NewBulk(nbit int32, count int32) Bulk {
+	nword := (nbit + wordBits - 1) / wordBits
+	size := int64(nword) * int64(count)
+	if int64(int32(size*4)) != size*4 {
+		base.Fatalf("bvbulkalloc too big: nbit=%d count=%d nword=%d size=%d", nbit, count, nword, size)
+	}
+	return Bulk{
+		words: make([]uint32, size),
+		nbit:  nbit,
+		nword: nword,
+	}
+}
+
+func (b *Bulk) Next() BitVec {
+	out := BitVec{b.nbit, b.words[:b.nword]}
+	b.words = b.words[b.nword:]
+	return out
+}
+
+func (bv1 BitVec) Eq(bv2 BitVec) bool {
+	if bv1.N != bv2.N {
+		base.Fatalf("bvequal: lengths %d and %d are not equal", bv1.N, bv2.N)
+	}
+	for i, x := range bv1.B {
+		if x != bv2.B[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func (dst BitVec) Copy(src BitVec) {
+	copy(dst.B, src.B)
+}
+
+func (bv BitVec) Get(i int32) bool {
+	if i < 0 || i >= bv.N {
+		base.Fatalf("bvget: index %d is out of bounds with length %d\n", i, bv.N)
+	}
+	mask := uint32(1 << uint(i%wordBits))
+	return bv.B[i>>wordShift]&mask != 0
+}
+
+func (bv BitVec) Set(i int32) {
+	if i < 0 || i >= bv.N {
+		base.Fatalf("bvset: index %d is out of bounds with length %d\n", i, bv.N)
+	}
+	mask := uint32(1 << uint(i%wordBits))
+	bv.B[i/wordBits] |= mask
+}
+
+func (bv BitVec) Unset(i int32) {
+	if i < 0 || i >= bv.N {
+		base.Fatalf("bvunset: index %d is out of bounds with length %d\n", i, bv.N)
+	}
+	mask := uint32(1 << uint(i%wordBits))
+	bv.B[i/wordBits] &^= mask
+}
+
+// bvnext returns the smallest index >= i for which bvget(bv, i) == 1.
+// If there is no such index, bvnext returns -1.
+func (bv BitVec) Next(i int32) int32 {
+	if i >= bv.N {
+		return -1
+	}
+
+	// Jump i ahead to next word with bits.
+	if bv.B[i>>wordShift]>>uint(i&wordMask) == 0 {
+		i &^= wordMask
+		i += wordBits
+		for i < bv.N && bv.B[i>>wordShift] == 0 {
+			i += wordBits
+		}
+	}
+
+	if i >= bv.N {
+		return -1
+	}
+
+	// Find 1 bit.
+	w := bv.B[i>>wordShift] >> uint(i&wordMask)
+	i += int32(bits.TrailingZeros32(w))
+
+	return i
+}
+
+func (bv BitVec) IsEmpty() bool {
+	for _, x := range bv.B {
+		if x != 0 {
+			return false
+		}
+	}
+	return true
+}
+
+func (bv BitVec) Not() {
+	for i, x := range bv.B {
+		bv.B[i] = ^x
+	}
+}
+
+// union
+func (dst BitVec) Or(src1, src2 BitVec) {
+	if len(src1.B) == 0 {
+		return
+	}
+	_, _ = dst.B[len(src1.B)-1], src2.B[len(src1.B)-1] // hoist bounds checks out of the loop
+
+	for i, x := range src1.B {
+		dst.B[i] = x | src2.B[i]
+	}
+}
+
+// intersection
+func (dst BitVec) And(src1, src2 BitVec) {
+	if len(src1.B) == 0 {
+		return
+	}
+	_, _ = dst.B[len(src1.B)-1], src2.B[len(src1.B)-1] // hoist bounds checks out of the loop
+
+	for i, x := range src1.B {
+		dst.B[i] = x & src2.B[i]
+	}
+}
+
+// difference
+func (dst BitVec) AndNot(src1, src2 BitVec) {
+	if len(src1.B) == 0 {
+		return
+	}
+	_, _ = dst.B[len(src1.B)-1], src2.B[len(src1.B)-1] // hoist bounds checks out of the loop
+
+	for i, x := range src1.B {
+		dst.B[i] = x &^ src2.B[i]
+	}
+}
+
+func (bv BitVec) String() string {
+	s := make([]byte, 2+bv.N)
+	copy(s, "#*")
+	for i := int32(0); i < bv.N; i++ {
+		ch := byte('0')
+		if bv.Get(i) {
+			ch = '1'
+		}
+		s[2+i] = ch
+	}
+	return string(s)
+}
+
+func (bv BitVec) Clear() {
+	for i := range bv.B {
+		bv.B[i] = 0
+	}
+}
diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index b0d46eab2f..4fc8cf04ef 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/objw"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -110,9 +111,9 @@ func genhash(t *types.Type) *obj.LSym {
 			memhashvarlen = typecheck.LookupRuntimeFunc("memhash_varlen")
 		}
 		ot := 0
-		ot = dsymptr(closure, ot, memhashvarlen, 0)
-		ot = duintptr(closure, ot, uint64(t.Width)) // size encoded in closure
-		ggloblsym(closure, int32(ot), obj.DUPOK|obj.RODATA)
+		ot = objw.SymPtr(closure, ot, memhashvarlen, 0)
+		ot = objw.Uintptr(closure, ot, uint64(t.Width)) // size encoded in closure
+		objw.Global(closure, int32(ot), obj.DUPOK|obj.RODATA)
 		return closure
 	case types.ASPECIAL:
 		break
@@ -253,8 +254,8 @@ func genhash(t *types.Type) *obj.LSym {
 
 	// Build closure. It doesn't close over any variables, so
 	// it contains just the function pointer.
-	dsymptr(closure, 0, sym.Linksym(), 0)
-	ggloblsym(closure, int32(types.PtrSize), obj.DUPOK|obj.RODATA)
+	objw.SymPtr(closure, 0, sym.Linksym(), 0)
+	objw.Global(closure, int32(types.PtrSize), obj.DUPOK|obj.RODATA)
 
 	return closure
 }
@@ -302,8 +303,8 @@ func sysClosure(name string) *obj.LSym {
 	s := typecheck.LookupRuntimeVar(name + "·f")
 	if len(s.P) == 0 {
 		f := typecheck.LookupRuntimeFunc(name)
-		dsymptr(s, 0, f, 0)
-		ggloblsym(s, int32(types.PtrSize), obj.DUPOK|obj.RODATA)
+		objw.SymPtr(s, 0, f, 0)
+		objw.Global(s, int32(types.PtrSize), obj.DUPOK|obj.RODATA)
 	}
 	return s
 }
@@ -353,9 +354,9 @@ func geneq(t *types.Type) *obj.LSym {
 			memequalvarlen = typecheck.LookupRuntimeVar("memequal_varlen") // asm func
 		}
 		ot := 0
-		ot = dsymptr(closure, ot, memequalvarlen, 0)
-		ot = duintptr(closure, ot, uint64(t.Width))
-		ggloblsym(closure, int32(ot), obj.DUPOK|obj.RODATA)
+		ot = objw.SymPtr(closure, ot, memequalvarlen, 0)
+		ot = objw.Uintptr(closure, ot, uint64(t.Width))
+		objw.Global(closure, int32(ot), obj.DUPOK|obj.RODATA)
 		return closure
 	case types.ASPECIAL:
 		break
@@ -632,8 +633,8 @@ func geneq(t *types.Type) *obj.LSym {
 	typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
 
 	// Generate a closure which points at the function we just generated.
-	dsymptr(closure, 0, sym.Linksym(), 0)
-	ggloblsym(closure, int32(types.PtrSize), obj.DUPOK|obj.RODATA)
+	objw.SymPtr(closure, 0, sym.Linksym(), 0)
+	objw.Global(closure, int32(types.PtrSize), obj.DUPOK|obj.RODATA)
 	return closure
 }
 
diff --git a/src/cmd/compile/internal/gc/bv.go b/src/cmd/compile/internal/gc/bv.go
deleted file mode 100644
index d82851e7cb..0000000000
--- a/src/cmd/compile/internal/gc/bv.go
+++ /dev/null
@@ -1,280 +0,0 @@
-// Copyright 2013 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 gc
-
-import (
-	"math/bits"
-
-	"cmd/compile/internal/base"
-)
-
-const (
-	wordBits  = 32
-	wordMask  = wordBits - 1
-	wordShift = 5
-)
-
-// A bvec is a bit vector.
-type bvec struct {
-	n int32    // number of bits in vector
-	b []uint32 // words holding bits
-}
-
-func bvalloc(n int32) bvec {
-	nword := (n + wordBits - 1) / wordBits
-	return bvec{n, make([]uint32, nword)}
-}
-
-type bulkBvec struct {
-	words []uint32
-	nbit  int32
-	nword int32
-}
-
-func bvbulkalloc(nbit int32, count int32) bulkBvec {
-	nword := (nbit + wordBits - 1) / wordBits
-	size := int64(nword) * int64(count)
-	if int64(int32(size*4)) != size*4 {
-		base.Fatalf("bvbulkalloc too big: nbit=%d count=%d nword=%d size=%d", nbit, count, nword, size)
-	}
-	return bulkBvec{
-		words: make([]uint32, size),
-		nbit:  nbit,
-		nword: nword,
-	}
-}
-
-func (b *bulkBvec) next() bvec {
-	out := bvec{b.nbit, b.words[:b.nword]}
-	b.words = b.words[b.nword:]
-	return out
-}
-
-func (bv1 bvec) Eq(bv2 bvec) bool {
-	if bv1.n != bv2.n {
-		base.Fatalf("bvequal: lengths %d and %d are not equal", bv1.n, bv2.n)
-	}
-	for i, x := range bv1.b {
-		if x != bv2.b[i] {
-			return false
-		}
-	}
-	return true
-}
-
-func (dst bvec) Copy(src bvec) {
-	copy(dst.b, src.b)
-}
-
-func (bv bvec) Get(i int32) bool {
-	if i < 0 || i >= bv.n {
-		base.Fatalf("bvget: index %d is out of bounds with length %d\n", i, bv.n)
-	}
-	mask := uint32(1 << uint(i%wordBits))
-	return bv.b[i>>wordShift]&mask != 0
-}
-
-func (bv bvec) Set(i int32) {
-	if i < 0 || i >= bv.n {
-		base.Fatalf("bvset: index %d is out of bounds with length %d\n", i, bv.n)
-	}
-	mask := uint32(1 << uint(i%wordBits))
-	bv.b[i/wordBits] |= mask
-}
-
-func (bv bvec) Unset(i int32) {
-	if i < 0 || i >= bv.n {
-		base.Fatalf("bvunset: index %d is out of bounds with length %d\n", i, bv.n)
-	}
-	mask := uint32(1 << uint(i%wordBits))
-	bv.b[i/wordBits] &^= mask
-}
-
-// bvnext returns the smallest index >= i for which bvget(bv, i) == 1.
-// If there is no such index, bvnext returns -1.
-func (bv bvec) Next(i int32) int32 {
-	if i >= bv.n {
-		return -1
-	}
-
-	// Jump i ahead to next word with bits.
-	if bv.b[i>>wordShift]>>uint(i&wordMask) == 0 {
-		i &^= wordMask
-		i += wordBits
-		for i < bv.n && bv.b[i>>wordShift] == 0 {
-			i += wordBits
-		}
-	}
-
-	if i >= bv.n {
-		return -1
-	}
-
-	// Find 1 bit.
-	w := bv.b[i>>wordShift] >> uint(i&wordMask)
-	i += int32(bits.TrailingZeros32(w))
-
-	return i
-}
-
-func (bv bvec) IsEmpty() bool {
-	for _, x := range bv.b {
-		if x != 0 {
-			return false
-		}
-	}
-	return true
-}
-
-func (bv bvec) Not() {
-	for i, x := range bv.b {
-		bv.b[i] = ^x
-	}
-}
-
-// union
-func (dst bvec) Or(src1, src2 bvec) {
-	if len(src1.b) == 0 {
-		return
-	}
-	_, _ = dst.b[len(src1.b)-1], src2.b[len(src1.b)-1] // hoist bounds checks out of the loop
-
-	for i, x := range src1.b {
-		dst.b[i] = x | src2.b[i]
-	}
-}
-
-// intersection
-func (dst bvec) And(src1, src2 bvec) {
-	if len(src1.b) == 0 {
-		return
-	}
-	_, _ = dst.b[len(src1.b)-1], src2.b[len(src1.b)-1] // hoist bounds checks out of the loop
-
-	for i, x := range src1.b {
-		dst.b[i] = x & src2.b[i]
-	}
-}
-
-// difference
-func (dst bvec) AndNot(src1, src2 bvec) {
-	if len(src1.b) == 0 {
-		return
-	}
-	_, _ = dst.b[len(src1.b)-1], src2.b[len(src1.b)-1] // hoist bounds checks out of the loop
-
-	for i, x := range src1.b {
-		dst.b[i] = x &^ src2.b[i]
-	}
-}
-
-func (bv bvec) String() string {
-	s := make([]byte, 2+bv.n)
-	copy(s, "#*")
-	for i := int32(0); i < bv.n; i++ {
-		ch := byte('0')
-		if bv.Get(i) {
-			ch = '1'
-		}
-		s[2+i] = ch
-	}
-	return string(s)
-}
-
-func (bv bvec) Clear() {
-	for i := range bv.b {
-		bv.b[i] = 0
-	}
-}
-
-// FNV-1 hash function constants.
-const (
-	H0 = 2166136261
-	Hp = 16777619
-)
-
-func hashbitmap(h uint32, bv bvec) uint32 {
-	n := int((bv.n + 31) / 32)
-	for i := 0; i < n; i++ {
-		w := bv.b[i]
-		h = (h * Hp) ^ (w & 0xff)
-		h = (h * Hp) ^ ((w >> 8) & 0xff)
-		h = (h * Hp) ^ ((w >> 16) & 0xff)
-		h = (h * Hp) ^ ((w >> 24) & 0xff)
-	}
-
-	return h
-}
-
-// bvecSet is a set of bvecs, in initial insertion order.
-type bvecSet struct {
-	index []int  // hash -> uniq index. -1 indicates empty slot.
-	uniq  []bvec // unique bvecs, in insertion order
-}
-
-func (m *bvecSet) grow() {
-	// Allocate new index.
-	n := len(m.index) * 2
-	if n == 0 {
-		n = 32
-	}
-	newIndex := make([]int, n)
-	for i := range newIndex {
-		newIndex[i] = -1
-	}
-
-	// Rehash into newIndex.
-	for i, bv := range m.uniq {
-		h := hashbitmap(H0, bv) % uint32(len(newIndex))
-		for {
-			j := newIndex[h]
-			if j < 0 {
-				newIndex[h] = i
-				break
-			}
-			h++
-			if h == uint32(len(newIndex)) {
-				h = 0
-			}
-		}
-	}
-	m.index = newIndex
-}
-
-// add adds bv to the set and returns its index in m.extractUniqe.
-// The caller must not modify bv after this.
-func (m *bvecSet) add(bv bvec) int {
-	if len(m.uniq)*4 >= len(m.index) {
-		m.grow()
-	}
-
-	index := m.index
-	h := hashbitmap(H0, bv) % uint32(len(index))
-	for {
-		j := index[h]
-		if j < 0 {
-			// New bvec.
-			index[h] = len(m.uniq)
-			m.uniq = append(m.uniq, bv)
-			return len(m.uniq) - 1
-		}
-		jlive := m.uniq[j]
-		if bv.Eq(jlive) {
-			// Existing bvec.
-			return j
-		}
-
-		h++
-		if h == uint32(len(index)) {
-			h = 0
-		}
-	}
-}
-
-// extractUniqe returns this slice of unique bit vectors in m, as
-// indexed by the result of bvecSet.add.
-func (m *bvecSet) extractUniqe() []bvec {
-	return m.uniq
-}
diff --git a/src/cmd/compile/internal/gc/bvset.go b/src/cmd/compile/internal/gc/bvset.go
new file mode 100644
index 0000000000..7f5f41fb5c
--- /dev/null
+++ b/src/cmd/compile/internal/gc/bvset.go
@@ -0,0 +1,97 @@
+// Copyright 2013 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 gc
+
+import "cmd/compile/internal/bitvec"
+
+// FNV-1 hash function constants.
+const (
+	h0 = 2166136261
+	hp = 16777619
+)
+
+// bvecSet is a set of bvecs, in initial insertion order.
+type bvecSet struct {
+	index []int           // hash -> uniq index. -1 indicates empty slot.
+	uniq  []bitvec.BitVec // unique bvecs, in insertion order
+}
+
+func (m *bvecSet) grow() {
+	// Allocate new index.
+	n := len(m.index) * 2
+	if n == 0 {
+		n = 32
+	}
+	newIndex := make([]int, n)
+	for i := range newIndex {
+		newIndex[i] = -1
+	}
+
+	// Rehash into newIndex.
+	for i, bv := range m.uniq {
+		h := hashbitmap(h0, bv) % uint32(len(newIndex))
+		for {
+			j := newIndex[h]
+			if j < 0 {
+				newIndex[h] = i
+				break
+			}
+			h++
+			if h == uint32(len(newIndex)) {
+				h = 0
+			}
+		}
+	}
+	m.index = newIndex
+}
+
+// add adds bv to the set and returns its index in m.extractUniqe.
+// The caller must not modify bv after this.
+func (m *bvecSet) add(bv bitvec.BitVec) int {
+	if len(m.uniq)*4 >= len(m.index) {
+		m.grow()
+	}
+
+	index := m.index
+	h := hashbitmap(h0, bv) % uint32(len(index))
+	for {
+		j := index[h]
+		if j < 0 {
+			// New bvec.
+			index[h] = len(m.uniq)
+			m.uniq = append(m.uniq, bv)
+			return len(m.uniq) - 1
+		}
+		jlive := m.uniq[j]
+		if bv.Eq(jlive) {
+			// Existing bvec.
+			return j
+		}
+
+		h++
+		if h == uint32(len(index)) {
+			h = 0
+		}
+	}
+}
+
+// extractUnique returns this slice of unique bit vectors in m, as
+// indexed by the result of bvecSet.add.
+func (m *bvecSet) extractUnique() []bitvec.BitVec {
+	return m.uniq
+}
+
+func hashbitmap(h uint32, bv bitvec.BitVec) uint32 {
+	n := int((bv.N + 31) / 32)
+	for i := 0; i < n; i++ {
+		w := bv.B[i]
+		h = (h * hp) ^ (w & 0xff)
+		h = (h * hp) ^ ((w >> 8) & 0xff)
+		h = (h * hp) ^ ((w >> 16) & 0xff)
+		h = (h * hp) ^ ((w >> 24) & 0xff)
+	}
+
+	return h
+}
diff --git a/src/cmd/compile/internal/gc/embed.go b/src/cmd/compile/internal/gc/embed.go
index bcfec3cad3..282e718b29 100644
--- a/src/cmd/compile/internal/gc/embed.go
+++ b/src/cmd/compile/internal/gc/embed.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/objw"
 	"cmd/compile/internal/syntax"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
@@ -206,19 +207,19 @@ func initEmbed(v *ir.Name) {
 		}
 		sym := v.Sym().Linksym()
 		off := 0
-		off = dsymptr(sym, off, fsym, 0)       // data string
-		off = duintptr(sym, off, uint64(size)) // len
+		off = objw.SymPtr(sym, off, fsym, 0)       // data string
+		off = objw.Uintptr(sym, off, uint64(size)) // len
 		if kind == embedBytes {
-			duintptr(sym, off, uint64(size)) // cap for slice
+			objw.Uintptr(sym, off, uint64(size)) // cap for slice
 		}
 
 	case embedFiles:
 		slicedata := base.Ctxt.Lookup(`"".` + v.Sym().Name + `.files`)
 		off := 0
 		// []files pointed at by Files
-		off = dsymptr(slicedata, off, slicedata, 3*types.PtrSize) // []file, pointing just past slice
-		off = duintptr(slicedata, off, uint64(len(files)))
-		off = duintptr(slicedata, off, uint64(len(files)))
+		off = objw.SymPtr(slicedata, off, slicedata, 3*types.PtrSize) // []file, pointing just past slice
+		off = objw.Uintptr(slicedata, off, uint64(len(files)))
+		off = objw.Uintptr(slicedata, off, uint64(len(files)))
 
 		// embed/embed.go type file is:
 		//	name string
@@ -228,25 +229,25 @@ func initEmbed(v *ir.Name) {
 		const hashSize = 16
 		hash := make([]byte, hashSize)
 		for _, file := range files {
-			off = dsymptr(slicedata, off, stringsym(v.Pos(), file), 0) // file string
-			off = duintptr(slicedata, off, uint64(len(file)))
+			off = objw.SymPtr(slicedata, off, stringsym(v.Pos(), file), 0) // file string
+			off = objw.Uintptr(slicedata, off, uint64(len(file)))
 			if strings.HasSuffix(file, "/") {
 				// entry for directory - no data
-				off = duintptr(slicedata, off, 0)
-				off = duintptr(slicedata, off, 0)
+				off = objw.Uintptr(slicedata, off, 0)
+				off = objw.Uintptr(slicedata, off, 0)
 				off += hashSize
 			} else {
 				fsym, size, err := fileStringSym(v.Pos(), base.Flag.Cfg.Embed.Files[file], true, hash)
 				if err != nil {
 					base.ErrorfAt(v.Pos(), "embed %s: %v", file, err)
 				}
-				off = dsymptr(slicedata, off, fsym, 0) // data string
-				off = duintptr(slicedata, off, uint64(size))
+				off = objw.SymPtr(slicedata, off, fsym, 0) // data string
+				off = objw.Uintptr(slicedata, off, uint64(size))
 				off = int(slicedata.WriteBytes(base.Ctxt, int64(off), hash))
 			}
 		}
-		ggloblsym(slicedata, int32(off), obj.RODATA|obj.LOCAL)
+		objw.Global(slicedata, int32(off), obj.RODATA|obj.LOCAL)
 		sym := v.Sym().Linksym()
-		dsymptr(sym, 0, slicedata, 0)
+		objw.SymPtr(sym, 0, slicedata, 0)
 	}
 }
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index 7648e910d5..c979edcdf8 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -5,6 +5,7 @@
 package gc
 
 import (
+	"cmd/compile/internal/objw"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -33,10 +34,10 @@ type Arch struct {
 
 	// ZeroRange zeroes a range of memory on stack. It is only inserted
 	// at function entry, and it is ok to clobber registers.
-	ZeroRange func(*Progs, *obj.Prog, int64, int64, *uint32) *obj.Prog
+	ZeroRange func(*objw.Progs, *obj.Prog, int64, int64, *uint32) *obj.Prog
 
-	Ginsnop      func(*Progs) *obj.Prog
-	Ginsnopdefer func(*Progs) *obj.Prog // special ginsnop for deferreturn
+	Ginsnop      func(*objw.Progs) *obj.Prog
+	Ginsnopdefer func(*objw.Progs) *obj.Prog // special ginsnop for deferreturn
 
 	// SSAMarkMoves marks any MOVXconst ops that need to avoid clobbering flags.
 	SSAMarkMoves func(*SSAGenState, *ssa.Block)
diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go
index f24687ec0f..f746a358ca 100644
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ b/src/cmd/compile/internal/gc/gsubr.go
@@ -33,164 +33,14 @@ package gc
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
-	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
-	"cmd/internal/src"
 	"fmt"
 	"os"
 )
 
-var sharedProgArray = new([10000]obj.Prog) // *T instead of T to work around issue 19839
-
-// Progs accumulates Progs for a function and converts them into machine code.
-type Progs struct {
-	Text      *obj.Prog  // ATEXT Prog for this function
-	next      *obj.Prog  // next Prog
-	pc        int64      // virtual PC; count of Progs
-	pos       src.XPos   // position to use for new Progs
-	curfn     *ir.Func   // fn these Progs are for
-	progcache []obj.Prog // local progcache
-	cacheidx  int        // first free element of progcache
-
-	nextLive LivenessIndex // liveness index for the next Prog
-	prevLive LivenessIndex // last emitted liveness index
-}
-
-// newProgs returns a new Progs for fn.
-// worker indicates which of the backend workers will use the Progs.
-func newProgs(fn *ir.Func, worker int) *Progs {
-	pp := new(Progs)
-	if base.Ctxt.CanReuseProgs() {
-		sz := len(sharedProgArray) / base.Flag.LowerC
-		pp.progcache = sharedProgArray[sz*worker : sz*(worker+1)]
-	}
-	pp.curfn = fn
-
-	// prime the pump
-	pp.next = pp.NewProg()
-	pp.clearp(pp.next)
-
-	pp.pos = fn.Pos()
-	pp.settext(fn)
-	// PCDATA tables implicitly start with index -1.
-	pp.prevLive = LivenessIndex{-1, false}
-	pp.nextLive = pp.prevLive
-	return pp
-}
-
-func (pp *Progs) NewProg() *obj.Prog {
-	var p *obj.Prog
-	if pp.cacheidx < len(pp.progcache) {
-		p = &pp.progcache[pp.cacheidx]
-		pp.cacheidx++
-	} else {
-		p = new(obj.Prog)
-	}
-	p.Ctxt = base.Ctxt
-	return p
-}
-
-// Flush converts from pp to machine code.
-func (pp *Progs) Flush() {
-	plist := &obj.Plist{Firstpc: pp.Text, Curfn: pp.curfn}
-	obj.Flushplist(base.Ctxt, plist, pp.NewProg, base.Ctxt.Pkgpath)
-}
-
-// Free clears pp and any associated resources.
-func (pp *Progs) Free() {
-	if base.Ctxt.CanReuseProgs() {
-		// Clear progs to enable GC and avoid abuse.
-		s := pp.progcache[:pp.cacheidx]
-		for i := range s {
-			s[i] = obj.Prog{}
-		}
-	}
-	// Clear pp to avoid abuse.
-	*pp = Progs{}
-}
-
-// Prog adds a Prog with instruction As to pp.
-func (pp *Progs) Prog(as obj.As) *obj.Prog {
-	if pp.nextLive.StackMapValid() && pp.nextLive.stackMapIndex != pp.prevLive.stackMapIndex {
-		// Emit stack map index change.
-		idx := pp.nextLive.stackMapIndex
-		pp.prevLive.stackMapIndex = idx
-		p := pp.Prog(obj.APCDATA)
-		Addrconst(&p.From, objabi.PCDATA_StackMapIndex)
-		Addrconst(&p.To, int64(idx))
-	}
-	if pp.nextLive.isUnsafePoint != pp.prevLive.isUnsafePoint {
-		// Emit unsafe-point marker.
-		pp.prevLive.isUnsafePoint = pp.nextLive.isUnsafePoint
-		p := pp.Prog(obj.APCDATA)
-		Addrconst(&p.From, objabi.PCDATA_UnsafePoint)
-		if pp.nextLive.isUnsafePoint {
-			Addrconst(&p.To, objabi.PCDATA_UnsafePointUnsafe)
-		} else {
-			Addrconst(&p.To, objabi.PCDATA_UnsafePointSafe)
-		}
-	}
-
-	p := pp.next
-	pp.next = pp.NewProg()
-	pp.clearp(pp.next)
-	p.Link = pp.next
-
-	if !pp.pos.IsKnown() && base.Flag.K != 0 {
-		base.Warn("prog: unknown position (line 0)")
-	}
-
-	p.As = as
-	p.Pos = pp.pos
-	if pp.pos.IsStmt() == src.PosIsStmt {
-		// Clear IsStmt for later Progs at this pos provided that as can be marked as a stmt
-		if ssa.LosesStmtMark(as) {
-			return p
-		}
-		pp.pos = pp.pos.WithNotStmt()
-	}
-	return p
-}
-
-func (pp *Progs) clearp(p *obj.Prog) {
-	obj.Nopout(p)
-	p.As = obj.AEND
-	p.Pc = pp.pc
-	pp.pc++
-}
-
-func (pp *Progs) Appendpp(p *obj.Prog, as obj.As, ftype obj.AddrType, freg int16, foffset int64, ttype obj.AddrType, treg int16, toffset int64) *obj.Prog {
-	q := pp.NewProg()
-	pp.clearp(q)
-	q.As = as
-	q.Pos = p.Pos
-	q.From.Type = ftype
-	q.From.Reg = freg
-	q.From.Offset = foffset
-	q.To.Type = ttype
-	q.To.Reg = treg
-	q.To.Offset = toffset
-	q.Link = p.Link
-	p.Link = q
-	return q
-}
-
-func (pp *Progs) settext(fn *ir.Func) {
-	if pp.Text != nil {
-		base.Fatalf("Progs.settext called twice")
-	}
-	ptxt := pp.Prog(obj.ATEXT)
-	pp.Text = ptxt
-
-	fn.LSym.Func().Text = ptxt
-	ptxt.From.Type = obj.TYPE_MEM
-	ptxt.From.Name = obj.NAME_EXTERN
-	ptxt.From.Sym = fn.LSym
-}
-
 // makeABIWrapper creates a new function that wraps a cross-ABI call
 // to "f".  The wrapper is marked as an ABIWRAPPER.
 func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
@@ -426,41 +276,3 @@ func setupTextLSym(f *ir.Func, flag int) {
 
 	base.Ctxt.InitTextSym(f.LSym, flag)
 }
-
-func ggloblnod(nam ir.Node) {
-	s := nam.Sym().Linksym()
-	s.Gotype = ngotype(nam).Linksym()
-	flags := 0
-	if nam.Name().Readonly() {
-		flags = obj.RODATA
-	}
-	if nam.Type() != nil && !nam.Type().HasPointers() {
-		flags |= obj.NOPTR
-	}
-	base.Ctxt.Globl(s, nam.Type().Width, flags)
-	if nam.Name().LibfuzzerExtraCounter() {
-		s.Type = objabi.SLIBFUZZER_EXTRA_COUNTER
-	}
-	if nam.Sym().Linkname != "" {
-		// Make sure linkname'd symbol is non-package. When a symbol is
-		// both imported and linkname'd, s.Pkg may not set to "_" in
-		// types.Sym.Linksym because LSym already exists. Set it here.
-		s.Pkg = "_"
-	}
-}
-
-func ggloblsym(s *obj.LSym, width int32, flags int16) {
-	if flags&obj.LOCAL != 0 {
-		s.Set(obj.AttrLocal, true)
-		flags &^= obj.LOCAL
-	}
-	base.Ctxt.Globl(s, int64(width), int(flags))
-}
-
-func Addrconst(a *obj.Addr, v int64) {
-	a.SetConst(v)
-}
-
-func Patch(p *obj.Prog, to *obj.Prog) {
-	p.To.SetTarget(to)
-}
diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index ed61c11522..da3f40f4e8 100644
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/objw"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -100,17 +101,17 @@ func fninit() *ir.Name {
 	sym.Def = task
 	lsym := sym.Linksym()
 	ot := 0
-	ot = duintptr(lsym, ot, 0) // state: not initialized yet
-	ot = duintptr(lsym, ot, uint64(len(deps)))
-	ot = duintptr(lsym, ot, uint64(len(fns)))
+	ot = objw.Uintptr(lsym, ot, 0) // state: not initialized yet
+	ot = objw.Uintptr(lsym, ot, uint64(len(deps)))
+	ot = objw.Uintptr(lsym, ot, uint64(len(fns)))
 	for _, d := range deps {
-		ot = dsymptr(lsym, ot, d, 0)
+		ot = objw.SymPtr(lsym, ot, d, 0)
 	}
 	for _, f := range fns {
-		ot = dsymptr(lsym, ot, f, 0)
+		ot = objw.SymPtr(lsym, ot, f, 0)
 	}
 	// An initTask has pointers, but none into the Go heap.
 	// It's not quite read only, the state field must be modifiable.
-	ggloblsym(lsym, int32(ot), obj.NOPTR)
+	objw.Global(lsym, int32(ot), obj.NOPTR)
 	return task
 }
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 1b4ba50e6b..1d0a0f7a04 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/objw"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/bio"
@@ -160,7 +161,7 @@ func dumpdata() {
 
 	if zerosize > 0 {
 		zero := ir.Pkgs.Map.Lookup("zero")
-		ggloblsym(zero.Linksym(), int32(zerosize), obj.DUPOK|obj.RODATA)
+		objw.Global(zero.Linksym(), int32(zerosize), obj.DUPOK|obj.RODATA)
 	}
 
 	addGCLocals()
@@ -281,8 +282,8 @@ func dumpfuncsyms() {
 	})
 	for _, s := range funcsyms {
 		sf := s.Pkg.Lookup(ir.FuncSymName(s)).Linksym()
-		dsymptr(sf, 0, s.Linksym(), 0)
-		ggloblsym(sf, int32(types.PtrSize), obj.DUPOK|obj.RODATA)
+		objw.SymPtr(sf, 0, s.Linksym(), 0)
+		objw.Global(sf, int32(types.PtrSize), obj.DUPOK|obj.RODATA)
 	}
 }
 
@@ -298,53 +299,20 @@ func addGCLocals() {
 		}
 		for _, gcsym := range []*obj.LSym{fn.GCArgs, fn.GCLocals} {
 			if gcsym != nil && !gcsym.OnList() {
-				ggloblsym(gcsym, int32(len(gcsym.P)), obj.RODATA|obj.DUPOK)
+				objw.Global(gcsym, int32(len(gcsym.P)), obj.RODATA|obj.DUPOK)
 			}
 		}
 		if x := fn.StackObjects; x != nil {
 			attr := int16(obj.RODATA)
-			ggloblsym(x, int32(len(x.P)), attr)
+			objw.Global(x, int32(len(x.P)), attr)
 			x.Set(obj.AttrStatic, true)
 		}
 		if x := fn.OpenCodedDeferInfo; x != nil {
-			ggloblsym(x, int32(len(x.P)), obj.RODATA|obj.DUPOK)
+			objw.Global(x, int32(len(x.P)), obj.RODATA|obj.DUPOK)
 		}
 	}
 }
 
-func duintxx(s *obj.LSym, off int, v uint64, wid int) int {
-	if off&(wid-1) != 0 {
-		base.Fatalf("duintxxLSym: misaligned: v=%d wid=%d off=%d", v, wid, off)
-	}
-	s.WriteInt(base.Ctxt, int64(off), wid, int64(v))
-	return off + wid
-}
-
-func duint8(s *obj.LSym, off int, v uint8) int {
-	return duintxx(s, off, uint64(v), 1)
-}
-
-func duint16(s *obj.LSym, off int, v uint16) int {
-	return duintxx(s, off, uint64(v), 2)
-}
-
-func duint32(s *obj.LSym, off int, v uint32) int {
-	return duintxx(s, off, uint64(v), 4)
-}
-
-func duintptr(s *obj.LSym, off int, v uint64) int {
-	return duintxx(s, off, v, types.PtrSize)
-}
-
-func dbvec(s *obj.LSym, off int, bv bvec) int {
-	// Runtime reads the bitmaps as byte arrays. Oblige.
-	for j := 0; int32(j) < bv.n; j += 8 {
-		word := bv.b[j/32]
-		off = duint8(s, off, uint8(word>>(uint(j)%32)))
-	}
-	return off
-}
-
 const (
 	stringSymPrefix  = "go.string."
 	stringSymPattern = ".gostring.%d.%x"
@@ -370,7 +338,7 @@ func stringsym(pos src.XPos, s string) (data *obj.LSym) {
 	symdata := base.Ctxt.Lookup(stringSymPrefix + symname)
 	if !symdata.OnList() {
 		off := dstringdata(symdata, 0, s, pos, "string")
-		ggloblsym(symdata, int32(off), obj.DUPOK|obj.RODATA|obj.LOCAL)
+		objw.Global(symdata, int32(off), obj.DUPOK|obj.RODATA|obj.LOCAL)
 		symdata.Set(obj.AttrContentAddressable, true)
 	}
 
@@ -450,7 +418,7 @@ func fileStringSym(pos src.XPos, file string, readonly bool, hash []byte) (*obj.
 			info := symdata.NewFileInfo()
 			info.Name = file
 			info.Size = size
-			ggloblsym(symdata, int32(size), obj.DUPOK|obj.RODATA|obj.LOCAL)
+			objw.Global(symdata, int32(size), obj.DUPOK|obj.RODATA|obj.LOCAL)
 			// Note: AttrContentAddressable cannot be set here,
 			// because the content-addressable-handling code
 			// does not know about file symbols.
@@ -480,7 +448,7 @@ func slicedata(pos src.XPos, s string) *ir.Name {
 
 	lsym := sym.Linksym()
 	off := dstringdata(lsym, 0, s, pos, "slice")
-	ggloblsym(lsym, int32(off), obj.NOPTR|obj.LOCAL)
+	objw.Global(lsym, int32(off), obj.NOPTR|obj.LOCAL)
 
 	return symnode
 }
@@ -505,25 +473,6 @@ func dstringdata(s *obj.LSym, off int, t string, pos src.XPos, what string) int
 	return off + len(t)
 }
 
-func dsymptr(s *obj.LSym, off int, x *obj.LSym, xoff int) int {
-	off = int(types.Rnd(int64(off), int64(types.PtrSize)))
-	s.WriteAddr(base.Ctxt, int64(off), types.PtrSize, x, int64(xoff))
-	off += types.PtrSize
-	return off
-}
-
-func dsymptrOff(s *obj.LSym, off int, x *obj.LSym) int {
-	s.WriteOff(base.Ctxt, int64(off), x, 0)
-	off += 4
-	return off
-}
-
-func dsymptrWeakOff(s *obj.LSym, off int, x *obj.LSym) int {
-	s.WriteWeakOff(base.Ctxt, int64(off), x, 0)
-	off += 4
-	return off
-}
-
 // slicesym writes a static slice symbol {&arr, lencap, lencap} to n+noff.
 // slicesym does not modify n.
 func slicesym(n *ir.Name, noff int64, arr *ir.Name, lencap int64) {
@@ -623,3 +572,25 @@ func litsym(n *ir.Name, noff int64, c ir.Node, wid int) {
 		base.Fatalf("litsym unhandled OLITERAL %v", c)
 	}
 }
+
+func ggloblnod(nam ir.Node) {
+	s := nam.Sym().Linksym()
+	s.Gotype = ngotype(nam).Linksym()
+	flags := 0
+	if nam.Name().Readonly() {
+		flags = obj.RODATA
+	}
+	if nam.Type() != nil && !nam.Type().HasPointers() {
+		flags |= obj.NOPTR
+	}
+	base.Ctxt.Globl(s, nam.Type().Width, flags)
+	if nam.Name().LibfuzzerExtraCounter() {
+		s.Type = objabi.SLIBFUZZER_EXTRA_COUNTER
+	}
+	if nam.Sym().Linkname != "" {
+		// Make sure linkname'd symbol is non-package. When a symbol is
+		// both imported and linkname'd, s.Pkg may not set to "_" in
+		// types.Sym.Linksym because LSym already exists. Set it here.
+		s.Pkg = "_"
+	}
+}
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index c0f3326454..40a2195a12 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -6,7 +6,9 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/bitvec"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/objw"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
@@ -34,13 +36,13 @@ func emitptrargsmap(fn *ir.Func) {
 	}
 	lsym := base.Ctxt.Lookup(fn.LSym.Name + ".args_stackmap")
 	nptr := int(fn.Type().ArgWidth() / int64(types.PtrSize))
-	bv := bvalloc(int32(nptr) * 2)
+	bv := bitvec.New(int32(nptr) * 2)
 	nbitmap := 1
 	if fn.Type().NumResults() > 0 {
 		nbitmap = 2
 	}
-	off := duint32(lsym, 0, uint32(nbitmap))
-	off = duint32(lsym, off, uint32(bv.n))
+	off := objw.Uint32(lsym, 0, uint32(nbitmap))
+	off = objw.Uint32(lsym, off, uint32(bv.N))
 
 	if ir.IsMethod(fn) {
 		onebitwalktype1(fn.Type().Recvs(), 0, bv)
@@ -48,14 +50,14 @@ func emitptrargsmap(fn *ir.Func) {
 	if fn.Type().NumParams() > 0 {
 		onebitwalktype1(fn.Type().Params(), 0, bv)
 	}
-	off = dbvec(lsym, off, bv)
+	off = objw.BitVec(lsym, off, bv)
 
 	if fn.Type().NumResults() > 0 {
 		onebitwalktype1(fn.Type().Results(), 0, bv)
-		off = dbvec(lsym, off, bv)
+		off = objw.BitVec(lsym, off, bv)
 	}
 
-	ggloblsym(lsym, int32(off), obj.RODATA|obj.LOCAL)
+	objw.Global(lsym, int32(off), obj.RODATA|obj.LOCAL)
 }
 
 // cmpstackvarlt reports whether the stack variable a sorts before b.
@@ -314,7 +316,7 @@ func compileSSA(fn *ir.Func, worker int) {
 		largeStackFramesMu.Unlock()
 		return
 	}
-	pp := newProgs(fn, worker)
+	pp := objw.NewProgs(fn, worker)
 	defer pp.Free()
 	genssa(f, pp)
 	// Check frame size again.
diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/gc/plive.go
index ac3b4bcd31..260edda9ce 100644
--- a/src/cmd/compile/internal/gc/plive.go
+++ b/src/cmd/compile/internal/gc/plive.go
@@ -16,7 +16,9 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/bitvec"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/objw"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -88,15 +90,15 @@ type BlockEffects struct {
 	//
 	//	uevar: upward exposed variables (used before set in block)
 	//	varkill: killed variables (set in block)
-	uevar   bvec
-	varkill bvec
+	uevar   bitvec.BitVec
+	varkill bitvec.BitVec
 
 	// Computed during Liveness.solve using control flow information:
 	//
 	//	livein: variables live at block entry
 	//	liveout: variables live at block exit
-	livein  bvec
-	liveout bvec
+	livein  bitvec.BitVec
+	liveout bitvec.BitVec
 }
 
 // A collection of global state used by liveness analysis.
@@ -114,84 +116,54 @@ type Liveness struct {
 	allUnsafe bool
 	// unsafePoints bit i is set if Value ID i is an unsafe-point
 	// (preemption is not allowed). Only valid if !allUnsafe.
-	unsafePoints bvec
+	unsafePoints bitvec.BitVec
 
 	// An array with a bit vector for each safe point in the
 	// current Block during Liveness.epilogue. Indexed in Value
 	// order for that block. Additionally, for the entry block
 	// livevars[0] is the entry bitmap. Liveness.compact moves
 	// these to stackMaps.
-	livevars []bvec
+	livevars []bitvec.BitVec
 
 	// livenessMap maps from safe points (i.e., CALLs) to their
 	// liveness map indexes.
 	livenessMap LivenessMap
 	stackMapSet bvecSet
-	stackMaps   []bvec
+	stackMaps   []bitvec.BitVec
 
 	cache progeffectscache
 }
 
 // LivenessMap maps from *ssa.Value to LivenessIndex.
 type LivenessMap struct {
-	vals map[ssa.ID]LivenessIndex
+	vals map[ssa.ID]objw.LivenessIndex
 	// The set of live, pointer-containing variables at the deferreturn
 	// call (only set when open-coded defers are used).
-	deferreturn LivenessIndex
+	deferreturn objw.LivenessIndex
 }
 
 func (m *LivenessMap) reset() {
 	if m.vals == nil {
-		m.vals = make(map[ssa.ID]LivenessIndex)
+		m.vals = make(map[ssa.ID]objw.LivenessIndex)
 	} else {
 		for k := range m.vals {
 			delete(m.vals, k)
 		}
 	}
-	m.deferreturn = LivenessDontCare
+	m.deferreturn = objw.LivenessDontCare
 }
 
-func (m *LivenessMap) set(v *ssa.Value, i LivenessIndex) {
+func (m *LivenessMap) set(v *ssa.Value, i objw.LivenessIndex) {
 	m.vals[v.ID] = i
 }
 
-func (m LivenessMap) Get(v *ssa.Value) LivenessIndex {
+func (m LivenessMap) Get(v *ssa.Value) objw.LivenessIndex {
 	// If v isn't in the map, then it's a "don't care" and not an
 	// unsafe-point.
 	if idx, ok := m.vals[v.ID]; ok {
 		return idx
 	}
-	return LivenessIndex{StackMapDontCare, false}
-}
-
-// LivenessIndex stores the liveness map information for a Value.
-type LivenessIndex struct {
-	stackMapIndex int
-
-	// isUnsafePoint indicates that this is an unsafe-point.
-	//
-	// Note that it's possible for a call Value to have a stack
-	// map while also being an unsafe-point. This means it cannot
-	// be preempted at this instruction, but that a preemption or
-	// stack growth may happen in the called function.
-	isUnsafePoint bool
-}
-
-// LivenessDontCare indicates that the liveness information doesn't
-// matter. Currently it is used in deferreturn liveness when we don't
-// actually need it. It should never be emitted to the PCDATA stream.
-var LivenessDontCare = LivenessIndex{StackMapDontCare, true}
-
-// StackMapDontCare indicates that the stack map index at a Value
-// doesn't matter.
-//
-// This is a sentinel value that should never be emitted to the PCDATA
-// stream. We use -1000 because that's obviously never a valid stack
-// index (but -1 is).
-const StackMapDontCare = -1000
-
-func (idx LivenessIndex) StackMapValid() bool {
-	return idx.stackMapIndex != StackMapDontCare
+	return objw.LivenessIndex{StackMapIndex: objw.StackMapDontCare, IsUnsafePoint: false}
 }
 
 type progeffectscache struct {
@@ -380,7 +352,7 @@ func newliveness(fn *ir.Func, f *ssa.Func, vars []*ir.Name, idx map[*ir.Name]int
 		if cap(lc.be) >= f.NumBlocks() {
 			lv.be = lc.be[:f.NumBlocks()]
 		}
-		lv.livenessMap = LivenessMap{vals: lc.livenessMap.vals, deferreturn: LivenessDontCare}
+		lv.livenessMap = LivenessMap{vals: lc.livenessMap.vals, deferreturn: objw.LivenessDontCare}
 		lc.livenessMap.vals = nil
 	}
 	if lv.be == nil {
@@ -389,14 +361,14 @@ func newliveness(fn *ir.Func, f *ssa.Func, vars []*ir.Name, idx map[*ir.Name]int
 
 	nblocks := int32(len(f.Blocks))
 	nvars := int32(len(vars))
-	bulk := bvbulkalloc(nvars, nblocks*7)
+	bulk := bitvec.NewBulk(nvars, nblocks*7)
 	for _, b := range f.Blocks {
 		be := lv.blockEffects(b)
 
-		be.uevar = bulk.next()
-		be.varkill = bulk.next()
-		be.livein = bulk.next()
-		be.liveout = bulk.next()
+		be.uevar = bulk.Next()
+		be.varkill = bulk.Next()
+		be.livein = bulk.Next()
+		be.liveout = bulk.Next()
 	}
 	lv.livenessMap.reset()
 
@@ -411,7 +383,7 @@ func (lv *Liveness) blockEffects(b *ssa.Block) *BlockEffects {
 // NOTE: The bitmap for a specific type t could be cached in t after
 // the first run and then simply copied into bv at the correct offset
 // on future calls with the same type t.
-func onebitwalktype1(t *types.Type, off int64, bv bvec) {
+func onebitwalktype1(t *types.Type, off int64, bv bitvec.BitVec) {
 	if t.Align > 0 && off&int64(t.Align-1) != 0 {
 		base.Fatalf("onebitwalktype1: invalid initial alignment: type %v has alignment %d, but offset is %v", t, t.Align, off)
 	}
@@ -487,7 +459,7 @@ func onebitwalktype1(t *types.Type, off int64, bv bvec) {
 // Generates live pointer value maps for arguments and local variables. The
 // this argument and the in arguments are always assumed live. The vars
 // argument is a slice of *Nodes.
-func (lv *Liveness) pointerMap(liveout bvec, vars []*ir.Name, args, locals bvec) {
+func (lv *Liveness) pointerMap(liveout bitvec.BitVec, vars []*ir.Name, args, locals bitvec.BitVec) {
 	for i := int32(0); ; i++ {
 		i = liveout.Next(i)
 		if i < 0 {
@@ -527,7 +499,7 @@ func (lv *Liveness) markUnsafePoints() {
 		return
 	}
 
-	lv.unsafePoints = bvalloc(int32(lv.f.NumValues()))
+	lv.unsafePoints = bitvec.New(int32(lv.f.NumValues()))
 
 	// Mark architecture-specific unsafe points.
 	for _, b := range lv.f.Blocks {
@@ -638,11 +610,11 @@ func (lv *Liveness) markUnsafePoints() {
 	// nice to only flood as far as the unsafe.Pointer -> uintptr
 	// conversion, but it's hard to know which argument of an Add
 	// or Sub to follow.
-	var flooded bvec
+	var flooded bitvec.BitVec
 	var flood func(b *ssa.Block, vi int)
 	flood = func(b *ssa.Block, vi int) {
-		if flooded.n == 0 {
-			flooded = bvalloc(int32(lv.f.NumBlocks()))
+		if flooded.N == 0 {
+			flooded = bitvec.New(int32(lv.f.NumBlocks()))
 		}
 		if flooded.Get(int32(b.ID)) {
 			return
@@ -725,8 +697,8 @@ func (lv *Liveness) solve() {
 	// These temporary bitvectors exist to avoid successive allocations and
 	// frees within the loop.
 	nvars := int32(len(lv.vars))
-	newlivein := bvalloc(nvars)
-	newliveout := bvalloc(nvars)
+	newlivein := bitvec.New(nvars)
+	newliveout := bitvec.New(nvars)
 
 	// Walk blocks in postorder ordering. This improves convergence.
 	po := lv.f.Postorder()
@@ -783,8 +755,8 @@ func (lv *Liveness) solve() {
 // variables at each safe point locations.
 func (lv *Liveness) epilogue() {
 	nvars := int32(len(lv.vars))
-	liveout := bvalloc(nvars)
-	livedefer := bvalloc(nvars) // always-live variables
+	liveout := bitvec.New(nvars)
+	livedefer := bitvec.New(nvars) // always-live variables
 
 	// If there is a defer (that could recover), then all output
 	// parameters are live all the time.  In addition, any locals
@@ -838,7 +810,7 @@ func (lv *Liveness) epilogue() {
 
 	{
 		// Reserve an entry for function entry.
-		live := bvalloc(nvars)
+		live := bitvec.New(nvars)
 		lv.livevars = append(lv.livevars, live)
 	}
 
@@ -852,7 +824,7 @@ func (lv *Liveness) epilogue() {
 				continue
 			}
 
-			live := bvalloc(nvars)
+			live := bitvec.New(nvars)
 			lv.livevars = append(lv.livevars, live)
 		}
 
@@ -910,16 +882,16 @@ func (lv *Liveness) epilogue() {
 
 	// If we have an open-coded deferreturn call, make a liveness map for it.
 	if lv.fn.OpenCodedDeferDisallowed() {
-		lv.livenessMap.deferreturn = LivenessDontCare
+		lv.livenessMap.deferreturn = objw.LivenessDontCare
 	} else {
-		lv.livenessMap.deferreturn = LivenessIndex{
-			stackMapIndex: lv.stackMapSet.add(livedefer),
-			isUnsafePoint: false,
+		lv.livenessMap.deferreturn = objw.LivenessIndex{
+			StackMapIndex: lv.stackMapSet.add(livedefer),
+			IsUnsafePoint: false,
 		}
 	}
 
 	// Done compacting. Throw out the stack map set.
-	lv.stackMaps = lv.stackMapSet.extractUniqe()
+	lv.stackMaps = lv.stackMapSet.extractUnique()
 	lv.stackMapSet = bvecSet{}
 
 	// Useful sanity check: on entry to the function,
@@ -958,9 +930,9 @@ func (lv *Liveness) compact(b *ssa.Block) {
 	for _, v := range b.Values {
 		hasStackMap := lv.hasStackMap(v)
 		isUnsafePoint := lv.allUnsafe || lv.unsafePoints.Get(int32(v.ID))
-		idx := LivenessIndex{StackMapDontCare, isUnsafePoint}
+		idx := objw.LivenessIndex{StackMapIndex: objw.StackMapDontCare, IsUnsafePoint: isUnsafePoint}
 		if hasStackMap {
-			idx.stackMapIndex = lv.stackMapSet.add(lv.livevars[pos])
+			idx.StackMapIndex = lv.stackMapSet.add(lv.livevars[pos])
 			pos++
 		}
 		if hasStackMap || isUnsafePoint {
@@ -972,7 +944,7 @@ func (lv *Liveness) compact(b *ssa.Block) {
 	lv.livevars = lv.livevars[:0]
 }
 
-func (lv *Liveness) showlive(v *ssa.Value, live bvec) {
+func (lv *Liveness) showlive(v *ssa.Value, live bitvec.BitVec) {
 	if base.Flag.Live == 0 || ir.FuncName(lv.fn) == "init" || strings.HasPrefix(ir.FuncName(lv.fn), ".") {
 		return
 	}
@@ -1012,7 +984,7 @@ func (lv *Liveness) showlive(v *ssa.Value, live bvec) {
 	base.WarnfAt(pos, s)
 }
 
-func (lv *Liveness) printbvec(printed bool, name string, live bvec) bool {
+func (lv *Liveness) printbvec(printed bool, name string, live bitvec.BitVec) bool {
 	if live.IsEmpty() {
 		return printed
 	}
@@ -1128,7 +1100,7 @@ func (lv *Liveness) printDebug() {
 				fmt.Printf("\tlive=")
 				printed = false
 				if pcdata.StackMapValid() {
-					live := lv.stackMaps[pcdata.stackMapIndex]
+					live := lv.stackMaps[pcdata.StackMapIndex]
 					for j, n := range lv.vars {
 						if !live.Get(int32(j)) {
 							continue
@@ -1143,7 +1115,7 @@ func (lv *Liveness) printDebug() {
 				fmt.Printf("\n")
 			}
 
-			if pcdata.isUnsafePoint {
+			if pcdata.IsUnsafePoint {
 				fmt.Printf("\tunsafe-point\n")
 			}
 		}
@@ -1196,13 +1168,13 @@ func (lv *Liveness) emit() (argsSym, liveSym *obj.LSym) {
 	// Temporary symbols for encoding bitmaps.
 	var argsSymTmp, liveSymTmp obj.LSym
 
-	args := bvalloc(int32(maxArgs / int64(types.PtrSize)))
-	aoff := duint32(&argsSymTmp, 0, uint32(len(lv.stackMaps))) // number of bitmaps
-	aoff = duint32(&argsSymTmp, aoff, uint32(args.n))          // number of bits in each bitmap
+	args := bitvec.New(int32(maxArgs / int64(types.PtrSize)))
+	aoff := objw.Uint32(&argsSymTmp, 0, uint32(len(lv.stackMaps))) // number of bitmaps
+	aoff = objw.Uint32(&argsSymTmp, aoff, uint32(args.N))          // number of bits in each bitmap
 
-	locals := bvalloc(int32(maxLocals / int64(types.PtrSize)))
-	loff := duint32(&liveSymTmp, 0, uint32(len(lv.stackMaps))) // number of bitmaps
-	loff = duint32(&liveSymTmp, loff, uint32(locals.n))        // number of bits in each bitmap
+	locals := bitvec.New(int32(maxLocals / int64(types.PtrSize)))
+	loff := objw.Uint32(&liveSymTmp, 0, uint32(len(lv.stackMaps))) // number of bitmaps
+	loff = objw.Uint32(&liveSymTmp, loff, uint32(locals.N))        // number of bits in each bitmap
 
 	for _, live := range lv.stackMaps {
 		args.Clear()
@@ -1210,8 +1182,8 @@ func (lv *Liveness) emit() (argsSym, liveSym *obj.LSym) {
 
 		lv.pointerMap(live, lv.vars, args, locals)
 
-		aoff = dbvec(&argsSymTmp, aoff, args)
-		loff = dbvec(&liveSymTmp, loff, locals)
+		aoff = objw.BitVec(&argsSymTmp, aoff, args)
+		loff = objw.BitVec(&liveSymTmp, loff, locals)
 	}
 
 	// Give these LSyms content-addressable names,
@@ -1233,7 +1205,7 @@ func (lv *Liveness) emit() (argsSym, liveSym *obj.LSym) {
 // pointer variables in the function and emits a runtime data
 // structure read by the garbage collector.
 // Returns a map from GC safe points to their corresponding stack map index.
-func liveness(curfn *ir.Func, f *ssa.Func, stkptrsize int64, pp *Progs) LivenessMap {
+func liveness(curfn *ir.Func, f *ssa.Func, stkptrsize int64, pp *objw.Progs) LivenessMap {
 	// Construct the global liveness state.
 	vars, idx := getvariables(curfn)
 	lv := newliveness(curfn, f, vars, idx, stkptrsize)
@@ -1247,7 +1219,7 @@ func liveness(curfn *ir.Func, f *ssa.Func, stkptrsize int64, pp *Progs) Liveness
 		for _, b := range f.Blocks {
 			for _, val := range b.Values {
 				if idx := lv.livenessMap.Get(val); idx.StackMapValid() {
-					lv.showlive(val, lv.stackMaps[idx.stackMapIndex])
+					lv.showlive(val, lv.stackMaps[idx.StackMapIndex])
 				}
 			}
 		}
@@ -1276,13 +1248,13 @@ func liveness(curfn *ir.Func, f *ssa.Func, stkptrsize int64, pp *Progs) Liveness
 	fninfo.GCArgs, fninfo.GCLocals = lv.emit()
 
 	p := pp.Prog(obj.AFUNCDATA)
-	Addrconst(&p.From, objabi.FUNCDATA_ArgsPointerMaps)
+	p.From.SetConst(objabi.FUNCDATA_ArgsPointerMaps)
 	p.To.Type = obj.TYPE_MEM
 	p.To.Name = obj.NAME_EXTERN
 	p.To.Sym = fninfo.GCArgs
 
 	p = pp.Prog(obj.AFUNCDATA)
-	Addrconst(&p.From, objabi.FUNCDATA_LocalsPointerMaps)
+	p.From.SetConst(objabi.FUNCDATA_LocalsPointerMaps)
 	p.To.Type = obj.TYPE_MEM
 	p.To.Name = obj.NAME_EXTERN
 	p.To.Sym = fninfo.GCLocals
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 7594884f9f..dcb2620f1f 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -6,7 +6,9 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/bitvec"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/objw"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/gcprog"
@@ -472,14 +474,14 @@ func dimportpath(p *types.Pkg) {
 
 	s := base.Ctxt.Lookup("type..importpath." + p.Prefix + ".")
 	ot := dnameData(s, 0, str, "", nil, false)
-	ggloblsym(s, int32(ot), obj.DUPOK|obj.RODATA)
+	objw.Global(s, int32(ot), obj.DUPOK|obj.RODATA)
 	s.Set(obj.AttrContentAddressable, true)
 	p.Pathsym = s
 }
 
 func dgopkgpath(s *obj.LSym, ot int, pkg *types.Pkg) int {
 	if pkg == nil {
-		return duintptr(s, ot, 0)
+		return objw.Uintptr(s, ot, 0)
 	}
 
 	if pkg == types.LocalPkg && base.Ctxt.Pkgpath == "" {
@@ -489,17 +491,17 @@ func dgopkgpath(s *obj.LSym, ot int, pkg *types.Pkg) int {
 		// Every package that imports this one directly defines the symbol.
 		// See also https://groups.google.com/forum/#!topic/golang-dev/myb9s53HxGQ.
 		ns := base.Ctxt.Lookup(`type..importpath."".`)
-		return dsymptr(s, ot, ns, 0)
+		return objw.SymPtr(s, ot, ns, 0)
 	}
 
 	dimportpath(pkg)
-	return dsymptr(s, ot, pkg.Pathsym, 0)
+	return objw.SymPtr(s, ot, pkg.Pathsym, 0)
 }
 
 // dgopkgpathOff writes an offset relocation in s at offset ot to the pkg path symbol.
 func dgopkgpathOff(s *obj.LSym, ot int, pkg *types.Pkg) int {
 	if pkg == nil {
-		return duint32(s, ot, 0)
+		return objw.Uint32(s, ot, 0)
 	}
 	if pkg == types.LocalPkg && base.Ctxt.Pkgpath == "" {
 		// If we don't know the full import path of the package being compiled
@@ -508,11 +510,11 @@ func dgopkgpathOff(s *obj.LSym, ot int, pkg *types.Pkg) int {
 		// Every package that imports this one directly defines the symbol.
 		// See also https://groups.google.com/forum/#!topic/golang-dev/myb9s53HxGQ.
 		ns := base.Ctxt.Lookup(`type..importpath."".`)
-		return dsymptrOff(s, ot, ns)
+		return objw.SymPtrOff(s, ot, ns)
 	}
 
 	dimportpath(pkg)
-	return dsymptrOff(s, ot, pkg.Pathsym)
+	return objw.SymPtrOff(s, ot, pkg.Pathsym)
 }
 
 // dnameField dumps a reflect.name for a struct field.
@@ -521,7 +523,7 @@ func dnameField(lsym *obj.LSym, ot int, spkg *types.Pkg, ft *types.Field) int {
 		base.Fatalf("package mismatch for %v", ft.Sym)
 	}
 	nsym := dname(ft.Sym.Name, ft.Note, nil, types.IsExported(ft.Sym.Name))
-	return dsymptr(lsym, ot, nsym, 0)
+	return objw.SymPtr(lsym, ot, nsym, 0)
 }
 
 // dnameData writes the contents of a reflect.name into s at offset ot.
@@ -600,7 +602,7 @@ func dname(name, tag string, pkg *types.Pkg, exported bool) *obj.LSym {
 		return s
 	}
 	ot := dnameData(s, 0, name, tag, pkg, exported)
-	ggloblsym(s, int32(ot), obj.DUPOK|obj.RODATA)
+	objw.Global(s, int32(ot), obj.DUPOK|obj.RODATA)
 	s.Set(obj.AttrContentAddressable, true)
 	return s
 }
@@ -634,10 +636,10 @@ func dextratype(lsym *obj.LSym, ot int, t *types.Type, dataAdd int) int {
 		base.Fatalf("methods are too far away on %v: %d", t, dataAdd)
 	}
 
-	ot = duint16(lsym, ot, uint16(mcount))
-	ot = duint16(lsym, ot, uint16(xcount))
-	ot = duint32(lsym, ot, uint32(dataAdd))
-	ot = duint32(lsym, ot, 0)
+	ot = objw.Uint16(lsym, ot, uint16(mcount))
+	ot = objw.Uint16(lsym, ot, uint16(xcount))
+	ot = objw.Uint32(lsym, ot, uint32(dataAdd))
+	ot = objw.Uint32(lsym, ot, 0)
 	return ot
 }
 
@@ -669,7 +671,7 @@ func dextratypeData(lsym *obj.LSym, ot int, t *types.Type) int {
 		}
 		nsym := dname(a.name.Name, "", pkg, exported)
 
-		ot = dsymptrOff(lsym, ot, nsym)
+		ot = objw.SymPtrOff(lsym, ot, nsym)
 		ot = dmethodptrOff(lsym, ot, dtypesym(a.mtype))
 		ot = dmethodptrOff(lsym, ot, a.isym.Linksym())
 		ot = dmethodptrOff(lsym, ot, a.tsym.Linksym())
@@ -678,7 +680,7 @@ func dextratypeData(lsym *obj.LSym, ot int, t *types.Type) int {
 }
 
 func dmethodptrOff(s *obj.LSym, ot int, x *obj.LSym) int {
-	duint32(s, ot, 0)
+	objw.Uint32(s, ot, 0)
 	r := obj.Addrel(s)
 	r.Off = int32(ot)
 	r.Siz = 4
@@ -768,9 +770,9 @@ func dcommontype(lsym *obj.LSym, t *types.Type) int {
 	//		ptrToThis     typeOff
 	//	}
 	ot := 0
-	ot = duintptr(lsym, ot, uint64(t.Width))
-	ot = duintptr(lsym, ot, uint64(ptrdata))
-	ot = duint32(lsym, ot, types.TypeHash(t))
+	ot = objw.Uintptr(lsym, ot, uint64(t.Width))
+	ot = objw.Uintptr(lsym, ot, uint64(ptrdata))
+	ot = objw.Uint32(lsym, ot, types.TypeHash(t))
 
 	var tflag uint8
 	if uncommonSize(t) != 0 {
@@ -802,7 +804,7 @@ func dcommontype(lsym *obj.LSym, t *types.Type) int {
 		}
 	}
 
-	ot = duint8(lsym, ot, tflag)
+	ot = objw.Uint8(lsym, ot, tflag)
 
 	// runtime (and common sense) expects alignment to be a power of two.
 	i := int(t.Align)
@@ -813,8 +815,8 @@ func dcommontype(lsym *obj.LSym, t *types.Type) int {
 	if i&(i-1) != 0 {
 		base.Fatalf("invalid alignment %d for %v", t.Align, t)
 	}
-	ot = duint8(lsym, ot, t.Align) // align
-	ot = duint8(lsym, ot, t.Align) // fieldAlign
+	ot = objw.Uint8(lsym, ot, t.Align) // align
+	ot = objw.Uint8(lsym, ot, t.Align) // fieldAlign
 
 	i = kinds[t.Kind()]
 	if types.IsDirectIface(t) {
@@ -823,23 +825,23 @@ func dcommontype(lsym *obj.LSym, t *types.Type) int {
 	if useGCProg {
 		i |= objabi.KindGCProg
 	}
-	ot = duint8(lsym, ot, uint8(i)) // kind
+	ot = objw.Uint8(lsym, ot, uint8(i)) // kind
 	if eqfunc != nil {
-		ot = dsymptr(lsym, ot, eqfunc, 0) // equality function
+		ot = objw.SymPtr(lsym, ot, eqfunc, 0) // equality function
 	} else {
-		ot = duintptr(lsym, ot, 0) // type we can't do == with
+		ot = objw.Uintptr(lsym, ot, 0) // type we can't do == with
 	}
-	ot = dsymptr(lsym, ot, gcsym, 0) // gcdata
+	ot = objw.SymPtr(lsym, ot, gcsym, 0) // gcdata
 
 	nsym := dname(p, "", nil, exported)
-	ot = dsymptrOff(lsym, ot, nsym) // str
+	ot = objw.SymPtrOff(lsym, ot, nsym) // str
 	// ptrToThis
 	if sptr == nil {
-		ot = duint32(lsym, ot, 0)
+		ot = objw.Uint32(lsym, ot, 0)
 	} else if sptrWeak {
-		ot = dsymptrWeakOff(lsym, ot, sptr)
+		ot = objw.SymPtrWeakOff(lsym, ot, sptr)
 	} else {
-		ot = dsymptrOff(lsym, ot, sptr)
+		ot = objw.SymPtrOff(lsym, ot, sptr)
 	}
 
 	return ot
@@ -1029,24 +1031,24 @@ func dtypesym(t *types.Type) *obj.LSym {
 		t2 := types.NewSlice(t.Elem())
 		s2 := dtypesym(t2)
 		ot = dcommontype(lsym, t)
-		ot = dsymptr(lsym, ot, s1, 0)
-		ot = dsymptr(lsym, ot, s2, 0)
-		ot = duintptr(lsym, ot, uint64(t.NumElem()))
+		ot = objw.SymPtr(lsym, ot, s1, 0)
+		ot = objw.SymPtr(lsym, ot, s2, 0)
+		ot = objw.Uintptr(lsym, ot, uint64(t.NumElem()))
 		ot = dextratype(lsym, ot, t, 0)
 
 	case types.TSLICE:
 		// ../../../../runtime/type.go:/sliceType
 		s1 := dtypesym(t.Elem())
 		ot = dcommontype(lsym, t)
-		ot = dsymptr(lsym, ot, s1, 0)
+		ot = objw.SymPtr(lsym, ot, s1, 0)
 		ot = dextratype(lsym, ot, t, 0)
 
 	case types.TCHAN:
 		// ../../../../runtime/type.go:/chanType
 		s1 := dtypesym(t.Elem())
 		ot = dcommontype(lsym, t)
-		ot = dsymptr(lsym, ot, s1, 0)
-		ot = duintptr(lsym, ot, uint64(t.ChanDir()))
+		ot = objw.SymPtr(lsym, ot, s1, 0)
+		ot = objw.Uintptr(lsym, ot, uint64(t.ChanDir()))
 		ot = dextratype(lsym, ot, t, 0)
 
 	case types.TFUNC:
@@ -1068,8 +1070,8 @@ func dtypesym(t *types.Type) *obj.LSym {
 		if isddd {
 			outCount |= 1 << 15
 		}
-		ot = duint16(lsym, ot, uint16(inCount))
-		ot = duint16(lsym, ot, uint16(outCount))
+		ot = objw.Uint16(lsym, ot, uint16(inCount))
+		ot = objw.Uint16(lsym, ot, uint16(outCount))
 		if types.PtrSize == 8 {
 			ot += 4 // align for *rtype
 		}
@@ -1079,13 +1081,13 @@ func dtypesym(t *types.Type) *obj.LSym {
 
 		// Array of rtype pointers follows funcType.
 		for _, t1 := range t.Recvs().Fields().Slice() {
-			ot = dsymptr(lsym, ot, dtypesym(t1.Type), 0)
+			ot = objw.SymPtr(lsym, ot, dtypesym(t1.Type), 0)
 		}
 		for _, t1 := range t.Params().Fields().Slice() {
-			ot = dsymptr(lsym, ot, dtypesym(t1.Type), 0)
+			ot = objw.SymPtr(lsym, ot, dtypesym(t1.Type), 0)
 		}
 		for _, t1 := range t.Results().Fields().Slice() {
-			ot = dsymptr(lsym, ot, dtypesym(t1.Type), 0)
+			ot = objw.SymPtr(lsym, ot, dtypesym(t1.Type), 0)
 		}
 
 	case types.TINTER:
@@ -1104,9 +1106,9 @@ func dtypesym(t *types.Type) *obj.LSym {
 		}
 		ot = dgopkgpath(lsym, ot, tpkg)
 
-		ot = dsymptr(lsym, ot, lsym, ot+3*types.PtrSize+uncommonSize(t))
-		ot = duintptr(lsym, ot, uint64(n))
-		ot = duintptr(lsym, ot, uint64(n))
+		ot = objw.SymPtr(lsym, ot, lsym, ot+3*types.PtrSize+uncommonSize(t))
+		ot = objw.Uintptr(lsym, ot, uint64(n))
+		ot = objw.Uintptr(lsym, ot, uint64(n))
 		dataAdd := imethodSize() * n
 		ot = dextratype(lsym, ot, t, dataAdd)
 
@@ -1119,8 +1121,8 @@ func dtypesym(t *types.Type) *obj.LSym {
 			}
 			nsym := dname(a.name.Name, "", pkg, exported)
 
-			ot = dsymptrOff(lsym, ot, nsym)
-			ot = dsymptrOff(lsym, ot, dtypesym(a.type_))
+			ot = objw.SymPtrOff(lsym, ot, nsym)
+			ot = objw.SymPtrOff(lsym, ot, dtypesym(a.type_))
 		}
 
 	// ../../../../runtime/type.go:/mapType
@@ -1131,27 +1133,27 @@ func dtypesym(t *types.Type) *obj.LSym {
 		hasher := genhash(t.Key())
 
 		ot = dcommontype(lsym, t)
-		ot = dsymptr(lsym, ot, s1, 0)
-		ot = dsymptr(lsym, ot, s2, 0)
-		ot = dsymptr(lsym, ot, s3, 0)
-		ot = dsymptr(lsym, ot, hasher, 0)
+		ot = objw.SymPtr(lsym, ot, s1, 0)
+		ot = objw.SymPtr(lsym, ot, s2, 0)
+		ot = objw.SymPtr(lsym, ot, s3, 0)
+		ot = objw.SymPtr(lsym, ot, hasher, 0)
 		var flags uint32
 		// Note: flags must match maptype accessors in ../../../../runtime/type.go
 		// and maptype builder in ../../../../reflect/type.go:MapOf.
 		if t.Key().Width > MAXKEYSIZE {
-			ot = duint8(lsym, ot, uint8(types.PtrSize))
+			ot = objw.Uint8(lsym, ot, uint8(types.PtrSize))
 			flags |= 1 // indirect key
 		} else {
-			ot = duint8(lsym, ot, uint8(t.Key().Width))
+			ot = objw.Uint8(lsym, ot, uint8(t.Key().Width))
 		}
 
 		if t.Elem().Width > MAXELEMSIZE {
-			ot = duint8(lsym, ot, uint8(types.PtrSize))
+			ot = objw.Uint8(lsym, ot, uint8(types.PtrSize))
 			flags |= 2 // indirect value
 		} else {
-			ot = duint8(lsym, ot, uint8(t.Elem().Width))
+			ot = objw.Uint8(lsym, ot, uint8(t.Elem().Width))
 		}
-		ot = duint16(lsym, ot, uint16(bmap(t).Width))
+		ot = objw.Uint16(lsym, ot, uint16(bmap(t).Width))
 		if types.IsReflexive(t.Key()) {
 			flags |= 4 // reflexive key
 		}
@@ -1161,7 +1163,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 		if hashMightPanic(t.Key()) {
 			flags |= 16 // hash might panic
 		}
-		ot = duint32(lsym, ot, flags)
+		ot = objw.Uint32(lsym, ot, flags)
 		ot = dextratype(lsym, ot, t, 0)
 
 	case types.TPTR:
@@ -1177,7 +1179,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 		s1 := dtypesym(t.Elem())
 
 		ot = dcommontype(lsym, t)
-		ot = dsymptr(lsym, ot, s1, 0)
+		ot = objw.SymPtr(lsym, ot, s1, 0)
 		ot = dextratype(lsym, ot, t, 0)
 
 	// ../../../../runtime/type.go:/structType
@@ -1203,9 +1205,9 @@ func dtypesym(t *types.Type) *obj.LSym {
 
 		ot = dcommontype(lsym, t)
 		ot = dgopkgpath(lsym, ot, spkg)
-		ot = dsymptr(lsym, ot, lsym, ot+3*types.PtrSize+uncommonSize(t))
-		ot = duintptr(lsym, ot, uint64(len(fields)))
-		ot = duintptr(lsym, ot, uint64(len(fields)))
+		ot = objw.SymPtr(lsym, ot, lsym, ot+3*types.PtrSize+uncommonSize(t))
+		ot = objw.Uintptr(lsym, ot, uint64(len(fields)))
+		ot = objw.Uintptr(lsym, ot, uint64(len(fields)))
 
 		dataAdd := len(fields) * structfieldSize()
 		ot = dextratype(lsym, ot, t, dataAdd)
@@ -1213,7 +1215,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 		for _, f := range fields {
 			// ../../../../runtime/type.go:/structField
 			ot = dnameField(lsym, ot, spkg, f)
-			ot = dsymptr(lsym, ot, dtypesym(f.Type), 0)
+			ot = objw.SymPtr(lsym, ot, dtypesym(f.Type), 0)
 			offsetAnon := uint64(f.Offset) << 1
 			if offsetAnon>>1 != uint64(f.Offset) {
 				base.Fatalf("%v: bad field offset for %s", t, f.Sym.Name)
@@ -1221,12 +1223,12 @@ func dtypesym(t *types.Type) *obj.LSym {
 			if f.Embedded != 0 {
 				offsetAnon |= 1
 			}
-			ot = duintptr(lsym, ot, offsetAnon)
+			ot = objw.Uintptr(lsym, ot, offsetAnon)
 		}
 	}
 
 	ot = dextratypeData(lsym, ot, t)
-	ggloblsym(lsym, int32(ot), int16(dupok|obj.RODATA))
+	objw.Global(lsym, int32(ot), int16(dupok|obj.RODATA))
 
 	// The linker will leave a table of all the typelinks for
 	// types in the binary, so the runtime can find them.
@@ -1396,15 +1398,15 @@ func dumptabs() {
 		//   _      [4]byte
 		//   fun    [1]uintptr // variable sized
 		// }
-		o := dsymptr(i.lsym, 0, dtypesym(i.itype), 0)
-		o = dsymptr(i.lsym, o, dtypesym(i.t), 0)
-		o = duint32(i.lsym, o, types.TypeHash(i.t)) // copy of type hash
-		o += 4                                      // skip unused field
+		o := objw.SymPtr(i.lsym, 0, dtypesym(i.itype), 0)
+		o = objw.SymPtr(i.lsym, o, dtypesym(i.t), 0)
+		o = objw.Uint32(i.lsym, o, types.TypeHash(i.t)) // copy of type hash
+		o += 4                                          // skip unused field
 		for _, fn := range genfun(i.t, i.itype) {
-			o = dsymptr(i.lsym, o, fn, 0) // method pointer for each method
+			o = objw.SymPtr(i.lsym, o, fn, 0) // method pointer for each method
 		}
 		// Nothing writes static itabs, so they are read only.
-		ggloblsym(i.lsym, int32(o), int16(obj.DUPOK|obj.RODATA))
+		objw.Global(i.lsym, int32(o), int16(obj.DUPOK|obj.RODATA))
 		i.lsym.Set(obj.AttrContentAddressable, true)
 	}
 
@@ -1421,20 +1423,20 @@ func dumptabs() {
 			// }
 			nsym := dname(p.s.Name, "", nil, true)
 			tsym := dtypesym(p.t)
-			ot = dsymptrOff(s, ot, nsym)
-			ot = dsymptrOff(s, ot, tsym)
+			ot = objw.SymPtrOff(s, ot, nsym)
+			ot = objw.SymPtrOff(s, ot, tsym)
 			// Plugin exports symbols as interfaces. Mark their types
 			// as UsedInIface.
 			tsym.Set(obj.AttrUsedInIface, true)
 		}
-		ggloblsym(s, int32(ot), int16(obj.RODATA))
+		objw.Global(s, int32(ot), int16(obj.RODATA))
 
 		ot = 0
 		s = base.Ctxt.Lookup("go.plugin.exports")
 		for _, p := range ptabs {
-			ot = dsymptr(s, ot, p.s.Linksym(), 0)
+			ot = objw.SymPtr(s, ot, p.s.Linksym(), 0)
 		}
-		ggloblsym(s, int32(ot), int16(obj.RODATA))
+		objw.Global(s, int32(ot), int16(obj.RODATA))
 	}
 }
 
@@ -1569,9 +1571,9 @@ func dgcptrmask(t *types.Type) *obj.LSym {
 	if !sym.Uniq() {
 		sym.SetUniq(true)
 		for i, x := range ptrmask {
-			duint8(lsym, i, x)
+			objw.Uint8(lsym, i, x)
 		}
-		ggloblsym(lsym, int32(len(ptrmask)), obj.DUPOK|obj.RODATA|obj.LOCAL)
+		objw.Global(lsym, int32(len(ptrmask)), obj.DUPOK|obj.RODATA|obj.LOCAL)
 		lsym.Set(obj.AttrContentAddressable, true)
 	}
 	return lsym
@@ -1588,7 +1590,7 @@ func fillptrmask(t *types.Type, ptrmask []byte) {
 		return
 	}
 
-	vec := bvalloc(8 * int32(len(ptrmask)))
+	vec := bitvec.New(8 * int32(len(ptrmask)))
 	onebitwalktype1(t, 0, vec)
 
 	nptr := types.PtrDataSize(t) / int64(types.PtrSize)
@@ -1637,13 +1639,13 @@ func (p *GCProg) init(lsym *obj.LSym) {
 }
 
 func (p *GCProg) writeByte(x byte) {
-	p.symoff = duint8(p.lsym, p.symoff, x)
+	p.symoff = objw.Uint8(p.lsym, p.symoff, x)
 }
 
 func (p *GCProg) end() {
 	p.w.End()
-	duint32(p.lsym, 0, uint32(p.symoff-4))
-	ggloblsym(p.lsym, int32(p.symoff), obj.DUPOK|obj.RODATA|obj.LOCAL)
+	objw.Uint32(p.lsym, 0, uint32(p.symoff-4))
+	objw.Global(p.lsym, int32(p.symoff), obj.DUPOK|obj.RODATA|obj.LOCAL)
 	if base.Debug.GCProg > 0 {
 		fmt.Fprintf(os.Stderr, "compile: end GCProg for %v\n", p.lsym)
 	}
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 382e4d4320..44e199abbf 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -18,6 +18,7 @@ import (
 	"bytes"
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/objw"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
@@ -228,22 +229,22 @@ func dvarint(x *obj.LSym, off int, v int64) int {
 		panic(fmt.Sprintf("dvarint: bad offset for funcdata - %v", v))
 	}
 	if v < 1<<7 {
-		return duint8(x, off, uint8(v))
+		return objw.Uint8(x, off, uint8(v))
 	}
-	off = duint8(x, off, uint8((v&127)|128))
+	off = objw.Uint8(x, off, uint8((v&127)|128))
 	if v < 1<<14 {
-		return duint8(x, off, uint8(v>>7))
+		return objw.Uint8(x, off, uint8(v>>7))
 	}
-	off = duint8(x, off, uint8(((v>>7)&127)|128))
+	off = objw.Uint8(x, off, uint8(((v>>7)&127)|128))
 	if v < 1<<21 {
-		return duint8(x, off, uint8(v>>14))
+		return objw.Uint8(x, off, uint8(v>>14))
 	}
-	off = duint8(x, off, uint8(((v>>14)&127)|128))
+	off = objw.Uint8(x, off, uint8(((v>>14)&127)|128))
 	if v < 1<<28 {
-		return duint8(x, off, uint8(v>>21))
+		return objw.Uint8(x, off, uint8(v>>21))
 	}
-	off = duint8(x, off, uint8(((v>>21)&127)|128))
-	return duint8(x, off, uint8(v>>28))
+	off = objw.Uint8(x, off, uint8(((v>>21)&127)|128))
+	return objw.Uint8(x, off, uint8(v>>28))
 }
 
 // emitOpenDeferInfo emits FUNCDATA information about the defers in a function
@@ -6281,7 +6282,7 @@ func (s *state) addNamedValue(n *ir.Name, v *ssa.Value) {
 }
 
 // Generate a disconnected call to a runtime routine and a return.
-func gencallret(pp *Progs, sym *obj.LSym) *obj.Prog {
+func gencallret(pp *objw.Progs, sym *obj.LSym) *obj.Prog {
 	p := pp.Prog(obj.ACALL)
 	p.To.Type = obj.TYPE_MEM
 	p.To.Name = obj.NAME_EXTERN
@@ -6298,7 +6299,7 @@ type Branch struct {
 
 // SSAGenState contains state needed during Prog generation.
 type SSAGenState struct {
-	pp *Progs
+	pp *objw.Progs
 
 	// Branches remembers all the branch instructions we've seen
 	// and where they would like to go.
@@ -6344,12 +6345,12 @@ func (s *SSAGenState) Prog(as obj.As) *obj.Prog {
 
 // Pc returns the current Prog.
 func (s *SSAGenState) Pc() *obj.Prog {
-	return s.pp.next
+	return s.pp.Next
 }
 
 // SetPos sets the current source position.
 func (s *SSAGenState) SetPos(pos src.XPos) {
-	s.pp.pos = pos
+	s.pp.Pos = pos
 }
 
 // Br emits a single branch instruction and returns the instruction.
@@ -6385,7 +6386,7 @@ func (s *SSAGenState) DebugFriendlySetPosFrom(v *ssa.Value) {
 			}
 			s.SetPos(p)
 		} else {
-			s.SetPos(s.pp.pos.WithNotStmt())
+			s.SetPos(s.pp.Pos.WithNotStmt())
 		}
 	}
 }
@@ -6397,7 +6398,7 @@ func (s byXoffset) Len() int           { return len(s) }
 func (s byXoffset) Less(i, j int) bool { return s[i].FrameOffset() < s[j].FrameOffset() }
 func (s byXoffset) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 
-func emitStackObjects(e *ssafn, pp *Progs) {
+func emitStackObjects(e *ssafn, pp *objw.Progs) {
 	var vars []*ir.Name
 	for _, n := range e.curfn.Dcl {
 		if livenessShouldTrack(n) && n.Addrtaken() {
@@ -6415,21 +6416,21 @@ func emitStackObjects(e *ssafn, pp *Progs) {
 	// Format must match runtime/stack.go:stackObjectRecord.
 	x := e.curfn.LSym.Func().StackObjects
 	off := 0
-	off = duintptr(x, off, uint64(len(vars)))
+	off = objw.Uintptr(x, off, uint64(len(vars)))
 	for _, v := range vars {
 		// Note: arguments and return values have non-negative Xoffset,
 		// in which case the offset is relative to argp.
 		// Locals have a negative Xoffset, in which case the offset is relative to varp.
-		off = duintptr(x, off, uint64(v.FrameOffset()))
+		off = objw.Uintptr(x, off, uint64(v.FrameOffset()))
 		if !types.TypeSym(v.Type()).Siggen() {
 			e.Fatalf(v.Pos(), "stack object's type symbol not generated for type %s", v.Type())
 		}
-		off = dsymptr(x, off, dtypesym(v.Type()), 0)
+		off = objw.SymPtr(x, off, dtypesym(v.Type()), 0)
 	}
 
 	// Emit a funcdata pointing at the stack object data.
 	p := pp.Prog(obj.AFUNCDATA)
-	Addrconst(&p.From, objabi.FUNCDATA_StackObjects)
+	p.From.SetConst(objabi.FUNCDATA_StackObjects)
 	p.To.Type = obj.TYPE_MEM
 	p.To.Name = obj.NAME_EXTERN
 	p.To.Sym = x
@@ -6442,7 +6443,7 @@ func emitStackObjects(e *ssafn, pp *Progs) {
 }
 
 // genssa appends entries to pp for each instruction in f.
-func genssa(f *ssa.Func, pp *Progs) {
+func genssa(f *ssa.Func, pp *objw.Progs) {
 	var s SSAGenState
 
 	e := f.Frontend().(*ssafn)
@@ -6455,7 +6456,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 		// This function uses open-coded defers -- write out the funcdata
 		// info that we computed at the end of genssa.
 		p := pp.Prog(obj.AFUNCDATA)
-		Addrconst(&p.From, objabi.FUNCDATA_OpenCodedDeferInfo)
+		p.From.SetConst(objabi.FUNCDATA_OpenCodedDeferInfo)
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
 		p.To.Sym = openDeferInfo
@@ -6471,7 +6472,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 		progToValue = make(map[*obj.Prog]*ssa.Value, f.NumValues())
 		progToBlock = make(map[*obj.Prog]*ssa.Block, f.NumBlocks())
 		f.Logf("genssa %s\n", f.Name)
-		progToBlock[s.pp.next] = f.Blocks[0]
+		progToBlock[s.pp.Next] = f.Blocks[0]
 	}
 
 	s.ScratchFpMem = e.scratchFpMem
@@ -6509,7 +6510,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 
 	// Emit basic blocks
 	for i, b := range f.Blocks {
-		s.bstart[b.ID] = s.pp.next
+		s.bstart[b.ID] = s.pp.Next
 		s.lineRunStart = nil
 
 		// Attach a "default" liveness info. Normally this will be
@@ -6518,12 +6519,12 @@ func genssa(f *ssa.Func, pp *Progs) {
 		// instruction. We won't use the actual liveness map on a
 		// control instruction. Just mark it something that is
 		// preemptible, unless this function is "all unsafe".
-		s.pp.nextLive = LivenessIndex{-1, allUnsafe(f)}
+		s.pp.NextLive = objw.LivenessIndex{StackMapIndex: -1, IsUnsafePoint: allUnsafe(f)}
 
 		// Emit values in block
 		thearch.SSAMarkMoves(&s, b)
 		for _, v := range b.Values {
-			x := s.pp.next
+			x := s.pp.Next
 			s.DebugFriendlySetPosFrom(v)
 
 			switch v.Op {
@@ -6561,7 +6562,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 			default:
 				// Attach this safe point to the next
 				// instruction.
-				s.pp.nextLive = s.livenessMap.Get(v)
+				s.pp.NextLive = s.livenessMap.Get(v)
 
 				// Special case for first line in function; move it to the start.
 				if firstPos != src.NoXPos {
@@ -6573,17 +6574,17 @@ func genssa(f *ssa.Func, pp *Progs) {
 			}
 
 			if base.Ctxt.Flag_locationlists {
-				valueToProgAfter[v.ID] = s.pp.next
+				valueToProgAfter[v.ID] = s.pp.Next
 			}
 
 			if f.PrintOrHtmlSSA {
-				for ; x != s.pp.next; x = x.Link {
+				for ; x != s.pp.Next; x = x.Link {
 					progToValue[x] = v
 				}
 			}
 		}
 		// If this is an empty infinite loop, stick a hardware NOP in there so that debuggers are less confused.
-		if s.bstart[b.ID] == s.pp.next && len(b.Succs) == 1 && b.Succs[0].Block() == b {
+		if s.bstart[b.ID] == s.pp.Next && len(b.Succs) == 1 && b.Succs[0].Block() == b {
 			p := thearch.Ginsnop(s.pp)
 			p.Pos = p.Pos.WithIsStmt()
 			if b.Pos == src.NoXPos {
@@ -6603,11 +6604,11 @@ func genssa(f *ssa.Func, pp *Progs) {
 			// line numbers for otherwise empty blocks.
 			next = f.Blocks[i+1]
 		}
-		x := s.pp.next
+		x := s.pp.Next
 		s.SetPos(b.Pos)
 		thearch.SSAGenBlock(&s, b, next)
 		if f.PrintOrHtmlSSA {
-			for ; x != s.pp.next; x = x.Link {
+			for ; x != s.pp.Next; x = x.Link {
 				progToBlock[x] = b
 			}
 		}
@@ -6623,7 +6624,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 		// When doing open-coded defers, generate a disconnected call to
 		// deferreturn and a return. This will be used to during panic
 		// recovery to unwind the stack and return back to the runtime.
-		s.pp.nextLive = s.livenessMap.deferreturn
+		s.pp.NextLive = s.livenessMap.deferreturn
 		gencallret(pp, ir.Syms.Deferreturn)
 	}
 
@@ -6655,7 +6656,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 				// some of the inline marks.
 				// Use this instruction instead.
 				p.Pos = p.Pos.WithIsStmt() // promote position to a statement
-				pp.curfn.LSym.Func().AddInlMark(p, inlMarks[m])
+				pp.CurFunc.LSym.Func().AddInlMark(p, inlMarks[m])
 				// Make the inline mark a real nop, so it doesn't generate any code.
 				m.As = obj.ANOP
 				m.Pos = src.NoXPos
@@ -6667,7 +6668,7 @@ func genssa(f *ssa.Func, pp *Progs) {
 		// Any unmatched inline marks now need to be added to the inlining tree (and will generate a nop instruction).
 		for _, p := range inlMarkList {
 			if p.As != obj.ANOP {
-				pp.curfn.LSym.Func().AddInlMark(p, inlMarks[p])
+				pp.CurFunc.LSym.Func().AddInlMark(p, inlMarks[p])
 			}
 		}
 	}
@@ -7048,7 +7049,7 @@ func (s *SSAGenState) AddrScratch(a *obj.Addr) {
 // Call returns a new CALL instruction for the SSA value v.
 // It uses PrepareCall to prepare the call.
 func (s *SSAGenState) Call(v *ssa.Value) *obj.Prog {
-	pPosIsStmt := s.pp.pos.IsStmt() // The statement-ness fo the call comes from ssaGenState
+	pPosIsStmt := s.pp.Pos.IsStmt() // The statement-ness fo the call comes from ssaGenState
 	s.PrepareCall(v)
 
 	p := s.Prog(obj.ACALL)
@@ -7106,7 +7107,7 @@ func (s *SSAGenState) PrepareCall(v *ssa.Value) {
 		// Record call graph information for nowritebarrierrec
 		// analysis.
 		if nowritebarrierrecCheck != nil {
-			nowritebarrierrecCheck.recordCall(s.pp.curfn, call.Fn, v.Pos)
+			nowritebarrierrecCheck.recordCall(s.pp.CurFunc, call.Fn, v.Pos)
 		}
 	}
 
diff --git a/src/cmd/compile/internal/mips/ggen.go b/src/cmd/compile/internal/mips/ggen.go
index 9cce68821b..1a5125207d 100644
--- a/src/cmd/compile/internal/mips/ggen.go
+++ b/src/cmd/compile/internal/mips/ggen.go
@@ -6,21 +6,21 @@ package mips
 
 import (
 	"cmd/compile/internal/base"
-	"cmd/compile/internal/gc"
+	"cmd/compile/internal/objw"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/mips"
 )
 
 // TODO(mips): implement DUFFZERO
-func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
+func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 
 	if cnt == 0 {
 		return p
 	}
 	if cnt < int64(4*types.PtrSize) {
 		for i := int64(0); i < cnt; i += int64(types.PtrSize) {
-			p = pp.Appendpp(p, mips.AMOVW, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGSP, base.Ctxt.FixedFrameSize()+off+i)
+			p = pp.Append(p, mips.AMOVW, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGSP, base.Ctxt.FixedFrameSize()+off+i)
 		}
 	} else {
 		//fmt.Printf("zerorange frame:%v, lo: %v, hi:%v \n", frame ,lo, hi)
@@ -30,22 +30,22 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 		//	MOVW	R0, (Widthptr)r1
 		//	ADD 	$Widthptr, r1
 		//	BNE		r1, r2, loop
-		p = pp.Appendpp(p, mips.AADD, obj.TYPE_CONST, 0, base.Ctxt.FixedFrameSize()+off-4, obj.TYPE_REG, mips.REGRT1, 0)
+		p = pp.Append(p, mips.AADD, obj.TYPE_CONST, 0, base.Ctxt.FixedFrameSize()+off-4, obj.TYPE_REG, mips.REGRT1, 0)
 		p.Reg = mips.REGSP
-		p = pp.Appendpp(p, mips.AADD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, mips.REGRT2, 0)
+		p = pp.Append(p, mips.AADD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, mips.REGRT2, 0)
 		p.Reg = mips.REGRT1
-		p = pp.Appendpp(p, mips.AMOVW, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGRT1, int64(types.PtrSize))
+		p = pp.Append(p, mips.AMOVW, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGRT1, int64(types.PtrSize))
 		p1 := p
-		p = pp.Appendpp(p, mips.AADD, obj.TYPE_CONST, 0, int64(types.PtrSize), obj.TYPE_REG, mips.REGRT1, 0)
-		p = pp.Appendpp(p, mips.ABNE, obj.TYPE_REG, mips.REGRT1, 0, obj.TYPE_BRANCH, 0, 0)
+		p = pp.Append(p, mips.AADD, obj.TYPE_CONST, 0, int64(types.PtrSize), obj.TYPE_REG, mips.REGRT1, 0)
+		p = pp.Append(p, mips.ABNE, obj.TYPE_REG, mips.REGRT1, 0, obj.TYPE_BRANCH, 0, 0)
 		p.Reg = mips.REGRT2
-		gc.Patch(p, p1)
+		p.To.SetTarget(p1)
 	}
 
 	return p
 }
 
-func ginsnop(pp *gc.Progs) *obj.Prog {
+func ginsnop(pp *objw.Progs) *obj.Prog {
 	p := pp.Prog(mips.ANOR)
 	p.From.Type = obj.TYPE_REG
 	p.From.Reg = mips.REG_R0
diff --git a/src/cmd/compile/internal/mips/ssa.go b/src/cmd/compile/internal/mips/ssa.go
index 10453c27d5..e46d87e17d 100644
--- a/src/cmd/compile/internal/mips/ssa.go
+++ b/src/cmd/compile/internal/mips/ssa.go
@@ -427,7 +427,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p4.From.Reg = v.Args[1].Reg()
 		p4.Reg = mips.REG_R1
 		p4.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p4, p2)
+		p4.To.SetTarget(p2)
 	case ssa.OpMIPSLoweredMove:
 		// SUBU	$4, R1
 		// MOVW	4(R1), Rtmp
@@ -480,7 +480,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p6.From.Reg = v.Args[2].Reg()
 		p6.Reg = mips.REG_R1
 		p6.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p6, p2)
+		p6.To.SetTarget(p2)
 	case ssa.OpMIPSCALLstatic, ssa.OpMIPSCALLclosure, ssa.OpMIPSCALLinter:
 		s.Call(v)
 	case ssa.OpMIPSLoweredWB:
@@ -577,7 +577,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p3.From.Type = obj.TYPE_REG
 		p3.From.Reg = mips.REGTMP
 		p3.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p3, p)
+		p3.To.SetTarget(p)
 
 		s.Prog(mips.ASYNC)
 	case ssa.OpMIPSLoweredAtomicAdd:
@@ -613,7 +613,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p3.From.Type = obj.TYPE_REG
 		p3.From.Reg = mips.REGTMP
 		p3.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p3, p)
+		p3.To.SetTarget(p)
 
 		s.Prog(mips.ASYNC)
 
@@ -657,7 +657,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p3.From.Type = obj.TYPE_REG
 		p3.From.Reg = mips.REGTMP
 		p3.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p3, p)
+		p3.To.SetTarget(p)
 
 		s.Prog(mips.ASYNC)
 
@@ -701,7 +701,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p3.From.Type = obj.TYPE_REG
 		p3.From.Reg = mips.REGTMP
 		p3.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p3, p)
+		p3.To.SetTarget(p)
 
 		s.Prog(mips.ASYNC)
 
@@ -750,12 +750,12 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p5.From.Type = obj.TYPE_REG
 		p5.From.Reg = v.Reg0()
 		p5.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p5, p1)
+		p5.To.SetTarget(p1)
 
 		s.Prog(mips.ASYNC)
 
 		p6 := s.Prog(obj.ANOP)
-		gc.Patch(p2, p6)
+		p2.To.SetTarget(p6)
 
 	case ssa.OpMIPSLoweredNilCheck:
 		// Issue a load which will fault if arg is nil.
diff --git a/src/cmd/compile/internal/mips64/ggen.go b/src/cmd/compile/internal/mips64/ggen.go
index dc5f95960d..37bb871958 100644
--- a/src/cmd/compile/internal/mips64/ggen.go
+++ b/src/cmd/compile/internal/mips64/ggen.go
@@ -5,25 +5,25 @@
 package mips64
 
 import (
-	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/objw"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/mips"
 )
 
-func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
+func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 	if cnt == 0 {
 		return p
 	}
 	if cnt < int64(4*types.PtrSize) {
 		for i := int64(0); i < cnt; i += int64(types.PtrSize) {
-			p = pp.Appendpp(p, mips.AMOVV, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGSP, 8+off+i)
+			p = pp.Append(p, mips.AMOVV, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGSP, 8+off+i)
 		}
 	} else if cnt <= int64(128*types.PtrSize) {
-		p = pp.Appendpp(p, mips.AADDV, obj.TYPE_CONST, 0, 8+off-8, obj.TYPE_REG, mips.REGRT1, 0)
+		p = pp.Append(p, mips.AADDV, obj.TYPE_CONST, 0, 8+off-8, obj.TYPE_REG, mips.REGRT1, 0)
 		p.Reg = mips.REGSP
-		p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
+		p = pp.Append(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
 		p.To.Name = obj.NAME_EXTERN
 		p.To.Sym = ir.Syms.Duffzero
 		p.To.Offset = 8 * (128 - cnt/int64(types.PtrSize))
@@ -34,22 +34,22 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 		//	MOVV	R0, (Widthptr)r1
 		//	ADDV	$Widthptr, r1
 		//	BNE		r1, r2, loop
-		p = pp.Appendpp(p, mips.AADDV, obj.TYPE_CONST, 0, 8+off-8, obj.TYPE_REG, mips.REGRT1, 0)
+		p = pp.Append(p, mips.AADDV, obj.TYPE_CONST, 0, 8+off-8, obj.TYPE_REG, mips.REGRT1, 0)
 		p.Reg = mips.REGSP
-		p = pp.Appendpp(p, mips.AADDV, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, mips.REGRT2, 0)
+		p = pp.Append(p, mips.AADDV, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, mips.REGRT2, 0)
 		p.Reg = mips.REGRT1
-		p = pp.Appendpp(p, mips.AMOVV, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGRT1, int64(types.PtrSize))
+		p = pp.Append(p, mips.AMOVV, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGRT1, int64(types.PtrSize))
 		p1 := p
-		p = pp.Appendpp(p, mips.AADDV, obj.TYPE_CONST, 0, int64(types.PtrSize), obj.TYPE_REG, mips.REGRT1, 0)
-		p = pp.Appendpp(p, mips.ABNE, obj.TYPE_REG, mips.REGRT1, 0, obj.TYPE_BRANCH, 0, 0)
+		p = pp.Append(p, mips.AADDV, obj.TYPE_CONST, 0, int64(types.PtrSize), obj.TYPE_REG, mips.REGRT1, 0)
+		p = pp.Append(p, mips.ABNE, obj.TYPE_REG, mips.REGRT1, 0, obj.TYPE_BRANCH, 0, 0)
 		p.Reg = mips.REGRT2
-		gc.Patch(p, p1)
+		p.To.SetTarget(p1)
 	}
 
 	return p
 }
 
-func ginsnop(pp *gc.Progs) *obj.Prog {
+func ginsnop(pp *objw.Progs) *obj.Prog {
 	p := pp.Prog(mips.ANOR)
 	p.From.Type = obj.TYPE_REG
 	p.From.Reg = mips.REG_R0
diff --git a/src/cmd/compile/internal/mips64/ssa.go b/src/cmd/compile/internal/mips64/ssa.go
index 0da5eebe8d..096e7048ce 100644
--- a/src/cmd/compile/internal/mips64/ssa.go
+++ b/src/cmd/compile/internal/mips64/ssa.go
@@ -428,7 +428,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p4.From.Reg = v.Args[1].Reg()
 		p4.Reg = mips.REG_R1
 		p4.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p4, p2)
+		p4.To.SetTarget(p2)
 	case ssa.OpMIPS64DUFFCOPY:
 		p := s.Prog(obj.ADUFFCOPY)
 		p.To.Type = obj.TYPE_MEM
@@ -490,7 +490,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p6.From.Reg = v.Args[2].Reg()
 		p6.Reg = mips.REG_R1
 		p6.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p6, p2)
+		p6.To.SetTarget(p2)
 	case ssa.OpMIPS64CALLstatic, ssa.OpMIPS64CALLclosure, ssa.OpMIPS64CALLinter:
 		s.Call(v)
 	case ssa.OpMIPS64LoweredWB:
@@ -579,7 +579,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p3.From.Type = obj.TYPE_REG
 		p3.From.Reg = mips.REGTMP
 		p3.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p3, p)
+		p3.To.SetTarget(p)
 		s.Prog(mips.ASYNC)
 	case ssa.OpMIPS64LoweredAtomicAdd32, ssa.OpMIPS64LoweredAtomicAdd64:
 		// SYNC
@@ -616,7 +616,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p3.From.Type = obj.TYPE_REG
 		p3.From.Reg = mips.REGTMP
 		p3.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p3, p)
+		p3.To.SetTarget(p)
 		s.Prog(mips.ASYNC)
 		p4 := s.Prog(mips.AADDVU)
 		p4.From.Type = obj.TYPE_REG
@@ -659,7 +659,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p3.From.Type = obj.TYPE_REG
 		p3.From.Reg = mips.REGTMP
 		p3.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p3, p)
+		p3.To.SetTarget(p)
 		s.Prog(mips.ASYNC)
 		p4 := s.Prog(mips.AADDVU)
 		p4.From.Type = obj.TYPE_CONST
@@ -712,9 +712,9 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p5.From.Type = obj.TYPE_REG
 		p5.From.Reg = v.Reg0()
 		p5.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p5, p1)
+		p5.To.SetTarget(p1)
 		p6 := s.Prog(mips.ASYNC)
-		gc.Patch(p2, p6)
+		p2.To.SetTarget(p6)
 	case ssa.OpMIPS64LoweredNilCheck:
 		// Issue a load which will fault if arg is nil.
 		p := s.Prog(mips.AMOVB)
@@ -751,7 +751,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p3.To.Type = obj.TYPE_REG
 		p3.To.Reg = v.Reg()
 		p4 := s.Prog(obj.ANOP) // not a machine instruction, for branch to land
-		gc.Patch(p2, p4)
+		p2.To.SetTarget(p4)
 	case ssa.OpMIPS64LoweredGetClosurePtr:
 		// Closure pointer is R22 (mips.REGCTXT).
 		gc.CheckLoweredGetClosurePtr(v)
diff --git a/src/cmd/compile/internal/objw/objw.go b/src/cmd/compile/internal/objw/objw.go
new file mode 100644
index 0000000000..dfbcf51556
--- /dev/null
+++ b/src/cmd/compile/internal/objw/objw.go
@@ -0,0 +1,72 @@
+// Copyright 2009 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 objw
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/bitvec"
+	"cmd/compile/internal/types"
+	"cmd/internal/obj"
+)
+
+func Uint8(s *obj.LSym, off int, v uint8) int {
+	return UintN(s, off, uint64(v), 1)
+}
+
+func Uint16(s *obj.LSym, off int, v uint16) int {
+	return UintN(s, off, uint64(v), 2)
+}
+
+func Uint32(s *obj.LSym, off int, v uint32) int {
+	return UintN(s, off, uint64(v), 4)
+}
+
+func Uintptr(s *obj.LSym, off int, v uint64) int {
+	return UintN(s, off, v, types.PtrSize)
+}
+
+func UintN(s *obj.LSym, off int, v uint64, wid int) int {
+	if off&(wid-1) != 0 {
+		base.Fatalf("duintxxLSym: misaligned: v=%d wid=%d off=%d", v, wid, off)
+	}
+	s.WriteInt(base.Ctxt, int64(off), wid, int64(v))
+	return off + wid
+}
+
+func SymPtr(s *obj.LSym, off int, x *obj.LSym, xoff int) int {
+	off = int(types.Rnd(int64(off), int64(types.PtrSize)))
+	s.WriteAddr(base.Ctxt, int64(off), types.PtrSize, x, int64(xoff))
+	off += types.PtrSize
+	return off
+}
+
+func SymPtrOff(s *obj.LSym, off int, x *obj.LSym) int {
+	s.WriteOff(base.Ctxt, int64(off), x, 0)
+	off += 4
+	return off
+}
+
+func SymPtrWeakOff(s *obj.LSym, off int, x *obj.LSym) int {
+	s.WriteWeakOff(base.Ctxt, int64(off), x, 0)
+	off += 4
+	return off
+}
+
+func Global(s *obj.LSym, width int32, flags int16) {
+	if flags&obj.LOCAL != 0 {
+		s.Set(obj.AttrLocal, true)
+		flags &^= obj.LOCAL
+	}
+	base.Ctxt.Globl(s, int64(width), int(flags))
+}
+
+func BitVec(s *obj.LSym, off int, bv bitvec.BitVec) int {
+	// Runtime reads the bitmaps as byte arrays. Oblige.
+	for j := 0; int32(j) < bv.N; j += 8 {
+		word := bv.B[j/32]
+		off = Uint8(s, off, uint8(word>>(uint(j)%32)))
+	}
+	return off
+}
diff --git a/src/cmd/compile/internal/objw/prog.go b/src/cmd/compile/internal/objw/prog.go
new file mode 100644
index 0000000000..54028e47fd
--- /dev/null
+++ b/src/cmd/compile/internal/objw/prog.go
@@ -0,0 +1,218 @@
+// Derived from Inferno utils/6c/txt.c
+// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6c/txt.c
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package objw
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/ssa"
+	"cmd/internal/obj"
+	"cmd/internal/objabi"
+	"cmd/internal/src"
+)
+
+var sharedProgArray = new([10000]obj.Prog) // *T instead of T to work around issue 19839
+
+// NewProgs returns a new Progs for fn.
+// worker indicates which of the backend workers will use the Progs.
+func NewProgs(fn *ir.Func, worker int) *Progs {
+	pp := new(Progs)
+	if base.Ctxt.CanReuseProgs() {
+		sz := len(sharedProgArray) / base.Flag.LowerC
+		pp.Cache = sharedProgArray[sz*worker : sz*(worker+1)]
+	}
+	pp.CurFunc = fn
+
+	// prime the pump
+	pp.Next = pp.NewProg()
+	pp.Clear(pp.Next)
+
+	pp.Pos = fn.Pos()
+	pp.SetText(fn)
+	// PCDATA tables implicitly start with index -1.
+	pp.PrevLive = LivenessIndex{-1, false}
+	pp.NextLive = pp.PrevLive
+	return pp
+}
+
+// Progs accumulates Progs for a function and converts them into machine code.
+type Progs struct {
+	Text       *obj.Prog  // ATEXT Prog for this function
+	Next       *obj.Prog  // next Prog
+	PC         int64      // virtual PC; count of Progs
+	Pos        src.XPos   // position to use for new Progs
+	CurFunc    *ir.Func   // fn these Progs are for
+	Cache      []obj.Prog // local progcache
+	CacheIndex int        // first free element of progcache
+
+	NextLive LivenessIndex // liveness index for the next Prog
+	PrevLive LivenessIndex // last emitted liveness index
+}
+
+// LivenessIndex stores the liveness map information for a Value.
+type LivenessIndex struct {
+	StackMapIndex int
+
+	// IsUnsafePoint indicates that this is an unsafe-point.
+	//
+	// Note that it's possible for a call Value to have a stack
+	// map while also being an unsafe-point. This means it cannot
+	// be preempted at this instruction, but that a preemption or
+	// stack growth may happen in the called function.
+	IsUnsafePoint bool
+}
+
+// StackMapDontCare indicates that the stack map index at a Value
+// doesn't matter.
+//
+// This is a sentinel value that should never be emitted to the PCDATA
+// stream. We use -1000 because that's obviously never a valid stack
+// index (but -1 is).
+const StackMapDontCare = -1000
+
+// LivenessDontCare indicates that the liveness information doesn't
+// matter. Currently it is used in deferreturn liveness when we don't
+// actually need it. It should never be emitted to the PCDATA stream.
+var LivenessDontCare = LivenessIndex{StackMapDontCare, true}
+
+func (idx LivenessIndex) StackMapValid() bool {
+	return idx.StackMapIndex != StackMapDontCare
+}
+
+func (pp *Progs) NewProg() *obj.Prog {
+	var p *obj.Prog
+	if pp.CacheIndex < len(pp.Cache) {
+		p = &pp.Cache[pp.CacheIndex]
+		pp.CacheIndex++
+	} else {
+		p = new(obj.Prog)
+	}
+	p.Ctxt = base.Ctxt
+	return p
+}
+
+// Flush converts from pp to machine code.
+func (pp *Progs) Flush() {
+	plist := &obj.Plist{Firstpc: pp.Text, Curfn: pp.CurFunc}
+	obj.Flushplist(base.Ctxt, plist, pp.NewProg, base.Ctxt.Pkgpath)
+}
+
+// Free clears pp and any associated resources.
+func (pp *Progs) Free() {
+	if base.Ctxt.CanReuseProgs() {
+		// Clear progs to enable GC and avoid abuse.
+		s := pp.Cache[:pp.CacheIndex]
+		for i := range s {
+			s[i] = obj.Prog{}
+		}
+	}
+	// Clear pp to avoid abuse.
+	*pp = Progs{}
+}
+
+// Prog adds a Prog with instruction As to pp.
+func (pp *Progs) Prog(as obj.As) *obj.Prog {
+	if pp.NextLive.StackMapValid() && pp.NextLive.StackMapIndex != pp.PrevLive.StackMapIndex {
+		// Emit stack map index change.
+		idx := pp.NextLive.StackMapIndex
+		pp.PrevLive.StackMapIndex = idx
+		p := pp.Prog(obj.APCDATA)
+		p.From.SetConst(objabi.PCDATA_StackMapIndex)
+		p.To.SetConst(int64(idx))
+	}
+	if pp.NextLive.IsUnsafePoint != pp.PrevLive.IsUnsafePoint {
+		// Emit unsafe-point marker.
+		pp.PrevLive.IsUnsafePoint = pp.NextLive.IsUnsafePoint
+		p := pp.Prog(obj.APCDATA)
+		p.From.SetConst(objabi.PCDATA_UnsafePoint)
+		if pp.NextLive.IsUnsafePoint {
+			p.To.SetConst(objabi.PCDATA_UnsafePointUnsafe)
+		} else {
+			p.To.SetConst(objabi.PCDATA_UnsafePointSafe)
+		}
+	}
+
+	p := pp.Next
+	pp.Next = pp.NewProg()
+	pp.Clear(pp.Next)
+	p.Link = pp.Next
+
+	if !pp.Pos.IsKnown() && base.Flag.K != 0 {
+		base.Warn("prog: unknown position (line 0)")
+	}
+
+	p.As = as
+	p.Pos = pp.Pos
+	if pp.Pos.IsStmt() == src.PosIsStmt {
+		// Clear IsStmt for later Progs at this pos provided that as can be marked as a stmt
+		if ssa.LosesStmtMark(as) {
+			return p
+		}
+		pp.Pos = pp.Pos.WithNotStmt()
+	}
+	return p
+}
+
+func (pp *Progs) Clear(p *obj.Prog) {
+	obj.Nopout(p)
+	p.As = obj.AEND
+	p.Pc = pp.PC
+	pp.PC++
+}
+
+func (pp *Progs) Append(p *obj.Prog, as obj.As, ftype obj.AddrType, freg int16, foffset int64, ttype obj.AddrType, treg int16, toffset int64) *obj.Prog {
+	q := pp.NewProg()
+	pp.Clear(q)
+	q.As = as
+	q.Pos = p.Pos
+	q.From.Type = ftype
+	q.From.Reg = freg
+	q.From.Offset = foffset
+	q.To.Type = ttype
+	q.To.Reg = treg
+	q.To.Offset = toffset
+	q.Link = p.Link
+	p.Link = q
+	return q
+}
+
+func (pp *Progs) SetText(fn *ir.Func) {
+	if pp.Text != nil {
+		base.Fatalf("Progs.settext called twice")
+	}
+	ptxt := pp.Prog(obj.ATEXT)
+	pp.Text = ptxt
+
+	fn.LSym.Func().Text = ptxt
+	ptxt.From.Type = obj.TYPE_MEM
+	ptxt.From.Name = obj.NAME_EXTERN
+	ptxt.From.Sym = fn.LSym
+}
diff --git a/src/cmd/compile/internal/ppc64/ggen.go b/src/cmd/compile/internal/ppc64/ggen.go
index 9e57231863..c76962cfb8 100644
--- a/src/cmd/compile/internal/ppc64/ggen.go
+++ b/src/cmd/compile/internal/ppc64/ggen.go
@@ -6,46 +6,46 @@ package ppc64
 
 import (
 	"cmd/compile/internal/base"
-	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/objw"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/ppc64"
 )
 
-func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
+func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 	if cnt == 0 {
 		return p
 	}
 	if cnt < int64(4*types.PtrSize) {
 		for i := int64(0); i < cnt; i += int64(types.PtrSize) {
-			p = pp.Appendpp(p, ppc64.AMOVD, obj.TYPE_REG, ppc64.REGZERO, 0, obj.TYPE_MEM, ppc64.REGSP, base.Ctxt.FixedFrameSize()+off+i)
+			p = pp.Append(p, ppc64.AMOVD, obj.TYPE_REG, ppc64.REGZERO, 0, obj.TYPE_MEM, ppc64.REGSP, base.Ctxt.FixedFrameSize()+off+i)
 		}
 	} else if cnt <= int64(128*types.PtrSize) {
-		p = pp.Appendpp(p, ppc64.AADD, obj.TYPE_CONST, 0, base.Ctxt.FixedFrameSize()+off-8, obj.TYPE_REG, ppc64.REGRT1, 0)
+		p = pp.Append(p, ppc64.AADD, obj.TYPE_CONST, 0, base.Ctxt.FixedFrameSize()+off-8, obj.TYPE_REG, ppc64.REGRT1, 0)
 		p.Reg = ppc64.REGSP
-		p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
+		p = pp.Append(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
 		p.To.Name = obj.NAME_EXTERN
 		p.To.Sym = ir.Syms.Duffzero
 		p.To.Offset = 4 * (128 - cnt/int64(types.PtrSize))
 	} else {
-		p = pp.Appendpp(p, ppc64.AMOVD, obj.TYPE_CONST, 0, base.Ctxt.FixedFrameSize()+off-8, obj.TYPE_REG, ppc64.REGTMP, 0)
-		p = pp.Appendpp(p, ppc64.AADD, obj.TYPE_REG, ppc64.REGTMP, 0, obj.TYPE_REG, ppc64.REGRT1, 0)
+		p = pp.Append(p, ppc64.AMOVD, obj.TYPE_CONST, 0, base.Ctxt.FixedFrameSize()+off-8, obj.TYPE_REG, ppc64.REGTMP, 0)
+		p = pp.Append(p, ppc64.AADD, obj.TYPE_REG, ppc64.REGTMP, 0, obj.TYPE_REG, ppc64.REGRT1, 0)
 		p.Reg = ppc64.REGSP
-		p = pp.Appendpp(p, ppc64.AMOVD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, ppc64.REGTMP, 0)
-		p = pp.Appendpp(p, ppc64.AADD, obj.TYPE_REG, ppc64.REGTMP, 0, obj.TYPE_REG, ppc64.REGRT2, 0)
+		p = pp.Append(p, ppc64.AMOVD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, ppc64.REGTMP, 0)
+		p = pp.Append(p, ppc64.AADD, obj.TYPE_REG, ppc64.REGTMP, 0, obj.TYPE_REG, ppc64.REGRT2, 0)
 		p.Reg = ppc64.REGRT1
-		p = pp.Appendpp(p, ppc64.AMOVDU, obj.TYPE_REG, ppc64.REGZERO, 0, obj.TYPE_MEM, ppc64.REGRT1, int64(types.PtrSize))
+		p = pp.Append(p, ppc64.AMOVDU, obj.TYPE_REG, ppc64.REGZERO, 0, obj.TYPE_MEM, ppc64.REGRT1, int64(types.PtrSize))
 		p1 := p
-		p = pp.Appendpp(p, ppc64.ACMP, obj.TYPE_REG, ppc64.REGRT1, 0, obj.TYPE_REG, ppc64.REGRT2, 0)
-		p = pp.Appendpp(p, ppc64.ABNE, obj.TYPE_NONE, 0, 0, obj.TYPE_BRANCH, 0, 0)
-		gc.Patch(p, p1)
+		p = pp.Append(p, ppc64.ACMP, obj.TYPE_REG, ppc64.REGRT1, 0, obj.TYPE_REG, ppc64.REGRT2, 0)
+		p = pp.Append(p, ppc64.ABNE, obj.TYPE_NONE, 0, 0, obj.TYPE_BRANCH, 0, 0)
+		p.To.SetTarget(p1)
 	}
 
 	return p
 }
 
-func ginsnop(pp *gc.Progs) *obj.Prog {
+func ginsnop(pp *objw.Progs) *obj.Prog {
 	p := pp.Prog(ppc64.AOR)
 	p.From.Type = obj.TYPE_REG
 	p.From.Reg = ppc64.REG_R0
@@ -54,7 +54,7 @@ func ginsnop(pp *gc.Progs) *obj.Prog {
 	return p
 }
 
-func ginsnopdefer(pp *gc.Progs) *obj.Prog {
+func ginsnopdefer(pp *objw.Progs) *obj.Prog {
 	// On PPC64 two nops are required in the defer case.
 	//
 	// (see gc/cgen.go, gc/plive.go -- copy of comment below)
diff --git a/src/cmd/compile/internal/ppc64/ssa.go b/src/cmd/compile/internal/ppc64/ssa.go
index 32e9be8417..edcaad03ec 100644
--- a/src/cmd/compile/internal/ppc64/ssa.go
+++ b/src/cmd/compile/internal/ppc64/ssa.go
@@ -210,7 +210,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		// BNE retry
 		p3 := s.Prog(ppc64.ABNE)
 		p3.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p3, p)
+		p3.To.SetTarget(p)
 
 	case ssa.OpPPC64LoweredAtomicAdd32,
 		ssa.OpPPC64LoweredAtomicAdd64:
@@ -254,7 +254,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		// BNE retry
 		p4 := s.Prog(ppc64.ABNE)
 		p4.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p4, p)
+		p4.To.SetTarget(p)
 
 		// Ensure a 32 bit result
 		if v.Op == ssa.OpPPC64LoweredAtomicAdd32 {
@@ -300,7 +300,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		// BNE retry
 		p2 := s.Prog(ppc64.ABNE)
 		p2.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p2, p)
+		p2.To.SetTarget(p)
 		// ISYNC
 		pisync := s.Prog(ppc64.AISYNC)
 		pisync.To.Type = obj.TYPE_NONE
@@ -348,7 +348,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		// ISYNC
 		pisync := s.Prog(ppc64.AISYNC)
 		pisync.To.Type = obj.TYPE_NONE
-		gc.Patch(p2, pisync)
+		p2.To.SetTarget(pisync)
 
 	case ssa.OpPPC64LoweredAtomicStore8,
 		ssa.OpPPC64LoweredAtomicStore32,
@@ -439,7 +439,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		// BNE retry
 		p4 := s.Prog(ppc64.ABNE)
 		p4.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p4, p)
+		p4.To.SetTarget(p)
 		// LWSYNC - Assuming shared data not write-through-required nor
 		// caching-inhibited. See Appendix B.2.1.1 in the ISA 2.07b.
 		// If the operation is a CAS-Release, then synchronization is not necessary.
@@ -462,10 +462,10 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p7.From.Offset = 0
 		p7.To.Type = obj.TYPE_REG
 		p7.To.Reg = out
-		gc.Patch(p2, p7)
+		p2.To.SetTarget(p7)
 		// done (label)
 		p8 := s.Prog(obj.ANOP)
-		gc.Patch(p6, p8)
+		p6.To.SetTarget(p8)
 
 	case ssa.OpPPC64LoweredGetClosurePtr:
 		// Closure pointer is R11 (already)
@@ -539,10 +539,10 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.To.Reg = r
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = r0
-		gc.Patch(pbahead, p)
+		pbahead.To.SetTarget(p)
 
 		p = s.Prog(obj.ANOP)
-		gc.Patch(pbover, p)
+		pbover.To.SetTarget(p)
 
 	case ssa.OpPPC64DIVW:
 		// word-width version of above
@@ -574,10 +574,10 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.To.Reg = r
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = r0
-		gc.Patch(pbahead, p)
+		pbahead.To.SetTarget(p)
 
 		p = s.Prog(obj.ANOP)
-		gc.Patch(pbover, p)
+		pbover.To.SetTarget(p)
 
 	case ssa.OpPPC64CLRLSLWI:
 		r := v.Reg()
@@ -1028,7 +1028,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 			p.From.Offset = ppc64.BO_BCTR
 			p.Reg = ppc64.REG_R0
 			p.To.Type = obj.TYPE_BRANCH
-			gc.Patch(p, top)
+			p.To.SetTarget(top)
 		}
 		// When ctr == 1 the loop was not generated but
 		// there are at least 64 bytes to clear, so add
@@ -1228,7 +1228,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 			p.From.Offset = ppc64.BO_BCTR
 			p.Reg = ppc64.REG_R0
 			p.To.Type = obj.TYPE_BRANCH
-			gc.Patch(p, top)
+			p.To.SetTarget(top)
 		}
 
 		// when ctr == 1 the loop was not generated but
@@ -1407,7 +1407,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 			p.From.Offset = ppc64.BO_BCTR
 			p.Reg = ppc64.REG_R0
 			p.To.Type = obj.TYPE_BRANCH
-			gc.Patch(p, top)
+			p.To.SetTarget(top)
 
 			// srcReg and dstReg were incremented in the loop, so
 			// later instructions start with offset 0.
@@ -1654,7 +1654,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 			p.From.Offset = ppc64.BO_BCTR
 			p.Reg = ppc64.REG_R0
 			p.To.Type = obj.TYPE_BRANCH
-			gc.Patch(p, top)
+			p.To.SetTarget(top)
 
 			// srcReg and dstReg were incremented in the loop, so
 			// later instructions start with offset 0.
@@ -1840,7 +1840,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 
 			// NOP (so the BNE has somewhere to land)
 			nop := s.Prog(obj.ANOP)
-			gc.Patch(p2, nop)
+			p2.To.SetTarget(nop)
 
 		} else {
 			// Issue a load which will fault if arg is nil.
diff --git a/src/cmd/compile/internal/riscv64/ggen.go b/src/cmd/compile/internal/riscv64/ggen.go
index d18644bb1b..9df739456b 100644
--- a/src/cmd/compile/internal/riscv64/ggen.go
+++ b/src/cmd/compile/internal/riscv64/ggen.go
@@ -6,14 +6,14 @@ package riscv64
 
 import (
 	"cmd/compile/internal/base"
-	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/objw"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/riscv"
 )
 
-func zeroRange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
+func zeroRange(pp *objw.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 	if cnt == 0 {
 		return p
 	}
@@ -23,15 +23,15 @@ func zeroRange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 
 	if cnt < int64(4*types.PtrSize) {
 		for i := int64(0); i < cnt; i += int64(types.PtrSize) {
-			p = pp.Appendpp(p, riscv.AMOV, obj.TYPE_REG, riscv.REG_ZERO, 0, obj.TYPE_MEM, riscv.REG_SP, off+i)
+			p = pp.Append(p, riscv.AMOV, obj.TYPE_REG, riscv.REG_ZERO, 0, obj.TYPE_MEM, riscv.REG_SP, off+i)
 		}
 		return p
 	}
 
 	if cnt <= int64(128*types.PtrSize) {
-		p = pp.Appendpp(p, riscv.AADDI, obj.TYPE_CONST, 0, off, obj.TYPE_REG, riscv.REG_A0, 0)
+		p = pp.Append(p, riscv.AADDI, obj.TYPE_CONST, 0, off, obj.TYPE_REG, riscv.REG_A0, 0)
 		p.Reg = riscv.REG_SP
-		p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
+		p = pp.Append(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
 		p.To.Name = obj.NAME_EXTERN
 		p.To.Sym = ir.Syms.Duffzero
 		p.To.Offset = 8 * (128 - cnt/int64(types.PtrSize))
@@ -45,15 +45,15 @@ func zeroRange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 	// 	MOV	ZERO, (T0)
 	// 	ADD	$Widthptr, T0
 	//	BNE	T0, T1, loop
-	p = pp.Appendpp(p, riscv.AADD, obj.TYPE_CONST, 0, off, obj.TYPE_REG, riscv.REG_T0, 0)
+	p = pp.Append(p, riscv.AADD, obj.TYPE_CONST, 0, off, obj.TYPE_REG, riscv.REG_T0, 0)
 	p.Reg = riscv.REG_SP
-	p = pp.Appendpp(p, riscv.AADD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, riscv.REG_T1, 0)
+	p = pp.Append(p, riscv.AADD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, riscv.REG_T1, 0)
 	p.Reg = riscv.REG_T0
-	p = pp.Appendpp(p, riscv.AMOV, obj.TYPE_REG, riscv.REG_ZERO, 0, obj.TYPE_MEM, riscv.REG_T0, 0)
+	p = pp.Append(p, riscv.AMOV, obj.TYPE_REG, riscv.REG_ZERO, 0, obj.TYPE_MEM, riscv.REG_T0, 0)
 	loop := p
-	p = pp.Appendpp(p, riscv.AADD, obj.TYPE_CONST, 0, int64(types.PtrSize), obj.TYPE_REG, riscv.REG_T0, 0)
-	p = pp.Appendpp(p, riscv.ABNE, obj.TYPE_REG, riscv.REG_T0, 0, obj.TYPE_BRANCH, 0, 0)
+	p = pp.Append(p, riscv.AADD, obj.TYPE_CONST, 0, int64(types.PtrSize), obj.TYPE_REG, riscv.REG_T0, 0)
+	p = pp.Append(p, riscv.ABNE, obj.TYPE_REG, riscv.REG_T0, 0, obj.TYPE_BRANCH, 0, 0)
 	p.Reg = riscv.REG_T1
-	gc.Patch(p, loop)
+	p.To.SetTarget(loop)
 	return p
 }
diff --git a/src/cmd/compile/internal/riscv64/gsubr.go b/src/cmd/compile/internal/riscv64/gsubr.go
index d40bdf7a1d..74bccf8d42 100644
--- a/src/cmd/compile/internal/riscv64/gsubr.go
+++ b/src/cmd/compile/internal/riscv64/gsubr.go
@@ -5,12 +5,12 @@
 package riscv64
 
 import (
-	"cmd/compile/internal/gc"
+	"cmd/compile/internal/objw"
 	"cmd/internal/obj"
 	"cmd/internal/obj/riscv"
 )
 
-func ginsnop(pp *gc.Progs) *obj.Prog {
+func ginsnop(pp *objw.Progs) *obj.Prog {
 	// Hardware nop is ADD $0, ZERO
 	p := pp.Prog(riscv.AADD)
 	p.From.Type = obj.TYPE_CONST
diff --git a/src/cmd/compile/internal/riscv64/ssa.go b/src/cmd/compile/internal/riscv64/ssa.go
index 616b76e5f6..d08cebdcf5 100644
--- a/src/cmd/compile/internal/riscv64/ssa.go
+++ b/src/cmd/compile/internal/riscv64/ssa.go
@@ -502,7 +502,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p4.From.Reg = riscv.REG_TMP
 		p4.Reg = riscv.REG_ZERO
 		p4.To.Type = obj.TYPE_BRANCH
-		gc.Patch(p4, p1)
+		p4.To.SetTarget(p1)
 
 		p5 := s.Prog(riscv.AMOV)
 		p5.From.Type = obj.TYPE_CONST
@@ -511,7 +511,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p5.To.Reg = out
 
 		p6 := s.Prog(obj.ANOP)
-		gc.Patch(p2, p6)
+		p2.To.SetTarget(p6)
 
 	case ssa.OpRISCV64LoweredZero:
 		mov, sz := largestMove(v.AuxInt)
@@ -537,7 +537,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p3.Reg = v.Args[0].Reg()
 		p3.From.Type = obj.TYPE_REG
 		p3.From.Reg = v.Args[1].Reg()
-		gc.Patch(p3, p)
+		p3.To.SetTarget(p)
 
 	case ssa.OpRISCV64LoweredMove:
 		mov, sz := largestMove(v.AuxInt)
@@ -577,7 +577,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p5.Reg = v.Args[1].Reg()
 		p5.From.Type = obj.TYPE_REG
 		p5.From.Reg = v.Args[2].Reg()
-		gc.Patch(p5, p)
+		p5.To.SetTarget(p)
 
 	case ssa.OpRISCV64LoweredNilCheck:
 		// Issue a load which will fault if arg is nil.
diff --git a/src/cmd/compile/internal/s390x/ggen.go b/src/cmd/compile/internal/s390x/ggen.go
index 0e2f48bf4c..488a080c46 100644
--- a/src/cmd/compile/internal/s390x/ggen.go
+++ b/src/cmd/compile/internal/s390x/ggen.go
@@ -6,7 +6,7 @@ package s390x
 
 import (
 	"cmd/compile/internal/base"
-	"cmd/compile/internal/gc"
+	"cmd/compile/internal/objw"
 	"cmd/internal/obj"
 	"cmd/internal/obj/s390x"
 )
@@ -18,7 +18,7 @@ import (
 const clearLoopCutoff = 1024
 
 // zerorange clears the stack in the given range.
-func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
+func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 	if cnt == 0 {
 		return p
 	}
@@ -31,7 +31,7 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 	// need to create a copy of the stack pointer that we can adjust.
 	// We also need to do this if we are going to loop.
 	if off < 0 || off > 4096-clearLoopCutoff || cnt > clearLoopCutoff {
-		p = pp.Appendpp(p, s390x.AADD, obj.TYPE_CONST, 0, off, obj.TYPE_REG, s390x.REGRT1, 0)
+		p = pp.Append(p, s390x.AADD, obj.TYPE_CONST, 0, off, obj.TYPE_REG, s390x.REGRT1, 0)
 		p.Reg = int16(s390x.REGSP)
 		reg = s390x.REGRT1
 		off = 0
@@ -40,12 +40,12 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 	// Generate a loop of large clears.
 	if cnt > clearLoopCutoff {
 		ireg := int16(s390x.REGRT2) // register holds number of remaining loop iterations
-		p = pp.Appendpp(p, s390x.AMOVD, obj.TYPE_CONST, 0, cnt/256, obj.TYPE_REG, ireg, 0)
-		p = pp.Appendpp(p, s390x.ACLEAR, obj.TYPE_CONST, 0, 256, obj.TYPE_MEM, reg, off)
+		p = pp.Append(p, s390x.AMOVD, obj.TYPE_CONST, 0, cnt/256, obj.TYPE_REG, ireg, 0)
+		p = pp.Append(p, s390x.ACLEAR, obj.TYPE_CONST, 0, 256, obj.TYPE_MEM, reg, off)
 		pl := p
-		p = pp.Appendpp(p, s390x.AADD, obj.TYPE_CONST, 0, 256, obj.TYPE_REG, reg, 0)
-		p = pp.Appendpp(p, s390x.ABRCTG, obj.TYPE_REG, ireg, 0, obj.TYPE_BRANCH, 0, 0)
-		gc.Patch(p, pl)
+		p = pp.Append(p, s390x.AADD, obj.TYPE_CONST, 0, 256, obj.TYPE_REG, reg, 0)
+		p = pp.Append(p, s390x.ABRCTG, obj.TYPE_REG, ireg, 0, obj.TYPE_BRANCH, 0, 0)
+		p.To.SetTarget(pl)
 		cnt = cnt % 256
 	}
 
@@ -70,11 +70,11 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 			case 2:
 				ins = s390x.AMOVH
 			}
-			p = pp.Appendpp(p, ins, obj.TYPE_CONST, 0, 0, obj.TYPE_MEM, reg, off)
+			p = pp.Append(p, ins, obj.TYPE_CONST, 0, 0, obj.TYPE_MEM, reg, off)
 
 		// Handle clears that would require multiple move instructions with CLEAR (assembled as XC).
 		default:
-			p = pp.Appendpp(p, s390x.ACLEAR, obj.TYPE_CONST, 0, n, obj.TYPE_MEM, reg, off)
+			p = pp.Append(p, s390x.ACLEAR, obj.TYPE_CONST, 0, n, obj.TYPE_MEM, reg, off)
 		}
 
 		cnt -= n
@@ -84,6 +84,6 @@ func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog {
 	return p
 }
 
-func ginsnop(pp *gc.Progs) *obj.Prog {
+func ginsnop(pp *objw.Progs) *obj.Prog {
 	return pp.Prog(s390x.ANOPH)
 }
diff --git a/src/cmd/compile/internal/s390x/ssa.go b/src/cmd/compile/internal/s390x/ssa.go
index 366adffd98..dc01401348 100644
--- a/src/cmd/compile/internal/s390x/ssa.go
+++ b/src/cmd/compile/internal/s390x/ssa.go
@@ -709,7 +709,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 
 		bne := s.Prog(s390x.ABLT)
 		bne.To.Type = obj.TYPE_BRANCH
-		gc.Patch(bne, mvc)
+		bne.To.SetTarget(mvc)
 
 		if v.AuxInt > 0 {
 			mvc := s.Prog(s390x.AMVC)
@@ -751,7 +751,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 
 		bne := s.Prog(s390x.ABLT)
 		bne.To.Type = obj.TYPE_BRANCH
-		gc.Patch(bne, clear)
+		bne.To.SetTarget(clear)
 
 		if v.AuxInt > 0 {
 			clear := s.Prog(s390x.ACLEAR)
@@ -846,7 +846,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 
 		// NOP (so the BNE has somewhere to land)
 		nop := s.Prog(obj.ANOP)
-		gc.Patch(bne, nop)
+		bne.To.SetTarget(nop)
 	case ssa.OpS390XLoweredAtomicExchange32, ssa.OpS390XLoweredAtomicExchange64:
 		// Loop until the CS{,G} succeeds.
 		//     MOV{WZ,D} arg0, ret
@@ -873,7 +873,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		// BNE cs
 		bne := s.Prog(s390x.ABNE)
 		bne.To.Type = obj.TYPE_BRANCH
-		gc.Patch(bne, cs)
+		bne.To.SetTarget(cs)
 	case ssa.OpS390XSYNC:
 		s.Prog(s390x.ASYNC)
 	case ssa.OpClobber:
diff --git a/src/cmd/compile/internal/wasm/ssa.go b/src/cmd/compile/internal/wasm/ssa.go
index 4e5aa433d9..ee86fc62d2 100644
--- a/src/cmd/compile/internal/wasm/ssa.go
+++ b/src/cmd/compile/internal/wasm/ssa.go
@@ -9,6 +9,7 @@ import (
 	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
+	"cmd/compile/internal/objw"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -30,7 +31,7 @@ func Init(arch *gc.Arch) {
 	arch.SSAGenBlock = ssaGenBlock
 }
 
-func zeroRange(pp *gc.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.Prog {
+func zeroRange(pp *objw.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.Prog {
 	if cnt == 0 {
 		return p
 	}
@@ -39,15 +40,15 @@ func zeroRange(pp *gc.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.Pr
 	}
 
 	for i := int64(0); i < cnt; i += 8 {
-		p = pp.Appendpp(p, wasm.AGet, obj.TYPE_REG, wasm.REG_SP, 0, 0, 0, 0)
-		p = pp.Appendpp(p, wasm.AI64Const, obj.TYPE_CONST, 0, 0, 0, 0, 0)
-		p = pp.Appendpp(p, wasm.AI64Store, 0, 0, 0, obj.TYPE_CONST, 0, off+i)
+		p = pp.Append(p, wasm.AGet, obj.TYPE_REG, wasm.REG_SP, 0, 0, 0, 0)
+		p = pp.Append(p, wasm.AI64Const, obj.TYPE_CONST, 0, 0, 0, 0, 0)
+		p = pp.Append(p, wasm.AI64Store, 0, 0, 0, obj.TYPE_CONST, 0, off+i)
 	}
 
 	return p
 }
 
-func ginsnop(pp *gc.Progs) *obj.Prog {
+func ginsnop(pp *objw.Progs) *obj.Prog {
 	return pp.Prog(wasm.ANop)
 }
 
diff --git a/src/cmd/compile/internal/x86/ggen.go b/src/cmd/compile/internal/x86/ggen.go
index de43594e88..3ca479763e 100644
--- a/src/cmd/compile/internal/x86/ggen.go
+++ b/src/cmd/compile/internal/x86/ggen.go
@@ -5,41 +5,41 @@
 package x86
 
 import (
-	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/objw"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/x86"
 )
 
-func zerorange(pp *gc.Progs, p *obj.Prog, off, cnt int64, ax *uint32) *obj.Prog {
+func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, ax *uint32) *obj.Prog {
 	if cnt == 0 {
 		return p
 	}
 	if *ax == 0 {
-		p = pp.Appendpp(p, x86.AMOVL, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
+		p = pp.Append(p, x86.AMOVL, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
 		*ax = 1
 	}
 
 	if cnt <= int64(4*types.RegSize) {
 		for i := int64(0); i < cnt; i += int64(types.RegSize) {
-			p = pp.Appendpp(p, x86.AMOVL, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_MEM, x86.REG_SP, off+i)
+			p = pp.Append(p, x86.AMOVL, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_MEM, x86.REG_SP, off+i)
 		}
 	} else if cnt <= int64(128*types.RegSize) {
-		p = pp.Appendpp(p, x86.ALEAL, obj.TYPE_MEM, x86.REG_SP, off, obj.TYPE_REG, x86.REG_DI, 0)
-		p = pp.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_ADDR, 0, 1*(128-cnt/int64(types.RegSize)))
+		p = pp.Append(p, x86.ALEAL, obj.TYPE_MEM, x86.REG_SP, off, obj.TYPE_REG, x86.REG_DI, 0)
+		p = pp.Append(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_ADDR, 0, 1*(128-cnt/int64(types.RegSize)))
 		p.To.Sym = ir.Syms.Duffzero
 	} else {
-		p = pp.Appendpp(p, x86.AMOVL, obj.TYPE_CONST, 0, cnt/int64(types.RegSize), obj.TYPE_REG, x86.REG_CX, 0)
-		p = pp.Appendpp(p, x86.ALEAL, obj.TYPE_MEM, x86.REG_SP, off, obj.TYPE_REG, x86.REG_DI, 0)
-		p = pp.Appendpp(p, x86.AREP, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
-		p = pp.Appendpp(p, x86.ASTOSL, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
+		p = pp.Append(p, x86.AMOVL, obj.TYPE_CONST, 0, cnt/int64(types.RegSize), obj.TYPE_REG, x86.REG_CX, 0)
+		p = pp.Append(p, x86.ALEAL, obj.TYPE_MEM, x86.REG_SP, off, obj.TYPE_REG, x86.REG_DI, 0)
+		p = pp.Append(p, x86.AREP, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
+		p = pp.Append(p, x86.ASTOSL, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
 	}
 
 	return p
 }
 
-func ginsnop(pp *gc.Progs) *obj.Prog {
+func ginsnop(pp *objw.Progs) *obj.Prog {
 	// See comment in ../amd64/ggen.go.
 	p := pp.Prog(x86.AXCHGL)
 	p.From.Type = obj.TYPE_REG
-- 
GitLab


From 071ab0a14c294cda484e6f03140cb3cd27a5dca9 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 23 Dec 2020 00:48:08 -0500
Subject: [PATCH 0309/2400] [dev.regabi] cmd/compile: split out package
 liveness [generated]

[git-generate]

cd src/cmd/compile/internal/gc
rf '
	# AutoVar is essentially an ssa helper; move it there.
	mv AutoVar value.go
	mv value.go cmd/compile/internal/ssa

	# Export liveness API and unexport non-API.
	mv LivenessMap Map
	mv Map.vals Map.Vals
	mv Map.deferreturn Map.DeferReturn
	mv livenessShouldTrack ShouldTrack
	mv onebitwalktype1 SetTypeBits
	mv allUnsafe IsUnsafe
	mv liveness Compute
	mv BlockEffects blockEffects
	mv Liveness liveness
	mv liveness _liveness # make room for import

	mv emitptrargsmap WriteFuncMap
	mv WriteFuncMap plive.go

	mv bvset.go plive.go cmd/compile/internal/liveness
'
cd ../liveness
rf '
	mv _liveness liveness
'

Change-Id: I3b86e5025bd9d32a7e19f44714fa16be4125059e
Reviewed-on: https://go-review.googlesource.com/c/go/+/279311
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/pgen.go           |  36 +---
 src/cmd/compile/internal/gc/reflect.go        |   3 +-
 src/cmd/compile/internal/gc/ssa.go            |  23 +--
 .../internal/{gc => liveness}/bvset.go        |   2 +-
 .../internal/{gc => liveness}/plive.go        | 163 +++++++++++-------
 src/cmd/compile/internal/ssa/value.go         |  11 ++
 6 files changed, 121 insertions(+), 117 deletions(-)
 rename src/cmd/compile/internal/{gc => liveness}/bvset.go (99%)
 rename src/cmd/compile/internal/{gc => liveness}/plive.go (91%)

diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index 40a2195a12..dcba5c7ecb 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -6,8 +6,8 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
-	"cmd/compile/internal/bitvec"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/liveness"
 	"cmd/compile/internal/objw"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/typecheck"
@@ -30,36 +30,6 @@ var (
 	compilequeue []*ir.Func // functions waiting to be compiled
 )
 
-func emitptrargsmap(fn *ir.Func) {
-	if ir.FuncName(fn) == "_" || fn.Sym().Linkname != "" {
-		return
-	}
-	lsym := base.Ctxt.Lookup(fn.LSym.Name + ".args_stackmap")
-	nptr := int(fn.Type().ArgWidth() / int64(types.PtrSize))
-	bv := bitvec.New(int32(nptr) * 2)
-	nbitmap := 1
-	if fn.Type().NumResults() > 0 {
-		nbitmap = 2
-	}
-	off := objw.Uint32(lsym, 0, uint32(nbitmap))
-	off = objw.Uint32(lsym, off, uint32(bv.N))
-
-	if ir.IsMethod(fn) {
-		onebitwalktype1(fn.Type().Recvs(), 0, bv)
-	}
-	if fn.Type().NumParams() > 0 {
-		onebitwalktype1(fn.Type().Params(), 0, bv)
-	}
-	off = objw.BitVec(lsym, off, bv)
-
-	if fn.Type().NumResults() > 0 {
-		onebitwalktype1(fn.Type().Results(), 0, bv)
-		off = objw.BitVec(lsym, off, bv)
-	}
-
-	objw.Global(lsym, int32(off), obj.RODATA|obj.LOCAL)
-}
-
 // cmpstackvarlt reports whether the stack variable a sorts before b.
 //
 // Sort the list of stack variables. Autos after anything else,
@@ -213,7 +183,7 @@ func funccompile(fn *ir.Func) {
 	if len(fn.Body) == 0 {
 		// Initialize ABI wrappers if necessary.
 		initLSym(fn, false)
-		emitptrargsmap(fn)
+		liveness.WriteFuncMap(fn)
 		return
 	}
 
@@ -254,7 +224,7 @@ func compile(fn *ir.Func) {
 	for _, n := range fn.Dcl {
 		switch n.Class_ {
 		case ir.PPARAM, ir.PPARAMOUT, ir.PAUTO:
-			if livenessShouldTrack(n) && n.Addrtaken() {
+			if liveness.ShouldTrack(n) && n.Addrtaken() {
 				dtypesym(n.Type())
 				// Also make sure we allocate a linker symbol
 				// for the stack object data, for the same reason.
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index dcb2620f1f..42f441a44a 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -8,6 +8,7 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/bitvec"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/liveness"
 	"cmd/compile/internal/objw"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
@@ -1591,7 +1592,7 @@ func fillptrmask(t *types.Type, ptrmask []byte) {
 	}
 
 	vec := bitvec.New(8 * int32(len(ptrmask)))
-	onebitwalktype1(t, 0, vec)
+	liveness.SetTypeBits(t, 0, vec)
 
 	nptr := types.PtrDataSize(t) / int64(types.PtrSize)
 	for i := int64(0); i < nptr; i++ {
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 44e199abbf..5c36e922a6 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -18,6 +18,7 @@ import (
 	"bytes"
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/liveness"
 	"cmd/compile/internal/objw"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/typecheck"
@@ -6315,7 +6316,7 @@ type SSAGenState struct {
 
 	// Map from GC safe points to liveness index, generated by
 	// liveness analysis.
-	livenessMap LivenessMap
+	livenessMap liveness.Map
 
 	// lineRunStart records the beginning of the current run of instructions
 	// within a single block sharing the same line number
@@ -6401,7 +6402,7 @@ func (s byXoffset) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 func emitStackObjects(e *ssafn, pp *objw.Progs) {
 	var vars []*ir.Name
 	for _, n := range e.curfn.Dcl {
-		if livenessShouldTrack(n) && n.Addrtaken() {
+		if liveness.ShouldTrack(n) && n.Addrtaken() {
 			vars = append(vars, n)
 		}
 	}
@@ -6448,7 +6449,7 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 
 	e := f.Frontend().(*ssafn)
 
-	s.livenessMap = liveness(e.curfn, f, e.stkptrsize, pp)
+	s.livenessMap = liveness.Compute(e.curfn, f, e.stkptrsize, pp)
 	emitStackObjects(e, pp)
 
 	openDeferInfo := e.curfn.LSym.Func().OpenCodedDeferInfo
@@ -6519,7 +6520,7 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 		// instruction. We won't use the actual liveness map on a
 		// control instruction. Just mark it something that is
 		// preemptible, unless this function is "all unsafe".
-		s.pp.NextLive = objw.LivenessIndex{StackMapIndex: -1, IsUnsafePoint: allUnsafe(f)}
+		s.pp.NextLive = objw.LivenessIndex{StackMapIndex: -1, IsUnsafePoint: liveness.IsUnsafe(f)}
 
 		// Emit values in block
 		thearch.SSAMarkMoves(&s, b)
@@ -6624,7 +6625,7 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 		// When doing open-coded defers, generate a disconnected call to
 		// deferreturn and a return. This will be used to during panic
 		// recovery to unwind the stack and return back to the runtime.
-		s.pp.NextLive = s.livenessMap.deferreturn
+		s.pp.NextLive = s.livenessMap.DeferReturn
 		gencallret(pp, ir.Syms.Deferreturn)
 	}
 
@@ -7012,18 +7013,8 @@ func CheckLoweredGetClosurePtr(v *ssa.Value) {
 	}
 }
 
-// AutoVar returns a *Name and int64 representing the auto variable and offset within it
-// where v should be spilled.
-func AutoVar(v *ssa.Value) (*ir.Name, int64) {
-	loc := v.Block.Func.RegAlloc[v.ID].(ssa.LocalSlot)
-	if v.Type.Size() > loc.Type.Size() {
-		v.Fatalf("spill/restore type %s doesn't fit in slot type %s", v.Type, loc.Type)
-	}
-	return loc.N, loc.Off
-}
-
 func AddrAuto(a *obj.Addr, v *ssa.Value) {
-	n, off := AutoVar(v)
+	n, off := ssa.AutoVar(v)
 	a.Type = obj.TYPE_MEM
 	a.Sym = n.Sym().Linksym()
 	a.Reg = int16(thearch.REGSP)
diff --git a/src/cmd/compile/internal/gc/bvset.go b/src/cmd/compile/internal/liveness/bvset.go
similarity index 99%
rename from src/cmd/compile/internal/gc/bvset.go
rename to src/cmd/compile/internal/liveness/bvset.go
index 7f5f41fb5c..21bc1fee4d 100644
--- a/src/cmd/compile/internal/gc/bvset.go
+++ b/src/cmd/compile/internal/liveness/bvset.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package liveness
 
 import "cmd/compile/internal/bitvec"
 
diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/liveness/plive.go
similarity index 91%
rename from src/cmd/compile/internal/gc/plive.go
rename to src/cmd/compile/internal/liveness/plive.go
index 260edda9ce..785a3a29de 100644
--- a/src/cmd/compile/internal/gc/plive.go
+++ b/src/cmd/compile/internal/liveness/plive.go
@@ -12,9 +12,13 @@
 //
 // Each level includes the earlier output as well.
 
-package gc
+package liveness
 
 import (
+	"crypto/md5"
+	"fmt"
+	"strings"
+
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/bitvec"
 	"cmd/compile/internal/ir"
@@ -23,9 +27,6 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
-	"crypto/md5"
-	"fmt"
-	"strings"
 )
 
 // OpVarDef is an annotation for the liveness analysis, marking a place
@@ -83,8 +84,8 @@ import (
 // so the compiler can allocate two temps to the same location. Here it's now
 // useless, since the implementation of stack objects.
 
-// BlockEffects summarizes the liveness effects on an SSA block.
-type BlockEffects struct {
+// blockEffects summarizes the liveness effects on an SSA block.
+type blockEffects struct {
 	// Computed during Liveness.prologue using only the content of
 	// individual blocks:
 	//
@@ -102,14 +103,14 @@ type BlockEffects struct {
 }
 
 // A collection of global state used by liveness analysis.
-type Liveness struct {
+type liveness struct {
 	fn         *ir.Func
 	f          *ssa.Func
 	vars       []*ir.Name
 	idx        map[*ir.Name]int32
 	stkptrsize int64
 
-	be []BlockEffects
+	be []blockEffects
 
 	// allUnsafe indicates that all points in this function are
 	// unsafe-points.
@@ -127,40 +128,40 @@ type Liveness struct {
 
 	// livenessMap maps from safe points (i.e., CALLs) to their
 	// liveness map indexes.
-	livenessMap LivenessMap
+	livenessMap Map
 	stackMapSet bvecSet
 	stackMaps   []bitvec.BitVec
 
 	cache progeffectscache
 }
 
-// LivenessMap maps from *ssa.Value to LivenessIndex.
-type LivenessMap struct {
-	vals map[ssa.ID]objw.LivenessIndex
-	// The set of live, pointer-containing variables at the deferreturn
+// Map maps from *ssa.Value to LivenessIndex.
+type Map struct {
+	Vals map[ssa.ID]objw.LivenessIndex
+	// The set of live, pointer-containing variables at the DeferReturn
 	// call (only set when open-coded defers are used).
-	deferreturn objw.LivenessIndex
+	DeferReturn objw.LivenessIndex
 }
 
-func (m *LivenessMap) reset() {
-	if m.vals == nil {
-		m.vals = make(map[ssa.ID]objw.LivenessIndex)
+func (m *Map) reset() {
+	if m.Vals == nil {
+		m.Vals = make(map[ssa.ID]objw.LivenessIndex)
 	} else {
-		for k := range m.vals {
-			delete(m.vals, k)
+		for k := range m.Vals {
+			delete(m.Vals, k)
 		}
 	}
-	m.deferreturn = objw.LivenessDontCare
+	m.DeferReturn = objw.LivenessDontCare
 }
 
-func (m *LivenessMap) set(v *ssa.Value, i objw.LivenessIndex) {
-	m.vals[v.ID] = i
+func (m *Map) set(v *ssa.Value, i objw.LivenessIndex) {
+	m.Vals[v.ID] = i
 }
 
-func (m LivenessMap) Get(v *ssa.Value) objw.LivenessIndex {
+func (m Map) Get(v *ssa.Value) objw.LivenessIndex {
 	// If v isn't in the map, then it's a "don't care" and not an
 	// unsafe-point.
-	if idx, ok := m.vals[v.ID]; ok {
+	if idx, ok := m.Vals[v.ID]; ok {
 		return idx
 	}
 	return objw.LivenessIndex{StackMapIndex: objw.StackMapDontCare, IsUnsafePoint: false}
@@ -172,13 +173,13 @@ type progeffectscache struct {
 	initialized bool
 }
 
-// livenessShouldTrack reports whether the liveness analysis
+// ShouldTrack reports whether the liveness analysis
 // should track the variable n.
 // We don't care about variables that have no pointers,
 // nor do we care about non-local variables,
 // nor do we care about empty structs (handled by the pointer check),
 // nor do we care about the fake PAUTOHEAP variables.
-func livenessShouldTrack(nn ir.Node) bool {
+func ShouldTrack(nn ir.Node) bool {
 	if nn.Op() != ir.ONAME {
 		return false
 	}
@@ -191,7 +192,7 @@ func livenessShouldTrack(nn ir.Node) bool {
 func getvariables(fn *ir.Func) ([]*ir.Name, map[*ir.Name]int32) {
 	var vars []*ir.Name
 	for _, n := range fn.Dcl {
-		if livenessShouldTrack(n) {
+		if ShouldTrack(n) {
 			vars = append(vars, n)
 		}
 	}
@@ -202,7 +203,7 @@ func getvariables(fn *ir.Func) ([]*ir.Name, map[*ir.Name]int32) {
 	return vars, idx
 }
 
-func (lv *Liveness) initcache() {
+func (lv *liveness) initcache() {
 	if lv.cache.initialized {
 		base.Fatalf("liveness cache initialized twice")
 		return
@@ -246,7 +247,7 @@ const (
 // valueEffects returns the index of a variable in lv.vars and the
 // liveness effects v has on that variable.
 // If v does not affect any tracked variables, it returns -1, 0.
-func (lv *Liveness) valueEffects(v *ssa.Value) (int32, liveEffect) {
+func (lv *liveness) valueEffects(v *ssa.Value) (int32, liveEffect) {
 	n, e := affectedNode(v)
 	if e == 0 || n == nil || n.Op() != ir.ONAME { // cheapest checks first
 		return -1, 0
@@ -293,10 +294,10 @@ func affectedNode(v *ssa.Value) (ir.Node, ssa.SymEffect) {
 	// Special cases.
 	switch v.Op {
 	case ssa.OpLoadReg:
-		n, _ := AutoVar(v.Args[0])
+		n, _ := ssa.AutoVar(v.Args[0])
 		return n, ssa.SymRead
 	case ssa.OpStoreReg:
-		n, _ := AutoVar(v)
+		n, _ := ssa.AutoVar(v)
 		return n, ssa.SymWrite
 
 	case ssa.OpVarLive:
@@ -304,7 +305,7 @@ func affectedNode(v *ssa.Value) (ir.Node, ssa.SymEffect) {
 	case ssa.OpVarDef, ssa.OpVarKill:
 		return v.Aux.(*ir.Name), ssa.SymWrite
 	case ssa.OpKeepAlive:
-		n, _ := AutoVar(v.Args[0])
+		n, _ := ssa.AutoVar(v.Args[0])
 		return n, ssa.SymRead
 	}
 
@@ -326,15 +327,15 @@ func affectedNode(v *ssa.Value) (ir.Node, ssa.SymEffect) {
 }
 
 type livenessFuncCache struct {
-	be          []BlockEffects
-	livenessMap LivenessMap
+	be          []blockEffects
+	livenessMap Map
 }
 
 // Constructs a new liveness structure used to hold the global state of the
 // liveness computation. The cfg argument is a slice of *BasicBlocks and the
 // vars argument is a slice of *Nodes.
-func newliveness(fn *ir.Func, f *ssa.Func, vars []*ir.Name, idx map[*ir.Name]int32, stkptrsize int64) *Liveness {
-	lv := &Liveness{
+func newliveness(fn *ir.Func, f *ssa.Func, vars []*ir.Name, idx map[*ir.Name]int32, stkptrsize int64) *liveness {
+	lv := &liveness{
 		fn:         fn,
 		f:          f,
 		vars:       vars,
@@ -352,11 +353,11 @@ func newliveness(fn *ir.Func, f *ssa.Func, vars []*ir.Name, idx map[*ir.Name]int
 		if cap(lc.be) >= f.NumBlocks() {
 			lv.be = lc.be[:f.NumBlocks()]
 		}
-		lv.livenessMap = LivenessMap{vals: lc.livenessMap.vals, deferreturn: objw.LivenessDontCare}
-		lc.livenessMap.vals = nil
+		lv.livenessMap = Map{Vals: lc.livenessMap.Vals, DeferReturn: objw.LivenessDontCare}
+		lc.livenessMap.Vals = nil
 	}
 	if lv.be == nil {
-		lv.be = make([]BlockEffects, f.NumBlocks())
+		lv.be = make([]blockEffects, f.NumBlocks())
 	}
 
 	nblocks := int32(len(f.Blocks))
@@ -376,14 +377,14 @@ func newliveness(fn *ir.Func, f *ssa.Func, vars []*ir.Name, idx map[*ir.Name]int
 	return lv
 }
 
-func (lv *Liveness) blockEffects(b *ssa.Block) *BlockEffects {
+func (lv *liveness) blockEffects(b *ssa.Block) *blockEffects {
 	return &lv.be[b.ID]
 }
 
 // NOTE: The bitmap for a specific type t could be cached in t after
 // the first run and then simply copied into bv at the correct offset
 // on future calls with the same type t.
-func onebitwalktype1(t *types.Type, off int64, bv bitvec.BitVec) {
+func SetTypeBits(t *types.Type, off int64, bv bitvec.BitVec) {
 	if t.Align > 0 && off&int64(t.Align-1) != 0 {
 		base.Fatalf("onebitwalktype1: invalid initial alignment: type %v has alignment %d, but offset is %v", t, t.Align, off)
 	}
@@ -442,13 +443,13 @@ func onebitwalktype1(t *types.Type, off int64, bv bitvec.BitVec) {
 			break
 		}
 		for i := int64(0); i < t.NumElem(); i++ {
-			onebitwalktype1(elt, off, bv)
+			SetTypeBits(elt, off, bv)
 			off += elt.Width
 		}
 
 	case types.TSTRUCT:
 		for _, f := range t.Fields().Slice() {
-			onebitwalktype1(f.Type, off+f.Offset, bv)
+			SetTypeBits(f.Type, off+f.Offset, bv)
 		}
 
 	default:
@@ -459,7 +460,7 @@ func onebitwalktype1(t *types.Type, off int64, bv bitvec.BitVec) {
 // Generates live pointer value maps for arguments and local variables. The
 // this argument and the in arguments are always assumed live. The vars
 // argument is a slice of *Nodes.
-func (lv *Liveness) pointerMap(liveout bitvec.BitVec, vars []*ir.Name, args, locals bitvec.BitVec) {
+func (lv *liveness) pointerMap(liveout bitvec.BitVec, vars []*ir.Name, args, locals bitvec.BitVec) {
 	for i := int32(0); ; i++ {
 		i = liveout.Next(i)
 		if i < 0 {
@@ -468,17 +469,17 @@ func (lv *Liveness) pointerMap(liveout bitvec.BitVec, vars []*ir.Name, args, loc
 		node := vars[i]
 		switch node.Class_ {
 		case ir.PAUTO:
-			onebitwalktype1(node.Type(), node.FrameOffset()+lv.stkptrsize, locals)
+			SetTypeBits(node.Type(), node.FrameOffset()+lv.stkptrsize, locals)
 
 		case ir.PPARAM, ir.PPARAMOUT:
-			onebitwalktype1(node.Type(), node.FrameOffset(), args)
+			SetTypeBits(node.Type(), node.FrameOffset(), args)
 		}
 	}
 }
 
-// allUnsafe indicates that all points in this function are
+// IsUnsafe indicates that all points in this function are
 // unsafe-points.
-func allUnsafe(f *ssa.Func) bool {
+func IsUnsafe(f *ssa.Func) bool {
 	// The runtime assumes the only safe-points are function
 	// prologues (because that's how it used to be). We could and
 	// should improve that, but for now keep consider all points
@@ -492,8 +493,8 @@ func allUnsafe(f *ssa.Func) bool {
 }
 
 // markUnsafePoints finds unsafe points and computes lv.unsafePoints.
-func (lv *Liveness) markUnsafePoints() {
-	if allUnsafe(lv.f) {
+func (lv *liveness) markUnsafePoints() {
+	if IsUnsafe(lv.f) {
 		// No complex analysis necessary.
 		lv.allUnsafe = true
 		return
@@ -655,7 +656,7 @@ func (lv *Liveness) markUnsafePoints() {
 // This does not necessarily mean the instruction is a safe-point. In
 // particular, call Values can have a stack map in case the callee
 // grows the stack, but not themselves be a safe-point.
-func (lv *Liveness) hasStackMap(v *ssa.Value) bool {
+func (lv *liveness) hasStackMap(v *ssa.Value) bool {
 	if !v.Op.IsCall() {
 		return false
 	}
@@ -671,7 +672,7 @@ func (lv *Liveness) hasStackMap(v *ssa.Value) bool {
 // Initializes the sets for solving the live variables. Visits all the
 // instructions in each basic block to summarizes the information at each basic
 // block
-func (lv *Liveness) prologue() {
+func (lv *liveness) prologue() {
 	lv.initcache()
 
 	for _, b := range lv.f.Blocks {
@@ -693,7 +694,7 @@ func (lv *Liveness) prologue() {
 }
 
 // Solve the liveness dataflow equations.
-func (lv *Liveness) solve() {
+func (lv *liveness) solve() {
 	// These temporary bitvectors exist to avoid successive allocations and
 	// frees within the loop.
 	nvars := int32(len(lv.vars))
@@ -753,7 +754,7 @@ func (lv *Liveness) solve() {
 
 // Visits all instructions in a basic block and computes a bit vector of live
 // variables at each safe point locations.
-func (lv *Liveness) epilogue() {
+func (lv *liveness) epilogue() {
 	nvars := int32(len(lv.vars))
 	liveout := bitvec.New(nvars)
 	livedefer := bitvec.New(nvars) // always-live variables
@@ -882,9 +883,9 @@ func (lv *Liveness) epilogue() {
 
 	// If we have an open-coded deferreturn call, make a liveness map for it.
 	if lv.fn.OpenCodedDeferDisallowed() {
-		lv.livenessMap.deferreturn = objw.LivenessDontCare
+		lv.livenessMap.DeferReturn = objw.LivenessDontCare
 	} else {
-		lv.livenessMap.deferreturn = objw.LivenessIndex{
+		lv.livenessMap.DeferReturn = objw.LivenessIndex{
 			StackMapIndex: lv.stackMapSet.add(livedefer),
 			IsUnsafePoint: false,
 		}
@@ -920,7 +921,7 @@ func (lv *Liveness) epilogue() {
 // is actually a net loss: we save about 50k of argument bitmaps but the new
 // PCDATA tables cost about 100k. So for now we keep using a single index for
 // both bitmap lists.
-func (lv *Liveness) compact(b *ssa.Block) {
+func (lv *liveness) compact(b *ssa.Block) {
 	pos := 0
 	if b == lv.f.Entry {
 		// Handle entry stack map.
@@ -944,7 +945,7 @@ func (lv *Liveness) compact(b *ssa.Block) {
 	lv.livevars = lv.livevars[:0]
 }
 
-func (lv *Liveness) showlive(v *ssa.Value, live bitvec.BitVec) {
+func (lv *liveness) showlive(v *ssa.Value, live bitvec.BitVec) {
 	if base.Flag.Live == 0 || ir.FuncName(lv.fn) == "init" || strings.HasPrefix(ir.FuncName(lv.fn), ".") {
 		return
 	}
@@ -984,7 +985,7 @@ func (lv *Liveness) showlive(v *ssa.Value, live bitvec.BitVec) {
 	base.WarnfAt(pos, s)
 }
 
-func (lv *Liveness) printbvec(printed bool, name string, live bitvec.BitVec) bool {
+func (lv *liveness) printbvec(printed bool, name string, live bitvec.BitVec) bool {
 	if live.IsEmpty() {
 		return printed
 	}
@@ -1008,7 +1009,7 @@ func (lv *Liveness) printbvec(printed bool, name string, live bitvec.BitVec) boo
 }
 
 // printeffect is like printbvec, but for valueEffects.
-func (lv *Liveness) printeffect(printed bool, name string, pos int32, x bool) bool {
+func (lv *liveness) printeffect(printed bool, name string, pos int32, x bool) bool {
 	if !x {
 		return printed
 	}
@@ -1028,7 +1029,7 @@ func (lv *Liveness) printeffect(printed bool, name string, pos int32, x bool) bo
 // Prints the computed liveness information and inputs, for debugging.
 // This format synthesizes the information used during the multiple passes
 // into a single presentation.
-func (lv *Liveness) printDebug() {
+func (lv *liveness) printDebug() {
 	fmt.Printf("liveness: %s\n", ir.FuncName(lv.fn))
 
 	for i, b := range lv.f.Blocks {
@@ -1137,7 +1138,7 @@ func (lv *Liveness) printDebug() {
 // first word dumped is the total number of bitmaps. The second word is the
 // length of the bitmaps. All bitmaps are assumed to be of equal length. The
 // remaining bytes are the raw bitmaps.
-func (lv *Liveness) emit() (argsSym, liveSym *obj.LSym) {
+func (lv *liveness) emit() (argsSym, liveSym *obj.LSym) {
 	// Size args bitmaps to be just large enough to hold the largest pointer.
 	// First, find the largest Xoffset node we care about.
 	// (Nodes without pointers aren't in lv.vars; see livenessShouldTrack.)
@@ -1201,11 +1202,11 @@ func (lv *Liveness) emit() (argsSym, liveSym *obj.LSym) {
 	return makeSym(&argsSymTmp), makeSym(&liveSymTmp)
 }
 
-// Entry pointer for liveness analysis. Solves for the liveness of
+// Entry pointer for Compute analysis. Solves for the Compute of
 // pointer variables in the function and emits a runtime data
 // structure read by the garbage collector.
 // Returns a map from GC safe points to their corresponding stack map index.
-func liveness(curfn *ir.Func, f *ssa.Func, stkptrsize int64, pp *objw.Progs) LivenessMap {
+func Compute(curfn *ir.Func, f *ssa.Func, stkptrsize int64, pp *objw.Progs) Map {
 	// Construct the global liveness state.
 	vars, idx := getvariables(curfn)
 	lv := newliveness(curfn, f, vars, idx, stkptrsize)
@@ -1233,11 +1234,11 @@ func liveness(curfn *ir.Func, f *ssa.Func, stkptrsize int64, pp *objw.Progs) Liv
 		cache := f.Cache.Liveness.(*livenessFuncCache)
 		if cap(lv.be) < 2000 { // Threshold from ssa.Cache slices.
 			for i := range lv.be {
-				lv.be[i] = BlockEffects{}
+				lv.be[i] = blockEffects{}
 			}
 			cache.be = lv.be
 		}
-		if len(lv.livenessMap.vals) < 2000 {
+		if len(lv.livenessMap.Vals) < 2000 {
 			cache.livenessMap = lv.livenessMap
 		}
 	}
@@ -1298,3 +1299,33 @@ func isfat(t *types.Type) bool {
 
 	return false
 }
+
+func WriteFuncMap(fn *ir.Func) {
+	if ir.FuncName(fn) == "_" || fn.Sym().Linkname != "" {
+		return
+	}
+	lsym := base.Ctxt.Lookup(fn.LSym.Name + ".args_stackmap")
+	nptr := int(fn.Type().ArgWidth() / int64(types.PtrSize))
+	bv := bitvec.New(int32(nptr) * 2)
+	nbitmap := 1
+	if fn.Type().NumResults() > 0 {
+		nbitmap = 2
+	}
+	off := objw.Uint32(lsym, 0, uint32(nbitmap))
+	off = objw.Uint32(lsym, off, uint32(bv.N))
+
+	if ir.IsMethod(fn) {
+		SetTypeBits(fn.Type().Recvs(), 0, bv)
+	}
+	if fn.Type().NumParams() > 0 {
+		SetTypeBits(fn.Type().Params(), 0, bv)
+	}
+	off = objw.BitVec(lsym, off, bv)
+
+	if fn.Type().NumResults() > 0 {
+		SetTypeBits(fn.Type().Results(), 0, bv)
+		off = objw.BitVec(lsym, off, bv)
+	}
+
+	objw.Global(lsym, int32(off), obj.RODATA|obj.LOCAL)
+}
diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go
index 993c5a580f..d000b7cce0 100644
--- a/src/cmd/compile/internal/ssa/value.go
+++ b/src/cmd/compile/internal/ssa/value.go
@@ -5,6 +5,7 @@
 package ssa
 
 import (
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"fmt"
@@ -495,3 +496,13 @@ func (v *Value) removeable() bool {
 
 // TODO(mdempsky): Shouldn't be necessary; see discussion at golang.org/cl/275756
 func (*Value) CanBeAnSSAAux() {}
+
+// AutoVar returns a *Name and int64 representing the auto variable and offset within it
+// where v should be spilled.
+func AutoVar(v *Value) (*ir.Name, int64) {
+	loc := v.Block.Func.RegAlloc[v.ID].(LocalSlot)
+	if v.Type.Size() > loc.Type.Size() {
+		v.Fatalf("spill/restore type %s doesn't fit in slot type %s", v.Type, loc.Type)
+	}
+	return loc.N, loc.Off
+}
-- 
GitLab


From de454eef5f47212dc8a9d9c2c8b598fa343d2c2b Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 23 Dec 2020 00:51:28 -0500
Subject: [PATCH 0310/2400] [dev.regabi] cmd/compile: split out package escape
 [generated]

[git-generate]

cd src/cmd/compile/internal/gc
rf '
	# Trivial min, max defined in escape.go but only used in ssa.go.
	mv min8 max8 ssa.go

	# Export package escape API.
	mv escapes Funcs
	mv escapeFuncs Batch
	mv escFmt Fmt
	mv unsafeUintptrTag UnsafeUintptrNote
	mv uintptrEscapesTag UintptrEscapesNote
	mv heapAllocReason HeapAllocReason

	# Unexport non-API.
	mv EscEdge edge
	mv EscHole hole
	mv EscLeaks leaks
	mv ParseLeaks parseLeaks
	mv EscLocation location
	mv EscNote note
	mv Escape _escape # leave room for escape import, fixed below
	mv EscFuncUnknown escFuncUnknown
	mv EscFuncPlanned escFuncPlanned
	mv EscFuncStarted escFuncStarted
	mv EscFuncTagged escFuncTagged

	mv escape.go cmd/compile/internal/escape
'
cd ../escape
rf '
	mv _escape escape
'

Change-Id: I3a6d1bfb6eba12bea936354ea1fe9813cbde425c
Reviewed-on: https://go-review.googlesource.com/c/go/+/279472
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 .../compile/internal/{gc => escape}/escape.go | 275 +++++++++---------
 src/cmd/compile/internal/gc/gsubr.go          |   3 +-
 src/cmd/compile/internal/gc/main.go           |   5 +-
 src/cmd/compile/internal/gc/order.go          |   3 +-
 src/cmd/compile/internal/gc/ssa.go            |  14 +
 src/cmd/compile/internal/gc/subr.go           |   3 +-
 src/cmd/compile/internal/gc/walk.go           |   3 +-
 7 files changed, 156 insertions(+), 150 deletions(-)
 rename src/cmd/compile/internal/{gc => escape}/escape.go (90%)

diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/escape/escape.go
similarity index 90%
rename from src/cmd/compile/internal/gc/escape.go
rename to src/cmd/compile/internal/escape/escape.go
index 187313695f..b7cb56b997 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -2,18 +2,19 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package escape
 
 import (
+	"fmt"
+	"math"
+	"strings"
+
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
-	"fmt"
-	"math"
-	"strings"
 )
 
 // Escape analysis.
@@ -84,8 +85,8 @@ import (
 // u[2], etc. However, we do record the implicit dereference involved
 // in indexing a slice.
 
-type Escape struct {
-	allLocs []*EscLocation
+type escape struct {
+	allLocs []*location
 	labels  map[*types.Sym]labelState // known labels
 
 	curfn *ir.Func
@@ -96,17 +97,17 @@ type Escape struct {
 	// unstructured loop).
 	loopDepth int
 
-	heapLoc  EscLocation
-	blankLoc EscLocation
+	heapLoc  location
+	blankLoc location
 }
 
-// An EscLocation represents an abstract location that stores a Go
+// An location represents an abstract location that stores a Go
 // variable.
-type EscLocation struct {
-	n         ir.Node   // represented variable or expression, if any
-	curfn     *ir.Func  // enclosing function
-	edges     []EscEdge // incoming edges
-	loopDepth int       // loopDepth at declaration
+type location struct {
+	n         ir.Node  // represented variable or expression, if any
+	curfn     *ir.Func // enclosing function
+	edges     []edge   // incoming edges
+	loopDepth int      // loopDepth at declaration
 
 	// derefs and walkgen are used during walkOne to track the
 	// minimal dereferences from the walk root.
@@ -116,7 +117,7 @@ type EscLocation struct {
 	// dst and dstEdgeindex track the next immediate assignment
 	// destination location during walkone, along with the index
 	// of the edge pointing back to this location.
-	dst        *EscLocation
+	dst        *location
 	dstEdgeIdx int
 
 	// queued is used by walkAll to track whether this location is
@@ -134,18 +135,18 @@ type EscLocation struct {
 	transient bool
 
 	// paramEsc records the represented parameter's leak set.
-	paramEsc EscLeaks
+	paramEsc leaks
 }
 
-// An EscEdge represents an assignment edge between two Go variables.
-type EscEdge struct {
-	src    *EscLocation
+// An edge represents an assignment edge between two Go variables.
+type edge struct {
+	src    *location
 	derefs int // >= -1
-	notes  *EscNote
+	notes  *note
 }
 
-// escFmt is called from node printing to print information about escape analysis results.
-func escFmt(n ir.Node) string {
+// Fmt is called from node printing to print information about escape analysis results.
+func Fmt(n ir.Node) string {
 	text := ""
 	switch n.Esc() {
 	case ir.EscUnknown:
@@ -164,7 +165,7 @@ func escFmt(n ir.Node) string {
 		text = fmt.Sprintf("esc(%d)", n.Esc())
 	}
 
-	if e, ok := n.Opt().(*EscLocation); ok && e.loopDepth != 0 {
+	if e, ok := n.Opt().(*location); ok && e.loopDepth != 0 {
 		if text != "" {
 			text += " "
 		}
@@ -173,16 +174,16 @@ func escFmt(n ir.Node) string {
 	return text
 }
 
-// escapeFuncs performs escape analysis on a minimal batch of
+// Batch performs escape analysis on a minimal batch of
 // functions.
-func escapeFuncs(fns []*ir.Func, recursive bool) {
+func Batch(fns []*ir.Func, recursive bool) {
 	for _, fn := range fns {
 		if fn.Op() != ir.ODCLFUNC {
 			base.Fatalf("unexpected node: %v", fn)
 		}
 	}
 
-	var e Escape
+	var e escape
 	e.heapLoc.escapes = true
 
 	// Construct data-flow graph from syntax trees.
@@ -198,11 +199,11 @@ func escapeFuncs(fns []*ir.Func, recursive bool) {
 	e.finish(fns)
 }
 
-func (e *Escape) initFunc(fn *ir.Func) {
-	if fn.Esc() != EscFuncUnknown {
+func (e *escape) initFunc(fn *ir.Func) {
+	if fn.Esc() != escFuncUnknown {
 		base.Fatalf("unexpected node: %v", fn)
 	}
-	fn.SetEsc(EscFuncPlanned)
+	fn.SetEsc(escFuncPlanned)
 	if base.Flag.LowerM > 3 {
 		ir.Dump("escAnalyze", fn)
 	}
@@ -218,8 +219,8 @@ func (e *Escape) initFunc(fn *ir.Func) {
 	}
 }
 
-func (e *Escape) walkFunc(fn *ir.Func) {
-	fn.SetEsc(EscFuncStarted)
+func (e *escape) walkFunc(fn *ir.Func) {
+	fn.SetEsc(escFuncStarted)
 
 	// Identify labels that mark the head of an unstructured loop.
 	ir.Visit(fn, func(n ir.Node) {
@@ -277,7 +278,7 @@ func (e *Escape) walkFunc(fn *ir.Func) {
 //    }
 
 // stmt evaluates a single Go statement.
-func (e *Escape) stmt(n ir.Node) {
+func (e *escape) stmt(n ir.Node) {
 	if n == nil {
 		return
 	}
@@ -368,7 +369,7 @@ func (e *Escape) stmt(n ir.Node) {
 		n := n.(*ir.SwitchStmt)
 		typesw := n.Tag != nil && n.Tag.Op() == ir.OTYPESW
 
-		var ks []EscHole
+		var ks []hole
 		for _, cas := range n.Cases { // cases
 			cas := cas.(*ir.CaseStmt)
 			if typesw && n.Tag.(*ir.TypeSwitchGuard).Tag != nil {
@@ -456,14 +457,14 @@ func (e *Escape) stmt(n ir.Node) {
 	}
 }
 
-func (e *Escape) stmts(l ir.Nodes) {
+func (e *escape) stmts(l ir.Nodes) {
 	for _, n := range l {
 		e.stmt(n)
 	}
 }
 
 // block is like stmts, but preserves loopDepth.
-func (e *Escape) block(l ir.Nodes) {
+func (e *escape) block(l ir.Nodes) {
 	old := e.loopDepth
 	e.stmts(l)
 	e.loopDepth = old
@@ -471,7 +472,7 @@ func (e *Escape) block(l ir.Nodes) {
 
 // expr models evaluating an expression n and flowing the result into
 // hole k.
-func (e *Escape) expr(k EscHole, n ir.Node) {
+func (e *escape) expr(k hole, n ir.Node) {
 	if n == nil {
 		return
 	}
@@ -479,7 +480,7 @@ func (e *Escape) expr(k EscHole, n ir.Node) {
 	e.exprSkipInit(k, n)
 }
 
-func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
+func (e *escape) exprSkipInit(k hole, n ir.Node) {
 	if n == nil {
 		return
 	}
@@ -590,7 +591,7 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 		e.discard(n.X)
 
 	case ir.OCALLMETH, ir.OCALLFUNC, ir.OCALLINTER, ir.OLEN, ir.OCAP, ir.OCOMPLEX, ir.OREAL, ir.OIMAG, ir.OAPPEND, ir.OCOPY:
-		e.call([]EscHole{k}, n, nil)
+		e.call([]hole{k}, n, nil)
 
 	case ir.ONEW:
 		n := n.(*ir.UnaryExpr)
@@ -627,7 +628,7 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 		//
 		// TODO(mdempsky): Change ks into a callback, so that
 		// we don't have to create this slice?
-		var ks []EscHole
+		var ks []hole
 		for i := m.Type.NumResults(); i > 0; i-- {
 			ks = append(ks, e.heapHole())
 		}
@@ -709,7 +710,7 @@ func (e *Escape) exprSkipInit(k EscHole, n ir.Node) {
 
 // unsafeValue evaluates a uintptr-typed arithmetic expression looking
 // for conversions from an unsafe.Pointer.
-func (e *Escape) unsafeValue(k EscHole, n ir.Node) {
+func (e *escape) unsafeValue(k hole, n ir.Node) {
 	if n.Type().Kind() != types.TUINTPTR {
 		base.Fatalf("unexpected type %v for %v", n.Type(), n)
 	}
@@ -751,11 +752,11 @@ func (e *Escape) unsafeValue(k EscHole, n ir.Node) {
 
 // discard evaluates an expression n for side-effects, but discards
 // its value.
-func (e *Escape) discard(n ir.Node) {
+func (e *escape) discard(n ir.Node) {
 	e.expr(e.discardHole(), n)
 }
 
-func (e *Escape) discards(l ir.Nodes) {
+func (e *escape) discards(l ir.Nodes) {
 	for _, n := range l {
 		e.discard(n)
 	}
@@ -763,7 +764,7 @@ func (e *Escape) discards(l ir.Nodes) {
 
 // addr evaluates an addressable expression n and returns an EscHole
 // that represents storing into the represented location.
-func (e *Escape) addr(n ir.Node) EscHole {
+func (e *escape) addr(n ir.Node) hole {
 	if n == nil || ir.IsBlank(n) {
 		// Can happen in select case, range, maybe others.
 		return e.discardHole()
@@ -809,8 +810,8 @@ func (e *Escape) addr(n ir.Node) EscHole {
 	return k
 }
 
-func (e *Escape) addrs(l ir.Nodes) []EscHole {
-	var ks []EscHole
+func (e *escape) addrs(l ir.Nodes) []hole {
+	var ks []hole
 	for _, n := range l {
 		ks = append(ks, e.addr(n))
 	}
@@ -818,7 +819,7 @@ func (e *Escape) addrs(l ir.Nodes) []EscHole {
 }
 
 // assign evaluates the assignment dst = src.
-func (e *Escape) assign(dst, src ir.Node, why string, where ir.Node) {
+func (e *escape) assign(dst, src ir.Node, why string, where ir.Node) {
 	// Filter out some no-op assignments for escape analysis.
 	ignore := dst != nil && src != nil && isSelfAssign(dst, src)
 	if ignore && base.Flag.LowerM != 0 {
@@ -836,14 +837,14 @@ func (e *Escape) assign(dst, src ir.Node, why string, where ir.Node) {
 	}
 }
 
-func (e *Escape) assignHeap(src ir.Node, why string, where ir.Node) {
+func (e *escape) assignHeap(src ir.Node, why string, where ir.Node) {
 	e.expr(e.heapHole().note(where, why), src)
 }
 
 // call evaluates a call expressions, including builtin calls. ks
 // should contain the holes representing where the function callee's
 // results flows; where is the OGO/ODEFER context of the call, if any.
-func (e *Escape) call(ks []EscHole, call, where ir.Node) {
+func (e *escape) call(ks []hole, call, where ir.Node) {
 	topLevelDefer := where != nil && where.Op() == ir.ODEFER && e.loopDepth == 1
 	if topLevelDefer {
 		// force stack allocation of defer record, unless
@@ -851,7 +852,7 @@ func (e *Escape) call(ks []EscHole, call, where ir.Node) {
 		where.SetEsc(ir.EscNever)
 	}
 
-	argument := func(k EscHole, arg ir.Node) {
+	argument := func(k hole, arg ir.Node) {
 		if topLevelDefer {
 			// Top level defers arguments don't escape to
 			// heap, but they do need to last until end of
@@ -969,7 +970,7 @@ func (e *Escape) call(ks []EscHole, call, where ir.Node) {
 // ks should contain the holes representing where the function
 // callee's results flows. fn is the statically-known callee function,
 // if any.
-func (e *Escape) tagHole(ks []EscHole, fn *ir.Name, param *types.Field) EscHole {
+func (e *escape) tagHole(ks []hole, fn *ir.Name, param *types.Field) hole {
 	// If this is a dynamic call, we can't rely on param.Note.
 	if fn == nil {
 		return e.heapHole()
@@ -981,15 +982,15 @@ func (e *Escape) tagHole(ks []EscHole, fn *ir.Name, param *types.Field) EscHole
 
 	// Call to previously tagged function.
 
-	if param.Note == uintptrEscapesTag {
+	if param.Note == UintptrEscapesNote {
 		k := e.heapHole()
 		k.uintptrEscapesHack = true
 		return k
 	}
 
-	var tagKs []EscHole
+	var tagKs []hole
 
-	esc := ParseLeaks(param.Note)
+	esc := parseLeaks(param.Note)
 	if x := esc.Heap(); x >= 0 {
 		tagKs = append(tagKs, e.heapHole().shift(x))
 	}
@@ -1010,9 +1011,9 @@ func (e *Escape) tagHole(ks []EscHole, fn *ir.Name, param *types.Field) EscHole
 // fn has not yet been analyzed, so its parameters and results
 // should be incorporated directly into the flow graph instead of
 // relying on its escape analysis tagging.
-func (e *Escape) inMutualBatch(fn *ir.Name) bool {
-	if fn.Defn != nil && fn.Defn.Esc() < EscFuncTagged {
-		if fn.Defn.Esc() == EscFuncUnknown {
+func (e *escape) inMutualBatch(fn *ir.Name) bool {
+	if fn.Defn != nil && fn.Defn.Esc() < escFuncTagged {
+		if fn.Defn.Esc() == escFuncUnknown {
 			base.Fatalf("graph inconsistency")
 		}
 		return true
@@ -1020,31 +1021,31 @@ func (e *Escape) inMutualBatch(fn *ir.Name) bool {
 	return false
 }
 
-// An EscHole represents a context for evaluation a Go
+// An hole represents a context for evaluation a Go
 // expression. E.g., when evaluating p in "x = **p", we'd have a hole
 // with dst==x and derefs==2.
-type EscHole struct {
-	dst    *EscLocation
+type hole struct {
+	dst    *location
 	derefs int // >= -1
-	notes  *EscNote
+	notes  *note
 
 	// uintptrEscapesHack indicates this context is evaluating an
 	// argument for a //go:uintptrescapes function.
 	uintptrEscapesHack bool
 }
 
-type EscNote struct {
-	next  *EscNote
+type note struct {
+	next  *note
 	where ir.Node
 	why   string
 }
 
-func (k EscHole) note(where ir.Node, why string) EscHole {
+func (k hole) note(where ir.Node, why string) hole {
 	if where == nil || why == "" {
 		base.Fatalf("note: missing where/why")
 	}
 	if base.Flag.LowerM >= 2 || logopt.Enabled() {
-		k.notes = &EscNote{
+		k.notes = &note{
 			next:  k.notes,
 			where: where,
 			why:   why,
@@ -1053,7 +1054,7 @@ func (k EscHole) note(where ir.Node, why string) EscHole {
 	return k
 }
 
-func (k EscHole) shift(delta int) EscHole {
+func (k hole) shift(delta int) hole {
 	k.derefs += delta
 	if k.derefs < -1 {
 		base.Fatalf("derefs underflow: %v", k.derefs)
@@ -1061,10 +1062,10 @@ func (k EscHole) shift(delta int) EscHole {
 	return k
 }
 
-func (k EscHole) deref(where ir.Node, why string) EscHole { return k.shift(1).note(where, why) }
-func (k EscHole) addr(where ir.Node, why string) EscHole  { return k.shift(-1).note(where, why) }
+func (k hole) deref(where ir.Node, why string) hole { return k.shift(1).note(where, why) }
+func (k hole) addr(where ir.Node, why string) hole  { return k.shift(-1).note(where, why) }
 
-func (k EscHole) dotType(t *types.Type, where ir.Node, why string) EscHole {
+func (k hole) dotType(t *types.Type, where ir.Node, why string) hole {
 	if !t.IsInterface() && !types.IsDirectIface(t) {
 		k = k.shift(1)
 	}
@@ -1073,7 +1074,7 @@ func (k EscHole) dotType(t *types.Type, where ir.Node, why string) EscHole {
 
 // teeHole returns a new hole that flows into each hole of ks,
 // similar to the Unix tee(1) command.
-func (e *Escape) teeHole(ks ...EscHole) EscHole {
+func (e *escape) teeHole(ks ...hole) hole {
 	if len(ks) == 0 {
 		return e.discardHole()
 	}
@@ -1101,7 +1102,7 @@ func (e *Escape) teeHole(ks ...EscHole) EscHole {
 	return loc.asHole()
 }
 
-func (e *Escape) dcl(n ir.Node) EscHole {
+func (e *escape) dcl(n ir.Node) hole {
 	loc := e.oldLoc(n)
 	loc.loopDepth = e.loopDepth
 	return loc.asHole()
@@ -1110,7 +1111,7 @@ func (e *Escape) dcl(n ir.Node) EscHole {
 // spill allocates a new location associated with expression n, flows
 // its address to k, and returns a hole that flows values to it. It's
 // intended for use with most expressions that allocate storage.
-func (e *Escape) spill(k EscHole, n ir.Node) EscHole {
+func (e *escape) spill(k hole, n ir.Node) hole {
 	loc := e.newLoc(n, true)
 	e.flow(k.addr(n, "spill"), loc)
 	return loc.asHole()
@@ -1119,7 +1120,7 @@ func (e *Escape) spill(k EscHole, n ir.Node) EscHole {
 // later returns a new hole that flows into k, but some time later.
 // Its main effect is to prevent immediate reuse of temporary
 // variables introduced during Order.
-func (e *Escape) later(k EscHole) EscHole {
+func (e *escape) later(k hole) hole {
 	loc := e.newLoc(nil, false)
 	e.flow(k, loc)
 	return loc.asHole()
@@ -1138,7 +1139,7 @@ func canonicalNode(n ir.Node) ir.Node {
 	return n
 }
 
-func (e *Escape) newLoc(n ir.Node, transient bool) *EscLocation {
+func (e *escape) newLoc(n ir.Node, transient bool) *location {
 	if e.curfn == nil {
 		base.Fatalf("e.curfn isn't set")
 	}
@@ -1147,7 +1148,7 @@ func (e *Escape) newLoc(n ir.Node, transient bool) *EscLocation {
 	}
 
 	n = canonicalNode(n)
-	loc := &EscLocation{
+	loc := &location{
 		n:         n,
 		curfn:     e.curfn,
 		loopDepth: e.loopDepth,
@@ -1165,23 +1166,23 @@ func (e *Escape) newLoc(n ir.Node, transient bool) *EscLocation {
 		}
 		n.SetOpt(loc)
 
-		if why := heapAllocReason(n); why != "" {
+		if why := HeapAllocReason(n); why != "" {
 			e.flow(e.heapHole().addr(n, why), loc)
 		}
 	}
 	return loc
 }
 
-func (e *Escape) oldLoc(n ir.Node) *EscLocation {
+func (e *escape) oldLoc(n ir.Node) *location {
 	n = canonicalNode(n)
-	return n.Opt().(*EscLocation)
+	return n.Opt().(*location)
 }
 
-func (l *EscLocation) asHole() EscHole {
-	return EscHole{dst: l}
+func (l *location) asHole() hole {
+	return hole{dst: l}
 }
 
-func (e *Escape) flow(k EscHole, src *EscLocation) {
+func (e *escape) flow(k hole, src *location) {
 	dst := k.dst
 	if dst == &e.blankLoc {
 		return
@@ -1206,15 +1207,15 @@ func (e *Escape) flow(k EscHole, src *EscLocation) {
 	}
 
 	// TODO(mdempsky): Deduplicate edges?
-	dst.edges = append(dst.edges, EscEdge{src: src, derefs: k.derefs, notes: k.notes})
+	dst.edges = append(dst.edges, edge{src: src, derefs: k.derefs, notes: k.notes})
 }
 
-func (e *Escape) heapHole() EscHole    { return e.heapLoc.asHole() }
-func (e *Escape) discardHole() EscHole { return e.blankLoc.asHole() }
+func (e *escape) heapHole() hole    { return e.heapLoc.asHole() }
+func (e *escape) discardHole() hole { return e.blankLoc.asHole() }
 
 // walkAll computes the minimal dereferences between all pairs of
 // locations.
-func (e *Escape) walkAll() {
+func (e *escape) walkAll() {
 	// We use a work queue to keep track of locations that we need
 	// to visit, and repeatedly walk until we reach a fixed point.
 	//
@@ -1224,8 +1225,8 @@ func (e *Escape) walkAll() {
 	// happen at most once. So we take Θ(len(e.allLocs)) walks.
 
 	// LIFO queue, has enough room for e.allLocs and e.heapLoc.
-	todo := make([]*EscLocation, 0, len(e.allLocs)+1)
-	enqueue := func(loc *EscLocation) {
+	todo := make([]*location, 0, len(e.allLocs)+1)
+	enqueue := func(loc *location) {
 		if !loc.queued {
 			todo = append(todo, loc)
 			loc.queued = true
@@ -1250,7 +1251,7 @@ func (e *Escape) walkAll() {
 
 // walkOne computes the minimal number of dereferences from root to
 // all other locations.
-func (e *Escape) walkOne(root *EscLocation, walkgen uint32, enqueue func(*EscLocation)) {
+func (e *escape) walkOne(root *location, walkgen uint32, enqueue func(*location)) {
 	// The data flow graph has negative edges (from addressing
 	// operations), so we use the Bellman-Ford algorithm. However,
 	// we don't have to worry about infinite negative cycles since
@@ -1260,7 +1261,7 @@ func (e *Escape) walkOne(root *EscLocation, walkgen uint32, enqueue func(*EscLoc
 	root.derefs = 0
 	root.dst = nil
 
-	todo := []*EscLocation{root} // LIFO queue
+	todo := []*location{root} // LIFO queue
 	for len(todo) > 0 {
 		l := todo[len(todo)-1]
 		todo = todo[:len(todo)-1]
@@ -1341,8 +1342,8 @@ func (e *Escape) walkOne(root *EscLocation, walkgen uint32, enqueue func(*EscLoc
 }
 
 // explainPath prints an explanation of how src flows to the walk root.
-func (e *Escape) explainPath(root, src *EscLocation) []*logopt.LoggedOpt {
-	visited := make(map[*EscLocation]bool)
+func (e *escape) explainPath(root, src *location) []*logopt.LoggedOpt {
+	visited := make(map[*location]bool)
 	pos := base.FmtPos(src.n.Pos())
 	var explanation []*logopt.LoggedOpt
 	for {
@@ -1371,7 +1372,7 @@ func (e *Escape) explainPath(root, src *EscLocation) []*logopt.LoggedOpt {
 	return explanation
 }
 
-func (e *Escape) explainFlow(pos string, dst, srcloc *EscLocation, derefs int, notes *EscNote, explanation []*logopt.LoggedOpt) []*logopt.LoggedOpt {
+func (e *escape) explainFlow(pos string, dst, srcloc *location, derefs int, notes *note, explanation []*logopt.LoggedOpt) []*logopt.LoggedOpt {
 	ops := "&"
 	if derefs >= 0 {
 		ops = strings.Repeat("*", derefs)
@@ -1404,7 +1405,7 @@ func (e *Escape) explainFlow(pos string, dst, srcloc *EscLocation, derefs int, n
 	return explanation
 }
 
-func (e *Escape) explainLoc(l *EscLocation) string {
+func (e *escape) explainLoc(l *location) string {
 	if l == &e.heapLoc {
 		return "{heap}"
 	}
@@ -1420,7 +1421,7 @@ func (e *Escape) explainLoc(l *EscLocation) string {
 
 // outlives reports whether values stored in l may survive beyond
 // other's lifetime if stack allocated.
-func (e *Escape) outlives(l, other *EscLocation) bool {
+func (e *escape) outlives(l, other *location) bool {
 	// The heap outlives everything.
 	if l.escapes {
 		return true
@@ -1484,7 +1485,7 @@ func containsClosure(f, c *ir.Func) bool {
 }
 
 // leak records that parameter l leaks to sink.
-func (l *EscLocation) leakTo(sink *EscLocation, derefs int) {
+func (l *location) leakTo(sink *location, derefs int) {
 	// If sink is a result parameter and we can fit return bits
 	// into the escape analysis tag, then record a return leak.
 	if sink.isName(ir.PPARAMOUT) && sink.curfn == l.curfn {
@@ -1501,10 +1502,10 @@ func (l *EscLocation) leakTo(sink *EscLocation, derefs int) {
 	l.paramEsc.AddHeap(derefs)
 }
 
-func (e *Escape) finish(fns []*ir.Func) {
+func (e *escape) finish(fns []*ir.Func) {
 	// Record parameter tags for package export data.
 	for _, fn := range fns {
-		fn.SetEsc(EscFuncTagged)
+		fn.SetEsc(escFuncTagged)
 
 		narg := 0
 		for _, fs := range &types.RecvsParams {
@@ -1557,47 +1558,47 @@ func (e *Escape) finish(fns []*ir.Func) {
 	}
 }
 
-func (l *EscLocation) isName(c ir.Class) bool {
+func (l *location) isName(c ir.Class) bool {
 	return l.n != nil && l.n.Op() == ir.ONAME && l.n.(*ir.Name).Class_ == c
 }
 
 const numEscResults = 7
 
-// An EscLeaks represents a set of assignment flows from a parameter
+// An leaks represents a set of assignment flows from a parameter
 // to the heap or to any of its function's (first numEscResults)
 // result parameters.
-type EscLeaks [1 + numEscResults]uint8
+type leaks [1 + numEscResults]uint8
 
 // Empty reports whether l is an empty set (i.e., no assignment flows).
-func (l EscLeaks) Empty() bool { return l == EscLeaks{} }
+func (l leaks) Empty() bool { return l == leaks{} }
 
 // Heap returns the minimum deref count of any assignment flow from l
 // to the heap. If no such flows exist, Heap returns -1.
-func (l EscLeaks) Heap() int { return l.get(0) }
+func (l leaks) Heap() int { return l.get(0) }
 
 // Result returns the minimum deref count of any assignment flow from
 // l to its function's i'th result parameter. If no such flows exist,
 // Result returns -1.
-func (l EscLeaks) Result(i int) int { return l.get(1 + i) }
+func (l leaks) Result(i int) int { return l.get(1 + i) }
 
 // AddHeap adds an assignment flow from l to the heap.
-func (l *EscLeaks) AddHeap(derefs int) { l.add(0, derefs) }
+func (l *leaks) AddHeap(derefs int) { l.add(0, derefs) }
 
 // AddResult adds an assignment flow from l to its function's i'th
 // result parameter.
-func (l *EscLeaks) AddResult(i, derefs int) { l.add(1+i, derefs) }
+func (l *leaks) AddResult(i, derefs int) { l.add(1+i, derefs) }
 
-func (l *EscLeaks) setResult(i, derefs int) { l.set(1+i, derefs) }
+func (l *leaks) setResult(i, derefs int) { l.set(1+i, derefs) }
 
-func (l EscLeaks) get(i int) int { return int(l[i]) - 1 }
+func (l leaks) get(i int) int { return int(l[i]) - 1 }
 
-func (l *EscLeaks) add(i, derefs int) {
+func (l *leaks) add(i, derefs int) {
 	if old := l.get(i); old < 0 || derefs < old {
 		l.set(i, derefs)
 	}
 }
 
-func (l *EscLeaks) set(i, derefs int) {
+func (l *leaks) set(i, derefs int) {
 	v := derefs + 1
 	if v < 0 {
 		base.Fatalf("invalid derefs count: %v", derefs)
@@ -1611,7 +1612,7 @@ func (l *EscLeaks) set(i, derefs int) {
 
 // Optimize removes result flow paths that are equal in length or
 // longer than the shortest heap flow path.
-func (l *EscLeaks) Optimize() {
+func (l *leaks) Optimize() {
 	// If we have a path to the heap, then there's no use in
 	// keeping equal or longer paths elsewhere.
 	if x := l.Heap(); x >= 0 {
@@ -1623,10 +1624,10 @@ func (l *EscLeaks) Optimize() {
 	}
 }
 
-var leakTagCache = map[EscLeaks]string{}
+var leakTagCache = map[leaks]string{}
 
 // Encode converts l into a binary string for export data.
-func (l EscLeaks) Encode() string {
+func (l leaks) Encode() string {
 	if l.Heap() == 0 {
 		// Space optimization: empty string encodes more
 		// efficiently in export data.
@@ -1645,9 +1646,9 @@ func (l EscLeaks) Encode() string {
 	return s
 }
 
-// ParseLeaks parses a binary string representing an EscLeaks.
-func ParseLeaks(s string) EscLeaks {
-	var l EscLeaks
+// parseLeaks parses a binary string representing an EscLeaks.
+func parseLeaks(s string) leaks {
+	var l leaks
 	if !strings.HasPrefix(s, "esc:") {
 		l.AddHeap(0)
 		return l
@@ -1656,31 +1657,17 @@ func ParseLeaks(s string) EscLeaks {
 	return l
 }
 
-func escapes(all []ir.Node) {
-	ir.VisitFuncsBottomUp(all, escapeFuncs)
+func Funcs(all []ir.Node) {
+	ir.VisitFuncsBottomUp(all, Batch)
 }
 
 const (
-	EscFuncUnknown = 0 + iota
-	EscFuncPlanned
-	EscFuncStarted
-	EscFuncTagged
+	escFuncUnknown = 0 + iota
+	escFuncPlanned
+	escFuncStarted
+	escFuncTagged
 )
 
-func min8(a, b int8) int8 {
-	if a < b {
-		return a
-	}
-	return b
-}
-
-func max8(a, b int8) int8 {
-	if a > b {
-		return a
-	}
-	return b
-}
-
 // funcSym returns fn.Nname.Sym if no nils are encountered along the way.
 func funcSym(fn *ir.Func) *types.Sym {
 	if fn == nil || fn.Nname == nil {
@@ -1855,9 +1842,9 @@ func mayAffectMemory(n ir.Node) bool {
 	}
 }
 
-// heapAllocReason returns the reason the given Node must be heap
+// HeapAllocReason returns the reason the given Node must be heap
 // allocated, or the empty string if it doesn't.
-func heapAllocReason(n ir.Node) string {
+func HeapAllocReason(n ir.Node) string {
 	if n.Type() == nil {
 		return ""
 	}
@@ -2064,13 +2051,13 @@ func moveToHeap(n *ir.Name) {
 // This special tag is applied to uintptr variables
 // that we believe may hold unsafe.Pointers for
 // calls into assembly functions.
-const unsafeUintptrTag = "unsafe-uintptr"
+const UnsafeUintptrNote = "unsafe-uintptr"
 
 // This special tag is applied to uintptr parameters of functions
 // marked go:uintptrescapes.
-const uintptrEscapesTag = "uintptr-escapes"
+const UintptrEscapesNote = "uintptr-escapes"
 
-func (e *Escape) paramTag(fn *ir.Func, narg int, f *types.Field) string {
+func (e *escape) paramTag(fn *ir.Func, narg int, f *types.Field) string {
 	name := func() string {
 		if f.Sym != nil {
 			return f.Sym.Name
@@ -2089,14 +2076,14 @@ func (e *Escape) paramTag(fn *ir.Func, narg int, f *types.Field) string {
 			if base.Flag.LowerM != 0 {
 				base.WarnfAt(f.Pos, "assuming %v is unsafe uintptr", name())
 			}
-			return unsafeUintptrTag
+			return UnsafeUintptrNote
 		}
 
 		if !f.Type.HasPointers() { // don't bother tagging for scalars
 			return ""
 		}
 
-		var esc EscLeaks
+		var esc leaks
 
 		// External functions are assumed unsafe, unless
 		// //go:noescape is given before the declaration.
@@ -2119,14 +2106,14 @@ func (e *Escape) paramTag(fn *ir.Func, narg int, f *types.Field) string {
 			if base.Flag.LowerM != 0 {
 				base.WarnfAt(f.Pos, "marking %v as escaping uintptr", name())
 			}
-			return uintptrEscapesTag
+			return UintptrEscapesNote
 		}
 		if f.IsDDD() && f.Type.Elem().IsUintptr() {
 			// final argument is ...uintptr.
 			if base.Flag.LowerM != 0 {
 				base.WarnfAt(f.Pos, "marking %v as escaping ...uintptr", name())
 			}
-			return uintptrEscapesTag
+			return UintptrEscapesNote
 		}
 	}
 
@@ -2136,7 +2123,7 @@ func (e *Escape) paramTag(fn *ir.Func, narg int, f *types.Field) string {
 
 	// Unnamed parameters are unused and therefore do not escape.
 	if f.Sym == nil || f.Sym.IsBlank() {
-		var esc EscLeaks
+		var esc leaks
 		return esc.Encode()
 	}
 
diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go
index f746a358ca..81f7956d2e 100644
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ b/src/cmd/compile/internal/gc/gsubr.go
@@ -32,6 +32,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/escape"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
@@ -141,7 +142,7 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 	ir.CurFunc = fn
 	typecheck.Stmts(fn.Body)
 
-	escapeFuncs([]*ir.Func{fn}, false)
+	escape.Batch([]*ir.Func{fn}, false)
 
 	typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
 
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 7f20d6b8a5..cda00fb9ae 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -10,6 +10,7 @@ import (
 	"bufio"
 	"bytes"
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/escape"
 	"cmd/compile/internal/inline"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
@@ -183,7 +184,7 @@ func Main(archInit func(*Arch)) {
 		logopt.LogJsonOption(base.Flag.JSON)
 	}
 
-	ir.EscFmt = escFmt
+	ir.EscFmt = escape.Fmt
 	ir.IsIntrinsicCall = isIntrinsicCall
 	inline.SSADumpInline = ssaDumpInline
 	initSSAEnv()
@@ -252,7 +253,7 @@ func Main(archInit func(*Arch)) {
 	// Large values are also moved off stack in escape analysis;
 	// because large values may contain pointers, it must happen early.
 	base.Timer.Start("fe", "escapes")
-	escapes(typecheck.Target.Decls)
+	escape.Funcs(typecheck.Target.Decls)
 
 	// Collect information for go:nowritebarrierrec
 	// checking. This must happen before transformclosure.
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 075bcea92c..32a355ae6b 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/escape"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
@@ -521,7 +522,7 @@ func (o *Order) call(nn ir.Node) {
 
 	// Check for "unsafe-uintptr" tag provided by escape analysis.
 	for i, param := range n.X.Type().Params().FieldSlice() {
-		if param.Note == unsafeUintptrTag || param.Note == uintptrEscapesTag {
+		if param.Note == escape.UnsafeUintptrNote || param.Note == escape.UintptrEscapesNote {
 			if arg := n.Args[i]; arg.Op() == ir.OSLICELIT {
 				arg := arg.(*ir.CompLitExpr)
 				for _, elt := range arg.List {
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 5c36e922a6..feb2d0de8f 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -7396,3 +7396,17 @@ func callTargetLSym(callee *types.Sym, callerLSym *obj.LSym) *obj.LSym {
 	}
 	return lsym
 }
+
+func min8(a, b int8) int8 {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func max8(a, b int8) int8 {
+	if a > b {
+		return a
+	}
+	return b
+}
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index f76fb8e24a..cba9bdc253 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/escape"
 	"cmd/compile/internal/inline"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/typecheck"
@@ -484,7 +485,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 	if rcvr.IsPtr() && rcvr.Elem() == method.Type.Recv().Type && rcvr.Elem().Sym() != nil {
 		inline.InlineCalls(fn)
 	}
-	escapeFuncs([]*ir.Func{fn}, false)
+	escape.Batch([]*ir.Func{fn}, false)
 
 	ir.CurFunc = nil
 	typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 73f82f333c..9e4de7f804 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -6,6 +6,7 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/escape"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
@@ -1455,7 +1456,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", t.Elem())
 		}
 		if n.Esc() == ir.EscNone {
-			if why := heapAllocReason(n); why != "" {
+			if why := escape.HeapAllocReason(n); why != "" {
 				base.Fatalf("%v has EscNone, but %v", n, why)
 			}
 			// var arr [r]T
-- 
GitLab


From fbc82f03b104ba9bde67ad202e9cb00a13842dca Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 23 Dec 2020 00:52:53 -0500
Subject: [PATCH 0311/2400] [dev.regabi] cmd/compile: split out package noder
 [generated]

[git-generate]
cd src/cmd/compile/internal/gc

rf '
	mv ArhdrSize HeaderSize
	mv arsize ReadHeader
	mv formathdr FormatHeader
	mv HeaderSize ReadHeader FormatHeader archive.go
	mv archive.go cmd/internal/archive

	mv makePos main.go

	mv checkDotImports CheckDotImports
	mv parseFiles ParseFiles

	mv Pragma pragmas
	mv PragmaEmbed pragmaEmbed
	mv PragmaPos pragmaPos
	mv FuncPragmas funcPragmas
	mv TypePragmas typePragmas

	mv fakeRecv noder.funcLit renameinitgen renameinit oldname varEmbed noder.go
	mv isDriveLetter islocalname findpkg myheight importfile \
		reservedimports isbadimport \
		pkgnotused \
		mkpackage clearImports \
		CheckDotImports dotImports importDot \
		importName \
		import.go

	mv noder _noder
	mv import.go lex.go lex_test.go noder.go cmd/compile/internal/noder
'
cd ../noder
rf '
	mv _noder noder
'

Change-Id: Iac2b856f7b86143c666d818e4b7c5b261cf387d5
Reviewed-on: https://go-review.googlesource.com/c/go/+/279473
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/closure.go        |  60 ---
 src/cmd/compile/internal/gc/dcl.go            |  64 ---
 src/cmd/compile/internal/gc/embed.go          |  53 --
 src/cmd/compile/internal/gc/init.go           |  12 -
 src/cmd/compile/internal/gc/main.go           | 380 +-------------
 src/cmd/compile/internal/gc/obj.go            |  16 +-
 src/cmd/compile/internal/gc/subr.go           | 105 ----
 src/cmd/compile/internal/noder/import.go      | 493 ++++++++++++++++++
 src/cmd/compile/internal/{gc => noder}/lex.go |  17 +-
 .../internal/{gc => noder}/lex_test.go        |   5 +-
 .../compile/internal/{gc => noder}/noder.go   | 225 +++++++-
 src/cmd/internal/archive/archive.go           |  21 +
 12 files changed, 735 insertions(+), 716 deletions(-)
 create mode 100644 src/cmd/compile/internal/noder/import.go
 rename src/cmd/compile/internal/{gc => noder}/lex.go (95%)
 rename src/cmd/compile/internal/{gc => noder}/lex_test.go (99%)
 rename src/cmd/compile/internal/{gc => noder}/noder.go (87%)

diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index 29455bffd8..4679b6535b 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -7,71 +7,11 @@ package gc
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
-	"cmd/compile/internal/syntax"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 )
 
-func (p *noder) funcLit(expr *syntax.FuncLit) ir.Node {
-	xtype := p.typeExpr(expr.Type)
-	ntype := p.typeExpr(expr.Type)
-
-	fn := ir.NewFunc(p.pos(expr))
-	fn.SetIsHiddenClosure(ir.CurFunc != nil)
-	fn.Nname = ir.NewFuncNameAt(p.pos(expr), ir.BlankNode.Sym(), fn) // filled in by typecheckclosure
-	fn.Nname.Ntype = xtype
-	fn.Nname.Defn = fn
-
-	clo := ir.NewClosureExpr(p.pos(expr), fn)
-	fn.ClosureType = ntype
-	fn.OClosure = clo
-
-	p.funcBody(fn, expr.Body)
-
-	// closure-specific variables are hanging off the
-	// ordinary ones in the symbol table; see oldname.
-	// unhook them.
-	// make the list of pointers for the closure call.
-	for _, v := range fn.ClosureVars {
-		// Unlink from v1; see comment in syntax.go type Param for these fields.
-		v1 := v.Defn
-		v1.Name().Innermost = v.Outer
-
-		// If the closure usage of v is not dense,
-		// we need to make it dense; now that we're out
-		// of the function in which v appeared,
-		// look up v.Sym in the enclosing function
-		// and keep it around for use in the compiled code.
-		//
-		// That is, suppose we just finished parsing the innermost
-		// closure f4 in this code:
-		//
-		//	func f() {
-		//		v := 1
-		//		func() { // f2
-		//			use(v)
-		//			func() { // f3
-		//				func() { // f4
-		//					use(v)
-		//				}()
-		//			}()
-		//		}()
-		//	}
-		//
-		// At this point v.Outer is f2's v; there is no f3's v.
-		// To construct the closure f4 from within f3,
-		// we need to use f3's v and in this case we need to create f3's v.
-		// We are now in the context of f3, so calling oldname(v.Sym)
-		// obtains f3's v, creating it if necessary (as it is in the example).
-		//
-		// capturevars will decide whether to use v directly or &v.
-		v.Outer = oldname(v.Sym()).(*ir.Name)
-	}
-
-	return clo
-}
-
 // transformclosure is called in a separate phase after escape analysis.
 // It transform closure bodies to properly reference captured variables.
 func transformclosure(fn *ir.Func) {
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index e53bba44ad..aaf5b35057 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -28,70 +28,6 @@ func NoWriteBarrierRecCheck() {
 
 var nowritebarrierrecCheck *nowritebarrierrecChecker
 
-// oldname returns the Node that declares symbol s in the current scope.
-// If no such Node currently exists, an ONONAME Node is returned instead.
-// Automatically creates a new closure variable if the referenced symbol was
-// declared in a different (containing) function.
-func oldname(s *types.Sym) ir.Node {
-	if s.Pkg != types.LocalPkg {
-		return ir.NewIdent(base.Pos, s)
-	}
-
-	n := ir.AsNode(s.Def)
-	if n == nil {
-		// Maybe a top-level declaration will come along later to
-		// define s. resolve will check s.Def again once all input
-		// source has been processed.
-		return ir.NewIdent(base.Pos, s)
-	}
-
-	if ir.CurFunc != nil && n.Op() == ir.ONAME && n.Name().Curfn != nil && n.Name().Curfn != ir.CurFunc {
-		// Inner func is referring to var in outer func.
-		//
-		// TODO(rsc): If there is an outer variable x and we
-		// are parsing x := 5 inside the closure, until we get to
-		// the := it looks like a reference to the outer x so we'll
-		// make x a closure variable unnecessarily.
-		n := n.(*ir.Name)
-		c := n.Name().Innermost
-		if c == nil || c.Curfn != ir.CurFunc {
-			// Do not have a closure var for the active closure yet; make one.
-			c = typecheck.NewName(s)
-			c.Class_ = ir.PAUTOHEAP
-			c.SetIsClosureVar(true)
-			c.SetIsDDD(n.IsDDD())
-			c.Defn = n
-
-			// Link into list of active closure variables.
-			// Popped from list in func funcLit.
-			c.Outer = n.Name().Innermost
-			n.Name().Innermost = c
-
-			ir.CurFunc.ClosureVars = append(ir.CurFunc.ClosureVars, c)
-		}
-
-		// return ref to closure var, not original
-		return c
-	}
-
-	return n
-}
-
-// importName is like oldname,
-// but it reports an error if sym is from another package and not exported.
-func importName(sym *types.Sym) ir.Node {
-	n := oldname(sym)
-	if !types.IsExported(sym.Name) && sym.Pkg != types.LocalPkg {
-		n.SetDiag(true)
-		base.Errorf("cannot refer to unexported name %s.%s", sym.Pkg.Name, sym.Name)
-	}
-	return n
-}
-
-func fakeRecv() *ir.Field {
-	return ir.NewField(base.Pos, nil, nil, types.FakeRecvType())
-}
-
 // funcsym returns s·f.
 func funcsym(s *types.Sym) *types.Sym {
 	// funcsymsmu here serves to protect not just mutations of funcsyms (below),
diff --git a/src/cmd/compile/internal/gc/embed.go b/src/cmd/compile/internal/gc/embed.go
index 282e718b29..959d8cd7fe 100644
--- a/src/cmd/compile/internal/gc/embed.go
+++ b/src/cmd/compile/internal/gc/embed.go
@@ -8,14 +8,12 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/objw"
-	"cmd/compile/internal/syntax"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 
 	"path"
 	"sort"
-	"strconv"
 	"strings"
 )
 
@@ -26,57 +24,6 @@ const (
 	embedFiles
 )
 
-func varEmbed(p *noder, names []*ir.Name, typ ir.Ntype, exprs []ir.Node, embeds []PragmaEmbed) (newExprs []ir.Node) {
-	haveEmbed := false
-	for _, decl := range p.file.DeclList {
-		imp, ok := decl.(*syntax.ImportDecl)
-		if !ok {
-			// imports always come first
-			break
-		}
-		path, _ := strconv.Unquote(imp.Path.Value)
-		if path == "embed" {
-			haveEmbed = true
-			break
-		}
-	}
-
-	pos := embeds[0].Pos
-	if !haveEmbed {
-		p.errorAt(pos, "invalid go:embed: missing import \"embed\"")
-		return exprs
-	}
-	if base.Flag.Cfg.Embed.Patterns == nil {
-		p.errorAt(pos, "invalid go:embed: build system did not supply embed configuration")
-		return exprs
-	}
-	if len(names) > 1 {
-		p.errorAt(pos, "go:embed cannot apply to multiple vars")
-		return exprs
-	}
-	if len(exprs) > 0 {
-		p.errorAt(pos, "go:embed cannot apply to var with initializer")
-		return exprs
-	}
-	if typ == nil {
-		// Should not happen, since len(exprs) == 0 now.
-		p.errorAt(pos, "go:embed cannot apply to var without type")
-		return exprs
-	}
-	if typecheck.DeclContext != ir.PEXTERN {
-		p.errorAt(pos, "go:embed cannot apply to var inside func")
-		return exprs
-	}
-
-	v := names[0]
-	typecheck.Target.Embeds = append(typecheck.Target.Embeds, v)
-	v.Embed = new([]ir.Embed)
-	for _, e := range embeds {
-		*v.Embed = append(*v.Embed, ir.Embed{Pos: p.makeXPos(e.Pos), Patterns: e.Patterns})
-	}
-	return exprs
-}
-
 func embedFileList(v *ir.Name) []string {
 	kind := embedKind(v.Type())
 	if kind == embedUnknown {
diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index da3f40f4e8..a299b8688b 100644
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -13,18 +13,6 @@ import (
 	"cmd/internal/obj"
 )
 
-// A function named init is a special case.
-// It is called by the initialization before main is run.
-// To make it unique within a package and also uncallable,
-// the name, normally "pkg.init", is altered to "pkg.init.0".
-var renameinitgen int
-
-func renameinit() *types.Sym {
-	s := typecheck.LookupNum("init.", renameinitgen)
-	renameinitgen++
-	return s
-}
-
 // fninit makes and returns an initialization record for the package.
 // See runtime/proc.go:initTask for its layout.
 // The 3 tasks for initialization are:
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index cda00fb9ae..7b540d8675 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -14,26 +14,21 @@ import (
 	"cmd/compile/internal/inline"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
+	"cmd/compile/internal/noder"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
-	"cmd/internal/bio"
 	"cmd/internal/dwarf"
-	"cmd/internal/goobj"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
 	"cmd/internal/src"
 	"flag"
 	"fmt"
-	"go/constant"
-	"io"
 	"io/ioutil"
 	"log"
 	"os"
-	"path"
 	"runtime"
 	"sort"
-	"strconv"
 	"strings"
 )
 
@@ -212,7 +207,7 @@ func Main(archInit func(*Arch)) {
 
 	// Parse input.
 	base.Timer.Start("fe", "parse")
-	lines := parseFiles(flag.Args())
+	lines := noder.ParseFiles(flag.Args())
 	cgoSymABIs()
 	base.Timer.Stop()
 	base.Timer.AddEvent(int64(lines), "lines")
@@ -222,7 +217,7 @@ func Main(archInit func(*Arch)) {
 	typecheck.Package()
 
 	// With all user code typechecked, it's now safe to verify unused dot imports.
-	checkDotImports()
+	noder.CheckDotImports()
 	base.ExitIfErrors()
 
 	// Build init task.
@@ -468,371 +463,6 @@ func readSymABIs(file, myimportpath string) {
 	}
 }
 
-func arsize(b *bufio.Reader, name string) int {
-	var buf [ArhdrSize]byte
-	if _, err := io.ReadFull(b, buf[:]); err != nil {
-		return -1
-	}
-	aname := strings.Trim(string(buf[0:16]), " ")
-	if !strings.HasPrefix(aname, name) {
-		return -1
-	}
-	asize := strings.Trim(string(buf[48:58]), " ")
-	i, _ := strconv.Atoi(asize)
-	return i
-}
-
-func isDriveLetter(b byte) bool {
-	return 'a' <= b && b <= 'z' || 'A' <= b && b <= 'Z'
-}
-
-// is this path a local name? begins with ./ or ../ or /
-func islocalname(name string) bool {
-	return strings.HasPrefix(name, "/") ||
-		runtime.GOOS == "windows" && len(name) >= 3 && isDriveLetter(name[0]) && name[1] == ':' && name[2] == '/' ||
-		strings.HasPrefix(name, "./") || name == "." ||
-		strings.HasPrefix(name, "../") || name == ".."
-}
-
-func findpkg(name string) (file string, ok bool) {
-	if islocalname(name) {
-		if base.Flag.NoLocalImports {
-			return "", false
-		}
-
-		if base.Flag.Cfg.PackageFile != nil {
-			file, ok = base.Flag.Cfg.PackageFile[name]
-			return file, ok
-		}
-
-		// try .a before .6.  important for building libraries:
-		// if there is an array.6 in the array.a library,
-		// want to find all of array.a, not just array.6.
-		file = fmt.Sprintf("%s.a", name)
-		if _, err := os.Stat(file); err == nil {
-			return file, true
-		}
-		file = fmt.Sprintf("%s.o", name)
-		if _, err := os.Stat(file); err == nil {
-			return file, true
-		}
-		return "", false
-	}
-
-	// local imports should be canonicalized already.
-	// don't want to see "encoding/../encoding/base64"
-	// as different from "encoding/base64".
-	if q := path.Clean(name); q != name {
-		base.Errorf("non-canonical import path %q (should be %q)", name, q)
-		return "", false
-	}
-
-	if base.Flag.Cfg.PackageFile != nil {
-		file, ok = base.Flag.Cfg.PackageFile[name]
-		return file, ok
-	}
-
-	for _, dir := range base.Flag.Cfg.ImportDirs {
-		file = fmt.Sprintf("%s/%s.a", dir, name)
-		if _, err := os.Stat(file); err == nil {
-			return file, true
-		}
-		file = fmt.Sprintf("%s/%s.o", dir, name)
-		if _, err := os.Stat(file); err == nil {
-			return file, true
-		}
-	}
-
-	if objabi.GOROOT != "" {
-		suffix := ""
-		suffixsep := ""
-		if base.Flag.InstallSuffix != "" {
-			suffixsep = "_"
-			suffix = base.Flag.InstallSuffix
-		} else if base.Flag.Race {
-			suffixsep = "_"
-			suffix = "race"
-		} else if base.Flag.MSan {
-			suffixsep = "_"
-			suffix = "msan"
-		}
-
-		file = fmt.Sprintf("%s/pkg/%s_%s%s%s/%s.a", objabi.GOROOT, objabi.GOOS, objabi.GOARCH, suffixsep, suffix, name)
-		if _, err := os.Stat(file); err == nil {
-			return file, true
-		}
-		file = fmt.Sprintf("%s/pkg/%s_%s%s%s/%s.o", objabi.GOROOT, objabi.GOOS, objabi.GOARCH, suffixsep, suffix, name)
-		if _, err := os.Stat(file); err == nil {
-			return file, true
-		}
-	}
-
-	return "", false
-}
-
-// myheight tracks the local package's height based on packages
-// imported so far.
-var myheight int
-
-func importfile(f constant.Value) *types.Pkg {
-	if f.Kind() != constant.String {
-		base.Errorf("import path must be a string")
-		return nil
-	}
-
-	path_ := constant.StringVal(f)
-	if len(path_) == 0 {
-		base.Errorf("import path is empty")
-		return nil
-	}
-
-	if isbadimport(path_, false) {
-		return nil
-	}
-
-	// The package name main is no longer reserved,
-	// but we reserve the import path "main" to identify
-	// the main package, just as we reserve the import
-	// path "math" to identify the standard math package.
-	if path_ == "main" {
-		base.Errorf("cannot import \"main\"")
-		base.ErrorExit()
-	}
-
-	if base.Ctxt.Pkgpath != "" && path_ == base.Ctxt.Pkgpath {
-		base.Errorf("import %q while compiling that package (import cycle)", path_)
-		base.ErrorExit()
-	}
-
-	if mapped, ok := base.Flag.Cfg.ImportMap[path_]; ok {
-		path_ = mapped
-	}
-
-	if path_ == "unsafe" {
-		return ir.Pkgs.Unsafe
-	}
-
-	if islocalname(path_) {
-		if path_[0] == '/' {
-			base.Errorf("import path cannot be absolute path")
-			return nil
-		}
-
-		prefix := base.Ctxt.Pathname
-		if base.Flag.D != "" {
-			prefix = base.Flag.D
-		}
-		path_ = path.Join(prefix, path_)
-
-		if isbadimport(path_, true) {
-			return nil
-		}
-	}
-
-	file, found := findpkg(path_)
-	if !found {
-		base.Errorf("can't find import: %q", path_)
-		base.ErrorExit()
-	}
-
-	importpkg := types.NewPkg(path_, "")
-	if importpkg.Imported {
-		return importpkg
-	}
-
-	importpkg.Imported = true
-
-	imp, err := bio.Open(file)
-	if err != nil {
-		base.Errorf("can't open import: %q: %v", path_, err)
-		base.ErrorExit()
-	}
-	defer imp.Close()
-
-	// check object header
-	p, err := imp.ReadString('\n')
-	if err != nil {
-		base.Errorf("import %s: reading input: %v", file, err)
-		base.ErrorExit()
-	}
-
-	if p == "!<arch>\n" { // package archive
-		// package export block should be first
-		sz := arsize(imp.Reader, "__.PKGDEF")
-		if sz <= 0 {
-			base.Errorf("import %s: not a package file", file)
-			base.ErrorExit()
-		}
-		p, err = imp.ReadString('\n')
-		if err != nil {
-			base.Errorf("import %s: reading input: %v", file, err)
-			base.ErrorExit()
-		}
-	}
-
-	if !strings.HasPrefix(p, "go object ") {
-		base.Errorf("import %s: not a go object file: %s", file, p)
-		base.ErrorExit()
-	}
-	q := fmt.Sprintf("%s %s %s %s\n", objabi.GOOS, objabi.GOARCH, objabi.Version, objabi.Expstring())
-	if p[10:] != q {
-		base.Errorf("import %s: object is [%s] expected [%s]", file, p[10:], q)
-		base.ErrorExit()
-	}
-
-	// process header lines
-	for {
-		p, err = imp.ReadString('\n')
-		if err != nil {
-			base.Errorf("import %s: reading input: %v", file, err)
-			base.ErrorExit()
-		}
-		if p == "\n" {
-			break // header ends with blank line
-		}
-	}
-
-	// Expect $$B\n to signal binary import format.
-
-	// look for $$
-	var c byte
-	for {
-		c, err = imp.ReadByte()
-		if err != nil {
-			break
-		}
-		if c == '$' {
-			c, err = imp.ReadByte()
-			if c == '$' || err != nil {
-				break
-			}
-		}
-	}
-
-	// get character after $$
-	if err == nil {
-		c, _ = imp.ReadByte()
-	}
-
-	var fingerprint goobj.FingerprintType
-	switch c {
-	case '\n':
-		base.Errorf("cannot import %s: old export format no longer supported (recompile library)", path_)
-		return nil
-
-	case 'B':
-		if base.Debug.Export != 0 {
-			fmt.Printf("importing %s (%s)\n", path_, file)
-		}
-		imp.ReadByte() // skip \n after $$B
-
-		c, err = imp.ReadByte()
-		if err != nil {
-			base.Errorf("import %s: reading input: %v", file, err)
-			base.ErrorExit()
-		}
-
-		// Indexed format is distinguished by an 'i' byte,
-		// whereas previous export formats started with 'c', 'd', or 'v'.
-		if c != 'i' {
-			base.Errorf("import %s: unexpected package format byte: %v", file, c)
-			base.ErrorExit()
-		}
-		fingerprint = typecheck.ReadImports(importpkg, imp)
-
-	default:
-		base.Errorf("no import in %q", path_)
-		base.ErrorExit()
-	}
-
-	// assume files move (get installed) so don't record the full path
-	if base.Flag.Cfg.PackageFile != nil {
-		// If using a packageFile map, assume path_ can be recorded directly.
-		base.Ctxt.AddImport(path_, fingerprint)
-	} else {
-		// For file "/Users/foo/go/pkg/darwin_amd64/math.a" record "math.a".
-		base.Ctxt.AddImport(file[len(file)-len(path_)-len(".a"):], fingerprint)
-	}
-
-	if importpkg.Height >= myheight {
-		myheight = importpkg.Height + 1
-	}
-
-	return importpkg
-}
-
-func pkgnotused(lineno src.XPos, path string, name string) {
-	// If the package was imported with a name other than the final
-	// import path element, show it explicitly in the error message.
-	// Note that this handles both renamed imports and imports of
-	// packages containing unconventional package declarations.
-	// Note that this uses / always, even on Windows, because Go import
-	// paths always use forward slashes.
-	elem := path
-	if i := strings.LastIndex(elem, "/"); i >= 0 {
-		elem = elem[i+1:]
-	}
-	if name == "" || elem == name {
-		base.ErrorfAt(lineno, "imported and not used: %q", path)
-	} else {
-		base.ErrorfAt(lineno, "imported and not used: %q as %s", path, name)
-	}
-}
-
-func mkpackage(pkgname string) {
-	if types.LocalPkg.Name == "" {
-		if pkgname == "_" {
-			base.Errorf("invalid package name _")
-		}
-		types.LocalPkg.Name = pkgname
-	} else {
-		if pkgname != types.LocalPkg.Name {
-			base.Errorf("package %s; expected %s", pkgname, types.LocalPkg.Name)
-		}
-	}
-}
-
-func clearImports() {
-	type importedPkg struct {
-		pos  src.XPos
-		path string
-		name string
-	}
-	var unused []importedPkg
-
-	for _, s := range types.LocalPkg.Syms {
-		n := ir.AsNode(s.Def)
-		if n == nil {
-			continue
-		}
-		if n.Op() == ir.OPACK {
-			// throw away top-level package name left over
-			// from previous file.
-			// leave s->block set to cause redeclaration
-			// errors if a conflicting top-level name is
-			// introduced by a different file.
-			p := n.(*ir.PkgName)
-			if !p.Used && base.SyntaxErrors() == 0 {
-				unused = append(unused, importedPkg{p.Pos(), p.Pkg.Path, s.Name})
-			}
-			s.Def = nil
-			continue
-		}
-		if types.IsDotAlias(s) {
-			// throw away top-level name left over
-			// from previous import . "x"
-			// We'll report errors after type checking in checkDotImports.
-			s.Def = nil
-			continue
-		}
-	}
-
-	sort.Slice(unused, func(i, j int) bool { return unused[i].pos.Before(unused[j].pos) })
-	for _, pkg := range unused {
-		pkgnotused(pkg.pos, pkg.path, pkg.name)
-	}
-}
-
 // recordFlags records the specified command-line flags to be placed
 // in the DWARF info.
 func recordFlags(flags ...string) {
@@ -922,3 +552,7 @@ func useABIWrapGen(f *ir.Func) bool {
 
 	return true
 }
+
+func makePos(b *src.PosBase, line, col uint) src.XPos {
+	return base.Ctxt.PosTable.XPos(src.MakePos(b, line, col))
+}
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 1d0a0f7a04..0dbe1da8d4 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -10,6 +10,7 @@ import (
 	"cmd/compile/internal/objw"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
+	"cmd/internal/archive"
 	"cmd/internal/bio"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
@@ -25,13 +26,6 @@ import (
 	"strconv"
 )
 
-// architecture-independent object file output
-const ArhdrSize = 60
-
-func formathdr(arhdr []byte, name string, size int64) {
-	copy(arhdr[:], fmt.Sprintf("%-16s%-12d%-6d%-6d%-8o%-10d`\n", name, 0, 0, 0, 0644, size))
-}
-
 // These modes say which kind of object file to generate.
 // The default use of the toolchain is to set both bits,
 // generating a combined compiler+linker object, one that
@@ -93,7 +87,7 @@ func printObjHeader(bout *bio.Writer) {
 }
 
 func startArchiveEntry(bout *bio.Writer) int64 {
-	var arhdr [ArhdrSize]byte
+	var arhdr [archive.HeaderSize]byte
 	bout.Write(arhdr[:])
 	return bout.Offset()
 }
@@ -104,10 +98,10 @@ func finishArchiveEntry(bout *bio.Writer, start int64, name string) {
 	if size&1 != 0 {
 		bout.WriteByte(0)
 	}
-	bout.MustSeek(start-ArhdrSize, 0)
+	bout.MustSeek(start-archive.HeaderSize, 0)
 
-	var arhdr [ArhdrSize]byte
-	formathdr(arhdr[:], name, size)
+	var arhdr [archive.HeaderSize]byte
+	archive.FormatHeader(arhdr[:], name, size)
 	bout.Write(arhdr[:])
 	bout.Flush()
 	bout.MustSeek(start+size+(size&1), 0)
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index cba9bdc253..362c5162b6 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -13,10 +13,7 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"fmt"
-	"strings"
 	"sync"
-	"unicode"
-	"unicode/utf8"
 )
 
 // largeStack is info about a function whose stack frame is too large (rare).
@@ -32,55 +29,6 @@ var (
 	largeStackFrames   []largeStack
 )
 
-// dotImports tracks all PkgNames that have been dot-imported.
-var dotImports []*ir.PkgName
-
-// find all the exported symbols in package referenced by PkgName,
-// and make them available in the current package
-func importDot(pack *ir.PkgName) {
-	if typecheck.DotImportRefs == nil {
-		typecheck.DotImportRefs = make(map[*ir.Ident]*ir.PkgName)
-	}
-
-	opkg := pack.Pkg
-	for _, s := range opkg.Syms {
-		if s.Def == nil {
-			if _, ok := typecheck.DeclImporter[s]; !ok {
-				continue
-			}
-		}
-		if !types.IsExported(s.Name) || strings.ContainsRune(s.Name, 0xb7) { // 0xb7 = center dot
-			continue
-		}
-		s1 := typecheck.Lookup(s.Name)
-		if s1.Def != nil {
-			pkgerror := fmt.Sprintf("during import %q", opkg.Path)
-			typecheck.Redeclared(base.Pos, s1, pkgerror)
-			continue
-		}
-
-		id := ir.NewIdent(src.NoXPos, s)
-		typecheck.DotImportRefs[id] = pack
-		s1.Def = id
-		s1.Block = 1
-	}
-
-	dotImports = append(dotImports, pack)
-}
-
-// checkDotImports reports errors for any unused dot imports.
-func checkDotImports() {
-	for _, pack := range dotImports {
-		if !pack.Used {
-			base.ErrorfAt(pack.Pos(), "imported and not used: %q", pack.Pkg.Path)
-		}
-	}
-
-	// No longer needed; release memory.
-	dotImports = nil
-	typecheck.DotImportRefs = nil
-}
-
 // backingArrayPtrLen extracts the pointer and length from a slice or string.
 // This constructs two nodes referring to n, so n must be a cheapexpr.
 func backingArrayPtrLen(n ir.Node) (ptr, length ir.Node) {
@@ -513,59 +461,6 @@ func ngotype(n ir.Node) *types.Sym {
 	return nil
 }
 
-// The linker uses the magic symbol prefixes "go." and "type."
-// Avoid potential confusion between import paths and symbols
-// by rejecting these reserved imports for now. Also, people
-// "can do weird things in GOPATH and we'd prefer they didn't
-// do _that_ weird thing" (per rsc). See also #4257.
-var reservedimports = []string{
-	"go",
-	"type",
-}
-
-func isbadimport(path string, allowSpace bool) bool {
-	if strings.Contains(path, "\x00") {
-		base.Errorf("import path contains NUL")
-		return true
-	}
-
-	for _, ri := range reservedimports {
-		if path == ri {
-			base.Errorf("import path %q is reserved and cannot be used", path)
-			return true
-		}
-	}
-
-	for _, r := range path {
-		if r == utf8.RuneError {
-			base.Errorf("import path contains invalid UTF-8 sequence: %q", path)
-			return true
-		}
-
-		if r < 0x20 || r == 0x7f {
-			base.Errorf("import path contains control character: %q", path)
-			return true
-		}
-
-		if r == '\\' {
-			base.Errorf("import path contains backslash; use slash: %q", path)
-			return true
-		}
-
-		if !allowSpace && unicode.IsSpace(r) {
-			base.Errorf("import path contains space character: %q", path)
-			return true
-		}
-
-		if strings.ContainsRune("!\"#$%&'()*,:;<=>?[]^`{|}", r) {
-			base.Errorf("import path contains invalid character '%c': %q", r, path)
-			return true
-		}
-	}
-
-	return false
-}
-
 // itabType loads the _type field from a runtime.itab struct.
 func itabType(itab ir.Node) ir.Node {
 	typ := ir.NewSelectorExpr(base.Pos, ir.ODOTPTR, itab, nil)
diff --git a/src/cmd/compile/internal/noder/import.go b/src/cmd/compile/internal/noder/import.go
new file mode 100644
index 0000000000..a39be9864b
--- /dev/null
+++ b/src/cmd/compile/internal/noder/import.go
@@ -0,0 +1,493 @@
+// Copyright 2009 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.
+
+//go:generate go run mkbuiltin.go
+
+package noder
+
+import (
+	"fmt"
+	"go/constant"
+	"os"
+	"path"
+	"runtime"
+	"sort"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
+	"cmd/compile/internal/types"
+	"cmd/internal/archive"
+	"cmd/internal/bio"
+	"cmd/internal/goobj"
+	"cmd/internal/objabi"
+	"cmd/internal/src"
+)
+
+func isDriveLetter(b byte) bool {
+	return 'a' <= b && b <= 'z' || 'A' <= b && b <= 'Z'
+}
+
+// is this path a local name? begins with ./ or ../ or /
+func islocalname(name string) bool {
+	return strings.HasPrefix(name, "/") ||
+		runtime.GOOS == "windows" && len(name) >= 3 && isDriveLetter(name[0]) && name[1] == ':' && name[2] == '/' ||
+		strings.HasPrefix(name, "./") || name == "." ||
+		strings.HasPrefix(name, "../") || name == ".."
+}
+
+func findpkg(name string) (file string, ok bool) {
+	if islocalname(name) {
+		if base.Flag.NoLocalImports {
+			return "", false
+		}
+
+		if base.Flag.Cfg.PackageFile != nil {
+			file, ok = base.Flag.Cfg.PackageFile[name]
+			return file, ok
+		}
+
+		// try .a before .6.  important for building libraries:
+		// if there is an array.6 in the array.a library,
+		// want to find all of array.a, not just array.6.
+		file = fmt.Sprintf("%s.a", name)
+		if _, err := os.Stat(file); err == nil {
+			return file, true
+		}
+		file = fmt.Sprintf("%s.o", name)
+		if _, err := os.Stat(file); err == nil {
+			return file, true
+		}
+		return "", false
+	}
+
+	// local imports should be canonicalized already.
+	// don't want to see "encoding/../encoding/base64"
+	// as different from "encoding/base64".
+	if q := path.Clean(name); q != name {
+		base.Errorf("non-canonical import path %q (should be %q)", name, q)
+		return "", false
+	}
+
+	if base.Flag.Cfg.PackageFile != nil {
+		file, ok = base.Flag.Cfg.PackageFile[name]
+		return file, ok
+	}
+
+	for _, dir := range base.Flag.Cfg.ImportDirs {
+		file = fmt.Sprintf("%s/%s.a", dir, name)
+		if _, err := os.Stat(file); err == nil {
+			return file, true
+		}
+		file = fmt.Sprintf("%s/%s.o", dir, name)
+		if _, err := os.Stat(file); err == nil {
+			return file, true
+		}
+	}
+
+	if objabi.GOROOT != "" {
+		suffix := ""
+		suffixsep := ""
+		if base.Flag.InstallSuffix != "" {
+			suffixsep = "_"
+			suffix = base.Flag.InstallSuffix
+		} else if base.Flag.Race {
+			suffixsep = "_"
+			suffix = "race"
+		} else if base.Flag.MSan {
+			suffixsep = "_"
+			suffix = "msan"
+		}
+
+		file = fmt.Sprintf("%s/pkg/%s_%s%s%s/%s.a", objabi.GOROOT, objabi.GOOS, objabi.GOARCH, suffixsep, suffix, name)
+		if _, err := os.Stat(file); err == nil {
+			return file, true
+		}
+		file = fmt.Sprintf("%s/pkg/%s_%s%s%s/%s.o", objabi.GOROOT, objabi.GOOS, objabi.GOARCH, suffixsep, suffix, name)
+		if _, err := os.Stat(file); err == nil {
+			return file, true
+		}
+	}
+
+	return "", false
+}
+
+// myheight tracks the local package's height based on packages
+// imported so far.
+var myheight int
+
+func importfile(f constant.Value) *types.Pkg {
+	if f.Kind() != constant.String {
+		base.Errorf("import path must be a string")
+		return nil
+	}
+
+	path_ := constant.StringVal(f)
+	if len(path_) == 0 {
+		base.Errorf("import path is empty")
+		return nil
+	}
+
+	if isbadimport(path_, false) {
+		return nil
+	}
+
+	// The package name main is no longer reserved,
+	// but we reserve the import path "main" to identify
+	// the main package, just as we reserve the import
+	// path "math" to identify the standard math package.
+	if path_ == "main" {
+		base.Errorf("cannot import \"main\"")
+		base.ErrorExit()
+	}
+
+	if base.Ctxt.Pkgpath != "" && path_ == base.Ctxt.Pkgpath {
+		base.Errorf("import %q while compiling that package (import cycle)", path_)
+		base.ErrorExit()
+	}
+
+	if mapped, ok := base.Flag.Cfg.ImportMap[path_]; ok {
+		path_ = mapped
+	}
+
+	if path_ == "unsafe" {
+		return ir.Pkgs.Unsafe
+	}
+
+	if islocalname(path_) {
+		if path_[0] == '/' {
+			base.Errorf("import path cannot be absolute path")
+			return nil
+		}
+
+		prefix := base.Ctxt.Pathname
+		if base.Flag.D != "" {
+			prefix = base.Flag.D
+		}
+		path_ = path.Join(prefix, path_)
+
+		if isbadimport(path_, true) {
+			return nil
+		}
+	}
+
+	file, found := findpkg(path_)
+	if !found {
+		base.Errorf("can't find import: %q", path_)
+		base.ErrorExit()
+	}
+
+	importpkg := types.NewPkg(path_, "")
+	if importpkg.Imported {
+		return importpkg
+	}
+
+	importpkg.Imported = true
+
+	imp, err := bio.Open(file)
+	if err != nil {
+		base.Errorf("can't open import: %q: %v", path_, err)
+		base.ErrorExit()
+	}
+	defer imp.Close()
+
+	// check object header
+	p, err := imp.ReadString('\n')
+	if err != nil {
+		base.Errorf("import %s: reading input: %v", file, err)
+		base.ErrorExit()
+	}
+
+	if p == "!<arch>\n" { // package archive
+		// package export block should be first
+		sz := archive.ReadHeader(imp.Reader, "__.PKGDEF")
+		if sz <= 0 {
+			base.Errorf("import %s: not a package file", file)
+			base.ErrorExit()
+		}
+		p, err = imp.ReadString('\n')
+		if err != nil {
+			base.Errorf("import %s: reading input: %v", file, err)
+			base.ErrorExit()
+		}
+	}
+
+	if !strings.HasPrefix(p, "go object ") {
+		base.Errorf("import %s: not a go object file: %s", file, p)
+		base.ErrorExit()
+	}
+	q := fmt.Sprintf("%s %s %s %s\n", objabi.GOOS, objabi.GOARCH, objabi.Version, objabi.Expstring())
+	if p[10:] != q {
+		base.Errorf("import %s: object is [%s] expected [%s]", file, p[10:], q)
+		base.ErrorExit()
+	}
+
+	// process header lines
+	for {
+		p, err = imp.ReadString('\n')
+		if err != nil {
+			base.Errorf("import %s: reading input: %v", file, err)
+			base.ErrorExit()
+		}
+		if p == "\n" {
+			break // header ends with blank line
+		}
+	}
+
+	// Expect $$B\n to signal binary import format.
+
+	// look for $$
+	var c byte
+	for {
+		c, err = imp.ReadByte()
+		if err != nil {
+			break
+		}
+		if c == '$' {
+			c, err = imp.ReadByte()
+			if c == '$' || err != nil {
+				break
+			}
+		}
+	}
+
+	// get character after $$
+	if err == nil {
+		c, _ = imp.ReadByte()
+	}
+
+	var fingerprint goobj.FingerprintType
+	switch c {
+	case '\n':
+		base.Errorf("cannot import %s: old export format no longer supported (recompile library)", path_)
+		return nil
+
+	case 'B':
+		if base.Debug.Export != 0 {
+			fmt.Printf("importing %s (%s)\n", path_, file)
+		}
+		imp.ReadByte() // skip \n after $$B
+
+		c, err = imp.ReadByte()
+		if err != nil {
+			base.Errorf("import %s: reading input: %v", file, err)
+			base.ErrorExit()
+		}
+
+		// Indexed format is distinguished by an 'i' byte,
+		// whereas previous export formats started with 'c', 'd', or 'v'.
+		if c != 'i' {
+			base.Errorf("import %s: unexpected package format byte: %v", file, c)
+			base.ErrorExit()
+		}
+		fingerprint = typecheck.ReadImports(importpkg, imp)
+
+	default:
+		base.Errorf("no import in %q", path_)
+		base.ErrorExit()
+	}
+
+	// assume files move (get installed) so don't record the full path
+	if base.Flag.Cfg.PackageFile != nil {
+		// If using a packageFile map, assume path_ can be recorded directly.
+		base.Ctxt.AddImport(path_, fingerprint)
+	} else {
+		// For file "/Users/foo/go/pkg/darwin_amd64/math.a" record "math.a".
+		base.Ctxt.AddImport(file[len(file)-len(path_)-len(".a"):], fingerprint)
+	}
+
+	if importpkg.Height >= myheight {
+		myheight = importpkg.Height + 1
+	}
+
+	return importpkg
+}
+
+// The linker uses the magic symbol prefixes "go." and "type."
+// Avoid potential confusion between import paths and symbols
+// by rejecting these reserved imports for now. Also, people
+// "can do weird things in GOPATH and we'd prefer they didn't
+// do _that_ weird thing" (per rsc). See also #4257.
+var reservedimports = []string{
+	"go",
+	"type",
+}
+
+func isbadimport(path string, allowSpace bool) bool {
+	if strings.Contains(path, "\x00") {
+		base.Errorf("import path contains NUL")
+		return true
+	}
+
+	for _, ri := range reservedimports {
+		if path == ri {
+			base.Errorf("import path %q is reserved and cannot be used", path)
+			return true
+		}
+	}
+
+	for _, r := range path {
+		if r == utf8.RuneError {
+			base.Errorf("import path contains invalid UTF-8 sequence: %q", path)
+			return true
+		}
+
+		if r < 0x20 || r == 0x7f {
+			base.Errorf("import path contains control character: %q", path)
+			return true
+		}
+
+		if r == '\\' {
+			base.Errorf("import path contains backslash; use slash: %q", path)
+			return true
+		}
+
+		if !allowSpace && unicode.IsSpace(r) {
+			base.Errorf("import path contains space character: %q", path)
+			return true
+		}
+
+		if strings.ContainsRune("!\"#$%&'()*,:;<=>?[]^`{|}", r) {
+			base.Errorf("import path contains invalid character '%c': %q", r, path)
+			return true
+		}
+	}
+
+	return false
+}
+
+func pkgnotused(lineno src.XPos, path string, name string) {
+	// If the package was imported with a name other than the final
+	// import path element, show it explicitly in the error message.
+	// Note that this handles both renamed imports and imports of
+	// packages containing unconventional package declarations.
+	// Note that this uses / always, even on Windows, because Go import
+	// paths always use forward slashes.
+	elem := path
+	if i := strings.LastIndex(elem, "/"); i >= 0 {
+		elem = elem[i+1:]
+	}
+	if name == "" || elem == name {
+		base.ErrorfAt(lineno, "imported and not used: %q", path)
+	} else {
+		base.ErrorfAt(lineno, "imported and not used: %q as %s", path, name)
+	}
+}
+
+func mkpackage(pkgname string) {
+	if types.LocalPkg.Name == "" {
+		if pkgname == "_" {
+			base.Errorf("invalid package name _")
+		}
+		types.LocalPkg.Name = pkgname
+	} else {
+		if pkgname != types.LocalPkg.Name {
+			base.Errorf("package %s; expected %s", pkgname, types.LocalPkg.Name)
+		}
+	}
+}
+
+func clearImports() {
+	type importedPkg struct {
+		pos  src.XPos
+		path string
+		name string
+	}
+	var unused []importedPkg
+
+	for _, s := range types.LocalPkg.Syms {
+		n := ir.AsNode(s.Def)
+		if n == nil {
+			continue
+		}
+		if n.Op() == ir.OPACK {
+			// throw away top-level package name left over
+			// from previous file.
+			// leave s->block set to cause redeclaration
+			// errors if a conflicting top-level name is
+			// introduced by a different file.
+			p := n.(*ir.PkgName)
+			if !p.Used && base.SyntaxErrors() == 0 {
+				unused = append(unused, importedPkg{p.Pos(), p.Pkg.Path, s.Name})
+			}
+			s.Def = nil
+			continue
+		}
+		if types.IsDotAlias(s) {
+			// throw away top-level name left over
+			// from previous import . "x"
+			// We'll report errors after type checking in checkDotImports.
+			s.Def = nil
+			continue
+		}
+	}
+
+	sort.Slice(unused, func(i, j int) bool { return unused[i].pos.Before(unused[j].pos) })
+	for _, pkg := range unused {
+		pkgnotused(pkg.pos, pkg.path, pkg.name)
+	}
+}
+
+// CheckDotImports reports errors for any unused dot imports.
+func CheckDotImports() {
+	for _, pack := range dotImports {
+		if !pack.Used {
+			base.ErrorfAt(pack.Pos(), "imported and not used: %q", pack.Pkg.Path)
+		}
+	}
+
+	// No longer needed; release memory.
+	dotImports = nil
+	typecheck.DotImportRefs = nil
+}
+
+// dotImports tracks all PkgNames that have been dot-imported.
+var dotImports []*ir.PkgName
+
+// find all the exported symbols in package referenced by PkgName,
+// and make them available in the current package
+func importDot(pack *ir.PkgName) {
+	if typecheck.DotImportRefs == nil {
+		typecheck.DotImportRefs = make(map[*ir.Ident]*ir.PkgName)
+	}
+
+	opkg := pack.Pkg
+	for _, s := range opkg.Syms {
+		if s.Def == nil {
+			if _, ok := typecheck.DeclImporter[s]; !ok {
+				continue
+			}
+		}
+		if !types.IsExported(s.Name) || strings.ContainsRune(s.Name, 0xb7) { // 0xb7 = center dot
+			continue
+		}
+		s1 := typecheck.Lookup(s.Name)
+		if s1.Def != nil {
+			pkgerror := fmt.Sprintf("during import %q", opkg.Path)
+			typecheck.Redeclared(base.Pos, s1, pkgerror)
+			continue
+		}
+
+		id := ir.NewIdent(src.NoXPos, s)
+		typecheck.DotImportRefs[id] = pack
+		s1.Def = id
+		s1.Block = 1
+	}
+
+	dotImports = append(dotImports, pack)
+}
+
+// importName is like oldname,
+// but it reports an error if sym is from another package and not exported.
+func importName(sym *types.Sym) ir.Node {
+	n := oldname(sym)
+	if !types.IsExported(sym.Name) && sym.Pkg != types.LocalPkg {
+		n.SetDiag(true)
+		base.Errorf("cannot refer to unexported name %s.%s", sym.Pkg.Name, sym.Name)
+	}
+	return n
+}
diff --git a/src/cmd/compile/internal/gc/lex.go b/src/cmd/compile/internal/noder/lex.go
similarity index 95%
rename from src/cmd/compile/internal/gc/lex.go
rename to src/cmd/compile/internal/noder/lex.go
index 39d73867e4..1095f3344a 100644
--- a/src/cmd/compile/internal/gc/lex.go
+++ b/src/cmd/compile/internal/noder/lex.go
@@ -2,22 +2,17 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package noder
 
 import (
-	"cmd/compile/internal/base"
+	"fmt"
+	"strings"
+
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/syntax"
 	"cmd/internal/objabi"
-	"cmd/internal/src"
-	"fmt"
-	"strings"
 )
 
-func makePos(b *src.PosBase, line, col uint) src.XPos {
-	return base.Ctxt.PosTable.XPos(src.MakePos(b, line, col))
-}
-
 func isSpace(c rune) bool {
 	return c == ' ' || c == '\t' || c == '\n' || c == '\r'
 }
@@ -27,7 +22,7 @@ func isQuoted(s string) bool {
 }
 
 const (
-	FuncPragmas = ir.Nointerface |
+	funcPragmas = ir.Nointerface |
 		ir.Noescape |
 		ir.Norace |
 		ir.Nosplit |
@@ -40,7 +35,7 @@ const (
 		ir.Nowritebarrierrec |
 		ir.Yeswritebarrierrec
 
-	TypePragmas = ir.NotInHeap
+	typePragmas = ir.NotInHeap
 )
 
 func pragmaFlag(verb string) ir.PragmaFlag {
diff --git a/src/cmd/compile/internal/gc/lex_test.go b/src/cmd/compile/internal/noder/lex_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/lex_test.go
rename to src/cmd/compile/internal/noder/lex_test.go
index b2081a1732..85a3f06759 100644
--- a/src/cmd/compile/internal/gc/lex_test.go
+++ b/src/cmd/compile/internal/noder/lex_test.go
@@ -2,13 +2,14 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package noder
 
 import (
-	"cmd/compile/internal/syntax"
 	"reflect"
 	"runtime"
 	"testing"
+
+	"cmd/compile/internal/syntax"
 )
 
 func eq(a, b []string) bool {
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/noder/noder.go
similarity index 87%
rename from src/cmd/compile/internal/gc/noder.go
rename to src/cmd/compile/internal/noder/noder.go
index 3e8703f050..a684673c8f 100644
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package noder
 
 import (
 	"fmt"
@@ -25,11 +25,11 @@ import (
 	"cmd/internal/src"
 )
 
-// parseFiles concurrently parses files into *syntax.File structures.
+// ParseFiles concurrently parses files into *syntax.File structures.
 // Each declaration in every *syntax.File is converted to a syntax tree
 // and its root represented by *Node is appended to Target.Decls.
 // Returns the total count of parsed lines.
-func parseFiles(filenames []string) uint {
+func ParseFiles(filenames []string) uint {
 	noders := make([]*noder, 0, len(filenames))
 	// Limit the number of simultaneously open files.
 	sem := make(chan struct{}, runtime.GOMAXPROCS(0)+10)
@@ -257,7 +257,7 @@ func (p *noder) node() {
 	p.setlineno(p.file.PkgName)
 	mkpackage(p.file.PkgName.Value)
 
-	if pragma, ok := p.file.Pragma.(*Pragma); ok {
+	if pragma, ok := p.file.Pragma.(*pragmas); ok {
 		pragma.Flag &^= ir.GoBuildPragma
 		p.checkUnused(pragma)
 	}
@@ -323,7 +323,7 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
 		return // avoid follow-on errors if there was a syntax error
 	}
 
-	if pragma, ok := imp.Pragma.(*Pragma); ok {
+	if pragma, ok := imp.Pragma.(*pragmas); ok {
 		p.checkUnused(pragma)
 	}
 
@@ -383,7 +383,7 @@ func (p *noder) varDecl(decl *syntax.VarDecl) []ir.Node {
 		exprs = p.exprList(decl.Values)
 	}
 
-	if pragma, ok := decl.Pragma.(*Pragma); ok {
+	if pragma, ok := decl.Pragma.(*pragmas); ok {
 		if len(pragma.Embeds) > 0 {
 			if !p.importedEmbed {
 				// This check can't be done when building the list pragma.Embeds
@@ -422,7 +422,7 @@ func (p *noder) constDecl(decl *syntax.ConstDecl, cs *constState) []ir.Node {
 		}
 	}
 
-	if pragma, ok := decl.Pragma.(*Pragma); ok {
+	if pragma, ok := decl.Pragma.(*pragmas); ok {
 		p.checkUnused(pragma)
 	}
 
@@ -477,10 +477,10 @@ func (p *noder) typeDecl(decl *syntax.TypeDecl) ir.Node {
 
 	n.Ntype = typ
 	n.SetAlias(decl.Alias)
-	if pragma, ok := decl.Pragma.(*Pragma); ok {
+	if pragma, ok := decl.Pragma.(*pragmas); ok {
 		if !decl.Alias {
-			n.SetPragma(pragma.Flag & TypePragmas)
-			pragma.Flag &^= TypePragmas
+			n.SetPragma(pragma.Flag & typePragmas)
+			pragma.Flag &^= typePragmas
 		}
 		p.checkUnused(pragma)
 	}
@@ -532,12 +532,12 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) ir.Node {
 	f.Nname.Defn = f
 	f.Nname.Ntype = t
 
-	if pragma, ok := fun.Pragma.(*Pragma); ok {
-		f.Pragma = pragma.Flag & FuncPragmas
+	if pragma, ok := fun.Pragma.(*pragmas); ok {
+		f.Pragma = pragma.Flag & funcPragmas
 		if pragma.Flag&ir.Systemstack != 0 && pragma.Flag&ir.Nosplit != 0 {
 			base.ErrorfAt(f.Pos(), "go:nosplit and go:systemstack cannot be combined")
 		}
-		pragma.Flag &^= FuncPragmas
+		pragma.Flag &^= funcPragmas
 		p.checkUnused(pragma)
 	}
 
@@ -1525,24 +1525,24 @@ var allowedStdPragmas = map[string]bool{
 	"go:generate":           true,
 }
 
-// *Pragma is the value stored in a syntax.Pragma during parsing.
-type Pragma struct {
+// *pragmas is the value stored in a syntax.pragmas during parsing.
+type pragmas struct {
 	Flag   ir.PragmaFlag // collected bits
-	Pos    []PragmaPos   // position of each individual flag
-	Embeds []PragmaEmbed
+	Pos    []pragmaPos   // position of each individual flag
+	Embeds []pragmaEmbed
 }
 
-type PragmaPos struct {
+type pragmaPos struct {
 	Flag ir.PragmaFlag
 	Pos  syntax.Pos
 }
 
-type PragmaEmbed struct {
+type pragmaEmbed struct {
 	Pos      syntax.Pos
 	Patterns []string
 }
 
-func (p *noder) checkUnused(pragma *Pragma) {
+func (p *noder) checkUnused(pragma *pragmas) {
 	for _, pos := range pragma.Pos {
 		if pos.Flag&pragma.Flag != 0 {
 			p.errorAt(pos.Pos, "misplaced compiler directive")
@@ -1555,7 +1555,7 @@ func (p *noder) checkUnused(pragma *Pragma) {
 	}
 }
 
-func (p *noder) checkUnusedDuringParse(pragma *Pragma) {
+func (p *noder) checkUnusedDuringParse(pragma *pragmas) {
 	for _, pos := range pragma.Pos {
 		if pos.Flag&pragma.Flag != 0 {
 			p.error(syntax.Error{Pos: pos.Pos, Msg: "misplaced compiler directive"})
@@ -1570,9 +1570,9 @@ func (p *noder) checkUnusedDuringParse(pragma *Pragma) {
 
 // pragma is called concurrently if files are parsed concurrently.
 func (p *noder) pragma(pos syntax.Pos, blankLine bool, text string, old syntax.Pragma) syntax.Pragma {
-	pragma, _ := old.(*Pragma)
+	pragma, _ := old.(*pragmas)
 	if pragma == nil {
-		pragma = new(Pragma)
+		pragma = new(pragmas)
 	}
 
 	if text == "" {
@@ -1626,7 +1626,7 @@ func (p *noder) pragma(pos syntax.Pos, blankLine bool, text string, old syntax.P
 			p.error(syntax.Error{Pos: pos, Msg: "usage: //go:embed pattern..."})
 			break
 		}
-		pragma.Embeds = append(pragma.Embeds, PragmaEmbed{pos, args})
+		pragma.Embeds = append(pragma.Embeds, pragmaEmbed{pos, args})
 
 	case strings.HasPrefix(text, "go:cgo_import_dynamic "):
 		// This is permitted for general use because Solaris
@@ -1665,7 +1665,7 @@ func (p *noder) pragma(pos syntax.Pos, blankLine bool, text string, old syntax.P
 			p.error(syntax.Error{Pos: pos, Msg: fmt.Sprintf("//%s is not allowed in the standard library", verb)})
 		}
 		pragma.Flag |= flag
-		pragma.Pos = append(pragma.Pos, PragmaPos{flag, pos})
+		pragma.Pos = append(pragma.Pos, pragmaPos{flag, pos})
 	}
 
 	return pragma
@@ -1761,3 +1761,178 @@ func parseGoEmbed(args string) ([]string, error) {
 	}
 	return list, nil
 }
+
+func fakeRecv() *ir.Field {
+	return ir.NewField(base.Pos, nil, nil, types.FakeRecvType())
+}
+
+func (p *noder) funcLit(expr *syntax.FuncLit) ir.Node {
+	xtype := p.typeExpr(expr.Type)
+	ntype := p.typeExpr(expr.Type)
+
+	fn := ir.NewFunc(p.pos(expr))
+	fn.SetIsHiddenClosure(ir.CurFunc != nil)
+	fn.Nname = ir.NewFuncNameAt(p.pos(expr), ir.BlankNode.Sym(), fn) // filled in by typecheckclosure
+	fn.Nname.Ntype = xtype
+	fn.Nname.Defn = fn
+
+	clo := ir.NewClosureExpr(p.pos(expr), fn)
+	fn.ClosureType = ntype
+	fn.OClosure = clo
+
+	p.funcBody(fn, expr.Body)
+
+	// closure-specific variables are hanging off the
+	// ordinary ones in the symbol table; see oldname.
+	// unhook them.
+	// make the list of pointers for the closure call.
+	for _, v := range fn.ClosureVars {
+		// Unlink from v1; see comment in syntax.go type Param for these fields.
+		v1 := v.Defn
+		v1.Name().Innermost = v.Outer
+
+		// If the closure usage of v is not dense,
+		// we need to make it dense; now that we're out
+		// of the function in which v appeared,
+		// look up v.Sym in the enclosing function
+		// and keep it around for use in the compiled code.
+		//
+		// That is, suppose we just finished parsing the innermost
+		// closure f4 in this code:
+		//
+		//	func f() {
+		//		v := 1
+		//		func() { // f2
+		//			use(v)
+		//			func() { // f3
+		//				func() { // f4
+		//					use(v)
+		//				}()
+		//			}()
+		//		}()
+		//	}
+		//
+		// At this point v.Outer is f2's v; there is no f3's v.
+		// To construct the closure f4 from within f3,
+		// we need to use f3's v and in this case we need to create f3's v.
+		// We are now in the context of f3, so calling oldname(v.Sym)
+		// obtains f3's v, creating it if necessary (as it is in the example).
+		//
+		// capturevars will decide whether to use v directly or &v.
+		v.Outer = oldname(v.Sym()).(*ir.Name)
+	}
+
+	return clo
+}
+
+// A function named init is a special case.
+// It is called by the initialization before main is run.
+// To make it unique within a package and also uncallable,
+// the name, normally "pkg.init", is altered to "pkg.init.0".
+var renameinitgen int
+
+func renameinit() *types.Sym {
+	s := typecheck.LookupNum("init.", renameinitgen)
+	renameinitgen++
+	return s
+}
+
+// oldname returns the Node that declares symbol s in the current scope.
+// If no such Node currently exists, an ONONAME Node is returned instead.
+// Automatically creates a new closure variable if the referenced symbol was
+// declared in a different (containing) function.
+func oldname(s *types.Sym) ir.Node {
+	if s.Pkg != types.LocalPkg {
+		return ir.NewIdent(base.Pos, s)
+	}
+
+	n := ir.AsNode(s.Def)
+	if n == nil {
+		// Maybe a top-level declaration will come along later to
+		// define s. resolve will check s.Def again once all input
+		// source has been processed.
+		return ir.NewIdent(base.Pos, s)
+	}
+
+	if ir.CurFunc != nil && n.Op() == ir.ONAME && n.Name().Curfn != nil && n.Name().Curfn != ir.CurFunc {
+		// Inner func is referring to var in outer func.
+		//
+		// TODO(rsc): If there is an outer variable x and we
+		// are parsing x := 5 inside the closure, until we get to
+		// the := it looks like a reference to the outer x so we'll
+		// make x a closure variable unnecessarily.
+		n := n.(*ir.Name)
+		c := n.Name().Innermost
+		if c == nil || c.Curfn != ir.CurFunc {
+			// Do not have a closure var for the active closure yet; make one.
+			c = typecheck.NewName(s)
+			c.Class_ = ir.PAUTOHEAP
+			c.SetIsClosureVar(true)
+			c.SetIsDDD(n.IsDDD())
+			c.Defn = n
+
+			// Link into list of active closure variables.
+			// Popped from list in func funcLit.
+			c.Outer = n.Name().Innermost
+			n.Name().Innermost = c
+
+			ir.CurFunc.ClosureVars = append(ir.CurFunc.ClosureVars, c)
+		}
+
+		// return ref to closure var, not original
+		return c
+	}
+
+	return n
+}
+
+func varEmbed(p *noder, names []*ir.Name, typ ir.Ntype, exprs []ir.Node, embeds []pragmaEmbed) (newExprs []ir.Node) {
+	haveEmbed := false
+	for _, decl := range p.file.DeclList {
+		imp, ok := decl.(*syntax.ImportDecl)
+		if !ok {
+			// imports always come first
+			break
+		}
+		path, _ := strconv.Unquote(imp.Path.Value)
+		if path == "embed" {
+			haveEmbed = true
+			break
+		}
+	}
+
+	pos := embeds[0].Pos
+	if !haveEmbed {
+		p.errorAt(pos, "invalid go:embed: missing import \"embed\"")
+		return exprs
+	}
+	if base.Flag.Cfg.Embed.Patterns == nil {
+		p.errorAt(pos, "invalid go:embed: build system did not supply embed configuration")
+		return exprs
+	}
+	if len(names) > 1 {
+		p.errorAt(pos, "go:embed cannot apply to multiple vars")
+		return exprs
+	}
+	if len(exprs) > 0 {
+		p.errorAt(pos, "go:embed cannot apply to var with initializer")
+		return exprs
+	}
+	if typ == nil {
+		// Should not happen, since len(exprs) == 0 now.
+		p.errorAt(pos, "go:embed cannot apply to var without type")
+		return exprs
+	}
+	if typecheck.DeclContext != ir.PEXTERN {
+		p.errorAt(pos, "go:embed cannot apply to var inside func")
+		return exprs
+	}
+
+	v := names[0]
+	typecheck.Target.Embeds = append(typecheck.Target.Embeds, v)
+	v.Embed = new([]ir.Embed)
+	for _, e := range embeds {
+		*v.Embed = append(*v.Embed, ir.Embed{Pos: p.makeXPos(e.Pos), Patterns: e.Patterns})
+	}
+	return exprs
+}
diff --git a/src/cmd/internal/archive/archive.go b/src/cmd/internal/archive/archive.go
index 762e888a04..e9b25fe240 100644
--- a/src/cmd/internal/archive/archive.go
+++ b/src/cmd/internal/archive/archive.go
@@ -464,3 +464,24 @@ func exactly16Bytes(s string) string {
 	s += sixteenSpaces[:16-len(s)]
 	return s
 }
+
+// architecture-independent object file output
+const HeaderSize = 60
+
+func ReadHeader(b *bufio.Reader, name string) int {
+	var buf [HeaderSize]byte
+	if _, err := io.ReadFull(b, buf[:]); err != nil {
+		return -1
+	}
+	aname := strings.Trim(string(buf[0:16]), " ")
+	if !strings.HasPrefix(aname, name) {
+		return -1
+	}
+	asize := strings.Trim(string(buf[48:58]), " ")
+	i, _ := strconv.Atoi(asize)
+	return i
+}
+
+func FormatHeader(arhdr []byte, name string, size int64) {
+	copy(arhdr[:], fmt.Sprintf("%-16s%-12d%-6d%-6d%-8o%-10d`\n", name, 0, 0, 0, 0644, size))
+}
-- 
GitLab


From 4dfb5d91a86dfcc046ced03cee6e844df0751e41 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 23 Dec 2020 00:54:11 -0500
Subject: [PATCH 0312/2400] [dev.regabi] cmd/compile: split out package
 staticdata [generated]

[git-generate]
cd src/cmd/compile/internal/gc

rf '
	# Export API and move to its own files.
	mv addrsym InitAddr
	mv pfuncsym InitFunc
	mv slicesym InitSlice
	mv slicebytes InitSliceBytes
	mv stringsym StringSym
	mv funcsym FuncSym
	mv makefuncsym NeedFuncSym
	mv dumpfuncsyms WriteFuncSyms
	mv InitAddr InitFunc InitSlice InitSliceBytes stringSymPrefix \
		StringSym fileStringSym slicedataGen slicedata dstringdata \
		funcsyms FuncSym NeedFuncSym WriteFuncSyms \
		data.go

	mv initEmbed WriteEmbed
	mv dumpembeds obj.go

	mv data.go embed.go cmd/compile/internal/staticdata
'

Change-Id: I209c5e597c8acfa29a48527695a9ddc1e9ea8e6a
Reviewed-on: https://go-review.googlesource.com/c/go/+/279474
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/dcl.go            |  51 ---
 src/cmd/compile/internal/gc/go.go             |   7 -
 src/cmd/compile/internal/gc/main.go           |   3 +-
 src/cmd/compile/internal/gc/obj.go            | 233 +-------------
 src/cmd/compile/internal/gc/sinit.go          |  29 +-
 src/cmd/compile/internal/gc/ssa.go            |   7 +-
 src/cmd/compile/internal/gc/walk.go           |   3 +-
 src/cmd/compile/internal/staticdata/data.go   | 296 ++++++++++++++++++
 .../internal/{gc => staticdata}/embed.go      |  23 +-
 9 files changed, 336 insertions(+), 316 deletions(-)
 create mode 100644 src/cmd/compile/internal/staticdata/data.go
 rename src/cmd/compile/internal/{gc => staticdata}/embed.go (95%)

diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index aaf5b35057..7b2bf5b606 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -28,57 +28,6 @@ func NoWriteBarrierRecCheck() {
 
 var nowritebarrierrecCheck *nowritebarrierrecChecker
 
-// funcsym returns s·f.
-func funcsym(s *types.Sym) *types.Sym {
-	// funcsymsmu here serves to protect not just mutations of funcsyms (below),
-	// but also the package lookup of the func sym name,
-	// since this function gets called concurrently from the backend.
-	// There are no other concurrent package lookups in the backend,
-	// except for the types package, which is protected separately.
-	// Reusing funcsymsmu to also cover this package lookup
-	// avoids a general, broader, expensive package lookup mutex.
-	// Note makefuncsym also does package look-up of func sym names,
-	// but that it is only called serially, from the front end.
-	funcsymsmu.Lock()
-	sf, existed := s.Pkg.LookupOK(ir.FuncSymName(s))
-	// Don't export s·f when compiling for dynamic linking.
-	// When dynamically linking, the necessary function
-	// symbols will be created explicitly with makefuncsym.
-	// See the makefuncsym comment for details.
-	if !base.Ctxt.Flag_dynlink && !existed {
-		funcsyms = append(funcsyms, s)
-	}
-	funcsymsmu.Unlock()
-	return sf
-}
-
-// makefuncsym ensures that s·f is exported.
-// It is only used with -dynlink.
-// When not compiling for dynamic linking,
-// the funcsyms are created as needed by
-// the packages that use them.
-// Normally we emit the s·f stubs as DUPOK syms,
-// but DUPOK doesn't work across shared library boundaries.
-// So instead, when dynamic linking, we only create
-// the s·f stubs in s's package.
-func makefuncsym(s *types.Sym) {
-	if !base.Ctxt.Flag_dynlink {
-		base.Fatalf("makefuncsym dynlink")
-	}
-	if s.IsBlank() {
-		return
-	}
-	if base.Flag.CompilingRuntime && (s.Name == "getg" || s.Name == "getclosureptr" || s.Name == "getcallerpc" || s.Name == "getcallersp") {
-		// runtime.getg(), getclosureptr(), getcallerpc(), and
-		// getcallersp() are not real functions and so do not
-		// get funcsyms.
-		return
-	}
-	if _, existed := s.Pkg.LookupOK(ir.FuncSymName(s)); !existed {
-		funcsyms = append(funcsyms, s)
-	}
-}
-
 type nowritebarrierrecChecker struct {
 	// extraCalls contains extra function calls that may not be
 	// visible during later analysis. It maps from the ODCLFUNC of
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index c979edcdf8..6f97d43fef 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -7,20 +7,13 @@ package gc
 import (
 	"cmd/compile/internal/objw"
 	"cmd/compile/internal/ssa"
-	"cmd/compile/internal/types"
 	"cmd/internal/obj"
-	"sync"
 )
 
 var pragcgobuf [][]string
 
 var zerosize int64
 
-var (
-	funcsymsmu sync.Mutex // protects funcsyms and associated package lookups (see func funcsym)
-	funcsyms   []*types.Sym
-)
-
 // interface to back end
 
 type Arch struct {
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 7b540d8675..bb6ace6562 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -16,6 +16,7 @@ import (
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/noder"
 	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/staticdata"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/dwarf"
@@ -194,7 +195,7 @@ func Main(archInit func(*Arch)) {
 
 	typecheck.Target = new(ir.Package)
 
-	typecheck.NeedFuncSym = makefuncsym
+	typecheck.NeedFuncSym = staticdata.NeedFuncSym
 	typecheck.NeedITab = func(t, iface *types.Type) { itabname(t, iface) }
 	typecheck.NeedRuntimeType = addsignat // TODO(rsc): typenamesym for lock?
 
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 0dbe1da8d4..50935d4e98 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -8,22 +8,16 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/objw"
+	"cmd/compile/internal/staticdata"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/archive"
 	"cmd/internal/bio"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
-	"cmd/internal/src"
-	"crypto/sha256"
 	"encoding/json"
 	"fmt"
 	"go/constant"
-	"io"
-	"io/ioutil"
-	"os"
-	"sort"
-	"strconv"
 )
 
 // These modes say which kind of object file to generate.
@@ -117,7 +111,7 @@ func dumpdata() {
 	numDecls := len(typecheck.Target.Decls)
 
 	dumpglobls(typecheck.Target.Externs)
-	dumpfuncsyms()
+	staticdata.WriteFuncSyms()
 	addptabs()
 	numExports := len(typecheck.Target.Exports)
 	addsignats(typecheck.Target.Externs)
@@ -270,17 +264,6 @@ func dumpglobls(externs []ir.Node) {
 	}
 }
 
-func dumpfuncsyms() {
-	sort.Slice(funcsyms, func(i, j int) bool {
-		return funcsyms[i].LinksymName() < funcsyms[j].LinksymName()
-	})
-	for _, s := range funcsyms {
-		sf := s.Pkg.Lookup(ir.FuncSymName(s)).Linksym()
-		objw.SymPtr(sf, 0, s.Linksym(), 0)
-		objw.Global(sf, int32(types.PtrSize), obj.DUPOK|obj.RODATA)
-	}
-}
-
 // addGCLocals adds gcargs, gclocals, gcregs, and stack object symbols to Ctxt.Data.
 //
 // This is done during the sequential phase after compilation, since
@@ -307,210 +290,6 @@ func addGCLocals() {
 	}
 }
 
-const (
-	stringSymPrefix  = "go.string."
-	stringSymPattern = ".gostring.%d.%x"
-)
-
-// stringsym returns a symbol containing the string s.
-// The symbol contains the string data, not a string header.
-func stringsym(pos src.XPos, s string) (data *obj.LSym) {
-	var symname string
-	if len(s) > 100 {
-		// Huge strings are hashed to avoid long names in object files.
-		// Indulge in some paranoia by writing the length of s, too,
-		// as protection against length extension attacks.
-		// Same pattern is known to fileStringSym below.
-		h := sha256.New()
-		io.WriteString(h, s)
-		symname = fmt.Sprintf(stringSymPattern, len(s), h.Sum(nil))
-	} else {
-		// Small strings get named directly by their contents.
-		symname = strconv.Quote(s)
-	}
-
-	symdata := base.Ctxt.Lookup(stringSymPrefix + symname)
-	if !symdata.OnList() {
-		off := dstringdata(symdata, 0, s, pos, "string")
-		objw.Global(symdata, int32(off), obj.DUPOK|obj.RODATA|obj.LOCAL)
-		symdata.Set(obj.AttrContentAddressable, true)
-	}
-
-	return symdata
-}
-
-// fileStringSym returns a symbol for the contents and the size of file.
-// If readonly is true, the symbol shares storage with any literal string
-// or other file with the same content and is placed in a read-only section.
-// If readonly is false, the symbol is a read-write copy separate from any other,
-// for use as the backing store of a []byte.
-// The content hash of file is copied into hash. (If hash is nil, nothing is copied.)
-// The returned symbol contains the data itself, not a string header.
-func fileStringSym(pos src.XPos, file string, readonly bool, hash []byte) (*obj.LSym, int64, error) {
-	f, err := os.Open(file)
-	if err != nil {
-		return nil, 0, err
-	}
-	defer f.Close()
-	info, err := f.Stat()
-	if err != nil {
-		return nil, 0, err
-	}
-	if !info.Mode().IsRegular() {
-		return nil, 0, fmt.Errorf("not a regular file")
-	}
-	size := info.Size()
-	if size <= 1*1024 {
-		data, err := ioutil.ReadAll(f)
-		if err != nil {
-			return nil, 0, err
-		}
-		if int64(len(data)) != size {
-			return nil, 0, fmt.Errorf("file changed between reads")
-		}
-		var sym *obj.LSym
-		if readonly {
-			sym = stringsym(pos, string(data))
-		} else {
-			sym = slicedata(pos, string(data)).Sym().Linksym()
-		}
-		if len(hash) > 0 {
-			sum := sha256.Sum256(data)
-			copy(hash, sum[:])
-		}
-		return sym, size, nil
-	}
-	if size > 2e9 {
-		// ggloblsym takes an int32,
-		// and probably the rest of the toolchain
-		// can't handle such big symbols either.
-		// See golang.org/issue/9862.
-		return nil, 0, fmt.Errorf("file too large")
-	}
-
-	// File is too big to read and keep in memory.
-	// Compute hash if needed for read-only content hashing or if the caller wants it.
-	var sum []byte
-	if readonly || len(hash) > 0 {
-		h := sha256.New()
-		n, err := io.Copy(h, f)
-		if err != nil {
-			return nil, 0, err
-		}
-		if n != size {
-			return nil, 0, fmt.Errorf("file changed between reads")
-		}
-		sum = h.Sum(nil)
-		copy(hash, sum)
-	}
-
-	var symdata *obj.LSym
-	if readonly {
-		symname := fmt.Sprintf(stringSymPattern, size, sum)
-		symdata = base.Ctxt.Lookup(stringSymPrefix + symname)
-		if !symdata.OnList() {
-			info := symdata.NewFileInfo()
-			info.Name = file
-			info.Size = size
-			objw.Global(symdata, int32(size), obj.DUPOK|obj.RODATA|obj.LOCAL)
-			// Note: AttrContentAddressable cannot be set here,
-			// because the content-addressable-handling code
-			// does not know about file symbols.
-		}
-	} else {
-		// Emit a zero-length data symbol
-		// and then fix up length and content to use file.
-		symdata = slicedata(pos, "").Sym().Linksym()
-		symdata.Size = size
-		symdata.Type = objabi.SNOPTRDATA
-		info := symdata.NewFileInfo()
-		info.Name = file
-		info.Size = size
-	}
-
-	return symdata, size, nil
-}
-
-var slicedataGen int
-
-func slicedata(pos src.XPos, s string) *ir.Name {
-	slicedataGen++
-	symname := fmt.Sprintf(".gobytes.%d", slicedataGen)
-	sym := types.LocalPkg.Lookup(symname)
-	symnode := typecheck.NewName(sym)
-	sym.Def = symnode
-
-	lsym := sym.Linksym()
-	off := dstringdata(lsym, 0, s, pos, "slice")
-	objw.Global(lsym, int32(off), obj.NOPTR|obj.LOCAL)
-
-	return symnode
-}
-
-func slicebytes(nam *ir.Name, off int64, s string) {
-	if nam.Op() != ir.ONAME {
-		base.Fatalf("slicebytes %v", nam)
-	}
-	slicesym(nam, off, slicedata(nam.Pos(), s), int64(len(s)))
-}
-
-func dstringdata(s *obj.LSym, off int, t string, pos src.XPos, what string) int {
-	// Objects that are too large will cause the data section to overflow right away,
-	// causing a cryptic error message by the linker. Check for oversize objects here
-	// and provide a useful error message instead.
-	if int64(len(t)) > 2e9 {
-		base.ErrorfAt(pos, "%v with length %v is too big", what, len(t))
-		return 0
-	}
-
-	s.WriteString(base.Ctxt, int64(off), len(t), t)
-	return off + len(t)
-}
-
-// slicesym writes a static slice symbol {&arr, lencap, lencap} to n+noff.
-// slicesym does not modify n.
-func slicesym(n *ir.Name, noff int64, arr *ir.Name, lencap int64) {
-	s := n.Sym().Linksym()
-	if arr.Op() != ir.ONAME {
-		base.Fatalf("slicesym non-name arr %v", arr)
-	}
-	s.WriteAddr(base.Ctxt, noff, types.PtrSize, arr.Sym().Linksym(), 0)
-	s.WriteInt(base.Ctxt, noff+types.SliceLenOffset, types.PtrSize, lencap)
-	s.WriteInt(base.Ctxt, noff+types.SliceCapOffset, types.PtrSize, lencap)
-}
-
-// addrsym writes the static address of a to n. a must be an ONAME.
-// Neither n nor a is modified.
-func addrsym(n *ir.Name, noff int64, a *ir.Name, aoff int64) {
-	if n.Op() != ir.ONAME {
-		base.Fatalf("addrsym n op %v", n.Op())
-	}
-	if n.Sym() == nil {
-		base.Fatalf("addrsym nil n sym")
-	}
-	if a.Op() != ir.ONAME {
-		base.Fatalf("addrsym a op %v", a.Op())
-	}
-	s := n.Sym().Linksym()
-	s.WriteAddr(base.Ctxt, noff, types.PtrSize, a.Sym().Linksym(), aoff)
-}
-
-// pfuncsym writes the static address of f to n. f must be a global function.
-// Neither n nor f is modified.
-func pfuncsym(n *ir.Name, noff int64, f *ir.Name) {
-	if n.Op() != ir.ONAME {
-		base.Fatalf("pfuncsym n op %v", n.Op())
-	}
-	if n.Sym() == nil {
-		base.Fatalf("pfuncsym nil n sym")
-	}
-	if f.Class_ != ir.PFUNC {
-		base.Fatalf("pfuncsym class not PFUNC %d", f.Class_)
-	}
-	s := n.Sym().Linksym()
-	s.WriteAddr(base.Ctxt, noff, types.PtrSize, funcsym(f.Sym()).Linksym(), 0)
-}
-
 // litsym writes the static literal c to n.
 // Neither n nor c is modified.
 func litsym(n *ir.Name, noff int64, c ir.Node, wid int) {
@@ -558,7 +337,7 @@ func litsym(n *ir.Name, noff int64, c ir.Node, wid int) {
 
 	case constant.String:
 		i := constant.StringVal(u)
-		symdata := stringsym(n.Pos(), i)
+		symdata := staticdata.StringSym(n.Pos(), i)
 		s.WriteAddr(base.Ctxt, noff, types.PtrSize, symdata, 0)
 		s.WriteInt(base.Ctxt, noff+int64(types.PtrSize), types.PtrSize, int64(len(i)))
 
@@ -588,3 +367,9 @@ func ggloblnod(nam ir.Node) {
 		s.Pkg = "_"
 	}
 }
+
+func dumpembeds() {
+	for _, v := range typecheck.Target.Embeds {
+		staticdata.WriteEmbed(v)
+	}
+}
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 26591ad5ab..d818be94a4 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/staticdata"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -76,7 +77,7 @@ func (s *InitSchedule) tryStaticInit(nn ir.Node) bool {
 func (s *InitSchedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *types.Type) bool {
 	if rn.Class_ == ir.PFUNC {
 		// TODO if roff != 0 { panic }
-		pfuncsym(l, loff, rn)
+		staticdata.InitFunc(l, loff, rn)
 		return true
 	}
 	if rn.Class_ != ir.PEXTERN || rn.Sym().Pkg != types.LocalPkg {
@@ -130,7 +131,7 @@ func (s *InitSchedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *type
 		r := r.(*ir.AddrExpr)
 		if a := r.X; a.Op() == ir.ONAME {
 			a := a.(*ir.Name)
-			addrsym(l, loff, a, 0)
+			staticdata.InitAddr(l, loff, a, 0)
 			return true
 		}
 
@@ -139,14 +140,14 @@ func (s *InitSchedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *type
 		switch r.X.Op() {
 		case ir.OARRAYLIT, ir.OSLICELIT, ir.OSTRUCTLIT, ir.OMAPLIT:
 			// copy pointer
-			addrsym(l, loff, s.inittemps[r], 0)
+			staticdata.InitAddr(l, loff, s.inittemps[r], 0)
 			return true
 		}
 
 	case ir.OSLICELIT:
 		r := r.(*ir.CompLitExpr)
 		// copy slice
-		slicesym(l, loff, s.inittemps[r], r.Len)
+		staticdata.InitSlice(l, loff, s.inittemps[r], r.Len)
 		return true
 
 	case ir.OARRAYLIT, ir.OSTRUCTLIT:
@@ -207,7 +208,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 	case ir.OADDR:
 		r := r.(*ir.AddrExpr)
 		if name, offset, ok := stataddr(r.X); ok {
-			addrsym(l, loff, name, offset)
+			staticdata.InitAddr(l, loff, name, offset)
 			return true
 		}
 		fallthrough
@@ -220,7 +221,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 			a := staticname(r.X.Type())
 
 			s.inittemps[r] = a
-			addrsym(l, loff, a, 0)
+			staticdata.InitAddr(l, loff, a, 0)
 
 			// Init underlying literal.
 			if !s.staticassign(a, 0, r.X, a.Type()) {
@@ -234,7 +235,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 		r := r.(*ir.ConvExpr)
 		if l.Class_ == ir.PEXTERN && r.X.Op() == ir.OLITERAL {
 			sval := ir.StringVal(r.X)
-			slicebytes(l, loff, sval)
+			staticdata.InitSliceBytes(l, loff, sval)
 			return true
 		}
 
@@ -246,7 +247,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 		ta.SetNoalg(true)
 		a := staticname(ta)
 		s.inittemps[r] = a
-		slicesym(l, loff, a, r.Len)
+		staticdata.InitSlice(l, loff, a, r.Len)
 		// Fall through to init underlying array.
 		l = a
 		loff = 0
@@ -284,7 +285,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 			// Closures with no captured variables are globals,
 			// so the assignment can be done at link time.
 			// TODO if roff != 0 { panic }
-			pfuncsym(l, loff, r.Func.Nname)
+			staticdata.InitFunc(l, loff, r.Func.Nname)
 			return true
 		}
 		closuredebugruntimecheck(r)
@@ -321,7 +322,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 		// Create a copy of l to modify while we emit data.
 
 		// Emit itab, advance offset.
-		addrsym(l, loff, itab.X.(*ir.Name), 0)
+		staticdata.InitAddr(l, loff, itab.X.(*ir.Name), 0)
 
 		// Emit data.
 		if types.IsDirectIface(val.Type()) {
@@ -342,7 +343,7 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 			if !s.staticassign(a, 0, val, val.Type()) {
 				s.append(ir.NewAssignStmt(base.Pos, a, val))
 			}
-			addrsym(l, loff+int64(types.PtrSize), a, 0)
+			staticdata.InitAddr(l, loff+int64(types.PtrSize), a, 0)
 		}
 
 		return true
@@ -638,7 +639,7 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 		if !ok || name.Class_ != ir.PEXTERN {
 			base.Fatalf("slicelit: %v", var_)
 		}
-		slicesym(name, offset, vstat, t.NumElem())
+		staticdata.InitSlice(name, offset, vstat, t.NumElem())
 		return
 	}
 
@@ -1138,7 +1139,7 @@ func genAsStatic(as *ir.AssignStmt) {
 		return
 	case ir.OMETHEXPR:
 		r := r.(*ir.MethodExpr)
-		pfuncsym(name, offset, r.FuncName())
+		staticdata.InitFunc(name, offset, r.FuncName())
 		return
 	case ir.ONAME:
 		r := r.(*ir.Name)
@@ -1146,7 +1147,7 @@ func genAsStatic(as *ir.AssignStmt) {
 			base.Fatalf("genAsStatic %+v", as)
 		}
 		if r.Class_ == ir.PFUNC {
-			pfuncsym(name, offset, r)
+			staticdata.InitFunc(name, offset, r)
 			return
 		}
 	}
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index feb2d0de8f..51eeb9315a 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -21,6 +21,7 @@ import (
 	"cmd/compile/internal/liveness"
 	"cmd/compile/internal/objw"
 	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/staticdata"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -2115,13 +2116,13 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		return s.entryNewValue1A(ssa.OpAddr, n.Type(), aux, s.sb)
 	case ir.OMETHEXPR:
 		n := n.(*ir.MethodExpr)
-		sym := funcsym(n.FuncName().Sym()).Linksym()
+		sym := staticdata.FuncSym(n.FuncName().Sym()).Linksym()
 		return s.entryNewValue1A(ssa.OpAddr, types.NewPtr(n.Type()), sym, s.sb)
 	case ir.ONAME:
 		n := n.(*ir.Name)
 		if n.Class_ == ir.PFUNC {
 			// "value" of a function is the address of the function's closure
-			sym := funcsym(n.Sym()).Linksym()
+			sym := staticdata.FuncSym(n.Sym()).Linksym()
 			return s.entryNewValue1A(ssa.OpAddr, types.NewPtr(n.Type()), sym, s.sb)
 		}
 		if s.canSSA(n) {
@@ -7160,7 +7161,7 @@ func (e *ssafn) StringData(s string) *obj.LSym {
 	if e.strings == nil {
 		e.strings = make(map[string]*obj.LSym)
 	}
-	data := stringsym(e.curfn.Pos(), s)
+	data := staticdata.StringSym(e.curfn.Pos(), s)
 	e.strings[s] = data
 	return data
 }
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 9e4de7f804..9c2484f3dc 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -8,6 +8,7 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/escape"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/staticdata"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -526,7 +527,7 @@ func walkexpr(n ir.Node, init *ir.Nodes) ir.Node {
 		// Emit string symbol now to avoid emitting
 		// any concurrently during the backend.
 		if v := n.Val(); v.Kind() == constant.String {
-			_ = stringsym(n.Pos(), constant.StringVal(v))
+			_ = staticdata.StringSym(n.Pos(), constant.StringVal(v))
 		}
 	}
 
diff --git a/src/cmd/compile/internal/staticdata/data.go b/src/cmd/compile/internal/staticdata/data.go
new file mode 100644
index 0000000000..7627aaa11a
--- /dev/null
+++ b/src/cmd/compile/internal/staticdata/data.go
@@ -0,0 +1,296 @@
+// Copyright 2009 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 staticdata
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"sort"
+	"strconv"
+	"sync"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/objw"
+	"cmd/compile/internal/typecheck"
+	"cmd/compile/internal/types"
+	"cmd/internal/obj"
+	"cmd/internal/objabi"
+	"cmd/internal/src"
+)
+
+// InitAddr writes the static address of a to n. a must be an ONAME.
+// Neither n nor a is modified.
+func InitAddr(n *ir.Name, noff int64, a *ir.Name, aoff int64) {
+	if n.Op() != ir.ONAME {
+		base.Fatalf("addrsym n op %v", n.Op())
+	}
+	if n.Sym() == nil {
+		base.Fatalf("addrsym nil n sym")
+	}
+	if a.Op() != ir.ONAME {
+		base.Fatalf("addrsym a op %v", a.Op())
+	}
+	s := n.Sym().Linksym()
+	s.WriteAddr(base.Ctxt, noff, types.PtrSize, a.Sym().Linksym(), aoff)
+}
+
+// InitFunc writes the static address of f to n. f must be a global function.
+// Neither n nor f is modified.
+func InitFunc(n *ir.Name, noff int64, f *ir.Name) {
+	if n.Op() != ir.ONAME {
+		base.Fatalf("pfuncsym n op %v", n.Op())
+	}
+	if n.Sym() == nil {
+		base.Fatalf("pfuncsym nil n sym")
+	}
+	if f.Class_ != ir.PFUNC {
+		base.Fatalf("pfuncsym class not PFUNC %d", f.Class_)
+	}
+	s := n.Sym().Linksym()
+	s.WriteAddr(base.Ctxt, noff, types.PtrSize, FuncSym(f.Sym()).Linksym(), 0)
+}
+
+// InitSlice writes a static slice symbol {&arr, lencap, lencap} to n+noff.
+// InitSlice does not modify n.
+func InitSlice(n *ir.Name, noff int64, arr *ir.Name, lencap int64) {
+	s := n.Sym().Linksym()
+	if arr.Op() != ir.ONAME {
+		base.Fatalf("slicesym non-name arr %v", arr)
+	}
+	s.WriteAddr(base.Ctxt, noff, types.PtrSize, arr.Sym().Linksym(), 0)
+	s.WriteInt(base.Ctxt, noff+types.SliceLenOffset, types.PtrSize, lencap)
+	s.WriteInt(base.Ctxt, noff+types.SliceCapOffset, types.PtrSize, lencap)
+}
+
+func InitSliceBytes(nam *ir.Name, off int64, s string) {
+	if nam.Op() != ir.ONAME {
+		base.Fatalf("slicebytes %v", nam)
+	}
+	InitSlice(nam, off, slicedata(nam.Pos(), s), int64(len(s)))
+}
+
+const (
+	stringSymPrefix  = "go.string."
+	stringSymPattern = ".gostring.%d.%x"
+)
+
+// StringSym returns a symbol containing the string s.
+// The symbol contains the string data, not a string header.
+func StringSym(pos src.XPos, s string) (data *obj.LSym) {
+	var symname string
+	if len(s) > 100 {
+		// Huge strings are hashed to avoid long names in object files.
+		// Indulge in some paranoia by writing the length of s, too,
+		// as protection against length extension attacks.
+		// Same pattern is known to fileStringSym below.
+		h := sha256.New()
+		io.WriteString(h, s)
+		symname = fmt.Sprintf(stringSymPattern, len(s), h.Sum(nil))
+	} else {
+		// Small strings get named directly by their contents.
+		symname = strconv.Quote(s)
+	}
+
+	symdata := base.Ctxt.Lookup(stringSymPrefix + symname)
+	if !symdata.OnList() {
+		off := dstringdata(symdata, 0, s, pos, "string")
+		objw.Global(symdata, int32(off), obj.DUPOK|obj.RODATA|obj.LOCAL)
+		symdata.Set(obj.AttrContentAddressable, true)
+	}
+
+	return symdata
+}
+
+// fileStringSym returns a symbol for the contents and the size of file.
+// If readonly is true, the symbol shares storage with any literal string
+// or other file with the same content and is placed in a read-only section.
+// If readonly is false, the symbol is a read-write copy separate from any other,
+// for use as the backing store of a []byte.
+// The content hash of file is copied into hash. (If hash is nil, nothing is copied.)
+// The returned symbol contains the data itself, not a string header.
+func fileStringSym(pos src.XPos, file string, readonly bool, hash []byte) (*obj.LSym, int64, error) {
+	f, err := os.Open(file)
+	if err != nil {
+		return nil, 0, err
+	}
+	defer f.Close()
+	info, err := f.Stat()
+	if err != nil {
+		return nil, 0, err
+	}
+	if !info.Mode().IsRegular() {
+		return nil, 0, fmt.Errorf("not a regular file")
+	}
+	size := info.Size()
+	if size <= 1*1024 {
+		data, err := ioutil.ReadAll(f)
+		if err != nil {
+			return nil, 0, err
+		}
+		if int64(len(data)) != size {
+			return nil, 0, fmt.Errorf("file changed between reads")
+		}
+		var sym *obj.LSym
+		if readonly {
+			sym = StringSym(pos, string(data))
+		} else {
+			sym = slicedata(pos, string(data)).Sym().Linksym()
+		}
+		if len(hash) > 0 {
+			sum := sha256.Sum256(data)
+			copy(hash, sum[:])
+		}
+		return sym, size, nil
+	}
+	if size > 2e9 {
+		// ggloblsym takes an int32,
+		// and probably the rest of the toolchain
+		// can't handle such big symbols either.
+		// See golang.org/issue/9862.
+		return nil, 0, fmt.Errorf("file too large")
+	}
+
+	// File is too big to read and keep in memory.
+	// Compute hash if needed for read-only content hashing or if the caller wants it.
+	var sum []byte
+	if readonly || len(hash) > 0 {
+		h := sha256.New()
+		n, err := io.Copy(h, f)
+		if err != nil {
+			return nil, 0, err
+		}
+		if n != size {
+			return nil, 0, fmt.Errorf("file changed between reads")
+		}
+		sum = h.Sum(nil)
+		copy(hash, sum)
+	}
+
+	var symdata *obj.LSym
+	if readonly {
+		symname := fmt.Sprintf(stringSymPattern, size, sum)
+		symdata = base.Ctxt.Lookup(stringSymPrefix + symname)
+		if !symdata.OnList() {
+			info := symdata.NewFileInfo()
+			info.Name = file
+			info.Size = size
+			objw.Global(symdata, int32(size), obj.DUPOK|obj.RODATA|obj.LOCAL)
+			// Note: AttrContentAddressable cannot be set here,
+			// because the content-addressable-handling code
+			// does not know about file symbols.
+		}
+	} else {
+		// Emit a zero-length data symbol
+		// and then fix up length and content to use file.
+		symdata = slicedata(pos, "").Sym().Linksym()
+		symdata.Size = size
+		symdata.Type = objabi.SNOPTRDATA
+		info := symdata.NewFileInfo()
+		info.Name = file
+		info.Size = size
+	}
+
+	return symdata, size, nil
+}
+
+var slicedataGen int
+
+func slicedata(pos src.XPos, s string) *ir.Name {
+	slicedataGen++
+	symname := fmt.Sprintf(".gobytes.%d", slicedataGen)
+	sym := types.LocalPkg.Lookup(symname)
+	symnode := typecheck.NewName(sym)
+	sym.Def = symnode
+
+	lsym := sym.Linksym()
+	off := dstringdata(lsym, 0, s, pos, "slice")
+	objw.Global(lsym, int32(off), obj.NOPTR|obj.LOCAL)
+
+	return symnode
+}
+
+func dstringdata(s *obj.LSym, off int, t string, pos src.XPos, what string) int {
+	// Objects that are too large will cause the data section to overflow right away,
+	// causing a cryptic error message by the linker. Check for oversize objects here
+	// and provide a useful error message instead.
+	if int64(len(t)) > 2e9 {
+		base.ErrorfAt(pos, "%v with length %v is too big", what, len(t))
+		return 0
+	}
+
+	s.WriteString(base.Ctxt, int64(off), len(t), t)
+	return off + len(t)
+}
+
+var (
+	funcsymsmu sync.Mutex // protects funcsyms and associated package lookups (see func funcsym)
+	funcsyms   []*types.Sym
+)
+
+// FuncSym returns s·f.
+func FuncSym(s *types.Sym) *types.Sym {
+	// funcsymsmu here serves to protect not just mutations of funcsyms (below),
+	// but also the package lookup of the func sym name,
+	// since this function gets called concurrently from the backend.
+	// There are no other concurrent package lookups in the backend,
+	// except for the types package, which is protected separately.
+	// Reusing funcsymsmu to also cover this package lookup
+	// avoids a general, broader, expensive package lookup mutex.
+	// Note makefuncsym also does package look-up of func sym names,
+	// but that it is only called serially, from the front end.
+	funcsymsmu.Lock()
+	sf, existed := s.Pkg.LookupOK(ir.FuncSymName(s))
+	// Don't export s·f when compiling for dynamic linking.
+	// When dynamically linking, the necessary function
+	// symbols will be created explicitly with makefuncsym.
+	// See the makefuncsym comment for details.
+	if !base.Ctxt.Flag_dynlink && !existed {
+		funcsyms = append(funcsyms, s)
+	}
+	funcsymsmu.Unlock()
+	return sf
+}
+
+// NeedFuncSym ensures that s·f is exported.
+// It is only used with -dynlink.
+// When not compiling for dynamic linking,
+// the funcsyms are created as needed by
+// the packages that use them.
+// Normally we emit the s·f stubs as DUPOK syms,
+// but DUPOK doesn't work across shared library boundaries.
+// So instead, when dynamic linking, we only create
+// the s·f stubs in s's package.
+func NeedFuncSym(s *types.Sym) {
+	if !base.Ctxt.Flag_dynlink {
+		base.Fatalf("makefuncsym dynlink")
+	}
+	if s.IsBlank() {
+		return
+	}
+	if base.Flag.CompilingRuntime && (s.Name == "getg" || s.Name == "getclosureptr" || s.Name == "getcallerpc" || s.Name == "getcallersp") {
+		// runtime.getg(), getclosureptr(), getcallerpc(), and
+		// getcallersp() are not real functions and so do not
+		// get funcsyms.
+		return
+	}
+	if _, existed := s.Pkg.LookupOK(ir.FuncSymName(s)); !existed {
+		funcsyms = append(funcsyms, s)
+	}
+}
+
+func WriteFuncSyms() {
+	sort.Slice(funcsyms, func(i, j int) bool {
+		return funcsyms[i].LinksymName() < funcsyms[j].LinksymName()
+	})
+	for _, s := range funcsyms {
+		sf := s.Pkg.Lookup(ir.FuncSymName(s)).Linksym()
+		objw.SymPtr(sf, 0, s.Linksym(), 0)
+		objw.Global(sf, int32(types.PtrSize), obj.DUPOK|obj.RODATA)
+	}
+}
diff --git a/src/cmd/compile/internal/gc/embed.go b/src/cmd/compile/internal/staticdata/embed.go
similarity index 95%
rename from src/cmd/compile/internal/gc/embed.go
rename to src/cmd/compile/internal/staticdata/embed.go
index 959d8cd7fe..55c9a3356e 100644
--- a/src/cmd/compile/internal/gc/embed.go
+++ b/src/cmd/compile/internal/staticdata/embed.go
@@ -2,19 +2,18 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package staticdata
 
 import (
+	"path"
+	"sort"
+	"strings"
+
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/objw"
-	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
-
-	"path"
-	"sort"
-	"strings"
 )
 
 const (
@@ -132,15 +131,9 @@ func embedFileLess(x, y string) bool {
 	return xdir < ydir || xdir == ydir && xelem < yelem
 }
 
-func dumpembeds() {
-	for _, v := range typecheck.Target.Embeds {
-		initEmbed(v)
-	}
-}
-
-// initEmbed emits the init data for a //go:embed variable,
+// WriteEmbed emits the init data for a //go:embed variable,
 // which is either a string, a []byte, or an embed.FS.
-func initEmbed(v *ir.Name) {
+func WriteEmbed(v *ir.Name) {
 	files := embedFileList(v)
 	switch kind := embedKind(v.Type()); kind {
 	case embedUnknown:
@@ -176,7 +169,7 @@ func initEmbed(v *ir.Name) {
 		const hashSize = 16
 		hash := make([]byte, hashSize)
 		for _, file := range files {
-			off = objw.SymPtr(slicedata, off, stringsym(v.Pos(), file), 0) // file string
+			off = objw.SymPtr(slicedata, off, StringSym(v.Pos(), file), 0) // file string
 			off = objw.Uintptr(slicedata, off, uint64(len(file)))
 			if strings.HasSuffix(file, "/") {
 				// entry for directory - no data
-- 
GitLab


From de65151e507e7b3c8e46d74f223d7c562177bedc Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 23 Dec 2020 00:55:38 -0500
Subject: [PATCH 0313/2400] [dev.regabi] cmd/compile: split out package
 reflectdata [generated]

[git-generate]

cd src/cmd/compile/internal/gc
rf '
	ex {
		import "cmd/compile/internal/base"
		thearch.LinkArch.Name -> base.Ctxt.Arch.Name
	}

	# Move out of reflect.go a few functions that should stay.
	mv addsignats obj.go
	mv deferstruct ssa.go

	# Export reflectdata API.
	mv zerosize ZeroSize
	mv hmap MapType
	mv bmap MapBucketType
	mv hiter MapIterType
	mv addsignat NeedRuntimeType
	mv typename TypePtr
	mv typenamesym TypeSym
	mv typesymprefix TypeSymPrefix
	mv itabsym ITabSym
	mv tracksym TrackSym
	mv zeroaddr ZeroAddr
	mv itabname ITabAddr
	mv ifaceMethodOffset InterfaceMethodOffset
	mv peekitabs CompileITabs
	mv addptabs CollectPTabs
	mv algtype AlgType
	mv dtypesym WriteType
	mv dumpbasictypes WriteBasicTypes
	mv dumpimportstrings WriteImportStrings
	mv dumpsignats WriteRuntimeTypes
	mv dumptabs WriteTabs
	mv eqinterface EqInterface
	mv eqstring EqString

	mv GCProg gcProg
	mv EqCanPanic eqCanPanic
	mv IsRegularMemory isRegularMemory
	mv Sig typeSig

	mv hashmem alg.go
	mv CollectPTabs genwrapper ZeroSize reflect.go
	mv alg.go reflect.go cmd/compile/internal/reflectdata
'

Change-Id: Iaae9da9e9fad5f772f5216004823ccff2ea8f139
Reviewed-on: https://go-review.googlesource.com/c/go/+/279475
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/abiutils_test.go  |   5 +-
 src/cmd/compile/internal/gc/go.go             |   2 -
 src/cmd/compile/internal/gc/main.go           |  11 +-
 src/cmd/compile/internal/gc/obj.go            |  60 +--
 src/cmd/compile/internal/gc/order.go          |   3 +-
 src/cmd/compile/internal/gc/pgen.go           |   3 +-
 src/cmd/compile/internal/gc/range.go          |   5 +-
 src/cmd/compile/internal/gc/sinit.go          |   5 +-
 src/cmd/compile/internal/gc/ssa.go            |  52 ++-
 src/cmd/compile/internal/gc/subr.go           | 140 +------
 src/cmd/compile/internal/gc/walk.go           |  81 ++--
 .../internal/{gc => reflectdata}/alg.go       |  78 ++--
 .../internal/{gc => reflectdata}/reflect.go   | 379 +++++++++++-------
 13 files changed, 418 insertions(+), 406 deletions(-)
 rename src/cmd/compile/internal/{gc => reflectdata}/alg.go (93%)
 rename src/cmd/compile/internal/{gc => reflectdata}/reflect.go (84%)

diff --git a/src/cmd/compile/internal/gc/abiutils_test.go b/src/cmd/compile/internal/gc/abiutils_test.go
index fe9a838688..4b2a30d00c 100644
--- a/src/cmd/compile/internal/gc/abiutils_test.go
+++ b/src/cmd/compile/internal/gc/abiutils_test.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"bufio"
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/reflectdata"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -38,10 +39,10 @@ func TestMain(m *testing.M) {
 	types.PtrSize = thearch.LinkArch.PtrSize
 	types.RegSize = thearch.LinkArch.RegSize
 	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
-		return typenamesym(t).Linksym()
+		return reflectdata.TypeSym(t).Linksym()
 	}
 	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
-		return typenamesym(t).Linksym()
+		return reflectdata.TypeSym(t).Linksym()
 	}
 	typecheck.Init()
 	os.Exit(m.Run())
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index 6f97d43fef..ba838a5ff5 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -12,8 +12,6 @@ import (
 
 var pragcgobuf [][]string
 
-var zerosize int64
-
 // interface to back end
 
 type Arch struct {
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index bb6ace6562..e66b877fd0 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -15,6 +15,7 @@ import (
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/noder"
+	"cmd/compile/internal/reflectdata"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/staticdata"
 	"cmd/compile/internal/typecheck"
@@ -190,19 +191,19 @@ func Main(archInit func(*Arch)) {
 	types.RegSize = thearch.LinkArch.RegSize
 	types.MaxWidth = thearch.MAXWIDTH
 	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
-		return typenamesym(t).Linksym()
+		return reflectdata.TypeSym(t).Linksym()
 	}
 
 	typecheck.Target = new(ir.Package)
 
 	typecheck.NeedFuncSym = staticdata.NeedFuncSym
-	typecheck.NeedITab = func(t, iface *types.Type) { itabname(t, iface) }
-	typecheck.NeedRuntimeType = addsignat // TODO(rsc): typenamesym for lock?
+	typecheck.NeedITab = func(t, iface *types.Type) { reflectdata.ITabAddr(t, iface) }
+	typecheck.NeedRuntimeType = reflectdata.NeedRuntimeType // TODO(rsc): typenamesym for lock?
 
 	base.AutogeneratedPos = makePos(src.NewFileBase("<autogenerated>", "<autogenerated>"), 1, 0)
 
 	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
-		return typenamesym(t).Linksym()
+		return reflectdata.TypeSym(t).Linksym()
 	}
 	typecheck.Init()
 
@@ -282,7 +283,7 @@ func Main(archInit func(*Arch)) {
 	// the right side of OCONVIFACE so that methods
 	// can be de-virtualized during compilation.
 	ir.CurFunc = nil
-	peekitabs()
+	reflectdata.CompileITabs()
 
 	// Compile top level functions.
 	// Don't use range--walk can add functions to Target.Decls.
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 50935d4e98..4db2ad9d4a 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -8,6 +8,7 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/objw"
+	"cmd/compile/internal/reflectdata"
 	"cmd/compile/internal/staticdata"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
@@ -112,14 +113,14 @@ func dumpdata() {
 
 	dumpglobls(typecheck.Target.Externs)
 	staticdata.WriteFuncSyms()
-	addptabs()
+	reflectdata.CollectPTabs()
 	numExports := len(typecheck.Target.Exports)
 	addsignats(typecheck.Target.Externs)
-	dumpsignats()
-	dumptabs()
-	numPTabs, numITabs := CountTabs()
-	dumpimportstrings()
-	dumpbasictypes()
+	reflectdata.WriteRuntimeTypes()
+	reflectdata.WriteTabs()
+	numPTabs, numITabs := reflectdata.CountTabs()
+	reflectdata.WriteImportStrings()
+	reflectdata.WriteBasicTypes()
 	dumpembeds()
 
 	// Calls to dumpsignats can generate functions,
@@ -138,7 +139,7 @@ func dumpdata() {
 		}
 		numDecls = len(typecheck.Target.Decls)
 		compileFunctions()
-		dumpsignats()
+		reflectdata.WriteRuntimeTypes()
 		if numDecls == len(typecheck.Target.Decls) {
 			break
 		}
@@ -147,9 +148,9 @@ func dumpdata() {
 	// Dump extra globals.
 	dumpglobls(typecheck.Target.Externs[numExterns:])
 
-	if zerosize > 0 {
+	if reflectdata.ZeroSize > 0 {
 		zero := ir.Pkgs.Map.Lookup("zero")
-		objw.Global(zero.Linksym(), int32(zerosize), obj.DUPOK|obj.RODATA)
+		objw.Global(zero.Linksym(), int32(reflectdata.ZeroSize), obj.DUPOK|obj.RODATA)
 	}
 
 	addGCLocals()
@@ -157,7 +158,7 @@ func dumpdata() {
 	if numExports != len(typecheck.Target.Exports) {
 		base.Fatalf("Target.Exports changed after compile functions loop")
 	}
-	newNumPTabs, newNumITabs := CountTabs()
+	newNumPTabs, newNumITabs := reflectdata.CountTabs()
 	if newNumPTabs != numPTabs {
 		base.Fatalf("ptabs changed after compile functions loop")
 	}
@@ -184,36 +185,6 @@ func dumpLinkerObj(bout *bio.Writer) {
 	obj.WriteObjFile(base.Ctxt, bout)
 }
 
-func addptabs() {
-	if !base.Ctxt.Flag_dynlink || types.LocalPkg.Name != "main" {
-		return
-	}
-	for _, exportn := range typecheck.Target.Exports {
-		s := exportn.Sym()
-		nn := ir.AsNode(s.Def)
-		if nn == nil {
-			continue
-		}
-		if nn.Op() != ir.ONAME {
-			continue
-		}
-		n := nn.(*ir.Name)
-		if !types.IsExported(s.Name) {
-			continue
-		}
-		if s.Pkg.Name != "main" {
-			continue
-		}
-		if n.Type().Kind() == types.TFUNC && n.Class_ == ir.PFUNC {
-			// function
-			ptabs = append(ptabs, ptabEntry{s: s, t: s.Def.Type()})
-		} else {
-			// variable
-			ptabs = append(ptabs, ptabEntry{s: s, t: types.NewPtr(s.Def.Type())})
-		}
-	}
-}
-
 func dumpGlobal(n *ir.Name) {
 	if n.Type() == nil {
 		base.Fatalf("external %v nil type\n", n)
@@ -373,3 +344,12 @@ func dumpembeds() {
 		staticdata.WriteEmbed(v)
 	}
 }
+
+func addsignats(dcls []ir.Node) {
+	// copy types from dcl list to signatset
+	for _, n := range dcls {
+		if n.Op() == ir.OTYPE {
+			reflectdata.NeedRuntimeType(n.Type())
+		}
+	}
+}
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 32a355ae6b..d1c5bb04a1 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -8,6 +8,7 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/escape"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/reflectdata"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
@@ -882,7 +883,7 @@ func (o *Order) stmt(n ir.Node) {
 
 			// n.Prealloc is the temp for the iterator.
 			// hiter contains pointers and needs to be zeroed.
-			n.Prealloc = o.newTemp(hiter(n.Type()), true)
+			n.Prealloc = o.newTemp(reflectdata.MapIterType(n.Type()), true)
 		}
 		o.exprListInPlace(n.Vars)
 		if orderBody {
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index dcba5c7ecb..4d990e7dba 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -9,6 +9,7 @@ import (
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/liveness"
 	"cmd/compile/internal/objw"
+	"cmd/compile/internal/reflectdata"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
@@ -225,7 +226,7 @@ func compile(fn *ir.Func) {
 		switch n.Class_ {
 		case ir.PPARAM, ir.PPARAMOUT, ir.PAUTO:
 			if liveness.ShouldTrack(n) && n.Addrtaken() {
-				dtypesym(n.Type())
+				reflectdata.WriteType(n.Type())
 				// Also make sure we allocate a linker symbol
 				// for the stack object data, for the same reason.
 				if fn.LSym.Func().StackObjects == nil {
diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index c040811932..4ba0654aef 100644
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/reflectdata"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/sys"
@@ -180,7 +181,7 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		fn := typecheck.LookupRuntime("mapiterinit")
 
 		fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem(), th)
-		init = append(init, mkcall1(fn, nil, nil, typename(t), ha, typecheck.NodAddr(hit)))
+		init = append(init, mkcall1(fn, nil, nil, reflectdata.TypePtr(t), ha, typecheck.NodAddr(hit)))
 		nfor.Cond = ir.NewBinaryExpr(base.Pos, ir.ONE, ir.NewSelectorExpr(base.Pos, ir.ODOT, hit, keysym), typecheck.NodNil())
 
 		fn = typecheck.LookupRuntime("mapiternext")
@@ -383,7 +384,7 @@ func mapClear(m ir.Node) ir.Node {
 	// instantiate mapclear(typ *type, hmap map[any]any)
 	fn := typecheck.LookupRuntime("mapclear")
 	fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem())
-	n := mkcall1(fn, nil, nil, typename(t), m)
+	n := mkcall1(fn, nil, nil, reflectdata.TypePtr(t), m)
 	return walkstmt(typecheck.Stmt(n))
 }
 
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index d818be94a4..337b67af46 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/reflectdata"
 	"cmd/compile/internal/staticdata"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
@@ -314,9 +315,9 @@ func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *type
 
 		var itab *ir.AddrExpr
 		if typ.IsEmptyInterface() {
-			itab = typename(val.Type())
+			itab = reflectdata.TypePtr(val.Type())
 		} else {
-			itab = itabname(val.Type(), typ)
+			itab = reflectdata.ITabAddr(val.Type(), typ)
 		}
 
 		// Create a copy of l to modify while we emit data.
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 51eeb9315a..997bcb6d5e 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -20,6 +20,7 @@ import (
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/liveness"
 	"cmd/compile/internal/objw"
+	"cmd/compile/internal/reflectdata"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/staticdata"
 	"cmd/compile/internal/typecheck"
@@ -89,7 +90,7 @@ func initssaconfig() {
 	_ = types.NewPtr(types.Types[types.TINT64])                             // *int64
 	_ = types.NewPtr(types.ErrorType)                                       // *error
 	types.NewPtrCacheEnabled = false
-	ssaConfig = ssa.NewConfig(thearch.LinkArch.Name, *types_, base.Ctxt, base.Flag.N == 0)
+	ssaConfig = ssa.NewConfig(base.Ctxt.Arch.Name, *types_, base.Ctxt, base.Flag.N == 0)
 	ssaConfig.SoftFloat = thearch.SoftFloat
 	ssaConfig.Race = base.Flag.Race
 	ssaCaches = make([]ssa.Cache, base.Flag.LowerC)
@@ -134,7 +135,7 @@ func initssaconfig() {
 	ir.Syms.Zerobase = typecheck.LookupRuntimeVar("zerobase")
 
 	// asm funcs with special ABI
-	if thearch.LinkArch.Name == "amd64" {
+	if base.Ctxt.Arch.Name == "amd64" {
 		GCWriteBarrierReg = map[int16]*obj.LSym{
 			x86.REG_AX: typecheck.LookupRuntimeFunc("gcWriteBarrier"),
 			x86.REG_CX: typecheck.LookupRuntimeFunc("gcWriteBarrierCX"),
@@ -389,7 +390,7 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 
 	s.hasOpenDefers = base.Flag.N == 0 && s.hasdefer && !s.curfn.OpenCodedDeferDisallowed()
 	switch {
-	case s.hasOpenDefers && (base.Ctxt.Flag_shared || base.Ctxt.Flag_dynlink) && thearch.LinkArch.Name == "386":
+	case s.hasOpenDefers && (base.Ctxt.Flag_shared || base.Ctxt.Flag_dynlink) && base.Ctxt.Arch.Name == "386":
 		// Don't support open-coded defers for 386 ONLY when using shared
 		// libraries, because there is extra code (added by rewriteToUseGot())
 		// preceding the deferreturn/ret code that is generated by gencallret()
@@ -6427,7 +6428,7 @@ func emitStackObjects(e *ssafn, pp *objw.Progs) {
 		if !types.TypeSym(v.Type()).Siggen() {
 			e.Fatalf(v.Pos(), "stack object's type symbol not generated for type %s", v.Type())
 		}
-		off = objw.SymPtr(x, off, dtypesym(v.Type()), 0)
+		off = objw.SymPtr(x, off, reflectdata.WriteType(v.Type()), 0)
 	}
 
 	// Emit a funcdata pointing at the stack object data.
@@ -7247,7 +7248,7 @@ func (e *ssafn) SplitArray(name ssa.LocalSlot) ssa.LocalSlot {
 }
 
 func (e *ssafn) DerefItab(it *obj.LSym, offset int64) *obj.LSym {
-	return itabsym(it, offset)
+	return reflectdata.ITabSym(it, offset)
 }
 
 // SplitSlot returns a slot representing the data of parent starting at offset.
@@ -7411,3 +7412,44 @@ func max8(a, b int8) int8 {
 	}
 	return b
 }
+
+// deferstruct makes a runtime._defer structure, with additional space for
+// stksize bytes of args.
+func deferstruct(stksize int64) *types.Type {
+	makefield := func(name string, typ *types.Type) *types.Field {
+		// Unlike the global makefield function, this one needs to set Pkg
+		// because these types might be compared (in SSA CSE sorting).
+		// TODO: unify this makefield and the global one above.
+		sym := &types.Sym{Name: name, Pkg: types.LocalPkg}
+		return types.NewField(src.NoXPos, sym, typ)
+	}
+	argtype := types.NewArray(types.Types[types.TUINT8], stksize)
+	argtype.Width = stksize
+	argtype.Align = 1
+	// These fields must match the ones in runtime/runtime2.go:_defer and
+	// cmd/compile/internal/gc/ssa.go:(*state).call.
+	fields := []*types.Field{
+		makefield("siz", types.Types[types.TUINT32]),
+		makefield("started", types.Types[types.TBOOL]),
+		makefield("heap", types.Types[types.TBOOL]),
+		makefield("openDefer", types.Types[types.TBOOL]),
+		makefield("sp", types.Types[types.TUINTPTR]),
+		makefield("pc", types.Types[types.TUINTPTR]),
+		// Note: the types here don't really matter. Defer structures
+		// are always scanned explicitly during stack copying and GC,
+		// so we make them uintptr type even though they are real pointers.
+		makefield("fn", types.Types[types.TUINTPTR]),
+		makefield("_panic", types.Types[types.TUINTPTR]),
+		makefield("link", types.Types[types.TUINTPTR]),
+		makefield("framepc", types.Types[types.TUINTPTR]),
+		makefield("varp", types.Types[types.TUINTPTR]),
+		makefield("fd", types.Types[types.TUINTPTR]),
+		makefield("args", argtype),
+	}
+
+	// build struct holding the above fields
+	s := types.NewStruct(types.NoPkg, fields)
+	s.SetNoalg(true)
+	types.CalcStructSize(s)
+	return s
+}
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 362c5162b6..89baaf7eee 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -6,9 +6,8 @@ package gc
 
 import (
 	"cmd/compile/internal/base"
-	"cmd/compile/internal/escape"
-	"cmd/compile/internal/inline"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/reflectdata"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
@@ -319,144 +318,9 @@ func cheapexpr(n ir.Node, init *ir.Nodes) ir.Node {
 	return copyexpr(n, n.Type(), init)
 }
 
-// Generate a wrapper function to convert from
-// a receiver of type T to a receiver of type U.
-// That is,
-//
-//	func (t T) M() {
-//		...
-//	}
-//
-// already exists; this function generates
-//
-//	func (u U) M() {
-//		u.M()
-//	}
-//
-// where the types T and U are such that u.M() is valid
-// and calls the T.M method.
-// The resulting function is for use in method tables.
-//
-//	rcvr - U
-//	method - M func (t T)(), a TFIELD type struct
-//	newnam - the eventual mangled name of this function
-func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
-	if false && base.Flag.LowerR != 0 {
-		fmt.Printf("genwrapper rcvrtype=%v method=%v newnam=%v\n", rcvr, method, newnam)
-	}
-
-	// Only generate (*T).M wrappers for T.M in T's own package.
-	if rcvr.IsPtr() && rcvr.Elem() == method.Type.Recv().Type &&
-		rcvr.Elem().Sym() != nil && rcvr.Elem().Sym().Pkg != types.LocalPkg {
-		return
-	}
-
-	// Only generate I.M wrappers for I in I's own package
-	// but keep doing it for error.Error (was issue #29304).
-	if rcvr.IsInterface() && rcvr.Sym() != nil && rcvr.Sym().Pkg != types.LocalPkg && rcvr != types.ErrorType {
-		return
-	}
-
-	base.Pos = base.AutogeneratedPos
-	typecheck.DeclContext = ir.PEXTERN
-
-	tfn := ir.NewFuncType(base.Pos,
-		ir.NewField(base.Pos, typecheck.Lookup(".this"), nil, rcvr),
-		typecheck.NewFuncParams(method.Type.Params(), true),
-		typecheck.NewFuncParams(method.Type.Results(), false))
-
-	fn := typecheck.DeclFunc(newnam, tfn)
-	fn.SetDupok(true)
-
-	nthis := ir.AsNode(tfn.Type().Recv().Nname)
-
-	methodrcvr := method.Type.Recv().Type
-
-	// generate nil pointer check for better error
-	if rcvr.IsPtr() && rcvr.Elem() == methodrcvr {
-		// generating wrapper from *T to T.
-		n := ir.NewIfStmt(base.Pos, nil, nil, nil)
-		n.Cond = ir.NewBinaryExpr(base.Pos, ir.OEQ, nthis, typecheck.NodNil())
-		call := ir.NewCallExpr(base.Pos, ir.OCALL, typecheck.LookupRuntime("panicwrap"), nil)
-		n.Body = []ir.Node{call}
-		fn.Body.Append(n)
-	}
-
-	dot := typecheck.AddImplicitDots(ir.NewSelectorExpr(base.Pos, ir.OXDOT, nthis, method.Sym))
-
-	// generate call
-	// It's not possible to use a tail call when dynamic linking on ppc64le. The
-	// bad scenario is when a local call is made to the wrapper: the wrapper will
-	// call the implementation, which might be in a different module and so set
-	// the TOC to the appropriate value for that module. But if it returns
-	// directly to the wrapper's caller, nothing will reset it to the correct
-	// value for that function.
-	if !base.Flag.Cfg.Instrumenting && rcvr.IsPtr() && methodrcvr.IsPtr() && method.Embedded != 0 && !types.IsInterfaceMethod(method.Type) && !(thearch.LinkArch.Name == "ppc64le" && base.Ctxt.Flag_dynlink) {
-		// generate tail call: adjust pointer receiver and jump to embedded method.
-		left := dot.X // skip final .M
-		if !left.Type().IsPtr() {
-			left = typecheck.NodAddr(left)
-		}
-		as := ir.NewAssignStmt(base.Pos, nthis, typecheck.ConvNop(left, rcvr))
-		fn.Body.Append(as)
-		fn.Body.Append(ir.NewBranchStmt(base.Pos, ir.ORETJMP, ir.MethodSym(methodrcvr, method.Sym)))
-	} else {
-		fn.SetWrapper(true) // ignore frame for panic+recover matching
-		call := ir.NewCallExpr(base.Pos, ir.OCALL, dot, nil)
-		call.Args.Set(ir.ParamNames(tfn.Type()))
-		call.IsDDD = tfn.Type().IsVariadic()
-		if method.Type.NumResults() > 0 {
-			ret := ir.NewReturnStmt(base.Pos, nil)
-			ret.Results = []ir.Node{call}
-			fn.Body.Append(ret)
-		} else {
-			fn.Body.Append(call)
-		}
-	}
-
-	if false && base.Flag.LowerR != 0 {
-		ir.DumpList("genwrapper body", fn.Body)
-	}
-
-	typecheck.FinishFuncBody()
-	if base.Debug.DclStack != 0 {
-		types.CheckDclstack()
-	}
-
-	typecheck.Func(fn)
-	ir.CurFunc = fn
-	typecheck.Stmts(fn.Body)
-
-	// Inline calls within (*T).M wrappers. This is safe because we only
-	// generate those wrappers within the same compilation unit as (T).M.
-	// TODO(mdempsky): Investigate why we can't enable this more generally.
-	if rcvr.IsPtr() && rcvr.Elem() == method.Type.Recv().Type && rcvr.Elem().Sym() != nil {
-		inline.InlineCalls(fn)
-	}
-	escape.Batch([]*ir.Func{fn}, false)
-
-	ir.CurFunc = nil
-	typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
-}
-
-func hashmem(t *types.Type) ir.Node {
-	sym := ir.Pkgs.Runtime.Lookup("memhash")
-
-	n := typecheck.NewName(sym)
-	ir.MarkFunc(n)
-	n.SetType(typecheck.NewFuncType(nil, []*ir.Field{
-		ir.NewField(base.Pos, nil, nil, types.NewPtr(t)),
-		ir.NewField(base.Pos, nil, nil, types.Types[types.TUINTPTR]),
-		ir.NewField(base.Pos, nil, nil, types.Types[types.TUINTPTR]),
-	}, []*ir.Field{
-		ir.NewField(base.Pos, nil, nil, types.Types[types.TUINTPTR]),
-	}))
-	return n
-}
-
 func ngotype(n ir.Node) *types.Sym {
 	if n.Type() != nil {
-		return typenamesym(n.Type())
+		return reflectdata.TypeSym(n.Type())
 	}
 	return nil
 }
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 9c2484f3dc..9b49b06c34 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -8,6 +8,7 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/escape"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/reflectdata"
 	"cmd/compile/internal/staticdata"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
@@ -594,12 +595,12 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		n := n.(*ir.TypeAssertExpr)
 		n.X = walkexpr(n.X, init)
 		// Set up interface type addresses for back end.
-		n.Ntype = typename(n.Type())
+		n.Ntype = reflectdata.TypePtr(n.Type())
 		if n.Op() == ir.ODOTTYPE {
-			n.Ntype.(*ir.AddrExpr).Alloc = typename(n.X.Type())
+			n.Ntype.(*ir.AddrExpr).Alloc = reflectdata.TypePtr(n.X.Type())
 		}
 		if !n.Type().IsInterface() && !n.X.Type().IsEmptyInterface() {
-			n.Itab = []ir.Node{itabname(n.Type(), n.X.Type())}
+			n.Itab = []ir.Node{reflectdata.ITabAddr(n.Type(), n.X.Type())}
 		}
 		return n
 
@@ -781,7 +782,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 				// Left in place for back end.
 				// Do not add a new write barrier.
 				// Set up address of type for back end.
-				r.(*ir.CallExpr).X = typename(r.Type().Elem())
+				r.(*ir.CallExpr).X = reflectdata.TypePtr(r.Type().Elem())
 				return as
 			}
 			// Otherwise, lowered for race detector.
@@ -870,11 +871,11 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		var call *ir.CallExpr
 		if w := t.Elem().Width; w <= zeroValSize {
 			fn := mapfn(mapaccess2[fast], t)
-			call = mkcall1(fn, fn.Type().Results(), init, typename(t), r.X, key)
+			call = mkcall1(fn, fn.Type().Results(), init, reflectdata.TypePtr(t), r.X, key)
 		} else {
 			fn := mapfn("mapaccess2_fat", t)
-			z := zeroaddr(w)
-			call = mkcall1(fn, fn.Type().Results(), init, typename(t), r.X, key, z)
+			z := reflectdata.ZeroAddr(w)
+			call = mkcall1(fn, fn.Type().Results(), init, reflectdata.TypePtr(t), r.X, key, z)
 		}
 
 		// mapaccess2* returns a typed bool, but due to spec changes,
@@ -915,7 +916,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			// order.stmt made sure key is addressable.
 			key = typecheck.NodAddr(key)
 		}
-		return mkcall1(mapfndel(mapdelete[fast], t), nil, init, typename(t), map_, key)
+		return mkcall1(mapfndel(mapdelete[fast], t), nil, init, reflectdata.TypePtr(t), map_, key)
 
 	case ir.OAS2DOTTYPE:
 		n := n.(*ir.AssignListStmt)
@@ -937,9 +938,9 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		// typeword generates the type word of the interface value.
 		typeword := func() ir.Node {
 			if toType.IsEmptyInterface() {
-				return typename(fromType)
+				return reflectdata.TypePtr(fromType)
 			}
-			return itabname(fromType, toType)
+			return reflectdata.ITabAddr(fromType, toType)
 		}
 
 		// Optimize convT2E or convT2I as a two-word copy when T is pointer-shaped.
@@ -1048,7 +1049,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		var tab ir.Node
 		if fromType.IsInterface() {
 			// convI2I
-			tab = typename(toType)
+			tab = reflectdata.TypePtr(toType)
 		} else {
 			// convT2x
 			tab = typeword()
@@ -1218,7 +1219,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 				// order.expr made sure key is addressable.
 				key = typecheck.NodAddr(key)
 			}
-			call = mkcall1(mapfn(mapassign[fast], t), nil, init, typename(t), map_, key)
+			call = mkcall1(mapfn(mapassign[fast], t), nil, init, reflectdata.TypePtr(t), map_, key)
 		} else {
 			// m[k] is not the target of an assignment.
 			fast := mapfast(t)
@@ -1229,10 +1230,10 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			}
 
 			if w := t.Elem().Width; w <= zeroValSize {
-				call = mkcall1(mapfn(mapaccess1[fast], t), types.NewPtr(t.Elem()), init, typename(t), map_, key)
+				call = mkcall1(mapfn(mapaccess1[fast], t), types.NewPtr(t.Elem()), init, reflectdata.TypePtr(t), map_, key)
 			} else {
-				z := zeroaddr(w)
-				call = mkcall1(mapfn("mapaccess1_fat", t), types.NewPtr(t.Elem()), init, typename(t), map_, key, z)
+				z := reflectdata.ZeroAddr(w)
+				call = mkcall1(mapfn("mapaccess1_fat", t), types.NewPtr(t.Elem()), init, reflectdata.TypePtr(t), map_, key, z)
 			}
 		}
 		call.SetType(types.NewPtr(t.Elem()))
@@ -1340,12 +1341,12 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			argtype = types.Types[types.TINT]
 		}
 
-		return mkcall1(chanfn(fnname, 1, n.Type()), n.Type(), init, typename(n.Type()), typecheck.Conv(size, argtype))
+		return mkcall1(chanfn(fnname, 1, n.Type()), n.Type(), init, reflectdata.TypePtr(n.Type()), typecheck.Conv(size, argtype))
 
 	case ir.OMAKEMAP:
 		n := n.(*ir.MakeExpr)
 		t := n.Type()
-		hmapType := hmap(t)
+		hmapType := reflectdata.MapType(t)
 		hint := n.Len
 
 		// var h *hmap
@@ -1365,7 +1366,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			// Maximum key and elem size is 128 bytes, larger objects
 			// are stored with an indirection. So max bucket size is 2048+eps.
 			if !ir.IsConst(hint, constant.Int) ||
-				constant.Compare(hint.Val(), token.LEQ, constant.MakeInt64(BUCKETSIZE)) {
+				constant.Compare(hint.Val(), token.LEQ, constant.MakeInt64(reflectdata.BUCKETSIZE)) {
 
 				// In case hint is larger than BUCKETSIZE runtime.makemap
 				// will allocate the buckets on the heap, see #20184
@@ -1376,11 +1377,11 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 				//     h.buckets = b
 				// }
 
-				nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OLE, hint, ir.NewInt(BUCKETSIZE)), nil, nil)
+				nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OLE, hint, ir.NewInt(reflectdata.BUCKETSIZE)), nil, nil)
 				nif.Likely = true
 
 				// var bv bmap
-				bv := typecheck.Temp(bmap(t))
+				bv := typecheck.Temp(reflectdata.MapBucketType(t))
 				nif.Body.Append(ir.NewAssignStmt(base.Pos, bv, nil))
 
 				// b = &bv
@@ -1394,7 +1395,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			}
 		}
 
-		if ir.IsConst(hint, constant.Int) && constant.Compare(hint.Val(), token.LEQ, constant.MakeInt64(BUCKETSIZE)) {
+		if ir.IsConst(hint, constant.Int) && constant.Compare(hint.Val(), token.LEQ, constant.MakeInt64(reflectdata.BUCKETSIZE)) {
 			// Handling make(map[any]any) and
 			// make(map[any]any, hint) where hint <= BUCKETSIZE
 			// special allows for faster map initialization and
@@ -1442,7 +1443,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 		fn := typecheck.LookupRuntime(fnname)
 		fn = typecheck.SubstArgTypes(fn, hmapType, t.Key(), t.Elem())
-		return mkcall1(fn, n.Type(), init, typename(n.Type()), typecheck.Conv(hint, argtype), h)
+		return mkcall1(fn, n.Type(), init, reflectdata.TypePtr(n.Type()), typecheck.Conv(hint, argtype), h)
 
 	case ir.OMAKESLICE:
 		n := n.(*ir.MakeExpr)
@@ -1511,7 +1512,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		m.SetType(t)
 
 		fn := typecheck.LookupRuntime(fnname)
-		m.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), typecheck.Conv(len, argtype), typecheck.Conv(cap, argtype))
+		m.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, reflectdata.TypePtr(t.Elem()), typecheck.Conv(len, argtype), typecheck.Conv(cap, argtype))
 		m.Ptr.MarkNonNil()
 		m.LenCap = []ir.Node{typecheck.Conv(len, types.Types[types.TINT]), typecheck.Conv(cap, types.Types[types.TINT])}
 		return walkexpr(typecheck.Expr(m), init)
@@ -1565,7 +1566,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		// instantiate makeslicecopy(typ *byte, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointer
 		fn := typecheck.LookupRuntime("makeslicecopy")
 		s := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
-		s.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), length, copylen, typecheck.Conv(copyptr, types.Types[types.TUNSAFEPTR]))
+		s.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, reflectdata.TypePtr(t.Elem()), length, copylen, typecheck.Conv(copyptr, types.Types[types.TUNSAFEPTR]))
 		s.Ptr.MarkNonNil()
 		s.LenCap = []ir.Node{length, length}
 		s.SetType(t)
@@ -1709,7 +1710,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 // markTypeUsedInInterface marks that type t is converted to an interface.
 // This information is used in the linker in dead method elimination.
 func markTypeUsedInInterface(t *types.Type, from *obj.LSym) {
-	tsym := typenamesym(t).Linksym()
+	tsym := reflectdata.TypeSym(t).Linksym()
 	// Emit a marker relocation. The linker will know the type is converted
 	// to an interface if "from" is reachable.
 	r := obj.Addrel(from)
@@ -1722,13 +1723,13 @@ func markTypeUsedInInterface(t *types.Type, from *obj.LSym) {
 func markUsedIfaceMethod(n *ir.CallExpr) {
 	dot := n.X.(*ir.SelectorExpr)
 	ityp := dot.X.Type()
-	tsym := typenamesym(ityp).Linksym()
+	tsym := reflectdata.TypeSym(ityp).Linksym()
 	r := obj.Addrel(ir.CurFunc.LSym)
 	r.Sym = tsym
 	// dot.Xoffset is the method index * Widthptr (the offset of code pointer
 	// in itab).
 	midx := dot.Offset / int64(types.PtrSize)
-	r.Add = ifaceMethodOffset(ityp, midx)
+	r.Add = reflectdata.InterfaceMethodOffset(ityp, midx)
 	r.Type = objabi.R_USEIFACEMETHOD
 }
 
@@ -2095,7 +2096,7 @@ func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 
 func callnew(t *types.Type) ir.Node {
 	types.CalcSize(t)
-	n := ir.NewUnaryExpr(base.Pos, ir.ONEWOBJ, typename(t))
+	n := ir.NewUnaryExpr(base.Pos, ir.ONEWOBJ, reflectdata.TypePtr(t))
 	n.SetType(types.NewPtr(t))
 	n.SetTypecheck(1)
 	n.MarkNonNil()
@@ -2589,7 +2590,7 @@ func mapfast(t *types.Type) int {
 	if t.Elem().Width > 128 {
 		return mapslow
 	}
-	switch algtype(t.Key()) {
+	switch reflectdata.AlgType(t.Key()) {
 	case types.AMEM32:
 		if !t.Key().HasPointers() {
 			return mapfast32
@@ -2733,7 +2734,7 @@ func appendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	fn = typecheck.SubstArgTypes(fn, elemtype, elemtype)
 
 	// s = growslice(T, s, n)
-	nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, s, mkcall1(fn, s.Type(), nif.PtrInit(), typename(elemtype), s, nn))}
+	nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, s, mkcall1(fn, s.Type(), nif.PtrInit(), reflectdata.TypePtr(elemtype), s, nn))}
 	nodes.Append(nif)
 
 	// s = s[:n]
@@ -2756,7 +2757,7 @@ func appendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 		fn = typecheck.SubstArgTypes(fn, l1.Type().Elem(), l2.Type().Elem())
 		ptr1, len1 := backingArrayPtrLen(cheapexpr(slice, &nodes))
 		ptr2, len2 := backingArrayPtrLen(l2)
-		ncopy = mkcall1(fn, types.Types[types.TINT], &nodes, typename(elemtype), ptr1, len1, ptr2, len2)
+		ncopy = mkcall1(fn, types.Types[types.TINT], &nodes, reflectdata.TypePtr(elemtype), ptr1, len1, ptr2, len2)
 	} else if base.Flag.Cfg.Instrumenting && !base.Flag.CompilingRuntime {
 		// rely on runtime to instrument:
 		//  copy(s[len(l1):], l2)
@@ -2903,7 +2904,7 @@ func extendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	fn = typecheck.SubstArgTypes(fn, elemtype, elemtype)
 
 	// s = growslice(T, s, n)
-	nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, s, mkcall1(fn, s.Type(), nif.PtrInit(), typename(elemtype), s, nn))}
+	nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, s, mkcall1(fn, s.Type(), nif.PtrInit(), reflectdata.TypePtr(elemtype), s, nn))}
 	nodes = append(nodes, nif)
 
 	// s = s[:n]
@@ -3025,7 +3026,7 @@ func walkappend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
 	fn := typecheck.LookupRuntime("growslice") //   growslice(<type>, old []T, mincap int) (ret []T)
 	fn = typecheck.SubstArgTypes(fn, ns.Type().Elem(), ns.Type().Elem())
 
-	nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, ns, mkcall1(fn, ns.Type(), nif.PtrInit(), typename(ns.Type().Elem()), ns,
+	nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, ns, mkcall1(fn, ns.Type(), nif.PtrInit(), reflectdata.TypePtr(ns.Type().Elem()), ns,
 		ir.NewBinaryExpr(base.Pos, ir.OADD, ir.NewUnaryExpr(base.Pos, ir.OLEN, ns), na)))}
 
 	l = append(l, nif)
@@ -3073,7 +3074,7 @@ func copyany(n *ir.BinaryExpr, init *ir.Nodes, runtimecall bool) ir.Node {
 		ptrL, lenL := backingArrayPtrLen(n.X)
 		n.Y = cheapexpr(n.Y, init)
 		ptrR, lenR := backingArrayPtrLen(n.Y)
-		return mkcall1(fn, n.Type(), init, typename(n.X.Type().Elem()), ptrL, lenL, ptrR, lenR)
+		return mkcall1(fn, n.Type(), init, reflectdata.TypePtr(n.X.Type().Elem()), ptrL, lenL, ptrR, lenR)
 	}
 
 	if runtimecall {
@@ -3146,7 +3147,7 @@ func eqfor(t *types.Type) (n ir.Node, needsize bool) {
 		n = typecheck.SubstArgTypes(n, t, t)
 		return n, true
 	case types.ASPECIAL:
-		sym := typesymprefix(".eq", t)
+		sym := reflectdata.TypeSymPrefix(".eq", t)
 		n := typecheck.NewName(sym)
 		ir.MarkFunc(n)
 		n.SetType(typecheck.NewFuncType(nil, []*ir.Field{
@@ -3200,7 +3201,7 @@ func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 		//   l.tab != nil && l.tab._type == type(r)
 		var eqtype ir.Node
 		tab := ir.NewUnaryExpr(base.Pos, ir.OITAB, l)
-		rtyp := typename(r.Type())
+		rtyp := reflectdata.TypePtr(r.Type())
 		if l.Type().IsEmptyInterface() {
 			tab.SetType(types.NewPtr(types.Types[types.TUINT8]))
 			tab.SetTypecheck(1)
@@ -3424,7 +3425,7 @@ func tracecmpArg(n ir.Node, t *types.Type, init *ir.Nodes) ir.Node {
 func walkcompareInterface(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 	n.Y = cheapexpr(n.Y, init)
 	n.X = cheapexpr(n.X, init)
-	eqtab, eqdata := eqinterface(n.X, n.Y)
+	eqtab, eqdata := reflectdata.EqInterface(n.X, n.Y)
 	var cmp ir.Node
 	if n.Op() == ir.OEQ {
 		cmp = ir.NewLogicalExpr(base.Pos, ir.OANDAND, eqtab, eqdata)
@@ -3538,7 +3539,7 @@ func walkcompareString(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 		// prepare for rewrite below
 		n.X = cheapexpr(n.X, init)
 		n.Y = cheapexpr(n.Y, init)
-		eqlen, eqmem := eqstring(n.X, n.Y)
+		eqlen, eqmem := reflectdata.EqString(n.X, n.Y)
 		// quick check of len before full compare for == or !=.
 		// memequal then tests equality up to length len.
 		if n.Op() == ir.OEQ {
@@ -3728,7 +3729,7 @@ func usefield(n *ir.SelectorExpr) {
 		base.Errorf("tracked field must be exported (upper case)")
 	}
 
-	sym := tracksym(outer, field)
+	sym := reflectdata.TrackSym(outer, field)
 	if ir.CurFunc.FieldTrack == nil {
 		ir.CurFunc.FieldTrack = make(map[*types.Sym]struct{})
 	}
@@ -3946,7 +3947,7 @@ func walkCheckPtrAlignment(n *ir.ConvExpr, init *ir.Nodes, count ir.Node) ir.Nod
 	}
 
 	n.X = cheapexpr(n.X, init)
-	init.Append(mkcall("checkptrAlignment", nil, init, typecheck.ConvNop(n.X, types.Types[types.TUNSAFEPTR]), typename(elem), typecheck.Conv(count, types.Types[types.TUINTPTR])))
+	init.Append(mkcall("checkptrAlignment", nil, init, typecheck.ConvNop(n.X, types.Types[types.TUNSAFEPTR]), reflectdata.TypePtr(elem), typecheck.Conv(count, types.Types[types.TUINTPTR])))
 	return n
 }
 
diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/reflectdata/alg.go
similarity index 93%
rename from src/cmd/compile/internal/gc/alg.go
rename to src/cmd/compile/internal/reflectdata/alg.go
index 4fc8cf04ef..8391486e50 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/reflectdata/alg.go
@@ -2,38 +2,39 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package reflectdata
 
 import (
+	"fmt"
+	"sort"
+
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/objw"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
-	"fmt"
-	"sort"
 )
 
-// IsRegularMemory reports whether t can be compared/hashed as regular memory.
-func IsRegularMemory(t *types.Type) bool {
+// isRegularMemory reports whether t can be compared/hashed as regular memory.
+func isRegularMemory(t *types.Type) bool {
 	a, _ := types.AlgType(t)
 	return a == types.AMEM
 }
 
-// EqCanPanic reports whether == on type t could panic (has an interface somewhere).
+// eqCanPanic reports whether == on type t could panic (has an interface somewhere).
 // t must be comparable.
-func EqCanPanic(t *types.Type) bool {
+func eqCanPanic(t *types.Type) bool {
 	switch t.Kind() {
 	default:
 		return false
 	case types.TINTER:
 		return true
 	case types.TARRAY:
-		return EqCanPanic(t.Elem())
+		return eqCanPanic(t.Elem())
 	case types.TSTRUCT:
 		for _, f := range t.FieldSlice() {
-			if !f.Sym.IsBlank() && EqCanPanic(f.Type) {
+			if !f.Sym.IsBlank() && eqCanPanic(f.Type) {
 				return true
 			}
 		}
@@ -41,9 +42,9 @@ func EqCanPanic(t *types.Type) bool {
 	}
 }
 
-// algtype is like algtype1, except it returns the fixed-width AMEMxx variants
+// AlgType is like algtype1, except it returns the fixed-width AMEMxx variants
 // instead of the general AMEM kind when possible.
-func algtype(t *types.Type) types.AlgKind {
+func AlgType(t *types.Type) types.AlgKind {
 	a, _ := types.AlgType(t)
 	if a == types.AMEM {
 		switch t.Width {
@@ -69,7 +70,7 @@ func algtype(t *types.Type) types.AlgKind {
 // the hash of a value of type t.
 // Note: the generated function must match runtime.typehash exactly.
 func genhash(t *types.Type) *obj.LSym {
-	switch algtype(t) {
+	switch AlgType(t) {
 	default:
 		// genhash is only called for types that have equality
 		base.Fatalf("genhash %v", t)
@@ -119,7 +120,7 @@ func genhash(t *types.Type) *obj.LSym {
 		break
 	}
 
-	closure := typesymprefix(".hashfunc", t).Linksym()
+	closure := TypeSymPrefix(".hashfunc", t).Linksym()
 	if len(closure.P) > 0 { // already generated
 		return closure
 	}
@@ -139,7 +140,7 @@ func genhash(t *types.Type) *obj.LSym {
 		}
 	}
 
-	sym := typesymprefix(".hash", t)
+	sym := TypeSymPrefix(".hash", t)
 	if base.Flag.LowerR != 0 {
 		fmt.Printf("genhash %v %v %v\n", closure, sym, t)
 	}
@@ -199,7 +200,7 @@ func genhash(t *types.Type) *obj.LSym {
 			}
 
 			// Hash non-memory fields with appropriate hash function.
-			if !IsRegularMemory(f.Type) {
+			if !isRegularMemory(f.Type) {
 				hashel := hashfor(f.Type)
 				call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil)
 				nx := ir.NewSelectorExpr(base.Pos, ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
@@ -283,7 +284,7 @@ func hashfor(t *types.Type) ir.Node {
 	default:
 		// Note: the caller of hashfor ensured that this symbol
 		// exists and has a body by calling genhash for t.
-		sym = typesymprefix(".hash", t)
+		sym = TypeSymPrefix(".hash", t)
 	}
 
 	n := typecheck.NewName(sym)
@@ -312,7 +313,7 @@ func sysClosure(name string) *obj.LSym {
 // geneq returns a symbol which is the closure used to compute
 // equality for two objects of type t.
 func geneq(t *types.Type) *obj.LSym {
-	switch algtype(t) {
+	switch AlgType(t) {
 	case types.ANOEQ:
 		// The runtime will panic if it tries to compare
 		// a type with a nil equality function.
@@ -362,11 +363,11 @@ func geneq(t *types.Type) *obj.LSym {
 		break
 	}
 
-	closure := typesymprefix(".eqfunc", t).Linksym()
+	closure := TypeSymPrefix(".eqfunc", t).Linksym()
 	if len(closure.P) > 0 { // already generated
 		return closure
 	}
-	sym := typesymprefix(".eq", t)
+	sym := TypeSymPrefix(".eq", t)
 	if base.Flag.LowerR != 0 {
 		fmt.Printf("geneq %v\n", t)
 	}
@@ -476,12 +477,12 @@ func geneq(t *types.Type) *obj.LSym {
 			// TODO: when the array size is small, unroll the length match checks.
 			checkAll(3, false, func(pi, qi ir.Node) ir.Node {
 				// Compare lengths.
-				eqlen, _ := eqstring(pi, qi)
+				eqlen, _ := EqString(pi, qi)
 				return eqlen
 			})
 			checkAll(1, true, func(pi, qi ir.Node) ir.Node {
 				// Compare contents.
-				_, eqmem := eqstring(pi, qi)
+				_, eqmem := EqString(pi, qi)
 				return eqmem
 			})
 		case types.TFLOAT32, types.TFLOAT64:
@@ -520,8 +521,8 @@ func geneq(t *types.Type) *obj.LSym {
 			}
 
 			// Compare non-memory fields with field equality.
-			if !IsRegularMemory(f.Type) {
-				if EqCanPanic(f.Type) {
+			if !isRegularMemory(f.Type) {
+				if eqCanPanic(f.Type) {
 					// Enforce ordering by starting a new set of reorderable conditions.
 					conds = append(conds, []ir.Node{})
 				}
@@ -529,13 +530,13 @@ func geneq(t *types.Type) *obj.LSym {
 				q := ir.NewSelectorExpr(base.Pos, ir.OXDOT, nq, f.Sym)
 				switch {
 				case f.Type.IsString():
-					eqlen, eqmem := eqstring(p, q)
+					eqlen, eqmem := EqString(p, q)
 					and(eqlen)
 					and(eqmem)
 				default:
 					and(ir.NewBinaryExpr(base.Pos, ir.OEQ, p, q))
 				}
-				if EqCanPanic(f.Type) {
+				if eqCanPanic(f.Type) {
 					// Also enforce ordering after something that can panic.
 					conds = append(conds, []ir.Node{})
 				}
@@ -597,7 +598,7 @@ func geneq(t *types.Type) *obj.LSym {
 	//   return (or goto ret)
 	fn.Body.Append(ir.NewLabelStmt(base.Pos, neq))
 	fn.Body.Append(ir.NewAssignStmt(base.Pos, nr, ir.NewBool(false)))
-	if EqCanPanic(t) || anyCall(fn) {
+	if eqCanPanic(t) || anyCall(fn) {
 		// Epilogue is large, so share it with the equal case.
 		fn.Body.Append(ir.NewBranchStmt(base.Pos, ir.OGOTO, ret))
 	} else {
@@ -655,13 +656,13 @@ func eqfield(p ir.Node, q ir.Node, field *types.Sym) ir.Node {
 	return ne
 }
 
-// eqstring returns the nodes
+// EqString returns the nodes
 //   len(s) == len(t)
 // and
 //   memequal(s.ptr, t.ptr, len(s))
 // which can be used to construct string equality comparison.
 // eqlen must be evaluated before eqmem, and shortcircuiting is required.
-func eqstring(s, t ir.Node) (eqlen *ir.BinaryExpr, eqmem *ir.CallExpr) {
+func EqString(s, t ir.Node) (eqlen *ir.BinaryExpr, eqmem *ir.CallExpr) {
 	s = typecheck.Conv(s, types.Types[types.TSTRING])
 	t = typecheck.Conv(t, types.Types[types.TSTRING])
 	sptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, s)
@@ -680,13 +681,13 @@ func eqstring(s, t ir.Node) (eqlen *ir.BinaryExpr, eqmem *ir.CallExpr) {
 	return cmp, call
 }
 
-// eqinterface returns the nodes
+// EqInterface returns the nodes
 //   s.tab == t.tab (or s.typ == t.typ, as appropriate)
 // and
 //   ifaceeq(s.tab, s.data, t.data) (or efaceeq(s.typ, s.data, t.data), as appropriate)
 // which can be used to construct interface equality comparison.
 // eqtab must be evaluated before eqdata, and shortcircuiting is required.
-func eqinterface(s, t ir.Node) (eqtab *ir.BinaryExpr, eqdata *ir.CallExpr) {
+func EqInterface(s, t ir.Node) (eqtab *ir.BinaryExpr, eqdata *ir.CallExpr) {
 	if !types.Identical(s.Type(), t.Type()) {
 		base.Fatalf("eqinterface %v %v", s.Type(), t.Type())
 	}
@@ -764,9 +765,24 @@ func memrun(t *types.Type, start int) (size int64, next int) {
 			break
 		}
 		// Also, stop before a blank or non-memory field.
-		if f := t.Field(next); f.Sym.IsBlank() || !IsRegularMemory(f.Type) {
+		if f := t.Field(next); f.Sym.IsBlank() || !isRegularMemory(f.Type) {
 			break
 		}
 	}
 	return t.Field(next-1).End() - t.Field(start).Offset, next
 }
+
+func hashmem(t *types.Type) ir.Node {
+	sym := ir.Pkgs.Runtime.Lookup("memhash")
+
+	n := typecheck.NewName(sym)
+	ir.MarkFunc(n)
+	n.SetType(typecheck.NewFuncType(nil, []*ir.Field{
+		ir.NewField(base.Pos, nil, nil, types.NewPtr(t)),
+		ir.NewField(base.Pos, nil, nil, types.Types[types.TUINTPTR]),
+		ir.NewField(base.Pos, nil, nil, types.Types[types.TUINTPTR]),
+	}, []*ir.Field{
+		ir.NewField(base.Pos, nil, nil, types.Types[types.TUINTPTR]),
+	}))
+	return n
+}
diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
similarity index 84%
rename from src/cmd/compile/internal/gc/reflect.go
rename to src/cmd/compile/internal/reflectdata/reflect.go
index 42f441a44a..a5e2fb407a 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -2,11 +2,19 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package reflectdata
 
 import (
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+	"sync"
+
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/bitvec"
+	"cmd/compile/internal/escape"
+	"cmd/compile/internal/inline"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/liveness"
 	"cmd/compile/internal/objw"
@@ -16,11 +24,6 @@ import (
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
 	"cmd/internal/src"
-	"fmt"
-	"os"
-	"sort"
-	"strings"
-	"sync"
 )
 
 type itabEntry struct {
@@ -52,7 +55,7 @@ var (
 	ptabs []ptabEntry
 )
 
-type Sig struct {
+type typeSig struct {
 	name  *types.Sym
 	isym  *types.Sym
 	tsym  *types.Sym
@@ -87,8 +90,8 @@ func makefield(name string, t *types.Type) *types.Field {
 	return types.NewField(src.NoXPos, sym, t)
 }
 
-// bmap makes the map bucket type given the type of the map.
-func bmap(t *types.Type) *types.Type {
+// MapBucketType makes the map bucket type given the type of the map.
+func MapBucketType(t *types.Type) *types.Type {
 	if t.MapType().Bucket != nil {
 		return t.MapType().Bucket
 	}
@@ -194,14 +197,14 @@ func bmap(t *types.Type) *types.Type {
 	return bucket
 }
 
-// hmap builds a type representing a Hmap structure for the given map type.
+// MapType builds a type representing a Hmap structure for the given map type.
 // Make sure this stays in sync with runtime/map.go.
-func hmap(t *types.Type) *types.Type {
+func MapType(t *types.Type) *types.Type {
 	if t.MapType().Hmap != nil {
 		return t.MapType().Hmap
 	}
 
-	bmap := bmap(t)
+	bmap := MapBucketType(t)
 
 	// build a struct:
 	// type hmap struct {
@@ -243,15 +246,15 @@ func hmap(t *types.Type) *types.Type {
 	return hmap
 }
 
-// hiter builds a type representing an Hiter structure for the given map type.
+// MapIterType builds a type representing an Hiter structure for the given map type.
 // Make sure this stays in sync with runtime/map.go.
-func hiter(t *types.Type) *types.Type {
+func MapIterType(t *types.Type) *types.Type {
 	if t.MapType().Hiter != nil {
 		return t.MapType().Hiter
 	}
 
-	hmap := hmap(t)
-	bmap := bmap(t)
+	hmap := MapType(t)
+	bmap := MapBucketType(t)
 
 	// build a struct:
 	// type hiter struct {
@@ -302,50 +305,9 @@ func hiter(t *types.Type) *types.Type {
 	return hiter
 }
 
-// deferstruct makes a runtime._defer structure, with additional space for
-// stksize bytes of args.
-func deferstruct(stksize int64) *types.Type {
-	makefield := func(name string, typ *types.Type) *types.Field {
-		// Unlike the global makefield function, this one needs to set Pkg
-		// because these types might be compared (in SSA CSE sorting).
-		// TODO: unify this makefield and the global one above.
-		sym := &types.Sym{Name: name, Pkg: types.LocalPkg}
-		return types.NewField(src.NoXPos, sym, typ)
-	}
-	argtype := types.NewArray(types.Types[types.TUINT8], stksize)
-	argtype.Width = stksize
-	argtype.Align = 1
-	// These fields must match the ones in runtime/runtime2.go:_defer and
-	// cmd/compile/internal/gc/ssa.go:(*state).call.
-	fields := []*types.Field{
-		makefield("siz", types.Types[types.TUINT32]),
-		makefield("started", types.Types[types.TBOOL]),
-		makefield("heap", types.Types[types.TBOOL]),
-		makefield("openDefer", types.Types[types.TBOOL]),
-		makefield("sp", types.Types[types.TUINTPTR]),
-		makefield("pc", types.Types[types.TUINTPTR]),
-		// Note: the types here don't really matter. Defer structures
-		// are always scanned explicitly during stack copying and GC,
-		// so we make them uintptr type even though they are real pointers.
-		makefield("fn", types.Types[types.TUINTPTR]),
-		makefield("_panic", types.Types[types.TUINTPTR]),
-		makefield("link", types.Types[types.TUINTPTR]),
-		makefield("framepc", types.Types[types.TUINTPTR]),
-		makefield("varp", types.Types[types.TUINTPTR]),
-		makefield("fd", types.Types[types.TUINTPTR]),
-		makefield("args", argtype),
-	}
-
-	// build struct holding the above fields
-	s := types.NewStruct(types.NoPkg, fields)
-	s.SetNoalg(true)
-	types.CalcStructSize(s)
-	return s
-}
-
 // methods returns the methods of the non-interface type t, sorted by name.
 // Generates stub functions as needed.
-func methods(t *types.Type) []*Sig {
+func methods(t *types.Type) []*typeSig {
 	// method type
 	mt := types.ReceiverBaseType(t)
 
@@ -363,7 +325,7 @@ func methods(t *types.Type) []*Sig {
 
 	// make list of methods for t,
 	// generating code if necessary.
-	var ms []*Sig
+	var ms []*typeSig
 	for _, f := range mt.AllMethods().Slice() {
 		if !f.IsMethod() {
 			base.Fatalf("non-method on %v method %v %v\n", mt, f.Sym, f)
@@ -388,7 +350,7 @@ func methods(t *types.Type) []*Sig {
 			continue
 		}
 
-		sig := &Sig{
+		sig := &typeSig{
 			name:  method,
 			isym:  ir.MethodSym(it, method),
 			tsym:  ir.MethodSym(t, method),
@@ -418,8 +380,8 @@ func methods(t *types.Type) []*Sig {
 }
 
 // imethods returns the methods of the interface type t, sorted by name.
-func imethods(t *types.Type) []*Sig {
-	var methods []*Sig
+func imethods(t *types.Type) []*typeSig {
+	var methods []*typeSig
 	for _, f := range t.Fields().Slice() {
 		if f.Type.Kind() != types.TFUNC || f.Sym == nil {
 			continue
@@ -434,7 +396,7 @@ func imethods(t *types.Type) []*Sig {
 			}
 		}
 
-		sig := &Sig{
+		sig := &typeSig{
 			name:  f.Sym,
 			mtype: f.Type,
 			type_: typecheck.NewMethodType(f.Type, nil),
@@ -622,7 +584,7 @@ func dextratype(lsym *obj.LSym, ot int, t *types.Type, dataAdd int) int {
 	}
 
 	for _, a := range m {
-		dtypesym(a.type_)
+		WriteType(a.type_)
 	}
 
 	ot = dgopkgpathOff(lsym, ot, typePkg(t))
@@ -673,7 +635,7 @@ func dextratypeData(lsym *obj.LSym, ot int, t *types.Type) int {
 		nsym := dname(a.name.Name, "", pkg, exported)
 
 		ot = objw.SymPtrOff(lsym, ot, nsym)
-		ot = dmethodptrOff(lsym, ot, dtypesym(a.mtype))
+		ot = dmethodptrOff(lsym, ot, WriteType(a.mtype))
 		ot = dmethodptrOff(lsym, ot, a.isym.Linksym())
 		ot = dmethodptrOff(lsym, ot, a.tsym.Linksym())
 	}
@@ -750,7 +712,7 @@ func dcommontype(lsym *obj.LSym, t *types.Type) int {
 		if t.Sym() != nil || methods(tptr) != nil {
 			sptrWeak = false
 		}
-		sptr = dtypesym(tptr)
+		sptr = WriteType(tptr)
 	}
 
 	gcsym, useGCProg, ptrdata := dgcsym(t)
@@ -782,7 +744,7 @@ func dcommontype(lsym *obj.LSym, t *types.Type) int {
 	if t.Sym() != nil && t.Sym().Name != "" {
 		tflag |= tflagNamed
 	}
-	if IsRegularMemory(t) {
+	if isRegularMemory(t) {
 		tflag |= tflagRegularMemory
 	}
 
@@ -848,20 +810,20 @@ func dcommontype(lsym *obj.LSym, t *types.Type) int {
 	return ot
 }
 
-// tracksym returns the symbol for tracking use of field/method f, assumed
+// TrackSym returns the symbol for tracking use of field/method f, assumed
 // to be a member of struct/interface type t.
-func tracksym(t *types.Type, f *types.Field) *types.Sym {
+func TrackSym(t *types.Type, f *types.Field) *types.Sym {
 	return ir.Pkgs.Track.Lookup(t.ShortString() + "." + f.Sym.Name)
 }
 
-func typesymprefix(prefix string, t *types.Type) *types.Sym {
+func TypeSymPrefix(prefix string, t *types.Type) *types.Sym {
 	p := prefix + "." + t.ShortString()
 	s := types.TypeSymLookup(p)
 
 	// This function is for looking up type-related generated functions
 	// (e.g. eq and hash). Make sure they are indeed generated.
 	signatmu.Lock()
-	addsignat(t)
+	NeedRuntimeType(t)
 	signatmu.Unlock()
 
 	//print("algsym: %s -> %+S\n", p, s);
@@ -869,19 +831,19 @@ func typesymprefix(prefix string, t *types.Type) *types.Sym {
 	return s
 }
 
-func typenamesym(t *types.Type) *types.Sym {
+func TypeSym(t *types.Type) *types.Sym {
 	if t == nil || (t.IsPtr() && t.Elem() == nil) || t.IsUntyped() {
 		base.Fatalf("typenamesym %v", t)
 	}
 	s := types.TypeSym(t)
 	signatmu.Lock()
-	addsignat(t)
+	NeedRuntimeType(t)
 	signatmu.Unlock()
 	return s
 }
 
-func typename(t *types.Type) *ir.AddrExpr {
-	s := typenamesym(t)
+func TypePtr(t *types.Type) *ir.AddrExpr {
+	s := TypeSym(t)
 	if s.Def == nil {
 		n := ir.NewNameAt(src.NoXPos, s)
 		n.SetType(types.Types[types.TUINT8])
@@ -896,7 +858,7 @@ func typename(t *types.Type) *ir.AddrExpr {
 	return n
 }
 
-func itabname(t, itype *types.Type) *ir.AddrExpr {
+func ITabAddr(t, itype *types.Type) *ir.AddrExpr {
 	if t == nil || (t.IsPtr() && t.Elem() == nil) || t.IsUntyped() || !itype.IsInterface() || itype.IsEmptyInterface() {
 		base.Fatalf("itabname(%v, %v)", t, itype)
 	}
@@ -978,7 +940,7 @@ func formalType(t *types.Type) *types.Type {
 	return t
 }
 
-func dtypesym(t *types.Type) *obj.LSym {
+func WriteType(t *types.Type) *obj.LSym {
 	t = formalType(t)
 	if t.IsUntyped() {
 		base.Fatalf("dtypesym %v", t)
@@ -1028,9 +990,9 @@ func dtypesym(t *types.Type) *obj.LSym {
 
 	case types.TARRAY:
 		// ../../../../runtime/type.go:/arrayType
-		s1 := dtypesym(t.Elem())
+		s1 := WriteType(t.Elem())
 		t2 := types.NewSlice(t.Elem())
-		s2 := dtypesym(t2)
+		s2 := WriteType(t2)
 		ot = dcommontype(lsym, t)
 		ot = objw.SymPtr(lsym, ot, s1, 0)
 		ot = objw.SymPtr(lsym, ot, s2, 0)
@@ -1039,14 +1001,14 @@ func dtypesym(t *types.Type) *obj.LSym {
 
 	case types.TSLICE:
 		// ../../../../runtime/type.go:/sliceType
-		s1 := dtypesym(t.Elem())
+		s1 := WriteType(t.Elem())
 		ot = dcommontype(lsym, t)
 		ot = objw.SymPtr(lsym, ot, s1, 0)
 		ot = dextratype(lsym, ot, t, 0)
 
 	case types.TCHAN:
 		// ../../../../runtime/type.go:/chanType
-		s1 := dtypesym(t.Elem())
+		s1 := WriteType(t.Elem())
 		ot = dcommontype(lsym, t)
 		ot = objw.SymPtr(lsym, ot, s1, 0)
 		ot = objw.Uintptr(lsym, ot, uint64(t.ChanDir()))
@@ -1054,15 +1016,15 @@ func dtypesym(t *types.Type) *obj.LSym {
 
 	case types.TFUNC:
 		for _, t1 := range t.Recvs().Fields().Slice() {
-			dtypesym(t1.Type)
+			WriteType(t1.Type)
 		}
 		isddd := false
 		for _, t1 := range t.Params().Fields().Slice() {
 			isddd = t1.IsDDD()
-			dtypesym(t1.Type)
+			WriteType(t1.Type)
 		}
 		for _, t1 := range t.Results().Fields().Slice() {
-			dtypesym(t1.Type)
+			WriteType(t1.Type)
 		}
 
 		ot = dcommontype(lsym, t)
@@ -1082,20 +1044,20 @@ func dtypesym(t *types.Type) *obj.LSym {
 
 		// Array of rtype pointers follows funcType.
 		for _, t1 := range t.Recvs().Fields().Slice() {
-			ot = objw.SymPtr(lsym, ot, dtypesym(t1.Type), 0)
+			ot = objw.SymPtr(lsym, ot, WriteType(t1.Type), 0)
 		}
 		for _, t1 := range t.Params().Fields().Slice() {
-			ot = objw.SymPtr(lsym, ot, dtypesym(t1.Type), 0)
+			ot = objw.SymPtr(lsym, ot, WriteType(t1.Type), 0)
 		}
 		for _, t1 := range t.Results().Fields().Slice() {
-			ot = objw.SymPtr(lsym, ot, dtypesym(t1.Type), 0)
+			ot = objw.SymPtr(lsym, ot, WriteType(t1.Type), 0)
 		}
 
 	case types.TINTER:
 		m := imethods(t)
 		n := len(m)
 		for _, a := range m {
-			dtypesym(a.type_)
+			WriteType(a.type_)
 		}
 
 		// ../../../../runtime/type.go:/interfaceType
@@ -1123,14 +1085,14 @@ func dtypesym(t *types.Type) *obj.LSym {
 			nsym := dname(a.name.Name, "", pkg, exported)
 
 			ot = objw.SymPtrOff(lsym, ot, nsym)
-			ot = objw.SymPtrOff(lsym, ot, dtypesym(a.type_))
+			ot = objw.SymPtrOff(lsym, ot, WriteType(a.type_))
 		}
 
 	// ../../../../runtime/type.go:/mapType
 	case types.TMAP:
-		s1 := dtypesym(t.Key())
-		s2 := dtypesym(t.Elem())
-		s3 := dtypesym(bmap(t))
+		s1 := WriteType(t.Key())
+		s2 := WriteType(t.Elem())
+		s3 := WriteType(MapBucketType(t))
 		hasher := genhash(t.Key())
 
 		ot = dcommontype(lsym, t)
@@ -1154,7 +1116,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 		} else {
 			ot = objw.Uint8(lsym, ot, uint8(t.Elem().Width))
 		}
-		ot = objw.Uint16(lsym, ot, uint16(bmap(t).Width))
+		ot = objw.Uint16(lsym, ot, uint16(MapBucketType(t).Width))
 		if types.IsReflexive(t.Key()) {
 			flags |= 4 // reflexive key
 		}
@@ -1177,7 +1139,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 		}
 
 		// ../../../../runtime/type.go:/ptrType
-		s1 := dtypesym(t.Elem())
+		s1 := WriteType(t.Elem())
 
 		ot = dcommontype(lsym, t)
 		ot = objw.SymPtr(lsym, ot, s1, 0)
@@ -1188,7 +1150,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 	case types.TSTRUCT:
 		fields := t.Fields().Slice()
 		for _, t1 := range fields {
-			dtypesym(t1.Type)
+			WriteType(t1.Type)
 		}
 
 		// All non-exported struct field names within a struct
@@ -1216,7 +1178,7 @@ func dtypesym(t *types.Type) *obj.LSym {
 		for _, f := range fields {
 			// ../../../../runtime/type.go:/structField
 			ot = dnameField(lsym, ot, spkg, f)
-			ot = objw.SymPtr(lsym, ot, dtypesym(f.Type), 0)
+			ot = objw.SymPtr(lsym, ot, WriteType(f.Type), 0)
 			offsetAnon := uint64(f.Offset) << 1
 			if offsetAnon>>1 != uint64(f.Offset) {
 				base.Fatalf("%v: bad field offset for %s", t, f.Sym.Name)
@@ -1257,9 +1219,9 @@ func dtypesym(t *types.Type) *obj.LSym {
 	return lsym
 }
 
-// ifaceMethodOffset returns the offset of the i-th method in the interface
+// InterfaceMethodOffset returns the offset of the i-th method in the interface
 // type descriptor, ityp.
-func ifaceMethodOffset(ityp *types.Type, i int64) int64 {
+func InterfaceMethodOffset(ityp *types.Type, i int64) int64 {
 	// interface type descriptor layout is struct {
 	//   _type        // commonSize
 	//   pkgpath      // 1 word
@@ -1273,7 +1235,7 @@ func ifaceMethodOffset(ityp *types.Type, i int64) int64 {
 
 // for each itabEntry, gather the methods on
 // the concrete type that implement the interface
-func peekitabs() {
+func CompileITabs() {
 	for i := range itabs {
 		tab := &itabs[i]
 		methods := genfun(tab.t, tab.itype)
@@ -1319,11 +1281,11 @@ func genfun(t, it *types.Type) []*obj.LSym {
 	return out
 }
 
-// itabsym uses the information gathered in
+// ITabSym uses the information gathered in
 // peekitabs to de-virtualize interface methods.
 // Since this is called by the SSA backend, it shouldn't
 // generate additional Nodes, Syms, etc.
-func itabsym(it *obj.LSym, offset int64) *obj.LSym {
+func ITabSym(it *obj.LSym, offset int64) *obj.LSym {
 	var syms []*obj.LSym
 	if it == nil {
 		return nil
@@ -1348,24 +1310,15 @@ func itabsym(it *obj.LSym, offset int64) *obj.LSym {
 	return syms[methodnum]
 }
 
-// addsignat ensures that a runtime type descriptor is emitted for t.
-func addsignat(t *types.Type) {
+// NeedRuntimeType ensures that a runtime type descriptor is emitted for t.
+func NeedRuntimeType(t *types.Type) {
 	if _, ok := signatset[t]; !ok {
 		signatset[t] = struct{}{}
 		signatslice = append(signatslice, t)
 	}
 }
 
-func addsignats(dcls []ir.Node) {
-	// copy types from dcl list to signatset
-	for _, n := range dcls {
-		if n.Op() == ir.OTYPE {
-			addsignat(n.Type())
-		}
-	}
-}
-
-func dumpsignats() {
+func WriteRuntimeTypes() {
 	// Process signatset. Use a loop, as dtypesym adds
 	// entries to signatset while it is being processed.
 	signats := make([]typeAndStr, len(signatslice))
@@ -1380,15 +1333,15 @@ func dumpsignats() {
 		sort.Sort(typesByString(signats))
 		for _, ts := range signats {
 			t := ts.t
-			dtypesym(t)
+			WriteType(t)
 			if t.Sym() != nil {
-				dtypesym(types.NewPtr(t))
+				WriteType(types.NewPtr(t))
 			}
 		}
 	}
 }
 
-func dumptabs() {
+func WriteTabs() {
 	// process itabs
 	for _, i := range itabs {
 		// dump empty itab symbol into i.sym
@@ -1399,8 +1352,8 @@ func dumptabs() {
 		//   _      [4]byte
 		//   fun    [1]uintptr // variable sized
 		// }
-		o := objw.SymPtr(i.lsym, 0, dtypesym(i.itype), 0)
-		o = objw.SymPtr(i.lsym, o, dtypesym(i.t), 0)
+		o := objw.SymPtr(i.lsym, 0, WriteType(i.itype), 0)
+		o = objw.SymPtr(i.lsym, o, WriteType(i.t), 0)
 		o = objw.Uint32(i.lsym, o, types.TypeHash(i.t)) // copy of type hash
 		o += 4                                          // skip unused field
 		for _, fn := range genfun(i.t, i.itype) {
@@ -1423,7 +1376,7 @@ func dumptabs() {
 			//	typ  typeOff // pointer to symbol
 			// }
 			nsym := dname(p.s.Name, "", nil, true)
-			tsym := dtypesym(p.t)
+			tsym := WriteType(p.t)
 			ot = objw.SymPtrOff(s, ot, nsym)
 			ot = objw.SymPtrOff(s, ot, tsym)
 			// Plugin exports symbols as interfaces. Mark their types
@@ -1441,14 +1394,14 @@ func dumptabs() {
 	}
 }
 
-func dumpimportstrings() {
+func WriteImportStrings() {
 	// generate import strings for imported packages
 	for _, p := range types.ImportedPkgList() {
 		dimportpath(p)
 	}
 }
 
-func dumpbasictypes() {
+func WriteBasicTypes() {
 	// do basic types if compiling package runtime.
 	// they have to be in at least one package,
 	// and runtime is always loaded implicitly,
@@ -1457,16 +1410,16 @@ func dumpbasictypes() {
 	// but using runtime means fewer copies in object files.
 	if base.Ctxt.Pkgpath == "runtime" {
 		for i := types.Kind(1); i <= types.TBOOL; i++ {
-			dtypesym(types.NewPtr(types.Types[i]))
+			WriteType(types.NewPtr(types.Types[i]))
 		}
-		dtypesym(types.NewPtr(types.Types[types.TSTRING]))
-		dtypesym(types.NewPtr(types.Types[types.TUNSAFEPTR]))
+		WriteType(types.NewPtr(types.Types[types.TSTRING]))
+		WriteType(types.NewPtr(types.Types[types.TUNSAFEPTR]))
 
 		// emit type structs for error and func(error) string.
 		// The latter is the type of an auto-generated wrapper.
-		dtypesym(types.NewPtr(types.ErrorType))
+		WriteType(types.NewPtr(types.ErrorType))
 
-		dtypesym(typecheck.NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, types.ErrorType)}, []*ir.Field{ir.NewField(base.Pos, nil, nil, types.Types[types.TSTRING])}))
+		WriteType(typecheck.NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, types.ErrorType)}, []*ir.Field{ir.NewField(base.Pos, nil, nil, types.Types[types.TSTRING])}))
 
 		// add paths for runtime and main, which 6l imports implicitly.
 		dimportpath(ir.Pkgs.Runtime)
@@ -1611,8 +1564,8 @@ func dgcprog(t *types.Type) (*obj.LSym, int64) {
 	if t.Width == types.BADWIDTH {
 		base.Fatalf("dgcprog: %v badwidth", t)
 	}
-	lsym := typesymprefix(".gcprog", t).Linksym()
-	var p GCProg
+	lsym := TypeSymPrefix(".gcprog", t).Linksym()
+	var p gcProg
 	p.init(lsym)
 	p.emit(t, 0)
 	offset := p.w.BitIndex() * int64(types.PtrSize)
@@ -1623,13 +1576,13 @@ func dgcprog(t *types.Type) (*obj.LSym, int64) {
 	return lsym, offset
 }
 
-type GCProg struct {
+type gcProg struct {
 	lsym   *obj.LSym
 	symoff int
 	w      gcprog.Writer
 }
 
-func (p *GCProg) init(lsym *obj.LSym) {
+func (p *gcProg) init(lsym *obj.LSym) {
 	p.lsym = lsym
 	p.symoff = 4 // first 4 bytes hold program length
 	p.w.Init(p.writeByte)
@@ -1639,11 +1592,11 @@ func (p *GCProg) init(lsym *obj.LSym) {
 	}
 }
 
-func (p *GCProg) writeByte(x byte) {
+func (p *gcProg) writeByte(x byte) {
 	p.symoff = objw.Uint8(p.lsym, p.symoff, x)
 }
 
-func (p *GCProg) end() {
+func (p *gcProg) end() {
 	p.w.End()
 	objw.Uint32(p.lsym, 0, uint32(p.symoff-4))
 	objw.Global(p.lsym, int32(p.symoff), obj.DUPOK|obj.RODATA|obj.LOCAL)
@@ -1652,7 +1605,7 @@ func (p *GCProg) end() {
 	}
 }
 
-func (p *GCProg) emit(t *types.Type, offset int64) {
+func (p *gcProg) emit(t *types.Type, offset int64) {
 	types.CalcSize(t)
 	if !t.HasPointers() {
 		return
@@ -1707,14 +1660,14 @@ func (p *GCProg) emit(t *types.Type, offset int64) {
 	}
 }
 
-// zeroaddr returns the address of a symbol with at least
+// ZeroAddr returns the address of a symbol with at least
 // size bytes of zeros.
-func zeroaddr(size int64) ir.Node {
+func ZeroAddr(size int64) ir.Node {
 	if size >= 1<<31 {
 		base.Fatalf("map elem too big %d", size)
 	}
-	if zerosize < size {
-		zerosize = size
+	if ZeroSize < size {
+		ZeroSize = size
 	}
 	s := ir.Pkgs.Map.Lookup("zero")
 	if s.Def == nil {
@@ -1729,3 +1682,155 @@ func zeroaddr(size int64) ir.Node {
 	z.SetTypecheck(1)
 	return z
 }
+
+func CollectPTabs() {
+	if !base.Ctxt.Flag_dynlink || types.LocalPkg.Name != "main" {
+		return
+	}
+	for _, exportn := range typecheck.Target.Exports {
+		s := exportn.Sym()
+		nn := ir.AsNode(s.Def)
+		if nn == nil {
+			continue
+		}
+		if nn.Op() != ir.ONAME {
+			continue
+		}
+		n := nn.(*ir.Name)
+		if !types.IsExported(s.Name) {
+			continue
+		}
+		if s.Pkg.Name != "main" {
+			continue
+		}
+		if n.Type().Kind() == types.TFUNC && n.Class_ == ir.PFUNC {
+			// function
+			ptabs = append(ptabs, ptabEntry{s: s, t: s.Def.Type()})
+		} else {
+			// variable
+			ptabs = append(ptabs, ptabEntry{s: s, t: types.NewPtr(s.Def.Type())})
+		}
+	}
+}
+
+// Generate a wrapper function to convert from
+// a receiver of type T to a receiver of type U.
+// That is,
+//
+//	func (t T) M() {
+//		...
+//	}
+//
+// already exists; this function generates
+//
+//	func (u U) M() {
+//		u.M()
+//	}
+//
+// where the types T and U are such that u.M() is valid
+// and calls the T.M method.
+// The resulting function is for use in method tables.
+//
+//	rcvr - U
+//	method - M func (t T)(), a TFIELD type struct
+//	newnam - the eventual mangled name of this function
+func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
+	if false && base.Flag.LowerR != 0 {
+		fmt.Printf("genwrapper rcvrtype=%v method=%v newnam=%v\n", rcvr, method, newnam)
+	}
+
+	// Only generate (*T).M wrappers for T.M in T's own package.
+	if rcvr.IsPtr() && rcvr.Elem() == method.Type.Recv().Type &&
+		rcvr.Elem().Sym() != nil && rcvr.Elem().Sym().Pkg != types.LocalPkg {
+		return
+	}
+
+	// Only generate I.M wrappers for I in I's own package
+	// but keep doing it for error.Error (was issue #29304).
+	if rcvr.IsInterface() && rcvr.Sym() != nil && rcvr.Sym().Pkg != types.LocalPkg && rcvr != types.ErrorType {
+		return
+	}
+
+	base.Pos = base.AutogeneratedPos
+	typecheck.DeclContext = ir.PEXTERN
+
+	tfn := ir.NewFuncType(base.Pos,
+		ir.NewField(base.Pos, typecheck.Lookup(".this"), nil, rcvr),
+		typecheck.NewFuncParams(method.Type.Params(), true),
+		typecheck.NewFuncParams(method.Type.Results(), false))
+
+	fn := typecheck.DeclFunc(newnam, tfn)
+	fn.SetDupok(true)
+
+	nthis := ir.AsNode(tfn.Type().Recv().Nname)
+
+	methodrcvr := method.Type.Recv().Type
+
+	// generate nil pointer check for better error
+	if rcvr.IsPtr() && rcvr.Elem() == methodrcvr {
+		// generating wrapper from *T to T.
+		n := ir.NewIfStmt(base.Pos, nil, nil, nil)
+		n.Cond = ir.NewBinaryExpr(base.Pos, ir.OEQ, nthis, typecheck.NodNil())
+		call := ir.NewCallExpr(base.Pos, ir.OCALL, typecheck.LookupRuntime("panicwrap"), nil)
+		n.Body = []ir.Node{call}
+		fn.Body.Append(n)
+	}
+
+	dot := typecheck.AddImplicitDots(ir.NewSelectorExpr(base.Pos, ir.OXDOT, nthis, method.Sym))
+
+	// generate call
+	// It's not possible to use a tail call when dynamic linking on ppc64le. The
+	// bad scenario is when a local call is made to the wrapper: the wrapper will
+	// call the implementation, which might be in a different module and so set
+	// the TOC to the appropriate value for that module. But if it returns
+	// directly to the wrapper's caller, nothing will reset it to the correct
+	// value for that function.
+	if !base.Flag.Cfg.Instrumenting && rcvr.IsPtr() && methodrcvr.IsPtr() && method.Embedded != 0 && !types.IsInterfaceMethod(method.Type) && !(base.Ctxt.Arch.Name == "ppc64le" && base.Ctxt.Flag_dynlink) {
+		// generate tail call: adjust pointer receiver and jump to embedded method.
+		left := dot.X // skip final .M
+		if !left.Type().IsPtr() {
+			left = typecheck.NodAddr(left)
+		}
+		as := ir.NewAssignStmt(base.Pos, nthis, typecheck.ConvNop(left, rcvr))
+		fn.Body.Append(as)
+		fn.Body.Append(ir.NewBranchStmt(base.Pos, ir.ORETJMP, ir.MethodSym(methodrcvr, method.Sym)))
+	} else {
+		fn.SetWrapper(true) // ignore frame for panic+recover matching
+		call := ir.NewCallExpr(base.Pos, ir.OCALL, dot, nil)
+		call.Args.Set(ir.ParamNames(tfn.Type()))
+		call.IsDDD = tfn.Type().IsVariadic()
+		if method.Type.NumResults() > 0 {
+			ret := ir.NewReturnStmt(base.Pos, nil)
+			ret.Results = []ir.Node{call}
+			fn.Body.Append(ret)
+		} else {
+			fn.Body.Append(call)
+		}
+	}
+
+	if false && base.Flag.LowerR != 0 {
+		ir.DumpList("genwrapper body", fn.Body)
+	}
+
+	typecheck.FinishFuncBody()
+	if base.Debug.DclStack != 0 {
+		types.CheckDclstack()
+	}
+
+	typecheck.Func(fn)
+	ir.CurFunc = fn
+	typecheck.Stmts(fn.Body)
+
+	// Inline calls within (*T).M wrappers. This is safe because we only
+	// generate those wrappers within the same compilation unit as (T).M.
+	// TODO(mdempsky): Investigate why we can't enable this more generally.
+	if rcvr.IsPtr() && rcvr.Elem() == method.Type.Recv().Type && rcvr.Elem().Sym() != nil {
+		inline.InlineCalls(fn)
+	}
+	escape.Batch([]*ir.Func{fn}, false)
+
+	ir.CurFunc = nil
+	typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
+}
+
+var ZeroSize int64
-- 
GitLab


From 6c34d2f42077bd7757c942c8d1b466366190b45a Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 23 Dec 2020 00:57:10 -0500
Subject: [PATCH 0314/2400] [dev.regabi] cmd/compile: split out package ssagen
 [generated]

[git-generate]

cd src/cmd/compile/internal/gc
rf '
	# maxOpenDefers is declared in ssa.go but used only by walk.
	mv maxOpenDefers walk.go

	# gc.Arch -> ssagen.Arch
	# It is not as nice but will do for now.
	mv Arch ArchInfo
	mv thearch Arch
	mv Arch ArchInfo arch.go

	# Pull dwarf out of pgen.go.
	mv debuginfo declPos createDwarfVars preInliningDcls \
		createSimpleVars createSimpleVar \
		createComplexVars createComplexVar \
		dwarf.go

	# Pull high-level compilation out of pgen.go,
	# leaving only the SSA code.
	mv compilequeue funccompile compile compilenow \
		compileFunctions isInlinableButNotInlined \
		initLSym \
		compile.go

	mv BoundsCheckFunc GCWriteBarrierReg ssa.go
	mv largeStack largeStackFrames CheckLargeStacks pgen.go

	# All that is left in dcl.go is the nowritebarrierrecCheck
	mv dcl.go nowb.go

	# Export API and unexport non-API.
	mv initssaconfig InitConfig
	mv isIntrinsicCall IsIntrinsicCall
	mv ssaDumpInline DumpInline
	mv initSSATables InitTables
	mv initSSAEnv InitEnv
	mv compileSSA Compile
	mv stackOffset StackOffset
	mv canSSAType TypeOK
	mv SSAGenState State
	mv FwdRefAux fwdRefAux

	mv cgoSymABIs CgoSymABIs
	mv readSymABIs ReadSymABIs
	mv initLSym InitLSym
	mv useABIWrapGen symabiDefs CgoSymABIs ReadSymABIs InitLSym selectLSym makeABIWrapper setupTextLSym abi.go

	mv arch.go abi.go nowb.go phi.go pgen.go pgen_test.go ssa.go cmd/compile/internal/ssagen
'
rm go.go gsubr.go

Change-Id: I47fad6cbf1d1e583fd9139003a08401d7cd048a1
Reviewed-on: https://go-review.googlesource.com/c/go/+/279476
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/amd64/galign.go      |   4 +-
 src/cmd/compile/internal/amd64/ssa.go         |  80 +--
 src/cmd/compile/internal/arm/galign.go        |   6 +-
 src/cmd/compile/internal/arm/ssa.go           |  40 +-
 src/cmd/compile/internal/arm64/galign.go      |   6 +-
 src/cmd/compile/internal/arm64/ssa.go         |  44 +-
 src/cmd/compile/internal/gc/abiutils_test.go  |  15 +-
 src/cmd/compile/internal/gc/compile.go        | 177 ++++++
 .../compile/internal/gc/{pgen.go => dwarf.go} | 568 +++---------------
 src/cmd/compile/internal/gc/main.go           | 164 +----
 src/cmd/compile/internal/gc/racewalk.go       |   3 +-
 src/cmd/compile/internal/gc/range.go          |   3 +-
 src/cmd/compile/internal/gc/subr.go           |  23 +-
 src/cmd/compile/internal/gc/walk.go           |  23 +-
 src/cmd/compile/internal/mips/galign.go       |   6 +-
 src/cmd/compile/internal/mips/ssa.go          |  34 +-
 src/cmd/compile/internal/mips64/galign.go     |   6 +-
 src/cmd/compile/internal/mips64/ssa.go        |  32 +-
 src/cmd/compile/internal/ppc64/galign.go      |   4 +-
 src/cmd/compile/internal/ppc64/ssa.go         |  34 +-
 src/cmd/compile/internal/riscv64/galign.go    |   4 +-
 src/cmd/compile/internal/riscv64/ssa.go       |  36 +-
 src/cmd/compile/internal/s390x/galign.go      |   4 +-
 src/cmd/compile/internal/s390x/ssa.go         |  56 +-
 .../internal/{gc/gsubr.go => ssagen/abi.go}   | 342 +++++++----
 .../internal/{gc/go.go => ssagen/arch.go}     |  22 +-
 .../internal/{gc/dcl.go => ssagen/nowb.go}    |   5 +-
 src/cmd/compile/internal/ssagen/pgen.go       | 279 +++++++++
 .../internal/{gc => ssagen}/pgen_test.go      |   9 +-
 .../compile/internal/{gc => ssagen}/phi.go    |  23 +-
 .../compile/internal/{gc => ssagen}/ssa.go    | 154 ++---
 src/cmd/compile/internal/wasm/ssa.go          |  36 +-
 src/cmd/compile/internal/x86/galign.go        |   4 +-
 src/cmd/compile/internal/x86/ssa.go           |  64 +-
 src/cmd/compile/main.go                       |   3 +-
 35 files changed, 1167 insertions(+), 1146 deletions(-)
 create mode 100644 src/cmd/compile/internal/gc/compile.go
 rename src/cmd/compile/internal/gc/{pgen.go => dwarf.go} (55%)
 rename src/cmd/compile/internal/{gc/gsubr.go => ssagen/abi.go} (69%)
 rename src/cmd/compile/internal/{gc/go.go => ssagen/arch.go} (68%)
 rename src/cmd/compile/internal/{gc/dcl.go => ssagen/nowb.go} (99%)
 create mode 100644 src/cmd/compile/internal/ssagen/pgen.go
 rename src/cmd/compile/internal/{gc => ssagen}/pgen_test.go (99%)
 rename src/cmd/compile/internal/{gc => ssagen}/phi.go (97%)
 rename src/cmd/compile/internal/{gc => ssagen}/ssa.go (98%)

diff --git a/src/cmd/compile/internal/amd64/galign.go b/src/cmd/compile/internal/amd64/galign.go
index af58440502..ce1c402902 100644
--- a/src/cmd/compile/internal/amd64/galign.go
+++ b/src/cmd/compile/internal/amd64/galign.go
@@ -5,13 +5,13 @@
 package amd64
 
 import (
-	"cmd/compile/internal/gc"
+	"cmd/compile/internal/ssagen"
 	"cmd/internal/obj/x86"
 )
 
 var leaptr = x86.ALEAQ
 
-func Init(arch *gc.Arch) {
+func Init(arch *ssagen.ArchInfo) {
 	arch.LinkArch = &x86.Linkamd64
 	arch.REGSP = x86.REGSP
 	arch.MAXWIDTH = 1 << 50
diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index 0150bd296a..da355c49d1 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -9,17 +9,17 @@ import (
 	"math"
 
 	"cmd/compile/internal/base"
-	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/x86"
 )
 
 // markMoves marks any MOVXconst ops that need to avoid clobbering flags.
-func ssaMarkMoves(s *gc.SSAGenState, b *ssa.Block) {
+func ssaMarkMoves(s *ssagen.State, b *ssa.Block) {
 	flive := b.FlagsLiveAtEnd
 	for _, c := range b.ControlValues() {
 		flive = c.Type.IsFlags() || flive
@@ -112,7 +112,7 @@ func moveByType(t *types.Type) obj.As {
 //     dest := dest(To) op src(From)
 // and also returns the created obj.Prog so it
 // may be further adjusted (offset, scale, etc).
-func opregreg(s *gc.SSAGenState, op obj.As, dest, src int16) *obj.Prog {
+func opregreg(s *ssagen.State, op obj.As, dest, src int16) *obj.Prog {
 	p := s.Prog(op)
 	p.From.Type = obj.TYPE_REG
 	p.To.Type = obj.TYPE_REG
@@ -166,7 +166,7 @@ func duff(size int64) (int64, int64) {
 	return off, adj
 }
 
-func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
+func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 	switch v.Op {
 	case ssa.OpAMD64VFMADD231SD:
 		p := s.Prog(v.Op.Asm())
@@ -632,12 +632,12 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 			p.To.Type = obj.TYPE_REG
 			p.To.Reg = o
 		}
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 	case ssa.OpAMD64LEAQ, ssa.OpAMD64LEAL, ssa.OpAMD64LEAW:
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.OpAMD64CMPQ, ssa.OpAMD64CMPL, ssa.OpAMD64CMPW, ssa.OpAMD64CMPB,
@@ -673,7 +673,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Args[1].Reg()
 	case ssa.OpAMD64CMPQconstload, ssa.OpAMD64CMPLconstload, ssa.OpAMD64CMPWconstload, ssa.OpAMD64CMPBconstload:
@@ -681,20 +681,20 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux2(&p.From, v, sc.Off())
+		ssagen.AddAux2(&p.From, v, sc.Off())
 		p.To.Type = obj.TYPE_CONST
 		p.To.Offset = sc.Val()
 	case ssa.OpAMD64CMPQloadidx8, ssa.OpAMD64CMPQloadidx1, ssa.OpAMD64CMPLloadidx4, ssa.OpAMD64CMPLloadidx1, ssa.OpAMD64CMPWloadidx2, ssa.OpAMD64CMPWloadidx1, ssa.OpAMD64CMPBloadidx1:
 		p := s.Prog(v.Op.Asm())
 		memIdx(&p.From, v)
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Args[2].Reg()
 	case ssa.OpAMD64CMPQconstloadidx8, ssa.OpAMD64CMPQconstloadidx1, ssa.OpAMD64CMPLconstloadidx4, ssa.OpAMD64CMPLconstloadidx1, ssa.OpAMD64CMPWconstloadidx2, ssa.OpAMD64CMPWconstloadidx1, ssa.OpAMD64CMPBconstloadidx1:
 		sc := v.AuxValAndOff()
 		p := s.Prog(v.Op.Asm())
 		memIdx(&p.From, v)
-		gc.AddAux2(&p.From, v, sc.Off())
+		ssagen.AddAux2(&p.From, v, sc.Off())
 		p.To.Type = obj.TYPE_CONST
 		p.To.Offset = sc.Val()
 	case ssa.OpAMD64MOVLconst, ssa.OpAMD64MOVQconst:
@@ -734,14 +734,14 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.OpAMD64MOVBloadidx1, ssa.OpAMD64MOVWloadidx1, ssa.OpAMD64MOVLloadidx1, ssa.OpAMD64MOVQloadidx1, ssa.OpAMD64MOVSSloadidx1, ssa.OpAMD64MOVSDloadidx1,
 		ssa.OpAMD64MOVQloadidx8, ssa.OpAMD64MOVSDloadidx8, ssa.OpAMD64MOVLloadidx8, ssa.OpAMD64MOVLloadidx4, ssa.OpAMD64MOVSSloadidx4, ssa.OpAMD64MOVWloadidx2:
 		p := s.Prog(v.Op.Asm())
 		memIdx(&p.From, v)
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.OpAMD64MOVQstore, ssa.OpAMD64MOVSSstore, ssa.OpAMD64MOVSDstore, ssa.OpAMD64MOVLstore, ssa.OpAMD64MOVWstore, ssa.OpAMD64MOVBstore, ssa.OpAMD64MOVOstore,
@@ -753,7 +753,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Reg = v.Args[1].Reg()
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 	case ssa.OpAMD64MOVBstoreidx1, ssa.OpAMD64MOVWstoreidx1, ssa.OpAMD64MOVLstoreidx1, ssa.OpAMD64MOVQstoreidx1, ssa.OpAMD64MOVSSstoreidx1, ssa.OpAMD64MOVSDstoreidx1,
 		ssa.OpAMD64MOVQstoreidx8, ssa.OpAMD64MOVSDstoreidx8, ssa.OpAMD64MOVLstoreidx8, ssa.OpAMD64MOVSSstoreidx4, ssa.OpAMD64MOVLstoreidx4, ssa.OpAMD64MOVWstoreidx2,
 		ssa.OpAMD64ADDLmodifyidx1, ssa.OpAMD64ADDLmodifyidx4, ssa.OpAMD64ADDLmodifyidx8, ssa.OpAMD64ADDQmodifyidx1, ssa.OpAMD64ADDQmodifyidx8,
@@ -765,7 +765,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = v.Args[2].Reg()
 		memIdx(&p.To, v)
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 	case ssa.OpAMD64ADDQconstmodify, ssa.OpAMD64ADDLconstmodify:
 		sc := v.AuxValAndOff()
 		off := sc.Off()
@@ -788,7 +788,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 			p := s.Prog(asm)
 			p.To.Type = obj.TYPE_MEM
 			p.To.Reg = v.Args[0].Reg()
-			gc.AddAux2(&p.To, v, off)
+			ssagen.AddAux2(&p.To, v, off)
 			break
 		}
 		fallthrough
@@ -803,7 +803,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Offset = val
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux2(&p.To, v, off)
+		ssagen.AddAux2(&p.To, v, off)
 
 	case ssa.OpAMD64MOVQstoreconst, ssa.OpAMD64MOVLstoreconst, ssa.OpAMD64MOVWstoreconst, ssa.OpAMD64MOVBstoreconst:
 		p := s.Prog(v.Op.Asm())
@@ -812,7 +812,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Offset = sc.Val()
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux2(&p.To, v, sc.Off())
+		ssagen.AddAux2(&p.To, v, sc.Off())
 	case ssa.OpAMD64MOVQstoreconstidx1, ssa.OpAMD64MOVQstoreconstidx8, ssa.OpAMD64MOVLstoreconstidx1, ssa.OpAMD64MOVLstoreconstidx4, ssa.OpAMD64MOVWstoreconstidx1, ssa.OpAMD64MOVWstoreconstidx2, ssa.OpAMD64MOVBstoreconstidx1,
 		ssa.OpAMD64ADDLconstmodifyidx1, ssa.OpAMD64ADDLconstmodifyidx4, ssa.OpAMD64ADDLconstmodifyidx8, ssa.OpAMD64ADDQconstmodifyidx1, ssa.OpAMD64ADDQconstmodifyidx8,
 		ssa.OpAMD64ANDLconstmodifyidx1, ssa.OpAMD64ANDLconstmodifyidx4, ssa.OpAMD64ANDLconstmodifyidx8, ssa.OpAMD64ANDQconstmodifyidx1, ssa.OpAMD64ANDQconstmodifyidx8,
@@ -837,7 +837,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 			p.From.Type = obj.TYPE_NONE
 		}
 		memIdx(&p.To, v)
-		gc.AddAux2(&p.To, v, sc.Off())
+		ssagen.AddAux2(&p.To, v, sc.Off())
 	case ssa.OpAMD64MOVLQSX, ssa.OpAMD64MOVWQSX, ssa.OpAMD64MOVBQSX, ssa.OpAMD64MOVLQZX, ssa.OpAMD64MOVWQZX, ssa.OpAMD64MOVBQZX,
 		ssa.OpAMD64CVTTSS2SL, ssa.OpAMD64CVTTSD2SL, ssa.OpAMD64CVTTSS2SQ, ssa.OpAMD64CVTTSD2SQ,
 		ssa.OpAMD64CVTSS2SD, ssa.OpAMD64CVTSD2SS:
@@ -867,7 +867,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[1].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 		if v.Reg() != v.Args[0].Reg() {
@@ -893,7 +893,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Reg = r
 		p.From.Index = i
 
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 		if v.Reg() != v.Args[0].Reg() {
@@ -951,7 +951,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 			return
 		}
 		p := s.Prog(loadByType(v.Type))
-		gc.AddrAuto(&p.From, v.Args[0])
+		ssagen.AddrAuto(&p.From, v.Args[0])
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 
@@ -963,16 +963,16 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(storeByType(v.Type))
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddrAuto(&p.To, v)
+		ssagen.AddrAuto(&p.To, v)
 	case ssa.OpAMD64LoweredHasCPUFeature:
 		p := s.Prog(x86.AMOVBQZX)
 		p.From.Type = obj.TYPE_MEM
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.OpAMD64LoweredGetClosurePtr:
 		// Closure pointer is DX.
-		gc.CheckLoweredGetClosurePtr(v)
+		ssagen.CheckLoweredGetClosurePtr(v)
 	case ssa.OpAMD64LoweredGetG:
 		r := v.Reg()
 		// See the comments in cmd/internal/obj/x86/obj6.go
@@ -1029,13 +1029,13 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
 		// arg0 is in DI. Set sym to match where regalloc put arg1.
-		p.To.Sym = gc.GCWriteBarrierReg[v.Args[1].Reg()]
+		p.To.Sym = ssagen.GCWriteBarrierReg[v.Args[1].Reg()]
 
 	case ssa.OpAMD64LoweredPanicBoundsA, ssa.OpAMD64LoweredPanicBoundsB, ssa.OpAMD64LoweredPanicBoundsC:
 		p := s.Prog(obj.ACALL)
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.BoundsCheckFunc[v.AuxInt]
+		p.To.Sym = ssagen.BoundsCheckFunc[v.AuxInt]
 		s.UseArgs(int64(2 * types.PtrSize)) // space used in callee args area by assembly stubs
 
 	case ssa.OpAMD64NEGQ, ssa.OpAMD64NEGL,
@@ -1117,7 +1117,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 
 	case ssa.OpAMD64SETNEF:
 		p := s.Prog(v.Op.Asm())
@@ -1173,7 +1173,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg0()
 	case ssa.OpAMD64XCHGB, ssa.OpAMD64XCHGL, ssa.OpAMD64XCHGQ:
@@ -1186,7 +1186,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Reg = r
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[1].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 	case ssa.OpAMD64XADDLlock, ssa.OpAMD64XADDQlock:
 		r := v.Reg0()
 		if r != v.Args[0].Reg() {
@@ -1198,7 +1198,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Reg = r
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[1].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 	case ssa.OpAMD64CMPXCHGLlock, ssa.OpAMD64CMPXCHGQlock:
 		if v.Args[1].Reg() != x86.REG_AX {
 			v.Fatalf("input[1] not in AX %s", v.LongString())
@@ -1209,7 +1209,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Reg = v.Args[2].Reg()
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 		p = s.Prog(x86.ASETEQ)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg0()
@@ -1220,20 +1220,20 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Reg = v.Args[1].Reg()
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 	case ssa.OpClobber:
 		p := s.Prog(x86.AMOVL)
 		p.From.Type = obj.TYPE_CONST
 		p.From.Offset = 0xdeaddead
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = x86.REG_SP
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 		p = s.Prog(x86.AMOVL)
 		p.From.Type = obj.TYPE_CONST
 		p.From.Offset = 0xdeaddead
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = x86.REG_SP
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 		p.To.Offset += 4
 	default:
 		v.Fatalf("genValue not implemented: %s", v.LongString())
@@ -1259,22 +1259,22 @@ var blockJump = [...]struct {
 	ssa.BlockAMD64NAN: {x86.AJPS, x86.AJPC},
 }
 
-var eqfJumps = [2][2]gc.IndexJump{
+var eqfJumps = [2][2]ssagen.IndexJump{
 	{{Jump: x86.AJNE, Index: 1}, {Jump: x86.AJPS, Index: 1}}, // next == b.Succs[0]
 	{{Jump: x86.AJNE, Index: 1}, {Jump: x86.AJPC, Index: 0}}, // next == b.Succs[1]
 }
-var nefJumps = [2][2]gc.IndexJump{
+var nefJumps = [2][2]ssagen.IndexJump{
 	{{Jump: x86.AJNE, Index: 0}, {Jump: x86.AJPC, Index: 1}}, // next == b.Succs[0]
 	{{Jump: x86.AJNE, Index: 0}, {Jump: x86.AJPS, Index: 0}}, // next == b.Succs[1]
 }
 
-func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
+func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
 	switch b.Kind {
 	case ssa.BlockPlain:
 		if b.Succs[0].Block() != next {
 			p := s.Prog(obj.AJMP)
 			p.To.Type = obj.TYPE_BRANCH
-			s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+			s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
 		}
 	case ssa.BlockDefer:
 		// defer returns in rax:
@@ -1287,11 +1287,11 @@ func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
 		p.To.Reg = x86.REG_AX
 		p = s.Prog(x86.AJNE)
 		p.To.Type = obj.TYPE_BRANCH
-		s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[1].Block()})
+		s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[1].Block()})
 		if b.Succs[0].Block() != next {
 			p := s.Prog(obj.AJMP)
 			p.To.Type = obj.TYPE_BRANCH
-			s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+			s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
 		}
 	case ssa.BlockExit:
 	case ssa.BlockRet:
diff --git a/src/cmd/compile/internal/arm/galign.go b/src/cmd/compile/internal/arm/galign.go
index 20e2f43a91..81959ae0ab 100644
--- a/src/cmd/compile/internal/arm/galign.go
+++ b/src/cmd/compile/internal/arm/galign.go
@@ -5,13 +5,13 @@
 package arm
 
 import (
-	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/ssagen"
 	"cmd/internal/obj/arm"
 	"cmd/internal/objabi"
 )
 
-func Init(arch *gc.Arch) {
+func Init(arch *ssagen.ArchInfo) {
 	arch.LinkArch = &arm.Linkarm
 	arch.REGSP = arm.REGSP
 	arch.MAXWIDTH = (1 << 32) - 1
@@ -20,7 +20,7 @@ func Init(arch *gc.Arch) {
 	arch.Ginsnop = ginsnop
 	arch.Ginsnopdefer = ginsnop
 
-	arch.SSAMarkMoves = func(s *gc.SSAGenState, b *ssa.Block) {}
+	arch.SSAMarkMoves = func(s *ssagen.State, b *ssa.Block) {}
 	arch.SSAGenValue = ssaGenValue
 	arch.SSAGenBlock = ssaGenBlock
 }
diff --git a/src/cmd/compile/internal/arm/ssa.go b/src/cmd/compile/internal/arm/ssa.go
index 30eae59331..729d2dab2d 100644
--- a/src/cmd/compile/internal/arm/ssa.go
+++ b/src/cmd/compile/internal/arm/ssa.go
@@ -10,10 +10,10 @@ import (
 	"math/bits"
 
 	"cmd/compile/internal/base"
-	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/arm"
@@ -93,7 +93,7 @@ func makeshift(reg int16, typ int64, s int64) shift {
 }
 
 // genshift generates a Prog for r = r0 op (r1 shifted by n)
-func genshift(s *gc.SSAGenState, as obj.As, r0, r1, r int16, typ int64, n int64) *obj.Prog {
+func genshift(s *ssagen.State, as obj.As, r0, r1, r int16, typ int64, n int64) *obj.Prog {
 	p := s.Prog(as)
 	p.From.Type = obj.TYPE_SHIFT
 	p.From.Offset = int64(makeshift(r1, typ, n))
@@ -111,7 +111,7 @@ func makeregshift(r1 int16, typ int64, r2 int16) shift {
 }
 
 // genregshift generates a Prog for r = r0 op (r1 shifted by r2)
-func genregshift(s *gc.SSAGenState, as obj.As, r0, r1, r2, r int16, typ int64) *obj.Prog {
+func genregshift(s *ssagen.State, as obj.As, r0, r1, r2, r int16, typ int64) *obj.Prog {
 	p := s.Prog(as)
 	p.From.Type = obj.TYPE_SHIFT
 	p.From.Offset = int64(makeregshift(r1, typ, r2))
@@ -145,7 +145,7 @@ func getBFC(v uint32) (uint32, uint32) {
 	return 0xffffffff, 0
 }
 
-func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
+func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 	switch v.Op {
 	case ssa.OpCopy, ssa.OpARMMOVWreg:
 		if v.Type.IsMemory() {
@@ -183,7 +183,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 			return
 		}
 		p := s.Prog(loadByType(v.Type))
-		gc.AddrAuto(&p.From, v.Args[0])
+		ssagen.AddrAuto(&p.From, v.Args[0])
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.OpStoreReg:
@@ -194,7 +194,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(storeByType(v.Type))
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddrAuto(&p.To, v)
+		ssagen.AddrAuto(&p.To, v)
 	case ssa.OpARMADD,
 		ssa.OpARMADC,
 		ssa.OpARMSUB,
@@ -545,10 +545,10 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 			v.Fatalf("aux is of unknown type %T", v.Aux)
 		case *obj.LSym:
 			wantreg = "SB"
-			gc.AddAux(&p.From, v)
+			ssagen.AddAux(&p.From, v)
 		case *ir.Name:
 			wantreg = "SP"
-			gc.AddAux(&p.From, v)
+			ssagen.AddAux(&p.From, v)
 		case nil:
 			// No sym, just MOVW $off(SP), R
 			wantreg = "SP"
@@ -568,7 +568,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.OpARMMOVBstore,
@@ -581,7 +581,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Reg = v.Args[1].Reg()
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 	case ssa.OpARMMOVWloadidx, ssa.OpARMMOVBUloadidx, ssa.OpARMMOVBloadidx, ssa.OpARMMOVHUloadidx, ssa.OpARMMOVHloadidx:
 		// this is just shift 0 bits
 		fallthrough
@@ -712,13 +712,13 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(obj.ACALL)
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.BoundsCheckFunc[v.AuxInt]
+		p.To.Sym = ssagen.BoundsCheckFunc[v.AuxInt]
 		s.UseArgs(8) // space used in callee args area by assembly stubs
 	case ssa.OpARMLoweredPanicExtendA, ssa.OpARMLoweredPanicExtendB, ssa.OpARMLoweredPanicExtendC:
 		p := s.Prog(obj.ACALL)
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.ExtendCheckFunc[v.AuxInt]
+		p.To.Sym = ssagen.ExtendCheckFunc[v.AuxInt]
 		s.UseArgs(12) // space used in callee args area by assembly stubs
 	case ssa.OpARMDUFFZERO:
 		p := s.Prog(obj.ADUFFZERO)
@@ -737,7 +737,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(arm.AMOVB)
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = arm.REGTMP
 		if logopt.Enabled() {
@@ -846,7 +846,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.To.Reg = v.Reg()
 	case ssa.OpARMLoweredGetClosurePtr:
 		// Closure pointer is R7 (arm.REGCTXT).
-		gc.CheckLoweredGetClosurePtr(v)
+		ssagen.CheckLoweredGetClosurePtr(v)
 	case ssa.OpARMLoweredGetCallerSP:
 		// caller's SP is FixedFrameSize below the address of the first arg
 		p := s.Prog(arm.AMOVW)
@@ -901,24 +901,24 @@ var blockJump = map[ssa.BlockKind]struct {
 }
 
 // To model a 'LEnoov' ('<=' without overflow checking) branching
-var leJumps = [2][2]gc.IndexJump{
+var leJumps = [2][2]ssagen.IndexJump{
 	{{Jump: arm.ABEQ, Index: 0}, {Jump: arm.ABPL, Index: 1}}, // next == b.Succs[0]
 	{{Jump: arm.ABMI, Index: 0}, {Jump: arm.ABEQ, Index: 0}}, // next == b.Succs[1]
 }
 
 // To model a 'GTnoov' ('>' without overflow checking) branching
-var gtJumps = [2][2]gc.IndexJump{
+var gtJumps = [2][2]ssagen.IndexJump{
 	{{Jump: arm.ABMI, Index: 1}, {Jump: arm.ABEQ, Index: 1}}, // next == b.Succs[0]
 	{{Jump: arm.ABEQ, Index: 1}, {Jump: arm.ABPL, Index: 0}}, // next == b.Succs[1]
 }
 
-func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
+func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
 	switch b.Kind {
 	case ssa.BlockPlain:
 		if b.Succs[0].Block() != next {
 			p := s.Prog(obj.AJMP)
 			p.To.Type = obj.TYPE_BRANCH
-			s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+			s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
 		}
 
 	case ssa.BlockDefer:
@@ -931,11 +931,11 @@ func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
 		p.Reg = arm.REG_R0
 		p = s.Prog(arm.ABNE)
 		p.To.Type = obj.TYPE_BRANCH
-		s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[1].Block()})
+		s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[1].Block()})
 		if b.Succs[0].Block() != next {
 			p := s.Prog(obj.AJMP)
 			p.To.Type = obj.TYPE_BRANCH
-			s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+			s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
 		}
 
 	case ssa.BlockExit:
diff --git a/src/cmd/compile/internal/arm64/galign.go b/src/cmd/compile/internal/arm64/galign.go
index 40d6e17ae2..d3db37e16f 100644
--- a/src/cmd/compile/internal/arm64/galign.go
+++ b/src/cmd/compile/internal/arm64/galign.go
@@ -5,12 +5,12 @@
 package arm64
 
 import (
-	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/ssagen"
 	"cmd/internal/obj/arm64"
 )
 
-func Init(arch *gc.Arch) {
+func Init(arch *ssagen.ArchInfo) {
 	arch.LinkArch = &arm64.Linkarm64
 	arch.REGSP = arm64.REGSP
 	arch.MAXWIDTH = 1 << 50
@@ -20,7 +20,7 @@ func Init(arch *gc.Arch) {
 	arch.Ginsnop = ginsnop
 	arch.Ginsnopdefer = ginsnop
 
-	arch.SSAMarkMoves = func(s *gc.SSAGenState, b *ssa.Block) {}
+	arch.SSAMarkMoves = func(s *ssagen.State, b *ssa.Block) {}
 	arch.SSAGenValue = ssaGenValue
 	arch.SSAGenBlock = ssaGenBlock
 }
diff --git a/src/cmd/compile/internal/arm64/ssa.go b/src/cmd/compile/internal/arm64/ssa.go
index 9bdea3ee2a..8d25fa8592 100644
--- a/src/cmd/compile/internal/arm64/ssa.go
+++ b/src/cmd/compile/internal/arm64/ssa.go
@@ -8,10 +8,10 @@ import (
 	"math"
 
 	"cmd/compile/internal/base"
-	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/arm64"
@@ -83,7 +83,7 @@ func makeshift(reg int16, typ int64, s int64) int64 {
 }
 
 // genshift generates a Prog for r = r0 op (r1 shifted by n)
-func genshift(s *gc.SSAGenState, as obj.As, r0, r1, r int16, typ int64, n int64) *obj.Prog {
+func genshift(s *ssagen.State, as obj.As, r0, r1, r int16, typ int64, n int64) *obj.Prog {
 	p := s.Prog(as)
 	p.From.Type = obj.TYPE_SHIFT
 	p.From.Offset = makeshift(r1, typ, n)
@@ -112,7 +112,7 @@ func genIndexedOperand(v *ssa.Value) obj.Addr {
 	return mop
 }
 
-func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
+func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 	switch v.Op {
 	case ssa.OpCopy, ssa.OpARM64MOVDreg:
 		if v.Type.IsMemory() {
@@ -150,7 +150,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 			return
 		}
 		p := s.Prog(loadByType(v.Type))
-		gc.AddrAuto(&p.From, v.Args[0])
+		ssagen.AddrAuto(&p.From, v.Args[0])
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.OpStoreReg:
@@ -161,7 +161,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(storeByType(v.Type))
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddrAuto(&p.To, v)
+		ssagen.AddrAuto(&p.To, v)
 	case ssa.OpARM64ADD,
 		ssa.OpARM64SUB,
 		ssa.OpARM64AND,
@@ -395,10 +395,10 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 			v.Fatalf("aux is of unknown type %T", v.Aux)
 		case *obj.LSym:
 			wantreg = "SB"
-			gc.AddAux(&p.From, v)
+			ssagen.AddAux(&p.From, v)
 		case *ir.Name:
 			wantreg = "SP"
-			gc.AddAux(&p.From, v)
+			ssagen.AddAux(&p.From, v)
 		case nil:
 			// No sym, just MOVD $off(SP), R
 			wantreg = "SP"
@@ -419,7 +419,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.OpARM64MOVBloadidx,
@@ -446,7 +446,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg0()
 	case ssa.OpARM64MOVBstore,
@@ -463,7 +463,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Reg = v.Args[1].Reg()
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 	case ssa.OpARM64MOVBstoreidx,
 		ssa.OpARM64MOVHstoreidx,
 		ssa.OpARM64MOVWstoreidx,
@@ -484,7 +484,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Offset = int64(v.Args[2].Reg())
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 	case ssa.OpARM64MOVBstorezero,
 		ssa.OpARM64MOVHstorezero,
 		ssa.OpARM64MOVWstorezero,
@@ -494,7 +494,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Reg = arm64.REGZERO
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 	case ssa.OpARM64MOVBstorezeroidx,
 		ssa.OpARM64MOVHstorezeroidx,
 		ssa.OpARM64MOVWstorezeroidx,
@@ -513,7 +513,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Offset = int64(arm64.REGZERO)
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 	case ssa.OpARM64BFI,
 		ssa.OpARM64BFXIL:
 		r := v.Reg()
@@ -1027,14 +1027,14 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(obj.ACALL)
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.BoundsCheckFunc[v.AuxInt]
+		p.To.Sym = ssagen.BoundsCheckFunc[v.AuxInt]
 		s.UseArgs(16) // space used in callee args area by assembly stubs
 	case ssa.OpARM64LoweredNilCheck:
 		// Issue a load which will fault if arg is nil.
 		p := s.Prog(arm64.AMOVB)
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = arm64.REGTMP
 		if logopt.Enabled() {
@@ -1065,7 +1065,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.To.Reg = v.Reg()
 	case ssa.OpARM64LoweredGetClosurePtr:
 		// Closure pointer is R26 (arm64.REGCTXT).
-		gc.CheckLoweredGetClosurePtr(v)
+		ssagen.CheckLoweredGetClosurePtr(v)
 	case ssa.OpARM64LoweredGetCallerSP:
 		// caller's SP is FixedFrameSize below the address of the first arg
 		p := s.Prog(arm64.AMOVD)
@@ -1134,24 +1134,24 @@ var blockJump = map[ssa.BlockKind]struct {
 }
 
 // To model a 'LEnoov' ('<=' without overflow checking) branching
-var leJumps = [2][2]gc.IndexJump{
+var leJumps = [2][2]ssagen.IndexJump{
 	{{Jump: arm64.ABEQ, Index: 0}, {Jump: arm64.ABPL, Index: 1}}, // next == b.Succs[0]
 	{{Jump: arm64.ABMI, Index: 0}, {Jump: arm64.ABEQ, Index: 0}}, // next == b.Succs[1]
 }
 
 // To model a 'GTnoov' ('>' without overflow checking) branching
-var gtJumps = [2][2]gc.IndexJump{
+var gtJumps = [2][2]ssagen.IndexJump{
 	{{Jump: arm64.ABMI, Index: 1}, {Jump: arm64.ABEQ, Index: 1}}, // next == b.Succs[0]
 	{{Jump: arm64.ABEQ, Index: 1}, {Jump: arm64.ABPL, Index: 0}}, // next == b.Succs[1]
 }
 
-func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
+func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
 	switch b.Kind {
 	case ssa.BlockPlain:
 		if b.Succs[0].Block() != next {
 			p := s.Prog(obj.AJMP)
 			p.To.Type = obj.TYPE_BRANCH
-			s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+			s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
 		}
 
 	case ssa.BlockDefer:
@@ -1164,11 +1164,11 @@ func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
 		p.Reg = arm64.REG_R0
 		p = s.Prog(arm64.ABNE)
 		p.To.Type = obj.TYPE_BRANCH
-		s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[1].Block()})
+		s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[1].Block()})
 		if b.Succs[0].Block() != next {
 			p := s.Prog(obj.AJMP)
 			p.To.Type = obj.TYPE_BRANCH
-			s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+			s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
 		}
 
 	case ssa.BlockExit:
diff --git a/src/cmd/compile/internal/gc/abiutils_test.go b/src/cmd/compile/internal/gc/abiutils_test.go
index 4b2a30d00c..a421a229dc 100644
--- a/src/cmd/compile/internal/gc/abiutils_test.go
+++ b/src/cmd/compile/internal/gc/abiutils_test.go
@@ -8,6 +8,7 @@ import (
 	"bufio"
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/reflectdata"
+	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -28,16 +29,16 @@ var configAMD64 = ABIConfig{
 }
 
 func TestMain(m *testing.M) {
-	thearch.LinkArch = &x86.Linkamd64
-	thearch.REGSP = x86.REGSP
-	thearch.MAXWIDTH = 1 << 50
-	types.MaxWidth = thearch.MAXWIDTH
-	base.Ctxt = obj.Linknew(thearch.LinkArch)
+	ssagen.Arch.LinkArch = &x86.Linkamd64
+	ssagen.Arch.REGSP = x86.REGSP
+	ssagen.Arch.MAXWIDTH = 1 << 50
+	types.MaxWidth = ssagen.Arch.MAXWIDTH
+	base.Ctxt = obj.Linknew(ssagen.Arch.LinkArch)
 	base.Ctxt.DiagFunc = base.Errorf
 	base.Ctxt.DiagFlush = base.FlushErrors
 	base.Ctxt.Bso = bufio.NewWriter(os.Stdout)
-	types.PtrSize = thearch.LinkArch.PtrSize
-	types.RegSize = thearch.LinkArch.RegSize
+	types.PtrSize = ssagen.Arch.LinkArch.PtrSize
+	types.RegSize = ssagen.Arch.LinkArch.RegSize
 	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
 		return reflectdata.TypeSym(t).Linksym()
 	}
diff --git a/src/cmd/compile/internal/gc/compile.go b/src/cmd/compile/internal/gc/compile.go
new file mode 100644
index 0000000000..c2a6a9e327
--- /dev/null
+++ b/src/cmd/compile/internal/gc/compile.go
@@ -0,0 +1,177 @@
+// Copyright 2011 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 gc
+
+import (
+	"internal/race"
+	"math/rand"
+	"sort"
+	"sync"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/liveness"
+	"cmd/compile/internal/reflectdata"
+	"cmd/compile/internal/ssagen"
+	"cmd/compile/internal/typecheck"
+	"cmd/compile/internal/types"
+)
+
+// "Portable" code generation.
+
+var (
+	compilequeue []*ir.Func // functions waiting to be compiled
+)
+
+func funccompile(fn *ir.Func) {
+	if ir.CurFunc != nil {
+		base.Fatalf("funccompile %v inside %v", fn.Sym(), ir.CurFunc.Sym())
+	}
+
+	if fn.Type() == nil {
+		if base.Errors() == 0 {
+			base.Fatalf("funccompile missing type")
+		}
+		return
+	}
+
+	// assign parameter offsets
+	types.CalcSize(fn.Type())
+
+	if len(fn.Body) == 0 {
+		// Initialize ABI wrappers if necessary.
+		ssagen.InitLSym(fn, false)
+		liveness.WriteFuncMap(fn)
+		return
+	}
+
+	typecheck.DeclContext = ir.PAUTO
+	ir.CurFunc = fn
+	compile(fn)
+	ir.CurFunc = nil
+	typecheck.DeclContext = ir.PEXTERN
+}
+
+func compile(fn *ir.Func) {
+	// Set up the function's LSym early to avoid data races with the assemblers.
+	// Do this before walk, as walk needs the LSym to set attributes/relocations
+	// (e.g. in markTypeUsedInInterface).
+	ssagen.InitLSym(fn, true)
+
+	errorsBefore := base.Errors()
+	walk(fn)
+	if base.Errors() > errorsBefore {
+		return
+	}
+
+	// From this point, there should be no uses of Curfn. Enforce that.
+	ir.CurFunc = nil
+
+	if ir.FuncName(fn) == "_" {
+		// We don't need to generate code for this function, just report errors in its body.
+		// At this point we've generated any errors needed.
+		// (Beyond here we generate only non-spec errors, like "stack frame too large".)
+		// See issue 29870.
+		return
+	}
+
+	// Make sure type syms are declared for all types that might
+	// be types of stack objects. We need to do this here
+	// because symbols must be allocated before the parallel
+	// phase of the compiler.
+	for _, n := range fn.Dcl {
+		switch n.Class_ {
+		case ir.PPARAM, ir.PPARAMOUT, ir.PAUTO:
+			if liveness.ShouldTrack(n) && n.Addrtaken() {
+				reflectdata.WriteType(n.Type())
+				// Also make sure we allocate a linker symbol
+				// for the stack object data, for the same reason.
+				if fn.LSym.Func().StackObjects == nil {
+					fn.LSym.Func().StackObjects = base.Ctxt.Lookup(fn.LSym.Name + ".stkobj")
+				}
+			}
+		}
+	}
+
+	if compilenow(fn) {
+		ssagen.Compile(fn, 0)
+	} else {
+		compilequeue = append(compilequeue, fn)
+	}
+}
+
+// compilenow reports whether to compile immediately.
+// If functions are not compiled immediately,
+// they are enqueued in compilequeue,
+// which is drained by compileFunctions.
+func compilenow(fn *ir.Func) bool {
+	// Issue 38068: if this function is a method AND an inline
+	// candidate AND was not inlined (yet), put it onto the compile
+	// queue instead of compiling it immediately. This is in case we
+	// wind up inlining it into a method wrapper that is generated by
+	// compiling a function later on in the Target.Decls list.
+	if ir.IsMethod(fn) && isInlinableButNotInlined(fn) {
+		return false
+	}
+	return base.Flag.LowerC == 1 && base.Debug.CompileLater == 0
+}
+
+// compileFunctions compiles all functions in compilequeue.
+// It fans out nBackendWorkers to do the work
+// and waits for them to complete.
+func compileFunctions() {
+	if len(compilequeue) != 0 {
+		types.CalcSizeDisabled = true // not safe to calculate sizes concurrently
+		if race.Enabled {
+			// Randomize compilation order to try to shake out races.
+			tmp := make([]*ir.Func, len(compilequeue))
+			perm := rand.Perm(len(compilequeue))
+			for i, v := range perm {
+				tmp[v] = compilequeue[i]
+			}
+			copy(compilequeue, tmp)
+		} else {
+			// Compile the longest functions first,
+			// since they're most likely to be the slowest.
+			// This helps avoid stragglers.
+			sort.Slice(compilequeue, func(i, j int) bool {
+				return len(compilequeue[i].Body) > len(compilequeue[j].Body)
+			})
+		}
+		var wg sync.WaitGroup
+		base.Ctxt.InParallel = true
+		c := make(chan *ir.Func, base.Flag.LowerC)
+		for i := 0; i < base.Flag.LowerC; i++ {
+			wg.Add(1)
+			go func(worker int) {
+				for fn := range c {
+					ssagen.Compile(fn, worker)
+				}
+				wg.Done()
+			}(i)
+		}
+		for _, fn := range compilequeue {
+			c <- fn
+		}
+		close(c)
+		compilequeue = nil
+		wg.Wait()
+		base.Ctxt.InParallel = false
+		types.CalcSizeDisabled = false
+	}
+}
+
+// isInlinableButNotInlined returns true if 'fn' was marked as an
+// inline candidate but then never inlined (presumably because we
+// found no call sites).
+func isInlinableButNotInlined(fn *ir.Func) bool {
+	if fn.Inl == nil {
+		return false
+	}
+	if fn.Sym() == nil {
+		return true
+	}
+	return !fn.Sym().Linksym().WasInlined()
+}
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/dwarf.go
similarity index 55%
rename from src/cmd/compile/internal/gc/pgen.go
rename to src/cmd/compile/internal/gc/dwarf.go
index 4d990e7dba..e853c51422 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/dwarf.go
@@ -5,361 +5,19 @@
 package gc
 
 import (
+	"sort"
+
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
-	"cmd/compile/internal/liveness"
-	"cmd/compile/internal/objw"
-	"cmd/compile/internal/reflectdata"
 	"cmd/compile/internal/ssa"
-	"cmd/compile/internal/typecheck"
+	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/types"
 	"cmd/internal/dwarf"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
 	"cmd/internal/src"
-	"cmd/internal/sys"
-	"internal/race"
-	"math/rand"
-	"sort"
-	"sync"
-	"time"
 )
 
-// "Portable" code generation.
-
-var (
-	compilequeue []*ir.Func // functions waiting to be compiled
-)
-
-// cmpstackvarlt reports whether the stack variable a sorts before b.
-//
-// Sort the list of stack variables. Autos after anything else,
-// within autos, unused after used, within used, things with
-// pointers first, zeroed things first, and then decreasing size.
-// Because autos are laid out in decreasing addresses
-// on the stack, pointers first, zeroed things first and decreasing size
-// really means, in memory, things with pointers needing zeroing at
-// the top of the stack and increasing in size.
-// Non-autos sort on offset.
-func cmpstackvarlt(a, b *ir.Name) bool {
-	if (a.Class_ == ir.PAUTO) != (b.Class_ == ir.PAUTO) {
-		return b.Class_ == ir.PAUTO
-	}
-
-	if a.Class_ != ir.PAUTO {
-		return a.FrameOffset() < b.FrameOffset()
-	}
-
-	if a.Used() != b.Used() {
-		return a.Used()
-	}
-
-	ap := a.Type().HasPointers()
-	bp := b.Type().HasPointers()
-	if ap != bp {
-		return ap
-	}
-
-	ap = a.Needzero()
-	bp = b.Needzero()
-	if ap != bp {
-		return ap
-	}
-
-	if a.Type().Width != b.Type().Width {
-		return a.Type().Width > b.Type().Width
-	}
-
-	return a.Sym().Name < b.Sym().Name
-}
-
-// byStackvar implements sort.Interface for []*Node using cmpstackvarlt.
-type byStackVar []*ir.Name
-
-func (s byStackVar) Len() int           { return len(s) }
-func (s byStackVar) Less(i, j int) bool { return cmpstackvarlt(s[i], s[j]) }
-func (s byStackVar) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
-
-func (s *ssafn) AllocFrame(f *ssa.Func) {
-	s.stksize = 0
-	s.stkptrsize = 0
-	fn := s.curfn
-
-	// Mark the PAUTO's unused.
-	for _, ln := range fn.Dcl {
-		if ln.Class_ == ir.PAUTO {
-			ln.SetUsed(false)
-		}
-	}
-
-	for _, l := range f.RegAlloc {
-		if ls, ok := l.(ssa.LocalSlot); ok {
-			ls.N.Name().SetUsed(true)
-		}
-	}
-
-	scratchUsed := false
-	for _, b := range f.Blocks {
-		for _, v := range b.Values {
-			if n, ok := v.Aux.(*ir.Name); ok {
-				switch n.Class_ {
-				case ir.PPARAM, ir.PPARAMOUT:
-					// Don't modify nodfp; it is a global.
-					if n != ir.RegFP {
-						n.Name().SetUsed(true)
-					}
-				case ir.PAUTO:
-					n.Name().SetUsed(true)
-				}
-			}
-			if !scratchUsed {
-				scratchUsed = v.Op.UsesScratch()
-			}
-
-		}
-	}
-
-	if f.Config.NeedsFpScratch && scratchUsed {
-		s.scratchFpMem = typecheck.TempAt(src.NoXPos, s.curfn, types.Types[types.TUINT64])
-	}
-
-	sort.Sort(byStackVar(fn.Dcl))
-
-	// Reassign stack offsets of the locals that are used.
-	lastHasPtr := false
-	for i, n := range fn.Dcl {
-		if n.Op() != ir.ONAME || n.Class_ != ir.PAUTO {
-			continue
-		}
-		if !n.Used() {
-			fn.Dcl = fn.Dcl[:i]
-			break
-		}
-
-		types.CalcSize(n.Type())
-		w := n.Type().Width
-		if w >= types.MaxWidth || w < 0 {
-			base.Fatalf("bad width")
-		}
-		if w == 0 && lastHasPtr {
-			// Pad between a pointer-containing object and a zero-sized object.
-			// This prevents a pointer to the zero-sized object from being interpreted
-			// as a pointer to the pointer-containing object (and causing it
-			// to be scanned when it shouldn't be). See issue 24993.
-			w = 1
-		}
-		s.stksize += w
-		s.stksize = types.Rnd(s.stksize, int64(n.Type().Align))
-		if n.Type().HasPointers() {
-			s.stkptrsize = s.stksize
-			lastHasPtr = true
-		} else {
-			lastHasPtr = false
-		}
-		if thearch.LinkArch.InFamily(sys.MIPS, sys.MIPS64, sys.ARM, sys.ARM64, sys.PPC64, sys.S390X) {
-			s.stksize = types.Rnd(s.stksize, int64(types.PtrSize))
-		}
-		n.SetFrameOffset(-s.stksize)
-	}
-
-	s.stksize = types.Rnd(s.stksize, int64(types.RegSize))
-	s.stkptrsize = types.Rnd(s.stkptrsize, int64(types.RegSize))
-}
-
-func funccompile(fn *ir.Func) {
-	if ir.CurFunc != nil {
-		base.Fatalf("funccompile %v inside %v", fn.Sym(), ir.CurFunc.Sym())
-	}
-
-	if fn.Type() == nil {
-		if base.Errors() == 0 {
-			base.Fatalf("funccompile missing type")
-		}
-		return
-	}
-
-	// assign parameter offsets
-	types.CalcSize(fn.Type())
-
-	if len(fn.Body) == 0 {
-		// Initialize ABI wrappers if necessary.
-		initLSym(fn, false)
-		liveness.WriteFuncMap(fn)
-		return
-	}
-
-	typecheck.DeclContext = ir.PAUTO
-	ir.CurFunc = fn
-	compile(fn)
-	ir.CurFunc = nil
-	typecheck.DeclContext = ir.PEXTERN
-}
-
-func compile(fn *ir.Func) {
-	// Set up the function's LSym early to avoid data races with the assemblers.
-	// Do this before walk, as walk needs the LSym to set attributes/relocations
-	// (e.g. in markTypeUsedInInterface).
-	initLSym(fn, true)
-
-	errorsBefore := base.Errors()
-	walk(fn)
-	if base.Errors() > errorsBefore {
-		return
-	}
-
-	// From this point, there should be no uses of Curfn. Enforce that.
-	ir.CurFunc = nil
-
-	if ir.FuncName(fn) == "_" {
-		// We don't need to generate code for this function, just report errors in its body.
-		// At this point we've generated any errors needed.
-		// (Beyond here we generate only non-spec errors, like "stack frame too large".)
-		// See issue 29870.
-		return
-	}
-
-	// Make sure type syms are declared for all types that might
-	// be types of stack objects. We need to do this here
-	// because symbols must be allocated before the parallel
-	// phase of the compiler.
-	for _, n := range fn.Dcl {
-		switch n.Class_ {
-		case ir.PPARAM, ir.PPARAMOUT, ir.PAUTO:
-			if liveness.ShouldTrack(n) && n.Addrtaken() {
-				reflectdata.WriteType(n.Type())
-				// Also make sure we allocate a linker symbol
-				// for the stack object data, for the same reason.
-				if fn.LSym.Func().StackObjects == nil {
-					fn.LSym.Func().StackObjects = base.Ctxt.Lookup(fn.LSym.Name + ".stkobj")
-				}
-			}
-		}
-	}
-
-	if compilenow(fn) {
-		compileSSA(fn, 0)
-	} else {
-		compilequeue = append(compilequeue, fn)
-	}
-}
-
-// compilenow reports whether to compile immediately.
-// If functions are not compiled immediately,
-// they are enqueued in compilequeue,
-// which is drained by compileFunctions.
-func compilenow(fn *ir.Func) bool {
-	// Issue 38068: if this function is a method AND an inline
-	// candidate AND was not inlined (yet), put it onto the compile
-	// queue instead of compiling it immediately. This is in case we
-	// wind up inlining it into a method wrapper that is generated by
-	// compiling a function later on in the Target.Decls list.
-	if ir.IsMethod(fn) && isInlinableButNotInlined(fn) {
-		return false
-	}
-	return base.Flag.LowerC == 1 && base.Debug.CompileLater == 0
-}
-
-// isInlinableButNotInlined returns true if 'fn' was marked as an
-// inline candidate but then never inlined (presumably because we
-// found no call sites).
-func isInlinableButNotInlined(fn *ir.Func) bool {
-	if fn.Inl == nil {
-		return false
-	}
-	if fn.Sym() == nil {
-		return true
-	}
-	return !fn.Sym().Linksym().WasInlined()
-}
-
-const maxStackSize = 1 << 30
-
-// compileSSA builds an SSA backend function,
-// uses it to generate a plist,
-// and flushes that plist to machine code.
-// worker indicates which of the backend workers is doing the processing.
-func compileSSA(fn *ir.Func, worker int) {
-	f := buildssa(fn, worker)
-	// Note: check arg size to fix issue 25507.
-	if f.Frontend().(*ssafn).stksize >= maxStackSize || fn.Type().ArgWidth() >= maxStackSize {
-		largeStackFramesMu.Lock()
-		largeStackFrames = append(largeStackFrames, largeStack{locals: f.Frontend().(*ssafn).stksize, args: fn.Type().ArgWidth(), pos: fn.Pos()})
-		largeStackFramesMu.Unlock()
-		return
-	}
-	pp := objw.NewProgs(fn, worker)
-	defer pp.Free()
-	genssa(f, pp)
-	// Check frame size again.
-	// The check above included only the space needed for local variables.
-	// After genssa, the space needed includes local variables and the callee arg region.
-	// We must do this check prior to calling pp.Flush.
-	// If there are any oversized stack frames,
-	// the assembler may emit inscrutable complaints about invalid instructions.
-	if pp.Text.To.Offset >= maxStackSize {
-		largeStackFramesMu.Lock()
-		locals := f.Frontend().(*ssafn).stksize
-		largeStackFrames = append(largeStackFrames, largeStack{locals: locals, args: fn.Type().ArgWidth(), callee: pp.Text.To.Offset - locals, pos: fn.Pos()})
-		largeStackFramesMu.Unlock()
-		return
-	}
-
-	pp.Flush() // assemble, fill in boilerplate, etc.
-	// fieldtrack must be called after pp.Flush. See issue 20014.
-	fieldtrack(pp.Text.From.Sym, fn.FieldTrack)
-}
-
-func init() {
-	if race.Enabled {
-		rand.Seed(time.Now().UnixNano())
-	}
-}
-
-// compileFunctions compiles all functions in compilequeue.
-// It fans out nBackendWorkers to do the work
-// and waits for them to complete.
-func compileFunctions() {
-	if len(compilequeue) != 0 {
-		types.CalcSizeDisabled = true // not safe to calculate sizes concurrently
-		if race.Enabled {
-			// Randomize compilation order to try to shake out races.
-			tmp := make([]*ir.Func, len(compilequeue))
-			perm := rand.Perm(len(compilequeue))
-			for i, v := range perm {
-				tmp[v] = compilequeue[i]
-			}
-			copy(compilequeue, tmp)
-		} else {
-			// Compile the longest functions first,
-			// since they're most likely to be the slowest.
-			// This helps avoid stragglers.
-			sort.Slice(compilequeue, func(i, j int) bool {
-				return len(compilequeue[i].Body) > len(compilequeue[j].Body)
-			})
-		}
-		var wg sync.WaitGroup
-		base.Ctxt.InParallel = true
-		c := make(chan *ir.Func, base.Flag.LowerC)
-		for i := 0; i < base.Flag.LowerC; i++ {
-			wg.Add(1)
-			go func(worker int) {
-				for fn := range c {
-					compileSSA(fn, worker)
-				}
-				wg.Done()
-			}(i)
-		}
-		for _, fn := range compilequeue {
-			c <- fn
-		}
-		close(c)
-		compilequeue = nil
-		wg.Wait()
-		base.Ctxt.InParallel = false
-		types.CalcSizeDisabled = false
-	}
-}
-
 func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.Scope, dwarf.InlCalls) {
 	fn := curfn.(*ir.Func)
 
@@ -485,100 +143,6 @@ func declPos(decl *ir.Name) src.XPos {
 	return decl.Pos()
 }
 
-// createSimpleVars creates a DWARF entry for every variable declared in the
-// function, claiming that they are permanently on the stack.
-func createSimpleVars(fnsym *obj.LSym, apDecls []*ir.Name) ([]*ir.Name, []*dwarf.Var, map[*ir.Name]bool) {
-	var vars []*dwarf.Var
-	var decls []*ir.Name
-	selected := make(map[*ir.Name]bool)
-	for _, n := range apDecls {
-		if ir.IsAutoTmp(n) {
-			continue
-		}
-
-		decls = append(decls, n)
-		vars = append(vars, createSimpleVar(fnsym, n))
-		selected[n] = true
-	}
-	return decls, vars, selected
-}
-
-func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
-	var abbrev int
-	var offs int64
-
-	switch n.Class_ {
-	case ir.PAUTO:
-		offs = n.FrameOffset()
-		abbrev = dwarf.DW_ABRV_AUTO
-		if base.Ctxt.FixedFrameSize() == 0 {
-			offs -= int64(types.PtrSize)
-		}
-		if objabi.Framepointer_enabled || objabi.GOARCH == "arm64" {
-			// There is a word space for FP on ARM64 even if the frame pointer is disabled
-			offs -= int64(types.PtrSize)
-		}
-
-	case ir.PPARAM, ir.PPARAMOUT:
-		abbrev = dwarf.DW_ABRV_PARAM
-		offs = n.FrameOffset() + base.Ctxt.FixedFrameSize()
-	default:
-		base.Fatalf("createSimpleVar unexpected class %v for node %v", n.Class_, n)
-	}
-
-	typename := dwarf.InfoPrefix + types.TypeSymName(n.Type())
-	delete(fnsym.Func().Autot, ngotype(n).Linksym())
-	inlIndex := 0
-	if base.Flag.GenDwarfInl > 1 {
-		if n.Name().InlFormal() || n.Name().InlLocal() {
-			inlIndex = posInlIndex(n.Pos()) + 1
-			if n.Name().InlFormal() {
-				abbrev = dwarf.DW_ABRV_PARAM
-			}
-		}
-	}
-	declpos := base.Ctxt.InnermostPos(declPos(n))
-	return &dwarf.Var{
-		Name:          n.Sym().Name,
-		IsReturnValue: n.Class_ == ir.PPARAMOUT,
-		IsInlFormal:   n.Name().InlFormal(),
-		Abbrev:        abbrev,
-		StackOffset:   int32(offs),
-		Type:          base.Ctxt.Lookup(typename),
-		DeclFile:      declpos.RelFilename(),
-		DeclLine:      declpos.RelLine(),
-		DeclCol:       declpos.Col(),
-		InlIndex:      int32(inlIndex),
-		ChildIndex:    -1,
-	}
-}
-
-// createComplexVars creates recomposed DWARF vars with location lists,
-// suitable for describing optimized code.
-func createComplexVars(fnsym *obj.LSym, fn *ir.Func) ([]*ir.Name, []*dwarf.Var, map[*ir.Name]bool) {
-	debugInfo := fn.DebugInfo.(*ssa.FuncDebug)
-
-	// Produce a DWARF variable entry for each user variable.
-	var decls []*ir.Name
-	var vars []*dwarf.Var
-	ssaVars := make(map[*ir.Name]bool)
-
-	for varID, dvar := range debugInfo.Vars {
-		n := dvar
-		ssaVars[n] = true
-		for _, slot := range debugInfo.VarSlots[varID] {
-			ssaVars[debugInfo.Slots[slot].N] = true
-		}
-
-		if dvar := createComplexVar(fnsym, fn, ssa.VarID(varID)); dvar != nil {
-			decls = append(decls, n)
-			vars = append(vars, dvar)
-		}
-	}
-
-	return decls, vars, ssaVars
-}
-
 // createDwarfVars process fn, returning a list of DWARF variables and the
 // Nodes they represent.
 func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir.Name) ([]*ir.Name, []*dwarf.Var) {
@@ -617,7 +181,7 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 		if c == '.' || n.Type().IsUntyped() {
 			continue
 		}
-		if n.Class_ == ir.PPARAM && !canSSAType(n.Type()) {
+		if n.Class_ == ir.PPARAM && !ssagen.TypeOK(n.Type()) {
 			// SSA-able args get location lists, and may move in and
 			// out of registers, so those are handled elsewhere.
 			// Autos and named output params seem to get handled
@@ -699,26 +263,98 @@ func preInliningDcls(fnsym *obj.LSym) []*ir.Name {
 	return rdcl
 }
 
-// stackOffset returns the stack location of a LocalSlot relative to the
-// stack pointer, suitable for use in a DWARF location entry. This has nothing
-// to do with its offset in the user variable.
-func stackOffset(slot ssa.LocalSlot) int32 {
-	n := slot.N
-	var off int64
+// createSimpleVars creates a DWARF entry for every variable declared in the
+// function, claiming that they are permanently on the stack.
+func createSimpleVars(fnsym *obj.LSym, apDecls []*ir.Name) ([]*ir.Name, []*dwarf.Var, map[*ir.Name]bool) {
+	var vars []*dwarf.Var
+	var decls []*ir.Name
+	selected := make(map[*ir.Name]bool)
+	for _, n := range apDecls {
+		if ir.IsAutoTmp(n) {
+			continue
+		}
+
+		decls = append(decls, n)
+		vars = append(vars, createSimpleVar(fnsym, n))
+		selected[n] = true
+	}
+	return decls, vars, selected
+}
+
+func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
+	var abbrev int
+	var offs int64
+
 	switch n.Class_ {
 	case ir.PAUTO:
-		off = n.FrameOffset()
+		offs = n.FrameOffset()
+		abbrev = dwarf.DW_ABRV_AUTO
 		if base.Ctxt.FixedFrameSize() == 0 {
-			off -= int64(types.PtrSize)
+			offs -= int64(types.PtrSize)
 		}
 		if objabi.Framepointer_enabled || objabi.GOARCH == "arm64" {
 			// There is a word space for FP on ARM64 even if the frame pointer is disabled
-			off -= int64(types.PtrSize)
+			offs -= int64(types.PtrSize)
 		}
+
 	case ir.PPARAM, ir.PPARAMOUT:
-		off = n.FrameOffset() + base.Ctxt.FixedFrameSize()
+		abbrev = dwarf.DW_ABRV_PARAM
+		offs = n.FrameOffset() + base.Ctxt.FixedFrameSize()
+	default:
+		base.Fatalf("createSimpleVar unexpected class %v for node %v", n.Class_, n)
+	}
+
+	typename := dwarf.InfoPrefix + types.TypeSymName(n.Type())
+	delete(fnsym.Func().Autot, ngotype(n).Linksym())
+	inlIndex := 0
+	if base.Flag.GenDwarfInl > 1 {
+		if n.Name().InlFormal() || n.Name().InlLocal() {
+			inlIndex = posInlIndex(n.Pos()) + 1
+			if n.Name().InlFormal() {
+				abbrev = dwarf.DW_ABRV_PARAM
+			}
+		}
+	}
+	declpos := base.Ctxt.InnermostPos(declPos(n))
+	return &dwarf.Var{
+		Name:          n.Sym().Name,
+		IsReturnValue: n.Class_ == ir.PPARAMOUT,
+		IsInlFormal:   n.Name().InlFormal(),
+		Abbrev:        abbrev,
+		StackOffset:   int32(offs),
+		Type:          base.Ctxt.Lookup(typename),
+		DeclFile:      declpos.RelFilename(),
+		DeclLine:      declpos.RelLine(),
+		DeclCol:       declpos.Col(),
+		InlIndex:      int32(inlIndex),
+		ChildIndex:    -1,
 	}
-	return int32(off + slot.Off)
+}
+
+// createComplexVars creates recomposed DWARF vars with location lists,
+// suitable for describing optimized code.
+func createComplexVars(fnsym *obj.LSym, fn *ir.Func) ([]*ir.Name, []*dwarf.Var, map[*ir.Name]bool) {
+	debugInfo := fn.DebugInfo.(*ssa.FuncDebug)
+
+	// Produce a DWARF variable entry for each user variable.
+	var decls []*ir.Name
+	var vars []*dwarf.Var
+	ssaVars := make(map[*ir.Name]bool)
+
+	for varID, dvar := range debugInfo.Vars {
+		n := dvar
+		ssaVars[n] = true
+		for _, slot := range debugInfo.VarSlots[varID] {
+			ssaVars[debugInfo.Slots[slot].N] = true
+		}
+
+		if dvar := createComplexVar(fnsym, fn, ssa.VarID(varID)); dvar != nil {
+			decls = append(decls, n)
+			vars = append(vars, dvar)
+		}
+	}
+
+	return decls, vars, ssaVars
 }
 
 // createComplexVar builds a single DWARF variable entry and location list.
@@ -759,7 +395,7 @@ func createComplexVar(fnsym *obj.LSym, fn *ir.Func, varID ssa.VarID) *dwarf.Var
 		// variables just give it the first one. It's not used otherwise.
 		// This won't work well if the first slot hasn't been assigned a stack
 		// location, but it's not obvious how to do better.
-		StackOffset: stackOffset(debug.Slots[debug.VarSlots[varID][0]]),
+		StackOffset: ssagen.StackOffset(debug.Slots[debug.VarSlots[varID][0]]),
 		DeclFile:    declpos.RelFilename(),
 		DeclLine:    declpos.RelLine(),
 		DeclCol:     declpos.Col(),
@@ -774,31 +410,3 @@ func createComplexVar(fnsym *obj.LSym, fn *ir.Func, varID ssa.VarID) *dwarf.Var
 	}
 	return dvar
 }
-
-// fieldtrack adds R_USEFIELD relocations to fnsym to record any
-// struct fields that it used.
-func fieldtrack(fnsym *obj.LSym, tracked map[*types.Sym]struct{}) {
-	if fnsym == nil {
-		return
-	}
-	if objabi.Fieldtrack_enabled == 0 || len(tracked) == 0 {
-		return
-	}
-
-	trackSyms := make([]*types.Sym, 0, len(tracked))
-	for sym := range tracked {
-		trackSyms = append(trackSyms, sym)
-	}
-	sort.Sort(symByName(trackSyms))
-	for _, sym := range trackSyms {
-		r := obj.Addrel(fnsym)
-		r.Sym = sym.Linksym()
-		r.Type = objabi.R_USEFIELD
-	}
-}
-
-type symByName []*types.Sym
-
-func (a symByName) Len() int           { return len(a) }
-func (a symByName) Less(i, j int) bool { return a[i].Name < a[j].Name }
-func (a symByName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index e66b877fd0..154235f744 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -17,6 +17,7 @@ import (
 	"cmd/compile/internal/noder"
 	"cmd/compile/internal/reflectdata"
 	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/staticdata"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
@@ -26,12 +27,9 @@ import (
 	"cmd/internal/src"
 	"flag"
 	"fmt"
-	"io/ioutil"
 	"log"
 	"os"
 	"runtime"
-	"sort"
-	"strings"
 )
 
 func hidePanic() {
@@ -52,14 +50,14 @@ func hidePanic() {
 // Main parses flags and Go source files specified in the command-line
 // arguments, type-checks the parsed Go package, compiles functions to machine
 // code, and finally writes the compiled package definition to disk.
-func Main(archInit func(*Arch)) {
+func Main(archInit func(*ssagen.ArchInfo)) {
 	base.Timer.Start("fe", "init")
 
 	defer hidePanic()
 
-	archInit(&thearch)
+	archInit(&ssagen.Arch)
 
-	base.Ctxt = obj.Linknew(thearch.LinkArch)
+	base.Ctxt = obj.Linknew(ssagen.Arch.LinkArch)
 	base.Ctxt.DiagFunc = base.Errorf
 	base.Ctxt.DiagFlush = base.FlushErrors
 	base.Ctxt.Bso = bufio.NewWriter(os.Stdout)
@@ -151,7 +149,7 @@ func Main(archInit func(*Arch)) {
 	types.ParseLangFlag()
 
 	if base.Flag.SymABIs != "" {
-		readSymABIs(base.Flag.SymABIs, base.Ctxt.Pkgpath)
+		ssagen.ReadSymABIs(base.Flag.SymABIs, base.Ctxt.Pkgpath)
 	}
 
 	if base.Compiling(base.NoInstrumentPkgs) {
@@ -159,7 +157,7 @@ func Main(archInit func(*Arch)) {
 		base.Flag.MSan = false
 	}
 
-	thearch.LinkArch.Init(base.Ctxt)
+	ssagen.Arch.LinkArch.Init(base.Ctxt)
 	startProfile()
 	if base.Flag.Race {
 		ir.Pkgs.Race = types.NewPkg("runtime/race", "")
@@ -174,7 +172,7 @@ func Main(archInit func(*Arch)) {
 		dwarf.EnableLogging(base.Debug.DwarfInl != 0)
 	}
 	if base.Debug.SoftFloat != 0 {
-		thearch.SoftFloat = true
+		ssagen.Arch.SoftFloat = true
 	}
 
 	if base.Flag.JSON != "" { // parse version,destination from json logging optimization.
@@ -182,14 +180,14 @@ func Main(archInit func(*Arch)) {
 	}
 
 	ir.EscFmt = escape.Fmt
-	ir.IsIntrinsicCall = isIntrinsicCall
-	inline.SSADumpInline = ssaDumpInline
-	initSSAEnv()
-	initSSATables()
-
-	types.PtrSize = thearch.LinkArch.PtrSize
-	types.RegSize = thearch.LinkArch.RegSize
-	types.MaxWidth = thearch.MAXWIDTH
+	ir.IsIntrinsicCall = ssagen.IsIntrinsicCall
+	inline.SSADumpInline = ssagen.DumpInline
+	ssagen.InitEnv()
+	ssagen.InitTables()
+
+	types.PtrSize = ssagen.Arch.LinkArch.PtrSize
+	types.RegSize = ssagen.Arch.LinkArch.RegSize
+	types.MaxWidth = ssagen.Arch.MAXWIDTH
 	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
 		return reflectdata.TypeSym(t).Linksym()
 	}
@@ -210,7 +208,7 @@ func Main(archInit func(*Arch)) {
 	// Parse input.
 	base.Timer.Start("fe", "parse")
 	lines := noder.ParseFiles(flag.Args())
-	cgoSymABIs()
+	ssagen.CgoSymABIs()
 	base.Timer.Stop()
 	base.Timer.AddEvent(int64(lines), "lines")
 	recordPackageName()
@@ -257,7 +255,7 @@ func Main(archInit func(*Arch)) {
 	// We'll do the final check after write barriers are
 	// inserted.
 	if base.Flag.CompilingRuntime {
-		EnableNoWriteBarrierRecCheck()
+		ssagen.EnableNoWriteBarrierRecCheck()
 	}
 
 	// Transform closure bodies to properly reference captured variables.
@@ -277,7 +275,7 @@ func Main(archInit func(*Arch)) {
 	// Prepare for SSA compilation.
 	// This must be before peekitabs, because peekitabs
 	// can trigger function compilation.
-	initssaconfig()
+	ssagen.InitConfig()
 
 	// Just before compilation, compile itabs found on
 	// the right side of OCONVIFACE so that methods
@@ -302,7 +300,7 @@ func Main(archInit func(*Arch)) {
 
 	if base.Flag.CompilingRuntime {
 		// Write barriers are now known. Check the call graph.
-		NoWriteBarrierRecCheck()
+		ssagen.NoWriteBarrierRecCheck()
 	}
 
 	// Finalize DWARF inline routine DIEs, then explicitly turn off
@@ -323,7 +321,7 @@ func Main(archInit func(*Arch)) {
 		dumpasmhdr()
 	}
 
-	CheckLargeStacks()
+	ssagen.CheckLargeStacks()
 	typecheck.CheckFuncStack()
 
 	if len(compilequeue) != 0 {
@@ -343,34 +341,6 @@ func Main(archInit func(*Arch)) {
 	}
 }
 
-func CheckLargeStacks() {
-	// Check whether any of the functions we have compiled have gigantic stack frames.
-	sort.Slice(largeStackFrames, func(i, j int) bool {
-		return largeStackFrames[i].pos.Before(largeStackFrames[j].pos)
-	})
-	for _, large := range largeStackFrames {
-		if large.callee != 0 {
-			base.ErrorfAt(large.pos, "stack frame too large (>1GB): %d MB locals + %d MB args + %d MB callee", large.locals>>20, large.args>>20, large.callee>>20)
-		} else {
-			base.ErrorfAt(large.pos, "stack frame too large (>1GB): %d MB locals + %d MB args", large.locals>>20, large.args>>20)
-		}
-	}
-}
-
-func cgoSymABIs() {
-	// The linker expects an ABI0 wrapper for all cgo-exported
-	// functions.
-	for _, prag := range typecheck.Target.CgoPragmas {
-		switch prag[0] {
-		case "cgo_export_static", "cgo_export_dynamic":
-			if symabiRefs == nil {
-				symabiRefs = make(map[string]obj.ABI)
-			}
-			symabiRefs[prag[1]] = obj.ABI0
-		}
-	}
-}
-
 func writebench(filename string) error {
 	f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
 	if err != nil {
@@ -394,77 +364,6 @@ func writebench(filename string) error {
 	return f.Close()
 }
 
-// symabiDefs and symabiRefs record the defined and referenced ABIs of
-// symbols required by non-Go code. These are keyed by link symbol
-// name, where the local package prefix is always `"".`
-var symabiDefs, symabiRefs map[string]obj.ABI
-
-// readSymABIs reads a symabis file that specifies definitions and
-// references of text symbols by ABI.
-//
-// The symabis format is a set of lines, where each line is a sequence
-// of whitespace-separated fields. The first field is a verb and is
-// either "def" for defining a symbol ABI or "ref" for referencing a
-// symbol using an ABI. For both "def" and "ref", the second field is
-// the symbol name and the third field is the ABI name, as one of the
-// named cmd/internal/obj.ABI constants.
-func readSymABIs(file, myimportpath string) {
-	data, err := ioutil.ReadFile(file)
-	if err != nil {
-		log.Fatalf("-symabis: %v", err)
-	}
-
-	symabiDefs = make(map[string]obj.ABI)
-	symabiRefs = make(map[string]obj.ABI)
-
-	localPrefix := ""
-	if myimportpath != "" {
-		// Symbols in this package may be written either as
-		// "".X or with the package's import path already in
-		// the symbol.
-		localPrefix = objabi.PathToPrefix(myimportpath) + "."
-	}
-
-	for lineNum, line := range strings.Split(string(data), "\n") {
-		lineNum++ // 1-based
-		line = strings.TrimSpace(line)
-		if line == "" || strings.HasPrefix(line, "#") {
-			continue
-		}
-
-		parts := strings.Fields(line)
-		switch parts[0] {
-		case "def", "ref":
-			// Parse line.
-			if len(parts) != 3 {
-				log.Fatalf(`%s:%d: invalid symabi: syntax is "%s sym abi"`, file, lineNum, parts[0])
-			}
-			sym, abistr := parts[1], parts[2]
-			abi, valid := obj.ParseABI(abistr)
-			if !valid {
-				log.Fatalf(`%s:%d: invalid symabi: unknown abi "%s"`, file, lineNum, abistr)
-			}
-
-			// If the symbol is already prefixed with
-			// myimportpath, rewrite it to start with ""
-			// so it matches the compiler's internal
-			// symbol names.
-			if localPrefix != "" && strings.HasPrefix(sym, localPrefix) {
-				sym = `"".` + sym[len(localPrefix):]
-			}
-
-			// Record for later.
-			if parts[0] == "def" {
-				symabiDefs[sym] = abi
-			} else {
-				symabiRefs[sym] = abi
-			}
-		default:
-			log.Fatalf(`%s:%d: invalid symabi type "%s"`, file, lineNum, parts[0])
-		}
-	}
-}
-
 // recordFlags records the specified command-line flags to be placed
 // in the DWARF info.
 func recordFlags(flags ...string) {
@@ -532,29 +431,6 @@ func recordPackageName() {
 	s.P = []byte(types.LocalPkg.Name)
 }
 
-// useNewABIWrapGen returns TRUE if the compiler should generate an
-// ABI wrapper for the function 'f'.
-func useABIWrapGen(f *ir.Func) bool {
-	if !base.Flag.ABIWrap {
-		return false
-	}
-
-	// Support limit option for bisecting.
-	if base.Flag.ABIWrapLimit == 1 {
-		return false
-	}
-	if base.Flag.ABIWrapLimit < 1 {
-		return true
-	}
-	base.Flag.ABIWrapLimit--
-	if base.Debug.ABIWrap != 0 && base.Flag.ABIWrapLimit == 1 {
-		fmt.Fprintf(os.Stderr, "=-= limit reached after new wrapper for %s\n",
-			f.LSym.Name)
-	}
-
-	return true
-}
-
 func makePos(b *src.PosBase, line, col uint) src.XPos {
 	return base.Ctxt.PosTable.XPos(src.MakePos(b, line, col))
 }
diff --git a/src/cmd/compile/internal/gc/racewalk.go b/src/cmd/compile/internal/gc/racewalk.go
index 1ad3b9b422..c52bf1479b 100644
--- a/src/cmd/compile/internal/gc/racewalk.go
+++ b/src/cmd/compile/internal/gc/racewalk.go
@@ -7,6 +7,7 @@ package gc
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"cmd/internal/sys"
@@ -25,7 +26,7 @@ func instrument(fn *ir.Func) {
 		lno := base.Pos
 		base.Pos = src.NoXPos
 
-		if thearch.LinkArch.Arch.Family != sys.AMD64 {
+		if ssagen.Arch.LinkArch.Arch.Family != sys.AMD64 {
 			fn.Enter.Prepend(mkcall("racefuncenterfp", nil, nil))
 			fn.Exit.Append(mkcall("racefuncexit", nil, nil))
 		} else {
diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index 4ba0654aef..2b2178a8bd 100644
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -8,6 +8,7 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/reflectdata"
+	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/sys"
@@ -15,7 +16,7 @@ import (
 )
 
 func cheapComputableIndex(width int64) bool {
-	switch thearch.LinkArch.Family {
+	switch ssagen.Arch.LinkArch.Family {
 	// MIPS does not have R+R addressing
 	// Arm64 may lack ability to generate this code in our assembler,
 	// but the architecture supports it.
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 89baaf7eee..02a4c0a688 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -8,24 +8,11 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/reflectdata"
+	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"fmt"
-	"sync"
-)
-
-// largeStack is info about a function whose stack frame is too large (rare).
-type largeStack struct {
-	locals int64
-	args   int64
-	callee int64
-	pos    src.XPos
-}
-
-var (
-	largeStackFramesMu sync.Mutex // protects largeStackFrames
-	largeStackFrames   []largeStack
 )
 
 // backingArrayPtrLen extracts the pointer and length from a slice or string.
@@ -91,25 +78,25 @@ func calcHasCall(n ir.Node) bool {
 	// so we ensure they are evaluated first.
 	case ir.OADD, ir.OSUB, ir.OMUL:
 		n := n.(*ir.BinaryExpr)
-		if thearch.SoftFloat && (types.IsFloat[n.Type().Kind()] || types.IsComplex[n.Type().Kind()]) {
+		if ssagen.Arch.SoftFloat && (types.IsFloat[n.Type().Kind()] || types.IsComplex[n.Type().Kind()]) {
 			return true
 		}
 		return n.X.HasCall() || n.Y.HasCall()
 	case ir.ONEG:
 		n := n.(*ir.UnaryExpr)
-		if thearch.SoftFloat && (types.IsFloat[n.Type().Kind()] || types.IsComplex[n.Type().Kind()]) {
+		if ssagen.Arch.SoftFloat && (types.IsFloat[n.Type().Kind()] || types.IsComplex[n.Type().Kind()]) {
 			return true
 		}
 		return n.X.HasCall()
 	case ir.OLT, ir.OEQ, ir.ONE, ir.OLE, ir.OGE, ir.OGT:
 		n := n.(*ir.BinaryExpr)
-		if thearch.SoftFloat && (types.IsFloat[n.X.Type().Kind()] || types.IsComplex[n.X.Type().Kind()]) {
+		if ssagen.Arch.SoftFloat && (types.IsFloat[n.X.Type().Kind()] || types.IsComplex[n.X.Type().Kind()]) {
 			return true
 		}
 		return n.X.HasCall() || n.Y.HasCall()
 	case ir.OCONV:
 		n := n.(*ir.ConvExpr)
-		if thearch.SoftFloat && ((types.IsFloat[n.Type().Kind()] || types.IsComplex[n.Type().Kind()]) || (types.IsFloat[n.X.Type().Kind()] || types.IsComplex[n.X.Type().Kind()])) {
+		if ssagen.Arch.SoftFloat && ((types.IsFloat[n.Type().Kind()] || types.IsComplex[n.Type().Kind()]) || (types.IsFloat[n.X.Type().Kind()] || types.IsComplex[n.X.Type().Kind()])) {
 			return true
 		}
 		return n.X.HasCall()
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 9b49b06c34..f86dbba2c9 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -9,6 +9,7 @@ import (
 	"cmd/compile/internal/escape"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/reflectdata"
+	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/staticdata"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
@@ -977,7 +978,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 			n.X = cheapexpr(n.X, init)
 			// byteindex widens n.Left so that the multiplication doesn't overflow.
 			index := ir.NewBinaryExpr(base.Pos, ir.OLSH, byteindex(n.X), ir.NewInt(3))
-			if thearch.LinkArch.ByteOrder == binary.BigEndian {
+			if ssagen.Arch.LinkArch.ByteOrder == binary.BigEndian {
 				index = ir.NewBinaryExpr(base.Pos, ir.OADD, index, ir.NewInt(7))
 			}
 			xe := ir.NewIndexExpr(base.Pos, ir.Names.Staticuint64s, index)
@@ -1675,7 +1676,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return mkcall("stringtoslicerune", n.Type(), init, a, typecheck.Conv(n.X, types.Types[types.TSTRING]))
 
 	case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT, ir.OSTRUCTLIT, ir.OPTRLIT:
-		if isStaticCompositeLiteral(n) && !canSSAType(n.Type()) {
+		if isStaticCompositeLiteral(n) && !ssagen.TypeOK(n.Type()) {
 			n := n.(*ir.CompLitExpr) // not OPTRLIT
 			// n can be directly represented in the read-only data section.
 			// Make direct reference to the static data. See issue 12841.
@@ -1739,11 +1740,11 @@ func markUsedIfaceMethod(n *ir.CallExpr) {
 //
 // If no such function is necessary, it returns (Txxx, Txxx).
 func rtconvfn(src, dst *types.Type) (param, result types.Kind) {
-	if thearch.SoftFloat {
+	if ssagen.Arch.SoftFloat {
 		return types.Txxx, types.Txxx
 	}
 
-	switch thearch.LinkArch.Family {
+	switch ssagen.Arch.LinkArch.Family {
 	case sys.ARM, sys.MIPS:
 		if src.IsFloat() {
 			switch dst.Kind() {
@@ -3229,7 +3230,7 @@ func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 	unalignedLoad := canMergeLoads()
 	if unalignedLoad {
 		// Keep this low enough to generate less code than a function call.
-		maxcmpsize = 2 * int64(thearch.LinkArch.RegSize)
+		maxcmpsize = 2 * int64(ssagen.Arch.LinkArch.RegSize)
 	}
 
 	switch t.Kind() {
@@ -3469,8 +3470,8 @@ func walkcompareString(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 		combine64bit := false
 		if canCombineLoads {
 			// Keep this low enough to generate less code than a function call.
-			maxRewriteLen = 2 * thearch.LinkArch.RegSize
-			combine64bit = thearch.LinkArch.RegSize >= 8
+			maxRewriteLen = 2 * ssagen.Arch.LinkArch.RegSize
+			combine64bit = ssagen.Arch.LinkArch.RegSize >= 8
 		}
 
 		var and ir.Op
@@ -3909,12 +3910,12 @@ func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 // larger, possibly unaligned, load. Note that currently the
 // optimizations must be able to handle little endian byte order.
 func canMergeLoads() bool {
-	switch thearch.LinkArch.Family {
+	switch ssagen.Arch.LinkArch.Family {
 	case sys.ARM64, sys.AMD64, sys.I386, sys.S390X:
 		return true
 	case sys.PPC64:
 		// Load combining only supported on ppc64le.
-		return thearch.LinkArch.ByteOrder == binary.LittleEndian
+		return ssagen.Arch.LinkArch.ByteOrder == binary.LittleEndian
 	}
 	return false
 }
@@ -4032,3 +4033,7 @@ func appendWalkStmt(init *ir.Nodes, stmt ir.Node) {
 	}
 	init.Append(n)
 }
+
+// The max number of defers in a function using open-coded defers. We enforce this
+// limit because the deferBits bitmask is currently a single byte (to minimize code size)
+const maxOpenDefers = 8
diff --git a/src/cmd/compile/internal/mips/galign.go b/src/cmd/compile/internal/mips/galign.go
index be40c16dde..599163550b 100644
--- a/src/cmd/compile/internal/mips/galign.go
+++ b/src/cmd/compile/internal/mips/galign.go
@@ -5,13 +5,13 @@
 package mips
 
 import (
-	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/ssagen"
 	"cmd/internal/obj/mips"
 	"cmd/internal/objabi"
 )
 
-func Init(arch *gc.Arch) {
+func Init(arch *ssagen.ArchInfo) {
 	arch.LinkArch = &mips.Linkmips
 	if objabi.GOARCH == "mipsle" {
 		arch.LinkArch = &mips.Linkmipsle
@@ -22,7 +22,7 @@ func Init(arch *gc.Arch) {
 	arch.ZeroRange = zerorange
 	arch.Ginsnop = ginsnop
 	arch.Ginsnopdefer = ginsnop
-	arch.SSAMarkMoves = func(s *gc.SSAGenState, b *ssa.Block) {}
+	arch.SSAMarkMoves = func(s *ssagen.State, b *ssa.Block) {}
 	arch.SSAGenValue = ssaGenValue
 	arch.SSAGenBlock = ssaGenBlock
 }
diff --git a/src/cmd/compile/internal/mips/ssa.go b/src/cmd/compile/internal/mips/ssa.go
index e46d87e17d..f1cdbd3241 100644
--- a/src/cmd/compile/internal/mips/ssa.go
+++ b/src/cmd/compile/internal/mips/ssa.go
@@ -8,10 +8,10 @@ import (
 	"math"
 
 	"cmd/compile/internal/base"
-	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/mips"
@@ -77,7 +77,7 @@ func storeByType(t *types.Type, r int16) obj.As {
 	panic("bad store type")
 }
 
-func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
+func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 	switch v.Op {
 	case ssa.OpCopy, ssa.OpMIPSMOVWreg:
 		t := v.Type
@@ -123,7 +123,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		}
 		r := v.Reg()
 		p := s.Prog(loadByType(v.Type, r))
-		gc.AddrAuto(&p.From, v.Args[0])
+		ssagen.AddrAuto(&p.From, v.Args[0])
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = r
 		if isHILO(r) {
@@ -153,7 +153,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(storeByType(v.Type, r))
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = r
-		gc.AddrAuto(&p.To, v)
+		ssagen.AddrAuto(&p.To, v)
 	case ssa.OpMIPSADD,
 		ssa.OpMIPSSUB,
 		ssa.OpMIPSAND,
@@ -288,10 +288,10 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 			v.Fatalf("aux is of unknown type %T", v.Aux)
 		case *obj.LSym:
 			wantreg = "SB"
-			gc.AddAux(&p.From, v)
+			ssagen.AddAux(&p.From, v)
 		case *ir.Name:
 			wantreg = "SP"
-			gc.AddAux(&p.From, v)
+			ssagen.AddAux(&p.From, v)
 		case nil:
 			// No sym, just MOVW $off(SP), R
 			wantreg = "SP"
@@ -312,7 +312,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.OpMIPSMOVBstore,
@@ -325,7 +325,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Reg = v.Args[1].Reg()
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 	case ssa.OpMIPSMOVBstorezero,
 		ssa.OpMIPSMOVHstorezero,
 		ssa.OpMIPSMOVWstorezero:
@@ -334,7 +334,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Reg = mips.REGZERO
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 	case ssa.OpMIPSMOVBreg,
 		ssa.OpMIPSMOVBUreg,
 		ssa.OpMIPSMOVHreg,
@@ -492,13 +492,13 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(obj.ACALL)
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.BoundsCheckFunc[v.AuxInt]
+		p.To.Sym = ssagen.BoundsCheckFunc[v.AuxInt]
 		s.UseArgs(8) // space used in callee args area by assembly stubs
 	case ssa.OpMIPSLoweredPanicExtendA, ssa.OpMIPSLoweredPanicExtendB, ssa.OpMIPSLoweredPanicExtendC:
 		p := s.Prog(obj.ACALL)
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.ExtendCheckFunc[v.AuxInt]
+		p.To.Sym = ssagen.ExtendCheckFunc[v.AuxInt]
 		s.UseArgs(12) // space used in callee args area by assembly stubs
 	case ssa.OpMIPSLoweredAtomicLoad8,
 		ssa.OpMIPSLoweredAtomicLoad32:
@@ -762,7 +762,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(mips.AMOVB)
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = mips.REGTMP
 		if logopt.Enabled() {
@@ -793,7 +793,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 
 	case ssa.OpMIPSLoweredGetClosurePtr:
 		// Closure pointer is R22 (mips.REGCTXT).
-		gc.CheckLoweredGetClosurePtr(v)
+		ssagen.CheckLoweredGetClosurePtr(v)
 	case ssa.OpMIPSLoweredGetCallerSP:
 		// caller's SP is FixedFrameSize below the address of the first arg
 		p := s.Prog(mips.AMOVW)
@@ -826,13 +826,13 @@ var blockJump = map[ssa.BlockKind]struct {
 	ssa.BlockMIPSFPF: {mips.ABFPF, mips.ABFPT},
 }
 
-func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
+func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
 	switch b.Kind {
 	case ssa.BlockPlain:
 		if b.Succs[0].Block() != next {
 			p := s.Prog(obj.AJMP)
 			p.To.Type = obj.TYPE_BRANCH
-			s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+			s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
 		}
 	case ssa.BlockDefer:
 		// defer returns in R1:
@@ -843,11 +843,11 @@ func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
 		p.From.Reg = mips.REGZERO
 		p.Reg = mips.REG_R1
 		p.To.Type = obj.TYPE_BRANCH
-		s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[1].Block()})
+		s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[1].Block()})
 		if b.Succs[0].Block() != next {
 			p := s.Prog(obj.AJMP)
 			p.To.Type = obj.TYPE_BRANCH
-			s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+			s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
 		}
 	case ssa.BlockExit:
 	case ssa.BlockRet:
diff --git a/src/cmd/compile/internal/mips64/galign.go b/src/cmd/compile/internal/mips64/galign.go
index 90c381a50b..fc0a34228c 100644
--- a/src/cmd/compile/internal/mips64/galign.go
+++ b/src/cmd/compile/internal/mips64/galign.go
@@ -5,13 +5,13 @@
 package mips64
 
 import (
-	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/ssagen"
 	"cmd/internal/obj/mips"
 	"cmd/internal/objabi"
 )
 
-func Init(arch *gc.Arch) {
+func Init(arch *ssagen.ArchInfo) {
 	arch.LinkArch = &mips.Linkmips64
 	if objabi.GOARCH == "mips64le" {
 		arch.LinkArch = &mips.Linkmips64le
@@ -23,7 +23,7 @@ func Init(arch *gc.Arch) {
 	arch.Ginsnop = ginsnop
 	arch.Ginsnopdefer = ginsnop
 
-	arch.SSAMarkMoves = func(s *gc.SSAGenState, b *ssa.Block) {}
+	arch.SSAMarkMoves = func(s *ssagen.State, b *ssa.Block) {}
 	arch.SSAGenValue = ssaGenValue
 	arch.SSAGenBlock = ssaGenBlock
 }
diff --git a/src/cmd/compile/internal/mips64/ssa.go b/src/cmd/compile/internal/mips64/ssa.go
index 096e7048ce..14cf7af143 100644
--- a/src/cmd/compile/internal/mips64/ssa.go
+++ b/src/cmd/compile/internal/mips64/ssa.go
@@ -8,10 +8,10 @@ import (
 	"math"
 
 	"cmd/compile/internal/base"
-	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/mips"
@@ -85,7 +85,7 @@ func storeByType(t *types.Type, r int16) obj.As {
 	panic("bad store type")
 }
 
-func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
+func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 	switch v.Op {
 	case ssa.OpCopy, ssa.OpMIPS64MOVVreg:
 		if v.Type.IsMemory() {
@@ -126,7 +126,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		}
 		r := v.Reg()
 		p := s.Prog(loadByType(v.Type, r))
-		gc.AddrAuto(&p.From, v.Args[0])
+		ssagen.AddrAuto(&p.From, v.Args[0])
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = r
 		if isHILO(r) {
@@ -156,7 +156,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(storeByType(v.Type, r))
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = r
-		gc.AddrAuto(&p.To, v)
+		ssagen.AddrAuto(&p.To, v)
 	case ssa.OpMIPS64ADDV,
 		ssa.OpMIPS64SUBV,
 		ssa.OpMIPS64AND,
@@ -262,10 +262,10 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 			v.Fatalf("aux is of unknown type %T", v.Aux)
 		case *obj.LSym:
 			wantreg = "SB"
-			gc.AddAux(&p.From, v)
+			ssagen.AddAux(&p.From, v)
 		case *ir.Name:
 			wantreg = "SP"
-			gc.AddAux(&p.From, v)
+			ssagen.AddAux(&p.From, v)
 		case nil:
 			// No sym, just MOVV $off(SP), R
 			wantreg = "SP"
@@ -288,7 +288,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.OpMIPS64MOVBstore,
@@ -302,7 +302,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Reg = v.Args[1].Reg()
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 	case ssa.OpMIPS64MOVBstorezero,
 		ssa.OpMIPS64MOVHstorezero,
 		ssa.OpMIPS64MOVWstorezero,
@@ -312,7 +312,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Reg = mips.REGZERO
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 	case ssa.OpMIPS64MOVBreg,
 		ssa.OpMIPS64MOVBUreg,
 		ssa.OpMIPS64MOVHreg,
@@ -502,7 +502,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(obj.ACALL)
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.BoundsCheckFunc[v.AuxInt]
+		p.To.Sym = ssagen.BoundsCheckFunc[v.AuxInt]
 		s.UseArgs(16) // space used in callee args area by assembly stubs
 	case ssa.OpMIPS64LoweredAtomicLoad8, ssa.OpMIPS64LoweredAtomicLoad32, ssa.OpMIPS64LoweredAtomicLoad64:
 		as := mips.AMOVV
@@ -720,7 +720,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(mips.AMOVB)
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = mips.REGTMP
 		if logopt.Enabled() {
@@ -754,7 +754,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p2.To.SetTarget(p4)
 	case ssa.OpMIPS64LoweredGetClosurePtr:
 		// Closure pointer is R22 (mips.REGCTXT).
-		gc.CheckLoweredGetClosurePtr(v)
+		ssagen.CheckLoweredGetClosurePtr(v)
 	case ssa.OpMIPS64LoweredGetCallerSP:
 		// caller's SP is FixedFrameSize below the address of the first arg
 		p := s.Prog(mips.AMOVV)
@@ -787,13 +787,13 @@ var blockJump = map[ssa.BlockKind]struct {
 	ssa.BlockMIPS64FPF: {mips.ABFPF, mips.ABFPT},
 }
 
-func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
+func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
 	switch b.Kind {
 	case ssa.BlockPlain:
 		if b.Succs[0].Block() != next {
 			p := s.Prog(obj.AJMP)
 			p.To.Type = obj.TYPE_BRANCH
-			s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+			s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
 		}
 	case ssa.BlockDefer:
 		// defer returns in R1:
@@ -804,11 +804,11 @@ func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
 		p.From.Reg = mips.REGZERO
 		p.Reg = mips.REG_R1
 		p.To.Type = obj.TYPE_BRANCH
-		s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[1].Block()})
+		s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[1].Block()})
 		if b.Succs[0].Block() != next {
 			p := s.Prog(obj.AJMP)
 			p.To.Type = obj.TYPE_BRANCH
-			s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+			s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
 		}
 	case ssa.BlockExit:
 	case ssa.BlockRet:
diff --git a/src/cmd/compile/internal/ppc64/galign.go b/src/cmd/compile/internal/ppc64/galign.go
index c8ef567dc3..c72d1aa834 100644
--- a/src/cmd/compile/internal/ppc64/galign.go
+++ b/src/cmd/compile/internal/ppc64/galign.go
@@ -5,12 +5,12 @@
 package ppc64
 
 import (
-	"cmd/compile/internal/gc"
+	"cmd/compile/internal/ssagen"
 	"cmd/internal/obj/ppc64"
 	"cmd/internal/objabi"
 )
 
-func Init(arch *gc.Arch) {
+func Init(arch *ssagen.ArchInfo) {
 	arch.LinkArch = &ppc64.Linkppc64
 	if objabi.GOARCH == "ppc64le" {
 		arch.LinkArch = &ppc64.Linkppc64le
diff --git a/src/cmd/compile/internal/ppc64/ssa.go b/src/cmd/compile/internal/ppc64/ssa.go
index edcaad03ec..c85e110ed3 100644
--- a/src/cmd/compile/internal/ppc64/ssa.go
+++ b/src/cmd/compile/internal/ppc64/ssa.go
@@ -6,10 +6,10 @@ package ppc64
 
 import (
 	"cmd/compile/internal/base"
-	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/ppc64"
@@ -19,7 +19,7 @@ import (
 )
 
 // markMoves marks any MOVXconst ops that need to avoid clobbering flags.
-func ssaMarkMoves(s *gc.SSAGenState, b *ssa.Block) {
+func ssaMarkMoves(s *ssagen.State, b *ssa.Block) {
 	//	flive := b.FlagsLiveAtEnd
 	//	if b.Control != nil && b.Control.Type.IsFlags() {
 	//		flive = true
@@ -101,7 +101,7 @@ func storeByType(t *types.Type) obj.As {
 	panic("bad store type")
 }
 
-func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
+func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 	switch v.Op {
 	case ssa.OpCopy:
 		t := v.Type
@@ -469,7 +469,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 
 	case ssa.OpPPC64LoweredGetClosurePtr:
 		// Closure pointer is R11 (already)
-		gc.CheckLoweredGetClosurePtr(v)
+		ssagen.CheckLoweredGetClosurePtr(v)
 
 	case ssa.OpPPC64LoweredGetCallerSP:
 		// caller's SP is FixedFrameSize below the address of the first arg
@@ -491,7 +491,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 	case ssa.OpLoadReg:
 		loadOp := loadByType(v.Type)
 		p := s.Prog(loadOp)
-		gc.AddrAuto(&p.From, v.Args[0])
+		ssagen.AddrAuto(&p.From, v.Args[0])
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 
@@ -500,7 +500,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(storeOp)
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddrAuto(&p.To, v)
+		ssagen.AddrAuto(&p.To, v)
 
 	case ssa.OpPPC64DIVD:
 		// For now,
@@ -758,7 +758,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 			p.From.Reg = v.Args[0].Reg()
 			p.To.Type = obj.TYPE_REG
 			p.To.Reg = v.Reg()
-			gc.AddAux(&p.From, v)
+			ssagen.AddAux(&p.From, v)
 
 		}
 
@@ -819,7 +819,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 			p := s.Prog(ppc64.AMOVD)
 			p.From.Type = obj.TYPE_ADDR
 			p.From.Reg = v.Args[0].Reg()
-			gc.AddAux(&p.From, v)
+			ssagen.AddAux(&p.From, v)
 			p.To.Type = obj.TYPE_REG
 			p.To.Reg = v.Reg()
 			// Load go.string using 0 offset
@@ -837,7 +837,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 
@@ -871,7 +871,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Reg = ppc64.REGZERO
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 
 	case ssa.OpPPC64MOVDstore, ssa.OpPPC64MOVWstore, ssa.OpPPC64MOVHstore, ssa.OpPPC64MOVBstore, ssa.OpPPC64FMOVDstore, ssa.OpPPC64FMOVSstore:
 		p := s.Prog(v.Op.Asm())
@@ -879,7 +879,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Reg = v.Args[1].Reg()
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 
 	case ssa.OpPPC64MOVDstoreidx, ssa.OpPPC64MOVWstoreidx, ssa.OpPPC64MOVHstoreidx, ssa.OpPPC64MOVBstoreidx,
 		ssa.OpPPC64FMOVDstoreidx, ssa.OpPPC64FMOVSstoreidx, ssa.OpPPC64MOVDBRstoreidx, ssa.OpPPC64MOVWBRstoreidx,
@@ -1809,7 +1809,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(obj.ACALL)
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.BoundsCheckFunc[v.AuxInt]
+		p.To.Sym = ssagen.BoundsCheckFunc[v.AuxInt]
 		s.UseArgs(16) // space used in callee args area by assembly stubs
 
 	case ssa.OpPPC64LoweredNilCheck:
@@ -1847,7 +1847,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 			p := s.Prog(ppc64.AMOVBZ)
 			p.From.Type = obj.TYPE_MEM
 			p.From.Reg = v.Args[0].Reg()
-			gc.AddAux(&p.From, v)
+			ssagen.AddAux(&p.From, v)
 			p.To.Type = obj.TYPE_REG
 			p.To.Reg = ppc64.REGTMP
 		}
@@ -1893,7 +1893,7 @@ var blockJump = [...]struct {
 	ssa.BlockPPC64FGT: {ppc64.ABGT, ppc64.ABLE, false, false},
 }
 
-func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
+func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
 	switch b.Kind {
 	case ssa.BlockDefer:
 		// defer returns in R3:
@@ -1907,18 +1907,18 @@ func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
 
 		p = s.Prog(ppc64.ABNE)
 		p.To.Type = obj.TYPE_BRANCH
-		s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[1].Block()})
+		s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[1].Block()})
 		if b.Succs[0].Block() != next {
 			p := s.Prog(obj.AJMP)
 			p.To.Type = obj.TYPE_BRANCH
-			s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+			s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
 		}
 
 	case ssa.BlockPlain:
 		if b.Succs[0].Block() != next {
 			p := s.Prog(obj.AJMP)
 			p.To.Type = obj.TYPE_BRANCH
-			s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+			s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
 		}
 	case ssa.BlockExit:
 	case ssa.BlockRet:
diff --git a/src/cmd/compile/internal/riscv64/galign.go b/src/cmd/compile/internal/riscv64/galign.go
index 4db0fac52e..338248a7cf 100644
--- a/src/cmd/compile/internal/riscv64/galign.go
+++ b/src/cmd/compile/internal/riscv64/galign.go
@@ -5,11 +5,11 @@
 package riscv64
 
 import (
-	"cmd/compile/internal/gc"
+	"cmd/compile/internal/ssagen"
 	"cmd/internal/obj/riscv"
 )
 
-func Init(arch *gc.Arch) {
+func Init(arch *ssagen.ArchInfo) {
 	arch.LinkArch = &riscv.LinkRISCV64
 
 	arch.REGSP = riscv.REG_SP
diff --git a/src/cmd/compile/internal/riscv64/ssa.go b/src/cmd/compile/internal/riscv64/ssa.go
index d08cebdcf5..70c29a4b7b 100644
--- a/src/cmd/compile/internal/riscv64/ssa.go
+++ b/src/cmd/compile/internal/riscv64/ssa.go
@@ -6,9 +6,9 @@ package riscv64
 
 import (
 	"cmd/compile/internal/base"
-	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/riscv"
@@ -180,9 +180,9 @@ func largestMove(alignment int64) (obj.As, int64) {
 
 // markMoves marks any MOVXconst ops that need to avoid clobbering flags.
 // RISC-V has no flags, so this is a no-op.
-func ssaMarkMoves(s *gc.SSAGenState, b *ssa.Block) {}
+func ssaMarkMoves(s *ssagen.State, b *ssa.Block) {}
 
-func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
+func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 	s.SetPos(v.Pos)
 
 	switch v.Op {
@@ -191,7 +191,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 	case ssa.OpArg:
 		// input args need no code
 	case ssa.OpPhi:
-		gc.CheckLoweredPhi(v)
+		ssagen.CheckLoweredPhi(v)
 	case ssa.OpCopy, ssa.OpRISCV64MOVconvert, ssa.OpRISCV64MOVDreg:
 		if v.Type.IsMemory() {
 			return
@@ -221,7 +221,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 			return
 		}
 		p := s.Prog(loadByType(v.Type))
-		gc.AddrAuto(&p.From, v.Args[0])
+		ssagen.AddrAuto(&p.From, v.Args[0])
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.OpStoreReg:
@@ -232,7 +232,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(storeByType(v.Type))
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddrAuto(&p.To, v)
+		ssagen.AddrAuto(&p.To, v)
 	case ssa.OpSP, ssa.OpSB, ssa.OpGetG:
 		// nothing to do
 	case ssa.OpRISCV64MOVBreg, ssa.OpRISCV64MOVHreg, ssa.OpRISCV64MOVWreg,
@@ -323,10 +323,10 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 			v.Fatalf("aux is of unknown type %T", v.Aux)
 		case *obj.LSym:
 			wantreg = "SB"
-			gc.AddAux(&p.From, v)
+			ssagen.AddAux(&p.From, v)
 		case *ir.Name:
 			wantreg = "SP"
-			gc.AddAux(&p.From, v)
+			ssagen.AddAux(&p.From, v)
 		case nil:
 			// No sym, just MOVW $off(SP), R
 			wantreg = "SP"
@@ -342,7 +342,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.OpRISCV64MOVBstore, ssa.OpRISCV64MOVHstore, ssa.OpRISCV64MOVWstore, ssa.OpRISCV64MOVDstore,
@@ -352,14 +352,14 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Reg = v.Args[1].Reg()
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 	case ssa.OpRISCV64MOVBstorezero, ssa.OpRISCV64MOVHstorezero, ssa.OpRISCV64MOVWstorezero, ssa.OpRISCV64MOVDstorezero:
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = riscv.REG_ZERO
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 	case ssa.OpRISCV64SEQZ, ssa.OpRISCV64SNEZ:
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_REG
@@ -377,7 +377,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(obj.ACALL)
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.BoundsCheckFunc[v.AuxInt]
+		p.To.Sym = ssagen.BoundsCheckFunc[v.AuxInt]
 		s.UseArgs(16) // space used in callee args area by assembly stubs
 
 	case ssa.OpRISCV64LoweredAtomicLoad8:
@@ -585,7 +585,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(riscv.AMOVB)
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = riscv.REG_ZERO
 		if base.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos == 1 in generated wrappers
@@ -594,7 +594,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 
 	case ssa.OpRISCV64LoweredGetClosurePtr:
 		// Closure pointer is S4 (riscv.REG_CTXT).
-		gc.CheckLoweredGetClosurePtr(v)
+		ssagen.CheckLoweredGetClosurePtr(v)
 
 	case ssa.OpRISCV64LoweredGetCallerSP:
 		// caller's SP is FixedFrameSize below the address of the first arg
@@ -644,7 +644,7 @@ var blockBranch = [...]obj.As{
 	ssa.BlockRISCV64BNEZ: riscv.ABNEZ,
 }
 
-func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
+func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
 	s.SetPos(b.Pos)
 
 	switch b.Kind {
@@ -657,17 +657,17 @@ func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = riscv.REG_ZERO
 		p.Reg = riscv.REG_A0
-		s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[1].Block()})
+		s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[1].Block()})
 		if b.Succs[0].Block() != next {
 			p := s.Prog(obj.AJMP)
 			p.To.Type = obj.TYPE_BRANCH
-			s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+			s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
 		}
 	case ssa.BlockPlain:
 		if b.Succs[0].Block() != next {
 			p := s.Prog(obj.AJMP)
 			p.To.Type = obj.TYPE_BRANCH
-			s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+			s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
 		}
 	case ssa.BlockExit:
 	case ssa.BlockRet:
diff --git a/src/cmd/compile/internal/s390x/galign.go b/src/cmd/compile/internal/s390x/galign.go
index cb68fd36c1..b004a2db0a 100644
--- a/src/cmd/compile/internal/s390x/galign.go
+++ b/src/cmd/compile/internal/s390x/galign.go
@@ -5,11 +5,11 @@
 package s390x
 
 import (
-	"cmd/compile/internal/gc"
+	"cmd/compile/internal/ssagen"
 	"cmd/internal/obj/s390x"
 )
 
-func Init(arch *gc.Arch) {
+func Init(arch *ssagen.ArchInfo) {
 	arch.LinkArch = &s390x.Links390x
 	arch.REGSP = s390x.REGSP
 	arch.MAXWIDTH = 1 << 50
diff --git a/src/cmd/compile/internal/s390x/ssa.go b/src/cmd/compile/internal/s390x/ssa.go
index dc01401348..d4c7a286e2 100644
--- a/src/cmd/compile/internal/s390x/ssa.go
+++ b/src/cmd/compile/internal/s390x/ssa.go
@@ -8,16 +8,16 @@ import (
 	"math"
 
 	"cmd/compile/internal/base"
-	"cmd/compile/internal/gc"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/s390x"
 )
 
 // markMoves marks any MOVXconst ops that need to avoid clobbering flags.
-func ssaMarkMoves(s *gc.SSAGenState, b *ssa.Block) {
+func ssaMarkMoves(s *ssagen.State, b *ssa.Block) {
 	flive := b.FlagsLiveAtEnd
 	for _, c := range b.ControlValues() {
 		flive = c.Type.IsFlags() || flive
@@ -135,7 +135,7 @@ func moveByType(t *types.Type) obj.As {
 //     dest := dest(To) op src(From)
 // and also returns the created obj.Prog so it
 // may be further adjusted (offset, scale, etc).
-func opregreg(s *gc.SSAGenState, op obj.As, dest, src int16) *obj.Prog {
+func opregreg(s *ssagen.State, op obj.As, dest, src int16) *obj.Prog {
 	p := s.Prog(op)
 	p.From.Type = obj.TYPE_REG
 	p.To.Type = obj.TYPE_REG
@@ -148,7 +148,7 @@ func opregreg(s *gc.SSAGenState, op obj.As, dest, src int16) *obj.Prog {
 //	dest := src(From) op off
 // and also returns the created obj.Prog so it
 // may be further adjusted (offset, scale, etc).
-func opregregimm(s *gc.SSAGenState, op obj.As, dest, src int16, off int64) *obj.Prog {
+func opregregimm(s *ssagen.State, op obj.As, dest, src int16, off int64) *obj.Prog {
 	p := s.Prog(op)
 	p.From.Type = obj.TYPE_CONST
 	p.From.Offset = off
@@ -158,7 +158,7 @@ func opregregimm(s *gc.SSAGenState, op obj.As, dest, src int16, off int64) *obj.
 	return p
 }
 
-func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
+func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 	switch v.Op {
 	case ssa.OpS390XSLD, ssa.OpS390XSLW,
 		ssa.OpS390XSRD, ssa.OpS390XSRW,
@@ -395,14 +395,14 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Type = obj.TYPE_ADDR
 		p.From.Reg = r
 		p.From.Index = i
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.OpS390XMOVDaddr:
 		p := s.Prog(s390x.AMOVD)
 		p.From.Type = obj.TYPE_ADDR
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.OpS390XCMP, ssa.OpS390XCMPW, ssa.OpS390XCMPU, ssa.OpS390XCMPWU:
@@ -448,7 +448,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[1].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = r
 	case ssa.OpS390XMOVDload,
@@ -459,7 +459,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.OpS390XMOVBZloadidx, ssa.OpS390XMOVHZloadidx, ssa.OpS390XMOVWZloadidx,
@@ -476,7 +476,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Reg = r
 		p.From.Scale = 1
 		p.From.Index = i
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.OpS390XMOVBstore, ssa.OpS390XMOVHstore, ssa.OpS390XMOVWstore, ssa.OpS390XMOVDstore,
@@ -487,7 +487,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Reg = v.Args[1].Reg()
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 	case ssa.OpS390XMOVBstoreidx, ssa.OpS390XMOVHstoreidx, ssa.OpS390XMOVWstoreidx, ssa.OpS390XMOVDstoreidx,
 		ssa.OpS390XMOVHBRstoreidx, ssa.OpS390XMOVWBRstoreidx, ssa.OpS390XMOVDBRstoreidx,
 		ssa.OpS390XFMOVSstoreidx, ssa.OpS390XFMOVDstoreidx:
@@ -503,7 +503,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.To.Reg = r
 		p.To.Scale = 1
 		p.To.Index = i
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 	case ssa.OpS390XMOVDstoreconst, ssa.OpS390XMOVWstoreconst, ssa.OpS390XMOVHstoreconst, ssa.OpS390XMOVBstoreconst:
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_CONST
@@ -511,7 +511,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Offset = sc.Val()
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux2(&p.To, v, sc.Off())
+		ssagen.AddAux2(&p.To, v, sc.Off())
 	case ssa.OpS390XMOVBreg, ssa.OpS390XMOVHreg, ssa.OpS390XMOVWreg,
 		ssa.OpS390XMOVBZreg, ssa.OpS390XMOVHZreg, ssa.OpS390XMOVWZreg,
 		ssa.OpS390XLDGR, ssa.OpS390XLGDR,
@@ -530,7 +530,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Offset = sc.Val()
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux2(&p.To, v, sc.Off())
+		ssagen.AddAux2(&p.To, v, sc.Off())
 	case ssa.OpCopy:
 		if v.Type.IsMemory() {
 			return
@@ -546,7 +546,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 			return
 		}
 		p := s.Prog(loadByType(v.Type))
-		gc.AddrAuto(&p.From, v.Args[0])
+		ssagen.AddrAuto(&p.From, v.Args[0])
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.OpStoreReg:
@@ -557,10 +557,10 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(storeByType(v.Type))
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddrAuto(&p.To, v)
+		ssagen.AddrAuto(&p.To, v)
 	case ssa.OpS390XLoweredGetClosurePtr:
 		// Closure pointer is R12 (already)
-		gc.CheckLoweredGetClosurePtr(v)
+		ssagen.CheckLoweredGetClosurePtr(v)
 	case ssa.OpS390XLoweredRound32F, ssa.OpS390XLoweredRound64F:
 		// input is already rounded
 	case ssa.OpS390XLoweredGetG:
@@ -593,7 +593,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(obj.ACALL)
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.BoundsCheckFunc[v.AuxInt]
+		p.To.Sym = ssagen.BoundsCheckFunc[v.AuxInt]
 		s.UseArgs(16) // space used in callee args area by assembly stubs
 	case ssa.OpS390XFLOGR, ssa.OpS390XPOPCNT,
 		ssa.OpS390XNEG, ssa.OpS390XNEGW,
@@ -637,7 +637,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(s390x.AMOVBZ)
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = s390x.REGTMP
 		if logopt.Enabled() {
@@ -672,7 +672,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.Reg = v.Args[len(v.Args)-2].Reg()
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 	case ssa.OpS390XLoweredMove:
 		// Inputs must be valid pointers to memory,
 		// so adjust arg0 and arg1 as part of the expansion.
@@ -764,7 +764,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg0()
 	case ssa.OpS390XMOVBatomicstore, ssa.OpS390XMOVWatomicstore, ssa.OpS390XMOVDatomicstore:
@@ -773,7 +773,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Reg = v.Args[1].Reg()
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 	case ssa.OpS390XLAN, ssa.OpS390XLAO:
 		// LA(N|O) Ry, TMP, 0(Rx)
 		op := s.Prog(v.Op.Asm())
@@ -808,7 +808,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Reg = v.Args[1].Reg()
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 	case ssa.OpS390XLoweredAtomicCas32, ssa.OpS390XLoweredAtomicCas64:
 		// Convert the flags output of CS{,G} into a bool.
 		//    CS{,G} arg1, arg2, arg0
@@ -824,7 +824,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		cs.Reg = v.Args[2].Reg()      // new
 		cs.To.Type = obj.TYPE_MEM
 		cs.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&cs.To, v)
+		ssagen.AddAux(&cs.To, v)
 
 		// MOVD $0, ret
 		movd := s.Prog(s390x.AMOVD)
@@ -859,7 +859,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		load.From.Reg = v.Args[0].Reg()
 		load.To.Type = obj.TYPE_REG
 		load.To.Reg = v.Reg0()
-		gc.AddAux(&load.From, v)
+		ssagen.AddAux(&load.From, v)
 
 		// CS{,G} ret, arg1, arg0
 		cs := s.Prog(v.Op.Asm())
@@ -868,7 +868,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		cs.Reg = v.Args[1].Reg() // new
 		cs.To.Type = obj.TYPE_MEM
 		cs.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&cs.To, v)
+		ssagen.AddAux(&cs.To, v)
 
 		// BNE cs
 		bne := s.Prog(s390x.ABNE)
@@ -908,14 +908,14 @@ func blockAsm(b *ssa.Block) obj.As {
 	panic("unreachable")
 }
 
-func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
+func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
 	// Handle generic blocks first.
 	switch b.Kind {
 	case ssa.BlockPlain:
 		if b.Succs[0].Block() != next {
 			p := s.Prog(s390x.ABR)
 			p.To.Type = obj.TYPE_BRANCH
-			s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+			s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
 		}
 		return
 	case ssa.BlockDefer:
diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/ssagen/abi.go
similarity index 69%
rename from src/cmd/compile/internal/gc/gsubr.go
rename to src/cmd/compile/internal/ssagen/abi.go
index 81f7956d2e..af08fcb7c3 100644
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -1,36 +1,18 @@
-// Derived from Inferno utils/6c/txt.c
-// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6c/txt.c
-//
-//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
-//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
-//	Portions Copyright © 1997-1999 Vita Nuova Limited
-//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
-//	Portions Copyright © 2004,2006 Bruce Ellis
-//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
-//	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
-//	Portions Copyright © 2009 The Go Authors. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
+// Copyright 2009 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 gc
+//go:generate go run mkbuiltin.go
+
+package ssagen
 
 import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"strings"
+
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/escape"
 	"cmd/compile/internal/ir"
@@ -38,10 +20,211 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
-	"fmt"
-	"os"
 )
 
+// useNewABIWrapGen returns TRUE if the compiler should generate an
+// ABI wrapper for the function 'f'.
+func useABIWrapGen(f *ir.Func) bool {
+	if !base.Flag.ABIWrap {
+		return false
+	}
+
+	// Support limit option for bisecting.
+	if base.Flag.ABIWrapLimit == 1 {
+		return false
+	}
+	if base.Flag.ABIWrapLimit < 1 {
+		return true
+	}
+	base.Flag.ABIWrapLimit--
+	if base.Debug.ABIWrap != 0 && base.Flag.ABIWrapLimit == 1 {
+		fmt.Fprintf(os.Stderr, "=-= limit reached after new wrapper for %s\n",
+			f.LSym.Name)
+	}
+
+	return true
+}
+
+// symabiDefs and symabiRefs record the defined and referenced ABIs of
+// symbols required by non-Go code. These are keyed by link symbol
+// name, where the local package prefix is always `"".`
+var symabiDefs, symabiRefs map[string]obj.ABI
+
+func CgoSymABIs() {
+	// The linker expects an ABI0 wrapper for all cgo-exported
+	// functions.
+	for _, prag := range typecheck.Target.CgoPragmas {
+		switch prag[0] {
+		case "cgo_export_static", "cgo_export_dynamic":
+			if symabiRefs == nil {
+				symabiRefs = make(map[string]obj.ABI)
+			}
+			symabiRefs[prag[1]] = obj.ABI0
+		}
+	}
+}
+
+// ReadSymABIs reads a symabis file that specifies definitions and
+// references of text symbols by ABI.
+//
+// The symabis format is a set of lines, where each line is a sequence
+// of whitespace-separated fields. The first field is a verb and is
+// either "def" for defining a symbol ABI or "ref" for referencing a
+// symbol using an ABI. For both "def" and "ref", the second field is
+// the symbol name and the third field is the ABI name, as one of the
+// named cmd/internal/obj.ABI constants.
+func ReadSymABIs(file, myimportpath string) {
+	data, err := ioutil.ReadFile(file)
+	if err != nil {
+		log.Fatalf("-symabis: %v", err)
+	}
+
+	symabiDefs = make(map[string]obj.ABI)
+	symabiRefs = make(map[string]obj.ABI)
+
+	localPrefix := ""
+	if myimportpath != "" {
+		// Symbols in this package may be written either as
+		// "".X or with the package's import path already in
+		// the symbol.
+		localPrefix = objabi.PathToPrefix(myimportpath) + "."
+	}
+
+	for lineNum, line := range strings.Split(string(data), "\n") {
+		lineNum++ // 1-based
+		line = strings.TrimSpace(line)
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+
+		parts := strings.Fields(line)
+		switch parts[0] {
+		case "def", "ref":
+			// Parse line.
+			if len(parts) != 3 {
+				log.Fatalf(`%s:%d: invalid symabi: syntax is "%s sym abi"`, file, lineNum, parts[0])
+			}
+			sym, abistr := parts[1], parts[2]
+			abi, valid := obj.ParseABI(abistr)
+			if !valid {
+				log.Fatalf(`%s:%d: invalid symabi: unknown abi "%s"`, file, lineNum, abistr)
+			}
+
+			// If the symbol is already prefixed with
+			// myimportpath, rewrite it to start with ""
+			// so it matches the compiler's internal
+			// symbol names.
+			if localPrefix != "" && strings.HasPrefix(sym, localPrefix) {
+				sym = `"".` + sym[len(localPrefix):]
+			}
+
+			// Record for later.
+			if parts[0] == "def" {
+				symabiDefs[sym] = abi
+			} else {
+				symabiRefs[sym] = abi
+			}
+		default:
+			log.Fatalf(`%s:%d: invalid symabi type "%s"`, file, lineNum, parts[0])
+		}
+	}
+}
+
+// InitLSym defines f's obj.LSym and initializes it based on the
+// properties of f. This includes setting the symbol flags and ABI and
+// creating and initializing related DWARF symbols.
+//
+// InitLSym must be called exactly once per function and must be
+// called for both functions with bodies and functions without bodies.
+// For body-less functions, we only create the LSym; for functions
+// with bodies call a helper to setup up / populate the LSym.
+func InitLSym(f *ir.Func, hasBody bool) {
+	// FIXME: for new-style ABI wrappers, we set up the lsym at the
+	// point the wrapper is created.
+	if f.LSym != nil && base.Flag.ABIWrap {
+		return
+	}
+	selectLSym(f, hasBody)
+	if hasBody {
+		setupTextLSym(f, 0)
+	}
+}
+
+// selectLSym sets up the LSym for a given function, and
+// makes calls to helpers to create ABI wrappers if needed.
+func selectLSym(f *ir.Func, hasBody bool) {
+	if f.LSym != nil {
+		base.Fatalf("Func.initLSym called twice")
+	}
+
+	if nam := f.Nname; !ir.IsBlank(nam) {
+
+		var wrapperABI obj.ABI
+		needABIWrapper := false
+		defABI, hasDefABI := symabiDefs[nam.Sym().LinksymName()]
+		if hasDefABI && defABI == obj.ABI0 {
+			// Symbol is defined as ABI0. Create an
+			// Internal -> ABI0 wrapper.
+			f.LSym = nam.Sym().LinksymABI0()
+			needABIWrapper, wrapperABI = true, obj.ABIInternal
+		} else {
+			f.LSym = nam.Sym().Linksym()
+			// No ABI override. Check that the symbol is
+			// using the expected ABI.
+			want := obj.ABIInternal
+			if f.LSym.ABI() != want {
+				base.Fatalf("function symbol %s has the wrong ABI %v, expected %v", f.LSym.Name, f.LSym.ABI(), want)
+			}
+		}
+		if f.Pragma&ir.Systemstack != 0 {
+			f.LSym.Set(obj.AttrCFunc, true)
+		}
+
+		isLinknameExported := nam.Sym().Linkname != "" && (hasBody || hasDefABI)
+		if abi, ok := symabiRefs[f.LSym.Name]; (ok && abi == obj.ABI0) || isLinknameExported {
+			// Either 1) this symbol is definitely
+			// referenced as ABI0 from this package; or 2)
+			// this symbol is defined in this package but
+			// given a linkname, indicating that it may be
+			// referenced from another package. Create an
+			// ABI0 -> Internal wrapper so it can be
+			// called as ABI0. In case 2, it's important
+			// that we know it's defined in this package
+			// since other packages may "pull" symbols
+			// using linkname and we don't want to create
+			// duplicate ABI wrappers.
+			if f.LSym.ABI() != obj.ABI0 {
+				needABIWrapper, wrapperABI = true, obj.ABI0
+			}
+		}
+
+		if needABIWrapper {
+			if !useABIWrapGen(f) {
+				// Fallback: use alias instead. FIXME.
+
+				// These LSyms have the same name as the
+				// native function, so we create them directly
+				// rather than looking them up. The uniqueness
+				// of f.lsym ensures uniqueness of asym.
+				asym := &obj.LSym{
+					Name: f.LSym.Name,
+					Type: objabi.SABIALIAS,
+					R:    []obj.Reloc{{Sym: f.LSym}}, // 0 size, so "informational"
+				}
+				asym.SetABI(wrapperABI)
+				asym.Set(obj.AttrDuplicateOK, true)
+				base.Ctxt.ABIAliases = append(base.Ctxt.ABIAliases, asym)
+			} else {
+				if base.Debug.ABIWrap != 0 {
+					fmt.Fprintf(os.Stderr, "=-= %v to %v wrapper for %s.%s\n",
+						wrapperABI, 1-wrapperABI, types.LocalPkg.Path, f.LSym.Name)
+				}
+				makeABIWrapper(f, wrapperABI)
+			}
+		}
+	}
+}
+
 // makeABIWrapper creates a new function that wraps a cross-ABI call
 // to "f".  The wrapper is marked as an ABIWRAPPER.
 func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
@@ -152,101 +335,6 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 	ir.CurFunc = savedcurfn
 }
 
-// initLSym defines f's obj.LSym and initializes it based on the
-// properties of f. This includes setting the symbol flags and ABI and
-// creating and initializing related DWARF symbols.
-//
-// initLSym must be called exactly once per function and must be
-// called for both functions with bodies and functions without bodies.
-// For body-less functions, we only create the LSym; for functions
-// with bodies call a helper to setup up / populate the LSym.
-func initLSym(f *ir.Func, hasBody bool) {
-	// FIXME: for new-style ABI wrappers, we set up the lsym at the
-	// point the wrapper is created.
-	if f.LSym != nil && base.Flag.ABIWrap {
-		return
-	}
-	selectLSym(f, hasBody)
-	if hasBody {
-		setupTextLSym(f, 0)
-	}
-}
-
-// selectLSym sets up the LSym for a given function, and
-// makes calls to helpers to create ABI wrappers if needed.
-func selectLSym(f *ir.Func, hasBody bool) {
-	if f.LSym != nil {
-		base.Fatalf("Func.initLSym called twice")
-	}
-
-	if nam := f.Nname; !ir.IsBlank(nam) {
-
-		var wrapperABI obj.ABI
-		needABIWrapper := false
-		defABI, hasDefABI := symabiDefs[nam.Sym().LinksymName()]
-		if hasDefABI && defABI == obj.ABI0 {
-			// Symbol is defined as ABI0. Create an
-			// Internal -> ABI0 wrapper.
-			f.LSym = nam.Sym().LinksymABI0()
-			needABIWrapper, wrapperABI = true, obj.ABIInternal
-		} else {
-			f.LSym = nam.Sym().Linksym()
-			// No ABI override. Check that the symbol is
-			// using the expected ABI.
-			want := obj.ABIInternal
-			if f.LSym.ABI() != want {
-				base.Fatalf("function symbol %s has the wrong ABI %v, expected %v", f.LSym.Name, f.LSym.ABI(), want)
-			}
-		}
-		if f.Pragma&ir.Systemstack != 0 {
-			f.LSym.Set(obj.AttrCFunc, true)
-		}
-
-		isLinknameExported := nam.Sym().Linkname != "" && (hasBody || hasDefABI)
-		if abi, ok := symabiRefs[f.LSym.Name]; (ok && abi == obj.ABI0) || isLinknameExported {
-			// Either 1) this symbol is definitely
-			// referenced as ABI0 from this package; or 2)
-			// this symbol is defined in this package but
-			// given a linkname, indicating that it may be
-			// referenced from another package. Create an
-			// ABI0 -> Internal wrapper so it can be
-			// called as ABI0. In case 2, it's important
-			// that we know it's defined in this package
-			// since other packages may "pull" symbols
-			// using linkname and we don't want to create
-			// duplicate ABI wrappers.
-			if f.LSym.ABI() != obj.ABI0 {
-				needABIWrapper, wrapperABI = true, obj.ABI0
-			}
-		}
-
-		if needABIWrapper {
-			if !useABIWrapGen(f) {
-				// Fallback: use alias instead. FIXME.
-
-				// These LSyms have the same name as the
-				// native function, so we create them directly
-				// rather than looking them up. The uniqueness
-				// of f.lsym ensures uniqueness of asym.
-				asym := &obj.LSym{
-					Name: f.LSym.Name,
-					Type: objabi.SABIALIAS,
-					R:    []obj.Reloc{{Sym: f.LSym}}, // 0 size, so "informational"
-				}
-				asym.SetABI(wrapperABI)
-				asym.Set(obj.AttrDuplicateOK, true)
-				base.Ctxt.ABIAliases = append(base.Ctxt.ABIAliases, asym)
-			} else {
-				if base.Debug.ABIWrap != 0 {
-					fmt.Fprintf(os.Stderr, "=-= %v to %v wrapper for %s.%s\n",
-						wrapperABI, 1-wrapperABI, types.LocalPkg.Path, f.LSym.Name)
-				}
-				makeABIWrapper(f, wrapperABI)
-			}
-		}
-	}
-}
-
 // setupTextLsym initializes the LSym for a with-body text symbol.
 func setupTextLSym(f *ir.Func, flag int) {
 	if f.Dupok() {
diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/ssagen/arch.go
similarity index 68%
rename from src/cmd/compile/internal/gc/go.go
rename to src/cmd/compile/internal/ssagen/arch.go
index ba838a5ff5..cc50ab36b5 100644
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/ssagen/arch.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package ssagen
 
 import (
 	"cmd/compile/internal/objw"
@@ -10,11 +10,11 @@ import (
 	"cmd/internal/obj"
 )
 
-var pragcgobuf [][]string
+var Arch ArchInfo
 
 // interface to back end
 
-type Arch struct {
+type ArchInfo struct {
 	LinkArch *obj.LinkArch
 
 	REGSP     int
@@ -31,22 +31,12 @@ type Arch struct {
 	Ginsnopdefer func(*objw.Progs) *obj.Prog // special ginsnop for deferreturn
 
 	// SSAMarkMoves marks any MOVXconst ops that need to avoid clobbering flags.
-	SSAMarkMoves func(*SSAGenState, *ssa.Block)
+	SSAMarkMoves func(*State, *ssa.Block)
 
 	// SSAGenValue emits Prog(s) for the Value.
-	SSAGenValue func(*SSAGenState, *ssa.Value)
+	SSAGenValue func(*State, *ssa.Value)
 
 	// SSAGenBlock emits end-of-block Progs. SSAGenValue should be called
 	// for all values in the block before SSAGenBlock.
-	SSAGenBlock func(s *SSAGenState, b, next *ssa.Block)
+	SSAGenBlock func(s *State, b, next *ssa.Block)
 }
-
-var thearch Arch
-
-var (
-	BoundsCheckFunc [ssa.BoundsKindCount]*obj.LSym
-	ExtendCheckFunc [ssa.BoundsKindCount]*obj.LSym
-)
-
-// GCWriteBarrierReg maps from registers to gcWriteBarrier implementation LSyms.
-var GCWriteBarrierReg map[int16]*obj.LSym
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/ssagen/nowb.go
similarity index 99%
rename from src/cmd/compile/internal/gc/dcl.go
rename to src/cmd/compile/internal/ssagen/nowb.go
index 7b2bf5b606..7b2e68c8e7 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/ssagen/nowb.go
@@ -2,17 +2,18 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package ssagen
 
 import (
 	"bytes"
+	"fmt"
+
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/src"
-	"fmt"
 )
 
 func EnableNoWriteBarrierRecCheck() {
diff --git a/src/cmd/compile/internal/ssagen/pgen.go b/src/cmd/compile/internal/ssagen/pgen.go
new file mode 100644
index 0000000000..bc6be20d86
--- /dev/null
+++ b/src/cmd/compile/internal/ssagen/pgen.go
@@ -0,0 +1,279 @@
+// Copyright 2011 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 ssagen
+
+import (
+	"internal/race"
+	"math/rand"
+	"sort"
+	"sync"
+	"time"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/objw"
+	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/typecheck"
+	"cmd/compile/internal/types"
+	"cmd/internal/obj"
+	"cmd/internal/objabi"
+	"cmd/internal/src"
+	"cmd/internal/sys"
+)
+
+// cmpstackvarlt reports whether the stack variable a sorts before b.
+//
+// Sort the list of stack variables. Autos after anything else,
+// within autos, unused after used, within used, things with
+// pointers first, zeroed things first, and then decreasing size.
+// Because autos are laid out in decreasing addresses
+// on the stack, pointers first, zeroed things first and decreasing size
+// really means, in memory, things with pointers needing zeroing at
+// the top of the stack and increasing in size.
+// Non-autos sort on offset.
+func cmpstackvarlt(a, b *ir.Name) bool {
+	if (a.Class_ == ir.PAUTO) != (b.Class_ == ir.PAUTO) {
+		return b.Class_ == ir.PAUTO
+	}
+
+	if a.Class_ != ir.PAUTO {
+		return a.FrameOffset() < b.FrameOffset()
+	}
+
+	if a.Used() != b.Used() {
+		return a.Used()
+	}
+
+	ap := a.Type().HasPointers()
+	bp := b.Type().HasPointers()
+	if ap != bp {
+		return ap
+	}
+
+	ap = a.Needzero()
+	bp = b.Needzero()
+	if ap != bp {
+		return ap
+	}
+
+	if a.Type().Width != b.Type().Width {
+		return a.Type().Width > b.Type().Width
+	}
+
+	return a.Sym().Name < b.Sym().Name
+}
+
+// byStackvar implements sort.Interface for []*Node using cmpstackvarlt.
+type byStackVar []*ir.Name
+
+func (s byStackVar) Len() int           { return len(s) }
+func (s byStackVar) Less(i, j int) bool { return cmpstackvarlt(s[i], s[j]) }
+func (s byStackVar) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
+func (s *ssafn) AllocFrame(f *ssa.Func) {
+	s.stksize = 0
+	s.stkptrsize = 0
+	fn := s.curfn
+
+	// Mark the PAUTO's unused.
+	for _, ln := range fn.Dcl {
+		if ln.Class_ == ir.PAUTO {
+			ln.SetUsed(false)
+		}
+	}
+
+	for _, l := range f.RegAlloc {
+		if ls, ok := l.(ssa.LocalSlot); ok {
+			ls.N.Name().SetUsed(true)
+		}
+	}
+
+	scratchUsed := false
+	for _, b := range f.Blocks {
+		for _, v := range b.Values {
+			if n, ok := v.Aux.(*ir.Name); ok {
+				switch n.Class_ {
+				case ir.PPARAM, ir.PPARAMOUT:
+					// Don't modify nodfp; it is a global.
+					if n != ir.RegFP {
+						n.Name().SetUsed(true)
+					}
+				case ir.PAUTO:
+					n.Name().SetUsed(true)
+				}
+			}
+			if !scratchUsed {
+				scratchUsed = v.Op.UsesScratch()
+			}
+
+		}
+	}
+
+	if f.Config.NeedsFpScratch && scratchUsed {
+		s.scratchFpMem = typecheck.TempAt(src.NoXPos, s.curfn, types.Types[types.TUINT64])
+	}
+
+	sort.Sort(byStackVar(fn.Dcl))
+
+	// Reassign stack offsets of the locals that are used.
+	lastHasPtr := false
+	for i, n := range fn.Dcl {
+		if n.Op() != ir.ONAME || n.Class_ != ir.PAUTO {
+			continue
+		}
+		if !n.Used() {
+			fn.Dcl = fn.Dcl[:i]
+			break
+		}
+
+		types.CalcSize(n.Type())
+		w := n.Type().Width
+		if w >= types.MaxWidth || w < 0 {
+			base.Fatalf("bad width")
+		}
+		if w == 0 && lastHasPtr {
+			// Pad between a pointer-containing object and a zero-sized object.
+			// This prevents a pointer to the zero-sized object from being interpreted
+			// as a pointer to the pointer-containing object (and causing it
+			// to be scanned when it shouldn't be). See issue 24993.
+			w = 1
+		}
+		s.stksize += w
+		s.stksize = types.Rnd(s.stksize, int64(n.Type().Align))
+		if n.Type().HasPointers() {
+			s.stkptrsize = s.stksize
+			lastHasPtr = true
+		} else {
+			lastHasPtr = false
+		}
+		if Arch.LinkArch.InFamily(sys.MIPS, sys.MIPS64, sys.ARM, sys.ARM64, sys.PPC64, sys.S390X) {
+			s.stksize = types.Rnd(s.stksize, int64(types.PtrSize))
+		}
+		n.SetFrameOffset(-s.stksize)
+	}
+
+	s.stksize = types.Rnd(s.stksize, int64(types.RegSize))
+	s.stkptrsize = types.Rnd(s.stkptrsize, int64(types.RegSize))
+}
+
+const maxStackSize = 1 << 30
+
+// Compile builds an SSA backend function,
+// uses it to generate a plist,
+// and flushes that plist to machine code.
+// worker indicates which of the backend workers is doing the processing.
+func Compile(fn *ir.Func, worker int) {
+	f := buildssa(fn, worker)
+	// Note: check arg size to fix issue 25507.
+	if f.Frontend().(*ssafn).stksize >= maxStackSize || fn.Type().ArgWidth() >= maxStackSize {
+		largeStackFramesMu.Lock()
+		largeStackFrames = append(largeStackFrames, largeStack{locals: f.Frontend().(*ssafn).stksize, args: fn.Type().ArgWidth(), pos: fn.Pos()})
+		largeStackFramesMu.Unlock()
+		return
+	}
+	pp := objw.NewProgs(fn, worker)
+	defer pp.Free()
+	genssa(f, pp)
+	// Check frame size again.
+	// The check above included only the space needed for local variables.
+	// After genssa, the space needed includes local variables and the callee arg region.
+	// We must do this check prior to calling pp.Flush.
+	// If there are any oversized stack frames,
+	// the assembler may emit inscrutable complaints about invalid instructions.
+	if pp.Text.To.Offset >= maxStackSize {
+		largeStackFramesMu.Lock()
+		locals := f.Frontend().(*ssafn).stksize
+		largeStackFrames = append(largeStackFrames, largeStack{locals: locals, args: fn.Type().ArgWidth(), callee: pp.Text.To.Offset - locals, pos: fn.Pos()})
+		largeStackFramesMu.Unlock()
+		return
+	}
+
+	pp.Flush() // assemble, fill in boilerplate, etc.
+	// fieldtrack must be called after pp.Flush. See issue 20014.
+	fieldtrack(pp.Text.From.Sym, fn.FieldTrack)
+}
+
+func init() {
+	if race.Enabled {
+		rand.Seed(time.Now().UnixNano())
+	}
+}
+
+// StackOffset returns the stack location of a LocalSlot relative to the
+// stack pointer, suitable for use in a DWARF location entry. This has nothing
+// to do with its offset in the user variable.
+func StackOffset(slot ssa.LocalSlot) int32 {
+	n := slot.N
+	var off int64
+	switch n.Class_ {
+	case ir.PAUTO:
+		off = n.FrameOffset()
+		if base.Ctxt.FixedFrameSize() == 0 {
+			off -= int64(types.PtrSize)
+		}
+		if objabi.Framepointer_enabled || objabi.GOARCH == "arm64" {
+			// There is a word space for FP on ARM64 even if the frame pointer is disabled
+			off -= int64(types.PtrSize)
+		}
+	case ir.PPARAM, ir.PPARAMOUT:
+		off = n.FrameOffset() + base.Ctxt.FixedFrameSize()
+	}
+	return int32(off + slot.Off)
+}
+
+// fieldtrack adds R_USEFIELD relocations to fnsym to record any
+// struct fields that it used.
+func fieldtrack(fnsym *obj.LSym, tracked map[*types.Sym]struct{}) {
+	if fnsym == nil {
+		return
+	}
+	if objabi.Fieldtrack_enabled == 0 || len(tracked) == 0 {
+		return
+	}
+
+	trackSyms := make([]*types.Sym, 0, len(tracked))
+	for sym := range tracked {
+		trackSyms = append(trackSyms, sym)
+	}
+	sort.Sort(symByName(trackSyms))
+	for _, sym := range trackSyms {
+		r := obj.Addrel(fnsym)
+		r.Sym = sym.Linksym()
+		r.Type = objabi.R_USEFIELD
+	}
+}
+
+type symByName []*types.Sym
+
+func (a symByName) Len() int           { return len(a) }
+func (a symByName) Less(i, j int) bool { return a[i].Name < a[j].Name }
+func (a symByName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+
+// largeStack is info about a function whose stack frame is too large (rare).
+type largeStack struct {
+	locals int64
+	args   int64
+	callee int64
+	pos    src.XPos
+}
+
+var (
+	largeStackFramesMu sync.Mutex // protects largeStackFrames
+	largeStackFrames   []largeStack
+)
+
+func CheckLargeStacks() {
+	// Check whether any of the functions we have compiled have gigantic stack frames.
+	sort.Slice(largeStackFrames, func(i, j int) bool {
+		return largeStackFrames[i].pos.Before(largeStackFrames[j].pos)
+	})
+	for _, large := range largeStackFrames {
+		if large.callee != 0 {
+			base.ErrorfAt(large.pos, "stack frame too large (>1GB): %d MB locals + %d MB args + %d MB callee", large.locals>>20, large.args>>20, large.callee>>20)
+		} else {
+			base.ErrorfAt(large.pos, "stack frame too large (>1GB): %d MB locals + %d MB args", large.locals>>20, large.args>>20)
+		}
+	}
+}
diff --git a/src/cmd/compile/internal/gc/pgen_test.go b/src/cmd/compile/internal/ssagen/pgen_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/pgen_test.go
rename to src/cmd/compile/internal/ssagen/pgen_test.go
index 95c4b24fa1..82d8447e9f 100644
--- a/src/cmd/compile/internal/gc/pgen_test.go
+++ b/src/cmd/compile/internal/ssagen/pgen_test.go
@@ -2,16 +2,17 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package ssagen
 
 import (
+	"reflect"
+	"sort"
+	"testing"
+
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
-	"reflect"
-	"sort"
-	"testing"
 )
 
 func typeWithoutPointers() *types.Type {
diff --git a/src/cmd/compile/internal/gc/phi.go b/src/cmd/compile/internal/ssagen/phi.go
similarity index 97%
rename from src/cmd/compile/internal/gc/phi.go
rename to src/cmd/compile/internal/ssagen/phi.go
index 75ce18ff84..01ad211282 100644
--- a/src/cmd/compile/internal/gc/phi.go
+++ b/src/cmd/compile/internal/ssagen/phi.go
@@ -2,15 +2,16 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package ssagen
 
 import (
+	"container/heap"
+	"fmt"
+
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
-	"container/heap"
-	"fmt"
 )
 
 // This file contains the algorithm to place phi nodes in a function.
@@ -23,13 +24,13 @@ const smallBlocks = 500
 
 const debugPhi = false
 
-// FwdRefAux wraps an arbitrary ir.Node as an ssa.Aux for use with OpFwdref.
-type FwdRefAux struct {
+// fwdRefAux wraps an arbitrary ir.Node as an ssa.Aux for use with OpFwdref.
+type fwdRefAux struct {
 	_ [0]func() // ensure ir.Node isn't compared for equality
 	N ir.Node
 }
 
-func (FwdRefAux) CanBeAnSSAAux() {}
+func (fwdRefAux) CanBeAnSSAAux() {}
 
 // insertPhis finds all the places in the function where a phi is
 // necessary and inserts them.
@@ -87,7 +88,7 @@ func (s *phiState) insertPhis() {
 			if v.Op != ssa.OpFwdRef {
 				continue
 			}
-			var_ := v.Aux.(FwdRefAux).N
+			var_ := v.Aux.(fwdRefAux).N
 
 			// Optimization: look back 1 block for the definition.
 			if len(b.Preds) == 1 {
@@ -334,7 +335,7 @@ func (s *phiState) resolveFwdRefs() {
 			if v.Op != ssa.OpFwdRef {
 				continue
 			}
-			n := s.varnum[v.Aux.(FwdRefAux).N]
+			n := s.varnum[v.Aux.(fwdRefAux).N]
 			v.Op = ssa.OpCopy
 			v.Aux = nil
 			v.AddArg(values[n])
@@ -465,7 +466,7 @@ func (s *simplePhiState) insertPhis() {
 				continue
 			}
 			s.fwdrefs = append(s.fwdrefs, v)
-			var_ := v.Aux.(FwdRefAux).N
+			var_ := v.Aux.(fwdRefAux).N
 			if _, ok := s.defvars[b.ID][var_]; !ok {
 				s.defvars[b.ID][var_] = v // treat FwdDefs as definitions.
 			}
@@ -479,7 +480,7 @@ loop:
 		v := s.fwdrefs[len(s.fwdrefs)-1]
 		s.fwdrefs = s.fwdrefs[:len(s.fwdrefs)-1]
 		b := v.Block
-		var_ := v.Aux.(FwdRefAux).N
+		var_ := v.Aux.(fwdRefAux).N
 		if b == s.f.Entry {
 			// No variable should be live at entry.
 			s.s.Fatalf("Value live at entry. It shouldn't be. func %s, node %v, value %v", s.f.Name, var_, v)
@@ -546,7 +547,7 @@ func (s *simplePhiState) lookupVarOutgoing(b *ssa.Block, t *types.Type, var_ ir.
 		}
 	}
 	// Generate a FwdRef for the variable and return that.
-	v := b.NewValue0A(line, ssa.OpFwdRef, t, FwdRefAux{N: var_})
+	v := b.NewValue0A(line, ssa.OpFwdRef, t, fwdRefAux{N: var_})
 	s.defvars[b.ID][var_] = v
 	if var_.Op() == ir.ONAME {
 		s.s.addNamedValue(var_.(*ir.Name), v)
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
similarity index 98%
rename from src/cmd/compile/internal/gc/ssa.go
rename to src/cmd/compile/internal/ssagen/ssa.go
index 997bcb6d5e..a77e57a5b6 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -2,9 +2,11 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package ssagen
 
 import (
+	"bufio"
+	"bytes"
 	"encoding/binary"
 	"fmt"
 	"go/constant"
@@ -14,8 +16,6 @@ import (
 	"sort"
 	"strings"
 
-	"bufio"
-	"bytes"
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/liveness"
@@ -41,20 +41,16 @@ var ssaDumpStdout bool // whether to dump to stdout
 var ssaDumpCFG string  // generate CFGs for these phases
 const ssaDumpFile = "ssa.html"
 
-// The max number of defers in a function using open-coded defers. We enforce this
-// limit because the deferBits bitmask is currently a single byte (to minimize code size)
-const maxOpenDefers = 8
-
 // ssaDumpInlined holds all inlined functions when ssaDump contains a function name.
 var ssaDumpInlined []*ir.Func
 
-func ssaDumpInline(fn *ir.Func) {
+func DumpInline(fn *ir.Func) {
 	if ssaDump != "" && ssaDump == ir.FuncName(fn) {
 		ssaDumpInlined = append(ssaDumpInlined, fn)
 	}
 }
 
-func initSSAEnv() {
+func InitEnv() {
 	ssaDump = os.Getenv("GOSSAFUNC")
 	ssaDir = os.Getenv("GOSSADIR")
 	if ssaDump != "" {
@@ -70,10 +66,10 @@ func initSSAEnv() {
 	}
 }
 
-func initssaconfig() {
+func InitConfig() {
 	types_ := ssa.NewTypes()
 
-	if thearch.SoftFloat {
+	if Arch.SoftFloat {
 		softfloatInit()
 	}
 
@@ -91,7 +87,7 @@ func initssaconfig() {
 	_ = types.NewPtr(types.ErrorType)                                       // *error
 	types.NewPtrCacheEnabled = false
 	ssaConfig = ssa.NewConfig(base.Ctxt.Arch.Name, *types_, base.Ctxt, base.Flag.N == 0)
-	ssaConfig.SoftFloat = thearch.SoftFloat
+	ssaConfig.SoftFloat = Arch.SoftFloat
 	ssaConfig.Race = base.Flag.Race
 	ssaCaches = make([]ssa.Cache, base.Flag.LowerC)
 
@@ -148,7 +144,7 @@ func initssaconfig() {
 		}
 	}
 
-	if thearch.LinkArch.Family == sys.Wasm {
+	if Arch.LinkArch.Family == sys.Wasm {
 		BoundsCheckFunc[ssa.BoundsIndex] = typecheck.LookupRuntimeFunc("goPanicIndex")
 		BoundsCheckFunc[ssa.BoundsIndexU] = typecheck.LookupRuntimeFunc("goPanicIndexU")
 		BoundsCheckFunc[ssa.BoundsSliceAlen] = typecheck.LookupRuntimeFunc("goPanicSliceAlen")
@@ -183,7 +179,7 @@ func initssaconfig() {
 		BoundsCheckFunc[ssa.BoundsSlice3C] = typecheck.LookupRuntimeFunc("panicSlice3C")
 		BoundsCheckFunc[ssa.BoundsSlice3CU] = typecheck.LookupRuntimeFunc("panicSlice3CU")
 	}
-	if thearch.LinkArch.PtrSize == 4 {
+	if Arch.LinkArch.PtrSize == 4 {
 		ExtendCheckFunc[ssa.BoundsIndex] = typecheck.LookupRuntimeVar("panicExtendIndex")
 		ExtendCheckFunc[ssa.BoundsIndexU] = typecheck.LookupRuntimeVar("panicExtendIndexU")
 		ExtendCheckFunc[ssa.BoundsSliceAlen] = typecheck.LookupRuntimeVar("panicExtendSliceAlen")
@@ -1215,7 +1211,7 @@ func (s *state) stmt(n ir.Node) {
 		n := n.(*ir.AssignListStmt)
 		res, resok := s.dottype(n.Rhs[0].(*ir.TypeAssertExpr), true)
 		deref := false
-		if !canSSAType(n.Rhs[0].Type()) {
+		if !TypeOK(n.Rhs[0].Type()) {
 			if res.Op != ssa.OpLoad {
 				s.Fatalf("dottype of non-load")
 			}
@@ -1351,7 +1347,7 @@ func (s *state) stmt(n ir.Node) {
 		}
 
 		var r *ssa.Value
-		deref := !canSSAType(t)
+		deref := !TypeOK(t)
 		if deref {
 			if rhs == nil {
 				r = nil // Signal assign to use OpZero.
@@ -2133,7 +2129,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		return s.load(n.Type(), addr)
 	case ir.ONAMEOFFSET:
 		n := n.(*ir.NameOffsetExpr)
-		if s.canSSAName(n.Name_) && canSSAType(n.Type()) {
+		if s.canSSAName(n.Name_) && TypeOK(n.Type()) {
 			return s.variable(n, n.Type())
 		}
 		addr := s.addr(n)
@@ -2352,18 +2348,18 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 
 		if ft.IsFloat() || tt.IsFloat() {
 			conv, ok := fpConvOpToSSA[twoTypes{s.concreteEtype(ft), s.concreteEtype(tt)}]
-			if s.config.RegSize == 4 && thearch.LinkArch.Family != sys.MIPS && !s.softFloat {
+			if s.config.RegSize == 4 && Arch.LinkArch.Family != sys.MIPS && !s.softFloat {
 				if conv1, ok1 := fpConvOpToSSA32[twoTypes{s.concreteEtype(ft), s.concreteEtype(tt)}]; ok1 {
 					conv = conv1
 				}
 			}
-			if thearch.LinkArch.Family == sys.ARM64 || thearch.LinkArch.Family == sys.Wasm || thearch.LinkArch.Family == sys.S390X || s.softFloat {
+			if Arch.LinkArch.Family == sys.ARM64 || Arch.LinkArch.Family == sys.Wasm || Arch.LinkArch.Family == sys.S390X || s.softFloat {
 				if conv1, ok1 := uint64fpConvOpToSSA[twoTypes{s.concreteEtype(ft), s.concreteEtype(tt)}]; ok1 {
 					conv = conv1
 				}
 			}
 
-			if thearch.LinkArch.Family == sys.MIPS && !s.softFloat {
+			if Arch.LinkArch.Family == sys.MIPS && !s.softFloat {
 				if ft.Size() == 4 && ft.IsInteger() && !ft.IsSigned() {
 					// tt is float32 or float64, and ft is also unsigned
 					if tt.Size() == 4 {
@@ -2713,7 +2709,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 			addr := s.constOffPtrSP(types.NewPtr(n.Type()), n.Offset)
 			return s.rawLoad(n.Type(), addr)
 		}
-		if canSSAType(n.Type()) {
+		if TypeOK(n.Type()) {
 			return s.newValue1I(ssa.OpSelectN, n.Type(), which, s.prevCall)
 		} else {
 			addr := s.newValue1I(ssa.OpSelectNAddr, types.NewPtr(n.Type()), which, s.prevCall)
@@ -2779,7 +2775,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 			p := s.addr(n)
 			return s.load(n.X.Type().Elem(), p)
 		case n.X.Type().IsArray():
-			if canSSAType(n.X.Type()) {
+			if TypeOK(n.X.Type()) {
 				// SSA can handle arrays of length at most 1.
 				bound := n.X.Type().NumElem()
 				a := s.expr(n.X)
@@ -3055,7 +3051,7 @@ func (s *state) append(n *ir.CallExpr, inplace bool) *ssa.Value {
 	}
 	args := make([]argRec, 0, nargs)
 	for _, n := range n.Args[1:] {
-		if canSSAType(n.Type()) {
+		if TypeOK(n.Type()) {
 			args = append(args, argRec{v: s.expr(n), store: true})
 		} else {
 			v := s.addr(n)
@@ -3418,7 +3414,7 @@ type intrinsicKey struct {
 	fn   string
 }
 
-func initSSATables() {
+func InitTables() {
 	intrinsics = map[intrinsicKey]intrinsicBuilder{}
 
 	var all []*sys.Arch
@@ -4297,7 +4293,7 @@ func findIntrinsic(sym *types.Sym) intrinsicBuilder {
 	}
 	// Skip intrinsifying math functions (which may contain hard-float
 	// instructions) when soft-float
-	if thearch.SoftFloat && pkg == "math" {
+	if Arch.SoftFloat && pkg == "math" {
 		return nil
 	}
 
@@ -4309,10 +4305,10 @@ func findIntrinsic(sym *types.Sym) intrinsicBuilder {
 			return nil
 		}
 	}
-	return intrinsics[intrinsicKey{thearch.LinkArch.Arch, pkg, fn}]
+	return intrinsics[intrinsicKey{Arch.LinkArch.Arch, pkg, fn}]
 }
 
-func isIntrinsicCall(n *ir.CallExpr) bool {
+func IsIntrinsicCall(n *ir.CallExpr) bool {
 	if n == nil {
 		return false
 	}
@@ -4427,7 +4423,7 @@ func (s *state) openDeferRecord(n *ir.CallExpr) {
 	}
 	for _, argn := range n.Rargs {
 		var v *ssa.Value
-		if canSSAType(argn.Type()) {
+		if TypeOK(argn.Type()) {
 			v = s.openDeferSave(nil, argn.Type(), s.expr(argn))
 		} else {
 			v = s.openDeferSave(argn, argn.Type(), nil)
@@ -4456,7 +4452,7 @@ func (s *state) openDeferRecord(n *ir.CallExpr) {
 // evaluated (via s.addr() below) to get the value that is to be stored. The
 // function returns an SSA value representing a pointer to the autotmp location.
 func (s *state) openDeferSave(n ir.Node, t *types.Type, val *ssa.Value) *ssa.Value {
-	canSSA := canSSAType(t)
+	canSSA := TypeOK(t)
 	var pos src.XPos
 	if canSSA {
 		pos = val.Pos
@@ -4570,7 +4566,7 @@ func (s *state) openDeferExit() {
 			ACArgs = append(ACArgs, ssa.Param{Type: f.Type, Offset: int32(argStart + f.Offset)})
 			if testLateExpansion {
 				var a *ssa.Value
-				if !canSSAType(f.Type) {
+				if !TypeOK(f.Type) {
 					a = s.newValue2(ssa.OpDereference, f.Type, argAddrVal, s.mem())
 				} else {
 					a = s.load(f.Type, argAddrVal)
@@ -4578,7 +4574,7 @@ func (s *state) openDeferExit() {
 				callArgs = append(callArgs, a)
 			} else {
 				addr := s.constOffPtrSP(pt, argStart+f.Offset)
-				if !canSSAType(f.Type) {
+				if !TypeOK(f.Type) {
 					s.move(f.Type, addr, argAddrVal)
 				} else {
 					argVal := s.load(f.Type, argAddrVal)
@@ -4946,7 +4942,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 // maybeNilCheckClosure checks if a nil check of a closure is needed in some
 // architecture-dependent situations and, if so, emits the nil check.
 func (s *state) maybeNilCheckClosure(closure *ssa.Value, k callKind) {
-	if thearch.LinkArch.Family == sys.Wasm || objabi.GOOS == "aix" && k != callGo {
+	if Arch.LinkArch.Family == sys.Wasm || objabi.GOOS == "aix" && k != callGo {
 		// On AIX, the closure needs to be verified as fn can be nil, except if it's a call go. This needs to be handled by the runtime to have the "go of nil func value" error.
 		// TODO(neelance): On other architectures this should be eliminated by the optimization steps
 		s.nilCheck(closure)
@@ -5139,7 +5135,7 @@ func (s *state) canSSA(n ir.Node) bool {
 	if n.Op() != ir.ONAME {
 		return false
 	}
-	return s.canSSAName(n.(*ir.Name)) && canSSAType(n.Type())
+	return s.canSSAName(n.(*ir.Name)) && TypeOK(n.Type())
 }
 
 func (s *state) canSSAName(name *ir.Name) bool {
@@ -5181,7 +5177,7 @@ func (s *state) canSSAName(name *ir.Name) bool {
 }
 
 // canSSA reports whether variables of type t are SSA-able.
-func canSSAType(t *types.Type) bool {
+func TypeOK(t *types.Type) bool {
 	types.CalcSize(t)
 	if t.Width > int64(4*types.PtrSize) {
 		// 4*Widthptr is an arbitrary constant. We want it
@@ -5195,7 +5191,7 @@ func canSSAType(t *types.Type) bool {
 		// not supported on SSA variables.
 		// TODO: allow if all indexes are constant.
 		if t.NumElem() <= 1 {
-			return canSSAType(t.Elem())
+			return TypeOK(t.Elem())
 		}
 		return false
 	case types.TSTRUCT:
@@ -5203,7 +5199,7 @@ func canSSAType(t *types.Type) bool {
 			return false
 		}
 		for _, t1 := range t.Fields().Slice() {
-			if !canSSAType(t1.Type) {
+			if !TypeOK(t1.Type) {
 				return false
 			}
 		}
@@ -5307,7 +5303,7 @@ func (s *state) boundsCheck(idx, len *ssa.Value, kind ssa.BoundsKind, bounded bo
 	b.AddEdgeTo(bPanic)
 
 	s.startBlock(bPanic)
-	if thearch.LinkArch.Family == sys.Wasm {
+	if Arch.LinkArch.Family == sys.Wasm {
 		// TODO(khr): figure out how to do "register" based calling convention for bounds checks.
 		// Should be similar to gcWriteBarrier, but I can't make it work.
 		s.rtcall(BoundsCheckFunc[kind], false, nil, idx, len)
@@ -5435,7 +5431,7 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
 	if testLateExpansion {
 		for i, t := range results {
 			off = types.Rnd(off, t.Alignment())
-			if canSSAType(t) {
+			if TypeOK(t) {
 				res[i] = s.newValue1I(ssa.OpSelectN, t, int64(i), call)
 			} else {
 				addr := s.newValue1I(ssa.OpSelectNAddr, types.NewPtr(t), int64(i), call)
@@ -5575,7 +5571,7 @@ func (s *state) storeTypePtrs(t *types.Type, left, right *ssa.Value) {
 func (s *state) putArg(n ir.Node, t *types.Type, off int64, forLateExpandedCall bool) (ssa.Param, *ssa.Value) {
 	var a *ssa.Value
 	if forLateExpandedCall {
-		if !canSSAType(t) {
+		if !TypeOK(t) {
 			a = s.newValue2(ssa.OpDereference, t, s.addr(n), s.mem())
 		} else {
 			a = s.expr(n)
@@ -5596,7 +5592,7 @@ func (s *state) storeArgWithBase(n ir.Node, t *types.Type, base *ssa.Value, off
 		addr = s.newValue1I(ssa.OpOffPtr, pt, off, base)
 	}
 
-	if !canSSAType(t) {
+	if !TypeOK(t) {
 		a := s.addr(n)
 		s.move(t, addr, a)
 		return
@@ -6146,7 +6142,7 @@ func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Val
 
 	var tmp ir.Node     // temporary for use with large types
 	var addr *ssa.Value // address of tmp
-	if commaok && !canSSAType(n.Type()) {
+	if commaok && !TypeOK(n.Type()) {
 		// unSSAable type, use temporary.
 		// TODO: get rid of some of these temporaries.
 		tmp = typecheck.TempAt(n.Pos(), s.curfn, n.Type())
@@ -6250,7 +6246,7 @@ func (s *state) variable(n ir.Node, t *types.Type) *ssa.Value {
 	}
 	// Make a FwdRef, which records a value that's live on block input.
 	// We'll find the matching definition as part of insertPhis.
-	v = s.newValue0A(ssa.OpFwdRef, t, FwdRefAux{N: n})
+	v = s.newValue0A(ssa.OpFwdRef, t, fwdRefAux{N: n})
 	s.fwdVars[n] = v
 	if n.Op() == ir.ONAME {
 		s.addNamedValue(n.(*ir.Name), v)
@@ -6300,8 +6296,8 @@ type Branch struct {
 	B *ssa.Block // target
 }
 
-// SSAGenState contains state needed during Prog generation.
-type SSAGenState struct {
+// State contains state needed during Prog generation.
+type State struct {
 	pp *objw.Progs
 
 	// Branches remembers all the branch instructions we've seen
@@ -6330,7 +6326,7 @@ type SSAGenState struct {
 }
 
 // Prog appends a new Prog.
-func (s *SSAGenState) Prog(as obj.As) *obj.Prog {
+func (s *State) Prog(as obj.As) *obj.Prog {
 	p := s.pp.Prog(as)
 	if ssa.LosesStmtMark(as) {
 		return p
@@ -6347,19 +6343,19 @@ func (s *SSAGenState) Prog(as obj.As) *obj.Prog {
 }
 
 // Pc returns the current Prog.
-func (s *SSAGenState) Pc() *obj.Prog {
+func (s *State) Pc() *obj.Prog {
 	return s.pp.Next
 }
 
 // SetPos sets the current source position.
-func (s *SSAGenState) SetPos(pos src.XPos) {
+func (s *State) SetPos(pos src.XPos) {
 	s.pp.Pos = pos
 }
 
 // Br emits a single branch instruction and returns the instruction.
 // Not all architectures need the returned instruction, but otherwise
 // the boilerplate is common to all.
-func (s *SSAGenState) Br(op obj.As, target *ssa.Block) *obj.Prog {
+func (s *State) Br(op obj.As, target *ssa.Block) *obj.Prog {
 	p := s.Prog(op)
 	p.To.Type = obj.TYPE_BRANCH
 	s.Branches = append(s.Branches, Branch{P: p, B: target})
@@ -6371,7 +6367,7 @@ func (s *SSAGenState) Br(op obj.As, target *ssa.Block) *obj.Prog {
 // Spill/fill/copy instructions from the register allocator,
 // phi functions, and instructions with a no-pos position
 // are examples of instructions that can cause churn.
-func (s *SSAGenState) DebugFriendlySetPosFrom(v *ssa.Value) {
+func (s *State) DebugFriendlySetPosFrom(v *ssa.Value) {
 	switch v.Op {
 	case ssa.OpPhi, ssa.OpCopy, ssa.OpLoadReg, ssa.OpStoreReg:
 		// These are not statements
@@ -6447,7 +6443,7 @@ func emitStackObjects(e *ssafn, pp *objw.Progs) {
 
 // genssa appends entries to pp for each instruction in f.
 func genssa(f *ssa.Func, pp *objw.Progs) {
-	var s SSAGenState
+	var s State
 
 	e := f.Frontend().(*ssafn)
 
@@ -6525,7 +6521,7 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 		s.pp.NextLive = objw.LivenessIndex{StackMapIndex: -1, IsUnsafePoint: liveness.IsUnsafe(f)}
 
 		// Emit values in block
-		thearch.SSAMarkMoves(&s, b)
+		Arch.SSAMarkMoves(&s, b)
 		for _, v := range b.Values {
 			x := s.pp.Next
 			s.DebugFriendlySetPosFrom(v)
@@ -6552,7 +6548,7 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 					v.Fatalf("OpConvert should be a no-op: %s; %s", v.Args[0].LongString(), v.LongString())
 				}
 			case ssa.OpInlMark:
-				p := thearch.Ginsnop(s.pp)
+				p := Arch.Ginsnop(s.pp)
 				if inlMarks == nil {
 					inlMarks = map[*obj.Prog]int32{}
 					inlMarksByPos = map[src.XPos][]*obj.Prog{}
@@ -6573,7 +6569,7 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 					firstPos = src.NoXPos
 				}
 				// let the backend handle it
-				thearch.SSAGenValue(&s, v)
+				Arch.SSAGenValue(&s, v)
 			}
 
 			if base.Ctxt.Flag_locationlists {
@@ -6588,7 +6584,7 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 		}
 		// If this is an empty infinite loop, stick a hardware NOP in there so that debuggers are less confused.
 		if s.bstart[b.ID] == s.pp.Next && len(b.Succs) == 1 && b.Succs[0].Block() == b {
-			p := thearch.Ginsnop(s.pp)
+			p := Arch.Ginsnop(s.pp)
 			p.Pos = p.Pos.WithIsStmt()
 			if b.Pos == src.NoXPos {
 				b.Pos = p.Pos // It needs a file, otherwise a no-file non-zero line causes confusion.  See #35652.
@@ -6609,7 +6605,7 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 		}
 		x := s.pp.Next
 		s.SetPos(b.Pos)
-		thearch.SSAGenBlock(&s, b, next)
+		Arch.SSAGenBlock(&s, b, next)
 		if f.PrintOrHtmlSSA {
 			for ; x != s.pp.Next; x = x.Link {
 				progToBlock[x] = b
@@ -6621,7 +6617,7 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 		// still be inside the function in question. So if
 		// it ends in a call which doesn't return, add a
 		// nop (which will never execute) after the call.
-		thearch.Ginsnop(pp)
+		Arch.Ginsnop(pp)
 	}
 	if openDeferInfo != nil {
 		// When doing open-coded defers, generate a disconnected call to
@@ -6636,7 +6632,7 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 		// going to emit anyway, and use those instructions instead of the
 		// inline marks.
 		for p := pp.Text; p != nil; p = p.Link {
-			if p.As == obj.ANOP || p.As == obj.AFUNCDATA || p.As == obj.APCDATA || p.As == obj.ATEXT || p.As == obj.APCALIGN || thearch.LinkArch.Family == sys.Wasm {
+			if p.As == obj.ANOP || p.As == obj.AFUNCDATA || p.As == obj.APCDATA || p.As == obj.ATEXT || p.As == obj.APCALIGN || Arch.LinkArch.Family == sys.Wasm {
 				// Don't use 0-sized instructions as inline marks, because we need
 				// to identify inline mark instructions by pc offset.
 				// (Some of these instructions are sometimes zero-sized, sometimes not.
@@ -6677,7 +6673,7 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 	}
 
 	if base.Ctxt.Flag_locationlists {
-		debugInfo := ssa.BuildFuncDebug(base.Ctxt, f, base.Debug.LocationLists > 1, stackOffset)
+		debugInfo := ssa.BuildFuncDebug(base.Ctxt, f, base.Debug.LocationLists > 1, StackOffset)
 		e.curfn.DebugInfo = debugInfo
 		bstart := s.bstart
 		// Note that at this moment, Prog.Pc is a sequence number; it's
@@ -6766,12 +6762,12 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 	f.HTMLWriter = nil
 }
 
-func defframe(s *SSAGenState, e *ssafn) {
+func defframe(s *State, e *ssafn) {
 	pp := s.pp
 
 	frame := types.Rnd(s.maxarg+e.stksize, int64(types.RegSize))
-	if thearch.PadFrame != nil {
-		frame = thearch.PadFrame(frame)
+	if Arch.PadFrame != nil {
+		frame = Arch.PadFrame(frame)
 	}
 
 	// Fill in argument and frame size.
@@ -6808,7 +6804,7 @@ func defframe(s *SSAGenState, e *ssafn) {
 		}
 
 		// Zero old range
-		p = thearch.ZeroRange(pp, p, frame+lo, hi-lo, &state)
+		p = Arch.ZeroRange(pp, p, frame+lo, hi-lo, &state)
 
 		// Set new range.
 		lo = n.FrameOffset()
@@ -6816,7 +6812,7 @@ func defframe(s *SSAGenState, e *ssafn) {
 	}
 
 	// Zero final range.
-	thearch.ZeroRange(pp, p, frame+lo, hi-lo, &state)
+	Arch.ZeroRange(pp, p, frame+lo, hi-lo, &state)
 }
 
 // For generating consecutive jump instructions to model a specific branching
@@ -6825,14 +6821,14 @@ type IndexJump struct {
 	Index int
 }
 
-func (s *SSAGenState) oneJump(b *ssa.Block, jump *IndexJump) {
+func (s *State) oneJump(b *ssa.Block, jump *IndexJump) {
 	p := s.Br(jump.Jump, b.Succs[jump.Index].Block())
 	p.Pos = b.Pos
 }
 
 // CombJump generates combinational instructions (2 at present) for a block jump,
 // thereby the behaviour of non-standard condition codes could be simulated
-func (s *SSAGenState) CombJump(b, next *ssa.Block, jumps *[2][2]IndexJump) {
+func (s *State) CombJump(b, next *ssa.Block, jumps *[2][2]IndexJump) {
 	switch next {
 	case b.Succs[0].Block():
 		s.oneJump(b, &jumps[0][0])
@@ -7019,7 +7015,7 @@ func AddrAuto(a *obj.Addr, v *ssa.Value) {
 	n, off := ssa.AutoVar(v)
 	a.Type = obj.TYPE_MEM
 	a.Sym = n.Sym().Linksym()
-	a.Reg = int16(thearch.REGSP)
+	a.Reg = int16(Arch.REGSP)
 	a.Offset = n.FrameOffset() + off
 	if n.Class_ == ir.PPARAM || n.Class_ == ir.PPARAMOUT {
 		a.Name = obj.NAME_PARAM
@@ -7028,20 +7024,20 @@ func AddrAuto(a *obj.Addr, v *ssa.Value) {
 	}
 }
 
-func (s *SSAGenState) AddrScratch(a *obj.Addr) {
+func (s *State) AddrScratch(a *obj.Addr) {
 	if s.ScratchFpMem == nil {
 		panic("no scratch memory available; forgot to declare usesScratch for Op?")
 	}
 	a.Type = obj.TYPE_MEM
 	a.Name = obj.NAME_AUTO
 	a.Sym = s.ScratchFpMem.Sym().Linksym()
-	a.Reg = int16(thearch.REGSP)
+	a.Reg = int16(Arch.REGSP)
 	a.Offset = s.ScratchFpMem.Offset_
 }
 
 // Call returns a new CALL instruction for the SSA value v.
 // It uses PrepareCall to prepare the call.
-func (s *SSAGenState) Call(v *ssa.Value) *obj.Prog {
+func (s *State) Call(v *ssa.Value) *obj.Prog {
 	pPosIsStmt := s.pp.Pos.IsStmt() // The statement-ness fo the call comes from ssaGenState
 	s.PrepareCall(v)
 
@@ -7057,7 +7053,7 @@ func (s *SSAGenState) Call(v *ssa.Value) *obj.Prog {
 		p.To.Sym = sym.Fn
 	} else {
 		// TODO(mdempsky): Can these differences be eliminated?
-		switch thearch.LinkArch.Family {
+		switch Arch.LinkArch.Family {
 		case sys.AMD64, sys.I386, sys.PPC64, sys.RISCV64, sys.S390X, sys.Wasm:
 			p.To.Type = obj.TYPE_REG
 		case sys.ARM, sys.ARM64, sys.MIPS, sys.MIPS64:
@@ -7073,7 +7069,7 @@ func (s *SSAGenState) Call(v *ssa.Value) *obj.Prog {
 // PrepareCall prepares to emit a CALL instruction for v and does call-related bookkeeping.
 // It must be called immediately before emitting the actual CALL instruction,
 // since it emits PCDATA for the stack map at the call (calls are safe points).
-func (s *SSAGenState) PrepareCall(v *ssa.Value) {
+func (s *State) PrepareCall(v *ssa.Value) {
 	idx := s.livenessMap.Get(v)
 	if !idx.StackMapValid() {
 		// See Liveness.hasStackMap.
@@ -7093,7 +7089,7 @@ func (s *SSAGenState) PrepareCall(v *ssa.Value) {
 		// insert an actual hardware NOP that will have the right line number.
 		// This is different from obj.ANOP, which is a virtual no-op
 		// that doesn't make it into the instruction stream.
-		thearch.Ginsnopdefer(s.pp)
+		Arch.Ginsnopdefer(s.pp)
 	}
 
 	if ok {
@@ -7111,7 +7107,7 @@ func (s *SSAGenState) PrepareCall(v *ssa.Value) {
 
 // UseArgs records the fact that an instruction needs a certain amount of
 // callee args space for its use.
-func (s *SSAGenState) UseArgs(n int64) {
+func (s *State) UseArgs(n int64) {
 	if s.maxarg < n {
 		s.maxarg = n
 	}
@@ -7223,7 +7219,7 @@ func (e *ssafn) SplitInt64(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot) {
 	} else {
 		t = types.Types[types.TUINT32]
 	}
-	if thearch.LinkArch.ByteOrder == binary.BigEndian {
+	if Arch.LinkArch.ByteOrder == binary.BigEndian {
 		return e.SplitSlot(&name, ".hi", 0, t), e.SplitSlot(&name, ".lo", t.Size(), types.Types[types.TUINT32])
 	}
 	return e.SplitSlot(&name, ".hi", t.Size(), t), e.SplitSlot(&name, ".lo", 0, types.Types[types.TUINT32])
@@ -7274,7 +7270,7 @@ func (e *ssafn) SplitSlot(parent *ssa.LocalSlot, suffix string, offset int64, t
 }
 
 func (e *ssafn) CanSSA(t *types.Type) bool {
-	return canSSAType(t)
+	return TypeOK(t)
 }
 
 func (e *ssafn) Line(pos src.XPos) string {
@@ -7453,3 +7449,11 @@ func deferstruct(stksize int64) *types.Type {
 	types.CalcStructSize(s)
 	return s
 }
+
+var (
+	BoundsCheckFunc [ssa.BoundsKindCount]*obj.LSym
+	ExtendCheckFunc [ssa.BoundsKindCount]*obj.LSym
+)
+
+// GCWriteBarrierReg maps from registers to gcWriteBarrier implementation LSyms.
+var GCWriteBarrierReg map[int16]*obj.LSym
diff --git a/src/cmd/compile/internal/wasm/ssa.go b/src/cmd/compile/internal/wasm/ssa.go
index ee86fc62d2..e4ef9d7c6a 100644
--- a/src/cmd/compile/internal/wasm/ssa.go
+++ b/src/cmd/compile/internal/wasm/ssa.go
@@ -6,18 +6,18 @@ package wasm
 
 import (
 	"cmd/compile/internal/base"
-	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/objw"
 	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/wasm"
 	"cmd/internal/objabi"
 )
 
-func Init(arch *gc.Arch) {
+func Init(arch *ssagen.ArchInfo) {
 	arch.LinkArch = &wasm.Linkwasm
 	arch.REGSP = wasm.REG_SP
 	arch.MAXWIDTH = 1 << 50
@@ -52,10 +52,10 @@ func ginsnop(pp *objw.Progs) *obj.Prog {
 	return pp.Prog(wasm.ANop)
 }
 
-func ssaMarkMoves(s *gc.SSAGenState, b *ssa.Block) {
+func ssaMarkMoves(s *ssagen.State, b *ssa.Block) {
 }
 
-func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
+func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
 	switch b.Kind {
 	case ssa.BlockPlain:
 		if next != b.Succs[0].Block() {
@@ -121,7 +121,7 @@ func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
 	}
 }
 
-func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
+func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 	switch v.Op {
 	case ssa.OpWasmLoweredStaticCall, ssa.OpWasmLoweredClosureCall, ssa.OpWasmLoweredInterCall:
 		s.PrepareCall(v)
@@ -188,7 +188,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		getReg(s, wasm.REG_SP)
 		getValue64(s, v.Args[0])
 		p := s.Prog(storeOp(v.Type))
-		gc.AddrAuto(&p.To, v)
+		ssagen.AddrAuto(&p.To, v)
 
 	default:
 		if v.Type.IsMemory() {
@@ -208,7 +208,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 	}
 }
 
-func ssaGenValueOnStack(s *gc.SSAGenState, v *ssa.Value, extend bool) {
+func ssaGenValueOnStack(s *ssagen.State, v *ssa.Value, extend bool) {
 	switch v.Op {
 	case ssa.OpWasmLoweredGetClosurePtr:
 		getReg(s, wasm.REG_CTXT)
@@ -243,10 +243,10 @@ func ssaGenValueOnStack(s *gc.SSAGenState, v *ssa.Value, extend bool) {
 		p.From.Type = obj.TYPE_ADDR
 		switch v.Aux.(type) {
 		case *obj.LSym:
-			gc.AddAux(&p.From, v)
+			ssagen.AddAux(&p.From, v)
 		case *ir.Name:
 			p.From.Reg = v.Args[0].Reg()
-			gc.AddAux(&p.From, v)
+			ssagen.AddAux(&p.From, v)
 		default:
 			panic("wasm: bad LoweredAddr")
 		}
@@ -363,7 +363,7 @@ func ssaGenValueOnStack(s *gc.SSAGenState, v *ssa.Value, extend bool) {
 
 	case ssa.OpLoadReg:
 		p := s.Prog(loadOp(v.Type))
-		gc.AddrAuto(&p.From, v.Args[0])
+		ssagen.AddrAuto(&p.From, v.Args[0])
 
 	case ssa.OpCopy:
 		getValue64(s, v.Args[0])
@@ -385,7 +385,7 @@ func isCmp(v *ssa.Value) bool {
 	}
 }
 
-func getValue32(s *gc.SSAGenState, v *ssa.Value) {
+func getValue32(s *ssagen.State, v *ssa.Value) {
 	if v.OnWasmStack {
 		s.OnWasmStackSkipped--
 		ssaGenValueOnStack(s, v, false)
@@ -402,7 +402,7 @@ func getValue32(s *gc.SSAGenState, v *ssa.Value) {
 	}
 }
 
-func getValue64(s *gc.SSAGenState, v *ssa.Value) {
+func getValue64(s *ssagen.State, v *ssa.Value) {
 	if v.OnWasmStack {
 		s.OnWasmStackSkipped--
 		ssaGenValueOnStack(s, v, true)
@@ -416,32 +416,32 @@ func getValue64(s *gc.SSAGenState, v *ssa.Value) {
 	}
 }
 
-func i32Const(s *gc.SSAGenState, val int32) {
+func i32Const(s *ssagen.State, val int32) {
 	p := s.Prog(wasm.AI32Const)
 	p.From = obj.Addr{Type: obj.TYPE_CONST, Offset: int64(val)}
 }
 
-func i64Const(s *gc.SSAGenState, val int64) {
+func i64Const(s *ssagen.State, val int64) {
 	p := s.Prog(wasm.AI64Const)
 	p.From = obj.Addr{Type: obj.TYPE_CONST, Offset: val}
 }
 
-func f32Const(s *gc.SSAGenState, val float64) {
+func f32Const(s *ssagen.State, val float64) {
 	p := s.Prog(wasm.AF32Const)
 	p.From = obj.Addr{Type: obj.TYPE_FCONST, Val: val}
 }
 
-func f64Const(s *gc.SSAGenState, val float64) {
+func f64Const(s *ssagen.State, val float64) {
 	p := s.Prog(wasm.AF64Const)
 	p.From = obj.Addr{Type: obj.TYPE_FCONST, Val: val}
 }
 
-func getReg(s *gc.SSAGenState, reg int16) {
+func getReg(s *ssagen.State, reg int16) {
 	p := s.Prog(wasm.AGet)
 	p.From = obj.Addr{Type: obj.TYPE_REG, Reg: reg}
 }
 
-func setReg(s *gc.SSAGenState, reg int16) {
+func setReg(s *ssagen.State, reg int16) {
 	p := s.Prog(wasm.ASet)
 	p.To = obj.Addr{Type: obj.TYPE_REG, Reg: reg}
 }
diff --git a/src/cmd/compile/internal/x86/galign.go b/src/cmd/compile/internal/x86/galign.go
index 7d628f9b7c..fc806f9119 100644
--- a/src/cmd/compile/internal/x86/galign.go
+++ b/src/cmd/compile/internal/x86/galign.go
@@ -6,14 +6,14 @@ package x86
 
 import (
 	"cmd/compile/internal/base"
-	"cmd/compile/internal/gc"
+	"cmd/compile/internal/ssagen"
 	"cmd/internal/obj/x86"
 	"cmd/internal/objabi"
 	"fmt"
 	"os"
 )
 
-func Init(arch *gc.Arch) {
+func Init(arch *ssagen.ArchInfo) {
 	arch.LinkArch = &x86.Link386
 	arch.REGSP = x86.REGSP
 	arch.SSAGenValue = ssaGenValue
diff --git a/src/cmd/compile/internal/x86/ssa.go b/src/cmd/compile/internal/x86/ssa.go
index d3d60591cc..00dfa07bf7 100644
--- a/src/cmd/compile/internal/x86/ssa.go
+++ b/src/cmd/compile/internal/x86/ssa.go
@@ -9,17 +9,17 @@ import (
 	"math"
 
 	"cmd/compile/internal/base"
-	"cmd/compile/internal/gc"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/x86"
 )
 
 // markMoves marks any MOVXconst ops that need to avoid clobbering flags.
-func ssaMarkMoves(s *gc.SSAGenState, b *ssa.Block) {
+func ssaMarkMoves(s *ssagen.State, b *ssa.Block) {
 	flive := b.FlagsLiveAtEnd
 	for _, c := range b.ControlValues() {
 		flive = c.Type.IsFlags() || flive
@@ -109,7 +109,7 @@ func moveByType(t *types.Type) obj.As {
 //     dest := dest(To) op src(From)
 // and also returns the created obj.Prog so it
 // may be further adjusted (offset, scale, etc).
-func opregreg(s *gc.SSAGenState, op obj.As, dest, src int16) *obj.Prog {
+func opregreg(s *ssagen.State, op obj.As, dest, src int16) *obj.Prog {
 	p := s.Prog(op)
 	p.From.Type = obj.TYPE_REG
 	p.To.Type = obj.TYPE_REG
@@ -118,7 +118,7 @@ func opregreg(s *gc.SSAGenState, op obj.As, dest, src int16) *obj.Prog {
 	return p
 }
 
-func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
+func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 	switch v.Op {
 	case ssa.Op386ADDL:
 		r := v.Reg()
@@ -406,14 +406,14 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = r
 		p.From.Index = i
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.Op386LEAL:
 		p := s.Prog(x86.ALEAL)
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.Op386CMPL, ssa.Op386CMPW, ssa.Op386CMPB,
@@ -439,7 +439,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Args[1].Reg()
 	case ssa.Op386CMPLconstload, ssa.Op386CMPWconstload, ssa.Op386CMPBconstload:
@@ -447,7 +447,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux2(&p.From, v, sc.Off())
+		ssagen.AddAux2(&p.From, v, sc.Off())
 		p.To.Type = obj.TYPE_CONST
 		p.To.Offset = sc.Val()
 	case ssa.Op386MOVLconst:
@@ -499,7 +499,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.Op386MOVBloadidx1, ssa.Op386MOVWloadidx1, ssa.Op386MOVLloadidx1, ssa.Op386MOVSSloadidx1, ssa.Op386MOVSDloadidx1,
@@ -523,7 +523,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		}
 		p.From.Reg = r
 		p.From.Index = i
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.Op386ADDLloadidx4, ssa.Op386SUBLloadidx4, ssa.Op386MULLloadidx4,
@@ -533,7 +533,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Reg = v.Args[1].Reg()
 		p.From.Index = v.Args[2].Reg()
 		p.From.Scale = 4
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 		if v.Reg() != v.Args[0].Reg() {
@@ -546,7 +546,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[1].Reg()
-		gc.AddAux(&p.From, v)
+		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 		if v.Reg() != v.Args[0].Reg() {
@@ -559,7 +559,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Reg = v.Args[1].Reg()
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 	case ssa.Op386ADDLconstmodify:
 		sc := v.AuxValAndOff()
 		val := sc.Val()
@@ -573,7 +573,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 			off := sc.Off()
 			p.To.Type = obj.TYPE_MEM
 			p.To.Reg = v.Args[0].Reg()
-			gc.AddAux2(&p.To, v, off)
+			ssagen.AddAux2(&p.To, v, off)
 			break
 		}
 		fallthrough
@@ -586,7 +586,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Offset = val
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux2(&p.To, v, off)
+		ssagen.AddAux2(&p.To, v, off)
 	case ssa.Op386MOVBstoreidx1, ssa.Op386MOVWstoreidx1, ssa.Op386MOVLstoreidx1, ssa.Op386MOVSSstoreidx1, ssa.Op386MOVSDstoreidx1,
 		ssa.Op386MOVSDstoreidx8, ssa.Op386MOVSSstoreidx4, ssa.Op386MOVLstoreidx4, ssa.Op386MOVWstoreidx2,
 		ssa.Op386ADDLmodifyidx4, ssa.Op386SUBLmodifyidx4, ssa.Op386ANDLmodifyidx4, ssa.Op386ORLmodifyidx4, ssa.Op386XORLmodifyidx4:
@@ -612,7 +612,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		}
 		p.To.Reg = r
 		p.To.Index = i
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 	case ssa.Op386MOVLstoreconst, ssa.Op386MOVWstoreconst, ssa.Op386MOVBstoreconst:
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_CONST
@@ -620,7 +620,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Offset = sc.Val()
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux2(&p.To, v, sc.Off())
+		ssagen.AddAux2(&p.To, v, sc.Off())
 	case ssa.Op386ADDLconstmodifyidx4:
 		sc := v.AuxValAndOff()
 		val := sc.Val()
@@ -636,7 +636,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 			p.To.Reg = v.Args[0].Reg()
 			p.To.Scale = 4
 			p.To.Index = v.Args[1].Reg()
-			gc.AddAux2(&p.To, v, off)
+			ssagen.AddAux2(&p.To, v, off)
 			break
 		}
 		fallthrough
@@ -663,7 +663,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = r
 		p.To.Index = i
-		gc.AddAux2(&p.To, v, sc.Off())
+		ssagen.AddAux2(&p.To, v, sc.Off())
 	case ssa.Op386MOVWLSX, ssa.Op386MOVBLSX, ssa.Op386MOVWLZX, ssa.Op386MOVBLZX,
 		ssa.Op386CVTSL2SS, ssa.Op386CVTSL2SD,
 		ssa.Op386CVTTSS2SL, ssa.Op386CVTTSD2SL,
@@ -695,7 +695,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 			return
 		}
 		p := s.Prog(loadByType(v.Type))
-		gc.AddrAuto(&p.From, v.Args[0])
+		ssagen.AddrAuto(&p.From, v.Args[0])
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 
@@ -707,10 +707,10 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(storeByType(v.Type))
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = v.Args[0].Reg()
-		gc.AddrAuto(&p.To, v)
+		ssagen.AddrAuto(&p.To, v)
 	case ssa.Op386LoweredGetClosurePtr:
 		// Closure pointer is DX.
-		gc.CheckLoweredGetClosurePtr(v)
+		ssagen.CheckLoweredGetClosurePtr(v)
 	case ssa.Op386LoweredGetG:
 		r := v.Reg()
 		// See the comments in cmd/internal/obj/x86/obj6.go
@@ -766,14 +766,14 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p := s.Prog(obj.ACALL)
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.BoundsCheckFunc[v.AuxInt]
+		p.To.Sym = ssagen.BoundsCheckFunc[v.AuxInt]
 		s.UseArgs(8) // space used in callee args area by assembly stubs
 
 	case ssa.Op386LoweredPanicExtendA, ssa.Op386LoweredPanicExtendB, ssa.Op386LoweredPanicExtendC:
 		p := s.Prog(obj.ACALL)
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = gc.ExtendCheckFunc[v.AuxInt]
+		p.To.Sym = ssagen.ExtendCheckFunc[v.AuxInt]
 		s.UseArgs(12) // space used in callee args area by assembly stubs
 
 	case ssa.Op386CALLstatic, ssa.Op386CALLclosure, ssa.Op386CALLinter:
@@ -848,7 +848,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Reg = x86.REG_AX
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 		if logopt.Enabled() {
 			logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
 		}
@@ -861,7 +861,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
 		p.From.Offset = 0xdeaddead
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = x86.REG_SP
-		gc.AddAux(&p.To, v)
+		ssagen.AddAux(&p.To, v)
 	default:
 		v.Fatalf("genValue not implemented: %s", v.LongString())
 	}
@@ -886,22 +886,22 @@ var blockJump = [...]struct {
 	ssa.Block386NAN: {x86.AJPS, x86.AJPC},
 }
 
-var eqfJumps = [2][2]gc.IndexJump{
+var eqfJumps = [2][2]ssagen.IndexJump{
 	{{Jump: x86.AJNE, Index: 1}, {Jump: x86.AJPS, Index: 1}}, // next == b.Succs[0]
 	{{Jump: x86.AJNE, Index: 1}, {Jump: x86.AJPC, Index: 0}}, // next == b.Succs[1]
 }
-var nefJumps = [2][2]gc.IndexJump{
+var nefJumps = [2][2]ssagen.IndexJump{
 	{{Jump: x86.AJNE, Index: 0}, {Jump: x86.AJPC, Index: 1}}, // next == b.Succs[0]
 	{{Jump: x86.AJNE, Index: 0}, {Jump: x86.AJPS, Index: 0}}, // next == b.Succs[1]
 }
 
-func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
+func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
 	switch b.Kind {
 	case ssa.BlockPlain:
 		if b.Succs[0].Block() != next {
 			p := s.Prog(obj.AJMP)
 			p.To.Type = obj.TYPE_BRANCH
-			s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+			s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
 		}
 	case ssa.BlockDefer:
 		// defer returns in rax:
@@ -914,11 +914,11 @@ func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
 		p.To.Reg = x86.REG_AX
 		p = s.Prog(x86.AJNE)
 		p.To.Type = obj.TYPE_BRANCH
-		s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[1].Block()})
+		s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[1].Block()})
 		if b.Succs[0].Block() != next {
 			p := s.Prog(obj.AJMP)
 			p.To.Type = obj.TYPE_BRANCH
-			s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+			s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
 		}
 	case ssa.BlockExit:
 	case ssa.BlockRet:
diff --git a/src/cmd/compile/main.go b/src/cmd/compile/main.go
index 5a33719d87..cb2f4e8cf4 100644
--- a/src/cmd/compile/main.go
+++ b/src/cmd/compile/main.go
@@ -15,6 +15,7 @@ import (
 	"cmd/compile/internal/ppc64"
 	"cmd/compile/internal/riscv64"
 	"cmd/compile/internal/s390x"
+	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/wasm"
 	"cmd/compile/internal/x86"
 	"cmd/internal/objabi"
@@ -23,7 +24,7 @@ import (
 	"os"
 )
 
-var archInits = map[string]func(*gc.Arch){
+var archInits = map[string]func(*ssagen.ArchInfo){
 	"386":      x86.Init,
 	"amd64":    amd64.Init,
 	"arm":      arm.Init,
-- 
GitLab


From 01fd2d05c8b7bfc083977ca73123a5541b289737 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 23 Dec 2020 00:58:27 -0500
Subject: [PATCH 0315/2400] [dev.regabi] cmd/compile: split out package
 dwarfgen [generated]

[git-generate]
cd src/cmd/compile/internal/gc

rf '
	# Inline and remove ngotype.
	ex {
		import "cmd/compile/internal/ir"
		import "cmd/compile/internal/reflectdata"
		var n ir.Node
		ngotype(n) -> reflectdata.TypeSym(n.Type())
	}
	rm ngotype

	mv recordFlags RecordFlags
	mv recordPackageName RecordPackageName
	mv RecordFlags RecordPackageName dwarf.go

	mv debuginfo Info
	mv genAbstractFunc AbstractFunc
	mv scope.go scope_test.go dwarf.go dwinl.go cmd/compile/internal/dwarfgen
'

Change-Id: I31fa982900dbba2066ca4c7a706af922e5481c70
Reviewed-on: https://go-review.googlesource.com/c/go/+/279477
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 .../internal/{gc => dwarfgen}/dwarf.go        | 83 +++++++++++++++++--
 .../internal/{gc => dwarfgen}/dwinl.go        |  9 +-
 .../internal/{gc => dwarfgen}/scope.go        |  5 +-
 .../internal/{gc => dwarfgen}/scope_test.go   |  5 +-
 src/cmd/compile/internal/gc/main.go           | 76 ++---------------
 src/cmd/compile/internal/gc/obj.go            |  2 +-
 src/cmd/compile/internal/gc/subr.go           |  8 --
 7 files changed, 94 insertions(+), 94 deletions(-)
 rename src/cmd/compile/internal/{gc => dwarfgen}/dwarf.go (85%)
 rename src/cmd/compile/internal/{gc => dwarfgen}/dwinl.go (99%)
 rename src/cmd/compile/internal/{gc => dwarfgen}/scope.go (99%)
 rename src/cmd/compile/internal/{gc => dwarfgen}/scope_test.go (99%)

diff --git a/src/cmd/compile/internal/gc/dwarf.go b/src/cmd/compile/internal/dwarfgen/dwarf.go
similarity index 85%
rename from src/cmd/compile/internal/gc/dwarf.go
rename to src/cmd/compile/internal/dwarfgen/dwarf.go
index e853c51422..19cb70058c 100644
--- a/src/cmd/compile/internal/gc/dwarf.go
+++ b/src/cmd/compile/internal/dwarfgen/dwarf.go
@@ -2,13 +2,17 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package dwarfgen
 
 import (
+	"bytes"
+	"flag"
+	"fmt"
 	"sort"
 
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/reflectdata"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/types"
@@ -18,7 +22,7 @@ import (
 	"cmd/internal/src"
 )
 
-func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.Scope, dwarf.InlCalls) {
+func Info(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.Scope, dwarf.InlCalls) {
 	fn := curfn.(*ir.Func)
 
 	if fn.Nname != nil {
@@ -86,7 +90,7 @@ func debuginfo(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.S
 				continue
 			}
 			apdecls = append(apdecls, n)
-			fnsym.Func().RecordAutoType(ngotype(n).Linksym())
+			fnsym.Func().RecordAutoType(reflectdata.TypeSym(n.Type()).Linksym())
 		}
 	}
 
@@ -236,7 +240,7 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 			ChildIndex:    -1,
 		})
 		// Record go type of to insure that it gets emitted by the linker.
-		fnsym.Func().RecordAutoType(ngotype(n).Linksym())
+		fnsym.Func().RecordAutoType(reflectdata.TypeSym(n.Type()).Linksym())
 	}
 
 	return decls, vars
@@ -305,7 +309,7 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 	}
 
 	typename := dwarf.InfoPrefix + types.TypeSymName(n.Type())
-	delete(fnsym.Func().Autot, ngotype(n).Linksym())
+	delete(fnsym.Func().Autot, reflectdata.TypeSym(n.Type()).Linksym())
 	inlIndex := 0
 	if base.Flag.GenDwarfInl > 1 {
 		if n.Name().InlFormal() || n.Name().InlLocal() {
@@ -372,7 +376,7 @@ func createComplexVar(fnsym *obj.LSym, fn *ir.Func, varID ssa.VarID) *dwarf.Var
 		return nil
 	}
 
-	gotype := ngotype(n).Linksym()
+	gotype := reflectdata.TypeSym(n.Type()).Linksym()
 	delete(fnsym.Func().Autot, gotype)
 	typename := dwarf.InfoPrefix + gotype.Name[len("type."):]
 	inlIndex := 0
@@ -410,3 +414,70 @@ func createComplexVar(fnsym *obj.LSym, fn *ir.Func, varID ssa.VarID) *dwarf.Var
 	}
 	return dvar
 }
+
+// RecordFlags records the specified command-line flags to be placed
+// in the DWARF info.
+func RecordFlags(flags ...string) {
+	if base.Ctxt.Pkgpath == "" {
+		// We can't record the flags if we don't know what the
+		// package name is.
+		return
+	}
+
+	type BoolFlag interface {
+		IsBoolFlag() bool
+	}
+	type CountFlag interface {
+		IsCountFlag() bool
+	}
+	var cmd bytes.Buffer
+	for _, name := range flags {
+		f := flag.Lookup(name)
+		if f == nil {
+			continue
+		}
+		getter := f.Value.(flag.Getter)
+		if getter.String() == f.DefValue {
+			// Flag has default value, so omit it.
+			continue
+		}
+		if bf, ok := f.Value.(BoolFlag); ok && bf.IsBoolFlag() {
+			val, ok := getter.Get().(bool)
+			if ok && val {
+				fmt.Fprintf(&cmd, " -%s", f.Name)
+				continue
+			}
+		}
+		if cf, ok := f.Value.(CountFlag); ok && cf.IsCountFlag() {
+			val, ok := getter.Get().(int)
+			if ok && val == 1 {
+				fmt.Fprintf(&cmd, " -%s", f.Name)
+				continue
+			}
+		}
+		fmt.Fprintf(&cmd, " -%s=%v", f.Name, getter.Get())
+	}
+
+	if cmd.Len() == 0 {
+		return
+	}
+	s := base.Ctxt.Lookup(dwarf.CUInfoPrefix + "producer." + base.Ctxt.Pkgpath)
+	s.Type = objabi.SDWARFCUINFO
+	// Sometimes (for example when building tests) we can link
+	// together two package main archives. So allow dups.
+	s.Set(obj.AttrDuplicateOK, true)
+	base.Ctxt.Data = append(base.Ctxt.Data, s)
+	s.P = cmd.Bytes()[1:]
+}
+
+// RecordPackageName records the name of the package being
+// compiled, so that the linker can save it in the compile unit's DIE.
+func RecordPackageName() {
+	s := base.Ctxt.Lookup(dwarf.CUInfoPrefix + "packagename." + base.Ctxt.Pkgpath)
+	s.Type = objabi.SDWARFCUINFO
+	// Sometimes (for example when building tests) we can link
+	// together two package main archives. So allow dups.
+	s.Set(obj.AttrDuplicateOK, true)
+	base.Ctxt.Data = append(base.Ctxt.Data, s)
+	s.P = []byte(types.LocalPkg.Name)
+}
diff --git a/src/cmd/compile/internal/gc/dwinl.go b/src/cmd/compile/internal/dwarfgen/dwinl.go
similarity index 99%
rename from src/cmd/compile/internal/gc/dwinl.go
rename to src/cmd/compile/internal/dwarfgen/dwinl.go
index d9eb930037..d5687cb1d7 100644
--- a/src/cmd/compile/internal/gc/dwinl.go
+++ b/src/cmd/compile/internal/dwarfgen/dwinl.go
@@ -2,16 +2,17 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package dwarfgen
 
 import (
+	"fmt"
+	"strings"
+
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/internal/dwarf"
 	"cmd/internal/obj"
 	"cmd/internal/src"
-	"fmt"
-	"strings"
 )
 
 // To identify variables by original source position.
@@ -206,7 +207,7 @@ func assembleInlines(fnsym *obj.LSym, dwVars []*dwarf.Var) dwarf.InlCalls {
 // late in the compilation when it is determined that we need an
 // abstract function DIE for an inlined routine imported from a
 // previously compiled package.
-func genAbstractFunc(fn *obj.LSym) {
+func AbstractFunc(fn *obj.LSym) {
 	ifn := base.Ctxt.DwFixups.GetPrecursorFunc(fn)
 	if ifn == nil {
 		base.Ctxt.Diag("failed to locate precursor fn for %v", fn)
diff --git a/src/cmd/compile/internal/gc/scope.go b/src/cmd/compile/internal/dwarfgen/scope.go
similarity index 99%
rename from src/cmd/compile/internal/gc/scope.go
rename to src/cmd/compile/internal/dwarfgen/scope.go
index 9ab33583c8..1c040edc28 100644
--- a/src/cmd/compile/internal/gc/scope.go
+++ b/src/cmd/compile/internal/dwarfgen/scope.go
@@ -2,15 +2,16 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package dwarfgen
 
 import (
+	"sort"
+
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/internal/dwarf"
 	"cmd/internal/obj"
 	"cmd/internal/src"
-	"sort"
 )
 
 // See golang.org/issue/20390.
diff --git a/src/cmd/compile/internal/gc/scope_test.go b/src/cmd/compile/internal/dwarfgen/scope_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/scope_test.go
rename to src/cmd/compile/internal/dwarfgen/scope_test.go
index b0e038d27f..fcfcf85f84 100644
--- a/src/cmd/compile/internal/gc/scope_test.go
+++ b/src/cmd/compile/internal/dwarfgen/scope_test.go
@@ -2,10 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc_test
+package dwarfgen
 
 import (
-	"cmd/internal/objfile"
 	"debug/dwarf"
 	"fmt"
 	"internal/testenv"
@@ -18,6 +17,8 @@ import (
 	"strconv"
 	"strings"
 	"testing"
+
+	"cmd/internal/objfile"
 )
 
 type testline struct {
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 154235f744..2a8012b462 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -10,6 +10,7 @@ import (
 	"bufio"
 	"bytes"
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/dwarfgen"
 	"cmd/compile/internal/escape"
 	"cmd/compile/internal/inline"
 	"cmd/compile/internal/ir"
@@ -114,7 +115,7 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	// Record flags that affect the build result. (And don't
 	// record flags that don't, since that would cause spurious
 	// changes in the binary.)
-	recordFlags("B", "N", "l", "msan", "race", "shared", "dynlink", "dwarflocationlists", "dwarfbasentries", "smallframes", "spectre")
+	dwarfgen.RecordFlags("B", "N", "l", "msan", "race", "shared", "dynlink", "dwarflocationlists", "dwarfbasentries", "smallframes", "spectre")
 
 	if !base.EnableTrace && base.Flag.LowerT {
 		log.Fatalf("compiler not built with support for -t")
@@ -134,8 +135,8 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	}
 
 	if base.Flag.Dwarf {
-		base.Ctxt.DebugInfo = debuginfo
-		base.Ctxt.GenAbstractFunc = genAbstractFunc
+		base.Ctxt.DebugInfo = dwarfgen.Info
+		base.Ctxt.GenAbstractFunc = dwarfgen.AbstractFunc
 		base.Ctxt.DwFixups = obj.NewDwarfFixupTable(base.Ctxt)
 	} else {
 		// turn off inline generation if no dwarf at all
@@ -211,7 +212,7 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	ssagen.CgoSymABIs()
 	base.Timer.Stop()
 	base.Timer.AddEvent(int64(lines), "lines")
-	recordPackageName()
+	dwarfgen.RecordPackageName()
 
 	// Typecheck.
 	typecheck.Package()
@@ -364,73 +365,6 @@ func writebench(filename string) error {
 	return f.Close()
 }
 
-// recordFlags records the specified command-line flags to be placed
-// in the DWARF info.
-func recordFlags(flags ...string) {
-	if base.Ctxt.Pkgpath == "" {
-		// We can't record the flags if we don't know what the
-		// package name is.
-		return
-	}
-
-	type BoolFlag interface {
-		IsBoolFlag() bool
-	}
-	type CountFlag interface {
-		IsCountFlag() bool
-	}
-	var cmd bytes.Buffer
-	for _, name := range flags {
-		f := flag.Lookup(name)
-		if f == nil {
-			continue
-		}
-		getter := f.Value.(flag.Getter)
-		if getter.String() == f.DefValue {
-			// Flag has default value, so omit it.
-			continue
-		}
-		if bf, ok := f.Value.(BoolFlag); ok && bf.IsBoolFlag() {
-			val, ok := getter.Get().(bool)
-			if ok && val {
-				fmt.Fprintf(&cmd, " -%s", f.Name)
-				continue
-			}
-		}
-		if cf, ok := f.Value.(CountFlag); ok && cf.IsCountFlag() {
-			val, ok := getter.Get().(int)
-			if ok && val == 1 {
-				fmt.Fprintf(&cmd, " -%s", f.Name)
-				continue
-			}
-		}
-		fmt.Fprintf(&cmd, " -%s=%v", f.Name, getter.Get())
-	}
-
-	if cmd.Len() == 0 {
-		return
-	}
-	s := base.Ctxt.Lookup(dwarf.CUInfoPrefix + "producer." + base.Ctxt.Pkgpath)
-	s.Type = objabi.SDWARFCUINFO
-	// Sometimes (for example when building tests) we can link
-	// together two package main archives. So allow dups.
-	s.Set(obj.AttrDuplicateOK, true)
-	base.Ctxt.Data = append(base.Ctxt.Data, s)
-	s.P = cmd.Bytes()[1:]
-}
-
-// recordPackageName records the name of the package being
-// compiled, so that the linker can save it in the compile unit's DIE.
-func recordPackageName() {
-	s := base.Ctxt.Lookup(dwarf.CUInfoPrefix + "packagename." + base.Ctxt.Pkgpath)
-	s.Type = objabi.SDWARFCUINFO
-	// Sometimes (for example when building tests) we can link
-	// together two package main archives. So allow dups.
-	s.Set(obj.AttrDuplicateOK, true)
-	base.Ctxt.Data = append(base.Ctxt.Data, s)
-	s.P = []byte(types.LocalPkg.Name)
-}
-
 func makePos(b *src.PosBase, line, col uint) src.XPos {
 	return base.Ctxt.PosTable.XPos(src.MakePos(b, line, col))
 }
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 4db2ad9d4a..f159256da6 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -319,7 +319,7 @@ func litsym(n *ir.Name, noff int64, c ir.Node, wid int) {
 
 func ggloblnod(nam ir.Node) {
 	s := nam.Sym().Linksym()
-	s.Gotype = ngotype(nam).Linksym()
+	s.Gotype = reflectdata.TypeSym(nam.Type()).Linksym()
 	flags := 0
 	if nam.Name().Readonly() {
 		flags = obj.RODATA
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 02a4c0a688..17bbd1c3a2 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -7,7 +7,6 @@ package gc
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
-	"cmd/compile/internal/reflectdata"
 	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
@@ -305,13 +304,6 @@ func cheapexpr(n ir.Node, init *ir.Nodes) ir.Node {
 	return copyexpr(n, n.Type(), init)
 }
 
-func ngotype(n ir.Node) *types.Sym {
-	if n.Type() != nil {
-		return reflectdata.TypeSym(n.Type())
-	}
-	return nil
-}
-
 // itabType loads the _type field from a runtime.itab struct.
 func itabType(itab ir.Node) ir.Node {
 	typ := ir.NewSelectorExpr(base.Pos, ir.ODOTPTR, itab, nil)
-- 
GitLab


From e4895ab4c0eb44de6ddc5dc8d860a827b20d2781 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 23 Dec 2020 01:05:16 -0500
Subject: [PATCH 0316/2400] [dev.regabi] cmd/compile: split out package walk
 [generated]

[git-generate]
cd src/cmd/compile/internal/gc
rf '
	# Late addition to package ir.
	mv closuredebugruntimecheck ClosureDebugRuntimeCheck
	mv hasemptycvars IsTrivialClosure
	mv ClosureDebugRuntimeCheck IsTrivialClosure func.go
	mv func.go cmd/compile/internal/ir

	# Late addition to package reflectdata.
	mv markTypeUsedInInterface MarkTypeUsedInInterface
	mv markUsedIfaceMethod MarkUsedIfaceMethod
	mv MarkTypeUsedInInterface MarkUsedIfaceMethod reflect.go
	mv reflect.go cmd/compile/internal/reflectdata

	# Late addition to package staticdata.
	mv litsym InitConst
	mv InitConst data.go
	mv data.go cmd/compile/internal/staticdata

	# Extract staticinit out of walk into its own package.
	mv InitEntry InitPlan InitSchedule InitSchedule.append InitSchedule.staticInit \
		InitSchedule.tryStaticInit InitSchedule.staticcopy \
		InitSchedule.staticassign InitSchedule.initplan InitSchedule.addvalue \
		statuniqgen staticname stataddr anySideEffects getlit isvaluelit \
		sched.go
	mv InitSchedule.initplans InitSchedule.Plans
	mv InitSchedule.inittemps InitSchedule.Temps
	mv InitSchedule.out InitSchedule.Out
	mv InitSchedule.staticInit InitSchedule.StaticInit
	mv InitSchedule.staticassign InitSchedule.StaticAssign
	mv InitSchedule Schedule
	mv InitPlan Plan
	mv InitEntry Entry
	mv anySideEffects AnySideEffects
	mv staticname StaticName
	mv stataddr StaticLoc
	mv sched.go cmd/compile/internal/staticinit

	# Export API and unexport non-API.
	mv transformclosure Closure
	mv walk Walk

	mv Order orderState

	mv swt.go switch.go
	mv racewalk.go race.go

	mv closure.go order.go range.go select.go switch.go race.go \
		sinit.go subr.go walk.go \
		cmd/compile/internal/walk
'

: # Update format test.
cd ../../
go install cmd/compile/... cmd/internal/archive
go test -u || go test -u
rm -rf ../../../pkg/darwin_amd64/cmd

Change-Id: I11c7a45f74d4a9e963da15c080e1018caaa99c05
Reviewed-on: https://go-review.googlesource.com/c/go/+/279478
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/fmtmap_test.go                |   2 +-
 src/cmd/compile/internal/gc/compile.go        |   3 +-
 src/cmd/compile/internal/gc/initorder.go      |  11 +-
 src/cmd/compile/internal/gc/main.go           |   3 +-
 src/cmd/compile/internal/gc/obj.go            |  57 --
 src/cmd/compile/internal/ir/func.go           |  21 +
 .../compile/internal/reflectdata/reflect.go   |  26 +
 src/cmd/compile/internal/staticdata/data.go   |  57 ++
 src/cmd/compile/internal/staticinit/sched.go  | 596 ++++++++++++++++++
 .../compile/internal/{gc => walk}/closure.go  |  31 +-
 .../compile/internal/{gc => walk}/order.go    |  80 +--
 .../internal/{gc/racewalk.go => walk/race.go} |   2 +-
 .../compile/internal/{gc => walk}/range.go    |   5 +-
 .../compile/internal/{gc => walk}/select.go   |   2 +-
 .../compile/internal/{gc => walk}/sinit.go    | 509 +--------------
 src/cmd/compile/internal/{gc => walk}/subr.go |   5 +-
 .../internal/{gc/swt.go => walk/switch.go}    |   9 +-
 src/cmd/compile/internal/{gc => walk}/walk.go | 135 +---
 18 files changed, 790 insertions(+), 764 deletions(-)
 create mode 100644 src/cmd/compile/internal/staticinit/sched.go
 rename src/cmd/compile/internal/{gc => walk}/closure.go (85%)
 rename src/cmd/compile/internal/{gc => walk}/order.go (95%)
 rename src/cmd/compile/internal/{gc/racewalk.go => walk/race.go} (99%)
 rename src/cmd/compile/internal/{gc => walk}/range.go (99%)
 rename src/cmd/compile/internal/{gc => walk}/select.go (99%)
 rename src/cmd/compile/internal/{gc => walk}/sinit.go (59%)
 rename src/cmd/compile/internal/{gc => walk}/subr.go (99%)
 rename src/cmd/compile/internal/{gc/swt.go => walk/switch.go} (99%)
 rename src/cmd/compile/internal/{gc => walk}/walk.go (97%)

diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
index 9bc059c2e4..a925ec05ac 100644
--- a/src/cmd/compile/fmtmap_test.go
+++ b/src/cmd/compile/fmtmap_test.go
@@ -37,7 +37,6 @@ var knownFormats = map[string]string{
 	"[]cmd/compile/internal/syntax.token %s":       "",
 	"cmd/compile/internal/arm.shift %d":            "",
 	"cmd/compile/internal/gc.RegIndex %d":          "",
-	"cmd/compile/internal/gc.initKind %d":          "",
 	"cmd/compile/internal/ir.Class %d":             "",
 	"cmd/compile/internal/ir.Node %+v":             "",
 	"cmd/compile/internal/ir.Node %L":              "",
@@ -68,6 +67,7 @@ var knownFormats = map[string]string{
 	"cmd/compile/internal/syntax.token %s":         "",
 	"cmd/compile/internal/types.Kind %d":           "",
 	"cmd/compile/internal/types.Kind %s":           "",
+	"cmd/compile/internal/walk.initKind %d":        "",
 	"go/constant.Value %#v":                        "",
 	"math/big.Accuracy %s":                         "",
 	"reflect.Type %s":                              "",
diff --git a/src/cmd/compile/internal/gc/compile.go b/src/cmd/compile/internal/gc/compile.go
index c2a6a9e327..926b2dee95 100644
--- a/src/cmd/compile/internal/gc/compile.go
+++ b/src/cmd/compile/internal/gc/compile.go
@@ -17,6 +17,7 @@ import (
 	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
+	"cmd/compile/internal/walk"
 )
 
 // "Portable" code generation.
@@ -61,7 +62,7 @@ func compile(fn *ir.Func) {
 	ssagen.InitLSym(fn, true)
 
 	errorsBefore := base.Errors()
-	walk(fn)
+	walk.Walk(fn)
 	if base.Errors() > errorsBefore {
 		return
 	}
diff --git a/src/cmd/compile/internal/gc/initorder.go b/src/cmd/compile/internal/gc/initorder.go
index 5caa2e769f..4ac468fb4e 100644
--- a/src/cmd/compile/internal/gc/initorder.go
+++ b/src/cmd/compile/internal/gc/initorder.go
@@ -11,6 +11,7 @@ import (
 
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/staticinit"
 )
 
 // Package initialization
@@ -77,9 +78,9 @@ type InitOrder struct {
 // corresponding list of statements to include in the init() function
 // body.
 func initOrder(l []ir.Node) []ir.Node {
-	s := InitSchedule{
-		initplans: make(map[ir.Node]*InitPlan),
-		inittemps: make(map[ir.Node]*ir.Name),
+	s := staticinit.Schedule{
+		Plans: make(map[ir.Node]*staticinit.Plan),
+		Temps: make(map[ir.Node]*ir.Name),
 	}
 	o := InitOrder{
 		blocking: make(map[ir.Node][]ir.Node),
@@ -91,7 +92,7 @@ func initOrder(l []ir.Node) []ir.Node {
 		switch n.Op() {
 		case ir.OAS, ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV:
 			o.processAssign(n)
-			o.flushReady(s.staticInit)
+			o.flushReady(s.StaticInit)
 		case ir.ODCLCONST, ir.ODCLFUNC, ir.ODCLTYPE:
 			// nop
 		default:
@@ -124,7 +125,7 @@ func initOrder(l []ir.Node) []ir.Node {
 		base.Fatalf("expected empty map: %v", o.blocking)
 	}
 
-	return s.out
+	return s.Out
 }
 
 func (o *InitOrder) processAssign(n ir.Node) {
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 2a8012b462..aeb58a3310 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -22,6 +22,7 @@ import (
 	"cmd/compile/internal/staticdata"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
+	"cmd/compile/internal/walk"
 	"cmd/internal/dwarf"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
@@ -268,7 +269,7 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 			n := n.(*ir.Func)
 			if n.OClosure != nil {
 				ir.CurFunc = n
-				transformclosure(n)
+				walk.Closure(n)
 			}
 		}
 	}
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index f159256da6..0ab3a8dad4 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -18,7 +18,6 @@ import (
 	"cmd/internal/objabi"
 	"encoding/json"
 	"fmt"
-	"go/constant"
 )
 
 // These modes say which kind of object file to generate.
@@ -261,62 +260,6 @@ func addGCLocals() {
 	}
 }
 
-// litsym writes the static literal c to n.
-// Neither n nor c is modified.
-func litsym(n *ir.Name, noff int64, c ir.Node, wid int) {
-	if n.Op() != ir.ONAME {
-		base.Fatalf("litsym n op %v", n.Op())
-	}
-	if n.Sym() == nil {
-		base.Fatalf("litsym nil n sym")
-	}
-	if c.Op() == ir.ONIL {
-		return
-	}
-	if c.Op() != ir.OLITERAL {
-		base.Fatalf("litsym c op %v", c.Op())
-	}
-	s := n.Sym().Linksym()
-	switch u := c.Val(); u.Kind() {
-	case constant.Bool:
-		i := int64(obj.Bool2int(constant.BoolVal(u)))
-		s.WriteInt(base.Ctxt, noff, wid, i)
-
-	case constant.Int:
-		s.WriteInt(base.Ctxt, noff, wid, ir.IntVal(c.Type(), u))
-
-	case constant.Float:
-		f, _ := constant.Float64Val(u)
-		switch c.Type().Kind() {
-		case types.TFLOAT32:
-			s.WriteFloat32(base.Ctxt, noff, float32(f))
-		case types.TFLOAT64:
-			s.WriteFloat64(base.Ctxt, noff, f)
-		}
-
-	case constant.Complex:
-		re, _ := constant.Float64Val(constant.Real(u))
-		im, _ := constant.Float64Val(constant.Imag(u))
-		switch c.Type().Kind() {
-		case types.TCOMPLEX64:
-			s.WriteFloat32(base.Ctxt, noff, float32(re))
-			s.WriteFloat32(base.Ctxt, noff+4, float32(im))
-		case types.TCOMPLEX128:
-			s.WriteFloat64(base.Ctxt, noff, re)
-			s.WriteFloat64(base.Ctxt, noff+8, im)
-		}
-
-	case constant.String:
-		i := constant.StringVal(u)
-		symdata := staticdata.StringSym(n.Pos(), i)
-		s.WriteAddr(base.Ctxt, noff, types.PtrSize, symdata, 0)
-		s.WriteInt(base.Ctxt, noff+int64(types.PtrSize), types.PtrSize, int64(len(i)))
-
-	default:
-		base.Fatalf("litsym unhandled OLITERAL %v", c)
-	}
-}
-
 func ggloblnod(nam ir.Node) {
 	s := nam.Sym().Linksym()
 	s.Gotype = reflectdata.TypeSym(nam.Type()).Linksym()
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index a93516d716..6bc8cd574c 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -288,3 +288,24 @@ func MarkFunc(n *Name) {
 	n.Class_ = PFUNC
 	n.Sym().SetFunc(true)
 }
+
+// ClosureDebugRuntimeCheck applies boilerplate checks for debug flags
+// and compiling runtime
+func ClosureDebugRuntimeCheck(clo *ClosureExpr) {
+	if base.Debug.Closure > 0 {
+		if clo.Esc() == EscHeap {
+			base.WarnfAt(clo.Pos(), "heap closure, captured vars = %v", clo.Func.ClosureVars)
+		} else {
+			base.WarnfAt(clo.Pos(), "stack closure, captured vars = %v", clo.Func.ClosureVars)
+		}
+	}
+	if base.Flag.CompilingRuntime && clo.Esc() == EscHeap {
+		base.ErrorfAt(clo.Pos(), "heap-allocated closure, not allowed in runtime")
+	}
+}
+
+// IsTrivialClosure reports whether closure clo has an
+// empty list of captured vars.
+func IsTrivialClosure(clo *ClosureExpr) bool {
+	return len(clo.Func.ClosureVars) == 0
+}
diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index a5e2fb407a..ba3e0fa75e 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -1834,3 +1834,29 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 }
 
 var ZeroSize int64
+
+// MarkTypeUsedInInterface marks that type t is converted to an interface.
+// This information is used in the linker in dead method elimination.
+func MarkTypeUsedInInterface(t *types.Type, from *obj.LSym) {
+	tsym := TypeSym(t).Linksym()
+	// Emit a marker relocation. The linker will know the type is converted
+	// to an interface if "from" is reachable.
+	r := obj.Addrel(from)
+	r.Sym = tsym
+	r.Type = objabi.R_USEIFACE
+}
+
+// MarkUsedIfaceMethod marks that an interface method is used in the current
+// function. n is OCALLINTER node.
+func MarkUsedIfaceMethod(n *ir.CallExpr) {
+	dot := n.X.(*ir.SelectorExpr)
+	ityp := dot.X.Type()
+	tsym := TypeSym(ityp).Linksym()
+	r := obj.Addrel(ir.CurFunc.LSym)
+	r.Sym = tsym
+	// dot.Xoffset is the method index * Widthptr (the offset of code pointer
+	// in itab).
+	midx := dot.Offset / int64(types.PtrSize)
+	r.Add = InterfaceMethodOffset(ityp, midx)
+	r.Type = objabi.R_USEIFACEMETHOD
+}
diff --git a/src/cmd/compile/internal/staticdata/data.go b/src/cmd/compile/internal/staticdata/data.go
index 7627aaa11a..342a2e2bbc 100644
--- a/src/cmd/compile/internal/staticdata/data.go
+++ b/src/cmd/compile/internal/staticdata/data.go
@@ -7,6 +7,7 @@ package staticdata
 import (
 	"crypto/sha256"
 	"fmt"
+	"go/constant"
 	"io"
 	"io/ioutil"
 	"os"
@@ -294,3 +295,59 @@ func WriteFuncSyms() {
 		objw.Global(sf, int32(types.PtrSize), obj.DUPOK|obj.RODATA)
 	}
 }
+
+// InitConst writes the static literal c to n.
+// Neither n nor c is modified.
+func InitConst(n *ir.Name, noff int64, c ir.Node, wid int) {
+	if n.Op() != ir.ONAME {
+		base.Fatalf("litsym n op %v", n.Op())
+	}
+	if n.Sym() == nil {
+		base.Fatalf("litsym nil n sym")
+	}
+	if c.Op() == ir.ONIL {
+		return
+	}
+	if c.Op() != ir.OLITERAL {
+		base.Fatalf("litsym c op %v", c.Op())
+	}
+	s := n.Sym().Linksym()
+	switch u := c.Val(); u.Kind() {
+	case constant.Bool:
+		i := int64(obj.Bool2int(constant.BoolVal(u)))
+		s.WriteInt(base.Ctxt, noff, wid, i)
+
+	case constant.Int:
+		s.WriteInt(base.Ctxt, noff, wid, ir.IntVal(c.Type(), u))
+
+	case constant.Float:
+		f, _ := constant.Float64Val(u)
+		switch c.Type().Kind() {
+		case types.TFLOAT32:
+			s.WriteFloat32(base.Ctxt, noff, float32(f))
+		case types.TFLOAT64:
+			s.WriteFloat64(base.Ctxt, noff, f)
+		}
+
+	case constant.Complex:
+		re, _ := constant.Float64Val(constant.Real(u))
+		im, _ := constant.Float64Val(constant.Imag(u))
+		switch c.Type().Kind() {
+		case types.TCOMPLEX64:
+			s.WriteFloat32(base.Ctxt, noff, float32(re))
+			s.WriteFloat32(base.Ctxt, noff+4, float32(im))
+		case types.TCOMPLEX128:
+			s.WriteFloat64(base.Ctxt, noff, re)
+			s.WriteFloat64(base.Ctxt, noff+8, im)
+		}
+
+	case constant.String:
+		i := constant.StringVal(u)
+		symdata := StringSym(n.Pos(), i)
+		s.WriteAddr(base.Ctxt, noff, types.PtrSize, symdata, 0)
+		s.WriteInt(base.Ctxt, noff+int64(types.PtrSize), types.PtrSize, int64(len(i)))
+
+	default:
+		base.Fatalf("litsym unhandled OLITERAL %v", c)
+	}
+}
diff --git a/src/cmd/compile/internal/staticinit/sched.go b/src/cmd/compile/internal/staticinit/sched.go
new file mode 100644
index 0000000000..2a499d6eed
--- /dev/null
+++ b/src/cmd/compile/internal/staticinit/sched.go
@@ -0,0 +1,596 @@
+// Copyright 2009 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 staticinit
+
+import (
+	"fmt"
+	"go/constant"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/reflectdata"
+	"cmd/compile/internal/staticdata"
+	"cmd/compile/internal/typecheck"
+	"cmd/compile/internal/types"
+	"cmd/internal/obj"
+)
+
+type Entry struct {
+	Xoffset int64   // struct, array only
+	Expr    ir.Node // bytes of run-time computed expressions
+}
+
+type Plan struct {
+	E []Entry
+}
+
+// An Schedule is used to decompose assignment statements into
+// static and dynamic initialization parts. Static initializations are
+// handled by populating variables' linker symbol data, while dynamic
+// initializations are accumulated to be executed in order.
+type Schedule struct {
+	// Out is the ordered list of dynamic initialization
+	// statements.
+	Out []ir.Node
+
+	Plans map[ir.Node]*Plan
+	Temps map[ir.Node]*ir.Name
+}
+
+func (s *Schedule) append(n ir.Node) {
+	s.Out = append(s.Out, n)
+}
+
+// StaticInit adds an initialization statement n to the schedule.
+func (s *Schedule) StaticInit(n ir.Node) {
+	if !s.tryStaticInit(n) {
+		if base.Flag.Percent != 0 {
+			ir.Dump("nonstatic", n)
+		}
+		s.append(n)
+	}
+}
+
+// tryStaticInit attempts to statically execute an initialization
+// statement and reports whether it succeeded.
+func (s *Schedule) tryStaticInit(nn ir.Node) bool {
+	// Only worry about simple "l = r" assignments. Multiple
+	// variable/expression OAS2 assignments have already been
+	// replaced by multiple simple OAS assignments, and the other
+	// OAS2* assignments mostly necessitate dynamic execution
+	// anyway.
+	if nn.Op() != ir.OAS {
+		return false
+	}
+	n := nn.(*ir.AssignStmt)
+	if ir.IsBlank(n.X) && !AnySideEffects(n.Y) {
+		// Discard.
+		return true
+	}
+	lno := ir.SetPos(n)
+	defer func() { base.Pos = lno }()
+	nam := n.X.(*ir.Name)
+	return s.StaticAssign(nam, 0, n.Y, nam.Type())
+}
+
+// like staticassign but we are copying an already
+// initialized value r.
+func (s *Schedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *types.Type) bool {
+	if rn.Class_ == ir.PFUNC {
+		// TODO if roff != 0 { panic }
+		staticdata.InitFunc(l, loff, rn)
+		return true
+	}
+	if rn.Class_ != ir.PEXTERN || rn.Sym().Pkg != types.LocalPkg {
+		return false
+	}
+	if rn.Defn == nil { // probably zeroed but perhaps supplied externally and of unknown value
+		return false
+	}
+	if rn.Defn.Op() != ir.OAS {
+		return false
+	}
+	if rn.Type().IsString() { // perhaps overwritten by cmd/link -X (#34675)
+		return false
+	}
+	orig := rn
+	r := rn.Defn.(*ir.AssignStmt).Y
+
+	for r.Op() == ir.OCONVNOP && !types.Identical(r.Type(), typ) {
+		r = r.(*ir.ConvExpr).X
+	}
+
+	switch r.Op() {
+	case ir.OMETHEXPR:
+		r = r.(*ir.MethodExpr).FuncName()
+		fallthrough
+	case ir.ONAME:
+		r := r.(*ir.Name)
+		if s.staticcopy(l, loff, r, typ) {
+			return true
+		}
+		// We may have skipped past one or more OCONVNOPs, so
+		// use conv to ensure r is assignable to l (#13263).
+		dst := ir.Node(l)
+		if loff != 0 || !types.Identical(typ, l.Type()) {
+			dst = ir.NewNameOffsetExpr(base.Pos, l, loff, typ)
+		}
+		s.append(ir.NewAssignStmt(base.Pos, dst, typecheck.Conv(r, typ)))
+		return true
+
+	case ir.ONIL:
+		return true
+
+	case ir.OLITERAL:
+		if ir.IsZero(r) {
+			return true
+		}
+		staticdata.InitConst(l, loff, r, int(typ.Width))
+		return true
+
+	case ir.OADDR:
+		r := r.(*ir.AddrExpr)
+		if a := r.X; a.Op() == ir.ONAME {
+			a := a.(*ir.Name)
+			staticdata.InitAddr(l, loff, a, 0)
+			return true
+		}
+
+	case ir.OPTRLIT:
+		r := r.(*ir.AddrExpr)
+		switch r.X.Op() {
+		case ir.OARRAYLIT, ir.OSLICELIT, ir.OSTRUCTLIT, ir.OMAPLIT:
+			// copy pointer
+			staticdata.InitAddr(l, loff, s.Temps[r], 0)
+			return true
+		}
+
+	case ir.OSLICELIT:
+		r := r.(*ir.CompLitExpr)
+		// copy slice
+		staticdata.InitSlice(l, loff, s.Temps[r], r.Len)
+		return true
+
+	case ir.OARRAYLIT, ir.OSTRUCTLIT:
+		r := r.(*ir.CompLitExpr)
+		p := s.Plans[r]
+		for i := range p.E {
+			e := &p.E[i]
+			typ := e.Expr.Type()
+			if e.Expr.Op() == ir.OLITERAL || e.Expr.Op() == ir.ONIL {
+				staticdata.InitConst(l, loff+e.Xoffset, e.Expr, int(typ.Width))
+				continue
+			}
+			x := e.Expr
+			if x.Op() == ir.OMETHEXPR {
+				x = x.(*ir.MethodExpr).FuncName()
+			}
+			if x.Op() == ir.ONAME && s.staticcopy(l, loff+e.Xoffset, x.(*ir.Name), typ) {
+				continue
+			}
+			// Requires computation, but we're
+			// copying someone else's computation.
+			ll := ir.NewNameOffsetExpr(base.Pos, l, loff+e.Xoffset, typ)
+			rr := ir.NewNameOffsetExpr(base.Pos, orig, e.Xoffset, typ)
+			ir.SetPos(rr)
+			s.append(ir.NewAssignStmt(base.Pos, ll, rr))
+		}
+
+		return true
+	}
+
+	return false
+}
+
+func (s *Schedule) StaticAssign(l *ir.Name, loff int64, r ir.Node, typ *types.Type) bool {
+	for r.Op() == ir.OCONVNOP {
+		r = r.(*ir.ConvExpr).X
+	}
+
+	switch r.Op() {
+	case ir.ONAME:
+		r := r.(*ir.Name)
+		return s.staticcopy(l, loff, r, typ)
+
+	case ir.OMETHEXPR:
+		r := r.(*ir.MethodExpr)
+		return s.staticcopy(l, loff, r.FuncName(), typ)
+
+	case ir.ONIL:
+		return true
+
+	case ir.OLITERAL:
+		if ir.IsZero(r) {
+			return true
+		}
+		staticdata.InitConst(l, loff, r, int(typ.Width))
+		return true
+
+	case ir.OADDR:
+		r := r.(*ir.AddrExpr)
+		if name, offset, ok := StaticLoc(r.X); ok {
+			staticdata.InitAddr(l, loff, name, offset)
+			return true
+		}
+		fallthrough
+
+	case ir.OPTRLIT:
+		r := r.(*ir.AddrExpr)
+		switch r.X.Op() {
+		case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT, ir.OSTRUCTLIT:
+			// Init pointer.
+			a := StaticName(r.X.Type())
+
+			s.Temps[r] = a
+			staticdata.InitAddr(l, loff, a, 0)
+
+			// Init underlying literal.
+			if !s.StaticAssign(a, 0, r.X, a.Type()) {
+				s.append(ir.NewAssignStmt(base.Pos, a, r.X))
+			}
+			return true
+		}
+		//dump("not static ptrlit", r);
+
+	case ir.OSTR2BYTES:
+		r := r.(*ir.ConvExpr)
+		if l.Class_ == ir.PEXTERN && r.X.Op() == ir.OLITERAL {
+			sval := ir.StringVal(r.X)
+			staticdata.InitSliceBytes(l, loff, sval)
+			return true
+		}
+
+	case ir.OSLICELIT:
+		r := r.(*ir.CompLitExpr)
+		s.initplan(r)
+		// Init slice.
+		ta := types.NewArray(r.Type().Elem(), r.Len)
+		ta.SetNoalg(true)
+		a := StaticName(ta)
+		s.Temps[r] = a
+		staticdata.InitSlice(l, loff, a, r.Len)
+		// Fall through to init underlying array.
+		l = a
+		loff = 0
+		fallthrough
+
+	case ir.OARRAYLIT, ir.OSTRUCTLIT:
+		r := r.(*ir.CompLitExpr)
+		s.initplan(r)
+
+		p := s.Plans[r]
+		for i := range p.E {
+			e := &p.E[i]
+			if e.Expr.Op() == ir.OLITERAL || e.Expr.Op() == ir.ONIL {
+				staticdata.InitConst(l, loff+e.Xoffset, e.Expr, int(e.Expr.Type().Width))
+				continue
+			}
+			ir.SetPos(e.Expr)
+			if !s.StaticAssign(l, loff+e.Xoffset, e.Expr, e.Expr.Type()) {
+				a := ir.NewNameOffsetExpr(base.Pos, l, loff+e.Xoffset, e.Expr.Type())
+				s.append(ir.NewAssignStmt(base.Pos, a, e.Expr))
+			}
+		}
+
+		return true
+
+	case ir.OMAPLIT:
+		break
+
+	case ir.OCLOSURE:
+		r := r.(*ir.ClosureExpr)
+		if ir.IsTrivialClosure(r) {
+			if base.Debug.Closure > 0 {
+				base.WarnfAt(r.Pos(), "closure converted to global")
+			}
+			// Closures with no captured variables are globals,
+			// so the assignment can be done at link time.
+			// TODO if roff != 0 { panic }
+			staticdata.InitFunc(l, loff, r.Func.Nname)
+			return true
+		}
+		ir.ClosureDebugRuntimeCheck(r)
+
+	case ir.OCONVIFACE:
+		// This logic is mirrored in isStaticCompositeLiteral.
+		// If you change something here, change it there, and vice versa.
+
+		// Determine the underlying concrete type and value we are converting from.
+		r := r.(*ir.ConvExpr)
+		val := ir.Node(r)
+		for val.Op() == ir.OCONVIFACE {
+			val = val.(*ir.ConvExpr).X
+		}
+
+		if val.Type().IsInterface() {
+			// val is an interface type.
+			// If val is nil, we can statically initialize l;
+			// both words are zero and so there no work to do, so report success.
+			// If val is non-nil, we have no concrete type to record,
+			// and we won't be able to statically initialize its value, so report failure.
+			return val.Op() == ir.ONIL
+		}
+
+		reflectdata.MarkTypeUsedInInterface(val.Type(), l.Sym().Linksym())
+
+		var itab *ir.AddrExpr
+		if typ.IsEmptyInterface() {
+			itab = reflectdata.TypePtr(val.Type())
+		} else {
+			itab = reflectdata.ITabAddr(val.Type(), typ)
+		}
+
+		// Create a copy of l to modify while we emit data.
+
+		// Emit itab, advance offset.
+		staticdata.InitAddr(l, loff, itab.X.(*ir.Name), 0)
+
+		// Emit data.
+		if types.IsDirectIface(val.Type()) {
+			if val.Op() == ir.ONIL {
+				// Nil is zero, nothing to do.
+				return true
+			}
+			// Copy val directly into n.
+			ir.SetPos(val)
+			if !s.StaticAssign(l, loff+int64(types.PtrSize), val, val.Type()) {
+				a := ir.NewNameOffsetExpr(base.Pos, l, loff+int64(types.PtrSize), val.Type())
+				s.append(ir.NewAssignStmt(base.Pos, a, val))
+			}
+		} else {
+			// Construct temp to hold val, write pointer to temp into n.
+			a := StaticName(val.Type())
+			s.Temps[val] = a
+			if !s.StaticAssign(a, 0, val, val.Type()) {
+				s.append(ir.NewAssignStmt(base.Pos, a, val))
+			}
+			staticdata.InitAddr(l, loff+int64(types.PtrSize), a, 0)
+		}
+
+		return true
+	}
+
+	//dump("not static", r);
+	return false
+}
+
+func (s *Schedule) initplan(n ir.Node) {
+	if s.Plans[n] != nil {
+		return
+	}
+	p := new(Plan)
+	s.Plans[n] = p
+	switch n.Op() {
+	default:
+		base.Fatalf("initplan")
+
+	case ir.OARRAYLIT, ir.OSLICELIT:
+		n := n.(*ir.CompLitExpr)
+		var k int64
+		for _, a := range n.List {
+			if a.Op() == ir.OKEY {
+				kv := a.(*ir.KeyExpr)
+				k = typecheck.IndexConst(kv.Key)
+				if k < 0 {
+					base.Fatalf("initplan arraylit: invalid index %v", kv.Key)
+				}
+				a = kv.Value
+			}
+			s.addvalue(p, k*n.Type().Elem().Width, a)
+			k++
+		}
+
+	case ir.OSTRUCTLIT:
+		n := n.(*ir.CompLitExpr)
+		for _, a := range n.List {
+			if a.Op() != ir.OSTRUCTKEY {
+				base.Fatalf("initplan structlit")
+			}
+			a := a.(*ir.StructKeyExpr)
+			if a.Field.IsBlank() {
+				continue
+			}
+			s.addvalue(p, a.Offset, a.Value)
+		}
+
+	case ir.OMAPLIT:
+		n := n.(*ir.CompLitExpr)
+		for _, a := range n.List {
+			if a.Op() != ir.OKEY {
+				base.Fatalf("initplan maplit")
+			}
+			a := a.(*ir.KeyExpr)
+			s.addvalue(p, -1, a.Value)
+		}
+	}
+}
+
+func (s *Schedule) addvalue(p *Plan, xoffset int64, n ir.Node) {
+	// special case: zero can be dropped entirely
+	if ir.IsZero(n) {
+		return
+	}
+
+	// special case: inline struct and array (not slice) literals
+	if isvaluelit(n) {
+		s.initplan(n)
+		q := s.Plans[n]
+		for _, qe := range q.E {
+			// qe is a copy; we are not modifying entries in q.E
+			qe.Xoffset += xoffset
+			p.E = append(p.E, qe)
+		}
+		return
+	}
+
+	// add to plan
+	p.E = append(p.E, Entry{Xoffset: xoffset, Expr: n})
+}
+
+// from here down is the walk analysis
+// of composite literals.
+// most of the work is to generate
+// data statements for the constant
+// part of the composite literal.
+
+var statuniqgen int // name generator for static temps
+
+// StaticName returns a name backed by a (writable) static data symbol.
+// Use readonlystaticname for read-only node.
+func StaticName(t *types.Type) *ir.Name {
+	// Don't use lookupN; it interns the resulting string, but these are all unique.
+	n := typecheck.NewName(typecheck.Lookup(fmt.Sprintf("%s%d", obj.StaticNamePref, statuniqgen)))
+	statuniqgen++
+	typecheck.Declare(n, ir.PEXTERN)
+	n.SetType(t)
+	n.Sym().Linksym().Set(obj.AttrLocal, true)
+	return n
+}
+
+// StaticLoc returns the static address of n, if n has one, or else nil.
+func StaticLoc(n ir.Node) (name *ir.Name, offset int64, ok bool) {
+	if n == nil {
+		return nil, 0, false
+	}
+
+	switch n.Op() {
+	case ir.ONAME:
+		n := n.(*ir.Name)
+		return n, 0, true
+
+	case ir.OMETHEXPR:
+		n := n.(*ir.MethodExpr)
+		return StaticLoc(n.FuncName())
+
+	case ir.ODOT:
+		n := n.(*ir.SelectorExpr)
+		if name, offset, ok = StaticLoc(n.X); !ok {
+			break
+		}
+		offset += n.Offset
+		return name, offset, true
+
+	case ir.OINDEX:
+		n := n.(*ir.IndexExpr)
+		if n.X.Type().IsSlice() {
+			break
+		}
+		if name, offset, ok = StaticLoc(n.X); !ok {
+			break
+		}
+		l := getlit(n.Index)
+		if l < 0 {
+			break
+		}
+
+		// Check for overflow.
+		if n.Type().Width != 0 && types.MaxWidth/n.Type().Width <= int64(l) {
+			break
+		}
+		offset += int64(l) * n.Type().Width
+		return name, offset, true
+	}
+
+	return nil, 0, false
+}
+
+// AnySideEffects reports whether n contains any operations that could have observable side effects.
+func AnySideEffects(n ir.Node) bool {
+	return ir.Any(n, func(n ir.Node) bool {
+		switch n.Op() {
+		// Assume side effects unless we know otherwise.
+		default:
+			return true
+
+		// No side effects here (arguments are checked separately).
+		case ir.ONAME,
+			ir.ONONAME,
+			ir.OTYPE,
+			ir.OPACK,
+			ir.OLITERAL,
+			ir.ONIL,
+			ir.OADD,
+			ir.OSUB,
+			ir.OOR,
+			ir.OXOR,
+			ir.OADDSTR,
+			ir.OADDR,
+			ir.OANDAND,
+			ir.OBYTES2STR,
+			ir.ORUNES2STR,
+			ir.OSTR2BYTES,
+			ir.OSTR2RUNES,
+			ir.OCAP,
+			ir.OCOMPLIT,
+			ir.OMAPLIT,
+			ir.OSTRUCTLIT,
+			ir.OARRAYLIT,
+			ir.OSLICELIT,
+			ir.OPTRLIT,
+			ir.OCONV,
+			ir.OCONVIFACE,
+			ir.OCONVNOP,
+			ir.ODOT,
+			ir.OEQ,
+			ir.ONE,
+			ir.OLT,
+			ir.OLE,
+			ir.OGT,
+			ir.OGE,
+			ir.OKEY,
+			ir.OSTRUCTKEY,
+			ir.OLEN,
+			ir.OMUL,
+			ir.OLSH,
+			ir.ORSH,
+			ir.OAND,
+			ir.OANDNOT,
+			ir.ONEW,
+			ir.ONOT,
+			ir.OBITNOT,
+			ir.OPLUS,
+			ir.ONEG,
+			ir.OOROR,
+			ir.OPAREN,
+			ir.ORUNESTR,
+			ir.OREAL,
+			ir.OIMAG,
+			ir.OCOMPLEX:
+			return false
+
+		// Only possible side effect is division by zero.
+		case ir.ODIV, ir.OMOD:
+			n := n.(*ir.BinaryExpr)
+			if n.Y.Op() != ir.OLITERAL || constant.Sign(n.Y.Val()) == 0 {
+				return true
+			}
+
+		// Only possible side effect is panic on invalid size,
+		// but many makechan and makemap use size zero, which is definitely OK.
+		case ir.OMAKECHAN, ir.OMAKEMAP:
+			n := n.(*ir.MakeExpr)
+			if !ir.IsConst(n.Len, constant.Int) || constant.Sign(n.Len.Val()) != 0 {
+				return true
+			}
+
+		// Only possible side effect is panic on invalid size.
+		// TODO(rsc): Merge with previous case (probably breaks toolstash -cmp).
+		case ir.OMAKESLICE, ir.OMAKESLICECOPY:
+			return true
+		}
+		return false
+	})
+}
+
+func getlit(lit ir.Node) int {
+	if ir.IsSmallIntConst(lit) {
+		return int(ir.Int64Val(lit))
+	}
+	return -1
+}
+
+func isvaluelit(n ir.Node) bool {
+	return n.Op() == ir.OARRAYLIT || n.Op() == ir.OSTRUCTLIT
+}
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/walk/closure.go
similarity index 85%
rename from src/cmd/compile/internal/gc/closure.go
rename to src/cmd/compile/internal/walk/closure.go
index 4679b6535b..545c762ac7 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/walk/closure.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package walk
 
 import (
 	"cmd/compile/internal/base"
@@ -12,9 +12,9 @@ import (
 	"cmd/internal/src"
 )
 
-// transformclosure is called in a separate phase after escape analysis.
+// Closure is called in a separate phase after escape analysis.
 // It transform closure bodies to properly reference captured variables.
-func transformclosure(fn *ir.Func) {
+func Closure(fn *ir.Func) {
 	lno := base.Pos
 	base.Pos = fn.Pos()
 
@@ -115,38 +115,17 @@ func transformclosure(fn *ir.Func) {
 	base.Pos = lno
 }
 
-// hasemptycvars reports whether closure clo has an
-// empty list of captured vars.
-func hasemptycvars(clo *ir.ClosureExpr) bool {
-	return len(clo.Func.ClosureVars) == 0
-}
-
-// closuredebugruntimecheck applies boilerplate checks for debug flags
-// and compiling runtime
-func closuredebugruntimecheck(clo *ir.ClosureExpr) {
-	if base.Debug.Closure > 0 {
-		if clo.Esc() == ir.EscHeap {
-			base.WarnfAt(clo.Pos(), "heap closure, captured vars = %v", clo.Func.ClosureVars)
-		} else {
-			base.WarnfAt(clo.Pos(), "stack closure, captured vars = %v", clo.Func.ClosureVars)
-		}
-	}
-	if base.Flag.CompilingRuntime && clo.Esc() == ir.EscHeap {
-		base.ErrorfAt(clo.Pos(), "heap-allocated closure, not allowed in runtime")
-	}
-}
-
 func walkclosure(clo *ir.ClosureExpr, init *ir.Nodes) ir.Node {
 	fn := clo.Func
 
 	// If no closure vars, don't bother wrapping.
-	if hasemptycvars(clo) {
+	if ir.IsTrivialClosure(clo) {
 		if base.Debug.Closure > 0 {
 			base.WarnfAt(clo.Pos(), "closure converted to global")
 		}
 		return fn.Nname
 	}
-	closuredebugruntimecheck(clo)
+	ir.ClosureDebugRuntimeCheck(clo)
 
 	typ := typecheck.ClosureType(clo)
 
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/walk/order.go
similarity index 95%
rename from src/cmd/compile/internal/gc/order.go
rename to src/cmd/compile/internal/walk/order.go
index d1c5bb04a1..03310a50c6 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -2,17 +2,19 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package walk
 
 import (
+	"fmt"
+
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/escape"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/reflectdata"
+	"cmd/compile/internal/staticinit"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
-	"fmt"
 )
 
 // Rewrite tree to use separate statements to enforce
@@ -45,8 +47,8 @@ import (
 // it can result in unnecessary zeroing of those variables in the function
 // prologue.
 
-// Order holds state during the ordering process.
-type Order struct {
+// orderState holds state during the ordering process.
+type orderState struct {
 	out  []ir.Node             // list of generated statements
 	temp []*ir.Name            // stack of temporary variables
 	free map[string][]*ir.Name // free list of unused temporaries, by type.LongString().
@@ -65,14 +67,14 @@ func order(fn *ir.Func) {
 }
 
 // append typechecks stmt and appends it to out.
-func (o *Order) append(stmt ir.Node) {
+func (o *orderState) append(stmt ir.Node) {
 	o.out = append(o.out, typecheck.Stmt(stmt))
 }
 
 // newTemp allocates a new temporary with the given type,
 // pushes it onto the temp stack, and returns it.
 // If clear is true, newTemp emits code to zero the temporary.
-func (o *Order) newTemp(t *types.Type, clear bool) *ir.Name {
+func (o *orderState) newTemp(t *types.Type, clear bool) *ir.Name {
 	var v *ir.Name
 	// Note: LongString is close to the type equality we want,
 	// but not exactly. We still need to double-check with types.Identical.
@@ -100,7 +102,7 @@ func (o *Order) newTemp(t *types.Type, clear bool) *ir.Name {
 
 // copyExpr behaves like newTemp but also emits
 // code to initialize the temporary to the value n.
-func (o *Order) copyExpr(n ir.Node) ir.Node {
+func (o *orderState) copyExpr(n ir.Node) ir.Node {
 	return o.copyExpr1(n, false)
 }
 
@@ -114,11 +116,11 @@ func (o *Order) copyExpr(n ir.Node) ir.Node {
 // (The other candidate would be map access, but map access
 // returns a pointer to the result data instead of taking a pointer
 // to be filled in.)
-func (o *Order) copyExprClear(n ir.Node) *ir.Name {
+func (o *orderState) copyExprClear(n ir.Node) *ir.Name {
 	return o.copyExpr1(n, true)
 }
 
-func (o *Order) copyExpr1(n ir.Node, clear bool) *ir.Name {
+func (o *orderState) copyExpr1(n ir.Node, clear bool) *ir.Name {
 	t := n.Type()
 	v := o.newTemp(t, clear)
 	o.append(ir.NewAssignStmt(base.Pos, v, n))
@@ -129,7 +131,7 @@ func (o *Order) copyExpr1(n ir.Node, clear bool) *ir.Name {
 // The definition of cheap is that n is a variable or constant.
 // If not, cheapExpr allocates a new tmp, emits tmp = n,
 // and then returns tmp.
-func (o *Order) cheapExpr(n ir.Node) ir.Node {
+func (o *orderState) cheapExpr(n ir.Node) ir.Node {
 	if n == nil {
 		return nil
 	}
@@ -158,7 +160,7 @@ func (o *Order) cheapExpr(n ir.Node) ir.Node {
 // as assigning to the original n.
 //
 // The intended use is to apply to x when rewriting x += y into x = x + y.
-func (o *Order) safeExpr(n ir.Node) ir.Node {
+func (o *orderState) safeExpr(n ir.Node) ir.Node {
 	switch n.Op() {
 	case ir.ONAME, ir.OLITERAL, ir.ONIL:
 		return n
@@ -241,15 +243,15 @@ func isaddrokay(n ir.Node) bool {
 // tmp = n, and then returns tmp.
 // The result of addrTemp MUST be assigned back to n, e.g.
 // 	n.Left = o.addrTemp(n.Left)
-func (o *Order) addrTemp(n ir.Node) ir.Node {
+func (o *orderState) addrTemp(n ir.Node) ir.Node {
 	if n.Op() == ir.OLITERAL || n.Op() == ir.ONIL {
 		// TODO: expand this to all static composite literal nodes?
 		n = typecheck.DefaultLit(n, nil)
 		types.CalcSize(n.Type())
 		vstat := readonlystaticname(n.Type())
-		var s InitSchedule
-		s.staticassign(vstat, 0, n, n.Type())
-		if s.out != nil {
+		var s staticinit.Schedule
+		s.StaticAssign(vstat, 0, n, n.Type())
+		if s.Out != nil {
 			base.Fatalf("staticassign of const generated code: %+v", n)
 		}
 		vstat = typecheck.Expr(vstat).(*ir.Name)
@@ -263,7 +265,7 @@ func (o *Order) addrTemp(n ir.Node) ir.Node {
 
 // mapKeyTemp prepares n to be a key in a map runtime call and returns n.
 // It should only be used for map runtime calls which have *_fast* versions.
-func (o *Order) mapKeyTemp(t *types.Type, n ir.Node) ir.Node {
+func (o *orderState) mapKeyTemp(t *types.Type, n ir.Node) ir.Node {
 	// Most map calls need to take the address of the key.
 	// Exception: map*_fast* calls. See golang.org/issue/19015.
 	if mapfast(t) == mapslow {
@@ -318,13 +320,13 @@ func mapKeyReplaceStrConv(n ir.Node) bool {
 type ordermarker int
 
 // markTemp returns the top of the temporary variable stack.
-func (o *Order) markTemp() ordermarker {
+func (o *orderState) markTemp() ordermarker {
 	return ordermarker(len(o.temp))
 }
 
 // popTemp pops temporaries off the stack until reaching the mark,
 // which must have been returned by markTemp.
-func (o *Order) popTemp(mark ordermarker) {
+func (o *orderState) popTemp(mark ordermarker) {
 	for _, n := range o.temp[mark:] {
 		key := n.Type().LongString()
 		o.free[key] = append(o.free[key], n)
@@ -335,7 +337,7 @@ func (o *Order) popTemp(mark ordermarker) {
 // cleanTempNoPop emits VARKILL instructions to *out
 // for each temporary above the mark on the temporary stack.
 // It does not pop the temporaries from the stack.
-func (o *Order) cleanTempNoPop(mark ordermarker) []ir.Node {
+func (o *orderState) cleanTempNoPop(mark ordermarker) []ir.Node {
 	var out []ir.Node
 	for i := len(o.temp) - 1; i >= int(mark); i-- {
 		n := o.temp[i]
@@ -346,13 +348,13 @@ func (o *Order) cleanTempNoPop(mark ordermarker) []ir.Node {
 
 // cleanTemp emits VARKILL instructions for each temporary above the
 // mark on the temporary stack and removes them from the stack.
-func (o *Order) cleanTemp(top ordermarker) {
+func (o *orderState) cleanTemp(top ordermarker) {
 	o.out = append(o.out, o.cleanTempNoPop(top)...)
 	o.popTemp(top)
 }
 
 // stmtList orders each of the statements in the list.
-func (o *Order) stmtList(l ir.Nodes) {
+func (o *orderState) stmtList(l ir.Nodes) {
 	s := l
 	for i := range s {
 		orderMakeSliceCopy(s[i:])
@@ -396,14 +398,14 @@ func orderMakeSliceCopy(s []ir.Node) {
 }
 
 // edge inserts coverage instrumentation for libfuzzer.
-func (o *Order) edge() {
+func (o *orderState) edge() {
 	if base.Debug.Libfuzzer == 0 {
 		return
 	}
 
 	// Create a new uint8 counter to be allocated in section
 	// __libfuzzer_extra_counters.
-	counter := staticname(types.Types[types.TUINT8])
+	counter := staticinit.StaticName(types.Types[types.TUINT8])
 	counter.Name().SetLibfuzzerExtraCounter(true)
 
 	// counter += 1
@@ -415,7 +417,7 @@ func (o *Order) edge() {
 // and then replaces the old slice in n with the new slice.
 // free is a map that can be used to obtain temporary variables by type.
 func orderBlock(n *ir.Nodes, free map[string][]*ir.Name) {
-	var order Order
+	var order orderState
 	order.free = free
 	mark := order.markTemp()
 	order.edge()
@@ -428,8 +430,8 @@ func orderBlock(n *ir.Nodes, free map[string][]*ir.Name) {
 // leaves them as the init list of the final *np.
 // The result of exprInPlace MUST be assigned back to n, e.g.
 // 	n.Left = o.exprInPlace(n.Left)
-func (o *Order) exprInPlace(n ir.Node) ir.Node {
-	var order Order
+func (o *orderState) exprInPlace(n ir.Node) ir.Node {
+	var order orderState
 	order.free = o.free
 	n = order.expr(n, nil)
 	n = ir.InitExpr(order.out, n)
@@ -446,7 +448,7 @@ func (o *Order) exprInPlace(n ir.Node) ir.Node {
 // 	n.Left = orderStmtInPlace(n.Left)
 // free is a map that can be used to obtain temporary variables by type.
 func orderStmtInPlace(n ir.Node, free map[string][]*ir.Name) ir.Node {
-	var order Order
+	var order orderState
 	order.free = free
 	mark := order.markTemp()
 	order.stmt(n)
@@ -455,7 +457,7 @@ func orderStmtInPlace(n ir.Node, free map[string][]*ir.Name) ir.Node {
 }
 
 // init moves n's init list to o.out.
-func (o *Order) init(n ir.Node) {
+func (o *orderState) init(n ir.Node) {
 	if ir.MayBeShared(n) {
 		// For concurrency safety, don't mutate potentially shared nodes.
 		// First, ensure that no work is required here.
@@ -470,7 +472,7 @@ func (o *Order) init(n ir.Node) {
 
 // call orders the call expression n.
 // n.Op is OCALLMETH/OCALLFUNC/OCALLINTER or a builtin like OCOPY.
-func (o *Order) call(nn ir.Node) {
+func (o *orderState) call(nn ir.Node) {
 	if len(nn.Init()) > 0 {
 		// Caller should have already called o.init(nn).
 		base.Fatalf("%v with unexpected ninit", nn.Op())
@@ -551,7 +553,7 @@ func (o *Order) call(nn ir.Node) {
 // cases they are also typically registerizable, so not much harm done.
 // And this only applies to the multiple-assignment form.
 // We could do a more precise analysis if needed, like in walk.go.
-func (o *Order) mapAssign(n ir.Node) {
+func (o *orderState) mapAssign(n ir.Node) {
 	switch n.Op() {
 	default:
 		base.Fatalf("order.mapAssign %v", n.Op())
@@ -596,7 +598,7 @@ func (o *Order) mapAssign(n ir.Node) {
 	}
 }
 
-func (o *Order) safeMapRHS(r ir.Node) ir.Node {
+func (o *orderState) safeMapRHS(r ir.Node) ir.Node {
 	// Make sure we evaluate the RHS before starting the map insert.
 	// We need to make sure the RHS won't panic.  See issue 22881.
 	if r.Op() == ir.OAPPEND {
@@ -613,7 +615,7 @@ func (o *Order) safeMapRHS(r ir.Node) ir.Node {
 // stmt orders the statement n, appending to o.out.
 // Temporaries created during the statement are cleaned
 // up using VARKILL instructions as possible.
-func (o *Order) stmt(n ir.Node) {
+func (o *orderState) stmt(n ir.Node) {
 	if n == nil {
 		return
 	}
@@ -1061,7 +1063,7 @@ func hasDefaultCase(n *ir.SwitchStmt) bool {
 }
 
 // exprList orders the expression list l into o.
-func (o *Order) exprList(l ir.Nodes) {
+func (o *orderState) exprList(l ir.Nodes) {
 	s := l
 	for i := range s {
 		s[i] = o.expr(s[i], nil)
@@ -1070,14 +1072,14 @@ func (o *Order) exprList(l ir.Nodes) {
 
 // exprListInPlace orders the expression list l but saves
 // the side effects on the individual expression ninit lists.
-func (o *Order) exprListInPlace(l ir.Nodes) {
+func (o *orderState) exprListInPlace(l ir.Nodes) {
 	s := l
 	for i := range s {
 		s[i] = o.exprInPlace(s[i])
 	}
 }
 
-func (o *Order) exprNoLHS(n ir.Node) ir.Node {
+func (o *orderState) exprNoLHS(n ir.Node) ir.Node {
 	return o.expr(n, nil)
 }
 
@@ -1088,7 +1090,7 @@ func (o *Order) exprNoLHS(n ir.Node) ir.Node {
 // to avoid copying the result of the expression to a temporary.)
 // The result of expr MUST be assigned back to n, e.g.
 // 	n.Left = o.expr(n.Left, lhs)
-func (o *Order) expr(n, lhs ir.Node) ir.Node {
+func (o *orderState) expr(n, lhs ir.Node) ir.Node {
 	if n == nil {
 		return n
 	}
@@ -1098,7 +1100,7 @@ func (o *Order) expr(n, lhs ir.Node) ir.Node {
 	return n
 }
 
-func (o *Order) expr1(n, lhs ir.Node) ir.Node {
+func (o *orderState) expr1(n, lhs ir.Node) ir.Node {
 	o.init(n)
 
 	switch n.Op() {
@@ -1441,7 +1443,7 @@ func (o *Order) expr1(n, lhs ir.Node) ir.Node {
 //	tmp1, tmp2, tmp3 = ...
 // 	a, b, a = tmp1, tmp2, tmp3
 // This is necessary to ensure left to right assignment order.
-func (o *Order) as2(n *ir.AssignListStmt) {
+func (o *orderState) as2(n *ir.AssignListStmt) {
 	tmplist := []ir.Node{}
 	left := []ir.Node{}
 	for ni, l := range n.Lhs {
@@ -1463,7 +1465,7 @@ func (o *Order) as2(n *ir.AssignListStmt) {
 
 // okAs2 orders OAS2XXX with ok.
 // Just like as2, this also adds temporaries to ensure left-to-right assignment.
-func (o *Order) okAs2(n *ir.AssignListStmt) {
+func (o *orderState) okAs2(n *ir.AssignListStmt) {
 	var tmp1, tmp2 ir.Node
 	if !ir.IsBlank(n.Lhs[0]) {
 		typ := n.Rhs[0].Type()
diff --git a/src/cmd/compile/internal/gc/racewalk.go b/src/cmd/compile/internal/walk/race.go
similarity index 99%
rename from src/cmd/compile/internal/gc/racewalk.go
rename to src/cmd/compile/internal/walk/race.go
index c52bf1479b..1fe439a99a 100644
--- a/src/cmd/compile/internal/gc/racewalk.go
+++ b/src/cmd/compile/internal/walk/race.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package walk
 
 import (
 	"cmd/compile/internal/base"
diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/walk/range.go
similarity index 99%
rename from src/cmd/compile/internal/gc/range.go
rename to src/cmd/compile/internal/walk/range.go
index 2b2178a8bd..ea23761a39 100644
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/walk/range.go
@@ -2,9 +2,11 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package walk
 
 import (
+	"unicode/utf8"
+
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/reflectdata"
@@ -12,7 +14,6 @@ import (
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/sys"
-	"unicode/utf8"
 )
 
 func cheapComputableIndex(width int64) bool {
diff --git a/src/cmd/compile/internal/gc/select.go b/src/cmd/compile/internal/walk/select.go
similarity index 99%
rename from src/cmd/compile/internal/gc/select.go
rename to src/cmd/compile/internal/walk/select.go
index 51bb1e5355..006833eb7b 100644
--- a/src/cmd/compile/internal/gc/select.go
+++ b/src/cmd/compile/internal/walk/select.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package walk
 
 import (
 	"cmd/compile/internal/base"
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/walk/sinit.go
similarity index 59%
rename from src/cmd/compile/internal/gc/sinit.go
rename to src/cmd/compile/internal/walk/sinit.go
index 337b67af46..dbb17dfe50 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/walk/sinit.go
@@ -2,358 +2,18 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package walk
 
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
-	"cmd/compile/internal/reflectdata"
 	"cmd/compile/internal/staticdata"
+	"cmd/compile/internal/staticinit"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
-	"fmt"
 )
 
-type InitEntry struct {
-	Xoffset int64   // struct, array only
-	Expr    ir.Node // bytes of run-time computed expressions
-}
-
-type InitPlan struct {
-	E []InitEntry
-}
-
-// An InitSchedule is used to decompose assignment statements into
-// static and dynamic initialization parts. Static initializations are
-// handled by populating variables' linker symbol data, while dynamic
-// initializations are accumulated to be executed in order.
-type InitSchedule struct {
-	// out is the ordered list of dynamic initialization
-	// statements.
-	out []ir.Node
-
-	initplans map[ir.Node]*InitPlan
-	inittemps map[ir.Node]*ir.Name
-}
-
-func (s *InitSchedule) append(n ir.Node) {
-	s.out = append(s.out, n)
-}
-
-// staticInit adds an initialization statement n to the schedule.
-func (s *InitSchedule) staticInit(n ir.Node) {
-	if !s.tryStaticInit(n) {
-		if base.Flag.Percent != 0 {
-			ir.Dump("nonstatic", n)
-		}
-		s.append(n)
-	}
-}
-
-// tryStaticInit attempts to statically execute an initialization
-// statement and reports whether it succeeded.
-func (s *InitSchedule) tryStaticInit(nn ir.Node) bool {
-	// Only worry about simple "l = r" assignments. Multiple
-	// variable/expression OAS2 assignments have already been
-	// replaced by multiple simple OAS assignments, and the other
-	// OAS2* assignments mostly necessitate dynamic execution
-	// anyway.
-	if nn.Op() != ir.OAS {
-		return false
-	}
-	n := nn.(*ir.AssignStmt)
-	if ir.IsBlank(n.X) && !anySideEffects(n.Y) {
-		// Discard.
-		return true
-	}
-	lno := ir.SetPos(n)
-	defer func() { base.Pos = lno }()
-	nam := n.X.(*ir.Name)
-	return s.staticassign(nam, 0, n.Y, nam.Type())
-}
-
-// like staticassign but we are copying an already
-// initialized value r.
-func (s *InitSchedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *types.Type) bool {
-	if rn.Class_ == ir.PFUNC {
-		// TODO if roff != 0 { panic }
-		staticdata.InitFunc(l, loff, rn)
-		return true
-	}
-	if rn.Class_ != ir.PEXTERN || rn.Sym().Pkg != types.LocalPkg {
-		return false
-	}
-	if rn.Defn == nil { // probably zeroed but perhaps supplied externally and of unknown value
-		return false
-	}
-	if rn.Defn.Op() != ir.OAS {
-		return false
-	}
-	if rn.Type().IsString() { // perhaps overwritten by cmd/link -X (#34675)
-		return false
-	}
-	orig := rn
-	r := rn.Defn.(*ir.AssignStmt).Y
-
-	for r.Op() == ir.OCONVNOP && !types.Identical(r.Type(), typ) {
-		r = r.(*ir.ConvExpr).X
-	}
-
-	switch r.Op() {
-	case ir.OMETHEXPR:
-		r = r.(*ir.MethodExpr).FuncName()
-		fallthrough
-	case ir.ONAME:
-		r := r.(*ir.Name)
-		if s.staticcopy(l, loff, r, typ) {
-			return true
-		}
-		// We may have skipped past one or more OCONVNOPs, so
-		// use conv to ensure r is assignable to l (#13263).
-		dst := ir.Node(l)
-		if loff != 0 || !types.Identical(typ, l.Type()) {
-			dst = ir.NewNameOffsetExpr(base.Pos, l, loff, typ)
-		}
-		s.append(ir.NewAssignStmt(base.Pos, dst, typecheck.Conv(r, typ)))
-		return true
-
-	case ir.ONIL:
-		return true
-
-	case ir.OLITERAL:
-		if ir.IsZero(r) {
-			return true
-		}
-		litsym(l, loff, r, int(typ.Width))
-		return true
-
-	case ir.OADDR:
-		r := r.(*ir.AddrExpr)
-		if a := r.X; a.Op() == ir.ONAME {
-			a := a.(*ir.Name)
-			staticdata.InitAddr(l, loff, a, 0)
-			return true
-		}
-
-	case ir.OPTRLIT:
-		r := r.(*ir.AddrExpr)
-		switch r.X.Op() {
-		case ir.OARRAYLIT, ir.OSLICELIT, ir.OSTRUCTLIT, ir.OMAPLIT:
-			// copy pointer
-			staticdata.InitAddr(l, loff, s.inittemps[r], 0)
-			return true
-		}
-
-	case ir.OSLICELIT:
-		r := r.(*ir.CompLitExpr)
-		// copy slice
-		staticdata.InitSlice(l, loff, s.inittemps[r], r.Len)
-		return true
-
-	case ir.OARRAYLIT, ir.OSTRUCTLIT:
-		r := r.(*ir.CompLitExpr)
-		p := s.initplans[r]
-		for i := range p.E {
-			e := &p.E[i]
-			typ := e.Expr.Type()
-			if e.Expr.Op() == ir.OLITERAL || e.Expr.Op() == ir.ONIL {
-				litsym(l, loff+e.Xoffset, e.Expr, int(typ.Width))
-				continue
-			}
-			x := e.Expr
-			if x.Op() == ir.OMETHEXPR {
-				x = x.(*ir.MethodExpr).FuncName()
-			}
-			if x.Op() == ir.ONAME && s.staticcopy(l, loff+e.Xoffset, x.(*ir.Name), typ) {
-				continue
-			}
-			// Requires computation, but we're
-			// copying someone else's computation.
-			ll := ir.NewNameOffsetExpr(base.Pos, l, loff+e.Xoffset, typ)
-			rr := ir.NewNameOffsetExpr(base.Pos, orig, e.Xoffset, typ)
-			ir.SetPos(rr)
-			s.append(ir.NewAssignStmt(base.Pos, ll, rr))
-		}
-
-		return true
-	}
-
-	return false
-}
-
-func (s *InitSchedule) staticassign(l *ir.Name, loff int64, r ir.Node, typ *types.Type) bool {
-	for r.Op() == ir.OCONVNOP {
-		r = r.(*ir.ConvExpr).X
-	}
-
-	switch r.Op() {
-	case ir.ONAME:
-		r := r.(*ir.Name)
-		return s.staticcopy(l, loff, r, typ)
-
-	case ir.OMETHEXPR:
-		r := r.(*ir.MethodExpr)
-		return s.staticcopy(l, loff, r.FuncName(), typ)
-
-	case ir.ONIL:
-		return true
-
-	case ir.OLITERAL:
-		if ir.IsZero(r) {
-			return true
-		}
-		litsym(l, loff, r, int(typ.Width))
-		return true
-
-	case ir.OADDR:
-		r := r.(*ir.AddrExpr)
-		if name, offset, ok := stataddr(r.X); ok {
-			staticdata.InitAddr(l, loff, name, offset)
-			return true
-		}
-		fallthrough
-
-	case ir.OPTRLIT:
-		r := r.(*ir.AddrExpr)
-		switch r.X.Op() {
-		case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT, ir.OSTRUCTLIT:
-			// Init pointer.
-			a := staticname(r.X.Type())
-
-			s.inittemps[r] = a
-			staticdata.InitAddr(l, loff, a, 0)
-
-			// Init underlying literal.
-			if !s.staticassign(a, 0, r.X, a.Type()) {
-				s.append(ir.NewAssignStmt(base.Pos, a, r.X))
-			}
-			return true
-		}
-		//dump("not static ptrlit", r);
-
-	case ir.OSTR2BYTES:
-		r := r.(*ir.ConvExpr)
-		if l.Class_ == ir.PEXTERN && r.X.Op() == ir.OLITERAL {
-			sval := ir.StringVal(r.X)
-			staticdata.InitSliceBytes(l, loff, sval)
-			return true
-		}
-
-	case ir.OSLICELIT:
-		r := r.(*ir.CompLitExpr)
-		s.initplan(r)
-		// Init slice.
-		ta := types.NewArray(r.Type().Elem(), r.Len)
-		ta.SetNoalg(true)
-		a := staticname(ta)
-		s.inittemps[r] = a
-		staticdata.InitSlice(l, loff, a, r.Len)
-		// Fall through to init underlying array.
-		l = a
-		loff = 0
-		fallthrough
-
-	case ir.OARRAYLIT, ir.OSTRUCTLIT:
-		r := r.(*ir.CompLitExpr)
-		s.initplan(r)
-
-		p := s.initplans[r]
-		for i := range p.E {
-			e := &p.E[i]
-			if e.Expr.Op() == ir.OLITERAL || e.Expr.Op() == ir.ONIL {
-				litsym(l, loff+e.Xoffset, e.Expr, int(e.Expr.Type().Width))
-				continue
-			}
-			ir.SetPos(e.Expr)
-			if !s.staticassign(l, loff+e.Xoffset, e.Expr, e.Expr.Type()) {
-				a := ir.NewNameOffsetExpr(base.Pos, l, loff+e.Xoffset, e.Expr.Type())
-				s.append(ir.NewAssignStmt(base.Pos, a, e.Expr))
-			}
-		}
-
-		return true
-
-	case ir.OMAPLIT:
-		break
-
-	case ir.OCLOSURE:
-		r := r.(*ir.ClosureExpr)
-		if hasemptycvars(r) {
-			if base.Debug.Closure > 0 {
-				base.WarnfAt(r.Pos(), "closure converted to global")
-			}
-			// Closures with no captured variables are globals,
-			// so the assignment can be done at link time.
-			// TODO if roff != 0 { panic }
-			staticdata.InitFunc(l, loff, r.Func.Nname)
-			return true
-		}
-		closuredebugruntimecheck(r)
-
-	case ir.OCONVIFACE:
-		// This logic is mirrored in isStaticCompositeLiteral.
-		// If you change something here, change it there, and vice versa.
-
-		// Determine the underlying concrete type and value we are converting from.
-		r := r.(*ir.ConvExpr)
-		val := ir.Node(r)
-		for val.Op() == ir.OCONVIFACE {
-			val = val.(*ir.ConvExpr).X
-		}
-
-		if val.Type().IsInterface() {
-			// val is an interface type.
-			// If val is nil, we can statically initialize l;
-			// both words are zero and so there no work to do, so report success.
-			// If val is non-nil, we have no concrete type to record,
-			// and we won't be able to statically initialize its value, so report failure.
-			return val.Op() == ir.ONIL
-		}
-
-		markTypeUsedInInterface(val.Type(), l.Sym().Linksym())
-
-		var itab *ir.AddrExpr
-		if typ.IsEmptyInterface() {
-			itab = reflectdata.TypePtr(val.Type())
-		} else {
-			itab = reflectdata.ITabAddr(val.Type(), typ)
-		}
-
-		// Create a copy of l to modify while we emit data.
-
-		// Emit itab, advance offset.
-		staticdata.InitAddr(l, loff, itab.X.(*ir.Name), 0)
-
-		// Emit data.
-		if types.IsDirectIface(val.Type()) {
-			if val.Op() == ir.ONIL {
-				// Nil is zero, nothing to do.
-				return true
-			}
-			// Copy val directly into n.
-			ir.SetPos(val)
-			if !s.staticassign(l, loff+int64(types.PtrSize), val, val.Type()) {
-				a := ir.NewNameOffsetExpr(base.Pos, l, loff+int64(types.PtrSize), val.Type())
-				s.append(ir.NewAssignStmt(base.Pos, a, val))
-			}
-		} else {
-			// Construct temp to hold val, write pointer to temp into n.
-			a := staticname(val.Type())
-			s.inittemps[val] = a
-			if !s.staticassign(a, 0, val, val.Type()) {
-				s.append(ir.NewAssignStmt(base.Pos, a, val))
-			}
-			staticdata.InitAddr(l, loff+int64(types.PtrSize), a, 0)
-		}
-
-		return true
-	}
-
-	//dump("not static", r);
-	return false
-}
-
 // initContext is the context in which static data is populated.
 // It is either in an init function or in any other function.
 // Static data populated in an init function will be written either
@@ -378,29 +38,9 @@ func (c initContext) String() string {
 	return "inNonInitFunction"
 }
 
-// from here down is the walk analysis
-// of composite literals.
-// most of the work is to generate
-// data statements for the constant
-// part of the composite literal.
-
-var statuniqgen int // name generator for static temps
-
-// staticname returns a name backed by a (writable) static data symbol.
-// Use readonlystaticname for read-only node.
-func staticname(t *types.Type) *ir.Name {
-	// Don't use lookupN; it interns the resulting string, but these are all unique.
-	n := typecheck.NewName(typecheck.Lookup(fmt.Sprintf("%s%d", obj.StaticNamePref, statuniqgen)))
-	statuniqgen++
-	typecheck.Declare(n, ir.PEXTERN)
-	n.SetType(t)
-	n.Sym().Linksym().Set(obj.AttrLocal, true)
-	return n
-}
-
 // readonlystaticname returns a name backed by a (writable) static data symbol.
 func readonlystaticname(t *types.Type) *ir.Name {
-	n := staticname(t)
+	n := staticinit.StaticName(t)
 	n.MarkReadonly()
 	n.Sym().Linksym().Set(obj.AttrContentAddressable, true)
 	return n
@@ -572,7 +212,7 @@ func fixedlit(ctxt initContext, kind initKind, n *ir.CompLitExpr, var_ ir.Node,
 
 	for _, r := range n.List {
 		a, value := splitnode(r)
-		if a == ir.BlankNode && !anySideEffects(value) {
+		if a == ir.BlankNode && !staticinit.AnySideEffects(value) {
 			// Discard.
 			continue
 		}
@@ -629,14 +269,14 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 
 	if ctxt == inNonInitFunction {
 		// put everything into static array
-		vstat := staticname(t)
+		vstat := staticinit.StaticName(t)
 
 		fixedlit(ctxt, initKindStatic, n, vstat, init)
 		fixedlit(ctxt, initKindDynamic, n, vstat, init)
 
 		// copy static to slice
 		var_ = typecheck.AssignExpr(var_)
-		name, offset, ok := stataddr(var_)
+		name, offset, ok := staticinit.StaticLoc(var_)
 		if !ok || name.Class_ != ir.PEXTERN {
 			base.Fatalf("slicelit: %v", var_)
 		}
@@ -672,7 +312,7 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 		if ctxt == inInitFunction {
 			vstat = readonlystaticname(t)
 		} else {
-			vstat = staticname(t)
+			vstat = staticinit.StaticName(t)
 		}
 		fixedlit(ctxt, initKindStatic, n, vstat, init)
 	}
@@ -993,150 +633,19 @@ func oaslit(n *ir.AssignStmt, init *ir.Nodes) bool {
 	return true
 }
 
-func getlit(lit ir.Node) int {
-	if ir.IsSmallIntConst(lit) {
-		return int(ir.Int64Val(lit))
-	}
-	return -1
-}
-
-// stataddr returns the static address of n, if n has one, or else nil.
-func stataddr(n ir.Node) (name *ir.Name, offset int64, ok bool) {
-	if n == nil {
-		return nil, 0, false
-	}
-
-	switch n.Op() {
-	case ir.ONAME:
-		n := n.(*ir.Name)
-		return n, 0, true
-
-	case ir.OMETHEXPR:
-		n := n.(*ir.MethodExpr)
-		return stataddr(n.FuncName())
-
-	case ir.ODOT:
-		n := n.(*ir.SelectorExpr)
-		if name, offset, ok = stataddr(n.X); !ok {
-			break
-		}
-		offset += n.Offset
-		return name, offset, true
-
-	case ir.OINDEX:
-		n := n.(*ir.IndexExpr)
-		if n.X.Type().IsSlice() {
-			break
-		}
-		if name, offset, ok = stataddr(n.X); !ok {
-			break
-		}
-		l := getlit(n.Index)
-		if l < 0 {
-			break
-		}
-
-		// Check for overflow.
-		if n.Type().Width != 0 && types.MaxWidth/n.Type().Width <= int64(l) {
-			break
-		}
-		offset += int64(l) * n.Type().Width
-		return name, offset, true
-	}
-
-	return nil, 0, false
-}
-
-func (s *InitSchedule) initplan(n ir.Node) {
-	if s.initplans[n] != nil {
-		return
-	}
-	p := new(InitPlan)
-	s.initplans[n] = p
-	switch n.Op() {
-	default:
-		base.Fatalf("initplan")
-
-	case ir.OARRAYLIT, ir.OSLICELIT:
-		n := n.(*ir.CompLitExpr)
-		var k int64
-		for _, a := range n.List {
-			if a.Op() == ir.OKEY {
-				kv := a.(*ir.KeyExpr)
-				k = typecheck.IndexConst(kv.Key)
-				if k < 0 {
-					base.Fatalf("initplan arraylit: invalid index %v", kv.Key)
-				}
-				a = kv.Value
-			}
-			s.addvalue(p, k*n.Type().Elem().Width, a)
-			k++
-		}
-
-	case ir.OSTRUCTLIT:
-		n := n.(*ir.CompLitExpr)
-		for _, a := range n.List {
-			if a.Op() != ir.OSTRUCTKEY {
-				base.Fatalf("initplan structlit")
-			}
-			a := a.(*ir.StructKeyExpr)
-			if a.Field.IsBlank() {
-				continue
-			}
-			s.addvalue(p, a.Offset, a.Value)
-		}
-
-	case ir.OMAPLIT:
-		n := n.(*ir.CompLitExpr)
-		for _, a := range n.List {
-			if a.Op() != ir.OKEY {
-				base.Fatalf("initplan maplit")
-			}
-			a := a.(*ir.KeyExpr)
-			s.addvalue(p, -1, a.Value)
-		}
-	}
-}
-
-func (s *InitSchedule) addvalue(p *InitPlan, xoffset int64, n ir.Node) {
-	// special case: zero can be dropped entirely
-	if ir.IsZero(n) {
-		return
-	}
-
-	// special case: inline struct and array (not slice) literals
-	if isvaluelit(n) {
-		s.initplan(n)
-		q := s.initplans[n]
-		for _, qe := range q.E {
-			// qe is a copy; we are not modifying entries in q.E
-			qe.Xoffset += xoffset
-			p.E = append(p.E, qe)
-		}
-		return
-	}
-
-	// add to plan
-	p.E = append(p.E, InitEntry{Xoffset: xoffset, Expr: n})
-}
-
-func isvaluelit(n ir.Node) bool {
-	return n.Op() == ir.OARRAYLIT || n.Op() == ir.OSTRUCTLIT
-}
-
 func genAsStatic(as *ir.AssignStmt) {
 	if as.X.Type() == nil {
 		base.Fatalf("genAsStatic as.Left not typechecked")
 	}
 
-	name, offset, ok := stataddr(as.X)
+	name, offset, ok := staticinit.StaticLoc(as.X)
 	if !ok || (name.Class_ != ir.PEXTERN && as.X != ir.BlankNode) {
 		base.Fatalf("genAsStatic: lhs %v", as.X)
 	}
 
 	switch r := as.Y; r.Op() {
 	case ir.OLITERAL:
-		litsym(name, offset, r, int(r.Type().Width))
+		staticdata.InitConst(name, offset, r, int(r.Type().Width))
 		return
 	case ir.OMETHEXPR:
 		r := r.(*ir.MethodExpr)
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/walk/subr.go
similarity index 99%
rename from src/cmd/compile/internal/gc/subr.go
rename to src/cmd/compile/internal/walk/subr.go
index 17bbd1c3a2..bc65432d49 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/walk/subr.go
@@ -2,16 +2,17 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package walk
 
 import (
+	"fmt"
+
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
-	"fmt"
 )
 
 // backingArrayPtrLen extracts the pointer and length from a slice or string.
diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/walk/switch.go
similarity index 99%
rename from src/cmd/compile/internal/gc/swt.go
rename to src/cmd/compile/internal/walk/switch.go
index 9ffa8b67bb..9becd0e404 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/walk/switch.go
@@ -2,17 +2,18 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package walk
 
 import (
+	"go/constant"
+	"go/token"
+	"sort"
+
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
-	"go/constant"
-	"go/token"
-	"sort"
 )
 
 // walkswitch walks a switch statement.
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/walk/walk.go
similarity index 97%
rename from src/cmd/compile/internal/gc/walk.go
rename to src/cmd/compile/internal/walk/walk.go
index f86dbba2c9..cb3018a4ac 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -2,9 +2,16 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package walk
 
 import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"go/constant"
+	"go/token"
+	"strings"
+
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/escape"
 	"cmd/compile/internal/ir"
@@ -17,19 +24,13 @@ import (
 	"cmd/internal/objabi"
 	"cmd/internal/src"
 	"cmd/internal/sys"
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"go/constant"
-	"go/token"
-	"strings"
 )
 
 // The constant is known to runtime.
 const tmpstringbufsize = 32
 const zeroValSize = 1024 // must match value of runtime/map.go:maxZero
 
-func walk(fn *ir.Func) {
+func Walk(fn *ir.Func) {
 	ir.CurFunc = fn
 	errorsBefore := base.Errors()
 	order(fn)
@@ -670,7 +671,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		n := n.(*ir.CallExpr)
 		if n.Op() == ir.OCALLINTER {
 			usemethod(n)
-			markUsedIfaceMethod(n)
+			reflectdata.MarkUsedIfaceMethod(n)
 		}
 
 		if n.Op() == ir.OCALLFUNC && n.X.Op() == ir.OCLOSURE {
@@ -933,7 +934,7 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		toType := n.Type()
 
 		if !fromType.IsInterface() && !ir.IsBlank(ir.CurFunc.Nname) { // skip unnamed functions (func _())
-			markTypeUsedInInterface(fromType, ir.CurFunc.LSym)
+			reflectdata.MarkTypeUsedInInterface(fromType, ir.CurFunc.LSym)
 		}
 
 		// typeword generates the type word of the interface value.
@@ -1708,32 +1709,6 @@ func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
 	// in the presence of type assertions.
 }
 
-// markTypeUsedInInterface marks that type t is converted to an interface.
-// This information is used in the linker in dead method elimination.
-func markTypeUsedInInterface(t *types.Type, from *obj.LSym) {
-	tsym := reflectdata.TypeSym(t).Linksym()
-	// Emit a marker relocation. The linker will know the type is converted
-	// to an interface if "from" is reachable.
-	r := obj.Addrel(from)
-	r.Sym = tsym
-	r.Type = objabi.R_USEIFACE
-}
-
-// markUsedIfaceMethod marks that an interface method is used in the current
-// function. n is OCALLINTER node.
-func markUsedIfaceMethod(n *ir.CallExpr) {
-	dot := n.X.(*ir.SelectorExpr)
-	ityp := dot.X.Type()
-	tsym := reflectdata.TypeSym(ityp).Linksym()
-	r := obj.Addrel(ir.CurFunc.LSym)
-	r.Sym = tsym
-	// dot.Xoffset is the method index * Widthptr (the offset of code pointer
-	// in itab).
-	midx := dot.Offset / int64(types.PtrSize)
-	r.Add = reflectdata.InterfaceMethodOffset(ityp, midx)
-	r.Type = objabi.R_USEIFACEMETHOD
-}
-
 // rtconvfn returns the parameter and result types that will be used by a
 // runtime function to convert from type src to type dst. The runtime function
 // name can be derived from the names of the returned types.
@@ -3737,94 +3712,6 @@ func usefield(n *ir.SelectorExpr) {
 	ir.CurFunc.FieldTrack[sym] = struct{}{}
 }
 
-// anySideEffects reports whether n contains any operations that could have observable side effects.
-func anySideEffects(n ir.Node) bool {
-	return ir.Any(n, func(n ir.Node) bool {
-		switch n.Op() {
-		// Assume side effects unless we know otherwise.
-		default:
-			return true
-
-		// No side effects here (arguments are checked separately).
-		case ir.ONAME,
-			ir.ONONAME,
-			ir.OTYPE,
-			ir.OPACK,
-			ir.OLITERAL,
-			ir.ONIL,
-			ir.OADD,
-			ir.OSUB,
-			ir.OOR,
-			ir.OXOR,
-			ir.OADDSTR,
-			ir.OADDR,
-			ir.OANDAND,
-			ir.OBYTES2STR,
-			ir.ORUNES2STR,
-			ir.OSTR2BYTES,
-			ir.OSTR2RUNES,
-			ir.OCAP,
-			ir.OCOMPLIT,
-			ir.OMAPLIT,
-			ir.OSTRUCTLIT,
-			ir.OARRAYLIT,
-			ir.OSLICELIT,
-			ir.OPTRLIT,
-			ir.OCONV,
-			ir.OCONVIFACE,
-			ir.OCONVNOP,
-			ir.ODOT,
-			ir.OEQ,
-			ir.ONE,
-			ir.OLT,
-			ir.OLE,
-			ir.OGT,
-			ir.OGE,
-			ir.OKEY,
-			ir.OSTRUCTKEY,
-			ir.OLEN,
-			ir.OMUL,
-			ir.OLSH,
-			ir.ORSH,
-			ir.OAND,
-			ir.OANDNOT,
-			ir.ONEW,
-			ir.ONOT,
-			ir.OBITNOT,
-			ir.OPLUS,
-			ir.ONEG,
-			ir.OOROR,
-			ir.OPAREN,
-			ir.ORUNESTR,
-			ir.OREAL,
-			ir.OIMAG,
-			ir.OCOMPLEX:
-			return false
-
-		// Only possible side effect is division by zero.
-		case ir.ODIV, ir.OMOD:
-			n := n.(*ir.BinaryExpr)
-			if n.Y.Op() != ir.OLITERAL || constant.Sign(n.Y.Val()) == 0 {
-				return true
-			}
-
-		// Only possible side effect is panic on invalid size,
-		// but many makechan and makemap use size zero, which is definitely OK.
-		case ir.OMAKECHAN, ir.OMAKEMAP:
-			n := n.(*ir.MakeExpr)
-			if !ir.IsConst(n.Len, constant.Int) || constant.Sign(n.Len.Val()) != 0 {
-				return true
-			}
-
-		// Only possible side effect is panic on invalid size.
-		// TODO(rsc): Merge with previous case (probably breaks toolstash -cmp).
-		case ir.OMAKESLICE, ir.OMAKESLICECOPY:
-			return true
-		}
-		return false
-	})
-}
-
 // Rewrite
 //	go builtin(x, y, z)
 // into
-- 
GitLab


From 3f04d964ab05c31a41efa1590a8303376901ab60 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 23 Dec 2020 01:07:07 -0500
Subject: [PATCH 0317/2400] [dev.regabi] cmd/compile: split up walkexpr1,
 walkstmt [generated]

walkexpr1 is the second largest non-machine-generated function in the compiler.
weighing in at 1,164 lines. Since we are destroying the git blame history
anyway, now is a good time to split each different case into its own function,
making future work on this function more manageable.
Do the same to walkstmt too for consistency, even though it is a paltry 259 lines.

[git-generate]
cd src/cmd/compile/internal/walk
rf '
	mv addstr walkAddString
	mv walkCall walkCall1
	mv walkpartialcall walkCallPart
	mv walkclosure walkClosure
	mv walkrange walkRange
	mv walkselect walkSelect
	mv walkselectcases walkSelectCases
	mv walkswitch walkSwitch
	mv walkExprSwitch walkSwitchExpr
	mv walkTypeSwitch walkSwitchType
	mv walkstmt walkStmt
	mv walkstmtlist walkStmtList
	mv walkexprlist walkExprList
	mv walkexprlistsafe walkExprListSafe
	mv walkexprlistcheap walkExprListCheap
	mv walkexpr walkExpr
	mv walkexpr1 walkExpr1
	mv walkprint walkPrint
	mv walkappend walkAppend
	mv walkcompare walkCompare
	mv walkcompareInterface walkCompareInterface
	mv walkcompareString walkCompareString

	mv appendslice appendSlice
	mv cheapexpr cheapExpr
	mv copyany walkCopy
	mv copyexpr copyExpr
	mv eqfor eqFor
	mv extendslice extendSlice
	mv finishcompare finishCompare
	mv safeexpr safeExpr

	mv walkStmt:/^\tcase ir.ORECV:/+2,/^\tcase /-2 walkRecv
	add walk.go:/^func walkRecv/-0 \
		// walkRecv walks an ORECV node.
	mv walkStmt:/^\tcase ir.ODCL:/+2,/^\tcase /-2 walkDecl
	add walk.go:/^func walkDecl/-0 \
		// walkDecl walks an ODCL node.
	mv walkStmt:/^\tcase ir.OGO:/+2,/^\tcase /-2 walkGoDefer
	add walk.go:/^func walkGoDefer/-0 \
		// walkGoDefer walks an OGO or ODEFER node.
	mv walkStmt:/^\tcase ir.OFOR,/+2,/^\tcase /-2 walkFor
	add walk.go:/^func walkFor/-0 \
		// walkFor walks an OFOR or OFORUNTIL node.
	mv walkStmt:/^\tcase ir.OIF:/+2,/^\tcase /-2 walkIf
	add walk.go:/^func walkIf/-0 \
		// walkIf walks an OIF node.
	mv walkStmt:/^\tcase ir.ORETURN:/+2,/^\tcase /-2 walkReturn
	add walk.go:/^func walkReturn/-0 \
		// walkReturn walks an ORETURN node.

	mv walkExpr1:/^\tcase ir.ODOT,/+2,/^\tcase /-2 walkDot
	add walk.go:/^func walkDot/-0 \
		// walkDot walks an ODOT or ODOTPTR node.
	mv walkExpr1:/^\tcase ir.ODOTTYPE,/+2,/^\tcase /-2 walkDotType
	add walk.go:/^func walkDotType/-0 \
		// walkDotType walks an ODOTTYPE or ODOTTYPE2 node.
	mv walkExpr1:/^\tcase ir.OLEN,/+2,/^\tcase /-2 walkLenCap
	add walk.go:/^func walkLenCap/-0 \
		// walkLenCap walks an OLEN or OCAP node.
	mv walkExpr1:/^\tcase ir.OANDAND,/+2,/^\tcase /-2 walkLogical
	add walk.go:/^func walkLogical/-0 \
		// walkLogical walks an OANDAND or OOROR node.
	mv walkExpr1:/^\tcase ir.OCALLINTER,/+2,/^\tcase /-2 walkCall
	add walk.go:/^func walkCall/-0 \
		// walkCall walks an OCALLFUNC, OCALLINTER, or OCALLMETH node.
	mv walkExpr1:/^\tcase ir.OAS,/+1,/^\tcase /-2 walkAssign
	add walk.go:/^func walkAssign/-0 \
		// walkAssign walks an OAS (AssignExpr) or OASOP (AssignOpExpr) node.
	mv walkExpr1:/^\tcase ir.OAS2:/+2,/^\tcase /-3 walkAssignList
	add walk.go:/^func walkAssignList/-0 \
		// walkAssignList walks an OAS2 node.
	mv walkExpr1:/^\tcase ir.OAS2FUNC:/+2,/^\tcase /-4 walkAssignFunc
	add walk.go:/^func walkAssignFunc/-0 \
		// walkAssignFunc walks an OAS2FUNC node.
	mv walkExpr1:/^\tcase ir.OAS2RECV:/+2,/^\tcase /-3 walkAssignRecv
	add walk.go:/^func walkAssignRecv/-0 \
		// walkAssignRecv walks an OAS2RECV node.
	mv walkExpr1:/^\tcase ir.OAS2MAPR:/+2,/^\tcase /-2 walkAssignMapRead
	add walk.go:/^func walkAssignMapRead/-0 \
		// walkAssignMapRead walks an OAS2MAPR node.
	mv walkExpr1:/^\tcase ir.ODELETE:/+2,/^\tcase /-2 walkDelete
	add walk.go:/^func walkDelete/-0 \
		// walkDelete walks an ODELETE node.
	mv walkExpr1:/^\tcase ir.OAS2DOTTYPE:/+2,/^\tcase /-2 walkAssignDotType
	add walk.go:/^func walkAssignDotType/-0 \
		// walkAssignDotType walks an OAS2DOTTYPE node.
	mv walkExpr1:/^\tcase ir.OCONVIFACE:/+2,/^\tcase /-2 walkConvInterface
	add walk.go:/^func walkConvInterface/-0 \
		// walkConvInterface walks an OCONVIFACE node.
	mv walkExpr1:/^\tcase ir.OCONV,/+2,/^\tcase /-2 walkConv
	add walk.go:/^func walkConv/-0 \
		// walkConv walks an OCONV or OCONVNOP (but not OCONVIFACE) node.
	mv walkExpr1:/^\tcase ir.ODIV,/+2,/^\tcase /-2 walkDivMod
	add walk.go:/^func walkDivMod/-0 \
		// walkDivMod walks an ODIV or OMOD node.
	mv walkExpr1:/^\tcase ir.OINDEX:/+2,/^\tcase /-2 walkIndex
	add walk.go:/^func walkIndex/-0 \
		// walkIndex walks an OINDEX node.
	# move type assertion above comment
	mv walkExpr1:/^\tcase ir.OINDEXMAP:/+/n := n/-+ walkExpr1:/^\tcase ir.OINDEXMAP:/+0
	mv walkExpr1:/^\tcase ir.OINDEXMAP:/+2,/^\tcase /-2 walkIndexMap
	add walk.go:/^func walkIndexMap/-0 \
		// walkIndexMap walks an OINDEXMAP node.
	mv walkExpr1:/^\tcase ir.OSLICEHEADER:/+2,/^\tcase /-2 walkSliceHeader
	add walk.go:/^func walkSliceHeader/-0 \
		// walkSliceHeader walks an OSLICEHEADER node.
	mv walkExpr1:/^\tcase ir.OSLICE,/+2,/^\tcase /-2 walkSlice
	add walk.go:/^func walkSlice/-0 \
		// walkSlice walks an OSLICE, OSLICEARR, OSLICESTR, OSLICE3, or OSLICE3ARR node.
	mv walkExpr1:/^\tcase ir.ONEW:/+2,/^\tcase /-2 walkNew
	add walk.go:/^func walkNew/-0 \
		// walkNew walks an ONEW node.
	# move type assertion above comment
	mv walkExpr1:/^\tcase ir.OCLOSE:/+/n := n/-+ walkExpr1:/^\tcase ir.OCLOSE:/+0
	mv walkExpr1:/^\tcase ir.OCLOSE:/+2,/^\tcase /-2 walkClose
	add walk.go:/^func walkClose/-0 \
		// walkClose walks an OCLOSE node.
	# move type assertion above comment
	mv walkExpr1:/^\tcase ir.OMAKECHAN:/+/n := n/-+ walkExpr1:/^\tcase ir.OMAKECHAN:/+0
	mv walkExpr1:/^\tcase ir.OMAKECHAN:/+2,/^\tcase /-2 walkMakeChan
	add walk.go:/^func walkMakeChan/-0 \
		// walkMakeChan walks an OMAKECHAN node.
	mv walkExpr1:/^\tcase ir.OMAKEMAP:/+2,/^\tcase /-2 walkMakeMap
	add walk.go:/^func walkMakeMap/-0 \
		// walkMakeMap walks an OMAKEMAP node.
	mv walkExpr1:/^\tcase ir.OMAKESLICE:/+2,/^\tcase /-2 walkMakeSlice
	add walk.go:/^func walkMakeSlice/-0 \
		// walkMakeSlice walks an OMAKESLICE node.
	mv walkExpr1:/^\tcase ir.OMAKESLICECOPY:/+2,/^\tcase /-2 walkMakeSliceCopy
	add walk.go:/^func walkMakeSliceCopy/-0 \
		// walkMakeSliceCopy walks an OMAKESLICECOPY node.
	mv walkExpr1:/^\tcase ir.ORUNESTR:/+2,/^\tcase /-2 walkRuneToString
	add walk.go:/^func walkRuneToString/-0 \
		// walkRuneToString walks an ORUNESTR node.
	mv walkExpr1:/^\tcase ir.OBYTES2STR,/+2,/^\tcase /-2 walkBytesRunesToString
	add walk.go:/^func walkBytesRunesToString/-0 \
		// walkBytesRunesToString walks an OBYTES2STR or ORUNES2STR node.
	mv walkExpr1:/^\tcase ir.OBYTES2STRTMP:/+2,/^\tcase /-2 walkBytesToStringTemp
	add walk.go:/^func walkBytesToStringTemp/-0 \
		// walkBytesToStringTemp walks an OBYTES2STRTMP node.
	mv walkExpr1:/^\tcase ir.OSTR2BYTES:/+2,/^\tcase /-2 walkStringToBytes
	add walk.go:/^func walkStringToBytes/-0 \
		// walkStringToBytes walks an OSTR2BYTES node.
	# move type assertion above comment
	mv walkExpr1:/^\tcase ir.OSTR2BYTESTMP:/+/n := n/-+ walkExpr1:/^\tcase ir.OSTR2BYTESTMP:/+0
	mv walkExpr1:/^\tcase ir.OSTR2BYTESTMP:/+2,/^\tcase /-2 walkStringToBytesTemp
	add walk.go:/^func walkStringToBytesTemp/-0 \
		// walkStringToBytesTemp walks an OSTR2BYTESTMP node.
	mv walkExpr1:/^\tcase ir.OSTR2RUNES:/+2,/^\tcase /-2 walkStringToRunes
	add walk.go:/^func walkStringToRunes/-0 \
		// walkStringToRunes walks an OSTR2RUNES node.
	mv walkExpr1:/^\tcase ir.OARRAYLIT,/+1,/^\tcase /-2 walkCompLit
	add walk.go:/^func walkCompLit/-0 \
		// walkCompLit walks a composite literal node: \
		// OARRAYLIT, OSLICELIT, OMAPLIT, OSTRUCTLIT (all CompLitExpr), or OPTRLIT (AddrExpr).
	mv walkExpr1:/^\tcase ir.OSEND:/+2,/^\tcase /-2 walkSend
	add walk.go:/^func walkSend/-0 \
		// walkSend walks an OSEND node.

	mv walkStmt walkStmtList \
		walkDecl \
		walkFor \
		walkGoDefer \
		walkIf \
		wrapCall \
		stmt.go

	mv walkExpr walkExpr1 walkExprList walkExprListCheap walkExprListSafe \
		cheapExpr safeExpr copyExpr \
		walkAddString \
		walkCall \
		walkCall1 \
		walkDivMod \
		walkDot \
		walkDotType \
		walkIndex \
		walkIndexMap \
		walkLogical \
		walkSend \
		walkSlice \
		walkSliceHeader \
		reduceSlice \
		bounded \
		usemethod \
		usefield \
		expr.go

	mv \
		walkAssign \
		walkAssignDotType \
		walkAssignFunc \
		walkAssignList \
		walkAssignMapRead \
		walkAssignRecv \
		walkReturn \
		fncall \
		ascompatee \
		ascompatee1 \
		ascompatet \
		reorder3 \
		reorder3save \
		aliased \
		anyAddrTaken \
		refersToName \
		refersToCommonName \
		appendSlice \
		isAppendOfMake \
		extendSlice \
		assign.go

	mv \
		walkCompare \
		walkCompareInterface \
		walkCompareString \
		finishCompare \
		eqFor \
		brcom \
		brrev \
		tracecmpArg \
		canMergeLoads \
		compare.go

	mv \
		walkConv \
		walkConvInterface \
		walkBytesRunesToString \
		walkBytesToStringTemp \
		walkRuneToString \
		walkStringToBytes \
		walkStringToBytesTemp \
		walkStringToRunes \
		convFuncName \
		rtconvfn \
		byteindex \
		walkCheckPtrAlignment \
		walkCheckPtrArithmetic \
		convert.go

	mv \
		walkAppend \
		walkClose \
		walkCopy \
		walkDelete \
		walkLenCap \
		walkMakeChan \
		walkMakeMap \
		walkMakeSlice \
		walkMakeSliceCopy \
		walkNew \
		walkPrint \
		badtype \
		callnew \
		writebarrierfn \
		isRuneCount \
		builtin.go

	mv \
		walkCompLit \
		sinit.go \
		complit.go

	mv subr.go walk.go
'

Change-Id: Ie0cf3ba4adf363c120c134d57cb7ef37934eaab9
Reviewed-on: https://go-review.googlesource.com/c/go/+/279430
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/walk/assign.go       |  920 ++++
 src/cmd/compile/internal/walk/builtin.go      |  699 +++
 src/cmd/compile/internal/walk/closure.go      |   12 +-
 src/cmd/compile/internal/walk/compare.go      |  507 ++
 .../internal/walk/{sinit.go => complit.go}    |   23 +-
 src/cmd/compile/internal/walk/convert.go      |  502 ++
 src/cmd/compile/internal/walk/expr.go         | 1009 ++++
 src/cmd/compile/internal/walk/range.go        |   10 +-
 src/cmd/compile/internal/walk/select.go       |    8 +-
 src/cmd/compile/internal/walk/stmt.go         |  315 ++
 src/cmd/compile/internal/walk/subr.go         |  338 --
 src/cmd/compile/internal/walk/switch.go       |   30 +-
 src/cmd/compile/internal/walk/walk.go         | 4080 ++---------------
 13 files changed, 4364 insertions(+), 4089 deletions(-)
 create mode 100644 src/cmd/compile/internal/walk/assign.go
 create mode 100644 src/cmd/compile/internal/walk/builtin.go
 create mode 100644 src/cmd/compile/internal/walk/compare.go
 rename src/cmd/compile/internal/walk/{sinit.go => complit.go} (96%)
 create mode 100644 src/cmd/compile/internal/walk/convert.go
 create mode 100644 src/cmd/compile/internal/walk/expr.go
 create mode 100644 src/cmd/compile/internal/walk/stmt.go
 delete mode 100644 src/cmd/compile/internal/walk/subr.go

diff --git a/src/cmd/compile/internal/walk/assign.go b/src/cmd/compile/internal/walk/assign.go
new file mode 100644
index 0000000000..6b0e2b272c
--- /dev/null
+++ b/src/cmd/compile/internal/walk/assign.go
@@ -0,0 +1,920 @@
+// Copyright 2009 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 walk
+
+import (
+	"go/constant"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/reflectdata"
+	"cmd/compile/internal/typecheck"
+	"cmd/compile/internal/types"
+	"cmd/internal/src"
+)
+
+// walkAssign walks an OAS (AssignExpr) or OASOP (AssignOpExpr) node.
+func walkAssign(init *ir.Nodes, n ir.Node) ir.Node {
+	init.Append(n.PtrInit().Take()...)
+
+	var left, right ir.Node
+	switch n.Op() {
+	case ir.OAS:
+		n := n.(*ir.AssignStmt)
+		left, right = n.X, n.Y
+	case ir.OASOP:
+		n := n.(*ir.AssignOpStmt)
+		left, right = n.X, n.Y
+	}
+
+	// Recognize m[k] = append(m[k], ...) so we can reuse
+	// the mapassign call.
+	var mapAppend *ir.CallExpr
+	if left.Op() == ir.OINDEXMAP && right.Op() == ir.OAPPEND {
+		left := left.(*ir.IndexExpr)
+		mapAppend = right.(*ir.CallExpr)
+		if !ir.SameSafeExpr(left, mapAppend.Args[0]) {
+			base.Fatalf("not same expressions: %v != %v", left, mapAppend.Args[0])
+		}
+	}
+
+	left = walkExpr(left, init)
+	left = safeExpr(left, init)
+	if mapAppend != nil {
+		mapAppend.Args[0] = left
+	}
+
+	if n.Op() == ir.OASOP {
+		// Rewrite x op= y into x = x op y.
+		n = ir.NewAssignStmt(base.Pos, left, typecheck.Expr(ir.NewBinaryExpr(base.Pos, n.(*ir.AssignOpStmt).AsOp, left, right)))
+	} else {
+		n.(*ir.AssignStmt).X = left
+	}
+	as := n.(*ir.AssignStmt)
+
+	if oaslit(as, init) {
+		return ir.NewBlockStmt(as.Pos(), nil)
+	}
+
+	if as.Y == nil {
+		// TODO(austin): Check all "implicit zeroing"
+		return as
+	}
+
+	if !base.Flag.Cfg.Instrumenting && ir.IsZero(as.Y) {
+		return as
+	}
+
+	switch as.Y.Op() {
+	default:
+		as.Y = walkExpr(as.Y, init)
+
+	case ir.ORECV:
+		// x = <-c; as.Left is x, as.Right.Left is c.
+		// order.stmt made sure x is addressable.
+		recv := as.Y.(*ir.UnaryExpr)
+		recv.X = walkExpr(recv.X, init)
+
+		n1 := typecheck.NodAddr(as.X)
+		r := recv.X // the channel
+		return mkcall1(chanfn("chanrecv1", 2, r.Type()), nil, init, r, n1)
+
+	case ir.OAPPEND:
+		// x = append(...)
+		call := as.Y.(*ir.CallExpr)
+		if call.Type().Elem().NotInHeap() {
+			base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", call.Type().Elem())
+		}
+		var r ir.Node
+		switch {
+		case isAppendOfMake(call):
+			// x = append(y, make([]T, y)...)
+			r = extendSlice(call, init)
+		case call.IsDDD:
+			r = appendSlice(call, init) // also works for append(slice, string).
+		default:
+			r = walkAppend(call, init, as)
+		}
+		as.Y = r
+		if r.Op() == ir.OAPPEND {
+			// Left in place for back end.
+			// Do not add a new write barrier.
+			// Set up address of type for back end.
+			r.(*ir.CallExpr).X = reflectdata.TypePtr(r.Type().Elem())
+			return as
+		}
+		// Otherwise, lowered for race detector.
+		// Treat as ordinary assignment.
+	}
+
+	if as.X != nil && as.Y != nil {
+		return convas(as, init)
+	}
+	return as
+}
+
+// walkAssignDotType walks an OAS2DOTTYPE node.
+func walkAssignDotType(n *ir.AssignListStmt, init *ir.Nodes) ir.Node {
+	walkExprListSafe(n.Lhs, init)
+	n.Rhs[0] = walkExpr(n.Rhs[0], init)
+	return n
+}
+
+// walkAssignFunc walks an OAS2FUNC node.
+func walkAssignFunc(init *ir.Nodes, n *ir.AssignListStmt) ir.Node {
+	init.Append(n.PtrInit().Take()...)
+
+	r := n.Rhs[0]
+	walkExprListSafe(n.Lhs, init)
+	r = walkExpr(r, init)
+
+	if ir.IsIntrinsicCall(r.(*ir.CallExpr)) {
+		n.Rhs = []ir.Node{r}
+		return n
+	}
+	init.Append(r)
+
+	ll := ascompatet(n.Lhs, r.Type())
+	return ir.NewBlockStmt(src.NoXPos, ll)
+}
+
+// walkAssignList walks an OAS2 node.
+func walkAssignList(init *ir.Nodes, n *ir.AssignListStmt) ir.Node {
+	init.Append(n.PtrInit().Take()...)
+	walkExprListSafe(n.Lhs, init)
+	walkExprListSafe(n.Rhs, init)
+	return ir.NewBlockStmt(src.NoXPos, ascompatee(ir.OAS, n.Lhs, n.Rhs, init))
+}
+
+// walkAssignMapRead walks an OAS2MAPR node.
+func walkAssignMapRead(init *ir.Nodes, n *ir.AssignListStmt) ir.Node {
+	init.Append(n.PtrInit().Take()...)
+
+	r := n.Rhs[0].(*ir.IndexExpr)
+	walkExprListSafe(n.Lhs, init)
+	r.X = walkExpr(r.X, init)
+	r.Index = walkExpr(r.Index, init)
+	t := r.X.Type()
+
+	fast := mapfast(t)
+	var key ir.Node
+	if fast != mapslow {
+		// fast versions take key by value
+		key = r.Index
+	} else {
+		// standard version takes key by reference
+		// order.expr made sure key is addressable.
+		key = typecheck.NodAddr(r.Index)
+	}
+
+	// from:
+	//   a,b = m[i]
+	// to:
+	//   var,b = mapaccess2*(t, m, i)
+	//   a = *var
+	a := n.Lhs[0]
+
+	var call *ir.CallExpr
+	if w := t.Elem().Width; w <= zeroValSize {
+		fn := mapfn(mapaccess2[fast], t)
+		call = mkcall1(fn, fn.Type().Results(), init, reflectdata.TypePtr(t), r.X, key)
+	} else {
+		fn := mapfn("mapaccess2_fat", t)
+		z := reflectdata.ZeroAddr(w)
+		call = mkcall1(fn, fn.Type().Results(), init, reflectdata.TypePtr(t), r.X, key, z)
+	}
+
+	// mapaccess2* returns a typed bool, but due to spec changes,
+	// the boolean result of i.(T) is now untyped so we make it the
+	// same type as the variable on the lhs.
+	if ok := n.Lhs[1]; !ir.IsBlank(ok) && ok.Type().IsBoolean() {
+		call.Type().Field(1).Type = ok.Type()
+	}
+	n.Rhs = []ir.Node{call}
+	n.SetOp(ir.OAS2FUNC)
+
+	// don't generate a = *var if a is _
+	if ir.IsBlank(a) {
+		return walkExpr(typecheck.Stmt(n), init)
+	}
+
+	var_ := typecheck.Temp(types.NewPtr(t.Elem()))
+	var_.SetTypecheck(1)
+	var_.MarkNonNil() // mapaccess always returns a non-nil pointer
+
+	n.Lhs[0] = var_
+	init.Append(walkExpr(n, init))
+
+	as := ir.NewAssignStmt(base.Pos, a, ir.NewStarExpr(base.Pos, var_))
+	return walkExpr(typecheck.Stmt(as), init)
+}
+
+// walkAssignRecv walks an OAS2RECV node.
+func walkAssignRecv(init *ir.Nodes, n *ir.AssignListStmt) ir.Node {
+	init.Append(n.PtrInit().Take()...)
+
+	r := n.Rhs[0].(*ir.UnaryExpr) // recv
+	walkExprListSafe(n.Lhs, init)
+	r.X = walkExpr(r.X, init)
+	var n1 ir.Node
+	if ir.IsBlank(n.Lhs[0]) {
+		n1 = typecheck.NodNil()
+	} else {
+		n1 = typecheck.NodAddr(n.Lhs[0])
+	}
+	fn := chanfn("chanrecv2", 2, r.X.Type())
+	ok := n.Lhs[1]
+	call := mkcall1(fn, types.Types[types.TBOOL], init, r.X, n1)
+	return typecheck.Stmt(ir.NewAssignStmt(base.Pos, ok, call))
+}
+
+// walkReturn walks an ORETURN node.
+func walkReturn(n *ir.ReturnStmt) ir.Node {
+	ir.CurFunc.NumReturns++
+	if len(n.Results) == 0 {
+		return n
+	}
+	if (ir.HasNamedResults(ir.CurFunc) && len(n.Results) > 1) || paramoutheap(ir.CurFunc) {
+		// assign to the function out parameters,
+		// so that ascompatee can fix up conflicts
+		var rl []ir.Node
+
+		for _, ln := range ir.CurFunc.Dcl {
+			cl := ln.Class_
+			if cl == ir.PAUTO || cl == ir.PAUTOHEAP {
+				break
+			}
+			if cl == ir.PPARAMOUT {
+				var ln ir.Node = ln
+				if ir.IsParamStackCopy(ln) {
+					ln = walkExpr(typecheck.Expr(ir.NewStarExpr(base.Pos, ln.Name().Heapaddr)), nil)
+				}
+				rl = append(rl, ln)
+			}
+		}
+
+		if got, want := len(n.Results), len(rl); got != want {
+			// order should have rewritten multi-value function calls
+			// with explicit OAS2FUNC nodes.
+			base.Fatalf("expected %v return arguments, have %v", want, got)
+		}
+
+		// move function calls out, to make ascompatee's job easier.
+		walkExprListSafe(n.Results, n.PtrInit())
+
+		n.Results.Set(ascompatee(n.Op(), rl, n.Results, n.PtrInit()))
+		return n
+	}
+	walkExprList(n.Results, n.PtrInit())
+
+	// For each return parameter (lhs), assign the corresponding result (rhs).
+	lhs := ir.CurFunc.Type().Results()
+	rhs := n.Results
+	res := make([]ir.Node, lhs.NumFields())
+	for i, nl := range lhs.FieldSlice() {
+		nname := ir.AsNode(nl.Nname)
+		if ir.IsParamHeapCopy(nname) {
+			nname = nname.Name().Stackcopy
+		}
+		a := ir.NewAssignStmt(base.Pos, nname, rhs[i])
+		res[i] = convas(a, n.PtrInit())
+	}
+	n.Results.Set(res)
+	return n
+}
+
+// fncall reports whether assigning an rvalue of type rt to an lvalue l might involve a function call.
+func fncall(l ir.Node, rt *types.Type) bool {
+	if l.HasCall() || l.Op() == ir.OINDEXMAP {
+		return true
+	}
+	if types.Identical(l.Type(), rt) {
+		return false
+	}
+	// There might be a conversion required, which might involve a runtime call.
+	return true
+}
+
+func ascompatee(op ir.Op, nl, nr []ir.Node, init *ir.Nodes) []ir.Node {
+	// check assign expression list to
+	// an expression list. called in
+	//	expr-list = expr-list
+
+	// ensure order of evaluation for function calls
+	for i := range nl {
+		nl[i] = safeExpr(nl[i], init)
+	}
+	for i1 := range nr {
+		nr[i1] = safeExpr(nr[i1], init)
+	}
+
+	var nn []*ir.AssignStmt
+	i := 0
+	for ; i < len(nl); i++ {
+		if i >= len(nr) {
+			break
+		}
+		// Do not generate 'x = x' during return. See issue 4014.
+		if op == ir.ORETURN && ir.SameSafeExpr(nl[i], nr[i]) {
+			continue
+		}
+		nn = append(nn, ascompatee1(nl[i], nr[i], init))
+	}
+
+	// cannot happen: caller checked that lists had same length
+	if i < len(nl) || i < len(nr) {
+		var nln, nrn ir.Nodes
+		nln.Set(nl)
+		nrn.Set(nr)
+		base.Fatalf("error in shape across %+v %v %+v / %d %d [%s]", nln, op, nrn, len(nl), len(nr), ir.FuncName(ir.CurFunc))
+	}
+	return reorder3(nn)
+}
+
+func ascompatee1(l ir.Node, r ir.Node, init *ir.Nodes) *ir.AssignStmt {
+	// convas will turn map assigns into function calls,
+	// making it impossible for reorder3 to work.
+	n := ir.NewAssignStmt(base.Pos, l, r)
+
+	if l.Op() == ir.OINDEXMAP {
+		return n
+	}
+
+	return convas(n, init)
+}
+
+// check assign type list to
+// an expression list. called in
+//	expr-list = func()
+func ascompatet(nl ir.Nodes, nr *types.Type) []ir.Node {
+	if len(nl) != nr.NumFields() {
+		base.Fatalf("ascompatet: assignment count mismatch: %d = %d", len(nl), nr.NumFields())
+	}
+
+	var nn, mm ir.Nodes
+	for i, l := range nl {
+		if ir.IsBlank(l) {
+			continue
+		}
+		r := nr.Field(i)
+
+		// Any assignment to an lvalue that might cause a function call must be
+		// deferred until all the returned values have been read.
+		if fncall(l, r.Type) {
+			tmp := ir.Node(typecheck.Temp(r.Type))
+			tmp = typecheck.Expr(tmp)
+			a := convas(ir.NewAssignStmt(base.Pos, l, tmp), &mm)
+			mm.Append(a)
+			l = tmp
+		}
+
+		res := ir.NewResultExpr(base.Pos, nil, types.BADWIDTH)
+		res.Offset = base.Ctxt.FixedFrameSize() + r.Offset
+		res.SetType(r.Type)
+		res.SetTypecheck(1)
+
+		a := convas(ir.NewAssignStmt(base.Pos, l, res), &nn)
+		updateHasCall(a)
+		if a.HasCall() {
+			ir.Dump("ascompatet ucount", a)
+			base.Fatalf("ascompatet: too many function calls evaluating parameters")
+		}
+
+		nn.Append(a)
+	}
+	return append(nn, mm...)
+}
+
+// reorder3
+// from ascompatee
+//	a,b = c,d
+// simultaneous assignment. there cannot
+// be later use of an earlier lvalue.
+//
+// function calls have been removed.
+func reorder3(all []*ir.AssignStmt) []ir.Node {
+	// If a needed expression may be affected by an
+	// earlier assignment, make an early copy of that
+	// expression and use the copy instead.
+	var early []ir.Node
+
+	var mapinit ir.Nodes
+	for i, n := range all {
+		l := n.X
+
+		// Save subexpressions needed on left side.
+		// Drill through non-dereferences.
+		for {
+			switch ll := l; ll.Op() {
+			case ir.ODOT:
+				ll := ll.(*ir.SelectorExpr)
+				l = ll.X
+				continue
+			case ir.OPAREN:
+				ll := ll.(*ir.ParenExpr)
+				l = ll.X
+				continue
+			case ir.OINDEX:
+				ll := ll.(*ir.IndexExpr)
+				if ll.X.Type().IsArray() {
+					ll.Index = reorder3save(ll.Index, all, i, &early)
+					l = ll.X
+					continue
+				}
+			}
+			break
+		}
+
+		switch l.Op() {
+		default:
+			base.Fatalf("reorder3 unexpected lvalue %v", l.Op())
+
+		case ir.ONAME:
+			break
+
+		case ir.OINDEX, ir.OINDEXMAP:
+			l := l.(*ir.IndexExpr)
+			l.X = reorder3save(l.X, all, i, &early)
+			l.Index = reorder3save(l.Index, all, i, &early)
+			if l.Op() == ir.OINDEXMAP {
+				all[i] = convas(all[i], &mapinit)
+			}
+
+		case ir.ODEREF:
+			l := l.(*ir.StarExpr)
+			l.X = reorder3save(l.X, all, i, &early)
+		case ir.ODOTPTR:
+			l := l.(*ir.SelectorExpr)
+			l.X = reorder3save(l.X, all, i, &early)
+		}
+
+		// Save expression on right side.
+		all[i].Y = reorder3save(all[i].Y, all, i, &early)
+	}
+
+	early = append(mapinit, early...)
+	for _, as := range all {
+		early = append(early, as)
+	}
+	return early
+}
+
+// if the evaluation of *np would be affected by the
+// assignments in all up to but not including the ith assignment,
+// copy into a temporary during *early and
+// replace *np with that temp.
+// The result of reorder3save MUST be assigned back to n, e.g.
+// 	n.Left = reorder3save(n.Left, all, i, early)
+func reorder3save(n ir.Node, all []*ir.AssignStmt, i int, early *[]ir.Node) ir.Node {
+	if !aliased(n, all[:i]) {
+		return n
+	}
+
+	q := ir.Node(typecheck.Temp(n.Type()))
+	as := typecheck.Stmt(ir.NewAssignStmt(base.Pos, q, n))
+	*early = append(*early, as)
+	return q
+}
+
+// Is it possible that the computation of r might be
+// affected by assignments in all?
+func aliased(r ir.Node, all []*ir.AssignStmt) bool {
+	if r == nil {
+		return false
+	}
+
+	// Treat all fields of a struct as referring to the whole struct.
+	// We could do better but we would have to keep track of the fields.
+	for r.Op() == ir.ODOT {
+		r = r.(*ir.SelectorExpr).X
+	}
+
+	// Look for obvious aliasing: a variable being assigned
+	// during the all list and appearing in n.
+	// Also record whether there are any writes to addressable
+	// memory (either main memory or variables whose addresses
+	// have been taken).
+	memwrite := false
+	for _, as := range all {
+		// We can ignore assignments to blank.
+		if ir.IsBlank(as.X) {
+			continue
+		}
+
+		lv := ir.OuterValue(as.X)
+		if lv.Op() != ir.ONAME {
+			memwrite = true
+			continue
+		}
+		l := lv.(*ir.Name)
+
+		switch l.Class_ {
+		default:
+			base.Fatalf("unexpected class: %v, %v", l, l.Class_)
+
+		case ir.PAUTOHEAP, ir.PEXTERN:
+			memwrite = true
+			continue
+
+		case ir.PAUTO, ir.PPARAM, ir.PPARAMOUT:
+			if l.Name().Addrtaken() {
+				memwrite = true
+				continue
+			}
+
+			if refersToName(l, r) {
+				// Direct hit: l appears in r.
+				return true
+			}
+		}
+	}
+
+	// The variables being written do not appear in r.
+	// However, r might refer to computed addresses
+	// that are being written.
+
+	// If no computed addresses are affected by the writes, no aliasing.
+	if !memwrite {
+		return false
+	}
+
+	// If r does not refer to any variables whose addresses have been taken,
+	// then the only possible writes to r would be directly to the variables,
+	// and we checked those above, so no aliasing problems.
+	if !anyAddrTaken(r) {
+		return false
+	}
+
+	// Otherwise, both the writes and r refer to computed memory addresses.
+	// Assume that they might conflict.
+	return true
+}
+
+// anyAddrTaken reports whether the evaluation n,
+// which appears on the left side of an assignment,
+// may refer to variables whose addresses have been taken.
+func anyAddrTaken(n ir.Node) bool {
+	return ir.Any(n, func(n ir.Node) bool {
+		switch n.Op() {
+		case ir.ONAME:
+			n := n.(*ir.Name)
+			return n.Class_ == ir.PEXTERN || n.Class_ == ir.PAUTOHEAP || n.Name().Addrtaken()
+
+		case ir.ODOT: // but not ODOTPTR - should have been handled in aliased.
+			base.Fatalf("anyAddrTaken unexpected ODOT")
+
+		case ir.OADD,
+			ir.OAND,
+			ir.OANDAND,
+			ir.OANDNOT,
+			ir.OBITNOT,
+			ir.OCONV,
+			ir.OCONVIFACE,
+			ir.OCONVNOP,
+			ir.ODIV,
+			ir.ODOTTYPE,
+			ir.OLITERAL,
+			ir.OLSH,
+			ir.OMOD,
+			ir.OMUL,
+			ir.ONEG,
+			ir.ONIL,
+			ir.OOR,
+			ir.OOROR,
+			ir.OPAREN,
+			ir.OPLUS,
+			ir.ORSH,
+			ir.OSUB,
+			ir.OXOR:
+			return false
+		}
+		// Be conservative.
+		return true
+	})
+}
+
+// refersToName reports whether r refers to name.
+func refersToName(name *ir.Name, r ir.Node) bool {
+	return ir.Any(r, func(r ir.Node) bool {
+		return r.Op() == ir.ONAME && r == name
+	})
+}
+
+// refersToCommonName reports whether any name
+// appears in common between l and r.
+// This is called from sinit.go.
+func refersToCommonName(l ir.Node, r ir.Node) bool {
+	if l == nil || r == nil {
+		return false
+	}
+
+	// This could be written elegantly as a Find nested inside a Find:
+	//
+	//	found := ir.Find(l, func(l ir.Node) interface{} {
+	//		if l.Op() == ir.ONAME {
+	//			return ir.Find(r, func(r ir.Node) interface{} {
+	//				if r.Op() == ir.ONAME && l.Name() == r.Name() {
+	//					return r
+	//				}
+	//				return nil
+	//			})
+	//		}
+	//		return nil
+	//	})
+	//	return found != nil
+	//
+	// But that would allocate a new closure for the inner Find
+	// for each name found on the left side.
+	// It may not matter at all, but the below way of writing it
+	// only allocates two closures, not O(|L|) closures.
+
+	var doL, doR func(ir.Node) error
+	var targetL *ir.Name
+	doR = func(r ir.Node) error {
+		if r.Op() == ir.ONAME && r.Name() == targetL {
+			return stop
+		}
+		return ir.DoChildren(r, doR)
+	}
+	doL = func(l ir.Node) error {
+		if l.Op() == ir.ONAME {
+			l := l.(*ir.Name)
+			targetL = l.Name()
+			if doR(r) == stop {
+				return stop
+			}
+		}
+		return ir.DoChildren(l, doL)
+	}
+	return doL(l) == stop
+}
+
+// expand append(l1, l2...) to
+//   init {
+//     s := l1
+//     n := len(s) + len(l2)
+//     // Compare as uint so growslice can panic on overflow.
+//     if uint(n) > uint(cap(s)) {
+//       s = growslice(s, n)
+//     }
+//     s = s[:n]
+//     memmove(&s[len(l1)], &l2[0], len(l2)*sizeof(T))
+//   }
+//   s
+//
+// l2 is allowed to be a string.
+func appendSlice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
+	walkAppendArgs(n, init)
+
+	l1 := n.Args[0]
+	l2 := n.Args[1]
+	l2 = cheapExpr(l2, init)
+	n.Args[1] = l2
+
+	var nodes ir.Nodes
+
+	// var s []T
+	s := typecheck.Temp(l1.Type())
+	nodes.Append(ir.NewAssignStmt(base.Pos, s, l1)) // s = l1
+
+	elemtype := s.Type().Elem()
+
+	// n := len(s) + len(l2)
+	nn := typecheck.Temp(types.Types[types.TINT])
+	nodes.Append(ir.NewAssignStmt(base.Pos, nn, ir.NewBinaryExpr(base.Pos, ir.OADD, ir.NewUnaryExpr(base.Pos, ir.OLEN, s), ir.NewUnaryExpr(base.Pos, ir.OLEN, l2))))
+
+	// if uint(n) > uint(cap(s))
+	nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
+	nuint := typecheck.Conv(nn, types.Types[types.TUINT])
+	scapuint := typecheck.Conv(ir.NewUnaryExpr(base.Pos, ir.OCAP, s), types.Types[types.TUINT])
+	nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OGT, nuint, scapuint)
+
+	// instantiate growslice(typ *type, []any, int) []any
+	fn := typecheck.LookupRuntime("growslice")
+	fn = typecheck.SubstArgTypes(fn, elemtype, elemtype)
+
+	// s = growslice(T, s, n)
+	nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, s, mkcall1(fn, s.Type(), nif.PtrInit(), reflectdata.TypePtr(elemtype), s, nn))}
+	nodes.Append(nif)
+
+	// s = s[:n]
+	nt := ir.NewSliceExpr(base.Pos, ir.OSLICE, s)
+	nt.SetSliceBounds(nil, nn, nil)
+	nt.SetBounded(true)
+	nodes.Append(ir.NewAssignStmt(base.Pos, s, nt))
+
+	var ncopy ir.Node
+	if elemtype.HasPointers() {
+		// copy(s[len(l1):], l2)
+		slice := ir.NewSliceExpr(base.Pos, ir.OSLICE, s)
+		slice.SetType(s.Type())
+		slice.SetSliceBounds(ir.NewUnaryExpr(base.Pos, ir.OLEN, l1), nil, nil)
+
+		ir.CurFunc.SetWBPos(n.Pos())
+
+		// instantiate typedslicecopy(typ *type, dstPtr *any, dstLen int, srcPtr *any, srcLen int) int
+		fn := typecheck.LookupRuntime("typedslicecopy")
+		fn = typecheck.SubstArgTypes(fn, l1.Type().Elem(), l2.Type().Elem())
+		ptr1, len1 := backingArrayPtrLen(cheapExpr(slice, &nodes))
+		ptr2, len2 := backingArrayPtrLen(l2)
+		ncopy = mkcall1(fn, types.Types[types.TINT], &nodes, reflectdata.TypePtr(elemtype), ptr1, len1, ptr2, len2)
+	} else if base.Flag.Cfg.Instrumenting && !base.Flag.CompilingRuntime {
+		// rely on runtime to instrument:
+		//  copy(s[len(l1):], l2)
+		// l2 can be a slice or string.
+		slice := ir.NewSliceExpr(base.Pos, ir.OSLICE, s)
+		slice.SetType(s.Type())
+		slice.SetSliceBounds(ir.NewUnaryExpr(base.Pos, ir.OLEN, l1), nil, nil)
+
+		ptr1, len1 := backingArrayPtrLen(cheapExpr(slice, &nodes))
+		ptr2, len2 := backingArrayPtrLen(l2)
+
+		fn := typecheck.LookupRuntime("slicecopy")
+		fn = typecheck.SubstArgTypes(fn, ptr1.Type().Elem(), ptr2.Type().Elem())
+		ncopy = mkcall1(fn, types.Types[types.TINT], &nodes, ptr1, len1, ptr2, len2, ir.NewInt(elemtype.Width))
+	} else {
+		// memmove(&s[len(l1)], &l2[0], len(l2)*sizeof(T))
+		ix := ir.NewIndexExpr(base.Pos, s, ir.NewUnaryExpr(base.Pos, ir.OLEN, l1))
+		ix.SetBounded(true)
+		addr := typecheck.NodAddr(ix)
+
+		sptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, l2)
+
+		nwid := cheapExpr(typecheck.Conv(ir.NewUnaryExpr(base.Pos, ir.OLEN, l2), types.Types[types.TUINTPTR]), &nodes)
+		nwid = ir.NewBinaryExpr(base.Pos, ir.OMUL, nwid, ir.NewInt(elemtype.Width))
+
+		// instantiate func memmove(to *any, frm *any, length uintptr)
+		fn := typecheck.LookupRuntime("memmove")
+		fn = typecheck.SubstArgTypes(fn, elemtype, elemtype)
+		ncopy = mkcall1(fn, nil, &nodes, addr, sptr, nwid)
+	}
+	ln := append(nodes, ncopy)
+
+	typecheck.Stmts(ln)
+	walkStmtList(ln)
+	init.Append(ln...)
+	return s
+}
+
+// isAppendOfMake reports whether n is of the form append(x , make([]T, y)...).
+// isAppendOfMake assumes n has already been typechecked.
+func isAppendOfMake(n ir.Node) bool {
+	if base.Flag.N != 0 || base.Flag.Cfg.Instrumenting {
+		return false
+	}
+
+	if n.Typecheck() == 0 {
+		base.Fatalf("missing typecheck: %+v", n)
+	}
+
+	if n.Op() != ir.OAPPEND {
+		return false
+	}
+	call := n.(*ir.CallExpr)
+	if !call.IsDDD || len(call.Args) != 2 || call.Args[1].Op() != ir.OMAKESLICE {
+		return false
+	}
+
+	mk := call.Args[1].(*ir.MakeExpr)
+	if mk.Cap != nil {
+		return false
+	}
+
+	// y must be either an integer constant or the largest possible positive value
+	// of variable y needs to fit into an uint.
+
+	// typecheck made sure that constant arguments to make are not negative and fit into an int.
+
+	// The care of overflow of the len argument to make will be handled by an explicit check of int(len) < 0 during runtime.
+	y := mk.Len
+	if !ir.IsConst(y, constant.Int) && y.Type().Size() > types.Types[types.TUINT].Size() {
+		return false
+	}
+
+	return true
+}
+
+// extendSlice rewrites append(l1, make([]T, l2)...) to
+//   init {
+//     if l2 >= 0 { // Empty if block here for more meaningful node.SetLikely(true)
+//     } else {
+//       panicmakeslicelen()
+//     }
+//     s := l1
+//     n := len(s) + l2
+//     // Compare n and s as uint so growslice can panic on overflow of len(s) + l2.
+//     // cap is a positive int and n can become negative when len(s) + l2
+//     // overflows int. Interpreting n when negative as uint makes it larger
+//     // than cap(s). growslice will check the int n arg and panic if n is
+//     // negative. This prevents the overflow from being undetected.
+//     if uint(n) > uint(cap(s)) {
+//       s = growslice(T, s, n)
+//     }
+//     s = s[:n]
+//     lptr := &l1[0]
+//     sptr := &s[0]
+//     if lptr == sptr || !T.HasPointers() {
+//       // growslice did not clear the whole underlying array (or did not get called)
+//       hp := &s[len(l1)]
+//       hn := l2 * sizeof(T)
+//       memclr(hp, hn)
+//     }
+//   }
+//   s
+func extendSlice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
+	// isAppendOfMake made sure all possible positive values of l2 fit into an uint.
+	// The case of l2 overflow when converting from e.g. uint to int is handled by an explicit
+	// check of l2 < 0 at runtime which is generated below.
+	l2 := typecheck.Conv(n.Args[1].(*ir.MakeExpr).Len, types.Types[types.TINT])
+	l2 = typecheck.Expr(l2)
+	n.Args[1] = l2 // walkAppendArgs expects l2 in n.List.Second().
+
+	walkAppendArgs(n, init)
+
+	l1 := n.Args[0]
+	l2 = n.Args[1] // re-read l2, as it may have been updated by walkAppendArgs
+
+	var nodes []ir.Node
+
+	// if l2 >= 0 (likely happens), do nothing
+	nifneg := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGE, l2, ir.NewInt(0)), nil, nil)
+	nifneg.Likely = true
+
+	// else panicmakeslicelen()
+	nifneg.Else = []ir.Node{mkcall("panicmakeslicelen", nil, init)}
+	nodes = append(nodes, nifneg)
+
+	// s := l1
+	s := typecheck.Temp(l1.Type())
+	nodes = append(nodes, ir.NewAssignStmt(base.Pos, s, l1))
+
+	elemtype := s.Type().Elem()
+
+	// n := len(s) + l2
+	nn := typecheck.Temp(types.Types[types.TINT])
+	nodes = append(nodes, ir.NewAssignStmt(base.Pos, nn, ir.NewBinaryExpr(base.Pos, ir.OADD, ir.NewUnaryExpr(base.Pos, ir.OLEN, s), l2)))
+
+	// if uint(n) > uint(cap(s))
+	nuint := typecheck.Conv(nn, types.Types[types.TUINT])
+	capuint := typecheck.Conv(ir.NewUnaryExpr(base.Pos, ir.OCAP, s), types.Types[types.TUINT])
+	nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGT, nuint, capuint), nil, nil)
+
+	// instantiate growslice(typ *type, old []any, newcap int) []any
+	fn := typecheck.LookupRuntime("growslice")
+	fn = typecheck.SubstArgTypes(fn, elemtype, elemtype)
+
+	// s = growslice(T, s, n)
+	nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, s, mkcall1(fn, s.Type(), nif.PtrInit(), reflectdata.TypePtr(elemtype), s, nn))}
+	nodes = append(nodes, nif)
+
+	// s = s[:n]
+	nt := ir.NewSliceExpr(base.Pos, ir.OSLICE, s)
+	nt.SetSliceBounds(nil, nn, nil)
+	nt.SetBounded(true)
+	nodes = append(nodes, ir.NewAssignStmt(base.Pos, s, nt))
+
+	// lptr := &l1[0]
+	l1ptr := typecheck.Temp(l1.Type().Elem().PtrTo())
+	tmp := ir.NewUnaryExpr(base.Pos, ir.OSPTR, l1)
+	nodes = append(nodes, ir.NewAssignStmt(base.Pos, l1ptr, tmp))
+
+	// sptr := &s[0]
+	sptr := typecheck.Temp(elemtype.PtrTo())
+	tmp = ir.NewUnaryExpr(base.Pos, ir.OSPTR, s)
+	nodes = append(nodes, ir.NewAssignStmt(base.Pos, sptr, tmp))
+
+	// hp := &s[len(l1)]
+	ix := ir.NewIndexExpr(base.Pos, s, ir.NewUnaryExpr(base.Pos, ir.OLEN, l1))
+	ix.SetBounded(true)
+	hp := typecheck.ConvNop(typecheck.NodAddr(ix), types.Types[types.TUNSAFEPTR])
+
+	// hn := l2 * sizeof(elem(s))
+	hn := typecheck.Conv(ir.NewBinaryExpr(base.Pos, ir.OMUL, l2, ir.NewInt(elemtype.Width)), types.Types[types.TUINTPTR])
+
+	clrname := "memclrNoHeapPointers"
+	hasPointers := elemtype.HasPointers()
+	if hasPointers {
+		clrname = "memclrHasPointers"
+		ir.CurFunc.SetWBPos(n.Pos())
+	}
+
+	var clr ir.Nodes
+	clrfn := mkcall(clrname, nil, &clr, hp, hn)
+	clr.Append(clrfn)
+
+	if hasPointers {
+		// if l1ptr == sptr
+		nifclr := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OEQ, l1ptr, sptr), nil, nil)
+		nifclr.Body = clr
+		nodes = append(nodes, nifclr)
+	} else {
+		nodes = append(nodes, clr...)
+	}
+
+	typecheck.Stmts(nodes)
+	walkStmtList(nodes)
+	init.Append(nodes...)
+	return s
+}
diff --git a/src/cmd/compile/internal/walk/builtin.go b/src/cmd/compile/internal/walk/builtin.go
new file mode 100644
index 0000000000..61a555b773
--- /dev/null
+++ b/src/cmd/compile/internal/walk/builtin.go
@@ -0,0 +1,699 @@
+// Copyright 2009 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 walk
+
+import (
+	"fmt"
+	"go/constant"
+	"go/token"
+	"strings"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/escape"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/reflectdata"
+	"cmd/compile/internal/typecheck"
+	"cmd/compile/internal/types"
+)
+
+// Rewrite append(src, x, y, z) so that any side effects in
+// x, y, z (including runtime panics) are evaluated in
+// initialization statements before the append.
+// For normal code generation, stop there and leave the
+// rest to cgen_append.
+//
+// For race detector, expand append(src, a [, b]* ) to
+//
+//   init {
+//     s := src
+//     const argc = len(args) - 1
+//     if cap(s) - len(s) < argc {
+//	    s = growslice(s, len(s)+argc)
+//     }
+//     n := len(s)
+//     s = s[:n+argc]
+//     s[n] = a
+//     s[n+1] = b
+//     ...
+//   }
+//   s
+func walkAppend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
+	if !ir.SameSafeExpr(dst, n.Args[0]) {
+		n.Args[0] = safeExpr(n.Args[0], init)
+		n.Args[0] = walkExpr(n.Args[0], init)
+	}
+	walkExprListSafe(n.Args[1:], init)
+
+	nsrc := n.Args[0]
+
+	// walkexprlistsafe will leave OINDEX (s[n]) alone if both s
+	// and n are name or literal, but those may index the slice we're
+	// modifying here. Fix explicitly.
+	// Using cheapexpr also makes sure that the evaluation
+	// of all arguments (and especially any panics) happen
+	// before we begin to modify the slice in a visible way.
+	ls := n.Args[1:]
+	for i, n := range ls {
+		n = cheapExpr(n, init)
+		if !types.Identical(n.Type(), nsrc.Type().Elem()) {
+			n = typecheck.AssignConv(n, nsrc.Type().Elem(), "append")
+			n = walkExpr(n, init)
+		}
+		ls[i] = n
+	}
+
+	argc := len(n.Args) - 1
+	if argc < 1 {
+		return nsrc
+	}
+
+	// General case, with no function calls left as arguments.
+	// Leave for gen, except that instrumentation requires old form.
+	if !base.Flag.Cfg.Instrumenting || base.Flag.CompilingRuntime {
+		return n
+	}
+
+	var l []ir.Node
+
+	ns := typecheck.Temp(nsrc.Type())
+	l = append(l, ir.NewAssignStmt(base.Pos, ns, nsrc)) // s = src
+
+	na := ir.NewInt(int64(argc))                 // const argc
+	nif := ir.NewIfStmt(base.Pos, nil, nil, nil) // if cap(s) - len(s) < argc
+	nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OLT, ir.NewBinaryExpr(base.Pos, ir.OSUB, ir.NewUnaryExpr(base.Pos, ir.OCAP, ns), ir.NewUnaryExpr(base.Pos, ir.OLEN, ns)), na)
+
+	fn := typecheck.LookupRuntime("growslice") //   growslice(<type>, old []T, mincap int) (ret []T)
+	fn = typecheck.SubstArgTypes(fn, ns.Type().Elem(), ns.Type().Elem())
+
+	nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, ns, mkcall1(fn, ns.Type(), nif.PtrInit(), reflectdata.TypePtr(ns.Type().Elem()), ns,
+		ir.NewBinaryExpr(base.Pos, ir.OADD, ir.NewUnaryExpr(base.Pos, ir.OLEN, ns), na)))}
+
+	l = append(l, nif)
+
+	nn := typecheck.Temp(types.Types[types.TINT])
+	l = append(l, ir.NewAssignStmt(base.Pos, nn, ir.NewUnaryExpr(base.Pos, ir.OLEN, ns))) // n = len(s)
+
+	slice := ir.NewSliceExpr(base.Pos, ir.OSLICE, ns) // ...s[:n+argc]
+	slice.SetSliceBounds(nil, ir.NewBinaryExpr(base.Pos, ir.OADD, nn, na), nil)
+	slice.SetBounded(true)
+	l = append(l, ir.NewAssignStmt(base.Pos, ns, slice)) // s = s[:n+argc]
+
+	ls = n.Args[1:]
+	for i, n := range ls {
+		ix := ir.NewIndexExpr(base.Pos, ns, nn) // s[n] ...
+		ix.SetBounded(true)
+		l = append(l, ir.NewAssignStmt(base.Pos, ix, n)) // s[n] = arg
+		if i+1 < len(ls) {
+			l = append(l, ir.NewAssignStmt(base.Pos, nn, ir.NewBinaryExpr(base.Pos, ir.OADD, nn, ir.NewInt(1)))) // n = n + 1
+		}
+	}
+
+	typecheck.Stmts(l)
+	walkStmtList(l)
+	init.Append(l...)
+	return ns
+}
+
+// walkClose walks an OCLOSE node.
+func walkClose(n *ir.UnaryExpr, init *ir.Nodes) ir.Node {
+	// cannot use chanfn - closechan takes any, not chan any
+	fn := typecheck.LookupRuntime("closechan")
+	fn = typecheck.SubstArgTypes(fn, n.X.Type())
+	return mkcall1(fn, nil, init, n.X)
+}
+
+// Lower copy(a, b) to a memmove call or a runtime call.
+//
+// init {
+//   n := len(a)
+//   if n > len(b) { n = len(b) }
+//   if a.ptr != b.ptr { memmove(a.ptr, b.ptr, n*sizeof(elem(a))) }
+// }
+// n;
+//
+// Also works if b is a string.
+//
+func walkCopy(n *ir.BinaryExpr, init *ir.Nodes, runtimecall bool) ir.Node {
+	if n.X.Type().Elem().HasPointers() {
+		ir.CurFunc.SetWBPos(n.Pos())
+		fn := writebarrierfn("typedslicecopy", n.X.Type().Elem(), n.Y.Type().Elem())
+		n.X = cheapExpr(n.X, init)
+		ptrL, lenL := backingArrayPtrLen(n.X)
+		n.Y = cheapExpr(n.Y, init)
+		ptrR, lenR := backingArrayPtrLen(n.Y)
+		return mkcall1(fn, n.Type(), init, reflectdata.TypePtr(n.X.Type().Elem()), ptrL, lenL, ptrR, lenR)
+	}
+
+	if runtimecall {
+		// rely on runtime to instrument:
+		//  copy(n.Left, n.Right)
+		// n.Right can be a slice or string.
+
+		n.X = cheapExpr(n.X, init)
+		ptrL, lenL := backingArrayPtrLen(n.X)
+		n.Y = cheapExpr(n.Y, init)
+		ptrR, lenR := backingArrayPtrLen(n.Y)
+
+		fn := typecheck.LookupRuntime("slicecopy")
+		fn = typecheck.SubstArgTypes(fn, ptrL.Type().Elem(), ptrR.Type().Elem())
+
+		return mkcall1(fn, n.Type(), init, ptrL, lenL, ptrR, lenR, ir.NewInt(n.X.Type().Elem().Width))
+	}
+
+	n.X = walkExpr(n.X, init)
+	n.Y = walkExpr(n.Y, init)
+	nl := typecheck.Temp(n.X.Type())
+	nr := typecheck.Temp(n.Y.Type())
+	var l []ir.Node
+	l = append(l, ir.NewAssignStmt(base.Pos, nl, n.X))
+	l = append(l, ir.NewAssignStmt(base.Pos, nr, n.Y))
+
+	nfrm := ir.NewUnaryExpr(base.Pos, ir.OSPTR, nr)
+	nto := ir.NewUnaryExpr(base.Pos, ir.OSPTR, nl)
+
+	nlen := typecheck.Temp(types.Types[types.TINT])
+
+	// n = len(to)
+	l = append(l, ir.NewAssignStmt(base.Pos, nlen, ir.NewUnaryExpr(base.Pos, ir.OLEN, nl)))
+
+	// if n > len(frm) { n = len(frm) }
+	nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
+
+	nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OGT, nlen, ir.NewUnaryExpr(base.Pos, ir.OLEN, nr))
+	nif.Body.Append(ir.NewAssignStmt(base.Pos, nlen, ir.NewUnaryExpr(base.Pos, ir.OLEN, nr)))
+	l = append(l, nif)
+
+	// if to.ptr != frm.ptr { memmove( ... ) }
+	ne := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.ONE, nto, nfrm), nil, nil)
+	ne.Likely = true
+	l = append(l, ne)
+
+	fn := typecheck.LookupRuntime("memmove")
+	fn = typecheck.SubstArgTypes(fn, nl.Type().Elem(), nl.Type().Elem())
+	nwid := ir.Node(typecheck.Temp(types.Types[types.TUINTPTR]))
+	setwid := ir.NewAssignStmt(base.Pos, nwid, typecheck.Conv(nlen, types.Types[types.TUINTPTR]))
+	ne.Body.Append(setwid)
+	nwid = ir.NewBinaryExpr(base.Pos, ir.OMUL, nwid, ir.NewInt(nl.Type().Elem().Width))
+	call := mkcall1(fn, nil, init, nto, nfrm, nwid)
+	ne.Body.Append(call)
+
+	typecheck.Stmts(l)
+	walkStmtList(l)
+	init.Append(l...)
+	return nlen
+}
+
+// walkDelete walks an ODELETE node.
+func walkDelete(init *ir.Nodes, n *ir.CallExpr) ir.Node {
+	init.Append(n.PtrInit().Take()...)
+	map_ := n.Args[0]
+	key := n.Args[1]
+	map_ = walkExpr(map_, init)
+	key = walkExpr(key, init)
+
+	t := map_.Type()
+	fast := mapfast(t)
+	if fast == mapslow {
+		// order.stmt made sure key is addressable.
+		key = typecheck.NodAddr(key)
+	}
+	return mkcall1(mapfndel(mapdelete[fast], t), nil, init, reflectdata.TypePtr(t), map_, key)
+}
+
+// walkLenCap walks an OLEN or OCAP node.
+func walkLenCap(n *ir.UnaryExpr, init *ir.Nodes) ir.Node {
+	if isRuneCount(n) {
+		// Replace len([]rune(string)) with runtime.countrunes(string).
+		return mkcall("countrunes", n.Type(), init, typecheck.Conv(n.X.(*ir.ConvExpr).X, types.Types[types.TSTRING]))
+	}
+
+	n.X = walkExpr(n.X, init)
+
+	// replace len(*[10]int) with 10.
+	// delayed until now to preserve side effects.
+	t := n.X.Type()
+
+	if t.IsPtr() {
+		t = t.Elem()
+	}
+	if t.IsArray() {
+		safeExpr(n.X, init)
+		con := typecheck.OrigInt(n, t.NumElem())
+		con.SetTypecheck(1)
+		return con
+	}
+	return n
+}
+
+// walkMakeChan walks an OMAKECHAN node.
+func walkMakeChan(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
+	// When size fits into int, use makechan instead of
+	// makechan64, which is faster and shorter on 32 bit platforms.
+	size := n.Len
+	fnname := "makechan64"
+	argtype := types.Types[types.TINT64]
+
+	// Type checking guarantees that TIDEAL size is positive and fits in an int.
+	// The case of size overflow when converting TUINT or TUINTPTR to TINT
+	// will be handled by the negative range checks in makechan during runtime.
+	if size.Type().IsKind(types.TIDEAL) || size.Type().Size() <= types.Types[types.TUINT].Size() {
+		fnname = "makechan"
+		argtype = types.Types[types.TINT]
+	}
+
+	return mkcall1(chanfn(fnname, 1, n.Type()), n.Type(), init, reflectdata.TypePtr(n.Type()), typecheck.Conv(size, argtype))
+}
+
+// walkMakeMap walks an OMAKEMAP node.
+func walkMakeMap(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
+	t := n.Type()
+	hmapType := reflectdata.MapType(t)
+	hint := n.Len
+
+	// var h *hmap
+	var h ir.Node
+	if n.Esc() == ir.EscNone {
+		// Allocate hmap on stack.
+
+		// var hv hmap
+		hv := typecheck.Temp(hmapType)
+		init.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, hv, nil)))
+		// h = &hv
+		h = typecheck.NodAddr(hv)
+
+		// Allocate one bucket pointed to by hmap.buckets on stack if hint
+		// is not larger than BUCKETSIZE. In case hint is larger than
+		// BUCKETSIZE runtime.makemap will allocate the buckets on the heap.
+		// Maximum key and elem size is 128 bytes, larger objects
+		// are stored with an indirection. So max bucket size is 2048+eps.
+		if !ir.IsConst(hint, constant.Int) ||
+			constant.Compare(hint.Val(), token.LEQ, constant.MakeInt64(reflectdata.BUCKETSIZE)) {
+
+			// In case hint is larger than BUCKETSIZE runtime.makemap
+			// will allocate the buckets on the heap, see #20184
+			//
+			// if hint <= BUCKETSIZE {
+			//     var bv bmap
+			//     b = &bv
+			//     h.buckets = b
+			// }
+
+			nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OLE, hint, ir.NewInt(reflectdata.BUCKETSIZE)), nil, nil)
+			nif.Likely = true
+
+			// var bv bmap
+			bv := typecheck.Temp(reflectdata.MapBucketType(t))
+			nif.Body.Append(ir.NewAssignStmt(base.Pos, bv, nil))
+
+			// b = &bv
+			b := typecheck.NodAddr(bv)
+
+			// h.buckets = b
+			bsym := hmapType.Field(5).Sym // hmap.buckets see reflect.go:hmap
+			na := ir.NewAssignStmt(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, h, bsym), b)
+			nif.Body.Append(na)
+			appendWalkStmt(init, nif)
+		}
+	}
+
+	if ir.IsConst(hint, constant.Int) && constant.Compare(hint.Val(), token.LEQ, constant.MakeInt64(reflectdata.BUCKETSIZE)) {
+		// Handling make(map[any]any) and
+		// make(map[any]any, hint) where hint <= BUCKETSIZE
+		// special allows for faster map initialization and
+		// improves binary size by using calls with fewer arguments.
+		// For hint <= BUCKETSIZE overLoadFactor(hint, 0) is false
+		// and no buckets will be allocated by makemap. Therefore,
+		// no buckets need to be allocated in this code path.
+		if n.Esc() == ir.EscNone {
+			// Only need to initialize h.hash0 since
+			// hmap h has been allocated on the stack already.
+			// h.hash0 = fastrand()
+			rand := mkcall("fastrand", types.Types[types.TUINT32], init)
+			hashsym := hmapType.Field(4).Sym // hmap.hash0 see reflect.go:hmap
+			appendWalkStmt(init, ir.NewAssignStmt(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, h, hashsym), rand))
+			return typecheck.ConvNop(h, t)
+		}
+		// Call runtime.makehmap to allocate an
+		// hmap on the heap and initialize hmap's hash0 field.
+		fn := typecheck.LookupRuntime("makemap_small")
+		fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem())
+		return mkcall1(fn, n.Type(), init)
+	}
+
+	if n.Esc() != ir.EscNone {
+		h = typecheck.NodNil()
+	}
+	// Map initialization with a variable or large hint is
+	// more complicated. We therefore generate a call to
+	// runtime.makemap to initialize hmap and allocate the
+	// map buckets.
+
+	// When hint fits into int, use makemap instead of
+	// makemap64, which is faster and shorter on 32 bit platforms.
+	fnname := "makemap64"
+	argtype := types.Types[types.TINT64]
+
+	// Type checking guarantees that TIDEAL hint is positive and fits in an int.
+	// See checkmake call in TMAP case of OMAKE case in OpSwitch in typecheck1 function.
+	// The case of hint overflow when converting TUINT or TUINTPTR to TINT
+	// will be handled by the negative range checks in makemap during runtime.
+	if hint.Type().IsKind(types.TIDEAL) || hint.Type().Size() <= types.Types[types.TUINT].Size() {
+		fnname = "makemap"
+		argtype = types.Types[types.TINT]
+	}
+
+	fn := typecheck.LookupRuntime(fnname)
+	fn = typecheck.SubstArgTypes(fn, hmapType, t.Key(), t.Elem())
+	return mkcall1(fn, n.Type(), init, reflectdata.TypePtr(n.Type()), typecheck.Conv(hint, argtype), h)
+}
+
+// walkMakeSlice walks an OMAKESLICE node.
+func walkMakeSlice(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
+	l := n.Len
+	r := n.Cap
+	if r == nil {
+		r = safeExpr(l, init)
+		l = r
+	}
+	t := n.Type()
+	if t.Elem().NotInHeap() {
+		base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", t.Elem())
+	}
+	if n.Esc() == ir.EscNone {
+		if why := escape.HeapAllocReason(n); why != "" {
+			base.Fatalf("%v has EscNone, but %v", n, why)
+		}
+		// var arr [r]T
+		// n = arr[:l]
+		i := typecheck.IndexConst(r)
+		if i < 0 {
+			base.Fatalf("walkexpr: invalid index %v", r)
+		}
+
+		// cap is constrained to [0,2^31) or [0,2^63) depending on whether
+		// we're in 32-bit or 64-bit systems. So it's safe to do:
+		//
+		// if uint64(len) > cap {
+		//     if len < 0 { panicmakeslicelen() }
+		//     panicmakeslicecap()
+		// }
+		nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGT, typecheck.Conv(l, types.Types[types.TUINT64]), ir.NewInt(i)), nil, nil)
+		niflen := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OLT, l, ir.NewInt(0)), nil, nil)
+		niflen.Body = []ir.Node{mkcall("panicmakeslicelen", nil, init)}
+		nif.Body.Append(niflen, mkcall("panicmakeslicecap", nil, init))
+		init.Append(typecheck.Stmt(nif))
+
+		t = types.NewArray(t.Elem(), i) // [r]T
+		var_ := typecheck.Temp(t)
+		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, nil)) // zero temp
+		r := ir.NewSliceExpr(base.Pos, ir.OSLICE, var_)             // arr[:l]
+		r.SetSliceBounds(nil, l, nil)
+		// The conv is necessary in case n.Type is named.
+		return walkExpr(typecheck.Expr(typecheck.Conv(r, n.Type())), init)
+	}
+
+	// n escapes; set up a call to makeslice.
+	// When len and cap can fit into int, use makeslice instead of
+	// makeslice64, which is faster and shorter on 32 bit platforms.
+
+	len, cap := l, r
+
+	fnname := "makeslice64"
+	argtype := types.Types[types.TINT64]
+
+	// Type checking guarantees that TIDEAL len/cap are positive and fit in an int.
+	// The case of len or cap overflow when converting TUINT or TUINTPTR to TINT
+	// will be handled by the negative range checks in makeslice during runtime.
+	if (len.Type().IsKind(types.TIDEAL) || len.Type().Size() <= types.Types[types.TUINT].Size()) &&
+		(cap.Type().IsKind(types.TIDEAL) || cap.Type().Size() <= types.Types[types.TUINT].Size()) {
+		fnname = "makeslice"
+		argtype = types.Types[types.TINT]
+	}
+
+	m := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
+	m.SetType(t)
+
+	fn := typecheck.LookupRuntime(fnname)
+	m.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, reflectdata.TypePtr(t.Elem()), typecheck.Conv(len, argtype), typecheck.Conv(cap, argtype))
+	m.Ptr.MarkNonNil()
+	m.LenCap = []ir.Node{typecheck.Conv(len, types.Types[types.TINT]), typecheck.Conv(cap, types.Types[types.TINT])}
+	return walkExpr(typecheck.Expr(m), init)
+}
+
+// walkMakeSliceCopy walks an OMAKESLICECOPY node.
+func walkMakeSliceCopy(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
+	if n.Esc() == ir.EscNone {
+		base.Fatalf("OMAKESLICECOPY with EscNone: %v", n)
+	}
+
+	t := n.Type()
+	if t.Elem().NotInHeap() {
+		base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", t.Elem())
+	}
+
+	length := typecheck.Conv(n.Len, types.Types[types.TINT])
+	copylen := ir.NewUnaryExpr(base.Pos, ir.OLEN, n.Cap)
+	copyptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, n.Cap)
+
+	if !t.Elem().HasPointers() && n.Bounded() {
+		// When len(to)==len(from) and elements have no pointers:
+		// replace make+copy with runtime.mallocgc+runtime.memmove.
+
+		// We do not check for overflow of len(to)*elem.Width here
+		// since len(from) is an existing checked slice capacity
+		// with same elem.Width for the from slice.
+		size := ir.NewBinaryExpr(base.Pos, ir.OMUL, typecheck.Conv(length, types.Types[types.TUINTPTR]), typecheck.Conv(ir.NewInt(t.Elem().Width), types.Types[types.TUINTPTR]))
+
+		// instantiate mallocgc(size uintptr, typ *byte, needszero bool) unsafe.Pointer
+		fn := typecheck.LookupRuntime("mallocgc")
+		sh := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
+		sh.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, size, typecheck.NodNil(), ir.NewBool(false))
+		sh.Ptr.MarkNonNil()
+		sh.LenCap = []ir.Node{length, length}
+		sh.SetType(t)
+
+		s := typecheck.Temp(t)
+		r := typecheck.Stmt(ir.NewAssignStmt(base.Pos, s, sh))
+		r = walkExpr(r, init)
+		init.Append(r)
+
+		// instantiate memmove(to *any, frm *any, size uintptr)
+		fn = typecheck.LookupRuntime("memmove")
+		fn = typecheck.SubstArgTypes(fn, t.Elem(), t.Elem())
+		ncopy := mkcall1(fn, nil, init, ir.NewUnaryExpr(base.Pos, ir.OSPTR, s), copyptr, size)
+		init.Append(walkExpr(typecheck.Stmt(ncopy), init))
+
+		return s
+	}
+	// Replace make+copy with runtime.makeslicecopy.
+	// instantiate makeslicecopy(typ *byte, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointer
+	fn := typecheck.LookupRuntime("makeslicecopy")
+	s := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
+	s.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, reflectdata.TypePtr(t.Elem()), length, copylen, typecheck.Conv(copyptr, types.Types[types.TUNSAFEPTR]))
+	s.Ptr.MarkNonNil()
+	s.LenCap = []ir.Node{length, length}
+	s.SetType(t)
+	return walkExpr(typecheck.Expr(s), init)
+}
+
+// walkNew walks an ONEW node.
+func walkNew(n *ir.UnaryExpr, init *ir.Nodes) ir.Node {
+	if n.Type().Elem().NotInHeap() {
+		base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", n.Type().Elem())
+	}
+	if n.Esc() == ir.EscNone {
+		if n.Type().Elem().Width >= ir.MaxImplicitStackVarSize {
+			base.Fatalf("large ONEW with EscNone: %v", n)
+		}
+		r := typecheck.Temp(n.Type().Elem())
+		init.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, r, nil))) // zero temp
+		return typecheck.Expr(typecheck.NodAddr(r))
+	}
+	return callnew(n.Type().Elem())
+}
+
+// generate code for print
+func walkPrint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
+	// Hoist all the argument evaluation up before the lock.
+	walkExprListCheap(nn.Args, init)
+
+	// For println, add " " between elements and "\n" at the end.
+	if nn.Op() == ir.OPRINTN {
+		s := nn.Args
+		t := make([]ir.Node, 0, len(s)*2)
+		for i, n := range s {
+			if i != 0 {
+				t = append(t, ir.NewString(" "))
+			}
+			t = append(t, n)
+		}
+		t = append(t, ir.NewString("\n"))
+		nn.Args.Set(t)
+	}
+
+	// Collapse runs of constant strings.
+	s := nn.Args
+	t := make([]ir.Node, 0, len(s))
+	for i := 0; i < len(s); {
+		var strs []string
+		for i < len(s) && ir.IsConst(s[i], constant.String) {
+			strs = append(strs, ir.StringVal(s[i]))
+			i++
+		}
+		if len(strs) > 0 {
+			t = append(t, ir.NewString(strings.Join(strs, "")))
+		}
+		if i < len(s) {
+			t = append(t, s[i])
+			i++
+		}
+	}
+	nn.Args.Set(t)
+
+	calls := []ir.Node{mkcall("printlock", nil, init)}
+	for i, n := range nn.Args {
+		if n.Op() == ir.OLITERAL {
+			if n.Type() == types.UntypedRune {
+				n = typecheck.DefaultLit(n, types.RuneType)
+			}
+
+			switch n.Val().Kind() {
+			case constant.Int:
+				n = typecheck.DefaultLit(n, types.Types[types.TINT64])
+
+			case constant.Float:
+				n = typecheck.DefaultLit(n, types.Types[types.TFLOAT64])
+			}
+		}
+
+		if n.Op() != ir.OLITERAL && n.Type() != nil && n.Type().Kind() == types.TIDEAL {
+			n = typecheck.DefaultLit(n, types.Types[types.TINT64])
+		}
+		n = typecheck.DefaultLit(n, nil)
+		nn.Args[i] = n
+		if n.Type() == nil || n.Type().Kind() == types.TFORW {
+			continue
+		}
+
+		var on *ir.Name
+		switch n.Type().Kind() {
+		case types.TINTER:
+			if n.Type().IsEmptyInterface() {
+				on = typecheck.LookupRuntime("printeface")
+			} else {
+				on = typecheck.LookupRuntime("printiface")
+			}
+			on = typecheck.SubstArgTypes(on, n.Type()) // any-1
+		case types.TPTR:
+			if n.Type().Elem().NotInHeap() {
+				on = typecheck.LookupRuntime("printuintptr")
+				n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
+				n.SetType(types.Types[types.TUNSAFEPTR])
+				n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
+				n.SetType(types.Types[types.TUINTPTR])
+				break
+			}
+			fallthrough
+		case types.TCHAN, types.TMAP, types.TFUNC, types.TUNSAFEPTR:
+			on = typecheck.LookupRuntime("printpointer")
+			on = typecheck.SubstArgTypes(on, n.Type()) // any-1
+		case types.TSLICE:
+			on = typecheck.LookupRuntime("printslice")
+			on = typecheck.SubstArgTypes(on, n.Type()) // any-1
+		case types.TUINT, types.TUINT8, types.TUINT16, types.TUINT32, types.TUINT64, types.TUINTPTR:
+			if types.IsRuntimePkg(n.Type().Sym().Pkg) && n.Type().Sym().Name == "hex" {
+				on = typecheck.LookupRuntime("printhex")
+			} else {
+				on = typecheck.LookupRuntime("printuint")
+			}
+		case types.TINT, types.TINT8, types.TINT16, types.TINT32, types.TINT64:
+			on = typecheck.LookupRuntime("printint")
+		case types.TFLOAT32, types.TFLOAT64:
+			on = typecheck.LookupRuntime("printfloat")
+		case types.TCOMPLEX64, types.TCOMPLEX128:
+			on = typecheck.LookupRuntime("printcomplex")
+		case types.TBOOL:
+			on = typecheck.LookupRuntime("printbool")
+		case types.TSTRING:
+			cs := ""
+			if ir.IsConst(n, constant.String) {
+				cs = ir.StringVal(n)
+			}
+			switch cs {
+			case " ":
+				on = typecheck.LookupRuntime("printsp")
+			case "\n":
+				on = typecheck.LookupRuntime("printnl")
+			default:
+				on = typecheck.LookupRuntime("printstring")
+			}
+		default:
+			badtype(ir.OPRINT, n.Type(), nil)
+			continue
+		}
+
+		r := ir.NewCallExpr(base.Pos, ir.OCALL, on, nil)
+		if params := on.Type().Params().FieldSlice(); len(params) > 0 {
+			t := params[0].Type
+			if !types.Identical(t, n.Type()) {
+				n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
+				n.SetType(t)
+			}
+			r.Args.Append(n)
+		}
+		calls = append(calls, r)
+	}
+
+	calls = append(calls, mkcall("printunlock", nil, init))
+
+	typecheck.Stmts(calls)
+	walkExprList(calls, init)
+
+	r := ir.NewBlockStmt(base.Pos, nil)
+	r.List.Set(calls)
+	return walkStmt(typecheck.Stmt(r))
+}
+
+func badtype(op ir.Op, tl, tr *types.Type) {
+	var s string
+	if tl != nil {
+		s += fmt.Sprintf("\n\t%v", tl)
+	}
+	if tr != nil {
+		s += fmt.Sprintf("\n\t%v", tr)
+	}
+
+	// common mistake: *struct and *interface.
+	if tl != nil && tr != nil && tl.IsPtr() && tr.IsPtr() {
+		if tl.Elem().IsStruct() && tr.Elem().IsInterface() {
+			s += "\n\t(*struct vs *interface)"
+		} else if tl.Elem().IsInterface() && tr.Elem().IsStruct() {
+			s += "\n\t(*interface vs *struct)"
+		}
+	}
+
+	base.Errorf("illegal types for operand: %v%s", op, s)
+}
+
+func callnew(t *types.Type) ir.Node {
+	types.CalcSize(t)
+	n := ir.NewUnaryExpr(base.Pos, ir.ONEWOBJ, reflectdata.TypePtr(t))
+	n.SetType(types.NewPtr(t))
+	n.SetTypecheck(1)
+	n.MarkNonNil()
+	return n
+}
+
+func writebarrierfn(name string, l *types.Type, r *types.Type) ir.Node {
+	fn := typecheck.LookupRuntime(name)
+	fn = typecheck.SubstArgTypes(fn, l, r)
+	return fn
+}
+
+// isRuneCount reports whether n is of the form len([]rune(string)).
+// These are optimized into a call to runtime.countrunes.
+func isRuneCount(n ir.Node) bool {
+	return base.Flag.N == 0 && !base.Flag.Cfg.Instrumenting && n.Op() == ir.OLEN && n.(*ir.UnaryExpr).X.Op() == ir.OSTR2RUNES
+}
diff --git a/src/cmd/compile/internal/walk/closure.go b/src/cmd/compile/internal/walk/closure.go
index 545c762ac7..30f86f0965 100644
--- a/src/cmd/compile/internal/walk/closure.go
+++ b/src/cmd/compile/internal/walk/closure.go
@@ -115,7 +115,7 @@ func Closure(fn *ir.Func) {
 	base.Pos = lno
 }
 
-func walkclosure(clo *ir.ClosureExpr, init *ir.Nodes) ir.Node {
+func walkClosure(clo *ir.ClosureExpr, init *ir.Nodes) ir.Node {
 	fn := clo.Func
 
 	// If no closure vars, don't bother wrapping.
@@ -148,10 +148,10 @@ func walkclosure(clo *ir.ClosureExpr, init *ir.Nodes) ir.Node {
 		clo.Prealloc = nil
 	}
 
-	return walkexpr(cfn, init)
+	return walkExpr(cfn, init)
 }
 
-func walkpartialcall(n *ir.CallPartExpr, init *ir.Nodes) ir.Node {
+func walkCallPart(n *ir.CallPartExpr, init *ir.Nodes) ir.Node {
 	// Create closure in the form of a composite literal.
 	// For x.M with receiver (x) type T, the generated code looks like:
 	//
@@ -162,8 +162,8 @@ func walkpartialcall(n *ir.CallPartExpr, init *ir.Nodes) ir.Node {
 	if n.X.Type().IsInterface() {
 		// Trigger panic for method on nil interface now.
 		// Otherwise it happens in the wrapper and is confusing.
-		n.X = cheapexpr(n.X, init)
-		n.X = walkexpr(n.X, nil)
+		n.X = cheapExpr(n.X, init)
+		n.X = walkExpr(n.X, nil)
 
 		tab := typecheck.Expr(ir.NewUnaryExpr(base.Pos, ir.OITAB, n.X))
 
@@ -193,5 +193,5 @@ func walkpartialcall(n *ir.CallPartExpr, init *ir.Nodes) ir.Node {
 		n.Prealloc = nil
 	}
 
-	return walkexpr(cfn, init)
+	return walkExpr(cfn, init)
 }
diff --git a/src/cmd/compile/internal/walk/compare.go b/src/cmd/compile/internal/walk/compare.go
new file mode 100644
index 0000000000..b1ab42782b
--- /dev/null
+++ b/src/cmd/compile/internal/walk/compare.go
@@ -0,0 +1,507 @@
+// Copyright 2009 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 walk
+
+import (
+	"encoding/binary"
+	"go/constant"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/reflectdata"
+	"cmd/compile/internal/ssagen"
+	"cmd/compile/internal/typecheck"
+	"cmd/compile/internal/types"
+	"cmd/internal/sys"
+)
+
+// The result of walkCompare MUST be assigned back to n, e.g.
+// 	n.Left = walkCompare(n.Left, init)
+func walkCompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
+	if n.X.Type().IsInterface() && n.Y.Type().IsInterface() && n.X.Op() != ir.ONIL && n.Y.Op() != ir.ONIL {
+		return walkCompareInterface(n, init)
+	}
+
+	if n.X.Type().IsString() && n.Y.Type().IsString() {
+		return walkCompareString(n, init)
+	}
+
+	n.X = walkExpr(n.X, init)
+	n.Y = walkExpr(n.Y, init)
+
+	// Given mixed interface/concrete comparison,
+	// rewrite into types-equal && data-equal.
+	// This is efficient, avoids allocations, and avoids runtime calls.
+	if n.X.Type().IsInterface() != n.Y.Type().IsInterface() {
+		// Preserve side-effects in case of short-circuiting; see #32187.
+		l := cheapExpr(n.X, init)
+		r := cheapExpr(n.Y, init)
+		// Swap so that l is the interface value and r is the concrete value.
+		if n.Y.Type().IsInterface() {
+			l, r = r, l
+		}
+
+		// Handle both == and !=.
+		eq := n.Op()
+		andor := ir.OOROR
+		if eq == ir.OEQ {
+			andor = ir.OANDAND
+		}
+		// Check for types equal.
+		// For empty interface, this is:
+		//   l.tab == type(r)
+		// For non-empty interface, this is:
+		//   l.tab != nil && l.tab._type == type(r)
+		var eqtype ir.Node
+		tab := ir.NewUnaryExpr(base.Pos, ir.OITAB, l)
+		rtyp := reflectdata.TypePtr(r.Type())
+		if l.Type().IsEmptyInterface() {
+			tab.SetType(types.NewPtr(types.Types[types.TUINT8]))
+			tab.SetTypecheck(1)
+			eqtype = ir.NewBinaryExpr(base.Pos, eq, tab, rtyp)
+		} else {
+			nonnil := ir.NewBinaryExpr(base.Pos, brcom(eq), typecheck.NodNil(), tab)
+			match := ir.NewBinaryExpr(base.Pos, eq, itabType(tab), rtyp)
+			eqtype = ir.NewLogicalExpr(base.Pos, andor, nonnil, match)
+		}
+		// Check for data equal.
+		eqdata := ir.NewBinaryExpr(base.Pos, eq, ifaceData(n.Pos(), l, r.Type()), r)
+		// Put it all together.
+		expr := ir.NewLogicalExpr(base.Pos, andor, eqtype, eqdata)
+		return finishCompare(n, expr, init)
+	}
+
+	// Must be comparison of array or struct.
+	// Otherwise back end handles it.
+	// While we're here, decide whether to
+	// inline or call an eq alg.
+	t := n.X.Type()
+	var inline bool
+
+	maxcmpsize := int64(4)
+	unalignedLoad := canMergeLoads()
+	if unalignedLoad {
+		// Keep this low enough to generate less code than a function call.
+		maxcmpsize = 2 * int64(ssagen.Arch.LinkArch.RegSize)
+	}
+
+	switch t.Kind() {
+	default:
+		if base.Debug.Libfuzzer != 0 && t.IsInteger() {
+			n.X = cheapExpr(n.X, init)
+			n.Y = cheapExpr(n.Y, init)
+
+			// If exactly one comparison operand is
+			// constant, invoke the constcmp functions
+			// instead, and arrange for the constant
+			// operand to be the first argument.
+			l, r := n.X, n.Y
+			if r.Op() == ir.OLITERAL {
+				l, r = r, l
+			}
+			constcmp := l.Op() == ir.OLITERAL && r.Op() != ir.OLITERAL
+
+			var fn string
+			var paramType *types.Type
+			switch t.Size() {
+			case 1:
+				fn = "libfuzzerTraceCmp1"
+				if constcmp {
+					fn = "libfuzzerTraceConstCmp1"
+				}
+				paramType = types.Types[types.TUINT8]
+			case 2:
+				fn = "libfuzzerTraceCmp2"
+				if constcmp {
+					fn = "libfuzzerTraceConstCmp2"
+				}
+				paramType = types.Types[types.TUINT16]
+			case 4:
+				fn = "libfuzzerTraceCmp4"
+				if constcmp {
+					fn = "libfuzzerTraceConstCmp4"
+				}
+				paramType = types.Types[types.TUINT32]
+			case 8:
+				fn = "libfuzzerTraceCmp8"
+				if constcmp {
+					fn = "libfuzzerTraceConstCmp8"
+				}
+				paramType = types.Types[types.TUINT64]
+			default:
+				base.Fatalf("unexpected integer size %d for %v", t.Size(), t)
+			}
+			init.Append(mkcall(fn, nil, init, tracecmpArg(l, paramType, init), tracecmpArg(r, paramType, init)))
+		}
+		return n
+	case types.TARRAY:
+		// We can compare several elements at once with 2/4/8 byte integer compares
+		inline = t.NumElem() <= 1 || (types.IsSimple[t.Elem().Kind()] && (t.NumElem() <= 4 || t.Elem().Width*t.NumElem() <= maxcmpsize))
+	case types.TSTRUCT:
+		inline = t.NumComponents(types.IgnoreBlankFields) <= 4
+	}
+
+	cmpl := n.X
+	for cmpl != nil && cmpl.Op() == ir.OCONVNOP {
+		cmpl = cmpl.(*ir.ConvExpr).X
+	}
+	cmpr := n.Y
+	for cmpr != nil && cmpr.Op() == ir.OCONVNOP {
+		cmpr = cmpr.(*ir.ConvExpr).X
+	}
+
+	// Chose not to inline. Call equality function directly.
+	if !inline {
+		// eq algs take pointers; cmpl and cmpr must be addressable
+		if !ir.IsAssignable(cmpl) || !ir.IsAssignable(cmpr) {
+			base.Fatalf("arguments of comparison must be lvalues - %v %v", cmpl, cmpr)
+		}
+
+		fn, needsize := eqFor(t)
+		call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
+		call.Args.Append(typecheck.NodAddr(cmpl))
+		call.Args.Append(typecheck.NodAddr(cmpr))
+		if needsize {
+			call.Args.Append(ir.NewInt(t.Width))
+		}
+		res := ir.Node(call)
+		if n.Op() != ir.OEQ {
+			res = ir.NewUnaryExpr(base.Pos, ir.ONOT, res)
+		}
+		return finishCompare(n, res, init)
+	}
+
+	// inline: build boolean expression comparing element by element
+	andor := ir.OANDAND
+	if n.Op() == ir.ONE {
+		andor = ir.OOROR
+	}
+	var expr ir.Node
+	compare := func(el, er ir.Node) {
+		a := ir.NewBinaryExpr(base.Pos, n.Op(), el, er)
+		if expr == nil {
+			expr = a
+		} else {
+			expr = ir.NewLogicalExpr(base.Pos, andor, expr, a)
+		}
+	}
+	cmpl = safeExpr(cmpl, init)
+	cmpr = safeExpr(cmpr, init)
+	if t.IsStruct() {
+		for _, f := range t.Fields().Slice() {
+			sym := f.Sym
+			if sym.IsBlank() {
+				continue
+			}
+			compare(
+				ir.NewSelectorExpr(base.Pos, ir.OXDOT, cmpl, sym),
+				ir.NewSelectorExpr(base.Pos, ir.OXDOT, cmpr, sym),
+			)
+		}
+	} else {
+		step := int64(1)
+		remains := t.NumElem() * t.Elem().Width
+		combine64bit := unalignedLoad && types.RegSize == 8 && t.Elem().Width <= 4 && t.Elem().IsInteger()
+		combine32bit := unalignedLoad && t.Elem().Width <= 2 && t.Elem().IsInteger()
+		combine16bit := unalignedLoad && t.Elem().Width == 1 && t.Elem().IsInteger()
+		for i := int64(0); remains > 0; {
+			var convType *types.Type
+			switch {
+			case remains >= 8 && combine64bit:
+				convType = types.Types[types.TINT64]
+				step = 8 / t.Elem().Width
+			case remains >= 4 && combine32bit:
+				convType = types.Types[types.TUINT32]
+				step = 4 / t.Elem().Width
+			case remains >= 2 && combine16bit:
+				convType = types.Types[types.TUINT16]
+				step = 2 / t.Elem().Width
+			default:
+				step = 1
+			}
+			if step == 1 {
+				compare(
+					ir.NewIndexExpr(base.Pos, cmpl, ir.NewInt(i)),
+					ir.NewIndexExpr(base.Pos, cmpr, ir.NewInt(i)),
+				)
+				i++
+				remains -= t.Elem().Width
+			} else {
+				elemType := t.Elem().ToUnsigned()
+				cmplw := ir.Node(ir.NewIndexExpr(base.Pos, cmpl, ir.NewInt(i)))
+				cmplw = typecheck.Conv(cmplw, elemType) // convert to unsigned
+				cmplw = typecheck.Conv(cmplw, convType) // widen
+				cmprw := ir.Node(ir.NewIndexExpr(base.Pos, cmpr, ir.NewInt(i)))
+				cmprw = typecheck.Conv(cmprw, elemType)
+				cmprw = typecheck.Conv(cmprw, convType)
+				// For code like this:  uint32(s[0]) | uint32(s[1])<<8 | uint32(s[2])<<16 ...
+				// ssa will generate a single large load.
+				for offset := int64(1); offset < step; offset++ {
+					lb := ir.Node(ir.NewIndexExpr(base.Pos, cmpl, ir.NewInt(i+offset)))
+					lb = typecheck.Conv(lb, elemType)
+					lb = typecheck.Conv(lb, convType)
+					lb = ir.NewBinaryExpr(base.Pos, ir.OLSH, lb, ir.NewInt(8*t.Elem().Width*offset))
+					cmplw = ir.NewBinaryExpr(base.Pos, ir.OOR, cmplw, lb)
+					rb := ir.Node(ir.NewIndexExpr(base.Pos, cmpr, ir.NewInt(i+offset)))
+					rb = typecheck.Conv(rb, elemType)
+					rb = typecheck.Conv(rb, convType)
+					rb = ir.NewBinaryExpr(base.Pos, ir.OLSH, rb, ir.NewInt(8*t.Elem().Width*offset))
+					cmprw = ir.NewBinaryExpr(base.Pos, ir.OOR, cmprw, rb)
+				}
+				compare(cmplw, cmprw)
+				i += step
+				remains -= step * t.Elem().Width
+			}
+		}
+	}
+	if expr == nil {
+		expr = ir.NewBool(n.Op() == ir.OEQ)
+		// We still need to use cmpl and cmpr, in case they contain
+		// an expression which might panic. See issue 23837.
+		t := typecheck.Temp(cmpl.Type())
+		a1 := typecheck.Stmt(ir.NewAssignStmt(base.Pos, t, cmpl))
+		a2 := typecheck.Stmt(ir.NewAssignStmt(base.Pos, t, cmpr))
+		init.Append(a1, a2)
+	}
+	return finishCompare(n, expr, init)
+}
+
+func walkCompareInterface(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
+	n.Y = cheapExpr(n.Y, init)
+	n.X = cheapExpr(n.X, init)
+	eqtab, eqdata := reflectdata.EqInterface(n.X, n.Y)
+	var cmp ir.Node
+	if n.Op() == ir.OEQ {
+		cmp = ir.NewLogicalExpr(base.Pos, ir.OANDAND, eqtab, eqdata)
+	} else {
+		eqtab.SetOp(ir.ONE)
+		cmp = ir.NewLogicalExpr(base.Pos, ir.OOROR, eqtab, ir.NewUnaryExpr(base.Pos, ir.ONOT, eqdata))
+	}
+	return finishCompare(n, cmp, init)
+}
+
+func walkCompareString(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
+	// Rewrite comparisons to short constant strings as length+byte-wise comparisons.
+	var cs, ncs ir.Node // const string, non-const string
+	switch {
+	case ir.IsConst(n.X, constant.String) && ir.IsConst(n.Y, constant.String):
+		// ignore; will be constant evaluated
+	case ir.IsConst(n.X, constant.String):
+		cs = n.X
+		ncs = n.Y
+	case ir.IsConst(n.Y, constant.String):
+		cs = n.Y
+		ncs = n.X
+	}
+	if cs != nil {
+		cmp := n.Op()
+		// Our comparison below assumes that the non-constant string
+		// is on the left hand side, so rewrite "" cmp x to x cmp "".
+		// See issue 24817.
+		if ir.IsConst(n.X, constant.String) {
+			cmp = brrev(cmp)
+		}
+
+		// maxRewriteLen was chosen empirically.
+		// It is the value that minimizes cmd/go file size
+		// across most architectures.
+		// See the commit description for CL 26758 for details.
+		maxRewriteLen := 6
+		// Some architectures can load unaligned byte sequence as 1 word.
+		// So we can cover longer strings with the same amount of code.
+		canCombineLoads := canMergeLoads()
+		combine64bit := false
+		if canCombineLoads {
+			// Keep this low enough to generate less code than a function call.
+			maxRewriteLen = 2 * ssagen.Arch.LinkArch.RegSize
+			combine64bit = ssagen.Arch.LinkArch.RegSize >= 8
+		}
+
+		var and ir.Op
+		switch cmp {
+		case ir.OEQ:
+			and = ir.OANDAND
+		case ir.ONE:
+			and = ir.OOROR
+		default:
+			// Don't do byte-wise comparisons for <, <=, etc.
+			// They're fairly complicated.
+			// Length-only checks are ok, though.
+			maxRewriteLen = 0
+		}
+		if s := ir.StringVal(cs); len(s) <= maxRewriteLen {
+			if len(s) > 0 {
+				ncs = safeExpr(ncs, init)
+			}
+			r := ir.Node(ir.NewBinaryExpr(base.Pos, cmp, ir.NewUnaryExpr(base.Pos, ir.OLEN, ncs), ir.NewInt(int64(len(s)))))
+			remains := len(s)
+			for i := 0; remains > 0; {
+				if remains == 1 || !canCombineLoads {
+					cb := ir.NewInt(int64(s[i]))
+					ncb := ir.NewIndexExpr(base.Pos, ncs, ir.NewInt(int64(i)))
+					r = ir.NewLogicalExpr(base.Pos, and, r, ir.NewBinaryExpr(base.Pos, cmp, ncb, cb))
+					remains--
+					i++
+					continue
+				}
+				var step int
+				var convType *types.Type
+				switch {
+				case remains >= 8 && combine64bit:
+					convType = types.Types[types.TINT64]
+					step = 8
+				case remains >= 4:
+					convType = types.Types[types.TUINT32]
+					step = 4
+				case remains >= 2:
+					convType = types.Types[types.TUINT16]
+					step = 2
+				}
+				ncsubstr := typecheck.Conv(ir.NewIndexExpr(base.Pos, ncs, ir.NewInt(int64(i))), convType)
+				csubstr := int64(s[i])
+				// Calculate large constant from bytes as sequence of shifts and ors.
+				// Like this:  uint32(s[0]) | uint32(s[1])<<8 | uint32(s[2])<<16 ...
+				// ssa will combine this into a single large load.
+				for offset := 1; offset < step; offset++ {
+					b := typecheck.Conv(ir.NewIndexExpr(base.Pos, ncs, ir.NewInt(int64(i+offset))), convType)
+					b = ir.NewBinaryExpr(base.Pos, ir.OLSH, b, ir.NewInt(int64(8*offset)))
+					ncsubstr = ir.NewBinaryExpr(base.Pos, ir.OOR, ncsubstr, b)
+					csubstr |= int64(s[i+offset]) << uint8(8*offset)
+				}
+				csubstrPart := ir.NewInt(csubstr)
+				// Compare "step" bytes as once
+				r = ir.NewLogicalExpr(base.Pos, and, r, ir.NewBinaryExpr(base.Pos, cmp, csubstrPart, ncsubstr))
+				remains -= step
+				i += step
+			}
+			return finishCompare(n, r, init)
+		}
+	}
+
+	var r ir.Node
+	if n.Op() == ir.OEQ || n.Op() == ir.ONE {
+		// prepare for rewrite below
+		n.X = cheapExpr(n.X, init)
+		n.Y = cheapExpr(n.Y, init)
+		eqlen, eqmem := reflectdata.EqString(n.X, n.Y)
+		// quick check of len before full compare for == or !=.
+		// memequal then tests equality up to length len.
+		if n.Op() == ir.OEQ {
+			// len(left) == len(right) && memequal(left, right, len)
+			r = ir.NewLogicalExpr(base.Pos, ir.OANDAND, eqlen, eqmem)
+		} else {
+			// len(left) != len(right) || !memequal(left, right, len)
+			eqlen.SetOp(ir.ONE)
+			r = ir.NewLogicalExpr(base.Pos, ir.OOROR, eqlen, ir.NewUnaryExpr(base.Pos, ir.ONOT, eqmem))
+		}
+	} else {
+		// sys_cmpstring(s1, s2) :: 0
+		r = mkcall("cmpstring", types.Types[types.TINT], init, typecheck.Conv(n.X, types.Types[types.TSTRING]), typecheck.Conv(n.Y, types.Types[types.TSTRING]))
+		r = ir.NewBinaryExpr(base.Pos, n.Op(), r, ir.NewInt(0))
+	}
+
+	return finishCompare(n, r, init)
+}
+
+// The result of finishCompare MUST be assigned back to n, e.g.
+// 	n.Left = finishCompare(n.Left, x, r, init)
+func finishCompare(n *ir.BinaryExpr, r ir.Node, init *ir.Nodes) ir.Node {
+	r = typecheck.Expr(r)
+	r = typecheck.Conv(r, n.Type())
+	r = walkExpr(r, init)
+	return r
+}
+
+func eqFor(t *types.Type) (n ir.Node, needsize bool) {
+	// Should only arrive here with large memory or
+	// a struct/array containing a non-memory field/element.
+	// Small memory is handled inline, and single non-memory
+	// is handled by walkcompare.
+	switch a, _ := types.AlgType(t); a {
+	case types.AMEM:
+		n := typecheck.LookupRuntime("memequal")
+		n = typecheck.SubstArgTypes(n, t, t)
+		return n, true
+	case types.ASPECIAL:
+		sym := reflectdata.TypeSymPrefix(".eq", t)
+		n := typecheck.NewName(sym)
+		ir.MarkFunc(n)
+		n.SetType(typecheck.NewFuncType(nil, []*ir.Field{
+			ir.NewField(base.Pos, nil, nil, types.NewPtr(t)),
+			ir.NewField(base.Pos, nil, nil, types.NewPtr(t)),
+		}, []*ir.Field{
+			ir.NewField(base.Pos, nil, nil, types.Types[types.TBOOL]),
+		}))
+		return n, false
+	}
+	base.Fatalf("eqfor %v", t)
+	return nil, false
+}
+
+// brcom returns !(op).
+// For example, brcom(==) is !=.
+func brcom(op ir.Op) ir.Op {
+	switch op {
+	case ir.OEQ:
+		return ir.ONE
+	case ir.ONE:
+		return ir.OEQ
+	case ir.OLT:
+		return ir.OGE
+	case ir.OGT:
+		return ir.OLE
+	case ir.OLE:
+		return ir.OGT
+	case ir.OGE:
+		return ir.OLT
+	}
+	base.Fatalf("brcom: no com for %v\n", op)
+	return op
+}
+
+// brrev returns reverse(op).
+// For example, Brrev(<) is >.
+func brrev(op ir.Op) ir.Op {
+	switch op {
+	case ir.OEQ:
+		return ir.OEQ
+	case ir.ONE:
+		return ir.ONE
+	case ir.OLT:
+		return ir.OGT
+	case ir.OGT:
+		return ir.OLT
+	case ir.OLE:
+		return ir.OGE
+	case ir.OGE:
+		return ir.OLE
+	}
+	base.Fatalf("brrev: no rev for %v\n", op)
+	return op
+}
+
+func tracecmpArg(n ir.Node, t *types.Type, init *ir.Nodes) ir.Node {
+	// Ugly hack to avoid "constant -1 overflows uintptr" errors, etc.
+	if n.Op() == ir.OLITERAL && n.Type().IsSigned() && ir.Int64Val(n) < 0 {
+		n = copyExpr(n, n.Type(), init)
+	}
+
+	return typecheck.Conv(n, t)
+}
+
+// canMergeLoads reports whether the backend optimization passes for
+// the current architecture can combine adjacent loads into a single
+// larger, possibly unaligned, load. Note that currently the
+// optimizations must be able to handle little endian byte order.
+func canMergeLoads() bool {
+	switch ssagen.Arch.LinkArch.Family {
+	case sys.ARM64, sys.AMD64, sys.I386, sys.S390X:
+		return true
+	case sys.PPC64:
+		// Load combining only supported on ppc64le.
+		return ssagen.Arch.LinkArch.ByteOrder == binary.LittleEndian
+	}
+	return false
+}
diff --git a/src/cmd/compile/internal/walk/sinit.go b/src/cmd/compile/internal/walk/complit.go
similarity index 96%
rename from src/cmd/compile/internal/walk/sinit.go
rename to src/cmd/compile/internal/walk/complit.go
index dbb17dfe50..6fbbee9284 100644
--- a/src/cmd/compile/internal/walk/sinit.go
+++ b/src/cmd/compile/internal/walk/complit.go
@@ -7,6 +7,7 @@ package walk
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/staticdata"
 	"cmd/compile/internal/staticinit"
 	"cmd/compile/internal/typecheck"
@@ -14,6 +15,22 @@ import (
 	"cmd/internal/obj"
 )
 
+// walkCompLit walks a composite literal node:
+// OARRAYLIT, OSLICELIT, OMAPLIT, OSTRUCTLIT (all CompLitExpr), or OPTRLIT (AddrExpr).
+func walkCompLit(n ir.Node, init *ir.Nodes) ir.Node {
+	if isStaticCompositeLiteral(n) && !ssagen.TypeOK(n.Type()) {
+		n := n.(*ir.CompLitExpr) // not OPTRLIT
+		// n can be directly represented in the read-only data section.
+		// Make direct reference to the static data. See issue 12841.
+		vstat := readonlystaticname(n.Type())
+		fixedlit(inInitFunction, initKindStatic, n, vstat, init)
+		return typecheck.Expr(vstat)
+	}
+	var_ := typecheck.Temp(n.Type())
+	anylit(n, var_, init)
+	return var_
+}
+
 // initContext is the context in which static data is populated.
 // It is either in an init function or in any other function.
 // Static data populated in an init function will be written either
@@ -245,7 +262,7 @@ func fixedlit(ctxt initContext, kind initKind, n *ir.CompLitExpr, var_ ir.Node,
 			genAsStatic(as)
 		case initKindDynamic, initKindLocalCode:
 			a = orderStmtInPlace(as, map[string][]*ir.Name{})
-			a = walkstmt(a)
+			a = walkStmt(a)
 			init.Append(a)
 		default:
 			base.Fatalf("fixedlit: bad kind %d", kind)
@@ -403,7 +420,7 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 		ir.SetPos(value)
 		as := typecheck.Stmt(ir.NewAssignStmt(base.Pos, a, value))
 		as = orderStmtInPlace(as, map[string][]*ir.Name{})
-		as = walkstmt(as)
+		as = walkStmt(as)
 		init.Append(as)
 	}
 
@@ -412,7 +429,7 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 
 	a = typecheck.Stmt(a)
 	a = orderStmtInPlace(a, map[string][]*ir.Name{})
-	a = walkstmt(a)
+	a = walkStmt(a)
 	init.Append(a)
 }
 
diff --git a/src/cmd/compile/internal/walk/convert.go b/src/cmd/compile/internal/walk/convert.go
new file mode 100644
index 0000000000..21426c9817
--- /dev/null
+++ b/src/cmd/compile/internal/walk/convert.go
@@ -0,0 +1,502 @@
+// Copyright 2009 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 walk
+
+import (
+	"encoding/binary"
+	"go/constant"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/reflectdata"
+	"cmd/compile/internal/ssagen"
+	"cmd/compile/internal/typecheck"
+	"cmd/compile/internal/types"
+	"cmd/internal/sys"
+)
+
+// walkConv walks an OCONV or OCONVNOP (but not OCONVIFACE) node.
+func walkConv(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
+	n.X = walkExpr(n.X, init)
+	if n.Op() == ir.OCONVNOP && n.Type() == n.X.Type() {
+		return n.X
+	}
+	if n.Op() == ir.OCONVNOP && ir.ShouldCheckPtr(ir.CurFunc, 1) {
+		if n.Type().IsPtr() && n.X.Type().IsUnsafePtr() { // unsafe.Pointer to *T
+			return walkCheckPtrAlignment(n, init, nil)
+		}
+		if n.Type().IsUnsafePtr() && n.X.Type().IsUintptr() { // uintptr to unsafe.Pointer
+			return walkCheckPtrArithmetic(n, init)
+		}
+	}
+	param, result := rtconvfn(n.X.Type(), n.Type())
+	if param == types.Txxx {
+		return n
+	}
+	fn := types.BasicTypeNames[param] + "to" + types.BasicTypeNames[result]
+	return typecheck.Conv(mkcall(fn, types.Types[result], init, typecheck.Conv(n.X, types.Types[param])), n.Type())
+}
+
+// walkConvInterface walks an OCONVIFACE node.
+func walkConvInterface(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
+	n.X = walkExpr(n.X, init)
+
+	fromType := n.X.Type()
+	toType := n.Type()
+
+	if !fromType.IsInterface() && !ir.IsBlank(ir.CurFunc.Nname) { // skip unnamed functions (func _())
+		reflectdata.MarkTypeUsedInInterface(fromType, ir.CurFunc.LSym)
+	}
+
+	// typeword generates the type word of the interface value.
+	typeword := func() ir.Node {
+		if toType.IsEmptyInterface() {
+			return reflectdata.TypePtr(fromType)
+		}
+		return reflectdata.ITabAddr(fromType, toType)
+	}
+
+	// Optimize convT2E or convT2I as a two-word copy when T is pointer-shaped.
+	if types.IsDirectIface(fromType) {
+		l := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), n.X)
+		l.SetType(toType)
+		l.SetTypecheck(n.Typecheck())
+		return l
+	}
+
+	if ir.Names.Staticuint64s == nil {
+		ir.Names.Staticuint64s = typecheck.NewName(ir.Pkgs.Runtime.Lookup("staticuint64s"))
+		ir.Names.Staticuint64s.Class_ = ir.PEXTERN
+		// The actual type is [256]uint64, but we use [256*8]uint8 so we can address
+		// individual bytes.
+		ir.Names.Staticuint64s.SetType(types.NewArray(types.Types[types.TUINT8], 256*8))
+		ir.Names.Zerobase = typecheck.NewName(ir.Pkgs.Runtime.Lookup("zerobase"))
+		ir.Names.Zerobase.Class_ = ir.PEXTERN
+		ir.Names.Zerobase.SetType(types.Types[types.TUINTPTR])
+	}
+
+	// Optimize convT2{E,I} for many cases in which T is not pointer-shaped,
+	// by using an existing addressable value identical to n.Left
+	// or creating one on the stack.
+	var value ir.Node
+	switch {
+	case fromType.Size() == 0:
+		// n.Left is zero-sized. Use zerobase.
+		cheapExpr(n.X, init) // Evaluate n.Left for side-effects. See issue 19246.
+		value = ir.Names.Zerobase
+	case fromType.IsBoolean() || (fromType.Size() == 1 && fromType.IsInteger()):
+		// n.Left is a bool/byte. Use staticuint64s[n.Left * 8] on little-endian
+		// and staticuint64s[n.Left * 8 + 7] on big-endian.
+		n.X = cheapExpr(n.X, init)
+		// byteindex widens n.Left so that the multiplication doesn't overflow.
+		index := ir.NewBinaryExpr(base.Pos, ir.OLSH, byteindex(n.X), ir.NewInt(3))
+		if ssagen.Arch.LinkArch.ByteOrder == binary.BigEndian {
+			index = ir.NewBinaryExpr(base.Pos, ir.OADD, index, ir.NewInt(7))
+		}
+		xe := ir.NewIndexExpr(base.Pos, ir.Names.Staticuint64s, index)
+		xe.SetBounded(true)
+		value = xe
+	case n.X.Op() == ir.ONAME && n.X.(*ir.Name).Class_ == ir.PEXTERN && n.X.(*ir.Name).Readonly():
+		// n.Left is a readonly global; use it directly.
+		value = n.X
+	case !fromType.IsInterface() && n.Esc() == ir.EscNone && fromType.Width <= 1024:
+		// n.Left does not escape. Use a stack temporary initialized to n.Left.
+		value = typecheck.Temp(fromType)
+		init.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, value, n.X)))
+	}
+
+	if value != nil {
+		// Value is identical to n.Left.
+		// Construct the interface directly: {type/itab, &value}.
+		l := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), typecheck.Expr(typecheck.NodAddr(value)))
+		l.SetType(toType)
+		l.SetTypecheck(n.Typecheck())
+		return l
+	}
+
+	// Implement interface to empty interface conversion.
+	// tmp = i.itab
+	// if tmp != nil {
+	//    tmp = tmp.type
+	// }
+	// e = iface{tmp, i.data}
+	if toType.IsEmptyInterface() && fromType.IsInterface() && !fromType.IsEmptyInterface() {
+		// Evaluate the input interface.
+		c := typecheck.Temp(fromType)
+		init.Append(ir.NewAssignStmt(base.Pos, c, n.X))
+
+		// Get the itab out of the interface.
+		tmp := typecheck.Temp(types.NewPtr(types.Types[types.TUINT8]))
+		init.Append(ir.NewAssignStmt(base.Pos, tmp, typecheck.Expr(ir.NewUnaryExpr(base.Pos, ir.OITAB, c))))
+
+		// Get the type out of the itab.
+		nif := ir.NewIfStmt(base.Pos, typecheck.Expr(ir.NewBinaryExpr(base.Pos, ir.ONE, tmp, typecheck.NodNil())), nil, nil)
+		nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, tmp, itabType(tmp))}
+		init.Append(nif)
+
+		// Build the result.
+		e := ir.NewBinaryExpr(base.Pos, ir.OEFACE, tmp, ifaceData(n.Pos(), c, types.NewPtr(types.Types[types.TUINT8])))
+		e.SetType(toType) // assign type manually, typecheck doesn't understand OEFACE.
+		e.SetTypecheck(1)
+		return e
+	}
+
+	fnname, needsaddr := convFuncName(fromType, toType)
+
+	if !needsaddr && !fromType.IsInterface() {
+		// Use a specialized conversion routine that only returns a data pointer.
+		// ptr = convT2X(val)
+		// e = iface{typ/tab, ptr}
+		fn := typecheck.LookupRuntime(fnname)
+		types.CalcSize(fromType)
+		fn = typecheck.SubstArgTypes(fn, fromType)
+		types.CalcSize(fn.Type())
+		call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
+		call.Args = []ir.Node{n.X}
+		e := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), safeExpr(walkExpr(typecheck.Expr(call), init), init))
+		e.SetType(toType)
+		e.SetTypecheck(1)
+		return e
+	}
+
+	var tab ir.Node
+	if fromType.IsInterface() {
+		// convI2I
+		tab = reflectdata.TypePtr(toType)
+	} else {
+		// convT2x
+		tab = typeword()
+	}
+
+	v := n.X
+	if needsaddr {
+		// Types of large or unknown size are passed by reference.
+		// Orderexpr arranged for n.Left to be a temporary for all
+		// the conversions it could see. Comparison of an interface
+		// with a non-interface, especially in a switch on interface value
+		// with non-interface cases, is not visible to order.stmt, so we
+		// have to fall back on allocating a temp here.
+		if !ir.IsAssignable(v) {
+			v = copyExpr(v, v.Type(), init)
+		}
+		v = typecheck.NodAddr(v)
+	}
+
+	types.CalcSize(fromType)
+	fn := typecheck.LookupRuntime(fnname)
+	fn = typecheck.SubstArgTypes(fn, fromType, toType)
+	types.CalcSize(fn.Type())
+	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
+	call.Args = []ir.Node{tab, v}
+	return walkExpr(typecheck.Expr(call), init)
+}
+
+// walkBytesRunesToString walks an OBYTES2STR or ORUNES2STR node.
+func walkBytesRunesToString(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
+	a := typecheck.NodNil()
+	if n.Esc() == ir.EscNone {
+		// Create temporary buffer for string on stack.
+		t := types.NewArray(types.Types[types.TUINT8], tmpstringbufsize)
+		a = typecheck.NodAddr(typecheck.Temp(t))
+	}
+	if n.Op() == ir.ORUNES2STR {
+		// slicerunetostring(*[32]byte, []rune) string
+		return mkcall("slicerunetostring", n.Type(), init, a, n.X)
+	}
+	// slicebytetostring(*[32]byte, ptr *byte, n int) string
+	n.X = cheapExpr(n.X, init)
+	ptr, len := backingArrayPtrLen(n.X)
+	return mkcall("slicebytetostring", n.Type(), init, a, ptr, len)
+}
+
+// walkBytesToStringTemp walks an OBYTES2STRTMP node.
+func walkBytesToStringTemp(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
+	n.X = walkExpr(n.X, init)
+	if !base.Flag.Cfg.Instrumenting {
+		// Let the backend handle OBYTES2STRTMP directly
+		// to avoid a function call to slicebytetostringtmp.
+		return n
+	}
+	// slicebytetostringtmp(ptr *byte, n int) string
+	n.X = cheapExpr(n.X, init)
+	ptr, len := backingArrayPtrLen(n.X)
+	return mkcall("slicebytetostringtmp", n.Type(), init, ptr, len)
+}
+
+// walkRuneToString walks an ORUNESTR node.
+func walkRuneToString(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
+	a := typecheck.NodNil()
+	if n.Esc() == ir.EscNone {
+		t := types.NewArray(types.Types[types.TUINT8], 4)
+		a = typecheck.NodAddr(typecheck.Temp(t))
+	}
+	// intstring(*[4]byte, rune)
+	return mkcall("intstring", n.Type(), init, a, typecheck.Conv(n.X, types.Types[types.TINT64]))
+}
+
+// walkStringToBytes walks an OSTR2BYTES node.
+func walkStringToBytes(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
+	s := n.X
+	if ir.IsConst(s, constant.String) {
+		sc := ir.StringVal(s)
+
+		// Allocate a [n]byte of the right size.
+		t := types.NewArray(types.Types[types.TUINT8], int64(len(sc)))
+		var a ir.Node
+		if n.Esc() == ir.EscNone && len(sc) <= int(ir.MaxImplicitStackVarSize) {
+			a = typecheck.NodAddr(typecheck.Temp(t))
+		} else {
+			a = callnew(t)
+		}
+		p := typecheck.Temp(t.PtrTo()) // *[n]byte
+		init.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, p, a)))
+
+		// Copy from the static string data to the [n]byte.
+		if len(sc) > 0 {
+			as := ir.NewAssignStmt(base.Pos, ir.NewStarExpr(base.Pos, p), ir.NewStarExpr(base.Pos, typecheck.ConvNop(ir.NewUnaryExpr(base.Pos, ir.OSPTR, s), t.PtrTo())))
+			appendWalkStmt(init, as)
+		}
+
+		// Slice the [n]byte to a []byte.
+		slice := ir.NewSliceExpr(n.Pos(), ir.OSLICEARR, p)
+		slice.SetType(n.Type())
+		slice.SetTypecheck(1)
+		return walkExpr(slice, init)
+	}
+
+	a := typecheck.NodNil()
+	if n.Esc() == ir.EscNone {
+		// Create temporary buffer for slice on stack.
+		t := types.NewArray(types.Types[types.TUINT8], tmpstringbufsize)
+		a = typecheck.NodAddr(typecheck.Temp(t))
+	}
+	// stringtoslicebyte(*32[byte], string) []byte
+	return mkcall("stringtoslicebyte", n.Type(), init, a, typecheck.Conv(s, types.Types[types.TSTRING]))
+}
+
+// walkStringToBytesTemp walks an OSTR2BYTESTMP node.
+func walkStringToBytesTemp(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
+	// []byte(string) conversion that creates a slice
+	// referring to the actual string bytes.
+	// This conversion is handled later by the backend and
+	// is only for use by internal compiler optimizations
+	// that know that the slice won't be mutated.
+	// The only such case today is:
+	// for i, c := range []byte(string)
+	n.X = walkExpr(n.X, init)
+	return n
+}
+
+// walkStringToRunes walks an OSTR2RUNES node.
+func walkStringToRunes(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
+	a := typecheck.NodNil()
+	if n.Esc() == ir.EscNone {
+		// Create temporary buffer for slice on stack.
+		t := types.NewArray(types.Types[types.TINT32], tmpstringbufsize)
+		a = typecheck.NodAddr(typecheck.Temp(t))
+	}
+	// stringtoslicerune(*[32]rune, string) []rune
+	return mkcall("stringtoslicerune", n.Type(), init, a, typecheck.Conv(n.X, types.Types[types.TSTRING]))
+}
+
+// convFuncName builds the runtime function name for interface conversion.
+// It also reports whether the function expects the data by address.
+// Not all names are possible. For example, we never generate convE2E or convE2I.
+func convFuncName(from, to *types.Type) (fnname string, needsaddr bool) {
+	tkind := to.Tie()
+	switch from.Tie() {
+	case 'I':
+		if tkind == 'I' {
+			return "convI2I", false
+		}
+	case 'T':
+		switch {
+		case from.Size() == 2 && from.Align == 2:
+			return "convT16", false
+		case from.Size() == 4 && from.Align == 4 && !from.HasPointers():
+			return "convT32", false
+		case from.Size() == 8 && from.Align == types.Types[types.TUINT64].Align && !from.HasPointers():
+			return "convT64", false
+		}
+		if sc := from.SoleComponent(); sc != nil {
+			switch {
+			case sc.IsString():
+				return "convTstring", false
+			case sc.IsSlice():
+				return "convTslice", false
+			}
+		}
+
+		switch tkind {
+		case 'E':
+			if !from.HasPointers() {
+				return "convT2Enoptr", true
+			}
+			return "convT2E", true
+		case 'I':
+			if !from.HasPointers() {
+				return "convT2Inoptr", true
+			}
+			return "convT2I", true
+		}
+	}
+	base.Fatalf("unknown conv func %c2%c", from.Tie(), to.Tie())
+	panic("unreachable")
+}
+
+// rtconvfn returns the parameter and result types that will be used by a
+// runtime function to convert from type src to type dst. The runtime function
+// name can be derived from the names of the returned types.
+//
+// If no such function is necessary, it returns (Txxx, Txxx).
+func rtconvfn(src, dst *types.Type) (param, result types.Kind) {
+	if ssagen.Arch.SoftFloat {
+		return types.Txxx, types.Txxx
+	}
+
+	switch ssagen.Arch.LinkArch.Family {
+	case sys.ARM, sys.MIPS:
+		if src.IsFloat() {
+			switch dst.Kind() {
+			case types.TINT64, types.TUINT64:
+				return types.TFLOAT64, dst.Kind()
+			}
+		}
+		if dst.IsFloat() {
+			switch src.Kind() {
+			case types.TINT64, types.TUINT64:
+				return src.Kind(), types.TFLOAT64
+			}
+		}
+
+	case sys.I386:
+		if src.IsFloat() {
+			switch dst.Kind() {
+			case types.TINT64, types.TUINT64:
+				return types.TFLOAT64, dst.Kind()
+			case types.TUINT32, types.TUINT, types.TUINTPTR:
+				return types.TFLOAT64, types.TUINT32
+			}
+		}
+		if dst.IsFloat() {
+			switch src.Kind() {
+			case types.TINT64, types.TUINT64:
+				return src.Kind(), types.TFLOAT64
+			case types.TUINT32, types.TUINT, types.TUINTPTR:
+				return types.TUINT32, types.TFLOAT64
+			}
+		}
+	}
+	return types.Txxx, types.Txxx
+}
+
+// byteindex converts n, which is byte-sized, to an int used to index into an array.
+// We cannot use conv, because we allow converting bool to int here,
+// which is forbidden in user code.
+func byteindex(n ir.Node) ir.Node {
+	// We cannot convert from bool to int directly.
+	// While converting from int8 to int is possible, it would yield
+	// the wrong result for negative values.
+	// Reinterpreting the value as an unsigned byte solves both cases.
+	if !types.Identical(n.Type(), types.Types[types.TUINT8]) {
+		n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
+		n.SetType(types.Types[types.TUINT8])
+		n.SetTypecheck(1)
+	}
+	n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
+	n.SetType(types.Types[types.TINT])
+	n.SetTypecheck(1)
+	return n
+}
+
+func walkCheckPtrAlignment(n *ir.ConvExpr, init *ir.Nodes, count ir.Node) ir.Node {
+	if !n.Type().IsPtr() {
+		base.Fatalf("expected pointer type: %v", n.Type())
+	}
+	elem := n.Type().Elem()
+	if count != nil {
+		if !elem.IsArray() {
+			base.Fatalf("expected array type: %v", elem)
+		}
+		elem = elem.Elem()
+	}
+
+	size := elem.Size()
+	if elem.Alignment() == 1 && (size == 0 || size == 1 && count == nil) {
+		return n
+	}
+
+	if count == nil {
+		count = ir.NewInt(1)
+	}
+
+	n.X = cheapExpr(n.X, init)
+	init.Append(mkcall("checkptrAlignment", nil, init, typecheck.ConvNop(n.X, types.Types[types.TUNSAFEPTR]), reflectdata.TypePtr(elem), typecheck.Conv(count, types.Types[types.TUINTPTR])))
+	return n
+}
+
+func walkCheckPtrArithmetic(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
+	// Calling cheapexpr(n, init) below leads to a recursive call
+	// to walkexpr, which leads us back here again. Use n.Opt to
+	// prevent infinite loops.
+	if opt := n.Opt(); opt == &walkCheckPtrArithmeticMarker {
+		return n
+	} else if opt != nil {
+		// We use n.Opt() here because today it's not used for OCONVNOP. If that changes,
+		// there's no guarantee that temporarily replacing it is safe, so just hard fail here.
+		base.Fatalf("unexpected Opt: %v", opt)
+	}
+	n.SetOpt(&walkCheckPtrArithmeticMarker)
+	defer n.SetOpt(nil)
+
+	// TODO(mdempsky): Make stricter. We only need to exempt
+	// reflect.Value.Pointer and reflect.Value.UnsafeAddr.
+	switch n.X.Op() {
+	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
+		return n
+	}
+
+	if n.X.Op() == ir.ODOTPTR && ir.IsReflectHeaderDataField(n.X) {
+		return n
+	}
+
+	// Find original unsafe.Pointer operands involved in this
+	// arithmetic expression.
+	//
+	// "It is valid both to add and to subtract offsets from a
+	// pointer in this way. It is also valid to use &^ to round
+	// pointers, usually for alignment."
+	var originals []ir.Node
+	var walk func(n ir.Node)
+	walk = func(n ir.Node) {
+		switch n.Op() {
+		case ir.OADD:
+			n := n.(*ir.BinaryExpr)
+			walk(n.X)
+			walk(n.Y)
+		case ir.OSUB, ir.OANDNOT:
+			n := n.(*ir.BinaryExpr)
+			walk(n.X)
+		case ir.OCONVNOP:
+			n := n.(*ir.ConvExpr)
+			if n.X.Type().IsUnsafePtr() {
+				n.X = cheapExpr(n.X, init)
+				originals = append(originals, typecheck.ConvNop(n.X, types.Types[types.TUNSAFEPTR]))
+			}
+		}
+	}
+	walk(n.X)
+
+	cheap := cheapExpr(n, init)
+
+	slice := typecheck.MakeDotArgs(types.NewSlice(types.Types[types.TUNSAFEPTR]), originals)
+	slice.SetEsc(ir.EscNone)
+
+	init.Append(mkcall("checkptrArithmetic", nil, init, typecheck.ConvNop(cheap, types.Types[types.TUNSAFEPTR]), slice))
+	// TODO(khr): Mark backing store of slice as dead. This will allow us to reuse
+	// the backing store for multiple calls to checkptrArithmetic.
+
+	return cheap
+}
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
new file mode 100644
index 0000000000..2029a6aef6
--- /dev/null
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -0,0 +1,1009 @@
+// Copyright 2009 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 walk
+
+import (
+	"fmt"
+	"go/constant"
+	"strings"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/reflectdata"
+	"cmd/compile/internal/staticdata"
+	"cmd/compile/internal/typecheck"
+	"cmd/compile/internal/types"
+	"cmd/internal/obj"
+	"cmd/internal/objabi"
+)
+
+// The result of walkExpr MUST be assigned back to n, e.g.
+// 	n.Left = walkExpr(n.Left, init)
+func walkExpr(n ir.Node, init *ir.Nodes) ir.Node {
+	if n == nil {
+		return n
+	}
+
+	// Eagerly checkwidth all expressions for the back end.
+	if n.Type() != nil && !n.Type().WidthCalculated() {
+		switch n.Type().Kind() {
+		case types.TBLANK, types.TNIL, types.TIDEAL:
+		default:
+			types.CheckSize(n.Type())
+		}
+	}
+
+	if init == n.PtrInit() {
+		// not okay to use n->ninit when walking n,
+		// because we might replace n with some other node
+		// and would lose the init list.
+		base.Fatalf("walkexpr init == &n->ninit")
+	}
+
+	if len(n.Init()) != 0 {
+		walkStmtList(n.Init())
+		init.Append(n.PtrInit().Take()...)
+	}
+
+	lno := ir.SetPos(n)
+
+	if base.Flag.LowerW > 1 {
+		ir.Dump("before walk expr", n)
+	}
+
+	if n.Typecheck() != 1 {
+		base.Fatalf("missed typecheck: %+v", n)
+	}
+
+	if n.Type().IsUntyped() {
+		base.Fatalf("expression has untyped type: %+v", n)
+	}
+
+	if n.Op() == ir.ONAME && n.(*ir.Name).Class_ == ir.PAUTOHEAP {
+		n := n.(*ir.Name)
+		nn := ir.NewStarExpr(base.Pos, n.Name().Heapaddr)
+		nn.X.MarkNonNil()
+		return walkExpr(typecheck.Expr(nn), init)
+	}
+
+	n = walkExpr1(n, init)
+
+	// Expressions that are constant at run time but not
+	// considered const by the language spec are not turned into
+	// constants until walk. For example, if n is y%1 == 0, the
+	// walk of y%1 may have replaced it by 0.
+	// Check whether n with its updated args is itself now a constant.
+	t := n.Type()
+	n = typecheck.EvalConst(n)
+	if n.Type() != t {
+		base.Fatalf("evconst changed Type: %v had type %v, now %v", n, t, n.Type())
+	}
+	if n.Op() == ir.OLITERAL {
+		n = typecheck.Expr(n)
+		// Emit string symbol now to avoid emitting
+		// any concurrently during the backend.
+		if v := n.Val(); v.Kind() == constant.String {
+			_ = staticdata.StringSym(n.Pos(), constant.StringVal(v))
+		}
+	}
+
+	updateHasCall(n)
+
+	if base.Flag.LowerW != 0 && n != nil {
+		ir.Dump("after walk expr", n)
+	}
+
+	base.Pos = lno
+	return n
+}
+
+func walkExpr1(n ir.Node, init *ir.Nodes) ir.Node {
+	switch n.Op() {
+	default:
+		ir.Dump("walk", n)
+		base.Fatalf("walkexpr: switch 1 unknown op %+v", n.Op())
+		panic("unreachable")
+
+	case ir.ONONAME, ir.OGETG, ir.ONEWOBJ, ir.OMETHEXPR:
+		return n
+
+	case ir.OTYPE, ir.ONAME, ir.OLITERAL, ir.ONIL, ir.ONAMEOFFSET:
+		// TODO(mdempsky): Just return n; see discussion on CL 38655.
+		// Perhaps refactor to use Node.mayBeShared for these instead.
+		// If these return early, make sure to still call
+		// stringsym for constant strings.
+		return n
+
+	case ir.ONOT, ir.ONEG, ir.OPLUS, ir.OBITNOT, ir.OREAL, ir.OIMAG, ir.OSPTR, ir.OITAB, ir.OIDATA:
+		n := n.(*ir.UnaryExpr)
+		n.X = walkExpr(n.X, init)
+		return n
+
+	case ir.ODOTMETH, ir.ODOTINTER:
+		n := n.(*ir.SelectorExpr)
+		n.X = walkExpr(n.X, init)
+		return n
+
+	case ir.OADDR:
+		n := n.(*ir.AddrExpr)
+		n.X = walkExpr(n.X, init)
+		return n
+
+	case ir.ODEREF:
+		n := n.(*ir.StarExpr)
+		n.X = walkExpr(n.X, init)
+		return n
+
+	case ir.OEFACE, ir.OAND, ir.OANDNOT, ir.OSUB, ir.OMUL, ir.OADD, ir.OOR, ir.OXOR, ir.OLSH, ir.ORSH:
+		n := n.(*ir.BinaryExpr)
+		n.X = walkExpr(n.X, init)
+		n.Y = walkExpr(n.Y, init)
+		return n
+
+	case ir.ODOT, ir.ODOTPTR:
+		n := n.(*ir.SelectorExpr)
+		return walkDot(n, init)
+
+	case ir.ODOTTYPE, ir.ODOTTYPE2:
+		n := n.(*ir.TypeAssertExpr)
+		return walkDotType(n, init)
+
+	case ir.OLEN, ir.OCAP:
+		n := n.(*ir.UnaryExpr)
+		return walkLenCap(n, init)
+
+	case ir.OCOMPLEX:
+		n := n.(*ir.BinaryExpr)
+		n.X = walkExpr(n.X, init)
+		n.Y = walkExpr(n.Y, init)
+		return n
+
+	case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
+		n := n.(*ir.BinaryExpr)
+		return walkCompare(n, init)
+
+	case ir.OANDAND, ir.OOROR:
+		n := n.(*ir.LogicalExpr)
+		return walkLogical(n, init)
+
+	case ir.OPRINT, ir.OPRINTN:
+		return walkPrint(n.(*ir.CallExpr), init)
+
+	case ir.OPANIC:
+		n := n.(*ir.UnaryExpr)
+		return mkcall("gopanic", nil, init, n.X)
+
+	case ir.ORECOVER:
+		n := n.(*ir.CallExpr)
+		return mkcall("gorecover", n.Type(), init, typecheck.NodAddr(ir.RegFP))
+
+	case ir.OCLOSUREREAD, ir.OCFUNC:
+		return n
+
+	case ir.OCALLINTER, ir.OCALLFUNC, ir.OCALLMETH:
+		n := n.(*ir.CallExpr)
+		return walkCall(n, init)
+
+	case ir.OAS, ir.OASOP:
+		return walkAssign(init, n)
+
+	case ir.OAS2:
+		n := n.(*ir.AssignListStmt)
+		return walkAssignList(init, n)
+
+	// a,b,... = fn()
+	case ir.OAS2FUNC:
+		n := n.(*ir.AssignListStmt)
+		return walkAssignFunc(init, n)
+
+	// x, y = <-c
+	// order.stmt made sure x is addressable or blank.
+	case ir.OAS2RECV:
+		n := n.(*ir.AssignListStmt)
+		return walkAssignRecv(init, n)
+
+	// a,b = m[i]
+	case ir.OAS2MAPR:
+		n := n.(*ir.AssignListStmt)
+		return walkAssignMapRead(init, n)
+
+	case ir.ODELETE:
+		n := n.(*ir.CallExpr)
+		return walkDelete(init, n)
+
+	case ir.OAS2DOTTYPE:
+		n := n.(*ir.AssignListStmt)
+		return walkAssignDotType(n, init)
+
+	case ir.OCONVIFACE:
+		n := n.(*ir.ConvExpr)
+		return walkConvInterface(n, init)
+
+	case ir.OCONV, ir.OCONVNOP:
+		n := n.(*ir.ConvExpr)
+		return walkConv(n, init)
+
+	case ir.ODIV, ir.OMOD:
+		n := n.(*ir.BinaryExpr)
+		return walkDivMod(n, init)
+
+	case ir.OINDEX:
+		n := n.(*ir.IndexExpr)
+		return walkIndex(n, init)
+
+	case ir.OINDEXMAP:
+		n := n.(*ir.IndexExpr)
+		return walkIndexMap(n, init)
+
+	case ir.ORECV:
+		base.Fatalf("walkexpr ORECV") // should see inside OAS only
+		panic("unreachable")
+
+	case ir.OSLICEHEADER:
+		n := n.(*ir.SliceHeaderExpr)
+		return walkSliceHeader(n, init)
+
+	case ir.OSLICE, ir.OSLICEARR, ir.OSLICESTR, ir.OSLICE3, ir.OSLICE3ARR:
+		n := n.(*ir.SliceExpr)
+		return walkSlice(n, init)
+
+	case ir.ONEW:
+		n := n.(*ir.UnaryExpr)
+		return walkNew(n, init)
+
+	case ir.OADDSTR:
+		return walkAddString(n.(*ir.AddStringExpr), init)
+
+	case ir.OAPPEND:
+		// order should make sure we only see OAS(node, OAPPEND), which we handle above.
+		base.Fatalf("append outside assignment")
+		panic("unreachable")
+
+	case ir.OCOPY:
+		return walkCopy(n.(*ir.BinaryExpr), init, base.Flag.Cfg.Instrumenting && !base.Flag.CompilingRuntime)
+
+	case ir.OCLOSE:
+		n := n.(*ir.UnaryExpr)
+		return walkClose(n, init)
+
+	case ir.OMAKECHAN:
+		n := n.(*ir.MakeExpr)
+		return walkMakeChan(n, init)
+
+	case ir.OMAKEMAP:
+		n := n.(*ir.MakeExpr)
+		return walkMakeMap(n, init)
+
+	case ir.OMAKESLICE:
+		n := n.(*ir.MakeExpr)
+		return walkMakeSlice(n, init)
+
+	case ir.OMAKESLICECOPY:
+		n := n.(*ir.MakeExpr)
+		return walkMakeSliceCopy(n, init)
+
+	case ir.ORUNESTR:
+		n := n.(*ir.ConvExpr)
+		return walkRuneToString(n, init)
+
+	case ir.OBYTES2STR, ir.ORUNES2STR:
+		n := n.(*ir.ConvExpr)
+		return walkBytesRunesToString(n, init)
+
+	case ir.OBYTES2STRTMP:
+		n := n.(*ir.ConvExpr)
+		return walkBytesToStringTemp(n, init)
+
+	case ir.OSTR2BYTES:
+		n := n.(*ir.ConvExpr)
+		return walkStringToBytes(n, init)
+
+	case ir.OSTR2BYTESTMP:
+		n := n.(*ir.ConvExpr)
+		return walkStringToBytesTemp(n, init)
+
+	case ir.OSTR2RUNES:
+		n := n.(*ir.ConvExpr)
+		return walkStringToRunes(n, init)
+
+	case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT, ir.OSTRUCTLIT, ir.OPTRLIT:
+		return walkCompLit(n, init)
+
+	case ir.OSEND:
+		n := n.(*ir.SendStmt)
+		return walkSend(n, init)
+
+	case ir.OCLOSURE:
+		return walkClosure(n.(*ir.ClosureExpr), init)
+
+	case ir.OCALLPART:
+		return walkCallPart(n.(*ir.CallPartExpr), init)
+	}
+
+	// No return! Each case must return (or panic),
+	// to avoid confusion about what gets returned
+	// in the presence of type assertions.
+}
+
+// walk the whole tree of the body of an
+// expression or simple statement.
+// the types expressions are calculated.
+// compile-time constants are evaluated.
+// complex side effects like statements are appended to init
+func walkExprList(s []ir.Node, init *ir.Nodes) {
+	for i := range s {
+		s[i] = walkExpr(s[i], init)
+	}
+}
+
+func walkExprListCheap(s []ir.Node, init *ir.Nodes) {
+	for i, n := range s {
+		s[i] = cheapExpr(n, init)
+		s[i] = walkExpr(s[i], init)
+	}
+}
+
+func walkExprListSafe(s []ir.Node, init *ir.Nodes) {
+	for i, n := range s {
+		s[i] = safeExpr(n, init)
+		s[i] = walkExpr(s[i], init)
+	}
+}
+
+// return side-effect free and cheap n, appending side effects to init.
+// result may not be assignable.
+func cheapExpr(n ir.Node, init *ir.Nodes) ir.Node {
+	switch n.Op() {
+	case ir.ONAME, ir.OLITERAL, ir.ONIL:
+		return n
+	}
+
+	return copyExpr(n, n.Type(), init)
+}
+
+// return side effect-free n, appending side effects to init.
+// result is assignable if n is.
+func safeExpr(n ir.Node, init *ir.Nodes) ir.Node {
+	if n == nil {
+		return nil
+	}
+
+	if len(n.Init()) != 0 {
+		walkStmtList(n.Init())
+		init.Append(n.PtrInit().Take()...)
+	}
+
+	switch n.Op() {
+	case ir.ONAME, ir.OLITERAL, ir.ONIL, ir.ONAMEOFFSET:
+		return n
+
+	case ir.OLEN, ir.OCAP:
+		n := n.(*ir.UnaryExpr)
+		l := safeExpr(n.X, init)
+		if l == n.X {
+			return n
+		}
+		a := ir.Copy(n).(*ir.UnaryExpr)
+		a.X = l
+		return walkExpr(typecheck.Expr(a), init)
+
+	case ir.ODOT, ir.ODOTPTR:
+		n := n.(*ir.SelectorExpr)
+		l := safeExpr(n.X, init)
+		if l == n.X {
+			return n
+		}
+		a := ir.Copy(n).(*ir.SelectorExpr)
+		a.X = l
+		return walkExpr(typecheck.Expr(a), init)
+
+	case ir.ODEREF:
+		n := n.(*ir.StarExpr)
+		l := safeExpr(n.X, init)
+		if l == n.X {
+			return n
+		}
+		a := ir.Copy(n).(*ir.StarExpr)
+		a.X = l
+		return walkExpr(typecheck.Expr(a), init)
+
+	case ir.OINDEX, ir.OINDEXMAP:
+		n := n.(*ir.IndexExpr)
+		l := safeExpr(n.X, init)
+		r := safeExpr(n.Index, init)
+		if l == n.X && r == n.Index {
+			return n
+		}
+		a := ir.Copy(n).(*ir.IndexExpr)
+		a.X = l
+		a.Index = r
+		return walkExpr(typecheck.Expr(a), init)
+
+	case ir.OSTRUCTLIT, ir.OARRAYLIT, ir.OSLICELIT:
+		n := n.(*ir.CompLitExpr)
+		if isStaticCompositeLiteral(n) {
+			return n
+		}
+	}
+
+	// make a copy; must not be used as an lvalue
+	if ir.IsAssignable(n) {
+		base.Fatalf("missing lvalue case in safeexpr: %v", n)
+	}
+	return cheapExpr(n, init)
+}
+
+func copyExpr(n ir.Node, t *types.Type, init *ir.Nodes) ir.Node {
+	l := typecheck.Temp(t)
+	appendWalkStmt(init, ir.NewAssignStmt(base.Pos, l, n))
+	return l
+}
+
+func walkAddString(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
+	c := len(n.List)
+
+	if c < 2 {
+		base.Fatalf("addstr count %d too small", c)
+	}
+
+	buf := typecheck.NodNil()
+	if n.Esc() == ir.EscNone {
+		sz := int64(0)
+		for _, n1 := range n.List {
+			if n1.Op() == ir.OLITERAL {
+				sz += int64(len(ir.StringVal(n1)))
+			}
+		}
+
+		// Don't allocate the buffer if the result won't fit.
+		if sz < tmpstringbufsize {
+			// Create temporary buffer for result string on stack.
+			t := types.NewArray(types.Types[types.TUINT8], tmpstringbufsize)
+			buf = typecheck.NodAddr(typecheck.Temp(t))
+		}
+	}
+
+	// build list of string arguments
+	args := []ir.Node{buf}
+	for _, n2 := range n.List {
+		args = append(args, typecheck.Conv(n2, types.Types[types.TSTRING]))
+	}
+
+	var fn string
+	if c <= 5 {
+		// small numbers of strings use direct runtime helpers.
+		// note: order.expr knows this cutoff too.
+		fn = fmt.Sprintf("concatstring%d", c)
+	} else {
+		// large numbers of strings are passed to the runtime as a slice.
+		fn = "concatstrings"
+
+		t := types.NewSlice(types.Types[types.TSTRING])
+		// args[1:] to skip buf arg
+		slice := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(t), args[1:])
+		slice.Prealloc = n.Prealloc
+		args = []ir.Node{buf, slice}
+		slice.SetEsc(ir.EscNone)
+	}
+
+	cat := typecheck.LookupRuntime(fn)
+	r := ir.NewCallExpr(base.Pos, ir.OCALL, cat, nil)
+	r.Args.Set(args)
+	r1 := typecheck.Expr(r)
+	r1 = walkExpr(r1, init)
+	r1.SetType(n.Type())
+
+	return r1
+}
+
+// walkCall walks an OCALLFUNC, OCALLINTER, or OCALLMETH node.
+func walkCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
+	if n.Op() == ir.OCALLINTER {
+		usemethod(n)
+		reflectdata.MarkUsedIfaceMethod(n)
+	}
+
+	if n.Op() == ir.OCALLFUNC && n.X.Op() == ir.OCLOSURE {
+		// Transform direct call of a closure to call of a normal function.
+		// transformclosure already did all preparation work.
+
+		// Prepend captured variables to argument list.
+		clo := n.X.(*ir.ClosureExpr)
+		n.Args.Prepend(clo.Func.ClosureEnter...)
+		clo.Func.ClosureEnter.Set(nil)
+
+		// Replace OCLOSURE with ONAME/PFUNC.
+		n.X = clo.Func.Nname
+
+		// Update type of OCALLFUNC node.
+		// Output arguments had not changed, but their offsets could.
+		if n.X.Type().NumResults() == 1 {
+			n.SetType(n.X.Type().Results().Field(0).Type)
+		} else {
+			n.SetType(n.X.Type().Results())
+		}
+	}
+
+	walkCall1(n, init)
+	return n
+}
+
+func walkCall1(n *ir.CallExpr, init *ir.Nodes) {
+	if len(n.Rargs) != 0 {
+		return // already walked
+	}
+
+	params := n.X.Type().Params()
+	args := n.Args
+
+	n.X = walkExpr(n.X, init)
+	walkExprList(args, init)
+
+	// If this is a method call, add the receiver at the beginning of the args.
+	if n.Op() == ir.OCALLMETH {
+		withRecv := make([]ir.Node, len(args)+1)
+		dot := n.X.(*ir.SelectorExpr)
+		withRecv[0] = dot.X
+		dot.X = nil
+		copy(withRecv[1:], args)
+		args = withRecv
+	}
+
+	// For any argument whose evaluation might require a function call,
+	// store that argument into a temporary variable,
+	// to prevent that calls from clobbering arguments already on the stack.
+	// When instrumenting, all arguments might require function calls.
+	var tempAssigns []ir.Node
+	for i, arg := range args {
+		updateHasCall(arg)
+		// Determine param type.
+		var t *types.Type
+		if n.Op() == ir.OCALLMETH {
+			if i == 0 {
+				t = n.X.Type().Recv().Type
+			} else {
+				t = params.Field(i - 1).Type
+			}
+		} else {
+			t = params.Field(i).Type
+		}
+		if base.Flag.Cfg.Instrumenting || fncall(arg, t) {
+			// make assignment of fncall to tempAt
+			tmp := typecheck.Temp(t)
+			a := convas(ir.NewAssignStmt(base.Pos, tmp, arg), init)
+			tempAssigns = append(tempAssigns, a)
+			// replace arg with temp
+			args[i] = tmp
+		}
+	}
+
+	n.Args.Set(tempAssigns)
+	n.Rargs.Set(args)
+}
+
+// walkDivMod walks an ODIV or OMOD node.
+func walkDivMod(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
+	n.X = walkExpr(n.X, init)
+	n.Y = walkExpr(n.Y, init)
+
+	// rewrite complex div into function call.
+	et := n.X.Type().Kind()
+
+	if types.IsComplex[et] && n.Op() == ir.ODIV {
+		t := n.Type()
+		call := mkcall("complex128div", types.Types[types.TCOMPLEX128], init, typecheck.Conv(n.X, types.Types[types.TCOMPLEX128]), typecheck.Conv(n.Y, types.Types[types.TCOMPLEX128]))
+		return typecheck.Conv(call, t)
+	}
+
+	// Nothing to do for float divisions.
+	if types.IsFloat[et] {
+		return n
+	}
+
+	// rewrite 64-bit div and mod on 32-bit architectures.
+	// TODO: Remove this code once we can introduce
+	// runtime calls late in SSA processing.
+	if types.RegSize < 8 && (et == types.TINT64 || et == types.TUINT64) {
+		if n.Y.Op() == ir.OLITERAL {
+			// Leave div/mod by constant powers of 2 or small 16-bit constants.
+			// The SSA backend will handle those.
+			switch et {
+			case types.TINT64:
+				c := ir.Int64Val(n.Y)
+				if c < 0 {
+					c = -c
+				}
+				if c != 0 && c&(c-1) == 0 {
+					return n
+				}
+			case types.TUINT64:
+				c := ir.Uint64Val(n.Y)
+				if c < 1<<16 {
+					return n
+				}
+				if c != 0 && c&(c-1) == 0 {
+					return n
+				}
+			}
+		}
+		var fn string
+		if et == types.TINT64 {
+			fn = "int64"
+		} else {
+			fn = "uint64"
+		}
+		if n.Op() == ir.ODIV {
+			fn += "div"
+		} else {
+			fn += "mod"
+		}
+		return mkcall(fn, n.Type(), init, typecheck.Conv(n.X, types.Types[et]), typecheck.Conv(n.Y, types.Types[et]))
+	}
+	return n
+}
+
+// walkDot walks an ODOT or ODOTPTR node.
+func walkDot(n *ir.SelectorExpr, init *ir.Nodes) ir.Node {
+	usefield(n)
+	n.X = walkExpr(n.X, init)
+	return n
+}
+
+// walkDotType walks an ODOTTYPE or ODOTTYPE2 node.
+func walkDotType(n *ir.TypeAssertExpr, init *ir.Nodes) ir.Node {
+	n.X = walkExpr(n.X, init)
+	// Set up interface type addresses for back end.
+	n.Ntype = reflectdata.TypePtr(n.Type())
+	if n.Op() == ir.ODOTTYPE {
+		n.Ntype.(*ir.AddrExpr).Alloc = reflectdata.TypePtr(n.X.Type())
+	}
+	if !n.Type().IsInterface() && !n.X.Type().IsEmptyInterface() {
+		n.Itab = []ir.Node{reflectdata.ITabAddr(n.Type(), n.X.Type())}
+	}
+	return n
+}
+
+// walkIndex walks an OINDEX node.
+func walkIndex(n *ir.IndexExpr, init *ir.Nodes) ir.Node {
+	n.X = walkExpr(n.X, init)
+
+	// save the original node for bounds checking elision.
+	// If it was a ODIV/OMOD walk might rewrite it.
+	r := n.Index
+
+	n.Index = walkExpr(n.Index, init)
+
+	// if range of type cannot exceed static array bound,
+	// disable bounds check.
+	if n.Bounded() {
+		return n
+	}
+	t := n.X.Type()
+	if t != nil && t.IsPtr() {
+		t = t.Elem()
+	}
+	if t.IsArray() {
+		n.SetBounded(bounded(r, t.NumElem()))
+		if base.Flag.LowerM != 0 && n.Bounded() && !ir.IsConst(n.Index, constant.Int) {
+			base.Warn("index bounds check elided")
+		}
+		if ir.IsSmallIntConst(n.Index) && !n.Bounded() {
+			base.Errorf("index out of bounds")
+		}
+	} else if ir.IsConst(n.X, constant.String) {
+		n.SetBounded(bounded(r, int64(len(ir.StringVal(n.X)))))
+		if base.Flag.LowerM != 0 && n.Bounded() && !ir.IsConst(n.Index, constant.Int) {
+			base.Warn("index bounds check elided")
+		}
+		if ir.IsSmallIntConst(n.Index) && !n.Bounded() {
+			base.Errorf("index out of bounds")
+		}
+	}
+
+	if ir.IsConst(n.Index, constant.Int) {
+		if v := n.Index.Val(); constant.Sign(v) < 0 || ir.ConstOverflow(v, types.Types[types.TINT]) {
+			base.Errorf("index out of bounds")
+		}
+	}
+	return n
+}
+
+// walkIndexMap walks an OINDEXMAP node.
+func walkIndexMap(n *ir.IndexExpr, init *ir.Nodes) ir.Node {
+	// Replace m[k] with *map{access1,assign}(maptype, m, &k)
+	n.X = walkExpr(n.X, init)
+	n.Index = walkExpr(n.Index, init)
+	map_ := n.X
+	key := n.Index
+	t := map_.Type()
+	var call *ir.CallExpr
+	if n.Assigned {
+		// This m[k] expression is on the left-hand side of an assignment.
+		fast := mapfast(t)
+		if fast == mapslow {
+			// standard version takes key by reference.
+			// order.expr made sure key is addressable.
+			key = typecheck.NodAddr(key)
+		}
+		call = mkcall1(mapfn(mapassign[fast], t), nil, init, reflectdata.TypePtr(t), map_, key)
+	} else {
+		// m[k] is not the target of an assignment.
+		fast := mapfast(t)
+		if fast == mapslow {
+			// standard version takes key by reference.
+			// order.expr made sure key is addressable.
+			key = typecheck.NodAddr(key)
+		}
+
+		if w := t.Elem().Width; w <= zeroValSize {
+			call = mkcall1(mapfn(mapaccess1[fast], t), types.NewPtr(t.Elem()), init, reflectdata.TypePtr(t), map_, key)
+		} else {
+			z := reflectdata.ZeroAddr(w)
+			call = mkcall1(mapfn("mapaccess1_fat", t), types.NewPtr(t.Elem()), init, reflectdata.TypePtr(t), map_, key, z)
+		}
+	}
+	call.SetType(types.NewPtr(t.Elem()))
+	call.MarkNonNil() // mapaccess1* and mapassign always return non-nil pointers.
+	star := ir.NewStarExpr(base.Pos, call)
+	star.SetType(t.Elem())
+	star.SetTypecheck(1)
+	return star
+}
+
+// walkLogical walks an OANDAND or OOROR node.
+func walkLogical(n *ir.LogicalExpr, init *ir.Nodes) ir.Node {
+	n.X = walkExpr(n.X, init)
+
+	// cannot put side effects from n.Right on init,
+	// because they cannot run before n.Left is checked.
+	// save elsewhere and store on the eventual n.Right.
+	var ll ir.Nodes
+
+	n.Y = walkExpr(n.Y, &ll)
+	n.Y = ir.InitExpr(ll, n.Y)
+	return n
+}
+
+// walkSend walks an OSEND node.
+func walkSend(n *ir.SendStmt, init *ir.Nodes) ir.Node {
+	n1 := n.Value
+	n1 = typecheck.AssignConv(n1, n.Chan.Type().Elem(), "chan send")
+	n1 = walkExpr(n1, init)
+	n1 = typecheck.NodAddr(n1)
+	return mkcall1(chanfn("chansend1", 2, n.Chan.Type()), nil, init, n.Chan, n1)
+}
+
+// walkSlice walks an OSLICE, OSLICEARR, OSLICESTR, OSLICE3, or OSLICE3ARR node.
+func walkSlice(n *ir.SliceExpr, init *ir.Nodes) ir.Node {
+
+	checkSlice := ir.ShouldCheckPtr(ir.CurFunc, 1) && n.Op() == ir.OSLICE3ARR && n.X.Op() == ir.OCONVNOP && n.X.(*ir.ConvExpr).X.Type().IsUnsafePtr()
+	if checkSlice {
+		conv := n.X.(*ir.ConvExpr)
+		conv.X = walkExpr(conv.X, init)
+	} else {
+		n.X = walkExpr(n.X, init)
+	}
+
+	low, high, max := n.SliceBounds()
+	low = walkExpr(low, init)
+	if low != nil && ir.IsZero(low) {
+		// Reduce x[0:j] to x[:j] and x[0:j:k] to x[:j:k].
+		low = nil
+	}
+	high = walkExpr(high, init)
+	max = walkExpr(max, init)
+	n.SetSliceBounds(low, high, max)
+	if checkSlice {
+		n.X = walkCheckPtrAlignment(n.X.(*ir.ConvExpr), init, max)
+	}
+
+	if n.Op().IsSlice3() {
+		if max != nil && max.Op() == ir.OCAP && ir.SameSafeExpr(n.X, max.(*ir.UnaryExpr).X) {
+			// Reduce x[i:j:cap(x)] to x[i:j].
+			if n.Op() == ir.OSLICE3 {
+				n.SetOp(ir.OSLICE)
+			} else {
+				n.SetOp(ir.OSLICEARR)
+			}
+			return reduceSlice(n)
+		}
+		return n
+	}
+	return reduceSlice(n)
+}
+
+// walkSliceHeader walks an OSLICEHEADER node.
+func walkSliceHeader(n *ir.SliceHeaderExpr, init *ir.Nodes) ir.Node {
+	n.Ptr = walkExpr(n.Ptr, init)
+	n.LenCap[0] = walkExpr(n.LenCap[0], init)
+	n.LenCap[1] = walkExpr(n.LenCap[1], init)
+	return n
+}
+
+// TODO(josharian): combine this with its caller and simplify
+func reduceSlice(n *ir.SliceExpr) ir.Node {
+	low, high, max := n.SliceBounds()
+	if high != nil && high.Op() == ir.OLEN && ir.SameSafeExpr(n.X, high.(*ir.UnaryExpr).X) {
+		// Reduce x[i:len(x)] to x[i:].
+		high = nil
+	}
+	n.SetSliceBounds(low, high, max)
+	if (n.Op() == ir.OSLICE || n.Op() == ir.OSLICESTR) && low == nil && high == nil {
+		// Reduce x[:] to x.
+		if base.Debug.Slice > 0 {
+			base.Warn("slice: omit slice operation")
+		}
+		return n.X
+	}
+	return n
+}
+
+// return 1 if integer n must be in range [0, max), 0 otherwise
+func bounded(n ir.Node, max int64) bool {
+	if n.Type() == nil || !n.Type().IsInteger() {
+		return false
+	}
+
+	sign := n.Type().IsSigned()
+	bits := int32(8 * n.Type().Width)
+
+	if ir.IsSmallIntConst(n) {
+		v := ir.Int64Val(n)
+		return 0 <= v && v < max
+	}
+
+	switch n.Op() {
+	case ir.OAND, ir.OANDNOT:
+		n := n.(*ir.BinaryExpr)
+		v := int64(-1)
+		switch {
+		case ir.IsSmallIntConst(n.X):
+			v = ir.Int64Val(n.X)
+		case ir.IsSmallIntConst(n.Y):
+			v = ir.Int64Val(n.Y)
+			if n.Op() == ir.OANDNOT {
+				v = ^v
+				if !sign {
+					v &= 1<<uint(bits) - 1
+				}
+			}
+		}
+		if 0 <= v && v < max {
+			return true
+		}
+
+	case ir.OMOD:
+		n := n.(*ir.BinaryExpr)
+		if !sign && ir.IsSmallIntConst(n.Y) {
+			v := ir.Int64Val(n.Y)
+			if 0 <= v && v <= max {
+				return true
+			}
+		}
+
+	case ir.ODIV:
+		n := n.(*ir.BinaryExpr)
+		if !sign && ir.IsSmallIntConst(n.Y) {
+			v := ir.Int64Val(n.Y)
+			for bits > 0 && v >= 2 {
+				bits--
+				v >>= 1
+			}
+		}
+
+	case ir.ORSH:
+		n := n.(*ir.BinaryExpr)
+		if !sign && ir.IsSmallIntConst(n.Y) {
+			v := ir.Int64Val(n.Y)
+			if v > int64(bits) {
+				return true
+			}
+			bits -= int32(v)
+		}
+	}
+
+	if !sign && bits <= 62 && 1<<uint(bits) <= max {
+		return true
+	}
+
+	return false
+}
+
+// usemethod checks interface method calls for uses of reflect.Type.Method.
+func usemethod(n *ir.CallExpr) {
+	t := n.X.Type()
+
+	// Looking for either of:
+	//	Method(int) reflect.Method
+	//	MethodByName(string) (reflect.Method, bool)
+	//
+	// TODO(crawshaw): improve precision of match by working out
+	//                 how to check the method name.
+	if n := t.NumParams(); n != 1 {
+		return
+	}
+	if n := t.NumResults(); n != 1 && n != 2 {
+		return
+	}
+	p0 := t.Params().Field(0)
+	res0 := t.Results().Field(0)
+	var res1 *types.Field
+	if t.NumResults() == 2 {
+		res1 = t.Results().Field(1)
+	}
+
+	if res1 == nil {
+		if p0.Type.Kind() != types.TINT {
+			return
+		}
+	} else {
+		if !p0.Type.IsString() {
+			return
+		}
+		if !res1.Type.IsBoolean() {
+			return
+		}
+	}
+
+	// Note: Don't rely on res0.Type.String() since its formatting depends on multiple factors
+	//       (including global variables such as numImports - was issue #19028).
+	// Also need to check for reflect package itself (see Issue #38515).
+	if s := res0.Type.Sym(); s != nil && s.Name == "Method" && types.IsReflectPkg(s.Pkg) {
+		ir.CurFunc.SetReflectMethod(true)
+		// The LSym is initialized at this point. We need to set the attribute on the LSym.
+		ir.CurFunc.LSym.Set(obj.AttrReflectMethod, true)
+	}
+}
+
+func usefield(n *ir.SelectorExpr) {
+	if objabi.Fieldtrack_enabled == 0 {
+		return
+	}
+
+	switch n.Op() {
+	default:
+		base.Fatalf("usefield %v", n.Op())
+
+	case ir.ODOT, ir.ODOTPTR:
+		break
+	}
+	if n.Sel == nil {
+		// No field name.  This DOTPTR was built by the compiler for access
+		// to runtime data structures.  Ignore.
+		return
+	}
+
+	t := n.X.Type()
+	if t.IsPtr() {
+		t = t.Elem()
+	}
+	field := n.Selection
+	if field == nil {
+		base.Fatalf("usefield %v %v without paramfld", n.X.Type(), n.Sel)
+	}
+	if field.Sym != n.Sel || field.Offset != n.Offset {
+		base.Fatalf("field inconsistency: %v,%v != %v,%v", field.Sym, field.Offset, n.Sel, n.Offset)
+	}
+	if !strings.Contains(field.Note, "go:\"track\"") {
+		return
+	}
+
+	outer := n.X.Type()
+	if outer.IsPtr() {
+		outer = outer.Elem()
+	}
+	if outer.Sym() == nil {
+		base.Errorf("tracked field must be in named struct type")
+	}
+	if !types.IsExported(field.Sym.Name) {
+		base.Errorf("tracked field must be exported (upper case)")
+	}
+
+	sym := reflectdata.TrackSym(outer, field)
+	if ir.CurFunc.FieldTrack == nil {
+		ir.CurFunc.FieldTrack = make(map[*types.Sym]struct{})
+	}
+	ir.CurFunc.FieldTrack[sym] = struct{}{}
+}
diff --git a/src/cmd/compile/internal/walk/range.go b/src/cmd/compile/internal/walk/range.go
index ea23761a39..98a3dc23f9 100644
--- a/src/cmd/compile/internal/walk/range.go
+++ b/src/cmd/compile/internal/walk/range.go
@@ -32,11 +32,11 @@ func cheapComputableIndex(width int64) bool {
 	return false
 }
 
-// walkrange transforms various forms of ORANGE into
+// walkRange transforms various forms of ORANGE into
 // simpler forms.  The result must be assigned back to n.
 // Node n may also be modified in place, and may also be
 // the returned node.
-func walkrange(nrange *ir.RangeStmt) ir.Node {
+func walkRange(nrange *ir.RangeStmt) ir.Node {
 	if isMapClear(nrange) {
 		m := nrange.X
 		lno := ir.SetPos(m)
@@ -325,7 +325,7 @@ func walkrange(nrange *ir.RangeStmt) ir.Node {
 		n = ifGuard
 	}
 
-	n = walkstmt(n)
+	n = walkStmt(n)
 
 	base.Pos = lno
 	return n
@@ -387,7 +387,7 @@ func mapClear(m ir.Node) ir.Node {
 	fn := typecheck.LookupRuntime("mapclear")
 	fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem())
 	n := mkcall1(fn, nil, nil, reflectdata.TypePtr(t), m)
-	return walkstmt(typecheck.Stmt(n))
+	return walkStmt(typecheck.Stmt(n))
 }
 
 // Lower n into runtime·memclr if possible, for
@@ -477,7 +477,7 @@ func arrayClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
 	n.Cond = typecheck.Expr(n.Cond)
 	n.Cond = typecheck.DefaultLit(n.Cond, nil)
 	typecheck.Stmts(n.Body)
-	return walkstmt(n)
+	return walkStmt(n)
 }
 
 // addptr returns (*T)(uintptr(p) + n).
diff --git a/src/cmd/compile/internal/walk/select.go b/src/cmd/compile/internal/walk/select.go
index 006833eb7b..438131b294 100644
--- a/src/cmd/compile/internal/walk/select.go
+++ b/src/cmd/compile/internal/walk/select.go
@@ -11,7 +11,7 @@ import (
 	"cmd/compile/internal/types"
 )
 
-func walkselect(sel *ir.SelectStmt) {
+func walkSelect(sel *ir.SelectStmt) {
 	lno := ir.SetPos(sel)
 	if len(sel.Compiled) != 0 {
 		base.Fatalf("double walkselect")
@@ -20,16 +20,16 @@ func walkselect(sel *ir.SelectStmt) {
 	init := sel.Init()
 	sel.PtrInit().Set(nil)
 
-	init = append(init, walkselectcases(sel.Cases)...)
+	init = append(init, walkSelectCases(sel.Cases)...)
 	sel.Cases = ir.Nodes{}
 
 	sel.Compiled.Set(init)
-	walkstmtlist(sel.Compiled)
+	walkStmtList(sel.Compiled)
 
 	base.Pos = lno
 }
 
-func walkselectcases(cases ir.Nodes) []ir.Node {
+func walkSelectCases(cases ir.Nodes) []ir.Node {
 	ncas := len(cases)
 	sellineno := base.Pos
 
diff --git a/src/cmd/compile/internal/walk/stmt.go b/src/cmd/compile/internal/walk/stmt.go
new file mode 100644
index 0000000000..3fe7e103aa
--- /dev/null
+++ b/src/cmd/compile/internal/walk/stmt.go
@@ -0,0 +1,315 @@
+// Copyright 2009 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 walk
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
+)
+
+// The result of walkStmt MUST be assigned back to n, e.g.
+// 	n.Left = walkStmt(n.Left)
+func walkStmt(n ir.Node) ir.Node {
+	if n == nil {
+		return n
+	}
+
+	ir.SetPos(n)
+
+	walkStmtList(n.Init())
+
+	switch n.Op() {
+	default:
+		if n.Op() == ir.ONAME {
+			n := n.(*ir.Name)
+			base.Errorf("%v is not a top level statement", n.Sym())
+		} else {
+			base.Errorf("%v is not a top level statement", n.Op())
+		}
+		ir.Dump("nottop", n)
+		return n
+
+	case ir.OAS,
+		ir.OASOP,
+		ir.OAS2,
+		ir.OAS2DOTTYPE,
+		ir.OAS2RECV,
+		ir.OAS2FUNC,
+		ir.OAS2MAPR,
+		ir.OCLOSE,
+		ir.OCOPY,
+		ir.OCALLMETH,
+		ir.OCALLINTER,
+		ir.OCALL,
+		ir.OCALLFUNC,
+		ir.ODELETE,
+		ir.OSEND,
+		ir.OPRINT,
+		ir.OPRINTN,
+		ir.OPANIC,
+		ir.ORECOVER,
+		ir.OGETG:
+		if n.Typecheck() == 0 {
+			base.Fatalf("missing typecheck: %+v", n)
+		}
+		init := n.Init()
+		n.PtrInit().Set(nil)
+		n = walkExpr(n, &init)
+		if n.Op() == ir.ONAME {
+			// copy rewrote to a statement list and a temp for the length.
+			// Throw away the temp to avoid plain values as statements.
+			n = ir.NewBlockStmt(n.Pos(), init)
+			init.Set(nil)
+		}
+		if len(init) > 0 {
+			switch n.Op() {
+			case ir.OAS, ir.OAS2, ir.OBLOCK:
+				n.PtrInit().Prepend(init...)
+
+			default:
+				init.Append(n)
+				n = ir.NewBlockStmt(n.Pos(), init)
+			}
+		}
+		return n
+
+	// special case for a receive where we throw away
+	// the value received.
+	case ir.ORECV:
+		n := n.(*ir.UnaryExpr)
+		return walkRecv(n)
+
+	case ir.OBREAK,
+		ir.OCONTINUE,
+		ir.OFALL,
+		ir.OGOTO,
+		ir.OLABEL,
+		ir.ODCLCONST,
+		ir.ODCLTYPE,
+		ir.OCHECKNIL,
+		ir.OVARDEF,
+		ir.OVARKILL,
+		ir.OVARLIVE:
+		return n
+
+	case ir.ODCL:
+		n := n.(*ir.Decl)
+		return walkDecl(n)
+
+	case ir.OBLOCK:
+		n := n.(*ir.BlockStmt)
+		walkStmtList(n.List)
+		return n
+
+	case ir.OCASE:
+		base.Errorf("case statement out of place")
+		panic("unreachable")
+
+	case ir.ODEFER:
+		n := n.(*ir.GoDeferStmt)
+		ir.CurFunc.SetHasDefer(true)
+		ir.CurFunc.NumDefers++
+		if ir.CurFunc.NumDefers > maxOpenDefers {
+			// Don't allow open-coded defers if there are more than
+			// 8 defers in the function, since we use a single
+			// byte to record active defers.
+			ir.CurFunc.SetOpenCodedDeferDisallowed(true)
+		}
+		if n.Esc() != ir.EscNever {
+			// If n.Esc is not EscNever, then this defer occurs in a loop,
+			// so open-coded defers cannot be used in this function.
+			ir.CurFunc.SetOpenCodedDeferDisallowed(true)
+		}
+		fallthrough
+	case ir.OGO:
+		n := n.(*ir.GoDeferStmt)
+		return walkGoDefer(n)
+
+	case ir.OFOR, ir.OFORUNTIL:
+		n := n.(*ir.ForStmt)
+		return walkFor(n)
+
+	case ir.OIF:
+		n := n.(*ir.IfStmt)
+		return walkIf(n)
+
+	case ir.ORETURN:
+		n := n.(*ir.ReturnStmt)
+		return walkReturn(n)
+
+	case ir.ORETJMP:
+		n := n.(*ir.BranchStmt)
+		return n
+
+	case ir.OINLMARK:
+		n := n.(*ir.InlineMarkStmt)
+		return n
+
+	case ir.OSELECT:
+		n := n.(*ir.SelectStmt)
+		walkSelect(n)
+		return n
+
+	case ir.OSWITCH:
+		n := n.(*ir.SwitchStmt)
+		walkSwitch(n)
+		return n
+
+	case ir.ORANGE:
+		n := n.(*ir.RangeStmt)
+		return walkRange(n)
+	}
+
+	// No return! Each case must return (or panic),
+	// to avoid confusion about what gets returned
+	// in the presence of type assertions.
+}
+
+func walkStmtList(s []ir.Node) {
+	for i := range s {
+		s[i] = walkStmt(s[i])
+	}
+}
+
+// walkDecl walks an ODCL node.
+func walkDecl(n *ir.Decl) ir.Node {
+	v := n.X.(*ir.Name)
+	if v.Class_ == ir.PAUTOHEAP {
+		if base.Flag.CompilingRuntime {
+			base.Errorf("%v escapes to heap, not allowed in runtime", v)
+		}
+		nn := ir.NewAssignStmt(base.Pos, v.Name().Heapaddr, callnew(v.Type()))
+		nn.Def = true
+		return walkStmt(typecheck.Stmt(nn))
+	}
+	return n
+}
+
+// walkFor walks an OFOR or OFORUNTIL node.
+func walkFor(n *ir.ForStmt) ir.Node {
+	if n.Cond != nil {
+		walkStmtList(n.Cond.Init())
+		init := n.Cond.Init()
+		n.Cond.PtrInit().Set(nil)
+		n.Cond = walkExpr(n.Cond, &init)
+		n.Cond = ir.InitExpr(init, n.Cond)
+	}
+
+	n.Post = walkStmt(n.Post)
+	if n.Op() == ir.OFORUNTIL {
+		walkStmtList(n.Late)
+	}
+	walkStmtList(n.Body)
+	return n
+}
+
+// walkGoDefer walks an OGO or ODEFER node.
+func walkGoDefer(n *ir.GoDeferStmt) ir.Node {
+	var init ir.Nodes
+	switch call := n.Call; call.Op() {
+	case ir.OPRINT, ir.OPRINTN:
+		call := call.(*ir.CallExpr)
+		n.Call = wrapCall(call, &init)
+
+	case ir.ODELETE:
+		call := call.(*ir.CallExpr)
+		if mapfast(call.Args[0].Type()) == mapslow {
+			n.Call = wrapCall(call, &init)
+		} else {
+			n.Call = walkExpr(call, &init)
+		}
+
+	case ir.OCOPY:
+		call := call.(*ir.BinaryExpr)
+		n.Call = walkCopy(call, &init, true)
+
+	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
+		call := call.(*ir.CallExpr)
+		if len(call.Body) > 0 {
+			n.Call = wrapCall(call, &init)
+		} else {
+			n.Call = walkExpr(call, &init)
+		}
+
+	default:
+		n.Call = walkExpr(call, &init)
+	}
+	if len(init) > 0 {
+		init.Append(n)
+		return ir.NewBlockStmt(n.Pos(), init)
+	}
+	return n
+}
+
+// walkIf walks an OIF node.
+func walkIf(n *ir.IfStmt) ir.Node {
+	n.Cond = walkExpr(n.Cond, n.PtrInit())
+	walkStmtList(n.Body)
+	walkStmtList(n.Else)
+	return n
+}
+
+// The result of wrapCall MUST be assigned back to n, e.g.
+// 	n.Left = wrapCall(n.Left, init)
+func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
+	if len(n.Init()) != 0 {
+		walkStmtList(n.Init())
+		init.Append(n.PtrInit().Take()...)
+	}
+
+	isBuiltinCall := n.Op() != ir.OCALLFUNC && n.Op() != ir.OCALLMETH && n.Op() != ir.OCALLINTER
+
+	// Turn f(a, b, []T{c, d, e}...) back into f(a, b, c, d, e).
+	if !isBuiltinCall && n.IsDDD {
+		last := len(n.Args) - 1
+		if va := n.Args[last]; va.Op() == ir.OSLICELIT {
+			va := va.(*ir.CompLitExpr)
+			n.Args.Set(append(n.Args[:last], va.List...))
+			n.IsDDD = false
+		}
+	}
+
+	// origArgs keeps track of what argument is uintptr-unsafe/unsafe-uintptr conversion.
+	origArgs := make([]ir.Node, len(n.Args))
+	var funcArgs []*ir.Field
+	for i, arg := range n.Args {
+		s := typecheck.LookupNum("a", i)
+		if !isBuiltinCall && arg.Op() == ir.OCONVNOP && arg.Type().IsUintptr() && arg.(*ir.ConvExpr).X.Type().IsUnsafePtr() {
+			origArgs[i] = arg
+			arg = arg.(*ir.ConvExpr).X
+			n.Args[i] = arg
+		}
+		funcArgs = append(funcArgs, ir.NewField(base.Pos, s, nil, arg.Type()))
+	}
+	t := ir.NewFuncType(base.Pos, nil, funcArgs, nil)
+
+	wrapCall_prgen++
+	sym := typecheck.LookupNum("wrap·", wrapCall_prgen)
+	fn := typecheck.DeclFunc(sym, t)
+
+	args := ir.ParamNames(t.Type())
+	for i, origArg := range origArgs {
+		if origArg == nil {
+			continue
+		}
+		args[i] = ir.NewConvExpr(base.Pos, origArg.Op(), origArg.Type(), args[i])
+	}
+	call := ir.NewCallExpr(base.Pos, n.Op(), n.X, args)
+	if !isBuiltinCall {
+		call.SetOp(ir.OCALL)
+		call.IsDDD = n.IsDDD
+	}
+	fn.Body = []ir.Node{call}
+
+	typecheck.FinishFuncBody()
+
+	typecheck.Func(fn)
+	typecheck.Stmts(fn.Body)
+	typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
+
+	call = ir.NewCallExpr(base.Pos, ir.OCALL, fn.Nname, n.Args)
+	return walkExpr(typecheck.Stmt(call), init)
+}
diff --git a/src/cmd/compile/internal/walk/subr.go b/src/cmd/compile/internal/walk/subr.go
deleted file mode 100644
index bc65432d49..0000000000
--- a/src/cmd/compile/internal/walk/subr.go
+++ /dev/null
@@ -1,338 +0,0 @@
-// Copyright 2009 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 walk
-
-import (
-	"fmt"
-
-	"cmd/compile/internal/base"
-	"cmd/compile/internal/ir"
-	"cmd/compile/internal/ssagen"
-	"cmd/compile/internal/typecheck"
-	"cmd/compile/internal/types"
-	"cmd/internal/src"
-)
-
-// backingArrayPtrLen extracts the pointer and length from a slice or string.
-// This constructs two nodes referring to n, so n must be a cheapexpr.
-func backingArrayPtrLen(n ir.Node) (ptr, length ir.Node) {
-	var init ir.Nodes
-	c := cheapexpr(n, &init)
-	if c != n || len(init) != 0 {
-		base.Fatalf("backingArrayPtrLen not cheap: %v", n)
-	}
-	ptr = ir.NewUnaryExpr(base.Pos, ir.OSPTR, n)
-	if n.Type().IsString() {
-		ptr.SetType(types.Types[types.TUINT8].PtrTo())
-	} else {
-		ptr.SetType(n.Type().Elem().PtrTo())
-	}
-	length = ir.NewUnaryExpr(base.Pos, ir.OLEN, n)
-	length.SetType(types.Types[types.TINT])
-	return ptr, length
-}
-
-// updateHasCall checks whether expression n contains any function
-// calls and sets the n.HasCall flag if so.
-func updateHasCall(n ir.Node) {
-	if n == nil {
-		return
-	}
-	n.SetHasCall(calcHasCall(n))
-}
-
-func calcHasCall(n ir.Node) bool {
-	if len(n.Init()) != 0 {
-		// TODO(mdempsky): This seems overly conservative.
-		return true
-	}
-
-	switch n.Op() {
-	default:
-		base.Fatalf("calcHasCall %+v", n)
-		panic("unreachable")
-
-	case ir.OLITERAL, ir.ONIL, ir.ONAME, ir.OTYPE, ir.ONAMEOFFSET:
-		if n.HasCall() {
-			base.Fatalf("OLITERAL/ONAME/OTYPE should never have calls: %+v", n)
-		}
-		return false
-	case ir.OCALL, ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
-		return true
-	case ir.OANDAND, ir.OOROR:
-		// hard with instrumented code
-		n := n.(*ir.LogicalExpr)
-		if base.Flag.Cfg.Instrumenting {
-			return true
-		}
-		return n.X.HasCall() || n.Y.HasCall()
-	case ir.OINDEX, ir.OSLICE, ir.OSLICEARR, ir.OSLICE3, ir.OSLICE3ARR, ir.OSLICESTR,
-		ir.ODEREF, ir.ODOTPTR, ir.ODOTTYPE, ir.ODIV, ir.OMOD:
-		// These ops might panic, make sure they are done
-		// before we start marshaling args for a call. See issue 16760.
-		return true
-
-	// When using soft-float, these ops might be rewritten to function calls
-	// so we ensure they are evaluated first.
-	case ir.OADD, ir.OSUB, ir.OMUL:
-		n := n.(*ir.BinaryExpr)
-		if ssagen.Arch.SoftFloat && (types.IsFloat[n.Type().Kind()] || types.IsComplex[n.Type().Kind()]) {
-			return true
-		}
-		return n.X.HasCall() || n.Y.HasCall()
-	case ir.ONEG:
-		n := n.(*ir.UnaryExpr)
-		if ssagen.Arch.SoftFloat && (types.IsFloat[n.Type().Kind()] || types.IsComplex[n.Type().Kind()]) {
-			return true
-		}
-		return n.X.HasCall()
-	case ir.OLT, ir.OEQ, ir.ONE, ir.OLE, ir.OGE, ir.OGT:
-		n := n.(*ir.BinaryExpr)
-		if ssagen.Arch.SoftFloat && (types.IsFloat[n.X.Type().Kind()] || types.IsComplex[n.X.Type().Kind()]) {
-			return true
-		}
-		return n.X.HasCall() || n.Y.HasCall()
-	case ir.OCONV:
-		n := n.(*ir.ConvExpr)
-		if ssagen.Arch.SoftFloat && ((types.IsFloat[n.Type().Kind()] || types.IsComplex[n.Type().Kind()]) || (types.IsFloat[n.X.Type().Kind()] || types.IsComplex[n.X.Type().Kind()])) {
-			return true
-		}
-		return n.X.HasCall()
-
-	case ir.OAND, ir.OANDNOT, ir.OLSH, ir.OOR, ir.ORSH, ir.OXOR, ir.OCOPY, ir.OCOMPLEX, ir.OEFACE:
-		n := n.(*ir.BinaryExpr)
-		return n.X.HasCall() || n.Y.HasCall()
-
-	case ir.OAS:
-		n := n.(*ir.AssignStmt)
-		return n.X.HasCall() || n.Y != nil && n.Y.HasCall()
-
-	case ir.OADDR:
-		n := n.(*ir.AddrExpr)
-		return n.X.HasCall()
-	case ir.OPAREN:
-		n := n.(*ir.ParenExpr)
-		return n.X.HasCall()
-	case ir.OBITNOT, ir.ONOT, ir.OPLUS, ir.ORECV,
-		ir.OALIGNOF, ir.OCAP, ir.OCLOSE, ir.OIMAG, ir.OLEN, ir.ONEW,
-		ir.OOFFSETOF, ir.OPANIC, ir.OREAL, ir.OSIZEOF,
-		ir.OCHECKNIL, ir.OCFUNC, ir.OIDATA, ir.OITAB, ir.ONEWOBJ, ir.OSPTR, ir.OVARDEF, ir.OVARKILL, ir.OVARLIVE:
-		n := n.(*ir.UnaryExpr)
-		return n.X.HasCall()
-	case ir.ODOT, ir.ODOTMETH, ir.ODOTINTER:
-		n := n.(*ir.SelectorExpr)
-		return n.X.HasCall()
-
-	case ir.OGETG, ir.OCLOSUREREAD, ir.OMETHEXPR:
-		return false
-
-	// TODO(rsc): These look wrong in various ways but are what calcHasCall has always done.
-	case ir.OADDSTR:
-		// TODO(rsc): This used to check left and right, which are not part of OADDSTR.
-		return false
-	case ir.OBLOCK:
-		// TODO(rsc): Surely the block's statements matter.
-		return false
-	case ir.OCONVIFACE, ir.OCONVNOP, ir.OBYTES2STR, ir.OBYTES2STRTMP, ir.ORUNES2STR, ir.OSTR2BYTES, ir.OSTR2BYTESTMP, ir.OSTR2RUNES, ir.ORUNESTR:
-		// TODO(rsc): Some conversions are themselves calls, no?
-		n := n.(*ir.ConvExpr)
-		return n.X.HasCall()
-	case ir.ODOTTYPE2:
-		// TODO(rsc): Shouldn't this be up with ODOTTYPE above?
-		n := n.(*ir.TypeAssertExpr)
-		return n.X.HasCall()
-	case ir.OSLICEHEADER:
-		// TODO(rsc): What about len and cap?
-		n := n.(*ir.SliceHeaderExpr)
-		return n.Ptr.HasCall()
-	case ir.OAS2DOTTYPE, ir.OAS2FUNC:
-		// TODO(rsc): Surely we need to check List and Rlist.
-		return false
-	}
-}
-
-func badtype(op ir.Op, tl, tr *types.Type) {
-	var s string
-	if tl != nil {
-		s += fmt.Sprintf("\n\t%v", tl)
-	}
-	if tr != nil {
-		s += fmt.Sprintf("\n\t%v", tr)
-	}
-
-	// common mistake: *struct and *interface.
-	if tl != nil && tr != nil && tl.IsPtr() && tr.IsPtr() {
-		if tl.Elem().IsStruct() && tr.Elem().IsInterface() {
-			s += "\n\t(*struct vs *interface)"
-		} else if tl.Elem().IsInterface() && tr.Elem().IsStruct() {
-			s += "\n\t(*interface vs *struct)"
-		}
-	}
-
-	base.Errorf("illegal types for operand: %v%s", op, s)
-}
-
-// brcom returns !(op).
-// For example, brcom(==) is !=.
-func brcom(op ir.Op) ir.Op {
-	switch op {
-	case ir.OEQ:
-		return ir.ONE
-	case ir.ONE:
-		return ir.OEQ
-	case ir.OLT:
-		return ir.OGE
-	case ir.OGT:
-		return ir.OLE
-	case ir.OLE:
-		return ir.OGT
-	case ir.OGE:
-		return ir.OLT
-	}
-	base.Fatalf("brcom: no com for %v\n", op)
-	return op
-}
-
-// brrev returns reverse(op).
-// For example, Brrev(<) is >.
-func brrev(op ir.Op) ir.Op {
-	switch op {
-	case ir.OEQ:
-		return ir.OEQ
-	case ir.ONE:
-		return ir.ONE
-	case ir.OLT:
-		return ir.OGT
-	case ir.OGT:
-		return ir.OLT
-	case ir.OLE:
-		return ir.OGE
-	case ir.OGE:
-		return ir.OLE
-	}
-	base.Fatalf("brrev: no rev for %v\n", op)
-	return op
-}
-
-// return side effect-free n, appending side effects to init.
-// result is assignable if n is.
-func safeexpr(n ir.Node, init *ir.Nodes) ir.Node {
-	if n == nil {
-		return nil
-	}
-
-	if len(n.Init()) != 0 {
-		walkstmtlist(n.Init())
-		init.Append(n.PtrInit().Take()...)
-	}
-
-	switch n.Op() {
-	case ir.ONAME, ir.OLITERAL, ir.ONIL, ir.ONAMEOFFSET:
-		return n
-
-	case ir.OLEN, ir.OCAP:
-		n := n.(*ir.UnaryExpr)
-		l := safeexpr(n.X, init)
-		if l == n.X {
-			return n
-		}
-		a := ir.Copy(n).(*ir.UnaryExpr)
-		a.X = l
-		return walkexpr(typecheck.Expr(a), init)
-
-	case ir.ODOT, ir.ODOTPTR:
-		n := n.(*ir.SelectorExpr)
-		l := safeexpr(n.X, init)
-		if l == n.X {
-			return n
-		}
-		a := ir.Copy(n).(*ir.SelectorExpr)
-		a.X = l
-		return walkexpr(typecheck.Expr(a), init)
-
-	case ir.ODEREF:
-		n := n.(*ir.StarExpr)
-		l := safeexpr(n.X, init)
-		if l == n.X {
-			return n
-		}
-		a := ir.Copy(n).(*ir.StarExpr)
-		a.X = l
-		return walkexpr(typecheck.Expr(a), init)
-
-	case ir.OINDEX, ir.OINDEXMAP:
-		n := n.(*ir.IndexExpr)
-		l := safeexpr(n.X, init)
-		r := safeexpr(n.Index, init)
-		if l == n.X && r == n.Index {
-			return n
-		}
-		a := ir.Copy(n).(*ir.IndexExpr)
-		a.X = l
-		a.Index = r
-		return walkexpr(typecheck.Expr(a), init)
-
-	case ir.OSTRUCTLIT, ir.OARRAYLIT, ir.OSLICELIT:
-		n := n.(*ir.CompLitExpr)
-		if isStaticCompositeLiteral(n) {
-			return n
-		}
-	}
-
-	// make a copy; must not be used as an lvalue
-	if ir.IsAssignable(n) {
-		base.Fatalf("missing lvalue case in safeexpr: %v", n)
-	}
-	return cheapexpr(n, init)
-}
-
-func copyexpr(n ir.Node, t *types.Type, init *ir.Nodes) ir.Node {
-	l := typecheck.Temp(t)
-	appendWalkStmt(init, ir.NewAssignStmt(base.Pos, l, n))
-	return l
-}
-
-// return side-effect free and cheap n, appending side effects to init.
-// result may not be assignable.
-func cheapexpr(n ir.Node, init *ir.Nodes) ir.Node {
-	switch n.Op() {
-	case ir.ONAME, ir.OLITERAL, ir.ONIL:
-		return n
-	}
-
-	return copyexpr(n, n.Type(), init)
-}
-
-// itabType loads the _type field from a runtime.itab struct.
-func itabType(itab ir.Node) ir.Node {
-	typ := ir.NewSelectorExpr(base.Pos, ir.ODOTPTR, itab, nil)
-	typ.SetType(types.NewPtr(types.Types[types.TUINT8]))
-	typ.SetTypecheck(1)
-	typ.Offset = int64(types.PtrSize) // offset of _type in runtime.itab
-	typ.SetBounded(true)              // guaranteed not to fault
-	return typ
-}
-
-// ifaceData loads the data field from an interface.
-// The concrete type must be known to have type t.
-// It follows the pointer if !isdirectiface(t).
-func ifaceData(pos src.XPos, n ir.Node, t *types.Type) ir.Node {
-	if t.IsInterface() {
-		base.Fatalf("ifaceData interface: %v", t)
-	}
-	ptr := ir.NewUnaryExpr(pos, ir.OIDATA, n)
-	if types.IsDirectIface(t) {
-		ptr.SetType(t)
-		ptr.SetTypecheck(1)
-		return ptr
-	}
-	ptr.SetType(types.NewPtr(t))
-	ptr.SetTypecheck(1)
-	ind := ir.NewStarExpr(pos, ptr)
-	ind.SetType(t)
-	ind.SetTypecheck(1)
-	ind.SetBounded(true)
-	return ind
-}
diff --git a/src/cmd/compile/internal/walk/switch.go b/src/cmd/compile/internal/walk/switch.go
index 9becd0e404..360086ec79 100644
--- a/src/cmd/compile/internal/walk/switch.go
+++ b/src/cmd/compile/internal/walk/switch.go
@@ -16,23 +16,23 @@ import (
 	"cmd/internal/src"
 )
 
-// walkswitch walks a switch statement.
-func walkswitch(sw *ir.SwitchStmt) {
+// walkSwitch walks a switch statement.
+func walkSwitch(sw *ir.SwitchStmt) {
 	// Guard against double walk, see #25776.
 	if len(sw.Cases) == 0 && len(sw.Compiled) > 0 {
 		return // Was fatal, but eliminating every possible source of double-walking is hard
 	}
 
 	if sw.Tag != nil && sw.Tag.Op() == ir.OTYPESW {
-		walkTypeSwitch(sw)
+		walkSwitchType(sw)
 	} else {
-		walkExprSwitch(sw)
+		walkSwitchExpr(sw)
 	}
 }
 
-// walkExprSwitch generates an AST implementing sw.  sw is an
+// walkSwitchExpr generates an AST implementing sw.  sw is an
 // expression switch.
-func walkExprSwitch(sw *ir.SwitchStmt) {
+func walkSwitchExpr(sw *ir.SwitchStmt) {
 	lno := ir.SetPos(sw)
 
 	cond := sw.Tag
@@ -57,9 +57,9 @@ func walkExprSwitch(sw *ir.SwitchStmt) {
 		cond.SetOp(ir.OBYTES2STRTMP)
 	}
 
-	cond = walkexpr(cond, sw.PtrInit())
+	cond = walkExpr(cond, sw.PtrInit())
 	if cond.Op() != ir.OLITERAL && cond.Op() != ir.ONIL {
-		cond = copyexpr(cond, cond.Type(), &sw.Compiled)
+		cond = copyExpr(cond, cond.Type(), &sw.Compiled)
 	}
 
 	base.Pos = lno
@@ -107,7 +107,7 @@ func walkExprSwitch(sw *ir.SwitchStmt) {
 	s.Emit(&sw.Compiled)
 	sw.Compiled.Append(defaultGoto)
 	sw.Compiled.Append(body.Take()...)
-	walkstmtlist(sw.Compiled)
+	walkStmtList(sw.Compiled)
 }
 
 // An exprSwitch walks an expression switch.
@@ -287,15 +287,15 @@ func endsInFallthrough(stmts []ir.Node) (bool, src.XPos) {
 	return stmts[i].Op() == ir.OFALL, stmts[i].Pos()
 }
 
-// walkTypeSwitch generates an AST that implements sw, where sw is a
+// walkSwitchType generates an AST that implements sw, where sw is a
 // type switch.
-func walkTypeSwitch(sw *ir.SwitchStmt) {
+func walkSwitchType(sw *ir.SwitchStmt) {
 	var s typeSwitch
 	s.facename = sw.Tag.(*ir.TypeSwitchGuard).X
 	sw.Tag = nil
 
-	s.facename = walkexpr(s.facename, sw.PtrInit())
-	s.facename = copyexpr(s.facename, s.facename.Type(), &sw.Compiled)
+	s.facename = walkExpr(s.facename, sw.PtrInit())
+	s.facename = copyExpr(s.facename, s.facename.Type(), &sw.Compiled)
 	s.okname = typecheck.Temp(types.Types[types.TBOOL])
 
 	// Get interface descriptor word.
@@ -327,7 +327,7 @@ func walkTypeSwitch(sw *ir.SwitchStmt) {
 		dotHash.Offset = int64(2 * types.PtrSize) // offset of hash in runtime.itab
 	}
 	dotHash.SetBounded(true) // guaranteed not to fault
-	s.hashname = copyexpr(dotHash, dotHash.Type(), &sw.Compiled)
+	s.hashname = copyExpr(dotHash, dotHash.Type(), &sw.Compiled)
 
 	br := ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)
 	var defaultGoto, nilGoto ir.Node
@@ -409,7 +409,7 @@ func walkTypeSwitch(sw *ir.SwitchStmt) {
 	sw.Compiled.Append(defaultGoto)
 	sw.Compiled.Append(body.Take()...)
 
-	walkstmtlist(sw.Compiled)
+	walkStmtList(sw.Compiled)
 }
 
 // A typeSwitch walks a type switch.
diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index cb3018a4ac..9dda367b4d 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -5,25 +5,17 @@
 package walk
 
 import (
-	"encoding/binary"
 	"errors"
 	"fmt"
-	"go/constant"
-	"go/token"
 	"strings"
 
 	"cmd/compile/internal/base"
-	"cmd/compile/internal/escape"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/reflectdata"
 	"cmd/compile/internal/ssagen"
-	"cmd/compile/internal/staticdata"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
-	"cmd/internal/obj"
-	"cmd/internal/objabi"
 	"cmd/internal/src"
-	"cmd/internal/sys"
 )
 
 // The constant is known to runtime.
@@ -79,7 +71,7 @@ func Walk(fn *ir.Func) {
 	if base.Errors() > errorsBefore {
 		return
 	}
-	walkstmtlist(ir.CurFunc.Body)
+	walkStmtList(ir.CurFunc.Body)
 	if base.Flag.W != 0 {
 		s := fmt.Sprintf("after walk %v", ir.CurFunc.Sym())
 		ir.DumpList(s, ir.CurFunc.Body)
@@ -97,12 +89,6 @@ func Walk(fn *ir.Func) {
 	}
 }
 
-func walkstmtlist(s []ir.Node) {
-	for i := range s {
-		s[i] = walkstmt(s[i])
-	}
-}
-
 func paramoutheap(fn *ir.Func) bool {
 	for _, ln := range fn.Dcl {
 		switch ln.Class_ {
@@ -120,3596 +106,257 @@ func paramoutheap(fn *ir.Func) bool {
 	return false
 }
 
-// The result of walkstmt MUST be assigned back to n, e.g.
-// 	n.Left = walkstmt(n.Left)
-func walkstmt(n ir.Node) ir.Node {
-	if n == nil {
-		return n
+// walkRecv walks an ORECV node.
+func walkRecv(n *ir.UnaryExpr) ir.Node {
+	if n.Typecheck() == 0 {
+		base.Fatalf("missing typecheck: %+v", n)
 	}
+	init := n.Init()
+	n.PtrInit().Set(nil)
 
-	ir.SetPos(n)
+	n.X = walkExpr(n.X, &init)
+	call := walkExpr(mkcall1(chanfn("chanrecv1", 2, n.X.Type()), nil, &init, n.X, typecheck.NodNil()), &init)
+	return ir.InitExpr(init, call)
+}
 
-	walkstmtlist(n.Init())
+func convas(n *ir.AssignStmt, init *ir.Nodes) *ir.AssignStmt {
+	if n.Op() != ir.OAS {
+		base.Fatalf("convas: not OAS %v", n.Op())
+	}
+	defer updateHasCall(n)
 
-	switch n.Op() {
-	default:
-		if n.Op() == ir.ONAME {
-			n := n.(*ir.Name)
-			base.Errorf("%v is not a top level statement", n.Sym())
-		} else {
-			base.Errorf("%v is not a top level statement", n.Op())
-		}
-		ir.Dump("nottop", n)
-		return n
+	n.SetTypecheck(1)
 
-	case ir.OAS,
-		ir.OASOP,
-		ir.OAS2,
-		ir.OAS2DOTTYPE,
-		ir.OAS2RECV,
-		ir.OAS2FUNC,
-		ir.OAS2MAPR,
-		ir.OCLOSE,
-		ir.OCOPY,
-		ir.OCALLMETH,
-		ir.OCALLINTER,
-		ir.OCALL,
-		ir.OCALLFUNC,
-		ir.ODELETE,
-		ir.OSEND,
-		ir.OPRINT,
-		ir.OPRINTN,
-		ir.OPANIC,
-		ir.ORECOVER,
-		ir.OGETG:
-		if n.Typecheck() == 0 {
-			base.Fatalf("missing typecheck: %+v", n)
-		}
-		init := n.Init()
-		n.PtrInit().Set(nil)
-		n = walkexpr(n, &init)
-		if n.Op() == ir.ONAME {
-			// copy rewrote to a statement list and a temp for the length.
-			// Throw away the temp to avoid plain values as statements.
-			n = ir.NewBlockStmt(n.Pos(), init)
-			init.Set(nil)
-		}
-		if len(init) > 0 {
-			switch n.Op() {
-			case ir.OAS, ir.OAS2, ir.OBLOCK:
-				n.PtrInit().Prepend(init...)
-
-			default:
-				init.Append(n)
-				n = ir.NewBlockStmt(n.Pos(), init)
-			}
-		}
+	if n.X == nil || n.Y == nil {
 		return n
+	}
 
-	// special case for a receive where we throw away
-	// the value received.
-	case ir.ORECV:
-		n := n.(*ir.UnaryExpr)
-		if n.Typecheck() == 0 {
-			base.Fatalf("missing typecheck: %+v", n)
-		}
-		init := n.Init()
-		n.PtrInit().Set(nil)
-
-		n.X = walkexpr(n.X, &init)
-		call := walkexpr(mkcall1(chanfn("chanrecv1", 2, n.X.Type()), nil, &init, n.X, typecheck.NodNil()), &init)
-		return ir.InitExpr(init, call)
-
-	case ir.OBREAK,
-		ir.OCONTINUE,
-		ir.OFALL,
-		ir.OGOTO,
-		ir.OLABEL,
-		ir.ODCLCONST,
-		ir.ODCLTYPE,
-		ir.OCHECKNIL,
-		ir.OVARDEF,
-		ir.OVARKILL,
-		ir.OVARLIVE:
+	lt := n.X.Type()
+	rt := n.Y.Type()
+	if lt == nil || rt == nil {
 		return n
+	}
 
-	case ir.ODCL:
-		n := n.(*ir.Decl)
-		v := n.X.(*ir.Name)
-		if v.Class_ == ir.PAUTOHEAP {
-			if base.Flag.CompilingRuntime {
-				base.Errorf("%v escapes to heap, not allowed in runtime", v)
-			}
-			nn := ir.NewAssignStmt(base.Pos, v.Name().Heapaddr, callnew(v.Type()))
-			nn.Def = true
-			return walkstmt(typecheck.Stmt(nn))
-		}
+	if ir.IsBlank(n.X) {
+		n.Y = typecheck.DefaultLit(n.Y, nil)
 		return n
+	}
 
-	case ir.OBLOCK:
-		n := n.(*ir.BlockStmt)
-		walkstmtlist(n.List)
-		return n
+	if !types.Identical(lt, rt) {
+		n.Y = typecheck.AssignConv(n.Y, lt, "assignment")
+		n.Y = walkExpr(n.Y, init)
+	}
+	types.CalcSize(n.Y.Type())
 
-	case ir.OCASE:
-		base.Errorf("case statement out of place")
-		panic("unreachable")
+	return n
+}
+
+var stop = errors.New("stop")
 
-	case ir.ODEFER:
-		n := n.(*ir.GoDeferStmt)
-		ir.CurFunc.SetHasDefer(true)
-		ir.CurFunc.NumDefers++
-		if ir.CurFunc.NumDefers > maxOpenDefers {
-			// Don't allow open-coded defers if there are more than
-			// 8 defers in the function, since we use a single
-			// byte to record active defers.
-			ir.CurFunc.SetOpenCodedDeferDisallowed(true)
+// paramstoheap returns code to allocate memory for heap-escaped parameters
+// and to copy non-result parameters' values from the stack.
+func paramstoheap(params *types.Type) []ir.Node {
+	var nn []ir.Node
+	for _, t := range params.Fields().Slice() {
+		v := ir.AsNode(t.Nname)
+		if v != nil && v.Sym() != nil && strings.HasPrefix(v.Sym().Name, "~r") { // unnamed result
+			v = nil
 		}
-		if n.Esc() != ir.EscNever {
-			// If n.Esc is not EscNever, then this defer occurs in a loop,
-			// so open-coded defers cannot be used in this function.
-			ir.CurFunc.SetOpenCodedDeferDisallowed(true)
+		if v == nil {
+			continue
 		}
-		fallthrough
-	case ir.OGO:
-		n := n.(*ir.GoDeferStmt)
-		var init ir.Nodes
-		switch call := n.Call; call.Op() {
-		case ir.OPRINT, ir.OPRINTN:
-			call := call.(*ir.CallExpr)
-			n.Call = wrapCall(call, &init)
-
-		case ir.ODELETE:
-			call := call.(*ir.CallExpr)
-			if mapfast(call.Args[0].Type()) == mapslow {
-				n.Call = wrapCall(call, &init)
-			} else {
-				n.Call = walkexpr(call, &init)
-			}
 
-		case ir.OCOPY:
-			call := call.(*ir.BinaryExpr)
-			n.Call = copyany(call, &init, true)
-
-		case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
-			call := call.(*ir.CallExpr)
-			if len(call.Body) > 0 {
-				n.Call = wrapCall(call, &init)
-			} else {
-				n.Call = walkexpr(call, &init)
+		if stackcopy := v.Name().Stackcopy; stackcopy != nil {
+			nn = append(nn, walkStmt(ir.NewDecl(base.Pos, ir.ODCL, v)))
+			if stackcopy.Class_ == ir.PPARAM {
+				nn = append(nn, walkStmt(typecheck.Stmt(ir.NewAssignStmt(base.Pos, v, stackcopy))))
 			}
-
-		default:
-			n.Call = walkexpr(call, &init)
 		}
-		if len(init) > 0 {
-			init.Append(n)
-			return ir.NewBlockStmt(n.Pos(), init)
-		}
-		return n
+	}
 
-	case ir.OFOR, ir.OFORUNTIL:
-		n := n.(*ir.ForStmt)
-		if n.Cond != nil {
-			walkstmtlist(n.Cond.Init())
-			init := n.Cond.Init()
-			n.Cond.PtrInit().Set(nil)
-			n.Cond = walkexpr(n.Cond, &init)
-			n.Cond = ir.InitExpr(init, n.Cond)
-		}
+	return nn
+}
 
-		n.Post = walkstmt(n.Post)
-		if n.Op() == ir.OFORUNTIL {
-			walkstmtlist(n.Late)
+// zeroResults zeros the return values at the start of the function.
+// We need to do this very early in the function.  Defer might stop a
+// panic and show the return values as they exist at the time of
+// panic.  For precise stacks, the garbage collector assumes results
+// are always live, so we need to zero them before any allocations,
+// even allocations to move params/results to the heap.
+// The generated code is added to Curfn's Enter list.
+func zeroResults() {
+	for _, f := range ir.CurFunc.Type().Results().Fields().Slice() {
+		v := ir.AsNode(f.Nname)
+		if v != nil && v.Name().Heapaddr != nil {
+			// The local which points to the return value is the
+			// thing that needs zeroing. This is already handled
+			// by a Needzero annotation in plive.go:livenessepilogue.
+			continue
 		}
-		walkstmtlist(n.Body)
-		return n
-
-	case ir.OIF:
-		n := n.(*ir.IfStmt)
-		n.Cond = walkexpr(n.Cond, n.PtrInit())
-		walkstmtlist(n.Body)
-		walkstmtlist(n.Else)
-		return n
-
-	case ir.ORETURN:
-		n := n.(*ir.ReturnStmt)
-		ir.CurFunc.NumReturns++
-		if len(n.Results) == 0 {
-			return n
+		if ir.IsParamHeapCopy(v) {
+			// TODO(josharian/khr): Investigate whether we can switch to "continue" here,
+			// and document more in either case.
+			// In the review of CL 114797, Keith wrote (roughly):
+			// I don't think the zeroing below matters.
+			// The stack return value will never be marked as live anywhere in the function.
+			// It is not written to until deferreturn returns.
+			v = v.Name().Stackcopy
 		}
-		if (ir.HasNamedResults(ir.CurFunc) && len(n.Results) > 1) || paramoutheap(ir.CurFunc) {
-			// assign to the function out parameters,
-			// so that ascompatee can fix up conflicts
-			var rl []ir.Node
-
-			for _, ln := range ir.CurFunc.Dcl {
-				cl := ln.Class_
-				if cl == ir.PAUTO || cl == ir.PAUTOHEAP {
-					break
-				}
-				if cl == ir.PPARAMOUT {
-					var ln ir.Node = ln
-					if ir.IsParamStackCopy(ln) {
-						ln = walkexpr(typecheck.Expr(ir.NewStarExpr(base.Pos, ln.Name().Heapaddr)), nil)
-					}
-					rl = append(rl, ln)
-				}
-			}
-
-			if got, want := len(n.Results), len(rl); got != want {
-				// order should have rewritten multi-value function calls
-				// with explicit OAS2FUNC nodes.
-				base.Fatalf("expected %v return arguments, have %v", want, got)
-			}
-
-			// move function calls out, to make ascompatee's job easier.
-			walkexprlistsafe(n.Results, n.PtrInit())
+		// Zero the stack location containing f.
+		ir.CurFunc.Enter.Append(ir.NewAssignStmt(ir.CurFunc.Pos(), v, nil))
+	}
+}
 
-			n.Results.Set(ascompatee(n.Op(), rl, n.Results, n.PtrInit()))
-			return n
+// returnsfromheap returns code to copy values for heap-escaped parameters
+// back to the stack.
+func returnsfromheap(params *types.Type) []ir.Node {
+	var nn []ir.Node
+	for _, t := range params.Fields().Slice() {
+		v := ir.AsNode(t.Nname)
+		if v == nil {
+			continue
 		}
-		walkexprlist(n.Results, n.PtrInit())
-
-		// For each return parameter (lhs), assign the corresponding result (rhs).
-		lhs := ir.CurFunc.Type().Results()
-		rhs := n.Results
-		res := make([]ir.Node, lhs.NumFields())
-		for i, nl := range lhs.FieldSlice() {
-			nname := ir.AsNode(nl.Nname)
-			if ir.IsParamHeapCopy(nname) {
-				nname = nname.Name().Stackcopy
-			}
-			a := ir.NewAssignStmt(base.Pos, nname, rhs[i])
-			res[i] = convas(a, n.PtrInit())
+		if stackcopy := v.Name().Stackcopy; stackcopy != nil && stackcopy.Class_ == ir.PPARAMOUT {
+			nn = append(nn, walkStmt(typecheck.Stmt(ir.NewAssignStmt(base.Pos, stackcopy, v))))
 		}
-		n.Results.Set(res)
-		return n
-
-	case ir.ORETJMP:
-		n := n.(*ir.BranchStmt)
-		return n
-
-	case ir.OINLMARK:
-		n := n.(*ir.InlineMarkStmt)
-		return n
-
-	case ir.OSELECT:
-		n := n.(*ir.SelectStmt)
-		walkselect(n)
-		return n
-
-	case ir.OSWITCH:
-		n := n.(*ir.SwitchStmt)
-		walkswitch(n)
-		return n
-
-	case ir.ORANGE:
-		n := n.(*ir.RangeStmt)
-		return walkrange(n)
 	}
 
-	// No return! Each case must return (or panic),
-	// to avoid confusion about what gets returned
-	// in the presence of type assertions.
+	return nn
 }
 
-// walk the whole tree of the body of an
-// expression or simple statement.
-// the types expressions are calculated.
-// compile-time constants are evaluated.
-// complex side effects like statements are appended to init
-func walkexprlist(s []ir.Node, init *ir.Nodes) {
-	for i := range s {
-		s[i] = walkexpr(s[i], init)
-	}
+// heapmoves generates code to handle migrating heap-escaped parameters
+// between the stack and the heap. The generated code is added to Curfn's
+// Enter and Exit lists.
+func heapmoves() {
+	lno := base.Pos
+	base.Pos = ir.CurFunc.Pos()
+	nn := paramstoheap(ir.CurFunc.Type().Recvs())
+	nn = append(nn, paramstoheap(ir.CurFunc.Type().Params())...)
+	nn = append(nn, paramstoheap(ir.CurFunc.Type().Results())...)
+	ir.CurFunc.Enter.Append(nn...)
+	base.Pos = ir.CurFunc.Endlineno
+	ir.CurFunc.Exit.Append(returnsfromheap(ir.CurFunc.Type().Results())...)
+	base.Pos = lno
 }
 
-func walkexprlistsafe(s []ir.Node, init *ir.Nodes) {
-	for i, n := range s {
-		s[i] = safeexpr(n, init)
-		s[i] = walkexpr(s[i], init)
+func vmkcall(fn ir.Node, t *types.Type, init *ir.Nodes, va []ir.Node) *ir.CallExpr {
+	if fn.Type() == nil || fn.Type().Kind() != types.TFUNC {
+		base.Fatalf("mkcall %v %v", fn, fn.Type())
 	}
-}
 
-func walkexprlistcheap(s []ir.Node, init *ir.Nodes) {
-	for i, n := range s {
-		s[i] = cheapexpr(n, init)
-		s[i] = walkexpr(s[i], init)
+	n := fn.Type().NumParams()
+	if n != len(va) {
+		base.Fatalf("vmkcall %v needs %v args got %v", fn, n, len(va))
 	}
+
+	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, va)
+	typecheck.Call(call)
+	call.SetType(t)
+	return walkExpr(call, init).(*ir.CallExpr)
 }
 
-// convFuncName builds the runtime function name for interface conversion.
-// It also reports whether the function expects the data by address.
-// Not all names are possible. For example, we never generate convE2E or convE2I.
-func convFuncName(from, to *types.Type) (fnname string, needsaddr bool) {
-	tkind := to.Tie()
-	switch from.Tie() {
-	case 'I':
-		if tkind == 'I' {
-			return "convI2I", false
-		}
-	case 'T':
-		switch {
-		case from.Size() == 2 && from.Align == 2:
-			return "convT16", false
-		case from.Size() == 4 && from.Align == 4 && !from.HasPointers():
-			return "convT32", false
-		case from.Size() == 8 && from.Align == types.Types[types.TUINT64].Align && !from.HasPointers():
-			return "convT64", false
-		}
-		if sc := from.SoleComponent(); sc != nil {
-			switch {
-			case sc.IsString():
-				return "convTstring", false
-			case sc.IsSlice():
-				return "convTslice", false
-			}
-		}
+func mkcall(name string, t *types.Type, init *ir.Nodes, args ...ir.Node) *ir.CallExpr {
+	return vmkcall(typecheck.LookupRuntime(name), t, init, args)
+}
 
-		switch tkind {
-		case 'E':
-			if !from.HasPointers() {
-				return "convT2Enoptr", true
-			}
-			return "convT2E", true
-		case 'I':
-			if !from.HasPointers() {
-				return "convT2Inoptr", true
-			}
-			return "convT2I", true
-		}
-	}
-	base.Fatalf("unknown conv func %c2%c", from.Tie(), to.Tie())
-	panic("unreachable")
+func mkcall1(fn ir.Node, t *types.Type, init *ir.Nodes, args ...ir.Node) *ir.CallExpr {
+	return vmkcall(fn, t, init, args)
 }
 
-// The result of walkexpr MUST be assigned back to n, e.g.
-// 	n.Left = walkexpr(n.Left, init)
-func walkexpr(n ir.Node, init *ir.Nodes) ir.Node {
-	if n == nil {
-		return n
+func chanfn(name string, n int, t *types.Type) ir.Node {
+	if !t.IsChan() {
+		base.Fatalf("chanfn %v", t)
 	}
-
-	// Eagerly checkwidth all expressions for the back end.
-	if n.Type() != nil && !n.Type().WidthCalculated() {
-		switch n.Type().Kind() {
-		case types.TBLANK, types.TNIL, types.TIDEAL:
-		default:
-			types.CheckSize(n.Type())
-		}
+	fn := typecheck.LookupRuntime(name)
+	switch n {
+	default:
+		base.Fatalf("chanfn %d", n)
+	case 1:
+		fn = typecheck.SubstArgTypes(fn, t.Elem())
+	case 2:
+		fn = typecheck.SubstArgTypes(fn, t.Elem(), t.Elem())
 	}
+	return fn
+}
 
-	if init == n.PtrInit() {
-		// not okay to use n->ninit when walking n,
-		// because we might replace n with some other node
-		// and would lose the init list.
-		base.Fatalf("walkexpr init == &n->ninit")
+func mapfn(name string, t *types.Type) ir.Node {
+	if !t.IsMap() {
+		base.Fatalf("mapfn %v", t)
 	}
+	fn := typecheck.LookupRuntime(name)
+	fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem(), t.Key(), t.Elem())
+	return fn
+}
 
-	if len(n.Init()) != 0 {
-		walkstmtlist(n.Init())
-		init.Append(n.PtrInit().Take()...)
+func mapfndel(name string, t *types.Type) ir.Node {
+	if !t.IsMap() {
+		base.Fatalf("mapfn %v", t)
 	}
+	fn := typecheck.LookupRuntime(name)
+	fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem(), t.Key())
+	return fn
+}
 
-	lno := ir.SetPos(n)
-
-	if base.Flag.LowerW > 1 {
-		ir.Dump("before walk expr", n)
-	}
+const (
+	mapslow = iota
+	mapfast32
+	mapfast32ptr
+	mapfast64
+	mapfast64ptr
+	mapfaststr
+	nmapfast
+)
 
-	if n.Typecheck() != 1 {
-		base.Fatalf("missed typecheck: %+v", n)
-	}
+type mapnames [nmapfast]string
 
-	if n.Type().IsUntyped() {
-		base.Fatalf("expression has untyped type: %+v", n)
-	}
+func mkmapnames(base string, ptr string) mapnames {
+	return mapnames{base, base + "_fast32", base + "_fast32" + ptr, base + "_fast64", base + "_fast64" + ptr, base + "_faststr"}
+}
 
-	if n.Op() == ir.ONAME && n.(*ir.Name).Class_ == ir.PAUTOHEAP {
-		n := n.(*ir.Name)
-		nn := ir.NewStarExpr(base.Pos, n.Name().Heapaddr)
-		nn.X.MarkNonNil()
-		return walkexpr(typecheck.Expr(nn), init)
-	}
+var mapaccess1 = mkmapnames("mapaccess1", "")
+var mapaccess2 = mkmapnames("mapaccess2", "")
+var mapassign = mkmapnames("mapassign", "ptr")
+var mapdelete = mkmapnames("mapdelete", "")
 
-	n = walkexpr1(n, init)
-
-	// Expressions that are constant at run time but not
-	// considered const by the language spec are not turned into
-	// constants until walk. For example, if n is y%1 == 0, the
-	// walk of y%1 may have replaced it by 0.
-	// Check whether n with its updated args is itself now a constant.
-	t := n.Type()
-	n = typecheck.EvalConst(n)
-	if n.Type() != t {
-		base.Fatalf("evconst changed Type: %v had type %v, now %v", n, t, n.Type())
+func mapfast(t *types.Type) int {
+	// Check runtime/map.go:maxElemSize before changing.
+	if t.Elem().Width > 128 {
+		return mapslow
 	}
-	if n.Op() == ir.OLITERAL {
-		n = typecheck.Expr(n)
-		// Emit string symbol now to avoid emitting
-		// any concurrently during the backend.
-		if v := n.Val(); v.Kind() == constant.String {
-			_ = staticdata.StringSym(n.Pos(), constant.StringVal(v))
+	switch reflectdata.AlgType(t.Key()) {
+	case types.AMEM32:
+		if !t.Key().HasPointers() {
+			return mapfast32
 		}
+		if types.PtrSize == 4 {
+			return mapfast32ptr
+		}
+		base.Fatalf("small pointer %v", t.Key())
+	case types.AMEM64:
+		if !t.Key().HasPointers() {
+			return mapfast64
+		}
+		if types.PtrSize == 8 {
+			return mapfast64ptr
+		}
+		// Two-word object, at least one of which is a pointer.
+		// Use the slow path.
+	case types.ASTRING:
+		return mapfaststr
 	}
+	return mapslow
+}
 
-	updateHasCall(n)
+func walkAppendArgs(n *ir.CallExpr, init *ir.Nodes) {
+	walkExprListSafe(n.Args, init)
 
-	if base.Flag.LowerW != 0 && n != nil {
-		ir.Dump("after walk expr", n)
+	// walkexprlistsafe will leave OINDEX (s[n]) alone if both s
+	// and n are name or literal, but those may index the slice we're
+	// modifying here. Fix explicitly.
+	ls := n.Args
+	for i1, n1 := range ls {
+		ls[i1] = cheapExpr(n1, init)
 	}
-
-	base.Pos = lno
-	return n
-}
-
-func walkexpr1(n ir.Node, init *ir.Nodes) ir.Node {
-	switch n.Op() {
-	default:
-		ir.Dump("walk", n)
-		base.Fatalf("walkexpr: switch 1 unknown op %+v", n.Op())
-		panic("unreachable")
-
-	case ir.ONONAME, ir.OGETG, ir.ONEWOBJ, ir.OMETHEXPR:
-		return n
-
-	case ir.OTYPE, ir.ONAME, ir.OLITERAL, ir.ONIL, ir.ONAMEOFFSET:
-		// TODO(mdempsky): Just return n; see discussion on CL 38655.
-		// Perhaps refactor to use Node.mayBeShared for these instead.
-		// If these return early, make sure to still call
-		// stringsym for constant strings.
-		return n
-
-	case ir.ONOT, ir.ONEG, ir.OPLUS, ir.OBITNOT, ir.OREAL, ir.OIMAG, ir.OSPTR, ir.OITAB, ir.OIDATA:
-		n := n.(*ir.UnaryExpr)
-		n.X = walkexpr(n.X, init)
-		return n
-
-	case ir.ODOTMETH, ir.ODOTINTER:
-		n := n.(*ir.SelectorExpr)
-		n.X = walkexpr(n.X, init)
-		return n
-
-	case ir.OADDR:
-		n := n.(*ir.AddrExpr)
-		n.X = walkexpr(n.X, init)
-		return n
-
-	case ir.ODEREF:
-		n := n.(*ir.StarExpr)
-		n.X = walkexpr(n.X, init)
-		return n
-
-	case ir.OEFACE, ir.OAND, ir.OANDNOT, ir.OSUB, ir.OMUL, ir.OADD, ir.OOR, ir.OXOR, ir.OLSH, ir.ORSH:
-		n := n.(*ir.BinaryExpr)
-		n.X = walkexpr(n.X, init)
-		n.Y = walkexpr(n.Y, init)
-		return n
-
-	case ir.ODOT, ir.ODOTPTR:
-		n := n.(*ir.SelectorExpr)
-		usefield(n)
-		n.X = walkexpr(n.X, init)
-		return n
-
-	case ir.ODOTTYPE, ir.ODOTTYPE2:
-		n := n.(*ir.TypeAssertExpr)
-		n.X = walkexpr(n.X, init)
-		// Set up interface type addresses for back end.
-		n.Ntype = reflectdata.TypePtr(n.Type())
-		if n.Op() == ir.ODOTTYPE {
-			n.Ntype.(*ir.AddrExpr).Alloc = reflectdata.TypePtr(n.X.Type())
-		}
-		if !n.Type().IsInterface() && !n.X.Type().IsEmptyInterface() {
-			n.Itab = []ir.Node{reflectdata.ITabAddr(n.Type(), n.X.Type())}
-		}
-		return n
-
-	case ir.OLEN, ir.OCAP:
-		n := n.(*ir.UnaryExpr)
-		if isRuneCount(n) {
-			// Replace len([]rune(string)) with runtime.countrunes(string).
-			return mkcall("countrunes", n.Type(), init, typecheck.Conv(n.X.(*ir.ConvExpr).X, types.Types[types.TSTRING]))
-		}
-
-		n.X = walkexpr(n.X, init)
-
-		// replace len(*[10]int) with 10.
-		// delayed until now to preserve side effects.
-		t := n.X.Type()
-
-		if t.IsPtr() {
-			t = t.Elem()
-		}
-		if t.IsArray() {
-			safeexpr(n.X, init)
-			con := typecheck.OrigInt(n, t.NumElem())
-			con.SetTypecheck(1)
-			return con
-		}
-		return n
-
-	case ir.OCOMPLEX:
-		n := n.(*ir.BinaryExpr)
-		n.X = walkexpr(n.X, init)
-		n.Y = walkexpr(n.Y, init)
-		return n
-
-	case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
-		n := n.(*ir.BinaryExpr)
-		return walkcompare(n, init)
-
-	case ir.OANDAND, ir.OOROR:
-		n := n.(*ir.LogicalExpr)
-		n.X = walkexpr(n.X, init)
-
-		// cannot put side effects from n.Right on init,
-		// because they cannot run before n.Left is checked.
-		// save elsewhere and store on the eventual n.Right.
-		var ll ir.Nodes
-
-		n.Y = walkexpr(n.Y, &ll)
-		n.Y = ir.InitExpr(ll, n.Y)
-		return n
-
-	case ir.OPRINT, ir.OPRINTN:
-		return walkprint(n.(*ir.CallExpr), init)
-
-	case ir.OPANIC:
-		n := n.(*ir.UnaryExpr)
-		return mkcall("gopanic", nil, init, n.X)
-
-	case ir.ORECOVER:
-		n := n.(*ir.CallExpr)
-		return mkcall("gorecover", n.Type(), init, typecheck.NodAddr(ir.RegFP))
-
-	case ir.OCLOSUREREAD, ir.OCFUNC:
-		return n
-
-	case ir.OCALLINTER, ir.OCALLFUNC, ir.OCALLMETH:
-		n := n.(*ir.CallExpr)
-		if n.Op() == ir.OCALLINTER {
-			usemethod(n)
-			reflectdata.MarkUsedIfaceMethod(n)
-		}
-
-		if n.Op() == ir.OCALLFUNC && n.X.Op() == ir.OCLOSURE {
-			// Transform direct call of a closure to call of a normal function.
-			// transformclosure already did all preparation work.
-
-			// Prepend captured variables to argument list.
-			clo := n.X.(*ir.ClosureExpr)
-			n.Args.Prepend(clo.Func.ClosureEnter...)
-			clo.Func.ClosureEnter.Set(nil)
-
-			// Replace OCLOSURE with ONAME/PFUNC.
-			n.X = clo.Func.Nname
-
-			// Update type of OCALLFUNC node.
-			// Output arguments had not changed, but their offsets could.
-			if n.X.Type().NumResults() == 1 {
-				n.SetType(n.X.Type().Results().Field(0).Type)
-			} else {
-				n.SetType(n.X.Type().Results())
-			}
-		}
-
-		walkCall(n, init)
-		return n
-
-	case ir.OAS, ir.OASOP:
-		init.Append(n.PtrInit().Take()...)
-
-		var left, right ir.Node
-		switch n.Op() {
-		case ir.OAS:
-			n := n.(*ir.AssignStmt)
-			left, right = n.X, n.Y
-		case ir.OASOP:
-			n := n.(*ir.AssignOpStmt)
-			left, right = n.X, n.Y
-		}
-
-		// Recognize m[k] = append(m[k], ...) so we can reuse
-		// the mapassign call.
-		var mapAppend *ir.CallExpr
-		if left.Op() == ir.OINDEXMAP && right.Op() == ir.OAPPEND {
-			left := left.(*ir.IndexExpr)
-			mapAppend = right.(*ir.CallExpr)
-			if !ir.SameSafeExpr(left, mapAppend.Args[0]) {
-				base.Fatalf("not same expressions: %v != %v", left, mapAppend.Args[0])
-			}
-		}
-
-		left = walkexpr(left, init)
-		left = safeexpr(left, init)
-		if mapAppend != nil {
-			mapAppend.Args[0] = left
-		}
-
-		if n.Op() == ir.OASOP {
-			// Rewrite x op= y into x = x op y.
-			n = ir.NewAssignStmt(base.Pos, left, typecheck.Expr(ir.NewBinaryExpr(base.Pos, n.(*ir.AssignOpStmt).AsOp, left, right)))
-		} else {
-			n.(*ir.AssignStmt).X = left
-		}
-		as := n.(*ir.AssignStmt)
-
-		if oaslit(as, init) {
-			return ir.NewBlockStmt(as.Pos(), nil)
-		}
-
-		if as.Y == nil {
-			// TODO(austin): Check all "implicit zeroing"
-			return as
-		}
-
-		if !base.Flag.Cfg.Instrumenting && ir.IsZero(as.Y) {
-			return as
-		}
-
-		switch as.Y.Op() {
-		default:
-			as.Y = walkexpr(as.Y, init)
-
-		case ir.ORECV:
-			// x = <-c; as.Left is x, as.Right.Left is c.
-			// order.stmt made sure x is addressable.
-			recv := as.Y.(*ir.UnaryExpr)
-			recv.X = walkexpr(recv.X, init)
-
-			n1 := typecheck.NodAddr(as.X)
-			r := recv.X // the channel
-			return mkcall1(chanfn("chanrecv1", 2, r.Type()), nil, init, r, n1)
-
-		case ir.OAPPEND:
-			// x = append(...)
-			call := as.Y.(*ir.CallExpr)
-			if call.Type().Elem().NotInHeap() {
-				base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", call.Type().Elem())
-			}
-			var r ir.Node
-			switch {
-			case isAppendOfMake(call):
-				// x = append(y, make([]T, y)...)
-				r = extendslice(call, init)
-			case call.IsDDD:
-				r = appendslice(call, init) // also works for append(slice, string).
-			default:
-				r = walkappend(call, init, as)
-			}
-			as.Y = r
-			if r.Op() == ir.OAPPEND {
-				// Left in place for back end.
-				// Do not add a new write barrier.
-				// Set up address of type for back end.
-				r.(*ir.CallExpr).X = reflectdata.TypePtr(r.Type().Elem())
-				return as
-			}
-			// Otherwise, lowered for race detector.
-			// Treat as ordinary assignment.
-		}
-
-		if as.X != nil && as.Y != nil {
-			return convas(as, init)
-		}
-		return as
-
-	case ir.OAS2:
-		n := n.(*ir.AssignListStmt)
-		init.Append(n.PtrInit().Take()...)
-		walkexprlistsafe(n.Lhs, init)
-		walkexprlistsafe(n.Rhs, init)
-		return ir.NewBlockStmt(src.NoXPos, ascompatee(ir.OAS, n.Lhs, n.Rhs, init))
-
-	// a,b,... = fn()
-	case ir.OAS2FUNC:
-		n := n.(*ir.AssignListStmt)
-		init.Append(n.PtrInit().Take()...)
-
-		r := n.Rhs[0]
-		walkexprlistsafe(n.Lhs, init)
-		r = walkexpr(r, init)
-
-		if ir.IsIntrinsicCall(r.(*ir.CallExpr)) {
-			n.Rhs = []ir.Node{r}
-			return n
-		}
-		init.Append(r)
-
-		ll := ascompatet(n.Lhs, r.Type())
-		return ir.NewBlockStmt(src.NoXPos, ll)
-
-	// x, y = <-c
-	// order.stmt made sure x is addressable or blank.
-	case ir.OAS2RECV:
-		n := n.(*ir.AssignListStmt)
-		init.Append(n.PtrInit().Take()...)
-
-		r := n.Rhs[0].(*ir.UnaryExpr) // recv
-		walkexprlistsafe(n.Lhs, init)
-		r.X = walkexpr(r.X, init)
-		var n1 ir.Node
-		if ir.IsBlank(n.Lhs[0]) {
-			n1 = typecheck.NodNil()
-		} else {
-			n1 = typecheck.NodAddr(n.Lhs[0])
-		}
-		fn := chanfn("chanrecv2", 2, r.X.Type())
-		ok := n.Lhs[1]
-		call := mkcall1(fn, types.Types[types.TBOOL], init, r.X, n1)
-		return typecheck.Stmt(ir.NewAssignStmt(base.Pos, ok, call))
-
-	// a,b = m[i]
-	case ir.OAS2MAPR:
-		n := n.(*ir.AssignListStmt)
-		init.Append(n.PtrInit().Take()...)
-
-		r := n.Rhs[0].(*ir.IndexExpr)
-		walkexprlistsafe(n.Lhs, init)
-		r.X = walkexpr(r.X, init)
-		r.Index = walkexpr(r.Index, init)
-		t := r.X.Type()
-
-		fast := mapfast(t)
-		var key ir.Node
-		if fast != mapslow {
-			// fast versions take key by value
-			key = r.Index
-		} else {
-			// standard version takes key by reference
-			// order.expr made sure key is addressable.
-			key = typecheck.NodAddr(r.Index)
-		}
-
-		// from:
-		//   a,b = m[i]
-		// to:
-		//   var,b = mapaccess2*(t, m, i)
-		//   a = *var
-		a := n.Lhs[0]
-
-		var call *ir.CallExpr
-		if w := t.Elem().Width; w <= zeroValSize {
-			fn := mapfn(mapaccess2[fast], t)
-			call = mkcall1(fn, fn.Type().Results(), init, reflectdata.TypePtr(t), r.X, key)
-		} else {
-			fn := mapfn("mapaccess2_fat", t)
-			z := reflectdata.ZeroAddr(w)
-			call = mkcall1(fn, fn.Type().Results(), init, reflectdata.TypePtr(t), r.X, key, z)
-		}
-
-		// mapaccess2* returns a typed bool, but due to spec changes,
-		// the boolean result of i.(T) is now untyped so we make it the
-		// same type as the variable on the lhs.
-		if ok := n.Lhs[1]; !ir.IsBlank(ok) && ok.Type().IsBoolean() {
-			call.Type().Field(1).Type = ok.Type()
-		}
-		n.Rhs = []ir.Node{call}
-		n.SetOp(ir.OAS2FUNC)
-
-		// don't generate a = *var if a is _
-		if ir.IsBlank(a) {
-			return walkexpr(typecheck.Stmt(n), init)
-		}
-
-		var_ := typecheck.Temp(types.NewPtr(t.Elem()))
-		var_.SetTypecheck(1)
-		var_.MarkNonNil() // mapaccess always returns a non-nil pointer
-
-		n.Lhs[0] = var_
-		init.Append(walkexpr(n, init))
-
-		as := ir.NewAssignStmt(base.Pos, a, ir.NewStarExpr(base.Pos, var_))
-		return walkexpr(typecheck.Stmt(as), init)
-
-	case ir.ODELETE:
-		n := n.(*ir.CallExpr)
-		init.Append(n.PtrInit().Take()...)
-		map_ := n.Args[0]
-		key := n.Args[1]
-		map_ = walkexpr(map_, init)
-		key = walkexpr(key, init)
-
-		t := map_.Type()
-		fast := mapfast(t)
-		if fast == mapslow {
-			// order.stmt made sure key is addressable.
-			key = typecheck.NodAddr(key)
-		}
-		return mkcall1(mapfndel(mapdelete[fast], t), nil, init, reflectdata.TypePtr(t), map_, key)
-
-	case ir.OAS2DOTTYPE:
-		n := n.(*ir.AssignListStmt)
-		walkexprlistsafe(n.Lhs, init)
-		n.Rhs[0] = walkexpr(n.Rhs[0], init)
-		return n
-
-	case ir.OCONVIFACE:
-		n := n.(*ir.ConvExpr)
-		n.X = walkexpr(n.X, init)
-
-		fromType := n.X.Type()
-		toType := n.Type()
-
-		if !fromType.IsInterface() && !ir.IsBlank(ir.CurFunc.Nname) { // skip unnamed functions (func _())
-			reflectdata.MarkTypeUsedInInterface(fromType, ir.CurFunc.LSym)
-		}
-
-		// typeword generates the type word of the interface value.
-		typeword := func() ir.Node {
-			if toType.IsEmptyInterface() {
-				return reflectdata.TypePtr(fromType)
-			}
-			return reflectdata.ITabAddr(fromType, toType)
-		}
-
-		// Optimize convT2E or convT2I as a two-word copy when T is pointer-shaped.
-		if types.IsDirectIface(fromType) {
-			l := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), n.X)
-			l.SetType(toType)
-			l.SetTypecheck(n.Typecheck())
-			return l
-		}
-
-		if ir.Names.Staticuint64s == nil {
-			ir.Names.Staticuint64s = typecheck.NewName(ir.Pkgs.Runtime.Lookup("staticuint64s"))
-			ir.Names.Staticuint64s.Class_ = ir.PEXTERN
-			// The actual type is [256]uint64, but we use [256*8]uint8 so we can address
-			// individual bytes.
-			ir.Names.Staticuint64s.SetType(types.NewArray(types.Types[types.TUINT8], 256*8))
-			ir.Names.Zerobase = typecheck.NewName(ir.Pkgs.Runtime.Lookup("zerobase"))
-			ir.Names.Zerobase.Class_ = ir.PEXTERN
-			ir.Names.Zerobase.SetType(types.Types[types.TUINTPTR])
-		}
-
-		// Optimize convT2{E,I} for many cases in which T is not pointer-shaped,
-		// by using an existing addressable value identical to n.Left
-		// or creating one on the stack.
-		var value ir.Node
-		switch {
-		case fromType.Size() == 0:
-			// n.Left is zero-sized. Use zerobase.
-			cheapexpr(n.X, init) // Evaluate n.Left for side-effects. See issue 19246.
-			value = ir.Names.Zerobase
-		case fromType.IsBoolean() || (fromType.Size() == 1 && fromType.IsInteger()):
-			// n.Left is a bool/byte. Use staticuint64s[n.Left * 8] on little-endian
-			// and staticuint64s[n.Left * 8 + 7] on big-endian.
-			n.X = cheapexpr(n.X, init)
-			// byteindex widens n.Left so that the multiplication doesn't overflow.
-			index := ir.NewBinaryExpr(base.Pos, ir.OLSH, byteindex(n.X), ir.NewInt(3))
-			if ssagen.Arch.LinkArch.ByteOrder == binary.BigEndian {
-				index = ir.NewBinaryExpr(base.Pos, ir.OADD, index, ir.NewInt(7))
-			}
-			xe := ir.NewIndexExpr(base.Pos, ir.Names.Staticuint64s, index)
-			xe.SetBounded(true)
-			value = xe
-		case n.X.Op() == ir.ONAME && n.X.(*ir.Name).Class_ == ir.PEXTERN && n.X.(*ir.Name).Readonly():
-			// n.Left is a readonly global; use it directly.
-			value = n.X
-		case !fromType.IsInterface() && n.Esc() == ir.EscNone && fromType.Width <= 1024:
-			// n.Left does not escape. Use a stack temporary initialized to n.Left.
-			value = typecheck.Temp(fromType)
-			init.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, value, n.X)))
-		}
-
-		if value != nil {
-			// Value is identical to n.Left.
-			// Construct the interface directly: {type/itab, &value}.
-			l := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), typecheck.Expr(typecheck.NodAddr(value)))
-			l.SetType(toType)
-			l.SetTypecheck(n.Typecheck())
-			return l
-		}
-
-		// Implement interface to empty interface conversion.
-		// tmp = i.itab
-		// if tmp != nil {
-		//    tmp = tmp.type
-		// }
-		// e = iface{tmp, i.data}
-		if toType.IsEmptyInterface() && fromType.IsInterface() && !fromType.IsEmptyInterface() {
-			// Evaluate the input interface.
-			c := typecheck.Temp(fromType)
-			init.Append(ir.NewAssignStmt(base.Pos, c, n.X))
-
-			// Get the itab out of the interface.
-			tmp := typecheck.Temp(types.NewPtr(types.Types[types.TUINT8]))
-			init.Append(ir.NewAssignStmt(base.Pos, tmp, typecheck.Expr(ir.NewUnaryExpr(base.Pos, ir.OITAB, c))))
-
-			// Get the type out of the itab.
-			nif := ir.NewIfStmt(base.Pos, typecheck.Expr(ir.NewBinaryExpr(base.Pos, ir.ONE, tmp, typecheck.NodNil())), nil, nil)
-			nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, tmp, itabType(tmp))}
-			init.Append(nif)
-
-			// Build the result.
-			e := ir.NewBinaryExpr(base.Pos, ir.OEFACE, tmp, ifaceData(n.Pos(), c, types.NewPtr(types.Types[types.TUINT8])))
-			e.SetType(toType) // assign type manually, typecheck doesn't understand OEFACE.
-			e.SetTypecheck(1)
-			return e
-		}
-
-		fnname, needsaddr := convFuncName(fromType, toType)
-
-		if !needsaddr && !fromType.IsInterface() {
-			// Use a specialized conversion routine that only returns a data pointer.
-			// ptr = convT2X(val)
-			// e = iface{typ/tab, ptr}
-			fn := typecheck.LookupRuntime(fnname)
-			types.CalcSize(fromType)
-			fn = typecheck.SubstArgTypes(fn, fromType)
-			types.CalcSize(fn.Type())
-			call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
-			call.Args = []ir.Node{n.X}
-			e := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), safeexpr(walkexpr(typecheck.Expr(call), init), init))
-			e.SetType(toType)
-			e.SetTypecheck(1)
-			return e
-		}
-
-		var tab ir.Node
-		if fromType.IsInterface() {
-			// convI2I
-			tab = reflectdata.TypePtr(toType)
-		} else {
-			// convT2x
-			tab = typeword()
-		}
-
-		v := n.X
-		if needsaddr {
-			// Types of large or unknown size are passed by reference.
-			// Orderexpr arranged for n.Left to be a temporary for all
-			// the conversions it could see. Comparison of an interface
-			// with a non-interface, especially in a switch on interface value
-			// with non-interface cases, is not visible to order.stmt, so we
-			// have to fall back on allocating a temp here.
-			if !ir.IsAssignable(v) {
-				v = copyexpr(v, v.Type(), init)
-			}
-			v = typecheck.NodAddr(v)
-		}
-
-		types.CalcSize(fromType)
-		fn := typecheck.LookupRuntime(fnname)
-		fn = typecheck.SubstArgTypes(fn, fromType, toType)
-		types.CalcSize(fn.Type())
-		call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
-		call.Args = []ir.Node{tab, v}
-		return walkexpr(typecheck.Expr(call), init)
-
-	case ir.OCONV, ir.OCONVNOP:
-		n := n.(*ir.ConvExpr)
-		n.X = walkexpr(n.X, init)
-		if n.Op() == ir.OCONVNOP && n.Type() == n.X.Type() {
-			return n.X
-		}
-		if n.Op() == ir.OCONVNOP && ir.ShouldCheckPtr(ir.CurFunc, 1) {
-			if n.Type().IsPtr() && n.X.Type().IsUnsafePtr() { // unsafe.Pointer to *T
-				return walkCheckPtrAlignment(n, init, nil)
-			}
-			if n.Type().IsUnsafePtr() && n.X.Type().IsUintptr() { // uintptr to unsafe.Pointer
-				return walkCheckPtrArithmetic(n, init)
-			}
-		}
-		param, result := rtconvfn(n.X.Type(), n.Type())
-		if param == types.Txxx {
-			return n
-		}
-		fn := types.BasicTypeNames[param] + "to" + types.BasicTypeNames[result]
-		return typecheck.Conv(mkcall(fn, types.Types[result], init, typecheck.Conv(n.X, types.Types[param])), n.Type())
-
-	case ir.ODIV, ir.OMOD:
-		n := n.(*ir.BinaryExpr)
-		n.X = walkexpr(n.X, init)
-		n.Y = walkexpr(n.Y, init)
-
-		// rewrite complex div into function call.
-		et := n.X.Type().Kind()
-
-		if types.IsComplex[et] && n.Op() == ir.ODIV {
-			t := n.Type()
-			call := mkcall("complex128div", types.Types[types.TCOMPLEX128], init, typecheck.Conv(n.X, types.Types[types.TCOMPLEX128]), typecheck.Conv(n.Y, types.Types[types.TCOMPLEX128]))
-			return typecheck.Conv(call, t)
-		}
-
-		// Nothing to do for float divisions.
-		if types.IsFloat[et] {
-			return n
-		}
-
-		// rewrite 64-bit div and mod on 32-bit architectures.
-		// TODO: Remove this code once we can introduce
-		// runtime calls late in SSA processing.
-		if types.RegSize < 8 && (et == types.TINT64 || et == types.TUINT64) {
-			if n.Y.Op() == ir.OLITERAL {
-				// Leave div/mod by constant powers of 2 or small 16-bit constants.
-				// The SSA backend will handle those.
-				switch et {
-				case types.TINT64:
-					c := ir.Int64Val(n.Y)
-					if c < 0 {
-						c = -c
-					}
-					if c != 0 && c&(c-1) == 0 {
-						return n
-					}
-				case types.TUINT64:
-					c := ir.Uint64Val(n.Y)
-					if c < 1<<16 {
-						return n
-					}
-					if c != 0 && c&(c-1) == 0 {
-						return n
-					}
-				}
-			}
-			var fn string
-			if et == types.TINT64 {
-				fn = "int64"
-			} else {
-				fn = "uint64"
-			}
-			if n.Op() == ir.ODIV {
-				fn += "div"
-			} else {
-				fn += "mod"
-			}
-			return mkcall(fn, n.Type(), init, typecheck.Conv(n.X, types.Types[et]), typecheck.Conv(n.Y, types.Types[et]))
-		}
-		return n
-
-	case ir.OINDEX:
-		n := n.(*ir.IndexExpr)
-		n.X = walkexpr(n.X, init)
-
-		// save the original node for bounds checking elision.
-		// If it was a ODIV/OMOD walk might rewrite it.
-		r := n.Index
-
-		n.Index = walkexpr(n.Index, init)
-
-		// if range of type cannot exceed static array bound,
-		// disable bounds check.
-		if n.Bounded() {
-			return n
-		}
-		t := n.X.Type()
-		if t != nil && t.IsPtr() {
-			t = t.Elem()
-		}
-		if t.IsArray() {
-			n.SetBounded(bounded(r, t.NumElem()))
-			if base.Flag.LowerM != 0 && n.Bounded() && !ir.IsConst(n.Index, constant.Int) {
-				base.Warn("index bounds check elided")
-			}
-			if ir.IsSmallIntConst(n.Index) && !n.Bounded() {
-				base.Errorf("index out of bounds")
-			}
-		} else if ir.IsConst(n.X, constant.String) {
-			n.SetBounded(bounded(r, int64(len(ir.StringVal(n.X)))))
-			if base.Flag.LowerM != 0 && n.Bounded() && !ir.IsConst(n.Index, constant.Int) {
-				base.Warn("index bounds check elided")
-			}
-			if ir.IsSmallIntConst(n.Index) && !n.Bounded() {
-				base.Errorf("index out of bounds")
-			}
-		}
-
-		if ir.IsConst(n.Index, constant.Int) {
-			if v := n.Index.Val(); constant.Sign(v) < 0 || ir.ConstOverflow(v, types.Types[types.TINT]) {
-				base.Errorf("index out of bounds")
-			}
-		}
-		return n
-
-	case ir.OINDEXMAP:
-		// Replace m[k] with *map{access1,assign}(maptype, m, &k)
-		n := n.(*ir.IndexExpr)
-		n.X = walkexpr(n.X, init)
-		n.Index = walkexpr(n.Index, init)
-		map_ := n.X
-		key := n.Index
-		t := map_.Type()
-		var call *ir.CallExpr
-		if n.Assigned {
-			// This m[k] expression is on the left-hand side of an assignment.
-			fast := mapfast(t)
-			if fast == mapslow {
-				// standard version takes key by reference.
-				// order.expr made sure key is addressable.
-				key = typecheck.NodAddr(key)
-			}
-			call = mkcall1(mapfn(mapassign[fast], t), nil, init, reflectdata.TypePtr(t), map_, key)
-		} else {
-			// m[k] is not the target of an assignment.
-			fast := mapfast(t)
-			if fast == mapslow {
-				// standard version takes key by reference.
-				// order.expr made sure key is addressable.
-				key = typecheck.NodAddr(key)
-			}
-
-			if w := t.Elem().Width; w <= zeroValSize {
-				call = mkcall1(mapfn(mapaccess1[fast], t), types.NewPtr(t.Elem()), init, reflectdata.TypePtr(t), map_, key)
-			} else {
-				z := reflectdata.ZeroAddr(w)
-				call = mkcall1(mapfn("mapaccess1_fat", t), types.NewPtr(t.Elem()), init, reflectdata.TypePtr(t), map_, key, z)
-			}
-		}
-		call.SetType(types.NewPtr(t.Elem()))
-		call.MarkNonNil() // mapaccess1* and mapassign always return non-nil pointers.
-		star := ir.NewStarExpr(base.Pos, call)
-		star.SetType(t.Elem())
-		star.SetTypecheck(1)
-		return star
-
-	case ir.ORECV:
-		base.Fatalf("walkexpr ORECV") // should see inside OAS only
-		panic("unreachable")
-
-	case ir.OSLICEHEADER:
-		n := n.(*ir.SliceHeaderExpr)
-		n.Ptr = walkexpr(n.Ptr, init)
-		n.LenCap[0] = walkexpr(n.LenCap[0], init)
-		n.LenCap[1] = walkexpr(n.LenCap[1], init)
-		return n
-
-	case ir.OSLICE, ir.OSLICEARR, ir.OSLICESTR, ir.OSLICE3, ir.OSLICE3ARR:
-		n := n.(*ir.SliceExpr)
-
-		checkSlice := ir.ShouldCheckPtr(ir.CurFunc, 1) && n.Op() == ir.OSLICE3ARR && n.X.Op() == ir.OCONVNOP && n.X.(*ir.ConvExpr).X.Type().IsUnsafePtr()
-		if checkSlice {
-			conv := n.X.(*ir.ConvExpr)
-			conv.X = walkexpr(conv.X, init)
-		} else {
-			n.X = walkexpr(n.X, init)
-		}
-
-		low, high, max := n.SliceBounds()
-		low = walkexpr(low, init)
-		if low != nil && ir.IsZero(low) {
-			// Reduce x[0:j] to x[:j] and x[0:j:k] to x[:j:k].
-			low = nil
-		}
-		high = walkexpr(high, init)
-		max = walkexpr(max, init)
-		n.SetSliceBounds(low, high, max)
-		if checkSlice {
-			n.X = walkCheckPtrAlignment(n.X.(*ir.ConvExpr), init, max)
-		}
-
-		if n.Op().IsSlice3() {
-			if max != nil && max.Op() == ir.OCAP && ir.SameSafeExpr(n.X, max.(*ir.UnaryExpr).X) {
-				// Reduce x[i:j:cap(x)] to x[i:j].
-				if n.Op() == ir.OSLICE3 {
-					n.SetOp(ir.OSLICE)
-				} else {
-					n.SetOp(ir.OSLICEARR)
-				}
-				return reduceSlice(n)
-			}
-			return n
-		}
-		return reduceSlice(n)
-
-	case ir.ONEW:
-		n := n.(*ir.UnaryExpr)
-		if n.Type().Elem().NotInHeap() {
-			base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", n.Type().Elem())
-		}
-		if n.Esc() == ir.EscNone {
-			if n.Type().Elem().Width >= ir.MaxImplicitStackVarSize {
-				base.Fatalf("large ONEW with EscNone: %v", n)
-			}
-			r := typecheck.Temp(n.Type().Elem())
-			init.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, r, nil))) // zero temp
-			return typecheck.Expr(typecheck.NodAddr(r))
-		}
-		return callnew(n.Type().Elem())
-
-	case ir.OADDSTR:
-		return addstr(n.(*ir.AddStringExpr), init)
-
-	case ir.OAPPEND:
-		// order should make sure we only see OAS(node, OAPPEND), which we handle above.
-		base.Fatalf("append outside assignment")
-		panic("unreachable")
-
-	case ir.OCOPY:
-		return copyany(n.(*ir.BinaryExpr), init, base.Flag.Cfg.Instrumenting && !base.Flag.CompilingRuntime)
-
-	case ir.OCLOSE:
-		// cannot use chanfn - closechan takes any, not chan any
-		n := n.(*ir.UnaryExpr)
-		fn := typecheck.LookupRuntime("closechan")
-		fn = typecheck.SubstArgTypes(fn, n.X.Type())
-		return mkcall1(fn, nil, init, n.X)
-
-	case ir.OMAKECHAN:
-		// When size fits into int, use makechan instead of
-		// makechan64, which is faster and shorter on 32 bit platforms.
-		n := n.(*ir.MakeExpr)
-		size := n.Len
-		fnname := "makechan64"
-		argtype := types.Types[types.TINT64]
-
-		// Type checking guarantees that TIDEAL size is positive and fits in an int.
-		// The case of size overflow when converting TUINT or TUINTPTR to TINT
-		// will be handled by the negative range checks in makechan during runtime.
-		if size.Type().IsKind(types.TIDEAL) || size.Type().Size() <= types.Types[types.TUINT].Size() {
-			fnname = "makechan"
-			argtype = types.Types[types.TINT]
-		}
-
-		return mkcall1(chanfn(fnname, 1, n.Type()), n.Type(), init, reflectdata.TypePtr(n.Type()), typecheck.Conv(size, argtype))
-
-	case ir.OMAKEMAP:
-		n := n.(*ir.MakeExpr)
-		t := n.Type()
-		hmapType := reflectdata.MapType(t)
-		hint := n.Len
-
-		// var h *hmap
-		var h ir.Node
-		if n.Esc() == ir.EscNone {
-			// Allocate hmap on stack.
-
-			// var hv hmap
-			hv := typecheck.Temp(hmapType)
-			init.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, hv, nil)))
-			// h = &hv
-			h = typecheck.NodAddr(hv)
-
-			// Allocate one bucket pointed to by hmap.buckets on stack if hint
-			// is not larger than BUCKETSIZE. In case hint is larger than
-			// BUCKETSIZE runtime.makemap will allocate the buckets on the heap.
-			// Maximum key and elem size is 128 bytes, larger objects
-			// are stored with an indirection. So max bucket size is 2048+eps.
-			if !ir.IsConst(hint, constant.Int) ||
-				constant.Compare(hint.Val(), token.LEQ, constant.MakeInt64(reflectdata.BUCKETSIZE)) {
-
-				// In case hint is larger than BUCKETSIZE runtime.makemap
-				// will allocate the buckets on the heap, see #20184
-				//
-				// if hint <= BUCKETSIZE {
-				//     var bv bmap
-				//     b = &bv
-				//     h.buckets = b
-				// }
-
-				nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OLE, hint, ir.NewInt(reflectdata.BUCKETSIZE)), nil, nil)
-				nif.Likely = true
-
-				// var bv bmap
-				bv := typecheck.Temp(reflectdata.MapBucketType(t))
-				nif.Body.Append(ir.NewAssignStmt(base.Pos, bv, nil))
-
-				// b = &bv
-				b := typecheck.NodAddr(bv)
-
-				// h.buckets = b
-				bsym := hmapType.Field(5).Sym // hmap.buckets see reflect.go:hmap
-				na := ir.NewAssignStmt(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, h, bsym), b)
-				nif.Body.Append(na)
-				appendWalkStmt(init, nif)
-			}
-		}
-
-		if ir.IsConst(hint, constant.Int) && constant.Compare(hint.Val(), token.LEQ, constant.MakeInt64(reflectdata.BUCKETSIZE)) {
-			// Handling make(map[any]any) and
-			// make(map[any]any, hint) where hint <= BUCKETSIZE
-			// special allows for faster map initialization and
-			// improves binary size by using calls with fewer arguments.
-			// For hint <= BUCKETSIZE overLoadFactor(hint, 0) is false
-			// and no buckets will be allocated by makemap. Therefore,
-			// no buckets need to be allocated in this code path.
-			if n.Esc() == ir.EscNone {
-				// Only need to initialize h.hash0 since
-				// hmap h has been allocated on the stack already.
-				// h.hash0 = fastrand()
-				rand := mkcall("fastrand", types.Types[types.TUINT32], init)
-				hashsym := hmapType.Field(4).Sym // hmap.hash0 see reflect.go:hmap
-				appendWalkStmt(init, ir.NewAssignStmt(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, h, hashsym), rand))
-				return typecheck.ConvNop(h, t)
-			}
-			// Call runtime.makehmap to allocate an
-			// hmap on the heap and initialize hmap's hash0 field.
-			fn := typecheck.LookupRuntime("makemap_small")
-			fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem())
-			return mkcall1(fn, n.Type(), init)
-		}
-
-		if n.Esc() != ir.EscNone {
-			h = typecheck.NodNil()
-		}
-		// Map initialization with a variable or large hint is
-		// more complicated. We therefore generate a call to
-		// runtime.makemap to initialize hmap and allocate the
-		// map buckets.
-
-		// When hint fits into int, use makemap instead of
-		// makemap64, which is faster and shorter on 32 bit platforms.
-		fnname := "makemap64"
-		argtype := types.Types[types.TINT64]
-
-		// Type checking guarantees that TIDEAL hint is positive and fits in an int.
-		// See checkmake call in TMAP case of OMAKE case in OpSwitch in typecheck1 function.
-		// The case of hint overflow when converting TUINT or TUINTPTR to TINT
-		// will be handled by the negative range checks in makemap during runtime.
-		if hint.Type().IsKind(types.TIDEAL) || hint.Type().Size() <= types.Types[types.TUINT].Size() {
-			fnname = "makemap"
-			argtype = types.Types[types.TINT]
-		}
-
-		fn := typecheck.LookupRuntime(fnname)
-		fn = typecheck.SubstArgTypes(fn, hmapType, t.Key(), t.Elem())
-		return mkcall1(fn, n.Type(), init, reflectdata.TypePtr(n.Type()), typecheck.Conv(hint, argtype), h)
-
-	case ir.OMAKESLICE:
-		n := n.(*ir.MakeExpr)
-		l := n.Len
-		r := n.Cap
-		if r == nil {
-			r = safeexpr(l, init)
-			l = r
-		}
-		t := n.Type()
-		if t.Elem().NotInHeap() {
-			base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", t.Elem())
-		}
-		if n.Esc() == ir.EscNone {
-			if why := escape.HeapAllocReason(n); why != "" {
-				base.Fatalf("%v has EscNone, but %v", n, why)
-			}
-			// var arr [r]T
-			// n = arr[:l]
-			i := typecheck.IndexConst(r)
-			if i < 0 {
-				base.Fatalf("walkexpr: invalid index %v", r)
-			}
-
-			// cap is constrained to [0,2^31) or [0,2^63) depending on whether
-			// we're in 32-bit or 64-bit systems. So it's safe to do:
-			//
-			// if uint64(len) > cap {
-			//     if len < 0 { panicmakeslicelen() }
-			//     panicmakeslicecap()
-			// }
-			nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGT, typecheck.Conv(l, types.Types[types.TUINT64]), ir.NewInt(i)), nil, nil)
-			niflen := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OLT, l, ir.NewInt(0)), nil, nil)
-			niflen.Body = []ir.Node{mkcall("panicmakeslicelen", nil, init)}
-			nif.Body.Append(niflen, mkcall("panicmakeslicecap", nil, init))
-			init.Append(typecheck.Stmt(nif))
-
-			t = types.NewArray(t.Elem(), i) // [r]T
-			var_ := typecheck.Temp(t)
-			appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, nil)) // zero temp
-			r := ir.NewSliceExpr(base.Pos, ir.OSLICE, var_)             // arr[:l]
-			r.SetSliceBounds(nil, l, nil)
-			// The conv is necessary in case n.Type is named.
-			return walkexpr(typecheck.Expr(typecheck.Conv(r, n.Type())), init)
-		}
-
-		// n escapes; set up a call to makeslice.
-		// When len and cap can fit into int, use makeslice instead of
-		// makeslice64, which is faster and shorter on 32 bit platforms.
-
-		len, cap := l, r
-
-		fnname := "makeslice64"
-		argtype := types.Types[types.TINT64]
-
-		// Type checking guarantees that TIDEAL len/cap are positive and fit in an int.
-		// The case of len or cap overflow when converting TUINT or TUINTPTR to TINT
-		// will be handled by the negative range checks in makeslice during runtime.
-		if (len.Type().IsKind(types.TIDEAL) || len.Type().Size() <= types.Types[types.TUINT].Size()) &&
-			(cap.Type().IsKind(types.TIDEAL) || cap.Type().Size() <= types.Types[types.TUINT].Size()) {
-			fnname = "makeslice"
-			argtype = types.Types[types.TINT]
-		}
-
-		m := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
-		m.SetType(t)
-
-		fn := typecheck.LookupRuntime(fnname)
-		m.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, reflectdata.TypePtr(t.Elem()), typecheck.Conv(len, argtype), typecheck.Conv(cap, argtype))
-		m.Ptr.MarkNonNil()
-		m.LenCap = []ir.Node{typecheck.Conv(len, types.Types[types.TINT]), typecheck.Conv(cap, types.Types[types.TINT])}
-		return walkexpr(typecheck.Expr(m), init)
-
-	case ir.OMAKESLICECOPY:
-		n := n.(*ir.MakeExpr)
-		if n.Esc() == ir.EscNone {
-			base.Fatalf("OMAKESLICECOPY with EscNone: %v", n)
-		}
-
-		t := n.Type()
-		if t.Elem().NotInHeap() {
-			base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", t.Elem())
-		}
-
-		length := typecheck.Conv(n.Len, types.Types[types.TINT])
-		copylen := ir.NewUnaryExpr(base.Pos, ir.OLEN, n.Cap)
-		copyptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, n.Cap)
-
-		if !t.Elem().HasPointers() && n.Bounded() {
-			// When len(to)==len(from) and elements have no pointers:
-			// replace make+copy with runtime.mallocgc+runtime.memmove.
-
-			// We do not check for overflow of len(to)*elem.Width here
-			// since len(from) is an existing checked slice capacity
-			// with same elem.Width for the from slice.
-			size := ir.NewBinaryExpr(base.Pos, ir.OMUL, typecheck.Conv(length, types.Types[types.TUINTPTR]), typecheck.Conv(ir.NewInt(t.Elem().Width), types.Types[types.TUINTPTR]))
-
-			// instantiate mallocgc(size uintptr, typ *byte, needszero bool) unsafe.Pointer
-			fn := typecheck.LookupRuntime("mallocgc")
-			sh := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
-			sh.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, size, typecheck.NodNil(), ir.NewBool(false))
-			sh.Ptr.MarkNonNil()
-			sh.LenCap = []ir.Node{length, length}
-			sh.SetType(t)
-
-			s := typecheck.Temp(t)
-			r := typecheck.Stmt(ir.NewAssignStmt(base.Pos, s, sh))
-			r = walkexpr(r, init)
-			init.Append(r)
-
-			// instantiate memmove(to *any, frm *any, size uintptr)
-			fn = typecheck.LookupRuntime("memmove")
-			fn = typecheck.SubstArgTypes(fn, t.Elem(), t.Elem())
-			ncopy := mkcall1(fn, nil, init, ir.NewUnaryExpr(base.Pos, ir.OSPTR, s), copyptr, size)
-			init.Append(walkexpr(typecheck.Stmt(ncopy), init))
-
-			return s
-		}
-		// Replace make+copy with runtime.makeslicecopy.
-		// instantiate makeslicecopy(typ *byte, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointer
-		fn := typecheck.LookupRuntime("makeslicecopy")
-		s := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
-		s.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, reflectdata.TypePtr(t.Elem()), length, copylen, typecheck.Conv(copyptr, types.Types[types.TUNSAFEPTR]))
-		s.Ptr.MarkNonNil()
-		s.LenCap = []ir.Node{length, length}
-		s.SetType(t)
-		return walkexpr(typecheck.Expr(s), init)
-
-	case ir.ORUNESTR:
-		n := n.(*ir.ConvExpr)
-		a := typecheck.NodNil()
-		if n.Esc() == ir.EscNone {
-			t := types.NewArray(types.Types[types.TUINT8], 4)
-			a = typecheck.NodAddr(typecheck.Temp(t))
-		}
-		// intstring(*[4]byte, rune)
-		return mkcall("intstring", n.Type(), init, a, typecheck.Conv(n.X, types.Types[types.TINT64]))
-
-	case ir.OBYTES2STR, ir.ORUNES2STR:
-		n := n.(*ir.ConvExpr)
-		a := typecheck.NodNil()
-		if n.Esc() == ir.EscNone {
-			// Create temporary buffer for string on stack.
-			t := types.NewArray(types.Types[types.TUINT8], tmpstringbufsize)
-			a = typecheck.NodAddr(typecheck.Temp(t))
-		}
-		if n.Op() == ir.ORUNES2STR {
-			// slicerunetostring(*[32]byte, []rune) string
-			return mkcall("slicerunetostring", n.Type(), init, a, n.X)
-		}
-		// slicebytetostring(*[32]byte, ptr *byte, n int) string
-		n.X = cheapexpr(n.X, init)
-		ptr, len := backingArrayPtrLen(n.X)
-		return mkcall("slicebytetostring", n.Type(), init, a, ptr, len)
-
-	case ir.OBYTES2STRTMP:
-		n := n.(*ir.ConvExpr)
-		n.X = walkexpr(n.X, init)
-		if !base.Flag.Cfg.Instrumenting {
-			// Let the backend handle OBYTES2STRTMP directly
-			// to avoid a function call to slicebytetostringtmp.
-			return n
-		}
-		// slicebytetostringtmp(ptr *byte, n int) string
-		n.X = cheapexpr(n.X, init)
-		ptr, len := backingArrayPtrLen(n.X)
-		return mkcall("slicebytetostringtmp", n.Type(), init, ptr, len)
-
-	case ir.OSTR2BYTES:
-		n := n.(*ir.ConvExpr)
-		s := n.X
-		if ir.IsConst(s, constant.String) {
-			sc := ir.StringVal(s)
-
-			// Allocate a [n]byte of the right size.
-			t := types.NewArray(types.Types[types.TUINT8], int64(len(sc)))
-			var a ir.Node
-			if n.Esc() == ir.EscNone && len(sc) <= int(ir.MaxImplicitStackVarSize) {
-				a = typecheck.NodAddr(typecheck.Temp(t))
-			} else {
-				a = callnew(t)
-			}
-			p := typecheck.Temp(t.PtrTo()) // *[n]byte
-			init.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, p, a)))
-
-			// Copy from the static string data to the [n]byte.
-			if len(sc) > 0 {
-				as := ir.NewAssignStmt(base.Pos, ir.NewStarExpr(base.Pos, p), ir.NewStarExpr(base.Pos, typecheck.ConvNop(ir.NewUnaryExpr(base.Pos, ir.OSPTR, s), t.PtrTo())))
-				appendWalkStmt(init, as)
-			}
-
-			// Slice the [n]byte to a []byte.
-			slice := ir.NewSliceExpr(n.Pos(), ir.OSLICEARR, p)
-			slice.SetType(n.Type())
-			slice.SetTypecheck(1)
-			return walkexpr(slice, init)
-		}
-
-		a := typecheck.NodNil()
-		if n.Esc() == ir.EscNone {
-			// Create temporary buffer for slice on stack.
-			t := types.NewArray(types.Types[types.TUINT8], tmpstringbufsize)
-			a = typecheck.NodAddr(typecheck.Temp(t))
-		}
-		// stringtoslicebyte(*32[byte], string) []byte
-		return mkcall("stringtoslicebyte", n.Type(), init, a, typecheck.Conv(s, types.Types[types.TSTRING]))
-
-	case ir.OSTR2BYTESTMP:
-		// []byte(string) conversion that creates a slice
-		// referring to the actual string bytes.
-		// This conversion is handled later by the backend and
-		// is only for use by internal compiler optimizations
-		// that know that the slice won't be mutated.
-		// The only such case today is:
-		// for i, c := range []byte(string)
-		n := n.(*ir.ConvExpr)
-		n.X = walkexpr(n.X, init)
-		return n
-
-	case ir.OSTR2RUNES:
-		n := n.(*ir.ConvExpr)
-		a := typecheck.NodNil()
-		if n.Esc() == ir.EscNone {
-			// Create temporary buffer for slice on stack.
-			t := types.NewArray(types.Types[types.TINT32], tmpstringbufsize)
-			a = typecheck.NodAddr(typecheck.Temp(t))
-		}
-		// stringtoslicerune(*[32]rune, string) []rune
-		return mkcall("stringtoslicerune", n.Type(), init, a, typecheck.Conv(n.X, types.Types[types.TSTRING]))
-
-	case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT, ir.OSTRUCTLIT, ir.OPTRLIT:
-		if isStaticCompositeLiteral(n) && !ssagen.TypeOK(n.Type()) {
-			n := n.(*ir.CompLitExpr) // not OPTRLIT
-			// n can be directly represented in the read-only data section.
-			// Make direct reference to the static data. See issue 12841.
-			vstat := readonlystaticname(n.Type())
-			fixedlit(inInitFunction, initKindStatic, n, vstat, init)
-			return typecheck.Expr(vstat)
-		}
-		var_ := typecheck.Temp(n.Type())
-		anylit(n, var_, init)
-		return var_
-
-	case ir.OSEND:
-		n := n.(*ir.SendStmt)
-		n1 := n.Value
-		n1 = typecheck.AssignConv(n1, n.Chan.Type().Elem(), "chan send")
-		n1 = walkexpr(n1, init)
-		n1 = typecheck.NodAddr(n1)
-		return mkcall1(chanfn("chansend1", 2, n.Chan.Type()), nil, init, n.Chan, n1)
-
-	case ir.OCLOSURE:
-		return walkclosure(n.(*ir.ClosureExpr), init)
-
-	case ir.OCALLPART:
-		return walkpartialcall(n.(*ir.CallPartExpr), init)
-	}
-
-	// No return! Each case must return (or panic),
-	// to avoid confusion about what gets returned
-	// in the presence of type assertions.
-}
-
-// rtconvfn returns the parameter and result types that will be used by a
-// runtime function to convert from type src to type dst. The runtime function
-// name can be derived from the names of the returned types.
-//
-// If no such function is necessary, it returns (Txxx, Txxx).
-func rtconvfn(src, dst *types.Type) (param, result types.Kind) {
-	if ssagen.Arch.SoftFloat {
-		return types.Txxx, types.Txxx
-	}
-
-	switch ssagen.Arch.LinkArch.Family {
-	case sys.ARM, sys.MIPS:
-		if src.IsFloat() {
-			switch dst.Kind() {
-			case types.TINT64, types.TUINT64:
-				return types.TFLOAT64, dst.Kind()
-			}
-		}
-		if dst.IsFloat() {
-			switch src.Kind() {
-			case types.TINT64, types.TUINT64:
-				return src.Kind(), types.TFLOAT64
-			}
-		}
-
-	case sys.I386:
-		if src.IsFloat() {
-			switch dst.Kind() {
-			case types.TINT64, types.TUINT64:
-				return types.TFLOAT64, dst.Kind()
-			case types.TUINT32, types.TUINT, types.TUINTPTR:
-				return types.TFLOAT64, types.TUINT32
-			}
-		}
-		if dst.IsFloat() {
-			switch src.Kind() {
-			case types.TINT64, types.TUINT64:
-				return src.Kind(), types.TFLOAT64
-			case types.TUINT32, types.TUINT, types.TUINTPTR:
-				return types.TUINT32, types.TFLOAT64
-			}
-		}
-	}
-	return types.Txxx, types.Txxx
-}
-
-// TODO(josharian): combine this with its caller and simplify
-func reduceSlice(n *ir.SliceExpr) ir.Node {
-	low, high, max := n.SliceBounds()
-	if high != nil && high.Op() == ir.OLEN && ir.SameSafeExpr(n.X, high.(*ir.UnaryExpr).X) {
-		// Reduce x[i:len(x)] to x[i:].
-		high = nil
-	}
-	n.SetSliceBounds(low, high, max)
-	if (n.Op() == ir.OSLICE || n.Op() == ir.OSLICESTR) && low == nil && high == nil {
-		// Reduce x[:] to x.
-		if base.Debug.Slice > 0 {
-			base.Warn("slice: omit slice operation")
-		}
-		return n.X
-	}
-	return n
-}
-
-func ascompatee1(l ir.Node, r ir.Node, init *ir.Nodes) *ir.AssignStmt {
-	// convas will turn map assigns into function calls,
-	// making it impossible for reorder3 to work.
-	n := ir.NewAssignStmt(base.Pos, l, r)
-
-	if l.Op() == ir.OINDEXMAP {
-		return n
-	}
-
-	return convas(n, init)
-}
-
-func ascompatee(op ir.Op, nl, nr []ir.Node, init *ir.Nodes) []ir.Node {
-	// check assign expression list to
-	// an expression list. called in
-	//	expr-list = expr-list
-
-	// ensure order of evaluation for function calls
-	for i := range nl {
-		nl[i] = safeexpr(nl[i], init)
-	}
-	for i1 := range nr {
-		nr[i1] = safeexpr(nr[i1], init)
-	}
-
-	var nn []*ir.AssignStmt
-	i := 0
-	for ; i < len(nl); i++ {
-		if i >= len(nr) {
-			break
-		}
-		// Do not generate 'x = x' during return. See issue 4014.
-		if op == ir.ORETURN && ir.SameSafeExpr(nl[i], nr[i]) {
-			continue
-		}
-		nn = append(nn, ascompatee1(nl[i], nr[i], init))
-	}
-
-	// cannot happen: caller checked that lists had same length
-	if i < len(nl) || i < len(nr) {
-		var nln, nrn ir.Nodes
-		nln.Set(nl)
-		nrn.Set(nr)
-		base.Fatalf("error in shape across %+v %v %+v / %d %d [%s]", nln, op, nrn, len(nl), len(nr), ir.FuncName(ir.CurFunc))
-	}
-	return reorder3(nn)
-}
-
-// fncall reports whether assigning an rvalue of type rt to an lvalue l might involve a function call.
-func fncall(l ir.Node, rt *types.Type) bool {
-	if l.HasCall() || l.Op() == ir.OINDEXMAP {
-		return true
-	}
-	if types.Identical(l.Type(), rt) {
-		return false
-	}
-	// There might be a conversion required, which might involve a runtime call.
-	return true
-}
-
-// check assign type list to
-// an expression list. called in
-//	expr-list = func()
-func ascompatet(nl ir.Nodes, nr *types.Type) []ir.Node {
-	if len(nl) != nr.NumFields() {
-		base.Fatalf("ascompatet: assignment count mismatch: %d = %d", len(nl), nr.NumFields())
-	}
-
-	var nn, mm ir.Nodes
-	for i, l := range nl {
-		if ir.IsBlank(l) {
-			continue
-		}
-		r := nr.Field(i)
-
-		// Any assignment to an lvalue that might cause a function call must be
-		// deferred until all the returned values have been read.
-		if fncall(l, r.Type) {
-			tmp := ir.Node(typecheck.Temp(r.Type))
-			tmp = typecheck.Expr(tmp)
-			a := convas(ir.NewAssignStmt(base.Pos, l, tmp), &mm)
-			mm.Append(a)
-			l = tmp
-		}
-
-		res := ir.NewResultExpr(base.Pos, nil, types.BADWIDTH)
-		res.Offset = base.Ctxt.FixedFrameSize() + r.Offset
-		res.SetType(r.Type)
-		res.SetTypecheck(1)
-
-		a := convas(ir.NewAssignStmt(base.Pos, l, res), &nn)
-		updateHasCall(a)
-		if a.HasCall() {
-			ir.Dump("ascompatet ucount", a)
-			base.Fatalf("ascompatet: too many function calls evaluating parameters")
-		}
-
-		nn.Append(a)
-	}
-	return append(nn, mm...)
-}
-
-func walkCall(n *ir.CallExpr, init *ir.Nodes) {
-	if len(n.Rargs) != 0 {
-		return // already walked
-	}
-
-	params := n.X.Type().Params()
-	args := n.Args
-
-	n.X = walkexpr(n.X, init)
-	walkexprlist(args, init)
-
-	// If this is a method call, add the receiver at the beginning of the args.
-	if n.Op() == ir.OCALLMETH {
-		withRecv := make([]ir.Node, len(args)+1)
-		dot := n.X.(*ir.SelectorExpr)
-		withRecv[0] = dot.X
-		dot.X = nil
-		copy(withRecv[1:], args)
-		args = withRecv
-	}
-
-	// For any argument whose evaluation might require a function call,
-	// store that argument into a temporary variable,
-	// to prevent that calls from clobbering arguments already on the stack.
-	// When instrumenting, all arguments might require function calls.
-	var tempAssigns []ir.Node
-	for i, arg := range args {
-		updateHasCall(arg)
-		// Determine param type.
-		var t *types.Type
-		if n.Op() == ir.OCALLMETH {
-			if i == 0 {
-				t = n.X.Type().Recv().Type
-			} else {
-				t = params.Field(i - 1).Type
-			}
-		} else {
-			t = params.Field(i).Type
-		}
-		if base.Flag.Cfg.Instrumenting || fncall(arg, t) {
-			// make assignment of fncall to tempAt
-			tmp := typecheck.Temp(t)
-			a := convas(ir.NewAssignStmt(base.Pos, tmp, arg), init)
-			tempAssigns = append(tempAssigns, a)
-			// replace arg with temp
-			args[i] = tmp
-		}
-	}
-
-	n.Args.Set(tempAssigns)
-	n.Rargs.Set(args)
-}
-
-// generate code for print
-func walkprint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
-	// Hoist all the argument evaluation up before the lock.
-	walkexprlistcheap(nn.Args, init)
-
-	// For println, add " " between elements and "\n" at the end.
-	if nn.Op() == ir.OPRINTN {
-		s := nn.Args
-		t := make([]ir.Node, 0, len(s)*2)
-		for i, n := range s {
-			if i != 0 {
-				t = append(t, ir.NewString(" "))
-			}
-			t = append(t, n)
-		}
-		t = append(t, ir.NewString("\n"))
-		nn.Args.Set(t)
-	}
-
-	// Collapse runs of constant strings.
-	s := nn.Args
-	t := make([]ir.Node, 0, len(s))
-	for i := 0; i < len(s); {
-		var strs []string
-		for i < len(s) && ir.IsConst(s[i], constant.String) {
-			strs = append(strs, ir.StringVal(s[i]))
-			i++
-		}
-		if len(strs) > 0 {
-			t = append(t, ir.NewString(strings.Join(strs, "")))
-		}
-		if i < len(s) {
-			t = append(t, s[i])
-			i++
-		}
-	}
-	nn.Args.Set(t)
-
-	calls := []ir.Node{mkcall("printlock", nil, init)}
-	for i, n := range nn.Args {
-		if n.Op() == ir.OLITERAL {
-			if n.Type() == types.UntypedRune {
-				n = typecheck.DefaultLit(n, types.RuneType)
-			}
-
-			switch n.Val().Kind() {
-			case constant.Int:
-				n = typecheck.DefaultLit(n, types.Types[types.TINT64])
-
-			case constant.Float:
-				n = typecheck.DefaultLit(n, types.Types[types.TFLOAT64])
-			}
-		}
-
-		if n.Op() != ir.OLITERAL && n.Type() != nil && n.Type().Kind() == types.TIDEAL {
-			n = typecheck.DefaultLit(n, types.Types[types.TINT64])
-		}
-		n = typecheck.DefaultLit(n, nil)
-		nn.Args[i] = n
-		if n.Type() == nil || n.Type().Kind() == types.TFORW {
-			continue
-		}
-
-		var on *ir.Name
-		switch n.Type().Kind() {
-		case types.TINTER:
-			if n.Type().IsEmptyInterface() {
-				on = typecheck.LookupRuntime("printeface")
-			} else {
-				on = typecheck.LookupRuntime("printiface")
-			}
-			on = typecheck.SubstArgTypes(on, n.Type()) // any-1
-		case types.TPTR:
-			if n.Type().Elem().NotInHeap() {
-				on = typecheck.LookupRuntime("printuintptr")
-				n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
-				n.SetType(types.Types[types.TUNSAFEPTR])
-				n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
-				n.SetType(types.Types[types.TUINTPTR])
-				break
-			}
-			fallthrough
-		case types.TCHAN, types.TMAP, types.TFUNC, types.TUNSAFEPTR:
-			on = typecheck.LookupRuntime("printpointer")
-			on = typecheck.SubstArgTypes(on, n.Type()) // any-1
-		case types.TSLICE:
-			on = typecheck.LookupRuntime("printslice")
-			on = typecheck.SubstArgTypes(on, n.Type()) // any-1
-		case types.TUINT, types.TUINT8, types.TUINT16, types.TUINT32, types.TUINT64, types.TUINTPTR:
-			if types.IsRuntimePkg(n.Type().Sym().Pkg) && n.Type().Sym().Name == "hex" {
-				on = typecheck.LookupRuntime("printhex")
-			} else {
-				on = typecheck.LookupRuntime("printuint")
-			}
-		case types.TINT, types.TINT8, types.TINT16, types.TINT32, types.TINT64:
-			on = typecheck.LookupRuntime("printint")
-		case types.TFLOAT32, types.TFLOAT64:
-			on = typecheck.LookupRuntime("printfloat")
-		case types.TCOMPLEX64, types.TCOMPLEX128:
-			on = typecheck.LookupRuntime("printcomplex")
-		case types.TBOOL:
-			on = typecheck.LookupRuntime("printbool")
-		case types.TSTRING:
-			cs := ""
-			if ir.IsConst(n, constant.String) {
-				cs = ir.StringVal(n)
-			}
-			switch cs {
-			case " ":
-				on = typecheck.LookupRuntime("printsp")
-			case "\n":
-				on = typecheck.LookupRuntime("printnl")
-			default:
-				on = typecheck.LookupRuntime("printstring")
-			}
-		default:
-			badtype(ir.OPRINT, n.Type(), nil)
-			continue
-		}
-
-		r := ir.NewCallExpr(base.Pos, ir.OCALL, on, nil)
-		if params := on.Type().Params().FieldSlice(); len(params) > 0 {
-			t := params[0].Type
-			if !types.Identical(t, n.Type()) {
-				n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
-				n.SetType(t)
-			}
-			r.Args.Append(n)
-		}
-		calls = append(calls, r)
-	}
-
-	calls = append(calls, mkcall("printunlock", nil, init))
-
-	typecheck.Stmts(calls)
-	walkexprlist(calls, init)
-
-	r := ir.NewBlockStmt(base.Pos, nil)
-	r.List.Set(calls)
-	return walkstmt(typecheck.Stmt(r))
-}
-
-func callnew(t *types.Type) ir.Node {
-	types.CalcSize(t)
-	n := ir.NewUnaryExpr(base.Pos, ir.ONEWOBJ, reflectdata.TypePtr(t))
-	n.SetType(types.NewPtr(t))
-	n.SetTypecheck(1)
-	n.MarkNonNil()
-	return n
-}
-
-func convas(n *ir.AssignStmt, init *ir.Nodes) *ir.AssignStmt {
-	if n.Op() != ir.OAS {
-		base.Fatalf("convas: not OAS %v", n.Op())
-	}
-	defer updateHasCall(n)
-
-	n.SetTypecheck(1)
-
-	if n.X == nil || n.Y == nil {
-		return n
-	}
-
-	lt := n.X.Type()
-	rt := n.Y.Type()
-	if lt == nil || rt == nil {
-		return n
-	}
-
-	if ir.IsBlank(n.X) {
-		n.Y = typecheck.DefaultLit(n.Y, nil)
-		return n
-	}
-
-	if !types.Identical(lt, rt) {
-		n.Y = typecheck.AssignConv(n.Y, lt, "assignment")
-		n.Y = walkexpr(n.Y, init)
-	}
-	types.CalcSize(n.Y.Type())
-
-	return n
-}
-
-// reorder3
-// from ascompatee
-//	a,b = c,d
-// simultaneous assignment. there cannot
-// be later use of an earlier lvalue.
-//
-// function calls have been removed.
-func reorder3(all []*ir.AssignStmt) []ir.Node {
-	// If a needed expression may be affected by an
-	// earlier assignment, make an early copy of that
-	// expression and use the copy instead.
-	var early []ir.Node
-
-	var mapinit ir.Nodes
-	for i, n := range all {
-		l := n.X
-
-		// Save subexpressions needed on left side.
-		// Drill through non-dereferences.
-		for {
-			switch ll := l; ll.Op() {
-			case ir.ODOT:
-				ll := ll.(*ir.SelectorExpr)
-				l = ll.X
-				continue
-			case ir.OPAREN:
-				ll := ll.(*ir.ParenExpr)
-				l = ll.X
-				continue
-			case ir.OINDEX:
-				ll := ll.(*ir.IndexExpr)
-				if ll.X.Type().IsArray() {
-					ll.Index = reorder3save(ll.Index, all, i, &early)
-					l = ll.X
-					continue
-				}
-			}
-			break
-		}
-
-		switch l.Op() {
-		default:
-			base.Fatalf("reorder3 unexpected lvalue %v", l.Op())
-
-		case ir.ONAME:
-			break
-
-		case ir.OINDEX, ir.OINDEXMAP:
-			l := l.(*ir.IndexExpr)
-			l.X = reorder3save(l.X, all, i, &early)
-			l.Index = reorder3save(l.Index, all, i, &early)
-			if l.Op() == ir.OINDEXMAP {
-				all[i] = convas(all[i], &mapinit)
-			}
-
-		case ir.ODEREF:
-			l := l.(*ir.StarExpr)
-			l.X = reorder3save(l.X, all, i, &early)
-		case ir.ODOTPTR:
-			l := l.(*ir.SelectorExpr)
-			l.X = reorder3save(l.X, all, i, &early)
-		}
-
-		// Save expression on right side.
-		all[i].Y = reorder3save(all[i].Y, all, i, &early)
-	}
-
-	early = append(mapinit, early...)
-	for _, as := range all {
-		early = append(early, as)
-	}
-	return early
-}
-
-// if the evaluation of *np would be affected by the
-// assignments in all up to but not including the ith assignment,
-// copy into a temporary during *early and
-// replace *np with that temp.
-// The result of reorder3save MUST be assigned back to n, e.g.
-// 	n.Left = reorder3save(n.Left, all, i, early)
-func reorder3save(n ir.Node, all []*ir.AssignStmt, i int, early *[]ir.Node) ir.Node {
-	if !aliased(n, all[:i]) {
-		return n
-	}
-
-	q := ir.Node(typecheck.Temp(n.Type()))
-	as := typecheck.Stmt(ir.NewAssignStmt(base.Pos, q, n))
-	*early = append(*early, as)
-	return q
-}
-
-// Is it possible that the computation of r might be
-// affected by assignments in all?
-func aliased(r ir.Node, all []*ir.AssignStmt) bool {
-	if r == nil {
-		return false
-	}
-
-	// Treat all fields of a struct as referring to the whole struct.
-	// We could do better but we would have to keep track of the fields.
-	for r.Op() == ir.ODOT {
-		r = r.(*ir.SelectorExpr).X
-	}
-
-	// Look for obvious aliasing: a variable being assigned
-	// during the all list and appearing in n.
-	// Also record whether there are any writes to addressable
-	// memory (either main memory or variables whose addresses
-	// have been taken).
-	memwrite := false
-	for _, as := range all {
-		// We can ignore assignments to blank.
-		if ir.IsBlank(as.X) {
-			continue
-		}
-
-		lv := ir.OuterValue(as.X)
-		if lv.Op() != ir.ONAME {
-			memwrite = true
-			continue
-		}
-		l := lv.(*ir.Name)
-
-		switch l.Class_ {
-		default:
-			base.Fatalf("unexpected class: %v, %v", l, l.Class_)
-
-		case ir.PAUTOHEAP, ir.PEXTERN:
-			memwrite = true
-			continue
-
-		case ir.PAUTO, ir.PPARAM, ir.PPARAMOUT:
-			if l.Name().Addrtaken() {
-				memwrite = true
-				continue
-			}
-
-			if refersToName(l, r) {
-				// Direct hit: l appears in r.
-				return true
-			}
-		}
-	}
-
-	// The variables being written do not appear in r.
-	// However, r might refer to computed addresses
-	// that are being written.
-
-	// If no computed addresses are affected by the writes, no aliasing.
-	if !memwrite {
-		return false
-	}
-
-	// If r does not refer to any variables whose addresses have been taken,
-	// then the only possible writes to r would be directly to the variables,
-	// and we checked those above, so no aliasing problems.
-	if !anyAddrTaken(r) {
-		return false
-	}
-
-	// Otherwise, both the writes and r refer to computed memory addresses.
-	// Assume that they might conflict.
-	return true
-}
-
-// anyAddrTaken reports whether the evaluation n,
-// which appears on the left side of an assignment,
-// may refer to variables whose addresses have been taken.
-func anyAddrTaken(n ir.Node) bool {
-	return ir.Any(n, func(n ir.Node) bool {
-		switch n.Op() {
-		case ir.ONAME:
-			n := n.(*ir.Name)
-			return n.Class_ == ir.PEXTERN || n.Class_ == ir.PAUTOHEAP || n.Name().Addrtaken()
-
-		case ir.ODOT: // but not ODOTPTR - should have been handled in aliased.
-			base.Fatalf("anyAddrTaken unexpected ODOT")
-
-		case ir.OADD,
-			ir.OAND,
-			ir.OANDAND,
-			ir.OANDNOT,
-			ir.OBITNOT,
-			ir.OCONV,
-			ir.OCONVIFACE,
-			ir.OCONVNOP,
-			ir.ODIV,
-			ir.ODOTTYPE,
-			ir.OLITERAL,
-			ir.OLSH,
-			ir.OMOD,
-			ir.OMUL,
-			ir.ONEG,
-			ir.ONIL,
-			ir.OOR,
-			ir.OOROR,
-			ir.OPAREN,
-			ir.OPLUS,
-			ir.ORSH,
-			ir.OSUB,
-			ir.OXOR:
-			return false
-		}
-		// Be conservative.
-		return true
-	})
-}
-
-// refersToName reports whether r refers to name.
-func refersToName(name *ir.Name, r ir.Node) bool {
-	return ir.Any(r, func(r ir.Node) bool {
-		return r.Op() == ir.ONAME && r == name
-	})
-}
-
-var stop = errors.New("stop")
-
-// refersToCommonName reports whether any name
-// appears in common between l and r.
-// This is called from sinit.go.
-func refersToCommonName(l ir.Node, r ir.Node) bool {
-	if l == nil || r == nil {
-		return false
-	}
-
-	// This could be written elegantly as a Find nested inside a Find:
-	//
-	//	found := ir.Find(l, func(l ir.Node) interface{} {
-	//		if l.Op() == ir.ONAME {
-	//			return ir.Find(r, func(r ir.Node) interface{} {
-	//				if r.Op() == ir.ONAME && l.Name() == r.Name() {
-	//					return r
-	//				}
-	//				return nil
-	//			})
-	//		}
-	//		return nil
-	//	})
-	//	return found != nil
-	//
-	// But that would allocate a new closure for the inner Find
-	// for each name found on the left side.
-	// It may not matter at all, but the below way of writing it
-	// only allocates two closures, not O(|L|) closures.
-
-	var doL, doR func(ir.Node) error
-	var targetL *ir.Name
-	doR = func(r ir.Node) error {
-		if r.Op() == ir.ONAME && r.Name() == targetL {
-			return stop
-		}
-		return ir.DoChildren(r, doR)
-	}
-	doL = func(l ir.Node) error {
-		if l.Op() == ir.ONAME {
-			l := l.(*ir.Name)
-			targetL = l.Name()
-			if doR(r) == stop {
-				return stop
-			}
-		}
-		return ir.DoChildren(l, doL)
-	}
-	return doL(l) == stop
-}
-
-// paramstoheap returns code to allocate memory for heap-escaped parameters
-// and to copy non-result parameters' values from the stack.
-func paramstoheap(params *types.Type) []ir.Node {
-	var nn []ir.Node
-	for _, t := range params.Fields().Slice() {
-		v := ir.AsNode(t.Nname)
-		if v != nil && v.Sym() != nil && strings.HasPrefix(v.Sym().Name, "~r") { // unnamed result
-			v = nil
-		}
-		if v == nil {
-			continue
-		}
-
-		if stackcopy := v.Name().Stackcopy; stackcopy != nil {
-			nn = append(nn, walkstmt(ir.NewDecl(base.Pos, ir.ODCL, v)))
-			if stackcopy.Class_ == ir.PPARAM {
-				nn = append(nn, walkstmt(typecheck.Stmt(ir.NewAssignStmt(base.Pos, v, stackcopy))))
-			}
-		}
-	}
-
-	return nn
-}
-
-// zeroResults zeros the return values at the start of the function.
-// We need to do this very early in the function.  Defer might stop a
-// panic and show the return values as they exist at the time of
-// panic.  For precise stacks, the garbage collector assumes results
-// are always live, so we need to zero them before any allocations,
-// even allocations to move params/results to the heap.
-// The generated code is added to Curfn's Enter list.
-func zeroResults() {
-	for _, f := range ir.CurFunc.Type().Results().Fields().Slice() {
-		v := ir.AsNode(f.Nname)
-		if v != nil && v.Name().Heapaddr != nil {
-			// The local which points to the return value is the
-			// thing that needs zeroing. This is already handled
-			// by a Needzero annotation in plive.go:livenessepilogue.
-			continue
-		}
-		if ir.IsParamHeapCopy(v) {
-			// TODO(josharian/khr): Investigate whether we can switch to "continue" here,
-			// and document more in either case.
-			// In the review of CL 114797, Keith wrote (roughly):
-			// I don't think the zeroing below matters.
-			// The stack return value will never be marked as live anywhere in the function.
-			// It is not written to until deferreturn returns.
-			v = v.Name().Stackcopy
-		}
-		// Zero the stack location containing f.
-		ir.CurFunc.Enter.Append(ir.NewAssignStmt(ir.CurFunc.Pos(), v, nil))
-	}
-}
-
-// returnsfromheap returns code to copy values for heap-escaped parameters
-// back to the stack.
-func returnsfromheap(params *types.Type) []ir.Node {
-	var nn []ir.Node
-	for _, t := range params.Fields().Slice() {
-		v := ir.AsNode(t.Nname)
-		if v == nil {
-			continue
-		}
-		if stackcopy := v.Name().Stackcopy; stackcopy != nil && stackcopy.Class_ == ir.PPARAMOUT {
-			nn = append(nn, walkstmt(typecheck.Stmt(ir.NewAssignStmt(base.Pos, stackcopy, v))))
-		}
-	}
-
-	return nn
-}
-
-// heapmoves generates code to handle migrating heap-escaped parameters
-// between the stack and the heap. The generated code is added to Curfn's
-// Enter and Exit lists.
-func heapmoves() {
-	lno := base.Pos
-	base.Pos = ir.CurFunc.Pos()
-	nn := paramstoheap(ir.CurFunc.Type().Recvs())
-	nn = append(nn, paramstoheap(ir.CurFunc.Type().Params())...)
-	nn = append(nn, paramstoheap(ir.CurFunc.Type().Results())...)
-	ir.CurFunc.Enter.Append(nn...)
-	base.Pos = ir.CurFunc.Endlineno
-	ir.CurFunc.Exit.Append(returnsfromheap(ir.CurFunc.Type().Results())...)
-	base.Pos = lno
-}
-
-func vmkcall(fn ir.Node, t *types.Type, init *ir.Nodes, va []ir.Node) *ir.CallExpr {
-	if fn.Type() == nil || fn.Type().Kind() != types.TFUNC {
-		base.Fatalf("mkcall %v %v", fn, fn.Type())
-	}
-
-	n := fn.Type().NumParams()
-	if n != len(va) {
-		base.Fatalf("vmkcall %v needs %v args got %v", fn, n, len(va))
-	}
-
-	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, va)
-	typecheck.Call(call)
-	call.SetType(t)
-	return walkexpr(call, init).(*ir.CallExpr)
-}
-
-func mkcall(name string, t *types.Type, init *ir.Nodes, args ...ir.Node) *ir.CallExpr {
-	return vmkcall(typecheck.LookupRuntime(name), t, init, args)
-}
-
-func mkcall1(fn ir.Node, t *types.Type, init *ir.Nodes, args ...ir.Node) *ir.CallExpr {
-	return vmkcall(fn, t, init, args)
-}
-
-// byteindex converts n, which is byte-sized, to an int used to index into an array.
-// We cannot use conv, because we allow converting bool to int here,
-// which is forbidden in user code.
-func byteindex(n ir.Node) ir.Node {
-	// We cannot convert from bool to int directly.
-	// While converting from int8 to int is possible, it would yield
-	// the wrong result for negative values.
-	// Reinterpreting the value as an unsigned byte solves both cases.
-	if !types.Identical(n.Type(), types.Types[types.TUINT8]) {
-		n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
-		n.SetType(types.Types[types.TUINT8])
-		n.SetTypecheck(1)
-	}
-	n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
-	n.SetType(types.Types[types.TINT])
-	n.SetTypecheck(1)
-	return n
-}
-
-func chanfn(name string, n int, t *types.Type) ir.Node {
-	if !t.IsChan() {
-		base.Fatalf("chanfn %v", t)
-	}
-	fn := typecheck.LookupRuntime(name)
-	switch n {
-	default:
-		base.Fatalf("chanfn %d", n)
-	case 1:
-		fn = typecheck.SubstArgTypes(fn, t.Elem())
-	case 2:
-		fn = typecheck.SubstArgTypes(fn, t.Elem(), t.Elem())
-	}
-	return fn
-}
-
-func mapfn(name string, t *types.Type) ir.Node {
-	if !t.IsMap() {
-		base.Fatalf("mapfn %v", t)
-	}
-	fn := typecheck.LookupRuntime(name)
-	fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem(), t.Key(), t.Elem())
-	return fn
-}
-
-func mapfndel(name string, t *types.Type) ir.Node {
-	if !t.IsMap() {
-		base.Fatalf("mapfn %v", t)
-	}
-	fn := typecheck.LookupRuntime(name)
-	fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem(), t.Key())
-	return fn
-}
-
-const (
-	mapslow = iota
-	mapfast32
-	mapfast32ptr
-	mapfast64
-	mapfast64ptr
-	mapfaststr
-	nmapfast
-)
-
-type mapnames [nmapfast]string
-
-func mkmapnames(base string, ptr string) mapnames {
-	return mapnames{base, base + "_fast32", base + "_fast32" + ptr, base + "_fast64", base + "_fast64" + ptr, base + "_faststr"}
-}
-
-var mapaccess1 = mkmapnames("mapaccess1", "")
-var mapaccess2 = mkmapnames("mapaccess2", "")
-var mapassign = mkmapnames("mapassign", "ptr")
-var mapdelete = mkmapnames("mapdelete", "")
-
-func mapfast(t *types.Type) int {
-	// Check runtime/map.go:maxElemSize before changing.
-	if t.Elem().Width > 128 {
-		return mapslow
-	}
-	switch reflectdata.AlgType(t.Key()) {
-	case types.AMEM32:
-		if !t.Key().HasPointers() {
-			return mapfast32
-		}
-		if types.PtrSize == 4 {
-			return mapfast32ptr
-		}
-		base.Fatalf("small pointer %v", t.Key())
-	case types.AMEM64:
-		if !t.Key().HasPointers() {
-			return mapfast64
-		}
-		if types.PtrSize == 8 {
-			return mapfast64ptr
-		}
-		// Two-word object, at least one of which is a pointer.
-		// Use the slow path.
-	case types.ASTRING:
-		return mapfaststr
-	}
-	return mapslow
-}
-
-func writebarrierfn(name string, l *types.Type, r *types.Type) ir.Node {
-	fn := typecheck.LookupRuntime(name)
-	fn = typecheck.SubstArgTypes(fn, l, r)
-	return fn
-}
-
-func addstr(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
-	c := len(n.List)
-
-	if c < 2 {
-		base.Fatalf("addstr count %d too small", c)
-	}
-
-	buf := typecheck.NodNil()
-	if n.Esc() == ir.EscNone {
-		sz := int64(0)
-		for _, n1 := range n.List {
-			if n1.Op() == ir.OLITERAL {
-				sz += int64(len(ir.StringVal(n1)))
-			}
-		}
-
-		// Don't allocate the buffer if the result won't fit.
-		if sz < tmpstringbufsize {
-			// Create temporary buffer for result string on stack.
-			t := types.NewArray(types.Types[types.TUINT8], tmpstringbufsize)
-			buf = typecheck.NodAddr(typecheck.Temp(t))
-		}
-	}
-
-	// build list of string arguments
-	args := []ir.Node{buf}
-	for _, n2 := range n.List {
-		args = append(args, typecheck.Conv(n2, types.Types[types.TSTRING]))
-	}
-
-	var fn string
-	if c <= 5 {
-		// small numbers of strings use direct runtime helpers.
-		// note: order.expr knows this cutoff too.
-		fn = fmt.Sprintf("concatstring%d", c)
-	} else {
-		// large numbers of strings are passed to the runtime as a slice.
-		fn = "concatstrings"
-
-		t := types.NewSlice(types.Types[types.TSTRING])
-		// args[1:] to skip buf arg
-		slice := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(t), args[1:])
-		slice.Prealloc = n.Prealloc
-		args = []ir.Node{buf, slice}
-		slice.SetEsc(ir.EscNone)
-	}
-
-	cat := typecheck.LookupRuntime(fn)
-	r := ir.NewCallExpr(base.Pos, ir.OCALL, cat, nil)
-	r.Args.Set(args)
-	r1 := typecheck.Expr(r)
-	r1 = walkexpr(r1, init)
-	r1.SetType(n.Type())
-
-	return r1
-}
-
-func walkAppendArgs(n *ir.CallExpr, init *ir.Nodes) {
-	walkexprlistsafe(n.Args, init)
-
-	// walkexprlistsafe will leave OINDEX (s[n]) alone if both s
-	// and n are name or literal, but those may index the slice we're
-	// modifying here. Fix explicitly.
-	ls := n.Args
-	for i1, n1 := range ls {
-		ls[i1] = cheapexpr(n1, init)
-	}
-}
-
-// expand append(l1, l2...) to
-//   init {
-//     s := l1
-//     n := len(s) + len(l2)
-//     // Compare as uint so growslice can panic on overflow.
-//     if uint(n) > uint(cap(s)) {
-//       s = growslice(s, n)
-//     }
-//     s = s[:n]
-//     memmove(&s[len(l1)], &l2[0], len(l2)*sizeof(T))
-//   }
-//   s
-//
-// l2 is allowed to be a string.
-func appendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
-	walkAppendArgs(n, init)
-
-	l1 := n.Args[0]
-	l2 := n.Args[1]
-	l2 = cheapexpr(l2, init)
-	n.Args[1] = l2
-
-	var nodes ir.Nodes
-
-	// var s []T
-	s := typecheck.Temp(l1.Type())
-	nodes.Append(ir.NewAssignStmt(base.Pos, s, l1)) // s = l1
-
-	elemtype := s.Type().Elem()
-
-	// n := len(s) + len(l2)
-	nn := typecheck.Temp(types.Types[types.TINT])
-	nodes.Append(ir.NewAssignStmt(base.Pos, nn, ir.NewBinaryExpr(base.Pos, ir.OADD, ir.NewUnaryExpr(base.Pos, ir.OLEN, s), ir.NewUnaryExpr(base.Pos, ir.OLEN, l2))))
-
-	// if uint(n) > uint(cap(s))
-	nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
-	nuint := typecheck.Conv(nn, types.Types[types.TUINT])
-	scapuint := typecheck.Conv(ir.NewUnaryExpr(base.Pos, ir.OCAP, s), types.Types[types.TUINT])
-	nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OGT, nuint, scapuint)
-
-	// instantiate growslice(typ *type, []any, int) []any
-	fn := typecheck.LookupRuntime("growslice")
-	fn = typecheck.SubstArgTypes(fn, elemtype, elemtype)
-
-	// s = growslice(T, s, n)
-	nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, s, mkcall1(fn, s.Type(), nif.PtrInit(), reflectdata.TypePtr(elemtype), s, nn))}
-	nodes.Append(nif)
-
-	// s = s[:n]
-	nt := ir.NewSliceExpr(base.Pos, ir.OSLICE, s)
-	nt.SetSliceBounds(nil, nn, nil)
-	nt.SetBounded(true)
-	nodes.Append(ir.NewAssignStmt(base.Pos, s, nt))
-
-	var ncopy ir.Node
-	if elemtype.HasPointers() {
-		// copy(s[len(l1):], l2)
-		slice := ir.NewSliceExpr(base.Pos, ir.OSLICE, s)
-		slice.SetType(s.Type())
-		slice.SetSliceBounds(ir.NewUnaryExpr(base.Pos, ir.OLEN, l1), nil, nil)
-
-		ir.CurFunc.SetWBPos(n.Pos())
-
-		// instantiate typedslicecopy(typ *type, dstPtr *any, dstLen int, srcPtr *any, srcLen int) int
-		fn := typecheck.LookupRuntime("typedslicecopy")
-		fn = typecheck.SubstArgTypes(fn, l1.Type().Elem(), l2.Type().Elem())
-		ptr1, len1 := backingArrayPtrLen(cheapexpr(slice, &nodes))
-		ptr2, len2 := backingArrayPtrLen(l2)
-		ncopy = mkcall1(fn, types.Types[types.TINT], &nodes, reflectdata.TypePtr(elemtype), ptr1, len1, ptr2, len2)
-	} else if base.Flag.Cfg.Instrumenting && !base.Flag.CompilingRuntime {
-		// rely on runtime to instrument:
-		//  copy(s[len(l1):], l2)
-		// l2 can be a slice or string.
-		slice := ir.NewSliceExpr(base.Pos, ir.OSLICE, s)
-		slice.SetType(s.Type())
-		slice.SetSliceBounds(ir.NewUnaryExpr(base.Pos, ir.OLEN, l1), nil, nil)
-
-		ptr1, len1 := backingArrayPtrLen(cheapexpr(slice, &nodes))
-		ptr2, len2 := backingArrayPtrLen(l2)
-
-		fn := typecheck.LookupRuntime("slicecopy")
-		fn = typecheck.SubstArgTypes(fn, ptr1.Type().Elem(), ptr2.Type().Elem())
-		ncopy = mkcall1(fn, types.Types[types.TINT], &nodes, ptr1, len1, ptr2, len2, ir.NewInt(elemtype.Width))
-	} else {
-		// memmove(&s[len(l1)], &l2[0], len(l2)*sizeof(T))
-		ix := ir.NewIndexExpr(base.Pos, s, ir.NewUnaryExpr(base.Pos, ir.OLEN, l1))
-		ix.SetBounded(true)
-		addr := typecheck.NodAddr(ix)
-
-		sptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, l2)
-
-		nwid := cheapexpr(typecheck.Conv(ir.NewUnaryExpr(base.Pos, ir.OLEN, l2), types.Types[types.TUINTPTR]), &nodes)
-		nwid = ir.NewBinaryExpr(base.Pos, ir.OMUL, nwid, ir.NewInt(elemtype.Width))
-
-		// instantiate func memmove(to *any, frm *any, length uintptr)
-		fn := typecheck.LookupRuntime("memmove")
-		fn = typecheck.SubstArgTypes(fn, elemtype, elemtype)
-		ncopy = mkcall1(fn, nil, &nodes, addr, sptr, nwid)
-	}
-	ln := append(nodes, ncopy)
-
-	typecheck.Stmts(ln)
-	walkstmtlist(ln)
-	init.Append(ln...)
-	return s
-}
-
-// isAppendOfMake reports whether n is of the form append(x , make([]T, y)...).
-// isAppendOfMake assumes n has already been typechecked.
-func isAppendOfMake(n ir.Node) bool {
-	if base.Flag.N != 0 || base.Flag.Cfg.Instrumenting {
-		return false
-	}
-
-	if n.Typecheck() == 0 {
-		base.Fatalf("missing typecheck: %+v", n)
-	}
-
-	if n.Op() != ir.OAPPEND {
-		return false
-	}
-	call := n.(*ir.CallExpr)
-	if !call.IsDDD || len(call.Args) != 2 || call.Args[1].Op() != ir.OMAKESLICE {
-		return false
-	}
-
-	mk := call.Args[1].(*ir.MakeExpr)
-	if mk.Cap != nil {
-		return false
-	}
-
-	// y must be either an integer constant or the largest possible positive value
-	// of variable y needs to fit into an uint.
-
-	// typecheck made sure that constant arguments to make are not negative and fit into an int.
-
-	// The care of overflow of the len argument to make will be handled by an explicit check of int(len) < 0 during runtime.
-	y := mk.Len
-	if !ir.IsConst(y, constant.Int) && y.Type().Size() > types.Types[types.TUINT].Size() {
-		return false
-	}
-
-	return true
-}
-
-// extendslice rewrites append(l1, make([]T, l2)...) to
-//   init {
-//     if l2 >= 0 { // Empty if block here for more meaningful node.SetLikely(true)
-//     } else {
-//       panicmakeslicelen()
-//     }
-//     s := l1
-//     n := len(s) + l2
-//     // Compare n and s as uint so growslice can panic on overflow of len(s) + l2.
-//     // cap is a positive int and n can become negative when len(s) + l2
-//     // overflows int. Interpreting n when negative as uint makes it larger
-//     // than cap(s). growslice will check the int n arg and panic if n is
-//     // negative. This prevents the overflow from being undetected.
-//     if uint(n) > uint(cap(s)) {
-//       s = growslice(T, s, n)
-//     }
-//     s = s[:n]
-//     lptr := &l1[0]
-//     sptr := &s[0]
-//     if lptr == sptr || !T.HasPointers() {
-//       // growslice did not clear the whole underlying array (or did not get called)
-//       hp := &s[len(l1)]
-//       hn := l2 * sizeof(T)
-//       memclr(hp, hn)
-//     }
-//   }
-//   s
-func extendslice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
-	// isAppendOfMake made sure all possible positive values of l2 fit into an uint.
-	// The case of l2 overflow when converting from e.g. uint to int is handled by an explicit
-	// check of l2 < 0 at runtime which is generated below.
-	l2 := typecheck.Conv(n.Args[1].(*ir.MakeExpr).Len, types.Types[types.TINT])
-	l2 = typecheck.Expr(l2)
-	n.Args[1] = l2 // walkAppendArgs expects l2 in n.List.Second().
-
-	walkAppendArgs(n, init)
-
-	l1 := n.Args[0]
-	l2 = n.Args[1] // re-read l2, as it may have been updated by walkAppendArgs
-
-	var nodes []ir.Node
-
-	// if l2 >= 0 (likely happens), do nothing
-	nifneg := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGE, l2, ir.NewInt(0)), nil, nil)
-	nifneg.Likely = true
-
-	// else panicmakeslicelen()
-	nifneg.Else = []ir.Node{mkcall("panicmakeslicelen", nil, init)}
-	nodes = append(nodes, nifneg)
-
-	// s := l1
-	s := typecheck.Temp(l1.Type())
-	nodes = append(nodes, ir.NewAssignStmt(base.Pos, s, l1))
-
-	elemtype := s.Type().Elem()
-
-	// n := len(s) + l2
-	nn := typecheck.Temp(types.Types[types.TINT])
-	nodes = append(nodes, ir.NewAssignStmt(base.Pos, nn, ir.NewBinaryExpr(base.Pos, ir.OADD, ir.NewUnaryExpr(base.Pos, ir.OLEN, s), l2)))
-
-	// if uint(n) > uint(cap(s))
-	nuint := typecheck.Conv(nn, types.Types[types.TUINT])
-	capuint := typecheck.Conv(ir.NewUnaryExpr(base.Pos, ir.OCAP, s), types.Types[types.TUINT])
-	nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGT, nuint, capuint), nil, nil)
-
-	// instantiate growslice(typ *type, old []any, newcap int) []any
-	fn := typecheck.LookupRuntime("growslice")
-	fn = typecheck.SubstArgTypes(fn, elemtype, elemtype)
-
-	// s = growslice(T, s, n)
-	nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, s, mkcall1(fn, s.Type(), nif.PtrInit(), reflectdata.TypePtr(elemtype), s, nn))}
-	nodes = append(nodes, nif)
-
-	// s = s[:n]
-	nt := ir.NewSliceExpr(base.Pos, ir.OSLICE, s)
-	nt.SetSliceBounds(nil, nn, nil)
-	nt.SetBounded(true)
-	nodes = append(nodes, ir.NewAssignStmt(base.Pos, s, nt))
-
-	// lptr := &l1[0]
-	l1ptr := typecheck.Temp(l1.Type().Elem().PtrTo())
-	tmp := ir.NewUnaryExpr(base.Pos, ir.OSPTR, l1)
-	nodes = append(nodes, ir.NewAssignStmt(base.Pos, l1ptr, tmp))
-
-	// sptr := &s[0]
-	sptr := typecheck.Temp(elemtype.PtrTo())
-	tmp = ir.NewUnaryExpr(base.Pos, ir.OSPTR, s)
-	nodes = append(nodes, ir.NewAssignStmt(base.Pos, sptr, tmp))
-
-	// hp := &s[len(l1)]
-	ix := ir.NewIndexExpr(base.Pos, s, ir.NewUnaryExpr(base.Pos, ir.OLEN, l1))
-	ix.SetBounded(true)
-	hp := typecheck.ConvNop(typecheck.NodAddr(ix), types.Types[types.TUNSAFEPTR])
-
-	// hn := l2 * sizeof(elem(s))
-	hn := typecheck.Conv(ir.NewBinaryExpr(base.Pos, ir.OMUL, l2, ir.NewInt(elemtype.Width)), types.Types[types.TUINTPTR])
-
-	clrname := "memclrNoHeapPointers"
-	hasPointers := elemtype.HasPointers()
-	if hasPointers {
-		clrname = "memclrHasPointers"
-		ir.CurFunc.SetWBPos(n.Pos())
-	}
-
-	var clr ir.Nodes
-	clrfn := mkcall(clrname, nil, &clr, hp, hn)
-	clr.Append(clrfn)
-
-	if hasPointers {
-		// if l1ptr == sptr
-		nifclr := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OEQ, l1ptr, sptr), nil, nil)
-		nifclr.Body = clr
-		nodes = append(nodes, nifclr)
-	} else {
-		nodes = append(nodes, clr...)
-	}
-
-	typecheck.Stmts(nodes)
-	walkstmtlist(nodes)
-	init.Append(nodes...)
-	return s
-}
-
-// Rewrite append(src, x, y, z) so that any side effects in
-// x, y, z (including runtime panics) are evaluated in
-// initialization statements before the append.
-// For normal code generation, stop there and leave the
-// rest to cgen_append.
-//
-// For race detector, expand append(src, a [, b]* ) to
-//
-//   init {
-//     s := src
-//     const argc = len(args) - 1
-//     if cap(s) - len(s) < argc {
-//	    s = growslice(s, len(s)+argc)
-//     }
-//     n := len(s)
-//     s = s[:n+argc]
-//     s[n] = a
-//     s[n+1] = b
-//     ...
-//   }
-//   s
-func walkappend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
-	if !ir.SameSafeExpr(dst, n.Args[0]) {
-		n.Args[0] = safeexpr(n.Args[0], init)
-		n.Args[0] = walkexpr(n.Args[0], init)
-	}
-	walkexprlistsafe(n.Args[1:], init)
-
-	nsrc := n.Args[0]
-
-	// walkexprlistsafe will leave OINDEX (s[n]) alone if both s
-	// and n are name or literal, but those may index the slice we're
-	// modifying here. Fix explicitly.
-	// Using cheapexpr also makes sure that the evaluation
-	// of all arguments (and especially any panics) happen
-	// before we begin to modify the slice in a visible way.
-	ls := n.Args[1:]
-	for i, n := range ls {
-		n = cheapexpr(n, init)
-		if !types.Identical(n.Type(), nsrc.Type().Elem()) {
-			n = typecheck.AssignConv(n, nsrc.Type().Elem(), "append")
-			n = walkexpr(n, init)
-		}
-		ls[i] = n
-	}
-
-	argc := len(n.Args) - 1
-	if argc < 1 {
-		return nsrc
-	}
-
-	// General case, with no function calls left as arguments.
-	// Leave for gen, except that instrumentation requires old form.
-	if !base.Flag.Cfg.Instrumenting || base.Flag.CompilingRuntime {
-		return n
-	}
-
-	var l []ir.Node
-
-	ns := typecheck.Temp(nsrc.Type())
-	l = append(l, ir.NewAssignStmt(base.Pos, ns, nsrc)) // s = src
-
-	na := ir.NewInt(int64(argc))                 // const argc
-	nif := ir.NewIfStmt(base.Pos, nil, nil, nil) // if cap(s) - len(s) < argc
-	nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OLT, ir.NewBinaryExpr(base.Pos, ir.OSUB, ir.NewUnaryExpr(base.Pos, ir.OCAP, ns), ir.NewUnaryExpr(base.Pos, ir.OLEN, ns)), na)
-
-	fn := typecheck.LookupRuntime("growslice") //   growslice(<type>, old []T, mincap int) (ret []T)
-	fn = typecheck.SubstArgTypes(fn, ns.Type().Elem(), ns.Type().Elem())
-
-	nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, ns, mkcall1(fn, ns.Type(), nif.PtrInit(), reflectdata.TypePtr(ns.Type().Elem()), ns,
-		ir.NewBinaryExpr(base.Pos, ir.OADD, ir.NewUnaryExpr(base.Pos, ir.OLEN, ns), na)))}
-
-	l = append(l, nif)
-
-	nn := typecheck.Temp(types.Types[types.TINT])
-	l = append(l, ir.NewAssignStmt(base.Pos, nn, ir.NewUnaryExpr(base.Pos, ir.OLEN, ns))) // n = len(s)
-
-	slice := ir.NewSliceExpr(base.Pos, ir.OSLICE, ns) // ...s[:n+argc]
-	slice.SetSliceBounds(nil, ir.NewBinaryExpr(base.Pos, ir.OADD, nn, na), nil)
-	slice.SetBounded(true)
-	l = append(l, ir.NewAssignStmt(base.Pos, ns, slice)) // s = s[:n+argc]
-
-	ls = n.Args[1:]
-	for i, n := range ls {
-		ix := ir.NewIndexExpr(base.Pos, ns, nn) // s[n] ...
-		ix.SetBounded(true)
-		l = append(l, ir.NewAssignStmt(base.Pos, ix, n)) // s[n] = arg
-		if i+1 < len(ls) {
-			l = append(l, ir.NewAssignStmt(base.Pos, nn, ir.NewBinaryExpr(base.Pos, ir.OADD, nn, ir.NewInt(1)))) // n = n + 1
-		}
-	}
-
-	typecheck.Stmts(l)
-	walkstmtlist(l)
-	init.Append(l...)
-	return ns
-}
-
-// Lower copy(a, b) to a memmove call or a runtime call.
-//
-// init {
-//   n := len(a)
-//   if n > len(b) { n = len(b) }
-//   if a.ptr != b.ptr { memmove(a.ptr, b.ptr, n*sizeof(elem(a))) }
-// }
-// n;
-//
-// Also works if b is a string.
-//
-func copyany(n *ir.BinaryExpr, init *ir.Nodes, runtimecall bool) ir.Node {
-	if n.X.Type().Elem().HasPointers() {
-		ir.CurFunc.SetWBPos(n.Pos())
-		fn := writebarrierfn("typedslicecopy", n.X.Type().Elem(), n.Y.Type().Elem())
-		n.X = cheapexpr(n.X, init)
-		ptrL, lenL := backingArrayPtrLen(n.X)
-		n.Y = cheapexpr(n.Y, init)
-		ptrR, lenR := backingArrayPtrLen(n.Y)
-		return mkcall1(fn, n.Type(), init, reflectdata.TypePtr(n.X.Type().Elem()), ptrL, lenL, ptrR, lenR)
-	}
-
-	if runtimecall {
-		// rely on runtime to instrument:
-		//  copy(n.Left, n.Right)
-		// n.Right can be a slice or string.
-
-		n.X = cheapexpr(n.X, init)
-		ptrL, lenL := backingArrayPtrLen(n.X)
-		n.Y = cheapexpr(n.Y, init)
-		ptrR, lenR := backingArrayPtrLen(n.Y)
-
-		fn := typecheck.LookupRuntime("slicecopy")
-		fn = typecheck.SubstArgTypes(fn, ptrL.Type().Elem(), ptrR.Type().Elem())
-
-		return mkcall1(fn, n.Type(), init, ptrL, lenL, ptrR, lenR, ir.NewInt(n.X.Type().Elem().Width))
-	}
-
-	n.X = walkexpr(n.X, init)
-	n.Y = walkexpr(n.Y, init)
-	nl := typecheck.Temp(n.X.Type())
-	nr := typecheck.Temp(n.Y.Type())
-	var l []ir.Node
-	l = append(l, ir.NewAssignStmt(base.Pos, nl, n.X))
-	l = append(l, ir.NewAssignStmt(base.Pos, nr, n.Y))
-
-	nfrm := ir.NewUnaryExpr(base.Pos, ir.OSPTR, nr)
-	nto := ir.NewUnaryExpr(base.Pos, ir.OSPTR, nl)
-
-	nlen := typecheck.Temp(types.Types[types.TINT])
-
-	// n = len(to)
-	l = append(l, ir.NewAssignStmt(base.Pos, nlen, ir.NewUnaryExpr(base.Pos, ir.OLEN, nl)))
-
-	// if n > len(frm) { n = len(frm) }
-	nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
-
-	nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OGT, nlen, ir.NewUnaryExpr(base.Pos, ir.OLEN, nr))
-	nif.Body.Append(ir.NewAssignStmt(base.Pos, nlen, ir.NewUnaryExpr(base.Pos, ir.OLEN, nr)))
-	l = append(l, nif)
-
-	// if to.ptr != frm.ptr { memmove( ... ) }
-	ne := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.ONE, nto, nfrm), nil, nil)
-	ne.Likely = true
-	l = append(l, ne)
-
-	fn := typecheck.LookupRuntime("memmove")
-	fn = typecheck.SubstArgTypes(fn, nl.Type().Elem(), nl.Type().Elem())
-	nwid := ir.Node(typecheck.Temp(types.Types[types.TUINTPTR]))
-	setwid := ir.NewAssignStmt(base.Pos, nwid, typecheck.Conv(nlen, types.Types[types.TUINTPTR]))
-	ne.Body.Append(setwid)
-	nwid = ir.NewBinaryExpr(base.Pos, ir.OMUL, nwid, ir.NewInt(nl.Type().Elem().Width))
-	call := mkcall1(fn, nil, init, nto, nfrm, nwid)
-	ne.Body.Append(call)
-
-	typecheck.Stmts(l)
-	walkstmtlist(l)
-	init.Append(l...)
-	return nlen
-}
-
-func eqfor(t *types.Type) (n ir.Node, needsize bool) {
-	// Should only arrive here with large memory or
-	// a struct/array containing a non-memory field/element.
-	// Small memory is handled inline, and single non-memory
-	// is handled by walkcompare.
-	switch a, _ := types.AlgType(t); a {
-	case types.AMEM:
-		n := typecheck.LookupRuntime("memequal")
-		n = typecheck.SubstArgTypes(n, t, t)
-		return n, true
-	case types.ASPECIAL:
-		sym := reflectdata.TypeSymPrefix(".eq", t)
-		n := typecheck.NewName(sym)
-		ir.MarkFunc(n)
-		n.SetType(typecheck.NewFuncType(nil, []*ir.Field{
-			ir.NewField(base.Pos, nil, nil, types.NewPtr(t)),
-			ir.NewField(base.Pos, nil, nil, types.NewPtr(t)),
-		}, []*ir.Field{
-			ir.NewField(base.Pos, nil, nil, types.Types[types.TBOOL]),
-		}))
-		return n, false
-	}
-	base.Fatalf("eqfor %v", t)
-	return nil, false
-}
-
-// The result of walkcompare MUST be assigned back to n, e.g.
-// 	n.Left = walkcompare(n.Left, init)
-func walkcompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
-	if n.X.Type().IsInterface() && n.Y.Type().IsInterface() && n.X.Op() != ir.ONIL && n.Y.Op() != ir.ONIL {
-		return walkcompareInterface(n, init)
-	}
-
-	if n.X.Type().IsString() && n.Y.Type().IsString() {
-		return walkcompareString(n, init)
-	}
-
-	n.X = walkexpr(n.X, init)
-	n.Y = walkexpr(n.Y, init)
-
-	// Given mixed interface/concrete comparison,
-	// rewrite into types-equal && data-equal.
-	// This is efficient, avoids allocations, and avoids runtime calls.
-	if n.X.Type().IsInterface() != n.Y.Type().IsInterface() {
-		// Preserve side-effects in case of short-circuiting; see #32187.
-		l := cheapexpr(n.X, init)
-		r := cheapexpr(n.Y, init)
-		// Swap so that l is the interface value and r is the concrete value.
-		if n.Y.Type().IsInterface() {
-			l, r = r, l
-		}
-
-		// Handle both == and !=.
-		eq := n.Op()
-		andor := ir.OOROR
-		if eq == ir.OEQ {
-			andor = ir.OANDAND
-		}
-		// Check for types equal.
-		// For empty interface, this is:
-		//   l.tab == type(r)
-		// For non-empty interface, this is:
-		//   l.tab != nil && l.tab._type == type(r)
-		var eqtype ir.Node
-		tab := ir.NewUnaryExpr(base.Pos, ir.OITAB, l)
-		rtyp := reflectdata.TypePtr(r.Type())
-		if l.Type().IsEmptyInterface() {
-			tab.SetType(types.NewPtr(types.Types[types.TUINT8]))
-			tab.SetTypecheck(1)
-			eqtype = ir.NewBinaryExpr(base.Pos, eq, tab, rtyp)
-		} else {
-			nonnil := ir.NewBinaryExpr(base.Pos, brcom(eq), typecheck.NodNil(), tab)
-			match := ir.NewBinaryExpr(base.Pos, eq, itabType(tab), rtyp)
-			eqtype = ir.NewLogicalExpr(base.Pos, andor, nonnil, match)
-		}
-		// Check for data equal.
-		eqdata := ir.NewBinaryExpr(base.Pos, eq, ifaceData(n.Pos(), l, r.Type()), r)
-		// Put it all together.
-		expr := ir.NewLogicalExpr(base.Pos, andor, eqtype, eqdata)
-		return finishcompare(n, expr, init)
-	}
-
-	// Must be comparison of array or struct.
-	// Otherwise back end handles it.
-	// While we're here, decide whether to
-	// inline or call an eq alg.
-	t := n.X.Type()
-	var inline bool
-
-	maxcmpsize := int64(4)
-	unalignedLoad := canMergeLoads()
-	if unalignedLoad {
-		// Keep this low enough to generate less code than a function call.
-		maxcmpsize = 2 * int64(ssagen.Arch.LinkArch.RegSize)
-	}
-
-	switch t.Kind() {
-	default:
-		if base.Debug.Libfuzzer != 0 && t.IsInteger() {
-			n.X = cheapexpr(n.X, init)
-			n.Y = cheapexpr(n.Y, init)
-
-			// If exactly one comparison operand is
-			// constant, invoke the constcmp functions
-			// instead, and arrange for the constant
-			// operand to be the first argument.
-			l, r := n.X, n.Y
-			if r.Op() == ir.OLITERAL {
-				l, r = r, l
-			}
-			constcmp := l.Op() == ir.OLITERAL && r.Op() != ir.OLITERAL
-
-			var fn string
-			var paramType *types.Type
-			switch t.Size() {
-			case 1:
-				fn = "libfuzzerTraceCmp1"
-				if constcmp {
-					fn = "libfuzzerTraceConstCmp1"
-				}
-				paramType = types.Types[types.TUINT8]
-			case 2:
-				fn = "libfuzzerTraceCmp2"
-				if constcmp {
-					fn = "libfuzzerTraceConstCmp2"
-				}
-				paramType = types.Types[types.TUINT16]
-			case 4:
-				fn = "libfuzzerTraceCmp4"
-				if constcmp {
-					fn = "libfuzzerTraceConstCmp4"
-				}
-				paramType = types.Types[types.TUINT32]
-			case 8:
-				fn = "libfuzzerTraceCmp8"
-				if constcmp {
-					fn = "libfuzzerTraceConstCmp8"
-				}
-				paramType = types.Types[types.TUINT64]
-			default:
-				base.Fatalf("unexpected integer size %d for %v", t.Size(), t)
-			}
-			init.Append(mkcall(fn, nil, init, tracecmpArg(l, paramType, init), tracecmpArg(r, paramType, init)))
-		}
-		return n
-	case types.TARRAY:
-		// We can compare several elements at once with 2/4/8 byte integer compares
-		inline = t.NumElem() <= 1 || (types.IsSimple[t.Elem().Kind()] && (t.NumElem() <= 4 || t.Elem().Width*t.NumElem() <= maxcmpsize))
-	case types.TSTRUCT:
-		inline = t.NumComponents(types.IgnoreBlankFields) <= 4
-	}
-
-	cmpl := n.X
-	for cmpl != nil && cmpl.Op() == ir.OCONVNOP {
-		cmpl = cmpl.(*ir.ConvExpr).X
-	}
-	cmpr := n.Y
-	for cmpr != nil && cmpr.Op() == ir.OCONVNOP {
-		cmpr = cmpr.(*ir.ConvExpr).X
-	}
-
-	// Chose not to inline. Call equality function directly.
-	if !inline {
-		// eq algs take pointers; cmpl and cmpr must be addressable
-		if !ir.IsAssignable(cmpl) || !ir.IsAssignable(cmpr) {
-			base.Fatalf("arguments of comparison must be lvalues - %v %v", cmpl, cmpr)
-		}
-
-		fn, needsize := eqfor(t)
-		call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
-		call.Args.Append(typecheck.NodAddr(cmpl))
-		call.Args.Append(typecheck.NodAddr(cmpr))
-		if needsize {
-			call.Args.Append(ir.NewInt(t.Width))
-		}
-		res := ir.Node(call)
-		if n.Op() != ir.OEQ {
-			res = ir.NewUnaryExpr(base.Pos, ir.ONOT, res)
-		}
-		return finishcompare(n, res, init)
-	}
-
-	// inline: build boolean expression comparing element by element
-	andor := ir.OANDAND
-	if n.Op() == ir.ONE {
-		andor = ir.OOROR
-	}
-	var expr ir.Node
-	compare := func(el, er ir.Node) {
-		a := ir.NewBinaryExpr(base.Pos, n.Op(), el, er)
-		if expr == nil {
-			expr = a
-		} else {
-			expr = ir.NewLogicalExpr(base.Pos, andor, expr, a)
-		}
-	}
-	cmpl = safeexpr(cmpl, init)
-	cmpr = safeexpr(cmpr, init)
-	if t.IsStruct() {
-		for _, f := range t.Fields().Slice() {
-			sym := f.Sym
-			if sym.IsBlank() {
-				continue
-			}
-			compare(
-				ir.NewSelectorExpr(base.Pos, ir.OXDOT, cmpl, sym),
-				ir.NewSelectorExpr(base.Pos, ir.OXDOT, cmpr, sym),
-			)
-		}
-	} else {
-		step := int64(1)
-		remains := t.NumElem() * t.Elem().Width
-		combine64bit := unalignedLoad && types.RegSize == 8 && t.Elem().Width <= 4 && t.Elem().IsInteger()
-		combine32bit := unalignedLoad && t.Elem().Width <= 2 && t.Elem().IsInteger()
-		combine16bit := unalignedLoad && t.Elem().Width == 1 && t.Elem().IsInteger()
-		for i := int64(0); remains > 0; {
-			var convType *types.Type
-			switch {
-			case remains >= 8 && combine64bit:
-				convType = types.Types[types.TINT64]
-				step = 8 / t.Elem().Width
-			case remains >= 4 && combine32bit:
-				convType = types.Types[types.TUINT32]
-				step = 4 / t.Elem().Width
-			case remains >= 2 && combine16bit:
-				convType = types.Types[types.TUINT16]
-				step = 2 / t.Elem().Width
-			default:
-				step = 1
-			}
-			if step == 1 {
-				compare(
-					ir.NewIndexExpr(base.Pos, cmpl, ir.NewInt(i)),
-					ir.NewIndexExpr(base.Pos, cmpr, ir.NewInt(i)),
-				)
-				i++
-				remains -= t.Elem().Width
-			} else {
-				elemType := t.Elem().ToUnsigned()
-				cmplw := ir.Node(ir.NewIndexExpr(base.Pos, cmpl, ir.NewInt(i)))
-				cmplw = typecheck.Conv(cmplw, elemType) // convert to unsigned
-				cmplw = typecheck.Conv(cmplw, convType) // widen
-				cmprw := ir.Node(ir.NewIndexExpr(base.Pos, cmpr, ir.NewInt(i)))
-				cmprw = typecheck.Conv(cmprw, elemType)
-				cmprw = typecheck.Conv(cmprw, convType)
-				// For code like this:  uint32(s[0]) | uint32(s[1])<<8 | uint32(s[2])<<16 ...
-				// ssa will generate a single large load.
-				for offset := int64(1); offset < step; offset++ {
-					lb := ir.Node(ir.NewIndexExpr(base.Pos, cmpl, ir.NewInt(i+offset)))
-					lb = typecheck.Conv(lb, elemType)
-					lb = typecheck.Conv(lb, convType)
-					lb = ir.NewBinaryExpr(base.Pos, ir.OLSH, lb, ir.NewInt(8*t.Elem().Width*offset))
-					cmplw = ir.NewBinaryExpr(base.Pos, ir.OOR, cmplw, lb)
-					rb := ir.Node(ir.NewIndexExpr(base.Pos, cmpr, ir.NewInt(i+offset)))
-					rb = typecheck.Conv(rb, elemType)
-					rb = typecheck.Conv(rb, convType)
-					rb = ir.NewBinaryExpr(base.Pos, ir.OLSH, rb, ir.NewInt(8*t.Elem().Width*offset))
-					cmprw = ir.NewBinaryExpr(base.Pos, ir.OOR, cmprw, rb)
-				}
-				compare(cmplw, cmprw)
-				i += step
-				remains -= step * t.Elem().Width
-			}
-		}
-	}
-	if expr == nil {
-		expr = ir.NewBool(n.Op() == ir.OEQ)
-		// We still need to use cmpl and cmpr, in case they contain
-		// an expression which might panic. See issue 23837.
-		t := typecheck.Temp(cmpl.Type())
-		a1 := typecheck.Stmt(ir.NewAssignStmt(base.Pos, t, cmpl))
-		a2 := typecheck.Stmt(ir.NewAssignStmt(base.Pos, t, cmpr))
-		init.Append(a1, a2)
-	}
-	return finishcompare(n, expr, init)
-}
-
-func tracecmpArg(n ir.Node, t *types.Type, init *ir.Nodes) ir.Node {
-	// Ugly hack to avoid "constant -1 overflows uintptr" errors, etc.
-	if n.Op() == ir.OLITERAL && n.Type().IsSigned() && ir.Int64Val(n) < 0 {
-		n = copyexpr(n, n.Type(), init)
-	}
-
-	return typecheck.Conv(n, t)
-}
-
-func walkcompareInterface(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
-	n.Y = cheapexpr(n.Y, init)
-	n.X = cheapexpr(n.X, init)
-	eqtab, eqdata := reflectdata.EqInterface(n.X, n.Y)
-	var cmp ir.Node
-	if n.Op() == ir.OEQ {
-		cmp = ir.NewLogicalExpr(base.Pos, ir.OANDAND, eqtab, eqdata)
-	} else {
-		eqtab.SetOp(ir.ONE)
-		cmp = ir.NewLogicalExpr(base.Pos, ir.OOROR, eqtab, ir.NewUnaryExpr(base.Pos, ir.ONOT, eqdata))
-	}
-	return finishcompare(n, cmp, init)
-}
-
-func walkcompareString(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
-	// Rewrite comparisons to short constant strings as length+byte-wise comparisons.
-	var cs, ncs ir.Node // const string, non-const string
-	switch {
-	case ir.IsConst(n.X, constant.String) && ir.IsConst(n.Y, constant.String):
-		// ignore; will be constant evaluated
-	case ir.IsConst(n.X, constant.String):
-		cs = n.X
-		ncs = n.Y
-	case ir.IsConst(n.Y, constant.String):
-		cs = n.Y
-		ncs = n.X
-	}
-	if cs != nil {
-		cmp := n.Op()
-		// Our comparison below assumes that the non-constant string
-		// is on the left hand side, so rewrite "" cmp x to x cmp "".
-		// See issue 24817.
-		if ir.IsConst(n.X, constant.String) {
-			cmp = brrev(cmp)
-		}
-
-		// maxRewriteLen was chosen empirically.
-		// It is the value that minimizes cmd/go file size
-		// across most architectures.
-		// See the commit description for CL 26758 for details.
-		maxRewriteLen := 6
-		// Some architectures can load unaligned byte sequence as 1 word.
-		// So we can cover longer strings with the same amount of code.
-		canCombineLoads := canMergeLoads()
-		combine64bit := false
-		if canCombineLoads {
-			// Keep this low enough to generate less code than a function call.
-			maxRewriteLen = 2 * ssagen.Arch.LinkArch.RegSize
-			combine64bit = ssagen.Arch.LinkArch.RegSize >= 8
-		}
-
-		var and ir.Op
-		switch cmp {
-		case ir.OEQ:
-			and = ir.OANDAND
-		case ir.ONE:
-			and = ir.OOROR
-		default:
-			// Don't do byte-wise comparisons for <, <=, etc.
-			// They're fairly complicated.
-			// Length-only checks are ok, though.
-			maxRewriteLen = 0
-		}
-		if s := ir.StringVal(cs); len(s) <= maxRewriteLen {
-			if len(s) > 0 {
-				ncs = safeexpr(ncs, init)
-			}
-			r := ir.Node(ir.NewBinaryExpr(base.Pos, cmp, ir.NewUnaryExpr(base.Pos, ir.OLEN, ncs), ir.NewInt(int64(len(s)))))
-			remains := len(s)
-			for i := 0; remains > 0; {
-				if remains == 1 || !canCombineLoads {
-					cb := ir.NewInt(int64(s[i]))
-					ncb := ir.NewIndexExpr(base.Pos, ncs, ir.NewInt(int64(i)))
-					r = ir.NewLogicalExpr(base.Pos, and, r, ir.NewBinaryExpr(base.Pos, cmp, ncb, cb))
-					remains--
-					i++
-					continue
-				}
-				var step int
-				var convType *types.Type
-				switch {
-				case remains >= 8 && combine64bit:
-					convType = types.Types[types.TINT64]
-					step = 8
-				case remains >= 4:
-					convType = types.Types[types.TUINT32]
-					step = 4
-				case remains >= 2:
-					convType = types.Types[types.TUINT16]
-					step = 2
-				}
-				ncsubstr := typecheck.Conv(ir.NewIndexExpr(base.Pos, ncs, ir.NewInt(int64(i))), convType)
-				csubstr := int64(s[i])
-				// Calculate large constant from bytes as sequence of shifts and ors.
-				// Like this:  uint32(s[0]) | uint32(s[1])<<8 | uint32(s[2])<<16 ...
-				// ssa will combine this into a single large load.
-				for offset := 1; offset < step; offset++ {
-					b := typecheck.Conv(ir.NewIndexExpr(base.Pos, ncs, ir.NewInt(int64(i+offset))), convType)
-					b = ir.NewBinaryExpr(base.Pos, ir.OLSH, b, ir.NewInt(int64(8*offset)))
-					ncsubstr = ir.NewBinaryExpr(base.Pos, ir.OOR, ncsubstr, b)
-					csubstr |= int64(s[i+offset]) << uint8(8*offset)
-				}
-				csubstrPart := ir.NewInt(csubstr)
-				// Compare "step" bytes as once
-				r = ir.NewLogicalExpr(base.Pos, and, r, ir.NewBinaryExpr(base.Pos, cmp, csubstrPart, ncsubstr))
-				remains -= step
-				i += step
-			}
-			return finishcompare(n, r, init)
-		}
-	}
-
-	var r ir.Node
-	if n.Op() == ir.OEQ || n.Op() == ir.ONE {
-		// prepare for rewrite below
-		n.X = cheapexpr(n.X, init)
-		n.Y = cheapexpr(n.Y, init)
-		eqlen, eqmem := reflectdata.EqString(n.X, n.Y)
-		// quick check of len before full compare for == or !=.
-		// memequal then tests equality up to length len.
-		if n.Op() == ir.OEQ {
-			// len(left) == len(right) && memequal(left, right, len)
-			r = ir.NewLogicalExpr(base.Pos, ir.OANDAND, eqlen, eqmem)
-		} else {
-			// len(left) != len(right) || !memequal(left, right, len)
-			eqlen.SetOp(ir.ONE)
-			r = ir.NewLogicalExpr(base.Pos, ir.OOROR, eqlen, ir.NewUnaryExpr(base.Pos, ir.ONOT, eqmem))
-		}
-	} else {
-		// sys_cmpstring(s1, s2) :: 0
-		r = mkcall("cmpstring", types.Types[types.TINT], init, typecheck.Conv(n.X, types.Types[types.TSTRING]), typecheck.Conv(n.Y, types.Types[types.TSTRING]))
-		r = ir.NewBinaryExpr(base.Pos, n.Op(), r, ir.NewInt(0))
-	}
-
-	return finishcompare(n, r, init)
-}
-
-// The result of finishcompare MUST be assigned back to n, e.g.
-// 	n.Left = finishcompare(n.Left, x, r, init)
-func finishcompare(n *ir.BinaryExpr, r ir.Node, init *ir.Nodes) ir.Node {
-	r = typecheck.Expr(r)
-	r = typecheck.Conv(r, n.Type())
-	r = walkexpr(r, init)
-	return r
-}
-
-// return 1 if integer n must be in range [0, max), 0 otherwise
-func bounded(n ir.Node, max int64) bool {
-	if n.Type() == nil || !n.Type().IsInteger() {
-		return false
-	}
-
-	sign := n.Type().IsSigned()
-	bits := int32(8 * n.Type().Width)
-
-	if ir.IsSmallIntConst(n) {
-		v := ir.Int64Val(n)
-		return 0 <= v && v < max
-	}
-
-	switch n.Op() {
-	case ir.OAND, ir.OANDNOT:
-		n := n.(*ir.BinaryExpr)
-		v := int64(-1)
-		switch {
-		case ir.IsSmallIntConst(n.X):
-			v = ir.Int64Val(n.X)
-		case ir.IsSmallIntConst(n.Y):
-			v = ir.Int64Val(n.Y)
-			if n.Op() == ir.OANDNOT {
-				v = ^v
-				if !sign {
-					v &= 1<<uint(bits) - 1
-				}
-			}
-		}
-		if 0 <= v && v < max {
-			return true
-		}
-
-	case ir.OMOD:
-		n := n.(*ir.BinaryExpr)
-		if !sign && ir.IsSmallIntConst(n.Y) {
-			v := ir.Int64Val(n.Y)
-			if 0 <= v && v <= max {
-				return true
-			}
-		}
-
-	case ir.ODIV:
-		n := n.(*ir.BinaryExpr)
-		if !sign && ir.IsSmallIntConst(n.Y) {
-			v := ir.Int64Val(n.Y)
-			for bits > 0 && v >= 2 {
-				bits--
-				v >>= 1
-			}
-		}
-
-	case ir.ORSH:
-		n := n.(*ir.BinaryExpr)
-		if !sign && ir.IsSmallIntConst(n.Y) {
-			v := ir.Int64Val(n.Y)
-			if v > int64(bits) {
-				return true
-			}
-			bits -= int32(v)
-		}
-	}
-
-	if !sign && bits <= 62 && 1<<uint(bits) <= max {
-		return true
-	}
-
-	return false
-}
-
-// usemethod checks interface method calls for uses of reflect.Type.Method.
-func usemethod(n *ir.CallExpr) {
-	t := n.X.Type()
-
-	// Looking for either of:
-	//	Method(int) reflect.Method
-	//	MethodByName(string) (reflect.Method, bool)
-	//
-	// TODO(crawshaw): improve precision of match by working out
-	//                 how to check the method name.
-	if n := t.NumParams(); n != 1 {
-		return
-	}
-	if n := t.NumResults(); n != 1 && n != 2 {
-		return
-	}
-	p0 := t.Params().Field(0)
-	res0 := t.Results().Field(0)
-	var res1 *types.Field
-	if t.NumResults() == 2 {
-		res1 = t.Results().Field(1)
-	}
-
-	if res1 == nil {
-		if p0.Type.Kind() != types.TINT {
-			return
-		}
-	} else {
-		if !p0.Type.IsString() {
-			return
-		}
-		if !res1.Type.IsBoolean() {
-			return
-		}
-	}
-
-	// Note: Don't rely on res0.Type.String() since its formatting depends on multiple factors
-	//       (including global variables such as numImports - was issue #19028).
-	// Also need to check for reflect package itself (see Issue #38515).
-	if s := res0.Type.Sym(); s != nil && s.Name == "Method" && types.IsReflectPkg(s.Pkg) {
-		ir.CurFunc.SetReflectMethod(true)
-		// The LSym is initialized at this point. We need to set the attribute on the LSym.
-		ir.CurFunc.LSym.Set(obj.AttrReflectMethod, true)
-	}
-}
-
-func usefield(n *ir.SelectorExpr) {
-	if objabi.Fieldtrack_enabled == 0 {
-		return
-	}
-
-	switch n.Op() {
-	default:
-		base.Fatalf("usefield %v", n.Op())
-
-	case ir.ODOT, ir.ODOTPTR:
-		break
-	}
-	if n.Sel == nil {
-		// No field name.  This DOTPTR was built by the compiler for access
-		// to runtime data structures.  Ignore.
-		return
-	}
-
-	t := n.X.Type()
-	if t.IsPtr() {
-		t = t.Elem()
-	}
-	field := n.Selection
-	if field == nil {
-		base.Fatalf("usefield %v %v without paramfld", n.X.Type(), n.Sel)
-	}
-	if field.Sym != n.Sel || field.Offset != n.Offset {
-		base.Fatalf("field inconsistency: %v,%v != %v,%v", field.Sym, field.Offset, n.Sel, n.Offset)
-	}
-	if !strings.Contains(field.Note, "go:\"track\"") {
-		return
-	}
-
-	outer := n.X.Type()
-	if outer.IsPtr() {
-		outer = outer.Elem()
-	}
-	if outer.Sym() == nil {
-		base.Errorf("tracked field must be in named struct type")
-	}
-	if !types.IsExported(field.Sym.Name) {
-		base.Errorf("tracked field must be exported (upper case)")
-	}
-
-	sym := reflectdata.TrackSym(outer, field)
-	if ir.CurFunc.FieldTrack == nil {
-		ir.CurFunc.FieldTrack = make(map[*types.Sym]struct{})
-	}
-	ir.CurFunc.FieldTrack[sym] = struct{}{}
 }
 
 // Rewrite
@@ -3730,197 +377,194 @@ func usefield(n *ir.SelectorExpr) {
 
 var wrapCall_prgen int
 
-// The result of wrapCall MUST be assigned back to n, e.g.
-// 	n.Left = wrapCall(n.Left, init)
-func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
-	if len(n.Init()) != 0 {
-		walkstmtlist(n.Init())
-		init.Append(n.PtrInit().Take()...)
-	}
-
-	isBuiltinCall := n.Op() != ir.OCALLFUNC && n.Op() != ir.OCALLMETH && n.Op() != ir.OCALLINTER
-
-	// Turn f(a, b, []T{c, d, e}...) back into f(a, b, c, d, e).
-	if !isBuiltinCall && n.IsDDD {
-		last := len(n.Args) - 1
-		if va := n.Args[last]; va.Op() == ir.OSLICELIT {
-			va := va.(*ir.CompLitExpr)
-			n.Args.Set(append(n.Args[:last], va.List...))
-			n.IsDDD = false
-		}
-	}
+var walkCheckPtrArithmeticMarker byte
 
-	// origArgs keeps track of what argument is uintptr-unsafe/unsafe-uintptr conversion.
-	origArgs := make([]ir.Node, len(n.Args))
-	var funcArgs []*ir.Field
-	for i, arg := range n.Args {
-		s := typecheck.LookupNum("a", i)
-		if !isBuiltinCall && arg.Op() == ir.OCONVNOP && arg.Type().IsUintptr() && arg.(*ir.ConvExpr).X.Type().IsUnsafePtr() {
-			origArgs[i] = arg
-			arg = arg.(*ir.ConvExpr).X
-			n.Args[i] = arg
-		}
-		funcArgs = append(funcArgs, ir.NewField(base.Pos, s, nil, arg.Type()))
+// appendWalkStmt typechecks and walks stmt and then appends it to init.
+func appendWalkStmt(init *ir.Nodes, stmt ir.Node) {
+	op := stmt.Op()
+	n := typecheck.Stmt(stmt)
+	if op == ir.OAS || op == ir.OAS2 {
+		// If the assignment has side effects, walkexpr will append them
+		// directly to init for us, while walkstmt will wrap it in an OBLOCK.
+		// We need to append them directly.
+		// TODO(rsc): Clean this up.
+		n = walkExpr(n, init)
+	} else {
+		n = walkStmt(n)
 	}
-	t := ir.NewFuncType(base.Pos, nil, funcArgs, nil)
+	init.Append(n)
+}
 
-	wrapCall_prgen++
-	sym := typecheck.LookupNum("wrap·", wrapCall_prgen)
-	fn := typecheck.DeclFunc(sym, t)
+// The max number of defers in a function using open-coded defers. We enforce this
+// limit because the deferBits bitmask is currently a single byte (to minimize code size)
+const maxOpenDefers = 8
 
-	args := ir.ParamNames(t.Type())
-	for i, origArg := range origArgs {
-		if origArg == nil {
-			continue
-		}
-		args[i] = ir.NewConvExpr(base.Pos, origArg.Op(), origArg.Type(), args[i])
-	}
-	call := ir.NewCallExpr(base.Pos, n.Op(), n.X, args)
-	if !isBuiltinCall {
-		call.SetOp(ir.OCALL)
-		call.IsDDD = n.IsDDD
+// backingArrayPtrLen extracts the pointer and length from a slice or string.
+// This constructs two nodes referring to n, so n must be a cheapexpr.
+func backingArrayPtrLen(n ir.Node) (ptr, length ir.Node) {
+	var init ir.Nodes
+	c := cheapExpr(n, &init)
+	if c != n || len(init) != 0 {
+		base.Fatalf("backingArrayPtrLen not cheap: %v", n)
+	}
+	ptr = ir.NewUnaryExpr(base.Pos, ir.OSPTR, n)
+	if n.Type().IsString() {
+		ptr.SetType(types.Types[types.TUINT8].PtrTo())
+	} else {
+		ptr.SetType(n.Type().Elem().PtrTo())
 	}
-	fn.Body = []ir.Node{call}
-
-	typecheck.FinishFuncBody()
-
-	typecheck.Func(fn)
-	typecheck.Stmts(fn.Body)
-	typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
-
-	call = ir.NewCallExpr(base.Pos, ir.OCALL, fn.Nname, n.Args)
-	return walkexpr(typecheck.Stmt(call), init)
+	length = ir.NewUnaryExpr(base.Pos, ir.OLEN, n)
+	length.SetType(types.Types[types.TINT])
+	return ptr, length
 }
 
-// canMergeLoads reports whether the backend optimization passes for
-// the current architecture can combine adjacent loads into a single
-// larger, possibly unaligned, load. Note that currently the
-// optimizations must be able to handle little endian byte order.
-func canMergeLoads() bool {
-	switch ssagen.Arch.LinkArch.Family {
-	case sys.ARM64, sys.AMD64, sys.I386, sys.S390X:
-		return true
-	case sys.PPC64:
-		// Load combining only supported on ppc64le.
-		return ssagen.Arch.LinkArch.ByteOrder == binary.LittleEndian
+// updateHasCall checks whether expression n contains any function
+// calls and sets the n.HasCall flag if so.
+func updateHasCall(n ir.Node) {
+	if n == nil {
+		return
 	}
-	return false
-}
-
-// isRuneCount reports whether n is of the form len([]rune(string)).
-// These are optimized into a call to runtime.countrunes.
-func isRuneCount(n ir.Node) bool {
-	return base.Flag.N == 0 && !base.Flag.Cfg.Instrumenting && n.Op() == ir.OLEN && n.(*ir.UnaryExpr).X.Op() == ir.OSTR2RUNES
+	n.SetHasCall(calcHasCall(n))
 }
 
-func walkCheckPtrAlignment(n *ir.ConvExpr, init *ir.Nodes, count ir.Node) ir.Node {
-	if !n.Type().IsPtr() {
-		base.Fatalf("expected pointer type: %v", n.Type())
-	}
-	elem := n.Type().Elem()
-	if count != nil {
-		if !elem.IsArray() {
-			base.Fatalf("expected array type: %v", elem)
-		}
-		elem = elem.Elem()
+func calcHasCall(n ir.Node) bool {
+	if len(n.Init()) != 0 {
+		// TODO(mdempsky): This seems overly conservative.
+		return true
 	}
 
-	size := elem.Size()
-	if elem.Alignment() == 1 && (size == 0 || size == 1 && count == nil) {
-		return n
-	}
+	switch n.Op() {
+	default:
+		base.Fatalf("calcHasCall %+v", n)
+		panic("unreachable")
 
-	if count == nil {
-		count = ir.NewInt(1)
-	}
+	case ir.OLITERAL, ir.ONIL, ir.ONAME, ir.OTYPE, ir.ONAMEOFFSET:
+		if n.HasCall() {
+			base.Fatalf("OLITERAL/ONAME/OTYPE should never have calls: %+v", n)
+		}
+		return false
+	case ir.OCALL, ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
+		return true
+	case ir.OANDAND, ir.OOROR:
+		// hard with instrumented code
+		n := n.(*ir.LogicalExpr)
+		if base.Flag.Cfg.Instrumenting {
+			return true
+		}
+		return n.X.HasCall() || n.Y.HasCall()
+	case ir.OINDEX, ir.OSLICE, ir.OSLICEARR, ir.OSLICE3, ir.OSLICE3ARR, ir.OSLICESTR,
+		ir.ODEREF, ir.ODOTPTR, ir.ODOTTYPE, ir.ODIV, ir.OMOD:
+		// These ops might panic, make sure they are done
+		// before we start marshaling args for a call. See issue 16760.
+		return true
 
-	n.X = cheapexpr(n.X, init)
-	init.Append(mkcall("checkptrAlignment", nil, init, typecheck.ConvNop(n.X, types.Types[types.TUNSAFEPTR]), reflectdata.TypePtr(elem), typecheck.Conv(count, types.Types[types.TUINTPTR])))
-	return n
-}
+	// When using soft-float, these ops might be rewritten to function calls
+	// so we ensure they are evaluated first.
+	case ir.OADD, ir.OSUB, ir.OMUL:
+		n := n.(*ir.BinaryExpr)
+		if ssagen.Arch.SoftFloat && (types.IsFloat[n.Type().Kind()] || types.IsComplex[n.Type().Kind()]) {
+			return true
+		}
+		return n.X.HasCall() || n.Y.HasCall()
+	case ir.ONEG:
+		n := n.(*ir.UnaryExpr)
+		if ssagen.Arch.SoftFloat && (types.IsFloat[n.Type().Kind()] || types.IsComplex[n.Type().Kind()]) {
+			return true
+		}
+		return n.X.HasCall()
+	case ir.OLT, ir.OEQ, ir.ONE, ir.OLE, ir.OGE, ir.OGT:
+		n := n.(*ir.BinaryExpr)
+		if ssagen.Arch.SoftFloat && (types.IsFloat[n.X.Type().Kind()] || types.IsComplex[n.X.Type().Kind()]) {
+			return true
+		}
+		return n.X.HasCall() || n.Y.HasCall()
+	case ir.OCONV:
+		n := n.(*ir.ConvExpr)
+		if ssagen.Arch.SoftFloat && ((types.IsFloat[n.Type().Kind()] || types.IsComplex[n.Type().Kind()]) || (types.IsFloat[n.X.Type().Kind()] || types.IsComplex[n.X.Type().Kind()])) {
+			return true
+		}
+		return n.X.HasCall()
 
-var walkCheckPtrArithmeticMarker byte
+	case ir.OAND, ir.OANDNOT, ir.OLSH, ir.OOR, ir.ORSH, ir.OXOR, ir.OCOPY, ir.OCOMPLEX, ir.OEFACE:
+		n := n.(*ir.BinaryExpr)
+		return n.X.HasCall() || n.Y.HasCall()
 
-func walkCheckPtrArithmetic(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
-	// Calling cheapexpr(n, init) below leads to a recursive call
-	// to walkexpr, which leads us back here again. Use n.Opt to
-	// prevent infinite loops.
-	if opt := n.Opt(); opt == &walkCheckPtrArithmeticMarker {
-		return n
-	} else if opt != nil {
-		// We use n.Opt() here because today it's not used for OCONVNOP. If that changes,
-		// there's no guarantee that temporarily replacing it is safe, so just hard fail here.
-		base.Fatalf("unexpected Opt: %v", opt)
-	}
-	n.SetOpt(&walkCheckPtrArithmeticMarker)
-	defer n.SetOpt(nil)
+	case ir.OAS:
+		n := n.(*ir.AssignStmt)
+		return n.X.HasCall() || n.Y != nil && n.Y.HasCall()
 
-	// TODO(mdempsky): Make stricter. We only need to exempt
-	// reflect.Value.Pointer and reflect.Value.UnsafeAddr.
-	switch n.X.Op() {
-	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
-		return n
-	}
+	case ir.OADDR:
+		n := n.(*ir.AddrExpr)
+		return n.X.HasCall()
+	case ir.OPAREN:
+		n := n.(*ir.ParenExpr)
+		return n.X.HasCall()
+	case ir.OBITNOT, ir.ONOT, ir.OPLUS, ir.ORECV,
+		ir.OALIGNOF, ir.OCAP, ir.OCLOSE, ir.OIMAG, ir.OLEN, ir.ONEW,
+		ir.OOFFSETOF, ir.OPANIC, ir.OREAL, ir.OSIZEOF,
+		ir.OCHECKNIL, ir.OCFUNC, ir.OIDATA, ir.OITAB, ir.ONEWOBJ, ir.OSPTR, ir.OVARDEF, ir.OVARKILL, ir.OVARLIVE:
+		n := n.(*ir.UnaryExpr)
+		return n.X.HasCall()
+	case ir.ODOT, ir.ODOTMETH, ir.ODOTINTER:
+		n := n.(*ir.SelectorExpr)
+		return n.X.HasCall()
 
-	if n.X.Op() == ir.ODOTPTR && ir.IsReflectHeaderDataField(n.X) {
-		return n
-	}
+	case ir.OGETG, ir.OCLOSUREREAD, ir.OMETHEXPR:
+		return false
 
-	// Find original unsafe.Pointer operands involved in this
-	// arithmetic expression.
-	//
-	// "It is valid both to add and to subtract offsets from a
-	// pointer in this way. It is also valid to use &^ to round
-	// pointers, usually for alignment."
-	var originals []ir.Node
-	var walk func(n ir.Node)
-	walk = func(n ir.Node) {
-		switch n.Op() {
-		case ir.OADD:
-			n := n.(*ir.BinaryExpr)
-			walk(n.X)
-			walk(n.Y)
-		case ir.OSUB, ir.OANDNOT:
-			n := n.(*ir.BinaryExpr)
-			walk(n.X)
-		case ir.OCONVNOP:
-			n := n.(*ir.ConvExpr)
-			if n.X.Type().IsUnsafePtr() {
-				n.X = cheapexpr(n.X, init)
-				originals = append(originals, typecheck.ConvNop(n.X, types.Types[types.TUNSAFEPTR]))
-			}
-		}
+	// TODO(rsc): These look wrong in various ways but are what calcHasCall has always done.
+	case ir.OADDSTR:
+		// TODO(rsc): This used to check left and right, which are not part of OADDSTR.
+		return false
+	case ir.OBLOCK:
+		// TODO(rsc): Surely the block's statements matter.
+		return false
+	case ir.OCONVIFACE, ir.OCONVNOP, ir.OBYTES2STR, ir.OBYTES2STRTMP, ir.ORUNES2STR, ir.OSTR2BYTES, ir.OSTR2BYTESTMP, ir.OSTR2RUNES, ir.ORUNESTR:
+		// TODO(rsc): Some conversions are themselves calls, no?
+		n := n.(*ir.ConvExpr)
+		return n.X.HasCall()
+	case ir.ODOTTYPE2:
+		// TODO(rsc): Shouldn't this be up with ODOTTYPE above?
+		n := n.(*ir.TypeAssertExpr)
+		return n.X.HasCall()
+	case ir.OSLICEHEADER:
+		// TODO(rsc): What about len and cap?
+		n := n.(*ir.SliceHeaderExpr)
+		return n.Ptr.HasCall()
+	case ir.OAS2DOTTYPE, ir.OAS2FUNC:
+		// TODO(rsc): Surely we need to check List and Rlist.
+		return false
 	}
-	walk(n.X)
-
-	cheap := cheapexpr(n, init)
-
-	slice := typecheck.MakeDotArgs(types.NewSlice(types.Types[types.TUNSAFEPTR]), originals)
-	slice.SetEsc(ir.EscNone)
-
-	init.Append(mkcall("checkptrArithmetic", nil, init, typecheck.ConvNop(cheap, types.Types[types.TUNSAFEPTR]), slice))
-	// TODO(khr): Mark backing store of slice as dead. This will allow us to reuse
-	// the backing store for multiple calls to checkptrArithmetic.
+}
 
-	return cheap
+// itabType loads the _type field from a runtime.itab struct.
+func itabType(itab ir.Node) ir.Node {
+	typ := ir.NewSelectorExpr(base.Pos, ir.ODOTPTR, itab, nil)
+	typ.SetType(types.NewPtr(types.Types[types.TUINT8]))
+	typ.SetTypecheck(1)
+	typ.Offset = int64(types.PtrSize) // offset of _type in runtime.itab
+	typ.SetBounded(true)              // guaranteed not to fault
+	return typ
 }
 
-// appendWalkStmt typechecks and walks stmt and then appends it to init.
-func appendWalkStmt(init *ir.Nodes, stmt ir.Node) {
-	op := stmt.Op()
-	n := typecheck.Stmt(stmt)
-	if op == ir.OAS || op == ir.OAS2 {
-		// If the assignment has side effects, walkexpr will append them
-		// directly to init for us, while walkstmt will wrap it in an OBLOCK.
-		// We need to append them directly.
-		// TODO(rsc): Clean this up.
-		n = walkexpr(n, init)
-	} else {
-		n = walkstmt(n)
+// ifaceData loads the data field from an interface.
+// The concrete type must be known to have type t.
+// It follows the pointer if !isdirectiface(t).
+func ifaceData(pos src.XPos, n ir.Node, t *types.Type) ir.Node {
+	if t.IsInterface() {
+		base.Fatalf("ifaceData interface: %v", t)
 	}
-	init.Append(n)
+	ptr := ir.NewUnaryExpr(pos, ir.OIDATA, n)
+	if types.IsDirectIface(t) {
+		ptr.SetType(t)
+		ptr.SetTypecheck(1)
+		return ptr
+	}
+	ptr.SetType(types.NewPtr(t))
+	ptr.SetTypecheck(1)
+	ind := ir.NewStarExpr(pos, ptr)
+	ind.SetType(t)
+	ind.SetTypecheck(1)
+	ind.SetBounded(true)
+	return ind
 }
-
-// The max number of defers in a function using open-coded defers. We enforce this
-// limit because the deferBits bitmask is currently a single byte (to minimize code size)
-const maxOpenDefers = 8
-- 
GitLab


From 3d8a3cb06b98d24e4fbf99d7d8706271cbb9634f Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 23 Dec 2020 01:08:27 -0500
Subject: [PATCH 0318/2400] [dev.regabi] cmd/compile: split out package pkginit
 [generated]

[git-generate]
cd src/cmd/compile/internal/gc
rf '
	mv fninit Task
	mv init.go initorder.go cmd/compile/internal/pkginit
'

Change-Id: Ie2a924784c7a6fa029eaef821384eef4b262e1af
Reviewed-on: https://go-review.googlesource.com/c/go/+/279479
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/main.go                   | 3 ++-
 src/cmd/compile/internal/{gc => pkginit}/init.go      | 6 +++---
 src/cmd/compile/internal/{gc => pkginit}/initorder.go | 2 +-
 3 files changed, 6 insertions(+), 5 deletions(-)
 rename src/cmd/compile/internal/{gc => pkginit}/init.go (96%)
 rename src/cmd/compile/internal/{gc => pkginit}/initorder.go (99%)

diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index aeb58a3310..8483c87a38 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -16,6 +16,7 @@ import (
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/noder"
+	"cmd/compile/internal/pkginit"
 	"cmd/compile/internal/reflectdata"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/ssagen"
@@ -223,7 +224,7 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	base.ExitIfErrors()
 
 	// Build init task.
-	if initTask := fninit(); initTask != nil {
+	if initTask := pkginit.Task(); initTask != nil {
 		typecheck.Export(initTask)
 	}
 
diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/pkginit/init.go
similarity index 96%
rename from src/cmd/compile/internal/gc/init.go
rename to src/cmd/compile/internal/pkginit/init.go
index a299b8688b..f964edee88 100644
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/pkginit/init.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package pkginit
 
 import (
 	"cmd/compile/internal/base"
@@ -13,13 +13,13 @@ import (
 	"cmd/internal/obj"
 )
 
-// fninit makes and returns an initialization record for the package.
+// Task makes and returns an initialization record for the package.
 // See runtime/proc.go:initTask for its layout.
 // The 3 tasks for initialization are:
 //   1) Initialize all of the packages the current package depends on.
 //   2) Initialize all the variables that have initializers.
 //   3) Run any init functions.
-func fninit() *ir.Name {
+func Task() *ir.Name {
 	nf := initOrder(typecheck.Target.Decls)
 
 	var deps []*obj.LSym // initTask records for packages the current package depends on
diff --git a/src/cmd/compile/internal/gc/initorder.go b/src/cmd/compile/internal/pkginit/initorder.go
similarity index 99%
rename from src/cmd/compile/internal/gc/initorder.go
rename to src/cmd/compile/internal/pkginit/initorder.go
index 4ac468fb4e..d63c5a4717 100644
--- a/src/cmd/compile/internal/gc/initorder.go
+++ b/src/cmd/compile/internal/pkginit/initorder.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package pkginit
 
 import (
 	"bytes"
-- 
GitLab


From 37f138df6bcd7bb7cf62148cd8388f3916388ab6 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 23 Dec 2020 01:09:46 -0500
Subject: [PATCH 0319/2400] [dev.regabi] cmd/compile: split out package test
 [generated]

[git-generate]
cd src/cmd/compile/internal/gc
rf '
	mv bench_test.go constFold_test.go dep_test.go \
		fixedbugs_test.go iface_test.go float_test.go global_test.go \
		inl_test.go lang_test.go logic_test.go \
		reproduciblebuilds_test.go shift_test.go ssa_test.go \
		truncconst_test.go zerorange_test.go \
		cmd/compile/internal/test
'
mv testdata ../test

Change-Id: I041971b7e9766673f7a331679bfe1c8110dcda66
Reviewed-on: https://go-review.googlesource.com/c/go/+/279480
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/{gc => test}/bench_test.go       | 2 +-
 src/cmd/compile/internal/{gc => test}/constFold_test.go   | 2 +-
 src/cmd/compile/internal/{gc => test}/dep_test.go         | 2 +-
 src/cmd/compile/internal/{gc => test}/fixedbugs_test.go   | 2 +-
 src/cmd/compile/internal/{gc => test}/float_test.go       | 2 +-
 src/cmd/compile/internal/{gc => test}/global_test.go      | 2 +-
 src/cmd/compile/internal/{gc => test}/iface_test.go       | 8 +++-----
 src/cmd/compile/internal/{gc => test}/inl_test.go         | 2 +-
 src/cmd/compile/internal/{gc => test}/lang_test.go        | 2 +-
 src/cmd/compile/internal/{gc => test}/logic_test.go       | 2 +-
 .../internal/{gc => test}/reproduciblebuilds_test.go      | 2 +-
 src/cmd/compile/internal/{gc => test}/shift_test.go       | 2 +-
 src/cmd/compile/internal/{gc => test}/ssa_test.go         | 2 +-
 .../internal/{gc => test}/testdata/addressed_test.go      | 0
 .../compile/internal/{gc => test}/testdata/append_test.go | 0
 .../internal/{gc => test}/testdata/arithBoundary_test.go  | 0
 .../internal/{gc => test}/testdata/arithConst_test.go     | 0
 .../compile/internal/{gc => test}/testdata/arith_test.go  | 0
 .../compile/internal/{gc => test}/testdata/array_test.go  | 0
 .../compile/internal/{gc => test}/testdata/assert_test.go | 0
 .../compile/internal/{gc => test}/testdata/break_test.go  | 0
 .../compile/internal/{gc => test}/testdata/chan_test.go   | 0
 .../internal/{gc => test}/testdata/closure_test.go        | 0
 .../internal/{gc => test}/testdata/cmpConst_test.go       | 0
 .../compile/internal/{gc => test}/testdata/cmp_test.go    | 0
 .../internal/{gc => test}/testdata/compound_test.go       | 0
 .../compile/internal/{gc => test}/testdata/copy_test.go   | 0
 .../compile/internal/{gc => test}/testdata/ctl_test.go    | 0
 .../internal/{gc => test}/testdata/deferNoReturn_test.go  | 0
 .../internal/{gc => test}/testdata/divbyzero_test.go      | 0
 .../internal/{gc => test}/testdata/dupLoad_test.go        | 0
 .../{gc => test}/testdata/flowgraph_generator1.go         | 0
 src/cmd/compile/internal/{gc => test}/testdata/fp_test.go | 0
 .../{gc => test}/testdata/gen/arithBoundaryGen.go         | 0
 .../internal/{gc => test}/testdata/gen/arithConstGen.go   | 0
 .../internal/{gc => test}/testdata/gen/cmpConstGen.go     | 0
 .../internal/{gc => test}/testdata/gen/constFoldGen.go    | 0
 .../compile/internal/{gc => test}/testdata/gen/copyGen.go | 0
 .../compile/internal/{gc => test}/testdata/gen/zeroGen.go | 0
 .../internal/{gc => test}/testdata/loadstore_test.go      | 0
 .../compile/internal/{gc => test}/testdata/map_test.go    | 0
 .../internal/{gc => test}/testdata/namedReturn_test.go    | 0
 .../compile/internal/{gc => test}/testdata/phi_test.go    | 0
 .../internal/{gc => test}/testdata/regalloc_test.go       | 0
 .../{gc => test}/testdata/reproducible/issue20272.go      | 0
 .../{gc => test}/testdata/reproducible/issue27013.go      | 0
 .../{gc => test}/testdata/reproducible/issue30202.go      | 0
 .../{gc => test}/testdata/reproducible/issue38068.go      | 0
 .../compile/internal/{gc => test}/testdata/short_test.go  | 0
 .../compile/internal/{gc => test}/testdata/slice_test.go  | 0
 .../internal/{gc => test}/testdata/sqrtConst_test.go      | 0
 .../compile/internal/{gc => test}/testdata/string_test.go | 0
 .../compile/internal/{gc => test}/testdata/unsafe_test.go | 0
 .../compile/internal/{gc => test}/testdata/zero_test.go   | 0
 src/cmd/compile/internal/{gc => test}/truncconst_test.go  | 2 +-
 src/cmd/compile/internal/{gc => test}/zerorange_test.go   | 6 ++----
 56 files changed, 18 insertions(+), 22 deletions(-)
 rename src/cmd/compile/internal/{gc => test}/bench_test.go (98%)
 rename src/cmd/compile/internal/{gc => test}/constFold_test.go (99%)
 rename src/cmd/compile/internal/{gc => test}/dep_test.go (97%)
 rename src/cmd/compile/internal/{gc => test}/fixedbugs_test.go (99%)
 rename src/cmd/compile/internal/{gc => test}/float_test.go (99%)
 rename src/cmd/compile/internal/{gc => test}/global_test.go (99%)
 rename src/cmd/compile/internal/{gc => test}/iface_test.go (98%)
 rename src/cmd/compile/internal/{gc => test}/inl_test.go (99%)
 rename src/cmd/compile/internal/{gc => test}/lang_test.go (99%)
 rename src/cmd/compile/internal/{gc => test}/logic_test.go (99%)
 rename src/cmd/compile/internal/{gc => test}/reproduciblebuilds_test.go (99%)
 rename src/cmd/compile/internal/{gc => test}/shift_test.go (99%)
 rename src/cmd/compile/internal/{gc => test}/ssa_test.go (99%)
 rename src/cmd/compile/internal/{gc => test}/testdata/addressed_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/append_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/arithBoundary_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/arithConst_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/arith_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/array_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/assert_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/break_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/chan_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/closure_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/cmpConst_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/cmp_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/compound_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/copy_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/ctl_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/deferNoReturn_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/divbyzero_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/dupLoad_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/flowgraph_generator1.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/fp_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/gen/arithBoundaryGen.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/gen/arithConstGen.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/gen/cmpConstGen.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/gen/constFoldGen.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/gen/copyGen.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/gen/zeroGen.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/loadstore_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/map_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/namedReturn_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/phi_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/regalloc_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/reproducible/issue20272.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/reproducible/issue27013.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/reproducible/issue30202.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/reproducible/issue38068.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/short_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/slice_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/sqrtConst_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/string_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/unsafe_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/testdata/zero_test.go (100%)
 rename src/cmd/compile/internal/{gc => test}/truncconst_test.go (99%)
 rename src/cmd/compile/internal/{gc => test}/zerorange_test.go (98%)

diff --git a/src/cmd/compile/internal/gc/bench_test.go b/src/cmd/compile/internal/test/bench_test.go
similarity index 98%
rename from src/cmd/compile/internal/gc/bench_test.go
rename to src/cmd/compile/internal/test/bench_test.go
index 8c4288128f..3fffe57d08 100644
--- a/src/cmd/compile/internal/gc/bench_test.go
+++ b/src/cmd/compile/internal/test/bench_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
 
 import "testing"
 
diff --git a/src/cmd/compile/internal/gc/constFold_test.go b/src/cmd/compile/internal/test/constFold_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/constFold_test.go
rename to src/cmd/compile/internal/test/constFold_test.go
index 59f905dad9..7159f0ed33 100644
--- a/src/cmd/compile/internal/gc/constFold_test.go
+++ b/src/cmd/compile/internal/test/constFold_test.go
@@ -1,7 +1,7 @@
 // run
 // Code generated by gen/constFoldGen.go. DO NOT EDIT.
 
-package gc
+package test
 
 import "testing"
 
diff --git a/src/cmd/compile/internal/gc/dep_test.go b/src/cmd/compile/internal/test/dep_test.go
similarity index 97%
rename from src/cmd/compile/internal/gc/dep_test.go
rename to src/cmd/compile/internal/test/dep_test.go
index a185bc9f54..26122e6a5b 100644
--- a/src/cmd/compile/internal/gc/dep_test.go
+++ b/src/cmd/compile/internal/test/dep_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
 
 import (
 	"internal/testenv"
diff --git a/src/cmd/compile/internal/gc/fixedbugs_test.go b/src/cmd/compile/internal/test/fixedbugs_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/fixedbugs_test.go
rename to src/cmd/compile/internal/test/fixedbugs_test.go
index 8ac4436947..e7e2f7e58e 100644
--- a/src/cmd/compile/internal/gc/fixedbugs_test.go
+++ b/src/cmd/compile/internal/test/fixedbugs_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
 
 import (
 	"internal/testenv"
diff --git a/src/cmd/compile/internal/gc/float_test.go b/src/cmd/compile/internal/test/float_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/float_test.go
rename to src/cmd/compile/internal/test/float_test.go
index c619d25705..884a983bdd 100644
--- a/src/cmd/compile/internal/gc/float_test.go
+++ b/src/cmd/compile/internal/test/float_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
 
 import (
 	"math"
diff --git a/src/cmd/compile/internal/gc/global_test.go b/src/cmd/compile/internal/test/global_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/global_test.go
rename to src/cmd/compile/internal/test/global_test.go
index edad6d042a..5f5f7d6198 100644
--- a/src/cmd/compile/internal/gc/global_test.go
+++ b/src/cmd/compile/internal/test/global_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
 
 import (
 	"bytes"
diff --git a/src/cmd/compile/internal/gc/iface_test.go b/src/cmd/compile/internal/test/iface_test.go
similarity index 98%
rename from src/cmd/compile/internal/gc/iface_test.go
rename to src/cmd/compile/internal/test/iface_test.go
index 21c6587217..ebc4f891c9 100644
--- a/src/cmd/compile/internal/gc/iface_test.go
+++ b/src/cmd/compile/internal/test/iface_test.go
@@ -2,15 +2,13 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
+
+import "testing"
 
 // Test to make sure we make copies of the values we
 // put in interfaces.
 
-import (
-	"testing"
-)
-
 var x int
 
 func TestEfaceConv1(t *testing.T) {
diff --git a/src/cmd/compile/internal/gc/inl_test.go b/src/cmd/compile/internal/test/inl_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/inl_test.go
rename to src/cmd/compile/internal/test/inl_test.go
index 02735e50fb..9d31975b31 100644
--- a/src/cmd/compile/internal/gc/inl_test.go
+++ b/src/cmd/compile/internal/test/inl_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
 
 import (
 	"bufio"
diff --git a/src/cmd/compile/internal/gc/lang_test.go b/src/cmd/compile/internal/test/lang_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/lang_test.go
rename to src/cmd/compile/internal/test/lang_test.go
index 72e7f07a21..67c1551292 100644
--- a/src/cmd/compile/internal/gc/lang_test.go
+++ b/src/cmd/compile/internal/test/lang_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
 
 import (
 	"internal/testenv"
diff --git a/src/cmd/compile/internal/gc/logic_test.go b/src/cmd/compile/internal/test/logic_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/logic_test.go
rename to src/cmd/compile/internal/test/logic_test.go
index 78d2dd2fa8..1d7043ff60 100644
--- a/src/cmd/compile/internal/gc/logic_test.go
+++ b/src/cmd/compile/internal/test/logic_test.go
@@ -1,4 +1,4 @@
-package gc
+package test
 
 import "testing"
 
diff --git a/src/cmd/compile/internal/gc/reproduciblebuilds_test.go b/src/cmd/compile/internal/test/reproduciblebuilds_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/reproduciblebuilds_test.go
rename to src/cmd/compile/internal/test/reproduciblebuilds_test.go
index 8101e44079..4d84f9cdef 100644
--- a/src/cmd/compile/internal/gc/reproduciblebuilds_test.go
+++ b/src/cmd/compile/internal/test/reproduciblebuilds_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc_test
+package test
 
 import (
 	"bytes"
diff --git a/src/cmd/compile/internal/gc/shift_test.go b/src/cmd/compile/internal/test/shift_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/shift_test.go
rename to src/cmd/compile/internal/test/shift_test.go
index ce2eedf152..ea88f0a70a 100644
--- a/src/cmd/compile/internal/gc/shift_test.go
+++ b/src/cmd/compile/internal/test/shift_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
 
 import (
 	"reflect"
diff --git a/src/cmd/compile/internal/gc/ssa_test.go b/src/cmd/compile/internal/test/ssa_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/ssa_test.go
rename to src/cmd/compile/internal/test/ssa_test.go
index 7f7c9464d4..2f3e24c2d3 100644
--- a/src/cmd/compile/internal/gc/ssa_test.go
+++ b/src/cmd/compile/internal/test/ssa_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
 
 import (
 	"bytes"
diff --git a/src/cmd/compile/internal/gc/testdata/addressed_test.go b/src/cmd/compile/internal/test/testdata/addressed_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/addressed_test.go
rename to src/cmd/compile/internal/test/testdata/addressed_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/append_test.go b/src/cmd/compile/internal/test/testdata/append_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/append_test.go
rename to src/cmd/compile/internal/test/testdata/append_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/arithBoundary_test.go b/src/cmd/compile/internal/test/testdata/arithBoundary_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/arithBoundary_test.go
rename to src/cmd/compile/internal/test/testdata/arithBoundary_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/arithConst_test.go b/src/cmd/compile/internal/test/testdata/arithConst_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/arithConst_test.go
rename to src/cmd/compile/internal/test/testdata/arithConst_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/arith_test.go b/src/cmd/compile/internal/test/testdata/arith_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/arith_test.go
rename to src/cmd/compile/internal/test/testdata/arith_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/array_test.go b/src/cmd/compile/internal/test/testdata/array_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/array_test.go
rename to src/cmd/compile/internal/test/testdata/array_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/assert_test.go b/src/cmd/compile/internal/test/testdata/assert_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/assert_test.go
rename to src/cmd/compile/internal/test/testdata/assert_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/break_test.go b/src/cmd/compile/internal/test/testdata/break_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/break_test.go
rename to src/cmd/compile/internal/test/testdata/break_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/chan_test.go b/src/cmd/compile/internal/test/testdata/chan_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/chan_test.go
rename to src/cmd/compile/internal/test/testdata/chan_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/closure_test.go b/src/cmd/compile/internal/test/testdata/closure_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/closure_test.go
rename to src/cmd/compile/internal/test/testdata/closure_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/cmpConst_test.go b/src/cmd/compile/internal/test/testdata/cmpConst_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/cmpConst_test.go
rename to src/cmd/compile/internal/test/testdata/cmpConst_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/cmp_test.go b/src/cmd/compile/internal/test/testdata/cmp_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/cmp_test.go
rename to src/cmd/compile/internal/test/testdata/cmp_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/compound_test.go b/src/cmd/compile/internal/test/testdata/compound_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/compound_test.go
rename to src/cmd/compile/internal/test/testdata/compound_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/copy_test.go b/src/cmd/compile/internal/test/testdata/copy_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/copy_test.go
rename to src/cmd/compile/internal/test/testdata/copy_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/ctl_test.go b/src/cmd/compile/internal/test/testdata/ctl_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/ctl_test.go
rename to src/cmd/compile/internal/test/testdata/ctl_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/deferNoReturn_test.go b/src/cmd/compile/internal/test/testdata/deferNoReturn_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/deferNoReturn_test.go
rename to src/cmd/compile/internal/test/testdata/deferNoReturn_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/divbyzero_test.go b/src/cmd/compile/internal/test/testdata/divbyzero_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/divbyzero_test.go
rename to src/cmd/compile/internal/test/testdata/divbyzero_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/dupLoad_test.go b/src/cmd/compile/internal/test/testdata/dupLoad_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/dupLoad_test.go
rename to src/cmd/compile/internal/test/testdata/dupLoad_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/flowgraph_generator1.go b/src/cmd/compile/internal/test/testdata/flowgraph_generator1.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/flowgraph_generator1.go
rename to src/cmd/compile/internal/test/testdata/flowgraph_generator1.go
diff --git a/src/cmd/compile/internal/gc/testdata/fp_test.go b/src/cmd/compile/internal/test/testdata/fp_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/fp_test.go
rename to src/cmd/compile/internal/test/testdata/fp_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/gen/arithBoundaryGen.go b/src/cmd/compile/internal/test/testdata/gen/arithBoundaryGen.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/gen/arithBoundaryGen.go
rename to src/cmd/compile/internal/test/testdata/gen/arithBoundaryGen.go
diff --git a/src/cmd/compile/internal/gc/testdata/gen/arithConstGen.go b/src/cmd/compile/internal/test/testdata/gen/arithConstGen.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/gen/arithConstGen.go
rename to src/cmd/compile/internal/test/testdata/gen/arithConstGen.go
diff --git a/src/cmd/compile/internal/gc/testdata/gen/cmpConstGen.go b/src/cmd/compile/internal/test/testdata/gen/cmpConstGen.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/gen/cmpConstGen.go
rename to src/cmd/compile/internal/test/testdata/gen/cmpConstGen.go
diff --git a/src/cmd/compile/internal/gc/testdata/gen/constFoldGen.go b/src/cmd/compile/internal/test/testdata/gen/constFoldGen.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/gen/constFoldGen.go
rename to src/cmd/compile/internal/test/testdata/gen/constFoldGen.go
diff --git a/src/cmd/compile/internal/gc/testdata/gen/copyGen.go b/src/cmd/compile/internal/test/testdata/gen/copyGen.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/gen/copyGen.go
rename to src/cmd/compile/internal/test/testdata/gen/copyGen.go
diff --git a/src/cmd/compile/internal/gc/testdata/gen/zeroGen.go b/src/cmd/compile/internal/test/testdata/gen/zeroGen.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/gen/zeroGen.go
rename to src/cmd/compile/internal/test/testdata/gen/zeroGen.go
diff --git a/src/cmd/compile/internal/gc/testdata/loadstore_test.go b/src/cmd/compile/internal/test/testdata/loadstore_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/loadstore_test.go
rename to src/cmd/compile/internal/test/testdata/loadstore_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/map_test.go b/src/cmd/compile/internal/test/testdata/map_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/map_test.go
rename to src/cmd/compile/internal/test/testdata/map_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/namedReturn_test.go b/src/cmd/compile/internal/test/testdata/namedReturn_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/namedReturn_test.go
rename to src/cmd/compile/internal/test/testdata/namedReturn_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/phi_test.go b/src/cmd/compile/internal/test/testdata/phi_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/phi_test.go
rename to src/cmd/compile/internal/test/testdata/phi_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/regalloc_test.go b/src/cmd/compile/internal/test/testdata/regalloc_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/regalloc_test.go
rename to src/cmd/compile/internal/test/testdata/regalloc_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/reproducible/issue20272.go b/src/cmd/compile/internal/test/testdata/reproducible/issue20272.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/reproducible/issue20272.go
rename to src/cmd/compile/internal/test/testdata/reproducible/issue20272.go
diff --git a/src/cmd/compile/internal/gc/testdata/reproducible/issue27013.go b/src/cmd/compile/internal/test/testdata/reproducible/issue27013.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/reproducible/issue27013.go
rename to src/cmd/compile/internal/test/testdata/reproducible/issue27013.go
diff --git a/src/cmd/compile/internal/gc/testdata/reproducible/issue30202.go b/src/cmd/compile/internal/test/testdata/reproducible/issue30202.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/reproducible/issue30202.go
rename to src/cmd/compile/internal/test/testdata/reproducible/issue30202.go
diff --git a/src/cmd/compile/internal/gc/testdata/reproducible/issue38068.go b/src/cmd/compile/internal/test/testdata/reproducible/issue38068.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/reproducible/issue38068.go
rename to src/cmd/compile/internal/test/testdata/reproducible/issue38068.go
diff --git a/src/cmd/compile/internal/gc/testdata/short_test.go b/src/cmd/compile/internal/test/testdata/short_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/short_test.go
rename to src/cmd/compile/internal/test/testdata/short_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/slice_test.go b/src/cmd/compile/internal/test/testdata/slice_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/slice_test.go
rename to src/cmd/compile/internal/test/testdata/slice_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/sqrtConst_test.go b/src/cmd/compile/internal/test/testdata/sqrtConst_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/sqrtConst_test.go
rename to src/cmd/compile/internal/test/testdata/sqrtConst_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/string_test.go b/src/cmd/compile/internal/test/testdata/string_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/string_test.go
rename to src/cmd/compile/internal/test/testdata/string_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/unsafe_test.go b/src/cmd/compile/internal/test/testdata/unsafe_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/unsafe_test.go
rename to src/cmd/compile/internal/test/testdata/unsafe_test.go
diff --git a/src/cmd/compile/internal/gc/testdata/zero_test.go b/src/cmd/compile/internal/test/testdata/zero_test.go
similarity index 100%
rename from src/cmd/compile/internal/gc/testdata/zero_test.go
rename to src/cmd/compile/internal/test/testdata/zero_test.go
diff --git a/src/cmd/compile/internal/gc/truncconst_test.go b/src/cmd/compile/internal/test/truncconst_test.go
similarity index 99%
rename from src/cmd/compile/internal/gc/truncconst_test.go
rename to src/cmd/compile/internal/test/truncconst_test.go
index d153818064..7705042ca2 100644
--- a/src/cmd/compile/internal/gc/truncconst_test.go
+++ b/src/cmd/compile/internal/test/truncconst_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
 
 import "testing"
 
diff --git a/src/cmd/compile/internal/gc/zerorange_test.go b/src/cmd/compile/internal/test/zerorange_test.go
similarity index 98%
rename from src/cmd/compile/internal/gc/zerorange_test.go
rename to src/cmd/compile/internal/test/zerorange_test.go
index 89f4cb9bcf..cb1a6e04e4 100644
--- a/src/cmd/compile/internal/gc/zerorange_test.go
+++ b/src/cmd/compile/internal/test/zerorange_test.go
@@ -2,11 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
 
-import (
-	"testing"
-)
+import "testing"
 
 var glob = 3
 var globp *int64
-- 
GitLab


From 63c96c2ee7444b83224b9c5aadd8ad5b757c1e03 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 23 Dec 2020 00:36:34 -0800
Subject: [PATCH 0320/2400] [dev.regabi] cmd/compile: update mkbuiltin.go and
 re-enable TestBuiltin

Update's mkbuiltin.go to match builtin.go after the recent rf
rewrites.

Change-Id: I80cf5d7c27b36fe28553406819cb4263de84e5ed
Reviewed-on: https://go-review.googlesource.com/c/go/+/279952
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/typecheck/builtin_test.go |  1 -
 src/cmd/compile/internal/typecheck/mkbuiltin.go    | 11 ++++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/builtin_test.go b/src/cmd/compile/internal/typecheck/builtin_test.go
index cc8d49730a..fb9d3e393f 100644
--- a/src/cmd/compile/internal/typecheck/builtin_test.go
+++ b/src/cmd/compile/internal/typecheck/builtin_test.go
@@ -13,7 +13,6 @@ import (
 )
 
 func TestBuiltin(t *testing.T) {
-	t.Skip("mkbuiltin needs fixing")
 	testenv.MustHaveGoRun(t)
 	t.Parallel()
 
diff --git a/src/cmd/compile/internal/typecheck/mkbuiltin.go b/src/cmd/compile/internal/typecheck/mkbuiltin.go
index 2a208d960f..27dbf1f10e 100644
--- a/src/cmd/compile/internal/typecheck/mkbuiltin.go
+++ b/src/cmd/compile/internal/typecheck/mkbuiltin.go
@@ -36,6 +36,7 @@ func main() {
 	fmt.Fprintln(&b, "package typecheck")
 	fmt.Fprintln(&b)
 	fmt.Fprintln(&b, `import (`)
+	fmt.Fprintln(&b, `      "cmd/compile/internal/base"`)
 	fmt.Fprintln(&b, `      "cmd/compile/internal/ir"`)
 	fmt.Fprintln(&b, `      "cmd/compile/internal/types"`)
 	fmt.Fprintln(&b, `)`)
@@ -169,7 +170,7 @@ func (i *typeInterner) mktype(t ast.Expr) string {
 		}
 		return fmt.Sprintf("types.NewChan(%s, %s)", i.subtype(t.Value), dir)
 	case *ast.FuncType:
-		return fmt.Sprintf("functype(nil, %s, %s)", i.fields(t.Params, false), i.fields(t.Results, false))
+		return fmt.Sprintf("NewFuncType(nil, %s, %s)", i.fields(t.Params, false), i.fields(t.Results, false))
 	case *ast.InterfaceType:
 		if len(t.Methods.List) != 0 {
 			log.Fatal("non-empty interfaces unsupported")
@@ -180,7 +181,7 @@ func (i *typeInterner) mktype(t ast.Expr) string {
 	case *ast.StarExpr:
 		return fmt.Sprintf("types.NewPtr(%s)", i.subtype(t.X))
 	case *ast.StructType:
-		return fmt.Sprintf("tostruct(%s)", i.fields(t.Fields, true))
+		return fmt.Sprintf("NewStructType(%s)", i.fields(t.Fields, true))
 
 	default:
 		log.Fatalf("unhandled type: %#v", t)
@@ -196,13 +197,13 @@ func (i *typeInterner) fields(fl *ast.FieldList, keepNames bool) string {
 	for _, f := range fl.List {
 		typ := i.subtype(f.Type)
 		if len(f.Names) == 0 {
-			res = append(res, fmt.Sprintf("anonfield(%s)", typ))
+			res = append(res, fmt.Sprintf("ir.NewField(base.Pos, nil, nil, %s)", typ))
 		} else {
 			for _, name := range f.Names {
 				if keepNames {
-					res = append(res, fmt.Sprintf("namedfield(%q, %s)", name.Name, typ))
+					res = append(res, fmt.Sprintf("ir.NewField(base.Pos, Lookup(%q), nil, %s)", name.Name, typ))
 				} else {
-					res = append(res, fmt.Sprintf("anonfield(%s)", typ))
+					res = append(res, fmt.Sprintf("ir.NewField(base.Pos, nil, nil, %s)", typ))
 				}
 			}
 		}
-- 
GitLab


From 5898025026e3ec38451e86c7837f6faf3633cf27 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 23 Dec 2020 00:50:18 -0800
Subject: [PATCH 0321/2400] [dev.regabi] cmd/compile: update mkbuiltin.go to
 use new type constructors

We recently added new functions to types like NewSignature and
NewField, so we can use these directly rather than depending on the
typecheck and ir wrappers.

Passes toolstash -cmp.

Change-Id: I32676aa9a4ea71892216017756e72bcf90297219
Reviewed-on: https://go-review.googlesource.com/c/go/+/279953
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/typecheck/builtin.go | 189 +++++++++---------
 .../compile/internal/typecheck/mkbuiltin.go   |  15 +-
 2 files changed, 101 insertions(+), 103 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/builtin.go b/src/cmd/compile/internal/typecheck/builtin.go
index d3c30fbf50..0dee852529 100644
--- a/src/cmd/compile/internal/typecheck/builtin.go
+++ b/src/cmd/compile/internal/typecheck/builtin.go
@@ -3,9 +3,8 @@
 package typecheck
 
 import (
-	"cmd/compile/internal/base"
-	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
+	"cmd/internal/src"
 )
 
 var runtimeDecls = [...]struct {
@@ -212,133 +211,133 @@ func runtimeTypes() []*types.Type {
 	typs[1] = types.NewPtr(typs[0])
 	typs[2] = types.Types[types.TANY]
 	typs[3] = types.NewPtr(typs[2])
-	typs[4] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3])})
+	typs[4] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])})
 	typs[5] = types.Types[types.TUINTPTR]
 	typs[6] = types.Types[types.TBOOL]
 	typs[7] = types.Types[types.TUNSAFEPTR]
-	typs[8] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[5]), ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[6])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7])})
-	typs[9] = NewFuncType(nil, nil, nil)
+	typs[8] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[6])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
+	typs[9] = types.NewSignature(types.NoPkg, nil, nil, nil)
 	typs[10] = types.Types[types.TINTER]
-	typs[11] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[10])}, nil)
+	typs[11] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[10])}, nil)
 	typs[12] = types.Types[types.TINT32]
 	typs[13] = types.NewPtr(typs[12])
-	typs[14] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[13])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[10])})
+	typs[14] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[13])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[10])})
 	typs[15] = types.Types[types.TINT]
-	typs[16] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[15])}, nil)
+	typs[16] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[15])}, nil)
 	typs[17] = types.Types[types.TUINT]
-	typs[18] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[17]), ir.NewField(base.Pos, nil, nil, typs[15])}, nil)
-	typs[19] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])}, nil)
+	typs[18] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[17]), types.NewField(src.NoXPos, nil, typs[15])}, nil)
+	typs[19] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])}, nil)
 	typs[20] = types.Types[types.TFLOAT64]
-	typs[21] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])}, nil)
+	typs[21] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])}, nil)
 	typs[22] = types.Types[types.TINT64]
-	typs[23] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[22])}, nil)
+	typs[23] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[22])}, nil)
 	typs[24] = types.Types[types.TUINT64]
-	typs[25] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[24])}, nil)
+	typs[25] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[24])}, nil)
 	typs[26] = types.Types[types.TCOMPLEX128]
-	typs[27] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[26])}, nil)
+	typs[27] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[26])}, nil)
 	typs[28] = types.Types[types.TSTRING]
-	typs[29] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])}, nil)
-	typs[30] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[2])}, nil)
-	typs[31] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[5])}, nil)
+	typs[29] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])}, nil)
+	typs[30] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[2])}, nil)
+	typs[31] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[5])}, nil)
 	typs[32] = types.NewArray(typs[0], 32)
 	typs[33] = types.NewPtr(typs[32])
-	typs[34] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
-	typs[35] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
-	typs[36] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
-	typs[37] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
+	typs[34] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+	typs[35] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+	typs[36] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+	typs[37] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
 	typs[38] = types.NewSlice(typs[28])
-	typs[39] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[38])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
-	typs[40] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[15])})
+	typs[39] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[38])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+	typs[40] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15])})
 	typs[41] = types.NewArray(typs[0], 4)
 	typs[42] = types.NewPtr(typs[41])
-	typs[43] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[42]), ir.NewField(base.Pos, nil, nil, typs[22])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
-	typs[44] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
-	typs[45] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
+	typs[43] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[42]), types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+	typs[44] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+	typs[45] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
 	typs[46] = types.RuneType
 	typs[47] = types.NewSlice(typs[46])
-	typs[48] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[47])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])})
+	typs[48] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[47])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
 	typs[49] = types.NewSlice(typs[0])
-	typs[50] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[33]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[49])})
+	typs[50] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[49])})
 	typs[51] = types.NewArray(typs[46], 32)
 	typs[52] = types.NewPtr(typs[51])
-	typs[53] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[52]), ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[47])})
-	typs[54] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[5])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[15])})
-	typs[55] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[46]), ir.NewField(base.Pos, nil, nil, typs[15])})
-	typs[56] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[28])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[15])})
-	typs[57] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[2])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[2])})
-	typs[58] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[2])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7])})
-	typs[59] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[2])})
-	typs[60] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[2])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[2]), ir.NewField(base.Pos, nil, nil, typs[6])})
-	typs[61] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[1])}, nil)
-	typs[62] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1])}, nil)
+	typs[53] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[52]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[47])})
+	typs[54] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[5])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15])})
+	typs[55] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[46]), types.NewField(src.NoXPos, nil, typs[15])})
+	typs[56] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15])})
+	typs[57] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[2])})
+	typs[58] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
+	typs[59] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[2])})
+	typs[60] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[2]), types.NewField(src.NoXPos, nil, typs[6])})
+	typs[61] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[1])}, nil)
+	typs[62] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1])}, nil)
 	typs[63] = types.NewPtr(typs[5])
-	typs[64] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[63]), ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[7])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[64] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[63]), types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[7])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
 	typs[65] = types.Types[types.TUINT32]
-	typs[66] = NewFuncType(nil, nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[65])})
+	typs[66] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[65])})
 	typs[67] = types.NewMap(typs[2], typs[2])
-	typs[68] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[22]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[67])})
-	typs[69] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[67])})
-	typs[70] = NewFuncType(nil, nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[67])})
-	typs[71] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3])})
-	typs[72] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[2])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3])})
-	typs[73] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[1])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3])})
-	typs[74] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[6])})
-	typs[75] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[2])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[6])})
-	typs[76] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[1])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[6])})
-	typs[77] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[3])}, nil)
-	typs[78] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67]), ir.NewField(base.Pos, nil, nil, typs[2])}, nil)
-	typs[79] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3])}, nil)
-	typs[80] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[67])}, nil)
+	typs[68] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[22]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[67])})
+	typs[69] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[67])})
+	typs[70] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[67])})
+	typs[71] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])})
+	typs[72] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])})
+	typs[73] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[1])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])})
+	typs[74] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[6])})
+	typs[75] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[6])})
+	typs[76] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[1])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[6])})
+	typs[77] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
+	typs[78] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[2])}, nil)
+	typs[79] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])}, nil)
+	typs[80] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67])}, nil)
 	typs[81] = types.NewChan(typs[2], types.Cboth)
-	typs[82] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[22])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[81])})
-	typs[83] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[81])})
+	typs[82] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[81])})
+	typs[83] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[81])})
 	typs[84] = types.NewChan(typs[2], types.Crecv)
-	typs[85] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[84]), ir.NewField(base.Pos, nil, nil, typs[3])}, nil)
-	typs[86] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[84]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[85] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[84]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
+	typs[86] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[84]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
 	typs[87] = types.NewChan(typs[2], types.Csend)
-	typs[88] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[87]), ir.NewField(base.Pos, nil, nil, typs[3])}, nil)
+	typs[88] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[87]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
 	typs[89] = types.NewArray(typs[0], 3)
-	typs[90] = NewStructType([]*ir.Field{ir.NewField(base.Pos, Lookup("enabled"), nil, typs[6]), ir.NewField(base.Pos, Lookup("pad"), nil, typs[89]), ir.NewField(base.Pos, Lookup("needed"), nil, typs[6]), ir.NewField(base.Pos, Lookup("cgo"), nil, typs[6]), ir.NewField(base.Pos, Lookup("alignme"), nil, typs[24])})
-	typs[91] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[3])}, nil)
-	typs[92] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[3])}, nil)
-	typs[93] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[15])})
-	typs[94] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[87]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
-	typs[95] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[84])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
+	typs[90] = types.NewStruct(types.NoPkg, []*types.Field{types.NewField(src.NoXPos, Lookup("enabled"), typs[6]), types.NewField(src.NoXPos, Lookup("pad"), typs[89]), types.NewField(src.NoXPos, Lookup("needed"), typs[6]), types.NewField(src.NoXPos, Lookup("cgo"), typs[6]), types.NewField(src.NoXPos, Lookup("alignme"), typs[24])})
+	typs[91] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
+	typs[92] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
+	typs[93] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15])})
+	typs[94] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[87]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
+	typs[95] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[84])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
 	typs[96] = types.NewPtr(typs[6])
-	typs[97] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[96]), ir.NewField(base.Pos, nil, nil, typs[84])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
-	typs[98] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[63])}, nil)
-	typs[99] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[63]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[6])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[6])})
-	typs[100] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7])})
-	typs[101] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[22]), ir.NewField(base.Pos, nil, nil, typs[22])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7])})
-	typs[102] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[15]), ir.NewField(base.Pos, nil, nil, typs[7])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7])})
+	typs[97] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[96]), types.NewField(src.NoXPos, nil, typs[84])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
+	typs[98] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[63])}, nil)
+	typs[99] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[63]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[6])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[6])})
+	typs[100] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
+	typs[101] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[22]), types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
+	typs[102] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[7])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
 	typs[103] = types.NewSlice(typs[2])
-	typs[104] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[103]), ir.NewField(base.Pos, nil, nil, typs[15])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[103])})
-	typs[105] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[5])}, nil)
-	typs[106] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[5])}, nil)
-	typs[107] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[5])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
-	typs[108] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[3]), ir.NewField(base.Pos, nil, nil, typs[3])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
-	typs[109] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[7])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[6])})
-	typs[110] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[5]), ir.NewField(base.Pos, nil, nil, typs[5])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[5])})
-	typs[111] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[5])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[5])})
-	typs[112] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[22]), ir.NewField(base.Pos, nil, nil, typs[22])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[22])})
-	typs[113] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[24]), ir.NewField(base.Pos, nil, nil, typs[24])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[24])})
-	typs[114] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[22])})
-	typs[115] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[24])})
-	typs[116] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[65])})
-	typs[117] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[22])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])})
-	typs[118] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[24])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])})
-	typs[119] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[65])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[20])})
-	typs[120] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[26]), ir.NewField(base.Pos, nil, nil, typs[26])}, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[26])})
-	typs[121] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[5]), ir.NewField(base.Pos, nil, nil, typs[5])}, nil)
-	typs[122] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[5]), ir.NewField(base.Pos, nil, nil, typs[5]), ir.NewField(base.Pos, nil, nil, typs[5])}, nil)
-	typs[123] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[1]), ir.NewField(base.Pos, nil, nil, typs[5])}, nil)
+	typs[104] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[103]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[103])})
+	typs[105] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
+	typs[106] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
+	typs[107] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[5])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
+	typs[108] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
+	typs[109] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[7])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
+	typs[110] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[5])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[5])})
+	typs[111] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[5])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[5])})
+	typs[112] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[22]), types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[22])})
+	typs[113] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[24]), types.NewField(src.NoXPos, nil, typs[24])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[24])})
+	typs[114] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[22])})
+	typs[115] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[24])})
+	typs[116] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[65])})
+	typs[117] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])})
+	typs[118] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[24])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])})
+	typs[119] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[65])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])})
+	typs[120] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[26]), types.NewField(src.NoXPos, nil, typs[26])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[26])})
+	typs[121] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
+	typs[122] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
+	typs[123] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
 	typs[124] = types.NewSlice(typs[7])
-	typs[125] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[7]), ir.NewField(base.Pos, nil, nil, typs[124])}, nil)
+	typs[125] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[124])}, nil)
 	typs[126] = types.Types[types.TUINT8]
-	typs[127] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[126]), ir.NewField(base.Pos, nil, nil, typs[126])}, nil)
+	typs[127] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[126]), types.NewField(src.NoXPos, nil, typs[126])}, nil)
 	typs[128] = types.Types[types.TUINT16]
-	typs[129] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[128]), ir.NewField(base.Pos, nil, nil, typs[128])}, nil)
-	typs[130] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[65]), ir.NewField(base.Pos, nil, nil, typs[65])}, nil)
-	typs[131] = NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, typs[24]), ir.NewField(base.Pos, nil, nil, typs[24])}, nil)
+	typs[129] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[128]), types.NewField(src.NoXPos, nil, typs[128])}, nil)
+	typs[130] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[65]), types.NewField(src.NoXPos, nil, typs[65])}, nil)
+	typs[131] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[24]), types.NewField(src.NoXPos, nil, typs[24])}, nil)
 	return typs[:]
 }
diff --git a/src/cmd/compile/internal/typecheck/mkbuiltin.go b/src/cmd/compile/internal/typecheck/mkbuiltin.go
index 27dbf1f10e..07f4b767e8 100644
--- a/src/cmd/compile/internal/typecheck/mkbuiltin.go
+++ b/src/cmd/compile/internal/typecheck/mkbuiltin.go
@@ -36,9 +36,8 @@ func main() {
 	fmt.Fprintln(&b, "package typecheck")
 	fmt.Fprintln(&b)
 	fmt.Fprintln(&b, `import (`)
-	fmt.Fprintln(&b, `      "cmd/compile/internal/base"`)
-	fmt.Fprintln(&b, `      "cmd/compile/internal/ir"`)
 	fmt.Fprintln(&b, `      "cmd/compile/internal/types"`)
+	fmt.Fprintln(&b, `      "cmd/internal/src"`)
 	fmt.Fprintln(&b, `)`)
 
 	mkbuiltin(&b, "runtime")
@@ -170,7 +169,7 @@ func (i *typeInterner) mktype(t ast.Expr) string {
 		}
 		return fmt.Sprintf("types.NewChan(%s, %s)", i.subtype(t.Value), dir)
 	case *ast.FuncType:
-		return fmt.Sprintf("NewFuncType(nil, %s, %s)", i.fields(t.Params, false), i.fields(t.Results, false))
+		return fmt.Sprintf("types.NewSignature(types.NoPkg, nil, %s, %s)", i.fields(t.Params, false), i.fields(t.Results, false))
 	case *ast.InterfaceType:
 		if len(t.Methods.List) != 0 {
 			log.Fatal("non-empty interfaces unsupported")
@@ -181,7 +180,7 @@ func (i *typeInterner) mktype(t ast.Expr) string {
 	case *ast.StarExpr:
 		return fmt.Sprintf("types.NewPtr(%s)", i.subtype(t.X))
 	case *ast.StructType:
-		return fmt.Sprintf("NewStructType(%s)", i.fields(t.Fields, true))
+		return fmt.Sprintf("types.NewStruct(types.NoPkg, %s)", i.fields(t.Fields, true))
 
 	default:
 		log.Fatalf("unhandled type: %#v", t)
@@ -197,18 +196,18 @@ func (i *typeInterner) fields(fl *ast.FieldList, keepNames bool) string {
 	for _, f := range fl.List {
 		typ := i.subtype(f.Type)
 		if len(f.Names) == 0 {
-			res = append(res, fmt.Sprintf("ir.NewField(base.Pos, nil, nil, %s)", typ))
+			res = append(res, fmt.Sprintf("types.NewField(src.NoXPos, nil, %s)", typ))
 		} else {
 			for _, name := range f.Names {
 				if keepNames {
-					res = append(res, fmt.Sprintf("ir.NewField(base.Pos, Lookup(%q), nil, %s)", name.Name, typ))
+					res = append(res, fmt.Sprintf("types.NewField(src.NoXPos, Lookup(%q), %s)", name.Name, typ))
 				} else {
-					res = append(res, fmt.Sprintf("ir.NewField(base.Pos, nil, nil, %s)", typ))
+					res = append(res, fmt.Sprintf("types.NewField(src.NoXPos, nil, %s)", typ))
 				}
 			}
 		}
 	}
-	return fmt.Sprintf("[]*ir.Field{%s}", strings.Join(res, ", "))
+	return fmt.Sprintf("[]*types.Field{%s}", strings.Join(res, ", "))
 }
 
 func intconst(e ast.Expr) int64 {
-- 
GitLab


From 87a592b35602e89c55218d2a54a1e0dade5db7e2 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 23 Dec 2020 01:15:58 -0800
Subject: [PATCH 0322/2400] [dev.regabi] cmd/compile: cleanup import/export
 code

Now that we have concrete AST node types and better constructor APIs,
we can more cleanup a lot of the import code and some export code too.

Passes toolstash -cmp.

Change-Id: Ie3425d9dac11ac4245e5da675dd298984a926df4
Reviewed-on: https://go-review.googlesource.com/c/go/+/279954
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/typecheck/iexport.go |  27 +----
 src/cmd/compile/internal/typecheck/iimport.go | 114 +++++++-----------
 2 files changed, 49 insertions(+), 92 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index 4ddee01b5a..95a100e6a5 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -1155,7 +1155,7 @@ func (w *exportWriter) stmt(n ir.Node) {
 		w.pos(n.Pos())
 		w.stmtList(n.Init())
 		w.exprsOrNil(nil, nil) // TODO(rsc): Delete (and fix importer).
-		w.caseList(n)
+		w.caseList(n.Cases, false)
 
 	case ir.OSWITCH:
 		n := n.(*ir.SwitchStmt)
@@ -1163,7 +1163,7 @@ func (w *exportWriter) stmt(n ir.Node) {
 		w.pos(n.Pos())
 		w.stmtList(n.Init())
 		w.exprsOrNil(n.Tag, nil)
-		w.caseList(n)
+		w.caseList(n.Cases, isNamedTypeSwitch(n.Tag))
 
 	// case OCASE:
 	//	handled by caseList
@@ -1187,27 +1187,12 @@ func (w *exportWriter) stmt(n ir.Node) {
 	}
 }
 
-func isNamedTypeSwitch(n ir.Node) bool {
-	if n.Op() != ir.OSWITCH {
-		return false
-	}
-	sw := n.(*ir.SwitchStmt)
-	if sw.Tag == nil || sw.Tag.Op() != ir.OTYPESW {
-		return false
-	}
-	guard := sw.Tag.(*ir.TypeSwitchGuard)
-	return guard.Tag != nil
+func isNamedTypeSwitch(x ir.Node) bool {
+	guard, ok := x.(*ir.TypeSwitchGuard)
+	return ok && guard.Tag != nil
 }
 
-func (w *exportWriter) caseList(sw ir.Node) {
-	namedTypeSwitch := isNamedTypeSwitch(sw)
-
-	var cases []ir.Node
-	if sw.Op() == ir.OSWITCH {
-		cases = sw.(*ir.SwitchStmt).Cases
-	} else {
-		cases = sw.(*ir.SelectStmt).Cases
-	}
+func (w *exportWriter) caseList(cases []ir.Node, namedTypeSwitch bool) {
 	w.uint64(uint64(len(cases)))
 	for _, cas := range cases {
 		cas := cas.(*ir.CaseStmt)
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index ab43d4f71b..3c7dde5506 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -767,8 +767,8 @@ func (r *importReader) stmtList() []ir.Node {
 	return list
 }
 
-func (r *importReader) caseList(sw ir.Node) []ir.Node {
-	namedTypeSwitch := isNamedTypeSwitch(sw)
+func (r *importReader) caseList(switchExpr ir.Node) []ir.Node {
+	namedTypeSwitch := isNamedTypeSwitch(switchExpr)
 
 	cases := make([]ir.Node, r.uint64())
 	for i := range cases {
@@ -781,7 +781,7 @@ func (r *importReader) caseList(sw ir.Node) []ir.Node {
 			caseVar := ir.NewNameAt(cas.Pos(), r.ident())
 			Declare(caseVar, DeclContext)
 			cas.Vars = []ir.Node{caseVar}
-			caseVar.Defn = sw.(*ir.SwitchStmt).Tag
+			caseVar.Defn = switchExpr
 		}
 		cas.Body.Set(r.stmtList())
 		cases[i] = cas
@@ -821,7 +821,7 @@ func (r *importReader) node() ir.Node {
 		pos := r.pos()
 		typ := r.typ()
 
-		n := npos(pos, NodNil())
+		n := ir.NewNilExpr(pos)
 		n.SetType(typ)
 		return n
 
@@ -829,7 +829,7 @@ func (r *importReader) node() ir.Node {
 		pos := r.pos()
 		typ := r.typ()
 
-		n := npos(pos, ir.NewLiteral(r.value(typ)))
+		n := ir.NewBasicLit(pos, r.value(typ))
 		n.SetType(typ)
 		return n
 
@@ -864,26 +864,19 @@ func (r *importReader) node() ir.Node {
 	//	unreachable - mapped to case OADDR below by exporter
 
 	case ir.OSTRUCTLIT:
-		// TODO(mdempsky): Export position information for OSTRUCTKEY nodes.
-		savedlineno := base.Pos
-		base.Pos = r.pos()
-		n := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(r.typ()).(ir.Ntype), nil)
-		n.List.Set(r.elemList()) // special handling of field names
-		base.Pos = savedlineno
-		return n
+		pos := r.pos()
+		return ir.NewCompLitExpr(pos, ir.OCOMPLIT, ir.TypeNode(r.typ()).(ir.Ntype), r.elemList(pos))
 
 	// case OARRAYLIT, OSLICELIT, OMAPLIT:
 	// 	unreachable - mapped to case OCOMPLIT below by exporter
 
 	case ir.OCOMPLIT:
-		n := ir.NewCompLitExpr(r.pos(), ir.OCOMPLIT, ir.TypeNode(r.typ()).(ir.Ntype), nil)
-		n.List.Set(r.exprList())
-		return n
+		return ir.NewCompLitExpr(r.pos(), ir.OCOMPLIT, ir.TypeNode(r.typ()).(ir.Ntype), r.exprList())
 
 	case ir.OKEY:
 		pos := r.pos()
-		left, right := r.exprsOrNil()
-		return ir.NewKeyExpr(pos, left, right)
+		key, value := r.exprsOrNil()
+		return ir.NewKeyExpr(pos, key, value)
 
 	// case OSTRUCTKEY:
 	//	unreachable - handled in case OSTRUCTLIT by elemList
@@ -926,9 +919,9 @@ func (r *importReader) node() ir.Node {
 	// 	unreachable - mapped to OCONV case below by exporter
 
 	case ir.OCONV:
-		n := ir.NewConvExpr(r.pos(), ir.OCONV, nil, r.expr())
-		n.SetType(r.typ())
-		return n
+		pos := r.pos()
+		x := r.expr()
+		return ir.NewConvExpr(pos, ir.OCONV, r.typ(), x)
 
 	case ir.OCOPY, ir.OCOMPLEX, ir.OREAL, ir.OIMAG, ir.OAPPEND, ir.OCAP, ir.OCLOSE, ir.ODELETE, ir.OLEN, ir.OMAKE, ir.ONEW, ir.OPANIC, ir.ORECOVER, ir.OPRINT, ir.OPRINTN:
 		n := builtinCall(r.pos(), op)
@@ -942,10 +935,10 @@ func (r *importReader) node() ir.Node {
 	// 	unreachable - mapped to OCALL case below by exporter
 
 	case ir.OCALL:
-		n := ir.NewCallExpr(r.pos(), ir.OCALL, nil, nil)
-		n.PtrInit().Set(r.stmtList())
-		n.X = r.expr()
-		n.Args.Set(r.exprList())
+		pos := r.pos()
+		init := r.stmtList()
+		n := ir.NewCallExpr(pos, ir.OCALL, r.expr(), r.exprList())
+		n.PtrInit().Set(init)
 		n.IsDDD = r.bool()
 		return n
 
@@ -979,7 +972,8 @@ func (r *importReader) node() ir.Node {
 	case ir.OADDSTR:
 		pos := r.pos()
 		list := r.exprList()
-		x := npos(pos, list[0])
+		x := list[0]
+		x.SetPos(pos) // TODO(mdempsky): Remove toolstash bandage.
 		for _, y := range list[1:] {
 			x = ir.NewBinaryExpr(pos, ir.OADD, x, y)
 		}
@@ -1006,9 +1000,7 @@ func (r *importReader) node() ir.Node {
 		return ir.NewAssignStmt(r.pos(), r.expr(), r.expr())
 
 	case ir.OASOP:
-		n := ir.NewAssignOpStmt(r.pos(), ir.OXXX, nil, nil)
-		n.AsOp = r.op()
-		n.X = r.expr()
+		n := ir.NewAssignOpStmt(r.pos(), r.op(), r.expr(), nil)
 		if !r.bool() {
 			n.Y = ir.NewInt(1)
 			n.IncDec = true
@@ -1021,15 +1013,10 @@ func (r *importReader) node() ir.Node {
 	// 	unreachable - mapped to OAS2 case below by exporter
 
 	case ir.OAS2:
-		n := ir.NewAssignListStmt(r.pos(), ir.OAS2, nil, nil)
-		n.Lhs.Set(r.exprList())
-		n.Rhs.Set(r.exprList())
-		return n
+		return ir.NewAssignListStmt(r.pos(), ir.OAS2, r.exprList(), r.exprList())
 
 	case ir.ORETURN:
-		n := ir.NewReturnStmt(r.pos(), nil)
-		n.Results.Set(r.exprList())
-		return n
+		return ir.NewReturnStmt(r.pos(), r.exprList())
 
 	// case ORETJMP:
 	// 	unreachable - generated by compiler for trampolin routines (not exported)
@@ -1038,57 +1025,47 @@ func (r *importReader) node() ir.Node {
 		return ir.NewGoDeferStmt(r.pos(), op, r.expr())
 
 	case ir.OIF:
-		n := ir.NewIfStmt(r.pos(), nil, nil, nil)
-		n.PtrInit().Set(r.stmtList())
-		n.Cond = r.expr()
-		n.Body.Set(r.stmtList())
-		n.Else.Set(r.stmtList())
+		pos, init := r.pos(), r.stmtList()
+		n := ir.NewIfStmt(pos, r.expr(), r.stmtList(), r.stmtList())
+		n.PtrInit().Set(init)
 		return n
 
 	case ir.OFOR:
-		n := ir.NewForStmt(r.pos(), nil, nil, nil, nil)
-		n.PtrInit().Set(r.stmtList())
-		left, right := r.exprsOrNil()
-		n.Cond = left
-		n.Post = right
-		n.Body.Set(r.stmtList())
-		return n
+		pos, init := r.pos(), r.stmtList()
+		cond, post := r.exprsOrNil()
+		return ir.NewForStmt(pos, init, cond, post, r.stmtList())
 
 	case ir.ORANGE:
-		n := ir.NewRangeStmt(r.pos(), nil, nil, nil)
-		n.Vars.Set(r.stmtList())
-		n.X = r.expr()
-		n.Body.Set(r.stmtList())
-		return n
+		return ir.NewRangeStmt(r.pos(), r.stmtList(), r.expr(), r.stmtList())
 
 	case ir.OSELECT:
-		n := ir.NewSelectStmt(r.pos(), nil)
-		n.PtrInit().Set(r.stmtList())
+		pos := r.pos()
+		init := r.stmtList()
 		r.exprsOrNil() // TODO(rsc): Delete (and fix exporter). These are always nil.
-		n.Cases.Set(r.caseList(n))
+		n := ir.NewSelectStmt(pos, r.caseList(nil))
+		n.PtrInit().Set(init)
 		return n
 
 	case ir.OSWITCH:
-		n := ir.NewSwitchStmt(r.pos(), nil, nil)
-		n.PtrInit().Set(r.stmtList())
-		left, _ := r.exprsOrNil()
-		n.Tag = left
-		n.Cases.Set(r.caseList(n))
+		pos := r.pos()
+		init := r.stmtList()
+		x, _ := r.exprsOrNil()
+		n := ir.NewSwitchStmt(pos, x, r.caseList(x))
+		n.PtrInit().Set(init)
 		return n
 
 	// case OCASE:
 	//	handled by caseList
 
 	case ir.OFALL:
-		n := ir.NewBranchStmt(r.pos(), ir.OFALL, nil)
-		return n
+		return ir.NewBranchStmt(r.pos(), ir.OFALL, nil)
 
 	// case OEMPTY:
 	// 	unreachable - not emitted by exporter
 
 	case ir.OBREAK, ir.OCONTINUE, ir.OGOTO:
-		var sym *types.Sym
 		pos := r.pos()
+		var sym *types.Sym
 		if label := r.string(); label != "" {
 			sym = Lookup(label)
 		}
@@ -1111,12 +1088,12 @@ func (r *importReader) op() ir.Op {
 	return ir.Op(r.uint64())
 }
 
-func (r *importReader) elemList() []ir.Node {
+func (r *importReader) elemList(pos src.XPos) []ir.Node {
 	c := r.uint64()
 	list := make([]ir.Node, c)
 	for i := range list {
-		s := r.ident()
-		list[i] = ir.NewStructKeyExpr(base.Pos, s, r.expr())
+		// TODO(mdempsky): Export position information for OSTRUCTKEY nodes.
+		list[i] = ir.NewStructKeyExpr(pos, r.ident(), r.expr())
 	}
 	return list
 }
@@ -1135,8 +1112,3 @@ func (r *importReader) exprsOrNil() (a, b ir.Node) {
 func builtinCall(pos src.XPos, op ir.Op) *ir.CallExpr {
 	return ir.NewCallExpr(pos, ir.OCALL, ir.NewIdent(base.Pos, types.BuiltinPkg.Lookup(ir.OpNames[op])), nil)
 }
-
-func npos(pos src.XPos, n ir.Node) ir.Node {
-	n.SetPos(pos)
-	return n
-}
-- 
GitLab


From 18ebfb49e9114b98e5a66acae073f5514e383aba Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 23 Dec 2020 02:00:39 -0800
Subject: [PATCH 0323/2400] [dev.regabi] cmd/compile: cleanup noder

Similar to previous CL: take advantage of better constructor APIs for
translating ASTs from syntax to ir.

Passes toolstash -cmp.

Change-Id: I40970775e7dd5afe2a0b7593ce3bd73237562457
Reviewed-on: https://go-review.googlesource.com/c/go/+/279972
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/noder/noder.go | 96 +++++++++----------------
 1 file changed, 33 insertions(+), 63 deletions(-)

diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index a684673c8f..c73e2d7fc5 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -377,11 +377,7 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
 func (p *noder) varDecl(decl *syntax.VarDecl) []ir.Node {
 	names := p.declNames(ir.ONAME, decl.NameList)
 	typ := p.typeExprOrNil(decl.Type)
-
-	var exprs []ir.Node
-	if decl.Values != nil {
-		exprs = p.exprList(decl.Values)
-	}
+	exprs := p.exprList(decl.Values)
 
 	if pragma, ok := decl.Pragma.(*pragmas); ok {
 		if len(pragma.Embeds) > 0 {
@@ -620,10 +616,14 @@ func (p *noder) param(param *syntax.Field, dddOk, final bool) *ir.Field {
 }
 
 func (p *noder) exprList(expr syntax.Expr) []ir.Node {
-	if list, ok := expr.(*syntax.ListExpr); ok {
-		return p.exprs(list.ElemList)
+	switch expr := expr.(type) {
+	case nil:
+		return nil
+	case *syntax.ListExpr:
+		return p.exprs(expr.ElemList)
+	default:
+		return []ir.Node{p.expr(expr)}
 	}
-	return []ir.Node{p.expr(expr)}
 }
 
 func (p *noder) exprs(exprs []syntax.Expr) []ir.Node {
@@ -642,17 +642,14 @@ func (p *noder) expr(expr syntax.Expr) ir.Node {
 	case *syntax.Name:
 		return p.mkname(expr)
 	case *syntax.BasicLit:
-		n := ir.NewLiteral(p.basicLit(expr))
+		n := ir.NewBasicLit(p.pos(expr), p.basicLit(expr))
 		if expr.Kind == syntax.RuneLit {
 			n.SetType(types.UntypedRune)
 		}
 		n.SetDiag(expr.Bad) // avoid follow-on errors if there was a syntax error
 		return n
 	case *syntax.CompositeLit:
-		n := ir.NewCompLitExpr(p.pos(expr), ir.OCOMPLIT, nil, nil)
-		if expr.Type != nil {
-			n.Ntype = ir.Node(p.expr(expr.Type)).(ir.Ntype)
-		}
+		n := ir.NewCompLitExpr(p.pos(expr), ir.OCOMPLIT, p.typeExpr(expr.Type), nil)
 		l := p.exprs(expr.ElemList)
 		for i, e := range l {
 			l[i] = p.wrapname(expr.ElemList[i], e)
@@ -695,7 +692,7 @@ func (p *noder) expr(expr syntax.Expr) ir.Node {
 		n.SetSliceBounds(index[0], index[1], index[2])
 		return n
 	case *syntax.AssertExpr:
-		return ir.NewTypeAssertExpr(p.pos(expr), p.expr(expr.X), p.typeExpr(expr.Type).(ir.Ntype))
+		return ir.NewTypeAssertExpr(p.pos(expr), p.expr(expr.X), p.typeExpr(expr.Type))
 	case *syntax.Operation:
 		if expr.Op == syntax.Add && expr.Y != nil {
 			return p.sum(expr)
@@ -719,8 +716,7 @@ func (p *noder) expr(expr syntax.Expr) ir.Node {
 		}
 		return ir.NewBinaryExpr(pos, op, x, y)
 	case *syntax.CallExpr:
-		n := ir.NewCallExpr(p.pos(expr), ir.OCALL, p.expr(expr.Fun), nil)
-		n.Args.Set(p.exprs(expr.ArgList))
+		n := ir.NewCallExpr(p.pos(expr), ir.OCALL, p.expr(expr.Fun), p.exprs(expr.ArgList))
 		n.IsDDD = expr.HasDots
 		return n
 
@@ -987,7 +983,7 @@ func (p *noder) stmt(stmt syntax.Stmt) ir.Node {
 func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) ir.Node {
 	p.setlineno(stmt)
 	switch stmt := stmt.(type) {
-	case *syntax.EmptyStmt:
+	case nil, *syntax.EmptyStmt:
 		return nil
 	case *syntax.LabeledStmt:
 		return p.labeledStmt(stmt, fallOK)
@@ -1060,12 +1056,7 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) ir.Node {
 		}
 		return ir.NewGoDeferStmt(p.pos(stmt), op, p.expr(stmt.Call))
 	case *syntax.ReturnStmt:
-		var results []ir.Node
-		if stmt.Results != nil {
-			results = p.exprList(stmt.Results)
-		}
-		n := ir.NewReturnStmt(p.pos(stmt), nil)
-		n.Results.Set(results)
+		n := ir.NewReturnStmt(p.pos(stmt), p.exprList(stmt.Results))
 		if len(n.Results) == 0 && ir.CurFunc != nil {
 			for _, ln := range ir.CurFunc.Dcl {
 				if ln.Class_ == ir.PPARAM {
@@ -1159,14 +1150,9 @@ func (p *noder) blockStmt(stmt *syntax.BlockStmt) []ir.Node {
 
 func (p *noder) ifStmt(stmt *syntax.IfStmt) ir.Node {
 	p.openScope(stmt.Pos())
-	n := ir.NewIfStmt(p.pos(stmt), nil, nil, nil)
-	if stmt.Init != nil {
-		*n.PtrInit() = []ir.Node{p.stmt(stmt.Init)}
-	}
-	if stmt.Cond != nil {
-		n.Cond = p.expr(stmt.Cond)
-	}
-	n.Body.Set(p.blockStmt(stmt.Then))
+	init := p.simpleStmt(stmt.Init)
+	n := ir.NewIfStmt(p.pos(stmt), p.expr(stmt.Cond), p.blockStmt(stmt.Then), nil)
+	*n.PtrInit() = init
 	if stmt.Else != nil {
 		e := p.stmt(stmt.Else)
 		if e.Op() == ir.OBLOCK {
@@ -1197,30 +1183,17 @@ func (p *noder) forStmt(stmt *syntax.ForStmt) ir.Node {
 		return n
 	}
 
-	n := ir.NewForStmt(p.pos(stmt), nil, nil, nil, nil)
-	if stmt.Init != nil {
-		*n.PtrInit() = []ir.Node{p.stmt(stmt.Init)}
-	}
-	if stmt.Cond != nil {
-		n.Cond = p.expr(stmt.Cond)
-	}
-	if stmt.Post != nil {
-		n.Post = p.stmt(stmt.Post)
-	}
-	n.Body.Set(p.blockStmt(stmt.Body))
+	n := ir.NewForStmt(p.pos(stmt), p.simpleStmt(stmt.Init), p.expr(stmt.Cond), p.stmt(stmt.Post), p.blockStmt(stmt.Body))
 	p.closeAnotherScope()
 	return n
 }
 
 func (p *noder) switchStmt(stmt *syntax.SwitchStmt) ir.Node {
 	p.openScope(stmt.Pos())
-	n := ir.NewSwitchStmt(p.pos(stmt), nil, nil)
-	if stmt.Init != nil {
-		*n.PtrInit() = []ir.Node{p.stmt(stmt.Init)}
-	}
-	if stmt.Tag != nil {
-		n.Tag = p.expr(stmt.Tag)
-	}
+
+	init := p.simpleStmt(stmt.Init)
+	n := ir.NewSwitchStmt(p.pos(stmt), p.expr(stmt.Tag), nil)
+	*n.PtrInit() = init
 
 	var tswitch *ir.TypeSwitchGuard
 	if l := n.Tag; l != nil && l.Op() == ir.OTYPESW {
@@ -1241,10 +1214,7 @@ func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *ir.TypeSwitch
 		}
 		p.openScope(clause.Pos())
 
-		n := ir.NewCaseStmt(p.pos(clause), nil, nil)
-		if clause.Cases != nil {
-			n.List.Set(p.exprList(clause.Cases))
-		}
+		n := ir.NewCaseStmt(p.pos(clause), p.exprList(clause.Cases), nil)
 		if tswitch != nil && tswitch.Tag != nil {
 			nn := typecheck.NewName(tswitch.Tag.Sym())
 			typecheck.Declare(nn, typecheck.DeclContext)
@@ -1283,13 +1253,18 @@ func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *ir.TypeSwitch
 }
 
 func (p *noder) selectStmt(stmt *syntax.SelectStmt) ir.Node {
-	n := ir.NewSelectStmt(p.pos(stmt), nil)
-	n.Cases.Set(p.commClauses(stmt.Body, stmt.Rbrace))
-	return n
+	return ir.NewSelectStmt(p.pos(stmt), p.commClauses(stmt.Body, stmt.Rbrace))
+}
+
+func (p *noder) simpleStmt(stmt syntax.SimpleStmt) []ir.Node {
+	if stmt == nil {
+		return nil
+	}
+	return []ir.Node{p.stmt(stmt)}
 }
 
 func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []ir.Node {
-	nodes := make([]ir.Node, 0, len(clauses))
+	nodes := make([]ir.Node, len(clauses))
 	for i, clause := range clauses {
 		p.setlineno(clause)
 		if i > 0 {
@@ -1297,12 +1272,7 @@ func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []i
 		}
 		p.openScope(clause.Pos())
 
-		n := ir.NewCaseStmt(p.pos(clause), nil, nil)
-		if clause.Comm != nil {
-			n.List = []ir.Node{p.stmt(clause.Comm)}
-		}
-		n.Body.Set(p.stmts(clause.Body))
-		nodes = append(nodes, n)
+		nodes[i] = ir.NewCaseStmt(p.pos(clause), p.simpleStmt(clause.Comm), p.stmts(clause.Body))
 	}
 	if len(clauses) > 0 {
 		p.closeScope(rbrace)
-- 
GitLab


From addade2cce83fb0019ad8394311c51466d4042cf Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 23 Dec 2020 02:16:17 -0800
Subject: [PATCH 0324/2400] [dev.regabi] cmd/compile: prefer types constructors
 over typecheck

Similar to the earlier mkbuiltin cleanup, there's a bunch of code that
calls typecheck.NewFuncType or typecheck.NewStructType, which can now
just call types.NewSignature and types.NewStruct, respectively.

Passes toolstash -cmp.

Change-Id: Ie6e09f1a7efef84b9a2bb5daa7087a6879979668
Reviewed-on: https://go-review.googlesource.com/c/go/+/279955
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/reflectdata/alg.go   | 22 ++++++------
 .../compile/internal/reflectdata/reflect.go   |  6 +++-
 src/cmd/compile/internal/typecheck/dcl.go     | 34 ++++++++-----------
 src/cmd/compile/internal/typecheck/func.go    | 14 ++++----
 src/cmd/compile/internal/walk/compare.go      | 10 +++---
 src/cmd/compile/internal/walk/select.go       |  6 ++--
 6 files changed, 46 insertions(+), 46 deletions(-)

diff --git a/src/cmd/compile/internal/reflectdata/alg.go b/src/cmd/compile/internal/reflectdata/alg.go
index 8391486e50..1f943f5795 100644
--- a/src/cmd/compile/internal/reflectdata/alg.go
+++ b/src/cmd/compile/internal/reflectdata/alg.go
@@ -289,11 +289,11 @@ func hashfor(t *types.Type) ir.Node {
 
 	n := typecheck.NewName(sym)
 	ir.MarkFunc(n)
-	n.SetType(typecheck.NewFuncType(nil, []*ir.Field{
-		ir.NewField(base.Pos, nil, nil, types.NewPtr(t)),
-		ir.NewField(base.Pos, nil, nil, types.Types[types.TUINTPTR]),
-	}, []*ir.Field{
-		ir.NewField(base.Pos, nil, nil, types.Types[types.TUINTPTR]),
+	n.SetType(types.NewSignature(types.NoPkg, nil, []*types.Field{
+		types.NewField(base.Pos, nil, types.NewPtr(t)),
+		types.NewField(base.Pos, nil, types.Types[types.TUINTPTR]),
+	}, []*types.Field{
+		types.NewField(base.Pos, nil, types.Types[types.TUINTPTR]),
 	}))
 	return n
 }
@@ -777,12 +777,12 @@ func hashmem(t *types.Type) ir.Node {
 
 	n := typecheck.NewName(sym)
 	ir.MarkFunc(n)
-	n.SetType(typecheck.NewFuncType(nil, []*ir.Field{
-		ir.NewField(base.Pos, nil, nil, types.NewPtr(t)),
-		ir.NewField(base.Pos, nil, nil, types.Types[types.TUINTPTR]),
-		ir.NewField(base.Pos, nil, nil, types.Types[types.TUINTPTR]),
-	}, []*ir.Field{
-		ir.NewField(base.Pos, nil, nil, types.Types[types.TUINTPTR]),
+	n.SetType(types.NewSignature(types.NoPkg, nil, []*types.Field{
+		types.NewField(base.Pos, nil, types.NewPtr(t)),
+		types.NewField(base.Pos, nil, types.Types[types.TUINTPTR]),
+		types.NewField(base.Pos, nil, types.Types[types.TUINTPTR]),
+	}, []*types.Field{
+		types.NewField(base.Pos, nil, types.Types[types.TUINTPTR]),
 	}))
 	return n
 }
diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index ba3e0fa75e..3fbf6f337f 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -1419,7 +1419,11 @@ func WriteBasicTypes() {
 		// The latter is the type of an auto-generated wrapper.
 		WriteType(types.NewPtr(types.ErrorType))
 
-		WriteType(typecheck.NewFuncType(nil, []*ir.Field{ir.NewField(base.Pos, nil, nil, types.ErrorType)}, []*ir.Field{ir.NewField(base.Pos, nil, nil, types.Types[types.TSTRING])}))
+		WriteType(types.NewSignature(types.NoPkg, nil, []*types.Field{
+			types.NewField(base.Pos, nil, types.ErrorType),
+		}, []*types.Field{
+			types.NewField(base.Pos, nil, types.Types[types.TSTRING]),
+		}))
 
 		// add paths for runtime and main, which 6l imports implicitly.
 		dimportpath(ir.Pkgs.Runtime)
diff --git a/src/cmd/compile/internal/typecheck/dcl.go b/src/cmd/compile/internal/typecheck/dcl.go
index 9f66d0fa17..bfdd76ba10 100644
--- a/src/cmd/compile/internal/typecheck/dcl.go
+++ b/src/cmd/compile/internal/typecheck/dcl.go
@@ -676,30 +676,26 @@ func autotmpname(n int) string {
 
 // f is method type, with receiver.
 // return function type, receiver as first argument (or not).
-func NewMethodType(f *types.Type, receiver *types.Type) *types.Type {
-	inLen := f.Params().Fields().Len()
-	if receiver != nil {
-		inLen++
+func NewMethodType(sig *types.Type, recv *types.Type) *types.Type {
+	nrecvs := 0
+	if recv != nil {
+		nrecvs++
 	}
-	in := make([]*ir.Field, 0, inLen)
 
-	if receiver != nil {
-		d := ir.NewField(base.Pos, nil, nil, receiver)
-		in = append(in, d)
+	params := make([]*types.Field, nrecvs+sig.Params().Fields().Len())
+	if recv != nil {
+		params[0] = types.NewField(base.Pos, nil, recv)
 	}
-
-	for _, t := range f.Params().Fields().Slice() {
-		d := ir.NewField(base.Pos, nil, nil, t.Type)
-		d.IsDDD = t.IsDDD()
-		in = append(in, d)
+	for i, param := range sig.Params().Fields().Slice() {
+		d := types.NewField(base.Pos, nil, param.Type)
+		d.SetIsDDD(param.IsDDD())
+		params[nrecvs+i] = d
 	}
 
-	outLen := f.Results().Fields().Len()
-	out := make([]*ir.Field, 0, outLen)
-	for _, t := range f.Results().Fields().Slice() {
-		d := ir.NewField(base.Pos, nil, nil, t.Type)
-		out = append(out, d)
+	results := make([]*types.Field, sig.Results().Fields().Len())
+	for i, t := range sig.Results().Fields().Slice() {
+		results[i] = types.NewField(base.Pos, nil, t.Type)
 	}
 
-	return NewFuncType(nil, in, out)
+	return types.NewSignature(types.LocalPkg, nil, params, results)
 }
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index 99d81dcede..fdac719ad9 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -73,17 +73,17 @@ func ClosureType(clo *ir.ClosureExpr) *types.Type {
 	// The information appears in the binary in the form of type descriptors;
 	// the struct is unnamed so that closures in multiple packages with the
 	// same struct type can share the descriptor.
-	fields := []*ir.Field{
-		ir.NewField(base.Pos, Lookup(".F"), nil, types.Types[types.TUINTPTR]),
+	fields := []*types.Field{
+		types.NewField(base.Pos, Lookup(".F"), types.Types[types.TUINTPTR]),
 	}
 	for _, v := range clo.Func.ClosureVars {
 		typ := v.Type()
 		if !v.Byval() {
 			typ = types.NewPtr(typ)
 		}
-		fields = append(fields, ir.NewField(base.Pos, v.Sym(), nil, typ))
+		fields = append(fields, types.NewField(base.Pos, v.Sym(), typ))
 	}
-	typ := NewStructType(fields)
+	typ := types.NewStruct(types.NoPkg, fields)
 	typ.SetNoalg(true)
 	return typ
 }
@@ -92,9 +92,9 @@ func ClosureType(clo *ir.ClosureExpr) *types.Type {
 // needed in the closure for n (n must be a OCALLPART node).
 // The address of a variable of the returned type can be cast to a func.
 func PartialCallType(n *ir.CallPartExpr) *types.Type {
-	t := NewStructType([]*ir.Field{
-		ir.NewField(base.Pos, Lookup("F"), nil, types.Types[types.TUINTPTR]),
-		ir.NewField(base.Pos, Lookup("R"), nil, n.X.Type()),
+	t := types.NewStruct(types.NoPkg, []*types.Field{
+		types.NewField(base.Pos, Lookup("F"), types.Types[types.TUINTPTR]),
+		types.NewField(base.Pos, Lookup("R"), n.X.Type()),
 	})
 	t.SetNoalg(true)
 	return t
diff --git a/src/cmd/compile/internal/walk/compare.go b/src/cmd/compile/internal/walk/compare.go
index b1ab42782b..40b45d4dea 100644
--- a/src/cmd/compile/internal/walk/compare.go
+++ b/src/cmd/compile/internal/walk/compare.go
@@ -428,11 +428,11 @@ func eqFor(t *types.Type) (n ir.Node, needsize bool) {
 		sym := reflectdata.TypeSymPrefix(".eq", t)
 		n := typecheck.NewName(sym)
 		ir.MarkFunc(n)
-		n.SetType(typecheck.NewFuncType(nil, []*ir.Field{
-			ir.NewField(base.Pos, nil, nil, types.NewPtr(t)),
-			ir.NewField(base.Pos, nil, nil, types.NewPtr(t)),
-		}, []*ir.Field{
-			ir.NewField(base.Pos, nil, nil, types.Types[types.TBOOL]),
+		n.SetType(types.NewSignature(types.NoPkg, nil, []*types.Field{
+			types.NewField(base.Pos, nil, types.NewPtr(t)),
+			types.NewField(base.Pos, nil, types.NewPtr(t)),
+		}, []*types.Field{
+			types.NewField(base.Pos, nil, types.Types[types.TBOOL]),
 		}))
 		return n, false
 	}
diff --git a/src/cmd/compile/internal/walk/select.go b/src/cmd/compile/internal/walk/select.go
index 438131b294..5e03732169 100644
--- a/src/cmd/compile/internal/walk/select.go
+++ b/src/cmd/compile/internal/walk/select.go
@@ -287,9 +287,9 @@ var scase *types.Type
 // Keep in sync with src/runtime/select.go.
 func scasetype() *types.Type {
 	if scase == nil {
-		scase = typecheck.NewStructType([]*ir.Field{
-			ir.NewField(base.Pos, typecheck.Lookup("c"), nil, types.Types[types.TUNSAFEPTR]),
-			ir.NewField(base.Pos, typecheck.Lookup("elem"), nil, types.Types[types.TUNSAFEPTR]),
+		scase = types.NewStruct(types.NoPkg, []*types.Field{
+			types.NewField(base.Pos, typecheck.Lookup("c"), types.Types[types.TUNSAFEPTR]),
+			types.NewField(base.Pos, typecheck.Lookup("elem"), types.Types[types.TUNSAFEPTR]),
 		})
 		scase.SetNoalg(true)
 	}
-- 
GitLab


From 31267f82e16249a1d9065099c615a936dc32688b Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 23 Dec 2020 02:48:57 -0800
Subject: [PATCH 0325/2400] [dev.regabi] cmd/compile: simplify
 function/interface/struct typechecking

After the previous CL, the only callers to NewFuncType, tointerface,
or NewStructType are the functions for type-checking the type literal
ASTs. So just inline the code there.

While here, refactor the Field type-checking logic a little bit, to
reduce some duplication.

Passes toolstash -cmp.

Change-Id: Ie12d14b87ef8b6e528ac9dccd609604bd09b98ec
Reviewed-on: https://go-review.googlesource.com/c/go/+/279956
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/typecheck/dcl.go  | 87 ----------------------
 src/cmd/compile/internal/typecheck/type.go | 72 +++++++++++++++++-
 2 files changed, 69 insertions(+), 90 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/dcl.go b/src/cmd/compile/internal/typecheck/dcl.go
index bfdd76ba10..db18c17e13 100644
--- a/src/cmd/compile/internal/typecheck/dcl.go
+++ b/src/cmd/compile/internal/typecheck/dcl.go
@@ -281,72 +281,6 @@ func CheckFuncStack() {
 	}
 }
 
-// turn a parsed function declaration into a type
-func NewFuncType(nrecv *ir.Field, nparams, nresults []*ir.Field) *types.Type {
-	funarg := func(n *ir.Field) *types.Field {
-		lno := base.Pos
-		base.Pos = n.Pos
-
-		if n.Ntype != nil {
-			n.Type = typecheckNtype(n.Ntype).Type()
-			n.Ntype = nil
-		}
-
-		f := types.NewField(n.Pos, n.Sym, n.Type)
-		f.SetIsDDD(n.IsDDD)
-		if n.Decl != nil {
-			n.Decl.SetType(f.Type)
-			f.Nname = n.Decl
-		}
-
-		base.Pos = lno
-		return f
-	}
-	funargs := func(nn []*ir.Field) []*types.Field {
-		res := make([]*types.Field, len(nn))
-		for i, n := range nn {
-			res[i] = funarg(n)
-		}
-		return res
-	}
-
-	var recv *types.Field
-	if nrecv != nil {
-		recv = funarg(nrecv)
-	}
-
-	t := types.NewSignature(types.LocalPkg, recv, funargs(nparams), funargs(nresults))
-	checkdupfields("argument", t.Recvs().FieldSlice(), t.Params().FieldSlice(), t.Results().FieldSlice())
-	return t
-}
-
-// convert a parsed id/type list into
-// a type for struct/interface/arglist
-func NewStructType(l []*ir.Field) *types.Type {
-	lno := base.Pos
-
-	fields := make([]*types.Field, len(l))
-	for i, n := range l {
-		base.Pos = n.Pos
-
-		if n.Ntype != nil {
-			n.Type = typecheckNtype(n.Ntype).Type()
-			n.Ntype = nil
-		}
-		f := types.NewField(n.Pos, n.Sym, n.Type)
-		if n.Embedded {
-			checkembeddedtype(n.Type)
-			f.Embedded = 1
-		}
-		f.Note = n.Note
-		fields[i] = f
-	}
-	checkdupfields("field", fields)
-
-	base.Pos = lno
-	return types.NewStruct(types.LocalPkg, fields)
-}
-
 // Add a method, declared as a function.
 // - msym is the method symbol
 // - t is function type (with receiver)
@@ -604,27 +538,6 @@ func initname(s string) bool {
 	return s == "init"
 }
 
-func tointerface(nmethods []*ir.Field) *types.Type {
-	if len(nmethods) == 0 {
-		return types.Types[types.TINTER]
-	}
-
-	lno := base.Pos
-
-	methods := make([]*types.Field, len(nmethods))
-	for i, n := range nmethods {
-		base.Pos = n.Pos
-		if n.Ntype != nil {
-			n.Type = typecheckNtype(n.Ntype).Type()
-			n.Ntype = nil
-		}
-		methods[i] = types.NewField(n.Pos, n.Sym, n.Type)
-	}
-
-	base.Pos = lno
-	return types.NewInterface(types.LocalPkg, methods)
-}
-
 var vargen int
 
 func Temp(t *types.Type) *ir.Name {
diff --git a/src/cmd/compile/internal/typecheck/type.go b/src/cmd/compile/internal/typecheck/type.go
index 4782bb9c31..0c2ebb8b26 100644
--- a/src/cmd/compile/internal/typecheck/type.go
+++ b/src/cmd/compile/internal/typecheck/type.go
@@ -73,13 +73,42 @@ func tcChanType(n *ir.ChanType) ir.Node {
 
 // tcFuncType typechecks an OTFUNC node.
 func tcFuncType(n *ir.FuncType) ir.Node {
-	n.SetOTYPE(NewFuncType(n.Recv, n.Params, n.Results))
+	misc := func(f *types.Field, nf *ir.Field) {
+		f.SetIsDDD(nf.IsDDD)
+		if nf.Decl != nil {
+			nf.Decl.SetType(f.Type)
+			f.Nname = nf.Decl
+		}
+	}
+
+	lno := base.Pos
+
+	var recv *types.Field
+	if n.Recv != nil {
+		recv = tcField(n.Recv, misc)
+	}
+
+	t := types.NewSignature(types.LocalPkg, recv, tcFields(n.Params, misc), tcFields(n.Results, misc))
+	checkdupfields("argument", t.Recvs().FieldSlice(), t.Params().FieldSlice(), t.Results().FieldSlice())
+
+	base.Pos = lno
+
+	n.SetOTYPE(t)
 	return n
 }
 
 // tcInterfaceType typechecks an OTINTER node.
 func tcInterfaceType(n *ir.InterfaceType) ir.Node {
-	n.SetOTYPE(tointerface(n.Methods))
+	if len(n.Methods) == 0 {
+		n.SetOTYPE(types.Types[types.TINTER])
+		return n
+	}
+	
+	lno := base.Pos
+	methods := tcFields(n.Methods, nil)
+	base.Pos = lno
+
+	n.SetOTYPE(types.NewInterface(types.LocalPkg, methods))
 	return n
 }
 
@@ -117,6 +146,43 @@ func tcSliceType(n *ir.SliceType) ir.Node {
 
 // tcStructType typechecks an OTSTRUCT node.
 func tcStructType(n *ir.StructType) ir.Node {
-	n.SetOTYPE(NewStructType(n.Fields))
+	lno := base.Pos
+
+	fields := tcFields(n.Fields, func(f *types.Field, nf *ir.Field) {
+		if nf.Embedded {
+			checkembeddedtype(f.Type)
+			f.Embedded = 1
+		}
+		f.Note = nf.Note
+	})
+	checkdupfields("field", fields)
+
+	base.Pos = lno
+	n.SetOTYPE(types.NewStruct(types.LocalPkg, fields))
 	return n
 }
+
+// tcField typechecks a generic Field.
+// misc can be provided to handle specialized typechecking.
+func tcField(n *ir.Field, misc func(*types.Field, *ir.Field)) *types.Field {
+	base.Pos = n.Pos
+	if n.Ntype != nil {
+		n.Type = typecheckNtype(n.Ntype).Type()
+		n.Ntype = nil
+	}
+	f := types.NewField(n.Pos, n.Sym, n.Type)
+	if misc != nil {
+		misc(f, n)
+	}
+	return f
+}
+
+// tcFields typechecks a slice of generic Fields.
+// misc can be provided to handle specialized typechecking.
+func tcFields(l []*ir.Field, misc func(*types.Field, *ir.Field)) []*types.Field {
+	fields := make([]*types.Field, len(l))
+	for i, n := range l {
+		fields[i] = tcField(n, misc)
+	}
+	return fields
+}
-- 
GitLab


From 53f082b0ee81f14d1b1a1c997e2f8e9164af37bc Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 23 Dec 2020 03:33:03 -0800
Subject: [PATCH 0326/2400] [dev.regabi] cmd/compile: cleanup export code
 further

This CL rips off a number of toolstash bandages:

- Fixes position information for string concatenation.

- Adds position information for struct literal fields.

- Removes unnecessary exprsOrNil calls or replaces them with plain
  expr calls when possible.

- Reorders conversion expressions to put type first, which matches
  source order and also the order the importer needs for calling the
  ConvExpr constructor.

Change-Id: I44cdc6035540d9ecefd9c1bcd92b8711d6ed813c
Reviewed-on: https://go-review.googlesource.com/c/go/+/279957
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/typecheck/iexport.go | 11 ++++----
 src/cmd/compile/internal/typecheck/iimport.go | 26 ++++++-------------
 2 files changed, 13 insertions(+), 24 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index 95a100e6a5..8ac791c036 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -858,8 +858,6 @@ func intSize(typ *types.Type) (signed bool, maxBytes uint) {
 // according to the maximum number of bytes needed to encode a value
 // of type typ. As a special case, 8-bit types are always encoded as a
 // single byte.
-//
-// TODO(mdempsky): Is this level of complexity really worthwhile?
 func (w *exportWriter) mpint(x constant.Value, typ *types.Type) {
 	signed, maxBytes := intSize(typ)
 
@@ -1154,7 +1152,6 @@ func (w *exportWriter) stmt(n ir.Node) {
 		w.op(n.Op())
 		w.pos(n.Pos())
 		w.stmtList(n.Init())
-		w.exprsOrNil(nil, nil) // TODO(rsc): Delete (and fix importer).
 		w.caseList(n.Cases, false)
 
 	case ir.OSWITCH:
@@ -1298,7 +1295,7 @@ func (w *exportWriter) expr(n ir.Node) {
 			s = n.Tag.Sym()
 		}
 		w.localIdent(s, 0) // declared pseudo-variable, if any
-		w.exprsOrNil(n.X, nil)
+		w.expr(n.X)
 
 	// case OTARRAY, OTMAP, OTCHAN, OTSTRUCT, OTINTER, OTFUNC:
 	// 	should have been resolved by typechecking - handled by default case
@@ -1333,7 +1330,8 @@ func (w *exportWriter) expr(n ir.Node) {
 		n := n.(*ir.KeyExpr)
 		w.op(ir.OKEY)
 		w.pos(n.Pos())
-		w.exprsOrNil(n.Key, n.Value)
+		w.expr(n.Key)
+		w.expr(n.Value)
 
 	// case OSTRUCTKEY:
 	//	unreachable - handled in case OSTRUCTLIT by elemList
@@ -1397,8 +1395,8 @@ func (w *exportWriter) expr(n ir.Node) {
 		n := n.(*ir.ConvExpr)
 		w.op(ir.OCONV)
 		w.pos(n.Pos())
-		w.expr(n.X)
 		w.typ(n.Type())
+		w.expr(n.X)
 
 	case ir.OREAL, ir.OIMAG, ir.OCAP, ir.OCLOSE, ir.OLEN, ir.ONEW, ir.OPANIC:
 		n := n.(*ir.UnaryExpr)
@@ -1529,6 +1527,7 @@ func (w *exportWriter) fieldList(list ir.Nodes) {
 	w.uint64(uint64(len(list)))
 	for _, n := range list {
 		n := n.(*ir.StructKeyExpr)
+		w.pos(n.Pos())
 		w.selector(n.Field)
 		w.expr(n.Value)
 	}
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 3c7dde5506..c4d840d2ac 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -851,8 +851,7 @@ func (r *importReader) node() ir.Node {
 		if s := r.ident(); s != nil {
 			tag = ir.NewIdent(pos, s)
 		}
-		expr, _ := r.exprsOrNil()
-		return ir.NewTypeSwitchGuard(pos, tag, expr)
+		return ir.NewTypeSwitchGuard(pos, tag, r.expr())
 
 	// case OTARRAY, OTMAP, OTCHAN, OTSTRUCT, OTINTER, OTFUNC:
 	//      unreachable - should have been resolved by typechecking
@@ -864,19 +863,16 @@ func (r *importReader) node() ir.Node {
 	//	unreachable - mapped to case OADDR below by exporter
 
 	case ir.OSTRUCTLIT:
-		pos := r.pos()
-		return ir.NewCompLitExpr(pos, ir.OCOMPLIT, ir.TypeNode(r.typ()).(ir.Ntype), r.elemList(pos))
+		return ir.NewCompLitExpr(r.pos(), ir.OCOMPLIT, ir.TypeNode(r.typ()), r.fieldList())
 
 	// case OARRAYLIT, OSLICELIT, OMAPLIT:
 	// 	unreachable - mapped to case OCOMPLIT below by exporter
 
 	case ir.OCOMPLIT:
-		return ir.NewCompLitExpr(r.pos(), ir.OCOMPLIT, ir.TypeNode(r.typ()).(ir.Ntype), r.exprList())
+		return ir.NewCompLitExpr(r.pos(), ir.OCOMPLIT, ir.TypeNode(r.typ()), r.exprList())
 
 	case ir.OKEY:
-		pos := r.pos()
-		key, value := r.exprsOrNil()
-		return ir.NewKeyExpr(pos, key, value)
+		return ir.NewKeyExpr(r.pos(), r.expr(), r.expr())
 
 	// case OSTRUCTKEY:
 	//	unreachable - handled in case OSTRUCTLIT by elemList
@@ -919,9 +915,7 @@ func (r *importReader) node() ir.Node {
 	// 	unreachable - mapped to OCONV case below by exporter
 
 	case ir.OCONV:
-		pos := r.pos()
-		x := r.expr()
-		return ir.NewConvExpr(pos, ir.OCONV, r.typ(), x)
+		return ir.NewConvExpr(r.pos(), ir.OCONV, r.typ(), r.expr())
 
 	case ir.OCOPY, ir.OCOMPLEX, ir.OREAL, ir.OIMAG, ir.OAPPEND, ir.OCAP, ir.OCLOSE, ir.ODELETE, ir.OLEN, ir.OMAKE, ir.ONEW, ir.OPANIC, ir.ORECOVER, ir.OPRINT, ir.OPRINTN:
 		n := builtinCall(r.pos(), op)
@@ -973,7 +967,6 @@ func (r *importReader) node() ir.Node {
 		pos := r.pos()
 		list := r.exprList()
 		x := list[0]
-		x.SetPos(pos) // TODO(mdempsky): Remove toolstash bandage.
 		for _, y := range list[1:] {
 			x = ir.NewBinaryExpr(pos, ir.OADD, x, y)
 		}
@@ -1041,7 +1034,6 @@ func (r *importReader) node() ir.Node {
 	case ir.OSELECT:
 		pos := r.pos()
 		init := r.stmtList()
-		r.exprsOrNil() // TODO(rsc): Delete (and fix exporter). These are always nil.
 		n := ir.NewSelectStmt(pos, r.caseList(nil))
 		n.PtrInit().Set(init)
 		return n
@@ -1088,12 +1080,10 @@ func (r *importReader) op() ir.Op {
 	return ir.Op(r.uint64())
 }
 
-func (r *importReader) elemList(pos src.XPos) []ir.Node {
-	c := r.uint64()
-	list := make([]ir.Node, c)
+func (r *importReader) fieldList() []ir.Node {
+	list := make([]ir.Node, r.uint64())
 	for i := range list {
-		// TODO(mdempsky): Export position information for OSTRUCTKEY nodes.
-		list[i] = ir.NewStructKeyExpr(pos, r.ident(), r.expr())
+		list[i] = ir.NewStructKeyExpr(r.pos(), r.ident(), r.expr())
 	}
 	return list
 }
-- 
GitLab


From d19018e8f1970e2232b35931546ef60cdc0734d1 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 23 Dec 2020 05:40:11 -0800
Subject: [PATCH 0327/2400] [dev.regabi] cmd/compile: split
 SliceHeaderExpr.LenCap into separate fields

Passes toolstash -cmp.

Change-Id: Ifc98a408c154a05997963e2c731466842ebbf50e
Reviewed-on: https://go-review.googlesource.com/c/go/+/279958
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/ir/expr.go        |  8 ++++----
 src/cmd/compile/internal/ir/fmt.go         |  5 +----
 src/cmd/compile/internal/ir/node_gen.go    |  7 ++++---
 src/cmd/compile/internal/ssagen/ssa.go     |  4 ++--
 src/cmd/compile/internal/typecheck/expr.go | 18 +++++-------------
 src/cmd/compile/internal/walk/builtin.go   |  9 ++++++---
 src/cmd/compile/internal/walk/expr.go      |  4 ++--
 7 files changed, 24 insertions(+), 31 deletions(-)

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 640cc03954..d862a645d0 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -695,16 +695,16 @@ func (o Op) IsSlice3() bool {
 // A SliceHeader expression constructs a slice header from its parts.
 type SliceHeaderExpr struct {
 	miniExpr
-	Ptr    Node
-	LenCap Nodes // TODO(rsc): Split into two Node fields
+	Ptr Node
+	Len Node
+	Cap Node
 }
 
 func NewSliceHeaderExpr(pos src.XPos, typ *types.Type, ptr, len, cap Node) *SliceHeaderExpr {
-	n := &SliceHeaderExpr{Ptr: ptr}
+	n := &SliceHeaderExpr{Ptr: ptr, Len: len, Cap: cap}
 	n.pos = pos
 	n.op = OSLICEHEADER
 	n.typ = typ
-	n.LenCap = []Node{len, cap}
 	return n
 }
 
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 2682908539..8cfc38a9ae 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -800,10 +800,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 
 	case OSLICEHEADER:
 		n := n.(*SliceHeaderExpr)
-		if len(n.LenCap) != 2 {
-			base.Fatalf("bad OSLICEHEADER list length %d", len(n.LenCap))
-		}
-		fmt.Fprintf(s, "sliceheader{%v,%v,%v}", n.Ptr, n.LenCap[0], n.LenCap[1])
+		fmt.Fprintf(s, "sliceheader{%v,%v,%v}", n.Ptr, n.Len, n.Cap)
 
 	case OCOMPLEX, OCOPY:
 		n := n.(*BinaryExpr)
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index 89b1c0ba23..d11e7bf918 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -858,20 +858,21 @@ func (n *SliceHeaderExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *SliceHeaderExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
-	c.LenCap = c.LenCap.Copy()
 	return &c
 }
 func (n *SliceHeaderExpr) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
 	err = maybeDo(n.Ptr, err, do)
-	err = maybeDoList(n.LenCap, err, do)
+	err = maybeDo(n.Len, err, do)
+	err = maybeDo(n.Cap, err, do)
 	return err
 }
 func (n *SliceHeaderExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	n.Ptr = maybeEdit(n.Ptr, edit)
-	editList(n.LenCap, edit)
+	n.Len = maybeEdit(n.Len, edit)
+	n.Cap = maybeEdit(n.Cap, edit)
 }
 
 func (n *SliceType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index a77e57a5b6..6b2ba5a781 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -2844,8 +2844,8 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 	case ir.OSLICEHEADER:
 		n := n.(*ir.SliceHeaderExpr)
 		p := s.expr(n.Ptr)
-		l := s.expr(n.LenCap[0])
-		c := s.expr(n.LenCap[1])
+		l := s.expr(n.Len)
+		c := s.expr(n.Cap)
 		return s.newValue3(ssa.OpSliceMake, n.Type(), p, l, c)
 
 	case ir.OSLICE, ir.OSLICEARR, ir.OSLICE3, ir.OSLICE3ARR:
diff --git a/src/cmd/compile/internal/typecheck/expr.go b/src/cmd/compile/internal/typecheck/expr.go
index f940a2e73d..00615c506c 100644
--- a/src/cmd/compile/internal/typecheck/expr.go
+++ b/src/cmd/compile/internal/typecheck/expr.go
@@ -924,30 +924,22 @@ func tcSliceHeader(n *ir.SliceHeaderExpr) ir.Node {
 		base.Fatalf("need unsafe.Pointer for OSLICEHEADER")
 	}
 
-	if x := len(n.LenCap); x != 2 {
-		base.Fatalf("expected 2 params (len, cap) for OSLICEHEADER, got %d", x)
-	}
-
 	n.Ptr = Expr(n.Ptr)
-	l := Expr(n.LenCap[0])
-	c := Expr(n.LenCap[1])
-	l = DefaultLit(l, types.Types[types.TINT])
-	c = DefaultLit(c, types.Types[types.TINT])
+	n.Len = DefaultLit(Expr(n.Len), types.Types[types.TINT])
+	n.Cap = DefaultLit(Expr(n.Cap), types.Types[types.TINT])
 
-	if ir.IsConst(l, constant.Int) && ir.Int64Val(l) < 0 {
+	if ir.IsConst(n.Len, constant.Int) && ir.Int64Val(n.Len) < 0 {
 		base.Fatalf("len for OSLICEHEADER must be non-negative")
 	}
 
-	if ir.IsConst(c, constant.Int) && ir.Int64Val(c) < 0 {
+	if ir.IsConst(n.Cap, constant.Int) && ir.Int64Val(n.Cap) < 0 {
 		base.Fatalf("cap for OSLICEHEADER must be non-negative")
 	}
 
-	if ir.IsConst(l, constant.Int) && ir.IsConst(c, constant.Int) && constant.Compare(l.Val(), token.GTR, c.Val()) {
+	if ir.IsConst(n.Len, constant.Int) && ir.IsConst(n.Cap, constant.Int) && constant.Compare(n.Len.Val(), token.GTR, n.Cap.Val()) {
 		base.Fatalf("len larger than cap for OSLICEHEADER")
 	}
 
-	n.LenCap[0] = l
-	n.LenCap[1] = c
 	return n
 }
 
diff --git a/src/cmd/compile/internal/walk/builtin.go b/src/cmd/compile/internal/walk/builtin.go
index 61a555b773..63f7925863 100644
--- a/src/cmd/compile/internal/walk/builtin.go
+++ b/src/cmd/compile/internal/walk/builtin.go
@@ -438,7 +438,8 @@ func walkMakeSlice(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
 	fn := typecheck.LookupRuntime(fnname)
 	m.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, reflectdata.TypePtr(t.Elem()), typecheck.Conv(len, argtype), typecheck.Conv(cap, argtype))
 	m.Ptr.MarkNonNil()
-	m.LenCap = []ir.Node{typecheck.Conv(len, types.Types[types.TINT]), typecheck.Conv(cap, types.Types[types.TINT])}
+	m.Len = typecheck.Conv(len, types.Types[types.TINT])
+	m.Cap = typecheck.Conv(cap, types.Types[types.TINT])
 	return walkExpr(typecheck.Expr(m), init)
 }
 
@@ -471,7 +472,8 @@ func walkMakeSliceCopy(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
 		sh := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
 		sh.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, size, typecheck.NodNil(), ir.NewBool(false))
 		sh.Ptr.MarkNonNil()
-		sh.LenCap = []ir.Node{length, length}
+		sh.Len = length
+		sh.Cap = length
 		sh.SetType(t)
 
 		s := typecheck.Temp(t)
@@ -493,7 +495,8 @@ func walkMakeSliceCopy(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
 	s := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
 	s.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, reflectdata.TypePtr(t.Elem()), length, copylen, typecheck.Conv(copyptr, types.Types[types.TUNSAFEPTR]))
 	s.Ptr.MarkNonNil()
-	s.LenCap = []ir.Node{length, length}
+	s.Len = length
+	s.Cap = length
 	s.SetType(t)
 	return walkExpr(typecheck.Expr(s), init)
 }
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 2029a6aef6..4f57962205 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -817,8 +817,8 @@ func walkSlice(n *ir.SliceExpr, init *ir.Nodes) ir.Node {
 // walkSliceHeader walks an OSLICEHEADER node.
 func walkSliceHeader(n *ir.SliceHeaderExpr, init *ir.Nodes) ir.Node {
 	n.Ptr = walkExpr(n.Ptr, init)
-	n.LenCap[0] = walkExpr(n.LenCap[0], init)
-	n.LenCap[1] = walkExpr(n.LenCap[1], init)
+	n.Len = walkExpr(n.Len, init)
+	n.Cap = walkExpr(n.Cap, init)
 	return n
 }
 
-- 
GitLab


From d1d64e4cea41bf908152e6a9c45980946e7825a2 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 23 Dec 2020 06:06:31 -0800
Subject: [PATCH 0328/2400] [dev.regabi] cmd/compile: split SliceExpr.List into
 separate fields

Passes toolstash -cmp.

Change-Id: I4e31154d04d99f2b80bec6a2c571a2a4a3f2ec99
Reviewed-on: https://go-review.googlesource.com/c/go/+/279959
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/escape/escape.go     |  7 +--
 src/cmd/compile/internal/ir/expr.go           | 63 ++-----------------
 src/cmd/compile/internal/ir/fmt.go            | 13 ++--
 src/cmd/compile/internal/ir/node_gen.go       |  9 ++-
 src/cmd/compile/internal/noder/noder.go       | 11 ++--
 src/cmd/compile/internal/ssagen/ssa.go        | 24 ++++---
 src/cmd/compile/internal/typecheck/expr.go    | 22 +++----
 src/cmd/compile/internal/typecheck/iexport.go |  8 +--
 src/cmd/compile/internal/typecheck/iimport.go |  7 +--
 src/cmd/compile/internal/walk/assign.go       | 12 ++--
 src/cmd/compile/internal/walk/builtin.go      |  8 +--
 src/cmd/compile/internal/walk/complit.go      |  2 +-
 src/cmd/compile/internal/walk/convert.go      |  2 +-
 src/cmd/compile/internal/walk/expr.go         | 24 +++----
 src/cmd/compile/internal/walk/order.go        | 11 +---
 15 files changed, 72 insertions(+), 151 deletions(-)

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index b7cb56b997..338b2e0680 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -559,10 +559,9 @@ func (e *escape) exprSkipInit(k hole, n ir.Node) {
 	case ir.OSLICE, ir.OSLICEARR, ir.OSLICE3, ir.OSLICE3ARR, ir.OSLICESTR:
 		n := n.(*ir.SliceExpr)
 		e.expr(k.note(n, "slice"), n.X)
-		low, high, max := n.SliceBounds()
-		e.discard(low)
-		e.discard(high)
-		e.discard(max)
+		e.discard(n.Low)
+		e.discard(n.High)
+		e.discard(n.Max)
 
 	case ir.OCONV, ir.OCONVNOP:
 		n := n.(*ir.ConvExpr)
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index d862a645d0..4675966090 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -605,11 +605,13 @@ func (*SelectorExpr) CanBeNtype() {}
 type SliceExpr struct {
 	miniExpr
 	X    Node
-	List Nodes // TODO(rsc): Use separate Nodes
+	Low  Node
+	High Node
+	Max  Node
 }
 
-func NewSliceExpr(pos src.XPos, op Op, x Node) *SliceExpr {
-	n := &SliceExpr{X: x}
+func NewSliceExpr(pos src.XPos, op Op, x, low, high, max Node) *SliceExpr {
+	n := &SliceExpr{X: x, Low: low, High: high, Max: max}
 	n.pos = pos
 	n.op = op
 	return n
@@ -624,61 +626,6 @@ func (n *SliceExpr) SetOp(op Op) {
 	}
 }
 
-// SliceBounds returns n's slice bounds: low, high, and max in expr[low:high:max].
-// n must be a slice expression. max is nil if n is a simple slice expression.
-func (n *SliceExpr) SliceBounds() (low, high, max Node) {
-	if len(n.List) == 0 {
-		return nil, nil, nil
-	}
-
-	switch n.Op() {
-	case OSLICE, OSLICEARR, OSLICESTR:
-		s := n.List
-		return s[0], s[1], nil
-	case OSLICE3, OSLICE3ARR:
-		s := n.List
-		return s[0], s[1], s[2]
-	}
-	base.Fatalf("SliceBounds op %v: %v", n.Op(), n)
-	return nil, nil, nil
-}
-
-// SetSliceBounds sets n's slice bounds, where n is a slice expression.
-// n must be a slice expression. If max is non-nil, n must be a full slice expression.
-func (n *SliceExpr) SetSliceBounds(low, high, max Node) {
-	switch n.Op() {
-	case OSLICE, OSLICEARR, OSLICESTR:
-		if max != nil {
-			base.Fatalf("SetSliceBounds %v given three bounds", n.Op())
-		}
-		s := n.List
-		if s == nil {
-			if low == nil && high == nil {
-				return
-			}
-			n.List = []Node{low, high}
-			return
-		}
-		s[0] = low
-		s[1] = high
-		return
-	case OSLICE3, OSLICE3ARR:
-		s := n.List
-		if s == nil {
-			if low == nil && high == nil && max == nil {
-				return
-			}
-			n.List = []Node{low, high, max}
-			return
-		}
-		s[0] = low
-		s[1] = high
-		s[2] = max
-		return
-	}
-	base.Fatalf("SetSliceBounds op %v: %v", n.Op(), n)
-}
-
 // IsSlice3 reports whether o is a slice3 op (OSLICE3, OSLICE3ARR).
 // o must be a slicing op.
 func (o Op) IsSlice3() bool {
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 8cfc38a9ae..b882979aa4 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -782,18 +782,17 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		n := n.(*SliceExpr)
 		exprFmt(n.X, s, nprec)
 		fmt.Fprint(s, "[")
-		low, high, max := n.SliceBounds()
-		if low != nil {
-			fmt.Fprint(s, low)
+		if n.Low != nil {
+			fmt.Fprint(s, n.Low)
 		}
 		fmt.Fprint(s, ":")
-		if high != nil {
-			fmt.Fprint(s, high)
+		if n.High != nil {
+			fmt.Fprint(s, n.High)
 		}
 		if n.Op().IsSlice3() {
 			fmt.Fprint(s, ":")
-			if max != nil {
-				fmt.Fprint(s, max)
+			if n.Max != nil {
+				fmt.Fprint(s, n.Max)
 			}
 		}
 		fmt.Fprint(s, "]")
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index d11e7bf918..23205b61fe 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -838,20 +838,23 @@ func (n *SliceExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *SliceExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
-	c.List = c.List.Copy()
 	return &c
 }
 func (n *SliceExpr) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
 	err = maybeDo(n.X, err, do)
-	err = maybeDoList(n.List, err, do)
+	err = maybeDo(n.Low, err, do)
+	err = maybeDo(n.High, err, do)
+	err = maybeDo(n.Max, err, do)
 	return err
 }
 func (n *SliceExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	n.X = maybeEdit(n.X, edit)
-	editList(n.List, edit)
+	n.Low = maybeEdit(n.Low, edit)
+	n.High = maybeEdit(n.High, edit)
+	n.Max = maybeEdit(n.Max, edit)
 }
 
 func (n *SliceHeaderExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index c73e2d7fc5..4789740bd1 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -682,15 +682,14 @@ func (p *noder) expr(expr syntax.Expr) ir.Node {
 		if expr.Full {
 			op = ir.OSLICE3
 		}
-		n := ir.NewSliceExpr(p.pos(expr), op, p.expr(expr.X))
+		x := p.expr(expr.X)
 		var index [3]ir.Node
-		for i, x := range &expr.Index {
-			if x != nil {
-				index[i] = p.expr(x)
+		for i, n := range &expr.Index {
+			if n != nil {
+				index[i] = p.expr(n)
 			}
 		}
-		n.SetSliceBounds(index[0], index[1], index[2])
-		return n
+		return ir.NewSliceExpr(p.pos(expr), op, x, index[0], index[1], index[2])
 	case *syntax.AssertExpr:
 		return ir.NewTypeAssertExpr(p.pos(expr), p.expr(expr.X), p.typeExpr(expr.Type))
 	case *syntax.Operation:
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 6b2ba5a781..cf683e578d 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -1367,7 +1367,7 @@ func (s *state) stmt(n ir.Node) {
 			// We're assigning a slicing operation back to its source.
 			// Don't write back fields we aren't changing. See issue #14855.
 			rhs := rhs.(*ir.SliceExpr)
-			i, j, k := rhs.SliceBounds()
+			i, j, k := rhs.Low, rhs.High, rhs.Max
 			if i != nil && (i.Op() == ir.OLITERAL && i.Val().Kind() == constant.Int && ir.Int64Val(i) == 0) {
 				// [0:...] is the same as [:...]
 				i = nil
@@ -2852,15 +2852,14 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		n := n.(*ir.SliceExpr)
 		v := s.expr(n.X)
 		var i, j, k *ssa.Value
-		low, high, max := n.SliceBounds()
-		if low != nil {
-			i = s.expr(low)
+		if n.Low != nil {
+			i = s.expr(n.Low)
 		}
-		if high != nil {
-			j = s.expr(high)
+		if n.High != nil {
+			j = s.expr(n.High)
 		}
-		if max != nil {
-			k = s.expr(max)
+		if n.Max != nil {
+			k = s.expr(n.Max)
 		}
 		p, l, c := s.slice(v, i, j, k, n.Bounded())
 		return s.newValue3(ssa.OpSliceMake, n.Type(), p, l, c)
@@ -2869,12 +2868,11 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		n := n.(*ir.SliceExpr)
 		v := s.expr(n.X)
 		var i, j *ssa.Value
-		low, high, _ := n.SliceBounds()
-		if low != nil {
-			i = s.expr(low)
+		if n.Low != nil {
+			i = s.expr(n.Low)
 		}
-		if high != nil {
-			j = s.expr(high)
+		if n.High != nil {
+			j = s.expr(n.High)
 		}
 		p, l, _ := s.slice(v, i, j, nil, n.Bounded())
 		return s.newValue2(ssa.OpStringMake, n.Type(), p, l)
diff --git a/src/cmd/compile/internal/typecheck/expr.go b/src/cmd/compile/internal/typecheck/expr.go
index 00615c506c..6bbb68550e 100644
--- a/src/cmd/compile/internal/typecheck/expr.go
+++ b/src/cmd/compile/internal/typecheck/expr.go
@@ -831,17 +831,11 @@ func tcSPtr(n *ir.UnaryExpr) ir.Node {
 
 // tcSlice typechecks an OSLICE or OSLICE3 node.
 func tcSlice(n *ir.SliceExpr) ir.Node {
-	n.X = Expr(n.X)
-	low, high, max := n.SliceBounds()
+	n.X = DefaultLit(Expr(n.X), nil)
+	n.Low = indexlit(Expr(n.Low))
+	n.High = indexlit(Expr(n.High))
+	n.Max = indexlit(Expr(n.Max))
 	hasmax := n.Op().IsSlice3()
-	low = Expr(low)
-	high = Expr(high)
-	max = Expr(max)
-	n.X = DefaultLit(n.X, nil)
-	low = indexlit(low)
-	high = indexlit(high)
-	max = indexlit(max)
-	n.SetSliceBounds(low, high, max)
 	l := n.X
 	if l.Type() == nil {
 		n.SetType(nil)
@@ -886,19 +880,19 @@ func tcSlice(n *ir.SliceExpr) ir.Node {
 		return n
 	}
 
-	if low != nil && !checksliceindex(l, low, tp) {
+	if n.Low != nil && !checksliceindex(l, n.Low, tp) {
 		n.SetType(nil)
 		return n
 	}
-	if high != nil && !checksliceindex(l, high, tp) {
+	if n.High != nil && !checksliceindex(l, n.High, tp) {
 		n.SetType(nil)
 		return n
 	}
-	if max != nil && !checksliceindex(l, max, tp) {
+	if n.Max != nil && !checksliceindex(l, n.Max, tp) {
 		n.SetType(nil)
 		return n
 	}
-	if !checksliceconst(low, high) || !checksliceconst(low, max) || !checksliceconst(high, max) {
+	if !checksliceconst(n.Low, n.High) || !checksliceconst(n.Low, n.Max) || !checksliceconst(n.High, n.Max) {
 		n.SetType(nil)
 		return n
 	}
diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index 8ac791c036..365e4315bc 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -1370,17 +1370,15 @@ func (w *exportWriter) expr(n ir.Node) {
 		w.op(ir.OSLICE)
 		w.pos(n.Pos())
 		w.expr(n.X)
-		low, high, _ := n.SliceBounds()
-		w.exprsOrNil(low, high)
+		w.exprsOrNil(n.Low, n.High)
 
 	case ir.OSLICE3, ir.OSLICE3ARR:
 		n := n.(*ir.SliceExpr)
 		w.op(ir.OSLICE3)
 		w.pos(n.Pos())
 		w.expr(n.X)
-		low, high, max := n.SliceBounds()
-		w.exprsOrNil(low, high)
-		w.expr(max)
+		w.exprsOrNil(n.Low, n.High)
+		w.expr(n.Max)
 
 	case ir.OCOPY, ir.OCOMPLEX:
 		// treated like other builtin calls (see e.g., OREAL)
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index c4d840d2ac..cc8646977d 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -902,14 +902,13 @@ func (r *importReader) node() ir.Node {
 		return ir.NewIndexExpr(r.pos(), r.expr(), r.expr())
 
 	case ir.OSLICE, ir.OSLICE3:
-		n := ir.NewSliceExpr(r.pos(), op, r.expr())
+		pos, x := r.pos(), r.expr()
 		low, high := r.exprsOrNil()
 		var max ir.Node
-		if n.Op().IsSlice3() {
+		if op.IsSlice3() {
 			max = r.expr()
 		}
-		n.SetSliceBounds(low, high, max)
-		return n
+		return ir.NewSliceExpr(pos, op, x, low, high, max)
 
 	// case OCONV, OCONVIFACE, OCONVNOP, OBYTES2STR, ORUNES2STR, OSTR2BYTES, OSTR2RUNES, ORUNESTR:
 	// 	unreachable - mapped to OCONV case below by exporter
diff --git a/src/cmd/compile/internal/walk/assign.go b/src/cmd/compile/internal/walk/assign.go
index 6b0e2b272c..99c1abd73f 100644
--- a/src/cmd/compile/internal/walk/assign.go
+++ b/src/cmd/compile/internal/walk/assign.go
@@ -700,17 +700,15 @@ func appendSlice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	nodes.Append(nif)
 
 	// s = s[:n]
-	nt := ir.NewSliceExpr(base.Pos, ir.OSLICE, s)
-	nt.SetSliceBounds(nil, nn, nil)
+	nt := ir.NewSliceExpr(base.Pos, ir.OSLICE, s, nil, nn, nil)
 	nt.SetBounded(true)
 	nodes.Append(ir.NewAssignStmt(base.Pos, s, nt))
 
 	var ncopy ir.Node
 	if elemtype.HasPointers() {
 		// copy(s[len(l1):], l2)
-		slice := ir.NewSliceExpr(base.Pos, ir.OSLICE, s)
+		slice := ir.NewSliceExpr(base.Pos, ir.OSLICE, s, ir.NewUnaryExpr(base.Pos, ir.OLEN, l1), nil, nil)
 		slice.SetType(s.Type())
-		slice.SetSliceBounds(ir.NewUnaryExpr(base.Pos, ir.OLEN, l1), nil, nil)
 
 		ir.CurFunc.SetWBPos(n.Pos())
 
@@ -724,9 +722,8 @@ func appendSlice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 		// rely on runtime to instrument:
 		//  copy(s[len(l1):], l2)
 		// l2 can be a slice or string.
-		slice := ir.NewSliceExpr(base.Pos, ir.OSLICE, s)
+		slice := ir.NewSliceExpr(base.Pos, ir.OSLICE, s, ir.NewUnaryExpr(base.Pos, ir.OLEN, l1), nil, nil)
 		slice.SetType(s.Type())
-		slice.SetSliceBounds(ir.NewUnaryExpr(base.Pos, ir.OLEN, l1), nil, nil)
 
 		ptr1, len1 := backingArrayPtrLen(cheapExpr(slice, &nodes))
 		ptr2, len2 := backingArrayPtrLen(l2)
@@ -870,8 +867,7 @@ func extendSlice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	nodes = append(nodes, nif)
 
 	// s = s[:n]
-	nt := ir.NewSliceExpr(base.Pos, ir.OSLICE, s)
-	nt.SetSliceBounds(nil, nn, nil)
+	nt := ir.NewSliceExpr(base.Pos, ir.OSLICE, s, nil, nn, nil)
 	nt.SetBounded(true)
 	nodes = append(nodes, ir.NewAssignStmt(base.Pos, s, nt))
 
diff --git a/src/cmd/compile/internal/walk/builtin.go b/src/cmd/compile/internal/walk/builtin.go
index 63f7925863..fe6045cbbd 100644
--- a/src/cmd/compile/internal/walk/builtin.go
+++ b/src/cmd/compile/internal/walk/builtin.go
@@ -95,8 +95,7 @@ func walkAppend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
 	nn := typecheck.Temp(types.Types[types.TINT])
 	l = append(l, ir.NewAssignStmt(base.Pos, nn, ir.NewUnaryExpr(base.Pos, ir.OLEN, ns))) // n = len(s)
 
-	slice := ir.NewSliceExpr(base.Pos, ir.OSLICE, ns) // ...s[:n+argc]
-	slice.SetSliceBounds(nil, ir.NewBinaryExpr(base.Pos, ir.OADD, nn, na), nil)
+	slice := ir.NewSliceExpr(base.Pos, ir.OSLICE, ns, nil, ir.NewBinaryExpr(base.Pos, ir.OADD, nn, na), nil) // ...s[:n+argc]
 	slice.SetBounded(true)
 	l = append(l, ir.NewAssignStmt(base.Pos, ns, slice)) // s = s[:n+argc]
 
@@ -407,9 +406,8 @@ func walkMakeSlice(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
 
 		t = types.NewArray(t.Elem(), i) // [r]T
 		var_ := typecheck.Temp(t)
-		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, nil)) // zero temp
-		r := ir.NewSliceExpr(base.Pos, ir.OSLICE, var_)             // arr[:l]
-		r.SetSliceBounds(nil, l, nil)
+		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, nil))  // zero temp
+		r := ir.NewSliceExpr(base.Pos, ir.OSLICE, var_, nil, l, nil) // arr[:l]
 		// The conv is necessary in case n.Type is named.
 		return walkExpr(typecheck.Expr(typecheck.Conv(r, n.Type())), init)
 	}
diff --git a/src/cmd/compile/internal/walk/complit.go b/src/cmd/compile/internal/walk/complit.go
index 6fbbee9284..b53fe2e935 100644
--- a/src/cmd/compile/internal/walk/complit.go
+++ b/src/cmd/compile/internal/walk/complit.go
@@ -425,7 +425,7 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 	}
 
 	// make slice out of heap (6)
-	a = ir.NewAssignStmt(base.Pos, var_, ir.NewSliceExpr(base.Pos, ir.OSLICE, vauto))
+	a = ir.NewAssignStmt(base.Pos, var_, ir.NewSliceExpr(base.Pos, ir.OSLICE, vauto, nil, nil, nil))
 
 	a = typecheck.Stmt(a)
 	a = orderStmtInPlace(a, map[string][]*ir.Name{})
diff --git a/src/cmd/compile/internal/walk/convert.go b/src/cmd/compile/internal/walk/convert.go
index 21426c9817..fd954d6113 100644
--- a/src/cmd/compile/internal/walk/convert.go
+++ b/src/cmd/compile/internal/walk/convert.go
@@ -260,7 +260,7 @@ func walkStringToBytes(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 		}
 
 		// Slice the [n]byte to a []byte.
-		slice := ir.NewSliceExpr(n.Pos(), ir.OSLICEARR, p)
+		slice := ir.NewSliceExpr(n.Pos(), ir.OSLICEARR, p, nil, nil, nil)
 		slice.SetType(n.Type())
 		slice.SetTypecheck(1)
 		return walkExpr(slice, init)
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 4f57962205..658a579fda 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -786,21 +786,19 @@ func walkSlice(n *ir.SliceExpr, init *ir.Nodes) ir.Node {
 		n.X = walkExpr(n.X, init)
 	}
 
-	low, high, max := n.SliceBounds()
-	low = walkExpr(low, init)
-	if low != nil && ir.IsZero(low) {
+	n.Low = walkExpr(n.Low, init)
+	if n.Low != nil && ir.IsZero(n.Low) {
 		// Reduce x[0:j] to x[:j] and x[0:j:k] to x[:j:k].
-		low = nil
+		n.Low = nil
 	}
-	high = walkExpr(high, init)
-	max = walkExpr(max, init)
-	n.SetSliceBounds(low, high, max)
+	n.High = walkExpr(n.High, init)
+	n.Max = walkExpr(n.Max, init)
 	if checkSlice {
-		n.X = walkCheckPtrAlignment(n.X.(*ir.ConvExpr), init, max)
+		n.X = walkCheckPtrAlignment(n.X.(*ir.ConvExpr), init, n.Max)
 	}
 
 	if n.Op().IsSlice3() {
-		if max != nil && max.Op() == ir.OCAP && ir.SameSafeExpr(n.X, max.(*ir.UnaryExpr).X) {
+		if n.Max != nil && n.Max.Op() == ir.OCAP && ir.SameSafeExpr(n.X, n.Max.(*ir.UnaryExpr).X) {
 			// Reduce x[i:j:cap(x)] to x[i:j].
 			if n.Op() == ir.OSLICE3 {
 				n.SetOp(ir.OSLICE)
@@ -824,13 +822,11 @@ func walkSliceHeader(n *ir.SliceHeaderExpr, init *ir.Nodes) ir.Node {
 
 // TODO(josharian): combine this with its caller and simplify
 func reduceSlice(n *ir.SliceExpr) ir.Node {
-	low, high, max := n.SliceBounds()
-	if high != nil && high.Op() == ir.OLEN && ir.SameSafeExpr(n.X, high.(*ir.UnaryExpr).X) {
+	if n.High != nil && n.High.Op() == ir.OLEN && ir.SameSafeExpr(n.X, n.High.(*ir.UnaryExpr).X) {
 		// Reduce x[i:len(x)] to x[i:].
-		high = nil
+		n.High = nil
 	}
-	n.SetSliceBounds(low, high, max)
-	if (n.Op() == ir.OSLICE || n.Op() == ir.OSLICESTR) && low == nil && high == nil {
+	if (n.Op() == ir.OSLICE || n.Op() == ir.OSLICESTR) && n.Low == nil && n.High == nil {
 		// Reduce x[:] to x.
 		if base.Debug.Slice > 0 {
 			base.Warn("slice: omit slice operation")
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index 03310a50c6..de6a3807e6 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -1296,14 +1296,9 @@ func (o *orderState) expr1(n, lhs ir.Node) ir.Node {
 	case ir.OSLICE, ir.OSLICEARR, ir.OSLICESTR, ir.OSLICE3, ir.OSLICE3ARR:
 		n := n.(*ir.SliceExpr)
 		n.X = o.expr(n.X, nil)
-		low, high, max := n.SliceBounds()
-		low = o.expr(low, nil)
-		low = o.cheapExpr(low)
-		high = o.expr(high, nil)
-		high = o.cheapExpr(high)
-		max = o.expr(max, nil)
-		max = o.cheapExpr(max)
-		n.SetSliceBounds(low, high, max)
+		n.Low = o.cheapExpr(o.expr(n.Low, nil))
+		n.High = o.cheapExpr(o.expr(n.High, nil))
+		n.Max = o.cheapExpr(o.expr(n.Max, nil))
 		if lhs == nil || lhs.Op() != ir.ONAME && !ir.SameSafeExpr(lhs, n.X) {
 			return o.copyExpr(n)
 		}
-- 
GitLab


From 9eeed291bcfbf6de4d64abd39eb1eb66cdf9fbb2 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Wed, 23 Dec 2020 20:29:28 +0700
Subject: [PATCH 0329/2400] [dev.regabi] cmd/compile: eliminate usage of
 ir.Node in liveness

All function parameters and return values in liveness have explicit
*ir.Name type, so use it directly instead of casting from ir.Node. While
at it, rename "affectedNode" to "affectedVar" to reflect this change.

Passes buildall w/ toolstash -cmp.

Change-Id: Id927e817a92ddb551a029064a2a54e020ca27074
Reviewed-on: https://go-review.googlesource.com/c/go/+/279434
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/liveness/plive.go | 20 +++++++-------------
 1 file changed, 7 insertions(+), 13 deletions(-)

diff --git a/src/cmd/compile/internal/liveness/plive.go b/src/cmd/compile/internal/liveness/plive.go
index 785a3a29de..cf4debb795 100644
--- a/src/cmd/compile/internal/liveness/plive.go
+++ b/src/cmd/compile/internal/liveness/plive.go
@@ -179,11 +179,7 @@ type progeffectscache struct {
 // nor do we care about non-local variables,
 // nor do we care about empty structs (handled by the pointer check),
 // nor do we care about the fake PAUTOHEAP variables.
-func ShouldTrack(nn ir.Node) bool {
-	if nn.Op() != ir.ONAME {
-		return false
-	}
-	n := nn.(*ir.Name)
+func ShouldTrack(n *ir.Name) bool {
 	return (n.Class_ == ir.PAUTO || n.Class_ == ir.PPARAM || n.Class_ == ir.PPARAMOUT) && n.Type().HasPointers()
 }
 
@@ -248,19 +244,17 @@ const (
 // liveness effects v has on that variable.
 // If v does not affect any tracked variables, it returns -1, 0.
 func (lv *liveness) valueEffects(v *ssa.Value) (int32, liveEffect) {
-	n, e := affectedNode(v)
-	if e == 0 || n == nil || n.Op() != ir.ONAME { // cheapest checks first
+	n, e := affectedVar(v)
+	if e == 0 || n == nil { // cheapest checks first
 		return -1, 0
 	}
-
-	nn := n.(*ir.Name)
 	// AllocFrame has dropped unused variables from
 	// lv.fn.Func.Dcl, but they might still be referenced by
 	// OpVarFoo pseudo-ops. Ignore them to prevent "lost track of
 	// variable" ICEs (issue 19632).
 	switch v.Op {
 	case ssa.OpVarDef, ssa.OpVarKill, ssa.OpVarLive, ssa.OpKeepAlive:
-		if !nn.Name().Used() {
+		if !n.Name().Used() {
 			return -1, 0
 		}
 	}
@@ -283,14 +277,14 @@ func (lv *liveness) valueEffects(v *ssa.Value) (int32, liveEffect) {
 		return -1, 0
 	}
 
-	if pos, ok := lv.idx[nn]; ok {
+	if pos, ok := lv.idx[n]; ok {
 		return pos, effect
 	}
 	return -1, 0
 }
 
-// affectedNode returns the *Node affected by v
-func affectedNode(v *ssa.Value) (ir.Node, ssa.SymEffect) {
+// affectedVar returns the *ir.Name node affected by v
+func affectedVar(v *ssa.Value) (*ir.Name, ssa.SymEffect) {
 	// Special cases.
 	switch v.Op {
 	case ssa.OpLoadReg:
-- 
GitLab


From 40818038bf513405bc988678a297a5a6d24f6513 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 23 Dec 2020 06:59:16 -0800
Subject: [PATCH 0330/2400] [dev.regabi] cmd/compile: change CaseStmt.Vars to
 Var

There's only ever one variable implicitly declared by a CaseStmt. It's
only a slice because we previous used Rlist for this.

Passes toolstash -cmp.

Change-Id: Idf747f3ec6dfbbe4e94d60546ba04a81754df3fe
Reviewed-on: https://go-review.googlesource.com/c/go/+/280012
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/escape/escape.go     | 2 +-
 src/cmd/compile/internal/ir/node_gen.go       | 5 ++---
 src/cmd/compile/internal/ir/stmt.go           | 2 +-
 src/cmd/compile/internal/noder/noder.go       | 2 +-
 src/cmd/compile/internal/typecheck/iexport.go | 2 +-
 src/cmd/compile/internal/typecheck/iimport.go | 2 +-
 src/cmd/compile/internal/typecheck/stmt.go    | 6 +++---
 src/cmd/compile/internal/walk/switch.go       | 5 +----
 8 files changed, 11 insertions(+), 15 deletions(-)

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index 338b2e0680..7a52ff3b88 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -373,7 +373,7 @@ func (e *escape) stmt(n ir.Node) {
 		for _, cas := range n.Cases { // cases
 			cas := cas.(*ir.CaseStmt)
 			if typesw && n.Tag.(*ir.TypeSwitchGuard).Tag != nil {
-				cv := cas.Vars[0]
+				cv := cas.Var
 				k := e.dcl(cv) // type switch variables have no ODCL.
 				if cv.Type().HasPointers() {
 					ks = append(ks, k.dotType(cv.Type(), cas, "switch case"))
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index 23205b61fe..7d3488f3fd 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -230,7 +230,6 @@ func (n *CaseStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *CaseStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
-	c.Vars = c.Vars.Copy()
 	c.List = c.List.Copy()
 	c.Body = c.Body.Copy()
 	return &c
@@ -238,7 +237,7 @@ func (n *CaseStmt) copy() Node {
 func (n *CaseStmt) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
-	err = maybeDoList(n.Vars, err, do)
+	err = maybeDo(n.Var, err, do)
 	err = maybeDoList(n.List, err, do)
 	err = maybeDo(n.Comm, err, do)
 	err = maybeDoList(n.Body, err, do)
@@ -246,7 +245,7 @@ func (n *CaseStmt) doChildren(do func(Node) error) error {
 }
 func (n *CaseStmt) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
-	editList(n.Vars, edit)
+	n.Var = maybeEdit(n.Var, edit)
 	editList(n.List, edit)
 	n.Comm = maybeEdit(n.Comm, edit)
 	editList(n.Body, edit)
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index ad6db436a7..c9988eba5c 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -176,7 +176,7 @@ func (n *BranchStmt) Sym() *types.Sym { return n.Label }
 // A CaseStmt is a case statement in a switch or select: case List: Body.
 type CaseStmt struct {
 	miniStmt
-	Vars Nodes // declared variable for this case in type switch
+	Var  Node  // declared variable for this case in type switch
 	List Nodes // list of expressions for switch, early select
 	Comm Node  // communication case (Exprs[0]) after select is type-checked
 	Body Nodes
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 4789740bd1..68a01612dc 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -1217,7 +1217,7 @@ func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *ir.TypeSwitch
 		if tswitch != nil && tswitch.Tag != nil {
 			nn := typecheck.NewName(tswitch.Tag.Sym())
 			typecheck.Declare(nn, typecheck.DeclContext)
-			n.Vars = []ir.Node{nn}
+			n.Var = nn
 			// keep track of the instances for reporting unused
 			nn.Defn = tswitch
 		}
diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index 365e4315bc..4cb943daaf 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -1196,7 +1196,7 @@ func (w *exportWriter) caseList(cases []ir.Node, namedTypeSwitch bool) {
 		w.pos(cas.Pos())
 		w.stmtList(cas.List)
 		if namedTypeSwitch {
-			w.localName(cas.Vars[0].(*ir.Name))
+			w.localName(cas.Var.(*ir.Name))
 		}
 		w.stmtList(cas.Body)
 	}
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index cc8646977d..221229571c 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -780,7 +780,7 @@ func (r *importReader) caseList(switchExpr ir.Node) []ir.Node {
 			// Sym for diagnostics anyway.
 			caseVar := ir.NewNameAt(cas.Pos(), r.ident())
 			Declare(caseVar, DeclContext)
-			cas.Vars = []ir.Node{caseVar}
+			cas.Var = caseVar
 			caseVar.Defn = switchExpr
 		}
 		cas.Body.Set(r.stmtList())
diff --git a/src/cmd/compile/internal/typecheck/stmt.go b/src/cmd/compile/internal/typecheck/stmt.go
index bf3801eea2..133f93e53b 100644
--- a/src/cmd/compile/internal/typecheck/stmt.go
+++ b/src/cmd/compile/internal/typecheck/stmt.go
@@ -694,7 +694,7 @@ func tcSwitchType(n *ir.SwitchStmt) {
 			ts.add(ncase.Pos(), n1.Type())
 		}
 
-		if len(ncase.Vars) != 0 {
+		if ncase.Var != nil {
 			// Assign the clause variable's type.
 			vt := t
 			if len(ls) == 1 {
@@ -707,7 +707,7 @@ func tcSwitchType(n *ir.SwitchStmt) {
 				}
 			}
 
-			nvar := ncase.Vars[0]
+			nvar := ncase.Var
 			nvar.SetType(vt)
 			if vt != nil {
 				nvar = AssignExpr(nvar)
@@ -716,7 +716,7 @@ func tcSwitchType(n *ir.SwitchStmt) {
 				nvar.SetTypecheck(1)
 				nvar.SetWalkdef(1)
 			}
-			ncase.Vars[0] = nvar
+			ncase.Var = nvar
 		}
 
 		Stmts(ncase.Body)
diff --git a/src/cmd/compile/internal/walk/switch.go b/src/cmd/compile/internal/walk/switch.go
index 360086ec79..7829d93373 100644
--- a/src/cmd/compile/internal/walk/switch.go
+++ b/src/cmd/compile/internal/walk/switch.go
@@ -334,10 +334,7 @@ func walkSwitchType(sw *ir.SwitchStmt) {
 	var body ir.Nodes
 	for _, ncase := range sw.Cases {
 		ncase := ncase.(*ir.CaseStmt)
-		var caseVar ir.Node
-		if len(ncase.Vars) != 0 {
-			caseVar = ncase.Vars[0]
-		}
+		caseVar := ncase.Var
 
 		// For single-type cases with an interface type,
 		// we initialize the case variable as part of the type assertion.
-- 
GitLab


From 27b248b307e6db463930231a7820d5335424c04e Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Thu, 24 Dec 2020 13:09:20 +0700
Subject: [PATCH 0331/2400] [dev.regabi] cmd/compile: separate range stmt Vars
 to Key, Value nodes

Passes buildall w/ toolstash -cmp.

Change-Id: I9738fcabc8ebf3afa34d102afadf1b474b50db35
Reviewed-on: https://go-review.googlesource.com/c/go/+/279435
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/escape/escape.go     | 18 ++--
 src/cmd/compile/internal/ir/fmt.go            | 13 ++-
 src/cmd/compile/internal/ir/node_gen.go       |  7 +-
 src/cmd/compile/internal/ir/stmt.go           | 11 +--
 src/cmd/compile/internal/noder/noder.go       |  8 +-
 src/cmd/compile/internal/typecheck/iexport.go |  2 +-
 src/cmd/compile/internal/typecheck/iimport.go |  4 +-
 src/cmd/compile/internal/typecheck/stmt.go    | 91 +++++++------------
 src/cmd/compile/internal/walk/order.go        |  5 +-
 src/cmd/compile/internal/walk/range.go        | 18 +---
 10 files changed, 73 insertions(+), 104 deletions(-)

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index 7a52ff3b88..31d157b165 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -347,21 +347,19 @@ func (e *escape) stmt(n ir.Node) {
 		e.loopDepth--
 
 	case ir.ORANGE:
-		// for List = range Right { Nbody }
+		// for Key, Value = range X { Body }
 		n := n.(*ir.RangeStmt)
 		e.loopDepth++
-		ks := e.addrs(n.Vars)
+		e.addr(n.Key)
+		k := e.addr(n.Value)
 		e.block(n.Body)
 		e.loopDepth--
 
-		// Right is evaluated outside the loop.
-		k := e.discardHole()
-		if len(ks) >= 2 {
-			if n.X.Type().IsArray() {
-				k = ks[1].note(n, "range")
-			} else {
-				k = ks[1].deref(n, "range-deref")
-			}
+		// X is evaluated outside the loop.
+		if n.X.Type().IsArray() {
+			k = k.note(n, "range")
+		} else {
+			k = k.deref(n, "range-deref")
 		}
 		e.expr(e.later(k), n.X)
 
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index b882979aa4..2b73c5ac1b 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -444,12 +444,15 @@ func stmtFmt(n Node, s fmt.State) {
 			break
 		}
 
-		if len(n.Vars) == 0 {
-			fmt.Fprintf(s, "for range %v { %v }", n.X, n.Body)
-			break
+		fmt.Fprint(s, "for")
+		if n.Key != nil {
+			fmt.Fprintf(s, " %v", n.Key)
+			if n.Value != nil {
+				fmt.Fprintf(s, ", %v", n.Value)
+			}
+			fmt.Fprint(s, " =")
 		}
-
-		fmt.Fprintf(s, "for %.v = range %v { %v }", n.Vars, n.X, n.Body)
+		fmt.Fprintf(s, " range %v { %v }", n.X, n.Body)
 
 	case OSELECT:
 		n := n.(*SelectStmt)
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index 7d3488f3fd..ecb39563c4 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -724,22 +724,23 @@ func (n *RangeStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *RangeStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
-	c.Vars = c.Vars.Copy()
 	c.Body = c.Body.Copy()
 	return &c
 }
 func (n *RangeStmt) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
-	err = maybeDoList(n.Vars, err, do)
 	err = maybeDo(n.X, err, do)
+	err = maybeDo(n.Key, err, do)
+	err = maybeDo(n.Value, err, do)
 	err = maybeDoList(n.Body, err, do)
 	return err
 }
 func (n *RangeStmt) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
-	editList(n.Vars, edit)
 	n.X = maybeEdit(n.X, edit)
+	n.Key = maybeEdit(n.Key, edit)
+	n.Value = maybeEdit(n.Value, edit)
 	editList(n.Body, edit)
 }
 
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index c9988eba5c..453153c024 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -290,25 +290,24 @@ func NewLabelStmt(pos src.XPos, label *types.Sym) *LabelStmt {
 
 func (n *LabelStmt) Sym() *types.Sym { return n.Label }
 
-// A RangeStmt is a range loop: for Vars = range X { Stmts }
-// Op can be OFOR or OFORUNTIL (!Cond).
+// A RangeStmt is a range loop: for Key, Value = range X { Body }
 type RangeStmt struct {
 	miniStmt
 	Label    *types.Sym
-	Vars     Nodes // TODO(rsc): Replace with Key, Value Node
 	Def      bool
 	X        Node
+	Key      Node
+	Value    Node
 	Body     Nodes
 	HasBreak bool
 	typ      *types.Type // TODO(rsc): Remove - use X.Type() instead
 	Prealloc *Name
 }
 
-func NewRangeStmt(pos src.XPos, vars []Node, x Node, body []Node) *RangeStmt {
-	n := &RangeStmt{X: x}
+func NewRangeStmt(pos src.XPos, key, value, x Node, body []Node) *RangeStmt {
+	n := &RangeStmt{X: x, Key: key, Value: value}
 	n.pos = pos
 	n.op = ORANGE
-	n.Vars.Set(vars)
 	n.Body.Set(body)
 	return n
 }
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 68a01612dc..ad66b6c850 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -1172,10 +1172,14 @@ func (p *noder) forStmt(stmt *syntax.ForStmt) ir.Node {
 			panic("unexpected RangeClause")
 		}
 
-		n := ir.NewRangeStmt(p.pos(r), nil, p.expr(r.X), nil)
+		n := ir.NewRangeStmt(p.pos(r), nil, nil, p.expr(r.X), nil)
 		if r.Lhs != nil {
 			n.Def = r.Def
-			n.Vars.Set(p.assignList(r.Lhs, n, n.Def))
+			lhs := p.assignList(r.Lhs, n, n.Def)
+			n.Key = lhs[0]
+			if len(lhs) > 1 {
+				n.Value = lhs[1]
+			}
 		}
 		n.Body.Set(p.blockStmt(stmt.Body))
 		p.closeAnotherScope()
diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index 4cb943daaf..449d99266d 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -1143,7 +1143,7 @@ func (w *exportWriter) stmt(n ir.Node) {
 		n := n.(*ir.RangeStmt)
 		w.op(ir.ORANGE)
 		w.pos(n.Pos())
-		w.stmtList(n.Vars)
+		w.exprsOrNil(n.Key, n.Value)
 		w.expr(n.X)
 		w.stmtList(n.Body)
 
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 221229571c..8285c418e9 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -1028,7 +1028,9 @@ func (r *importReader) node() ir.Node {
 		return ir.NewForStmt(pos, init, cond, post, r.stmtList())
 
 	case ir.ORANGE:
-		return ir.NewRangeStmt(r.pos(), r.stmtList(), r.expr(), r.stmtList())
+		pos := r.pos()
+		k, v := r.exprsOrNil()
+		return ir.NewRangeStmt(pos, k, v, r.expr(), r.stmtList())
 
 	case ir.OSELECT:
 		pos := r.pos()
diff --git a/src/cmd/compile/internal/typecheck/stmt.go b/src/cmd/compile/internal/typecheck/stmt.go
index 133f93e53b..dfa224b318 100644
--- a/src/cmd/compile/internal/typecheck/stmt.go
+++ b/src/cmd/compile/internal/typecheck/stmt.go
@@ -19,19 +19,18 @@ func typecheckrangeExpr(n *ir.RangeStmt) {
 		return
 	}
 	// delicate little dance.  see typecheckas2
-	ls := n.Vars
-	for i1, n1 := range ls {
-		if !ir.DeclaredBy(n1, n) {
-			ls[i1] = AssignExpr(ls[i1])
-		}
+	if n.Key != nil && !ir.DeclaredBy(n.Key, n) {
+		n.Key = AssignExpr(n.Key)
+	}
+	if n.Value != nil && !ir.DeclaredBy(n.Value, n) {
+		n.Value = AssignExpr(n.Value)
 	}
-
 	if t.IsPtr() && t.Elem().IsArray() {
 		t = t.Elem()
 	}
 	n.SetType(t)
 
-	var t1, t2 *types.Type
+	var tk, tv *types.Type
 	toomany := false
 	switch t.Kind() {
 	default:
@@ -39,12 +38,12 @@ func typecheckrangeExpr(n *ir.RangeStmt) {
 		return
 
 	case types.TARRAY, types.TSLICE:
-		t1 = types.Types[types.TINT]
-		t2 = t.Elem()
+		tk = types.Types[types.TINT]
+		tv = t.Elem()
 
 	case types.TMAP:
-		t1 = t.Key()
-		t2 = t.Elem()
+		tk = t.Key()
+		tv = t.Elem()
 
 	case types.TCHAN:
 		if !t.ChanDir().CanRecv() {
@@ -52,61 +51,35 @@ func typecheckrangeExpr(n *ir.RangeStmt) {
 			return
 		}
 
-		t1 = t.Elem()
-		t2 = nil
-		if len(n.Vars) == 2 {
+		tk = t.Elem()
+		tv = nil
+		if n.Value != nil {
 			toomany = true
 		}
 
 	case types.TSTRING:
-		t1 = types.Types[types.TINT]
-		t2 = types.RuneType
+		tk = types.Types[types.TINT]
+		tv = types.RuneType
 	}
 
-	if len(n.Vars) > 2 || toomany {
+	if toomany {
 		base.ErrorfAt(n.Pos(), "too many variables in range")
 	}
 
-	var v1, v2 ir.Node
-	if len(n.Vars) != 0 {
-		v1 = n.Vars[0]
-	}
-	if len(n.Vars) > 1 {
-		v2 = n.Vars[1]
-	}
-
-	// this is not only an optimization but also a requirement in the spec.
-	// "if the second iteration variable is the blank identifier, the range
-	// clause is equivalent to the same clause with only the first variable
-	// present."
-	if ir.IsBlank(v2) {
-		if v1 != nil {
-			n.Vars = []ir.Node{v1}
-		}
-		v2 = nil
-	}
-
-	if v1 != nil {
-		if ir.DeclaredBy(v1, n) {
-			v1.SetType(t1)
-		} else if v1.Type() != nil {
-			if op, why := assignop(t1, v1.Type()); op == ir.OXXX {
-				base.ErrorfAt(n.Pos(), "cannot assign type %v to %L in range%s", t1, v1, why)
-			}
-		}
-		checkassign(n, v1)
-	}
-
-	if v2 != nil {
-		if ir.DeclaredBy(v2, n) {
-			v2.SetType(t2)
-		} else if v2.Type() != nil {
-			if op, why := assignop(t2, v2.Type()); op == ir.OXXX {
-				base.ErrorfAt(n.Pos(), "cannot assign type %v to %L in range%s", t2, v2, why)
+	do := func(nn ir.Node, t *types.Type) {
+		if nn != nil {
+			if ir.DeclaredBy(nn, n) {
+				nn.SetType(t)
+			} else if nn.Type() != nil {
+				if op, why := assignop(t, nn.Type()); op == ir.OXXX {
+					base.ErrorfAt(n.Pos(), "cannot assign type %v to %L in range%s", t, nn, why)
+				}
 			}
+			checkassign(n, nn)
 		}
-		checkassign(n, v2)
 	}
+	do(n.Key, tk)
+	do(n.Value, tv)
 }
 
 // type check assignment.
@@ -399,11 +372,11 @@ func tcRange(n *ir.RangeStmt) {
 
 	// second half of dance, the first half being typecheckrangeExpr
 	n.SetTypecheck(1)
-	ls := n.Vars
-	for i1, n1 := range ls {
-		if n1.Typecheck() == 0 {
-			ls[i1] = AssignExpr(ls[i1])
-		}
+	if n.Key != nil && n.Key.Typecheck() == 0 {
+		n.Key = AssignExpr(n.Key)
+	}
+	if n.Value != nil && n.Value.Typecheck() == 0 {
+		n.Value = AssignExpr(n.Value)
 	}
 
 	decldepth++
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index de6a3807e6..1fcebf5194 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -848,7 +848,7 @@ func (o *orderState) stmt(n ir.Node) {
 			base.Fatalf("order.stmt range %v", n.Type())
 
 		case types.TARRAY, types.TSLICE:
-			if len(n.Vars) < 2 || ir.IsBlank(n.Vars[1]) {
+			if n.Value == nil || ir.IsBlank(n.Value) {
 				// for i := range x will only use x once, to compute len(x).
 				// No need to copy it.
 				break
@@ -887,7 +887,8 @@ func (o *orderState) stmt(n ir.Node) {
 			// hiter contains pointers and needs to be zeroed.
 			n.Prealloc = o.newTemp(reflectdata.MapIterType(n.Type()), true)
 		}
-		o.exprListInPlace(n.Vars)
+		n.Key = o.exprInPlace(n.Key)
+		n.Value = o.exprInPlace(n.Value)
 		if orderBody {
 			orderBlock(&n.Body, o.free)
 		}
diff --git a/src/cmd/compile/internal/walk/range.go b/src/cmd/compile/internal/walk/range.go
index 98a3dc23f9..5ecd577f74 100644
--- a/src/cmd/compile/internal/walk/range.go
+++ b/src/cmd/compile/internal/walk/range.go
@@ -61,15 +61,7 @@ func walkRange(nrange *ir.RangeStmt) ir.Node {
 	a := nrange.X
 	lno := ir.SetPos(a)
 
-	var v1, v2 ir.Node
-	l := len(nrange.Vars)
-	if l > 0 {
-		v1 = nrange.Vars[0]
-	}
-
-	if l > 1 {
-		v2 = nrange.Vars[1]
-	}
+	v1, v2 := nrange.Key, nrange.Value
 
 	if ir.IsBlank(v2) {
 		v2 = nil
@@ -343,15 +335,11 @@ func isMapClear(n *ir.RangeStmt) bool {
 		return false
 	}
 
-	if n.Op() != ir.ORANGE || n.Type().Kind() != types.TMAP || len(n.Vars) != 1 {
-		return false
-	}
-
-	k := n.Vars[0]
-	if k == nil || ir.IsBlank(k) {
+	if n.Op() != ir.ORANGE || n.Type().Kind() != types.TMAP || n.Key == nil || n.Value != nil {
 		return false
 	}
 
+	k := n.Key
 	// Require k to be a new variable name.
 	if !ir.DeclaredBy(k, n) {
 		return false
-- 
GitLab


From 082cc8b7d9daf88db8779262aca8ab5692a00dfb Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Thu, 24 Dec 2020 18:16:44 +0700
Subject: [PATCH 0332/2400] [dev.regabi] cmd/compile: change ir.IsAssignable ->
 ir.IsAddressable

ir.IsAssignable does not include map index expression, so it should be
named ir.IsAddressable instead.

[git-generate]

cd src/cmd/compile/internal/ir
rf '
  mv IsAssignable IsAddressable
'

Change-Id: Ief6188e7b784ba9592d7b0cbec33b5f70d78f638
Reviewed-on: https://go-review.googlesource.com/c/go/+/279436
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/expr.go             | 6 +++---
 src/cmd/compile/internal/ssagen/ssa.go          | 2 +-
 src/cmd/compile/internal/typecheck/expr.go      | 2 +-
 src/cmd/compile/internal/typecheck/typecheck.go | 4 ++--
 src/cmd/compile/internal/walk/compare.go        | 2 +-
 src/cmd/compile/internal/walk/convert.go        | 2 +-
 src/cmd/compile/internal/walk/expr.go           | 2 +-
 src/cmd/compile/internal/walk/order.go          | 2 +-
 8 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 4675966090..a79b78fb45 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -776,12 +776,12 @@ func IsZero(n Node) bool {
 }
 
 // lvalue etc
-func IsAssignable(n Node) bool {
+func IsAddressable(n Node) bool {
 	switch n.Op() {
 	case OINDEX:
 		n := n.(*IndexExpr)
 		if n.X.Type() != nil && n.X.Type().IsArray() {
-			return IsAssignable(n.X)
+			return IsAddressable(n.X)
 		}
 		if n.X.Type() != nil && n.X.Type().IsString() {
 			return false
@@ -792,7 +792,7 @@ func IsAssignable(n Node) bool {
 
 	case ODOT:
 		n := n.(*SelectorExpr)
-		return IsAssignable(n.X)
+		return IsAddressable(n.X)
 
 	case ONAME:
 		n := n.(*Name)
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index cf683e578d..69e1696423 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -2736,7 +2736,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		// SSA, then load just the selected field. This
 		// prevents false memory dependencies in race/msan
 		// instrumentation.
-		if ir.IsAssignable(n) && !s.canSSA(n) {
+		if ir.IsAddressable(n) && !s.canSSA(n) {
 			p := s.addr(n)
 			return s.load(n.Type(), p)
 		}
diff --git a/src/cmd/compile/internal/typecheck/expr.go b/src/cmd/compile/internal/typecheck/expr.go
index 6bbb68550e..879ae385c7 100644
--- a/src/cmd/compile/internal/typecheck/expr.go
+++ b/src/cmd/compile/internal/typecheck/expr.go
@@ -842,7 +842,7 @@ func tcSlice(n *ir.SliceExpr) ir.Node {
 		return n
 	}
 	if l.Type().IsArray() {
-		if !ir.IsAssignable(n.X) {
+		if !ir.IsAddressable(n.X) {
 			base.Errorf("invalid operation %v (slice of unaddressable value)", n)
 			n.SetType(nil)
 			return n
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index bf43402d3d..87daee123d 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -1638,7 +1638,7 @@ func nonexported(sym *types.Sym) bool {
 }
 
 func checklvalue(n ir.Node, verb string) {
-	if !ir.IsAssignable(n) {
+	if !ir.IsAddressable(n) {
 		base.Errorf("cannot %s %v", verb, n)
 	}
 }
@@ -1656,7 +1656,7 @@ func checkassign(stmt ir.Node, n ir.Node) {
 		}
 	}
 
-	if ir.IsAssignable(n) {
+	if ir.IsAddressable(n) {
 		return
 	}
 	if n.Op() == ir.OINDEXMAP {
diff --git a/src/cmd/compile/internal/walk/compare.go b/src/cmd/compile/internal/walk/compare.go
index 40b45d4dea..a4ea31bf55 100644
--- a/src/cmd/compile/internal/walk/compare.go
+++ b/src/cmd/compile/internal/walk/compare.go
@@ -155,7 +155,7 @@ func walkCompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 	// Chose not to inline. Call equality function directly.
 	if !inline {
 		// eq algs take pointers; cmpl and cmpr must be addressable
-		if !ir.IsAssignable(cmpl) || !ir.IsAssignable(cmpr) {
+		if !ir.IsAddressable(cmpl) || !ir.IsAddressable(cmpr) {
 			base.Fatalf("arguments of comparison must be lvalues - %v %v", cmpl, cmpr)
 		}
 
diff --git a/src/cmd/compile/internal/walk/convert.go b/src/cmd/compile/internal/walk/convert.go
index fd954d6113..99abf30668 100644
--- a/src/cmd/compile/internal/walk/convert.go
+++ b/src/cmd/compile/internal/walk/convert.go
@@ -178,7 +178,7 @@ func walkConvInterface(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 		// with a non-interface, especially in a switch on interface value
 		// with non-interface cases, is not visible to order.stmt, so we
 		// have to fall back on allocating a temp here.
-		if !ir.IsAssignable(v) {
+		if !ir.IsAddressable(v) {
 			v = copyExpr(v, v.Type(), init)
 		}
 		v = typecheck.NodAddr(v)
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 658a579fda..882e455749 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -429,7 +429,7 @@ func safeExpr(n ir.Node, init *ir.Nodes) ir.Node {
 	}
 
 	// make a copy; must not be used as an lvalue
-	if ir.IsAssignable(n) {
+	if ir.IsAddressable(n) {
 		base.Fatalf("missing lvalue case in safeexpr: %v", n)
 	}
 	return cheapExpr(n, init)
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index 1fcebf5194..ef95dc14c7 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -235,7 +235,7 @@ func (o *orderState) safeExpr(n ir.Node) ir.Node {
 // because we emit explicit VARKILL instructions marking the end of those
 // temporaries' lifetimes.
 func isaddrokay(n ir.Node) bool {
-	return ir.IsAssignable(n) && (n.Op() != ir.ONAME || n.(*ir.Name).Class_ == ir.PEXTERN || ir.IsAutoTmp(n))
+	return ir.IsAddressable(n) && (n.Op() != ir.ONAME || n.(*ir.Name).Class_ == ir.PEXTERN || ir.IsAutoTmp(n))
 }
 
 // addrTemp ensures that n is okay to pass by address to runtime routines.
-- 
GitLab


From 4b1d0fe66f3fcd80febc0e4be2850c06e3469da3 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 24 Dec 2020 15:42:37 -0800
Subject: [PATCH 0333/2400] [dev.regabi] cmd/compile: new devirtualization pkg
 [generated]

The devirtualization code was only in inl.go because it reused some of
the same helper functions as inlining (notably staticValue), but that
code all ended up in package ir instead anyway. Beyond that minor
commonality, it's entirely separate from inlining.

It's definitely on the small side, but consistent with the new
micropass-as-a-package approach we're trying.

[git-generate]
cd src/cmd/compile/internal/inline
rf '
  mv Devirtualize Func
  mv devirtualizeCall Call
  mv Func Call devirtualize.go
  mv devirtualize.go cmd/compile/internal/devirtualize
'

Change-Id: Iff7b9fe486856660a8107d5391c54b7e8d238706
Reviewed-on: https://go-review.googlesource.com/c/go/+/280212
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 .../internal/devirtualize/devirtualize.go     | 101 ++++++++++++++++++
 src/cmd/compile/internal/gc/main.go           |   3 +-
 src/cmd/compile/internal/inline/inl.go        |  67 ------------
 3 files changed, 103 insertions(+), 68 deletions(-)
 create mode 100644 src/cmd/compile/internal/devirtualize/devirtualize.go

diff --git a/src/cmd/compile/internal/devirtualize/devirtualize.go b/src/cmd/compile/internal/devirtualize/devirtualize.go
new file mode 100644
index 0000000000..95b28eff61
--- /dev/null
+++ b/src/cmd/compile/internal/devirtualize/devirtualize.go
@@ -0,0 +1,101 @@
+// Copyright 2011 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.
+//
+// The inlining facility makes 2 passes: first caninl determines which
+// functions are suitable for inlining, and for those that are it
+// saves a copy of the body. Then inlcalls walks each function body to
+// expand calls to inlinable functions.
+//
+// The Debug.l flag controls the aggressiveness. Note that main() swaps level 0 and 1,
+// making 1 the default and -l disable. Additional levels (beyond -l) may be buggy and
+// are not supported.
+//      0: disabled
+//      1: 80-nodes leaf functions, oneliners, panic, lazy typechecking (default)
+//      2: (unassigned)
+//      3: (unassigned)
+//      4: allow non-leaf functions
+//
+// At some point this may get another default and become switch-offable with -N.
+//
+// The -d typcheckinl flag enables early typechecking of all imported bodies,
+// which is useful to flush out bugs.
+//
+// The Debug.m flag enables diagnostic output.  a single -m is useful for verifying
+// which calls get inlined or not, more is for debugging, and may go away at any point.
+
+package devirtualize
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
+	"cmd/compile/internal/types"
+)
+
+// Devirtualize replaces interface method calls within fn with direct
+// concrete-type method calls where applicable.
+func Func(fn *ir.Func) {
+	ir.CurFunc = fn
+	ir.VisitList(fn.Body, func(n ir.Node) {
+		if n.Op() == ir.OCALLINTER {
+			Call(n.(*ir.CallExpr))
+		}
+	})
+}
+
+func Call(call *ir.CallExpr) {
+	sel := call.X.(*ir.SelectorExpr)
+	r := ir.StaticValue(sel.X)
+	if r.Op() != ir.OCONVIFACE {
+		return
+	}
+	recv := r.(*ir.ConvExpr)
+
+	typ := recv.X.Type()
+	if typ.IsInterface() {
+		return
+	}
+
+	dt := ir.NewTypeAssertExpr(sel.Pos(), sel.X, nil)
+	dt.SetType(typ)
+	x := typecheck.Callee(ir.NewSelectorExpr(sel.Pos(), ir.OXDOT, dt, sel.Sel))
+	switch x.Op() {
+	case ir.ODOTMETH:
+		x := x.(*ir.SelectorExpr)
+		if base.Flag.LowerM != 0 {
+			base.WarnfAt(call.Pos(), "devirtualizing %v to %v", sel, typ)
+		}
+		call.SetOp(ir.OCALLMETH)
+		call.X = x
+	case ir.ODOTINTER:
+		// Promoted method from embedded interface-typed field (#42279).
+		x := x.(*ir.SelectorExpr)
+		if base.Flag.LowerM != 0 {
+			base.WarnfAt(call.Pos(), "partially devirtualizing %v to %v", sel, typ)
+		}
+		call.SetOp(ir.OCALLINTER)
+		call.X = x
+	default:
+		// TODO(mdempsky): Turn back into Fatalf after more testing.
+		if base.Flag.LowerM != 0 {
+			base.WarnfAt(call.Pos(), "failed to devirtualize %v (%v)", x, x.Op())
+		}
+		return
+	}
+
+	// Duplicated logic from typecheck for function call return
+	// value types.
+	//
+	// Receiver parameter size may have changed; need to update
+	// call.Type to get correct stack offsets for result
+	// parameters.
+	types.CheckSize(x.Type())
+	switch ft := x.Type(); ft.NumResults() {
+	case 0:
+	case 1:
+		call.SetType(ft.Results().Field(0).Type)
+	default:
+		call.SetType(ft.Results())
+	}
+}
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 8483c87a38..ba3620e676 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -10,6 +10,7 @@ import (
 	"bufio"
 	"bytes"
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/devirtualize"
 	"cmd/compile/internal/dwarfgen"
 	"cmd/compile/internal/escape"
 	"cmd/compile/internal/inline"
@@ -237,7 +238,7 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	// Devirtualize.
 	for _, n := range typecheck.Target.Decls {
 		if n.Op() == ir.ODCLFUNC {
-			inline.Devirtualize(n.(*ir.Func))
+			devirtualize.Func(n.(*ir.Func))
 		}
 	}
 	ir.CurFunc = nil
diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 222e62d0cc..9ffb08048a 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -1203,73 +1203,6 @@ func pruneUnusedAutos(ll []*ir.Name, vis *hairyVisitor) []*ir.Name {
 	return s
 }
 
-// Devirtualize replaces interface method calls within fn with direct
-// concrete-type method calls where applicable.
-func Devirtualize(fn *ir.Func) {
-	ir.CurFunc = fn
-	ir.VisitList(fn.Body, func(n ir.Node) {
-		if n.Op() == ir.OCALLINTER {
-			devirtualizeCall(n.(*ir.CallExpr))
-		}
-	})
-}
-
-func devirtualizeCall(call *ir.CallExpr) {
-	sel := call.X.(*ir.SelectorExpr)
-	r := ir.StaticValue(sel.X)
-	if r.Op() != ir.OCONVIFACE {
-		return
-	}
-	recv := r.(*ir.ConvExpr)
-
-	typ := recv.X.Type()
-	if typ.IsInterface() {
-		return
-	}
-
-	dt := ir.NewTypeAssertExpr(sel.Pos(), sel.X, nil)
-	dt.SetType(typ)
-	x := typecheck.Callee(ir.NewSelectorExpr(sel.Pos(), ir.OXDOT, dt, sel.Sel))
-	switch x.Op() {
-	case ir.ODOTMETH:
-		x := x.(*ir.SelectorExpr)
-		if base.Flag.LowerM != 0 {
-			base.WarnfAt(call.Pos(), "devirtualizing %v to %v", sel, typ)
-		}
-		call.SetOp(ir.OCALLMETH)
-		call.X = x
-	case ir.ODOTINTER:
-		// Promoted method from embedded interface-typed field (#42279).
-		x := x.(*ir.SelectorExpr)
-		if base.Flag.LowerM != 0 {
-			base.WarnfAt(call.Pos(), "partially devirtualizing %v to %v", sel, typ)
-		}
-		call.SetOp(ir.OCALLINTER)
-		call.X = x
-	default:
-		// TODO(mdempsky): Turn back into Fatalf after more testing.
-		if base.Flag.LowerM != 0 {
-			base.WarnfAt(call.Pos(), "failed to devirtualize %v (%v)", x, x.Op())
-		}
-		return
-	}
-
-	// Duplicated logic from typecheck for function call return
-	// value types.
-	//
-	// Receiver parameter size may have changed; need to update
-	// call.Type to get correct stack offsets for result
-	// parameters.
-	types.CheckSize(x.Type())
-	switch ft := x.Type(); ft.NumResults() {
-	case 0:
-	case 1:
-		call.SetType(ft.Results().Field(0).Type)
-	default:
-		call.SetType(ft.Results())
-	}
-}
-
 // numNonClosures returns the number of functions in list which are not closures.
 func numNonClosures(list []*ir.Func) int {
 	count := 0
-- 
GitLab


From 2785c691c2ba63d284bdaf0f3bcdb678c3f16cd0 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 24 Dec 2020 16:03:47 -0800
Subject: [PATCH 0334/2400] [dev.regabi] cmd/compile: cleanup devirtualization
 docs

Change-Id: I8e319f55fad6e9ed857aa020a96f3a89ccaadcea
Reviewed-on: https://go-review.googlesource.com/c/go/+/280213
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 .../internal/devirtualize/devirtualize.go     | 38 ++++++-------------
 1 file changed, 11 insertions(+), 27 deletions(-)

diff --git a/src/cmd/compile/internal/devirtualize/devirtualize.go b/src/cmd/compile/internal/devirtualize/devirtualize.go
index 95b28eff61..60ba208d08 100644
--- a/src/cmd/compile/internal/devirtualize/devirtualize.go
+++ b/src/cmd/compile/internal/devirtualize/devirtualize.go
@@ -1,29 +1,10 @@
-// Copyright 2011 The Go Authors. All rights reserved.
+// Copyright 2020 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.
-//
-// The inlining facility makes 2 passes: first caninl determines which
-// functions are suitable for inlining, and for those that are it
-// saves a copy of the body. Then inlcalls walks each function body to
-// expand calls to inlinable functions.
-//
-// The Debug.l flag controls the aggressiveness. Note that main() swaps level 0 and 1,
-// making 1 the default and -l disable. Additional levels (beyond -l) may be buggy and
-// are not supported.
-//      0: disabled
-//      1: 80-nodes leaf functions, oneliners, panic, lazy typechecking (default)
-//      2: (unassigned)
-//      3: (unassigned)
-//      4: allow non-leaf functions
-//
-// At some point this may get another default and become switch-offable with -N.
-//
-// The -d typcheckinl flag enables early typechecking of all imported bodies,
-// which is useful to flush out bugs.
-//
-// The Debug.m flag enables diagnostic output.  a single -m is useful for verifying
-// which calls get inlined or not, more is for debugging, and may go away at any point.
 
+// Package devirtualize implements a simple "devirtualization"
+// optimization pass, which replaces interface method calls with
+// direct concrete-type method calls where possible.
 package devirtualize
 
 import (
@@ -33,18 +14,21 @@ import (
 	"cmd/compile/internal/types"
 )
 
-// Devirtualize replaces interface method calls within fn with direct
-// concrete-type method calls where applicable.
+// Func devirtualizes calls within fn where possible.
 func Func(fn *ir.Func) {
 	ir.CurFunc = fn
 	ir.VisitList(fn.Body, func(n ir.Node) {
-		if n.Op() == ir.OCALLINTER {
-			Call(n.(*ir.CallExpr))
+		if call, ok := n.(*ir.CallExpr); ok {
+			Call(call)
 		}
 	})
 }
 
+// Call devirtualizes the given call if possible.
 func Call(call *ir.CallExpr) {
+	if call.Op() != ir.OCALLINTER {
+		return
+	}
 	sel := call.X.(*ir.SelectorExpr)
 	r := ir.StaticValue(sel.X)
 	if r.Op() != ir.OCONVIFACE {
-- 
GitLab


From e24d2f3d0513961441904afdf71cafe7808c0be9 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Thu, 24 Dec 2020 18:49:35 +0700
Subject: [PATCH 0335/2400] [dev.regabi] cmd/compile: remove typ from RangeStmt

We can use RangeStmt.X.Type() instead.

Passes buildall w/ toolstash -cmp.

Change-Id: Id63ce9cb046c3b39bcc35453b1602c986794dfe1
Reviewed-on: https://go-review.googlesource.com/c/go/+/279437
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/stmt.go        |  4 ----
 src/cmd/compile/internal/typecheck/stmt.go | 17 ++++++++++-------
 src/cmd/compile/internal/walk/order.go     |  5 +++--
 src/cmd/compile/internal/walk/range.go     | 14 +++++++-------
 4 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index 453153c024..cfda6fd234 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -300,7 +300,6 @@ type RangeStmt struct {
 	Value    Node
 	Body     Nodes
 	HasBreak bool
-	typ      *types.Type // TODO(rsc): Remove - use X.Type() instead
 	Prealloc *Name
 }
 
@@ -312,9 +311,6 @@ func NewRangeStmt(pos src.XPos, key, value, x Node, body []Node) *RangeStmt {
 	return n
 }
 
-func (n *RangeStmt) Type() *types.Type     { return n.typ }
-func (n *RangeStmt) SetType(x *types.Type) { n.typ = x }
-
 // A ReturnStmt is a return statement.
 type ReturnStmt struct {
 	miniStmt
diff --git a/src/cmd/compile/internal/typecheck/stmt.go b/src/cmd/compile/internal/typecheck/stmt.go
index dfa224b318..fe9ef400bb 100644
--- a/src/cmd/compile/internal/typecheck/stmt.go
+++ b/src/cmd/compile/internal/typecheck/stmt.go
@@ -11,13 +11,20 @@ import (
 	"cmd/internal/src"
 )
 
+func RangeExprType(t *types.Type) *types.Type {
+	if t.IsPtr() && t.Elem().IsArray() {
+		return t.Elem()
+	}
+	return t
+}
+
 func typecheckrangeExpr(n *ir.RangeStmt) {
 	n.X = Expr(n.X)
-
-	t := n.X.Type()
-	if t == nil {
+	if n.X.Type() == nil {
 		return
 	}
+
+	t := RangeExprType(n.X.Type())
 	// delicate little dance.  see typecheckas2
 	if n.Key != nil && !ir.DeclaredBy(n.Key, n) {
 		n.Key = AssignExpr(n.Key)
@@ -25,10 +32,6 @@ func typecheckrangeExpr(n *ir.RangeStmt) {
 	if n.Value != nil && !ir.DeclaredBy(n.Value, n) {
 		n.Value = AssignExpr(n.Value)
 	}
-	if t.IsPtr() && t.Elem().IsArray() {
-		t = t.Elem()
-	}
-	n.SetType(t)
 
 	var tk, tv *types.Type
 	toomany := false
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index ef95dc14c7..1e41cfc6aa 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -843,7 +843,8 @@ func (o *orderState) stmt(n ir.Node) {
 		n.X = o.expr(n.X, nil)
 
 		orderBody := true
-		switch n.Type().Kind() {
+		xt := typecheck.RangeExprType(n.X.Type())
+		switch xt.Kind() {
 		default:
 			base.Fatalf("order.stmt range %v", n.Type())
 
@@ -885,7 +886,7 @@ func (o *orderState) stmt(n ir.Node) {
 
 			// n.Prealloc is the temp for the iterator.
 			// hiter contains pointers and needs to be zeroed.
-			n.Prealloc = o.newTemp(reflectdata.MapIterType(n.Type()), true)
+			n.Prealloc = o.newTemp(reflectdata.MapIterType(xt), true)
 		}
 		n.Key = o.exprInPlace(n.Key)
 		n.Value = o.exprInPlace(n.Value)
diff --git a/src/cmd/compile/internal/walk/range.go b/src/cmd/compile/internal/walk/range.go
index 5ecd577f74..49a69e9751 100644
--- a/src/cmd/compile/internal/walk/range.go
+++ b/src/cmd/compile/internal/walk/range.go
@@ -56,9 +56,8 @@ func walkRange(nrange *ir.RangeStmt) ir.Node {
 	//	hb: hidden bool
 	//	a, v1, v2: not hidden aggregate, val 1, 2
 
-	t := nrange.Type()
-
 	a := nrange.X
+	t := typecheck.RangeExprType(a.Type())
 	lno := ir.SetPos(a)
 
 	v1, v2 := nrange.Key, nrange.Value
@@ -113,7 +112,7 @@ func walkRange(nrange *ir.RangeStmt) ir.Node {
 		}
 
 		// for v1, v2 := range ha { body }
-		if cheapComputableIndex(nrange.Type().Elem().Width) {
+		if cheapComputableIndex(t.Elem().Width) {
 			// v1, v2 = hv1, ha[hv1]
 			tmp := ir.NewIndexExpr(base.Pos, ha, hv1)
 			tmp.SetBounded(true)
@@ -142,7 +141,7 @@ func walkRange(nrange *ir.RangeStmt) ir.Node {
 		ifGuard.Cond = ir.NewBinaryExpr(base.Pos, ir.OLT, hv1, hn)
 		nfor.SetOp(ir.OFORUNTIL)
 
-		hp := typecheck.Temp(types.NewPtr(nrange.Type().Elem()))
+		hp := typecheck.Temp(types.NewPtr(t.Elem()))
 		tmp := ir.NewIndexExpr(base.Pos, ha, ir.NewInt(0))
 		tmp.SetBounded(true)
 		init = append(init, ir.NewAssignStmt(base.Pos, hp, typecheck.NodAddr(tmp)))
@@ -335,7 +334,8 @@ func isMapClear(n *ir.RangeStmt) bool {
 		return false
 	}
 
-	if n.Op() != ir.ORANGE || n.Type().Kind() != types.TMAP || n.Key == nil || n.Value != nil {
+	t := n.X.Type()
+	if n.Op() != ir.ORANGE || t.Kind() != types.TMAP || n.Key == nil || n.Value != nil {
 		return false
 	}
 
@@ -360,7 +360,7 @@ func isMapClear(n *ir.RangeStmt) bool {
 	}
 
 	// Keys where equality is not reflexive can not be deleted from maps.
-	if !types.IsReflexive(m.Type().Key()) {
+	if !types.IsReflexive(t.Key()) {
 		return false
 	}
 
@@ -416,7 +416,7 @@ func arrayClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
 		return nil
 	}
 
-	elemsize := loop.Type().Elem().Width
+	elemsize := typecheck.RangeExprType(loop.X.Type()).Elem().Width
 	if elemsize <= 0 || !ir.IsZero(stmt.Y) {
 		return nil
 	}
-- 
GitLab


From 396b6c2e7c5c368c67e71824471d4f2d48f5c128 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 23 Dec 2020 16:14:59 -0800
Subject: [PATCH 0336/2400] [dev.regabi] cmd/compile: cleanup assignment
 typechecking

The assignment type-checking code previously bounced around a lot
between the LHS and RHS sides of the assignment. But there's actually
a very simple, consistent pattern to how to type check assignments:

1. Check the RHS expression.

2. If the LHS expression is an identifier that was declared in this
statement and it doesn't have an explicit type, give it the RHS
expression's default type.

3. Check the LHS expression.

4. Try assigning the RHS expression to the LHS expression, adding
implicit conversions as needed.

This CL implements this algorithm, and refactors tcAssign and
tcAssignList to use a common implementation. It also fixes the error
messages to consistently say just "1 variable" or "1 value", rather
than occasionally "1 variables" or "1 values".

Fixes #43348.

Passes toolstash -cmp.

Change-Id: I749cb8d6ccbc7d22cd7cb0a381f58a39fc2696b5
Reviewed-on: https://go-review.googlesource.com/c/go/+/280112
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/typecheck/stmt.go    | 235 +++++++-----------
 .../compile/internal/typecheck/typecheck.go   |   5 +
 test/fixedbugs/issue27595.go                  |   2 +-
 test/fixedbugs/issue30087.go                  |   6 +-
 test/used.go                                  |   1 +
 5 files changed, 105 insertions(+), 144 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/stmt.go b/src/cmd/compile/internal/typecheck/stmt.go
index fe9ef400bb..7e74b730bc 100644
--- a/src/cmd/compile/internal/typecheck/stmt.go
+++ b/src/cmd/compile/internal/typecheck/stmt.go
@@ -93,47 +93,16 @@ func tcAssign(n *ir.AssignStmt) {
 		defer tracePrint("typecheckas", n)(nil)
 	}
 
-	// delicate little dance.
-	// the definition of n may refer to this assignment
-	// as its definition, in which case it will call typecheckas.
-	// in that case, do not call typecheck back, or it will cycle.
-	// if the variable has a type (ntype) then typechecking
-	// will not look at defn, so it is okay (and desirable,
-	// so that the conversion below happens).
-	n.X = Resolve(n.X)
-
-	if !ir.DeclaredBy(n.X, n) || n.X.Name().Ntype != nil {
+	if n.Y == nil {
 		n.X = AssignExpr(n.X)
+		return
 	}
 
-	// Use ctxMultiOK so we can emit an "N variables but M values" error
-	// to be consistent with typecheckas2 (#26616).
-	n.Y = typecheck(n.Y, ctxExpr|ctxMultiOK)
-	checkassign(n, n.X)
-	if n.Y != nil && n.Y.Type() != nil {
-		if n.Y.Type().IsFuncArgStruct() {
-			base.Errorf("assignment mismatch: 1 variable but %v returns %d values", n.Y.(*ir.CallExpr).X, n.Y.Type().NumFields())
-			// Multi-value RHS isn't actually valid for OAS; nil out
-			// to indicate failed typechecking.
-			n.Y.SetType(nil)
-		} else if n.X.Type() != nil {
-			n.Y = AssignConv(n.Y, n.X.Type(), "assignment")
-		}
-	}
-
-	if ir.DeclaredBy(n.X, n) && n.X.Name().Ntype == nil {
-		n.Y = DefaultLit(n.Y, nil)
-		n.X.SetType(n.Y.Type())
-	}
-
-	// second half of dance.
-	// now that right is done, typecheck the left
-	// just to get it over with.  see dance above.
-	n.SetTypecheck(1)
+	lhs, rhs := []ir.Node{n.X}, []ir.Node{n.Y}
+	assign(n, lhs, rhs)
+	n.X, n.Y = lhs[0], rhs[0]
 
-	if n.X.Typecheck() == 0 {
-		n.X = AssignExpr(n.X)
-	}
+	// TODO(mdempsky): This seems out of place.
 	if !ir.IsBlank(n.X) {
 		types.CheckSize(n.X.Type()) // ensure width is calculated for backend
 	}
@@ -144,132 +113,118 @@ func tcAssignList(n *ir.AssignListStmt) {
 		defer tracePrint("typecheckas2", n)(nil)
 	}
 
-	ls := n.Lhs
-	for i1, n1 := range ls {
-		// delicate little dance.
-		n1 = Resolve(n1)
-		ls[i1] = n1
+	assign(n, n.Lhs, n.Rhs)
+}
+
+func assign(stmt ir.Node, lhs, rhs []ir.Node) {
+	// delicate little dance.
+	// the definition of lhs may refer to this assignment
+	// as its definition, in which case it will call typecheckas.
+	// in that case, do not call typecheck back, or it will cycle.
+	// if the variable has a type (ntype) then typechecking
+	// will not look at defn, so it is okay (and desirable,
+	// so that the conversion below happens).
 
-		if !ir.DeclaredBy(n1, n) || n1.Name().Ntype != nil {
-			ls[i1] = AssignExpr(ls[i1])
+	checkLHS := func(i int, typ *types.Type) {
+		lhs[i] = Resolve(lhs[i])
+		if n := lhs[i]; typ != nil && ir.DeclaredBy(n, stmt) && n.Name().Ntype == nil {
+			if typ.Kind() != types.TNIL {
+				n.SetType(defaultType(typ))
+			} else {
+				base.Errorf("use of untyped nil")
+			}
 		}
+		if lhs[i].Typecheck() == 0 {
+			lhs[i] = AssignExpr(lhs[i])
+		}
+		checkassign(stmt, lhs[i])
 	}
 
-	cl := len(n.Lhs)
-	cr := len(n.Rhs)
-	if cl > 1 && cr == 1 {
-		n.Rhs[0] = typecheck(n.Rhs[0], ctxExpr|ctxMultiOK)
-	} else {
-		Exprs(n.Rhs)
-	}
-	checkassignlist(n, n.Lhs)
-
-	var l ir.Node
-	var r ir.Node
-	if cl == cr {
-		// easy
-		ls := n.Lhs
-		rs := n.Rhs
-		for il, nl := range ls {
-			nr := rs[il]
-			if nl.Type() != nil && nr.Type() != nil {
-				rs[il] = AssignConv(nr, nl.Type(), "assignment")
-			}
-			if ir.DeclaredBy(nl, n) && nl.Name().Ntype == nil {
-				rs[il] = DefaultLit(rs[il], nil)
-				nl.SetType(rs[il].Type())
-			}
+	assignType := func(i int, typ *types.Type) {
+		checkLHS(i, typ)
+		if typ != nil {
+			checkassignto(typ, lhs[i])
 		}
+	}
 
-		goto out
+	cr := len(rhs)
+	if len(rhs) == 1 {
+		rhs[0] = typecheck(rhs[0], ctxExpr|ctxMultiOK)
+		if rtyp := rhs[0].Type(); rtyp != nil && rtyp.IsFuncArgStruct() {
+			cr = rtyp.NumFields()
+		}
+	} else {
+		Exprs(rhs)
 	}
 
-	l = n.Lhs[0]
-	r = n.Rhs[0]
+	// x, ok = y
+assignOK:
+	for len(lhs) == 2 && cr == 1 {
+		stmt := stmt.(*ir.AssignListStmt)
+		r := rhs[0]
 
-	// x,y,z = f()
-	if cr == 1 {
-		if r.Type() == nil {
-			goto out
-		}
 		switch r.Op() {
-		case ir.OCALLMETH, ir.OCALLINTER, ir.OCALLFUNC:
-			if !r.Type().IsFuncArgStruct() {
-				break
-			}
-			cr = r.Type().NumFields()
-			if cr != cl {
-				goto mismatch
-			}
-			r.(*ir.CallExpr).Use = ir.CallUseList
-			n.SetOp(ir.OAS2FUNC)
-			for i, l := range n.Lhs {
-				f := r.Type().Field(i)
-				if f.Type != nil && l.Type() != nil {
-					checkassignto(f.Type, l)
-				}
-				if ir.DeclaredBy(l, n) && l.Name().Ntype == nil {
-					l.SetType(f.Type)
-				}
-			}
-			goto out
+		case ir.OINDEXMAP:
+			stmt.SetOp(ir.OAS2MAPR)
+		case ir.ORECV:
+			stmt.SetOp(ir.OAS2RECV)
+		case ir.ODOTTYPE:
+			r := r.(*ir.TypeAssertExpr)
+			stmt.SetOp(ir.OAS2DOTTYPE)
+			r.SetOp(ir.ODOTTYPE2)
+		default:
+			break assignOK
 		}
+
+		assignType(0, r.Type())
+		assignType(1, types.UntypedBool)
+		return
 	}
 
-	// x, ok = y
-	if cl == 2 && cr == 1 {
-		if r.Type() == nil {
-			goto out
-		}
-		switch r.Op() {
-		case ir.OINDEXMAP, ir.ORECV, ir.ODOTTYPE:
-			switch r.Op() {
-			case ir.OINDEXMAP:
-				n.SetOp(ir.OAS2MAPR)
-			case ir.ORECV:
-				n.SetOp(ir.OAS2RECV)
-			case ir.ODOTTYPE:
-				r := r.(*ir.TypeAssertExpr)
-				n.SetOp(ir.OAS2DOTTYPE)
-				r.SetOp(ir.ODOTTYPE2)
+	if len(lhs) != cr {
+		if r, ok := rhs[0].(*ir.CallExpr); ok && len(rhs) == 1 {
+			if r.Type() != nil {
+				base.ErrorfAt(stmt.Pos(), "assignment mismatch: %d variable%s but %v returns %d value%s", len(lhs), plural(len(lhs)), r.X, cr, plural(cr))
 			}
-			if l.Type() != nil {
-				checkassignto(r.Type(), l)
-			}
-			if ir.DeclaredBy(l, n) {
-				l.SetType(r.Type())
-			}
-			l := n.Lhs[1]
-			if l.Type() != nil && !l.Type().IsBoolean() {
-				checkassignto(types.Types[types.TBOOL], l)
-			}
-			if ir.DeclaredBy(l, n) && l.Name().Ntype == nil {
-				l.SetType(types.Types[types.TBOOL])
-			}
-			goto out
+		} else {
+			base.ErrorfAt(stmt.Pos(), "assignment mismatch: %d variable%s but %v value%s", len(lhs), plural(len(lhs)), len(rhs), plural(len(rhs)))
+		}
+
+		for i := range lhs {
+			checkLHS(i, nil)
 		}
+		return
 	}
 
-mismatch:
-	switch r.Op() {
-	default:
-		base.Errorf("assignment mismatch: %d variables but %d values", cl, cr)
-	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
-		r := r.(*ir.CallExpr)
-		base.Errorf("assignment mismatch: %d variables but %v returns %d values", cl, r.X, cr)
+	// x,y,z = f()
+	if cr > len(rhs) {
+		stmt := stmt.(*ir.AssignListStmt)
+		stmt.SetOp(ir.OAS2FUNC)
+		r := rhs[0].(*ir.CallExpr)
+		r.Use = ir.CallUseList
+		rtyp := r.Type()
+
+		for i := range lhs {
+			assignType(i, rtyp.Field(i).Type)
+		}
+		return
 	}
 
-	// second half of dance
-out:
-	n.SetTypecheck(1)
-	ls = n.Lhs
-	for i1, n1 := range ls {
-		if n1.Typecheck() == 0 {
-			ls[i1] = AssignExpr(ls[i1])
+	for i, r := range rhs {
+		checkLHS(i, r.Type())
+		if lhs[i].Type() != nil {
+			rhs[i] = AssignConv(r, lhs[i].Type(), "assignment")
 		}
 	}
 }
 
+func plural(n int) string {
+	if n == 1 {
+		return ""
+	}
+	return "s"
+}
+
 // tcFor typechecks an OFOR node.
 func tcFor(n *ir.ForStmt) ir.Node {
 	Stmts(n.Init())
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 87daee123d..05a346b8c8 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -1690,6 +1690,11 @@ func checkassignlist(stmt ir.Node, l ir.Nodes) {
 }
 
 func checkassignto(src *types.Type, dst ir.Node) {
+	// TODO(mdempsky): Handle all untyped types correctly.
+	if src == types.UntypedBool && dst.Type().IsBoolean() {
+		return
+	}
+
 	if op, why := assignop(src, dst.Type()); op == ir.OXXX {
 		base.Errorf("cannot assign %v to %L in multiple assignment%s", src, dst, why)
 		return
diff --git a/test/fixedbugs/issue27595.go b/test/fixedbugs/issue27595.go
index af5c7a10d9..b9328a6813 100644
--- a/test/fixedbugs/issue27595.go
+++ b/test/fixedbugs/issue27595.go
@@ -8,7 +8,7 @@ package main
 
 var a = twoResults()       // ERROR "assignment mismatch: 1 variable but twoResults returns 2 values"
 var b, c, d = twoResults() // ERROR "assignment mismatch: 3 variables but twoResults returns 2 values"
-var e, f = oneResult()     // ERROR "assignment mismatch: 2 variables but oneResult returns 1 values"
+var e, f = oneResult()     // ERROR "assignment mismatch: 2 variables but oneResult returns 1 value"
 
 func twoResults() (int, int) {
 	return 1, 2
diff --git a/test/fixedbugs/issue30087.go b/test/fixedbugs/issue30087.go
index 3ad9c8c8d9..a8f6202329 100644
--- a/test/fixedbugs/issue30087.go
+++ b/test/fixedbugs/issue30087.go
@@ -7,8 +7,8 @@
 package main
 
 func main() {
-	var a, b = 1    // ERROR "assignment mismatch: 2 variables but 1 values|wrong number of initializations"
-	_ = 1, 2        // ERROR "assignment mismatch: 1 variables but 2 values|number of variables does not match"
-	c, d := 1       // ERROR "assignment mismatch: 2 variables but 1 values|wrong number of initializations"
+	var a, b = 1    // ERROR "assignment mismatch: 2 variables but 1 value|wrong number of initializations"
+	_ = 1, 2        // ERROR "assignment mismatch: 1 variable but 2 values|number of variables does not match"
+	c, d := 1       // ERROR "assignment mismatch: 2 variables but 1 value|wrong number of initializations"
 	e, f := 1, 2, 3 // ERROR "assignment mismatch: 2 variables but 3 values|wrong number of initializations"
 }
diff --git a/test/used.go b/test/used.go
index 5c7aad24a6..76f3fc91cc 100644
--- a/test/used.go
+++ b/test/used.go
@@ -63,6 +63,7 @@ func _() {
 	_ = f1()               // ok
 	_, _ = f2()            // ok
 	_ = f2()               // ERROR "assignment mismatch: 1 variable but f2 returns 2 values"
+	_ = f1(), 0            // ERROR "assignment mismatch: 1 variable but 2 values"
 	T.M0                   // ERROR "T.M0 evaluated but not used"
 	t.M0                   // ERROR "t.M0 evaluated but not used"
 	cap                    // ERROR "use of builtin cap not in function call"
-- 
GitLab


From 1d9a1f67d537309f80740b16ef619500fb55db16 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 25 Dec 2020 00:12:15 -0800
Subject: [PATCH 0337/2400] [dev.regabi] cmd/compile: don't emit reflect data
 for method types

Within the compiler, we represent the type of methods as a special
"method" type, where the receiver parameter type is kept separate from
the other parameters. This is convenient for operations like testing
whether a type implements an interface, where we want to ignore the
receiver type.

These method types don't properly exist within the Go language though:
there are only "function" types. E.g., method expressions (expressions
of the form Type.Method) are simply functions with the receiver
parameter prepended to the regular parameter list.

However, the compiler backend is currently a little sloppy in its
handling of these types, which results in temporary variables being
declared as having "method" type, which then end up in DWARF
data. This is probably harmless in practice, but it's still wrong.

The proper solution is to fix the backend code so that we use correct
types everywhere, and the next CL does exactly this. But as it fixes
the DWARF output, so it fails toolstash -cmp. So this prelim CL
bandages over the issue in a way that generates the same output as
that proper fix.

Change-Id: I37a127bc8365c3a79ce513bdb3cfccb945912762
Reviewed-on: https://go-review.googlesource.com/c/go/+/280293
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/reflectdata/reflect.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index 3fbf6f337f..27ee09ade2 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -835,6 +835,10 @@ func TypeSym(t *types.Type) *types.Sym {
 	if t == nil || (t.IsPtr() && t.Elem() == nil) || t.IsUntyped() {
 		base.Fatalf("typenamesym %v", t)
 	}
+	if t.Kind() == types.TFUNC && t.Recv() != nil {
+		// TODO(mdempsky): Fix callers and make fatal.
+		t = typecheck.NewMethodType(t, t.Recv().Type)
+	}
 	s := types.TypeSym(t)
 	signatmu.Lock()
 	NeedRuntimeType(t)
-- 
GitLab


From e4f293d85306cb89da3c134ce432e330e289447e Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 25 Dec 2020 00:34:32 -0800
Subject: [PATCH 0338/2400] [dev.regabi] cmd/compile: fix OCALLMETH desugaring

During walkCall, there's a half-hearted attempt at rewriting OCALLMETH
expressions into regular function calls by moving the receiver
argument into n.Args with the rest of the arguments. But the way it
does this leaves the AST in an inconsistent state (an ODOTMETH node
with no X expression), and leaves a lot of duplicate work for the rest
of the backend to deal with.

By simply rewriting OCALLMETH expressions into proper OCALLFUNC
expressions, we eliminate a ton of unnecessary code duplication during
SSA construction and avoid creation of invalid method-typed variables.

Passes toolstash -cmp.

Change-Id: I4d5c5f90a79f8994059b2d0ae472182e08096c0a
Reviewed-on: https://go-review.googlesource.com/c/go/+/280294
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 .../compile/internal/reflectdata/reflect.go   |  3 +-
 src/cmd/compile/internal/ssagen/ssa.go        | 59 +++----------------
 src/cmd/compile/internal/typecheck/dcl.go     |  3 +
 src/cmd/compile/internal/walk/expr.go         | 26 ++++----
 4 files changed, 24 insertions(+), 67 deletions(-)

diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index 27ee09ade2..64cc3e87ca 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -836,8 +836,7 @@ func TypeSym(t *types.Type) *types.Sym {
 		base.Fatalf("typenamesym %v", t)
 	}
 	if t.Kind() == types.TFUNC && t.Recv() != nil {
-		// TODO(mdempsky): Fix callers and make fatal.
-		t = typecheck.NewMethodType(t, t.Recv().Type)
+		base.Fatalf("misuse of method type: %v", t)
 	}
 	s := types.TypeSym(t)
 	signatmu.Lock()
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 69e1696423..25efeee112 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -214,10 +214,7 @@ func InitConfig() {
 func getParam(n *ir.CallExpr, i int) *types.Field {
 	t := n.X.Type()
 	if n.Op() == ir.OCALLMETH {
-		if i == 0 {
-			return t.Recv()
-		}
-		return t.Params().Field(i - 1)
+		base.Fatalf("OCALLMETH missed by walkCall")
 	}
 	return t.Params().Field(i)
 }
@@ -1166,7 +1163,7 @@ func (s *state) stmt(n ir.Node) {
 		}
 		fallthrough
 
-	case ir.OCALLMETH, ir.OCALLINTER:
+	case ir.OCALLINTER:
 		n := n.(*ir.CallExpr)
 		s.callResult(n, callNormal)
 		if n.Op() == ir.OCALLFUNC && n.X.Op() == ir.ONAME && n.X.(*ir.Name).Class_ == ir.PFUNC {
@@ -4396,16 +4393,7 @@ func (s *state) openDeferRecord(n *ir.CallExpr) {
 			opendefer.closure = closure
 		}
 	} else if n.Op() == ir.OCALLMETH {
-		if fn.Op() != ir.ODOTMETH {
-			base.Fatalf("OCALLMETH: n.Left not an ODOTMETH: %v", fn)
-		}
-		fn := fn.(*ir.SelectorExpr)
-		closureVal := s.getMethodClosure(fn)
-		// We must always store the function value in a stack slot for the
-		// runtime panic code to use. But in the defer exit code, we will
-		// call the method directly.
-		closure := s.openDeferSave(nil, fn.Type(), closureVal)
-		opendefer.closureNode = closure.Aux.(*ir.Name)
+		base.Fatalf("OCALLMETH missed by walkCall")
 	} else {
 		if fn.Op() != ir.ODOTINTER {
 			base.Fatalf("OCALLINTER: n.Left not an ODOTINTER: %v", fn.Op())
@@ -4679,18 +4667,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			s.maybeNilCheckClosure(closure, k)
 		}
 	case ir.OCALLMETH:
-		if fn.Op() != ir.ODOTMETH {
-			s.Fatalf("OCALLMETH: n.Left not an ODOTMETH: %v", fn)
-		}
-		fn := fn.(*ir.SelectorExpr)
-		testLateExpansion = k != callDeferStack && ssa.LateCallExpansionEnabledWithin(s.f)
-		if k == callNormal {
-			sym = fn.Sel
-			break
-		}
-		closure = s.getMethodClosure(fn)
-		// Note: receiver is already present in n.Rlist, so we don't
-		// want to set it here.
+		base.Fatalf("OCALLMETH missed by walkCall")
 	case ir.OCALLINTER:
 		if fn.Op() != ir.ODOTINTER {
 			s.Fatalf("OCALLINTER: n.Left not an ODOTINTER: %v", fn.Op())
@@ -4755,9 +4732,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		}
 		// Set receiver (for method calls).
 		if n.Op() == ir.OCALLMETH {
-			f := ft.Recv()
-			s.storeArgWithBase(args[0], f.Type, addr, off+f.Offset)
-			args = args[1:]
+			base.Fatalf("OCALLMETH missed by walkCall")
 		}
 		// Set other args.
 		for _, f := range ft.Params().Fields().Slice() {
@@ -4825,11 +4800,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		t := n.X.Type()
 		args := n.Rargs
 		if n.Op() == ir.OCALLMETH {
-			f := t.Recv()
-			ACArg, arg := s.putArg(args[0], f.Type, argStart+f.Offset, testLateExpansion)
-			ACArgs = append(ACArgs, ACArg)
-			callArgs = append(callArgs, arg)
-			args = args[1:]
+			base.Fatalf("OCALLMETH missed by walkCall")
 		}
 		for i, n := range args {
 			f := t.Params().Field(i)
@@ -4947,22 +4918,6 @@ func (s *state) maybeNilCheckClosure(closure *ssa.Value, k callKind) {
 	}
 }
 
-// getMethodClosure returns a value representing the closure for a method call
-func (s *state) getMethodClosure(fn *ir.SelectorExpr) *ssa.Value {
-	// Make a name n2 for the function.
-	// fn.Sym might be sync.(*Mutex).Unlock.
-	// Make a PFUNC node out of that, then evaluate it.
-	// We get back an SSA value representing &sync.(*Mutex).Unlock·f.
-	// We can then pass that to defer or go.
-	n2 := ir.NewNameAt(fn.Pos(), fn.Sel)
-	n2.Curfn = s.curfn
-	n2.Class_ = ir.PFUNC
-	// n2.Sym already existed, so it's already marked as a function.
-	n2.SetPos(fn.Pos())
-	n2.SetType(types.Types[types.TUINT8]) // fake type for a static closure. Could use runtime.funcval if we had it.
-	return s.expr(n2)
-}
-
 // getClosureAndRcvr returns values for the appropriate closure and receiver of an
 // interface call
 func (s *state) getClosureAndRcvr(fn *ir.SelectorExpr) (*ssa.Value, *ssa.Value) {
@@ -5089,7 +5044,7 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 		}
 		addr := s.addr(n.X)
 		return s.newValue1(ssa.OpCopy, t, addr) // ensure that addr has the right type
-	case ir.OCALLFUNC, ir.OCALLINTER, ir.OCALLMETH:
+	case ir.OCALLFUNC, ir.OCALLINTER:
 		n := n.(*ir.CallExpr)
 		return s.callAddr(n, callNormal)
 	case ir.ODOTTYPE:
diff --git a/src/cmd/compile/internal/typecheck/dcl.go b/src/cmd/compile/internal/typecheck/dcl.go
index db18c17e13..0da0956c3a 100644
--- a/src/cmd/compile/internal/typecheck/dcl.go
+++ b/src/cmd/compile/internal/typecheck/dcl.go
@@ -556,6 +556,9 @@ func TempAt(pos src.XPos, curfn *ir.Func, t *types.Type) *ir.Name {
 	if t == nil {
 		base.Fatalf("tempAt called with nil type")
 	}
+	if t.Kind() == types.TFUNC && t.Recv() != nil {
+		base.Fatalf("misuse of method type: %v", t)
+	}
 
 	s := &types.Sym{
 		Name: autotmpname(len(curfn.Dcl)),
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 882e455749..4eee32cf44 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -535,22 +535,31 @@ func walkCall1(n *ir.CallExpr, init *ir.Nodes) {
 		return // already walked
 	}
 
-	params := n.X.Type().Params()
 	args := n.Args
 
 	n.X = walkExpr(n.X, init)
 	walkExprList(args, init)
 
-	// If this is a method call, add the receiver at the beginning of the args.
+	// If this is a method call t.M(...),
+	// rewrite into a function call T.M(t, ...).
+	// TODO(mdempsky): Do this right after type checking.
 	if n.Op() == ir.OCALLMETH {
 		withRecv := make([]ir.Node, len(args)+1)
 		dot := n.X.(*ir.SelectorExpr)
 		withRecv[0] = dot.X
-		dot.X = nil
 		copy(withRecv[1:], args)
 		args = withRecv
+
+		dot = ir.NewSelectorExpr(dot.Pos(), ir.OXDOT, ir.TypeNode(dot.X.Type()), dot.Selection.Sym)
+		fn := typecheck.Expr(dot).(*ir.MethodExpr).FuncName()
+		fn.Type().Size()
+
+		n.SetOp(ir.OCALLFUNC)
+		n.X = fn
 	}
 
+	params := n.X.Type().Params()
+
 	// For any argument whose evaluation might require a function call,
 	// store that argument into a temporary variable,
 	// to prevent that calls from clobbering arguments already on the stack.
@@ -559,16 +568,7 @@ func walkCall1(n *ir.CallExpr, init *ir.Nodes) {
 	for i, arg := range args {
 		updateHasCall(arg)
 		// Determine param type.
-		var t *types.Type
-		if n.Op() == ir.OCALLMETH {
-			if i == 0 {
-				t = n.X.Type().Recv().Type
-			} else {
-				t = params.Field(i - 1).Type
-			}
-		} else {
-			t = params.Field(i).Type
-		}
+		t := params.Field(i).Type
 		if base.Flag.Cfg.Instrumenting || fncall(arg, t) {
 			// make assignment of fncall to tempAt
 			tmp := typecheck.Temp(t)
-- 
GitLab


From dd40bbc57bc94be17a553964649696120b9fa180 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 23 Dec 2020 15:15:36 -0500
Subject: [PATCH 0339/2400] [dev.typeparams] cmd/compile: re-enable
 internal/types2 test

CL 279531 disabled these because they were causing
trouble with the automation for the big move.
The big move is over. Reenable them.

Change-Id: I2b06f619a114ebcc9b9af73ce0d5b68ebaeaac03
Reviewed-on: https://go-review.googlesource.com/c/go/+/279993
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/types2/api_test.go        | 2 --
 src/cmd/compile/internal/types2/builtins_test.go   | 2 --
 src/cmd/compile/internal/types2/check_test.go      | 2 --
 src/cmd/compile/internal/types2/example_test.go    | 2 --
 src/cmd/compile/internal/types2/exprstring_test.go | 2 --
 src/cmd/compile/internal/types2/hilbert_test.go    | 2 --
 src/cmd/compile/internal/types2/importer_test.go   | 2 --
 src/cmd/compile/internal/types2/issues_test.go     | 2 --
 src/cmd/compile/internal/types2/resolver_test.go   | 2 --
 src/cmd/compile/internal/types2/self_test.go       | 2 --
 src/cmd/compile/internal/types2/sizes_test.go      | 2 --
 src/cmd/compile/internal/types2/stdlib_test.go     | 2 --
 src/cmd/compile/internal/types2/typestring_test.go | 2 --
 13 files changed, 26 deletions(-)

diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go
index bda34fef1d..58d7df2f1d 100644
--- a/src/cmd/compile/internal/types2/api_test.go
+++ b/src/cmd/compile/internal/types2/api_test.go
@@ -1,5 +1,3 @@
-// +build TODO_RSC_REMOVE_THIS
-
 // UNREVIEWED
 // Copyright 2013 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/src/cmd/compile/internal/types2/builtins_test.go b/src/cmd/compile/internal/types2/builtins_test.go
index b988b0d509..9f737bc9bb 100644
--- a/src/cmd/compile/internal/types2/builtins_test.go
+++ b/src/cmd/compile/internal/types2/builtins_test.go
@@ -1,5 +1,3 @@
-// +build TODO_RSC_REMOVE_THIS
-
 // UNREVIEWED
 // Copyright 2013 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/src/cmd/compile/internal/types2/check_test.go b/src/cmd/compile/internal/types2/check_test.go
index 26144441e6..85bf0728c0 100644
--- a/src/cmd/compile/internal/types2/check_test.go
+++ b/src/cmd/compile/internal/types2/check_test.go
@@ -1,5 +1,3 @@
-// +build TODO_RSC_REMOVE_THIS
-
 // UNREVIEWED
 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/src/cmd/compile/internal/types2/example_test.go b/src/cmd/compile/internal/types2/example_test.go
index 9ff3536746..dcdeaca0c0 100644
--- a/src/cmd/compile/internal/types2/example_test.go
+++ b/src/cmd/compile/internal/types2/example_test.go
@@ -1,5 +1,3 @@
-// +build TODO_RSC_REMOVE_THIS
-
 // UNREVIEWED
 // Copyright 2015 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/src/cmd/compile/internal/types2/exprstring_test.go b/src/cmd/compile/internal/types2/exprstring_test.go
index bccaa84f32..efb7c308b7 100644
--- a/src/cmd/compile/internal/types2/exprstring_test.go
+++ b/src/cmd/compile/internal/types2/exprstring_test.go
@@ -1,5 +1,3 @@
-// +build TODO_RSC_REMOVE_THIS
-
 // UNREVIEWED
 // Copyright 2013 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/src/cmd/compile/internal/types2/hilbert_test.go b/src/cmd/compile/internal/types2/hilbert_test.go
index b2b8257487..9f9dad6b64 100644
--- a/src/cmd/compile/internal/types2/hilbert_test.go
+++ b/src/cmd/compile/internal/types2/hilbert_test.go
@@ -1,5 +1,3 @@
-// +build TODO_RSC_REMOVE_THIS
-
 // Copyright 2013 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.
diff --git a/src/cmd/compile/internal/types2/importer_test.go b/src/cmd/compile/internal/types2/importer_test.go
index 0d6c2f1d46..90476c4269 100644
--- a/src/cmd/compile/internal/types2/importer_test.go
+++ b/src/cmd/compile/internal/types2/importer_test.go
@@ -1,5 +1,3 @@
-// +build TODO_RSC_REMOVE_THIS
-
 // UNREVIEWED
 // Copyright 2020 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/src/cmd/compile/internal/types2/issues_test.go b/src/cmd/compile/internal/types2/issues_test.go
index e184200a1a..f33b7c4396 100644
--- a/src/cmd/compile/internal/types2/issues_test.go
+++ b/src/cmd/compile/internal/types2/issues_test.go
@@ -1,5 +1,3 @@
-// +build TODO_RSC_REMOVE_THIS
-
 // UNREVIEWED
 // Copyright 2013 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/src/cmd/compile/internal/types2/resolver_test.go b/src/cmd/compile/internal/types2/resolver_test.go
index e939c677ee..cdfdba6b43 100644
--- a/src/cmd/compile/internal/types2/resolver_test.go
+++ b/src/cmd/compile/internal/types2/resolver_test.go
@@ -1,5 +1,3 @@
-// +build TODO_RSC_REMOVE_THIS
-
 // UNREVIEWED
 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/src/cmd/compile/internal/types2/self_test.go b/src/cmd/compile/internal/types2/self_test.go
index b03dc7f33a..6d7971e50f 100644
--- a/src/cmd/compile/internal/types2/self_test.go
+++ b/src/cmd/compile/internal/types2/self_test.go
@@ -1,5 +1,3 @@
-// +build TODO_RSC_REMOVE_THIS
-
 // UNREVIEWED
 // Copyright 2013 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/src/cmd/compile/internal/types2/sizes_test.go b/src/cmd/compile/internal/types2/sizes_test.go
index f6d37a31ab..b246909d2a 100644
--- a/src/cmd/compile/internal/types2/sizes_test.go
+++ b/src/cmd/compile/internal/types2/sizes_test.go
@@ -1,5 +1,3 @@
-// +build TODO_RSC_REMOVE_THIS
-
 // UNREVIEWED
 // Copyright 2016 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/src/cmd/compile/internal/types2/stdlib_test.go b/src/cmd/compile/internal/types2/stdlib_test.go
index 5ab24df776..ae573a4ec8 100644
--- a/src/cmd/compile/internal/types2/stdlib_test.go
+++ b/src/cmd/compile/internal/types2/stdlib_test.go
@@ -1,5 +1,3 @@
-// +build TODO_RSC_REMOVE_THIS
-
 // UNREVIEWED
 // Copyright 2013 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/src/cmd/compile/internal/types2/typestring_test.go b/src/cmd/compile/internal/types2/typestring_test.go
index b9e593be72..f1f7e34bf8 100644
--- a/src/cmd/compile/internal/types2/typestring_test.go
+++ b/src/cmd/compile/internal/types2/typestring_test.go
@@ -1,5 +1,3 @@
-// +build TODO_RSC_REMOVE_THIS
-
 // UNREVIEWED
 // Copyright 2012 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
-- 
GitLab


From a4f335f42033bc1ef9b948a9bff6f14aa6eb1aa8 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 26 Dec 2020 17:51:16 -0800
Subject: [PATCH 0340/2400] [dev.regabi] cmd/compile: always use a Field for
 ODOTPTR expressions

During walk, we create ODOTPTR expressions to access runtime struct
fields. But rather than using an actual Field for the selection, we
were just directly setting the ODOTPTR's Offset field.

This CL changes walk to create proper struct fields (albeit without
the rest of their enclosing struct type) and use them for creating the
ODOTPTR expressions.

Passes toolstash -cmp.

Change-Id: I08dbac3ed29141587feb0905d15adbcbcc4ca49e
Reviewed-on: https://go-review.googlesource.com/c/go/+/280432
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/walk/switch.go | 36 ++++++++++++++++++-------
 src/cmd/compile/internal/walk/walk.go   | 31 ++++++++++++++++-----
 2 files changed, 52 insertions(+), 15 deletions(-)

diff --git a/src/cmd/compile/internal/walk/switch.go b/src/cmd/compile/internal/walk/switch.go
index 7829d93373..141d2e5e05 100644
--- a/src/cmd/compile/internal/walk/switch.go
+++ b/src/cmd/compile/internal/walk/switch.go
@@ -318,15 +318,7 @@ func walkSwitchType(sw *ir.SwitchStmt) {
 	sw.Compiled.Append(ifNil)
 
 	// Load hash from type or itab.
-	dotHash := ir.NewSelectorExpr(base.Pos, ir.ODOTPTR, itab, nil)
-	dotHash.SetType(types.Types[types.TUINT32])
-	dotHash.SetTypecheck(1)
-	if s.facename.Type().IsEmptyInterface() {
-		dotHash.Offset = int64(2 * types.PtrSize) // offset of hash in runtime._type
-	} else {
-		dotHash.Offset = int64(2 * types.PtrSize) // offset of hash in runtime.itab
-	}
-	dotHash.SetBounded(true) // guaranteed not to fault
+	dotHash := typeHashFieldOf(base.Pos, itab)
 	s.hashname = copyExpr(dotHash, dotHash.Type(), &sw.Compiled)
 
 	br := ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)
@@ -409,6 +401,32 @@ func walkSwitchType(sw *ir.SwitchStmt) {
 	walkStmtList(sw.Compiled)
 }
 
+// typeHashFieldOf returns an expression to select the type hash field
+// from an interface's descriptor word (whether a *runtime._type or
+// *runtime.itab pointer).
+func typeHashFieldOf(pos src.XPos, itab *ir.UnaryExpr) *ir.SelectorExpr {
+	if itab.Op() != ir.OITAB {
+		base.Fatalf("expected OITAB, got %v", itab.Op())
+	}
+	var hashField *types.Field
+	if itab.X.Type().IsEmptyInterface() {
+		// runtime._type's hash field
+		if rtypeHashField == nil {
+			rtypeHashField = runtimeField("hash", int64(2*types.PtrSize), types.Types[types.TUINT32])
+		}
+		hashField = rtypeHashField
+	} else {
+		// runtime.itab's hash field
+		if itabHashField == nil {
+			itabHashField = runtimeField("hash", int64(2*types.PtrSize), types.Types[types.TUINT32])
+		}
+		hashField = itabHashField
+	}
+	return boundedDotPtr(pos, itab, hashField)
+}
+
+var rtypeHashField, itabHashField *types.Field
+
 // A typeSwitch walks a type switch.
 type typeSwitch struct {
 	// Temporary variables (i.e., ONAMEs) used by type switch dispatch logic:
diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index 9dda367b4d..6def35ef24 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -539,12 +539,31 @@ func calcHasCall(n ir.Node) bool {
 
 // itabType loads the _type field from a runtime.itab struct.
 func itabType(itab ir.Node) ir.Node {
-	typ := ir.NewSelectorExpr(base.Pos, ir.ODOTPTR, itab, nil)
-	typ.SetType(types.NewPtr(types.Types[types.TUINT8]))
-	typ.SetTypecheck(1)
-	typ.Offset = int64(types.PtrSize) // offset of _type in runtime.itab
-	typ.SetBounded(true)              // guaranteed not to fault
-	return typ
+	if itabTypeField == nil {
+		// runtime.itab's _type field
+		itabTypeField = runtimeField("_type", int64(types.PtrSize), types.NewPtr(types.Types[types.TUINT8]))
+	}
+	return boundedDotPtr(base.Pos, itab, itabTypeField)
+}
+
+var itabTypeField *types.Field
+
+// boundedDotPtr returns a selector expression representing ptr.field
+// and omits nil-pointer checks for ptr.
+func boundedDotPtr(pos src.XPos, ptr ir.Node, field *types.Field) *ir.SelectorExpr {
+	sel := ir.NewSelectorExpr(pos, ir.ODOTPTR, ptr, field.Sym)
+	sel.Selection = field
+	sel.Offset = field.Offset
+	sel.SetType(field.Type)
+	sel.SetTypecheck(1)
+	sel.SetBounded(true) // guaranteed not to fault
+	return sel
+}
+
+func runtimeField(name string, offset int64, typ *types.Type) *types.Field {
+	f := types.NewField(src.NoXPos, ir.Pkgs.Runtime.Lookup(name), typ)
+	f.Offset = offset
+	return f
 }
 
 // ifaceData loads the data field from an interface.
-- 
GitLab


From 0de8eafd98e7431a46c60dd8ea4d3f3a47691049 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 26 Dec 2020 18:02:33 -0800
Subject: [PATCH 0341/2400] [dev.regabi] cmd/compile: remove
 SelectorExpr.Offset field

Now that the previous CL ensures we always set SelectorExpr.Selection,
we can replace the SelectorExpr.Offset field with a helper method that
simply returns SelectorExpr.Selection.Offset.

Passes toolstash -cmp.

Change-Id: Id0f22b8b1980397b668f6860d27cb197b90ff52a
Reviewed-on: https://go-review.googlesource.com/c/go/+/280433
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/ir/expr.go           |  3 +--
 .../compile/internal/reflectdata/reflect.go   |  2 +-
 src/cmd/compile/internal/ssagen/ssa.go        | 24 ++++++++-----------
 src/cmd/compile/internal/staticinit/sched.go  |  2 +-
 src/cmd/compile/internal/typecheck/const.go   |  2 +-
 .../compile/internal/typecheck/typecheck.go   |  6 ++---
 src/cmd/compile/internal/walk/expr.go         | 13 ++--------
 src/cmd/compile/internal/walk/walk.go         |  1 -
 8 files changed, 18 insertions(+), 35 deletions(-)

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index a79b78fb45..1337d356a1 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -572,14 +572,12 @@ type SelectorExpr struct {
 	miniExpr
 	X         Node
 	Sel       *types.Sym
-	Offset    int64
 	Selection *types.Field
 }
 
 func NewSelectorExpr(pos src.XPos, op Op, x Node, sel *types.Sym) *SelectorExpr {
 	n := &SelectorExpr{X: x, Sel: sel}
 	n.pos = pos
-	n.Offset = types.BADWIDTH
 	n.SetOp(op)
 	return n
 }
@@ -596,6 +594,7 @@ func (n *SelectorExpr) SetOp(op Op) {
 func (n *SelectorExpr) Sym() *types.Sym    { return n.Sel }
 func (n *SelectorExpr) Implicit() bool     { return n.flags&miniExprImplicit != 0 }
 func (n *SelectorExpr) SetImplicit(b bool) { n.flags.set(miniExprImplicit, b) }
+func (n *SelectorExpr) Offset() int64      { return n.Selection.Offset }
 
 // Before type-checking, bytes.Buffer is a SelectorExpr.
 // After type-checking it becomes a Name.
diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index 64cc3e87ca..7c42421896 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -1863,7 +1863,7 @@ func MarkUsedIfaceMethod(n *ir.CallExpr) {
 	r.Sym = tsym
 	// dot.Xoffset is the method index * Widthptr (the offset of code pointer
 	// in itab).
-	midx := dot.Offset / int64(types.PtrSize)
+	midx := dot.Offset() / int64(types.PtrSize)
 	r.Add = InterfaceMethodOffset(ityp, midx)
 	r.Type = objabi.R_USEIFACEMETHOD
 }
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 25efeee112..9cdf902bcb 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -2743,7 +2743,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 	case ir.ODOTPTR:
 		n := n.(*ir.SelectorExpr)
 		p := s.exprPtr(n.X, n.Bounded(), n.Pos())
-		p = s.newValue1I(ssa.OpOffPtr, types.NewPtr(n.Type()), n.Offset, p)
+		p = s.newValue1I(ssa.OpOffPtr, types.NewPtr(n.Type()), n.Offset(), p)
 		return s.load(n.Type(), p)
 
 	case ir.OINDEX:
@@ -4924,7 +4924,7 @@ func (s *state) getClosureAndRcvr(fn *ir.SelectorExpr) (*ssa.Value, *ssa.Value)
 	i := s.expr(fn.X)
 	itab := s.newValue1(ssa.OpITab, types.Types[types.TUINTPTR], i)
 	s.nilCheck(itab)
-	itabidx := fn.Offset + 2*int64(types.PtrSize) + 8 // offset of fun field in runtime.itab
+	itabidx := fn.Offset() + 2*int64(types.PtrSize) + 8 // offset of fun field in runtime.itab
 	closure := s.newValue1I(ssa.OpOffPtr, s.f.Config.Types.UintptrPtr, itabidx, itab)
 	rcvr := s.newValue1(ssa.OpIData, s.f.Config.Types.BytePtr, i)
 	return closure, rcvr
@@ -5028,11 +5028,11 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 	case ir.ODOT:
 		n := n.(*ir.SelectorExpr)
 		p := s.addr(n.X)
-		return s.newValue1I(ssa.OpOffPtr, t, n.Offset, p)
+		return s.newValue1I(ssa.OpOffPtr, t, n.Offset(), p)
 	case ir.ODOTPTR:
 		n := n.(*ir.SelectorExpr)
 		p := s.exprPtr(n.X, n.Bounded(), n.Pos())
-		return s.newValue1I(ssa.OpOffPtr, t, n.Offset, p)
+		return s.newValue1I(ssa.OpOffPtr, t, n.Offset(), p)
 	case ir.OCLOSUREREAD:
 		n := n.(*ir.ClosureReadExpr)
 		return s.newValue1I(ssa.OpOffPtr, t, n.Offset,
@@ -7069,21 +7069,17 @@ func (s *State) UseArgs(n int64) {
 // fieldIdx finds the index of the field referred to by the ODOT node n.
 func fieldIdx(n *ir.SelectorExpr) int {
 	t := n.X.Type()
-	f := n.Sel
 	if !t.IsStruct() {
 		panic("ODOT's LHS is not a struct")
 	}
 
-	var i int
-	for _, t1 := range t.Fields().Slice() {
-		if t1.Sym != f {
-			i++
-			continue
-		}
-		if t1.Offset != n.Offset {
-			panic("field offset doesn't match")
+	for i, f := range t.Fields().Slice() {
+		if f.Sym == n.Sel {
+			if f.Offset != n.Offset() {
+				panic("field offset doesn't match")
+			}
+			return i
 		}
-		return i
 	}
 	panic(fmt.Sprintf("can't find field in expr %v\n", n))
 
diff --git a/src/cmd/compile/internal/staticinit/sched.go b/src/cmd/compile/internal/staticinit/sched.go
index 2a499d6eed..2711f6cec0 100644
--- a/src/cmd/compile/internal/staticinit/sched.go
+++ b/src/cmd/compile/internal/staticinit/sched.go
@@ -469,7 +469,7 @@ func StaticLoc(n ir.Node) (name *ir.Name, offset int64, ok bool) {
 		if name, offset, ok = StaticLoc(n.X); !ok {
 			break
 		}
-		offset += n.Offset
+		offset += n.Offset()
 		return name, offset, true
 
 	case ir.OINDEX:
diff --git a/src/cmd/compile/internal/typecheck/const.go b/src/cmd/compile/internal/typecheck/const.go
index 54d70cb835..e22b284e82 100644
--- a/src/cmd/compile/internal/typecheck/const.go
+++ b/src/cmd/compile/internal/typecheck/const.go
@@ -929,7 +929,7 @@ func evalunsafe(n ir.Node) int64 {
 				fallthrough
 			case ir.ODOT:
 				r := r.(*ir.SelectorExpr)
-				v += r.Offset
+				v += r.Offset()
 				next = r.X
 			default:
 				ir.Dump("unsafenmagic", tsel)
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 05a346b8c8..1d070507fa 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -1232,7 +1232,7 @@ func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 		if f1.Offset == types.BADWIDTH {
 			base.Fatalf("lookdot badwidth %v %p", f1, f1)
 		}
-		n.Offset = f1.Offset
+		n.Selection = f1
 		n.SetType(f1.Type)
 		if t.IsInterface() {
 			if n.X.Type().IsPtr() {
@@ -1243,7 +1243,6 @@ func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 
 			n.SetOp(ir.ODOTINTER)
 		}
-		n.Selection = f1
 		return f1
 	}
 
@@ -1299,10 +1298,9 @@ func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 		}
 
 		n.Sel = ir.MethodSym(n.X.Type(), f2.Sym)
-		n.Offset = f2.Offset
+		n.Selection = f2
 		n.SetType(f2.Type)
 		n.SetOp(ir.ODOTMETH)
-		n.Selection = f2
 
 		return f2
 	}
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 4eee32cf44..f0d9e7c2a1 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -965,22 +965,13 @@ func usefield(n *ir.SelectorExpr) {
 	case ir.ODOT, ir.ODOTPTR:
 		break
 	}
-	if n.Sel == nil {
-		// No field name.  This DOTPTR was built by the compiler for access
-		// to runtime data structures.  Ignore.
-		return
-	}
 
-	t := n.X.Type()
-	if t.IsPtr() {
-		t = t.Elem()
-	}
 	field := n.Selection
 	if field == nil {
 		base.Fatalf("usefield %v %v without paramfld", n.X.Type(), n.Sel)
 	}
-	if field.Sym != n.Sel || field.Offset != n.Offset {
-		base.Fatalf("field inconsistency: %v,%v != %v,%v", field.Sym, field.Offset, n.Sel, n.Offset)
+	if field.Sym != n.Sel {
+		base.Fatalf("field inconsistency: %v != %v", field.Sym, n.Sel)
 	}
 	if !strings.Contains(field.Note, "go:\"track\"") {
 		return
diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index 6def35ef24..c4c3debde4 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -553,7 +553,6 @@ var itabTypeField *types.Field
 func boundedDotPtr(pos src.XPos, ptr ir.Node, field *types.Field) *ir.SelectorExpr {
 	sel := ir.NewSelectorExpr(pos, ir.ODOTPTR, ptr, field.Sym)
 	sel.Selection = field
-	sel.Offset = field.Offset
 	sel.SetType(field.Type)
 	sel.SetTypecheck(1)
 	sel.SetBounded(true) // guaranteed not to fault
-- 
GitLab


From 0f732f8c91aa4550ce1803906a55de51760e3243 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 26 Dec 2020 19:30:12 -0800
Subject: [PATCH 0342/2400] [dev.regabi] cmd/compile: minor walkExpr cleanups

This CL cleans up a few minor points in walkExpr:

1. We don't actually care about computing the type-size of all
expressions that are walked. We care about computing the type-size of
all expressions that are *returned* by walk, as these are the
expressions that will actually be seen by the back end.

2. There's no need to call typecheck.EvalConst anymore. EvalConst used
to be responsible for doing additional constant folding during walk;
but for a while a now, it has done only as much constant folding as is
required during type checking (because doing further constant folding
led to too many issues with Go spec compliance). Instead, more
aggressive constant folding is handled entirely by SSA.

3. The code for detecting string constants and generating their
symbols can be simplified somewhat.

Passes toolstash -cmp.

Change-Id: I464ef5bceb8a97689c8f55435369a3402a5ebc55
Reviewed-on: https://go-review.googlesource.com/c/go/+/280434
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/walk/expr.go | 30 ++++++---------------------
 1 file changed, 6 insertions(+), 24 deletions(-)

diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index f0d9e7c2a1..53bffee181 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -26,15 +26,6 @@ func walkExpr(n ir.Node, init *ir.Nodes) ir.Node {
 		return n
 	}
 
-	// Eagerly checkwidth all expressions for the back end.
-	if n.Type() != nil && !n.Type().WidthCalculated() {
-		switch n.Type().Kind() {
-		case types.TBLANK, types.TNIL, types.TIDEAL:
-		default:
-			types.CheckSize(n.Type())
-		}
-	}
-
 	if init == n.PtrInit() {
 		// not okay to use n->ninit when walking n,
 		// because we might replace n with some other node
@@ -70,23 +61,14 @@ func walkExpr(n ir.Node, init *ir.Nodes) ir.Node {
 
 	n = walkExpr1(n, init)
 
-	// Expressions that are constant at run time but not
-	// considered const by the language spec are not turned into
-	// constants until walk. For example, if n is y%1 == 0, the
-	// walk of y%1 may have replaced it by 0.
-	// Check whether n with its updated args is itself now a constant.
-	t := n.Type()
-	n = typecheck.EvalConst(n)
-	if n.Type() != t {
-		base.Fatalf("evconst changed Type: %v had type %v, now %v", n, t, n.Type())
-	}
-	if n.Op() == ir.OLITERAL {
-		n = typecheck.Expr(n)
+	// Eagerly compute sizes of all expressions for the back end.
+	if typ := n.Type(); typ != nil && typ.Kind() != types.TBLANK && !typ.IsFuncArgStruct() {
+		types.CheckSize(typ)
+	}
+	if ir.IsConst(n, constant.String) {
 		// Emit string symbol now to avoid emitting
 		// any concurrently during the backend.
-		if v := n.Val(); v.Kind() == constant.String {
-			_ = staticdata.StringSym(n.Pos(), constant.StringVal(v))
-		}
+		_ = staticdata.StringSym(n.Pos(), constant.StringVal(n.Val()))
 	}
 
 	updateHasCall(n)
-- 
GitLab


From 135ce1c485d0563d285f47a748a6d56594571a91 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 26 Dec 2020 18:33:27 -0800
Subject: [PATCH 0343/2400] [dev.regabi] cmd/compile: desugar OMETHEXPR into
 ONAME during walk

A subsequent CL will change FuncName to lazily create the ONAME nodes,
which isn't currently safe to do during SSA construction, because that
phase is concurrent.

Passes toolstash -cmp.

Change-Id: Ic24acc1d1160ad93b70ced3baa468f750e689ea6
Reviewed-on: https://go-review.googlesource.com/c/go/+/280435
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/ssagen/ssa.go |  4 ----
 src/cmd/compile/internal/walk/expr.go  | 26 ++++++++++++++------------
 2 files changed, 14 insertions(+), 16 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 9cdf902bcb..082cb7c321 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -2108,10 +2108,6 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		n := n.(*ir.UnaryExpr)
 		aux := n.X.Sym().Linksym()
 		return s.entryNewValue1A(ssa.OpAddr, n.Type(), aux, s.sb)
-	case ir.OMETHEXPR:
-		n := n.(*ir.MethodExpr)
-		sym := staticdata.FuncSym(n.FuncName().Sym()).Linksym()
-		return s.entryNewValue1A(ssa.OpAddr, types.NewPtr(n.Type()), sym, s.sb)
 	case ir.ONAME:
 		n := n.(*ir.Name)
 		if n.Class_ == ir.PFUNC {
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 53bffee181..fd0dd5b062 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -88,7 +88,7 @@ func walkExpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		base.Fatalf("walkexpr: switch 1 unknown op %+v", n.Op())
 		panic("unreachable")
 
-	case ir.ONONAME, ir.OGETG, ir.ONEWOBJ, ir.OMETHEXPR:
+	case ir.ONONAME, ir.OGETG, ir.ONEWOBJ:
 		return n
 
 	case ir.OTYPE, ir.ONAME, ir.OLITERAL, ir.ONIL, ir.ONAMEOFFSET:
@@ -98,6 +98,11 @@ func walkExpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		// stringsym for constant strings.
 		return n
 
+	case ir.OMETHEXPR:
+		// TODO(mdempsky): Do this right after type checking.
+		n := n.(*ir.MethodExpr)
+		return n.FuncName()
+
 	case ir.ONOT, ir.ONEG, ir.OPLUS, ir.OBITNOT, ir.OREAL, ir.OIMAG, ir.OSPTR, ir.OITAB, ir.OIDATA:
 		n := n.(*ir.UnaryExpr)
 		n.X = walkExpr(n.X, init)
@@ -517,31 +522,28 @@ func walkCall1(n *ir.CallExpr, init *ir.Nodes) {
 		return // already walked
 	}
 
-	args := n.Args
-
-	n.X = walkExpr(n.X, init)
-	walkExprList(args, init)
-
 	// If this is a method call t.M(...),
 	// rewrite into a function call T.M(t, ...).
 	// TODO(mdempsky): Do this right after type checking.
 	if n.Op() == ir.OCALLMETH {
-		withRecv := make([]ir.Node, len(args)+1)
+		withRecv := make([]ir.Node, len(n.Args)+1)
 		dot := n.X.(*ir.SelectorExpr)
 		withRecv[0] = dot.X
-		copy(withRecv[1:], args)
-		args = withRecv
+		copy(withRecv[1:], n.Args)
+		n.Args = withRecv
 
 		dot = ir.NewSelectorExpr(dot.Pos(), ir.OXDOT, ir.TypeNode(dot.X.Type()), dot.Selection.Sym)
-		fn := typecheck.Expr(dot).(*ir.MethodExpr).FuncName()
-		fn.Type().Size()
 
 		n.SetOp(ir.OCALLFUNC)
-		n.X = fn
+		n.X = typecheck.Expr(dot)
 	}
 
+	args := n.Args
 	params := n.X.Type().Params()
 
+	n.X = walkExpr(n.X, init)
+	walkExprList(args, init)
+
 	// For any argument whose evaluation might require a function call,
 	// store that argument into a temporary variable,
 	// to prevent that calls from clobbering arguments already on the stack.
-- 
GitLab


From e6c973198d9f8e68e4dce8637e2d1492032ce939 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 26 Dec 2020 18:56:36 -0800
Subject: [PATCH 0344/2400] [dev.regabi] cmd/compile: stop mangling
 SelectorExpr.Sel for ODOTMETH

ODOTMETH is unique among SelectorExpr expressions, in that Sel gets
mangled so that it no longer has the original identifier that was
selected (e.g., just "Foo"), but instead the qualified symbol name for
the selected method (e.g., "pkg.Type.Foo"). This is rarely useful, and
instead results in a lot of compiler code needing to worry about
undoing this change.

This CL changes ODOTMETH to leave the original symbol in place. The
handful of code locations where the mangled symbol name is actually
wanted are updated to use ir.MethodExprName(n).Sym() or (equivalently)
ir.MethodExprName(n).Func.Sym() instead.

Historically, the compiler backend has mistakenly used types.Syms
where it should have used ir.Name/ir.Funcs. And this change in
particular may risk breaking something, as the SelectorExpr.Sel will
no longer point at a symbol that uniquely identifies the called
method. However, I expect CL 280294 (desugar OCALLMETH into OCALLFUNC)
to have substantially reduced this risk, as ODOTMETH expressions are
now replaced entirely earlier in the compiler.

Passes toolstash -cmp.

Change-Id: If3c9c3b7df78ea969f135840574cf89e1d263876
Reviewed-on: https://go-review.googlesource.com/c/go/+/280436
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/inline/inl.go        | 24 +++++++--------
 src/cmd/compile/internal/ir/fmt.go            |  4 +--
 src/cmd/compile/internal/typecheck/expr.go    |  8 ++---
 src/cmd/compile/internal/typecheck/func.go    | 29 +++++--------------
 src/cmd/compile/internal/typecheck/iexport.go | 22 +++++---------
 .../compile/internal/typecheck/typecheck.go   |  1 -
 src/cmd/compile/internal/types/fmt.go         | 14 +++------
 test/fixedbugs/issue31053.dir/main.go         |  6 ++--
 8 files changed, 38 insertions(+), 70 deletions(-)

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 9ffb08048a..67162771e9 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -324,19 +324,17 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 		if t == nil {
 			base.Fatalf("no function type for [%p] %+v\n", n.X, n.X)
 		}
-		if types.IsRuntimePkg(n.X.Sym().Pkg) {
-			fn := n.X.Sym().Name
-			if fn == "heapBits.nextArena" {
-				// Special case: explicitly allow
-				// mid-stack inlining of
-				// runtime.heapBits.next even though
-				// it calls slow-path
-				// runtime.heapBits.nextArena.
-				break
-			}
+		fn := ir.MethodExprName(n.X).Func
+		if types.IsRuntimePkg(fn.Sym().Pkg) && fn.Sym().Name == "heapBits.nextArena" {
+			// Special case: explicitly allow
+			// mid-stack inlining of
+			// runtime.heapBits.next even though
+			// it calls slow-path
+			// runtime.heapBits.nextArena.
+			break
 		}
-		if inlfn := ir.MethodExprName(n.X).Func; inlfn.Inl != nil {
-			v.budget -= inlfn.Inl.Cost
+		if fn.Inl != nil {
+			v.budget -= fn.Inl.Cost
 			break
 		}
 		// Call cost for non-leaf inlining.
@@ -531,7 +529,7 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.No
 		// Prevent inlining some reflect.Value methods when using checkptr,
 		// even when package reflect was compiled without it (#35073).
 		n := n.(*ir.CallExpr)
-		if s := n.X.Sym(); base.Debug.Checkptr != 0 && types.IsReflectPkg(s.Pkg) && (s.Name == "Value.UnsafeAddr" || s.Name == "Value.Pointer") {
+		if s := ir.MethodExprName(n.X).Sym(); base.Debug.Checkptr != 0 && types.IsReflectPkg(s.Pkg) && (s.Name == "Value.UnsafeAddr" || s.Name == "Value.Pointer") {
 			return n
 		}
 	}
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 2b73c5ac1b..f52c639c51 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -756,7 +756,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 			fmt.Fprint(s, ".<nil>")
 			return
 		}
-		fmt.Fprintf(s, ".%s", types.SymMethodName(n.Method.Sym))
+		fmt.Fprintf(s, ".%s", n.Method.Sym.Name)
 
 	case OXDOT, ODOT, ODOTPTR, ODOTINTER, ODOTMETH:
 		n := n.(*SelectorExpr)
@@ -765,7 +765,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 			fmt.Fprint(s, ".<nil>")
 			return
 		}
-		fmt.Fprintf(s, ".%s", types.SymMethodName(n.Sel))
+		fmt.Fprintf(s, ".%s", n.Sel.Name)
 
 	case ODOTTYPE, ODOTTYPE2:
 		n := n.(*TypeAssertExpr)
diff --git a/src/cmd/compile/internal/typecheck/expr.go b/src/cmd/compile/internal/typecheck/expr.go
index 879ae385c7..3e7a880c2a 100644
--- a/src/cmd/compile/internal/typecheck/expr.go
+++ b/src/cmd/compile/internal/typecheck/expr.go
@@ -571,7 +571,6 @@ func tcDot(n *ir.SelectorExpr, top int) ir.Node {
 	}
 
 	n.X = typecheck(n.X, ctxExpr|ctxType)
-
 	n.X = DefaultLit(n.X, nil)
 
 	t := n.X.Type()
@@ -581,8 +580,6 @@ func tcDot(n *ir.SelectorExpr, top int) ir.Node {
 		return n
 	}
 
-	s := n.Sel
-
 	if n.X.Op() == ir.OTYPE {
 		return typecheckMethodExpr(n)
 	}
@@ -629,7 +626,10 @@ func tcDot(n *ir.SelectorExpr, top int) ir.Node {
 	}
 
 	if (n.Op() == ir.ODOTINTER || n.Op() == ir.ODOTMETH) && top&ctxCallee == 0 {
-		return tcCallPart(n, s)
+		// Create top-level function.
+		fn := makepartialcall(n)
+
+		return ir.NewCallPartExpr(n.Pos(), n.X, n.Selection, fn)
 	}
 	return n
 }
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index fdac719ad9..50f514a6db 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -249,7 +249,9 @@ var globClosgen int32
 
 // makepartialcall returns a DCLFUNC node representing the wrapper function (*-fm) needed
 // for partial calls.
-func makepartialcall(dot *ir.SelectorExpr, t0 *types.Type, meth *types.Sym) *ir.Func {
+func makepartialcall(dot *ir.SelectorExpr) *ir.Func {
+	t0 := dot.Type()
+	meth := dot.Sel
 	rcvrtype := dot.X.Type()
 	sym := ir.MethodSymSuffix(rcvrtype, meth, "-fm")
 
@@ -263,11 +265,10 @@ func makepartialcall(dot *ir.SelectorExpr, t0 *types.Type, meth *types.Sym) *ir.
 	ir.CurFunc = nil
 
 	// Set line number equal to the line number where the method is declared.
-	var m *types.Field
-	if lookdot0(meth, rcvrtype, &m, false) == 1 && m.Pos.IsKnown() {
-		base.Pos = m.Pos
+	if pos := dot.Selection.Pos; pos.IsKnown() {
+		base.Pos = pos
 	}
-	// Note: !m.Pos.IsKnown() happens for method expressions where
+	// Note: !dot.Selection.Pos.IsKnown() happens for method expressions where
 	// the method is implicitly declared. The Error method of the
 	// built-in error type is one such method.  We leave the line
 	// number at the use of the method expression in this
@@ -280,6 +281,7 @@ func makepartialcall(dot *ir.SelectorExpr, t0 *types.Type, meth *types.Sym) *ir.
 	fn := DeclFunc(sym, tfn)
 	fn.SetDupok(true)
 	fn.SetNeedctxt(true)
+	fn.SetWrapper(true)
 
 	// Declare and initialize variable holding receiver.
 	cr := ir.NewClosureRead(rcvrtype, types.Rnd(int64(types.PtrSize), int64(rcvrtype.Align)))
@@ -382,23 +384,6 @@ func tcClosure(clo *ir.ClosureExpr, top int) {
 	Target.Decls = append(Target.Decls, fn)
 }
 
-func tcCallPart(n ir.Node, sym *types.Sym) *ir.CallPartExpr {
-	switch n.Op() {
-	case ir.ODOTINTER, ir.ODOTMETH:
-		break
-
-	default:
-		base.Fatalf("invalid typecheckpartialcall")
-	}
-	dot := n.(*ir.SelectorExpr)
-
-	// Create top-level function.
-	fn := makepartialcall(dot, dot.Type(), sym)
-	fn.SetWrapper(true)
-
-	return ir.NewCallPartExpr(dot.Pos(), dot.X, dot.Selection, fn)
-}
-
 // type check function definition
 // To be called by typecheck, not directly.
 // (Call typecheckFunc instead.)
diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index 449d99266d..0c813a71ef 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -594,23 +594,15 @@ func (w *exportWriter) selector(s *types.Sym) {
 		base.Fatalf("missing currPkg")
 	}
 
-	// Method selectors are rewritten into method symbols (of the
-	// form T.M) during typechecking, but we want to write out
-	// just the bare method name.
-	name := s.Name
-	if i := strings.LastIndex(name, "."); i >= 0 {
-		name = name[i+1:]
-	} else {
-		pkg := w.currPkg
-		if types.IsExported(name) {
-			pkg = types.LocalPkg
-		}
-		if s.Pkg != pkg {
-			base.Fatalf("package mismatch in selector: %v in package %q, but want %q", s, s.Pkg.Path, pkg.Path)
-		}
+	pkg := w.currPkg
+	if types.IsExported(s.Name) {
+		pkg = types.LocalPkg
+	}
+	if s.Pkg != pkg {
+		base.Fatalf("package mismatch in selector: %v in package %q, but want %q", s, s.Pkg.Path, pkg.Path)
 	}
 
-	w.string(name)
+	w.string(s.Name)
 }
 
 func (w *exportWriter) typ(t *types.Type) {
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 1d070507fa..b779f9ceb0 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -1297,7 +1297,6 @@ func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 			return nil
 		}
 
-		n.Sel = ir.MethodSym(n.X.Type(), f2.Sym)
 		n.Selection = f2
 		n.SetType(f2.Type)
 		n.SetOp(ir.ODOTMETH)
diff --git a/src/cmd/compile/internal/types/fmt.go b/src/cmd/compile/internal/types/fmt.go
index bf37f01922..cd0679f6b9 100644
--- a/src/cmd/compile/internal/types/fmt.go
+++ b/src/cmd/compile/internal/types/fmt.go
@@ -180,15 +180,6 @@ func symfmt(b *bytes.Buffer, s *Sym, verb rune, mode fmtMode) {
 	b.WriteString(s.Name)
 }
 
-func SymMethodName(s *Sym) string {
-	// Skip leading "type." in method name
-	name := s.Name
-	if i := strings.LastIndex(name, "."); i >= 0 {
-		name = name[i+1:]
-	}
-	return name
-}
-
 // Type
 
 var BasicTypeNames = []string{
@@ -595,7 +586,10 @@ func fldconv(b *bytes.Buffer, f *Field, verb rune, mode fmtMode, visited map[*Ty
 			if funarg != FunargNone {
 				name = fmt.Sprint(f.Nname)
 			} else if verb == 'L' {
-				name = SymMethodName(s)
+				name = s.Name
+				if name == ".F" {
+					name = "F" // Hack for toolstash -cmp.
+				}
 				if !IsExported(name) && mode != fmtTypeIDName {
 					name = sconv(s, 0, mode) // qualify non-exported names (used on structs, not on funarg)
 				}
diff --git a/test/fixedbugs/issue31053.dir/main.go b/test/fixedbugs/issue31053.dir/main.go
index 895c262164..3bc75d17d2 100644
--- a/test/fixedbugs/issue31053.dir/main.go
+++ b/test/fixedbugs/issue31053.dir/main.go
@@ -35,8 +35,8 @@ func main() {
 	_ = f.Exported
 	_ = f.exported    // ERROR "f.exported undefined .type f1.Foo has no field or method exported, but does have Exported."
 	_ = f.Unexported  // ERROR "f.Unexported undefined .type f1.Foo has no field or method Unexported."
-	_ = f.unexported  // ERROR "f.unexported undefined .cannot refer to unexported field or method f1..\*Foo..unexported."
-	f.unexported = 10 // ERROR "f.unexported undefined .cannot refer to unexported field or method f1..\*Foo..unexported."
-	f.unexported()    // ERROR "f.unexported undefined .cannot refer to unexported field or method f1..\*Foo..unexported."
+	_ = f.unexported  // ERROR "f.unexported undefined .cannot refer to unexported field or method unexported."
+	f.unexported = 10 // ERROR "f.unexported undefined .cannot refer to unexported field or method unexported."
+	f.unexported()    // ERROR "f.unexported undefined .cannot refer to unexported field or method unexported."
 	_ = f.hook        // ERROR "f.hook undefined .cannot refer to unexported field or method hook."
 }
-- 
GitLab


From 4c215c4fa934990d159c549bcdd85f9be92287cd Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 26 Dec 2020 19:55:57 -0800
Subject: [PATCH 0345/2400] [dev.regabi] cmd/compile: simplify and optimize
 reorder3

reorder3 is the code responsible for ensuring that evaluation of an
N:N parallel assignment statement respects the order of evaluation
rules specified for Go.

This CL simplifies the code and improves it from an O(N^2) algorithm
to O(N).

Passes toolstash -cmp.

Change-Id: I04cd31613af6924f637b042be8ad039ec6a924c2
Reviewed-on: https://go-review.googlesource.com/c/go/+/280437
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/walk/assign.go | 237 +++++++++---------------
 1 file changed, 85 insertions(+), 152 deletions(-)

diff --git a/src/cmd/compile/internal/walk/assign.go b/src/cmd/compile/internal/walk/assign.go
index 99c1abd73f..3f229dd9f6 100644
--- a/src/cmd/compile/internal/walk/assign.go
+++ b/src/cmd/compile/internal/walk/assign.go
@@ -395,10 +395,35 @@ func ascompatet(nl ir.Nodes, nr *types.Type) []ir.Node {
 //
 // function calls have been removed.
 func reorder3(all []*ir.AssignStmt) []ir.Node {
+	var assigned ir.NameSet
+	var memWrite bool
+
+	// affected reports whether expression n could be affected by
+	// the assignments applied so far.
+	affected := func(n ir.Node) bool {
+		return ir.Any(n, func(n ir.Node) bool {
+			if n.Op() == ir.ONAME && assigned.Has(n.(*ir.Name)) {
+				return true
+			}
+			if memWrite && readsMemory(n) {
+				return true
+			}
+			return false
+		})
+	}
+
 	// If a needed expression may be affected by an
 	// earlier assignment, make an early copy of that
 	// expression and use the copy instead.
 	var early []ir.Node
+	save := func(np *ir.Node) {
+		if n := *np; affected(n) {
+			tmp := ir.Node(typecheck.Temp(n.Type()))
+			as := typecheck.Stmt(ir.NewAssignStmt(base.Pos, tmp, n))
+			early = append(early, as)
+			*np = tmp
+		}
+	}
 
 	var mapinit ir.Nodes
 	for i, n := range all {
@@ -407,19 +432,18 @@ func reorder3(all []*ir.AssignStmt) []ir.Node {
 		// Save subexpressions needed on left side.
 		// Drill through non-dereferences.
 		for {
-			switch ll := l; ll.Op() {
-			case ir.ODOT:
-				ll := ll.(*ir.SelectorExpr)
-				l = ll.X
-				continue
-			case ir.OPAREN:
-				ll := ll.(*ir.ParenExpr)
+			switch ll := l.(type) {
+			case *ir.IndexExpr:
+				if ll.X.Type().IsArray() {
+					save(&ll.Index)
+					l = ll.X
+					continue
+				}
+			case *ir.ParenExpr:
 				l = ll.X
 				continue
-			case ir.OINDEX:
-				ll := ll.(*ir.IndexExpr)
-				if ll.X.Type().IsArray() {
-					ll.Index = reorder3save(ll.Index, all, i, &early)
+			case *ir.SelectorExpr:
+				if ll.Op() == ir.ODOT {
 					l = ll.X
 					continue
 				}
@@ -427,181 +451,90 @@ func reorder3(all []*ir.AssignStmt) []ir.Node {
 			break
 		}
 
+		var name *ir.Name
 		switch l.Op() {
 		default:
 			base.Fatalf("reorder3 unexpected lvalue %v", l.Op())
 
 		case ir.ONAME:
-			break
+			name = l.(*ir.Name)
 
 		case ir.OINDEX, ir.OINDEXMAP:
 			l := l.(*ir.IndexExpr)
-			l.X = reorder3save(l.X, all, i, &early)
-			l.Index = reorder3save(l.Index, all, i, &early)
+			save(&l.X)
+			save(&l.Index)
 			if l.Op() == ir.OINDEXMAP {
 				all[i] = convas(all[i], &mapinit)
 			}
 
 		case ir.ODEREF:
 			l := l.(*ir.StarExpr)
-			l.X = reorder3save(l.X, all, i, &early)
+			save(&l.X)
 		case ir.ODOTPTR:
 			l := l.(*ir.SelectorExpr)
-			l.X = reorder3save(l.X, all, i, &early)
+			save(&l.X)
 		}
 
 		// Save expression on right side.
-		all[i].Y = reorder3save(all[i].Y, all, i, &early)
-	}
-
-	early = append(mapinit, early...)
-	for _, as := range all {
-		early = append(early, as)
-	}
-	return early
-}
-
-// if the evaluation of *np would be affected by the
-// assignments in all up to but not including the ith assignment,
-// copy into a temporary during *early and
-// replace *np with that temp.
-// The result of reorder3save MUST be assigned back to n, e.g.
-// 	n.Left = reorder3save(n.Left, all, i, early)
-func reorder3save(n ir.Node, all []*ir.AssignStmt, i int, early *[]ir.Node) ir.Node {
-	if !aliased(n, all[:i]) {
-		return n
-	}
-
-	q := ir.Node(typecheck.Temp(n.Type()))
-	as := typecheck.Stmt(ir.NewAssignStmt(base.Pos, q, n))
-	*early = append(*early, as)
-	return q
-}
-
-// Is it possible that the computation of r might be
-// affected by assignments in all?
-func aliased(r ir.Node, all []*ir.AssignStmt) bool {
-	if r == nil {
-		return false
-	}
-
-	// Treat all fields of a struct as referring to the whole struct.
-	// We could do better but we would have to keep track of the fields.
-	for r.Op() == ir.ODOT {
-		r = r.(*ir.SelectorExpr).X
-	}
-
-	// Look for obvious aliasing: a variable being assigned
-	// during the all list and appearing in n.
-	// Also record whether there are any writes to addressable
-	// memory (either main memory or variables whose addresses
-	// have been taken).
-	memwrite := false
-	for _, as := range all {
-		// We can ignore assignments to blank.
-		if ir.IsBlank(as.X) {
-			continue
-		}
+		save(&all[i].Y)
 
-		lv := ir.OuterValue(as.X)
-		if lv.Op() != ir.ONAME {
-			memwrite = true
+		if name == nil || name.Addrtaken() || name.Class_ == ir.PEXTERN || name.Class_ == ir.PAUTOHEAP {
+			memWrite = true
 			continue
 		}
-		l := lv.(*ir.Name)
-
-		switch l.Class_ {
-		default:
-			base.Fatalf("unexpected class: %v, %v", l, l.Class_)
-
-		case ir.PAUTOHEAP, ir.PEXTERN:
-			memwrite = true
+		if ir.IsBlank(name) {
+			// We can ignore assignments to blank.
 			continue
-
-		case ir.PAUTO, ir.PPARAM, ir.PPARAMOUT:
-			if l.Name().Addrtaken() {
-				memwrite = true
-				continue
-			}
-
-			if refersToName(l, r) {
-				// Direct hit: l appears in r.
-				return true
-			}
 		}
+		assigned.Add(name)
 	}
 
-	// The variables being written do not appear in r.
-	// However, r might refer to computed addresses
-	// that are being written.
-
-	// If no computed addresses are affected by the writes, no aliasing.
-	if !memwrite {
-		return false
+	early = append(mapinit, early...)
+	for _, as := range all {
+		early = append(early, as)
 	}
+	return early
+}
 
-	// If r does not refer to any variables whose addresses have been taken,
-	// then the only possible writes to r would be directly to the variables,
-	// and we checked those above, so no aliasing problems.
-	if !anyAddrTaken(r) {
+// readsMemory reports whether the evaluation n directly reads from
+// memory that might be written to indirectly.
+func readsMemory(n ir.Node) bool {
+	switch n.Op() {
+	case ir.ONAME:
+		n := n.(*ir.Name)
+		return n.Class_ == ir.PEXTERN || n.Class_ == ir.PAUTOHEAP || n.Addrtaken()
+
+	case ir.OADD,
+		ir.OAND,
+		ir.OANDAND,
+		ir.OANDNOT,
+		ir.OBITNOT,
+		ir.OCONV,
+		ir.OCONVIFACE,
+		ir.OCONVNOP,
+		ir.ODIV,
+		ir.ODOT,
+		ir.ODOTTYPE,
+		ir.OLITERAL,
+		ir.OLSH,
+		ir.OMOD,
+		ir.OMUL,
+		ir.ONEG,
+		ir.ONIL,
+		ir.OOR,
+		ir.OOROR,
+		ir.OPAREN,
+		ir.OPLUS,
+		ir.ORSH,
+		ir.OSUB,
+		ir.OXOR:
 		return false
 	}
 
-	// Otherwise, both the writes and r refer to computed memory addresses.
-	// Assume that they might conflict.
+	// Be conservative.
 	return true
 }
 
-// anyAddrTaken reports whether the evaluation n,
-// which appears on the left side of an assignment,
-// may refer to variables whose addresses have been taken.
-func anyAddrTaken(n ir.Node) bool {
-	return ir.Any(n, func(n ir.Node) bool {
-		switch n.Op() {
-		case ir.ONAME:
-			n := n.(*ir.Name)
-			return n.Class_ == ir.PEXTERN || n.Class_ == ir.PAUTOHEAP || n.Name().Addrtaken()
-
-		case ir.ODOT: // but not ODOTPTR - should have been handled in aliased.
-			base.Fatalf("anyAddrTaken unexpected ODOT")
-
-		case ir.OADD,
-			ir.OAND,
-			ir.OANDAND,
-			ir.OANDNOT,
-			ir.OBITNOT,
-			ir.OCONV,
-			ir.OCONVIFACE,
-			ir.OCONVNOP,
-			ir.ODIV,
-			ir.ODOTTYPE,
-			ir.OLITERAL,
-			ir.OLSH,
-			ir.OMOD,
-			ir.OMUL,
-			ir.ONEG,
-			ir.ONIL,
-			ir.OOR,
-			ir.OOROR,
-			ir.OPAREN,
-			ir.OPLUS,
-			ir.ORSH,
-			ir.OSUB,
-			ir.OXOR:
-			return false
-		}
-		// Be conservative.
-		return true
-	})
-}
-
-// refersToName reports whether r refers to name.
-func refersToName(name *ir.Name, r ir.Node) bool {
-	return ir.Any(r, func(r ir.Node) bool {
-		return r.Op() == ir.ONAME && r == name
-	})
-}
-
 // refersToCommonName reports whether any name
 // appears in common between l and r.
 // This is called from sinit.go.
-- 
GitLab


From c98548e1109e9fbe29ef2a8c7c275b241aaacd3b Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 26 Dec 2020 21:10:16 -0800
Subject: [PATCH 0346/2400] [dev.regabi] cmd/compile: merge ascompatee,
 ascompatee1, and reorder3

These functions are interelated and have arbitrarily overlapping
responsibilities. By joining them together, we simplify the code and
remove some redundancy.

Passes toolstash -cmp.

Change-Id: I7c42cb7171b3006bc790199be3fd0991e6e985f2
Reviewed-on: https://go-review.googlesource.com/c/go/+/280438
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/walk/assign.go | 104 ++++++++----------------
 1 file changed, 32 insertions(+), 72 deletions(-)

diff --git a/src/cmd/compile/internal/walk/assign.go b/src/cmd/compile/internal/walk/assign.go
index 3f229dd9f6..99541c58d9 100644
--- a/src/cmd/compile/internal/walk/assign.go
+++ b/src/cmd/compile/internal/walk/assign.go
@@ -297,54 +297,6 @@ func fncall(l ir.Node, rt *types.Type) bool {
 	return true
 }
 
-func ascompatee(op ir.Op, nl, nr []ir.Node, init *ir.Nodes) []ir.Node {
-	// check assign expression list to
-	// an expression list. called in
-	//	expr-list = expr-list
-
-	// ensure order of evaluation for function calls
-	for i := range nl {
-		nl[i] = safeExpr(nl[i], init)
-	}
-	for i1 := range nr {
-		nr[i1] = safeExpr(nr[i1], init)
-	}
-
-	var nn []*ir.AssignStmt
-	i := 0
-	for ; i < len(nl); i++ {
-		if i >= len(nr) {
-			break
-		}
-		// Do not generate 'x = x' during return. See issue 4014.
-		if op == ir.ORETURN && ir.SameSafeExpr(nl[i], nr[i]) {
-			continue
-		}
-		nn = append(nn, ascompatee1(nl[i], nr[i], init))
-	}
-
-	// cannot happen: caller checked that lists had same length
-	if i < len(nl) || i < len(nr) {
-		var nln, nrn ir.Nodes
-		nln.Set(nl)
-		nrn.Set(nr)
-		base.Fatalf("error in shape across %+v %v %+v / %d %d [%s]", nln, op, nrn, len(nl), len(nr), ir.FuncName(ir.CurFunc))
-	}
-	return reorder3(nn)
-}
-
-func ascompatee1(l ir.Node, r ir.Node, init *ir.Nodes) *ir.AssignStmt {
-	// convas will turn map assigns into function calls,
-	// making it impossible for reorder3 to work.
-	n := ir.NewAssignStmt(base.Pos, l, r)
-
-	if l.Op() == ir.OINDEXMAP {
-		return n
-	}
-
-	return convas(n, init)
-}
-
 // check assign type list to
 // an expression list. called in
 //	expr-list = func()
@@ -387,14 +339,23 @@ func ascompatet(nl ir.Nodes, nr *types.Type) []ir.Node {
 	return append(nn, mm...)
 }
 
-// reorder3
-// from ascompatee
-//	a,b = c,d
-// simultaneous assignment. there cannot
-// be later use of an earlier lvalue.
-//
-// function calls have been removed.
-func reorder3(all []*ir.AssignStmt) []ir.Node {
+// check assign expression list to
+// an expression list. called in
+//	expr-list = expr-list
+func ascompatee(op ir.Op, nl, nr []ir.Node, init *ir.Nodes) []ir.Node {
+	// cannot happen: should have been rejected during type checking
+	if len(nl) != len(nr) {
+		base.Fatalf("assignment operands mismatch: %+v / %+v", ir.Nodes(nl), ir.Nodes(nr))
+	}
+
+	// ensure order of evaluation for function calls
+	for i := range nl {
+		nl[i] = safeExpr(nl[i], init)
+	}
+	for i := range nr {
+		nr[i] = safeExpr(nr[i], init)
+	}
+
 	var assigned ir.NameSet
 	var memWrite bool
 
@@ -425,9 +386,16 @@ func reorder3(all []*ir.AssignStmt) []ir.Node {
 		}
 	}
 
-	var mapinit ir.Nodes
-	for i, n := range all {
-		l := n.X
+	var late []ir.Node
+	for i, l := range nl {
+		r := nr[i]
+
+		// Do not generate 'x = x' during return. See issue 4014.
+		if op == ir.ORETURN && ir.SameSafeExpr(l, r) {
+			continue
+		}
+
+		as := ir.NewAssignStmt(base.Pos, l, r)
 
 		// Save subexpressions needed on left side.
 		// Drill through non-dereferences.
@@ -454,19 +422,13 @@ func reorder3(all []*ir.AssignStmt) []ir.Node {
 		var name *ir.Name
 		switch l.Op() {
 		default:
-			base.Fatalf("reorder3 unexpected lvalue %v", l.Op())
-
+			base.Fatalf("unexpected lvalue %v", l.Op())
 		case ir.ONAME:
 			name = l.(*ir.Name)
-
 		case ir.OINDEX, ir.OINDEXMAP:
 			l := l.(*ir.IndexExpr)
 			save(&l.X)
 			save(&l.Index)
-			if l.Op() == ir.OINDEXMAP {
-				all[i] = convas(all[i], &mapinit)
-			}
-
 		case ir.ODEREF:
 			l := l.(*ir.StarExpr)
 			save(&l.X)
@@ -476,7 +438,9 @@ func reorder3(all []*ir.AssignStmt) []ir.Node {
 		}
 
 		// Save expression on right side.
-		save(&all[i].Y)
+		save(&as.Y)
+
+		late = append(late, convas(as, init))
 
 		if name == nil || name.Addrtaken() || name.Class_ == ir.PEXTERN || name.Class_ == ir.PAUTOHEAP {
 			memWrite = true
@@ -489,11 +453,7 @@ func reorder3(all []*ir.AssignStmt) []ir.Node {
 		assigned.Add(name)
 	}
 
-	early = append(mapinit, early...)
-	for _, as := range all {
-		early = append(early, as)
-	}
-	return early
+	return append(early, late...)
 }
 
 // readsMemory reports whether the evaluation n directly reads from
-- 
GitLab


From 676d794b8119a40aaa0aa00124f367bd72eeff9c Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 26 Dec 2020 21:33:17 -0800
Subject: [PATCH 0347/2400] [dev.regabi] cmd/compile: remove refersToCommonName

After reorder3's simplification, the only remaining use of
refersToCommonName is in oaslit, where the LHS expression is always a
single name. We can replace the now overly-generalized
refersToCommonName with a simple ir.Any traversal with ir.Uses.

Passes toolstash -cmp.

Change-Id: Ice3020cdbbf6083d52e07866a687580f4eb134b8
Reviewed-on: https://go-review.googlesource.com/c/go/+/280439
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/walk/assign.go  | 49 ------------------------
 src/cmd/compile/internal/walk/complit.go |  3 +-
 2 files changed, 2 insertions(+), 50 deletions(-)

diff --git a/src/cmd/compile/internal/walk/assign.go b/src/cmd/compile/internal/walk/assign.go
index 99541c58d9..c01079d236 100644
--- a/src/cmd/compile/internal/walk/assign.go
+++ b/src/cmd/compile/internal/walk/assign.go
@@ -495,55 +495,6 @@ func readsMemory(n ir.Node) bool {
 	return true
 }
 
-// refersToCommonName reports whether any name
-// appears in common between l and r.
-// This is called from sinit.go.
-func refersToCommonName(l ir.Node, r ir.Node) bool {
-	if l == nil || r == nil {
-		return false
-	}
-
-	// This could be written elegantly as a Find nested inside a Find:
-	//
-	//	found := ir.Find(l, func(l ir.Node) interface{} {
-	//		if l.Op() == ir.ONAME {
-	//			return ir.Find(r, func(r ir.Node) interface{} {
-	//				if r.Op() == ir.ONAME && l.Name() == r.Name() {
-	//					return r
-	//				}
-	//				return nil
-	//			})
-	//		}
-	//		return nil
-	//	})
-	//	return found != nil
-	//
-	// But that would allocate a new closure for the inner Find
-	// for each name found on the left side.
-	// It may not matter at all, but the below way of writing it
-	// only allocates two closures, not O(|L|) closures.
-
-	var doL, doR func(ir.Node) error
-	var targetL *ir.Name
-	doR = func(r ir.Node) error {
-		if r.Op() == ir.ONAME && r.Name() == targetL {
-			return stop
-		}
-		return ir.DoChildren(r, doR)
-	}
-	doL = func(l ir.Node) error {
-		if l.Op() == ir.ONAME {
-			l := l.(*ir.Name)
-			targetL = l.Name()
-			if doR(r) == stop {
-				return stop
-			}
-		}
-		return ir.DoChildren(l, doL)
-	}
-	return doL(l) == stop
-}
-
 // expand append(l1, l2...) to
 //   init {
 //     s := l1
diff --git a/src/cmd/compile/internal/walk/complit.go b/src/cmd/compile/internal/walk/complit.go
index b53fe2e935..8c4f9583ef 100644
--- a/src/cmd/compile/internal/walk/complit.go
+++ b/src/cmd/compile/internal/walk/complit.go
@@ -629,6 +629,7 @@ func oaslit(n *ir.AssignStmt, init *ir.Nodes) bool {
 		// not a special composite literal assignment
 		return false
 	}
+	x := n.X.(*ir.Name)
 	if !types.Identical(n.X.Type(), n.Y.Type()) {
 		// not a special composite literal assignment
 		return false
@@ -640,7 +641,7 @@ func oaslit(n *ir.AssignStmt, init *ir.Nodes) bool {
 		return false
 
 	case ir.OSTRUCTLIT, ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT:
-		if refersToCommonName(n.X, n.Y) {
+		if ir.Any(n.Y, func(y ir.Node) bool { return ir.Uses(y, x) }) {
 			// not a special composite literal assignment
 			return false
 		}
-- 
GitLab


From 6c676775419b4cfc9f1a3b8959d538b81cec754e Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 26 Dec 2020 21:43:30 -0800
Subject: [PATCH 0348/2400] [dev.regabi] cmd/compile: simplify FuncName and
 PkgFuncName

Now that we have proper types, these functions can be restricted to
only allowing *ir.Func, rather than any ir.Node. And even more
fortunately, all of their callers already happen to always
pass *ir.Func arguments, making this CL pretty simple.

Passes toolstash -cmp.

Change-Id: I21ecd4c8cee3ccb8ba86b17cedb2e71c56ffe87a
Reviewed-on: https://go-review.googlesource.com/c/go/+/280440
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/ir/func.go | 38 ++++-------------------------
 1 file changed, 5 insertions(+), 33 deletions(-)

diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 6bc8cd574c..16d67f6ae0 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -206,50 +206,22 @@ func (f *Func) SetWBPos(pos src.XPos) {
 }
 
 // funcname returns the name (without the package) of the function n.
-func FuncName(n Node) string {
-	var f *Func
-	switch n := n.(type) {
-	case *Func:
-		f = n
-	case *Name:
-		f = n.Func
-	case *CallPartExpr:
-		f = n.Func
-	case *ClosureExpr:
-		f = n.Func
-	}
+func FuncName(f *Func) string {
 	if f == nil || f.Nname == nil {
 		return "<nil>"
 	}
-	return f.Nname.Sym().Name
+	return f.Sym().Name
 }
 
 // pkgFuncName returns the name of the function referenced by n, with package prepended.
 // This differs from the compiler's internal convention where local functions lack a package
 // because the ultimate consumer of this is a human looking at an IDE; package is only empty
 // if the compilation package is actually the empty string.
-func PkgFuncName(n Node) string {
-	var s *types.Sym
-	if n == nil {
+func PkgFuncName(f *Func) string {
+	if f == nil || f.Nname == nil {
 		return "<nil>"
 	}
-	if n.Op() == ONAME {
-		s = n.Sym()
-	} else {
-		var f *Func
-		switch n := n.(type) {
-		case *CallPartExpr:
-			f = n.Func
-		case *ClosureExpr:
-			f = n.Func
-		case *Func:
-			f = n
-		}
-		if f == nil || f.Nname == nil {
-			return "<nil>"
-		}
-		s = f.Nname.Sym()
-	}
+	s := f.Sym()
 	pkg := s.Pkg
 
 	p := base.Ctxt.Pkgpath
-- 
GitLab


From fbc4458c068459940c63952bcc6a697728f508fc Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 26 Dec 2020 22:00:53 -0800
Subject: [PATCH 0349/2400] [dev.regabi] cmd/compile: simplify some tree
 traversal code

When looking for referenced functions within bottomUpVisitor and
initDeps, the logic for ODOTMETH, OCALLPART, and OMETHEXPR are
basically identical, especially after previous refactorings to make
them use MethodExprName. This CL makes them exactly identical.

Passes toolstash -cmp.

Change-Id: I1f59c9be99aa9484d0397a0a6fb8ddd894a31c68
Reviewed-on: https://go-review.googlesource.com/c/go/+/280441
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/ir/scc.go            | 49 ++++++-------------
 src/cmd/compile/internal/pkginit/initorder.go |  6 +--
 2 files changed, 15 insertions(+), 40 deletions(-)

diff --git a/src/cmd/compile/internal/ir/scc.go b/src/cmd/compile/internal/ir/scc.go
index 4f646e22b5..f35c4d44e9 100644
--- a/src/cmd/compile/internal/ir/scc.go
+++ b/src/cmd/compile/internal/ir/scc.go
@@ -76,48 +76,27 @@ func (v *bottomUpVisitor) visit(n *Func) uint32 {
 	min := v.visitgen
 	v.stack = append(v.stack, n)
 
+	do := func(defn Node) {
+		if defn != nil {
+			if m := v.visit(defn.(*Func)); m < min {
+				min = m
+			}
+		}
+	}
+
 	Visit(n, func(n Node) {
 		switch n.Op() {
 		case ONAME:
-			n := n.(*Name)
-			if n.Class_ == PFUNC {
-				if n != nil && n.Name().Defn != nil {
-					if m := v.visit(n.Name().Defn.(*Func)); m < min {
-						min = m
-					}
-				}
+			if n := n.(*Name); n.Class_ == PFUNC {
+				do(n.Defn)
 			}
-		case OMETHEXPR:
-			n := n.(*MethodExpr)
-			fn := MethodExprName(n)
-			if fn != nil && fn.Defn != nil {
-				if m := v.visit(fn.Defn.(*Func)); m < min {
-					min = m
-				}
-			}
-		case ODOTMETH:
-			n := n.(*SelectorExpr)
-			fn := MethodExprName(n)
-			if fn != nil && fn.Op() == ONAME && fn.Class_ == PFUNC && fn.Defn != nil {
-				if m := v.visit(fn.Defn.(*Func)); m < min {
-					min = m
-				}
-			}
-		case OCALLPART:
-			n := n.(*CallPartExpr)
-			fn := AsNode(n.Method.Nname)
-			if fn != nil && fn.Op() == ONAME {
-				if fn := fn.(*Name); fn.Class_ == PFUNC && fn.Name().Defn != nil {
-					if m := v.visit(fn.Name().Defn.(*Func)); m < min {
-						min = m
-					}
-				}
+		case ODOTMETH, OCALLPART, OMETHEXPR:
+			if fn := MethodExprName(n); fn != nil {
+				do(fn.Defn)
 			}
 		case OCLOSURE:
 			n := n.(*ClosureExpr)
-			if m := v.visit(n.Func); m < min {
-				min = m
-			}
+			do(n.Func)
 		}
 	})
 
diff --git a/src/cmd/compile/internal/pkginit/initorder.go b/src/cmd/compile/internal/pkginit/initorder.go
index d63c5a4717..c6e223954d 100644
--- a/src/cmd/compile/internal/pkginit/initorder.go
+++ b/src/cmd/compile/internal/pkginit/initorder.go
@@ -289,10 +289,6 @@ func (d *initDeps) inspectList(l ir.Nodes) { ir.VisitList(l, d.cachedVisit()) }
 // referenced by n, if any.
 func (d *initDeps) visit(n ir.Node) {
 	switch n.Op() {
-	case ir.OMETHEXPR:
-		n := n.(*ir.MethodExpr)
-		d.foundDep(ir.MethodExprName(n))
-
 	case ir.ONAME:
 		n := n.(*ir.Name)
 		switch n.Class_ {
@@ -304,7 +300,7 @@ func (d *initDeps) visit(n ir.Node) {
 		n := n.(*ir.ClosureExpr)
 		d.inspectList(n.Func.Body)
 
-	case ir.ODOTMETH, ir.OCALLPART:
+	case ir.ODOTMETH, ir.OCALLPART, ir.OMETHEXPR:
 		d.foundDep(ir.MethodExprName(n))
 	}
 }
-- 
GitLab


From a59d26603f0dffbe6e914bc9ab29a2f9f70e5408 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 26 Dec 2020 22:23:45 -0800
Subject: [PATCH 0350/2400] [dev.regabi] cmd/compile: use []*CaseStmt in
 {Select,Switch}Stmt

Select and switch statements only ever contain case statements, so
change their Cases fields from Nodes to []*CaseStmt. This allows
removing a bunch of type assertions throughout the compiler.

CaseStmt should be renamed to CaseClause, and SelectStmt should
probably have its own CommClause type instead (like in go/ast and
cmd/compile/internal/syntax), but this is a good start.

Passes toolstash -cmp.

Change-Id: I2d41d616d44512c2be421e1e2ff13d0ee8b238ad
Reviewed-on: https://go-review.googlesource.com/c/go/+/280442
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/escape/escape.go     |  2 -
 src/cmd/compile/internal/ir/mknode.go         |  7 +++
 src/cmd/compile/internal/ir/node_gen.go       | 12 +++---
 src/cmd/compile/internal/ir/stmt.go           | 43 ++++++++++++++++---
 src/cmd/compile/internal/ir/visit.go          |  3 +-
 src/cmd/compile/internal/noder/noder.go       | 10 ++---
 src/cmd/compile/internal/typecheck/iexport.go |  3 +-
 src/cmd/compile/internal/typecheck/iimport.go |  4 +-
 src/cmd/compile/internal/typecheck/stmt.go    |  4 --
 .../compile/internal/typecheck/typecheck.go   | 13 +++---
 src/cmd/compile/internal/walk/order.go        |  6 +--
 src/cmd/compile/internal/walk/select.go       | 12 +++---
 src/cmd/compile/internal/walk/switch.go       |  7 +--
 13 files changed, 73 insertions(+), 53 deletions(-)

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index 31d157b165..d8f0111d2d 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -369,7 +369,6 @@ func (e *escape) stmt(n ir.Node) {
 
 		var ks []hole
 		for _, cas := range n.Cases { // cases
-			cas := cas.(*ir.CaseStmt)
 			if typesw && n.Tag.(*ir.TypeSwitchGuard).Tag != nil {
 				cv := cas.Var
 				k := e.dcl(cv) // type switch variables have no ODCL.
@@ -391,7 +390,6 @@ func (e *escape) stmt(n ir.Node) {
 	case ir.OSELECT:
 		n := n.(*ir.SelectStmt)
 		for _, cas := range n.Cases {
-			cas := cas.(*ir.CaseStmt)
 			e.stmt(cas.Comm)
 			e.block(cas.Body)
 		}
diff --git a/src/cmd/compile/internal/ir/mknode.go b/src/cmd/compile/internal/ir/mknode.go
index f5dacee622..edf3ee501c 100644
--- a/src/cmd/compile/internal/ir/mknode.go
+++ b/src/cmd/compile/internal/ir/mknode.go
@@ -37,6 +37,7 @@ func main() {
 	nodeType := lookup("Node")
 	ntypeType := lookup("Ntype")
 	nodesType := lookup("Nodes")
+	slicePtrCaseStmtType := types.NewSlice(types.NewPointer(lookup("CaseStmt")))
 	ptrFieldType := types.NewPointer(lookup("Field"))
 	slicePtrFieldType := types.NewSlice(ptrFieldType)
 	ptrIdentType := types.NewPointer(lookup("Ident"))
@@ -76,6 +77,8 @@ func main() {
 				switch {
 				case is(nodesType):
 					fmt.Fprintf(&buf, "c.%s = c.%s.Copy()\n", name, name)
+				case is(slicePtrCaseStmtType):
+					fmt.Fprintf(&buf, "c.%s = copyCases(c.%s)\n", name, name)
 				case is(ptrFieldType):
 					fmt.Fprintf(&buf, "if c.%s != nil { c.%s = c.%s.copy() }\n", name, name, name)
 				case is(slicePtrFieldType):
@@ -94,6 +97,8 @@ func main() {
 				fmt.Fprintf(&buf, "err = maybeDo(n.%s, err, do)\n", name)
 			case is(nodesType):
 				fmt.Fprintf(&buf, "err = maybeDoList(n.%s, err, do)\n", name)
+			case is(slicePtrCaseStmtType):
+				fmt.Fprintf(&buf, "err = maybeDoCases(n.%s, err, do)\n", name)
 			case is(ptrFieldType):
 				fmt.Fprintf(&buf, "err = maybeDoField(n.%s, err, do)\n", name)
 			case is(slicePtrFieldType):
@@ -113,6 +118,8 @@ func main() {
 				fmt.Fprintf(&buf, "n.%s = toNtype(maybeEdit(n.%s, edit))\n", name, name)
 			case is(nodesType):
 				fmt.Fprintf(&buf, "editList(n.%s, edit)\n", name)
+			case is(slicePtrCaseStmtType):
+				fmt.Fprintf(&buf, "editCases(n.%s, edit)\n", name)
 			case is(ptrFieldType):
 				fmt.Fprintf(&buf, "editField(n.%s, edit)\n", name)
 			case is(slicePtrFieldType):
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index ecb39563c4..041855bbe9 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -781,20 +781,20 @@ func (n *SelectStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *SelectStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
-	c.Cases = c.Cases.Copy()
+	c.Cases = copyCases(c.Cases)
 	c.Compiled = c.Compiled.Copy()
 	return &c
 }
 func (n *SelectStmt) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
-	err = maybeDoList(n.Cases, err, do)
+	err = maybeDoCases(n.Cases, err, do)
 	err = maybeDoList(n.Compiled, err, do)
 	return err
 }
 func (n *SelectStmt) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
-	editList(n.Cases, edit)
+	editCases(n.Cases, edit)
 	editList(n.Compiled, edit)
 }
 
@@ -945,7 +945,7 @@ func (n *SwitchStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *SwitchStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
-	c.Cases = c.Cases.Copy()
+	c.Cases = copyCases(c.Cases)
 	c.Compiled = c.Compiled.Copy()
 	return &c
 }
@@ -953,14 +953,14 @@ func (n *SwitchStmt) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
 	err = maybeDo(n.Tag, err, do)
-	err = maybeDoList(n.Cases, err, do)
+	err = maybeDoCases(n.Cases, err, do)
 	err = maybeDoList(n.Compiled, err, do)
 	return err
 }
 func (n *SwitchStmt) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	n.Tag = maybeEdit(n.Tag, edit)
-	editList(n.Cases, edit)
+	editCases(n.Cases, edit)
 	editList(n.Compiled, edit)
 }
 
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index cfda6fd234..ce775a8529 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -191,6 +191,37 @@ func NewCaseStmt(pos src.XPos, list, body []Node) *CaseStmt {
 	return n
 }
 
+func copyCases(list []*CaseStmt) []*CaseStmt {
+	if list == nil {
+		return nil
+	}
+	c := make([]*CaseStmt, len(list))
+	copy(c, list)
+	return c
+}
+
+func maybeDoCases(list []*CaseStmt, err error, do func(Node) error) error {
+	if err != nil {
+		return err
+	}
+	for _, x := range list {
+		if x != nil {
+			if err := do(x); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func editCases(list []*CaseStmt, edit func(Node) Node) {
+	for i, x := range list {
+		if x != nil {
+			list[i] = edit(x).(*CaseStmt)
+		}
+	}
+}
+
 // A ForStmt is a non-range for loop: for Init; Cond; Post { Body }
 // Op can be OFOR or OFORUNTIL (!Cond).
 type ForStmt struct {
@@ -334,18 +365,18 @@ func (n *ReturnStmt) SetOrig(x Node) { n.orig = x }
 type SelectStmt struct {
 	miniStmt
 	Label    *types.Sym
-	Cases    Nodes
+	Cases    []*CaseStmt
 	HasBreak bool
 
 	// TODO(rsc): Instead of recording here, replace with a block?
 	Compiled Nodes // compiled form, after walkswitch
 }
 
-func NewSelectStmt(pos src.XPos, cases []Node) *SelectStmt {
+func NewSelectStmt(pos src.XPos, cases []*CaseStmt) *SelectStmt {
 	n := &SelectStmt{}
 	n.pos = pos
 	n.op = OSELECT
-	n.Cases.Set(cases)
+	n.Cases = cases
 	return n
 }
 
@@ -367,7 +398,7 @@ func NewSendStmt(pos src.XPos, ch, value Node) *SendStmt {
 type SwitchStmt struct {
 	miniStmt
 	Tag      Node
-	Cases    Nodes // list of *CaseStmt
+	Cases    []*CaseStmt
 	Label    *types.Sym
 	HasBreak bool
 
@@ -375,11 +406,11 @@ type SwitchStmt struct {
 	Compiled Nodes // compiled form, after walkswitch
 }
 
-func NewSwitchStmt(pos src.XPos, tag Node, cases []Node) *SwitchStmt {
+func NewSwitchStmt(pos src.XPos, tag Node, cases []*CaseStmt) *SwitchStmt {
 	n := &SwitchStmt{Tag: tag}
 	n.pos = pos
 	n.op = OSWITCH
-	n.Cases.Set(cases)
+	n.Cases = cases
 	return n
 }
 
diff --git a/src/cmd/compile/internal/ir/visit.go b/src/cmd/compile/internal/ir/visit.go
index a1c345968f..8839e1664d 100644
--- a/src/cmd/compile/internal/ir/visit.go
+++ b/src/cmd/compile/internal/ir/visit.go
@@ -217,10 +217,9 @@ func EditChildren(n Node, edit func(Node) Node) {
 // Note that editList only calls edit on the nodes in the list, not their children.
 // If x's children should be processed, edit(x) must call EditChildren(x, edit) itself.
 func editList(list Nodes, edit func(Node) Node) {
-	s := list
 	for i, x := range list {
 		if x != nil {
-			s[i] = edit(x)
+			list[i] = edit(x)
 		}
 	}
 }
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index ad66b6c850..b974448338 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -1202,14 +1202,14 @@ func (p *noder) switchStmt(stmt *syntax.SwitchStmt) ir.Node {
 	if l := n.Tag; l != nil && l.Op() == ir.OTYPESW {
 		tswitch = l.(*ir.TypeSwitchGuard)
 	}
-	n.Cases.Set(p.caseClauses(stmt.Body, tswitch, stmt.Rbrace))
+	n.Cases = p.caseClauses(stmt.Body, tswitch, stmt.Rbrace)
 
 	p.closeScope(stmt.Rbrace)
 	return n
 }
 
-func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *ir.TypeSwitchGuard, rbrace syntax.Pos) []ir.Node {
-	nodes := make([]ir.Node, 0, len(clauses))
+func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *ir.TypeSwitchGuard, rbrace syntax.Pos) []*ir.CaseStmt {
+	nodes := make([]*ir.CaseStmt, 0, len(clauses))
 	for i, clause := range clauses {
 		p.setlineno(clause)
 		if i > 0 {
@@ -1266,8 +1266,8 @@ func (p *noder) simpleStmt(stmt syntax.SimpleStmt) []ir.Node {
 	return []ir.Node{p.stmt(stmt)}
 }
 
-func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []ir.Node {
-	nodes := make([]ir.Node, len(clauses))
+func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []*ir.CaseStmt {
+	nodes := make([]*ir.CaseStmt, len(clauses))
 	for i, clause := range clauses {
 		p.setlineno(clause)
 		if i > 0 {
diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index 0c813a71ef..19437a069e 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -1181,10 +1181,9 @@ func isNamedTypeSwitch(x ir.Node) bool {
 	return ok && guard.Tag != nil
 }
 
-func (w *exportWriter) caseList(cases []ir.Node, namedTypeSwitch bool) {
+func (w *exportWriter) caseList(cases []*ir.CaseStmt, namedTypeSwitch bool) {
 	w.uint64(uint64(len(cases)))
 	for _, cas := range cases {
-		cas := cas.(*ir.CaseStmt)
 		w.pos(cas.Pos())
 		w.stmtList(cas.List)
 		if namedTypeSwitch {
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 8285c418e9..fd8314b662 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -767,10 +767,10 @@ func (r *importReader) stmtList() []ir.Node {
 	return list
 }
 
-func (r *importReader) caseList(switchExpr ir.Node) []ir.Node {
+func (r *importReader) caseList(switchExpr ir.Node) []*ir.CaseStmt {
 	namedTypeSwitch := isNamedTypeSwitch(switchExpr)
 
-	cases := make([]ir.Node, r.uint64())
+	cases := make([]*ir.CaseStmt, r.uint64())
 	for i := range cases {
 		cas := ir.NewCaseStmt(r.pos(), nil, nil)
 		cas.List.Set(r.stmtList())
diff --git a/src/cmd/compile/internal/typecheck/stmt.go b/src/cmd/compile/internal/typecheck/stmt.go
index 7e74b730bc..03c3e399eb 100644
--- a/src/cmd/compile/internal/typecheck/stmt.go
+++ b/src/cmd/compile/internal/typecheck/stmt.go
@@ -364,8 +364,6 @@ func tcSelect(sel *ir.SelectStmt) {
 	lno := ir.SetPos(sel)
 	Stmts(sel.Init())
 	for _, ncase := range sel.Cases {
-		ncase := ncase.(*ir.CaseStmt)
-
 		if len(ncase.List) == 0 {
 			// default
 			if def != nil {
@@ -508,7 +506,6 @@ func tcSwitchExpr(n *ir.SwitchStmt) {
 	var defCase ir.Node
 	var cs constSet
 	for _, ncase := range n.Cases {
-		ncase := ncase.(*ir.CaseStmt)
 		ls := ncase.List
 		if len(ls) == 0 { // default:
 			if defCase != nil {
@@ -577,7 +574,6 @@ func tcSwitchType(n *ir.SwitchStmt) {
 	var defCase, nilCase ir.Node
 	var ts typeSet
 	for _, ncase := range n.Cases {
-		ncase := ncase.(*ir.CaseStmt)
 		ls := ncase.List
 		if len(ls) == 0 { // default:
 			if defCase != nil {
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index b779f9ceb0..dabfee3bf9 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -2103,7 +2103,6 @@ func isTermNode(n ir.Node) bool {
 		}
 		def := false
 		for _, cas := range n.Cases {
-			cas := cas.(*ir.CaseStmt)
 			if !isTermNodes(cas.Body) {
 				return false
 			}
@@ -2119,7 +2118,6 @@ func isTermNode(n ir.Node) bool {
 			return false
 		}
 		for _, cas := range n.Cases {
-			cas := cas.(*ir.CaseStmt)
 			if !isTermNodes(cas.Body) {
 				return false
 			}
@@ -2218,9 +2216,6 @@ func deadcodeslice(nn *ir.Nodes) {
 		case ir.OBLOCK:
 			n := n.(*ir.BlockStmt)
 			deadcodeslice(&n.List)
-		case ir.OCASE:
-			n := n.(*ir.CaseStmt)
-			deadcodeslice(&n.Body)
 		case ir.OFOR:
 			n := n.(*ir.ForStmt)
 			deadcodeslice(&n.Body)
@@ -2233,10 +2228,14 @@ func deadcodeslice(nn *ir.Nodes) {
 			deadcodeslice(&n.Body)
 		case ir.OSELECT:
 			n := n.(*ir.SelectStmt)
-			deadcodeslice(&n.Cases)
+			for _, cas := range n.Cases {
+				deadcodeslice(&cas.Body)
+			}
 		case ir.OSWITCH:
 			n := n.(*ir.SwitchStmt)
-			deadcodeslice(&n.Cases)
+			for _, cas := range n.Cases {
+				deadcodeslice(&cas.Body)
+			}
 		}
 
 		if cut {
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index 1e41cfc6aa..ebbd467570 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -914,7 +914,6 @@ func (o *orderState) stmt(n ir.Node) {
 		n := n.(*ir.SelectStmt)
 		t := o.markTemp()
 		for _, ncas := range n.Cases {
-			ncas := ncas.(*ir.CaseStmt)
 			r := ncas.Comm
 			ir.SetPos(ncas)
 
@@ -996,7 +995,6 @@ func (o *orderState) stmt(n ir.Node) {
 		// Also insert any ninit queued during the previous loop.
 		// (The temporary cleaning must follow that ninit work.)
 		for _, cas := range n.Cases {
-			cas := cas.(*ir.CaseStmt)
 			orderBlock(&cas.Body, o.free)
 			cas.Body.Prepend(o.cleanTempNoPop(t)...)
 
@@ -1036,13 +1034,12 @@ func (o *orderState) stmt(n ir.Node) {
 		n := n.(*ir.SwitchStmt)
 		if base.Debug.Libfuzzer != 0 && !hasDefaultCase(n) {
 			// Add empty "default:" case for instrumentation.
-			n.Cases.Append(ir.NewCaseStmt(base.Pos, nil, nil))
+			n.Cases = append(n.Cases, ir.NewCaseStmt(base.Pos, nil, nil))
 		}
 
 		t := o.markTemp()
 		n.Tag = o.expr(n.Tag, nil)
 		for _, ncas := range n.Cases {
-			ncas := ncas.(*ir.CaseStmt)
 			o.exprListInPlace(ncas.List)
 			orderBlock(&ncas.Body, o.free)
 		}
@@ -1056,7 +1053,6 @@ func (o *orderState) stmt(n ir.Node) {
 
 func hasDefaultCase(n *ir.SwitchStmt) bool {
 	for _, ncas := range n.Cases {
-		ncas := ncas.(*ir.CaseStmt)
 		if len(ncas.List) == 0 {
 			return true
 		}
diff --git a/src/cmd/compile/internal/walk/select.go b/src/cmd/compile/internal/walk/select.go
index 5e03732169..0b7e7e99fb 100644
--- a/src/cmd/compile/internal/walk/select.go
+++ b/src/cmd/compile/internal/walk/select.go
@@ -21,7 +21,7 @@ func walkSelect(sel *ir.SelectStmt) {
 	sel.PtrInit().Set(nil)
 
 	init = append(init, walkSelectCases(sel.Cases)...)
-	sel.Cases = ir.Nodes{}
+	sel.Cases = nil
 
 	sel.Compiled.Set(init)
 	walkStmtList(sel.Compiled)
@@ -29,7 +29,7 @@ func walkSelect(sel *ir.SelectStmt) {
 	base.Pos = lno
 }
 
-func walkSelectCases(cases ir.Nodes) []ir.Node {
+func walkSelectCases(cases []*ir.CaseStmt) []ir.Node {
 	ncas := len(cases)
 	sellineno := base.Pos
 
@@ -40,7 +40,7 @@ func walkSelectCases(cases ir.Nodes) []ir.Node {
 
 	// optimization: one-case select: single op.
 	if ncas == 1 {
-		cas := cases[0].(*ir.CaseStmt)
+		cas := cases[0]
 		ir.SetPos(cas)
 		l := cas.Init()
 		if cas.Comm != nil { // not default:
@@ -75,7 +75,6 @@ func walkSelectCases(cases ir.Nodes) []ir.Node {
 	// this rewrite is used by both the general code and the next optimization.
 	var dflt *ir.CaseStmt
 	for _, cas := range cases {
-		cas := cas.(*ir.CaseStmt)
 		ir.SetPos(cas)
 		n := cas.Comm
 		if n == nil {
@@ -99,9 +98,9 @@ func walkSelectCases(cases ir.Nodes) []ir.Node {
 
 	// optimization: two-case select but one is default: single non-blocking op.
 	if ncas == 2 && dflt != nil {
-		cas := cases[0].(*ir.CaseStmt)
+		cas := cases[0]
 		if cas == dflt {
-			cas = cases[1].(*ir.CaseStmt)
+			cas = cases[1]
 		}
 
 		n := cas.Comm
@@ -170,7 +169,6 @@ func walkSelectCases(cases ir.Nodes) []ir.Node {
 
 	// register cases
 	for _, cas := range cases {
-		cas := cas.(*ir.CaseStmt)
 		ir.SetPos(cas)
 
 		init = append(init, cas.Init()...)
diff --git a/src/cmd/compile/internal/walk/switch.go b/src/cmd/compile/internal/walk/switch.go
index 141d2e5e05..de0b471b34 100644
--- a/src/cmd/compile/internal/walk/switch.go
+++ b/src/cmd/compile/internal/walk/switch.go
@@ -71,7 +71,6 @@ func walkSwitchExpr(sw *ir.SwitchStmt) {
 	var defaultGoto ir.Node
 	var body ir.Nodes
 	for _, ncase := range sw.Cases {
-		ncase := ncase.(*ir.CaseStmt)
 		label := typecheck.AutoLabel(".s")
 		jmp := ir.NewBranchStmt(ncase.Pos(), ir.OGOTO, label)
 
@@ -96,7 +95,7 @@ func walkSwitchExpr(sw *ir.SwitchStmt) {
 			body.Append(br)
 		}
 	}
-	sw.Cases.Set(nil)
+	sw.Cases = nil
 
 	if defaultGoto == nil {
 		br := ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)
@@ -259,7 +258,6 @@ func allCaseExprsAreSideEffectFree(sw *ir.SwitchStmt) bool {
 	// enough.
 
 	for _, ncase := range sw.Cases {
-		ncase := ncase.(*ir.CaseStmt)
 		for _, v := range ncase.List {
 			if v.Op() != ir.OLITERAL {
 				return false
@@ -325,7 +323,6 @@ func walkSwitchType(sw *ir.SwitchStmt) {
 	var defaultGoto, nilGoto ir.Node
 	var body ir.Nodes
 	for _, ncase := range sw.Cases {
-		ncase := ncase.(*ir.CaseStmt)
 		caseVar := ncase.Var
 
 		// For single-type cases with an interface type,
@@ -384,7 +381,7 @@ func walkSwitchType(sw *ir.SwitchStmt) {
 		body.Append(ncase.Body...)
 		body.Append(br)
 	}
-	sw.Cases.Set(nil)
+	sw.Cases = nil
 
 	if defaultGoto == nil {
 		defaultGoto = br
-- 
GitLab


From ed9772e130d81b3a5a7b9e9b58e8d48a5ec4c319 Mon Sep 17 00:00:00 2001
From: Meng Zhuo <mzh@golangcn.org>
Date: Mon, 28 Dec 2020 15:22:47 +0800
Subject: [PATCH 0351/2400] [dev.regabi] cmd/compile: add explicit file name in
 types generation

The stringer using `go list` for the type detection, which depends on
GOROOT. Unfortunally by changing GOROOT to develop path will raise
version mismatch with internal packages.

Update #43369

Change-Id: Id81334ea5f1ecdbfa81eb2d162944d65664ce727
Reviewed-on: https://go-review.googlesource.com/c/go/+/280572
Trust: Meng Zhuo <mzh@golangcn.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/types/alg.go                |  2 +-
 src/cmd/compile/internal/types/algkind_string.go     |  2 +-
 src/cmd/compile/internal/types/goversion.go          |  2 --
 .../types/{etype_string.go => kind_string.go}        | 12 ++++++------
 src/cmd/compile/internal/types/type.go               |  4 ++--
 5 files changed, 10 insertions(+), 12 deletions(-)
 rename src/cmd/compile/internal/types/{etype_string.go => kind_string.go} (59%)

diff --git a/src/cmd/compile/internal/types/alg.go b/src/cmd/compile/internal/types/alg.go
index 14200e0d16..f1a472cca5 100644
--- a/src/cmd/compile/internal/types/alg.go
+++ b/src/cmd/compile/internal/types/alg.go
@@ -10,7 +10,7 @@ import "cmd/compile/internal/base"
 // hashing a Type.
 type AlgKind int
 
-//go:generate stringer -type AlgKind -trimprefix A
+//go:generate stringer -type AlgKind -trimprefix A alg.go
 
 const (
 	// These values are known by runtime.
diff --git a/src/cmd/compile/internal/types/algkind_string.go b/src/cmd/compile/internal/types/algkind_string.go
index 8c5a0bc287..a1b518e4dd 100644
--- a/src/cmd/compile/internal/types/algkind_string.go
+++ b/src/cmd/compile/internal/types/algkind_string.go
@@ -1,4 +1,4 @@
-// Code generated by "stringer -type AlgKind -trimprefix A"; DO NOT EDIT.
+// Code generated by "stringer -type AlgKind -trimprefix A alg.go"; DO NOT EDIT.
 
 package types
 
diff --git a/src/cmd/compile/internal/types/goversion.go b/src/cmd/compile/internal/types/goversion.go
index 2265f472cf..1a324aa42f 100644
--- a/src/cmd/compile/internal/types/goversion.go
+++ b/src/cmd/compile/internal/types/goversion.go
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:generate go run mkbuiltin.go
-
 package types
 
 import (
diff --git a/src/cmd/compile/internal/types/etype_string.go b/src/cmd/compile/internal/types/kind_string.go
similarity index 59%
rename from src/cmd/compile/internal/types/etype_string.go
rename to src/cmd/compile/internal/types/kind_string.go
index e7698296ab..1e1e846240 100644
--- a/src/cmd/compile/internal/types/etype_string.go
+++ b/src/cmd/compile/internal/types/kind_string.go
@@ -1,4 +1,4 @@
-// Code generated by "stringer -type EType -trimprefix T"; DO NOT EDIT.
+// Code generated by "stringer -type Kind -trimprefix T type.go"; DO NOT EDIT.
 
 package types
 
@@ -48,13 +48,13 @@ func _() {
 	_ = x[NTYPE-37]
 }
 
-const _EType_name = "xxxINT8UINT8INT16UINT16INT32UINT32INT64UINT64INTUINTUINTPTRCOMPLEX64COMPLEX128FLOAT32FLOAT64BOOLPTRFUNCSLICEARRAYSTRUCTCHANMAPINTERFORWANYSTRINGUNSAFEPTRIDEALNILBLANKFUNCARGSCHANARGSSSATUPLERESULTSNTYPE"
+const _Kind_name = "xxxINT8UINT8INT16UINT16INT32UINT32INT64UINT64INTUINTUINTPTRCOMPLEX64COMPLEX128FLOAT32FLOAT64BOOLPTRFUNCSLICEARRAYSTRUCTCHANMAPINTERFORWANYSTRINGUNSAFEPTRIDEALNILBLANKFUNCARGSCHANARGSSSATUPLERESULTSNTYPE"
 
-var _EType_index = [...]uint8{0, 3, 7, 12, 17, 23, 28, 34, 39, 45, 48, 52, 59, 68, 78, 85, 92, 96, 99, 103, 108, 113, 119, 123, 126, 131, 135, 138, 144, 153, 158, 161, 166, 174, 182, 185, 190, 197, 202}
+var _Kind_index = [...]uint8{0, 3, 7, 12, 17, 23, 28, 34, 39, 45, 48, 52, 59, 68, 78, 85, 92, 96, 99, 103, 108, 113, 119, 123, 126, 131, 135, 138, 144, 153, 158, 161, 166, 174, 182, 185, 190, 197, 202}
 
 func (i Kind) String() string {
-	if i >= Kind(len(_EType_index)-1) {
-		return "EType(" + strconv.FormatInt(int64(i), 10) + ")"
+	if i >= Kind(len(_Kind_index)-1) {
+		return "Kind(" + strconv.FormatInt(int64(i), 10) + ")"
 	}
-	return _EType_name[_EType_index[i]:_EType_index[i+1]]
+	return _Kind_name[_Kind_index[i]:_Kind_index[i+1]]
 }
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index b5557b492e..6feedbfabc 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -33,9 +33,9 @@ type VarObject interface {
 	RecordFrameOffset(int64) // save frame offset
 }
 
-//go:generate stringer -type EType -trimprefix T
+//go:generate stringer -type Kind -trimprefix T type.go
 
-// EType describes a kind of type.
+// Kind describes a kind of type.
 type Kind uint8
 
 const (
-- 
GitLab


From 2ecf52b841cd48e76df1fe721d29a972c22bf93f Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 26 Dec 2020 22:42:17 -0800
Subject: [PATCH 0352/2400] [dev.regabi] cmd/compile: separate CommStmt from
 CaseStmt

Like go/ast and cmd/compile/internal/syntax before it, package ir now
has separate concrete representations for switch-case clauses and
select-communication clauses.

Passes toolstash -cmp.

Change-Id: I32667cbae251fe7881be0f434388478433b2414f
Reviewed-on: https://go-review.googlesource.com/c/go/+/280443
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/ir/mknode.go         |  7 +++
 src/cmd/compile/internal/ir/node_gen.go       | 31 ++++++++--
 src/cmd/compile/internal/ir/stmt.go           | 62 +++++++++++++++----
 src/cmd/compile/internal/noder/noder.go       |  6 +-
 src/cmd/compile/internal/typecheck/iexport.go | 11 +++-
 src/cmd/compile/internal/typecheck/iimport.go | 10 ++-
 src/cmd/compile/internal/walk/select.go       |  8 +--
 7 files changed, 109 insertions(+), 26 deletions(-)

diff --git a/src/cmd/compile/internal/ir/mknode.go b/src/cmd/compile/internal/ir/mknode.go
index edf3ee501c..bc6fa3cd30 100644
--- a/src/cmd/compile/internal/ir/mknode.go
+++ b/src/cmd/compile/internal/ir/mknode.go
@@ -38,6 +38,7 @@ func main() {
 	ntypeType := lookup("Ntype")
 	nodesType := lookup("Nodes")
 	slicePtrCaseStmtType := types.NewSlice(types.NewPointer(lookup("CaseStmt")))
+	slicePtrCommStmtType := types.NewSlice(types.NewPointer(lookup("CommStmt")))
 	ptrFieldType := types.NewPointer(lookup("Field"))
 	slicePtrFieldType := types.NewSlice(ptrFieldType)
 	ptrIdentType := types.NewPointer(lookup("Ident"))
@@ -79,6 +80,8 @@ func main() {
 					fmt.Fprintf(&buf, "c.%s = c.%s.Copy()\n", name, name)
 				case is(slicePtrCaseStmtType):
 					fmt.Fprintf(&buf, "c.%s = copyCases(c.%s)\n", name, name)
+				case is(slicePtrCommStmtType):
+					fmt.Fprintf(&buf, "c.%s = copyComms(c.%s)\n", name, name)
 				case is(ptrFieldType):
 					fmt.Fprintf(&buf, "if c.%s != nil { c.%s = c.%s.copy() }\n", name, name, name)
 				case is(slicePtrFieldType):
@@ -99,6 +102,8 @@ func main() {
 				fmt.Fprintf(&buf, "err = maybeDoList(n.%s, err, do)\n", name)
 			case is(slicePtrCaseStmtType):
 				fmt.Fprintf(&buf, "err = maybeDoCases(n.%s, err, do)\n", name)
+			case is(slicePtrCommStmtType):
+				fmt.Fprintf(&buf, "err = maybeDoComms(n.%s, err, do)\n", name)
 			case is(ptrFieldType):
 				fmt.Fprintf(&buf, "err = maybeDoField(n.%s, err, do)\n", name)
 			case is(slicePtrFieldType):
@@ -120,6 +125,8 @@ func main() {
 				fmt.Fprintf(&buf, "editList(n.%s, edit)\n", name)
 			case is(slicePtrCaseStmtType):
 				fmt.Fprintf(&buf, "editCases(n.%s, edit)\n", name)
+			case is(slicePtrCommStmtType):
+				fmt.Fprintf(&buf, "editComms(n.%s, edit)\n", name)
 			case is(ptrFieldType):
 				fmt.Fprintf(&buf, "editField(n.%s, edit)\n", name)
 			case is(slicePtrFieldType):
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index 041855bbe9..5796544b48 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -239,7 +239,6 @@ func (n *CaseStmt) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.init, err, do)
 	err = maybeDo(n.Var, err, do)
 	err = maybeDoList(n.List, err, do)
-	err = maybeDo(n.Comm, err, do)
 	err = maybeDoList(n.Body, err, do)
 	return err
 }
@@ -247,7 +246,6 @@ func (n *CaseStmt) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	n.Var = maybeEdit(n.Var, edit)
 	editList(n.List, edit)
-	n.Comm = maybeEdit(n.Comm, edit)
 	editList(n.Body, edit)
 }
 
@@ -295,6 +293,29 @@ func (n *ClosureReadExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 }
 
+func (n *CommStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *CommStmt) copy() Node {
+	c := *n
+	c.init = c.init.Copy()
+	c.List = c.List.Copy()
+	c.Body = c.Body.Copy()
+	return &c
+}
+func (n *CommStmt) doChildren(do func(Node) error) error {
+	var err error
+	err = maybeDoList(n.init, err, do)
+	err = maybeDoList(n.List, err, do)
+	err = maybeDo(n.Comm, err, do)
+	err = maybeDoList(n.Body, err, do)
+	return err
+}
+func (n *CommStmt) editChildren(edit func(Node) Node) {
+	editList(n.init, edit)
+	editList(n.List, edit)
+	n.Comm = maybeEdit(n.Comm, edit)
+	editList(n.Body, edit)
+}
+
 func (n *CompLitExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *CompLitExpr) copy() Node {
 	c := *n
@@ -781,20 +802,20 @@ func (n *SelectStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *SelectStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
-	c.Cases = copyCases(c.Cases)
+	c.Cases = copyComms(c.Cases)
 	c.Compiled = c.Compiled.Copy()
 	return &c
 }
 func (n *SelectStmt) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
-	err = maybeDoCases(n.Cases, err, do)
+	err = maybeDoComms(n.Cases, err, do)
 	err = maybeDoList(n.Compiled, err, do)
 	return err
 }
 func (n *SelectStmt) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
-	editCases(n.Cases, edit)
+	editComms(n.Cases, edit)
 	editList(n.Compiled, edit)
 }
 
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index ce775a8529..181a0fd582 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -178,19 +178,17 @@ type CaseStmt struct {
 	miniStmt
 	Var  Node  // declared variable for this case in type switch
 	List Nodes // list of expressions for switch, early select
-	Comm Node  // communication case (Exprs[0]) after select is type-checked
 	Body Nodes
 }
 
 func NewCaseStmt(pos src.XPos, list, body []Node) *CaseStmt {
-	n := &CaseStmt{}
+	n := &CaseStmt{List: list, Body: body}
 	n.pos = pos
 	n.op = OCASE
-	n.List.Set(list)
-	n.Body.Set(body)
 	return n
 }
 
+// TODO(mdempsky): Generate these with mknode.go.
 func copyCases(list []*CaseStmt) []*CaseStmt {
 	if list == nil {
 		return nil
@@ -199,7 +197,6 @@ func copyCases(list []*CaseStmt) []*CaseStmt {
 	copy(c, list)
 	return c
 }
-
 func maybeDoCases(list []*CaseStmt, err error, do func(Node) error) error {
 	if err != nil {
 		return err
@@ -213,7 +210,6 @@ func maybeDoCases(list []*CaseStmt, err error, do func(Node) error) error {
 	}
 	return nil
 }
-
 func editCases(list []*CaseStmt, edit func(Node) Node) {
 	for i, x := range list {
 		if x != nil {
@@ -222,6 +218,50 @@ func editCases(list []*CaseStmt, edit func(Node) Node) {
 	}
 }
 
+type CommStmt struct {
+	miniStmt
+	List Nodes // list of expressions for switch, early select
+	Comm Node  // communication case (Exprs[0]) after select is type-checked
+	Body Nodes
+}
+
+func NewCommStmt(pos src.XPos, list, body []Node) *CommStmt {
+	n := &CommStmt{List: list, Body: body}
+	n.pos = pos
+	n.op = OCASE
+	return n
+}
+
+// TODO(mdempsky): Generate these with mknode.go.
+func copyComms(list []*CommStmt) []*CommStmt {
+	if list == nil {
+		return nil
+	}
+	c := make([]*CommStmt, len(list))
+	copy(c, list)
+	return c
+}
+func maybeDoComms(list []*CommStmt, err error, do func(Node) error) error {
+	if err != nil {
+		return err
+	}
+	for _, x := range list {
+		if x != nil {
+			if err := do(x); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+func editComms(list []*CommStmt, edit func(Node) Node) {
+	for i, x := range list {
+		if x != nil {
+			list[i] = edit(x).(*CommStmt)
+		}
+	}
+}
+
 // A ForStmt is a non-range for loop: for Init; Cond; Post { Body }
 // Op can be OFOR or OFORUNTIL (!Cond).
 type ForStmt struct {
@@ -365,18 +405,17 @@ func (n *ReturnStmt) SetOrig(x Node) { n.orig = x }
 type SelectStmt struct {
 	miniStmt
 	Label    *types.Sym
-	Cases    []*CaseStmt
+	Cases    []*CommStmt
 	HasBreak bool
 
 	// TODO(rsc): Instead of recording here, replace with a block?
 	Compiled Nodes // compiled form, after walkswitch
 }
 
-func NewSelectStmt(pos src.XPos, cases []*CaseStmt) *SelectStmt {
-	n := &SelectStmt{}
+func NewSelectStmt(pos src.XPos, cases []*CommStmt) *SelectStmt {
+	n := &SelectStmt{Cases: cases}
 	n.pos = pos
 	n.op = OSELECT
-	n.Cases = cases
 	return n
 }
 
@@ -407,10 +446,9 @@ type SwitchStmt struct {
 }
 
 func NewSwitchStmt(pos src.XPos, tag Node, cases []*CaseStmt) *SwitchStmt {
-	n := &SwitchStmt{Tag: tag}
+	n := &SwitchStmt{Tag: tag, Cases: cases}
 	n.pos = pos
 	n.op = OSWITCH
-	n.Cases = cases
 	return n
 }
 
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index b974448338..ff699cd54d 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -1266,8 +1266,8 @@ func (p *noder) simpleStmt(stmt syntax.SimpleStmt) []ir.Node {
 	return []ir.Node{p.stmt(stmt)}
 }
 
-func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []*ir.CaseStmt {
-	nodes := make([]*ir.CaseStmt, len(clauses))
+func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []*ir.CommStmt {
+	nodes := make([]*ir.CommStmt, len(clauses))
 	for i, clause := range clauses {
 		p.setlineno(clause)
 		if i > 0 {
@@ -1275,7 +1275,7 @@ func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []*
 		}
 		p.openScope(clause.Pos())
 
-		nodes[i] = ir.NewCaseStmt(p.pos(clause), p.simpleStmt(clause.Comm), p.stmts(clause.Body))
+		nodes[i] = ir.NewCommStmt(p.pos(clause), p.simpleStmt(clause.Comm), p.stmts(clause.Body))
 	}
 	if len(clauses) > 0 {
 		p.closeScope(rbrace)
diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index 19437a069e..ef2c4527a9 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -1144,7 +1144,7 @@ func (w *exportWriter) stmt(n ir.Node) {
 		w.op(n.Op())
 		w.pos(n.Pos())
 		w.stmtList(n.Init())
-		w.caseList(n.Cases, false)
+		w.commList(n.Cases)
 
 	case ir.OSWITCH:
 		n := n.(*ir.SwitchStmt)
@@ -1193,6 +1193,15 @@ func (w *exportWriter) caseList(cases []*ir.CaseStmt, namedTypeSwitch bool) {
 	}
 }
 
+func (w *exportWriter) commList(cases []*ir.CommStmt) {
+	w.uint64(uint64(len(cases)))
+	for _, cas := range cases {
+		w.pos(cas.Pos())
+		w.stmtList(cas.List)
+		w.stmtList(cas.Body)
+	}
+}
+
 func (w *exportWriter) exprList(list ir.Nodes) {
 	for _, n := range list {
 		w.expr(n)
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index fd8314b662..ba7ea2f156 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -789,6 +789,14 @@ func (r *importReader) caseList(switchExpr ir.Node) []*ir.CaseStmt {
 	return cases
 }
 
+func (r *importReader) commList() []*ir.CommStmt {
+	cases := make([]*ir.CommStmt, r.uint64())
+	for i := range cases {
+		cases[i] = ir.NewCommStmt(r.pos(), r.stmtList(), r.stmtList())
+	}
+	return cases
+}
+
 func (r *importReader) exprList() []ir.Node {
 	var list []ir.Node
 	for {
@@ -1035,7 +1043,7 @@ func (r *importReader) node() ir.Node {
 	case ir.OSELECT:
 		pos := r.pos()
 		init := r.stmtList()
-		n := ir.NewSelectStmt(pos, r.caseList(nil))
+		n := ir.NewSelectStmt(pos, r.commList())
 		n.PtrInit().Set(init)
 		return n
 
diff --git a/src/cmd/compile/internal/walk/select.go b/src/cmd/compile/internal/walk/select.go
index 0b7e7e99fb..f51684c9b6 100644
--- a/src/cmd/compile/internal/walk/select.go
+++ b/src/cmd/compile/internal/walk/select.go
@@ -29,7 +29,7 @@ func walkSelect(sel *ir.SelectStmt) {
 	base.Pos = lno
 }
 
-func walkSelectCases(cases []*ir.CaseStmt) []ir.Node {
+func walkSelectCases(cases []*ir.CommStmt) []ir.Node {
 	ncas := len(cases)
 	sellineno := base.Pos
 
@@ -73,7 +73,7 @@ func walkSelectCases(cases []*ir.CaseStmt) []ir.Node {
 
 	// convert case value arguments to addresses.
 	// this rewrite is used by both the general code and the next optimization.
-	var dflt *ir.CaseStmt
+	var dflt *ir.CommStmt
 	for _, cas := range cases {
 		ir.SetPos(cas)
 		n := cas.Comm
@@ -146,7 +146,7 @@ func walkSelectCases(cases []*ir.CaseStmt) []ir.Node {
 	if dflt != nil {
 		ncas--
 	}
-	casorder := make([]*ir.CaseStmt, ncas)
+	casorder := make([]*ir.CommStmt, ncas)
 	nsends, nrecvs := 0, 0
 
 	var init []ir.Node
@@ -242,7 +242,7 @@ func walkSelectCases(cases []*ir.CaseStmt) []ir.Node {
 	}
 
 	// dispatch cases
-	dispatch := func(cond ir.Node, cas *ir.CaseStmt) {
+	dispatch := func(cond ir.Node, cas *ir.CommStmt) {
 		cond = typecheck.Expr(cond)
 		cond = typecheck.DefaultLit(cond, nil)
 
-- 
GitLab


From 3bdafb0d82c9908ae04d2765847754df0646df35 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 26 Dec 2020 23:03:25 -0800
Subject: [PATCH 0353/2400] [dev.regabi] cmd/compile: remove CommStmt.List

Package syntax's parser already ensures that select communication
clauses only have one statement, so there's no need for ir's CommStmt
to need to represent more than one. Instead, noder can just directly
populate Comm in the first place.

Incidentally, this also revealed a latent issue in the inline-body
exporter: we were exporting List (where the case statement is before
type-checking), rather than Comm (where the case statement would be
after type-checking, when export happens).

Passes toolstash -cmp.

Change-Id: Ib4eb711527bed297c7332c79ed6e6562a1db2cfa
Reviewed-on: https://go-review.googlesource.com/c/go/+/280444
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/ir/node_gen.go       |  3 ---
 src/cmd/compile/internal/ir/stmt.go           | 13 ++++++-----
 src/cmd/compile/internal/noder/noder.go       | 23 ++++++++-----------
 src/cmd/compile/internal/typecheck/iexport.go |  2 +-
 src/cmd/compile/internal/typecheck/iimport.go |  6 +++--
 src/cmd/compile/internal/typecheck/stmt.go    | 18 +++++----------
 6 files changed, 28 insertions(+), 37 deletions(-)

diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index 5796544b48..7412969425 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -297,21 +297,18 @@ func (n *CommStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *CommStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
-	c.List = c.List.Copy()
 	c.Body = c.Body.Copy()
 	return &c
 }
 func (n *CommStmt) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
-	err = maybeDoList(n.List, err, do)
 	err = maybeDo(n.Comm, err, do)
 	err = maybeDoList(n.Body, err, do)
 	return err
 }
 func (n *CommStmt) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
-	editList(n.List, edit)
 	n.Comm = maybeEdit(n.Comm, edit)
 	editList(n.Body, edit)
 }
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index 181a0fd582..0f44acd8b4 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -220,13 +220,12 @@ func editCases(list []*CaseStmt, edit func(Node) Node) {
 
 type CommStmt struct {
 	miniStmt
-	List Nodes // list of expressions for switch, early select
-	Comm Node  // communication case (Exprs[0]) after select is type-checked
+	Comm Node  // communication case
 	Body Nodes
 }
 
-func NewCommStmt(pos src.XPos, list, body []Node) *CommStmt {
-	n := &CommStmt{List: list, Body: body}
+func NewCommStmt(pos src.XPos, comm Node, body []Node) *CommStmt {
+	n := &CommStmt{Comm: comm, Body: body}
 	n.pos = pos
 	n.op = OCASE
 	return n
@@ -274,11 +273,13 @@ type ForStmt struct {
 	HasBreak bool
 }
 
-func NewForStmt(pos src.XPos, init []Node, cond, post Node, body []Node) *ForStmt {
+func NewForStmt(pos src.XPos, init Node, cond, post Node, body []Node) *ForStmt {
 	n := &ForStmt{Cond: cond, Post: post}
 	n.pos = pos
 	n.op = OFOR
-	n.init.Set(init)
+	if init != nil {
+		n.init = []Node{init}
+	}
 	n.Body.Set(body)
 	return n
 }
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index ff699cd54d..19a88e21a2 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -1149,9 +1149,11 @@ func (p *noder) blockStmt(stmt *syntax.BlockStmt) []ir.Node {
 
 func (p *noder) ifStmt(stmt *syntax.IfStmt) ir.Node {
 	p.openScope(stmt.Pos())
-	init := p.simpleStmt(stmt.Init)
+	init := p.stmt(stmt.Init)
 	n := ir.NewIfStmt(p.pos(stmt), p.expr(stmt.Cond), p.blockStmt(stmt.Then), nil)
-	*n.PtrInit() = init
+	if init != nil {
+		*n.PtrInit() = []ir.Node{init}
+	}
 	if stmt.Else != nil {
 		e := p.stmt(stmt.Else)
 		if e.Op() == ir.OBLOCK {
@@ -1186,7 +1188,7 @@ func (p *noder) forStmt(stmt *syntax.ForStmt) ir.Node {
 		return n
 	}
 
-	n := ir.NewForStmt(p.pos(stmt), p.simpleStmt(stmt.Init), p.expr(stmt.Cond), p.stmt(stmt.Post), p.blockStmt(stmt.Body))
+	n := ir.NewForStmt(p.pos(stmt), p.stmt(stmt.Init), p.expr(stmt.Cond), p.stmt(stmt.Post), p.blockStmt(stmt.Body))
 	p.closeAnotherScope()
 	return n
 }
@@ -1194,9 +1196,11 @@ func (p *noder) forStmt(stmt *syntax.ForStmt) ir.Node {
 func (p *noder) switchStmt(stmt *syntax.SwitchStmt) ir.Node {
 	p.openScope(stmt.Pos())
 
-	init := p.simpleStmt(stmt.Init)
+	init := p.stmt(stmt.Init)
 	n := ir.NewSwitchStmt(p.pos(stmt), p.expr(stmt.Tag), nil)
-	*n.PtrInit() = init
+	if init != nil {
+		*n.PtrInit() = []ir.Node{init}
+	}
 
 	var tswitch *ir.TypeSwitchGuard
 	if l := n.Tag; l != nil && l.Op() == ir.OTYPESW {
@@ -1259,13 +1263,6 @@ func (p *noder) selectStmt(stmt *syntax.SelectStmt) ir.Node {
 	return ir.NewSelectStmt(p.pos(stmt), p.commClauses(stmt.Body, stmt.Rbrace))
 }
 
-func (p *noder) simpleStmt(stmt syntax.SimpleStmt) []ir.Node {
-	if stmt == nil {
-		return nil
-	}
-	return []ir.Node{p.stmt(stmt)}
-}
-
 func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []*ir.CommStmt {
 	nodes := make([]*ir.CommStmt, len(clauses))
 	for i, clause := range clauses {
@@ -1275,7 +1272,7 @@ func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []*
 		}
 		p.openScope(clause.Pos())
 
-		nodes[i] = ir.NewCommStmt(p.pos(clause), p.simpleStmt(clause.Comm), p.stmts(clause.Body))
+		nodes[i] = ir.NewCommStmt(p.pos(clause), p.stmt(clause.Comm), p.stmts(clause.Body))
 	}
 	if len(clauses) > 0 {
 		p.closeScope(rbrace)
diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index ef2c4527a9..bf093c60c7 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -1197,7 +1197,7 @@ func (w *exportWriter) commList(cases []*ir.CommStmt) {
 	w.uint64(uint64(len(cases)))
 	for _, cas := range cases {
 		w.pos(cas.Pos())
-		w.stmtList(cas.List)
+		w.node(cas.Comm)
 		w.stmtList(cas.Body)
 	}
 }
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index ba7ea2f156..af2dd84a38 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -792,7 +792,7 @@ func (r *importReader) caseList(switchExpr ir.Node) []*ir.CaseStmt {
 func (r *importReader) commList() []*ir.CommStmt {
 	cases := make([]*ir.CommStmt, r.uint64())
 	for i := range cases {
-		cases[i] = ir.NewCommStmt(r.pos(), r.stmtList(), r.stmtList())
+		cases[i] = ir.NewCommStmt(r.pos(), r.node(), r.stmtList())
 	}
 	return cases
 }
@@ -1033,7 +1033,9 @@ func (r *importReader) node() ir.Node {
 	case ir.OFOR:
 		pos, init := r.pos(), r.stmtList()
 		cond, post := r.exprsOrNil()
-		return ir.NewForStmt(pos, init, cond, post, r.stmtList())
+		n := ir.NewForStmt(pos, nil, cond, post, r.stmtList())
+		n.PtrInit().Set(init)
+		return n
 
 	case ir.ORANGE:
 		pos := r.pos()
diff --git a/src/cmd/compile/internal/typecheck/stmt.go b/src/cmd/compile/internal/typecheck/stmt.go
index 03c3e399eb..bfeea06e83 100644
--- a/src/cmd/compile/internal/typecheck/stmt.go
+++ b/src/cmd/compile/internal/typecheck/stmt.go
@@ -360,29 +360,23 @@ func tcReturn(n *ir.ReturnStmt) ir.Node {
 
 // select
 func tcSelect(sel *ir.SelectStmt) {
-	var def ir.Node
+	var def *ir.CommStmt
 	lno := ir.SetPos(sel)
 	Stmts(sel.Init())
 	for _, ncase := range sel.Cases {
-		if len(ncase.List) == 0 {
+		if ncase.Comm == nil {
 			// default
 			if def != nil {
 				base.ErrorfAt(ncase.Pos(), "multiple defaults in select (first at %v)", ir.Line(def))
 			} else {
 				def = ncase
 			}
-		} else if len(ncase.List) > 1 {
-			base.ErrorfAt(ncase.Pos(), "select cases cannot be lists")
 		} else {
-			ncase.List[0] = Stmt(ncase.List[0])
-			n := ncase.List[0]
+			n := Stmt(ncase.Comm)
 			ncase.Comm = n
-			ncase.List.Set(nil)
-			oselrecv2 := func(dst, recv ir.Node, colas bool) {
-				n := ir.NewAssignListStmt(n.Pos(), ir.OSELRECV2, nil, nil)
-				n.Lhs = []ir.Node{dst, ir.BlankNode}
-				n.Rhs = []ir.Node{recv}
-				n.Def = colas
+			oselrecv2 := func(dst, recv ir.Node, def bool) {
+				n := ir.NewAssignListStmt(n.Pos(), ir.OSELRECV2, []ir.Node{dst, ir.BlankNode}, []ir.Node{recv})
+				n.Def = def
 				n.SetTypecheck(1)
 				ncase.Comm = n
 			}
-- 
GitLab


From 5f3bd59a0d8a8d6feadc918078f153cc5d0447a8 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 26 Dec 2020 23:09:54 -0800
Subject: [PATCH 0354/2400] [dev.regabi] cmd/compile: remove some unneeded code
 in package ir

The deepCopy functions haven't been needed since we switched to using
Edit everywhere, and AddStringExpr no longer has an Alloc field that
needs special casing.

Passes toolstash -cmp.

Change-Id: I5bcc8c73d5cb784f7e57fb3162ae6e288e6c9392
Reviewed-on: https://go-review.googlesource.com/c/go/+/280445
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/ir/mknode.go |  4 ----
 src/cmd/compile/internal/ir/type.go   | 28 ---------------------------
 2 files changed, 32 deletions(-)

diff --git a/src/cmd/compile/internal/ir/mknode.go b/src/cmd/compile/internal/ir/mknode.go
index bc6fa3cd30..5c36b729c7 100644
--- a/src/cmd/compile/internal/ir/mknode.go
+++ b/src/cmd/compile/internal/ir/mknode.go
@@ -169,10 +169,6 @@ func forNodeFields(typName string, typ *types.Struct, f func(name string, is fun
 		case "orig":
 			continue
 		}
-		switch typName + "." + v.Name() {
-		case "AddStringExpr.Alloc":
-			continue
-		}
 		f(v.Name(), func(t types.Type) bool { return types.Identical(t, v.Type()) })
 	}
 }
diff --git a/src/cmd/compile/internal/ir/type.go b/src/cmd/compile/internal/ir/type.go
index 5e6d76229d..bd3a05d06e 100644
--- a/src/cmd/compile/internal/ir/type.go
+++ b/src/cmd/compile/internal/ir/type.go
@@ -115,14 +115,6 @@ func (n *StructType) SetOTYPE(t *types.Type) {
 	n.Fields = nil
 }
 
-func deepCopyFields(pos src.XPos, fields []*Field) []*Field {
-	var out []*Field
-	for _, f := range fields {
-		out = append(out, f.deepCopy(pos))
-	}
-	return out
-}
-
 // An InterfaceType represents a struct { ... } type syntax.
 type InterfaceType struct {
 	miniType
@@ -250,26 +242,6 @@ func editFields(list []*Field, edit func(Node) Node) {
 	}
 }
 
-func (f *Field) deepCopy(pos src.XPos) *Field {
-	if f == nil {
-		return nil
-	}
-	fpos := pos
-	if !pos.IsKnown() {
-		fpos = f.Pos
-	}
-	decl := f.Decl
-	if decl != nil {
-		decl = DeepCopy(pos, decl).(*Name)
-	}
-	ntype := f.Ntype
-	if ntype != nil {
-		ntype = DeepCopy(pos, ntype).(Ntype)
-	}
-	// No keyed literal here: if a new struct field is added, we want this to stop compiling.
-	return &Field{fpos, f.Sym, ntype, f.Type, f.Embedded, f.IsDDD, f.Note, decl}
-}
-
 // A SliceType represents a []Elem type syntax.
 // If DDD is true, it's the ...Elem at the end of a function list.
 type SliceType struct {
-- 
GitLab


From f8afb8216ad69ed0c4e5ac8b5ad86cc0cb78749d Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 26 Dec 2020 23:21:20 -0800
Subject: [PATCH 0355/2400] [dev.regabi] cmd/compile: rename CommStmt and
 CaseStmt [generated]

Rename these two AST nodes to match their cmd/compile/internal/syntax
and go/ast counterparts.

Passes toolstash -cmp.

[git-generate]
cd src/cmd/compile/internal/ir
rf '
	mv CaseStmt CaseClause
	mv CommStmt CommClause
'
sed -E -i -e 's/(Case|Comm)Stmt/\1Clause/g' mknode.go

Change-Id: I19fba0323a5de1e71346622857011b2f7879bcef
Reviewed-on: https://go-review.googlesource.com/c/go/+/280446
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/ir/fmt.go            |  2 +-
 src/cmd/compile/internal/ir/mknode.go         | 16 +++----
 src/cmd/compile/internal/ir/node_gen.go       | 16 +++----
 src/cmd/compile/internal/ir/stmt.go           | 44 +++++++++----------
 src/cmd/compile/internal/noder/noder.go       |  8 ++--
 src/cmd/compile/internal/typecheck/iexport.go |  4 +-
 src/cmd/compile/internal/typecheck/iimport.go |  8 ++--
 src/cmd/compile/internal/typecheck/stmt.go    |  2 +-
 src/cmd/compile/internal/walk/select.go       |  8 ++--
 9 files changed, 54 insertions(+), 54 deletions(-)

diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index f52c639c51..49f451a5d8 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -478,7 +478,7 @@ func stmtFmt(n Node, s fmt.State) {
 		fmt.Fprintf(s, " { %v }", n.Cases)
 
 	case OCASE:
-		n := n.(*CaseStmt)
+		n := n.(*CaseClause)
 		if len(n.List) != 0 {
 			fmt.Fprintf(s, "case %.v", n.List)
 		} else {
diff --git a/src/cmd/compile/internal/ir/mknode.go b/src/cmd/compile/internal/ir/mknode.go
index 5c36b729c7..3b5da32d8c 100644
--- a/src/cmd/compile/internal/ir/mknode.go
+++ b/src/cmd/compile/internal/ir/mknode.go
@@ -37,8 +37,8 @@ func main() {
 	nodeType := lookup("Node")
 	ntypeType := lookup("Ntype")
 	nodesType := lookup("Nodes")
-	slicePtrCaseStmtType := types.NewSlice(types.NewPointer(lookup("CaseStmt")))
-	slicePtrCommStmtType := types.NewSlice(types.NewPointer(lookup("CommStmt")))
+	slicePtrCaseClauseType := types.NewSlice(types.NewPointer(lookup("CaseClause")))
+	slicePtrCommClauseType := types.NewSlice(types.NewPointer(lookup("CommClause")))
 	ptrFieldType := types.NewPointer(lookup("Field"))
 	slicePtrFieldType := types.NewSlice(ptrFieldType)
 	ptrIdentType := types.NewPointer(lookup("Ident"))
@@ -78,9 +78,9 @@ func main() {
 				switch {
 				case is(nodesType):
 					fmt.Fprintf(&buf, "c.%s = c.%s.Copy()\n", name, name)
-				case is(slicePtrCaseStmtType):
+				case is(slicePtrCaseClauseType):
 					fmt.Fprintf(&buf, "c.%s = copyCases(c.%s)\n", name, name)
-				case is(slicePtrCommStmtType):
+				case is(slicePtrCommClauseType):
 					fmt.Fprintf(&buf, "c.%s = copyComms(c.%s)\n", name, name)
 				case is(ptrFieldType):
 					fmt.Fprintf(&buf, "if c.%s != nil { c.%s = c.%s.copy() }\n", name, name, name)
@@ -100,9 +100,9 @@ func main() {
 				fmt.Fprintf(&buf, "err = maybeDo(n.%s, err, do)\n", name)
 			case is(nodesType):
 				fmt.Fprintf(&buf, "err = maybeDoList(n.%s, err, do)\n", name)
-			case is(slicePtrCaseStmtType):
+			case is(slicePtrCaseClauseType):
 				fmt.Fprintf(&buf, "err = maybeDoCases(n.%s, err, do)\n", name)
-			case is(slicePtrCommStmtType):
+			case is(slicePtrCommClauseType):
 				fmt.Fprintf(&buf, "err = maybeDoComms(n.%s, err, do)\n", name)
 			case is(ptrFieldType):
 				fmt.Fprintf(&buf, "err = maybeDoField(n.%s, err, do)\n", name)
@@ -123,9 +123,9 @@ func main() {
 				fmt.Fprintf(&buf, "n.%s = toNtype(maybeEdit(n.%s, edit))\n", name, name)
 			case is(nodesType):
 				fmt.Fprintf(&buf, "editList(n.%s, edit)\n", name)
-			case is(slicePtrCaseStmtType):
+			case is(slicePtrCaseClauseType):
 				fmt.Fprintf(&buf, "editCases(n.%s, edit)\n", name)
-			case is(slicePtrCommStmtType):
+			case is(slicePtrCommClauseType):
 				fmt.Fprintf(&buf, "editComms(n.%s, edit)\n", name)
 			case is(ptrFieldType):
 				fmt.Fprintf(&buf, "editField(n.%s, edit)\n", name)
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index 7412969425..27a5311748 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -226,15 +226,15 @@ func (n *CallPartExpr) editChildren(edit func(Node) Node) {
 	n.X = maybeEdit(n.X, edit)
 }
 
-func (n *CaseStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *CaseStmt) copy() Node {
+func (n *CaseClause) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *CaseClause) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
 	c.List = c.List.Copy()
 	c.Body = c.Body.Copy()
 	return &c
 }
-func (n *CaseStmt) doChildren(do func(Node) error) error {
+func (n *CaseClause) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
 	err = maybeDo(n.Var, err, do)
@@ -242,7 +242,7 @@ func (n *CaseStmt) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.Body, err, do)
 	return err
 }
-func (n *CaseStmt) editChildren(edit func(Node) Node) {
+func (n *CaseClause) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	n.Var = maybeEdit(n.Var, edit)
 	editList(n.List, edit)
@@ -293,21 +293,21 @@ func (n *ClosureReadExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 }
 
-func (n *CommStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *CommStmt) copy() Node {
+func (n *CommClause) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *CommClause) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
 	c.Body = c.Body.Copy()
 	return &c
 }
-func (n *CommStmt) doChildren(do func(Node) error) error {
+func (n *CommClause) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
 	err = maybeDo(n.Comm, err, do)
 	err = maybeDoList(n.Body, err, do)
 	return err
 }
-func (n *CommStmt) editChildren(edit func(Node) Node) {
+func (n *CommClause) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	n.Comm = maybeEdit(n.Comm, edit)
 	editList(n.Body, edit)
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index 0f44acd8b4..de152fec72 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -173,31 +173,31 @@ func NewBranchStmt(pos src.XPos, op Op, label *types.Sym) *BranchStmt {
 
 func (n *BranchStmt) Sym() *types.Sym { return n.Label }
 
-// A CaseStmt is a case statement in a switch or select: case List: Body.
-type CaseStmt struct {
+// A CaseClause is a case statement in a switch or select: case List: Body.
+type CaseClause struct {
 	miniStmt
 	Var  Node  // declared variable for this case in type switch
 	List Nodes // list of expressions for switch, early select
 	Body Nodes
 }
 
-func NewCaseStmt(pos src.XPos, list, body []Node) *CaseStmt {
-	n := &CaseStmt{List: list, Body: body}
+func NewCaseStmt(pos src.XPos, list, body []Node) *CaseClause {
+	n := &CaseClause{List: list, Body: body}
 	n.pos = pos
 	n.op = OCASE
 	return n
 }
 
 // TODO(mdempsky): Generate these with mknode.go.
-func copyCases(list []*CaseStmt) []*CaseStmt {
+func copyCases(list []*CaseClause) []*CaseClause {
 	if list == nil {
 		return nil
 	}
-	c := make([]*CaseStmt, len(list))
+	c := make([]*CaseClause, len(list))
 	copy(c, list)
 	return c
 }
-func maybeDoCases(list []*CaseStmt, err error, do func(Node) error) error {
+func maybeDoCases(list []*CaseClause, err error, do func(Node) error) error {
 	if err != nil {
 		return err
 	}
@@ -210,37 +210,37 @@ func maybeDoCases(list []*CaseStmt, err error, do func(Node) error) error {
 	}
 	return nil
 }
-func editCases(list []*CaseStmt, edit func(Node) Node) {
+func editCases(list []*CaseClause, edit func(Node) Node) {
 	for i, x := range list {
 		if x != nil {
-			list[i] = edit(x).(*CaseStmt)
+			list[i] = edit(x).(*CaseClause)
 		}
 	}
 }
 
-type CommStmt struct {
+type CommClause struct {
 	miniStmt
-	Comm Node  // communication case
+	Comm Node // communication case
 	Body Nodes
 }
 
-func NewCommStmt(pos src.XPos, comm Node, body []Node) *CommStmt {
-	n := &CommStmt{Comm: comm, Body: body}
+func NewCommStmt(pos src.XPos, comm Node, body []Node) *CommClause {
+	n := &CommClause{Comm: comm, Body: body}
 	n.pos = pos
 	n.op = OCASE
 	return n
 }
 
 // TODO(mdempsky): Generate these with mknode.go.
-func copyComms(list []*CommStmt) []*CommStmt {
+func copyComms(list []*CommClause) []*CommClause {
 	if list == nil {
 		return nil
 	}
-	c := make([]*CommStmt, len(list))
+	c := make([]*CommClause, len(list))
 	copy(c, list)
 	return c
 }
-func maybeDoComms(list []*CommStmt, err error, do func(Node) error) error {
+func maybeDoComms(list []*CommClause, err error, do func(Node) error) error {
 	if err != nil {
 		return err
 	}
@@ -253,10 +253,10 @@ func maybeDoComms(list []*CommStmt, err error, do func(Node) error) error {
 	}
 	return nil
 }
-func editComms(list []*CommStmt, edit func(Node) Node) {
+func editComms(list []*CommClause, edit func(Node) Node) {
 	for i, x := range list {
 		if x != nil {
-			list[i] = edit(x).(*CommStmt)
+			list[i] = edit(x).(*CommClause)
 		}
 	}
 }
@@ -406,14 +406,14 @@ func (n *ReturnStmt) SetOrig(x Node) { n.orig = x }
 type SelectStmt struct {
 	miniStmt
 	Label    *types.Sym
-	Cases    []*CommStmt
+	Cases    []*CommClause
 	HasBreak bool
 
 	// TODO(rsc): Instead of recording here, replace with a block?
 	Compiled Nodes // compiled form, after walkswitch
 }
 
-func NewSelectStmt(pos src.XPos, cases []*CommStmt) *SelectStmt {
+func NewSelectStmt(pos src.XPos, cases []*CommClause) *SelectStmt {
 	n := &SelectStmt{Cases: cases}
 	n.pos = pos
 	n.op = OSELECT
@@ -438,7 +438,7 @@ func NewSendStmt(pos src.XPos, ch, value Node) *SendStmt {
 type SwitchStmt struct {
 	miniStmt
 	Tag      Node
-	Cases    []*CaseStmt
+	Cases    []*CaseClause
 	Label    *types.Sym
 	HasBreak bool
 
@@ -446,7 +446,7 @@ type SwitchStmt struct {
 	Compiled Nodes // compiled form, after walkswitch
 }
 
-func NewSwitchStmt(pos src.XPos, tag Node, cases []*CaseStmt) *SwitchStmt {
+func NewSwitchStmt(pos src.XPos, tag Node, cases []*CaseClause) *SwitchStmt {
 	n := &SwitchStmt{Tag: tag, Cases: cases}
 	n.pos = pos
 	n.op = OSWITCH
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 19a88e21a2..7c1f7595b3 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -1212,8 +1212,8 @@ func (p *noder) switchStmt(stmt *syntax.SwitchStmt) ir.Node {
 	return n
 }
 
-func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *ir.TypeSwitchGuard, rbrace syntax.Pos) []*ir.CaseStmt {
-	nodes := make([]*ir.CaseStmt, 0, len(clauses))
+func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *ir.TypeSwitchGuard, rbrace syntax.Pos) []*ir.CaseClause {
+	nodes := make([]*ir.CaseClause, 0, len(clauses))
 	for i, clause := range clauses {
 		p.setlineno(clause)
 		if i > 0 {
@@ -1263,8 +1263,8 @@ func (p *noder) selectStmt(stmt *syntax.SelectStmt) ir.Node {
 	return ir.NewSelectStmt(p.pos(stmt), p.commClauses(stmt.Body, stmt.Rbrace))
 }
 
-func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []*ir.CommStmt {
-	nodes := make([]*ir.CommStmt, len(clauses))
+func (p *noder) commClauses(clauses []*syntax.CommClause, rbrace syntax.Pos) []*ir.CommClause {
+	nodes := make([]*ir.CommClause, len(clauses))
 	for i, clause := range clauses {
 		p.setlineno(clause)
 		if i > 0 {
diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index bf093c60c7..3b071a61ab 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -1181,7 +1181,7 @@ func isNamedTypeSwitch(x ir.Node) bool {
 	return ok && guard.Tag != nil
 }
 
-func (w *exportWriter) caseList(cases []*ir.CaseStmt, namedTypeSwitch bool) {
+func (w *exportWriter) caseList(cases []*ir.CaseClause, namedTypeSwitch bool) {
 	w.uint64(uint64(len(cases)))
 	for _, cas := range cases {
 		w.pos(cas.Pos())
@@ -1193,7 +1193,7 @@ func (w *exportWriter) caseList(cases []*ir.CaseStmt, namedTypeSwitch bool) {
 	}
 }
 
-func (w *exportWriter) commList(cases []*ir.CommStmt) {
+func (w *exportWriter) commList(cases []*ir.CommClause) {
 	w.uint64(uint64(len(cases)))
 	for _, cas := range cases {
 		w.pos(cas.Pos())
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index af2dd84a38..cf2cf87492 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -767,10 +767,10 @@ func (r *importReader) stmtList() []ir.Node {
 	return list
 }
 
-func (r *importReader) caseList(switchExpr ir.Node) []*ir.CaseStmt {
+func (r *importReader) caseList(switchExpr ir.Node) []*ir.CaseClause {
 	namedTypeSwitch := isNamedTypeSwitch(switchExpr)
 
-	cases := make([]*ir.CaseStmt, r.uint64())
+	cases := make([]*ir.CaseClause, r.uint64())
 	for i := range cases {
 		cas := ir.NewCaseStmt(r.pos(), nil, nil)
 		cas.List.Set(r.stmtList())
@@ -789,8 +789,8 @@ func (r *importReader) caseList(switchExpr ir.Node) []*ir.CaseStmt {
 	return cases
 }
 
-func (r *importReader) commList() []*ir.CommStmt {
-	cases := make([]*ir.CommStmt, r.uint64())
+func (r *importReader) commList() []*ir.CommClause {
+	cases := make([]*ir.CommClause, r.uint64())
 	for i := range cases {
 		cases[i] = ir.NewCommStmt(r.pos(), r.node(), r.stmtList())
 	}
diff --git a/src/cmd/compile/internal/typecheck/stmt.go b/src/cmd/compile/internal/typecheck/stmt.go
index bfeea06e83..f5d36a663d 100644
--- a/src/cmd/compile/internal/typecheck/stmt.go
+++ b/src/cmd/compile/internal/typecheck/stmt.go
@@ -360,7 +360,7 @@ func tcReturn(n *ir.ReturnStmt) ir.Node {
 
 // select
 func tcSelect(sel *ir.SelectStmt) {
-	var def *ir.CommStmt
+	var def *ir.CommClause
 	lno := ir.SetPos(sel)
 	Stmts(sel.Init())
 	for _, ncase := range sel.Cases {
diff --git a/src/cmd/compile/internal/walk/select.go b/src/cmd/compile/internal/walk/select.go
index f51684c9b6..1c5e1d7e64 100644
--- a/src/cmd/compile/internal/walk/select.go
+++ b/src/cmd/compile/internal/walk/select.go
@@ -29,7 +29,7 @@ func walkSelect(sel *ir.SelectStmt) {
 	base.Pos = lno
 }
 
-func walkSelectCases(cases []*ir.CommStmt) []ir.Node {
+func walkSelectCases(cases []*ir.CommClause) []ir.Node {
 	ncas := len(cases)
 	sellineno := base.Pos
 
@@ -73,7 +73,7 @@ func walkSelectCases(cases []*ir.CommStmt) []ir.Node {
 
 	// convert case value arguments to addresses.
 	// this rewrite is used by both the general code and the next optimization.
-	var dflt *ir.CommStmt
+	var dflt *ir.CommClause
 	for _, cas := range cases {
 		ir.SetPos(cas)
 		n := cas.Comm
@@ -146,7 +146,7 @@ func walkSelectCases(cases []*ir.CommStmt) []ir.Node {
 	if dflt != nil {
 		ncas--
 	}
-	casorder := make([]*ir.CommStmt, ncas)
+	casorder := make([]*ir.CommClause, ncas)
 	nsends, nrecvs := 0, 0
 
 	var init []ir.Node
@@ -242,7 +242,7 @@ func walkSelectCases(cases []*ir.CommStmt) []ir.Node {
 	}
 
 	// dispatch cases
-	dispatch := func(cond ir.Node, cas *ir.CommStmt) {
+	dispatch := func(cond ir.Node, cas *ir.CommClause) {
 		cond = typecheck.Expr(cond)
 		cond = typecheck.DefaultLit(cond, nil)
 
-- 
GitLab


From 3383b5c74a4543d7232468201778a8db03cf133d Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 26 Dec 2020 23:46:36 -0800
Subject: [PATCH 0356/2400] [dev.regabi] cmd/compile: flatten dependency graph
 [generated]

This CL shuffles a couple functions around to help flatten the package
dependency graph somewhat:

1. ssa.LosesStmtMark is only ever used in associated with an
objw.Prog, so we might as well move it to that package. This removes a
dependency from objw (a relatively low-level utility package that
wraps cmd/internal/obj) on ssa (a large and relatively high-level
package).

2. Moves liveness.SetTypeBits into a new package typebits. A
single-function package is a bit on the silly side, but reflectdata
shouldn't need to depend on liveness (nor vice versa).

[git-generate]
cd src/cmd/compile/internal/ssa
rf '
	mv LosesStmtMark prog.go
	mv prog.go cmd/compile/internal/objw
'

cd ../liveness
rf '
	mv SetTypeBits Set
	mv Set typebits.go
	rm typebits.go:/Copyright/+4,/^package/-0
	mv typebits.go cmd/compile/internal/typebits
'

Change-Id: Ic9a983f0ad6c0cf1a537f99889699a8444699e6e
Reviewed-on: https://go-review.googlesource.com/c/go/+/280447
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/liveness/plive.go    | 87 ++-----------------
 src/cmd/compile/internal/objw/prog.go         | 12 ++-
 .../compile/internal/reflectdata/reflect.go   |  4 +-
 src/cmd/compile/internal/ssa/numberlines.go   | 10 ---
 src/cmd/compile/internal/ssagen/ssa.go        |  2 +-
 src/cmd/compile/internal/typebits/typebits.go | 87 +++++++++++++++++++
 6 files changed, 106 insertions(+), 96 deletions(-)
 create mode 100644 src/cmd/compile/internal/typebits/typebits.go

diff --git a/src/cmd/compile/internal/liveness/plive.go b/src/cmd/compile/internal/liveness/plive.go
index cf4debb795..89c70df65a 100644
--- a/src/cmd/compile/internal/liveness/plive.go
+++ b/src/cmd/compile/internal/liveness/plive.go
@@ -24,6 +24,7 @@ import (
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/objw"
 	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/typebits"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
@@ -375,82 +376,6 @@ func (lv *liveness) blockEffects(b *ssa.Block) *blockEffects {
 	return &lv.be[b.ID]
 }
 
-// NOTE: The bitmap for a specific type t could be cached in t after
-// the first run and then simply copied into bv at the correct offset
-// on future calls with the same type t.
-func SetTypeBits(t *types.Type, off int64, bv bitvec.BitVec) {
-	if t.Align > 0 && off&int64(t.Align-1) != 0 {
-		base.Fatalf("onebitwalktype1: invalid initial alignment: type %v has alignment %d, but offset is %v", t, t.Align, off)
-	}
-	if !t.HasPointers() {
-		// Note: this case ensures that pointers to go:notinheap types
-		// are not considered pointers by garbage collection and stack copying.
-		return
-	}
-
-	switch t.Kind() {
-	case types.TPTR, types.TUNSAFEPTR, types.TFUNC, types.TCHAN, types.TMAP:
-		if off&int64(types.PtrSize-1) != 0 {
-			base.Fatalf("onebitwalktype1: invalid alignment, %v", t)
-		}
-		bv.Set(int32(off / int64(types.PtrSize))) // pointer
-
-	case types.TSTRING:
-		// struct { byte *str; intgo len; }
-		if off&int64(types.PtrSize-1) != 0 {
-			base.Fatalf("onebitwalktype1: invalid alignment, %v", t)
-		}
-		bv.Set(int32(off / int64(types.PtrSize))) //pointer in first slot
-
-	case types.TINTER:
-		// struct { Itab *tab;	void *data; }
-		// or, when isnilinter(t)==true:
-		// struct { Type *type; void *data; }
-		if off&int64(types.PtrSize-1) != 0 {
-			base.Fatalf("onebitwalktype1: invalid alignment, %v", t)
-		}
-		// The first word of an interface is a pointer, but we don't
-		// treat it as such.
-		// 1. If it is a non-empty interface, the pointer points to an itab
-		//    which is always in persistentalloc space.
-		// 2. If it is an empty interface, the pointer points to a _type.
-		//   a. If it is a compile-time-allocated type, it points into
-		//      the read-only data section.
-		//   b. If it is a reflect-allocated type, it points into the Go heap.
-		//      Reflect is responsible for keeping a reference to
-		//      the underlying type so it won't be GCd.
-		// If we ever have a moving GC, we need to change this for 2b (as
-		// well as scan itabs to update their itab._type fields).
-		bv.Set(int32(off/int64(types.PtrSize) + 1)) // pointer in second slot
-
-	case types.TSLICE:
-		// struct { byte *array; uintgo len; uintgo cap; }
-		if off&int64(types.PtrSize-1) != 0 {
-			base.Fatalf("onebitwalktype1: invalid TARRAY alignment, %v", t)
-		}
-		bv.Set(int32(off / int64(types.PtrSize))) // pointer in first slot (BitsPointer)
-
-	case types.TARRAY:
-		elt := t.Elem()
-		if elt.Width == 0 {
-			// Short-circuit for #20739.
-			break
-		}
-		for i := int64(0); i < t.NumElem(); i++ {
-			SetTypeBits(elt, off, bv)
-			off += elt.Width
-		}
-
-	case types.TSTRUCT:
-		for _, f := range t.Fields().Slice() {
-			SetTypeBits(f.Type, off+f.Offset, bv)
-		}
-
-	default:
-		base.Fatalf("onebitwalktype1: unexpected type, %v", t)
-	}
-}
-
 // Generates live pointer value maps for arguments and local variables. The
 // this argument and the in arguments are always assumed live. The vars
 // argument is a slice of *Nodes.
@@ -463,10 +388,10 @@ func (lv *liveness) pointerMap(liveout bitvec.BitVec, vars []*ir.Name, args, loc
 		node := vars[i]
 		switch node.Class_ {
 		case ir.PAUTO:
-			SetTypeBits(node.Type(), node.FrameOffset()+lv.stkptrsize, locals)
+			typebits.Set(node.Type(), node.FrameOffset()+lv.stkptrsize, locals)
 
 		case ir.PPARAM, ir.PPARAMOUT:
-			SetTypeBits(node.Type(), node.FrameOffset(), args)
+			typebits.Set(node.Type(), node.FrameOffset(), args)
 		}
 	}
 }
@@ -1309,15 +1234,15 @@ func WriteFuncMap(fn *ir.Func) {
 	off = objw.Uint32(lsym, off, uint32(bv.N))
 
 	if ir.IsMethod(fn) {
-		SetTypeBits(fn.Type().Recvs(), 0, bv)
+		typebits.Set(fn.Type().Recvs(), 0, bv)
 	}
 	if fn.Type().NumParams() > 0 {
-		SetTypeBits(fn.Type().Params(), 0, bv)
+		typebits.Set(fn.Type().Params(), 0, bv)
 	}
 	off = objw.BitVec(lsym, off, bv)
 
 	if fn.Type().NumResults() > 0 {
-		SetTypeBits(fn.Type().Results(), 0, bv)
+		typebits.Set(fn.Type().Results(), 0, bv)
 		off = objw.BitVec(lsym, off, bv)
 	}
 
diff --git a/src/cmd/compile/internal/objw/prog.go b/src/cmd/compile/internal/objw/prog.go
index 54028e47fd..8d24f94aa5 100644
--- a/src/cmd/compile/internal/objw/prog.go
+++ b/src/cmd/compile/internal/objw/prog.go
@@ -33,7 +33,6 @@ package objw
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
-	"cmd/compile/internal/ssa"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
 	"cmd/internal/src"
@@ -173,7 +172,7 @@ func (pp *Progs) Prog(as obj.As) *obj.Prog {
 	p.Pos = pp.Pos
 	if pp.Pos.IsStmt() == src.PosIsStmt {
 		// Clear IsStmt for later Progs at this pos provided that as can be marked as a stmt
-		if ssa.LosesStmtMark(as) {
+		if LosesStmtMark(as) {
 			return p
 		}
 		pp.Pos = pp.Pos.WithNotStmt()
@@ -216,3 +215,12 @@ func (pp *Progs) SetText(fn *ir.Func) {
 	ptxt.From.Name = obj.NAME_EXTERN
 	ptxt.From.Sym = fn.LSym
 }
+
+// LosesStmtMark reports whether a prog with op as loses its statement mark on the way to DWARF.
+// The attributes from some opcodes are lost in translation.
+// TODO: this is an artifact of how funcpctab combines information for instructions at a single PC.
+// Should try to fix it there.
+func LosesStmtMark(as obj.As) bool {
+	// is_stmt does not work for these; it DOES for ANOP even though that generates no code.
+	return as == obj.APCDATA || as == obj.AFUNCDATA
+}
diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index 7c42421896..df80380fc1 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -16,8 +16,8 @@ import (
 	"cmd/compile/internal/escape"
 	"cmd/compile/internal/inline"
 	"cmd/compile/internal/ir"
-	"cmd/compile/internal/liveness"
 	"cmd/compile/internal/objw"
+	"cmd/compile/internal/typebits"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/gcprog"
@@ -1552,7 +1552,7 @@ func fillptrmask(t *types.Type, ptrmask []byte) {
 	}
 
 	vec := bitvec.New(8 * int32(len(ptrmask)))
-	liveness.SetTypeBits(t, 0, vec)
+	typebits.Set(t, 0, vec)
 
 	nptr := types.PtrDataSize(t) / int64(types.PtrSize)
 	for i := int64(0); i < nptr; i++ {
diff --git a/src/cmd/compile/internal/ssa/numberlines.go b/src/cmd/compile/internal/ssa/numberlines.go
index f4e62b88c4..2a9c8e4f32 100644
--- a/src/cmd/compile/internal/ssa/numberlines.go
+++ b/src/cmd/compile/internal/ssa/numberlines.go
@@ -5,7 +5,6 @@
 package ssa
 
 import (
-	"cmd/internal/obj"
 	"cmd/internal/src"
 	"fmt"
 	"sort"
@@ -23,15 +22,6 @@ func isPoorStatementOp(op Op) bool {
 	return false
 }
 
-// LosesStmtMark reports whether a prog with op as loses its statement mark on the way to DWARF.
-// The attributes from some opcodes are lost in translation.
-// TODO: this is an artifact of how funcpctab combines information for instructions at a single PC.
-// Should try to fix it there.
-func LosesStmtMark(as obj.As) bool {
-	// is_stmt does not work for these; it DOES for ANOP even though that generates no code.
-	return as == obj.APCDATA || as == obj.AFUNCDATA
-}
-
 // nextGoodStatementIndex returns an index at i or later that is believed
 // to be a good place to start the statement for b.  This decision is
 // based on v's Op, the possibility of a better later operation, and
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 082cb7c321..0da6ab3272 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -6277,7 +6277,7 @@ type State struct {
 // Prog appends a new Prog.
 func (s *State) Prog(as obj.As) *obj.Prog {
 	p := s.pp.Prog(as)
-	if ssa.LosesStmtMark(as) {
+	if objw.LosesStmtMark(as) {
 		return p
 	}
 	// Float a statement start to the beginning of any same-line run.
diff --git a/src/cmd/compile/internal/typebits/typebits.go b/src/cmd/compile/internal/typebits/typebits.go
new file mode 100644
index 0000000000..63a2bb3ffa
--- /dev/null
+++ b/src/cmd/compile/internal/typebits/typebits.go
@@ -0,0 +1,87 @@
+// Copyright 2013 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 typebits
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/bitvec"
+	"cmd/compile/internal/types"
+)
+
+// NOTE: The bitmap for a specific type t could be cached in t after
+// the first run and then simply copied into bv at the correct offset
+// on future calls with the same type t.
+func Set(t *types.Type, off int64, bv bitvec.BitVec) {
+	if t.Align > 0 && off&int64(t.Align-1) != 0 {
+		base.Fatalf("onebitwalktype1: invalid initial alignment: type %v has alignment %d, but offset is %v", t, t.Align, off)
+	}
+	if !t.HasPointers() {
+		// Note: this case ensures that pointers to go:notinheap types
+		// are not considered pointers by garbage collection and stack copying.
+		return
+	}
+
+	switch t.Kind() {
+	case types.TPTR, types.TUNSAFEPTR, types.TFUNC, types.TCHAN, types.TMAP:
+		if off&int64(types.PtrSize-1) != 0 {
+			base.Fatalf("onebitwalktype1: invalid alignment, %v", t)
+		}
+		bv.Set(int32(off / int64(types.PtrSize))) // pointer
+
+	case types.TSTRING:
+		// struct { byte *str; intgo len; }
+		if off&int64(types.PtrSize-1) != 0 {
+			base.Fatalf("onebitwalktype1: invalid alignment, %v", t)
+		}
+		bv.Set(int32(off / int64(types.PtrSize))) //pointer in first slot
+
+	case types.TINTER:
+		// struct { Itab *tab;	void *data; }
+		// or, when isnilinter(t)==true:
+		// struct { Type *type; void *data; }
+		if off&int64(types.PtrSize-1) != 0 {
+			base.Fatalf("onebitwalktype1: invalid alignment, %v", t)
+		}
+		// The first word of an interface is a pointer, but we don't
+		// treat it as such.
+		// 1. If it is a non-empty interface, the pointer points to an itab
+		//    which is always in persistentalloc space.
+		// 2. If it is an empty interface, the pointer points to a _type.
+		//   a. If it is a compile-time-allocated type, it points into
+		//      the read-only data section.
+		//   b. If it is a reflect-allocated type, it points into the Go heap.
+		//      Reflect is responsible for keeping a reference to
+		//      the underlying type so it won't be GCd.
+		// If we ever have a moving GC, we need to change this for 2b (as
+		// well as scan itabs to update their itab._type fields).
+		bv.Set(int32(off/int64(types.PtrSize) + 1)) // pointer in second slot
+
+	case types.TSLICE:
+		// struct { byte *array; uintgo len; uintgo cap; }
+		if off&int64(types.PtrSize-1) != 0 {
+			base.Fatalf("onebitwalktype1: invalid TARRAY alignment, %v", t)
+		}
+		bv.Set(int32(off / int64(types.PtrSize))) // pointer in first slot (BitsPointer)
+
+	case types.TARRAY:
+		elt := t.Elem()
+		if elt.Width == 0 {
+			// Short-circuit for #20739.
+			break
+		}
+		for i := int64(0); i < t.NumElem(); i++ {
+			Set(elt, off, bv)
+			off += elt.Width
+		}
+
+	case types.TSTRUCT:
+		for _, f := range t.Fields().Slice() {
+			Set(f.Type, off+f.Offset, bv)
+		}
+
+	default:
+		base.Fatalf("onebitwalktype1: unexpected type, %v", t)
+	}
+}
-- 
GitLab


From 137f0d2e06523f6daf808ea09e77e68d8944a85a Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 27 Dec 2020 10:48:10 -0800
Subject: [PATCH 0357/2400] [dev.regabi] cmd/compile: remove unnecessary
 Name.Sym call

Since the introduction of ir.BasicLit, we no longer create Names
without Syms.

Passes toolstash -cmp.

Change-Id: I82de3fd65455e3756ff56e52febb512c0a2128f2
Reviewed-on: https://go-review.googlesource.com/c/go/+/280512
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/typecheck/func.go | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index 50f514a6db..a9d92c668c 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -527,9 +527,7 @@ func tcCall(n *ir.CallExpr, top int) ir.Node {
 	default:
 		n.SetOp(ir.OCALLFUNC)
 		if t.Kind() != types.TFUNC {
-			// TODO(mdempsky): Remove "o.Sym() != nil" once we stop
-			// using ir.Name for numeric literals.
-			if o := ir.Orig(l); o.Name() != nil && o.Sym() != nil && types.BuiltinPkg.Lookup(o.Sym().Name).Def != nil {
+			if o := ir.Orig(l); o.Name() != nil && types.BuiltinPkg.Lookup(o.Sym().Name).Def != nil {
 				// be more specific when the non-function
 				// name matches a predeclared function
 				base.Errorf("cannot call non-function %L, declared at %s",
-- 
GitLab


From 098a6490b93f337ed3f13a7a18376ebb8175f2be Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 27 Dec 2020 11:11:11 -0800
Subject: [PATCH 0358/2400] [dev.regabi] cmd/compile: remove Declare in
 makepartialcall

This is the only remaining late call to Declare. By changing it to use
Temp, we'll be able to move the legacy lexical scoping logic by moving
it to noder and iimport.

Passes toolstash -cmp.

Change-Id: Id7cf7a08e3138e50816f515fef3088785a10aaf4
Reviewed-on: https://go-review.googlesource.com/c/go/+/280513
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/typecheck/func.go | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index a9d92c668c..ed4f3ad4fe 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -285,15 +285,13 @@ func makepartialcall(dot *ir.SelectorExpr) *ir.Func {
 
 	// Declare and initialize variable holding receiver.
 	cr := ir.NewClosureRead(rcvrtype, types.Rnd(int64(types.PtrSize), int64(rcvrtype.Align)))
-	ptr := NewName(Lookup(".this"))
-	Declare(ptr, ir.PAUTO)
-	ptr.SetUsed(true)
+	var ptr *ir.Name
 	var body []ir.Node
 	if rcvrtype.IsPtr() || rcvrtype.IsInterface() {
-		ptr.SetType(rcvrtype)
+		ptr = Temp(rcvrtype)
 		body = append(body, ir.NewAssignStmt(base.Pos, ptr, cr))
 	} else {
-		ptr.SetType(types.NewPtr(rcvrtype))
+		ptr = Temp(types.NewPtr(rcvrtype))
 		body = append(body, ir.NewAssignStmt(base.Pos, ptr, NodAddr(cr)))
 	}
 
-- 
GitLab


From fda7ec3a3f03f95854d33e344b41d52e017e88e0 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 27 Dec 2020 11:45:57 -0800
Subject: [PATCH 0359/2400] [dev.regabi] cmd/compile: remove Name.IsDDD, etc

These are never used.

Change-Id: I58f7359f20252ca942f59bc7593c615a7b9de105
Reviewed-on: https://go-review.googlesource.com/c/go/+/280514
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/ir/name.go       | 3 ---
 src/cmd/compile/internal/noder/noder.go   | 1 -
 src/cmd/compile/internal/typecheck/dcl.go | 2 --
 3 files changed, 6 deletions(-)

diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 93535f4cee..cc8e1b4cd1 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -268,7 +268,6 @@ const (
 	nameInlLocal              // PAUTO created by inliner, derived from callee local
 	nameOpenDeferSlot         // if temporary var storing info for open-coded defers
 	nameLibfuzzerExtraCounter // if PEXTERN should be assigned to __libfuzzer_extra_counters section
-	nameIsDDD                 // is function argument a ...
 	nameAlias                 // is type name an alias
 )
 
@@ -286,7 +285,6 @@ func (n *Name) InlFormal() bool             { return n.flags&nameInlFormal != 0
 func (n *Name) InlLocal() bool              { return n.flags&nameInlLocal != 0 }
 func (n *Name) OpenDeferSlot() bool         { return n.flags&nameOpenDeferSlot != 0 }
 func (n *Name) LibfuzzerExtraCounter() bool { return n.flags&nameLibfuzzerExtraCounter != 0 }
-func (n *Name) IsDDD() bool                 { return n.flags&nameIsDDD != 0 }
 
 func (n *Name) SetCaptured(b bool)              { n.flags.set(nameCaptured, b) }
 func (n *Name) setReadonly(b bool)              { n.flags.set(nameReadonly, b) }
@@ -302,7 +300,6 @@ func (n *Name) SetInlFormal(b bool)             { n.flags.set(nameInlFormal, b)
 func (n *Name) SetInlLocal(b bool)              { n.flags.set(nameInlLocal, b) }
 func (n *Name) SetOpenDeferSlot(b bool)         { n.flags.set(nameOpenDeferSlot, b) }
 func (n *Name) SetLibfuzzerExtraCounter(b bool) { n.flags.set(nameLibfuzzerExtraCounter, b) }
-func (n *Name) SetIsDDD(b bool)                 { n.flags.set(nameIsDDD, b) }
 
 // MarkReadonly indicates that n is an ONAME with readonly contents.
 func (n *Name) MarkReadonly() {
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 7c1f7595b3..920f4839ad 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -1838,7 +1838,6 @@ func oldname(s *types.Sym) ir.Node {
 			c = typecheck.NewName(s)
 			c.Class_ = ir.PAUTOHEAP
 			c.SetIsClosureVar(true)
-			c.SetIsDDD(n.IsDDD())
 			c.Defn = n
 
 			// Link into list of active closure variables.
diff --git a/src/cmd/compile/internal/typecheck/dcl.go b/src/cmd/compile/internal/typecheck/dcl.go
index 0da0956c3a..36057ba2d1 100644
--- a/src/cmd/compile/internal/typecheck/dcl.go
+++ b/src/cmd/compile/internal/typecheck/dcl.go
@@ -447,7 +447,6 @@ func funcarg(n *ir.Field, ctxt ir.Class) {
 	name := ir.NewNameAt(n.Pos, n.Sym)
 	n.Decl = name
 	name.Ntype = n.Ntype
-	name.SetIsDDD(n.IsDDD)
 	Declare(name, ctxt)
 
 	vargen++
@@ -461,7 +460,6 @@ func funcarg2(f *types.Field, ctxt ir.Class) {
 	n := ir.NewNameAt(f.Pos, f.Sym)
 	f.Nname = n
 	n.SetType(f.Type)
-	n.SetIsDDD(f.IsDDD())
 	Declare(n, ctxt)
 }
 
-- 
GitLab


From 76136be02701aab8a4b546956f1847d28dbe0ba2 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 27 Dec 2020 11:26:12 -0800
Subject: [PATCH 0360/2400] [dev.regabi] cmd/compile: check for recursive
 import in ImportBody

After earlier importer refactorings, most of the importer is now
reentrant, so we don't need to guard against it at Resolve. The only
remaining part that is still not reentrant is inline body importing,
so move the recursive-import check there.

Passes toolstash -cmp.

Change-Id: Ia828f880a03e6125b102668c12a155d4c253d26b
Reviewed-on: https://go-review.googlesource.com/c/go/+/280515
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/typecheck/iimport.go   | 5 +++++
 src/cmd/compile/internal/typecheck/typecheck.go | 8 +-------
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index cf2cf87492..546ddcba79 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -71,7 +71,12 @@ func ImportBody(fn *ir.Func) {
 		base.Fatalf("missing import reader for %v", fn)
 	}
 
+	if inimport {
+		base.Fatalf("recursive inimport")
+	}
+	inimport = true
 	r.doInline(fn)
+	inimport = false
 }
 
 func importReaderFor(sym *types.Sym, importers map[*types.Sym]iimporterAndOffset) *importReader {
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index dabfee3bf9..e23c249ff2 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -251,13 +251,7 @@ func Resolve(n ir.Node) (res ir.Node) {
 			}
 		}
 
-		if inimport {
-			base.Fatalf("recursive inimport")
-		}
-		inimport = true
-		n = expandDecl(n)
-		inimport = false
-		return n
+		return expandDecl(n)
 	}
 
 	r := ir.AsNode(n.Sym().Def)
-- 
GitLab


From 3f370b75fb2f31754132271b2879929daa5f88fd Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 28 Dec 2020 15:40:19 -0800
Subject: [PATCH 0361/2400] [dev.regabi] cmd/compile: cleanup //go:generate
 directives

During recent refactoring, we moved mkbuiltin.go to package typecheck,
but accidentally duplicated its //go:generate directive into a bunch
of other files/directories. This CL cleans up the unnecessary
duplicates.

Also, update all of the stringer invocations to use an explicit file
name, and regenerate their files.

Updates #43369.

Change-Id: I4e493c1fff103d742de0a839d7a3375659270b50
Reviewed-on: https://go-review.googlesource.com/c/go/+/280635
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Meng Zhuo <mzh@golangcn.org>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Meng Zhuo <mzh@golangcn.org>
---
 src/cmd/compile/internal/gc/main.go           |  2 -
 src/cmd/compile/internal/ir/class_string.go   |  2 +-
 src/cmd/compile/internal/ir/name.go           |  2 +-
 src/cmd/compile/internal/ir/node.go           |  2 +-
 src/cmd/compile/internal/ir/op_string.go      |  2 +-
 src/cmd/compile/internal/noder/import.go      |  2 -
 src/cmd/compile/internal/ssagen/abi.go        |  2 -
 .../internal/syntax/operator_string.go        | 30 +++++++++-
 .../compile/internal/syntax/token_string.go   | 55 ++++++++++++++++++-
 src/cmd/compile/internal/syntax/tokens.go     |  4 +-
 10 files changed, 89 insertions(+), 14 deletions(-)

diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index ba3620e676..ced82736ce 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:generate go run mkbuiltin.go
-
 package gc
 
 import (
diff --git a/src/cmd/compile/internal/ir/class_string.go b/src/cmd/compile/internal/ir/class_string.go
index 866bf1a6b5..13b9bd4812 100644
--- a/src/cmd/compile/internal/ir/class_string.go
+++ b/src/cmd/compile/internal/ir/class_string.go
@@ -1,4 +1,4 @@
-// Code generated by "stringer -type=Class"; DO NOT EDIT.
+// Code generated by "stringer -type=Class name.go"; DO NOT EDIT.
 
 package ir
 
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index cc8e1b4cd1..cb4876b9f8 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -373,7 +373,7 @@ func DeclaredBy(x, stmt Node) bool {
 // called declaration contexts.
 type Class uint8
 
-//go:generate stringer -type=Class
+//go:generate stringer -type=Class name.go
 const (
 	Pxxx      Class = iota // no class; used during ssa conversion to indicate pseudo-variables
 	PEXTERN                // global variables
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index b4a557f290..54a3e2ba89 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -92,7 +92,7 @@ func MayBeShared(n Node) bool {
 	return false
 }
 
-//go:generate stringer -type=Op -trimprefix=O
+//go:generate stringer -type=Op -trimprefix=O node.go
 
 type Op uint8
 
diff --git a/src/cmd/compile/internal/ir/op_string.go b/src/cmd/compile/internal/ir/op_string.go
index f23e08c47c..0339444132 100644
--- a/src/cmd/compile/internal/ir/op_string.go
+++ b/src/cmd/compile/internal/ir/op_string.go
@@ -1,4 +1,4 @@
-// Code generated by "stringer -type=Op -trimprefix=O"; DO NOT EDIT.
+// Code generated by "stringer -type=Op -trimprefix=O node.go"; DO NOT EDIT.
 
 package ir
 
diff --git a/src/cmd/compile/internal/noder/import.go b/src/cmd/compile/internal/noder/import.go
index a39be9864b..08f19a4028 100644
--- a/src/cmd/compile/internal/noder/import.go
+++ b/src/cmd/compile/internal/noder/import.go
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:generate go run mkbuiltin.go
-
 package noder
 
 import (
diff --git a/src/cmd/compile/internal/ssagen/abi.go b/src/cmd/compile/internal/ssagen/abi.go
index af08fcb7c3..b0338e8155 100644
--- a/src/cmd/compile/internal/ssagen/abi.go
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:generate go run mkbuiltin.go
-
 package ssagen
 
 import (
diff --git a/src/cmd/compile/internal/syntax/operator_string.go b/src/cmd/compile/internal/syntax/operator_string.go
index 3c759b2e9b..a7cd40fb13 100644
--- a/src/cmd/compile/internal/syntax/operator_string.go
+++ b/src/cmd/compile/internal/syntax/operator_string.go
@@ -1,9 +1,37 @@
-// Code generated by "stringer -type Operator -linecomment"; DO NOT EDIT.
+// Code generated by "stringer -type Operator -linecomment tokens.go"; DO NOT EDIT.
 
 package syntax
 
 import "strconv"
 
+func _() {
+	// An "invalid array index" compiler error signifies that the constant values have changed.
+	// Re-run the stringer command to generate them again.
+	var x [1]struct{}
+	_ = x[Def-1]
+	_ = x[Not-2]
+	_ = x[Recv-3]
+	_ = x[OrOr-4]
+	_ = x[AndAnd-5]
+	_ = x[Eql-6]
+	_ = x[Neq-7]
+	_ = x[Lss-8]
+	_ = x[Leq-9]
+	_ = x[Gtr-10]
+	_ = x[Geq-11]
+	_ = x[Add-12]
+	_ = x[Sub-13]
+	_ = x[Or-14]
+	_ = x[Xor-15]
+	_ = x[Mul-16]
+	_ = x[Div-17]
+	_ = x[Rem-18]
+	_ = x[And-19]
+	_ = x[AndNot-20]
+	_ = x[Shl-21]
+	_ = x[Shr-22]
+}
+
 const _Operator_name = ":!<-||&&==!=<<=>>=+-|^*/%&&^<<>>"
 
 var _Operator_index = [...]uint8{0, 1, 2, 4, 6, 8, 10, 12, 13, 15, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 28, 30, 32}
diff --git a/src/cmd/compile/internal/syntax/token_string.go b/src/cmd/compile/internal/syntax/token_string.go
index 3cf5473feb..ef295eb24b 100644
--- a/src/cmd/compile/internal/syntax/token_string.go
+++ b/src/cmd/compile/internal/syntax/token_string.go
@@ -1,9 +1,62 @@
-// Code generated by "stringer -type token -linecomment"; DO NOT EDIT.
+// Code generated by "stringer -type token -linecomment tokens.go"; DO NOT EDIT.
 
 package syntax
 
 import "strconv"
 
+func _() {
+	// An "invalid array index" compiler error signifies that the constant values have changed.
+	// Re-run the stringer command to generate them again.
+	var x [1]struct{}
+	_ = x[_EOF-1]
+	_ = x[_Name-2]
+	_ = x[_Literal-3]
+	_ = x[_Operator-4]
+	_ = x[_AssignOp-5]
+	_ = x[_IncOp-6]
+	_ = x[_Assign-7]
+	_ = x[_Define-8]
+	_ = x[_Arrow-9]
+	_ = x[_Star-10]
+	_ = x[_Lparen-11]
+	_ = x[_Lbrack-12]
+	_ = x[_Lbrace-13]
+	_ = x[_Rparen-14]
+	_ = x[_Rbrack-15]
+	_ = x[_Rbrace-16]
+	_ = x[_Comma-17]
+	_ = x[_Semi-18]
+	_ = x[_Colon-19]
+	_ = x[_Dot-20]
+	_ = x[_DotDotDot-21]
+	_ = x[_Break-22]
+	_ = x[_Case-23]
+	_ = x[_Chan-24]
+	_ = x[_Const-25]
+	_ = x[_Continue-26]
+	_ = x[_Default-27]
+	_ = x[_Defer-28]
+	_ = x[_Else-29]
+	_ = x[_Fallthrough-30]
+	_ = x[_For-31]
+	_ = x[_Func-32]
+	_ = x[_Go-33]
+	_ = x[_Goto-34]
+	_ = x[_If-35]
+	_ = x[_Import-36]
+	_ = x[_Interface-37]
+	_ = x[_Map-38]
+	_ = x[_Package-39]
+	_ = x[_Range-40]
+	_ = x[_Return-41]
+	_ = x[_Select-42]
+	_ = x[_Struct-43]
+	_ = x[_Switch-44]
+	_ = x[_Type-45]
+	_ = x[_Var-46]
+	_ = x[tokenCount-47]
+}
+
 const _token_name = "EOFnameliteralopop=opop=:=<-*([{)]},;:....breakcasechanconstcontinuedefaultdeferelsefallthroughforfuncgogotoifimportinterfacemappackagerangereturnselectstructswitchtypevar"
 
 var _token_index = [...]uint8{0, 3, 7, 14, 16, 19, 23, 24, 26, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 42, 47, 51, 55, 60, 68, 75, 80, 84, 95, 98, 102, 104, 108, 110, 116, 125, 128, 135, 140, 146, 152, 158, 164, 168, 171, 171}
diff --git a/src/cmd/compile/internal/syntax/tokens.go b/src/cmd/compile/internal/syntax/tokens.go
index 3b97cb66f2..2936b6576b 100644
--- a/src/cmd/compile/internal/syntax/tokens.go
+++ b/src/cmd/compile/internal/syntax/tokens.go
@@ -6,7 +6,7 @@ package syntax
 
 type token uint
 
-//go:generate stringer -type token -linecomment
+//go:generate stringer -type token -linecomment tokens.go
 
 const (
 	_    token = iota
@@ -105,7 +105,7 @@ const (
 
 type Operator uint
 
-//go:generate stringer -type Operator -linecomment
+//go:generate stringer -type Operator -linecomment tokens.go
 
 const (
 	_ Operator = iota
-- 
GitLab


From e563715b3085f44a76564485214e33e3c3b2b7b0 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 28 Dec 2020 15:29:03 -0800
Subject: [PATCH 0362/2400] [dev.regabi] cmd/compile: remove Sym.Importdef

Evidently it hasn't been needed since circa 2018, when we removed the
binary export data format.

Change-Id: I4e4c788d6b6233340fb0de0a56d035c31d96f761
Reviewed-on: https://go-review.googlesource.com/c/go/+/280634
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/typecheck/export.go  | 1 -
 src/cmd/compile/internal/types/sizeof_test.go | 2 +-
 src/cmd/compile/internal/types/sym.go         | 3 +--
 3 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/export.go b/src/cmd/compile/internal/typecheck/export.go
index 381a28e3ed..03deff8174 100644
--- a/src/cmd/compile/internal/typecheck/export.go
+++ b/src/cmd/compile/internal/typecheck/export.go
@@ -59,7 +59,6 @@ func importsym(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op ir.Op, ctxt ir.Cl
 	n := ir.NewDeclNameAt(pos, op, s)
 	n.Class_ = ctxt // TODO(mdempsky): Move this into NewDeclNameAt too?
 	s.SetPkgDef(n)
-	s.Importdef = ipkg
 	return n
 }
 
diff --git a/src/cmd/compile/internal/types/sizeof_test.go b/src/cmd/compile/internal/types/sizeof_test.go
index 1ca07b12c8..675739f7f6 100644
--- a/src/cmd/compile/internal/types/sizeof_test.go
+++ b/src/cmd/compile/internal/types/sizeof_test.go
@@ -20,7 +20,7 @@ func TestSizeof(t *testing.T) {
 		_32bit uintptr     // size on 32bit platforms
 		_64bit uintptr     // size on 64bit platforms
 	}{
-		{Sym{}, 48, 80},
+		{Sym{}, 44, 72},
 		{Type{}, 56, 96},
 		{Map{}, 20, 40},
 		{Forward{}, 20, 32},
diff --git a/src/cmd/compile/internal/types/sym.go b/src/cmd/compile/internal/types/sym.go
index c512e3a003..cd061d5f1c 100644
--- a/src/cmd/compile/internal/types/sym.go
+++ b/src/cmd/compile/internal/types/sym.go
@@ -27,8 +27,7 @@ import (
 // NOTE: In practice, things can be messier than the description above
 // for various reasons (historical, convenience).
 type Sym struct {
-	Importdef *Pkg   // where imported definition was found
-	Linkname  string // link name
+	Linkname string // link name
 
 	Pkg  *Pkg
 	Name string // object name
-- 
GitLab


From 4629f6a51da5afabbebe9616f65fbfe0675d6039 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 28 Dec 2020 16:14:11 -0800
Subject: [PATCH 0363/2400] [dev.regabi] cmd/compile: merge
 {Selector,CallPart,Method}Expr

These three expression nodes all represent the same syntax, and so
they're represented the same within types2. And also they're not
handled that meaningfully differently throughout the rest of the
compiler to merit unique representations.

Method expressions are somewhat unique today that they're very
frequently turned into plain function names. But eventually that can
be handled by a post-typecheck desugaring phase that reduces the
number of redundant AST forms.

Passes toolstash -cmp.

Change-Id: I20df91bbd0d885c1f18ec67feb61ae1558670719
Reviewed-on: https://go-review.googlesource.com/c/go/+/280636
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/escape/escape.go     |  8 +--
 src/cmd/compile/internal/inline/inl.go        | 11 ++--
 src/cmd/compile/internal/ir/expr.go           | 60 +++++--------------
 src/cmd/compile/internal/ir/fmt.go            | 21 +------
 src/cmd/compile/internal/ir/node_gen.go       | 32 ----------
 src/cmd/compile/internal/staticinit/sched.go  |  8 +--
 src/cmd/compile/internal/typecheck/expr.go    |  6 +-
 src/cmd/compile/internal/typecheck/func.go    | 16 +++--
 src/cmd/compile/internal/typecheck/iexport.go | 21 +------
 .../compile/internal/typecheck/typecheck.go   | 15 ++---
 src/cmd/compile/internal/walk/closure.go      |  4 +-
 src/cmd/compile/internal/walk/complit.go      |  4 +-
 src/cmd/compile/internal/walk/expr.go         |  4 +-
 src/cmd/compile/internal/walk/order.go        |  2 +-
 14 files changed, 58 insertions(+), 154 deletions(-)

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index d8f0111d2d..7b4037e028 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -612,10 +612,10 @@ func (e *escape) exprSkipInit(k hole, n ir.Node) {
 		// Flow the receiver argument to both the closure and
 		// to the receiver parameter.
 
-		n := n.(*ir.CallPartExpr)
+		n := n.(*ir.SelectorExpr)
 		closureK := e.spill(k, n)
 
-		m := n.Method
+		m := n.Selection
 
 		// We don't know how the method value will be called
 		// later, so conservatively assume the result
@@ -1542,7 +1542,7 @@ func (e *escape) finish(fns []*ir.Func) {
 					n := n.(*ir.ClosureExpr)
 					n.SetTransient(true)
 				case ir.OCALLPART:
-					n := n.(*ir.CallPartExpr)
+					n := n.(*ir.SelectorExpr)
 					n.SetTransient(true)
 				case ir.OSLICELIT:
 					n := n.(*ir.CompLitExpr)
@@ -1863,7 +1863,7 @@ func HeapAllocReason(n ir.Node) string {
 	if n.Op() == ir.OCLOSURE && typecheck.ClosureType(n.(*ir.ClosureExpr)).Size() >= ir.MaxImplicitStackVarSize {
 		return "too large for stack"
 	}
-	if n.Op() == ir.OCALLPART && typecheck.PartialCallType(n.(*ir.CallPartExpr)).Size() >= ir.MaxImplicitStackVarSize {
+	if n.Op() == ir.OCALLPART && typecheck.PartialCallType(n.(*ir.SelectorExpr)).Size() >= ir.MaxImplicitStackVarSize {
 		return "too large for stack"
 	}
 
diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 67162771e9..fc6a17b933 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -419,6 +419,9 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 
 	case ir.OCALLPART, ir.OSLICELIT:
 		v.budget-- // Hack for toolstash -cmp.
+
+	case ir.OMETHEXPR:
+		v.budget++ // Hack for toolstash -cmp.
 	}
 
 	v.budget--
@@ -613,12 +616,12 @@ func inlCallee(fn ir.Node) *ir.Func {
 	fn = ir.StaticValue(fn)
 	switch fn.Op() {
 	case ir.OMETHEXPR:
-		fn := fn.(*ir.MethodExpr)
+		fn := fn.(*ir.SelectorExpr)
 		n := ir.MethodExprName(fn)
-		// Check that receiver type matches fn.Left.
+		// Check that receiver type matches fn.X.
 		// TODO(mdempsky): Handle implicit dereference
 		// of pointer receiver argument?
-		if n == nil || !types.Identical(n.Type().Recv().Type, fn.T) {
+		if n == nil || !types.Identical(n.Type().Recv().Type, fn.X.Type()) {
 			return nil
 		}
 		return n.Func
@@ -1098,7 +1101,7 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 		return n
 
 	case ir.OMETHEXPR:
-		n := n.(*ir.MethodExpr)
+		n := n.(*ir.SelectorExpr)
 		return n
 
 	case ir.OLITERAL, ir.ONIL, ir.OTYPE:
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 1337d356a1..872f81a447 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -225,26 +225,6 @@ func (n *CallExpr) SetOp(op Op) {
 	}
 }
 
-// A CallPartExpr is a method expression X.Method (uncalled).
-type CallPartExpr struct {
-	miniExpr
-	Func     *Func
-	X        Node
-	Method   *types.Field
-	Prealloc *Name
-}
-
-func NewCallPartExpr(pos src.XPos, x Node, method *types.Field, fn *Func) *CallPartExpr {
-	n := &CallPartExpr{Func: fn, X: x, Method: method}
-	n.op = OCALLPART
-	n.pos = pos
-	n.typ = fn.Type()
-	n.Func = fn
-	return n
-}
-
-func (n *CallPartExpr) Sym() *types.Sym { return n.Method.Sym }
-
 // A ClosureExpr is a function literal expression.
 type ClosureExpr struct {
 	miniExpr
@@ -476,24 +456,6 @@ func (n *MakeExpr) SetOp(op Op) {
 	}
 }
 
-// A MethodExpr is a method expression T.M (where T is a type).
-type MethodExpr struct {
-	miniExpr
-	T         *types.Type
-	Method    *types.Field
-	FuncName_ *Name
-}
-
-func NewMethodExpr(pos src.XPos, t *types.Type, method *types.Field) *MethodExpr {
-	n := &MethodExpr{T: t, Method: method}
-	n.pos = pos
-	n.op = OMETHEXPR
-	return n
-}
-
-func (n *MethodExpr) FuncName() *Name { return n.FuncName_ }
-func (n *MethodExpr) Sym() *types.Sym { panic("MethodExpr.Sym") }
-
 // A NilExpr represents the predefined untyped constant nil.
 // (It may be copied and assigned a type, though.)
 type NilExpr struct {
@@ -567,12 +529,13 @@ func NewNameOffsetExpr(pos src.XPos, name *Name, offset int64, typ *types.Type)
 	return n
 }
 
-// A SelectorExpr is a selector expression X.Sym.
+// A SelectorExpr is a selector expression X.Sel.
 type SelectorExpr struct {
 	miniExpr
 	X         Node
 	Sel       *types.Sym
 	Selection *types.Field
+	Prealloc  *Name // preallocated storage for OCALLPART, if any
 }
 
 func NewSelectorExpr(pos src.XPos, op Op, x Node, sel *types.Sym) *SelectorExpr {
@@ -586,7 +549,7 @@ func (n *SelectorExpr) SetOp(op Op) {
 	switch op {
 	default:
 		panic(n.no("SetOp " + op.String()))
-	case ODOT, ODOTPTR, ODOTMETH, ODOTINTER, OXDOT:
+	case OXDOT, ODOT, ODOTPTR, ODOTMETH, ODOTINTER, OCALLPART, OMETHEXPR:
 		n.op = op
 	}
 }
@@ -596,6 +559,16 @@ func (n *SelectorExpr) Implicit() bool     { return n.flags&miniExprImplicit !=
 func (n *SelectorExpr) SetImplicit(b bool) { n.flags.set(miniExprImplicit, b) }
 func (n *SelectorExpr) Offset() int64      { return n.Selection.Offset }
 
+func (n *SelectorExpr) FuncName() *Name {
+	if n.Op() != OMETHEXPR {
+		panic(n.no("FuncName"))
+	}
+	fn := NewNameAt(n.Selection.Pos, MethodSym(n.X.Type(), n.Sel))
+	fn.Class_ = PFUNC
+	fn.SetType(n.Type())
+	return fn
+}
+
 // Before type-checking, bytes.Buffer is a SelectorExpr.
 // After type-checking it becomes a Name.
 func (*SelectorExpr) CanBeNtype() {}
@@ -1089,13 +1062,8 @@ func MethodExprName(n Node) *Name {
 // MethodFunc is like MethodName, but returns the types.Field instead.
 func MethodExprFunc(n Node) *types.Field {
 	switch n.Op() {
-	case ODOTMETH:
+	case ODOTMETH, OMETHEXPR, OCALLPART:
 		return n.(*SelectorExpr).Selection
-	case OMETHEXPR:
-		return n.(*MethodExpr).Method
-	case OCALLPART:
-		n := n.(*CallPartExpr)
-		return n.Method
 	}
 	base.Fatalf("unexpected node: %v (%v)", n, n.Op())
 	panic("unreachable")
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 49f451a5d8..7680f05ad2 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -630,10 +630,6 @@ func exprFmt(n Node, s fmt.State, prec int) {
 	case OPACK, ONONAME:
 		fmt.Fprint(s, n.Sym())
 
-	case OMETHEXPR:
-		n := n.(*MethodExpr)
-		fmt.Fprint(s, n.FuncName().Sym())
-
 	case ONAMEOFFSET:
 		n := n.(*NameOffsetExpr)
 		fmt.Fprintf(s, "(%v)(%v@%d)", n.Type(), n.Name_, n.Offset_)
@@ -749,16 +745,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		n := n.(*StructKeyExpr)
 		fmt.Fprintf(s, "%v:%v", n.Field, n.Value)
 
-	case OCALLPART:
-		n := n.(*CallPartExpr)
-		exprFmt(n.X, s, nprec)
-		if n.Method.Sym == nil {
-			fmt.Fprint(s, ".<nil>")
-			return
-		}
-		fmt.Fprintf(s, ".%s", n.Method.Sym.Name)
-
-	case OXDOT, ODOT, ODOTPTR, ODOTINTER, ODOTMETH:
+	case OXDOT, ODOT, ODOTPTR, ODOTINTER, ODOTMETH, OCALLPART, OMETHEXPR:
 		n := n.(*SelectorExpr)
 		exprFmt(n.X, s, nprec)
 		if n.Sel == nil {
@@ -1160,12 +1147,6 @@ func dumpNode(w io.Writer, n Node, depth int) {
 		}
 		return
 
-	case OMETHEXPR:
-		n := n.(*MethodExpr)
-		fmt.Fprintf(w, "%+v-%+v", n.Op(), n.FuncName().Sym())
-		dumpNodeHeader(w, n)
-		return
-
 	case OASOP:
 		n := n.(*AssignOpStmt)
 		fmt.Fprintf(w, "%+v-%+v", n.Op(), n.AsOp)
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index 27a5311748..a1ce9a4e9d 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -209,23 +209,6 @@ func (n *CallExpr) editChildren(edit func(Node) Node) {
 	editList(n.Body, edit)
 }
 
-func (n *CallPartExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *CallPartExpr) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *CallPartExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	return err
-}
-func (n *CallPartExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-}
-
 func (n *CaseClause) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *CaseClause) copy() Node {
 	c := *n
@@ -655,21 +638,6 @@ func (n *MapType) editChildren(edit func(Node) Node) {
 	n.Elem = maybeEdit(n.Elem, edit)
 }
 
-func (n *MethodExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-func (n *MethodExpr) copy() Node {
-	c := *n
-	c.init = c.init.Copy()
-	return &c
-}
-func (n *MethodExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	return err
-}
-func (n *MethodExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-}
-
 func (n *Name) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *Name) copy() Node                    { panic("Name.copy") }
 func (n *Name) doChildren(do func(Node) error) error {
diff --git a/src/cmd/compile/internal/staticinit/sched.go b/src/cmd/compile/internal/staticinit/sched.go
index 2711f6cec0..d8f51766de 100644
--- a/src/cmd/compile/internal/staticinit/sched.go
+++ b/src/cmd/compile/internal/staticinit/sched.go
@@ -104,7 +104,7 @@ func (s *Schedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *types.Ty
 
 	switch r.Op() {
 	case ir.OMETHEXPR:
-		r = r.(*ir.MethodExpr).FuncName()
+		r = r.(*ir.SelectorExpr).FuncName()
 		fallthrough
 	case ir.ONAME:
 		r := r.(*ir.Name)
@@ -165,7 +165,7 @@ func (s *Schedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *types.Ty
 			}
 			x := e.Expr
 			if x.Op() == ir.OMETHEXPR {
-				x = x.(*ir.MethodExpr).FuncName()
+				x = x.(*ir.SelectorExpr).FuncName()
 			}
 			if x.Op() == ir.ONAME && s.staticcopy(l, loff+e.Xoffset, x.(*ir.Name), typ) {
 				continue
@@ -195,7 +195,7 @@ func (s *Schedule) StaticAssign(l *ir.Name, loff int64, r ir.Node, typ *types.Ty
 		return s.staticcopy(l, loff, r, typ)
 
 	case ir.OMETHEXPR:
-		r := r.(*ir.MethodExpr)
+		r := r.(*ir.SelectorExpr)
 		return s.staticcopy(l, loff, r.FuncName(), typ)
 
 	case ir.ONIL:
@@ -461,7 +461,7 @@ func StaticLoc(n ir.Node) (name *ir.Name, offset int64, ok bool) {
 		return n, 0, true
 
 	case ir.OMETHEXPR:
-		n := n.(*ir.MethodExpr)
+		n := n.(*ir.SelectorExpr)
 		return StaticLoc(n.FuncName())
 
 	case ir.ODOT:
diff --git a/src/cmd/compile/internal/typecheck/expr.go b/src/cmd/compile/internal/typecheck/expr.go
index 3e7a880c2a..0682548c27 100644
--- a/src/cmd/compile/internal/typecheck/expr.go
+++ b/src/cmd/compile/internal/typecheck/expr.go
@@ -626,10 +626,8 @@ func tcDot(n *ir.SelectorExpr, top int) ir.Node {
 	}
 
 	if (n.Op() == ir.ODOTINTER || n.Op() == ir.ODOTMETH) && top&ctxCallee == 0 {
-		// Create top-level function.
-		fn := makepartialcall(n)
-
-		return ir.NewCallPartExpr(n.Pos(), n.X, n.Selection, fn)
+		n.SetOp(ir.OCALLPART)
+		n.SetType(MethodValueWrapper(n).Type())
 	}
 	return n
 }
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index ed4f3ad4fe..c58fef10ec 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -91,7 +91,7 @@ func ClosureType(clo *ir.ClosureExpr) *types.Type {
 // PartialCallType returns the struct type used to hold all the information
 // needed in the closure for n (n must be a OCALLPART node).
 // The address of a variable of the returned type can be cast to a func.
-func PartialCallType(n *ir.CallPartExpr) *types.Type {
+func PartialCallType(n *ir.SelectorExpr) *types.Type {
 	t := types.NewStruct(types.NoPkg, []*types.Field{
 		types.NewField(base.Pos, Lookup("F"), types.Types[types.TUINTPTR]),
 		types.NewField(base.Pos, Lookup("R"), n.X.Type()),
@@ -247,9 +247,17 @@ func closurename(outerfunc *ir.Func) *types.Sym {
 // globClosgen is like Func.Closgen, but for the global scope.
 var globClosgen int32
 
-// makepartialcall returns a DCLFUNC node representing the wrapper function (*-fm) needed
-// for partial calls.
-func makepartialcall(dot *ir.SelectorExpr) *ir.Func {
+// MethodValueWrapper returns the DCLFUNC node representing the
+// wrapper function (*-fm) needed for the given method value. If the
+// wrapper function hasn't already been created yet, it's created and
+// added to Target.Decls.
+//
+// TODO(mdempsky): Move into walk. This isn't part of type checking.
+func MethodValueWrapper(dot *ir.SelectorExpr) *ir.Func {
+	if dot.Op() != ir.OCALLPART {
+		base.Fatalf("MethodValueWrapper: unexpected %v (%v)", dot, dot.Op())
+	}
+
 	t0 := dot.Type()
 	meth := dot.Sel
 	rcvrtype := dot.X.Type()
diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index 3b071a61ab..e35cbcafa2 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -1252,17 +1252,6 @@ func (w *exportWriter) expr(n ir.Node) {
 		w.pos(n.Pos())
 		w.value(n.Type(), n.Val())
 
-	case ir.OMETHEXPR:
-		// Special case: explicit name of func (*T) method(...) is turned into pkg.(*T).method,
-		// but for export, this should be rendered as (*pkg.T).meth.
-		// These nodes have the special property that they are names with a left OTYPE and a right ONAME.
-		n := n.(*ir.MethodExpr)
-		w.op(ir.OXDOT)
-		w.pos(n.Pos())
-		w.op(ir.OTYPE)
-		w.typ(n.T) // n.Left.Op == OTYPE
-		w.selector(n.Method.Sym)
-
 	case ir.ONAME:
 		// Package scope name.
 		n := n.(*ir.Name)
@@ -1336,15 +1325,7 @@ func (w *exportWriter) expr(n ir.Node) {
 	// case OSTRUCTKEY:
 	//	unreachable - handled in case OSTRUCTLIT by elemList
 
-	case ir.OCALLPART:
-		// An OCALLPART is an OXDOT before type checking.
-		n := n.(*ir.CallPartExpr)
-		w.op(ir.OXDOT)
-		w.pos(n.Pos())
-		w.expr(n.X)
-		w.selector(n.Method.Sym)
-
-	case ir.OXDOT, ir.ODOT, ir.ODOTPTR, ir.ODOTINTER, ir.ODOTMETH:
+	case ir.OXDOT, ir.ODOT, ir.ODOTPTR, ir.ODOTINTER, ir.ODOTMETH, ir.OCALLPART, ir.OMETHEXPR:
 		n := n.(*ir.SelectorExpr)
 		w.op(ir.OXDOT)
 		w.pos(n.Pos())
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index e23c249ff2..ff9178b597 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -1176,19 +1176,16 @@ func typecheckMethodExpr(n *ir.SelectorExpr) (res ir.Node) {
 		return n
 	}
 
-	me := ir.NewMethodExpr(n.Pos(), n.X.Type(), m)
-	me.SetType(NewMethodType(m.Type, n.X.Type()))
-	f := NewName(ir.MethodSym(t, m.Sym))
-	f.Class_ = ir.PFUNC
-	f.SetType(me.Type())
-	me.FuncName_ = f
+	n.SetOp(ir.OMETHEXPR)
+	n.Selection = m
+	n.SetType(NewMethodType(m.Type, n.X.Type()))
 
 	// Issue 25065. Make sure that we emit the symbol for a local method.
 	if base.Ctxt.Flag_dynlink && !inimport && (t.Sym() == nil || t.Sym().Pkg == types.LocalPkg) {
-		NeedFuncSym(me.FuncName_.Sym())
+		NeedFuncSym(n.FuncName().Sym())
 	}
 
-	return me
+	return n
 }
 
 func derefall(t *types.Type) *types.Type {
@@ -1422,7 +1419,7 @@ notenough:
 			// Method expressions have the form T.M, and the compiler has
 			// rewritten those to ONAME nodes but left T in Left.
 			if call.Op() == ir.OMETHEXPR {
-				call := call.(*ir.MethodExpr)
+				call := call.(*ir.SelectorExpr)
 				base.Errorf("not enough arguments in call to method expression %v%s", call, details)
 			} else {
 				base.Errorf("not enough arguments in call to %v%s", call, details)
diff --git a/src/cmd/compile/internal/walk/closure.go b/src/cmd/compile/internal/walk/closure.go
index 30f86f0965..9bcb82bc03 100644
--- a/src/cmd/compile/internal/walk/closure.go
+++ b/src/cmd/compile/internal/walk/closure.go
@@ -151,7 +151,7 @@ func walkClosure(clo *ir.ClosureExpr, init *ir.Nodes) ir.Node {
 	return walkExpr(cfn, init)
 }
 
-func walkCallPart(n *ir.CallPartExpr, init *ir.Nodes) ir.Node {
+func walkCallPart(n *ir.SelectorExpr, init *ir.Nodes) ir.Node {
 	// Create closure in the form of a composite literal.
 	// For x.M with receiver (x) type T, the generated code looks like:
 	//
@@ -176,7 +176,7 @@ func walkCallPart(n *ir.CallPartExpr, init *ir.Nodes) ir.Node {
 
 	clos := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ).(ir.Ntype), nil)
 	clos.SetEsc(n.Esc())
-	clos.List = []ir.Node{ir.NewUnaryExpr(base.Pos, ir.OCFUNC, n.Func.Nname), n.X}
+	clos.List = []ir.Node{ir.NewUnaryExpr(base.Pos, ir.OCFUNC, typecheck.MethodValueWrapper(n).Nname), n.X}
 
 	addr := typecheck.NodAddr(clos)
 	addr.SetEsc(n.Esc())
diff --git a/src/cmd/compile/internal/walk/complit.go b/src/cmd/compile/internal/walk/complit.go
index 8c4f9583ef..fadcd87f25 100644
--- a/src/cmd/compile/internal/walk/complit.go
+++ b/src/cmd/compile/internal/walk/complit.go
@@ -539,7 +539,7 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, n))
 
 	case ir.OMETHEXPR:
-		n := n.(*ir.MethodExpr)
+		n := n.(*ir.SelectorExpr)
 		anylit(n.FuncName(), var_, init)
 
 	case ir.OPTRLIT:
@@ -666,7 +666,7 @@ func genAsStatic(as *ir.AssignStmt) {
 		staticdata.InitConst(name, offset, r, int(r.Type().Width))
 		return
 	case ir.OMETHEXPR:
-		r := r.(*ir.MethodExpr)
+		r := r.(*ir.SelectorExpr)
 		staticdata.InitFunc(name, offset, r.FuncName())
 		return
 	case ir.ONAME:
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index fd0dd5b062..7cc6758024 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -100,7 +100,7 @@ func walkExpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 	case ir.OMETHEXPR:
 		// TODO(mdempsky): Do this right after type checking.
-		n := n.(*ir.MethodExpr)
+		n := n.(*ir.SelectorExpr)
 		return n.FuncName()
 
 	case ir.ONOT, ir.ONEG, ir.OPLUS, ir.OBITNOT, ir.OREAL, ir.OIMAG, ir.OSPTR, ir.OITAB, ir.OIDATA:
@@ -306,7 +306,7 @@ func walkExpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return walkClosure(n.(*ir.ClosureExpr), init)
 
 	case ir.OCALLPART:
-		return walkCallPart(n.(*ir.CallPartExpr), init)
+		return walkCallPart(n.(*ir.SelectorExpr), init)
 	}
 
 	// No return! Each case must return (or panic),
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index ebbd467570..0dd76ccee9 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -1310,7 +1310,7 @@ func (o *orderState) expr1(n, lhs ir.Node) ir.Node {
 		return n
 
 	case ir.OCALLPART:
-		n := n.(*ir.CallPartExpr)
+		n := n.(*ir.SelectorExpr)
 		n.X = o.expr(n.X, nil)
 		if n.Transient() {
 			t := typecheck.PartialCallType(n)
-- 
GitLab


From 6acbae4fcc640715efd01cb161a65e1e04fda3cb Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 28 Dec 2020 17:06:43 -0800
Subject: [PATCH 0364/2400] [dev.regabi] cmd/compile: address some ir TODOs

Previously, ODOTTYPE/ODOTTYPE2 were forced to reuse some available
Node fields for storing pointers to runtime type descriptors. This
resulted in awkward field types for TypeAssertExpr and AddrExpr.

This CL gives TypeAssertExpr proper fields for the runtime type
descriptors, and also tightens the field types as
possible/appropriate.

Passes toolstash -cmp.

Change-Id: I521ee7a1462affc5459de33a0de6c68a7d6416ba
Reviewed-on: https://go-review.googlesource.com/c/go/+/280637
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/ir/expr.go        | 11 ++++++++---
 src/cmd/compile/internal/ir/node_gen.go    |  7 +------
 src/cmd/compile/internal/ssagen/ssa.go     |  8 ++++----
 src/cmd/compile/internal/typecheck/expr.go |  2 +-
 src/cmd/compile/internal/walk/expr.go      |  7 ++++---
 5 files changed, 18 insertions(+), 17 deletions(-)

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 872f81a447..825d4ace78 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -109,7 +109,7 @@ func NewAddStringExpr(pos src.XPos, list []Node) *AddStringExpr {
 type AddrExpr struct {
 	miniExpr
 	X     Node
-	Alloc Node // preallocated storage if any
+	Alloc *Name // preallocated storage if any
 }
 
 func NewAddrExpr(pos src.XPos, x Node) *AddrExpr {
@@ -660,8 +660,13 @@ func (n *StarExpr) SetOTYPE(t *types.Type) {
 type TypeAssertExpr struct {
 	miniExpr
 	X     Node
-	Ntype Node  // TODO: Should be Ntype, but reused as address of type structure
-	Itab  Nodes // Itab[0] is itab
+	Ntype Ntype
+
+	// Runtime type information provided by walkDotType.
+	// Caution: These aren't always populated; see walkDotType.
+	SrcType *AddrExpr // *runtime._type for X's type
+	DstType *AddrExpr // *runtime._type for Type
+	Itab    *AddrExpr // *runtime.itab for Type implementing X's type
 }
 
 func NewTypeAssertExpr(pos src.XPos, x Node, typ Ntype) *TypeAssertExpr {
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index a1ce9a4e9d..1d24904a3f 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -32,13 +32,11 @@ func (n *AddrExpr) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
 	err = maybeDo(n.X, err, do)
-	err = maybeDo(n.Alloc, err, do)
 	return err
 }
 func (n *AddrExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	n.X = maybeEdit(n.X, edit)
-	n.Alloc = maybeEdit(n.Alloc, edit)
 }
 
 func (n *ArrayType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
@@ -954,7 +952,6 @@ func (n *TypeAssertExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
 func (n *TypeAssertExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
-	c.Itab = c.Itab.Copy()
 	return &c
 }
 func (n *TypeAssertExpr) doChildren(do func(Node) error) error {
@@ -962,14 +959,12 @@ func (n *TypeAssertExpr) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.init, err, do)
 	err = maybeDo(n.X, err, do)
 	err = maybeDo(n.Ntype, err, do)
-	err = maybeDoList(n.Itab, err, do)
 	return err
 }
 func (n *TypeAssertExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	n.X = maybeEdit(n.X, edit)
-	n.Ntype = maybeEdit(n.Ntype, edit)
-	editList(n.Itab, edit)
+	n.Ntype = toNtype(maybeEdit(n.Ntype, edit))
 }
 
 func (n *TypeSwitchGuard) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 0da6ab3272..509d53f8c9 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -5978,8 +5978,8 @@ func (s *state) floatToUint(cvttab *f2uCvtTab, n ir.Node, x *ssa.Value, ft, tt *
 // commaok indicates whether to panic or return a bool.
 // If commaok is false, resok will be nil.
 func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Value) {
-	iface := s.expr(n.X)      // input interface
-	target := s.expr(n.Ntype) // target type
+	iface := s.expr(n.X)        // input interface
+	target := s.expr(n.DstType) // target type
 	byteptr := s.f.Config.Types.BytePtr
 
 	if n.Type().IsInterface() {
@@ -6086,7 +6086,7 @@ func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Val
 		targetITab = target
 	} else {
 		// Looking for pointer to itab for target type and source interface.
-		targetITab = s.expr(n.Itab[0])
+		targetITab = s.expr(n.Itab)
 	}
 
 	var tmp ir.Node     // temporary for use with large types
@@ -6113,7 +6113,7 @@ func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Val
 	if !commaok {
 		// on failure, panic by calling panicdottype
 		s.startBlock(bFail)
-		taddr := s.expr(n.Ntype.(*ir.AddrExpr).Alloc)
+		taddr := s.expr(n.SrcType)
 		if n.X.Type().IsEmptyInterface() {
 			s.rtcall(ir.Syms.PanicdottypeE, false, nil, itab, target, taddr)
 		} else {
diff --git a/src/cmd/compile/internal/typecheck/expr.go b/src/cmd/compile/internal/typecheck/expr.go
index 0682548c27..29d7a08011 100644
--- a/src/cmd/compile/internal/typecheck/expr.go
+++ b/src/cmd/compile/internal/typecheck/expr.go
@@ -649,7 +649,7 @@ func tcDotType(n *ir.TypeAssertExpr) ir.Node {
 	}
 
 	if n.Ntype != nil {
-		n.Ntype = typecheck(n.Ntype, ctxType)
+		n.Ntype = typecheckNtype(n.Ntype)
 		n.SetType(n.Ntype.Type())
 		n.Ntype = nil
 		if n.Type() == nil {
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 7cc6758024..f40aa6adb5 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -639,12 +639,13 @@ func walkDot(n *ir.SelectorExpr, init *ir.Nodes) ir.Node {
 func walkDotType(n *ir.TypeAssertExpr, init *ir.Nodes) ir.Node {
 	n.X = walkExpr(n.X, init)
 	// Set up interface type addresses for back end.
-	n.Ntype = reflectdata.TypePtr(n.Type())
+
+	n.DstType = reflectdata.TypePtr(n.Type())
 	if n.Op() == ir.ODOTTYPE {
-		n.Ntype.(*ir.AddrExpr).Alloc = reflectdata.TypePtr(n.X.Type())
+		n.SrcType = reflectdata.TypePtr(n.X.Type())
 	}
 	if !n.Type().IsInterface() && !n.X.Type().IsEmptyInterface() {
-		n.Itab = []ir.Node{reflectdata.ITabAddr(n.Type(), n.X.Type())}
+		n.Itab = reflectdata.ITabAddr(n.Type(), n.X.Type())
 	}
 	return n
 }
-- 
GitLab


From 289da2b33ed6292c853017a15d3108d22ea7491a Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 28 Dec 2020 17:30:04 -0800
Subject: [PATCH 0365/2400] [dev.regabi] cmd/compile: move Node.Opt to Name

Escape analysis uses Node.Opt to map nodes to their "location", so
that other references to the same node use the same location
again. But in the current implementation of escape analysis, we never
need to refer back to a node's location except for named nodes (since
other nodes are anonymous, and have no way to be referenced).

This CL moves Opt from Node down to Name, turns it into a directly
accessed field, and cleans up escape analysis to avoid setting Opt on
non-named expressions.

One nit: in walkCheckPtrArithmetic, we were abusing Opt as a way to
detect/prevent loops. This CL adds a CheckPtr bit flag instead.

Passes toolstash -cmp.

Change-Id: If57d5ad8d972fa63bedbe69b9ebb6753e31aba85
Reviewed-on: https://go-review.googlesource.com/c/go/+/280638
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/escape/escape.go | 45 ++++++++++++++---------
 src/cmd/compile/internal/ir/expr.go       |  8 ++--
 src/cmd/compile/internal/ir/mini.go       |  2 -
 src/cmd/compile/internal/ir/name.go       |  4 +-
 src/cmd/compile/internal/ir/node.go       |  2 -
 src/cmd/compile/internal/walk/convert.go  | 14 +++----
 src/cmd/compile/internal/walk/walk.go     |  2 -
 7 files changed, 38 insertions(+), 39 deletions(-)

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index 7b4037e028..b953666ce6 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -165,12 +165,16 @@ func Fmt(n ir.Node) string {
 		text = fmt.Sprintf("esc(%d)", n.Esc())
 	}
 
-	if e, ok := n.Opt().(*location); ok && e.loopDepth != 0 {
-		if text != "" {
-			text += " "
+	if n.Op() == ir.ONAME {
+		n := n.(*ir.Name)
+		if e, ok := n.Opt.(*location); ok && e.loopDepth != 0 {
+			if text != "" {
+				text += " "
+			}
+			text += fmt.Sprintf("ld(%d)", e.loopDepth)
 		}
-		text += fmt.Sprintf("ld(%d)", e.loopDepth)
 	}
+
 	return text
 }
 
@@ -312,7 +316,7 @@ func (e *escape) stmt(n ir.Node) {
 		// Record loop depth at declaration.
 		n := n.(*ir.Decl)
 		if !ir.IsBlank(n.X) {
-			e.dcl(n.X)
+			e.dcl(n.X.(*ir.Name))
 		}
 
 	case ir.OLABEL:
@@ -370,7 +374,7 @@ func (e *escape) stmt(n ir.Node) {
 		var ks []hole
 		for _, cas := range n.Cases { // cases
 			if typesw && n.Tag.(*ir.TypeSwitchGuard).Tag != nil {
-				cv := cas.Var
+				cv := cas.Var.(*ir.Name)
 				k := e.dcl(cv) // type switch variables have no ODCL.
 				if cv.Type().HasPointers() {
 					ks = append(ks, k.dotType(cv.Type(), cas, "switch case"))
@@ -1097,7 +1101,7 @@ func (e *escape) teeHole(ks ...hole) hole {
 	return loc.asHole()
 }
 
-func (e *escape) dcl(n ir.Node) hole {
+func (e *escape) dcl(n *ir.Name) hole {
 	loc := e.oldLoc(n)
 	loc.loopDepth = e.loopDepth
 	return loc.asHole()
@@ -1151,15 +1155,17 @@ func (e *escape) newLoc(n ir.Node, transient bool) *location {
 	}
 	e.allLocs = append(e.allLocs, loc)
 	if n != nil {
-		if n.Op() == ir.ONAME && n.Name().Curfn != e.curfn {
+		if n.Op() == ir.ONAME {
 			n := n.(*ir.Name)
-			base.Fatalf("curfn mismatch: %v != %v", n.Name().Curfn, e.curfn)
-		}
+			if n.Curfn != e.curfn {
+				base.Fatalf("curfn mismatch: %v != %v", n.Name().Curfn, e.curfn)
+			}
 
-		if n.Opt() != nil {
-			base.Fatalf("%v already has a location", n)
+			if n.Opt != nil {
+				base.Fatalf("%v already has a location", n)
+			}
+			n.Opt = loc
 		}
-		n.SetOpt(loc)
 
 		if why := HeapAllocReason(n); why != "" {
 			e.flow(e.heapHole().addr(n, why), loc)
@@ -1168,9 +1174,9 @@ func (e *escape) newLoc(n ir.Node, transient bool) *location {
 	return loc
 }
 
-func (e *escape) oldLoc(n ir.Node) *location {
-	n = canonicalNode(n)
-	return n.Opt().(*location)
+func (e *escape) oldLoc(n *ir.Name) *location {
+	n = canonicalNode(n).(*ir.Name)
+	return n.Opt.(*location)
 }
 
 func (l *location) asHole() hole {
@@ -1516,7 +1522,10 @@ func (e *escape) finish(fns []*ir.Func) {
 		if n == nil {
 			continue
 		}
-		n.SetOpt(nil)
+		if n.Op() == ir.ONAME {
+			n := n.(*ir.Name)
+			n.Opt = nil
+		}
 
 		// Update n.Esc based on escape analysis results.
 
@@ -2122,7 +2131,7 @@ func (e *escape) paramTag(fn *ir.Func, narg int, f *types.Field) string {
 		return esc.Encode()
 	}
 
-	n := ir.AsNode(f.Nname)
+	n := f.Nname.(*ir.Name)
 	loc := e.oldLoc(n)
 	esc := loc.paramEsc
 	esc.Optimize()
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 825d4ace78..bb32d96088 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -48,8 +48,7 @@ type Expr interface {
 type miniExpr struct {
 	miniNode
 	typ   *types.Type
-	init  Nodes       // TODO(rsc): Don't require every Node to have an init
-	opt   interface{} // TODO(rsc): Don't require every Node to have an opt?
+	init  Nodes // TODO(rsc): Don't require every Node to have an init
 	flags bitset8
 }
 
@@ -59,14 +58,13 @@ const (
 	miniExprTransient
 	miniExprBounded
 	miniExprImplicit // for use by implementations; not supported by every Expr
+	miniExprCheckPtr
 )
 
 func (*miniExpr) isExpr() {}
 
 func (n *miniExpr) Type() *types.Type     { return n.typ }
 func (n *miniExpr) SetType(x *types.Type) { n.typ = x }
-func (n *miniExpr) Opt() interface{}      { return n.opt }
-func (n *miniExpr) SetOpt(x interface{})  { n.opt = x }
 func (n *miniExpr) HasCall() bool         { return n.flags&miniExprHasCall != 0 }
 func (n *miniExpr) SetHasCall(b bool)     { n.flags.set(miniExprHasCall, b) }
 func (n *miniExpr) NonNil() bool          { return n.flags&miniExprNonNil != 0 }
@@ -324,6 +322,8 @@ func NewConvExpr(pos src.XPos, op Op, typ *types.Type, x Node) *ConvExpr {
 
 func (n *ConvExpr) Implicit() bool     { return n.flags&miniExprImplicit != 0 }
 func (n *ConvExpr) SetImplicit(b bool) { n.flags.set(miniExprImplicit, b) }
+func (n *ConvExpr) CheckPtr() bool     { return n.flags&miniExprCheckPtr != 0 }
+func (n *ConvExpr) SetCheckPtr(b bool) { n.flags.set(miniExprCheckPtr, b) }
 
 func (n *ConvExpr) SetOp(op Op) {
 	switch op {
diff --git a/src/cmd/compile/internal/ir/mini.go b/src/cmd/compile/internal/ir/mini.go
index 53a63afe9b..9270132621 100644
--- a/src/cmd/compile/internal/ir/mini.go
+++ b/src/cmd/compile/internal/ir/mini.go
@@ -102,5 +102,3 @@ func (n *miniNode) HasCall() bool           { return false }
 func (n *miniNode) SetHasCall(bool)         { panic(n.no("SetHasCall")) }
 func (n *miniNode) NonNil() bool            { return false }
 func (n *miniNode) MarkNonNil()             { panic(n.no("MarkNonNil")) }
-func (n *miniNode) Opt() interface{}        { return nil }
-func (n *miniNode) SetOpt(interface{})      { panic(n.no("SetOpt")) }
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index cb4876b9f8..980e3f6349 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -42,6 +42,7 @@ type Name struct {
 	Func      *Func
 	Offset_   int64
 	val       constant.Value
+	Opt       interface{} // for use by escape analysis
 	orig      Node
 	Embed     *[]Embed // list of embedded files, for ONAME var
 
@@ -321,8 +322,7 @@ func (n *Name) Val() constant.Value {
 	return n.val
 }
 
-// SetVal sets the constant.Value for the node,
-// which must not have been used with SetOpt.
+// SetVal sets the constant.Value for the node.
 func (n *Name) SetVal(v constant.Value) {
 	if n.op != OLITERAL {
 		panic(n.no("SetVal"))
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 54a3e2ba89..0238e9de85 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -50,8 +50,6 @@ type Node interface {
 	SetEsc(x uint16)
 	Walkdef() uint8
 	SetWalkdef(x uint8)
-	Opt() interface{}
-	SetOpt(x interface{})
 	Diag() bool
 	SetDiag(x bool)
 	Typecheck() uint8
diff --git a/src/cmd/compile/internal/walk/convert.go b/src/cmd/compile/internal/walk/convert.go
index 99abf30668..d0cd5ff753 100644
--- a/src/cmd/compile/internal/walk/convert.go
+++ b/src/cmd/compile/internal/walk/convert.go
@@ -438,18 +438,14 @@ func walkCheckPtrAlignment(n *ir.ConvExpr, init *ir.Nodes, count ir.Node) ir.Nod
 }
 
 func walkCheckPtrArithmetic(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
-	// Calling cheapexpr(n, init) below leads to a recursive call
-	// to walkexpr, which leads us back here again. Use n.Opt to
+	// Calling cheapexpr(n, init) below leads to a recursive call to
+	// walkexpr, which leads us back here again. Use n.Checkptr to
 	// prevent infinite loops.
-	if opt := n.Opt(); opt == &walkCheckPtrArithmeticMarker {
+	if n.CheckPtr() {
 		return n
-	} else if opt != nil {
-		// We use n.Opt() here because today it's not used for OCONVNOP. If that changes,
-		// there's no guarantee that temporarily replacing it is safe, so just hard fail here.
-		base.Fatalf("unexpected Opt: %v", opt)
 	}
-	n.SetOpt(&walkCheckPtrArithmeticMarker)
-	defer n.SetOpt(nil)
+	n.SetCheckPtr(true)
+	defer n.SetCheckPtr(false)
 
 	// TODO(mdempsky): Make stricter. We only need to exempt
 	// reflect.Value.Pointer and reflect.Value.UnsafeAddr.
diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index c4c3debde4..bdc9a2ea6a 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -377,8 +377,6 @@ func walkAppendArgs(n *ir.CallExpr, init *ir.Nodes) {
 
 var wrapCall_prgen int
 
-var walkCheckPtrArithmeticMarker byte
-
 // appendWalkStmt typechecks and walks stmt and then appends it to init.
 func appendWalkStmt(init *ir.Nodes, stmt ir.Node) {
 	op := stmt.Op()
-- 
GitLab


From 25c613c02dabb45f3a3dc038a8f01c664d98731a Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 28 Dec 2020 19:14:39 -0800
Subject: [PATCH 0366/2400] [dev.regabi] cmd/compile: add Linksym helpers

Syms are meant to be just interned (pkg, name) tuples, and are a
purely abstract, Go-language concept. As such, associating them with
linker symbols (a low-level, implementation-oriented detail) is
inappropriate.

There's still work to be done before linker symbols can be directly
attached to their appropriate, higher-level objects instead. But in
the mean-time, we can at least add helper functions and discourage
folks from using Sym.Linksym directly. The next CL will mechanically
rewrite code to use these helpers where possible.

Passes toolstash -cmp.

Change-Id: I413bd1c80bce056304f9a7343526bd153f2b9c7d
Reviewed-on: https://go-review.googlesource.com/c/go/+/280639
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/gc/obj.go              |  2 +-
 src/cmd/compile/internal/ir/func.go             | 10 +++-------
 src/cmd/compile/internal/ir/name.go             |  3 +++
 src/cmd/compile/internal/reflectdata/reflect.go | 16 ++++++++++++++--
 src/cmd/compile/internal/ssagen/pgen.go         | 14 ++++----------
 src/cmd/compile/internal/ssagen/ssa.go          |  4 ++--
 src/cmd/compile/internal/staticdata/data.go     |  7 +++++++
 src/cmd/compile/internal/types/sym.go           |  4 ++++
 src/cmd/compile/internal/walk/expr.go           |  2 +-
 9 files changed, 39 insertions(+), 23 deletions(-)

diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 0ab3a8dad4..d0454981f4 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -260,7 +260,7 @@ func addGCLocals() {
 	}
 }
 
-func ggloblnod(nam ir.Node) {
+func ggloblnod(nam *ir.Name) {
 	s := nam.Sym().Linksym()
 	s.Gotype = reflectdata.TypeSym(nam.Type()).Linksym()
 	flags := 0
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 16d67f6ae0..a4f5875aab 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -78,7 +78,7 @@ type Func struct {
 	// Marks records scope boundary changes.
 	Marks []Mark
 
-	FieldTrack map[*types.Sym]struct{}
+	FieldTrack map[*obj.LSym]struct{}
 	DebugInfo  interface{}
 	LSym       *obj.LSym
 
@@ -119,12 +119,8 @@ func (f *Func) isStmt() {}
 func (f *Func) Type() *types.Type     { return f.typ }
 func (f *Func) SetType(x *types.Type) { f.typ = x }
 
-func (f *Func) Sym() *types.Sym {
-	if f.Nname != nil {
-		return f.Nname.Sym()
-	}
-	return nil
-}
+func (f *Func) Sym() *types.Sym    { return f.Nname.Sym() }
+func (f *Func) Linksym() *obj.LSym { return f.Nname.Linksym() }
 
 // An Inline holds fields used for function bodies that can be inlined.
 type Inline struct {
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 980e3f6349..b13b57e95f 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -7,6 +7,7 @@ package ir
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
+	"cmd/internal/obj"
 	"cmd/internal/objabi"
 	"cmd/internal/src"
 
@@ -238,6 +239,8 @@ func (n *Name) SetFrameOffset(x int64) { n.Offset_ = x }
 func (n *Name) Iota() int64            { return n.Offset_ }
 func (n *Name) SetIota(x int64)        { n.Offset_ = x }
 
+func (n *Name) Linksym() *obj.LSym { return n.sym.Linksym() }
+
 func (*Name) CanBeNtype()    {}
 func (*Name) CanBeAnSSASym() {}
 func (*Name) CanBeAnSSAAux() {}
diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index df80380fc1..4c625b40cb 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -812,8 +812,8 @@ func dcommontype(lsym *obj.LSym, t *types.Type) int {
 
 // TrackSym returns the symbol for tracking use of field/method f, assumed
 // to be a member of struct/interface type t.
-func TrackSym(t *types.Type, f *types.Field) *types.Sym {
-	return ir.Pkgs.Track.Lookup(t.ShortString() + "." + f.Sym.Name)
+func TrackSym(t *types.Type, f *types.Field) *obj.LSym {
+	return ir.Pkgs.Track.Lookup(t.ShortString() + "." + f.Sym.Name).Linksym()
 }
 
 func TypeSymPrefix(prefix string, t *types.Type) *types.Sym {
@@ -845,6 +845,18 @@ func TypeSym(t *types.Type) *types.Sym {
 	return s
 }
 
+func TypeLinksymPrefix(prefix string, t *types.Type) *obj.LSym {
+	return TypeSymPrefix(prefix, t).Linksym()
+}
+
+func TypeLinksymLookup(name string) *obj.LSym {
+	return types.TypeSymLookup(name).Linksym()
+}
+
+func TypeLinksym(t *types.Type) *obj.LSym {
+	return TypeSym(t).Linksym()
+}
+
 func TypePtr(t *types.Type) *ir.AddrExpr {
 	s := TypeSym(t)
 	if s.Def == nil {
diff --git a/src/cmd/compile/internal/ssagen/pgen.go b/src/cmd/compile/internal/ssagen/pgen.go
index bc6be20d86..72ce233fda 100644
--- a/src/cmd/compile/internal/ssagen/pgen.go
+++ b/src/cmd/compile/internal/ssagen/pgen.go
@@ -225,7 +225,7 @@ func StackOffset(slot ssa.LocalSlot) int32 {
 
 // fieldtrack adds R_USEFIELD relocations to fnsym to record any
 // struct fields that it used.
-func fieldtrack(fnsym *obj.LSym, tracked map[*types.Sym]struct{}) {
+func fieldtrack(fnsym *obj.LSym, tracked map[*obj.LSym]struct{}) {
 	if fnsym == nil {
 		return
 	}
@@ -233,24 +233,18 @@ func fieldtrack(fnsym *obj.LSym, tracked map[*types.Sym]struct{}) {
 		return
 	}
 
-	trackSyms := make([]*types.Sym, 0, len(tracked))
+	trackSyms := make([]*obj.LSym, 0, len(tracked))
 	for sym := range tracked {
 		trackSyms = append(trackSyms, sym)
 	}
-	sort.Sort(symByName(trackSyms))
+	sort.Slice(trackSyms, func(i, j int) bool { return trackSyms[i].Name < trackSyms[j].Name })
 	for _, sym := range trackSyms {
 		r := obj.Addrel(fnsym)
-		r.Sym = sym.Linksym()
+		r.Sym = sym
 		r.Type = objabi.R_USEFIELD
 	}
 }
 
-type symByName []*types.Sym
-
-func (a symByName) Len() int           { return len(a) }
-func (a symByName) Less(i, j int) bool { return a[i].Name < a[j].Name }
-func (a symByName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
-
 // largeStack is info about a function whose stack frame is too large (rare).
 type largeStack struct {
 	locals int64
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 509d53f8c9..5cf267636b 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -2106,7 +2106,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		return s.newValue3(ssa.OpSliceMake, n.Type(), ptr, len, len)
 	case ir.OCFUNC:
 		n := n.(*ir.UnaryExpr)
-		aux := n.X.Sym().Linksym()
+		aux := n.X.(*ir.Name).Linksym()
 		return s.entryNewValue1A(ssa.OpAddr, n.Type(), aux, s.sb)
 	case ir.ONAME:
 		n := n.(*ir.Name)
@@ -6826,7 +6826,7 @@ func AddAux2(a *obj.Addr, v *ssa.Value, offset int64) {
 	case *ir.Name:
 		if n.Class_ == ir.PPARAM || n.Class_ == ir.PPARAMOUT {
 			a.Name = obj.NAME_PARAM
-			a.Sym = ir.Orig(n).Sym().Linksym()
+			a.Sym = ir.Orig(n).(*ir.Name).Linksym()
 			a.Offset += n.FrameOffset()
 			break
 		}
diff --git a/src/cmd/compile/internal/staticdata/data.go b/src/cmd/compile/internal/staticdata/data.go
index 342a2e2bbc..ab9cb5bd7e 100644
--- a/src/cmd/compile/internal/staticdata/data.go
+++ b/src/cmd/compile/internal/staticdata/data.go
@@ -258,6 +258,13 @@ func FuncSym(s *types.Sym) *types.Sym {
 	return sf
 }
 
+func FuncLinksym(n *ir.Name) *obj.LSym {
+	if n.Op() != ir.ONAME || n.Class_ != ir.PFUNC {
+		base.Fatalf("expected func name: %v", n)
+	}
+	return FuncSym(n.Sym()).Linksym()
+}
+
 // NeedFuncSym ensures that s·f is exported.
 // It is only used with -dynlink.
 // When not compiling for dynamic linking,
diff --git a/src/cmd/compile/internal/types/sym.go b/src/cmd/compile/internal/types/sym.go
index cd061d5f1c..2914e2ed3f 100644
--- a/src/cmd/compile/internal/types/sym.go
+++ b/src/cmd/compile/internal/types/sym.go
@@ -74,6 +74,10 @@ func (sym *Sym) LinksymName() string {
 	return sym.Pkg.Prefix + "." + sym.Name
 }
 
+// Deprecated: This method should not be used directly. Instead, use a
+// higher-level abstraction that directly returns the linker symbol
+// for a named object. For example, reflectdata.TypeLinksym(t) instead
+// of reflectdata.TypeSym(t).Linksym().
 func (sym *Sym) Linksym() *obj.LSym {
 	if sym == nil {
 		return nil
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index f40aa6adb5..0d7ffca15d 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -975,7 +975,7 @@ func usefield(n *ir.SelectorExpr) {
 
 	sym := reflectdata.TrackSym(outer, field)
 	if ir.CurFunc.FieldTrack == nil {
-		ir.CurFunc.FieldTrack = make(map[*types.Sym]struct{})
+		ir.CurFunc.FieldTrack = make(map[*obj.LSym]struct{})
 	}
 	ir.CurFunc.FieldTrack[sym] = struct{}{}
 }
-- 
GitLab


From ec59b197d5d92ad758c3214d906f9c750cd5b84e Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 28 Dec 2020 19:34:35 -0800
Subject: [PATCH 0367/2400] [dev.regabi] cmd/compile: rewrite to use linksym
 helpers [generated]

Passes toolstash -cmp.

[git-generate]
cd src/cmd/compile/internal/gc
pkgs=$(grep -l -w Linksym ../*/*.go | xargs dirname | grep -v '/gc$' | sort -u)
rf '
	ex . '"$(echo $pkgs)"' {
		import "cmd/compile/internal/ir"
		import "cmd/compile/internal/reflectdata"
		import "cmd/compile/internal/staticdata"
		import "cmd/compile/internal/types"

		avoid reflectdata.TypeLinksym
		avoid reflectdata.TypeLinksymLookup
		avoid reflectdata.TypeLinksymPrefix
		avoid staticdata.FuncLinksym

		var f *ir.Func
		var n *ir.Name
		var s string
		var t *types.Type

		f.Sym().Linksym() -> f.Linksym()
		n.Sym().Linksym() -> n.Linksym()

		reflectdata.TypeSym(t).Linksym() -> reflectdata.TypeLinksym(t)
		reflectdata.TypeSymPrefix(s, t).Linksym() -> reflectdata.TypeLinksymPrefix(s, t)
		staticdata.FuncSym(n.Sym()).Linksym() -> staticdata.FuncLinksym(n)
		types.TypeSymLookup(s).Linksym() -> reflectdata.TypeLinksymLookup(s)
	}
'

Change-Id: I7a3ae1dcd61bcdf4a29f708ff12f7f80c2b280c6
Reviewed-on: https://go-review.googlesource.com/c/go/+/280640
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/dwarfgen/dwarf.go     | 10 +++++-----
 src/cmd/compile/internal/gc/abiutils_test.go   |  4 ++--
 src/cmd/compile/internal/gc/compile.go         |  2 +-
 src/cmd/compile/internal/gc/main.go            |  4 ++--
 src/cmd/compile/internal/gc/obj.go             |  4 ++--
 src/cmd/compile/internal/inline/inl.go         |  2 +-
 src/cmd/compile/internal/ir/name.go            |  2 +-
 src/cmd/compile/internal/pkginit/init.go       |  4 ++--
 src/cmd/compile/internal/reflectdata/alg.go    |  8 ++++----
 .../compile/internal/reflectdata/reflect.go    |  6 +++---
 src/cmd/compile/internal/ssagen/abi.go         |  2 +-
 src/cmd/compile/internal/ssagen/ssa.go         | 10 +++++-----
 src/cmd/compile/internal/staticdata/data.go    | 18 +++++++++---------
 src/cmd/compile/internal/staticdata/embed.go   |  4 ++--
 src/cmd/compile/internal/staticinit/sched.go   |  4 ++--
 src/cmd/compile/internal/walk/complit.go       |  2 +-
 src/cmd/compile/internal/walk/race.go          |  2 +-
 17 files changed, 44 insertions(+), 44 deletions(-)

diff --git a/src/cmd/compile/internal/dwarfgen/dwarf.go b/src/cmd/compile/internal/dwarfgen/dwarf.go
index 19cb70058c..d0bee58442 100644
--- a/src/cmd/compile/internal/dwarfgen/dwarf.go
+++ b/src/cmd/compile/internal/dwarfgen/dwarf.go
@@ -26,7 +26,7 @@ func Info(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.Scope,
 	fn := curfn.(*ir.Func)
 
 	if fn.Nname != nil {
-		expect := fn.Sym().Linksym()
+		expect := fn.Linksym()
 		if fnsym.ABI() == obj.ABI0 {
 			expect = fn.Sym().LinksymABI0()
 		}
@@ -90,7 +90,7 @@ func Info(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.Scope,
 				continue
 			}
 			apdecls = append(apdecls, n)
-			fnsym.Func().RecordAutoType(reflectdata.TypeSym(n.Type()).Linksym())
+			fnsym.Func().RecordAutoType(reflectdata.TypeLinksym(n.Type()))
 		}
 	}
 
@@ -240,7 +240,7 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 			ChildIndex:    -1,
 		})
 		// Record go type of to insure that it gets emitted by the linker.
-		fnsym.Func().RecordAutoType(reflectdata.TypeSym(n.Type()).Linksym())
+		fnsym.Func().RecordAutoType(reflectdata.TypeLinksym(n.Type()))
 	}
 
 	return decls, vars
@@ -309,7 +309,7 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 	}
 
 	typename := dwarf.InfoPrefix + types.TypeSymName(n.Type())
-	delete(fnsym.Func().Autot, reflectdata.TypeSym(n.Type()).Linksym())
+	delete(fnsym.Func().Autot, reflectdata.TypeLinksym(n.Type()))
 	inlIndex := 0
 	if base.Flag.GenDwarfInl > 1 {
 		if n.Name().InlFormal() || n.Name().InlLocal() {
@@ -376,7 +376,7 @@ func createComplexVar(fnsym *obj.LSym, fn *ir.Func, varID ssa.VarID) *dwarf.Var
 		return nil
 	}
 
-	gotype := reflectdata.TypeSym(n.Type()).Linksym()
+	gotype := reflectdata.TypeLinksym(n.Type())
 	delete(fnsym.Func().Autot, gotype)
 	typename := dwarf.InfoPrefix + gotype.Name[len("type."):]
 	inlIndex := 0
diff --git a/src/cmd/compile/internal/gc/abiutils_test.go b/src/cmd/compile/internal/gc/abiutils_test.go
index a421a229dc..656eab18cb 100644
--- a/src/cmd/compile/internal/gc/abiutils_test.go
+++ b/src/cmd/compile/internal/gc/abiutils_test.go
@@ -40,10 +40,10 @@ func TestMain(m *testing.M) {
 	types.PtrSize = ssagen.Arch.LinkArch.PtrSize
 	types.RegSize = ssagen.Arch.LinkArch.RegSize
 	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
-		return reflectdata.TypeSym(t).Linksym()
+		return reflectdata.TypeLinksym(t)
 	}
 	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
-		return reflectdata.TypeSym(t).Linksym()
+		return reflectdata.TypeLinksym(t)
 	}
 	typecheck.Init()
 	os.Exit(m.Run())
diff --git a/src/cmd/compile/internal/gc/compile.go b/src/cmd/compile/internal/gc/compile.go
index 926b2dee95..1b3dd672f3 100644
--- a/src/cmd/compile/internal/gc/compile.go
+++ b/src/cmd/compile/internal/gc/compile.go
@@ -174,5 +174,5 @@ func isInlinableButNotInlined(fn *ir.Func) bool {
 	if fn.Sym() == nil {
 		return true
 	}
-	return !fn.Sym().Linksym().WasInlined()
+	return !fn.Linksym().WasInlined()
 }
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index ced82736ce..a4613f04fb 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -191,7 +191,7 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	types.RegSize = ssagen.Arch.LinkArch.RegSize
 	types.MaxWidth = ssagen.Arch.MAXWIDTH
 	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
-		return reflectdata.TypeSym(t).Linksym()
+		return reflectdata.TypeLinksym(t)
 	}
 
 	typecheck.Target = new(ir.Package)
@@ -203,7 +203,7 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	base.AutogeneratedPos = makePos(src.NewFileBase("<autogenerated>", "<autogenerated>"), 1, 0)
 
 	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
-		return reflectdata.TypeSym(t).Linksym()
+		return reflectdata.TypeLinksym(t)
 	}
 	typecheck.Init()
 
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index d0454981f4..45eadf719e 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -261,8 +261,8 @@ func addGCLocals() {
 }
 
 func ggloblnod(nam *ir.Name) {
-	s := nam.Sym().Linksym()
-	s.Gotype = reflectdata.TypeSym(nam.Type()).Linksym()
+	s := nam.Linksym()
+	s.Gotype = reflectdata.TypeLinksym(nam.Type())
 	flags := 0
 	if nam.Name().Readonly() {
 		flags = obj.RODATA
diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index fc6a17b933..126871b805 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -932,7 +932,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 		parent = b.InliningIndex()
 	}
 
-	sym := fn.Sym().Linksym()
+	sym := fn.Linksym()
 	newIndex := base.Ctxt.InlTree.Add(parent, n.Pos(), sym)
 
 	// Add an inline mark just before the inlined body.
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index b13b57e95f..7958391435 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -314,7 +314,7 @@ func (n *Name) MarkReadonly() {
 	// Mark the linksym as readonly immediately
 	// so that the SSA backend can use this information.
 	// It will be overridden later during dumpglobls.
-	n.Sym().Linksym().Type = objabi.SRODATA
+	n.Linksym().Type = objabi.SRODATA
 }
 
 // Val returns the constant.Value for the node.
diff --git a/src/cmd/compile/internal/pkginit/init.go b/src/cmd/compile/internal/pkginit/init.go
index f964edee88..8e3592700c 100644
--- a/src/cmd/compile/internal/pkginit/init.go
+++ b/src/cmd/compile/internal/pkginit/init.go
@@ -34,7 +34,7 @@ func Task() *ir.Name {
 		if n.Op() != ir.ONAME || n.(*ir.Name).Class_ != ir.PEXTERN {
 			base.Fatalf("bad inittask: %v", n)
 		}
-		deps = append(deps, n.(*ir.Name).Sym().Linksym())
+		deps = append(deps, n.(*ir.Name).Linksym())
 	}
 
 	// Make a function that contains all the initialization statements.
@@ -74,7 +74,7 @@ func Task() *ir.Name {
 				continue
 			}
 		}
-		fns = append(fns, fn.Nname.Sym().Linksym())
+		fns = append(fns, fn.Nname.Linksym())
 	}
 
 	if len(deps) == 0 && len(fns) == 0 && types.LocalPkg.Name != "main" && types.LocalPkg.Name != "runtime" {
diff --git a/src/cmd/compile/internal/reflectdata/alg.go b/src/cmd/compile/internal/reflectdata/alg.go
index 1f943f5795..5603aefa77 100644
--- a/src/cmd/compile/internal/reflectdata/alg.go
+++ b/src/cmd/compile/internal/reflectdata/alg.go
@@ -104,7 +104,7 @@ func genhash(t *types.Type) *obj.LSym {
 		// For other sizes of plain memory, we build a closure
 		// that calls memhash_varlen. The size of the memory is
 		// encoded in the first slot of the closure.
-		closure := types.TypeSymLookup(fmt.Sprintf(".hashfunc%d", t.Width)).Linksym()
+		closure := TypeLinksymLookup(fmt.Sprintf(".hashfunc%d", t.Width))
 		if len(closure.P) > 0 { // already generated
 			return closure
 		}
@@ -120,7 +120,7 @@ func genhash(t *types.Type) *obj.LSym {
 		break
 	}
 
-	closure := TypeSymPrefix(".hashfunc", t).Linksym()
+	closure := TypeLinksymPrefix(".hashfunc", t)
 	if len(closure.P) > 0 { // already generated
 		return closure
 	}
@@ -347,7 +347,7 @@ func geneq(t *types.Type) *obj.LSym {
 	case types.AMEM:
 		// make equality closure. The size of the type
 		// is encoded in the closure.
-		closure := types.TypeSymLookup(fmt.Sprintf(".eqfunc%d", t.Width)).Linksym()
+		closure := TypeLinksymLookup(fmt.Sprintf(".eqfunc%d", t.Width))
 		if len(closure.P) != 0 {
 			return closure
 		}
@@ -363,7 +363,7 @@ func geneq(t *types.Type) *obj.LSym {
 		break
 	}
 
-	closure := TypeSymPrefix(".eqfunc", t).Linksym()
+	closure := TypeLinksymPrefix(".eqfunc", t)
 	if len(closure.P) > 0 { // already generated
 		return closure
 	}
diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index 4c625b40cb..87f381fbdd 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -1583,7 +1583,7 @@ func dgcprog(t *types.Type) (*obj.LSym, int64) {
 	if t.Width == types.BADWIDTH {
 		base.Fatalf("dgcprog: %v badwidth", t)
 	}
-	lsym := TypeSymPrefix(".gcprog", t).Linksym()
+	lsym := TypeLinksymPrefix(".gcprog", t)
 	var p gcProg
 	p.init(lsym)
 	p.emit(t, 0)
@@ -1857,7 +1857,7 @@ var ZeroSize int64
 // MarkTypeUsedInInterface marks that type t is converted to an interface.
 // This information is used in the linker in dead method elimination.
 func MarkTypeUsedInInterface(t *types.Type, from *obj.LSym) {
-	tsym := TypeSym(t).Linksym()
+	tsym := TypeLinksym(t)
 	// Emit a marker relocation. The linker will know the type is converted
 	// to an interface if "from" is reachable.
 	r := obj.Addrel(from)
@@ -1870,7 +1870,7 @@ func MarkTypeUsedInInterface(t *types.Type, from *obj.LSym) {
 func MarkUsedIfaceMethod(n *ir.CallExpr) {
 	dot := n.X.(*ir.SelectorExpr)
 	ityp := dot.X.Type()
-	tsym := TypeSym(ityp).Linksym()
+	tsym := TypeLinksym(ityp)
 	r := obj.Addrel(ir.CurFunc.LSym)
 	r.Sym = tsym
 	// dot.Xoffset is the method index * Widthptr (the offset of code pointer
diff --git a/src/cmd/compile/internal/ssagen/abi.go b/src/cmd/compile/internal/ssagen/abi.go
index b0338e8155..cd5d962b91 100644
--- a/src/cmd/compile/internal/ssagen/abi.go
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -166,7 +166,7 @@ func selectLSym(f *ir.Func, hasBody bool) {
 			f.LSym = nam.Sym().LinksymABI0()
 			needABIWrapper, wrapperABI = true, obj.ABIInternal
 		} else {
-			f.LSym = nam.Sym().Linksym()
+			f.LSym = nam.Linksym()
 			// No ABI override. Check that the symbol is
 			// using the expected ABI.
 			want := obj.ABIInternal
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 5cf267636b..15c023d332 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -2112,7 +2112,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		n := n.(*ir.Name)
 		if n.Class_ == ir.PFUNC {
 			// "value" of a function is the address of the function's closure
-			sym := staticdata.FuncSym(n.Sym()).Linksym()
+			sym := staticdata.FuncLinksym(n)
 			return s.entryNewValue1A(ssa.OpAddr, types.NewPtr(n.Type()), sym, s.sb)
 		}
 		if s.canSSA(n) {
@@ -4959,7 +4959,7 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 		switch n.Class_ {
 		case ir.PEXTERN:
 			// global variable
-			v := s.entryNewValue1A(ssa.OpAddr, t, n.Sym().Linksym(), s.sb)
+			v := s.entryNewValue1A(ssa.OpAddr, t, n.Linksym(), s.sb)
 			// TODO: Make OpAddr use AuxInt as well as Aux.
 			if offset != 0 {
 				v = s.entryNewValue1I(ssa.OpOffPtr, v.Type, offset, v)
@@ -6831,7 +6831,7 @@ func AddAux2(a *obj.Addr, v *ssa.Value, offset int64) {
 			break
 		}
 		a.Name = obj.NAME_AUTO
-		a.Sym = n.Sym().Linksym()
+		a.Sym = n.Linksym()
 		a.Offset += n.FrameOffset()
 	default:
 		v.Fatalf("aux in %s not implemented %#v", v, v.Aux)
@@ -6963,7 +6963,7 @@ func CheckLoweredGetClosurePtr(v *ssa.Value) {
 func AddrAuto(a *obj.Addr, v *ssa.Value) {
 	n, off := ssa.AutoVar(v)
 	a.Type = obj.TYPE_MEM
-	a.Sym = n.Sym().Linksym()
+	a.Sym = n.Linksym()
 	a.Reg = int16(Arch.REGSP)
 	a.Offset = n.FrameOffset() + off
 	if n.Class_ == ir.PPARAM || n.Class_ == ir.PPARAMOUT {
@@ -6979,7 +6979,7 @@ func (s *State) AddrScratch(a *obj.Addr) {
 	}
 	a.Type = obj.TYPE_MEM
 	a.Name = obj.NAME_AUTO
-	a.Sym = s.ScratchFpMem.Sym().Linksym()
+	a.Sym = s.ScratchFpMem.Linksym()
 	a.Reg = int16(Arch.REGSP)
 	a.Offset = s.ScratchFpMem.Offset_
 }
diff --git a/src/cmd/compile/internal/staticdata/data.go b/src/cmd/compile/internal/staticdata/data.go
index ab9cb5bd7e..260731244f 100644
--- a/src/cmd/compile/internal/staticdata/data.go
+++ b/src/cmd/compile/internal/staticdata/data.go
@@ -37,8 +37,8 @@ func InitAddr(n *ir.Name, noff int64, a *ir.Name, aoff int64) {
 	if a.Op() != ir.ONAME {
 		base.Fatalf("addrsym a op %v", a.Op())
 	}
-	s := n.Sym().Linksym()
-	s.WriteAddr(base.Ctxt, noff, types.PtrSize, a.Sym().Linksym(), aoff)
+	s := n.Linksym()
+	s.WriteAddr(base.Ctxt, noff, types.PtrSize, a.Linksym(), aoff)
 }
 
 // InitFunc writes the static address of f to n. f must be a global function.
@@ -53,18 +53,18 @@ func InitFunc(n *ir.Name, noff int64, f *ir.Name) {
 	if f.Class_ != ir.PFUNC {
 		base.Fatalf("pfuncsym class not PFUNC %d", f.Class_)
 	}
-	s := n.Sym().Linksym()
-	s.WriteAddr(base.Ctxt, noff, types.PtrSize, FuncSym(f.Sym()).Linksym(), 0)
+	s := n.Linksym()
+	s.WriteAddr(base.Ctxt, noff, types.PtrSize, FuncLinksym(f), 0)
 }
 
 // InitSlice writes a static slice symbol {&arr, lencap, lencap} to n+noff.
 // InitSlice does not modify n.
 func InitSlice(n *ir.Name, noff int64, arr *ir.Name, lencap int64) {
-	s := n.Sym().Linksym()
+	s := n.Linksym()
 	if arr.Op() != ir.ONAME {
 		base.Fatalf("slicesym non-name arr %v", arr)
 	}
-	s.WriteAddr(base.Ctxt, noff, types.PtrSize, arr.Sym().Linksym(), 0)
+	s.WriteAddr(base.Ctxt, noff, types.PtrSize, arr.Linksym(), 0)
 	s.WriteInt(base.Ctxt, noff+types.SliceLenOffset, types.PtrSize, lencap)
 	s.WriteInt(base.Ctxt, noff+types.SliceCapOffset, types.PtrSize, lencap)
 }
@@ -141,7 +141,7 @@ func fileStringSym(pos src.XPos, file string, readonly bool, hash []byte) (*obj.
 		if readonly {
 			sym = StringSym(pos, string(data))
 		} else {
-			sym = slicedata(pos, string(data)).Sym().Linksym()
+			sym = slicedata(pos, string(data)).Linksym()
 		}
 		if len(hash) > 0 {
 			sum := sha256.Sum256(data)
@@ -189,7 +189,7 @@ func fileStringSym(pos src.XPos, file string, readonly bool, hash []byte) (*obj.
 	} else {
 		// Emit a zero-length data symbol
 		// and then fix up length and content to use file.
-		symdata = slicedata(pos, "").Sym().Linksym()
+		symdata = slicedata(pos, "").Linksym()
 		symdata.Size = size
 		symdata.Type = objabi.SNOPTRDATA
 		info := symdata.NewFileInfo()
@@ -318,7 +318,7 @@ func InitConst(n *ir.Name, noff int64, c ir.Node, wid int) {
 	if c.Op() != ir.OLITERAL {
 		base.Fatalf("litsym c op %v", c.Op())
 	}
-	s := n.Sym().Linksym()
+	s := n.Linksym()
 	switch u := c.Val(); u.Kind() {
 	case constant.Bool:
 		i := int64(obj.Bool2int(constant.BoolVal(u)))
diff --git a/src/cmd/compile/internal/staticdata/embed.go b/src/cmd/compile/internal/staticdata/embed.go
index 55c9a3356e..2e551f0b2c 100644
--- a/src/cmd/compile/internal/staticdata/embed.go
+++ b/src/cmd/compile/internal/staticdata/embed.go
@@ -145,7 +145,7 @@ func WriteEmbed(v *ir.Name) {
 		if err != nil {
 			base.ErrorfAt(v.Pos(), "embed %s: %v", file, err)
 		}
-		sym := v.Sym().Linksym()
+		sym := v.Linksym()
 		off := 0
 		off = objw.SymPtr(sym, off, fsym, 0)       // data string
 		off = objw.Uintptr(sym, off, uint64(size)) // len
@@ -187,7 +187,7 @@ func WriteEmbed(v *ir.Name) {
 			}
 		}
 		objw.Global(slicedata, int32(off), obj.RODATA|obj.LOCAL)
-		sym := v.Sym().Linksym()
+		sym := v.Linksym()
 		objw.SymPtr(sym, 0, slicedata, 0)
 	}
 }
diff --git a/src/cmd/compile/internal/staticinit/sched.go b/src/cmd/compile/internal/staticinit/sched.go
index d8f51766de..1b0af1b05d 100644
--- a/src/cmd/compile/internal/staticinit/sched.go
+++ b/src/cmd/compile/internal/staticinit/sched.go
@@ -313,7 +313,7 @@ func (s *Schedule) StaticAssign(l *ir.Name, loff int64, r ir.Node, typ *types.Ty
 			return val.Op() == ir.ONIL
 		}
 
-		reflectdata.MarkTypeUsedInInterface(val.Type(), l.Sym().Linksym())
+		reflectdata.MarkTypeUsedInInterface(val.Type(), l.Linksym())
 
 		var itab *ir.AddrExpr
 		if typ.IsEmptyInterface() {
@@ -445,7 +445,7 @@ func StaticName(t *types.Type) *ir.Name {
 	statuniqgen++
 	typecheck.Declare(n, ir.PEXTERN)
 	n.SetType(t)
-	n.Sym().Linksym().Set(obj.AttrLocal, true)
+	n.Linksym().Set(obj.AttrLocal, true)
 	return n
 }
 
diff --git a/src/cmd/compile/internal/walk/complit.go b/src/cmd/compile/internal/walk/complit.go
index fadcd87f25..3c28ed70ad 100644
--- a/src/cmd/compile/internal/walk/complit.go
+++ b/src/cmd/compile/internal/walk/complit.go
@@ -59,7 +59,7 @@ func (c initContext) String() string {
 func readonlystaticname(t *types.Type) *ir.Name {
 	n := staticinit.StaticName(t)
 	n.MarkReadonly()
-	n.Sym().Linksym().Set(obj.AttrContentAddressable, true)
+	n.Linksym().Set(obj.AttrContentAddressable, true)
 	return n
 }
 
diff --git a/src/cmd/compile/internal/walk/race.go b/src/cmd/compile/internal/walk/race.go
index 1fe439a99a..87a8839dcd 100644
--- a/src/cmd/compile/internal/walk/race.go
+++ b/src/cmd/compile/internal/walk/race.go
@@ -14,7 +14,7 @@ import (
 )
 
 func instrument(fn *ir.Func) {
-	if fn.Pragma&ir.Norace != 0 || (fn.Sym().Linksym() != nil && fn.Sym().Linksym().ABIWrapper()) {
+	if fn.Pragma&ir.Norace != 0 || (fn.Linksym() != nil && fn.Linksym().ABIWrapper()) {
 		return
 	}
 
-- 
GitLab


From a5ec920160da51166ee22ac0e5335f51a5d36d8e Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 28 Dec 2020 21:01:34 -0800
Subject: [PATCH 0368/2400] [dev.regabi] cmd/compile: more Linksym cleanup

This largely gets rid of the remaining direct Linksym calls, hopefully
enough to discourage people from following bad existing practice until
Sym.Linksym can be removed entirely.

Passes toolstash -cmp.

Change-Id: I5d8f8f703ace7256538fc79648891ede0d879dc2
Reviewed-on: https://go-review.googlesource.com/c/go/+/280641
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/gc/obj.go            |  4 +-
 src/cmd/compile/internal/pkginit/init.go      |  4 +-
 src/cmd/compile/internal/reflectdata/alg.go   |  4 +-
 .../compile/internal/reflectdata/reflect.go   | 96 ++++++++-----------
 src/cmd/compile/internal/ssagen/ssa.go        |  2 +-
 src/cmd/compile/internal/staticdata/data.go   |  2 +-
 6 files changed, 46 insertions(+), 66 deletions(-)

diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 45eadf719e..1e8ac8ebb2 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -148,8 +148,8 @@ func dumpdata() {
 	dumpglobls(typecheck.Target.Externs[numExterns:])
 
 	if reflectdata.ZeroSize > 0 {
-		zero := ir.Pkgs.Map.Lookup("zero")
-		objw.Global(zero.Linksym(), int32(reflectdata.ZeroSize), obj.DUPOK|obj.RODATA)
+		zero := ir.Pkgs.Map.Lookup("zero").Linksym()
+		objw.Global(zero, int32(reflectdata.ZeroSize), obj.DUPOK|obj.RODATA)
 	}
 
 	addGCLocals()
diff --git a/src/cmd/compile/internal/pkginit/init.go b/src/cmd/compile/internal/pkginit/init.go
index 8e3592700c..f1ffbb5933 100644
--- a/src/cmd/compile/internal/pkginit/init.go
+++ b/src/cmd/compile/internal/pkginit/init.go
@@ -56,7 +56,7 @@ func Task() *ir.Name {
 		typecheck.Stmts(nf)
 		ir.CurFunc = nil
 		typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
-		fns = append(fns, initializers.Linksym())
+		fns = append(fns, fn.Linksym())
 	}
 	if typecheck.InitTodoFunc.Dcl != nil {
 		// We only generate temps using initTodo if there
@@ -87,7 +87,7 @@ func Task() *ir.Name {
 	task.SetType(types.Types[types.TUINT8]) // fake type
 	task.Class_ = ir.PEXTERN
 	sym.Def = task
-	lsym := sym.Linksym()
+	lsym := task.Linksym()
 	ot := 0
 	ot = objw.Uintptr(lsym, ot, 0) // state: not initialized yet
 	ot = objw.Uintptr(lsym, ot, uint64(len(deps)))
diff --git a/src/cmd/compile/internal/reflectdata/alg.go b/src/cmd/compile/internal/reflectdata/alg.go
index 5603aefa77..d23ca6c7aa 100644
--- a/src/cmd/compile/internal/reflectdata/alg.go
+++ b/src/cmd/compile/internal/reflectdata/alg.go
@@ -255,7 +255,7 @@ func genhash(t *types.Type) *obj.LSym {
 
 	// Build closure. It doesn't close over any variables, so
 	// it contains just the function pointer.
-	objw.SymPtr(closure, 0, sym.Linksym(), 0)
+	objw.SymPtr(closure, 0, fn.Linksym(), 0)
 	objw.Global(closure, int32(types.PtrSize), obj.DUPOK|obj.RODATA)
 
 	return closure
@@ -634,7 +634,7 @@ func geneq(t *types.Type) *obj.LSym {
 	typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
 
 	// Generate a closure which points at the function we just generated.
-	objw.SymPtr(closure, 0, sym.Linksym(), 0)
+	objw.SymPtr(closure, 0, fn.Linksym(), 0)
 	objw.Global(closure, int32(types.PtrSize), obj.DUPOK|obj.RODATA)
 	return closure
 }
diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index 87f381fbdd..5f88262ddf 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -52,13 +52,13 @@ var (
 	signatslice []*types.Type
 
 	itabs []itabEntry
-	ptabs []ptabEntry
+	ptabs []*ir.Name
 )
 
 type typeSig struct {
 	name  *types.Sym
-	isym  *types.Sym
-	tsym  *types.Sym
+	isym  *obj.LSym
+	tsym  *obj.LSym
 	type_ *types.Type
 	mtype *types.Type
 }
@@ -327,21 +327,19 @@ func methods(t *types.Type) []*typeSig {
 	// generating code if necessary.
 	var ms []*typeSig
 	for _, f := range mt.AllMethods().Slice() {
+		if f.Sym == nil {
+			base.Fatalf("method with no sym on %v", mt)
+		}
 		if !f.IsMethod() {
-			base.Fatalf("non-method on %v method %v %v\n", mt, f.Sym, f)
+			base.Fatalf("non-method on %v method %v %v", mt, f.Sym, f)
 		}
 		if f.Type.Recv() == nil {
-			base.Fatalf("receiver with no type on %v method %v %v\n", mt, f.Sym, f)
+			base.Fatalf("receiver with no type on %v method %v %v", mt, f.Sym, f)
 		}
 		if f.Nointerface() {
 			continue
 		}
 
-		method := f.Sym
-		if method == nil {
-			break
-		}
-
 		// get receiver type for this particular method.
 		// if pointer receiver but non-pointer t and
 		// this is not an embedded pointer inside a struct,
@@ -351,29 +349,13 @@ func methods(t *types.Type) []*typeSig {
 		}
 
 		sig := &typeSig{
-			name:  method,
-			isym:  ir.MethodSym(it, method),
-			tsym:  ir.MethodSym(t, method),
+			name:  f.Sym,
+			isym:  methodWrapper(it, f),
+			tsym:  methodWrapper(t, f),
 			type_: typecheck.NewMethodType(f.Type, t),
 			mtype: typecheck.NewMethodType(f.Type, nil),
 		}
 		ms = append(ms, sig)
-
-		this := f.Type.Recv().Type
-
-		if !sig.isym.Siggen() {
-			sig.isym.SetSiggen(true)
-			if !types.Identical(this, it) {
-				genwrapper(it, f, sig.isym)
-			}
-		}
-
-		if !sig.tsym.Siggen() {
-			sig.tsym.SetSiggen(true)
-			if !types.Identical(this, t) {
-				genwrapper(t, f, sig.tsym)
-			}
-		}
 	}
 
 	return ms
@@ -407,11 +389,7 @@ func imethods(t *types.Type) []*typeSig {
 		// IfaceType.Method is not in the reflect data.
 		// Generate the method body, so that compiled
 		// code can refer to it.
-		isym := ir.MethodSym(t, f.Sym)
-		if !isym.Siggen() {
-			isym.SetSiggen(true)
-			genwrapper(t, f, isym)
-		}
+		methodWrapper(t, f)
 	}
 
 	return methods
@@ -636,8 +614,8 @@ func dextratypeData(lsym *obj.LSym, ot int, t *types.Type) int {
 
 		ot = objw.SymPtrOff(lsym, ot, nsym)
 		ot = dmethodptrOff(lsym, ot, WriteType(a.mtype))
-		ot = dmethodptrOff(lsym, ot, a.isym.Linksym())
-		ot = dmethodptrOff(lsym, ot, a.tsym.Linksym())
+		ot = dmethodptrOff(lsym, ot, a.isym)
+		ot = dmethodptrOff(lsym, ot, a.tsym)
 	}
 	return ot
 }
@@ -884,7 +862,7 @@ func ITabAddr(t, itype *types.Type) *ir.AddrExpr {
 		n.Class_ = ir.PEXTERN
 		n.SetTypecheck(1)
 		s.Def = n
-		itabs = append(itabs, itabEntry{t: t, itype: itype, lsym: s.Linksym()})
+		itabs = append(itabs, itabEntry{t: t, itype: itype, lsym: n.Linksym()})
 	}
 
 	n := typecheck.NodAddr(ir.AsNode(s.Def))
@@ -1281,7 +1259,7 @@ func genfun(t, it *types.Type) []*obj.LSym {
 	// so we can find the intersect in a single pass
 	for _, m := range methods {
 		if m.name == sigs[0].name {
-			out = append(out, m.isym.Linksym())
+			out = append(out, m.isym)
 			sigs = sigs[1:]
 			if len(sigs) == 0 {
 				break
@@ -1390,8 +1368,12 @@ func WriteTabs() {
 			//	name nameOff
 			//	typ  typeOff // pointer to symbol
 			// }
-			nsym := dname(p.s.Name, "", nil, true)
-			tsym := WriteType(p.t)
+			nsym := dname(p.Sym().Name, "", nil, true)
+			t := p.Type()
+			if p.Class_ != ir.PFUNC {
+				t = types.NewPtr(t)
+			}
+			tsym := WriteType(t)
 			ot = objw.SymPtrOff(s, ot, nsym)
 			ot = objw.SymPtrOff(s, ot, tsym)
 			// Plugin exports symbols as interfaces. Mark their types
@@ -1403,7 +1385,7 @@ func WriteTabs() {
 		ot = 0
 		s = base.Ctxt.Lookup("go.plugin.exports")
 		for _, p := range ptabs {
-			ot = objw.SymPtr(s, ot, p.s.Linksym(), 0)
+			ot = objw.SymPtr(s, ot, p.Linksym(), 0)
 		}
 		objw.Global(s, int32(ot), int16(obj.RODATA))
 	}
@@ -1722,13 +1704,7 @@ func CollectPTabs() {
 		if s.Pkg.Name != "main" {
 			continue
 		}
-		if n.Type().Kind() == types.TFUNC && n.Class_ == ir.PFUNC {
-			// function
-			ptabs = append(ptabs, ptabEntry{s: s, t: s.Def.Type()})
-		} else {
-			// variable
-			ptabs = append(ptabs, ptabEntry{s: s, t: types.NewPtr(s.Def.Type())})
-		}
+		ptabs = append(ptabs, n)
 	}
 }
 
@@ -1752,22 +1728,28 @@ func CollectPTabs() {
 //
 //	rcvr - U
 //	method - M func (t T)(), a TFIELD type struct
-//	newnam - the eventual mangled name of this function
-func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
-	if false && base.Flag.LowerR != 0 {
-		fmt.Printf("genwrapper rcvrtype=%v method=%v newnam=%v\n", rcvr, method, newnam)
+func methodWrapper(rcvr *types.Type, method *types.Field) *obj.LSym {
+	newnam := ir.MethodSym(rcvr, method.Sym)
+	lsym := newnam.Linksym()
+	if newnam.Siggen() {
+		return lsym
+	}
+	newnam.SetSiggen(true)
+
+	if types.Identical(rcvr, method.Type.Recv().Type) {
+		return lsym
 	}
 
 	// Only generate (*T).M wrappers for T.M in T's own package.
 	if rcvr.IsPtr() && rcvr.Elem() == method.Type.Recv().Type &&
 		rcvr.Elem().Sym() != nil && rcvr.Elem().Sym().Pkg != types.LocalPkg {
-		return
+		return lsym
 	}
 
 	// Only generate I.M wrappers for I in I's own package
 	// but keep doing it for error.Error (was issue #29304).
 	if rcvr.IsInterface() && rcvr.Sym() != nil && rcvr.Sym().Pkg != types.LocalPkg && rcvr != types.ErrorType {
-		return
+		return lsym
 	}
 
 	base.Pos = base.AutogeneratedPos
@@ -1827,10 +1809,6 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 		}
 	}
 
-	if false && base.Flag.LowerR != 0 {
-		ir.DumpList("genwrapper body", fn.Body)
-	}
-
 	typecheck.FinishFuncBody()
 	if base.Debug.DclStack != 0 {
 		types.CheckDclstack()
@@ -1850,6 +1828,8 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
 
 	ir.CurFunc = nil
 	typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
+
+	return lsym
 }
 
 var ZeroSize int64
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 15c023d332..3c94ec4c95 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -4578,7 +4578,7 @@ func (s *state) openDeferExit() {
 				call = s.newValue3A(ssa.OpClosureCall, types.TypeMem, aux, codeptr, v, s.mem())
 			}
 		} else {
-			aux := ssa.StaticAuxCall(fn.Sym().Linksym(), ACArgs, ACResults)
+			aux := ssa.StaticAuxCall(fn.(*ir.Name).Linksym(), ACArgs, ACResults)
 			if testLateExpansion {
 				callArgs = append(callArgs, s.mem())
 				call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
diff --git a/src/cmd/compile/internal/staticdata/data.go b/src/cmd/compile/internal/staticdata/data.go
index 260731244f..27d9cec06d 100644
--- a/src/cmd/compile/internal/staticdata/data.go
+++ b/src/cmd/compile/internal/staticdata/data.go
@@ -209,7 +209,7 @@ func slicedata(pos src.XPos, s string) *ir.Name {
 	symnode := typecheck.NewName(sym)
 	sym.Def = symnode
 
-	lsym := sym.Linksym()
+	lsym := symnode.Linksym()
 	off := dstringdata(lsym, 0, s, pos, "slice")
 	objw.Global(lsym, int32(off), obj.NOPTR|obj.LOCAL)
 
-- 
GitLab


From e34c44a7c46d63a96e262f837670052759cd4569 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Tue, 29 Dec 2020 12:09:51 +0700
Subject: [PATCH 0369/2400] [dev.regabi] cmd/compile: refactoring typecheck
 arith

Currently, the tcArith logic is complicated and involes many
un-necessary checks for some ir.Op. This CL refactors how it works:

 - Add a new tcShiftOp function, which only does necessary works for
   typechecking OLSH/ORSH. That ends up moving OLSH/ORSH to a separated
   case in typecheck1.

 - Move OASOP to separated case, so its logic is detached from tcArith.

 - Move OANDAND/OOROR to separated case, which does some validation
   dedicated to logical operators only.

Passes toolstash -cmp.

Change-Id: I0db7b7c7a3e52d6f9e9d87eee6967871f1c32200
Reviewed-on: https://go-review.googlesource.com/c/go/+/279442
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/typecheck/expr.go    | 186 ++++--------------
 .../compile/internal/typecheck/typecheck.go   | 114 ++++++++---
 2 files changed, 135 insertions(+), 165 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/expr.go b/src/cmd/compile/internal/typecheck/expr.go
index 29d7a08011..f3e3a93150 100644
--- a/src/cmd/compile/internal/typecheck/expr.go
+++ b/src/cmd/compile/internal/typecheck/expr.go
@@ -55,103 +55,50 @@ func tcAddr(n *ir.AddrExpr) ir.Node {
 	return n
 }
 
-// tcArith typechecks a binary arithmetic expression.
-func tcArith(n ir.Node) ir.Node {
-	var l, r ir.Node
-	var setLR func()
-	switch n := n.(type) {
-	case *ir.AssignOpStmt:
-		l, r = n.X, n.Y
-		setLR = func() { n.X = l; n.Y = r }
-	case *ir.BinaryExpr:
-		l, r = n.X, n.Y
-		setLR = func() { n.X = l; n.Y = r }
-	case *ir.LogicalExpr:
-		l, r = n.X, n.Y
-		setLR = func() { n.X = l; n.Y = r }
-	}
-	l = Expr(l)
-	r = Expr(r)
-	setLR()
-	if l.Type() == nil || r.Type() == nil {
-		n.SetType(nil)
-		return n
+func tcShift(n, l, r ir.Node) (ir.Node, ir.Node, *types.Type) {
+	if l.Type() == nil || l.Type() == nil {
+		return l, r, nil
 	}
-	op := n.Op()
-	if n.Op() == ir.OASOP {
-		n := n.(*ir.AssignOpStmt)
-		checkassign(n, l)
-		if n.IncDec && !okforarith[l.Type().Kind()] {
-			base.Errorf("invalid operation: %v (non-numeric type %v)", n, l.Type())
-			n.SetType(nil)
-			return n
-		}
-		// TODO(marvin): Fix Node.EType type union.
-		op = n.AsOp
-	}
-	if op == ir.OLSH || op == ir.ORSH {
-		r = DefaultLit(r, types.Types[types.TUINT])
-		setLR()
-		t := r.Type()
-		if !t.IsInteger() {
-			base.Errorf("invalid operation: %v (shift count type %v, must be integer)", n, r.Type())
-			n.SetType(nil)
-			return n
-		}
-		if t.IsSigned() && !types.AllowsGoVersion(curpkg(), 1, 13) {
-			base.ErrorfVers("go1.13", "invalid operation: %v (signed shift count type %v)", n, r.Type())
-			n.SetType(nil)
-			return n
-		}
-		t = l.Type()
-		if t != nil && t.Kind() != types.TIDEAL && !t.IsInteger() {
-			base.Errorf("invalid operation: %v (shift of type %v)", n, t)
-			n.SetType(nil)
-			return n
-		}
 
-		// no defaultlit for left
-		// the outer context gives the type
-		n.SetType(l.Type())
-		if (l.Type() == types.UntypedFloat || l.Type() == types.UntypedComplex) && r.Op() == ir.OLITERAL {
-			n.SetType(types.UntypedInt)
-		}
-		return n
+	r = DefaultLit(r, types.Types[types.TUINT])
+	t := r.Type()
+	if !t.IsInteger() {
+		base.Errorf("invalid operation: %v (shift count type %v, must be integer)", n, r.Type())
+		return l, r, nil
+	}
+	if t.IsSigned() && !types.AllowsGoVersion(curpkg(), 1, 13) {
+		base.ErrorfVers("go1.13", "invalid operation: %v (signed shift count type %v)", n, r.Type())
+		return l, r, nil
+	}
+	t = l.Type()
+	if t != nil && t.Kind() != types.TIDEAL && !t.IsInteger() {
+		base.Errorf("invalid operation: %v (shift of type %v)", n, t)
+		return l, r, nil
 	}
 
-	// For "x == x && len(s)", it's better to report that "len(s)" (type int)
-	// can't be used with "&&" than to report that "x == x" (type untyped bool)
-	// can't be converted to int (see issue #41500).
-	if n.Op() == ir.OANDAND || n.Op() == ir.OOROR {
-		n := n.(*ir.LogicalExpr)
-		if !n.X.Type().IsBoolean() {
-			base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op(), typekind(n.X.Type()))
-			n.SetType(nil)
-			return n
-		}
-		if !n.Y.Type().IsBoolean() {
-			base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op(), typekind(n.Y.Type()))
-			n.SetType(nil)
-			return n
-		}
+	// no defaultlit for left
+	// the outer context gives the type
+	t = l.Type()
+	if (l.Type() == types.UntypedFloat || l.Type() == types.UntypedComplex) && r.Op() == ir.OLITERAL {
+		t = types.UntypedInt
 	}
+	return l, r, t
+}
 
-	// ideal mixed with non-ideal
+// tcArith typechecks operands of a binary arithmetic expression.
+// The result of tcArith MUST be assigned back to original operands,
+// t is the type of the expression, and should be set by the caller. e.g:
+//     n.X, n.Y, t = tcArith(n, op, n.X, n.Y)
+//     n.SetType(t)
+func tcArith(n ir.Node, op ir.Op, l, r ir.Node) (ir.Node, ir.Node, *types.Type) {
 	l, r = defaultlit2(l, r, false)
-	setLR()
-
 	if l.Type() == nil || r.Type() == nil {
-		n.SetType(nil)
-		return n
+		return l, r, nil
 	}
 	t := l.Type()
 	if t.Kind() == types.TIDEAL {
 		t = r.Type()
 	}
-	et := t.Kind()
-	if et == types.TIDEAL {
-		et = types.TINT
-	}
 	aop := ir.OXXX
 	if iscmp[n.Op()] && t.Kind() != types.TIDEAL && !types.Identical(l.Type(), r.Type()) {
 		// comparison is okay as long as one side is
@@ -167,15 +114,13 @@ func tcArith(n ir.Node) ir.Node {
 			if aop != ir.OXXX {
 				if r.Type().IsInterface() && !l.Type().IsInterface() && !types.IsComparable(l.Type()) {
 					base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(l.Type()))
-					n.SetType(nil)
-					return n
+					return l, r, nil
 				}
 
 				types.CalcSize(l.Type())
 				if r.Type().IsInterface() == l.Type().IsInterface() || l.Type().Width >= 1<<16 {
 					l = ir.NewConvExpr(base.Pos, aop, r.Type(), l)
 					l.SetTypecheck(1)
-					setLR()
 				}
 
 				t = r.Type()
@@ -188,34 +133,28 @@ func tcArith(n ir.Node) ir.Node {
 			if aop != ir.OXXX {
 				if l.Type().IsInterface() && !r.Type().IsInterface() && !types.IsComparable(r.Type()) {
 					base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(r.Type()))
-					n.SetType(nil)
-					return n
+					return l, r, nil
 				}
 
 				types.CalcSize(r.Type())
 				if r.Type().IsInterface() == l.Type().IsInterface() || r.Type().Width >= 1<<16 {
 					r = ir.NewConvExpr(base.Pos, aop, l.Type(), r)
 					r.SetTypecheck(1)
-					setLR()
 				}
 
 				t = l.Type()
 			}
 		}
-
-		et = t.Kind()
 	}
 
 	if t.Kind() != types.TIDEAL && !types.Identical(l.Type(), r.Type()) {
 		l, r = defaultlit2(l, r, true)
 		if l.Type() == nil || r.Type() == nil {
-			n.SetType(nil)
-			return n
+			return l, r, nil
 		}
 		if l.Type().IsInterface() == r.Type().IsInterface() || aop == 0 {
 			base.Errorf("invalid operation: %v (mismatched types %v and %v)", n, l.Type(), r.Type())
-			n.SetType(nil)
-			return n
+			return l, r, nil
 		}
 	}
 
@@ -224,85 +163,46 @@ func tcArith(n ir.Node) ir.Node {
 	}
 	if dt := defaultType(t); !okfor[op][dt.Kind()] {
 		base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(t))
-		n.SetType(nil)
-		return n
+		return l, r, nil
 	}
 
 	// okfor allows any array == array, map == map, func == func.
 	// restrict to slice/map/func == nil and nil == slice/map/func.
 	if l.Type().IsArray() && !types.IsComparable(l.Type()) {
 		base.Errorf("invalid operation: %v (%v cannot be compared)", n, l.Type())
-		n.SetType(nil)
-		return n
+		return l, r, nil
 	}
 
 	if l.Type().IsSlice() && !ir.IsNil(l) && !ir.IsNil(r) {
 		base.Errorf("invalid operation: %v (slice can only be compared to nil)", n)
-		n.SetType(nil)
-		return n
+		return l, r, nil
 	}
 
 	if l.Type().IsMap() && !ir.IsNil(l) && !ir.IsNil(r) {
 		base.Errorf("invalid operation: %v (map can only be compared to nil)", n)
-		n.SetType(nil)
-		return n
+		return l, r, nil
 	}
 
 	if l.Type().Kind() == types.TFUNC && !ir.IsNil(l) && !ir.IsNil(r) {
 		base.Errorf("invalid operation: %v (func can only be compared to nil)", n)
-		n.SetType(nil)
-		return n
+		return l, r, nil
 	}
 
 	if l.Type().IsStruct() {
 		if f := types.IncomparableField(l.Type()); f != nil {
 			base.Errorf("invalid operation: %v (struct containing %v cannot be compared)", n, f.Type)
-			n.SetType(nil)
-			return n
+			return l, r, nil
 		}
 	}
 
-	if iscmp[n.Op()] {
-		t = types.UntypedBool
-		n.SetType(t)
-		if con := EvalConst(n); con.Op() == ir.OLITERAL {
-			return con
-		}
-		l, r = defaultlit2(l, r, true)
-		setLR()
-		return n
-	}
-
-	if et == types.TSTRING && n.Op() == ir.OADD {
-		// create or update OADDSTR node with list of strings in x + y + z + (w + v) + ...
-		n := n.(*ir.BinaryExpr)
-		var add *ir.AddStringExpr
-		if l.Op() == ir.OADDSTR {
-			add = l.(*ir.AddStringExpr)
-			add.SetPos(n.Pos())
-		} else {
-			add = ir.NewAddStringExpr(n.Pos(), []ir.Node{l})
-		}
-		if r.Op() == ir.OADDSTR {
-			r := r.(*ir.AddStringExpr)
-			add.List.Append(r.List.Take()...)
-		} else {
-			add.List.Append(r)
-		}
-		add.SetType(t)
-		return add
-	}
-
 	if (op == ir.ODIV || op == ir.OMOD) && ir.IsConst(r, constant.Int) {
 		if constant.Sign(r.Val()) == 0 {
 			base.Errorf("division by zero")
-			n.SetType(nil)
-			return n
+			return l, r, nil
 		}
 	}
 
-	n.SetType(t)
-	return n
+	return l, r, t
 }
 
 // The result of tcCompLit MUST be assigned back to n, e.g.
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index ff9178b597..e29d58cefa 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -672,28 +672,98 @@ func typecheck1(n ir.Node, top int) ir.Node {
 	case ir.ODEREF:
 		n := n.(*ir.StarExpr)
 		return tcStar(n, top)
-	// arithmetic exprs
-	case ir.OASOP,
-		ir.OADD,
-		ir.OAND,
-		ir.OANDAND,
-		ir.OANDNOT,
-		ir.ODIV,
-		ir.OEQ,
-		ir.OGE,
-		ir.OGT,
-		ir.OLE,
-		ir.OLT,
-		ir.OLSH,
-		ir.ORSH,
-		ir.OMOD,
-		ir.OMUL,
-		ir.ONE,
-		ir.OOR,
-		ir.OOROR,
-		ir.OSUB,
-		ir.OXOR:
-		return tcArith(n)
+
+	// x op= y
+	case ir.OASOP:
+		n := n.(*ir.AssignOpStmt)
+		n.X, n.Y = Expr(n.X), Expr(n.Y)
+		checkassign(n, n.X)
+		if n.IncDec && !okforarith[n.X.Type().Kind()] {
+			base.Errorf("invalid operation: %v (non-numeric type %v)", n, n.X.Type())
+			return n
+		}
+		switch n.AsOp {
+		case ir.OLSH, ir.ORSH:
+			n.X, n.Y, _ = tcShift(n, n.X, n.Y)
+		case ir.OADD, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OMOD, ir.OMUL, ir.OOR, ir.OSUB, ir.OXOR:
+			n.X, n.Y, _ = tcArith(n, n.AsOp, n.X, n.Y)
+		default:
+			base.Fatalf("invalid assign op: %v", n.AsOp)
+		}
+		return n
+
+	// logical operators
+	case ir.OANDAND, ir.OOROR:
+		n := n.(*ir.LogicalExpr)
+		n.X, n.Y = Expr(n.X), Expr(n.Y)
+		// For "x == x && len(s)", it's better to report that "len(s)" (type int)
+		// can't be used with "&&" than to report that "x == x" (type untyped bool)
+		// can't be converted to int (see issue #41500).
+		if !n.X.Type().IsBoolean() {
+			base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op(), typekind(n.X.Type()))
+			n.SetType(nil)
+			return n
+		}
+		if !n.Y.Type().IsBoolean() {
+			base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op(), typekind(n.Y.Type()))
+			n.SetType(nil)
+			return n
+		}
+		l, r, t := tcArith(n, n.Op(), n.X, n.Y)
+		n.X, n.Y = l, r
+		n.SetType(t)
+		return n
+
+	// shift operators
+	case ir.OLSH, ir.ORSH:
+		n := n.(*ir.BinaryExpr)
+		n.X, n.Y = Expr(n.X), Expr(n.Y)
+		l, r, t := tcShift(n, n.X, n.Y)
+		n.X, n.Y = l, r
+		n.SetType(t)
+		return n
+
+	// comparison operators
+	case ir.OEQ, ir.OGE, ir.OGT, ir.OLE, ir.OLT, ir.ONE:
+		n := n.(*ir.BinaryExpr)
+		n.X, n.Y = Expr(n.X), Expr(n.Y)
+		l, r, t := tcArith(n, n.Op(), n.X, n.Y)
+		if t != nil {
+			n.X, n.Y = l, r
+			n.SetType(types.UntypedBool)
+			if con := EvalConst(n); con.Op() == ir.OLITERAL {
+				return con
+			}
+			n.X, n.Y = defaultlit2(l, r, true)
+		}
+		return n
+
+	// binary operators
+	case ir.OADD, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OMOD, ir.OMUL, ir.OOR, ir.OSUB, ir.OXOR:
+		n := n.(*ir.BinaryExpr)
+		n.X, n.Y = Expr(n.X), Expr(n.Y)
+		l, r, t := tcArith(n, n.Op(), n.X, n.Y)
+		if t != nil && t.Kind() == types.TSTRING && n.Op() == ir.OADD {
+			// create or update OADDSTR node with list of strings in x + y + z + (w + v) + ...
+			var add *ir.AddStringExpr
+			if l.Op() == ir.OADDSTR {
+				add = l.(*ir.AddStringExpr)
+				add.SetPos(n.Pos())
+			} else {
+				add = ir.NewAddStringExpr(n.Pos(), []ir.Node{l})
+			}
+			if r.Op() == ir.OADDSTR {
+				r := r.(*ir.AddStringExpr)
+				add.List.Append(r.List.Take()...)
+			} else {
+				add.List.Append(r)
+			}
+			add.SetType(t)
+			return add
+		}
+		n.X, n.Y = l, r
+		n.SetType(t)
+		return n
 
 	case ir.OBITNOT, ir.ONEG, ir.ONOT, ir.OPLUS:
 		n := n.(*ir.UnaryExpr)
-- 
GitLab


From 82ad3083f86947eece2e4ce2ae82f1230aa466d9 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Tue, 29 Dec 2020 12:31:17 +0700
Subject: [PATCH 0370/2400] [dev.regabi] cmd/compile: remove typ from
 AssignOpStmt

Previous detached logic of typechecking AssignOpStmt from tcArith, the
typ field of it is not used anymore.

Pass toolstash -cmp.

Change-Id: I407507a1c4c4f2958fca4d6899875564e54bf1f5
Reviewed-on: https://go-review.googlesource.com/c/go/+/279443
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/stmt.go | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index de152fec72..1301e65e26 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -112,7 +112,6 @@ func (n *AssignStmt) SetOp(op Op) {
 // An AssignOpStmt is an AsOp= assignment statement: X AsOp= Y.
 type AssignOpStmt struct {
 	miniStmt
-	typ    *types.Type
 	X      Node
 	AsOp   Op // OADD etc
 	Y      Node
@@ -126,9 +125,6 @@ func NewAssignOpStmt(pos src.XPos, asOp Op, x, y Node) *AssignOpStmt {
 	return n
 }
 
-func (n *AssignOpStmt) Type() *types.Type     { return n.typ }
-func (n *AssignOpStmt) SetType(x *types.Type) { n.typ = x }
-
 // A BlockStmt is a block: { List }.
 type BlockStmt struct {
 	miniStmt
-- 
GitLab


From 33801cdc627bc4d3f7128d1076a1ac249da2e015 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 28 Dec 2020 23:42:49 -0800
Subject: [PATCH 0371/2400] [dev.regabi] cmd/compile: use Ntype where possible

For nodes that are always a type expression, we can use Ntype instead
of Node.

Passes toolstash -cmp.

Change-Id: I28f9fa235015ab48d0da06b78b30c49d74c64e3a
Reviewed-on: https://go-review.googlesource.com/c/go/+/280642
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ir/func.go        |  2 +-
 src/cmd/compile/internal/ir/node_gen.go    | 10 +++++-----
 src/cmd/compile/internal/ir/type.go        | 22 +++++++++++-----------
 src/cmd/compile/internal/typecheck/expr.go |  4 ++--
 src/cmd/compile/internal/typecheck/func.go |  2 +-
 src/cmd/compile/internal/typecheck/type.go | 12 ++++++------
 6 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index a4f5875aab..4613425f1a 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -67,7 +67,7 @@ type Func struct {
 	Dcl []*Name
 
 	ClosureEnter Nodes   // list of ONAME nodes (or OADDR-of-ONAME nodes, for output parameters) of captured variables
-	ClosureType  Node    // closure representation type
+	ClosureType  Ntype   // closure representation type
 	ClosureVars  []*Name // closure params; each has closurevar set
 
 	// Parents records the parent scope of each scope within a
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index 1d24904a3f..fe54b62f18 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -52,7 +52,7 @@ func (n *ArrayType) doChildren(do func(Node) error) error {
 }
 func (n *ArrayType) editChildren(edit func(Node) Node) {
 	n.Len = maybeEdit(n.Len, edit)
-	n.Elem = maybeEdit(n.Elem, edit)
+	n.Elem = toNtype(maybeEdit(n.Elem, edit))
 }
 
 func (n *AssignListStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
@@ -241,7 +241,7 @@ func (n *ChanType) doChildren(do func(Node) error) error {
 	return err
 }
 func (n *ChanType) editChildren(edit func(Node) Node) {
-	n.Elem = maybeEdit(n.Elem, edit)
+	n.Elem = toNtype(maybeEdit(n.Elem, edit))
 }
 
 func (n *ClosureExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
@@ -632,8 +632,8 @@ func (n *MapType) doChildren(do func(Node) error) error {
 	return err
 }
 func (n *MapType) editChildren(edit func(Node) Node) {
-	n.Key = maybeEdit(n.Key, edit)
-	n.Elem = maybeEdit(n.Elem, edit)
+	n.Key = toNtype(maybeEdit(n.Key, edit))
+	n.Elem = toNtype(maybeEdit(n.Elem, edit))
 }
 
 func (n *Name) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
@@ -873,7 +873,7 @@ func (n *SliceType) doChildren(do func(Node) error) error {
 	return err
 }
 func (n *SliceType) editChildren(edit func(Node) Node) {
-	n.Elem = maybeEdit(n.Elem, edit)
+	n.Elem = toNtype(maybeEdit(n.Elem, edit))
 }
 
 func (n *StarExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
diff --git a/src/cmd/compile/internal/ir/type.go b/src/cmd/compile/internal/ir/type.go
index bd3a05d06e..408f6ed563 100644
--- a/src/cmd/compile/internal/ir/type.go
+++ b/src/cmd/compile/internal/ir/type.go
@@ -46,7 +46,7 @@ func (n *miniType) Type() *types.Type { return n.typ }
 // setOTYPE also records t.Nod = self if t.Nod is not already set.
 // (Some types are shared by multiple OTYPE nodes, so only
 // the first such node is used as t.Nod.)
-func (n *miniType) setOTYPE(t *types.Type, self Node) {
+func (n *miniType) setOTYPE(t *types.Type, self Ntype) {
 	if n.typ != nil {
 		panic(n.op.String() + " SetType: type already set")
 	}
@@ -61,11 +61,11 @@ func (n *miniType) Implicit() bool  { return false } // for Format OTYPE
 // A ChanType represents a chan Elem syntax with the direction Dir.
 type ChanType struct {
 	miniType
-	Elem Node
+	Elem Ntype
 	Dir  types.ChanDir
 }
 
-func NewChanType(pos src.XPos, elem Node, dir types.ChanDir) *ChanType {
+func NewChanType(pos src.XPos, elem Ntype, dir types.ChanDir) *ChanType {
 	n := &ChanType{Elem: elem, Dir: dir}
 	n.op = OTCHAN
 	n.pos = pos
@@ -80,11 +80,11 @@ func (n *ChanType) SetOTYPE(t *types.Type) {
 // A MapType represents a map[Key]Value type syntax.
 type MapType struct {
 	miniType
-	Key  Node
-	Elem Node
+	Key  Ntype
+	Elem Ntype
 }
 
-func NewMapType(pos src.XPos, key, elem Node) *MapType {
+func NewMapType(pos src.XPos, key, elem Ntype) *MapType {
 	n := &MapType{Key: key, Elem: elem}
 	n.op = OTMAP
 	n.pos = pos
@@ -246,11 +246,11 @@ func editFields(list []*Field, edit func(Node) Node) {
 // If DDD is true, it's the ...Elem at the end of a function list.
 type SliceType struct {
 	miniType
-	Elem Node
+	Elem Ntype
 	DDD  bool
 }
 
-func NewSliceType(pos src.XPos, elem Node) *SliceType {
+func NewSliceType(pos src.XPos, elem Ntype) *SliceType {
 	n := &SliceType{Elem: elem}
 	n.op = OTSLICE
 	n.pos = pos
@@ -267,11 +267,11 @@ func (n *SliceType) SetOTYPE(t *types.Type) {
 type ArrayType struct {
 	miniType
 	Len  Node
-	Elem Node
+	Elem Ntype
 }
 
-func NewArrayType(pos src.XPos, size Node, elem Node) *ArrayType {
-	n := &ArrayType{Len: size, Elem: elem}
+func NewArrayType(pos src.XPos, len Node, elem Ntype) *ArrayType {
+	n := &ArrayType{Len: len, Elem: elem}
 	n.op = OTARRAY
 	n.pos = pos
 	return n
diff --git a/src/cmd/compile/internal/typecheck/expr.go b/src/cmd/compile/internal/typecheck/expr.go
index f3e3a93150..5752139c0b 100644
--- a/src/cmd/compile/internal/typecheck/expr.go
+++ b/src/cmd/compile/internal/typecheck/expr.go
@@ -230,7 +230,7 @@ func tcCompLit(n *ir.CompLitExpr) (res ir.Node) {
 
 	// Need to handle [...]T arrays specially.
 	if array, ok := n.Ntype.(*ir.ArrayType); ok && array.Elem != nil && array.Len == nil {
-		array.Elem = typecheck(array.Elem, ctxType)
+		array.Elem = typecheckNtype(array.Elem)
 		elemType := array.Elem.Type()
 		if elemType == nil {
 			n.SetType(nil)
@@ -243,7 +243,7 @@ func tcCompLit(n *ir.CompLitExpr) (res ir.Node) {
 		return n
 	}
 
-	n.Ntype = ir.Node(typecheck(n.Ntype, ctxType)).(ir.Ntype)
+	n.Ntype = typecheckNtype(n.Ntype)
 	t := n.Ntype.Type()
 	if t == nil {
 		n.SetType(nil)
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index c58fef10ec..9bb9245d4a 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -342,7 +342,7 @@ func tcClosure(clo *ir.ClosureExpr, top int) {
 		fn.Iota = x
 	}
 
-	fn.ClosureType = typecheck(fn.ClosureType, ctxType)
+	fn.ClosureType = typecheckNtype(fn.ClosureType)
 	clo.SetType(fn.ClosureType.Type())
 	fn.SetClosureCalled(top&ctxCallee != 0)
 
diff --git a/src/cmd/compile/internal/typecheck/type.go b/src/cmd/compile/internal/typecheck/type.go
index 0c2ebb8b26..6fdafef77d 100644
--- a/src/cmd/compile/internal/typecheck/type.go
+++ b/src/cmd/compile/internal/typecheck/type.go
@@ -14,7 +14,7 @@ import (
 
 // tcArrayType typechecks an OTARRAY node.
 func tcArrayType(n *ir.ArrayType) ir.Node {
-	n.Elem = typecheck(n.Elem, ctxType)
+	n.Elem = typecheckNtype(n.Elem)
 	if n.Elem.Type() == nil {
 		return n
 	}
@@ -59,7 +59,7 @@ func tcArrayType(n *ir.ArrayType) ir.Node {
 
 // tcChanType typechecks an OTCHAN node.
 func tcChanType(n *ir.ChanType) ir.Node {
-	n.Elem = typecheck(n.Elem, ctxType)
+	n.Elem = typecheckNtype(n.Elem)
 	l := n.Elem
 	if l.Type() == nil {
 		return n
@@ -103,7 +103,7 @@ func tcInterfaceType(n *ir.InterfaceType) ir.Node {
 		n.SetOTYPE(types.Types[types.TINTER])
 		return n
 	}
-	
+
 	lno := base.Pos
 	methods := tcFields(n.Methods, nil)
 	base.Pos = lno
@@ -114,8 +114,8 @@ func tcInterfaceType(n *ir.InterfaceType) ir.Node {
 
 // tcMapType typechecks an OTMAP node.
 func tcMapType(n *ir.MapType) ir.Node {
-	n.Key = typecheck(n.Key, ctxType)
-	n.Elem = typecheck(n.Elem, ctxType)
+	n.Key = typecheckNtype(n.Key)
+	n.Elem = typecheckNtype(n.Elem)
 	l := n.Key
 	r := n.Elem
 	if l.Type() == nil || r.Type() == nil {
@@ -134,7 +134,7 @@ func tcMapType(n *ir.MapType) ir.Node {
 
 // tcSliceType typechecks an OTSLICE node.
 func tcSliceType(n *ir.SliceType) ir.Node {
-	n.Elem = typecheck(n.Elem, ctxType)
+	n.Elem = typecheckNtype(n.Elem)
 	if n.Elem.Type() == nil {
 		return n
 	}
-- 
GitLab


From 171fc6f22388cc8628b5590f42d46a7c57277428 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 29 Dec 2020 00:44:28 -0800
Subject: [PATCH 0372/2400] [dev.regabi] cmd/compile: remove workarounds for
 go/constant issues

These were fixed in CLs 273086 and 273126, which have been merged back
into dev.regabi already.

Passes toolstash -cmp.

Change-Id: I011e9ed7062bc034496a279e21cc163267bf83fd
Reviewed-on: https://go-review.googlesource.com/c/go/+/280643
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/typecheck/const.go   | 11 +----------
 src/cmd/compile/internal/typecheck/iexport.go |  2 +-
 src/cmd/compile/internal/typecheck/iimport.go |  2 +-
 3 files changed, 3 insertions(+), 12 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/const.go b/src/cmd/compile/internal/typecheck/const.go
index e22b284e82..5259218ef9 100644
--- a/src/cmd/compile/internal/typecheck/const.go
+++ b/src/cmd/compile/internal/typecheck/const.go
@@ -564,20 +564,11 @@ func EvalConst(n ir.Node) ir.Node {
 	return n
 }
 
-func makeInt(i *big.Int) constant.Value {
-	if i.IsInt64() {
-		return constant.Make(i.Int64()) // workaround #42640 (Int64Val(Make(big.NewInt(10))) returns (10, false), not (10, true))
-	}
-	return constant.Make(i)
-}
-
 func makeFloat64(f float64) constant.Value {
 	if math.IsInf(f, 0) {
 		base.Fatalf("infinity is not a valid constant")
 	}
-	v := constant.MakeFloat64(f)
-	v = constant.ToFloat(v) // workaround #42641 (MakeFloat64(0).Kind() returns Int, not Float)
-	return v
+	return constant.MakeFloat64(f)
 }
 
 func makeComplex(real, imag constant.Value) constant.Value {
diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index e35cbcafa2..c287d76c43 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -936,7 +936,7 @@ func (w *exportWriter) mpfloat(v constant.Value, typ *types.Type) {
 	if acc != big.Exact {
 		base.Fatalf("mantissa scaling failed for %f (%s)", f, acc)
 	}
-	w.mpint(makeInt(manti), typ)
+	w.mpint(constant.Make(manti), typ)
 	if manti.Sign() != 0 {
 		w.int64(exp)
 	}
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 546ddcba79..86277e69bd 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -372,7 +372,7 @@ func (p *importReader) value(typ *types.Type) constant.Value {
 	case constant.Int:
 		var i big.Int
 		p.mpint(&i, typ)
-		return makeInt(&i)
+		return constant.Make(&i)
 	case constant.Float:
 		return p.float(typ)
 	case constant.Complex:
-- 
GitLab


From 6f30c9504861d68d13113989a3cf063832d47002 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 29 Dec 2020 01:22:50 -0800
Subject: [PATCH 0373/2400] [dev.regabi] cmd/compile: remove unneeded
 indirection

Thanks to package reorganizing, we can remove types.TypeLinkSym by
simply having its only callers use reflectdata.TypeLinksym directly.

Passes toolstash -cmp.

Change-Id: I5bc5dbb6bf0664af43ae5130cfe1f19bd23b2bfe
Reviewed-on: https://go-review.googlesource.com/c/go/+/280644
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/gc/abiutils_test.go |  7 -------
 src/cmd/compile/internal/gc/main.go          |  6 ------
 src/cmd/compile/internal/ssa/writebarrier.go |  5 +++--
 src/cmd/compile/internal/types/type.go       |  5 -----
 src/cmd/compile/internal/types/utils.go      | 11 -----------
 5 files changed, 3 insertions(+), 31 deletions(-)

diff --git a/src/cmd/compile/internal/gc/abiutils_test.go b/src/cmd/compile/internal/gc/abiutils_test.go
index 656eab18cb..d535a6a34b 100644
--- a/src/cmd/compile/internal/gc/abiutils_test.go
+++ b/src/cmd/compile/internal/gc/abiutils_test.go
@@ -7,7 +7,6 @@ package gc
 import (
 	"bufio"
 	"cmd/compile/internal/base"
-	"cmd/compile/internal/reflectdata"
 	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
@@ -39,12 +38,6 @@ func TestMain(m *testing.M) {
 	base.Ctxt.Bso = bufio.NewWriter(os.Stdout)
 	types.PtrSize = ssagen.Arch.LinkArch.PtrSize
 	types.RegSize = ssagen.Arch.LinkArch.RegSize
-	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
-		return reflectdata.TypeLinksym(t)
-	}
-	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
-		return reflectdata.TypeLinksym(t)
-	}
 	typecheck.Init()
 	os.Exit(m.Run())
 }
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index a4613f04fb..45219801f0 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -190,9 +190,6 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	types.PtrSize = ssagen.Arch.LinkArch.PtrSize
 	types.RegSize = ssagen.Arch.LinkArch.RegSize
 	types.MaxWidth = ssagen.Arch.MAXWIDTH
-	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
-		return reflectdata.TypeLinksym(t)
-	}
 
 	typecheck.Target = new(ir.Package)
 
@@ -202,9 +199,6 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 
 	base.AutogeneratedPos = makePos(src.NewFileBase("<autogenerated>", "<autogenerated>"), 1, 0)
 
-	types.TypeLinkSym = func(t *types.Type) *obj.LSym {
-		return reflectdata.TypeLinksym(t)
-	}
 	typecheck.Init()
 
 	// Parse input.
diff --git a/src/cmd/compile/internal/ssa/writebarrier.go b/src/cmd/compile/internal/ssa/writebarrier.go
index 849c9e8967..4378f2d627 100644
--- a/src/cmd/compile/internal/ssa/writebarrier.go
+++ b/src/cmd/compile/internal/ssa/writebarrier.go
@@ -5,6 +5,7 @@
 package ssa
 
 import (
+	"cmd/compile/internal/reflectdata"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
@@ -270,11 +271,11 @@ func writebarrier(f *Func) {
 			case OpMoveWB:
 				fn = typedmemmove
 				val = w.Args[1]
-				typ = w.Aux.(*types.Type).Symbol()
+				typ = reflectdata.TypeLinksym(w.Aux.(*types.Type))
 				nWBops--
 			case OpZeroWB:
 				fn = typedmemclr
-				typ = w.Aux.(*types.Type).Symbol()
+				typ = reflectdata.TypeLinksym(w.Aux.(*types.Type))
 				nWBops--
 			case OpVarDef, OpVarLive, OpVarKill:
 			}
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 6feedbfabc..5176b96c02 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -6,7 +6,6 @@ package types
 
 import (
 	"cmd/compile/internal/base"
-	"cmd/internal/obj"
 	"cmd/internal/src"
 	"fmt"
 	"sync"
@@ -1532,10 +1531,6 @@ func (t *Type) HasPointers() bool {
 	return true
 }
 
-func (t *Type) Symbol() *obj.LSym {
-	return TypeLinkSym(t)
-}
-
 // Tie returns 'T' if t is a concrete type,
 // 'I' if t is an interface type, and 'E' if t is an empty interface type.
 // It is used to build calls to the conv* and assert* runtime routines.
diff --git a/src/cmd/compile/internal/types/utils.go b/src/cmd/compile/internal/types/utils.go
index 2477f1da66..f9f629ca3e 100644
--- a/src/cmd/compile/internal/types/utils.go
+++ b/src/cmd/compile/internal/types/utils.go
@@ -4,19 +4,8 @@
 
 package types
 
-import (
-	"cmd/internal/obj"
-)
-
 const BADWIDTH = -1000000000
 
-// The following variables must be initialized early by the frontend.
-// They are here to break import cycles.
-// TODO(gri) eliminate these dependencies.
-var (
-	TypeLinkSym func(*Type) *obj.LSym
-)
-
 type bitset8 uint8
 
 func (f *bitset8) set(mask uint8, b bool) {
-- 
GitLab


From e40cb4d4ae357d80d5e2b66e765c937317fad07f Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 29 Dec 2020 02:55:05 -0800
Subject: [PATCH 0374/2400] [dev.regabi] cmd/compile: remove more unused code

Change-Id: I60ac28e3ab376cb0dac23a9b4f481f8562ad8c56
Reviewed-on: https://go-review.googlesource.com/c/go/+/280647
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/typecheck/dcl.go | 57 -----------------------
 1 file changed, 57 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/dcl.go b/src/cmd/compile/internal/typecheck/dcl.go
index 36057ba2d1..83f926e135 100644
--- a/src/cmd/compile/internal/typecheck/dcl.go
+++ b/src/cmd/compile/internal/typecheck/dcl.go
@@ -17,63 +17,6 @@ import (
 
 var DeclContext ir.Class // PEXTERN/PAUTO
 
-func AssignDefn(left []ir.Node, defn ir.Node) {
-	for _, n := range left {
-		if n.Sym() != nil {
-			n.Sym().SetUniq(true)
-		}
-	}
-
-	var nnew, nerr int
-	for i, n := range left {
-		if ir.IsBlank(n) {
-			continue
-		}
-		if !assignableName(n) {
-			base.ErrorfAt(defn.Pos(), "non-name %v on left side of :=", n)
-			nerr++
-			continue
-		}
-
-		if !n.Sym().Uniq() {
-			base.ErrorfAt(defn.Pos(), "%v repeated on left side of :=", n.Sym())
-			n.SetDiag(true)
-			nerr++
-			continue
-		}
-
-		n.Sym().SetUniq(false)
-		if n.Sym().Block == types.Block {
-			continue
-		}
-
-		nnew++
-		n := NewName(n.Sym())
-		Declare(n, DeclContext)
-		n.Defn = defn
-		defn.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, n))
-		left[i] = n
-	}
-
-	if nnew == 0 && nerr == 0 {
-		base.ErrorfAt(defn.Pos(), "no new variables on left side of :=")
-	}
-}
-
-// := declarations
-func assignableName(n ir.Node) bool {
-	switch n.Op() {
-	case ir.ONAME,
-		ir.ONONAME,
-		ir.OPACK,
-		ir.OTYPE,
-		ir.OLITERAL:
-		return n.Sym() != nil
-	}
-
-	return false
-}
-
 func DeclFunc(sym *types.Sym, tfn ir.Ntype) *ir.Func {
 	if tfn.Op() != ir.OTFUNC {
 		base.Fatalf("expected OTFUNC node, got %v", tfn)
-- 
GitLab


From 9ea272e5ec5dd5eadd59d54c08377d5d9527a51b Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 29 Dec 2020 03:08:23 -0800
Subject: [PATCH 0375/2400] [dev.regabi] cmd/compile: simplify ir.Func somewhat

Two simplifications:

1. Statements (including ODCLFUNC) don't have types, and the
Func.Nname already has a type. There's no need for a second one.
However, there is a lot of code that expects to be able to call
Func.Type, so leave a forwarding method, like with Sym and Linksym.

2. Inline and remove ir.NewFuncNameAt. It doesn't really save any
code, and it's only used a handful of places.

Passes toolstash -cmp.

Change-Id: I51acaa341897dae0fcdf2fa576a10174a2ae4d1e
Reviewed-on: https://go-review.googlesource.com/c/go/+/280648
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/ir/func.go           | 16 +---------------
 src/cmd/compile/internal/ir/sizeof_test.go    |  2 +-
 src/cmd/compile/internal/noder/noder.go       |  7 +++++--
 src/cmd/compile/internal/typecheck/dcl.go     |  3 ++-
 src/cmd/compile/internal/typecheck/export.go  |  8 ++------
 src/cmd/compile/internal/typecheck/func.go    |  1 -
 src/cmd/compile/internal/typecheck/iimport.go | 11 ++++++-----
 src/cmd/compile/internal/walk/closure.go      |  2 +-
 8 files changed, 18 insertions(+), 32 deletions(-)

diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 4613425f1a..bffd4dd5ef 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -49,7 +49,6 @@ import (
 // pointer from the Func back to the OCALLPART.
 type Func struct {
 	miniNode
-	typ  *types.Type
 	Body Nodes
 	Iota int64
 
@@ -116,9 +115,7 @@ func NewFunc(pos src.XPos) *Func {
 
 func (f *Func) isStmt() {}
 
-func (f *Func) Type() *types.Type     { return f.typ }
-func (f *Func) SetType(x *types.Type) { f.typ = x }
-
+func (f *Func) Type() *types.Type  { return f.Nname.Type() }
 func (f *Func) Sym() *types.Sym    { return f.Nname.Sym() }
 func (f *Func) Linksym() *obj.LSym { return f.Nname.Linksym() }
 
@@ -236,17 +233,6 @@ func FuncSymName(s *types.Sym) string {
 	return s.Name + "·f"
 }
 
-// NewFuncNameAt generates a new name node for a function or method.
-func NewFuncNameAt(pos src.XPos, s *types.Sym, fn *Func) *Name {
-	if fn.Nname != nil {
-		base.Fatalf("newFuncName - already have name")
-	}
-	n := NewNameAt(pos, s)
-	n.SetFunc(fn)
-	fn.Nname = n
-	return n
-}
-
 // MarkFunc marks a node as a function.
 func MarkFunc(n *Name) {
 	if n.Op() != ONAME || n.Class_ != Pxxx {
diff --git a/src/cmd/compile/internal/ir/sizeof_test.go b/src/cmd/compile/internal/ir/sizeof_test.go
index 2a618f85ed..61f207af20 100644
--- a/src/cmd/compile/internal/ir/sizeof_test.go
+++ b/src/cmd/compile/internal/ir/sizeof_test.go
@@ -20,7 +20,7 @@ func TestSizeof(t *testing.T) {
 		_32bit uintptr     // size on 32bit platforms
 		_64bit uintptr     // size on 64bit platforms
 	}{
-		{Func{}, 200, 352},
+		{Func{}, 196, 344},
 		{Name{}, 132, 232},
 	}
 
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 920f4839ad..f4b5e0cf91 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -524,7 +524,8 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) ir.Node {
 		name = ir.BlankNode.Sym() // filled in by typecheckfunc
 	}
 
-	f.Nname = ir.NewFuncNameAt(p.pos(fun.Name), name, f)
+	f.Nname = ir.NewNameAt(p.pos(fun.Name), name)
+	f.Nname.Func = f
 	f.Nname.Defn = f
 	f.Nname.Ntype = t
 
@@ -1742,7 +1743,9 @@ func (p *noder) funcLit(expr *syntax.FuncLit) ir.Node {
 
 	fn := ir.NewFunc(p.pos(expr))
 	fn.SetIsHiddenClosure(ir.CurFunc != nil)
-	fn.Nname = ir.NewFuncNameAt(p.pos(expr), ir.BlankNode.Sym(), fn) // filled in by typecheckclosure
+
+	fn.Nname = ir.NewNameAt(p.pos(expr), ir.BlankNode.Sym()) // filled in by typecheckclosure
+	fn.Nname.Func = fn
 	fn.Nname.Ntype = xtype
 	fn.Nname.Defn = fn
 
diff --git a/src/cmd/compile/internal/typecheck/dcl.go b/src/cmd/compile/internal/typecheck/dcl.go
index 83f926e135..c4f32ff59d 100644
--- a/src/cmd/compile/internal/typecheck/dcl.go
+++ b/src/cmd/compile/internal/typecheck/dcl.go
@@ -23,7 +23,8 @@ func DeclFunc(sym *types.Sym, tfn ir.Ntype) *ir.Func {
 	}
 
 	fn := ir.NewFunc(base.Pos)
-	fn.Nname = ir.NewFuncNameAt(base.Pos, sym, fn)
+	fn.Nname = ir.NewNameAt(base.Pos, sym)
+	fn.Nname.Func = fn
 	fn.Nname.Defn = fn
 	fn.Nname.Ntype = tfn
 	ir.MarkFunc(fn.Nname)
diff --git a/src/cmd/compile/internal/typecheck/export.go b/src/cmd/compile/internal/typecheck/export.go
index 03deff8174..c525391401 100644
--- a/src/cmd/compile/internal/typecheck/export.go
+++ b/src/cmd/compile/internal/typecheck/export.go
@@ -31,12 +31,8 @@ func importconst(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type, val
 // ipkg is the package being imported
 func importfunc(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) *ir.Name {
 	n := importobj(ipkg, pos, s, ir.ONAME, ir.PFUNC, t)
-
-	fn := ir.NewFunc(pos)
-	fn.SetType(t)
-	n.SetFunc(fn)
-	fn.Nname = n
-
+	n.Func = ir.NewFunc(pos)
+	n.Func.Nname = n
 	return n
 }
 
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index 9bb9245d4a..060024951e 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -409,7 +409,6 @@ func tcFunc(n *ir.Func) {
 	if t == nil {
 		return
 	}
-	n.SetType(t)
 	rcvr := t.Recv()
 	if rcvr != nil && n.Shortname != nil {
 		m := addmethod(n, n.Shortname, t, true, n.Pragma&ir.Nointerface != 0)
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 86277e69bd..00ecd9b819 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -331,12 +331,13 @@ func (r *importReader) doDecl(sym *types.Sym) *ir.Name {
 			recv := r.param()
 			mtyp := r.signature(recv)
 
-			fn := ir.NewFunc(mpos)
-			fn.SetType(mtyp)
-			m := ir.NewFuncNameAt(mpos, ir.MethodSym(recv.Type, msym), fn)
-			m.SetType(mtyp)
-			m.Class_ = ir.PFUNC
 			// methodSym already marked m.Sym as a function.
+			m := ir.NewNameAt(mpos, ir.MethodSym(recv.Type, msym))
+			m.Class_ = ir.PFUNC
+			m.SetType(mtyp)
+
+			m.Func = ir.NewFunc(mpos)
+			m.Func.Nname = m
 
 			f := types.NewField(mpos, msym, mtyp)
 			f.Nname = m
diff --git a/src/cmd/compile/internal/walk/closure.go b/src/cmd/compile/internal/walk/closure.go
index 9bcb82bc03..00d3f50bc4 100644
--- a/src/cmd/compile/internal/walk/closure.go
+++ b/src/cmd/compile/internal/walk/closure.go
@@ -67,7 +67,7 @@ func Closure(fn *ir.Func) {
 		}
 
 		types.CalcSize(f.Type())
-		fn.SetType(f.Type()) // update type of ODCLFUNC
+		fn.Nname.SetType(f.Type()) // update type of ODCLFUNC
 	} else {
 		// The closure is not called, so it is going to stay as closure.
 		var body []ir.Node
-- 
GitLab


From 0523d525ae0dea229cffc5634caddd0acbc066af Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Sat, 28 Nov 2020 16:01:58 -0800
Subject: [PATCH 0376/2400] [dev.regabi] cmd/compile: separate out address
 taken computation from typechecker

This CL computes a second parallel addrtaken bit that we check
against the old way of doing it. A subsequent CL will rip out the
typechecker code and just use the new way.

Change-Id: I62b7342c44f694144844695386f80088bbd40bf4
Reviewed-on: https://go-review.googlesource.com/c/go/+/275695
Trust: Keith Randall <khr@golang.org>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/inline/inl.go        |  1 +
 src/cmd/compile/internal/ir/name.go           | 21 ++++++--
 src/cmd/compile/internal/typecheck/func.go    | 16 +++++++
 src/cmd/compile/internal/typecheck/subr.go    | 48 +++++++++++++++++++
 .../compile/internal/typecheck/typecheck.go   | 24 ++++++++--
 src/cmd/compile/internal/walk/order.go        |  3 +-
 6 files changed, 104 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 126871b805..7324369ced 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -1013,6 +1013,7 @@ func inlvar(var_ ir.Node) ir.Node {
 	n.SetUsed(true)
 	n.Curfn = ir.CurFunc // the calling function, not the called one
 	n.SetAddrtaken(var_.Name().Addrtaken())
+	n.SetAddrtaken2(var_.Name().Addrtaken())
 
 	ir.CurFunc.Dcl = append(ir.CurFunc.Dcl, n)
 	return n
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 7958391435..8b1084deeb 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -35,10 +35,10 @@ func (*Ident) CanBeNtype() {}
 // Name holds Node fields used only by named nodes (ONAME, OTYPE, some OLITERAL).
 type Name struct {
 	miniExpr
-	BuiltinOp Op    // uint8
-	Class_    Class // uint8
-	flags     bitset16
+	BuiltinOp Op         // uint8
+	Class_    Class      // uint8
 	pragma    PragmaFlag // int16
+	flags     bitset32
 	sym       *types.Sym
 	Func      *Func
 	Offset_   int64
@@ -273,6 +273,7 @@ const (
 	nameOpenDeferSlot         // if temporary var storing info for open-coded defers
 	nameLibfuzzerExtraCounter // if PEXTERN should be assigned to __libfuzzer_extra_counters section
 	nameAlias                 // is type name an alias
+	nameAddrtaken2
 )
 
 func (n *Name) Captured() bool              { return n.flags&nameCaptured != 0 }
@@ -284,7 +285,7 @@ func (n *Name) Used() bool                  { return n.flags&nameUsed != 0 }
 func (n *Name) IsClosureVar() bool          { return n.flags&nameIsClosureVar != 0 }
 func (n *Name) IsOutputParamHeapAddr() bool { return n.flags&nameIsOutputParamHeapAddr != 0 }
 func (n *Name) Assigned() bool              { return n.flags&nameAssigned != 0 }
-func (n *Name) Addrtaken() bool             { return n.flags&nameAddrtaken != 0 }
+func (n *Name) Addrtaken() bool             { return n.checkAddrtaken() && n.flags&nameAddrtaken != 0 }
 func (n *Name) InlFormal() bool             { return n.flags&nameInlFormal != 0 }
 func (n *Name) InlLocal() bool              { return n.flags&nameInlLocal != 0 }
 func (n *Name) OpenDeferSlot() bool         { return n.flags&nameOpenDeferSlot != 0 }
@@ -300,11 +301,23 @@ func (n *Name) SetIsClosureVar(b bool)          { n.flags.set(nameIsClosureVar,
 func (n *Name) SetIsOutputParamHeapAddr(b bool) { n.flags.set(nameIsOutputParamHeapAddr, b) }
 func (n *Name) SetAssigned(b bool)              { n.flags.set(nameAssigned, b) }
 func (n *Name) SetAddrtaken(b bool)             { n.flags.set(nameAddrtaken, b) }
+func (n *Name) SetAddrtaken2(b bool)            { n.flags.set(nameAddrtaken2, b) }
 func (n *Name) SetInlFormal(b bool)             { n.flags.set(nameInlFormal, b) }
 func (n *Name) SetInlLocal(b bool)              { n.flags.set(nameInlLocal, b) }
 func (n *Name) SetOpenDeferSlot(b bool)         { n.flags.set(nameOpenDeferSlot, b) }
 func (n *Name) SetLibfuzzerExtraCounter(b bool) { n.flags.set(nameLibfuzzerExtraCounter, b) }
 
+func (n *Name) checkAddrtaken() bool {
+	// The two different ways of computing addrtaken bits might diverge during computation,
+	// but any time we look at them, they should be identical.
+	x := n.flags&nameAddrtaken != 0
+	y := n.flags&nameAddrtaken2 != 0
+	if x != y {
+		panic("inconsistent addrtaken")
+	}
+	return true
+}
+
 // MarkReadonly indicates that n is an ONAME with readonly contents.
 func (n *Name) MarkReadonly() {
 	if n.Op() != ONAME {
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index 060024951e..ce6f4027da 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -135,6 +135,7 @@ func CaptureVars(fn *ir.Func) {
 			v.SetByval(true)
 		} else {
 			outermost.Name().SetAddrtaken(true)
+			outermost.Name().SetAddrtaken2(true)
 			outer = NodAddr(outer)
 		}
 
@@ -163,6 +164,21 @@ func CaptureVars(fn *ir.Func) {
 func ImportedBody(fn *ir.Func) {
 	lno := ir.SetPos(fn.Nname)
 
+	// When we load an inlined body, we need to allow OADDR
+	// operations on untyped expressions. We will fix the
+	// addrtaken flags on all the arguments of the OADDR with the
+	// computeAddrtaken call below (after we typecheck the body).
+	// TODO: export/import types and addrtaken marks along with inlined bodies,
+	// so this will be unnecessary.
+	incrementalAddrtaken = false
+	defer func() {
+		if dirtyAddrtaken {
+			computeAddrtaken(fn.Inl.Body) // compute addrtaken marks once types are available
+			dirtyAddrtaken = false
+		}
+		incrementalAddrtaken = true
+	}()
+
 	ImportBody(fn)
 
 	// typecheckinl is only for imported functions;
diff --git a/src/cmd/compile/internal/typecheck/subr.go b/src/cmd/compile/internal/typecheck/subr.go
index 178eba4484..8d31fea9ec 100644
--- a/src/cmd/compile/internal/typecheck/subr.go
+++ b/src/cmd/compile/internal/typecheck/subr.go
@@ -67,9 +67,57 @@ func NodAddr(n ir.Node) *ir.AddrExpr {
 
 // nodAddrPos returns a node representing &n at position pos.
 func NodAddrAt(pos src.XPos, n ir.Node) *ir.AddrExpr {
+	n = markAddrOf(n)
 	return ir.NewAddrExpr(pos, n)
 }
 
+func markAddrOf(n ir.Node) ir.Node {
+	if incrementalAddrtaken {
+		// We can only do incremental addrtaken computation when it is ok
+		// to typecheck the argument of the OADDR. That's only safe after the
+		// main typecheck has completed.
+		// The argument to OADDR needs to be typechecked because &x[i] takes
+		// the address of x if x is an array, but not if x is a slice.
+		// Note: outervalue doesn't work correctly until n is typechecked.
+		n = typecheck(n, ctxExpr)
+		if x := ir.OuterValue(n); x.Op() == ir.ONAME {
+			x.Name().SetAddrtaken2(true)
+		}
+	} else {
+		// Remember that we built an OADDR without computing the Addrtaken bit for
+		// its argument. We'll do that later in bulk using computeAddrtaken.
+		dirtyAddrtaken = true
+	}
+	return n
+}
+
+// If incrementalAddrtaken is false, we do not compute Addrtaken for an OADDR Node
+// when it is built. The Addrtaken bits are set in bulk by computeAddrtaken.
+// If incrementalAddrtaken is true, then when an OADDR Node is built the Addrtaken
+// field of its argument is updated immediately.
+var incrementalAddrtaken = false
+
+// If dirtyAddrtaken is true, then there are OADDR whose corresponding arguments
+// have not yet been marked as Addrtaken.
+var dirtyAddrtaken = false
+
+func computeAddrtaken(top []ir.Node) {
+	for _, n := range top {
+		ir.Visit(n, func(n ir.Node) {
+			if n.Op() == ir.OADDR {
+				if x := ir.OuterValue(n.(*ir.AddrExpr).X); x.Op() == ir.ONAME {
+					x.Name().SetAddrtaken2(true)
+					if x.Name().IsClosureVar() {
+						// Mark the original variable as Addrtaken so that capturevars
+						// knows not to pass it by value.
+						x.Name().Defn.Name().SetAddrtaken2(true)
+					}
+				}
+			}
+		})
+	}
+}
+
 func NodNil() ir.Node {
 	n := ir.NewNilExpr(base.Pos)
 	n.SetType(types.Types[types.TNIL])
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index e29d58cefa..335e1b53ce 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -99,7 +99,26 @@ func Package() {
 	// Phase 5: With all user code type-checked, it's now safe to verify map keys.
 	CheckMapKeys()
 
-	// Phase 6: Decide how to capture closed variables.
+	// Phase 6: Compute Addrtaken for names.
+	// We need to wait until typechecking is done so that when we see &x[i]
+	// we know that x has its address taken if x is an array, but not if x is a slice.
+	// We compute Addrtaken in bulk here.
+	// After this phase, we maintain Addrtaken incrementally.
+	if dirtyAddrtaken {
+		computeAddrtaken(Target.Decls)
+		dirtyAddrtaken = false
+	}
+	incrementalAddrtaken = true
+
+	// Phase 7: Eliminate some obviously dead code.
+	// Must happen after typechecking.
+	for _, n := range Target.Decls {
+		if n.Op() == ir.ODCLFUNC {
+			deadcode(n.(*ir.Func))
+		}
+	}
+
+	// Phase 8: Decide how to capture closed variables.
 	// This needs to run before escape analysis,
 	// because variables captured by value do not escape.
 	base.Timer.Start("fe", "capturevars")
@@ -156,9 +175,6 @@ func FuncBody(n *ir.Func) {
 	if base.Errors() > errorsBefore {
 		n.Body.Set(nil) // type errors; do not compile
 	}
-	// Now that we've checked whether n terminates,
-	// we can eliminate some obviously dead code.
-	deadcode(n)
 }
 
 var importlist []*ir.Func
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index 0dd76ccee9..82180c113e 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -517,7 +517,8 @@ func (o *orderState) call(nn ir.Node) {
 			if arg.X.Type().IsUnsafePtr() {
 				x := o.copyExpr(arg.X)
 				arg.X = x
-				x.Name().SetAddrtaken(true) // ensure SSA keeps the x variable
+				x.Name().SetAddrtaken(true)  // ensure SSA keeps the x variable
+				x.Name().SetAddrtaken2(true) // ensure SSA keeps the x variable
 				n.Body.Append(typecheck.Stmt(ir.NewUnaryExpr(base.Pos, ir.OVARLIVE, x)))
 			}
 		}
-- 
GitLab


From 0620c674ddca234e0a69b5a35c5fb06a881dd73b Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Sat, 28 Nov 2020 12:37:55 -0800
Subject: [PATCH 0377/2400] [dev.regabi] cmd/compile: remove original addrtaken
 bit

Switch the source of truth to the new addrtaken bit. Remove the old one.

Change-Id: Ie53679ab14cfcd34b55e912e7ecb962a22db7db3
Reviewed-on: https://go-review.googlesource.com/c/go/+/275696
Trust: Keith Randall <khr@golang.org>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/inline/inl.go     |  1 -
 src/cmd/compile/internal/ir/name.go        | 14 +-------------
 src/cmd/compile/internal/typecheck/expr.go |  8 --------
 src/cmd/compile/internal/typecheck/func.go |  1 -
 src/cmd/compile/internal/walk/order.go     |  1 -
 5 files changed, 1 insertion(+), 24 deletions(-)

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 7324369ced..8f3a4b4d8c 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -1012,7 +1012,6 @@ func inlvar(var_ ir.Node) ir.Node {
 	n.Class_ = ir.PAUTO
 	n.SetUsed(true)
 	n.Curfn = ir.CurFunc // the calling function, not the called one
-	n.SetAddrtaken(var_.Name().Addrtaken())
 	n.SetAddrtaken2(var_.Name().Addrtaken())
 
 	ir.CurFunc.Dcl = append(ir.CurFunc.Dcl, n)
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 8b1084deeb..6e41fd650b 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -285,7 +285,7 @@ func (n *Name) Used() bool                  { return n.flags&nameUsed != 0 }
 func (n *Name) IsClosureVar() bool          { return n.flags&nameIsClosureVar != 0 }
 func (n *Name) IsOutputParamHeapAddr() bool { return n.flags&nameIsOutputParamHeapAddr != 0 }
 func (n *Name) Assigned() bool              { return n.flags&nameAssigned != 0 }
-func (n *Name) Addrtaken() bool             { return n.checkAddrtaken() && n.flags&nameAddrtaken != 0 }
+func (n *Name) Addrtaken() bool             { return n.flags&nameAddrtaken2 != 0 }
 func (n *Name) InlFormal() bool             { return n.flags&nameInlFormal != 0 }
 func (n *Name) InlLocal() bool              { return n.flags&nameInlLocal != 0 }
 func (n *Name) OpenDeferSlot() bool         { return n.flags&nameOpenDeferSlot != 0 }
@@ -300,24 +300,12 @@ func (n *Name) SetUsed(b bool)                  { n.flags.set(nameUsed, b) }
 func (n *Name) SetIsClosureVar(b bool)          { n.flags.set(nameIsClosureVar, b) }
 func (n *Name) SetIsOutputParamHeapAddr(b bool) { n.flags.set(nameIsOutputParamHeapAddr, b) }
 func (n *Name) SetAssigned(b bool)              { n.flags.set(nameAssigned, b) }
-func (n *Name) SetAddrtaken(b bool)             { n.flags.set(nameAddrtaken, b) }
 func (n *Name) SetAddrtaken2(b bool)            { n.flags.set(nameAddrtaken2, b) }
 func (n *Name) SetInlFormal(b bool)             { n.flags.set(nameInlFormal, b) }
 func (n *Name) SetInlLocal(b bool)              { n.flags.set(nameInlLocal, b) }
 func (n *Name) SetOpenDeferSlot(b bool)         { n.flags.set(nameOpenDeferSlot, b) }
 func (n *Name) SetLibfuzzerExtraCounter(b bool) { n.flags.set(nameLibfuzzerExtraCounter, b) }
 
-func (n *Name) checkAddrtaken() bool {
-	// The two different ways of computing addrtaken bits might diverge during computation,
-	// but any time we look at them, they should be identical.
-	x := n.flags&nameAddrtaken != 0
-	y := n.flags&nameAddrtaken2 != 0
-	if x != y {
-		panic("inconsistent addrtaken")
-	}
-	return true
-}
-
 // MarkReadonly indicates that n is an ONAME with readonly contents.
 func (n *Name) MarkReadonly() {
 	if n.Op() != ONAME {
diff --git a/src/cmd/compile/internal/typecheck/expr.go b/src/cmd/compile/internal/typecheck/expr.go
index 5752139c0b..12bfae67a8 100644
--- a/src/cmd/compile/internal/typecheck/expr.go
+++ b/src/cmd/compile/internal/typecheck/expr.go
@@ -35,14 +35,6 @@ func tcAddr(n *ir.AddrExpr) ir.Node {
 			if ir.Orig(r) != r {
 				base.Fatalf("found non-orig name node %v", r) // TODO(mdempsky): What does this mean?
 			}
-			r.Name().SetAddrtaken(true)
-			if r.Name().IsClosureVar() && !CaptureVarsComplete {
-				// Mark the original variable as Addrtaken so that capturevars
-				// knows not to pass it by value.
-				// But if the capturevars phase is complete, don't touch it,
-				// in case l.Name's containing function has not yet been compiled.
-				r.Name().Defn.Name().SetAddrtaken(true)
-			}
 		}
 		n.X = DefaultLit(n.X, nil)
 		if n.X.Type() == nil {
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index ce6f4027da..0819380885 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -134,7 +134,6 @@ func CaptureVars(fn *ir.Func) {
 		if outermost.Class_ != ir.PPARAMOUT && !outermost.Name().Addrtaken() && !outermost.Name().Assigned() && v.Type().Width <= 128 {
 			v.SetByval(true)
 		} else {
-			outermost.Name().SetAddrtaken(true)
 			outermost.Name().SetAddrtaken2(true)
 			outer = NodAddr(outer)
 		}
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index 82180c113e..58c1c597fc 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -517,7 +517,6 @@ func (o *orderState) call(nn ir.Node) {
 			if arg.X.Type().IsUnsafePtr() {
 				x := o.copyExpr(arg.X)
 				arg.X = x
-				x.Name().SetAddrtaken(true)  // ensure SSA keeps the x variable
 				x.Name().SetAddrtaken2(true) // ensure SSA keeps the x variable
 				n.Body.Append(typecheck.Stmt(ir.NewUnaryExpr(base.Pos, ir.OVARLIVE, x)))
 			}
-- 
GitLab


From b3e1ec97fd57d66eb1a1307b8c96141d0014ec51 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Sat, 28 Nov 2020 12:55:01 -0800
Subject: [PATCH 0378/2400] [dev.regabi] cmd/compile: move new addrtaken bit
 back to the old name

Change-Id: I2732aefe95a21c23d73a907d5596fcb1626d6dd7
Reviewed-on: https://go-review.googlesource.com/c/go/+/275697
Trust: Keith Randall <khr@golang.org>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/inline/inl.go     | 2 +-
 src/cmd/compile/internal/ir/name.go        | 7 +++----
 src/cmd/compile/internal/typecheck/func.go | 2 +-
 src/cmd/compile/internal/typecheck/subr.go | 6 +++---
 src/cmd/compile/internal/walk/order.go     | 2 +-
 5 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 8f3a4b4d8c..126871b805 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -1012,7 +1012,7 @@ func inlvar(var_ ir.Node) ir.Node {
 	n.Class_ = ir.PAUTO
 	n.SetUsed(true)
 	n.Curfn = ir.CurFunc // the calling function, not the called one
-	n.SetAddrtaken2(var_.Name().Addrtaken())
+	n.SetAddrtaken(var_.Name().Addrtaken())
 
 	ir.CurFunc.Dcl = append(ir.CurFunc.Dcl, n)
 	return n
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 6e41fd650b..d6135ee29a 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -38,7 +38,7 @@ type Name struct {
 	BuiltinOp Op         // uint8
 	Class_    Class      // uint8
 	pragma    PragmaFlag // int16
-	flags     bitset32
+	flags     bitset16
 	sym       *types.Sym
 	Func      *Func
 	Offset_   int64
@@ -273,7 +273,6 @@ const (
 	nameOpenDeferSlot         // if temporary var storing info for open-coded defers
 	nameLibfuzzerExtraCounter // if PEXTERN should be assigned to __libfuzzer_extra_counters section
 	nameAlias                 // is type name an alias
-	nameAddrtaken2
 )
 
 func (n *Name) Captured() bool              { return n.flags&nameCaptured != 0 }
@@ -285,7 +284,7 @@ func (n *Name) Used() bool                  { return n.flags&nameUsed != 0 }
 func (n *Name) IsClosureVar() bool          { return n.flags&nameIsClosureVar != 0 }
 func (n *Name) IsOutputParamHeapAddr() bool { return n.flags&nameIsOutputParamHeapAddr != 0 }
 func (n *Name) Assigned() bool              { return n.flags&nameAssigned != 0 }
-func (n *Name) Addrtaken() bool             { return n.flags&nameAddrtaken2 != 0 }
+func (n *Name) Addrtaken() bool             { return n.flags&nameAddrtaken != 0 }
 func (n *Name) InlFormal() bool             { return n.flags&nameInlFormal != 0 }
 func (n *Name) InlLocal() bool              { return n.flags&nameInlLocal != 0 }
 func (n *Name) OpenDeferSlot() bool         { return n.flags&nameOpenDeferSlot != 0 }
@@ -300,7 +299,7 @@ func (n *Name) SetUsed(b bool)                  { n.flags.set(nameUsed, b) }
 func (n *Name) SetIsClosureVar(b bool)          { n.flags.set(nameIsClosureVar, b) }
 func (n *Name) SetIsOutputParamHeapAddr(b bool) { n.flags.set(nameIsOutputParamHeapAddr, b) }
 func (n *Name) SetAssigned(b bool)              { n.flags.set(nameAssigned, b) }
-func (n *Name) SetAddrtaken2(b bool)            { n.flags.set(nameAddrtaken2, b) }
+func (n *Name) SetAddrtaken(b bool)             { n.flags.set(nameAddrtaken, b) }
 func (n *Name) SetInlFormal(b bool)             { n.flags.set(nameInlFormal, b) }
 func (n *Name) SetInlLocal(b bool)              { n.flags.set(nameInlLocal, b) }
 func (n *Name) SetOpenDeferSlot(b bool)         { n.flags.set(nameOpenDeferSlot, b) }
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index 0819380885..75f38d588d 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -134,7 +134,7 @@ func CaptureVars(fn *ir.Func) {
 		if outermost.Class_ != ir.PPARAMOUT && !outermost.Name().Addrtaken() && !outermost.Name().Assigned() && v.Type().Width <= 128 {
 			v.SetByval(true)
 		} else {
-			outermost.Name().SetAddrtaken2(true)
+			outermost.Name().SetAddrtaken(true)
 			outer = NodAddr(outer)
 		}
 
diff --git a/src/cmd/compile/internal/typecheck/subr.go b/src/cmd/compile/internal/typecheck/subr.go
index 8d31fea9ec..9d414874a0 100644
--- a/src/cmd/compile/internal/typecheck/subr.go
+++ b/src/cmd/compile/internal/typecheck/subr.go
@@ -81,7 +81,7 @@ func markAddrOf(n ir.Node) ir.Node {
 		// Note: outervalue doesn't work correctly until n is typechecked.
 		n = typecheck(n, ctxExpr)
 		if x := ir.OuterValue(n); x.Op() == ir.ONAME {
-			x.Name().SetAddrtaken2(true)
+			x.Name().SetAddrtaken(true)
 		}
 	} else {
 		// Remember that we built an OADDR without computing the Addrtaken bit for
@@ -106,11 +106,11 @@ func computeAddrtaken(top []ir.Node) {
 		ir.Visit(n, func(n ir.Node) {
 			if n.Op() == ir.OADDR {
 				if x := ir.OuterValue(n.(*ir.AddrExpr).X); x.Op() == ir.ONAME {
-					x.Name().SetAddrtaken2(true)
+					x.Name().SetAddrtaken(true)
 					if x.Name().IsClosureVar() {
 						// Mark the original variable as Addrtaken so that capturevars
 						// knows not to pass it by value.
-						x.Name().Defn.Name().SetAddrtaken2(true)
+						x.Name().Defn.Name().SetAddrtaken(true)
 					}
 				}
 			}
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index 58c1c597fc..0dd76ccee9 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -517,7 +517,7 @@ func (o *orderState) call(nn ir.Node) {
 			if arg.X.Type().IsUnsafePtr() {
 				x := o.copyExpr(arg.X)
 				arg.X = x
-				x.Name().SetAddrtaken2(true) // ensure SSA keeps the x variable
+				x.Name().SetAddrtaken(true) // ensure SSA keeps the x variable
 				n.Body.Append(typecheck.Stmt(ir.NewUnaryExpr(base.Pos, ir.OVARLIVE, x)))
 			}
 		}
-- 
GitLab


From 5cf3c87fa6ce8440ccda9dddeec0d5e899ee485e Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Tue, 29 Dec 2020 23:26:45 +0700
Subject: [PATCH 0379/2400] [dev.regabi] cmd/compile: generate case/comm clause
 functions in mknode.go

Passes toolstash -cmp.

Change-Id: I52e9d6f35f22d5d59ac6aad02011c5abaac45739
Reviewed-on: https://go-review.googlesource.com/c/go/+/279446
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/mknode.go   | 38 ++++++++++++++++
 src/cmd/compile/internal/ir/node_gen.go | 58 ++++++++++++++++++++++++
 src/cmd/compile/internal/ir/stmt.go     | 60 -------------------------
 3 files changed, 96 insertions(+), 60 deletions(-)

diff --git a/src/cmd/compile/internal/ir/mknode.go b/src/cmd/compile/internal/ir/mknode.go
index 3b5da32d8c..17ef720172 100644
--- a/src/cmd/compile/internal/ir/mknode.go
+++ b/src/cmd/compile/internal/ir/mknode.go
@@ -136,6 +136,10 @@ func main() {
 		fmt.Fprintf(&buf, "}\n")
 	}
 
+	for _, name := range []string{"CaseClause", "CommClause"} {
+		sliceHelper(&buf, name)
+	}
+
 	out, err := format.Source(buf.Bytes())
 	if err != nil {
 		// write out mangled source so we can see the bug.
@@ -148,6 +152,40 @@ func main() {
 	}
 }
 
+func sliceHelper(buf *bytes.Buffer, name string) {
+	tmpl := fmt.Sprintf(`
+func copy%[1]ss(list []*%[2]s) []*%[2]s {
+	if list == nil {
+		return nil
+	}
+	c := make([]*%[2]s, len(list))
+	copy(c, list)
+	return c
+}
+func maybeDo%[1]ss(list []*%[2]s, err error, do func(Node) error) error {
+	if err != nil {
+		return err
+	}
+	for _, x := range list {
+		if x != nil {
+			if err := do(x); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+func edit%[1]ss(list []*%[2]s, edit func(Node) Node) {
+	for i, x := range list {
+		if x != nil {
+			list[i] = edit(x).(*%[2]s)
+		}
+	}
+}
+`, strings.TrimSuffix(name, "Clause"), name)
+	fmt.Fprintln(buf, tmpl)
+}
+
 func forNodeFields(typName string, typ *types.Struct, f func(name string, is func(types.Type) bool)) {
 	for i, n := 0, typ.NumFields(); i < n; i++ {
 		v := typ.Field(i)
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index fe54b62f18..a2a30a0587 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -1015,3 +1015,61 @@ func (n *typeNode) doChildren(do func(Node) error) error {
 }
 func (n *typeNode) editChildren(edit func(Node) Node) {
 }
+
+func copyCases(list []*CaseClause) []*CaseClause {
+	if list == nil {
+		return nil
+	}
+	c := make([]*CaseClause, len(list))
+	copy(c, list)
+	return c
+}
+func maybeDoCases(list []*CaseClause, err error, do func(Node) error) error {
+	if err != nil {
+		return err
+	}
+	for _, x := range list {
+		if x != nil {
+			if err := do(x); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+func editCases(list []*CaseClause, edit func(Node) Node) {
+	for i, x := range list {
+		if x != nil {
+			list[i] = edit(x).(*CaseClause)
+		}
+	}
+}
+
+func copyComms(list []*CommClause) []*CommClause {
+	if list == nil {
+		return nil
+	}
+	c := make([]*CommClause, len(list))
+	copy(c, list)
+	return c
+}
+func maybeDoComms(list []*CommClause, err error, do func(Node) error) error {
+	if err != nil {
+		return err
+	}
+	for _, x := range list {
+		if x != nil {
+			if err := do(x); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+func editComms(list []*CommClause, edit func(Node) Node) {
+	for i, x := range list {
+		if x != nil {
+			list[i] = edit(x).(*CommClause)
+		}
+	}
+}
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index 1301e65e26..d88280dda7 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -184,36 +184,6 @@ func NewCaseStmt(pos src.XPos, list, body []Node) *CaseClause {
 	return n
 }
 
-// TODO(mdempsky): Generate these with mknode.go.
-func copyCases(list []*CaseClause) []*CaseClause {
-	if list == nil {
-		return nil
-	}
-	c := make([]*CaseClause, len(list))
-	copy(c, list)
-	return c
-}
-func maybeDoCases(list []*CaseClause, err error, do func(Node) error) error {
-	if err != nil {
-		return err
-	}
-	for _, x := range list {
-		if x != nil {
-			if err := do(x); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-func editCases(list []*CaseClause, edit func(Node) Node) {
-	for i, x := range list {
-		if x != nil {
-			list[i] = edit(x).(*CaseClause)
-		}
-	}
-}
-
 type CommClause struct {
 	miniStmt
 	Comm Node // communication case
@@ -227,36 +197,6 @@ func NewCommStmt(pos src.XPos, comm Node, body []Node) *CommClause {
 	return n
 }
 
-// TODO(mdempsky): Generate these with mknode.go.
-func copyComms(list []*CommClause) []*CommClause {
-	if list == nil {
-		return nil
-	}
-	c := make([]*CommClause, len(list))
-	copy(c, list)
-	return c
-}
-func maybeDoComms(list []*CommClause, err error, do func(Node) error) error {
-	if err != nil {
-		return err
-	}
-	for _, x := range list {
-		if x != nil {
-			if err := do(x); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-func editComms(list []*CommClause, edit func(Node) Node) {
-	for i, x := range list {
-		if x != nil {
-			list[i] = edit(x).(*CommClause)
-		}
-	}
-}
-
 // A ForStmt is a non-range for loop: for Init; Cond; Post { Body }
 // Op can be OFOR or OFORUNTIL (!Cond).
 type ForStmt struct {
-- 
GitLab


From 37babc97bb8f1d26dbbbc39e4ec5080a273fa2bb Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Wed, 30 Dec 2020 00:18:35 +0700
Subject: [PATCH 0380/2400] [dev.regabi] cmd/compile: allow visitor visits
 *ir.Name

So future CLs can refactor ir.Node to *ir.Name when possible.

Passes toolstash -cmp.

Change-Id: I91ae38417ba10de207ed84b65d1d69cf64f24456
Reviewed-on: https://go-review.googlesource.com/c/go/+/279448
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/mknode.go   |  5 ++-
 src/cmd/compile/internal/ir/node_gen.go | 42 +++++++++++++++++++++++++
 2 files changed, 46 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ir/mknode.go b/src/cmd/compile/internal/ir/mknode.go
index 17ef720172..54a228bce7 100644
--- a/src/cmd/compile/internal/ir/mknode.go
+++ b/src/cmd/compile/internal/ir/mknode.go
@@ -35,6 +35,7 @@ func main() {
 	}
 
 	nodeType := lookup("Node")
+	ptrNameType := types.NewPointer(lookup("Name"))
 	ntypeType := lookup("Ntype")
 	nodesType := lookup("Nodes")
 	slicePtrCaseClauseType := types.NewSlice(types.NewPointer(lookup("CaseClause")))
@@ -94,7 +95,7 @@ func main() {
 		fmt.Fprintf(&buf, "func (n *%s) doChildren(do func(Node) error) error { var err error\n", name)
 		forNodeFields(typName, typ, func(name string, is func(types.Type) bool) {
 			switch {
-			case is(ptrIdentType):
+			case is(ptrIdentType), is(ptrNameType):
 				fmt.Fprintf(&buf, "if n.%s != nil { err = maybeDo(n.%s, err, do) }\n", name, name)
 			case is(nodeType), is(ntypeType):
 				fmt.Fprintf(&buf, "err = maybeDo(n.%s, err, do)\n", name)
@@ -117,6 +118,8 @@ func main() {
 			switch {
 			case is(ptrIdentType):
 				fmt.Fprintf(&buf, "if n.%s != nil { n.%s = edit(n.%s).(*Ident) }\n", name, name, name)
+			case is(ptrNameType):
+				fmt.Fprintf(&buf, "if n.%s != nil { n.%s = edit(n.%s).(*Name) }\n", name, name, name)
 			case is(nodeType):
 				fmt.Fprintf(&buf, "n.%s = maybeEdit(n.%s, edit)\n", name, name)
 			case is(ntypeType):
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index a2a30a0587..d8bb4200ef 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -15,11 +15,17 @@ func (n *AddStringExpr) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
 	err = maybeDoList(n.List, err, do)
+	if n.Prealloc != nil {
+		err = maybeDo(n.Prealloc, err, do)
+	}
 	return err
 }
 func (n *AddStringExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	editList(n.List, edit)
+	if n.Prealloc != nil {
+		n.Prealloc = edit(n.Prealloc).(*Name)
+	}
 }
 
 func (n *AddrExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
@@ -32,11 +38,17 @@ func (n *AddrExpr) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
 	err = maybeDo(n.X, err, do)
+	if n.Alloc != nil {
+		err = maybeDo(n.Alloc, err, do)
+	}
 	return err
 }
 func (n *AddrExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	n.X = maybeEdit(n.X, edit)
+	if n.Alloc != nil {
+		n.Alloc = edit(n.Alloc).(*Name)
+	}
 }
 
 func (n *ArrayType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
@@ -253,10 +265,16 @@ func (n *ClosureExpr) copy() Node {
 func (n *ClosureExpr) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
+	if n.Prealloc != nil {
+		err = maybeDo(n.Prealloc, err, do)
+	}
 	return err
 }
 func (n *ClosureExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
+	if n.Prealloc != nil {
+		n.Prealloc = edit(n.Prealloc).(*Name)
+	}
 }
 
 func (n *ClosureReadExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
@@ -306,12 +324,18 @@ func (n *CompLitExpr) doChildren(do func(Node) error) error {
 	err = maybeDoList(n.init, err, do)
 	err = maybeDo(n.Ntype, err, do)
 	err = maybeDoList(n.List, err, do)
+	if n.Prealloc != nil {
+		err = maybeDo(n.Prealloc, err, do)
+	}
 	return err
 }
 func (n *CompLitExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	n.Ntype = toNtype(maybeEdit(n.Ntype, edit))
 	editList(n.List, edit)
+	if n.Prealloc != nil {
+		n.Prealloc = edit(n.Prealloc).(*Name)
+	}
 }
 
 func (n *ConstExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
@@ -654,10 +678,16 @@ func (n *NameOffsetExpr) copy() Node {
 func (n *NameOffsetExpr) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
+	if n.Name_ != nil {
+		err = maybeDo(n.Name_, err, do)
+	}
 	return err
 }
 func (n *NameOffsetExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
+	if n.Name_ != nil {
+		n.Name_ = edit(n.Name_).(*Name)
+	}
 }
 
 func (n *NilExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
@@ -718,6 +748,9 @@ func (n *RangeStmt) doChildren(do func(Node) error) error {
 	err = maybeDo(n.Key, err, do)
 	err = maybeDo(n.Value, err, do)
 	err = maybeDoList(n.Body, err, do)
+	if n.Prealloc != nil {
+		err = maybeDo(n.Prealloc, err, do)
+	}
 	return err
 }
 func (n *RangeStmt) editChildren(edit func(Node) Node) {
@@ -726,6 +759,9 @@ func (n *RangeStmt) editChildren(edit func(Node) Node) {
 	n.Key = maybeEdit(n.Key, edit)
 	n.Value = maybeEdit(n.Value, edit)
 	editList(n.Body, edit)
+	if n.Prealloc != nil {
+		n.Prealloc = edit(n.Prealloc).(*Name)
+	}
 }
 
 func (n *ResultExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
@@ -792,11 +828,17 @@ func (n *SelectorExpr) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
 	err = maybeDo(n.X, err, do)
+	if n.Prealloc != nil {
+		err = maybeDo(n.Prealloc, err, do)
+	}
 	return err
 }
 func (n *SelectorExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	n.X = maybeEdit(n.X, edit)
+	if n.Prealloc != nil {
+		n.Prealloc = edit(n.Prealloc).(*Name)
+	}
 }
 
 func (n *SendStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
-- 
GitLab


From 850aa7c60cb56d0cc40e3c213acb14ac96e2bf9e Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Wed, 30 Dec 2020 01:24:30 +0700
Subject: [PATCH 0381/2400] [dev.regabi] cmd/compile: use *ir.Name instead of
 ir.Node for CaseClause.Var

Passes toolstash -cmp.

Change-Id: Ib0b6ebf5751ffce2c9500dc67d78e54937ead208
Reviewed-on: https://go-review.googlesource.com/c/go/+/279449
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/escape/escape.go     | 2 +-
 src/cmd/compile/internal/ir/node_gen.go       | 8 ++++++--
 src/cmd/compile/internal/ir/stmt.go           | 2 +-
 src/cmd/compile/internal/typecheck/iexport.go | 2 +-
 src/cmd/compile/internal/typecheck/stmt.go    | 2 +-
 src/cmd/compile/internal/walk/switch.go       | 4 ++--
 6 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index b953666ce6..ec99c86c06 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -374,7 +374,7 @@ func (e *escape) stmt(n ir.Node) {
 		var ks []hole
 		for _, cas := range n.Cases { // cases
 			if typesw && n.Tag.(*ir.TypeSwitchGuard).Tag != nil {
-				cv := cas.Var.(*ir.Name)
+				cv := cas.Var
 				k := e.dcl(cv) // type switch variables have no ODCL.
 				if cv.Type().HasPointers() {
 					ks = append(ks, k.dotType(cv.Type(), cas, "switch case"))
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index d8bb4200ef..6c1a28022f 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -230,14 +230,18 @@ func (n *CaseClause) copy() Node {
 func (n *CaseClause) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.Var, err, do)
+	if n.Var != nil {
+		err = maybeDo(n.Var, err, do)
+	}
 	err = maybeDoList(n.List, err, do)
 	err = maybeDoList(n.Body, err, do)
 	return err
 }
 func (n *CaseClause) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
-	n.Var = maybeEdit(n.Var, edit)
+	if n.Var != nil {
+		n.Var = edit(n.Var).(*Name)
+	}
 	editList(n.List, edit)
 	editList(n.Body, edit)
 }
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index d88280dda7..a1f5e5933f 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -172,7 +172,7 @@ func (n *BranchStmt) Sym() *types.Sym { return n.Label }
 // A CaseClause is a case statement in a switch or select: case List: Body.
 type CaseClause struct {
 	miniStmt
-	Var  Node  // declared variable for this case in type switch
+	Var  *Name // declared variable for this case in type switch
 	List Nodes // list of expressions for switch, early select
 	Body Nodes
 }
diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index c287d76c43..489879b3b4 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -1187,7 +1187,7 @@ func (w *exportWriter) caseList(cases []*ir.CaseClause, namedTypeSwitch bool) {
 		w.pos(cas.Pos())
 		w.stmtList(cas.List)
 		if namedTypeSwitch {
-			w.localName(cas.Var.(*ir.Name))
+			w.localName(cas.Var)
 		}
 		w.stmtList(cas.Body)
 	}
diff --git a/src/cmd/compile/internal/typecheck/stmt.go b/src/cmd/compile/internal/typecheck/stmt.go
index f5d36a663d..d90d13b44c 100644
--- a/src/cmd/compile/internal/typecheck/stmt.go
+++ b/src/cmd/compile/internal/typecheck/stmt.go
@@ -631,7 +631,7 @@ func tcSwitchType(n *ir.SwitchStmt) {
 			nvar := ncase.Var
 			nvar.SetType(vt)
 			if vt != nil {
-				nvar = AssignExpr(nvar)
+				nvar = AssignExpr(nvar).(*ir.Name)
 			} else {
 				// Clause variable is broken; prevent typechecking.
 				nvar.SetTypecheck(1)
diff --git a/src/cmd/compile/internal/walk/switch.go b/src/cmd/compile/internal/walk/switch.go
index de0b471b34..b03bc3eba7 100644
--- a/src/cmd/compile/internal/walk/switch.go
+++ b/src/cmd/compile/internal/walk/switch.go
@@ -440,7 +440,7 @@ type typeClause struct {
 	body ir.Nodes
 }
 
-func (s *typeSwitch) Add(pos src.XPos, typ *types.Type, caseVar, jmp ir.Node) {
+func (s *typeSwitch) Add(pos src.XPos, typ *types.Type, caseVar *ir.Name, jmp ir.Node) {
 	var body ir.Nodes
 	if caseVar != nil {
 		l := []ir.Node{
@@ -450,7 +450,7 @@ func (s *typeSwitch) Add(pos src.XPos, typ *types.Type, caseVar, jmp ir.Node) {
 		typecheck.Stmts(l)
 		body.Append(l...)
 	} else {
-		caseVar = ir.BlankNode
+		caseVar = ir.BlankNode.(*ir.Name)
 	}
 
 	// cv, ok = iface.(type)
-- 
GitLab


From f5816624cd332ec236c9a155b4a16ba0e8b968af Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Wed, 30 Dec 2020 01:44:56 +0700
Subject: [PATCH 0382/2400] [dev.regabi] cmd/compile: change AddrExpr.Alloc to
 AddrExpr.Prealloc

For being consistent with other Prealloc fields.

[git-generate]

cd src/cmd/compile/internal/ir
rf '
  mv AddrExpr.Alloc AddrExpr.Prealloc
'
go generate

Change-Id: Id1b05119092036e3f8208b73b63bd0ca6ceb7b15
Reviewed-on: https://go-review.googlesource.com/c/go/+/279450
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ir/expr.go      | 4 ++--
 src/cmd/compile/internal/ir/node_gen.go  | 8 ++++----
 src/cmd/compile/internal/walk/closure.go | 4 ++--
 src/cmd/compile/internal/walk/complit.go | 6 +++---
 4 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index bb32d96088..a989ce5e01 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -106,8 +106,8 @@ func NewAddStringExpr(pos src.XPos, list []Node) *AddStringExpr {
 // It may end up being a normal address-of or an allocation of a composite literal.
 type AddrExpr struct {
 	miniExpr
-	X     Node
-	Alloc *Name // preallocated storage if any
+	X        Node
+	Prealloc *Name // preallocated storage if any
 }
 
 func NewAddrExpr(pos src.XPos, x Node) *AddrExpr {
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index 6c1a28022f..0dd5100018 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -38,16 +38,16 @@ func (n *AddrExpr) doChildren(do func(Node) error) error {
 	var err error
 	err = maybeDoList(n.init, err, do)
 	err = maybeDo(n.X, err, do)
-	if n.Alloc != nil {
-		err = maybeDo(n.Alloc, err, do)
+	if n.Prealloc != nil {
+		err = maybeDo(n.Prealloc, err, do)
 	}
 	return err
 }
 func (n *AddrExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 	n.X = maybeEdit(n.X, edit)
-	if n.Alloc != nil {
-		n.Alloc = edit(n.Alloc).(*Name)
+	if n.Prealloc != nil {
+		n.Prealloc = edit(n.Prealloc).(*Name)
 	}
 }
 
diff --git a/src/cmd/compile/internal/walk/closure.go b/src/cmd/compile/internal/walk/closure.go
index 00d3f50bc4..0726d3b552 100644
--- a/src/cmd/compile/internal/walk/closure.go
+++ b/src/cmd/compile/internal/walk/closure.go
@@ -144,7 +144,7 @@ func walkClosure(clo *ir.ClosureExpr, init *ir.Nodes) ir.Node {
 		if !types.Identical(typ, x.Type()) {
 			panic("closure type does not match order's assigned type")
 		}
-		addr.Alloc = x
+		addr.Prealloc = x
 		clo.Prealloc = nil
 	}
 
@@ -189,7 +189,7 @@ func walkCallPart(n *ir.SelectorExpr, init *ir.Nodes) ir.Node {
 		if !types.Identical(typ, x.Type()) {
 			panic("partial call type does not match order's assigned type")
 		}
-		addr.Alloc = x
+		addr.Prealloc = x
 		n.Prealloc = nil
 	}
 
diff --git a/src/cmd/compile/internal/walk/complit.go b/src/cmd/compile/internal/walk/complit.go
index 3c28ed70ad..d8605d39bd 100644
--- a/src/cmd/compile/internal/walk/complit.go
+++ b/src/cmd/compile/internal/walk/complit.go
@@ -549,10 +549,10 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 		}
 
 		var r ir.Node
-		if n.Alloc != nil {
+		if n.Prealloc != nil {
 			// n.Right is stack temporary used as backing store.
-			appendWalkStmt(init, ir.NewAssignStmt(base.Pos, n.Alloc, nil)) // zero backing store, just in case (#18410)
-			r = typecheck.NodAddr(n.Alloc)
+			appendWalkStmt(init, ir.NewAssignStmt(base.Pos, n.Prealloc, nil)) // zero backing store, just in case (#18410)
+			r = typecheck.NodAddr(n.Prealloc)
 		} else {
 			r = ir.NewUnaryExpr(base.Pos, ir.ONEW, ir.TypeNode(n.X.Type()))
 			r.SetEsc(n.Esc())
-- 
GitLab


From 9958b7ed3e92007cda0f25cffe502e2b88689c6c Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Wed, 30 Dec 2020 02:01:41 +0700
Subject: [PATCH 0383/2400] [dev.regabi] cmd/compile: unexport ir.FmtNode

It's only used inside package ir now.

[git-generate]

cd src/cmd/compile/internal/ir
rf 'mv FmtNode fmtNode'
sed -i 's/FmtNode/fmtNode/g' mknode.go
go generate

Change-Id: Ib8f6c6984905a4d4cfca1b23972a39c5ea30ff42
Reviewed-on: https://go-review.googlesource.com/c/go/+/279451
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/fmt.go      |   2 +-
 src/cmd/compile/internal/ir/mknode.go   |   2 +-
 src/cmd/compile/internal/ir/node_gen.go | 114 ++++++++++++------------
 3 files changed, 59 insertions(+), 59 deletions(-)

diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 7680f05ad2..ea6b5856df 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -128,7 +128,7 @@ func (o Op) Format(s fmt.State, verb rune) {
 //	%L	Go syntax followed by " (type T)" if type is known.
 //	%+v	Debug syntax, as in Dump.
 //
-func FmtNode(n Node, s fmt.State, verb rune) {
+func fmtNode(n Node, s fmt.State, verb rune) {
 	// %+v prints Dump.
 	// Otherwise we print Go syntax.
 	if s.Flag('+') && verb == 'v' {
diff --git a/src/cmd/compile/internal/ir/mknode.go b/src/cmd/compile/internal/ir/mknode.go
index 54a228bce7..755ac6ba87 100644
--- a/src/cmd/compile/internal/ir/mknode.go
+++ b/src/cmd/compile/internal/ir/mknode.go
@@ -68,7 +68,7 @@ func main() {
 		}
 
 		fmt.Fprintf(&buf, "\n")
-		fmt.Fprintf(&buf, "func (n *%s) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }\n", name)
+		fmt.Fprintf(&buf, "func (n *%s) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }\n", name)
 
 		switch name {
 		case "Name":
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index 0dd5100018..4427d89f5c 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -4,7 +4,7 @@ package ir
 
 import "fmt"
 
-func (n *AddStringExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *AddStringExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *AddStringExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -28,7 +28,7 @@ func (n *AddStringExpr) editChildren(edit func(Node) Node) {
 	}
 }
 
-func (n *AddrExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *AddrExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *AddrExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -51,7 +51,7 @@ func (n *AddrExpr) editChildren(edit func(Node) Node) {
 	}
 }
 
-func (n *ArrayType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ArrayType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *ArrayType) copy() Node {
 	c := *n
 	return &c
@@ -67,7 +67,7 @@ func (n *ArrayType) editChildren(edit func(Node) Node) {
 	n.Elem = toNtype(maybeEdit(n.Elem, edit))
 }
 
-func (n *AssignListStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *AssignListStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *AssignListStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -88,7 +88,7 @@ func (n *AssignListStmt) editChildren(edit func(Node) Node) {
 	editList(n.Rhs, edit)
 }
 
-func (n *AssignOpStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *AssignOpStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *AssignOpStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -107,7 +107,7 @@ func (n *AssignOpStmt) editChildren(edit func(Node) Node) {
 	n.Y = maybeEdit(n.Y, edit)
 }
 
-func (n *AssignStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *AssignStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *AssignStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -126,7 +126,7 @@ func (n *AssignStmt) editChildren(edit func(Node) Node) {
 	n.Y = maybeEdit(n.Y, edit)
 }
 
-func (n *BasicLit) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *BasicLit) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *BasicLit) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -141,7 +141,7 @@ func (n *BasicLit) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 }
 
-func (n *BinaryExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *BinaryExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *BinaryExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -160,7 +160,7 @@ func (n *BinaryExpr) editChildren(edit func(Node) Node) {
 	n.Y = maybeEdit(n.Y, edit)
 }
 
-func (n *BlockStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *BlockStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *BlockStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -178,7 +178,7 @@ func (n *BlockStmt) editChildren(edit func(Node) Node) {
 	editList(n.List, edit)
 }
 
-func (n *BranchStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *BranchStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *BranchStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -193,7 +193,7 @@ func (n *BranchStmt) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 }
 
-func (n *CallExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *CallExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *CallExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -219,7 +219,7 @@ func (n *CallExpr) editChildren(edit func(Node) Node) {
 	editList(n.Body, edit)
 }
 
-func (n *CaseClause) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *CaseClause) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *CaseClause) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -246,7 +246,7 @@ func (n *CaseClause) editChildren(edit func(Node) Node) {
 	editList(n.Body, edit)
 }
 
-func (n *ChanType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ChanType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *ChanType) copy() Node {
 	c := *n
 	return &c
@@ -260,7 +260,7 @@ func (n *ChanType) editChildren(edit func(Node) Node) {
 	n.Elem = toNtype(maybeEdit(n.Elem, edit))
 }
 
-func (n *ClosureExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ClosureExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *ClosureExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -281,7 +281,7 @@ func (n *ClosureExpr) editChildren(edit func(Node) Node) {
 	}
 }
 
-func (n *ClosureReadExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ClosureReadExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *ClosureReadExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -296,7 +296,7 @@ func (n *ClosureReadExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 }
 
-func (n *CommClause) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *CommClause) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *CommClause) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -316,7 +316,7 @@ func (n *CommClause) editChildren(edit func(Node) Node) {
 	editList(n.Body, edit)
 }
 
-func (n *CompLitExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *CompLitExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *CompLitExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -342,7 +342,7 @@ func (n *CompLitExpr) editChildren(edit func(Node) Node) {
 	}
 }
 
-func (n *ConstExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ConstExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *ConstExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -357,7 +357,7 @@ func (n *ConstExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 }
 
-func (n *ConvExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ConvExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *ConvExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -374,7 +374,7 @@ func (n *ConvExpr) editChildren(edit func(Node) Node) {
 	n.X = maybeEdit(n.X, edit)
 }
 
-func (n *Decl) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *Decl) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *Decl) copy() Node {
 	c := *n
 	return &c
@@ -388,7 +388,7 @@ func (n *Decl) editChildren(edit func(Node) Node) {
 	n.X = maybeEdit(n.X, edit)
 }
 
-func (n *ForStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ForStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *ForStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -413,7 +413,7 @@ func (n *ForStmt) editChildren(edit func(Node) Node) {
 	editList(n.Body, edit)
 }
 
-func (n *Func) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *Func) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *Func) copy() Node {
 	c := *n
 	c.Body = c.Body.Copy()
@@ -428,7 +428,7 @@ func (n *Func) editChildren(edit func(Node) Node) {
 	editList(n.Body, edit)
 }
 
-func (n *FuncType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *FuncType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *FuncType) copy() Node {
 	c := *n
 	if c.Recv != nil {
@@ -451,7 +451,7 @@ func (n *FuncType) editChildren(edit func(Node) Node) {
 	editFields(n.Results, edit)
 }
 
-func (n *GoDeferStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *GoDeferStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *GoDeferStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -468,7 +468,7 @@ func (n *GoDeferStmt) editChildren(edit func(Node) Node) {
 	n.Call = maybeEdit(n.Call, edit)
 }
 
-func (n *Ident) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *Ident) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *Ident) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -483,7 +483,7 @@ func (n *Ident) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 }
 
-func (n *IfStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *IfStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *IfStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -506,7 +506,7 @@ func (n *IfStmt) editChildren(edit func(Node) Node) {
 	editList(n.Else, edit)
 }
 
-func (n *IndexExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *IndexExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *IndexExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -525,7 +525,7 @@ func (n *IndexExpr) editChildren(edit func(Node) Node) {
 	n.Index = maybeEdit(n.Index, edit)
 }
 
-func (n *InlineMarkStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *InlineMarkStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *InlineMarkStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -540,7 +540,7 @@ func (n *InlineMarkStmt) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 }
 
-func (n *InlinedCallExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *InlinedCallExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *InlinedCallExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -561,7 +561,7 @@ func (n *InlinedCallExpr) editChildren(edit func(Node) Node) {
 	editList(n.ReturnVars, edit)
 }
 
-func (n *InterfaceType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *InterfaceType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *InterfaceType) copy() Node {
 	c := *n
 	c.Methods = copyFields(c.Methods)
@@ -576,7 +576,7 @@ func (n *InterfaceType) editChildren(edit func(Node) Node) {
 	editFields(n.Methods, edit)
 }
 
-func (n *KeyExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *KeyExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *KeyExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -595,7 +595,7 @@ func (n *KeyExpr) editChildren(edit func(Node) Node) {
 	n.Value = maybeEdit(n.Value, edit)
 }
 
-func (n *LabelStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *LabelStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *LabelStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -610,7 +610,7 @@ func (n *LabelStmt) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 }
 
-func (n *LogicalExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *LogicalExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *LogicalExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -629,7 +629,7 @@ func (n *LogicalExpr) editChildren(edit func(Node) Node) {
 	n.Y = maybeEdit(n.Y, edit)
 }
 
-func (n *MakeExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *MakeExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *MakeExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -648,7 +648,7 @@ func (n *MakeExpr) editChildren(edit func(Node) Node) {
 	n.Cap = maybeEdit(n.Cap, edit)
 }
 
-func (n *MapType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *MapType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *MapType) copy() Node {
 	c := *n
 	return &c
@@ -664,7 +664,7 @@ func (n *MapType) editChildren(edit func(Node) Node) {
 	n.Elem = toNtype(maybeEdit(n.Elem, edit))
 }
 
-func (n *Name) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *Name) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *Name) copy() Node                    { panic("Name.copy") }
 func (n *Name) doChildren(do func(Node) error) error {
 	var err error
@@ -673,7 +673,7 @@ func (n *Name) doChildren(do func(Node) error) error {
 func (n *Name) editChildren(edit func(Node) Node) {
 }
 
-func (n *NameOffsetExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *NameOffsetExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *NameOffsetExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -694,7 +694,7 @@ func (n *NameOffsetExpr) editChildren(edit func(Node) Node) {
 	}
 }
 
-func (n *NilExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *NilExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *NilExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -709,7 +709,7 @@ func (n *NilExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 }
 
-func (n *ParenExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ParenExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *ParenExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -726,7 +726,7 @@ func (n *ParenExpr) editChildren(edit func(Node) Node) {
 	n.X = maybeEdit(n.X, edit)
 }
 
-func (n *PkgName) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *PkgName) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *PkgName) copy() Node {
 	c := *n
 	return &c
@@ -738,7 +738,7 @@ func (n *PkgName) doChildren(do func(Node) error) error {
 func (n *PkgName) editChildren(edit func(Node) Node) {
 }
 
-func (n *RangeStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *RangeStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *RangeStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -768,7 +768,7 @@ func (n *RangeStmt) editChildren(edit func(Node) Node) {
 	}
 }
 
-func (n *ResultExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ResultExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *ResultExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -783,7 +783,7 @@ func (n *ResultExpr) editChildren(edit func(Node) Node) {
 	editList(n.init, edit)
 }
 
-func (n *ReturnStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *ReturnStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *ReturnStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -801,7 +801,7 @@ func (n *ReturnStmt) editChildren(edit func(Node) Node) {
 	editList(n.Results, edit)
 }
 
-func (n *SelectStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *SelectStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *SelectStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -822,7 +822,7 @@ func (n *SelectStmt) editChildren(edit func(Node) Node) {
 	editList(n.Compiled, edit)
 }
 
-func (n *SelectorExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *SelectorExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *SelectorExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -845,7 +845,7 @@ func (n *SelectorExpr) editChildren(edit func(Node) Node) {
 	}
 }
 
-func (n *SendStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *SendStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *SendStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -864,7 +864,7 @@ func (n *SendStmt) editChildren(edit func(Node) Node) {
 	n.Value = maybeEdit(n.Value, edit)
 }
 
-func (n *SliceExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *SliceExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *SliceExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -887,7 +887,7 @@ func (n *SliceExpr) editChildren(edit func(Node) Node) {
 	n.Max = maybeEdit(n.Max, edit)
 }
 
-func (n *SliceHeaderExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *SliceHeaderExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *SliceHeaderExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -908,7 +908,7 @@ func (n *SliceHeaderExpr) editChildren(edit func(Node) Node) {
 	n.Cap = maybeEdit(n.Cap, edit)
 }
 
-func (n *SliceType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *SliceType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *SliceType) copy() Node {
 	c := *n
 	return &c
@@ -922,7 +922,7 @@ func (n *SliceType) editChildren(edit func(Node) Node) {
 	n.Elem = toNtype(maybeEdit(n.Elem, edit))
 }
 
-func (n *StarExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *StarExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *StarExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -939,7 +939,7 @@ func (n *StarExpr) editChildren(edit func(Node) Node) {
 	n.X = maybeEdit(n.X, edit)
 }
 
-func (n *StructKeyExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *StructKeyExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *StructKeyExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -956,7 +956,7 @@ func (n *StructKeyExpr) editChildren(edit func(Node) Node) {
 	n.Value = maybeEdit(n.Value, edit)
 }
 
-func (n *StructType) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *StructType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *StructType) copy() Node {
 	c := *n
 	c.Fields = copyFields(c.Fields)
@@ -971,7 +971,7 @@ func (n *StructType) editChildren(edit func(Node) Node) {
 	editFields(n.Fields, edit)
 }
 
-func (n *SwitchStmt) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *SwitchStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *SwitchStmt) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -994,7 +994,7 @@ func (n *SwitchStmt) editChildren(edit func(Node) Node) {
 	editList(n.Compiled, edit)
 }
 
-func (n *TypeAssertExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *TypeAssertExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *TypeAssertExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -1013,7 +1013,7 @@ func (n *TypeAssertExpr) editChildren(edit func(Node) Node) {
 	n.Ntype = toNtype(maybeEdit(n.Ntype, edit))
 }
 
-func (n *TypeSwitchGuard) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *TypeSwitchGuard) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *TypeSwitchGuard) copy() Node {
 	c := *n
 	return &c
@@ -1033,7 +1033,7 @@ func (n *TypeSwitchGuard) editChildren(edit func(Node) Node) {
 	n.X = maybeEdit(n.X, edit)
 }
 
-func (n *UnaryExpr) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *UnaryExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *UnaryExpr) copy() Node {
 	c := *n
 	c.init = c.init.Copy()
@@ -1050,7 +1050,7 @@ func (n *UnaryExpr) editChildren(edit func(Node) Node) {
 	n.X = maybeEdit(n.X, edit)
 }
 
-func (n *typeNode) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
+func (n *typeNode) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *typeNode) copy() Node {
 	c := *n
 	return &c
-- 
GitLab


From 82ab3d1448ee19ebf464297660ed1bc54aa2f3e6 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Wed, 30 Dec 2020 02:46:25 +0700
Subject: [PATCH 0384/2400] [dev.regabi] cmd/compile: use *ir.Name for Decl.X

Passes toolstash -cmp.

Change-Id: I505577d067eda3512f6d78618fc0eff061a71e3c
Reviewed-on: https://go-review.googlesource.com/c/go/+/280732
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/escape/escape.go       |  2 +-
 src/cmd/compile/internal/inline/inl.go          | 10 +++++-----
 src/cmd/compile/internal/ir/node_gen.go         |  8 ++++++--
 src/cmd/compile/internal/ir/stmt.go             |  4 ++--
 src/cmd/compile/internal/ssagen/ssa.go          |  2 +-
 src/cmd/compile/internal/typecheck/iexport.go   |  2 +-
 src/cmd/compile/internal/typecheck/typecheck.go |  4 ++--
 src/cmd/compile/internal/walk/order.go          |  2 +-
 src/cmd/compile/internal/walk/stmt.go           |  2 +-
 src/cmd/compile/internal/walk/walk.go           |  2 +-
 10 files changed, 21 insertions(+), 17 deletions(-)

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index ec99c86c06..b5b09beb5a 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -316,7 +316,7 @@ func (e *escape) stmt(n ir.Node) {
 		// Record loop depth at declaration.
 		n := n.(*ir.Decl)
 		if !ir.IsBlank(n.X) {
-			e.dcl(n.X.(*ir.Name))
+			e.dcl(n.X)
 		}
 
 	case ir.OLABEL:
diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 126871b805..7584f6a19f 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -649,7 +649,7 @@ func inlParam(t *types.Field, as ir.Node, inlvars map[*ir.Name]ir.Node) ir.Node
 	if inlvar == nil {
 		base.Fatalf("missing inlvar for %v", n)
 	}
-	as.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, inlvar))
+	as.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, inlvar.(*ir.Name)))
 	inlvar.Name().Defn = as
 	return inlvar
 }
@@ -771,14 +771,14 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 
 			if v.Byval() {
 				iv := typecheck.Expr(inlvar(v))
-				ninit.Append(ir.NewDecl(base.Pos, ir.ODCL, iv))
+				ninit.Append(ir.NewDecl(base.Pos, ir.ODCL, iv.(*ir.Name)))
 				ninit.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, iv, o)))
 				inlvars[v] = iv
 			} else {
 				addr := typecheck.NewName(typecheck.Lookup("&" + v.Sym().Name))
 				addr.SetType(types.NewPtr(v.Type()))
 				ia := typecheck.Expr(inlvar(addr))
-				ninit.Append(ir.NewDecl(base.Pos, ir.ODCL, ia))
+				ninit.Append(ir.NewDecl(base.Pos, ir.ODCL, ia.(*ir.Name)))
 				ninit.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, ia, typecheck.NodAddr(o))))
 				inlvars[addr] = ia
 
@@ -917,7 +917,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 	if !delayretvars {
 		// Zero the return parameters.
 		for _, n := range retvars {
-			ninit.Append(ir.NewDecl(base.Pos, ir.ODCL, n))
+			ninit.Append(ir.NewDecl(base.Pos, ir.ODCL, n.(*ir.Name)))
 			ras := ir.NewAssignStmt(base.Pos, n, nil)
 			ninit.Append(typecheck.Stmt(ras))
 		}
@@ -1139,7 +1139,7 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 
 			if subst.delayretvars {
 				for _, n := range as.Lhs {
-					as.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, n))
+					as.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, n.(*ir.Name)))
 					n.Name().Defn = as
 				}
 			}
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index 4427d89f5c..4c48e82d77 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -381,11 +381,15 @@ func (n *Decl) copy() Node {
 }
 func (n *Decl) doChildren(do func(Node) error) error {
 	var err error
-	err = maybeDo(n.X, err, do)
+	if n.X != nil {
+		err = maybeDo(n.X, err, do)
+	}
 	return err
 }
 func (n *Decl) editChildren(edit func(Node) Node) {
-	n.X = maybeEdit(n.X, edit)
+	if n.X != nil {
+		n.X = edit(n.X).(*Name)
+	}
 }
 
 func (n *ForStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index a1f5e5933f..4575dec260 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -13,10 +13,10 @@ import (
 // A Decl is a declaration of a const, type, or var. (A declared func is a Func.)
 type Decl struct {
 	miniNode
-	X Node // the thing being declared
+	X *Name // the thing being declared
 }
 
-func NewDecl(pos src.XPos, op Op, x Node) *Decl {
+func NewDecl(pos src.XPos, op Op, x *Name) *Decl {
 	n := &Decl{X: x}
 	n.pos = pos
 	switch op {
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 3c94ec4c95..ddf65eb209 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -1242,7 +1242,7 @@ func (s *state) stmt(n ir.Node) {
 
 	case ir.ODCL:
 		n := n.(*ir.Decl)
-		if n.X.(*ir.Name).Class_ == ir.PAUTOHEAP {
+		if n.X.Class_ == ir.PAUTOHEAP {
 			s.Fatalf("DCL %v", n)
 		}
 
diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index 489879b3b4..aa16a54bb8 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -1067,7 +1067,7 @@ func (w *exportWriter) stmt(n ir.Node) {
 		n := n.(*ir.Decl)
 		w.op(ir.ODCL)
 		w.pos(n.X.Pos())
-		w.localName(n.X.(*ir.Name))
+		w.localName(n.X)
 		w.typ(n.X.Type())
 
 	case ir.OAS:
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 335e1b53ce..480d2de8e3 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -1011,12 +1011,12 @@ func typecheck1(n ir.Node, top int) ir.Node {
 
 	case ir.ODCLCONST:
 		n := n.(*ir.Decl)
-		n.X = Expr(n.X)
+		n.X = Expr(n.X).(*ir.Name)
 		return n
 
 	case ir.ODCLTYPE:
 		n := n.(*ir.Decl)
-		n.X = typecheck(n.X, ctxType)
+		n.X = typecheck(n.X, ctxType).(*ir.Name)
 		types.CheckSize(n.X.Type())
 		return n
 	}
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index 0dd76ccee9..b3d2eaec17 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -955,7 +955,7 @@ func (o *orderState) stmt(n ir.Node) {
 						if len(init) > 0 && init[0].Op() == ir.ODCL && init[0].(*ir.Decl).X == n {
 							init = init[1:]
 						}
-						dcl := typecheck.Stmt(ir.NewDecl(base.Pos, ir.ODCL, n))
+						dcl := typecheck.Stmt(ir.NewDecl(base.Pos, ir.ODCL, n.(*ir.Name)))
 						ncas.PtrInit().Append(dcl)
 					}
 					tmp := o.newTemp(t, t.HasPointers())
diff --git a/src/cmd/compile/internal/walk/stmt.go b/src/cmd/compile/internal/walk/stmt.go
index 3fe7e103aa..f843d2c4fa 100644
--- a/src/cmd/compile/internal/walk/stmt.go
+++ b/src/cmd/compile/internal/walk/stmt.go
@@ -176,7 +176,7 @@ func walkStmtList(s []ir.Node) {
 
 // walkDecl walks an ODCL node.
 func walkDecl(n *ir.Decl) ir.Node {
-	v := n.X.(*ir.Name)
+	v := n.X
 	if v.Class_ == ir.PAUTOHEAP {
 		if base.Flag.CompilingRuntime {
 			base.Errorf("%v escapes to heap, not allowed in runtime", v)
diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index bdc9a2ea6a..b6be949689 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -167,7 +167,7 @@ func paramstoheap(params *types.Type) []ir.Node {
 		}
 
 		if stackcopy := v.Name().Stackcopy; stackcopy != nil {
-			nn = append(nn, walkStmt(ir.NewDecl(base.Pos, ir.ODCL, v)))
+			nn = append(nn, walkStmt(ir.NewDecl(base.Pos, ir.ODCL, v.(*ir.Name))))
 			if stackcopy.Class_ == ir.PPARAM {
 				nn = append(nn, walkStmt(typecheck.Stmt(ir.NewAssignStmt(base.Pos, v, stackcopy))))
 			}
-- 
GitLab


From 499851bac88dfa2a85c39a2123f092071098cada Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 29 Dec 2020 15:36:48 -0800
Subject: [PATCH 0385/2400] [dev.regabi] cmd/compile: generalize ir/mknode.go

This CL generalizes ir/mknode.go to get rid of most of almost all of
its special cases for node field types. The only remaining speciale
case now is Field, which doesn't implement Node any more, but perhaps
should.

To help with removing special cases, node fields can now be tagged
with `mknode:"-"` so that mknode ignores them when generating its
helper methods. Further, to simplify skipping all of the orig fields,
a new origNode helper type is added which declares an orig field
marked as `mknode:"-"` and also provides the Orig and SetOrig methods
needed to implement the OrigNode interface.

Passes toolstash -cmp.

Change-Id: Ic68d4f0a9d2ef6e57e9fe87cdc641e5c4859830b
Reviewed-on: https://go-review.googlesource.com/c/go/+/280674
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/ir/copy.go     |    8 +
 src/cmd/compile/internal/ir/expr.go     |   57 +-
 src/cmd/compile/internal/ir/func.go     |    4 +
 src/cmd/compile/internal/ir/mknode.go   |  256 ++---
 src/cmd/compile/internal/ir/name.go     |    4 +
 src/cmd/compile/internal/ir/node_gen.go | 1329 +++++++++++++++--------
 src/cmd/compile/internal/ir/stmt.go     |    7 +-
 src/cmd/compile/internal/ir/type.go     |   62 +-
 src/cmd/compile/internal/ir/visit.go    |   22 +-
 9 files changed, 1057 insertions(+), 692 deletions(-)

diff --git a/src/cmd/compile/internal/ir/copy.go b/src/cmd/compile/internal/ir/copy.go
index 0ab355f767..7da9b24940 100644
--- a/src/cmd/compile/internal/ir/copy.go
+++ b/src/cmd/compile/internal/ir/copy.go
@@ -25,6 +25,14 @@ type OrigNode interface {
 	SetOrig(Node)
 }
 
+// origNode may be embedded into a Node to make it implement OrigNode.
+type origNode struct {
+	orig Node `mknode:"-"`
+}
+
+func (n *origNode) Orig() Node     { return n.orig }
+func (n *origNode) SetOrig(o Node) { n.orig = o }
+
 // Orig returns the “original” node for n.
 // If n implements OrigNode, Orig returns n.Orig().
 // Otherwise Orig returns n itself.
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index a989ce5e01..55e4b61baf 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -14,27 +14,6 @@ import (
 	"go/token"
 )
 
-func maybeDo(x Node, err error, do func(Node) error) error {
-	if x != nil && err == nil {
-		err = do(x)
-	}
-	return err
-}
-
-func maybeDoList(x Nodes, err error, do func(Node) error) error {
-	if err == nil {
-		err = DoList(x, do)
-	}
-	return err
-}
-
-func maybeEdit(x Node, edit func(Node) Node) Node {
-	if x == nil {
-		return x
-	}
-	return edit(x)
-}
-
 // An Expr is a Node that can appear as an expression.
 type Expr interface {
 	Node
@@ -77,16 +56,6 @@ func (n *miniExpr) Init() Nodes           { return n.init }
 func (n *miniExpr) PtrInit() *Nodes       { return &n.init }
 func (n *miniExpr) SetInit(x Nodes)       { n.init = x }
 
-func toNtype(x Node) Ntype {
-	if x == nil {
-		return nil
-	}
-	if _, ok := x.(Ntype); !ok {
-		Dump("not Ntype", x)
-	}
-	return x.(Ntype)
-}
-
 // An AddStringExpr is a string concatenation Expr[0] + Exprs[1] + ... + Expr[len(Expr)-1].
 type AddStringExpr struct {
 	miniExpr
@@ -189,7 +158,7 @@ const (
 // A CallExpr is a function call X(Args).
 type CallExpr struct {
 	miniExpr
-	orig     Node
+	origNode
 	X        Node
 	Args     Nodes
 	Rargs    Nodes // TODO(rsc): Delete.
@@ -210,9 +179,6 @@ func NewCallExpr(pos src.XPos, op Op, fun Node, args []Node) *CallExpr {
 
 func (*CallExpr) isStmt() {}
 
-func (n *CallExpr) Orig() Node     { return n.orig }
-func (n *CallExpr) SetOrig(x Node) { n.orig = x }
-
 func (n *CallExpr) SetOp(op Op) {
 	switch op {
 	default:
@@ -226,7 +192,7 @@ func (n *CallExpr) SetOp(op Op) {
 // A ClosureExpr is a function literal expression.
 type ClosureExpr struct {
 	miniExpr
-	Func     *Func
+	Func     *Func `mknode:"-"`
 	Prealloc *Name
 }
 
@@ -254,7 +220,7 @@ func NewClosureRead(typ *types.Type, offset int64) *ClosureReadExpr {
 // Before type-checking, the type is Ntype.
 type CompLitExpr struct {
 	miniExpr
-	orig     Node
+	origNode
 	Ntype    Ntype
 	List     Nodes // initialized values
 	Prealloc *Name
@@ -270,8 +236,6 @@ func NewCompLitExpr(pos src.XPos, op Op, typ Ntype, list []Node) *CompLitExpr {
 	return n
 }
 
-func (n *CompLitExpr) Orig() Node         { return n.orig }
-func (n *CompLitExpr) SetOrig(x Node)     { n.orig = x }
 func (n *CompLitExpr) Implicit() bool     { return n.flags&miniExprImplicit != 0 }
 func (n *CompLitExpr) SetImplicit(b bool) { n.flags.set(miniExprImplicit, b) }
 
@@ -286,14 +250,15 @@ func (n *CompLitExpr) SetOp(op Op) {
 
 type ConstExpr struct {
 	miniExpr
-	val  constant.Value
-	orig Node
+	origNode
+	val constant.Value
 }
 
 func NewConstExpr(val constant.Value, orig Node) Node {
-	n := &ConstExpr{orig: orig, val: val}
+	n := &ConstExpr{val: val}
 	n.op = OLITERAL
 	n.pos = orig.Pos()
+	n.orig = orig
 	n.SetType(orig.Type())
 	n.SetTypecheck(orig.Typecheck())
 	n.SetDiag(orig.Diag())
@@ -301,8 +266,6 @@ func NewConstExpr(val constant.Value, orig Node) Node {
 }
 
 func (n *ConstExpr) Sym() *types.Sym     { return n.orig.Sym() }
-func (n *ConstExpr) Orig() Node          { return n.orig }
-func (n *ConstExpr) SetOrig(orig Node)   { panic(n.no("SetOrig")) }
 func (n *ConstExpr) Val() constant.Value { return n.val }
 
 // A ConvExpr is a conversion Type(X).
@@ -664,9 +627,9 @@ type TypeAssertExpr struct {
 
 	// Runtime type information provided by walkDotType.
 	// Caution: These aren't always populated; see walkDotType.
-	SrcType *AddrExpr // *runtime._type for X's type
-	DstType *AddrExpr // *runtime._type for Type
-	Itab    *AddrExpr // *runtime.itab for Type implementing X's type
+	SrcType *AddrExpr `mknode:"-"` // *runtime._type for X's type
+	DstType *AddrExpr `mknode:"-"` // *runtime._type for Type
+	Itab    *AddrExpr `mknode:"-"` // *runtime.itab for Type implementing X's type
 }
 
 func NewTypeAssertExpr(pos src.XPos, x Node, typ Ntype) *TypeAssertExpr {
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index bffd4dd5ef..32ad37fa80 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -115,6 +115,10 @@ func NewFunc(pos src.XPos) *Func {
 
 func (f *Func) isStmt() {}
 
+func (n *Func) copy() Node                           { panic(n.no("copy")) }
+func (n *Func) doChildren(do func(Node) error) error { return doNodes(n.Body, do) }
+func (n *Func) editChildren(edit func(Node) Node)    { editNodes(n.Body, edit) }
+
 func (f *Func) Type() *types.Type  { return f.Nname.Type() }
 func (f *Func) Sym() *types.Sym    { return f.Nname.Sym() }
 func (f *Func) Linksym() *obj.LSym { return f.Nname.Linksym() }
diff --git a/src/cmd/compile/internal/ir/mknode.go b/src/cmd/compile/internal/ir/mknode.go
index 755ac6ba87..4e26bc5011 100644
--- a/src/cmd/compile/internal/ir/mknode.go
+++ b/src/cmd/compile/internal/ir/mknode.go
@@ -13,11 +13,16 @@ import (
 	"go/types"
 	"io/ioutil"
 	"log"
+	"reflect"
+	"sort"
 	"strings"
 
 	"golang.org/x/tools/go/packages"
 )
 
+var irPkg *types.Package
+var buf bytes.Buffer
+
 func main() {
 	cfg := &packages.Config{
 		Mode: packages.NeedSyntax | packages.NeedTypes,
@@ -26,44 +31,26 @@ func main() {
 	if err != nil {
 		log.Fatal(err)
 	}
+	irPkg = pkgs[0].Types
 
-	pkg := pkgs[0].Types
-	scope := pkg.Scope()
-
-	lookup := func(name string) *types.Named {
-		return scope.Lookup(name).(*types.TypeName).Type().(*types.Named)
-	}
-
-	nodeType := lookup("Node")
-	ptrNameType := types.NewPointer(lookup("Name"))
-	ntypeType := lookup("Ntype")
-	nodesType := lookup("Nodes")
-	slicePtrCaseClauseType := types.NewSlice(types.NewPointer(lookup("CaseClause")))
-	slicePtrCommClauseType := types.NewSlice(types.NewPointer(lookup("CommClause")))
-	ptrFieldType := types.NewPointer(lookup("Field"))
-	slicePtrFieldType := types.NewSlice(ptrFieldType)
-	ptrIdentType := types.NewPointer(lookup("Ident"))
-
-	var buf bytes.Buffer
 	fmt.Fprintln(&buf, "// Code generated by mknode.go. DO NOT EDIT.")
 	fmt.Fprintln(&buf)
 	fmt.Fprintln(&buf, "package ir")
 	fmt.Fprintln(&buf)
 	fmt.Fprintln(&buf, `import "fmt"`)
 
+	scope := irPkg.Scope()
 	for _, name := range scope.Names() {
-		obj, ok := scope.Lookup(name).(*types.TypeName)
-		if !ok {
+		if strings.HasPrefix(name, "mini") {
 			continue
 		}
 
-		typName := obj.Name()
-		typ, ok := obj.Type().(*types.Named).Underlying().(*types.Struct)
+		obj, ok := scope.Lookup(name).(*types.TypeName)
 		if !ok {
 			continue
 		}
-
-		if strings.HasPrefix(typName, "mini") || !hasMiniNode(typ) {
+		typ := obj.Type().(*types.Named)
+		if !implementsNode(types.NewPointer(typ)) {
 			continue
 		}
 
@@ -71,77 +58,31 @@ func main() {
 		fmt.Fprintf(&buf, "func (n *%s) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }\n", name)
 
 		switch name {
-		case "Name":
-			fmt.Fprintf(&buf, "func (n *%s) copy() Node {panic(\"%s.copy\")}\n", name, name)
-		default:
-			fmt.Fprintf(&buf, "func (n *%s) copy() Node { c := *n\n", name)
-			forNodeFields(typName, typ, func(name string, is func(types.Type) bool) {
-				switch {
-				case is(nodesType):
-					fmt.Fprintf(&buf, "c.%s = c.%s.Copy()\n", name, name)
-				case is(slicePtrCaseClauseType):
-					fmt.Fprintf(&buf, "c.%s = copyCases(c.%s)\n", name, name)
-				case is(slicePtrCommClauseType):
-					fmt.Fprintf(&buf, "c.%s = copyComms(c.%s)\n", name, name)
-				case is(ptrFieldType):
-					fmt.Fprintf(&buf, "if c.%s != nil { c.%s = c.%s.copy() }\n", name, name, name)
-				case is(slicePtrFieldType):
-					fmt.Fprintf(&buf, "c.%s = copyFields(c.%s)\n", name, name)
-				}
-			})
-			fmt.Fprintf(&buf, "return &c }\n")
+		case "Name", "Func":
+			// Too specialized to automate.
+			continue
 		}
 
-		fmt.Fprintf(&buf, "func (n *%s) doChildren(do func(Node) error) error { var err error\n", name)
-		forNodeFields(typName, typ, func(name string, is func(types.Type) bool) {
-			switch {
-			case is(ptrIdentType), is(ptrNameType):
-				fmt.Fprintf(&buf, "if n.%s != nil { err = maybeDo(n.%s, err, do) }\n", name, name)
-			case is(nodeType), is(ntypeType):
-				fmt.Fprintf(&buf, "err = maybeDo(n.%s, err, do)\n", name)
-			case is(nodesType):
-				fmt.Fprintf(&buf, "err = maybeDoList(n.%s, err, do)\n", name)
-			case is(slicePtrCaseClauseType):
-				fmt.Fprintf(&buf, "err = maybeDoCases(n.%s, err, do)\n", name)
-			case is(slicePtrCommClauseType):
-				fmt.Fprintf(&buf, "err = maybeDoComms(n.%s, err, do)\n", name)
-			case is(ptrFieldType):
-				fmt.Fprintf(&buf, "err = maybeDoField(n.%s, err, do)\n", name)
-			case is(slicePtrFieldType):
-				fmt.Fprintf(&buf, "err = maybeDoFields(n.%s, err, do)\n", name)
-			}
-		})
-		fmt.Fprintf(&buf, "return err }\n")
-
-		fmt.Fprintf(&buf, "func (n *%s) editChildren(edit func(Node) Node) {\n", name)
-		forNodeFields(typName, typ, func(name string, is func(types.Type) bool) {
-			switch {
-			case is(ptrIdentType):
-				fmt.Fprintf(&buf, "if n.%s != nil { n.%s = edit(n.%s).(*Ident) }\n", name, name, name)
-			case is(ptrNameType):
-				fmt.Fprintf(&buf, "if n.%s != nil { n.%s = edit(n.%s).(*Name) }\n", name, name, name)
-			case is(nodeType):
-				fmt.Fprintf(&buf, "n.%s = maybeEdit(n.%s, edit)\n", name, name)
-			case is(ntypeType):
-				fmt.Fprintf(&buf, "n.%s = toNtype(maybeEdit(n.%s, edit))\n", name, name)
-			case is(nodesType):
-				fmt.Fprintf(&buf, "editList(n.%s, edit)\n", name)
-			case is(slicePtrCaseClauseType):
-				fmt.Fprintf(&buf, "editCases(n.%s, edit)\n", name)
-			case is(slicePtrCommClauseType):
-				fmt.Fprintf(&buf, "editComms(n.%s, edit)\n", name)
-			case is(ptrFieldType):
-				fmt.Fprintf(&buf, "editField(n.%s, edit)\n", name)
-			case is(slicePtrFieldType):
-				fmt.Fprintf(&buf, "editFields(n.%s, edit)\n", name)
-			}
-		})
-		fmt.Fprintf(&buf, "}\n")
+		forNodeFields(typ,
+			"func (n *%[1]s) copy() Node { c := *n\n",
+			"",
+			"c.%[1]s = copy%[2]s(c.%[1]s)",
+			"return &c }\n")
+
+		forNodeFields(typ,
+			"func (n *%[1]s) doChildren(do func(Node) error) error {\n",
+			"if n.%[1]s != nil { if err := do(n.%[1]s); err != nil { return err } }",
+			"if err := do%[2]s(n.%[1]s, do); err != nil { return err }",
+			"return nil }\n")
+
+		forNodeFields(typ,
+			"func (n *%[1]s) editChildren(edit func(Node) Node) {\n",
+			"if n.%[1]s != nil { n.%[1]s = edit(n.%[1]s).(%[2]s) }",
+			"edit%[2]s(n.%[1]s, edit)",
+			"}\n")
 	}
 
-	for _, name := range []string{"CaseClause", "CommClause"} {
-		sliceHelper(&buf, name)
-	}
+	makeHelpers()
 
 	out, err := format.Source(buf.Bytes())
 	if err != nil {
@@ -155,20 +96,32 @@ func main() {
 	}
 }
 
-func sliceHelper(buf *bytes.Buffer, name string) {
-	tmpl := fmt.Sprintf(`
-func copy%[1]ss(list []*%[2]s) []*%[2]s {
+// needHelper maps needed slice helpers from their base name to their
+// respective slice-element type.
+var needHelper = map[string]string{}
+
+func makeHelpers() {
+	var names []string
+	for name := range needHelper {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+
+	for _, name := range names {
+		fmt.Fprintf(&buf, sliceHelperTmpl, name, needHelper[name])
+	}
+}
+
+const sliceHelperTmpl = `
+func copy%[1]s(list []%[2]s) []%[2]s {
 	if list == nil {
 		return nil
 	}
-	c := make([]*%[2]s, len(list))
+	c := make([]%[2]s, len(list))
 	copy(c, list)
 	return c
 }
-func maybeDo%[1]ss(list []*%[2]s, err error, do func(Node) error) error {
-	if err != nil {
-		return err
-	}
+func do%[1]s(list []%[2]s, do func(Node) error) error {
 	for _, x := range list {
 		if x != nil {
 			if err := do(x); err != nil {
@@ -178,51 +131,98 @@ func maybeDo%[1]ss(list []*%[2]s, err error, do func(Node) error) error {
 	}
 	return nil
 }
-func edit%[1]ss(list []*%[2]s, edit func(Node) Node) {
+func edit%[1]s(list []%[2]s, edit func(Node) Node) {
 	for i, x := range list {
 		if x != nil {
-			list[i] = edit(x).(*%[2]s)
+			list[i] = edit(x).(%[2]s)
 		}
 	}
 }
-`, strings.TrimSuffix(name, "Clause"), name)
-	fmt.Fprintln(buf, tmpl)
-}
+`
 
-func forNodeFields(typName string, typ *types.Struct, f func(name string, is func(types.Type) bool)) {
-	for i, n := 0, typ.NumFields(); i < n; i++ {
-		v := typ.Field(i)
-		if v.Embedded() {
-			if typ, ok := v.Type().Underlying().(*types.Struct); ok {
-				forNodeFields(typName, typ, f)
-				continue
-			}
+func forNodeFields(named *types.Named, prologue, singleTmpl, sliceTmpl, epilogue string) {
+	fmt.Fprintf(&buf, prologue, named.Obj().Name())
+
+	anyField(named.Underlying().(*types.Struct), func(f *types.Var) bool {
+		if f.Embedded() {
+			return false
+		}
+		name, typ := f.Name(), f.Type()
+
+		slice, _ := typ.Underlying().(*types.Slice)
+		if slice != nil {
+			typ = slice.Elem()
 		}
-		switch typName {
-		case "Func":
-			if strings.ToLower(strings.TrimSuffix(v.Name(), "_")) != "body" {
-				continue
+
+		tmpl, what := singleTmpl, types.TypeString(typ, types.RelativeTo(irPkg))
+		if implementsNode(typ) {
+			if slice != nil {
+				helper := strings.TrimPrefix(what, "*") + "s"
+				needHelper[helper] = what
+				tmpl, what = sliceTmpl, helper
 			}
-		case "Name":
-			continue
+		} else if what == "*Field" {
+			// Special case for *Field.
+			tmpl = sliceTmpl
+			if slice != nil {
+				what = "Fields"
+			} else {
+				what = "Field"
+			}
+		} else {
+			return false
 		}
-		switch v.Name() {
-		case "orig":
-			continue
+
+		if tmpl == "" {
+			return false
+		}
+
+		// Allow template to not use all arguments without
+		// upsetting fmt.Printf.
+		s := fmt.Sprintf(tmpl+"\x00 %[1]s %[2]s", name, what)
+		fmt.Fprintln(&buf, s[:strings.LastIndex(s, "\x00")])
+		return false
+	})
+
+	fmt.Fprintf(&buf, epilogue)
+}
+
+func implementsNode(typ types.Type) bool {
+	if _, ok := typ.Underlying().(*types.Interface); ok {
+		// TODO(mdempsky): Check the interface implements Node.
+		// Worst case, node_gen.go will fail to compile if we're wrong.
+		return true
+	}
+
+	if ptr, ok := typ.(*types.Pointer); ok {
+		if str, ok := ptr.Elem().Underlying().(*types.Struct); ok {
+			return anyField(str, func(f *types.Var) bool {
+				return f.Embedded() && f.Name() == "miniNode"
+			})
 		}
-		f(v.Name(), func(t types.Type) bool { return types.Identical(t, v.Type()) })
 	}
+
+	return false
 }
 
-func hasMiniNode(typ *types.Struct) bool {
+func anyField(typ *types.Struct, pred func(f *types.Var) bool) bool {
 	for i, n := 0, typ.NumFields(); i < n; i++ {
-		v := typ.Field(i)
-		if v.Name() == "miniNode" {
+		if value, ok := reflect.StructTag(typ.Tag(i)).Lookup("mknode"); ok {
+			if value != "-" {
+				panic(fmt.Sprintf("unexpected tag value: %q", value))
+			}
+			continue
+		}
+
+		f := typ.Field(i)
+		if pred(f) {
 			return true
 		}
-		if v.Embedded() {
-			if typ, ok := v.Type().Underlying().(*types.Struct); ok && hasMiniNode(typ) {
-				return true
+		if f.Embedded() {
+			if typ, ok := f.Type().Underlying().(*types.Struct); ok {
+				if anyField(typ, pred) {
+					return true
+				}
 			}
 		}
 	}
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index d6135ee29a..b12e833f73 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -143,6 +143,10 @@ type Name struct {
 
 func (n *Name) isExpr() {}
 
+func (n *Name) copy() Node                           { panic(n.no("copy")) }
+func (n *Name) doChildren(do func(Node) error) error { return nil }
+func (n *Name) editChildren(edit func(Node) Node)    {}
+
 // CloneName makes a cloned copy of the name.
 // It's not ir.Copy(n) because in general that operation is a mistake on names,
 // which uniquely identify variables.
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index 4c48e82d77..21e4eff9fb 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -7,22 +7,27 @@ import "fmt"
 func (n *AddStringExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *AddStringExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
-	c.List = c.List.Copy()
+	c.init = copyNodes(c.init)
+	c.List = copyNodes(c.List)
 	return &c
 }
 func (n *AddStringExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDoList(n.List, err, do)
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if err := doNodes(n.List, do); err != nil {
+		return err
+	}
 	if n.Prealloc != nil {
-		err = maybeDo(n.Prealloc, err, do)
+		if err := do(n.Prealloc); err != nil {
+			return err
+		}
 	}
-	return err
+	return nil
 }
 func (n *AddStringExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	editList(n.List, edit)
+	editNodes(n.init, edit)
+	editNodes(n.List, edit)
 	if n.Prealloc != nil {
 		n.Prealloc = edit(n.Prealloc).(*Name)
 	}
@@ -31,21 +36,30 @@ func (n *AddStringExpr) editChildren(edit func(Node) Node) {
 func (n *AddrExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *AddrExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *AddrExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.X != nil {
+		if err := do(n.X); err != nil {
+			return err
+		}
+	}
 	if n.Prealloc != nil {
-		err = maybeDo(n.Prealloc, err, do)
+		if err := do(n.Prealloc); err != nil {
+			return err
+		}
 	}
-	return err
+	return nil
 }
 func (n *AddrExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
+	editNodes(n.init, edit)
+	if n.X != nil {
+		n.X = edit(n.X).(Node)
+	}
 	if n.Prealloc != nil {
 		n.Prealloc = edit(n.Prealloc).(*Name)
 	}
@@ -57,193 +71,273 @@ func (n *ArrayType) copy() Node {
 	return &c
 }
 func (n *ArrayType) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDo(n.Len, err, do)
-	err = maybeDo(n.Elem, err, do)
-	return err
+	if n.Len != nil {
+		if err := do(n.Len); err != nil {
+			return err
+		}
+	}
+	if n.Elem != nil {
+		if err := do(n.Elem); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 func (n *ArrayType) editChildren(edit func(Node) Node) {
-	n.Len = maybeEdit(n.Len, edit)
-	n.Elem = toNtype(maybeEdit(n.Elem, edit))
+	if n.Len != nil {
+		n.Len = edit(n.Len).(Node)
+	}
+	if n.Elem != nil {
+		n.Elem = edit(n.Elem).(Ntype)
+	}
 }
 
 func (n *AssignListStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *AssignListStmt) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
-	c.Lhs = c.Lhs.Copy()
-	c.Rhs = c.Rhs.Copy()
+	c.init = copyNodes(c.init)
+	c.Lhs = copyNodes(c.Lhs)
+	c.Rhs = copyNodes(c.Rhs)
 	return &c
 }
 func (n *AssignListStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDoList(n.Lhs, err, do)
-	err = maybeDoList(n.Rhs, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if err := doNodes(n.Lhs, do); err != nil {
+		return err
+	}
+	if err := doNodes(n.Rhs, do); err != nil {
+		return err
+	}
+	return nil
 }
 func (n *AssignListStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	editList(n.Lhs, edit)
-	editList(n.Rhs, edit)
+	editNodes(n.init, edit)
+	editNodes(n.Lhs, edit)
+	editNodes(n.Rhs, edit)
 }
 
 func (n *AssignOpStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *AssignOpStmt) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *AssignOpStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	err = maybeDo(n.Y, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.X != nil {
+		if err := do(n.X); err != nil {
+			return err
+		}
+	}
+	if n.Y != nil {
+		if err := do(n.Y); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 func (n *AssignOpStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-	n.Y = maybeEdit(n.Y, edit)
+	editNodes(n.init, edit)
+	if n.X != nil {
+		n.X = edit(n.X).(Node)
+	}
+	if n.Y != nil {
+		n.Y = edit(n.Y).(Node)
+	}
 }
 
 func (n *AssignStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *AssignStmt) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *AssignStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	err = maybeDo(n.Y, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.X != nil {
+		if err := do(n.X); err != nil {
+			return err
+		}
+	}
+	if n.Y != nil {
+		if err := do(n.Y); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 func (n *AssignStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-	n.Y = maybeEdit(n.Y, edit)
+	editNodes(n.init, edit)
+	if n.X != nil {
+		n.X = edit(n.X).(Node)
+	}
+	if n.Y != nil {
+		n.Y = edit(n.Y).(Node)
+	}
 }
 
 func (n *BasicLit) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *BasicLit) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *BasicLit) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	return nil
 }
 func (n *BasicLit) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
+	editNodes(n.init, edit)
 }
 
 func (n *BinaryExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *BinaryExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *BinaryExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	err = maybeDo(n.Y, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.X != nil {
+		if err := do(n.X); err != nil {
+			return err
+		}
+	}
+	if n.Y != nil {
+		if err := do(n.Y); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 func (n *BinaryExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-	n.Y = maybeEdit(n.Y, edit)
+	editNodes(n.init, edit)
+	if n.X != nil {
+		n.X = edit(n.X).(Node)
+	}
+	if n.Y != nil {
+		n.Y = edit(n.Y).(Node)
+	}
 }
 
 func (n *BlockStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *BlockStmt) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
-	c.List = c.List.Copy()
+	c.init = copyNodes(c.init)
+	c.List = copyNodes(c.List)
 	return &c
 }
 func (n *BlockStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDoList(n.List, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if err := doNodes(n.List, do); err != nil {
+		return err
+	}
+	return nil
 }
 func (n *BlockStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	editList(n.List, edit)
+	editNodes(n.init, edit)
+	editNodes(n.List, edit)
 }
 
 func (n *BranchStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *BranchStmt) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *BranchStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	return nil
 }
 func (n *BranchStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
+	editNodes(n.init, edit)
 }
 
 func (n *CallExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *CallExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
-	c.Args = c.Args.Copy()
-	c.Rargs = c.Rargs.Copy()
-	c.Body = c.Body.Copy()
+	c.init = copyNodes(c.init)
+	c.Args = copyNodes(c.Args)
+	c.Rargs = copyNodes(c.Rargs)
+	c.Body = copyNodes(c.Body)
 	return &c
 }
 func (n *CallExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	err = maybeDoList(n.Args, err, do)
-	err = maybeDoList(n.Rargs, err, do)
-	err = maybeDoList(n.Body, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.X != nil {
+		if err := do(n.X); err != nil {
+			return err
+		}
+	}
+	if err := doNodes(n.Args, do); err != nil {
+		return err
+	}
+	if err := doNodes(n.Rargs, do); err != nil {
+		return err
+	}
+	if err := doNodes(n.Body, do); err != nil {
+		return err
+	}
+	return nil
 }
 func (n *CallExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-	editList(n.Args, edit)
-	editList(n.Rargs, edit)
-	editList(n.Body, edit)
+	editNodes(n.init, edit)
+	if n.X != nil {
+		n.X = edit(n.X).(Node)
+	}
+	editNodes(n.Args, edit)
+	editNodes(n.Rargs, edit)
+	editNodes(n.Body, edit)
 }
 
 func (n *CaseClause) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *CaseClause) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
-	c.List = c.List.Copy()
-	c.Body = c.Body.Copy()
+	c.init = copyNodes(c.init)
+	c.List = copyNodes(c.List)
+	c.Body = copyNodes(c.Body)
 	return &c
 }
 func (n *CaseClause) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
 	if n.Var != nil {
-		err = maybeDo(n.Var, err, do)
+		if err := do(n.Var); err != nil {
+			return err
+		}
+	}
+	if err := doNodes(n.List, do); err != nil {
+		return err
+	}
+	if err := doNodes(n.Body, do); err != nil {
+		return err
 	}
-	err = maybeDoList(n.List, err, do)
-	err = maybeDoList(n.Body, err, do)
-	return err
+	return nil
 }
 func (n *CaseClause) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
+	editNodes(n.init, edit)
 	if n.Var != nil {
 		n.Var = edit(n.Var).(*Name)
 	}
-	editList(n.List, edit)
-	editList(n.Body, edit)
+	editNodes(n.List, edit)
+	editNodes(n.Body, edit)
 }
 
 func (n *ChanType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
@@ -252,30 +346,38 @@ func (n *ChanType) copy() Node {
 	return &c
 }
 func (n *ChanType) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDo(n.Elem, err, do)
-	return err
+	if n.Elem != nil {
+		if err := do(n.Elem); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 func (n *ChanType) editChildren(edit func(Node) Node) {
-	n.Elem = toNtype(maybeEdit(n.Elem, edit))
+	if n.Elem != nil {
+		n.Elem = edit(n.Elem).(Ntype)
+	}
 }
 
 func (n *ClosureExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *ClosureExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *ClosureExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
 	if n.Prealloc != nil {
-		err = maybeDo(n.Prealloc, err, do)
+		if err := do(n.Prealloc); err != nil {
+			return err
+		}
 	}
-	return err
+	return nil
 }
 func (n *ClosureExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
+	editNodes(n.init, edit)
 	if n.Prealloc != nil {
 		n.Prealloc = edit(n.Prealloc).(*Name)
 	}
@@ -284,59 +386,80 @@ func (n *ClosureExpr) editChildren(edit func(Node) Node) {
 func (n *ClosureReadExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *ClosureReadExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *ClosureReadExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	return nil
 }
 func (n *ClosureReadExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
+	editNodes(n.init, edit)
 }
 
 func (n *CommClause) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *CommClause) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
-	c.Body = c.Body.Copy()
+	c.init = copyNodes(c.init)
+	c.Body = copyNodes(c.Body)
 	return &c
 }
 func (n *CommClause) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.Comm, err, do)
-	err = maybeDoList(n.Body, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.Comm != nil {
+		if err := do(n.Comm); err != nil {
+			return err
+		}
+	}
+	if err := doNodes(n.Body, do); err != nil {
+		return err
+	}
+	return nil
 }
 func (n *CommClause) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.Comm = maybeEdit(n.Comm, edit)
-	editList(n.Body, edit)
+	editNodes(n.init, edit)
+	if n.Comm != nil {
+		n.Comm = edit(n.Comm).(Node)
+	}
+	editNodes(n.Body, edit)
 }
 
 func (n *CompLitExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *CompLitExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
-	c.List = c.List.Copy()
+	c.init = copyNodes(c.init)
+	c.List = copyNodes(c.List)
 	return &c
 }
 func (n *CompLitExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.Ntype, err, do)
-	err = maybeDoList(n.List, err, do)
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.Ntype != nil {
+		if err := do(n.Ntype); err != nil {
+			return err
+		}
+	}
+	if err := doNodes(n.List, do); err != nil {
+		return err
+	}
 	if n.Prealloc != nil {
-		err = maybeDo(n.Prealloc, err, do)
+		if err := do(n.Prealloc); err != nil {
+			return err
+		}
 	}
-	return err
+	return nil
 }
 func (n *CompLitExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.Ntype = toNtype(maybeEdit(n.Ntype, edit))
-	editList(n.List, edit)
+	editNodes(n.init, edit)
+	if n.Ntype != nil {
+		n.Ntype = edit(n.Ntype).(Ntype)
+	}
+	editNodes(n.List, edit)
 	if n.Prealloc != nil {
 		n.Prealloc = edit(n.Prealloc).(*Name)
 	}
@@ -345,33 +468,41 @@ func (n *CompLitExpr) editChildren(edit func(Node) Node) {
 func (n *ConstExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *ConstExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *ConstExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	return nil
 }
 func (n *ConstExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
+	editNodes(n.init, edit)
 }
 
 func (n *ConvExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *ConvExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *ConvExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.X != nil {
+		if err := do(n.X); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 func (n *ConvExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
+	editNodes(n.init, edit)
+	if n.X != nil {
+		n.X = edit(n.X).(Node)
+	}
 }
 
 func (n *Decl) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
@@ -380,11 +511,12 @@ func (n *Decl) copy() Node {
 	return &c
 }
 func (n *Decl) doChildren(do func(Node) error) error {
-	var err error
 	if n.X != nil {
-		err = maybeDo(n.X, err, do)
+		if err := do(n.X); err != nil {
+			return err
+		}
 	}
-	return err
+	return nil
 }
 func (n *Decl) editChildren(edit func(Node) Node) {
 	if n.X != nil {
@@ -395,59 +527,66 @@ func (n *Decl) editChildren(edit func(Node) Node) {
 func (n *ForStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *ForStmt) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
-	c.Late = c.Late.Copy()
-	c.Body = c.Body.Copy()
+	c.init = copyNodes(c.init)
+	c.Late = copyNodes(c.Late)
+	c.Body = copyNodes(c.Body)
 	return &c
 }
 func (n *ForStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.Cond, err, do)
-	err = maybeDoList(n.Late, err, do)
-	err = maybeDo(n.Post, err, do)
-	err = maybeDoList(n.Body, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.Cond != nil {
+		if err := do(n.Cond); err != nil {
+			return err
+		}
+	}
+	if err := doNodes(n.Late, do); err != nil {
+		return err
+	}
+	if n.Post != nil {
+		if err := do(n.Post); err != nil {
+			return err
+		}
+	}
+	if err := doNodes(n.Body, do); err != nil {
+		return err
+	}
+	return nil
 }
 func (n *ForStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.Cond = maybeEdit(n.Cond, edit)
-	editList(n.Late, edit)
-	n.Post = maybeEdit(n.Post, edit)
-	editList(n.Body, edit)
+	editNodes(n.init, edit)
+	if n.Cond != nil {
+		n.Cond = edit(n.Cond).(Node)
+	}
+	editNodes(n.Late, edit)
+	if n.Post != nil {
+		n.Post = edit(n.Post).(Node)
+	}
+	editNodes(n.Body, edit)
 }
 
 func (n *Func) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
-func (n *Func) copy() Node {
-	c := *n
-	c.Body = c.Body.Copy()
-	return &c
-}
-func (n *Func) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.Body, err, do)
-	return err
-}
-func (n *Func) editChildren(edit func(Node) Node) {
-	editList(n.Body, edit)
-}
 
 func (n *FuncType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *FuncType) copy() Node {
 	c := *n
-	if c.Recv != nil {
-		c.Recv = c.Recv.copy()
-	}
+	c.Recv = copyField(c.Recv)
 	c.Params = copyFields(c.Params)
 	c.Results = copyFields(c.Results)
 	return &c
 }
 func (n *FuncType) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoField(n.Recv, err, do)
-	err = maybeDoFields(n.Params, err, do)
-	err = maybeDoFields(n.Results, err, do)
-	return err
+	if err := doField(n.Recv, do); err != nil {
+		return err
+	}
+	if err := doFields(n.Params, do); err != nil {
+		return err
+	}
+	if err := doFields(n.Results, do); err != nil {
+		return err
+	}
+	return nil
 }
 func (n *FuncType) editChildren(edit func(Node) Node) {
 	editField(n.Recv, edit)
@@ -458,111 +597,149 @@ func (n *FuncType) editChildren(edit func(Node) Node) {
 func (n *GoDeferStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *GoDeferStmt) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *GoDeferStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.Call, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.Call != nil {
+		if err := do(n.Call); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 func (n *GoDeferStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.Call = maybeEdit(n.Call, edit)
+	editNodes(n.init, edit)
+	if n.Call != nil {
+		n.Call = edit(n.Call).(Node)
+	}
 }
 
 func (n *Ident) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *Ident) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *Ident) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	return nil
 }
 func (n *Ident) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
+	editNodes(n.init, edit)
 }
 
 func (n *IfStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *IfStmt) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
-	c.Body = c.Body.Copy()
-	c.Else = c.Else.Copy()
+	c.init = copyNodes(c.init)
+	c.Body = copyNodes(c.Body)
+	c.Else = copyNodes(c.Else)
 	return &c
 }
 func (n *IfStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.Cond, err, do)
-	err = maybeDoList(n.Body, err, do)
-	err = maybeDoList(n.Else, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.Cond != nil {
+		if err := do(n.Cond); err != nil {
+			return err
+		}
+	}
+	if err := doNodes(n.Body, do); err != nil {
+		return err
+	}
+	if err := doNodes(n.Else, do); err != nil {
+		return err
+	}
+	return nil
 }
 func (n *IfStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.Cond = maybeEdit(n.Cond, edit)
-	editList(n.Body, edit)
-	editList(n.Else, edit)
+	editNodes(n.init, edit)
+	if n.Cond != nil {
+		n.Cond = edit(n.Cond).(Node)
+	}
+	editNodes(n.Body, edit)
+	editNodes(n.Else, edit)
 }
 
 func (n *IndexExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *IndexExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *IndexExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	err = maybeDo(n.Index, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.X != nil {
+		if err := do(n.X); err != nil {
+			return err
+		}
+	}
+	if n.Index != nil {
+		if err := do(n.Index); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 func (n *IndexExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-	n.Index = maybeEdit(n.Index, edit)
+	editNodes(n.init, edit)
+	if n.X != nil {
+		n.X = edit(n.X).(Node)
+	}
+	if n.Index != nil {
+		n.Index = edit(n.Index).(Node)
+	}
 }
 
 func (n *InlineMarkStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *InlineMarkStmt) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *InlineMarkStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	return nil
 }
 func (n *InlineMarkStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
+	editNodes(n.init, edit)
 }
 
 func (n *InlinedCallExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *InlinedCallExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
-	c.Body = c.Body.Copy()
-	c.ReturnVars = c.ReturnVars.Copy()
+	c.init = copyNodes(c.init)
+	c.Body = copyNodes(c.Body)
+	c.ReturnVars = copyNodes(c.ReturnVars)
 	return &c
 }
 func (n *InlinedCallExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDoList(n.Body, err, do)
-	err = maybeDoList(n.ReturnVars, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if err := doNodes(n.Body, do); err != nil {
+		return err
+	}
+	if err := doNodes(n.ReturnVars, do); err != nil {
+		return err
+	}
+	return nil
 }
 func (n *InlinedCallExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	editList(n.Body, edit)
-	editList(n.ReturnVars, edit)
+	editNodes(n.init, edit)
+	editNodes(n.Body, edit)
+	editNodes(n.ReturnVars, edit)
 }
 
 func (n *InterfaceType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
@@ -572,9 +749,10 @@ func (n *InterfaceType) copy() Node {
 	return &c
 }
 func (n *InterfaceType) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoFields(n.Methods, err, do)
-	return err
+	if err := doFields(n.Methods, do); err != nil {
+		return err
+	}
+	return nil
 }
 func (n *InterfaceType) editChildren(edit func(Node) Node) {
 	editFields(n.Methods, edit)
@@ -583,73 +761,113 @@ func (n *InterfaceType) editChildren(edit func(Node) Node) {
 func (n *KeyExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *KeyExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *KeyExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.Key, err, do)
-	err = maybeDo(n.Value, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.Key != nil {
+		if err := do(n.Key); err != nil {
+			return err
+		}
+	}
+	if n.Value != nil {
+		if err := do(n.Value); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 func (n *KeyExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.Key = maybeEdit(n.Key, edit)
-	n.Value = maybeEdit(n.Value, edit)
+	editNodes(n.init, edit)
+	if n.Key != nil {
+		n.Key = edit(n.Key).(Node)
+	}
+	if n.Value != nil {
+		n.Value = edit(n.Value).(Node)
+	}
 }
 
 func (n *LabelStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *LabelStmt) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *LabelStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	return nil
 }
 func (n *LabelStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
+	editNodes(n.init, edit)
 }
 
 func (n *LogicalExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *LogicalExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *LogicalExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	err = maybeDo(n.Y, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.X != nil {
+		if err := do(n.X); err != nil {
+			return err
+		}
+	}
+	if n.Y != nil {
+		if err := do(n.Y); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 func (n *LogicalExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-	n.Y = maybeEdit(n.Y, edit)
+	editNodes(n.init, edit)
+	if n.X != nil {
+		n.X = edit(n.X).(Node)
+	}
+	if n.Y != nil {
+		n.Y = edit(n.Y).(Node)
+	}
 }
 
 func (n *MakeExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *MakeExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *MakeExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.Len, err, do)
-	err = maybeDo(n.Cap, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.Len != nil {
+		if err := do(n.Len); err != nil {
+			return err
+		}
+	}
+	if n.Cap != nil {
+		if err := do(n.Cap); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 func (n *MakeExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.Len = maybeEdit(n.Len, edit)
-	n.Cap = maybeEdit(n.Cap, edit)
+	editNodes(n.init, edit)
+	if n.Len != nil {
+		n.Len = edit(n.Len).(Node)
+	}
+	if n.Cap != nil {
+		n.Cap = edit(n.Cap).(Node)
+	}
 }
 
 func (n *MapType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
@@ -658,41 +876,48 @@ func (n *MapType) copy() Node {
 	return &c
 }
 func (n *MapType) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDo(n.Key, err, do)
-	err = maybeDo(n.Elem, err, do)
-	return err
+	if n.Key != nil {
+		if err := do(n.Key); err != nil {
+			return err
+		}
+	}
+	if n.Elem != nil {
+		if err := do(n.Elem); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 func (n *MapType) editChildren(edit func(Node) Node) {
-	n.Key = toNtype(maybeEdit(n.Key, edit))
-	n.Elem = toNtype(maybeEdit(n.Elem, edit))
+	if n.Key != nil {
+		n.Key = edit(n.Key).(Ntype)
+	}
+	if n.Elem != nil {
+		n.Elem = edit(n.Elem).(Ntype)
+	}
 }
 
 func (n *Name) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
-func (n *Name) copy() Node                    { panic("Name.copy") }
-func (n *Name) doChildren(do func(Node) error) error {
-	var err error
-	return err
-}
-func (n *Name) editChildren(edit func(Node) Node) {
-}
 
 func (n *NameOffsetExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *NameOffsetExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *NameOffsetExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
 	if n.Name_ != nil {
-		err = maybeDo(n.Name_, err, do)
+		if err := do(n.Name_); err != nil {
+			return err
+		}
 	}
-	return err
+	return nil
 }
 func (n *NameOffsetExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
+	editNodes(n.init, edit)
 	if n.Name_ != nil {
 		n.Name_ = edit(n.Name_).(*Name)
 	}
@@ -701,33 +926,41 @@ func (n *NameOffsetExpr) editChildren(edit func(Node) Node) {
 func (n *NilExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *NilExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *NilExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	return nil
 }
 func (n *NilExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
+	editNodes(n.init, edit)
 }
 
 func (n *ParenExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *ParenExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *ParenExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.X != nil {
+		if err := do(n.X); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 func (n *ParenExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
+	editNodes(n.init, edit)
+	if n.X != nil {
+		n.X = edit(n.X).(Node)
+	}
 }
 
 func (n *PkgName) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
@@ -736,8 +969,7 @@ func (n *PkgName) copy() Node {
 	return &c
 }
 func (n *PkgName) doChildren(do func(Node) error) error {
-	var err error
-	return err
+	return nil
 }
 func (n *PkgName) editChildren(edit func(Node) Node) {
 }
@@ -745,28 +977,51 @@ func (n *PkgName) editChildren(edit func(Node) Node) {
 func (n *RangeStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *RangeStmt) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
-	c.Body = c.Body.Copy()
+	c.init = copyNodes(c.init)
+	c.Body = copyNodes(c.Body)
 	return &c
 }
 func (n *RangeStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	err = maybeDo(n.Key, err, do)
-	err = maybeDo(n.Value, err, do)
-	err = maybeDoList(n.Body, err, do)
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.X != nil {
+		if err := do(n.X); err != nil {
+			return err
+		}
+	}
+	if n.Key != nil {
+		if err := do(n.Key); err != nil {
+			return err
+		}
+	}
+	if n.Value != nil {
+		if err := do(n.Value); err != nil {
+			return err
+		}
+	}
+	if err := doNodes(n.Body, do); err != nil {
+		return err
+	}
 	if n.Prealloc != nil {
-		err = maybeDo(n.Prealloc, err, do)
+		if err := do(n.Prealloc); err != nil {
+			return err
+		}
 	}
-	return err
+	return nil
 }
 func (n *RangeStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-	n.Key = maybeEdit(n.Key, edit)
-	n.Value = maybeEdit(n.Value, edit)
-	editList(n.Body, edit)
+	editNodes(n.init, edit)
+	if n.X != nil {
+		n.X = edit(n.X).(Node)
+	}
+	if n.Key != nil {
+		n.Key = edit(n.Key).(Node)
+	}
+	if n.Value != nil {
+		n.Value = edit(n.Value).(Node)
+	}
+	editNodes(n.Body, edit)
 	if n.Prealloc != nil {
 		n.Prealloc = edit(n.Prealloc).(*Name)
 	}
@@ -775,75 +1030,93 @@ func (n *RangeStmt) editChildren(edit func(Node) Node) {
 func (n *ResultExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *ResultExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *ResultExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	return nil
 }
 func (n *ResultExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
+	editNodes(n.init, edit)
 }
 
 func (n *ReturnStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *ReturnStmt) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
-	c.Results = c.Results.Copy()
+	c.init = copyNodes(c.init)
+	c.Results = copyNodes(c.Results)
 	return &c
 }
 func (n *ReturnStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDoList(n.Results, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if err := doNodes(n.Results, do); err != nil {
+		return err
+	}
+	return nil
 }
 func (n *ReturnStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	editList(n.Results, edit)
+	editNodes(n.init, edit)
+	editNodes(n.Results, edit)
 }
 
 func (n *SelectStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *SelectStmt) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
-	c.Cases = copyComms(c.Cases)
-	c.Compiled = c.Compiled.Copy()
+	c.init = copyNodes(c.init)
+	c.Cases = copyCommClauses(c.Cases)
+	c.Compiled = copyNodes(c.Compiled)
 	return &c
 }
 func (n *SelectStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDoComms(n.Cases, err, do)
-	err = maybeDoList(n.Compiled, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if err := doCommClauses(n.Cases, do); err != nil {
+		return err
+	}
+	if err := doNodes(n.Compiled, do); err != nil {
+		return err
+	}
+	return nil
 }
 func (n *SelectStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	editComms(n.Cases, edit)
-	editList(n.Compiled, edit)
+	editNodes(n.init, edit)
+	editCommClauses(n.Cases, edit)
+	editNodes(n.Compiled, edit)
 }
 
 func (n *SelectorExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *SelectorExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *SelectorExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.X != nil {
+		if err := do(n.X); err != nil {
+			return err
+		}
+	}
 	if n.Prealloc != nil {
-		err = maybeDo(n.Prealloc, err, do)
+		if err := do(n.Prealloc); err != nil {
+			return err
+		}
 	}
-	return err
+	return nil
 }
 func (n *SelectorExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
+	editNodes(n.init, edit)
+	if n.X != nil {
+		n.X = edit(n.X).(Node)
+	}
 	if n.Prealloc != nil {
 		n.Prealloc = edit(n.Prealloc).(*Name)
 	}
@@ -852,64 +1125,121 @@ func (n *SelectorExpr) editChildren(edit func(Node) Node) {
 func (n *SendStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *SendStmt) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *SendStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.Chan, err, do)
-	err = maybeDo(n.Value, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.Chan != nil {
+		if err := do(n.Chan); err != nil {
+			return err
+		}
+	}
+	if n.Value != nil {
+		if err := do(n.Value); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 func (n *SendStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.Chan = maybeEdit(n.Chan, edit)
-	n.Value = maybeEdit(n.Value, edit)
+	editNodes(n.init, edit)
+	if n.Chan != nil {
+		n.Chan = edit(n.Chan).(Node)
+	}
+	if n.Value != nil {
+		n.Value = edit(n.Value).(Node)
+	}
 }
 
 func (n *SliceExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *SliceExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *SliceExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	err = maybeDo(n.Low, err, do)
-	err = maybeDo(n.High, err, do)
-	err = maybeDo(n.Max, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.X != nil {
+		if err := do(n.X); err != nil {
+			return err
+		}
+	}
+	if n.Low != nil {
+		if err := do(n.Low); err != nil {
+			return err
+		}
+	}
+	if n.High != nil {
+		if err := do(n.High); err != nil {
+			return err
+		}
+	}
+	if n.Max != nil {
+		if err := do(n.Max); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 func (n *SliceExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-	n.Low = maybeEdit(n.Low, edit)
-	n.High = maybeEdit(n.High, edit)
-	n.Max = maybeEdit(n.Max, edit)
+	editNodes(n.init, edit)
+	if n.X != nil {
+		n.X = edit(n.X).(Node)
+	}
+	if n.Low != nil {
+		n.Low = edit(n.Low).(Node)
+	}
+	if n.High != nil {
+		n.High = edit(n.High).(Node)
+	}
+	if n.Max != nil {
+		n.Max = edit(n.Max).(Node)
+	}
 }
 
 func (n *SliceHeaderExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *SliceHeaderExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *SliceHeaderExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.Ptr, err, do)
-	err = maybeDo(n.Len, err, do)
-	err = maybeDo(n.Cap, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.Ptr != nil {
+		if err := do(n.Ptr); err != nil {
+			return err
+		}
+	}
+	if n.Len != nil {
+		if err := do(n.Len); err != nil {
+			return err
+		}
+	}
+	if n.Cap != nil {
+		if err := do(n.Cap); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 func (n *SliceHeaderExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.Ptr = maybeEdit(n.Ptr, edit)
-	n.Len = maybeEdit(n.Len, edit)
-	n.Cap = maybeEdit(n.Cap, edit)
+	editNodes(n.init, edit)
+	if n.Ptr != nil {
+		n.Ptr = edit(n.Ptr).(Node)
+	}
+	if n.Len != nil {
+		n.Len = edit(n.Len).(Node)
+	}
+	if n.Cap != nil {
+		n.Cap = edit(n.Cap).(Node)
+	}
 }
 
 func (n *SliceType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
@@ -918,46 +1248,65 @@ func (n *SliceType) copy() Node {
 	return &c
 }
 func (n *SliceType) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDo(n.Elem, err, do)
-	return err
+	if n.Elem != nil {
+		if err := do(n.Elem); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 func (n *SliceType) editChildren(edit func(Node) Node) {
-	n.Elem = toNtype(maybeEdit(n.Elem, edit))
+	if n.Elem != nil {
+		n.Elem = edit(n.Elem).(Ntype)
+	}
 }
 
 func (n *StarExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *StarExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *StarExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.X != nil {
+		if err := do(n.X); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 func (n *StarExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
+	editNodes(n.init, edit)
+	if n.X != nil {
+		n.X = edit(n.X).(Node)
+	}
 }
 
 func (n *StructKeyExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *StructKeyExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *StructKeyExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.Value, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.Value != nil {
+		if err := do(n.Value); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 func (n *StructKeyExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.Value = maybeEdit(n.Value, edit)
+	editNodes(n.init, edit)
+	if n.Value != nil {
+		n.Value = edit(n.Value).(Node)
+	}
 }
 
 func (n *StructType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
@@ -967,9 +1316,10 @@ func (n *StructType) copy() Node {
 	return &c
 }
 func (n *StructType) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoFields(n.Fields, err, do)
-	return err
+	if err := doFields(n.Fields, do); err != nil {
+		return err
+	}
+	return nil
 }
 func (n *StructType) editChildren(edit func(Node) Node) {
 	editFields(n.Fields, edit)
@@ -978,43 +1328,67 @@ func (n *StructType) editChildren(edit func(Node) Node) {
 func (n *SwitchStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *SwitchStmt) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
-	c.Cases = copyCases(c.Cases)
-	c.Compiled = c.Compiled.Copy()
+	c.init = copyNodes(c.init)
+	c.Cases = copyCaseClauses(c.Cases)
+	c.Compiled = copyNodes(c.Compiled)
 	return &c
 }
 func (n *SwitchStmt) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.Tag, err, do)
-	err = maybeDoCases(n.Cases, err, do)
-	err = maybeDoList(n.Compiled, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.Tag != nil {
+		if err := do(n.Tag); err != nil {
+			return err
+		}
+	}
+	if err := doCaseClauses(n.Cases, do); err != nil {
+		return err
+	}
+	if err := doNodes(n.Compiled, do); err != nil {
+		return err
+	}
+	return nil
 }
 func (n *SwitchStmt) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.Tag = maybeEdit(n.Tag, edit)
-	editCases(n.Cases, edit)
-	editList(n.Compiled, edit)
+	editNodes(n.init, edit)
+	if n.Tag != nil {
+		n.Tag = edit(n.Tag).(Node)
+	}
+	editCaseClauses(n.Cases, edit)
+	editNodes(n.Compiled, edit)
 }
 
 func (n *TypeAssertExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *TypeAssertExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *TypeAssertExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	err = maybeDo(n.Ntype, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.X != nil {
+		if err := do(n.X); err != nil {
+			return err
+		}
+	}
+	if n.Ntype != nil {
+		if err := do(n.Ntype); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 func (n *TypeAssertExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
-	n.Ntype = toNtype(maybeEdit(n.Ntype, edit))
+	editNodes(n.init, edit)
+	if n.X != nil {
+		n.X = edit(n.X).(Node)
+	}
+	if n.Ntype != nil {
+		n.Ntype = edit(n.Ntype).(Ntype)
+	}
 }
 
 func (n *TypeSwitchGuard) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
@@ -1023,35 +1397,49 @@ func (n *TypeSwitchGuard) copy() Node {
 	return &c
 }
 func (n *TypeSwitchGuard) doChildren(do func(Node) error) error {
-	var err error
 	if n.Tag != nil {
-		err = maybeDo(n.Tag, err, do)
+		if err := do(n.Tag); err != nil {
+			return err
+		}
 	}
-	err = maybeDo(n.X, err, do)
-	return err
+	if n.X != nil {
+		if err := do(n.X); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 func (n *TypeSwitchGuard) editChildren(edit func(Node) Node) {
 	if n.Tag != nil {
 		n.Tag = edit(n.Tag).(*Ident)
 	}
-	n.X = maybeEdit(n.X, edit)
+	if n.X != nil {
+		n.X = edit(n.X).(Node)
+	}
 }
 
 func (n *UnaryExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *UnaryExpr) copy() Node {
 	c := *n
-	c.init = c.init.Copy()
+	c.init = copyNodes(c.init)
 	return &c
 }
 func (n *UnaryExpr) doChildren(do func(Node) error) error {
-	var err error
-	err = maybeDoList(n.init, err, do)
-	err = maybeDo(n.X, err, do)
-	return err
+	if err := doNodes(n.init, do); err != nil {
+		return err
+	}
+	if n.X != nil {
+		if err := do(n.X); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 func (n *UnaryExpr) editChildren(edit func(Node) Node) {
-	editList(n.init, edit)
-	n.X = maybeEdit(n.X, edit)
+	editNodes(n.init, edit)
+	if n.X != nil {
+		n.X = edit(n.X).(Node)
+	}
 }
 
 func (n *typeNode) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
@@ -1060,13 +1448,12 @@ func (n *typeNode) copy() Node {
 	return &c
 }
 func (n *typeNode) doChildren(do func(Node) error) error {
-	var err error
-	return err
+	return nil
 }
 func (n *typeNode) editChildren(edit func(Node) Node) {
 }
 
-func copyCases(list []*CaseClause) []*CaseClause {
+func copyCaseClauses(list []*CaseClause) []*CaseClause {
 	if list == nil {
 		return nil
 	}
@@ -1074,10 +1461,7 @@ func copyCases(list []*CaseClause) []*CaseClause {
 	copy(c, list)
 	return c
 }
-func maybeDoCases(list []*CaseClause, err error, do func(Node) error) error {
-	if err != nil {
-		return err
-	}
+func doCaseClauses(list []*CaseClause, do func(Node) error) error {
 	for _, x := range list {
 		if x != nil {
 			if err := do(x); err != nil {
@@ -1087,7 +1471,7 @@ func maybeDoCases(list []*CaseClause, err error, do func(Node) error) error {
 	}
 	return nil
 }
-func editCases(list []*CaseClause, edit func(Node) Node) {
+func editCaseClauses(list []*CaseClause, edit func(Node) Node) {
 	for i, x := range list {
 		if x != nil {
 			list[i] = edit(x).(*CaseClause)
@@ -1095,7 +1479,7 @@ func editCases(list []*CaseClause, edit func(Node) Node) {
 	}
 }
 
-func copyComms(list []*CommClause) []*CommClause {
+func copyCommClauses(list []*CommClause) []*CommClause {
 	if list == nil {
 		return nil
 	}
@@ -1103,10 +1487,7 @@ func copyComms(list []*CommClause) []*CommClause {
 	copy(c, list)
 	return c
 }
-func maybeDoComms(list []*CommClause, err error, do func(Node) error) error {
-	if err != nil {
-		return err
-	}
+func doCommClauses(list []*CommClause, do func(Node) error) error {
 	for _, x := range list {
 		if x != nil {
 			if err := do(x); err != nil {
@@ -1116,10 +1497,36 @@ func maybeDoComms(list []*CommClause, err error, do func(Node) error) error {
 	}
 	return nil
 }
-func editComms(list []*CommClause, edit func(Node) Node) {
+func editCommClauses(list []*CommClause, edit func(Node) Node) {
 	for i, x := range list {
 		if x != nil {
 			list[i] = edit(x).(*CommClause)
 		}
 	}
 }
+
+func copyNodes(list []Node) []Node {
+	if list == nil {
+		return nil
+	}
+	c := make([]Node, len(list))
+	copy(c, list)
+	return c
+}
+func doNodes(list []Node, do func(Node) error) error {
+	for _, x := range list {
+		if x != nil {
+			if err := do(x); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+func editNodes(list []Node, edit func(Node) Node) {
+	for i, x := range list {
+		if x != nil {
+			list[i] = edit(x).(Node)
+		}
+	}
+}
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index 4575dec260..9c2cba9a08 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -322,8 +322,8 @@ func NewRangeStmt(pos src.XPos, key, value, x Node, body []Node) *RangeStmt {
 // A ReturnStmt is a return statement.
 type ReturnStmt struct {
 	miniStmt
-	orig    Node  // for typecheckargs rewrite
-	Results Nodes // return list
+	origNode       // for typecheckargs rewrite
+	Results  Nodes // return list
 }
 
 func NewReturnStmt(pos src.XPos, results []Node) *ReturnStmt {
@@ -335,9 +335,6 @@ func NewReturnStmt(pos src.XPos, results []Node) *ReturnStmt {
 	return n
 }
 
-func (n *ReturnStmt) Orig() Node     { return n.orig }
-func (n *ReturnStmt) SetOrig(x Node) { n.orig = x }
-
 // A SelectStmt is a block: { Cases }.
 type SelectStmt struct {
 	miniStmt
diff --git a/src/cmd/compile/internal/ir/type.go b/src/cmd/compile/internal/ir/type.go
index 408f6ed563..7dd394f9ea 100644
--- a/src/cmd/compile/internal/ir/type.go
+++ b/src/cmd/compile/internal/ir/type.go
@@ -185,45 +185,32 @@ func (f *Field) String() string {
 	return typ
 }
 
-func (f *Field) copy() *Field {
+// TODO(mdempsky): Make Field a Node again so these can be generated?
+// Fields are Nodes in go/ast and cmd/compile/internal/syntax.
+
+func copyField(f *Field) *Field {
+	if f == nil {
+		return nil
+	}
 	c := *f
 	return &c
 }
-
-func copyFields(list []*Field) []*Field {
-	out := make([]*Field, len(list))
-	copy(out, list)
-	for i, f := range out {
-		out[i] = f.copy()
+func doField(f *Field, do func(Node) error) error {
+	if f == nil {
+		return nil
 	}
-	return out
-}
-
-func maybeDoField(f *Field, err error, do func(Node) error) error {
-	if f != nil {
-		if err == nil && f.Decl != nil {
-			err = do(f.Decl)
-		}
-		if err == nil && f.Ntype != nil {
-			err = do(f.Ntype)
+	if f.Decl != nil {
+		if err := do(f.Decl); err != nil {
+			return err
 		}
 	}
-	return err
-}
-
-func maybeDoFields(list []*Field, err error, do func(Node) error) error {
-	if err != nil {
-		return err
-	}
-	for _, f := range list {
-		err = maybeDoField(f, err, do)
-		if err != nil {
+	if f.Ntype != nil {
+		if err := do(f.Ntype); err != nil {
 			return err
 		}
 	}
-	return err
+	return nil
 }
-
 func editField(f *Field, edit func(Node) Node) {
 	if f == nil {
 		return
@@ -232,10 +219,25 @@ func editField(f *Field, edit func(Node) Node) {
 		f.Decl = edit(f.Decl).(*Name)
 	}
 	if f.Ntype != nil {
-		f.Ntype = toNtype(edit(f.Ntype))
+		f.Ntype = edit(f.Ntype).(Ntype)
 	}
 }
 
+func copyFields(list []*Field) []*Field {
+	out := make([]*Field, len(list))
+	for i, f := range list {
+		out[i] = copyField(f)
+	}
+	return out
+}
+func doFields(list []*Field, do func(Node) error) error {
+	for _, x := range list {
+		if err := doField(x, do); err != nil {
+			return err
+		}
+	}
+	return nil
+}
 func editFields(list []*Field, edit func(Node) Node) {
 	for _, f := range list {
 		editField(f, edit)
diff --git a/src/cmd/compile/internal/ir/visit.go b/src/cmd/compile/internal/ir/visit.go
index 8839e1664d..4616390b7c 100644
--- a/src/cmd/compile/internal/ir/visit.go
+++ b/src/cmd/compile/internal/ir/visit.go
@@ -106,14 +106,7 @@ func DoChildren(n Node, do func(Node) error) error {
 // Note that DoList only calls do on the nodes in the list, not their children.
 // If x's children should be processed, do(x) must call DoChildren(x, do) itself.
 func DoList(list Nodes, do func(Node) error) error {
-	for _, x := range list {
-		if x != nil {
-			if err := do(x); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
+	return doNodes(list, do)
 }
 
 // Visit visits each non-nil node x in the IR tree rooted at n
@@ -210,16 +203,3 @@ func EditChildren(n Node, edit func(Node) Node) {
 	}
 	n.editChildren(edit)
 }
-
-// editList calls edit on each non-nil node x in the list,
-// saving the result of edit back into the list.
-//
-// Note that editList only calls edit on the nodes in the list, not their children.
-// If x's children should be processed, edit(x) must call EditChildren(x, edit) itself.
-func editList(list Nodes, edit func(Node) Node) {
-	for i, x := range list {
-		if x != nil {
-			list[i] = edit(x)
-		}
-	}
-}
-- 
GitLab


From f9b67f76a59cb9adf5d04e9b559cda98afb3c6f4 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 29 Dec 2020 19:46:31 -0800
Subject: [PATCH 0386/2400] [dev.regabi] cmd/compile: change ir.DoChildren to
 use bool result type

After using the IR visitor code for a bit, it seems clear that a
simple boolean result type is adequate for tree traversals. This CL
updates ir.DoChildren to use the same calling convention as ir.Any,
and updates mknode.go to generate code accordingly.

There were only two places where the error-based DoChildren API was
used within the compiler:

1. Within typechecking, marking statements that contain "break". This
code never returns errors anyway, so it's trivially updated to return
false instead.

2. Within inlining, the "hairy visitor" actually does make use of
returning errors. However, it threads through a reference to the
hairyVisitor anyway, where it would be trivial to store any needed
information instead. For the purpose of this CL, we provide
"errChildren" and "errList" helper functions that provide the previous
error-based semantics on top of the new bool-based API.

Passes toolstash -cmp.

Change-Id: I4bac9a697b4dbfb5f66eeac37d4a2ced2073d7d0
Reviewed-on: https://go-review.googlesource.com/c/go/+/280675
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/inline/inl.go        |  29 +-
 src/cmd/compile/internal/ir/func.go           |   6 +-
 src/cmd/compile/internal/ir/mknode.go         |  18 +-
 src/cmd/compile/internal/ir/name.go           |   6 +-
 src/cmd/compile/internal/ir/node.go           |   2 +-
 src/cmd/compile/internal/ir/node_gen.go       | 898 ++++++++----------
 src/cmd/compile/internal/ir/type.go           |  26 +-
 src/cmd/compile/internal/ir/visit.go          | 103 +-
 .../compile/internal/typecheck/typecheck.go   |   6 +-
 9 files changed, 481 insertions(+), 613 deletions(-)

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 7584f6a19f..df797da2d1 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -265,7 +265,7 @@ var errBudget = errors.New("too expensive")
 func (v *hairyVisitor) tooHairy(fn *ir.Func) bool {
 	v.do = v.doNode // cache closure
 
-	err := ir.DoChildren(fn, v.do)
+	err := errChildren(fn, v.do)
 	if err != nil {
 		v.reason = err.Error()
 		return true
@@ -393,13 +393,13 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 		if ir.IsConst(n.Cond, constant.Bool) {
 			// This if and the condition cost nothing.
 			// TODO(rsc): It seems strange that we visit the dead branch.
-			if err := ir.DoList(n.Init(), v.do); err != nil {
+			if err := errList(n.Init(), v.do); err != nil {
 				return err
 			}
-			if err := ir.DoList(n.Body, v.do); err != nil {
+			if err := errList(n.Body, v.do); err != nil {
 				return err
 			}
-			if err := ir.DoList(n.Else, v.do); err != nil {
+			if err := errList(n.Else, v.do); err != nil {
 				return err
 			}
 			return nil
@@ -431,7 +431,7 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 		return errBudget
 	}
 
-	return ir.DoChildren(n, v.do)
+	return errChildren(n, v.do)
 }
 
 func isBigFunc(fn *ir.Func) bool {
@@ -1214,3 +1214,22 @@ func numNonClosures(list []*ir.Func) int {
 	}
 	return count
 }
+
+// TODO(mdempsky): Update inl.go to use ir.DoChildren directly.
+func errChildren(n ir.Node, do func(ir.Node) error) (err error) {
+	ir.DoChildren(n, func(x ir.Node) bool {
+		err = do(x)
+		return err != nil
+	})
+	return
+}
+func errList(list []ir.Node, do func(ir.Node) error) error {
+	for _, x := range list {
+		if x != nil {
+			if err := do(x); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 32ad37fa80..9a79a4f30f 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -115,9 +115,9 @@ func NewFunc(pos src.XPos) *Func {
 
 func (f *Func) isStmt() {}
 
-func (n *Func) copy() Node                           { panic(n.no("copy")) }
-func (n *Func) doChildren(do func(Node) error) error { return doNodes(n.Body, do) }
-func (n *Func) editChildren(edit func(Node) Node)    { editNodes(n.Body, edit) }
+func (n *Func) copy() Node                         { panic(n.no("copy")) }
+func (n *Func) doChildren(do func(Node) bool) bool { return doNodes(n.Body, do) }
+func (n *Func) editChildren(edit func(Node) Node)  { editNodes(n.Body, edit) }
 
 func (f *Func) Type() *types.Type  { return f.Nname.Type() }
 func (f *Func) Sym() *types.Sym    { return f.Nname.Sym() }
diff --git a/src/cmd/compile/internal/ir/mknode.go b/src/cmd/compile/internal/ir/mknode.go
index 4e26bc5011..326f491a69 100644
--- a/src/cmd/compile/internal/ir/mknode.go
+++ b/src/cmd/compile/internal/ir/mknode.go
@@ -70,10 +70,10 @@ func main() {
 			"return &c }\n")
 
 		forNodeFields(typ,
-			"func (n *%[1]s) doChildren(do func(Node) error) error {\n",
-			"if n.%[1]s != nil { if err := do(n.%[1]s); err != nil { return err } }",
-			"if err := do%[2]s(n.%[1]s, do); err != nil { return err }",
-			"return nil }\n")
+			"func (n *%[1]s) doChildren(do func(Node) bool) bool {\n",
+			"if n.%[1]s != nil && do(n.%[1]s) { return true }",
+			"if do%[2]s(n.%[1]s, do) { return true }",
+			"return false }\n")
 
 		forNodeFields(typ,
 			"func (n *%[1]s) editChildren(edit func(Node) Node) {\n",
@@ -121,15 +121,13 @@ func copy%[1]s(list []%[2]s) []%[2]s {
 	copy(c, list)
 	return c
 }
-func do%[1]s(list []%[2]s, do func(Node) error) error {
+func do%[1]s(list []%[2]s, do func(Node) bool) bool {
 	for _, x := range list {
-		if x != nil {
-			if err := do(x); err != nil {
-				return err
-			}
+		if x != nil && do(x) {
+			return true
 		}
 	}
-	return nil
+	return false
 }
 func edit%[1]s(list []%[2]s, edit func(Node) Node) {
 	for i, x := range list {
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index b12e833f73..697b04f541 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -143,9 +143,9 @@ type Name struct {
 
 func (n *Name) isExpr() {}
 
-func (n *Name) copy() Node                           { panic(n.no("copy")) }
-func (n *Name) doChildren(do func(Node) error) error { return nil }
-func (n *Name) editChildren(edit func(Node) Node)    {}
+func (n *Name) copy() Node                         { panic(n.no("copy")) }
+func (n *Name) doChildren(do func(Node) bool) bool { return false }
+func (n *Name) editChildren(edit func(Node) Node)  {}
 
 // CloneName makes a cloned copy of the name.
 // It's not ir.Copy(n) because in general that operation is a mistake on names,
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 0238e9de85..0d56b5aeb8 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -28,7 +28,7 @@ type Node interface {
 	// For making copies. For Copy and SepCopy.
 	copy() Node
 
-	doChildren(func(Node) error) error
+	doChildren(func(Node) bool) bool
 	editChildren(func(Node) Node)
 
 	// Abstract graph structure, for generic traversals.
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index 21e4eff9fb..65c0b239ed 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -11,19 +11,17 @@ func (n *AddStringExpr) copy() Node {
 	c.List = copyNodes(c.List)
 	return &c
 }
-func (n *AddStringExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *AddStringExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if err := doNodes(n.List, do); err != nil {
-		return err
+	if doNodes(n.List, do) {
+		return true
 	}
-	if n.Prealloc != nil {
-		if err := do(n.Prealloc); err != nil {
-			return err
-		}
+	if n.Prealloc != nil && do(n.Prealloc) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *AddStringExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -39,21 +37,17 @@ func (n *AddrExpr) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *AddrExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *AddrExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.X != nil {
-		if err := do(n.X); err != nil {
-			return err
-		}
+	if n.X != nil && do(n.X) {
+		return true
 	}
-	if n.Prealloc != nil {
-		if err := do(n.Prealloc); err != nil {
-			return err
-		}
+	if n.Prealloc != nil && do(n.Prealloc) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *AddrExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -70,18 +64,14 @@ func (n *ArrayType) copy() Node {
 	c := *n
 	return &c
 }
-func (n *ArrayType) doChildren(do func(Node) error) error {
-	if n.Len != nil {
-		if err := do(n.Len); err != nil {
-			return err
-		}
+func (n *ArrayType) doChildren(do func(Node) bool) bool {
+	if n.Len != nil && do(n.Len) {
+		return true
 	}
-	if n.Elem != nil {
-		if err := do(n.Elem); err != nil {
-			return err
-		}
+	if n.Elem != nil && do(n.Elem) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *ArrayType) editChildren(edit func(Node) Node) {
 	if n.Len != nil {
@@ -100,17 +90,17 @@ func (n *AssignListStmt) copy() Node {
 	c.Rhs = copyNodes(c.Rhs)
 	return &c
 }
-func (n *AssignListStmt) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *AssignListStmt) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if err := doNodes(n.Lhs, do); err != nil {
-		return err
+	if doNodes(n.Lhs, do) {
+		return true
 	}
-	if err := doNodes(n.Rhs, do); err != nil {
-		return err
+	if doNodes(n.Rhs, do) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *AssignListStmt) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -124,21 +114,17 @@ func (n *AssignOpStmt) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *AssignOpStmt) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *AssignOpStmt) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.X != nil {
-		if err := do(n.X); err != nil {
-			return err
-		}
+	if n.X != nil && do(n.X) {
+		return true
 	}
-	if n.Y != nil {
-		if err := do(n.Y); err != nil {
-			return err
-		}
+	if n.Y != nil && do(n.Y) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *AssignOpStmt) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -156,21 +142,17 @@ func (n *AssignStmt) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *AssignStmt) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *AssignStmt) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.X != nil {
-		if err := do(n.X); err != nil {
-			return err
-		}
+	if n.X != nil && do(n.X) {
+		return true
 	}
-	if n.Y != nil {
-		if err := do(n.Y); err != nil {
-			return err
-		}
+	if n.Y != nil && do(n.Y) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *AssignStmt) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -188,11 +170,11 @@ func (n *BasicLit) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *BasicLit) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *BasicLit) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *BasicLit) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -204,21 +186,17 @@ func (n *BinaryExpr) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *BinaryExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *BinaryExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.X != nil {
-		if err := do(n.X); err != nil {
-			return err
-		}
+	if n.X != nil && do(n.X) {
+		return true
 	}
-	if n.Y != nil {
-		if err := do(n.Y); err != nil {
-			return err
-		}
+	if n.Y != nil && do(n.Y) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *BinaryExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -237,14 +215,14 @@ func (n *BlockStmt) copy() Node {
 	c.List = copyNodes(c.List)
 	return &c
 }
-func (n *BlockStmt) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *BlockStmt) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if err := doNodes(n.List, do); err != nil {
-		return err
+	if doNodes(n.List, do) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *BlockStmt) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -257,11 +235,11 @@ func (n *BranchStmt) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *BranchStmt) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *BranchStmt) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *BranchStmt) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -276,25 +254,23 @@ func (n *CallExpr) copy() Node {
 	c.Body = copyNodes(c.Body)
 	return &c
 }
-func (n *CallExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *CallExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.X != nil {
-		if err := do(n.X); err != nil {
-			return err
-		}
+	if n.X != nil && do(n.X) {
+		return true
 	}
-	if err := doNodes(n.Args, do); err != nil {
-		return err
+	if doNodes(n.Args, do) {
+		return true
 	}
-	if err := doNodes(n.Rargs, do); err != nil {
-		return err
+	if doNodes(n.Rargs, do) {
+		return true
 	}
-	if err := doNodes(n.Body, do); err != nil {
-		return err
+	if doNodes(n.Body, do) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *CallExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -314,22 +290,20 @@ func (n *CaseClause) copy() Node {
 	c.Body = copyNodes(c.Body)
 	return &c
 }
-func (n *CaseClause) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *CaseClause) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.Var != nil {
-		if err := do(n.Var); err != nil {
-			return err
-		}
+	if n.Var != nil && do(n.Var) {
+		return true
 	}
-	if err := doNodes(n.List, do); err != nil {
-		return err
+	if doNodes(n.List, do) {
+		return true
 	}
-	if err := doNodes(n.Body, do); err != nil {
-		return err
+	if doNodes(n.Body, do) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *CaseClause) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -345,13 +319,11 @@ func (n *ChanType) copy() Node {
 	c := *n
 	return &c
 }
-func (n *ChanType) doChildren(do func(Node) error) error {
-	if n.Elem != nil {
-		if err := do(n.Elem); err != nil {
-			return err
-		}
+func (n *ChanType) doChildren(do func(Node) bool) bool {
+	if n.Elem != nil && do(n.Elem) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *ChanType) editChildren(edit func(Node) Node) {
 	if n.Elem != nil {
@@ -365,16 +337,14 @@ func (n *ClosureExpr) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *ClosureExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *ClosureExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.Prealloc != nil {
-		if err := do(n.Prealloc); err != nil {
-			return err
-		}
+	if n.Prealloc != nil && do(n.Prealloc) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *ClosureExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -389,11 +359,11 @@ func (n *ClosureReadExpr) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *ClosureReadExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *ClosureReadExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *ClosureReadExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -406,19 +376,17 @@ func (n *CommClause) copy() Node {
 	c.Body = copyNodes(c.Body)
 	return &c
 }
-func (n *CommClause) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *CommClause) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.Comm != nil {
-		if err := do(n.Comm); err != nil {
-			return err
-		}
+	if n.Comm != nil && do(n.Comm) {
+		return true
 	}
-	if err := doNodes(n.Body, do); err != nil {
-		return err
+	if doNodes(n.Body, do) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *CommClause) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -435,24 +403,20 @@ func (n *CompLitExpr) copy() Node {
 	c.List = copyNodes(c.List)
 	return &c
 }
-func (n *CompLitExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *CompLitExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.Ntype != nil {
-		if err := do(n.Ntype); err != nil {
-			return err
-		}
+	if n.Ntype != nil && do(n.Ntype) {
+		return true
 	}
-	if err := doNodes(n.List, do); err != nil {
-		return err
+	if doNodes(n.List, do) {
+		return true
 	}
-	if n.Prealloc != nil {
-		if err := do(n.Prealloc); err != nil {
-			return err
-		}
+	if n.Prealloc != nil && do(n.Prealloc) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *CompLitExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -471,11 +435,11 @@ func (n *ConstExpr) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *ConstExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *ConstExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *ConstExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -487,16 +451,14 @@ func (n *ConvExpr) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *ConvExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *ConvExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.X != nil {
-		if err := do(n.X); err != nil {
-			return err
-		}
+	if n.X != nil && do(n.X) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *ConvExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -510,13 +472,11 @@ func (n *Decl) copy() Node {
 	c := *n
 	return &c
 }
-func (n *Decl) doChildren(do func(Node) error) error {
-	if n.X != nil {
-		if err := do(n.X); err != nil {
-			return err
-		}
+func (n *Decl) doChildren(do func(Node) bool) bool {
+	if n.X != nil && do(n.X) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *Decl) editChildren(edit func(Node) Node) {
 	if n.X != nil {
@@ -532,27 +492,23 @@ func (n *ForStmt) copy() Node {
 	c.Body = copyNodes(c.Body)
 	return &c
 }
-func (n *ForStmt) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *ForStmt) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.Cond != nil {
-		if err := do(n.Cond); err != nil {
-			return err
-		}
+	if n.Cond != nil && do(n.Cond) {
+		return true
 	}
-	if err := doNodes(n.Late, do); err != nil {
-		return err
+	if doNodes(n.Late, do) {
+		return true
 	}
-	if n.Post != nil {
-		if err := do(n.Post); err != nil {
-			return err
-		}
+	if n.Post != nil && do(n.Post) {
+		return true
 	}
-	if err := doNodes(n.Body, do); err != nil {
-		return err
+	if doNodes(n.Body, do) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *ForStmt) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -576,17 +532,17 @@ func (n *FuncType) copy() Node {
 	c.Results = copyFields(c.Results)
 	return &c
 }
-func (n *FuncType) doChildren(do func(Node) error) error {
-	if err := doField(n.Recv, do); err != nil {
-		return err
+func (n *FuncType) doChildren(do func(Node) bool) bool {
+	if doField(n.Recv, do) {
+		return true
 	}
-	if err := doFields(n.Params, do); err != nil {
-		return err
+	if doFields(n.Params, do) {
+		return true
 	}
-	if err := doFields(n.Results, do); err != nil {
-		return err
+	if doFields(n.Results, do) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *FuncType) editChildren(edit func(Node) Node) {
 	editField(n.Recv, edit)
@@ -600,16 +556,14 @@ func (n *GoDeferStmt) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *GoDeferStmt) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *GoDeferStmt) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.Call != nil {
-		if err := do(n.Call); err != nil {
-			return err
-		}
+	if n.Call != nil && do(n.Call) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *GoDeferStmt) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -624,11 +578,11 @@ func (n *Ident) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *Ident) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *Ident) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *Ident) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -642,22 +596,20 @@ func (n *IfStmt) copy() Node {
 	c.Else = copyNodes(c.Else)
 	return &c
 }
-func (n *IfStmt) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *IfStmt) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.Cond != nil {
-		if err := do(n.Cond); err != nil {
-			return err
-		}
+	if n.Cond != nil && do(n.Cond) {
+		return true
 	}
-	if err := doNodes(n.Body, do); err != nil {
-		return err
+	if doNodes(n.Body, do) {
+		return true
 	}
-	if err := doNodes(n.Else, do); err != nil {
-		return err
+	if doNodes(n.Else, do) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *IfStmt) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -674,21 +626,17 @@ func (n *IndexExpr) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *IndexExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *IndexExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.X != nil {
-		if err := do(n.X); err != nil {
-			return err
-		}
+	if n.X != nil && do(n.X) {
+		return true
 	}
-	if n.Index != nil {
-		if err := do(n.Index); err != nil {
-			return err
-		}
+	if n.Index != nil && do(n.Index) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *IndexExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -706,11 +654,11 @@ func (n *InlineMarkStmt) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *InlineMarkStmt) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *InlineMarkStmt) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *InlineMarkStmt) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -724,17 +672,17 @@ func (n *InlinedCallExpr) copy() Node {
 	c.ReturnVars = copyNodes(c.ReturnVars)
 	return &c
 }
-func (n *InlinedCallExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *InlinedCallExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if err := doNodes(n.Body, do); err != nil {
-		return err
+	if doNodes(n.Body, do) {
+		return true
 	}
-	if err := doNodes(n.ReturnVars, do); err != nil {
-		return err
+	if doNodes(n.ReturnVars, do) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *InlinedCallExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -748,11 +696,11 @@ func (n *InterfaceType) copy() Node {
 	c.Methods = copyFields(c.Methods)
 	return &c
 }
-func (n *InterfaceType) doChildren(do func(Node) error) error {
-	if err := doFields(n.Methods, do); err != nil {
-		return err
+func (n *InterfaceType) doChildren(do func(Node) bool) bool {
+	if doFields(n.Methods, do) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *InterfaceType) editChildren(edit func(Node) Node) {
 	editFields(n.Methods, edit)
@@ -764,21 +712,17 @@ func (n *KeyExpr) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *KeyExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *KeyExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.Key != nil {
-		if err := do(n.Key); err != nil {
-			return err
-		}
+	if n.Key != nil && do(n.Key) {
+		return true
 	}
-	if n.Value != nil {
-		if err := do(n.Value); err != nil {
-			return err
-		}
+	if n.Value != nil && do(n.Value) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *KeyExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -796,11 +740,11 @@ func (n *LabelStmt) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *LabelStmt) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *LabelStmt) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *LabelStmt) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -812,21 +756,17 @@ func (n *LogicalExpr) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *LogicalExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *LogicalExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.X != nil {
-		if err := do(n.X); err != nil {
-			return err
-		}
+	if n.X != nil && do(n.X) {
+		return true
 	}
-	if n.Y != nil {
-		if err := do(n.Y); err != nil {
-			return err
-		}
+	if n.Y != nil && do(n.Y) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *LogicalExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -844,21 +784,17 @@ func (n *MakeExpr) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *MakeExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *MakeExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.Len != nil {
-		if err := do(n.Len); err != nil {
-			return err
-		}
+	if n.Len != nil && do(n.Len) {
+		return true
 	}
-	if n.Cap != nil {
-		if err := do(n.Cap); err != nil {
-			return err
-		}
+	if n.Cap != nil && do(n.Cap) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *MakeExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -875,18 +811,14 @@ func (n *MapType) copy() Node {
 	c := *n
 	return &c
 }
-func (n *MapType) doChildren(do func(Node) error) error {
-	if n.Key != nil {
-		if err := do(n.Key); err != nil {
-			return err
-		}
+func (n *MapType) doChildren(do func(Node) bool) bool {
+	if n.Key != nil && do(n.Key) {
+		return true
 	}
-	if n.Elem != nil {
-		if err := do(n.Elem); err != nil {
-			return err
-		}
+	if n.Elem != nil && do(n.Elem) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *MapType) editChildren(edit func(Node) Node) {
 	if n.Key != nil {
@@ -905,16 +837,14 @@ func (n *NameOffsetExpr) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *NameOffsetExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *NameOffsetExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.Name_ != nil {
-		if err := do(n.Name_); err != nil {
-			return err
-		}
+	if n.Name_ != nil && do(n.Name_) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *NameOffsetExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -929,11 +859,11 @@ func (n *NilExpr) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *NilExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *NilExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *NilExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -945,16 +875,14 @@ func (n *ParenExpr) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *ParenExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *ParenExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.X != nil {
-		if err := do(n.X); err != nil {
-			return err
-		}
+	if n.X != nil && do(n.X) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *ParenExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -968,8 +896,8 @@ func (n *PkgName) copy() Node {
 	c := *n
 	return &c
 }
-func (n *PkgName) doChildren(do func(Node) error) error {
-	return nil
+func (n *PkgName) doChildren(do func(Node) bool) bool {
+	return false
 }
 func (n *PkgName) editChildren(edit func(Node) Node) {
 }
@@ -981,34 +909,26 @@ func (n *RangeStmt) copy() Node {
 	c.Body = copyNodes(c.Body)
 	return &c
 }
-func (n *RangeStmt) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *RangeStmt) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.X != nil {
-		if err := do(n.X); err != nil {
-			return err
-		}
+	if n.X != nil && do(n.X) {
+		return true
 	}
-	if n.Key != nil {
-		if err := do(n.Key); err != nil {
-			return err
-		}
+	if n.Key != nil && do(n.Key) {
+		return true
 	}
-	if n.Value != nil {
-		if err := do(n.Value); err != nil {
-			return err
-		}
+	if n.Value != nil && do(n.Value) {
+		return true
 	}
-	if err := doNodes(n.Body, do); err != nil {
-		return err
+	if doNodes(n.Body, do) {
+		return true
 	}
-	if n.Prealloc != nil {
-		if err := do(n.Prealloc); err != nil {
-			return err
-		}
+	if n.Prealloc != nil && do(n.Prealloc) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *RangeStmt) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -1033,11 +953,11 @@ func (n *ResultExpr) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *ResultExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *ResultExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *ResultExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -1050,14 +970,14 @@ func (n *ReturnStmt) copy() Node {
 	c.Results = copyNodes(c.Results)
 	return &c
 }
-func (n *ReturnStmt) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *ReturnStmt) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if err := doNodes(n.Results, do); err != nil {
-		return err
+	if doNodes(n.Results, do) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *ReturnStmt) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -1072,17 +992,17 @@ func (n *SelectStmt) copy() Node {
 	c.Compiled = copyNodes(c.Compiled)
 	return &c
 }
-func (n *SelectStmt) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *SelectStmt) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if err := doCommClauses(n.Cases, do); err != nil {
-		return err
+	if doCommClauses(n.Cases, do) {
+		return true
 	}
-	if err := doNodes(n.Compiled, do); err != nil {
-		return err
+	if doNodes(n.Compiled, do) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *SelectStmt) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -1096,21 +1016,17 @@ func (n *SelectorExpr) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *SelectorExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *SelectorExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.X != nil {
-		if err := do(n.X); err != nil {
-			return err
-		}
+	if n.X != nil && do(n.X) {
+		return true
 	}
-	if n.Prealloc != nil {
-		if err := do(n.Prealloc); err != nil {
-			return err
-		}
+	if n.Prealloc != nil && do(n.Prealloc) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *SelectorExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -1128,21 +1044,17 @@ func (n *SendStmt) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *SendStmt) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *SendStmt) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.Chan != nil {
-		if err := do(n.Chan); err != nil {
-			return err
-		}
+	if n.Chan != nil && do(n.Chan) {
+		return true
 	}
-	if n.Value != nil {
-		if err := do(n.Value); err != nil {
-			return err
-		}
+	if n.Value != nil && do(n.Value) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *SendStmt) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -1160,31 +1072,23 @@ func (n *SliceExpr) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *SliceExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *SliceExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.X != nil {
-		if err := do(n.X); err != nil {
-			return err
-		}
+	if n.X != nil && do(n.X) {
+		return true
 	}
-	if n.Low != nil {
-		if err := do(n.Low); err != nil {
-			return err
-		}
+	if n.Low != nil && do(n.Low) {
+		return true
 	}
-	if n.High != nil {
-		if err := do(n.High); err != nil {
-			return err
-		}
+	if n.High != nil && do(n.High) {
+		return true
 	}
-	if n.Max != nil {
-		if err := do(n.Max); err != nil {
-			return err
-		}
+	if n.Max != nil && do(n.Max) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *SliceExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -1208,26 +1112,20 @@ func (n *SliceHeaderExpr) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *SliceHeaderExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *SliceHeaderExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.Ptr != nil {
-		if err := do(n.Ptr); err != nil {
-			return err
-		}
+	if n.Ptr != nil && do(n.Ptr) {
+		return true
 	}
-	if n.Len != nil {
-		if err := do(n.Len); err != nil {
-			return err
-		}
+	if n.Len != nil && do(n.Len) {
+		return true
 	}
-	if n.Cap != nil {
-		if err := do(n.Cap); err != nil {
-			return err
-		}
+	if n.Cap != nil && do(n.Cap) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *SliceHeaderExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -1247,13 +1145,11 @@ func (n *SliceType) copy() Node {
 	c := *n
 	return &c
 }
-func (n *SliceType) doChildren(do func(Node) error) error {
-	if n.Elem != nil {
-		if err := do(n.Elem); err != nil {
-			return err
-		}
+func (n *SliceType) doChildren(do func(Node) bool) bool {
+	if n.Elem != nil && do(n.Elem) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *SliceType) editChildren(edit func(Node) Node) {
 	if n.Elem != nil {
@@ -1267,16 +1163,14 @@ func (n *StarExpr) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *StarExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *StarExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.X != nil {
-		if err := do(n.X); err != nil {
-			return err
-		}
+	if n.X != nil && do(n.X) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *StarExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -1291,16 +1185,14 @@ func (n *StructKeyExpr) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *StructKeyExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *StructKeyExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.Value != nil {
-		if err := do(n.Value); err != nil {
-			return err
-		}
+	if n.Value != nil && do(n.Value) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *StructKeyExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -1315,11 +1207,11 @@ func (n *StructType) copy() Node {
 	c.Fields = copyFields(c.Fields)
 	return &c
 }
-func (n *StructType) doChildren(do func(Node) error) error {
-	if err := doFields(n.Fields, do); err != nil {
-		return err
+func (n *StructType) doChildren(do func(Node) bool) bool {
+	if doFields(n.Fields, do) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *StructType) editChildren(edit func(Node) Node) {
 	editFields(n.Fields, edit)
@@ -1333,22 +1225,20 @@ func (n *SwitchStmt) copy() Node {
 	c.Compiled = copyNodes(c.Compiled)
 	return &c
 }
-func (n *SwitchStmt) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *SwitchStmt) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.Tag != nil {
-		if err := do(n.Tag); err != nil {
-			return err
-		}
+	if n.Tag != nil && do(n.Tag) {
+		return true
 	}
-	if err := doCaseClauses(n.Cases, do); err != nil {
-		return err
+	if doCaseClauses(n.Cases, do) {
+		return true
 	}
-	if err := doNodes(n.Compiled, do); err != nil {
-		return err
+	if doNodes(n.Compiled, do) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *SwitchStmt) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -1365,21 +1255,17 @@ func (n *TypeAssertExpr) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *TypeAssertExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *TypeAssertExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.X != nil {
-		if err := do(n.X); err != nil {
-			return err
-		}
+	if n.X != nil && do(n.X) {
+		return true
 	}
-	if n.Ntype != nil {
-		if err := do(n.Ntype); err != nil {
-			return err
-		}
+	if n.Ntype != nil && do(n.Ntype) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *TypeAssertExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -1396,18 +1282,14 @@ func (n *TypeSwitchGuard) copy() Node {
 	c := *n
 	return &c
 }
-func (n *TypeSwitchGuard) doChildren(do func(Node) error) error {
-	if n.Tag != nil {
-		if err := do(n.Tag); err != nil {
-			return err
-		}
+func (n *TypeSwitchGuard) doChildren(do func(Node) bool) bool {
+	if n.Tag != nil && do(n.Tag) {
+		return true
 	}
-	if n.X != nil {
-		if err := do(n.X); err != nil {
-			return err
-		}
+	if n.X != nil && do(n.X) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *TypeSwitchGuard) editChildren(edit func(Node) Node) {
 	if n.Tag != nil {
@@ -1424,16 +1306,14 @@ func (n *UnaryExpr) copy() Node {
 	c.init = copyNodes(c.init)
 	return &c
 }
-func (n *UnaryExpr) doChildren(do func(Node) error) error {
-	if err := doNodes(n.init, do); err != nil {
-		return err
+func (n *UnaryExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
 	}
-	if n.X != nil {
-		if err := do(n.X); err != nil {
-			return err
-		}
+	if n.X != nil && do(n.X) {
+		return true
 	}
-	return nil
+	return false
 }
 func (n *UnaryExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
@@ -1447,8 +1327,8 @@ func (n *typeNode) copy() Node {
 	c := *n
 	return &c
 }
-func (n *typeNode) doChildren(do func(Node) error) error {
-	return nil
+func (n *typeNode) doChildren(do func(Node) bool) bool {
+	return false
 }
 func (n *typeNode) editChildren(edit func(Node) Node) {
 }
@@ -1461,15 +1341,13 @@ func copyCaseClauses(list []*CaseClause) []*CaseClause {
 	copy(c, list)
 	return c
 }
-func doCaseClauses(list []*CaseClause, do func(Node) error) error {
+func doCaseClauses(list []*CaseClause, do func(Node) bool) bool {
 	for _, x := range list {
-		if x != nil {
-			if err := do(x); err != nil {
-				return err
-			}
+		if x != nil && do(x) {
+			return true
 		}
 	}
-	return nil
+	return false
 }
 func editCaseClauses(list []*CaseClause, edit func(Node) Node) {
 	for i, x := range list {
@@ -1487,15 +1365,13 @@ func copyCommClauses(list []*CommClause) []*CommClause {
 	copy(c, list)
 	return c
 }
-func doCommClauses(list []*CommClause, do func(Node) error) error {
+func doCommClauses(list []*CommClause, do func(Node) bool) bool {
 	for _, x := range list {
-		if x != nil {
-			if err := do(x); err != nil {
-				return err
-			}
+		if x != nil && do(x) {
+			return true
 		}
 	}
-	return nil
+	return false
 }
 func editCommClauses(list []*CommClause, edit func(Node) Node) {
 	for i, x := range list {
@@ -1513,15 +1389,13 @@ func copyNodes(list []Node) []Node {
 	copy(c, list)
 	return c
 }
-func doNodes(list []Node, do func(Node) error) error {
+func doNodes(list []Node, do func(Node) bool) bool {
 	for _, x := range list {
-		if x != nil {
-			if err := do(x); err != nil {
-				return err
-			}
+		if x != nil && do(x) {
+			return true
 		}
 	}
-	return nil
+	return false
 }
 func editNodes(list []Node, edit func(Node) Node) {
 	for i, x := range list {
diff --git a/src/cmd/compile/internal/ir/type.go b/src/cmd/compile/internal/ir/type.go
index 7dd394f9ea..a903ea8cd4 100644
--- a/src/cmd/compile/internal/ir/type.go
+++ b/src/cmd/compile/internal/ir/type.go
@@ -195,21 +195,17 @@ func copyField(f *Field) *Field {
 	c := *f
 	return &c
 }
-func doField(f *Field, do func(Node) error) error {
+func doField(f *Field, do func(Node) bool) bool {
 	if f == nil {
-		return nil
+		return false
 	}
-	if f.Decl != nil {
-		if err := do(f.Decl); err != nil {
-			return err
-		}
+	if f.Decl != nil && do(f.Decl) {
+		return true
 	}
-	if f.Ntype != nil {
-		if err := do(f.Ntype); err != nil {
-			return err
-		}
+	if f.Ntype != nil && do(f.Ntype) {
+		return true
 	}
-	return nil
+	return false
 }
 func editField(f *Field, edit func(Node) Node) {
 	if f == nil {
@@ -230,13 +226,13 @@ func copyFields(list []*Field) []*Field {
 	}
 	return out
 }
-func doFields(list []*Field, do func(Node) error) error {
+func doFields(list []*Field, do func(Node) bool) bool {
 	for _, x := range list {
-		if err := doField(x, do); err != nil {
-			return err
+		if doField(x, do) {
+			return true
 		}
 	}
-	return nil
+	return false
 }
 func editFields(list []*Field, edit func(Node) Node) {
 	for _, f := range list {
diff --git a/src/cmd/compile/internal/ir/visit.go b/src/cmd/compile/internal/ir/visit.go
index 4616390b7c..c1b3d4ed95 100644
--- a/src/cmd/compile/internal/ir/visit.go
+++ b/src/cmd/compile/internal/ir/visit.go
@@ -4,23 +4,18 @@
 
 // IR visitors for walking the IR tree.
 //
-// The lowest level helpers are DoChildren and EditChildren,
-// which nodes help implement (TODO(rsc): eventually) and
-// provide control over whether and when recursion happens
-// during the walk of the IR.
+// The lowest level helpers are DoChildren and EditChildren, which
+// nodes help implement and provide control over whether and when
+// recursion happens during the walk of the IR.
 //
 // Although these are both useful directly, two simpler patterns
-// are fairly common and also provided: Inspect and Scan.
+// are fairly common and also provided: Visit and Any.
 
 package ir
 
-import (
-	"errors"
-)
-
 // DoChildren calls do(x) on each of n's non-nil child nodes x.
-// If any call returns a non-nil error, DoChildren stops and returns that error.
-// Otherwise, DoChildren returns nil.
+// If any call returns true, DoChildren stops and returns true.
+// Otherwise, DoChildren returns false.
 //
 // Note that DoChildren(n, do) only calls do(x) for n's immediate children.
 // If x's children should be processed, then do(x) must call DoChildren(x, do).
@@ -28,32 +23,32 @@ import (
 // DoChildren allows constructing general traversals of the IR graph
 // that can stop early if needed. The most general usage is:
 //
-//	var do func(ir.Node) error
-//	do = func(x ir.Node) error {
+//	var do func(ir.Node) bool
+//	do = func(x ir.Node) bool {
 //		... processing BEFORE visting children ...
 //		if ... should visit children ... {
 //			ir.DoChildren(x, do)
 //			... processing AFTER visting children ...
 //		}
 //		if ... should stop parent DoChildren call from visiting siblings ... {
-//			return non-nil error
+//			return true
 //		}
-//		return nil
+//		return false
 //	}
 //	do(root)
 //
-// Since DoChildren does not generate any errors itself, if the do function
-// never wants to stop the traversal, it can assume that DoChildren itself
-// will always return nil, simplifying to:
+// Since DoChildren does not return true itself, if the do function
+// never wants to stop the traversal, it can assume that DoChildren
+// itself will always return false, simplifying to:
 //
-//	var do func(ir.Node) error
-//	do = func(x ir.Node) error {
+//	var do func(ir.Node) bool
+//	do = func(x ir.Node) bool {
 //		... processing BEFORE visting children ...
 //		if ... should visit children ... {
 //			ir.DoChildren(x, do)
 //		}
 //		... processing AFTER visting children ...
-//		return nil
+//		return false
 //	}
 //	do(root)
 //
@@ -61,14 +56,15 @@ import (
 // only processing before visiting children and never stopping:
 //
 //	func Visit(n ir.Node, visit func(ir.Node)) {
-//		var do func(ir.Node) error
-//		do = func(x ir.Node) error {
+//		if n == nil {
+//			return
+//		}
+//		var do func(ir.Node) bool
+//		do = func(x ir.Node) bool {
 //			visit(x)
 //			return ir.DoChildren(x, do)
 //		}
-//		if n != nil {
-//			visit(n)
-//		}
+//		do(n)
 //	}
 //
 // The Any function illustrates a different simplification of the pattern,
@@ -76,50 +72,40 @@ import (
 // a node x for which cond(x) returns true, at which point the entire
 // traversal stops and returns true.
 //
-//	func Any(n ir.Node, find cond(ir.Node)) bool {
-//		stop := errors.New("stop")
-//		var do func(ir.Node) error
-//		do = func(x ir.Node) error {
-//			if cond(x) {
-//				return stop
-//			}
-//			return ir.DoChildren(x, do)
+//	func Any(n ir.Node, cond(ir.Node) bool) bool {
+//		if n == nil {
+//			return false
 //		}
-//		return do(n) == stop
+//		var do func(ir.Node) bool
+//		do = func(x ir.Node) bool {
+//			return cond(x) || ir.DoChildren(x, do)
+//		}
+//		return do(n)
 //	}
 //
 // Visit and Any are presented above as examples of how to use
 // DoChildren effectively, but of course, usage that fits within the
 // simplifications captured by Visit or Any will be best served
 // by directly calling the ones provided by this package.
-func DoChildren(n Node, do func(Node) error) error {
+func DoChildren(n Node, do func(Node) bool) bool {
 	if n == nil {
-		return nil
+		return false
 	}
 	return n.doChildren(do)
 }
 
-// DoList calls f on each non-nil node x in the list, in list order.
-// If any call returns a non-nil error, DoList stops and returns that error.
-// Otherwise DoList returns nil.
-//
-// Note that DoList only calls do on the nodes in the list, not their children.
-// If x's children should be processed, do(x) must call DoChildren(x, do) itself.
-func DoList(list Nodes, do func(Node) error) error {
-	return doNodes(list, do)
-}
-
 // Visit visits each non-nil node x in the IR tree rooted at n
 // in a depth-first preorder traversal, calling visit on each node visited.
 func Visit(n Node, visit func(Node)) {
-	var do func(Node) error
-	do = func(x Node) error {
+	if n == nil {
+		return
+	}
+	var do func(Node) bool
+	do = func(x Node) bool {
 		visit(x)
 		return DoChildren(x, do)
 	}
-	if n != nil {
-		do(n)
-	}
+	do(n)
 }
 
 // VisitList calls Visit(x, visit) for each node x in the list.
@@ -129,8 +115,6 @@ func VisitList(list Nodes, visit func(Node)) {
 	}
 }
 
-var stop = errors.New("stop")
-
 // Any looks for a non-nil node x in the IR tree rooted at n
 // for which cond(x) returns true.
 // Any considers nodes in a depth-first, preorder traversal.
@@ -141,14 +125,11 @@ func Any(n Node, cond func(Node) bool) bool {
 	if n == nil {
 		return false
 	}
-	var do func(Node) error
-	do = func(x Node) error {
-		if cond(x) {
-			return stop
-		}
-		return DoChildren(x, do)
+	var do func(Node) bool
+	do = func(x Node) bool {
+		return cond(x) || DoChildren(x, do)
 	}
-	return do(n) == stop
+	return do(n)
 }
 
 // AnyList calls Any(x, cond) for each node x in the list, in order.
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 480d2de8e3..ebdcc4a72e 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -2053,8 +2053,8 @@ func markBreak(fn *ir.Func) {
 	var labels map[*types.Sym]ir.Node
 	var implicit ir.Node
 
-	var mark func(ir.Node) error
-	mark = func(n ir.Node) error {
+	var mark func(ir.Node) bool
+	mark = func(n ir.Node) bool {
 		switch n.Op() {
 		default:
 			ir.DoChildren(n, mark)
@@ -2094,7 +2094,7 @@ func markBreak(fn *ir.Func) {
 			}
 			implicit = old
 		}
-		return nil
+		return false
 	}
 
 	mark(fn)
-- 
GitLab


From 0c1a899a6c61dc59032ead0602d1cc6b918f7669 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 26 Dec 2020 01:06:03 -0800
Subject: [PATCH 0387/2400] [dev.regabi] cmd/compile: fix defined-pointer
 method call check

The compiler has logic to check whether we implicitly dereferenced a
defined pointer while trying to select a method. However, rather than
checking whether there were any implicit dereferences of a defined
pointer, it was finding the innermost dereference/selector expression
and checking whether that was dereferencing a named pointer. Moreover,
it was only checking defined pointer declared in the package block.

This CL restructures the code to match go/types and gccgo's behavior.

Fixes #43384.

Change-Id: I7bddfe2515776d9480eb2c7286023d4c15423888
Reviewed-on: https://go-review.googlesource.com/c/go/+/280392
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 .../compile/internal/typecheck/typecheck.go   |  31 +++--
 test/fixedbugs/issue43384.go                  | 124 ++++++++++++++++++
 2 files changed, 144 insertions(+), 11 deletions(-)
 create mode 100644 test/fixedbugs/issue43384.go

diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index ebdcc4a72e..b79739bfeb 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -1328,6 +1328,7 @@ func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 			// Already in the process of diagnosing an error.
 			return f2
 		}
+		orig := n.X
 		tt := n.X.Type()
 		types.CalcSize(tt)
 		rcvr := f2.Type.Recv().Type
@@ -1358,20 +1359,28 @@ func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 			}
 		}
 
-		implicit, ll := n.Implicit(), n.X
-		for ll != nil && (ll.Op() == ir.ODOT || ll.Op() == ir.ODOTPTR || ll.Op() == ir.ODEREF) {
-			switch l := ll.(type) {
+		// Check that we haven't implicitly dereferenced any defined pointer types.
+		for x := n.X; ; {
+			var inner ir.Node
+			implicit := false
+			switch x := x.(type) {
+			case *ir.AddrExpr:
+				inner, implicit = x.X, x.Implicit()
 			case *ir.SelectorExpr:
-				implicit, ll = l.Implicit(), l.X
+				inner, implicit = x.X, x.Implicit()
 			case *ir.StarExpr:
-				implicit, ll = l.Implicit(), l.X
+				inner, implicit = x.X, x.Implicit()
 			}
-		}
-		if implicit && ll.Type().IsPtr() && ll.Type().Sym() != nil && ll.Type().Sym().Def != nil && ir.AsNode(ll.Type().Sym().Def).Op() == ir.OTYPE {
-			// It is invalid to automatically dereference a named pointer type when selecting a method.
-			// Make n.Left == ll to clarify error message.
-			n.X = ll
-			return nil
+			if !implicit {
+				break
+			}
+			if inner.Type().Sym() != nil && (x.Op() == ir.ODEREF || x.Op() == ir.ODOTPTR) {
+				// Found an implicit dereference of a defined pointer type.
+				// Restore n.X for better error message.
+				n.X = orig
+				return nil
+			}
+			x = inner
 		}
 
 		n.Selection = f2
diff --git a/test/fixedbugs/issue43384.go b/test/fixedbugs/issue43384.go
new file mode 100644
index 0000000000..1bd793ba95
--- /dev/null
+++ b/test/fixedbugs/issue43384.go
@@ -0,0 +1,124 @@
+// errorcheck
+
+// Copyright 2020 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 p
+
+type T int
+
+func (T) Mv()  {}
+func (*T) Mp() {}
+
+type P1 struct{ T }
+type P2 struct{ *T }
+type P3 *struct{ T }
+type P4 *struct{ *T }
+
+func _() {
+	{
+		var p P1
+		p.Mv()
+		(&p).Mv()
+		(*&p).Mv()
+		p.Mp()
+		(&p).Mp()
+		(*&p).Mp()
+	}
+	{
+		var p P2
+		p.Mv()
+		(&p).Mv()
+		(*&p).Mv()
+		p.Mp()
+		(&p).Mp()
+		(*&p).Mp()
+	}
+	{
+		var p P3
+		p.Mv()     // ERROR "undefined"
+		(&p).Mv()  // ERROR "undefined"
+		(*&p).Mv() // ERROR "undefined"
+		(**&p).Mv()
+		(*p).Mv()
+		(&*p).Mv()
+		p.Mp()     // ERROR "undefined"
+		(&p).Mp()  // ERROR "undefined"
+		(*&p).Mp() // ERROR "undefined"
+		(**&p).Mp()
+		(*p).Mp()
+		(&*p).Mp()
+	}
+	{
+		var p P4
+		p.Mv()     // ERROR "undefined"
+		(&p).Mv()  // ERROR "undefined"
+		(*&p).Mv() // ERROR "undefined"
+		(**&p).Mv()
+		(*p).Mv()
+		(&*p).Mv()
+		p.Mp()     // ERROR "undefined"
+		(&p).Mp()  // ERROR "undefined"
+		(*&p).Mp() // ERROR "undefined"
+		(**&p).Mp()
+		(*p).Mp()
+		(&*p).Mp()
+	}
+}
+
+func _() {
+	type P5 struct{ T }
+	type P6 struct{ *T }
+	type P7 *struct{ T }
+	type P8 *struct{ *T }
+
+	{
+		var p P5
+		p.Mv()
+		(&p).Mv()
+		(*&p).Mv()
+		p.Mp()
+		(&p).Mp()
+		(*&p).Mp()
+	}
+	{
+		var p P6
+		p.Mv()
+		(&p).Mv()
+		(*&p).Mv()
+		p.Mp()
+		(&p).Mp()
+		(*&p).Mp()
+	}
+	{
+		var p P7
+		p.Mv()     // ERROR "undefined"
+		(&p).Mv()  // ERROR "undefined"
+		(*&p).Mv() // ERROR "undefined"
+		(**&p).Mv()
+		(*p).Mv()
+		(&*p).Mv()
+		p.Mp()     // ERROR "undefined"
+		(&p).Mp()  // ERROR "undefined"
+		(*&p).Mp() // ERROR "undefined"
+		(**&p).Mp()
+		(*p).Mp()
+		(&*p).Mp()
+	}
+	{
+		var p P8
+		p.Mv()     // ERROR "undefined"
+		(&p).Mv()  // ERROR "undefined"
+		(*&p).Mv() // ERROR "undefined"
+		(**&p).Mv()
+		(*p).Mv()
+		(&*p).Mv()
+		p.Mp()     // ERROR "undefined"
+		(&p).Mp()  // ERROR "undefined"
+		(*&p).Mp() // ERROR "undefined"
+		(**&p).Mp()
+		(*p).Mp()
+		(&*p).Mp()
+	}
+}
-- 
GitLab


From 451693af71a9d64f7f71a311d7076c8545672f88 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 29 Dec 2020 03:34:57 -0800
Subject: [PATCH 0388/2400] [dev.regabi] cmd/compile: simplify typecheckdef

Reorganize code to be a little clearer. Also allows tightening
typecheckdefstack from []ir.Node to []*ir.Name.

Passes toolstash -cmp.

Change-Id: I43df1a5e2a72dd3423b132d3afe363bf76700269
Reviewed-on: https://go-review.googlesource.com/c/go/+/280649
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 .../compile/internal/typecheck/typecheck.go   | 83 ++++++++-----------
 1 file changed, 36 insertions(+), 47 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index b79739bfeb..cf9b48f5a6 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -246,7 +246,7 @@ const (
 // marks variables that escape the local frame.
 // rewrites n.Op to be more specific in some cases.
 
-var typecheckdefstack []ir.Node
+var typecheckdefstack []*ir.Name
 
 // Resolve ONONAME to definition, if any.
 func Resolve(n ir.Node) (res ir.Node) {
@@ -584,24 +584,9 @@ func indexlit(n ir.Node) ir.Node {
 // typecheck1 should ONLY be called from typecheck.
 func typecheck1(n ir.Node, top int) ir.Node {
 	switch n.Op() {
-	case ir.OLITERAL, ir.ONAME, ir.ONONAME, ir.OTYPE:
-		if n.Sym() == nil {
-			return n
-		}
-
-		if n.Op() == ir.ONAME {
-			n := n.(*ir.Name)
-			if n.BuiltinOp != 0 && top&ctxCallee == 0 {
-				base.Errorf("use of builtin %v not in function call", n.Sym())
-				n.SetType(nil)
-				return n
-			}
-		}
-
-		typecheckdef(n)
-		if n.Op() == ir.ONONAME {
-			n.SetType(nil)
-			return n
+	case ir.OLITERAL, ir.ONAME, ir.OTYPE:
+		if n.Sym() != nil {
+			typecheckdef(n)
 		}
 	}
 
@@ -611,22 +596,37 @@ func typecheck1(n ir.Node, top int) ir.Node {
 		base.Fatalf("typecheck %v", n.Op())
 		panic("unreachable")
 
-	// names
 	case ir.OLITERAL:
-		if n.Type() == nil && n.Val().Kind() == constant.String {
-			base.Fatalf("string literal missing type")
+		if n.Sym() == nil && n.Type() == nil {
+			base.Fatalf("literal missing type: %v", n)
 		}
 		return n
 
-	case ir.ONIL, ir.ONONAME:
+	case ir.ONIL:
+		return n
+
+	// names
+	case ir.ONONAME:
+		if !n.Diag() {
+			// Note: adderrorname looks for this string and
+			// adds context about the outer expression
+			base.ErrorfAt(n.Pos(), "undefined: %v", n.Sym())
+			n.SetDiag(true)
+		}
+		n.SetType(nil)
 		return n
 
 	case ir.ONAME:
 		n := n.(*ir.Name)
-		if n.Name().Decldepth == 0 {
-			n.Name().Decldepth = decldepth
+		if n.Decldepth == 0 {
+			n.Decldepth = decldepth
 		}
 		if n.BuiltinOp != 0 {
+			if top&ctxCallee == 0 {
+				base.Errorf("use of builtin %v not in function call", n.Sym())
+				n.SetType(nil)
+				return n
+			}
 			return n
 		}
 		if top&ctxAssign == 0 {
@@ -652,9 +652,6 @@ func typecheck1(n ir.Node, top int) ir.Node {
 
 	// types (ODEREF is with exprs)
 	case ir.OTYPE:
-		if n.Type() == nil {
-			return n
-		}
 		return n
 
 	case ir.OTSLICE:
@@ -1852,26 +1849,22 @@ func typecheckdef(n ir.Node) {
 		defer tracePrint("typecheckdef", n)(nil)
 	}
 
-	lno := ir.SetPos(n)
-
-	if n.Op() == ir.ONONAME {
-		if !n.Diag() {
-			n.SetDiag(true)
-
-			// Note: adderrorname looks for this string and
-			// adds context about the outer expression
-			base.ErrorfAt(base.Pos, "undefined: %v", n.Sym())
-		}
-		base.Pos = lno
+	if n.Walkdef() == 1 {
 		return
 	}
 
-	if n.Walkdef() == 1 {
-		base.Pos = lno
+	if n.Type() != nil { // builtin
+		// Mark as Walkdef so that if n.SetType(nil) is called later, we
+		// won't try walking again.
+		if got := n.Walkdef(); got != 0 {
+			base.Fatalf("unexpected walkdef: %v", got)
+		}
+		n.SetWalkdef(1)
 		return
 	}
 
-	typecheckdefstack = append(typecheckdefstack, n)
+	lno := ir.SetPos(n)
+	typecheckdefstack = append(typecheckdefstack, n.(*ir.Name))
 	if n.Walkdef() == 2 {
 		base.FlushErrors()
 		fmt.Printf("typecheckdef loop:")
@@ -1885,10 +1878,6 @@ func typecheckdef(n ir.Node) {
 
 	n.SetWalkdef(2)
 
-	if n.Type() != nil || n.Sym() == nil { // builtin or no name
-		goto ret
-	}
-
 	switch n.Op() {
 	default:
 		base.Fatalf("typecheckdef %v", n.Op())
@@ -2367,7 +2356,7 @@ func deadcodeexpr(n ir.Node) ir.Node {
 func getIotaValue() int64 {
 	if i := len(typecheckdefstack); i > 0 {
 		if x := typecheckdefstack[i-1]; x.Op() == ir.OLITERAL {
-			return x.(*ir.Name).Iota()
+			return x.Iota()
 		}
 	}
 
-- 
GitLab


From f0d99def5b8919292a76b19dfdaf601e25dc6157 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Tue, 29 Dec 2020 10:08:30 -0800
Subject: [PATCH 0389/2400] [dev.regabi] cmd/compile: add newline to ir.Dump

If you do two ir.Dumps in a row, there's no newline between them.

Change-Id: I1a80dd22da68cb677eb9abd7a50571ea33584010
Reviewed-on: https://go-review.googlesource.com/c/go/+/280672
Trust: Keith Randall <khr@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/fmt.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index ea6b5856df..6209702291 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -978,7 +978,7 @@ func (l Nodes) Format(s fmt.State, verb rune) {
 
 // Dump prints the message s followed by a debug dump of n.
 func Dump(s string, n Node) {
-	fmt.Printf("%s [%p]%+v", s, n, n)
+	fmt.Printf("%s [%p]%+v\n", s, n, n)
 }
 
 // DumpList prints the message s followed by a debug dump of each node in the list.
-- 
GitLab


From 178c667db2858f52965609b24857d5448dfb12c4 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Tue, 29 Dec 2020 10:07:38 -0800
Subject: [PATCH 0390/2400] [dev.regabi] cmd/compile: fix OSLICEARR comments

Change-Id: Ia6e734977a2cd80c91c28f4525be403f062dccc6
Reviewed-on: https://go-review.googlesource.com/c/go/+/280651
Trust: Keith Randall <khr@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/node.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 0d56b5aeb8..9536503085 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -218,10 +218,10 @@ const (
 	OPAREN       // (Left)
 	OSEND        // Left <- Right
 	OSLICE       // Left[List[0] : List[1]] (Left is untypechecked or slice)
-	OSLICEARR    // Left[List[0] : List[1]] (Left is array)
+	OSLICEARR    // Left[List[0] : List[1]] (Left is pointer to array)
 	OSLICESTR    // Left[List[0] : List[1]] (Left is string)
 	OSLICE3      // Left[List[0] : List[1] : List[2]] (Left is untypedchecked or slice)
-	OSLICE3ARR   // Left[List[0] : List[1] : List[2]] (Left is array)
+	OSLICE3ARR   // Left[List[0] : List[1] : List[2]] (Left is pointer to array)
 	OSLICEHEADER // sliceheader{Left, List[0], List[1]} (Left is unsafe.Pointer, List[0] is length, List[1] is capacity)
 	ORECOVER     // recover()
 	ORECV        // <-Left
-- 
GitLab


From 477b049060966e90124edf950413575f84a9aa74 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 30 Dec 2020 18:43:10 -0800
Subject: [PATCH 0391/2400] [dev.regabi] cmd/compile: fix printing of method
 expressions

OTYPE and OMETHEXPR were missing from OpPrec. So add them with the
same precedences as OT{ARRAY,MAP,STRUCT,etc} and
ODOT{,METH,INTER,etc}, respectively. However, ODEREF (which is also
used for pointer types *T) has a lower precedence than other types, so
pointer types need to be specially handled to assign them their
correct, lower precedence.

Incidentally, this also improves the error messages in issue15055.go,
where we were adding unnecessary parentheses around the types in
conversion expressions.

Thanks to Cuong Manh Le for writing the test cases for #43428.

Fixes #43428.

Change-Id: I57e7979babe3ed9ef8a8b5a2a3745e3737dd785f
Reviewed-on: https://go-review.googlesource.com/c/go/+/280873
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/ir/fmt.go |  6 ++++--
 test/fixedbugs/issue15055.go       |  8 +++++---
 test/fixedbugs/issue43428.go       | 25 +++++++++++++++++++++++++
 3 files changed, 34 insertions(+), 5 deletions(-)
 create mode 100644 test/fixedbugs/issue43428.go

diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 6209702291..92ea160a28 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -216,6 +216,7 @@ var OpPrec = []int{
 	OTINTER:        8,
 	OTMAP:          8,
 	OTSTRUCT:       8,
+	OTYPE:          8,
 	OINDEXMAP:      8,
 	OINDEX:         8,
 	OSLICE:         8,
@@ -232,6 +233,7 @@ var OpPrec = []int{
 	ODOT:           8,
 	OXDOT:          8,
 	OCALLPART:      8,
+	OMETHEXPR:      8,
 	OPLUS:          7,
 	ONOT:           7,
 	OBITNOT:        7,
@@ -551,8 +553,8 @@ func exprFmt(n Node, s fmt.State, prec int) {
 	}
 
 	nprec := OpPrec[n.Op()]
-	if n.Op() == OTYPE && n.Sym() != nil {
-		nprec = 8
+	if n.Op() == OTYPE && n.Type().IsPtr() {
+		nprec = OpPrec[ODEREF]
 	}
 
 	if prec > nprec {
diff --git a/test/fixedbugs/issue15055.go b/test/fixedbugs/issue15055.go
index e58047e411..33cf63aaad 100644
--- a/test/fixedbugs/issue15055.go
+++ b/test/fixedbugs/issue15055.go
@@ -8,10 +8,12 @@ package main
 
 func main() {
 	type name string
-	_ = []byte("abc", "def", 12)    // ERROR "too many arguments to conversion to \[\]byte: \(\[\]byte\)\(.abc., .def., 12\)"
+	_ = []byte("abc", "def", 12)    // ERROR "too many arguments to conversion to \[\]byte: \[\]byte\(.abc., .def., 12\)"
 	_ = string("a", "b", nil)       // ERROR "too many arguments to conversion to string: string\(.a., .b., nil\)"
-	_ = []byte()                    // ERROR "missing argument to conversion to \[\]byte: \(\[\]byte\)\(\)"
+	_ = []byte()                    // ERROR "missing argument to conversion to \[\]byte: \[\]byte\(\)"
 	_ = string()                    // ERROR "missing argument to conversion to string: string\(\)"
+	_ = *int()                      // ERROR "missing argument to conversion to int: int\(\)"
+	_ = (*int)()                    // ERROR "missing argument to conversion to \*int: \(\*int\)\(\)"
 	_ = name("a", 1, 3.3)           // ERROR "too many arguments to conversion to name: name\(.a., 1, 3.3\)"
-	_ = map[string]string(nil, nil) // ERROR "too many arguments to conversion to map\[string\]string: \(map\[string\]string\)\(nil, nil\)"
+	_ = map[string]string(nil, nil) // ERROR "too many arguments to conversion to map\[string\]string: map\[string\]string\(nil, nil\)"
 }
diff --git a/test/fixedbugs/issue43428.go b/test/fixedbugs/issue43428.go
new file mode 100644
index 0000000000..773a3f3516
--- /dev/null
+++ b/test/fixedbugs/issue43428.go
@@ -0,0 +1,25 @@
+// errorcheck
+
+// Copyright 2020 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 p
+
+import "time"
+
+type T int
+
+func (T) Mv()  {}
+func (*T) Mp() {}
+
+var _ = []int{
+	T.Mv,    // ERROR "cannot use T\.Mv|incompatible type"
+	(*T).Mv, // ERROR "cannot use \(\*T\)\.Mv|incompatible type"
+	(*T).Mp, // ERROR "cannot use \(\*T\)\.Mp|incompatible type"
+
+	time.Time.GobEncode,    // ERROR "cannot use time\.Time\.GobEncode|incompatible type"
+	(*time.Time).GobEncode, // ERROR "cannot use \(\*time\.Time\)\.GobEncode|incompatible type"
+	(*time.Time).GobDecode, // ERROR "cannot use \(\*time\.Time\)\.GobDecode|incompatible type"
+
+}
-- 
GitLab


From 8fe119765404d29c5efe0fb86afebfa523f83a7f Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Wed, 30 Dec 2020 14:52:50 +0700
Subject: [PATCH 0392/2400] [dev.regabi] cmd/compile: remove Name.orig

Passes toolstash -cmp.

Change-Id: Ie563ece7e4da14af46adc660b3d39757eb47c067
Reviewed-on: https://go-review.googlesource.com/c/go/+/280734
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/name.go        | 4 +---
 src/cmd/compile/internal/ir/sizeof_test.go | 2 +-
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 697b04f541..c79b7e52e5 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -44,8 +44,7 @@ type Name struct {
 	Offset_   int64
 	val       constant.Value
 	Opt       interface{} // for use by escape analysis
-	orig      Node
-	Embed     *[]Embed // list of embedded files, for ONAME var
+	Embed     *[]Embed    // list of embedded files, for ONAME var
 
 	PkgName *PkgName // real package for import . names
 	// For a local variable (not param) or extern, the initializing assignment (OAS or OAS2).
@@ -219,7 +218,6 @@ func newNameAt(pos src.XPos, op Op, sym *types.Sym) *Name {
 	n := new(Name)
 	n.op = op
 	n.pos = pos
-	n.orig = n
 	n.sym = sym
 	return n
 }
diff --git a/src/cmd/compile/internal/ir/sizeof_test.go b/src/cmd/compile/internal/ir/sizeof_test.go
index 61f207af20..8f5fae8a12 100644
--- a/src/cmd/compile/internal/ir/sizeof_test.go
+++ b/src/cmd/compile/internal/ir/sizeof_test.go
@@ -21,7 +21,7 @@ func TestSizeof(t *testing.T) {
 		_64bit uintptr     // size on 64bit platforms
 	}{
 		{Func{}, 196, 344},
-		{Name{}, 132, 232},
+		{Name{}, 124, 216},
 	}
 
 	for _, tt := range tests {
-- 
GitLab


From 77fd81a3e6c4aa248df135cc24be2871689cc7c3 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Wed, 30 Dec 2020 14:08:44 +0700
Subject: [PATCH 0393/2400] [dev.regabi] cmd/compile: use names for keep alive
 variables in function call

Back to pre Russquake, Node.Nbody of OCALL* node is used to attach
variables which must be kept alive during that call.

Now after Russquake, we have CallExpr to represent a function call,
so use a dedicated field for those variables instead.

Passes toolstash -cmp.

Change-Id: I4f40ebefcc7c41cdcc4e29c7a6d8496a083b68f4
Reviewed-on: https://go-review.googlesource.com/c/go/+/280733
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/expr.go     | 14 ++++++------
 src/cmd/compile/internal/ir/node_gen.go | 30 ++++++++++++++++++++++---
 src/cmd/compile/internal/ssagen/ssa.go  |  4 +++-
 src/cmd/compile/internal/walk/order.go  |  2 +-
 src/cmd/compile/internal/walk/stmt.go   |  2 +-
 5 files changed, 39 insertions(+), 13 deletions(-)

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 55e4b61baf..f435a5bb26 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -159,13 +159,13 @@ const (
 type CallExpr struct {
 	miniExpr
 	origNode
-	X        Node
-	Args     Nodes
-	Rargs    Nodes // TODO(rsc): Delete.
-	Body     Nodes // TODO(rsc): Delete.
-	IsDDD    bool
-	Use      CallUse
-	NoInline bool
+	X         Node
+	Args      Nodes
+	Rargs     Nodes   // TODO(rsc): Delete.
+	KeepAlive []*Name // vars to be kept alive until call returns
+	IsDDD     bool
+	Use       CallUse
+	NoInline  bool
 }
 
 func NewCallExpr(pos src.XPos, op Op, fun Node, args []Node) *CallExpr {
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index 65c0b239ed..7f494b16cd 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -251,7 +251,7 @@ func (n *CallExpr) copy() Node {
 	c.init = copyNodes(c.init)
 	c.Args = copyNodes(c.Args)
 	c.Rargs = copyNodes(c.Rargs)
-	c.Body = copyNodes(c.Body)
+	c.KeepAlive = copyNames(c.KeepAlive)
 	return &c
 }
 func (n *CallExpr) doChildren(do func(Node) bool) bool {
@@ -267,7 +267,7 @@ func (n *CallExpr) doChildren(do func(Node) bool) bool {
 	if doNodes(n.Rargs, do) {
 		return true
 	}
-	if doNodes(n.Body, do) {
+	if doNames(n.KeepAlive, do) {
 		return true
 	}
 	return false
@@ -279,7 +279,7 @@ func (n *CallExpr) editChildren(edit func(Node) Node) {
 	}
 	editNodes(n.Args, edit)
 	editNodes(n.Rargs, edit)
-	editNodes(n.Body, edit)
+	editNames(n.KeepAlive, edit)
 }
 
 func (n *CaseClause) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
@@ -1381,6 +1381,30 @@ func editCommClauses(list []*CommClause, edit func(Node) Node) {
 	}
 }
 
+func copyNames(list []*Name) []*Name {
+	if list == nil {
+		return nil
+	}
+	c := make([]*Name, len(list))
+	copy(c, list)
+	return c
+}
+func doNames(list []*Name, do func(Node) bool) bool {
+	for _, x := range list {
+		if x != nil && do(x) {
+			return true
+		}
+	}
+	return false
+}
+func editNames(list []*Name, edit func(Node) Node) {
+	for i, x := range list {
+		if x != nil {
+			list[i] = edit(x).(*Name)
+		}
+	}
+}
+
 func copyNodes(list []Node) []Node {
 	if list == nil {
 		return nil
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index ddf65eb209..022959a934 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -4867,7 +4867,9 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		s.vars[memVar] = call
 	}
 	// Insert OVARLIVE nodes
-	s.stmtList(n.Body)
+	for _, name := range n.KeepAlive {
+		s.stmt(ir.NewUnaryExpr(n.Pos(), ir.OVARLIVE, name))
+	}
 
 	// Finish block for defers
 	if k == callDefer || k == callDeferStack {
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index b3d2eaec17..681f5dcc76 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -518,7 +518,7 @@ func (o *orderState) call(nn ir.Node) {
 				x := o.copyExpr(arg.X)
 				arg.X = x
 				x.Name().SetAddrtaken(true) // ensure SSA keeps the x variable
-				n.Body.Append(typecheck.Stmt(ir.NewUnaryExpr(base.Pos, ir.OVARLIVE, x)))
+				n.KeepAlive = append(n.KeepAlive, x.(*ir.Name))
 			}
 		}
 	}
diff --git a/src/cmd/compile/internal/walk/stmt.go b/src/cmd/compile/internal/walk/stmt.go
index f843d2c4fa..cfd1da46d2 100644
--- a/src/cmd/compile/internal/walk/stmt.go
+++ b/src/cmd/compile/internal/walk/stmt.go
@@ -228,7 +228,7 @@ func walkGoDefer(n *ir.GoDeferStmt) ir.Node {
 
 	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
 		call := call.(*ir.CallExpr)
-		if len(call.Body) > 0 {
+		if len(call.KeepAlive) > 0 {
 			n.Call = wrapCall(call, &init)
 		} else {
 			n.Call = walkExpr(call, &init)
-- 
GitLab


From dfbcff80c65991e90b7a06a09e4399f7725356dc Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Thu, 31 Dec 2020 16:51:12 +0700
Subject: [PATCH 0394/2400] [dev.regabi] cmd/compile: make copyExpr return
 *ir.Name directly

copyExpr just calls copyExpr1 with "clear" is false, so make it return
*ir.Name directly instead of ir.Node

Passes toolstash -cmp.

Change-Id: I31ca1d88d9eaf8ac37517022f1c74285ffce07d3
Reviewed-on: https://go-review.googlesource.com/c/go/+/280714
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/walk/order.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index 681f5dcc76..a2bd0cf10a 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -102,7 +102,7 @@ func (o *orderState) newTemp(t *types.Type, clear bool) *ir.Name {
 
 // copyExpr behaves like newTemp but also emits
 // code to initialize the temporary to the value n.
-func (o *orderState) copyExpr(n ir.Node) ir.Node {
+func (o *orderState) copyExpr(n ir.Node) *ir.Name {
 	return o.copyExpr1(n, false)
 }
 
@@ -518,7 +518,7 @@ func (o *orderState) call(nn ir.Node) {
 				x := o.copyExpr(arg.X)
 				arg.X = x
 				x.Name().SetAddrtaken(true) // ensure SSA keeps the x variable
-				n.KeepAlive = append(n.KeepAlive, x.(*ir.Name))
+				n.KeepAlive = append(n.KeepAlive, x)
 			}
 		}
 	}
-- 
GitLab


From fd22df990545bce77ff78b27c4f7220c7a666a84 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 31 Dec 2020 18:25:35 -0800
Subject: [PATCH 0395/2400] [dev.regabi] cmd/compile: remove idempotent Name()
 calls [generated]

[git-generate]
cd src/cmd/compile/internal/ir
pkgs=$(grep -l -w Name ../*/*.go | xargs dirname | sort -u | grep -v '/ir$')
rf '
	ex . '"$(echo $pkgs)"' {
		var n *Name
		n.Name() -> n
	}
'

Change-Id: I6bfce6417a6dba833d2f652ae212a32c11bc5ef6
Reviewed-on: https://go-review.googlesource.com/c/go/+/280972
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/dwarfgen/dwarf.go    | 22 +++++++--------
 src/cmd/compile/internal/escape/escape.go     |  2 +-
 src/cmd/compile/internal/gc/obj.go            |  4 +--
 src/cmd/compile/internal/ir/expr.go           |  4 +--
 src/cmd/compile/internal/ir/name.go           |  4 +--
 src/cmd/compile/internal/liveness/plive.go    | 14 +++++-----
 src/cmd/compile/internal/noder/noder.go       |  6 ++--
 src/cmd/compile/internal/pkginit/initorder.go |  2 +-
 src/cmd/compile/internal/ssagen/nowb.go       |  4 +--
 src/cmd/compile/internal/ssagen/pgen.go       |  6 ++--
 src/cmd/compile/internal/ssagen/ssa.go        |  4 +--
 src/cmd/compile/internal/typecheck/func.go    |  6 ++--
 src/cmd/compile/internal/typecheck/iexport.go |  4 +--
 .../compile/internal/typecheck/typecheck.go   | 28 +++++++++----------
 src/cmd/compile/internal/walk/expr.go         |  2 +-
 src/cmd/compile/internal/walk/order.go        |  4 +--
 src/cmd/compile/internal/walk/stmt.go         |  2 +-
 17 files changed, 59 insertions(+), 59 deletions(-)

diff --git a/src/cmd/compile/internal/dwarfgen/dwarf.go b/src/cmd/compile/internal/dwarfgen/dwarf.go
index d0bee58442..42c83b1f23 100644
--- a/src/cmd/compile/internal/dwarfgen/dwarf.go
+++ b/src/cmd/compile/internal/dwarfgen/dwarf.go
@@ -127,7 +127,7 @@ func Info(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.Scope,
 }
 
 func declPos(decl *ir.Name) src.XPos {
-	if decl.Name().Defn != nil && (decl.Name().Captured() || decl.Name().Byval()) {
+	if decl.Defn != nil && (decl.Captured() || decl.Byval()) {
 		// It's not clear which position is correct for captured variables here:
 		// * decl.Pos is the wrong position for captured variables, in the inner
 		//   function, but it is the right position in the outer function.
@@ -142,7 +142,7 @@ func declPos(decl *ir.Name) src.XPos {
 		//   case statement.
 		// This code is probably wrong for type switch variables that are also
 		// captured.
-		return decl.Name().Defn.Pos()
+		return decl.Defn.Pos()
 	}
 	return decl.Pos()
 }
@@ -211,7 +211,7 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 			// misleading location for the param (we want pointer-to-heap
 			// and not stack).
 			// TODO(thanm): generate a better location expression
-			stackcopy := n.Name().Stackcopy
+			stackcopy := n.Stackcopy
 			if stackcopy != nil && (stackcopy.Class_ == ir.PPARAM || stackcopy.Class_ == ir.PPARAMOUT) {
 				abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
 				isReturnValue = (stackcopy.Class_ == ir.PPARAMOUT)
@@ -219,9 +219,9 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 		}
 		inlIndex := 0
 		if base.Flag.GenDwarfInl > 1 {
-			if n.Name().InlFormal() || n.Name().InlLocal() {
+			if n.InlFormal() || n.InlLocal() {
 				inlIndex = posInlIndex(n.Pos()) + 1
-				if n.Name().InlFormal() {
+				if n.InlFormal() {
 					abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
 				}
 			}
@@ -312,9 +312,9 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 	delete(fnsym.Func().Autot, reflectdata.TypeLinksym(n.Type()))
 	inlIndex := 0
 	if base.Flag.GenDwarfInl > 1 {
-		if n.Name().InlFormal() || n.Name().InlLocal() {
+		if n.InlFormal() || n.InlLocal() {
 			inlIndex = posInlIndex(n.Pos()) + 1
-			if n.Name().InlFormal() {
+			if n.InlFormal() {
 				abbrev = dwarf.DW_ABRV_PARAM
 			}
 		}
@@ -323,7 +323,7 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 	return &dwarf.Var{
 		Name:          n.Sym().Name,
 		IsReturnValue: n.Class_ == ir.PPARAMOUT,
-		IsInlFormal:   n.Name().InlFormal(),
+		IsInlFormal:   n.InlFormal(),
 		Abbrev:        abbrev,
 		StackOffset:   int32(offs),
 		Type:          base.Ctxt.Lookup(typename),
@@ -381,9 +381,9 @@ func createComplexVar(fnsym *obj.LSym, fn *ir.Func, varID ssa.VarID) *dwarf.Var
 	typename := dwarf.InfoPrefix + gotype.Name[len("type."):]
 	inlIndex := 0
 	if base.Flag.GenDwarfInl > 1 {
-		if n.Name().InlFormal() || n.Name().InlLocal() {
+		if n.InlFormal() || n.InlLocal() {
 			inlIndex = posInlIndex(n.Pos()) + 1
-			if n.Name().InlFormal() {
+			if n.InlFormal() {
 				abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
 			}
 		}
@@ -392,7 +392,7 @@ func createComplexVar(fnsym *obj.LSym, fn *ir.Func, varID ssa.VarID) *dwarf.Var
 	dvar := &dwarf.Var{
 		Name:          n.Sym().Name,
 		IsReturnValue: n.Class_ == ir.PPARAMOUT,
-		IsInlFormal:   n.Name().InlFormal(),
+		IsInlFormal:   n.InlFormal(),
 		Abbrev:        abbrev,
 		Type:          base.Ctxt.Lookup(typename),
 		// The stack offset is used as a sorting key, so for decomposed
diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index b5b09beb5a..98dbf54b75 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -1158,7 +1158,7 @@ func (e *escape) newLoc(n ir.Node, transient bool) *location {
 		if n.Op() == ir.ONAME {
 			n := n.(*ir.Name)
 			if n.Curfn != e.curfn {
-				base.Fatalf("curfn mismatch: %v != %v", n.Name().Curfn, e.curfn)
+				base.Fatalf("curfn mismatch: %v != %v", n.Curfn, e.curfn)
 			}
 
 			if n.Opt != nil {
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 1e8ac8ebb2..30cfac1b71 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -264,14 +264,14 @@ func ggloblnod(nam *ir.Name) {
 	s := nam.Linksym()
 	s.Gotype = reflectdata.TypeLinksym(nam.Type())
 	flags := 0
-	if nam.Name().Readonly() {
+	if nam.Readonly() {
 		flags = obj.RODATA
 	}
 	if nam.Type() != nil && !nam.Type().HasPointers() {
 		flags |= obj.NOPTR
 	}
 	base.Ctxt.Globl(s, nam.Type().Width, flags)
-	if nam.Name().LibfuzzerExtraCounter() {
+	if nam.LibfuzzerExtraCounter() {
 		s.Type = objabi.SLIBFUZZER_EXTRA_COUNTER
 	}
 	if nam.Sym().Linkname != "" {
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index f435a5bb26..88fbdff1e0 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -771,11 +771,11 @@ func staticValue1(nn Node) Node {
 		return nil
 	}
 	n := nn.(*Name)
-	if n.Class_ != PAUTO || n.Name().Addrtaken() {
+	if n.Class_ != PAUTO || n.Addrtaken() {
 		return nil
 	}
 
-	defn := n.Name().Defn
+	defn := n.Defn
 	if defn == nil {
 		return nil
 	}
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index c79b7e52e5..5acb2d0762 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -312,7 +312,7 @@ func (n *Name) MarkReadonly() {
 	if n.Op() != ONAME {
 		base.Fatalf("Node.MarkReadonly %v", n.Op())
 	}
-	n.Name().setReadonly(true)
+	n.setReadonly(true)
 	// Mark the linksym as readonly immediately
 	// so that the SSA backend can use this information.
 	// It will be overridden later during dumpglobls.
@@ -433,7 +433,7 @@ func IsParamHeapCopy(n Node) bool {
 		return false
 	}
 	name := n.(*Name)
-	return name.Class_ == PAUTOHEAP && name.Name().Stackcopy != nil
+	return name.Class_ == PAUTOHEAP && name.Stackcopy != nil
 }
 
 var RegFP *Name
diff --git a/src/cmd/compile/internal/liveness/plive.go b/src/cmd/compile/internal/liveness/plive.go
index 89c70df65a..91f10b0a9d 100644
--- a/src/cmd/compile/internal/liveness/plive.go
+++ b/src/cmd/compile/internal/liveness/plive.go
@@ -255,7 +255,7 @@ func (lv *liveness) valueEffects(v *ssa.Value) (int32, liveEffect) {
 	// variable" ICEs (issue 19632).
 	switch v.Op {
 	case ssa.OpVarDef, ssa.OpVarKill, ssa.OpVarLive, ssa.OpKeepAlive:
-		if !n.Name().Used() {
+		if !n.Used() {
 			return -1, 0
 		}
 	}
@@ -688,11 +688,11 @@ func (lv *liveness) epilogue() {
 	if lv.fn.HasDefer() {
 		for i, n := range lv.vars {
 			if n.Class_ == ir.PPARAMOUT {
-				if n.Name().IsOutputParamHeapAddr() {
+				if n.IsOutputParamHeapAddr() {
 					// Just to be paranoid.  Heap addresses are PAUTOs.
 					base.Fatalf("variable %v both output param and heap output param", n)
 				}
-				if n.Name().Heapaddr != nil {
+				if n.Heapaddr != nil {
 					// If this variable moved to the heap, then
 					// its stack copy is not live.
 					continue
@@ -700,21 +700,21 @@ func (lv *liveness) epilogue() {
 				// Note: zeroing is handled by zeroResults in walk.go.
 				livedefer.Set(int32(i))
 			}
-			if n.Name().IsOutputParamHeapAddr() {
+			if n.IsOutputParamHeapAddr() {
 				// This variable will be overwritten early in the function
 				// prologue (from the result of a mallocgc) but we need to
 				// zero it in case that malloc causes a stack scan.
-				n.Name().SetNeedzero(true)
+				n.SetNeedzero(true)
 				livedefer.Set(int32(i))
 			}
-			if n.Name().OpenDeferSlot() {
+			if n.OpenDeferSlot() {
 				// Open-coded defer args slots must be live
 				// everywhere in a function, since a panic can
 				// occur (almost) anywhere. Because it is live
 				// everywhere, it must be zeroed on entry.
 				livedefer.Set(int32(i))
 				// It was already marked as Needzero when created.
-				if !n.Name().Needzero() {
+				if !n.Needzero() {
 					base.Fatalf("all pointer-containing defer arg slots should have Needzero set")
 				}
 			}
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index f4b5e0cf91..748fd96380 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -1835,7 +1835,7 @@ func oldname(s *types.Sym) ir.Node {
 		// the := it looks like a reference to the outer x so we'll
 		// make x a closure variable unnecessarily.
 		n := n.(*ir.Name)
-		c := n.Name().Innermost
+		c := n.Innermost
 		if c == nil || c.Curfn != ir.CurFunc {
 			// Do not have a closure var for the active closure yet; make one.
 			c = typecheck.NewName(s)
@@ -1845,8 +1845,8 @@ func oldname(s *types.Sym) ir.Node {
 
 			// Link into list of active closure variables.
 			// Popped from list in func funcLit.
-			c.Outer = n.Name().Innermost
-			n.Name().Innermost = c
+			c.Outer = n.Innermost
+			n.Innermost = c
 
 			ir.CurFunc.ClosureVars = append(ir.CurFunc.ClosureVars, c)
 		}
diff --git a/src/cmd/compile/internal/pkginit/initorder.go b/src/cmd/compile/internal/pkginit/initorder.go
index c6e223954d..1c222c1de4 100644
--- a/src/cmd/compile/internal/pkginit/initorder.go
+++ b/src/cmd/compile/internal/pkginit/initorder.go
@@ -197,7 +197,7 @@ func (o *InitOrder) findInitLoopAndExit(n *ir.Name, path *[]*ir.Name) {
 
 	// There might be multiple loops involving n; by sorting
 	// references, we deterministically pick the one reported.
-	refers := collectDeps(n.Name().Defn, false).Sorted(func(ni, nj *ir.Name) bool {
+	refers := collectDeps(n.Defn, false).Sorted(func(ni, nj *ir.Name) bool {
 		return ni.Pos().Before(nj.Pos())
 	})
 
diff --git a/src/cmd/compile/internal/ssagen/nowb.go b/src/cmd/compile/internal/ssagen/nowb.go
index 7b2e68c8e7..26858fac87 100644
--- a/src/cmd/compile/internal/ssagen/nowb.go
+++ b/src/cmd/compile/internal/ssagen/nowb.go
@@ -76,7 +76,7 @@ func (c *nowritebarrierrecChecker) findExtraCalls(nn ir.Node) {
 		return
 	}
 	fn := n.X.(*ir.Name)
-	if fn.Class_ != ir.PFUNC || fn.Name().Defn == nil {
+	if fn.Class_ != ir.PFUNC || fn.Defn == nil {
 		return
 	}
 	if !types.IsRuntimePkg(fn.Sym().Pkg) || fn.Sym().Name != "systemstack" {
@@ -88,7 +88,7 @@ func (c *nowritebarrierrecChecker) findExtraCalls(nn ir.Node) {
 	switch arg.Op() {
 	case ir.ONAME:
 		arg := arg.(*ir.Name)
-		callee = arg.Name().Defn.(*ir.Func)
+		callee = arg.Defn.(*ir.Func)
 	case ir.OCLOSURE:
 		arg := arg.(*ir.ClosureExpr)
 		callee = arg.Func
diff --git a/src/cmd/compile/internal/ssagen/pgen.go b/src/cmd/compile/internal/ssagen/pgen.go
index 72ce233fda..2be10ff7af 100644
--- a/src/cmd/compile/internal/ssagen/pgen.go
+++ b/src/cmd/compile/internal/ssagen/pgen.go
@@ -86,7 +86,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 
 	for _, l := range f.RegAlloc {
 		if ls, ok := l.(ssa.LocalSlot); ok {
-			ls.N.Name().SetUsed(true)
+			ls.N.SetUsed(true)
 		}
 	}
 
@@ -98,10 +98,10 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 				case ir.PPARAM, ir.PPARAMOUT:
 					// Don't modify nodfp; it is a global.
 					if n != ir.RegFP {
-						n.Name().SetUsed(true)
+						n.SetUsed(true)
 					}
 				case ir.PAUTO:
-					n.Name().SetUsed(true)
+					n.SetUsed(true)
 				}
 			}
 			if !scratchUsed {
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 022959a934..8e3b09aac3 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -6223,7 +6223,7 @@ func (s *state) addNamedValue(n *ir.Name, v *ssa.Value) {
 		// from being assigned too early. See #14591 and #14762. TODO: allow this.
 		return
 	}
-	loc := ssa.LocalSlot{N: n.Name(), Type: n.Type(), Off: 0}
+	loc := ssa.LocalSlot{N: n, Type: n.Type(), Off: 0}
 	values, ok := s.f.NamedValues[loc]
 	if !ok {
 		s.f.Names = append(s.f.Names, loc)
@@ -7198,7 +7198,7 @@ func (e *ssafn) DerefItab(it *obj.LSym, offset int64) *obj.LSym {
 func (e *ssafn) SplitSlot(parent *ssa.LocalSlot, suffix string, offset int64, t *types.Type) ssa.LocalSlot {
 	node := parent.N
 
-	if node.Class_ != ir.PAUTO || node.Name().Addrtaken() {
+	if node.Class_ != ir.PAUTO || node.Addrtaken() {
 		// addressed things and non-autos retain their parents (i.e., cannot truly be split)
 		return ssa.LocalSlot{N: node, Type: t, Off: parent.Off + offset}
 	}
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index 75f38d588d..3552bcf924 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -131,10 +131,10 @@ func CaptureVars(fn *ir.Func) {
 		outermost := v.Defn.(*ir.Name)
 
 		// out parameters will be assigned to implicitly upon return.
-		if outermost.Class_ != ir.PPARAMOUT && !outermost.Name().Addrtaken() && !outermost.Name().Assigned() && v.Type().Width <= 128 {
+		if outermost.Class_ != ir.PPARAMOUT && !outermost.Addrtaken() && !outermost.Assigned() && v.Type().Width <= 128 {
 			v.SetByval(true)
 		} else {
-			outermost.Name().SetAddrtaken(true)
+			outermost.SetAddrtaken(true)
 			outer = NodAddr(outer)
 		}
 
@@ -147,7 +147,7 @@ func CaptureVars(fn *ir.Func) {
 			if v.Byval() {
 				how = "value"
 			}
-			base.WarnfAt(v.Pos(), "%v capturing by %s: %v (addr=%v assign=%v width=%d)", name, how, v.Sym(), outermost.Name().Addrtaken(), outermost.Name().Assigned(), int32(v.Type().Width))
+			base.WarnfAt(v.Pos(), "%v capturing by %s: %v (addr=%v assign=%v width=%d)", name, how, v.Sym(), outermost.Addrtaken(), outermost.Assigned(), int32(v.Type().Width))
 		}
 
 		outer = Expr(outer)
diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index aa16a54bb8..50acb10a9a 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -1521,8 +1521,8 @@ func (w *exportWriter) localName(n *ir.Name) {
 	// PPARAM/PPARAMOUT, because we only want to include vargen in
 	// non-param names.
 	var v int32
-	if n.Class_ == ir.PAUTO || (n.Class_ == ir.PAUTOHEAP && n.Name().Stackcopy == nil) {
-		v = n.Name().Vargen
+	if n.Class_ == ir.PAUTO || (n.Class_ == ir.PAUTOHEAP && n.Stackcopy == nil) {
+		v = n.Vargen
 	}
 
 	w.localIdent(n.Sym(), v)
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index cf9b48f5a6..519d8ddfd9 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -57,7 +57,7 @@ func Package() {
 	base.Timer.Start("fe", "typecheck", "top1")
 	for i := 0; i < len(Target.Decls); i++ {
 		n := Target.Decls[i]
-		if op := n.Op(); op != ir.ODCL && op != ir.OAS && op != ir.OAS2 && (op != ir.ODCLTYPE || !n.(*ir.Decl).X.Name().Alias()) {
+		if op := n.Op(); op != ir.ODCL && op != ir.OAS && op != ir.OAS2 && (op != ir.ODCLTYPE || !n.(*ir.Decl).X.Alias()) {
 			Target.Decls[i] = Stmt(n)
 		}
 	}
@@ -69,7 +69,7 @@ func Package() {
 	base.Timer.Start("fe", "typecheck", "top2")
 	for i := 0; i < len(Target.Decls); i++ {
 		n := Target.Decls[i]
-		if op := n.Op(); op == ir.ODCL || op == ir.OAS || op == ir.OAS2 || op == ir.ODCLTYPE && n.(*ir.Decl).X.Name().Alias() {
+		if op := n.Op(); op == ir.ODCL || op == ir.OAS || op == ir.OAS2 || op == ir.ODCLTYPE && n.(*ir.Decl).X.Alias() {
 			Target.Decls[i] = Stmt(n)
 		}
 	}
@@ -636,7 +636,7 @@ func typecheck1(n ir.Node, top int) ir.Node {
 				n.SetType(nil)
 				return n
 			}
-			n.Name().SetUsed(true)
+			n.SetUsed(true)
 		}
 		return n
 
@@ -1729,9 +1729,9 @@ func checkassign(stmt ir.Node, n ir.Node) {
 		r := ir.OuterValue(n)
 		if r.Op() == ir.ONAME {
 			r := r.(*ir.Name)
-			r.Name().SetAssigned(true)
-			if r.Name().IsClosureVar() {
-				r.Name().Defn.Name().SetAssigned(true)
+			r.SetAssigned(true)
+			if r.IsClosureVar() {
+				r.Defn.Name().SetAssigned(true)
 			}
 		}
 	}
@@ -1938,9 +1938,9 @@ func typecheckdef(n ir.Node) {
 
 	case ir.ONAME:
 		n := n.(*ir.Name)
-		if n.Name().Ntype != nil {
-			n.Name().Ntype = typecheckNtype(n.Name().Ntype)
-			n.SetType(n.Name().Ntype.Type())
+		if n.Ntype != nil {
+			n.Ntype = typecheckNtype(n.Ntype)
+			n.SetType(n.Ntype.Type())
 			if n.Type() == nil {
 				n.SetDiag(true)
 				goto ret
@@ -1950,7 +1950,7 @@ func typecheckdef(n ir.Node) {
 		if n.Type() != nil {
 			break
 		}
-		if n.Name().Defn == nil {
+		if n.Defn == nil {
 			if n.BuiltinOp != 0 { // like OPRINTN
 				break
 			}
@@ -1965,13 +1965,13 @@ func typecheckdef(n ir.Node) {
 			base.Fatalf("var without type, init: %v", n.Sym())
 		}
 
-		if n.Name().Defn.Op() == ir.ONAME {
-			n.Name().Defn = Expr(n.Name().Defn)
-			n.SetType(n.Name().Defn.Type())
+		if n.Defn.Op() == ir.ONAME {
+			n.Defn = Expr(n.Defn)
+			n.SetType(n.Defn.Type())
 			break
 		}
 
-		n.Name().Defn = Stmt(n.Name().Defn) // fills in n.Type
+		n.Defn = Stmt(n.Defn) // fills in n.Type
 
 	case ir.OTYPE:
 		n := n.(*ir.Name)
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 0d7ffca15d..f06a87c37f 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -54,7 +54,7 @@ func walkExpr(n ir.Node, init *ir.Nodes) ir.Node {
 
 	if n.Op() == ir.ONAME && n.(*ir.Name).Class_ == ir.PAUTOHEAP {
 		n := n.(*ir.Name)
-		nn := ir.NewStarExpr(base.Pos, n.Name().Heapaddr)
+		nn := ir.NewStarExpr(base.Pos, n.Heapaddr)
 		nn.X.MarkNonNil()
 		return walkExpr(typecheck.Expr(nn), init)
 	}
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index a2bd0cf10a..e40c877ea9 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -406,7 +406,7 @@ func (o *orderState) edge() {
 	// Create a new uint8 counter to be allocated in section
 	// __libfuzzer_extra_counters.
 	counter := staticinit.StaticName(types.Types[types.TUINT8])
-	counter.Name().SetLibfuzzerExtraCounter(true)
+	counter.SetLibfuzzerExtraCounter(true)
 
 	// counter += 1
 	incr := ir.NewAssignOpStmt(base.Pos, ir.OADD, counter, ir.NewInt(1))
@@ -517,7 +517,7 @@ func (o *orderState) call(nn ir.Node) {
 			if arg.X.Type().IsUnsafePtr() {
 				x := o.copyExpr(arg.X)
 				arg.X = x
-				x.Name().SetAddrtaken(true) // ensure SSA keeps the x variable
+				x.SetAddrtaken(true) // ensure SSA keeps the x variable
 				n.KeepAlive = append(n.KeepAlive, x)
 			}
 		}
diff --git a/src/cmd/compile/internal/walk/stmt.go b/src/cmd/compile/internal/walk/stmt.go
index cfd1da46d2..8641a58e2e 100644
--- a/src/cmd/compile/internal/walk/stmt.go
+++ b/src/cmd/compile/internal/walk/stmt.go
@@ -181,7 +181,7 @@ func walkDecl(n *ir.Decl) ir.Node {
 		if base.Flag.CompilingRuntime {
 			base.Errorf("%v escapes to heap, not allowed in runtime", v)
 		}
-		nn := ir.NewAssignStmt(base.Pos, v.Name().Heapaddr, callnew(v.Type()))
+		nn := ir.NewAssignStmt(base.Pos, v.Heapaddr, callnew(v.Type()))
 		nn.Def = true
 		return walkStmt(typecheck.Stmt(nn))
 	}
-- 
GitLab


From b8fd3440cd3973a16184c4c878b557cf6c6703e4 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 31 Dec 2020 21:32:52 -0800
Subject: [PATCH 0396/2400] [dev.regabi] cmd/compile: report unused variables
 during typecheck

Unused variables are a type-checking error, so they should be reported
during typecheck rather than walk.

One catch is that we only want to report unused-variable errors for
functions that type check successfully, but some errors are reported
during noding, so we don't have an easy way to detect that
currently. As an approximate solution, we simply check if we've
reported any errors yet.

Passes toolstash -cmp.

Change-Id: I9400bfc94312c71d0c908a491e85c16d62224c9c
Reviewed-on: https://go-review.googlesource.com/c/go/+/280973
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 .../compile/internal/typecheck/typecheck.go   | 34 +++++++++++++++++++
 src/cmd/compile/internal/walk/walk.go         | 30 ----------------
 2 files changed, 34 insertions(+), 30 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 519d8ddfd9..4b5c3198ca 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -171,6 +171,7 @@ func FuncBody(n *ir.Func) {
 	decldepth = 1
 	errorsBefore := base.Errors()
 	Stmts(n.Body)
+	CheckUnused(n)
 	CheckReturn(n)
 	if base.Errors() > errorsBefore {
 		n.Body.Set(nil) // type errors; do not compile
@@ -2203,6 +2204,39 @@ func isTermNode(n ir.Node) bool {
 	return false
 }
 
+// CheckUnused checks for any declared variables that weren't used.
+func CheckUnused(fn *ir.Func) {
+	// Only report unused variables if we haven't seen any type-checking
+	// errors yet.
+	if base.Errors() != 0 {
+		return
+	}
+
+	// Propagate the used flag for typeswitch variables up to the NONAME in its definition.
+	for _, ln := range fn.Dcl {
+		if ln.Op() == ir.ONAME && ln.Class_ == ir.PAUTO && ln.Used() {
+			if guard, ok := ln.Defn.(*ir.TypeSwitchGuard); ok {
+				guard.Used = true
+			}
+		}
+	}
+
+	for _, ln := range fn.Dcl {
+		if ln.Op() != ir.ONAME || ln.Class_ != ir.PAUTO || ln.Used() {
+			continue
+		}
+		if defn, ok := ln.Defn.(*ir.TypeSwitchGuard); ok {
+			if defn.Used {
+				continue
+			}
+			base.ErrorfAt(defn.Tag.Pos(), "%v declared but not used", ln.Sym())
+			defn.Used = true // suppress repeats
+		} else {
+			base.ErrorfAt(ln.Pos(), "%v declared but not used", ln.Sym())
+		}
+	}
+}
+
 // CheckReturn makes sure that fn terminates appropriately.
 func CheckReturn(fn *ir.Func) {
 	if fn.Type().NumResults() != 0 && len(fn.Body) != 0 {
diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index b6be949689..25f53a8e7c 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -37,36 +37,6 @@ func Walk(fn *ir.Func) {
 
 	lno := base.Pos
 
-	// Final typecheck for any unused variables.
-	for i, ln := range fn.Dcl {
-		if ln.Op() == ir.ONAME && (ln.Class_ == ir.PAUTO || ln.Class_ == ir.PAUTOHEAP) {
-			ln = typecheck.AssignExpr(ln).(*ir.Name)
-			fn.Dcl[i] = ln
-		}
-	}
-
-	// Propagate the used flag for typeswitch variables up to the NONAME in its definition.
-	for _, ln := range fn.Dcl {
-		if ln.Op() == ir.ONAME && (ln.Class_ == ir.PAUTO || ln.Class_ == ir.PAUTOHEAP) && ln.Defn != nil && ln.Defn.Op() == ir.OTYPESW && ln.Used() {
-			ln.Defn.(*ir.TypeSwitchGuard).Used = true
-		}
-	}
-
-	for _, ln := range fn.Dcl {
-		if ln.Op() != ir.ONAME || (ln.Class_ != ir.PAUTO && ln.Class_ != ir.PAUTOHEAP) || ln.Sym().Name[0] == '&' || ln.Used() {
-			continue
-		}
-		if defn, ok := ln.Defn.(*ir.TypeSwitchGuard); ok {
-			if defn.Used {
-				continue
-			}
-			base.ErrorfAt(defn.Tag.Pos(), "%v declared but not used", ln.Sym())
-			defn.Used = true // suppress repeats
-		} else {
-			base.ErrorfAt(ln.Pos(), "%v declared but not used", ln.Sym())
-		}
-	}
-
 	base.Pos = lno
 	if base.Errors() > errorsBefore {
 		return
-- 
GitLab


From 0f1d2129c4c294a895480b79eeab8d22c07ac573 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 31 Dec 2020 21:48:27 -0800
Subject: [PATCH 0397/2400] [dev.regabi] cmd/compile: reshuffle type-checking
 code [generated]

This commit splits up typecheck.Package and moves the code
elsewhere. The type-checking code is moved into noder, so that it can
eventually be interleaved with the noding process. The
non-type-checking code is moved back into package gc, so that it can
be incorporated into appropriate compiler backend phases.

While here, deadcode removal is moved into its own package.

Passes toolstash -cmp.

[git-generate]
cd src/cmd/compile/internal/typecheck

: Split into two functions.
sed -i -e '/Phase 6/i}\n\nfunc postTypecheck() {' typecheck.go

rf '
	# Export needed identifiers.
	mv deadcode Deadcode
	mv loadsys InitRuntime
	mv declareUniverse DeclareUniverse
	mv dirtyAddrtaken DirtyAddrtaken
	mv computeAddrtaken ComputeAddrtaken
	mv incrementalAddrtaken IncrementalAddrtaken

	# Move into new package.
	mv Deadcode deadcodeslice deadcodeexpr deadcode.go
	mv deadcode.go cmd/compile/internal/deadcode

	# Move top-level type-checking code into noder.
	# Move DeclVars there too, now that nothing else uses it.
	mv DeclVars Package noder.go
	mv noder.go cmd/compile/internal/noder

	# Move non-type-checking code back into gc.
	mv postTypecheck main.go
	mv main.go cmd/compile/internal/gc
'

cd ../deadcode
rf '
	# Destutter names.
	mv Deadcode Func
	mv deadcodeslice stmts
	mv deadcodeexpr expr
'

cd ../noder
rf '
	# Move functions up, next to their related code.
	mv noder.go:/func Package/-1,$ \
		noder.go:/makeSrcPosBase translates/-1
	mv noder.go:/func DeclVars/-3,$ \
		noder.go:/constState tracks/-1
'

cd ../gc
rf '
	# Inline postTypecheck code back into gc.Main.
	mv main.go:/func postTypecheck/+0,/AllImportedBodies/+1 \
		main.go:/Build init task/-1
	rm postTypecheck
'

Change-Id: Ie5e992ece4a42204cce6aa98dd6eb52112d098c8
Reviewed-on: https://go-review.googlesource.com/c/go/+/280974
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/deadcode/deadcode.go | 150 +++++++++++
 src/cmd/compile/internal/gc/main.go           |  42 ++-
 src/cmd/compile/internal/noder/noder.go       | 119 ++++++++-
 src/cmd/compile/internal/typecheck/dcl.go     |  54 ----
 src/cmd/compile/internal/typecheck/func.go    |  10 +-
 src/cmd/compile/internal/typecheck/subr.go    |  16 +-
 src/cmd/compile/internal/typecheck/syms.go    |   4 +-
 .../compile/internal/typecheck/typecheck.go   | 243 +-----------------
 .../compile/internal/typecheck/universe.go    |   4 +-
 9 files changed, 327 insertions(+), 315 deletions(-)
 create mode 100644 src/cmd/compile/internal/deadcode/deadcode.go

diff --git a/src/cmd/compile/internal/deadcode/deadcode.go b/src/cmd/compile/internal/deadcode/deadcode.go
new file mode 100644
index 0000000000..5453cfe396
--- /dev/null
+++ b/src/cmd/compile/internal/deadcode/deadcode.go
@@ -0,0 +1,150 @@
+// Copyright 2009 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 deadcode
+
+import (
+	"go/constant"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+)
+
+func Func(fn *ir.Func) {
+	stmts(&fn.Body)
+
+	if len(fn.Body) == 0 {
+		return
+	}
+
+	for _, n := range fn.Body {
+		if len(n.Init()) > 0 {
+			return
+		}
+		switch n.Op() {
+		case ir.OIF:
+			n := n.(*ir.IfStmt)
+			if !ir.IsConst(n.Cond, constant.Bool) || len(n.Body) > 0 || len(n.Else) > 0 {
+				return
+			}
+		case ir.OFOR:
+			n := n.(*ir.ForStmt)
+			if !ir.IsConst(n.Cond, constant.Bool) || ir.BoolVal(n.Cond) {
+				return
+			}
+		default:
+			return
+		}
+	}
+
+	fn.Body.Set([]ir.Node{ir.NewBlockStmt(base.Pos, nil)})
+}
+
+func stmts(nn *ir.Nodes) {
+	var lastLabel = -1
+	for i, n := range *nn {
+		if n != nil && n.Op() == ir.OLABEL {
+			lastLabel = i
+		}
+	}
+	for i, n := range *nn {
+		// Cut is set to true when all nodes after i'th position
+		// should be removed.
+		// In other words, it marks whole slice "tail" as dead.
+		cut := false
+		if n == nil {
+			continue
+		}
+		if n.Op() == ir.OIF {
+			n := n.(*ir.IfStmt)
+			n.Cond = expr(n.Cond)
+			if ir.IsConst(n.Cond, constant.Bool) {
+				var body ir.Nodes
+				if ir.BoolVal(n.Cond) {
+					n.Else = ir.Nodes{}
+					body = n.Body
+				} else {
+					n.Body = ir.Nodes{}
+					body = n.Else
+				}
+				// If "then" or "else" branch ends with panic or return statement,
+				// it is safe to remove all statements after this node.
+				// isterminating is not used to avoid goto-related complications.
+				// We must be careful not to deadcode-remove labels, as they
+				// might be the target of a goto. See issue 28616.
+				if body := body; len(body) != 0 {
+					switch body[(len(body) - 1)].Op() {
+					case ir.ORETURN, ir.ORETJMP, ir.OPANIC:
+						if i > lastLabel {
+							cut = true
+						}
+					}
+				}
+			}
+		}
+
+		stmts(n.PtrInit())
+		switch n.Op() {
+		case ir.OBLOCK:
+			n := n.(*ir.BlockStmt)
+			stmts(&n.List)
+		case ir.OFOR:
+			n := n.(*ir.ForStmt)
+			stmts(&n.Body)
+		case ir.OIF:
+			n := n.(*ir.IfStmt)
+			stmts(&n.Body)
+			stmts(&n.Else)
+		case ir.ORANGE:
+			n := n.(*ir.RangeStmt)
+			stmts(&n.Body)
+		case ir.OSELECT:
+			n := n.(*ir.SelectStmt)
+			for _, cas := range n.Cases {
+				stmts(&cas.Body)
+			}
+		case ir.OSWITCH:
+			n := n.(*ir.SwitchStmt)
+			for _, cas := range n.Cases {
+				stmts(&cas.Body)
+			}
+		}
+
+		if cut {
+			nn.Set((*nn)[:i+1])
+			break
+		}
+	}
+}
+
+func expr(n ir.Node) ir.Node {
+	// Perform dead-code elimination on short-circuited boolean
+	// expressions involving constants with the intent of
+	// producing a constant 'if' condition.
+	switch n.Op() {
+	case ir.OANDAND:
+		n := n.(*ir.LogicalExpr)
+		n.X = expr(n.X)
+		n.Y = expr(n.Y)
+		if ir.IsConst(n.X, constant.Bool) {
+			if ir.BoolVal(n.X) {
+				return n.Y // true && x => x
+			} else {
+				return n.X // false && x => false
+			}
+		}
+	case ir.OOROR:
+		n := n.(*ir.LogicalExpr)
+		n.X = expr(n.X)
+		n.Y = expr(n.Y)
+		if ir.IsConst(n.X, constant.Bool) {
+			if ir.BoolVal(n.X) {
+				return n.X // true || x => true
+			} else {
+				return n.Y // false || x => x
+			}
+		}
+	}
+	return n
+}
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 45219801f0..603619eb5a 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -8,6 +8,7 @@ import (
 	"bufio"
 	"bytes"
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/deadcode"
 	"cmd/compile/internal/devirtualize"
 	"cmd/compile/internal/dwarfgen"
 	"cmd/compile/internal/escape"
@@ -210,12 +211,51 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	dwarfgen.RecordPackageName()
 
 	// Typecheck.
-	typecheck.Package()
+	noder.Package()
 
 	// With all user code typechecked, it's now safe to verify unused dot imports.
 	noder.CheckDotImports()
 	base.ExitIfErrors()
+	// Phase 6: Compute Addrtaken for names.
+	// We need to wait until typechecking is done so that when we see &x[i]
+	// we know that x has its address taken if x is an array, but not if x is a slice.
+	// We compute Addrtaken in bulk here.
+	// After this phase, we maintain Addrtaken incrementally.
+	if typecheck.DirtyAddrtaken {
+		typecheck.ComputeAddrtaken(typecheck.Target.Decls)
+		typecheck.DirtyAddrtaken = false
+	}
+	typecheck.IncrementalAddrtaken = true
 
+	// Phase 7: Eliminate some obviously dead code.
+	// Must happen after typechecking.
+	for _, n := range typecheck.Target.Decls {
+		if n.Op() == ir.ODCLFUNC {
+			deadcode.Func(n.(*ir.Func))
+		}
+	}
+
+	// Phase 8: Decide how to capture closed variables.
+	// This needs to run before escape analysis,
+	// because variables captured by value do not escape.
+	base.Timer.Start("fe", "capturevars")
+	for _, n := range typecheck.Target.Decls {
+		if n.Op() == ir.ODCLFUNC {
+			n := n.(*ir.Func)
+			if n.OClosure != nil {
+				ir.CurFunc = n
+				typecheck.CaptureVars(n)
+			}
+		}
+	}
+	typecheck.CaptureVarsComplete = true
+	ir.CurFunc = nil
+
+	if base.Debug.TypecheckInl != 0 {
+		// Typecheck imported function bodies if Debug.l > 1,
+		// otherwise lazily when used or re-exported.
+		typecheck.AllImportedBodies()
+	}
 	// Build init task.
 	if initTask := pkginit.Task(); initTask != nil {
 		typecheck.Export(initTask)
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 748fd96380..40569af317 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -85,6 +85,69 @@ func ParseFiles(filenames []string) uint {
 	return lines
 }
 
+func Package() {
+	typecheck.DeclareUniverse()
+
+	typecheck.TypecheckAllowed = true
+
+	// Process top-level declarations in phases.
+
+	// Phase 1: const, type, and names and types of funcs.
+	//   This will gather all the information about types
+	//   and methods but doesn't depend on any of it.
+	//
+	//   We also defer type alias declarations until phase 2
+	//   to avoid cycles like #18640.
+	//   TODO(gri) Remove this again once we have a fix for #25838.
+
+	// Don't use range--typecheck can add closures to Target.Decls.
+	base.Timer.Start("fe", "typecheck", "top1")
+	for i := 0; i < len(typecheck.Target.Decls); i++ {
+		n := typecheck.Target.Decls[i]
+		if op := n.Op(); op != ir.ODCL && op != ir.OAS && op != ir.OAS2 && (op != ir.ODCLTYPE || !n.(*ir.Decl).X.Alias()) {
+			typecheck.Target.Decls[i] = typecheck.Stmt(n)
+		}
+	}
+
+	// Phase 2: Variable assignments.
+	//   To check interface assignments, depends on phase 1.
+
+	// Don't use range--typecheck can add closures to Target.Decls.
+	base.Timer.Start("fe", "typecheck", "top2")
+	for i := 0; i < len(typecheck.Target.Decls); i++ {
+		n := typecheck.Target.Decls[i]
+		if op := n.Op(); op == ir.ODCL || op == ir.OAS || op == ir.OAS2 || op == ir.ODCLTYPE && n.(*ir.Decl).X.Alias() {
+			typecheck.Target.Decls[i] = typecheck.Stmt(n)
+		}
+	}
+
+	// Phase 3: Type check function bodies.
+	// Don't use range--typecheck can add closures to Target.Decls.
+	base.Timer.Start("fe", "typecheck", "func")
+	var fcount int64
+	for i := 0; i < len(typecheck.Target.Decls); i++ {
+		n := typecheck.Target.Decls[i]
+		if n.Op() == ir.ODCLFUNC {
+			typecheck.FuncBody(n.(*ir.Func))
+			fcount++
+		}
+	}
+
+	// Phase 4: Check external declarations.
+	// TODO(mdempsky): This should be handled when type checking their
+	// corresponding ODCL nodes.
+	base.Timer.Start("fe", "typecheck", "externdcls")
+	for i, n := range typecheck.Target.Externs {
+		if n.Op() == ir.ONAME {
+			typecheck.Target.Externs[i] = typecheck.Expr(typecheck.Target.Externs[i])
+		}
+	}
+
+	// Phase 5: With all user code type-checked, it's now safe to verify map keys.
+	typecheck.CheckMapKeys()
+
+}
+
 // makeSrcPosBase translates from a *syntax.PosBase to a *src.PosBase.
 func (p *noder) makeSrcPosBase(b0 *syntax.PosBase) *src.PosBase {
 	// fast path: most likely PosBase hasn't changed
@@ -398,7 +461,61 @@ func (p *noder) varDecl(decl *syntax.VarDecl) []ir.Node {
 	}
 
 	p.setlineno(decl)
-	return typecheck.DeclVars(names, typ, exprs)
+	return DeclVars(names, typ, exprs)
+}
+
+// declare variables from grammar
+// new_name_list (type | [type] = expr_list)
+func DeclVars(vl []*ir.Name, t ir.Ntype, el []ir.Node) []ir.Node {
+	var init []ir.Node
+	doexpr := len(el) > 0
+
+	if len(el) == 1 && len(vl) > 1 {
+		e := el[0]
+		as2 := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
+		as2.Rhs = []ir.Node{e}
+		for _, v := range vl {
+			as2.Lhs.Append(v)
+			typecheck.Declare(v, typecheck.DeclContext)
+			v.Ntype = t
+			v.Defn = as2
+			if ir.CurFunc != nil {
+				init = append(init, ir.NewDecl(base.Pos, ir.ODCL, v))
+			}
+		}
+
+		return append(init, as2)
+	}
+
+	for i, v := range vl {
+		var e ir.Node
+		if doexpr {
+			if i >= len(el) {
+				base.Errorf("assignment mismatch: %d variables but %d values", len(vl), len(el))
+				break
+			}
+			e = el[i]
+		}
+
+		typecheck.Declare(v, typecheck.DeclContext)
+		v.Ntype = t
+
+		if e != nil || ir.CurFunc != nil || ir.IsBlank(v) {
+			if ir.CurFunc != nil {
+				init = append(init, ir.NewDecl(base.Pos, ir.ODCL, v))
+			}
+			as := ir.NewAssignStmt(base.Pos, v, e)
+			init = append(init, as)
+			if e != nil {
+				v.Defn = as
+			}
+		}
+	}
+
+	if len(el) > len(vl) {
+		base.Errorf("assignment mismatch: %d variables but %d values", len(vl), len(el))
+	}
+	return init
 }
 
 // constState tracks state between constant specifiers within a
diff --git a/src/cmd/compile/internal/typecheck/dcl.go b/src/cmd/compile/internal/typecheck/dcl.go
index c4f32ff59d..fd55f472ab 100644
--- a/src/cmd/compile/internal/typecheck/dcl.go
+++ b/src/cmd/compile/internal/typecheck/dcl.go
@@ -33,60 +33,6 @@ func DeclFunc(sym *types.Sym, tfn ir.Ntype) *ir.Func {
 	return fn
 }
 
-// declare variables from grammar
-// new_name_list (type | [type] = expr_list)
-func DeclVars(vl []*ir.Name, t ir.Ntype, el []ir.Node) []ir.Node {
-	var init []ir.Node
-	doexpr := len(el) > 0
-
-	if len(el) == 1 && len(vl) > 1 {
-		e := el[0]
-		as2 := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-		as2.Rhs = []ir.Node{e}
-		for _, v := range vl {
-			as2.Lhs.Append(v)
-			Declare(v, DeclContext)
-			v.Ntype = t
-			v.Defn = as2
-			if ir.CurFunc != nil {
-				init = append(init, ir.NewDecl(base.Pos, ir.ODCL, v))
-			}
-		}
-
-		return append(init, as2)
-	}
-
-	for i, v := range vl {
-		var e ir.Node
-		if doexpr {
-			if i >= len(el) {
-				base.Errorf("assignment mismatch: %d variables but %d values", len(vl), len(el))
-				break
-			}
-			e = el[i]
-		}
-
-		Declare(v, DeclContext)
-		v.Ntype = t
-
-		if e != nil || ir.CurFunc != nil || ir.IsBlank(v) {
-			if ir.CurFunc != nil {
-				init = append(init, ir.NewDecl(base.Pos, ir.ODCL, v))
-			}
-			as := ir.NewAssignStmt(base.Pos, v, e)
-			init = append(init, as)
-			if e != nil {
-				v.Defn = as
-			}
-		}
-	}
-
-	if len(el) > len(vl) {
-		base.Errorf("assignment mismatch: %d variables but %d values", len(vl), len(el))
-	}
-	return init
-}
-
 // Declare records that Node n declares symbol n.Sym in the specified
 // declaration context.
 func Declare(n *ir.Name, ctxt ir.Class) {
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index 3552bcf924..d8c1748432 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -169,13 +169,13 @@ func ImportedBody(fn *ir.Func) {
 	// computeAddrtaken call below (after we typecheck the body).
 	// TODO: export/import types and addrtaken marks along with inlined bodies,
 	// so this will be unnecessary.
-	incrementalAddrtaken = false
+	IncrementalAddrtaken = false
 	defer func() {
-		if dirtyAddrtaken {
-			computeAddrtaken(fn.Inl.Body) // compute addrtaken marks once types are available
-			dirtyAddrtaken = false
+		if DirtyAddrtaken {
+			ComputeAddrtaken(fn.Inl.Body) // compute addrtaken marks once types are available
+			DirtyAddrtaken = false
 		}
-		incrementalAddrtaken = true
+		IncrementalAddrtaken = true
 	}()
 
 	ImportBody(fn)
diff --git a/src/cmd/compile/internal/typecheck/subr.go b/src/cmd/compile/internal/typecheck/subr.go
index 9d414874a0..447e945d81 100644
--- a/src/cmd/compile/internal/typecheck/subr.go
+++ b/src/cmd/compile/internal/typecheck/subr.go
@@ -72,7 +72,7 @@ func NodAddrAt(pos src.XPos, n ir.Node) *ir.AddrExpr {
 }
 
 func markAddrOf(n ir.Node) ir.Node {
-	if incrementalAddrtaken {
+	if IncrementalAddrtaken {
 		// We can only do incremental addrtaken computation when it is ok
 		// to typecheck the argument of the OADDR. That's only safe after the
 		// main typecheck has completed.
@@ -86,22 +86,22 @@ func markAddrOf(n ir.Node) ir.Node {
 	} else {
 		// Remember that we built an OADDR without computing the Addrtaken bit for
 		// its argument. We'll do that later in bulk using computeAddrtaken.
-		dirtyAddrtaken = true
+		DirtyAddrtaken = true
 	}
 	return n
 }
 
-// If incrementalAddrtaken is false, we do not compute Addrtaken for an OADDR Node
+// If IncrementalAddrtaken is false, we do not compute Addrtaken for an OADDR Node
 // when it is built. The Addrtaken bits are set in bulk by computeAddrtaken.
-// If incrementalAddrtaken is true, then when an OADDR Node is built the Addrtaken
+// If IncrementalAddrtaken is true, then when an OADDR Node is built the Addrtaken
 // field of its argument is updated immediately.
-var incrementalAddrtaken = false
+var IncrementalAddrtaken = false
 
-// If dirtyAddrtaken is true, then there are OADDR whose corresponding arguments
+// If DirtyAddrtaken is true, then there are OADDR whose corresponding arguments
 // have not yet been marked as Addrtaken.
-var dirtyAddrtaken = false
+var DirtyAddrtaken = false
 
-func computeAddrtaken(top []ir.Node) {
+func ComputeAddrtaken(top []ir.Node) {
 	for _, n := range top {
 		ir.Visit(n, func(n ir.Node) {
 			if n.Op() == ir.OADDR {
diff --git a/src/cmd/compile/internal/typecheck/syms.go b/src/cmd/compile/internal/typecheck/syms.go
index ab3384bf90..f0e230432a 100644
--- a/src/cmd/compile/internal/typecheck/syms.go
+++ b/src/cmd/compile/internal/typecheck/syms.go
@@ -61,10 +61,10 @@ func Lookup(name string) *types.Sym {
 	return types.LocalPkg.Lookup(name)
 }
 
-// loadsys loads the definitions for the low-level runtime functions,
+// InitRuntime loads the definitions for the low-level runtime functions,
 // so that the compiler can generate calls to them,
 // but does not make them visible to user code.
-func loadsys() {
+func InitRuntime() {
 	types.Block = 1
 
 	inimport = true
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 4b5c3198ca..4c6ac21fc6 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -35,110 +35,7 @@ func Init() {
 	initUniverse()
 	DeclContext = ir.PEXTERN
 	base.Timer.Start("fe", "loadsys")
-	loadsys()
-}
-
-func Package() {
-	declareUniverse()
-
-	TypecheckAllowed = true
-
-	// Process top-level declarations in phases.
-
-	// Phase 1: const, type, and names and types of funcs.
-	//   This will gather all the information about types
-	//   and methods but doesn't depend on any of it.
-	//
-	//   We also defer type alias declarations until phase 2
-	//   to avoid cycles like #18640.
-	//   TODO(gri) Remove this again once we have a fix for #25838.
-
-	// Don't use range--typecheck can add closures to Target.Decls.
-	base.Timer.Start("fe", "typecheck", "top1")
-	for i := 0; i < len(Target.Decls); i++ {
-		n := Target.Decls[i]
-		if op := n.Op(); op != ir.ODCL && op != ir.OAS && op != ir.OAS2 && (op != ir.ODCLTYPE || !n.(*ir.Decl).X.Alias()) {
-			Target.Decls[i] = Stmt(n)
-		}
-	}
-
-	// Phase 2: Variable assignments.
-	//   To check interface assignments, depends on phase 1.
-
-	// Don't use range--typecheck can add closures to Target.Decls.
-	base.Timer.Start("fe", "typecheck", "top2")
-	for i := 0; i < len(Target.Decls); i++ {
-		n := Target.Decls[i]
-		if op := n.Op(); op == ir.ODCL || op == ir.OAS || op == ir.OAS2 || op == ir.ODCLTYPE && n.(*ir.Decl).X.Alias() {
-			Target.Decls[i] = Stmt(n)
-		}
-	}
-
-	// Phase 3: Type check function bodies.
-	// Don't use range--typecheck can add closures to Target.Decls.
-	base.Timer.Start("fe", "typecheck", "func")
-	var fcount int64
-	for i := 0; i < len(Target.Decls); i++ {
-		n := Target.Decls[i]
-		if n.Op() == ir.ODCLFUNC {
-			FuncBody(n.(*ir.Func))
-			fcount++
-		}
-	}
-
-	// Phase 4: Check external declarations.
-	// TODO(mdempsky): This should be handled when type checking their
-	// corresponding ODCL nodes.
-	base.Timer.Start("fe", "typecheck", "externdcls")
-	for i, n := range Target.Externs {
-		if n.Op() == ir.ONAME {
-			Target.Externs[i] = Expr(Target.Externs[i])
-		}
-	}
-
-	// Phase 5: With all user code type-checked, it's now safe to verify map keys.
-	CheckMapKeys()
-
-	// Phase 6: Compute Addrtaken for names.
-	// We need to wait until typechecking is done so that when we see &x[i]
-	// we know that x has its address taken if x is an array, but not if x is a slice.
-	// We compute Addrtaken in bulk here.
-	// After this phase, we maintain Addrtaken incrementally.
-	if dirtyAddrtaken {
-		computeAddrtaken(Target.Decls)
-		dirtyAddrtaken = false
-	}
-	incrementalAddrtaken = true
-
-	// Phase 7: Eliminate some obviously dead code.
-	// Must happen after typechecking.
-	for _, n := range Target.Decls {
-		if n.Op() == ir.ODCLFUNC {
-			deadcode(n.(*ir.Func))
-		}
-	}
-
-	// Phase 8: Decide how to capture closed variables.
-	// This needs to run before escape analysis,
-	// because variables captured by value do not escape.
-	base.Timer.Start("fe", "capturevars")
-	for _, n := range Target.Decls {
-		if n.Op() == ir.ODCLFUNC {
-			n := n.(*ir.Func)
-			if n.OClosure != nil {
-				ir.CurFunc = n
-				CaptureVars(n)
-			}
-		}
-	}
-	CaptureVarsComplete = true
-	ir.CurFunc = nil
-
-	if base.Debug.TypecheckInl != 0 {
-		// Typecheck imported function bodies if Debug.l > 1,
-		// otherwise lazily when used or re-exported.
-		AllImportedBodies()
-	}
+	InitRuntime()
 }
 
 func AssignExpr(n ir.Node) ir.Node { return typecheck(n, ctxExpr|ctxAssign) }
@@ -2247,144 +2144,6 @@ func CheckReturn(fn *ir.Func) {
 	}
 }
 
-func deadcode(fn *ir.Func) {
-	deadcodeslice(&fn.Body)
-
-	if len(fn.Body) == 0 {
-		return
-	}
-
-	for _, n := range fn.Body {
-		if len(n.Init()) > 0 {
-			return
-		}
-		switch n.Op() {
-		case ir.OIF:
-			n := n.(*ir.IfStmt)
-			if !ir.IsConst(n.Cond, constant.Bool) || len(n.Body) > 0 || len(n.Else) > 0 {
-				return
-			}
-		case ir.OFOR:
-			n := n.(*ir.ForStmt)
-			if !ir.IsConst(n.Cond, constant.Bool) || ir.BoolVal(n.Cond) {
-				return
-			}
-		default:
-			return
-		}
-	}
-
-	fn.Body.Set([]ir.Node{ir.NewBlockStmt(base.Pos, nil)})
-}
-
-func deadcodeslice(nn *ir.Nodes) {
-	var lastLabel = -1
-	for i, n := range *nn {
-		if n != nil && n.Op() == ir.OLABEL {
-			lastLabel = i
-		}
-	}
-	for i, n := range *nn {
-		// Cut is set to true when all nodes after i'th position
-		// should be removed.
-		// In other words, it marks whole slice "tail" as dead.
-		cut := false
-		if n == nil {
-			continue
-		}
-		if n.Op() == ir.OIF {
-			n := n.(*ir.IfStmt)
-			n.Cond = deadcodeexpr(n.Cond)
-			if ir.IsConst(n.Cond, constant.Bool) {
-				var body ir.Nodes
-				if ir.BoolVal(n.Cond) {
-					n.Else = ir.Nodes{}
-					body = n.Body
-				} else {
-					n.Body = ir.Nodes{}
-					body = n.Else
-				}
-				// If "then" or "else" branch ends with panic or return statement,
-				// it is safe to remove all statements after this node.
-				// isterminating is not used to avoid goto-related complications.
-				// We must be careful not to deadcode-remove labels, as they
-				// might be the target of a goto. See issue 28616.
-				if body := body; len(body) != 0 {
-					switch body[(len(body) - 1)].Op() {
-					case ir.ORETURN, ir.ORETJMP, ir.OPANIC:
-						if i > lastLabel {
-							cut = true
-						}
-					}
-				}
-			}
-		}
-
-		deadcodeslice(n.PtrInit())
-		switch n.Op() {
-		case ir.OBLOCK:
-			n := n.(*ir.BlockStmt)
-			deadcodeslice(&n.List)
-		case ir.OFOR:
-			n := n.(*ir.ForStmt)
-			deadcodeslice(&n.Body)
-		case ir.OIF:
-			n := n.(*ir.IfStmt)
-			deadcodeslice(&n.Body)
-			deadcodeslice(&n.Else)
-		case ir.ORANGE:
-			n := n.(*ir.RangeStmt)
-			deadcodeslice(&n.Body)
-		case ir.OSELECT:
-			n := n.(*ir.SelectStmt)
-			for _, cas := range n.Cases {
-				deadcodeslice(&cas.Body)
-			}
-		case ir.OSWITCH:
-			n := n.(*ir.SwitchStmt)
-			for _, cas := range n.Cases {
-				deadcodeslice(&cas.Body)
-			}
-		}
-
-		if cut {
-			nn.Set((*nn)[:i+1])
-			break
-		}
-	}
-}
-
-func deadcodeexpr(n ir.Node) ir.Node {
-	// Perform dead-code elimination on short-circuited boolean
-	// expressions involving constants with the intent of
-	// producing a constant 'if' condition.
-	switch n.Op() {
-	case ir.OANDAND:
-		n := n.(*ir.LogicalExpr)
-		n.X = deadcodeexpr(n.X)
-		n.Y = deadcodeexpr(n.Y)
-		if ir.IsConst(n.X, constant.Bool) {
-			if ir.BoolVal(n.X) {
-				return n.Y // true && x => x
-			} else {
-				return n.X // false && x => false
-			}
-		}
-	case ir.OOROR:
-		n := n.(*ir.LogicalExpr)
-		n.X = deadcodeexpr(n.X)
-		n.Y = deadcodeexpr(n.Y)
-		if ir.IsConst(n.X, constant.Bool) {
-			if ir.BoolVal(n.X) {
-				return n.X // true || x => true
-			} else {
-				return n.Y // false || x => x
-			}
-		}
-	}
-	return n
-}
-
 // getIotaValue returns the current value for "iota",
 // or -1 if not within a ConstSpec.
 func getIotaValue() int64 {
diff --git a/src/cmd/compile/internal/typecheck/universe.go b/src/cmd/compile/internal/typecheck/universe.go
index fc8e962e28..054f094cd3 100644
--- a/src/cmd/compile/internal/typecheck/universe.go
+++ b/src/cmd/compile/internal/typecheck/universe.go
@@ -336,8 +336,8 @@ func makeErrorInterface() *types.Type {
 	return types.NewInterface(types.NoPkg, []*types.Field{method})
 }
 
-// declareUniverse makes the universe block visible within the current package.
-func declareUniverse() {
+// DeclareUniverse makes the universe block visible within the current package.
+func DeclareUniverse() {
 	// Operationally, this is similar to a dot import of builtinpkg, except
 	// that we silently skip symbols that are already declared in the
 	// package block rather than emitting a redeclared symbol error.
-- 
GitLab


From 3a4474cdfda0096b5d88c769f81ad81d6f0168c7 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 31 Dec 2020 23:39:15 -0800
Subject: [PATCH 0398/2400] [dev.regabi] cmd/compile: some more manual
 shuffling

More minor reshuffling of passes.

Passes toolstash -cmp.

Change-Id: I22633b3741f668fc5ee8579d7d610035ed57df1f
Reviewed-on: https://go-review.googlesource.com/c/go/+/280975
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/gc/abiutils_test.go  |  2 +-
 src/cmd/compile/internal/gc/main.go           | 26 +++++++------------
 src/cmd/compile/internal/noder/noder.go       | 14 ++++++++++
 src/cmd/compile/internal/typecheck/dcl.go     |  2 +-
 src/cmd/compile/internal/typecheck/syms.go    |  7 +----
 .../compile/internal/typecheck/typecheck.go   |  7 -----
 .../compile/internal/typecheck/universe.go    |  4 +--
 7 files changed, 29 insertions(+), 33 deletions(-)

diff --git a/src/cmd/compile/internal/gc/abiutils_test.go b/src/cmd/compile/internal/gc/abiutils_test.go
index d535a6a34b..6fd0af1b1f 100644
--- a/src/cmd/compile/internal/gc/abiutils_test.go
+++ b/src/cmd/compile/internal/gc/abiutils_test.go
@@ -38,7 +38,7 @@ func TestMain(m *testing.M) {
 	base.Ctxt.Bso = bufio.NewWriter(os.Stdout)
 	types.PtrSize = ssagen.Arch.LinkArch.PtrSize
 	types.RegSize = ssagen.Arch.LinkArch.RegSize
-	typecheck.Init()
+	typecheck.InitUniverse()
 	os.Exit(m.Run())
 }
 
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 603619eb5a..df6a9d8e45 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -200,23 +200,15 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 
 	base.AutogeneratedPos = makePos(src.NewFileBase("<autogenerated>", "<autogenerated>"), 1, 0)
 
-	typecheck.Init()
+	typecheck.InitUniverse()
 
-	// Parse input.
-	base.Timer.Start("fe", "parse")
-	lines := noder.ParseFiles(flag.Args())
-	ssagen.CgoSymABIs()
-	base.Timer.Stop()
-	base.Timer.AddEvent(int64(lines), "lines")
-	dwarfgen.RecordPackageName()
+	// Parse and typecheck input.
+	noder.LoadPackage(flag.Args())
 
-	// Typecheck.
-	noder.Package()
+	dwarfgen.RecordPackageName()
+	ssagen.CgoSymABIs()
 
-	// With all user code typechecked, it's now safe to verify unused dot imports.
-	noder.CheckDotImports()
-	base.ExitIfErrors()
-	// Phase 6: Compute Addrtaken for names.
+	// Compute Addrtaken for names.
 	// We need to wait until typechecking is done so that when we see &x[i]
 	// we know that x has its address taken if x is an array, but not if x is a slice.
 	// We compute Addrtaken in bulk here.
@@ -227,7 +219,7 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	}
 	typecheck.IncrementalAddrtaken = true
 
-	// Phase 7: Eliminate some obviously dead code.
+	// Eliminate some obviously dead code.
 	// Must happen after typechecking.
 	for _, n := range typecheck.Target.Decls {
 		if n.Op() == ir.ODCLFUNC {
@@ -235,7 +227,7 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 		}
 	}
 
-	// Phase 8: Decide how to capture closed variables.
+	// Decide how to capture closed variables.
 	// This needs to run before escape analysis,
 	// because variables captured by value do not escape.
 	base.Timer.Start("fe", "capturevars")
@@ -256,6 +248,7 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 		// otherwise lazily when used or re-exported.
 		typecheck.AllImportedBodies()
 	}
+
 	// Build init task.
 	if initTask := pkginit.Task(); initTask != nil {
 		typecheck.Export(initTask)
@@ -311,6 +304,7 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	// Prepare for SSA compilation.
 	// This must be before peekitabs, because peekitabs
 	// can trigger function compilation.
+	typecheck.InitRuntime()
 	ssagen.InitConfig()
 
 	// Just before compilation, compile itabs found on
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 40569af317..29bfde3ff2 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -25,6 +25,20 @@ import (
 	"cmd/internal/src"
 )
 
+func LoadPackage(filenames []string) {
+	base.Timer.Start("fe", "parse")
+	lines := ParseFiles(filenames)
+	base.Timer.Stop()
+	base.Timer.AddEvent(int64(lines), "lines")
+
+	// Typecheck.
+	Package()
+
+	// With all user code typechecked, it's now safe to verify unused dot imports.
+	CheckDotImports()
+	base.ExitIfErrors()
+}
+
 // ParseFiles concurrently parses files into *syntax.File structures.
 // Each declaration in every *syntax.File is converted to a syntax tree
 // and its root represented by *Node is appended to Target.Decls.
diff --git a/src/cmd/compile/internal/typecheck/dcl.go b/src/cmd/compile/internal/typecheck/dcl.go
index fd55f472ab..daec9848d0 100644
--- a/src/cmd/compile/internal/typecheck/dcl.go
+++ b/src/cmd/compile/internal/typecheck/dcl.go
@@ -15,7 +15,7 @@ import (
 	"cmd/internal/src"
 )
 
-var DeclContext ir.Class // PEXTERN/PAUTO
+var DeclContext ir.Class = ir.PEXTERN // PEXTERN/PAUTO
 
 func DeclFunc(sym *types.Sym, tfn ir.Ntype) *ir.Func {
 	if tfn.Op() != ir.OTFUNC {
diff --git a/src/cmd/compile/internal/typecheck/syms.go b/src/cmd/compile/internal/typecheck/syms.go
index f0e230432a..2251062e16 100644
--- a/src/cmd/compile/internal/typecheck/syms.go
+++ b/src/cmd/compile/internal/typecheck/syms.go
@@ -65,11 +65,9 @@ func Lookup(name string) *types.Sym {
 // so that the compiler can generate calls to them,
 // but does not make them visible to user code.
 func InitRuntime() {
+	base.Timer.Start("fe", "loadsys")
 	types.Block = 1
 
-	inimport = true
-	TypecheckAllowed = true
-
 	typs := runtimeTypes()
 	for _, d := range &runtimeDecls {
 		sym := ir.Pkgs.Runtime.Lookup(d.name)
@@ -83,9 +81,6 @@ func InitRuntime() {
 			base.Fatalf("unhandled declaration tag %v", d.tag)
 		}
 	}
-
-	TypecheckAllowed = false
-	inimport = false
 }
 
 // LookupRuntimeFunc looks up Go function name in package runtime. This function
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 4c6ac21fc6..c8d82443a1 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -31,13 +31,6 @@ var (
 	NeedRuntimeType = func(*types.Type) {}
 )
 
-func Init() {
-	initUniverse()
-	DeclContext = ir.PEXTERN
-	base.Timer.Start("fe", "loadsys")
-	InitRuntime()
-}
-
 func AssignExpr(n ir.Node) ir.Node { return typecheck(n, ctxExpr|ctxAssign) }
 func Expr(n ir.Node) ir.Node       { return typecheck(n, ctxExpr) }
 func Stmt(n ir.Node) ir.Node       { return typecheck(n, ctxStmt) }
diff --git a/src/cmd/compile/internal/typecheck/universe.go b/src/cmd/compile/internal/typecheck/universe.go
index 054f094cd3..f1e7ed4273 100644
--- a/src/cmd/compile/internal/typecheck/universe.go
+++ b/src/cmd/compile/internal/typecheck/universe.go
@@ -90,8 +90,8 @@ var unsafeFuncs = [...]struct {
 	{"Sizeof", ir.OSIZEOF},
 }
 
-// initUniverse initializes the universe block.
-func initUniverse() {
+// InitUniverse initializes the universe block.
+func InitUniverse() {
 	if types.PtrSize == 0 {
 		base.Fatalf("typeinit before betypeinit")
 	}
-- 
GitLab


From 68e6fa4f6852b4ef0fe61789618c093f4e2185c9 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 31 Dec 2020 23:45:36 -0800
Subject: [PATCH 0399/2400] [dev.regabi] cmd/compile: fix
 package-initialization order

This CL fixes package initialization order by creating the init task
before the general deadcode-removal pass.

It also changes noder to emit zero-initialization assignments (i.e.,
OAS with nil RHS) for package-block variables, so that initOrder can
tell the variables still need initialization. To allow this, we need
to also extend the static-init code to recognize zero-initialization
assignments.

This doesn't pass toolstash -cmp, because it reorders some package
initialization routines.

Fixes #43444.

Change-Id: I0da7996a62c85e15e97ce965298127e075390a7e
Reviewed-on: https://go-review.googlesource.com/c/go/+/280976
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/gc/main.go          | 10 ++--
 src/cmd/compile/internal/noder/noder.go      | 52 +++++++-------------
 src/cmd/compile/internal/pkginit/init.go     |  4 ++
 src/cmd/compile/internal/staticinit/sched.go | 16 ++++--
 test/fixedbugs/issue43444.go                 | 28 +++++++++++
 test/fixedbugs/issue43444.out                |  1 +
 6 files changed, 70 insertions(+), 41 deletions(-)
 create mode 100644 test/fixedbugs/issue43444.go
 create mode 100644 test/fixedbugs/issue43444.out

diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index df6a9d8e45..c1f51e4f1d 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -208,6 +208,11 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	dwarfgen.RecordPackageName()
 	ssagen.CgoSymABIs()
 
+	// Build init task.
+	if initTask := pkginit.Task(); initTask != nil {
+		typecheck.Export(initTask)
+	}
+
 	// Compute Addrtaken for names.
 	// We need to wait until typechecking is done so that when we see &x[i]
 	// we know that x has its address taken if x is an array, but not if x is a slice.
@@ -249,11 +254,6 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 		typecheck.AllImportedBodies()
 	}
 
-	// Build init task.
-	if initTask := pkginit.Task(); initTask != nil {
-		typecheck.Export(initTask)
-	}
-
 	// Inlining
 	base.Timer.Start("fe", "inlining")
 	if base.Flag.LowerL != 0 {
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 29bfde3ff2..cc8a1c7c89 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -474,24 +474,15 @@ func (p *noder) varDecl(decl *syntax.VarDecl) []ir.Node {
 		p.checkUnused(pragma)
 	}
 
-	p.setlineno(decl)
-	return DeclVars(names, typ, exprs)
-}
-
-// declare variables from grammar
-// new_name_list (type | [type] = expr_list)
-func DeclVars(vl []*ir.Name, t ir.Ntype, el []ir.Node) []ir.Node {
 	var init []ir.Node
-	doexpr := len(el) > 0
+	p.setlineno(decl)
 
-	if len(el) == 1 && len(vl) > 1 {
-		e := el[0]
-		as2 := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-		as2.Rhs = []ir.Node{e}
-		for _, v := range vl {
+	if len(names) > 1 && len(exprs) == 1 {
+		as2 := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, exprs)
+		for _, v := range names {
 			as2.Lhs.Append(v)
 			typecheck.Declare(v, typecheck.DeclContext)
-			v.Ntype = t
+			v.Ntype = typ
 			v.Defn = as2
 			if ir.CurFunc != nil {
 				init = append(init, ir.NewDecl(base.Pos, ir.ODCL, v))
@@ -501,34 +492,29 @@ func DeclVars(vl []*ir.Name, t ir.Ntype, el []ir.Node) []ir.Node {
 		return append(init, as2)
 	}
 
-	for i, v := range vl {
+	for i, v := range names {
 		var e ir.Node
-		if doexpr {
-			if i >= len(el) {
-				base.Errorf("assignment mismatch: %d variables but %d values", len(vl), len(el))
-				break
-			}
-			e = el[i]
+		if i < len(exprs) {
+			e = exprs[i]
 		}
 
 		typecheck.Declare(v, typecheck.DeclContext)
-		v.Ntype = t
+		v.Ntype = typ
 
-		if e != nil || ir.CurFunc != nil || ir.IsBlank(v) {
-			if ir.CurFunc != nil {
-				init = append(init, ir.NewDecl(base.Pos, ir.ODCL, v))
-			}
-			as := ir.NewAssignStmt(base.Pos, v, e)
-			init = append(init, as)
-			if e != nil {
-				v.Defn = as
-			}
+		if ir.CurFunc != nil {
+			init = append(init, ir.NewDecl(base.Pos, ir.ODCL, v))
+		}
+		as := ir.NewAssignStmt(base.Pos, v, e)
+		init = append(init, as)
+		if e != nil || ir.CurFunc == nil {
+			v.Defn = as
 		}
 	}
 
-	if len(el) > len(vl) {
-		base.Errorf("assignment mismatch: %d variables but %d values", len(vl), len(el))
+	if len(exprs) != 0 && len(names) != len(exprs) {
+		base.Errorf("assignment mismatch: %d variables but %d values", len(names), len(exprs))
 	}
+
 	return init
 }
 
diff --git a/src/cmd/compile/internal/pkginit/init.go b/src/cmd/compile/internal/pkginit/init.go
index f1ffbb5933..24fe1a7628 100644
--- a/src/cmd/compile/internal/pkginit/init.go
+++ b/src/cmd/compile/internal/pkginit/init.go
@@ -6,6 +6,7 @@ package pkginit
 
 import (
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/deadcode"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/objw"
 	"cmd/compile/internal/typecheck"
@@ -68,6 +69,9 @@ func Task() *ir.Name {
 
 	// Record user init functions.
 	for _, fn := range typecheck.Target.Inits {
+		// Must happen after initOrder; see #43444.
+		deadcode.Func(fn)
+
 		// Skip init functions with empty bodies.
 		if len(fn.Body) == 1 {
 			if stmt := fn.Body[0]; stmt.Op() == ir.OBLOCK && len(stmt.(*ir.BlockStmt).List) == 0 {
diff --git a/src/cmd/compile/internal/staticinit/sched.go b/src/cmd/compile/internal/staticinit/sched.go
index 1b0af1b05d..8e4ce55954 100644
--- a/src/cmd/compile/internal/staticinit/sched.go
+++ b/src/cmd/compile/internal/staticinit/sched.go
@@ -86,17 +86,22 @@ func (s *Schedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *types.Ty
 	if rn.Class_ != ir.PEXTERN || rn.Sym().Pkg != types.LocalPkg {
 		return false
 	}
-	if rn.Defn == nil { // probably zeroed but perhaps supplied externally and of unknown value
-		return false
-	}
 	if rn.Defn.Op() != ir.OAS {
 		return false
 	}
 	if rn.Type().IsString() { // perhaps overwritten by cmd/link -X (#34675)
 		return false
 	}
+	if rn.Embed != nil {
+		return false
+	}
 	orig := rn
 	r := rn.Defn.(*ir.AssignStmt).Y
+	if r == nil {
+		// No explicit initialization value. Probably zeroed but perhaps
+		// supplied externally and of unknown value.
+		return false
+	}
 
 	for r.Op() == ir.OCONVNOP && !types.Identical(r.Type(), typ) {
 		r = r.(*ir.ConvExpr).X
@@ -185,6 +190,11 @@ func (s *Schedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *types.Ty
 }
 
 func (s *Schedule) StaticAssign(l *ir.Name, loff int64, r ir.Node, typ *types.Type) bool {
+	if r == nil {
+		// No explicit initialization value. Either zero or supplied
+		// externally.
+		return true
+	}
 	for r.Op() == ir.OCONVNOP {
 		r = r.(*ir.ConvExpr).X
 	}
diff --git a/test/fixedbugs/issue43444.go b/test/fixedbugs/issue43444.go
new file mode 100644
index 0000000000..c430e1baf7
--- /dev/null
+++ b/test/fixedbugs/issue43444.go
@@ -0,0 +1,28 @@
+// run
+
+package main
+
+var sp = ""
+
+func f(name string, _ ...interface{}) int {
+	print(sp, name)
+	sp = " "
+	return 0
+}
+
+var a = f("a", x)
+var b = f("b", y)
+var c = f("c", z)
+var d = func() int {
+	if false {
+		_ = z
+	}
+	return f("d")
+}()
+var e = f("e")
+
+var x int
+var y int = 42
+var z int = func() int { return 42 }()
+
+func main() { println() }
diff --git a/test/fixedbugs/issue43444.out b/test/fixedbugs/issue43444.out
new file mode 100644
index 0000000000..22d6a0dc69
--- /dev/null
+++ b/test/fixedbugs/issue43444.out
@@ -0,0 +1 @@
+e a b c d
-- 
GitLab


From 6ddbc75efd4bc2757e7684e7760ee411ec721e15 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 1 Jan 2021 01:32:46 -0800
Subject: [PATCH 0400/2400] [dev.regabi] cmd/compile: earlier deadcode removal

This CL moves the general deadcode-removal pass to before computing
Addrtaken, which allows variables to still be converted to SSA if
their address is only taken in unreachable code paths (e.g., the "&mp"
expression in the "if false" block in runtime/os_linux.go:newosproc).

This doesn't pass toolstash -cmp, because it allows SSA to better
optimize some code.

Change-Id: I43e54acc02fdcbad8eb6493283f355aa1ee0de84
Reviewed-on: https://go-review.googlesource.com/c/go/+/280992
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/gc/main.go | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index c1f51e4f1d..2ea614e17f 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -213,6 +213,14 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 		typecheck.Export(initTask)
 	}
 
+	// Eliminate some obviously dead code.
+	// Must happen after typechecking.
+	for _, n := range typecheck.Target.Decls {
+		if n.Op() == ir.ODCLFUNC {
+			deadcode.Func(n.(*ir.Func))
+		}
+	}
+
 	// Compute Addrtaken for names.
 	// We need to wait until typechecking is done so that when we see &x[i]
 	// we know that x has its address taken if x is an array, but not if x is a slice.
@@ -224,14 +232,6 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	}
 	typecheck.IncrementalAddrtaken = true
 
-	// Eliminate some obviously dead code.
-	// Must happen after typechecking.
-	for _, n := range typecheck.Target.Decls {
-		if n.Op() == ir.ODCLFUNC {
-			deadcode.Func(n.(*ir.Func))
-		}
-	}
-
 	// Decide how to capture closed variables.
 	// This needs to run before escape analysis,
 	// because variables captured by value do not escape.
-- 
GitLab


From ece345aa691c4097fdb8d1f2736a8fd6214515a9 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 1 Jan 2021 01:46:55 -0800
Subject: [PATCH 0401/2400] [dev.regabi] cmd/compile: expand documentation for
 Func.Closure{Vars,Enter}

I keep getting these confused and having to look at how the code
actually uses them.

Change-Id: I86baf22b76e7dddada6830df0fac241092f716bf
Reviewed-on: https://go-review.googlesource.com/c/go/+/280993
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ir/func.go | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 9a79a4f30f..c54b742669 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -65,9 +65,22 @@ type Func struct {
 	// include closurevars until transformclosure runs.
 	Dcl []*Name
 
-	ClosureEnter Nodes   // list of ONAME nodes (or OADDR-of-ONAME nodes, for output parameters) of captured variables
-	ClosureType  Ntype   // closure representation type
-	ClosureVars  []*Name // closure params; each has closurevar set
+	ClosureType Ntype // closure representation type
+
+	// ClosureVars lists the free variables that are used within a
+	// function literal, but formally declared in an enclosing
+	// function. The variables in this slice are the closure function's
+	// own copy of the variables, which are used within its function
+	// body. They will also each have IsClosureVar set, and will have
+	// Byval set if they're captured by value.
+	ClosureVars []*Name
+
+	// ClosureEnter holds the expressions that the enclosing function
+	// will use to initialize the closure's free variables. These
+	// correspond one-to-one with the variables in ClosureVars, and will
+	// be either an ONAME node (if the variable is captured by value) or
+	// an OADDR-of-ONAME node (if not).
+	ClosureEnter Nodes
 
 	// Parents records the parent scope of each scope within a
 	// function. The root scope (0) has no parent, so the i'th
-- 
GitLab


From 9ed1577779b38620a5df1871ec1cd8d8677d5cc0 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 1 Jan 2021 02:14:45 -0800
Subject: [PATCH 0402/2400] [dev.regabi] cmd/compile: remove Func.ClosureEnter

We can easily compute this on demand.

Passes toolstash -cmp.

Change-Id: I433d8adb2b1615ae05b2764e69904369a59542c5
Reviewed-on: https://go-review.googlesource.com/c/go/+/280994
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ir/func.go        |  7 -------
 src/cmd/compile/internal/ir/sizeof_test.go |  2 +-
 src/cmd/compile/internal/typecheck/func.go | 14 ++++----------
 src/cmd/compile/internal/walk/closure.go   | 22 +++++++++++++++++++++-
 src/cmd/compile/internal/walk/expr.go      |  3 +--
 5 files changed, 27 insertions(+), 21 deletions(-)

diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index c54b742669..1eaca9c6f3 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -75,13 +75,6 @@ type Func struct {
 	// Byval set if they're captured by value.
 	ClosureVars []*Name
 
-	// ClosureEnter holds the expressions that the enclosing function
-	// will use to initialize the closure's free variables. These
-	// correspond one-to-one with the variables in ClosureVars, and will
-	// be either an ONAME node (if the variable is captured by value) or
-	// an OADDR-of-ONAME node (if not).
-	ClosureEnter Nodes
-
 	// Parents records the parent scope of each scope within a
 	// function. The root scope (0) has no parent, so the i'th
 	// scope's parent is stored at Parents[i-1].
diff --git a/src/cmd/compile/internal/ir/sizeof_test.go b/src/cmd/compile/internal/ir/sizeof_test.go
index 8f5fae8a12..60120f2998 100644
--- a/src/cmd/compile/internal/ir/sizeof_test.go
+++ b/src/cmd/compile/internal/ir/sizeof_test.go
@@ -20,7 +20,7 @@ func TestSizeof(t *testing.T) {
 		_32bit uintptr     // size on 32bit platforms
 		_64bit uintptr     // size on 64bit platforms
 	}{
-		{Func{}, 196, 344},
+		{Func{}, 184, 320},
 		{Name{}, 124, 216},
 	}
 
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index d8c1748432..2bc911882f 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -122,20 +122,17 @@ func CaptureVars(fn *ir.Func) {
 		}
 		out = append(out, v)
 
-		// type check the & of closed variables outside the closure,
+		// type check closed variables outside the closure,
 		// so that the outer frame also grabs them and knows they escape.
-		types.CalcSize(v.Type())
+		Expr(v.Outer)
 
-		var outer ir.Node
-		outer = v.Outer
 		outermost := v.Defn.(*ir.Name)
 
 		// out parameters will be assigned to implicitly upon return.
-		if outermost.Class_ != ir.PPARAMOUT && !outermost.Addrtaken() && !outermost.Assigned() && v.Type().Width <= 128 {
+		if outermost.Class_ != ir.PPARAMOUT && !outermost.Addrtaken() && !outermost.Assigned() && v.Type().Size() <= 128 {
 			v.SetByval(true)
 		} else {
 			outermost.SetAddrtaken(true)
-			outer = NodAddr(outer)
 		}
 
 		if base.Flag.LowerM > 1 {
@@ -147,11 +144,8 @@ func CaptureVars(fn *ir.Func) {
 			if v.Byval() {
 				how = "value"
 			}
-			base.WarnfAt(v.Pos(), "%v capturing by %s: %v (addr=%v assign=%v width=%d)", name, how, v.Sym(), outermost.Addrtaken(), outermost.Assigned(), int32(v.Type().Width))
+			base.WarnfAt(v.Pos(), "%v capturing by %s: %v (addr=%v assign=%v width=%d)", name, how, v.Sym(), outermost.Addrtaken(), outermost.Assigned(), v.Type().Size())
 		}
-
-		outer = Expr(outer)
-		fn.ClosureEnter.Append(outer)
 	}
 
 	fn.ClosureVars = out
diff --git a/src/cmd/compile/internal/walk/closure.go b/src/cmd/compile/internal/walk/closure.go
index 0726d3b552..d4eb4eb8a3 100644
--- a/src/cmd/compile/internal/walk/closure.go
+++ b/src/cmd/compile/internal/walk/closure.go
@@ -131,7 +131,7 @@ func walkClosure(clo *ir.ClosureExpr, init *ir.Nodes) ir.Node {
 
 	clos := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ).(ir.Ntype), nil)
 	clos.SetEsc(clo.Esc())
-	clos.List.Set(append([]ir.Node{ir.NewUnaryExpr(base.Pos, ir.OCFUNC, fn.Nname)}, fn.ClosureEnter...))
+	clos.List.Set(append([]ir.Node{ir.NewUnaryExpr(base.Pos, ir.OCFUNC, fn.Nname)}, closureArgs(clo)...))
 
 	addr := typecheck.NodAddr(clos)
 	addr.SetEsc(clo.Esc())
@@ -151,6 +151,26 @@ func walkClosure(clo *ir.ClosureExpr, init *ir.Nodes) ir.Node {
 	return walkExpr(cfn, init)
 }
 
+// closureArgs returns a slice of expressions that an be used to
+// initialize the given closure's free variables. These correspond
+// one-to-one with the variables in clo.Func.ClosureVars, and will be
+// either an ONAME node (if the variable is captured by value) or an
+// OADDR-of-ONAME node (if not).
+func closureArgs(clo *ir.ClosureExpr) []ir.Node {
+	fn := clo.Func
+
+	args := make([]ir.Node, len(fn.ClosureVars))
+	for i, v := range fn.ClosureVars {
+		var outer ir.Node
+		outer = v.Outer
+		if !v.Byval() {
+			outer = typecheck.NodAddrAt(fn.Pos(), outer)
+		}
+		args[i] = typecheck.Expr(outer)
+	}
+	return args
+}
+
 func walkCallPart(n *ir.SelectorExpr, init *ir.Nodes) ir.Node {
 	// Create closure in the form of a composite literal.
 	// For x.M with receiver (x) type T, the generated code looks like:
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index f06a87c37f..1fd09b42af 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -498,8 +498,7 @@ func walkCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 
 		// Prepend captured variables to argument list.
 		clo := n.X.(*ir.ClosureExpr)
-		n.Args.Prepend(clo.Func.ClosureEnter...)
-		clo.Func.ClosureEnter.Set(nil)
+		n.Args.Prepend(closureArgs(clo)...)
 
 		// Replace OCLOSURE with ONAME/PFUNC.
 		n.X = clo.Func.Nname
-- 
GitLab


From 7d55669847389b8d2e490400226f272023da8605 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 1 Jan 2021 02:23:48 -0800
Subject: [PATCH 0403/2400] [dev.regabi] cmd/compile: simplify dwarfgen.declPos

The previous code was way overcomplicating things. To find out if a
variable is a closure pseudo-variable, one only needs to check
IsClosureVar. Checking Captured and Byval are only meant to be used by
closure conversion.

Passes toolstash -cmp.

Change-Id: I22622cba36ba7f60b3275d17999a8b6bb7c6719a
Reviewed-on: https://go-review.googlesource.com/c/go/+/280995
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/dwarfgen/dwarf.go | 18 ++----------------
 1 file changed, 2 insertions(+), 16 deletions(-)

diff --git a/src/cmd/compile/internal/dwarfgen/dwarf.go b/src/cmd/compile/internal/dwarfgen/dwarf.go
index 42c83b1f23..6eac9d547e 100644
--- a/src/cmd/compile/internal/dwarfgen/dwarf.go
+++ b/src/cmd/compile/internal/dwarfgen/dwarf.go
@@ -127,22 +127,8 @@ func Info(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.Scope,
 }
 
 func declPos(decl *ir.Name) src.XPos {
-	if decl.Defn != nil && (decl.Captured() || decl.Byval()) {
-		// It's not clear which position is correct for captured variables here:
-		// * decl.Pos is the wrong position for captured variables, in the inner
-		//   function, but it is the right position in the outer function.
-		// * decl.Name.Defn is nil for captured variables that were arguments
-		//   on the outer function, however the decl.Pos for those seems to be
-		//   correct.
-		// * decl.Name.Defn is the "wrong" thing for variables declared in the
-		//   header of a type switch, it's their position in the header, rather
-		//   than the position of the case statement. In principle this is the
-		//   right thing, but here we prefer the latter because it makes each
-		//   instance of the header variable local to the lexical block of its
-		//   case statement.
-		// This code is probably wrong for type switch variables that are also
-		// captured.
-		return decl.Defn.Pos()
+	if decl.IsClosureVar() {
+		decl = decl.Defn.(*ir.Name)
 	}
 	return decl.Pos()
 }
-- 
GitLab


From fad9a8b52864da738037163565e8eacc958baaa8 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 1 Jan 2021 02:39:00 -0800
Subject: [PATCH 0404/2400] [dev.regabi] cmd/compile: simplify inlining of
 closures

Closures have their own ONAMEs for captured variables, which their
function bodies refer to. So during inlining, we need to account for
this and ensure the references still work.

The previous inlining handled this by actually declaring the variables
and then either copying the original value or creating a pointer to
them, as appropriate for variables captured by value or by reference.

But this is needlessly complicated. When inlining the function body,
we need to rewrite all variable references anyway. We can just detect
closure variables and change them to directly point to the enclosing
function's version of this variable. No need for copying or further
indirection.

Does not pass toolstash -cmp. Presumably because we're able to
generate better code in some circumstances.

Change-Id: I8f0ccf7b098f39b8cd33f3bcefb875c8132d2c62
Reviewed-on: https://go-review.googlesource.com/c/go/+/280996
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/inline/inl.go | 55 +++++++++-----------------
 1 file changed, 19 insertions(+), 36 deletions(-)

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index df797da2d1..9e9d0bba7c 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -753,42 +753,6 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 	// record formals/locals for later post-processing
 	var inlfvars []ir.Node
 
-	// Handle captured variables when inlining closures.
-	if c := fn.OClosure; c != nil {
-		for _, v := range fn.ClosureVars {
-			if v.Op() == ir.OXXX {
-				continue
-			}
-
-			o := v.Outer
-			// make sure the outer param matches the inlining location
-			// NB: if we enabled inlining of functions containing OCLOSURE or refined
-			// the reassigned check via some sort of copy propagation this would most
-			// likely need to be changed to a loop to walk up to the correct Param
-			if o == nil || o.Curfn != ir.CurFunc {
-				base.Fatalf("%v: unresolvable capture %v %v\n", ir.Line(n), fn, v)
-			}
-
-			if v.Byval() {
-				iv := typecheck.Expr(inlvar(v))
-				ninit.Append(ir.NewDecl(base.Pos, ir.ODCL, iv.(*ir.Name)))
-				ninit.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, iv, o)))
-				inlvars[v] = iv
-			} else {
-				addr := typecheck.NewName(typecheck.Lookup("&" + v.Sym().Name))
-				addr.SetType(types.NewPtr(v.Type()))
-				ia := typecheck.Expr(inlvar(addr))
-				ninit.Append(ir.NewDecl(base.Pos, ir.ODCL, ia.(*ir.Name)))
-				ninit.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, ia, typecheck.NodAddr(o))))
-				inlvars[addr] = ia
-
-				// When capturing by reference, all occurrence of the captured var
-				// must be substituted with dereference of the temporary address
-				inlvars[v] = typecheck.Expr(ir.NewStarExpr(base.Pos, ia))
-			}
-		}
-	}
-
 	for _, ln := range fn.Inl.Dcl {
 		if ln.Op() != ir.ONAME {
 			continue
@@ -1088,6 +1052,25 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 	switch n.Op() {
 	case ir.ONAME:
 		n := n.(*ir.Name)
+
+		// Handle captured variables when inlining closures.
+		if n.IsClosureVar() {
+			o := n.Outer
+
+			// make sure the outer param matches the inlining location
+			// NB: if we enabled inlining of functions containing OCLOSURE or refined
+			// the reassigned check via some sort of copy propagation this would most
+			// likely need to be changed to a loop to walk up to the correct Param
+			if o == nil || o.Curfn != ir.CurFunc {
+				base.Fatalf("%v: unresolvable capture %v\n", ir.Line(n), n)
+			}
+
+			if base.Flag.LowerM > 2 {
+				fmt.Printf("substituting captured name %+v  ->  %+v\n", n, o)
+			}
+			return o
+		}
+
 		if inlvar := subst.inlvars[n]; inlvar != nil { // These will be set during inlnode
 			if base.Flag.LowerM > 2 {
 				fmt.Printf("substituting name %+v  ->  %+v\n", n, inlvar)
-- 
GitLab


From 67ad695416fbcdf9d61e5bfc0f9cd9aac313caa4 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 1 Jan 2021 03:57:21 -0800
Subject: [PATCH 0405/2400] [dev.regabi] cmd/compile: split escape analysis
 state

In a future CL, I plan to change escape analysis to walk function
literal bodies at the point they appear within the AST, rather than
separately as their own standalone function declaration. This means
escape analysis's AST-walking code will become reentrant.

To make this easier to get right, this CL splits escape analysis's
state into two separate types: one that holds all of the state shared
across the entire batch, and another that holds only the state that's
used within initFunc and walkFunc.

Incidentally, this CL reveals that a bunch of logopt code was using
e.curfn outside of the AST-walking code paths where it's actually set,
so it was always nil. That code is in need of refactoring anyway, so
I'll come back and figure out the correct values to pass later when I
address that.

Passes toolstash -cmp.

Change-Id: I1d13f47d06f7583401afa1b53fcc5ee2adaea6c8
Reviewed-on: https://go-review.googlesource.com/c/go/+/280997
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/escape/escape.go | 122 +++++++++++++---------
 1 file changed, 70 insertions(+), 52 deletions(-)

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index 98dbf54b75..17770ffbbc 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -85,20 +85,29 @@ import (
 // u[2], etc. However, we do record the implicit dereference involved
 // in indexing a slice.
 
-type escape struct {
+// A batch holds escape analysis state that's shared across an entire
+// batch of functions being analyzed at once.
+type batch struct {
 	allLocs []*location
-	labels  map[*types.Sym]labelState // known labels
 
-	curfn *ir.Func
+	heapLoc  location
+	blankLoc location
+}
+
+// An escape holds state specific to a single function being analyzed
+// within a batch.
+type escape struct {
+	*batch
+
+	curfn *ir.Func // function being analyzed
+
+	labels map[*types.Sym]labelState // known labels
 
 	// loopDepth counts the current loop nesting depth within
 	// curfn. It increments within each "for" loop and at each
 	// label with a corresponding backwards "goto" (i.e.,
 	// unstructured loop).
 	loopDepth int
-
-	heapLoc  location
-	blankLoc location
 }
 
 // An location represents an abstract location that stores a Go
@@ -167,11 +176,11 @@ func Fmt(n ir.Node) string {
 
 	if n.Op() == ir.ONAME {
 		n := n.(*ir.Name)
-		if e, ok := n.Opt.(*location); ok && e.loopDepth != 0 {
+		if loc, ok := n.Opt.(*location); ok && loc.loopDepth != 0 {
 			if text != "" {
 				text += " "
 			}
-			text += fmt.Sprintf("ld(%d)", e.loopDepth)
+			text += fmt.Sprintf("ld(%d)", loc.loopDepth)
 		}
 	}
 
@@ -187,23 +196,31 @@ func Batch(fns []*ir.Func, recursive bool) {
 		}
 	}
 
-	var e escape
-	e.heapLoc.escapes = true
+	var b batch
+	b.heapLoc.escapes = true
 
 	// Construct data-flow graph from syntax trees.
 	for _, fn := range fns {
-		e.initFunc(fn)
+		b.with(fn).initFunc()
 	}
 	for _, fn := range fns {
-		e.walkFunc(fn)
+		b.with(fn).walkFunc()
 	}
-	e.curfn = nil
 
-	e.walkAll()
-	e.finish(fns)
+	b.walkAll()
+	b.finish(fns)
+}
+
+func (b *batch) with(fn *ir.Func) *escape {
+	return &escape{
+		batch:     b,
+		curfn:     fn,
+		loopDepth: 1,
+	}
 }
 
-func (e *escape) initFunc(fn *ir.Func) {
+func (e *escape) initFunc() {
+	fn := e.curfn
 	if fn.Esc() != escFuncUnknown {
 		base.Fatalf("unexpected node: %v", fn)
 	}
@@ -212,9 +229,6 @@ func (e *escape) initFunc(fn *ir.Func) {
 		ir.Dump("escAnalyze", fn)
 	}
 
-	e.curfn = fn
-	e.loopDepth = 1
-
 	// Allocate locations for local variables.
 	for _, dcl := range fn.Dcl {
 		if dcl.Op() == ir.ONAME {
@@ -223,7 +237,8 @@ func (e *escape) initFunc(fn *ir.Func) {
 	}
 }
 
-func (e *escape) walkFunc(fn *ir.Func) {
+func (e *escape) walkFunc() {
+	fn := e.curfn
 	fn.SetEsc(escFuncStarted)
 
 	// Identify labels that mark the head of an unstructured loop.
@@ -246,8 +261,6 @@ func (e *escape) walkFunc(fn *ir.Func) {
 		}
 	})
 
-	e.curfn = fn
-	e.loopDepth = 1
 	e.block(fn.Body)
 
 	if len(e.labels) != 0 {
@@ -680,9 +693,9 @@ func (e *escape) exprSkipInit(k hole, n ir.Node) {
 
 	case ir.OCLOSURE:
 		n := n.(*ir.ClosureExpr)
-		k = e.spill(k, n)
 
 		// Link addresses of captured variables to closure.
+		k = e.spill(k, n)
 		for _, v := range n.Func.ClosureVars {
 			k := k
 			if !v.Byval() {
@@ -1174,7 +1187,7 @@ func (e *escape) newLoc(n ir.Node, transient bool) *location {
 	return loc
 }
 
-func (e *escape) oldLoc(n *ir.Name) *location {
+func (b *batch) oldLoc(n *ir.Name) *location {
 	n = canonicalNode(n).(*ir.Name)
 	return n.Opt.(*location)
 }
@@ -1216,7 +1229,7 @@ func (e *escape) discardHole() hole { return e.blankLoc.asHole() }
 
 // walkAll computes the minimal dereferences between all pairs of
 // locations.
-func (e *escape) walkAll() {
+func (b *batch) walkAll() {
 	// We use a work queue to keep track of locations that we need
 	// to visit, and repeatedly walk until we reach a fixed point.
 	//
@@ -1226,7 +1239,7 @@ func (e *escape) walkAll() {
 	// happen at most once. So we take Θ(len(e.allLocs)) walks.
 
 	// LIFO queue, has enough room for e.allLocs and e.heapLoc.
-	todo := make([]*location, 0, len(e.allLocs)+1)
+	todo := make([]*location, 0, len(b.allLocs)+1)
 	enqueue := func(loc *location) {
 		if !loc.queued {
 			todo = append(todo, loc)
@@ -1234,10 +1247,10 @@ func (e *escape) walkAll() {
 		}
 	}
 
-	for _, loc := range e.allLocs {
+	for _, loc := range b.allLocs {
 		enqueue(loc)
 	}
-	enqueue(&e.heapLoc)
+	enqueue(&b.heapLoc)
 
 	var walkgen uint32
 	for len(todo) > 0 {
@@ -1246,13 +1259,13 @@ func (e *escape) walkAll() {
 		root.queued = false
 
 		walkgen++
-		e.walkOne(root, walkgen, enqueue)
+		b.walkOne(root, walkgen, enqueue)
 	}
 }
 
 // walkOne computes the minimal number of dereferences from root to
 // all other locations.
-func (e *escape) walkOne(root *location, walkgen uint32, enqueue func(*location)) {
+func (b *batch) walkOne(root *location, walkgen uint32, enqueue func(*location)) {
 	// The data flow graph has negative edges (from addressing
 	// operations), so we use the Bellman-Ford algorithm. However,
 	// we don't have to worry about infinite negative cycles since
@@ -1287,7 +1300,7 @@ func (e *escape) walkOne(root *location, walkgen uint32, enqueue func(*location)
 			}
 		}
 
-		if e.outlives(root, l) {
+		if b.outlives(root, l) {
 			// l's value flows to root. If l is a function
 			// parameter and root is the heap or a
 			// corresponding result parameter, then record
@@ -1296,12 +1309,13 @@ func (e *escape) walkOne(root *location, walkgen uint32, enqueue func(*location)
 			if l.isName(ir.PPARAM) {
 				if (logopt.Enabled() || base.Flag.LowerM >= 2) && !l.escapes {
 					if base.Flag.LowerM >= 2 {
-						fmt.Printf("%s: parameter %v leaks to %s with derefs=%d:\n", base.FmtPos(l.n.Pos()), l.n, e.explainLoc(root), derefs)
+						fmt.Printf("%s: parameter %v leaks to %s with derefs=%d:\n", base.FmtPos(l.n.Pos()), l.n, b.explainLoc(root), derefs)
 					}
-					explanation := e.explainPath(root, l)
+					explanation := b.explainPath(root, l)
 					if logopt.Enabled() {
-						logopt.LogOpt(l.n.Pos(), "leak", "escape", ir.FuncName(e.curfn),
-							fmt.Sprintf("parameter %v leaks to %s with derefs=%d", l.n, e.explainLoc(root), derefs), explanation)
+						var e_curfn *ir.Func // TODO(mdempsky): Fix.
+						logopt.LogOpt(l.n.Pos(), "leak", "escape", ir.FuncName(e_curfn),
+							fmt.Sprintf("parameter %v leaks to %s with derefs=%d", l.n, b.explainLoc(root), derefs), explanation)
 					}
 				}
 				l.leakTo(root, derefs)
@@ -1315,9 +1329,10 @@ func (e *escape) walkOne(root *location, walkgen uint32, enqueue func(*location)
 					if base.Flag.LowerM >= 2 {
 						fmt.Printf("%s: %v escapes to heap:\n", base.FmtPos(l.n.Pos()), l.n)
 					}
-					explanation := e.explainPath(root, l)
+					explanation := b.explainPath(root, l)
 					if logopt.Enabled() {
-						logopt.LogOpt(l.n.Pos(), "escape", "escape", ir.FuncName(e.curfn), fmt.Sprintf("%v escapes to heap", l.n), explanation)
+						var e_curfn *ir.Func // TODO(mdempsky): Fix.
+						logopt.LogOpt(l.n.Pos(), "escape", "escape", ir.FuncName(e_curfn), fmt.Sprintf("%v escapes to heap", l.n), explanation)
 					}
 				}
 				l.escapes = true
@@ -1343,7 +1358,7 @@ func (e *escape) walkOne(root *location, walkgen uint32, enqueue func(*location)
 }
 
 // explainPath prints an explanation of how src flows to the walk root.
-func (e *escape) explainPath(root, src *location) []*logopt.LoggedOpt {
+func (b *batch) explainPath(root, src *location) []*logopt.LoggedOpt {
 	visited := make(map[*location]bool)
 	pos := base.FmtPos(src.n.Pos())
 	var explanation []*logopt.LoggedOpt
@@ -1362,7 +1377,7 @@ func (e *escape) explainPath(root, src *location) []*logopt.LoggedOpt {
 			base.Fatalf("path inconsistency: %v != %v", edge.src, src)
 		}
 
-		explanation = e.explainFlow(pos, dst, src, edge.derefs, edge.notes, explanation)
+		explanation = b.explainFlow(pos, dst, src, edge.derefs, edge.notes, explanation)
 
 		if dst == root {
 			break
@@ -1373,14 +1388,14 @@ func (e *escape) explainPath(root, src *location) []*logopt.LoggedOpt {
 	return explanation
 }
 
-func (e *escape) explainFlow(pos string, dst, srcloc *location, derefs int, notes *note, explanation []*logopt.LoggedOpt) []*logopt.LoggedOpt {
+func (b *batch) explainFlow(pos string, dst, srcloc *location, derefs int, notes *note, explanation []*logopt.LoggedOpt) []*logopt.LoggedOpt {
 	ops := "&"
 	if derefs >= 0 {
 		ops = strings.Repeat("*", derefs)
 	}
 	print := base.Flag.LowerM >= 2
 
-	flow := fmt.Sprintf("   flow: %s = %s%v:", e.explainLoc(dst), ops, e.explainLoc(srcloc))
+	flow := fmt.Sprintf("   flow: %s = %s%v:", b.explainLoc(dst), ops, b.explainLoc(srcloc))
 	if print {
 		fmt.Printf("%s:%s\n", pos, flow)
 	}
@@ -1391,7 +1406,8 @@ func (e *escape) explainFlow(pos string, dst, srcloc *location, derefs int, note
 		} else if srcloc != nil && srcloc.n != nil {
 			epos = srcloc.n.Pos()
 		}
-		explanation = append(explanation, logopt.NewLoggedOpt(epos, "escflow", "escape", ir.FuncName(e.curfn), flow))
+		var e_curfn *ir.Func // TODO(mdempsky): Fix.
+		explanation = append(explanation, logopt.NewLoggedOpt(epos, "escflow", "escape", ir.FuncName(e_curfn), flow))
 	}
 
 	for note := notes; note != nil; note = note.next {
@@ -1399,15 +1415,16 @@ func (e *escape) explainFlow(pos string, dst, srcloc *location, derefs int, note
 			fmt.Printf("%s:     from %v (%v) at %s\n", pos, note.where, note.why, base.FmtPos(note.where.Pos()))
 		}
 		if logopt.Enabled() {
-			explanation = append(explanation, logopt.NewLoggedOpt(note.where.Pos(), "escflow", "escape", ir.FuncName(e.curfn),
+			var e_curfn *ir.Func // TODO(mdempsky): Fix.
+			explanation = append(explanation, logopt.NewLoggedOpt(note.where.Pos(), "escflow", "escape", ir.FuncName(e_curfn),
 				fmt.Sprintf("     from %v (%v)", note.where, note.why)))
 		}
 	}
 	return explanation
 }
 
-func (e *escape) explainLoc(l *location) string {
-	if l == &e.heapLoc {
+func (b *batch) explainLoc(l *location) string {
+	if l == &b.heapLoc {
 		return "{heap}"
 	}
 	if l.n == nil {
@@ -1422,7 +1439,7 @@ func (e *escape) explainLoc(l *location) string {
 
 // outlives reports whether values stored in l may survive beyond
 // other's lifetime if stack allocated.
-func (e *escape) outlives(l, other *location) bool {
+func (b *batch) outlives(l, other *location) bool {
 	// The heap outlives everything.
 	if l.escapes {
 		return true
@@ -1503,7 +1520,7 @@ func (l *location) leakTo(sink *location, derefs int) {
 	l.paramEsc.AddHeap(derefs)
 }
 
-func (e *escape) finish(fns []*ir.Func) {
+func (b *batch) finish(fns []*ir.Func) {
 	// Record parameter tags for package export data.
 	for _, fn := range fns {
 		fn.SetEsc(escFuncTagged)
@@ -1512,12 +1529,12 @@ func (e *escape) finish(fns []*ir.Func) {
 		for _, fs := range &types.RecvsParams {
 			for _, f := range fs(fn.Type()).Fields().Slice() {
 				narg++
-				f.Note = e.paramTag(fn, narg, f)
+				f.Note = b.paramTag(fn, narg, f)
 			}
 		}
 	}
 
-	for _, loc := range e.allLocs {
+	for _, loc := range b.allLocs {
 		n := loc.n
 		if n == nil {
 			continue
@@ -1535,7 +1552,8 @@ func (e *escape) finish(fns []*ir.Func) {
 					base.WarnfAt(n.Pos(), "%v escapes to heap", n)
 				}
 				if logopt.Enabled() {
-					logopt.LogOpt(n.Pos(), "escape", "escape", ir.FuncName(e.curfn))
+					var e_curfn *ir.Func // TODO(mdempsky): Fix.
+					logopt.LogOpt(n.Pos(), "escape", "escape", ir.FuncName(e_curfn))
 				}
 			}
 			n.SetEsc(ir.EscHeap)
@@ -2061,7 +2079,7 @@ const UnsafeUintptrNote = "unsafe-uintptr"
 // marked go:uintptrescapes.
 const UintptrEscapesNote = "uintptr-escapes"
 
-func (e *escape) paramTag(fn *ir.Func, narg int, f *types.Field) string {
+func (b *batch) paramTag(fn *ir.Func, narg int, f *types.Field) string {
 	name := func() string {
 		if f.Sym != nil {
 			return f.Sym.Name
@@ -2132,7 +2150,7 @@ func (e *escape) paramTag(fn *ir.Func, narg int, f *types.Field) string {
 	}
 
 	n := f.Nname.(*ir.Name)
-	loc := e.oldLoc(n)
+	loc := b.oldLoc(n)
 	esc := loc.paramEsc
 	esc.Optimize()
 
-- 
GitLab


From bfa97ba48fa2924d9c2da1dca01fdb65b44cdb5f Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 1 Jan 2021 04:51:22 -0800
Subject: [PATCH 0406/2400] [dev.regabi] test: add another closure test case

When deciding whether a captured variable can be passed by value, the
compiler is sensitive to the order that the OCLOSURE node is
typechecked relative to the order that the variable is passed to
"checkassign". Today, for an assignment like:

    q, g = 2, func() int { return q }

we get this right because we always typecheck the full RHS expression
list before calling checkassign on any LHS expression.

But I nearly made a change that would interleave this ordering,
causing us to call checkassign on q before typechecking the function
literal. And alarmingly, there weren't any tests that caught this.

So this commit adds one.

Change-Id: I66cacd61066c7a229070861a7d973bcc434904cc
Reviewed-on: https://go-review.googlesource.com/c/go/+/280998
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 test/closure2.go | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/test/closure2.go b/test/closure2.go
index e4db05d884..812d41f8ce 100644
--- a/test/closure2.go
+++ b/test/closure2.go
@@ -9,6 +9,8 @@
 
 package main
 
+var never bool
+
 func main() {
 	{
 		type X struct {
@@ -115,4 +117,16 @@ func main() {
 			panic("g() != 2")
 		}
 	}
+
+	{
+		var g func() int
+		q := 0
+		q, g = 1, func() int { return q }
+		if never {
+			g = func() int { return 2 }
+		}
+		if g() != 1 {
+			panic("g() != 1")
+		}
+	}
 }
-- 
GitLab


From 7958a23ea326b48cb249840da5834188112889ea Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Fri, 1 Jan 2021 23:20:47 +0700
Subject: [PATCH 0407/2400] [dev.regabi] cmd/compile: use *ir.Name where
 possible in inl.go

Passes toolstash -cmp.

Change-Id: Ic99a5189ad0fca37bccb0e4b4d13793adc4f8fd8
Reviewed-on: https://go-review.googlesource.com/c/go/+/280715
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/inline/inl.go | 36 ++++++++++++++------------
 1 file changed, 19 insertions(+), 17 deletions(-)

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 9e9d0bba7c..a70c3ae362 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -639,17 +639,19 @@ func inlCallee(fn ir.Node) *ir.Func {
 	return nil
 }
 
-func inlParam(t *types.Field, as ir.Node, inlvars map[*ir.Name]ir.Node) ir.Node {
-	n := ir.AsNode(t.Nname)
-	if n == nil || ir.IsBlank(n) {
+func inlParam(t *types.Field, as ir.Node, inlvars map[*ir.Name]*ir.Name) ir.Node {
+	if t.Nname == nil {
 		return ir.BlankNode
 	}
-
-	inlvar := inlvars[n.(*ir.Name)]
+	n := t.Nname.(*ir.Name)
+	if ir.IsBlank(n) {
+		return ir.BlankNode
+	}
+	inlvar := inlvars[n]
 	if inlvar == nil {
 		base.Fatalf("missing inlvar for %v", n)
 	}
-	as.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, inlvar.(*ir.Name)))
+	as.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, inlvar))
 	inlvar.Name().Defn = as
 	return inlvar
 }
@@ -748,10 +750,10 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 	}
 
 	// Make temp names to use instead of the originals.
-	inlvars := make(map[*ir.Name]ir.Node)
+	inlvars := make(map[*ir.Name]*ir.Name)
 
 	// record formals/locals for later post-processing
-	var inlfvars []ir.Node
+	var inlfvars []*ir.Name
 
 	for _, ln := range fn.Inl.Dcl {
 		if ln.Op() != ir.ONAME {
@@ -767,7 +769,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 			// nothing should have moved to the heap yet.
 			base.Fatalf("impossible: %v", ln)
 		}
-		inlf := typecheck.Expr(inlvar(ln))
+		inlf := typecheck.Expr(inlvar(ln)).(*ir.Name)
 		inlvars[ln] = inlf
 		if base.Flag.GenDwarfInl > 0 {
 			if ln.Class_ == ir.PPARAM {
@@ -795,11 +797,11 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 	// temporaries for return values.
 	var retvars []ir.Node
 	for i, t := range fn.Type().Results().Fields().Slice() {
-		var m ir.Node
-		if n := ir.AsNode(t.Nname); n != nil && !ir.IsBlank(n) && !strings.HasPrefix(n.Sym().Name, "~r") {
-			n := n.(*ir.Name)
+		var m *ir.Name
+		if nn := t.Nname; nn != nil && !ir.IsBlank(nn.(*ir.Name)) && !strings.HasPrefix(nn.Sym().Name, "~r") {
+			n := nn.(*ir.Name)
 			m = inlvar(n)
-			m = typecheck.Expr(m)
+			m = typecheck.Expr(m).(*ir.Name)
 			inlvars[n] = m
 			delayretvars = false // found a named result parameter
 		} else {
@@ -966,7 +968,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 // Every time we expand a function we generate a new set of tmpnames,
 // PAUTO's in the calling functions, and link them off of the
 // PPARAM's, PAUTOS and PPARAMOUTs of the called function.
-func inlvar(var_ ir.Node) ir.Node {
+func inlvar(var_ *ir.Name) *ir.Name {
 	if base.Flag.LowerM > 3 {
 		fmt.Printf("inlvar %+v\n", var_)
 	}
@@ -976,14 +978,14 @@ func inlvar(var_ ir.Node) ir.Node {
 	n.Class_ = ir.PAUTO
 	n.SetUsed(true)
 	n.Curfn = ir.CurFunc // the calling function, not the called one
-	n.SetAddrtaken(var_.Name().Addrtaken())
+	n.SetAddrtaken(var_.Addrtaken())
 
 	ir.CurFunc.Dcl = append(ir.CurFunc.Dcl, n)
 	return n
 }
 
 // Synthesize a variable to store the inlined function's results in.
-func retvar(t *types.Field, i int) ir.Node {
+func retvar(t *types.Field, i int) *ir.Name {
 	n := typecheck.NewName(typecheck.LookupNum("~R", i))
 	n.SetType(t.Type)
 	n.Class_ = ir.PAUTO
@@ -1018,7 +1020,7 @@ type inlsubst struct {
 	// "return" statement.
 	delayretvars bool
 
-	inlvars map[*ir.Name]ir.Node
+	inlvars map[*ir.Name]*ir.Name
 
 	// bases maps from original PosBase to PosBase with an extra
 	// inlined call frame.
-- 
GitLab


From 1544a03198139656ef4ebc287f2287ad19c19a51 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Sat, 2 Jan 2021 00:39:14 +0700
Subject: [PATCH 0408/2400] [dev.regabi] cmd/compile: refactor redundant type
 conversion [generated]

Passes toolstash -cmp.

[git-generate]

cd src/cmd/compile
rf '
    ex . '"$(printf '%s\n' ./internal/* | paste -sd' ')"' {
        type T interface{}
        var t T
        strict t
        t.(T) -> t
    }
'
cd internal/ir
go generate

Change-Id: I492d50390e724a7216c3cd8b49d4aaf7d0c335da
Reviewed-on: https://go-review.googlesource.com/c/go/+/280716
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/inline/inl.go          | 2 +-
 src/cmd/compile/internal/typecheck/func.go      | 2 +-
 src/cmd/compile/internal/typecheck/typecheck.go | 2 +-
 src/cmd/compile/internal/walk/closure.go        | 4 ++--
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index a70c3ae362..31b97a3787 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -866,7 +866,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 			vas.Y = typecheck.NodNil()
 			vas.Y.SetType(param.Type)
 		} else {
-			lit := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(param.Type).(ir.Ntype), nil)
+			lit := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(param.Type), nil)
 			lit.List.Set(varargs)
 			vas.Y = lit
 		}
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index 2bc911882f..296755028d 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -21,7 +21,7 @@ func MakeDotArgs(typ *types.Type, args []ir.Node) ir.Node {
 		n = NodNil()
 		n.SetType(typ)
 	} else {
-		lit := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ).(ir.Ntype), nil)
+		lit := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ), nil)
 		lit.List.Append(args...)
 		lit.SetImplicit(true)
 		n = lit
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index c8d82443a1..0822a4624c 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -1686,7 +1686,7 @@ func stringtoruneslit(n *ir.ConvExpr) ir.Node {
 		i++
 	}
 
-	nn := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(n.Type()).(ir.Ntype), nil)
+	nn := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(n.Type()), nil)
 	nn.List.Set(l)
 	return Expr(nn)
 }
diff --git a/src/cmd/compile/internal/walk/closure.go b/src/cmd/compile/internal/walk/closure.go
index d4eb4eb8a3..62d2a362b1 100644
--- a/src/cmd/compile/internal/walk/closure.go
+++ b/src/cmd/compile/internal/walk/closure.go
@@ -129,7 +129,7 @@ func walkClosure(clo *ir.ClosureExpr, init *ir.Nodes) ir.Node {
 
 	typ := typecheck.ClosureType(clo)
 
-	clos := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ).(ir.Ntype), nil)
+	clos := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ), nil)
 	clos.SetEsc(clo.Esc())
 	clos.List.Set(append([]ir.Node{ir.NewUnaryExpr(base.Pos, ir.OCFUNC, fn.Nname)}, closureArgs(clo)...))
 
@@ -194,7 +194,7 @@ func walkCallPart(n *ir.SelectorExpr, init *ir.Nodes) ir.Node {
 
 	typ := typecheck.PartialCallType(n)
 
-	clos := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ).(ir.Ntype), nil)
+	clos := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ), nil)
 	clos.SetEsc(n.Esc())
 	clos.List = []ir.Node{ir.NewUnaryExpr(base.Pos, ir.OCFUNC, typecheck.MethodValueWrapper(n).Nname), n.X}
 
-- 
GitLab


From 2f2d4b4e68ab2fc448a1c2daf793b11ccde2fb16 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 2 Jan 2021 01:04:19 -0800
Subject: [PATCH 0409/2400] [dev.regabi] cmd/compile: remove {Ptr,Set}Init from
 Node interface

This CL separates out PtrInit and SetInit into a new InitNode
extension interface, and adds a new TakeInit helper function for
taking and clearing the Init list (if any) from a Node.

This allows removing miniNode.SetInit and miniNode.PtrInit, which in
turn allow getting rid of immutableEmptyNodes, and will allow
simplification of the Nodes API.

It would be nice to get rid of the default Init method too, but
there's way more code that expects to be able to call that at the
moment, so that'll have to wait.

Passes toolstash -cmp.

Change-Id: Ia8c18fab9555b774376f7f43eeecfde4f07b5946
Reviewed-on: https://go-review.googlesource.com/c/go/+/281001
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/deadcode/deadcode.go |  4 +-
 src/cmd/compile/internal/inline/inl.go        |  4 +-
 src/cmd/compile/internal/ir/mini.go           |  8 +--
 src/cmd/compile/internal/ir/node.go           | 52 ++++++++-----------
 src/cmd/compile/internal/noder/noder.go       |  2 +-
 .../compile/internal/typecheck/typecheck.go   |  2 +-
 src/cmd/compile/internal/walk/assign.go       | 10 ++--
 src/cmd/compile/internal/walk/builtin.go      |  2 +-
 src/cmd/compile/internal/walk/expr.go         |  6 +--
 src/cmd/compile/internal/walk/order.go        |  9 ++--
 src/cmd/compile/internal/walk/range.go        |  2 +-
 src/cmd/compile/internal/walk/select.go       |  9 ++--
 src/cmd/compile/internal/walk/stmt.go         | 12 ++---
 src/cmd/compile/internal/walk/walk.go         |  3 +-
 14 files changed, 52 insertions(+), 73 deletions(-)

diff --git a/src/cmd/compile/internal/deadcode/deadcode.go b/src/cmd/compile/internal/deadcode/deadcode.go
index 5453cfe396..474532bc17 100644
--- a/src/cmd/compile/internal/deadcode/deadcode.go
+++ b/src/cmd/compile/internal/deadcode/deadcode.go
@@ -84,7 +84,9 @@ func stmts(nn *ir.Nodes) {
 			}
 		}
 
-		stmts(n.PtrInit())
+		if len(n.Init()) != 0 {
+			stmts(n.(ir.InitNode).PtrInit())
+		}
 		switch n.Op() {
 		case ir.OBLOCK:
 			n := n.(*ir.BlockStmt)
diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 31b97a3787..24fbe3dac0 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -639,7 +639,7 @@ func inlCallee(fn ir.Node) *ir.Func {
 	return nil
 }
 
-func inlParam(t *types.Field, as ir.Node, inlvars map[*ir.Name]*ir.Name) ir.Node {
+func inlParam(t *types.Field, as ir.InitNode, inlvars map[*ir.Name]*ir.Name) ir.Node {
 	if t.Nname == nil {
 		return ir.BlankNode
 	}
@@ -741,7 +741,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 		callee := n.X
 		for callee.Op() == ir.OCONVNOP {
 			conv := callee.(*ir.ConvExpr)
-			ninit.Append(conv.PtrInit().Take()...)
+			ninit.Append(ir.TakeInit(conv)...)
 			callee = conv.X
 		}
 		if callee.Op() != ir.ONAME && callee.Op() != ir.OCLOSURE && callee.Op() != ir.OMETHEXPR {
diff --git a/src/cmd/compile/internal/ir/mini.go b/src/cmd/compile/internal/ir/mini.go
index 9270132621..93aa15abec 100644
--- a/src/cmd/compile/internal/ir/mini.go
+++ b/src/cmd/compile/internal/ir/mini.go
@@ -80,13 +80,7 @@ func (n *miniNode) SetDiag(x bool) { n.bits.set(miniDiag, x) }
 
 // Empty, immutable graph structure.
 
-func (n *miniNode) Init() Nodes     { return Nodes{} }
-func (n *miniNode) PtrInit() *Nodes { return &immutableEmptyNodes }
-func (n *miniNode) SetInit(x Nodes) {
-	if x != nil {
-		panic(n.no("SetInit"))
-	}
-}
+func (n *miniNode) Init() Nodes { return Nodes{} }
 
 // Additional functionality unavailable.
 
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 9536503085..9945cc987a 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -34,8 +34,6 @@ type Node interface {
 	// Abstract graph structure, for generic traversals.
 	Op() Op
 	Init() Nodes
-	PtrInit() *Nodes
-	SetInit(x Nodes)
 
 	// Fields specific to certain Ops only.
 	Type() *types.Type
@@ -90,6 +88,20 @@ func MayBeShared(n Node) bool {
 	return false
 }
 
+type InitNode interface {
+	Node
+	PtrInit() *Nodes
+	SetInit(x Nodes)
+}
+
+func TakeInit(n Node) Nodes {
+	init := n.Init()
+	if len(init) != 0 {
+		n.(InitNode).SetInit(nil)
+	}
+	return init
+}
+
 //go:generate stringer -type=Op -trimprefix=O node.go
 
 type Op uint8
@@ -311,35 +323,15 @@ const (
 // a slice to save space.
 type Nodes []Node
 
-// immutableEmptyNodes is an immutable, empty Nodes list.
-// The methods that would modify it panic instead.
-var immutableEmptyNodes = Nodes{}
-
-func (n *Nodes) mutate() {
-	if n == &immutableEmptyNodes {
-		panic("immutable Nodes.Set")
-	}
-}
-
 // Set sets n to a slice.
 // This takes ownership of the slice.
-func (n *Nodes) Set(s []Node) {
-	if n == &immutableEmptyNodes {
-		if len(s) == 0 {
-			// Allow immutableEmptyNodes.Set(nil) (a no-op).
-			return
-		}
-		n.mutate()
-	}
-	*n = s
-}
+func (n *Nodes) Set(s []Node) { *n = s }
 
 // Append appends entries to Nodes.
 func (n *Nodes) Append(a ...Node) {
 	if len(a) == 0 {
 		return
 	}
-	n.mutate()
 	*n = append(*n, a...)
 }
 
@@ -349,7 +341,6 @@ func (n *Nodes) Prepend(a ...Node) {
 	if len(a) == 0 {
 		return
 	}
-	n.mutate()
 	*n = append(a, *n...)
 }
 
@@ -544,15 +535,16 @@ func SetPos(n Node) src.XPos {
 
 // The result of InitExpr MUST be assigned back to n, e.g.
 // 	n.Left = InitExpr(init, n.Left)
-func InitExpr(init []Node, n Node) Node {
+func InitExpr(init []Node, expr Node) Node {
 	if len(init) == 0 {
-		return n
+		return expr
 	}
-	if MayBeShared(n) {
+
+	n, ok := expr.(InitNode)
+	if !ok || MayBeShared(n) {
 		// Introduce OCONVNOP to hold init list.
-		old := n
-		n = NewConvExpr(base.Pos, OCONVNOP, nil, old)
-		n.SetType(old.Type())
+		n = NewConvExpr(base.Pos, OCONVNOP, nil, expr)
+		n.SetType(expr.Type())
 		n.SetTypecheck(1)
 	}
 
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index cc8a1c7c89..948833f46e 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -1200,7 +1200,7 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) ir.Node {
 	panic("unhandled Stmt")
 }
 
-func (p *noder) assignList(expr syntax.Expr, defn ir.Node, colas bool) []ir.Node {
+func (p *noder) assignList(expr syntax.Expr, defn ir.InitNode, colas bool) []ir.Node {
 	if !colas {
 		return p.exprList(expr)
 	}
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 0822a4624c..0ee66df2cf 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -914,7 +914,7 @@ func typecheck1(n ir.Node, top int) ir.Node {
 	// Each must execute its own return n.
 }
 
-func typecheckargs(n ir.Node) {
+func typecheckargs(n ir.InitNode) {
 	var list []ir.Node
 	switch n := n.(type) {
 	default:
diff --git a/src/cmd/compile/internal/walk/assign.go b/src/cmd/compile/internal/walk/assign.go
index c01079d236..762baa0dd9 100644
--- a/src/cmd/compile/internal/walk/assign.go
+++ b/src/cmd/compile/internal/walk/assign.go
@@ -17,7 +17,7 @@ import (
 
 // walkAssign walks an OAS (AssignExpr) or OASOP (AssignOpExpr) node.
 func walkAssign(init *ir.Nodes, n ir.Node) ir.Node {
-	init.Append(n.PtrInit().Take()...)
+	init.Append(ir.TakeInit(n)...)
 
 	var left, right ir.Node
 	switch n.Op() {
@@ -124,7 +124,7 @@ func walkAssignDotType(n *ir.AssignListStmt, init *ir.Nodes) ir.Node {
 
 // walkAssignFunc walks an OAS2FUNC node.
 func walkAssignFunc(init *ir.Nodes, n *ir.AssignListStmt) ir.Node {
-	init.Append(n.PtrInit().Take()...)
+	init.Append(ir.TakeInit(n)...)
 
 	r := n.Rhs[0]
 	walkExprListSafe(n.Lhs, init)
@@ -142,7 +142,7 @@ func walkAssignFunc(init *ir.Nodes, n *ir.AssignListStmt) ir.Node {
 
 // walkAssignList walks an OAS2 node.
 func walkAssignList(init *ir.Nodes, n *ir.AssignListStmt) ir.Node {
-	init.Append(n.PtrInit().Take()...)
+	init.Append(ir.TakeInit(n)...)
 	walkExprListSafe(n.Lhs, init)
 	walkExprListSafe(n.Rhs, init)
 	return ir.NewBlockStmt(src.NoXPos, ascompatee(ir.OAS, n.Lhs, n.Rhs, init))
@@ -150,7 +150,7 @@ func walkAssignList(init *ir.Nodes, n *ir.AssignListStmt) ir.Node {
 
 // walkAssignMapRead walks an OAS2MAPR node.
 func walkAssignMapRead(init *ir.Nodes, n *ir.AssignListStmt) ir.Node {
-	init.Append(n.PtrInit().Take()...)
+	init.Append(ir.TakeInit(n)...)
 
 	r := n.Rhs[0].(*ir.IndexExpr)
 	walkExprListSafe(n.Lhs, init)
@@ -213,7 +213,7 @@ func walkAssignMapRead(init *ir.Nodes, n *ir.AssignListStmt) ir.Node {
 
 // walkAssignRecv walks an OAS2RECV node.
 func walkAssignRecv(init *ir.Nodes, n *ir.AssignListStmt) ir.Node {
-	init.Append(n.PtrInit().Take()...)
+	init.Append(ir.TakeInit(n)...)
 
 	r := n.Rhs[0].(*ir.UnaryExpr) // recv
 	walkExprListSafe(n.Lhs, init)
diff --git a/src/cmd/compile/internal/walk/builtin.go b/src/cmd/compile/internal/walk/builtin.go
index fe6045cbbd..13837eeffc 100644
--- a/src/cmd/compile/internal/walk/builtin.go
+++ b/src/cmd/compile/internal/walk/builtin.go
@@ -206,7 +206,7 @@ func walkCopy(n *ir.BinaryExpr, init *ir.Nodes, runtimecall bool) ir.Node {
 
 // walkDelete walks an ODELETE node.
 func walkDelete(init *ir.Nodes, n *ir.CallExpr) ir.Node {
-	init.Append(n.PtrInit().Take()...)
+	init.Append(ir.TakeInit(n)...)
 	map_ := n.Args[0]
 	key := n.Args[1]
 	map_ = walkExpr(map_, init)
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 1fd09b42af..7dfac30094 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -26,7 +26,7 @@ func walkExpr(n ir.Node, init *ir.Nodes) ir.Node {
 		return n
 	}
 
-	if init == n.PtrInit() {
+	if n, ok := n.(ir.InitNode); ok && init == n.PtrInit() {
 		// not okay to use n->ninit when walking n,
 		// because we might replace n with some other node
 		// and would lose the init list.
@@ -35,7 +35,7 @@ func walkExpr(n ir.Node, init *ir.Nodes) ir.Node {
 
 	if len(n.Init()) != 0 {
 		walkStmtList(n.Init())
-		init.Append(n.PtrInit().Take()...)
+		init.Append(ir.TakeInit(n)...)
 	}
 
 	lno := ir.SetPos(n)
@@ -359,7 +359,7 @@ func safeExpr(n ir.Node, init *ir.Nodes) ir.Node {
 
 	if len(n.Init()) != 0 {
 		walkStmtList(n.Init())
-		init.Append(n.PtrInit().Take()...)
+		init.Append(ir.TakeInit(n)...)
 	}
 
 	switch n.Op() {
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index e40c877ea9..679b795270 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -466,8 +466,7 @@ func (o *orderState) init(n ir.Node) {
 		}
 		return
 	}
-	o.stmtList(n.Init())
-	n.PtrInit().Set(nil)
+	o.stmtList(ir.TakeInit(n))
 }
 
 // call orders the call expression n.
@@ -938,8 +937,7 @@ func (o *orderState) stmt(n ir.Node) {
 				if !ir.IsAutoTmp(recv.X) {
 					recv.X = o.copyExpr(recv.X)
 				}
-				init := *r.PtrInit()
-				r.PtrInit().Set(nil)
+				init := ir.TakeInit(r)
 
 				colas := r.Def
 				do := func(i int, t *types.Type) {
@@ -1000,8 +998,7 @@ func (o *orderState) stmt(n ir.Node) {
 
 			// TODO(mdempsky): Is this actually necessary?
 			// walkselect appears to walk Ninit.
-			cas.Body.Prepend(cas.Init()...)
-			cas.PtrInit().Set(nil)
+			cas.Body.Prepend(ir.TakeInit(cas)...)
 		}
 
 		o.out = append(o.out, n)
diff --git a/src/cmd/compile/internal/walk/range.go b/src/cmd/compile/internal/walk/range.go
index 49a69e9751..3092b71d72 100644
--- a/src/cmd/compile/internal/walk/range.go
+++ b/src/cmd/compile/internal/walk/range.go
@@ -210,7 +210,7 @@ func walkRange(nrange *ir.RangeStmt) ir.Node {
 		a.SetTypecheck(1)
 		a.Lhs = []ir.Node{hv1, hb}
 		a.Rhs = []ir.Node{ir.NewUnaryExpr(base.Pos, ir.ORECV, ha)}
-		*nfor.Cond.PtrInit() = []ir.Node{a}
+		nfor.Cond = ir.InitExpr([]ir.Node{a}, nfor.Cond)
 		if v1 == nil {
 			body = nil
 		} else {
diff --git a/src/cmd/compile/internal/walk/select.go b/src/cmd/compile/internal/walk/select.go
index 1c5e1d7e64..c6e9b71384 100644
--- a/src/cmd/compile/internal/walk/select.go
+++ b/src/cmd/compile/internal/walk/select.go
@@ -17,8 +17,7 @@ func walkSelect(sel *ir.SelectStmt) {
 		base.Fatalf("double walkselect")
 	}
 
-	init := sel.Init()
-	sel.PtrInit().Set(nil)
+	init := ir.TakeInit(sel)
 
 	init = append(init, walkSelectCases(sel.Cases)...)
 	sel.Cases = nil
@@ -45,8 +44,7 @@ func walkSelectCases(cases []*ir.CommClause) []ir.Node {
 		l := cas.Init()
 		if cas.Comm != nil { // not default:
 			n := cas.Comm
-			l = append(l, n.Init()...)
-			n.PtrInit().Set(nil)
+			l = append(l, ir.TakeInit(n)...)
 			switch n.Op() {
 			default:
 				base.Fatalf("select %v", n.Op())
@@ -171,8 +169,7 @@ func walkSelectCases(cases []*ir.CommClause) []ir.Node {
 	for _, cas := range cases {
 		ir.SetPos(cas)
 
-		init = append(init, cas.Init()...)
-		cas.PtrInit().Set(nil)
+		init = append(init, ir.TakeInit(cas)...)
 
 		n := cas.Comm
 		if n == nil { // default:
diff --git a/src/cmd/compile/internal/walk/stmt.go b/src/cmd/compile/internal/walk/stmt.go
index 8641a58e2e..3440c66506 100644
--- a/src/cmd/compile/internal/walk/stmt.go
+++ b/src/cmd/compile/internal/walk/stmt.go
@@ -55,8 +55,7 @@ func walkStmt(n ir.Node) ir.Node {
 		if n.Typecheck() == 0 {
 			base.Fatalf("missing typecheck: %+v", n)
 		}
-		init := n.Init()
-		n.PtrInit().Set(nil)
+		init := ir.TakeInit(n)
 		n = walkExpr(n, &init)
 		if n.Op() == ir.ONAME {
 			// copy rewrote to a statement list and a temp for the length.
@@ -67,7 +66,7 @@ func walkStmt(n ir.Node) ir.Node {
 		if len(init) > 0 {
 			switch n.Op() {
 			case ir.OAS, ir.OAS2, ir.OBLOCK:
-				n.PtrInit().Prepend(init...)
+				n.(ir.InitNode).PtrInit().Prepend(init...)
 
 			default:
 				init.Append(n)
@@ -191,9 +190,8 @@ func walkDecl(n *ir.Decl) ir.Node {
 // walkFor walks an OFOR or OFORUNTIL node.
 func walkFor(n *ir.ForStmt) ir.Node {
 	if n.Cond != nil {
-		walkStmtList(n.Cond.Init())
-		init := n.Cond.Init()
-		n.Cond.PtrInit().Set(nil)
+		init := ir.TakeInit(n.Cond)
+		walkStmtList(init)
 		n.Cond = walkExpr(n.Cond, &init)
 		n.Cond = ir.InitExpr(init, n.Cond)
 	}
@@ -257,7 +255,7 @@ func walkIf(n *ir.IfStmt) ir.Node {
 func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	if len(n.Init()) != 0 {
 		walkStmtList(n.Init())
-		init.Append(n.PtrInit().Take()...)
+		init.Append(ir.TakeInit(n)...)
 	}
 
 	isBuiltinCall := n.Op() != ir.OCALLFUNC && n.Op() != ir.OCALLMETH && n.Op() != ir.OCALLINTER
diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index 25f53a8e7c..57c2d43753 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -81,8 +81,7 @@ func walkRecv(n *ir.UnaryExpr) ir.Node {
 	if n.Typecheck() == 0 {
 		base.Fatalf("missing typecheck: %+v", n)
 	}
-	init := n.Init()
-	n.PtrInit().Set(nil)
+	init := ir.TakeInit(n)
 
 	n.X = walkExpr(n.X, &init)
 	call := walkExpr(mkcall1(chanfn("chanrecv1", 2, n.X.Type()), nil, &init, n.X, typecheck.NodNil()), &init)
-- 
GitLab


From f2538033c08a8c215a19610680d66f5909c5bcdd Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 2 Jan 2021 01:27:29 -0800
Subject: [PATCH 0410/2400] [dev.regabi] cmd/compile: remove Nodes.Set
 [generated]

Just "=". It's cleaner.

Passes toolstash -cmp.

[git-generate]
cd src/cmd/compile/internal/ir
pkgs=$(go list . ../...)
rf '
	ex '"$(echo $pkgs)"' {
		var l Nodes
		var p *Nodes

		p.Set(l) -> *p = l
	}

	ex '"$(echo $pkgs)"' {
		var n InitNode
		var l Nodes

		*n.PtrInit() = l -> n.SetInit(l)
	}

	rm Nodes.Set
'

Change-Id: Ic97219792243667146a02776553942ae1189ff7d
Reviewed-on: https://go-review.googlesource.com/c/go/+/281002
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/deadcode/deadcode.go   |  4 ++--
 src/cmd/compile/internal/inline/inl.go          | 16 ++++++++--------
 src/cmd/compile/internal/ir/expr.go             | 10 +++++-----
 src/cmd/compile/internal/ir/node.go             |  4 ----
 src/cmd/compile/internal/ir/stmt.go             | 16 ++++++++--------
 src/cmd/compile/internal/noder/noder.go         | 14 +++++++-------
 src/cmd/compile/internal/pkginit/init.go        |  2 +-
 src/cmd/compile/internal/reflectdata/reflect.go |  2 +-
 src/cmd/compile/internal/ssagen/abi.go          |  2 +-
 src/cmd/compile/internal/typecheck/const.go     |  4 ++--
 src/cmd/compile/internal/typecheck/func.go      |  8 ++++----
 src/cmd/compile/internal/typecheck/iimport.go   | 16 ++++++++--------
 src/cmd/compile/internal/typecheck/typecheck.go |  8 ++++----
 src/cmd/compile/internal/walk/assign.go         |  4 ++--
 src/cmd/compile/internal/walk/builtin.go        |  6 +++---
 src/cmd/compile/internal/walk/closure.go        |  4 ++--
 src/cmd/compile/internal/walk/expr.go           |  6 +++---
 src/cmd/compile/internal/walk/order.go          | 12 ++++++------
 src/cmd/compile/internal/walk/range.go          |  2 +-
 src/cmd/compile/internal/walk/select.go         |  8 ++++----
 src/cmd/compile/internal/walk/stmt.go           |  4 ++--
 21 files changed, 74 insertions(+), 78 deletions(-)

diff --git a/src/cmd/compile/internal/deadcode/deadcode.go b/src/cmd/compile/internal/deadcode/deadcode.go
index 474532bc17..c409320fc4 100644
--- a/src/cmd/compile/internal/deadcode/deadcode.go
+++ b/src/cmd/compile/internal/deadcode/deadcode.go
@@ -38,7 +38,7 @@ func Func(fn *ir.Func) {
 		}
 	}
 
-	fn.Body.Set([]ir.Node{ir.NewBlockStmt(base.Pos, nil)})
+	fn.Body = []ir.Node{ir.NewBlockStmt(base.Pos, nil)}
 }
 
 func stmts(nn *ir.Nodes) {
@@ -114,7 +114,7 @@ func stmts(nn *ir.Nodes) {
 		}
 
 		if cut {
-			nn.Set((*nn)[:i+1])
+			*nn = (*nn)[:i+1]
 			break
 		}
 	}
diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 24fbe3dac0..2887abb061 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -544,7 +544,7 @@ func inlnode(n ir.Node, maxCost int32, inlMap map[*ir.Func]bool, edit func(ir.No
 	if as := n; as.Op() == ir.OAS2FUNC {
 		as := as.(*ir.AssignListStmt)
 		if as.Rhs[0].Op() == ir.OINLCALL {
-			as.Rhs.Set(inlconv2list(as.Rhs[0].(*ir.InlinedCallExpr)))
+			as.Rhs = inlconv2list(as.Rhs[0].(*ir.InlinedCallExpr))
 			as.SetOp(ir.OAS2)
 			as.SetTypecheck(0)
 			n = typecheck.Stmt(as)
@@ -867,7 +867,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 			vas.Y.SetType(param.Type)
 		} else {
 			lit := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(param.Type), nil)
-			lit.List.Set(varargs)
+			lit.List = varargs
 			vas.Y = lit
 		}
 	}
@@ -944,9 +944,9 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 	//dumplist("ninit post", ninit);
 
 	call := ir.NewInlinedCallExpr(base.Pos, nil, nil)
-	call.PtrInit().Set(ninit)
-	call.Body.Set(body)
-	call.ReturnVars.Set(retvars)
+	*call.PtrInit() = ninit
+	call.Body = body
+	call.ReturnVars = retvars
 	call.SetType(n.Type())
 	call.SetTypecheck(1)
 
@@ -1120,7 +1120,7 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 			for _, n := range subst.retvars {
 				as.Lhs.Append(n)
 			}
-			as.Rhs.Set(subst.list(n.Results))
+			as.Rhs = subst.list(n.Results)
 
 			if subst.delayretvars {
 				for _, n := range as.Lhs {
@@ -1139,7 +1139,7 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 		n := n.(*ir.BranchStmt)
 		m := ir.Copy(n).(*ir.BranchStmt)
 		m.SetPos(subst.updatedPos(m.Pos()))
-		m.PtrInit().Set(nil)
+		*m.PtrInit() = nil
 		p := fmt.Sprintf("%s·%d", n.Label.Name, inlgen)
 		m.Label = typecheck.Lookup(p)
 		return m
@@ -1148,7 +1148,7 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 		n := n.(*ir.LabelStmt)
 		m := ir.Copy(n).(*ir.LabelStmt)
 		m.SetPos(subst.updatedPos(m.Pos()))
-		m.PtrInit().Set(nil)
+		*m.PtrInit() = nil
 		p := fmt.Sprintf("%s·%d", n.Label.Name, inlgen)
 		m.Label = typecheck.Lookup(p)
 		return m
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 88fbdff1e0..1b88427146 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -67,7 +67,7 @@ func NewAddStringExpr(pos src.XPos, list []Node) *AddStringExpr {
 	n := &AddStringExpr{}
 	n.pos = pos
 	n.op = OADDSTR
-	n.List.Set(list)
+	n.List = list
 	return n
 }
 
@@ -173,7 +173,7 @@ func NewCallExpr(pos src.XPos, op Op, fun Node, args []Node) *CallExpr {
 	n.pos = pos
 	n.orig = n
 	n.SetOp(op)
-	n.Args.Set(args)
+	n.Args = args
 	return n
 }
 
@@ -231,7 +231,7 @@ func NewCompLitExpr(pos src.XPos, op Op, typ Ntype, list []Node) *CompLitExpr {
 	n := &CompLitExpr{Ntype: typ}
 	n.pos = pos
 	n.SetOp(op)
-	n.List.Set(list)
+	n.List = list
 	n.orig = n
 	return n
 }
@@ -364,8 +364,8 @@ func NewInlinedCallExpr(pos src.XPos, body, retvars []Node) *InlinedCallExpr {
 	n := &InlinedCallExpr{}
 	n.pos = pos
 	n.op = OINLCALL
-	n.Body.Set(body)
-	n.ReturnVars.Set(retvars)
+	n.Body = body
+	n.ReturnVars = retvars
 	return n
 }
 
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 9945cc987a..9d1ee17aa8 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -323,10 +323,6 @@ const (
 // a slice to save space.
 type Nodes []Node
 
-// Set sets n to a slice.
-// This takes ownership of the slice.
-func (n *Nodes) Set(s []Node) { *n = s }
-
 // Append appends entries to Nodes.
 func (n *Nodes) Append(a ...Node) {
 	if len(a) == 0 {
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index 9c2cba9a08..b13c6b7795 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -70,8 +70,8 @@ func NewAssignListStmt(pos src.XPos, op Op, lhs, rhs []Node) *AssignListStmt {
 	n := &AssignListStmt{}
 	n.pos = pos
 	n.SetOp(op)
-	n.Lhs.Set(lhs)
-	n.Rhs.Set(rhs)
+	n.Lhs = lhs
+	n.Rhs = rhs
 	return n
 }
 
@@ -141,7 +141,7 @@ func NewBlockStmt(pos src.XPos, list []Node) *BlockStmt {
 		}
 	}
 	n.op = OBLOCK
-	n.List.Set(list)
+	n.List = list
 	return n
 }
 
@@ -216,7 +216,7 @@ func NewForStmt(pos src.XPos, init Node, cond, post Node, body []Node) *ForStmt
 	if init != nil {
 		n.init = []Node{init}
 	}
-	n.Body.Set(body)
+	n.Body = body
 	return n
 }
 
@@ -262,8 +262,8 @@ func NewIfStmt(pos src.XPos, cond Node, body, els []Node) *IfStmt {
 	n := &IfStmt{Cond: cond}
 	n.pos = pos
 	n.op = OIF
-	n.Body.Set(body)
-	n.Else.Set(els)
+	n.Body = body
+	n.Else = els
 	return n
 }
 
@@ -315,7 +315,7 @@ func NewRangeStmt(pos src.XPos, key, value, x Node, body []Node) *RangeStmt {
 	n := &RangeStmt{X: x, Key: key, Value: value}
 	n.pos = pos
 	n.op = ORANGE
-	n.Body.Set(body)
+	n.Body = body
 	return n
 }
 
@@ -331,7 +331,7 @@ func NewReturnStmt(pos src.XPos, results []Node) *ReturnStmt {
 	n.pos = pos
 	n.op = ORETURN
 	n.orig = n
-	n.Results.Set(results)
+	n.Results = results
 	return n
 }
 
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 948833f46e..678e378291 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -245,7 +245,7 @@ func (p *noder) funcBody(fn *ir.Func, block *syntax.BlockStmt) {
 		if body == nil {
 			body = []ir.Node{ir.NewBlockStmt(base.Pos, nil)}
 		}
-		fn.Body.Set(body)
+		fn.Body = body
 
 		base.Pos = p.makeXPos(block.Rbrace)
 		fn.Endlineno = base.Pos
@@ -772,7 +772,7 @@ func (p *noder) expr(expr syntax.Expr) ir.Node {
 		for i, e := range l {
 			l[i] = p.wrapname(expr.ElemList[i], e)
 		}
-		n.List.Set(l)
+		n.List = l
 		base.Pos = p.makeXPos(expr.Rbrace)
 		return n
 	case *syntax.KeyValueExpr:
@@ -1128,8 +1128,8 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) ir.Node {
 		if list, ok := stmt.Lhs.(*syntax.ListExpr); ok && len(list.ElemList) != 1 || len(rhs) != 1 {
 			n := ir.NewAssignListStmt(p.pos(stmt), ir.OAS2, nil, nil)
 			n.Def = stmt.Op == syntax.Def
-			n.Lhs.Set(p.assignList(stmt.Lhs, n, n.Def))
-			n.Rhs.Set(rhs)
+			n.Lhs = p.assignList(stmt.Lhs, n, n.Def)
+			n.Rhs = rhs
 			return n
 		}
 
@@ -1276,7 +1276,7 @@ func (p *noder) ifStmt(stmt *syntax.IfStmt) ir.Node {
 		e := p.stmt(stmt.Else)
 		if e.Op() == ir.OBLOCK {
 			e := e.(*ir.BlockStmt)
-			n.Else.Set(e.List)
+			n.Else = e.List
 		} else {
 			n.Else = []ir.Node{e}
 		}
@@ -1301,7 +1301,7 @@ func (p *noder) forStmt(stmt *syntax.ForStmt) ir.Node {
 				n.Value = lhs[1]
 			}
 		}
-		n.Body.Set(p.blockStmt(stmt.Body))
+		n.Body = p.blockStmt(stmt.Body)
 		p.closeAnotherScope()
 		return n
 	}
@@ -1359,7 +1359,7 @@ func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *ir.TypeSwitch
 			body = body[:len(body)-1]
 		}
 
-		n.Body.Set(p.stmtsFall(body, true))
+		n.Body = p.stmtsFall(body, true)
 		if l := len(n.Body); l > 0 && n.Body[l-1].Op() == ir.OFALL {
 			if tswitch != nil {
 				base.Errorf("cannot fallthrough in type switch")
diff --git a/src/cmd/compile/internal/pkginit/init.go b/src/cmd/compile/internal/pkginit/init.go
index 24fe1a7628..a32e09879c 100644
--- a/src/cmd/compile/internal/pkginit/init.go
+++ b/src/cmd/compile/internal/pkginit/init.go
@@ -49,7 +49,7 @@ func Task() *ir.Name {
 		fn.Dcl = append(fn.Dcl, typecheck.InitTodoFunc.Dcl...)
 		typecheck.InitTodoFunc.Dcl = nil
 
-		fn.Body.Set(nf)
+		fn.Body = nf
 		typecheck.FinishFuncBody()
 
 		typecheck.Func(fn)
diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index 5f88262ddf..f926765326 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -1798,7 +1798,7 @@ func methodWrapper(rcvr *types.Type, method *types.Field) *obj.LSym {
 	} else {
 		fn.SetWrapper(true) // ignore frame for panic+recover matching
 		call := ir.NewCallExpr(base.Pos, ir.OCALL, dot, nil)
-		call.Args.Set(ir.ParamNames(tfn.Type()))
+		call.Args = ir.ParamNames(tfn.Type())
 		call.IsDDD = tfn.Type().IsVariadic()
 		if method.Type.NumResults() > 0 {
 			ret := ir.NewReturnStmt(base.Pos, nil)
diff --git a/src/cmd/compile/internal/ssagen/abi.go b/src/cmd/compile/internal/ssagen/abi.go
index cd5d962b91..1c013dd2d8 100644
--- a/src/cmd/compile/internal/ssagen/abi.go
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -303,7 +303,7 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 		tail = ir.NewBranchStmt(base.Pos, ir.ORETJMP, f.Nname.Sym())
 	} else {
 		call := ir.NewCallExpr(base.Pos, ir.OCALL, f.Nname, nil)
-		call.Args.Set(ir.ParamNames(tfn.Type()))
+		call.Args = ir.ParamNames(tfn.Type())
 		call.IsDDD = tfn.Type().IsVariadic()
 		tail = call
 		if tfn.Type().NumResults() > 0 {
diff --git a/src/cmd/compile/internal/typecheck/const.go b/src/cmd/compile/internal/typecheck/const.go
index 5259218ef9..d6bf101974 100644
--- a/src/cmd/compile/internal/typecheck/const.go
+++ b/src/cmd/compile/internal/typecheck/const.go
@@ -509,7 +509,7 @@ func EvalConst(n ir.Node) ir.Node {
 				}
 
 				nl := ir.Copy(n).(*ir.AddStringExpr)
-				nl.List.Set(s[i:i2])
+				nl.List = s[i:i2]
 				newList = append(newList, OrigConst(nl, constant.MakeString(strings.Join(strs, ""))))
 				i = i2 - 1
 			} else {
@@ -518,7 +518,7 @@ func EvalConst(n ir.Node) ir.Node {
 		}
 
 		nn := ir.Copy(n).(*ir.AddStringExpr)
-		nn.List.Set(newList)
+		nn.List = newList
 		return nn
 
 	case ir.OCAP, ir.OLEN:
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index 296755028d..8592397004 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -52,7 +52,7 @@ func FixVariadicCall(call *ir.CallExpr) {
 		extra[i] = nil // allow GC
 	}
 
-	call.Args.Set(append(args[:vi], slice))
+	call.Args = append(args[:vi], slice)
 	call.IsDDD = true
 }
 
@@ -313,7 +313,7 @@ func MethodValueWrapper(dot *ir.SelectorExpr) *ir.Func {
 	}
 
 	call := ir.NewCallExpr(base.Pos, ir.OCALL, ir.NewSelectorExpr(base.Pos, ir.OXDOT, ptr, meth), nil)
-	call.Args.Set(ir.ParamNames(tfn.Type()))
+	call.Args = ir.ParamNames(tfn.Type())
 	call.IsDDD = tfn.Type().IsVariadic()
 	if t0.NumResults() != 0 {
 		ret := ir.NewReturnStmt(base.Pos, nil)
@@ -323,7 +323,7 @@ func MethodValueWrapper(dot *ir.SelectorExpr) *ir.Func {
 		body = append(body, call)
 	}
 
-	fn.Body.Set(body)
+	fn.Body = body
 	FinishFuncBody()
 
 	Func(fn)
@@ -798,7 +798,7 @@ func tcMake(n *ir.CallExpr) ir.Node {
 		return n
 	}
 
-	n.Args.Set(nil)
+	n.Args = nil
 	l := args[0]
 	l = typecheck(l, ctxType)
 	t := l.Type()
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 00ecd9b819..0caac362e3 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -779,7 +779,7 @@ func (r *importReader) caseList(switchExpr ir.Node) []*ir.CaseClause {
 	cases := make([]*ir.CaseClause, r.uint64())
 	for i := range cases {
 		cas := ir.NewCaseStmt(r.pos(), nil, nil)
-		cas.List.Set(r.stmtList())
+		cas.List = r.stmtList()
 		if namedTypeSwitch {
 			// Note: per-case variables will have distinct, dotted
 			// names after import. That's okay: swt.go only needs
@@ -789,7 +789,7 @@ func (r *importReader) caseList(switchExpr ir.Node) []*ir.CaseClause {
 			cas.Var = caseVar
 			caseVar.Defn = switchExpr
 		}
-		cas.Body.Set(r.stmtList())
+		cas.Body = r.stmtList()
 		cases[i] = cas
 	}
 	return cases
@@ -932,7 +932,7 @@ func (r *importReader) node() ir.Node {
 
 	case ir.OCOPY, ir.OCOMPLEX, ir.OREAL, ir.OIMAG, ir.OAPPEND, ir.OCAP, ir.OCLOSE, ir.ODELETE, ir.OLEN, ir.OMAKE, ir.ONEW, ir.OPANIC, ir.ORECOVER, ir.OPRINT, ir.OPRINTN:
 		n := builtinCall(r.pos(), op)
-		n.Args.Set(r.exprList())
+		n.Args = r.exprList()
 		if op == ir.OAPPEND {
 			n.IsDDD = r.bool()
 		}
@@ -945,7 +945,7 @@ func (r *importReader) node() ir.Node {
 		pos := r.pos()
 		init := r.stmtList()
 		n := ir.NewCallExpr(pos, ir.OCALL, r.expr(), r.exprList())
-		n.PtrInit().Set(init)
+		*n.PtrInit() = init
 		n.IsDDD = r.bool()
 		return n
 
@@ -1033,14 +1033,14 @@ func (r *importReader) node() ir.Node {
 	case ir.OIF:
 		pos, init := r.pos(), r.stmtList()
 		n := ir.NewIfStmt(pos, r.expr(), r.stmtList(), r.stmtList())
-		n.PtrInit().Set(init)
+		*n.PtrInit() = init
 		return n
 
 	case ir.OFOR:
 		pos, init := r.pos(), r.stmtList()
 		cond, post := r.exprsOrNil()
 		n := ir.NewForStmt(pos, nil, cond, post, r.stmtList())
-		n.PtrInit().Set(init)
+		*n.PtrInit() = init
 		return n
 
 	case ir.ORANGE:
@@ -1052,7 +1052,7 @@ func (r *importReader) node() ir.Node {
 		pos := r.pos()
 		init := r.stmtList()
 		n := ir.NewSelectStmt(pos, r.commList())
-		n.PtrInit().Set(init)
+		*n.PtrInit() = init
 		return n
 
 	case ir.OSWITCH:
@@ -1060,7 +1060,7 @@ func (r *importReader) node() ir.Node {
 		init := r.stmtList()
 		x, _ := r.exprsOrNil()
 		n := ir.NewSwitchStmt(pos, x, r.caseList(x))
-		n.PtrInit().Set(init)
+		*n.PtrInit() = init
 		return n
 
 	// case OCASE:
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 0ee66df2cf..d0922e8508 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -64,7 +64,7 @@ func FuncBody(n *ir.Func) {
 	CheckUnused(n)
 	CheckReturn(n)
 	if base.Errors() > errorsBefore {
-		n.Body.Set(nil) // type errors; do not compile
+		n.Body = nil // type errors; do not compile
 	}
 }
 
@@ -971,9 +971,9 @@ func typecheckargs(n ir.InitNode) {
 
 	switch n := n.(type) {
 	case *ir.CallExpr:
-		n.Args.Set(list)
+		n.Args = list
 	case *ir.ReturnStmt:
-		n.Results.Set(list)
+		n.Results = list
 	}
 
 	n.PtrInit().Append(Stmt(as))
@@ -1687,7 +1687,7 @@ func stringtoruneslit(n *ir.ConvExpr) ir.Node {
 	}
 
 	nn := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(n.Type()), nil)
-	nn.List.Set(l)
+	nn.List = l
 	return Expr(nn)
 }
 
diff --git a/src/cmd/compile/internal/walk/assign.go b/src/cmd/compile/internal/walk/assign.go
index 762baa0dd9..7f3e4cc995 100644
--- a/src/cmd/compile/internal/walk/assign.go
+++ b/src/cmd/compile/internal/walk/assign.go
@@ -264,7 +264,7 @@ func walkReturn(n *ir.ReturnStmt) ir.Node {
 		// move function calls out, to make ascompatee's job easier.
 		walkExprListSafe(n.Results, n.PtrInit())
 
-		n.Results.Set(ascompatee(n.Op(), rl, n.Results, n.PtrInit()))
+		n.Results = ascompatee(n.Op(), rl, n.Results, n.PtrInit())
 		return n
 	}
 	walkExprList(n.Results, n.PtrInit())
@@ -281,7 +281,7 @@ func walkReturn(n *ir.ReturnStmt) ir.Node {
 		a := ir.NewAssignStmt(base.Pos, nname, rhs[i])
 		res[i] = convas(a, n.PtrInit())
 	}
-	n.Results.Set(res)
+	n.Results = res
 	return n
 }
 
diff --git a/src/cmd/compile/internal/walk/builtin.go b/src/cmd/compile/internal/walk/builtin.go
index 13837eeffc..a061181e2f 100644
--- a/src/cmd/compile/internal/walk/builtin.go
+++ b/src/cmd/compile/internal/walk/builtin.go
@@ -531,7 +531,7 @@ func walkPrint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 			t = append(t, n)
 		}
 		t = append(t, ir.NewString("\n"))
-		nn.Args.Set(t)
+		nn.Args = t
 	}
 
 	// Collapse runs of constant strings.
@@ -551,7 +551,7 @@ func walkPrint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 			i++
 		}
 	}
-	nn.Args.Set(t)
+	nn.Args = t
 
 	calls := []ir.Node{mkcall("printlock", nil, init)}
 	for i, n := range nn.Args {
@@ -653,7 +653,7 @@ func walkPrint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 	walkExprList(calls, init)
 
 	r := ir.NewBlockStmt(base.Pos, nil)
-	r.List.Set(calls)
+	r.List = calls
 	return walkStmt(typecheck.Stmt(r))
 }
 
diff --git a/src/cmd/compile/internal/walk/closure.go b/src/cmd/compile/internal/walk/closure.go
index 62d2a362b1..fcdb43f113 100644
--- a/src/cmd/compile/internal/walk/closure.go
+++ b/src/cmd/compile/internal/walk/closure.go
@@ -107,7 +107,7 @@ func Closure(fn *ir.Func) {
 
 		if len(body) > 0 {
 			typecheck.Stmts(body)
-			fn.Enter.Set(body)
+			fn.Enter = body
 			fn.SetNeedctxt(true)
 		}
 	}
@@ -131,7 +131,7 @@ func walkClosure(clo *ir.ClosureExpr, init *ir.Nodes) ir.Node {
 
 	clos := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ), nil)
 	clos.SetEsc(clo.Esc())
-	clos.List.Set(append([]ir.Node{ir.NewUnaryExpr(base.Pos, ir.OCFUNC, fn.Nname)}, closureArgs(clo)...))
+	clos.List = append([]ir.Node{ir.NewUnaryExpr(base.Pos, ir.OCFUNC, fn.Nname)}, closureArgs(clo)...)
 
 	addr := typecheck.NodAddr(clos)
 	addr.SetEsc(clo.Esc())
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 7dfac30094..8a56526a36 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -477,7 +477,7 @@ func walkAddString(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
 
 	cat := typecheck.LookupRuntime(fn)
 	r := ir.NewCallExpr(base.Pos, ir.OCALL, cat, nil)
-	r.Args.Set(args)
+	r.Args = args
 	r1 := typecheck.Expr(r)
 	r1 = walkExpr(r1, init)
 	r1.SetType(n.Type())
@@ -562,8 +562,8 @@ func walkCall1(n *ir.CallExpr, init *ir.Nodes) {
 		}
 	}
 
-	n.Args.Set(tempAssigns)
-	n.Rargs.Set(args)
+	n.Args = tempAssigns
+	n.Rargs = args
 }
 
 // walkDivMod walks an ODIV or OMOD node.
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index 679b795270..767af07414 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -423,7 +423,7 @@ func orderBlock(n *ir.Nodes, free map[string][]*ir.Name) {
 	order.edge()
 	order.stmtList(*n)
 	order.cleanTemp(mark)
-	n.Set(order.out)
+	*n = order.out
 }
 
 // exprInPlace orders the side effects in *np and
@@ -1233,9 +1233,9 @@ func (o *orderState) expr1(n, lhs ir.Node) ir.Node {
 		// If left-hand side doesn't cause a short-circuit, issue right-hand side.
 		nif := ir.NewIfStmt(base.Pos, r, nil, nil)
 		if n.Op() == ir.OANDAND {
-			nif.Body.Set(gen)
+			nif.Body = gen
 		} else {
-			nif.Else.Set(gen)
+			nif.Else = gen
 		}
 		o.out = append(o.out, nif)
 		return r
@@ -1401,7 +1401,7 @@ func (o *orderState) expr1(n, lhs ir.Node) ir.Node {
 
 			statics = append(statics, r)
 		}
-		n.List.Set(statics)
+		n.List = statics
 
 		if len(dynamics) == 0 {
 			return n
@@ -1448,8 +1448,8 @@ func (o *orderState) as2(n *ir.AssignListStmt) {
 	o.out = append(o.out, n)
 
 	as := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-	as.Lhs.Set(left)
-	as.Rhs.Set(tmplist)
+	as.Lhs = left
+	as.Rhs = tmplist
 	o.stmt(typecheck.Stmt(as))
 }
 
diff --git a/src/cmd/compile/internal/walk/range.go b/src/cmd/compile/internal/walk/range.go
index 3092b71d72..9225c429f0 100644
--- a/src/cmd/compile/internal/walk/range.go
+++ b/src/cmd/compile/internal/walk/range.go
@@ -429,7 +429,7 @@ func arrayClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
 	// 	i = len(a) - 1
 	// }
 	n := ir.NewIfStmt(base.Pos, nil, nil, nil)
-	n.Body.Set(nil)
+	n.Body = nil
 	n.Cond = ir.NewBinaryExpr(base.Pos, ir.ONE, ir.NewUnaryExpr(base.Pos, ir.OLEN, a), ir.NewInt(0))
 
 	// hp = &a[0]
diff --git a/src/cmd/compile/internal/walk/select.go b/src/cmd/compile/internal/walk/select.go
index c6e9b71384..776b020155 100644
--- a/src/cmd/compile/internal/walk/select.go
+++ b/src/cmd/compile/internal/walk/select.go
@@ -22,7 +22,7 @@ func walkSelect(sel *ir.SelectStmt) {
 	init = append(init, walkSelectCases(sel.Cases)...)
 	sel.Cases = nil
 
-	sel.Compiled.Set(init)
+	sel.Compiled = init
 	walkStmtList(sel.Compiled)
 
 	base.Pos = lno
@@ -104,7 +104,7 @@ func walkSelectCases(cases []*ir.CommClause) []ir.Node {
 		n := cas.Comm
 		ir.SetPos(n)
 		r := ir.NewIfStmt(base.Pos, nil, nil, nil)
-		r.PtrInit().Set(cas.Init())
+		*r.PtrInit() = cas.Init()
 		var call ir.Node
 		switch n.Op() {
 		default:
@@ -136,8 +136,8 @@ func walkSelectCases(cases []*ir.CommClause) []ir.Node {
 		}
 
 		r.Cond = typecheck.Expr(call)
-		r.Body.Set(cas.Body)
-		r.Else.Set(append(dflt.Init(), dflt.Body...))
+		r.Body = cas.Body
+		r.Else = append(dflt.Init(), dflt.Body...)
 		return []ir.Node{r, ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)}
 	}
 
diff --git a/src/cmd/compile/internal/walk/stmt.go b/src/cmd/compile/internal/walk/stmt.go
index 3440c66506..460c0a7c10 100644
--- a/src/cmd/compile/internal/walk/stmt.go
+++ b/src/cmd/compile/internal/walk/stmt.go
@@ -61,7 +61,7 @@ func walkStmt(n ir.Node) ir.Node {
 			// copy rewrote to a statement list and a temp for the length.
 			// Throw away the temp to avoid plain values as statements.
 			n = ir.NewBlockStmt(n.Pos(), init)
-			init.Set(nil)
+			init = nil
 		}
 		if len(init) > 0 {
 			switch n.Op() {
@@ -265,7 +265,7 @@ func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 		last := len(n.Args) - 1
 		if va := n.Args[last]; va.Op() == ir.OSLICELIT {
 			va := va.(*ir.CompLitExpr)
-			n.Args.Set(append(n.Args[:last], va.List...))
+			n.Args = append(n.Args[:last], va.List...)
 			n.IsDDD = false
 		}
 	}
-- 
GitLab


From b1747756e30a4e1ea0698ddbbb08f5cb7d97b1ba Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 2 Jan 2021 02:40:42 -0800
Subject: [PATCH 0411/2400] [dev.regabi] cmd/compile: reorganize escape
 analysis somewhat

To do closure conversion during escape analysis, we need to walk the
AST in order. So this CL makes a few changes:

1. Function literals are walked where they appear in their enclosing
function, rather than as independent functions.

2. Walking "range" and "switch" statements is reordered to visit the
X/Tag expression up front, before the body.

3. Most assignments are refactored to use a new assignList helper,
which handles 1:1, 2:1, and N:N assignments. N:1 function call
assignments are still handled directly by the OAS2FUNC case.

4. A latent missed-optimization in escape.addr is fixed: the
ONAMEOFFSET case was failing to update k with the result of calling
e.addr(n.Name_). In partice, this probably wasn't an issue because
ONAMEOFFSET is likely only used for PEXTERN variables (which are
treated as heap memory anyway) or code generated by walk (which has
already gone through escape analysis).

5. Finally, don't replace k with discardHole at the end of
escape.addr. This is already handled at the start of escape.expr, and
we'll want to be able to access the hole's location after escape.expr
returns.

Passes toolstash -cmp.

Change-Id: I2325234346b12b10056a360c489692bab8fdbd93
Reviewed-on: https://go-review.googlesource.com/c/go/+/281003
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/escape/escape.go | 110 ++++++++++++----------
 1 file changed, 59 insertions(+), 51 deletions(-)

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index 17770ffbbc..1aba0a3fd2 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -201,10 +201,12 @@ func Batch(fns []*ir.Func, recursive bool) {
 
 	// Construct data-flow graph from syntax trees.
 	for _, fn := range fns {
-		b.with(fn).initFunc()
+		b.initFunc(fn)
 	}
 	for _, fn := range fns {
-		b.with(fn).walkFunc()
+		if !fn.IsHiddenClosure() {
+			b.walkFunc(fn)
+		}
 	}
 
 	b.walkAll()
@@ -219,8 +221,8 @@ func (b *batch) with(fn *ir.Func) *escape {
 	}
 }
 
-func (e *escape) initFunc() {
-	fn := e.curfn
+func (b *batch) initFunc(fn *ir.Func) {
+	e := b.with(fn)
 	if fn.Esc() != escFuncUnknown {
 		base.Fatalf("unexpected node: %v", fn)
 	}
@@ -237,8 +239,8 @@ func (e *escape) initFunc() {
 	}
 }
 
-func (e *escape) walkFunc() {
-	fn := e.curfn
+func (b *batch) walkFunc(fn *ir.Func) {
+	e := b.with(fn)
 	fn.SetEsc(escFuncStarted)
 
 	// Identify labels that mark the head of an unstructured loop.
@@ -366,54 +368,52 @@ func (e *escape) stmt(n ir.Node) {
 	case ir.ORANGE:
 		// for Key, Value = range X { Body }
 		n := n.(*ir.RangeStmt)
-		e.loopDepth++
-		e.addr(n.Key)
-		k := e.addr(n.Value)
-		e.block(n.Body)
-		e.loopDepth--
 
 		// X is evaluated outside the loop.
+		tmp := e.newLoc(nil, false)
+		e.expr(tmp.asHole(), n.X)
+
+		e.loopDepth++
+		ks := e.addrs([]ir.Node{n.Key, n.Value})
 		if n.X.Type().IsArray() {
-			k = k.note(n, "range")
+			e.flow(ks[1].note(n, "range"), tmp)
 		} else {
-			k = k.deref(n, "range-deref")
+			e.flow(ks[1].deref(n, "range-deref"), tmp)
 		}
-		e.expr(e.later(k), n.X)
+
+		e.block(n.Body)
+		e.loopDepth--
 
 	case ir.OSWITCH:
 		n := n.(*ir.SwitchStmt)
-		typesw := n.Tag != nil && n.Tag.Op() == ir.OTYPESW
 
-		var ks []hole
-		for _, cas := range n.Cases { // cases
-			if typesw && n.Tag.(*ir.TypeSwitchGuard).Tag != nil {
-				cv := cas.Var
-				k := e.dcl(cv) // type switch variables have no ODCL.
-				if cv.Type().HasPointers() {
-					ks = append(ks, k.dotType(cv.Type(), cas, "switch case"))
+		if guard, ok := n.Tag.(*ir.TypeSwitchGuard); ok {
+			var ks []hole
+			if guard.Tag != nil {
+				for _, cas := range n.Cases {
+					cv := cas.Var
+					k := e.dcl(cv) // type switch variables have no ODCL.
+					if cv.Type().HasPointers() {
+						ks = append(ks, k.dotType(cv.Type(), cas, "switch case"))
+					}
 				}
 			}
-
-			e.discards(cas.List)
-			e.block(cas.Body)
-		}
-
-		if typesw {
 			e.expr(e.teeHole(ks...), n.Tag.(*ir.TypeSwitchGuard).X)
 		} else {
 			e.discard(n.Tag)
 		}
 
+		for _, cas := range n.Cases {
+			e.discards(cas.List)
+			e.block(cas.Body)
+		}
+
 	case ir.OSELECT:
 		n := n.(*ir.SelectStmt)
 		for _, cas := range n.Cases {
 			e.stmt(cas.Comm)
 			e.block(cas.Body)
 		}
-	case ir.OSELRECV2:
-		n := n.(*ir.AssignListStmt)
-		e.assign(n.Lhs[0], n.Rhs[0], "selrecv", n)
-		e.assign(n.Lhs[1], nil, "selrecv", n)
 	case ir.ORECV:
 		// TODO(mdempsky): Consider e.discard(n.Left).
 		n := n.(*ir.UnaryExpr)
@@ -425,28 +425,24 @@ func (e *escape) stmt(n ir.Node) {
 
 	case ir.OAS:
 		n := n.(*ir.AssignStmt)
-		e.assign(n.X, n.Y, "assign", n)
+		e.assignList([]ir.Node{n.X}, []ir.Node{n.Y}, "assign", n)
 	case ir.OASOP:
 		n := n.(*ir.AssignOpStmt)
-		e.assign(n.X, n.Y, "assign", n)
+		// TODO(mdempsky): Worry about OLSH/ORSH?
+		e.assignList([]ir.Node{n.X}, []ir.Node{n.Y}, "assign", n)
 	case ir.OAS2:
 		n := n.(*ir.AssignListStmt)
-		for i, nl := range n.Lhs {
-			e.assign(nl, n.Rhs[i], "assign-pair", n)
-		}
+		e.assignList(n.Lhs, n.Rhs, "assign-pair", n)
 
 	case ir.OAS2DOTTYPE: // v, ok = x.(type)
 		n := n.(*ir.AssignListStmt)
-		e.assign(n.Lhs[0], n.Rhs[0], "assign-pair-dot-type", n)
-		e.assign(n.Lhs[1], nil, "assign-pair-dot-type", n)
+		e.assignList(n.Lhs, n.Rhs, "assign-pair-dot-type", n)
 	case ir.OAS2MAPR: // v, ok = m[k]
 		n := n.(*ir.AssignListStmt)
-		e.assign(n.Lhs[0], n.Rhs[0], "assign-pair-mapr", n)
-		e.assign(n.Lhs[1], nil, "assign-pair-mapr", n)
-	case ir.OAS2RECV: // v, ok = <-ch
+		e.assignList(n.Lhs, n.Rhs, "assign-pair-mapr", n)
+	case ir.OAS2RECV, ir.OSELRECV2: // v, ok = <-ch
 		n := n.(*ir.AssignListStmt)
-		e.assign(n.Lhs[0], n.Rhs[0], "assign-pair-receive", n)
-		e.assign(n.Lhs[1], nil, "assign-pair-receive", n)
+		e.assignList(n.Lhs, n.Rhs, "assign-pair-receive", n)
 
 	case ir.OAS2FUNC:
 		n := n.(*ir.AssignListStmt)
@@ -455,9 +451,11 @@ func (e *escape) stmt(n ir.Node) {
 	case ir.ORETURN:
 		n := n.(*ir.ReturnStmt)
 		results := e.curfn.Type().Results().FieldSlice()
-		for i, v := range n.Results {
-			e.assign(ir.AsNode(results[i].Nname), v, "return", n)
+		dsts := make([]ir.Node, len(results))
+		for i, res := range results {
+			dsts[i] = res.Nname.(*ir.Name)
 		}
+		e.assignList(dsts, n.Results, "return", n)
 	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER, ir.OCLOSE, ir.OCOPY, ir.ODELETE, ir.OPANIC, ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
 		e.call(nil, n, nil)
 	case ir.OGO, ir.ODEFER:
@@ -694,6 +692,10 @@ func (e *escape) exprSkipInit(k hole, n ir.Node) {
 	case ir.OCLOSURE:
 		n := n.(*ir.ClosureExpr)
 
+		if fn := n.Func; fn.IsHiddenClosure() {
+			e.walkFunc(fn)
+		}
+
 		// Link addresses of captured variables to closure.
 		k = e.spill(k, n)
 		for _, v := range n.Func.ClosureVars {
@@ -795,7 +797,7 @@ func (e *escape) addr(n ir.Node) hole {
 		k = e.oldLoc(n).asHole()
 	case ir.ONAMEOFFSET:
 		n := n.(*ir.NameOffsetExpr)
-		e.addr(n.Name_)
+		k = e.addr(n.Name_)
 	case ir.ODOT:
 		n := n.(*ir.SelectorExpr)
 		k = e.addr(n.X)
@@ -815,10 +817,6 @@ func (e *escape) addr(n ir.Node) hole {
 		e.assignHeap(n.Index, "key of map put", n)
 	}
 
-	if !n.Type().HasPointers() {
-		k = e.discardHole()
-	}
-
 	return k
 }
 
@@ -830,6 +828,16 @@ func (e *escape) addrs(l ir.Nodes) []hole {
 	return ks
 }
 
+func (e *escape) assignList(dsts, srcs []ir.Node, why string, where ir.Node) {
+	for i, dst := range dsts {
+		var src ir.Node
+		if i < len(srcs) {
+			src = srcs[i]
+		}
+		e.assign(dst, src, why, where)
+	}
+}
+
 // assign evaluates the assignment dst = src.
 func (e *escape) assign(dst, src ir.Node, why string, where ir.Node) {
 	// Filter out some no-op assignments for escape analysis.
-- 
GitLab


From 57c426c9a57736d84f6ddd88d7a3306e63f66945 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 2 Jan 2021 03:15:14 -0800
Subject: [PATCH 0412/2400] [dev.regabi] cmd/compile: tighten typecheckdef to
 *ir.Name

We only actually care about ir.Names in typecheckdef, so don't bother
calling it on anything else. Allows us to get rid of some more
superfluous .Name() calls and .(*ir.Name) assertions.

Passes toolstash -cmp.

Change-Id: I78c7cb680178991ea185958b47a36f101d4d5ef7
Reviewed-on: https://go-review.googlesource.com/c/go/+/281004
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 .../compile/internal/typecheck/typecheck.go   | 25 ++++++++-----------
 1 file changed, 10 insertions(+), 15 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index d0922e8508..812b94de0d 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -474,11 +474,8 @@ func indexlit(n ir.Node) ir.Node {
 
 // typecheck1 should ONLY be called from typecheck.
 func typecheck1(n ir.Node, top int) ir.Node {
-	switch n.Op() {
-	case ir.OLITERAL, ir.ONAME, ir.OTYPE:
-		if n.Sym() != nil {
-			typecheckdef(n)
-		}
+	if n, ok := n.(*ir.Name); ok {
+		typecheckdef(n)
 	}
 
 	switch n.Op() {
@@ -1735,7 +1732,7 @@ func typecheckdeftype(n *ir.Name) {
 	types.ResumeCheckSize()
 }
 
-func typecheckdef(n ir.Node) {
+func typecheckdef(n *ir.Name) {
 	if base.EnableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckdef", n)(nil)
 	}
@@ -1755,7 +1752,7 @@ func typecheckdef(n ir.Node) {
 	}
 
 	lno := ir.SetPos(n)
-	typecheckdefstack = append(typecheckdefstack, n.(*ir.Name))
+	typecheckdefstack = append(typecheckdefstack, n)
 	if n.Walkdef() == 2 {
 		base.FlushErrors()
 		fmt.Printf("typecheckdef loop:")
@@ -1774,18 +1771,18 @@ func typecheckdef(n ir.Node) {
 		base.Fatalf("typecheckdef %v", n.Op())
 
 	case ir.OLITERAL:
-		if n.Name().Ntype != nil {
-			n.Name().Ntype = typecheckNtype(n.Name().Ntype)
-			n.SetType(n.Name().Ntype.Type())
-			n.Name().Ntype = nil
+		if n.Ntype != nil {
+			n.Ntype = typecheckNtype(n.Ntype)
+			n.SetType(n.Ntype.Type())
+			n.Ntype = nil
 			if n.Type() == nil {
 				n.SetDiag(true)
 				goto ret
 			}
 		}
 
-		e := n.Name().Defn
-		n.Name().Defn = nil
+		e := n.Defn
+		n.Defn = nil
 		if e == nil {
 			ir.Dump("typecheckdef nil defn", n)
 			base.ErrorfAt(n.Pos(), "xxx")
@@ -1828,7 +1825,6 @@ func typecheckdef(n ir.Node) {
 		}
 
 	case ir.ONAME:
-		n := n.(*ir.Name)
 		if n.Ntype != nil {
 			n.Ntype = typecheckNtype(n.Ntype)
 			n.SetType(n.Ntype.Type())
@@ -1865,7 +1861,6 @@ func typecheckdef(n ir.Node) {
 		n.Defn = Stmt(n.Defn) // fills in n.Type
 
 	case ir.OTYPE:
-		n := n.(*ir.Name)
 		if n.Alias() {
 			// Type alias declaration: Simply use the rhs type - no need
 			// to create a new type.
-- 
GitLab


From bb1b6c95c2d312ec0e23a90dffd37a62f98af7ae Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 2 Jan 2021 03:23:49 -0800
Subject: [PATCH 0413/2400] [dev.regabi] cmd/compile: remove Node.{,Set}Walkdef

After the previous commit, we no longer access Walkdef on anything but
ir.Names, so we can remove them from the Node interface and miniNode.

The flag bits storage should also move from miniNode.bits to
Name.flags, but the latter is already full at the moment. Leaving as a
TODO for now.

Passes toolstash -cmp.

Change-Id: I2427e4cf7bc68dc1d1529f40fb93dd9f7a9149f6
Reviewed-on: https://go-review.googlesource.com/c/go/+/281005
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/ir/mini.go | 9 +--------
 src/cmd/compile/internal/ir/name.go | 8 ++++++++
 src/cmd/compile/internal/ir/node.go | 2 --
 3 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/src/cmd/compile/internal/ir/mini.go b/src/cmd/compile/internal/ir/mini.go
index 93aa15abec..4dd9a8807a 100644
--- a/src/cmd/compile/internal/ir/mini.go
+++ b/src/cmd/compile/internal/ir/mini.go
@@ -54,20 +54,13 @@ func (n *miniNode) Esc() uint16       { return n.esc }
 func (n *miniNode) SetEsc(x uint16)   { n.esc = x }
 
 const (
-	miniWalkdefShift   = 0
+	miniWalkdefShift   = 0 // TODO(mdempsky): Move to Name.flags.
 	miniTypecheckShift = 2
 	miniDiag           = 1 << 4
 	miniHasCall        = 1 << 5 // for miniStmt
 )
 
-func (n *miniNode) Walkdef() uint8   { return n.bits.get2(miniWalkdefShift) }
 func (n *miniNode) Typecheck() uint8 { return n.bits.get2(miniTypecheckShift) }
-func (n *miniNode) SetWalkdef(x uint8) {
-	if x > 3 {
-		panic(fmt.Sprintf("cannot SetWalkdef %d", x))
-	}
-	n.bits.set2(miniWalkdefShift, x)
-}
 func (n *miniNode) SetTypecheck(x uint8) {
 	if x > 3 {
 		panic(fmt.Sprintf("cannot SetTypecheck %d", x))
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 5acb2d0762..afee6e1308 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -10,6 +10,7 @@ import (
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
 	"cmd/internal/src"
+	"fmt"
 
 	"go/constant"
 )
@@ -240,6 +241,13 @@ func (n *Name) FrameOffset() int64     { return n.Offset_ }
 func (n *Name) SetFrameOffset(x int64) { n.Offset_ = x }
 func (n *Name) Iota() int64            { return n.Offset_ }
 func (n *Name) SetIota(x int64)        { n.Offset_ = x }
+func (n *Name) Walkdef() uint8         { return n.bits.get2(miniWalkdefShift) }
+func (n *Name) SetWalkdef(x uint8) {
+	if x > 3 {
+		panic(fmt.Sprintf("cannot SetWalkdef %d", x))
+	}
+	n.bits.set2(miniWalkdefShift, x)
+}
 
 func (n *Name) Linksym() *obj.LSym { return n.sym.Linksym() }
 
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 9d1ee17aa8..a5a7203faa 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -46,8 +46,6 @@ type Node interface {
 	// Storage for analysis passes.
 	Esc() uint16
 	SetEsc(x uint16)
-	Walkdef() uint8
-	SetWalkdef(x uint8)
 	Diag() bool
 	SetDiag(x bool)
 	Typecheck() uint8
-- 
GitLab


From 5d80a590a2abc26dcc6cc4455f7cb2bf78fd9123 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 2 Jan 2021 22:43:58 -0800
Subject: [PATCH 0414/2400] [dev.regabi] cmd/compile: simplify walkReturn

Just de-duplicating some logic and adding better comments.

Passes toolstash -cmp.

Change-Id: I15ec07070510692c6d4367880bc3d2d9847370ab
Reviewed-on: https://go-review.googlesource.com/c/go/+/281132
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/walk/assign.go | 69 ++++++++++---------------
 1 file changed, 27 insertions(+), 42 deletions(-)

diff --git a/src/cmd/compile/internal/walk/assign.go b/src/cmd/compile/internal/walk/assign.go
index 7f3e4cc995..d552749d26 100644
--- a/src/cmd/compile/internal/walk/assign.go
+++ b/src/cmd/compile/internal/walk/assign.go
@@ -143,8 +143,6 @@ func walkAssignFunc(init *ir.Nodes, n *ir.AssignListStmt) ir.Node {
 // walkAssignList walks an OAS2 node.
 func walkAssignList(init *ir.Nodes, n *ir.AssignListStmt) ir.Node {
 	init.Append(ir.TakeInit(n)...)
-	walkExprListSafe(n.Lhs, init)
-	walkExprListSafe(n.Rhs, init)
 	return ir.NewBlockStmt(src.NoXPos, ascompatee(ir.OAS, n.Lhs, n.Rhs, init))
 }
 
@@ -232,54 +230,33 @@ func walkAssignRecv(init *ir.Nodes, n *ir.AssignListStmt) ir.Node {
 
 // walkReturn walks an ORETURN node.
 func walkReturn(n *ir.ReturnStmt) ir.Node {
-	ir.CurFunc.NumReturns++
+	fn := ir.CurFunc
+
+	fn.NumReturns++
 	if len(n.Results) == 0 {
 		return n
 	}
-	if (ir.HasNamedResults(ir.CurFunc) && len(n.Results) > 1) || paramoutheap(ir.CurFunc) {
-		// assign to the function out parameters,
-		// so that ascompatee can fix up conflicts
-		var rl []ir.Node
-
-		for _, ln := range ir.CurFunc.Dcl {
-			cl := ln.Class_
-			if cl == ir.PAUTO || cl == ir.PAUTOHEAP {
-				break
-			}
-			if cl == ir.PPARAMOUT {
-				var ln ir.Node = ln
-				if ir.IsParamStackCopy(ln) {
-					ln = walkExpr(typecheck.Expr(ir.NewStarExpr(base.Pos, ln.Name().Heapaddr)), nil)
-				}
-				rl = append(rl, ln)
-			}
-		}
 
-		if got, want := len(n.Results), len(rl); got != want {
-			// order should have rewritten multi-value function calls
-			// with explicit OAS2FUNC nodes.
-			base.Fatalf("expected %v return arguments, have %v", want, got)
-		}
-
-		// move function calls out, to make ascompatee's job easier.
-		walkExprListSafe(n.Results, n.PtrInit())
+	results := fn.Type().Results().FieldSlice()
+	dsts := make([]ir.Node, len(results))
+	for i, v := range results {
+		// TODO(mdempsky): typecheck should have already checked the result variables.
+		dsts[i] = typecheck.AssignExpr(v.Nname.(*ir.Name))
+	}
 
-		n.Results = ascompatee(n.Op(), rl, n.Results, n.PtrInit())
+	if (ir.HasNamedResults(fn) && len(n.Results) > 1) || paramoutheap(fn) {
+		// General case: For anything tricky, let ascompatee handle
+		// ordering the assignments correctly.
+		n.Results = ascompatee(n.Op(), dsts, n.Results, n.PtrInit())
 		return n
 	}
-	walkExprList(n.Results, n.PtrInit())
 
-	// For each return parameter (lhs), assign the corresponding result (rhs).
-	lhs := ir.CurFunc.Type().Results()
-	rhs := n.Results
-	res := make([]ir.Node, lhs.NumFields())
-	for i, nl := range lhs.FieldSlice() {
-		nname := ir.AsNode(nl.Nname)
-		if ir.IsParamHeapCopy(nname) {
-			nname = nname.Name().Stackcopy
-		}
-		a := ir.NewAssignStmt(base.Pos, nname, rhs[i])
-		res[i] = convas(a, n.PtrInit())
+	// Common case: Assignment order doesn't matter. Simply assign to
+	// each result parameter in order.
+	walkExprList(n.Results, n.PtrInit())
+	res := make([]ir.Node, len(results))
+	for i, v := range n.Results {
+		res[i] = convas(ir.NewAssignStmt(base.Pos, dsts[i], v), n.PtrInit())
 	}
 	n.Results = res
 	return n
@@ -348,6 +325,14 @@ func ascompatee(op ir.Op, nl, nr []ir.Node, init *ir.Nodes) []ir.Node {
 		base.Fatalf("assignment operands mismatch: %+v / %+v", ir.Nodes(nl), ir.Nodes(nr))
 	}
 
+	// TODO(mdempsky): Simplify this code. Not only is it redundant to
+	// call safeExpr on the operands twice, but ensuring order of
+	// evaluation for function calls was already handled by order.go.
+
+	// move function calls out, to make ascompatee's job easier.
+	walkExprListSafe(nl, init)
+	walkExprListSafe(nr, init)
+
 	// ensure order of evaluation for function calls
 	for i := range nl {
 		nl[i] = safeExpr(nl[i], init)
-- 
GitLab


From a317067d65c2f9814cb05e573974d416949bace8 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 2 Jan 2021 23:24:16 -0800
Subject: [PATCH 0415/2400] [dev.regabi] cmd/compile: improve ascompatee

order.go has already ordered function calls, so ascompatee only needs
to worry about expressions that might access a variable after it's
already been re-assigned. It already handles this, so the safeExpr
calls simply result in unnecessarily pessimistic code.

Does not pass toolstash -cmp, because it allows more efficient code
generation. E.g., cmd/go on linux/ppc64le is about 2kB smaller.

Change-Id: Idde0588eabe7850fa13c4e281fc46bbeffb4f68c
Reviewed-on: https://go-review.googlesource.com/c/go/+/281152
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/walk/assign.go | 38 ++++++-------------------
 1 file changed, 9 insertions(+), 29 deletions(-)

diff --git a/src/cmd/compile/internal/walk/assign.go b/src/cmd/compile/internal/walk/assign.go
index d552749d26..04bd576b69 100644
--- a/src/cmd/compile/internal/walk/assign.go
+++ b/src/cmd/compile/internal/walk/assign.go
@@ -325,22 +325,6 @@ func ascompatee(op ir.Op, nl, nr []ir.Node, init *ir.Nodes) []ir.Node {
 		base.Fatalf("assignment operands mismatch: %+v / %+v", ir.Nodes(nl), ir.Nodes(nr))
 	}
 
-	// TODO(mdempsky): Simplify this code. Not only is it redundant to
-	// call safeExpr on the operands twice, but ensuring order of
-	// evaluation for function calls was already handled by order.go.
-
-	// move function calls out, to make ascompatee's job easier.
-	walkExprListSafe(nl, init)
-	walkExprListSafe(nr, init)
-
-	// ensure order of evaluation for function calls
-	for i := range nl {
-		nl[i] = safeExpr(nl[i], init)
-	}
-	for i := range nr {
-		nr[i] = safeExpr(nr[i], init)
-	}
-
 	var assigned ir.NameSet
 	var memWrite bool
 
@@ -361,27 +345,22 @@ func ascompatee(op ir.Op, nl, nr []ir.Node, init *ir.Nodes) []ir.Node {
 	// If a needed expression may be affected by an
 	// earlier assignment, make an early copy of that
 	// expression and use the copy instead.
-	var early []ir.Node
+	var early ir.Nodes
 	save := func(np *ir.Node) {
 		if n := *np; affected(n) {
-			tmp := ir.Node(typecheck.Temp(n.Type()))
-			as := typecheck.Stmt(ir.NewAssignStmt(base.Pos, tmp, n))
-			early = append(early, as)
-			*np = tmp
+			*np = copyExpr(n, n.Type(), &early)
 		}
 	}
 
-	var late []ir.Node
-	for i, l := range nl {
-		r := nr[i]
+	var late ir.Nodes
+	for i, lorig := range nl {
+		l, r := lorig, nr[i]
 
 		// Do not generate 'x = x' during return. See issue 4014.
 		if op == ir.ORETURN && ir.SameSafeExpr(l, r) {
 			continue
 		}
 
-		as := ir.NewAssignStmt(base.Pos, l, r)
-
 		// Save subexpressions needed on left side.
 		// Drill through non-dereferences.
 		for {
@@ -423,9 +402,9 @@ func ascompatee(op ir.Op, nl, nr []ir.Node, init *ir.Nodes) []ir.Node {
 		}
 
 		// Save expression on right side.
-		save(&as.Y)
+		save(&r)
 
-		late = append(late, convas(as, init))
+		appendWalkStmt(&late, convas(ir.NewAssignStmt(base.Pos, lorig, r), &late))
 
 		if name == nil || name.Addrtaken() || name.Class_ == ir.PEXTERN || name.Class_ == ir.PAUTOHEAP {
 			memWrite = true
@@ -438,7 +417,8 @@ func ascompatee(op ir.Op, nl, nr []ir.Node, init *ir.Nodes) []ir.Node {
 		assigned.Add(name)
 	}
 
-	return append(early, late...)
+	early.Append(late.Take()...)
+	return early
 }
 
 // readsMemory reports whether the evaluation n directly reads from
-- 
GitLab


From d36a6bf44da6d9b6e1ec355381ef15d253435e20 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 2 Jan 2021 23:56:20 -0800
Subject: [PATCH 0416/2400] [dev.regabi] cmd/compile: improve walkReturn common
 case

Instead of evaluating all result expressions up front and then
assigning them to their result destinations, we can interleave
evaluation with assignment. This reduces how much temporary
stack/register space is needed to hold the values in flight.

Doesn't pass toolstash -cmp, because it allows better return statement
code to be generated. E.g., cmd/go's text segment on linux/ppc64le
shrinks another 1kB.

Change-Id: I3fe889342c80e947e0118704ec01f1682c577e6e
Reviewed-on: https://go-review.googlesource.com/c/go/+/281153
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/walk/assign.go | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/walk/assign.go b/src/cmd/compile/internal/walk/assign.go
index 04bd576b69..84ba7f0dc5 100644
--- a/src/cmd/compile/internal/walk/assign.go
+++ b/src/cmd/compile/internal/walk/assign.go
@@ -253,10 +253,9 @@ func walkReturn(n *ir.ReturnStmt) ir.Node {
 
 	// Common case: Assignment order doesn't matter. Simply assign to
 	// each result parameter in order.
-	walkExprList(n.Results, n.PtrInit())
-	res := make([]ir.Node, len(results))
+	var res ir.Nodes
 	for i, v := range n.Results {
-		res[i] = convas(ir.NewAssignStmt(base.Pos, dsts[i], v), n.PtrInit())
+		appendWalkStmt(&res, convas(ir.NewAssignStmt(base.Pos, dsts[i], v), &res))
 	}
 	n.Results = res
 	return n
-- 
GitLab


From f2e6dab04859a3211ce9f5bf5bac9edde0831ce1 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 3 Jan 2021 00:03:28 -0800
Subject: [PATCH 0417/2400] [dev.regabi] cmd/compile: remove walkReturn "common
 case" path

After the previous two optimization CLs, this code path now generates
the same code as ascompatee does anyway. So just use that and remove
some redundant code.

Passes toolstash -cmp.

Change-Id: I5e2e5c6dbea64d8e91abe0f2cf51aa5bb86576d2
Reviewed-on: https://go-review.googlesource.com/c/go/+/281154
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/walk/assign.go | 24 ++++++++----------------
 1 file changed, 8 insertions(+), 16 deletions(-)

diff --git a/src/cmd/compile/internal/walk/assign.go b/src/cmd/compile/internal/walk/assign.go
index 84ba7f0dc5..ec0f60ad93 100644
--- a/src/cmd/compile/internal/walk/assign.go
+++ b/src/cmd/compile/internal/walk/assign.go
@@ -143,7 +143,7 @@ func walkAssignFunc(init *ir.Nodes, n *ir.AssignListStmt) ir.Node {
 // walkAssignList walks an OAS2 node.
 func walkAssignList(init *ir.Nodes, n *ir.AssignListStmt) ir.Node {
 	init.Append(ir.TakeInit(n)...)
-	return ir.NewBlockStmt(src.NoXPos, ascompatee(ir.OAS, n.Lhs, n.Rhs, init))
+	return ir.NewBlockStmt(src.NoXPos, ascompatee(ir.OAS, n.Lhs, n.Rhs))
 }
 
 // walkAssignMapRead walks an OAS2MAPR node.
@@ -244,20 +244,7 @@ func walkReturn(n *ir.ReturnStmt) ir.Node {
 		dsts[i] = typecheck.AssignExpr(v.Nname.(*ir.Name))
 	}
 
-	if (ir.HasNamedResults(fn) && len(n.Results) > 1) || paramoutheap(fn) {
-		// General case: For anything tricky, let ascompatee handle
-		// ordering the assignments correctly.
-		n.Results = ascompatee(n.Op(), dsts, n.Results, n.PtrInit())
-		return n
-	}
-
-	// Common case: Assignment order doesn't matter. Simply assign to
-	// each result parameter in order.
-	var res ir.Nodes
-	for i, v := range n.Results {
-		appendWalkStmt(&res, convas(ir.NewAssignStmt(base.Pos, dsts[i], v), &res))
-	}
-	n.Results = res
+	n.Results = ascompatee(n.Op(), dsts, n.Results)
 	return n
 }
 
@@ -318,7 +305,7 @@ func ascompatet(nl ir.Nodes, nr *types.Type) []ir.Node {
 // check assign expression list to
 // an expression list. called in
 //	expr-list = expr-list
-func ascompatee(op ir.Op, nl, nr []ir.Node, init *ir.Nodes) []ir.Node {
+func ascompatee(op ir.Op, nl, nr []ir.Node) []ir.Node {
 	// cannot happen: should have been rejected during type checking
 	if len(nl) != len(nr) {
 		base.Fatalf("assignment operands mismatch: %+v / %+v", ir.Nodes(nl), ir.Nodes(nr))
@@ -413,6 +400,11 @@ func ascompatee(op ir.Op, nl, nr []ir.Node, init *ir.Nodes) []ir.Node {
 			// We can ignore assignments to blank.
 			continue
 		}
+		if op == ir.ORETURN && types.OrigSym(name.Sym()) == nil {
+			// We can also ignore assignments to anonymous result
+			// parameters. These can't appear in expressions anyway.
+			continue
+		}
 		assigned.Add(name)
 	}
 
-- 
GitLab


From 907a4bfdc75004bc31c30564734cffc61ab1e80c Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 3 Jan 2021 00:16:46 -0800
Subject: [PATCH 0418/2400] [dev.regabi] cmd/compile: fix map assignment order

After the previous cleanup/optimization CLs, ascompatee now correctly
handles map assignments too. So remove the code from order.mapAssign,
which causes us to assign to the map at the wrong point during
execution. It's not every day you get to fix an issue by only removing
code.

Thanks to Cuong Manh Le for test cases and continually following up on
this issue.

Passes toolstash -cmp. (Apparently the standard library never uses
tricky map assignments. Go figure.)

Fixes #23017.

Change-Id: Ie0728103d59d884d00c1c050251290a2a46150f9
Reviewed-on: https://go-review.googlesource.com/c/go/+/281172
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/walk/order.go |  37 +-------
 test/fixedbugs/issue23017.go           | 113 +++++++++++++++++++++++++
 2 files changed, 114 insertions(+), 36 deletions(-)
 create mode 100644 test/fixedbugs/issue23017.go

diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index 767af07414..2164685cd4 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -537,21 +537,7 @@ func (o *orderState) call(nn ir.Node) {
 	}
 }
 
-// mapAssign appends n to o.out, introducing temporaries
-// to make sure that all map assignments have the form m[k] = x.
-// (Note: expr has already been called on n, so we know k is addressable.)
-//
-// If n is the multiple assignment form ..., m[k], ... = ..., x, ..., the rewrite is
-//	t1 = m
-//	t2 = k
-//	...., t3, ... = ..., x, ...
-//	t1[t2] = t3
-//
-// The temporaries t1, t2 are needed in case the ... being assigned
-// contain m or k. They are usually unnecessary, but in the unnecessary
-// cases they are also typically registerizable, so not much harm done.
-// And this only applies to the multiple-assignment form.
-// We could do a more precise analysis if needed, like in walk.go.
+// mapAssign appends n to o.out.
 func (o *orderState) mapAssign(n ir.Node) {
 	switch n.Op() {
 	default:
@@ -572,28 +558,7 @@ func (o *orderState) mapAssign(n ir.Node) {
 
 	case ir.OAS2, ir.OAS2DOTTYPE, ir.OAS2MAPR, ir.OAS2FUNC:
 		n := n.(*ir.AssignListStmt)
-		var post []ir.Node
-		for i, m := range n.Lhs {
-			switch {
-			case m.Op() == ir.OINDEXMAP:
-				m := m.(*ir.IndexExpr)
-				if !ir.IsAutoTmp(m.X) {
-					m.X = o.copyExpr(m.X)
-				}
-				if !ir.IsAutoTmp(m.Index) {
-					m.Index = o.copyExpr(m.Index)
-				}
-				fallthrough
-			case base.Flag.Cfg.Instrumenting && n.Op() == ir.OAS2FUNC && !ir.IsBlank(m):
-				t := o.newTemp(m.Type(), false)
-				n.Lhs[i] = t
-				a := ir.NewAssignStmt(base.Pos, m, t)
-				post = append(post, typecheck.Stmt(a))
-			}
-		}
-
 		o.out = append(o.out, n)
-		o.out = append(o.out, post...)
 	}
 }
 
diff --git a/test/fixedbugs/issue23017.go b/test/fixedbugs/issue23017.go
new file mode 100644
index 0000000000..770c48ef26
--- /dev/null
+++ b/test/fixedbugs/issue23017.go
@@ -0,0 +1,113 @@
+// run
+
+// Copyright 2020 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.
+
+// assignment order in multiple assignments.
+// See issue #23017
+
+package main
+
+import "fmt"
+
+func main() {}
+
+func init() {
+	var m = map[int]int{}
+	var p *int
+
+	defer func() {
+		recover()
+		check(1, len(m))
+		check(42, m[2])
+	}()
+	m[2], *p = 42, 2
+}
+
+func init() {
+	var m = map[int]int{}
+	p := []int{}
+
+	defer func() {
+		recover()
+		check(1, len(m))
+		check(2, m[2])
+	}()
+	m[2], p[1] = 2, 2
+}
+
+func init() {
+	type P struct{ i int }
+	var m = map[int]int{}
+	var p *P
+
+	defer func() {
+		recover()
+		check(1, len(m))
+		check(3, m[2])
+	}()
+	m[2], p.i = 3, 2
+}
+
+func init() {
+	type T struct{ i int }
+	var x T
+	p := &x
+	p, p.i = new(T), 4
+	check(4, x.i)
+}
+
+func init() {
+	var m map[int]int
+	var a int
+	var p = &a
+
+	defer func() {
+		recover()
+		check(5, *p)
+	}()
+	*p, m[2] = 5, 2
+}
+
+var g int
+
+func init() {
+	var m map[int]int
+	defer func() {
+		recover()
+		check(0, g)
+	}()
+	m[0], g = 1, 2
+}
+
+func init() {
+	type T struct{ x struct{ y int } }
+	var x T
+	p := &x
+	p, p.x.y = new(T), 7
+	check(7, x.x.y)
+	check(0, p.x.y)
+}
+
+func init() {
+	type T *struct{ x struct{ y int } }
+	x := struct{ y int }{0}
+	var q T = &struct{ x struct{ y int } }{x}
+	p := q
+	p, p.x.y = nil, 7
+	check(7, q.x.y)
+}
+
+func init() {
+	x, y := 1, 2
+	x, y = y, x
+	check(2, x)
+	check(1, y)
+}
+
+func check(want, got int) {
+	if want != got {
+		panic(fmt.Sprintf("wanted %d, but got %d", want, got))
+	}
+}
-- 
GitLab


From 8fc44cf0fac5357f45cacc445c0900a8fd054bd5 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 3 Jan 2021 00:53:51 -0800
Subject: [PATCH 0419/2400] [dev.regabi] cmd/compile: remove a couple CloneName
 calls

In inl.go, that code path is unused, since we added ir.BasicLit to
represent unnamed OLITERALs.

In race.go, rather than cloning ir.RegFP, we can just create it from
scratch again.

Passes toolstash -cmp (incl. w/ -race).

Change-Id: I8e063e4898d2acf056ceca5bc03df6b40a14eca9
Reviewed-on: https://go-review.googlesource.com/c/go/+/281192
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/inline/inl.go | 9 ---------
 src/cmd/compile/internal/walk/race.go  | 6 +++++-
 2 files changed, 5 insertions(+), 10 deletions(-)

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 2887abb061..b9b424b74d 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -1096,15 +1096,6 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 		if n.Sym() != nil {
 			return n
 		}
-		if n, ok := n.(*ir.Name); ok && n.Op() == ir.OLITERAL {
-			// This happens for unnamed OLITERAL.
-			// which should really not be a *Name, but for now it is.
-			// ir.Copy(n) is not allowed generally and would panic below,
-			// but it's OK in this situation.
-			n = n.CloneName()
-			n.SetPos(subst.updatedPos(n.Pos()))
-			return n
-		}
 
 	case ir.ORETURN:
 		// Since we don't handle bodies with closures,
diff --git a/src/cmd/compile/internal/walk/race.go b/src/cmd/compile/internal/walk/race.go
index 87a8839dcd..20becf9be9 100644
--- a/src/cmd/compile/internal/walk/race.go
+++ b/src/cmd/compile/internal/walk/race.go
@@ -8,6 +8,7 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/ssagen"
+	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"cmd/internal/sys"
@@ -36,7 +37,10 @@ func instrument(fn *ir.Func) {
 			// This only works for amd64. This will not
 			// work on arm or others that might support
 			// race in the future.
-			nodpc := ir.RegFP.CloneName()
+
+			nodpc := ir.NewNameAt(src.NoXPos, typecheck.Lookup(".fp"))
+			nodpc.Class_ = ir.PPARAM
+			nodpc.SetUsed(true)
 			nodpc.SetType(types.Types[types.TUINTPTR])
 			nodpc.SetFrameOffset(int64(-types.PtrSize))
 			fn.Dcl = append(fn.Dcl, nodpc)
-- 
GitLab


From a30fd5288415cb1e4a91ec89fac725a9ee7a3d05 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Mon, 4 Jan 2021 10:37:48 +0700
Subject: [PATCH 0420/2400] [dev.regabi] cmd/compile: use ir.NewNameAt in
 SubstArgTypes

So we can remove Name.CloneName now.

Passes toolstash -cmp.

Change-Id: I63e57ba52a7031e06fe9c4ee9aee7de6dec70792
Reviewed-on: https://go-review.googlesource.com/c/go/+/281312
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ir/name.go        | 6 ------
 src/cmd/compile/internal/typecheck/syms.go | 6 +++---
 2 files changed, 3 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index afee6e1308..689ef983f6 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -147,12 +147,6 @@ func (n *Name) copy() Node                         { panic(n.no("copy")) }
 func (n *Name) doChildren(do func(Node) bool) bool { return false }
 func (n *Name) editChildren(edit func(Node) Node)  {}
 
-// CloneName makes a cloned copy of the name.
-// It's not ir.Copy(n) because in general that operation is a mistake on names,
-// which uniquely identify variables.
-// Callers must use n.CloneName to make clear they intend to create a separate name.
-func (n *Name) CloneName() *Name { c := *n; return &c }
-
 // TypeDefn returns the type definition for a named OTYPE.
 // That is, given "type T Defn", it returns Defn.
 // It is used by package types.
diff --git a/src/cmd/compile/internal/typecheck/syms.go b/src/cmd/compile/internal/typecheck/syms.go
index 2251062e16..01c03b5f9f 100644
--- a/src/cmd/compile/internal/typecheck/syms.go
+++ b/src/cmd/compile/internal/typecheck/syms.go
@@ -26,12 +26,12 @@ func LookupRuntime(name string) *ir.Name {
 // The result of SubstArgTypes MUST be assigned back to old, e.g.
 // 	n.Left = SubstArgTypes(n.Left, t1, t2)
 func SubstArgTypes(old *ir.Name, types_ ...*types.Type) *ir.Name {
-	n := old.CloneName()
-
 	for _, t := range types_ {
 		types.CalcSize(t)
 	}
-	n.SetType(types.SubstAny(n.Type(), &types_))
+	n := ir.NewNameAt(old.Pos(), old.Sym())
+	n.Class_ = old.Class()
+	n.SetType(types.SubstAny(old.Type(), &types_))
 	if len(types_) > 0 {
 		base.Fatalf("substArgTypes: too many argument types")
 	}
-- 
GitLab


From 290b4154b73b54045a147f463c6988b935d75d49 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 3 Jan 2021 14:24:25 -0800
Subject: [PATCH 0421/2400] [dev.regabi] cmd/compile: fix ICE due to large
 uint64 constants

It's an error to call Int64Val on constants that don't fit into
int64. CL 272654 made the compiler stricter about detecting misuse,
and revealed that we were using it improperly in detecting consecutive
integer-switch cases. That particular usage actually did work in
practice, but it's easy and best to just fix it.

Fixes #43480.

Change-Id: I56f722d75e83091638ac43b80e45df0b0ad7d48d
Reviewed-on: https://go-review.googlesource.com/c/go/+/281272
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/walk/switch.go |  7 +++++-
 test/fixedbugs/issue43480.go            | 33 +++++++++++++++++++++++++
 2 files changed, 39 insertions(+), 1 deletion(-)
 create mode 100644 test/fixedbugs/issue43480.go

diff --git a/src/cmd/compile/internal/walk/switch.go b/src/cmd/compile/internal/walk/switch.go
index b03bc3eba7..59446ef3db 100644
--- a/src/cmd/compile/internal/walk/switch.go
+++ b/src/cmd/compile/internal/walk/switch.go
@@ -201,10 +201,15 @@ func (s *exprSwitch) flush() {
 
 	// Merge consecutive integer cases.
 	if s.exprname.Type().IsInteger() {
+		consecutive := func(last, next constant.Value) bool {
+			delta := constant.BinaryOp(next, token.SUB, last)
+			return constant.Compare(delta, token.EQL, constant.MakeInt64(1))
+		}
+
 		merged := cc[:1]
 		for _, c := range cc[1:] {
 			last := &merged[len(merged)-1]
-			if last.jmp == c.jmp && ir.Int64Val(last.hi)+1 == ir.Int64Val(c.lo) {
+			if last.jmp == c.jmp && consecutive(last.hi.Val(), c.lo.Val()) {
 				last.hi = c.lo
 			} else {
 				merged = append(merged, c)
diff --git a/test/fixedbugs/issue43480.go b/test/fixedbugs/issue43480.go
new file mode 100644
index 0000000000..d98ad3a34e
--- /dev/null
+++ b/test/fixedbugs/issue43480.go
@@ -0,0 +1,33 @@
+// run
+
+// Copyright 2020 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.
+
+// Issue #43480: ICE on large uint64 constants in switch cases.
+
+package main
+
+func isPow10(x uint64) bool {
+	switch x {
+	case 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
+		1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19:
+		return true
+	}
+	return false
+}
+
+func main() {
+	var x uint64 = 1
+
+	for {
+		if !isPow10(x) || isPow10(x-1) || isPow10(x+1) {
+			panic(x)
+		}
+		next := x * 10
+		if next/10 != x {
+			break // overflow
+		}
+		x = next
+	}
+}
-- 
GitLab


From d89705e08742c0f4fdf5d2bdbab6f344c6be884f Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 3 Jan 2021 14:37:06 -0800
Subject: [PATCH 0422/2400] [dev.regabi] cmd/compile: fix re-export of
 parameters

When exporting signature types, we include the originating package,
because it's exposed via go/types's API. And as a consistency check,
we ensure that the parameter names came from that same package.

However, we were getting this wrong in the case of exported variables
that were initialized with a method value using an imported method. In
this case, when we created the method value wrapper function's
type (which is reused as the variable's type if none is explicitly
provided in the variable declaration), we were reusing the
original (i.e., imported) parameter names, but the newly created
signature type was associated with the current package instead.

The correct fix here is really to preserve the original signature
type's package (along with position and name for its parameters), but
that's awkward to do at the moment because the DeclFunc API requires
an ir representation of the function signature, whereas we only
provide a way to explicitly set packages via the type constructor
APIs.

As an interim fix, we associate the parameters with the current
package, to be consistent with the signature type's package.

Fixes #43479.

Change-Id: Id45a10f8cf64165c9bc7d9598f0a0ee199a5e752
Reviewed-on: https://go-review.googlesource.com/c/go/+/281292
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/typecheck/dcl.go     |  3 ++
 src/cmd/compile/internal/typecheck/iexport.go | 13 ++++++-
 src/cmd/compile/internal/typecheck/iimport.go | 27 +++++++------
 src/cmd/compile/internal/typecheck/subr.go    |  3 ++
 test/fixedbugs/issue43479.dir/a.go            | 27 +++++++++++++
 test/fixedbugs/issue43479.dir/b.go            | 38 +++++++++++++++++++
 test/fixedbugs/issue43479.go                  |  7 ++++
 7 files changed, 104 insertions(+), 14 deletions(-)
 create mode 100644 test/fixedbugs/issue43479.dir/a.go
 create mode 100644 test/fixedbugs/issue43479.dir/b.go
 create mode 100644 test/fixedbugs/issue43479.go

diff --git a/src/cmd/compile/internal/typecheck/dcl.go b/src/cmd/compile/internal/typecheck/dcl.go
index daec9848d0..5eaf100eed 100644
--- a/src/cmd/compile/internal/typecheck/dcl.go
+++ b/src/cmd/compile/internal/typecheck/dcl.go
@@ -486,6 +486,9 @@ func NewMethodType(sig *types.Type, recv *types.Type) *types.Type {
 		nrecvs++
 	}
 
+	// TODO(mdempsky): Move this function to types.
+	// TODO(mdempsky): Preserve positions, names, and package from sig+recv.
+
 	params := make([]*types.Field, nrecvs+sig.Params().Fields().Len())
 	if recv != nil {
 		params[0] = types.NewField(base.Pos, nil, recv)
diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index 50acb10a9a..dd515b8ccd 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -574,6 +574,11 @@ func (w *exportWriter) pos(pos src.XPos) {
 }
 
 func (w *exportWriter) pkg(pkg *types.Pkg) {
+	// TODO(mdempsky): Add flag to types.Pkg to mark pseudo-packages.
+	if pkg == ir.Pkgs.Go {
+		base.Fatalf("export of pseudo-package: %q", pkg.Path)
+	}
+
 	// Ensure any referenced packages are declared in the main index.
 	w.p.allPkgs[pkg] = true
 
@@ -1529,6 +1534,10 @@ func (w *exportWriter) localName(n *ir.Name) {
 }
 
 func (w *exportWriter) localIdent(s *types.Sym, v int32) {
+	if w.currPkg == nil {
+		base.Fatalf("missing currPkg")
+	}
+
 	// Anonymous parameters.
 	if s == nil {
 		w.string("")
@@ -1553,8 +1562,8 @@ func (w *exportWriter) localIdent(s *types.Sym, v int32) {
 		name = fmt.Sprintf("%s·%d", name, v)
 	}
 
-	if !types.IsExported(name) && s.Pkg != w.currPkg {
-		base.Fatalf("weird package in name: %v => %v, not %q", s, name, w.currPkg.Path)
+	if s.Pkg != w.currPkg {
+		base.Fatalf("weird package in name: %v => %v from %q, not %q", s, name, s.Pkg.Path, w.currPkg.Path)
 	}
 
 	w.string(name)
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 0caac362e3..2dc7e70b65 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -327,7 +327,7 @@ func (r *importReader) doDecl(sym *types.Sym) *ir.Name {
 		ms := make([]*types.Field, r.uint64())
 		for i := range ms {
 			mpos := r.pos()
-			msym := r.ident()
+			msym := r.selector()
 			recv := r.param()
 			mtyp := r.signature(recv)
 
@@ -434,18 +434,21 @@ func (p *importReader) float(typ *types.Type) constant.Value {
 	return constant.Make(&f)
 }
 
-func (r *importReader) ident() *types.Sym {
+func (r *importReader) ident(selector bool) *types.Sym {
 	name := r.string()
 	if name == "" {
 		return nil
 	}
 	pkg := r.currPkg
-	if types.IsExported(name) {
+	if selector && types.IsExported(name) {
 		pkg = types.LocalPkg
 	}
 	return pkg.Lookup(name)
 }
 
+func (r *importReader) localIdent() *types.Sym { return r.ident(false) }
+func (r *importReader) selector() *types.Sym   { return r.ident(true) }
+
 func (r *importReader) qualifiedIdent() *ir.Ident {
 	name := r.string()
 	pkg := r.pkg()
@@ -534,7 +537,7 @@ func (r *importReader) typ1() *types.Type {
 		fs := make([]*types.Field, r.uint64())
 		for i := range fs {
 			pos := r.pos()
-			sym := r.ident()
+			sym := r.selector()
 			typ := r.typ()
 			emb := r.bool()
 			note := r.string()
@@ -563,7 +566,7 @@ func (r *importReader) typ1() *types.Type {
 		methods := make([]*types.Field, r.uint64())
 		for i := range methods {
 			pos := r.pos()
-			sym := r.ident()
+			sym := r.selector()
 			typ := r.signature(fakeRecvField())
 
 			methods[i] = types.NewField(pos, sym, typ)
@@ -599,7 +602,7 @@ func (r *importReader) paramList() []*types.Field {
 }
 
 func (r *importReader) param() *types.Field {
-	return types.NewField(r.pos(), r.ident(), r.typ())
+	return types.NewField(r.pos(), r.localIdent(), r.typ())
 }
 
 func (r *importReader) bool() bool {
@@ -784,7 +787,7 @@ func (r *importReader) caseList(switchExpr ir.Node) []*ir.CaseClause {
 			// Note: per-case variables will have distinct, dotted
 			// names after import. That's okay: swt.go only needs
 			// Sym for diagnostics anyway.
-			caseVar := ir.NewNameAt(cas.Pos(), r.ident())
+			caseVar := ir.NewNameAt(cas.Pos(), r.localIdent())
 			Declare(caseVar, DeclContext)
 			cas.Var = caseVar
 			caseVar.Defn = switchExpr
@@ -851,7 +854,7 @@ func (r *importReader) node() ir.Node {
 		return r.qualifiedIdent()
 
 	case ir.ONAME:
-		return r.ident().Def.(*ir.Name)
+		return r.localIdent().Def.(*ir.Name)
 
 	// case OPACK, ONONAME:
 	// 	unreachable - should have been resolved by typechecking
@@ -862,7 +865,7 @@ func (r *importReader) node() ir.Node {
 	case ir.OTYPESW:
 		pos := r.pos()
 		var tag *ir.Ident
-		if s := r.ident(); s != nil {
+		if s := r.localIdent(); s != nil {
 			tag = ir.NewIdent(pos, s)
 		}
 		return ir.NewTypeSwitchGuard(pos, tag, r.expr())
@@ -899,7 +902,7 @@ func (r *importReader) node() ir.Node {
 
 	case ir.OXDOT:
 		// see parser.new_dotname
-		return ir.NewSelectorExpr(r.pos(), ir.OXDOT, r.expr(), r.ident())
+		return ir.NewSelectorExpr(r.pos(), ir.OXDOT, r.expr(), r.selector())
 
 	// case ODOTTYPE, ODOTTYPE2:
 	// 	unreachable - mapped to case ODOTTYPE below by exporter
@@ -989,7 +992,7 @@ func (r *importReader) node() ir.Node {
 	// statements
 	case ir.ODCL:
 		pos := r.pos()
-		lhs := ir.NewDeclNameAt(pos, ir.ONAME, r.ident())
+		lhs := ir.NewDeclNameAt(pos, ir.ONAME, r.localIdent())
 		lhs.SetType(r.typ())
 
 		Declare(lhs, ir.PAUTO)
@@ -1100,7 +1103,7 @@ func (r *importReader) op() ir.Op {
 func (r *importReader) fieldList() []ir.Node {
 	list := make([]ir.Node, r.uint64())
 	for i := range list {
-		list[i] = ir.NewStructKeyExpr(r.pos(), r.ident(), r.expr())
+		list[i] = ir.NewStructKeyExpr(r.pos(), r.selector(), r.expr())
 	}
 	return list
 }
diff --git a/src/cmd/compile/internal/typecheck/subr.go b/src/cmd/compile/internal/typecheck/subr.go
index 447e945d81..569075d684 100644
--- a/src/cmd/compile/internal/typecheck/subr.go
+++ b/src/cmd/compile/internal/typecheck/subr.go
@@ -43,6 +43,9 @@ func NewFuncParams(tl *types.Type, mustname bool) []*ir.Field {
 			// invent a name so that we can refer to it in the trampoline
 			s = LookupNum(".anon", gen)
 			gen++
+		} else if s != nil && s.Pkg != types.LocalPkg {
+			// TODO(mdempsky): Preserve original position, name, and package.
+			s = Lookup(s.Name)
 		}
 		a := ir.NewField(base.Pos, s, nil, t.Type)
 		a.Pos = t.Pos
diff --git a/test/fixedbugs/issue43479.dir/a.go b/test/fixedbugs/issue43479.dir/a.go
new file mode 100644
index 0000000000..ed3e6a5d9b
--- /dev/null
+++ b/test/fixedbugs/issue43479.dir/a.go
@@ -0,0 +1,27 @@
+// Copyright 2020 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 a
+
+type Here struct{ stuff int }
+type Info struct{ Dir string }
+
+func New() Here { return Here{} }
+func (h Here) Dir(p string) (Info, error)
+
+type I interface{ M(x string) }
+
+type T = struct {
+	Here
+	I
+}
+
+var X T
+
+var A = (*T).Dir
+var B = T.Dir
+var C = X.Dir
+var D = (*T).M
+var E = T.M
+var F = X.M
diff --git a/test/fixedbugs/issue43479.dir/b.go b/test/fixedbugs/issue43479.dir/b.go
new file mode 100644
index 0000000000..02d16909cc
--- /dev/null
+++ b/test/fixedbugs/issue43479.dir/b.go
@@ -0,0 +1,38 @@
+// Copyright 2020 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 b
+
+import "./a"
+
+var Here = a.New()
+var Dir = Here.Dir
+
+type T = struct {
+	a.Here
+	a.I
+}
+
+var X T
+
+// Test exporting the type of method values for anonymous structs with
+// promoted methods.
+var A = a.A
+var B = a.B
+var C = a.C
+var D = a.D
+var E = a.E
+var F = a.F
+var G = (*a.T).Dir
+var H = a.T.Dir
+var I = a.X.Dir
+var J = (*a.T).M
+var K = a.T.M
+var L = a.X.M
+var M = (*T).Dir
+var N = T.Dir
+var O = X.Dir
+var P = (*T).M
+var Q = T.M
+var R = X.M
diff --git a/test/fixedbugs/issue43479.go b/test/fixedbugs/issue43479.go
new file mode 100644
index 0000000000..f21d1d5c58
--- /dev/null
+++ b/test/fixedbugs/issue43479.go
@@ -0,0 +1,7 @@
+// compiledir
+
+// Copyright 2020 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 ignored
-- 
GitLab


From f24e40c14a0a767b6663c85dc900bb9e6b7c2d8e Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 3 Jan 2021 20:14:00 -0800
Subject: [PATCH 0423/2400] [dev.regabi] cmd/compile: remove Name.Class_
 accessors

These aren't part of the Node interface anymore, so no need to keep
them around.

Passes toolstash -cmp.

[git-generate]
cd src/cmd/compile/internal/ir

: Fix one off case that causes trouble for rf.
sed -i -e 's/n.SetClass(ir.PAUTO)/n.Class_ = ir.PAUTO/' ../ssa/export_test.go

pkgs=$(go list . ../...)
rf '
	ex '"$(echo $pkgs)"' {
		var n *Name
		var c Class
		n.Class() -> n.Class_
		n.SetClass(c) -> n.Class_ = c
	}

	rm Name.Class
	rm Name.SetClass
	mv Name.Class_ Name.Class
'

Change-Id: Ifb304bf4691a8c455456aabd8aa77178d4a49500
Reviewed-on: https://go-review.googlesource.com/c/go/+/281294
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/dwarfgen/dwarf.go    | 24 +++++-----
 src/cmd/compile/internal/escape/escape.go     | 26 +++++-----
 .../compile/internal/gc/abiutilsaux_test.go   |  2 +-
 src/cmd/compile/internal/gc/compile.go        |  2 +-
 src/cmd/compile/internal/gc/export.go         |  2 +-
 src/cmd/compile/internal/gc/obj.go            |  2 +-
 src/cmd/compile/internal/inline/inl.go        | 24 +++++-----
 src/cmd/compile/internal/ir/expr.go           |  6 +--
 src/cmd/compile/internal/ir/func.go           |  4 +-
 src/cmd/compile/internal/ir/name.go           |  8 ++--
 src/cmd/compile/internal/ir/scc.go            |  2 +-
 src/cmd/compile/internal/liveness/plive.go    | 14 +++---
 src/cmd/compile/internal/noder/noder.go       |  6 +--
 src/cmd/compile/internal/pkginit/init.go      |  4 +-
 src/cmd/compile/internal/pkginit/initorder.go | 10 ++--
 .../compile/internal/reflectdata/reflect.go   |  8 ++--
 src/cmd/compile/internal/ssa/deadstore.go     |  8 ++--
 src/cmd/compile/internal/ssa/export_test.go   |  2 +-
 src/cmd/compile/internal/ssagen/nowb.go       |  2 +-
 src/cmd/compile/internal/ssagen/pgen.go       | 14 +++---
 src/cmd/compile/internal/ssagen/pgen_test.go  |  4 +-
 src/cmd/compile/internal/ssagen/ssa.go        | 48 +++++++++----------
 src/cmd/compile/internal/staticdata/data.go   |  6 +--
 src/cmd/compile/internal/staticinit/sched.go  |  6 +--
 src/cmd/compile/internal/typecheck/dcl.go     |  4 +-
 src/cmd/compile/internal/typecheck/export.go  |  2 +-
 src/cmd/compile/internal/typecheck/func.go    |  4 +-
 src/cmd/compile/internal/typecheck/iexport.go |  8 ++--
 src/cmd/compile/internal/typecheck/iimport.go |  2 +-
 src/cmd/compile/internal/typecheck/syms.go    |  2 +-
 .../compile/internal/typecheck/typecheck.go   |  4 +-
 .../compile/internal/typecheck/universe.go    |  2 +-
 src/cmd/compile/internal/walk/assign.go       |  4 +-
 src/cmd/compile/internal/walk/closure.go      |  6 +--
 src/cmd/compile/internal/walk/complit.go      |  8 ++--
 src/cmd/compile/internal/walk/convert.go      |  6 +--
 src/cmd/compile/internal/walk/expr.go         |  2 +-
 src/cmd/compile/internal/walk/order.go        |  2 +-
 src/cmd/compile/internal/walk/race.go         |  2 +-
 src/cmd/compile/internal/walk/stmt.go         |  2 +-
 src/cmd/compile/internal/walk/walk.go         |  6 +--
 41 files changed, 149 insertions(+), 151 deletions(-)

diff --git a/src/cmd/compile/internal/dwarfgen/dwarf.go b/src/cmd/compile/internal/dwarfgen/dwarf.go
index 6eac9d547e..1534adaac8 100644
--- a/src/cmd/compile/internal/dwarfgen/dwarf.go
+++ b/src/cmd/compile/internal/dwarfgen/dwarf.go
@@ -76,7 +76,7 @@ func Info(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.Scope,
 			if n.Op() != ir.ONAME { // might be OTYPE or OLITERAL
 				continue
 			}
-			switch n.Class_ {
+			switch n.Class {
 			case ir.PAUTO:
 				if !n.Used() {
 					// Text == nil -> generating abstract function
@@ -171,7 +171,7 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 		if c == '.' || n.Type().IsUntyped() {
 			continue
 		}
-		if n.Class_ == ir.PPARAM && !ssagen.TypeOK(n.Type()) {
+		if n.Class == ir.PPARAM && !ssagen.TypeOK(n.Type()) {
 			// SSA-able args get location lists, and may move in and
 			// out of registers, so those are handled elsewhere.
 			// Autos and named output params seem to get handled
@@ -186,10 +186,10 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 		typename := dwarf.InfoPrefix + types.TypeSymName(n.Type())
 		decls = append(decls, n)
 		abbrev := dwarf.DW_ABRV_AUTO_LOCLIST
-		isReturnValue := (n.Class_ == ir.PPARAMOUT)
-		if n.Class_ == ir.PPARAM || n.Class_ == ir.PPARAMOUT {
+		isReturnValue := (n.Class == ir.PPARAMOUT)
+		if n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT {
 			abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
-		} else if n.Class_ == ir.PAUTOHEAP {
+		} else if n.Class == ir.PAUTOHEAP {
 			// If dcl in question has been promoted to heap, do a bit
 			// of extra work to recover original class (auto or param);
 			// see issue 30908. This insures that we get the proper
@@ -198,9 +198,9 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 			// and not stack).
 			// TODO(thanm): generate a better location expression
 			stackcopy := n.Stackcopy
-			if stackcopy != nil && (stackcopy.Class_ == ir.PPARAM || stackcopy.Class_ == ir.PPARAMOUT) {
+			if stackcopy != nil && (stackcopy.Class == ir.PPARAM || stackcopy.Class == ir.PPARAMOUT) {
 				abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
-				isReturnValue = (stackcopy.Class_ == ir.PPARAMOUT)
+				isReturnValue = (stackcopy.Class == ir.PPARAMOUT)
 			}
 		}
 		inlIndex := 0
@@ -275,7 +275,7 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 	var abbrev int
 	var offs int64
 
-	switch n.Class_ {
+	switch n.Class {
 	case ir.PAUTO:
 		offs = n.FrameOffset()
 		abbrev = dwarf.DW_ABRV_AUTO
@@ -291,7 +291,7 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 		abbrev = dwarf.DW_ABRV_PARAM
 		offs = n.FrameOffset() + base.Ctxt.FixedFrameSize()
 	default:
-		base.Fatalf("createSimpleVar unexpected class %v for node %v", n.Class_, n)
+		base.Fatalf("createSimpleVar unexpected class %v for node %v", n.Class, n)
 	}
 
 	typename := dwarf.InfoPrefix + types.TypeSymName(n.Type())
@@ -308,7 +308,7 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 	declpos := base.Ctxt.InnermostPos(declPos(n))
 	return &dwarf.Var{
 		Name:          n.Sym().Name,
-		IsReturnValue: n.Class_ == ir.PPARAMOUT,
+		IsReturnValue: n.Class == ir.PPARAMOUT,
 		IsInlFormal:   n.InlFormal(),
 		Abbrev:        abbrev,
 		StackOffset:   int32(offs),
@@ -353,7 +353,7 @@ func createComplexVar(fnsym *obj.LSym, fn *ir.Func, varID ssa.VarID) *dwarf.Var
 	n := debug.Vars[varID]
 
 	var abbrev int
-	switch n.Class_ {
+	switch n.Class {
 	case ir.PAUTO:
 		abbrev = dwarf.DW_ABRV_AUTO_LOCLIST
 	case ir.PPARAM, ir.PPARAMOUT:
@@ -377,7 +377,7 @@ func createComplexVar(fnsym *obj.LSym, fn *ir.Func, varID ssa.VarID) *dwarf.Var
 	declpos := base.Ctxt.InnermostPos(n.Pos())
 	dvar := &dwarf.Var{
 		Name:          n.Sym().Name,
-		IsReturnValue: n.Class_ == ir.PPARAMOUT,
+		IsReturnValue: n.Class == ir.PPARAMOUT,
 		IsInlFormal:   n.InlFormal(),
 		Abbrev:        abbrev,
 		Type:          base.Ctxt.Lookup(typename),
diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index 1aba0a3fd2..6a2e685fe8 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -519,7 +519,7 @@ func (e *escape) exprSkipInit(k hole, n ir.Node) {
 
 	case ir.ONAME:
 		n := n.(*ir.Name)
-		if n.Class_ == ir.PFUNC || n.Class_ == ir.PEXTERN {
+		if n.Class == ir.PFUNC || n.Class == ir.PEXTERN {
 			return
 		}
 		e.flow(k, e.oldLoc(n))
@@ -791,7 +791,7 @@ func (e *escape) addr(n ir.Node) hole {
 		base.Fatalf("unexpected addr: %v", n)
 	case ir.ONAME:
 		n := n.(*ir.Name)
-		if n.Class_ == ir.PEXTERN {
+		if n.Class == ir.PEXTERN {
 			break
 		}
 		k = e.oldLoc(n).asHole()
@@ -899,7 +899,7 @@ func (e *escape) call(ks []hole, call, where ir.Node) {
 		switch call.Op() {
 		case ir.OCALLFUNC:
 			switch v := ir.StaticValue(call.X); {
-			case v.Op() == ir.ONAME && v.(*ir.Name).Class_ == ir.PFUNC:
+			case v.Op() == ir.ONAME && v.(*ir.Name).Class == ir.PFUNC:
 				fn = v.(*ir.Name)
 			case v.Op() == ir.OCLOSURE:
 				fn = v.(*ir.ClosureExpr).Func.Nname
@@ -1589,7 +1589,7 @@ func (b *batch) finish(fns []*ir.Func) {
 }
 
 func (l *location) isName(c ir.Class) bool {
-	return l.n != nil && l.n.Op() == ir.ONAME && l.n.(*ir.Name).Class_ == c
+	return l.n != nil && l.n.Op() == ir.ONAME && l.n.(*ir.Name).Class == c
 }
 
 const numEscResults = 7
@@ -1882,7 +1882,7 @@ func HeapAllocReason(n ir.Node) string {
 	// Parameters are always passed via the stack.
 	if n.Op() == ir.ONAME {
 		n := n.(*ir.Name)
-		if n.Class_ == ir.PPARAM || n.Class_ == ir.PPARAMOUT {
+		if n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT {
 			return ""
 		}
 	}
@@ -1939,7 +1939,7 @@ func addrescapes(n ir.Node) {
 
 		// if this is a tmpname (PAUTO), it was tagged by tmpname as not escaping.
 		// on PPARAM it means something different.
-		if n.Class_ == ir.PAUTO && n.Esc() == ir.EscNever {
+		if n.Class == ir.PAUTO && n.Esc() == ir.EscNever {
 			break
 		}
 
@@ -1949,7 +1949,7 @@ func addrescapes(n ir.Node) {
 			break
 		}
 
-		if n.Class_ != ir.PPARAM && n.Class_ != ir.PPARAMOUT && n.Class_ != ir.PAUTO {
+		if n.Class != ir.PPARAM && n.Class != ir.PPARAMOUT && n.Class != ir.PAUTO {
 			break
 		}
 
@@ -2003,7 +2003,7 @@ func moveToHeap(n *ir.Name) {
 	if base.Flag.CompilingRuntime {
 		base.Errorf("%v escapes to heap, not allowed in runtime", n)
 	}
-	if n.Class_ == ir.PAUTOHEAP {
+	if n.Class == ir.PAUTOHEAP {
 		ir.Dump("n", n)
 		base.Fatalf("double move to heap")
 	}
@@ -2022,7 +2022,7 @@ func moveToHeap(n *ir.Name) {
 	// Parameters have a local stack copy used at function start/end
 	// in addition to the copy in the heap that may live longer than
 	// the function.
-	if n.Class_ == ir.PPARAM || n.Class_ == ir.PPARAMOUT {
+	if n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT {
 		if n.FrameOffset() == types.BADWIDTH {
 			base.Fatalf("addrescapes before param assignment")
 		}
@@ -2034,9 +2034,9 @@ func moveToHeap(n *ir.Name) {
 		stackcopy := typecheck.NewName(n.Sym())
 		stackcopy.SetType(n.Type())
 		stackcopy.SetFrameOffset(n.FrameOffset())
-		stackcopy.Class_ = n.Class_
+		stackcopy.Class = n.Class
 		stackcopy.Heapaddr = heapaddr
-		if n.Class_ == ir.PPARAMOUT {
+		if n.Class == ir.PPARAMOUT {
 			// Make sure the pointer to the heap copy is kept live throughout the function.
 			// The function could panic at any point, and then a defer could recover.
 			// Thus, we need the pointer to the heap copy always available so the
@@ -2058,7 +2058,7 @@ func moveToHeap(n *ir.Name) {
 			}
 			// Parameters are before locals, so can stop early.
 			// This limits the search even in functions with many local variables.
-			if d.Class_ == ir.PAUTO {
+			if d.Class == ir.PAUTO {
 				break
 			}
 		}
@@ -2069,7 +2069,7 @@ func moveToHeap(n *ir.Name) {
 	}
 
 	// Modify n in place so that uses of n now mean indirection of the heapaddr.
-	n.Class_ = ir.PAUTOHEAP
+	n.Class = ir.PAUTOHEAP
 	n.SetFrameOffset(0)
 	n.Heapaddr = heapaddr
 	n.SetEsc(ir.EscHeap)
diff --git a/src/cmd/compile/internal/gc/abiutilsaux_test.go b/src/cmd/compile/internal/gc/abiutilsaux_test.go
index e6590beac0..9386b554b0 100644
--- a/src/cmd/compile/internal/gc/abiutilsaux_test.go
+++ b/src/cmd/compile/internal/gc/abiutilsaux_test.go
@@ -21,7 +21,7 @@ import (
 func mkParamResultField(t *types.Type, s *types.Sym, which ir.Class) *types.Field {
 	field := types.NewField(src.NoXPos, s, t)
 	n := typecheck.NewName(s)
-	n.Class_ = which
+	n.Class = which
 	field.Nname = n
 	n.SetType(t)
 	return field
diff --git a/src/cmd/compile/internal/gc/compile.go b/src/cmd/compile/internal/gc/compile.go
index 1b3dd672f3..25b1c76737 100644
--- a/src/cmd/compile/internal/gc/compile.go
+++ b/src/cmd/compile/internal/gc/compile.go
@@ -83,7 +83,7 @@ func compile(fn *ir.Func) {
 	// because symbols must be allocated before the parallel
 	// phase of the compiler.
 	for _, n := range fn.Dcl {
-		switch n.Class_ {
+		switch n.Class {
 		case ir.PPARAM, ir.PPARAMOUT, ir.PAUTO:
 			if liveness.ShouldTrack(n) && n.Addrtaken() {
 				reflectdata.WriteType(n.Type())
diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index c65c6c8335..356fcfa671 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -83,7 +83,7 @@ type exporter struct {
 func (p *exporter) markObject(n ir.Node) {
 	if n.Op() == ir.ONAME {
 		n := n.(*ir.Name)
-		if n.Class_ == ir.PFUNC {
+		if n.Class == ir.PFUNC {
 			inline.Inline_Flood(n, typecheck.Export)
 		}
 	}
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 30cfac1b71..fbb2145e1b 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -188,7 +188,7 @@ func dumpGlobal(n *ir.Name) {
 	if n.Type() == nil {
 		base.Fatalf("external %v nil type\n", n)
 	}
-	if n.Class_ == ir.PFUNC {
+	if n.Class == ir.PFUNC {
 		return
 	}
 	if n.Sym().Pkg != types.LocalPkg {
diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index b9b424b74d..6f5f6499ce 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -199,8 +199,8 @@ func Inline_Flood(n *ir.Name, exportsym func(*ir.Name)) {
 	if n == nil {
 		return
 	}
-	if n.Op() != ir.ONAME || n.Class_ != ir.PFUNC {
-		base.Fatalf("inlFlood: unexpected %v, %v, %v", n, n.Op(), n.Class_)
+	if n.Op() != ir.ONAME || n.Class != ir.PFUNC {
+		base.Fatalf("inlFlood: unexpected %v, %v, %v", n, n.Op(), n.Class)
 	}
 	fn := n.Func
 	if fn == nil {
@@ -227,7 +227,7 @@ func Inline_Flood(n *ir.Name, exportsym func(*ir.Name)) {
 
 		case ir.ONAME:
 			n := n.(*ir.Name)
-			switch n.Class_ {
+			switch n.Class {
 			case ir.PFUNC:
 				Inline_Flood(n, exportsym)
 				exportsym(n)
@@ -292,7 +292,7 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 		// runtime.throw is a "cheap call" like panic in normal code.
 		if n.X.Op() == ir.ONAME {
 			name := n.X.(*ir.Name)
-			if name.Class_ == ir.PFUNC && types.IsRuntimePkg(name.Sym().Pkg) {
+			if name.Class == ir.PFUNC && types.IsRuntimePkg(name.Sym().Pkg) {
 				fn := name.Sym().Name
 				if fn == "getcallerpc" || fn == "getcallersp" {
 					return errors.New("call to " + fn)
@@ -407,7 +407,7 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 
 	case ir.ONAME:
 		n := n.(*ir.Name)
-		if n.Class_ == ir.PAUTO {
+		if n.Class == ir.PAUTO {
 			v.usedLocals[n] = true
 		}
 
@@ -627,7 +627,7 @@ func inlCallee(fn ir.Node) *ir.Func {
 		return n.Func
 	case ir.ONAME:
 		fn := fn.(*ir.Name)
-		if fn.Class_ == ir.PFUNC {
+		if fn.Class == ir.PFUNC {
 			return fn.Func
 		}
 	case ir.OCLOSURE:
@@ -759,7 +759,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 		if ln.Op() != ir.ONAME {
 			continue
 		}
-		if ln.Class_ == ir.PPARAMOUT { // return values handled below.
+		if ln.Class == ir.PPARAMOUT { // return values handled below.
 			continue
 		}
 		if ir.IsParamStackCopy(ln) { // ignore the on-stack copy of a parameter that moved to the heap
@@ -772,7 +772,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 		inlf := typecheck.Expr(inlvar(ln)).(*ir.Name)
 		inlvars[ln] = inlf
 		if base.Flag.GenDwarfInl > 0 {
-			if ln.Class_ == ir.PPARAM {
+			if ln.Class == ir.PPARAM {
 				inlf.Name().SetInlFormal(true)
 			} else {
 				inlf.Name().SetInlLocal(true)
@@ -975,7 +975,7 @@ func inlvar(var_ *ir.Name) *ir.Name {
 
 	n := typecheck.NewName(var_.Sym())
 	n.SetType(var_.Type())
-	n.Class_ = ir.PAUTO
+	n.Class = ir.PAUTO
 	n.SetUsed(true)
 	n.Curfn = ir.CurFunc // the calling function, not the called one
 	n.SetAddrtaken(var_.Addrtaken())
@@ -988,7 +988,7 @@ func inlvar(var_ *ir.Name) *ir.Name {
 func retvar(t *types.Field, i int) *ir.Name {
 	n := typecheck.NewName(typecheck.LookupNum("~R", i))
 	n.SetType(t.Type)
-	n.Class_ = ir.PAUTO
+	n.Class = ir.PAUTO
 	n.SetUsed(true)
 	n.Curfn = ir.CurFunc // the calling function, not the called one
 	ir.CurFunc.Dcl = append(ir.CurFunc.Dcl, n)
@@ -1000,7 +1000,7 @@ func retvar(t *types.Field, i int) *ir.Name {
 func argvar(t *types.Type, i int) ir.Node {
 	n := typecheck.NewName(typecheck.LookupNum("~arg", i))
 	n.SetType(t.Elem())
-	n.Class_ = ir.PAUTO
+	n.Class = ir.PAUTO
 	n.SetUsed(true)
 	n.Curfn = ir.CurFunc // the calling function, not the called one
 	ir.CurFunc.Dcl = append(ir.CurFunc.Dcl, n)
@@ -1170,7 +1170,7 @@ func (subst *inlsubst) updatedPos(xpos src.XPos) src.XPos {
 func pruneUnusedAutos(ll []*ir.Name, vis *hairyVisitor) []*ir.Name {
 	s := make([]*ir.Name, 0, len(ll))
 	for _, n := range ll {
-		if n.Class_ == ir.PAUTO {
+		if n.Class == ir.PAUTO {
 			if _, found := vis.usedLocals[n]; !found {
 				continue
 			}
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 1b88427146..6d81bf8781 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -527,7 +527,7 @@ func (n *SelectorExpr) FuncName() *Name {
 		panic(n.no("FuncName"))
 	}
 	fn := NewNameAt(n.Selection.Pos, MethodSym(n.X.Type(), n.Sel))
-	fn.Class_ = PFUNC
+	fn.Class = PFUNC
 	fn.SetType(n.Type())
 	return fn
 }
@@ -736,7 +736,7 @@ func IsAddressable(n Node) bool {
 
 	case ONAME:
 		n := n.(*Name)
-		if n.Class_ == PFUNC {
+		if n.Class == PFUNC {
 			return false
 		}
 		return true
@@ -771,7 +771,7 @@ func staticValue1(nn Node) Node {
 		return nil
 	}
 	n := nn.(*Name)
-	if n.Class_ != PAUTO || n.Addrtaken() {
+	if n.Class != PAUTO || n.Addrtaken() {
 		return nil
 	}
 
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 1eaca9c6f3..12ef083c19 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -245,11 +245,11 @@ func FuncSymName(s *types.Sym) string {
 
 // MarkFunc marks a node as a function.
 func MarkFunc(n *Name) {
-	if n.Op() != ONAME || n.Class_ != Pxxx {
+	if n.Op() != ONAME || n.Class != Pxxx {
 		base.Fatalf("expected ONAME/Pxxx node, got %v", n)
 	}
 
-	n.Class_ = PFUNC
+	n.Class = PFUNC
 	n.Sym().SetFunc(true)
 }
 
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 689ef983f6..58b4ababff 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -37,7 +37,7 @@ func (*Ident) CanBeNtype() {}
 type Name struct {
 	miniExpr
 	BuiltinOp Op         // uint8
-	Class_    Class      // uint8
+	Class     Class      // uint8
 	pragma    PragmaFlag // int16
 	flags     bitset16
 	sym       *types.Sym
@@ -222,8 +222,6 @@ func (n *Name) Sym() *types.Sym     { return n.sym }
 func (n *Name) SetSym(x *types.Sym) { n.sym = x }
 func (n *Name) SubOp() Op           { return n.BuiltinOp }
 func (n *Name) SetSubOp(x Op)       { n.BuiltinOp = x }
-func (n *Name) Class() Class        { return n.Class_ }
-func (n *Name) SetClass(x Class)    { n.Class_ = x }
 func (n *Name) SetFunc(x *Func)     { n.Func = x }
 func (n *Name) Offset() int64       { panic("Name.Offset") }
 func (n *Name) SetOffset(x int64) {
@@ -425,7 +423,7 @@ func IsParamStackCopy(n Node) bool {
 		return false
 	}
 	name := n.(*Name)
-	return (name.Class_ == PPARAM || name.Class_ == PPARAMOUT) && name.Heapaddr != nil
+	return (name.Class == PPARAM || name.Class == PPARAMOUT) && name.Heapaddr != nil
 }
 
 // IsParamHeapCopy reports whether this is the on-heap copy of
@@ -435,7 +433,7 @@ func IsParamHeapCopy(n Node) bool {
 		return false
 	}
 	name := n.(*Name)
-	return name.Class_ == PAUTOHEAP && name.Stackcopy != nil
+	return name.Class == PAUTOHEAP && name.Stackcopy != nil
 }
 
 var RegFP *Name
diff --git a/src/cmd/compile/internal/ir/scc.go b/src/cmd/compile/internal/ir/scc.go
index f35c4d44e9..83c6074170 100644
--- a/src/cmd/compile/internal/ir/scc.go
+++ b/src/cmd/compile/internal/ir/scc.go
@@ -87,7 +87,7 @@ func (v *bottomUpVisitor) visit(n *Func) uint32 {
 	Visit(n, func(n Node) {
 		switch n.Op() {
 		case ONAME:
-			if n := n.(*Name); n.Class_ == PFUNC {
+			if n := n.(*Name); n.Class == PFUNC {
 				do(n.Defn)
 			}
 		case ODOTMETH, OCALLPART, OMETHEXPR:
diff --git a/src/cmd/compile/internal/liveness/plive.go b/src/cmd/compile/internal/liveness/plive.go
index 91f10b0a9d..26d90824b2 100644
--- a/src/cmd/compile/internal/liveness/plive.go
+++ b/src/cmd/compile/internal/liveness/plive.go
@@ -181,7 +181,7 @@ type progeffectscache struct {
 // nor do we care about empty structs (handled by the pointer check),
 // nor do we care about the fake PAUTOHEAP variables.
 func ShouldTrack(n *ir.Name) bool {
-	return (n.Class_ == ir.PAUTO || n.Class_ == ir.PPARAM || n.Class_ == ir.PPARAMOUT) && n.Type().HasPointers()
+	return (n.Class == ir.PAUTO || n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT) && n.Type().HasPointers()
 }
 
 // getvariables returns the list of on-stack variables that we need to track
@@ -208,7 +208,7 @@ func (lv *liveness) initcache() {
 	lv.cache.initialized = true
 
 	for i, node := range lv.vars {
-		switch node.Class_ {
+		switch node.Class {
 		case ir.PPARAM:
 			// A return instruction with a p.to is a tail return, which brings
 			// the stack pointer back up (if it ever went down) and then jumps
@@ -386,7 +386,7 @@ func (lv *liveness) pointerMap(liveout bitvec.BitVec, vars []*ir.Name, args, loc
 			break
 		}
 		node := vars[i]
-		switch node.Class_ {
+		switch node.Class {
 		case ir.PAUTO:
 			typebits.Set(node.Type(), node.FrameOffset()+lv.stkptrsize, locals)
 
@@ -687,7 +687,7 @@ func (lv *liveness) epilogue() {
 	// don't need to keep the stack copy live?
 	if lv.fn.HasDefer() {
 		for i, n := range lv.vars {
-			if n.Class_ == ir.PPARAMOUT {
+			if n.Class == ir.PPARAMOUT {
 				if n.IsOutputParamHeapAddr() {
 					// Just to be paranoid.  Heap addresses are PAUTOs.
 					base.Fatalf("variable %v both output param and heap output param", n)
@@ -785,7 +785,7 @@ func (lv *liveness) epilogue() {
 				if !liveout.Get(int32(i)) {
 					continue
 				}
-				if n.Class_ == ir.PPARAM {
+				if n.Class == ir.PPARAM {
 					continue // ok
 				}
 				base.Fatalf("bad live variable at entry of %v: %L", lv.fn.Nname, n)
@@ -818,7 +818,7 @@ func (lv *liveness) epilogue() {
 	// the only things that can possibly be live are the
 	// input parameters.
 	for j, n := range lv.vars {
-		if n.Class_ != ir.PPARAM && lv.stackMaps[0].Get(int32(j)) {
+		if n.Class != ir.PPARAM && lv.stackMaps[0].Get(int32(j)) {
 			lv.f.Fatalf("%v %L recorded as live on entry", lv.fn.Nname, n)
 		}
 	}
@@ -1063,7 +1063,7 @@ func (lv *liveness) emit() (argsSym, liveSym *obj.LSym) {
 	// (Nodes without pointers aren't in lv.vars; see livenessShouldTrack.)
 	var maxArgNode *ir.Name
 	for _, n := range lv.vars {
-		switch n.Class_ {
+		switch n.Class {
 		case ir.PPARAM, ir.PPARAMOUT:
 			if maxArgNode == nil || n.FrameOffset() > maxArgNode.FrameOffset() {
 				maxArgNode = n
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 678e378291..76913c62a6 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -1176,10 +1176,10 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) ir.Node {
 		n := ir.NewReturnStmt(p.pos(stmt), p.exprList(stmt.Results))
 		if len(n.Results) == 0 && ir.CurFunc != nil {
 			for _, ln := range ir.CurFunc.Dcl {
-				if ln.Class_ == ir.PPARAM {
+				if ln.Class == ir.PPARAM {
 					continue
 				}
-				if ln.Class_ != ir.PPARAMOUT {
+				if ln.Class != ir.PPARAMOUT {
 					break
 				}
 				if ln.Sym().Def != ln {
@@ -1956,7 +1956,7 @@ func oldname(s *types.Sym) ir.Node {
 		if c == nil || c.Curfn != ir.CurFunc {
 			// Do not have a closure var for the active closure yet; make one.
 			c = typecheck.NewName(s)
-			c.Class_ = ir.PAUTOHEAP
+			c.Class = ir.PAUTOHEAP
 			c.SetIsClosureVar(true)
 			c.Defn = n
 
diff --git a/src/cmd/compile/internal/pkginit/init.go b/src/cmd/compile/internal/pkginit/init.go
index a32e09879c..5bc66c7e1b 100644
--- a/src/cmd/compile/internal/pkginit/init.go
+++ b/src/cmd/compile/internal/pkginit/init.go
@@ -32,7 +32,7 @@ func Task() *ir.Name {
 		if n.Op() == ir.ONONAME {
 			continue
 		}
-		if n.Op() != ir.ONAME || n.(*ir.Name).Class_ != ir.PEXTERN {
+		if n.Op() != ir.ONAME || n.(*ir.Name).Class != ir.PEXTERN {
 			base.Fatalf("bad inittask: %v", n)
 		}
 		deps = append(deps, n.(*ir.Name).Linksym())
@@ -89,7 +89,7 @@ func Task() *ir.Name {
 	sym := typecheck.Lookup(".inittask")
 	task := typecheck.NewName(sym)
 	task.SetType(types.Types[types.TUINT8]) // fake type
-	task.Class_ = ir.PEXTERN
+	task.Class = ir.PEXTERN
 	sym.Def = task
 	lsym := task.Linksym()
 	ot := 0
diff --git a/src/cmd/compile/internal/pkginit/initorder.go b/src/cmd/compile/internal/pkginit/initorder.go
index 1c222c1de4..bdefd594ff 100644
--- a/src/cmd/compile/internal/pkginit/initorder.go
+++ b/src/cmd/compile/internal/pkginit/initorder.go
@@ -140,7 +140,7 @@ func (o *InitOrder) processAssign(n ir.Node) {
 		defn := dep.Defn
 		// Skip dependencies on functions (PFUNC) and
 		// variables already initialized (InitDone).
-		if dep.Class_ != ir.PEXTERN || o.order[defn] == orderDone {
+		if dep.Class != ir.PEXTERN || o.order[defn] == orderDone {
 			continue
 		}
 		o.order[n]++
@@ -204,7 +204,7 @@ func (o *InitOrder) findInitLoopAndExit(n *ir.Name, path *[]*ir.Name) {
 	*path = append(*path, n)
 	for _, ref := range refers {
 		// Short-circuit variables that were initialized.
-		if ref.Class_ == ir.PEXTERN && o.order[ref.Defn] == orderDone {
+		if ref.Class == ir.PEXTERN && o.order[ref.Defn] == orderDone {
 			continue
 		}
 
@@ -221,7 +221,7 @@ func reportInitLoopAndExit(l []*ir.Name) {
 	// the start.
 	i := -1
 	for j, n := range l {
-		if n.Class_ == ir.PEXTERN && (i == -1 || n.Pos().Before(l[i].Pos())) {
+		if n.Class == ir.PEXTERN && (i == -1 || n.Pos().Before(l[i].Pos())) {
 			i = j
 		}
 	}
@@ -291,7 +291,7 @@ func (d *initDeps) visit(n ir.Node) {
 	switch n.Op() {
 	case ir.ONAME:
 		n := n.(*ir.Name)
-		switch n.Class_ {
+		switch n.Class {
 		case ir.PEXTERN, ir.PFUNC:
 			d.foundDep(n)
 		}
@@ -324,7 +324,7 @@ func (d *initDeps) foundDep(n *ir.Name) {
 		return
 	}
 	d.seen.Add(n)
-	if d.transitive && n.Class_ == ir.PFUNC {
+	if d.transitive && n.Class == ir.PFUNC {
 		d.inspectList(n.Defn.(*ir.Func).Body)
 	}
 }
diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index f926765326..30857fff6d 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -840,7 +840,7 @@ func TypePtr(t *types.Type) *ir.AddrExpr {
 	if s.Def == nil {
 		n := ir.NewNameAt(src.NoXPos, s)
 		n.SetType(types.Types[types.TUINT8])
-		n.Class_ = ir.PEXTERN
+		n.Class = ir.PEXTERN
 		n.SetTypecheck(1)
 		s.Def = n
 	}
@@ -859,7 +859,7 @@ func ITabAddr(t, itype *types.Type) *ir.AddrExpr {
 	if s.Def == nil {
 		n := typecheck.NewName(s)
 		n.SetType(types.Types[types.TUINT8])
-		n.Class_ = ir.PEXTERN
+		n.Class = ir.PEXTERN
 		n.SetTypecheck(1)
 		s.Def = n
 		itabs = append(itabs, itabEntry{t: t, itype: itype, lsym: n.Linksym()})
@@ -1370,7 +1370,7 @@ func WriteTabs() {
 			// }
 			nsym := dname(p.Sym().Name, "", nil, true)
 			t := p.Type()
-			if p.Class_ != ir.PFUNC {
+			if p.Class != ir.PFUNC {
 				t = types.NewPtr(t)
 			}
 			tsym := WriteType(t)
@@ -1674,7 +1674,7 @@ func ZeroAddr(size int64) ir.Node {
 	if s.Def == nil {
 		x := typecheck.NewName(s)
 		x.SetType(types.Types[types.TUINT8])
-		x.Class_ = ir.PEXTERN
+		x.Class = ir.PEXTERN
 		x.SetTypecheck(1)
 		s.Def = x
 	}
diff --git a/src/cmd/compile/internal/ssa/deadstore.go b/src/cmd/compile/internal/ssa/deadstore.go
index a68c82ba97..530918da4d 100644
--- a/src/cmd/compile/internal/ssa/deadstore.go
+++ b/src/cmd/compile/internal/ssa/deadstore.go
@@ -148,7 +148,7 @@ func elimDeadAutosGeneric(f *Func) {
 		case OpAddr, OpLocalAddr:
 			// Propagate the address if it points to an auto.
 			n, ok := v.Aux.(*ir.Name)
-			if !ok || n.Class() != ir.PAUTO {
+			if !ok || n.Class != ir.PAUTO {
 				return
 			}
 			if addr[v] == nil {
@@ -159,7 +159,7 @@ func elimDeadAutosGeneric(f *Func) {
 		case OpVarDef, OpVarKill:
 			// v should be eliminated if we eliminate the auto.
 			n, ok := v.Aux.(*ir.Name)
-			if !ok || n.Class() != ir.PAUTO {
+			if !ok || n.Class != ir.PAUTO {
 				return
 			}
 			if elim[v] == nil {
@@ -175,7 +175,7 @@ func elimDeadAutosGeneric(f *Func) {
 			// may not be used by the inline code, but will be used by
 			// panic processing).
 			n, ok := v.Aux.(*ir.Name)
-			if !ok || n.Class() != ir.PAUTO {
+			if !ok || n.Class != ir.PAUTO {
 				return
 			}
 			if !used[n] {
@@ -307,7 +307,7 @@ func elimUnreadAutos(f *Func) {
 			if !ok {
 				continue
 			}
-			if n.Class() != ir.PAUTO {
+			if n.Class != ir.PAUTO {
 				continue
 			}
 
diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go
index 8712ff78c1..32e6d09d1b 100644
--- a/src/cmd/compile/internal/ssa/export_test.go
+++ b/src/cmd/compile/internal/ssa/export_test.go
@@ -70,7 +70,7 @@ func (TestFrontend) StringData(s string) *obj.LSym {
 }
 func (TestFrontend) Auto(pos src.XPos, t *types.Type) *ir.Name {
 	n := ir.NewNameAt(pos, &types.Sym{Name: "aFakeAuto"})
-	n.SetClass(ir.PAUTO)
+	n.Class = ir.PAUTO
 	return n
 }
 func (d TestFrontend) SplitString(s LocalSlot) (LocalSlot, LocalSlot) {
diff --git a/src/cmd/compile/internal/ssagen/nowb.go b/src/cmd/compile/internal/ssagen/nowb.go
index 26858fac87..60cfb2f698 100644
--- a/src/cmd/compile/internal/ssagen/nowb.go
+++ b/src/cmd/compile/internal/ssagen/nowb.go
@@ -76,7 +76,7 @@ func (c *nowritebarrierrecChecker) findExtraCalls(nn ir.Node) {
 		return
 	}
 	fn := n.X.(*ir.Name)
-	if fn.Class_ != ir.PFUNC || fn.Defn == nil {
+	if fn.Class != ir.PFUNC || fn.Defn == nil {
 		return
 	}
 	if !types.IsRuntimePkg(fn.Sym().Pkg) || fn.Sym().Name != "systemstack" {
diff --git a/src/cmd/compile/internal/ssagen/pgen.go b/src/cmd/compile/internal/ssagen/pgen.go
index 2be10ff7af..bbd319d735 100644
--- a/src/cmd/compile/internal/ssagen/pgen.go
+++ b/src/cmd/compile/internal/ssagen/pgen.go
@@ -34,11 +34,11 @@ import (
 // the top of the stack and increasing in size.
 // Non-autos sort on offset.
 func cmpstackvarlt(a, b *ir.Name) bool {
-	if (a.Class_ == ir.PAUTO) != (b.Class_ == ir.PAUTO) {
-		return b.Class_ == ir.PAUTO
+	if (a.Class == ir.PAUTO) != (b.Class == ir.PAUTO) {
+		return b.Class == ir.PAUTO
 	}
 
-	if a.Class_ != ir.PAUTO {
+	if a.Class != ir.PAUTO {
 		return a.FrameOffset() < b.FrameOffset()
 	}
 
@@ -79,7 +79,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 
 	// Mark the PAUTO's unused.
 	for _, ln := range fn.Dcl {
-		if ln.Class_ == ir.PAUTO {
+		if ln.Class == ir.PAUTO {
 			ln.SetUsed(false)
 		}
 	}
@@ -94,7 +94,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 	for _, b := range f.Blocks {
 		for _, v := range b.Values {
 			if n, ok := v.Aux.(*ir.Name); ok {
-				switch n.Class_ {
+				switch n.Class {
 				case ir.PPARAM, ir.PPARAMOUT:
 					// Don't modify nodfp; it is a global.
 					if n != ir.RegFP {
@@ -120,7 +120,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 	// Reassign stack offsets of the locals that are used.
 	lastHasPtr := false
 	for i, n := range fn.Dcl {
-		if n.Op() != ir.ONAME || n.Class_ != ir.PAUTO {
+		if n.Op() != ir.ONAME || n.Class != ir.PAUTO {
 			continue
 		}
 		if !n.Used() {
@@ -207,7 +207,7 @@ func init() {
 func StackOffset(slot ssa.LocalSlot) int32 {
 	n := slot.N
 	var off int64
-	switch n.Class_ {
+	switch n.Class {
 	case ir.PAUTO:
 		off = n.FrameOffset()
 		if base.Ctxt.FixedFrameSize() == 0 {
diff --git a/src/cmd/compile/internal/ssagen/pgen_test.go b/src/cmd/compile/internal/ssagen/pgen_test.go
index 82d8447e9f..69ed8ad74e 100644
--- a/src/cmd/compile/internal/ssagen/pgen_test.go
+++ b/src/cmd/compile/internal/ssagen/pgen_test.go
@@ -46,7 +46,7 @@ func TestCmpstackvar(t *testing.T) {
 		n := typecheck.NewName(s)
 		n.SetType(t)
 		n.SetFrameOffset(xoffset)
-		n.Class_ = cl
+		n.Class = cl
 		return n
 	}
 	testdata := []struct {
@@ -161,7 +161,7 @@ func TestStackvarSort(t *testing.T) {
 		n := typecheck.NewName(s)
 		n.SetType(t)
 		n.SetFrameOffset(xoffset)
-		n.Class_ = cl
+		n.Class = cl
 		return n
 	}
 	inp := []*ir.Name{
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 8e3b09aac3..5998c42012 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -436,7 +436,7 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 	var args []ssa.Param
 	var results []ssa.Param
 	for _, n := range fn.Dcl {
-		switch n.Class_ {
+		switch n.Class {
 		case ir.PPARAM:
 			s.decladdrs[n] = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(n.Type()), n, s.sp, s.startmem)
 			args = append(args, ssa.Param{Type: n.Type(), Offset: int32(n.FrameOffset())})
@@ -457,13 +457,13 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 		case ir.PFUNC:
 			// local function - already handled by frontend
 		default:
-			s.Fatalf("local variable with class %v unimplemented", n.Class_)
+			s.Fatalf("local variable with class %v unimplemented", n.Class)
 		}
 	}
 
 	// Populate SSAable arguments.
 	for _, n := range fn.Dcl {
-		if n.Class_ == ir.PPARAM && s.canSSA(n) {
+		if n.Class == ir.PPARAM && s.canSSA(n) {
 			v := s.newValue0A(ssa.OpArg, n.Type(), n)
 			s.vars[n] = v
 			s.addNamedValue(n, v) // This helps with debugging information, not needed for compilation itself.
@@ -1166,7 +1166,7 @@ func (s *state) stmt(n ir.Node) {
 	case ir.OCALLINTER:
 		n := n.(*ir.CallExpr)
 		s.callResult(n, callNormal)
-		if n.Op() == ir.OCALLFUNC && n.X.Op() == ir.ONAME && n.X.(*ir.Name).Class_ == ir.PFUNC {
+		if n.Op() == ir.OCALLFUNC && n.X.Op() == ir.ONAME && n.X.(*ir.Name).Class == ir.PFUNC {
 			if fn := n.X.Sym().Name; base.Flag.CompilingRuntime && fn == "throw" ||
 				n.X.Sym().Pkg == ir.Pkgs.Runtime && (fn == "throwinit" || fn == "gopanic" || fn == "panicwrap" || fn == "block" || fn == "panicmakeslicelen" || fn == "panicmakeslicecap") {
 				m := s.mem()
@@ -1242,7 +1242,7 @@ func (s *state) stmt(n ir.Node) {
 
 	case ir.ODCL:
 		n := n.(*ir.Decl)
-		if n.X.Class_ == ir.PAUTOHEAP {
+		if n.X.Class == ir.PAUTOHEAP {
 			s.Fatalf("DCL %v", n)
 		}
 
@@ -1634,7 +1634,7 @@ func (s *state) stmt(n ir.Node) {
 		if !v.Addrtaken() {
 			s.Fatalf("VARLIVE variable %v must have Addrtaken set", v)
 		}
-		switch v.Class_ {
+		switch v.Class {
 		case ir.PAUTO, ir.PPARAM, ir.PPARAMOUT:
 		default:
 			s.Fatalf("VARLIVE variable %v must be Auto or Arg", v)
@@ -2110,7 +2110,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		return s.entryNewValue1A(ssa.OpAddr, n.Type(), aux, s.sb)
 	case ir.ONAME:
 		n := n.(*ir.Name)
-		if n.Class_ == ir.PFUNC {
+		if n.Class == ir.PFUNC {
 			// "value" of a function is the address of the function's closure
 			sym := staticdata.FuncLinksym(n)
 			return s.entryNewValue1A(ssa.OpAddr, types.NewPtr(n.Type()), sym, s.sb)
@@ -3003,7 +3003,7 @@ func (s *state) append(n *ir.CallExpr, inplace bool) *ssa.Value {
 	if inplace {
 		if sn.Op() == ir.ONAME {
 			sn := sn.(*ir.Name)
-			if sn.Class_ != ir.PEXTERN {
+			if sn.Class != ir.PEXTERN {
 				// Tell liveness we're about to build a new slice
 				s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, sn, s.mem())
 			}
@@ -3222,7 +3222,7 @@ func (s *state) assign(left ir.Node, right *ssa.Value, deref bool, skip skipMask
 
 	// If this assignment clobbers an entire local variable, then emit
 	// OpVarDef so liveness analysis knows the variable is redefined.
-	if base := clobberBase(left); base.Op() == ir.ONAME && base.(*ir.Name).Class_ != ir.PEXTERN && skip == 0 {
+	if base := clobberBase(left); base.Op() == ir.ONAME && base.(*ir.Name).Class != ir.PEXTERN && skip == 0 {
 		s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, base.(*ir.Name), s.mem(), !ir.IsAutoTmp(base))
 	}
 
@@ -4385,7 +4385,7 @@ func (s *state) openDeferRecord(n *ir.CallExpr) {
 		closureVal := s.expr(fn)
 		closure := s.openDeferSave(nil, fn.Type(), closureVal)
 		opendefer.closureNode = closure.Aux.(*ir.Name)
-		if !(fn.Op() == ir.ONAME && fn.(*ir.Name).Class_ == ir.PFUNC) {
+		if !(fn.Op() == ir.ONAME && fn.(*ir.Name).Class == ir.PFUNC) {
 			opendefer.closure = closure
 		}
 	} else if n.Op() == ir.OCALLMETH {
@@ -4651,7 +4651,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 	switch n.Op() {
 	case ir.OCALLFUNC:
 		testLateExpansion = k != callDeferStack && ssa.LateCallExpansionEnabledWithin(s.f)
-		if k == callNormal && fn.Op() == ir.ONAME && fn.(*ir.Name).Class_ == ir.PFUNC {
+		if k == callNormal && fn.Op() == ir.ONAME && fn.(*ir.Name).Class == ir.PFUNC {
 			fn := fn.(*ir.Name)
 			sym = fn.Sym()
 			break
@@ -4958,7 +4958,7 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 		fallthrough
 	case ir.ONAME:
 		n := n.(*ir.Name)
-		switch n.Class_ {
+		switch n.Class {
 		case ir.PEXTERN:
 			// global variable
 			v := s.entryNewValue1A(ssa.OpAddr, t, n.Linksym(), s.sb)
@@ -4987,7 +4987,7 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 			// that cse works on their addresses
 			return s.newValue2Apos(ssa.OpLocalAddr, t, n, s.sp, s.mem(), true)
 		default:
-			s.Fatalf("variable address class %v not implemented", n.Class_)
+			s.Fatalf("variable address class %v not implemented", n.Class)
 			return nil
 		}
 	case ir.ORESULT:
@@ -5096,10 +5096,10 @@ func (s *state) canSSAName(name *ir.Name) bool {
 	if ir.IsParamHeapCopy(name) {
 		return false
 	}
-	if name.Class_ == ir.PAUTOHEAP {
+	if name.Class == ir.PAUTOHEAP {
 		s.Fatalf("canSSA of PAUTOHEAP %v", name)
 	}
-	switch name.Class_ {
+	switch name.Class {
 	case ir.PEXTERN:
 		return false
 	case ir.PPARAMOUT:
@@ -5117,7 +5117,7 @@ func (s *state) canSSAName(name *ir.Name) bool {
 			return false
 		}
 	}
-	if name.Class_ == ir.PPARAM && name.Sym() != nil && name.Sym().Name == ".this" {
+	if name.Class == ir.PPARAM && name.Sym() != nil && name.Sym().Name == ".this" {
 		// wrappers generated by genwrapper need to update
 		// the .this pointer in place.
 		// TODO: treat as a PPARAMOUT?
@@ -6210,7 +6210,7 @@ func (s *state) mem() *ssa.Value {
 }
 
 func (s *state) addNamedValue(n *ir.Name, v *ssa.Value) {
-	if n.Class_ == ir.Pxxx {
+	if n.Class == ir.Pxxx {
 		// Don't track our marker nodes (memVar etc.).
 		return
 	}
@@ -6218,7 +6218,7 @@ func (s *state) addNamedValue(n *ir.Name, v *ssa.Value) {
 		// Don't track temporary variables.
 		return
 	}
-	if n.Class_ == ir.PPARAMOUT {
+	if n.Class == ir.PPARAMOUT {
 		// Don't track named output values.  This prevents return values
 		// from being assigned too early. See #14591 and #14762. TODO: allow this.
 		return
@@ -6741,8 +6741,8 @@ func defframe(s *State, e *ssafn) {
 		if !n.Needzero() {
 			continue
 		}
-		if n.Class_ != ir.PAUTO {
-			e.Fatalf(n.Pos(), "needzero class %d", n.Class_)
+		if n.Class != ir.PAUTO {
+			e.Fatalf(n.Pos(), "needzero class %d", n.Class)
 		}
 		if n.Type().Size()%int64(types.PtrSize) != 0 || n.FrameOffset()%int64(types.PtrSize) != 0 || n.Type().Size() == 0 {
 			e.Fatalf(n.Pos(), "var %L has size %d offset %d", n, n.Type().Size(), n.Offset_)
@@ -6826,7 +6826,7 @@ func AddAux2(a *obj.Addr, v *ssa.Value, offset int64) {
 		a.Name = obj.NAME_EXTERN
 		a.Sym = n
 	case *ir.Name:
-		if n.Class_ == ir.PPARAM || n.Class_ == ir.PPARAMOUT {
+		if n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT {
 			a.Name = obj.NAME_PARAM
 			a.Sym = ir.Orig(n).(*ir.Name).Linksym()
 			a.Offset += n.FrameOffset()
@@ -6968,7 +6968,7 @@ func AddrAuto(a *obj.Addr, v *ssa.Value) {
 	a.Sym = n.Linksym()
 	a.Reg = int16(Arch.REGSP)
 	a.Offset = n.FrameOffset() + off
-	if n.Class_ == ir.PPARAM || n.Class_ == ir.PPARAMOUT {
+	if n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT {
 		a.Name = obj.NAME_PARAM
 	} else {
 		a.Name = obj.NAME_AUTO
@@ -7198,7 +7198,7 @@ func (e *ssafn) DerefItab(it *obj.LSym, offset int64) *obj.LSym {
 func (e *ssafn) SplitSlot(parent *ssa.LocalSlot, suffix string, offset int64, t *types.Type) ssa.LocalSlot {
 	node := parent.N
 
-	if node.Class_ != ir.PAUTO || node.Addrtaken() {
+	if node.Class != ir.PAUTO || node.Addrtaken() {
 		// addressed things and non-autos retain their parents (i.e., cannot truly be split)
 		return ssa.LocalSlot{N: node, Type: t, Off: parent.Off + offset}
 	}
@@ -7208,7 +7208,7 @@ func (e *ssafn) SplitSlot(parent *ssa.LocalSlot, suffix string, offset int64, t
 	s.Def = n
 	ir.AsNode(s.Def).Name().SetUsed(true)
 	n.SetType(t)
-	n.Class_ = ir.PAUTO
+	n.Class = ir.PAUTO
 	n.SetEsc(ir.EscNever)
 	n.Curfn = e.curfn
 	e.curfn.Dcl = append(e.curfn.Dcl, n)
diff --git a/src/cmd/compile/internal/staticdata/data.go b/src/cmd/compile/internal/staticdata/data.go
index 27d9cec06d..94fa6760a0 100644
--- a/src/cmd/compile/internal/staticdata/data.go
+++ b/src/cmd/compile/internal/staticdata/data.go
@@ -50,8 +50,8 @@ func InitFunc(n *ir.Name, noff int64, f *ir.Name) {
 	if n.Sym() == nil {
 		base.Fatalf("pfuncsym nil n sym")
 	}
-	if f.Class_ != ir.PFUNC {
-		base.Fatalf("pfuncsym class not PFUNC %d", f.Class_)
+	if f.Class != ir.PFUNC {
+		base.Fatalf("pfuncsym class not PFUNC %d", f.Class)
 	}
 	s := n.Linksym()
 	s.WriteAddr(base.Ctxt, noff, types.PtrSize, FuncLinksym(f), 0)
@@ -259,7 +259,7 @@ func FuncSym(s *types.Sym) *types.Sym {
 }
 
 func FuncLinksym(n *ir.Name) *obj.LSym {
-	if n.Op() != ir.ONAME || n.Class_ != ir.PFUNC {
+	if n.Op() != ir.ONAME || n.Class != ir.PFUNC {
 		base.Fatalf("expected func name: %v", n)
 	}
 	return FuncSym(n.Sym()).Linksym()
diff --git a/src/cmd/compile/internal/staticinit/sched.go b/src/cmd/compile/internal/staticinit/sched.go
index 8e4ce55954..ac0b6cd87e 100644
--- a/src/cmd/compile/internal/staticinit/sched.go
+++ b/src/cmd/compile/internal/staticinit/sched.go
@@ -78,12 +78,12 @@ func (s *Schedule) tryStaticInit(nn ir.Node) bool {
 // like staticassign but we are copying an already
 // initialized value r.
 func (s *Schedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *types.Type) bool {
-	if rn.Class_ == ir.PFUNC {
+	if rn.Class == ir.PFUNC {
 		// TODO if roff != 0 { panic }
 		staticdata.InitFunc(l, loff, rn)
 		return true
 	}
-	if rn.Class_ != ir.PEXTERN || rn.Sym().Pkg != types.LocalPkg {
+	if rn.Class != ir.PEXTERN || rn.Sym().Pkg != types.LocalPkg {
 		return false
 	}
 	if rn.Defn.Op() != ir.OAS {
@@ -246,7 +246,7 @@ func (s *Schedule) StaticAssign(l *ir.Name, loff int64, r ir.Node, typ *types.Ty
 
 	case ir.OSTR2BYTES:
 		r := r.(*ir.ConvExpr)
-		if l.Class_ == ir.PEXTERN && r.X.Op() == ir.OLITERAL {
+		if l.Class == ir.PEXTERN && r.X.Op() == ir.OLITERAL {
 			sval := ir.StringVal(r.X)
 			staticdata.InitSliceBytes(l, loff, sval)
 			return true
diff --git a/src/cmd/compile/internal/typecheck/dcl.go b/src/cmd/compile/internal/typecheck/dcl.go
index 5eaf100eed..6c3aa3781e 100644
--- a/src/cmd/compile/internal/typecheck/dcl.go
+++ b/src/cmd/compile/internal/typecheck/dcl.go
@@ -91,7 +91,7 @@ func Declare(n *ir.Name, ctxt ir.Class) {
 	s.Lastlineno = base.Pos
 	s.Def = n
 	n.Vargen = int32(gen)
-	n.Class_ = ctxt
+	n.Class = ctxt
 	if ctxt == ir.PFUNC {
 		n.Sym().SetFunc(true)
 	}
@@ -455,7 +455,7 @@ func TempAt(pos src.XPos, curfn *ir.Func, t *types.Type) *ir.Name {
 	n := ir.NewNameAt(pos, s)
 	s.Def = n
 	n.SetType(t)
-	n.Class_ = ir.PAUTO
+	n.Class = ir.PAUTO
 	n.SetEsc(ir.EscNever)
 	n.Curfn = curfn
 	n.SetUsed(true)
diff --git a/src/cmd/compile/internal/typecheck/export.go b/src/cmd/compile/internal/typecheck/export.go
index c525391401..63d0a1ec6c 100644
--- a/src/cmd/compile/internal/typecheck/export.go
+++ b/src/cmd/compile/internal/typecheck/export.go
@@ -53,7 +53,7 @@ func importsym(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op ir.Op, ctxt ir.Cl
 	}
 
 	n := ir.NewDeclNameAt(pos, op, s)
-	n.Class_ = ctxt // TODO(mdempsky): Move this into NewDeclNameAt too?
+	n.Class = ctxt // TODO(mdempsky): Move this into NewDeclNameAt too?
 	s.SetPkgDef(n)
 	return n
 }
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index 8592397004..b3efb8f25a 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -129,7 +129,7 @@ func CaptureVars(fn *ir.Func) {
 		outermost := v.Defn.(*ir.Name)
 
 		// out parameters will be assigned to implicitly upon return.
-		if outermost.Class_ != ir.PPARAMOUT && !outermost.Addrtaken() && !outermost.Assigned() && v.Type().Size() <= 128 {
+		if outermost.Class != ir.PPARAMOUT && !outermost.Addrtaken() && !outermost.Assigned() && v.Type().Size() <= 128 {
 			v.SetByval(true)
 		} else {
 			outermost.SetAddrtaken(true)
@@ -408,7 +408,7 @@ func tcFunc(n *ir.Func) {
 	}
 
 	for _, ln := range n.Dcl {
-		if ln.Op() == ir.ONAME && (ln.Class_ == ir.PPARAM || ln.Class_ == ir.PPARAMOUT) {
+		if ln.Op() == ir.ONAME && (ln.Class == ir.PPARAM || ln.Class == ir.PPARAMOUT) {
 			ln.Decldepth = 1
 		}
 	}
diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index dd515b8ccd..a7927c39a3 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -430,7 +430,7 @@ func (p *iexporter) doDecl(n *ir.Name) {
 
 	switch n.Op() {
 	case ir.ONAME:
-		switch n.Class_ {
+		switch n.Class {
 		case ir.PEXTERN:
 			// Variable.
 			w.tag('V')
@@ -450,7 +450,7 @@ func (p *iexporter) doDecl(n *ir.Name) {
 			w.funcExt(n)
 
 		default:
-			base.Fatalf("unexpected class: %v, %v", n, n.Class_)
+			base.Fatalf("unexpected class: %v, %v", n, n.Class)
 		}
 
 	case ir.OLITERAL:
@@ -1260,7 +1260,7 @@ func (w *exportWriter) expr(n ir.Node) {
 	case ir.ONAME:
 		// Package scope name.
 		n := n.(*ir.Name)
-		if (n.Class_ == ir.PEXTERN || n.Class_ == ir.PFUNC) && !ir.IsBlank(n) {
+		if (n.Class == ir.PEXTERN || n.Class == ir.PFUNC) && !ir.IsBlank(n) {
 			w.op(ir.ONONAME)
 			w.qualifiedIdent(n)
 			break
@@ -1526,7 +1526,7 @@ func (w *exportWriter) localName(n *ir.Name) {
 	// PPARAM/PPARAMOUT, because we only want to include vargen in
 	// non-param names.
 	var v int32
-	if n.Class_ == ir.PAUTO || (n.Class_ == ir.PAUTOHEAP && n.Stackcopy == nil) {
+	if n.Class == ir.PAUTO || (n.Class == ir.PAUTOHEAP && n.Stackcopy == nil) {
 		v = n.Vargen
 	}
 
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 2dc7e70b65..15c57b2380 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -333,7 +333,7 @@ func (r *importReader) doDecl(sym *types.Sym) *ir.Name {
 
 			// methodSym already marked m.Sym as a function.
 			m := ir.NewNameAt(mpos, ir.MethodSym(recv.Type, msym))
-			m.Class_ = ir.PFUNC
+			m.Class = ir.PFUNC
 			m.SetType(mtyp)
 
 			m.Func = ir.NewFunc(mpos)
diff --git a/src/cmd/compile/internal/typecheck/syms.go b/src/cmd/compile/internal/typecheck/syms.go
index 01c03b5f9f..28db40db91 100644
--- a/src/cmd/compile/internal/typecheck/syms.go
+++ b/src/cmd/compile/internal/typecheck/syms.go
@@ -30,7 +30,7 @@ func SubstArgTypes(old *ir.Name, types_ ...*types.Type) *ir.Name {
 		types.CalcSize(t)
 	}
 	n := ir.NewNameAt(old.Pos(), old.Sym())
-	n.Class_ = old.Class()
+	n.Class = old.Class
 	n.SetType(types.SubstAny(old.Type(), &types_))
 	if len(types_) > 0 {
 		base.Fatalf("substArgTypes: too many argument types")
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 812b94de0d..981f4ef1d6 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -2099,7 +2099,7 @@ func CheckUnused(fn *ir.Func) {
 
 	// Propagate the used flag for typeswitch variables up to the NONAME in its definition.
 	for _, ln := range fn.Dcl {
-		if ln.Op() == ir.ONAME && ln.Class_ == ir.PAUTO && ln.Used() {
+		if ln.Op() == ir.ONAME && ln.Class == ir.PAUTO && ln.Used() {
 			if guard, ok := ln.Defn.(*ir.TypeSwitchGuard); ok {
 				guard.Used = true
 			}
@@ -2107,7 +2107,7 @@ func CheckUnused(fn *ir.Func) {
 	}
 
 	for _, ln := range fn.Dcl {
-		if ln.Op() != ir.ONAME || ln.Class_ != ir.PAUTO || ln.Used() {
+		if ln.Op() != ir.ONAME || ln.Class != ir.PAUTO || ln.Used() {
 			continue
 		}
 		if defn, ok := ln.Defn.(*ir.TypeSwitchGuard); ok {
diff --git a/src/cmd/compile/internal/typecheck/universe.go b/src/cmd/compile/internal/typecheck/universe.go
index f1e7ed4273..402b8deeb3 100644
--- a/src/cmd/compile/internal/typecheck/universe.go
+++ b/src/cmd/compile/internal/typecheck/universe.go
@@ -357,6 +357,6 @@ func DeclareUniverse() {
 
 	ir.RegFP = NewName(Lookup(".fp"))
 	ir.RegFP.SetType(types.Types[types.TINT32])
-	ir.RegFP.Class_ = ir.PPARAM
+	ir.RegFP.Class = ir.PPARAM
 	ir.RegFP.SetUsed(true)
 }
diff --git a/src/cmd/compile/internal/walk/assign.go b/src/cmd/compile/internal/walk/assign.go
index ec0f60ad93..3fe810ac4e 100644
--- a/src/cmd/compile/internal/walk/assign.go
+++ b/src/cmd/compile/internal/walk/assign.go
@@ -392,7 +392,7 @@ func ascompatee(op ir.Op, nl, nr []ir.Node) []ir.Node {
 
 		appendWalkStmt(&late, convas(ir.NewAssignStmt(base.Pos, lorig, r), &late))
 
-		if name == nil || name.Addrtaken() || name.Class_ == ir.PEXTERN || name.Class_ == ir.PAUTOHEAP {
+		if name == nil || name.Addrtaken() || name.Class == ir.PEXTERN || name.Class == ir.PAUTOHEAP {
 			memWrite = true
 			continue
 		}
@@ -418,7 +418,7 @@ func readsMemory(n ir.Node) bool {
 	switch n.Op() {
 	case ir.ONAME:
 		n := n.(*ir.Name)
-		return n.Class_ == ir.PEXTERN || n.Class_ == ir.PAUTOHEAP || n.Addrtaken()
+		return n.Class == ir.PEXTERN || n.Class == ir.PAUTOHEAP || n.Addrtaken()
 
 	case ir.OADD,
 		ir.OAND,
diff --git a/src/cmd/compile/internal/walk/closure.go b/src/cmd/compile/internal/walk/closure.go
index fcdb43f113..449df88f9e 100644
--- a/src/cmd/compile/internal/walk/closure.go
+++ b/src/cmd/compile/internal/walk/closure.go
@@ -52,7 +52,7 @@ func Closure(fn *ir.Func) {
 				v = addr
 			}
 
-			v.Class_ = ir.PPARAM
+			v.Class = ir.PPARAM
 			decls = append(decls, v)
 
 			fld := types.NewField(src.NoXPos, v.Sym(), v.Type())
@@ -84,7 +84,7 @@ func Closure(fn *ir.Func) {
 
 			if v.Byval() && v.Type().Width <= int64(2*types.PtrSize) {
 				// If it is a small variable captured by value, downgrade it to PAUTO.
-				v.Class_ = ir.PAUTO
+				v.Class = ir.PAUTO
 				fn.Dcl = append(fn.Dcl, v)
 				body = append(body, ir.NewAssignStmt(base.Pos, v, cr))
 			} else {
@@ -92,7 +92,7 @@ func Closure(fn *ir.Func) {
 				// and initialize in entry prologue.
 				addr := typecheck.NewName(typecheck.Lookup("&" + v.Sym().Name))
 				addr.SetType(types.NewPtr(v.Type()))
-				addr.Class_ = ir.PAUTO
+				addr.Class = ir.PAUTO
 				addr.SetUsed(true)
 				addr.Curfn = fn
 				fn.Dcl = append(fn.Dcl, addr)
diff --git a/src/cmd/compile/internal/walk/complit.go b/src/cmd/compile/internal/walk/complit.go
index d8605d39bd..8a77bba2ad 100644
--- a/src/cmd/compile/internal/walk/complit.go
+++ b/src/cmd/compile/internal/walk/complit.go
@@ -68,7 +68,7 @@ func isSimpleName(nn ir.Node) bool {
 		return false
 	}
 	n := nn.(*ir.Name)
-	return n.Class_ != ir.PAUTOHEAP && n.Class_ != ir.PEXTERN
+	return n.Class != ir.PAUTOHEAP && n.Class != ir.PEXTERN
 }
 
 func litas(l ir.Node, r ir.Node, init *ir.Nodes) {
@@ -294,7 +294,7 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 		// copy static to slice
 		var_ = typecheck.AssignExpr(var_)
 		name, offset, ok := staticinit.StaticLoc(var_)
-		if !ok || name.Class_ != ir.PEXTERN {
+		if !ok || name.Class != ir.PEXTERN {
 			base.Fatalf("slicelit: %v", var_)
 		}
 		staticdata.InitSlice(name, offset, vstat, t.NumElem())
@@ -657,7 +657,7 @@ func genAsStatic(as *ir.AssignStmt) {
 	}
 
 	name, offset, ok := staticinit.StaticLoc(as.X)
-	if !ok || (name.Class_ != ir.PEXTERN && as.X != ir.BlankNode) {
+	if !ok || (name.Class != ir.PEXTERN && as.X != ir.BlankNode) {
 		base.Fatalf("genAsStatic: lhs %v", as.X)
 	}
 
@@ -674,7 +674,7 @@ func genAsStatic(as *ir.AssignStmt) {
 		if r.Offset_ != 0 {
 			base.Fatalf("genAsStatic %+v", as)
 		}
-		if r.Class_ == ir.PFUNC {
+		if r.Class == ir.PFUNC {
 			staticdata.InitFunc(name, offset, r)
 			return
 		}
diff --git a/src/cmd/compile/internal/walk/convert.go b/src/cmd/compile/internal/walk/convert.go
index d0cd5ff753..85459fd92f 100644
--- a/src/cmd/compile/internal/walk/convert.go
+++ b/src/cmd/compile/internal/walk/convert.go
@@ -68,12 +68,12 @@ func walkConvInterface(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 
 	if ir.Names.Staticuint64s == nil {
 		ir.Names.Staticuint64s = typecheck.NewName(ir.Pkgs.Runtime.Lookup("staticuint64s"))
-		ir.Names.Staticuint64s.Class_ = ir.PEXTERN
+		ir.Names.Staticuint64s.Class = ir.PEXTERN
 		// The actual type is [256]uint64, but we use [256*8]uint8 so we can address
 		// individual bytes.
 		ir.Names.Staticuint64s.SetType(types.NewArray(types.Types[types.TUINT8], 256*8))
 		ir.Names.Zerobase = typecheck.NewName(ir.Pkgs.Runtime.Lookup("zerobase"))
-		ir.Names.Zerobase.Class_ = ir.PEXTERN
+		ir.Names.Zerobase.Class = ir.PEXTERN
 		ir.Names.Zerobase.SetType(types.Types[types.TUINTPTR])
 	}
 
@@ -98,7 +98,7 @@ func walkConvInterface(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 		xe := ir.NewIndexExpr(base.Pos, ir.Names.Staticuint64s, index)
 		xe.SetBounded(true)
 		value = xe
-	case n.X.Op() == ir.ONAME && n.X.(*ir.Name).Class_ == ir.PEXTERN && n.X.(*ir.Name).Readonly():
+	case n.X.Op() == ir.ONAME && n.X.(*ir.Name).Class == ir.PEXTERN && n.X.(*ir.Name).Readonly():
 		// n.Left is a readonly global; use it directly.
 		value = n.X
 	case !fromType.IsInterface() && n.Esc() == ir.EscNone && fromType.Width <= 1024:
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 8a56526a36..3dffb496e9 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -52,7 +52,7 @@ func walkExpr(n ir.Node, init *ir.Nodes) ir.Node {
 		base.Fatalf("expression has untyped type: %+v", n)
 	}
 
-	if n.Op() == ir.ONAME && n.(*ir.Name).Class_ == ir.PAUTOHEAP {
+	if n.Op() == ir.ONAME && n.(*ir.Name).Class == ir.PAUTOHEAP {
 		n := n.(*ir.Name)
 		nn := ir.NewStarExpr(base.Pos, n.Heapaddr)
 		nn.X.MarkNonNil()
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index 2164685cd4..38a9bec6e3 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -235,7 +235,7 @@ func (o *orderState) safeExpr(n ir.Node) ir.Node {
 // because we emit explicit VARKILL instructions marking the end of those
 // temporaries' lifetimes.
 func isaddrokay(n ir.Node) bool {
-	return ir.IsAddressable(n) && (n.Op() != ir.ONAME || n.(*ir.Name).Class_ == ir.PEXTERN || ir.IsAutoTmp(n))
+	return ir.IsAddressable(n) && (n.Op() != ir.ONAME || n.(*ir.Name).Class == ir.PEXTERN || ir.IsAutoTmp(n))
 }
 
 // addrTemp ensures that n is okay to pass by address to runtime routines.
diff --git a/src/cmd/compile/internal/walk/race.go b/src/cmd/compile/internal/walk/race.go
index 20becf9be9..77cabe50c6 100644
--- a/src/cmd/compile/internal/walk/race.go
+++ b/src/cmd/compile/internal/walk/race.go
@@ -39,7 +39,7 @@ func instrument(fn *ir.Func) {
 			// race in the future.
 
 			nodpc := ir.NewNameAt(src.NoXPos, typecheck.Lookup(".fp"))
-			nodpc.Class_ = ir.PPARAM
+			nodpc.Class = ir.PPARAM
 			nodpc.SetUsed(true)
 			nodpc.SetType(types.Types[types.TUINTPTR])
 			nodpc.SetFrameOffset(int64(-types.PtrSize))
diff --git a/src/cmd/compile/internal/walk/stmt.go b/src/cmd/compile/internal/walk/stmt.go
index 460c0a7c10..1df491bd4e 100644
--- a/src/cmd/compile/internal/walk/stmt.go
+++ b/src/cmd/compile/internal/walk/stmt.go
@@ -176,7 +176,7 @@ func walkStmtList(s []ir.Node) {
 // walkDecl walks an ODCL node.
 func walkDecl(n *ir.Decl) ir.Node {
 	v := n.X
-	if v.Class_ == ir.PAUTOHEAP {
+	if v.Class == ir.PAUTOHEAP {
 		if base.Flag.CompilingRuntime {
 			base.Errorf("%v escapes to heap, not allowed in runtime", v)
 		}
diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index 57c2d43753..928b673752 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -61,7 +61,7 @@ func Walk(fn *ir.Func) {
 
 func paramoutheap(fn *ir.Func) bool {
 	for _, ln := range fn.Dcl {
-		switch ln.Class_ {
+		switch ln.Class {
 		case ir.PPARAMOUT:
 			if ir.IsParamStackCopy(ln) || ln.Addrtaken() {
 				return true
@@ -137,7 +137,7 @@ func paramstoheap(params *types.Type) []ir.Node {
 
 		if stackcopy := v.Name().Stackcopy; stackcopy != nil {
 			nn = append(nn, walkStmt(ir.NewDecl(base.Pos, ir.ODCL, v.(*ir.Name))))
-			if stackcopy.Class_ == ir.PPARAM {
+			if stackcopy.Class == ir.PPARAM {
 				nn = append(nn, walkStmt(typecheck.Stmt(ir.NewAssignStmt(base.Pos, v, stackcopy))))
 			}
 		}
@@ -185,7 +185,7 @@ func returnsfromheap(params *types.Type) []ir.Node {
 		if v == nil {
 			continue
 		}
-		if stackcopy := v.Name().Stackcopy; stackcopy != nil && stackcopy.Class_ == ir.PPARAMOUT {
+		if stackcopy := v.Name().Stackcopy; stackcopy != nil && stackcopy.Class == ir.PPARAMOUT {
 			nn = append(nn, walkStmt(typecheck.Stmt(ir.NewAssignStmt(base.Pos, stackcopy, v))))
 		}
 	}
-- 
GitLab


From c28ca67a961a0c1d149a249918a15ed74c61af27 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 4 Jan 2021 22:58:24 -0800
Subject: [PATCH 0424/2400] [dev.regabi] cmd/compile: fix ir.Dump for
 []*CaseClause, etc

Dump uses reflection to print IR nodes, and it only knew how to print
out the Nodes slice type itself. This CL adds support for printing any
slice whose element type implements Node, such as SwitchStmt and
SelectStmt's clause lists.

Change-Id: I2fd8defe11868b564d1d389ea3cd9b8abcefac62
Reviewed-on: https://go-review.googlesource.com/c/go/+/281537
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/ir/fmt.go | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 92ea160a28..a4e769f508 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -1237,10 +1237,25 @@ func dumpNode(w io.Writer, n Node, depth int) {
 				fmt.Fprintf(w, "%+v-%s", n.Op(), name)
 			}
 			dumpNodes(w, val, depth+1)
+		default:
+			if vf.Kind() == reflect.Slice && vf.Type().Elem().Implements(nodeType) {
+				if vf.Len() == 0 {
+					continue
+				}
+				if name != "" {
+					indent(w, depth)
+					fmt.Fprintf(w, "%+v-%s", n.Op(), name)
+				}
+				for i, n := 0, vf.Len(); i < n; i++ {
+					dumpNode(w, vf.Index(i).Interface().(Node), depth+1)
+				}
+			}
 		}
 	}
 }
 
+var nodeType = reflect.TypeOf((*Node)(nil)).Elem()
+
 func dumpNodes(w io.Writer, list Nodes, depth int) {
 	if len(list) == 0 {
 		fmt.Fprintf(w, " <nil>")
-- 
GitLab


From eb626409d152caabac418eccbe86b49d1fc6a6f5 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 4 Jan 2021 18:28:55 -0800
Subject: [PATCH 0425/2400] [dev.regabi] cmd/compile: simplify CaptureVars

CaptureVars is responsible for deciding whether free variables should
be captured by value or by reference, but currently it also makes up
for some of the short-comings of the frontend symbol resolution /
type-checking algorithms. These are really separate responsibilities,
so move the latter into type-checking where it fits better.

Passes toolstash -cmp.

Change-Id: Iffbd53e83846a9ca9dfb54b597450b8543252850
Reviewed-on: https://go-review.googlesource.com/c/go/+/281534
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/typecheck/func.go | 49 ++++++++++------------
 1 file changed, 21 insertions(+), 28 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index b3efb8f25a..e4c3088225 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -106,26 +106,7 @@ func PartialCallType(n *ir.SelectorExpr) *types.Type {
 // We use value capturing for values <= 128 bytes that are never reassigned
 // after capturing (effectively constant).
 func CaptureVars(fn *ir.Func) {
-	lno := base.Pos
-	base.Pos = fn.Pos()
-	cvars := fn.ClosureVars
-	out := cvars[:0]
-	for _, v := range cvars {
-		if v.Type() == nil {
-			// If v.Type is nil, it means v looked like it
-			// was going to be used in the closure, but
-			// isn't. This happens in struct literals like
-			// s{f: x} where we can't distinguish whether
-			// f is a field identifier or expression until
-			// resolving s.
-			continue
-		}
-		out = append(out, v)
-
-		// type check closed variables outside the closure,
-		// so that the outer frame also grabs them and knows they escape.
-		Expr(v.Outer)
-
+	for _, v := range fn.ClosureVars {
 		outermost := v.Defn.(*ir.Name)
 
 		// out parameters will be assigned to implicitly upon return.
@@ -136,20 +117,13 @@ func CaptureVars(fn *ir.Func) {
 		}
 
 		if base.Flag.LowerM > 1 {
-			var name *types.Sym
-			if v.Curfn != nil && v.Curfn.Nname != nil {
-				name = v.Curfn.Sym()
-			}
 			how := "ref"
 			if v.Byval() {
 				how = "value"
 			}
-			base.WarnfAt(v.Pos(), "%v capturing by %s: %v (addr=%v assign=%v width=%d)", name, how, v.Sym(), outermost.Addrtaken(), outermost.Assigned(), v.Type().Size())
+			base.WarnfAt(v.Pos(), "%v capturing by %s: %v (addr=%v assign=%v width=%d)", v.Curfn, how, v, outermost.Addrtaken(), outermost.Assigned(), v.Type().Size())
 		}
 	}
-
-	fn.ClosureVars = out
-	base.Pos = lno
 }
 
 // Lazy typechecking of imported bodies. For local functions, caninl will set ->typecheck
@@ -396,6 +370,25 @@ func tcClosure(clo *ir.ClosureExpr, top int) {
 		ir.CurFunc = oldfn
 	}
 
+	out := 0
+	for _, v := range fn.ClosureVars {
+		if v.Type() == nil {
+			// If v.Type is nil, it means v looked like it was going to be
+			// used in the closure, but isn't. This happens in struct
+			// literals like s{f: x} where we can't distinguish whether f is
+			// a field identifier or expression until resolving s.
+			continue
+		}
+
+		// type check closed variables outside the closure, so that the
+		// outer frame also captures them.
+		Expr(v.Outer)
+
+		fn.ClosureVars[out] = v
+		out++
+	}
+	fn.ClosureVars = fn.ClosureVars[:out]
+
 	Target.Decls = append(Target.Decls, fn)
 }
 
-- 
GitLab


From 9aa950c40789223d9e8df7d1ec657cd313e6c7aa Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 5 Jan 2021 03:28:06 -0800
Subject: [PATCH 0426/2400] [dev.regabi] cmd/compile: make ir.OuterValue safer

For OINDEX expressions, ir.OuterValue depends on knowing the indexee's
type. Rather than silently acting as though it's not an array, make it
loudly fail.

The only code that needs to be fixed to support this is checkassign
during typechecking, which needs to avoid calling ir.OuterValue now if
typechecking the assigned operand already failed.

Passes toolstash -cmp.

Change-Id: I935cae0dacc837202bc6b63164dc2f0a6fde005c
Reviewed-on: https://go-review.googlesource.com/c/go/+/281539
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/ir/node.go             |  5 ++++-
 src/cmd/compile/internal/typecheck/typecheck.go | 13 ++++++++-----
 2 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index a5a7203faa..850d7343aa 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -568,7 +568,10 @@ func OuterValue(n Node) Node {
 			continue
 		case OINDEX:
 			nn := nn.(*IndexExpr)
-			if nn.X.Type() != nil && nn.X.Type().IsArray() {
+			if nn.X.Type() == nil {
+				base.Fatalf("OuterValue needs type for %v", nn.X)
+			}
+			if nn.X.Type().IsArray() {
 				n = nn.X
 				continue
 			}
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 981f4ef1d6..c3a5a3c40f 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -1612,6 +1612,14 @@ func checklvalue(n ir.Node, verb string) {
 }
 
 func checkassign(stmt ir.Node, n ir.Node) {
+	// have already complained about n being invalid
+	if n.Type() == nil {
+		if base.Errors() == 0 {
+			base.Fatalf("expected an error about %v", n)
+		}
+		return
+	}
+
 	// Variables declared in ORANGE are assigned on every iteration.
 	if !ir.DeclaredBy(n, stmt) || stmt.Op() == ir.ORANGE {
 		r := ir.OuterValue(n)
@@ -1633,11 +1641,6 @@ func checkassign(stmt ir.Node, n ir.Node) {
 		return
 	}
 
-	// have already complained about n being invalid
-	if n.Type() == nil {
-		return
-	}
-
 	switch {
 	case n.Op() == ir.ODOT && n.(*ir.SelectorExpr).X.Op() == ir.OINDEXMAP:
 		base.Errorf("cannot assign to struct field %v in map", n)
-- 
GitLab


From e09783cbc0a7142719c6210b4eda7b21daad91d5 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 5 Jan 2021 03:27:46 -0800
Subject: [PATCH 0427/2400] [dev.regabi] cmd/compile: make ir.StaticValue safer

ir.StaticValue currently relies on CaptureVars setting Addrtaken for
variables that are assigned within nested function literals. We want
to move that logic to escape analysis, but ir.StaticValue is used in
inlining and devirtualization, which happen before escape
analysis.

The long-term solution here is to generalize escape analysis's precise
reassignment tracking for use by other optimization passes, but for
now we just generalize ir.StaticValue to not depend on Addrtaken
anymore. Instead, it now also pays attention to OADDR nodes as well as
recurses into OCLOSURE bodies.

Passes toolstash -cmp.

Change-Id: I6114e3277fb70b235f4423d2983d0433c881f79f
Reviewed-on: https://go-review.googlesource.com/c/go/+/281540
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/ir/expr.go | 38 +++++++++++++++++++++++++----
 1 file changed, 33 insertions(+), 5 deletions(-)

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 6d81bf8781..77b6c8a103 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -771,7 +771,7 @@ func staticValue1(nn Node) Node {
 		return nil
 	}
 	n := nn.(*Name)
-	if n.Class != PAUTO || n.Addrtaken() {
+	if n.Class != PAUTO {
 		return nil
 	}
 
@@ -823,23 +823,51 @@ func reassigned(name *Name) bool {
 	if name.Curfn == nil {
 		return true
 	}
-	return Any(name.Curfn, func(n Node) bool {
+
+	// TODO(mdempsky): This is inefficient and becoming increasingly
+	// unwieldy. Figure out a way to generalize escape analysis's
+	// reassignment detection for use by inlining and devirtualization.
+
+	// isName reports whether n is a reference to name.
+	isName := func(n Node) bool {
+		if n, ok := n.(*Name); ok && n.Op() == ONAME {
+			if n.IsClosureVar() && n.Defn != nil {
+				n = n.Defn.(*Name)
+			}
+			return n == name
+		}
+		return false
+	}
+
+	var do func(n Node) bool
+	do = func(n Node) bool {
 		switch n.Op() {
 		case OAS:
 			n := n.(*AssignStmt)
-			if n.X == name && n != name.Defn {
+			if isName(n.X) && n != name.Defn {
 				return true
 			}
 		case OAS2, OAS2FUNC, OAS2MAPR, OAS2DOTTYPE, OAS2RECV, OSELRECV2:
 			n := n.(*AssignListStmt)
 			for _, p := range n.Lhs {
-				if p == name && n != name.Defn {
+				if isName(p) && n != name.Defn {
 					return true
 				}
 			}
+		case OADDR:
+			n := n.(*AddrExpr)
+			if isName(OuterValue(n.X)) {
+				return true
+			}
+		case OCLOSURE:
+			n := n.(*ClosureExpr)
+			if Any(n.Func, do) {
+				return true
+			}
 		}
 		return false
-	})
+	}
+	return Any(name.Curfn, do)
 }
 
 // IsIntrinsicCall reports whether the compiler back end will treat the call as an intrinsic operation.
-- 
GitLab


From 77365c5ed739f4882020ff76b2a4f5bfe4e8fc9d Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 5 Jan 2021 06:43:38 -0800
Subject: [PATCH 0428/2400] [dev.regabi] cmd/compile: add Name.Canonical and
 move Byval

There's a bunch of code that wants to map closure variables back to
their original name, so add a single Name.Canonical method that they
can all use.

Also, move the Byval flag from being stored on individual closure
variables to being stored on the canonical variable.

Passes toolstash -cmp.

Change-Id: Ia3ef81af5a15783d09f04b4e274ce33df94518e6
Reviewed-on: https://go-review.googlesource.com/c/go/+/281541
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/dwarfgen/dwarf.go |  5 +---
 src/cmd/compile/internal/escape/escape.go  | 20 +++------------
 src/cmd/compile/internal/ir/expr.go        | 11 +++-----
 src/cmd/compile/internal/ir/name.go        | 29 ++++++++++++++++++++--
 src/cmd/compile/internal/typecheck/func.go |  4 +--
 5 files changed, 37 insertions(+), 32 deletions(-)

diff --git a/src/cmd/compile/internal/dwarfgen/dwarf.go b/src/cmd/compile/internal/dwarfgen/dwarf.go
index 1534adaac8..ff249c1f4e 100644
--- a/src/cmd/compile/internal/dwarfgen/dwarf.go
+++ b/src/cmd/compile/internal/dwarfgen/dwarf.go
@@ -127,10 +127,7 @@ func Info(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.Scope,
 }
 
 func declPos(decl *ir.Name) src.XPos {
-	if decl.IsClosureVar() {
-		decl = decl.Defn.(*ir.Name)
-	}
-	return decl.Pos()
+	return decl.Canonical().Pos()
 }
 
 // createDwarfVars process fn, returning a list of DWARF variables and the
diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index 6a2e685fe8..794c52f5ae 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -1146,19 +1146,6 @@ func (e *escape) later(k hole) hole {
 	return loc.asHole()
 }
 
-// canonicalNode returns the canonical *Node that n logically
-// represents.
-func canonicalNode(n ir.Node) ir.Node {
-	if n != nil && n.Op() == ir.ONAME && n.Name().IsClosureVar() {
-		n = n.Name().Defn
-		if n.Name().IsClosureVar() {
-			base.Fatalf("still closure var")
-		}
-	}
-
-	return n
-}
-
 func (e *escape) newLoc(n ir.Node, transient bool) *location {
 	if e.curfn == nil {
 		base.Fatalf("e.curfn isn't set")
@@ -1167,7 +1154,9 @@ func (e *escape) newLoc(n ir.Node, transient bool) *location {
 		base.ErrorfAt(n.Pos(), "%v is incomplete (or unallocatable); stack allocation disallowed", n.Type())
 	}
 
-	n = canonicalNode(n)
+	if n != nil && n.Op() == ir.ONAME {
+		n = n.(*ir.Name).Canonical()
+	}
 	loc := &location{
 		n:         n,
 		curfn:     e.curfn,
@@ -1196,8 +1185,7 @@ func (e *escape) newLoc(n ir.Node, transient bool) *location {
 }
 
 func (b *batch) oldLoc(n *ir.Name) *location {
-	n = canonicalNode(n).(*ir.Name)
-	return n.Opt.(*location)
+	return n.Canonical().Opt.(*location)
 }
 
 func (l *location) asHole() hole {
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 77b6c8a103..e7aa9c6a8f 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -829,14 +829,9 @@ func reassigned(name *Name) bool {
 	// reassignment detection for use by inlining and devirtualization.
 
 	// isName reports whether n is a reference to name.
-	isName := func(n Node) bool {
-		if n, ok := n.(*Name); ok && n.Op() == ONAME {
-			if n.IsClosureVar() && n.Defn != nil {
-				n = n.Defn.(*Name)
-			}
-			return n == name
-		}
-		return false
+	isName := func(x Node) bool {
+		n, ok := x.(*Name)
+		return ok && n.Canonical() == name
 	}
 
 	var do func(n Node) bool
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 58b4ababff..9d7d376ba5 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -279,7 +279,6 @@ const (
 
 func (n *Name) Captured() bool              { return n.flags&nameCaptured != 0 }
 func (n *Name) Readonly() bool              { return n.flags&nameReadonly != 0 }
-func (n *Name) Byval() bool                 { return n.flags&nameByval != 0 }
 func (n *Name) Needzero() bool              { return n.flags&nameNeedzero != 0 }
 func (n *Name) AutoTemp() bool              { return n.flags&nameAutoTemp != 0 }
 func (n *Name) Used() bool                  { return n.flags&nameUsed != 0 }
@@ -294,7 +293,6 @@ func (n *Name) LibfuzzerExtraCounter() bool { return n.flags&nameLibfuzzerExtraC
 
 func (n *Name) SetCaptured(b bool)              { n.flags.set(nameCaptured, b) }
 func (n *Name) setReadonly(b bool)              { n.flags.set(nameReadonly, b) }
-func (n *Name) SetByval(b bool)                 { n.flags.set(nameByval, b) }
 func (n *Name) SetNeedzero(b bool)              { n.flags.set(nameNeedzero, b) }
 func (n *Name) SetAutoTemp(b bool)              { n.flags.set(nameAutoTemp, b) }
 func (n *Name) SetUsed(b bool)                  { n.flags.set(nameUsed, b) }
@@ -336,6 +334,33 @@ func (n *Name) SetVal(v constant.Value) {
 	n.val = v
 }
 
+// Canonical returns the logical declaration that n represents. If n
+// is a closure variable, then Canonical returns the original Name as
+// it appears in the function that immediately contains the
+// declaration. Otherwise, Canonical simply returns n itself.
+func (n *Name) Canonical() *Name {
+	if n.IsClosureVar() {
+		n = n.Defn.(*Name)
+		if n.IsClosureVar() {
+			base.Fatalf("recursive closure variable: %v", n)
+		}
+	}
+	return n
+}
+
+func (n *Name) SetByval(b bool) {
+	if n.Canonical() != n {
+		base.Fatalf("SetByval called on non-canonical variable: %v", n)
+	}
+	n.flags.set(nameByval, b)
+}
+
+func (n *Name) Byval() bool {
+	// We require byval to be set on the canonical variable, but we
+	// allow it to be accessed from any instance.
+	return n.Canonical().flags&nameByval != 0
+}
+
 // SameSource reports whether two nodes refer to the same source
 // element.
 //
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index e4c3088225..8fdb33b145 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -110,8 +110,8 @@ func CaptureVars(fn *ir.Func) {
 		outermost := v.Defn.(*ir.Name)
 
 		// out parameters will be assigned to implicitly upon return.
-		if outermost.Class != ir.PPARAMOUT && !outermost.Addrtaken() && !outermost.Assigned() && v.Type().Size() <= 128 {
-			v.SetByval(true)
+		if outermost.Class != ir.PPARAMOUT && !outermost.Addrtaken() && !outermost.Assigned() && outermost.Type().Size() <= 128 {
+			outermost.SetByval(true)
 		} else {
 			outermost.SetAddrtaken(true)
 		}
-- 
GitLab


From 4a9d9adea4d071927de01e5aa07b215cf1464be9 Mon Sep 17 00:00:00 2001
From: Baokun Lee <bk@golangcn.org>
Date: Tue, 5 Jan 2021 15:04:34 +0800
Subject: [PATCH 0429/2400] [dev.regabi] cmd/compile: remove initname function

Passes toolstash -cmp.

Change-Id: I84b99d6e636c7b867780389ad11dafc70d3628cd
Reviewed-on: https://go-review.googlesource.com/c/go/+/281313
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/typecheck/dcl.go | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/dcl.go b/src/cmd/compile/internal/typecheck/dcl.go
index 6c3aa3781e..ffbf474a58 100644
--- a/src/cmd/compile/internal/typecheck/dcl.go
+++ b/src/cmd/compile/internal/typecheck/dcl.go
@@ -266,7 +266,7 @@ func autoexport(n *ir.Name, ctxt ir.Class) {
 		return
 	}
 
-	if types.IsExported(n.Sym().Name) || initname(n.Sym().Name) {
+	if types.IsExported(n.Sym().Name) || n.Sym().Name == "init" {
 		Export(n)
 	}
 	if base.Flag.AsmHdr != "" && !n.Sym().Asm() {
@@ -422,10 +422,6 @@ func funcargs2(t *types.Type) {
 	}
 }
 
-func initname(s string) bool {
-	return s == "init"
-}
-
 var vargen int
 
 func Temp(t *types.Type) *ir.Name {
-- 
GitLab


From 81f4f0e912775d11df35220ea598e54c272073fd Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 5 Jan 2021 11:53:00 -0800
Subject: [PATCH 0430/2400] [dev.regabi] cmd/compile: remove race-y check in
 Name.Canonical

The backend doesn't synchronize compilation of functions with their
enclosed function literals, so it's not safe to double-check that
IsClosureVar isn't set on the underlying Name. Plenty of frontend
stuff would blow-up if this was wrong anyway, so it should be fine to
omit.

Change-Id: I3e97b64051fe56d97bf316c9b5dcce61f2082428
Reviewed-on: https://go-review.googlesource.com/c/go/+/281812
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ir/name.go | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 9d7d376ba5..3999c0ecb4 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -341,9 +341,6 @@ func (n *Name) SetVal(v constant.Value) {
 func (n *Name) Canonical() *Name {
 	if n.IsClosureVar() {
 		n = n.Defn.(*Name)
-		if n.IsClosureVar() {
-			base.Fatalf("recursive closure variable: %v", n)
-		}
 	}
 	return n
 }
-- 
GitLab


From fb69c67cad4d554dab8281786b7e1e2707fc3346 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 5 Jan 2021 08:37:41 -0800
Subject: [PATCH 0431/2400] [dev.regabi] test: enable finalizer tests on !amd64

The gc implementation has had precise GC for a while now, so we can
enable these tests more broadly.

Confirmed that they still fail with gccgo 10.2.1.

Change-Id: Ic1c0394ab832024a99e34163c422941a3706e1a2
Reviewed-on: https://go-review.googlesource.com/c/go/+/281542
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 test/deferfin.go            | 7 +------
 test/fixedbugs/issue5493.go | 7 +++----
 2 files changed, 4 insertions(+), 10 deletions(-)

diff --git a/test/deferfin.go b/test/deferfin.go
index 80372916d2..1312bbbe71 100644
--- a/test/deferfin.go
+++ b/test/deferfin.go
@@ -18,12 +18,8 @@ import (
 var sink func()
 
 func main() {
-	// Does not work on 32-bits due to partially conservative GC.
+	// Does not work with gccgo, due to partially conservative GC.
 	// Try to enable when we have fully precise GC.
-	if runtime.GOARCH != "amd64" {
-		return
-	}
-	// Likewise for gccgo.
 	if runtime.Compiler == "gccgo" {
 		return
 	}
@@ -60,4 +56,3 @@ func main() {
 		panic("not all finalizers are called")
 	}
 }
-
diff --git a/test/fixedbugs/issue5493.go b/test/fixedbugs/issue5493.go
index 2ee0398af2..8f771bc2db 100644
--- a/test/fixedbugs/issue5493.go
+++ b/test/fixedbugs/issue5493.go
@@ -14,6 +14,7 @@ import (
 )
 
 const N = 10
+
 var count int64
 
 func run() error {
@@ -31,10 +32,9 @@ func run() error {
 }
 
 func main() {
-	// Does not work on 32-bits, or with gccgo, due to partially
-	// conservative GC.
+	// Does not work with gccgo, due to partially conservative GC.
 	// Try to enable when we have fully precise GC.
-	if runtime.GOARCH != "amd64" || runtime.Compiler == "gccgo" {
+	if runtime.Compiler == "gccgo" {
 		return
 	}
 	count = N
@@ -56,4 +56,3 @@ func main() {
 		panic("not all finalizers are called")
 	}
 }
-
-- 
GitLab


From fd43831f4476dc9a3ba83aa3a2e4117ed0b8596e Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 4 Jan 2021 18:05:34 -0800
Subject: [PATCH 0432/2400] [dev.regabi] cmd/compile: reimplement capture
 analysis

Currently we rely on the type-checker to do some basic data-flow
analysis to help decide whether function literals should capture
variables by value or reference. However, this analysis isn't done by
go/types, and escape analysis already has a better framework for doing
this more precisely.

This CL extends escape analysis to recalculate the same "byval" as
CaptureVars and check that it matches. A future CL will remove
CaptureVars in favor of escape analysis's calculation.

Notably, escape analysis happens after deadcode removes obviously
unreachable code, so it sees the AST without any unreachable
assignments. (Also without unreachable addrtakens, but
ComputeAddrtaken already happens after deadcode too.) There are two
test cases where a variable is only reassigned on certain CPUs. This
CL changes them to reassign the variables unconditionally (as no-op
reassignments that avoid triggering cmd/vet's self-assignment check),
at least until we remove CaptureVars.

Passes toolstash -cmp.

Change-Id: I7162619739fedaf861b478fb8d506f96a6ac21f3
Reviewed-on: https://go-review.googlesource.com/c/go/+/281535
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/escape/escape.go     | 250 ++++++++++++++----
 .../compile/internal/logopt/logopt_test.go    |   1 +
 test/chancap.go                               |   1 +
 test/fixedbugs/issue4085b.go                  |   1 +
 4 files changed, 202 insertions(+), 51 deletions(-)

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index 794c52f5ae..4aa7381c20 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -88,12 +88,20 @@ import (
 // A batch holds escape analysis state that's shared across an entire
 // batch of functions being analyzed at once.
 type batch struct {
-	allLocs []*location
+	allLocs  []*location
+	closures []closure
 
 	heapLoc  location
 	blankLoc location
 }
 
+// A closure holds a closure expression and its spill hole (i.e.,
+// where the hole representing storing into its closure record).
+type closure struct {
+	k   hole
+	clo *ir.ClosureExpr
+}
+
 // An escape holds state specific to a single function being analyzed
 // within a batch.
 type escape struct {
@@ -108,6 +116,12 @@ type escape struct {
 	// label with a corresponding backwards "goto" (i.e.,
 	// unstructured loop).
 	loopDepth int
+
+	// loopSlop tracks how far off typecheck's "decldepth" variable
+	// would be from loopDepth at the same point during type checking.
+	// It's only needed to match CaptureVars's pessimism until it can be
+	// removed entirely.
+	loopSlop int
 }
 
 // An location represents an abstract location that stores a Go
@@ -117,6 +131,7 @@ type location struct {
 	curfn     *ir.Func // enclosing function
 	edges     []edge   // incoming edges
 	loopDepth int      // loopDepth at declaration
+	loopSlop  int      // loopSlop at declaration
 
 	// derefs and walkgen are used during walkOne to track the
 	// minimal dereferences from the walk root.
@@ -145,6 +160,10 @@ type location struct {
 
 	// paramEsc records the represented parameter's leak set.
 	paramEsc leaks
+
+	captured   bool // has a closure captured this variable?
+	reassigned bool // has this variable been reassigned?
+	addrtaken  bool // has this variable's address been taken?
 }
 
 // An edge represents an assignment edge between two Go variables.
@@ -209,10 +228,69 @@ func Batch(fns []*ir.Func, recursive bool) {
 		}
 	}
 
+	// We've walked the function bodies, so we've seen everywhere a
+	// variable might be reassigned or have it's address taken. Now we
+	// can decide whether closures should capture their free variables
+	// by value or reference.
+	for _, closure := range b.closures {
+		b.flowClosure(closure.k, closure.clo, false)
+	}
+	b.closures = nil
+
+	for _, orphan := range findOrphans(fns) {
+		b.flowClosure(b.blankLoc.asHole(), orphan, true)
+	}
+
+	for _, loc := range b.allLocs {
+		if why := HeapAllocReason(loc.n); why != "" {
+			b.flow(b.heapHole().addr(loc.n, why), loc)
+		}
+	}
+
 	b.walkAll()
 	b.finish(fns)
 }
 
+// findOrphans finds orphaned closure expressions that were originally
+// contained within a function in fns, but were lost due to earlier
+// optimizations.
+// TODO(mdempsky): Remove after CaptureVars is gone.
+func findOrphans(fns []*ir.Func) []*ir.ClosureExpr {
+	have := make(map[*ir.Func]bool)
+	for _, fn := range fns {
+		have[fn] = true
+	}
+
+	parent := func(fn *ir.Func) *ir.Func {
+		if len(fn.ClosureVars) == 0 {
+			return nil
+		}
+		cv := fn.ClosureVars[0]
+		if cv.Defn == nil {
+			return nil // method value wrapper
+		}
+		return cv.Outer.Curfn
+	}
+
+	outermost := func(fn *ir.Func) *ir.Func {
+		for {
+			outer := parent(fn)
+			if outer == nil {
+				return fn
+			}
+			fn = outer
+		}
+	}
+
+	var orphans []*ir.ClosureExpr
+	for _, fn := range typecheck.Target.Decls {
+		if fn, ok := fn.(*ir.Func); ok && have[outermost(fn)] && !have[fn] {
+			orphans = append(orphans, fn.OClosure)
+		}
+	}
+	return orphans
+}
+
 func (b *batch) with(fn *ir.Func) *escape {
 	return &escape{
 		batch:     b,
@@ -270,6 +348,33 @@ func (b *batch) walkFunc(fn *ir.Func) {
 	}
 }
 
+func (b *batch) flowClosure(k hole, clo *ir.ClosureExpr, orphan bool) {
+	for _, cv := range clo.Func.ClosureVars {
+		n := cv.Canonical()
+		if n.Opt == nil && orphan {
+			continue // n.Curfn must have been an orphan too
+		}
+
+		loc := b.oldLoc(cv)
+		if !loc.captured && !orphan {
+			base.FatalfAt(cv.Pos(), "closure variable never captured: %v", cv)
+		}
+
+		// Capture by value for variables <= 128 bytes that are never reassigned.
+		byval := !loc.addrtaken && !loc.reassigned && n.Type().Size() <= 128
+		if byval != n.Byval() {
+			base.FatalfAt(cv.Pos(), "byval mismatch: %v: %v != %v", cv, byval, n.Byval())
+		}
+
+		// Flow captured variables to closure.
+		k := k
+		if !cv.Byval() {
+			k = k.addr(cv, "reference")
+		}
+		b.flow(k.note(cv, "captured by a closure"), loc)
+	}
+}
+
 // Below we implement the methods for walking the AST and recording
 // data flow edges. Note that because a sub-expression might have
 // side-effects, it's important to always visit the entire AST.
@@ -308,7 +413,7 @@ func (e *escape) stmt(n ir.Node) {
 	}()
 
 	if base.Flag.LowerM > 2 {
-		fmt.Printf("%v:[%d] %v stmt: %v\n", base.FmtPos(base.Pos), e.loopDepth, funcSym(e.curfn), n)
+		fmt.Printf("%v:[%d] %v stmt: %v\n", base.FmtPos(base.Pos), e.loopDepth, e.curfn, n)
 	}
 
 	e.stmts(n.Init())
@@ -341,6 +446,9 @@ func (e *escape) stmt(n ir.Node) {
 			if base.Flag.LowerM > 2 {
 				fmt.Printf("%v:%v non-looping label\n", base.FmtPos(base.Pos), n)
 			}
+			if s := n.Label.Name; !strings.HasPrefix(s, ".") && !strings.Contains(s, "·") {
+				e.loopSlop++
+			}
 		case looping:
 			if base.Flag.LowerM > 2 {
 				fmt.Printf("%v: %v looping label\n", base.FmtPos(base.Pos), n)
@@ -380,6 +488,7 @@ func (e *escape) stmt(n ir.Node) {
 		} else {
 			e.flow(ks[1].deref(n, "range-deref"), tmp)
 		}
+		e.reassigned(ks, n)
 
 		e.block(n.Body)
 		e.loopDepth--
@@ -447,7 +556,9 @@ func (e *escape) stmt(n ir.Node) {
 	case ir.OAS2FUNC:
 		n := n.(*ir.AssignListStmt)
 		e.stmts(n.Rhs[0].Init())
-		e.call(e.addrs(n.Lhs), n.Rhs[0], nil)
+		ks := e.addrs(n.Lhs)
+		e.call(ks, n.Rhs[0], nil)
+		e.reassigned(ks, n)
 	case ir.ORETURN:
 		n := n.(*ir.ReturnStmt)
 		results := e.curfn.Type().Results().FieldSlice()
@@ -478,6 +589,7 @@ func (e *escape) stmts(l ir.Nodes) {
 func (e *escape) block(l ir.Nodes) {
 	old := e.loopDepth
 	e.stmts(l)
+	e.loopSlop += e.loopDepth - old
 	e.loopDepth = old
 }
 
@@ -507,7 +619,7 @@ func (e *escape) exprSkipInit(k hole, n ir.Node) {
 	if uintptrEscapesHack && n.Op() == ir.OCONVNOP && n.(*ir.ConvExpr).X.Type().IsUnsafePtr() {
 		// nop
 	} else if k.derefs >= 0 && !n.Type().HasPointers() {
-		k = e.discardHole()
+		k.dst = &e.blankLoc
 	}
 
 	switch n.Op() {
@@ -691,20 +803,23 @@ func (e *escape) exprSkipInit(k hole, n ir.Node) {
 
 	case ir.OCLOSURE:
 		n := n.(*ir.ClosureExpr)
+		k = e.spill(k, n)
+		e.closures = append(e.closures, closure{k, n})
 
 		if fn := n.Func; fn.IsHiddenClosure() {
-			e.walkFunc(fn)
-		}
-
-		// Link addresses of captured variables to closure.
-		k = e.spill(k, n)
-		for _, v := range n.Func.ClosureVars {
-			k := k
-			if !v.Byval() {
-				k = k.addr(v, "reference")
+			for _, cv := range fn.ClosureVars {
+				if loc := e.oldLoc(cv); !loc.captured {
+					loc.captured = true
+
+					// Ignore reassignments to the variable in straightline code
+					// preceding the first capture by a closure.
+					if loc.loopDepth+loc.loopSlop == e.loopDepth+e.loopSlop {
+						loc.reassigned = false
+					}
+				}
 			}
 
-			e.expr(k.note(n, "captured by a closure"), v.Defn)
+			e.walkFunc(fn)
 		}
 
 	case ir.ORUNES2STR, ir.OBYTES2STR, ir.OSTR2RUNES, ir.OSTR2BYTES, ir.ORUNESTR:
@@ -728,6 +843,9 @@ func (e *escape) unsafeValue(k hole, n ir.Node) {
 	if n.Type().Kind() != types.TUINTPTR {
 		base.Fatalf("unexpected type %v for %v", n.Type(), n)
 	}
+	if k.addrtaken {
+		base.Fatalf("unexpected addrtaken")
+	}
 
 	e.stmts(n.Init())
 
@@ -828,33 +946,59 @@ func (e *escape) addrs(l ir.Nodes) []hole {
 	return ks
 }
 
+// reassigned marks the locations associated with the given holes as
+// reassigned, unless the location represents a variable declared and
+// assigned exactly once by where.
+func (e *escape) reassigned(ks []hole, where ir.Node) {
+	if as, ok := where.(*ir.AssignStmt); ok && as.Op() == ir.OAS && as.Y == nil {
+		if dst, ok := as.X.(*ir.Name); ok && dst.Op() == ir.ONAME && dst.Defn == nil {
+			// Zero-value assignment for variable declared without an
+			// explicit initial value. Assume this is its initialization
+			// statement.
+			return
+		}
+	}
+
+	for _, k := range ks {
+		loc := k.dst
+		// Variables declared by range statements are assigned on every iteration.
+		if n, ok := loc.n.(*ir.Name); ok && n.Defn == where && where.Op() != ir.ORANGE {
+			continue
+		}
+		loc.reassigned = true
+	}
+}
+
+// assignList evaluates the assignment dsts... = srcs....
 func (e *escape) assignList(dsts, srcs []ir.Node, why string, where ir.Node) {
-	for i, dst := range dsts {
+	ks := e.addrs(dsts)
+	for i, k := range ks {
 		var src ir.Node
 		if i < len(srcs) {
 			src = srcs[i]
 		}
-		e.assign(dst, src, why, where)
-	}
-}
 
-// assign evaluates the assignment dst = src.
-func (e *escape) assign(dst, src ir.Node, why string, where ir.Node) {
-	// Filter out some no-op assignments for escape analysis.
-	ignore := dst != nil && src != nil && isSelfAssign(dst, src)
-	if ignore && base.Flag.LowerM != 0 {
-		base.WarnfAt(where.Pos(), "%v ignoring self-assignment in %v", funcSym(e.curfn), where)
-	}
+		if dst := dsts[i]; dst != nil {
+			// Detect implicit conversion of uintptr to unsafe.Pointer when
+			// storing into reflect.{Slice,String}Header.
+			if dst.Op() == ir.ODOTPTR && ir.IsReflectHeaderDataField(dst) {
+				e.unsafeValue(e.heapHole().note(where, why), src)
+				continue
+			}
 
-	k := e.addr(dst)
-	if dst != nil && dst.Op() == ir.ODOTPTR && ir.IsReflectHeaderDataField(dst) {
-		e.unsafeValue(e.heapHole().note(where, why), src)
-	} else {
-		if ignore {
-			k = e.discardHole()
+			// Filter out some no-op assignments for escape analysis.
+			if src != nil && isSelfAssign(dst, src) {
+				if base.Flag.LowerM != 0 {
+					base.WarnfAt(where.Pos(), "%v ignoring self-assignment in %v", e.curfn, where)
+				}
+				k = e.discardHole()
+			}
 		}
+
 		e.expr(k.note(where, why), src)
 	}
+
+	e.reassigned(ks, where)
 }
 
 func (e *escape) assignHeap(src ir.Node, why string, where ir.Node) {
@@ -1034,7 +1178,7 @@ func (e *escape) tagHole(ks []hole, fn *ir.Name, param *types.Field) hole {
 func (e *escape) inMutualBatch(fn *ir.Name) bool {
 	if fn.Defn != nil && fn.Defn.Esc() < escFuncTagged {
 		if fn.Defn.Esc() == escFuncUnknown {
-			base.Fatalf("graph inconsistency")
+			base.Fatalf("graph inconsistency: %v", fn)
 		}
 		return true
 	}
@@ -1049,6 +1193,11 @@ type hole struct {
 	derefs int // >= -1
 	notes  *note
 
+	// addrtaken indicates whether this context is taking the address of
+	// the expression, independent of whether the address will actually
+	// be stored into a variable.
+	addrtaken bool
+
 	// uintptrEscapesHack indicates this context is evaluating an
 	// argument for a //go:uintptrescapes function.
 	uintptrEscapesHack bool
@@ -1079,6 +1228,7 @@ func (k hole) shift(delta int) hole {
 	if k.derefs < -1 {
 		base.Fatalf("derefs underflow: %v", k.derefs)
 	}
+	k.addrtaken = delta < 0
 	return k
 }
 
@@ -1123,8 +1273,12 @@ func (e *escape) teeHole(ks ...hole) hole {
 }
 
 func (e *escape) dcl(n *ir.Name) hole {
+	if n.Curfn != e.curfn || n.IsClosureVar() {
+		base.Fatalf("bad declaration of %v", n)
+	}
 	loc := e.oldLoc(n)
 	loc.loopDepth = e.loopDepth
+	loc.loopSlop = e.loopSlop
 	return loc.asHole()
 }
 
@@ -1161,6 +1315,7 @@ func (e *escape) newLoc(n ir.Node, transient bool) *location {
 		n:         n,
 		curfn:     e.curfn,
 		loopDepth: e.loopDepth,
+		loopSlop:  e.loopSlop,
 		transient: transient,
 	}
 	e.allLocs = append(e.allLocs, loc)
@@ -1176,10 +1331,6 @@ func (e *escape) newLoc(n ir.Node, transient bool) *location {
 			}
 			n.Opt = loc
 		}
-
-		if why := HeapAllocReason(n); why != "" {
-			e.flow(e.heapHole().addr(n, why), loc)
-		}
 	}
 	return loc
 }
@@ -1192,9 +1343,13 @@ func (l *location) asHole() hole {
 	return hole{dst: l}
 }
 
-func (e *escape) flow(k hole, src *location) {
+func (b *batch) flow(k hole, src *location) {
+	if k.addrtaken {
+		src.addrtaken = true
+	}
+
 	dst := k.dst
-	if dst == &e.blankLoc {
+	if dst == &b.blankLoc {
 		return
 	}
 	if dst == src && k.derefs >= 0 { // dst = dst, dst = *dst, ...
@@ -1206,9 +1361,10 @@ func (e *escape) flow(k hole, src *location) {
 			if base.Flag.LowerM >= 2 {
 				fmt.Printf("%s: %v escapes to heap:\n", pos, src.n)
 			}
-			explanation := e.explainFlow(pos, dst, src, k.derefs, k.notes, []*logopt.LoggedOpt{})
+			explanation := b.explainFlow(pos, dst, src, k.derefs, k.notes, []*logopt.LoggedOpt{})
 			if logopt.Enabled() {
-				logopt.LogOpt(src.n.Pos(), "escapes", "escape", ir.FuncName(e.curfn), fmt.Sprintf("%v escapes to heap", src.n), explanation)
+				var e_curfn *ir.Func // TODO(mdempsky): Fix.
+				logopt.LogOpt(src.n.Pos(), "escapes", "escape", ir.FuncName(e_curfn), fmt.Sprintf("%v escapes to heap", src.n), explanation)
 			}
 
 		}
@@ -1220,8 +1376,8 @@ func (e *escape) flow(k hole, src *location) {
 	dst.edges = append(dst.edges, edge{src: src, derefs: k.derefs, notes: k.notes})
 }
 
-func (e *escape) heapHole() hole    { return e.heapLoc.asHole() }
-func (e *escape) discardHole() hole { return e.blankLoc.asHole() }
+func (b *batch) heapHole() hole    { return b.heapLoc.asHole() }
+func (b *batch) discardHole() hole { return b.blankLoc.asHole() }
 
 // walkAll computes the minimal dereferences between all pairs of
 // locations.
@@ -1686,14 +1842,6 @@ const (
 	escFuncTagged
 )
 
-// funcSym returns fn.Nname.Sym if no nils are encountered along the way.
-func funcSym(fn *ir.Func) *types.Sym {
-	if fn == nil || fn.Nname == nil {
-		return nil
-	}
-	return fn.Sym()
-}
-
 // Mark labels that have no backjumps to them as not increasing e.loopdepth.
 type labelState int
 
@@ -1863,7 +2011,7 @@ func mayAffectMemory(n ir.Node) bool {
 // HeapAllocReason returns the reason the given Node must be heap
 // allocated, or the empty string if it doesn't.
 func HeapAllocReason(n ir.Node) string {
-	if n.Type() == nil {
+	if n == nil || n.Type() == nil {
 		return ""
 	}
 
diff --git a/src/cmd/compile/internal/logopt/logopt_test.go b/src/cmd/compile/internal/logopt/logopt_test.go
index 71976174b0..1d1e21b060 100644
--- a/src/cmd/compile/internal/logopt/logopt_test.go
+++ b/src/cmd/compile/internal/logopt/logopt_test.go
@@ -154,6 +154,7 @@ func s15a8(x *[15]int64) [15]int64 {
 		// On not-amd64, test the host architecture and os
 		arches := []string{runtime.GOARCH}
 		goos0 := runtime.GOOS
+		goos0 = "" + goos0             // TODO(mdempsky): Remove once CaptureVars is gone.
 		if runtime.GOARCH == "amd64" { // Test many things with "linux" (wasm will get "js")
 			arches = []string{"arm", "arm64", "386", "amd64", "mips", "mips64", "ppc64le", "riscv64", "s390x", "wasm"}
 			goos0 = "linux"
diff --git a/test/chancap.go b/test/chancap.go
index 8dce9247cd..3a4f67638a 100644
--- a/test/chancap.go
+++ b/test/chancap.go
@@ -41,6 +41,7 @@ func main() {
 	n := -1
 	shouldPanic("makechan: size out of range", func() { _ = make(T, n) })
 	shouldPanic("makechan: size out of range", func() { _ = make(T, int64(n)) })
+	n = 0 + n // TODO(mdempsky): Remove once CaptureVars is gone.
 	if ptrSize == 8 {
 		// Test mem > maxAlloc
 		var n2 int64 = 1 << 59
diff --git a/test/fixedbugs/issue4085b.go b/test/fixedbugs/issue4085b.go
index cf27512da0..b69e10c6cc 100644
--- a/test/fixedbugs/issue4085b.go
+++ b/test/fixedbugs/issue4085b.go
@@ -22,6 +22,7 @@ func main() {
 	testMakeInAppend(n)
 
 	var t *byte
+	n = 0 + n // TODO(mdempsky): Remove once CaptureVars is gone.
 	if unsafe.Sizeof(t) == 8 {
 		// Test mem > maxAlloc
 		var n2 int64 = 1 << 59
-- 
GitLab


From 98218388321c0c48a4b955792b8d1e3db63a140d Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 5 Jan 2021 08:20:11 -0800
Subject: [PATCH 0433/2400] [dev.regabi] cmd/compile: remove CaptureVars

Capture analysis is now part of escape analysis.

Passes toolstash -cmp.

Change-Id: Ifcd3ecc342074c590e0db1ff0646dfa1ea2ff57b
Reviewed-on: https://go-review.googlesource.com/c/go/+/281543
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/escape/escape.go     | 14 +++--
 src/cmd/compile/internal/gc/main.go           | 16 ------
 src/cmd/compile/internal/ir/name.go           | 11 +---
 src/cmd/compile/internal/ir/sizeof_test.go    |  2 +-
 src/cmd/compile/internal/typecheck/func.go    | 54 -------------------
 src/cmd/compile/internal/typecheck/stmt.go    |  4 --
 .../compile/internal/typecheck/typecheck.go   | 19 -------
 7 files changed, 14 insertions(+), 106 deletions(-)

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index 4aa7381c20..2222f98003 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -361,9 +361,17 @@ func (b *batch) flowClosure(k hole, clo *ir.ClosureExpr, orphan bool) {
 		}
 
 		// Capture by value for variables <= 128 bytes that are never reassigned.
-		byval := !loc.addrtaken && !loc.reassigned && n.Type().Size() <= 128
-		if byval != n.Byval() {
-			base.FatalfAt(cv.Pos(), "byval mismatch: %v: %v != %v", cv, byval, n.Byval())
+		n.SetByval(!loc.addrtaken && !loc.reassigned && n.Type().Size() <= 128)
+		if !n.Byval() {
+			n.SetAddrtaken(true)
+		}
+
+		if base.Flag.LowerM > 1 {
+			how := "ref"
+			if n.Byval() {
+				how = "value"
+			}
+			base.WarnfAt(n.Pos(), "%v capturing by %s: %v (addr=%v assign=%v width=%d)", n.Curfn, how, n, loc.addrtaken, loc.reassigned, n.Type().Size())
 		}
 
 		// Flow captured variables to closure.
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 2ea614e17f..c3756309ea 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -232,22 +232,6 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	}
 	typecheck.IncrementalAddrtaken = true
 
-	// Decide how to capture closed variables.
-	// This needs to run before escape analysis,
-	// because variables captured by value do not escape.
-	base.Timer.Start("fe", "capturevars")
-	for _, n := range typecheck.Target.Decls {
-		if n.Op() == ir.ODCLFUNC {
-			n := n.(*ir.Func)
-			if n.OClosure != nil {
-				ir.CurFunc = n
-				typecheck.CaptureVars(n)
-			}
-		}
-	}
-	typecheck.CaptureVarsComplete = true
-	ir.CurFunc = nil
-
 	if base.Debug.TypecheckInl != 0 {
 		// Typecheck imported function bodies if Debug.l > 1,
 		// otherwise lazily when used or re-exported.
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 3999c0ecb4..a51cf79929 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -59,8 +59,7 @@ type Name struct {
 	// (results) are numbered starting at one, followed by function inputs
 	// (parameters), and then local variables. Vargen is used to distinguish
 	// local variables/params with the same name.
-	Vargen    int32
-	Decldepth int32 // declaration loop depth, increased for every loop or label
+	Vargen int32
 
 	Ntype    Ntype
 	Heapaddr *Name // temp holding heap address of param
@@ -260,15 +259,13 @@ func (n *Name) Alias() bool { return n.flags&nameAlias != 0 }
 func (n *Name) SetAlias(alias bool) { n.flags.set(nameAlias, alias) }
 
 const (
-	nameCaptured = 1 << iota // is the variable captured by a closure
-	nameReadonly
+	nameReadonly              = 1 << iota
 	nameByval                 // is the variable captured by value or by reference
 	nameNeedzero              // if it contains pointers, needs to be zeroed on function entry
 	nameAutoTemp              // is the variable a temporary (implies no dwarf info. reset if escapes to heap)
 	nameUsed                  // for variable declared and not used error
 	nameIsClosureVar          // PAUTOHEAP closure pseudo-variable; original at n.Name.Defn
 	nameIsOutputParamHeapAddr // pointer to a result parameter's heap copy
-	nameAssigned              // is the variable ever assigned to
 	nameAddrtaken             // address taken, even if not moved to heap
 	nameInlFormal             // PAUTO created by inliner, derived from callee formal
 	nameInlLocal              // PAUTO created by inliner, derived from callee local
@@ -277,28 +274,24 @@ const (
 	nameAlias                 // is type name an alias
 )
 
-func (n *Name) Captured() bool              { return n.flags&nameCaptured != 0 }
 func (n *Name) Readonly() bool              { return n.flags&nameReadonly != 0 }
 func (n *Name) Needzero() bool              { return n.flags&nameNeedzero != 0 }
 func (n *Name) AutoTemp() bool              { return n.flags&nameAutoTemp != 0 }
 func (n *Name) Used() bool                  { return n.flags&nameUsed != 0 }
 func (n *Name) IsClosureVar() bool          { return n.flags&nameIsClosureVar != 0 }
 func (n *Name) IsOutputParamHeapAddr() bool { return n.flags&nameIsOutputParamHeapAddr != 0 }
-func (n *Name) Assigned() bool              { return n.flags&nameAssigned != 0 }
 func (n *Name) Addrtaken() bool             { return n.flags&nameAddrtaken != 0 }
 func (n *Name) InlFormal() bool             { return n.flags&nameInlFormal != 0 }
 func (n *Name) InlLocal() bool              { return n.flags&nameInlLocal != 0 }
 func (n *Name) OpenDeferSlot() bool         { return n.flags&nameOpenDeferSlot != 0 }
 func (n *Name) LibfuzzerExtraCounter() bool { return n.flags&nameLibfuzzerExtraCounter != 0 }
 
-func (n *Name) SetCaptured(b bool)              { n.flags.set(nameCaptured, b) }
 func (n *Name) setReadonly(b bool)              { n.flags.set(nameReadonly, b) }
 func (n *Name) SetNeedzero(b bool)              { n.flags.set(nameNeedzero, b) }
 func (n *Name) SetAutoTemp(b bool)              { n.flags.set(nameAutoTemp, b) }
 func (n *Name) SetUsed(b bool)                  { n.flags.set(nameUsed, b) }
 func (n *Name) SetIsClosureVar(b bool)          { n.flags.set(nameIsClosureVar, b) }
 func (n *Name) SetIsOutputParamHeapAddr(b bool) { n.flags.set(nameIsOutputParamHeapAddr, b) }
-func (n *Name) SetAssigned(b bool)              { n.flags.set(nameAssigned, b) }
 func (n *Name) SetAddrtaken(b bool)             { n.flags.set(nameAddrtaken, b) }
 func (n *Name) SetInlFormal(b bool)             { n.flags.set(nameInlFormal, b) }
 func (n *Name) SetInlLocal(b bool)              { n.flags.set(nameInlLocal, b) }
diff --git a/src/cmd/compile/internal/ir/sizeof_test.go b/src/cmd/compile/internal/ir/sizeof_test.go
index 60120f2998..1a4d2e5c7a 100644
--- a/src/cmd/compile/internal/ir/sizeof_test.go
+++ b/src/cmd/compile/internal/ir/sizeof_test.go
@@ -21,7 +21,7 @@ func TestSizeof(t *testing.T) {
 		_64bit uintptr     // size on 64bit platforms
 	}{
 		{Func{}, 184, 320},
-		{Name{}, 124, 216},
+		{Name{}, 120, 216},
 	}
 
 	for _, tt := range tests {
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index 8fdb33b145..8789395ffb 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -100,32 +100,6 @@ func PartialCallType(n *ir.SelectorExpr) *types.Type {
 	return t
 }
 
-// CaptureVars is called in a separate phase after all typechecking is done.
-// It decides whether each variable captured by a closure should be captured
-// by value or by reference.
-// We use value capturing for values <= 128 bytes that are never reassigned
-// after capturing (effectively constant).
-func CaptureVars(fn *ir.Func) {
-	for _, v := range fn.ClosureVars {
-		outermost := v.Defn.(*ir.Name)
-
-		// out parameters will be assigned to implicitly upon return.
-		if outermost.Class != ir.PPARAMOUT && !outermost.Addrtaken() && !outermost.Assigned() && outermost.Type().Size() <= 128 {
-			outermost.SetByval(true)
-		} else {
-			outermost.SetAddrtaken(true)
-		}
-
-		if base.Flag.LowerM > 1 {
-			how := "ref"
-			if v.Byval() {
-				how = "value"
-			}
-			base.WarnfAt(v.Pos(), "%v capturing by %s: %v (addr=%v assign=%v width=%d)", v.Curfn, how, v, outermost.Addrtaken(), outermost.Assigned(), v.Type().Size())
-		}
-	}
-}
-
 // Lazy typechecking of imported bodies. For local functions, caninl will set ->typecheck
 // because they're a copy of an already checked body.
 func ImportedBody(fn *ir.Func) {
@@ -198,9 +172,6 @@ func fnpkg(fn *ir.Name) *types.Pkg {
 	return fn.Sym().Pkg
 }
 
-// CaptureVarsComplete is set to true when the capturevars phase is done.
-var CaptureVarsComplete bool
-
 // closurename generates a new unique name for a closure within
 // outerfunc.
 func closurename(outerfunc *ir.Func) *types.Sym {
@@ -336,22 +307,6 @@ func tcClosure(clo *ir.ClosureExpr, top int) {
 		return
 	}
 
-	for _, ln := range fn.ClosureVars {
-		n := ln.Defn
-		if !n.Name().Captured() {
-			n.Name().SetCaptured(true)
-			if n.Name().Decldepth == 0 {
-				base.Fatalf("typecheckclosure: var %v does not have decldepth assigned", n)
-			}
-
-			// Ignore assignments to the variable in straightline code
-			// preceding the first capturing by a closure.
-			if n.Name().Decldepth == decldepth {
-				n.Name().SetAssigned(false)
-			}
-		}
-	}
-
 	fn.Nname.SetSym(closurename(ir.CurFunc))
 	ir.MarkFunc(fn.Nname)
 	Func(fn)
@@ -363,10 +318,7 @@ func tcClosure(clo *ir.ClosureExpr, top int) {
 	if ir.CurFunc != nil && clo.Type() != nil {
 		oldfn := ir.CurFunc
 		ir.CurFunc = fn
-		olddd := decldepth
-		decldepth = 1
 		Stmts(fn.Body)
-		decldepth = olddd
 		ir.CurFunc = oldfn
 	}
 
@@ -400,12 +352,6 @@ func tcFunc(n *ir.Func) {
 		defer tracePrint("typecheckfunc", n)(nil)
 	}
 
-	for _, ln := range n.Dcl {
-		if ln.Op() == ir.ONAME && (ln.Class == ir.PPARAM || ln.Class == ir.PPARAMOUT) {
-			ln.Decldepth = 1
-		}
-	}
-
 	n.Nname = AssignExpr(n.Nname).(*ir.Name)
 	t := n.Nname.Type()
 	if t == nil {
diff --git a/src/cmd/compile/internal/typecheck/stmt.go b/src/cmd/compile/internal/typecheck/stmt.go
index d90d13b44c..8baa5dda78 100644
--- a/src/cmd/compile/internal/typecheck/stmt.go
+++ b/src/cmd/compile/internal/typecheck/stmt.go
@@ -228,7 +228,6 @@ func plural(n int) string {
 // tcFor typechecks an OFOR node.
 func tcFor(n *ir.ForStmt) ir.Node {
 	Stmts(n.Init())
-	decldepth++
 	n.Cond = Expr(n.Cond)
 	n.Cond = DefaultLit(n.Cond, nil)
 	if n.Cond != nil {
@@ -242,7 +241,6 @@ func tcFor(n *ir.ForStmt) ir.Node {
 		Stmts(n.Late)
 	}
 	Stmts(n.Body)
-	decldepth--
 	return n
 }
 
@@ -337,9 +335,7 @@ func tcRange(n *ir.RangeStmt) {
 		n.Value = AssignExpr(n.Value)
 	}
 
-	decldepth++
 	Stmts(n.Body)
-	decldepth--
 }
 
 // tcReturn typechecks an ORETURN node.
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index c3a5a3c40f..07bbd25105 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -21,8 +21,6 @@ var InitTodoFunc = ir.NewFunc(base.Pos)
 
 var inimport bool // set during import
 
-var decldepth int32
-
 var TypecheckAllowed bool
 
 var (
@@ -58,7 +56,6 @@ func Callee(n ir.Node) ir.Node {
 
 func FuncBody(n *ir.Func) {
 	ir.CurFunc = n
-	decldepth = 1
 	errorsBefore := base.Errors()
 	Stmts(n.Body)
 	CheckUnused(n)
@@ -506,9 +503,6 @@ func typecheck1(n ir.Node, top int) ir.Node {
 
 	case ir.ONAME:
 		n := n.(*ir.Name)
-		if n.Decldepth == 0 {
-			n.Decldepth = decldepth
-		}
 		if n.BuiltinOp != 0 {
 			if top&ctxCallee == 0 {
 				base.Errorf("use of builtin %v not in function call", n.Sym())
@@ -839,7 +833,6 @@ func typecheck1(n ir.Node, top int) ir.Node {
 		return n
 
 	case ir.OLABEL:
-		decldepth++
 		if n.Sym().IsBlank() {
 			// Empty identifier is valid but useless.
 			// Eliminate now to simplify life later.
@@ -1620,18 +1613,6 @@ func checkassign(stmt ir.Node, n ir.Node) {
 		return
 	}
 
-	// Variables declared in ORANGE are assigned on every iteration.
-	if !ir.DeclaredBy(n, stmt) || stmt.Op() == ir.ORANGE {
-		r := ir.OuterValue(n)
-		if r.Op() == ir.ONAME {
-			r := r.(*ir.Name)
-			r.SetAssigned(true)
-			if r.IsClosureVar() {
-				r.Defn.Name().SetAssigned(true)
-			}
-		}
-	}
-
 	if ir.IsAddressable(n) {
 		return
 	}
-- 
GitLab


From cb05a0aa6a05cbef05587f02473dbd7f6740b933 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 5 Jan 2021 09:37:28 -0800
Subject: [PATCH 0434/2400] [dev.regabi] cmd/compile: remove toolstash
 scaffolding

Now that CaptureVars is gone, we can remove the extra code in escape
analysis that only served to appease toolstash -cmp.

Change-Id: I8c811834f3d966e76702e2d362e3de414c94bea6
Reviewed-on: https://go-review.googlesource.com/c/go/+/281544
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/escape/escape.go     | 69 ++-----------------
 .../compile/internal/logopt/logopt_test.go    |  1 -
 test/chancap.go                               |  1 -
 test/fixedbugs/issue4085b.go                  |  1 -
 4 files changed, 4 insertions(+), 68 deletions(-)

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index 2222f98003..5df82d8cdc 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -116,12 +116,6 @@ type escape struct {
 	// label with a corresponding backwards "goto" (i.e.,
 	// unstructured loop).
 	loopDepth int
-
-	// loopSlop tracks how far off typecheck's "decldepth" variable
-	// would be from loopDepth at the same point during type checking.
-	// It's only needed to match CaptureVars's pessimism until it can be
-	// removed entirely.
-	loopSlop int
 }
 
 // An location represents an abstract location that stores a Go
@@ -131,7 +125,6 @@ type location struct {
 	curfn     *ir.Func // enclosing function
 	edges     []edge   // incoming edges
 	loopDepth int      // loopDepth at declaration
-	loopSlop  int      // loopSlop at declaration
 
 	// derefs and walkgen are used during walkOne to track the
 	// minimal dereferences from the walk root.
@@ -233,14 +226,10 @@ func Batch(fns []*ir.Func, recursive bool) {
 	// can decide whether closures should capture their free variables
 	// by value or reference.
 	for _, closure := range b.closures {
-		b.flowClosure(closure.k, closure.clo, false)
+		b.flowClosure(closure.k, closure.clo)
 	}
 	b.closures = nil
 
-	for _, orphan := range findOrphans(fns) {
-		b.flowClosure(b.blankLoc.asHole(), orphan, true)
-	}
-
 	for _, loc := range b.allLocs {
 		if why := HeapAllocReason(loc.n); why != "" {
 			b.flow(b.heapHole().addr(loc.n, why), loc)
@@ -251,46 +240,6 @@ func Batch(fns []*ir.Func, recursive bool) {
 	b.finish(fns)
 }
 
-// findOrphans finds orphaned closure expressions that were originally
-// contained within a function in fns, but were lost due to earlier
-// optimizations.
-// TODO(mdempsky): Remove after CaptureVars is gone.
-func findOrphans(fns []*ir.Func) []*ir.ClosureExpr {
-	have := make(map[*ir.Func]bool)
-	for _, fn := range fns {
-		have[fn] = true
-	}
-
-	parent := func(fn *ir.Func) *ir.Func {
-		if len(fn.ClosureVars) == 0 {
-			return nil
-		}
-		cv := fn.ClosureVars[0]
-		if cv.Defn == nil {
-			return nil // method value wrapper
-		}
-		return cv.Outer.Curfn
-	}
-
-	outermost := func(fn *ir.Func) *ir.Func {
-		for {
-			outer := parent(fn)
-			if outer == nil {
-				return fn
-			}
-			fn = outer
-		}
-	}
-
-	var orphans []*ir.ClosureExpr
-	for _, fn := range typecheck.Target.Decls {
-		if fn, ok := fn.(*ir.Func); ok && have[outermost(fn)] && !have[fn] {
-			orphans = append(orphans, fn.OClosure)
-		}
-	}
-	return orphans
-}
-
 func (b *batch) with(fn *ir.Func) *escape {
 	return &escape{
 		batch:     b,
@@ -348,15 +297,11 @@ func (b *batch) walkFunc(fn *ir.Func) {
 	}
 }
 
-func (b *batch) flowClosure(k hole, clo *ir.ClosureExpr, orphan bool) {
+func (b *batch) flowClosure(k hole, clo *ir.ClosureExpr) {
 	for _, cv := range clo.Func.ClosureVars {
 		n := cv.Canonical()
-		if n.Opt == nil && orphan {
-			continue // n.Curfn must have been an orphan too
-		}
-
 		loc := b.oldLoc(cv)
-		if !loc.captured && !orphan {
+		if !loc.captured {
 			base.FatalfAt(cv.Pos(), "closure variable never captured: %v", cv)
 		}
 
@@ -454,9 +399,6 @@ func (e *escape) stmt(n ir.Node) {
 			if base.Flag.LowerM > 2 {
 				fmt.Printf("%v:%v non-looping label\n", base.FmtPos(base.Pos), n)
 			}
-			if s := n.Label.Name; !strings.HasPrefix(s, ".") && !strings.Contains(s, "·") {
-				e.loopSlop++
-			}
 		case looping:
 			if base.Flag.LowerM > 2 {
 				fmt.Printf("%v: %v looping label\n", base.FmtPos(base.Pos), n)
@@ -597,7 +539,6 @@ func (e *escape) stmts(l ir.Nodes) {
 func (e *escape) block(l ir.Nodes) {
 	old := e.loopDepth
 	e.stmts(l)
-	e.loopSlop += e.loopDepth - old
 	e.loopDepth = old
 }
 
@@ -821,7 +762,7 @@ func (e *escape) exprSkipInit(k hole, n ir.Node) {
 
 					// Ignore reassignments to the variable in straightline code
 					// preceding the first capture by a closure.
-					if loc.loopDepth+loc.loopSlop == e.loopDepth+e.loopSlop {
+					if loc.loopDepth == e.loopDepth {
 						loc.reassigned = false
 					}
 				}
@@ -1286,7 +1227,6 @@ func (e *escape) dcl(n *ir.Name) hole {
 	}
 	loc := e.oldLoc(n)
 	loc.loopDepth = e.loopDepth
-	loc.loopSlop = e.loopSlop
 	return loc.asHole()
 }
 
@@ -1323,7 +1263,6 @@ func (e *escape) newLoc(n ir.Node, transient bool) *location {
 		n:         n,
 		curfn:     e.curfn,
 		loopDepth: e.loopDepth,
-		loopSlop:  e.loopSlop,
 		transient: transient,
 	}
 	e.allLocs = append(e.allLocs, loc)
diff --git a/src/cmd/compile/internal/logopt/logopt_test.go b/src/cmd/compile/internal/logopt/logopt_test.go
index 1d1e21b060..71976174b0 100644
--- a/src/cmd/compile/internal/logopt/logopt_test.go
+++ b/src/cmd/compile/internal/logopt/logopt_test.go
@@ -154,7 +154,6 @@ func s15a8(x *[15]int64) [15]int64 {
 		// On not-amd64, test the host architecture and os
 		arches := []string{runtime.GOARCH}
 		goos0 := runtime.GOOS
-		goos0 = "" + goos0             // TODO(mdempsky): Remove once CaptureVars is gone.
 		if runtime.GOARCH == "amd64" { // Test many things with "linux" (wasm will get "js")
 			arches = []string{"arm", "arm64", "386", "amd64", "mips", "mips64", "ppc64le", "riscv64", "s390x", "wasm"}
 			goos0 = "linux"
diff --git a/test/chancap.go b/test/chancap.go
index 3a4f67638a..8dce9247cd 100644
--- a/test/chancap.go
+++ b/test/chancap.go
@@ -41,7 +41,6 @@ func main() {
 	n := -1
 	shouldPanic("makechan: size out of range", func() { _ = make(T, n) })
 	shouldPanic("makechan: size out of range", func() { _ = make(T, int64(n)) })
-	n = 0 + n // TODO(mdempsky): Remove once CaptureVars is gone.
 	if ptrSize == 8 {
 		// Test mem > maxAlloc
 		var n2 int64 = 1 << 59
diff --git a/test/fixedbugs/issue4085b.go b/test/fixedbugs/issue4085b.go
index b69e10c6cc..cf27512da0 100644
--- a/test/fixedbugs/issue4085b.go
+++ b/test/fixedbugs/issue4085b.go
@@ -22,7 +22,6 @@ func main() {
 	testMakeInAppend(n)
 
 	var t *byte
-	n = 0 + n // TODO(mdempsky): Remove once CaptureVars is gone.
 	if unsafe.Sizeof(t) == 8 {
 		// Test mem > maxAlloc
 		var n2 int64 = 1 << 59
-- 
GitLab


From 196102d046b2579fedc11435b541b9f9ffcac93d Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 5 Jan 2021 09:46:23 -0800
Subject: [PATCH 0435/2400] [dev.typeparams] cmd/compile/internal/types2:
 review of typexpr.go

This code matches go/types/typexpr but for the necessary adjustments
because of the use of package syntax rather than go/ast, and for the
code being part of cmd/compile/internal/types2 rather than go/types.

Primary differences to go.types/typexpr.go:
- syntax.FuncType doesn't carry type parameters
- type instantiations are represented using syntax.IndexExpr
  nodes
- there's an explicit syntax.SliceType
- *x is expressed as a unary operation, not a StarExpr
- grouped fields are identified by identical pointer types

To see the changes copied from recent go/types changes, compare Patchsets 1 and 2.

Change-Id: I8aa9452882d1f5e9529c52a30c7c8e65f3fcbb43
Reviewed-on: https://go-review.googlesource.com/c/go/+/281545
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/typexpr.go | 32 +++++++++++-----------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 4231577a4f..3ee8ac85cf 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2013 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.
@@ -230,13 +229,13 @@ func isubst(x syntax.Expr, smap map[*syntax.Name]*syntax.Name) syntax.Expr {
 	case *syntax.ListExpr:
 		var elems []syntax.Expr
 		for i, elem := range n.ElemList {
-			Elem := isubst(elem, smap)
-			if Elem != elem {
+			new := isubst(elem, smap)
+			if new != elem {
 				if elems == nil {
 					elems = make([]syntax.Expr, len(n.ElemList))
 					copy(elems, n.ElemList)
 				}
-				elems[i] = Elem
+				elems[i] = new
 			}
 		}
 		if elems != nil {
@@ -315,6 +314,7 @@ func (check *Checker) funcType(sig *Signature, recvPar *syntax.Field, tparams []
 				for i, t := range sig.rparams {
 					list[i] = t.typ
 				}
+				smap := makeSubstMap(recvTParams, list)
 				for i, tname := range sig.rparams {
 					bound := recvTParams[i].typ.(*TypeParam).bound
 					// bound is (possibly) parameterized in the context of the
@@ -323,7 +323,7 @@ func (check *Checker) funcType(sig *Signature, recvPar *syntax.Field, tparams []
 					// TODO(gri) should we assume now that bounds always exist?
 					//           (no bound == empty interface)
 					if bound != nil {
-						bound = check.subst(tname.pos, bound, makeSubstMap(recvTParams, list))
+						bound = check.subst(tname.pos, bound, smap)
 						tname.typ.(*TypeParam).bound = bound
 					}
 				}
@@ -646,9 +646,9 @@ func (check *Checker) instantiatedType(x syntax.Expr, targs []syntax.Expr, def *
 		unreachable() // should have been caught by genericType
 	}
 
-	// create a new type Instance rather than instantiate the type
+	// create a new type instance rather than instantiate the type
 	// TODO(gri) should do argument number check here rather than
-	// when instantiating the type?
+	//           when instantiating the type?
 	typ := new(instance)
 	def.setUnderlying(typ)
 
@@ -1118,8 +1118,9 @@ func (check *Checker) structType(styp *Struct, e *syntax.StructType) {
 			add(f.Name, false, f.Name.Pos())
 		} else {
 			// embedded field
-			// spec: "An embedded type must be specified as a (possibly parenthesized) type name T or
-			// as a pointer to a non-interface type name *T, and T itself may not be a pointer type."
+			// spec: "An embedded type must be specified as a type name T or as a
+			// pointer to a non-interface type name *T, and T itself may not be a
+			// pointer type."
 			pos := startPos(f.Type)
 			name := embeddedFieldIdent(f.Type)
 			if name == nil {
@@ -1129,6 +1130,7 @@ func (check *Checker) structType(styp *Struct, e *syntax.StructType) {
 				continue
 			}
 			add(name, true, pos)
+
 			// Because we have a name, typ must be of the form T or *T, where T is the name
 			// of a (named or alias) type, and t (= deref(typ)) must be the type of T.
 			// We must delay this check to the end because we don't want to instantiate
@@ -1204,20 +1206,18 @@ func (check *Checker) collectTypeConstraints(pos syntax.Pos, types []syntax.Expr
 		list = append(list, typ)
 	}
 
-	// Ensure that each type is only present once in the type list.
-	// Types may be interfaces, which may not be complete yet. It's
-	// ok to do this check at the end because it's not a requirement
-	// for correctness of the code.
+	// Ensure that each type is only present once in the type list.  Types may be
+	// interfaces, which may not be complete yet. It's ok to do this check at the
+	// end because it's not a requirement for correctness of the code.
+	// Note: This is a quadratic algorithm, but type lists tend to be short.
 	check.atEnd(func() {
-		uniques := make([]Type, 0, len(list)) // assume all types are unique
 		for i, t := range list {
 			if t := t.Interface(); t != nil {
 				check.completeInterface(types[i].Pos(), t)
 			}
-			if includes(uniques, t) {
+			if includes(list[:i], t) {
 				check.softErrorf(types[i], "duplicate type %s in type list", t)
 			}
-			uniques = append(uniques, t)
 		}
 	})
 
-- 
GitLab


From 9546596d771711a4844b91de4680ad739819cbdc Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 5 Jan 2021 12:33:11 -0800
Subject: [PATCH 0436/2400] [dev.typeparams] cmd/compile/internal/types2:
 remove disabled code related to type lists

Earlier (contract-based) versions of the generics design restricted the
kind of types that could be used in a type list - the current design does
not have these restrictions anymore. Remove the respective checking code.

Change-Id: Ia333f7aa8a9c31a92c08acbd5cadba3532a455b6
Reviewed-on: https://go-review.googlesource.com/c/go/+/281546
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/typexpr.go | 69 +---------------------
 1 file changed, 1 insertion(+), 68 deletions(-)

diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 3ee8ac85cf..910db0819f 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -1192,18 +1192,7 @@ func (check *Checker) collectTypeConstraints(pos syntax.Pos, types []syntax.Expr
 			check.invalidASTf(pos, "missing type constraint")
 			continue
 		}
-		typ := check.varType(texpr)
-		// A type constraint may be a predeclared type or a
-		// composite type composed of only predeclared types.
-		// TODO(gri) If we enable this again it also must run
-		// at the end.
-		const restricted = false
-		var why string
-		if restricted && !check.typeConstraint(typ, &why) {
-			check.errorf(texpr, "invalid type constraint %s (%s)", typ, why)
-			continue
-		}
-		list = append(list, typ)
+		list = append(list, check.varType(texpr))
 	}
 
 	// Ensure that each type is only present once in the type list.  Types may be
@@ -1234,62 +1223,6 @@ func includes(list []Type, typ Type) bool {
 	return false
 }
 
-// typeConstraint checks that typ may be used in a type list.
-// For now this just checks for the absence of defined (*Named) types.
-func (check *Checker) typeConstraint(typ Type, why *string) bool {
-	switch t := typ.(type) {
-	case *Basic:
-		// ok
-	case *Array:
-		return check.typeConstraint(t.elem, why)
-	case *Slice:
-		return check.typeConstraint(t.elem, why)
-	case *Struct:
-		for _, f := range t.fields {
-			if !check.typeConstraint(f.typ, why) {
-				return false
-			}
-		}
-	case *Pointer:
-		return check.typeConstraint(t.base, why)
-	case *Tuple:
-		if t == nil {
-			return true
-		}
-		for _, v := range t.vars {
-			if !check.typeConstraint(v.typ, why) {
-				return false
-			}
-		}
-	case *Signature:
-		if len(t.tparams) != 0 {
-			panic("type parameter in function type")
-		}
-		return (t.recv == nil || check.typeConstraint(t.recv.typ, why)) &&
-			check.typeConstraint(t.params, why) &&
-			check.typeConstraint(t.results, why)
-	case *Interface:
-		t.assertCompleteness()
-		for _, m := range t.allMethods {
-			if !check.typeConstraint(m.typ, why) {
-				return false
-			}
-		}
-	case *Map:
-		return check.typeConstraint(t.key, why) && check.typeConstraint(t.elem, why)
-	case *Chan:
-		return check.typeConstraint(t.elem, why)
-	case *Named:
-		*why = check.sprintf("contains defined type %s", t)
-		return false
-	case *TypeParam:
-		// ok, e.g.: func f (type T interface { type T }) ()
-	default:
-		unreachable()
-	}
-	return true
-}
-
 func ptrBase(x *syntax.Operation) syntax.Expr {
 	if x.Op == syntax.Mul && x.Y == nil {
 		return x.X
-- 
GitLab


From 0e286579c5c49660ff01fc7db5f2747958869ce9 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 16 Dec 2020 17:02:07 -0500
Subject: [PATCH 0437/2400] [dev.typeparams] go/types: import typexpr.go from
 dev.go2go

Changes from dev.go2go (compare with patchset 1):
 + Update stale comments.
 + Fix a bug in structType where check.atEnd closed over the loop
   variable, resulting in incorrect error positions.
 + Fix a bug in the CallExpr clause of typInternal where it didn't check
   e.Brackets before checking instantiatedType.
 + Remove support for parenthesized embedded type names.
 + Add an IndexExpr clause to embeddedFieldIdent.
 + Lift the substMap construction out of the loop in funcType when
   substituting receiver type parameters.
 + Minor simplification in collectTypeConstraints.

Compare with patchset 1 to see these changes.

Change-Id: I24f10e8615a0bbcd56c86ecf3490ce6a99cfebd6
Reviewed-on: https://go-review.googlesource.com/c/go/+/278916
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Trust: Robert Findley <rfindley@google.com>
---
 src/go/types/call.go    |   8 +
 src/go/types/stmt.go    |   2 +-
 src/go/types/typexpr.go | 550 +++++++++++++++++++++++++++++++++-------
 3 files changed, 464 insertions(+), 96 deletions(-)

diff --git a/src/go/types/call.go b/src/go/types/call.go
index 6765b17bf3..61a7f0926d 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -567,3 +567,11 @@ Error:
 	x.mode = invalid
 	x.expr = e
 }
+
+// instantiatedOperand reports an error of x is an uninstantiated (generic) type and sets x.typ to Typ[Invalid].
+func (check *Checker) instantiatedOperand(x *operand) {
+	if x.mode == typexpr && isGeneric(x.typ) {
+		check.errorf(x, 0, "cannot use generic type %s without instantiation", x.typ)
+		x.typ = Typ[Invalid]
+	}
+}
diff --git a/src/go/types/stmt.go b/src/go/types/stmt.go
index a36ca43016..0162368a64 100644
--- a/src/go/types/stmt.go
+++ b/src/go/types/stmt.go
@@ -269,7 +269,7 @@ L:
 func (check *Checker) caseTypes(x *operand, xtyp *Interface, types []ast.Expr, seen map[Type]ast.Expr) (T Type) {
 L:
 	for _, e := range types {
-		T = check.typOrNil(e)
+		T = check.typeOrNil(e)
 		if T == Typ[Invalid] {
 			continue L
 		}
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index 24df33965d..42d8f691d0 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -118,6 +118,7 @@ func (check *Checker) ident(x *operand, e *ast.Ident, def *Named, wantType bool)
 }
 
 // typ type-checks the type expression e and returns its type, or Typ[Invalid].
+// The type must not be an (uninstantiated) generic type.
 func (check *Checker) typ(e ast.Expr) Type {
 	return check.definedType(e, nil)
 }
@@ -166,32 +167,169 @@ func (check *Checker) anyType(e ast.Expr) Type {
 // in a type declaration, and def.underlying will be set to the type of e before
 // any components of e are type-checked.
 //
-func (check *Checker) definedType(e ast.Expr, def *Named) (T Type) {
-	if trace {
-		check.trace(e.Pos(), "%s", e)
-		check.indent++
-		defer func() {
-			check.indent--
-			check.trace(e.Pos(), "=> %s", T)
-		}()
+func (check *Checker) definedType(e ast.Expr, def *Named) Type {
+	typ := check.typInternal(e, def)
+	assert(isTyped(typ))
+	if isGeneric(typ) {
+		check.errorf(e, 0, "cannot use generic type %s without instantiation", typ)
+		typ = Typ[Invalid]
 	}
+	check.recordTypeAndValue(e, typexpr, typ, nil)
+	return typ
+}
 
-	T = check.typInternal(e, def)
-	assert(isTyped(T))
-	check.recordTypeAndValue(e, typexpr, T, nil)
+// genericType is like typ but the type must be an (uninstantiated) generic type.
+func (check *Checker) genericType(e ast.Expr, reportErr bool) Type {
+	typ := check.typInternal(e, nil)
+	assert(isTyped(typ))
+	if typ != Typ[Invalid] && !isGeneric(typ) {
+		if reportErr {
+			check.errorf(e, 0, "%s is not a generic type", typ)
+		}
+		typ = Typ[Invalid]
+	}
+	// TODO(gri) what is the correct call below?
+	check.recordTypeAndValue(e, typexpr, typ, nil)
+	return typ
+}
 
-	return
+// isubst returns an x with identifiers substituted per the substitution map smap.
+// isubst only handles the case of (valid) method receiver type expressions correctly.
+func isubst(x ast.Expr, smap map[*ast.Ident]*ast.Ident) ast.Expr {
+	switch n := x.(type) {
+	case *ast.Ident:
+		if alt := smap[n]; alt != nil {
+			return alt
+		}
+	case *ast.StarExpr:
+		X := isubst(n.X, smap)
+		if X != n.X {
+			new := *n
+			new.X = X
+			return &new
+		}
+	case *ast.CallExpr:
+		var args []ast.Expr
+		for i, arg := range n.Args {
+			new := isubst(arg, smap)
+			if new != arg {
+				if args == nil {
+					args = make([]ast.Expr, len(n.Args))
+					copy(args, n.Args)
+				}
+				args[i] = new
+			}
+		}
+		if args != nil {
+			new := *n
+			new.Args = args
+			return &new
+		}
+	case *ast.ParenExpr:
+		return isubst(n.X, smap) // no need to keep parentheses
+	default:
+		// Other receiver type expressions are invalid.
+		// It's fine to ignore those here as they will
+		// be checked elsewhere.
+	}
+	return x
 }
 
 // funcType type-checks a function or method type.
 func (check *Checker) funcType(sig *Signature, recvPar *ast.FieldList, ftyp *ast.FuncType) {
-	scope := NewScope(check.scope, token.NoPos, token.NoPos, "function")
-	scope.isFunc = true
-	check.recordScope(ftyp, scope)
+	check.openScope(ftyp, "function")
+	check.scope.isFunc = true
+	check.recordScope(ftyp, check.scope)
+	sig.scope = check.scope
+	defer check.closeScope()
+
+	var recvTyp ast.Expr // rewritten receiver type; valid if != nil
+	if recvPar != nil && len(recvPar.List) > 0 {
+		// collect generic receiver type parameters, if any
+		// - a receiver type parameter is like any other type parameter, except that it is declared implicitly
+		// - the receiver specification acts as local declaration for its type parameters, which may be blank
+		_, rname, rparams := check.unpackRecv(recvPar.List[0].Type, true)
+		if len(rparams) > 0 {
+			// Blank identifiers don't get declared and regular type-checking of the instantiated
+			// parameterized receiver type expression fails in Checker.collectParams of receiver.
+			// Identify blank type parameters and substitute each with a unique new identifier named
+			// "n_" (where n is the parameter index) and which cannot conflict with any user-defined
+			// name.
+			var smap map[*ast.Ident]*ast.Ident // substitution map from "_" to "n_" identifiers
+			for i, p := range rparams {
+				if p.Name == "_" {
+					new := *p
+					new.Name = fmt.Sprintf("%d_", i)
+					rparams[i] = &new // use n_ identifier instead of _ so it can be looked up
+					if smap == nil {
+						smap = make(map[*ast.Ident]*ast.Ident)
+					}
+					smap[p] = &new
+				}
+			}
+			if smap != nil {
+				// blank identifiers were found => use rewritten receiver type
+				recvTyp = isubst(recvPar.List[0].Type, smap)
+			}
+			sig.rparams = check.declareTypeParams(nil, rparams)
+			// determine receiver type to get its type parameters
+			// and the respective type parameter bounds
+			var recvTParams []*TypeName
+			if rname != nil {
+				// recv should be a Named type (otherwise an error is reported elsewhere)
+				// Also: Don't report an error via genericType since it will be reported
+				//       again when we type-check the signature.
+				// TODO(gri) maybe the receiver should be marked as invalid instead?
+				if recv := asNamed(check.genericType(rname, false)); recv != nil {
+					recvTParams = recv.tparams
+				}
+			}
+			// provide type parameter bounds
+			// - only do this if we have the right number (otherwise an error is reported elsewhere)
+			if len(sig.rparams) == len(recvTParams) {
+				// We have a list of *TypeNames but we need a list of Types.
+				list := make([]Type, len(sig.rparams))
+				for i, t := range sig.rparams {
+					list[i] = t.typ
+				}
+				smap := makeSubstMap(recvTParams, list)
+				for i, tname := range sig.rparams {
+					bound := recvTParams[i].typ.(*TypeParam).bound
+					// bound is (possibly) parameterized in the context of the
+					// receiver type declaration. Substitute parameters for the
+					// current context.
+					// TODO(gri) should we assume now that bounds always exist?
+					//           (no bound == empty interface)
+					if bound != nil {
+						bound = check.subst(tname.pos, bound, smap)
+						tname.typ.(*TypeParam).bound = bound
+					}
+				}
+			}
+		}
+	}
+
+	if ftyp.TParams != nil {
+		sig.tparams = check.collectTypeParams(ftyp.TParams)
+		// Always type-check method type parameters but complain that they are not allowed.
+		// (A separate check is needed when type-checking interface method signatures because
+		// they don't have a receiver specification.)
+		if recvPar != nil {
+			check.errorf(ftyp.TParams, 0, "methods cannot have type parameters")
+		}
+	}
 
-	recvList, _ := check.collectParams(scope, recvPar, false)
-	params, variadic := check.collectParams(scope, ftyp.Params, true)
-	results, _ := check.collectParams(scope, ftyp.Results, false)
+	// Value (non-type) parameters' scope starts in the function body. Use a temporary scope for their
+	// declarations and then squash that scope into the parent scope (and report any redeclarations at
+	// that time).
+	scope := NewScope(check.scope, token.NoPos, token.NoPos, "function body (temp. scope)")
+	recvList, _ := check.collectParams(scope, recvPar, recvTyp, false) // use rewritten receiver type, if any
+	params, variadic := check.collectParams(scope, ftyp.Params, nil, true)
+	results, _ := check.collectParams(scope, ftyp.Results, nil, false)
+	scope.Squash(func(obj, alt Object) {
+		check.errorf(obj, _DuplicateDecl, "%s redeclared in this block", obj.Name())
+		check.reportAltDecl(alt)
+	})
 
 	if recvPar != nil {
 		// recv parameter list present (may be empty)
@@ -200,9 +338,7 @@ func (check *Checker) funcType(sig *Signature, recvPar *ast.FieldList, ftyp *ast
 		var recv *Var
 		switch len(recvList) {
 		case 0:
-			// TODO(rFindley) this is now redundant with resolver.go. Clean up when
-			//                importing remaining typexpr.go changes.
-			// check.error(recvPar, _BadRecv, "method is missing receiver")
+			// error reported by resolver
 			recv = NewParam(0, nil, "", Typ[Invalid]) // ignore recv below
 		default:
 			// more than one receiver
@@ -211,19 +347,24 @@ func (check *Checker) funcType(sig *Signature, recvPar *ast.FieldList, ftyp *ast
 		case 1:
 			recv = recvList[0]
 		}
+
+		// TODO(gri) We should delay rtyp expansion to when we actually need the
+		//           receiver; thus all checks here should be delayed to later.
+		rtyp, _ := deref(recv.typ)
+		rtyp = expand(rtyp)
+
 		// spec: "The receiver type must be of the form T or *T where T is a type name."
 		// (ignore invalid types - error was reported before)
-		if t, _ := deref(recv.typ); t != Typ[Invalid] {
+		if t := rtyp; t != Typ[Invalid] {
 			var err string
-			if T, _ := t.(*Named); T != nil {
+			if T := asNamed(t); T != nil {
 				// spec: "The type denoted by T is called the receiver base type; it must not
 				// be a pointer or interface type and it must be declared in the same package
 				// as the method."
 				if T.obj.pkg != check.pkg {
 					err = "type not defined in this package"
 				} else {
-					// TODO(gri) This is not correct if the underlying type is unknown yet.
-					switch u := T.underlying.(type) {
+					switch u := optype(T).(type) {
 					case *Basic:
 						// unsafe.Pointer is treated like a regular pointer
 						if u.kind == UnsafePointer {
@@ -244,7 +385,6 @@ func (check *Checker) funcType(sig *Signature, recvPar *ast.FieldList, ftyp *ast
 		sig.recv = recv
 	}
 
-	sig.scope = scope
 	sig.params = NewTuple(params...)
 	sig.results = NewTuple(results...)
 	sig.variadic = variadic
@@ -257,10 +397,31 @@ func goTypeName(typ Type) string {
 }
 
 // typInternal drives type checking of types.
-// Must only be called by definedType.
+// Must only be called by definedType or genericType.
 //
-func (check *Checker) typInternal(e ast.Expr, def *Named) Type {
-	switch e := e.(type) {
+func (check *Checker) typInternal(e0 ast.Expr, def *Named) (T Type) {
+	if trace {
+		check.trace(e0.Pos(), "type %s", e0)
+		check.indent++
+		defer func() {
+			check.indent--
+			var under Type
+			if T != nil {
+				// Calling under() here may lead to endless instantiations.
+				// Test case: type T[P any] *T[P]
+				// TODO(gri) investigate if that's a bug or to be expected
+				// (see also analogous comment in Checker.instantiate).
+				under = T.Underlying()
+			}
+			if T == under {
+				check.trace(e0.Pos(), "=> %s // %s", T, goTypeName(T))
+			} else {
+				check.trace(e0.Pos(), "=> %s (under = %s) // %s", T, under, goTypeName(T))
+			}
+		}()
+	}
+
+	switch e := e0.(type) {
 	case *ast.BadExpr:
 		// ignore - error reported before
 
@@ -298,7 +459,19 @@ func (check *Checker) typInternal(e ast.Expr, def *Named) Type {
 			check.errorf(&x, _NotAType, "%s is not a type", &x)
 		}
 
+	case *ast.IndexExpr:
+		return check.instantiatedType(e.X, []ast.Expr{e.Index}, def)
+
+	case *ast.CallExpr:
+		if e.Brackets {
+			return check.instantiatedType(e.Fun, e.Args, def)
+		} else {
+			check.errorf(e0, _NotAType, "%s is not a type", e0)
+		}
+
 	case *ast.ParenExpr:
+		// Generic types must be instantiated before they can be used in any form.
+		// Consequently, generic types cannot be parenthesized.
 		return check.definedType(e.X, def)
 
 	case *ast.ArrayType:
@@ -306,16 +479,15 @@ func (check *Checker) typInternal(e ast.Expr, def *Named) Type {
 			typ := new(Array)
 			def.setUnderlying(typ)
 			typ.len = check.arrayLength(e.Len)
-			typ.elem = check.typ(e.Elt)
-			return typ
-
-		} else {
-			typ := new(Slice)
-			def.setUnderlying(typ)
-			typ.elem = check.typ(e.Elt)
+			typ.elem = check.varType(e.Elt)
 			return typ
 		}
 
+		typ := new(Slice)
+		def.setUnderlying(typ)
+		typ.elem = check.varType(e.Elt)
+		return typ
+
 	case *ast.StructType:
 		typ := new(Struct)
 		def.setUnderlying(typ)
@@ -325,7 +497,7 @@ func (check *Checker) typInternal(e ast.Expr, def *Named) Type {
 	case *ast.StarExpr:
 		typ := new(Pointer)
 		def.setUnderlying(typ)
-		typ.base = check.typ(e.X)
+		typ.base = check.varType(e.X)
 		return typ
 
 	case *ast.FuncType:
@@ -337,6 +509,9 @@ func (check *Checker) typInternal(e ast.Expr, def *Named) Type {
 	case *ast.InterfaceType:
 		typ := new(Interface)
 		def.setUnderlying(typ)
+		if def != nil {
+			typ.obj = def.obj
+		}
 		check.interfaceType(typ, e, def)
 		return typ
 
@@ -344,8 +519,8 @@ func (check *Checker) typInternal(e ast.Expr, def *Named) Type {
 		typ := new(Map)
 		def.setUnderlying(typ)
 
-		typ.key = check.typ(e.Key)
-		typ.elem = check.typ(e.Value)
+		typ.key = check.varType(e.Key)
+		typ.elem = check.varType(e.Value)
 
 		// spec: "The comparison operators == and != must be fully defined
 		// for operands of the key type; thus the key type must not be a
@@ -355,7 +530,11 @@ func (check *Checker) typInternal(e ast.Expr, def *Named) Type {
 		// it is safe to continue in any case (was issue 6667).
 		check.atEnd(func() {
 			if !Comparable(typ.key) {
-				check.errorf(e.Key, _IncomparableMapKey, "incomparable map key type %s", typ.key)
+				var why string
+				if asTypeParam(typ.key) != nil {
+					why = " (missing comparable constraint)"
+				}
+				check.errorf(e.Key, _IncomparableMapKey, "incomparable map key type %s%s", typ.key, why)
 			}
 		})
 
@@ -379,11 +558,11 @@ func (check *Checker) typInternal(e ast.Expr, def *Named) Type {
 		}
 
 		typ.dir = dir
-		typ.elem = check.typ(e.Value)
+		typ.elem = check.varType(e.Value)
 		return typ
 
 	default:
-		check.errorf(e, _NotAType, "%s is not a type", e)
+		check.errorf(e0, _NotAType, "%s is not a type", e0)
 	}
 
 	typ := Typ[Invalid]
@@ -392,10 +571,11 @@ func (check *Checker) typInternal(e ast.Expr, def *Named) Type {
 }
 
 // typeOrNil type-checks the type expression (or nil value) e
-// and returns the typ of e, or nil.
-// If e is neither a type nor nil, typOrNil returns Typ[Invalid].
-//
-func (check *Checker) typOrNil(e ast.Expr) Type {
+// and returns the type of e, or nil. If e is a type, it must
+// not be an (uninstantiated) generic type.
+// If e is neither a type nor nil, typeOrNil returns Typ[Invalid].
+// TODO(gri) should we also disallow non-var types?
+func (check *Checker) typeOrNil(e ast.Expr) Type {
 	var x operand
 	check.rawExpr(&x, e, nil)
 	switch x.mode {
@@ -404,6 +584,7 @@ func (check *Checker) typOrNil(e ast.Expr) Type {
 	case novalue:
 		check.errorf(&x, _NotAType, "%s used as type", &x)
 	case typexpr:
+		check.instantiatedOperand(&x)
 		return x.typ
 	case value:
 		if x.isNil() {
@@ -416,6 +597,49 @@ func (check *Checker) typOrNil(e ast.Expr) Type {
 	return Typ[Invalid]
 }
 
+func (check *Checker) instantiatedType(x ast.Expr, targs []ast.Expr, def *Named) Type {
+	b := check.genericType(x, true) // TODO(gri) what about cycles?
+	if b == Typ[Invalid] {
+		return b // error already reported
+	}
+	base := asNamed(b)
+	if base == nil {
+		unreachable() // should have been caught by genericType
+	}
+
+	// create a new type instance rather than instantiate the type
+	// TODO(gri) should do argument number check here rather than
+	//           when instantiating the type?
+	typ := new(instance)
+	def.setUnderlying(typ)
+
+	typ.check = check
+	typ.pos = x.Pos()
+	typ.base = base
+
+	// evaluate arguments (always)
+	typ.targs = check.typeList(targs)
+	if typ.targs == nil {
+		def.setUnderlying(Typ[Invalid]) // avoid later errors due to lazy instantiation
+		return Typ[Invalid]
+	}
+
+	// determine argument positions (for error reporting)
+	typ.poslist = make([]token.Pos, len(targs))
+	for i, arg := range targs {
+		typ.poslist[i] = arg.Pos()
+	}
+
+	// make sure we check instantiation works at least once
+	// and that the resulting type is valid
+	check.atEnd(func() {
+		t := typ.expand()
+		check.validType(t, nil)
+	})
+
+	return typ
+}
+
 // arrayLength type-checks the array length expression e
 // and returns the constant length >= 0, or a value < 0
 // to indicate an error (and thus an unknown length).
@@ -443,7 +667,25 @@ func (check *Checker) arrayLength(e ast.Expr) int64 {
 	return -1
 }
 
-func (check *Checker) collectParams(scope *Scope, list *ast.FieldList, variadicOk bool) (params []*Var, variadic bool) {
+// typeList provides the list of types corresponding to the incoming expression list.
+// If an error occured, the result is nil, but all list elements were type-checked.
+func (check *Checker) typeList(list []ast.Expr) []Type {
+	res := make([]Type, len(list)) // res != nil even if len(list) == 0
+	for i, x := range list {
+		t := check.varType(x)
+		if t == Typ[Invalid] {
+			res = nil
+		}
+		if res != nil {
+			res[i] = t
+		}
+	}
+	return res
+}
+
+// collectParams declares the parameters of list in scope and returns the corresponding
+// variable list. If type0 != nil, it is used instead of the the first type in list.
+func (check *Checker) collectParams(scope *Scope, list *ast.FieldList, type0 ast.Expr, variadicOk bool) (params []*Var, variadic bool) {
 	if list == nil {
 		return
 	}
@@ -451,6 +693,9 @@ func (check *Checker) collectParams(scope *Scope, list *ast.FieldList, variadicO
 	var named, anonymous bool
 	for i, field := range list.List {
 		ftype := field.Type
+		if i == 0 && type0 != nil {
+			ftype = type0
+		}
 		if t, _ := ftype.(*ast.Ellipsis); t != nil {
 			ftype = t.Elt
 			if variadicOk && i == len(list.List)-1 && len(field.Names) <= 1 {
@@ -460,7 +705,7 @@ func (check *Checker) collectParams(scope *Scope, list *ast.FieldList, variadicO
 				// ignore ... and continue
 			}
 		}
-		typ := check.typ(ftype)
+		typ := check.varType(ftype)
 		// The parser ensures that f.Tag is nil and we don't
 		// care if a constructed AST contains a non-nil tag.
 		if len(field.Names) > 0 {
@@ -511,9 +756,12 @@ func (check *Checker) declareInSet(oset *objset, pos token.Pos, obj Object) bool
 }
 
 func (check *Checker) interfaceType(ityp *Interface, iface *ast.InterfaceType, def *Named) {
+	var tlist *ast.Ident // "type" name of first entry in a type list declaration
+	var types []ast.Expr
 	for _, f := range iface.Methods.List {
 		if len(f.Names) > 0 {
-			// We have a method with name f.Names[0].
+			// We have a method with name f.Names[0], or a type
+			// of a type list (name.Name == "type").
 			// (The parser ensures that there's only one method
 			// and we don't care if a constructed AST has more.)
 			name := f.Names[0]
@@ -522,6 +770,18 @@ func (check *Checker) interfaceType(ityp *Interface, iface *ast.InterfaceType, d
 				continue // ignore
 			}
 
+			if name.Name == "type" {
+				// Always collect all type list entries, even from
+				// different type lists, under the assumption that
+				// the author intended to include all types.
+				types = append(types, f.Type)
+				if tlist != nil && tlist != name {
+					check.errorf(name, 0, "cannot have multiple type lists in an interface")
+				}
+				tlist = name
+				continue
+			}
+
 			typ := check.typ(f.Type)
 			sig, _ := typ.(*Signature)
 			if sig == nil {
@@ -531,6 +791,13 @@ func (check *Checker) interfaceType(ityp *Interface, iface *ast.InterfaceType, d
 				continue // ignore
 			}
 
+			// Always type-check method type parameters but complain if they are not enabled.
+			// (This extra check is needed here because interface method signatures don't have
+			// a receiver specification.)
+			if sig.tparams != nil {
+				check.errorf(f.Type.(*ast.FuncType).TParams, 0, "methods cannot have type parameters")
+			}
+
 			// use named receiver type if available (for better error messages)
 			var recvTyp Type = ityp
 			if def != nil {
@@ -542,25 +809,17 @@ func (check *Checker) interfaceType(ityp *Interface, iface *ast.InterfaceType, d
 			check.recordDef(name, m)
 			ityp.methods = append(ityp.methods, m)
 		} else {
-			// We have an embedded interface and f.Type is its
-			// (possibly qualified) embedded type name. Collect
-			// it if it's a valid interface.
-			typ := check.typ(f.Type)
-
-			utyp := under(typ)
-			if _, ok := utyp.(*Interface); !ok {
-				if utyp != Typ[Invalid] {
-					check.errorf(f.Type, _InvalidIfaceEmbed, "%s is not an interface", typ)
-				}
-				continue
-			}
-
-			ityp.embeddeds = append(ityp.embeddeds, typ)
+			// We have an embedded type. completeInterface will
+			// eventually verify that we have an interface.
+			ityp.embeddeds = append(ityp.embeddeds, check.typ(f.Type))
 			check.posMap[ityp] = append(check.posMap[ityp], f.Type.Pos())
 		}
 	}
 
-	if len(ityp.methods) == 0 && len(ityp.embeddeds) == 0 {
+	// type constraints
+	ityp.types = NewSum(check.collectTypeConstraints(iface.Pos(), types))
+
+	if len(ityp.methods) == 0 && ityp.types == nil && len(ityp.embeddeds) == 0 {
 		// empty interface
 		ityp.allMethods = markComplete
 		return
@@ -665,7 +924,7 @@ func (check *Checker) completeInterface(pos token.Pos, ityp *Interface) {
 					format = "%s is not an interface"
 				}
 				// TODO: correct error code.
-				check.errorf(atPos(pos), 0, format, typ)
+				check.errorf(atPos(pos), _InvalidIfaceEmbed, format, typ)
 			}
 			continue
 		}
@@ -729,7 +988,7 @@ func (a byUniqueTypeName) Less(i, j int) bool { return sortName(a[i]) < sortName
 func (a byUniqueTypeName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
 
 func sortName(t Type) string {
-	if named, _ := t.(*Named); named != nil {
+	if named := asNamed(t); named != nil {
 		return named.obj.Id()
 	}
 	return ""
@@ -798,7 +1057,7 @@ func (check *Checker) structType(styp *Struct, e *ast.StructType) {
 	}
 
 	for _, f := range list.List {
-		typ = check.typ(f.Type)
+		typ = check.varType(f.Type)
 		tag = check.tag(f.Tag)
 		if len(f.Names) > 0 {
 			// named fields
@@ -807,8 +1066,9 @@ func (check *Checker) structType(styp *Struct, e *ast.StructType) {
 			}
 		} else {
 			// embedded field
-			// spec: "An embedded type must be specified as a type name T or as a pointer
-			// to a non-interface type name *T, and T itself may not be a pointer type."
+			// spec: "An embedded type must be specified as a type name T or as a
+			// pointer to a non-interface type name *T, and T itself may not be a
+			// pointer type."
 			pos := f.Type.Pos()
 			name := embeddedFieldIdent(f.Type)
 			if name == nil {
@@ -818,37 +1078,37 @@ func (check *Checker) structType(styp *Struct, e *ast.StructType) {
 				addInvalid(name, pos)
 				continue
 			}
-			t, isPtr := deref(typ)
+			add(name, true, pos)
+
 			// Because we have a name, typ must be of the form T or *T, where T is the name
 			// of a (named or alias) type, and t (= deref(typ)) must be the type of T.
-			switch t := t.Underlying().(type) {
-			case *Basic:
-				if t == Typ[Invalid] {
-					// error was reported before
-					addInvalid(name, pos)
-					continue
-				}
+			// We must delay this check to the end because we don't want to instantiate
+			// (via under(t)) a possibly incomplete type.
 
-				// unsafe.Pointer is treated like a regular pointer
-				if t.kind == UnsafePointer {
-					check.errorf(f.Type, _InvalidPtrEmbed, "embedded field type cannot be unsafe.Pointer")
-					addInvalid(name, pos)
-					continue
-				}
-
-			case *Pointer:
-				check.errorf(f.Type, _InvalidPtrEmbed, "embedded field type cannot be a pointer")
-				addInvalid(name, pos)
-				continue
+			// for use in the closure below
+			embeddedTyp := typ
+			embeddedPos := f.Type
 
-			case *Interface:
-				if isPtr {
-					check.errorf(f.Type, _InvalidPtrEmbed, "embedded field type cannot be a pointer to an interface")
-					addInvalid(name, pos)
-					continue
+			check.atEnd(func() {
+				t, isPtr := deref(embeddedTyp)
+				switch t := optype(t).(type) {
+				case *Basic:
+					if t == Typ[Invalid] {
+						// error was reported before
+						return
+					}
+					// unsafe.Pointer is treated like a regular pointer
+					if t.kind == UnsafePointer {
+						check.errorf(embeddedPos, _InvalidPtrEmbed, "embedded field type cannot be unsafe.Pointer")
+					}
+				case *Pointer:
+					check.errorf(embeddedPos, _InvalidPtrEmbed, "embedded field type cannot be a pointer")
+				case *Interface:
+					if isPtr {
+						check.errorf(embeddedPos, _InvalidPtrEmbed, "embedded field type cannot be a pointer to an interface")
+					}
 				}
-			}
-			add(name, true, pos)
+			})
 		}
 	}
 
@@ -867,10 +1127,54 @@ func embeddedFieldIdent(e ast.Expr) *ast.Ident {
 		}
 	case *ast.SelectorExpr:
 		return e.Sel
+	case *ast.IndexExpr:
+		return embeddedFieldIdent(e.X)
+	case *ast.CallExpr:
+		if e.Brackets {
+			return embeddedFieldIdent(e.Fun)
+		}
 	}
 	return nil // invalid embedded field
 }
 
+func (check *Checker) collectTypeConstraints(pos token.Pos, types []ast.Expr) []Type {
+	list := make([]Type, 0, len(types)) // assume all types are correct
+	for _, texpr := range types {
+		if texpr == nil {
+			check.invalidAST(atPos(pos), "missing type constraint")
+			continue
+		}
+		typ := check.varType(texpr)
+		// A type constraint may be a predeclared type or a composite type composed
+		// of only predeclared types.
+		// TODO(gri) If we enable this again it also must run at the end.
+		const restricted = false
+		var why string
+		if restricted && !check.typeConstraint(typ, &why) {
+			check.errorf(texpr, 0, "invalid type constraint %s (%s)", typ, why)
+			continue
+		}
+		list = append(list, typ)
+	}
+
+	// Ensure that each type is only present once in the type list.  Types may be
+	// interfaces, which may not be complete yet. It's ok to do this check at the
+	// end because it's not a requirement for correctness of the code.
+	// Note: This is a quadratic algorithm, but type lists tend to be short.
+	check.atEnd(func() {
+		for i, t := range list {
+			if t := asInterface(t); t != nil {
+				check.completeInterface(types[i].Pos(), t)
+			}
+			if includes(list[:i], t) {
+				check.softErrorf(types[i], 0, "duplicate type %s in type list", t)
+			}
+		}
+	})
+
+	return list
+}
+
 // includes reports whether typ is in list.
 func includes(list []Type, typ Type) bool {
 	for _, e := range list {
@@ -880,3 +1184,59 @@ func includes(list []Type, typ Type) bool {
 	}
 	return false
 }
+
+// typeConstraint checks that typ may be used in a type list.
+// For now this just checks for the absence of defined (*Named) types.
+func (check *Checker) typeConstraint(typ Type, why *string) bool {
+	switch t := typ.(type) {
+	case *Basic:
+		// ok
+	case *Array:
+		return check.typeConstraint(t.elem, why)
+	case *Slice:
+		return check.typeConstraint(t.elem, why)
+	case *Struct:
+		for _, f := range t.fields {
+			if !check.typeConstraint(f.typ, why) {
+				return false
+			}
+		}
+	case *Pointer:
+		return check.typeConstraint(t.base, why)
+	case *Tuple:
+		if t == nil {
+			return true
+		}
+		for _, v := range t.vars {
+			if !check.typeConstraint(v.typ, why) {
+				return false
+			}
+		}
+	case *Signature:
+		if len(t.tparams) != 0 {
+			panic("type parameter in function type")
+		}
+		return (t.recv == nil || check.typeConstraint(t.recv.typ, why)) &&
+			check.typeConstraint(t.params, why) &&
+			check.typeConstraint(t.results, why)
+	case *Interface:
+		t.assertCompleteness()
+		for _, m := range t.allMethods {
+			if !check.typeConstraint(m.typ, why) {
+				return false
+			}
+		}
+	case *Map:
+		return check.typeConstraint(t.key, why) && check.typeConstraint(t.elem, why)
+	case *Chan:
+		return check.typeConstraint(t.elem, why)
+	case *Named:
+		*why = check.sprintf("contains defined type %s", t)
+		return false
+	case *TypeParam:
+		// ok, e.g.: func f (type T interface { type T }) ()
+	default:
+		unreachable()
+	}
+	return true
+}
-- 
GitLab


From d76cefed1f221e652d75764576f3be92571d9c82 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 6 Jan 2021 10:00:58 -0500
Subject: [PATCH 0438/2400] [dev.typeparams] go/types: remove disabled code
 related to type lists

This is a port of CL 281546 to go/types.

Change-Id: I6f3d6fa520672d91072f3b5d1a06201320422b57
Reviewed-on: https://go-review.googlesource.com/c/go/+/281992
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/typexpr.go | 68 +----------------------------------------
 1 file changed, 1 insertion(+), 67 deletions(-)

diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index 42d8f691d0..10d4973b2a 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -1144,17 +1144,7 @@ func (check *Checker) collectTypeConstraints(pos token.Pos, types []ast.Expr) []
 			check.invalidAST(atPos(pos), "missing type constraint")
 			continue
 		}
-		typ := check.varType(texpr)
-		// A type constraint may be a predeclared type or a composite type composed
-		// of only predeclared types.
-		// TODO(gri) If we enable this again it also must run at the end.
-		const restricted = false
-		var why string
-		if restricted && !check.typeConstraint(typ, &why) {
-			check.errorf(texpr, 0, "invalid type constraint %s (%s)", typ, why)
-			continue
-		}
-		list = append(list, typ)
+		list = append(list, check.varType(texpr))
 	}
 
 	// Ensure that each type is only present once in the type list.  Types may be
@@ -1184,59 +1174,3 @@ func includes(list []Type, typ Type) bool {
 	}
 	return false
 }
-
-// typeConstraint checks that typ may be used in a type list.
-// For now this just checks for the absence of defined (*Named) types.
-func (check *Checker) typeConstraint(typ Type, why *string) bool {
-	switch t := typ.(type) {
-	case *Basic:
-		// ok
-	case *Array:
-		return check.typeConstraint(t.elem, why)
-	case *Slice:
-		return check.typeConstraint(t.elem, why)
-	case *Struct:
-		for _, f := range t.fields {
-			if !check.typeConstraint(f.typ, why) {
-				return false
-			}
-		}
-	case *Pointer:
-		return check.typeConstraint(t.base, why)
-	case *Tuple:
-		if t == nil {
-			return true
-		}
-		for _, v := range t.vars {
-			if !check.typeConstraint(v.typ, why) {
-				return false
-			}
-		}
-	case *Signature:
-		if len(t.tparams) != 0 {
-			panic("type parameter in function type")
-		}
-		return (t.recv == nil || check.typeConstraint(t.recv.typ, why)) &&
-			check.typeConstraint(t.params, why) &&
-			check.typeConstraint(t.results, why)
-	case *Interface:
-		t.assertCompleteness()
-		for _, m := range t.allMethods {
-			if !check.typeConstraint(m.typ, why) {
-				return false
-			}
-		}
-	case *Map:
-		return check.typeConstraint(t.key, why) && check.typeConstraint(t.elem, why)
-	case *Chan:
-		return check.typeConstraint(t.elem, why)
-	case *Named:
-		*why = check.sprintf("contains defined type %s", t)
-		return false
-	case *TypeParam:
-		// ok, e.g.: func f (type T interface { type T }) ()
-	default:
-		unreachable()
-	}
-	return true
-}
-- 
GitLab


From 7e689f86e3928f15a54256cc5192e800354a577e Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 6 Jan 2021 12:37:21 -0500
Subject: [PATCH 0439/2400] [dev.typeparams] go/types: move use and useLHS to
 match dev.go2go

This is a pure code move to simplify the diff.

Change-Id: I56ce4d17ed9f003d79f748e267c46a17feefe301
Reviewed-on: https://go-review.googlesource.com/c/go/+/282192
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/call.go | 98 ++++++++++++++++++++++----------------------
 1 file changed, 49 insertions(+), 49 deletions(-)

diff --git a/src/go/types/call.go b/src/go/types/call.go
index 61a7f0926d..424ec902ff 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -100,55 +100,6 @@ func (check *Checker) call(x *operand, e *ast.CallExpr) exprKind {
 	}
 }
 
-// use type-checks each argument.
-// Useful to make sure expressions are evaluated
-// (and variables are "used") in the presence of other errors.
-// The arguments may be nil.
-func (check *Checker) use(arg ...ast.Expr) {
-	var x operand
-	for _, e := range arg {
-		// The nil check below is necessary since certain AST fields
-		// may legally be nil (e.g., the ast.SliceExpr.High field).
-		if e != nil {
-			check.rawExpr(&x, e, nil)
-		}
-	}
-}
-
-// useLHS is like use, but doesn't "use" top-level identifiers.
-// It should be called instead of use if the arguments are
-// expressions on the lhs of an assignment.
-// The arguments must not be nil.
-func (check *Checker) useLHS(arg ...ast.Expr) {
-	var x operand
-	for _, e := range arg {
-		// If the lhs is an identifier denoting a variable v, this assignment
-		// is not a 'use' of v. Remember current value of v.used and restore
-		// after evaluating the lhs via check.rawExpr.
-		var v *Var
-		var v_used bool
-		if ident, _ := unparen(e).(*ast.Ident); ident != nil {
-			// never type-check the blank name on the lhs
-			if ident.Name == "_" {
-				continue
-			}
-			if _, obj := check.scope.LookupParent(ident.Name, token.NoPos); obj != nil {
-				// It's ok to mark non-local variables, but ignore variables
-				// from other packages to avoid potential race conditions with
-				// dot-imported variables.
-				if w, _ := obj.(*Var); w != nil && w.pkg == check.pkg {
-					v = w
-					v_used = v.used
-				}
-			}
-		}
-		check.rawExpr(&x, e, nil)
-		if v != nil {
-			v.used = v_used // restore v.used
-		}
-	}
-}
-
 // useGetter is like use, but takes a getter instead of a list of expressions.
 // It should be called instead of use if a getter is present to avoid repeated
 // evaluation of the first argument (since the getter was likely obtained via
@@ -568,6 +519,55 @@ Error:
 	x.expr = e
 }
 
+// use type-checks each argument.
+// Useful to make sure expressions are evaluated
+// (and variables are "used") in the presence of other errors.
+// The arguments may be nil.
+func (check *Checker) use(arg ...ast.Expr) {
+	var x operand
+	for _, e := range arg {
+		// The nil check below is necessary since certain AST fields
+		// may legally be nil (e.g., the ast.SliceExpr.High field).
+		if e != nil {
+			check.rawExpr(&x, e, nil)
+		}
+	}
+}
+
+// useLHS is like use, but doesn't "use" top-level identifiers.
+// It should be called instead of use if the arguments are
+// expressions on the lhs of an assignment.
+// The arguments must not be nil.
+func (check *Checker) useLHS(arg ...ast.Expr) {
+	var x operand
+	for _, e := range arg {
+		// If the lhs is an identifier denoting a variable v, this assignment
+		// is not a 'use' of v. Remember current value of v.used and restore
+		// after evaluating the lhs via check.rawExpr.
+		var v *Var
+		var v_used bool
+		if ident, _ := unparen(e).(*ast.Ident); ident != nil {
+			// never type-check the blank name on the lhs
+			if ident.Name == "_" {
+				continue
+			}
+			if _, obj := check.scope.LookupParent(ident.Name, token.NoPos); obj != nil {
+				// It's ok to mark non-local variables, but ignore variables
+				// from other packages to avoid potential race conditions with
+				// dot-imported variables.
+				if w, _ := obj.(*Var); w != nil && w.pkg == check.pkg {
+					v = w
+					v_used = v.used
+				}
+			}
+		}
+		check.rawExpr(&x, e, nil)
+		if v != nil {
+			v.used = v_used // restore v.used
+		}
+	}
+}
+
 // instantiatedOperand reports an error of x is an uninstantiated (generic) type and sets x.typ to Typ[Invalid].
 func (check *Checker) instantiatedOperand(x *operand) {
 	if x.mode == typexpr && isGeneric(x.typ) {
-- 
GitLab


From b241938e04ed7171897390fdaefd3d3017a16a0b Mon Sep 17 00:00:00 2001
From: Baokun Lee <bk@golangcn.org>
Date: Tue, 29 Dec 2020 18:49:13 +0800
Subject: [PATCH 0440/2400] [dev.regabi] cmd/compile: fix some methods error
 text

Change-Id: Ie9b034efba30d66a869c5e991b60c76198fd330f
Reviewed-on: https://go-review.googlesource.com/c/go/+/279444
Run-TryBot: Baokun Lee <bk@golangcn.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/reflectdata/alg.go | 4 ++--
 src/cmd/compile/internal/staticdata/data.go | 2 +-
 src/cmd/compile/internal/types/alg.go       | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/reflectdata/alg.go b/src/cmd/compile/internal/reflectdata/alg.go
index d23ca6c7aa..d576053753 100644
--- a/src/cmd/compile/internal/reflectdata/alg.go
+++ b/src/cmd/compile/internal/reflectdata/alg.go
@@ -42,8 +42,8 @@ func eqCanPanic(t *types.Type) bool {
 	}
 }
 
-// AlgType is like algtype1, except it returns the fixed-width AMEMxx variants
-// instead of the general AMEM kind when possible.
+// AlgType returns the fixed-width AMEMxx variants instead of the general
+// AMEM kind when possible.
 func AlgType(t *types.Type) types.AlgKind {
 	a, _ := types.AlgType(t)
 	if a == types.AMEM {
diff --git a/src/cmd/compile/internal/staticdata/data.go b/src/cmd/compile/internal/staticdata/data.go
index 94fa6760a0..a2a844f940 100644
--- a/src/cmd/compile/internal/staticdata/data.go
+++ b/src/cmd/compile/internal/staticdata/data.go
@@ -276,7 +276,7 @@ func FuncLinksym(n *ir.Name) *obj.LSym {
 // the s·f stubs in s's package.
 func NeedFuncSym(s *types.Sym) {
 	if !base.Ctxt.Flag_dynlink {
-		base.Fatalf("makefuncsym dynlink")
+		base.Fatalf("NeedFuncSym: dynlink")
 	}
 	if s.IsBlank() {
 		return
diff --git a/src/cmd/compile/internal/types/alg.go b/src/cmd/compile/internal/types/alg.go
index f1a472cca5..6091ee249c 100644
--- a/src/cmd/compile/internal/types/alg.go
+++ b/src/cmd/compile/internal/types/alg.go
@@ -132,7 +132,7 @@ func AlgType(t *Type) (AlgKind, *Type) {
 		return ret, nil
 	}
 
-	base.Fatalf("algtype1: unexpected type %v", t)
+	base.Fatalf("algtype: unexpected type %v", t)
 	return 0, nil
 }
 
-- 
GitLab


From 934f9dc0efbae667c445684915676323b98b34d0 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 7 Jan 2021 12:57:15 -0800
Subject: [PATCH 0441/2400] [dev.typeparams] cmd/compile/internal/syntax: clean
 up node printing API
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Preparation for using the syntax printer as expression printer in types2.

- Introduced Form to control printing format
- Cleaned up/added String and ShortString convenience functions
- Implemented ShortForm format which prints … for non-empty
  function and composite literal bodies
- Added test to check write error handling

Change-Id: Ie86e46d766fb60fcf07ef643c7788b2ef440ffa8
Reviewed-on: https://go-review.googlesource.com/c/go/+/282552
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/syntax/dumper.go     |  8 +-
 .../compile/internal/syntax/parser_test.go    |  4 +-
 src/cmd/compile/internal/syntax/printer.go    | 80 ++++++++++++++-----
 .../compile/internal/syntax/printer_test.go   | 29 ++++++-
 4 files changed, 94 insertions(+), 27 deletions(-)

diff --git a/src/cmd/compile/internal/syntax/dumper.go b/src/cmd/compile/internal/syntax/dumper.go
index 01453d5a7a..d5247886da 100644
--- a/src/cmd/compile/internal/syntax/dumper.go
+++ b/src/cmd/compile/internal/syntax/dumper.go
@@ -26,7 +26,7 @@ func Fdump(w io.Writer, n Node) (err error) {
 
 	defer func() {
 		if e := recover(); e != nil {
-			err = e.(localError).err // re-panics if it's not a localError
+			err = e.(writeError).err // re-panics if it's not a writeError
 		}
 	}()
 
@@ -82,16 +82,16 @@ func (p *dumper) Write(data []byte) (n int, err error) {
 	return
 }
 
-// localError wraps locally caught errors so we can distinguish
+// writeError wraps locally caught write errors so we can distinguish
 // them from genuine panics which we don't want to return as errors.
-type localError struct {
+type writeError struct {
 	err error
 }
 
 // printf is a convenience wrapper that takes care of print errors.
 func (p *dumper) printf(format string, args ...interface{}) {
 	if _, err := fmt.Fprintf(p, format, args...); err != nil {
-		panic(localError{err})
+		panic(writeError{err})
 	}
 }
 
diff --git a/src/cmd/compile/internal/syntax/parser_test.go b/src/cmd/compile/internal/syntax/parser_test.go
index ea9e9acc83..340ca6bb6f 100644
--- a/src/cmd/compile/internal/syntax/parser_test.go
+++ b/src/cmd/compile/internal/syntax/parser_test.go
@@ -169,7 +169,7 @@ func walkDirs(t *testing.T, dir string, action func(string)) {
 
 func verifyPrint(t *testing.T, filename string, ast1 *File) {
 	var buf1 bytes.Buffer
-	_, err := Fprint(&buf1, ast1, true)
+	_, err := Fprint(&buf1, ast1, LineForm)
 	if err != nil {
 		panic(err)
 	}
@@ -181,7 +181,7 @@ func verifyPrint(t *testing.T, filename string, ast1 *File) {
 	}
 
 	var buf2 bytes.Buffer
-	_, err = Fprint(&buf2, ast2, true)
+	_, err = Fprint(&buf2, ast2, LineForm)
 	if err != nil {
 		panic(err)
 	}
diff --git a/src/cmd/compile/internal/syntax/printer.go b/src/cmd/compile/internal/syntax/printer.go
index c8bf59675a..0a60e1753d 100644
--- a/src/cmd/compile/internal/syntax/printer.go
+++ b/src/cmd/compile/internal/syntax/printer.go
@@ -13,19 +13,28 @@ import (
 	"strings"
 )
 
-// TODO(gri) Consider removing the linebreaks flag from this signature.
-// Its likely rarely used in common cases.
+// Form controls print formatting.
+type Form uint
 
-func Fprint(w io.Writer, x Node, linebreaks bool) (n int, err error) {
+const (
+	_         Form = iota // default
+	LineForm              // use spaces instead of linebreaks where possible
+	ShortForm             // like LineForm but print "…" for non-empty function or composite literal bodies
+)
+
+// Fprint prints node x to w in the specified form.
+// It returns the number of bytes written, and whether there was an error.
+func Fprint(w io.Writer, x Node, form Form) (n int, err error) {
 	p := printer{
 		output:     w,
-		linebreaks: linebreaks,
+		form:       form,
+		linebreaks: form == 0,
 	}
 
 	defer func() {
 		n = p.written
 		if e := recover(); e != nil {
-			err = e.(localError).err // re-panics if it's not a localError
+			err = e.(writeError).err // re-panics if it's not a writeError
 		}
 	}()
 
@@ -35,15 +44,20 @@ func Fprint(w io.Writer, x Node, linebreaks bool) (n int, err error) {
 	return
 }
 
-func String(n Node) string {
+func asString(n Node, form Form) string {
 	var buf bytes.Buffer
-	_, err := Fprint(&buf, n, false)
+	_, err := Fprint(&buf, n, form)
 	if err != nil {
-		panic(err) // TODO(gri) print something sensible into buf instead
+		fmt.Fprintf(&buf, "<<< ERROR: %s", err)
 	}
 	return buf.String()
 }
 
+// String and ShortString are convenience functions that print n in
+// LineForm or ShortForm respectively, and return the printed string.
+func String(n Node) string      { return asString(n, LineForm) }
+func ShortString(n Node) string { return asString(n, ShortForm) }
+
 type ctrlSymbol int
 
 const (
@@ -65,7 +79,8 @@ type whitespace struct {
 
 type printer struct {
 	output     io.Writer
-	written    int  // number of bytes written
+	written    int // number of bytes written
+	form       Form
 	linebreaks bool // print linebreaks instead of semis
 
 	indent  int // current indentation level
@@ -81,7 +96,7 @@ func (p *printer) write(data []byte) {
 	n, err := p.output.Write(data)
 	p.written += n
 	if err != nil {
-		panic(localError{err})
+		panic(writeError{err})
 	}
 }
 
@@ -355,17 +370,34 @@ func (p *printer) printRawNode(n Node) {
 		p.print(_Name, n.Value) // _Name requires actual value following immediately
 
 	case *FuncLit:
-		p.print(n.Type, blank, n.Body)
+		p.print(n.Type, blank)
+		if n.Body != nil {
+			if p.form == ShortForm {
+				p.print(_Lbrace)
+				if len(n.Body.List) > 0 {
+					p.print(_Name, "…")
+				}
+				p.print(_Rbrace)
+			} else {
+				p.print(n.Body)
+			}
+		}
 
 	case *CompositeLit:
 		if n.Type != nil {
 			p.print(n.Type)
 		}
 		p.print(_Lbrace)
-		if n.NKeys > 0 && n.NKeys == len(n.ElemList) {
-			p.printExprLines(n.ElemList)
+		if p.form == ShortForm {
+			if len(n.ElemList) > 0 {
+				p.print(_Name, "…")
+			}
 		} else {
-			p.printExprList(n.ElemList)
+			if n.NKeys > 0 && n.NKeys == len(n.ElemList) {
+				p.printExprLines(n.ElemList)
+			} else {
+				p.printExprList(n.ElemList)
+			}
 		}
 		p.print(_Rbrace)
 
@@ -450,9 +482,13 @@ func (p *printer) printRawNode(n Node) {
 		}
 		p.print(_Lbrace)
 		if len(n.FieldList) > 0 {
-			p.print(newline, indent)
-			p.printFieldList(n.FieldList, n.TagList)
-			p.print(outdent, newline)
+			if p.linebreaks {
+				p.print(newline, indent)
+				p.printFieldList(n.FieldList, n.TagList)
+				p.print(outdent, newline)
+			} else {
+				p.printFieldList(n.FieldList, n.TagList)
+			}
 		}
 		p.print(_Rbrace)
 
@@ -467,9 +503,13 @@ func (p *printer) printRawNode(n Node) {
 		}
 		p.print(_Lbrace)
 		if len(n.MethodList) > 0 {
-			p.print(newline, indent)
-			p.printMethodList(n.MethodList)
-			p.print(outdent, newline)
+			if p.linebreaks {
+				p.print(newline, indent)
+				p.printMethodList(n.MethodList)
+				p.print(outdent, newline)
+			} else {
+				p.printMethodList(n.MethodList)
+			}
 		}
 		p.print(_Rbrace)
 
diff --git a/src/cmd/compile/internal/syntax/printer_test.go b/src/cmd/compile/internal/syntax/printer_test.go
index 9f1f7e18cb..6c07fe0a26 100644
--- a/src/cmd/compile/internal/syntax/printer_test.go
+++ b/src/cmd/compile/internal/syntax/printer_test.go
@@ -25,11 +25,38 @@ func TestPrint(t *testing.T) {
 	}
 
 	if ast != nil {
-		Fprint(testOut(), ast, true)
+		Fprint(testOut(), ast, LineForm)
 		fmt.Println()
 	}
 }
 
+type shortBuffer struct {
+	buf []byte
+}
+
+func (w *shortBuffer) Write(data []byte) (n int, err error) {
+	w.buf = append(w.buf, data...)
+	n = len(data)
+	if len(w.buf) > 10 {
+		err = io.ErrShortBuffer
+	}
+	return
+}
+
+func TestPrintError(t *testing.T) {
+	const src = "package p; var x int"
+	ast, err := Parse(nil, strings.NewReader(src), nil, nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var buf shortBuffer
+	_, err = Fprint(&buf, ast, 0)
+	if err == nil || err != io.ErrShortBuffer {
+		t.Errorf("got err = %s, want %s", err, io.ErrShortBuffer)
+	}
+}
+
 var stringTests = []string{
 	"package p",
 	"package p; type _ int; type T1 = struct{}; type ( _ *struct{}; T2 = float32 )",
-- 
GitLab


From 0aede1205bdac5d3b938476a6e682190e835bb26 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 7 Jan 2021 12:58:31 -0800
Subject: [PATCH 0442/2400] [dev.typeparams] cmd/compile/internal/types2: use
 syntax printer to print expressions

The syntax package has a full-fledged node printer. Use that printer
to create the expression strings needed in error messages, and remove
the local (essentially) duplicate code for creating expression strings.

Change-Id: I03673e5e79b3c1470f8073ebbe840a90fd9053ec
Reviewed-on: https://go-review.googlesource.com/c/go/+/282553
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/types2/api.go        |   2 +-
 src/cmd/compile/internal/types2/api_test.go   |  10 +-
 .../compile/internal/types2/assignments.go    |   2 +-
 .../compile/internal/types2/builtins_test.go  |   2 +-
 src/cmd/compile/internal/types2/errors.go     |   2 +-
 src/cmd/compile/internal/types2/exprstring.go | 293 ------------------
 .../internal/types2/exprstring_test.go        |   9 +-
 src/cmd/compile/internal/types2/operand.go    |   2 +-
 8 files changed, 15 insertions(+), 307 deletions(-)
 delete mode 100644 src/cmd/compile/internal/types2/exprstring.go

diff --git a/src/cmd/compile/internal/types2/api.go b/src/cmd/compile/internal/types2/api.go
index c5c30babff..3348ccb900 100644
--- a/src/cmd/compile/internal/types2/api.go
+++ b/src/cmd/compile/internal/types2/api.go
@@ -379,7 +379,7 @@ func (init *Initializer) String() string {
 		buf.WriteString(lhs.Name())
 	}
 	buf.WriteString(" = ")
-	WriteExpr(&buf, init.Rhs)
+	syntax.Fprint(&buf, init.Rhs, syntax.ShortForm)
 	return buf.String()
 }
 
diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go
index 58d7df2f1d..c1327b179c 100644
--- a/src/cmd/compile/internal/types2/api_test.go
+++ b/src/cmd/compile/internal/types2/api_test.go
@@ -151,7 +151,7 @@ func TestValuesInfo(t *testing.T) {
 		// look for expression
 		var expr syntax.Expr
 		for e := range info.Types {
-			if ExprString(e) == test.expr {
+			if syntax.ShortString(e) == test.expr {
 				expr = e
 				break
 			}
@@ -306,7 +306,7 @@ func TestTypesInfo(t *testing.T) {
 		// look for expression type
 		var typ Type
 		for e, tv := range info.Types {
-			if ExprString(e) == test.expr {
+			if syntax.ShortString(e) == test.expr {
 				typ = tv.Type
 				break
 			}
@@ -454,7 +454,7 @@ func TestInferredInfo(t *testing.T) {
 			default:
 				panic(fmt.Sprintf("unexpected call expression type %T", call))
 			}
-			if ExprString(fun) == test.fun {
+			if syntax.ShortString(fun) == test.fun {
 				targs = inf.Targs
 				sig = inf.Sig
 				break
@@ -733,8 +733,8 @@ func TestPredicatesInfo(t *testing.T) {
 		// look for expression predicates
 		got := "<missing>"
 		for e, tv := range info.Types {
-			//println(name, ExprString(e))
-			if ExprString(e) == test.expr {
+			//println(name, syntax.ShortString(e))
+			if syntax.ShortString(e) == test.expr {
 				got = predString(tv)
 				break
 			}
diff --git a/src/cmd/compile/internal/types2/assignments.go b/src/cmd/compile/internal/types2/assignments.go
index b367aa76da..0fa9c6b8e6 100644
--- a/src/cmd/compile/internal/types2/assignments.go
+++ b/src/cmd/compile/internal/types2/assignments.go
@@ -197,7 +197,7 @@ func (check *Checker) assignVar(lhs syntax.Expr, x *operand) Type {
 			var op operand
 			check.expr(&op, sel.X)
 			if op.mode == mapindex {
-				check.errorf(&z, "cannot assign to struct field %s in map", ExprString(z.expr))
+				check.errorf(&z, "cannot assign to struct field %s in map", syntax.ShortString(z.expr))
 				return nil
 			}
 		}
diff --git a/src/cmd/compile/internal/types2/builtins_test.go b/src/cmd/compile/internal/types2/builtins_test.go
index 9f737bc9bb..0fc7c17d3e 100644
--- a/src/cmd/compile/internal/types2/builtins_test.go
+++ b/src/cmd/compile/internal/types2/builtins_test.go
@@ -176,7 +176,7 @@ func testBuiltinSignature(t *testing.T, name, src0, want string) {
 		// the recorded type for the built-in must match the wanted signature
 		typ := types[fun].Type
 		if typ == nil {
-			t.Errorf("%s: no type recorded for %s", src0, ExprString(fun))
+			t.Errorf("%s: no type recorded for %s", src0, syntax.ShortString(fun))
 			return
 		}
 		if got := typ.String(); got != want {
diff --git a/src/cmd/compile/internal/types2/errors.go b/src/cmd/compile/internal/types2/errors.go
index 941e7c6fd3..d74980253e 100644
--- a/src/cmd/compile/internal/types2/errors.go
+++ b/src/cmd/compile/internal/types2/errors.go
@@ -53,7 +53,7 @@ func (check *Checker) sprintf(format string, args ...interface{}) string {
 		case syntax.Pos:
 			arg = a.String()
 		case syntax.Expr:
-			arg = ExprString(a)
+			arg = syntax.ShortString(a)
 		case Object:
 			arg = ObjectString(a, check.qualifier)
 		case Type:
diff --git a/src/cmd/compile/internal/types2/exprstring.go b/src/cmd/compile/internal/types2/exprstring.go
deleted file mode 100644
index 0ec5d1338f..0000000000
--- a/src/cmd/compile/internal/types2/exprstring.go
+++ /dev/null
@@ -1,293 +0,0 @@
-// UNREVIEWED
-// Copyright 2013 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.
-
-// This file implements printing of expressions.
-
-package types2
-
-import (
-	"bytes"
-	"cmd/compile/internal/syntax"
-)
-
-// ExprString returns the (possibly shortened) string representation for x.
-// Shortened representations are suitable for user interfaces but may not
-// necessarily follow Go syntax.
-func ExprString(x syntax.Expr) string {
-	var buf bytes.Buffer
-	WriteExpr(&buf, x)
-	return buf.String()
-}
-
-// WriteExpr writes the (possibly shortened) string representation for x to buf.
-// Shortened representations are suitable for user interfaces but may not
-// necessarily follow Go syntax.
-func WriteExpr(buf *bytes.Buffer, x syntax.Expr) {
-	// The AST preserves source-level parentheses so there is
-	// no need to introduce them here to correct for different
-	// operator precedences. (This assumes that the AST was
-	// generated by a Go parser.)
-
-	// TODO(gri): This assumption is not correct - we need to recreate
-	//            parentheses in expressions.
-
-	switch x := x.(type) {
-	default:
-		buf.WriteString("(ast: bad expr)") // nil, syntax.BadExpr, syntax.KeyValueExpr
-
-	case *syntax.Name:
-		buf.WriteString(x.Value)
-
-	case *syntax.DotsType:
-		buf.WriteString("...")
-		if x.Elem != nil {
-			WriteExpr(buf, x.Elem)
-		}
-
-	case *syntax.BasicLit:
-		buf.WriteString(x.Value)
-
-	case *syntax.FuncLit:
-		WriteExpr(buf, x.Type)
-		if x.Body != nil && len(x.Body.List) > 0 {
-			buf.WriteString(" {…}") // shortened
-		} else {
-			buf.WriteString(" {}")
-		}
-
-	case *syntax.CompositeLit:
-		WriteExpr(buf, x.Type)
-		if len(x.ElemList) > 0 {
-			buf.WriteString("{…}") // shortened
-		} else {
-			buf.WriteString("{}")
-		}
-
-	case *syntax.ParenExpr:
-		buf.WriteByte('(')
-		WriteExpr(buf, x.X)
-		buf.WriteByte(')')
-
-	case *syntax.SelectorExpr:
-		WriteExpr(buf, x.X)
-		buf.WriteByte('.')
-		buf.WriteString(x.Sel.Value)
-
-	case *syntax.IndexExpr:
-		WriteExpr(buf, x.X)
-		buf.WriteByte('[')
-		WriteExpr(buf, x.Index) // x.Index may be a *ListExpr
-		buf.WriteByte(']')
-
-	case *syntax.SliceExpr:
-		WriteExpr(buf, x.X)
-		buf.WriteByte('[')
-		if x.Index[0] != nil {
-			WriteExpr(buf, x.Index[0])
-		}
-		buf.WriteByte(':')
-		if x.Index[1] != nil {
-			WriteExpr(buf, x.Index[1])
-		}
-		if x.Full {
-			buf.WriteByte(':')
-			if x.Index[2] != nil {
-				WriteExpr(buf, x.Index[2])
-			}
-		}
-		buf.WriteByte(']')
-
-	case *syntax.AssertExpr:
-		WriteExpr(buf, x.X)
-		buf.WriteString(".(")
-		WriteExpr(buf, x.Type)
-		buf.WriteByte(')')
-
-	case *syntax.CallExpr:
-		WriteExpr(buf, x.Fun)
-		buf.WriteByte('(')
-		writeExprList(buf, x.ArgList)
-		if x.HasDots {
-			buf.WriteString("...")
-		}
-		buf.WriteByte(')')
-
-	case *syntax.ListExpr:
-		writeExprList(buf, x.ElemList)
-
-	case *syntax.Operation:
-		// TODO(gri) This would be simpler if x.X == nil meant unary expression.
-		if x.Y == nil {
-			// unary expression
-			buf.WriteString(x.Op.String())
-			WriteExpr(buf, x.X)
-		} else {
-			// binary expression
-			WriteExpr(buf, x.X)
-			buf.WriteByte(' ')
-			buf.WriteString(x.Op.String())
-			buf.WriteByte(' ')
-			WriteExpr(buf, x.Y)
-		}
-
-		// case *ast.StarExpr:
-		// 	buf.WriteByte('*')
-		// 	WriteExpr(buf, x.X)
-
-		// case *ast.UnaryExpr:
-		// 	buf.WriteString(x.Op.String())
-		// 	WriteExpr(buf, x.X)
-
-		// case *ast.BinaryExpr:
-		// 	WriteExpr(buf, x.X)
-		// 	buf.WriteByte(' ')
-		// 	buf.WriteString(x.Op.String())
-		// 	buf.WriteByte(' ')
-		// 	WriteExpr(buf, x.Y)
-
-	case *syntax.ArrayType:
-		if x.Len == nil {
-			buf.WriteString("[...]")
-		} else {
-			buf.WriteByte('[')
-			WriteExpr(buf, x.Len)
-			buf.WriteByte(']')
-		}
-		WriteExpr(buf, x.Elem)
-
-	case *syntax.SliceType:
-		buf.WriteString("[]")
-		WriteExpr(buf, x.Elem)
-
-	case *syntax.StructType:
-		buf.WriteString("struct{")
-		writeFieldList(buf, x.FieldList, "; ", false)
-		buf.WriteByte('}')
-
-	case *syntax.FuncType:
-		buf.WriteString("func")
-		writeSigExpr(buf, x)
-
-	case *syntax.InterfaceType:
-		// separate type list types from method list
-		// TODO(gri) we can get rid of this extra code if writeExprList does the separation
-		var types []syntax.Expr
-		var methods []*syntax.Field
-		for _, f := range x.MethodList {
-			if f.Name != nil && f.Name.Value == "type" {
-				// type list type
-				types = append(types, f.Type)
-			} else {
-				// method or embedded interface
-				methods = append(methods, f)
-			}
-		}
-
-		buf.WriteString("interface{")
-		writeFieldList(buf, methods, "; ", true)
-		if len(types) > 0 {
-			if len(methods) > 0 {
-				buf.WriteString("; ")
-			}
-			buf.WriteString("type ")
-			writeExprList(buf, types)
-		}
-		buf.WriteByte('}')
-
-	case *syntax.MapType:
-		buf.WriteString("map[")
-		WriteExpr(buf, x.Key)
-		buf.WriteByte(']')
-		WriteExpr(buf, x.Value)
-
-	case *syntax.ChanType:
-		var s string
-		switch x.Dir {
-		case syntax.SendOnly:
-			s = "chan<- "
-		case syntax.RecvOnly:
-			s = "<-chan "
-		default:
-			s = "chan "
-		}
-		buf.WriteString(s)
-		if e, _ := x.Elem.(*syntax.ChanType); x.Dir != syntax.SendOnly && e != nil && e.Dir == syntax.RecvOnly {
-			// don't print chan (<-chan T) as chan <-chan T (but chan<- <-chan T is ok)
-			buf.WriteByte('(')
-			WriteExpr(buf, x.Elem)
-			buf.WriteByte(')')
-		} else {
-			WriteExpr(buf, x.Elem)
-		}
-	}
-}
-
-func writeSigExpr(buf *bytes.Buffer, sig *syntax.FuncType) {
-	buf.WriteByte('(')
-	writeFieldList(buf, sig.ParamList, ", ", false)
-	buf.WriteByte(')')
-
-	res := sig.ResultList
-	n := len(res)
-	if n == 0 {
-		// no result
-		return
-	}
-
-	buf.WriteByte(' ')
-	if n == 1 && res[0].Name == nil {
-		// single unnamed result
-		WriteExpr(buf, res[0].Type)
-		return
-	}
-
-	// multiple or named result(s)
-	buf.WriteByte('(')
-	writeFieldList(buf, res, ", ", false)
-	buf.WriteByte(')')
-}
-
-func writeFieldList(buf *bytes.Buffer, list []*syntax.Field, sep string, iface bool) {
-	for i := 0; i < len(list); {
-		f := list[i]
-		if i > 0 {
-			buf.WriteString(sep)
-		}
-
-		// if we don't have a name, we have an embedded type
-		if f.Name == nil {
-			WriteExpr(buf, f.Type)
-			i++
-			continue
-		}
-
-		// types of interface methods consist of signatures only
-		if sig, _ := f.Type.(*syntax.FuncType); sig != nil && iface {
-			buf.WriteString(f.Name.Value)
-			writeSigExpr(buf, sig)
-			i++
-			continue
-		}
-
-		// write the type only once for a sequence of fields with the same type
-		t := f.Type
-		buf.WriteString(f.Name.Value)
-		for i++; i < len(list) && list[i].Type == t; i++ {
-			buf.WriteString(", ")
-			buf.WriteString(list[i].Name.Value)
-		}
-		buf.WriteByte(' ')
-		WriteExpr(buf, t)
-	}
-}
-
-func writeExprList(buf *bytes.Buffer, list []syntax.Expr) {
-	for i, x := range list {
-		if i > 0 {
-			buf.WriteString(", ")
-		}
-		WriteExpr(buf, x)
-	}
-}
diff --git a/src/cmd/compile/internal/types2/exprstring_test.go b/src/cmd/compile/internal/types2/exprstring_test.go
index efb7c308b7..39e1354eac 100644
--- a/src/cmd/compile/internal/types2/exprstring_test.go
+++ b/src/cmd/compile/internal/types2/exprstring_test.go
@@ -9,9 +9,9 @@ import (
 	"testing"
 
 	"cmd/compile/internal/syntax"
-	. "cmd/compile/internal/types2"
 )
 
+// TODO(gri) move these tests into syntax package
 var testExprs = []testEntry{
 	// basic type literals
 	dup("x"),
@@ -24,8 +24,9 @@ var testExprs = []testEntry{
 	dup("`bar`"),
 
 	// func and composite literals
-	{"func(){}", "func() {}"},
-	{"func(x int) complex128 {}", "func(x int) complex128 {}"},
+	dup("func() {}"),
+	dup("[]int{}"),
+	{"func(x int) complex128 { return 0 }", "func(x int) complex128 {…}"},
 	{"[]int{1, 2, 3}", "[]int{…}"},
 
 	// non-type expressions
@@ -90,7 +91,7 @@ func TestExprString(t *testing.T) {
 			continue
 		}
 		x := f.DeclList[0].(*syntax.VarDecl).Values
-		if got := ExprString(x); got != test.str {
+		if got := syntax.ShortString(x); got != test.str {
 			t.Errorf("%s: got %s, want %s", test.src, got, test.str)
 		}
 	}
diff --git a/src/cmd/compile/internal/types2/operand.go b/src/cmd/compile/internal/types2/operand.go
index 0a19760423..ab4a7eb4f3 100644
--- a/src/cmd/compile/internal/types2/operand.go
+++ b/src/cmd/compile/internal/types2/operand.go
@@ -110,7 +110,7 @@ func operandString(x *operand, qf Qualifier) string {
 
 	var expr string
 	if x.expr != nil {
-		expr = ExprString(x.expr)
+		expr = syntax.ShortString(x.expr)
 	} else {
 		switch x.mode {
 		case builtin:
-- 
GitLab


From 7903214fcc52a53a7749b4634eb9e940c27ffe75 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 7 Jan 2021 17:20:55 -0800
Subject: [PATCH 0443/2400] [dev.typeparams] cmd/compile/internal/syntax: add
 ShortString tests

This CL moves the exprstring_test.go from the types2
package into the syntax package (which contains the
actual ShortString function). The code is mostly un-
changed but for the updated TestShortString function.

Change-Id: Ib39e3181e643fc0ac96ddf144a3114893a50c2fc
Reviewed-on: https://go-review.googlesource.com/c/go/+/282554
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 .../compile/internal/syntax/printer_test.go   | 87 ++++++++++++++++
 .../internal/types2/exprstring_test.go        | 98 -------------------
 2 files changed, 87 insertions(+), 98 deletions(-)
 delete mode 100644 src/cmd/compile/internal/types2/exprstring_test.go

diff --git a/src/cmd/compile/internal/syntax/printer_test.go b/src/cmd/compile/internal/syntax/printer_test.go
index 6c07fe0a26..e83e9c1b2c 100644
--- a/src/cmd/compile/internal/syntax/printer_test.go
+++ b/src/cmd/compile/internal/syntax/printer_test.go
@@ -96,3 +96,90 @@ func testOut() io.Writer {
 	}
 	return ioutil.Discard
 }
+
+func dup(s string) [2]string { return [2]string{s, s} }
+
+var exprTests = [][2]string{
+	// basic type literals
+	dup("x"),
+	dup("true"),
+	dup("42"),
+	dup("3.1415"),
+	dup("2.71828i"),
+	dup(`'a'`),
+	dup(`"foo"`),
+	dup("`bar`"),
+
+	// func and composite literals
+	dup("func() {}"),
+	dup("[]int{}"),
+	{"func(x int) complex128 { return 0 }", "func(x int) complex128 {…}"},
+	{"[]int{1, 2, 3}", "[]int{…}"},
+
+	// non-type expressions
+	dup("(x)"),
+	dup("x.f"),
+	dup("a[i]"),
+
+	dup("s[:]"),
+	dup("s[i:]"),
+	dup("s[:j]"),
+	dup("s[i:j]"),
+	dup("s[:j:k]"),
+	dup("s[i:j:k]"),
+
+	dup("x.(T)"),
+
+	dup("x.([10]int)"),
+	dup("x.([...]int)"),
+
+	dup("x.(struct{})"),
+	dup("x.(struct{x int; y, z float32; E})"),
+
+	dup("x.(func())"),
+	dup("x.(func(x int))"),
+	dup("x.(func() int)"),
+	dup("x.(func(x, y int, z float32) (r int))"),
+	dup("x.(func(a, b, c int))"),
+	dup("x.(func(x ...T))"),
+
+	dup("x.(interface{})"),
+	dup("x.(interface{m(); n(x int); E})"),
+	dup("x.(interface{m(); n(x int) T; E; F})"),
+
+	dup("x.(map[K]V)"),
+
+	dup("x.(chan E)"),
+	dup("x.(<-chan E)"),
+	dup("x.(chan<- chan int)"),
+	dup("x.(chan<- <-chan int)"),
+	dup("x.(<-chan chan int)"),
+	dup("x.(chan (<-chan int))"),
+
+	dup("f()"),
+	dup("f(x)"),
+	dup("int(x)"),
+	dup("f(x, x + y)"),
+	dup("f(s...)"),
+	dup("f(a, s...)"),
+
+	dup("*x"),
+	dup("&x"),
+	dup("x + y"),
+	dup("x + y << (2 * s)"),
+}
+
+func TestShortString(t *testing.T) {
+	for _, test := range exprTests {
+		src := "package p; var _ = " + test[0]
+		ast, err := Parse(nil, strings.NewReader(src), nil, nil, 0)
+		if err != nil {
+			t.Errorf("%s: %s", test[0], err)
+			continue
+		}
+		x := ast.DeclList[0].(*VarDecl).Values
+		if got := ShortString(x); got != test[1] {
+			t.Errorf("%s: got %s, want %s", test[0], got, test[1])
+		}
+	}
+}
diff --git a/src/cmd/compile/internal/types2/exprstring_test.go b/src/cmd/compile/internal/types2/exprstring_test.go
deleted file mode 100644
index 39e1354eac..0000000000
--- a/src/cmd/compile/internal/types2/exprstring_test.go
+++ /dev/null
@@ -1,98 +0,0 @@
-// UNREVIEWED
-// Copyright 2013 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 types2_test
-
-import (
-	"testing"
-
-	"cmd/compile/internal/syntax"
-)
-
-// TODO(gri) move these tests into syntax package
-var testExprs = []testEntry{
-	// basic type literals
-	dup("x"),
-	dup("true"),
-	dup("42"),
-	dup("3.1415"),
-	dup("2.71828i"),
-	dup(`'a'`),
-	dup(`"foo"`),
-	dup("`bar`"),
-
-	// func and composite literals
-	dup("func() {}"),
-	dup("[]int{}"),
-	{"func(x int) complex128 { return 0 }", "func(x int) complex128 {…}"},
-	{"[]int{1, 2, 3}", "[]int{…}"},
-
-	// non-type expressions
-	dup("(x)"),
-	dup("x.f"),
-	dup("a[i]"),
-
-	dup("s[:]"),
-	dup("s[i:]"),
-	dup("s[:j]"),
-	dup("s[i:j]"),
-	dup("s[:j:k]"),
-	dup("s[i:j:k]"),
-
-	dup("x.(T)"),
-
-	dup("x.([10]int)"),
-	dup("x.([...]int)"),
-
-	dup("x.(struct{})"),
-	dup("x.(struct{x int; y, z float32; E})"),
-
-	dup("x.(func())"),
-	dup("x.(func(x int))"),
-	dup("x.(func() int)"),
-	dup("x.(func(x, y int, z float32) (r int))"),
-	dup("x.(func(a, b, c int))"),
-	dup("x.(func(x ...T))"),
-
-	dup("x.(interface{})"),
-	dup("x.(interface{m(); n(x int); E})"),
-	dup("x.(interface{m(); n(x int) T; E; F})"),
-
-	dup("x.(map[K]V)"),
-
-	dup("x.(chan E)"),
-	dup("x.(<-chan E)"),
-	dup("x.(chan<- chan int)"),
-	dup("x.(chan<- <-chan int)"),
-	dup("x.(<-chan chan int)"),
-	dup("x.(chan (<-chan int))"),
-
-	dup("f()"),
-	dup("f(x)"),
-	dup("int(x)"),
-	dup("f(x, x + y)"),
-	dup("f(s...)"),
-	dup("f(a, s...)"),
-
-	dup("*x"),
-	dup("&x"),
-	dup("x + y"),
-	dup("x + y << (2 * s)"),
-}
-
-func TestExprString(t *testing.T) {
-	for _, test := range testExprs {
-		src := "package p; var _ = " + test.src
-		f, err := parseSrc("expr", src)
-		if err != nil {
-			t.Errorf("%s: %s", test.src, err)
-			continue
-		}
-		x := f.DeclList[0].(*syntax.VarDecl).Values
-		if got := syntax.ShortString(x); got != test.str {
-			t.Errorf("%s: got %s, want %s", test.src, got, test.str)
-		}
-	}
-}
-- 
GitLab


From d017a1b64951d43b009c18454443025cbc9373e1 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 7 Jan 2021 17:38:12 -0800
Subject: [PATCH 0444/2400] [dev.typeparams] cmd/compile/internal/syntax: add
 Walk node vistor from types2

This moves the Walk visitor from the types2 to the syntax
package. There are no changes but for package name adjustments.
Preparation for a more full-fledged node visitor.

Change-Id: I95217e27ff943ac58a7638fb8d1cd347d0d554b0
Reviewed-on: https://go-review.googlesource.com/c/go/+/282556
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 .../internal/{types2 => syntax}/walk.go       | 122 +++++++++---------
 .../compile/internal/types2/resolver_test.go  |   6 +-
 2 files changed, 61 insertions(+), 67 deletions(-)
 rename src/cmd/compile/internal/{types2 => syntax}/walk.go (67%)

diff --git a/src/cmd/compile/internal/types2/walk.go b/src/cmd/compile/internal/syntax/walk.go
similarity index 67%
rename from src/cmd/compile/internal/types2/walk.go
rename to src/cmd/compile/internal/syntax/walk.go
index 18cfb28ade..418b26d674 100644
--- a/src/cmd/compile/internal/types2/walk.go
+++ b/src/cmd/compile/internal/syntax/walk.go
@@ -1,18 +1,12 @@
-// UNREVIEWED
 // Copyright 2012 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.
 
 // This file implements syntax tree walking.
-// TODO(gri) A more general API should probably be in
-//           the syntax package.
 
-package types2
+package syntax
 
-import (
-	"cmd/compile/internal/syntax"
-	"fmt"
-)
+import "fmt"
 
 // Walk traverses a syntax in pre-order: It starts by calling f(root);
 // root must not be nil. If f returns false (== "continue"), Walk calls
@@ -23,17 +17,17 @@ import (
 // field lists such as type T in "a, b, c T"). Such shared nodes are
 // walked multiple times.
 // TODO(gri) Revisit this design. It may make sense to walk those nodes
-//           only once. A place where this matters is TestResolveIdents.
-func Walk(root syntax.Node, f func(syntax.Node) bool) {
+//           only once. A place where this matters is types2.TestResolveIdents.
+func Walk(root Node, f func(Node) bool) {
 	w := walker{f}
 	w.node(root)
 }
 
 type walker struct {
-	f func(syntax.Node) bool
+	f func(Node) bool
 }
 
-func (w *walker) node(n syntax.Node) {
+func (w *walker) node(n Node) {
 	if n == nil {
 		panic("invalid syntax tree: nil node")
 	}
@@ -44,18 +38,18 @@ func (w *walker) node(n syntax.Node) {
 
 	switch n := n.(type) {
 	// packages
-	case *syntax.File:
+	case *File:
 		w.node(n.PkgName)
 		w.declList(n.DeclList)
 
 	// declarations
-	case *syntax.ImportDecl:
+	case *ImportDecl:
 		if n.LocalPkgName != nil {
 			w.node(n.LocalPkgName)
 		}
 		w.node(n.Path)
 
-	case *syntax.ConstDecl:
+	case *ConstDecl:
 		w.nameList(n.NameList)
 		if n.Type != nil {
 			w.node(n.Type)
@@ -64,12 +58,12 @@ func (w *walker) node(n syntax.Node) {
 			w.node(n.Values)
 		}
 
-	case *syntax.TypeDecl:
+	case *TypeDecl:
 		w.node(n.Name)
 		w.fieldList(n.TParamList)
 		w.node(n.Type)
 
-	case *syntax.VarDecl:
+	case *VarDecl:
 		w.nameList(n.NameList)
 		if n.Type != nil {
 			w.node(n.Type)
@@ -78,7 +72,7 @@ func (w *walker) node(n syntax.Node) {
 			w.node(n.Values)
 		}
 
-	case *syntax.FuncDecl:
+	case *FuncDecl:
 		if n.Recv != nil {
 			w.node(n.Recv)
 		}
@@ -90,36 +84,36 @@ func (w *walker) node(n syntax.Node) {
 		}
 
 	// expressions
-	case *syntax.BadExpr: // nothing to do
-	case *syntax.Name:
-	case *syntax.BasicLit: // nothing to do
+	case *BadExpr: // nothing to do
+	case *Name: // nothing to do
+	case *BasicLit: // nothing to do
 
-	case *syntax.CompositeLit:
+	case *CompositeLit:
 		if n.Type != nil {
 			w.node(n.Type)
 		}
 		w.exprList(n.ElemList)
 
-	case *syntax.KeyValueExpr:
+	case *KeyValueExpr:
 		w.node(n.Key)
 		w.node(n.Value)
 
-	case *syntax.FuncLit:
+	case *FuncLit:
 		w.node(n.Type)
 		w.node(n.Body)
 
-	case *syntax.ParenExpr:
+	case *ParenExpr:
 		w.node(n.X)
 
-	case *syntax.SelectorExpr:
+	case *SelectorExpr:
 		w.node(n.X)
 		w.node(n.Sel)
 
-	case *syntax.IndexExpr:
+	case *IndexExpr:
 		w.node(n.X)
 		w.node(n.Index)
 
-	case *syntax.SliceExpr:
+	case *SliceExpr:
 		w.node(n.X)
 		for _, x := range n.Index {
 			if x != nil {
@@ -127,43 +121,43 @@ func (w *walker) node(n syntax.Node) {
 			}
 		}
 
-	case *syntax.AssertExpr:
+	case *AssertExpr:
 		w.node(n.X)
 		w.node(n.Type)
 
-	case *syntax.TypeSwitchGuard:
+	case *TypeSwitchGuard:
 		if n.Lhs != nil {
 			w.node(n.Lhs)
 		}
 		w.node(n.X)
 
-	case *syntax.Operation:
+	case *Operation:
 		w.node(n.X)
 		if n.Y != nil {
 			w.node(n.Y)
 		}
 
-	case *syntax.CallExpr:
+	case *CallExpr:
 		w.node(n.Fun)
 		w.exprList(n.ArgList)
 
-	case *syntax.ListExpr:
+	case *ListExpr:
 		w.exprList(n.ElemList)
 
 	// types
-	case *syntax.ArrayType:
+	case *ArrayType:
 		if n.Len != nil {
 			w.node(n.Len)
 		}
 		w.node(n.Elem)
 
-	case *syntax.SliceType:
+	case *SliceType:
 		w.node(n.Elem)
 
-	case *syntax.DotsType:
+	case *DotsType:
 		w.node(n.Elem)
 
-	case *syntax.StructType:
+	case *StructType:
 		w.fieldList(n.FieldList)
 		for _, t := range n.TagList {
 			if t != nil {
@@ -171,65 +165,65 @@ func (w *walker) node(n syntax.Node) {
 			}
 		}
 
-	case *syntax.Field:
+	case *Field:
 		if n.Name != nil {
 			w.node(n.Name)
 		}
 		w.node(n.Type)
 
-	case *syntax.InterfaceType:
+	case *InterfaceType:
 		w.fieldList(n.MethodList)
 
-	case *syntax.FuncType:
+	case *FuncType:
 		w.fieldList(n.ParamList)
 		w.fieldList(n.ResultList)
 
-	case *syntax.MapType:
+	case *MapType:
 		w.node(n.Key)
 		w.node(n.Value)
 
-	case *syntax.ChanType:
+	case *ChanType:
 		w.node(n.Elem)
 
 	// statements
-	case *syntax.EmptyStmt: // nothing to do
+	case *EmptyStmt: // nothing to do
 
-	case *syntax.LabeledStmt:
+	case *LabeledStmt:
 		w.node(n.Label)
 		w.node(n.Stmt)
 
-	case *syntax.BlockStmt:
+	case *BlockStmt:
 		w.stmtList(n.List)
 
-	case *syntax.ExprStmt:
+	case *ExprStmt:
 		w.node(n.X)
 
-	case *syntax.SendStmt:
+	case *SendStmt:
 		w.node(n.Chan)
 		w.node(n.Value)
 
-	case *syntax.DeclStmt:
+	case *DeclStmt:
 		w.declList(n.DeclList)
 
-	case *syntax.AssignStmt:
+	case *AssignStmt:
 		w.node(n.Lhs)
 		w.node(n.Rhs)
 
-	case *syntax.BranchStmt:
+	case *BranchStmt:
 		if n.Label != nil {
 			w.node(n.Label)
 		}
 		// Target points to nodes elsewhere in the syntax tree
 
-	case *syntax.CallStmt:
+	case *CallStmt:
 		w.node(n.Call)
 
-	case *syntax.ReturnStmt:
+	case *ReturnStmt:
 		if n.Results != nil {
 			w.node(n.Results)
 		}
 
-	case *syntax.IfStmt:
+	case *IfStmt:
 		if n.Init != nil {
 			w.node(n.Init)
 		}
@@ -239,7 +233,7 @@ func (w *walker) node(n syntax.Node) {
 			w.node(n.Else)
 		}
 
-	case *syntax.ForStmt:
+	case *ForStmt:
 		if n.Init != nil {
 			w.node(n.Init)
 		}
@@ -251,7 +245,7 @@ func (w *walker) node(n syntax.Node) {
 		}
 		w.node(n.Body)
 
-	case *syntax.SwitchStmt:
+	case *SwitchStmt:
 		if n.Init != nil {
 			w.node(n.Init)
 		}
@@ -262,25 +256,25 @@ func (w *walker) node(n syntax.Node) {
 			w.node(s)
 		}
 
-	case *syntax.SelectStmt:
+	case *SelectStmt:
 		for _, s := range n.Body {
 			w.node(s)
 		}
 
 	// helper nodes
-	case *syntax.RangeClause:
+	case *RangeClause:
 		if n.Lhs != nil {
 			w.node(n.Lhs)
 		}
 		w.node(n.X)
 
-	case *syntax.CaseClause:
+	case *CaseClause:
 		if n.Cases != nil {
 			w.node(n.Cases)
 		}
 		w.stmtList(n.Body)
 
-	case *syntax.CommClause:
+	case *CommClause:
 		if n.Comm != nil {
 			w.node(n.Comm)
 		}
@@ -291,31 +285,31 @@ func (w *walker) node(n syntax.Node) {
 	}
 }
 
-func (w *walker) declList(list []syntax.Decl) {
+func (w *walker) declList(list []Decl) {
 	for _, n := range list {
 		w.node(n)
 	}
 }
 
-func (w *walker) exprList(list []syntax.Expr) {
+func (w *walker) exprList(list []Expr) {
 	for _, n := range list {
 		w.node(n)
 	}
 }
 
-func (w *walker) stmtList(list []syntax.Stmt) {
+func (w *walker) stmtList(list []Stmt) {
 	for _, n := range list {
 		w.node(n)
 	}
 }
 
-func (w *walker) nameList(list []*syntax.Name) {
+func (w *walker) nameList(list []*Name) {
 	for _, n := range list {
 		w.node(n)
 	}
 }
 
-func (w *walker) fieldList(list []*syntax.Field) {
+func (w *walker) fieldList(list []*Field) {
 	for _, n := range list {
 		w.node(n)
 	}
diff --git a/src/cmd/compile/internal/types2/resolver_test.go b/src/cmd/compile/internal/types2/resolver_test.go
index cdfdba6b43..983e8ec4d6 100644
--- a/src/cmd/compile/internal/types2/resolver_test.go
+++ b/src/cmd/compile/internal/types2/resolver_test.go
@@ -144,7 +144,7 @@ func TestResolveIdents(t *testing.T) {
 
 	// check that qualified identifiers are resolved
 	for _, f := range files {
-		Walk(f, func(n syntax.Node) bool {
+		syntax.Walk(f, func(n syntax.Node) bool {
 			if s, ok := n.(*syntax.SelectorExpr); ok {
 				if x, ok := s.X.(*syntax.Name); ok {
 					obj := uses[x]
@@ -172,13 +172,13 @@ func TestResolveIdents(t *testing.T) {
 
 	// Check that each identifier in the source is found in uses or defs or both.
 	// We need the foundUses/Defs maps (rather then just deleting the found objects
-	// from the uses and defs maps) because Walk traverses shared nodes multiple
+	// from the uses and defs maps) because syntax.Walk traverses shared nodes multiple
 	// times (e.g. types in field lists such as "a, b, c int").
 	foundUses := make(map[*syntax.Name]bool)
 	foundDefs := make(map[*syntax.Name]bool)
 	var both []string
 	for _, f := range files {
-		Walk(f, func(n syntax.Node) bool {
+		syntax.Walk(f, func(n syntax.Node) bool {
 			if x, ok := n.(*syntax.Name); ok {
 				var objects int
 				if _, found := uses[x]; found {
-- 
GitLab


From 822aeacd9ed0630f84552d3120a12ddaa65b23cc Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Fri, 8 Jan 2021 10:29:11 -0800
Subject: [PATCH 0445/2400] [dev.typeparams] cmd/compile/internal/syntax:
 remove ShortString, use String instead

Follow-up on feedback by mdempsky@ in https://golang.org/cl/282552 .

Change-Id: I1e5bb2d67cc8ae29fed100b87d18a33b3e2069eb
Reviewed-on: https://go-review.googlesource.com/c/go/+/282672
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/syntax/printer.go       | 11 ++++-------
 src/cmd/compile/internal/syntax/printer_test.go  |  2 +-
 src/cmd/compile/internal/types2/api_test.go      | 10 +++++-----
 src/cmd/compile/internal/types2/assignments.go   |  2 +-
 src/cmd/compile/internal/types2/builtins_test.go |  2 +-
 src/cmd/compile/internal/types2/errors.go        |  2 +-
 src/cmd/compile/internal/types2/operand.go       |  2 +-
 7 files changed, 14 insertions(+), 17 deletions(-)

diff --git a/src/cmd/compile/internal/syntax/printer.go b/src/cmd/compile/internal/syntax/printer.go
index 0a60e1753d..161eb0d092 100644
--- a/src/cmd/compile/internal/syntax/printer.go
+++ b/src/cmd/compile/internal/syntax/printer.go
@@ -44,20 +44,17 @@ func Fprint(w io.Writer, x Node, form Form) (n int, err error) {
 	return
 }
 
-func asString(n Node, form Form) string {
+// String is a convenience functions that prints n in ShortForm
+// and returns the printed string.
+func String(n Node) string {
 	var buf bytes.Buffer
-	_, err := Fprint(&buf, n, form)
+	_, err := Fprint(&buf, n, ShortForm)
 	if err != nil {
 		fmt.Fprintf(&buf, "<<< ERROR: %s", err)
 	}
 	return buf.String()
 }
 
-// String and ShortString are convenience functions that print n in
-// LineForm or ShortForm respectively, and return the printed string.
-func String(n Node) string      { return asString(n, LineForm) }
-func ShortString(n Node) string { return asString(n, ShortForm) }
-
 type ctrlSymbol int
 
 const (
diff --git a/src/cmd/compile/internal/syntax/printer_test.go b/src/cmd/compile/internal/syntax/printer_test.go
index e83e9c1b2c..bcae815a46 100644
--- a/src/cmd/compile/internal/syntax/printer_test.go
+++ b/src/cmd/compile/internal/syntax/printer_test.go
@@ -178,7 +178,7 @@ func TestShortString(t *testing.T) {
 			continue
 		}
 		x := ast.DeclList[0].(*VarDecl).Values
-		if got := ShortString(x); got != test[1] {
+		if got := String(x); got != test[1] {
 			t.Errorf("%s: got %s, want %s", test[0], got, test[1])
 		}
 	}
diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go
index c1327b179c..d9647b9432 100644
--- a/src/cmd/compile/internal/types2/api_test.go
+++ b/src/cmd/compile/internal/types2/api_test.go
@@ -151,7 +151,7 @@ func TestValuesInfo(t *testing.T) {
 		// look for expression
 		var expr syntax.Expr
 		for e := range info.Types {
-			if syntax.ShortString(e) == test.expr {
+			if syntax.String(e) == test.expr {
 				expr = e
 				break
 			}
@@ -306,7 +306,7 @@ func TestTypesInfo(t *testing.T) {
 		// look for expression type
 		var typ Type
 		for e, tv := range info.Types {
-			if syntax.ShortString(e) == test.expr {
+			if syntax.String(e) == test.expr {
 				typ = tv.Type
 				break
 			}
@@ -454,7 +454,7 @@ func TestInferredInfo(t *testing.T) {
 			default:
 				panic(fmt.Sprintf("unexpected call expression type %T", call))
 			}
-			if syntax.ShortString(fun) == test.fun {
+			if syntax.String(fun) == test.fun {
 				targs = inf.Targs
 				sig = inf.Sig
 				break
@@ -733,8 +733,8 @@ func TestPredicatesInfo(t *testing.T) {
 		// look for expression predicates
 		got := "<missing>"
 		for e, tv := range info.Types {
-			//println(name, syntax.ShortString(e))
-			if syntax.ShortString(e) == test.expr {
+			//println(name, syntax.String(e))
+			if syntax.String(e) == test.expr {
 				got = predString(tv)
 				break
 			}
diff --git a/src/cmd/compile/internal/types2/assignments.go b/src/cmd/compile/internal/types2/assignments.go
index 0fa9c6b8e6..3238b3ac37 100644
--- a/src/cmd/compile/internal/types2/assignments.go
+++ b/src/cmd/compile/internal/types2/assignments.go
@@ -197,7 +197,7 @@ func (check *Checker) assignVar(lhs syntax.Expr, x *operand) Type {
 			var op operand
 			check.expr(&op, sel.X)
 			if op.mode == mapindex {
-				check.errorf(&z, "cannot assign to struct field %s in map", syntax.ShortString(z.expr))
+				check.errorf(&z, "cannot assign to struct field %s in map", syntax.String(z.expr))
 				return nil
 			}
 		}
diff --git a/src/cmd/compile/internal/types2/builtins_test.go b/src/cmd/compile/internal/types2/builtins_test.go
index 0fc7c17d3e..35c38518f6 100644
--- a/src/cmd/compile/internal/types2/builtins_test.go
+++ b/src/cmd/compile/internal/types2/builtins_test.go
@@ -176,7 +176,7 @@ func testBuiltinSignature(t *testing.T, name, src0, want string) {
 		// the recorded type for the built-in must match the wanted signature
 		typ := types[fun].Type
 		if typ == nil {
-			t.Errorf("%s: no type recorded for %s", src0, syntax.ShortString(fun))
+			t.Errorf("%s: no type recorded for %s", src0, syntax.String(fun))
 			return
 		}
 		if got := typ.String(); got != want {
diff --git a/src/cmd/compile/internal/types2/errors.go b/src/cmd/compile/internal/types2/errors.go
index d74980253e..62b1d39d83 100644
--- a/src/cmd/compile/internal/types2/errors.go
+++ b/src/cmd/compile/internal/types2/errors.go
@@ -53,7 +53,7 @@ func (check *Checker) sprintf(format string, args ...interface{}) string {
 		case syntax.Pos:
 			arg = a.String()
 		case syntax.Expr:
-			arg = syntax.ShortString(a)
+			arg = syntax.String(a)
 		case Object:
 			arg = ObjectString(a, check.qualifier)
 		case Type:
diff --git a/src/cmd/compile/internal/types2/operand.go b/src/cmd/compile/internal/types2/operand.go
index ab4a7eb4f3..d5a10b2c29 100644
--- a/src/cmd/compile/internal/types2/operand.go
+++ b/src/cmd/compile/internal/types2/operand.go
@@ -110,7 +110,7 @@ func operandString(x *operand, qf Qualifier) string {
 
 	var expr string
 	if x.expr != nil {
-		expr = syntax.ShortString(x.expr)
+		expr = syntax.String(x.expr)
 	} else {
 		switch x.mode {
 		case builtin:
-- 
GitLab


From 6ee9b118a2a70371e038fb6bec4fe7989a3a2b2d Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Fri, 8 Jan 2021 14:04:50 -0800
Subject: [PATCH 0446/2400] [dev.regabi] cmd/compile: remove fmt_test code; it
 has outlived its usefulness

With the recent compiler rewrites and cleanups to gc/fmt.go, the
"safety net" provided by fmt_test has become less important and
the test itself has become a burden (often breaks because of small
format changes elsewhere).

Eventually, the syntax and types2 packages will provide most error
and diagnostic compiler output at which point fmt.go can be further
simplified as well.

Change-Id: Ie93eefd3e1166f3548fed0199b732dbd6c81948a
Reviewed-on: https://go-review.googlesource.com/c/go/+/282560
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/fmt_test.go    | 615 ---------------------------------
 src/cmd/compile/fmtmap_test.go |  75 ----
 2 files changed, 690 deletions(-)
 delete mode 100644 src/cmd/compile/fmt_test.go
 delete mode 100644 src/cmd/compile/fmtmap_test.go

diff --git a/src/cmd/compile/fmt_test.go b/src/cmd/compile/fmt_test.go
deleted file mode 100644
index 6398a84f8f..0000000000
--- a/src/cmd/compile/fmt_test.go
+++ /dev/null
@@ -1,615 +0,0 @@
-// Copyright 2016 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.
-
-// This file implements TestFormats; a test that verifies
-// format strings in the compiler (this directory and all
-// subdirectories, recursively).
-//
-// TestFormats finds potential (Printf, etc.) format strings.
-// If they are used in a call, the format verbs are verified
-// based on the matching argument type against a precomputed
-// map of valid formats (knownFormats). This map can be used to
-// automatically rewrite format strings across all compiler
-// files with the -r flag.
-//
-// The format map needs to be updated whenever a new (type,
-// format) combination is found and the format verb is not
-// 'v' or 'T' (as in "%v" or "%T"). To update the map auto-
-// matically from the compiler source's use of format strings,
-// use the -u flag. (Whether formats are valid for the values
-// to be formatted must be verified manually, of course.)
-//
-// The -v flag prints out the names of all functions called
-// with a format string, the names of files that were not
-// processed, and any format rewrites made (with -r).
-//
-// Run as: go test -run Formats [-r][-u][-v]
-//
-// Known shortcomings:
-// - indexed format strings ("%[2]s", etc.) are not supported
-//   (the test will fail)
-// - format strings that are not simple string literals cannot
-//   be updated automatically
-//   (the test will fail with respective warnings)
-// - format strings in _test packages outside the current
-//   package are not processed
-//   (the test will report those files)
-//
-package main_test
-
-import (
-	"bytes"
-	"flag"
-	"fmt"
-	"go/ast"
-	"go/build"
-	"go/constant"
-	"go/format"
-	"go/importer"
-	"go/parser"
-	"go/token"
-	"go/types"
-	"internal/testenv"
-	"io"
-	"io/fs"
-	"io/ioutil"
-	"log"
-	"os"
-	"path/filepath"
-	"sort"
-	"strconv"
-	"strings"
-	"testing"
-	"unicode/utf8"
-)
-
-var (
-	rewrite = flag.Bool("r", false, "rewrite format strings")
-	update  = flag.Bool("u", false, "update known formats")
-)
-
-// The following variables collect information across all processed files.
-var (
-	fset          = token.NewFileSet()
-	formatStrings = make(map[*ast.BasicLit]bool)      // set of all potential format strings found
-	foundFormats  = make(map[string]bool)             // set of all formats found
-	callSites     = make(map[*ast.CallExpr]*callSite) // map of all calls
-)
-
-// A File is a corresponding (filename, ast) pair.
-type File struct {
-	name string
-	ast  *ast.File
-}
-
-func TestFormats(t *testing.T) {
-	if testing.Short() && testenv.Builder() == "" {
-		t.Skip("Skipping in short mode")
-	}
-	testenv.MustHaveGoBuild(t) // more restrictive than necessary, but that's ok
-
-	// process all directories
-	filepath.WalkDir(".", func(path string, info fs.DirEntry, err error) error {
-		if info.IsDir() {
-			if info.Name() == "testdata" {
-				return filepath.SkipDir
-			}
-
-			importPath := filepath.Join("cmd/compile", path)
-			if ignoredPackages[filepath.ToSlash(importPath)] {
-				return filepath.SkipDir
-			}
-
-			pkg, err := build.Import(importPath, path, 0)
-			if err != nil {
-				if _, ok := err.(*build.NoGoError); ok {
-					return nil // nothing to do here
-				}
-				t.Fatal(err)
-			}
-			collectPkgFormats(t, pkg)
-		}
-		return nil
-	})
-
-	// test and rewrite formats
-	updatedFiles := make(map[string]File) // files that were rewritten
-	for _, p := range callSites {
-		// test current format literal and determine updated one
-		out := formatReplace(p.str, func(index int, in string) string {
-			if in == "*" {
-				return in // cannot rewrite '*' (as in "%*d")
-			}
-			// in != '*'
-			typ := p.types[index]
-			format := typ + " " + in // e.g., "*Node %n"
-
-			// Do not bother reporting basic types, nor %v, %T, %p.
-			// Vet handles basic types, and those three formats apply to all types.
-			if !strings.Contains(typ, ".") || (in == "%v" || in == "%T" || in == "%p") {
-				return in
-			}
-
-			// check if format is known
-			out, known := knownFormats[format]
-
-			// record format if not yet found
-			_, found := foundFormats[format]
-			if !found {
-				foundFormats[format] = true
-			}
-
-			// report an error if the format is unknown and this is the first
-			// time we see it; ignore "%v" and "%T" which are always valid
-			if !known && !found && in != "%v" && in != "%T" {
-				t.Errorf("%s: unknown format %q for %s argument", posString(p.arg), in, typ)
-			}
-
-			if out == "" {
-				out = in
-			}
-			return out
-		})
-
-		// replace existing format literal if it changed
-		if out != p.str {
-			// we cannot replace the argument if it's not a string literal for now
-			// (e.g., it may be "foo" + "bar")
-			lit, ok := p.arg.(*ast.BasicLit)
-			if !ok {
-				delete(callSites, p.call) // treat as if we hadn't found this site
-				continue
-			}
-
-			if testing.Verbose() {
-				fmt.Printf("%s:\n\t- %q\n\t+ %q\n", posString(p.arg), p.str, out)
-			}
-
-			// find argument index of format argument
-			index := -1
-			for i, arg := range p.call.Args {
-				if p.arg == arg {
-					index = i
-					break
-				}
-			}
-			if index < 0 {
-				// we may have processed the same call site twice,
-				// but that shouldn't happen
-				panic("internal error: matching argument not found")
-			}
-
-			// replace literal
-			new := *lit                    // make a copy
-			new.Value = strconv.Quote(out) // this may introduce "-quotes where there were `-quotes
-			p.call.Args[index] = &new
-			updatedFiles[p.file.name] = p.file
-		}
-	}
-
-	// write dirty files back
-	var filesUpdated bool
-	if len(updatedFiles) > 0 && *rewrite {
-		for _, file := range updatedFiles {
-			var buf bytes.Buffer
-			if err := format.Node(&buf, fset, file.ast); err != nil {
-				t.Errorf("WARNING: gofmt %s failed: %v", file.name, err)
-				continue
-			}
-			if err := ioutil.WriteFile(file.name, buf.Bytes(), 0x666); err != nil {
-				t.Errorf("WARNING: writing %s failed: %v", file.name, err)
-				continue
-			}
-			fmt.Printf("updated %s\n", file.name)
-			filesUpdated = true
-		}
-	}
-
-	// report the names of all functions called with a format string
-	if len(callSites) > 0 && testing.Verbose() {
-		set := make(map[string]bool)
-		for _, p := range callSites {
-			set[nodeString(p.call.Fun)] = true
-		}
-		var list []string
-		for s := range set {
-			list = append(list, s)
-		}
-		fmt.Println("\nFunctions called with a format string")
-		writeList(os.Stdout, list)
-	}
-
-	// update formats
-	if len(foundFormats) > 0 && *update {
-		var list []string
-		for s := range foundFormats {
-			list = append(list, fmt.Sprintf("%q: \"\",", s))
-		}
-		var buf bytes.Buffer
-		buf.WriteString(knownFormatsHeader)
-		writeList(&buf, list)
-		buf.WriteString("}\n")
-		out, err := format.Source(buf.Bytes())
-		const outfile = "fmtmap_test.go"
-		if err != nil {
-			t.Errorf("WARNING: gofmt %s failed: %v", outfile, err)
-			out = buf.Bytes() // continue with unformatted source
-		}
-		if err = ioutil.WriteFile(outfile, out, 0644); err != nil {
-			t.Errorf("WARNING: updating format map failed: %v", err)
-		}
-	}
-
-	// check that knownFormats is up to date
-	if !*rewrite && !*update {
-		var mismatch bool
-		for s := range foundFormats {
-			if _, ok := knownFormats[s]; !ok {
-				mismatch = true
-				break
-			}
-		}
-		if !mismatch {
-			for s := range knownFormats {
-				if _, ok := foundFormats[s]; !ok {
-					mismatch = true
-					break
-				}
-			}
-		}
-		if mismatch {
-			t.Errorf("format map is out of date; run 'go test -u' to update and manually verify correctness of change'")
-		}
-	}
-
-	// all format strings of calls must be in the formatStrings set (self-verification)
-	for _, p := range callSites {
-		if lit, ok := p.arg.(*ast.BasicLit); ok && lit.Kind == token.STRING {
-			if formatStrings[lit] {
-				// ok
-				delete(formatStrings, lit)
-			} else {
-				// this should never happen
-				panic(fmt.Sprintf("internal error: format string not found (%s)", posString(lit)))
-			}
-		}
-	}
-
-	// if we have any strings left, we may need to update them manually
-	if len(formatStrings) > 0 && filesUpdated {
-		var list []string
-		for lit := range formatStrings {
-			list = append(list, fmt.Sprintf("%s: %s", posString(lit), nodeString(lit)))
-		}
-		fmt.Println("\nWARNING: Potentially missed format strings")
-		writeList(os.Stdout, list)
-		t.Fail()
-	}
-
-	fmt.Println()
-}
-
-// A callSite describes a function call that appears to contain
-// a format string.
-type callSite struct {
-	file  File
-	call  *ast.CallExpr // call containing the format string
-	arg   ast.Expr      // format argument (string literal or constant)
-	str   string        // unquoted format string
-	types []string      // argument types
-}
-
-func collectPkgFormats(t *testing.T, pkg *build.Package) {
-	// collect all files
-	var filenames []string
-	filenames = append(filenames, pkg.GoFiles...)
-	filenames = append(filenames, pkg.CgoFiles...)
-	filenames = append(filenames, pkg.TestGoFiles...)
-
-	// TODO(gri) verify _test files outside package
-	for _, name := range pkg.XTestGoFiles {
-		// don't process this test itself
-		if name != "fmt_test.go" && testing.Verbose() {
-			fmt.Printf("WARNING: %s not processed\n", filepath.Join(pkg.Dir, name))
-		}
-	}
-
-	// make filenames relative to .
-	for i, name := range filenames {
-		filenames[i] = filepath.Join(pkg.Dir, name)
-	}
-
-	// parse all files
-	files := make([]*ast.File, len(filenames))
-	for i, filename := range filenames {
-		f, err := parser.ParseFile(fset, filename, nil, parser.ParseComments)
-		if err != nil {
-			t.Fatal(err)
-		}
-		files[i] = f
-	}
-
-	// typecheck package
-	conf := types.Config{Importer: importer.Default()}
-	etypes := make(map[ast.Expr]types.TypeAndValue)
-	if _, err := conf.Check(pkg.ImportPath, fset, files, &types.Info{Types: etypes}); err != nil {
-		t.Fatal(err)
-	}
-
-	// collect all potential format strings (for extra verification later)
-	for _, file := range files {
-		ast.Inspect(file, func(n ast.Node) bool {
-			if s, ok := stringLit(n); ok && isFormat(s) {
-				formatStrings[n.(*ast.BasicLit)] = true
-			}
-			return true
-		})
-	}
-
-	// collect all formats/arguments of calls with format strings
-	for index, file := range files {
-		ast.Inspect(file, func(n ast.Node) bool {
-			if call, ok := n.(*ast.CallExpr); ok {
-				if ignoredFunctions[nodeString(call.Fun)] {
-					return true
-				}
-				// look for an arguments that might be a format string
-				for i, arg := range call.Args {
-					if s, ok := stringVal(etypes[arg]); ok && isFormat(s) {
-						// make sure we have enough arguments
-						n := numFormatArgs(s)
-						if i+1+n > len(call.Args) {
-							t.Errorf("%s: not enough format args (ignore %s?)", posString(call), nodeString(call.Fun))
-							break // ignore this call
-						}
-						// assume last n arguments are to be formatted;
-						// determine their types
-						argTypes := make([]string, n)
-						for i, arg := range call.Args[len(call.Args)-n:] {
-							if tv, ok := etypes[arg]; ok {
-								argTypes[i] = typeString(tv.Type)
-							}
-						}
-						// collect call site
-						if callSites[call] != nil {
-							panic("internal error: file processed twice?")
-						}
-						callSites[call] = &callSite{
-							file:  File{filenames[index], file},
-							call:  call,
-							arg:   arg,
-							str:   s,
-							types: argTypes,
-						}
-						break // at most one format per argument list
-					}
-				}
-			}
-			return true
-		})
-	}
-}
-
-// writeList writes list in sorted order to w.
-func writeList(w io.Writer, list []string) {
-	sort.Strings(list)
-	for _, s := range list {
-		fmt.Fprintln(w, "\t", s)
-	}
-}
-
-// posString returns a string representation of n's position
-// in the form filename:line:col: .
-func posString(n ast.Node) string {
-	if n == nil {
-		return ""
-	}
-	return fset.Position(n.Pos()).String()
-}
-
-// nodeString returns a string representation of n.
-func nodeString(n ast.Node) string {
-	var buf bytes.Buffer
-	if err := format.Node(&buf, fset, n); err != nil {
-		log.Fatal(err) // should always succeed
-	}
-	return buf.String()
-}
-
-// typeString returns a string representation of n.
-func typeString(typ types.Type) string {
-	s := filepath.ToSlash(typ.String())
-
-	// Report all the concrete IR types as Node, to shorten fmtmap.
-	const ir = "cmd/compile/internal/ir."
-	if s == "*"+ir+"Name" || s == "*"+ir+"Func" || s == "*"+ir+"Decl" ||
-		s == ir+"Ntype" || s == ir+"Expr" || s == ir+"Stmt" ||
-		strings.HasPrefix(s, "*"+ir) && (strings.HasSuffix(s, "Expr") || strings.HasSuffix(s, "Stmt")) {
-		return "cmd/compile/internal/ir.Node"
-	}
-
-	return s
-}
-
-// stringLit returns the unquoted string value and true if
-// n represents a string literal; otherwise it returns ""
-// and false.
-func stringLit(n ast.Node) (string, bool) {
-	if lit, ok := n.(*ast.BasicLit); ok && lit.Kind == token.STRING {
-		s, err := strconv.Unquote(lit.Value)
-		if err != nil {
-			log.Fatal(err) // should not happen with correct ASTs
-		}
-		return s, true
-	}
-	return "", false
-}
-
-// stringVal returns the (unquoted) string value and true if
-// tv is a string constant; otherwise it returns "" and false.
-func stringVal(tv types.TypeAndValue) (string, bool) {
-	if tv.IsValue() && tv.Value != nil && tv.Value.Kind() == constant.String {
-		return constant.StringVal(tv.Value), true
-	}
-	return "", false
-}
-
-// formatIter iterates through the string s in increasing
-// index order and calls f for each format specifier '%..v'.
-// The arguments for f describe the specifier's index range.
-// If a format specifier contains a "*", f is called with
-// the index range for "*" alone, before being called for
-// the entire specifier. The result of f is the index of
-// the rune at which iteration continues.
-func formatIter(s string, f func(i, j int) int) {
-	i := 0     // index after current rune
-	var r rune // current rune
-
-	next := func() {
-		r1, w := utf8.DecodeRuneInString(s[i:])
-		if w == 0 {
-			r1 = -1 // signal end-of-string
-		}
-		r = r1
-		i += w
-	}
-
-	flags := func() {
-		for r == ' ' || r == '#' || r == '+' || r == '-' || r == '0' {
-			next()
-		}
-	}
-
-	index := func() {
-		if r == '[' {
-			log.Fatalf("cannot handle indexed arguments: %s", s)
-		}
-	}
-
-	digits := func() {
-		index()
-		if r == '*' {
-			i = f(i-1, i)
-			next()
-			return
-		}
-		for '0' <= r && r <= '9' {
-			next()
-		}
-	}
-
-	for next(); r >= 0; next() {
-		if r == '%' {
-			i0 := i
-			next()
-			flags()
-			digits()
-			if r == '.' {
-				next()
-				digits()
-			}
-			index()
-			// accept any letter (a-z, A-Z) as format verb;
-			// ignore anything else
-			if 'a' <= r && r <= 'z' || 'A' <= r && r <= 'Z' {
-				i = f(i0-1, i)
-			}
-		}
-	}
-}
-
-// isFormat reports whether s contains format specifiers.
-func isFormat(s string) (yes bool) {
-	formatIter(s, func(i, j int) int {
-		yes = true
-		return len(s) // stop iteration
-	})
-	return
-}
-
-// oneFormat reports whether s is exactly one format specifier.
-func oneFormat(s string) (yes bool) {
-	formatIter(s, func(i, j int) int {
-		yes = i == 0 && j == len(s)
-		return j
-	})
-	return
-}
-
-// numFormatArgs returns the number of format specifiers in s.
-func numFormatArgs(s string) int {
-	count := 0
-	formatIter(s, func(i, j int) int {
-		count++
-		return j
-	})
-	return count
-}
-
-// formatReplace replaces the i'th format specifier s in the incoming
-// string in with the result of f(i, s) and returns the new string.
-func formatReplace(in string, f func(i int, s string) string) string {
-	var buf []byte
-	i0 := 0
-	index := 0
-	formatIter(in, func(i, j int) int {
-		if sub := in[i:j]; sub != "*" { // ignore calls for "*" width/length specifiers
-			buf = append(buf, in[i0:i]...)
-			buf = append(buf, f(index, sub)...)
-			i0 = j
-		}
-		index++
-		return j
-	})
-	return string(append(buf, in[i0:]...))
-}
-
-// ignoredPackages is the set of packages which can
-// be ignored.
-var ignoredPackages = map[string]bool{}
-
-// ignoredFunctions is the set of functions which may have
-// format-like arguments but which don't do any formatting and
-// thus may be ignored.
-var ignoredFunctions = map[string]bool{}
-
-func init() {
-	// verify that knownFormats entries are correctly formatted
-	for key, val := range knownFormats {
-		// key must be "typename format", and format starts with a '%'
-		// (formats containing '*' alone are not collected in this map)
-		i := strings.Index(key, "%")
-		if i < 0 || !oneFormat(key[i:]) {
-			log.Fatalf("incorrect knownFormats key: %q", key)
-		}
-		// val must be "format" or ""
-		if val != "" && !oneFormat(val) {
-			log.Fatalf("incorrect knownFormats value: %q (key = %q)", val, key)
-		}
-	}
-}
-
-const knownFormatsHeader = `// Copyright 2018 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.
-
-// This file implements the knownFormats map which records the valid
-// formats for a given type. The valid formats must correspond to
-// supported compiler formats implemented in fmt.go, or whatever
-// other format verbs are implemented for the given type. The map may
-// also be used to change the use of a format verb across all compiler
-// sources automatically (for instance, if the implementation of fmt.go
-// changes), by using the -r option together with the new formats in the
-// map. To generate this file automatically from the existing source,
-// run: go test -run Formats -u.
-//
-// See the package comment in fmt_test.go for additional information.
-
-package main_test
-
-// knownFormats entries are of the form "typename format" -> "newformat".
-// An absent entry means that the format is not recognized as valid.
-// An empty new format means that the format should remain unchanged.
-var knownFormats = map[string]string{
-`
diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
deleted file mode 100644
index a925ec05ac..0000000000
--- a/src/cmd/compile/fmtmap_test.go
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright 2018 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.
-
-// This file implements the knownFormats map which records the valid
-// formats for a given type. The valid formats must correspond to
-// supported compiler formats implemented in fmt.go, or whatever
-// other format verbs are implemented for the given type. The map may
-// also be used to change the use of a format verb across all compiler
-// sources automatically (for instance, if the implementation of fmt.go
-// changes), by using the -r option together with the new formats in the
-// map. To generate this file automatically from the existing source,
-// run: go test -run Formats -u.
-//
-// See the package comment in fmt_test.go for additional information.
-
-package main_test
-
-// knownFormats entries are of the form "typename format" -> "newformat".
-// An absent entry means that the format is not recognized as valid.
-// An empty new format means that the format should remain unchanged.
-var knownFormats = map[string]string{
-	"*bytes.Buffer %s":                             "",
-	"*cmd/compile/internal/ssa.Block %s":           "",
-	"*cmd/compile/internal/ssa.Func %s":            "",
-	"*cmd/compile/internal/ssa.Register %s":        "",
-	"*cmd/compile/internal/ssa.Value %s":           "",
-	"*cmd/compile/internal/types.Sym %+v":          "",
-	"*cmd/compile/internal/types.Sym %S":           "",
-	"*cmd/compile/internal/types.Type %+v":         "",
-	"*cmd/compile/internal/types.Type %-S":         "",
-	"*cmd/compile/internal/types.Type %L":          "",
-	"*cmd/compile/internal/types.Type %S":          "",
-	"*cmd/compile/internal/types.Type %s":          "",
-	"*math/big.Float %f":                           "",
-	"*math/big.Int %s":                             "",
-	"[]cmd/compile/internal/syntax.token %s":       "",
-	"cmd/compile/internal/arm.shift %d":            "",
-	"cmd/compile/internal/gc.RegIndex %d":          "",
-	"cmd/compile/internal/ir.Class %d":             "",
-	"cmd/compile/internal/ir.Node %+v":             "",
-	"cmd/compile/internal/ir.Node %L":              "",
-	"cmd/compile/internal/ir.Nodes %+v":            "",
-	"cmd/compile/internal/ir.Nodes %.v":            "",
-	"cmd/compile/internal/ir.Op %+v":               "",
-	"cmd/compile/internal/ssa.Aux %#v":             "",
-	"cmd/compile/internal/ssa.Aux %q":              "",
-	"cmd/compile/internal/ssa.Aux %s":              "",
-	"cmd/compile/internal/ssa.BranchPrediction %d": "",
-	"cmd/compile/internal/ssa.ID %d":               "",
-	"cmd/compile/internal/ssa.LocalSlot %s":        "",
-	"cmd/compile/internal/ssa.Location %s":         "",
-	"cmd/compile/internal/ssa.Op %s":               "",
-	"cmd/compile/internal/ssa.ValAndOff %s":        "",
-	"cmd/compile/internal/ssa.flagConstant %s":     "",
-	"cmd/compile/internal/ssa.rbrank %d":           "",
-	"cmd/compile/internal/ssa.regMask %d":          "",
-	"cmd/compile/internal/ssa.register %d":         "",
-	"cmd/compile/internal/ssa.relation %s":         "",
-	"cmd/compile/internal/syntax.Error %q":         "",
-	"cmd/compile/internal/syntax.Expr %#v":         "",
-	"cmd/compile/internal/syntax.LitKind %d":       "",
-	"cmd/compile/internal/syntax.Operator %s":      "",
-	"cmd/compile/internal/syntax.Pos %s":           "",
-	"cmd/compile/internal/syntax.position %s":      "",
-	"cmd/compile/internal/syntax.token %q":         "",
-	"cmd/compile/internal/syntax.token %s":         "",
-	"cmd/compile/internal/types.Kind %d":           "",
-	"cmd/compile/internal/types.Kind %s":           "",
-	"cmd/compile/internal/walk.initKind %d":        "",
-	"go/constant.Value %#v":                        "",
-	"math/big.Accuracy %s":                         "",
-	"reflect.Type %s":                              "",
-	"time.Duration %d":                             "",
-}
-- 
GitLab


From 8b2efa990b08e6c32422fbfdab746f4f6948ae42 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 3 Jan 2021 19:49:49 -0800
Subject: [PATCH 0447/2400] [dev.regabi] cmd/compile: deref PAUTOHEAPs during
 SSA construction

Currently, during walk we rewrite PAUTOHEAP uses into derefs of their
corresponding Heapaddr, but we can easily do this instead during SSA
construction. This does involve updating two test cases:

* nilptr3.go

This file had a test that we emit a "removed nil check" diagnostic for
the implicit dereference from accessing a PAUTOHEAP variable. This CL
removes this diagnostic, since it's not really useful to end users:
from the user's point of view, there's no pointer anyway, so they
needn't care about whether we check for nil or not. That's a purely
internal detail. And with the PAUTOHEAP dereference handled during SSA
construction, we can more robustly ensure this happens, rather than
relying on setting a flag in walk and hoping that SSA sees it.

* issue20780.go

Previously, when PAUTOHEAPs were dereferenced during walk, it had a
consequence that when they're passed as a function call argument, they
would first get copied to the stack before being copied to their
actual destination. Moving the dereferencing to SSA had a side-effect
of eliminating this unnecessary temporary, and copying directly to the
destination parameter.

The test is updated to instead call "g(h(), h())" where h() returns a
large value, as the first result will always need to be spilled
somewhere will calling the second function. Maybe eventually we're
smart enough to realize it can be spilled to the heap, but we don't do
that today.

Because I'm concerned that the direct copy-to-parameter optimization
could interfere with race-detector instrumentation (e.g., maybe the
copies were previously necessary to ensure they're not clobbered by
inserted raceread calls?), I've also added issue20780b.go to exercise
this in a few different ways.

Change-Id: I720598cb32b17518bc10a03e555620c0f25fd28d
Reviewed-on: https://go-review.googlesource.com/c/go/+/281293
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/ssagen/ssa.go | 11 +++--
 src/cmd/compile/internal/walk/expr.go  | 10 ++---
 test/fixedbugs/issue20780.go           | 16 ++++---
 test/fixedbugs/issue20780b.go          | 62 ++++++++++++++++++++++++++
 test/nilptr3.go                        |  8 ----
 5 files changed, 81 insertions(+), 26 deletions(-)
 create mode 100644 test/fixedbugs/issue20780b.go

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 5998c42012..f48909e6be 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -3222,8 +3222,8 @@ func (s *state) assign(left ir.Node, right *ssa.Value, deref bool, skip skipMask
 
 	// If this assignment clobbers an entire local variable, then emit
 	// OpVarDef so liveness analysis knows the variable is redefined.
-	if base := clobberBase(left); base.Op() == ir.ONAME && base.(*ir.Name).Class != ir.PEXTERN && skip == 0 {
-		s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, base.(*ir.Name), s.mem(), !ir.IsAutoTmp(base))
+	if base, ok := clobberBase(left).(*ir.Name); ok && base.Op() == ir.ONAME && base.Class != ir.PEXTERN && base.Class != ir.PAUTOHEAP && skip == 0 {
+		s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, base, s.mem(), !ir.IsAutoTmp(base))
 	}
 
 	// Left is not ssa-able. Compute its address.
@@ -4986,6 +4986,8 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 			// ensure that we reuse symbols for out parameters so
 			// that cse works on their addresses
 			return s.newValue2Apos(ssa.OpLocalAddr, t, n, s.sp, s.mem(), true)
+		case ir.PAUTOHEAP:
+			return s.expr(n.Heapaddr)
 		default:
 			s.Fatalf("variable address class %v not implemented", n.Class)
 			return nil
@@ -5096,11 +5098,8 @@ func (s *state) canSSAName(name *ir.Name) bool {
 	if ir.IsParamHeapCopy(name) {
 		return false
 	}
-	if name.Class == ir.PAUTOHEAP {
-		s.Fatalf("canSSA of PAUTOHEAP %v", name)
-	}
 	switch name.Class {
-	case ir.PEXTERN:
+	case ir.PEXTERN, ir.PAUTOHEAP:
 		return false
 	case ir.PPARAMOUT:
 		if s.hasdefer {
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 3dffb496e9..6fdb8f15f5 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -52,19 +52,15 @@ func walkExpr(n ir.Node, init *ir.Nodes) ir.Node {
 		base.Fatalf("expression has untyped type: %+v", n)
 	}
 
-	if n.Op() == ir.ONAME && n.(*ir.Name).Class == ir.PAUTOHEAP {
-		n := n.(*ir.Name)
-		nn := ir.NewStarExpr(base.Pos, n.Heapaddr)
-		nn.X.MarkNonNil()
-		return walkExpr(typecheck.Expr(nn), init)
-	}
-
 	n = walkExpr1(n, init)
 
 	// Eagerly compute sizes of all expressions for the back end.
 	if typ := n.Type(); typ != nil && typ.Kind() != types.TBLANK && !typ.IsFuncArgStruct() {
 		types.CheckSize(typ)
 	}
+	if n, ok := n.(*ir.Name); ok && n.Heapaddr != nil {
+		types.CheckSize(n.Heapaddr.Type())
+	}
 	if ir.IsConst(n, constant.String) {
 		// Emit string symbol now to avoid emitting
 		// any concurrently during the backend.
diff --git a/test/fixedbugs/issue20780.go b/test/fixedbugs/issue20780.go
index 53c4f615e1..f73e6d1f79 100644
--- a/test/fixedbugs/issue20780.go
+++ b/test/fixedbugs/issue20780.go
@@ -9,11 +9,17 @@
 
 package main
 
+type Big = [400e6]byte
+
 func f() { // GC_ERROR "stack frame too large"
-	var x [800e6]byte
-	g(x)
-	return
+	// Note: This test relies on the fact that we currently always
+	// spill function-results to the stack, even if they're so
+	// large that we would normally heap allocate them. If we ever
+	// improve the backend to spill temporaries to the heap, this
+	// test will probably need updating to find some new way to
+	// construct an overly large stack frame.
+	g(h(), h())
 }
 
-//go:noinline
-func g([800e6]byte) {}
+func g(Big, Big)
+func h() Big
diff --git a/test/fixedbugs/issue20780b.go b/test/fixedbugs/issue20780b.go
new file mode 100644
index 0000000000..c8bf1f8349
--- /dev/null
+++ b/test/fixedbugs/issue20780b.go
@@ -0,0 +1,62 @@
+// +build cgo,linux,amd64
+// run -race
+
+// Copyright 2021 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.
+
+// Test that CL 281293 doesn't interfere with race detector
+// instrumentation.
+
+package main
+
+import "fmt"
+
+const N = 2e6
+
+type Big = [N]int
+
+var sink interface{}
+
+func main() {
+	g(0, f(0))
+
+	x1 := f(1)
+	sink = &x1
+	g(1, x1)
+	g(7, f(7))
+	g(1, x1)
+
+	x3 := f(3)
+	sink = &x3
+	g(1, x1)
+	g(3, x3)
+
+	h(f(0), x1, f(2), x3, f(4))
+}
+
+//go:noinline
+func f(k int) (x Big) {
+	for i := range x {
+		x[i] = k*N + i
+	}
+	return
+}
+
+//go:noinline
+func g(k int, x Big) {
+	for i := range x {
+		if x[i] != k*N+i {
+			panic(fmt.Sprintf("x%d[%d] = %d", k, i, x[i]))
+		}
+	}
+}
+
+//go:noinline
+func h(x0, x1, x2, x3, x4 Big) {
+	g(0, x0)
+	g(1, x1)
+	g(2, x2)
+	g(3, x3)
+	g(4, x4)
+}
diff --git a/test/nilptr3.go b/test/nilptr3.go
index e0f2ed9767..3345cfa5ab 100644
--- a/test/nilptr3.go
+++ b/test/nilptr3.go
@@ -214,14 +214,6 @@ func p1() byte {
 	return p[5] // ERROR "removed nil check"
 }
 
-// make sure not to do nil check for access of PAUTOHEAP
-//go:noinline
-func (p *Struct) m() {}
-func c1() {
-	var x Struct
-	func() { x.m() }() // ERROR "removed nil check"
-}
-
 type SS struct {
 	x byte
 }
-- 
GitLab


From 950cf4d46c5bc343644e7ef08828b9e5114d4676 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 3 Jan 2021 21:34:03 -0800
Subject: [PATCH 0448/2400] [dev.regabi] cmd/compile: bind closure vars during
 SSA constructions

For function literals that aren't inlined or directly called, we need
to pass their arguments via a closure struct. This also means we need
to rewrite uses of closure variables to access from this closure
struct.

Currently we do this rewrite in a pass before walking begins. This CL
moves the code to SSA construction instead, alongside binding other
input parameters.

Change-Id: I13538ef3394e2d6f75d5b7b2d0adbb00db812dc2
Reviewed-on: https://go-review.googlesource.com/c/go/+/281352
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/ssagen/ssa.go   |  41 +++++++
 src/cmd/compile/internal/walk/closure.go | 139 ++++++++---------------
 2 files changed, 91 insertions(+), 89 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index f48909e6be..0c222b12cf 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -470,6 +470,47 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 		}
 	}
 
+	// Populate closure variables.
+	if !fn.ClosureCalled() {
+		clo := s.entryNewValue0(ssa.OpGetClosurePtr, s.f.Config.Types.BytePtr)
+		offset := int64(types.PtrSize) // PtrSize to skip past function entry PC field
+		for _, n := range fn.ClosureVars {
+			typ := n.Type()
+			if !n.Byval() {
+				typ = types.NewPtr(typ)
+			}
+
+			offset = types.Rnd(offset, typ.Alignment())
+			r := s.newValue1I(ssa.OpOffPtr, types.NewPtr(typ), offset, clo)
+			offset += typ.Size()
+
+			if n.Byval() && TypeOK(n.Type()) {
+				// If it is a small variable captured by value, downgrade it to PAUTO.
+				r = s.load(n.Type(), r)
+
+				n.Class = ir.PAUTO
+			} else {
+				if !n.Byval() {
+					r = s.load(typ, r)
+				}
+
+				// Declare variable holding address taken from closure.
+				addr := ir.NewNameAt(fn.Pos(), &types.Sym{Name: "&" + n.Sym().Name, Pkg: types.LocalPkg})
+				addr.SetType(types.NewPtr(n.Type()))
+				addr.Class = ir.PAUTO
+				addr.SetUsed(true)
+				addr.Curfn = fn
+				types.CalcSize(addr.Type())
+
+				n.Heapaddr = addr
+				n = addr
+			}
+
+			fn.Dcl = append(fn.Dcl, n)
+			s.assign(n, r, false, 0)
+		}
+	}
+
 	// Convert the AST-based IR to the SSA-based IR
 	s.stmtList(fn.Enter)
 	s.stmtList(fn.Body)
diff --git a/src/cmd/compile/internal/walk/closure.go b/src/cmd/compile/internal/walk/closure.go
index 449df88f9e..acb74b9901 100644
--- a/src/cmd/compile/internal/walk/closure.go
+++ b/src/cmd/compile/internal/walk/closure.go
@@ -15,103 +15,64 @@ import (
 // Closure is called in a separate phase after escape analysis.
 // It transform closure bodies to properly reference captured variables.
 func Closure(fn *ir.Func) {
+	if len(fn.ClosureVars) == 0 {
+		return
+	}
+
+	if !fn.ClosureCalled() {
+		// The closure is not directly called, so it is going to stay as closure.
+		fn.SetNeedctxt(true)
+		return
+	}
+
 	lno := base.Pos
 	base.Pos = fn.Pos()
 
-	if fn.ClosureCalled() {
-		// If the closure is directly called, we transform it to a plain function call
-		// with variables passed as args. This avoids allocation of a closure object.
-		// Here we do only a part of the transformation. Walk of OCALLFUNC(OCLOSURE)
-		// will complete the transformation later.
-		// For illustration, the following closure:
-		//	func(a int) {
-		//		println(byval)
-		//		byref++
-		//	}(42)
-		// becomes:
-		//	func(byval int, &byref *int, a int) {
-		//		println(byval)
-		//		(*&byref)++
-		//	}(byval, &byref, 42)
-
-		// f is ONAME of the actual function.
-		f := fn.Nname
-
-		// We are going to insert captured variables before input args.
-		var params []*types.Field
-		var decls []*ir.Name
-		for _, v := range fn.ClosureVars {
-			if !v.Byval() {
-				// If v of type T is captured by reference,
-				// we introduce function param &v *T
-				// and v remains PAUTOHEAP with &v heapaddr
-				// (accesses will implicitly deref &v).
-				addr := typecheck.NewName(typecheck.Lookup("&" + v.Sym().Name))
-				addr.SetType(types.NewPtr(v.Type()))
-				v.Heapaddr = addr
-				v = addr
-			}
-
-			v.Class = ir.PPARAM
-			decls = append(decls, v)
-
-			fld := types.NewField(src.NoXPos, v.Sym(), v.Type())
-			fld.Nname = v
-			params = append(params, fld)
-		}
-
-		if len(params) > 0 {
-			// Prepend params and decls.
-			f.Type().Params().SetFields(append(params, f.Type().Params().FieldSlice()...))
-			fn.Dcl = append(decls, fn.Dcl...)
+	// If the closure is directly called, we transform it to a plain function call
+	// with variables passed as args. This avoids allocation of a closure object.
+	// Here we do only a part of the transformation. Walk of OCALLFUNC(OCLOSURE)
+	// will complete the transformation later.
+	// For illustration, the following closure:
+	//	func(a int) {
+	//		println(byval)
+	//		byref++
+	//	}(42)
+	// becomes:
+	//	func(byval int, &byref *int, a int) {
+	//		println(byval)
+	//		(*&byref)++
+	//	}(byval, &byref, 42)
+
+	// f is ONAME of the actual function.
+	f := fn.Nname
+
+	// We are going to insert captured variables before input args.
+	var params []*types.Field
+	var decls []*ir.Name
+	for _, v := range fn.ClosureVars {
+		if !v.Byval() {
+			// If v of type T is captured by reference,
+			// we introduce function param &v *T
+			// and v remains PAUTOHEAP with &v heapaddr
+			// (accesses will implicitly deref &v).
+			addr := typecheck.NewName(typecheck.Lookup("&" + v.Sym().Name))
+			addr.SetType(types.NewPtr(v.Type()))
+			v.Heapaddr = addr
+			v = addr
 		}
 
-		types.CalcSize(f.Type())
-		fn.Nname.SetType(f.Type()) // update type of ODCLFUNC
-	} else {
-		// The closure is not called, so it is going to stay as closure.
-		var body []ir.Node
-		offset := int64(types.PtrSize)
-		for _, v := range fn.ClosureVars {
-			// cv refers to the field inside of closure OSTRUCTLIT.
-			typ := v.Type()
-			if !v.Byval() {
-				typ = types.NewPtr(typ)
-			}
-			offset = types.Rnd(offset, int64(typ.Align))
-			cr := ir.NewClosureRead(typ, offset)
-			offset += typ.Width
-
-			if v.Byval() && v.Type().Width <= int64(2*types.PtrSize) {
-				// If it is a small variable captured by value, downgrade it to PAUTO.
-				v.Class = ir.PAUTO
-				fn.Dcl = append(fn.Dcl, v)
-				body = append(body, ir.NewAssignStmt(base.Pos, v, cr))
-			} else {
-				// Declare variable holding addresses taken from closure
-				// and initialize in entry prologue.
-				addr := typecheck.NewName(typecheck.Lookup("&" + v.Sym().Name))
-				addr.SetType(types.NewPtr(v.Type()))
-				addr.Class = ir.PAUTO
-				addr.SetUsed(true)
-				addr.Curfn = fn
-				fn.Dcl = append(fn.Dcl, addr)
-				v.Heapaddr = addr
-				var src ir.Node = cr
-				if v.Byval() {
-					src = typecheck.NodAddr(cr)
-				}
-				body = append(body, ir.NewAssignStmt(base.Pos, addr, src))
-			}
-		}
+		v.Class = ir.PPARAM
+		decls = append(decls, v)
 
-		if len(body) > 0 {
-			typecheck.Stmts(body)
-			fn.Enter = body
-			fn.SetNeedctxt(true)
-		}
+		fld := types.NewField(src.NoXPos, v.Sym(), v.Type())
+		fld.Nname = v
+		params = append(params, fld)
 	}
 
+	// Prepend params and decls.
+	f.Type().Params().SetFields(append(params, f.Type().Params().FieldSlice()...))
+	fn.Dcl = append(decls, fn.Dcl...)
+
 	base.Pos = lno
 }
 
-- 
GitLab


From c9c26d7ffb3c4077ffaa80f7c8e2d550528e1445 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 4 Jan 2021 02:24:48 -0800
Subject: [PATCH 0449/2400] [dev.regabi] cmd/compile: use ClosureVars for
 method value wrappers

Similar to with regular closures, we can change method value wrappers
to use ClosureVars and allow SSA construction to take care of wiring
it up appropriately.

Change-Id: I05c0b1bcec4e24305324755df35b7bc5b8a6ce7a
Reviewed-on: https://go-review.googlesource.com/c/go/+/281353
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/escape/escape.go  |  3 +++
 src/cmd/compile/internal/ir/name.go        |  4 ++--
 src/cmd/compile/internal/typecheck/func.go | 25 ++++++++++------------
 3 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index 5df82d8cdc..9b9b8f6a58 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -583,6 +583,9 @@ func (e *escape) exprSkipInit(k hole, n ir.Node) {
 		if n.Class == ir.PFUNC || n.Class == ir.PEXTERN {
 			return
 		}
+		if n.IsClosureVar() && n.Defn == nil {
+			return // ".this" from method value wrapper
+		}
 		e.flow(k, e.oldLoc(n))
 
 	case ir.ONAMEOFFSET:
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index a51cf79929..cfb481e31c 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -264,7 +264,7 @@ const (
 	nameNeedzero              // if it contains pointers, needs to be zeroed on function entry
 	nameAutoTemp              // is the variable a temporary (implies no dwarf info. reset if escapes to heap)
 	nameUsed                  // for variable declared and not used error
-	nameIsClosureVar          // PAUTOHEAP closure pseudo-variable; original at n.Name.Defn
+	nameIsClosureVar          // PAUTOHEAP closure pseudo-variable; original (if any) at n.Defn
 	nameIsOutputParamHeapAddr // pointer to a result parameter's heap copy
 	nameAddrtaken             // address taken, even if not moved to heap
 	nameInlFormal             // PAUTO created by inliner, derived from callee formal
@@ -332,7 +332,7 @@ func (n *Name) SetVal(v constant.Value) {
 // it appears in the function that immediately contains the
 // declaration. Otherwise, Canonical simply returns n itself.
 func (n *Name) Canonical() *Name {
-	if n.IsClosureVar() {
+	if n.IsClosureVar() && n.Defn != nil {
 		n = n.Defn.(*Name)
 	}
 	return n
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index 8789395ffb..12762f7ee8 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -246,29 +246,26 @@ func MethodValueWrapper(dot *ir.SelectorExpr) *ir.Func {
 	fn.SetWrapper(true)
 
 	// Declare and initialize variable holding receiver.
-	cr := ir.NewClosureRead(rcvrtype, types.Rnd(int64(types.PtrSize), int64(rcvrtype.Align)))
-	var ptr *ir.Name
-	var body []ir.Node
-	if rcvrtype.IsPtr() || rcvrtype.IsInterface() {
-		ptr = Temp(rcvrtype)
-		body = append(body, ir.NewAssignStmt(base.Pos, ptr, cr))
-	} else {
-		ptr = Temp(types.NewPtr(rcvrtype))
-		body = append(body, ir.NewAssignStmt(base.Pos, ptr, NodAddr(cr)))
-	}
+	ptr := ir.NewNameAt(base.Pos, Lookup(".this"))
+	ptr.Class = ir.PAUTOHEAP
+	ptr.SetType(rcvrtype)
+	ptr.Curfn = fn
+	ptr.SetIsClosureVar(true)
+	ptr.SetByval(true)
+	fn.ClosureVars = append(fn.ClosureVars, ptr)
 
 	call := ir.NewCallExpr(base.Pos, ir.OCALL, ir.NewSelectorExpr(base.Pos, ir.OXDOT, ptr, meth), nil)
 	call.Args = ir.ParamNames(tfn.Type())
 	call.IsDDD = tfn.Type().IsVariadic()
+
+	var body ir.Node = call
 	if t0.NumResults() != 0 {
 		ret := ir.NewReturnStmt(base.Pos, nil)
 		ret.Results = []ir.Node{call}
-		body = append(body, ret)
-	} else {
-		body = append(body, call)
+		body = ret
 	}
 
-	fn.Body = body
+	fn.Body = []ir.Node{body}
 	FinishFuncBody()
 
 	Func(fn)
-- 
GitLab


From 7fd84c6e465d9c9d9424538ec99da2c59afdd469 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 4 Jan 2021 16:33:30 -0800
Subject: [PATCH 0450/2400] [dev.regabi] cmd/compile: remove OCLOSUREREAD

After the previous CLs, all closure reads are handled during SSA
construction.

Change-Id: Iad67b01fa2d3798f50ea647be7ccf8195f189c27
Reviewed-on: https://go-review.googlesource.com/c/go/+/281512
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/escape/escape.go     |  4 +--
 src/cmd/compile/internal/ir/expr.go           | 17 ++----------
 src/cmd/compile/internal/ir/node.go           | 27 +++++++++----------
 src/cmd/compile/internal/ir/node_gen.go       | 16 -----------
 src/cmd/compile/internal/ir/op_string.go      | 27 +++++++++----------
 src/cmd/compile/internal/ssagen/ssa.go        |  7 -----
 .../compile/internal/typecheck/typecheck.go   |  3 ---
 src/cmd/compile/internal/walk/expr.go         |  2 +-
 src/cmd/compile/internal/walk/walk.go         |  2 +-
 9 files changed, 32 insertions(+), 73 deletions(-)

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index 9b9b8f6a58..c63383af43 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -575,7 +575,7 @@ func (e *escape) exprSkipInit(k hole, n ir.Node) {
 	default:
 		base.Fatalf("unexpected expr: %v", n)
 
-	case ir.OLITERAL, ir.ONIL, ir.OGETG, ir.OCLOSUREREAD, ir.OTYPE, ir.OMETHEXPR:
+	case ir.OLITERAL, ir.ONIL, ir.OGETG, ir.OTYPE, ir.OMETHEXPR:
 		// nop
 
 	case ir.ONAME:
@@ -1926,7 +1926,7 @@ func mayAffectMemory(n ir.Node) bool {
 	// an ir.Any looking for any op that's not the ones in the case statement.
 	// But that produces changes in the compiled output detected by buildall.
 	switch n.Op() {
-	case ir.ONAME, ir.OCLOSUREREAD, ir.OLITERAL, ir.ONIL:
+	case ir.ONAME, ir.OLITERAL, ir.ONIL:
 		return false
 
 	case ir.OADD, ir.OSUB, ir.OOR, ir.OXOR, ir.OMUL, ir.OLSH, ir.ORSH, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OMOD:
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index e7aa9c6a8f..51425db42d 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -203,19 +203,6 @@ func NewClosureExpr(pos src.XPos, fn *Func) *ClosureExpr {
 	return n
 }
 
-// A ClosureRead denotes reading a variable stored within a closure struct.
-type ClosureReadExpr struct {
-	miniExpr
-	Offset int64
-}
-
-func NewClosureRead(typ *types.Type, offset int64) *ClosureReadExpr {
-	n := &ClosureReadExpr{Offset: offset}
-	n.typ = typ
-	n.op = OCLOSUREREAD
-	return n
-}
-
 // A CompLitExpr is a composite literal Type{Vals}.
 // Before type-checking, the type is Ntype.
 type CompLitExpr struct {
@@ -727,7 +714,7 @@ func IsAddressable(n Node) bool {
 			return false
 		}
 		fallthrough
-	case ODEREF, ODOTPTR, OCLOSUREREAD:
+	case ODEREF, ODOTPTR:
 		return true
 
 	case ODOT:
@@ -889,7 +876,7 @@ func SameSafeExpr(l Node, r Node) bool {
 	}
 
 	switch l.Op() {
-	case ONAME, OCLOSUREREAD:
+	case ONAME:
 		return l == r
 
 	case ODOT, ODOTPTR:
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 850d7343aa..a2b6e7203b 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -294,20 +294,19 @@ const (
 	OTSLICE // []int
 
 	// misc
-	OINLCALL     // intermediary representation of an inlined call.
-	OEFACE       // itable and data words of an empty-interface value.
-	OITAB        // itable word of an interface value.
-	OIDATA       // data word of an interface value in Left
-	OSPTR        // base pointer of a slice or string.
-	OCLOSUREREAD // read from inside closure struct at beginning of closure function
-	OCFUNC       // reference to c function pointer (not go func value)
-	OCHECKNIL    // emit code to ensure pointer/interface not nil
-	OVARDEF      // variable is about to be fully initialized
-	OVARKILL     // variable is dead
-	OVARLIVE     // variable is alive
-	ORESULT      // result of a function call; Xoffset is stack offset
-	OINLMARK     // start of an inlined body, with file/line of caller. Xoffset is an index into the inline tree.
-	ONAMEOFFSET  // offset within a name
+	OINLCALL    // intermediary representation of an inlined call.
+	OEFACE      // itable and data words of an empty-interface value.
+	OITAB       // itable word of an interface value.
+	OIDATA      // data word of an interface value in Left
+	OSPTR       // base pointer of a slice or string.
+	OCFUNC      // reference to c function pointer (not go func value)
+	OCHECKNIL   // emit code to ensure pointer/interface not nil
+	OVARDEF     // variable is about to be fully initialized
+	OVARKILL    // variable is dead
+	OVARLIVE    // variable is alive
+	ORESULT     // result of a function call; Xoffset is stack offset
+	OINLMARK    // start of an inlined body, with file/line of caller. Xoffset is an index into the inline tree.
+	ONAMEOFFSET // offset within a name
 
 	// arch-specific opcodes
 	ORETJMP // return to other function
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index 7f494b16cd..f1b0a21628 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -353,22 +353,6 @@ func (n *ClosureExpr) editChildren(edit func(Node) Node) {
 	}
 }
 
-func (n *ClosureReadExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
-func (n *ClosureReadExpr) copy() Node {
-	c := *n
-	c.init = copyNodes(c.init)
-	return &c
-}
-func (n *ClosureReadExpr) doChildren(do func(Node) bool) bool {
-	if doNodes(n.init, do) {
-		return true
-	}
-	return false
-}
-func (n *ClosureReadExpr) editChildren(edit func(Node) Node) {
-	editNodes(n.init, edit)
-}
-
 func (n *CommClause) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *CommClause) copy() Node {
 	c := *n
diff --git a/src/cmd/compile/internal/ir/op_string.go b/src/cmd/compile/internal/ir/op_string.go
index 0339444132..b54b4785a2 100644
--- a/src/cmd/compile/internal/ir/op_string.go
+++ b/src/cmd/compile/internal/ir/op_string.go
@@ -150,23 +150,22 @@ func _() {
 	_ = x[OITAB-139]
 	_ = x[OIDATA-140]
 	_ = x[OSPTR-141]
-	_ = x[OCLOSUREREAD-142]
-	_ = x[OCFUNC-143]
-	_ = x[OCHECKNIL-144]
-	_ = x[OVARDEF-145]
-	_ = x[OVARKILL-146]
-	_ = x[OVARLIVE-147]
-	_ = x[ORESULT-148]
-	_ = x[OINLMARK-149]
-	_ = x[ONAMEOFFSET-150]
-	_ = x[ORETJMP-151]
-	_ = x[OGETG-152]
-	_ = x[OEND-153]
+	_ = x[OCFUNC-142]
+	_ = x[OCHECKNIL-143]
+	_ = x[OVARDEF-144]
+	_ = x[OVARKILL-145]
+	_ = x[OVARLIVE-146]
+	_ = x[ORESULT-147]
+	_ = x[OINLMARK-148]
+	_ = x[ONAMEOFFSET-149]
+	_ = x[ORETJMP-150]
+	_ = x[OGETG-151]
+	_ = x[OEND-152]
 }
 
-const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNEWOBJNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCLOSUREREADCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKNAMEOFFSETRETJMPGETGEND"
+const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNEWOBJNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKNAMEOFFSETRETJMPGETGEND"
 
-var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 388, 391, 400, 403, 407, 415, 422, 431, 444, 447, 450, 453, 456, 459, 462, 468, 471, 477, 480, 486, 490, 493, 497, 502, 507, 513, 518, 522, 527, 535, 543, 549, 558, 569, 576, 580, 587, 595, 599, 603, 607, 614, 621, 629, 635, 643, 651, 656, 661, 665, 673, 678, 682, 685, 693, 697, 699, 704, 706, 711, 717, 723, 729, 735, 740, 744, 751, 757, 762, 768, 774, 781, 786, 790, 795, 799, 810, 815, 823, 829, 836, 843, 849, 856, 866, 872, 876, 879}
+var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 388, 391, 400, 403, 407, 415, 422, 431, 444, 447, 450, 453, 456, 459, 462, 468, 471, 477, 480, 486, 490, 493, 497, 502, 507, 513, 518, 522, 527, 535, 543, 549, 558, 569, 576, 580, 587, 595, 599, 603, 607, 614, 621, 629, 635, 643, 651, 656, 661, 665, 673, 678, 682, 685, 693, 697, 699, 704, 706, 711, 717, 723, 729, 735, 740, 744, 751, 757, 762, 768, 774, 781, 786, 790, 795, 799, 804, 812, 818, 825, 832, 838, 845, 855, 861, 865, 868}
 
 func (i Op) String() string {
 	if i >= Op(len(_Op_index)-1) {
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 0c222b12cf..54bde20f1c 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -2168,9 +2168,6 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		}
 		addr := s.addr(n)
 		return s.load(n.Type(), addr)
-	case ir.OCLOSUREREAD:
-		addr := s.addr(n)
-		return s.load(n.Type(), addr)
 	case ir.ONIL:
 		n := n.(*ir.NilExpr)
 		t := n.Type()
@@ -5074,10 +5071,6 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 		n := n.(*ir.SelectorExpr)
 		p := s.exprPtr(n.X, n.Bounded(), n.Pos())
 		return s.newValue1I(ssa.OpOffPtr, t, n.Offset(), p)
-	case ir.OCLOSUREREAD:
-		n := n.(*ir.ClosureReadExpr)
-		return s.newValue1I(ssa.OpOffPtr, t, n.Offset,
-			s.entryNewValue0(ssa.OpGetClosurePtr, s.f.Config.Types.BytePtr))
 	case ir.OCONVNOP:
 		n := n.(*ir.ConvExpr)
 		if n.Type() == n.X.Type() {
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 07bbd25105..3160725e3c 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -789,9 +789,6 @@ func typecheck1(n ir.Node, top int) ir.Node {
 		n := n.(*ir.UnaryExpr)
 		return tcSPtr(n)
 
-	case ir.OCLOSUREREAD:
-		return n
-
 	case ir.OCFUNC:
 		n := n.(*ir.UnaryExpr)
 		n.X = Expr(n.X)
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 6fdb8f15f5..df575d6985 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -162,7 +162,7 @@ func walkExpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		n := n.(*ir.CallExpr)
 		return mkcall("gorecover", n.Type(), init, typecheck.NodAddr(ir.RegFP))
 
-	case ir.OCLOSUREREAD, ir.OCFUNC:
+	case ir.OCFUNC:
 		return n
 
 	case ir.OCALLINTER, ir.OCALLFUNC, ir.OCALLMETH:
diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index 928b673752..e780a90660 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -476,7 +476,7 @@ func calcHasCall(n ir.Node) bool {
 		n := n.(*ir.SelectorExpr)
 		return n.X.HasCall()
 
-	case ir.OGETG, ir.OCLOSUREREAD, ir.OMETHEXPR:
+	case ir.OGETG, ir.OMETHEXPR:
 		return false
 
 	// TODO(rsc): These look wrong in various ways but are what calcHasCall has always done.
-- 
GitLab


From 81cd99858d2ae99e7ac2785367ee5b97de9e6e25 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 6 Jan 2021 12:25:10 -0500
Subject: [PATCH 0451/2400] [dev.typeparams] go/types: import expr changes from
 dev.go2go

This change imports assignments.go, builtins.go, call.go,
conversions.go, and expr.go from the dev.go2go branch.

Changes from dev.go2go:
 - Update error positions and codes.
 - Fix some failing tests due to error message changes.
 - Fix a bug in exprInternal where normal IndexExpr checking wasn't
   proceeding in the case of a non-generic indexed func.
 - Fix the type of the second operand in commaerr expressions to be
   universeError. We should add tests in a later CL.

This code was mostly reviewed, but call.go and expr.go were marked
incomplete.  Additionally, these two files had notably diverged from
types2, requiring further understanding.

The dev.go2go branch significantly simplified the type checking of
arguments, resulting in the removal of the _InvalidDotDotDot operand
error code.

Change-Id: Iba2cef95e17bfaa6da6d4eb94c2e2ce1c691ac44
Reviewed-on: https://go-review.googlesource.com/c/go/+/282193
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Trust: Robert Findley <rfindley@google.com>
---
 src/go/types/assignments.go        |  70 ++--
 src/go/types/builtins.go           | 211 +++++++----
 src/go/types/call.go               | 586 +++++++++++++++++++++--------
 src/go/types/conversions.go        |  30 +-
 src/go/types/errorcodes.go         |  44 +--
 src/go/types/eval_test.go          |   4 +-
 src/go/types/expr.go               | 245 ++++++++----
 src/go/types/testdata/builtins.src |   6 +-
 src/go/types/testdata/expr3.src    |  22 +-
 src/go/types/testdata/stmt0.src    |   2 +-
 10 files changed, 815 insertions(+), 405 deletions(-)

diff --git a/src/go/types/assignments.go b/src/go/types/assignments.go
index 616564b567..3374f81899 100644
--- a/src/go/types/assignments.go
+++ b/src/go/types/assignments.go
@@ -26,7 +26,9 @@ func (check *Checker) assignment(x *operand, T Type, context string) {
 	case constant_, variable, mapindex, value, commaok, commaerr:
 		// ok
 	default:
-		unreachable()
+		// we may get here because of other problems (issue #39634, crash 12)
+		check.errorf(x, 0, "cannot assign %s to %s in %s", x, T, context)
+		return
 	}
 
 	if isUntyped(x.typ) {
@@ -66,6 +68,11 @@ func (check *Checker) assignment(x *operand, T Type, context string) {
 	}
 	// x.typ is typed
 
+	// A generic (non-instantiated) function value cannot be assigned to a variable.
+	if sig := asSignature(x.typ); sig != nil && len(sig.tparams) > 0 {
+		check.errorf(x, 0, "cannot use generic function %s without instantiation in %s", x, context)
+	}
+
 	// spec: "If a left-hand side is the blank identifier, any typed or
 	// non-constant value except for the predeclared identifier nil may
 	// be assigned to it."
@@ -148,6 +155,7 @@ func (check *Checker) initVar(lhs *Var, x *operand, context string) Type {
 
 func (check *Checker) assignVar(lhs ast.Expr, x *operand) Type {
 	if x.mode == invalid || x.typ == Typ[Invalid] {
+		check.useLHS(lhs)
 		return nil
 	}
 
@@ -221,25 +229,27 @@ func (check *Checker) assignVar(lhs ast.Expr, x *operand) Type {
 
 // If returnPos is valid, initVars is called to type-check the assignment of
 // return expressions, and returnPos is the position of the return statement.
-func (check *Checker) initVars(lhs []*Var, rhs []ast.Expr, returnPos token.Pos) {
-	l := len(lhs)
-	get, r, commaOk := unpack(func(x *operand, i int) { check.multiExpr(x, rhs[i]) }, len(rhs), l == 2 && !returnPos.IsValid())
-	if get == nil || l != r {
-		// invalidate lhs and use rhs
+func (check *Checker) initVars(lhs []*Var, origRHS []ast.Expr, returnPos token.Pos) {
+	rhs, commaOk := check.exprList(origRHS, len(lhs) == 2 && !returnPos.IsValid())
+
+	if len(lhs) != len(rhs) {
+		// invalidate lhs
 		for _, obj := range lhs {
 			if obj.typ == nil {
 				obj.typ = Typ[Invalid]
 			}
 		}
-		if get == nil {
-			return // error reported by unpack
+		// don't report an error if we already reported one
+		for _, x := range rhs {
+			if x.mode == invalid {
+				return
+			}
 		}
-		check.useGetter(get, r)
 		if returnPos.IsValid() {
-			check.errorf(atPos(returnPos), _WrongResultCount, "wrong number of return values (want %d, got %d)", l, r)
+			check.errorf(atPos(returnPos), _WrongResultCount, "wrong number of return values (want %d, got %d)", len(lhs), len(rhs))
 			return
 		}
-		check.errorf(rhs[0], _WrongAssignCount, "cannot initialize %d variables with %d values", l, r)
+		check.errorf(rhs[0], _WrongAssignCount, "cannot initialize %d variables with %d values", len(lhs), len(rhs))
 		return
 	}
 
@@ -248,50 +258,46 @@ func (check *Checker) initVars(lhs []*Var, rhs []ast.Expr, returnPos token.Pos)
 		context = "return statement"
 	}
 
-	var x operand
 	if commaOk {
 		var a [2]Type
 		for i := range a {
-			get(&x, i)
-			a[i] = check.initVar(lhs[i], &x, context)
+			a[i] = check.initVar(lhs[i], rhs[i], context)
 		}
-		check.recordCommaOkTypes(rhs[0], a)
+		check.recordCommaOkTypes(origRHS[0], a)
 		return
 	}
 
 	for i, lhs := range lhs {
-		get(&x, i)
-		check.initVar(lhs, &x, context)
+		check.initVar(lhs, rhs[i], context)
 	}
 }
 
-func (check *Checker) assignVars(lhs, rhs []ast.Expr) {
-	l := len(lhs)
-	get, r, commaOk := unpack(func(x *operand, i int) { check.multiExpr(x, rhs[i]) }, len(rhs), l == 2)
-	if get == nil {
+func (check *Checker) assignVars(lhs, origRHS []ast.Expr) {
+	rhs, commaOk := check.exprList(origRHS, len(lhs) == 2)
+
+	if len(lhs) != len(rhs) {
 		check.useLHS(lhs...)
-		return // error reported by unpack
-	}
-	if l != r {
-		check.useGetter(get, r)
-		check.errorf(rhs[0], _WrongAssignCount, "cannot assign %d values to %d variables", r, l)
+		// don't report an error if we already reported one
+		for _, x := range rhs {
+			if x.mode == invalid {
+				return
+			}
+		}
+		check.errorf(rhs[0], _WrongAssignCount, "cannot assign %d values to %d variables", len(rhs), len(lhs))
 		return
 	}
 
-	var x operand
 	if commaOk {
 		var a [2]Type
 		for i := range a {
-			get(&x, i)
-			a[i] = check.assignVar(lhs[i], &x)
+			a[i] = check.assignVar(lhs[i], rhs[i])
 		}
-		check.recordCommaOkTypes(rhs[0], a)
+		check.recordCommaOkTypes(origRHS[0], a)
 		return
 	}
 
 	for i, lhs := range lhs {
-		get(&x, i)
-		check.assignVar(lhs, &x)
+		check.assignVar(lhs, rhs[i])
 	}
 }
 
diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go
index fd35f78676..17916c6b0c 100644
--- a/src/go/types/builtins.go
+++ b/src/go/types/builtins.go
@@ -31,8 +31,8 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 	// For len(x) and cap(x) we need to know if x contains any function calls or
 	// receive operations. Save/restore current setting and set hasCallOrRecv to
 	// false for the evaluation of x so that we can check it afterwards.
-	// Note: We must do this _before_ calling unpack because unpack evaluates the
-	//       first argument before we even call arg(x, 0)!
+	// Note: We must do this _before_ calling exprList because exprList evaluates
+	//       all arguments.
 	if id == _Len || id == _Cap {
 		defer func(b bool) {
 			check.hasCallOrRecv = b
@@ -41,15 +41,14 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 	}
 
 	// determine actual arguments
-	var arg getter
+	var arg func(*operand, int) // TODO(gri) remove use of arg getter in favor of using xlist directly
 	nargs := len(call.Args)
 	switch id {
 	default:
 		// make argument getter
-		arg, nargs, _ = unpack(func(x *operand, i int) { check.multiExpr(x, call.Args[i]) }, nargs, false)
-		if arg == nil {
-			return
-		}
+		xlist, _ := check.exprList(call.Args, false)
+		arg = func(x *operand, i int) { *x = *xlist[i]; x.typ = expand(x.typ) }
+		nargs = len(xlist)
 		// evaluate first argument, if present
 		if nargs > 0 {
 			arg(x, 0)
@@ -84,7 +83,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 		// of S and the respective parameter passing rules apply."
 		S := x.typ
 		var T Type
-		if s, _ := S.Underlying().(*Slice); s != nil {
+		if s := asSlice(S); s != nil {
 			T = s.elem
 		} else {
 			check.invalidArg(x, _InvalidAppend, "%s is not a slice", x)
@@ -121,14 +120,17 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 		// check general case by creating custom signature
 		sig := makeSig(S, S, NewSlice(T)) // []T required for variadic signature
 		sig.variadic = true
-		check.arguments(x, call, sig, func(x *operand, i int) {
-			// only evaluate arguments that have not been evaluated before
-			if i < len(alist) {
-				*x = alist[i]
-				return
-			}
-			arg(x, i)
-		}, nargs)
+		var xlist []*operand
+		// convert []operand to []*operand
+		for i := range alist {
+			xlist = append(xlist, &alist[i])
+		}
+		for i := len(alist); i < nargs; i++ {
+			var x operand
+			arg(&x, i)
+			xlist = append(xlist, &x)
+		}
+		check.arguments(call, sig, xlist) // discard result (we know the result type)
 		// ok to continue even if check.arguments reported errors
 
 		x.mode = value
@@ -143,7 +145,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 		mode := invalid
 		var typ Type
 		var val constant.Value
-		switch typ = implicitArrayDeref(x.typ.Underlying()); t := typ.(type) {
+		switch typ = implicitArrayDeref(optype(x.typ)); t := typ.(type) {
 		case *Basic:
 			if isString(t) && id == _Len {
 				if x.mode == constant_ {
@@ -176,6 +178,25 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 			if id == _Len {
 				mode = value
 			}
+
+		case *Sum:
+			if t.is(func(t Type) bool {
+				switch t := under(t).(type) {
+				case *Basic:
+					if isString(t) && id == _Len {
+						return true
+					}
+				case *Array, *Slice, *Chan:
+					return true
+				case *Map:
+					if id == _Len {
+						return true
+					}
+				}
+				return false
+			}) {
+				mode = value
+			}
 		}
 
 		if mode == invalid && typ != Typ[Invalid] {
@@ -196,7 +217,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 
 	case _Close:
 		// close(c)
-		c, _ := x.typ.Underlying().(*Chan)
+		c := asChan(x.typ)
 		if c == nil {
 			check.invalidArg(x, _InvalidClose, "%s is not a channel", x)
 			return
@@ -271,7 +292,21 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 		}
 
 		// the argument types must be of floating-point type
-		if !isFloat(x.typ) {
+		f := func(x Type) Type {
+			if t := asBasic(x); t != nil {
+				switch t.kind {
+				case Float32:
+					return Typ[Complex64]
+				case Float64:
+					return Typ[Complex128]
+				case UntypedFloat:
+					return Typ[UntypedComplex]
+				}
+			}
+			return nil
+		}
+		resTyp := check.applyTypeFunc(f, x.typ)
+		if resTyp == nil {
 			check.invalidArg(x, _InvalidComplex, "arguments have type %s, expected floating-point", x.typ)
 			return
 		}
@@ -283,20 +318,6 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 			x.mode = value
 		}
 
-		// determine result type
-		var res BasicKind
-		switch x.typ.Underlying().(*Basic).kind {
-		case Float32:
-			res = Complex64
-		case Float64:
-			res = Complex128
-		case UntypedFloat:
-			res = UntypedComplex
-		default:
-			unreachable()
-		}
-		resTyp := Typ[res]
-
 		if check.Types != nil && x.mode != constant_ {
 			check.recordBuiltinType(call.Fun, makeSig(resTyp, x.typ, x.typ))
 		}
@@ -306,7 +327,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 	case _Copy:
 		// copy(x, y []T) int
 		var dst Type
-		if t, _ := x.typ.Underlying().(*Slice); t != nil {
+		if t := asSlice(x.typ); t != nil {
 			dst = t.elem
 		}
 
@@ -316,7 +337,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 			return
 		}
 		var src Type
-		switch t := y.typ.Underlying().(type) {
+		switch t := optype(y.typ).(type) {
 		case *Basic:
 			if isString(y.typ) {
 				src = universeByte
@@ -343,7 +364,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 
 	case _Delete:
 		// delete(m, k)
-		m, _ := x.typ.Underlying().(*Map)
+		m := asMap(x.typ)
 		if m == nil {
 			check.invalidArg(x, _InvalidDelete, "%s is not a map", x)
 			return
@@ -389,7 +410,21 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 		}
 
 		// the argument must be of complex type
-		if !isComplex(x.typ) {
+		f := func(x Type) Type {
+			if t := asBasic(x); t != nil {
+				switch t.kind {
+				case Complex64:
+					return Typ[Float32]
+				case Complex128:
+					return Typ[Float64]
+				case UntypedComplex:
+					return Typ[UntypedFloat]
+				}
+			}
+			return nil
+		}
+		resTyp := check.applyTypeFunc(f, x.typ)
+		if resTyp == nil {
 			code := _InvalidImag
 			if id == _Real {
 				code = _InvalidReal
@@ -409,20 +444,6 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 			x.mode = value
 		}
 
-		// determine result type
-		var res BasicKind
-		switch x.typ.Underlying().(*Basic).kind {
-		case Complex64:
-			res = Float32
-		case Complex128:
-			res = Float64
-		case UntypedComplex:
-			res = UntypedFloat
-		default:
-			unreachable()
-		}
-		resTyp := Typ[res]
-
 		if check.Types != nil && x.mode != constant_ {
 			check.recordBuiltinType(call.Fun, makeSig(resTyp, x.typ))
 		}
@@ -434,25 +455,47 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 		// make(T, n, m)
 		// (no argument evaluated yet)
 		arg0 := call.Args[0]
-		T := check.typ(arg0)
+		T := check.varType(arg0)
 		if T == Typ[Invalid] {
 			return
 		}
 
-		var min int // minimum number of arguments
-		switch T.Underlying().(type) {
-		case *Slice:
-			min = 2
-		case *Map, *Chan:
-			min = 1
-		default:
+		min, max := -1, 10
+		var valid func(t Type) bool
+		valid = func(t Type) bool {
+			var m int
+			switch t := optype(t).(type) {
+			case *Slice:
+				m = 2
+			case *Map, *Chan:
+				m = 1
+			case *Sum:
+				return t.is(valid)
+			default:
+				return false
+			}
+			if m > min {
+				min = m
+			}
+			if m+1 < max {
+				max = m + 1
+			}
+			return true
+		}
+
+		if !valid(T) {
 			check.invalidArg(arg0, _InvalidMake, "cannot make %s; type must be slice, map, or channel", arg0)
 			return
 		}
-		if nargs < min || min+1 < nargs {
-			check.errorf(call, _WrongArgCount, "%v expects %d or %d arguments; found %d", call, min, min+1, nargs)
+		if nargs < min || max < nargs {
+			if min == max {
+				check.errorf(call, _WrongArgCount, "%v expects %d arguments; found %d", call, min, nargs)
+			} else {
+				check.errorf(call, _WrongArgCount, "%v expects %d or %d arguments; found %d", call, min, max, nargs)
+			}
 			return
 		}
+
 		types := []Type{T}
 		var sizes []int64 // constant integer arguments, if any
 		for _, arg := range call.Args[1:] {
@@ -475,7 +518,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 	case _New:
 		// new(T)
 		// (no argument evaluated yet)
-		T := check.typ(call.Args[0])
+		T := check.varType(call.Args[0])
 		if T == Typ[Invalid] {
 			return
 		}
@@ -545,6 +588,10 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 
 	case _Alignof:
 		// unsafe.Alignof(x T) uintptr
+		if asTypeParam(x.typ) != nil {
+			check.invalidOp(call, 0, "unsafe.Alignof undefined for %s", x)
+			return
+		}
 		check.assignment(x, nil, "argument to unsafe.Alignof")
 		if x.mode == invalid {
 			return
@@ -602,6 +649,10 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 
 	case _Sizeof:
 		// unsafe.Sizeof(x T) uintptr
+		if asTypeParam(x.typ) != nil {
+			check.invalidOp(call, 0, "unsafe.Sizeof undefined for %s", x)
+			return
+		}
 		check.assignment(x, nil, "argument to unsafe.Sizeof")
 		if x.mode == invalid {
 			return
@@ -657,6 +708,40 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 	return true
 }
 
+// applyTypeFunc applies f to x. If x is a type parameter,
+// the result is a type parameter constrained by an new
+// interface bound. The type bounds for that interface
+// are computed by applying f to each of the type bounds
+// of x. If any of these applications of f return nil,
+// applyTypeFunc returns nil.
+// If x is not a type parameter, the result is f(x).
+func (check *Checker) applyTypeFunc(f func(Type) Type, x Type) Type {
+	if tp := asTypeParam(x); tp != nil {
+		// Test if t satisfies the requirements for the argument
+		// type and collect possible result types at the same time.
+		var rtypes []Type
+		if !tp.Bound().is(func(x Type) bool {
+			if r := f(x); r != nil {
+				rtypes = append(rtypes, r)
+				return true
+			}
+			return false
+		}) {
+			return nil
+		}
+
+		// construct a suitable new type parameter
+		tpar := NewTypeName(token.NoPos, nil /* = Universe pkg */, "<type parameter>", nil)
+		ptyp := check.NewTypeParam(tpar, 0, &emptyInterface) // assigns type to tpar as a side-effect
+		tsum := NewSum(rtypes)
+		ptyp.bound = &Interface{types: tsum, allMethods: markComplete, allTypes: tsum}
+
+		return ptyp
+	}
+
+	return f(x)
+}
+
 // makeSig makes a signature for the given argument and result types.
 // Default types are used for untyped arguments, and res may be nil.
 func makeSig(res Type, args ...Type) *Signature {
@@ -678,7 +763,7 @@ func makeSig(res Type, args ...Type) *Signature {
 //
 func implicitArrayDeref(typ Type) Type {
 	if p, ok := typ.(*Pointer); ok {
-		if a, ok := p.base.Underlying().(*Array); ok {
+		if a := asArray(p.base); a != nil {
 			return a
 		}
 	}
diff --git a/src/go/types/call.go b/src/go/types/call.go
index 424ec902ff..e10e0a643d 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -1,3 +1,4 @@
+// REVIEW INCOMPLETE
 // Copyright 2013 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.
@@ -13,45 +14,73 @@ import (
 	"unicode"
 )
 
-func (check *Checker) call(x *operand, e *ast.CallExpr) exprKind {
-	check.exprOrType(x, e.Fun)
+// TODO(rFindley) this has diverged a bit from types2. Bring it up to date.
+// If call == nil, the "call" was an index expression, and orig is of type *ast.IndexExpr.
+func (check *Checker) call(x *operand, call *ast.CallExpr, orig ast.Expr) exprKind {
+	assert(orig != nil)
+	if call != nil {
+		assert(call == orig)
+		check.exprOrType(x, call.Fun)
+	} else {
+		// We must have an index expression.
+		// x has already been set up (evaluation of orig.X).
+		// Set up fake call so we can use its fields below.
+		expr := orig.(*ast.IndexExpr)
+		call = &ast.CallExpr{Fun: expr.X, Lparen: expr.Lbrack, Args: []ast.Expr{expr.Index}, Rparen: expr.Rbrack, Brackets: true}
+	}
 
 	switch x.mode {
 	case invalid:
-		check.use(e.Args...)
-		x.mode = invalid
-		x.expr = e
+		check.use(call.Args...)
+		x.expr = orig
 		return statement
 
 	case typexpr:
-		// conversion
+		// conversion or type instantiation
 		T := x.typ
 		x.mode = invalid
-		switch n := len(e.Args); n {
+		if isGeneric(T) {
+			// type instantiation
+			x.typ = check.typ(call)
+			if x.typ != Typ[Invalid] {
+				x.mode = typexpr
+			}
+			return expression
+		}
+
+		// conversion
+		switch n := len(call.Args); n {
 		case 0:
-			check.errorf(inNode(e, e.Rparen), _WrongArgCount, "missing argument in conversion to %s", T)
+			check.errorf(inNode(call, call.Rparen), _WrongArgCount, "missing argument in conversion to %s", T)
 		case 1:
-			check.expr(x, e.Args[0])
+			check.expr(x, call.Args[0])
 			if x.mode != invalid {
-				if e.Ellipsis.IsValid() {
-					check.errorf(e.Args[0], _BadDotDotDotSyntax, "invalid use of ... in conversion to %s", T)
+				if call.Ellipsis.IsValid() {
+					check.errorf(call.Args[0], _BadDotDotDotSyntax, "invalid use of ... in conversion to %s", T)
 					break
 				}
+				if t := asInterface(T); t != nil {
+					check.completeInterface(token.NoPos, t)
+					if t.IsConstraint() {
+						check.errorf(call, 0, "cannot use interface %s in conversion (contains type list or is comparable)", T)
+						break
+					}
+				}
 				check.conversion(x, T)
 			}
 		default:
-			check.use(e.Args...)
-			check.errorf(e.Args[n-1], _WrongArgCount, "too many arguments in conversion to %s", T)
+			check.use(call.Args...)
+			check.errorf(call.Args[n-1], _WrongArgCount, "too many arguments in conversion to %s", T)
 		}
-		x.expr = e
+		x.expr = orig
 		return conversion
 
 	case builtin:
 		id := x.id
-		if !check.builtin(x, e, id) {
+		if !check.builtin(x, call, id) {
 			x.mode = invalid
 		}
-		x.expr = e
+		x.expr = orig
 		// a non-constant result implies a function call
 		if x.mode != invalid && x.mode != constant_ {
 			check.hasCallOrRecv = true
@@ -62,21 +91,112 @@ func (check *Checker) call(x *operand, e *ast.CallExpr) exprKind {
 		// function/method call
 		cgocall := x.mode == cgofunc
 
-		sig, _ := x.typ.Underlying().(*Signature)
+		sig := asSignature(x.typ)
 		if sig == nil {
 			check.invalidOp(x, _InvalidCall, "cannot call non-function %s", x)
 			x.mode = invalid
-			x.expr = e
+			x.expr = orig
 			return statement
 		}
 
-		arg, n, _ := unpack(func(x *operand, i int) { check.multiExpr(x, e.Args[i]) }, len(e.Args), false)
-		if arg != nil {
-			check.arguments(x, e, sig, arg, n)
-		} else {
+		// evaluate arguments
+		args, ok := check.exprOrTypeList(call.Args)
+		if ok && call.Brackets && len(args) > 0 && args[0].mode != typexpr {
+			check.errorf(args[0], _NotAType, "%s is not a type", args[0])
+			ok = false
+		}
+		if !ok {
 			x.mode = invalid
+			x.expr = orig
+			return expression
+		}
+
+		// instantiate function if needed
+		if n := len(args); n > 0 && len(sig.tparams) > 0 && args[0].mode == typexpr {
+			// If the first argument is a type, assume we have explicit type arguments.
+
+			// check number of type arguments
+			// TODO(rFindley)
+			// if !check.conf.InferFromConstraints && n != len(sig.tparams) || n > len(sig.tparams) {
+			if n != len(sig.tparams) || n > len(sig.tparams) {
+				check.errorf(args[n-1], 0, "got %d type arguments but want %d", n, len(sig.tparams))
+				x.mode = invalid
+				x.expr = orig
+				return expression
+			}
+
+			// collect types
+			targs := make([]Type, n)
+			// TODO(rFindley) positioner?
+			poslist := make([]token.Pos, n)
+			for i, a := range args {
+				if a.mode != typexpr {
+					// error was reported earlier
+					x.mode = invalid
+					x.expr = orig
+					return expression
+				}
+				targs[i] = a.typ
+				poslist[i] = a.Pos()
+			}
+
+			// if we don't have enough type arguments, use constraint type inference
+			var inferred bool
+			if n < len(sig.tparams) {
+				var failed int
+				targs, failed = check.inferB(sig.tparams, targs)
+				if targs == nil {
+					// error was already reported
+					x.mode = invalid
+					x.expr = orig
+					return expression
+				}
+				if failed >= 0 {
+					// at least one type argument couldn't be inferred
+					assert(targs[failed] == nil)
+					tpar := sig.tparams[failed]
+					ppos := check.fset.Position(tpar.pos).String()
+					check.errorf(inNode(call, call.Rparen), 0, "cannot infer %s (%s) (%s)", tpar.name, ppos, targs)
+					x.mode = invalid
+					x.expr = orig
+					return expression
+				}
+				// all type arguments were inferred sucessfully
+				if debug {
+					for _, targ := range targs {
+						assert(targ != nil)
+					}
+				}
+				n = len(targs)
+				inferred = true
+			}
+			assert(n == len(sig.tparams))
+
+			// instantiate function signature
+			for i, typ := range targs {
+				// some positions may be missing if types are inferred
+				var pos token.Pos
+				if i < len(poslist) {
+					pos = poslist[i]
+				}
+				check.ordinaryType(atPos(pos), typ)
+			}
+			res := check.instantiate(x.Pos(), sig, targs, poslist).(*Signature)
+			assert(res.tparams == nil) // signature is not generic anymore
+			if inferred {
+				check.recordInferred(orig, targs, res)
+			}
+			x.typ = res
+			x.mode = value
+			x.expr = orig
+			return expression
 		}
 
+		// If we reach here, orig must have been a regular call, not an index expression.
+		assert(!call.Brackets)
+
+		sig = check.arguments(call, sig, args)
+
 		// determine result
 		switch sig.results.Len() {
 		case 0:
@@ -92,180 +212,253 @@ func (check *Checker) call(x *operand, e *ast.CallExpr) exprKind {
 			x.mode = value
 			x.typ = sig.results
 		}
-
-		x.expr = e
+		x.expr = call
 		check.hasCallOrRecv = true
 
+		// if type inference failed, a parametrized result must be invalidated
+		// (operands cannot have a parametrized type)
+		if x.mode == value && len(sig.tparams) > 0 && isParameterized(sig.tparams, x.typ) {
+			x.mode = invalid
+		}
+
 		return statement
 	}
 }
 
-// useGetter is like use, but takes a getter instead of a list of expressions.
-// It should be called instead of use if a getter is present to avoid repeated
-// evaluation of the first argument (since the getter was likely obtained via
-// unpack, which may have evaluated the first argument already).
-func (check *Checker) useGetter(get getter, n int) {
-	var x operand
-	for i := 0; i < n; i++ {
-		get(&x, i)
+// exprOrTypeList returns a list of operands and reports an error if the
+// list contains a mix of values and types (ignoring invalid operands).
+func (check *Checker) exprOrTypeList(elist []ast.Expr) (xlist []*operand, ok bool) {
+	ok = true
+
+	switch len(elist) {
+	case 0:
+		// nothing to do
+
+	case 1:
+		// single (possibly comma-ok) value or type, or function returning multiple values
+		e := elist[0]
+		var x operand
+		check.multiExprOrType(&x, e)
+		if t, ok := x.typ.(*Tuple); ok && x.mode != invalid && x.mode != typexpr {
+			// multiple values
+			xlist = make([]*operand, t.Len())
+			for i, v := range t.vars {
+				xlist[i] = &operand{mode: value, expr: e, typ: v.typ}
+			}
+			break
+		}
+
+		check.instantiatedOperand(&x)
+
+		// exactly one (possibly invalid or comma-ok) value or type
+		xlist = []*operand{&x}
+
+	default:
+		// multiple (possibly invalid) values or types
+		xlist = make([]*operand, len(elist))
+		ntypes := 0
+		for i, e := range elist {
+			var x operand
+			check.exprOrType(&x, e)
+			xlist[i] = &x
+			switch x.mode {
+			case invalid:
+				ntypes = len(xlist) // make 'if' condition fail below (no additional error in this case)
+			case typexpr:
+				ntypes++
+				check.instantiatedOperand(&x)
+			}
+		}
+		if 0 < ntypes && ntypes < len(xlist) {
+			check.errorf(xlist[0], 0, "mix of value and type expressions")
+			ok = false
+		}
 	}
+
+	return
 }
 
-// A getter sets x as the i'th operand, where 0 <= i < n and n is the total
-// number of operands (context-specific, and maintained elsewhere). A getter
-// type-checks the i'th operand; the details of the actual check are getter-
-// specific.
-type getter func(x *operand, i int)
-
-// unpack takes a getter get and a number of operands n. If n == 1, unpack
-// calls the incoming getter for the first operand. If that operand is
-// invalid, unpack returns (nil, 0, false). Otherwise, if that operand is a
-// function call, or a comma-ok expression and allowCommaOk is set, the result
-// is a new getter and operand count providing access to the function results,
-// or comma-ok values, respectively. The third result value reports if it
-// is indeed the comma-ok case. In all other cases, the incoming getter and
-// operand count are returned unchanged, and the third result value is false.
-//
-// In other words, if there's exactly one operand that - after type-checking
-// by calling get - stands for multiple operands, the resulting getter provides
-// access to those operands instead.
-//
-// If the returned getter is called at most once for a given operand index i
-// (including i == 0), that operand is guaranteed to cause only one call of
-// the incoming getter with that i.
-//
-func unpack(get getter, n int, allowCommaOk bool) (getter, int, bool) {
-	if n != 1 {
-		// zero or multiple values
-		return get, n, false
-	}
-	// possibly result of an n-valued function call or comma,ok value
-	var x0 operand
-	get(&x0, 0)
-	if x0.mode == invalid {
-		return nil, 0, false
-	}
+func (check *Checker) exprList(elist []ast.Expr, allowCommaOk bool) (xlist []*operand, commaOk bool) {
+	switch len(elist) {
+	case 0:
+		// nothing to do
+
+	case 1:
+		// single (possibly comma-ok) value, or function returning multiple values
+		e := elist[0]
+		var x operand
+		check.multiExpr(&x, e)
+		if t, ok := x.typ.(*Tuple); ok && x.mode != invalid {
+			// multiple values
+			xlist = make([]*operand, t.Len())
+			for i, v := range t.vars {
+				xlist[i] = &operand{mode: value, expr: e, typ: v.typ}
+			}
+			break
+		}
 
-	if t, ok := x0.typ.(*Tuple); ok {
-		// result of an n-valued function call
-		return func(x *operand, i int) {
+		// exactly one (possibly invalid or comma-ok) value
+		xlist = []*operand{&x}
+		if allowCommaOk && (x.mode == mapindex || x.mode == commaok || x.mode == commaerr) {
 			x.mode = value
-			x.expr = x0.expr
-			x.typ = t.At(i).typ
-		}, t.Len(), false
-	}
-
-	if x0.mode == mapindex || x0.mode == commaok || x0.mode == commaerr {
-		// comma-ok value
-		if allowCommaOk {
-			a := [2]Type{x0.typ, Typ[UntypedBool]}
-			if x0.mode == commaerr {
-				a[1] = universeError
+			x2 := &operand{mode: value, expr: e, typ: Typ[UntypedBool]}
+			if x.mode == commaerr {
+				x2.typ = universeError
 			}
-			return func(x *operand, i int) {
-				x.mode = value
-				x.expr = x0.expr
-				x.typ = a[i]
-			}, 2, true
+			xlist = append(xlist, x2)
+			commaOk = true
 		}
-		x0.mode = value
-	}
 
-	// single value
-	return func(x *operand, i int) {
-		if i != 0 {
-			unreachable()
+	default:
+		// multiple (possibly invalid) values
+		xlist = make([]*operand, len(elist))
+		for i, e := range elist {
+			var x operand
+			check.expr(&x, e)
+			xlist[i] = &x
 		}
-		*x = x0
-	}, 1, false
+	}
+
+	return
 }
 
-// arguments checks argument passing for the call with the given signature.
-// The arg function provides the operand for the i'th argument.
-func (check *Checker) arguments(x *operand, call *ast.CallExpr, sig *Signature, arg getter, n int) {
-	if call.Ellipsis.IsValid() {
-		// last argument is of the form x...
-		if !sig.variadic {
-			check.errorf(atPos(call.Ellipsis), _NonVariadicDotDotDot, "cannot use ... in call to non-variadic %s", call.Fun)
-			check.useGetter(arg, n)
+func (check *Checker) arguments(call *ast.CallExpr, sig *Signature, args []*operand) (rsig *Signature) {
+	rsig = sig
+
+	// TODO(gri) try to eliminate this extra verification loop
+	for _, a := range args {
+		switch a.mode {
+		case typexpr:
+			check.errorf(a, 0, "%s used as value", a)
 			return
-		}
-		if len(call.Args) == 1 && n > 1 {
-			// f()... is not permitted if f() is multi-valued
-			check.errorf(atPos(call.Ellipsis), _InvalidDotDotDotOperand, "cannot use ... with %d-valued %s", n, call.Args[0])
-			check.useGetter(arg, n)
+		case invalid:
 			return
 		}
 	}
 
-	// evaluate arguments
-	context := check.sprintf("argument to %s", call.Fun)
-	for i := 0; i < n; i++ {
-		arg(x, i)
-		if x.mode != invalid {
-			var ellipsis token.Pos
-			if i == n-1 && call.Ellipsis.IsValid() {
-				ellipsis = call.Ellipsis
+	// Function call argument/parameter count requirements
+	//
+	//               | standard call    | dotdotdot call |
+	// --------------+------------------+----------------+
+	// standard func | nargs == npars   | invalid        |
+	// --------------+------------------+----------------+
+	// variadic func | nargs >= npars-1 | nargs == npars |
+	// --------------+------------------+----------------+
+
+	nargs := len(args)
+	npars := sig.params.Len()
+	ddd := call.Ellipsis.IsValid()
+
+	// set up parameters
+	sigParams := sig.params // adjusted for variadic functions (may be nil for empty parameter lists!)
+	adjusted := false       // indicates if sigParams is different from t.params
+	if sig.variadic {
+		if ddd {
+			// variadic_func(a, b, c...)
+			if len(call.Args) == 1 && nargs > 1 {
+				// f()... is not permitted if f() is multi-valued
+				check.errorf(inNode(call, call.Ellipsis), _InvalidDotDotDot, "cannot use ... with %d-valued %s", nargs, call.Args[0])
+				return
 			}
-			check.argument(sig, i, x, ellipsis, context)
+		} else {
+			// variadic_func(a, b, c)
+			if nargs >= npars-1 {
+				// Create custom parameters for arguments: keep
+				// the first npars-1 parameters and add one for
+				// each argument mapping to the ... parameter.
+				vars := make([]*Var, npars-1) // npars > 0 for variadic functions
+				copy(vars, sig.params.vars)
+				last := sig.params.vars[npars-1]
+				typ := last.typ.(*Slice).elem
+				for len(vars) < nargs {
+					vars = append(vars, NewParam(last.pos, last.pkg, last.name, typ))
+				}
+				sigParams = NewTuple(vars...) // possibly nil!
+				adjusted = true
+				npars = nargs
+			} else {
+				// nargs < npars-1
+				npars-- // for correct error message below
+			}
+		}
+	} else {
+		if ddd {
+			// standard_func(a, b, c...)
+			check.errorf(inNode(call, call.Ellipsis), _NonVariadicDotDotDot, "cannot use ... in call to non-variadic %s", call.Fun)
+			return
 		}
+		// standard_func(a, b, c)
 	}
 
 	// check argument count
-	if sig.variadic {
-		// a variadic function accepts an "empty"
-		// last argument: count one extra
-		n++
-	}
-	if n < sig.params.Len() {
-		check.errorf(inNode(call, call.Rparen), _WrongArgCount, "too few arguments in call to %s", call.Fun)
-		// ok to continue
-	}
-}
-
-// argument checks passing of argument x to the i'th parameter of the given signature.
-// If ellipsis is valid, the argument is followed by ... at that position in the call.
-func (check *Checker) argument(sig *Signature, i int, x *operand, ellipsis token.Pos, context string) {
-	check.singleValue(x)
-	if x.mode == invalid {
+	switch {
+	case nargs < npars:
+		check.errorf(inNode(call, call.Rparen), _WrongArgCount, "not enough arguments in call to %s", call.Fun)
+		return
+	case nargs > npars:
+		check.errorf(args[npars], _WrongArgCount, "too many arguments in call to %s", call.Fun) // report at first extra argument
 		return
 	}
 
-	n := sig.params.Len()
-
-	// determine parameter type
-	var typ Type
-	switch {
-	case i < n:
-		typ = sig.params.vars[i].typ
-	case sig.variadic:
-		typ = sig.params.vars[n-1].typ
+	// infer type arguments and instantiate signature if necessary
+	if len(sig.tparams) > 0 {
+		// TODO(gri) provide position information for targs so we can feed
+		//           it to the instantiate call for better error reporting
+		targs, failed := check.infer(sig.tparams, sigParams, args)
+		if targs == nil {
+			return // error already reported
+		}
+		if failed >= 0 {
+			// Some type arguments couldn't be inferred. Use
+			// bounds type inference to try to make progress.
+			// TODO(rFindley)
+			/*
+				if check.conf.InferFromConstraints {
+					targs, failed = check.inferB(sig.tparams, targs)
+					if targs == nil {
+						return // error already reported
+					}
+				}
+			*/
+			if failed >= 0 {
+				// at least one type argument couldn't be inferred
+				assert(targs[failed] == nil)
+				tpar := sig.tparams[failed]
+				ppos := check.fset.Position(tpar.pos).String()
+				check.errorf(inNode(call, call.Rparen), 0, "cannot infer %s (%s) (%s)", tpar.name, ppos, targs)
+				return
+			}
+		}
+		// all type arguments were inferred sucessfully
 		if debug {
-			if _, ok := typ.(*Slice); !ok {
-				check.dump("%v: expected unnamed slice type, got %s", sig.params.vars[n-1].Pos(), typ)
+			for _, targ := range targs {
+				assert(targ != nil)
 			}
 		}
-	default:
-		check.errorf(x, _WrongArgCount, "too many arguments")
-		return
-	}
 
-	if ellipsis.IsValid() {
-		if i != n-1 {
-			check.errorf(atPos(ellipsis), _MisplacedDotDotDot, "can only use ... with matching parameter")
-			return
-		}
-		// argument is of the form x... and x is single-valued
-		if _, ok := x.typ.Underlying().(*Slice); !ok && x.typ != Typ[UntypedNil] { // see issue #18268
-			check.errorf(x, _InvalidDotDotDotOperand, "cannot use %s as parameter of type %s", x, typ)
-			return
+		// compute result signature
+		rsig = check.instantiate(call.Pos(), sig, targs, nil).(*Signature)
+		assert(rsig.tparams == nil) // signature is not generic anymore
+		check.recordInferred(call, targs, rsig)
+
+		// Optimization: Only if the parameter list was adjusted do we
+		// need to compute it from the adjusted list; otherwise we can
+		// simply use the result signature's parameter list.
+		if adjusted {
+			sigParams = check.subst(call.Pos(), sigParams, makeSubstMap(sig.tparams, targs)).(*Tuple)
+		} else {
+			sigParams = rsig.params
 		}
-	} else if sig.variadic && i >= n-1 {
-		// use the variadic parameter slice's element type
-		typ = typ.(*Slice).elem
 	}
 
-	check.assignment(x, typ, context)
+	// check arguments
+	// TODO(gri) Possible optimization (may be tricky): We could avoid
+	//           checking arguments from which we inferred type arguments.
+	for i, a := range args {
+		check.assignment(a, sigParams.vars[i].typ, check.sprintf("argument to %s", call.Fun))
+	}
+
+	return
 }
 
 var cgoPrefixes = [...]string{
@@ -368,7 +561,7 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr) {
 				x.typ = exp.typ
 				x.id = exp.id
 			default:
-				check.dump("unexpected object %v", exp)
+				check.dump("%v: unexpected object %v", e.Sel.Pos(), exp)
 				unreachable()
 			}
 			x.expr = e
@@ -381,6 +574,8 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr) {
 		goto Error
 	}
 
+	check.instantiatedOperand(x)
+
 	obj, index, indirect = check.lookupFieldOrMethod(x.typ, x.mode == variable, check.pkg, sel)
 	if obj == nil {
 		switch {
@@ -390,8 +585,20 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr) {
 		case indirect:
 			check.errorf(e.Sel, _InvalidMethodExpr, "cannot call pointer method %s on %s", sel, x.typ)
 		default:
-			// Check if capitalization of sel matters and provide better error
-			// message in that case.
+			var why string
+			if tpar := asTypeParam(x.typ); tpar != nil {
+				// Type parameter bounds don't specify fields, so don't mention "field".
+				switch obj := tpar.Bound().obj.(type) {
+				case nil:
+					why = check.sprintf("type bound for %s has no method %s", x.typ, sel)
+				case *TypeName:
+					why = check.sprintf("interface %s has no method %s", obj.name, sel)
+				}
+			} else {
+				why = check.sprintf("type %s has no field or method %s", x.typ, sel)
+			}
+
+			// Check if capitalization of sel matters and provide better error message in that case.
 			if len(sel) > 0 {
 				var changeCase string
 				if r := rune(sel[0]); unicode.IsUpper(r) {
@@ -400,11 +607,11 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr) {
 					changeCase = string(unicode.ToUpper(r)) + sel[1:]
 				}
 				if obj, _, _ = check.lookupFieldOrMethod(x.typ, x.mode == variable, check.pkg, changeCase); obj != nil {
-					check.errorf(e.Sel, _MissingFieldOrMethod, "%s.%s undefined (type %s has no field or method %s, but does have %s)", x.expr, sel, x.typ, sel, changeCase)
-					break
+					why += ", but does have " + changeCase
 				}
 			}
-			check.errorf(e.Sel, _MissingFieldOrMethod, "%s.%s undefined (type %s has no field or method %s)", x.expr, sel, x.typ, sel)
+
+			check.errorf(e.Sel, _MissingFieldOrMethod, "%s.%s undefined (%s)", x.expr, sel, why)
 		}
 		goto Error
 	}
@@ -412,6 +619,43 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr) {
 	// methods may not have a fully set up signature yet
 	if m, _ := obj.(*Func); m != nil {
 		check.objDecl(m, nil)
+		// If m has a parameterized receiver type, infer the type parameter
+		// values from the actual receiver provided and then substitute the
+		// type parameters in the signature accordingly.
+		// TODO(gri) factor this code out
+		sig := m.typ.(*Signature)
+		if len(sig.rparams) > 0 {
+			// The method may have a pointer receiver, but the actually provided receiver
+			// may be a (hopefully addressable) non-pointer value, or vice versa. Here we
+			// only care about inferring receiver type parameters; to make the inference
+			// work, match up pointer-ness of receiver and argument.
+			arg := x
+			if ptrRecv := isPointer(sig.recv.typ); ptrRecv != isPointer(arg.typ) {
+				copy := *arg
+				if ptrRecv {
+					copy.typ = NewPointer(arg.typ)
+				} else {
+					copy.typ = arg.typ.(*Pointer).base
+				}
+				arg = &copy
+			}
+			targs, failed := check.infer(sig.rparams, NewTuple(sig.recv), []*operand{arg})
+			if failed >= 0 {
+				// We may reach here if there were other errors (see issue #40056).
+				// check.infer will report a follow-up error.
+				// TODO(gri) avoid the follow-up error or provide better explanation.
+				goto Error
+			}
+			// Don't modify m. Instead - for now - make a copy of m and use that instead.
+			// (If we modify m, some tests will fail; possibly because the m is in use.)
+			// TODO(gri) investigate and provide a correct explanation here
+			copy := *m
+			copy.typ = check.subst(e.Pos(), m.typ, makeSubstMap(sig.rparams, targs))
+			obj = &copy
+		}
+		// TODO(gri) we also need to do substitution for parameterized interface methods
+		//           (this breaks code in testdata/linalg.go2 at the moment)
+		//           12/20/2019: Is this TODO still correct?
 	}
 
 	if x.mode == typexpr {
@@ -434,7 +678,8 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr) {
 		}
 		x.mode = value
 		x.typ = &Signature{
-			params:   NewTuple(append([]*Var{NewVar(token.NoPos, check.pkg, "", x.typ)}, params...)...),
+			tparams:  sig.tparams,
+			params:   NewTuple(append([]*Var{NewVar(token.NoPos, check.pkg, "_", x.typ)}, params...)...),
 			results:  sig.results,
 			variadic: sig.variadic,
 		}
@@ -458,7 +703,14 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr) {
 			// addressability, should we report the type &(x.typ) instead?
 			check.recordSelection(e, MethodVal, x.typ, obj, index, indirect)
 
-			if debug {
+			// TODO(gri) The verification pass below is disabled for now because
+			//           method sets don't match method lookup in some cases.
+			//           For instance, if we made a copy above when creating a
+			//           custom method for a parameterized received type, the
+			//           method set method doesn't match (no copy there). There
+			///          may be other situations.
+			disabled := true
+			if !disabled && debug {
 				// Verify that LookupFieldOrMethod and MethodSet.Lookup agree.
 				// TODO(gri) This only works because we call LookupFieldOrMethod
 				// _before_ calling NewMethodSet: LookupFieldOrMethod completes
diff --git a/src/go/types/conversions.go b/src/go/types/conversions.go
index 1cab1cc70f..0756b575ae 100644
--- a/src/go/types/conversions.go
+++ b/src/go/types/conversions.go
@@ -20,7 +20,7 @@ func (check *Checker) conversion(x *operand, T Type) {
 	switch {
 	case constArg && isConstType(T):
 		// constant conversion
-		switch t := T.Underlying().(*Basic); {
+		switch t := asBasic(T); {
 		case representableConst(x.val, check, t, &x.val):
 			ok = true
 		case isInteger(x.typ) && isString(t):
@@ -87,8 +87,8 @@ func (x *operand) convertibleTo(check *Checker, T Type) bool {
 
 	// "x's type and T have identical underlying types if tags are ignored"
 	V := x.typ
-	Vu := V.Underlying()
-	Tu := T.Underlying()
+	Vu := under(V)
+	Tu := under(T)
 	if check.identicalIgnoreTags(Vu, Tu) {
 		return true
 	}
@@ -97,14 +97,14 @@ func (x *operand) convertibleTo(check *Checker, T Type) bool {
 	// have identical underlying types if tags are ignored"
 	if V, ok := V.(*Pointer); ok {
 		if T, ok := T.(*Pointer); ok {
-			if check.identicalIgnoreTags(V.base.Underlying(), T.base.Underlying()) {
+			if check.identicalIgnoreTags(under(V.base), under(T.base)) {
 				return true
 			}
 		}
 	}
 
 	// "x's type and T are both integer or floating point types"
-	if (isInteger(V) || isFloat(V)) && (isInteger(T) || isFloat(T)) {
+	if isIntegerOrFloat(V) && isIntegerOrFloat(T) {
 		return true
 	}
 
@@ -137,27 +137,27 @@ func (x *operand) convertibleTo(check *Checker, T Type) bool {
 }
 
 func isUintptr(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.kind == Uintptr
+	t := asBasic(typ)
+	return t != nil && t.kind == Uintptr
 }
 
 func isUnsafePointer(typ Type) bool {
-	// TODO(gri): Is this (typ.Underlying() instead of just typ) correct?
+	// TODO(gri): Is this asBasic() instead of typ.(*Basic) correct?
+	//            (The former calls under(), while the latter doesn't.)
 	//            The spec does not say so, but gc claims it is. See also
 	//            issue 6326.
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.kind == UnsafePointer
+	t := asBasic(typ)
+	return t != nil && t.kind == UnsafePointer
 }
 
 func isPointer(typ Type) bool {
-	_, ok := typ.Underlying().(*Pointer)
-	return ok
+	return asPointer(typ) != nil
 }
 
 func isBytesOrRunes(typ Type) bool {
-	if s, ok := typ.(*Slice); ok {
-		t, ok := s.elem.Underlying().(*Basic)
-		return ok && (t.kind == Byte || t.kind == Rune)
+	if s := asSlice(typ); s != nil {
+		t := asBasic(s.elem)
+		return t != nil && (t.kind == Byte || t.kind == Rune)
 	}
 	return false
 }
diff --git a/src/go/types/errorcodes.go b/src/go/types/errorcodes.go
index c01a12c346..897b34d74f 100644
--- a/src/go/types/errorcodes.go
+++ b/src/go/types/errorcodes.go
@@ -753,52 +753,12 @@ const (
 	_NonVariadicDotDotDot
 
 	// _MisplacedDotDotDot occurs when a "..." is used somewhere other than the
-	// final argument to a function call.
+	// final argument in a function declaration.
 	//
 	// Example:
-	//  func printArgs(args ...int) {
-	//  	for _, a := range args {
-	//  		println(a)
-	//  	}
-	//  }
-	//
-	//  func f() {
-	//  	a := []int{1,2,3}
-	//  	printArgs(0, a...)
-	//  }
+	// 	func f(...int, int)
 	_MisplacedDotDotDot
 
-	// _InvalidDotDotDotOperand occurs when a "..." operator is applied to a
-	// single-valued operand.
-	//
-	// Example:
-	//  func printArgs(args ...int) {
-	//  	for _, a := range args {
-	//  		println(a)
-	//  	}
-	//  }
-	//
-	//  func f() {
-	//  	a := 1
-	//  	printArgs(a...)
-	//  }
-	//
-	// Example:
-	//  func args() (int, int) {
-	//  	return 1, 2
-	//  }
-	//
-	//  func printArgs(args ...int) {
-	//  	for _, a := range args {
-	//  		println(a)
-	//  	}
-	//  }
-	//
-	//  func g() {
-	//  	printArgs(args()...)
-	//  }
-	_InvalidDotDotDotOperand
-
 	// _InvalidDotDotDot occurs when a "..." is used in a non-variadic built-in
 	// function.
 	//
diff --git a/src/go/types/eval_test.go b/src/go/types/eval_test.go
index d940bf0e80..33dfbefe19 100644
--- a/src/go/types/eval_test.go
+++ b/src/go/types/eval_test.go
@@ -155,9 +155,9 @@ func TestEvalPos(t *testing.T) {
 		import "io"
 		type R = io.Reader
 		func _() {
-			/* interface{R}.Read => , func(interface{io.Reader}, p []byte) (n int, err error) */
+			/* interface{R}.Read => , func(_ interface{io.Reader}, p []byte) (n int, err error) */
 			_ = func() {
-				/* interface{io.Writer}.Write => , func(interface{io.Writer}, p []byte) (n int, err error) */
+				/* interface{io.Writer}.Write => , func(_ interface{io.Writer}, p []byte) (n int, err error) */
 				type io interface {} // must not shadow io in line above
 			}
 			type R interface {} // must not shadow R in first line of this function body
diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index c57edf8f0d..dcccd87c89 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -1,3 +1,4 @@
+// REVIEW INCOMPLETE
 // Copyright 2012 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.
@@ -99,8 +100,8 @@ func (check *Checker) unary(x *operand, e *ast.UnaryExpr, op token.Token) {
 		return
 
 	case token.ARROW:
-		typ, ok := x.typ.Underlying().(*Chan)
-		if !ok {
+		typ := asChan(x.typ)
+		if typ == nil {
 			check.invalidOp(x, _InvalidReceive, "cannot receive from non-channel %s", x)
 			x.mode = invalid
 			return
@@ -122,7 +123,7 @@ func (check *Checker) unary(x *operand, e *ast.UnaryExpr, op token.Token) {
 	}
 
 	if x.mode == constant_ {
-		typ := x.typ.Underlying().(*Basic)
+		typ := asBasic(x.typ)
 		var prec uint
 		if isUnsigned(typ) {
 			prec = uint(check.conf.sizeof(typ) * 8)
@@ -461,7 +462,7 @@ func (check *Checker) updateExprType(x ast.Expr, typ Type, final bool) {
 	// If the new type is not final and still untyped, just
 	// update the recorded type.
 	if !final && isUntyped(typ) {
-		old.typ = typ.Underlying().(*Basic)
+		old.typ = asBasic(typ)
 		check.untyped[x] = old
 		return
 	}
@@ -512,6 +513,7 @@ func (check *Checker) convertUntyped(x *operand, target Type) {
 }
 
 func (check *Checker) canConvertUntyped(x *operand, target Type) error {
+	target = expand(target)
 	if x.mode == invalid || isTyped(x.typ) || target == Typ[Invalid] {
 		return nil
 	}
@@ -744,7 +746,7 @@ func (check *Checker) shift(x, y *operand, e *ast.BinaryExpr, op token.Token) {
 				if e != nil {
 					x.expr = e // for better error message
 				}
-				check.representable(x, x.typ.Underlying().(*Basic))
+				check.representable(x, asBasic(x.typ))
 			}
 			return
 		}
@@ -889,7 +891,7 @@ func (check *Checker) binary(x *operand, e *ast.BinaryExpr, lhs, rhs ast.Expr, o
 	if x.mode == constant_ && y.mode == constant_ {
 		xval := x.val
 		yval := y.val
-		typ := x.typ.Underlying().(*Basic)
+		typ := asBasic(x.typ)
 		// force integer division of integer operands
 		if op == token.QUO && isInteger(typ) {
 			op = token.QUO_ASSIGN
@@ -1028,7 +1030,7 @@ const (
 //
 func (check *Checker) rawExpr(x *operand, e ast.Expr, hint Type) exprKind {
 	if trace {
-		check.trace(e.Pos(), "%s", e)
+		check.trace(e.Pos(), "expr %s", e)
 		check.indent++
 		defer func() {
 			check.indent--
@@ -1133,7 +1135,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 					// We have an "open" [...]T array type.
 					// Create a new ArrayType with unknown length (-1)
 					// and finish setting it up after analyzing the literal.
-					typ = &Array{len: -1, elem: check.typ(atyp.Elt)}
+					typ = &Array{len: -1, elem: check.varType(atyp.Elt)}
 					base = typ
 					break
 				}
@@ -1144,7 +1146,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 		case hint != nil:
 			// no composite literal type present - use hint (element type of enclosing type)
 			typ = hint
-			base, _ = deref(typ.Underlying()) // *T implies &T{}
+			base, _ = deref(under(typ)) // *T implies &T{}
 
 		default:
 			// TODO(gri) provide better error messages depending on context
@@ -1152,7 +1154,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 			goto Error
 		}
 
-		switch utyp := base.Underlying().(type) {
+		switch utyp := optype(base).(type) {
 		case *Struct:
 			if len(e.Elts) == 0 {
 				break
@@ -1280,7 +1282,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 					duplicate := false
 					// if the key is of interface type, the type is also significant when checking for duplicates
 					xkey := keyVal(x.val)
-					if _, ok := utyp.key.Underlying().(*Interface); ok {
+					if asInterface(utyp.key) != nil {
 						for _, vtyp := range visited[xkey] {
 							if check.identical(vtyp, x.typ) {
 								duplicate = true
@@ -1332,15 +1334,31 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 		check.selector(x, e)
 
 	case *ast.IndexExpr:
-		check.expr(x, e.X)
+		check.exprOrType(x, e.X)
 		if x.mode == invalid {
 			check.use(e.Index)
 			goto Error
 		}
 
+		if x.mode == typexpr {
+			// type instantiation
+			x.mode = invalid
+			x.typ = check.varType(e)
+			if x.typ != Typ[Invalid] {
+				x.mode = typexpr
+			}
+			return expression
+		}
+
+		if x.mode == value {
+			if sig := asSignature(x.typ); sig != nil && len(sig.tparams) > 0 {
+				return check.call(x, nil, e)
+			}
+		}
+
 		valid := false
 		length := int64(-1) // valid if >= 0
-		switch typ := x.typ.Underlying().(type) {
+		switch typ := optype(x.typ).(type) {
 		case *Basic:
 			if isString(typ) {
 				valid = true
@@ -1363,7 +1381,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 			x.typ = typ.elem
 
 		case *Pointer:
-			if typ, _ := typ.base.Underlying().(*Array); typ != nil {
+			if typ := asArray(typ.base); typ != nil {
 				valid = true
 				length = typ.len
 				x.mode = variable
@@ -1384,6 +1402,82 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 			x.typ = typ.elem
 			x.expr = e
 			return expression
+
+		case *Sum:
+			// A sum type can be indexed if all of the sum's types
+			// support indexing and have the same index and element
+			// type. Special rules apply for maps in the sum type.
+			var tkey, telem Type // key is for map types only
+			nmaps := 0           // number of map types in sum type
+			if typ.is(func(t Type) bool {
+				var e Type
+				switch t := under(t).(type) {
+				case *Basic:
+					if isString(t) {
+						e = universeByte
+					}
+				case *Array:
+					e = t.elem
+				case *Pointer:
+					if t := asArray(t.base); t != nil {
+						e = t.elem
+					}
+				case *Slice:
+					e = t.elem
+				case *Map:
+					// If there are multiple maps in the sum type,
+					// they must have identical key types.
+					// TODO(gri) We may be able to relax this rule
+					// but it becomes complicated very quickly.
+					if tkey != nil && !Identical(t.key, tkey) {
+						return false
+					}
+					tkey = t.key
+					e = t.elem
+					nmaps++
+				case *TypeParam:
+					check.errorf(x, 0, "type of %s contains a type parameter - cannot index (implementation restriction)", x)
+				case *instance:
+					panic("unimplemented")
+				}
+				if e == nil || telem != nil && !Identical(e, telem) {
+					return false
+				}
+				telem = e
+				return true
+			}) {
+				// If there are maps, the index expression must be assignable
+				// to the map key type (as for simple map index expressions).
+				if nmaps > 0 {
+					var key operand
+					check.expr(&key, e.Index)
+					check.assignment(&key, tkey, "map index")
+					// ok to continue even if indexing failed - map element type is known
+
+					// If there are only maps, we are done.
+					if nmaps == len(typ.types) {
+						x.mode = mapindex
+						x.typ = telem
+						x.expr = e
+						return expression
+					}
+
+					// Otherwise we have mix of maps and other types. For
+					// now we require that the map key be an integer type.
+					// TODO(gri) This is probably not good enough.
+					valid = isInteger(tkey)
+					// avoid 2nd indexing error if indexing failed above
+					if !valid && key.mode == invalid {
+						goto Error
+					}
+					x.mode = value // map index expressions are not addressable
+				} else {
+					// no maps
+					valid = true
+					x.mode = variable
+				}
+				x.typ = telem
+			}
 		}
 
 		if !valid {
@@ -1396,6 +1490,13 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 			goto Error
 		}
 
+		// In pathological (invalid) cases (e.g.: type T1 [][[]T1{}[0][0]]T0)
+		// the element type may be accessed before it's set. Make sure we have
+		// a valid type.
+		if x.typ == nil {
+			x.typ = Typ[Invalid]
+		}
+
 		check.index(e.Index, length)
 		// ok to continue
 
@@ -1408,7 +1509,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 
 		valid := false
 		length := int64(-1) // valid if >= 0
-		switch typ := x.typ.Underlying().(type) {
+		switch typ := optype(x.typ).(type) {
 		case *Basic:
 			if isString(typ) {
 				if e.Slice3 {
@@ -1436,7 +1537,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 			x.typ = &Slice{elem: typ.elem}
 
 		case *Pointer:
-			if typ, _ := typ.base.Underlying().(*Array); typ != nil {
+			if typ := asArray(typ.base); typ != nil {
 				valid = true
 				length = typ.len
 				x.typ = &Slice{elem: typ.elem}
@@ -1445,6 +1546,10 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 		case *Slice:
 			valid = true
 			// x.typ doesn't change
+
+		case *Sum, *TypeParam:
+			check.errorf(x, 0, "generic slice expressions not yet implemented")
+			goto Error
 		}
 
 		if !valid {
@@ -1505,11 +1610,12 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 		if x.mode == invalid {
 			goto Error
 		}
-		xtyp, _ := x.typ.Underlying().(*Interface)
+		xtyp, _ := under(x.typ).(*Interface)
 		if xtyp == nil {
 			check.invalidOp(x, _InvalidAssert, "%s is not an interface", x)
 			goto Error
 		}
+		check.ordinaryType(x, xtyp)
 		// x.(type) expressions are handled explicitly in type switches
 		if e.Type == nil {
 			// Don't use invalidAST because this can occur in the AST produced by
@@ -1517,7 +1623,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 			check.error(e, _BadTypeKeyword, "use of .(type) outside type switch")
 			goto Error
 		}
-		T := check.typ(e.Type)
+		T := check.varType(e.Type)
 		if T == Typ[Invalid] {
 			goto Error
 		}
@@ -1526,7 +1632,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 		x.typ = T
 
 	case *ast.CallExpr:
-		return check.call(x, e)
+		return check.call(x, e, e)
 
 	case *ast.StarExpr:
 		check.exprOrType(x, e.X)
@@ -1536,7 +1642,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 		case typexpr:
 			x.typ = &Pointer{base: x.typ}
 		default:
-			if typ, ok := x.typ.Underlying().(*Pointer); ok {
+			if typ := asPointer(x.typ); typ != nil {
 				x.mode = variable
 				x.typ = typ.base
 			} else {
@@ -1637,46 +1743,26 @@ func (check *Checker) typeAssertion(at positioner, x *operand, xtyp *Interface,
 	check.errorf(at, _ImpossibleAssert, "%s cannot have dynamic type %s (%s)", x, T, msg)
 }
 
-func (check *Checker) singleValue(x *operand) {
-	if x.mode == value {
-		// tuple types are never named - no need for underlying type below
-		if t, ok := x.typ.(*Tuple); ok {
-			assert(t.Len() != 1)
-			check.errorf(x, _TooManyValues, "%d-valued %s where single value is expected", t.Len(), x)
-			x.mode = invalid
-		}
-	}
-}
-
 // expr typechecks expression e and initializes x with the expression value.
 // The result must be a single value.
 // If an error occurred, x.mode is set to invalid.
 //
 func (check *Checker) expr(x *operand, e ast.Expr) {
-	check.multiExpr(x, e)
+	check.rawExpr(x, e, nil)
+	check.exclude(x, 1<<novalue|1<<builtin|1<<typexpr)
 	check.singleValue(x)
 }
 
-// multiExpr is like expr but the result may be a multi-value.
+// multiExpr is like expr but the result may also be a multi-value.
 func (check *Checker) multiExpr(x *operand, e ast.Expr) {
 	check.rawExpr(x, e, nil)
-	var msg string
-	var code errorCode
-	switch x.mode {
-	default:
-		return
-	case novalue:
-		msg = "%s used as value"
-		code = _TooManyValues
-	case builtin:
-		msg = "%s must be called"
-		code = _UncalledBuiltin
-	case typexpr:
-		msg = "%s is not an expression"
-		code = _NotAnExpr
-	}
-	check.errorf(x, code, msg, x)
-	x.mode = invalid
+	check.exclude(x, 1<<novalue|1<<builtin|1<<typexpr)
+}
+
+// multiExprOrType is like multiExpr but the result may also be a type.
+func (check *Checker) multiExprOrType(x *operand, e ast.Expr) {
+	check.rawExpr(x, e, nil)
+	check.exclude(x, 1<<novalue|1<<builtin)
 }
 
 // exprWithHint typechecks expression e and initializes x with the expression value;
@@ -1686,24 +1772,8 @@ func (check *Checker) multiExpr(x *operand, e ast.Expr) {
 func (check *Checker) exprWithHint(x *operand, e ast.Expr, hint Type) {
 	assert(hint != nil)
 	check.rawExpr(x, e, hint)
+	check.exclude(x, 1<<novalue|1<<builtin|1<<typexpr)
 	check.singleValue(x)
-	var msg string
-	var code errorCode
-	switch x.mode {
-	default:
-		return
-	case novalue:
-		msg = "%s used as value"
-		code = _TooManyValues
-	case builtin:
-		msg = "%s must be called"
-		code = _UncalledBuiltin
-	case typexpr:
-		msg = "%s is not an expression"
-		code = _NotAnExpr
-	}
-	check.errorf(x, code, msg, x)
-	x.mode = invalid
 }
 
 // exprOrType typechecks expression or type e and initializes x with the expression value or type.
@@ -1711,9 +1781,46 @@ func (check *Checker) exprWithHint(x *operand, e ast.Expr, hint Type) {
 //
 func (check *Checker) exprOrType(x *operand, e ast.Expr) {
 	check.rawExpr(x, e, nil)
+	check.exclude(x, 1<<novalue)
 	check.singleValue(x)
-	if x.mode == novalue {
-		check.errorf(x, _NotAnExpr, "%s used as value or type", x)
+}
+
+// exclude reports an error if x.mode is in modeset and sets x.mode to invalid.
+// The modeset may contain any of 1<<novalue, 1<<builtin, 1<<typexpr.
+func (check *Checker) exclude(x *operand, modeset uint) {
+	if modeset&(1<<x.mode) != 0 {
+		var msg string
+		var code errorCode
+		switch x.mode {
+		case novalue:
+			if modeset&(1<<typexpr) != 0 {
+				msg = "%s used as value"
+			} else {
+				msg = "%s used as value or type"
+			}
+			code = _TooManyValues
+		case builtin:
+			msg = "%s must be called"
+			code = _UncalledBuiltin
+		case typexpr:
+			msg = "%s is not an expression"
+			code = _NotAnExpr
+		default:
+			unreachable()
+		}
+		check.errorf(x, code, msg, x)
 		x.mode = invalid
 	}
 }
+
+// singleValue reports an error if x describes a tuple and sets x.mode to invalid.
+func (check *Checker) singleValue(x *operand) {
+	if x.mode == value {
+		// tuple types are never named - no need for underlying type below
+		if t, ok := x.typ.(*Tuple); ok {
+			assert(t.Len() != 1)
+			check.errorf(x, _TooManyValues, "%d-valued %s where single value is expected", t.Len(), x)
+			x.mode = invalid
+		}
+	}
+}
diff --git a/src/go/types/testdata/builtins.src b/src/go/types/testdata/builtins.src
index 98830eb08c..3c273b0766 100644
--- a/src/go/types/testdata/builtins.src
+++ b/src/go/types/testdata/builtins.src
@@ -25,11 +25,11 @@ func append1() {
 	_ = append(s, b)
 	_ = append(s, x /* ERROR cannot use x */ )
 	_ = append(s, s /* ERROR cannot use s */ )
-	_ = append(s... /* ERROR can only use ... with matching parameter */ )
-	_ = append(s, b, s... /* ERROR can only use ... with matching parameter */ )
+	_ = append(s...) /* ERROR not enough arguments */
+	_ = append(s, b, s /* ERROR too many arguments */ ...)
 	_ = append(s, 1, 2, 3)
 	_ = append(s, 1, 2, 3, x /* ERROR cannot use x */ , 5, 6, 6)
-	_ = append(s, 1, 2, s... /* ERROR can only use ... with matching parameter */ )
+	_ = append(s, 1, 2 /* ERROR too many arguments */, s...)
 	_ = append([]interface{}(nil), 1, 2, "foo", x, 3.1425, false)
 
 	type S []byte
diff --git a/src/go/types/testdata/expr3.src b/src/go/types/testdata/expr3.src
index e6777aad2b..c3158e6cf4 100644
--- a/src/go/types/testdata/expr3.src
+++ b/src/go/types/testdata/expr3.src
@@ -492,26 +492,26 @@ func _calls() {
 	f1(0)
 	f1(x)
 	f1(10.0)
-	f1() /* ERROR "too few arguments" */
+	f1() /* ERROR "not enough arguments" */
 	f1(x, y /* ERROR "too many arguments" */ )
 	f1(s /* ERROR "cannot use .* in argument" */ )
 	f1(x ... /* ERROR "cannot use ..." */ )
 	f1(g0 /* ERROR "used as value" */ ())
 	f1(g1())
-	f1(g2 /* ERROR "cannot use g2" */ /* ERROR "too many arguments" */ ())
+	f1(g2 /* ERROR "too many arguments" */ ())
 
-	f2() /* ERROR "too few arguments" */
-	f2(3.14) /* ERROR "too few arguments" */
+	f2() /* ERROR "not enough arguments" */
+	f2(3.14) /* ERROR "not enough arguments" */
 	f2(3.14, "foo")
 	f2(x /* ERROR "cannot use .* in argument" */ , "foo")
 	f2(g0 /* ERROR "used as value" */ ())
-	f2(g1 /* ERROR "cannot use .* in argument" */ ()) /* ERROR "too few arguments" */
+	f2(g1()) /* ERROR "not enough arguments" */
 	f2(g2())
 
-	fs() /* ERROR "too few arguments" */
+	fs() /* ERROR "not enough arguments" */
 	fs(g0 /* ERROR "used as value" */ ())
 	fs(g1 /* ERROR "cannot use .* in argument" */ ())
-	fs(g2 /* ERROR "cannot use .* in argument" */ /* ERROR "too many arguments" */ ())
+	fs(g2 /* ERROR "too many arguments" */ ())
 	fs(gs())
 
 	fv()
@@ -519,7 +519,7 @@ func _calls() {
 	fv(s /* ERROR "cannot use .* in argument" */ )
 	fv(s...)
 	fv(x /* ERROR "cannot use" */ ...)
-	fv(1, s... /* ERROR "can only use ... with matching parameter" */ )
+	fv(1, s /* ERROR "too many arguments" */ ...)
 	fv(gs /* ERROR "cannot use .* in argument" */ ())
 	fv(gs /* ERROR "cannot use .* in argument" */ ()...)
 
@@ -528,7 +528,7 @@ func _calls() {
 	t.fm(1, 2.0, x)
 	t.fm(s /* ERROR "cannot use .* in argument" */ )
 	t.fm(g1())
-	t.fm(1, s... /* ERROR "can only use ... with matching parameter" */ )
+	t.fm(1, s /* ERROR "too many arguments" */ ...)
 	t.fm(gs /* ERROR "cannot use .* in argument" */ ())
 	t.fm(gs /* ERROR "cannot use .* in argument" */ ()...)
 
@@ -536,7 +536,7 @@ func _calls() {
 	T.fm(t, 1, 2.0, x)
 	T.fm(t, s /* ERROR "cannot use .* in argument" */ )
 	T.fm(t, g1())
-	T.fm(t, 1, s... /* ERROR "can only use ... with matching parameter" */ )
+	T.fm(t, 1, s /* ERROR "too many arguments" */ ...)
 	T.fm(t, gs /* ERROR "cannot use .* in argument" */ ())
 	T.fm(t, gs /* ERROR "cannot use .* in argument" */ ()...)
 
@@ -545,7 +545,7 @@ func _calls() {
 	i.fm(1, 2.0, x)
 	i.fm(s /* ERROR "cannot use .* in argument" */ )
 	i.fm(g1())
-	i.fm(1, s... /* ERROR "can only use ... with matching parameter" */ )
+	i.fm(1, s /* ERROR "too many arguments" */ ...)
 	i.fm(gs /* ERROR "cannot use .* in argument" */ ())
 	i.fm(gs /* ERROR "cannot use .* in argument" */ ()...)
 
diff --git a/src/go/types/testdata/stmt0.src b/src/go/types/testdata/stmt0.src
index 13777292a9..fde846962e 100644
--- a/src/go/types/testdata/stmt0.src
+++ b/src/go/types/testdata/stmt0.src
@@ -86,7 +86,7 @@ func assignments1() {
 
 	g := func(int, bool){}
 	var m map[int]int
-	g(m[0]) /* ERROR "too few arguments" */
+	g(m[0]) /* ERROR "not enough arguments" */
 
 	// assignments to _
 	_ = nil /* ERROR "use of untyped nil" */
-- 
GitLab


From eb53a6c7cf80474628b03a1ae62afb1a84d10f03 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 7 Jan 2021 10:55:00 -0500
Subject: [PATCH 0452/2400] [dev.typeparams] import operand.go changes from
 dev.go2go

This involved some non-trivial changes from dev.go2go, due to the
refactoring of assignability in master.

Change-Id: I73d99053fc8b184ae79b7b8973bd15e69e50fe6b
Reviewed-on: https://go-review.googlesource.com/c/go/+/282119
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Trust: Robert Findley <rfindley@google.com>
---
 src/go/types/operand.go | 33 ++++++++++++++++++++++++++-------
 1 file changed, 26 insertions(+), 7 deletions(-)

diff --git a/src/go/types/operand.go b/src/go/types/operand.go
index 3e1ac312d9..336babcadc 100644
--- a/src/go/types/operand.go
+++ b/src/go/types/operand.go
@@ -158,7 +158,16 @@ func operandString(x *operand, qf Qualifier) string {
 	// <typ>
 	if hasType {
 		if x.typ != Typ[Invalid] {
-			buf.WriteString(" of type ")
+			var intro string
+			switch {
+			case isGeneric(x.typ):
+				intro = " of generic type "
+			case asTypeParam(x.typ) != nil:
+				intro = " of type parameter type "
+			default:
+				intro = " of type "
+			}
+			buf.WriteString(intro)
 			WriteType(&buf, x.typ, qf)
 		} else {
 			buf.WriteString(" with invalid type")
@@ -228,20 +237,30 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er
 		return true, 0
 	}
 
-	Vu := V.Underlying()
-	Tu := T.Underlying()
+	Vu := optype(V)
+	Tu := optype(T)
 
 	// x is an untyped value representable by a value of type T.
 	if isUntyped(Vu) {
-		if t, ok := Tu.(*Basic); ok && x.mode == constant_ {
-			return representableConst(x.val, check, t, nil), _IncompatibleAssign
+		// TODO(rFindley) synchronize this block of code with types2
+		switch t := Tu.(type) {
+		case *Basic:
+			if x.mode == constant_ {
+				return representableConst(x.val, check, t, nil), _IncompatibleAssign
+			}
+		case *Sum:
+			return t.is(func(t Type) bool {
+				// TODO(gri) this could probably be more efficient
+				ok, _ := x.assignableTo(check, t, reason)
+				return ok
+			}), _IncompatibleAssign
 		}
 		return check.implicitType(x, Tu) != nil, _IncompatibleAssign
 	}
 	// Vu is typed
 
-	// x's type V and T have identical underlying types and at least one of V or
-	// T is not a named type.
+	// x's type V and T have identical underlying types
+	// and at least one of V or T is not a named type
 	if check.identical(Vu, Tu) && (!isNamed(V) || !isNamed(T)) {
 		return true, 0
 	}
-- 
GitLab


From 1ce08541574f749947400a051bb40c8352743887 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 7 Jan 2021 11:13:56 -0500
Subject: [PATCH 0453/2400] [dev.typeparams] import stmt changes from dev.go2go

Import logic for typechecking statements involving generics from the
dev.go2go branch.  Notably, range type checking was simplified in
dev.go2go, resulting in the removal of the _InvalidChanRange error code.

Change-Id: I84c2665226c2b9b74e85f7fb6df257b0a292e5d3
Reviewed-on: https://go-review.googlesource.com/c/go/+/282120
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Trust: Robert Findley <rfindley@google.com>
---
 src/go/types/errorcodes.go      |  12 ---
 src/go/types/stmt.go            | 141 ++++++++++++++++++++++----------
 src/go/types/testdata/stmt0.src |   2 +-
 3 files changed, 100 insertions(+), 55 deletions(-)

diff --git a/src/go/types/errorcodes.go b/src/go/types/errorcodes.go
index 897b34d74f..2c5a291660 100644
--- a/src/go/types/errorcodes.go
+++ b/src/go/types/errorcodes.go
@@ -1038,18 +1038,6 @@ const (
 	//  }
 	_InvalidPostDecl
 
-	// _InvalidChanRange occurs when a send-only channel used in a range
-	// expression.
-	//
-	// Example:
-	//  func sum(c chan<- int) {
-	//  	s := 0
-	//  	for i := range c {
-	//  		s += i
-	//  	}
-	//  }
-	_InvalidChanRange
-
 	// _InvalidIterVar occurs when two iteration variables are used while ranging
 	// over a channel.
 	//
diff --git a/src/go/types/stmt.go b/src/go/types/stmt.go
index 0162368a64..82c21c2a7a 100644
--- a/src/go/types/stmt.go
+++ b/src/go/types/stmt.go
@@ -49,6 +49,11 @@ func (check *Checker) funcBody(decl *declInfo, name string, sig *Signature, body
 		check.error(atPos(body.Rbrace), _MissingReturn, "missing return")
 	}
 
+	// TODO(gri) Should we make it an error to declare generic functions
+	//           where the type parameters are not used?
+	// 12/19/2018: Probably not - it can make sense to have an API with
+	//           all functions uniformly sharing the same type parameters.
+
 	// spec: "Implementation restriction: A compiler may make it illegal to
 	// declare a variable inside a function body if the variable is never used."
 	check.usage(sig.scope)
@@ -147,9 +152,9 @@ func (check *Checker) multipleDefaults(list []ast.Stmt) {
 	}
 }
 
-func (check *Checker) openScope(s ast.Node, comment string) {
-	scope := NewScope(check.scope, s.Pos(), s.End(), comment)
-	check.recordScope(s, scope)
+func (check *Checker) openScope(node ast.Node, comment string) {
+	scope := NewScope(check.scope, node.Pos(), node.End(), comment)
+	check.recordScope(node, scope)
 	check.scope = scope
 }
 
@@ -273,6 +278,9 @@ L:
 		if T == Typ[Invalid] {
 			continue L
 		}
+		if T != nil {
+			check.ordinaryType(e, T)
+		}
 		// look for duplicate types
 		// (quadratic algorithm, but type switches tend to be reasonably small)
 		for t, other := range seen {
@@ -355,8 +363,8 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
 			return
 		}
 
-		tch, ok := ch.typ.Underlying().(*Chan)
-		if !ok {
+		tch := asChan(ch.typ)
+		if tch == nil {
 			check.invalidOp(inNode(s, s.Arrow), _InvalidSend, "cannot send to non-chan type %s", ch.typ)
 			return
 		}
@@ -609,7 +617,7 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
 			return
 		}
 
-		// rhs must be of the form: expr.(type) and expr must be an interface
+		// rhs must be of the form: expr.(type) and expr must be an ordinary interface
 		expr, _ := rhs.(*ast.TypeAssertExpr)
 		if expr == nil || expr.Type != nil {
 			check.invalidAST(s, "incorrect form of type switch guard")
@@ -620,11 +628,12 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
 		if x.mode == invalid {
 			return
 		}
-		xtyp, _ := x.typ.Underlying().(*Interface)
+		xtyp, _ := under(x.typ).(*Interface)
 		if xtyp == nil {
 			check.errorf(&x, _InvalidTypeSwitch, "%s is not an interface", &x)
 			return
 		}
+		check.ordinaryType(&x, xtyp)
 
 		check.multipleDefaults(s.Body.List)
 
@@ -761,45 +770,24 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
 		// determine key/value types
 		var key, val Type
 		if x.mode != invalid {
-			switch typ := x.typ.Underlying().(type) {
-			case *Basic:
-				if isString(typ) {
-					key = Typ[Int]
-					val = universeRune // use 'rune' name
-				}
-			case *Array:
-				key = Typ[Int]
-				val = typ.elem
-			case *Slice:
-				key = Typ[Int]
-				val = typ.elem
-			case *Pointer:
-				if typ, _ := typ.base.Underlying().(*Array); typ != nil {
-					key = Typ[Int]
-					val = typ.elem
-				}
-			case *Map:
-				key = typ.key
-				val = typ.elem
-			case *Chan:
-				key = typ.elem
-				val = Typ[Invalid]
-				if typ.dir == SendOnly {
-					check.errorf(&x, _InvalidChanRange, "cannot range over send-only channel %s", &x)
-					// ok to continue
-				}
-				if s.Value != nil {
-					check.errorf(atPos(s.Value.Pos()), _InvalidIterVar, "iteration over %s permits only one iteration variable", &x)
-					// ok to continue
+			typ := optype(x.typ)
+			if _, ok := typ.(*Chan); ok && s.Value != nil {
+				// TODO(gri) this also needs to happen for channels in generic variables
+				check.softErrorf(atPos(s.Value.Pos()), _InvalidIterVar, "range over %s permits only one iteration variable", &x)
+				// ok to continue
+			}
+			var msg string
+			key, val, msg = rangeKeyVal(typ, isVarName(s.Key), isVarName(s.Value))
+			if key == nil || msg != "" {
+				if msg != "" {
+					// TODO(rFindley) should this be parenthesized, to be consistent with other qualifiers?
+					msg = ": " + msg
 				}
+				check.softErrorf(&x, _InvalidRangeExpr, "cannot range over %s%s", &x, msg)
+				// ok to continue
 			}
 		}
 
-		if key == nil {
-			check.errorf(&x, _InvalidRangeExpr, "cannot range over %s", &x)
-			// ok to continue
-		}
-
 		// check assignment to/declaration of iteration variables
 		// (irregular assignment, cannot easily map to existing assignment checks)
 
@@ -879,3 +867,72 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
 		check.invalidAST(s, "invalid statement")
 	}
 }
+
+// isVarName reports whether x is a non-nil, non-blank (_) expression.
+func isVarName(x ast.Expr) bool {
+	if x == nil {
+		return false
+	}
+	ident, _ := unparen(x).(*ast.Ident)
+	return ident == nil || ident.Name != "_"
+}
+
+// rangeKeyVal returns the key and value type produced by a range clause
+// over an expression of type typ, and possibly an error message. If the
+// range clause is not permitted the returned key is nil or msg is not
+// empty (in that case we still may have a non-nil key type which can be
+// used to reduce the chance for follow-on errors).
+// The wantKey, wantVal, and hasVal flags indicate which of the iteration
+// variables are used or present; this matters if we range over a generic
+// type where not all keys or values are of the same type.
+func rangeKeyVal(typ Type, wantKey, wantVal bool) (Type, Type, string) {
+	switch typ := typ.(type) {
+	case *Basic:
+		if isString(typ) {
+			return Typ[Int], universeRune, "" // use 'rune' name
+		}
+	case *Array:
+		return Typ[Int], typ.elem, ""
+	case *Slice:
+		return Typ[Int], typ.elem, ""
+	case *Pointer:
+		if typ := asArray(typ.base); typ != nil {
+			return Typ[Int], typ.elem, ""
+		}
+	case *Map:
+		return typ.key, typ.elem, ""
+	case *Chan:
+		var msg string
+		if typ.dir == SendOnly {
+			msg = "send-only channel"
+		}
+		return typ.elem, Typ[Invalid], msg
+	case *Sum:
+		first := true
+		var key, val Type
+		var msg string
+		typ.is(func(t Type) bool {
+			k, v, m := rangeKeyVal(under(t), wantKey, wantVal)
+			if k == nil || m != "" {
+				key, val, msg = k, v, m
+				return false
+			}
+			if first {
+				key, val, msg = k, v, m
+				first = false
+				return true
+			}
+			if wantKey && !Identical(key, k) {
+				key, val, msg = nil, nil, "all possible values must have the same key type"
+				return false
+			}
+			if wantVal && !Identical(val, v) {
+				key, val, msg = nil, nil, "all possible values must have the same element type"
+				return false
+			}
+			return true
+		})
+		return key, val, msg
+	}
+	return nil, nil, ""
+}
diff --git a/src/go/types/testdata/stmt0.src b/src/go/types/testdata/stmt0.src
index fde846962e..297e34be42 100644
--- a/src/go/types/testdata/stmt0.src
+++ b/src/go/types/testdata/stmt0.src
@@ -886,7 +886,7 @@ func rangeloops1() {
 		ee = e
 		_ = ee
 	}
-	for _ = range sc /* ERROR "cannot range over send-only channel" */ {}
+	for _ = range sc /* ERROR "cannot range over" */ {}
 	for _ = range rc {}
 
 	// constant strings
-- 
GitLab


From 8c5aa42c798cac76cab67f85521c68e9dbff70b0 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 8 Jan 2021 20:46:03 -0800
Subject: [PATCH 0454/2400] [dev.typeparams] cmd/compile: calculate variable
 sizes in walk

Walk already explicitly calculates the size of all expression types,
to make sure they're known before SSA generation (which is concurrent,
and thus not safe to modify shared state like types). Might as well
compute all local variable sizes too, to be consistent.

Reduces the burden of the frontend to make sure it's calculated the
size of types that only the backend cares about.

Passes toolstash -cmp.

Change-Id: I68bcca67b4640bfc875467e4ed4d47104b1932f4
Reviewed-on: https://go-review.googlesource.com/c/go/+/282912
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/walk/walk.go | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index 928b673752..4a89d2201d 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -57,6 +57,11 @@ func Walk(fn *ir.Func) {
 	if base.Flag.Cfg.Instrumenting {
 		instrument(fn)
 	}
+
+	// Eagerly compute sizes of all variables for SSA.
+	for _, n := range fn.Dcl {
+		types.CalcSize(n.Type())
+	}
 }
 
 func paramoutheap(fn *ir.Func) bool {
-- 
GitLab


From 8123bc90b85ef685f1c877346c2378651a42d529 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 8 Jan 2021 20:44:53 -0800
Subject: [PATCH 0455/2400] [dev.typeparams] cmd/go: relax test expectation

go/types reports `"pkg/path" imported and not used` rather than
`imported and not used: "pkg/path"`, like cmd/compile. Relax the test
expectation to accomodate either.

Change-Id: I318992946160a9090f8991f4c97784ba1d1b78b4
Reviewed-on: https://go-review.googlesource.com/c/go/+/282913
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/go/testdata/script/vendor_test_issue14613.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/go/testdata/script/vendor_test_issue14613.txt b/src/cmd/go/testdata/script/vendor_test_issue14613.txt
index 7801e6944d..cfd7e58f4f 100644
--- a/src/cmd/go/testdata/script/vendor_test_issue14613.txt
+++ b/src/cmd/go/testdata/script/vendor_test_issue14613.txt
@@ -19,4 +19,4 @@ go test github.com/clsung/go-vendor-issue-14613/vendor_test.go
 # test with imported and not used
 go test -i github.com/clsung/go-vendor-issue-14613/vendor/mylibtesttest/myapp/myapp_test.go
 ! go test github.com/clsung/go-vendor-issue-14613/vendor/mylibtesttest/myapp/myapp_test.go
-stderr 'imported and not used:'
+stderr 'imported and not used'
-- 
GitLab


From 44d1a8523a50c30354e0b1ef70953567c26eed1a Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 8 Jan 2021 19:28:24 -0800
Subject: [PATCH 0456/2400] [dev.typeparams] cmd/compile/internal/types2: fixes
 for all.bash

This CL implements a number of minor fixes that were discovered in
getting -G=3 working for running all.bash.

1. Field tags were handled incorrectly. If a struct type had some
fields with tags, but later fields without tags, the trailing tag-less
fields would all copy the tag of the last tagged field. Fixed by
simply reinitializing `tag` to "" for each field visited.

2. Change the ending of switch case clause scopes from the end of the
last statement to the next "case" token or the switch-ending "}"
token. I don't think this is strictly necessary, but it matches my
intuition about where case-clause scopes end and cmd/compile's current
scoping logic (admittedly influenced by the former).

3. Change select statements to correctly use the scope of each
individual communication clause, instead of the scope of the entire
select statement. This issue appears to be due to the original
go/types code being written to rebind "s" from the *SelectStmt to the
Stmt in the range loop, and then being further asserted to "clause" of
type *CommClause. In most places within the loop body, "clause" was
used, but the rebound "s" identifier was used for the scope
boundaries.

However, in the syntax AST, SelectStmt directly contains a
[]*CommClause (rather than a *BlockStmt, with []Stmt), so no assertion
is necessary and instead of rebinding "s", the range loop was updated
to directly declare "clause".

4. The end position for increment/decrement statements (x++/x--) was
incorrectly calculated. Within the syntax AST, these are represented
as "x += ImplicitOne", and for AssignStmts types2 calculated the end
position as the end position of the RHS operand. But ImplicitOne
doesn't have any position information.

To workaround this, this CL detects ImplicitOne and then computes the
end position of the LHS operand instead, and then adds 2. In practice
this should be correct, though it could be wrong for ill-formatted
statements like "x ++".

Change-Id: I13d4830af39cb3f3b9f0d996672869d3db047ed2
Reviewed-on: https://go-review.googlesource.com/c/go/+/282914
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/types2/api_test.go |  4 +--
 src/cmd/compile/internal/types2/pos.go      |  4 +++
 src/cmd/compile/internal/types2/stmt.go     | 31 +++++++++++++++------
 src/cmd/compile/internal/types2/typexpr.go  |  1 +
 4 files changed, 30 insertions(+), 10 deletions(-)

diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go
index d9647b9432..81fc1243e9 100644
--- a/src/cmd/compile/internal/types2/api_test.go
+++ b/src/cmd/compile/internal/types2/api_test.go
@@ -799,10 +799,10 @@ func TestScopesInfo(t *testing.T) {
 			"file:", "func:",
 		}},
 		{`package p15; func _(c chan int) { select{ case <-c: } }`, []string{
-			"file:", "func:c", "select:",
+			"file:", "func:c", "comm:",
 		}},
 		{`package p16; func _(c chan int) { select{ case i := <-c: x := i; _ = x} }`, []string{
-			"file:", "func:c", "select:i x",
+			"file:", "func:c", "comm:i x",
 		}},
 		{`package p17; func _() { for{} }`, []string{
 			"file:", "func:", "for:", "block:",
diff --git a/src/cmd/compile/internal/types2/pos.go b/src/cmd/compile/internal/types2/pos.go
index 4dd839b7dc..0a19cd1a23 100644
--- a/src/cmd/compile/internal/types2/pos.go
+++ b/src/cmd/compile/internal/types2/pos.go
@@ -286,6 +286,10 @@ func endPos(n syntax.Node) syntax.Pos {
 			return n.Pos()
 		case *syntax.AssignStmt:
 			m = n.Rhs
+			if m == syntax.ImplicitOne {
+				p := endPos(n.Lhs)
+				return syntax.MakePos(p.Base(), p.Line(), p.Col()+2)
+			}
 		case *syntax.BranchStmt:
 			if n.Label != nil {
 				m = n.Label
diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go
index 3463cfdf57..52b9794c10 100644
--- a/src/cmd/compile/internal/types2/stmt.go
+++ b/src/cmd/compile/internal/types2/stmt.go
@@ -156,7 +156,11 @@ func (check *Checker) multipleSelectDefaults(list []*syntax.CommClause) {
 }
 
 func (check *Checker) openScope(node syntax.Node, comment string) {
-	scope := NewScope(check.scope, node.Pos(), endPos(node), comment)
+	check.openScopeUntil(node, endPos(node), comment)
+}
+
+func (check *Checker) openScopeUntil(node syntax.Node, end syntax.Pos, comment string) {
+	scope := NewScope(check.scope, node.Pos(), end, comment)
 	check.recordScope(node, scope)
 	check.scope = scope
 }
@@ -522,7 +526,7 @@ func (check *Checker) stmt(ctxt stmtContext, s syntax.Stmt) {
 
 		check.multipleSelectDefaults(s.Body)
 
-		for _, clause := range s.Body {
+		for i, clause := range s.Body {
 			if clause == nil {
 				continue // error reported before
 			}
@@ -552,8 +556,11 @@ func (check *Checker) stmt(ctxt stmtContext, s syntax.Stmt) {
 				check.error(clause.Comm, "select case must be send or receive (possibly with assignment)")
 				continue
 			}
-
-			check.openScope(s, "case")
+			end := s.Rbrace
+			if i+1 < len(s.Body) {
+				end = s.Body[i+1].Pos()
+			}
+			check.openScopeUntil(clause, end, "case")
 			if clause.Comm != nil {
 				check.stmt(inner, clause.Comm)
 			}
@@ -631,14 +638,16 @@ func (check *Checker) switchStmt(inner stmtContext, s *syntax.SwitchStmt) {
 			check.invalidASTf(clause, "incorrect expression switch case")
 			continue
 		}
-		check.caseValues(&x, unpackExpr(clause.Cases), seen)
-		check.openScope(clause, "case")
+		end := s.Rbrace
 		inner := inner
 		if i+1 < len(s.Body) {
+			end = s.Body[i+1].Pos()
 			inner |= fallthroughOk
 		} else {
 			inner |= finalSwitchCase
 		}
+		check.caseValues(&x, unpackExpr(clause.Cases), seen)
+		check.openScopeUntil(clause, end, "case")
 		check.stmtList(inner, clause.Body)
 		check.closeScope()
 	}
@@ -681,15 +690,19 @@ func (check *Checker) typeSwitchStmt(inner stmtContext, s *syntax.SwitchStmt, gu
 
 	var lhsVars []*Var                // list of implicitly declared lhs variables
 	seen := make(map[Type]syntax.Pos) // map of seen types to positions
-	for _, clause := range s.Body {
+	for i, clause := range s.Body {
 		if clause == nil {
 			check.invalidASTf(s, "incorrect type switch case")
 			continue
 		}
+		end := s.Rbrace
+		if i+1 < len(s.Body) {
+			end = s.Body[i+1].Pos()
+		}
 		// Check each type in this type switch case.
 		cases := unpackExpr(clause.Cases)
 		T := check.caseTypes(&x, xtyp, cases, seen, false)
-		check.openScope(clause, "case")
+		check.openScopeUntil(clause, end, "case")
 		// If lhs exists, declare a corresponding variable in the case-local scope.
 		if lhs != nil {
 			// spec: "The TypeSwitchGuard may include a short variable declaration.
@@ -701,6 +714,8 @@ func (check *Checker) typeSwitchStmt(inner stmtContext, s *syntax.SwitchStmt, gu
 				T = x.typ
 			}
 			obj := NewVar(lhs.Pos(), check.pkg, lhs.Value, T)
+			// TODO(mdempsky): Just use clause.Colon? Why did I even suggest
+			// "at the end of the TypeSwitchCase" in #16794 instead?
 			scopePos := clause.Pos() // for default clause (len(List) == 0)
 			if n := len(cases); n > 0 {
 				scopePos = endPos(cases[n-1])
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 910db0819f..32377ed3f4 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -1110,6 +1110,7 @@ func (check *Checker) structType(styp *Struct, e *syntax.StructType) {
 			typ = check.varType(f.Type)
 			prev = f.Type
 		}
+		tag = ""
 		if i < len(e.TagList) {
 			tag = check.tag(e.TagList[i])
 		}
-- 
GitLab


From 2e8f29b79d4bce097ebe0c822b469d4714657395 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 8 Jan 2021 19:27:51 -0800
Subject: [PATCH 0457/2400] [dev.typeparams] cmd/compile: add types2.Sizes
 implementation

This CL adds an implementation of types2.Sizes that calculates sizes
using the same sizing algorithm as cmd/compile. In particular, it
matches how cmd/compile pads structures and includes padding in size
calculations.

Change-Id: I4dd8e51f95c90f9d7bd1e7463e40edcd3955a219
Reviewed-on: https://go-review.googlesource.com/c/go/+/282915
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/noder.go |   1 +
 src/cmd/compile/internal/noder/sizes.go | 150 ++++++++++++++++++++++++
 2 files changed, 151 insertions(+)
 create mode 100644 src/cmd/compile/internal/noder/sizes.go

diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 938ffe05ce..099e3a6956 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -133,6 +133,7 @@ func ParseFiles(filenames []string) (lines uint) {
 					return os.Open(file)
 				},
 			},
+			Sizes: &gcSizes{},
 		}
 		info := types2.Info{
 			Types:      make(map[syntax.Expr]types2.TypeAndValue),
diff --git a/src/cmd/compile/internal/noder/sizes.go b/src/cmd/compile/internal/noder/sizes.go
new file mode 100644
index 0000000000..7cda6da9a6
--- /dev/null
+++ b/src/cmd/compile/internal/noder/sizes.go
@@ -0,0 +1,150 @@
+// Copyright 2021 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 noder
+
+import (
+	"fmt"
+
+	"cmd/compile/internal/types"
+	"cmd/compile/internal/types2"
+)
+
+// Code below based on go/types.StdSizes.
+// Intentional differences are marked with "gc:".
+
+type gcSizes struct{}
+
+func (s *gcSizes) Alignof(T types2.Type) int64 {
+	// For arrays and structs, alignment is defined in terms
+	// of alignment of the elements and fields, respectively.
+	switch t := T.Underlying().(type) {
+	case *types2.Array:
+		// spec: "For a variable x of array type: unsafe.Alignof(x)
+		// is the same as unsafe.Alignof(x[0]), but at least 1."
+		return s.Alignof(t.Elem())
+	case *types2.Struct:
+		// spec: "For a variable x of struct type: unsafe.Alignof(x)
+		// is the largest of the values unsafe.Alignof(x.f) for each
+		// field f of x, but at least 1."
+		max := int64(1)
+		for i, nf := 0, t.NumFields(); i < nf; i++ {
+			if a := s.Alignof(t.Field(i).Type()); a > max {
+				max = a
+			}
+		}
+		return max
+	case *types2.Slice, *types2.Interface:
+		// Multiword data structures are effectively structs
+		// in which each element has size PtrSize.
+		return int64(types.PtrSize)
+	case *types2.Basic:
+		// Strings are like slices and interfaces.
+		if t.Info()&types2.IsString != 0 {
+			return int64(types.PtrSize)
+		}
+	}
+	a := s.Sizeof(T) // may be 0
+	// spec: "For a variable x of any type: unsafe.Alignof(x) is at least 1."
+	if a < 1 {
+		return 1
+	}
+	// complex{64,128} are aligned like [2]float{32,64}.
+	if isComplex(T) {
+		a /= 2
+	}
+	if a > int64(types.RegSize) {
+		return int64(types.RegSize)
+	}
+	return a
+}
+
+func isComplex(T types2.Type) bool {
+	basic, ok := T.Underlying().(*types2.Basic)
+	return ok && basic.Info()&types2.IsComplex != 0
+}
+
+func (s *gcSizes) Offsetsof(fields []*types2.Var) []int64 {
+	offsets := make([]int64, len(fields))
+	var o int64
+	for i, f := range fields {
+		typ := f.Type()
+		a := s.Alignof(typ)
+		o = types.Rnd(o, a)
+		offsets[i] = o
+		o += s.Sizeof(typ)
+	}
+	return offsets
+}
+
+func (s *gcSizes) Sizeof(T types2.Type) int64 {
+	switch t := T.Underlying().(type) {
+	case *types2.Basic:
+		k := t.Kind()
+		if int(k) < len(basicSizes) {
+			if s := basicSizes[k]; s > 0 {
+				return int64(s)
+			}
+		}
+		switch k {
+		case types2.String:
+			return int64(types.PtrSize) * 2
+		case types2.Int, types2.Uint, types2.Uintptr, types2.UnsafePointer:
+			return int64(types.PtrSize)
+		}
+		panic(fmt.Sprintf("unimplemented basic: %v (kind %v)", T, k))
+	case *types2.Array:
+		n := t.Len()
+		if n <= 0 {
+			return 0
+		}
+		// n > 0
+		// gc: Size includes alignment padding.
+		return s.Sizeof(t.Elem()) * n
+	case *types2.Slice:
+		return int64(types.PtrSize) * 3
+	case *types2.Struct:
+		n := t.NumFields()
+		if n == 0 {
+			return 0
+		}
+		fields := make([]*types2.Var, n)
+		for i := range fields {
+			fields[i] = t.Field(i)
+		}
+		offsets := s.Offsetsof(fields)
+
+		// gc: The last field of a struct is not allowed to
+		// have size 0.
+		last := s.Sizeof(fields[n-1].Type())
+		if last == 0 {
+			last = 1
+		}
+
+		// gc: Size includes alignment padding.
+		return types.Rnd(offsets[n-1]+last, s.Alignof(t))
+	case *types2.Interface:
+		return int64(types.PtrSize) * 2
+	case *types2.Chan, *types2.Map, *types2.Pointer, *types2.Signature:
+		return int64(types.PtrSize)
+	default:
+		panic(fmt.Sprintf("unimplemented type: %T", t))
+	}
+}
+
+var basicSizes = [...]byte{
+	types2.Bool:       1,
+	types2.Int8:       1,
+	types2.Int16:      2,
+	types2.Int32:      4,
+	types2.Int64:      8,
+	types2.Uint8:      1,
+	types2.Uint16:     2,
+	types2.Uint32:     4,
+	types2.Uint64:     8,
+	types2.Float32:    4,
+	types2.Float64:    8,
+	types2.Complex64:  8,
+	types2.Complex128: 16,
+}
-- 
GitLab


From 3e1a87ac2a9dbf7754be4feb8681af3b1881eda7 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 9 Jan 2021 23:36:13 -0800
Subject: [PATCH 0458/2400] [dev.typeparams] cmd/compile: extract posMap from
 noder

This CL extracts the position mapping logic from noder and moves it
into a new posMap type, which can be more easily reused.

Passes toolstash -cmp.

Change-Id: I87dec3a3d27779c5bcc838f2e36c3aa8fabad155
Reviewed-on: https://go-review.googlesource.com/c/go/+/282916
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/noder.go  | 60 +++---------------
 src/cmd/compile/internal/noder/posmap.go | 79 ++++++++++++++++++++++++
 2 files changed, 86 insertions(+), 53 deletions(-)
 create mode 100644 src/cmd/compile/internal/noder/posmap.go

diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 099e3a6956..3e4d2c9bee 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -59,7 +59,6 @@ func ParseFiles(filenames []string) (lines uint) {
 
 	for _, filename := range filenames {
 		p := &noder{
-			basemap:     make(map[*syntax.PosBase]*src.PosBase),
 			err:         make(chan syntax.Error),
 			trackScopes: base.Flag.Dwarf,
 		}
@@ -271,42 +270,6 @@ func (m *gcimports) ImportFrom(path, srcDir string, mode types2.ImportMode) (*ty
 	return importer.Import(m.packages, path, srcDir, m.lookup)
 }
 
-// makeSrcPosBase translates from a *syntax.PosBase to a *src.PosBase.
-func (p *noder) makeSrcPosBase(b0 *syntax.PosBase) *src.PosBase {
-	// fast path: most likely PosBase hasn't changed
-	if p.basecache.last == b0 {
-		return p.basecache.base
-	}
-
-	b1, ok := p.basemap[b0]
-	if !ok {
-		fn := b0.Filename()
-		if b0.IsFileBase() {
-			b1 = src.NewFileBase(fn, absFilename(fn))
-		} else {
-			// line directive base
-			p0 := b0.Pos()
-			p0b := p0.Base()
-			if p0b == b0 {
-				panic("infinite recursion in makeSrcPosBase")
-			}
-			p1 := src.MakePos(p.makeSrcPosBase(p0b), p0.Line(), p0.Col())
-			b1 = src.NewLinePragmaBase(p1, fn, fileh(fn), b0.Line(), b0.Col())
-		}
-		p.basemap[b0] = b1
-	}
-
-	// update cache
-	p.basecache.last = b0
-	p.basecache.base = b1
-
-	return b1
-}
-
-func (p *noder) makeXPos(pos syntax.Pos) (_ src.XPos) {
-	return base.Ctxt.PosTable.XPos(src.MakePos(p.makeSrcPosBase(pos.Base()), pos.Line(), pos.Col()))
-}
-
 func (p *noder) errorAt(pos syntax.Pos, format string, args ...interface{}) {
 	base.ErrorfAt(p.makeXPos(pos), format, args...)
 }
@@ -322,11 +285,7 @@ func absFilename(name string) string {
 
 // noder transforms package syntax's AST into a Node tree.
 type noder struct {
-	basemap   map[*syntax.PosBase]*src.PosBase
-	basecache struct {
-		last *syntax.PosBase
-		base *src.PosBase
-	}
+	posMap
 
 	file           *syntax.File
 	linknames      []linkname
@@ -900,7 +859,11 @@ func (p *noder) expr(expr syntax.Expr) ir.Node {
 	case *syntax.Name:
 		return p.mkname(expr)
 	case *syntax.BasicLit:
-		n := ir.NewBasicLit(p.pos(expr), p.basicLit(expr))
+		pos := base.Pos
+		if expr != syntax.ImplicitOne { // ImplicitOne doesn't have a unique position
+			pos = p.pos(expr)
+		}
+		n := ir.NewBasicLit(pos, p.basicLit(expr))
 		if expr.Kind == syntax.RuneLit {
 			n.SetType(types.UntypedRune)
 		}
@@ -1720,17 +1683,8 @@ func (p *noder) wrapname(n syntax.Node, x ir.Node) ir.Node {
 	return x
 }
 
-func (p *noder) pos(n syntax.Node) src.XPos {
-	// TODO(gri): orig.Pos() should always be known - fix package syntax
-	xpos := base.Pos
-	if pos := n.Pos(); pos.IsKnown() {
-		xpos = p.makeXPos(pos)
-	}
-	return xpos
-}
-
 func (p *noder) setlineno(n syntax.Node) {
-	if n != nil {
+	if n != nil && n != syntax.ImplicitOne {
 		base.Pos = p.pos(n)
 	}
 }
diff --git a/src/cmd/compile/internal/noder/posmap.go b/src/cmd/compile/internal/noder/posmap.go
new file mode 100644
index 0000000000..d24f706281
--- /dev/null
+++ b/src/cmd/compile/internal/noder/posmap.go
@@ -0,0 +1,79 @@
+// Copyright 2021 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 noder
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/syntax"
+	"cmd/internal/src"
+)
+
+// A posMap handles mapping from syntax.Pos to src.XPos.
+type posMap struct {
+	bases map[*syntax.PosBase]*src.PosBase
+	cache struct {
+		last *syntax.PosBase
+		base *src.PosBase
+	}
+}
+
+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 {
+	if !pos.IsKnown() {
+		base.Fatalf("unknown position")
+	}
+
+	posBase := m.makeSrcPosBase(pos.Base())
+	return base.Ctxt.PosTable.XPos(src.MakePos(posBase, pos.Line(), pos.Col()))
+}
+
+// makeSrcPosBase translates from a *syntax.PosBase to a *src.PosBase.
+func (m *posMap) makeSrcPosBase(b0 *syntax.PosBase) *src.PosBase {
+	// fast path: most likely PosBase hasn't changed
+	if m.cache.last == b0 {
+		return m.cache.base
+	}
+
+	b1, ok := m.bases[b0]
+	if !ok {
+		fn := b0.Filename()
+		if b0.IsFileBase() {
+			b1 = src.NewFileBase(fn, absFilename(fn))
+		} else {
+			// line directive base
+			p0 := b0.Pos()
+			p0b := p0.Base()
+			if p0b == b0 {
+				panic("infinite recursion in makeSrcPosBase")
+			}
+			p1 := src.MakePos(m.makeSrcPosBase(p0b), p0.Line(), p0.Col())
+			b1 = src.NewLinePragmaBase(p1, fn, fileh(fn), b0.Line(), b0.Col())
+		}
+		if m.bases == nil {
+			m.bases = make(map[*syntax.PosBase]*src.PosBase)
+		}
+		m.bases[b0] = b1
+	}
+
+	// update cache
+	m.cache.last = b0
+	m.cache.base = b1
+
+	return b1
+}
+
+func (m *posMap) join(other *posMap) {
+	for k, v := range other.bases {
+		if m.bases[k] != nil {
+			base.Fatalf("duplicate posmap bases")
+		}
+		m.bases[k] = v
+	}
+}
-- 
GitLab


From 9e746e4255c582eb025d64ec9b3631ec7f56550e Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 9 Jan 2021 17:34:17 -0800
Subject: [PATCH 0459/2400] [dev.typeparams] cmd/compile: refactor varEmbed
 logic

Simplify the code and make it easier to reuse with irgen.

Change-Id: Id477c36e82c7598faa90025b1eed2606a3f82498
Reviewed-on: https://go-review.googlesource.com/c/go/+/282917
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/noder.go | 75 ++++++++-----------------
 1 file changed, 24 insertions(+), 51 deletions(-)

diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 3e4d2c9bee..b3f3c23c29 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -5,6 +5,7 @@
 package noder
 
 import (
+	"errors"
 	"fmt"
 	"go/constant"
 	"go/token"
@@ -556,19 +557,8 @@ func (p *noder) varDecl(decl *syntax.VarDecl) []ir.Node {
 	exprs := p.exprList(decl.Values)
 
 	if pragma, ok := decl.Pragma.(*pragmas); ok {
-		if len(pragma.Embeds) > 0 {
-			if !p.importedEmbed {
-				// This check can't be done when building the list pragma.Embeds
-				// because that list is created before the noder starts walking over the file,
-				// so at that point it hasn't seen the imports.
-				// We're left to check now, just before applying the //go:embed lines.
-				for _, e := range pragma.Embeds {
-					p.errorAt(e.Pos, "//go:embed only allowed in Go files that import \"embed\"")
-				}
-			} else {
-				exprs = varEmbed(p, names, typ, exprs, pragma.Embeds)
-			}
-			pragma.Embeds = nil
+		if err := varEmbed(p.makeXPos, names[0], decl, pragma); err != nil {
+			p.errorAt(decl.Pos(), "%s", err.Error())
 		}
 		p.checkUnused(pragma)
 	}
@@ -2069,53 +2059,36 @@ func oldname(s *types.Sym) ir.Node {
 	return n
 }
 
-func varEmbed(p *noder, names []*ir.Name, typ ir.Ntype, exprs []ir.Node, embeds []pragmaEmbed) (newExprs []ir.Node) {
-	haveEmbed := false
-	for _, decl := range p.file.DeclList {
-		imp, ok := decl.(*syntax.ImportDecl)
-		if !ok {
-			// imports always come first
-			break
-		}
-		path, _ := strconv.Unquote(imp.Path.Value)
-		if path == "embed" {
-			haveEmbed = true
-			break
-		}
+func varEmbed(makeXPos func(syntax.Pos) src.XPos, name *ir.Name, decl *syntax.VarDecl, pragma *pragmas) error {
+	if pragma.Embeds == nil {
+		return nil
 	}
 
-	pos := embeds[0].Pos
-	if !haveEmbed {
-		p.errorAt(pos, "invalid go:embed: missing import \"embed\"")
-		return exprs
-	}
+	pragmaEmbeds := pragma.Embeds
+	pragma.Embeds = nil
+
 	if base.Flag.Cfg.Embed.Patterns == nil {
-		p.errorAt(pos, "invalid go:embed: build system did not supply embed configuration")
-		return exprs
+		return errors.New("invalid go:embed: build system did not supply embed configuration")
 	}
-	if len(names) > 1 {
-		p.errorAt(pos, "go:embed cannot apply to multiple vars")
-		return exprs
+	if len(decl.NameList) > 1 {
+		return errors.New("go:embed cannot apply to multiple vars")
 	}
-	if len(exprs) > 0 {
-		p.errorAt(pos, "go:embed cannot apply to var with initializer")
-		return exprs
+	if decl.Values != nil {
+		return errors.New("go:embed cannot apply to var with initializer")
 	}
-	if typ == nil {
-		// Should not happen, since len(exprs) == 0 now.
-		p.errorAt(pos, "go:embed cannot apply to var without type")
-		return exprs
+	if decl.Type == nil {
+		// Should not happen, since Values == nil now.
+		return errors.New("go:embed cannot apply to var without type")
 	}
 	if typecheck.DeclContext != ir.PEXTERN {
-		p.errorAt(pos, "go:embed cannot apply to var inside func")
-		return exprs
+		return errors.New("go:embed cannot apply to var inside func")
 	}
 
-	v := names[0]
-	typecheck.Target.Embeds = append(typecheck.Target.Embeds, v)
-	v.Embed = new([]ir.Embed)
-	for _, e := range embeds {
-		*v.Embed = append(*v.Embed, ir.Embed{Pos: p.makeXPos(e.Pos), Patterns: e.Patterns})
+	var embeds []ir.Embed
+	for _, e := range pragmaEmbeds {
+		embeds = append(embeds, ir.Embed{Pos: makeXPos(e.Pos), Patterns: e.Patterns})
 	}
-	return exprs
+	typecheck.Target.Embeds = append(typecheck.Target.Embeds, name)
+	name.Embed = &embeds
+	return nil
 }
-- 
GitLab


From f57f484053f276c6fb57047cf02fa043974d7b95 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 11 Jan 2021 14:30:16 -0800
Subject: [PATCH 0460/2400] [dev.regabi] cmd/compile: decouple escape analysis
 from Name.Vargen

Escape analysis needs to know the index of result parameters for
recording escape-flow information. It currently relies on Vargen for
this, but it can easily figure this out for itself. So just do that
instead, so that we can remove Vargen.

Passes toolstash -cmp.

For #43633.

Change-Id: I65dedc2d73bc25e85ff400f308e50b73dc503630
Reviewed-on: https://go-review.googlesource.com/c/go/+/283192
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/escape/escape.go | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index c63383af43..bee3878f10 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -126,6 +126,11 @@ type location struct {
 	edges     []edge   // incoming edges
 	loopDepth int      // loopDepth at declaration
 
+	// resultIndex records the tuple index (starting at 1) for
+	// PPARAMOUT variables within their function's result type.
+	// For non-PPARAMOUT variables it's 0.
+	resultIndex int
+
 	// derefs and walkgen are used during walkOne to track the
 	// minimal dereferences from the walk root.
 	derefs  int // >= -1
@@ -259,11 +264,16 @@ func (b *batch) initFunc(fn *ir.Func) {
 	}
 
 	// Allocate locations for local variables.
-	for _, dcl := range fn.Dcl {
-		if dcl.Op() == ir.ONAME {
-			e.newLoc(dcl, false)
+	for _, n := range fn.Dcl {
+		if n.Op() == ir.ONAME {
+			e.newLoc(n, false)
 		}
 	}
+
+	// Initialize resultIndex for result parameters.
+	for i, f := range fn.Type().Results().FieldSlice() {
+		e.oldLoc(f.Nname.(*ir.Name)).resultIndex = 1 + i
+	}
 }
 
 func (b *batch) walkFunc(fn *ir.Func) {
@@ -1609,8 +1619,7 @@ func (l *location) leakTo(sink *location, derefs int) {
 	// If sink is a result parameter and we can fit return bits
 	// into the escape analysis tag, then record a return leak.
 	if sink.isName(ir.PPARAMOUT) && sink.curfn == l.curfn {
-		// TODO(mdempsky): Eliminate dependency on Vargen here.
-		ri := int(sink.n.Name().Vargen) - 1
+		ri := sink.resultIndex - 1
 		if ri < numEscResults {
 			// Leak to result parameter.
 			l.paramEsc.AddResult(ri, derefs)
-- 
GitLab


From 6a56c6c870a2ac8bae9e570641521ba5aa83ba51 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Mon, 11 Jan 2021 16:16:54 -0500
Subject: [PATCH 0461/2400] [dev.typeparams] go/types: import dev.go2go changes
 to check tests

Import changes from go2go to automatically discover testdata-driven
check tests.

Tests for generics will be added in a subsequent CL.

Change-Id: I50d55141750caebf15f1f382e139edfe9920c14e
Reviewed-on: https://go-review.googlesource.com/c/go/+/283132
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/check_test.go                    | 127 +++++++-----------
 .../types/testdata/{ => decls2}/decls2a.src   |   0
 .../types/testdata/{ => decls2}/decls2b.src   |   0
 .../{ => importdecl0}/importdecl0a.src        |   0
 .../{ => importdecl0}/importdecl0b.src        |   0
 .../{ => importdecl1}/importdecl1a.src        |   0
 .../{ => importdecl1}/importdecl1b.src        |   0
 .../testdata/{ => issue25008}/issue25008a.src |   0
 .../testdata/{ => issue25008}/issue25008b.src |   0
 9 files changed, 51 insertions(+), 76 deletions(-)
 rename src/go/types/testdata/{ => decls2}/decls2a.src (100%)
 rename src/go/types/testdata/{ => decls2}/decls2b.src (100%)
 rename src/go/types/testdata/{ => importdecl0}/importdecl0a.src (100%)
 rename src/go/types/testdata/{ => importdecl0}/importdecl0b.src (100%)
 rename src/go/types/testdata/{ => importdecl1}/importdecl1a.src (100%)
 rename src/go/types/testdata/{ => importdecl1}/importdecl1b.src (100%)
 rename src/go/types/testdata/{ => issue25008}/issue25008a.src (100%)
 rename src/go/types/testdata/{ => issue25008}/issue25008b.src (100%)

diff --git a/src/go/types/check_test.go b/src/go/types/check_test.go
index ce31dab68b..66943d676c 100644
--- a/src/go/types/check_test.go
+++ b/src/go/types/check_test.go
@@ -27,12 +27,14 @@ package types_test
 
 import (
 	"flag"
+	"fmt"
 	"go/ast"
 	"go/importer"
 	"go/parser"
 	"go/scanner"
 	"go/token"
 	"internal/testenv"
+	"io/ioutil"
 	"os"
 	"path/filepath"
 	"regexp"
@@ -48,54 +50,6 @@ var (
 	testFiles   = flag.String("files", "", "space-separated list of test files")
 )
 
-// The test filenames do not end in .go so that they are invisible
-// to gofmt since they contain comments that must not change their
-// positions relative to surrounding tokens.
-
-// Each tests entry is list of files belonging to the same package.
-var tests = [][]string{
-	{"testdata/errors.src"},
-	{"testdata/importdecl0a.src", "testdata/importdecl0b.src"},
-	{"testdata/importdecl1a.src", "testdata/importdecl1b.src"},
-	{"testdata/importC.src"}, // special handling in checkFiles
-	{"testdata/cycles.src"},
-	{"testdata/cycles1.src"},
-	{"testdata/cycles2.src"},
-	{"testdata/cycles3.src"},
-	{"testdata/cycles4.src"},
-	{"testdata/cycles5.src"},
-	{"testdata/init0.src"},
-	{"testdata/init1.src"},
-	{"testdata/init2.src"},
-	{"testdata/decls0.src"},
-	{"testdata/decls1.src"},
-	{"testdata/decls2a.src", "testdata/decls2b.src"},
-	{"testdata/decls3.src"},
-	{"testdata/decls4.src"},
-	{"testdata/decls5.src"},
-	{"testdata/const0.src"},
-	{"testdata/const1.src"},
-	{"testdata/constdecl.src"},
-	{"testdata/vardecl.src"},
-	{"testdata/expr0.src"},
-	{"testdata/expr1.src"},
-	{"testdata/expr2.src"},
-	{"testdata/expr3.src"},
-	{"testdata/methodsets.src"},
-	{"testdata/shifts.src"},
-	{"testdata/builtins.src"},
-	{"testdata/conversions.src"},
-	{"testdata/conversions2.src"},
-	{"testdata/stmt0.src"},
-	{"testdata/stmt1.src"},
-	{"testdata/gotos.src"},
-	{"testdata/labels.src"},
-	{"testdata/literals.src"},
-	{"testdata/issues.src"},
-	{"testdata/blank.src"},
-	{"testdata/issue25008b.src", "testdata/issue25008a.src"}, // order (b before a) is crucial!
-}
-
 var fset = token.NewFileSet()
 
 // Positioned errors are of the form filename:line:column: message .
@@ -236,9 +190,9 @@ func eliminate(t *testing.T, errmap map[string][]string, errlist []error) {
 	}
 }
 
-func checkFiles(t *testing.T, testfiles []string) {
+func checkFiles(t *testing.T, sources []string) {
 	// parse files and collect parser errors
-	files, errlist := parseFiles(t, testfiles)
+	files, errlist := parseFiles(t, sources)
 
 	pkgName := "<no package>"
 	if len(files) > 0 {
@@ -254,10 +208,14 @@ func checkFiles(t *testing.T, testfiles []string) {
 
 	// typecheck and collect typechecker errors
 	var conf Config
+	// TODO(rFindley) parse generics when given a .go2 suffix.
+
 	// special case for importC.src
-	if len(testfiles) == 1 && strings.HasSuffix(testfiles[0], "importC.src") {
+	if len(sources) == 1 && strings.HasSuffix(sources[0], "importC.src") {
 		conf.FakeImportC = true
 	}
+	// TODO(rFindley) we may need to use the source importer when adding generics
+	// tests.
 	conf.Importer = importer.Default()
 	conf.Error = func(err error) {
 		if *haltOnError {
@@ -306,44 +264,61 @@ func checkFiles(t *testing.T, testfiles []string) {
 	}
 }
 
+// TestCheck is for manual testing of selected input files, provided with -files.
 func TestCheck(t *testing.T) {
+	if *testFiles == "" {
+		return
+	}
 	testenv.MustHaveGoBuild(t)
-
-	// Declare builtins for testing.
 	DefPredeclaredTestFuncs()
+	checkFiles(t, strings.Split(*testFiles, " "))
+}
 
-	// If explicit test files are specified, only check those.
-	if files := *testFiles; files != "" {
-		checkFiles(t, strings.Split(files, " "))
-		return
-	}
+func TestTestdata(t *testing.T) { DefPredeclaredTestFuncs(); testDir(t, "testdata") }
 
-	// Otherwise, run all the tests.
-	for _, files := range tests {
-		checkFiles(t, files)
-	}
-}
+// TODO(rFindley) add go2 examples.
+// func TestExamples(t *testing.T)  { testDir(t, "examples") }
 
-func TestFixedBugs(t *testing.T) { testDir(t, "fixedbugs") }
+func TestFixedbugs(t *testing.T) { testDir(t, "fixedbugs") }
 
 func testDir(t *testing.T, dir string) {
 	testenv.MustHaveGoBuild(t)
 
-	dirs, err := os.ReadDir(dir)
+	fis, err := os.ReadDir(dir)
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
+		return
 	}
 
-	for _, d := range dirs {
-		testname := filepath.Base(d.Name())
-		testname = strings.TrimSuffix(testname, filepath.Ext(testname))
-		t.Run(testname, func(t *testing.T) {
-			filename := filepath.Join(dir, d.Name())
-			if d.IsDir() {
-				t.Errorf("skipped directory %q", filename)
-				return
+	for count, fi := range fis {
+		path := filepath.Join(dir, fi.Name())
+
+		// if fi is a directory, its files make up a single package
+		if fi.IsDir() {
+			if testing.Verbose() {
+				fmt.Printf("%3d %s\n", count, path)
+			}
+			fis, err := ioutil.ReadDir(path)
+			if err != nil {
+				t.Error(err)
+				continue
 			}
-			checkFiles(t, []string{filename})
-		})
+			files := make([]string, len(fis))
+			for i, fi := range fis {
+				// if fi is a directory, checkFiles below will complain
+				files[i] = filepath.Join(path, fi.Name())
+				if testing.Verbose() {
+					fmt.Printf("\t%s\n", files[i])
+				}
+			}
+			checkFiles(t, files)
+			continue
+		}
+
+		// otherwise, fi is a stand-alone file
+		if testing.Verbose() {
+			fmt.Printf("%3d %s\n", count, path)
+		}
+		checkFiles(t, []string{path})
 	}
 }
diff --git a/src/go/types/testdata/decls2a.src b/src/go/types/testdata/decls2/decls2a.src
similarity index 100%
rename from src/go/types/testdata/decls2a.src
rename to src/go/types/testdata/decls2/decls2a.src
diff --git a/src/go/types/testdata/decls2b.src b/src/go/types/testdata/decls2/decls2b.src
similarity index 100%
rename from src/go/types/testdata/decls2b.src
rename to src/go/types/testdata/decls2/decls2b.src
diff --git a/src/go/types/testdata/importdecl0a.src b/src/go/types/testdata/importdecl0/importdecl0a.src
similarity index 100%
rename from src/go/types/testdata/importdecl0a.src
rename to src/go/types/testdata/importdecl0/importdecl0a.src
diff --git a/src/go/types/testdata/importdecl0b.src b/src/go/types/testdata/importdecl0/importdecl0b.src
similarity index 100%
rename from src/go/types/testdata/importdecl0b.src
rename to src/go/types/testdata/importdecl0/importdecl0b.src
diff --git a/src/go/types/testdata/importdecl1a.src b/src/go/types/testdata/importdecl1/importdecl1a.src
similarity index 100%
rename from src/go/types/testdata/importdecl1a.src
rename to src/go/types/testdata/importdecl1/importdecl1a.src
diff --git a/src/go/types/testdata/importdecl1b.src b/src/go/types/testdata/importdecl1/importdecl1b.src
similarity index 100%
rename from src/go/types/testdata/importdecl1b.src
rename to src/go/types/testdata/importdecl1/importdecl1b.src
diff --git a/src/go/types/testdata/issue25008a.src b/src/go/types/testdata/issue25008/issue25008a.src
similarity index 100%
rename from src/go/types/testdata/issue25008a.src
rename to src/go/types/testdata/issue25008/issue25008a.src
diff --git a/src/go/types/testdata/issue25008b.src b/src/go/types/testdata/issue25008/issue25008b.src
similarity index 100%
rename from src/go/types/testdata/issue25008b.src
rename to src/go/types/testdata/issue25008/issue25008b.src
-- 
GitLab


From 106aa941dfda45d4aa5235b12317124aaf8941a0 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 9 Jan 2021 23:12:56 -0800
Subject: [PATCH 0462/2400] [dev.typeparams] cmd/compile: refactor DWARF scope
 marking

This CL extracts and simplifies noder's DWARF scope tracking code to
make it easier for reuse by irgen.

The previous code tried to be really clever about avoid recording
multiple scope boundaries at the same position (as happens at the end
of "if" and "for" statements). I had a really hard time remember how
this code worked exactly, so I've reimplemented a simpler algorithm
that just tracks all scope marks, and then compacts them at the end
before saving them to the ir.Func.

Passes toolstash -cmp.

Change-Id: Ibeb37997b77dc5179360d7db557c82ae1682e127
Reviewed-on: https://go-review.googlesource.com/c/go/+/282918
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/dwarfgen/marker.go | 94 +++++++++++++++++++++
 src/cmd/compile/internal/noder/noder.go     | 79 +++++++----------
 2 files changed, 123 insertions(+), 50 deletions(-)
 create mode 100644 src/cmd/compile/internal/dwarfgen/marker.go

diff --git a/src/cmd/compile/internal/dwarfgen/marker.go b/src/cmd/compile/internal/dwarfgen/marker.go
new file mode 100644
index 0000000000..ec6ce45a90
--- /dev/null
+++ b/src/cmd/compile/internal/dwarfgen/marker.go
@@ -0,0 +1,94 @@
+// Copyright 2021 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 dwarfgen
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/internal/src"
+)
+
+// A ScopeMarker tracks scope nesting and boundaries for later use
+// during DWARF generation.
+type ScopeMarker struct {
+	parents []ir.ScopeID
+	marks   []ir.Mark
+}
+
+// checkPos validates the given position and returns the current scope.
+func (m *ScopeMarker) checkPos(pos src.XPos) ir.ScopeID {
+	if !pos.IsKnown() {
+		base.Fatalf("unknown scope position")
+	}
+
+	if len(m.marks) == 0 {
+		return 0
+	}
+
+	last := &m.marks[len(m.marks)-1]
+	if xposBefore(pos, last.Pos) {
+		base.FatalfAt(pos, "non-monotonic scope positions\n\t%v: previous scope position", base.FmtPos(last.Pos))
+	}
+	return last.Scope
+}
+
+// Push records a transition to a new child scope of the current scope.
+func (m *ScopeMarker) Push(pos src.XPos) {
+	current := m.checkPos(pos)
+
+	m.parents = append(m.parents, current)
+	child := ir.ScopeID(len(m.parents))
+
+	m.marks = append(m.marks, ir.Mark{Pos: pos, Scope: child})
+}
+
+// Pop records a transition back to the current scope's parent.
+func (m *ScopeMarker) Pop(pos src.XPos) {
+	current := m.checkPos(pos)
+
+	parent := m.parents[current-1]
+
+	m.marks = append(m.marks, ir.Mark{Pos: pos, Scope: parent})
+}
+
+// Unpush removes the current scope, which must be empty.
+func (m *ScopeMarker) Unpush() {
+	i := len(m.marks) - 1
+	current := m.marks[i].Scope
+
+	if current != ir.ScopeID(len(m.parents)) {
+		base.FatalfAt(m.marks[i].Pos, "current scope is not empty")
+	}
+
+	m.parents = m.parents[:current-1]
+	m.marks = m.marks[:i]
+}
+
+// WriteTo writes the recorded scope marks to the given function,
+// and resets the marker for reuse.
+func (m *ScopeMarker) WriteTo(fn *ir.Func) {
+	m.compactMarks()
+
+	fn.Parents = make([]ir.ScopeID, len(m.parents))
+	copy(fn.Parents, m.parents)
+	m.parents = m.parents[:0]
+
+	fn.Marks = make([]ir.Mark, len(m.marks))
+	copy(fn.Marks, m.marks)
+	m.marks = m.marks[:0]
+}
+
+func (m *ScopeMarker) compactMarks() {
+	n := 0
+	for _, next := range m.marks {
+		if n > 0 && next.Pos == m.marks[n-1].Pos {
+			m.marks[n-1].Scope = next.Scope
+			continue
+		}
+		m.marks[n] = next
+		n++
+	}
+	m.marks = m.marks[:n]
+}
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index b3f3c23c29..71a5df082b 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -19,6 +19,7 @@ import (
 	"unicode/utf8"
 
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/dwarfgen"
 	"cmd/compile/internal/importer"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/syntax"
@@ -292,22 +293,17 @@ type noder struct {
 	linknames      []linkname
 	pragcgobuf     [][]string
 	err            chan syntax.Error
-	scope          ir.ScopeID
 	importedUnsafe bool
 	importedEmbed  bool
+	trackScopes    bool
 
-	// scopeVars is a stack tracking the number of variables declared in the
-	// current function at the moment each open scope was opened.
-	trackScopes bool
-	scopeVars   []int
+	funcState *funcState
 
 	// typeInfo provides access to the type information computed by the new
 	// typechecker. It is only present if -G is set, and all noders point to
 	// the same types.Info. For now this is a local field, if need be we can
 	// make it global.
 	typeInfo *types2.Info
-
-	lastCloseScopePos syntax.Pos
 }
 
 // For now we provide these basic accessors to get to type and object
@@ -335,9 +331,20 @@ func (p *noder) sel(x *syntax.SelectorExpr) *types2.Selection {
 	return p.typeInfo.Selections[x]
 }
 
+// funcState tracks all per-function state to make handling nested
+// functions easier.
+type funcState struct {
+	// scopeVars is a stack tracking the number of variables declared in
+	// the current function at the moment each open scope was opened.
+	scopeVars []int
+	marker    dwarfgen.ScopeMarker
+
+	lastCloseScopePos syntax.Pos
+}
+
 func (p *noder) funcBody(fn *ir.Func, block *syntax.BlockStmt) {
-	oldScope := p.scope
-	p.scope = 0
+	outerFuncState := p.funcState
+	p.funcState = new(funcState)
 	typecheck.StartFuncBody(fn)
 
 	if block != nil {
@@ -352,62 +359,34 @@ func (p *noder) funcBody(fn *ir.Func, block *syntax.BlockStmt) {
 	}
 
 	typecheck.FinishFuncBody()
-	p.scope = oldScope
+	p.funcState.marker.WriteTo(fn)
+	p.funcState = outerFuncState
 }
 
 func (p *noder) openScope(pos syntax.Pos) {
+	fs := p.funcState
 	types.Markdcl()
 
 	if p.trackScopes {
-		ir.CurFunc.Parents = append(ir.CurFunc.Parents, p.scope)
-		p.scopeVars = append(p.scopeVars, len(ir.CurFunc.Dcl))
-		p.scope = ir.ScopeID(len(ir.CurFunc.Parents))
-
-		p.markScope(pos)
+		fs.scopeVars = append(fs.scopeVars, len(ir.CurFunc.Dcl))
+		fs.marker.Push(p.makeXPos(pos))
 	}
 }
 
 func (p *noder) closeScope(pos syntax.Pos) {
-	p.lastCloseScopePos = pos
+	fs := p.funcState
+	fs.lastCloseScopePos = pos
 	types.Popdcl()
 
 	if p.trackScopes {
-		scopeVars := p.scopeVars[len(p.scopeVars)-1]
-		p.scopeVars = p.scopeVars[:len(p.scopeVars)-1]
+		scopeVars := fs.scopeVars[len(fs.scopeVars)-1]
+		fs.scopeVars = fs.scopeVars[:len(fs.scopeVars)-1]
 		if scopeVars == len(ir.CurFunc.Dcl) {
 			// no variables were declared in this scope, so we can retract it.
-
-			if int(p.scope) != len(ir.CurFunc.Parents) {
-				base.Fatalf("scope tracking inconsistency, no variables declared but scopes were not retracted")
-			}
-
-			p.scope = ir.CurFunc.Parents[p.scope-1]
-			ir.CurFunc.Parents = ir.CurFunc.Parents[:len(ir.CurFunc.Parents)-1]
-
-			nmarks := len(ir.CurFunc.Marks)
-			ir.CurFunc.Marks[nmarks-1].Scope = p.scope
-			prevScope := ir.ScopeID(0)
-			if nmarks >= 2 {
-				prevScope = ir.CurFunc.Marks[nmarks-2].Scope
-			}
-			if ir.CurFunc.Marks[nmarks-1].Scope == prevScope {
-				ir.CurFunc.Marks = ir.CurFunc.Marks[:nmarks-1]
-			}
-			return
+			fs.marker.Unpush()
+		} else {
+			fs.marker.Pop(p.makeXPos(pos))
 		}
-
-		p.scope = ir.CurFunc.Parents[p.scope-1]
-
-		p.markScope(pos)
-	}
-}
-
-func (p *noder) markScope(pos syntax.Pos) {
-	xpos := p.makeXPos(pos)
-	if i := len(ir.CurFunc.Marks); i > 0 && ir.CurFunc.Marks[i-1].Pos == xpos {
-		ir.CurFunc.Marks[i-1].Scope = p.scope
-	} else {
-		ir.CurFunc.Marks = append(ir.CurFunc.Marks, ir.Mark{Pos: xpos, Scope: p.scope})
 	}
 }
 
@@ -416,7 +395,7 @@ func (p *noder) markScope(pos syntax.Pos) {
 // "if" statements, as their implicit blocks always end at the same
 // position as an explicit block.
 func (p *noder) closeAnotherScope() {
-	p.closeScope(p.lastCloseScopePos)
+	p.closeScope(p.funcState.lastCloseScopePos)
 }
 
 // linkname records a //go:linkname directive.
-- 
GitLab


From 099599662d15598fc2690e60bd36bc087a3bdec5 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 8 Jan 2021 23:44:31 -0800
Subject: [PATCH 0463/2400] [dev.typeparams] cmd/compile: refactor import logic

This CL refactors noder's package import logic so it's easier to reuse
with types2 and gcimports. In particular, this allows the types2
integration to now support vendored packages.

Change-Id: I1fd98ad612b4683d2e1ac640839e64de1fa7324b
Reviewed-on: https://go-review.googlesource.com/c/go/+/282919
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/noder/import.go | 260 ++++++++++++-----------
 src/cmd/compile/internal/noder/noder.go  |  33 +--
 src/cmd/compile/internal/types/pkg.go    |   3 +-
 test/fixedbugs/issue11362.go             |   3 +-
 test/run.go                              |   1 -
 5 files changed, 138 insertions(+), 162 deletions(-)

diff --git a/src/cmd/compile/internal/noder/import.go b/src/cmd/compile/internal/noder/import.go
index 08f19a4028..ac7bc8bbf0 100644
--- a/src/cmd/compile/internal/noder/import.go
+++ b/src/cmd/compile/internal/noder/import.go
@@ -5,20 +5,25 @@
 package noder
 
 import (
+	"errors"
 	"fmt"
-	"go/constant"
+	"io"
 	"os"
-	"path"
+	pathpkg "path"
 	"runtime"
 	"sort"
+	"strconv"
 	"strings"
 	"unicode"
 	"unicode/utf8"
 
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/importer"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/syntax"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
+	"cmd/compile/internal/types2"
 	"cmd/internal/archive"
 	"cmd/internal/bio"
 	"cmd/internal/goobj"
@@ -26,6 +31,29 @@ import (
 	"cmd/internal/src"
 )
 
+// Temporary import helper to get type2-based type-checking going.
+type gcimports struct {
+	packages map[string]*types2.Package
+}
+
+func (m *gcimports) Import(path string) (*types2.Package, error) {
+	return m.ImportFrom(path, "" /* no vendoring */, 0)
+}
+
+func (m *gcimports) ImportFrom(path, srcDir string, mode types2.ImportMode) (*types2.Package, error) {
+	if mode != 0 {
+		panic("mode must be 0")
+	}
+
+	path, err := resolveImportPath(path)
+	if err != nil {
+		return nil, err
+	}
+
+	lookup := func(path string) (io.ReadCloser, error) { return openPackage(path) }
+	return importer.Import(m.packages, path, srcDir, lookup)
+}
+
 func isDriveLetter(b byte) bool {
 	return 'a' <= b && b <= 'z' || 'A' <= b && b <= 'Z'
 }
@@ -38,160 +66,152 @@ func islocalname(name string) bool {
 		strings.HasPrefix(name, "../") || name == ".."
 }
 
-func findpkg(name string) (file string, ok bool) {
-	if islocalname(name) {
+func openPackage(path string) (*os.File, error) {
+	if islocalname(path) {
 		if base.Flag.NoLocalImports {
-			return "", false
+			return nil, errors.New("local imports disallowed")
 		}
 
 		if base.Flag.Cfg.PackageFile != nil {
-			file, ok = base.Flag.Cfg.PackageFile[name]
-			return file, ok
+			return os.Open(base.Flag.Cfg.PackageFile[path])
 		}
 
-		// try .a before .6.  important for building libraries:
-		// if there is an array.6 in the array.a library,
-		// want to find all of array.a, not just array.6.
-		file = fmt.Sprintf("%s.a", name)
-		if _, err := os.Stat(file); err == nil {
-			return file, true
+		// try .a before .o.  important for building libraries:
+		// if there is an array.o in the array.a library,
+		// want to find all of array.a, not just array.o.
+		if file, err := os.Open(fmt.Sprintf("%s.a", path)); err == nil {
+			return file, nil
 		}
-		file = fmt.Sprintf("%s.o", name)
-		if _, err := os.Stat(file); err == nil {
-			return file, true
+		if file, err := os.Open(fmt.Sprintf("%s.o", path)); err == nil {
+			return file, nil
 		}
-		return "", false
+		return nil, errors.New("file not found")
 	}
 
 	// local imports should be canonicalized already.
 	// don't want to see "encoding/../encoding/base64"
 	// as different from "encoding/base64".
-	if q := path.Clean(name); q != name {
-		base.Errorf("non-canonical import path %q (should be %q)", name, q)
-		return "", false
+	if q := pathpkg.Clean(path); q != path {
+		return nil, fmt.Errorf("non-canonical import path %q (should be %q)", path, q)
 	}
 
 	if base.Flag.Cfg.PackageFile != nil {
-		file, ok = base.Flag.Cfg.PackageFile[name]
-		return file, ok
+		return os.Open(base.Flag.Cfg.PackageFile[path])
 	}
 
 	for _, dir := range base.Flag.Cfg.ImportDirs {
-		file = fmt.Sprintf("%s/%s.a", dir, name)
-		if _, err := os.Stat(file); err == nil {
-			return file, true
+		if file, err := os.Open(fmt.Sprintf("%s/%s.a", dir, path)); err == nil {
+			return file, nil
 		}
-		file = fmt.Sprintf("%s/%s.o", dir, name)
-		if _, err := os.Stat(file); err == nil {
-			return file, true
+		if file, err := os.Open(fmt.Sprintf("%s/%s.o", dir, path)); err == nil {
+			return file, nil
 		}
 	}
 
 	if objabi.GOROOT != "" {
 		suffix := ""
-		suffixsep := ""
 		if base.Flag.InstallSuffix != "" {
-			suffixsep = "_"
-			suffix = base.Flag.InstallSuffix
+			suffix = "_" + base.Flag.InstallSuffix
 		} else if base.Flag.Race {
-			suffixsep = "_"
-			suffix = "race"
+			suffix = "_race"
 		} else if base.Flag.MSan {
-			suffixsep = "_"
-			suffix = "msan"
+			suffix = "_msan"
 		}
 
-		file = fmt.Sprintf("%s/pkg/%s_%s%s%s/%s.a", objabi.GOROOT, objabi.GOOS, objabi.GOARCH, suffixsep, suffix, name)
-		if _, err := os.Stat(file); err == nil {
-			return file, true
+		if file, err := os.Open(fmt.Sprintf("%s/pkg/%s_%s%s/%s.a", objabi.GOROOT, objabi.GOOS, objabi.GOARCH, suffix, path)); err == nil {
+			return file, nil
 		}
-		file = fmt.Sprintf("%s/pkg/%s_%s%s%s/%s.o", objabi.GOROOT, objabi.GOOS, objabi.GOARCH, suffixsep, suffix, name)
-		if _, err := os.Stat(file); err == nil {
-			return file, true
+		if file, err := os.Open(fmt.Sprintf("%s/pkg/%s_%s%s/%s.o", objabi.GOROOT, objabi.GOOS, objabi.GOARCH, suffix, path)); err == nil {
+			return file, nil
 		}
 	}
-
-	return "", false
+	return nil, errors.New("file not found")
 }
 
 // myheight tracks the local package's height based on packages
 // imported so far.
 var myheight int
 
-func importfile(f constant.Value) *types.Pkg {
-	if f.Kind() != constant.String {
-		base.Errorf("import path must be a string")
-		return nil
-	}
-
-	path_ := constant.StringVal(f)
-	if len(path_) == 0 {
-		base.Errorf("import path is empty")
-		return nil
-	}
-
-	if isbadimport(path_, false) {
-		return nil
-	}
-
+// resolveImportPath resolves an import path as it appears in a Go
+// source file to the package's full path.
+func resolveImportPath(path string) (string, error) {
 	// The package name main is no longer reserved,
 	// but we reserve the import path "main" to identify
 	// the main package, just as we reserve the import
 	// path "math" to identify the standard math package.
-	if path_ == "main" {
-		base.Errorf("cannot import \"main\"")
-		base.ErrorExit()
-	}
-
-	if base.Ctxt.Pkgpath != "" && path_ == base.Ctxt.Pkgpath {
-		base.Errorf("import %q while compiling that package (import cycle)", path_)
-		base.ErrorExit()
+	if path == "main" {
+		return "", errors.New("cannot import \"main\"")
 	}
 
-	if mapped, ok := base.Flag.Cfg.ImportMap[path_]; ok {
-		path_ = mapped
+	if base.Ctxt.Pkgpath != "" && path == base.Ctxt.Pkgpath {
+		return "", fmt.Errorf("import %q while compiling that package (import cycle)", path)
 	}
 
-	if path_ == "unsafe" {
-		return ir.Pkgs.Unsafe
+	if mapped, ok := base.Flag.Cfg.ImportMap[path]; ok {
+		path = mapped
 	}
 
-	if islocalname(path_) {
-		if path_[0] == '/' {
-			base.Errorf("import path cannot be absolute path")
-			return nil
+	if islocalname(path) {
+		if path[0] == '/' {
+			return "", errors.New("import path cannot be absolute path")
 		}
 
-		prefix := base.Ctxt.Pathname
-		if base.Flag.D != "" {
-			prefix = base.Flag.D
+		prefix := base.Flag.D
+		if prefix == "" {
+			// Questionable, but when -D isn't specified, historically we
+			// resolve local import paths relative to the directory the
+			// compiler's current directory, not the respective source
+			// file's directory.
+			prefix = base.Ctxt.Pathname
 		}
-		path_ = path.Join(prefix, path_)
+		path = pathpkg.Join(prefix, path)
 
-		if isbadimport(path_, true) {
-			return nil
+		if err := checkImportPath(path, true); err != nil {
+			return "", err
 		}
 	}
 
-	file, found := findpkg(path_)
-	if !found {
-		base.Errorf("can't find import: %q", path_)
-		base.ErrorExit()
+	return path, nil
+}
+
+// TODO(mdempsky): Return an error instead.
+func importfile(decl *syntax.ImportDecl) *types.Pkg {
+	path, err := strconv.Unquote(decl.Path.Value)
+	if err != nil {
+		base.Errorf("import path must be a string")
+		return nil
 	}
 
-	importpkg := types.NewPkg(path_, "")
-	if importpkg.Imported {
-		return importpkg
+	if err := checkImportPath(path, false); err != nil {
+		base.Errorf("%s", err.Error())
+		return nil
+	}
+
+	path, err = resolveImportPath(path)
+	if err != nil {
+		base.Errorf("%s", err)
+		return nil
 	}
 
-	importpkg.Imported = true
+	importpkg := types.NewPkg(path, "")
+	if importpkg.Direct {
+		return importpkg // already fully loaded
+	}
+	importpkg.Direct = true
+	typecheck.Target.Imports = append(typecheck.Target.Imports, importpkg)
 
-	imp, err := bio.Open(file)
+	if path == "unsafe" {
+		return importpkg // initialized with universe
+	}
+
+	f, err := openPackage(path)
 	if err != nil {
-		base.Errorf("can't open import: %q: %v", path_, err)
+		base.Errorf("could not import %q: %v", path, err)
 		base.ErrorExit()
 	}
+	imp := bio.NewReader(f)
 	defer imp.Close()
+	file := f.Name()
 
 	// check object header
 	p, err := imp.ReadString('\n')
@@ -261,12 +281,12 @@ func importfile(f constant.Value) *types.Pkg {
 	var fingerprint goobj.FingerprintType
 	switch c {
 	case '\n':
-		base.Errorf("cannot import %s: old export format no longer supported (recompile library)", path_)
+		base.Errorf("cannot import %s: old export format no longer supported (recompile library)", path)
 		return nil
 
 	case 'B':
 		if base.Debug.Export != 0 {
-			fmt.Printf("importing %s (%s)\n", path_, file)
+			fmt.Printf("importing %s (%s)\n", path, file)
 		}
 		imp.ReadByte() // skip \n after $$B
 
@@ -285,17 +305,17 @@ func importfile(f constant.Value) *types.Pkg {
 		fingerprint = typecheck.ReadImports(importpkg, imp)
 
 	default:
-		base.Errorf("no import in %q", path_)
+		base.Errorf("no import in %q", path)
 		base.ErrorExit()
 	}
 
 	// assume files move (get installed) so don't record the full path
 	if base.Flag.Cfg.PackageFile != nil {
 		// If using a packageFile map, assume path_ can be recorded directly.
-		base.Ctxt.AddImport(path_, fingerprint)
+		base.Ctxt.AddImport(path, fingerprint)
 	} else {
 		// For file "/Users/foo/go/pkg/darwin_amd64/math.a" record "math.a".
-		base.Ctxt.AddImport(file[len(file)-len(path_)-len(".a"):], fingerprint)
+		base.Ctxt.AddImport(file[len(file)-len(path)-len(".a"):], fingerprint)
 	}
 
 	if importpkg.Height >= myheight {
@@ -315,47 +335,37 @@ var reservedimports = []string{
 	"type",
 }
 
-func isbadimport(path string, allowSpace bool) bool {
+func checkImportPath(path string, allowSpace bool) error {
+	if path == "" {
+		return errors.New("import path is empty")
+	}
+
 	if strings.Contains(path, "\x00") {
-		base.Errorf("import path contains NUL")
-		return true
+		return errors.New("import path contains NUL")
 	}
 
 	for _, ri := range reservedimports {
 		if path == ri {
-			base.Errorf("import path %q is reserved and cannot be used", path)
-			return true
+			return fmt.Errorf("import path %q is reserved and cannot be used", path)
 		}
 	}
 
 	for _, r := range path {
-		if r == utf8.RuneError {
-			base.Errorf("import path contains invalid UTF-8 sequence: %q", path)
-			return true
-		}
-
-		if r < 0x20 || r == 0x7f {
-			base.Errorf("import path contains control character: %q", path)
-			return true
-		}
-
-		if r == '\\' {
-			base.Errorf("import path contains backslash; use slash: %q", path)
-			return true
-		}
-
-		if !allowSpace && unicode.IsSpace(r) {
-			base.Errorf("import path contains space character: %q", path)
-			return true
-		}
-
-		if strings.ContainsRune("!\"#$%&'()*,:;<=>?[]^`{|}", r) {
-			base.Errorf("import path contains invalid character '%c': %q", r, path)
-			return true
+		switch {
+		case r == utf8.RuneError:
+			return fmt.Errorf("import path contains invalid UTF-8 sequence: %q", path)
+		case r < 0x20 || r == 0x7f:
+			return fmt.Errorf("import path contains control character: %q", path)
+		case r == '\\':
+			return fmt.Errorf("import path contains backslash; use slash: %q", path)
+		case !allowSpace && unicode.IsSpace(r):
+			return fmt.Errorf("import path contains space character: %q", path)
+		case strings.ContainsRune("!\"#$%&'()*,:;<=>?[]^`{|}", r):
+			return fmt.Errorf("import path contains invalid character '%c': %q", r, path)
 		}
 	}
 
-	return false
+	return nil
 }
 
 func pkgnotused(lineno src.XPos, path string, name string) {
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 71a5df082b..5a9e37af7d 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -9,7 +9,6 @@ import (
 	"fmt"
 	"go/constant"
 	"go/token"
-	"io"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -20,7 +19,6 @@ import (
 
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/dwarfgen"
-	"cmd/compile/internal/importer"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/syntax"
 	"cmd/compile/internal/typecheck"
@@ -126,13 +124,6 @@ func ParseFiles(filenames []string) (lines uint) {
 			},
 			Importer: &gcimports{
 				packages: make(map[string]*types2.Package),
-				lookup: func(path string) (io.ReadCloser, error) {
-					file, ok := findpkg(path)
-					if !ok {
-						return nil, fmt.Errorf("can't find import: %q", path)
-					}
-					return os.Open(file)
-				},
 			},
 			Sizes: &gcSizes{},
 		}
@@ -255,23 +246,6 @@ func Package() {
 
 }
 
-// Temporary import helper to get type2-based type-checking going.
-type gcimports struct {
-	packages map[string]*types2.Package
-	lookup   func(path string) (io.ReadCloser, error)
-}
-
-func (m *gcimports) Import(path string) (*types2.Package, error) {
-	return m.ImportFrom(path, "" /* no vendoring */, 0)
-}
-
-func (m *gcimports) ImportFrom(path, srcDir string, mode types2.ImportMode) (*types2.Package, error) {
-	if mode != 0 {
-		panic("mode must be 0")
-	}
-	return importer.Import(m.packages, path, srcDir, m.lookup)
-}
-
 func (p *noder) errorAt(pos syntax.Pos, format string, args ...interface{}) {
 	base.ErrorfAt(p.makeXPos(pos), format, args...)
 }
@@ -483,7 +457,7 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
 		p.checkUnused(pragma)
 	}
 
-	ipkg := importfile(p.basicLit(imp.Path))
+	ipkg := importfile(imp)
 	if ipkg == nil {
 		if base.Errors() == 0 {
 			base.Fatalf("phase error in import")
@@ -498,11 +472,6 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
 		p.importedEmbed = true
 	}
 
-	if !ipkg.Direct {
-		typecheck.Target.Imports = append(typecheck.Target.Imports, ipkg)
-	}
-	ipkg.Direct = true
-
 	var my *types.Sym
 	if imp.LocalPkgName != nil {
 		my = p.name(imp.LocalPkgName)
diff --git a/src/cmd/compile/internal/types/pkg.go b/src/cmd/compile/internal/types/pkg.go
index de45d32bfa..a6d2e2007b 100644
--- a/src/cmd/compile/internal/types/pkg.go
+++ b/src/cmd/compile/internal/types/pkg.go
@@ -31,8 +31,7 @@ type Pkg struct {
 	// height of their imported packages.
 	Height int
 
-	Imported bool // export data of this package was parsed
-	Direct   bool // imported directly
+	Direct bool // imported directly
 }
 
 // NewPkg returns a new Pkg for the given package path and name.
diff --git a/test/fixedbugs/issue11362.go b/test/fixedbugs/issue11362.go
index 964e5fdf6b..f4b65b0f72 100644
--- a/test/fixedbugs/issue11362.go
+++ b/test/fixedbugs/issue11362.go
@@ -8,8 +8,7 @@
 
 package main
 
-import _ "unicode//utf8" // GC_ERROR "non-canonical import path .unicode//utf8. \(should be .unicode/utf8.\)" "can't find import: .unicode//utf8."
+import _ "unicode//utf8" // GC_ERROR "non-canonical import path .unicode//utf8. \(should be .unicode/utf8.\)"
 
 func main() {
 }
-
diff --git a/test/run.go b/test/run.go
index fcf8a4fcc9..5315f9867d 100644
--- a/test/run.go
+++ b/test/run.go
@@ -1954,7 +1954,6 @@ var excluded = map[string]bool{
 	"fixedbugs/bug388.go":    true, // types2 not run due to syntax errors
 	"fixedbugs/bug412.go":    true, // types2 produces a follow-on error
 
-	"fixedbugs/issue11362.go":  true, // types2 import path handling
 	"fixedbugs/issue11590.go":  true, // types2 doesn't report a follow-on error (pref: types2)
 	"fixedbugs/issue11610.go":  true, // types2 not run after syntax errors
 	"fixedbugs/issue11614.go":  true, // types2 reports an extra error
-- 
GitLab


From b4d2a0445b0ca54a159e0895e1a8b31d47411894 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 11 Jan 2021 15:58:19 -0800
Subject: [PATCH 0464/2400] [dev.regabi] cmd/compile: refactor closure var
 setup/teardown

Creating closure vars is subtle and is also needed in both CL 281932
and CL 283112, so refactor out a common implementation that can be
used in all 3 places.

Passes toolstash -cmp.

Change-Id: Ib993eb90c895b52759bfbfbaad88921e391b0b4d
Reviewed-on: https://go-review.googlesource.com/c/go/+/283194
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
Trust: Dan Scales <danscales@google.com>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/name.go     | 76 +++++++++++++++++++++++++
 src/cmd/compile/internal/noder/noder.go | 64 +--------------------
 2 files changed, 79 insertions(+), 61 deletions(-)

diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index cfb481e31c..2375eddb99 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -351,6 +351,82 @@ func (n *Name) Byval() bool {
 	return n.Canonical().flags&nameByval != 0
 }
 
+// CaptureName returns a Name suitable for referring to n from within function
+// fn or from the package block if fn is nil. If n is a free variable declared
+// within a function that encloses fn, then CaptureName returns a closure
+// variable that refers to n and adds it to fn.ClosureVars. Otherwise, it simply
+// returns n.
+func CaptureName(pos src.XPos, fn *Func, n *Name) *Name {
+	if n.IsClosureVar() {
+		base.FatalfAt(pos, "misuse of CaptureName on closure variable: %v", n)
+	}
+	if n.Op() != ONAME || n.Curfn == nil || n.Curfn == fn {
+		return n // okay to use directly
+	}
+	if fn == nil {
+		base.FatalfAt(pos, "package-block reference to %v, declared in %v", n, n.Curfn)
+	}
+
+	c := n.Innermost
+	if c != nil && c.Curfn == fn {
+		return c
+	}
+
+	// Do not have a closure var for the active closure yet; make one.
+	c = NewNameAt(pos, n.Sym())
+	c.Curfn = fn
+	c.Class = PAUTOHEAP
+	c.SetIsClosureVar(true)
+	c.Defn = n
+
+	// Link into list of active closure variables.
+	// Popped from list in FinishCaptureNames.
+	c.Outer = n.Innermost
+	n.Innermost = c
+	fn.ClosureVars = append(fn.ClosureVars, c)
+
+	return c
+}
+
+// FinishCaptureNames handles any work leftover from calling CaptureName
+// earlier. outerfn should be the function that immediately encloses fn.
+func FinishCaptureNames(pos src.XPos, outerfn, fn *Func) {
+	// closure-specific variables are hanging off the
+	// ordinary ones; see CaptureName above.
+	// unhook them.
+	// make the list of pointers for the closure call.
+	for _, cv := range fn.ClosureVars {
+		// Unlink from n; see comment in syntax.go type Param for these fields.
+		n := cv.Defn.(*Name)
+		n.Innermost = cv.Outer
+
+		// If the closure usage of n is not dense, we need to make it
+		// dense by recapturing n within the enclosing function.
+		//
+		// That is, suppose we just finished parsing the innermost
+		// closure f4 in this code:
+		//
+		//	func f() {
+		//		n := 1
+		//		func() { // f2
+		//			use(n)
+		//			func() { // f3
+		//				func() { // f4
+		//					use(n)
+		//				}()
+		//			}()
+		//		}()
+		//	}
+		//
+		// At this point cv.Outer is f2's n; there is no n for f3. To
+		// construct the closure f4 from within f3, we need to use f3's
+		// n and in this case we need to create f3's n with CaptureName.
+		//
+		// We'll decide later in walk whether to use v directly or &v.
+		cv.Outer = CaptureName(pos, outerfn, n)
+	}
+}
+
 // SameSource reports whether two nodes refer to the same source
 // element.
 //
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 76913c62a6..ec0debdbbd 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -1872,45 +1872,7 @@ func (p *noder) funcLit(expr *syntax.FuncLit) ir.Node {
 
 	p.funcBody(fn, expr.Body)
 
-	// closure-specific variables are hanging off the
-	// ordinary ones in the symbol table; see oldname.
-	// unhook them.
-	// make the list of pointers for the closure call.
-	for _, v := range fn.ClosureVars {
-		// Unlink from v1; see comment in syntax.go type Param for these fields.
-		v1 := v.Defn
-		v1.Name().Innermost = v.Outer
-
-		// If the closure usage of v is not dense,
-		// we need to make it dense; now that we're out
-		// of the function in which v appeared,
-		// look up v.Sym in the enclosing function
-		// and keep it around for use in the compiled code.
-		//
-		// That is, suppose we just finished parsing the innermost
-		// closure f4 in this code:
-		//
-		//	func f() {
-		//		v := 1
-		//		func() { // f2
-		//			use(v)
-		//			func() { // f3
-		//				func() { // f4
-		//					use(v)
-		//				}()
-		//			}()
-		//		}()
-		//	}
-		//
-		// At this point v.Outer is f2's v; there is no f3's v.
-		// To construct the closure f4 from within f3,
-		// we need to use f3's v and in this case we need to create f3's v.
-		// We are now in the context of f3, so calling oldname(v.Sym)
-		// obtains f3's v, creating it if necessary (as it is in the example).
-		//
-		// capturevars will decide whether to use v directly or &v.
-		v.Outer = oldname(v.Sym()).(*ir.Name)
-	}
+	ir.FinishCaptureNames(base.Pos, ir.CurFunc, fn)
 
 	return clo
 }
@@ -1944,32 +1906,12 @@ func oldname(s *types.Sym) ir.Node {
 		return ir.NewIdent(base.Pos, s)
 	}
 
-	if ir.CurFunc != nil && n.Op() == ir.ONAME && n.Name().Curfn != nil && n.Name().Curfn != ir.CurFunc {
-		// Inner func is referring to var in outer func.
-		//
+	if n, ok := n.(*ir.Name); ok {
 		// TODO(rsc): If there is an outer variable x and we
 		// are parsing x := 5 inside the closure, until we get to
 		// the := it looks like a reference to the outer x so we'll
 		// make x a closure variable unnecessarily.
-		n := n.(*ir.Name)
-		c := n.Innermost
-		if c == nil || c.Curfn != ir.CurFunc {
-			// Do not have a closure var for the active closure yet; make one.
-			c = typecheck.NewName(s)
-			c.Class = ir.PAUTOHEAP
-			c.SetIsClosureVar(true)
-			c.Defn = n
-
-			// Link into list of active closure variables.
-			// Popped from list in func funcLit.
-			c.Outer = n.Innermost
-			n.Innermost = c
-
-			ir.CurFunc.ClosureVars = append(ir.CurFunc.ClosureVars, c)
-		}
-
-		// return ref to closure var, not original
-		return c
+		return ir.CaptureName(base.Pos, ir.CurFunc, n)
 	}
 
 	return n
-- 
GitLab


From 12ee55ba7bf22157267e735e8e4bbf651c5b4e7d Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 11 Jan 2021 15:07:09 -0800
Subject: [PATCH 0465/2400] [dev.regabi] cmd/compile: stop using Vargen for
 import/export

Historically, inline function bodies were exported as plain Go source
code, and symbol mangling was a convenient hack because it allowed
variables to be re-imported with largely the same names as they were
originally exported as.

However, nowadays we use a binary format that's more easily extended,
so we can simply serialize all of a function's declared objects up
front, and then refer to them by index later on. This also allows us
to easily report unmangled names all the time (e.g., error message
from issue7921.go).

Fixes #43633.

Change-Id: I46c88f5a47cb921f70ab140976ba9ddce38df216
Reviewed-on: https://go-review.googlesource.com/c/go/+/283193
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
Trust: Dan Scales <danscales@google.com>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/func.go           |   6 +
 src/cmd/compile/internal/ir/name.go           |   8 +-
 src/cmd/compile/internal/typecheck/dcl.go     |  27 +----
 src/cmd/compile/internal/typecheck/iexport.go |  58 +++++-----
 src/cmd/compile/internal/typecheck/iimport.go | 103 +++++++++++++-----
 .../compile/internal/typecheck/typecheck.go   |   2 +-
 test/fixedbugs/issue43633.dir/a.go            |  28 +++++
 test/fixedbugs/issue43633.dir/main.go         |  18 +++
 test/fixedbugs/issue43633.go                  |   7 ++
 test/fixedbugs/issue7921.go                   |   2 +-
 10 files changed, 171 insertions(+), 88 deletions(-)
 create mode 100644 test/fixedbugs/issue43633.dir/a.go
 create mode 100644 test/fixedbugs/issue43633.dir/main.go
 create mode 100644 test/fixedbugs/issue43633.go

diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 12ef083c19..d660fe3b40 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -61,8 +61,14 @@ type Func struct {
 	// memory for escaping parameters.
 	Enter Nodes
 	Exit  Nodes
+
 	// ONAME nodes for all params/locals for this func/closure, does NOT
 	// include closurevars until transformclosure runs.
+	// Names must be listed PPARAMs, PPARAMOUTs, then PAUTOs,
+	// with PPARAMs and PPARAMOUTs in order corresponding to the function signature.
+	// However, as anonymous or blank PPARAMs are not actually declared,
+	// they are omitted from Dcl.
+	// Anonymous and blank PPARAMOUTs are declared as ~rNN and ~bNN Names, respectively.
 	Dcl []*Name
 
 	ClosureType Ntype // closure representation type
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 2375eddb99..30f7e9b9e0 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -55,11 +55,9 @@ type Name struct {
 	// The function, method, or closure in which local variable or param is declared.
 	Curfn *Func
 
-	// Unique number for ONAME nodes within a function. Function outputs
-	// (results) are numbered starting at one, followed by function inputs
-	// (parameters), and then local variables. Vargen is used to distinguish
-	// local variables/params with the same name.
-	Vargen int32
+	// Unique number for OTYPE names within a function.
+	// TODO(mdempsky): Remove completely.
+	Typegen int32
 
 	Ntype    Ntype
 	Heapaddr *Name // temp holding heap address of param
diff --git a/src/cmd/compile/internal/typecheck/dcl.go b/src/cmd/compile/internal/typecheck/dcl.go
index ffbf474a58..caa3e8203a 100644
--- a/src/cmd/compile/internal/typecheck/dcl.go
+++ b/src/cmd/compile/internal/typecheck/dcl.go
@@ -7,7 +7,6 @@ package typecheck
 import (
 	"fmt"
 	"strconv"
-	"strings"
 
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
@@ -47,7 +46,6 @@ func Declare(n *ir.Name, ctxt ir.Class) {
 		base.ErrorfAt(n.Pos(), "cannot declare name %v", s)
 	}
 
-	gen := 0
 	if ctxt == ir.PEXTERN {
 		if s.Name == "init" {
 			base.ErrorfAt(n.Pos(), "cannot declare init - must be func")
@@ -66,10 +64,7 @@ func Declare(n *ir.Name, ctxt ir.Class) {
 		}
 		if n.Op() == ir.OTYPE {
 			declare_typegen++
-			gen = declare_typegen
-		} else if n.Op() == ir.ONAME && ctxt == ir.PAUTO && !strings.Contains(s.Name, "·") {
-			vargen++
-			gen = vargen
+			n.Typegen = int32(declare_typegen)
 		}
 		types.Pushdcl(s)
 		n.Curfn = ir.CurFunc
@@ -90,7 +85,6 @@ func Declare(n *ir.Name, ctxt ir.Class) {
 	s.Block = types.Block
 	s.Lastlineno = base.Pos
 	s.Def = n
-	n.Vargen = int32(gen)
 	n.Class = ctxt
 	if ctxt == ir.PFUNC {
 		n.Sym().SetFunc(true)
@@ -338,9 +332,6 @@ func funcarg(n *ir.Field, ctxt ir.Class) {
 	n.Decl = name
 	name.Ntype = n.Ntype
 	Declare(name, ctxt)
-
-	vargen++
-	n.Decl.Vargen = int32(vargen)
 }
 
 func funcarg2(f *types.Field, ctxt ir.Class) {
@@ -358,15 +349,6 @@ func funcargs(nt *ir.FuncType) {
 		base.Fatalf("funcargs %v", nt.Op())
 	}
 
-	// re-start the variable generation number
-	// we want to use small numbers for the return variables,
-	// so let them have the chunk starting at 1.
-	//
-	// TODO(mdempsky): This is ugly, and only necessary because
-	// esc.go uses Vargen to figure out result parameters' index
-	// within the result tuple.
-	vargen = len(nt.Results)
-
 	// declare the receiver and in arguments.
 	if nt.Recv != nil {
 		funcarg(nt.Recv, ir.PPARAM)
@@ -375,9 +357,6 @@ func funcargs(nt *ir.FuncType) {
 		funcarg(n, ir.PPARAM)
 	}
 
-	oldvargen := vargen
-	vargen = 0
-
 	// declare the out arguments.
 	gen := len(nt.Params)
 	for _, n := range nt.Results {
@@ -399,8 +378,6 @@ func funcargs(nt *ir.FuncType) {
 
 		funcarg(n, ir.PPARAMOUT)
 	}
-
-	vargen = oldvargen
 }
 
 // Same as funcargs, except run over an already constructed TFUNC.
@@ -422,8 +399,6 @@ func funcargs2(t *types.Type) {
 	}
 }
 
-var vargen int
-
 func Temp(t *types.Type) *ir.Name {
 	return TempAt(base.Pos, ir.CurFunc, t)
 }
diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index a7927c39a3..4d48b80346 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -422,6 +422,10 @@ type exportWriter struct {
 	prevFile   string
 	prevLine   int64
 	prevColumn int64
+
+	// dclIndex maps function-scoped declarations to their index
+	// within their respective Func's Dcl list.
+	dclIndex map[*ir.Name]int
 }
 
 func (p *iexporter) doDecl(n *ir.Name) {
@@ -529,7 +533,8 @@ func (p *iexporter) doInline(f *ir.Name) {
 	w := p.newWriter()
 	w.setPkg(fnpkg(f), false)
 
-	w.stmtList(ir.Nodes(f.Func.Inl.Body))
+	w.dclIndex = make(map[*ir.Name]int, len(f.Func.Inl.Dcl))
+	w.funcBody(f.Func)
 
 	w.finish("inl", p.inlineIndex, f.Sym())
 }
@@ -756,7 +761,7 @@ func (w *exportWriter) paramList(fs []*types.Field) {
 
 func (w *exportWriter) param(f *types.Field) {
 	w.pos(f.Pos)
-	w.localIdent(types.OrigSym(f.Sym), 0)
+	w.localIdent(types.OrigSym(f.Sym))
 	w.typ(f.Type)
 }
 
@@ -1030,7 +1035,19 @@ func (w *exportWriter) typeExt(t *types.Type) {
 
 // Inline bodies.
 
-func (w *exportWriter) stmtList(list ir.Nodes) {
+func (w *exportWriter) funcBody(fn *ir.Func) {
+	w.int64(int64(len(fn.Inl.Dcl)))
+	for i, n := range fn.Inl.Dcl {
+		w.pos(n.Pos())
+		w.localIdent(n.Sym())
+		w.typ(n.Type())
+		w.dclIndex[n] = i
+	}
+
+	w.stmtList(fn.Inl.Body)
+}
+
+func (w *exportWriter) stmtList(list []ir.Node) {
 	for _, n := range list {
 		w.node(n)
 	}
@@ -1070,10 +1087,11 @@ func (w *exportWriter) stmt(n ir.Node) {
 
 	case ir.ODCL:
 		n := n.(*ir.Decl)
+		if ir.IsBlank(n.X) {
+			return // blank declarations not useful to importers
+		}
 		w.op(ir.ODCL)
-		w.pos(n.X.Pos())
 		w.localName(n.X)
-		w.typ(n.X.Type())
 
 	case ir.OAS:
 		// Don't export "v = <N>" initializing statements, hope they're always
@@ -1288,7 +1306,7 @@ func (w *exportWriter) expr(n ir.Node) {
 			}
 			s = n.Tag.Sym()
 		}
-		w.localIdent(s, 0) // declared pseudo-variable, if any
+		w.localIdent(s) // declared pseudo-variable, if any
 		w.expr(n.X)
 
 	// case OTARRAY, OTMAP, OTCHAN, OTSTRUCT, OTINTER, OTFUNC:
@@ -1518,22 +1536,19 @@ func (w *exportWriter) fieldList(list ir.Nodes) {
 }
 
 func (w *exportWriter) localName(n *ir.Name) {
-	// Escape analysis happens after inline bodies are saved, but
-	// we're using the same ONAME nodes, so we might still see
-	// PAUTOHEAP here.
-	//
-	// Check for Stackcopy to identify PAUTOHEAP that came from
-	// PPARAM/PPARAMOUT, because we only want to include vargen in
-	// non-param names.
-	var v int32
-	if n.Class == ir.PAUTO || (n.Class == ir.PAUTOHEAP && n.Stackcopy == nil) {
-		v = n.Vargen
+	if ir.IsBlank(n) {
+		w.int64(-1)
+		return
 	}
 
-	w.localIdent(n.Sym(), v)
+	i, ok := w.dclIndex[n]
+	if !ok {
+		base.FatalfAt(n.Pos(), "missing from dclIndex: %+v", n)
+	}
+	w.int64(int64(i))
 }
 
-func (w *exportWriter) localIdent(s *types.Sym, v int32) {
+func (w *exportWriter) localIdent(s *types.Sym) {
 	if w.currPkg == nil {
 		base.Fatalf("missing currPkg")
 	}
@@ -1555,13 +1570,6 @@ func (w *exportWriter) localIdent(s *types.Sym, v int32) {
 		base.Fatalf("unexpected dot in identifier: %v", name)
 	}
 
-	if v > 0 {
-		if strings.Contains(name, "·") {
-			base.Fatalf("exporter: unexpected · in symbol name")
-		}
-		name = fmt.Sprintf("%s·%d", name, v)
-	}
-
 	if s.Pkg != w.currPkg {
 		base.Fatalf("weird package in name: %v => %v from %q, not %q", s, name, s.Pkg.Path, w.currPkg.Path)
 	}
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 15c57b2380..c9effabce0 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -262,6 +262,9 @@ type importReader struct {
 	prevBase   *src.PosBase
 	prevLine   int64
 	prevColumn int64
+
+	// curfn is the current function we're importing into.
+	curfn *ir.Func
 }
 
 func (p *iimporter) newReader(off uint64, pkg *types.Pkg) *importReader {
@@ -715,19 +718,7 @@ func (r *importReader) doInline(fn *ir.Func) {
 		base.Fatalf("%v already has inline body", fn)
 	}
 
-	StartFuncBody(fn)
-	body := r.stmtList()
-	FinishFuncBody()
-	if body == nil {
-		//
-		// Make sure empty body is not interpreted as
-		// no inlineable body (see also parser.fnbody)
-		// (not doing so can cause significant performance
-		// degradation due to unnecessary calls to empty
-		// functions).
-		body = []ir.Node{}
-	}
-	fn.Inl.Body = body
+	r.funcBody(fn)
 
 	importlist = append(importlist, fn)
 
@@ -755,6 +746,68 @@ func (r *importReader) doInline(fn *ir.Func) {
 // unrefined nodes (since this is what the importer uses). The respective case
 // entries are unreachable in the importer.
 
+func (r *importReader) funcBody(fn *ir.Func) {
+	outerfn := r.curfn
+	r.curfn = fn
+
+	// Import local declarations.
+	dcls := make([]*ir.Name, r.int64())
+	for i := range dcls {
+		n := ir.NewDeclNameAt(r.pos(), ir.ONAME, r.localIdent())
+		n.Class = ir.PAUTO // overwritten below for parameters/results
+		n.Curfn = fn
+		n.SetType(r.typ())
+		dcls[i] = n
+	}
+	fn.Inl.Dcl = dcls
+
+	// Fixup parameter classes and associate with their
+	// signature's type fields.
+	i := 0
+	fix := func(f *types.Field, class ir.Class) {
+		if class == ir.PPARAM && (f.Sym == nil || f.Sym.Name == "_") {
+			return
+		}
+		n := dcls[i]
+		n.Class = class
+		f.Nname = n
+		i++
+	}
+
+	typ := fn.Type()
+	if recv := typ.Recv(); recv != nil {
+		fix(recv, ir.PPARAM)
+	}
+	for _, f := range typ.Params().FieldSlice() {
+		fix(f, ir.PPARAM)
+	}
+	for _, f := range typ.Results().FieldSlice() {
+		fix(f, ir.PPARAMOUT)
+	}
+
+	// Import function body.
+	body := r.stmtList()
+	if body == nil {
+		// Make sure empty body is not interpreted as
+		// no inlineable body (see also parser.fnbody)
+		// (not doing so can cause significant performance
+		// degradation due to unnecessary calls to empty
+		// functions).
+		body = []ir.Node{}
+	}
+	fn.Inl.Body = body
+
+	r.curfn = outerfn
+}
+
+func (r *importReader) localName() *ir.Name {
+	i := r.int64()
+	if i < 0 {
+		return ir.BlankNode.(*ir.Name)
+	}
+	return r.curfn.Inl.Dcl[i]
+}
+
 func (r *importReader) stmtList() []ir.Node {
 	var list []ir.Node
 	for {
@@ -784,13 +837,8 @@ func (r *importReader) caseList(switchExpr ir.Node) []*ir.CaseClause {
 		cas := ir.NewCaseStmt(r.pos(), nil, nil)
 		cas.List = r.stmtList()
 		if namedTypeSwitch {
-			// Note: per-case variables will have distinct, dotted
-			// names after import. That's okay: swt.go only needs
-			// Sym for diagnostics anyway.
-			caseVar := ir.NewNameAt(cas.Pos(), r.localIdent())
-			Declare(caseVar, DeclContext)
-			cas.Var = caseVar
-			caseVar.Defn = switchExpr
+			cas.Var = r.localName()
+			cas.Var.Defn = switchExpr
 		}
 		cas.Body = r.stmtList()
 		cases[i] = cas
@@ -854,7 +902,7 @@ func (r *importReader) node() ir.Node {
 		return r.qualifiedIdent()
 
 	case ir.ONAME:
-		return r.localIdent().Def.(*ir.Name)
+		return r.localName()
 
 	// case OPACK, ONONAME:
 	// 	unreachable - should have been resolved by typechecking
@@ -991,16 +1039,11 @@ func (r *importReader) node() ir.Node {
 	// --------------------------------------------------------------------
 	// statements
 	case ir.ODCL:
-		pos := r.pos()
-		lhs := ir.NewDeclNameAt(pos, ir.ONAME, r.localIdent())
-		lhs.SetType(r.typ())
-
-		Declare(lhs, ir.PAUTO)
-
 		var stmts ir.Nodes
-		stmts.Append(ir.NewDecl(base.Pos, ir.ODCL, lhs))
-		stmts.Append(ir.NewAssignStmt(base.Pos, lhs, nil))
-		return ir.NewBlockStmt(pos, stmts)
+		n := r.localName()
+		stmts.Append(ir.NewDecl(n.Pos(), ir.ODCL, n))
+		stmts.Append(ir.NewAssignStmt(n.Pos(), n, nil))
+		return ir.NewBlockStmt(n.Pos(), stmts)
 
 	// case OAS, OASWB:
 	// 	unreachable - mapped to OAS case below by exporter
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 3160725e3c..431fb04bef 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -1687,7 +1687,7 @@ func typecheckdeftype(n *ir.Name) {
 	}
 
 	t := types.NewNamed(n)
-	t.Vargen = n.Vargen
+	t.Vargen = n.Typegen
 	if n.Pragma()&ir.NotInHeap != 0 {
 		t.SetNotInHeap(true)
 	}
diff --git a/test/fixedbugs/issue43633.dir/a.go b/test/fixedbugs/issue43633.dir/a.go
new file mode 100644
index 0000000000..946a37e87e
--- /dev/null
+++ b/test/fixedbugs/issue43633.dir/a.go
@@ -0,0 +1,28 @@
+// Copyright 2021 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 a
+
+func F() bool {
+	{
+		x := false
+		_ = x
+	}
+	if false {
+		_ = func(x bool) {}
+	}
+	x := true
+	return x
+}
+
+func G() func() bool {
+	x := true
+	return func() bool {
+		{
+			x := false
+			_ = x
+		}
+		return x
+	}
+}
diff --git a/test/fixedbugs/issue43633.dir/main.go b/test/fixedbugs/issue43633.dir/main.go
new file mode 100644
index 0000000000..320e00013c
--- /dev/null
+++ b/test/fixedbugs/issue43633.dir/main.go
@@ -0,0 +1,18 @@
+// Copyright 2021 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 "./a"
+
+var g = a.G()
+
+func main() {
+	if !a.F() {
+		panic("FAIL")
+	}
+	if !g() {
+		panic("FAIL")
+	}
+}
diff --git a/test/fixedbugs/issue43633.go b/test/fixedbugs/issue43633.go
new file mode 100644
index 0000000000..40df49f83b
--- /dev/null
+++ b/test/fixedbugs/issue43633.go
@@ -0,0 +1,7 @@
+// rundir
+
+// Copyright 2021 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 ignored
diff --git a/test/fixedbugs/issue7921.go b/test/fixedbugs/issue7921.go
index 5dce557ca3..a4e7b246d4 100644
--- a/test/fixedbugs/issue7921.go
+++ b/test/fixedbugs/issue7921.go
@@ -41,7 +41,7 @@ func bufferNoEscape3(xs []string) string { // ERROR "xs does not escape$"
 
 func bufferNoEscape4() []byte {
 	var b bytes.Buffer
-	b.Grow(64) // ERROR "bufferNoEscape4 ignoring self-assignment in bytes.b.buf = bytes.b.buf\[:bytes.m·3\]$" "inlining call to bytes.\(\*Buffer\).Grow$"
+	b.Grow(64) // ERROR "bufferNoEscape4 ignoring self-assignment in bytes.b.buf = bytes.b.buf\[:bytes.m\]$" "inlining call to bytes.\(\*Buffer\).Grow$"
 	useBuffer(&b)
 	return b.Bytes() // ERROR "inlining call to bytes.\(\*Buffer\).Bytes$"
 }
-- 
GitLab


From 95acd8121bf76a15ecba0259367dca0efe6d3a77 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 11 Jan 2021 17:22:20 -0800
Subject: [PATCH 0466/2400] [dev.regabi] cmd/compile: remove Name.Typegen

Just directly set Type.Vargen when declaring defined types within a
function.

Change-Id: Idcc0007084a660ce1c39da4a3697e158a1c615b5
Reviewed-on: https://go-review.googlesource.com/c/go/+/283212
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/ir/name.go             |  4 ----
 src/cmd/compile/internal/ir/sizeof_test.go      |  2 +-
 src/cmd/compile/internal/typecheck/dcl.go       |  8 --------
 src/cmd/compile/internal/typecheck/typecheck.go | 11 ++++++++++-
 4 files changed, 11 insertions(+), 14 deletions(-)

diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 30f7e9b9e0..514b303893 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -55,10 +55,6 @@ type Name struct {
 	// The function, method, or closure in which local variable or param is declared.
 	Curfn *Func
 
-	// Unique number for OTYPE names within a function.
-	// TODO(mdempsky): Remove completely.
-	Typegen int32
-
 	Ntype    Ntype
 	Heapaddr *Name // temp holding heap address of param
 
diff --git a/src/cmd/compile/internal/ir/sizeof_test.go b/src/cmd/compile/internal/ir/sizeof_test.go
index 1a4d2e5c7a..2ada7231aa 100644
--- a/src/cmd/compile/internal/ir/sizeof_test.go
+++ b/src/cmd/compile/internal/ir/sizeof_test.go
@@ -21,7 +21,7 @@ func TestSizeof(t *testing.T) {
 		_64bit uintptr     // size on 64bit platforms
 	}{
 		{Func{}, 184, 320},
-		{Name{}, 120, 216},
+		{Name{}, 116, 208},
 	}
 
 	for _, tt := range tests {
diff --git a/src/cmd/compile/internal/typecheck/dcl.go b/src/cmd/compile/internal/typecheck/dcl.go
index caa3e8203a..c7d7506fd1 100644
--- a/src/cmd/compile/internal/typecheck/dcl.go
+++ b/src/cmd/compile/internal/typecheck/dcl.go
@@ -62,10 +62,6 @@ func Declare(n *ir.Name, ctxt ir.Class) {
 		if ir.CurFunc != nil && ctxt != ir.PFUNC && n.Op() == ir.ONAME {
 			ir.CurFunc.Dcl = append(ir.CurFunc.Dcl, n)
 		}
-		if n.Op() == ir.OTYPE {
-			declare_typegen++
-			n.Typegen = int32(declare_typegen)
-		}
 		types.Pushdcl(s)
 		n.Curfn = ir.CurFunc
 	}
@@ -308,10 +304,6 @@ func checkembeddedtype(t *types.Type) {
 	}
 }
 
-// declare individual names - var, typ, const
-
-var declare_typegen int
-
 func fakeRecvField() *types.Field {
 	return types.NewField(src.NoXPos, nil, types.FakeRecvType())
 }
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 431fb04bef..3fc077b00c 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -1681,13 +1681,22 @@ func CheckMapKeys() {
 	mapqueue = nil
 }
 
+// typegen tracks the number of function-scoped defined types that
+// have been declared. It's used to generate unique linker symbols for
+// their runtime type descriptors.
+var typegen int32
+
 func typecheckdeftype(n *ir.Name) {
 	if base.EnableTrace && base.Flag.LowerT {
 		defer tracePrint("typecheckdeftype", n)(nil)
 	}
 
 	t := types.NewNamed(n)
-	t.Vargen = n.Typegen
+	if n.Curfn != nil {
+		typegen++
+		t.Vargen = typegen
+	}
+
 	if n.Pragma()&ir.NotInHeap != 0 {
 		t.SetNotInHeap(true)
 	}
-- 
GitLab


From cd5b74d2dfe6009d55c86e90f6c204e58c229c16 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 12 Jan 2021 11:34:00 -0800
Subject: [PATCH 0467/2400] [dev.regabi] cmd/compile: call NeedFuncSym in
 InitLSym

InitLSym is where we're now generating ABI wrappers, so it seems as
good a place as any to make sure we're generating the degenerate
closure wrappers for declared functions and methods.

Change-Id: I097f34bbcee65dee87a97f9ed6f3f38e4cf2e2b5
Reviewed-on: https://go-review.googlesource.com/c/go/+/283312
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/gc/main.go             |  2 --
 src/cmd/compile/internal/ssagen/abi.go          |  5 ++++-
 src/cmd/compile/internal/staticdata/data.go     | 13 ++++++++-----
 src/cmd/compile/internal/typecheck/func.go      |  4 ----
 src/cmd/compile/internal/typecheck/typecheck.go |  7 -------
 5 files changed, 12 insertions(+), 19 deletions(-)

diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index c3756309ea..1541bc4285 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -20,7 +20,6 @@ import (
 	"cmd/compile/internal/reflectdata"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/ssagen"
-	"cmd/compile/internal/staticdata"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/compile/internal/walk"
@@ -194,7 +193,6 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 
 	typecheck.Target = new(ir.Package)
 
-	typecheck.NeedFuncSym = staticdata.NeedFuncSym
 	typecheck.NeedITab = func(t, iface *types.Type) { reflectdata.ITabAddr(t, iface) }
 	typecheck.NeedRuntimeType = reflectdata.NeedRuntimeType // TODO(rsc): typenamesym for lock?
 
diff --git a/src/cmd/compile/internal/ssagen/abi.go b/src/cmd/compile/internal/ssagen/abi.go
index 1c013dd2d8..dc27ec3a29 100644
--- a/src/cmd/compile/internal/ssagen/abi.go
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -14,6 +14,7 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/escape"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/staticdata"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -137,6 +138,8 @@ func ReadSymABIs(file, myimportpath string) {
 // For body-less functions, we only create the LSym; for functions
 // with bodies call a helper to setup up / populate the LSym.
 func InitLSym(f *ir.Func, hasBody bool) {
+	staticdata.NeedFuncSym(f.Sym())
+
 	// FIXME: for new-style ABI wrappers, we set up the lsym at the
 	// point the wrapper is created.
 	if f.LSym != nil && base.Flag.ABIWrap {
@@ -152,7 +155,7 @@ func InitLSym(f *ir.Func, hasBody bool) {
 // makes calls to helpers to create ABI wrappers if needed.
 func selectLSym(f *ir.Func, hasBody bool) {
 	if f.LSym != nil {
-		base.Fatalf("Func.initLSym called twice")
+		base.FatalfAt(f.Pos(), "Func.initLSym called twice on %v", f)
 	}
 
 	if nam := f.Nname; !ir.IsBlank(nam) {
diff --git a/src/cmd/compile/internal/staticdata/data.go b/src/cmd/compile/internal/staticdata/data.go
index a2a844f940..4b12590fde 100644
--- a/src/cmd/compile/internal/staticdata/data.go
+++ b/src/cmd/compile/internal/staticdata/data.go
@@ -265,7 +265,7 @@ func FuncLinksym(n *ir.Name) *obj.LSym {
 	return FuncSym(n.Sym()).Linksym()
 }
 
-// NeedFuncSym ensures that s·f is exported.
+// NeedFuncSym ensures that s·f is exported, if needed.
 // It is only used with -dynlink.
 // When not compiling for dynamic linking,
 // the funcsyms are created as needed by
@@ -275,8 +275,13 @@ func FuncLinksym(n *ir.Name) *obj.LSym {
 // So instead, when dynamic linking, we only create
 // the s·f stubs in s's package.
 func NeedFuncSym(s *types.Sym) {
+	if base.Ctxt.InParallel {
+		// The append below probably just needs to lock
+		// funcsymsmu, like in FuncSym.
+		base.Fatalf("NeedFuncSym must be called in serial")
+	}
 	if !base.Ctxt.Flag_dynlink {
-		base.Fatalf("NeedFuncSym: dynlink")
+		return
 	}
 	if s.IsBlank() {
 		return
@@ -287,9 +292,7 @@ func NeedFuncSym(s *types.Sym) {
 		// get funcsyms.
 		return
 	}
-	if _, existed := s.Pkg.LookupOK(ir.FuncSymName(s)); !existed {
-		funcsyms = append(funcsyms, s)
-	}
+	funcsyms = append(funcsyms, s)
 }
 
 func WriteFuncSyms() {
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index 12762f7ee8..8f7411daec 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -364,10 +364,6 @@ func tcFunc(n *ir.Func) {
 		n.Nname.SetSym(ir.MethodSym(rcvr.Type, n.Shortname))
 		Declare(n.Nname, ir.PFUNC)
 	}
-
-	if base.Ctxt.Flag_dynlink && !inimport && n.Nname != nil {
-		NeedFuncSym(n.Sym())
-	}
 }
 
 // tcCall typechecks an OCALL node.
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 3fc077b00c..814af59772 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -24,7 +24,6 @@ var inimport bool // set during import
 var TypecheckAllowed bool
 
 var (
-	NeedFuncSym     = func(*types.Sym) {}
 	NeedITab        = func(t, itype *types.Type) {}
 	NeedRuntimeType = func(*types.Type) {}
 )
@@ -1140,12 +1139,6 @@ func typecheckMethodExpr(n *ir.SelectorExpr) (res ir.Node) {
 	n.SetOp(ir.OMETHEXPR)
 	n.Selection = m
 	n.SetType(NewMethodType(m.Type, n.X.Type()))
-
-	// Issue 25065. Make sure that we emit the symbol for a local method.
-	if base.Ctxt.Flag_dynlink && !inimport && (t.Sym() == nil || t.Sym().Pkg == types.LocalPkg) {
-		NeedFuncSym(n.FuncName().Sym())
-	}
-
 	return n
 }
 
-- 
GitLab


From cc90e7a51e15659ea1a1eb53ca08361b6a77696a Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 12 Jan 2021 11:38:32 -0800
Subject: [PATCH 0468/2400] [dev.regabi] cmd/compile: always use the compile
 queue

The compiler currently has two modes for compilation: one where it
compiles each function as it sees them, and another where it enqueues
them all into a work queue. A subsequent CL is going to reorder
function compilation to ensure that functions are always compiled
before any non-trivial function literals they enclose, and this will
be easier if we always use the compile work queue.

Also, fewer compilation modes makes things simpler to reason about.

Change-Id: Ie090e81f7476c49486296f2b90911fa0a466a5dd
Reviewed-on: https://go-review.googlesource.com/c/go/+/283313
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/base/debug.go     |  1 -
 src/cmd/compile/internal/gc/compile.go     | 87 ++++++----------------
 src/cmd/compile/internal/gc/main.go        |  5 +-
 src/cmd/compile/internal/gc/obj.go         |  5 +-
 src/cmd/compile/internal/liveness/plive.go |  1 +
 test/fixedbugs/issue20250.go               |  2 +-
 6 files changed, 28 insertions(+), 73 deletions(-)

diff --git a/src/cmd/compile/internal/base/debug.go b/src/cmd/compile/internal/base/debug.go
index 3acdcea846..164941bb26 100644
--- a/src/cmd/compile/internal/base/debug.go
+++ b/src/cmd/compile/internal/base/debug.go
@@ -32,7 +32,6 @@ type DebugFlags struct {
 	Append        int    `help:"print information about append compilation"`
 	Checkptr      int    `help:"instrument unsafe pointer conversions"`
 	Closure       int    `help:"print information about closure compilation"`
-	CompileLater  int    `help:"compile functions as late as possible"`
 	DclStack      int    `help:"run internal dclstack check"`
 	Defer         int    `help:"print information about defer compilation"`
 	DisableNil    int    `help:"disable nil checks"`
diff --git a/src/cmd/compile/internal/gc/compile.go b/src/cmd/compile/internal/gc/compile.go
index 25b1c76737..b9c10056b4 100644
--- a/src/cmd/compile/internal/gc/compile.go
+++ b/src/cmd/compile/internal/gc/compile.go
@@ -26,21 +26,17 @@ var (
 	compilequeue []*ir.Func // functions waiting to be compiled
 )
 
-func funccompile(fn *ir.Func) {
+func enqueueFunc(fn *ir.Func) {
 	if ir.CurFunc != nil {
-		base.Fatalf("funccompile %v inside %v", fn.Sym(), ir.CurFunc.Sym())
+		base.FatalfAt(fn.Pos(), "enqueueFunc %v inside %v", fn, ir.CurFunc)
 	}
 
-	if fn.Type() == nil {
-		if base.Errors() == 0 {
-			base.Fatalf("funccompile missing type")
-		}
+	if ir.FuncName(fn) == "_" {
+		// Skip compiling blank functions.
+		// Frontend already reported any spec-mandated errors (#29870).
 		return
 	}
 
-	// assign parameter offsets
-	types.CalcSize(fn.Type())
-
 	if len(fn.Body) == 0 {
 		// Initialize ABI wrappers if necessary.
 		ssagen.InitLSym(fn, false)
@@ -48,35 +44,31 @@ func funccompile(fn *ir.Func) {
 		return
 	}
 
-	typecheck.DeclContext = ir.PAUTO
-	ir.CurFunc = fn
-	compile(fn)
-	ir.CurFunc = nil
-	typecheck.DeclContext = ir.PEXTERN
+	errorsBefore := base.Errors()
+	prepareFunc(fn)
+	if base.Errors() > errorsBefore {
+		return
+	}
+
+	compilequeue = append(compilequeue, fn)
 }
 
-func compile(fn *ir.Func) {
+// prepareFunc handles any remaining frontend compilation tasks that
+// aren't yet safe to perform concurrently.
+func prepareFunc(fn *ir.Func) {
 	// Set up the function's LSym early to avoid data races with the assemblers.
 	// Do this before walk, as walk needs the LSym to set attributes/relocations
 	// (e.g. in markTypeUsedInInterface).
 	ssagen.InitLSym(fn, true)
 
-	errorsBefore := base.Errors()
-	walk.Walk(fn)
-	if base.Errors() > errorsBefore {
-		return
-	}
-
-	// From this point, there should be no uses of Curfn. Enforce that.
-	ir.CurFunc = nil
+	// Calculate parameter offsets.
+	types.CalcSize(fn.Type())
 
-	if ir.FuncName(fn) == "_" {
-		// We don't need to generate code for this function, just report errors in its body.
-		// At this point we've generated any errors needed.
-		// (Beyond here we generate only non-spec errors, like "stack frame too large".)
-		// See issue 29870.
-		return
-	}
+	typecheck.DeclContext = ir.PAUTO
+	ir.CurFunc = fn
+	walk.Walk(fn)
+	ir.CurFunc = nil // enforce no further uses of CurFunc
+	typecheck.DeclContext = ir.PEXTERN
 
 	// Make sure type syms are declared for all types that might
 	// be types of stack objects. We need to do this here
@@ -95,28 +87,6 @@ func compile(fn *ir.Func) {
 			}
 		}
 	}
-
-	if compilenow(fn) {
-		ssagen.Compile(fn, 0)
-	} else {
-		compilequeue = append(compilequeue, fn)
-	}
-}
-
-// compilenow reports whether to compile immediately.
-// If functions are not compiled immediately,
-// they are enqueued in compilequeue,
-// which is drained by compileFunctions.
-func compilenow(fn *ir.Func) bool {
-	// Issue 38068: if this function is a method AND an inline
-	// candidate AND was not inlined (yet), put it onto the compile
-	// queue instead of compiling it immediately. This is in case we
-	// wind up inlining it into a method wrapper that is generated by
-	// compiling a function later on in the Target.Decls list.
-	if ir.IsMethod(fn) && isInlinableButNotInlined(fn) {
-		return false
-	}
-	return base.Flag.LowerC == 1 && base.Debug.CompileLater == 0
 }
 
 // compileFunctions compiles all functions in compilequeue.
@@ -163,16 +133,3 @@ func compileFunctions() {
 		types.CalcSizeDisabled = false
 	}
 }
-
-// isInlinableButNotInlined returns true if 'fn' was marked as an
-// inline candidate but then never inlined (presumably because we
-// found no call sites).
-func isInlinableButNotInlined(fn *ir.Func) bool {
-	if fn.Inl == nil {
-		return false
-	}
-	if fn.Sym() == nil {
-		return true
-	}
-	return !fn.Linksym().WasInlined()
-}
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 1541bc4285..2903d64ff8 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -300,9 +300,8 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	base.Timer.Start("be", "compilefuncs")
 	fcount := int64(0)
 	for i := 0; i < len(typecheck.Target.Decls); i++ {
-		n := typecheck.Target.Decls[i]
-		if n.Op() == ir.ODCLFUNC {
-			funccompile(n.(*ir.Func))
+		if fn, ok := typecheck.Target.Decls[i].(*ir.Func); ok {
+			enqueueFunc(fn)
 			fcount++
 		}
 	}
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index fbb2145e1b..753db80f76 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -131,9 +131,8 @@ func dumpdata() {
 	// It was not until issue 24761 that we found any code that required a loop at all.
 	for {
 		for i := numDecls; i < len(typecheck.Target.Decls); i++ {
-			n := typecheck.Target.Decls[i]
-			if n.Op() == ir.ODCLFUNC {
-				funccompile(n.(*ir.Func))
+			if n, ok := typecheck.Target.Decls[i].(*ir.Func); ok {
+				enqueueFunc(n)
 			}
 		}
 		numDecls = len(typecheck.Target.Decls)
diff --git a/src/cmd/compile/internal/liveness/plive.go b/src/cmd/compile/internal/liveness/plive.go
index 26d90824b2..8d1754c813 100644
--- a/src/cmd/compile/internal/liveness/plive.go
+++ b/src/cmd/compile/internal/liveness/plive.go
@@ -1223,6 +1223,7 @@ func WriteFuncMap(fn *ir.Func) {
 	if ir.FuncName(fn) == "_" || fn.Sym().Linkname != "" {
 		return
 	}
+	types.CalcSize(fn.Type())
 	lsym := base.Ctxt.Lookup(fn.LSym.Name + ".args_stackmap")
 	nptr := int(fn.Type().ArgWidth() / int64(types.PtrSize))
 	bv := bitvec.New(int32(nptr) * 2)
diff --git a/test/fixedbugs/issue20250.go b/test/fixedbugs/issue20250.go
index c190515274..1a513bea56 100644
--- a/test/fixedbugs/issue20250.go
+++ b/test/fixedbugs/issue20250.go
@@ -1,4 +1,4 @@
-// errorcheck -0 -live -l -d=compilelater
+// errorcheck -0 -live -l
 
 // Copyright 2017 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
-- 
GitLab


From 432f9ffb11231b00b67c8fa8047f21a8282fa914 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 12 Jan 2021 11:39:10 -0800
Subject: [PATCH 0469/2400] [dev.regabi] cmd/compile: unindent compileFunctions

No real code changes. Just splitting into a separate CL so the next
one is easier to review.

Change-Id: I428dc986b76370d8d3afc12cf19585f6384389d7
Reviewed-on: https://go-review.googlesource.com/c/go/+/283314
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/gc/compile.go | 76 +++++++++++++-------------
 1 file changed, 39 insertions(+), 37 deletions(-)

diff --git a/src/cmd/compile/internal/gc/compile.go b/src/cmd/compile/internal/gc/compile.go
index b9c10056b4..c2894ab012 100644
--- a/src/cmd/compile/internal/gc/compile.go
+++ b/src/cmd/compile/internal/gc/compile.go
@@ -93,43 +93,45 @@ func prepareFunc(fn *ir.Func) {
 // It fans out nBackendWorkers to do the work
 // and waits for them to complete.
 func compileFunctions() {
-	if len(compilequeue) != 0 {
-		types.CalcSizeDisabled = true // not safe to calculate sizes concurrently
-		if race.Enabled {
-			// Randomize compilation order to try to shake out races.
-			tmp := make([]*ir.Func, len(compilequeue))
-			perm := rand.Perm(len(compilequeue))
-			for i, v := range perm {
-				tmp[v] = compilequeue[i]
-			}
-			copy(compilequeue, tmp)
-		} else {
-			// Compile the longest functions first,
-			// since they're most likely to be the slowest.
-			// This helps avoid stragglers.
-			sort.Slice(compilequeue, func(i, j int) bool {
-				return len(compilequeue[i].Body) > len(compilequeue[j].Body)
-			})
-		}
-		var wg sync.WaitGroup
-		base.Ctxt.InParallel = true
-		c := make(chan *ir.Func, base.Flag.LowerC)
-		for i := 0; i < base.Flag.LowerC; i++ {
-			wg.Add(1)
-			go func(worker int) {
-				for fn := range c {
-					ssagen.Compile(fn, worker)
-				}
-				wg.Done()
-			}(i)
-		}
-		for _, fn := range compilequeue {
-			c <- fn
+	if len(compilequeue) == 0 {
+		return
+	}
+
+	types.CalcSizeDisabled = true // not safe to calculate sizes concurrently
+	if race.Enabled {
+		// Randomize compilation order to try to shake out races.
+		tmp := make([]*ir.Func, len(compilequeue))
+		perm := rand.Perm(len(compilequeue))
+		for i, v := range perm {
+			tmp[v] = compilequeue[i]
 		}
-		close(c)
-		compilequeue = nil
-		wg.Wait()
-		base.Ctxt.InParallel = false
-		types.CalcSizeDisabled = false
+		copy(compilequeue, tmp)
+	} else {
+		// Compile the longest functions first,
+		// since they're most likely to be the slowest.
+		// This helps avoid stragglers.
+		sort.Slice(compilequeue, func(i, j int) bool {
+			return len(compilequeue[i].Body) > len(compilequeue[j].Body)
+		})
+	}
+	var wg sync.WaitGroup
+	base.Ctxt.InParallel = true
+	c := make(chan *ir.Func, base.Flag.LowerC)
+	for i := 0; i < base.Flag.LowerC; i++ {
+		wg.Add(1)
+		go func(worker int) {
+			for fn := range c {
+				ssagen.Compile(fn, worker)
+			}
+			wg.Done()
+		}(i)
+	}
+	for _, fn := range compilequeue {
+		c <- fn
 	}
+	close(c)
+	compilequeue = nil
+	wg.Wait()
+	base.Ctxt.InParallel = false
+	types.CalcSizeDisabled = false
 }
-- 
GitLab


From d6ad88b4db454813e1bdf09635cd853fe3b7ef13 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 12 Jan 2021 12:00:58 -0800
Subject: [PATCH 0470/2400] [dev.regabi] cmd/compile: compile functions before
 closures

This CL reorders function compilation to ensure that functions are
always compiled before any enclosed function literals. The primary
goal of this is to reduce the risk of race conditions that arise due
to compilation of function literals needing to inspect data from their
closure variables. However, a pleasant side effect is that it allows
skipping the redundant, separate compilation of function literals that
were inlined into their enclosing function.

Change-Id: I03ee96212988cb578c2452162b7e99cc5e92918f
Reviewed-on: https://go-review.googlesource.com/c/go/+/282892
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/compile.go     | 51 +++++++++++++++++-----
 src/cmd/compile/internal/ir/func.go        |  4 ++
 src/cmd/compile/internal/ir/sizeof_test.go |  2 +-
 src/cmd/compile/internal/walk/closure.go   |  2 +
 src/cmd/compile/internal/walk/expr.go      |  7 ++-
 5 files changed, 52 insertions(+), 14 deletions(-)

diff --git a/src/cmd/compile/internal/gc/compile.go b/src/cmd/compile/internal/gc/compile.go
index c2894ab012..410b3e90ea 100644
--- a/src/cmd/compile/internal/gc/compile.go
+++ b/src/cmd/compile/internal/gc/compile.go
@@ -37,6 +37,10 @@ func enqueueFunc(fn *ir.Func) {
 		return
 	}
 
+	if clo := fn.OClosure; clo != nil && !ir.IsTrivialClosure(clo) {
+		return // we'll get this as part of its enclosing function
+	}
+
 	if len(fn.Body) == 0 {
 		// Initialize ABI wrappers if necessary.
 		ssagen.InitLSym(fn, false)
@@ -45,11 +49,22 @@ func enqueueFunc(fn *ir.Func) {
 	}
 
 	errorsBefore := base.Errors()
-	prepareFunc(fn)
+
+	todo := []*ir.Func{fn}
+	for len(todo) > 0 {
+		next := todo[len(todo)-1]
+		todo = todo[:len(todo)-1]
+
+		prepareFunc(next)
+		todo = append(todo, next.Closures...)
+	}
+
 	if base.Errors() > errorsBefore {
 		return
 	}
 
+	// Enqueue just fn itself. compileFunctions will handle
+	// scheduling compilation of its closures after it's done.
 	compilequeue = append(compilequeue, fn)
 }
 
@@ -97,7 +112,6 @@ func compileFunctions() {
 		return
 	}
 
-	types.CalcSizeDisabled = true // not safe to calculate sizes concurrently
 	if race.Enabled {
 		// Randomize compilation order to try to shake out races.
 		tmp := make([]*ir.Func, len(compilequeue))
@@ -114,22 +128,37 @@ func compileFunctions() {
 			return len(compilequeue[i].Body) > len(compilequeue[j].Body)
 		})
 	}
-	var wg sync.WaitGroup
-	base.Ctxt.InParallel = true
-	c := make(chan *ir.Func, base.Flag.LowerC)
+
+	// We queue up a goroutine per function that needs to be
+	// compiled, but require them to grab an available worker ID
+	// before doing any substantial work to limit parallelism.
+	workerIDs := make(chan int, base.Flag.LowerC)
 	for i := 0; i < base.Flag.LowerC; i++ {
+		workerIDs <- i
+	}
+
+	var wg sync.WaitGroup
+	var asyncCompile func(*ir.Func)
+	asyncCompile = func(fn *ir.Func) {
 		wg.Add(1)
-		go func(worker int) {
-			for fn := range c {
-				ssagen.Compile(fn, worker)
+		go func() {
+			worker := <-workerIDs
+			ssagen.Compile(fn, worker)
+			workerIDs <- worker
+
+			// Done compiling fn. Schedule it's closures for compilation.
+			for _, closure := range fn.Closures {
+				asyncCompile(closure)
 			}
 			wg.Done()
-		}(i)
+		}()
 	}
+
+	types.CalcSizeDisabled = true // not safe to calculate sizes concurrently
+	base.Ctxt.InParallel = true
 	for _, fn := range compilequeue {
-		c <- fn
+		asyncCompile(fn)
 	}
-	close(c)
 	compilequeue = nil
 	wg.Wait()
 	base.Ctxt.InParallel = false
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index d660fe3b40..3fe23635f4 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -81,6 +81,10 @@ type Func struct {
 	// Byval set if they're captured by value.
 	ClosureVars []*Name
 
+	// Enclosed functions that need to be compiled.
+	// Populated during walk.
+	Closures []*Func
+
 	// Parents records the parent scope of each scope within a
 	// function. The root scope (0) has no parent, so the i'th
 	// scope's parent is stored at Parents[i-1].
diff --git a/src/cmd/compile/internal/ir/sizeof_test.go b/src/cmd/compile/internal/ir/sizeof_test.go
index 2ada7231aa..f95f77d6a2 100644
--- a/src/cmd/compile/internal/ir/sizeof_test.go
+++ b/src/cmd/compile/internal/ir/sizeof_test.go
@@ -20,7 +20,7 @@ func TestSizeof(t *testing.T) {
 		_32bit uintptr     // size on 32bit platforms
 		_64bit uintptr     // size on 64bit platforms
 	}{
-		{Func{}, 184, 320},
+		{Func{}, 196, 344},
 		{Name{}, 116, 208},
 	}
 
diff --git a/src/cmd/compile/internal/walk/closure.go b/src/cmd/compile/internal/walk/closure.go
index acb74b9901..7fa63ea9c7 100644
--- a/src/cmd/compile/internal/walk/closure.go
+++ b/src/cmd/compile/internal/walk/closure.go
@@ -86,6 +86,8 @@ func walkClosure(clo *ir.ClosureExpr, init *ir.Nodes) ir.Node {
 		}
 		return fn.Nname
 	}
+
+	ir.CurFunc.Closures = append(ir.CurFunc.Closures, fn)
 	ir.ClosureDebugRuntimeCheck(clo)
 
 	typ := typecheck.ClosureType(clo)
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index df575d6985..508cdd1d06 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -488,12 +488,15 @@ func walkCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 		reflectdata.MarkUsedIfaceMethod(n)
 	}
 
-	if n.Op() == ir.OCALLFUNC && n.X.Op() == ir.OCLOSURE {
+	if n.Op() == ir.OCALLFUNC && n.X.Op() == ir.OCLOSURE && !ir.IsTrivialClosure(n.X.(*ir.ClosureExpr)) {
 		// Transform direct call of a closure to call of a normal function.
 		// transformclosure already did all preparation work.
+		// We leave trivial closures for walkClosure to handle.
 
-		// Prepend captured variables to argument list.
 		clo := n.X.(*ir.ClosureExpr)
+		ir.CurFunc.Closures = append(ir.CurFunc.Closures, clo.Func)
+
+		// Prepend captured variables to argument list.
 		n.Args.Prepend(closureArgs(clo)...)
 
 		// Replace OCLOSURE with ONAME/PFUNC.
-- 
GitLab


From 41352fd401f4f22eceeca375361e018ea787f0fd Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 12 Jan 2021 12:12:27 -0800
Subject: [PATCH 0471/2400] [dev.regabi] cmd/compile: transform closures during
 walk

We used to transform directly called closures in a separate pass
before walk, because we couldn't guarantee whether we'd see the
closure call or the closure itself first. As of the last CL, this
ordering is always guaranteed, so we can rewrite calls and the closure
at the same time.

Change-Id: Ia6f4d504c24795e41500108589b53395d301123b
Reviewed-on: https://go-review.googlesource.com/c/go/+/283315
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/gc/main.go      | 15 ----
 src/cmd/compile/internal/walk/closure.go | 99 ++++++++++++++----------
 src/cmd/compile/internal/walk/expr.go    | 23 +-----
 3 files changed, 61 insertions(+), 76 deletions(-)

diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 2903d64ff8..9ecdd510b1 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -22,7 +22,6 @@ import (
 	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
-	"cmd/compile/internal/walk"
 	"cmd/internal/dwarf"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
@@ -269,20 +268,6 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 		ssagen.EnableNoWriteBarrierRecCheck()
 	}
 
-	// Transform closure bodies to properly reference captured variables.
-	// This needs to happen before walk, because closures must be transformed
-	// before walk reaches a call of a closure.
-	base.Timer.Start("fe", "xclosures")
-	for _, n := range typecheck.Target.Decls {
-		if n.Op() == ir.ODCLFUNC {
-			n := n.(*ir.Func)
-			if n.OClosure != nil {
-				ir.CurFunc = n
-				walk.Closure(n)
-			}
-		}
-	}
-
 	// Prepare for SSA compilation.
 	// This must be before peekitabs, because peekitabs
 	// can trigger function compilation.
diff --git a/src/cmd/compile/internal/walk/closure.go b/src/cmd/compile/internal/walk/closure.go
index 7fa63ea9c7..e9b3698080 100644
--- a/src/cmd/compile/internal/walk/closure.go
+++ b/src/cmd/compile/internal/walk/closure.go
@@ -12,50 +12,43 @@ import (
 	"cmd/internal/src"
 )
 
-// Closure is called in a separate phase after escape analysis.
-// It transform closure bodies to properly reference captured variables.
-func Closure(fn *ir.Func) {
-	if len(fn.ClosureVars) == 0 {
-		return
-	}
+// directClosureCall rewrites a direct call of a function literal into
+// a normal function call with closure variables passed as arguments.
+// This avoids allocation of a closure object.
+//
+// For illustration, the following call:
+//
+//	func(a int) {
+//		println(byval)
+//		byref++
+//	}(42)
+//
+// becomes:
+//
+//	func(byval int, &byref *int, a int) {
+//		println(byval)
+//		(*&byref)++
+//	}(byval, &byref, 42)
+func directClosureCall(n *ir.CallExpr) {
+	clo := n.X.(*ir.ClosureExpr)
+	clofn := clo.Func
 
-	if !fn.ClosureCalled() {
-		// The closure is not directly called, so it is going to stay as closure.
-		fn.SetNeedctxt(true)
-		return
+	if ir.IsTrivialClosure(clo) {
+		return // leave for walkClosure to handle
 	}
 
-	lno := base.Pos
-	base.Pos = fn.Pos()
-
-	// If the closure is directly called, we transform it to a plain function call
-	// with variables passed as args. This avoids allocation of a closure object.
-	// Here we do only a part of the transformation. Walk of OCALLFUNC(OCLOSURE)
-	// will complete the transformation later.
-	// For illustration, the following closure:
-	//	func(a int) {
-	//		println(byval)
-	//		byref++
-	//	}(42)
-	// becomes:
-	//	func(byval int, &byref *int, a int) {
-	//		println(byval)
-	//		(*&byref)++
-	//	}(byval, &byref, 42)
-
-	// f is ONAME of the actual function.
-	f := fn.Nname
-
 	// We are going to insert captured variables before input args.
 	var params []*types.Field
 	var decls []*ir.Name
-	for _, v := range fn.ClosureVars {
+	for _, v := range clofn.ClosureVars {
 		if !v.Byval() {
 			// If v of type T is captured by reference,
 			// we introduce function param &v *T
 			// and v remains PAUTOHEAP with &v heapaddr
 			// (accesses will implicitly deref &v).
-			addr := typecheck.NewName(typecheck.Lookup("&" + v.Sym().Name))
+
+			addr := ir.NewNameAt(clofn.Pos(), typecheck.Lookup("&"+v.Sym().Name))
+			addr.Curfn = clofn
 			addr.SetType(types.NewPtr(v.Type()))
 			v.Heapaddr = addr
 			v = addr
@@ -69,32 +62,58 @@ func Closure(fn *ir.Func) {
 		params = append(params, fld)
 	}
 
+	// f is ONAME of the actual function.
+	f := clofn.Nname
+
 	// Prepend params and decls.
-	f.Type().Params().SetFields(append(params, f.Type().Params().FieldSlice()...))
-	fn.Dcl = append(decls, fn.Dcl...)
+	typ := f.Type()
+	typ.Params().SetFields(append(params, typ.Params().FieldSlice()...))
+	clofn.Dcl = append(decls, clofn.Dcl...)
+
+	// Rewrite call.
+	n.X = f
+	n.Args.Prepend(closureArgs(clo)...)
+
+	// Update the call expression's type. We need to do this
+	// because typecheck gave it the result type of the OCLOSURE
+	// node, but we only rewrote the ONAME node's type. Logically,
+	// they're the same, but the stack offsets probably changed.
+	//
+	// TODO(mdempsky): Reuse a single type for both.
+	if typ.NumResults() == 1 {
+		n.SetType(typ.Results().Field(0).Type)
+	} else {
+		n.SetType(typ.Results())
+	}
 
-	base.Pos = lno
+	// Add to Closures for enqueueFunc. It's no longer a proper
+	// closure, but we may have already skipped over it in the
+	// functions list as a non-trivial closure, so this just
+	// ensures it's compiled.
+	ir.CurFunc.Closures = append(ir.CurFunc.Closures, clofn)
 }
 
 func walkClosure(clo *ir.ClosureExpr, init *ir.Nodes) ir.Node {
-	fn := clo.Func
+	clofn := clo.Func
 
 	// If no closure vars, don't bother wrapping.
 	if ir.IsTrivialClosure(clo) {
 		if base.Debug.Closure > 0 {
 			base.WarnfAt(clo.Pos(), "closure converted to global")
 		}
-		return fn.Nname
+		return clofn.Nname
 	}
 
-	ir.CurFunc.Closures = append(ir.CurFunc.Closures, fn)
+	// The closure is not trivial or directly called, so it's going to stay a closure.
 	ir.ClosureDebugRuntimeCheck(clo)
+	clofn.SetNeedctxt(true)
+	ir.CurFunc.Closures = append(ir.CurFunc.Closures, clofn)
 
 	typ := typecheck.ClosureType(clo)
 
 	clos := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ), nil)
 	clos.SetEsc(clo.Esc())
-	clos.List = append([]ir.Node{ir.NewUnaryExpr(base.Pos, ir.OCFUNC, fn.Nname)}, closureArgs(clo)...)
+	clos.List = append([]ir.Node{ir.NewUnaryExpr(base.Pos, ir.OCFUNC, clofn.Nname)}, closureArgs(clo)...)
 
 	addr := typecheck.NodAddr(clos)
 	addr.SetEsc(clo.Esc())
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 508cdd1d06..893a95f403 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -488,27 +488,8 @@ func walkCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 		reflectdata.MarkUsedIfaceMethod(n)
 	}
 
-	if n.Op() == ir.OCALLFUNC && n.X.Op() == ir.OCLOSURE && !ir.IsTrivialClosure(n.X.(*ir.ClosureExpr)) {
-		// Transform direct call of a closure to call of a normal function.
-		// transformclosure already did all preparation work.
-		// We leave trivial closures for walkClosure to handle.
-
-		clo := n.X.(*ir.ClosureExpr)
-		ir.CurFunc.Closures = append(ir.CurFunc.Closures, clo.Func)
-
-		// Prepend captured variables to argument list.
-		n.Args.Prepend(closureArgs(clo)...)
-
-		// Replace OCLOSURE with ONAME/PFUNC.
-		n.X = clo.Func.Nname
-
-		// Update type of OCALLFUNC node.
-		// Output arguments had not changed, but their offsets could.
-		if n.X.Type().NumResults() == 1 {
-			n.SetType(n.X.Type().Results().Field(0).Type)
-		} else {
-			n.SetType(n.X.Type().Results())
-		}
+	if n.Op() == ir.OCALLFUNC && n.X.Op() == ir.OCLOSURE {
+		directClosureCall(n)
 	}
 
 	walkCall1(n, init)
-- 
GitLab


From d9acf6f3a3758c3096ee5ef5a24c2bc5df9d9c8b Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 12 Jan 2021 12:25:33 -0800
Subject: [PATCH 0472/2400] [dev.regabi] cmd/compile: remove Func.ClosureType

The closure's type always matches the corresponding function's type,
so just use one instance rather than carrying around two. Simplifies
construction of closures, rewriting them during walk, and shrinks
memory usage.

Passes toolstash -cmp.

Change-Id: I83b8b8f435b02ab25a30fb7aa15d5ec7ad97189d
Reviewed-on: https://go-review.googlesource.com/c/go/+/283152
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/ir/func.go        |  2 --
 src/cmd/compile/internal/ir/sizeof_test.go |  2 +-
 src/cmd/compile/internal/noder/noder.go    |  2 --
 src/cmd/compile/internal/typecheck/func.go |  4 ++--
 src/cmd/compile/internal/walk/closure.go   | 10 +++++-----
 5 files changed, 8 insertions(+), 12 deletions(-)

diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 3fe23635f4..30cddd298e 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -71,8 +71,6 @@ type Func struct {
 	// Anonymous and blank PPARAMOUTs are declared as ~rNN and ~bNN Names, respectively.
 	Dcl []*Name
 
-	ClosureType Ntype // closure representation type
-
 	// ClosureVars lists the free variables that are used within a
 	// function literal, but formally declared in an enclosing
 	// function. The variables in this slice are the closure function's
diff --git a/src/cmd/compile/internal/ir/sizeof_test.go b/src/cmd/compile/internal/ir/sizeof_test.go
index f95f77d6a2..553dc53760 100644
--- a/src/cmd/compile/internal/ir/sizeof_test.go
+++ b/src/cmd/compile/internal/ir/sizeof_test.go
@@ -20,7 +20,7 @@ func TestSizeof(t *testing.T) {
 		_32bit uintptr     // size on 32bit platforms
 		_64bit uintptr     // size on 64bit platforms
 	}{
-		{Func{}, 196, 344},
+		{Func{}, 188, 328},
 		{Name{}, 116, 208},
 	}
 
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index ec0debdbbd..edd30a1fc1 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -1856,7 +1856,6 @@ func fakeRecv() *ir.Field {
 
 func (p *noder) funcLit(expr *syntax.FuncLit) ir.Node {
 	xtype := p.typeExpr(expr.Type)
-	ntype := p.typeExpr(expr.Type)
 
 	fn := ir.NewFunc(p.pos(expr))
 	fn.SetIsHiddenClosure(ir.CurFunc != nil)
@@ -1867,7 +1866,6 @@ func (p *noder) funcLit(expr *syntax.FuncLit) ir.Node {
 	fn.Nname.Defn = fn
 
 	clo := ir.NewClosureExpr(p.pos(expr), fn)
-	fn.ClosureType = ntype
 	fn.OClosure = clo
 
 	p.funcBody(fn, expr.Body)
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index 8f7411daec..03a10f594a 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -293,20 +293,20 @@ func tcClosure(clo *ir.ClosureExpr, top int) {
 		fn.Iota = x
 	}
 
-	fn.ClosureType = typecheckNtype(fn.ClosureType)
-	clo.SetType(fn.ClosureType.Type())
 	fn.SetClosureCalled(top&ctxCallee != 0)
 
 	// Do not typecheck fn twice, otherwise, we will end up pushing
 	// fn to Target.Decls multiple times, causing initLSym called twice.
 	// See #30709
 	if fn.Typecheck() == 1 {
+		clo.SetType(fn.Type())
 		return
 	}
 
 	fn.Nname.SetSym(closurename(ir.CurFunc))
 	ir.MarkFunc(fn.Nname)
 	Func(fn)
+	clo.SetType(fn.Type())
 
 	// Type check the body now, but only if we're inside a function.
 	// At top level (in a variable initialization: curfn==nil) we're not
diff --git a/src/cmd/compile/internal/walk/closure.go b/src/cmd/compile/internal/walk/closure.go
index e9b3698080..694aa99940 100644
--- a/src/cmd/compile/internal/walk/closure.go
+++ b/src/cmd/compile/internal/walk/closure.go
@@ -64,10 +64,12 @@ func directClosureCall(n *ir.CallExpr) {
 
 	// f is ONAME of the actual function.
 	f := clofn.Nname
-
-	// Prepend params and decls.
 	typ := f.Type()
-	typ.Params().SetFields(append(params, typ.Params().FieldSlice()...))
+
+	// Create new function type with parameters prepended, and
+	// then update type and declarations.
+	typ = types.NewSignature(typ.Pkg(), nil, append(params, typ.Params().FieldSlice()...), typ.Results().FieldSlice())
+	f.SetType(typ)
 	clofn.Dcl = append(decls, clofn.Dcl...)
 
 	// Rewrite call.
@@ -78,8 +80,6 @@ func directClosureCall(n *ir.CallExpr) {
 	// because typecheck gave it the result type of the OCLOSURE
 	// node, but we only rewrote the ONAME node's type. Logically,
 	// they're the same, but the stack offsets probably changed.
-	//
-	// TODO(mdempsky): Reuse a single type for both.
 	if typ.NumResults() == 1 {
 		n.SetType(typ.Results().Field(0).Type)
 	} else {
-- 
GitLab


From 9a19481acb93114948503d935e10f6985ff15843 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Wed, 30 Dec 2020 12:05:57 -0500
Subject: [PATCH 0473/2400] [dev.regabi] cmd/compile: make ordering for
 InvertFlags more stable

Current many architectures use a rule along the lines of

// Canonicalize the order of arguments to comparisons - helps with CSE.
((CMP|CMPW) x y) && x.ID > y.ID => (InvertFlags ((CMP|CMPW) y x))

to normalize comparisons as much as possible for CSE.  Replace the
ID comparison with something less variable across compiler changes.
This helps avoid spurious failures in some of the codegen-comparison
tests (though the current choice of comparison is sensitive to Op
ordering).

Two tests changed to accommodate modified instruction choice.

Change-Id: Ib35f450bd2bae9d4f9f7838ceaf7ec682bcf1e1a
Reviewed-on: https://go-review.googlesource.com/c/go/+/280155
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/gen/386.rules   |  2 +-
 src/cmd/compile/internal/ssa/gen/AMD64.rules |  2 +-
 src/cmd/compile/internal/ssa/gen/ARM.rules   |  2 +-
 src/cmd/compile/internal/ssa/gen/ARM64.rules |  2 +-
 src/cmd/compile/internal/ssa/gen/PPC64.rules |  2 +-
 src/cmd/compile/internal/ssa/gen/S390X.rules |  2 +-
 src/cmd/compile/internal/ssa/rewrite.go      | 12 ++++++++++++
 src/cmd/compile/internal/ssa/rewrite386.go   | 12 ++++++------
 src/cmd/compile/internal/ssa/rewriteAMD64.go | 16 ++++++++--------
 src/cmd/compile/internal/ssa/rewriteARM.go   |  4 ++--
 src/cmd/compile/internal/ssa/rewriteARM64.go |  8 ++++----
 src/cmd/compile/internal/ssa/rewritePPC64.go | 16 ++++++++--------
 src/cmd/compile/internal/ssa/rewriteS390X.go | 16 ++++++++--------
 test/codegen/condmove.go                     |  6 +++---
 test/codegen/spectre.go                      |  4 ++--
 15 files changed, 59 insertions(+), 47 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/gen/386.rules b/src/cmd/compile/internal/ssa/gen/386.rules
index fbc12fd672..df03cb71a6 100644
--- a/src/cmd/compile/internal/ssa/gen/386.rules
+++ b/src/cmd/compile/internal/ssa/gen/386.rules
@@ -475,7 +475,7 @@
 (CMPB (MOVLconst [c]) x) => (InvertFlags (CMPBconst x [int8(c)]))
 
 // Canonicalize the order of arguments to comparisons - helps with CSE.
-(CMP(L|W|B) x y) && x.ID > y.ID => (InvertFlags (CMP(L|W|B) y x))
+(CMP(L|W|B) x y) && canonLessThan(x,y) => (InvertFlags (CMP(L|W|B) y x))
 
 // strength reduction
 // Assumes that the following costs from https://gmplib.org/~tege/x86-timing.pdf:
diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules
index a866a967b9..7d46266411 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64.rules
+++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules
@@ -916,7 +916,7 @@
 (CMPB (MOVLconst [c]) x) => (InvertFlags (CMPBconst x [int8(c)]))
 
 // Canonicalize the order of arguments to comparisons - helps with CSE.
-(CMP(Q|L|W|B) x y) && x.ID > y.ID => (InvertFlags (CMP(Q|L|W|B) y x))
+(CMP(Q|L|W|B) x y) && canonLessThan(x,y) => (InvertFlags (CMP(Q|L|W|B) y x))
 
 // Using MOVZX instead of AND is cheaper.
 (AND(Q|L)const [  0xFF] x) => (MOVBQZX x)
diff --git a/src/cmd/compile/internal/ssa/gen/ARM.rules b/src/cmd/compile/internal/ssa/gen/ARM.rules
index 11c36b5da3..de0df363e4 100644
--- a/src/cmd/compile/internal/ssa/gen/ARM.rules
+++ b/src/cmd/compile/internal/ssa/gen/ARM.rules
@@ -507,7 +507,7 @@
 (TEQ x (MOVWconst [c])) => (TEQconst [c] x)
 
 // Canonicalize the order of arguments to comparisons - helps with CSE.
-(CMP x y) && x.ID > y.ID => (InvertFlags (CMP y x))
+(CMP x y) && canonLessThan(x,y) => (InvertFlags (CMP y x))
 
 // don't extend after proper load
 // MOVWreg instruction is not emitted if src and dst registers are same, but it ensures the type.
diff --git a/src/cmd/compile/internal/ssa/gen/ARM64.rules b/src/cmd/compile/internal/ssa/gen/ARM64.rules
index 3f4d0c1c52..a0e2a0d5e2 100644
--- a/src/cmd/compile/internal/ssa/gen/ARM64.rules
+++ b/src/cmd/compile/internal/ssa/gen/ARM64.rules
@@ -1151,7 +1151,7 @@
 (CMPW (MOVDconst [c]) x) => (InvertFlags (CMPWconst [int32(c)] x))
 
 // Canonicalize the order of arguments to comparisons - helps with CSE.
-((CMP|CMPW) x y) && x.ID > y.ID => (InvertFlags ((CMP|CMPW) y x))
+((CMP|CMPW) x y) && canonLessThan(x,y) => (InvertFlags ((CMP|CMPW) y x))
 
 // mul-neg => mneg
 (NEG (MUL x y)) => (MNEG x y)
diff --git a/src/cmd/compile/internal/ssa/gen/PPC64.rules b/src/cmd/compile/internal/ssa/gen/PPC64.rules
index c064046172..a762be65d4 100644
--- a/src/cmd/compile/internal/ssa/gen/PPC64.rules
+++ b/src/cmd/compile/internal/ssa/gen/PPC64.rules
@@ -1088,7 +1088,7 @@
 (CMPWU (MOVDconst [c]) y) && isU16Bit(c) => (InvertFlags (CMPWUconst y [int32(c)]))
 
 // Canonicalize the order of arguments to comparisons - helps with CSE.
-((CMP|CMPW|CMPU|CMPWU) x y) && x.ID > y.ID => (InvertFlags ((CMP|CMPW|CMPU|CMPWU) y x))
+((CMP|CMPW|CMPU|CMPWU) x y) && canonLessThan(x,y) => (InvertFlags ((CMP|CMPW|CMPU|CMPWU) y x))
 
 // ISEL auxInt values 0=LT 1=GT 2=EQ   arg2 ? arg0 : arg1
 // ISEL auxInt values 4=GE 5=LE 6=NE   arg2 ? arg1 : arg0
diff --git a/src/cmd/compile/internal/ssa/gen/S390X.rules b/src/cmd/compile/internal/ssa/gen/S390X.rules
index 384f2e807e..c3421da0a2 100644
--- a/src/cmd/compile/internal/ssa/gen/S390X.rules
+++ b/src/cmd/compile/internal/ssa/gen/S390X.rules
@@ -785,7 +785,7 @@
   => (RISBGZ x {s390x.NewRotateParams(r.Start, r.Start, -r.Start&63)})
 
 // Canonicalize the order of arguments to comparisons - helps with CSE.
-((CMP|CMPW|CMPU|CMPWU) x y) && x.ID > y.ID => (InvertFlags ((CMP|CMPW|CMPU|CMPWU) y x))
+((CMP|CMPW|CMPU|CMPWU) x y) && canonLessThan(x,y) => (InvertFlags ((CMP|CMPW|CMPU|CMPWU) y x))
 
 // Use sign/zero extend instead of RISBGZ.
 (RISBGZ x {r}) && r == s390x.NewRotateParams(56, 63, 0) => (MOVBZreg x)
diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go
index 9abfe0938b..e0a20668e2 100644
--- a/src/cmd/compile/internal/ssa/rewrite.go
+++ b/src/cmd/compile/internal/ssa/rewrite.go
@@ -521,6 +521,18 @@ func shiftIsBounded(v *Value) bool {
 	return v.AuxInt != 0
 }
 
+// canonLessThan returns whether x is "ordered" less than y, for purposes of normalizing
+// generated code as much as possible.
+func canonLessThan(x, y *Value) bool {
+	if x.Op != y.Op {
+		return x.Op < y.Op
+	}
+	if !x.Pos.SameFileAndLine(y.Pos) {
+		return x.Pos.Before(y.Pos)
+	}
+	return x.ID < y.ID
+}
+
 // truncate64Fto32F converts a float64 value to a float32 preserving the bit pattern
 // of the mantissa. It will panic if the truncation results in lost information.
 func truncate64Fto32F(f float64) float32 {
diff --git a/src/cmd/compile/internal/ssa/rewrite386.go b/src/cmd/compile/internal/ssa/rewrite386.go
index 2acdccd568..4e7fdb9e63 100644
--- a/src/cmd/compile/internal/ssa/rewrite386.go
+++ b/src/cmd/compile/internal/ssa/rewrite386.go
@@ -1785,12 +1785,12 @@ func rewriteValue386_Op386CMPB(v *Value) bool {
 		return true
 	}
 	// match: (CMPB x y)
-	// cond: x.ID > y.ID
+	// cond: canonLessThan(x,y)
 	// result: (InvertFlags (CMPB y x))
 	for {
 		x := v_0
 		y := v_1
-		if !(x.ID > y.ID) {
+		if !(canonLessThan(x, y)) {
 			break
 		}
 		v.reset(Op386InvertFlags)
@@ -2078,12 +2078,12 @@ func rewriteValue386_Op386CMPL(v *Value) bool {
 		return true
 	}
 	// match: (CMPL x y)
-	// cond: x.ID > y.ID
+	// cond: canonLessThan(x,y)
 	// result: (InvertFlags (CMPL y x))
 	for {
 		x := v_0
 		y := v_1
-		if !(x.ID > y.ID) {
+		if !(canonLessThan(x, y)) {
 			break
 		}
 		v.reset(Op386InvertFlags)
@@ -2386,12 +2386,12 @@ func rewriteValue386_Op386CMPW(v *Value) bool {
 		return true
 	}
 	// match: (CMPW x y)
-	// cond: x.ID > y.ID
+	// cond: canonLessThan(x,y)
 	// result: (InvertFlags (CMPW y x))
 	for {
 		x := v_0
 		y := v_1
-		if !(x.ID > y.ID) {
+		if !(canonLessThan(x, y)) {
 			break
 		}
 		v.reset(Op386InvertFlags)
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index 75d4ff7357..db2dc7a004 100644
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -6749,12 +6749,12 @@ func rewriteValueAMD64_OpAMD64CMPB(v *Value) bool {
 		return true
 	}
 	// match: (CMPB x y)
-	// cond: x.ID > y.ID
+	// cond: canonLessThan(x,y)
 	// result: (InvertFlags (CMPB y x))
 	for {
 		x := v_0
 		y := v_1
-		if !(x.ID > y.ID) {
+		if !(canonLessThan(x, y)) {
 			break
 		}
 		v.reset(OpAMD64InvertFlags)
@@ -7135,12 +7135,12 @@ func rewriteValueAMD64_OpAMD64CMPL(v *Value) bool {
 		return true
 	}
 	// match: (CMPL x y)
-	// cond: x.ID > y.ID
+	// cond: canonLessThan(x,y)
 	// result: (InvertFlags (CMPL y x))
 	for {
 		x := v_0
 		y := v_1
-		if !(x.ID > y.ID) {
+		if !(canonLessThan(x, y)) {
 			break
 		}
 		v.reset(OpAMD64InvertFlags)
@@ -7544,12 +7544,12 @@ func rewriteValueAMD64_OpAMD64CMPQ(v *Value) bool {
 		return true
 	}
 	// match: (CMPQ x y)
-	// cond: x.ID > y.ID
+	// cond: canonLessThan(x,y)
 	// result: (InvertFlags (CMPQ y x))
 	for {
 		x := v_0
 		y := v_1
-		if !(x.ID > y.ID) {
+		if !(canonLessThan(x, y)) {
 			break
 		}
 		v.reset(OpAMD64InvertFlags)
@@ -8106,12 +8106,12 @@ func rewriteValueAMD64_OpAMD64CMPW(v *Value) bool {
 		return true
 	}
 	// match: (CMPW x y)
-	// cond: x.ID > y.ID
+	// cond: canonLessThan(x,y)
 	// result: (InvertFlags (CMPW y x))
 	for {
 		x := v_0
 		y := v_1
-		if !(x.ID > y.ID) {
+		if !(canonLessThan(x, y)) {
 			break
 		}
 		v.reset(OpAMD64InvertFlags)
diff --git a/src/cmd/compile/internal/ssa/rewriteARM.go b/src/cmd/compile/internal/ssa/rewriteARM.go
index d9d439fa63..c958aae2c4 100644
--- a/src/cmd/compile/internal/ssa/rewriteARM.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM.go
@@ -3728,12 +3728,12 @@ func rewriteValueARM_OpARMCMP(v *Value) bool {
 		return true
 	}
 	// match: (CMP x y)
-	// cond: x.ID > y.ID
+	// cond: canonLessThan(x,y)
 	// result: (InvertFlags (CMP y x))
 	for {
 		x := v_0
 		y := v_1
-		if !(x.ID > y.ID) {
+		if !(canonLessThan(x, y)) {
 			break
 		}
 		v.reset(OpARMInvertFlags)
diff --git a/src/cmd/compile/internal/ssa/rewriteARM64.go b/src/cmd/compile/internal/ssa/rewriteARM64.go
index 5d5e526add..ff1156d901 100644
--- a/src/cmd/compile/internal/ssa/rewriteARM64.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM64.go
@@ -2772,12 +2772,12 @@ func rewriteValueARM64_OpARM64CMP(v *Value) bool {
 		return true
 	}
 	// match: (CMP x y)
-	// cond: x.ID > y.ID
+	// cond: canonLessThan(x,y)
 	// result: (InvertFlags (CMP y x))
 	for {
 		x := v_0
 		y := v_1
-		if !(x.ID > y.ID) {
+		if !(canonLessThan(x, y)) {
 			break
 		}
 		v.reset(OpARM64InvertFlags)
@@ -2941,12 +2941,12 @@ func rewriteValueARM64_OpARM64CMPW(v *Value) bool {
 		return true
 	}
 	// match: (CMPW x y)
-	// cond: x.ID > y.ID
+	// cond: canonLessThan(x,y)
 	// result: (InvertFlags (CMPW y x))
 	for {
 		x := v_0
 		y := v_1
-		if !(x.ID > y.ID) {
+		if !(canonLessThan(x, y)) {
 			break
 		}
 		v.reset(OpARM64InvertFlags)
diff --git a/src/cmd/compile/internal/ssa/rewritePPC64.go b/src/cmd/compile/internal/ssa/rewritePPC64.go
index 455f9b1388..98f748e5fa 100644
--- a/src/cmd/compile/internal/ssa/rewritePPC64.go
+++ b/src/cmd/compile/internal/ssa/rewritePPC64.go
@@ -4777,12 +4777,12 @@ func rewriteValuePPC64_OpPPC64CMP(v *Value) bool {
 		return true
 	}
 	// match: (CMP x y)
-	// cond: x.ID > y.ID
+	// cond: canonLessThan(x,y)
 	// result: (InvertFlags (CMP y x))
 	for {
 		x := v_0
 		y := v_1
-		if !(x.ID > y.ID) {
+		if !(canonLessThan(x, y)) {
 			break
 		}
 		v.reset(OpPPC64InvertFlags)
@@ -4834,12 +4834,12 @@ func rewriteValuePPC64_OpPPC64CMPU(v *Value) bool {
 		return true
 	}
 	// match: (CMPU x y)
-	// cond: x.ID > y.ID
+	// cond: canonLessThan(x,y)
 	// result: (InvertFlags (CMPU y x))
 	for {
 		x := v_0
 		y := v_1
-		if !(x.ID > y.ID) {
+		if !(canonLessThan(x, y)) {
 			break
 		}
 		v.reset(OpPPC64InvertFlags)
@@ -4964,12 +4964,12 @@ func rewriteValuePPC64_OpPPC64CMPW(v *Value) bool {
 		return true
 	}
 	// match: (CMPW x y)
-	// cond: x.ID > y.ID
+	// cond: canonLessThan(x,y)
 	// result: (InvertFlags (CMPW y x))
 	for {
 		x := v_0
 		y := v_1
-		if !(x.ID > y.ID) {
+		if !(canonLessThan(x, y)) {
 			break
 		}
 		v.reset(OpPPC64InvertFlags)
@@ -5045,12 +5045,12 @@ func rewriteValuePPC64_OpPPC64CMPWU(v *Value) bool {
 		return true
 	}
 	// match: (CMPWU x y)
-	// cond: x.ID > y.ID
+	// cond: canonLessThan(x,y)
 	// result: (InvertFlags (CMPWU y x))
 	for {
 		x := v_0
 		y := v_1
-		if !(x.ID > y.ID) {
+		if !(canonLessThan(x, y)) {
 			break
 		}
 		v.reset(OpPPC64InvertFlags)
diff --git a/src/cmd/compile/internal/ssa/rewriteS390X.go b/src/cmd/compile/internal/ssa/rewriteS390X.go
index a9722b820c..b52a1b6745 100644
--- a/src/cmd/compile/internal/ssa/rewriteS390X.go
+++ b/src/cmd/compile/internal/ssa/rewriteS390X.go
@@ -6332,12 +6332,12 @@ func rewriteValueS390X_OpS390XCMP(v *Value) bool {
 		return true
 	}
 	// match: (CMP x y)
-	// cond: x.ID > y.ID
+	// cond: canonLessThan(x,y)
 	// result: (InvertFlags (CMP y x))
 	for {
 		x := v_0
 		y := v_1
-		if !(x.ID > y.ID) {
+		if !(canonLessThan(x, y)) {
 			break
 		}
 		v.reset(OpS390XInvertFlags)
@@ -6389,12 +6389,12 @@ func rewriteValueS390X_OpS390XCMPU(v *Value) bool {
 		return true
 	}
 	// match: (CMPU x y)
-	// cond: x.ID > y.ID
+	// cond: canonLessThan(x,y)
 	// result: (InvertFlags (CMPU y x))
 	for {
 		x := v_0
 		y := v_1
-		if !(x.ID > y.ID) {
+		if !(canonLessThan(x, y)) {
 			break
 		}
 		v.reset(OpS390XInvertFlags)
@@ -6624,12 +6624,12 @@ func rewriteValueS390X_OpS390XCMPW(v *Value) bool {
 		return true
 	}
 	// match: (CMPW x y)
-	// cond: x.ID > y.ID
+	// cond: canonLessThan(x,y)
 	// result: (InvertFlags (CMPW y x))
 	for {
 		x := v_0
 		y := v_1
-		if !(x.ID > y.ID) {
+		if !(canonLessThan(x, y)) {
 			break
 		}
 		v.reset(OpS390XInvertFlags)
@@ -6721,12 +6721,12 @@ func rewriteValueS390X_OpS390XCMPWU(v *Value) bool {
 		return true
 	}
 	// match: (CMPWU x y)
-	// cond: x.ID > y.ID
+	// cond: canonLessThan(x,y)
 	// result: (InvertFlags (CMPWU y x))
 	for {
 		x := v_0
 		y := v_1
-		if !(x.ID > y.ID) {
+		if !(canonLessThan(x, y)) {
 			break
 		}
 		v.reset(OpS390XInvertFlags)
diff --git a/test/codegen/condmove.go b/test/codegen/condmove.go
index f86da3459a..7579dd1890 100644
--- a/test/codegen/condmove.go
+++ b/test/codegen/condmove.go
@@ -31,7 +31,7 @@ func cmovuintptr(x, y uintptr) uintptr {
 	if x < y {
 		x = -y
 	}
-	// amd64:"CMOVQCS"
+	// amd64:"CMOVQ(HI|CS)"
 	// arm64:"CSEL\t(LO|HI)"
 	// wasm:"Select"
 	return x
@@ -41,7 +41,7 @@ func cmov32bit(x, y uint32) uint32 {
 	if x < y {
 		x = -y
 	}
-	// amd64:"CMOVLCS"
+	// amd64:"CMOVL(HI|CS)"
 	// arm64:"CSEL\t(LO|HI)"
 	// wasm:"Select"
 	return x
@@ -51,7 +51,7 @@ func cmov16bit(x, y uint16) uint16 {
 	if x < y {
 		x = -y
 	}
-	// amd64:"CMOVWCS"
+	// amd64:"CMOVW(HI|CS)"
 	// arm64:"CSEL\t(LO|HI)"
 	// wasm:"Select"
 	return x
diff --git a/test/codegen/spectre.go b/test/codegen/spectre.go
index 3753498d09..d845da35ce 100644
--- a/test/codegen/spectre.go
+++ b/test/codegen/spectre.go
@@ -13,12 +13,12 @@ func IndexArray(x *[10]int, i int) int {
 }
 
 func IndexString(x string, i int) byte {
-	// amd64:`CMOVQCC`
+	// amd64:`CMOVQLS`
 	return x[i]
 }
 
 func IndexSlice(x []float64, i int) float64 {
-	// amd64:`CMOVQCC`
+	// amd64:`CMOVQLS`
 	return x[i]
 }
 
-- 
GitLab


From 2abd24f3b78f8f605840e5a0dd3b4f76734f6c13 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Mon, 4 Jan 2021 14:05:17 -0500
Subject: [PATCH 0474/2400] [dev.regabi] test: make run.go error messages
 slightly more informative

This is intended to make it easier to write/change a test
without referring to the source code to figure out what the
error messages actually mean, or how to correct them.

Change-Id: Ie79ff7cd9f2d1fa605257fe97eace68adc8a6716
Reviewed-on: https://go-review.googlesource.com/c/go/+/281452
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
---
 test/run.go | 44 ++++++++++++++++++++++----------------------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/test/run.go b/test/run.go
index db3e9f6c2f..1c516f4946 100644
--- a/test/run.go
+++ b/test/run.go
@@ -489,7 +489,7 @@ func (t *test) run() {
 	// Execution recipe stops at first blank line.
 	pos := strings.Index(t.src, "\n\n")
 	if pos == -1 {
-		t.err = errors.New("double newline not found")
+		t.err = fmt.Errorf("double newline ending execution recipe not found in %s", t.goFileName())
 		return
 	}
 	action := t.src[:pos]
@@ -860,9 +860,7 @@ func (t *test) run() {
 					t.err = err
 					return
 				}
-				if strings.Replace(string(out), "\r\n", "\n", -1) != t.expectedOutput() {
-					t.err = fmt.Errorf("incorrect output\n%s", out)
-				}
+				t.checkExpectedOutput(out)
 			}
 		}
 
@@ -902,9 +900,7 @@ func (t *test) run() {
 			t.err = err
 			return
 		}
-		if strings.Replace(string(out), "\r\n", "\n", -1) != t.expectedOutput() {
-			t.err = fmt.Errorf("incorrect output\n%s", out)
-		}
+		t.checkExpectedOutput(out)
 
 	case "build":
 		// Build Go file.
@@ -989,9 +985,7 @@ func (t *test) run() {
 				t.err = err
 				break
 			}
-			if strings.Replace(string(out), "\r\n", "\n", -1) != t.expectedOutput() {
-				t.err = fmt.Errorf("incorrect output\n%s", out)
-			}
+			t.checkExpectedOutput(out)
 		}
 
 	case "buildrun":
@@ -1017,9 +1011,7 @@ func (t *test) run() {
 			return
 		}
 
-		if strings.Replace(string(out), "\r\n", "\n", -1) != t.expectedOutput() {
-			t.err = fmt.Errorf("incorrect output\n%s", out)
-		}
+		t.checkExpectedOutput(out)
 
 	case "run":
 		// Run Go file if no special go command flags are provided;
@@ -1062,9 +1054,7 @@ func (t *test) run() {
 			t.err = err
 			return
 		}
-		if strings.Replace(string(out), "\r\n", "\n", -1) != t.expectedOutput() {
-			t.err = fmt.Errorf("incorrect output\n%s", out)
-		}
+		t.checkExpectedOutput(out)
 
 	case "runoutput":
 		// Run Go file and write its output into temporary Go file.
@@ -1099,9 +1089,7 @@ func (t *test) run() {
 			t.err = err
 			return
 		}
-		if string(out) != t.expectedOutput() {
-			t.err = fmt.Errorf("incorrect output\n%s", out)
-		}
+		t.checkExpectedOutput(out)
 
 	case "errorcheckoutput":
 		// Run Go file and write its output into temporary Go file.
@@ -1175,12 +1163,24 @@ func (t *test) makeTempDir() {
 	}
 }
 
-func (t *test) expectedOutput() string {
+// checkExpectedOutput compares the output from compiling and/or running with the contents
+// of the corresponding reference output file, if any (replace ".go" with ".out").
+// If they don't match, fail with an informative message.
+func (t *test) checkExpectedOutput(gotBytes []byte) {
+	got := string(gotBytes)
 	filename := filepath.Join(t.dir, t.gofile)
 	filename = filename[:len(filename)-len(".go")]
 	filename += ".out"
-	b, _ := ioutil.ReadFile(filename)
-	return string(b)
+	b, err := ioutil.ReadFile(filename)
+	// File is allowed to be missing (err != nil) in which case output should be empty.
+	got = strings.Replace(got, "\r\n", "\n", -1)
+	if got != string(b) {
+		if err == nil {
+			t.err = fmt.Errorf("output does not match expected in %s. Instead saw\n%s", filename, got)
+		} else {
+			t.err = fmt.Errorf("output should be empty when (optional) expected-output file %s is not present. Instead saw\n%s", filename, got)
+		}
+	}
 }
 
 func splitOutput(out string, wantAuto bool) []string {
-- 
GitLab


From c1370e918fd88a13f77a133f8e431197cd3a1fc6 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Mon, 28 Sep 2020 17:42:30 -0400
Subject: [PATCH 0475/2400] [dev.regabi] cmd/compile: add code to support
 register ABI spills around morestack calls

This is a selected copy from the register ABI experiment CL, focused
on the files and data structures that handle spilling around morestack.
Unnecessary code from the experiment was removed, other code was adapted.

Would it make sense to leave comments in the experiment as pieces are
brought over?

Experiment CL (for comparison purposes)
https://go-review.googlesource.com/c/go/+/28832

Change-Id: I92136f070351d4fcca1407b52ecf9b80898fed95
Reviewed-on: https://go-review.googlesource.com/c/go/+/279520
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
---
 src/cmd/compile/internal/ssa/func.go     |  3 ++
 src/cmd/compile/internal/ssa/location.go | 26 ++++++++++++++
 src/cmd/internal/obj/link.go             | 44 ++++++++++++++++++++++--
 src/cmd/internal/obj/x86/obj6.go         | 10 +++---
 4 files changed, 76 insertions(+), 7 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go
index e6c4798a78..f753b4407b 100644
--- a/src/cmd/compile/internal/ssa/func.go
+++ b/src/cmd/compile/internal/ssa/func.go
@@ -58,6 +58,9 @@ type Func struct {
 	// of keys to make iteration order deterministic.
 	Names []LocalSlot
 
+	// RegArgs is a slice of register-memory pairs that must be spilled and unspilled in the uncommon path of function entry.
+	RegArgs []ArgPair
+
 	// WBLoads is a list of Blocks that branch on the write
 	// barrier flag. Safe-points are disabled from the OpLoad that
 	// reads the write-barrier flag until the control flow rejoins
diff --git a/src/cmd/compile/internal/ssa/location.go b/src/cmd/compile/internal/ssa/location.go
index 69f90d9ab4..4cd0ac8d77 100644
--- a/src/cmd/compile/internal/ssa/location.go
+++ b/src/cmd/compile/internal/ssa/location.go
@@ -87,3 +87,29 @@ func (t LocPair) String() string {
 	}
 	return fmt.Sprintf("<%s,%s>", n0, n1)
 }
+
+type ArgPair struct {
+	reg *Register
+	mem LocalSlot
+}
+
+func (ap *ArgPair) Reg() int16 {
+	return ap.reg.objNum
+}
+
+func (ap *ArgPair) Type() *types.Type {
+	return ap.mem.Type
+}
+
+func (ap *ArgPair) Mem() *LocalSlot {
+	return &ap.mem
+}
+
+func (t ArgPair) String() string {
+	n0 := "nil"
+	if t.reg != nil {
+		n0 = t.reg.String()
+	}
+	n1 := t.mem.String()
+	return fmt.Sprintf("<%s,%s>", n0, n1)
+}
diff --git a/src/cmd/internal/obj/link.go b/src/cmd/internal/obj/link.go
index 977c5c3303..7ba8c6d317 100644
--- a/src/cmd/internal/obj/link.go
+++ b/src/cmd/internal/obj/link.go
@@ -766,6 +766,17 @@ type Auto struct {
 	Gotype  *LSym
 }
 
+// RegArg provides spill/fill information for a register-resident argument
+// to a function.  These need spilling/filling in the safepoint/stackgrowth case.
+// At the time of fill/spill, the offset must be adjusted by the architecture-dependent
+// adjustment to hardware SP that occurs in a call instruction.  E.g., for AMD64,
+// at Offset+8 because the return address was pushed.
+type RegArg struct {
+	Addr           Addr
+	Reg            int16
+	Spill, Unspill As
+}
+
 // Link holds the context for writing object code from a compiler
 // to be linker input or for reading that input into the linker.
 type Link struct {
@@ -796,10 +807,11 @@ type Link struct {
 	DebugInfo          func(fn *LSym, info *LSym, curfn interface{}) ([]dwarf.Scope, dwarf.InlCalls) // if non-nil, curfn is a *gc.Node
 	GenAbstractFunc    func(fn *LSym)
 	Errors             int
+	RegArgs            []RegArg
 
-	InParallel    bool // parallel backend phase in effect
-	UseBASEntries bool // use Base Address Selection Entries in location lists and PC ranges
-	IsAsm         bool // is the source assembly language, which may contain surprising idioms (e.g., call tables)
+	InParallel      bool // parallel backend phase in effect
+	UseBASEntries   bool // use Base Address Selection Entries in location lists and PC ranges
+	IsAsm           bool // is the source assembly language, which may contain surprising idioms (e.g., call tables)
 
 	// state for writing objects
 	Text []*LSym
@@ -844,6 +856,32 @@ func (ctxt *Link) Logf(format string, args ...interface{}) {
 	ctxt.Bso.Flush()
 }
 
+func (ctxt *Link) SpillRegisterArgs(last *Prog, pa ProgAlloc) *Prog {
+	// Spill register args.
+	for _, ra := range ctxt.RegArgs {
+		spill := Appendp(last, pa)
+		spill.As = ra.Spill
+		spill.From.Type = TYPE_REG
+		spill.From.Reg = ra.Reg
+		spill.To = ra.Addr
+		last = spill
+	}
+	return last
+}
+
+func (ctxt *Link) UnspillRegisterArgs(last *Prog, pa ProgAlloc) *Prog {
+	// Unspill any spilled register args
+	for _, ra := range ctxt.RegArgs {
+		unspill := Appendp(last, pa)
+		unspill.As = ra.Unspill
+		unspill.From = ra.Addr
+		unspill.To.Type = TYPE_REG
+		unspill.To.Reg = ra.Reg
+		last = unspill
+	}
+	return last
+}
+
 // The smallest possible offset from the hardware stack pointer to a local
 // variable on the stack. Architectures that use a link register save its value
 // on the stack in the function prologue and so always have a pointer between
diff --git a/src/cmd/internal/obj/x86/obj6.go b/src/cmd/internal/obj/x86/obj6.go
index 839aeb8fe3..1674db626f 100644
--- a/src/cmd/internal/obj/x86/obj6.go
+++ b/src/cmd/internal/obj/x86/obj6.go
@@ -1114,7 +1114,8 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
 	spfix.Spadj = -framesize
 
 	pcdata := ctxt.EmitEntryStackMap(cursym, spfix, newprog)
-	pcdata = ctxt.StartUnsafePoint(pcdata, newprog)
+	spill := ctxt.StartUnsafePoint(pcdata, newprog)
+	pcdata = ctxt.SpillRegisterArgs(spill, newprog)
 
 	call := obj.Appendp(pcdata, newprog)
 	call.Pos = cursym.Func().Text.Pos
@@ -1139,7 +1140,8 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
 		progedit(ctxt, callend.Link, newprog)
 	}
 
-	pcdata = ctxt.EndUnsafePoint(callend, newprog, -1)
+	pcdata = ctxt.UnspillRegisterArgs(callend, newprog)
+	pcdata = ctxt.EndUnsafePoint(pcdata, newprog, -1)
 
 	jmp := obj.Appendp(pcdata, newprog)
 	jmp.As = obj.AJMP
@@ -1147,9 +1149,9 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
 	jmp.To.SetTarget(cursym.Func().Text.Link)
 	jmp.Spadj = +framesize
 
-	jls.To.SetTarget(call)
+	jls.To.SetTarget(spill)
 	if q1 != nil {
-		q1.To.SetTarget(call)
+		q1.To.SetTarget(spill)
 	}
 
 	return end
-- 
GitLab


From 861707a8c84f0b1ddbcaea0e9f439398ee2175fb Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Mon, 4 Jan 2021 13:32:10 -0500
Subject: [PATCH 0476/2400] [dev.regabi] cmd/compile: added limited
 //go:registerparams pragma for new ABI dev

This only works for functions; if you try it with a method, it will
fail.  It does work for both local package and imports.  For now,
it tells you when it thinks it sees either a declaration or a call of
such a function (this will normally be silent since no existing
code uses this pragma).

Note: it appears to be really darn hard to figure out if this
pragma was set for a method, and the method's call site.  Better
ir.Node wranglers than I might be able to make headway, but it
seemed unnecessary for this experiment.

Change-Id: I601c2ddd124457bf6d62f714d7ac871705743c0a
Reviewed-on: https://go-review.googlesource.com/c/go/+/279521
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
---
 src/cmd/compile/internal/ir/node.go           |  3 ++
 src/cmd/compile/internal/noder/lex.go         |  3 ++
 src/cmd/compile/internal/ssagen/ssa.go        | 15 ++++++++
 src/cmd/compile/internal/typecheck/iexport.go |  3 ++
 src/cmd/compile/internal/typecheck/iimport.go |  3 ++
 test/abi/regabipragma.dir/main.go             | 36 +++++++++++++++++++
 test/abi/regabipragma.dir/tmp/foo.go          | 19 ++++++++++
 test/abi/regabipragma.go                      |  9 +++++
 test/abi/regabipragma.out                     |  6 ++++
 test/run.go                                   |  2 +-
 10 files changed, 98 insertions(+), 1 deletion(-)
 create mode 100644 test/abi/regabipragma.dir/main.go
 create mode 100644 test/abi/regabipragma.dir/tmp/foo.go
 create mode 100644 test/abi/regabipragma.go
 create mode 100644 test/abi/regabipragma.out

diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index a2b6e7203b..a1b09b38cc 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -452,6 +452,9 @@ const (
 
 	// Go command pragmas
 	GoBuildPragma
+
+	RegisterParams // TODO remove after register abi is working
+
 )
 
 func AsNode(n types.Object) Node {
diff --git a/src/cmd/compile/internal/noder/lex.go b/src/cmd/compile/internal/noder/lex.go
index 1095f3344a..cdca9e55f3 100644
--- a/src/cmd/compile/internal/noder/lex.go
+++ b/src/cmd/compile/internal/noder/lex.go
@@ -28,6 +28,7 @@ const (
 		ir.Nosplit |
 		ir.Noinline |
 		ir.NoCheckPtr |
+		ir.RegisterParams | // TODO remove after register abi is working
 		ir.CgoUnsafeArgs |
 		ir.UintptrEscapes |
 		ir.Systemstack |
@@ -79,6 +80,8 @@ func pragmaFlag(verb string) ir.PragmaFlag {
 		// in the argument list.
 		// Used in syscall/dll_windows.go.
 		return ir.UintptrEscapes
+	case "go:registerparams": // TODO remove after register abi is working
+		return ir.RegisterParams
 	case "go:notinheap":
 		return ir.NotInHeap
 	}
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 54bde20f1c..3b542cf92a 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -356,6 +356,13 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 	if fn.Pragma&ir.Nosplit != 0 {
 		s.f.NoSplit = true
 	}
+	if fn.Pragma&ir.RegisterParams != 0 { // TODO remove after register abi is working
+		if strings.Contains(name, ".") {
+			base.ErrorfAt(fn.Pos(), "Calls to //go:registerparams method %s won't work, remove the pragma from the declaration.", name)
+		}
+		s.f.Warnl(fn.Pos(), "Declared function %s has register params", name)
+	}
+
 	s.panics = map[funcLine]*ssa.Block{}
 	s.softFloat = s.config.SoftFloat
 
@@ -4685,6 +4692,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 	}
 
 	testLateExpansion := false
+	inRegisters := false
 
 	switch n.Op() {
 	case ir.OCALLFUNC:
@@ -4692,6 +4700,13 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		if k == callNormal && fn.Op() == ir.ONAME && fn.(*ir.Name).Class == ir.PFUNC {
 			fn := fn.(*ir.Name)
 			sym = fn.Sym()
+			// TODO remove after register abi is working
+			inRegistersImported := fn.Pragma()&ir.RegisterParams != 0
+			inRegistersSamePackage := fn.Func != nil && fn.Func.Pragma&ir.RegisterParams != 0
+			inRegisters = inRegistersImported || inRegistersSamePackage
+			if inRegisters {
+				s.f.Warnl(n.Pos(), "Called function %s has register params", sym.Linksym().Name)
+			}
 			break
 		}
 		closure = s.expr(fn)
diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index 4d48b80346..1ba8771139 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -976,6 +976,9 @@ func (w *exportWriter) funcExt(n *ir.Name) {
 	w.linkname(n.Sym())
 	w.symIdx(n.Sym())
 
+	// TODO remove after register abi is working.
+	w.uint64(uint64(n.Func.Pragma))
+
 	// Escape analysis.
 	for _, fs := range &types.RecvsParams {
 		for _, f := range fs(n.Type()).FieldSlice() {
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index c9effabce0..396d09263a 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -647,6 +647,9 @@ func (r *importReader) funcExt(n *ir.Name) {
 	r.linkname(n.Sym())
 	r.symIdx(n.Sym())
 
+	// TODO remove after register abi is working
+	n.SetPragma(ir.PragmaFlag(r.uint64()))
+
 	// Escape analysis.
 	for _, fs := range &types.RecvsParams {
 		for _, f := range fs(n.Type()).FieldSlice() {
diff --git a/test/abi/regabipragma.dir/main.go b/test/abi/regabipragma.dir/main.go
new file mode 100644
index 0000000000..d663337a10
--- /dev/null
+++ b/test/abi/regabipragma.dir/main.go
@@ -0,0 +1,36 @@
+// Copyright 2021 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 (
+	"fmt"
+	"regabipragma.dir/tmp"
+)
+
+type S string
+
+//go:noinline
+func (s S) ff(t string) string {
+	return string(s) + " " + t
+}
+
+//go:noinline
+//go:registerparams
+func f(s,t string) string { // ERROR "Declared function f has register params"
+	return s + " " + t
+}
+
+func check(s string) {
+	if s != "Hello world!" {
+		fmt.Printf("FAIL, wanted 'Hello world!' but got '%s'\n", s)
+	}
+}
+
+func main() {
+	check(f("Hello", "world!"))   // ERROR "Called function ...f has register params"
+	check(tmp.F("Hello", "world!"))  // ERROR "Called function regabipragma.dir/tmp.F has register params"
+	check(S("Hello").ff("world!"))
+	check(tmp.S("Hello").FF("world!"))
+}
diff --git a/test/abi/regabipragma.dir/tmp/foo.go b/test/abi/regabipragma.dir/tmp/foo.go
new file mode 100644
index 0000000000..cff989bbcd
--- /dev/null
+++ b/test/abi/regabipragma.dir/tmp/foo.go
@@ -0,0 +1,19 @@
+// Copyright 2021 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 tmp
+
+
+type S string
+
+//go:noinline
+func (s S) FF(t string) string {
+        return string(s) + " " + t
+}
+
+//go:noinline
+//go:registerparams
+func F(s,t string) string {
+        return s + " " + t
+}
diff --git a/test/abi/regabipragma.go b/test/abi/regabipragma.go
new file mode 100644
index 0000000000..93cdb6abbb
--- /dev/null
+++ b/test/abi/regabipragma.go
@@ -0,0 +1,9 @@
+// runindir
+
+// Copyright 2021 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.
+
+// TODO May delete or adapt this test once regabi is the default
+
+package ignore
diff --git a/test/abi/regabipragma.out b/test/abi/regabipragma.out
new file mode 100644
index 0000000000..7803613351
--- /dev/null
+++ b/test/abi/regabipragma.out
@@ -0,0 +1,6 @@
+# regabipragma.dir/tmp
+tmp/foo.go:17:6: Declared function F has register params
+# regabipragma.dir
+./main.go:21:6: Declared function f has register params
+./main.go:32:9: Called function "".f has register params
+./main.go:33:13: Called function regabipragma.dir/tmp.F has register params
diff --git a/test/run.go b/test/run.go
index 1c516f4946..09f9717cc0 100644
--- a/test/run.go
+++ b/test/run.go
@@ -59,7 +59,7 @@ var (
 
 	// dirs are the directories to look for *.go files in.
 	// TODO(bradfitz): just use all directories?
-	dirs = []string{".", "ken", "chan", "interface", "syntax", "dwarf", "fixedbugs", "codegen", "runtime"}
+	dirs = []string{".", "ken", "chan", "interface", "syntax", "dwarf", "fixedbugs", "codegen", "runtime", "abi"}
 
 	// ratec controls the max number of tests running at a time.
 	ratec chan bool
-- 
GitLab


From c41b999ad410c74bea222ee76488226a06ba4046 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Fri, 8 Jan 2021 10:15:36 -0500
Subject: [PATCH 0477/2400] [dev.regabi] cmd/compile: refactor abiutils from
 "gc" into new "abi"

Needs to be visible to ssagen, and might as well start clean to avoid
creating a lot of accidental dependencies.

Added some methods for export.

Decided to use a pointer instead of value for ABIConfig uses.

Tests ended up separate from abiutil itself; otherwise there are import cycles.

Change-Id: I5570e1e6a463e303c5e2dc84e8dd4125e7c1adcc
Reviewed-on: https://go-review.googlesource.com/c/go/+/282614
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
---
 .../compile/internal/{gc => abi}/abiutils.go  | 42 +++++++++++++++++--
 .../internal/{gc => test}/abiutils_test.go    | 10 ++---
 .../internal/{gc => test}/abiutilsaux_test.go | 17 ++++----
 3 files changed, 50 insertions(+), 19 deletions(-)
 rename src/cmd/compile/internal/{gc => abi}/abiutils.go (91%)
 rename src/cmd/compile/internal/{gc => test}/abiutils_test.go (98%)
 rename src/cmd/compile/internal/{gc => test}/abiutilsaux_test.go (87%)

diff --git a/src/cmd/compile/internal/gc/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
similarity index 91%
rename from src/cmd/compile/internal/gc/abiutils.go
rename to src/cmd/compile/internal/abi/abiutils.go
index 5822c088f9..3ac59e6f75 100644
--- a/src/cmd/compile/internal/gc/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package abi
 
 import (
 	"cmd/compile/internal/types"
@@ -28,7 +28,35 @@ type ABIParamResultInfo struct {
 	intSpillSlots     int
 	floatSpillSlots   int
 	offsetToSpillArea int64
-	config            ABIConfig // to enable String() method
+	config            *ABIConfig // to enable String() method
+}
+
+func (a *ABIParamResultInfo) InParams() []ABIParamAssignment {
+	return a.inparams
+}
+
+func (a *ABIParamResultInfo) OutParams() []ABIParamAssignment {
+	return a.outparams
+}
+
+func (a *ABIParamResultInfo) InParam(i int) ABIParamAssignment {
+	return a.inparams[i]
+}
+
+func (a *ABIParamResultInfo) OutParam(i int) ABIParamAssignment {
+	return a.outparams[i]
+}
+
+func (a *ABIParamResultInfo) IntSpillCount() int {
+	return a.intSpillSlots
+}
+
+func (a *ABIParamResultInfo) FloatSpillCount() int {
+	return a.floatSpillSlots
+}
+
+func (a *ABIParamResultInfo) SpillAreaOffset() int64 {
+	return a.offsetToSpillArea
 }
 
 // RegIndex stores the index into the set of machine registers used by
@@ -66,11 +94,17 @@ type ABIConfig struct {
 	regAmounts RegAmounts
 }
 
+// NewABIConfig returns a new ABI configuration for an architecture with
+// iRegsCount integer/pointer registers and fRegsCount floating point registers.
+func NewABIConfig(iRegsCount, fRegsCount int) *ABIConfig {
+	return &ABIConfig{RegAmounts{iRegsCount, fRegsCount}}
+}
+
 // ABIAnalyze takes a function type 't' and an ABI rules description
 // 'config' and analyzes the function to determine how its parameters
 // and results will be passed (in registers or on the stack), returning
 // an ABIParamResultInfo object that holds the results of the analysis.
-func ABIAnalyze(t *types.Type, config ABIConfig) ABIParamResultInfo {
+func ABIAnalyze(t *types.Type, config *ABIConfig) ABIParamResultInfo {
 	setup()
 	s := assignState{
 		rTotal: config.regAmounts,
@@ -124,7 +158,7 @@ func (c *RegAmounts) regString(r RegIndex) string {
 
 // toString method renders an ABIParamAssignment in human-readable
 // form, suitable for debugging or unit testing.
-func (ri *ABIParamAssignment) toString(config ABIConfig) string {
+func (ri *ABIParamAssignment) toString(config *ABIConfig) string {
 	regs := "R{"
 	for _, r := range ri.Registers {
 		regs += " " + config.regAmounts.regString(r)
diff --git a/src/cmd/compile/internal/gc/abiutils_test.go b/src/cmd/compile/internal/test/abiutils_test.go
similarity index 98%
rename from src/cmd/compile/internal/gc/abiutils_test.go
rename to src/cmd/compile/internal/test/abiutils_test.go
index 6fd0af1b1f..ae7d484062 100644
--- a/src/cmd/compile/internal/gc/abiutils_test.go
+++ b/src/cmd/compile/internal/test/abiutils_test.go
@@ -2,10 +2,11 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
 
 import (
 	"bufio"
+	"cmd/compile/internal/abi"
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/typecheck"
@@ -20,12 +21,7 @@ import (
 // AMD64 registers available:
 // - integer: RAX, RBX, RCX, RDI, RSI, R8, R9, r10, R11
 // - floating point: X0 - X14
-var configAMD64 = ABIConfig{
-	regAmounts: RegAmounts{
-		intRegs:   9,
-		floatRegs: 15,
-	},
-}
+var configAMD64 = abi.NewABIConfig(9,15)
 
 func TestMain(m *testing.M) {
 	ssagen.Arch.LinkArch = &x86.Linkamd64
diff --git a/src/cmd/compile/internal/gc/abiutilsaux_test.go b/src/cmd/compile/internal/test/abiutilsaux_test.go
similarity index 87%
rename from src/cmd/compile/internal/gc/abiutilsaux_test.go
rename to src/cmd/compile/internal/test/abiutilsaux_test.go
index 9386b554b0..7b84e73947 100644
--- a/src/cmd/compile/internal/gc/abiutilsaux_test.go
+++ b/src/cmd/compile/internal/test/abiutilsaux_test.go
@@ -2,12 +2,13 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package gc
+package test
 
 // This file contains utility routines and harness infrastructure used
 // by the ABI tests in "abiutils_test.go".
 
 import (
+	"cmd/compile/internal/abi"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
@@ -75,7 +76,7 @@ func tokenize(src string) []string {
 	return res
 }
 
-func verifyParamResultOffset(t *testing.T, f *types.Field, r ABIParamAssignment, which string, idx int) int {
+func verifyParamResultOffset(t *testing.T, f *types.Field, r abi.ABIParamAssignment, which string, idx int) int {
 	n := ir.AsNode(f.Nname).(*ir.Name)
 	if n.FrameOffset() != int64(r.Offset) {
 		t.Errorf("%s %d: got offset %d wanted %d t=%v",
@@ -110,7 +111,7 @@ func abitest(t *testing.T, ft *types.Type, exp expectedDump) {
 	types.CalcSize(ft)
 
 	// Analyze with full set of registers.
-	regRes := ABIAnalyze(ft, configAMD64)
+	regRes := abi.ABIAnalyze(ft, configAMD64)
 	regResString := strings.TrimSpace(regRes.String())
 
 	// Check results.
@@ -121,8 +122,8 @@ func abitest(t *testing.T, ft *types.Type, exp expectedDump) {
 	}
 
 	// Analyze again with empty register set.
-	empty := ABIConfig{}
-	emptyRes := ABIAnalyze(ft, empty)
+	empty := &abi.ABIConfig{}
+	emptyRes := abi.ABIAnalyze(ft, empty)
 	emptyResString := emptyRes.String()
 
 	// Walk the results and make sure the offsets assigned match
@@ -135,18 +136,18 @@ func abitest(t *testing.T, ft *types.Type, exp expectedDump) {
 	rfsl := ft.Recvs().Fields().Slice()
 	poff := 0
 	if len(rfsl) != 0 {
-		failed |= verifyParamResultOffset(t, rfsl[0], emptyRes.inparams[0], "receiver", 0)
+		failed |= verifyParamResultOffset(t, rfsl[0], emptyRes.InParams()[0], "receiver", 0)
 		poff = 1
 	}
 	// params
 	pfsl := ft.Params().Fields().Slice()
 	for k, f := range pfsl {
-		verifyParamResultOffset(t, f, emptyRes.inparams[k+poff], "param", k)
+		verifyParamResultOffset(t, f, emptyRes.InParams()[k+poff], "param", k)
 	}
 	// results
 	ofsl := ft.Results().Fields().Slice()
 	for k, f := range ofsl {
-		failed |= verifyParamResultOffset(t, f, emptyRes.outparams[k], "result", k)
+		failed |= verifyParamResultOffset(t, f, emptyRes.OutParams()[k], "result", k)
 	}
 
 	if failed != 0 {
-- 
GitLab


From d6d467372854124795cdd11429244ef1e28b809c Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 12 Jan 2021 23:55:08 -0800
Subject: [PATCH 0478/2400] [dev.regabi] cmd/compile: fix GOEXPERIMENT=regabi
 builder

I misread the FIXME comment in InitLSym the first time. It's referring
to how InitLSym is supposed to be called exactly once per
function (see function documentation), but this is evidently not
actually the case currently in GOEXPERIMENT=regabi mode.

So just move the NeedFuncSym call below the GOEXPERIMENT=regabi
workaround.

Also, to fix the linux-arm64-{aws,packet} builders, move the call to
reflectdata.WriteFuncSyms() to after the second batch of functions are
compiled. This is necessary to make sure we catch all the funcsyms
that can be added by late function compilation.

Change-Id: I6d6396d48e2ee29c1fb007fa2b99e065b36375db
Reviewed-on: https://go-review.googlesource.com/c/go/+/283552
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Trust: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/gc/obj.go     | 2 +-
 src/cmd/compile/internal/ssagen/abi.go | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 753db80f76..3e55b7688e 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -111,7 +111,6 @@ func dumpdata() {
 	numDecls := len(typecheck.Target.Decls)
 
 	dumpglobls(typecheck.Target.Externs)
-	staticdata.WriteFuncSyms()
 	reflectdata.CollectPTabs()
 	numExports := len(typecheck.Target.Exports)
 	addsignats(typecheck.Target.Externs)
@@ -151,6 +150,7 @@ func dumpdata() {
 		objw.Global(zero, int32(reflectdata.ZeroSize), obj.DUPOK|obj.RODATA)
 	}
 
+	staticdata.WriteFuncSyms()
 	addGCLocals()
 
 	if numExports != len(typecheck.Target.Exports) {
diff --git a/src/cmd/compile/internal/ssagen/abi.go b/src/cmd/compile/internal/ssagen/abi.go
index dc27ec3a29..f1226f6a47 100644
--- a/src/cmd/compile/internal/ssagen/abi.go
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -138,13 +138,12 @@ func ReadSymABIs(file, myimportpath string) {
 // For body-less functions, we only create the LSym; for functions
 // with bodies call a helper to setup up / populate the LSym.
 func InitLSym(f *ir.Func, hasBody bool) {
-	staticdata.NeedFuncSym(f.Sym())
-
 	// FIXME: for new-style ABI wrappers, we set up the lsym at the
 	// point the wrapper is created.
 	if f.LSym != nil && base.Flag.ABIWrap {
 		return
 	}
+	staticdata.NeedFuncSym(f.Sym())
 	selectLSym(f, hasBody)
 	if hasBody {
 		setupTextLSym(f, 0)
-- 
GitLab


From 983ac4b08663ea9655abe99ca30faf47e54fdc16 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 13 Jan 2021 15:02:16 -0800
Subject: [PATCH 0479/2400] [dev.regabi] cmd/compile: fix ICE when initializing
 blank vars

CL 278914 introduced NameOffsetExpr to avoid copying ONAME nodes and
hacking up their offsets, but evidently staticinit subtly depended on
the prior behavior to allow dynamic initialization of blank variables.

This CL refactors the code somewhat to avoid using NameOffsetExpr with
blank variables, and to instead create dynamic assignments directly to
the global blank node. It also adds a check to NewNameOffsetExpr to
guard against misuse like this, since I suspect there could be other
cases still lurking within staticinit. (This code is overdue for an
makeover anyway.)

Thanks to thanm@ for bisect and test case minimization.

Fixes #43677.

Change-Id: Ic71cb5d6698382feb9548dc3bb9fd606b207a172
Reviewed-on: https://go-review.googlesource.com/c/go/+/283537
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/ir/expr.go          |  3 ++
 src/cmd/compile/internal/staticinit/sched.go | 33 +++++++++++---------
 test/fixedbugs/issue43677.go                 | 18 +++++++++++
 3 files changed, 40 insertions(+), 14 deletions(-)
 create mode 100644 test/fixedbugs/issue43677.go

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 51425db42d..0639c3b620 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -473,6 +473,9 @@ type NameOffsetExpr struct {
 }
 
 func NewNameOffsetExpr(pos src.XPos, name *Name, offset int64, typ *types.Type) *NameOffsetExpr {
+	if name == nil || IsBlank(name) {
+		base.FatalfAt(pos, "cannot take offset of nil or blank name: %v", name)
+	}
 	n := &NameOffsetExpr{Name_: name, Offset_: offset}
 	n.typ = typ
 	n.op = ONAMEOFFSET
diff --git a/src/cmd/compile/internal/staticinit/sched.go b/src/cmd/compile/internal/staticinit/sched.go
index ac0b6cd87e..64946ad247 100644
--- a/src/cmd/compile/internal/staticinit/sched.go
+++ b/src/cmd/compile/internal/staticinit/sched.go
@@ -15,6 +15,7 @@ import (
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
+	"cmd/internal/src"
 )
 
 type Entry struct {
@@ -199,6 +200,20 @@ func (s *Schedule) StaticAssign(l *ir.Name, loff int64, r ir.Node, typ *types.Ty
 		r = r.(*ir.ConvExpr).X
 	}
 
+	assign := func(pos src.XPos, a *ir.Name, aoff int64, v ir.Node) {
+		if s.StaticAssign(a, aoff, v, v.Type()) {
+			return
+		}
+		var lhs ir.Node
+		if ir.IsBlank(a) {
+			// Don't use NameOffsetExpr with blank (#43677).
+			lhs = ir.BlankNode
+		} else {
+			lhs = ir.NewNameOffsetExpr(pos, a, aoff, v.Type())
+		}
+		s.append(ir.NewAssignStmt(pos, lhs, v))
+	}
+
 	switch r.Op() {
 	case ir.ONAME:
 		r := r.(*ir.Name)
@@ -237,9 +252,7 @@ func (s *Schedule) StaticAssign(l *ir.Name, loff int64, r ir.Node, typ *types.Ty
 			staticdata.InitAddr(l, loff, a, 0)
 
 			// Init underlying literal.
-			if !s.StaticAssign(a, 0, r.X, a.Type()) {
-				s.append(ir.NewAssignStmt(base.Pos, a, r.X))
-			}
+			assign(base.Pos, a, 0, r.X)
 			return true
 		}
 		//dump("not static ptrlit", r);
@@ -278,10 +291,7 @@ func (s *Schedule) StaticAssign(l *ir.Name, loff int64, r ir.Node, typ *types.Ty
 				continue
 			}
 			ir.SetPos(e.Expr)
-			if !s.StaticAssign(l, loff+e.Xoffset, e.Expr, e.Expr.Type()) {
-				a := ir.NewNameOffsetExpr(base.Pos, l, loff+e.Xoffset, e.Expr.Type())
-				s.append(ir.NewAssignStmt(base.Pos, a, e.Expr))
-			}
+			assign(base.Pos, l, loff+e.Xoffset, e.Expr)
 		}
 
 		return true
@@ -345,17 +355,12 @@ func (s *Schedule) StaticAssign(l *ir.Name, loff int64, r ir.Node, typ *types.Ty
 			}
 			// Copy val directly into n.
 			ir.SetPos(val)
-			if !s.StaticAssign(l, loff+int64(types.PtrSize), val, val.Type()) {
-				a := ir.NewNameOffsetExpr(base.Pos, l, loff+int64(types.PtrSize), val.Type())
-				s.append(ir.NewAssignStmt(base.Pos, a, val))
-			}
+			assign(base.Pos, l, loff+int64(types.PtrSize), val)
 		} else {
 			// Construct temp to hold val, write pointer to temp into n.
 			a := StaticName(val.Type())
 			s.Temps[val] = a
-			if !s.StaticAssign(a, 0, val, val.Type()) {
-				s.append(ir.NewAssignStmt(base.Pos, a, val))
-			}
+			assign(base.Pos, a, 0, val)
 			staticdata.InitAddr(l, loff+int64(types.PtrSize), a, 0)
 		}
 
diff --git a/test/fixedbugs/issue43677.go b/test/fixedbugs/issue43677.go
new file mode 100644
index 0000000000..1a68c8b8b9
--- /dev/null
+++ b/test/fixedbugs/issue43677.go
@@ -0,0 +1,18 @@
+// compile
+
+// Copyright 2021 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.
+
+// Issue #43677: ICE during compilation of dynamic initializers for
+// composite blank variables.
+
+package p
+
+func f() *int
+
+var _ = [2]*int{nil, f()}
+
+var _ = struct{ x, y *int }{nil, f()}
+
+var _ interface{} = f()
-- 
GitLab


From ef5285fbd0636965d916c81dbf87834731f337b2 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 9 Jan 2021 00:57:55 -0800
Subject: [PATCH 0480/2400] [dev.typeparams] cmd/compile: add types2-based
 noder

This CL adds "irgen", a new noding implementation that utilizes types2
to guide IR construction. Notably, it completely skips dealing with
constant and type expressions (aside from using ir.TypeNode to
interoperate with the types1 typechecker), because types2 already
handled those. It also omits any syntax checking, trusting that types2
already rejected any errors.

It currently still utilizes the types1 typechecker for the desugaring
operations it handles (e.g., turning OAS2 into OAS2FUNC/etc, inserting
implicit conversions, rewriting f(g()) functions, and so on). However,
the IR is constructed in a fully incremental fashion, so it should be
easy to now piecemeal replace those dependencies as needed.

Nearly all of "go test std cmd" passes with -G=3 enabled by
default. The main remaining blocker is the number of test/run.go
failures. There also appear to be cases where types2 does not provide
us with position information. These will be iterated upon.

Portions and ideas from Dan Scales's CL 276653.

Change-Id: Ic99e8f2d0267b0312d30c10d5d043f5817a59c9d
Reviewed-on: https://go-review.googlesource.com/c/go/+/281932
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/decl.go        | 222 ++++++++++++++
 src/cmd/compile/internal/noder/expr.go        | 204 +++++++++++++
 src/cmd/compile/internal/noder/func.go        |  74 +++++
 src/cmd/compile/internal/noder/helpers.go     | 130 ++++++++
 src/cmd/compile/internal/noder/irgen.go       | 176 +++++++++++
 src/cmd/compile/internal/noder/noder.go       | 178 ++---------
 src/cmd/compile/internal/noder/object.go      | 169 +++++++++++
 src/cmd/compile/internal/noder/posmap.go      |   6 +-
 src/cmd/compile/internal/noder/scopes.go      |  64 ++++
 src/cmd/compile/internal/noder/stmt.go        | 280 ++++++++++++++++++
 src/cmd/compile/internal/noder/types.go       | 208 +++++++++++++
 src/cmd/compile/internal/noder/validate.go    | 113 +++++++
 src/cmd/compile/internal/typecheck/dcl.go     |   5 +-
 src/cmd/compile/internal/typecheck/func.go    |   4 +-
 .../compile/internal/typecheck/typecheck.go   |   8 +-
 src/cmd/compile/internal/types/scope.go       |   2 +-
 16 files changed, 1685 insertions(+), 158 deletions(-)
 create mode 100644 src/cmd/compile/internal/noder/decl.go
 create mode 100644 src/cmd/compile/internal/noder/expr.go
 create mode 100644 src/cmd/compile/internal/noder/func.go
 create mode 100644 src/cmd/compile/internal/noder/helpers.go
 create mode 100644 src/cmd/compile/internal/noder/irgen.go
 create mode 100644 src/cmd/compile/internal/noder/object.go
 create mode 100644 src/cmd/compile/internal/noder/scopes.go
 create mode 100644 src/cmd/compile/internal/noder/stmt.go
 create mode 100644 src/cmd/compile/internal/noder/types.go
 create mode 100644 src/cmd/compile/internal/noder/validate.go

diff --git a/src/cmd/compile/internal/noder/decl.go b/src/cmd/compile/internal/noder/decl.go
new file mode 100644
index 0000000000..ce5bad88f3
--- /dev/null
+++ b/src/cmd/compile/internal/noder/decl.go
@@ -0,0 +1,222 @@
+// Copyright 2021 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 noder
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/syntax"
+	"cmd/compile/internal/typecheck"
+	"cmd/compile/internal/types"
+	"cmd/compile/internal/types2"
+)
+
+// TODO(mdempsky): Skip blank declarations? Probably only safe
+// for declarations without pragmas.
+
+func (g *irgen) decls(decls []syntax.Decl) []ir.Node {
+	var res ir.Nodes
+	for _, decl := range decls {
+		switch decl := decl.(type) {
+		case *syntax.ConstDecl:
+			g.constDecl(&res, decl)
+		case *syntax.FuncDecl:
+			g.funcDecl(&res, decl)
+		case *syntax.TypeDecl:
+			if ir.CurFunc == nil {
+				continue // already handled in irgen.generate
+			}
+			g.typeDecl(&res, decl)
+		case *syntax.VarDecl:
+			g.varDecl(&res, decl)
+		default:
+			g.unhandled("declaration", decl)
+		}
+	}
+	return res
+}
+
+func (g *irgen) importDecl(p *noder, decl *syntax.ImportDecl) {
+	// TODO(mdempsky): Merge with gcimports so we don't have to import
+	// packages twice.
+
+	g.pragmaFlags(decl.Pragma, 0)
+
+	ipkg := importfile(decl)
+	if ipkg == ir.Pkgs.Unsafe {
+		p.importedUnsafe = true
+	}
+}
+
+func (g *irgen) constDecl(out *ir.Nodes, decl *syntax.ConstDecl) {
+	g.pragmaFlags(decl.Pragma, 0)
+
+	for _, name := range decl.NameList {
+		name, obj := g.def(name)
+		name.SetVal(obj.(*types2.Const).Val())
+		out.Append(ir.NewDecl(g.pos(decl), ir.ODCLCONST, name))
+	}
+}
+
+func (g *irgen) funcDecl(out *ir.Nodes, decl *syntax.FuncDecl) {
+	fn := ir.NewFunc(g.pos(decl))
+	fn.Nname, _ = g.def(decl.Name)
+	fn.Nname.Func = fn
+	fn.Nname.Defn = fn
+
+	fn.Pragma = g.pragmaFlags(decl.Pragma, funcPragmas)
+	if fn.Pragma&ir.Systemstack != 0 && fn.Pragma&ir.Nosplit != 0 {
+		base.ErrorfAt(fn.Pos(), "go:nosplit and go:systemstack cannot be combined")
+	}
+
+	if decl.Name.Value == "init" && decl.Recv == nil {
+		g.target.Inits = append(g.target.Inits, fn)
+	}
+
+	g.funcBody(fn, decl.Recv, decl.Type, decl.Body)
+
+	out.Append(fn)
+}
+
+func (g *irgen) typeDecl(out *ir.Nodes, decl *syntax.TypeDecl) {
+	if decl.Alias {
+		if !types.AllowsGoVersion(types.LocalPkg, 1, 9) {
+			base.ErrorfAt(g.pos(decl), "type aliases only supported as of -lang=go1.9")
+		}
+
+		name, _ := g.def(decl.Name)
+		g.pragmaFlags(decl.Pragma, 0)
+
+		// TODO(mdempsky): This matches how typecheckdef marks aliases for
+		// export, but this won't generalize to exporting function-scoped
+		// type aliases. We should maybe just use n.Alias() instead.
+		if ir.CurFunc == nil {
+			name.Sym().Def = ir.TypeNode(name.Type())
+		}
+
+		out.Append(ir.NewDecl(g.pos(decl), ir.ODCLTYPE, name))
+		return
+	}
+
+	name, obj := g.def(decl.Name)
+	ntyp, otyp := name.Type(), obj.Type()
+	if ir.CurFunc != nil {
+		typecheck.TypeGen++
+		ntyp.Vargen = typecheck.TypeGen
+	}
+
+	pragmas := g.pragmaFlags(decl.Pragma, typePragmas)
+	name.SetPragma(pragmas) // TODO(mdempsky): Is this still needed?
+
+	if pragmas&ir.NotInHeap != 0 {
+		ntyp.SetNotInHeap(true)
+	}
+
+	// We need to use g.typeExpr(decl.Type) here to ensure that for
+	// chained, defined-type declarations like
+	//
+	//	type T U
+	//
+	//	//go:notinheap
+	//	type U struct { … }
+	//
+	// that we mark both T and U as NotInHeap. If we instead used just
+	// g.typ(otyp.Underlying()), then we'd instead set T's underlying
+	// type directly to the struct type (which is not marked NotInHeap)
+	// and fail to mark T as NotInHeap.
+	//
+	// Also, we rely here on Type.SetUnderlying allowing passing a
+	// defined type and handling forward references like from T to U
+	// above. Contrast with go/types's Named.SetUnderlying, which
+	// disallows this.
+	//
+	// [mdempsky: Subtleties like these are why I always vehemently
+	// object to new type pragmas.]
+	ntyp.SetUnderlying(g.typeExpr(decl.Type))
+
+	if otyp, ok := otyp.(*types2.Named); ok && otyp.NumMethods() != 0 {
+		methods := make([]*types.Field, otyp.NumMethods())
+		for i := range methods {
+			m := otyp.Method(i)
+			meth := g.obj(m)
+			methods[i] = types.NewField(meth.Pos(), g.selector(m), meth.Type())
+			methods[i].Nname = meth
+		}
+		ntyp.Methods().Set(methods)
+	}
+
+	out.Append(ir.NewDecl(g.pos(decl), ir.ODCLTYPE, name))
+}
+
+func (g *irgen) varDecl(out *ir.Nodes, decl *syntax.VarDecl) {
+	pos := g.pos(decl)
+	names := make([]*ir.Name, len(decl.NameList))
+	for i, name := range decl.NameList {
+		names[i], _ = g.def(name)
+	}
+	values := g.exprList(decl.Values)
+
+	if decl.Pragma != nil {
+		pragma := decl.Pragma.(*pragmas)
+		if err := varEmbed(g.makeXPos, names[0], decl, pragma); err != nil {
+			base.ErrorfAt(g.pos(decl), "%s", err.Error())
+		}
+		g.reportUnused(pragma)
+	}
+
+	var as2 *ir.AssignListStmt
+	if len(values) != 0 && len(names) != len(values) {
+		as2 = ir.NewAssignListStmt(pos, ir.OAS2, make([]ir.Node, len(names)), values)
+	}
+
+	for i, name := range names {
+		if ir.CurFunc != nil {
+			out.Append(ir.NewDecl(pos, ir.ODCL, name))
+		}
+		if as2 != nil {
+			as2.Lhs[i] = name
+			name.Defn = as2
+		} else {
+			as := ir.NewAssignStmt(pos, name, nil)
+			if len(values) != 0 {
+				as.Y = values[i]
+				name.Defn = as
+			} else if ir.CurFunc == nil {
+				name.Defn = as
+			}
+			out.Append(typecheck.Stmt(as))
+		}
+	}
+	if as2 != nil {
+		out.Append(typecheck.Stmt(as2))
+	}
+}
+
+// pragmaFlags returns any specified pragma flags included in allowed,
+// and reports errors about any other, unexpected pragmas.
+func (g *irgen) pragmaFlags(pragma syntax.Pragma, allowed ir.PragmaFlag) ir.PragmaFlag {
+	if pragma == nil {
+		return 0
+	}
+	p := pragma.(*pragmas)
+	present := p.Flag & allowed
+	p.Flag &^= allowed
+	g.reportUnused(p)
+	return present
+}
+
+// reportUnused reports errors about any unused pragmas.
+func (g *irgen) reportUnused(pragma *pragmas) {
+	for _, pos := range pragma.Pos {
+		if pos.Flag&pragma.Flag != 0 {
+			base.ErrorfAt(g.makeXPos(pos.Pos), "misplaced compiler directive")
+		}
+	}
+	if len(pragma.Embeds) > 0 {
+		for _, e := range pragma.Embeds {
+			base.ErrorfAt(g.makeXPos(e.Pos), "misplaced go:embed directive")
+		}
+	}
+}
diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
new file mode 100644
index 0000000000..fba6ad2e4b
--- /dev/null
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -0,0 +1,204 @@
+// Copyright 2021 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 noder
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/syntax"
+	"cmd/compile/internal/typecheck"
+	"cmd/compile/internal/types"
+	"cmd/compile/internal/types2"
+)
+
+func (g *irgen) expr(expr syntax.Expr) ir.Node {
+	// TODO(mdempsky): Change callers to not call on nil?
+	if expr == nil {
+		return nil
+	}
+
+	if expr == syntax.ImplicitOne {
+		base.Fatalf("expr of ImplicitOne")
+	}
+
+	if expr, ok := expr.(*syntax.Name); ok && expr.Value == "_" {
+		return ir.BlankNode
+	}
+
+	// TODO(mdempsky): Is there a better way to recognize and handle qualified identifiers?
+	if expr, ok := expr.(*syntax.SelectorExpr); ok {
+		if name, ok := expr.X.(*syntax.Name); ok {
+			if _, ok := g.info.Uses[name].(*types2.PkgName); ok {
+				return g.use(expr.Sel)
+			}
+		}
+	}
+
+	tv, ok := g.info.Types[expr]
+	if !ok {
+		base.FatalfAt(g.pos(expr), "missing type for %v (%T)", expr, expr)
+	}
+	switch {
+	case tv.IsBuiltin():
+		// TODO(mdempsky): Handle in CallExpr?
+		return g.use(expr.(*syntax.Name))
+	case tv.IsType():
+		return ir.TypeNode(g.typ(tv.Type))
+	case tv.IsValue(), tv.IsVoid():
+		// ok
+	default:
+		base.FatalfAt(g.pos(expr), "unrecognized type-checker result")
+	}
+
+	// Constant expression.
+	if tv.Value != nil {
+		return Const(g.pos(expr), g.typ(tv.Type), tv.Value)
+	}
+
+	// TODO(mdempsky): Remove dependency on typecheck.Expr.
+	n := typecheck.Expr(g.expr0(tv.Type, expr))
+	if !g.match(n.Type(), tv.Type, tv.HasOk()) {
+		base.FatalfAt(g.pos(expr), "expected %L to have type %v", n, tv.Type)
+	}
+	return n
+}
+
+func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
+	pos := g.pos(expr)
+
+	switch expr := expr.(type) {
+	case *syntax.Name:
+		if _, isNil := g.info.Uses[expr].(*types2.Nil); isNil {
+			return Nil(pos, g.typ(typ))
+		}
+		return g.use(expr)
+
+	case *syntax.CompositeLit:
+		return g.compLit(typ, expr)
+	case *syntax.FuncLit:
+		return g.funcLit(typ, expr)
+
+	case *syntax.AssertExpr:
+		return Assert(pos, g.expr(expr.X), g.typeExpr(expr.Type))
+	case *syntax.CallExpr:
+		return Call(pos, g.expr(expr.Fun), g.exprs(expr.ArgList), expr.HasDots)
+	case *syntax.IndexExpr:
+		return Index(pos, g.expr(expr.X), g.expr(expr.Index))
+	case *syntax.ParenExpr:
+		return g.expr(expr.X) // skip parens; unneeded after parse+typecheck
+	case *syntax.SelectorExpr:
+		// TODO(mdempsky/danscales): Use g.info.Selections[expr]
+		// to resolve field/method selection. See CL 280633.
+		return ir.NewSelectorExpr(pos, ir.OXDOT, g.expr(expr.X), g.name(expr.Sel))
+	case *syntax.SliceExpr:
+		return Slice(pos, g.expr(expr.X), g.expr(expr.Index[0]), g.expr(expr.Index[1]), g.expr(expr.Index[2]))
+
+	case *syntax.Operation:
+		if expr.Y == nil {
+			return Unary(pos, g.op(expr.Op, unOps[:]), g.expr(expr.X))
+		}
+		switch op := g.op(expr.Op, binOps[:]); op {
+		case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
+			return Compare(pos, g.typ(typ), op, g.expr(expr.X), g.expr(expr.Y))
+		default:
+			return Binary(pos, op, g.expr(expr.X), g.expr(expr.Y))
+		}
+
+	default:
+		g.unhandled("expression", expr)
+		panic("unreachable")
+	}
+}
+
+func (g *irgen) exprList(expr syntax.Expr) []ir.Node {
+	switch expr := expr.(type) {
+	case nil:
+		return nil
+	case *syntax.ListExpr:
+		return g.exprs(expr.ElemList)
+	default:
+		return []ir.Node{g.expr(expr)}
+	}
+}
+
+func (g *irgen) exprs(exprs []syntax.Expr) []ir.Node {
+	nodes := make([]ir.Node, len(exprs))
+	for i, expr := range exprs {
+		nodes[i] = g.expr(expr)
+	}
+	return nodes
+}
+
+func (g *irgen) compLit(typ types2.Type, lit *syntax.CompositeLit) ir.Node {
+	if ptr, ok := typ.Underlying().(*types2.Pointer); ok {
+		if _, isNamed := typ.(*types2.Named); isNamed {
+			// TODO(mdempsky): Questionable, but this is
+			// currently allowed by cmd/compile, go/types,
+			// and gccgo:
+			//
+			//	type T *struct{}
+			//	var _ = []T{{}}
+			base.FatalfAt(g.pos(lit), "defined-pointer composite literal")
+		}
+		return ir.NewAddrExpr(g.pos(lit), g.compLit(ptr.Elem(), lit))
+	}
+
+	_, isStruct := typ.Underlying().(*types2.Struct)
+
+	exprs := make([]ir.Node, len(lit.ElemList))
+	for i, elem := range lit.ElemList {
+		switch elem := elem.(type) {
+		case *syntax.KeyValueExpr:
+			if isStruct {
+				exprs[i] = ir.NewStructKeyExpr(g.pos(elem), g.name(elem.Key.(*syntax.Name)), g.expr(elem.Value))
+			} else {
+				exprs[i] = ir.NewKeyExpr(g.pos(elem), g.expr(elem.Key), g.expr(elem.Value))
+			}
+		default:
+			exprs[i] = g.expr(elem)
+		}
+	}
+
+	return ir.NewCompLitExpr(g.pos(lit), ir.OCOMPLIT, ir.TypeNode(g.typ(typ)), exprs)
+}
+
+func (g *irgen) funcLit(typ types2.Type, expr *syntax.FuncLit) ir.Node {
+	fn := ir.NewFunc(g.pos(expr))
+	fn.SetIsHiddenClosure(ir.CurFunc != nil)
+
+	fn.Nname = ir.NewNameAt(g.pos(expr), typecheck.ClosureName(ir.CurFunc))
+	ir.MarkFunc(fn.Nname)
+	fn.Nname.SetType(g.typ(typ))
+	fn.Nname.Func = fn
+	fn.Nname.Defn = fn
+
+	fn.OClosure = ir.NewClosureExpr(g.pos(expr), fn)
+	fn.OClosure.SetType(fn.Nname.Type())
+	fn.OClosure.SetTypecheck(1)
+
+	g.funcBody(fn, nil, expr.Type, expr.Body)
+
+	ir.FinishCaptureNames(fn.Pos(), ir.CurFunc, fn)
+
+	// TODO(mdempsky): ir.CaptureName should probably handle
+	// copying these fields from the canonical variable.
+	for _, cv := range fn.ClosureVars {
+		cv.SetType(cv.Canonical().Type())
+		cv.SetTypecheck(1)
+		cv.SetWalkdef(1)
+	}
+
+	g.target.Decls = append(g.target.Decls, fn)
+
+	return fn.OClosure
+}
+
+func (g *irgen) typeExpr(typ syntax.Expr) *types.Type {
+	n := g.expr(typ)
+	if n.Op() != ir.OTYPE {
+		base.FatalfAt(g.pos(typ), "expected type: %L", n)
+	}
+	return n.Type()
+}
diff --git a/src/cmd/compile/internal/noder/func.go b/src/cmd/compile/internal/noder/func.go
new file mode 100644
index 0000000000..702138157c
--- /dev/null
+++ b/src/cmd/compile/internal/noder/func.go
@@ -0,0 +1,74 @@
+// Copyright 2021 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 noder
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/syntax"
+	"cmd/compile/internal/typecheck"
+	"cmd/compile/internal/types"
+	"cmd/internal/src"
+)
+
+func (g *irgen) funcBody(fn *ir.Func, recv *syntax.Field, sig *syntax.FuncType, block *syntax.BlockStmt) {
+	typecheck.Func(fn)
+
+	// TODO(mdempsky): Remove uses of ir.CurFunc and
+	// typecheck.DeclContext after we stop relying on typecheck
+	// for desugaring.
+	outerfn, outerctxt := ir.CurFunc, typecheck.DeclContext
+	ir.CurFunc = fn
+
+	typ := fn.Type()
+	if param := typ.Recv(); param != nil {
+		g.defParam(param, recv, ir.PPARAM)
+	}
+	for i, param := range typ.Params().FieldSlice() {
+		g.defParam(param, sig.ParamList[i], ir.PPARAM)
+	}
+	for i, result := range typ.Results().FieldSlice() {
+		g.defParam(result, sig.ResultList[i], ir.PPARAMOUT)
+	}
+
+	// We may have type-checked a call to this function already and
+	// calculated its size, including parameter offsets. Now that we've
+	// created the parameter Names, force a recalculation to ensure
+	// their offsets are correct.
+	typ.Align = 0
+	types.CalcSize(typ)
+
+	if block != nil {
+		typecheck.DeclContext = ir.PAUTO
+
+		fn.Body = g.stmts(block.List)
+		if fn.Body == nil {
+			fn.Body = []ir.Node{ir.NewBlockStmt(src.NoXPos, nil)}
+		}
+		fn.Endlineno = g.makeXPos(block.Rbrace)
+
+		if base.Flag.Dwarf {
+			g.recordScopes(fn, sig)
+		}
+	}
+
+	ir.CurFunc, typecheck.DeclContext = outerfn, outerctxt
+}
+
+func (g *irgen) defParam(param *types.Field, decl *syntax.Field, class ir.Class) {
+	typecheck.DeclContext = class
+
+	var name *ir.Name
+	if decl.Name != nil {
+		name, _ = g.def(decl.Name)
+	} else if class == ir.PPARAMOUT {
+		name = g.obj(g.info.Implicits[decl])
+	}
+
+	if name != nil {
+		param.Nname = name
+		param.Sym = name.Sym() // in case it was renamed
+	}
+}
diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
new file mode 100644
index 0000000000..2139f16a6c
--- /dev/null
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -0,0 +1,130 @@
+// Copyright 2021 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 noder
+
+import (
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
+	"cmd/compile/internal/types"
+	"cmd/internal/src"
+	"go/constant"
+)
+
+// Helpers for constructing typed IR nodes.
+//
+// TODO(mdempsky): Move into their own package so they can be easily
+// reused by iimport and frontend optimizations.
+//
+// TODO(mdempsky): Update to consistently return already typechecked
+// results, rather than leaving the caller responsible for using
+// typecheck.Expr or typecheck.Stmt.
+
+// Values
+
+func Const(pos src.XPos, typ *types.Type, val constant.Value) ir.Node {
+	n := ir.NewBasicLit(pos, val)
+	n.SetType(typ)
+	return n
+}
+
+func Nil(pos src.XPos, typ *types.Type) ir.Node {
+	n := ir.NewNilExpr(pos)
+	n.SetType(typ)
+	return n
+}
+
+// Expressions
+
+func Assert(pos src.XPos, x ir.Node, typ *types.Type) ir.Node {
+	return typecheck.Expr(ir.NewTypeAssertExpr(pos, x, ir.TypeNode(typ)))
+}
+
+func Binary(pos src.XPos, op ir.Op, x, y ir.Node) ir.Node {
+	switch op {
+	case ir.OANDAND, ir.OOROR:
+		return ir.NewLogicalExpr(pos, op, x, y)
+	default:
+		return ir.NewBinaryExpr(pos, op, x, y)
+	}
+}
+
+func Call(pos src.XPos, fun ir.Node, args []ir.Node, dots bool) ir.Node {
+	// TODO(mdempsky): This should not be so difficult.
+
+	n := ir.NewCallExpr(pos, ir.OCALL, fun, args)
+	n.IsDDD = dots
+
+	// Actually a type conversion.
+	if fun.Op() == ir.OTYPE {
+		return typecheck.Expr(n)
+	}
+
+	if fun, ok := fun.(*ir.Name); ok && fun.BuiltinOp != 0 {
+		switch fun.BuiltinOp {
+		case ir.OCLOSE, ir.ODELETE, ir.OPANIC, ir.OPRINT, ir.OPRINTN:
+			return typecheck.Stmt(n)
+		default:
+			return typecheck.Expr(n)
+		}
+	}
+
+	// We probably already typechecked fun, and typecheck probably
+	// got it wrong because it didn't know the expression was
+	// going to be called immediately. Correct its mistakes.
+	switch fun := fun.(type) {
+	case *ir.ClosureExpr:
+		fun.Func.SetClosureCalled(true)
+	case *ir.SelectorExpr:
+		if fun.Op() == ir.OCALLPART {
+			op := ir.ODOTMETH
+			if fun.X.Type().IsInterface() {
+				op = ir.ODOTINTER
+			}
+			fun.SetOp(op)
+			fun.SetType(fun.Selection.Type)
+		}
+	}
+
+	typecheck.Call(n)
+	return n
+}
+
+func Compare(pos src.XPos, typ *types.Type, op ir.Op, x, y ir.Node) ir.Node {
+	n := typecheck.Expr(ir.NewBinaryExpr(pos, op, x, y))
+	n.SetType(typ)
+	return n
+}
+
+func Index(pos src.XPos, x, index ir.Node) ir.Node {
+	return ir.NewIndexExpr(pos, x, index)
+}
+
+func Slice(pos src.XPos, x, low, high, max ir.Node) ir.Node {
+	op := ir.OSLICE
+	if max != nil {
+		op = ir.OSLICE3
+	}
+	return ir.NewSliceExpr(pos, op, x, low, high, max)
+}
+
+func Unary(pos src.XPos, op ir.Op, x ir.Node) ir.Node {
+	switch op {
+	case ir.OADDR:
+		return typecheck.NodAddrAt(pos, x)
+	case ir.ODEREF:
+		return ir.NewStarExpr(pos, x)
+	default:
+		return ir.NewUnaryExpr(pos, op, x)
+	}
+}
+
+// Statements
+
+var one = constant.MakeInt64(1)
+
+func IncDec(pos src.XPos, op ir.Op, x ir.Node) ir.Node {
+	x = typecheck.AssignExpr(x)
+	return ir.NewAssignOpStmt(pos, op, x, typecheck.DefaultLit(ir.NewBasicLit(pos, one), x.Type()))
+}
diff --git a/src/cmd/compile/internal/noder/irgen.go b/src/cmd/compile/internal/noder/irgen.go
new file mode 100644
index 0000000000..694a6abb8e
--- /dev/null
+++ b/src/cmd/compile/internal/noder/irgen.go
@@ -0,0 +1,176 @@
+// Copyright 2021 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 noder
+
+import (
+	"os"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/dwarfgen"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/syntax"
+	"cmd/compile/internal/typecheck"
+	"cmd/compile/internal/types"
+	"cmd/compile/internal/types2"
+	"cmd/internal/src"
+)
+
+// check2 type checks a Go package using types2, and then generates IR
+// using the results.
+func check2(noders []*noder) {
+	if base.SyntaxErrors() != 0 {
+		base.ErrorExit()
+	}
+
+	// setup and syntax error reporting
+	var m posMap
+	files := make([]*syntax.File, len(noders))
+	for i, p := range noders {
+		m.join(&p.posMap)
+		files[i] = p.file
+	}
+
+	// typechecking
+	conf := types2.Config{
+		InferFromConstraints:  true,
+		IgnoreBranches:        true, // parser already checked via syntax.CheckBranches mode
+		CompilerErrorMessages: true, // use error strings matching existing compiler errors
+		Error: func(err error) {
+			terr := err.(types2.Error)
+			if len(terr.Msg) > 0 && terr.Msg[0] == '\t' {
+				// types2 reports error clarifications via separate
+				// error messages which are indented with a tab.
+				// Ignore them to satisfy tools and tests that expect
+				// only one error in such cases.
+				// TODO(gri) Need to adjust error reporting in types2.
+				return
+			}
+			base.ErrorfAt(m.makeXPos(terr.Pos), "%s", terr.Msg)
+		},
+		Importer: &gcimports{
+			packages: make(map[string]*types2.Package),
+		},
+		Sizes: &gcSizes{},
+	}
+	info := types2.Info{
+		Types:      make(map[syntax.Expr]types2.TypeAndValue),
+		Defs:       make(map[*syntax.Name]types2.Object),
+		Uses:       make(map[*syntax.Name]types2.Object),
+		Selections: make(map[*syntax.SelectorExpr]*types2.Selection),
+		Implicits:  make(map[syntax.Node]types2.Object),
+		Scopes:     make(map[syntax.Node]*types2.Scope),
+		// expand as needed
+	}
+	pkg, err := conf.Check(base.Ctxt.Pkgpath, files, &info)
+	files = nil
+	if err != nil {
+		base.FatalfAt(src.NoXPos, "conf.Check error: %v", err)
+	}
+	base.ExitIfErrors()
+	if base.Flag.G < 2 {
+		os.Exit(0)
+	}
+
+	g := irgen{
+		target: typecheck.Target,
+		self:   pkg,
+		info:   &info,
+		posMap: m,
+		objs:   make(map[types2.Object]*ir.Name),
+	}
+	g.generate(noders)
+
+	if base.Flag.G < 3 {
+		os.Exit(0)
+	}
+}
+
+type irgen struct {
+	target *ir.Package
+	self   *types2.Package
+	info   *types2.Info
+
+	posMap
+	objs   map[types2.Object]*ir.Name
+	marker dwarfgen.ScopeMarker
+}
+
+func (g *irgen) generate(noders []*noder) {
+	types.LocalPkg.Name = g.self.Name()
+	typecheck.TypecheckAllowed = true
+
+	// At this point, types2 has already handled name resolution and
+	// type checking. We just need to map from its object and type
+	// representations to those currently used by the rest of the
+	// compiler. This happens mostly in 3 passes.
+
+	// 1. Process all import declarations. We use the compiler's own
+	// importer for this, rather than types2's gcimporter-derived one,
+	// to handle extensions and inline function bodies correctly.
+	//
+	// Also, we need to do this in a separate pass, because mappings are
+	// instantiated on demand. If we interleaved processing import
+	// declarations with other declarations, it's likely we'd end up
+	// wanting to map an object/type from another source file, but not
+	// yet have the import data it relies on.
+	declLists := make([][]syntax.Decl, len(noders))
+Outer:
+	for i, p := range noders {
+		g.pragmaFlags(p.file.Pragma, ir.GoBuildPragma)
+		for j, decl := range p.file.DeclList {
+			switch decl := decl.(type) {
+			case *syntax.ImportDecl:
+				g.importDecl(p, decl)
+			default:
+				declLists[i] = p.file.DeclList[j:]
+				continue Outer // no more ImportDecls
+			}
+		}
+	}
+	types.LocalPkg.Height = myheight
+
+	// 2. Process all package-block type declarations. As with imports,
+	// we need to make sure all types are properly instantiated before
+	// trying to map any expressions that utilize them. In particular,
+	// we need to make sure type pragmas are already known (see comment
+	// in irgen.typeDecl).
+	//
+	// We could perhaps instead defer processing of package-block
+	// variable initializers and function bodies, like noder does, but
+	// special-casing just package-block type declarations minimizes the
+	// differences between processing package-block and function-scoped
+	// declarations.
+	for _, declList := range declLists {
+		for _, decl := range declList {
+			switch decl := decl.(type) {
+			case *syntax.TypeDecl:
+				g.typeDecl((*ir.Nodes)(&g.target.Decls), decl)
+			}
+		}
+	}
+
+	// 3. Process all remaining declarations.
+	for _, declList := range declLists {
+		g.target.Decls = append(g.target.Decls, g.decls(declList)...)
+	}
+	typecheck.DeclareUniverse()
+
+	for _, p := range noders {
+		// Process linkname and cgo pragmas.
+		p.processPragmas()
+
+		// Double check for any type-checking inconsistencies. This can be
+		// removed once we're confident in IR generation results.
+		syntax.Walk(p.file, func(n syntax.Node) bool {
+			g.validate(n)
+			return false
+		})
+	}
+}
+
+func (g *irgen) unhandled(what string, p poser) {
+	base.FatalfAt(g.pos(p), "unhandled %s: %T", what, p)
+	panic("unreachable")
+}
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 6a0ee831d7..0c7d015977 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -23,48 +23,31 @@ import (
 	"cmd/compile/internal/syntax"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
-	"cmd/compile/internal/types2"
 	"cmd/internal/objabi"
 	"cmd/internal/src"
 )
 
 func LoadPackage(filenames []string) {
 	base.Timer.Start("fe", "parse")
-	lines := ParseFiles(filenames)
-	base.Timer.Stop()
-	base.Timer.AddEvent(int64(lines), "lines")
 
-	if base.Flag.G != 0 && base.Flag.G < 3 {
-		// can only parse generic code for now
-		base.ExitIfErrors()
-		return
+	mode := syntax.CheckBranches
+	if base.Flag.G != 0 {
+		mode |= syntax.AllowGenerics
 	}
 
-	// Typecheck.
-	Package()
-
-	// With all user code typechecked, it's now safe to verify unused dot imports.
-	CheckDotImports()
-	base.ExitIfErrors()
-}
-
-// ParseFiles concurrently parses files into *syntax.File structures.
-// Each declaration in every *syntax.File is converted to a syntax tree
-// and its root represented by *Node is appended to Target.Decls.
-// Returns the total count of parsed lines.
-func ParseFiles(filenames []string) (lines uint) {
-	noders := make([]*noder, 0, len(filenames))
 	// Limit the number of simultaneously open files.
 	sem := make(chan struct{}, runtime.GOMAXPROCS(0)+10)
 
-	for _, filename := range filenames {
-		p := &noder{
+	noders := make([]*noder, len(filenames))
+	for i, filename := range filenames {
+		p := noder{
 			err:         make(chan syntax.Error),
 			trackScopes: base.Flag.Dwarf,
 		}
-		noders = append(noders, p)
+		noders[i] = &p
 
-		go func(filename string) {
+		filename := filename
+		go func() {
 			sem <- struct{}{}
 			defer func() { <-sem }()
 			defer close(p.err)
@@ -77,115 +60,42 @@ func ParseFiles(filenames []string) (lines uint) {
 			}
 			defer f.Close()
 
-			mode := syntax.CheckBranches
-			if base.Flag.G != 0 {
-				mode |= syntax.AllowGenerics
-			}
 			p.file, _ = syntax.Parse(fbase, f, p.error, p.pragma, mode) // errors are tracked via p.error
-		}(filename)
-	}
-
-	// generic noding phase (using new typechecker)
-	if base.Flag.G != 0 {
-		// setup and syntax error reporting
-		nodersmap := make(map[string]*noder)
-		var files []*syntax.File
-		for _, p := range noders {
-			for e := range p.err {
-				p.errorAt(e.Pos, "%s", e.Msg)
-			}
-
-			nodersmap[p.file.Pos().RelFilename()] = p
-			files = append(files, p.file)
-			lines += p.file.EOF.Line()
-
-		}
-		if base.SyntaxErrors() != 0 {
-			base.ErrorExit()
-		}
-
-		// typechecking
-		conf := types2.Config{
-			InferFromConstraints:  true,
-			IgnoreBranches:        true, // parser already checked via syntax.CheckBranches mode
-			CompilerErrorMessages: true, // use error strings matching existing compiler errors
-			Error: func(err error) {
-				terr := err.(types2.Error)
-				if len(terr.Msg) > 0 && terr.Msg[0] == '\t' {
-					// types2 reports error clarifications via separate
-					// error messages which are indented with a tab.
-					// Ignore them to satisfy tools and tests that expect
-					// only one error in such cases.
-					// TODO(gri) Need to adjust error reporting in types2.
-					return
-				}
-				p := nodersmap[terr.Pos.RelFilename()]
-				base.ErrorfAt(p.makeXPos(terr.Pos), "%s", terr.Msg)
-			},
-			Importer: &gcimports{
-				packages: make(map[string]*types2.Package),
-			},
-			Sizes: &gcSizes{},
-		}
-		info := types2.Info{
-			Types:      make(map[syntax.Expr]types2.TypeAndValue),
-			Defs:       make(map[*syntax.Name]types2.Object),
-			Uses:       make(map[*syntax.Name]types2.Object),
-			Selections: make(map[*syntax.SelectorExpr]*types2.Selection),
-			// expand as needed
-		}
-		conf.Check(base.Ctxt.Pkgpath, files, &info)
-		base.ExitIfErrors()
-		if base.Flag.G < 2 {
-			return
-		}
-
-		// noding
-		for _, p := range noders {
-			// errors have already been reported
-
-			p.typeInfo = &info
-			p.node()
-			lines += p.file.EOF.Line()
-			p.file = nil // release memory
-			base.ExitIfErrors()
-
-			// Always run testdclstack here, even when debug_dclstack is not set, as a sanity measure.
-			types.CheckDclstack()
-		}
-
-		types.LocalPkg.Height = myheight
-		return
+		}()
 	}
 
-	// traditional (non-generic) noding phase
+	var lines uint
 	for _, p := range noders {
 		for e := range p.err {
 			p.errorAt(e.Pos, "%s", e.Msg)
 		}
+		lines += p.file.EOF.Line()
+	}
+	base.Timer.AddEvent(int64(lines), "lines")
+
+	if base.Flag.G != 0 {
+		// Use types2 to type-check and possibly generate IR.
+		check2(noders)
+		return
+	}
 
+	for _, p := range noders {
 		p.node()
-		lines += p.file.EOF.Line()
 		p.file = nil // release memory
-		if base.SyntaxErrors() != 0 {
-			base.ErrorExit()
-		}
+	}
 
-		// Always run testdclstack here, even when debug_dclstack is not set, as a sanity measure.
-		types.CheckDclstack()
+	if base.SyntaxErrors() != 0 {
+		base.ErrorExit()
 	}
+	types.CheckDclstack()
 
 	for _, p := range noders {
 		p.processPragmas()
 	}
 
+	// Typecheck.
 	types.LocalPkg.Height = myheight
-	return
-}
-
-func Package() {
 	typecheck.DeclareUniverse()
-
 	typecheck.TypecheckAllowed = true
 
 	// Process top-level declarations in phases.
@@ -242,8 +152,10 @@ func Package() {
 	}
 
 	// Phase 5: With all user code type-checked, it's now safe to verify map keys.
+	// With all user code typechecked, it's now safe to verify unused dot imports.
 	typecheck.CheckMapKeys()
-
+	CheckDotImports()
+	base.ExitIfErrors()
 }
 
 func (p *noder) errorAt(pos syntax.Pos, format string, args ...interface{}) {
@@ -272,37 +184,6 @@ type noder struct {
 	trackScopes    bool
 
 	funcState *funcState
-
-	// typeInfo provides access to the type information computed by the new
-	// typechecker. It is only present if -G is set, and all noders point to
-	// the same types.Info. For now this is a local field, if need be we can
-	// make it global.
-	typeInfo *types2.Info
-}
-
-// For now we provide these basic accessors to get to type and object
-// information of expression nodes during noding. Eventually we will
-// attach this information directly to the syntax tree which should
-// simplify access and make it more efficient as well.
-
-// typ returns the type and value information for the given expression.
-func (p *noder) typ(x syntax.Expr) types2.TypeAndValue {
-	return p.typeInfo.Types[x]
-}
-
-// def returns the object for the given name in its declaration.
-func (p *noder) def(x *syntax.Name) types2.Object {
-	return p.typeInfo.Defs[x]
-}
-
-// use returns the object for the given name outside its declaration.
-func (p *noder) use(x *syntax.Name) types2.Object {
-	return p.typeInfo.Uses[x]
-}
-
-// sel returns the selection information for the given selector expression.
-func (p *noder) sel(x *syntax.SelectorExpr) *types2.Selection {
-	return p.typeInfo.Selections[x]
 }
 
 // funcState tracks all per-function state to make handling nested
@@ -380,7 +261,6 @@ type linkname struct {
 }
 
 func (p *noder) node() {
-	types.Block = 1
 	p.importedUnsafe = false
 	p.importedEmbed = false
 
diff --git a/src/cmd/compile/internal/noder/object.go b/src/cmd/compile/internal/noder/object.go
new file mode 100644
index 0000000000..9567042156
--- /dev/null
+++ b/src/cmd/compile/internal/noder/object.go
@@ -0,0 +1,169 @@
+// Copyright 2021 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 noder
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/syntax"
+	"cmd/compile/internal/typecheck"
+	"cmd/compile/internal/types"
+	"cmd/compile/internal/types2"
+	"cmd/internal/src"
+)
+
+func (g *irgen) def(name *syntax.Name) (*ir.Name, types2.Object) {
+	obj, ok := g.info.Defs[name]
+	if !ok {
+		base.FatalfAt(g.pos(name), "unknown name %v", name)
+	}
+	return g.obj(obj), obj
+}
+
+func (g *irgen) use(name *syntax.Name) *ir.Name {
+	obj, ok := g.info.Uses[name]
+	if !ok {
+		base.FatalfAt(g.pos(name), "unknown name %v", name)
+	}
+	return ir.CaptureName(g.pos(obj), ir.CurFunc, g.obj(obj))
+}
+
+// obj returns the Name that represents the given object. If no such
+// Name exists yet, it will be implicitly created.
+//
+// For objects declared at function scope, ir.CurFunc must already be
+// set to the respective function when the Name is created.
+func (g *irgen) obj(obj types2.Object) *ir.Name {
+	// For imported objects, we use iimport directly instead of mapping
+	// the types2 representation.
+	if obj.Pkg() != g.self {
+		sym := g.sym(obj)
+		if sym.Def != nil {
+			return sym.Def.(*ir.Name)
+		}
+		n := typecheck.Resolve(ir.NewIdent(src.NoXPos, sym))
+		if n, ok := n.(*ir.Name); ok {
+			return n
+		}
+		base.FatalfAt(g.pos(obj), "failed to resolve %v", obj)
+	}
+
+	if name, ok := g.objs[obj]; ok {
+		return name // previously mapped
+	}
+
+	var name *ir.Name
+	pos := g.pos(obj)
+
+	class := typecheck.DeclContext
+	if obj.Parent() == g.self.Scope() {
+		class = ir.PEXTERN // forward reference to package-block declaration
+	}
+
+	// "You are in a maze of twisting little passages, all different."
+	switch obj := obj.(type) {
+	case *types2.Const:
+		name = g.objCommon(pos, ir.OLITERAL, g.sym(obj), class, g.typ(obj.Type()))
+
+	case *types2.Func:
+		sig := obj.Type().(*types2.Signature)
+		var sym *types.Sym
+		var typ *types.Type
+		if recv := sig.Recv(); recv == nil {
+			if obj.Name() == "init" {
+				sym = renameinit()
+			} else {
+				sym = g.sym(obj)
+			}
+			typ = g.typ(sig)
+		} else {
+			sym = ir.MethodSym(g.typ(recv.Type()), g.selector(obj))
+			typ = g.signature(g.param(recv), sig)
+		}
+		name = g.objCommon(pos, ir.ONAME, sym, ir.PFUNC, typ)
+
+	case *types2.TypeName:
+		if obj.IsAlias() {
+			name = g.objCommon(pos, ir.OTYPE, g.sym(obj), class, g.typ(obj.Type()))
+		} else {
+			name = ir.NewDeclNameAt(pos, ir.OTYPE, g.sym(obj))
+			g.objFinish(name, class, types.NewNamed(name))
+		}
+
+	case *types2.Var:
+		var sym *types.Sym
+		if class == ir.PPARAMOUT {
+			// Backend needs names for result parameters,
+			// even if they're anonymous or blank.
+			switch obj.Name() {
+			case "":
+				sym = typecheck.LookupNum("~r", len(ir.CurFunc.Dcl)) // 'r' for "result"
+			case "_":
+				sym = typecheck.LookupNum("~b", len(ir.CurFunc.Dcl)) // 'b' for "blank"
+			}
+		}
+		if sym == nil {
+			sym = g.sym(obj)
+		}
+		name = g.objCommon(pos, ir.ONAME, sym, class, g.typ(obj.Type()))
+
+	default:
+		g.unhandled("object", obj)
+	}
+
+	g.objs[obj] = name
+	return name
+}
+
+func (g *irgen) objCommon(pos src.XPos, op ir.Op, sym *types.Sym, class ir.Class, typ *types.Type) *ir.Name {
+	name := ir.NewDeclNameAt(pos, op, sym)
+	g.objFinish(name, class, typ)
+	return name
+}
+
+func (g *irgen) objFinish(name *ir.Name, class ir.Class, typ *types.Type) {
+	sym := name.Sym()
+
+	name.SetType(typ)
+	name.Class = class
+	if name.Class == ir.PFUNC {
+		sym.SetFunc(true)
+	}
+
+	// We already know name's type, but typecheck is really eager to try
+	// recomputing it later. This appears to prevent that at least.
+	name.Ntype = ir.TypeNode(typ)
+	name.SetTypecheck(1)
+	name.SetWalkdef(1)
+
+	if ir.IsBlank(name) {
+		return
+	}
+
+	switch class {
+	case ir.PEXTERN:
+		g.target.Externs = append(g.target.Externs, name)
+		fallthrough
+	case ir.PFUNC:
+		sym.Def = name
+		if name.Class == ir.PFUNC && name.Type().Recv() != nil {
+			break // methods are exported with their receiver type
+		}
+		if types.IsExported(sym.Name) {
+			typecheck.Export(name)
+		}
+		if base.Flag.AsmHdr != "" && !name.Sym().Asm() {
+			name.Sym().SetAsm(true)
+			g.target.Asms = append(g.target.Asms, name)
+		}
+
+	default:
+		// Function-scoped declaration.
+		name.Curfn = ir.CurFunc
+		if name.Op() == ir.ONAME {
+			ir.CurFunc.Dcl = append(ir.CurFunc.Dcl, name)
+		}
+	}
+}
diff --git a/src/cmd/compile/internal/noder/posmap.go b/src/cmd/compile/internal/noder/posmap.go
index d24f706281..a6d3e2d7ef 100644
--- a/src/cmd/compile/internal/noder/posmap.go
+++ b/src/cmd/compile/internal/noder/posmap.go
@@ -27,7 +27,8 @@ func (m *posMap) end(p ender) src.XPos { return m.makeXPos(p.End()) }
 
 func (m *posMap) makeXPos(pos syntax.Pos) src.XPos {
 	if !pos.IsKnown() {
-		base.Fatalf("unknown position")
+		// TODO(mdempsky): Investigate restoring base.Fatalf.
+		return src.NoXPos
 	}
 
 	posBase := m.makeSrcPosBase(pos.Base())
@@ -70,6 +71,9 @@ func (m *posMap) makeSrcPosBase(b0 *syntax.PosBase) *src.PosBase {
 }
 
 func (m *posMap) join(other *posMap) {
+	if m.bases == nil {
+		m.bases = make(map[*syntax.PosBase]*src.PosBase)
+	}
 	for k, v := range other.bases {
 		if m.bases[k] != nil {
 			base.Fatalf("duplicate posmap bases")
diff --git a/src/cmd/compile/internal/noder/scopes.go b/src/cmd/compile/internal/noder/scopes.go
new file mode 100644
index 0000000000..eb518474c6
--- /dev/null
+++ b/src/cmd/compile/internal/noder/scopes.go
@@ -0,0 +1,64 @@
+// Copyright 2021 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 noder
+
+import (
+	"strings"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/syntax"
+	"cmd/compile/internal/types2"
+)
+
+// recordScopes populates fn.Parents and fn.Marks based on the scoping
+// information provided by types2.
+func (g *irgen) recordScopes(fn *ir.Func, sig *syntax.FuncType) {
+	scope, ok := g.info.Scopes[sig]
+	if !ok {
+		base.FatalfAt(fn.Pos(), "missing scope for %v", fn)
+	}
+
+	for i, n := 0, scope.NumChildren(); i < n; i++ {
+		g.walkScope(scope.Child(i))
+	}
+
+	g.marker.WriteTo(fn)
+}
+
+func (g *irgen) walkScope(scope *types2.Scope) bool {
+	// types2 doesn't provide a proper API for determining the
+	// lexical element a scope represents, so we have to resort to
+	// string matching. Conveniently though, this allows us to
+	// skip both function types and function literals, neither of
+	// which are interesting to us here.
+	if strings.HasPrefix(scope.String(), "function scope ") {
+		return false
+	}
+
+	g.marker.Push(g.pos(scope))
+
+	haveVars := false
+	for _, name := range scope.Names() {
+		if obj, ok := scope.Lookup(name).(*types2.Var); ok && obj.Name() != "_" {
+			haveVars = true
+			break
+		}
+	}
+
+	for i, n := 0, scope.NumChildren(); i < n; i++ {
+		if g.walkScope(scope.Child(i)) {
+			haveVars = true
+		}
+	}
+
+	if haveVars {
+		g.marker.Pop(g.end(scope))
+	} else {
+		g.marker.Unpush()
+	}
+
+	return haveVars
+}
diff --git a/src/cmd/compile/internal/noder/stmt.go b/src/cmd/compile/internal/noder/stmt.go
new file mode 100644
index 0000000000..7d79595a04
--- /dev/null
+++ b/src/cmd/compile/internal/noder/stmt.go
@@ -0,0 +1,280 @@
+// Copyright 2021 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 noder
+
+import (
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/syntax"
+	"cmd/compile/internal/typecheck"
+	"cmd/compile/internal/types"
+	"cmd/internal/src"
+)
+
+func (g *irgen) stmts(stmts []syntax.Stmt) []ir.Node {
+	var nodes []ir.Node
+	for _, stmt := range stmts {
+		switch s := g.stmt(stmt).(type) {
+		case nil: // EmptyStmt
+		case *ir.BlockStmt:
+			nodes = append(nodes, s.List...)
+		default:
+			nodes = append(nodes, s)
+		}
+	}
+	return nodes
+}
+
+func (g *irgen) stmt(stmt syntax.Stmt) ir.Node {
+	// TODO(mdempsky): Remove dependency on typecheck.
+	return typecheck.Stmt(g.stmt0(stmt))
+}
+
+func (g *irgen) stmt0(stmt syntax.Stmt) ir.Node {
+	switch stmt := stmt.(type) {
+	case nil, *syntax.EmptyStmt:
+		return nil
+	case *syntax.LabeledStmt:
+		return g.labeledStmt(stmt)
+	case *syntax.BlockStmt:
+		return ir.NewBlockStmt(g.pos(stmt), g.blockStmt(stmt))
+	case *syntax.ExprStmt:
+		x := g.expr(stmt.X)
+		if call, ok := x.(*ir.CallExpr); ok {
+			call.Use = ir.CallUseStmt
+		}
+		return x
+	case *syntax.SendStmt:
+		return ir.NewSendStmt(g.pos(stmt), g.expr(stmt.Chan), g.expr(stmt.Value))
+	case *syntax.DeclStmt:
+		return ir.NewBlockStmt(g.pos(stmt), g.decls(stmt.DeclList))
+
+	case *syntax.AssignStmt:
+		if stmt.Op != 0 && stmt.Op != syntax.Def {
+			op := g.op(stmt.Op, binOps[:])
+			if stmt.Rhs == syntax.ImplicitOne {
+				return IncDec(g.pos(stmt), op, g.expr(stmt.Lhs))
+			}
+			return ir.NewAssignOpStmt(g.pos(stmt), op, g.expr(stmt.Lhs), g.expr(stmt.Rhs))
+		}
+
+		rhs := g.exprList(stmt.Rhs)
+		if list, ok := stmt.Lhs.(*syntax.ListExpr); ok && len(list.ElemList) != 1 || len(rhs) != 1 {
+			n := ir.NewAssignListStmt(g.pos(stmt), ir.OAS2, nil, nil)
+			n.Def = stmt.Op == syntax.Def
+			n.Lhs = g.assignList(stmt.Lhs, n, n.Def)
+			n.Rhs = rhs
+			return n
+		}
+
+		n := ir.NewAssignStmt(g.pos(stmt), nil, nil)
+		n.Def = stmt.Op == syntax.Def
+		n.X = g.assignList(stmt.Lhs, n, n.Def)[0]
+		n.Y = rhs[0]
+		return n
+
+	case *syntax.BranchStmt:
+		return ir.NewBranchStmt(g.pos(stmt), g.tokOp(int(stmt.Tok), branchOps[:]), g.name(stmt.Label))
+	case *syntax.CallStmt:
+		return ir.NewGoDeferStmt(g.pos(stmt), g.tokOp(int(stmt.Tok), callOps[:]), g.expr(stmt.Call))
+	case *syntax.ReturnStmt:
+		return ir.NewReturnStmt(g.pos(stmt), g.exprList(stmt.Results))
+	case *syntax.IfStmt:
+		return g.ifStmt(stmt)
+	case *syntax.ForStmt:
+		return g.forStmt(stmt)
+	case *syntax.SelectStmt:
+		return g.selectStmt(stmt)
+	case *syntax.SwitchStmt:
+		return g.switchStmt(stmt)
+
+	default:
+		g.unhandled("statement", stmt)
+		panic("unreachable")
+	}
+}
+
+// TODO(mdempsky): Investigate replacing with switch statements or dense arrays.
+
+var branchOps = [...]ir.Op{
+	syntax.Break:       ir.OBREAK,
+	syntax.Continue:    ir.OCONTINUE,
+	syntax.Fallthrough: ir.OFALL,
+	syntax.Goto:        ir.OGOTO,
+}
+
+var callOps = [...]ir.Op{
+	syntax.Defer: ir.ODEFER,
+	syntax.Go:    ir.OGO,
+}
+
+func (g *irgen) tokOp(tok int, ops []ir.Op) ir.Op {
+	// TODO(mdempsky): Validate.
+	return ops[tok]
+}
+
+func (g *irgen) op(op syntax.Operator, ops []ir.Op) ir.Op {
+	// TODO(mdempsky): Validate.
+	return ops[op]
+}
+
+func (g *irgen) assignList(expr syntax.Expr, defn ir.InitNode, colas bool) []ir.Node {
+	if !colas {
+		return g.exprList(expr)
+	}
+
+	var exprs []syntax.Expr
+	if list, ok := expr.(*syntax.ListExpr); ok {
+		exprs = list.ElemList
+	} else {
+		exprs = []syntax.Expr{expr}
+	}
+
+	res := make([]ir.Node, len(exprs))
+	for i, expr := range exprs {
+		expr := expr.(*syntax.Name)
+		if expr.Value == "_" {
+			res[i] = ir.BlankNode
+			continue
+		}
+
+		if obj, ok := g.info.Uses[expr]; ok {
+			res[i] = g.obj(obj)
+			continue
+		}
+
+		name, _ := g.def(expr)
+		name.Defn = defn
+		defn.PtrInit().Append(ir.NewDecl(name.Pos(), ir.ODCL, name))
+		res[i] = name
+	}
+	return res
+}
+
+func (g *irgen) blockStmt(stmt *syntax.BlockStmt) []ir.Node {
+	return g.stmts(stmt.List)
+}
+
+func (g *irgen) ifStmt(stmt *syntax.IfStmt) ir.Node {
+	init := g.stmt(stmt.Init)
+	n := ir.NewIfStmt(g.pos(stmt), g.expr(stmt.Cond), g.blockStmt(stmt.Then), nil)
+	if stmt.Else != nil {
+		e := g.stmt(stmt.Else)
+		if e.Op() == ir.OBLOCK {
+			e := e.(*ir.BlockStmt)
+			n.Else = e.List
+		} else {
+			n.Else = []ir.Node{e}
+		}
+	}
+	return g.init(init, n)
+}
+
+func (g *irgen) forStmt(stmt *syntax.ForStmt) ir.Node {
+	if r, ok := stmt.Init.(*syntax.RangeClause); ok {
+		n := ir.NewRangeStmt(g.pos(r), nil, nil, g.expr(r.X), nil)
+		if r.Lhs != nil {
+			n.Def = r.Def
+			lhs := g.assignList(r.Lhs, n, n.Def)
+			n.Key = lhs[0]
+			if len(lhs) > 1 {
+				n.Value = lhs[1]
+			}
+		}
+		n.Body = g.blockStmt(stmt.Body)
+		return n
+	}
+
+	return ir.NewForStmt(g.pos(stmt), g.stmt(stmt.Init), g.expr(stmt.Cond), g.stmt(stmt.Post), g.blockStmt(stmt.Body))
+}
+
+func (g *irgen) selectStmt(stmt *syntax.SelectStmt) ir.Node {
+	body := make([]*ir.CommClause, len(stmt.Body))
+	for i, clause := range stmt.Body {
+		body[i] = ir.NewCommStmt(g.pos(clause), g.stmt(clause.Comm), g.stmts(clause.Body))
+	}
+	return ir.NewSelectStmt(g.pos(stmt), body)
+}
+
+func (g *irgen) switchStmt(stmt *syntax.SwitchStmt) ir.Node {
+	pos := g.pos(stmt)
+	init := g.stmt(stmt.Init)
+
+	var expr ir.Node
+	switch tag := stmt.Tag.(type) {
+	case *syntax.TypeSwitchGuard:
+		var ident *ir.Ident
+		if tag.Lhs != nil {
+			ident = ir.NewIdent(g.pos(tag.Lhs), g.name(tag.Lhs))
+		}
+		expr = ir.NewTypeSwitchGuard(pos, ident, g.expr(tag.X))
+	default:
+		expr = g.expr(tag)
+	}
+
+	body := make([]*ir.CaseClause, len(stmt.Body))
+	for i, clause := range stmt.Body {
+		// Check for an implicit clause variable before
+		// visiting body, because it may contain function
+		// literals that reference it, and then it'll be
+		// associated to the wrong function.
+		//
+		// Also, override its position to the clause's colon, so that
+		// dwarfgen can find the right scope for it later.
+		// TODO(mdempsky): We should probably just store the scope
+		// directly in the ir.Name.
+		var cv *ir.Name
+		if obj, ok := g.info.Implicits[clause]; ok {
+			cv = g.obj(obj)
+			cv.SetPos(g.makeXPos(clause.Colon))
+		}
+		body[i] = ir.NewCaseStmt(g.pos(clause), g.exprList(clause.Cases), g.stmts(clause.Body))
+		body[i].Var = cv
+	}
+
+	return g.init(init, ir.NewSwitchStmt(pos, expr, body))
+}
+
+func (g *irgen) labeledStmt(label *syntax.LabeledStmt) ir.Node {
+	sym := g.name(label.Label)
+	lhs := ir.NewLabelStmt(g.pos(label), sym)
+	ls := g.stmt(label.Stmt)
+
+	// Attach label directly to control statement too.
+	switch ls := ls.(type) {
+	case *ir.ForStmt:
+		ls.Label = sym
+	case *ir.RangeStmt:
+		ls.Label = sym
+	case *ir.SelectStmt:
+		ls.Label = sym
+	case *ir.SwitchStmt:
+		ls.Label = sym
+	}
+
+	l := []ir.Node{lhs}
+	if ls != nil {
+		if ls.Op() == ir.OBLOCK {
+			ls := ls.(*ir.BlockStmt)
+			l = append(l, ls.List...)
+		} else {
+			l = append(l, ls)
+		}
+	}
+	return ir.NewBlockStmt(src.NoXPos, l)
+}
+
+func (g *irgen) init(init ir.Node, stmt ir.InitNode) ir.InitNode {
+	if init != nil {
+		stmt.SetInit([]ir.Node{init})
+	}
+	return stmt
+}
+
+func (g *irgen) name(name *syntax.Name) *types.Sym {
+	if name == nil {
+		return nil
+	}
+	return typecheck.Lookup(name.Value)
+}
diff --git a/src/cmd/compile/internal/noder/types.go b/src/cmd/compile/internal/noder/types.go
new file mode 100644
index 0000000000..0635d76077
--- /dev/null
+++ b/src/cmd/compile/internal/noder/types.go
@@ -0,0 +1,208 @@
+// Copyright 2021 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 noder
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
+	"cmd/compile/internal/types"
+	"cmd/compile/internal/types2"
+	"cmd/internal/src"
+)
+
+func (g *irgen) pkg(pkg *types2.Package) *types.Pkg {
+	switch pkg {
+	case nil:
+		return types.BuiltinPkg
+	case g.self:
+		return types.LocalPkg
+	case types2.Unsafe:
+		return ir.Pkgs.Unsafe
+	}
+	return types.NewPkg(pkg.Path(), pkg.Name())
+}
+
+func (g *irgen) typ(typ types2.Type) *types.Type {
+	switch typ := typ.(type) {
+	case *types2.Basic:
+		return g.basic(typ)
+	case *types2.Named:
+		obj := g.obj(typ.Obj())
+		if obj.Op() != ir.OTYPE {
+			base.FatalfAt(obj.Pos(), "expected type: %L", obj)
+		}
+		return obj.Type()
+
+	case *types2.Array:
+		return types.NewArray(g.typ(typ.Elem()), typ.Len())
+	case *types2.Chan:
+		return types.NewChan(g.typ(typ.Elem()), dirs[typ.Dir()])
+	case *types2.Map:
+		return types.NewMap(g.typ(typ.Key()), g.typ(typ.Elem()))
+	case *types2.Pointer:
+		return types.NewPtr(g.typ(typ.Elem()))
+	case *types2.Signature:
+		return g.signature(nil, typ)
+	case *types2.Slice:
+		return types.NewSlice(g.typ(typ.Elem()))
+
+	case *types2.Struct:
+		fields := make([]*types.Field, typ.NumFields())
+		for i := range fields {
+			v := typ.Field(i)
+			f := types.NewField(g.pos(v), g.selector(v), g.typ(v.Type()))
+			f.Note = typ.Tag(i)
+			if v.Embedded() {
+				f.Embedded = 1
+			}
+			fields[i] = f
+		}
+		return types.NewStruct(g.tpkg(typ), fields)
+
+	case *types2.Interface:
+		embeddeds := make([]*types.Field, typ.NumEmbeddeds())
+		for i := range embeddeds {
+			// TODO(mdempsky): Get embedding position.
+			e := typ.EmbeddedType(i)
+			embeddeds[i] = types.NewField(src.NoXPos, nil, g.typ(e))
+		}
+
+		methods := make([]*types.Field, typ.NumExplicitMethods())
+		for i := range methods {
+			m := typ.ExplicitMethod(i)
+			mtyp := g.signature(typecheck.FakeRecv(), m.Type().(*types2.Signature))
+			methods[i] = types.NewField(g.pos(m), g.selector(m), mtyp)
+		}
+
+		return types.NewInterface(g.tpkg(typ), append(embeddeds, methods...))
+
+	default:
+		base.FatalfAt(src.NoXPos, "unhandled type: %v (%T)", typ, typ)
+		panic("unreachable")
+	}
+}
+
+func (g *irgen) signature(recv *types.Field, sig *types2.Signature) *types.Type {
+	do := func(typ *types2.Tuple) []*types.Field {
+		fields := make([]*types.Field, typ.Len())
+		for i := range fields {
+			fields[i] = g.param(typ.At(i))
+		}
+		return fields
+	}
+
+	params := do(sig.Params())
+	results := do(sig.Results())
+	if sig.Variadic() {
+		params[len(params)-1].SetIsDDD(true)
+	}
+
+	return types.NewSignature(g.tpkg(sig), recv, params, results)
+}
+
+func (g *irgen) param(v *types2.Var) *types.Field {
+	return types.NewField(g.pos(v), g.sym(v), g.typ(v.Type()))
+}
+
+func (g *irgen) sym(obj types2.Object) *types.Sym {
+	if name := obj.Name(); name != "" {
+		return g.pkg(obj.Pkg()).Lookup(obj.Name())
+	}
+	return nil
+}
+
+func (g *irgen) selector(obj types2.Object) *types.Sym {
+	pkg, name := g.pkg(obj.Pkg()), obj.Name()
+	if types.IsExported(name) {
+		pkg = types.LocalPkg
+	}
+	return pkg.Lookup(name)
+}
+
+// tpkg returns the package that a function, interface, or struct type
+// expression appeared in.
+//
+// Caveat: For the degenerate types "func()", "interface{}", and
+// "struct{}", tpkg always returns LocalPkg. However, we only need the
+// package information so that go/types can report it via its API, and
+// the reason we fail to return the original package for these
+// particular types is because go/types does *not* report it for
+// them. So in practice this limitation is probably moot.
+func (g *irgen) tpkg(typ types2.Type) *types.Pkg {
+	anyObj := func() types2.Object {
+		switch typ := typ.(type) {
+		case *types2.Signature:
+			if recv := typ.Recv(); recv != nil {
+				return recv
+			}
+			if params := typ.Params(); params.Len() > 0 {
+				return params.At(0)
+			}
+			if results := typ.Results(); results.Len() > 0 {
+				return results.At(0)
+			}
+		case *types2.Struct:
+			if typ.NumFields() > 0 {
+				return typ.Field(0)
+			}
+		case *types2.Interface:
+			if typ.NumExplicitMethods() > 0 {
+				return typ.ExplicitMethod(0)
+			}
+		}
+		return nil
+	}
+
+	if obj := anyObj(); obj != nil {
+		return g.pkg(obj.Pkg())
+	}
+	return types.LocalPkg
+}
+
+func (g *irgen) basic(typ *types2.Basic) *types.Type {
+	switch typ.Name() {
+	case "byte":
+		return types.ByteType
+	case "rune":
+		return types.RuneType
+	}
+	return *basics[typ.Kind()]
+}
+
+var basics = [...]**types.Type{
+	types2.Invalid:        new(*types.Type),
+	types2.Bool:           &types.Types[types.TBOOL],
+	types2.Int:            &types.Types[types.TINT],
+	types2.Int8:           &types.Types[types.TINT8],
+	types2.Int16:          &types.Types[types.TINT16],
+	types2.Int32:          &types.Types[types.TINT32],
+	types2.Int64:          &types.Types[types.TINT64],
+	types2.Uint:           &types.Types[types.TUINT],
+	types2.Uint8:          &types.Types[types.TUINT8],
+	types2.Uint16:         &types.Types[types.TUINT16],
+	types2.Uint32:         &types.Types[types.TUINT32],
+	types2.Uint64:         &types.Types[types.TUINT64],
+	types2.Uintptr:        &types.Types[types.TUINTPTR],
+	types2.Float32:        &types.Types[types.TFLOAT32],
+	types2.Float64:        &types.Types[types.TFLOAT64],
+	types2.Complex64:      &types.Types[types.TCOMPLEX64],
+	types2.Complex128:     &types.Types[types.TCOMPLEX128],
+	types2.String:         &types.Types[types.TSTRING],
+	types2.UnsafePointer:  &types.Types[types.TUNSAFEPTR],
+	types2.UntypedBool:    &types.UntypedBool,
+	types2.UntypedInt:     &types.UntypedInt,
+	types2.UntypedRune:    &types.UntypedRune,
+	types2.UntypedFloat:   &types.UntypedFloat,
+	types2.UntypedComplex: &types.UntypedComplex,
+	types2.UntypedString:  &types.UntypedString,
+	types2.UntypedNil:     &types.Types[types.TNIL],
+}
+
+var dirs = [...]types.ChanDir{
+	types2.SendRecv: types.Cboth,
+	types2.SendOnly: types.Csend,
+	types2.RecvOnly: types.Crecv,
+}
diff --git a/src/cmd/compile/internal/noder/validate.go b/src/cmd/compile/internal/noder/validate.go
new file mode 100644
index 0000000000..f97f81d5ad
--- /dev/null
+++ b/src/cmd/compile/internal/noder/validate.go
@@ -0,0 +1,113 @@
+// Copyright 2021 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 noder
+
+import (
+	"go/constant"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/syntax"
+	"cmd/compile/internal/types"
+	"cmd/compile/internal/types2"
+)
+
+// match reports whether types t1 and t2 are consistent
+// representations for a given expression's type.
+func (g *irgen) match(t1 *types.Type, t2 types2.Type, hasOK bool) bool {
+	tuple, ok := t2.(*types2.Tuple)
+	if !ok {
+		// Not a tuple; can use simple type identity comparison.
+		return types.Identical(t1, g.typ(t2))
+	}
+
+	if hasOK {
+		// For has-ok values, types2 represents the expression's type as
+		// a 2-element tuple, whereas ir just uses the first type and
+		// infers that the second type is boolean.
+		return tuple.Len() == 2 && types.Identical(t1, g.typ(tuple.At(0).Type()))
+	}
+
+	if t1 == nil || tuple == nil {
+		return t1 == nil && tuple == nil
+	}
+	if !t1.IsFuncArgStruct() {
+		return false
+	}
+	if t1.NumFields() != tuple.Len() {
+		return false
+	}
+	for i, result := range t1.FieldSlice() {
+		if !types.Identical(result.Type, g.typ(tuple.At(i).Type())) {
+			return false
+		}
+	}
+	return true
+}
+
+func (g *irgen) validate(n syntax.Node) {
+	switch n := n.(type) {
+	case *syntax.CallExpr:
+		tv := g.info.Types[n.Fun]
+		if tv.IsBuiltin() {
+			switch builtin := n.Fun.(type) {
+			case *syntax.Name:
+				g.validateBuiltin(builtin.Value, n)
+			case *syntax.SelectorExpr:
+				g.validateBuiltin(builtin.Sel.Value, n)
+			default:
+				g.unhandled("builtin", n)
+			}
+		}
+	}
+}
+
+func (g *irgen) validateBuiltin(name string, call *syntax.CallExpr) {
+	switch name {
+	case "Alignof", "Offsetof", "Sizeof":
+		// Check that types2+gcSizes calculates sizes the same
+		// as cmd/compile does.
+
+		got, ok := constant.Int64Val(g.info.Types[call].Value)
+		if !ok {
+			base.FatalfAt(g.pos(call), "expected int64 constant value")
+		}
+
+		want := g.unsafeExpr(name, call.ArgList[0])
+		if got != want {
+			base.FatalfAt(g.pos(call), "got %v from types2, but want %v", got, want)
+		}
+	}
+}
+
+// unsafeExpr evaluates the given unsafe builtin function on arg.
+func (g *irgen) unsafeExpr(name string, arg syntax.Expr) int64 {
+	switch name {
+	case "Alignof":
+		return g.typ(g.info.Types[arg].Type).Alignment()
+	case "Sizeof":
+		return g.typ(g.info.Types[arg].Type).Size()
+	}
+
+	// Offsetof
+
+	sel := arg.(*syntax.SelectorExpr)
+	selection := g.info.Selections[sel]
+
+	typ := g.typ(g.info.Types[sel.X].Type)
+	if typ.IsPtr() {
+		typ = typ.Elem()
+	}
+
+	var offset int64
+	for _, i := range selection.Index() {
+		// Ensure field offsets have been calculated.
+		types.CalcSize(typ)
+
+		f := typ.Field(i)
+		offset += f.Offset
+		typ = f.Type
+	}
+	return offset
+}
diff --git a/src/cmd/compile/internal/typecheck/dcl.go b/src/cmd/compile/internal/typecheck/dcl.go
index c7d7506fd1..bd54919c93 100644
--- a/src/cmd/compile/internal/typecheck/dcl.go
+++ b/src/cmd/compile/internal/typecheck/dcl.go
@@ -304,10 +304,13 @@ func checkembeddedtype(t *types.Type) {
 	}
 }
 
-func fakeRecvField() *types.Field {
+// TODO(mdempsky): Move to package types.
+func FakeRecv() *types.Field {
 	return types.NewField(src.NoXPos, nil, types.FakeRecvType())
 }
 
+var fakeRecvField = FakeRecv
+
 var funcStack []funcStackEnt // stack of previous values of Curfn/dclcontext
 
 type funcStackEnt struct {
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index 03a10f594a..766eb8bae9 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -174,7 +174,7 @@ func fnpkg(fn *ir.Name) *types.Pkg {
 
 // closurename generates a new unique name for a closure within
 // outerfunc.
-func closurename(outerfunc *ir.Func) *types.Sym {
+func ClosureName(outerfunc *ir.Func) *types.Sym {
 	outer := "glob."
 	prefix := "func"
 	gen := &globClosgen
@@ -303,7 +303,7 @@ func tcClosure(clo *ir.ClosureExpr, top int) {
 		return
 	}
 
-	fn.Nname.SetSym(closurename(ir.CurFunc))
+	fn.Nname.SetSym(ClosureName(ir.CurFunc))
 	ir.MarkFunc(fn.Nname)
 	Func(fn)
 	clo.SetType(fn.Type())
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 814af59772..d5100021a2 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -1674,10 +1674,10 @@ func CheckMapKeys() {
 	mapqueue = nil
 }
 
-// typegen tracks the number of function-scoped defined types that
+// TypeGen tracks the number of function-scoped defined types that
 // have been declared. It's used to generate unique linker symbols for
 // their runtime type descriptors.
-var typegen int32
+var TypeGen int32
 
 func typecheckdeftype(n *ir.Name) {
 	if base.EnableTrace && base.Flag.LowerT {
@@ -1686,8 +1686,8 @@ func typecheckdeftype(n *ir.Name) {
 
 	t := types.NewNamed(n)
 	if n.Curfn != nil {
-		typegen++
-		t.Vargen = typegen
+		TypeGen++
+		t.Vargen = TypeGen
 	}
 
 	if n.Pragma()&ir.NotInHeap != 0 {
diff --git a/src/cmd/compile/internal/types/scope.go b/src/cmd/compile/internal/types/scope.go
index a9669ffafc..d7c454f379 100644
--- a/src/cmd/compile/internal/types/scope.go
+++ b/src/cmd/compile/internal/types/scope.go
@@ -12,7 +12,7 @@ import (
 // Declaration stack & operations
 
 var blockgen int32 = 1 // max block number
-var Block int32        // current block number
+var Block int32 = 1    // current block number
 
 // A dsym stores a symbol's shadowed declaration so that it can be
 // restored once the block scope ends.
-- 
GitLab


From 5a5ab24689b63b3c156a17103265c439c1e86df7 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Wed, 6 Jan 2021 10:47:35 +0700
Subject: [PATCH 0481/2400] [dev.regabi] cmd/compile: do not rely on
 CallExpr.Rargs for detect already walked calls

Currently, there's an awkward issue with walk pass. When walking the AST
tree, the compiler generate code for runtime functions (using mkcall* variants),
add/modify the AST tree and walk new generated tree again. This causes the
double walking on some CallExpr, which is relying on checking Rargs to prevent
that. But checking Rargs has its own issue as well.

For functions that does not have arguments, this check is failed, and we
still double walk the CallExpr node.

This CL change the way that compiler detects double walking, by using
separated field instead of relying on Rargs. In perfect world, we should make
the compiler walks the AST tree just once, but it's not safe to do that at
this moment.

Passes toolstash -cmp.

Change-Id: Ifdd1e0f98940ddb1f574af2da2ac7f005b5fcadd
Reviewed-on: https://go-review.googlesource.com/c/go/+/283672
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/mini.go   | 4 ++++
 src/cmd/compile/internal/walk/expr.go | 3 ++-
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ir/mini.go b/src/cmd/compile/internal/ir/mini.go
index 4dd9a8807a..429f4ed360 100644
--- a/src/cmd/compile/internal/ir/mini.go
+++ b/src/cmd/compile/internal/ir/mini.go
@@ -58,6 +58,7 @@ const (
 	miniTypecheckShift = 2
 	miniDiag           = 1 << 4
 	miniHasCall        = 1 << 5 // for miniStmt
+	miniWalked         = 1 << 6 // to prevent/catch re-walking
 )
 
 func (n *miniNode) Typecheck() uint8 { return n.bits.get2(miniTypecheckShift) }
@@ -71,6 +72,9 @@ func (n *miniNode) SetTypecheck(x uint8) {
 func (n *miniNode) Diag() bool     { return n.bits&miniDiag != 0 }
 func (n *miniNode) SetDiag(x bool) { n.bits.set(miniDiag, x) }
 
+func (n *miniNode) Walked() bool     { return n.bits&miniWalked != 0 }
+func (n *miniNode) SetWalked(x bool) { n.bits.set(miniWalked, x) }
+
 // Empty, immutable graph structure.
 
 func (n *miniNode) Init() Nodes { return Nodes{} }
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 893a95f403..449f8ea3ec 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -497,9 +497,10 @@ func walkCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 }
 
 func walkCall1(n *ir.CallExpr, init *ir.Nodes) {
-	if len(n.Rargs) != 0 {
+	if n.Walked() {
 		return // already walked
 	}
+	n.SetWalked(true)
 
 	// If this is a method call t.M(...),
 	// rewrite into a function call T.M(t, ...).
-- 
GitLab


From 447630042588a14aec6680e624113258d3849d49 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Thu, 14 Jan 2021 11:30:27 +0700
Subject: [PATCH 0482/2400] [dev.regabi] cmd/compile: use byte for CallExpr.Use

Reduce 16 byte for CallExpr, from 184 to 168 on 64-bit archs.

Passes toolstash -cmp.

Change-Id: I59c7609ccd03e8b4a7df8d2c30de8022ae312cee
Reviewed-on: https://go-review.googlesource.com/c/go/+/283732
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ir/expr.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 0639c3b620..39659c45c0 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -145,7 +145,7 @@ func (n *BinaryExpr) SetOp(op Op) {
 }
 
 // A CallUse records how the result of the call is used:
-type CallUse int
+type CallUse byte
 
 const (
 	_ CallUse = iota
-- 
GitLab


From f97983249a812c2b079a489fc990fbeb3695be4d Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 11 Jan 2021 22:58:23 -0800
Subject: [PATCH 0483/2400] [dev.regabi] cmd/compile: move more PAUTOHEAP to
 SSA construction

This CL moves almost all PAUTOHEAP handling code to SSA construction.
Instead of changing Names to PAUTOHEAP, escape analysis now only sets
n.Esc() to ir.EscHeap, and SSA handles creating the "&x"
pseudo-variables and associating them via Heapaddr.

This CL also gets rid of n.Stackcopy, which was used to distinguish
the heap copy of a parameter used within a function from the stack
copy used in the function calling convention. In practice, this is
always obvious from context: liveness and function prologue/epilogue
want to know about the stack copies, and everywhere else wants the
heap copy.

Hopefully moving all parameter/result handling into SSA helps with
making the register ABI stuff easier.

Also, the only remaining uses of PAUTOHEAP are now for closure
variables, so I intend to rename it to PCLOSUREVAR or get rid of those
altogether too. But this CL is already big and scary enough.

Change-Id: Ief5ef6205041b9d0ee445314310c0c5a98187e77
Reviewed-on: https://go-review.googlesource.com/c/go/+/283233
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/dwarfgen/dwarf.go |  16 +-
 src/cmd/compile/internal/escape/escape.go  | 169 +----------------
 src/cmd/compile/internal/gc/compile.go     |  15 +-
 src/cmd/compile/internal/inline/inl.go     |   7 -
 src/cmd/compile/internal/ir/name.go        |  46 ++---
 src/cmd/compile/internal/ir/sizeof_test.go |   2 +-
 src/cmd/compile/internal/liveness/plive.go |   4 +-
 src/cmd/compile/internal/ssagen/ssa.go     | 205 ++++++++++++++-------
 src/cmd/compile/internal/walk/assign.go    |  18 +-
 src/cmd/compile/internal/walk/complit.go   |   4 +-
 src/cmd/compile/internal/walk/stmt.go      |  19 +-
 src/cmd/compile/internal/walk/walk.go      | 111 -----------
 12 files changed, 192 insertions(+), 424 deletions(-)

diff --git a/src/cmd/compile/internal/dwarfgen/dwarf.go b/src/cmd/compile/internal/dwarfgen/dwarf.go
index ff249c1f4e..2440e3c8d3 100644
--- a/src/cmd/compile/internal/dwarfgen/dwarf.go
+++ b/src/cmd/compile/internal/dwarfgen/dwarf.go
@@ -186,19 +186,11 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 		isReturnValue := (n.Class == ir.PPARAMOUT)
 		if n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT {
 			abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
-		} else if n.Class == ir.PAUTOHEAP {
-			// If dcl in question has been promoted to heap, do a bit
-			// of extra work to recover original class (auto or param);
-			// see issue 30908. This insures that we get the proper
-			// signature in the abstract function DIE, but leaves a
-			// misleading location for the param (we want pointer-to-heap
-			// and not stack).
+		}
+		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
-			stackcopy := n.Stackcopy
-			if stackcopy != nil && (stackcopy.Class == ir.PPARAM || stackcopy.Class == ir.PPARAMOUT) {
-				abbrev = dwarf.DW_ABRV_PARAM_LOCLIST
-				isReturnValue = (stackcopy.Class == ir.PPARAMOUT)
-			}
 		}
 		inlIndex := 0
 		if base.Flag.GenDwarfInl > 1 {
diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index bee3878f10..79e5a98c91 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -1658,7 +1658,14 @@ func (b *batch) finish(fns []*ir.Func) {
 		// Update n.Esc based on escape analysis results.
 
 		if loc.escapes {
-			if n.Op() != ir.ONAME {
+			if n.Op() == ir.ONAME {
+				if base.Flag.CompilingRuntime {
+					base.ErrorfAt(n.Pos(), "%v escapes to heap, not allowed in runtime", n)
+				}
+				if base.Flag.LowerM != 0 {
+					base.WarnfAt(n.Pos(), "moved to heap: %v", n)
+				}
+			} else {
 				if base.Flag.LowerM != 0 {
 					base.WarnfAt(n.Pos(), "%v escapes to heap", n)
 				}
@@ -1668,7 +1675,6 @@ func (b *batch) finish(fns []*ir.Func) {
 				}
 			}
 			n.SetEsc(ir.EscHeap)
-			addrescapes(n)
 		} else {
 			if base.Flag.LowerM != 0 && n.Op() != ir.ONAME {
 				base.WarnfAt(n.Pos(), "%v does not escape", n)
@@ -2014,165 +2020,6 @@ func HeapAllocReason(n ir.Node) string {
 	return ""
 }
 
-// addrescapes tags node n as having had its address taken
-// by "increasing" the "value" of n.Esc to EscHeap.
-// Storage is allocated as necessary to allow the address
-// to be taken.
-func addrescapes(n ir.Node) {
-	switch n.Op() {
-	default:
-		// Unexpected Op, probably due to a previous type error. Ignore.
-
-	case ir.ODEREF, ir.ODOTPTR:
-		// Nothing to do.
-
-	case ir.ONAME:
-		n := n.(*ir.Name)
-		if n == ir.RegFP {
-			break
-		}
-
-		// if this is a tmpname (PAUTO), it was tagged by tmpname as not escaping.
-		// on PPARAM it means something different.
-		if n.Class == ir.PAUTO && n.Esc() == ir.EscNever {
-			break
-		}
-
-		// If a closure reference escapes, mark the outer variable as escaping.
-		if n.IsClosureVar() {
-			addrescapes(n.Defn)
-			break
-		}
-
-		if n.Class != ir.PPARAM && n.Class != ir.PPARAMOUT && n.Class != ir.PAUTO {
-			break
-		}
-
-		// This is a plain parameter or local variable that needs to move to the heap,
-		// but possibly for the function outside the one we're compiling.
-		// That is, if we have:
-		//
-		//	func f(x int) {
-		//		func() {
-		//			global = &x
-		//		}
-		//	}
-		//
-		// then we're analyzing the inner closure but we need to move x to the
-		// heap in f, not in the inner closure. Flip over to f before calling moveToHeap.
-		oldfn := ir.CurFunc
-		ir.CurFunc = n.Curfn
-		ln := base.Pos
-		base.Pos = ir.CurFunc.Pos()
-		moveToHeap(n)
-		ir.CurFunc = oldfn
-		base.Pos = ln
-
-	// ODOTPTR has already been introduced,
-	// so these are the non-pointer ODOT and OINDEX.
-	// In &x[0], if x is a slice, then x does not
-	// escape--the pointer inside x does, but that
-	// is always a heap pointer anyway.
-	case ir.ODOT:
-		n := n.(*ir.SelectorExpr)
-		addrescapes(n.X)
-	case ir.OINDEX:
-		n := n.(*ir.IndexExpr)
-		if !n.X.Type().IsSlice() {
-			addrescapes(n.X)
-		}
-	case ir.OPAREN:
-		n := n.(*ir.ParenExpr)
-		addrescapes(n.X)
-	case ir.OCONVNOP:
-		n := n.(*ir.ConvExpr)
-		addrescapes(n.X)
-	}
-}
-
-// moveToHeap records the parameter or local variable n as moved to the heap.
-func moveToHeap(n *ir.Name) {
-	if base.Flag.LowerR != 0 {
-		ir.Dump("MOVE", n)
-	}
-	if base.Flag.CompilingRuntime {
-		base.Errorf("%v escapes to heap, not allowed in runtime", n)
-	}
-	if n.Class == ir.PAUTOHEAP {
-		ir.Dump("n", n)
-		base.Fatalf("double move to heap")
-	}
-
-	// Allocate a local stack variable to hold the pointer to the heap copy.
-	// temp will add it to the function declaration list automatically.
-	heapaddr := typecheck.Temp(types.NewPtr(n.Type()))
-	heapaddr.SetSym(typecheck.Lookup("&" + n.Sym().Name))
-	heapaddr.SetPos(n.Pos())
-
-	// Unset AutoTemp to persist the &foo variable name through SSA to
-	// liveness analysis.
-	// TODO(mdempsky/drchase): Cleaner solution?
-	heapaddr.SetAutoTemp(false)
-
-	// Parameters have a local stack copy used at function start/end
-	// in addition to the copy in the heap that may live longer than
-	// the function.
-	if n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT {
-		if n.FrameOffset() == types.BADWIDTH {
-			base.Fatalf("addrescapes before param assignment")
-		}
-
-		// We rewrite n below to be a heap variable (indirection of heapaddr).
-		// Preserve a copy so we can still write code referring to the original,
-		// and substitute that copy into the function declaration list
-		// so that analyses of the local (on-stack) variables use it.
-		stackcopy := typecheck.NewName(n.Sym())
-		stackcopy.SetType(n.Type())
-		stackcopy.SetFrameOffset(n.FrameOffset())
-		stackcopy.Class = n.Class
-		stackcopy.Heapaddr = heapaddr
-		if n.Class == ir.PPARAMOUT {
-			// Make sure the pointer to the heap copy is kept live throughout the function.
-			// The function could panic at any point, and then a defer could recover.
-			// Thus, we need the pointer to the heap copy always available so the
-			// post-deferreturn code can copy the return value back to the stack.
-			// See issue 16095.
-			heapaddr.SetIsOutputParamHeapAddr(true)
-		}
-		n.Stackcopy = stackcopy
-
-		// Substitute the stackcopy into the function variable list so that
-		// liveness and other analyses use the underlying stack slot
-		// and not the now-pseudo-variable n.
-		found := false
-		for i, d := range ir.CurFunc.Dcl {
-			if d == n {
-				ir.CurFunc.Dcl[i] = stackcopy
-				found = true
-				break
-			}
-			// Parameters are before locals, so can stop early.
-			// This limits the search even in functions with many local variables.
-			if d.Class == ir.PAUTO {
-				break
-			}
-		}
-		if !found {
-			base.Fatalf("cannot find %v in local variable list", n)
-		}
-		ir.CurFunc.Dcl = append(ir.CurFunc.Dcl, n)
-	}
-
-	// Modify n in place so that uses of n now mean indirection of the heapaddr.
-	n.Class = ir.PAUTOHEAP
-	n.SetFrameOffset(0)
-	n.Heapaddr = heapaddr
-	n.SetEsc(ir.EscHeap)
-	if base.Flag.LowerM != 0 {
-		base.WarnfAt(n.Pos(), "moved to heap: %v", n)
-	}
-}
-
 // This special tag is applied to uintptr variables
 // that we believe may hold unsafe.Pointers for
 // calls into assembly functions.
diff --git a/src/cmd/compile/internal/gc/compile.go b/src/cmd/compile/internal/gc/compile.go
index 410b3e90ea..a8a0106320 100644
--- a/src/cmd/compile/internal/gc/compile.go
+++ b/src/cmd/compile/internal/gc/compile.go
@@ -90,15 +90,12 @@ func prepareFunc(fn *ir.Func) {
 	// because symbols must be allocated before the parallel
 	// phase of the compiler.
 	for _, n := range fn.Dcl {
-		switch n.Class {
-		case ir.PPARAM, ir.PPARAMOUT, ir.PAUTO:
-			if liveness.ShouldTrack(n) && n.Addrtaken() {
-				reflectdata.WriteType(n.Type())
-				// Also make sure we allocate a linker symbol
-				// for the stack object data, for the same reason.
-				if fn.LSym.Func().StackObjects == nil {
-					fn.LSym.Func().StackObjects = base.Ctxt.Lookup(fn.LSym.Name + ".stkobj")
-				}
+		if liveness.ShouldTrack(n) && n.Addrtaken() {
+			reflectdata.WriteType(n.Type())
+			// Also make sure we allocate a linker symbol
+			// for the stack object data, for the same reason.
+			if fn.LSym.Func().StackObjects == nil {
+				fn.LSym.Func().StackObjects = base.Ctxt.Lookup(fn.LSym.Name + ".stkobj")
 			}
 		}
 	}
diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 6f5f6499ce..1811feebe9 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -762,13 +762,6 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 		if ln.Class == ir.PPARAMOUT { // return values handled below.
 			continue
 		}
-		if ir.IsParamStackCopy(ln) { // ignore the on-stack copy of a parameter that moved to the heap
-			// TODO(mdempsky): Remove once I'm confident
-			// this never actually happens. We currently
-			// perform inlining before escape analysis, so
-			// nothing should have moved to the heap yet.
-			base.Fatalf("impossible: %v", ln)
-		}
 		inlf := typecheck.Expr(inlvar(ln)).(*ir.Name)
 		inlvars[ln] = inlf
 		if base.Flag.GenDwarfInl > 0 {
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 514b303893..d19b0440e6 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -58,9 +58,6 @@ type Name struct {
 	Ntype    Ntype
 	Heapaddr *Name // temp holding heap address of param
 
-	// ONAME PAUTOHEAP
-	Stackcopy *Name // the PPARAM/PPARAMOUT on-stack slot (moved func params only)
-
 	// ONAME closure linkage
 	// Consider:
 	//
@@ -150,12 +147,7 @@ func (n *Name) TypeDefn() *types.Type {
 // RecordFrameOffset records the frame offset for the name.
 // It is used by package types when laying out function arguments.
 func (n *Name) RecordFrameOffset(offset int64) {
-	if n.Stackcopy != nil {
-		n.Stackcopy.SetFrameOffset(offset)
-		n.SetFrameOffset(0)
-	} else {
-		n.SetFrameOffset(offset)
-	}
+	n.SetFrameOffset(offset)
 }
 
 // NewNameAt returns a new ONAME Node associated with symbol s at position pos.
@@ -292,6 +284,22 @@ func (n *Name) SetInlLocal(b bool)              { n.flags.set(nameInlLocal, b) }
 func (n *Name) SetOpenDeferSlot(b bool)         { n.flags.set(nameOpenDeferSlot, b) }
 func (n *Name) SetLibfuzzerExtraCounter(b bool) { n.flags.set(nameLibfuzzerExtraCounter, b) }
 
+// OnStack reports whether variable n may reside on the stack.
+func (n *Name) OnStack() bool {
+	if n.Op() != ONAME || n.Class == PFUNC {
+		base.Fatalf("%v is not a variable", n)
+	}
+	switch n.Class {
+	case PPARAM, PPARAMOUT, PAUTO:
+		return n.Esc() != EscHeap
+	case PEXTERN, PAUTOHEAP:
+		return false
+	default:
+		base.FatalfAt(n.Pos(), "%v has unknown class %v", n, n.Class)
+		panic("unreachable")
+	}
+}
+
 // MarkReadonly indicates that n is an ONAME with readonly contents.
 func (n *Name) MarkReadonly() {
 	if n.Op() != ONAME {
@@ -501,24 +509,4 @@ func NewPkgName(pos src.XPos, sym *types.Sym, pkg *types.Pkg) *PkgName {
 	return p
 }
 
-// IsParamStackCopy reports whether this is the on-stack copy of a
-// function parameter that moved to the heap.
-func IsParamStackCopy(n Node) bool {
-	if n.Op() != ONAME {
-		return false
-	}
-	name := n.(*Name)
-	return (name.Class == PPARAM || name.Class == PPARAMOUT) && name.Heapaddr != nil
-}
-
-// IsParamHeapCopy reports whether this is the on-heap copy of
-// a function parameter that moved to the heap.
-func IsParamHeapCopy(n Node) bool {
-	if n.Op() != ONAME {
-		return false
-	}
-	name := n.(*Name)
-	return name.Class == PAUTOHEAP && name.Stackcopy != nil
-}
-
 var RegFP *Name
diff --git a/src/cmd/compile/internal/ir/sizeof_test.go b/src/cmd/compile/internal/ir/sizeof_test.go
index 553dc53760..d8c1518b90 100644
--- a/src/cmd/compile/internal/ir/sizeof_test.go
+++ b/src/cmd/compile/internal/ir/sizeof_test.go
@@ -21,7 +21,7 @@ func TestSizeof(t *testing.T) {
 		_64bit uintptr     // size on 64bit platforms
 	}{
 		{Func{}, 188, 328},
-		{Name{}, 116, 208},
+		{Name{}, 112, 200},
 	}
 
 	for _, tt := range tests {
diff --git a/src/cmd/compile/internal/liveness/plive.go b/src/cmd/compile/internal/liveness/plive.go
index 8d1754c813..abc9583d5a 100644
--- a/src/cmd/compile/internal/liveness/plive.go
+++ b/src/cmd/compile/internal/liveness/plive.go
@@ -181,7 +181,7 @@ type progeffectscache struct {
 // nor do we care about empty structs (handled by the pointer check),
 // nor do we care about the fake PAUTOHEAP variables.
 func ShouldTrack(n *ir.Name) bool {
-	return (n.Class == ir.PAUTO || n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT) && n.Type().HasPointers()
+	return (n.Class == ir.PAUTO && n.Esc() != ir.EscHeap || n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT) && n.Type().HasPointers()
 }
 
 // getvariables returns the list of on-stack variables that we need to track
@@ -788,7 +788,7 @@ func (lv *liveness) epilogue() {
 				if n.Class == ir.PPARAM {
 					continue // ok
 				}
-				base.Fatalf("bad live variable at entry of %v: %L", lv.fn.Nname, n)
+				base.FatalfAt(n.Pos(), "bad live variable at entry of %v: %L", lv.fn.Nname, n)
 			}
 
 			// Record live variables.
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 3b542cf92a..ab2e21bea0 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -399,11 +399,20 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 	}
 	if s.hasOpenDefers && len(s.curfn.Exit) > 0 {
 		// Skip doing open defers if there is any extra exit code (likely
-		// copying heap-allocated return values or race detection), since
-		// we will not generate that code in the case of the extra
-		// deferreturn/ret segment.
+		// race detection), since we will not generate that code in the
+		// case of the extra deferreturn/ret segment.
 		s.hasOpenDefers = false
 	}
+	if s.hasOpenDefers {
+		// Similarly, skip if there are any heap-allocated result
+		// parameters that need to be copied back to their stack slots.
+		for _, f := range s.curfn.Type().Results().FieldSlice() {
+			if !f.Nname.(*ir.Name).OnStack() {
+				s.hasOpenDefers = false
+				break
+			}
+		}
+	}
 	if s.hasOpenDefers &&
 		s.curfn.NumReturns*s.curfn.NumDefers > 15 {
 		// Since we are generating defer calls at every exit for
@@ -450,19 +459,9 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 		case ir.PPARAMOUT:
 			s.decladdrs[n] = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(n.Type()), n, s.sp, s.startmem)
 			results = append(results, ssa.Param{Type: n.Type(), Offset: int32(n.FrameOffset())})
-			if s.canSSA(n) {
-				// Save ssa-able PPARAMOUT variables so we can
-				// store them back to the stack at the end of
-				// the function.
-				s.returns = append(s.returns, n)
-			}
 		case ir.PAUTO:
 			// processed at each use, to prevent Addr coming
 			// before the decl.
-		case ir.PAUTOHEAP:
-			// moved to heap - already handled by frontend
-		case ir.PFUNC:
-			// local function - already handled by frontend
 		default:
 			s.Fatalf("local variable with class %v unimplemented", n.Class)
 		}
@@ -488,38 +487,28 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 			}
 
 			offset = types.Rnd(offset, typ.Alignment())
-			r := s.newValue1I(ssa.OpOffPtr, types.NewPtr(typ), offset, clo)
+			ptr := s.newValue1I(ssa.OpOffPtr, types.NewPtr(typ), offset, clo)
 			offset += typ.Size()
 
 			if n.Byval() && TypeOK(n.Type()) {
 				// If it is a small variable captured by value, downgrade it to PAUTO.
-				r = s.load(n.Type(), r)
-
 				n.Class = ir.PAUTO
-			} else {
-				if !n.Byval() {
-					r = s.load(typ, r)
-				}
-
-				// Declare variable holding address taken from closure.
-				addr := ir.NewNameAt(fn.Pos(), &types.Sym{Name: "&" + n.Sym().Name, Pkg: types.LocalPkg})
-				addr.SetType(types.NewPtr(n.Type()))
-				addr.Class = ir.PAUTO
-				addr.SetUsed(true)
-				addr.Curfn = fn
-				types.CalcSize(addr.Type())
-
-				n.Heapaddr = addr
-				n = addr
+				fn.Dcl = append(fn.Dcl, n)
+				s.assign(n, s.load(n.Type(), ptr), false, 0)
+				continue
 			}
 
-			fn.Dcl = append(fn.Dcl, n)
-			s.assign(n, r, false, 0)
+			if !n.Byval() {
+				ptr = s.load(typ, ptr)
+			}
+			s.setHeapaddr(fn.Pos(), n, ptr)
 		}
 	}
 
 	// Convert the AST-based IR to the SSA-based IR
 	s.stmtList(fn.Enter)
+	s.zeroResults()
+	s.paramsToHeap()
 	s.stmtList(fn.Body)
 
 	// fallthrough to exit
@@ -547,6 +536,100 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 	return s.f
 }
 
+// zeroResults zeros the return values at the start of the function.
+// We need to do this very early in the function.  Defer might stop a
+// panic and show the return values as they exist at the time of
+// panic.  For precise stacks, the garbage collector assumes results
+// are always live, so we need to zero them before any allocations,
+// even allocations to move params/results to the heap.
+func (s *state) zeroResults() {
+	for _, f := range s.curfn.Type().Results().FieldSlice() {
+		n := f.Nname.(*ir.Name)
+		if !n.OnStack() {
+			// The local which points to the return value is the
+			// thing that needs zeroing. This is already handled
+			// by a Needzero annotation in plive.go:(*liveness).epilogue.
+			continue
+		}
+		// Zero the stack location containing f.
+		if typ := n.Type(); TypeOK(typ) {
+			s.assign(n, s.zeroVal(typ), false, 0)
+		} else {
+			s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
+			s.zero(n.Type(), s.decladdrs[n])
+		}
+	}
+}
+
+// paramsToHeap produces code to allocate memory for heap-escaped parameters
+// and to copy non-result parameters' values from the stack.
+func (s *state) paramsToHeap() {
+	do := func(params *types.Type) {
+		for _, f := range params.FieldSlice() {
+			if f.Nname == nil {
+				continue // anonymous or blank parameter
+			}
+			n := f.Nname.(*ir.Name)
+			if ir.IsBlank(n) || n.OnStack() {
+				continue
+			}
+			s.newHeapaddr(n)
+			if n.Class == ir.PPARAM {
+				s.move(n.Type(), s.expr(n.Heapaddr), s.decladdrs[n])
+			}
+		}
+	}
+
+	typ := s.curfn.Type()
+	do(typ.Recvs())
+	do(typ.Params())
+	do(typ.Results())
+}
+
+// newHeapaddr allocates heap memory for n and sets its heap address.
+func (s *state) newHeapaddr(n *ir.Name) {
+	s.setHeapaddr(n.Pos(), n, s.newObject(n.Type()))
+}
+
+// setHeapaddr allocates a new PAUTO variable to store ptr (which must be non-nil)
+// and then sets it as n's heap address.
+func (s *state) setHeapaddr(pos src.XPos, n *ir.Name, ptr *ssa.Value) {
+	if !ptr.Type.IsPtr() || !types.Identical(n.Type(), ptr.Type.Elem()) {
+		base.FatalfAt(n.Pos(), "setHeapaddr %L with type %v", n, ptr.Type)
+	}
+
+	// Declare variable to hold address.
+	addr := ir.NewNameAt(pos, &types.Sym{Name: "&" + n.Sym().Name, Pkg: types.LocalPkg})
+	addr.SetType(types.NewPtr(n.Type()))
+	addr.Class = ir.PAUTO
+	addr.SetUsed(true)
+	addr.Curfn = s.curfn
+	s.curfn.Dcl = append(s.curfn.Dcl, addr)
+	types.CalcSize(addr.Type())
+
+	if n.Class == ir.PPARAMOUT {
+		addr.SetIsOutputParamHeapAddr(true)
+	}
+
+	n.Heapaddr = addr
+	s.assign(addr, ptr, false, 0)
+}
+
+// newObject returns an SSA value denoting new(typ).
+func (s *state) newObject(typ *types.Type) *ssa.Value {
+	if typ.Size() == 0 {
+		return s.newValue1A(ssa.OpAddr, types.NewPtr(typ), ir.Syms.Zerobase, s.sb)
+	}
+	return s.rtcall(ir.Syms.Newobject, true, []*types.Type{types.NewPtr(typ)}, s.reflectType(typ))[0]
+}
+
+// reflectType returns an SSA value representing a pointer to typ's
+// reflection type descriptor.
+func (s *state) reflectType(typ *types.Type) *ssa.Value {
+	lsym := reflectdata.TypeLinksym(typ)
+	return s.entryNewValue1A(ssa.OpAddr, types.NewPtr(types.Types[types.TUINT8]), lsym, s.sb)
+}
+
 func dumpSourcesColumn(writer *ssa.HTMLWriter, fn *ir.Func) {
 	// Read sources of target function fn.
 	fname := base.Ctxt.PosTable.Pos(fn.Pos()).Filename()
@@ -682,7 +765,7 @@ type state struct {
 	// all defined variables at the end of each block. Indexed by block ID.
 	defvars []map[ir.Node]*ssa.Value
 
-	// addresses of PPARAM and PPARAMOUT variables.
+	// addresses of PPARAM and PPARAMOUT variables on the stack.
 	decladdrs map[*ir.Name]*ssa.Value
 
 	// starting values. Memory, stack pointer, and globals pointer
@@ -702,9 +785,6 @@ type state struct {
 	// Used to deduplicate panic calls.
 	panics map[funcLine]*ssa.Block
 
-	// list of PPARAMOUT (return) variables.
-	returns []*ir.Name
-
 	cgoUnsafeArgs bool
 	hasdefer      bool // whether the function contains a defer statement
 	softFloat     bool
@@ -1290,8 +1370,8 @@ func (s *state) stmt(n ir.Node) {
 
 	case ir.ODCL:
 		n := n.(*ir.Decl)
-		if n.X.Class == ir.PAUTOHEAP {
-			s.Fatalf("DCL %v", n)
+		if v := n.X; v.Esc() == ir.EscHeap {
+			s.newHeapaddr(v)
 		}
 
 	case ir.OLABEL:
@@ -1727,21 +1807,25 @@ func (s *state) exit() *ssa.Block {
 		}
 	}
 
-	// Run exit code. Typically, this code copies heap-allocated PPARAMOUT
-	// variables back to the stack.
-	s.stmtList(s.curfn.Exit)
-
-	// Store SSAable PPARAMOUT variables back to stack locations.
-	for _, n := range s.returns {
-		addr := s.decladdrs[n]
-		val := s.variable(n, n.Type())
-		s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
-		s.store(n.Type(), addr, val)
+	// Store SSAable and heap-escaped PPARAMOUT variables back to stack locations.
+	for _, f := range s.curfn.Type().Results().FieldSlice() {
+		n := f.Nname.(*ir.Name)
+		if s.canSSA(n) {
+			val := s.variable(n, n.Type())
+			s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
+			s.store(n.Type(), s.decladdrs[n], val)
+		} else if !n.OnStack() {
+			s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
+			s.move(n.Type(), s.decladdrs[n], s.expr(n.Heapaddr))
+		}
 		// TODO: if val is ever spilled, we'd like to use the
 		// PPARAMOUT slot for spilling it. That won't happen
 		// currently.
 	}
 
+	// Run exit code. Today, this is just raceexit, in -race mode.
+	s.stmtList(s.curfn.Exit)
+
 	// Do actual return.
 	m := s.mem()
 	b := s.endBlock()
@@ -2945,12 +3029,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 
 	case ir.ONEWOBJ:
 		n := n.(*ir.UnaryExpr)
-		if n.Type().Elem().Size() == 0 {
-			return s.newValue1A(ssa.OpAddr, n.Type(), ir.Syms.Zerobase, s.sb)
-		}
-		typ := s.expr(n.X)
-		vv := s.rtcall(ir.Syms.Newobject, true, []*types.Type{n.Type()}, typ)
-		return vv[0]
+		return s.newObject(n.Type().Elem())
 
 	default:
 		s.Fatalf("unhandled expr %v", n.Op())
@@ -3267,7 +3346,7 @@ func (s *state) assign(left ir.Node, right *ssa.Value, deref bool, skip skipMask
 
 	// If this assignment clobbers an entire local variable, then emit
 	// OpVarDef so liveness analysis knows the variable is redefined.
-	if base, ok := clobberBase(left).(*ir.Name); ok && base.Op() == ir.ONAME && base.Class != ir.PEXTERN && base.Class != ir.PAUTOHEAP && skip == 0 {
+	if base, ok := clobberBase(left).(*ir.Name); ok && base.OnStack() && skip == 0 {
 		s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, base, s.mem(), !ir.IsAutoTmp(base))
 	}
 
@@ -5011,6 +5090,9 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 		fallthrough
 	case ir.ONAME:
 		n := n.(*ir.Name)
+		if n.Heapaddr != nil {
+			return s.expr(n.Heapaddr)
+		}
 		switch n.Class {
 		case ir.PEXTERN:
 			// global variable
@@ -5039,8 +5121,6 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 			// ensure that we reuse symbols for out parameters so
 			// that cse works on their addresses
 			return s.newValue2Apos(ssa.OpLocalAddr, t, n, s.sp, s.mem(), true)
-		case ir.PAUTOHEAP:
-			return s.expr(n.Heapaddr)
 		default:
 			s.Fatalf("variable address class %v not implemented", n.Class)
 			return nil
@@ -5141,15 +5221,10 @@ func (s *state) canSSA(n ir.Node) bool {
 }
 
 func (s *state) canSSAName(name *ir.Name) bool {
-	if name.Addrtaken() {
-		return false
-	}
-	if ir.IsParamHeapCopy(name) {
+	if name.Addrtaken() || !name.OnStack() {
 		return false
 	}
 	switch name.Class {
-	case ir.PEXTERN, ir.PAUTOHEAP:
-		return false
 	case ir.PPARAMOUT:
 		if s.hasdefer {
 			// TODO: handle this case? Named return values must be
@@ -6399,7 +6474,7 @@ func (s byXoffset) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 func emitStackObjects(e *ssafn, pp *objw.Progs) {
 	var vars []*ir.Name
 	for _, n := range e.curfn.Dcl {
-		if liveness.ShouldTrack(n) && n.Addrtaken() {
+		if liveness.ShouldTrack(n) && n.Addrtaken() && n.Esc() != ir.EscHeap {
 			vars = append(vars, n)
 		}
 	}
diff --git a/src/cmd/compile/internal/walk/assign.go b/src/cmd/compile/internal/walk/assign.go
index 3fe810ac4e..4043d7574a 100644
--- a/src/cmd/compile/internal/walk/assign.go
+++ b/src/cmd/compile/internal/walk/assign.go
@@ -392,11 +392,7 @@ func ascompatee(op ir.Op, nl, nr []ir.Node) []ir.Node {
 
 		appendWalkStmt(&late, convas(ir.NewAssignStmt(base.Pos, lorig, r), &late))
 
-		if name == nil || name.Addrtaken() || name.Class == ir.PEXTERN || name.Class == ir.PAUTOHEAP {
-			memWrite = true
-			continue
-		}
-		if ir.IsBlank(name) {
+		if name != nil && ir.IsBlank(name) {
 			// We can ignore assignments to blank.
 			continue
 		}
@@ -405,7 +401,12 @@ func ascompatee(op ir.Op, nl, nr []ir.Node) []ir.Node {
 			// parameters. These can't appear in expressions anyway.
 			continue
 		}
-		assigned.Add(name)
+
+		if name != nil && name.OnStack() && !name.Addrtaken() {
+			assigned.Add(name)
+		} else {
+			memWrite = true
+		}
 	}
 
 	early.Append(late.Take()...)
@@ -418,7 +419,10 @@ func readsMemory(n ir.Node) bool {
 	switch n.Op() {
 	case ir.ONAME:
 		n := n.(*ir.Name)
-		return n.Class == ir.PEXTERN || n.Class == ir.PAUTOHEAP || n.Addrtaken()
+		if n.Class == ir.PFUNC {
+			return false
+		}
+		return n.Addrtaken() || !n.OnStack()
 
 	case ir.OADD,
 		ir.OAND,
diff --git a/src/cmd/compile/internal/walk/complit.go b/src/cmd/compile/internal/walk/complit.go
index 8a77bba2ad..f82ef69ca9 100644
--- a/src/cmd/compile/internal/walk/complit.go
+++ b/src/cmd/compile/internal/walk/complit.go
@@ -64,11 +64,11 @@ func readonlystaticname(t *types.Type) *ir.Name {
 }
 
 func isSimpleName(nn ir.Node) bool {
-	if nn.Op() != ir.ONAME {
+	if nn.Op() != ir.ONAME || ir.IsBlank(nn) {
 		return false
 	}
 	n := nn.(*ir.Name)
-	return n.Class != ir.PAUTOHEAP && n.Class != ir.PEXTERN
+	return n.OnStack()
 }
 
 func litas(l ir.Node, r ir.Node, init *ir.Nodes) {
diff --git a/src/cmd/compile/internal/walk/stmt.go b/src/cmd/compile/internal/walk/stmt.go
index 1df491bd4e..d892b2413f 100644
--- a/src/cmd/compile/internal/walk/stmt.go
+++ b/src/cmd/compile/internal/walk/stmt.go
@@ -86,6 +86,7 @@ func walkStmt(n ir.Node) ir.Node {
 		ir.OFALL,
 		ir.OGOTO,
 		ir.OLABEL,
+		ir.ODCL,
 		ir.ODCLCONST,
 		ir.ODCLTYPE,
 		ir.OCHECKNIL,
@@ -94,10 +95,6 @@ func walkStmt(n ir.Node) ir.Node {
 		ir.OVARLIVE:
 		return n
 
-	case ir.ODCL:
-		n := n.(*ir.Decl)
-		return walkDecl(n)
-
 	case ir.OBLOCK:
 		n := n.(*ir.BlockStmt)
 		walkStmtList(n.List)
@@ -173,20 +170,6 @@ func walkStmtList(s []ir.Node) {
 	}
 }
 
-// walkDecl walks an ODCL node.
-func walkDecl(n *ir.Decl) ir.Node {
-	v := n.X
-	if v.Class == ir.PAUTOHEAP {
-		if base.Flag.CompilingRuntime {
-			base.Errorf("%v escapes to heap, not allowed in runtime", v)
-		}
-		nn := ir.NewAssignStmt(base.Pos, v.Heapaddr, callnew(v.Type()))
-		nn.Def = true
-		return walkStmt(typecheck.Stmt(nn))
-	}
-	return n
-}
-
 // walkFor walks an OFOR or OFORUNTIL node.
 func walkFor(n *ir.ForStmt) ir.Node {
 	if n.Cond != nil {
diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index e780a90660..71f018fe3e 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -7,7 +7,6 @@ package walk
 import (
 	"errors"
 	"fmt"
-	"strings"
 
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
@@ -47,35 +46,11 @@ func Walk(fn *ir.Func) {
 		ir.DumpList(s, ir.CurFunc.Body)
 	}
 
-	zeroResults()
-	heapmoves()
-	if base.Flag.W != 0 && len(ir.CurFunc.Enter) > 0 {
-		s := fmt.Sprintf("enter %v", ir.CurFunc.Sym())
-		ir.DumpList(s, ir.CurFunc.Enter)
-	}
-
 	if base.Flag.Cfg.Instrumenting {
 		instrument(fn)
 	}
 }
 
-func paramoutheap(fn *ir.Func) bool {
-	for _, ln := range fn.Dcl {
-		switch ln.Class {
-		case ir.PPARAMOUT:
-			if ir.IsParamStackCopy(ln) || ln.Addrtaken() {
-				return true
-			}
-
-		case ir.PAUTO:
-			// stop early - parameters are over
-			return false
-		}
-	}
-
-	return false
-}
-
 // walkRecv walks an ORECV node.
 func walkRecv(n *ir.UnaryExpr) ir.Node {
 	if n.Typecheck() == 0 {
@@ -122,92 +97,6 @@ func convas(n *ir.AssignStmt, init *ir.Nodes) *ir.AssignStmt {
 
 var stop = errors.New("stop")
 
-// paramstoheap returns code to allocate memory for heap-escaped parameters
-// and to copy non-result parameters' values from the stack.
-func paramstoheap(params *types.Type) []ir.Node {
-	var nn []ir.Node
-	for _, t := range params.Fields().Slice() {
-		v := ir.AsNode(t.Nname)
-		if v != nil && v.Sym() != nil && strings.HasPrefix(v.Sym().Name, "~r") { // unnamed result
-			v = nil
-		}
-		if v == nil {
-			continue
-		}
-
-		if stackcopy := v.Name().Stackcopy; stackcopy != nil {
-			nn = append(nn, walkStmt(ir.NewDecl(base.Pos, ir.ODCL, v.(*ir.Name))))
-			if stackcopy.Class == ir.PPARAM {
-				nn = append(nn, walkStmt(typecheck.Stmt(ir.NewAssignStmt(base.Pos, v, stackcopy))))
-			}
-		}
-	}
-
-	return nn
-}
-
-// zeroResults zeros the return values at the start of the function.
-// We need to do this very early in the function.  Defer might stop a
-// panic and show the return values as they exist at the time of
-// panic.  For precise stacks, the garbage collector assumes results
-// are always live, so we need to zero them before any allocations,
-// even allocations to move params/results to the heap.
-// The generated code is added to Curfn's Enter list.
-func zeroResults() {
-	for _, f := range ir.CurFunc.Type().Results().Fields().Slice() {
-		v := ir.AsNode(f.Nname)
-		if v != nil && v.Name().Heapaddr != nil {
-			// The local which points to the return value is the
-			// thing that needs zeroing. This is already handled
-			// by a Needzero annotation in plive.go:livenessepilogue.
-			continue
-		}
-		if ir.IsParamHeapCopy(v) {
-			// TODO(josharian/khr): Investigate whether we can switch to "continue" here,
-			// and document more in either case.
-			// In the review of CL 114797, Keith wrote (roughly):
-			// I don't think the zeroing below matters.
-			// The stack return value will never be marked as live anywhere in the function.
-			// It is not written to until deferreturn returns.
-			v = v.Name().Stackcopy
-		}
-		// Zero the stack location containing f.
-		ir.CurFunc.Enter.Append(ir.NewAssignStmt(ir.CurFunc.Pos(), v, nil))
-	}
-}
-
-// returnsfromheap returns code to copy values for heap-escaped parameters
-// back to the stack.
-func returnsfromheap(params *types.Type) []ir.Node {
-	var nn []ir.Node
-	for _, t := range params.Fields().Slice() {
-		v := ir.AsNode(t.Nname)
-		if v == nil {
-			continue
-		}
-		if stackcopy := v.Name().Stackcopy; stackcopy != nil && stackcopy.Class == ir.PPARAMOUT {
-			nn = append(nn, walkStmt(typecheck.Stmt(ir.NewAssignStmt(base.Pos, stackcopy, v))))
-		}
-	}
-
-	return nn
-}
-
-// heapmoves generates code to handle migrating heap-escaped parameters
-// between the stack and the heap. The generated code is added to Curfn's
-// Enter and Exit lists.
-func heapmoves() {
-	lno := base.Pos
-	base.Pos = ir.CurFunc.Pos()
-	nn := paramstoheap(ir.CurFunc.Type().Recvs())
-	nn = append(nn, paramstoheap(ir.CurFunc.Type().Params())...)
-	nn = append(nn, paramstoheap(ir.CurFunc.Type().Results())...)
-	ir.CurFunc.Enter.Append(nn...)
-	base.Pos = ir.CurFunc.Endlineno
-	ir.CurFunc.Exit.Append(returnsfromheap(ir.CurFunc.Type().Results())...)
-	base.Pos = lno
-}
-
 func vmkcall(fn ir.Node, t *types.Type, init *ir.Nodes, va []ir.Node) *ir.CallExpr {
 	if fn.Type() == nil || fn.Type().Kind() != types.TFUNC {
 		base.Fatalf("mkcall %v %v", fn, fn.Type())
-- 
GitLab


From 9734fd482d32528c5ec0e516f79af253871beb77 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Thu, 14 Jan 2021 13:41:35 +0700
Subject: [PATCH 0484/2400] [dev.regabi] cmd/compile: use node walked flag to
 prevent double walk for walkSwitch

CL 283672 added a flag to prevent double walking, use that flag instead
of checking SwitchStmt.Compiled field.

Passes toolstash -cmp.

Change-Id: Idb8f9078412fb789f51ed4fc4206638011e38a93
Reviewed-on: https://go-review.googlesource.com/c/go/+/283733
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/walk/switch.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/walk/switch.go b/src/cmd/compile/internal/walk/switch.go
index 59446ef3db..0cc1830d3f 100644
--- a/src/cmd/compile/internal/walk/switch.go
+++ b/src/cmd/compile/internal/walk/switch.go
@@ -19,9 +19,10 @@ import (
 // walkSwitch walks a switch statement.
 func walkSwitch(sw *ir.SwitchStmt) {
 	// Guard against double walk, see #25776.
-	if len(sw.Cases) == 0 && len(sw.Compiled) > 0 {
+	if sw.Walked() {
 		return // Was fatal, but eliminating every possible source of double-walking is hard
 	}
+	sw.SetWalked(true)
 
 	if sw.Tag != nil && sw.Tag.Op() == ir.OTYPESW {
 		walkSwitchType(sw)
-- 
GitLab


From 35b9c666012dcc5203a1362f10fe5279df163a1a Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Tue, 22 Dec 2020 16:48:13 -0500
Subject: [PATCH 0485/2400] [dev.regabi] cmd/compile,cmd/link: additional code
 review suggestions for CL 270863

This patch pulls in a few additional changes requested by code
reviewers for CL 270863 that were accidentally left out. Specifically,
guarding use of ORETJMP to insure it is not used when building dynlink
on ppc64le, and a tweaking the command line flags used to control
wrapper generation.

Change-Id: I4f96462e570180887eb8693e11badd83d142710a
Reviewed-on: https://go-review.googlesource.com/c/go/+/279527
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Trust: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/ssagen/abi.go | 3 ++-
 src/cmd/link/internal/ld/main.go       | 5 +----
 src/cmd/link/internal/ld/symtab.go     | 2 +-
 3 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/abi.go b/src/cmd/compile/internal/ssagen/abi.go
index f1226f6a47..7ff8e21a48 100644
--- a/src/cmd/compile/internal/ssagen/abi.go
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -301,7 +301,8 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 	// extra work in typecheck/walk/ssa, might want to add a new node
 	// OTAILCALL or something to this effect.
 	var tail ir.Node
-	if tfn.Type().NumResults() == 0 && tfn.Type().NumParams() == 0 && tfn.Type().NumRecvs() == 0 {
+	if tfn.Type().NumResults() == 0 && tfn.Type().NumParams() == 0 && tfn.Type().NumRecvs() == 0 && !(base.Ctxt.Arch.Name == "ppc64le" && base.Ctxt.Flag_dynlink) {
+
 		tail = ir.NewBranchStmt(base.Pos, ir.ORETJMP, f.Nname.Sym())
 	} else {
 		call := ir.NewCallExpr(base.Pos, ir.OCALL, f.Nname, nil)
diff --git a/src/cmd/link/internal/ld/main.go b/src/cmd/link/internal/ld/main.go
index 1420030eec..133308e5f4 100644
--- a/src/cmd/link/internal/ld/main.go
+++ b/src/cmd/link/internal/ld/main.go
@@ -95,7 +95,7 @@ var (
 	cpuprofile        = flag.String("cpuprofile", "", "write cpu profile to `file`")
 	memprofile        = flag.String("memprofile", "", "write memory profile to `file`")
 	memprofilerate    = flag.Int64("memprofilerate", 0, "set runtime.MemProfileRate to `rate`")
-	flagAbiWrap       = false
+	flagAbiWrap       = flag.Bool("abiwrap", objabi.Regabi_enabled != 0, "support ABI wrapper functions")
 	benchmarkFlag     = flag.String("benchmark", "", "set to 'mem' or 'cpu' to enable phase benchmarking")
 	benchmarkFileFlag = flag.String("benchmarkprofile", "", "emit phase profiles to `base`_phase.{cpu,mem}prof")
 )
@@ -134,9 +134,6 @@ func Main(arch *sys.Arch, theArch Arch) {
 	objabi.Flagfn1("X", "add string value `definition` of the form importpath.name=value", func(s string) { addstrdata1(ctxt, s) })
 	objabi.Flagcount("v", "print link trace", &ctxt.Debugvlog)
 	objabi.Flagfn1("importcfg", "read import configuration from `file`", ctxt.readImportCfg)
-	if objabi.Regabi_enabled != 0 {
-		flag.BoolVar(&flagAbiWrap, "abiwrap", true, "support ABI wrapper functions")
-	}
 
 	objabi.Flagparse(usage)
 
diff --git a/src/cmd/link/internal/ld/symtab.go b/src/cmd/link/internal/ld/symtab.go
index 3b709baf75..85a8ff42ad 100644
--- a/src/cmd/link/internal/ld/symtab.go
+++ b/src/cmd/link/internal/ld/symtab.go
@@ -120,7 +120,7 @@ func putelfsym(ctxt *Link, x loader.Sym, typ elf.SymType, curbind elf.SymBind) {
 	// sym or marker relocation to associate the wrapper with the
 	// wrapped function.
 	//
-	if flagAbiWrap {
+	if *flagAbiWrap {
 		if !ldr.IsExternal(x) && ldr.SymType(x) == sym.STEXT {
 			// First case
 			if ldr.SymVersion(x) == sym.SymVerABIInternal {
-- 
GitLab


From 67bf62d93955fa72c5307f5a2ad0394cb37abd82 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 13 Jan 2021 17:00:11 -0800
Subject: [PATCH 0486/2400] [dev.typeparams] cmd/compile/internal/types2:
 better error message for invalid ... use

This partially addresses the issue below: In many (all) cases we want to
handle invalid ... use in the parser as a syntax error; but this ensures
that we get a decent error if we get here anyway.

Updates #43680.

Change-Id: I93af43a5f5741d8bc76e7a13c0db75e6edf43111
Reviewed-on: https://go-review.googlesource.com/c/go/+/283475
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/examples/types.go2 | 3 +++
 src/cmd/compile/internal/types2/expr.go            | 2 +-
 src/cmd/compile/internal/types2/typexpr.go         | 6 ++++++
 3 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/examples/types.go2 b/src/cmd/compile/internal/types2/examples/types.go2
index be8d44e599..f094880c49 100644
--- a/src/cmd/compile/internal/types2/examples/types.go2
+++ b/src/cmd/compile/internal/types2/examples/types.go2
@@ -113,6 +113,9 @@ type I1[T any] interface{
 	m1(T)
 }
 
+// There is no such thing as a variadic generic type.
+type _[T ... /* ERROR invalid use of ... */ interface{}] struct{}
+
 // Generic interfaces may be embedded as one would expect.
 type I2 interface {
 	I1(int)     // method!
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 34cbefc864..a3778129ff 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -1181,7 +1181,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 		check.ident(x, e, nil, false)
 
 	case *syntax.DotsType:
-		// ellipses are handled explicitly where they are legal
+		// dots are handled explicitly where they are legal
 		// (array composite literals and parameter lists)
 		check.error(e, "invalid use of '...'")
 		goto Error
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 32377ed3f4..d30f2fef26 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -521,6 +521,12 @@ func (check *Checker) typInternal(e0 syntax.Expr, def *Named) (T Type) {
 		typ.elem = check.varType(e.Elem)
 		return typ
 
+	case *syntax.DotsType:
+		// dots are handled explicitly where they are legal
+		// (array composite literals and parameter lists)
+		check.error(e, "invalid use of '...'")
+		check.use(e.Elem)
+
 	case *syntax.StructType:
 		typ := new(Struct)
 		def.setUnderlying(typ)
-- 
GitLab


From 82c3f0a358ed449ffcdd5b419728721b314d7a91 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 14 Jan 2021 11:50:05 -0800
Subject: [PATCH 0487/2400] [dev.typeparams] cmd/compile/internal/types2:
 untyped shift counts must fit into uint

Updates #43697.

Change-Id: If94658cb798bb0434ac3ebbf9dff504dcd59a02a
Reviewed-on: https://go-review.googlesource.com/c/go/+/283872
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/types2/expr.go       | 42 +++++++++----------
 .../internal/types2/testdata/shifts.src       | 12 +++---
 2 files changed, 26 insertions(+), 28 deletions(-)

diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index a3778129ff..736d3bfacc 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -770,14 +770,14 @@ func (check *Checker) comparison(x, y *operand, op syntax.Operator) {
 }
 
 func (check *Checker) shift(x, y *operand, e *syntax.Operation, op syntax.Operator) {
-	untypedx := isUntyped(x.typ)
+	// TODO(gri) This function seems overly complex. Revisit.
 
 	var xval constant.Value
 	if x.mode == constant_ {
 		xval = constant.ToInt(x.val)
 	}
 
-	if isInteger(x.typ) || untypedx && xval != nil && xval.Kind() == constant.Int {
+	if isInteger(x.typ) || isUntyped(x.typ) && xval != nil && xval.Kind() == constant.Int {
 		// The lhs is of integer type or an untyped constant representable
 		// as an integer. Nothing to do.
 	} else {
@@ -789,40 +789,36 @@ func (check *Checker) shift(x, y *operand, e *syntax.Operation, op syntax.Operat
 
 	// spec: "The right operand in a shift expression must have integer type
 	// or be an untyped constant representable by a value of type uint."
-	switch {
-	case isInteger(y.typ):
-		// nothing to do
-	case isUntyped(y.typ):
-		check.convertUntyped(y, Typ[Uint])
-		if y.mode == invalid {
+
+	// Provide a good error message for negative shift counts.
+	if y.mode == constant_ {
+		yval := constant.ToInt(y.val) // consider -1, 1.0, but not -1.1
+		if yval.Kind() == constant.Int && constant.Sign(yval) < 0 {
+			check.invalidOpf(y, "negative shift count %s", y)
 			x.mode = invalid
 			return
 		}
-	default:
-		check.invalidOpf(y, "shift count %s must be integer", y)
-		x.mode = invalid
-		return
 	}
 
-	var yval constant.Value
-	if y.mode == constant_ {
-		// rhs must be an integer value
-		// (Either it was of an integer type already, or it was
-		// untyped and successfully converted to a uint above.)
-		yval = constant.ToInt(y.val)
-		assert(yval.Kind() == constant.Int)
-		if constant.Sign(yval) < 0 {
-			check.invalidOpf(y, "negative shift count %s", y)
+	// Caution: Check for isUntyped first because isInteger includes untyped
+	//          integers (was bug #43697).
+	if isUntyped(y.typ) {
+		check.convertUntyped(y, Typ[Uint])
+		if y.mode == invalid {
 			x.mode = invalid
 			return
 		}
+	} else if !isInteger(y.typ) {
+		check.invalidOpf(y, "shift count %s must be integer", y)
+		x.mode = invalid
+		return
 	}
 
 	if x.mode == constant_ {
 		if y.mode == constant_ {
 			// rhs must be within reasonable bounds in constant shifts
 			const shiftBound = 1023 - 1 + 52 // so we can express smallestFloat64
-			s, ok := constant.Uint64Val(yval)
+			s, ok := constant.Uint64Val(y.val)
 			if !ok || s > shiftBound {
 				check.invalidOpf(y, "invalid shift count %s", y)
 				x.mode = invalid
@@ -849,7 +845,7 @@ func (check *Checker) shift(x, y *operand, e *syntax.Operation, op syntax.Operat
 		}
 
 		// non-constant shift with constant lhs
-		if untypedx {
+		if isUntyped(x.typ) {
 			// spec: "If the left operand of a non-constant shift
 			// expression is an untyped constant, the type of the
 			// constant is what it would be if the shift expression
diff --git a/src/cmd/compile/internal/types2/testdata/shifts.src b/src/cmd/compile/internal/types2/testdata/shifts.src
index 04a679f5bb..60db731cf4 100644
--- a/src/cmd/compile/internal/types2/testdata/shifts.src
+++ b/src/cmd/compile/internal/types2/testdata/shifts.src
@@ -20,7 +20,7 @@ func shifts0() {
 		// This depends on the exact spec wording which is not
 		// done yet.
 		// TODO(gri) revisit and adjust when spec change is done
-		_ = 1<<- /* ERROR "truncated to uint" */ 1.0
+		_ = 1<<- /* ERROR "negative shift count" */ 1.0
 		_ = 1<<1075 /* ERROR "invalid shift" */
 		_ = 2.0<<1
 		_ = 1<<1.0
@@ -60,11 +60,13 @@ func shifts1() {
 		_ uint = 1 << u
 		_ float32 = 1 /* ERROR "must be integer" */ << u
 
-		// for issue 14822
+		// issue #14822
+		_ = 1<<( /* ERROR "overflows uint" */ 1<<64)
 		_ = 1<<( /* ERROR "invalid shift count" */ 1<<64-1)
-		_ = 1<<( /* ERROR "invalid shift count" */ 1<<64)
-		_ = u<<(1<<63) // valid
-		_ = u<<(1<<64) // valid
+
+		// issue #43697
+		_ = u<<( /* ERROR "overflows uint" */ 1<<64)
+		_ = u<<(1<<64-1)
 	)
 }
 
-- 
GitLab


From 4be7af23f97fe8d1b4210acde6789cf621564ec6 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 14 Jan 2021 19:40:07 -0800
Subject: [PATCH 0488/2400] [dev.regabi] cmd/compile: fix ICE during ir.Dump

fmt.go:dumpNodeHeader uses reflection to call all "func() bool"-typed
methods on Nodes during printing, but the OnStack method that I added
in CL 283233 isn't meant to be called on non-variables.

dumpNodeHeader does already guard against panics, as happen in some
other accessors, but not against Fatalf, as I was using in OnStack. So
simply change OnStack to use panic too.

Thanks to drchase@ for the report.

Change-Id: I0cfac84a96292193401a32fc5e7fd3c48773e008
Reviewed-on: https://go-review.googlesource.com/c/go/+/284074
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ir/name.go | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index d19b0440e6..64de42382e 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -286,18 +286,17 @@ func (n *Name) SetLibfuzzerExtraCounter(b bool) { n.flags.set(nameLibfuzzerExtra
 
 // OnStack reports whether variable n may reside on the stack.
 func (n *Name) OnStack() bool {
-	if n.Op() != ONAME || n.Class == PFUNC {
-		base.Fatalf("%v is not a variable", n)
-	}
-	switch n.Class {
-	case PPARAM, PPARAMOUT, PAUTO:
-		return n.Esc() != EscHeap
-	case PEXTERN, PAUTOHEAP:
-		return false
-	default:
-		base.FatalfAt(n.Pos(), "%v has unknown class %v", n, n.Class)
-		panic("unreachable")
+	if n.Op() == ONAME {
+		switch n.Class {
+		case PPARAM, PPARAMOUT, PAUTO:
+			return n.Esc() != EscHeap
+		case PEXTERN, PAUTOHEAP:
+			return false
+		}
 	}
+	// Note: fmt.go:dumpNodeHeader calls all "func() bool"-typed
+	// methods, but it can only recover from panics, not Fatalf.
+	panic(fmt.Sprintf("%v: not a variable: %v", base.FmtPos(n.Pos()), n))
 }
 
 // MarkReadonly indicates that n is an ONAME with readonly contents.
-- 
GitLab


From b7a698c73fc61bf60e2e61db0c98f16b0bfc8652 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Thu, 14 Jan 2021 20:10:35 -0500
Subject: [PATCH 0489/2400] [dev.regabi] test: disable test on windows because
 expected contains path separators.

The feature being tested is insensitive to the OS anyway.

Change-Id: Ieac9bfaafc6a54c00017afcc0b87bd8bbe80af7b
Reviewed-on: https://go-review.googlesource.com/c/go/+/284032
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 test/abi/regabipragma.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/abi/regabipragma.go b/test/abi/regabipragma.go
index 93cdb6abbb..6a1b1938ea 100644
--- a/test/abi/regabipragma.go
+++ b/test/abi/regabipragma.go
@@ -1,4 +1,5 @@
 // runindir
+// +build !windows
 
 // Copyright 2021 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
-- 
GitLab


From ab523fc510aadb82dc39dec89741fcbb90093ff0 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 15 Jan 2021 00:39:24 -0800
Subject: [PATCH 0490/2400] [dev.regabi] cmd/compile: don't promote Byval
 CaptureVars if Addrtaken

We decide during escape analysis whether to pass closure variables by
value or reference. One of the factors that's considered is whether a
variable has had its address taken.

However, this analysis is based only on the user-written source code,
whereas order+walk may introduce rewrites that take the address of a
variable (e.g., passing a uint16 key by reference to the size-generic
map runtime builtins).

Typically this would be harmless, albeit suboptimal. But in #43701 it
manifested as needing a stack object for a function where we didn't
realize we needed one up front when we generate symbols.

Probably we should just generate symbols on demand, now that those
routines are all concurrent-safe, but this is a first fix.

Thanks to Alberto Donizetti for reporting the issue, and Cuong Manh Le
for initial investigation.

Fixes #43701.

Change-Id: I16d87e9150723dcb16de7b43f2a8f3cd807a9437
Reviewed-on: https://go-review.googlesource.com/c/go/+/284075
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/ssagen/ssa.go | 11 +++++++++--
 test/fixedbugs/issue43701.go           | 18 ++++++++++++++++++
 2 files changed, 27 insertions(+), 2 deletions(-)
 create mode 100644 test/fixedbugs/issue43701.go

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index ab2e21bea0..fe9a1f617b 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -490,8 +490,15 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 			ptr := s.newValue1I(ssa.OpOffPtr, types.NewPtr(typ), offset, clo)
 			offset += typ.Size()
 
-			if n.Byval() && TypeOK(n.Type()) {
-				// If it is a small variable captured by value, downgrade it to PAUTO.
+			// If n is a small variable captured by value, promote
+			// it to PAUTO so it can be converted to SSA.
+			//
+			// Note: While we never capture a variable by value if
+			// the user took its address, we may have generated
+			// runtime calls that did (#43701). Since we don't
+			// convert Addrtaken variables to SSA anyway, no point
+			// in promoting them either.
+			if n.Byval() && !n.Addrtaken() && TypeOK(n.Type()) {
 				n.Class = ir.PAUTO
 				fn.Dcl = append(fn.Dcl, n)
 				s.assign(n, s.load(n.Type(), ptr), false, 0)
diff --git a/test/fixedbugs/issue43701.go b/test/fixedbugs/issue43701.go
new file mode 100644
index 0000000000..6e16180046
--- /dev/null
+++ b/test/fixedbugs/issue43701.go
@@ -0,0 +1,18 @@
+// compile
+
+// Copyright 2021 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 p
+
+func f() {
+	var st struct {
+		s string
+		i int16
+	}
+	_ = func() {
+		var m map[int16]int
+		m[st.i] = 0
+	}
+}
-- 
GitLab


From 14537e6e5410b403add59bb41d3954bdab0ade3e Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 15 Jan 2021 00:56:02 -0800
Subject: [PATCH 0491/2400] [dev.regabi] cmd/compile: move stkobj symbol
 generation to SSA

The code for allocating linksyms and recording that we need runtime
type descriptors is now concurrent-safe, so move it to where those
symbols are actually needed to reduce complexity and risk of failing
to generate all needed symbols in advance.

For #43701.

Change-Id: I759d2508213ac9a4e0b504b51a75fa10dfa37a8d
Reviewed-on: https://go-review.googlesource.com/c/go/+/284076
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/compile.go | 16 ----------------
 src/cmd/compile/internal/ssagen/ssa.go |  8 +++-----
 2 files changed, 3 insertions(+), 21 deletions(-)

diff --git a/src/cmd/compile/internal/gc/compile.go b/src/cmd/compile/internal/gc/compile.go
index a8a0106320..6e347bf0f1 100644
--- a/src/cmd/compile/internal/gc/compile.go
+++ b/src/cmd/compile/internal/gc/compile.go
@@ -13,7 +13,6 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/liveness"
-	"cmd/compile/internal/reflectdata"
 	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
@@ -84,21 +83,6 @@ func prepareFunc(fn *ir.Func) {
 	walk.Walk(fn)
 	ir.CurFunc = nil // enforce no further uses of CurFunc
 	typecheck.DeclContext = ir.PEXTERN
-
-	// Make sure type syms are declared for all types that might
-	// be types of stack objects. We need to do this here
-	// because symbols must be allocated before the parallel
-	// phase of the compiler.
-	for _, n := range fn.Dcl {
-		if liveness.ShouldTrack(n) && n.Addrtaken() {
-			reflectdata.WriteType(n.Type())
-			// Also make sure we allocate a linker symbol
-			// for the stack object data, for the same reason.
-			if fn.LSym.Func().StackObjects == nil {
-				fn.LSym.Func().StackObjects = base.Ctxt.Lookup(fn.LSym.Name + ".stkobj")
-			}
-		}
-	}
 }
 
 // compileFunctions compiles all functions in compilequeue.
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index fe9a1f617b..c48ac22d2a 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -6494,7 +6494,8 @@ func emitStackObjects(e *ssafn, pp *objw.Progs) {
 
 	// Populate the stack object data.
 	// Format must match runtime/stack.go:stackObjectRecord.
-	x := e.curfn.LSym.Func().StackObjects
+	x := base.Ctxt.Lookup(e.curfn.LSym.Name + ".stkobj")
+	e.curfn.LSym.Func().StackObjects = x
 	off := 0
 	off = objw.Uintptr(x, off, uint64(len(vars)))
 	for _, v := range vars {
@@ -6502,10 +6503,7 @@ func emitStackObjects(e *ssafn, pp *objw.Progs) {
 		// in which case the offset is relative to argp.
 		// Locals have a negative Xoffset, in which case the offset is relative to varp.
 		off = objw.Uintptr(x, off, uint64(v.FrameOffset()))
-		if !types.TypeSym(v.Type()).Siggen() {
-			e.Fatalf(v.Pos(), "stack object's type symbol not generated for type %s", v.Type())
-		}
-		off = objw.SymPtr(x, off, reflectdata.WriteType(v.Type()), 0)
+		off = objw.SymPtr(x, off, reflectdata.TypeLinksym(v.Type()), 0)
 	}
 
 	// Emit a funcdata pointing at the stack object data.
-- 
GitLab


From 03a875137ff8a496e3e7e06de711ce286679dcba Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 15 Jan 2021 00:58:03 -0800
Subject: [PATCH 0492/2400] [dev.regabi] cmd/compile: unexport
 reflectdata.WriteType

WriteType isn't safe for direct concurrent use, and users should
instead use TypeLinksym or another higher-level API provided by
reflectdata. After the previous CL, there are no remaining uses of
WriteType elsewhere in the compiler, so unexport it to keep it that
way.

For #43701.

[git-generate]
cd src/cmd/compile/internal/reflectdata
rf '
	mv WriteType writeType
'

Change-Id: I294a78be570a47feb38a1ad4eaae7723653d5991
Reviewed-on: https://go-review.googlesource.com/c/go/+/284077
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 .../compile/internal/reflectdata/reflect.go   | 64 +++++++++----------
 1 file changed, 32 insertions(+), 32 deletions(-)

diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index 30857fff6d..989bcf9ab9 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -562,7 +562,7 @@ func dextratype(lsym *obj.LSym, ot int, t *types.Type, dataAdd int) int {
 	}
 
 	for _, a := range m {
-		WriteType(a.type_)
+		writeType(a.type_)
 	}
 
 	ot = dgopkgpathOff(lsym, ot, typePkg(t))
@@ -613,7 +613,7 @@ func dextratypeData(lsym *obj.LSym, ot int, t *types.Type) int {
 		nsym := dname(a.name.Name, "", pkg, exported)
 
 		ot = objw.SymPtrOff(lsym, ot, nsym)
-		ot = dmethodptrOff(lsym, ot, WriteType(a.mtype))
+		ot = dmethodptrOff(lsym, ot, writeType(a.mtype))
 		ot = dmethodptrOff(lsym, ot, a.isym)
 		ot = dmethodptrOff(lsym, ot, a.tsym)
 	}
@@ -690,7 +690,7 @@ func dcommontype(lsym *obj.LSym, t *types.Type) int {
 		if t.Sym() != nil || methods(tptr) != nil {
 			sptrWeak = false
 		}
-		sptr = WriteType(tptr)
+		sptr = writeType(tptr)
 	}
 
 	gcsym, useGCProg, ptrdata := dgcsym(t)
@@ -933,7 +933,7 @@ func formalType(t *types.Type) *types.Type {
 	return t
 }
 
-func WriteType(t *types.Type) *obj.LSym {
+func writeType(t *types.Type) *obj.LSym {
 	t = formalType(t)
 	if t.IsUntyped() {
 		base.Fatalf("dtypesym %v", t)
@@ -983,9 +983,9 @@ func WriteType(t *types.Type) *obj.LSym {
 
 	case types.TARRAY:
 		// ../../../../runtime/type.go:/arrayType
-		s1 := WriteType(t.Elem())
+		s1 := writeType(t.Elem())
 		t2 := types.NewSlice(t.Elem())
-		s2 := WriteType(t2)
+		s2 := writeType(t2)
 		ot = dcommontype(lsym, t)
 		ot = objw.SymPtr(lsym, ot, s1, 0)
 		ot = objw.SymPtr(lsym, ot, s2, 0)
@@ -994,14 +994,14 @@ func WriteType(t *types.Type) *obj.LSym {
 
 	case types.TSLICE:
 		// ../../../../runtime/type.go:/sliceType
-		s1 := WriteType(t.Elem())
+		s1 := writeType(t.Elem())
 		ot = dcommontype(lsym, t)
 		ot = objw.SymPtr(lsym, ot, s1, 0)
 		ot = dextratype(lsym, ot, t, 0)
 
 	case types.TCHAN:
 		// ../../../../runtime/type.go:/chanType
-		s1 := WriteType(t.Elem())
+		s1 := writeType(t.Elem())
 		ot = dcommontype(lsym, t)
 		ot = objw.SymPtr(lsym, ot, s1, 0)
 		ot = objw.Uintptr(lsym, ot, uint64(t.ChanDir()))
@@ -1009,15 +1009,15 @@ func WriteType(t *types.Type) *obj.LSym {
 
 	case types.TFUNC:
 		for _, t1 := range t.Recvs().Fields().Slice() {
-			WriteType(t1.Type)
+			writeType(t1.Type)
 		}
 		isddd := false
 		for _, t1 := range t.Params().Fields().Slice() {
 			isddd = t1.IsDDD()
-			WriteType(t1.Type)
+			writeType(t1.Type)
 		}
 		for _, t1 := range t.Results().Fields().Slice() {
-			WriteType(t1.Type)
+			writeType(t1.Type)
 		}
 
 		ot = dcommontype(lsym, t)
@@ -1037,20 +1037,20 @@ func WriteType(t *types.Type) *obj.LSym {
 
 		// Array of rtype pointers follows funcType.
 		for _, t1 := range t.Recvs().Fields().Slice() {
-			ot = objw.SymPtr(lsym, ot, WriteType(t1.Type), 0)
+			ot = objw.SymPtr(lsym, ot, writeType(t1.Type), 0)
 		}
 		for _, t1 := range t.Params().Fields().Slice() {
-			ot = objw.SymPtr(lsym, ot, WriteType(t1.Type), 0)
+			ot = objw.SymPtr(lsym, ot, writeType(t1.Type), 0)
 		}
 		for _, t1 := range t.Results().Fields().Slice() {
-			ot = objw.SymPtr(lsym, ot, WriteType(t1.Type), 0)
+			ot = objw.SymPtr(lsym, ot, writeType(t1.Type), 0)
 		}
 
 	case types.TINTER:
 		m := imethods(t)
 		n := len(m)
 		for _, a := range m {
-			WriteType(a.type_)
+			writeType(a.type_)
 		}
 
 		// ../../../../runtime/type.go:/interfaceType
@@ -1078,14 +1078,14 @@ func WriteType(t *types.Type) *obj.LSym {
 			nsym := dname(a.name.Name, "", pkg, exported)
 
 			ot = objw.SymPtrOff(lsym, ot, nsym)
-			ot = objw.SymPtrOff(lsym, ot, WriteType(a.type_))
+			ot = objw.SymPtrOff(lsym, ot, writeType(a.type_))
 		}
 
 	// ../../../../runtime/type.go:/mapType
 	case types.TMAP:
-		s1 := WriteType(t.Key())
-		s2 := WriteType(t.Elem())
-		s3 := WriteType(MapBucketType(t))
+		s1 := writeType(t.Key())
+		s2 := writeType(t.Elem())
+		s3 := writeType(MapBucketType(t))
 		hasher := genhash(t.Key())
 
 		ot = dcommontype(lsym, t)
@@ -1132,7 +1132,7 @@ func WriteType(t *types.Type) *obj.LSym {
 		}
 
 		// ../../../../runtime/type.go:/ptrType
-		s1 := WriteType(t.Elem())
+		s1 := writeType(t.Elem())
 
 		ot = dcommontype(lsym, t)
 		ot = objw.SymPtr(lsym, ot, s1, 0)
@@ -1143,7 +1143,7 @@ func WriteType(t *types.Type) *obj.LSym {
 	case types.TSTRUCT:
 		fields := t.Fields().Slice()
 		for _, t1 := range fields {
-			WriteType(t1.Type)
+			writeType(t1.Type)
 		}
 
 		// All non-exported struct field names within a struct
@@ -1171,7 +1171,7 @@ func WriteType(t *types.Type) *obj.LSym {
 		for _, f := range fields {
 			// ../../../../runtime/type.go:/structField
 			ot = dnameField(lsym, ot, spkg, f)
-			ot = objw.SymPtr(lsym, ot, WriteType(f.Type), 0)
+			ot = objw.SymPtr(lsym, ot, writeType(f.Type), 0)
 			offsetAnon := uint64(f.Offset) << 1
 			if offsetAnon>>1 != uint64(f.Offset) {
 				base.Fatalf("%v: bad field offset for %s", t, f.Sym.Name)
@@ -1326,9 +1326,9 @@ func WriteRuntimeTypes() {
 		sort.Sort(typesByString(signats))
 		for _, ts := range signats {
 			t := ts.t
-			WriteType(t)
+			writeType(t)
 			if t.Sym() != nil {
-				WriteType(types.NewPtr(t))
+				writeType(types.NewPtr(t))
 			}
 		}
 	}
@@ -1345,8 +1345,8 @@ func WriteTabs() {
 		//   _      [4]byte
 		//   fun    [1]uintptr // variable sized
 		// }
-		o := objw.SymPtr(i.lsym, 0, WriteType(i.itype), 0)
-		o = objw.SymPtr(i.lsym, o, WriteType(i.t), 0)
+		o := objw.SymPtr(i.lsym, 0, writeType(i.itype), 0)
+		o = objw.SymPtr(i.lsym, o, writeType(i.t), 0)
 		o = objw.Uint32(i.lsym, o, types.TypeHash(i.t)) // copy of type hash
 		o += 4                                          // skip unused field
 		for _, fn := range genfun(i.t, i.itype) {
@@ -1373,7 +1373,7 @@ func WriteTabs() {
 			if p.Class != ir.PFUNC {
 				t = types.NewPtr(t)
 			}
-			tsym := WriteType(t)
+			tsym := writeType(t)
 			ot = objw.SymPtrOff(s, ot, nsym)
 			ot = objw.SymPtrOff(s, ot, tsym)
 			// Plugin exports symbols as interfaces. Mark their types
@@ -1407,16 +1407,16 @@ func WriteBasicTypes() {
 	// but using runtime means fewer copies in object files.
 	if base.Ctxt.Pkgpath == "runtime" {
 		for i := types.Kind(1); i <= types.TBOOL; i++ {
-			WriteType(types.NewPtr(types.Types[i]))
+			writeType(types.NewPtr(types.Types[i]))
 		}
-		WriteType(types.NewPtr(types.Types[types.TSTRING]))
-		WriteType(types.NewPtr(types.Types[types.TUNSAFEPTR]))
+		writeType(types.NewPtr(types.Types[types.TSTRING]))
+		writeType(types.NewPtr(types.Types[types.TUNSAFEPTR]))
 
 		// emit type structs for error and func(error) string.
 		// The latter is the type of an auto-generated wrapper.
-		WriteType(types.NewPtr(types.ErrorType))
+		writeType(types.NewPtr(types.ErrorType))
 
-		WriteType(types.NewSignature(types.NoPkg, nil, []*types.Field{
+		writeType(types.NewSignature(types.NoPkg, nil, []*types.Field{
 			types.NewField(base.Pos, nil, types.ErrorType),
 		}, []*types.Field{
 			types.NewField(base.Pos, nil, types.Types[types.TSTRING]),
-- 
GitLab


From 502198c8dc325eb60ff7afb74358b3beffd9831c Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 14 Jan 2021 17:34:38 -0800
Subject: [PATCH 0493/2400] [dev.typeparams] cmd/compile/internal/types2:
 consistently report nil type as "untyped nil"

This fixes an inconsistency where the type for nil in code such as

	var x unsafe.Pointer = nil

and in conversions of the form

	T(nil)

(where T is a pointer, function, slice, map, channel, interface, or
unsafe.Pointer) was reported as (converted to) the respective type.
For all other operations that accept a nil value, we don't do this
conversion for nil.

(We never change the type of the untyped nil value, in contrast to
other untyped values where we give the values context-specific types.)

It may still be useful to change this behavior and - consistently -
report a converted nil type like we do for any other type, but for
now this CL simply fixes the existing inconsistency.

Added tests and fixed existing test harness.

Updates #13061.

Change-Id: Ia82832845c096e3cbc4a239ba3d6c8b9a9d274c9
Reviewed-on: https://go-review.googlesource.com/c/go/+/284052
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/types2/api_test.go   | 64 ++++++++++++++++---
 .../compile/internal/types2/conversions.go    |  4 +-
 src/cmd/compile/internal/types2/expr.go       |  1 +
 3 files changed, 58 insertions(+), 11 deletions(-)

diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go
index 81fc1243e9..9fcbfc469f 100644
--- a/src/cmd/compile/internal/types2/api_test.go
+++ b/src/cmd/compile/internal/types2/api_test.go
@@ -182,6 +182,9 @@ func TestValuesInfo(t *testing.T) {
 }
 
 func TestTypesInfo(t *testing.T) {
+	// Test sources that are not expected to typecheck must start with the broken prefix.
+	const broken = "package broken_"
+
 	var tests = []struct {
 		src  string
 		expr string // expression
@@ -194,6 +197,39 @@ func TestTypesInfo(t *testing.T) {
 		{`package b3; var x interface{} = 0i`, `0i`, `complex128`},
 		{`package b4; var x interface{} = "foo"`, `"foo"`, `string`},
 
+		// uses of nil
+		{`package n0; var _ *int = nil`, `nil`, `untyped nil`},
+		{`package n1; var _ func() = nil`, `nil`, `untyped nil`},
+		{`package n2; var _ []byte = nil`, `nil`, `untyped nil`},
+		{`package n3; var _ map[int]int = nil`, `nil`, `untyped nil`},
+		{`package n4; var _ chan int = nil`, `nil`, `untyped nil`},
+		{`package n5; var _ interface{} = nil`, `nil`, `untyped nil`},
+		{`package n6; import "unsafe"; var _ unsafe.Pointer = nil`, `nil`, `untyped nil`},
+
+		{`package n10; var (x *int; _ = x == nil)`, `nil`, `untyped nil`},
+		{`package n11; var (x func(); _ = x == nil)`, `nil`, `untyped nil`},
+		{`package n12; var (x []byte; _ = x == nil)`, `nil`, `untyped nil`},
+		{`package n13; var (x map[int]int; _ = x == nil)`, `nil`, `untyped nil`},
+		{`package n14; var (x chan int; _ = x == nil)`, `nil`, `untyped nil`},
+		{`package n15; var (x interface{}; _ = x == nil)`, `nil`, `untyped nil`},
+		{`package n15; import "unsafe"; var (x unsafe.Pointer; _ = x == nil)`, `nil`, `untyped nil`},
+
+		{`package n20; var _ = (*int)(nil)`, `nil`, `untyped nil`},
+		{`package n21; var _ = (func())(nil)`, `nil`, `untyped nil`},
+		{`package n22; var _ = ([]byte)(nil)`, `nil`, `untyped nil`},
+		{`package n23; var _ = (map[int]int)(nil)`, `nil`, `untyped nil`},
+		{`package n24; var _ = (chan int)(nil)`, `nil`, `untyped nil`},
+		{`package n25; var _ = (interface{})(nil)`, `nil`, `untyped nil`},
+		{`package n26; import "unsafe"; var _ = unsafe.Pointer(nil)`, `nil`, `untyped nil`},
+
+		{`package n30; func f(*int) { f(nil) }`, `nil`, `untyped nil`},
+		{`package n31; func f(func()) { f(nil) }`, `nil`, `untyped nil`},
+		{`package n32; func f([]byte) { f(nil) }`, `nil`, `untyped nil`},
+		{`package n33; func f(map[int]int) { f(nil) }`, `nil`, `untyped nil`},
+		{`package n34; func f(chan int) { f(nil) }`, `nil`, `untyped nil`},
+		{`package n35; func f(interface{}) { f(nil) }`, `nil`, `untyped nil`},
+		{`package n35; import "unsafe"; func f(unsafe.Pointer) { f(nil) }`, `nil`, `untyped nil`},
+
 		// comma-ok expressions
 		{`package p0; var x interface{}; var _, _ = x.(int)`,
 			`x.(int)`,
@@ -275,25 +311,25 @@ func TestTypesInfo(t *testing.T) {
 		},
 
 		// tests for broken code that doesn't parse or type-check
-		{`package x0; func _() { var x struct {f string}; x.f := 0 }`, `x.f`, `string`},
-		{`package x1; func _() { var z string; type x struct {f string}; y := &x{q: z}}`, `z`, `string`},
-		{`package x2; func _() { var a, b string; type x struct {f string}; z := &x{f: a, f: b,}}`, `b`, `string`},
-		{`package x3; var x = panic("");`, `panic`, `func(interface{})`},
+		{broken + `x0; func _() { var x struct {f string}; x.f := 0 }`, `x.f`, `string`},
+		{broken + `x1; func _() { var z string; type x struct {f string}; y := &x{q: z}}`, `z`, `string`},
+		{broken + `x2; func _() { var a, b string; type x struct {f string}; z := &x{f: a, f: b,}}`, `b`, `string`},
+		{broken + `x3; var x = panic("");`, `panic`, `func(interface{})`},
 		{`package x4; func _() { panic("") }`, `panic`, `func(interface{})`},
-		{`package x5; func _() { var x map[string][...]int; x = map[string][...]int{"": {1,2,3}} }`, `x`, `map[string][-1]int`},
+		{broken + `x5; func _() { var x map[string][...]int; x = map[string][...]int{"": {1,2,3}} }`, `x`, `map[string][-1]int`},
 
 		// parameterized functions
 		{`package p0; func f[T any](T); var _ = f[int]`, `f`, `func[T₁ any](T₁)`},
 		{`package p1; func f[T any](T); var _ = f[int]`, `f[int]`, `func(int)`},
-		{`package p2; func f[T any](T); var _ = f(42)`, `f`, `func[T₁ any](T₁)`},
-		{`package p2; func f[T any](T); var _ = f(42)`, `f(42)`, `()`},
+		{`package p2; func f[T any](T); func _() { f(42) }`, `f`, `func[T₁ any](T₁)`},
+		{`package p3; func f[T any](T); func _() { f(42) }`, `f(42)`, `()`},
 
 		// type parameters
 		{`package t0; type t[] int; var _ t`, `t`, `t0.t`}, // t[] is a syntax error that is ignored in this test in favor of t
 		{`package t1; type t[P any] int; var _ t[int]`, `t`, `t1.t[P₁ any]`},
 		{`package t2; type t[P interface{}] int; var _ t[int]`, `t`, `t2.t[P₁ interface{}]`},
 		{`package t3; type t[P, Q interface{}] int; var _ t[int, int]`, `t`, `t3.t[P₁, Q₂ interface{}]`},
-		{`package t4; type t[P, Q interface{ m() }] int; var _ t[int, int]`, `t`, `t4.t[P₁, Q₂ interface{m()}]`},
+		{broken + `t4; type t[P, Q interface{ m() }] int; var _ t[int, int]`, `t`, `broken_t4.t[P₁, Q₂ interface{m()}]`},
 
 		// instantiated types must be sanitized
 		{`package g0; type t[P any] int; var x struct{ f t[int] }; var _ = x.f`, `x.f`, `g0.t[int]`},
@@ -301,7 +337,17 @@ func TestTypesInfo(t *testing.T) {
 
 	for _, test := range tests {
 		info := Info{Types: make(map[syntax.Expr]TypeAndValue)}
-		name, _ := mayTypecheck(t, "TypesInfo", test.src, &info)
+		var name string
+		if strings.HasPrefix(test.src, broken) {
+			var err error
+			name, err = mayTypecheck(t, "TypesInfo", test.src, &info)
+			if err == nil {
+				t.Errorf("package %s: expected to fail but passed", name)
+				continue
+			}
+		} else {
+			name = mustTypecheck(t, "TypesInfo", test.src, &info)
+		}
 
 		// look for expression type
 		var typ Type
diff --git a/src/cmd/compile/internal/types2/conversions.go b/src/cmd/compile/internal/types2/conversions.go
index 0f6a990935..2a7b54a49c 100644
--- a/src/cmd/compile/internal/types2/conversions.go
+++ b/src/cmd/compile/internal/types2/conversions.go
@@ -56,8 +56,8 @@ func (check *Checker) conversion(x *operand, T Type) {
 		// - Keep untyped nil for untyped nil arguments.
 		// - For integer to string conversions, keep the argument type.
 		//   (See also the TODO below.)
-		if IsInterface(T) || constArg && !isConstType(T) {
-			final = Default(x.typ)
+		if IsInterface(T) || constArg && !isConstType(T) || x.isNil() {
+			final = Default(x.typ) // default type of untyped nil is untyped nil
 		} else if isInteger(x.typ) && isString(T) {
 			final = x.typ
 		}
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 736d3bfacc..7fca5db7d7 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -667,6 +667,7 @@ func (check *Checker) convertUntypedInternal(x *operand, target Type) {
 				if !hasNil(target) {
 					goto Error
 				}
+				target = Typ[UntypedNil]
 			default:
 				goto Error
 			}
-- 
GitLab


From c9b1445ac830891e2ebb7a4c3ce278309bdcc764 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Fri, 15 Jan 2021 22:21:33 +0700
Subject: [PATCH 0494/2400] [dev.regabi] cmd/compile: remove TypeAssertExpr
 {Src,Dst}Type fields

CL 283233 added reflectType method to ssagen.state, which we can use to
setup type address in the SSA backend in favor of the frontend. However,
this will change the order of symbols generation, so not safe for toolstash.

Change-Id: Ib6932ec42a9d28c3fd7a1c055596e75494c29843
Reviewed-on: https://go-review.googlesource.com/c/go/+/284115
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/expr.go    | 8 +++-----
 src/cmd/compile/internal/ssagen/ssa.go | 6 +++---
 src/cmd/compile/internal/walk/expr.go  | 5 -----
 3 files changed, 6 insertions(+), 13 deletions(-)

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 39659c45c0..5b1be7fc0f 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -615,11 +615,9 @@ type TypeAssertExpr struct {
 	X     Node
 	Ntype Ntype
 
-	// Runtime type information provided by walkDotType.
-	// Caution: These aren't always populated; see walkDotType.
-	SrcType *AddrExpr `mknode:"-"` // *runtime._type for X's type
-	DstType *AddrExpr `mknode:"-"` // *runtime._type for Type
-	Itab    *AddrExpr `mknode:"-"` // *runtime.itab for Type implementing X's type
+	// Runtime type information provided by walkDotType for
+	// assertions from non-empty interface to concrete type.
+	Itab *AddrExpr `mknode:"-"` // *runtime.itab for Type implementing X's type
 }
 
 func NewTypeAssertExpr(pos src.XPos, x Node, typ Ntype) *TypeAssertExpr {
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index c48ac22d2a..48942e01d6 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -6110,8 +6110,8 @@ func (s *state) floatToUint(cvttab *f2uCvtTab, n ir.Node, x *ssa.Value, ft, tt *
 // commaok indicates whether to panic or return a bool.
 // If commaok is false, resok will be nil.
 func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Value) {
-	iface := s.expr(n.X)        // input interface
-	target := s.expr(n.DstType) // target type
+	iface := s.expr(n.X)              // input interface
+	target := s.reflectType(n.Type()) // target type
 	byteptr := s.f.Config.Types.BytePtr
 
 	if n.Type().IsInterface() {
@@ -6245,7 +6245,7 @@ func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Val
 	if !commaok {
 		// on failure, panic by calling panicdottype
 		s.startBlock(bFail)
-		taddr := s.expr(n.SrcType)
+		taddr := s.reflectType(n.X.Type())
 		if n.X.Type().IsEmptyInterface() {
 			s.rtcall(ir.Syms.PanicdottypeE, false, nil, itab, target, taddr)
 		} else {
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 449f8ea3ec..c9b7c0704e 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -619,11 +619,6 @@ func walkDot(n *ir.SelectorExpr, init *ir.Nodes) ir.Node {
 func walkDotType(n *ir.TypeAssertExpr, init *ir.Nodes) ir.Node {
 	n.X = walkExpr(n.X, init)
 	// Set up interface type addresses for back end.
-
-	n.DstType = reflectdata.TypePtr(n.Type())
-	if n.Op() == ir.ODOTTYPE {
-		n.SrcType = reflectdata.TypePtr(n.X.Type())
-	}
 	if !n.Type().IsInterface() && !n.X.Type().IsEmptyInterface() {
 		n.Itab = reflectdata.ITabAddr(n.Type(), n.X.Type())
 	}
-- 
GitLab


From ab3b67abfd9bff30fc001c966ab121bacff3de9b Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Fri, 15 Jan 2021 23:20:13 +0700
Subject: [PATCH 0495/2400] [dev.regabi] cmd/compile: remove ONEWOBJ

After CL 283233, SSA can now handle new(typ) without the frontend to
generate the type address, so we can remove ONEWOBJ in favor of ONEW
only.

This is also not save for toolstash, the same reason with CL 284115.

Change-Id: Ie03ea36b3b6f95fc7ce080376c6f7afc402d51a3
Reviewed-on: https://go-review.googlesource.com/c/go/+/284117
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/expr.go      |   2 +-
 src/cmd/compile/internal/ir/node.go      |   1 -
 src/cmd/compile/internal/ir/op_string.go | 143 +++++++++++------------
 src/cmd/compile/internal/ssagen/ssa.go   |   2 +-
 src/cmd/compile/internal/walk/builtin.go |  20 ++--
 src/cmd/compile/internal/walk/convert.go |   6 +-
 src/cmd/compile/internal/walk/expr.go    |   2 +-
 src/cmd/compile/internal/walk/walk.go    |   2 +-
 8 files changed, 87 insertions(+), 91 deletions(-)

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 5b1be7fc0f..dd91e347bd 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -657,7 +657,7 @@ func (n *UnaryExpr) SetOp(op Op) {
 	case OBITNOT, ONEG, ONOT, OPLUS, ORECV,
 		OALIGNOF, OCAP, OCLOSE, OIMAG, OLEN, ONEW,
 		OOFFSETOF, OPANIC, OREAL, OSIZEOF,
-		OCHECKNIL, OCFUNC, OIDATA, OITAB, ONEWOBJ, OSPTR, OVARDEF, OVARKILL, OVARLIVE:
+		OCHECKNIL, OCFUNC, OIDATA, OITAB, OSPTR, OVARDEF, OVARKILL, OVARLIVE:
 		n.op = op
 	}
 }
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index a1b09b38cc..de03800da2 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -216,7 +216,6 @@ const (
 	OAND         // Left & Right
 	OANDNOT      // Left &^ Right
 	ONEW         // new(Left); corresponds to calls to new in source code
-	ONEWOBJ      // runtime.newobject(n.Type); introduced by walk; Left is type descriptor
 	ONOT         // !Left
 	OBITNOT      // ^Left
 	OPLUS        // +Left
diff --git a/src/cmd/compile/internal/ir/op_string.go b/src/cmd/compile/internal/ir/op_string.go
index b54b4785a2..9538599c38 100644
--- a/src/cmd/compile/internal/ir/op_string.go
+++ b/src/cmd/compile/internal/ir/op_string.go
@@ -91,81 +91,80 @@ func _() {
 	_ = x[OAND-80]
 	_ = x[OANDNOT-81]
 	_ = x[ONEW-82]
-	_ = x[ONEWOBJ-83]
-	_ = x[ONOT-84]
-	_ = x[OBITNOT-85]
-	_ = x[OPLUS-86]
-	_ = x[ONEG-87]
-	_ = x[OOROR-88]
-	_ = x[OPANIC-89]
-	_ = x[OPRINT-90]
-	_ = x[OPRINTN-91]
-	_ = x[OPAREN-92]
-	_ = x[OSEND-93]
-	_ = x[OSLICE-94]
-	_ = x[OSLICEARR-95]
-	_ = x[OSLICESTR-96]
-	_ = x[OSLICE3-97]
-	_ = x[OSLICE3ARR-98]
-	_ = x[OSLICEHEADER-99]
-	_ = x[ORECOVER-100]
-	_ = x[ORECV-101]
-	_ = x[ORUNESTR-102]
-	_ = x[OSELRECV2-103]
-	_ = x[OIOTA-104]
-	_ = x[OREAL-105]
-	_ = x[OIMAG-106]
-	_ = x[OCOMPLEX-107]
-	_ = x[OALIGNOF-108]
-	_ = x[OOFFSETOF-109]
-	_ = x[OSIZEOF-110]
-	_ = x[OMETHEXPR-111]
-	_ = x[OSTMTEXPR-112]
-	_ = x[OBLOCK-113]
-	_ = x[OBREAK-114]
-	_ = x[OCASE-115]
-	_ = x[OCONTINUE-116]
-	_ = x[ODEFER-117]
-	_ = x[OFALL-118]
-	_ = x[OFOR-119]
-	_ = x[OFORUNTIL-120]
-	_ = x[OGOTO-121]
-	_ = x[OIF-122]
-	_ = x[OLABEL-123]
-	_ = x[OGO-124]
-	_ = x[ORANGE-125]
-	_ = x[ORETURN-126]
-	_ = x[OSELECT-127]
-	_ = x[OSWITCH-128]
-	_ = x[OTYPESW-129]
-	_ = x[OTCHAN-130]
-	_ = x[OTMAP-131]
-	_ = x[OTSTRUCT-132]
-	_ = x[OTINTER-133]
-	_ = x[OTFUNC-134]
-	_ = x[OTARRAY-135]
-	_ = x[OTSLICE-136]
-	_ = x[OINLCALL-137]
-	_ = x[OEFACE-138]
-	_ = x[OITAB-139]
-	_ = x[OIDATA-140]
-	_ = x[OSPTR-141]
-	_ = x[OCFUNC-142]
-	_ = x[OCHECKNIL-143]
-	_ = x[OVARDEF-144]
-	_ = x[OVARKILL-145]
-	_ = x[OVARLIVE-146]
-	_ = x[ORESULT-147]
-	_ = x[OINLMARK-148]
-	_ = x[ONAMEOFFSET-149]
-	_ = x[ORETJMP-150]
-	_ = x[OGETG-151]
-	_ = x[OEND-152]
+	_ = x[ONOT-83]
+	_ = x[OBITNOT-84]
+	_ = x[OPLUS-85]
+	_ = x[ONEG-86]
+	_ = x[OOROR-87]
+	_ = x[OPANIC-88]
+	_ = x[OPRINT-89]
+	_ = x[OPRINTN-90]
+	_ = x[OPAREN-91]
+	_ = x[OSEND-92]
+	_ = x[OSLICE-93]
+	_ = x[OSLICEARR-94]
+	_ = x[OSLICESTR-95]
+	_ = x[OSLICE3-96]
+	_ = x[OSLICE3ARR-97]
+	_ = x[OSLICEHEADER-98]
+	_ = x[ORECOVER-99]
+	_ = x[ORECV-100]
+	_ = x[ORUNESTR-101]
+	_ = x[OSELRECV2-102]
+	_ = x[OIOTA-103]
+	_ = x[OREAL-104]
+	_ = x[OIMAG-105]
+	_ = x[OCOMPLEX-106]
+	_ = x[OALIGNOF-107]
+	_ = x[OOFFSETOF-108]
+	_ = x[OSIZEOF-109]
+	_ = x[OMETHEXPR-110]
+	_ = x[OSTMTEXPR-111]
+	_ = x[OBLOCK-112]
+	_ = x[OBREAK-113]
+	_ = x[OCASE-114]
+	_ = x[OCONTINUE-115]
+	_ = x[ODEFER-116]
+	_ = x[OFALL-117]
+	_ = x[OFOR-118]
+	_ = x[OFORUNTIL-119]
+	_ = x[OGOTO-120]
+	_ = x[OIF-121]
+	_ = x[OLABEL-122]
+	_ = x[OGO-123]
+	_ = x[ORANGE-124]
+	_ = x[ORETURN-125]
+	_ = x[OSELECT-126]
+	_ = x[OSWITCH-127]
+	_ = x[OTYPESW-128]
+	_ = x[OTCHAN-129]
+	_ = x[OTMAP-130]
+	_ = x[OTSTRUCT-131]
+	_ = x[OTINTER-132]
+	_ = x[OTFUNC-133]
+	_ = x[OTARRAY-134]
+	_ = x[OTSLICE-135]
+	_ = x[OINLCALL-136]
+	_ = x[OEFACE-137]
+	_ = x[OITAB-138]
+	_ = x[OIDATA-139]
+	_ = x[OSPTR-140]
+	_ = x[OCFUNC-141]
+	_ = x[OCHECKNIL-142]
+	_ = x[OVARDEF-143]
+	_ = x[OVARKILL-144]
+	_ = x[OVARLIVE-145]
+	_ = x[ORESULT-146]
+	_ = x[OINLMARK-147]
+	_ = x[ONAMEOFFSET-148]
+	_ = x[ORETJMP-149]
+	_ = x[OGETG-150]
+	_ = x[OEND-151]
 }
 
-const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNEWOBJNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKNAMEOFFSETRETJMPGETGEND"
+const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKNAMEOFFSETRETJMPGETGEND"
 
-var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 388, 391, 400, 403, 407, 415, 422, 431, 444, 447, 450, 453, 456, 459, 462, 468, 471, 477, 480, 486, 490, 493, 497, 502, 507, 513, 518, 522, 527, 535, 543, 549, 558, 569, 576, 580, 587, 595, 599, 603, 607, 614, 621, 629, 635, 643, 651, 656, 661, 665, 673, 678, 682, 685, 693, 697, 699, 704, 706, 711, 717, 723, 729, 735, 740, 744, 751, 757, 762, 768, 774, 781, 786, 790, 795, 799, 804, 812, 818, 825, 832, 838, 845, 855, 861, 865, 868}
+var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 388, 391, 400, 403, 407, 415, 422, 431, 444, 447, 450, 453, 456, 459, 462, 468, 471, 474, 480, 484, 487, 491, 496, 501, 507, 512, 516, 521, 529, 537, 543, 552, 563, 570, 574, 581, 589, 593, 597, 601, 608, 615, 623, 629, 637, 645, 650, 655, 659, 667, 672, 676, 679, 687, 691, 693, 698, 700, 705, 711, 717, 723, 729, 734, 738, 745, 751, 756, 762, 768, 775, 780, 784, 789, 793, 798, 806, 812, 819, 826, 832, 839, 849, 855, 859, 862}
 
 func (i Op) String() string {
 	if i >= Op(len(_Op_index)-1) {
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 48942e01d6..097cfacc23 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -3034,7 +3034,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		}
 		return s.zeroVal(n.Type())
 
-	case ir.ONEWOBJ:
+	case ir.ONEW:
 		n := n.(*ir.UnaryExpr)
 		return s.newObject(n.Type().Elem())
 
diff --git a/src/cmd/compile/internal/walk/builtin.go b/src/cmd/compile/internal/walk/builtin.go
index a061181e2f..18ff702248 100644
--- a/src/cmd/compile/internal/walk/builtin.go
+++ b/src/cmd/compile/internal/walk/builtin.go
@@ -501,18 +501,21 @@ func walkMakeSliceCopy(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
 
 // walkNew walks an ONEW node.
 func walkNew(n *ir.UnaryExpr, init *ir.Nodes) ir.Node {
-	if n.Type().Elem().NotInHeap() {
+	t := n.Type().Elem()
+	if t.NotInHeap() {
 		base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", n.Type().Elem())
 	}
 	if n.Esc() == ir.EscNone {
-		if n.Type().Elem().Width >= ir.MaxImplicitStackVarSize {
+		if t.Size() >= ir.MaxImplicitStackVarSize {
 			base.Fatalf("large ONEW with EscNone: %v", n)
 		}
-		r := typecheck.Temp(n.Type().Elem())
+		r := typecheck.Temp(t)
 		init.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, r, nil))) // zero temp
 		return typecheck.Expr(typecheck.NodAddr(r))
 	}
-	return callnew(n.Type().Elem())
+	types.CalcSize(t)
+	n.MarkNonNil()
+	return n
 }
 
 // generate code for print
@@ -678,15 +681,6 @@ func badtype(op ir.Op, tl, tr *types.Type) {
 	base.Errorf("illegal types for operand: %v%s", op, s)
 }
 
-func callnew(t *types.Type) ir.Node {
-	types.CalcSize(t)
-	n := ir.NewUnaryExpr(base.Pos, ir.ONEWOBJ, reflectdata.TypePtr(t))
-	n.SetType(types.NewPtr(t))
-	n.SetTypecheck(1)
-	n.MarkNonNil()
-	return n
-}
-
 func writebarrierfn(name string, l *types.Type, r *types.Type) ir.Node {
 	fn := typecheck.LookupRuntime(name)
 	fn = typecheck.SubstArgTypes(fn, l, r)
diff --git a/src/cmd/compile/internal/walk/convert.go b/src/cmd/compile/internal/walk/convert.go
index 85459fd92f..848aee3938 100644
--- a/src/cmd/compile/internal/walk/convert.go
+++ b/src/cmd/compile/internal/walk/convert.go
@@ -248,7 +248,11 @@ func walkStringToBytes(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 		if n.Esc() == ir.EscNone && len(sc) <= int(ir.MaxImplicitStackVarSize) {
 			a = typecheck.NodAddr(typecheck.Temp(t))
 		} else {
-			a = callnew(t)
+			types.CalcSize(t)
+			a = ir.NewUnaryExpr(base.Pos, ir.ONEW, nil)
+			a.SetType(types.NewPtr(t))
+			a.SetTypecheck(1)
+			a.MarkNonNil()
 		}
 		p := typecheck.Temp(t.PtrTo()) // *[n]byte
 		init.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, p, a)))
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index c9b7c0704e..253634a60f 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -84,7 +84,7 @@ func walkExpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		base.Fatalf("walkexpr: switch 1 unknown op %+v", n.Op())
 		panic("unreachable")
 
-	case ir.ONONAME, ir.OGETG, ir.ONEWOBJ:
+	case ir.ONONAME, ir.OGETG:
 		return n
 
 	case ir.OTYPE, ir.ONAME, ir.OLITERAL, ir.ONIL, ir.ONAMEOFFSET:
diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index 71f018fe3e..4ba81b82fe 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -358,7 +358,7 @@ func calcHasCall(n ir.Node) bool {
 	case ir.OBITNOT, ir.ONOT, ir.OPLUS, ir.ORECV,
 		ir.OALIGNOF, ir.OCAP, ir.OCLOSE, ir.OIMAG, ir.OLEN, ir.ONEW,
 		ir.OOFFSETOF, ir.OPANIC, ir.OREAL, ir.OSIZEOF,
-		ir.OCHECKNIL, ir.OCFUNC, ir.OIDATA, ir.OITAB, ir.ONEWOBJ, ir.OSPTR, ir.OVARDEF, ir.OVARKILL, ir.OVARLIVE:
+		ir.OCHECKNIL, ir.OCFUNC, ir.OIDATA, ir.OITAB, ir.OSPTR, ir.OVARDEF, ir.OVARKILL, ir.OVARLIVE:
 		n := n.(*ir.UnaryExpr)
 		return n.X.HasCall()
 	case ir.ODOT, ir.ODOTMETH, ir.ODOTINTER:
-- 
GitLab


From a956a0e909e1d60c8d55339e5e591a9d1db885c4 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Fri, 15 Jan 2021 14:12:35 -0800
Subject: [PATCH 0496/2400] [dev.regabi] cmd/compile, runtime: fix up
 comments/error messages from recent renames

Went in a semi-automated way through the clearest renames of functions,
and updated comments and error messages where it made sense.

Change-Id: Ied8e152b562b705da7f52f715991a77dab60da35
Reviewed-on: https://go-review.googlesource.com/c/go/+/284216
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/asm/internal/asm/parse.go             |  2 +-
 src/cmd/compile/internal/base/flag.go         |  2 +-
 src/cmd/compile/internal/base/print.go        |  2 +-
 src/cmd/compile/internal/bitvec/bv.go         |  2 +-
 src/cmd/compile/internal/escape/escape.go     |  4 +-
 src/cmd/compile/internal/gc/compile.go        |  2 +-
 src/cmd/compile/internal/gc/main.go           |  8 ++--
 src/cmd/compile/internal/gc/obj.go            |  2 +-
 src/cmd/compile/internal/inline/inl.go        | 10 ++---
 src/cmd/compile/internal/ir/const.go          |  2 +-
 src/cmd/compile/internal/ir/func.go           |  2 +-
 src/cmd/compile/internal/ir/stmt.go           |  4 +-
 src/cmd/compile/internal/liveness/bvset.go    |  2 +-
 src/cmd/compile/internal/liveness/plive.go    |  2 +-
 src/cmd/compile/internal/noder/import.go      |  2 +-
 src/cmd/compile/internal/noder/noder.go       |  8 ++--
 src/cmd/compile/internal/objw/prog.go         |  2 +-
 src/cmd/compile/internal/pkginit/init.go      |  4 +-
 src/cmd/compile/internal/reflectdata/alg.go   |  2 +-
 .../compile/internal/reflectdata/reflect.go   | 20 ++++-----
 src/cmd/compile/internal/ssagen/abi.go        |  2 +-
 src/cmd/compile/internal/ssagen/nowb.go       |  4 +-
 src/cmd/compile/internal/ssagen/pgen.go       |  2 +-
 src/cmd/compile/internal/ssagen/ssa.go        |  8 ++--
 src/cmd/compile/internal/staticdata/data.go   | 30 +++++++-------
 src/cmd/compile/internal/staticdata/embed.go  |  2 +-
 src/cmd/compile/internal/staticinit/sched.go  |  2 +-
 .../compile/internal/test/abiutilsaux_test.go |  2 +-
 .../test/testdata/reproducible/issue38068.go  |  2 +-
 src/cmd/compile/internal/typebits/typebits.go | 12 +++---
 src/cmd/compile/internal/typecheck/const.go   |  2 +-
 src/cmd/compile/internal/typecheck/dcl.go     | 12 +++---
 src/cmd/compile/internal/typecheck/expr.go    |  6 +--
 src/cmd/compile/internal/typecheck/func.go    | 20 ++++-----
 src/cmd/compile/internal/typecheck/iimport.go |  4 +-
 src/cmd/compile/internal/typecheck/stmt.go    |  8 ++--
 src/cmd/compile/internal/typecheck/subr.go    | 10 ++---
 src/cmd/compile/internal/typecheck/syms.go    |  4 +-
 .../compile/internal/typecheck/typecheck.go   |  8 ++--
 src/cmd/compile/internal/types/alg.go         |  4 +-
 src/cmd/compile/internal/types/fmt.go         |  2 +-
 src/cmd/compile/internal/types/size.go        | 41 +++++++++----------
 src/cmd/compile/internal/types/type.go        |  4 +-
 src/cmd/compile/internal/walk/builtin.go      |  6 +--
 src/cmd/compile/internal/walk/closure.go      |  2 +-
 src/cmd/compile/internal/walk/compare.go      |  4 +-
 src/cmd/compile/internal/walk/convert.go      |  4 +-
 src/cmd/compile/internal/walk/expr.go         | 14 +++----
 src/cmd/compile/internal/walk/order.go        |  6 +--
 src/cmd/compile/internal/walk/range.go        |  8 ++--
 src/cmd/compile/internal/walk/select.go       |  4 +-
 src/cmd/compile/internal/walk/switch.go       |  4 +-
 src/cmd/compile/internal/walk/walk.go         | 10 ++---
 src/cmd/internal/goobj/mkbuiltin.go           |  4 +-
 src/cmd/internal/obj/textflag.go              |  2 +-
 src/embed/embed.go                            |  4 +-
 src/reflect/type.go                           |  2 +-
 src/runtime/runtime2.go                       |  2 +-
 src/runtime/type.go                           |  2 +-
 59 files changed, 176 insertions(+), 177 deletions(-)

diff --git a/src/cmd/asm/internal/asm/parse.go b/src/cmd/asm/internal/asm/parse.go
index 154cf9c7a7..f1d37bc2c8 100644
--- a/src/cmd/asm/internal/asm/parse.go
+++ b/src/cmd/asm/internal/asm/parse.go
@@ -305,7 +305,7 @@ func (p *Parser) pseudo(word string, operands [][]lex.Token) bool {
 // references and writes symabis information to w.
 //
 // The symabis format is documented at
-// cmd/compile/internal/gc.readSymABIs.
+// cmd/compile/internal/ssagen.ReadSymABIs.
 func (p *Parser) symDefRef(w io.Writer, word string, operands [][]lex.Token) {
 	switch word {
 	case "TEXT":
diff --git a/src/cmd/compile/internal/base/flag.go b/src/cmd/compile/internal/base/flag.go
index d35b8452f9..c38bbe6272 100644
--- a/src/cmd/compile/internal/base/flag.go
+++ b/src/cmd/compile/internal/base/flag.go
@@ -174,7 +174,7 @@ func ParseFlags() {
 	if (*Flag.Shared || *Flag.Dynlink || *Flag.LinkShared) && !Ctxt.Arch.InFamily(sys.AMD64, sys.ARM, sys.ARM64, sys.I386, sys.PPC64, sys.RISCV64, sys.S390X) {
 		log.Fatalf("%s/%s does not support -shared", objabi.GOOS, objabi.GOARCH)
 	}
-	parseSpectre(Flag.Spectre) // left as string for recordFlags
+	parseSpectre(Flag.Spectre) // left as string for RecordFlags
 
 	Ctxt.Flag_shared = Ctxt.Flag_dynlink || Ctxt.Flag_shared
 	Ctxt.Flag_optimize = Flag.N == 0
diff --git a/src/cmd/compile/internal/base/print.go b/src/cmd/compile/internal/base/print.go
index 9855dfdad0..668c600d31 100644
--- a/src/cmd/compile/internal/base/print.go
+++ b/src/cmd/compile/internal/base/print.go
@@ -121,7 +121,7 @@ func ErrorfAt(pos src.XPos, format string, args ...interface{}) {
 		lasterror.syntax = pos
 	} else {
 		// only one of multiple equal non-syntax errors per line
-		// (flusherrors shows only one of them, so we filter them
+		// (FlushErrors shows only one of them, so we filter them
 		// here as best as we can (they may not appear in order)
 		// so that we don't count them here and exit early, and
 		// then have nothing to show for.)
diff --git a/src/cmd/compile/internal/bitvec/bv.go b/src/cmd/compile/internal/bitvec/bv.go
index 1e084576d1..bcac1fe351 100644
--- a/src/cmd/compile/internal/bitvec/bv.go
+++ b/src/cmd/compile/internal/bitvec/bv.go
@@ -37,7 +37,7 @@ func NewBulk(nbit int32, count int32) Bulk {
 	nword := (nbit + wordBits - 1) / wordBits
 	size := int64(nword) * int64(count)
 	if int64(int32(size*4)) != size*4 {
-		base.Fatalf("bvbulkalloc too big: nbit=%d count=%d nword=%d size=%d", nbit, count, nword, size)
+		base.Fatalf("NewBulk too big: nbit=%d count=%d nword=%d size=%d", nbit, count, nword, size)
 	}
 	return Bulk{
 		words: make([]uint32, size),
diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index 79e5a98c91..96c2e02146 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -856,7 +856,7 @@ func (e *escape) discards(l ir.Nodes) {
 	}
 }
 
-// addr evaluates an addressable expression n and returns an EscHole
+// addr evaluates an addressable expression n and returns a hole
 // that represents storing into the represented location.
 func (e *escape) addr(n ir.Node) hole {
 	if n == nil || ir.IsBlank(n) {
@@ -1785,7 +1785,7 @@ func (l leaks) Encode() string {
 	return s
 }
 
-// parseLeaks parses a binary string representing an EscLeaks.
+// parseLeaks parses a binary string representing a leaks
 func parseLeaks(s string) leaks {
 	var l leaks
 	if !strings.HasPrefix(s, "esc:") {
diff --git a/src/cmd/compile/internal/gc/compile.go b/src/cmd/compile/internal/gc/compile.go
index 6e347bf0f1..ba67c58c45 100644
--- a/src/cmd/compile/internal/gc/compile.go
+++ b/src/cmd/compile/internal/gc/compile.go
@@ -72,7 +72,7 @@ func enqueueFunc(fn *ir.Func) {
 func prepareFunc(fn *ir.Func) {
 	// Set up the function's LSym early to avoid data races with the assemblers.
 	// Do this before walk, as walk needs the LSym to set attributes/relocations
-	// (e.g. in markTypeUsedInInterface).
+	// (e.g. in MarkTypeUsedInInterface).
 	ssagen.InitLSym(fn, true)
 
 	// Calculate parameter offsets.
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 9ecdd510b1..e9ac243527 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -121,7 +121,7 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 		log.Fatalf("compiler not built with support for -t")
 	}
 
-	// Enable inlining (after recordFlags, to avoid recording the rewritten -l).  For now:
+	// Enable inlining (after RecordFlags, to avoid recording the rewritten -l).  For now:
 	//	default: inlining on.  (Flag.LowerL == 1)
 	//	-l: inlining off  (Flag.LowerL == 0)
 	//	-l=2, -l=3: inlining on again, with extra debugging (Flag.LowerL > 1)
@@ -193,7 +193,7 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	typecheck.Target = new(ir.Package)
 
 	typecheck.NeedITab = func(t, iface *types.Type) { reflectdata.ITabAddr(t, iface) }
-	typecheck.NeedRuntimeType = reflectdata.NeedRuntimeType // TODO(rsc): typenamesym for lock?
+	typecheck.NeedRuntimeType = reflectdata.NeedRuntimeType // TODO(rsc): TypeSym for lock?
 
 	base.AutogeneratedPos = makePos(src.NewFileBase("<autogenerated>", "<autogenerated>"), 1, 0)
 
@@ -261,7 +261,7 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	escape.Funcs(typecheck.Target.Decls)
 
 	// Collect information for go:nowritebarrierrec
-	// checking. This must happen before transformclosure.
+	// checking. This must happen before transforming closures during Walk
 	// We'll do the final check after write barriers are
 	// inserted.
 	if base.Flag.CompilingRuntime {
@@ -269,7 +269,7 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	}
 
 	// Prepare for SSA compilation.
-	// This must be before peekitabs, because peekitabs
+	// This must be before CompileITabs, because CompileITabs
 	// can trigger function compilation.
 	typecheck.InitRuntime()
 	ssagen.InitConfig()
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 3e55b7688e..847d849666 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -121,7 +121,7 @@ func dumpdata() {
 	reflectdata.WriteBasicTypes()
 	dumpembeds()
 
-	// Calls to dumpsignats can generate functions,
+	// Calls to WriteRuntimeTypes can generate functions,
 	// like method wrappers and hash and equality routines.
 	// Compile any generated functions, process any new resulting types, repeat.
 	// This can't loop forever, because there is no way to generate an infinite
diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 1811feebe9..4bb849cdae 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -4,7 +4,7 @@
 //
 // The inlining facility makes 2 passes: first caninl determines which
 // functions are suitable for inlining, and for those that are it
-// saves a copy of the body. Then inlcalls walks each function body to
+// saves a copy of the body. Then InlineCalls walks each function body to
 // expand calls to inlinable functions.
 //
 // The Debug.l flag controls the aggressiveness. Note that main() swaps level 0 and 1,
@@ -79,7 +79,7 @@ func InlinePackage() {
 // fn and ->nbody will already have been typechecked.
 func CanInline(fn *ir.Func) {
 	if fn.Nname == nil {
-		base.Fatalf("caninl no nname %+v", fn)
+		base.Fatalf("CanInline no nname %+v", fn)
 	}
 
 	var reason string // reason, if any, that the function was not inlined
@@ -144,7 +144,7 @@ func CanInline(fn *ir.Func) {
 	}
 
 	if fn.Typecheck() == 0 {
-		base.Fatalf("caninl on non-typechecked function %v", fn)
+		base.Fatalf("CanInline on non-typechecked function %v", fn)
 	}
 
 	n := fn.Nname
@@ -200,11 +200,11 @@ func Inline_Flood(n *ir.Name, exportsym func(*ir.Name)) {
 		return
 	}
 	if n.Op() != ir.ONAME || n.Class != ir.PFUNC {
-		base.Fatalf("inlFlood: unexpected %v, %v, %v", n, n.Op(), n.Class)
+		base.Fatalf("Inline_Flood: unexpected %v, %v, %v", n, n.Op(), n.Class)
 	}
 	fn := n.Func
 	if fn == nil {
-		base.Fatalf("inlFlood: missing Func on %v", n)
+		base.Fatalf("Inline_Flood: missing Func on %v", n)
 	}
 	if fn.Inl == nil {
 		return
diff --git a/src/cmd/compile/internal/ir/const.go b/src/cmd/compile/internal/ir/const.go
index bfa0136232..eaa4d5b6b1 100644
--- a/src/cmd/compile/internal/ir/const.go
+++ b/src/cmd/compile/internal/ir/const.go
@@ -77,7 +77,7 @@ func ConstOverflow(v constant.Value, t *types.Type) bool {
 		ft := types.FloatForComplex(t)
 		return ConstOverflow(constant.Real(v), ft) || ConstOverflow(constant.Imag(v), ft)
 	}
-	base.Fatalf("doesoverflow: %v, %v", v, t)
+	base.Fatalf("ConstOverflow: %v, %v", v, t)
 	panic("unreachable")
 }
 
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 30cddd298e..4afdadf57b 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -63,7 +63,7 @@ type Func struct {
 	Exit  Nodes
 
 	// ONAME nodes for all params/locals for this func/closure, does NOT
-	// include closurevars until transformclosure runs.
+	// include closurevars until transforming closures during walk.
 	// Names must be listed PPARAMs, PPARAMOUTs, then PAUTOs,
 	// with PPARAMs and PPARAMOUTs in order corresponding to the function signature.
 	// However, as anonymous or blank PPARAMs are not actually declared,
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index b13c6b7795..4e4c0df993 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -343,7 +343,7 @@ type SelectStmt struct {
 	HasBreak bool
 
 	// TODO(rsc): Instead of recording here, replace with a block?
-	Compiled Nodes // compiled form, after walkswitch
+	Compiled Nodes // compiled form, after walkSwitch
 }
 
 func NewSelectStmt(pos src.XPos, cases []*CommClause) *SelectStmt {
@@ -376,7 +376,7 @@ type SwitchStmt struct {
 	HasBreak bool
 
 	// TODO(rsc): Instead of recording here, replace with a block?
-	Compiled Nodes // compiled form, after walkswitch
+	Compiled Nodes // compiled form, after walkSwitch
 }
 
 func NewSwitchStmt(pos src.XPos, tag Node, cases []*CaseClause) *SwitchStmt {
diff --git a/src/cmd/compile/internal/liveness/bvset.go b/src/cmd/compile/internal/liveness/bvset.go
index 21bc1fee4d..3431f54ede 100644
--- a/src/cmd/compile/internal/liveness/bvset.go
+++ b/src/cmd/compile/internal/liveness/bvset.go
@@ -47,7 +47,7 @@ func (m *bvecSet) grow() {
 	m.index = newIndex
 }
 
-// add adds bv to the set and returns its index in m.extractUniqe.
+// add adds bv to the set and returns its index in m.extractUnique.
 // The caller must not modify bv after this.
 func (m *bvecSet) add(bv bitvec.BitVec) int {
 	if len(m.uniq)*4 >= len(m.index) {
diff --git a/src/cmd/compile/internal/liveness/plive.go b/src/cmd/compile/internal/liveness/plive.go
index abc9583d5a..c70db6ed18 100644
--- a/src/cmd/compile/internal/liveness/plive.go
+++ b/src/cmd/compile/internal/liveness/plive.go
@@ -1060,7 +1060,7 @@ func (lv *liveness) printDebug() {
 func (lv *liveness) emit() (argsSym, liveSym *obj.LSym) {
 	// Size args bitmaps to be just large enough to hold the largest pointer.
 	// First, find the largest Xoffset node we care about.
-	// (Nodes without pointers aren't in lv.vars; see livenessShouldTrack.)
+	// (Nodes without pointers aren't in lv.vars; see ShouldTrack.)
 	var maxArgNode *ir.Name
 	for _, n := range lv.vars {
 		switch n.Class {
diff --git a/src/cmd/compile/internal/noder/import.go b/src/cmd/compile/internal/noder/import.go
index 08f19a4028..ca041a156c 100644
--- a/src/cmd/compile/internal/noder/import.go
+++ b/src/cmd/compile/internal/noder/import.go
@@ -418,7 +418,7 @@ func clearImports() {
 		if types.IsDotAlias(s) {
 			// throw away top-level name left over
 			// from previous import . "x"
-			// We'll report errors after type checking in checkDotImports.
+			// We'll report errors after type checking in CheckDotImports.
 			s.Def = nil
 			continue
 		}
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index edd30a1fc1..99c0e4adde 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -86,7 +86,7 @@ func ParseFiles(filenames []string) uint {
 		if base.SyntaxErrors() != 0 {
 			base.ErrorExit()
 		}
-		// Always run testdclstack here, even when debug_dclstack is not set, as a sanity measure.
+		// Always run CheckDclstack here, even when debug_dclstack is not set, as a sanity measure.
 		types.CheckDclstack()
 	}
 
@@ -638,7 +638,7 @@ func (p *noder) funcDecl(fun *syntax.FuncDecl) ir.Node {
 		}
 	} else {
 		f.Shortname = name
-		name = ir.BlankNode.Sym() // filled in by typecheckfunc
+		name = ir.BlankNode.Sym() // filled in by tcFunc
 	}
 
 	f.Nname = ir.NewNameAt(p.pos(fun.Name), name)
@@ -1084,7 +1084,7 @@ func (p *noder) stmtsFall(stmts []syntax.Stmt, fallOK bool) []ir.Node {
 		if s == nil {
 		} else if s.Op() == ir.OBLOCK && len(s.(*ir.BlockStmt).List) > 0 {
 			// Inline non-empty block.
-			// Empty blocks must be preserved for checkreturn.
+			// Empty blocks must be preserved for CheckReturn.
 			nodes = append(nodes, s.(*ir.BlockStmt).List...)
 		} else {
 			nodes = append(nodes, s)
@@ -1860,7 +1860,7 @@ func (p *noder) funcLit(expr *syntax.FuncLit) ir.Node {
 	fn := ir.NewFunc(p.pos(expr))
 	fn.SetIsHiddenClosure(ir.CurFunc != nil)
 
-	fn.Nname = ir.NewNameAt(p.pos(expr), ir.BlankNode.Sym()) // filled in by typecheckclosure
+	fn.Nname = ir.NewNameAt(p.pos(expr), ir.BlankNode.Sym()) // filled in by tcClosure
 	fn.Nname.Func = fn
 	fn.Nname.Ntype = xtype
 	fn.Nname.Defn = fn
diff --git a/src/cmd/compile/internal/objw/prog.go b/src/cmd/compile/internal/objw/prog.go
index 8d24f94aa5..b5ac4dda1e 100644
--- a/src/cmd/compile/internal/objw/prog.go
+++ b/src/cmd/compile/internal/objw/prog.go
@@ -205,7 +205,7 @@ func (pp *Progs) Append(p *obj.Prog, as obj.As, ftype obj.AddrType, freg int16,
 
 func (pp *Progs) SetText(fn *ir.Func) {
 	if pp.Text != nil {
-		base.Fatalf("Progs.settext called twice")
+		base.Fatalf("Progs.SetText called twice")
 	}
 	ptxt := pp.Prog(obj.ATEXT)
 	pp.Text = ptxt
diff --git a/src/cmd/compile/internal/pkginit/init.go b/src/cmd/compile/internal/pkginit/init.go
index 5bc66c7e1b..7cad262214 100644
--- a/src/cmd/compile/internal/pkginit/init.go
+++ b/src/cmd/compile/internal/pkginit/init.go
@@ -60,10 +60,10 @@ func Task() *ir.Name {
 		fns = append(fns, fn.Linksym())
 	}
 	if typecheck.InitTodoFunc.Dcl != nil {
-		// We only generate temps using initTodo if there
+		// We only generate temps using InitTodoFunc if there
 		// are package-scope initialization statements, so
 		// something's weird if we get here.
-		base.Fatalf("initTodo still has declarations")
+		base.Fatalf("InitTodoFunc still has declarations")
 	}
 	typecheck.InitTodoFunc = nil
 
diff --git a/src/cmd/compile/internal/reflectdata/alg.go b/src/cmd/compile/internal/reflectdata/alg.go
index d576053753..fcd824f164 100644
--- a/src/cmd/compile/internal/reflectdata/alg.go
+++ b/src/cmd/compile/internal/reflectdata/alg.go
@@ -689,7 +689,7 @@ func EqString(s, t ir.Node) (eqlen *ir.BinaryExpr, eqmem *ir.CallExpr) {
 // eqtab must be evaluated before eqdata, and shortcircuiting is required.
 func EqInterface(s, t ir.Node) (eqtab *ir.BinaryExpr, eqdata *ir.CallExpr) {
 	if !types.Identical(s.Type(), t.Type()) {
-		base.Fatalf("eqinterface %v %v", s.Type(), t.Type())
+		base.Fatalf("EqInterface %v %v", s.Type(), t.Type())
 	}
 	// func ifaceeq(tab *uintptr, x, y unsafe.Pointer) (ret bool)
 	// func efaceeq(typ *uintptr, x, y unsafe.Pointer) (ret bool)
diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index 989bcf9ab9..efe863cc3f 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -32,7 +32,7 @@ type itabEntry struct {
 
 	// symbols of each method in
 	// the itab, sorted by byte offset;
-	// filled in by peekitabs
+	// filled in by CompileITabs
 	entries []*obj.LSym
 }
 
@@ -401,7 +401,7 @@ func dimportpath(p *types.Pkg) {
 	}
 
 	// If we are compiling the runtime package, there are two runtime packages around
-	// -- localpkg and Runtimepkg. We don't want to produce import path symbols for
+	// -- localpkg and Pkgs.Runtime. We don't want to produce import path symbols for
 	// both of them, so just produce one for localpkg.
 	if base.Ctxt.Pkgpath == "runtime" && p == ir.Pkgs.Runtime {
 		return
@@ -811,7 +811,7 @@ func TypeSymPrefix(prefix string, t *types.Type) *types.Sym {
 
 func TypeSym(t *types.Type) *types.Sym {
 	if t == nil || (t.IsPtr() && t.Elem() == nil) || t.IsUntyped() {
-		base.Fatalf("typenamesym %v", t)
+		base.Fatalf("TypeSym %v", t)
 	}
 	if t.Kind() == types.TFUNC && t.Recv() != nil {
 		base.Fatalf("misuse of method type: %v", t)
@@ -853,7 +853,7 @@ func TypePtr(t *types.Type) *ir.AddrExpr {
 
 func ITabAddr(t, itype *types.Type) *ir.AddrExpr {
 	if t == nil || (t.IsPtr() && t.Elem() == nil) || t.IsUntyped() || !itype.IsInterface() || itype.IsEmptyInterface() {
-		base.Fatalf("itabname(%v, %v)", t, itype)
+		base.Fatalf("ITabAddr(%v, %v)", t, itype)
 	}
 	s := ir.Pkgs.Itab.Lookup(t.ShortString() + "," + itype.ShortString())
 	if s.Def == nil {
@@ -936,7 +936,7 @@ func formalType(t *types.Type) *types.Type {
 func writeType(t *types.Type) *obj.LSym {
 	t = formalType(t)
 	if t.IsUntyped() {
-		base.Fatalf("dtypesym %v", t)
+		base.Fatalf("writeType %v", t)
 	}
 
 	s := types.TypeSym(t)
@@ -1275,7 +1275,7 @@ func genfun(t, it *types.Type) []*obj.LSym {
 }
 
 // ITabSym uses the information gathered in
-// peekitabs to de-virtualize interface methods.
+// CompileITabs to de-virtualize interface methods.
 // Since this is called by the SSA backend, it shouldn't
 // generate additional Nodes, Syms, etc.
 func ITabSym(it *obj.LSym, offset int64) *obj.LSym {
@@ -1312,7 +1312,7 @@ func NeedRuntimeType(t *types.Type) {
 }
 
 func WriteRuntimeTypes() {
-	// Process signatset. Use a loop, as dtypesym adds
+	// Process signatset. Use a loop, as writeType adds
 	// entries to signatset while it is being processed.
 	signats := make([]typeAndStr, len(signatslice))
 	for len(signatslice) > 0 {
@@ -1617,13 +1617,13 @@ func (p *gcProg) emit(t *types.Type, offset int64) {
 	}
 	switch t.Kind() {
 	default:
-		base.Fatalf("GCProg.emit: unexpected type %v", t)
+		base.Fatalf("gcProg.emit: unexpected type %v", t)
 
 	case types.TSTRING:
 		p.w.Ptr(offset / int64(types.PtrSize))
 
 	case types.TINTER:
-		// Note: the first word isn't a pointer. See comment in plive.go:onebitwalktype1.
+		// Note: the first word isn't a pointer. See comment in typebits.Set
 		p.w.Ptr(offset/int64(types.PtrSize) + 1)
 
 	case types.TSLICE:
@@ -1632,7 +1632,7 @@ func (p *gcProg) emit(t *types.Type, offset int64) {
 	case types.TARRAY:
 		if t.NumElem() == 0 {
 			// should have been handled by haspointers check above
-			base.Fatalf("GCProg.emit: empty array")
+			base.Fatalf("gcProg.emit: empty array")
 		}
 
 		// Flatten array-of-array-of-array to just a big array by multiplying counts.
diff --git a/src/cmd/compile/internal/ssagen/abi.go b/src/cmd/compile/internal/ssagen/abi.go
index 7ff8e21a48..274c543ca5 100644
--- a/src/cmd/compile/internal/ssagen/abi.go
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -154,7 +154,7 @@ func InitLSym(f *ir.Func, hasBody bool) {
 // makes calls to helpers to create ABI wrappers if needed.
 func selectLSym(f *ir.Func, hasBody bool) {
 	if f.LSym != nil {
-		base.FatalfAt(f.Pos(), "Func.initLSym called twice on %v", f)
+		base.FatalfAt(f.Pos(), "InitLSym called twice on %v", f)
 	}
 
 	if nam := f.Nname; !ir.IsBlank(nam) {
diff --git a/src/cmd/compile/internal/ssagen/nowb.go b/src/cmd/compile/internal/ssagen/nowb.go
index 60cfb2f698..a2434366a0 100644
--- a/src/cmd/compile/internal/ssagen/nowb.go
+++ b/src/cmd/compile/internal/ssagen/nowb.go
@@ -45,7 +45,7 @@ type nowritebarrierrecCall struct {
 }
 
 // newNowritebarrierrecChecker creates a nowritebarrierrecChecker. It
-// must be called before transformclosure and walk.
+// must be called before walk
 func newNowritebarrierrecChecker() *nowritebarrierrecChecker {
 	c := &nowritebarrierrecChecker{
 		extraCalls: make(map[*ir.Func][]nowritebarrierrecCall),
@@ -54,7 +54,7 @@ func newNowritebarrierrecChecker() *nowritebarrierrecChecker {
 	// Find all systemstack calls and record their targets. In
 	// general, flow analysis can't see into systemstack, but it's
 	// important to handle it for this check, so we model it
-	// directly. This has to happen before transformclosure since
+	// directly. This has to happen before transforming closures in walk since
 	// it's a lot harder to work out the argument after.
 	for _, n := range typecheck.Target.Decls {
 		if n.Op() != ir.ODCLFUNC {
diff --git a/src/cmd/compile/internal/ssagen/pgen.go b/src/cmd/compile/internal/ssagen/pgen.go
index bbd319d735..182f8408cf 100644
--- a/src/cmd/compile/internal/ssagen/pgen.go
+++ b/src/cmd/compile/internal/ssagen/pgen.go
@@ -96,7 +96,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 			if n, ok := v.Aux.(*ir.Name); ok {
 				switch n.Class {
 				case ir.PPARAM, ir.PPARAMOUT:
-					// Don't modify nodfp; it is a global.
+					// Don't modify RegFP; it is a global.
 					if n != ir.RegFP {
 						n.SetUsed(true)
 					}
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 097cfacc23..7726ecac55 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -1508,10 +1508,10 @@ func (s *state) stmt(n ir.Node) {
 			// Currently doesn't really work because (*p)[:len(*p)] appears here as:
 			//    tmp = len(*p)
 			//    (*p)[:tmp]
-			//if j != nil && (j.Op == OLEN && samesafeexpr(j.Left, n.Left)) {
+			//if j != nil && (j.Op == OLEN && SameSafeExpr(j.Left, n.Left)) {
 			//      j = nil
 			//}
-			//if k != nil && (k.Op == OCAP && samesafeexpr(k.Left, n.Left)) {
+			//if k != nil && (k.Op == OCAP && SameSafeExpr(k.Left, n.Left)) {
 			//      k = nil
 			//}
 			if i == nil {
@@ -6462,7 +6462,7 @@ func (s *State) DebugFriendlySetPosFrom(v *ssa.Value) {
 			// in the generated code.
 			if p.IsStmt() != src.PosIsStmt {
 				p = p.WithNotStmt()
-				// Calls use the pos attached to v, but copy the statement mark from SSAGenState
+				// Calls use the pos attached to v, but copy the statement mark from State
 			}
 			s.SetPos(p)
 		} else {
@@ -7260,7 +7260,7 @@ func (e *ssafn) SplitInterface(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot
 	if n.Type().IsEmptyInterface() {
 		f = ".type"
 	}
-	c := e.SplitSlot(&name, f, 0, u) // see comment in plive.go:onebitwalktype1.
+	c := e.SplitSlot(&name, f, 0, u) // see comment in typebits.Set
 	d := e.SplitSlot(&name, ".data", u.Size(), t)
 	return c, d
 }
diff --git a/src/cmd/compile/internal/staticdata/data.go b/src/cmd/compile/internal/staticdata/data.go
index 4b12590fde..4dbc11c3c4 100644
--- a/src/cmd/compile/internal/staticdata/data.go
+++ b/src/cmd/compile/internal/staticdata/data.go
@@ -29,13 +29,13 @@ import (
 // Neither n nor a is modified.
 func InitAddr(n *ir.Name, noff int64, a *ir.Name, aoff int64) {
 	if n.Op() != ir.ONAME {
-		base.Fatalf("addrsym n op %v", n.Op())
+		base.Fatalf("InitAddr n op %v", n.Op())
 	}
 	if n.Sym() == nil {
-		base.Fatalf("addrsym nil n sym")
+		base.Fatalf("InitAddr nil n sym")
 	}
 	if a.Op() != ir.ONAME {
-		base.Fatalf("addrsym a op %v", a.Op())
+		base.Fatalf("InitAddr a op %v", a.Op())
 	}
 	s := n.Linksym()
 	s.WriteAddr(base.Ctxt, noff, types.PtrSize, a.Linksym(), aoff)
@@ -45,13 +45,13 @@ func InitAddr(n *ir.Name, noff int64, a *ir.Name, aoff int64) {
 // Neither n nor f is modified.
 func InitFunc(n *ir.Name, noff int64, f *ir.Name) {
 	if n.Op() != ir.ONAME {
-		base.Fatalf("pfuncsym n op %v", n.Op())
+		base.Fatalf("InitFunc n op %v", n.Op())
 	}
 	if n.Sym() == nil {
-		base.Fatalf("pfuncsym nil n sym")
+		base.Fatalf("InitFunc nil n sym")
 	}
 	if f.Class != ir.PFUNC {
-		base.Fatalf("pfuncsym class not PFUNC %d", f.Class)
+		base.Fatalf("InitFunc class not PFUNC %d", f.Class)
 	}
 	s := n.Linksym()
 	s.WriteAddr(base.Ctxt, noff, types.PtrSize, FuncLinksym(f), 0)
@@ -62,7 +62,7 @@ func InitFunc(n *ir.Name, noff int64, f *ir.Name) {
 func InitSlice(n *ir.Name, noff int64, arr *ir.Name, lencap int64) {
 	s := n.Linksym()
 	if arr.Op() != ir.ONAME {
-		base.Fatalf("slicesym non-name arr %v", arr)
+		base.Fatalf("InitSlice non-name arr %v", arr)
 	}
 	s.WriteAddr(base.Ctxt, noff, types.PtrSize, arr.Linksym(), 0)
 	s.WriteInt(base.Ctxt, noff+types.SliceLenOffset, types.PtrSize, lencap)
@@ -71,7 +71,7 @@ func InitSlice(n *ir.Name, noff int64, arr *ir.Name, lencap int64) {
 
 func InitSliceBytes(nam *ir.Name, off int64, s string) {
 	if nam.Op() != ir.ONAME {
-		base.Fatalf("slicebytes %v", nam)
+		base.Fatalf("InitSliceBytes %v", nam)
 	}
 	InitSlice(nam, off, slicedata(nam.Pos(), s), int64(len(s)))
 }
@@ -243,14 +243,14 @@ func FuncSym(s *types.Sym) *types.Sym {
 	// except for the types package, which is protected separately.
 	// Reusing funcsymsmu to also cover this package lookup
 	// avoids a general, broader, expensive package lookup mutex.
-	// Note makefuncsym also does package look-up of func sym names,
+	// Note NeedFuncSym also does package look-up of func sym names,
 	// but that it is only called serially, from the front end.
 	funcsymsmu.Lock()
 	sf, existed := s.Pkg.LookupOK(ir.FuncSymName(s))
 	// Don't export s·f when compiling for dynamic linking.
 	// When dynamically linking, the necessary function
-	// symbols will be created explicitly with makefuncsym.
-	// See the makefuncsym comment for details.
+	// symbols will be created explicitly with NeedFuncSym.
+	// See the NeedFuncSym comment for details.
 	if !base.Ctxt.Flag_dynlink && !existed {
 		funcsyms = append(funcsyms, s)
 	}
@@ -310,16 +310,16 @@ func WriteFuncSyms() {
 // Neither n nor c is modified.
 func InitConst(n *ir.Name, noff int64, c ir.Node, wid int) {
 	if n.Op() != ir.ONAME {
-		base.Fatalf("litsym n op %v", n.Op())
+		base.Fatalf("InitConst n op %v", n.Op())
 	}
 	if n.Sym() == nil {
-		base.Fatalf("litsym nil n sym")
+		base.Fatalf("InitConst nil n sym")
 	}
 	if c.Op() == ir.ONIL {
 		return
 	}
 	if c.Op() != ir.OLITERAL {
-		base.Fatalf("litsym c op %v", c.Op())
+		base.Fatalf("InitConst c op %v", c.Op())
 	}
 	s := n.Linksym()
 	switch u := c.Val(); u.Kind() {
@@ -358,6 +358,6 @@ func InitConst(n *ir.Name, noff int64, c ir.Node, wid int) {
 		s.WriteInt(base.Ctxt, noff+int64(types.PtrSize), types.PtrSize, int64(len(i)))
 
 	default:
-		base.Fatalf("litsym unhandled OLITERAL %v", c)
+		base.Fatalf("InitConst unhandled OLITERAL %v", c)
 	}
 }
diff --git a/src/cmd/compile/internal/staticdata/embed.go b/src/cmd/compile/internal/staticdata/embed.go
index 2e551f0b2c..2e15841fe2 100644
--- a/src/cmd/compile/internal/staticdata/embed.go
+++ b/src/cmd/compile/internal/staticdata/embed.go
@@ -82,7 +82,7 @@ func embedKindApprox(typ ir.Node) int {
 	// These are not guaranteed to match only string and []byte -
 	// maybe the local package has redefined one of those words.
 	// But it's the best we can do now during the noder.
-	// The stricter check happens later, in initEmbed calling embedKind.
+	// The stricter check happens later, in WriteEmbed calling embedKind.
 	if typ.Sym() != nil && typ.Sym().Name == "string" && typ.Sym().Pkg == types.LocalPkg {
 		return embedString
 	}
diff --git a/src/cmd/compile/internal/staticinit/sched.go b/src/cmd/compile/internal/staticinit/sched.go
index 64946ad247..8c195742e6 100644
--- a/src/cmd/compile/internal/staticinit/sched.go
+++ b/src/cmd/compile/internal/staticinit/sched.go
@@ -455,7 +455,7 @@ var statuniqgen int // name generator for static temps
 // StaticName returns a name backed by a (writable) static data symbol.
 // Use readonlystaticname for read-only node.
 func StaticName(t *types.Type) *ir.Name {
-	// Don't use lookupN; it interns the resulting string, but these are all unique.
+	// Don't use LookupNum; it interns the resulting string, but these are all unique.
 	n := typecheck.NewName(typecheck.Lookup(fmt.Sprintf("%s%d", obj.StaticNamePref, statuniqgen)))
 	statuniqgen++
 	typecheck.Declare(n, ir.PEXTERN)
diff --git a/src/cmd/compile/internal/test/abiutilsaux_test.go b/src/cmd/compile/internal/test/abiutilsaux_test.go
index 7b84e73947..10fb668745 100644
--- a/src/cmd/compile/internal/test/abiutilsaux_test.go
+++ b/src/cmd/compile/internal/test/abiutilsaux_test.go
@@ -127,7 +127,7 @@ func abitest(t *testing.T, ft *types.Type, exp expectedDump) {
 	emptyResString := emptyRes.String()
 
 	// Walk the results and make sure the offsets assigned match
-	// up with those assiged by dowidth. This checks to make sure that
+	// up with those assiged by CalcSize. This checks to make sure that
 	// when we have no available registers the ABI assignment degenerates
 	// back to the original ABI0.
 
diff --git a/src/cmd/compile/internal/test/testdata/reproducible/issue38068.go b/src/cmd/compile/internal/test/testdata/reproducible/issue38068.go
index db5ca7dcbe..b87daed8e9 100644
--- a/src/cmd/compile/internal/test/testdata/reproducible/issue38068.go
+++ b/src/cmd/compile/internal/test/testdata/reproducible/issue38068.go
@@ -53,7 +53,7 @@ func G(x *A, n int) {
 		return
 	}
 	// Address-taken local of type A, which will insure that the
-	// compiler's dtypesym() routine will create a method wrapper.
+	// compiler's writeType() routine will create a method wrapper.
 	var a, b A
 	a.next = x
 	a.prev = &b
diff --git a/src/cmd/compile/internal/typebits/typebits.go b/src/cmd/compile/internal/typebits/typebits.go
index 63a2bb3ffa..1c1b077423 100644
--- a/src/cmd/compile/internal/typebits/typebits.go
+++ b/src/cmd/compile/internal/typebits/typebits.go
@@ -15,7 +15,7 @@ import (
 // on future calls with the same type t.
 func Set(t *types.Type, off int64, bv bitvec.BitVec) {
 	if t.Align > 0 && off&int64(t.Align-1) != 0 {
-		base.Fatalf("onebitwalktype1: invalid initial alignment: type %v has alignment %d, but offset is %v", t, t.Align, off)
+		base.Fatalf("typebits.Set: invalid initial alignment: type %v has alignment %d, but offset is %v", t, t.Align, off)
 	}
 	if !t.HasPointers() {
 		// Note: this case ensures that pointers to go:notinheap types
@@ -26,14 +26,14 @@ func Set(t *types.Type, off int64, bv bitvec.BitVec) {
 	switch t.Kind() {
 	case types.TPTR, types.TUNSAFEPTR, types.TFUNC, types.TCHAN, types.TMAP:
 		if off&int64(types.PtrSize-1) != 0 {
-			base.Fatalf("onebitwalktype1: invalid alignment, %v", t)
+			base.Fatalf("typebits.Set: invalid alignment, %v", t)
 		}
 		bv.Set(int32(off / int64(types.PtrSize))) // pointer
 
 	case types.TSTRING:
 		// struct { byte *str; intgo len; }
 		if off&int64(types.PtrSize-1) != 0 {
-			base.Fatalf("onebitwalktype1: invalid alignment, %v", t)
+			base.Fatalf("typebits.Set: invalid alignment, %v", t)
 		}
 		bv.Set(int32(off / int64(types.PtrSize))) //pointer in first slot
 
@@ -42,7 +42,7 @@ func Set(t *types.Type, off int64, bv bitvec.BitVec) {
 		// or, when isnilinter(t)==true:
 		// struct { Type *type; void *data; }
 		if off&int64(types.PtrSize-1) != 0 {
-			base.Fatalf("onebitwalktype1: invalid alignment, %v", t)
+			base.Fatalf("typebits.Set: invalid alignment, %v", t)
 		}
 		// The first word of an interface is a pointer, but we don't
 		// treat it as such.
@@ -61,7 +61,7 @@ func Set(t *types.Type, off int64, bv bitvec.BitVec) {
 	case types.TSLICE:
 		// struct { byte *array; uintgo len; uintgo cap; }
 		if off&int64(types.PtrSize-1) != 0 {
-			base.Fatalf("onebitwalktype1: invalid TARRAY alignment, %v", t)
+			base.Fatalf("typebits.Set: invalid TARRAY alignment, %v", t)
 		}
 		bv.Set(int32(off / int64(types.PtrSize))) // pointer in first slot (BitsPointer)
 
@@ -82,6 +82,6 @@ func Set(t *types.Type, off int64, bv bitvec.BitVec) {
 		}
 
 	default:
-		base.Fatalf("onebitwalktype1: unexpected type, %v", t)
+		base.Fatalf("typebits.Set: unexpected type, %v", t)
 	}
 }
diff --git a/src/cmd/compile/internal/typecheck/const.go b/src/cmd/compile/internal/typecheck/const.go
index d6bf101974..1a8e58383a 100644
--- a/src/cmd/compile/internal/typecheck/const.go
+++ b/src/cmd/compile/internal/typecheck/const.go
@@ -623,7 +623,7 @@ func OrigInt(n ir.Node, v int64) ir.Node {
 	return OrigConst(n, constant.MakeInt64(v))
 }
 
-// defaultlit on both nodes simultaneously;
+// DefaultLit on both nodes simultaneously;
 // if they're both ideal going in they better
 // get the same type going out.
 // force means must assign concrete (non-ideal) type.
diff --git a/src/cmd/compile/internal/typecheck/dcl.go b/src/cmd/compile/internal/typecheck/dcl.go
index c7d7506fd1..c324238bf1 100644
--- a/src/cmd/compile/internal/typecheck/dcl.go
+++ b/src/cmd/compile/internal/typecheck/dcl.go
@@ -41,7 +41,7 @@ func Declare(n *ir.Name, ctxt ir.Class) {
 
 	s := n.Sym()
 
-	// kludgy: typecheckok means we're past parsing. Eg genwrapper may declare out of package names later.
+	// kludgy: TypecheckAllowed means we're past parsing. Eg reflectdata.methodWrapper may declare out of package names later.
 	if !inimport && !TypecheckAllowed && s.Pkg != types.LocalPkg {
 		base.ErrorfAt(n.Pos(), "cannot declare name %v", s)
 	}
@@ -308,7 +308,7 @@ func fakeRecvField() *types.Field {
 	return types.NewField(src.NoXPos, nil, types.FakeRecvType())
 }
 
-var funcStack []funcStackEnt // stack of previous values of Curfn/dclcontext
+var funcStack []funcStackEnt // stack of previous values of ir.CurFunc/DeclContext
 
 type funcStackEnt struct {
 	curfn      *ir.Func
@@ -398,14 +398,14 @@ func Temp(t *types.Type) *ir.Name {
 // make a new Node off the books
 func TempAt(pos src.XPos, curfn *ir.Func, t *types.Type) *ir.Name {
 	if curfn == nil {
-		base.Fatalf("no curfn for tempAt")
+		base.Fatalf("no curfn for TempAt")
 	}
 	if curfn.Op() == ir.OCLOSURE {
-		ir.Dump("tempAt", curfn)
-		base.Fatalf("adding tempAt to wrong closure function")
+		ir.Dump("TempAt", curfn)
+		base.Fatalf("adding TempAt to wrong closure function")
 	}
 	if t == nil {
-		base.Fatalf("tempAt called with nil type")
+		base.Fatalf("TempAt called with nil type")
 	}
 	if t.Kind() == types.TFUNC && t.Recv() != nil {
 		base.Fatalf("misuse of method type: %v", t)
diff --git a/src/cmd/compile/internal/typecheck/expr.go b/src/cmd/compile/internal/typecheck/expr.go
index 12bfae67a8..339fb00aa4 100644
--- a/src/cmd/compile/internal/typecheck/expr.go
+++ b/src/cmd/compile/internal/typecheck/expr.go
@@ -68,7 +68,7 @@ func tcShift(n, l, r ir.Node) (ir.Node, ir.Node, *types.Type) {
 		return l, r, nil
 	}
 
-	// no defaultlit for left
+	// no DefaultLit for left
 	// the outer context gives the type
 	t = l.Type()
 	if (l.Type() == types.UntypedFloat || l.Type() == types.UntypedComplex) && r.Op() == ir.OLITERAL {
@@ -201,7 +201,7 @@ func tcArith(n ir.Node, op ir.Op, l, r ir.Node) (ir.Node, ir.Node, *types.Type)
 // 	n.Left = tcCompLit(n.Left)
 func tcCompLit(n *ir.CompLitExpr) (res ir.Node) {
 	if base.EnableTrace && base.Flag.LowerT {
-		defer tracePrint("typecheckcomplit", n)(&res)
+		defer tracePrint("tcCompLit", n)(&res)
 	}
 
 	lno := base.Pos
@@ -838,7 +838,7 @@ func tcStar(n *ir.StarExpr, top int) ir.Node {
 	}
 	if l.Op() == ir.OTYPE {
 		n.SetOTYPE(types.NewPtr(l.Type()))
-		// Ensure l.Type gets dowidth'd for the backend. Issue 20174.
+		// Ensure l.Type gets CalcSize'd for the backend. Issue 20174.
 		types.CheckSize(l.Type())
 		return n
 	}
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index 03a10f594a..c832d9700f 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -100,7 +100,7 @@ func PartialCallType(n *ir.SelectorExpr) *types.Type {
 	return t
 }
 
-// Lazy typechecking of imported bodies. For local functions, caninl will set ->typecheck
+// Lazy typechecking of imported bodies. For local functions, CanInline will set ->typecheck
 // because they're a copy of an already checked body.
 func ImportedBody(fn *ir.Func) {
 	lno := ir.SetPos(fn.Nname)
@@ -122,14 +122,14 @@ func ImportedBody(fn *ir.Func) {
 
 	ImportBody(fn)
 
-	// typecheckinl is only for imported functions;
+	// Stmts(fn.Inl.Body) below is only for imported functions;
 	// their bodies may refer to unsafe as long as the package
 	// was marked safe during import (which was checked then).
-	// the ->inl of a local function has been typechecked before caninl copied it.
+	// the ->inl of a local function has been typechecked before CanInline copied it.
 	pkg := fnpkg(fn.Nname)
 
 	if pkg == types.LocalPkg || pkg == nil {
-		return // typecheckinl on local function
+		return // ImportedBody on local function
 	}
 
 	if base.Flag.LowerM > 2 || base.Debug.Export != 0 {
@@ -141,10 +141,10 @@ func ImportedBody(fn *ir.Func) {
 	Stmts(fn.Inl.Body)
 	ir.CurFunc = savefn
 
-	// During expandInline (which imports fn.Func.Inl.Body),
-	// declarations are added to fn.Func.Dcl by funcHdr(). Move them
+	// During ImportBody (which imports fn.Func.Inl.Body),
+	// declarations are added to fn.Func.Dcl by funcBody(). Move them
 	// to fn.Func.Inl.Dcl for consistency with how local functions
-	// behave. (Append because typecheckinl may be called multiple
+	// behave. (Append because ImportedBody may be called multiple
 	// times.)
 	fn.Inl.Dcl = append(fn.Inl.Dcl, fn.Dcl...)
 	fn.Dcl = nil
@@ -296,7 +296,7 @@ func tcClosure(clo *ir.ClosureExpr, top int) {
 	fn.SetClosureCalled(top&ctxCallee != 0)
 
 	// Do not typecheck fn twice, otherwise, we will end up pushing
-	// fn to Target.Decls multiple times, causing initLSym called twice.
+	// fn to Target.Decls multiple times, causing InitLSym called twice.
 	// See #30709
 	if fn.Typecheck() == 1 {
 		clo.SetType(fn.Type())
@@ -343,10 +343,10 @@ func tcClosure(clo *ir.ClosureExpr, top int) {
 
 // type check function definition
 // To be called by typecheck, not directly.
-// (Call typecheckFunc instead.)
+// (Call typecheck.Func instead.)
 func tcFunc(n *ir.Func) {
 	if base.EnableTrace && base.Flag.LowerT {
-		defer tracePrint("typecheckfunc", n)(nil)
+		defer tracePrint("tcFunc", n)(nil)
 	}
 
 	n.Nname = AssignExpr(n.Nname).(*ir.Name)
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 396d09263a..c2610229ec 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -37,7 +37,7 @@ var (
 	// and offset where that identifier's declaration can be read.
 	DeclImporter = map[*types.Sym]iimporterAndOffset{}
 
-	// inlineImporter is like declImporter, but for inline bodies
+	// inlineImporter is like DeclImporter, but for inline bodies
 	// for function and method symbols.
 	inlineImporter = map[*types.Sym]iimporterAndOffset{}
 )
@@ -334,7 +334,7 @@ func (r *importReader) doDecl(sym *types.Sym) *ir.Name {
 			recv := r.param()
 			mtyp := r.signature(recv)
 
-			// methodSym already marked m.Sym as a function.
+			// MethodSym already marked m.Sym as a function.
 			m := ir.NewNameAt(mpos, ir.MethodSym(recv.Type, msym))
 			m.Class = ir.PFUNC
 			m.SetType(mtyp)
diff --git a/src/cmd/compile/internal/typecheck/stmt.go b/src/cmd/compile/internal/typecheck/stmt.go
index 8baa5dda78..14ed175be9 100644
--- a/src/cmd/compile/internal/typecheck/stmt.go
+++ b/src/cmd/compile/internal/typecheck/stmt.go
@@ -25,7 +25,7 @@ func typecheckrangeExpr(n *ir.RangeStmt) {
 	}
 
 	t := RangeExprType(n.X.Type())
-	// delicate little dance.  see typecheckas2
+	// delicate little dance.  see tcAssignList
 	if n.Key != nil && !ir.DeclaredBy(n.Key, n) {
 		n.Key = AssignExpr(n.Key)
 	}
@@ -90,7 +90,7 @@ func typecheckrangeExpr(n *ir.RangeStmt) {
 // fill in the var's type.
 func tcAssign(n *ir.AssignStmt) {
 	if base.EnableTrace && base.Flag.LowerT {
-		defer tracePrint("typecheckas", n)(nil)
+		defer tracePrint("tcAssign", n)(nil)
 	}
 
 	if n.Y == nil {
@@ -110,7 +110,7 @@ func tcAssign(n *ir.AssignStmt) {
 
 func tcAssignList(n *ir.AssignListStmt) {
 	if base.EnableTrace && base.Flag.LowerT {
-		defer tracePrint("typecheckas2", n)(nil)
+		defer tracePrint("tcAssignList", n)(nil)
 	}
 
 	assign(n, n.Lhs, n.Rhs)
@@ -119,7 +119,7 @@ func tcAssignList(n *ir.AssignListStmt) {
 func assign(stmt ir.Node, lhs, rhs []ir.Node) {
 	// delicate little dance.
 	// the definition of lhs may refer to this assignment
-	// as its definition, in which case it will call typecheckas.
+	// as its definition, in which case it will call tcAssign.
 	// in that case, do not call typecheck back, or it will cycle.
 	// if the variable has a type (ntype) then typechecking
 	// will not look at defn, so it is okay (and desirable,
diff --git a/src/cmd/compile/internal/typecheck/subr.go b/src/cmd/compile/internal/typecheck/subr.go
index 569075d684..b6a0870672 100644
--- a/src/cmd/compile/internal/typecheck/subr.go
+++ b/src/cmd/compile/internal/typecheck/subr.go
@@ -81,7 +81,7 @@ func markAddrOf(n ir.Node) ir.Node {
 		// main typecheck has completed.
 		// The argument to OADDR needs to be typechecked because &x[i] takes
 		// the address of x if x is an array, but not if x is a slice.
-		// Note: outervalue doesn't work correctly until n is typechecked.
+		// Note: OuterValue doesn't work correctly until n is typechecked.
 		n = typecheck(n, ctxExpr)
 		if x := ir.OuterValue(n); x.Op() == ir.ONAME {
 			x.Name().SetAddrtaken(true)
@@ -368,10 +368,10 @@ func assignop(src, dst *types.Type) (ir.Op, string) {
 		var missing, have *types.Field
 		var ptr int
 		if implements(src, dst, &missing, &have, &ptr) {
-			// Call itabname so that (src, dst)
+			// Call NeedITab/ITabAddr so that (src, dst)
 			// gets added to itabs early, which allows
 			// us to de-virtualize calls through this
-			// type/interface pair later. See peekitabs in reflect.go
+			// type/interface pair later. See CompileITabs in reflect.go
 			if types.IsDirectIface(src) && !dst.IsEmptyInterface() {
 				NeedITab(src, dst)
 			}
@@ -441,7 +441,7 @@ func assignop(src, dst *types.Type) (ir.Op, string) {
 		}
 	}
 
-	// 6. rule about untyped constants - already converted by defaultlit.
+	// 6. rule about untyped constants - already converted by DefaultLit.
 
 	// 7. Any typed value can be assigned to the blank identifier.
 	if dst.Kind() == types.TBLANK {
@@ -835,7 +835,7 @@ func lookdot0(s *types.Sym, t *types.Type, save **types.Field, ignorecase bool)
 var slist []symlink
 
 // Code to help generate trampoline functions for methods on embedded
-// types. These are approx the same as the corresponding adddot
+// types. These are approx the same as the corresponding AddImplicitDots
 // routines except that they expect to be called with unique tasks and
 // they return the actual methods.
 
diff --git a/src/cmd/compile/internal/typecheck/syms.go b/src/cmd/compile/internal/typecheck/syms.go
index 28db40db91..f6ff2ee5da 100644
--- a/src/cmd/compile/internal/typecheck/syms.go
+++ b/src/cmd/compile/internal/typecheck/syms.go
@@ -15,7 +15,7 @@ import (
 func LookupRuntime(name string) *ir.Name {
 	s := ir.Pkgs.Runtime.Lookup(name)
 	if s == nil || s.Def == nil {
-		base.Fatalf("syslook: can't find runtime.%s", name)
+		base.Fatalf("LookupRuntime: can't find runtime.%s", name)
 	}
 	return ir.AsNode(s.Def).(*ir.Name)
 }
@@ -33,7 +33,7 @@ func SubstArgTypes(old *ir.Name, types_ ...*types.Type) *ir.Name {
 	n.Class = old.Class
 	n.SetType(types.SubstAny(old.Type(), &types_))
 	if len(types_) > 0 {
-		base.Fatalf("substArgTypes: too many argument types")
+		base.Fatalf("SubstArgTypes: too many argument types")
 	}
 	return n
 }
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 814af59772..3530e76972 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -456,7 +456,7 @@ func typecheck(n ir.Node, top int) (res ir.Node) {
 }
 
 // indexlit implements typechecking of untyped values as
-// array/slice indexes. It is almost equivalent to defaultlit
+// array/slice indexes. It is almost equivalent to DefaultLit
 // but also accepts untyped numeric values representable as
 // value of type int (see also checkmake for comparison).
 // The result of indexlit MUST be assigned back to n, e.g.
@@ -938,7 +938,7 @@ func typecheckargs(n ir.InitNode) {
 	// If we're outside of function context, then this call will
 	// be executed during the generated init function. However,
 	// init.go hasn't yet created it. Instead, associate the
-	// temporary variables with initTodo for now, and init.go
+	// temporary variables with  InitTodoFunc for now, and init.go
 	// will reassociate them later when it's appropriate.
 	static := ir.CurFunc == nil
 	if static {
@@ -1890,7 +1890,7 @@ func checkmake(t *types.Type, arg string, np *ir.Node) bool {
 		return false
 	}
 
-	// Do range checks for constants before defaultlit
+	// Do range checks for constants before DefaultLit
 	// to avoid redundant "constant NNN overflows int" errors.
 	if n.Op() == ir.OLITERAL {
 		v := toint(n.Val())
@@ -1904,7 +1904,7 @@ func checkmake(t *types.Type, arg string, np *ir.Node) bool {
 		}
 	}
 
-	// defaultlit is necessary for non-constants too: n might be 1.1<<k.
+	// DefaultLit is necessary for non-constants too: n might be 1.1<<k.
 	// TODO(gri) The length argument requirements for (array/slice) make
 	// are the same as for index expressions. Factor the code better;
 	// for instance, indexlit might be called here and incorporate some
diff --git a/src/cmd/compile/internal/types/alg.go b/src/cmd/compile/internal/types/alg.go
index 6091ee249c..2c2700f345 100644
--- a/src/cmd/compile/internal/types/alg.go
+++ b/src/cmd/compile/internal/types/alg.go
@@ -132,7 +132,7 @@ func AlgType(t *Type) (AlgKind, *Type) {
 		return ret, nil
 	}
 
-	base.Fatalf("algtype: unexpected type %v", t)
+	base.Fatalf("AlgType: unexpected type %v", t)
 	return 0, nil
 }
 
@@ -163,7 +163,7 @@ func IncomparableField(t *Type) *Field {
 // by padding.
 func IsPaddedField(t *Type, i int) bool {
 	if !t.IsStruct() {
-		base.Fatalf("ispaddedfield called non-struct %v", t)
+		base.Fatalf("IsPaddedField called non-struct %v", t)
 	}
 	end := t.Width
 	if i+1 < t.NumFields() {
diff --git a/src/cmd/compile/internal/types/fmt.go b/src/cmd/compile/internal/types/fmt.go
index cd0679f6b9..da224d4019 100644
--- a/src/cmd/compile/internal/types/fmt.go
+++ b/src/cmd/compile/internal/types/fmt.go
@@ -44,7 +44,7 @@ func OrigSym(s *Sym) *Sym {
 	}
 
 	if strings.HasPrefix(s.Name, ".anon") {
-		// originally an unnamed or _ name (see subr.go: structargs)
+		// originally an unnamed or _ name (see subr.go: NewFuncParams)
 		return nil
 	}
 
diff --git a/src/cmd/compile/internal/types/size.go b/src/cmd/compile/internal/types/size.go
index a54c086ded..98540eefb6 100644
--- a/src/cmd/compile/internal/types/size.go
+++ b/src/cmd/compile/internal/types/size.go
@@ -58,7 +58,7 @@ func typePos(t *Type) src.XPos {
 var MaxWidth int64
 
 // CalcSizeDisabled indicates whether it is safe
-// to calculate Types' widths and alignments. See dowidth.
+// to calculate Types' widths and alignments. See CalcSize.
 var CalcSizeDisabled bool
 
 // machine size and rounding alignment is dictated around
@@ -135,7 +135,7 @@ func expandiface(t *Type) {
 		m.Offset = int64(i) * int64(PtrSize)
 	}
 
-	// Access fields directly to avoid recursively calling dowidth
+	// Access fields directly to avoid recursively calling CalcSize
 	// within Type.Fields().
 	t.Extra.(*Interface).Fields.Set(methods)
 }
@@ -164,7 +164,7 @@ func calcStructOffset(errtype *Type, t *Type, o int64, flag int) int64 {
 		f.Offset = o
 		if f.Nname != nil {
 			// addrescapes has similar code to update these offsets.
-			// Usually addrescapes runs after widstruct,
+			// Usually addrescapes runs after calcStructOffset,
 			// in which case we could drop this,
 			// but function closure functions are the exception.
 			// NOTE(rsc): This comment may be stale.
@@ -306,17 +306,16 @@ func reportTypeLoop(t *Type) {
 }
 
 // CalcSize calculates and stores the size and alignment for t.
-// If sizeCalculationDisabled is set, and the size/alignment
+// If CalcSizeDisabled is set, and the size/alignment
 // have not already been calculated, it calls Fatal.
 // This is used to prevent data races in the back end.
 func CalcSize(t *Type) {
-	// Calling dowidth when typecheck tracing enabled is not safe.
+	// Calling CalcSize when typecheck tracing enabled is not safe.
 	// See issue #33658.
 	if base.EnableTrace && SkipSizeForTracing {
 		return
 	}
 	if PtrSize == 0 {
-
 		// Assume this is a test.
 		return
 	}
@@ -351,7 +350,7 @@ func CalcSize(t *Type) {
 		return
 	}
 
-	// defer checkwidth calls until after we're done
+	// defer CheckSize calls until after we're done
 	DeferCheckSize()
 
 	lno := base.Pos
@@ -367,7 +366,7 @@ func CalcSize(t *Type) {
 	case TFUNC, TCHAN, TMAP, TSTRING:
 		break
 
-	// simtype == 0 during bootstrap
+	// SimType == 0 during bootstrap
 	default:
 		if SimType[t.Kind()] != 0 {
 			et = SimType[t.Kind()]
@@ -377,7 +376,7 @@ func CalcSize(t *Type) {
 	var w int64
 	switch et {
 	default:
-		base.Fatalf("dowidth: unknown type: %v", t)
+		base.Fatalf("CalcSize: unknown type: %v", t)
 
 	// compiler-specific stuff
 	case TINT8, TUINT8, TBOOL:
@@ -443,11 +442,11 @@ func CalcSize(t *Type) {
 
 	case TANY:
 		// not a real type; should be replaced before use.
-		base.Fatalf("dowidth any")
+		base.Fatalf("CalcSize any")
 
 	case TSTRING:
 		if StringSize == 0 {
-			base.Fatalf("early dowidth string")
+			base.Fatalf("early CalcSize string")
 		}
 		w = StringSize
 		t.Align = uint8(PtrSize)
@@ -477,7 +476,7 @@ func CalcSize(t *Type) {
 
 	case TSTRUCT:
 		if t.IsFuncArgStruct() {
-			base.Fatalf("dowidth fn struct %v", t)
+			base.Fatalf("CalcSize fn struct %v", t)
 		}
 		w = calcStructOffset(t, t, 0, 1)
 
@@ -526,7 +525,7 @@ func CalcStructSize(s *Type) {
 	s.Width = calcStructOffset(s, s, 0, 1) // sets align
 }
 
-// when a type's width should be known, we call checkwidth
+// when a type's width should be known, we call CheckSize
 // to compute it.  during a declaration like
 //
 //	type T *struct { next T }
@@ -535,11 +534,11 @@ func CalcStructSize(s *Type) {
 // until after T has been initialized to be a pointer to that struct.
 // similarly, during import processing structs may be used
 // before their definition.  in those situations, calling
-// defercheckwidth() stops width calculations until
-// resumecheckwidth() is called, at which point all the
-// checkwidths that were deferred are executed.
-// dowidth should only be called when the type's size
-// is needed immediately.  checkwidth makes sure the
+// DeferCheckSize() stops width calculations until
+// ResumeCheckSize() is called, at which point all the
+// CalcSizes that were deferred are executed.
+// CalcSize should only be called when the type's size
+// is needed immediately.  CheckSize makes sure the
 // size is evaluated eventually.
 
 var deferredTypeStack []*Type
@@ -552,7 +551,7 @@ func CheckSize(t *Type) {
 	// function arg structs should not be checked
 	// outside of the enclosing function.
 	if t.IsFuncArgStruct() {
-		base.Fatalf("checkwidth %v", t)
+		base.Fatalf("CheckSize %v", t)
 	}
 
 	if defercalc == 0 {
@@ -606,7 +605,7 @@ func PtrDataSize(t *Type) int64 {
 	case TINTER:
 		// struct { Itab *tab;	void *data; } or
 		// struct { Type *type; void *data; }
-		// Note: see comment in plive.go:onebitwalktype1.
+		// Note: see comment in typebits.Set
 		return 2 * int64(PtrSize)
 
 	case TSLICE:
@@ -628,7 +627,7 @@ func PtrDataSize(t *Type) int64 {
 		return lastPtrField.Offset + PtrDataSize(lastPtrField.Type)
 
 	default:
-		base.Fatalf("typeptrdata: unexpected type, %v", t)
+		base.Fatalf("PtrDataSize: unexpected type, %v", t)
 		return 0
 	}
 }
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 5176b96c02..0dfbef8af1 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -107,7 +107,7 @@ const (
 // Types stores pointers to predeclared named types.
 //
 // It also stores pointers to several special types:
-//   - Types[TANY] is the placeholder "any" type recognized by substArgTypes.
+//   - Types[TANY] is the placeholder "any" type recognized by SubstArgTypes.
 //   - Types[TBLANK] represents the blank variable's type.
 //   - Types[TNIL] represents the predeclared "nil" value's type.
 //   - Types[TUNSAFEPTR] is package unsafe's Pointer type.
@@ -643,7 +643,7 @@ func SubstAny(t *Type, types *[]*Type) *Type {
 
 	case TANY:
 		if len(*types) == 0 {
-			base.Fatalf("substArgTypes: not enough argument types")
+			base.Fatalf("SubstArgTypes: not enough argument types")
 		}
 		t = (*types)[0]
 		*types = (*types)[1:]
diff --git a/src/cmd/compile/internal/walk/builtin.go b/src/cmd/compile/internal/walk/builtin.go
index 18ff702248..283c85629b 100644
--- a/src/cmd/compile/internal/walk/builtin.go
+++ b/src/cmd/compile/internal/walk/builtin.go
@@ -48,10 +48,10 @@ func walkAppend(n *ir.CallExpr, init *ir.Nodes, dst ir.Node) ir.Node {
 
 	nsrc := n.Args[0]
 
-	// walkexprlistsafe will leave OINDEX (s[n]) alone if both s
+	// walkExprListSafe will leave OINDEX (s[n]) alone if both s
 	// and n are name or literal, but those may index the slice we're
 	// modifying here. Fix explicitly.
-	// Using cheapexpr also makes sure that the evaluation
+	// Using cheapExpr also makes sure that the evaluation
 	// of all arguments (and especially any panics) happen
 	// before we begin to modify the slice in a visible way.
 	ls := n.Args[1:]
@@ -388,7 +388,7 @@ func walkMakeSlice(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
 		// n = arr[:l]
 		i := typecheck.IndexConst(r)
 		if i < 0 {
-			base.Fatalf("walkexpr: invalid index %v", r)
+			base.Fatalf("walkExpr: invalid index %v", r)
 		}
 
 		// cap is constrained to [0,2^31) or [0,2^63) depending on whether
diff --git a/src/cmd/compile/internal/walk/closure.go b/src/cmd/compile/internal/walk/closure.go
index 694aa99940..1d1cbc2054 100644
--- a/src/cmd/compile/internal/walk/closure.go
+++ b/src/cmd/compile/internal/walk/closure.go
@@ -159,7 +159,7 @@ func walkCallPart(n *ir.SelectorExpr, init *ir.Nodes) ir.Node {
 	//
 	//	clos = &struct{F uintptr; R T}{T.M·f, x}
 	//
-	// Like walkclosure above.
+	// Like walkClosure above.
 
 	if n.X.Type().IsInterface() {
 		// Trigger panic for method on nil interface now.
diff --git a/src/cmd/compile/internal/walk/compare.go b/src/cmd/compile/internal/walk/compare.go
index a4ea31bf55..7c385c0e0d 100644
--- a/src/cmd/compile/internal/walk/compare.go
+++ b/src/cmd/compile/internal/walk/compare.go
@@ -418,7 +418,7 @@ func eqFor(t *types.Type) (n ir.Node, needsize bool) {
 	// Should only arrive here with large memory or
 	// a struct/array containing a non-memory field/element.
 	// Small memory is handled inline, and single non-memory
-	// is handled by walkcompare.
+	// is handled by walkCompare.
 	switch a, _ := types.AlgType(t); a {
 	case types.AMEM:
 		n := typecheck.LookupRuntime("memequal")
@@ -436,7 +436,7 @@ func eqFor(t *types.Type) (n ir.Node, needsize bool) {
 		}))
 		return n, false
 	}
-	base.Fatalf("eqfor %v", t)
+	base.Fatalf("eqFor %v", t)
 	return nil, false
 }
 
diff --git a/src/cmd/compile/internal/walk/convert.go b/src/cmd/compile/internal/walk/convert.go
index 848aee3938..b47bb917c3 100644
--- a/src/cmd/compile/internal/walk/convert.go
+++ b/src/cmd/compile/internal/walk/convert.go
@@ -442,8 +442,8 @@ func walkCheckPtrAlignment(n *ir.ConvExpr, init *ir.Nodes, count ir.Node) ir.Nod
 }
 
 func walkCheckPtrArithmetic(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
-	// Calling cheapexpr(n, init) below leads to a recursive call to
-	// walkexpr, which leads us back here again. Use n.Checkptr to
+	// Calling cheapExpr(n, init) below leads to a recursive call to
+	// walkExpr, which leads us back here again. Use n.Checkptr to
 	// prevent infinite loops.
 	if n.CheckPtr() {
 		return n
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 253634a60f..510f568576 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -30,7 +30,7 @@ func walkExpr(n ir.Node, init *ir.Nodes) ir.Node {
 		// not okay to use n->ninit when walking n,
 		// because we might replace n with some other node
 		// and would lose the init list.
-		base.Fatalf("walkexpr init == &n->ninit")
+		base.Fatalf("walkExpr init == &n->ninit")
 	}
 
 	if len(n.Init()) != 0 {
@@ -81,7 +81,7 @@ func walkExpr1(n ir.Node, init *ir.Nodes) ir.Node {
 	switch n.Op() {
 	default:
 		ir.Dump("walk", n)
-		base.Fatalf("walkexpr: switch 1 unknown op %+v", n.Op())
+		base.Fatalf("walkExpr: switch 1 unknown op %+v", n.Op())
 		panic("unreachable")
 
 	case ir.ONONAME, ir.OGETG:
@@ -91,7 +91,7 @@ func walkExpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		// TODO(mdempsky): Just return n; see discussion on CL 38655.
 		// Perhaps refactor to use Node.mayBeShared for these instead.
 		// If these return early, make sure to still call
-		// stringsym for constant strings.
+		// StringSym for constant strings.
 		return n
 
 	case ir.OMETHEXPR:
@@ -221,7 +221,7 @@ func walkExpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return walkIndexMap(n, init)
 
 	case ir.ORECV:
-		base.Fatalf("walkexpr ORECV") // should see inside OAS only
+		base.Fatalf("walkExpr ORECV") // should see inside OAS only
 		panic("unreachable")
 
 	case ir.OSLICEHEADER:
@@ -413,7 +413,7 @@ func safeExpr(n ir.Node, init *ir.Nodes) ir.Node {
 
 	// make a copy; must not be used as an lvalue
 	if ir.IsAddressable(n) {
-		base.Fatalf("missing lvalue case in safeexpr: %v", n)
+		base.Fatalf("missing lvalue case in safeExpr: %v", n)
 	}
 	return cheapExpr(n, init)
 }
@@ -428,7 +428,7 @@ func walkAddString(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
 	c := len(n.List)
 
 	if c < 2 {
-		base.Fatalf("addstr count %d too small", c)
+		base.Fatalf("walkAddString count %d too small", c)
 	}
 
 	buf := typecheck.NodNil()
@@ -534,7 +534,7 @@ func walkCall1(n *ir.CallExpr, init *ir.Nodes) {
 		// Determine param type.
 		t := params.Field(i).Type
 		if base.Flag.Cfg.Instrumenting || fncall(arg, t) {
-			// make assignment of fncall to tempAt
+			// make assignment of fncall to Temp
 			tmp := typecheck.Temp(t)
 			a := convas(ir.NewAssignStmt(base.Pos, tmp, arg), init)
 			tempAssigns = append(tempAssigns, a)
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index 38a9bec6e3..78063c4db2 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -849,7 +849,7 @@ func (o *orderState) stmt(n ir.Node) {
 			n.X = o.copyExpr(r)
 
 			// n.Prealloc is the temp for the iterator.
-			// hiter contains pointers and needs to be zeroed.
+			// MapIterType contains pointers and needs to be zeroed.
 			n.Prealloc = o.newTemp(reflectdata.MapIterType(xt), true)
 		}
 		n.Key = o.exprInPlace(n.Key)
@@ -962,7 +962,7 @@ func (o *orderState) stmt(n ir.Node) {
 			cas.Body.Prepend(o.cleanTempNoPop(t)...)
 
 			// TODO(mdempsky): Is this actually necessary?
-			// walkselect appears to walk Ninit.
+			// walkSelect appears to walk Ninit.
 			cas.Body.Prepend(ir.TakeInit(cas)...)
 		}
 
@@ -986,7 +986,7 @@ func (o *orderState) stmt(n ir.Node) {
 		o.cleanTemp(t)
 
 	// TODO(rsc): Clean temporaries more aggressively.
-	// Note that because walkswitch will rewrite some of the
+	// Note that because walkSwitch will rewrite some of the
 	// switch into a binary search, this is not as easy as it looks.
 	// (If we ran that code here we could invoke order.stmt on
 	// the if-else chain instead.)
diff --git a/src/cmd/compile/internal/walk/range.go b/src/cmd/compile/internal/walk/range.go
index 9225c429f0..2b28e7442d 100644
--- a/src/cmd/compile/internal/walk/range.go
+++ b/src/cmd/compile/internal/walk/range.go
@@ -71,7 +71,7 @@ func walkRange(nrange *ir.RangeStmt) ir.Node {
 	}
 
 	if v1 == nil && v2 != nil {
-		base.Fatalf("walkrange: v2 != nil while v1 == nil")
+		base.Fatalf("walkRange: v2 != nil while v1 == nil")
 	}
 
 	var ifGuard *ir.IfStmt
@@ -80,7 +80,7 @@ func walkRange(nrange *ir.RangeStmt) ir.Node {
 	var init []ir.Node
 	switch t.Kind() {
 	default:
-		base.Fatalf("walkrange")
+		base.Fatalf("walkRange")
 
 	case types.TARRAY, types.TSLICE:
 		if nn := arrayClear(nrange, v1, v2, a); nn != nil {
@@ -168,7 +168,7 @@ func walkRange(nrange *ir.RangeStmt) ir.Node {
 
 		hit := nrange.Prealloc
 		th := hit.Type()
-		keysym := th.Field(0).Sym  // depends on layout of iterator struct.  See reflect.go:hiter
+		keysym := th.Field(0).Sym  // depends on layout of iterator struct.  See reflect.go:MapIterType
 		elemsym := th.Field(1).Sym // ditto
 
 		fn := typecheck.LookupRuntime("mapiterinit")
@@ -388,7 +388,7 @@ func mapClear(m ir.Node) ir.Node {
 //
 // in which the evaluation of a is side-effect-free.
 //
-// Parameters are as in walkrange: "for v1, v2 = range a".
+// Parameters are as in walkRange: "for v1, v2 = range a".
 func arrayClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
 	if base.Flag.N != 0 || base.Flag.Cfg.Instrumenting {
 		return nil
diff --git a/src/cmd/compile/internal/walk/select.go b/src/cmd/compile/internal/walk/select.go
index 776b020155..56ba0fa758 100644
--- a/src/cmd/compile/internal/walk/select.go
+++ b/src/cmd/compile/internal/walk/select.go
@@ -14,7 +14,7 @@ import (
 func walkSelect(sel *ir.SelectStmt) {
 	lno := ir.SetPos(sel)
 	if len(sel.Compiled) != 0 {
-		base.Fatalf("double walkselect")
+		base.Fatalf("double walkSelect")
 	}
 
 	init := ir.TakeInit(sel)
@@ -218,7 +218,7 @@ func walkSelectCases(cases []*ir.CommClause) []ir.Node {
 		}
 	}
 	if nsends+nrecvs != ncas {
-		base.Fatalf("walkselectcases: miscount: %v + %v != %v", nsends, nrecvs, ncas)
+		base.Fatalf("walkSelectCases: miscount: %v + %v != %v", nsends, nrecvs, ncas)
 	}
 
 	// run the select
diff --git a/src/cmd/compile/internal/walk/switch.go b/src/cmd/compile/internal/walk/switch.go
index 0cc1830d3f..162de018f6 100644
--- a/src/cmd/compile/internal/walk/switch.go
+++ b/src/cmd/compile/internal/walk/switch.go
@@ -49,8 +49,8 @@ func walkSwitchExpr(sw *ir.SwitchStmt) {
 	// Given "switch string(byteslice)",
 	// with all cases being side-effect free,
 	// use a zero-cost alias of the byte slice.
-	// Do this before calling walkexpr on cond,
-	// because walkexpr will lower the string
+	// Do this before calling walkExpr on cond,
+	// because walkExpr will lower the string
 	// conversion into a runtime call.
 	// See issue 24937 for more discussion.
 	if cond.Op() == ir.OBYTES2STR && allCaseExprsAreSideEffectFree(sw) {
diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index 4ba81b82fe..f95440d60d 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -208,7 +208,7 @@ func mapfast(t *types.Type) int {
 func walkAppendArgs(n *ir.CallExpr, init *ir.Nodes) {
 	walkExprListSafe(n.Args, init)
 
-	// walkexprlistsafe will leave OINDEX (s[n]) alone if both s
+	// walkExprListSafe will leave OINDEX (s[n]) alone if both s
 	// and n are name or literal, but those may index the slice we're
 	// modifying here. Fix explicitly.
 	ls := n.Args
@@ -240,8 +240,8 @@ func appendWalkStmt(init *ir.Nodes, stmt ir.Node) {
 	op := stmt.Op()
 	n := typecheck.Stmt(stmt)
 	if op == ir.OAS || op == ir.OAS2 {
-		// If the assignment has side effects, walkexpr will append them
-		// directly to init for us, while walkstmt will wrap it in an OBLOCK.
+		// If the assignment has side effects, walkExpr will append them
+		// directly to init for us, while walkStmt will wrap it in an OBLOCK.
 		// We need to append them directly.
 		// TODO(rsc): Clean this up.
 		n = walkExpr(n, init)
@@ -256,7 +256,7 @@ func appendWalkStmt(init *ir.Nodes, stmt ir.Node) {
 const maxOpenDefers = 8
 
 // backingArrayPtrLen extracts the pointer and length from a slice or string.
-// This constructs two nodes referring to n, so n must be a cheapexpr.
+// This constructs two nodes referring to n, so n must be a cheapExpr.
 func backingArrayPtrLen(n ir.Node) (ptr, length ir.Node) {
 	var init ir.Nodes
 	c := cheapExpr(n, &init)
@@ -423,7 +423,7 @@ func runtimeField(name string, offset int64, typ *types.Type) *types.Field {
 
 // ifaceData loads the data field from an interface.
 // The concrete type must be known to have type t.
-// It follows the pointer if !isdirectiface(t).
+// It follows the pointer if !IsDirectIface(t).
 func ifaceData(pos src.XPos, n ir.Node, t *types.Type) ir.Node {
 	if t.IsInterface() {
 		base.Fatalf("ifaceData interface: %v", t)
diff --git a/src/cmd/internal/goobj/mkbuiltin.go b/src/cmd/internal/goobj/mkbuiltin.go
index 07c3406681..22608e7e69 100644
--- a/src/cmd/internal/goobj/mkbuiltin.go
+++ b/src/cmd/internal/goobj/mkbuiltin.go
@@ -118,8 +118,8 @@ func mkbuiltin(w io.Writer) {
 
 // addBasicTypes returns the symbol names for basic types that are
 // defined in the runtime and referenced in other packages.
-// Needs to be kept in sync with reflect.go:dumpbasictypes() and
-// reflect.go:dtypesym() in the compiler.
+// Needs to be kept in sync with reflect.go:WriteBasicTypes() and
+// reflect.go:writeType() in the compiler.
 func enumerateBasicTypes() []extra {
 	names := [...]string{
 		"int8", "uint8", "int16", "uint16",
diff --git a/src/cmd/internal/obj/textflag.go b/src/cmd/internal/obj/textflag.go
index fcc4014aa2..2f55793285 100644
--- a/src/cmd/internal/obj/textflag.go
+++ b/src/cmd/internal/obj/textflag.go
@@ -33,7 +33,7 @@ const (
 	// This function uses its incoming context register.
 	NEEDCTXT = 64
 
-	// When passed to ggloblsym, causes Local to be set to true on the LSym it creates.
+	// When passed to objw.Global, causes Local to be set to true on the LSym it creates.
 	LOCAL = 128
 
 	// Allocate a word of thread local storage and store the offset from the
diff --git a/src/embed/embed.go b/src/embed/embed.go
index 29e0adf1a6..5f35cd13b6 100644
--- a/src/embed/embed.go
+++ b/src/embed/embed.go
@@ -133,7 +133,7 @@ import (
 // See the package documentation for more details about initializing an FS.
 type FS struct {
 	// The compiler knows the layout of this struct.
-	// See cmd/compile/internal/gc's initEmbed.
+	// See cmd/compile/internal/staticdata's WriteEmbed.
 	//
 	// The files list is sorted by name but not by simple string comparison.
 	// Instead, each file's name takes the form "dir/elem" or "dir/elem/".
@@ -203,7 +203,7 @@ var (
 // It implements fs.FileInfo and fs.DirEntry.
 type file struct {
 	// The compiler knows the layout of this struct.
-	// See cmd/compile/internal/gc's initEmbed.
+	// See cmd/compile/internal/staticdata's WriteEmbed.
 	name string
 	data string
 	hash [16]byte // truncated SHA256 hash
diff --git a/src/reflect/type.go b/src/reflect/type.go
index 1f1e70d485..13e3d71228 100644
--- a/src/reflect/type.go
+++ b/src/reflect/type.go
@@ -1890,7 +1890,7 @@ func MapOf(key, elem Type) Type {
 
 	// Make a map type.
 	// Note: flag values must match those used in the TMAP case
-	// in ../cmd/compile/internal/gc/reflect.go:dtypesym.
+	// in ../cmd/compile/internal/gc/reflect.go:writeType.
 	var imap interface{} = (map[unsafe.Pointer]unsafe.Pointer)(nil)
 	mt := **(**mapType)(unsafe.Pointer(&imap))
 	mt.str = resolveReflectName(newName(s, "", false))
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index c9376827da..9c3ceabd18 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -853,7 +853,7 @@ type funcinl struct {
 // layout of Itab known to compilers
 // allocated in non-garbage-collected memory
 // Needs to be in sync with
-// ../cmd/compile/internal/gc/reflect.go:/^func.dumptabs.
+// ../cmd/compile/internal/gc/reflect.go:/^func.WriteTabs.
 type itab struct {
 	inter *interfacetype
 	_type *_type
diff --git a/src/runtime/type.go b/src/runtime/type.go
index 81455f3532..18fc4bbfad 100644
--- a/src/runtime/type.go
+++ b/src/runtime/type.go
@@ -383,7 +383,7 @@ type maptype struct {
 }
 
 // Note: flag values must match those used in the TMAP case
-// in ../cmd/compile/internal/gc/reflect.go:dtypesym.
+// in ../cmd/compile/internal/gc/reflect.go:writeType.
 func (mt *maptype) indirectkey() bool { // store ptr to key instead of key itself
 	return mt.flags&1 != 0
 }
-- 
GitLab


From 6de9423445840351a4cc7b17d732f0b5e922ef1a Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 16 Jan 2021 03:27:17 -0800
Subject: [PATCH 0497/2400] [dev.regabi] cmd/compile: cleanup OAS2FUNC ordering

Currently, to ensure OAS2FUNC results are assigned in the correct
order, they're always assigned to temporary variables. However, these
temporary variables are typed based on the destination type, which may
require an interface conversion. This means walk may have to then
introduce a second set of temporaries to ensure result parameters are
all copied out of the results area, before it emits calls to runtime
conversion functions.

That's just silly. Instead, this CL changes order to allocate the
result temporaries with the same type as the function returns in the
first place, and then assign them one at a time to their destinations,
with conversions as needed.

While here, also fix an order-of-evaluation issue with has-ok
assignments that I almost added to multi-value function call
assignments, and add tests for each.

Change-Id: I9f4e962425fe3c5e3305adbbfeae2c7f253ec365
Reviewed-on: https://go-review.googlesource.com/c/go/+/284220
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/walk/assign.go | 10 +--
 src/cmd/compile/internal/walk/order.go  | 83 +++++++++++--------------
 test/reorder.go                         | 16 +++++
 3 files changed, 57 insertions(+), 52 deletions(-)

diff --git a/src/cmd/compile/internal/walk/assign.go b/src/cmd/compile/internal/walk/assign.go
index 4043d7574a..320a3464cc 100644
--- a/src/cmd/compile/internal/walk/assign.go
+++ b/src/cmd/compile/internal/walk/assign.go
@@ -268,7 +268,7 @@ func ascompatet(nl ir.Nodes, nr *types.Type) []ir.Node {
 		base.Fatalf("ascompatet: assignment count mismatch: %d = %d", len(nl), nr.NumFields())
 	}
 
-	var nn, mm ir.Nodes
+	var nn ir.Nodes
 	for i, l := range nl {
 		if ir.IsBlank(l) {
 			continue
@@ -278,11 +278,7 @@ func ascompatet(nl ir.Nodes, nr *types.Type) []ir.Node {
 		// Any assignment to an lvalue that might cause a function call must be
 		// deferred until all the returned values have been read.
 		if fncall(l, r.Type) {
-			tmp := ir.Node(typecheck.Temp(r.Type))
-			tmp = typecheck.Expr(tmp)
-			a := convas(ir.NewAssignStmt(base.Pos, l, tmp), &mm)
-			mm.Append(a)
-			l = tmp
+			base.FatalfAt(l.Pos(), "assigning %v to %+v", r.Type, l)
 		}
 
 		res := ir.NewResultExpr(base.Pos, nil, types.BADWIDTH)
@@ -299,7 +295,7 @@ func ascompatet(nl ir.Nodes, nr *types.Type) []ir.Node {
 
 		nn.Append(a)
 	}
-	return append(nn, mm...)
+	return nn
 }
 
 // check assign expression list to
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index 78063c4db2..d34c58009a 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -555,10 +555,6 @@ func (o *orderState) mapAssign(n ir.Node) {
 			n.Y = o.safeMapRHS(n.Y)
 		}
 		o.out = append(o.out, n)
-
-	case ir.OAS2, ir.OAS2DOTTYPE, ir.OAS2MAPR, ir.OAS2FUNC:
-		n := n.(*ir.AssignListStmt)
-		o.out = append(o.out, n)
 	}
 }
 
@@ -637,7 +633,7 @@ func (o *orderState) stmt(n ir.Node) {
 		t := o.markTemp()
 		o.exprList(n.Lhs)
 		o.exprList(n.Rhs)
-		o.mapAssign(n)
+		o.out = append(o.out, n)
 		o.cleanTemp(t)
 
 	// Special: avoid copy of func call n.Right
@@ -647,7 +643,7 @@ func (o *orderState) stmt(n ir.Node) {
 		o.exprList(n.Lhs)
 		o.init(n.Rhs[0])
 		o.call(n.Rhs[0])
-		o.as2(n)
+		o.as2func(n)
 		o.cleanTemp(t)
 
 	// Special: use temporary variables to hold result,
@@ -679,7 +675,7 @@ func (o *orderState) stmt(n ir.Node) {
 			base.Fatalf("order.stmt: %v", r.Op())
 		}
 
-		o.okAs2(n)
+		o.as2ok(n)
 		o.cleanTemp(t)
 
 	// Special: does not save n onto out.
@@ -1390,57 +1386,54 @@ func (o *orderState) expr1(n, lhs ir.Node) ir.Node {
 	// No return - type-assertions above. Each case must return for itself.
 }
 
-// as2 orders OAS2XXXX nodes. It creates temporaries to ensure left-to-right assignment.
-// The caller should order the right-hand side of the assignment before calling order.as2.
+// as2func orders OAS2FUNC nodes. It creates temporaries to ensure left-to-right assignment.
+// The caller should order the right-hand side of the assignment before calling order.as2func.
 // It rewrites,
-// 	a, b, a = ...
+//	a, b, a = ...
 // as
 //	tmp1, tmp2, tmp3 = ...
-// 	a, b, a = tmp1, tmp2, tmp3
+//	a, b, a = tmp1, tmp2, tmp3
 // This is necessary to ensure left to right assignment order.
-func (o *orderState) as2(n *ir.AssignListStmt) {
-	tmplist := []ir.Node{}
-	left := []ir.Node{}
-	for ni, l := range n.Lhs {
-		if !ir.IsBlank(l) {
-			tmp := o.newTemp(l.Type(), l.Type().HasPointers())
-			n.Lhs[ni] = tmp
-			tmplist = append(tmplist, tmp)
-			left = append(left, l)
+func (o *orderState) as2func(n *ir.AssignListStmt) {
+	results := n.Rhs[0].Type()
+	as := ir.NewAssignListStmt(n.Pos(), ir.OAS2, nil, nil)
+	for i, nl := range n.Lhs {
+		if !ir.IsBlank(nl) {
+			typ := results.Field(i).Type
+			tmp := o.newTemp(typ, typ.HasPointers())
+			n.Lhs[i] = tmp
+			as.Lhs = append(as.Lhs, nl)
+			as.Rhs = append(as.Rhs, tmp)
 		}
 	}
 
 	o.out = append(o.out, n)
-
-	as := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-	as.Lhs = left
-	as.Rhs = tmplist
 	o.stmt(typecheck.Stmt(as))
 }
 
-// okAs2 orders OAS2XXX with ok.
-// Just like as2, this also adds temporaries to ensure left-to-right assignment.
-func (o *orderState) okAs2(n *ir.AssignListStmt) {
-	var tmp1, tmp2 ir.Node
-	if !ir.IsBlank(n.Lhs[0]) {
-		typ := n.Rhs[0].Type()
-		tmp1 = o.newTemp(typ, typ.HasPointers())
+// as2ok orders OAS2XXX with ok.
+// Just like as2func, this also adds temporaries to ensure left-to-right assignment.
+func (o *orderState) as2ok(n *ir.AssignListStmt) {
+	as := ir.NewAssignListStmt(n.Pos(), ir.OAS2, nil, nil)
+
+	do := func(i int, typ *types.Type) {
+		if nl := n.Lhs[i]; !ir.IsBlank(nl) {
+			var tmp ir.Node = o.newTemp(typ, typ.HasPointers())
+			n.Lhs[i] = tmp
+			as.Lhs = append(as.Lhs, nl)
+			if i == 1 {
+				// The "ok" result is an untyped boolean according to the Go
+				// spec. We need to explicitly convert it to the LHS type in
+				// case the latter is a defined boolean type (#8475).
+				tmp = typecheck.Conv(tmp, nl.Type())
+			}
+			as.Rhs = append(as.Rhs, tmp)
+		}
 	}
 
-	if !ir.IsBlank(n.Lhs[1]) {
-		tmp2 = o.newTemp(types.Types[types.TBOOL], false)
-	}
+	do(0, n.Rhs[0].Type())
+	do(1, types.Types[types.TBOOL])
 
 	o.out = append(o.out, n)
-
-	if tmp1 != nil {
-		r := ir.NewAssignStmt(base.Pos, n.Lhs[0], tmp1)
-		o.mapAssign(typecheck.Stmt(r))
-		n.Lhs[0] = tmp1
-	}
-	if tmp2 != nil {
-		r := ir.NewAssignStmt(base.Pos, n.Lhs[1], typecheck.Conv(tmp2, n.Lhs[1].Type()))
-		o.mapAssign(typecheck.Stmt(r))
-		n.Lhs[1] = tmp2
-	}
+	o.stmt(typecheck.Stmt(as))
 }
diff --git a/test/reorder.go b/test/reorder.go
index 3a87d025c2..57892f882f 100644
--- a/test/reorder.go
+++ b/test/reorder.go
@@ -20,6 +20,8 @@ func main() {
 	p7()
 	p8()
 	p9()
+	p10()
+	p11()
 }
 
 var gx []int
@@ -149,3 +151,17 @@ func checkOAS2XXX(x bool, s string) {
 		panic("failed")
 	}
 }
+
+//go:noinline
+func fp() (*int, int) { return nil, 42 }
+
+func p10() {
+	p := new(int)
+	p, *p = fp()
+}
+
+func p11() {
+	var i interface{}
+	p := new(bool)
+	p, *p = i.(*bool)
+}
-- 
GitLab


From 78e5aabcdb8aeae58a6437a3051fde3555ee0bf2 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 16 Jan 2021 16:59:19 -0800
Subject: [PATCH 0498/2400] [dev.regabi] cmd/compile: replace Node.HasCall with
 walk.mayCall

After CL 284220, we now only need to detect expressions that contain
function calls in the arguments list of further function calls. So we
can simplify Node.HasCall/fncall/etc a lot.

Instead of incrementally tracking whether an expression contains
function calls all throughout walk, simply check once at the point of
using an expression as a function call argument. Since any expression
checked here will itself become a function call argument, it won't be
checked again because we'll short circuit at the enclosing function
call.

Also, restructure the recursive walk code to use mayCall, and trim
down the list of acceptable expressions. It should be okay to be
stricter, since we'll now only see function call arguments and after
they've already been walked.

It's possible I was overly aggressive removing Ops here. But if so,
we'll get an ICE, and it'll be easy to re-add them. I think this is
better than the alternative of accidentally allowing expressions
through that risk silently clobbering the stack.

Passes toolstash -cmp.

Change-Id: I585ef35dcccd9f4018e4bf2c3f9ccb1514a826f3
Reviewed-on: https://go-review.googlesource.com/c/go/+/284223
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/ir/expr.go     |   5 +-
 src/cmd/compile/internal/ir/mini.go     |   5 +-
 src/cmd/compile/internal/ir/node.go     |   3 -
 src/cmd/compile/internal/ir/stmt.go     |   8 +-
 src/cmd/compile/internal/walk/assign.go |  27 +----
 src/cmd/compile/internal/walk/expr.go   |  18 +--
 src/cmd/compile/internal/walk/walk.go   | 155 +++++++-----------------
 7 files changed, 65 insertions(+), 156 deletions(-)

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index dd91e347bd..4631476973 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -32,8 +32,7 @@ type miniExpr struct {
 }
 
 const (
-	miniExprHasCall = 1 << iota
-	miniExprNonNil
+	miniExprNonNil = 1 << iota
 	miniExprTransient
 	miniExprBounded
 	miniExprImplicit // for use by implementations; not supported by every Expr
@@ -44,8 +43,6 @@ func (*miniExpr) isExpr() {}
 
 func (n *miniExpr) Type() *types.Type     { return n.typ }
 func (n *miniExpr) SetType(x *types.Type) { n.typ = x }
-func (n *miniExpr) HasCall() bool         { return n.flags&miniExprHasCall != 0 }
-func (n *miniExpr) SetHasCall(b bool)     { n.flags.set(miniExprHasCall, b) }
 func (n *miniExpr) NonNil() bool          { return n.flags&miniExprNonNil != 0 }
 func (n *miniExpr) MarkNonNil()           { n.flags |= miniExprNonNil }
 func (n *miniExpr) Transient() bool       { return n.flags&miniExprTransient != 0 }
diff --git a/src/cmd/compile/internal/ir/mini.go b/src/cmd/compile/internal/ir/mini.go
index 429f4ed360..a7ff4ac9c7 100644
--- a/src/cmd/compile/internal/ir/mini.go
+++ b/src/cmd/compile/internal/ir/mini.go
@@ -57,8 +57,7 @@ const (
 	miniWalkdefShift   = 0 // TODO(mdempsky): Move to Name.flags.
 	miniTypecheckShift = 2
 	miniDiag           = 1 << 4
-	miniHasCall        = 1 << 5 // for miniStmt
-	miniWalked         = 1 << 6 // to prevent/catch re-walking
+	miniWalked         = 1 << 5 // to prevent/catch re-walking
 )
 
 func (n *miniNode) Typecheck() uint8 { return n.bits.get2(miniTypecheckShift) }
@@ -89,7 +88,5 @@ func (n *miniNode) Name() *Name             { return nil }
 func (n *miniNode) Sym() *types.Sym         { return nil }
 func (n *miniNode) Val() constant.Value     { panic(n.no("Val")) }
 func (n *miniNode) SetVal(v constant.Value) { panic(n.no("SetVal")) }
-func (n *miniNode) HasCall() bool           { return false }
-func (n *miniNode) SetHasCall(bool)         { panic(n.no("SetHasCall")) }
 func (n *miniNode) NonNil() bool            { return false }
 func (n *miniNode) MarkNonNil()             { panic(n.no("MarkNonNil")) }
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index de03800da2..a44bf42e78 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -52,8 +52,6 @@ type Node interface {
 	SetTypecheck(x uint8)
 	NonNil() bool
 	MarkNonNil()
-	HasCall() bool
-	SetHasCall(x bool)
 }
 
 // Line returns n's position as a string. If n has been inlined,
@@ -544,7 +542,6 @@ func InitExpr(init []Node, expr Node) Node {
 	}
 
 	n.PtrInit().Prepend(init...)
-	n.SetHasCall(true)
 	return n
 }
 
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index 4e4c0df993..0358569a1f 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -50,11 +50,9 @@ type miniStmt struct {
 
 func (*miniStmt) isStmt() {}
 
-func (n *miniStmt) Init() Nodes       { return n.init }
-func (n *miniStmt) SetInit(x Nodes)   { n.init = x }
-func (n *miniStmt) PtrInit() *Nodes   { return &n.init }
-func (n *miniStmt) HasCall() bool     { return n.bits&miniHasCall != 0 }
-func (n *miniStmt) SetHasCall(b bool) { n.bits.set(miniHasCall, b) }
+func (n *miniStmt) Init() Nodes     { return n.init }
+func (n *miniStmt) SetInit(x Nodes) { n.init = x }
+func (n *miniStmt) PtrInit() *Nodes { return &n.init }
 
 // An AssignListStmt is an assignment statement with
 // more than one item on at least one side: Lhs = Rhs.
diff --git a/src/cmd/compile/internal/walk/assign.go b/src/cmd/compile/internal/walk/assign.go
index 320a3464cc..6e8075a35f 100644
--- a/src/cmd/compile/internal/walk/assign.go
+++ b/src/cmd/compile/internal/walk/assign.go
@@ -248,18 +248,6 @@ func walkReturn(n *ir.ReturnStmt) ir.Node {
 	return n
 }
 
-// fncall reports whether assigning an rvalue of type rt to an lvalue l might involve a function call.
-func fncall(l ir.Node, rt *types.Type) bool {
-	if l.HasCall() || l.Op() == ir.OINDEXMAP {
-		return true
-	}
-	if types.Identical(l.Type(), rt) {
-		return false
-	}
-	// There might be a conversion required, which might involve a runtime call.
-	return true
-}
-
 // check assign type list to
 // an expression list. called in
 //	expr-list = func()
@@ -275,9 +263,9 @@ func ascompatet(nl ir.Nodes, nr *types.Type) []ir.Node {
 		}
 		r := nr.Field(i)
 
-		// Any assignment to an lvalue that might cause a function call must be
-		// deferred until all the returned values have been read.
-		if fncall(l, r.Type) {
+		// Order should have created autotemps of the appropriate type for
+		// us to store results into.
+		if tmp, ok := l.(*ir.Name); !ok || !tmp.AutoTemp() || !types.Identical(tmp.Type(), r.Type) {
 			base.FatalfAt(l.Pos(), "assigning %v to %+v", r.Type, l)
 		}
 
@@ -286,14 +274,7 @@ func ascompatet(nl ir.Nodes, nr *types.Type) []ir.Node {
 		res.SetType(r.Type)
 		res.SetTypecheck(1)
 
-		a := convas(ir.NewAssignStmt(base.Pos, l, res), &nn)
-		updateHasCall(a)
-		if a.HasCall() {
-			ir.Dump("ascompatet ucount", a)
-			base.Fatalf("ascompatet: too many function calls evaluating parameters")
-		}
-
-		nn.Append(a)
+		nn.Append(ir.NewAssignStmt(base.Pos, l, res))
 	}
 	return nn
 }
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 510f568576..a1e8e63785 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -67,8 +67,6 @@ func walkExpr(n ir.Node, init *ir.Nodes) ir.Node {
 		_ = staticdata.StringSym(n.Pos(), constant.StringVal(n.Val()))
 	}
 
-	updateHasCall(n)
-
 	if base.Flag.LowerW != 0 && n != nil {
 		ir.Dump("after walk expr", n)
 	}
@@ -527,15 +525,17 @@ func walkCall1(n *ir.CallExpr, init *ir.Nodes) {
 	// For any argument whose evaluation might require a function call,
 	// store that argument into a temporary variable,
 	// to prevent that calls from clobbering arguments already on the stack.
-	// When instrumenting, all arguments might require function calls.
 	var tempAssigns []ir.Node
 	for i, arg := range args {
-		updateHasCall(arg)
-		// Determine param type.
-		t := params.Field(i).Type
-		if base.Flag.Cfg.Instrumenting || fncall(arg, t) {
-			// make assignment of fncall to Temp
-			tmp := typecheck.Temp(t)
+		// Validate argument and parameter types match.
+		param := params.Field(i)
+		if !types.Identical(arg.Type(), param.Type) {
+			base.FatalfAt(n.Pos(), "assigning %L to parameter %v (type %v)", arg, param.Sym, param.Type)
+		}
+
+		if mayCall(arg) {
+			// assignment of arg to Temp
+			tmp := typecheck.Temp(param.Type)
 			a := convas(ir.NewAssignStmt(base.Pos, tmp, arg), init)
 			tempAssigns = append(tempAssigns, a)
 			// replace arg with temp
diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index f95440d60d..a9672a261b 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -67,8 +67,6 @@ func convas(n *ir.AssignStmt, init *ir.Nodes) *ir.AssignStmt {
 	if n.Op() != ir.OAS {
 		base.Fatalf("convas: not OAS %v", n.Op())
 	}
-	defer updateHasCall(n)
-
 	n.SetTypecheck(1)
 
 	if n.X == nil || n.Y == nil {
@@ -274,123 +272,64 @@ func backingArrayPtrLen(n ir.Node) (ptr, length ir.Node) {
 	return ptr, length
 }
 
-// updateHasCall checks whether expression n contains any function
-// calls and sets the n.HasCall flag if so.
-func updateHasCall(n ir.Node) {
-	if n == nil {
-		return
-	}
-	n.SetHasCall(calcHasCall(n))
-}
-
-func calcHasCall(n ir.Node) bool {
-	if len(n.Init()) != 0 {
-		// TODO(mdempsky): This seems overly conservative.
+// mayCall reports whether evaluating expression n may require
+// function calls, which could clobber function call arguments/results
+// currently on the stack.
+func mayCall(n ir.Node) bool {
+	// When instrumenting, any expression might require function calls.
+	if base.Flag.Cfg.Instrumenting {
 		return true
 	}
 
-	switch n.Op() {
-	default:
-		base.Fatalf("calcHasCall %+v", n)
-		panic("unreachable")
+	isSoftFloat := func(typ *types.Type) bool {
+		return types.IsFloat[typ.Kind()] || types.IsComplex[typ.Kind()]
+	}
 
-	case ir.OLITERAL, ir.ONIL, ir.ONAME, ir.OTYPE, ir.ONAMEOFFSET:
-		if n.HasCall() {
-			base.Fatalf("OLITERAL/ONAME/OTYPE should never have calls: %+v", n)
-		}
-		return false
-	case ir.OCALL, ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
-		return true
-	case ir.OANDAND, ir.OOROR:
-		// hard with instrumented code
-		n := n.(*ir.LogicalExpr)
-		if base.Flag.Cfg.Instrumenting {
-			return true
+	return ir.Any(n, func(n ir.Node) bool {
+		// walk should have already moved any Init blocks off of
+		// expressions.
+		if len(n.Init()) != 0 {
+			base.FatalfAt(n.Pos(), "mayCall %+v", n)
 		}
-		return n.X.HasCall() || n.Y.HasCall()
-	case ir.OINDEX, ir.OSLICE, ir.OSLICEARR, ir.OSLICE3, ir.OSLICE3ARR, ir.OSLICESTR,
-		ir.ODEREF, ir.ODOTPTR, ir.ODOTTYPE, ir.ODIV, ir.OMOD:
-		// These ops might panic, make sure they are done
-		// before we start marshaling args for a call. See issue 16760.
-		return true
 
-	// When using soft-float, these ops might be rewritten to function calls
-	// so we ensure they are evaluated first.
-	case ir.OADD, ir.OSUB, ir.OMUL:
-		n := n.(*ir.BinaryExpr)
-		if ssagen.Arch.SoftFloat && (types.IsFloat[n.Type().Kind()] || types.IsComplex[n.Type().Kind()]) {
-			return true
-		}
-		return n.X.HasCall() || n.Y.HasCall()
-	case ir.ONEG:
-		n := n.(*ir.UnaryExpr)
-		if ssagen.Arch.SoftFloat && (types.IsFloat[n.Type().Kind()] || types.IsComplex[n.Type().Kind()]) {
-			return true
-		}
-		return n.X.HasCall()
-	case ir.OLT, ir.OEQ, ir.ONE, ir.OLE, ir.OGE, ir.OGT:
-		n := n.(*ir.BinaryExpr)
-		if ssagen.Arch.SoftFloat && (types.IsFloat[n.X.Type().Kind()] || types.IsComplex[n.X.Type().Kind()]) {
+		switch n.Op() {
+		default:
+			base.FatalfAt(n.Pos(), "mayCall %+v", n)
+
+		case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
 			return true
-		}
-		return n.X.HasCall() || n.Y.HasCall()
-	case ir.OCONV:
-		n := n.(*ir.ConvExpr)
-		if ssagen.Arch.SoftFloat && ((types.IsFloat[n.Type().Kind()] || types.IsComplex[n.Type().Kind()]) || (types.IsFloat[n.X.Type().Kind()] || types.IsComplex[n.X.Type().Kind()])) {
+
+		case ir.OINDEX, ir.OSLICE, ir.OSLICEARR, ir.OSLICE3, ir.OSLICE3ARR, ir.OSLICESTR,
+			ir.ODEREF, ir.ODOTPTR, ir.ODOTTYPE, ir.ODIV, ir.OMOD:
+			// These ops might panic, make sure they are done
+			// before we start marshaling args for a call. See issue 16760.
 			return true
+
+		// When using soft-float, these ops might be rewritten to function calls
+		// so we ensure they are evaluated first.
+		case ir.OADD, ir.OSUB, ir.OMUL, ir.ONEG:
+			return ssagen.Arch.SoftFloat && isSoftFloat(n.Type())
+		case ir.OLT, ir.OEQ, ir.ONE, ir.OLE, ir.OGE, ir.OGT:
+			n := n.(*ir.BinaryExpr)
+			return ssagen.Arch.SoftFloat && isSoftFloat(n.X.Type())
+		case ir.OCONV:
+			n := n.(*ir.ConvExpr)
+			return ssagen.Arch.SoftFloat && (isSoftFloat(n.Type()) || isSoftFloat(n.X.Type()))
+
+		case ir.OLITERAL, ir.ONIL, ir.ONAME, ir.ONAMEOFFSET, ir.OMETHEXPR,
+			ir.OAND, ir.OANDNOT, ir.OLSH, ir.OOR, ir.ORSH, ir.OXOR, ir.OCOMPLEX, ir.OEFACE,
+			ir.OANDAND, ir.OOROR,
+			ir.OADDR, ir.OBITNOT, ir.ONOT, ir.OPLUS,
+			ir.OCAP, ir.OIMAG, ir.OLEN, ir.OREAL,
+			ir.OCONVNOP, ir.ODOT,
+			ir.OCFUNC, ir.OIDATA, ir.OITAB, ir.OSPTR,
+			ir.OBYTES2STRTMP, ir.OGETG, ir.OSLICEHEADER:
+			// ok: operations that don't require function calls.
+			// Expand as needed.
 		}
-		return n.X.HasCall()
-
-	case ir.OAND, ir.OANDNOT, ir.OLSH, ir.OOR, ir.ORSH, ir.OXOR, ir.OCOPY, ir.OCOMPLEX, ir.OEFACE:
-		n := n.(*ir.BinaryExpr)
-		return n.X.HasCall() || n.Y.HasCall()
-
-	case ir.OAS:
-		n := n.(*ir.AssignStmt)
-		return n.X.HasCall() || n.Y != nil && n.Y.HasCall()
-
-	case ir.OADDR:
-		n := n.(*ir.AddrExpr)
-		return n.X.HasCall()
-	case ir.OPAREN:
-		n := n.(*ir.ParenExpr)
-		return n.X.HasCall()
-	case ir.OBITNOT, ir.ONOT, ir.OPLUS, ir.ORECV,
-		ir.OALIGNOF, ir.OCAP, ir.OCLOSE, ir.OIMAG, ir.OLEN, ir.ONEW,
-		ir.OOFFSETOF, ir.OPANIC, ir.OREAL, ir.OSIZEOF,
-		ir.OCHECKNIL, ir.OCFUNC, ir.OIDATA, ir.OITAB, ir.OSPTR, ir.OVARDEF, ir.OVARKILL, ir.OVARLIVE:
-		n := n.(*ir.UnaryExpr)
-		return n.X.HasCall()
-	case ir.ODOT, ir.ODOTMETH, ir.ODOTINTER:
-		n := n.(*ir.SelectorExpr)
-		return n.X.HasCall()
-
-	case ir.OGETG, ir.OMETHEXPR:
-		return false
 
-	// TODO(rsc): These look wrong in various ways but are what calcHasCall has always done.
-	case ir.OADDSTR:
-		// TODO(rsc): This used to check left and right, which are not part of OADDSTR.
 		return false
-	case ir.OBLOCK:
-		// TODO(rsc): Surely the block's statements matter.
-		return false
-	case ir.OCONVIFACE, ir.OCONVNOP, ir.OBYTES2STR, ir.OBYTES2STRTMP, ir.ORUNES2STR, ir.OSTR2BYTES, ir.OSTR2BYTESTMP, ir.OSTR2RUNES, ir.ORUNESTR:
-		// TODO(rsc): Some conversions are themselves calls, no?
-		n := n.(*ir.ConvExpr)
-		return n.X.HasCall()
-	case ir.ODOTTYPE2:
-		// TODO(rsc): Shouldn't this be up with ODOTTYPE above?
-		n := n.(*ir.TypeAssertExpr)
-		return n.X.HasCall()
-	case ir.OSLICEHEADER:
-		// TODO(rsc): What about len and cap?
-		n := n.(*ir.SliceHeaderExpr)
-		return n.Ptr.HasCall()
-	case ir.OAS2DOTTYPE, ir.OAS2FUNC:
-		// TODO(rsc): Surely we need to check List and Rlist.
-		return false
-	}
+	})
 }
 
 // itabType loads the _type field from a runtime.itab struct.
-- 
GitLab


From ba0e8a92fa74768feaccb8c3e4e5791b2dbc382f Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 16 Jan 2021 18:25:00 -0800
Subject: [PATCH 0499/2400] [dev.regabi] cmd/compile: refactor temp
 construction in walk

This CL adds a few new helper functions for constructing and
initializing temporary variables during walk.

Passes toolstash -cmp.

Change-Id: I54965d992cd8dfef7cb7dc92a17c88372e52a0d6
Reviewed-on: https://go-review.googlesource.com/c/go/+/284224
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/walk/builtin.go | 13 ++-----
 src/cmd/compile/internal/walk/complit.go | 31 ++++------------
 src/cmd/compile/internal/walk/convert.go | 14 +++----
 src/cmd/compile/internal/walk/expr.go    |  3 +-
 src/cmd/compile/internal/walk/temp.go    | 47 ++++++++++++++++++++++++
 5 files changed, 63 insertions(+), 45 deletions(-)
 create mode 100644 src/cmd/compile/internal/walk/temp.go

diff --git a/src/cmd/compile/internal/walk/builtin.go b/src/cmd/compile/internal/walk/builtin.go
index 283c85629b..97f9de9c1d 100644
--- a/src/cmd/compile/internal/walk/builtin.go
+++ b/src/cmd/compile/internal/walk/builtin.go
@@ -277,10 +277,8 @@ func walkMakeMap(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
 		// Allocate hmap on stack.
 
 		// var hv hmap
-		hv := typecheck.Temp(hmapType)
-		init.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, hv, nil)))
 		// h = &hv
-		h = typecheck.NodAddr(hv)
+		h = stackTempAddr(init, hmapType)
 
 		// Allocate one bucket pointed to by hmap.buckets on stack if hint
 		// is not larger than BUCKETSIZE. In case hint is larger than
@@ -303,11 +301,8 @@ func walkMakeMap(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
 			nif.Likely = true
 
 			// var bv bmap
-			bv := typecheck.Temp(reflectdata.MapBucketType(t))
-			nif.Body.Append(ir.NewAssignStmt(base.Pos, bv, nil))
-
 			// b = &bv
-			b := typecheck.NodAddr(bv)
+			b := stackTempAddr(&nif.Body, reflectdata.MapBucketType(t))
 
 			// h.buckets = b
 			bsym := hmapType.Field(5).Sym // hmap.buckets see reflect.go:hmap
@@ -509,9 +504,7 @@ func walkNew(n *ir.UnaryExpr, init *ir.Nodes) ir.Node {
 		if t.Size() >= ir.MaxImplicitStackVarSize {
 			base.Fatalf("large ONEW with EscNone: %v", n)
 		}
-		r := typecheck.Temp(t)
-		init.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, r, nil))) // zero temp
-		return typecheck.Expr(typecheck.NodAddr(r))
+		return stackTempAddr(init, t)
 	}
 	types.CalcSize(t)
 	n.MarkNonNil()
diff --git a/src/cmd/compile/internal/walk/complit.go b/src/cmd/compile/internal/walk/complit.go
index f82ef69ca9..a7db453550 100644
--- a/src/cmd/compile/internal/walk/complit.go
+++ b/src/cmd/compile/internal/walk/complit.go
@@ -344,30 +344,14 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 		if !types.Identical(t, x.Type()) {
 			panic("dotdotdot base type does not match order's assigned type")
 		}
-
-		if vstat == nil {
-			a = ir.NewAssignStmt(base.Pos, x, nil)
-			a = typecheck.Stmt(a)
-			init.Append(a) // zero new temp
-		} else {
-			// Declare that we're about to initialize all of x.
-			// (Which happens at the *vauto = vstat below.)
-			init.Append(ir.NewUnaryExpr(base.Pos, ir.OVARDEF, x))
-		}
-
-		a = typecheck.NodAddr(x)
+		a = initStackTemp(init, x, vstat != nil)
 	} else if n.Esc() == ir.EscNone {
-		a = typecheck.Temp(t)
 		if vstat == nil {
-			a = ir.NewAssignStmt(base.Pos, typecheck.Temp(t), nil)
-			a = typecheck.Stmt(a)
-			init.Append(a) // zero new temp
-			a = a.(*ir.AssignStmt).X
-		} else {
-			init.Append(ir.NewUnaryExpr(base.Pos, ir.OVARDEF, a))
+			// TODO(mdempsky): Remove this useless temporary.
+			// It's only needed to keep toolstash happy.
+			typecheck.Temp(t)
 		}
-
-		a = typecheck.NodAddr(a)
+		a = initStackTemp(init, typecheck.Temp(t), vstat != nil)
 	} else {
 		a = ir.NewUnaryExpr(base.Pos, ir.ONEW, ir.TypeNode(t))
 	}
@@ -550,9 +534,8 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 
 		var r ir.Node
 		if n.Prealloc != nil {
-			// n.Right is stack temporary used as backing store.
-			appendWalkStmt(init, ir.NewAssignStmt(base.Pos, n.Prealloc, nil)) // zero backing store, just in case (#18410)
-			r = typecheck.NodAddr(n.Prealloc)
+			// n.Prealloc is stack temporary used as backing store.
+			r = initStackTemp(init, n.Prealloc, false)
 		} else {
 			r = ir.NewUnaryExpr(base.Pos, ir.ONEW, ir.TypeNode(n.X.Type()))
 			r.SetEsc(n.Esc())
diff --git a/src/cmd/compile/internal/walk/convert.go b/src/cmd/compile/internal/walk/convert.go
index b47bb917c3..d143c1084f 100644
--- a/src/cmd/compile/internal/walk/convert.go
+++ b/src/cmd/compile/internal/walk/convert.go
@@ -198,8 +198,7 @@ func walkBytesRunesToString(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 	a := typecheck.NodNil()
 	if n.Esc() == ir.EscNone {
 		// Create temporary buffer for string on stack.
-		t := types.NewArray(types.Types[types.TUINT8], tmpstringbufsize)
-		a = typecheck.NodAddr(typecheck.Temp(t))
+		a = stackBufAddr(tmpstringbufsize, types.Types[types.TUINT8])
 	}
 	if n.Op() == ir.ORUNES2STR {
 		// slicerunetostring(*[32]byte, []rune) string
@@ -229,8 +228,7 @@ func walkBytesToStringTemp(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 func walkRuneToString(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 	a := typecheck.NodNil()
 	if n.Esc() == ir.EscNone {
-		t := types.NewArray(types.Types[types.TUINT8], 4)
-		a = typecheck.NodAddr(typecheck.Temp(t))
+		a = stackBufAddr(4, types.Types[types.TUINT8])
 	}
 	// intstring(*[4]byte, rune)
 	return mkcall("intstring", n.Type(), init, a, typecheck.Conv(n.X, types.Types[types.TINT64]))
@@ -246,7 +244,7 @@ func walkStringToBytes(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 		t := types.NewArray(types.Types[types.TUINT8], int64(len(sc)))
 		var a ir.Node
 		if n.Esc() == ir.EscNone && len(sc) <= int(ir.MaxImplicitStackVarSize) {
-			a = typecheck.NodAddr(typecheck.Temp(t))
+			a = stackBufAddr(t.NumElem(), t.Elem())
 		} else {
 			types.CalcSize(t)
 			a = ir.NewUnaryExpr(base.Pos, ir.ONEW, nil)
@@ -273,8 +271,7 @@ func walkStringToBytes(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 	a := typecheck.NodNil()
 	if n.Esc() == ir.EscNone {
 		// Create temporary buffer for slice on stack.
-		t := types.NewArray(types.Types[types.TUINT8], tmpstringbufsize)
-		a = typecheck.NodAddr(typecheck.Temp(t))
+		a = stackBufAddr(tmpstringbufsize, types.Types[types.TUINT8])
 	}
 	// stringtoslicebyte(*32[byte], string) []byte
 	return mkcall("stringtoslicebyte", n.Type(), init, a, typecheck.Conv(s, types.Types[types.TSTRING]))
@@ -298,8 +295,7 @@ func walkStringToRunes(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 	a := typecheck.NodNil()
 	if n.Esc() == ir.EscNone {
 		// Create temporary buffer for slice on stack.
-		t := types.NewArray(types.Types[types.TINT32], tmpstringbufsize)
-		a = typecheck.NodAddr(typecheck.Temp(t))
+		a = stackBufAddr(tmpstringbufsize, types.Types[types.TINT32])
 	}
 	// stringtoslicerune(*[32]rune, string) []rune
 	return mkcall("stringtoslicerune", n.Type(), init, a, typecheck.Conv(n.X, types.Types[types.TSTRING]))
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index a1e8e63785..8a13f6a923 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -441,8 +441,7 @@ func walkAddString(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
 		// Don't allocate the buffer if the result won't fit.
 		if sz < tmpstringbufsize {
 			// Create temporary buffer for result string on stack.
-			t := types.NewArray(types.Types[types.TUINT8], tmpstringbufsize)
-			buf = typecheck.NodAddr(typecheck.Temp(t))
+			buf = stackBufAddr(tmpstringbufsize, types.Types[types.TUINT8])
 		}
 	}
 
diff --git a/src/cmd/compile/internal/walk/temp.go b/src/cmd/compile/internal/walk/temp.go
new file mode 100644
index 0000000000..901cb770f3
--- /dev/null
+++ b/src/cmd/compile/internal/walk/temp.go
@@ -0,0 +1,47 @@
+// Copyright 2021 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 walk
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
+	"cmd/compile/internal/types"
+)
+
+// initStackTemp appends statements to init to initialize the given
+// temporary variable, and then returns the expression &tmp. If vardef
+// is true, then the variable is initialized with OVARDEF, and the
+// caller must ensure the variable is later assigned before use;
+// otherwise, it's zero initialized.
+//
+// TODO(mdempsky): Change callers to provide tmp's initial value,
+// rather than just vardef, to make this safer/easier to use.
+func initStackTemp(init *ir.Nodes, tmp *ir.Name, vardef bool) *ir.AddrExpr {
+	if vardef {
+		init.Append(ir.NewUnaryExpr(base.Pos, ir.OVARDEF, tmp))
+	} else {
+		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, tmp, nil))
+	}
+	return typecheck.Expr(typecheck.NodAddr(tmp)).(*ir.AddrExpr)
+}
+
+// stackTempAddr returns the expression &tmp, where tmp is a newly
+// allocated temporary variable of the given type. Statements to
+// zero-initialize tmp are appended to init.
+func stackTempAddr(init *ir.Nodes, typ *types.Type) *ir.AddrExpr {
+	return initStackTemp(init, typecheck.Temp(typ), false)
+}
+
+// stackBufAddr returns thte expression &tmp, where tmp is a newly
+// allocated temporary variable of type [len]elem. This variable is
+// initialized, and elem must not contain pointers.
+func stackBufAddr(len int64, elem *types.Type) *ir.AddrExpr {
+	if elem.HasPointers() {
+		base.FatalfAt(base.Pos, "%v has pointers", elem)
+	}
+	tmp := typecheck.Temp(types.NewArray(elem, len))
+	return typecheck.Expr(typecheck.NodAddr(tmp)).(*ir.AddrExpr)
+}
-- 
GitLab


From 7ce2a8383d154ca1860286a9b5c8a1e6cf151a90 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 16 Jan 2021 19:35:39 -0800
Subject: [PATCH 0500/2400] [dev.regabi] cmd/compile: simplify stack temp
 initialization

This CL simplifies the previous one a little bit further, by combining
reordering stack-temporary initialization and getting rid of an
unneeded temporary variable. (Does not pass toolstash -cmp.)

Change-Id: I17799dfe368484f33a8ddd0ab4f68647d6262147
Reviewed-on: https://go-review.googlesource.com/c/go/+/284225
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/walk/complit.go | 17 +++++++----------
 src/cmd/compile/internal/walk/temp.go    | 19 ++++++-------------
 2 files changed, 13 insertions(+), 23 deletions(-)

diff --git a/src/cmd/compile/internal/walk/complit.go b/src/cmd/compile/internal/walk/complit.go
index a7db453550..97e820238b 100644
--- a/src/cmd/compile/internal/walk/complit.go
+++ b/src/cmd/compile/internal/walk/complit.go
@@ -344,21 +344,18 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 		if !types.Identical(t, x.Type()) {
 			panic("dotdotdot base type does not match order's assigned type")
 		}
-		a = initStackTemp(init, x, vstat != nil)
+		a = initStackTemp(init, x, vstat)
 	} else if n.Esc() == ir.EscNone {
-		if vstat == nil {
-			// TODO(mdempsky): Remove this useless temporary.
-			// It's only needed to keep toolstash happy.
-			typecheck.Temp(t)
-		}
-		a = initStackTemp(init, typecheck.Temp(t), vstat != nil)
+		a = initStackTemp(init, typecheck.Temp(t), vstat)
 	} else {
 		a = ir.NewUnaryExpr(base.Pos, ir.ONEW, ir.TypeNode(t))
 	}
 	appendWalkStmt(init, ir.NewAssignStmt(base.Pos, vauto, a))
 
-	if vstat != nil {
-		// copy static to heap (4)
+	if vstat != nil && n.Prealloc == nil && n.Esc() != ir.EscNone {
+		// If we allocated on the heap with ONEW, copy the static to the
+		// heap (4). We skip this for stack temporaries, because
+		// initStackTemp already handled the copy.
 		a = ir.NewStarExpr(base.Pos, vauto)
 		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, a, vstat))
 	}
@@ -535,7 +532,7 @@ func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
 		var r ir.Node
 		if n.Prealloc != nil {
 			// n.Prealloc is stack temporary used as backing store.
-			r = initStackTemp(init, n.Prealloc, false)
+			r = initStackTemp(init, n.Prealloc, nil)
 		} else {
 			r = ir.NewUnaryExpr(base.Pos, ir.ONEW, ir.TypeNode(n.X.Type()))
 			r.SetEsc(n.Esc())
diff --git a/src/cmd/compile/internal/walk/temp.go b/src/cmd/compile/internal/walk/temp.go
index 901cb770f3..9879a6c69d 100644
--- a/src/cmd/compile/internal/walk/temp.go
+++ b/src/cmd/compile/internal/walk/temp.go
@@ -12,19 +12,12 @@ import (
 )
 
 // initStackTemp appends statements to init to initialize the given
-// temporary variable, and then returns the expression &tmp. If vardef
-// is true, then the variable is initialized with OVARDEF, and the
-// caller must ensure the variable is later assigned before use;
-// otherwise, it's zero initialized.
-//
-// TODO(mdempsky): Change callers to provide tmp's initial value,
-// rather than just vardef, to make this safer/easier to use.
-func initStackTemp(init *ir.Nodes, tmp *ir.Name, vardef bool) *ir.AddrExpr {
-	if vardef {
-		init.Append(ir.NewUnaryExpr(base.Pos, ir.OVARDEF, tmp))
-	} else {
-		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, tmp, nil))
+// temporary variable to val, and then returns the expression &tmp.
+func initStackTemp(init *ir.Nodes, tmp *ir.Name, val ir.Node) *ir.AddrExpr {
+	if val != nil && !types.Identical(tmp.Type(), val.Type()) {
+		base.Fatalf("bad initial value for %L: %L", tmp, val)
 	}
+	appendWalkStmt(init, ir.NewAssignStmt(base.Pos, tmp, val))
 	return typecheck.Expr(typecheck.NodAddr(tmp)).(*ir.AddrExpr)
 }
 
@@ -32,7 +25,7 @@ func initStackTemp(init *ir.Nodes, tmp *ir.Name, vardef bool) *ir.AddrExpr {
 // allocated temporary variable of the given type. Statements to
 // zero-initialize tmp are appended to init.
 func stackTempAddr(init *ir.Nodes, typ *types.Type) *ir.AddrExpr {
-	return initStackTemp(init, typecheck.Temp(typ), false)
+	return initStackTemp(init, typecheck.Temp(typ), nil)
 }
 
 // stackBufAddr returns thte expression &tmp, where tmp is a newly
-- 
GitLab


From 88956fc4b1a44efe847fa07a8ebc21a49ff811e1 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Sun, 17 Jan 2021 00:17:59 +0700
Subject: [PATCH 0501/2400] [dev.regabi] cmd/compile: stop analyze
 NameOffsetExpr.Name_ in escape analysis

It is always used with global variables, so we can skip analyze it, the
same as what we are doing for ONAME/PEXTERN nodes.

While at it, add a Fatalf check to ensure NewNameOffsetExpr is only
called for global variables.

For #43737

Change-Id: Iac444ed8d583baba5042bea096531301843b1e8f
Reviewed-on: https://go-review.googlesource.com/c/go/+/284118
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/escape/escape.go | 9 ++-------
 src/cmd/compile/internal/ir/expr.go       | 4 ++--
 2 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index 96c2e02146..356fbc75f8 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -585,7 +585,7 @@ func (e *escape) exprSkipInit(k hole, n ir.Node) {
 	default:
 		base.Fatalf("unexpected expr: %v", n)
 
-	case ir.OLITERAL, ir.ONIL, ir.OGETG, ir.OTYPE, ir.OMETHEXPR:
+	case ir.OLITERAL, ir.ONIL, ir.OGETG, ir.OTYPE, ir.OMETHEXPR, ir.ONAMEOFFSET:
 		// nop
 
 	case ir.ONAME:
@@ -598,10 +598,6 @@ func (e *escape) exprSkipInit(k hole, n ir.Node) {
 		}
 		e.flow(k, e.oldLoc(n))
 
-	case ir.ONAMEOFFSET:
-		n := n.(*ir.NameOffsetExpr)
-		e.expr(k, n.Name_)
-
 	case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT:
 		n := n.(*ir.UnaryExpr)
 		e.discard(n.X)
@@ -876,8 +872,7 @@ func (e *escape) addr(n ir.Node) hole {
 		}
 		k = e.oldLoc(n).asHole()
 	case ir.ONAMEOFFSET:
-		n := n.(*ir.NameOffsetExpr)
-		k = e.addr(n.Name_)
+		break
 	case ir.ODOT:
 		n := n.(*ir.SelectorExpr)
 		k = e.addr(n.X)
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 4631476973..e24b2d5b2c 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -470,8 +470,8 @@ type NameOffsetExpr struct {
 }
 
 func NewNameOffsetExpr(pos src.XPos, name *Name, offset int64, typ *types.Type) *NameOffsetExpr {
-	if name == nil || IsBlank(name) {
-		base.FatalfAt(pos, "cannot take offset of nil or blank name: %v", name)
+	if name == nil || IsBlank(name) || !(name.Op() == ONAME && name.Class == PEXTERN) {
+		base.FatalfAt(pos, "cannot take offset of nil, blank name or non-global variable: %v", name)
 	}
 	n := &NameOffsetExpr{Name_: name, Offset_: offset}
 	n.typ = typ
-- 
GitLab


From 82b9cae700d844857b24b31f40a51283fbdd6dd5 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Sun, 17 Jan 2021 00:38:54 +0700
Subject: [PATCH 0502/2400] [dev.regabi] cmd/compile: change ir.NameOffsetExpr
 to use *obj.LSym instead of *Name

Because NameOffsetExpr is always used with global variables, and SSA
backend only needs (*Name).Linksym() to generate value for them.

Passes toolstash -cmp.

Updates #43737

Change-Id: I17209e21383edb766070c0accd1fa4660659caef
Reviewed-on: https://go-review.googlesource.com/c/go/+/284119
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/expr.go     | 17 ++++++++++-----
 src/cmd/compile/internal/ir/fmt.go      |  2 +-
 src/cmd/compile/internal/ir/node_gen.go |  6 -----
 src/cmd/compile/internal/ssagen/ssa.go  | 29 ++++++++++---------------
 4 files changed, 24 insertions(+), 30 deletions(-)

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index e24b2d5b2c..a3356d432a 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -8,6 +8,7 @@ import (
 	"bytes"
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
+	"cmd/internal/obj"
 	"cmd/internal/src"
 	"fmt"
 	"go/constant"
@@ -461,22 +462,26 @@ func NewResultExpr(pos src.XPos, typ *types.Type, offset int64) *ResultExpr {
 	return n
 }
 
-// A NameOffsetExpr refers to an offset within a variable.
+// A NameOffsetExpr refers to an offset within a global variable.
 // It is like a SelectorExpr but without the field name.
 type NameOffsetExpr struct {
 	miniExpr
-	Name_   *Name
+	Linksym *obj.LSym
 	Offset_ int64
 }
 
+func NewLinksymOffsetExpr(pos src.XPos, lsym *obj.LSym, offset int64, typ *types.Type) *NameOffsetExpr {
+	n := &NameOffsetExpr{Linksym: lsym, Offset_: offset}
+	n.typ = typ
+	n.op = ONAMEOFFSET
+	return n
+}
+
 func NewNameOffsetExpr(pos src.XPos, name *Name, offset int64, typ *types.Type) *NameOffsetExpr {
 	if name == nil || IsBlank(name) || !(name.Op() == ONAME && name.Class == PEXTERN) {
 		base.FatalfAt(pos, "cannot take offset of nil, blank name or non-global variable: %v", name)
 	}
-	n := &NameOffsetExpr{Name_: name, Offset_: offset}
-	n.typ = typ
-	n.op = ONAMEOFFSET
-	return n
+	return NewLinksymOffsetExpr(pos, name.Linksym(), offset, typ)
 }
 
 // A SelectorExpr is a selector expression X.Sel.
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index a4e769f508..dfb8e42270 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -634,7 +634,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 
 	case ONAMEOFFSET:
 		n := n.(*NameOffsetExpr)
-		fmt.Fprintf(s, "(%v)(%v@%d)", n.Type(), n.Name_, n.Offset_)
+		fmt.Fprintf(s, "(%v)(%s@%d)", n.Type(), n.Linksym.Name, n.Offset_)
 
 	case OTYPE:
 		if n.Type() == nil && n.Sym() != nil {
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index f1b0a21628..7db9517b2c 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -825,16 +825,10 @@ func (n *NameOffsetExpr) doChildren(do func(Node) bool) bool {
 	if doNodes(n.init, do) {
 		return true
 	}
-	if n.Name_ != nil && do(n.Name_) {
-		return true
-	}
 	return false
 }
 func (n *NameOffsetExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
-	if n.Name_ != nil {
-		n.Name_ = edit(n.Name_).(*Name)
-	}
 }
 
 func (n *NilExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 7726ecac55..fce02f475a 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -2257,15 +2257,10 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		if s.canSSA(n) {
 			return s.variable(n, n.Type())
 		}
-		addr := s.addr(n)
-		return s.load(n.Type(), addr)
+		return s.load(n.Type(), s.addr(n))
 	case ir.ONAMEOFFSET:
 		n := n.(*ir.NameOffsetExpr)
-		if s.canSSAName(n.Name_) && TypeOK(n.Type()) {
-			return s.variable(n, n.Type())
-		}
-		addr := s.addr(n)
-		return s.load(n.Type(), addr)
+		return s.load(n.Type(), s.addr(n))
 	case ir.ONIL:
 		n := n.(*ir.NilExpr)
 		t := n.Type()
@@ -5088,13 +5083,18 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 	}
 
 	t := types.NewPtr(n.Type())
-	var offset int64
+	linksymOffset := func(lsym *obj.LSym, offset int64) *ssa.Value {
+		v := s.entryNewValue1A(ssa.OpAddr, t, lsym, s.sb)
+		// TODO: Make OpAddr use AuxInt as well as Aux.
+		if offset != 0 {
+			v = s.entryNewValue1I(ssa.OpOffPtr, v.Type, offset, v)
+		}
+		return v
+	}
 	switch n.Op() {
 	case ir.ONAMEOFFSET:
 		no := n.(*ir.NameOffsetExpr)
-		offset = no.Offset_
-		n = no.Name_
-		fallthrough
+		return linksymOffset(no.Linksym, no.Offset_)
 	case ir.ONAME:
 		n := n.(*ir.Name)
 		if n.Heapaddr != nil {
@@ -5103,12 +5103,7 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 		switch n.Class {
 		case ir.PEXTERN:
 			// global variable
-			v := s.entryNewValue1A(ssa.OpAddr, t, n.Linksym(), s.sb)
-			// TODO: Make OpAddr use AuxInt as well as Aux.
-			if offset != 0 {
-				v = s.entryNewValue1I(ssa.OpOffPtr, v.Type, offset, v)
-			}
-			return v
+			return linksymOffset(n.Linksym(), 0)
 		case ir.PPARAM:
 			// parameter slot
 			v := s.decladdrs[n]
-- 
GitLab


From 59ff93fe645320c7d6a434ea7794546e89b12d45 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Sun, 17 Jan 2021 00:47:12 +0700
Subject: [PATCH 0503/2400] [dev.regabi] cmd/compile: rename NameOffsetExpr to
 LinksymOffsetExpr

Updates #43737

[git-generate]

cd src/cmd/compile/internal/ir

rf '
  mv NameOffsetExpr LinksymOffsetExpr
  mv ONAMEOFFSET OLINKSYMOFFSET
'

go generate

Change-Id: I8c6b8aa576e88278c0320d16bb2e8e424a15b907
Reviewed-on: https://go-review.googlesource.com/c/go/+/284120
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/escape/escape.go     |  4 +--
 src/cmd/compile/internal/ir/expr.go           | 14 ++++----
 src/cmd/compile/internal/ir/fmt.go            |  4 +--
 src/cmd/compile/internal/ir/node.go           | 26 +++++++--------
 src/cmd/compile/internal/ir/node_gen.go       | 32 +++++++++----------
 src/cmd/compile/internal/ir/op_string.go      |  6 ++--
 src/cmd/compile/internal/ssagen/ssa.go        |  8 ++---
 .../compile/internal/typecheck/typecheck.go   |  2 +-
 src/cmd/compile/internal/walk/expr.go         |  4 +--
 src/cmd/compile/internal/walk/walk.go         |  2 +-
 10 files changed, 51 insertions(+), 51 deletions(-)

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index 356fbc75f8..26420b820a 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -585,7 +585,7 @@ func (e *escape) exprSkipInit(k hole, n ir.Node) {
 	default:
 		base.Fatalf("unexpected expr: %v", n)
 
-	case ir.OLITERAL, ir.ONIL, ir.OGETG, ir.OTYPE, ir.OMETHEXPR, ir.ONAMEOFFSET:
+	case ir.OLITERAL, ir.ONIL, ir.OGETG, ir.OTYPE, ir.OMETHEXPR, ir.OLINKSYMOFFSET:
 		// nop
 
 	case ir.ONAME:
@@ -871,7 +871,7 @@ func (e *escape) addr(n ir.Node) hole {
 			break
 		}
 		k = e.oldLoc(n).asHole()
-	case ir.ONAMEOFFSET:
+	case ir.OLINKSYMOFFSET:
 		break
 	case ir.ODOT:
 		n := n.(*ir.SelectorExpr)
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index a3356d432a..8aad25d625 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -462,22 +462,22 @@ func NewResultExpr(pos src.XPos, typ *types.Type, offset int64) *ResultExpr {
 	return n
 }
 
-// A NameOffsetExpr refers to an offset within a global variable.
+// A LinksymOffsetExpr refers to an offset within a global variable.
 // It is like a SelectorExpr but without the field name.
-type NameOffsetExpr struct {
+type LinksymOffsetExpr struct {
 	miniExpr
 	Linksym *obj.LSym
 	Offset_ int64
 }
 
-func NewLinksymOffsetExpr(pos src.XPos, lsym *obj.LSym, offset int64, typ *types.Type) *NameOffsetExpr {
-	n := &NameOffsetExpr{Linksym: lsym, Offset_: offset}
+func NewLinksymOffsetExpr(pos src.XPos, lsym *obj.LSym, offset int64, typ *types.Type) *LinksymOffsetExpr {
+	n := &LinksymOffsetExpr{Linksym: lsym, Offset_: offset}
 	n.typ = typ
-	n.op = ONAMEOFFSET
+	n.op = OLINKSYMOFFSET
 	return n
 }
 
-func NewNameOffsetExpr(pos src.XPos, name *Name, offset int64, typ *types.Type) *NameOffsetExpr {
+func NewNameOffsetExpr(pos src.XPos, name *Name, offset int64, typ *types.Type) *LinksymOffsetExpr {
 	if name == nil || IsBlank(name) || !(name.Op() == ONAME && name.Class == PEXTERN) {
 		base.FatalfAt(pos, "cannot take offset of nil, blank name or non-global variable: %v", name)
 	}
@@ -731,7 +731,7 @@ func IsAddressable(n Node) bool {
 		}
 		return true
 
-	case ONAMEOFFSET:
+	case OLINKSYMOFFSET:
 		return true
 	}
 
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index dfb8e42270..68e1bc1569 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -632,8 +632,8 @@ func exprFmt(n Node, s fmt.State, prec int) {
 	case OPACK, ONONAME:
 		fmt.Fprint(s, n.Sym())
 
-	case ONAMEOFFSET:
-		n := n.(*NameOffsetExpr)
+	case OLINKSYMOFFSET:
+		n := n.(*LinksymOffsetExpr)
 		fmt.Fprintf(s, "(%v)(%s@%d)", n.Type(), n.Linksym.Name, n.Offset_)
 
 	case OTYPE:
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index a44bf42e78..a725307c2c 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -291,19 +291,19 @@ const (
 	OTSLICE // []int
 
 	// misc
-	OINLCALL    // intermediary representation of an inlined call.
-	OEFACE      // itable and data words of an empty-interface value.
-	OITAB       // itable word of an interface value.
-	OIDATA      // data word of an interface value in Left
-	OSPTR       // base pointer of a slice or string.
-	OCFUNC      // reference to c function pointer (not go func value)
-	OCHECKNIL   // emit code to ensure pointer/interface not nil
-	OVARDEF     // variable is about to be fully initialized
-	OVARKILL    // variable is dead
-	OVARLIVE    // variable is alive
-	ORESULT     // result of a function call; Xoffset is stack offset
-	OINLMARK    // start of an inlined body, with file/line of caller. Xoffset is an index into the inline tree.
-	ONAMEOFFSET // offset within a name
+	OINLCALL       // intermediary representation of an inlined call.
+	OEFACE         // itable and data words of an empty-interface value.
+	OITAB          // itable word of an interface value.
+	OIDATA         // data word of an interface value in Left
+	OSPTR          // base pointer of a slice or string.
+	OCFUNC         // reference to c function pointer (not go func value)
+	OCHECKNIL      // emit code to ensure pointer/interface not nil
+	OVARDEF        // variable is about to be fully initialized
+	OVARKILL       // variable is dead
+	OVARLIVE       // variable is alive
+	ORESULT        // result of a function call; Xoffset is stack offset
+	OINLMARK       // start of an inlined body, with file/line of caller. Xoffset is an index into the inline tree.
+	OLINKSYMOFFSET // offset within a name
 
 	// arch-specific opcodes
 	ORETJMP // return to other function
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index 7db9517b2c..8f89c67748 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -734,6 +734,22 @@ func (n *LabelStmt) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
 }
 
+func (n *LinksymOffsetExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *LinksymOffsetExpr) copy() Node {
+	c := *n
+	c.init = copyNodes(c.init)
+	return &c
+}
+func (n *LinksymOffsetExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
+	}
+	return false
+}
+func (n *LinksymOffsetExpr) editChildren(edit func(Node) Node) {
+	editNodes(n.init, edit)
+}
+
 func (n *LogicalExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *LogicalExpr) copy() Node {
 	c := *n
@@ -815,22 +831,6 @@ func (n *MapType) editChildren(edit func(Node) Node) {
 
 func (n *Name) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 
-func (n *NameOffsetExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
-func (n *NameOffsetExpr) copy() Node {
-	c := *n
-	c.init = copyNodes(c.init)
-	return &c
-}
-func (n *NameOffsetExpr) doChildren(do func(Node) bool) bool {
-	if doNodes(n.init, do) {
-		return true
-	}
-	return false
-}
-func (n *NameOffsetExpr) editChildren(edit func(Node) Node) {
-	editNodes(n.init, edit)
-}
-
 func (n *NilExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *NilExpr) copy() Node {
 	c := *n
diff --git a/src/cmd/compile/internal/ir/op_string.go b/src/cmd/compile/internal/ir/op_string.go
index 9538599c38..35196b01ae 100644
--- a/src/cmd/compile/internal/ir/op_string.go
+++ b/src/cmd/compile/internal/ir/op_string.go
@@ -156,15 +156,15 @@ func _() {
 	_ = x[OVARLIVE-145]
 	_ = x[ORESULT-146]
 	_ = x[OINLMARK-147]
-	_ = x[ONAMEOFFSET-148]
+	_ = x[OLINKSYMOFFSET-148]
 	_ = x[ORETJMP-149]
 	_ = x[OGETG-150]
 	_ = x[OEND-151]
 }
 
-const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKNAMEOFFSETRETJMPGETGEND"
+const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKLINKSYMOFFSETRETJMPGETGEND"
 
-var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 388, 391, 400, 403, 407, 415, 422, 431, 444, 447, 450, 453, 456, 459, 462, 468, 471, 474, 480, 484, 487, 491, 496, 501, 507, 512, 516, 521, 529, 537, 543, 552, 563, 570, 574, 581, 589, 593, 597, 601, 608, 615, 623, 629, 637, 645, 650, 655, 659, 667, 672, 676, 679, 687, 691, 693, 698, 700, 705, 711, 717, 723, 729, 734, 738, 745, 751, 756, 762, 768, 775, 780, 784, 789, 793, 798, 806, 812, 819, 826, 832, 839, 849, 855, 859, 862}
+var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 388, 391, 400, 403, 407, 415, 422, 431, 444, 447, 450, 453, 456, 459, 462, 468, 471, 474, 480, 484, 487, 491, 496, 501, 507, 512, 516, 521, 529, 537, 543, 552, 563, 570, 574, 581, 589, 593, 597, 601, 608, 615, 623, 629, 637, 645, 650, 655, 659, 667, 672, 676, 679, 687, 691, 693, 698, 700, 705, 711, 717, 723, 729, 734, 738, 745, 751, 756, 762, 768, 775, 780, 784, 789, 793, 798, 806, 812, 819, 826, 832, 839, 852, 858, 862, 865}
 
 func (i Op) String() string {
 	if i >= Op(len(_Op_index)-1) {
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index fce02f475a..1cd49a487e 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -2258,8 +2258,8 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 			return s.variable(n, n.Type())
 		}
 		return s.load(n.Type(), s.addr(n))
-	case ir.ONAMEOFFSET:
-		n := n.(*ir.NameOffsetExpr)
+	case ir.OLINKSYMOFFSET:
+		n := n.(*ir.LinksymOffsetExpr)
 		return s.load(n.Type(), s.addr(n))
 	case ir.ONIL:
 		n := n.(*ir.NilExpr)
@@ -5092,8 +5092,8 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 		return v
 	}
 	switch n.Op() {
-	case ir.ONAMEOFFSET:
-		no := n.(*ir.NameOffsetExpr)
+	case ir.OLINKSYMOFFSET:
+		no := n.(*ir.LinksymOffsetExpr)
 		return linksymOffset(no.Linksym, no.Offset_)
 	case ir.ONAME:
 		n := n.(*ir.Name)
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 3530e76972..5b44a5743f 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -521,7 +521,7 @@ func typecheck1(n ir.Node, top int) ir.Node {
 		}
 		return n
 
-	case ir.ONAMEOFFSET:
+	case ir.OLINKSYMOFFSET:
 		// type already set
 		return n
 
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 8a13f6a923..82a76dc239 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -85,7 +85,7 @@ func walkExpr1(n ir.Node, init *ir.Nodes) ir.Node {
 	case ir.ONONAME, ir.OGETG:
 		return n
 
-	case ir.OTYPE, ir.ONAME, ir.OLITERAL, ir.ONIL, ir.ONAMEOFFSET:
+	case ir.OTYPE, ir.ONAME, ir.OLITERAL, ir.ONIL, ir.OLINKSYMOFFSET:
 		// TODO(mdempsky): Just return n; see discussion on CL 38655.
 		// Perhaps refactor to use Node.mayBeShared for these instead.
 		// If these return early, make sure to still call
@@ -357,7 +357,7 @@ func safeExpr(n ir.Node, init *ir.Nodes) ir.Node {
 	}
 
 	switch n.Op() {
-	case ir.ONAME, ir.OLITERAL, ir.ONIL, ir.ONAMEOFFSET:
+	case ir.ONAME, ir.OLITERAL, ir.ONIL, ir.OLINKSYMOFFSET:
 		return n
 
 	case ir.OLEN, ir.OCAP:
diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index a9672a261b..f214551617 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -316,7 +316,7 @@ func mayCall(n ir.Node) bool {
 			n := n.(*ir.ConvExpr)
 			return ssagen.Arch.SoftFloat && (isSoftFloat(n.Type()) || isSoftFloat(n.X.Type()))
 
-		case ir.OLITERAL, ir.ONIL, ir.ONAME, ir.ONAMEOFFSET, ir.OMETHEXPR,
+		case ir.OLITERAL, ir.ONIL, ir.ONAME, ir.OLINKSYMOFFSET, ir.OMETHEXPR,
 			ir.OAND, ir.OANDNOT, ir.OLSH, ir.OOR, ir.ORSH, ir.OXOR, ir.OCOMPLEX, ir.OEFACE,
 			ir.OANDAND, ir.OOROR,
 			ir.OADDR, ir.OBITNOT, ir.ONOT, ir.OPLUS,
-- 
GitLab


From e3027c6828230d01089afec0ab958040ba326abc Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 16 Jan 2021 22:27:23 -0800
Subject: [PATCH 0504/2400] [dev.regabi] cmd/compile: fix linux-amd64-noopt
 builder

CL 284223 tightened down the allowed expressions in mayCall, but
evidently a little too tight. The linux-amd64-noopt builder does in
fact see expressions with non-empty Init lists in arguments list.

Since I believe these can only appear on the RHS of LogicalExpr
expressions, this CL relaxes that one case.

Change-Id: I1e6bbd0449778c40ed2610b3e1ef6a825a84ada7
Reviewed-on: https://go-review.googlesource.com/c/go/+/284226
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/walk/walk.go | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index f214551617..399fb2462b 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -305,6 +305,14 @@ func mayCall(n ir.Node) bool {
 			// before we start marshaling args for a call. See issue 16760.
 			return true
 
+		case ir.OANDAND, ir.OOROR:
+			n := n.(*ir.LogicalExpr)
+			// The RHS expression may have init statements that
+			// should only execute conditionally, and so cannot be
+			// pulled out to the top-level init list. We could try
+			// to be more precise here.
+			return len(n.Y.Init()) != 0
+
 		// When using soft-float, these ops might be rewritten to function calls
 		// so we ensure they are evaluated first.
 		case ir.OADD, ir.OSUB, ir.OMUL, ir.ONEG:
@@ -318,7 +326,6 @@ func mayCall(n ir.Node) bool {
 
 		case ir.OLITERAL, ir.ONIL, ir.ONAME, ir.OLINKSYMOFFSET, ir.OMETHEXPR,
 			ir.OAND, ir.OANDNOT, ir.OLSH, ir.OOR, ir.ORSH, ir.OXOR, ir.OCOMPLEX, ir.OEFACE,
-			ir.OANDAND, ir.OOROR,
 			ir.OADDR, ir.OBITNOT, ir.ONOT, ir.OPLUS,
 			ir.OCAP, ir.OIMAG, ir.OLEN, ir.OREAL,
 			ir.OCONVNOP, ir.ODOT,
-- 
GitLab


From 87845d14f9822c104cc192c8f7858a2a24d0029f Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 17 Jan 2021 00:30:32 -0800
Subject: [PATCH 0505/2400] [dev.regabi] cmd/compile: add ir.TailCallStmt

This CL splits out ORETJMP as a new TailCallStmt node, separate from
the other BranchStmt nodes. In doing so, this allows us to change it
from identifying a function by *types.Sym to identifying one by
directly pointing to the *ir.Func.

While here, also rename the operation to OTAILCALL.

Passes toolstash -cmp.

Change-Id: I273e6ea5d92bf3005ae02fb59b3240a190a6cf1b
Reviewed-on: https://go-review.googlesource.com/c/go/+/284227
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/deadcode/deadcode.go |  2 +-
 src/cmd/compile/internal/escape/escape.go     |  4 ++--
 src/cmd/compile/internal/inline/inl.go        |  2 +-
 src/cmd/compile/internal/ir/fmt.go            |  6 ++---
 src/cmd/compile/internal/ir/node.go           |  4 ++--
 src/cmd/compile/internal/ir/node_gen.go       | 22 +++++++++++++++++++
 src/cmd/compile/internal/ir/op_string.go      |  6 ++---
 src/cmd/compile/internal/ir/stmt.go           | 22 +++++++++++++++----
 .../compile/internal/reflectdata/reflect.go   |  2 +-
 src/cmd/compile/internal/ssagen/abi.go        |  2 +-
 src/cmd/compile/internal/ssagen/ssa.go        |  6 ++---
 .../compile/internal/typecheck/typecheck.go   |  6 ++---
 src/cmd/compile/internal/walk/order.go        |  2 +-
 src/cmd/compile/internal/walk/stmt.go         |  4 ++--
 14 files changed, 63 insertions(+), 27 deletions(-)

diff --git a/src/cmd/compile/internal/deadcode/deadcode.go b/src/cmd/compile/internal/deadcode/deadcode.go
index c409320fc4..520203787f 100644
--- a/src/cmd/compile/internal/deadcode/deadcode.go
+++ b/src/cmd/compile/internal/deadcode/deadcode.go
@@ -75,7 +75,7 @@ func stmts(nn *ir.Nodes) {
 				// might be the target of a goto. See issue 28616.
 				if body := body; len(body) != 0 {
 					switch body[(len(body) - 1)].Op() {
-					case ir.ORETURN, ir.ORETJMP, ir.OPANIC:
+					case ir.ORETURN, ir.OTAILCALL, ir.OPANIC:
 						if i > lastLabel {
 							cut = true
 						}
diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index 26420b820a..5ee6d4f498 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -534,8 +534,8 @@ func (e *escape) stmt(n ir.Node) {
 		e.stmts(n.Call.Init())
 		e.call(nil, n.Call, n)
 
-	case ir.ORETJMP:
-		// TODO(mdempsky): What do? esc.go just ignores it.
+	case ir.OTAILCALL:
+		// TODO(mdempsky): Treat like a normal call? esc.go used to just ignore it.
 	}
 }
 
diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 4bb849cdae..143fbe9efe 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -359,7 +359,7 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 		ir.OGO,
 		ir.ODEFER,
 		ir.ODCLTYPE, // can't print yet
-		ir.ORETJMP:
+		ir.OTAILCALL:
 		return errors.New("unhandled op " + n.Op().String())
 
 	case ir.OAPPEND:
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 68e1bc1569..ee6a62625a 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -378,9 +378,9 @@ func stmtFmt(n Node, s fmt.State) {
 		n := n.(*ReturnStmt)
 		fmt.Fprintf(s, "return %.v", n.Results)
 
-	case ORETJMP:
-		n := n.(*BranchStmt)
-		fmt.Fprintf(s, "retjmp %v", n.Label)
+	case OTAILCALL:
+		n := n.(*TailCallStmt)
+		fmt.Fprintf(s, "tailcall %v", n.Target)
 
 	case OINLMARK:
 		n := n.(*InlineMarkStmt)
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index a725307c2c..291e1286bb 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -306,8 +306,8 @@ const (
 	OLINKSYMOFFSET // offset within a name
 
 	// arch-specific opcodes
-	ORETJMP // return to other function
-	OGETG   // runtime.getg() (read g pointer)
+	OTAILCALL // tail call to another function
+	OGETG     // runtime.getg() (read g pointer)
 
 	OEND
 )
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index 8f89c67748..af9ee8d86e 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -1227,6 +1227,28 @@ func (n *SwitchStmt) editChildren(edit func(Node) Node) {
 	editNodes(n.Compiled, edit)
 }
 
+func (n *TailCallStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *TailCallStmt) copy() Node {
+	c := *n
+	c.init = copyNodes(c.init)
+	return &c
+}
+func (n *TailCallStmt) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
+	}
+	if n.Target != nil && do(n.Target) {
+		return true
+	}
+	return false
+}
+func (n *TailCallStmt) editChildren(edit func(Node) Node) {
+	editNodes(n.init, edit)
+	if n.Target != nil {
+		n.Target = edit(n.Target).(*Name)
+	}
+}
+
 func (n *TypeAssertExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *TypeAssertExpr) copy() Node {
 	c := *n
diff --git a/src/cmd/compile/internal/ir/op_string.go b/src/cmd/compile/internal/ir/op_string.go
index 35196b01ae..15c60baf44 100644
--- a/src/cmd/compile/internal/ir/op_string.go
+++ b/src/cmd/compile/internal/ir/op_string.go
@@ -157,14 +157,14 @@ func _() {
 	_ = x[ORESULT-146]
 	_ = x[OINLMARK-147]
 	_ = x[OLINKSYMOFFSET-148]
-	_ = x[ORETJMP-149]
+	_ = x[OTAILCALL-149]
 	_ = x[OGETG-150]
 	_ = x[OEND-151]
 }
 
-const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKLINKSYMOFFSETRETJMPGETGEND"
+const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKLINKSYMOFFSETTAILCALLGETGEND"
 
-var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 388, 391, 400, 403, 407, 415, 422, 431, 444, 447, 450, 453, 456, 459, 462, 468, 471, 474, 480, 484, 487, 491, 496, 501, 507, 512, 516, 521, 529, 537, 543, 552, 563, 570, 574, 581, 589, 593, 597, 601, 608, 615, 623, 629, 637, 645, 650, 655, 659, 667, 672, 676, 679, 687, 691, 693, 698, 700, 705, 711, 717, 723, 729, 734, 738, 745, 751, 756, 762, 768, 775, 780, 784, 789, 793, 798, 806, 812, 819, 826, 832, 839, 852, 858, 862, 865}
+var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 388, 391, 400, 403, 407, 415, 422, 431, 444, 447, 450, 453, 456, 459, 462, 468, 471, 474, 480, 484, 487, 491, 496, 501, 507, 512, 516, 521, 529, 537, 543, 552, 563, 570, 574, 581, 589, 593, 597, 601, 608, 615, 623, 629, 637, 645, 650, 655, 659, 667, 672, 676, 679, 687, 691, 693, 698, 700, 705, 711, 717, 723, 729, 734, 738, 745, 751, 756, 762, 768, 775, 780, 784, 789, 793, 798, 806, 812, 819, 826, 832, 839, 852, 860, 864, 867}
 
 func (i Op) String() string {
 	if i >= Op(len(_Op_index)-1) {
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index 0358569a1f..c304867e1d 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -144,9 +144,6 @@ func NewBlockStmt(pos src.XPos, list []Node) *BlockStmt {
 }
 
 // A BranchStmt is a break, continue, fallthrough, or goto statement.
-//
-// For back-end code generation, Op may also be RETJMP (return+jump),
-// in which case the label names another function entirely.
 type BranchStmt struct {
 	miniStmt
 	Label *types.Sym // label if present
@@ -154,7 +151,7 @@ type BranchStmt struct {
 
 func NewBranchStmt(pos src.XPos, op Op, label *types.Sym) *BranchStmt {
 	switch op {
-	case OBREAK, OCONTINUE, OFALL, OGOTO, ORETJMP:
+	case OBREAK, OCONTINUE, OFALL, OGOTO:
 		// ok
 	default:
 		panic("NewBranch " + op.String())
@@ -384,6 +381,23 @@ func NewSwitchStmt(pos src.XPos, tag Node, cases []*CaseClause) *SwitchStmt {
 	return n
 }
 
+// A TailCallStmt is a tail call statement, which is used for back-end
+// code generation to jump directly to another function entirely.
+type TailCallStmt struct {
+	miniStmt
+	Target *Name
+}
+
+func NewTailCallStmt(pos src.XPos, target *Name) *TailCallStmt {
+	if target.Op() != ONAME || target.Class != PFUNC {
+		base.FatalfAt(pos, "tail call to non-func %v", target)
+	}
+	n := &TailCallStmt{Target: target}
+	n.pos = pos
+	n.op = OTAILCALL
+	return n
+}
+
 // A TypeSwitchGuard is the [Name :=] X.(type) in a type switch.
 type TypeSwitchGuard struct {
 	miniNode
diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index efe863cc3f..fd3e6beaa3 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -1794,7 +1794,7 @@ func methodWrapper(rcvr *types.Type, method *types.Field) *obj.LSym {
 		}
 		as := ir.NewAssignStmt(base.Pos, nthis, typecheck.ConvNop(left, rcvr))
 		fn.Body.Append(as)
-		fn.Body.Append(ir.NewBranchStmt(base.Pos, ir.ORETJMP, ir.MethodSym(methodrcvr, method.Sym)))
+		fn.Body.Append(ir.NewTailCallStmt(base.Pos, method.Nname.(*ir.Name)))
 	} else {
 		fn.SetWrapper(true) // ignore frame for panic+recover matching
 		call := ir.NewCallExpr(base.Pos, ir.OCALL, dot, nil)
diff --git a/src/cmd/compile/internal/ssagen/abi.go b/src/cmd/compile/internal/ssagen/abi.go
index 274c543ca5..b5da420872 100644
--- a/src/cmd/compile/internal/ssagen/abi.go
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -303,7 +303,7 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 	var tail ir.Node
 	if tfn.Type().NumResults() == 0 && tfn.Type().NumParams() == 0 && tfn.Type().NumRecvs() == 0 && !(base.Ctxt.Arch.Name == "ppc64le" && base.Ctxt.Flag_dynlink) {
 
-		tail = ir.NewBranchStmt(base.Pos, ir.ORETJMP, f.Nname.Sym())
+		tail = ir.NewTailCallStmt(base.Pos, f.Nname)
 	} else {
 		call := ir.NewCallExpr(base.Pos, ir.OCALL, f.Nname, nil)
 		call.Args = ir.ParamNames(tfn.Type())
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 1cd49a487e..beef0d8234 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -1580,11 +1580,11 @@ func (s *state) stmt(n ir.Node) {
 		b := s.exit()
 		b.Pos = s.lastPos.WithIsStmt()
 
-	case ir.ORETJMP:
-		n := n.(*ir.BranchStmt)
+	case ir.OTAILCALL:
+		n := n.(*ir.TailCallStmt)
 		b := s.exit()
 		b.Kind = ssa.BlockRetJmp // override BlockRet
-		b.Aux = callTargetLSym(n.Label, s.curfn.LSym)
+		b.Aux = callTargetLSym(n.Target.Sym(), s.curfn.LSym)
 
 	case ir.OCONTINUE, ir.OBREAK:
 		n := n.(*ir.BranchStmt)
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 5b44a5743f..7881ea308d 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -857,8 +857,8 @@ func typecheck1(n ir.Node, top int) ir.Node {
 		n := n.(*ir.ReturnStmt)
 		return tcReturn(n)
 
-	case ir.ORETJMP:
-		n := n.(*ir.BranchStmt)
+	case ir.OTAILCALL:
+		n := n.(*ir.TailCallStmt)
 		return n
 
 	case ir.OSELECT:
@@ -2023,7 +2023,7 @@ func isTermNode(n ir.Node) bool {
 		n := n.(*ir.BlockStmt)
 		return isTermNodes(n.List)
 
-	case ir.OGOTO, ir.ORETURN, ir.ORETJMP, ir.OPANIC, ir.OFALL:
+	case ir.OGOTO, ir.ORETURN, ir.OTAILCALL, ir.OPANIC, ir.OFALL:
 		return true
 
 	case ir.OFOR, ir.OFORUNTIL:
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index d34c58009a..e1e9f168bb 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -692,7 +692,7 @@ func (o *orderState) stmt(n ir.Node) {
 		ir.OFALL,
 		ir.OGOTO,
 		ir.OLABEL,
-		ir.ORETJMP:
+		ir.OTAILCALL:
 		o.out = append(o.out, n)
 
 	// Special: handle call arguments.
diff --git a/src/cmd/compile/internal/walk/stmt.go b/src/cmd/compile/internal/walk/stmt.go
index d892b2413f..46a621c2ba 100644
--- a/src/cmd/compile/internal/walk/stmt.go
+++ b/src/cmd/compile/internal/walk/stmt.go
@@ -136,8 +136,8 @@ func walkStmt(n ir.Node) ir.Node {
 		n := n.(*ir.ReturnStmt)
 		return walkReturn(n)
 
-	case ir.ORETJMP:
-		n := n.(*ir.BranchStmt)
+	case ir.OTAILCALL:
+		n := n.(*ir.TailCallStmt)
 		return n
 
 	case ir.OINLMARK:
-- 
GitLab


From 99a5db11acc48794b703bee395a08848d49da41c Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 17 Jan 2021 01:13:34 -0800
Subject: [PATCH 0506/2400] [dev.regabi] cmd/compile: use LinksymOffsetExpr in
 walkConvInterface

This CL updates walkConvInterface to use LinksymOffsetExpr for
referencing runtime.staticuint64s and runtime.zerobase.

Passes toolstash -cmp (surprisingly).

Change-Id: Iad7e30371f89c8a5e176b5ddbc53faf57012ba0d
Reviewed-on: https://go-review.googlesource.com/c/go/+/284229
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/ir/expr.go      |  7 +++++++
 src/cmd/compile/internal/ir/symtab.go    |  7 +------
 src/cmd/compile/internal/ssagen/ssa.go   |  1 +
 src/cmd/compile/internal/walk/convert.go | 18 +++++-------------
 4 files changed, 14 insertions(+), 19 deletions(-)

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 8aad25d625..e944a0b155 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -477,6 +477,13 @@ func NewLinksymOffsetExpr(pos src.XPos, lsym *obj.LSym, offset int64, typ *types
 	return n
 }
 
+// NewLinksymExpr is NewLinksymOffsetExpr, but with offset fixed at 0.
+func NewLinksymExpr(pos src.XPos, lsym *obj.LSym, typ *types.Type) *LinksymOffsetExpr {
+	return NewLinksymOffsetExpr(pos, lsym, 0, typ)
+}
+
+// NewNameOffsetExpr is NewLinksymOffsetExpr, but taking a *Name
+// representing a global variable instead of an *obj.LSym directly.
 func NewNameOffsetExpr(pos src.XPos, name *Name, offset int64, typ *types.Type) *LinksymOffsetExpr {
 	if name == nil || IsBlank(name) || !(name.Op() == ONAME && name.Class == PEXTERN) {
 		base.FatalfAt(pos, "cannot take offset of nil, blank name or non-global variable: %v", name)
diff --git a/src/cmd/compile/internal/ir/symtab.go b/src/cmd/compile/internal/ir/symtab.go
index df694f6c84..80e4571764 100644
--- a/src/cmd/compile/internal/ir/symtab.go
+++ b/src/cmd/compile/internal/ir/symtab.go
@@ -9,12 +9,6 @@ import (
 	"cmd/internal/obj"
 )
 
-// Names holds known names.
-var Names struct {
-	Staticuint64s *Name
-	Zerobase      *Name
-}
-
 // Syms holds known symbols.
 var Syms struct {
 	AssertE2I       *obj.LSym
@@ -46,6 +40,7 @@ var Syms struct {
 	Racewriterange  *obj.LSym
 	// Wasm
 	SigPanic        *obj.LSym
+	Staticuint64s   *obj.LSym
 	Typedmemclr     *obj.LSym
 	Typedmemmove    *obj.LSym
 	Udiv            *obj.LSym
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index beef0d8234..02aff7a8cf 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -124,6 +124,7 @@ func InitConfig() {
 	ir.Syms.X86HasFMA = typecheck.LookupRuntimeVar("x86HasFMA")             // bool
 	ir.Syms.ARMHasVFPv4 = typecheck.LookupRuntimeVar("armHasVFPv4")         // bool
 	ir.Syms.ARM64HasATOMICS = typecheck.LookupRuntimeVar("arm64HasATOMICS") // bool
+	ir.Syms.Staticuint64s = typecheck.LookupRuntimeVar("staticuint64s")
 	ir.Syms.Typedmemclr = typecheck.LookupRuntimeFunc("typedmemclr")
 	ir.Syms.Typedmemmove = typecheck.LookupRuntimeFunc("typedmemmove")
 	ir.Syms.Udiv = typecheck.LookupRuntimeVar("udiv")                 // asm func with special ABI
diff --git a/src/cmd/compile/internal/walk/convert.go b/src/cmd/compile/internal/walk/convert.go
index d143c1084f..fa8e2c0bb8 100644
--- a/src/cmd/compile/internal/walk/convert.go
+++ b/src/cmd/compile/internal/walk/convert.go
@@ -66,17 +66,6 @@ func walkConvInterface(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 		return l
 	}
 
-	if ir.Names.Staticuint64s == nil {
-		ir.Names.Staticuint64s = typecheck.NewName(ir.Pkgs.Runtime.Lookup("staticuint64s"))
-		ir.Names.Staticuint64s.Class = ir.PEXTERN
-		// The actual type is [256]uint64, but we use [256*8]uint8 so we can address
-		// individual bytes.
-		ir.Names.Staticuint64s.SetType(types.NewArray(types.Types[types.TUINT8], 256*8))
-		ir.Names.Zerobase = typecheck.NewName(ir.Pkgs.Runtime.Lookup("zerobase"))
-		ir.Names.Zerobase.Class = ir.PEXTERN
-		ir.Names.Zerobase.SetType(types.Types[types.TUINTPTR])
-	}
-
 	// Optimize convT2{E,I} for many cases in which T is not pointer-shaped,
 	// by using an existing addressable value identical to n.Left
 	// or creating one on the stack.
@@ -85,7 +74,7 @@ func walkConvInterface(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 	case fromType.Size() == 0:
 		// n.Left is zero-sized. Use zerobase.
 		cheapExpr(n.X, init) // Evaluate n.Left for side-effects. See issue 19246.
-		value = ir.Names.Zerobase
+		value = ir.NewLinksymExpr(base.Pos, ir.Syms.Zerobase, types.Types[types.TUINTPTR])
 	case fromType.IsBoolean() || (fromType.Size() == 1 && fromType.IsInteger()):
 		// n.Left is a bool/byte. Use staticuint64s[n.Left * 8] on little-endian
 		// and staticuint64s[n.Left * 8 + 7] on big-endian.
@@ -95,7 +84,10 @@ func walkConvInterface(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 		if ssagen.Arch.LinkArch.ByteOrder == binary.BigEndian {
 			index = ir.NewBinaryExpr(base.Pos, ir.OADD, index, ir.NewInt(7))
 		}
-		xe := ir.NewIndexExpr(base.Pos, ir.Names.Staticuint64s, index)
+		// The actual type is [256]uint64, but we use [256*8]uint8 so we can address
+		// individual bytes.
+		staticuint64s := ir.NewLinksymExpr(base.Pos, ir.Syms.Staticuint64s, types.NewArray(types.Types[types.TUINT8], 256*8))
+		xe := ir.NewIndexExpr(base.Pos, staticuint64s, index)
 		xe.SetBounded(true)
 		value = xe
 	case n.X.Op() == ir.ONAME && n.X.(*ir.Name).Class == ir.PEXTERN && n.X.(*ir.Name).Readonly():
-- 
GitLab


From 7e0fa38aad7bb402fcd08a66adc6492818c79dcf Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 17 Jan 2021 02:16:58 -0800
Subject: [PATCH 0507/2400] [dev.regabi] cmd/compile: remove unneeded packages
 from ir.Pkgs

ir.Pkgs.Itablink isn't used anymore. (I don't recall what it was ever
used for.)

ir.Pkgs.Race and ir.Pkgs.Msan are only needed in exactly only place,
so just create them on demand there, the same way that we create
"main" on demand.

Change-Id: I3474bb949f71cd40c7a462b9f4a369adeacde0d6
Reviewed-on: https://go-review.googlesource.com/c/go/+/284230
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/gc/main.go             |  9 ---------
 src/cmd/compile/internal/ir/symtab.go           | 15 ++++++---------
 src/cmd/compile/internal/reflectdata/reflect.go |  5 +++--
 3 files changed, 9 insertions(+), 20 deletions(-)

diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index e9ac243527..f758933d79 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -96,9 +96,6 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	ir.Pkgs.Itab = types.NewPkg("go.itab", "go.itab")
 	ir.Pkgs.Itab.Prefix = "go.itab" // not go%2eitab
 
-	ir.Pkgs.Itablink = types.NewPkg("go.itablink", "go.itablink")
-	ir.Pkgs.Itablink.Prefix = "go.itablink" // not go%2eitablink
-
 	ir.Pkgs.Track = types.NewPkg("go.track", "go.track")
 	ir.Pkgs.Track.Prefix = "go.track" // not go%2etrack
 
@@ -160,12 +157,6 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 
 	ssagen.Arch.LinkArch.Init(base.Ctxt)
 	startProfile()
-	if base.Flag.Race {
-		ir.Pkgs.Race = types.NewPkg("runtime/race", "")
-	}
-	if base.Flag.MSan {
-		ir.Pkgs.Msan = types.NewPkg("runtime/msan", "")
-	}
 	if base.Flag.Race || base.Flag.MSan {
 		base.Flag.Cfg.Instrumenting = true
 	}
diff --git a/src/cmd/compile/internal/ir/symtab.go b/src/cmd/compile/internal/ir/symtab.go
index 80e4571764..0968efbf5c 100644
--- a/src/cmd/compile/internal/ir/symtab.go
+++ b/src/cmd/compile/internal/ir/symtab.go
@@ -65,13 +65,10 @@ var Syms struct {
 
 // Pkgs holds known packages.
 var Pkgs struct {
-	Go       *types.Pkg
-	Itab     *types.Pkg
-	Itablink *types.Pkg
-	Map      *types.Pkg
-	Msan     *types.Pkg
-	Race     *types.Pkg
-	Runtime  *types.Pkg
-	Track    *types.Pkg
-	Unsafe   *types.Pkg
+	Go      *types.Pkg
+	Itab    *types.Pkg
+	Map     *types.Pkg
+	Runtime *types.Pkg
+	Track   *types.Pkg
+	Unsafe  *types.Pkg
 }
diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index fd3e6beaa3..fe0bd26927 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -1426,11 +1426,12 @@ func WriteBasicTypes() {
 		dimportpath(ir.Pkgs.Runtime)
 
 		if base.Flag.Race {
-			dimportpath(ir.Pkgs.Race)
+			dimportpath(types.NewPkg("runtime/race", ""))
 		}
 		if base.Flag.MSan {
-			dimportpath(ir.Pkgs.Msan)
+			dimportpath(types.NewPkg("runtime/msan", ""))
 		}
+
 		dimportpath(types.NewPkg("main", ""))
 	}
 }
-- 
GitLab


From 0ffa1ead6e281932697154d4ea45413b2ba8fa53 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Sun, 17 Jan 2021 16:41:19 +0700
Subject: [PATCH 0508/2400] [dev.regabi] cmd/compile: use *obj.LSym instead of
 *ir.Name for staticdata functions

Those functions only use (*ir.Name).Linksym(), so just change them to
get an *obj.LSym directly. This helps get rid of un-necessary
validations that their callers have already done.

Passes toolstash -cmp.

For #43737.

Change-Id: Ifd6c2525e472f8e790940bc167665f9d74dd1bc5
Reviewed-on: https://go-review.googlesource.com/c/go/+/284121
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/staticdata/data.go  | 48 ++++++++------------
 src/cmd/compile/internal/staticinit/sched.go | 25 +++++-----
 src/cmd/compile/internal/walk/complit.go     |  6 +--
 3 files changed, 34 insertions(+), 45 deletions(-)

diff --git a/src/cmd/compile/internal/staticdata/data.go b/src/cmd/compile/internal/staticdata/data.go
index 4dbc11c3c4..6ef99b50c7 100644
--- a/src/cmd/compile/internal/staticdata/data.go
+++ b/src/cmd/compile/internal/staticdata/data.go
@@ -25,46 +25,29 @@ import (
 	"cmd/internal/src"
 )
 
-// InitAddr writes the static address of a to n. a must be an ONAME.
-// Neither n nor a is modified.
-func InitAddr(n *ir.Name, noff int64, a *ir.Name, aoff int64) {
+// InitAddrOffset writes the static name symbol lsym to n, it does not modify n.
+// It's the caller responsibility to make sure lsym is from ONAME/PEXTERN node.
+func InitAddrOffset(n *ir.Name, noff int64, lsym *obj.LSym, off int64) {
 	if n.Op() != ir.ONAME {
 		base.Fatalf("InitAddr n op %v", n.Op())
 	}
 	if n.Sym() == nil {
 		base.Fatalf("InitAddr nil n sym")
 	}
-	if a.Op() != ir.ONAME {
-		base.Fatalf("InitAddr a op %v", a.Op())
-	}
 	s := n.Linksym()
-	s.WriteAddr(base.Ctxt, noff, types.PtrSize, a.Linksym(), aoff)
+	s.WriteAddr(base.Ctxt, noff, types.PtrSize, lsym, off)
 }
 
-// InitFunc writes the static address of f to n. f must be a global function.
-// Neither n nor f is modified.
-func InitFunc(n *ir.Name, noff int64, f *ir.Name) {
-	if n.Op() != ir.ONAME {
-		base.Fatalf("InitFunc n op %v", n.Op())
-	}
-	if n.Sym() == nil {
-		base.Fatalf("InitFunc nil n sym")
-	}
-	if f.Class != ir.PFUNC {
-		base.Fatalf("InitFunc class not PFUNC %d", f.Class)
-	}
-	s := n.Linksym()
-	s.WriteAddr(base.Ctxt, noff, types.PtrSize, FuncLinksym(f), 0)
+// InitAddr is InitAddrOffset, with offset fixed to 0.
+func InitAddr(n *ir.Name, noff int64, lsym *obj.LSym) {
+	InitAddrOffset(n, noff, lsym, 0)
 }
 
-// InitSlice writes a static slice symbol {&arr, lencap, lencap} to n+noff.
-// InitSlice does not modify n.
-func InitSlice(n *ir.Name, noff int64, arr *ir.Name, lencap int64) {
+// InitSlice writes a static slice symbol {lsym, lencap, lencap} to n+noff, it does not modify n.
+// It's the caller responsibility to make sure lsym is from ONAME node.
+func InitSlice(n *ir.Name, noff int64, lsym *obj.LSym, lencap int64) {
 	s := n.Linksym()
-	if arr.Op() != ir.ONAME {
-		base.Fatalf("InitSlice non-name arr %v", arr)
-	}
-	s.WriteAddr(base.Ctxt, noff, types.PtrSize, arr.Linksym(), 0)
+	s.WriteAddr(base.Ctxt, noff, types.PtrSize, lsym, 0)
 	s.WriteInt(base.Ctxt, noff+types.SliceLenOffset, types.PtrSize, lencap)
 	s.WriteInt(base.Ctxt, noff+types.SliceCapOffset, types.PtrSize, lencap)
 }
@@ -73,7 +56,7 @@ func InitSliceBytes(nam *ir.Name, off int64, s string) {
 	if nam.Op() != ir.ONAME {
 		base.Fatalf("InitSliceBytes %v", nam)
 	}
-	InitSlice(nam, off, slicedata(nam.Pos(), s), int64(len(s)))
+	InitSlice(nam, off, slicedata(nam.Pos(), s).Linksym(), int64(len(s)))
 }
 
 const (
@@ -265,6 +248,13 @@ func FuncLinksym(n *ir.Name) *obj.LSym {
 	return FuncSym(n.Sym()).Linksym()
 }
 
+func GlobalLinksym(n *ir.Name) *obj.LSym {
+	if n.Op() != ir.ONAME || n.Class != ir.PEXTERN {
+		base.Fatalf("expected global variable: %v", n)
+	}
+	return n.Linksym()
+}
+
 // NeedFuncSym ensures that s·f is exported, if needed.
 // It is only used with -dynlink.
 // When not compiling for dynamic linking,
diff --git a/src/cmd/compile/internal/staticinit/sched.go b/src/cmd/compile/internal/staticinit/sched.go
index 8c195742e6..cf1b416462 100644
--- a/src/cmd/compile/internal/staticinit/sched.go
+++ b/src/cmd/compile/internal/staticinit/sched.go
@@ -81,7 +81,7 @@ func (s *Schedule) tryStaticInit(nn ir.Node) bool {
 func (s *Schedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *types.Type) bool {
 	if rn.Class == ir.PFUNC {
 		// TODO if roff != 0 { panic }
-		staticdata.InitFunc(l, loff, rn)
+		staticdata.InitAddr(l, loff, staticdata.FuncLinksym(rn))
 		return true
 	}
 	if rn.Class != ir.PEXTERN || rn.Sym().Pkg != types.LocalPkg {
@@ -138,9 +138,8 @@ func (s *Schedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *types.Ty
 
 	case ir.OADDR:
 		r := r.(*ir.AddrExpr)
-		if a := r.X; a.Op() == ir.ONAME {
-			a := a.(*ir.Name)
-			staticdata.InitAddr(l, loff, a, 0)
+		if a, ok := r.X.(*ir.Name); ok && a.Op() == ir.ONAME {
+			staticdata.InitAddr(l, loff, staticdata.GlobalLinksym(a))
 			return true
 		}
 
@@ -149,14 +148,14 @@ func (s *Schedule) staticcopy(l *ir.Name, loff int64, rn *ir.Name, typ *types.Ty
 		switch r.X.Op() {
 		case ir.OARRAYLIT, ir.OSLICELIT, ir.OSTRUCTLIT, ir.OMAPLIT:
 			// copy pointer
-			staticdata.InitAddr(l, loff, s.Temps[r], 0)
+			staticdata.InitAddr(l, loff, staticdata.GlobalLinksym(s.Temps[r]))
 			return true
 		}
 
 	case ir.OSLICELIT:
 		r := r.(*ir.CompLitExpr)
 		// copy slice
-		staticdata.InitSlice(l, loff, s.Temps[r], r.Len)
+		staticdata.InitSlice(l, loff, staticdata.GlobalLinksym(s.Temps[r]), r.Len)
 		return true
 
 	case ir.OARRAYLIT, ir.OSTRUCTLIT:
@@ -235,8 +234,8 @@ func (s *Schedule) StaticAssign(l *ir.Name, loff int64, r ir.Node, typ *types.Ty
 
 	case ir.OADDR:
 		r := r.(*ir.AddrExpr)
-		if name, offset, ok := StaticLoc(r.X); ok {
-			staticdata.InitAddr(l, loff, name, offset)
+		if name, offset, ok := StaticLoc(r.X); ok && name.Class == ir.PEXTERN {
+			staticdata.InitAddrOffset(l, loff, name.Linksym(), offset)
 			return true
 		}
 		fallthrough
@@ -249,7 +248,7 @@ func (s *Schedule) StaticAssign(l *ir.Name, loff int64, r ir.Node, typ *types.Ty
 			a := StaticName(r.X.Type())
 
 			s.Temps[r] = a
-			staticdata.InitAddr(l, loff, a, 0)
+			staticdata.InitAddr(l, loff, a.Linksym())
 
 			// Init underlying literal.
 			assign(base.Pos, a, 0, r.X)
@@ -273,7 +272,7 @@ func (s *Schedule) StaticAssign(l *ir.Name, loff int64, r ir.Node, typ *types.Ty
 		ta.SetNoalg(true)
 		a := StaticName(ta)
 		s.Temps[r] = a
-		staticdata.InitSlice(l, loff, a, r.Len)
+		staticdata.InitSlice(l, loff, a.Linksym(), r.Len)
 		// Fall through to init underlying array.
 		l = a
 		loff = 0
@@ -308,7 +307,7 @@ func (s *Schedule) StaticAssign(l *ir.Name, loff int64, r ir.Node, typ *types.Ty
 			// Closures with no captured variables are globals,
 			// so the assignment can be done at link time.
 			// TODO if roff != 0 { panic }
-			staticdata.InitFunc(l, loff, r.Func.Nname)
+			staticdata.InitAddr(l, loff, staticdata.FuncLinksym(r.Func.Nname))
 			return true
 		}
 		ir.ClosureDebugRuntimeCheck(r)
@@ -345,7 +344,7 @@ func (s *Schedule) StaticAssign(l *ir.Name, loff int64, r ir.Node, typ *types.Ty
 		// Create a copy of l to modify while we emit data.
 
 		// Emit itab, advance offset.
-		staticdata.InitAddr(l, loff, itab.X.(*ir.Name), 0)
+		staticdata.InitAddr(l, loff, itab.X.(*ir.Name).Linksym())
 
 		// Emit data.
 		if types.IsDirectIface(val.Type()) {
@@ -361,7 +360,7 @@ func (s *Schedule) StaticAssign(l *ir.Name, loff int64, r ir.Node, typ *types.Ty
 			a := StaticName(val.Type())
 			s.Temps[val] = a
 			assign(base.Pos, a, 0, val)
-			staticdata.InitAddr(l, loff+int64(types.PtrSize), a, 0)
+			staticdata.InitAddr(l, loff+int64(types.PtrSize), a.Linksym())
 		}
 
 		return true
diff --git a/src/cmd/compile/internal/walk/complit.go b/src/cmd/compile/internal/walk/complit.go
index 97e820238b..73442dc404 100644
--- a/src/cmd/compile/internal/walk/complit.go
+++ b/src/cmd/compile/internal/walk/complit.go
@@ -297,7 +297,7 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 		if !ok || name.Class != ir.PEXTERN {
 			base.Fatalf("slicelit: %v", var_)
 		}
-		staticdata.InitSlice(name, offset, vstat, t.NumElem())
+		staticdata.InitSlice(name, offset, vstat.Linksym(), t.NumElem())
 		return
 	}
 
@@ -647,7 +647,7 @@ func genAsStatic(as *ir.AssignStmt) {
 		return
 	case ir.OMETHEXPR:
 		r := r.(*ir.SelectorExpr)
-		staticdata.InitFunc(name, offset, r.FuncName())
+		staticdata.InitAddr(name, offset, staticdata.FuncLinksym(r.FuncName()))
 		return
 	case ir.ONAME:
 		r := r.(*ir.Name)
@@ -655,7 +655,7 @@ func genAsStatic(as *ir.AssignStmt) {
 			base.Fatalf("genAsStatic %+v", as)
 		}
 		if r.Class == ir.PFUNC {
-			staticdata.InitFunc(name, offset, r)
+			staticdata.InitAddr(name, offset, staticdata.FuncLinksym(r))
 			return
 		}
 	}
-- 
GitLab


From 4c835f9169e2b1f98a9755724d1f46bf50566003 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Mon, 18 Jan 2021 09:42:53 +0700
Subject: [PATCH 0509/2400] [dev.regabi] cmd/compile: use LinksymOffsetExpr in
 TypePtr/ItabAddr

Passes toolstash -cmp.

Fixes #43737

Change-Id: I2d5228c0213b5f8742e3cea6fac9bc985b19d78c
Reviewed-on: https://go-review.googlesource.com/c/go/+/284122
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 .../compile/internal/reflectdata/reflect.go   | 37 +++++--------------
 src/cmd/compile/internal/staticinit/sched.go  |  2 +-
 2 files changed, 11 insertions(+), 28 deletions(-)

diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index fe0bd26927..bd89b62ff5 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -836,39 +836,22 @@ func TypeLinksym(t *types.Type) *obj.LSym {
 }
 
 func TypePtr(t *types.Type) *ir.AddrExpr {
-	s := TypeSym(t)
-	if s.Def == nil {
-		n := ir.NewNameAt(src.NoXPos, s)
-		n.SetType(types.Types[types.TUINT8])
-		n.Class = ir.PEXTERN
-		n.SetTypecheck(1)
-		s.Def = n
-	}
-
-	n := typecheck.NodAddr(ir.AsNode(s.Def))
-	n.SetType(types.NewPtr(s.Def.Type()))
-	n.SetTypecheck(1)
-	return n
+	n := ir.NewLinksymExpr(base.Pos, TypeLinksym(t), types.Types[types.TUINT8])
+	return typecheck.Expr(typecheck.NodAddr(n)).(*ir.AddrExpr)
 }
 
 func ITabAddr(t, itype *types.Type) *ir.AddrExpr {
 	if t == nil || (t.IsPtr() && t.Elem() == nil) || t.IsUntyped() || !itype.IsInterface() || itype.IsEmptyInterface() {
 		base.Fatalf("ITabAddr(%v, %v)", t, itype)
 	}
-	s := ir.Pkgs.Itab.Lookup(t.ShortString() + "," + itype.ShortString())
-	if s.Def == nil {
-		n := typecheck.NewName(s)
-		n.SetType(types.Types[types.TUINT8])
-		n.Class = ir.PEXTERN
-		n.SetTypecheck(1)
-		s.Def = n
-		itabs = append(itabs, itabEntry{t: t, itype: itype, lsym: n.Linksym()})
-	}
-
-	n := typecheck.NodAddr(ir.AsNode(s.Def))
-	n.SetType(types.NewPtr(s.Def.Type()))
-	n.SetTypecheck(1)
-	return n
+	s, existed := ir.Pkgs.Itab.LookupOK(t.ShortString() + "," + itype.ShortString())
+	if !existed {
+		itabs = append(itabs, itabEntry{t: t, itype: itype, lsym: s.Linksym()})
+	}
+
+	lsym := s.Linksym()
+	n := ir.NewLinksymExpr(base.Pos, lsym, types.Types[types.TUINT8])
+	return typecheck.Expr(typecheck.NodAddr(n)).(*ir.AddrExpr)
 }
 
 // needkeyupdate reports whether map updates with t as a key
diff --git a/src/cmd/compile/internal/staticinit/sched.go b/src/cmd/compile/internal/staticinit/sched.go
index cf1b416462..f3ad82e7b6 100644
--- a/src/cmd/compile/internal/staticinit/sched.go
+++ b/src/cmd/compile/internal/staticinit/sched.go
@@ -344,7 +344,7 @@ func (s *Schedule) StaticAssign(l *ir.Name, loff int64, r ir.Node, typ *types.Ty
 		// Create a copy of l to modify while we emit data.
 
 		// Emit itab, advance offset.
-		staticdata.InitAddr(l, loff, itab.X.(*ir.Name).Linksym())
+		staticdata.InitAddr(l, loff, itab.X.(*ir.LinksymOffsetExpr).Linksym)
 
 		// Emit data.
 		if types.IsDirectIface(val.Type()) {
-- 
GitLab


From 6113db0bb47706b8b5f65b67b87f8277432ca4d2 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 17 Jan 2021 16:14:48 -0800
Subject: [PATCH 0510/2400] [dev.regabi] cmd/compile: convert OPANIC argument
 to interface{} during typecheck

Currently, typecheck leaves arguments to OPANIC as their original
type. This CL changes it to insert implicit OCONVIFACE operations to
convert arguments to `interface{}` like how any other function call
would be handled.

No immediate benefits, other than getting to remove a tiny bit of
special-case logic in order.go's handling of OPANICs. Instead, the
generic code path for handling OCONVIFACE is used, if necessary.
Longer term, this should be marginally helpful for #43753, as it
reduces the number of cases where we need values to be addressable for
runtime calls.

However, this does require adding some hacks to appease existing
tests:

1. We need yet another kludge in inline budgeting, to ensure that
reflect.flag.mustBe stays inlinable for cmd/compile/internal/test's
TestIntendedInlining.

2. Since the OCONVIFACE expressions are now being introduced during
typecheck, they're now visible to escape analysis. So expressions like
"panic(1)" are now seen as "panic(interface{}(1))", and escape
analysis warns that the "interface{}(1)" escapes to the heap. These
have always escaped to heap, just now we're accurately reporting about
it.

(Also, unfortunately fmt.go hides implicit conversions by default in
diagnostics messages, so instead of reporting "interface{}(1) escapes
to heap", it actually reports "1 escapes to heap", which is
confusing. However, this confusing messaging also isn't new.)

Change-Id: Icedf60e1d2e464e219441b8d1233a313770272af
Reviewed-on: https://go-review.googlesource.com/c/go/+/284412
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/inline/inl.go     |  7 +++++++
 src/cmd/compile/internal/typecheck/func.go |  2 +-
 src/cmd/compile/internal/walk/order.go     |  6 ++----
 test/closure3.dir/main.go                  |  2 +-
 test/escape2.go                            |  2 +-
 test/escape2n.go                           |  2 +-
 test/escape4.go                            |  6 +++---
 test/fixedbugs/issue13799.go               | 12 ++++++------
 test/fixedbugs/issue7921.go                |  2 +-
 9 files changed, 23 insertions(+), 18 deletions(-)

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 143fbe9efe..aa194ebab2 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -346,6 +346,13 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 		v.budget -= v.extraCallCost
 
 	case ir.OPANIC:
+		n := n.(*ir.UnaryExpr)
+		if n.X.Op() == ir.OCONVIFACE && n.X.(*ir.ConvExpr).Implicit() {
+			// Hack to keep reflect.flag.mustBe inlinable for TestIntendedInlining.
+			// Before CL 284412, these conversions were introduced later in the
+			// compiler, so they didn't count against inlining budget.
+			v.budget++
+		}
 		v.budget -= inlineExtraPanicCost
 
 	case ir.ORECOVER:
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index c832d9700f..b576590d4d 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -896,7 +896,7 @@ func tcNew(n *ir.UnaryExpr) ir.Node {
 // tcPanic typechecks an OPANIC node.
 func tcPanic(n *ir.UnaryExpr) ir.Node {
 	n.X = Expr(n.X)
-	n.X = DefaultLit(n.X, types.Types[types.TINTER])
+	n.X = AssignConv(n.X, types.Types[types.TINTER], "argument to panic")
 	if n.X.Type() == nil {
 		n.SetType(nil)
 		return n
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index e1e9f168bb..fe0b6a0eff 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -768,14 +768,12 @@ func (o *orderState) stmt(n ir.Node) {
 		orderBlock(&n.Else, o.free)
 		o.out = append(o.out, n)
 
-	// Special: argument will be converted to interface using convT2E
-	// so make sure it is an addressable temporary.
 	case ir.OPANIC:
 		n := n.(*ir.UnaryExpr)
 		t := o.markTemp()
 		n.X = o.expr(n.X, nil)
-		if !n.X.Type().IsInterface() {
-			n.X = o.addrTemp(n.X)
+		if !n.X.Type().IsEmptyInterface() {
+			base.FatalfAt(n.Pos(), "bad argument to panic: %L", n.X)
 		}
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
diff --git a/test/closure3.dir/main.go b/test/closure3.dir/main.go
index 5694673f1e..e8e1e99860 100644
--- a/test/closure3.dir/main.go
+++ b/test/closure3.dir/main.go
@@ -285,5 +285,5 @@ func main() {
 
 //go:noinline
 func ppanic(s string) { // ERROR "leaking param: s"
-	panic(s)
+	panic(s) // ERROR "s escapes to heap"
 }
diff --git a/test/escape2.go b/test/escape2.go
index 5c6eb559fa..b9b723d866 100644
--- a/test/escape2.go
+++ b/test/escape2.go
@@ -1547,7 +1547,7 @@ func foo153(v interface{}) *int { // ERROR "v does not escape"
 	case int: // ERROR "moved to heap: x$"
 		return &x
 	}
-	panic(0)
+	panic(0) // ERROR "0 escapes to heap"
 }
 
 // issue 8185 - &result escaping into result
diff --git a/test/escape2n.go b/test/escape2n.go
index 46e58f8566..7c8208aa73 100644
--- a/test/escape2n.go
+++ b/test/escape2n.go
@@ -1547,7 +1547,7 @@ func foo153(v interface{}) *int { // ERROR "v does not escape"
 	case int: // ERROR "moved to heap: x$"
 		return &x
 	}
-	panic(0)
+	panic(0) // ERROR "0 escapes to heap"
 }
 
 // issue 8185 - &result escaping into result
diff --git a/test/escape4.go b/test/escape4.go
index a4a9c14a3e..4e50231bf9 100644
--- a/test/escape4.go
+++ b/test/escape4.go
@@ -35,14 +35,14 @@ func f1() {
 func f2() {} // ERROR "can inline f2"
 
 // No inline for recover; panic now allowed to inline.
-func f3() { panic(1) } // ERROR "can inline f3"
+func f3() { panic(1) } // ERROR "can inline f3" "1 escapes to heap"
 func f4() { recover() }
 
 func f5() *byte {
 	type T struct {
 		x [1]byte
 	}
-	t := new(T)    // ERROR "new.T. escapes to heap"
+	t := new(T) // ERROR "new.T. escapes to heap"
 	return &t.x[0]
 }
 
@@ -52,6 +52,6 @@ func f6() *byte {
 			y byte
 		}
 	}
-	t := new(T)   // ERROR "new.T. escapes to heap"
+	t := new(T) // ERROR "new.T. escapes to heap"
 	return &t.x.y
 }
diff --git a/test/fixedbugs/issue13799.go b/test/fixedbugs/issue13799.go
index fbdd4c32bc..c8ecfc54e4 100644
--- a/test/fixedbugs/issue13799.go
+++ b/test/fixedbugs/issue13799.go
@@ -60,7 +60,7 @@ func test1(iter int) {
 	}
 
 	if len(m) != maxI {
-		panic(fmt.Sprintf("iter %d: maxI = %d, len(m) = %d", iter, maxI, len(m))) // ERROR "iter escapes to heap$" "len\(m\) escapes to heap$" "maxI escapes to heap$" "... argument does not escape$"
+		panic(fmt.Sprintf("iter %d: maxI = %d, len(m) = %d", iter, maxI, len(m))) // ERROR "iter escapes to heap$" "len\(m\) escapes to heap$" "maxI escapes to heap$" "... argument does not escape$" "fmt.Sprintf\(.*\) escapes to heap"
 	}
 }
 
@@ -84,7 +84,7 @@ func test2(iter int) {
 	}
 
 	if len(m) != maxI {
-		panic(fmt.Sprintf("iter %d: maxI = %d, len(m) = %d", iter, maxI, len(m))) // ERROR "iter escapes to heap$" "len\(m\) escapes to heap$" "maxI escapes to heap$" "... argument does not escape$"
+		panic(fmt.Sprintf("iter %d: maxI = %d, len(m) = %d", iter, maxI, len(m))) // ERROR "iter escapes to heap$" "len\(m\) escapes to heap$" "maxI escapes to heap$" "... argument does not escape$" "fmt.Sprintf\(.*\) escapes to heap"
 	}
 }
 
@@ -110,7 +110,7 @@ func test3(iter int) {
 	}
 
 	if *m != maxI {
-		panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "... argument does not escape$"
+		panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "... argument does not escape$" "fmt.Sprintf\(.*\) escapes to heap"
 	}
 }
 
@@ -136,7 +136,7 @@ func test4(iter int) {
 	}
 
 	if *m != maxI {
-		panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "... argument does not escape$"
+		panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "... argument does not escape$" "fmt.Sprintf\(.*\) escapes to heap"
 	}
 }
 
@@ -167,7 +167,7 @@ func test5(iter int) {
 	}
 
 	if *m != maxI {
-		panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "... argument does not escape$"
+		panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "... argument does not escape$" "fmt.Sprintf\(.*\) escapes to heap"
 	}
 }
 
@@ -185,6 +185,6 @@ func test6(iter int) {
 	}
 
 	if *m != maxI {
-		panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "... argument does not escape$"
+		panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "... argument does not escape$" "fmt.Sprintf\(.*\) escapes to heap"
 	}
 }
diff --git a/test/fixedbugs/issue7921.go b/test/fixedbugs/issue7921.go
index a4e7b246d4..65be4b5bbe 100644
--- a/test/fixedbugs/issue7921.go
+++ b/test/fixedbugs/issue7921.go
@@ -41,7 +41,7 @@ func bufferNoEscape3(xs []string) string { // ERROR "xs does not escape$"
 
 func bufferNoEscape4() []byte {
 	var b bytes.Buffer
-	b.Grow(64) // ERROR "bufferNoEscape4 ignoring self-assignment in bytes.b.buf = bytes.b.buf\[:bytes.m\]$" "inlining call to bytes.\(\*Buffer\).Grow$"
+	b.Grow(64) // ERROR "bufferNoEscape4 ignoring self-assignment in bytes.b.buf = bytes.b.buf\[:bytes.m\]$" "inlining call to bytes.\(\*Buffer\).Grow$" "string\(.*\) escapes to heap"
 	useBuffer(&b)
 	return b.Bytes() // ERROR "inlining call to bytes.\(\*Buffer\).Bytes$"
 }
-- 
GitLab


From 422f38fb6c8d673eaa13669a22768f4fdd91642b Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 17 Jan 2021 22:05:50 -0800
Subject: [PATCH 0511/2400] [dev.regabi] cmd/compile: move stack objects to
 liveness

Calculating and emitting stack objects are essentially part of
liveness analysis, so move the code from ssagen to liveness. Allows
unexporting liveness.ShouldTrack.

Passes toolstash -cmp.

Change-Id: I88b5b2e75b8dfb46b8b03a2fa09a9236865cbf3e
Reviewed-on: https://go-review.googlesource.com/c/go/+/284413
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/liveness/plive.go | 53 ++++++++++++++++++++--
 src/cmd/compile/internal/ssagen/ssa.go     | 50 --------------------
 2 files changed, 50 insertions(+), 53 deletions(-)

diff --git a/src/cmd/compile/internal/liveness/plive.go b/src/cmd/compile/internal/liveness/plive.go
index c70db6ed18..53ae797fce 100644
--- a/src/cmd/compile/internal/liveness/plive.go
+++ b/src/cmd/compile/internal/liveness/plive.go
@@ -17,12 +17,14 @@ package liveness
 import (
 	"crypto/md5"
 	"fmt"
+	"sort"
 	"strings"
 
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/bitvec"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/objw"
+	"cmd/compile/internal/reflectdata"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/typebits"
 	"cmd/compile/internal/types"
@@ -174,13 +176,13 @@ type progeffectscache struct {
 	initialized bool
 }
 
-// ShouldTrack reports whether the liveness analysis
+// shouldTrack reports whether the liveness analysis
 // should track the variable n.
 // We don't care about variables that have no pointers,
 // nor do we care about non-local variables,
 // nor do we care about empty structs (handled by the pointer check),
 // nor do we care about the fake PAUTOHEAP variables.
-func ShouldTrack(n *ir.Name) bool {
+func shouldTrack(n *ir.Name) bool {
 	return (n.Class == ir.PAUTO && n.Esc() != ir.EscHeap || n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT) && n.Type().HasPointers()
 }
 
@@ -189,7 +191,7 @@ func ShouldTrack(n *ir.Name) bool {
 func getvariables(fn *ir.Func) ([]*ir.Name, map[*ir.Name]int32) {
 	var vars []*ir.Name
 	for _, n := range fn.Dcl {
-		if ShouldTrack(n) {
+		if shouldTrack(n) {
 			vars = append(vars, n)
 		}
 	}
@@ -1179,9 +1181,54 @@ func Compute(curfn *ir.Func, f *ssa.Func, stkptrsize int64, pp *objw.Progs) Map
 	p.To.Name = obj.NAME_EXTERN
 	p.To.Sym = fninfo.GCLocals
 
+	if x := lv.emitStackObjects(); x != nil {
+		p := pp.Prog(obj.AFUNCDATA)
+		p.From.SetConst(objabi.FUNCDATA_StackObjects)
+		p.To.Type = obj.TYPE_MEM
+		p.To.Name = obj.NAME_EXTERN
+		p.To.Sym = x
+	}
+
 	return lv.livenessMap
 }
 
+func (lv *liveness) emitStackObjects() *obj.LSym {
+	var vars []*ir.Name
+	for _, n := range lv.fn.Dcl {
+		if shouldTrack(n) && n.Addrtaken() && n.Esc() != ir.EscHeap {
+			vars = append(vars, n)
+		}
+	}
+	if len(vars) == 0 {
+		return nil
+	}
+
+	// Sort variables from lowest to highest address.
+	sort.Slice(vars, func(i, j int) bool { return vars[i].FrameOffset() < vars[j].FrameOffset() })
+
+	// Populate the stack object data.
+	// Format must match runtime/stack.go:stackObjectRecord.
+	x := base.Ctxt.Lookup(lv.fn.LSym.Name + ".stkobj")
+	lv.fn.LSym.Func().StackObjects = x
+	off := 0
+	off = objw.Uintptr(x, off, uint64(len(vars)))
+	for _, v := range vars {
+		// Note: arguments and return values have non-negative Xoffset,
+		// in which case the offset is relative to argp.
+		// Locals have a negative Xoffset, in which case the offset is relative to varp.
+		off = objw.Uintptr(x, off, uint64(v.FrameOffset()))
+		off = objw.SymPtr(x, off, reflectdata.TypeLinksym(v.Type()), 0)
+	}
+
+	if base.Flag.Live != 0 {
+		for _, v := range vars {
+			base.WarnfAt(v.Pos(), "stack object %v %v", v, v.Type())
+		}
+	}
+
+	return x
+}
+
 // isfat reports whether a variable of type t needs multiple assignments to initialize.
 // For example:
 //
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 02aff7a8cf..0a1a7aed84 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -6467,55 +6467,6 @@ func (s *State) DebugFriendlySetPosFrom(v *ssa.Value) {
 	}
 }
 
-// byXoffset implements sort.Interface for []*ir.Name using Xoffset as the ordering.
-type byXoffset []*ir.Name
-
-func (s byXoffset) Len() int           { return len(s) }
-func (s byXoffset) Less(i, j int) bool { return s[i].FrameOffset() < s[j].FrameOffset() }
-func (s byXoffset) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
-
-func emitStackObjects(e *ssafn, pp *objw.Progs) {
-	var vars []*ir.Name
-	for _, n := range e.curfn.Dcl {
-		if liveness.ShouldTrack(n) && n.Addrtaken() && n.Esc() != ir.EscHeap {
-			vars = append(vars, n)
-		}
-	}
-	if len(vars) == 0 {
-		return
-	}
-
-	// Sort variables from lowest to highest address.
-	sort.Sort(byXoffset(vars))
-
-	// Populate the stack object data.
-	// Format must match runtime/stack.go:stackObjectRecord.
-	x := base.Ctxt.Lookup(e.curfn.LSym.Name + ".stkobj")
-	e.curfn.LSym.Func().StackObjects = x
-	off := 0
-	off = objw.Uintptr(x, off, uint64(len(vars)))
-	for _, v := range vars {
-		// Note: arguments and return values have non-negative Xoffset,
-		// in which case the offset is relative to argp.
-		// Locals have a negative Xoffset, in which case the offset is relative to varp.
-		off = objw.Uintptr(x, off, uint64(v.FrameOffset()))
-		off = objw.SymPtr(x, off, reflectdata.TypeLinksym(v.Type()), 0)
-	}
-
-	// Emit a funcdata pointing at the stack object data.
-	p := pp.Prog(obj.AFUNCDATA)
-	p.From.SetConst(objabi.FUNCDATA_StackObjects)
-	p.To.Type = obj.TYPE_MEM
-	p.To.Name = obj.NAME_EXTERN
-	p.To.Sym = x
-
-	if base.Flag.Live != 0 {
-		for _, v := range vars {
-			base.WarnfAt(v.Pos(), "stack object %v %s", v, v.Type().String())
-		}
-	}
-}
-
 // genssa appends entries to pp for each instruction in f.
 func genssa(f *ssa.Func, pp *objw.Progs) {
 	var s State
@@ -6523,7 +6474,6 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 	e := f.Frontend().(*ssafn)
 
 	s.livenessMap = liveness.Compute(e.curfn, f, e.stkptrsize, pp)
-	emitStackObjects(e, pp)
 
 	openDeferInfo := e.curfn.LSym.Func().OpenCodedDeferInfo
 	if openDeferInfo != nil {
-- 
GitLab


From 4f5c603c0f4375d7612feedfd4d5bef41a4060ee Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 17 Jan 2021 00:46:42 -0800
Subject: [PATCH 0512/2400] [dev.regabi] cmd/compile: cleanup callTargetLSym

Now that TailCallStmt carries an *ir.Name instead of a *types.Sym,
callTargetLSym can be similarly updated to take the target function as
an *ir.Name.

This inches us closer towards being able to move Linksym and other
properties from *types.Sym to *ir.Name, where they belong.

Passes toolstash -cmp w/ -gcflags=all=-abiwrap.

Change-Id: I091da290751970eba8ed0438f66d6cca88b665a8
Reviewed-on: https://go-review.googlesource.com/c/go/+/284228
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/ssagen/ssa.go | 33 +++++++++++---------------
 test/abi/regabipragma.out              |  8 +++----
 2 files changed, 18 insertions(+), 23 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 0a1a7aed84..72db4430a5 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -361,7 +361,7 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 		if strings.Contains(name, ".") {
 			base.ErrorfAt(fn.Pos(), "Calls to //go:registerparams method %s won't work, remove the pragma from the declaration.", name)
 		}
-		s.f.Warnl(fn.Pos(), "Declared function %s has register params", name)
+		s.f.Warnl(fn.Pos(), "declared function %v has register params", fn)
 	}
 
 	s.panics = map[funcLine]*ssa.Block{}
@@ -1585,7 +1585,7 @@ func (s *state) stmt(n ir.Node) {
 		n := n.(*ir.TailCallStmt)
 		b := s.exit()
 		b.Kind = ssa.BlockRetJmp // override BlockRet
-		b.Aux = callTargetLSym(n.Target.Sym(), s.curfn.LSym)
+		b.Aux = callTargetLSym(n.Target, s.curfn.LSym)
 
 	case ir.OCONTINUE, ir.OBREAK:
 		n := n.(*ir.BranchStmt)
@@ -4756,7 +4756,7 @@ func (s *state) callAddr(n *ir.CallExpr, k callKind) *ssa.Value {
 // Returns the address of the return value (or nil if none).
 func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Value {
 	s.prevCall = nil
-	var sym *types.Sym     // target symbol (if static)
+	var callee *ir.Name    // target function (if static)
 	var closure *ssa.Value // ptr to closure to run (if dynamic)
 	var codeptr *ssa.Value // ptr to target code (if dynamic)
 	var rcvr *ssa.Value    // receiver to set
@@ -4781,13 +4781,13 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		testLateExpansion = k != callDeferStack && ssa.LateCallExpansionEnabledWithin(s.f)
 		if k == callNormal && fn.Op() == ir.ONAME && fn.(*ir.Name).Class == ir.PFUNC {
 			fn := fn.(*ir.Name)
-			sym = fn.Sym()
+			callee = fn
 			// TODO remove after register abi is working
 			inRegistersImported := fn.Pragma()&ir.RegisterParams != 0
 			inRegistersSamePackage := fn.Func != nil && fn.Func.Pragma&ir.RegisterParams != 0
 			inRegisters = inRegistersImported || inRegistersSamePackage
 			if inRegisters {
-				s.f.Warnl(n.Pos(), "Called function %s has register params", sym.Linksym().Name)
+				s.f.Warnl(n.Pos(), "called function %v has register params", callee)
 			}
 			break
 		}
@@ -4982,13 +4982,13 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			} else {
 				call = s.newValue2A(ssa.OpInterCall, types.TypeMem, ssa.InterfaceAuxCall(ACArgs, ACResults), codeptr, s.mem())
 			}
-		case sym != nil:
+		case callee != nil:
 			if testLateExpansion {
-				aux := ssa.StaticAuxCall(callTargetLSym(sym, s.curfn.LSym), ACArgs, ACResults)
+				aux := ssa.StaticAuxCall(callTargetLSym(callee, s.curfn.LSym), ACArgs, ACResults)
 				call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 				call.AddArgs(callArgs...)
 			} else {
-				call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, ssa.StaticAuxCall(callTargetLSym(sym, s.curfn.LSym), ACArgs, ACResults), s.mem())
+				call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, ssa.StaticAuxCall(callTargetLSym(callee, s.curfn.LSym), ACArgs, ACResults), s.mem())
 			}
 		default:
 			s.Fatalf("bad call type %v %v", n.Op(), n)
@@ -7386,31 +7386,26 @@ func clobberBase(n ir.Node) ir.Node {
 //
 // 3. in all other cases, want the regular ABIInternal linksym
 //
-func callTargetLSym(callee *types.Sym, callerLSym *obj.LSym) *obj.LSym {
+func callTargetLSym(callee *ir.Name, callerLSym *obj.LSym) *obj.LSym {
 	lsym := callee.Linksym()
 	if !base.Flag.ABIWrap {
 		return lsym
 	}
-	if ir.AsNode(callee.Def) == nil {
+	fn := callee.Func
+	if fn == nil {
 		return lsym
 	}
-	defn := ir.AsNode(callee.Def).Name().Defn
-	if defn == nil {
-		return lsym
-	}
-	ndclfunc := defn.(*ir.Func)
 
 	// check for case 1 above
 	if callerLSym.ABIWrapper() {
-		if nlsym := ndclfunc.LSym; nlsym != nil {
+		if nlsym := fn.LSym; nlsym != nil {
 			lsym = nlsym
 		}
 	} else {
 		// check for case 2 above
-		nam := ndclfunc.Nname
-		defABI, hasDefABI := symabiDefs[nam.Sym().LinksymName()]
+		defABI, hasDefABI := symabiDefs[callee.Sym().LinksymName()]
 		if hasDefABI && defABI == obj.ABI0 {
-			lsym = nam.Sym().LinksymABI0()
+			lsym = callee.Sym().LinksymABI0()
 		}
 	}
 	return lsym
diff --git a/test/abi/regabipragma.out b/test/abi/regabipragma.out
index 7803613351..321b1adfcc 100644
--- a/test/abi/regabipragma.out
+++ b/test/abi/regabipragma.out
@@ -1,6 +1,6 @@
 # regabipragma.dir/tmp
-tmp/foo.go:17:6: Declared function F has register params
+tmp/foo.go:17:6: declared function F has register params
 # regabipragma.dir
-./main.go:21:6: Declared function f has register params
-./main.go:32:9: Called function "".f has register params
-./main.go:33:13: Called function regabipragma.dir/tmp.F has register params
+./main.go:21:6: declared function f has register params
+./main.go:32:9: called function f has register params
+./main.go:33:13: called function tmp.F has register params
-- 
GitLab


From 4a4212c0e59dee4458be2f5c85262e54f127c500 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 17 Jan 2021 02:38:41 -0800
Subject: [PATCH 0513/2400] [dev.regabi] cmd/compile: refactor Linksym creation

Currently there's a lot of logic within package types for creating
Linksyms. This CL pulls it out into base, where it can be more easily
reused by other compiler code that shouldn't need to depend on package
types.

Package base probably isn't the best place for this, but it's
convenient because it's a package that types already depends on. It's
also where the Ctxt object lives, which these functions depend upon.

Passes toolstash -cmp w/ -gcflags=all=-abiwrap.

Change-Id: I50d8b7e4596955205036969eab24d7dab053b363
Reviewed-on: https://go-review.googlesource.com/c/go/+/284231
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/base/base.go       |  4 --
 src/cmd/compile/internal/base/link.go       | 36 ++++++++++++++++
 src/cmd/compile/internal/dwarfgen/dwarf.go  |  2 +-
 src/cmd/compile/internal/ir/func.go         |  7 +--
 src/cmd/compile/internal/ir/name.go         |  3 +-
 src/cmd/compile/internal/ssagen/abi.go      |  4 +-
 src/cmd/compile/internal/ssagen/ssa.go      |  4 +-
 src/cmd/compile/internal/staticdata/data.go |  2 +-
 src/cmd/compile/internal/typecheck/syms.go  | 11 +++--
 src/cmd/compile/internal/types/sym.go       | 47 ++++++---------------
 10 files changed, 67 insertions(+), 53 deletions(-)
 create mode 100644 src/cmd/compile/internal/base/link.go

diff --git a/src/cmd/compile/internal/base/base.go b/src/cmd/compile/internal/base/base.go
index 5a30fa6a33..3b9bc3a8af 100644
--- a/src/cmd/compile/internal/base/base.go
+++ b/src/cmd/compile/internal/base/base.go
@@ -6,12 +6,8 @@ package base
 
 import (
 	"os"
-
-	"cmd/internal/obj"
 )
 
-var Ctxt *obj.Link
-
 var atExitFuncs []func()
 
 func AtExit(f func()) {
diff --git a/src/cmd/compile/internal/base/link.go b/src/cmd/compile/internal/base/link.go
new file mode 100644
index 0000000000..49fe4352b2
--- /dev/null
+++ b/src/cmd/compile/internal/base/link.go
@@ -0,0 +1,36 @@
+// Copyright 2021 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 base
+
+import (
+	"cmd/internal/obj"
+)
+
+var Ctxt *obj.Link
+
+// TODO(mdempsky): These should probably be obj.Link methods.
+
+// PkgLinksym returns the linker symbol for name within the given
+// package prefix. For user packages, prefix should be the package
+// path encoded with objabi.PathToPrefix.
+func PkgLinksym(prefix, name string, abi obj.ABI) *obj.LSym {
+	if name == "_" {
+		// TODO(mdempsky): Cleanup callers and Fatalf instead.
+		return linksym(prefix, "_", abi)
+	}
+	return linksym(prefix, prefix+"."+name, abi)
+}
+
+// Linkname returns the linker symbol for the given name as it might
+// appear within a //go:linkname directive.
+func Linkname(name string, abi obj.ABI) *obj.LSym {
+	return linksym("_", name, abi)
+}
+
+// linksym is an internal helper function for implementing the above
+// exported APIs.
+func linksym(pkg, name string, abi obj.ABI) *obj.LSym {
+	return Ctxt.LookupABIInit(name, abi, func(r *obj.LSym) { r.Pkg = pkg })
+}
diff --git a/src/cmd/compile/internal/dwarfgen/dwarf.go b/src/cmd/compile/internal/dwarfgen/dwarf.go
index 2440e3c8d3..bf039c8fbb 100644
--- a/src/cmd/compile/internal/dwarfgen/dwarf.go
+++ b/src/cmd/compile/internal/dwarfgen/dwarf.go
@@ -28,7 +28,7 @@ func Info(fnsym *obj.LSym, infosym *obj.LSym, curfn interface{}) ([]dwarf.Scope,
 	if fn.Nname != nil {
 		expect := fn.Linksym()
 		if fnsym.ABI() == obj.ABI0 {
-			expect = fn.Sym().LinksymABI0()
+			expect = fn.LinksymABI(obj.ABI0)
 		}
 		if fnsym != expect {
 			base.Fatalf("unexpected fnsym: %v != %v", fnsym, expect)
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 4afdadf57b..0a9db92d96 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -133,9 +133,10 @@ func (n *Func) copy() Node                         { panic(n.no("copy")) }
 func (n *Func) doChildren(do func(Node) bool) bool { return doNodes(n.Body, do) }
 func (n *Func) editChildren(edit func(Node) Node)  { editNodes(n.Body, edit) }
 
-func (f *Func) Type() *types.Type  { return f.Nname.Type() }
-func (f *Func) Sym() *types.Sym    { return f.Nname.Sym() }
-func (f *Func) Linksym() *obj.LSym { return f.Nname.Linksym() }
+func (f *Func) Type() *types.Type                { return f.Nname.Type() }
+func (f *Func) Sym() *types.Sym                  { return f.Nname.Sym() }
+func (f *Func) Linksym() *obj.LSym               { return f.Nname.Linksym() }
+func (f *Func) LinksymABI(abi obj.ABI) *obj.LSym { return f.Nname.LinksymABI(abi) }
 
 // An Inline holds fields used for function bodies that can be inlined.
 type Inline struct {
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 64de42382e..fa0639600c 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -226,7 +226,8 @@ func (n *Name) SetWalkdef(x uint8) {
 	n.bits.set2(miniWalkdefShift, x)
 }
 
-func (n *Name) Linksym() *obj.LSym { return n.sym.Linksym() }
+func (n *Name) Linksym() *obj.LSym               { return n.sym.Linksym() }
+func (n *Name) LinksymABI(abi obj.ABI) *obj.LSym { return n.sym.LinksymABI(abi) }
 
 func (*Name) CanBeNtype()    {}
 func (*Name) CanBeAnSSASym() {}
diff --git a/src/cmd/compile/internal/ssagen/abi.go b/src/cmd/compile/internal/ssagen/abi.go
index b5da420872..5bebce1db5 100644
--- a/src/cmd/compile/internal/ssagen/abi.go
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -161,11 +161,11 @@ func selectLSym(f *ir.Func, hasBody bool) {
 
 		var wrapperABI obj.ABI
 		needABIWrapper := false
-		defABI, hasDefABI := symabiDefs[nam.Sym().LinksymName()]
+		defABI, hasDefABI := symabiDefs[nam.Linksym().Name]
 		if hasDefABI && defABI == obj.ABI0 {
 			// Symbol is defined as ABI0. Create an
 			// Internal -> ABI0 wrapper.
-			f.LSym = nam.Sym().LinksymABI0()
+			f.LSym = nam.LinksymABI(obj.ABI0)
 			needABIWrapper, wrapperABI = true, obj.ABIInternal
 		} else {
 			f.LSym = nam.Linksym()
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 72db4430a5..8ed0e6101c 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -7403,9 +7403,9 @@ func callTargetLSym(callee *ir.Name, callerLSym *obj.LSym) *obj.LSym {
 		}
 	} else {
 		// check for case 2 above
-		defABI, hasDefABI := symabiDefs[callee.Sym().LinksymName()]
+		defABI, hasDefABI := symabiDefs[lsym.Name]
 		if hasDefABI && defABI == obj.ABI0 {
-			lsym = callee.Sym().LinksymABI0()
+			lsym = callee.LinksymABI(obj.ABI0)
 		}
 	}
 	return lsym
diff --git a/src/cmd/compile/internal/staticdata/data.go b/src/cmd/compile/internal/staticdata/data.go
index 6ef99b50c7..b06fd7aa4b 100644
--- a/src/cmd/compile/internal/staticdata/data.go
+++ b/src/cmd/compile/internal/staticdata/data.go
@@ -287,7 +287,7 @@ func NeedFuncSym(s *types.Sym) {
 
 func WriteFuncSyms() {
 	sort.Slice(funcsyms, func(i, j int) bool {
-		return funcsyms[i].LinksymName() < funcsyms[j].LinksymName()
+		return funcsyms[i].Linksym().Name < funcsyms[j].Linksym().Name
 	})
 	for _, s := range funcsyms {
 		sf := s.Pkg.Lookup(ir.FuncSymName(s)).Linksym()
diff --git a/src/cmd/compile/internal/typecheck/syms.go b/src/cmd/compile/internal/typecheck/syms.go
index f6ff2ee5da..202a932e6c 100644
--- a/src/cmd/compile/internal/typecheck/syms.go
+++ b/src/cmd/compile/internal/typecheck/syms.go
@@ -86,14 +86,17 @@ func InitRuntime() {
 // LookupRuntimeFunc looks up Go function name in package runtime. This function
 // must follow the internal calling convention.
 func LookupRuntimeFunc(name string) *obj.LSym {
-	s := ir.Pkgs.Runtime.Lookup(name)
-	s.SetFunc(true)
-	return s.Linksym()
+	return LookupRuntimeABI(name, obj.ABIInternal)
 }
 
 // LookupRuntimeVar looks up a variable (or assembly function) name in package
 // runtime. If this is a function, it may have a special calling
 // convention.
 func LookupRuntimeVar(name string) *obj.LSym {
-	return ir.Pkgs.Runtime.Lookup(name).Linksym()
+	return LookupRuntimeABI(name, obj.ABI0)
+}
+
+// LookupRuntimeABI looks up a name in package runtime using the given ABI.
+func LookupRuntimeABI(name string, abi obj.ABI) *obj.LSym {
+	return base.PkgLinksym("runtime", name, abi)
 }
diff --git a/src/cmd/compile/internal/types/sym.go b/src/cmd/compile/internal/types/sym.go
index 2914e2ed3f..0e66ed348b 100644
--- a/src/cmd/compile/internal/types/sym.go
+++ b/src/cmd/compile/internal/types/sym.go
@@ -64,53 +64,30 @@ func (sym *Sym) IsBlank() bool {
 	return sym != nil && sym.Name == "_"
 }
 
-func (sym *Sym) LinksymName() string {
-	if sym.IsBlank() {
-		return "_"
-	}
-	if sym.Linkname != "" {
-		return sym.Linkname
-	}
-	return sym.Pkg.Prefix + "." + sym.Name
-}
-
 // Deprecated: This method should not be used directly. Instead, use a
 // higher-level abstraction that directly returns the linker symbol
 // for a named object. For example, reflectdata.TypeLinksym(t) instead
 // of reflectdata.TypeSym(t).Linksym().
 func (sym *Sym) Linksym() *obj.LSym {
-	if sym == nil {
-		return nil
-	}
-	initPkg := func(r *obj.LSym) {
-		if sym.Linkname != "" {
-			r.Pkg = "_"
-		} else {
-			r.Pkg = sym.Pkg.Prefix
-		}
-	}
+	abi := obj.ABI0
 	if sym.Func() {
-		// This is a function symbol. Mark it as "internal ABI".
-		return base.Ctxt.LookupABIInit(sym.LinksymName(), obj.ABIInternal, initPkg)
+		abi = obj.ABIInternal
 	}
-	return base.Ctxt.LookupInit(sym.LinksymName(), initPkg)
+	return sym.LinksymABI(abi)
 }
 
-// LinksymABI0 looks up or creates an ABI0 linker symbol for "sym",
-// in cases where we want to specifically select the ABI0 version of
-// a symbol (typically used only for ABI wrappers).
-func (sym *Sym) LinksymABI0() *obj.LSym {
+// Deprecated: This method should not be used directly. Instead, use a
+// higher-level abstraction that directly returns the linker symbol
+// for a named object. For example, (*ir.Name).LinksymABI(abi) instead
+// of (*ir.Name).Sym().LinksymABI(abi).
+func (sym *Sym) LinksymABI(abi obj.ABI) *obj.LSym {
 	if sym == nil {
-		return nil
+		base.Fatalf("nil symbol")
 	}
-	initPkg := func(r *obj.LSym) {
-		if sym.Linkname != "" {
-			r.Pkg = "_"
-		} else {
-			r.Pkg = sym.Pkg.Prefix
-		}
+	if sym.Linkname != "" {
+		return base.Linkname(sym.Linkname, abi)
 	}
-	return base.Ctxt.LookupABIInit(sym.LinksymName(), obj.ABI0, initPkg)
+	return base.PkgLinksym(sym.Pkg.Prefix, sym.Name, abi)
 }
 
 // Less reports whether symbol a is ordered before symbol b.
-- 
GitLab


From a2f825c542bc62b9d4341080302ed309cd3daa97 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 17 Jan 2021 02:53:18 -0800
Subject: [PATCH 0514/2400] [dev.regabi] cmd/compile: directly create go.map
 and go.track symbols

These symbols are implementation details and don't correspond to Go
source symbols, so directly create them as linker symbols and get rid
of their pseudo packages.

Passes toolstash -cmp w/ -gcflags=all=-abiwrap.

Change-Id: I2e97374c21f3e909f6d350f15e7a5ed3574cadf4
Reviewed-on: https://go-review.googlesource.com/c/go/+/284372
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/main.go             |  7 -------
 src/cmd/compile/internal/gc/obj.go              |  2 +-
 src/cmd/compile/internal/ir/symtab.go           |  2 --
 src/cmd/compile/internal/reflectdata/reflect.go | 17 ++++-------------
 4 files changed, 5 insertions(+), 23 deletions(-)

diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index f758933d79..726a0685d5 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -96,13 +96,6 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	ir.Pkgs.Itab = types.NewPkg("go.itab", "go.itab")
 	ir.Pkgs.Itab.Prefix = "go.itab" // not go%2eitab
 
-	ir.Pkgs.Track = types.NewPkg("go.track", "go.track")
-	ir.Pkgs.Track.Prefix = "go.track" // not go%2etrack
-
-	// pseudo-package used for map zero values
-	ir.Pkgs.Map = types.NewPkg("go.map", "go.map")
-	ir.Pkgs.Map.Prefix = "go.map"
-
 	// pseudo-package used for methods with anonymous receivers
 	ir.Pkgs.Go = types.NewPkg("go", "")
 
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 847d849666..0472af7441 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -146,7 +146,7 @@ func dumpdata() {
 	dumpglobls(typecheck.Target.Externs[numExterns:])
 
 	if reflectdata.ZeroSize > 0 {
-		zero := ir.Pkgs.Map.Lookup("zero").Linksym()
+		zero := base.PkgLinksym("go.map", "zero", obj.ABI0)
 		objw.Global(zero, int32(reflectdata.ZeroSize), obj.DUPOK|obj.RODATA)
 	}
 
diff --git a/src/cmd/compile/internal/ir/symtab.go b/src/cmd/compile/internal/ir/symtab.go
index 0968efbf5c..61727fb1c4 100644
--- a/src/cmd/compile/internal/ir/symtab.go
+++ b/src/cmd/compile/internal/ir/symtab.go
@@ -67,8 +67,6 @@ var Syms struct {
 var Pkgs struct {
 	Go      *types.Pkg
 	Itab    *types.Pkg
-	Map     *types.Pkg
 	Runtime *types.Pkg
-	Track   *types.Pkg
 	Unsafe  *types.Pkg
 }
diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index bd89b62ff5..1ec92e3dd0 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -791,7 +791,7 @@ func dcommontype(lsym *obj.LSym, t *types.Type) int {
 // TrackSym returns the symbol for tracking use of field/method f, assumed
 // to be a member of struct/interface type t.
 func TrackSym(t *types.Type, f *types.Field) *obj.LSym {
-	return ir.Pkgs.Track.Lookup(t.ShortString() + "." + f.Sym.Name).Linksym()
+	return base.PkgLinksym("go.track", t.ShortString() + "." + f.Sym.Name, obj.ABI0)
 }
 
 func TypeSymPrefix(prefix string, t *types.Type) *types.Sym {
@@ -1654,18 +1654,9 @@ func ZeroAddr(size int64) ir.Node {
 	if ZeroSize < size {
 		ZeroSize = size
 	}
-	s := ir.Pkgs.Map.Lookup("zero")
-	if s.Def == nil {
-		x := typecheck.NewName(s)
-		x.SetType(types.Types[types.TUINT8])
-		x.Class = ir.PEXTERN
-		x.SetTypecheck(1)
-		s.Def = x
-	}
-	z := typecheck.NodAddr(ir.AsNode(s.Def))
-	z.SetType(types.NewPtr(types.Types[types.TUINT8]))
-	z.SetTypecheck(1)
-	return z
+	lsym := base.PkgLinksym("go.map", "zero", obj.ABI0)
+	x := ir.NewLinksymExpr(base.Pos, lsym, types.Types[types.TUINT8])
+	return typecheck.Expr(typecheck.NodAddr(x))
 }
 
 func CollectPTabs() {
-- 
GitLab


From 9423d50d53f132d7d00f5126144736bfe65627b6 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Tue, 19 Jan 2021 22:57:45 +0700
Subject: [PATCH 0515/2400] [dev.regabi] cmd/compile: use '%q' for printing
 rune values less than 128

Fixes #43762

Change-Id: I51734c9b4ee2366a5dae53b2d27b363f4d5fe6c1
Reviewed-on: https://go-review.googlesource.com/c/go/+/284592
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/fmt.go | 14 +++++++-------
 test/fixedbugs/issue43762.go       | 11 +++++++++++
 2 files changed, 18 insertions(+), 7 deletions(-)
 create mode 100644 test/fixedbugs/issue43762.go

diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index ee6a62625a..0ebfb84286 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -589,20 +589,20 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		}
 
 		if n.Type() == types.UntypedRune {
-			switch x, ok := constant.Int64Val(n.Val()); {
+			switch x, ok := constant.Uint64Val(n.Val()); {
 			case !ok:
 				fallthrough
 			default:
 				fmt.Fprintf(s, "('\\x00' + %v)", n.Val())
 
-			case ' ' <= x && x < utf8.RuneSelf && x != '\\' && x != '\'':
-				fmt.Fprintf(s, "'%c'", int(x))
+			case x < utf8.RuneSelf:
+				fmt.Fprintf(s, "%q", x)
 
-			case 0 <= x && x < 1<<16:
-				fmt.Fprintf(s, "'\\u%04x'", uint(int(x)))
+			case x < 1<<16:
+				fmt.Fprintf(s, "'\\u%04x'", x)
 
-			case 0 <= x && x <= utf8.MaxRune:
-				fmt.Fprintf(s, "'\\U%08x'", uint64(x))
+			case x <= utf8.MaxRune:
+				fmt.Fprintf(s, "'\\U%08x'", x)
 			}
 		} else {
 			fmt.Fprint(s, types.FmtConst(n.Val(), s.Flag('#')))
diff --git a/test/fixedbugs/issue43762.go b/test/fixedbugs/issue43762.go
new file mode 100644
index 0000000000..4544b6e496
--- /dev/null
+++ b/test/fixedbugs/issue43762.go
@@ -0,0 +1,11 @@
+// errorcheck
+
+// Copyright 2021 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 p
+
+var _ = true == '\\' // ERROR "invalid operation: true == '\\\\'"
+var _ = true == '\'' // ERROR "invalid operation: true == '\\''"
+var _ = true == '\n' // ERROR "invalid operation: true == '\\n'"
-- 
GitLab


From 3c0a39c964bb149f0a272c396ae3e7b3c4d36e30 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Fri, 15 Jan 2021 14:37:35 -0800
Subject: [PATCH 0516/2400] [dev.typeparams] cmd/compile/internal/types: minor
 fixes/cleanups around testing

Also, implemented isConstType predicate in terms of "is" predicate.

Change-Id: Ib3b311f52196dba974802348bc6d63307530d915
Reviewed-on: https://go-review.googlesource.com/c/go/+/284217
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/check_test.go      | 14 +++++++++++---
 src/cmd/compile/internal/types2/predicates.go      |  8 ++------
 src/cmd/compile/internal/types2/testdata/expr3.src |  4 ----
 3 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/cmd/compile/internal/types2/check_test.go b/src/cmd/compile/internal/types2/check_test.go
index 85bf0728c0..b03b074b6d 100644
--- a/src/cmd/compile/internal/types2/check_test.go
+++ b/src/cmd/compile/internal/types2/check_test.go
@@ -47,12 +47,12 @@ var (
 	testFiles   = flag.String("files", "", "space-separated list of test files")
 )
 
-func parseFiles(t *testing.T, filenames []string) ([]*syntax.File, []error) {
+func parseFiles(t *testing.T, filenames []string, mode syntax.Mode) ([]*syntax.File, []error) {
 	var files []*syntax.File
 	var errlist []error
 	errh := func(err error) { errlist = append(errlist, err) }
 	for _, filename := range filenames {
-		file, err := syntax.ParseFile(filename, errh, nil, syntax.AllowGenerics)
+		file, err := syntax.ParseFile(filename, errh, nil, mode)
 		if file == nil {
 			t.Fatalf("%s: %s", filename, err)
 		}
@@ -84,8 +84,16 @@ func delta(x, y uint) uint {
 }
 
 func checkFiles(t *testing.T, sources []string, colDelta uint, trace bool) {
+	if len(sources) == 0 {
+		t.Fatal("no source files")
+	}
+
+	var mode syntax.Mode
+	if strings.HasSuffix(sources[0], ".go2") {
+		mode |= syntax.AllowGenerics
+	}
 	// parse files and collect parser errors
-	files, errlist := parseFiles(t, sources)
+	files, errlist := parseFiles(t, sources, mode)
 
 	pkgName := "<no package>"
 	if len(files) > 0 {
diff --git a/src/cmd/compile/internal/types2/predicates.go b/src/cmd/compile/internal/types2/predicates.go
index b910d8d0ee..9cce189140 100644
--- a/src/cmd/compile/internal/types2/predicates.go
+++ b/src/cmd/compile/internal/types2/predicates.go
@@ -73,12 +73,8 @@ func isUntyped(typ Type) bool {
 	return !isTyped(typ)
 }
 
-func isOrdered(typ Type) bool { return is(typ, IsOrdered) }
-
-func isConstType(typ Type) bool {
-	t := typ.Basic()
-	return t != nil && t.info&IsConstType != 0
-}
+func isOrdered(typ Type) bool   { return is(typ, IsOrdered) }
+func isConstType(typ Type) bool { return is(typ, IsConstType) }
 
 // IsInterface reports whether typ is an interface type.
 func IsInterface(typ Type) bool {
diff --git a/src/cmd/compile/internal/types2/testdata/expr3.src b/src/cmd/compile/internal/types2/testdata/expr3.src
index 071c9bb367..6d0ac6cd94 100644
--- a/src/cmd/compile/internal/types2/testdata/expr3.src
+++ b/src/cmd/compile/internal/types2/testdata/expr3.src
@@ -145,10 +145,6 @@ func indexes() {
 	ms = "foo" /* ERROR "cannot use .* in assignment" */ [1:2]
 	ms = "foo" /* ERROR "cannot use .* in assignment" */ [i:j]
 	_, _ = ss, ms
-
-	// With type parameters, index expressions may have multiple indices.
-	_ = a[i, j /* ERROR "more than one index" */ ]
-	_ = a[i, j /* ERROR "more than one index" */ , j]
 }
 
 type T struct {
-- 
GitLab


From 90bfc7307175c2f58d4efb48003670dba23385ed Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 19 Jan 2021 10:38:33 -0800
Subject: [PATCH 0517/2400] [dev.typeparams] cmd/compile: cache mapped types
 during irgen

If we see the exact same types2.Type a second time, we can map it to
the same *types.Type instance. Not strictly necessary, but reduces
memory usage and plays better with the rest of the compiler given the
current state of things.

Change-Id: I53686d072c7c7834b0c97417bc8d5f2cd24572b2
Reviewed-on: https://go-review.googlesource.com/c/go/+/284692
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/irgen.go |  2 ++
 src/cmd/compile/internal/noder/types.go | 14 ++++++++++++++
 2 files changed, 16 insertions(+)

diff --git a/src/cmd/compile/internal/noder/irgen.go b/src/cmd/compile/internal/noder/irgen.go
index 694a6abb8e..e127348482 100644
--- a/src/cmd/compile/internal/noder/irgen.go
+++ b/src/cmd/compile/internal/noder/irgen.go
@@ -79,6 +79,7 @@ func check2(noders []*noder) {
 		info:   &info,
 		posMap: m,
 		objs:   make(map[types2.Object]*ir.Name),
+		typs:   make(map[types2.Type]*types.Type),
 	}
 	g.generate(noders)
 
@@ -94,6 +95,7 @@ type irgen struct {
 
 	posMap
 	objs   map[types2.Object]*ir.Name
+	typs   map[types2.Type]*types.Type
 	marker dwarfgen.ScopeMarker
 }
 
diff --git a/src/cmd/compile/internal/noder/types.go b/src/cmd/compile/internal/noder/types.go
index 0635d76077..aec1846619 100644
--- a/src/cmd/compile/internal/noder/types.go
+++ b/src/cmd/compile/internal/noder/types.go
@@ -26,6 +26,20 @@ func (g *irgen) pkg(pkg *types2.Package) *types.Pkg {
 }
 
 func (g *irgen) typ(typ types2.Type) *types.Type {
+	// Caching type mappings isn't strictly needed, because typ0 preserves
+	// type identity; but caching minimizes memory blow-up from mapping the
+	// same composite type multiple times, and also plays better with the
+	// current state of cmd/compile (e.g., haphazard calculation of type
+	// sizes).
+	res, ok := g.typs[typ]
+	if !ok {
+		res = g.typ0(typ)
+		g.typs[typ] = res
+	}
+	return res
+}
+
+func (g *irgen) typ0(typ types2.Type) *types.Type {
 	switch typ := typ.(type) {
 	case *types2.Basic:
 		return g.basic(typ)
-- 
GitLab


From 958927c8249fc7e073ffa5e5f0a8f7d3498b5616 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Fri, 15 Jan 2021 11:08:02 -0500
Subject: [PATCH 0518/2400] [dev.typeparams] go/parser: error for type
 instances without ParseTypeParams

It should be an invariant that the parser does not produce ast.CallExprs
with Brackets == true unless parsing with ParseTypeParams.

Fix the one case where this invariant was violated, and add a test for
errors produced in valid generic code when ParseTypeParams is unset. We
did have some coverage of errors in short_test.go, but I find them to be
easier to read in a testdata file and would like to gradually migrate
them there.

Change-Id: If2d174377087daa1b820cabc2b5bf8bcb0b39d8e
Reviewed-on: https://go-review.googlesource.com/c/go/+/284192
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Trust: Robert Findley <rfindley@google.com>
---
 src/go/parser/parser.go               |  7 +++++++
 src/go/parser/testdata/typeparams.src | 17 +++++++++++++++++
 2 files changed, 24 insertions(+)
 create mode 100644 src/go/parser/testdata/typeparams.src

diff --git a/src/go/parser/parser.go b/src/go/parser/parser.go
index 24e84d5103..ccbcef8f26 100644
--- a/src/go/parser/parser.go
+++ b/src/go/parser/parser.go
@@ -1494,6 +1494,7 @@ func (p *parser) parseIndexOrSliceOrInstance(x ast.Expr) ast.Expr {
 	var args []ast.Expr
 	var index [N]ast.Expr
 	var colons [N - 1]token.Pos
+	var firstComma token.Pos
 	if p.tok != token.COLON {
 		// We can't know if we have an index expression or a type instantiation;
 		// so even if we see a (named) type we are not going to be in type context.
@@ -1512,6 +1513,7 @@ func (p *parser) parseIndexOrSliceOrInstance(x ast.Expr) ast.Expr {
 			}
 		}
 	case token.COMMA:
+		firstComma = p.pos
 		// instance expression
 		args = append(args, index[0])
 		for p.tok == token.COMMA {
@@ -1549,6 +1551,11 @@ func (p *parser) parseIndexOrSliceOrInstance(x ast.Expr) ast.Expr {
 		return &ast.IndexExpr{X: x, Lbrack: lbrack, Index: index[0], Rbrack: rbrack}
 	}
 
+	if p.mode&ParseTypeParams == 0 {
+		p.error(firstComma, "expected ']' or ':', found ','")
+		return &ast.BadExpr{From: args[0].Pos(), To: args[len(args)-1].End()}
+	}
+
 	// instance expression
 	return &ast.CallExpr{Fun: x, Lparen: lbrack, Args: args, Rparen: rbrack, Brackets: true}
 }
diff --git a/src/go/parser/testdata/typeparams.src b/src/go/parser/testdata/typeparams.src
new file mode 100644
index 0000000000..1fea23f51a
--- /dev/null
+++ b/src/go/parser/testdata/typeparams.src
@@ -0,0 +1,17 @@
+// Copyright 2021 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.
+
+// Test cases for error messages produced while parsing code that uses type
+// parameters, without ParseTypeParams being enabled.
+
+package p
+
+type List[E any /* ERROR "expected ']', found any" */ ] []E
+
+type Pair[L, /* ERROR "expected ']', found ','" */ R any] struct {
+	Left L
+	Right R
+}
+
+var _ = Pair[int, /* ERROR "expected ']' or ':', found ','" */ string]{}
-- 
GitLab


From 2e64511ac965085cc6a74888b0e441c7e4a47468 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Fri, 15 Jan 2021 11:19:13 -0500
Subject: [PATCH 0519/2400] [dev.typeparams] go/types: unify methods in
 missingMethod

Unify methods in Checker.missingMethod. This code was accidentally
dropped from the merge, while dropping support for method type
parameters, but is needed for checking implementations of generic
interfaces.

Put the logic back, including checks that are only needed for method
type parameters. It makes the code no simpler to assume that method type
parameters are disallowed, and we have checks elsewhere that produce
errors for methods with type parameters.

Change-Id: I91f0c9d3e04537fdb9f7ae23a4ce4cec9f1da10e
Reviewed-on: https://go-review.googlesource.com/c/go/+/284252
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/lookup.go | 62 +++++++++++++++++++++++++++++++++---------
 1 file changed, 49 insertions(+), 13 deletions(-)

diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go
index f385ac993f..a0e7f3cc0d 100644
--- a/src/go/types/lookup.go
+++ b/src/go/types/lookup.go
@@ -325,21 +325,30 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
 				return m, f
 			}
 
-			if !check.identical(f.Type(), m.Type()) {
+			ftyp := f.typ.(*Signature)
+			mtyp := m.typ.(*Signature)
+			if len(ftyp.tparams) != len(mtyp.tparams) {
 				return m, f
 			}
 
-			// TODO(rFindley) delete this note once the spec has stabilized to
-			//                exclude method type parameters.
-			// NOTE: if enabling method type parameters, we need to unify f.Type()
-			// and m.Type() here to verify that their type parameters align (assuming
-			// this behaves correctly with respect to type bounds).
+			// If the methods have type parameters we don't care whether they
+			// are the same or not, as long as they match up. Use unification
+			// to see if they can be made to match.
+			// TODO(gri) is this always correct? what about type bounds?
+			// (Alternative is to rename/subst type parameters and compare.)
+			u := newUnifier(check, true)
+			u.x.init(ftyp.tparams)
+			if !u.unify(ftyp, mtyp) {
+				return m, f
+			}
 		}
 
 		return
 	}
 
 	// A concrete type implements T if it implements all methods of T.
+	Vd, _ := deref(V)
+	Vn := asNamed(Vd)
 	for _, m := range T.allMethods {
 		// TODO(gri) should this be calling lookupFieldOrMethod instead (and why not)?
 		obj, _, _ := check.rawLookupFieldOrMethod(V, false, m.pkg, m.name)
@@ -368,16 +377,43 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
 			check.objDecl(f, nil)
 		}
 
-		if !check.identical(f.Type(), m.Type()) {
+		// both methods must have the same number of type parameters
+		ftyp := f.typ.(*Signature)
+		mtyp := m.typ.(*Signature)
+		if len(ftyp.tparams) != len(mtyp.tparams) {
 			return m, f
 		}
 
-		// TODO(rFindley) delete this note once the spec has stabilized to exclude
-		//                method type parameters.
-		// NOTE: if enabling method type parameters, one needs to subst any
-		// receiver type parameters for V here, and unify f.Type() with m.Type() to
-		// verify that their type parameters align (assuming this behaves correctly
-		// with respect to type bounds).
+		// If V is a (instantiated) generic type, its methods are still
+		// parameterized using the original (declaration) receiver type
+		// parameters (subst simply copies the existing method list, it
+		// does not instantiate the methods).
+		// In order to compare the signatures, substitute the receiver
+		// type parameters of ftyp with V's instantiation type arguments.
+		// This lazily instantiates the signature of method f.
+		if Vn != nil && len(Vn.tparams) > 0 {
+			// Be careful: The number of type arguments may not match
+			// the number of receiver parameters. If so, an error was
+			// reported earlier but the length discrepancy is still
+			// here. Exit early in this case to prevent an assertion
+			// failure in makeSubstMap.
+			// TODO(gri) Can we avoid this check by fixing the lengths?
+			if len(ftyp.rparams) != len(Vn.targs) {
+				return
+			}
+			ftyp = check.subst(token.NoPos, ftyp, makeSubstMap(ftyp.rparams, Vn.targs)).(*Signature)
+		}
+
+		// If the methods have type parameters we don't care whether they
+		// are the same or not, as long as they match up. Use unification
+		// to see if they can be made to match.
+		// TODO(gri) is this always correct? what about type bounds?
+		// (Alternative is to rename/subst type parameters and compare.)
+		u := newUnifier(check, true)
+		u.x.init(ftyp.tparams)
+		if !u.unify(ftyp, mtyp) {
+			return m, f
+		}
 	}
 
 	return
-- 
GitLab


From f38f862417d19485468474646848d4294f8587b8 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Fri, 15 Jan 2021 11:23:28 -0500
Subject: [PATCH 0520/2400] [dev.typeparams] go/types: strip annotations from
 errors

Strip annotations from errors before emitting them. This is a partial
merge from dev.go2go: the Error.Full field is omitted for now, and
stripAnnotations is integrated with the updated error handling from
master.

Change-Id: Ia24d66b691a10d90b258b0b688d50c6b176bd629
Reviewed-on: https://go-review.googlesource.com/c/go/+/284253
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Trust: Robert Findley <rfindley@google.com>
---
 src/go/types/errors.go | 36 +++++++++++++++++++++++++++---------
 1 file changed, 27 insertions(+), 9 deletions(-)

diff --git a/src/go/types/errors.go b/src/go/types/errors.go
index a2195011f0..a956256762 100644
--- a/src/go/types/errors.go
+++ b/src/go/types/errors.go
@@ -89,15 +89,18 @@ func (check *Checker) err(err error) {
 		return
 	}
 
-	if check.errpos != nil && isInternal {
-		// If we have an internal error and the errpos override is set, use it to
-		// augment our error positioning.
-		// TODO(rFindley) we may also want to augment the error message and refer
-		// to the position (pos) in the original expression.
-		span := spanOf(check.errpos)
-		e.Pos = span.pos
-		e.go116start = span.start
-		e.go116end = span.end
+	if isInternal {
+		e.Msg = stripAnnotations(e.Msg)
+		if check.errpos != nil {
+			// If we have an internal error and the errpos override is set, use it to
+			// augment our error positioning.
+			// TODO(rFindley) we may also want to augment the error message and refer
+			// to the position (pos) in the original expression.
+			span := spanOf(check.errpos)
+			e.Pos = span.pos
+			e.go116start = span.start
+			e.go116end = span.end
+		}
 		err = e
 	}
 
@@ -225,3 +228,18 @@ func spanOf(at positioner) posSpan {
 		return posSpan{pos, pos, pos}
 	}
 }
+
+// stripAnnotations removes internal (type) annotations from s.
+func stripAnnotations(s string) string {
+	var b strings.Builder
+	for _, r := range s {
+		// strip #'s and subscript digits
+		if r != instanceMarker && !('₀' <= r && r < '₀'+10) { // '₀' == U+2080
+			b.WriteRune(r)
+		}
+	}
+	if b.Len() < len(s) {
+		return b.String()
+	}
+	return s
+}
-- 
GitLab


From 3e15bf77166bc89fb6af8649da560b09d9c0ada5 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Fri, 15 Jan 2021 11:30:49 -0500
Subject: [PATCH 0521/2400] [dev.typeparams] go/types: don't modify
 Named.underlying in validType

This was fixed on dev.go2go in CL 240901, but accidentally omitted from
the merge.

Change-Id: I9020eb51dac4aa07d57c3de747d33ba84abb6386
Reviewed-on: https://go-review.googlesource.com/c/go/+/284254
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Trust: Robert Findley <rfindley@google.com>
---
 src/go/types/decl.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index a822e08b1e..e62edfadb2 100644
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -342,7 +342,6 @@ func (check *Checker) validType(typ Type, path []Object) typeInfo {
 				if tn == t.obj {
 					check.cycleError(path[i:])
 					t.info = invalid
-					t.underlying = Typ[Invalid]
 					return t.info
 				}
 			}
-- 
GitLab


From 48a3cb399da872554f6ea13e1e92b3c8c73fec95 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Fri, 15 Jan 2021 12:45:11 -0500
Subject: [PATCH 0522/2400] [dev.typeparams] go/types: fix some merge errors in
 call.go

Some comments were left unresolved in the merge of call.go. Resolve them
to get tests to pass (tests to be added in a later CL).

Change-Id: Icf894593e7dd5131406c4eece8d43d4cd3170d1c
Reviewed-on: https://go-review.googlesource.com/c/go/+/284255
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Trust: Robert Findley <rfindley@google.com>
---
 src/go/types/call.go | 26 ++++++++++++--------------
 1 file changed, 12 insertions(+), 14 deletions(-)

diff --git a/src/go/types/call.go b/src/go/types/call.go
index e10e0a643d..97a9d0ea8f 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -116,9 +116,7 @@ func (check *Checker) call(x *operand, call *ast.CallExpr, orig ast.Expr) exprKi
 			// If the first argument is a type, assume we have explicit type arguments.
 
 			// check number of type arguments
-			// TODO(rFindley)
-			// if !check.conf.InferFromConstraints && n != len(sig.tparams) || n > len(sig.tparams) {
-			if n != len(sig.tparams) || n > len(sig.tparams) {
+			if n > len(sig.tparams) {
 				check.errorf(args[n-1], 0, "got %d type arguments but want %d", n, len(sig.tparams))
 				x.mode = invalid
 				x.expr = orig
@@ -127,7 +125,8 @@ func (check *Checker) call(x *operand, call *ast.CallExpr, orig ast.Expr) exprKi
 
 			// collect types
 			targs := make([]Type, n)
-			// TODO(rFindley) positioner?
+			// TODO(rFindley) use a positioner here? instantiate would need to be
+			//                updated accordingly.
 			poslist := make([]token.Pos, n)
 			for i, a := range args {
 				if a.mode != typexpr {
@@ -192,7 +191,11 @@ func (check *Checker) call(x *operand, call *ast.CallExpr, orig ast.Expr) exprKi
 			return expression
 		}
 
-		// If we reach here, orig must have been a regular call, not an index expression.
+		// If we reach here, orig must have been a regular call, not an index
+		// expression.
+		// TODO(rFindley) with a manually constructed AST it is possible to reach
+		//                this assertion. We should return an invalidAST error here
+		//                rather than panicking.
 		assert(!call.Brackets)
 
 		sig = check.arguments(call, sig, args)
@@ -411,15 +414,10 @@ func (check *Checker) arguments(call *ast.CallExpr, sig *Signature, args []*oper
 		if failed >= 0 {
 			// Some type arguments couldn't be inferred. Use
 			// bounds type inference to try to make progress.
-			// TODO(rFindley)
-			/*
-				if check.conf.InferFromConstraints {
-					targs, failed = check.inferB(sig.tparams, targs)
-					if targs == nil {
-						return // error already reported
-					}
-				}
-			*/
+			targs, failed = check.inferB(sig.tparams, targs)
+			if targs == nil {
+				return // error already reported
+			}
 			if failed >= 0 {
 				// at least one type argument couldn't be inferred
 				assert(targs[failed] == nil)
-- 
GitLab


From d8796b5670d46a4197fc5e81a32d127c45ab6557 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Fri, 15 Jan 2021 18:19:00 -0800
Subject: [PATCH 0523/2400] [dev.typeparams] cmd/compile/internal/types2:
 report type of nil based on context

With this CL, the type reported for uses of the predeclared
identifier nil changes from untyped nil to the type of the
context within which nil is used, matching the behaviour of
types2 for other untyped types.

If an untyped nil value is assigned or converted to an
interface, the nil expression is given the interface type.

The predicate TypeAndValue.IsNil doesn't change in behavior,
it still reports whether the relevant expression is a (typed
or untyped) nil value.

Change-Id: Id766468f3f3f2a53e4c55e1e6cd521e459c4a94f
Reviewed-on: https://go-review.googlesource.com/c/go/+/284218
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/types2/api.go        |  7 +-
 src/cmd/compile/internal/types2/api_test.go   | 66 ++++++++++---------
 .../compile/internal/types2/assignments.go    | 10 ++-
 .../compile/internal/types2/conversions.go    | 10 +--
 src/cmd/compile/internal/types2/expr.go       | 58 +++++++---------
 .../compile/internal/types2/issues_test.go    |  2 +-
 src/cmd/compile/internal/types2/operand.go    | 23 +++++--
 .../internal/types2/testdata/stmt0.src        |  6 +-
 src/cmd/compile/internal/types2/typexpr.go    |  9 +--
 test/fixedbugs/issue6402.go                   |  2 +-
 10 files changed, 101 insertions(+), 92 deletions(-)

diff --git a/src/cmd/compile/internal/types2/api.go b/src/cmd/compile/internal/types2/api.go
index 3348ccb900..7f6653b825 100644
--- a/src/cmd/compile/internal/types2/api.go
+++ b/src/cmd/compile/internal/types2/api.go
@@ -325,16 +325,17 @@ func (tv TypeAndValue) IsBuiltin() bool {
 // nil Value.
 func (tv TypeAndValue) IsValue() bool {
 	switch tv.mode {
-	case constant_, variable, mapindex, value, commaok, commaerr:
+	case constant_, variable, mapindex, value, nilvalue, commaok, commaerr:
 		return true
 	}
 	return false
 }
 
 // IsNil reports whether the corresponding expression denotes the
-// predeclared value nil.
+// predeclared value nil. Depending on context, it may have been
+// given a type different from UntypedNil.
 func (tv TypeAndValue) IsNil() bool {
-	return tv.mode == value && tv.Type == Typ[UntypedNil]
+	return tv.mode == nilvalue
 }
 
 // Addressable reports whether the corresponding expression
diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go
index 9fcbfc469f..6f65b84f7c 100644
--- a/src/cmd/compile/internal/types2/api_test.go
+++ b/src/cmd/compile/internal/types2/api_test.go
@@ -198,37 +198,41 @@ func TestTypesInfo(t *testing.T) {
 		{`package b4; var x interface{} = "foo"`, `"foo"`, `string`},
 
 		// uses of nil
-		{`package n0; var _ *int = nil`, `nil`, `untyped nil`},
-		{`package n1; var _ func() = nil`, `nil`, `untyped nil`},
-		{`package n2; var _ []byte = nil`, `nil`, `untyped nil`},
-		{`package n3; var _ map[int]int = nil`, `nil`, `untyped nil`},
-		{`package n4; var _ chan int = nil`, `nil`, `untyped nil`},
-		{`package n5; var _ interface{} = nil`, `nil`, `untyped nil`},
-		{`package n6; import "unsafe"; var _ unsafe.Pointer = nil`, `nil`, `untyped nil`},
-
-		{`package n10; var (x *int; _ = x == nil)`, `nil`, `untyped nil`},
-		{`package n11; var (x func(); _ = x == nil)`, `nil`, `untyped nil`},
-		{`package n12; var (x []byte; _ = x == nil)`, `nil`, `untyped nil`},
-		{`package n13; var (x map[int]int; _ = x == nil)`, `nil`, `untyped nil`},
-		{`package n14; var (x chan int; _ = x == nil)`, `nil`, `untyped nil`},
-		{`package n15; var (x interface{}; _ = x == nil)`, `nil`, `untyped nil`},
-		{`package n15; import "unsafe"; var (x unsafe.Pointer; _ = x == nil)`, `nil`, `untyped nil`},
-
-		{`package n20; var _ = (*int)(nil)`, `nil`, `untyped nil`},
-		{`package n21; var _ = (func())(nil)`, `nil`, `untyped nil`},
-		{`package n22; var _ = ([]byte)(nil)`, `nil`, `untyped nil`},
-		{`package n23; var _ = (map[int]int)(nil)`, `nil`, `untyped nil`},
-		{`package n24; var _ = (chan int)(nil)`, `nil`, `untyped nil`},
-		{`package n25; var _ = (interface{})(nil)`, `nil`, `untyped nil`},
-		{`package n26; import "unsafe"; var _ = unsafe.Pointer(nil)`, `nil`, `untyped nil`},
-
-		{`package n30; func f(*int) { f(nil) }`, `nil`, `untyped nil`},
-		{`package n31; func f(func()) { f(nil) }`, `nil`, `untyped nil`},
-		{`package n32; func f([]byte) { f(nil) }`, `nil`, `untyped nil`},
-		{`package n33; func f(map[int]int) { f(nil) }`, `nil`, `untyped nil`},
-		{`package n34; func f(chan int) { f(nil) }`, `nil`, `untyped nil`},
-		{`package n35; func f(interface{}) { f(nil) }`, `nil`, `untyped nil`},
-		{`package n35; import "unsafe"; func f(unsafe.Pointer) { f(nil) }`, `nil`, `untyped nil`},
+		{`package n0; var _ *int = nil`, `nil`, `*int`},
+		{`package n1; var _ func() = nil`, `nil`, `func()`},
+		{`package n2; var _ []byte = nil`, `nil`, `[]byte`},
+		{`package n3; var _ map[int]int = nil`, `nil`, `map[int]int`},
+		{`package n4; var _ chan int = nil`, `nil`, `chan int`},
+		{`package n5a; var _ interface{} = (*int)(nil)`, `nil`, `*int`},
+		{`package n5b; var _ interface{m()} = nil`, `nil`, `interface{m()}`},
+		{`package n6; import "unsafe"; var _ unsafe.Pointer = nil`, `nil`, `unsafe.Pointer`},
+
+		{`package n10; var (x *int; _ = x == nil)`, `nil`, `*int`},
+		{`package n11; var (x func(); _ = x == nil)`, `nil`, `func()`},
+		{`package n12; var (x []byte; _ = x == nil)`, `nil`, `[]byte`},
+		{`package n13; var (x map[int]int; _ = x == nil)`, `nil`, `map[int]int`},
+		{`package n14; var (x chan int; _ = x == nil)`, `nil`, `chan int`},
+		{`package n15a; var (x interface{}; _ = x == (*int)(nil))`, `nil`, `*int`},
+		{`package n15b; var (x interface{m()}; _ = x == nil)`, `nil`, `interface{m()}`},
+		{`package n15; import "unsafe"; var (x unsafe.Pointer; _ = x == nil)`, `nil`, `unsafe.Pointer`},
+
+		{`package n20; var _ = (*int)(nil)`, `nil`, `*int`},
+		{`package n21; var _ = (func())(nil)`, `nil`, `func()`},
+		{`package n22; var _ = ([]byte)(nil)`, `nil`, `[]byte`},
+		{`package n23; var _ = (map[int]int)(nil)`, `nil`, `map[int]int`},
+		{`package n24; var _ = (chan int)(nil)`, `nil`, `chan int`},
+		{`package n25a; var _ = (interface{})((*int)(nil))`, `nil`, `*int`},
+		{`package n25b; var _ = (interface{m()})(nil)`, `nil`, `interface{m()}`},
+		{`package n26; import "unsafe"; var _ = unsafe.Pointer(nil)`, `nil`, `unsafe.Pointer`},
+
+		{`package n30; func f(*int) { f(nil) }`, `nil`, `*int`},
+		{`package n31; func f(func()) { f(nil) }`, `nil`, `func()`},
+		{`package n32; func f([]byte) { f(nil) }`, `nil`, `[]byte`},
+		{`package n33; func f(map[int]int) { f(nil) }`, `nil`, `map[int]int`},
+		{`package n34; func f(chan int) { f(nil) }`, `nil`, `chan int`},
+		{`package n35a; func f(interface{}) { f((*int)(nil)) }`, `nil`, `*int`},
+		{`package n35b; func f(interface{m()}) { f(nil) }`, `nil`, `interface{m()}`},
+		{`package n35; import "unsafe"; func f(unsafe.Pointer) { f(nil) }`, `nil`, `unsafe.Pointer`},
 
 		// comma-ok expressions
 		{`package p0; var x interface{}; var _, _ = x.(int)`,
diff --git a/src/cmd/compile/internal/types2/assignments.go b/src/cmd/compile/internal/types2/assignments.go
index 3238b3ac37..6caa4863d5 100644
--- a/src/cmd/compile/internal/types2/assignments.go
+++ b/src/cmd/compile/internal/types2/assignments.go
@@ -20,7 +20,7 @@ func (check *Checker) assignment(x *operand, T Type, context string) {
 	switch x.mode {
 	case invalid:
 		return // error reported before
-	case constant_, variable, mapindex, value, commaok, commaerr:
+	case constant_, variable, mapindex, value, nilvalue, commaok, commaerr:
 		// ok
 	default:
 		// we may get here because of other problems (issue #39634, crash 12)
@@ -35,12 +35,13 @@ func (check *Checker) assignment(x *operand, T Type, context string) {
 		// bool, rune, int, float64, complex128 or string respectively, depending
 		// on whether the value is a boolean, rune, integer, floating-point, complex,
 		// or string constant."
-		if T == nil || IsInterface(T) {
-			if T == nil && x.typ == Typ[UntypedNil] {
+		if x.isNil() {
+			if T == nil {
 				check.errorf(x, "use of untyped nil in %s", context)
 				x.mode = invalid
 				return
 			}
+		} else if T == nil || IsInterface(T) {
 			target = Default(x.typ)
 		}
 		check.convertUntyped(x, target)
@@ -192,6 +193,9 @@ func (check *Checker) assignVar(lhs syntax.Expr, x *operand) Type {
 		return nil
 	case variable, mapindex:
 		// ok
+	case nilvalue:
+		check.errorf(&z, "cannot assign to nil") // default would print "untyped nil"
+		return nil
 	default:
 		if sel, ok := z.expr.(*syntax.SelectorExpr); ok {
 			var op operand
diff --git a/src/cmd/compile/internal/types2/conversions.go b/src/cmd/compile/internal/types2/conversions.go
index 2a7b54a49c..90c08fb72f 100644
--- a/src/cmd/compile/internal/types2/conversions.go
+++ b/src/cmd/compile/internal/types2/conversions.go
@@ -49,15 +49,17 @@ func (check *Checker) conversion(x *operand, T Type) {
 	// given a type explicitly by a constant declaration or conversion,...".
 	if isUntyped(x.typ) {
 		final := T
-		// - For conversions to interfaces, use the argument's default type.
+		// - For conversions to interfaces, except for untyped nil arguments,
+		//   use the argument's default type.
 		// - For conversions of untyped constants to non-constant types, also
 		//   use the default type (e.g., []byte("foo") should report string
 		//   not []byte as type for the constant "foo").
-		// - Keep untyped nil for untyped nil arguments.
 		// - For integer to string conversions, keep the argument type.
 		//   (See also the TODO below.)
-		if IsInterface(T) || constArg && !isConstType(T) || x.isNil() {
-			final = Default(x.typ) // default type of untyped nil is untyped nil
+		if x.typ == Typ[UntypedNil] {
+			// ok
+		} else if IsInterface(T) || constArg && !isConstType(T) {
+			final = Default(x.typ)
 		} else if isInteger(x.typ) && isString(T) {
 			final = x.typ
 		}
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 7fca5db7d7..b728238d9f 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -606,18 +606,15 @@ func (check *Checker) convertUntyped(x *operand, target Type) {
 		}
 
 		for _, t := range unpack(types) {
-			check.convertUntypedInternal(x, t)
+			x := *x // make a copy; convertUntypedInternal modifies x
+			check.convertUntypedInternal(&x, t)
 			if x.mode == invalid {
 				goto Error
 			}
 		}
 
-		// keep nil untyped (was bug #39755)
-		if x.isNil() {
-			target = Typ[UntypedNil]
-		}
 		x.typ = target
-		check.updateExprType(x.expr, target, true) // UntypedNils are final
+		check.updateExprType(x.expr, target, true)
 		return
 	}
 
@@ -634,6 +631,14 @@ Error:
 func (check *Checker) convertUntypedInternal(x *operand, target Type) {
 	assert(isTyped(target))
 
+	if x.isNil() {
+		assert(isUntyped(x.typ))
+		if hasNil(target) {
+			goto OK
+		}
+		goto Error
+	}
+
 	// typed target
 	switch t := optype(target.Under()).(type) {
 	case *Basic:
@@ -648,7 +653,7 @@ func (check *Checker) convertUntypedInternal(x *operand, target Type) {
 			// Non-constant untyped values may appear as the
 			// result of comparisons (untyped bool), intermediate
 			// (delayed-checked) rhs operands of shifts, and as
-			// the value nil.
+			// the value nil. Nil was handled upfront.
 			switch x.typ.(*Basic).kind {
 			case UntypedBool:
 				if !isBoolean(target) {
@@ -662,12 +667,6 @@ func (check *Checker) convertUntypedInternal(x *operand, target Type) {
 				// Non-constant untyped string values are not
 				// permitted by the spec and should not occur.
 				unreachable()
-			case UntypedNil:
-				// Unsafe.Pointer is a basic type that includes nil.
-				if !hasNil(target) {
-					goto Error
-				}
-				target = Typ[UntypedNil]
 			default:
 				goto Error
 			}
@@ -678,34 +677,21 @@ func (check *Checker) convertUntypedInternal(x *operand, target Type) {
 			return x.mode != invalid
 		})
 	case *Interface:
-		// Update operand types to the default type rather then
-		// the target (interface) type: values must have concrete
-		// dynamic types. If the value is nil, keep it untyped
-		// (this is important for tools such as go vet which need
-		// the dynamic type for argument checking of say, print
-		// functions)
-		if x.isNil() {
-			target = Typ[UntypedNil]
-		} else {
-			// cannot assign untyped values to non-empty interfaces
-			check.completeInterface(nopos, t)
-			if !t.Empty() {
-				goto Error
-			}
-			target = Default(x.typ)
-		}
-	case *Pointer, *Signature, *Slice, *Map, *Chan:
-		if !x.isNil() {
-			goto Error
-		}
-		// keep nil untyped - see comment for interfaces, above
-		target = Typ[UntypedNil]
+		// Update operand types to the default type rather then the target
+		// (interface) type: values must have concrete dynamic types.
+		// Untyped nil was handled upfront.
+		check.completeInterface(nopos, t)
+		if !t.Empty() {
+			goto Error // cannot assign untyped values to non-empty interfaces
+		}
+		target = Default(x.typ)
 	default:
 		goto Error
 	}
 
+OK:
 	x.typ = target
-	check.updateExprType(x.expr, target, true) // UntypedNils are final
+	check.updateExprType(x.expr, target, true)
 	return
 
 Error:
diff --git a/src/cmd/compile/internal/types2/issues_test.go b/src/cmd/compile/internal/types2/issues_test.go
index f33b7c4396..9a73a46d11 100644
--- a/src/cmd/compile/internal/types2/issues_test.go
+++ b/src/cmd/compile/internal/types2/issues_test.go
@@ -76,7 +76,7 @@ var (
 			}
 		case *syntax.Name:
 			if x.Value == "nil" {
-				want = Typ[UntypedNil]
+				want = NewInterfaceType(nil, nil) // interface{}
 			}
 		}
 		if want != nil && !Identical(tv.Type, want) {
diff --git a/src/cmd/compile/internal/types2/operand.go b/src/cmd/compile/internal/types2/operand.go
index d5a10b2c29..a14120c2c9 100644
--- a/src/cmd/compile/internal/types2/operand.go
+++ b/src/cmd/compile/internal/types2/operand.go
@@ -27,6 +27,7 @@ const (
 	variable                     // operand is an addressable variable
 	mapindex                     // operand is a map index expression (acts like a variable on lhs, commaok on rhs of an assignment)
 	value                        // operand is a computed value
+	nilvalue                     // operand is the nil value
 	commaok                      // like value, but operand may be used in a comma,ok expression
 	commaerr                     // like commaok, but second value is error, not boolean
 	cgofunc                      // operand is a cgo function
@@ -41,6 +42,7 @@ var operandModeString = [...]string{
 	variable:  "variable",
 	mapindex:  "map index expression",
 	value:     "value",
+	nilvalue:  "nil",
 	commaok:   "comma, ok expression",
 	commaerr:  "comma, error expression",
 	cgofunc:   "cgo function",
@@ -96,6 +98,9 @@ func (x *operand) Pos() syntax.Pos {
 // value      <expr> (<untyped kind> <mode>                    )
 // value      <expr> (               <mode>       of type <typ>)
 //
+// nilvalue   untyped nil
+// nilvalue   nil    (                            of type <typ>)
+//
 // commaok    <expr> (<untyped kind> <mode>                    )
 // commaok    <expr> (               <mode>       of type <typ>)
 //
@@ -106,6 +111,18 @@ func (x *operand) Pos() syntax.Pos {
 // cgofunc    <expr> (               <mode>       of type <typ>)
 //
 func operandString(x *operand, qf Qualifier) string {
+	// special-case nil
+	if x.mode == nilvalue {
+		switch x.typ {
+		case nil, Typ[Invalid]:
+			return "nil (with invalid type)"
+		case Typ[UntypedNil]:
+			return "untyped nil"
+		default:
+			return fmt.Sprintf("nil (of type %s)", TypeString(x.typ, qf))
+		}
+	}
+
 	var buf bytes.Buffer
 
 	var expr string
@@ -222,10 +239,8 @@ func (x *operand) setConst(k syntax.LitKind, lit string) {
 	x.val = val
 }
 
-// isNil reports whether x is the nil value.
-func (x *operand) isNil() bool {
-	return x.mode == value && x.typ == Typ[UntypedNil]
-}
+// isNil reports whether x is a typed or the untyped nil value.
+func (x *operand) isNil() bool { return x.mode == nilvalue }
 
 // TODO(gri) The functions operand.assignableTo, checker.convertUntyped,
 //           checker.representable, and checker.assignment are
diff --git a/src/cmd/compile/internal/types2/testdata/stmt0.src b/src/cmd/compile/internal/types2/testdata/stmt0.src
index 959f7d5659..77d4ba1bfe 100644
--- a/src/cmd/compile/internal/types2/testdata/stmt0.src
+++ b/src/cmd/compile/internal/types2/testdata/stmt0.src
@@ -69,10 +69,10 @@ func assignments1() {
 
 	// test cases for issue 5800
 	var (
-		_ int = nil /* ERROR "untyped nil value" */
-		_ [10]int = nil /* ERROR "untyped nil value" */
+		_ int = nil /* ERROR "cannot convert untyped nil" */
+		_ [10]int = nil /* ERROR "cannot convert untyped nil" */
 		_ []byte = nil
-		_ struct{} = nil /* ERROR "untyped nil value" */
+		_ struct{} = nil /* ERROR "cannot convert untyped nil" */
 		_ func() = nil
 		_ map[int]string = nil
 		_ chan int = nil
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index d30f2fef26..f0461d5895 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -111,7 +111,7 @@ func (check *Checker) ident(x *operand, e *syntax.Name, def *Named, wantType boo
 		x.mode = builtin
 
 	case *Nil:
-		x.mode = value
+		x.mode = nilvalue
 
 	default:
 		unreachable()
@@ -631,11 +631,8 @@ func (check *Checker) typOrNil(e syntax.Expr) Type {
 	case typexpr:
 		check.instantiatedOperand(&x)
 		return x.typ
-	case value:
-		if x.isNil() {
-			return nil
-		}
-		fallthrough
+	case nilvalue:
+		return nil
 	default:
 		check.errorf(&x, "%s is not a type", &x)
 	}
diff --git a/test/fixedbugs/issue6402.go b/test/fixedbugs/issue6402.go
index db83e94b86..cd8fb218ac 100644
--- a/test/fixedbugs/issue6402.go
+++ b/test/fixedbugs/issue6402.go
@@ -9,5 +9,5 @@
 package p
 
 func f() uintptr {
-	return nil // ERROR "cannot use nil as type uintptr in return argument|incompatible type|cannot convert nil"
+	return nil // ERROR "cannot use nil as type uintptr in return argument|incompatible type|cannot convert untyped nil"
 }
-- 
GitLab


From 734cb8be0a05f6dba241a14f94a1d238a41d4ded Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Fri, 15 Jan 2021 11:42:10 -0500
Subject: [PATCH 0524/2400] [dev.typeparams] go/types: refactor untyped
 conversion for typeparams

Some logic was missing in the merge from dev.go2go to deal with untyped
conversion of generic types. Part of this was due to the complexity of
the merge, as untyped conversion had been refactored on master.

Rather than back out the refactoring of untyped conversion, in this CL I
have decided to take it one step further. It was always problematic that
isRepresentable and canConvertUntyped mutated their arguments. In
retrospect the refactoring was perhaps too conservative.

This CL performs the following refactoring:
 + Replace 'isRepresentable' with 'representation': a Checker method
   produces the rounded representation of an untyped constant operand as
   a target type.
 + Make some functions return error codes rather than errors, and factor
   out the construction of the error message for invalid conversion.
   This avoided some indirect code.
 + Replace implicitType with implicitTypeAndValue, and have it handle
   the case of a constant basic operand, returning the rounded value.
 + Eliminate canConvertUntyped, lifting the logic to update expr types
   and values to the two callers.
 + Add handling for Sum types in implicitTypeAndValue. Here, the
   decision was made to depart from dev.go2go (and types2), and produce
   a Sum type as output. This seemed most correct on first principles,
   and tests still passed (though some logic for recording types had to
   be updated to allow for Sum types).

Change-Id: Ic93901f69e6671b83b14ee2bf185a4ed767e31ee
Reviewed-on: https://go-review.googlesource.com/c/go/+/284256
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Trust: Robert Findley <rfindley@google.com>
---
 src/go/types/assignments.go |  32 +++++----
 src/go/types/expr.go        | 137 ++++++++++++++++++++----------------
 src/go/types/operand.go     |  11 +--
 src/go/types/predicates.go  |   8 +--
 4 files changed, 97 insertions(+), 91 deletions(-)

diff --git a/src/go/types/assignments.go b/src/go/types/assignments.go
index 3374f81899..025dcbf2c8 100644
--- a/src/go/types/assignments.go
+++ b/src/go/types/assignments.go
@@ -7,7 +7,6 @@
 package types
 
 import (
-	"errors"
 	"go/ast"
 	"go/token"
 )
@@ -46,27 +45,30 @@ func (check *Checker) assignment(x *operand, T Type, context string) {
 			}
 			target = Default(x.typ)
 		}
-		if err := check.canConvertUntyped(x, target); err != nil {
+		newType, val, code := check.implicitTypeAndValue(x, target)
+		if code != 0 {
 			msg := check.sprintf("cannot use %s as %s value in %s", x, target, context)
-			code := _IncompatibleAssign
-			var ierr Error
-			if errors.As(err, &ierr) {
-				// Preserve these inner errors, as they are informative.
-				switch ierr.go116code {
-				case _TruncatedFloat:
-					msg += " (truncated)"
-					code = ierr.go116code
-				case _NumericOverflow:
-					msg += " (overflows)"
-					code = ierr.go116code
-				}
+			switch code {
+			case _TruncatedFloat:
+				msg += " (truncated)"
+			case _NumericOverflow:
+				msg += " (overflows)"
+			default:
+				code = _IncompatibleAssign
 			}
 			check.error(x, code, msg)
 			x.mode = invalid
 			return
 		}
+		if val != nil {
+			x.val = val
+			check.updateExprVal(x.expr, val)
+		}
+		if newType != x.typ {
+			x.typ = newType
+			check.updateExprType(x.expr, newType, false)
+		}
 	}
-	// x.typ is typed
 
 	// A generic (non-instantiated) function value cannot be assigned to a variable.
 	if sig := asSignature(x.typ); sig != nil && len(sig.tparams) > 0 {
diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index dcccd87c89..1deda99aaf 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -338,17 +338,18 @@ func representableConst(x constant.Value, check *Checker, typ *Basic, rounded *c
 // representable checks that a constant operand is representable in the given
 // basic type.
 func (check *Checker) representable(x *operand, typ *Basic) {
-	if err := check.isRepresentable(x, typ); err != nil {
+	if v, code := check.representation(x, typ); code != 0 {
+		check.invalidConversion(code, x, typ)
 		x.mode = invalid
-		check.err(err)
+	} else if v != nil {
+		x.val = v
 	}
 }
 
-func (check *Checker) isRepresentable(x *operand, typ *Basic) error {
+func (check *Checker) representation(x *operand, typ *Basic) (constant.Value, errorCode) {
 	assert(x.mode == constant_)
-	if !representableConst(x.val, check, typ, &x.val) {
-		var msg string
-		var code errorCode
+	v := x.val
+	if !representableConst(x.val, check, typ, &v) {
 		if isNumeric(x.typ) && isNumeric(typ) {
 			// numeric conversion : error msg
 			//
@@ -358,19 +359,25 @@ func (check *Checker) isRepresentable(x *operand, typ *Basic) error {
 			// float   -> float   : overflows
 			//
 			if !isInteger(x.typ) && isInteger(typ) {
-				msg = "%s truncated to %s"
-				code = _TruncatedFloat
+				return nil, _TruncatedFloat
 			} else {
-				msg = "%s overflows %s"
-				code = _NumericOverflow
+				return nil, _NumericOverflow
 			}
-		} else {
-			msg = "cannot convert %s to %s"
-			code = _InvalidConstVal
 		}
-		return check.newErrorf(x, code, false, msg, x, typ)
+		return nil, _InvalidConstVal
 	}
-	return nil
+	return v, 0
+}
+
+func (check *Checker) invalidConversion(code errorCode, x *operand, target Type) {
+	msg := "cannot convert %s to %s"
+	switch code {
+	case _TruncatedFloat:
+		msg = "%s truncated to %s"
+	case _NumericOverflow:
+		msg = "%s overflows %s"
+	}
+	check.errorf(x, code, msg, x, target)
 }
 
 // updateExprType updates the type of x to typ and invokes itself
@@ -506,16 +513,29 @@ func (check *Checker) updateExprVal(x ast.Expr, val constant.Value) {
 
 // convertUntyped attempts to set the type of an untyped value to the target type.
 func (check *Checker) convertUntyped(x *operand, target Type) {
-	if err := check.canConvertUntyped(x, target); err != nil {
+	newType, val, code := check.implicitTypeAndValue(x, target)
+	if code != 0 {
+		check.invalidConversion(code, x, target.Underlying())
 		x.mode = invalid
-		check.err(err)
+		return
+	}
+	if val != nil {
+		x.val = val
+		check.updateExprVal(x.expr, val)
+	}
+	if newType != x.typ {
+		x.typ = newType
+		check.updateExprType(x.expr, newType, false)
 	}
 }
 
-func (check *Checker) canConvertUntyped(x *operand, target Type) error {
+// implicitTypeAndValue returns the implicit type of x when used in a context
+// where the target type is expected. If no such implicit conversion is
+// possible, it returns a nil Type.
+func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, constant.Value, errorCode) {
 	target = expand(target)
 	if x.mode == invalid || isTyped(x.typ) || target == Typ[Invalid] {
-		return nil
+		return x.typ, nil, 0
 	}
 
 	if isUntyped(target) {
@@ -524,43 +544,23 @@ func (check *Checker) canConvertUntyped(x *operand, target Type) error {
 		tkind := target.(*Basic).kind
 		if isNumeric(x.typ) && isNumeric(target) {
 			if xkind < tkind {
-				x.typ = target
-				check.updateExprType(x.expr, target, false)
+				return target, nil, 0
 			}
 		} else if xkind != tkind {
-			return check.newErrorf(x, _InvalidUntypedConversion, false, "cannot convert %s to %s", x, target)
-		}
-		return nil
-	}
-
-	if t, ok := target.Underlying().(*Basic); ok && x.mode == constant_ {
-		if err := check.isRepresentable(x, t); err != nil {
-			return err
-		}
-		// Expression value may have been rounded - update if needed.
-		check.updateExprVal(x.expr, x.val)
-	} else {
-		newTarget := check.implicitType(x, target)
-		if newTarget == nil {
-			return check.newErrorf(x, _InvalidUntypedConversion, false, "cannot convert %s to %s", x, target)
+			return nil, nil, _InvalidUntypedConversion
 		}
-		target = newTarget
+		return x.typ, nil, 0
 	}
-	x.typ = target
-	// Even though implicitType can return UntypedNil, this value is final: the
-	// predeclared identifier nil has no type.
-	check.updateExprType(x.expr, target, true)
-	return nil
-}
 
-// implicitType returns the implicit type of x when used in a context where the
-// target type is expected. If no such implicit conversion is possible, it
-// returns nil.
-func (check *Checker) implicitType(x *operand, target Type) Type {
-	assert(isUntyped(x.typ))
-	switch t := target.Underlying().(type) {
+	switch t := optype(target).(type) {
 	case *Basic:
-		assert(x.mode != constant_)
+		if x.mode == constant_ {
+			v, code := check.representation(x, t)
+			if code != 0 {
+				return nil, nil, code
+			}
+			return target, v, code
+		}
 		// Non-constant untyped values may appear as the
 		// result of comparisons (untyped bool), intermediate
 		// (delayed-checked) rhs operands of shifts, and as
@@ -568,26 +568,39 @@ func (check *Checker) implicitType(x *operand, target Type) Type {
 		switch x.typ.(*Basic).kind {
 		case UntypedBool:
 			if !isBoolean(target) {
-				return nil
+				return nil, nil, _InvalidUntypedConversion
 			}
 		case UntypedInt, UntypedRune, UntypedFloat, UntypedComplex:
 			if !isNumeric(target) {
-				return nil
+				return nil, nil, _InvalidUntypedConversion
 			}
 		case UntypedString:
 			// Non-constant untyped string values are not permitted by the spec and
 			// should not occur during normal typechecking passes, but this path is
 			// reachable via the AssignableTo API.
 			if !isString(target) {
-				return nil
+				return nil, nil, _InvalidUntypedConversion
 			}
 		case UntypedNil:
 			// Unsafe.Pointer is a basic type that includes nil.
 			if !hasNil(target) {
-				return nil
+				return nil, nil, _InvalidUntypedConversion
 			}
+			// TODO(rFindley) return UntypedNil here (golang.org/issues/13061).
 		default:
-			return nil
+			return nil, nil, _InvalidUntypedConversion
+		}
+	case *Sum:
+		ok := t.is(func(t Type) bool {
+			target, _, _ := check.implicitTypeAndValue(x, t)
+			return target != nil
+		})
+		if !ok {
+			return nil, nil, _InvalidUntypedConversion
+		}
+		// keep nil untyped (was bug #39755)
+		if x.isNil() {
+			return Typ[UntypedNil], nil, 0
 		}
 	case *Interface:
 		// Values must have concrete dynamic types. If the value is nil,
@@ -595,24 +608,24 @@ func (check *Checker) implicitType(x *operand, target Type) Type {
 		// need the dynamic type for argument checking of say, print
 		// functions)
 		if x.isNil() {
-			return Typ[UntypedNil]
+			return Typ[UntypedNil], nil, 0
 		}
 		// cannot assign untyped values to non-empty interfaces
 		check.completeInterface(token.NoPos, t)
 		if !t.Empty() {
-			return nil
+			return nil, nil, _InvalidUntypedConversion
 		}
-		return Default(x.typ)
+		return Default(x.typ), nil, 0
 	case *Pointer, *Signature, *Slice, *Map, *Chan:
 		if !x.isNil() {
-			return nil
+			return nil, nil, _InvalidUntypedConversion
 		}
 		// Keep nil untyped - see comment for interfaces, above.
-		return Typ[UntypedNil]
+		return Typ[UntypedNil], nil, 0
 	default:
-		return nil
+		return nil, nil, _InvalidUntypedConversion
 	}
-	return target
+	return target, nil, 0
 }
 
 func (check *Checker) comparison(x, y *operand, op token.Token) {
diff --git a/src/go/types/operand.go b/src/go/types/operand.go
index 336babcadc..8f9c9d09bf 100644
--- a/src/go/types/operand.go
+++ b/src/go/types/operand.go
@@ -242,20 +242,15 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er
 
 	// x is an untyped value representable by a value of type T.
 	if isUntyped(Vu) {
-		// TODO(rFindley) synchronize this block of code with types2
-		switch t := Tu.(type) {
-		case *Basic:
-			if x.mode == constant_ {
-				return representableConst(x.val, check, t, nil), _IncompatibleAssign
-			}
-		case *Sum:
+		if t, ok := Tu.(*Sum); ok {
 			return t.is(func(t Type) bool {
 				// TODO(gri) this could probably be more efficient
 				ok, _ := x.assignableTo(check, t, reason)
 				return ok
 			}), _IncompatibleAssign
 		}
-		return check.implicitType(x, Tu) != nil, _IncompatibleAssign
+		newType, _, _ := check.implicitTypeAndValue(x, Tu)
+		return newType != nil, _IncompatibleAssign
 	}
 	// Vu is typed
 
diff --git a/src/go/types/predicates.go b/src/go/types/predicates.go
index 85e2b9a0ca..0233274967 100644
--- a/src/go/types/predicates.go
+++ b/src/go/types/predicates.go
@@ -74,12 +74,8 @@ func isUntyped(typ Type) bool {
 	return !isTyped(typ)
 }
 
-func isOrdered(typ Type) bool { return is(typ, IsOrdered) }
-
-func isConstType(typ Type) bool {
-	t := asBasic(typ)
-	return t != nil && t.info&IsConstType != 0
-}
+func isOrdered(typ Type) bool   { return is(typ, IsOrdered) }
+func isConstType(typ Type) bool { return is(typ, IsConstType) }
 
 // IsInterface reports whether typ is an interface type.
 func IsInterface(typ Type) bool {
-- 
GitLab


From fa01ade41e1632dbb8e1b06ff1e6565e8900fb38 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 12 Jan 2021 09:20:22 -0500
Subject: [PATCH 0525/2400] [dev.typeparams] go/types: add tests from dev.go2go

Add tests from the dev.go2go branch, modified to eliminate support for
parenthesized type embedding and method type parameters. For the most
part these tests were made to pass via the fixes from preceding CLs in
this stack.

While integrating support for type parameters with the changes to
go/types in master, a decision was made to temporarily use an error code
of 0 for new error messages. Now that these messages are actually
emitted during checking of test packages, it is a test failure for them
to have an error code of 0. To satisfy the test, create a new temporary
error code '_Todo', which represents an error code that has not yet been
assigned. _Todo is added only where it was necessary to make tests pass:
many error codes were left as 0, meaning we don't have any tests that
produce them. This marker may help us produce more comprehensive tests
in the future.

Finally, each package checked by testDir was made into a subtest, for
the ease of running individual packages while debugging test failures.
This seemed worth keeping.

Change-Id: Iba421b797e9fb11af664a73902f67d6c4f30ecad
Reviewed-on: https://go-review.googlesource.com/c/go/+/283854
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Trust: Robert Findley <rfindley@google.com>
---
 src/go/types/assignments.go           |   2 +-
 src/go/types/builtins.go              |   4 +-
 src/go/types/call.go                  |   8 +-
 src/go/types/check_test.go            |  44 +--
 src/go/types/decl.go                  |   2 +-
 src/go/types/errorcodes.go            |   4 +
 src/go/types/examples/functions.go2   | 214 ++++++++++++
 src/go/types/examples/methods.go2     |  96 ++++++
 src/go/types/examples/types.go2       | 266 +++++++++++++++
 src/go/types/fixedbugs/issue39634.go2 |  91 +++++
 src/go/types/fixedbugs/issue39664.go2 |  15 +
 src/go/types/fixedbugs/issue39680.go2 |  27 ++
 src/go/types/fixedbugs/issue39693.go2 |  14 +
 src/go/types/fixedbugs/issue39699.go2 |  29 ++
 src/go/types/fixedbugs/issue39711.go2 |  11 +
 src/go/types/fixedbugs/issue39723.go2 |   9 +
 src/go/types/fixedbugs/issue39725.go2 |  16 +
 src/go/types/fixedbugs/issue39754.go2 |  20 ++
 src/go/types/fixedbugs/issue39755.go2 |  23 ++
 src/go/types/fixedbugs/issue39768.go2 |  20 ++
 src/go/types/fixedbugs/issue39938.go2 |  50 +++
 src/go/types/fixedbugs/issue39948.go2 |   9 +
 src/go/types/fixedbugs/issue39976.go2 |  16 +
 src/go/types/fixedbugs/issue39982.go2 |  36 ++
 src/go/types/fixedbugs/issue40038.go2 |  15 +
 src/go/types/fixedbugs/issue40056.go2 |  15 +
 src/go/types/fixedbugs/issue40057.go2 |  17 +
 src/go/types/fixedbugs/issue40301.go2 |  12 +
 src/go/types/fixedbugs/issue40684.go2 |  15 +
 src/go/types/fixedbugs/issue41124.go2 |  91 +++++
 src/go/types/fixedbugs/issue42758.go2 |  33 ++
 src/go/types/infer.go                 |   4 +-
 src/go/types/resolver.go              |  11 +-
 src/go/types/subst.go                 |   9 +-
 src/go/types/testdata/builtins.go2    |  53 +++
 src/go/types/testdata/chans.go2       |  62 ++++
 src/go/types/testdata/issues.go2      | 255 ++++++++++++++
 src/go/types/testdata/linalg.go2      |  83 +++++
 src/go/types/testdata/map.go2         | 113 +++++++
 src/go/types/testdata/map2.go2        | 146 ++++++++
 src/go/types/testdata/slices.go2      |  68 ++++
 src/go/types/testdata/tinference.go2  | 108 ++++++
 src/go/types/testdata/tmp.go2         |  17 +
 src/go/types/testdata/todos.go2       |  22 ++
 src/go/types/testdata/typeinst.go2    |  59 ++++
 src/go/types/testdata/typeinst2.go2   | 256 ++++++++++++++
 src/go/types/testdata/typeparams.go2  | 458 ++++++++++++++++++++++++++
 src/go/types/typexpr.go               |  20 +-
 48 files changed, 2919 insertions(+), 49 deletions(-)
 create mode 100644 src/go/types/examples/functions.go2
 create mode 100644 src/go/types/examples/methods.go2
 create mode 100644 src/go/types/examples/types.go2
 create mode 100644 src/go/types/fixedbugs/issue39634.go2
 create mode 100644 src/go/types/fixedbugs/issue39664.go2
 create mode 100644 src/go/types/fixedbugs/issue39680.go2
 create mode 100644 src/go/types/fixedbugs/issue39693.go2
 create mode 100644 src/go/types/fixedbugs/issue39699.go2
 create mode 100644 src/go/types/fixedbugs/issue39711.go2
 create mode 100644 src/go/types/fixedbugs/issue39723.go2
 create mode 100644 src/go/types/fixedbugs/issue39725.go2
 create mode 100644 src/go/types/fixedbugs/issue39754.go2
 create mode 100644 src/go/types/fixedbugs/issue39755.go2
 create mode 100644 src/go/types/fixedbugs/issue39768.go2
 create mode 100644 src/go/types/fixedbugs/issue39938.go2
 create mode 100644 src/go/types/fixedbugs/issue39948.go2
 create mode 100644 src/go/types/fixedbugs/issue39976.go2
 create mode 100644 src/go/types/fixedbugs/issue39982.go2
 create mode 100644 src/go/types/fixedbugs/issue40038.go2
 create mode 100644 src/go/types/fixedbugs/issue40056.go2
 create mode 100644 src/go/types/fixedbugs/issue40057.go2
 create mode 100644 src/go/types/fixedbugs/issue40301.go2
 create mode 100644 src/go/types/fixedbugs/issue40684.go2
 create mode 100644 src/go/types/fixedbugs/issue41124.go2
 create mode 100644 src/go/types/fixedbugs/issue42758.go2
 create mode 100644 src/go/types/testdata/builtins.go2
 create mode 100644 src/go/types/testdata/chans.go2
 create mode 100644 src/go/types/testdata/issues.go2
 create mode 100644 src/go/types/testdata/linalg.go2
 create mode 100644 src/go/types/testdata/map.go2
 create mode 100644 src/go/types/testdata/map2.go2
 create mode 100644 src/go/types/testdata/slices.go2
 create mode 100644 src/go/types/testdata/tinference.go2
 create mode 100644 src/go/types/testdata/tmp.go2
 create mode 100644 src/go/types/testdata/todos.go2
 create mode 100644 src/go/types/testdata/typeinst.go2
 create mode 100644 src/go/types/testdata/typeinst2.go2
 create mode 100644 src/go/types/testdata/typeparams.go2

diff --git a/src/go/types/assignments.go b/src/go/types/assignments.go
index 025dcbf2c8..3aa06e8939 100644
--- a/src/go/types/assignments.go
+++ b/src/go/types/assignments.go
@@ -72,7 +72,7 @@ func (check *Checker) assignment(x *operand, T Type, context string) {
 
 	// A generic (non-instantiated) function value cannot be assigned to a variable.
 	if sig := asSignature(x.typ); sig != nil && len(sig.tparams) > 0 {
-		check.errorf(x, 0, "cannot use generic function %s without instantiation in %s", x, context)
+		check.errorf(x, _Todo, "cannot use generic function %s without instantiation in %s", x, context)
 	}
 
 	// spec: "If a left-hand side is the blank identifier, any typed or
diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go
index 17916c6b0c..28697d9087 100644
--- a/src/go/types/builtins.go
+++ b/src/go/types/builtins.go
@@ -589,7 +589,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 	case _Alignof:
 		// unsafe.Alignof(x T) uintptr
 		if asTypeParam(x.typ) != nil {
-			check.invalidOp(call, 0, "unsafe.Alignof undefined for %s", x)
+			check.invalidOp(call, _Todo, "unsafe.Alignof undefined for %s", x)
 			return
 		}
 		check.assignment(x, nil, "argument to unsafe.Alignof")
@@ -650,7 +650,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 	case _Sizeof:
 		// unsafe.Sizeof(x T) uintptr
 		if asTypeParam(x.typ) != nil {
-			check.invalidOp(call, 0, "unsafe.Sizeof undefined for %s", x)
+			check.invalidOp(call, _Todo, "unsafe.Sizeof undefined for %s", x)
 			return
 		}
 		check.assignment(x, nil, "argument to unsafe.Sizeof")
diff --git a/src/go/types/call.go b/src/go/types/call.go
index 97a9d0ea8f..d9a7b440ec 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -62,7 +62,7 @@ func (check *Checker) call(x *operand, call *ast.CallExpr, orig ast.Expr) exprKi
 				if t := asInterface(T); t != nil {
 					check.completeInterface(token.NoPos, t)
 					if t.IsConstraint() {
-						check.errorf(call, 0, "cannot use interface %s in conversion (contains type list or is comparable)", T)
+						check.errorf(call, _Todo, "cannot use interface %s in conversion (contains type list or is comparable)", T)
 						break
 					}
 				}
@@ -117,7 +117,7 @@ func (check *Checker) call(x *operand, call *ast.CallExpr, orig ast.Expr) exprKi
 
 			// check number of type arguments
 			if n > len(sig.tparams) {
-				check.errorf(args[n-1], 0, "got %d type arguments but want %d", n, len(sig.tparams))
+				check.errorf(args[n-1], _Todo, "got %d type arguments but want %d", n, len(sig.tparams))
 				x.mode = invalid
 				x.expr = orig
 				return expression
@@ -423,7 +423,7 @@ func (check *Checker) arguments(call *ast.CallExpr, sig *Signature, args []*oper
 				assert(targs[failed] == nil)
 				tpar := sig.tparams[failed]
 				ppos := check.fset.Position(tpar.pos).String()
-				check.errorf(inNode(call, call.Rparen), 0, "cannot infer %s (%s) (%s)", tpar.name, ppos, targs)
+				check.errorf(inNode(call, call.Rparen), _Todo, "cannot infer %s (%s) (%s)", tpar.name, ppos, targs)
 				return
 			}
 		}
@@ -821,7 +821,7 @@ func (check *Checker) useLHS(arg ...ast.Expr) {
 // instantiatedOperand reports an error of x is an uninstantiated (generic) type and sets x.typ to Typ[Invalid].
 func (check *Checker) instantiatedOperand(x *operand) {
 	if x.mode == typexpr && isGeneric(x.typ) {
-		check.errorf(x, 0, "cannot use generic type %s without instantiation", x.typ)
+		check.errorf(x, _Todo, "cannot use generic type %s without instantiation", x.typ)
 		x.typ = Typ[Invalid]
 	}
 }
diff --git a/src/go/types/check_test.go b/src/go/types/check_test.go
index 66943d676c..51eae052f3 100644
--- a/src/go/types/check_test.go
+++ b/src/go/types/check_test.go
@@ -68,11 +68,11 @@ func splitError(err error) (pos, msg string) {
 	return
 }
 
-func parseFiles(t *testing.T, filenames []string) ([]*ast.File, []error) {
+func parseFiles(t *testing.T, filenames []string, mode parser.Mode) ([]*ast.File, []error) {
 	var files []*ast.File
 	var errlist []error
 	for _, filename := range filenames {
-		file, err := parser.ParseFile(fset, filename, nil, parser.AllErrors)
+		file, err := parser.ParseFile(fset, filename, nil, mode)
 		if file == nil {
 			t.Fatalf("%s: %s", filename, err)
 		}
@@ -191,8 +191,17 @@ func eliminate(t *testing.T, errmap map[string][]string, errlist []error) {
 }
 
 func checkFiles(t *testing.T, sources []string) {
+	if len(sources) == 0 {
+		t.Fatal("no source files")
+	}
+
+	mode := parser.AllErrors
+	if strings.HasSuffix(sources[0], ".go2") {
+		mode |= parser.ParseTypeParams
+	}
+
 	// parse files and collect parser errors
-	files, errlist := parseFiles(t, sources)
+	files, errlist := parseFiles(t, sources, mode)
 
 	pkgName := "<no package>"
 	if len(files) > 0 {
@@ -208,7 +217,6 @@ func checkFiles(t *testing.T, sources []string) {
 
 	// typecheck and collect typechecker errors
 	var conf Config
-	// TODO(rFindley) parse generics when given a .go2 suffix.
 
 	// special case for importC.src
 	if len(sources) == 1 && strings.HasSuffix(sources[0], "importC.src") {
@@ -274,11 +282,8 @@ func TestCheck(t *testing.T) {
 	checkFiles(t, strings.Split(*testFiles, " "))
 }
 
-func TestTestdata(t *testing.T) { DefPredeclaredTestFuncs(); testDir(t, "testdata") }
-
-// TODO(rFindley) add go2 examples.
-// func TestExamples(t *testing.T)  { testDir(t, "examples") }
-
+func TestTestdata(t *testing.T)  { DefPredeclaredTestFuncs(); testDir(t, "testdata") }
+func TestExamples(t *testing.T)  { testDir(t, "examples") }
 func TestFixedbugs(t *testing.T) { testDir(t, "fixedbugs") }
 
 func testDir(t *testing.T, dir string) {
@@ -290,20 +295,18 @@ func testDir(t *testing.T, dir string) {
 		return
 	}
 
-	for count, fi := range fis {
+	for _, fi := range fis {
 		path := filepath.Join(dir, fi.Name())
 
 		// if fi is a directory, its files make up a single package
+		var files []string
 		if fi.IsDir() {
-			if testing.Verbose() {
-				fmt.Printf("%3d %s\n", count, path)
-			}
 			fis, err := ioutil.ReadDir(path)
 			if err != nil {
 				t.Error(err)
 				continue
 			}
-			files := make([]string, len(fis))
+			files = make([]string, len(fis))
 			for i, fi := range fis {
 				// if fi is a directory, checkFiles below will complain
 				files[i] = filepath.Join(path, fi.Name())
@@ -311,14 +314,11 @@ func testDir(t *testing.T, dir string) {
 					fmt.Printf("\t%s\n", files[i])
 				}
 			}
-			checkFiles(t, files)
-			continue
-		}
-
-		// otherwise, fi is a stand-alone file
-		if testing.Verbose() {
-			fmt.Printf("%3d %s\n", count, path)
+		} else {
+			files = []string{path}
 		}
-		checkFiles(t, []string{path})
+		t.Run(filepath.Base(path), func(t *testing.T) {
+			checkFiles(t, files)
+		})
 	}
 }
diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index e62edfadb2..bd2c546661 100644
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -740,7 +740,7 @@ func (check *Checker) collectTypeParams(list *ast.FieldList) (tparams []*TypeNam
 				setBoundAt(index+i, bound)
 			}
 		} else if bound != Typ[Invalid] {
-			check.errorf(f.Type, 0, "%s is not an interface", bound)
+			check.errorf(f.Type, _Todo, "%s is not an interface", bound)
 		}
 
 	next:
diff --git a/src/go/types/errorcodes.go b/src/go/types/errorcodes.go
index 2c5a291660..7e62091558 100644
--- a/src/go/types/errorcodes.go
+++ b/src/go/types/errorcodes.go
@@ -1311,4 +1311,8 @@ const (
 	//  	return i
 	//  }
 	_InvalidGo
+
+	// _Todo is a placeholder for error codes that have not been decided.
+	// TODO(rFindley) remove this error code after deciding on errors for generics code.
+	_Todo
 )
diff --git a/src/go/types/examples/functions.go2 b/src/go/types/examples/functions.go2
new file mode 100644
index 0000000000..c6ad511bd6
--- /dev/null
+++ b/src/go/types/examples/functions.go2
@@ -0,0 +1,214 @@
+// Copyright 2019 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.
+
+// This file shows some examples of type-parameterized functions.
+
+package p
+
+// Reverse is a generic function that takes a []T argument and
+// reverses that slice in place.
+func Reverse[T any](list []T) {
+	i := 0
+	j := len(list)-1
+	for i < j {
+		list[i], list[j] = list[j], list[i]
+		i++
+		j--
+	}
+}
+
+func _() {
+	// Reverse can be called with an explicit type argument.
+	Reverse[int](nil)
+	Reverse[string]([]string{"foo", "bar"})
+	Reverse[struct{x, y int}]([]struct{x, y int}{{1, 2}, {2, 3}, {3, 4}})
+
+	// Since the type parameter is used for an incoming argument,
+	// it can be inferred from the provided argument's type.
+	Reverse([]string{"foo", "bar"})
+	Reverse([]struct{x, y int}{{1, 2}, {2, 3}, {3, 4}})
+
+	// But the incoming argument must have a type, even if it's a
+	// default type. An untyped nil won't work.
+	// Reverse(nil) // this won't type-check
+
+	// A typed nil will work, though.
+	Reverse([]int(nil))
+}
+
+// Certain functions, such as the built-in `new` could be written using
+// type parameters.
+func new[T any]() *T {
+	var x T
+	return &x
+}
+
+// When calling our own `new`, we need to pass the type parameter
+// explicitly since there is no (value) argument from which the
+// result type could be inferred. We don't try to infer the
+// result type from the assignment to keep things simple and
+// easy to understand.
+var _ = new[int]()
+var _ *float64 = new(float64)() // the result type is indeed *float64
+
+// A function may have multiple type parameters, of course.
+func foo[A, B, C any](a A, b []B, c *C) B {
+	// do something here
+	return b[0]
+}
+
+// As before, we can pass type parameters explicitly.
+var s = foo[int, string, float64](1, []string{"first"}, new(float64)())
+
+// Or we can use type inference.
+var _ float64 = foo(42, []float64{1.0}, &s)
+
+// Type inference works in a straight-forward manner even
+// for variadic functions.
+func variadic[A, B any](A, B, ...B) int
+
+// var _ = variadic(1) // ERROR not enough arguments
+var _ = variadic(1, 2.3)
+var _ = variadic(1, 2.3, 3.4, 4.5)
+var _ = variadic[int, float64](1, 2.3, 3.4, 4)
+
+// Type inference also works in recursive function calls where
+// the inferred type is the type parameter of the caller.
+func f1[T any](x T) {
+	f1(x)
+}
+
+func f2a[T any](x, y T) {
+	f2a(x, y)
+}
+
+func f2b[T any](x, y T) {
+	f2b(y, x)
+}
+
+func g2a[P, Q any](x P, y Q) {
+	g2a(x, y)
+}
+
+func g2b[P, Q any](x P, y Q) {
+	g2b(y, x)
+}
+
+// Here's an example of a recursive function call with variadic
+// arguments and type inference inferring the type parameter of
+// the caller (i.e., itself).
+func max[T interface{ type int }](x ...T) T {
+	var x0 T
+	if len(x) > 0 {
+		x0 = x[0]
+	}
+	if len(x) > 1 {
+		x1 := max(x[1:]...)
+		if x1 > x0 {
+			return x1
+		}
+	}
+	return x0
+}
+
+// When inferring channel types, the channel direction is ignored
+// for the purpose of type inference. Once the type has been in-
+// fered, the usual parameter passing rules are applied.
+// Thus even if a type can be inferred successfully, the function
+// call may not be valid.
+
+func fboth[T any](chan T)
+func frecv[T any](<-chan T)
+func fsend[T any](chan<- T)
+
+func _() {
+	var both chan int
+	var recv <-chan int
+	var send chan<-int
+
+	fboth(both)
+	fboth(recv /* ERROR cannot use */ )
+	fboth(send /* ERROR cannot use */ )
+
+	frecv(both)
+	frecv(recv)
+	frecv(send /* ERROR cannot use */ )
+
+	fsend(both)
+	fsend(recv /* ERROR cannot use */)
+	fsend(send)
+}
+
+func ffboth[T any](func(chan T))
+func ffrecv[T any](func(<-chan T))
+func ffsend[T any](func(chan<- T))
+
+func _() {
+	var both func(chan int)
+	var recv func(<-chan int)
+	var send func(chan<- int)
+
+	ffboth(both)
+	ffboth(recv /* ERROR cannot use */ )
+	ffboth(send /* ERROR cannot use */ )
+
+	ffrecv(both /* ERROR cannot use */ )
+	ffrecv(recv)
+	ffrecv(send /* ERROR cannot use */ )
+
+	ffsend(both /* ERROR cannot use */ )
+	ffsend(recv /* ERROR cannot use */ )
+	ffsend(send)
+}
+
+// When inferring elements of unnamed composite parameter types,
+// if the arguments are defined types, use their underlying types.
+// Even though the matching types are not exactly structurally the
+// same (one is a type literal, the other a named type), because
+// assignment is permitted, parameter passing is permitted as well,
+// so type inference should be able to handle these cases well.
+
+func g1[T any]([]T)
+func g2[T any]([]T, T)
+func g3[T any](*T, ...T)
+
+func _() {
+	type intSlize []int
+	g1([]int{})
+	g1(intSlize{})
+	g2(nil, 0)
+
+	type myString string
+	var s1 string
+	g3(nil, "1", myString("2"), "3")
+	g3(&s1, "1", myString /* ERROR does not match */ ("2"), "3")
+
+	type myStruct struct{x int}
+	var s2 myStruct
+	g3(nil, struct{x int}{}, myStruct{})
+	g3(&s2, struct{x int}{}, myStruct{})
+	g3(nil, myStruct{}, struct{x int}{})
+	g3(&s2, myStruct{}, struct{x int}{})
+}
+
+// Here's a realistic example.
+
+func append[T any](s []T, t ...T) []T
+
+func _() {
+	var f func()
+	type Funcs []func()
+	var funcs Funcs
+	_ = append(funcs, f)
+}
+
+// Generic type declarations cannot have empty type parameter lists
+// (that would indicate a slice type). Thus, generic functions cannot
+// have empty type parameter lists, either. This is a syntax error.
+
+func h[] /* ERROR empty type parameter list */ ()
+
+func _() {
+	h[] /* ERROR operand */ ()
+}
diff --git a/src/go/types/examples/methods.go2 b/src/go/types/examples/methods.go2
new file mode 100644
index 0000000000..c294627837
--- /dev/null
+++ b/src/go/types/examples/methods.go2
@@ -0,0 +1,96 @@
+// Copyright 2019 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.
+
+// This file shows some examples of methods on type-parameterized types.
+
+package p
+
+// Parameterized types may have methods.
+type T1[A any] struct{ a A }
+
+// When declaring a method for a parameterized type, the "instantiated"
+// receiver type acts as an implicit declaration of the type parameters
+// for the receiver type. In the example below, method m1 on type T1 has
+// the receiver type T1[A] which declares the type parameter A for use
+// with this method. That is, within the method m1, A stands for the
+// actual type argument provided to an instantiated T1.
+func (t T1[A]) m1() A { return t.a }
+
+// For instance, if T1 is instantiated with the type int, the type
+// parameter A in m1 assumes that type (int) as well and we can write
+// code like this:
+var x T1[int]
+var _ int = x.m1()
+
+// Because the type parameter provided to a parameterized receiver type
+// is declared through that receiver declaration, it must be an identifier.
+// It cannot possibly be some other type because the receiver type is not
+// instantiated with concrete types, it is standing for the parameterized
+// receiver type.
+func (t T1[[ /* ERROR must be an identifier */ ]int]) m2() {}
+
+// Note that using what looks like a predeclared identifier, say int,
+// as type parameter in this situation is deceptive and considered bad
+// style. In m3 below, int is the name of the local receiver type parameter
+// and it shadows the predeclared identifier int which then cannot be used
+// anymore as expected.
+// This is no different from locally redelaring a predeclared identifier
+// and usually should be avoided. There are some notable exceptions; e.g.,
+// sometimes it makes sense to use the identifier "copy" which happens to
+// also be the name of a predeclared built-in function.
+func (t T1[int]) m3() { var _ int = 42 /* ERROR cannot use 42 .* as int */ }
+
+// The names of the type parameters used in a parameterized receiver
+// type don't have to match the type parameter names in the the declaration
+// of the type used for the receiver. In our example, even though T1 is
+// declared with type parameter named A, methods using that receiver type
+// are free to use their own name for that type parameter. That is, the
+// name of type parameters is always local to the declaration where they
+// are introduced. In our example we can write a method m2 and use the
+// name X instead of A for the type parameter w/o any difference.
+func (t T1[X]) m4() X { return t.a }
+
+// If the receiver type is parameterized, type parameters must always be
+// provided: this simply follows from the general rule that a parameterized
+// type must be instantiated before it can be used. A method receiver
+// declaration using a parameterized receiver type is no exception. It is
+// simply that such receiver type expressions perform two tasks simultaneously:
+// they declare the (local) type parameters and then use them to instantiate
+// the receiver type. Forgetting to provide a type parameter leads to an error.
+func (t T1 /* ERROR generic type .* without instantiation */ ) m5() {}
+
+// However, sometimes we don't need the type parameter, and thus it is
+// inconvenient to have to choose a name. Since the receiver type expression
+// serves as a declaration for its type parameters, we are free to choose the
+// blank identifier:
+func (t T1[_]) m6() {}
+
+// Naturally, these rules apply to any number of type parameters on the receiver
+// type. Here are some more complex examples.
+type T2[A, B, C any] struct {
+        a A
+        b B
+        c C
+}
+
+// Naming of the type parameters is local and has no semantic impact:
+func (t T2[A, B, C]) m1() (A, B, C) { return t.a, t.b, t.c }
+func (t T2[C, B, A]) m2() (C, B, A) { return t.a, t.b, t.c }
+func (t T2[X, Y, Z]) m3() (X, Y, Z) { return t.a, t.b, t.c }
+
+// Type parameters may be left blank if they are not needed:
+func (t T2[A, _, C]) m4() (A, C) { return t.a, t.c }
+func (t T2[_, _, X]) m5() X { return t.c }
+func (t T2[_, _, _]) m6() {}
+
+// As usual, blank names may be used for any object which we don't care about
+// using later. For instance, we may write an unnamed method with a receiver
+// that cannot be accessed:
+func (_ T2[_, _, _]) _() int { return 42 }
+
+// Because a receiver parameter list is simply a parameter list, we can
+// leave the receiver argument away for receiver types.
+type T0 struct{}
+func (T0) _() {}
+func (T1[A]) _() {}
diff --git a/src/go/types/examples/types.go2 b/src/go/types/examples/types.go2
new file mode 100644
index 0000000000..5aa624c131
--- /dev/null
+++ b/src/go/types/examples/types.go2
@@ -0,0 +1,266 @@
+// Copyright 2019 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.
+
+// This file shows some examples of generic types.
+
+package p
+
+// List is just what it says - a slice of E elements.
+type List[E any] []E
+
+// A generic (parameterized) type must always be instantiated
+// before it can be used to designate the type of a variable
+// (including a struct field, or function parameter); though
+// for the latter cases, the provided type may be another type
+// parameter. So:
+var _ List[byte] = []byte{}
+
+// A generic binary tree might be declared as follows.
+type Tree[E any] struct {
+	left, right *Tree[E]
+	payload E
+}
+
+// A simple instantiation of Tree:
+var root1 Tree[int]
+
+// The actual type parameter provided may be a generic type itself:
+var root2 Tree[List[int]]
+
+// A couple of more complex examples.
+// We don't need extra parentheses around the element type of the slices on
+// the right (unlike when we use ()'s rather than []'s for type parameters).
+var _ List[List[int]] = []List[int]{}
+var _ List[List[List[Tree[int]]]] = []List[List[Tree[int]]]{}
+
+// Type parameters act like type aliases when used in generic types
+// in the sense that we can "emulate" a specific type instantiation
+// with type aliases.
+type T1[P any] struct {
+	f P
+}
+
+type T2[P any] struct {
+	f struct {
+		g P
+	}
+}
+
+var x1 T1[struct{ g int }]
+var x2 T2[int]
+
+func _() {
+	// This assignment is invalid because the types of x1, x2 are T1(...)
+	// and T2(...) respectively, which are two different defined types.
+	x1 = x2 // ERROR assignment
+
+	// This assignment is valid because the types of x1.f and x2.f are
+	// both struct { g int }; the type parameters act like type aliases
+	// and their actual names don't come into play here.
+	x1.f = x2.f
+}
+
+// We can verify this behavior using type aliases instead:
+type T1a struct {
+	f A1
+}
+type A1 = struct { g int }
+
+type T2a struct {
+	f struct {
+		g A2
+	}
+}
+type A2 = int
+
+var x1a T1a
+var x2a T2a
+
+func _() {
+	x1a = x2a // ERROR assignment
+	x1a.f = x2a.f
+}
+
+// Another interesting corner case are generic types that don't use
+// their type arguments. For instance:
+type T[P any] struct{}
+
+var xint T[int]
+var xbool T[bool]
+
+// Are these two variables of the same type? After all, their underlying
+// types are identical. We consider them to be different because each type
+// instantiation creates a new named type, in this case T<int> and T<bool>
+// even if their underlying types are identical. This is sensible because
+// we might still have methods that have different signatures or behave
+// differently depending on the type arguments, and thus we can't possibly
+// consider such types identical. Consequently:
+func _() {
+	xint = xbool // ERROR assignment
+}
+
+// Generic types cannot be used without instantiation.
+var _ T // ERROR cannot use generic type T
+
+// In type context, generic (parameterized) types cannot be parenthesized before
+// being instantiated. See also NOTES entry from 12/4/2019.
+var _ (T /* ERROR cannot use generic type T */ )[ /* ERROR expected ';' */ int]
+
+// All types may be parameterized, including interfaces.
+type I1[T any] interface{
+	m1(T)
+}
+
+// Generic interfaces may be embedded as one would expect.
+type I2 interface {
+	I1(int)     // method!
+	I1[string]  // embedded I1
+}
+
+func _() {
+	var x I2
+	x.I1(0)
+	x.m1("foo")
+}
+
+type I0 interface {
+	m0()
+}
+
+type I3 interface {
+	I0
+	I1[bool]
+	m(string)
+}
+
+func _() {
+	var x I3
+	x.m0()
+	x.m1(true)
+	x.m("foo")
+}
+
+// We accept parenthesized embedded struct fields so we can distinguish between
+// a named field with a parenthesized type foo (T) and an embedded parameterized
+// type (foo(T)), similarly to interace embedding.
+// They still need to be valid embedded types after the parentheses are stripped
+// (i.e., in contrast to interfaces, we cannot embed a struct literal). The name
+// of the embedded field is derived as before, after stripping parentheses.
+// (7/14/2020: See comment above. We probably will revert this generalized ability
+// if we go with [] for type parameters.)
+type _ struct {
+	int8
+	*int16
+	*List[int]
+
+	int8 /* ERROR int8 redeclared */
+	* /* ERROR List redeclared */ List[int]
+}
+
+// It's possible to declare local types whose underlying types
+// are type parameters. As with ordinary type definitions, the
+// types underlying properties are "inherited" but the methods
+// are not.
+func _[T interface{ m(); type int }]() {
+	type L T
+	var x L
+
+	// m is not defined on L (it is not "inherited" from
+	// its underlying type).
+	x.m /* ERROR x.m undefined */ ()
+
+	// But the properties of T, such that as that it supports
+	// the operations of the types given by its type bound,
+	// are also the properties of L.
+	x++
+	_ = x - x
+
+	// On the other hand, if we define a local alias for T,
+	// that alias stands for T as expected.
+	type A = T
+	var y A
+	y.m()
+	_ = y < 0
+}
+
+// As a special case, an explicit type argument may be omitted
+// from a type parameter bound if the type bound expects exactly
+// one type argument. In that case, the type argument is the
+// respective type parameter to which the type bound applies.
+// Note: We may not permit this syntactic sugar at first.
+// Note: This is now disabled. All examples below are adjusted.
+type Adder[T any] interface {
+	Add(T) T
+}
+
+// We don't need to explicitly instantiate the Adder bound
+// if we have exactly one type parameter.
+func Sum[T Adder[T]](list []T) T {
+	var sum T
+	for _, x := range list {
+		sum = sum.Add(x)
+	}
+	return sum
+}
+
+// Valid and invalid variations.
+type B0 interface {}
+type B1[_ any] interface{}
+type B2[_, _ any] interface{}
+
+func _[T1 B0]()
+func _[T1 B1[T1]]()
+func _[T1 B2 /* ERROR cannot use generic type .* without instantiation */ ]()
+
+func _[T1, T2 B0]()
+func _[T1 B1[T1], T2 B1[T2]]()
+func _[T1, T2 B2 /* ERROR cannot use generic type .* without instantiation */ ]()
+
+func _[T1 B0, T2 B1[T2]]() // here B1 applies to T2
+
+// When the type argument is left away, the type bound is
+// instantiated for each type parameter with that type
+// parameter.
+// Note: We may not permit this syntactic sugar at first.
+func _[A Adder[A], B Adder[B], C Adder[A]]() {
+	var a A // A's type bound is Adder[A]
+	a = a.Add(a)
+	var b B // B's type bound is Adder[B]
+	b = b.Add(b)
+	var c C // C's type bound is Adder[A]
+	a = c.Add(a)
+}
+
+// The type of variables (incl. parameters and return values) cannot
+// be an interface with type constraints or be/embed comparable.
+type I interface {
+	type int
+}
+
+var (
+	_ interface /* ERROR contains type constraints */ {type int}
+	_ I /* ERROR contains type constraints */
+)
+
+func _(I /* ERROR contains type constraints */ )
+func _(x, y, z I /* ERROR contains type constraints */ )
+func _() I /* ERROR contains type constraints */
+
+func _() {
+	var _ I /* ERROR contains type constraints */
+}
+
+type C interface {
+	comparable
+}
+
+var _ comparable /* ERROR comparable */
+var _ C /* ERROR comparable */
+
+func _(_ comparable /* ERROR comparable */ , _ C /* ERROR comparable */ )
+
+func _() {
+	var _ comparable /* ERROR comparable */
+	var _ C /* ERROR comparable */
+}
diff --git a/src/go/types/fixedbugs/issue39634.go2 b/src/go/types/fixedbugs/issue39634.go2
new file mode 100644
index 0000000000..249542d541
--- /dev/null
+++ b/src/go/types/fixedbugs/issue39634.go2
@@ -0,0 +1,91 @@
+// Copyright 2020 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.
+
+// Examples adjusted to match new [T any] syntax for type parameters.
+// Also, previously permitted empty type parameter lists and instantiations
+// are now syntax errors.
+
+package p
+
+// crash 1
+type nt1[_ any]interface{g /* ERROR undeclared name */ }
+type ph1[e nt1[e],g(d /* ERROR undeclared name */ )]s /* ERROR undeclared name */
+func(*ph1[e,e /* ERROR redeclared */ ])h(d /* ERROR undeclared name */ )
+
+// crash 2
+// Disabled: empty []'s are now syntax errors. This example leads to too many follow-on errors.
+// type Numeric2 interface{t2 /* ERROR not a type */ }
+// func t2[T Numeric2](s[]T){0 /* ERROR not a type */ []{s /* ERROR cannot index */ [0][0]}}
+
+// crash 3
+type t3 *interface{ t3.p /* ERROR no field or method p */ }
+
+// crash 4
+type Numeric4 interface{t4 /* ERROR not a type */ }
+func t4[T Numeric4](s[]T){if( /* ERROR non-boolean */ 0){*s /* ERROR cannot indirect */ [0]}}
+
+// crash 7
+type foo7 interface { bar() }
+type x7[A any] struct{ foo7 }
+func main7() { var _ foo7 = x7[int]{} }
+
+// crash 8
+type foo8[A any] interface { type A }
+func bar8[A foo8[A]](a A) {}
+func main8() {}
+
+// crash 9
+type foo9[A any] interface { type foo9 /* ERROR interface contains type constraints */ [A] }
+func _() { var _ = new(foo9 /* ERROR interface contains type constraints */ [int]) }
+
+// crash 12
+var u /* ERROR cycle */ , i [func /* ERROR used as value */ /* ERROR used as value */ (u, c /* ERROR undeclared */ /* ERROR undeclared */ ) {}(0, len)]c /* ERROR undeclared */ /* ERROR undeclared */
+
+// crash 15
+func y15() { var a /* ERROR declared but not used */ interface{ p() } = G15[string]{} }
+type G15[X any] s /* ERROR undeclared name */
+func (G15 /* ERROR generic type .* without instantiation */ ) p()
+
+// crash 16
+type Foo16[T any] r16 /* ERROR not a type */
+func r16[T any]() Foo16[Foo16[T]]
+
+// crash 17
+type Y17 interface{ c() }
+type Z17 interface {
+	c() Y17
+	Y17 /* ERROR duplicate method */
+}
+func F17[T Z17](T)
+
+// crash 18
+type o18[T any] []func(_ o18[[]_ /* ERROR cannot use _ */ ])
+
+// crash 19
+type Z19 [][[]Z19{}[0][0]]c19 /* ERROR undeclared */
+
+// crash 20
+type Z20 /* ERROR illegal cycle */ interface{ Z20 }
+func F20[t Z20]() { F20(t /* ERROR invalid composite literal type */ {}) }
+
+// crash 21
+type Z21 /* ERROR illegal cycle */ interface{ Z21 }
+func F21[T Z21]() { ( /* ERROR not used */ F21[Z21]) }
+
+// crash 24
+type T24[P any] P
+func (r T24[P]) m() { T24 /* ERROR without instantiation */ .m() }
+
+// crash 25
+type T25[A any] int
+func (t T25[A]) m1() {}
+var x T25 /* ERROR without instantiation */ .m1
+
+// crash 26
+type T26 = interface{ F26[ /* ERROR methods cannot have type parameters */ Z any]() }
+func F26[Z any]() T26 { return F26 /* ERROR without instantiation */ /* ERROR missing method */ [] /* ERROR operand */ }
+
+// crash 27
+func e27[T any]() interface{ x27 /* ERROR not a type */ }
+func x27() { e27() /* ERROR cannot infer T */ }
diff --git a/src/go/types/fixedbugs/issue39664.go2 b/src/go/types/fixedbugs/issue39664.go2
new file mode 100644
index 0000000000..3b3ec56980
--- /dev/null
+++ b/src/go/types/fixedbugs/issue39664.go2
@@ -0,0 +1,15 @@
+// Copyright 2020 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 p
+
+type T[_ any] struct {}
+
+func (T /* ERROR instantiation */ ) m()
+
+func _() {
+	var x interface { m() }
+	x = T[int]{}
+	_ = x
+}
diff --git a/src/go/types/fixedbugs/issue39680.go2 b/src/go/types/fixedbugs/issue39680.go2
new file mode 100644
index 0000000000..9bc26f3546
--- /dev/null
+++ b/src/go/types/fixedbugs/issue39680.go2
@@ -0,0 +1,27 @@
+// Copyright 2020 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 p
+
+import "fmt"
+
+// Minimal test case.
+func _[T interface{type T}](x T) T{
+	return x
+}
+
+// Test case from issue.
+type constr[T any] interface {
+	type T
+}
+
+func Print[T constr[T]](s []T) {
+	for _, v := range s {
+		fmt.Print(v)
+	}
+}
+
+func f() {
+	Print([]string{"Hello, ", "playground\n"})
+}
diff --git a/src/go/types/fixedbugs/issue39693.go2 b/src/go/types/fixedbugs/issue39693.go2
new file mode 100644
index 0000000000..316ab1982e
--- /dev/null
+++ b/src/go/types/fixedbugs/issue39693.go2
@@ -0,0 +1,14 @@
+// Copyright 2020 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 p
+
+type Number interface {
+	int     /* ERROR int is not an interface */
+	float64 /* ERROR float64 is not an interface */
+}
+
+func Add[T Number](a, b T) T {
+	return a /* ERROR not defined */ + b
+}
diff --git a/src/go/types/fixedbugs/issue39699.go2 b/src/go/types/fixedbugs/issue39699.go2
new file mode 100644
index 0000000000..75491e7e26
--- /dev/null
+++ b/src/go/types/fixedbugs/issue39699.go2
@@ -0,0 +1,29 @@
+// Copyright 2020 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 p
+
+type T0 interface{
+}
+
+type T1 interface{
+	type int
+}
+
+type T2 interface{
+	comparable
+}
+
+type T3 interface {
+	T0
+	T1
+	T2
+}
+
+func _() {
+	_ = T0(0)
+	_ = T1 /* ERROR cannot use interface T1 in conversion */ (1)
+	_ = T2 /* ERROR cannot use interface T2 in conversion */ (2)
+	_ = T3 /* ERROR cannot use interface T3 in conversion */ (3)
+}
diff --git a/src/go/types/fixedbugs/issue39711.go2 b/src/go/types/fixedbugs/issue39711.go2
new file mode 100644
index 0000000000..df621a4c17
--- /dev/null
+++ b/src/go/types/fixedbugs/issue39711.go2
@@ -0,0 +1,11 @@
+// Copyright 2020 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 p
+
+// Do not report a duplicate type error for this type list.
+// (Check types after interfaces have been completed.)
+type _ interface {
+	type interface{ Error() string }, interface{ String() string }
+}
diff --git a/src/go/types/fixedbugs/issue39723.go2 b/src/go/types/fixedbugs/issue39723.go2
new file mode 100644
index 0000000000..55464e6b77
--- /dev/null
+++ b/src/go/types/fixedbugs/issue39723.go2
@@ -0,0 +1,9 @@
+// Copyright 2020 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 p
+
+// A constraint must be an interface; it cannot
+// be a type parameter, for instance.
+func _[A interface{ type interface{} }, B A /* ERROR not an interface */ ]()
diff --git a/src/go/types/fixedbugs/issue39725.go2 b/src/go/types/fixedbugs/issue39725.go2
new file mode 100644
index 0000000000..e19b6770bf
--- /dev/null
+++ b/src/go/types/fixedbugs/issue39725.go2
@@ -0,0 +1,16 @@
+// Copyright 2020 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 p
+
+func f1[T1, T2 any](T1, T2, struct{a T1; b T2})
+func _() {
+	f1(42, string("foo"), struct /* ERROR does not match inferred type struct\{a int; b string\} */ {a, b int}{})
+}
+
+// simplified test case from issue
+func f2[T any](_ []T, _ func(T))
+func _() {
+	f2([]string{}, func /* ERROR does not match inferred type func\(string\) */ (f []byte) {})
+}
diff --git a/src/go/types/fixedbugs/issue39754.go2 b/src/go/types/fixedbugs/issue39754.go2
new file mode 100644
index 0000000000..2ed84dc8ab
--- /dev/null
+++ b/src/go/types/fixedbugs/issue39754.go2
@@ -0,0 +1,20 @@
+// Copyright 2020 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 p
+
+type Optional[T any] struct {}
+
+func (_ Optional[T]) Val() (T, bool)
+
+type Box[T any] interface {
+	Val() (T, bool)
+}
+
+func f[V interface{}, A, B Box[V]]() {}
+
+func _() {
+	f[int, Optional[int], Optional[int]]()
+	// f[int, Optional[int], Optional /* ERROR does not satisfy Box */ [string]]()
+}
diff --git a/src/go/types/fixedbugs/issue39755.go2 b/src/go/types/fixedbugs/issue39755.go2
new file mode 100644
index 0000000000..b7ab68818e
--- /dev/null
+++ b/src/go/types/fixedbugs/issue39755.go2
@@ -0,0 +1,23 @@
+// Copyright 2020 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 p
+
+func _[T interface{type map[string]int}](x T) {
+	_ = x == nil
+}
+
+// simplified test case from issue
+
+type PathParamsConstraint interface {
+        type map[string]string, []struct{key, value string}
+}
+
+type PathParams[T PathParamsConstraint] struct {
+	t T
+}
+
+func (pp *PathParams[T]) IsNil() bool {
+	return pp.t == nil // this must succeed
+}
diff --git a/src/go/types/fixedbugs/issue39768.go2 b/src/go/types/fixedbugs/issue39768.go2
new file mode 100644
index 0000000000..abac141d7f
--- /dev/null
+++ b/src/go/types/fixedbugs/issue39768.go2
@@ -0,0 +1,20 @@
+// Copyright 2020 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 p
+
+type T[P any] P
+type A = T
+var x A[int]
+var _ A /* ERROR cannot use generic type */
+
+type B = T[int]
+var y B = x
+var _ B /* ERROR not a generic type */ [int]
+
+// test case from issue
+
+type Vector[T any] []T
+type VectorAlias = Vector
+var v Vector[int]
diff --git a/src/go/types/fixedbugs/issue39938.go2 b/src/go/types/fixedbugs/issue39938.go2
new file mode 100644
index 0000000000..76e7e369ca
--- /dev/null
+++ b/src/go/types/fixedbugs/issue39938.go2
@@ -0,0 +1,50 @@
+// Copyright 2020 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.
+
+// Check "infinite expansion" cycle errors across instantiated types.
+
+package p
+
+type E0[P any] P
+type E1[P any] *P
+type E2[P any] struct{ P }
+type E3[P any] struct{ *P }
+
+type T0 /* ERROR illegal cycle */ struct {
+        _ E0[T0]
+}
+
+type T0_ /* ERROR illegal cycle */ struct {
+        E0[T0_]
+}
+
+type T1 struct {
+        _ E1[T1]
+}
+
+type T2 /* ERROR illegal cycle */ struct {
+        _ E2[T2]
+}
+
+type T3 struct {
+        _ E3[T3]
+}
+
+// some more complex cases
+
+type T4 /* ERROR illegal cycle */ struct {
+	_ E0[E2[T4]]
+}
+
+type T5 struct {
+	_ E0[E2[E0[E1[E2[[10]T5]]]]]
+}
+
+type T6 /* ERROR illegal cycle */ struct {
+	_ E0[[10]E2[E0[E2[E2[T6]]]]]
+}
+
+type T7 struct {
+	_ E0[[]E2[E0[E2[E2[T6]]]]]
+}
diff --git a/src/go/types/fixedbugs/issue39948.go2 b/src/go/types/fixedbugs/issue39948.go2
new file mode 100644
index 0000000000..c2b460902c
--- /dev/null
+++ b/src/go/types/fixedbugs/issue39948.go2
@@ -0,0 +1,9 @@
+// Copyright 2020 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 p
+
+type T[P any] interface{
+	P // ERROR P is a type parameter, not an interface
+}
diff --git a/src/go/types/fixedbugs/issue39976.go2 b/src/go/types/fixedbugs/issue39976.go2
new file mode 100644
index 0000000000..3db4eae012
--- /dev/null
+++ b/src/go/types/fixedbugs/issue39976.go2
@@ -0,0 +1,16 @@
+// Copyright 2020 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 p
+
+type policy[K, V any] interface{}
+type LRU[K, V any] struct{}
+
+func NewCache[K, V any](p policy[K, V])
+
+func _() {
+	var lru LRU[int, string]
+	NewCache[int, string](&lru)
+	NewCache(& /* ERROR does not match policy\[K, V\] \(cannot infer K and V\) */ lru)
+}
diff --git a/src/go/types/fixedbugs/issue39982.go2 b/src/go/types/fixedbugs/issue39982.go2
new file mode 100644
index 0000000000..9810b6386a
--- /dev/null
+++ b/src/go/types/fixedbugs/issue39982.go2
@@ -0,0 +1,36 @@
+// Copyright 2020 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 p
+
+type (
+	T[_ any] struct{}
+	S[_ any] struct {
+		data T[*T[int]]
+	}
+)
+
+func _() {
+	_ = S[int]{
+		data: T[*T[int]]{},
+	}
+}
+
+// full test case from issue
+
+type (
+	Element[TElem any] struct{}
+
+	entry[K comparable] struct{}
+
+	Cache[K comparable] struct {
+		data map[K]*Element[*entry[K]]
+	}
+)
+
+func _() {
+	_ = Cache[int]{
+		data: make(map[int](*Element[*entry[int]])),
+	}
+}
diff --git a/src/go/types/fixedbugs/issue40038.go2 b/src/go/types/fixedbugs/issue40038.go2
new file mode 100644
index 0000000000..8948d61caa
--- /dev/null
+++ b/src/go/types/fixedbugs/issue40038.go2
@@ -0,0 +1,15 @@
+// Copyright 2020 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 p
+
+type A[T any] int
+
+func (A[T]) m(A[T])
+
+func f[P interface{m(P)}]()
+
+func _() {
+	_ = f[A[int]]
+}
\ No newline at end of file
diff --git a/src/go/types/fixedbugs/issue40056.go2 b/src/go/types/fixedbugs/issue40056.go2
new file mode 100644
index 0000000000..71074be67e
--- /dev/null
+++ b/src/go/types/fixedbugs/issue40056.go2
@@ -0,0 +1,15 @@
+// Copyright 2020 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 p
+
+func _() {
+	NewS() /* ERROR cannot infer T */ .M()
+}
+
+type S struct {}
+
+func NewS[T any]() *S
+
+func (_ *S /* ERROR S is not a generic type */ [T]) M()
\ No newline at end of file
diff --git a/src/go/types/fixedbugs/issue40057.go2 b/src/go/types/fixedbugs/issue40057.go2
new file mode 100644
index 0000000000..fdc8fb1c00
--- /dev/null
+++ b/src/go/types/fixedbugs/issue40057.go2
@@ -0,0 +1,17 @@
+// Copyright 2020 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 p
+
+func _() {
+	var x interface{}
+	switch t := x.(type) {
+	case S /* ERROR cannot use generic type */ :
+		t.m()
+	}
+}
+
+type S[T any] struct {}
+
+func (_ S[T]) m()
diff --git a/src/go/types/fixedbugs/issue40301.go2 b/src/go/types/fixedbugs/issue40301.go2
new file mode 100644
index 0000000000..5d97855f8a
--- /dev/null
+++ b/src/go/types/fixedbugs/issue40301.go2
@@ -0,0 +1,12 @@
+// Copyright 2020 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 p
+
+import "unsafe"
+
+func _[T any](x T) {
+	_ = unsafe /* ERROR undefined */ .Alignof(x)
+	_ = unsafe /* ERROR undefined */ .Sizeof(x)
+}
diff --git a/src/go/types/fixedbugs/issue40684.go2 b/src/go/types/fixedbugs/issue40684.go2
new file mode 100644
index 0000000000..0269c3a62c
--- /dev/null
+++ b/src/go/types/fixedbugs/issue40684.go2
@@ -0,0 +1,15 @@
+// Copyright 2020 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 p
+
+type T[_ any] int
+
+func f[_ any]()
+func g[_, _ any]()
+
+func _() {
+	_ = f[T /* ERROR without instantiation */ ]
+	_ = g[T /* ERROR without instantiation */ , T /* ERROR without instantiation */ ]
+}
\ No newline at end of file
diff --git a/src/go/types/fixedbugs/issue41124.go2 b/src/go/types/fixedbugs/issue41124.go2
new file mode 100644
index 0000000000..61f766bcbd
--- /dev/null
+++ b/src/go/types/fixedbugs/issue41124.go2
@@ -0,0 +1,91 @@
+// Copyright 2020 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 p
+
+// Test case from issue.
+
+type Nat interface {
+	type Zero, Succ
+}
+
+type Zero struct{}
+type Succ struct{
+	Nat // ERROR interface contains type constraints
+}
+
+// Struct tests.
+
+type I1 interface {
+	comparable
+}
+
+type I2 interface {
+	type int
+}
+
+type I3 interface {
+	I1
+	I2
+}
+
+type _ struct {
+	f I1 // ERROR interface is .* comparable
+}
+
+type _ struct {
+	comparable // ERROR interface is .* comparable
+}
+
+type _ struct{
+	I1 // ERROR interface is .* comparable
+}
+
+type _ struct{
+	I2 // ERROR interface contains type constraints
+}
+
+type _ struct{
+	I3 // ERROR interface contains type constraints
+}
+
+// General composite types.
+
+type (
+	_ [10]I1 // ERROR interface is .* comparable
+	_ [10]I2 // ERROR interface contains type constraints
+
+	_ []I1 // ERROR interface is .* comparable
+	_ []I2 // ERROR interface contains type constraints
+
+	_ *I3 // ERROR interface contains type constraints
+	_ map[I1 /* ERROR interface is .* comparable */ ]I2 // ERROR interface contains type constraints
+	_ chan I3 // ERROR interface contains type constraints
+	_ func(I1 /* ERROR interface is .* comparable */ )
+	_ func() I2 // ERROR interface contains type constraints
+)
+
+// Other cases.
+
+var _ = [...]I3 /* ERROR interface contains type constraints */ {}
+
+func _(x interface{}) {
+	_ = x.(I3 /* ERROR interface contains type constraints */ )
+}
+
+type T1[_ any] struct{}
+type T3[_, _, _ any] struct{}
+var _ T1[I2 /* ERROR interface contains type constraints */ ]
+var _ T3[int, I2 /* ERROR interface contains type constraints */ , float32]
+
+func f1[_ any]() int
+var _ = f1[I2 /* ERROR interface contains type constraints */ ]()
+func f3[_, _, _ any]() int
+var _ = f3[int, I2 /* ERROR interface contains type constraints */ , float32]()
+
+func _(x interface{}) {
+	switch x.(type) {
+	case I2 /* ERROR interface contains type constraints */ :
+	}
+}
diff --git a/src/go/types/fixedbugs/issue42758.go2 b/src/go/types/fixedbugs/issue42758.go2
new file mode 100644
index 0000000000..698cb8a16b
--- /dev/null
+++ b/src/go/types/fixedbugs/issue42758.go2
@@ -0,0 +1,33 @@
+// Copyright 2020 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 p
+
+func _[T any](x interface{}){
+	switch x.(type) {
+	case T: // ok to use a type parameter
+	case int:
+	}
+
+	switch x.(type) {
+	case T:
+	case T /* ERROR duplicate case */ :
+	}
+}
+
+type constraint interface {
+	type int
+}
+
+func _[T constraint](x interface{}){
+	switch x.(type) {
+	case T: // ok to use a type parameter even if type list contains int
+	case int:
+	}
+}
+
+func _(x constraint /* ERROR contains type constraints */ ) {
+	switch x /* ERROR contains type constraints */ .(type) {
+	}
+}
diff --git a/src/go/types/infer.go b/src/go/types/infer.go
index c0b1a4b71a..95bd3cb378 100644
--- a/src/go/types/infer.go
+++ b/src/go/types/infer.go
@@ -39,7 +39,7 @@ func (check *Checker) infer(tparams []*TypeName, params *Tuple, args []*operand)
 				}
 			}
 			if allFailed {
-				check.errorf(arg, 0, "%s %s of %s does not match %s (cannot infer %s)", kind, targ, arg.expr, tpar, typeNamesString(tparams))
+				check.errorf(arg, _Todo, "%s %s of %s does not match %s (cannot infer %s)", kind, targ, arg.expr, tpar, typeNamesString(tparams))
 				return
 			}
 		}
@@ -47,7 +47,7 @@ func (check *Checker) infer(tparams []*TypeName, params *Tuple, args []*operand)
 		// TODO(rFindley): pass a positioner here, rather than arg.Pos().
 		inferred := check.subst(arg.Pos(), tpar, smap)
 		if inferred != tpar {
-			check.errorf(arg, 0, "%s %s of %s does not match inferred type %s for %s", kind, targ, arg.expr, inferred, tpar)
+			check.errorf(arg, _Todo, "%s %s of %s does not match inferred type %s for %s", kind, targ, arg.expr, inferred, tpar)
 		} else {
 			check.errorf(arg, 0, "%s %s of %s does not match %s", kind, targ, arg.expr, tpar)
 		}
diff --git a/src/go/types/resolver.go b/src/go/types/resolver.go
index 9cd13987be..639ed12117 100644
--- a/src/go/types/resolver.go
+++ b/src/go/types/resolver.go
@@ -400,9 +400,12 @@ func (check *Checker) collectObjects() {
 					}
 				} else {
 					// method
-					if d.decl.Type.TParams != nil {
-						check.invalidAST(d.decl.Type.TParams, "method must have no type parameters")
-					}
+
+					// TODO(rFindley) earlier versions of this code checked that methods
+					//                have no type parameters, but this is checked later
+					//                when type checking the function type. Confirm that
+					//                we don't need to check tparams here.
+
 					ptr, recv, _ := check.unpackRecv(d.decl.Recv.List[0].Type, false)
 					// (Methods with invalid receiver cannot be associated to a type, and
 					// methods with blank _ names are never found; no need to collect any
@@ -496,7 +499,7 @@ L: // unpack receiver type
 				case nil:
 					check.invalidAST(ptyp, "parameterized receiver contains nil parameters")
 				default:
-					check.errorf(arg, 0, "receiver type parameter %s must be an identifier", arg)
+					check.errorf(arg, _Todo, "receiver type parameter %s must be an identifier", arg)
 				}
 				if par == nil {
 					par = &ast.Ident{NamePos: arg.Pos(), Name: "_"}
diff --git a/src/go/types/subst.go b/src/go/types/subst.go
index ca9462dfda..ed27488503 100644
--- a/src/go/types/subst.go
+++ b/src/go/types/subst.go
@@ -109,7 +109,7 @@ func (check *Checker) instantiate(pos token.Pos, typ Type, targs []Type, poslist
 	// the number of supplied types must match the number of type parameters
 	if len(targs) != len(tparams) {
 		// TODO(gri) provide better error message
-		check.errorf(atPos(pos), 0, "got %d arguments but %d type parameters", len(targs), len(tparams))
+		check.errorf(atPos(pos), _Todo, "got %d arguments but %d type parameters", len(targs), len(tparams))
 		return Typ[Invalid]
 	}
 
@@ -163,7 +163,8 @@ func (check *Checker) instantiate(pos token.Pos, typ Type, targs []Type, poslist
 				} else if wrong != nil {
 					// TODO(gri) This can still report uninstantiated types which makes the error message
 					//           more difficult to read then necessary.
-					check.softErrorf(atPos(pos), 0,
+					// TODO(rFindley) should this use parentheses rather than ':' for qualification?
+					check.softErrorf(atPos(pos), _Todo,
 						"%s does not satisfy %s: wrong method signature\n\tgot  %s\n\twant %s",
 						targ, tpar.bound, wrong, m,
 					)
@@ -184,7 +185,7 @@ func (check *Checker) instantiate(pos token.Pos, typ Type, targs []Type, poslist
 		if targ := asTypeParam(targ); targ != nil {
 			targBound := targ.Bound()
 			if targBound.allTypes == nil {
-				check.softErrorf(atPos(pos), 0, "%s does not satisfy %s (%s has no type constraints)", targ, tpar.bound, targ)
+				check.softErrorf(atPos(pos), _Todo, "%s does not satisfy %s (%s has no type constraints)", targ, tpar.bound, targ)
 				break
 			}
 			for _, t := range unpackType(targBound.allTypes) {
@@ -199,7 +200,7 @@ func (check *Checker) instantiate(pos token.Pos, typ Type, targs []Type, poslist
 
 		// Otherwise, targ's type or underlying type must also be one of the interface types listed, if any.
 		if !iface.isSatisfiedBy(targ) {
-			check.softErrorf(atPos(pos), 0, "%s does not satisfy %s (%s or %s not found in %s)", targ, tpar.bound, targ, under(targ), iface.allTypes)
+			check.softErrorf(atPos(pos), _Todo, "%s does not satisfy %s (%s or %s not found in %s)", targ, tpar.bound, targ, under(targ), iface.allTypes)
 			break
 		}
 	}
diff --git a/src/go/types/testdata/builtins.go2 b/src/go/types/testdata/builtins.go2
new file mode 100644
index 0000000000..3918d836b5
--- /dev/null
+++ b/src/go/types/testdata/builtins.go2
@@ -0,0 +1,53 @@
+// Copyright 2020 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.
+
+// This file tests built-in calls on generic types.
+
+package builtins
+
+type Bmc interface {
+	type map[rune]string, chan int
+}
+
+type Bms interface {
+	type map[string]int, []int
+}
+
+type Bcs interface {
+	type chan bool, []float64
+}
+
+type Bss interface {
+	type []int, []string
+}
+
+func _[T any] () {
+	_ = make(T /* ERROR invalid argument */ )
+	_ = make(T /* ERROR invalid argument */ , 10)
+	_ = make(T /* ERROR invalid argument */ , 10, 20)
+}
+
+func _[T Bmc] () {
+	_ = make(T)
+	_ = make(T, 10)
+	_ = make /* ERROR expects 1 or 2 arguments */ (T, 10, 20)
+}
+
+func _[T Bms] () {
+	_ = make /* ERROR expects 2 arguments */ (T)
+	_ = make(T, 10)
+	_ = make /* ERROR expects 2 arguments */ (T, 10, 20)
+}
+
+func _[T Bcs] () {
+	_ = make /* ERROR expects 2 arguments */ (T)
+	_ = make(T, 10)
+	_ = make /* ERROR expects 2 arguments */ (T, 10, 20)
+}
+
+func _[T Bss] () {
+	_ = make /* ERROR expects 2 or 3 arguments */ (T)
+	_ = make(T, 10)
+	_ = make(T, 10, 20)
+}
diff --git a/src/go/types/testdata/chans.go2 b/src/go/types/testdata/chans.go2
new file mode 100644
index 0000000000..fad2bcec9d
--- /dev/null
+++ b/src/go/types/testdata/chans.go2
@@ -0,0 +1,62 @@
+package chans
+
+import "runtime"
+
+// Ranger returns a Sender and a Receiver. The Receiver provides a
+// Next method to retrieve values. The Sender provides a Send method
+// to send values and a Close method to stop sending values. The Next
+// method indicates when the Sender has been closed, and the Send
+// method indicates when the Receiver has been freed.
+//
+// This is a convenient way to exit a goroutine sending values when
+// the receiver stops reading them.
+func Ranger[T any]() (*Sender[T], *Receiver[T]) {
+	c := make(chan T)
+	d := make(chan bool)
+	s := &Sender[T]{values: c, done: d}
+	r := &Receiver[T]{values: c, done: d}
+	runtime.SetFinalizer(r, r.finalize)
+	return s, r
+}
+
+// A sender is used to send values to a Receiver.
+type Sender[T any] struct {
+	values chan<- T
+	done <-chan bool
+}
+
+// Send sends a value to the receiver. It returns whether any more
+// values may be sent; if it returns false the value was not sent.
+func (s *Sender[T]) Send(v T) bool {
+	select {
+	case s.values <- v:
+		return true
+	case <-s.done:
+		return false
+	}
+}
+
+// Close tells the receiver that no more values will arrive.
+// After Close is called, the Sender may no longer be used.
+func (s *Sender[T]) Close() {
+	close(s.values)
+}
+
+// A Receiver receives values from a Sender.
+type Receiver[T any] struct {
+	values <-chan T
+	done chan<- bool
+}
+
+// Next returns the next value from the channel. The bool result
+// indicates whether the value is valid, or whether the Sender has
+// been closed and no more values will be received.
+func (r *Receiver[T]) Next() (T, bool) {
+	v, ok := <-r.values
+	return v, ok
+}
+
+// finalize is a finalizer for the receiver.
+func (r *Receiver[T]) finalize() {
+	close(r.done)
+}
diff --git a/src/go/types/testdata/issues.go2 b/src/go/types/testdata/issues.go2
new file mode 100644
index 0000000000..ac2dee36cb
--- /dev/null
+++ b/src/go/types/testdata/issues.go2
@@ -0,0 +1,255 @@
+// Copyright 2020 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.
+
+// This file contains regression tests for bugs found.
+
+package p
+
+import "io"
+import "context"
+
+// Interfaces are always comparable (though the comparison may panic at runtime).
+func eql[T comparable](x, y T) bool {
+	return x == y
+}
+
+func _() {
+	var x interface{}
+	var y interface{ m() }
+	eql(x, y /* ERROR does not match */ ) // interfaces of different types
+	eql(x, x)
+	eql(y, y)
+	eql(y, nil)
+	eql(io.Reader)(nil, nil)
+}
+
+// If we have a receiver of pointer type (below: *T) we must ignore
+// the pointer in the implementation of the method lookup because
+// the type bound of T is an interface an pointer to interface types
+// have no methods and then the lookup would fail.
+type C[T any] interface {
+    m()
+}
+
+// using type bound C
+func _[T C[T]](x *T) {
+	x.m()
+}
+
+// using an interface literal as bound
+func _[T interface{ m() }](x *T) {
+	x.m()
+}
+
+// In a generic function body all method calls will be pointer method calls.
+// If necessary, the function body will insert temporary variables, not seen
+// by the user, in order to get an addressable variable to use to call the method.
+// Thus, assume an argument type for a generic function to be the type of addressable
+// values in the generic function when checking if the argument type satisfies the
+// generic function's type bound.
+func f2[_ interface{ m1(); m2() }]()
+
+type T struct{}
+func (T) m1()
+func (*T) m2()
+
+func _() {
+	f2(T /* ERROR wrong method signature */ )()
+	f2(*T)()
+}
+
+// When a type parameter is used as an argument to instantiate a parameterized
+// type with a type list constraint, all of the type argument's types in its
+// bound, but at least one (!), must be in the type list of the bound of the
+// corresponding parameterized type's type parameter.
+type T1[P interface{type uint}] struct{}
+
+func _[P any]() {
+    _ = T1[P /* ERROR P has no type constraints */ ]{}
+}
+
+// This is the original (simplified) program causing the same issue.
+type Unsigned interface {
+	type uint
+}
+
+type T2[U Unsigned] struct {
+    s U
+}
+
+func (u T2[U]) Add1() U {
+    return u.s + 1
+}
+
+func NewT2[U any]() T2[U /* ERROR U has no type constraints */ ] {
+    return T2[U /* ERROR U has no type constraints */ ]{}
+}
+
+func _() {
+    u := NewT2[string]()
+    _ = u.Add1()
+}
+
+// When we encounter an instantiated type such as Elem[T] we must
+// not "expand" the instantiation when the type to be instantiated
+// (Elem in this case) is not yet fully set up.
+type Elem[T any] struct {
+	next *Elem[T]
+	list *List[T]
+}
+
+type List[T any] struct {
+	root Elem[T]
+}
+
+func (l *List[T]) Init() {
+	l.root.next = &l.root
+}
+
+// This is the original program causing the same issue.
+type Element2[TElem any] struct {
+	next, prev *Element2[TElem]
+	list *List2[TElem]
+	Value TElem
+}
+
+type List2[TElem any] struct {
+	root Element2[TElem]
+	len  int
+}
+
+func (l *List2[TElem]) Init() *List2[TElem] {
+	l.root.next = &l.root
+	l.root.prev = &l.root
+	l.len = 0
+	return l
+}
+
+// Self-recursive instantiations must work correctly.
+type A[P any] struct { _ *A[P] }
+
+type AB[P any] struct { _ *BA[P] }
+type BA[P any] struct { _ *AB[P] }
+
+// And a variation that also caused a problem with an
+// unresolved underlying type.
+type Element3[TElem any] struct {
+	next, prev *Element3[TElem]
+	list *List3[TElem]
+	Value TElem
+}
+
+func (e *Element3[TElem]) Next() *Element3[TElem] {
+	if p := e.next; e.list != nil && p != &e.list.root {
+		return p
+	}
+	return nil
+}
+
+type List3[TElem any] struct {
+	root Element3[TElem]
+	len  int
+}
+
+// Infinite generic type declarations must lead to an error.
+type inf1[T any] struct{ _ inf1 /* ERROR illegal cycle */ [T] }
+type inf2[T any] struct{ inf2 /* ERROR illegal cycle */ [T] }
+
+// The implementation of conversions T(x) between integers and floating-point
+// numbers checks that both T and x have either integer or floating-point
+// type. When the type of T or x is a type parameter, the respective simple
+// predicate disjunction in the implementation was wrong because if a type list
+// contains both an integer and a floating-point type, the type parameter is
+// neither an integer or a floating-point number.
+func convert[T1, T2 interface{type int, uint, float32}](v T1) T2 {
+	return T2(v)
+}
+
+func _() {
+	convert[int, uint](5)
+}
+
+// When testing binary operators, for +, the operand types must either be
+// both numeric, or both strings. The implementation had the same problem
+// with this check as the conversion issue above (issue #39623).
+
+func issue39623[T interface{type int, string}](x, y T) T {
+	return x + y
+}
+
+// Simplified, from https://go2goplay.golang.org/p/efS6x6s-9NI:
+func Sum[T interface{type int, string}](s []T) (sum T) {
+	for _, v := range s {
+		sum += v
+	}
+	return
+}
+
+// Assignability of an unnamed pointer type to a type parameter that
+// has a matching underlying type.
+func _[T interface{}, PT interface{type *T}] (x T) PT {
+    return &x
+}
+
+// Indexing of generic types containing type parameters in their type list:
+func at[T interface{ type []E }, E interface{}](x T, i int) E {
+        return x[i]
+}
+
+// A generic type inside a function acts like a named type. Its underlying
+// type is itself, its "operational type" is defined by the type list in
+// the tybe bound, if any.
+func _[T interface{type int}](x T) {
+	type myint int
+	var _ int = int(x)
+	var _ T = 42
+	var _ T = T(myint(42))
+}
+
+// Indexing a generic type with an array type bound checks length.
+// (Example by mdempsky@.)
+func _[T interface { type [10]int }](x T) {
+	_ = x[9] // ok
+	_ = x[20 /* ERROR out of bounds */ ]
+}
+
+// Pointer indirection of a generic type.
+func _[T interface{ type *int }](p T) int {
+	return *p
+}
+
+// Channel sends and receives on generic types.
+func _[T interface{ type chan int }](ch T) int {
+	ch <- 0
+	return <- ch
+}
+
+// Calling of a generic variable.
+func _[T interface{ type func() }](f T) {
+	f()
+	go f()
+}
+
+// We must compare against the underlying type of type list entries
+// when checking if a constraint is satisfied by a type. The under-
+// lying type of each type list entry must be computed after the
+// interface has been instantiated as its typelist may contain a
+// type parameter that was substituted with a defined type.
+// Test case from an (originally) failing example.
+
+type sliceOf[E any] interface{ type []E }
+
+func append[T interface{}, S sliceOf[T], T2 interface{ type T }](s S, t ...T2) S
+
+var f           func()
+var cancelSlice []context.CancelFunc
+var _ = append(context.CancelFunc, []context.CancelFunc, context.CancelFunc)(cancelSlice, f)
+
+// A generic function must be instantiated with a type, not a value.
+
+func g[T any](T) T
+
+var _ = g[int]
+var _ = g[nil /* ERROR is not a type */ ]
+var _ = g(0)
diff --git a/src/go/types/testdata/linalg.go2 b/src/go/types/testdata/linalg.go2
new file mode 100644
index 0000000000..0d27603a58
--- /dev/null
+++ b/src/go/types/testdata/linalg.go2
@@ -0,0 +1,83 @@
+// Copyright 2019 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 linalg
+
+import "math"
+
+// Numeric is type bound that matches any numeric type.
+// It would likely be in a constraints package in the standard library.
+type Numeric interface {
+	type int, int8, int16, int32, int64,
+		uint, uint8, uint16, uint32, uint64, uintptr,
+		float32, float64,
+		complex64, complex128
+}
+
+func DotProduct[T Numeric](s1, s2 []T) T {
+	if len(s1) != len(s2) {
+		panic("DotProduct: slices of unequal length")
+	}
+	var r T
+	for i := range s1 {
+		r += s1[i] * s2[i]
+	}
+	return r
+}
+
+// NumericAbs matches numeric types with an Abs method.
+type NumericAbs[T any] interface {
+	Numeric
+
+	Abs() T
+}
+
+// AbsDifference computes the absolute value of the difference of
+// a and b, where the absolute value is determined by the Abs method.
+func AbsDifference[T NumericAbs[T]](a, b T) T {
+	d := a - b
+	return d.Abs()
+}
+
+// OrderedNumeric is a type bound that matches numeric types that support the < operator.
+type OrderedNumeric interface {
+	type int, int8, int16, int32, int64,
+		uint, uint8, uint16, uint32, uint64, uintptr,
+		float32, float64
+}
+
+// Complex is a type bound that matches the two complex types, which do not have a < operator.
+type Complex interface {
+	type complex64, complex128
+}
+
+// OrderedAbs is a helper type that defines an Abs method for
+// ordered numeric types.
+type OrderedAbs[T OrderedNumeric] T
+
+func (a OrderedAbs[T]) Abs() OrderedAbs[T] {
+	if a < 0 {
+		return -a
+	}
+	return a
+}
+
+// ComplexAbs is a helper type that defines an Abs method for
+// complex types.
+type ComplexAbs[T Complex] T
+
+func (a ComplexAbs[T]) Abs() ComplexAbs[T] {
+	r := float64(real(a))
+	i := float64(imag(a))
+	d := math.Sqrt(r * r + i * i)
+	return ComplexAbs[T](complex(d, 0))
+}
+
+func OrderedAbsDifference[T OrderedNumeric](a, b T) T {
+	return T(AbsDifference(OrderedAbs[T](a), OrderedAbs[T](b)))
+}
+
+func ComplexAbsDifference[T Complex](a, b T) T {
+	return T(AbsDifference(ComplexAbs[T](a), ComplexAbs[T](b)))
+}
diff --git a/src/go/types/testdata/map.go2 b/src/go/types/testdata/map.go2
new file mode 100644
index 0000000000..814d9539fd
--- /dev/null
+++ b/src/go/types/testdata/map.go2
@@ -0,0 +1,113 @@
+// Copyright 2019 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 orderedmap provides an ordered map, implemented as a binary tree.
+package orderedmap
+
+// TODO(gri) fix imports for tests
+import "chans" // ERROR could not import
+
+// Map is an ordered map.
+type Map[K, V any] struct {
+	root    *node[K, V]
+	compare func(K, K) int
+}
+
+// node is the type of a node in the binary tree.
+type node[K, V any] struct {
+	key         K
+	val         V
+	left, right *node[K, V]
+}
+
+// New returns a new map.
+func New[K, V any](compare func(K, K) int) *Map[K, V] {
+        return &Map[K, V]{compare: compare}
+}
+
+// find looks up key in the map, and returns either a pointer
+// to the node holding key, or a pointer to the location where
+// such a node would go.
+func (m *Map[K, V]) find(key K) **node[K, V] {
+	pn := &m.root
+	for *pn != nil {
+		switch cmp := m.compare(key, (*pn).key); {
+		case cmp < 0:
+			pn = &(*pn).left
+		case cmp > 0:
+			pn = &(*pn).right
+		default:
+			return pn
+		}
+	}
+	return pn
+}
+
+// Insert inserts a new key/value into the map.
+// If the key is already present, the value is replaced.
+// Returns true if this is a new key, false if already present.
+func (m *Map[K, V]) Insert(key K, val V) bool {
+	pn := m.find(key)
+	if *pn != nil {
+		(*pn).val = val
+		return false
+	}
+        *pn = &node[K, V]{key: key, val: val}
+	return true
+}
+
+// Find returns the value associated with a key, or zero if not present.
+// The found result reports whether the key was found.
+func (m *Map[K, V]) Find(key K) (V, bool) {
+	pn := m.find(key)
+	if *pn == nil {
+		var zero V // see the discussion of zero values, above
+		return zero, false
+	}
+	return (*pn).val, true
+}
+
+// keyValue is a pair of key and value used when iterating.
+type keyValue[K, V any] struct {
+	key K
+	val V
+}
+
+// InOrder returns an iterator that does an in-order traversal of the map.
+func (m *Map[K, V]) InOrder() *Iterator[K, V] {
+	sender, receiver := chans.Ranger[keyValue[K, V]]()
+	var f func(*node[K, V]) bool
+	f = func(n *node[K, V]) bool {
+		if n == nil {
+			return true
+		}
+		// Stop sending values if sender.Send returns false,
+		// meaning that nothing is listening at the receiver end.
+		return f(n.left) &&
+                        sender.Send(keyValue[K, V]{n.key, n.val}) &&
+			f(n.right)
+	}
+	go func() {
+		f(m.root)
+		sender.Close()
+	}()
+	return &Iterator[K, V]{receiver}
+}
+
+// Iterator is used to iterate over the map.
+type Iterator[K, V any] struct {
+	r *chans.Receiver[keyValue[K, V]]
+}
+
+// Next returns the next key and value pair, and a boolean indicating
+// whether they are valid or whether we have reached the end.
+func (it *Iterator[K, V]) Next() (K, V, bool) {
+	keyval, ok := it.r.Next()
+	if !ok {
+		var zerok K
+		var zerov V
+		return zerok, zerov, false
+	}
+	return keyval.key, keyval.val, true
+}
diff --git a/src/go/types/testdata/map2.go2 b/src/go/types/testdata/map2.go2
new file mode 100644
index 0000000000..2833445662
--- /dev/null
+++ b/src/go/types/testdata/map2.go2
@@ -0,0 +1,146 @@
+// Copyright 2019 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.
+
+// This file is like map.go2, but instead if importing chans, it contains
+// the necessary functionality at the end of the file.
+
+// Package orderedmap provides an ordered map, implemented as a binary tree.
+package orderedmap
+
+// Map is an ordered map.
+type Map[K, V any] struct {
+	root    *node[K, V]
+	compare func(K, K) int
+}
+
+// node is the type of a node in the binary tree.
+type node[K, V any] struct {
+	key         K
+	val         V
+	left, right *node[K, V]
+}
+
+// New returns a new map.
+func New[K, V any](compare func(K, K) int) *Map[K, V] {
+        return &Map[K, V]{compare: compare}
+}
+
+// find looks up key in the map, and returns either a pointer
+// to the node holding key, or a pointer to the location where
+// such a node would go.
+func (m *Map[K, V]) find(key K) **node[K, V] {
+	pn := &m.root
+	for *pn != nil {
+		switch cmp := m.compare(key, (*pn).key); {
+		case cmp < 0:
+			pn = &(*pn).left
+		case cmp > 0:
+			pn = &(*pn).right
+		default:
+			return pn
+		}
+	}
+	return pn
+}
+
+// Insert inserts a new key/value into the map.
+// If the key is already present, the value is replaced.
+// Returns true if this is a new key, false if already present.
+func (m *Map[K, V]) Insert(key K, val V) bool {
+	pn := m.find(key)
+	if *pn != nil {
+		(*pn).val = val
+		return false
+	}
+	*pn = &node[K, V]{key: key, val: val}
+	return true
+}
+
+// Find returns the value associated with a key, or zero if not present.
+// The found result reports whether the key was found.
+func (m *Map[K, V]) Find(key K) (V, bool) {
+	pn := m.find(key)
+	if *pn == nil {
+		var zero V // see the discussion of zero values, above
+		return zero, false
+	}
+	return (*pn).val, true
+}
+
+// keyValue is a pair of key and value used when iterating.
+type keyValue[K, V any] struct {
+	key K
+	val V
+}
+
+// InOrder returns an iterator that does an in-order traversal of the map.
+func (m *Map[K, V]) InOrder() *Iterator[K, V] {
+	sender, receiver := chans_Ranger[keyValue[K, V]]()
+	var f func(*node[K, V]) bool
+	f = func(n *node[K, V]) bool {
+		if n == nil {
+			return true
+		}
+		// Stop sending values if sender.Send returns false,
+		// meaning that nothing is listening at the receiver end.
+		return f(n.left) &&
+                        sender.Send(keyValue[K, V]{n.key, n.val}) &&
+			f(n.right)
+	}
+	go func() {
+		f(m.root)
+		sender.Close()
+	}()
+	return &Iterator[K, V]{receiver}
+}
+
+// Iterator is used to iterate over the map.
+type Iterator[K, V any] struct {
+	r *chans_Receiver[keyValue[K, V]]
+}
+
+// Next returns the next key and value pair, and a boolean indicating
+// whether they are valid or whether we have reached the end.
+func (it *Iterator[K, V]) Next() (K, V, bool) {
+	keyval, ok := it.r.Next()
+	if !ok {
+		var zerok K
+		var zerov V
+		return zerok, zerov, false
+	}
+	return keyval.key, keyval.val, true
+}
+
+// chans
+
+func chans_Ranger[T any]() (*chans_Sender[T], *chans_Receiver[T])
+
+// A sender is used to send values to a Receiver.
+type chans_Sender[T any] struct {
+	values chan<- T
+	done <-chan bool
+}
+
+func (s *chans_Sender[T]) Send(v T) bool {
+	select {
+	case s.values <- v:
+		return true
+	case <-s.done:
+		return false
+	}
+}
+
+func (s *chans_Sender[T]) Close() {
+	close(s.values)
+}
+
+type chans_Receiver[T any] struct {
+	values <-chan T
+	done chan<- bool
+}
+
+func (r *chans_Receiver[T]) Next() (T, bool) {
+	v, ok := <-r.values
+	return v, ok
+}
\ No newline at end of file
diff --git a/src/go/types/testdata/slices.go2 b/src/go/types/testdata/slices.go2
new file mode 100644
index 0000000000..2bacd1c2aa
--- /dev/null
+++ b/src/go/types/testdata/slices.go2
@@ -0,0 +1,68 @@
+// Copyright 2019 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 slices implements various slice algorithms.
+package slices
+
+// Map turns a []T1 to a []T2 using a mapping function.
+func Map[T1, T2 any](s []T1, f func(T1) T2) []T2 {
+	r := make([]T2, len(s))
+	for i, v := range s {
+		r[i] = f(v)
+	}
+	return r
+}
+
+// Reduce reduces a []T1 to a single value using a reduction function.
+func Reduce[T1, T2 any](s []T1, initializer T2, f func(T2, T1) T2) T2 {
+	r := initializer
+	for _, v := range s {
+		r = f(r, v)
+	}
+	return r
+}
+
+// Filter filters values from a slice using a filter function.
+func Filter[T any](s []T, f func(T) bool) []T {
+	var r []T
+	for _, v := range s {
+		if f(v) {
+			r = append(r, v)
+		}
+	}
+	return r
+}
+
+// Example uses
+
+func limiter(x int) byte {
+	switch {
+	case x < 0:
+		return 0
+	default:
+		return byte(x)
+	case x > 255:
+		return 255
+	}
+}
+
+var input = []int{-4, 68954, 7, 44, 0, -555, 6945}
+var limited1 = Map[int, byte](input, limiter)
+var limited2 = Map(input, limiter) // using type inference
+
+func reducer(x float64, y int) float64 {
+	return x + float64(y)
+}
+
+var reduced1 = Reduce[int, float64](input, 0, reducer)
+var reduced2 = Reduce(input, 1i /* ERROR overflows */, reducer) // using type inference
+var reduced3 = Reduce(input, 1, reducer) // using type inference
+
+func filter(x int) bool {
+	return x&1 != 0
+}
+
+var filtered1 = Filter[int](input, filter)
+var filtered2 = Filter(input, filter) // using type inference
+
diff --git a/src/go/types/testdata/tinference.go2 b/src/go/types/testdata/tinference.go2
new file mode 100644
index 0000000000..31338b33ad
--- /dev/null
+++ b/src/go/types/testdata/tinference.go2
@@ -0,0 +1,108 @@
+// Copyright 2020 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 tinferenceB
+
+import "strconv"
+
+type any interface{}
+
+// TODO(rFindley) the below partially applied function types should probably
+//                not be permitted (spec question).
+
+func f0[A any, B interface{type C}, C interface{type D}, D interface{type A}](A, B, C, D)
+func _() {
+	f := f0[string]
+	f("a", "b", "c", "d")
+	f0("a", "b", "c", "d")
+}
+
+func f1[A any, B interface{type A}](A, B)
+func _() {
+	f := f1[int]
+	f(int(0), int(0))
+	f1(int(0), int(0))
+}
+
+func f2[A any, B interface{type []A}](A, B)
+func _() {
+	f := f2[byte]
+	f(byte(0), []byte{})
+	f2(byte(0), []byte{})
+}
+
+func f3[A any, B interface{type C}, C interface{type *A}](A, B, C)
+func _() {
+	f := f3[int]
+	var x int
+	f(x, &x, &x)
+	f3(x, &x, &x)
+}
+
+func f4[A any, B interface{type []C}, C interface{type *A}](A, B, C)
+func _() {
+	f := f4[int]
+	var x int
+	f(x, []*int{}, &x)
+	f4(x, []*int{}, &x)
+}
+
+func f5[A interface{type struct{b B; c C}}, B any, C interface{type *B}](x B) A
+func _() {
+	x := f5(1.2)
+	var _ float64 = x.b
+	var _ float64 = *x.c
+}
+
+func f6[A any, B interface{type struct{f []A}}](B) A
+func _() {
+	x := f6(struct{f []string}{})
+	var _ string = x
+}
+
+// TODO(gri) Need to flag invalid recursive constraints. At the
+// moment these cause infinite recursions and stack overflow.
+// func f7[A interface{type B}, B interface{type A}]()
+
+// More realistic examples
+
+func Double[S interface{ type []E }, E interface{ type int, int8, int16, int32, int64 }](s S) S {
+	r := make(S, len(s))
+	for i, v := range s {
+		r[i] = v + v
+	}
+	return r
+}
+
+type MySlice []int
+
+var _ = Double(MySlice{1})
+
+// From the draft design.
+
+type Setter[B any] interface {
+	Set(string)
+	type *B
+}
+
+func FromStrings[T interface{}, PT Setter[T]](s []string) []T {
+	result := make([]T, len(s))
+	for i, v := range s {
+		// The type of &result[i] is *T which is in the type list
+		// of Setter2, so we can convert it to PT.
+		p := PT(&result[i])
+		// PT has a Set method.
+		p.Set(v)
+	}
+	return result
+}
+
+type Settable int
+
+func (p *Settable) Set(s string) {
+	i, _ := strconv.Atoi(s) // real code should not ignore the error
+	*p = Settable(i)
+}
+
+var _ = FromStrings[Settable]([]string{"1", "2"})
diff --git a/src/go/types/testdata/tmp.go2 b/src/go/types/testdata/tmp.go2
new file mode 100644
index 0000000000..dae78caff8
--- /dev/null
+++ b/src/go/types/testdata/tmp.go2
@@ -0,0 +1,17 @@
+// Copyright 2020 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.
+
+// This file is meant as "dumping ground" for debugging code.
+
+package p
+
+// fun test case
+type C[P interface{m()}] P
+
+func (r C[P]) m() { r.m() }
+
+func f[T interface{m(); n()}](x T) {
+	y := C[T](x)
+	y.m()
+}
diff --git a/src/go/types/testdata/todos.go2 b/src/go/types/testdata/todos.go2
new file mode 100644
index 0000000000..09e9b4c48a
--- /dev/null
+++ b/src/go/types/testdata/todos.go2
@@ -0,0 +1,22 @@
+// Copyright 2020 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.
+
+// This file is meant as "dumping ground" for tests
+// of not yet implemented features. It will grow and
+// shrink over time.
+
+package p
+
+// When using []'s instead of ()'s for type parameters
+// we don't need extra parentheses for some composite
+// literal types.
+type T1[P any] struct{}
+type T2[P, Q any] struct{}
+
+func _() {
+   _ = []T1[int]{}            // ok if we use []'s
+   _ = [](T1[int]){}
+   _ = []T2[int, string]{}    // ok if we use []'s
+   _ = [](T2[int, string]){}
+}
diff --git a/src/go/types/testdata/typeinst.go2 b/src/go/types/testdata/typeinst.go2
new file mode 100644
index 0000000000..3184a4b5b1
--- /dev/null
+++ b/src/go/types/testdata/typeinst.go2
@@ -0,0 +1,59 @@
+// Copyright 2019 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 p
+
+type myInt int
+
+// Parameterized type declarations
+
+type T1[P any] P
+
+type T2[P any] struct {
+        f P
+        g int // int should still be in scope chain
+}
+
+type List[P any] []P
+
+// Alias type declarations cannot have type parameters. Syntax error.
+type A1[P any] = /* ERROR cannot be alias */ P
+
+// But an alias may refer to a generic, uninstantiated type.
+type A2 = List
+var _ A2[int]
+var _ A2 /* ERROR without instantiation */
+
+type A3 = List[int]
+var _ A3
+
+// Parameterized type instantiations
+
+var x int
+type _ x /* ERROR not a type */ [int]
+
+type _ int /* ERROR not a generic type */ []
+type _ myInt /* ERROR not a generic type */ []
+
+// TODO(gri) better error messages
+type _ T1 /* ERROR got 0 arguments but 1 type parameters */ []
+type _ T1[x /* ERROR not a type */ ]
+type _ T1 /* ERROR got 2 arguments but 1 type parameters */ [int, float32]
+
+var _ T2[int] = T2[int]{}
+
+var _ List[int] = []int{1, 2, 3}
+var _ List[[]int] = [][]int{{1, 2, 3}}
+var _ List[List[List[int]]]
+
+// Parameterized types containing parameterized types
+
+type T3[P any] List[P]
+
+var _ T3[int] = T3[int](List[int]{1, 2, 3})
+
+// Self-recursive generic types are not permitted
+
+type self1[P any] self1 /* ERROR illegal cycle */ [P]
+type self2[P any] *self2[P] // this is ok
diff --git a/src/go/types/testdata/typeinst2.go2 b/src/go/types/testdata/typeinst2.go2
new file mode 100644
index 0000000000..6e2104a515
--- /dev/null
+++ b/src/go/types/testdata/typeinst2.go2
@@ -0,0 +1,256 @@
+// Copyright 2019 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 p
+
+type List[E any] []E
+var _ List[List[List[int]]]
+var _ List[List[List[int]]] = []List[List[int]]{}
+
+type (
+	T1[P1 any] struct {
+		f1 T2[P1, float32]
+	}
+
+	T2[P2, P3 any] struct {
+		f2 P2
+		f3 P3
+	}
+)
+
+func _() {
+	var x1 T1[int]
+	var x2 T2[int, float32]
+
+	x1.f1.f2 = 0
+	x1.f1 = x2
+}
+
+type T3[P any] T1[T2[P, P]]
+
+func _() {
+	var x1 T3[int]
+	var x2 T2[int, int]
+	x1.f1.f2 = x2
+}
+
+func f[P any] (x P) List[P] {
+	return List[P]{x}
+}
+
+var (
+	_ []int = f(0)
+	_ []float32 = f[float32](10)
+	_ List[complex128] = f(1i)
+	_ []List[int] = f(List[int]{})
+        _ List[List[int]] = []List[int]{}
+        _ = []List[int]{}
+)
+
+// Parameterized types with methods
+
+func (l List[E]) Head() (_ E, _ bool) {
+	if len(l) > 0 {
+		return l[0], true
+	}
+	return
+}
+
+// A test case for instantiating types with other types (extracted from map.go2)
+
+type Pair[K any] struct {
+	key K
+}
+
+type Receiver[T any] struct {
+	values T
+}
+
+type Iterator[K any] struct {
+	r Receiver[Pair[K]]
+}
+
+func Values [T any] (r Receiver[T]) T {
+        return r.values
+}
+
+func (it Iterator[K]) Next() K {
+        return Values[Pair[K]](it.r).key
+}
+
+// A more complex test case testing type bounds (extracted from linalg.go2 and reduced to essence)
+
+type NumericAbs[T any] interface {
+	Abs() T
+}
+
+func AbsDifference[T NumericAbs[T]](x T)
+
+type OrderedAbs[T any] T
+
+func (a OrderedAbs[T]) Abs() OrderedAbs[T]
+
+func OrderedAbsDifference[T any](x T) {
+	AbsDifference(OrderedAbs[T](x))
+}
+
+// same code, reduced to essence
+
+func g[P interface{ m() P }](x P)
+
+type T4[P any] P
+
+func (_ T4[P]) m() T4[P]
+
+func _[Q any](x Q) {
+	g(T4[Q](x))
+}
+
+// Another test case that caused  problems in the past
+
+type T5[_ interface { a() }, _ interface{}] struct{}
+
+type A[P any] struct{ x P }
+
+func (_ A[P]) a() {}
+
+var _ T5[A[int], int]
+
+// Invoking methods with parameterized receiver types uses
+// type inference to determine the actual type arguments matching
+// the receiver type parameters from the actual receiver argument.
+// Go does implicit address-taking and dereferenciation depending
+// on the actual receiver and the method's receiver type. To make
+// type inference work, the type-checker matches "pointer-ness"
+// of the actual receiver and the method's receiver type.
+// The following code tests this mechanism.
+
+type R1[A any] struct{}
+func (_ R1[A]) vm()
+func (_ *R1[A]) pm()
+
+func _[T any](r R1[T], p *R1[T]) {
+	r.vm()
+	r.pm()
+	p.vm()
+	p.pm()
+}
+
+type R2[A, B any] struct{}
+func (_ R2[A, B]) vm()
+func (_ *R2[A, B]) pm()
+
+func _[T any](r R2[T, int], p *R2[string, T]) {
+	r.vm()
+	r.pm()
+	p.vm()
+	p.pm()
+}
+
+// An interface can (explicitly) declare at most one type list.
+type _ interface {
+	m0()
+	type int, string, bool
+	type /* ERROR multiple type lists */ float32, float64
+	m1()
+	m2()
+	type /* ERROR multiple type lists */ complex64, complex128
+	type /* ERROR multiple type lists */ rune
+}
+
+// Interface type lists may contain each type at most once.
+// (If there are multiple lists, we assume the author intended
+// for them to be all in a single list, and we report the error
+// as well.)
+type _ interface {
+	type int, int /* ERROR duplicate type int */
+	type /* ERROR multiple type lists */ int /* ERROR duplicate type int */
+}
+
+type _ interface {
+	type struct{f int}, struct{g int}, struct /* ERROR duplicate type */ {f int}
+}
+
+// Interface type lists can contain any type, incl. *Named types.
+// Verify that we use the underlying type to compute the operational type.
+type MyInt int
+func add1[T interface{type MyInt}](x T) T {
+	return x + 1
+}
+
+type MyString string
+func double[T interface{type MyInt, MyString}](x T) T {
+	return x + x
+}
+
+// Embedding of interfaces with type lists leads to interfaces
+// with type lists that are the intersection of the embedded
+// type lists.
+
+type E0 interface {
+	type int, bool, string
+}
+
+type E1 interface {
+	type int, float64, string
+}
+
+type E2 interface {
+	type float64
+}
+
+type I0 interface {
+	E0
+}
+
+func f0[T I0]()
+var _ = f0[int]
+var _ = f0[bool]
+var _ = f0[string]
+var _ = f0[float64 /* ERROR does not satisfy I0 */ ]
+
+type I01 interface {
+	E0
+	E1
+}
+
+func f01[T I01]()
+var _ = f01[int]
+var _ = f01[bool /* ERROR does not satisfy I0 */ ]
+var _ = f01[string]
+var _ = f01[float64 /* ERROR does not satisfy I0 */ ]
+
+type I012 interface {
+	E0
+	E1
+	E2
+}
+
+func f012[T I012]()
+var _ = f012[int /* ERROR does not satisfy I012 */ ]
+var _ = f012[bool /* ERROR does not satisfy I012 */ ]
+var _ = f012[string /* ERROR does not satisfy I012 */ ]
+var _ = f012[float64 /* ERROR does not satisfy I012 */ ]
+
+type I12 interface {
+	E1
+	E2
+}
+
+func f12[T I12]()
+var _ = f12[int /* ERROR does not satisfy I12 */ ]
+var _ = f12[bool /* ERROR does not satisfy I12 */ ]
+var _ = f12[string /* ERROR does not satisfy I12 */ ]
+var _ = f12[float64]
+
+type I0_ interface {
+	E0
+	type int
+}
+
+func f0_[T I0_]()
+var _ = f0_[int]
+var _ = f0_[bool /* ERROR does not satisfy I0_ */ ]
+var _ = f0_[string /* ERROR does not satisfy I0_ */ ]
+var _ = f0_[float64 /* ERROR does not satisfy I0_ */ ]
diff --git a/src/go/types/testdata/typeparams.go2 b/src/go/types/testdata/typeparams.go2
new file mode 100644
index 0000000000..bdf6d56082
--- /dev/null
+++ b/src/go/types/testdata/typeparams.go2
@@ -0,0 +1,458 @@
+// Copyright 2018 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 p
+
+// import "io" // for type assertion tests
+
+// The predeclared identifier "any" is only visible as a constraint
+// in a type parameter list.
+var _ any // ERROR undeclared
+func _[_ any /* ok here */ , _ interface{any /* ERROR undeclared */ }](any /* ERROR undeclared */ ) {
+        var _ any /* ERROR undeclared */
+}
+
+func identity[T any](x T) T { return x }
+
+func _[_ any](x int) int
+func _[T any](T /* ERROR redeclared */ T)()
+func _[T, T /* ERROR redeclared */ any]()
+
+func reverse[T any](list []T) []T {
+        rlist := make([]T, len(list))
+        i := len(list)
+        for _, x := range list {
+                i--
+                rlist[i] = x
+        }
+        return rlist
+}
+
+var _ = reverse /* ERROR cannot use generic function reverse */
+var _ = reverse[int, float32 /* ERROR got 2 type arguments */ ] ([]int{1, 2, 3})
+var _ = reverse[int]([ /* ERROR cannot use */ ]float32{1, 2, 3})
+var f = reverse[chan int]
+var _ = f(0 /* ERROR cannot use 0 .* as \[\]chan int */ )
+
+func swap[A, B any](a A, b B) (B, A) { return b, a }
+
+var _ = swap /* ERROR single value is expected */ [int, float32](1, 2)
+var f32, i = swap[int, float32](swap(float32, int)(1, 2))
+var _ float32 = f32
+var _ int = i
+
+func swapswap[A, B any](a A, b B) (A, B) {
+        return swap[B, A](b, a)
+}
+
+type F[A, B any] func(A, B) (B, A)
+
+func min[T interface{ type int }](x, y T) T {
+        if x < y {
+                return x
+        }
+        return y
+}
+
+func _[T interface{type int, float32}](x, y T) bool { return x < y }
+func _[T any](x, y T) bool { return x /* ERROR cannot compare */ < y }
+func _[T interface{type int, float32, bool}](x, y T) bool { return x /* ERROR cannot compare */ < y }
+
+func _[T C1[T]](x, y T) bool { return x /* ERROR cannot compare */ < y }
+func _[T C2[T]](x, y T) bool { return x < y }
+
+type C1[T any] interface{}
+type C2[T any] interface{ type int, float32 }
+
+func new[T any]() *T {
+        var x T
+        return &x
+}
+
+var _ = new /* ERROR cannot use generic function new */
+var _ *int = new[int]()
+
+func _[T any](map[T /* ERROR incomparable map key type T \(missing comparable constraint\) */]int) // w/o constraint we don't know if T is comparable
+
+func f1[T1 any](struct{T1}) int
+var _ = f1(int)(struct{T1}{})
+type T1 = int
+
+func f2[t1 any](struct{t1; x float32}) int
+var _ = f2(t1)(struct{t1; x float32}{})
+type t1 = int
+
+
+func f3[A, B, C any](A, struct{x B}, func(A, struct{x B}, *C)) int
+
+var _ = f3[int, rune, bool](1, struct{x rune}{}, nil)
+
+// indexing
+
+func _[T any] (x T, i int) { _ = x /* ERROR "cannot index" */ [i] }
+func _[T interface{ type int }] (x T, i int) { _ = x /* ERROR "cannot index" */ [i] }
+func _[T interface{ type string }] (x T, i int) { _ = x[i] }
+func _[T interface{ type []int }] (x T, i int) { _ = x[i] }
+func _[T interface{ type [10]int, *[20]int, map[int]int }] (x T, i int) { _ = x[i] }
+func _[T interface{ type string, []byte }] (x T, i int) { _ = x[i] }
+func _[T interface{ type []int, [1]rune }] (x T, i int) { _ = x /* ERROR "cannot index" */ [i] }
+func _[T interface{ type string, []rune }] (x T, i int) { _ = x /* ERROR "cannot index" */ [i] }
+
+// indexing with various combinations of map types in type lists (see issue #42616)
+func _[T interface{ type []E, map[int]E }, E any](x T, i int) { _ = x[i] }
+func _[T interface{ type []E }, E any](x T, i int) { _ = &x[i] }
+func _[T interface{ type map[int]E }, E any](x T, i int) { _, _ = x[i] } // comma-ok permitted
+func _[T interface{ type []E, map[int]E }, E any](x T, i int) { _ = &x /* ERROR cannot take address */ [i] }
+func _[T interface{ type []E, map[int]E, map[uint]E }, E any](x T, i int) { _ = x /* ERROR cannot index */ [i] } // different map element types
+func _[T interface{ type []E, map[string]E }, E any](x T, i int) { _ = x[i /* ERROR cannot use i */ ] }
+
+// slicing
+// TODO(gri) implement this
+
+func _[T interface{ type string }] (x T, i, j, k int) { _ = x /* ERROR invalid operation */ [i:j:k] }
+
+// len/cap built-ins
+
+func _[T any](x T) { _ = len(x /* ERROR invalid argument */ ) }
+func _[T interface{ type int }](x T) { _ = len(x /* ERROR invalid argument */ ) }
+func _[T interface{ type string, []byte, int }](x T) { _ = len(x /* ERROR invalid argument */ ) }
+func _[T interface{ type string }](x T) { _ = len(x) }
+func _[T interface{ type [10]int }](x T) { _ = len(x) }
+func _[T interface{ type []byte }](x T) { _ = len(x) }
+func _[T interface{ type map[int]int }](x T) { _ = len(x) }
+func _[T interface{ type chan int }](x T) { _ = len(x) }
+func _[T interface{ type string, []byte, chan int }](x T) { _ = len(x) }
+
+func _[T any](x T) { _ = cap(x /* ERROR invalid argument */ ) }
+func _[T interface{ type int }](x T) { _ = cap(x /* ERROR invalid argument */ ) }
+func _[T interface{ type string, []byte, int }](x T) { _ = cap(x /* ERROR invalid argument */ ) }
+func _[T interface{ type string }](x T) { _ = cap(x /* ERROR invalid argument */ ) }
+func _[T interface{ type [10]int }](x T) { _ = cap(x) }
+func _[T interface{ type []byte }](x T) { _ = cap(x) }
+func _[T interface{ type map[int]int }](x T) { _ = cap(x /* ERROR invalid argument */ ) }
+func _[T interface{ type chan int }](x T) { _ = cap(x) }
+func _[T interface{ type []byte, chan int }](x T) { _ = cap(x) }
+
+// range iteration
+
+func _[T interface{}](x T) {
+        for range x /* ERROR cannot range */ {}
+}
+
+func _[T interface{ type string, []string }](x T) {
+        for range x {}
+        for i := range x { _ = i }
+        for i, _ := range x { _ = i }
+        for i, e := range x /* ERROR must have the same element type */ { _ = i }
+        for _, e := range x /* ERROR must have the same element type */ {}
+        var e rune
+        _ = e
+        for _, (e) = range x /* ERROR must have the same element type */ {}
+}
+
+
+func _[T interface{ type string, []rune, map[int]rune }](x T) {
+        for _, e := range x { _ = e }
+        for i, e := range x { _ = i; _ = e }
+}
+
+func _[T interface{ type string, []rune, map[string]rune }](x T) {
+        for _, e := range x { _ = e }
+        for i, e := range x /* ERROR must have the same key type */ { _ = e }
+}
+
+func _[T interface{ type string, chan int }](x T) {
+        for range x {}
+        for i := range x { _ = i }
+        for i, _ := range x { _ = i } // TODO(gri) should get an error here: channels only return one value
+}
+
+func _[T interface{ type string, chan<-int }](x T) {
+        for i := range x /* ERROR send-only channel */ { _ = i }
+}
+
+// type inference checks
+
+var _ = new() /* ERROR cannot infer T */
+
+func f4[A, B, C any](A, B) C
+
+var _ = f4(1, 2) /* ERROR cannot infer C */
+var _ = f4[int, float32, complex128](1, 2)
+
+func f5[A, B, C any](A, []*B, struct{f []C}) int
+
+var _ = f5[int, float32, complex128](0, nil, struct{f []complex128}{})
+var _ = f5(0, nil, struct{f []complex128}{}) // ERROR cannot infer
+var _ = f5(0, []*float32{new[float32]()}, struct{f []complex128}{})
+
+func f6[A any](A, []A) int
+
+var _ = f6(0, nil)
+
+func f6nil[A any](A) int
+
+var _ = f6nil(nil) // ERROR cannot infer
+
+// type inference with variadic functions
+
+func f7[T any](...T) T
+
+var _ int = f7() /* ERROR cannot infer T */
+var _ int = f7(1)
+var _ int = f7(1, 2)
+var _ int = f7([]int{}...)
+var _ int = f7 /* ERROR cannot use */ ([]float64{}...)
+var _ float64 = f7([]float64{}...)
+var _ = f7[float64](1, 2.3)
+var _ = f7(float64(1), 2.3)
+var _ = f7(1, 2.3 /* ERROR does not match */ )
+var _ = f7(1.2, 3 /* ERROR does not match */ )
+
+func f8[A, B any](A, B, ...B) int
+
+var _ = f8(1) /* ERROR not enough arguments */
+var _ = f8(1, 2.3)
+var _ = f8(1, 2.3, 3.4, 4.5)
+var _ = f8(1, 2.3, 3.4, 4 /* ERROR does not match */ )
+var _ = f8(int, float64)(1, 2.3, 3.4, 4)
+
+var _ = f8(int, float64)(0, 0, nil...) // test case for #18268
+
+// init functions cannot have type parameters
+
+func init() {}
+func init[/* ERROR func init must have no type parameters */ _ any]() {}
+func init[/* ERROR func init must have no type parameters */ P any]() {}
+
+type T struct {}
+
+func (T) m1() {}
+func (T) m2[ /* ERROR methods cannot have type parameters */ _ any]() {}
+func (T) m3[ /* ERROR methods cannot have type parameters */ P any]() {}
+
+// type inference across parameterized types
+
+type S1[P any] struct { f P }
+
+func f9[P any](x S1[P])
+
+func _() {
+        f9[int](S1[int]{42})
+	f9(S1[int]{42})
+}
+
+type S2[A, B, C any] struct{}
+
+func f10[X, Y, Z any](a S2[X, int, Z], b S2[X, Y, bool])
+
+func _[P any]() {
+        f10[int, float32, string](S2[int, int, string]{}, S2[int, float32, bool]{})
+        f10(S2[int, int, string]{}, S2[int, float32, bool]{})
+        f10(S2[P, int, P]{}, S2[P, float32, bool]{})
+}
+
+// corner case for type inference
+// (was bug: after instanting f11, the type-checker didn't mark f11 as non-generic)
+
+func f11[T any]()
+
+func _() {
+	f11[int]()
+}
+
+// the previous example was extracted from
+
+func f12[T interface{m() T}]()
+
+type A[T any] T
+
+func (a A[T]) m() A[T]
+
+func _[T any]() {
+	f12(A[T])()
+}
+
+// method expressions
+
+func (_ S1[P]) m()
+
+func _() {
+	m := S1[int].m
+	m(struct { f int }{42})
+}
+
+func _[T any] (x T) {
+        m := S1[T].m
+        m(S1[T]{x})
+}
+
+// type parameters in methods (generalization)
+
+type R0 struct{}
+
+func (R0) _[ /* ERROR methods cannot have type parameters */ T any](x T)
+func (R0 /* ERROR invalid receiver */ ) _[ /* ERROR methods cannot have type parameters */ R0 any]() // scope of type parameters starts at "func"
+
+type R1[A, B any] struct{}
+
+func (_ R1[A, B]) m0(A, B)
+func (_ R1[A, B]) m1[ /* ERROR methods cannot have type parameters */ T any](A, B, T) T
+func (_ R1 /* ERROR not a generic type */ [R1, _]) _()
+func (_ R1[A, B]) _[ /* ERROR methods cannot have type parameters */ A /* ERROR redeclared */ any](B)
+
+func _() {
+        var r R1[int, string]
+        r.m1[rune](42, "foo", 'a')
+        r.m1[rune](42, "foo", 1.2 /* ERROR cannot use .* as rune .* \(truncated\) */)
+        r.m1(42, "foo", 1.2) // using type inference
+        var _ float64 = r.m1(42, "foo", 1.2)
+}
+
+type I1[A any] interface {
+        m1(A)
+}
+
+var _ I1[int] = r1[int]{}
+
+type r1[T any] struct{}
+
+func (_ r1[T]) m1(T)
+
+type I2[A, B any] interface {
+        m1(A)
+        m2(A) B
+}
+
+var _ I2[int, float32] = R2[int, float32]{}
+
+type R2[P, Q any] struct{}
+
+func (_ R2[X, Y]) m1(X)
+func (_ R2[X, Y]) m2(X) Y
+
+// type assertions and type switches over generic types
+// NOTE: These are currently disabled because it's unclear what the correct
+// approach is, and one can always work around by assigning the variable to
+// an interface first.
+
+// // ReadByte1 corresponds to the ReadByte example in the draft design.
+// func ReadByte1[T io.Reader](r T) (byte, error) {
+// 	if br, ok := r.(io.ByteReader); ok {
+// 		return br.ReadByte()
+// 	}
+// 	var b [1]byte
+// 	_, err := r.Read(b[:])
+// 	return b[0], err
+// }
+//
+// // ReadBytes2 is like ReadByte1 but uses a type switch instead.
+// func ReadByte2[T io.Reader](r T) (byte, error) {
+//         switch br := r.(type) {
+//         case io.ByteReader:
+//                 return br.ReadByte()
+//         }
+// 	var b [1]byte
+// 	_, err := r.Read(b[:])
+// 	return b[0], err
+// }
+//
+// // type assertions and type switches over generic types are strict
+// type I3 interface {
+//         m(int)
+// }
+//
+// type I4 interface {
+//         m() int // different signature from I3.m
+// }
+//
+// func _[T I3](x I3, p T) {
+//         // type assertions and type switches over interfaces are not strict
+//         _ = x.(I4)
+//         switch x.(type) {
+//         case I4:
+//         }
+// 
+//         // type assertions and type switches over generic types are strict
+//         _ = p /* ERROR cannot have dynamic type I4 */.(I4)
+//         switch p.(type) {
+//         case I4 /* ERROR cannot have dynamic type I4 */ :
+//         }
+// }
+
+// type assertions and type switches over generic types lead to errors for now
+
+func _[T any](x T) {
+	_ = x /* ERROR not an interface */ .(int)
+	switch x /* ERROR not an interface */ .(type) {
+	}
+
+	// work-around
+	var t interface{} = x
+	_ = t.(int)
+	switch t.(type) {
+	}
+}
+
+func _[T interface{type int}](x T) {
+	_ = x /* ERROR not an interface */ .(int)
+	switch x /* ERROR not an interface */ .(type) {
+	}
+
+	// work-around
+	var t interface{} = x
+	_ = t.(int)
+	switch t.(type) {
+	}
+}
+
+// error messages related to type bounds mention those bounds
+type C[P any] interface{}
+
+func _[P C[P]] (x P) {
+	x.m /* ERROR x.m undefined */ ()
+}
+
+type I interface {}
+
+func _[P I] (x P) {
+	x.m /* ERROR interface I has no method m */ ()
+}
+
+func _[P interface{}] (x P) {
+	x.m /* ERROR type bound for P has no method m */ ()
+}
+
+func _[P any] (x P) {
+	x.m /* ERROR type bound for P has no method m */ ()
+}
+
+// automatic distinguishing between array and generic types
+// NOTE: Disabled when using unified parameter list syntax.
+/*
+const P = 10
+type A1 [P]byte
+func _(a A1) {
+        assert(len(a) == 10)
+}
+
+type A2 [P]struct{
+        f [P]byte
+}
+func _(a A2) {
+        assert(len(a) == 10)
+        assert(len(a[0].f) == 10)
+}
+
+type A3 [P]func(x [P]A3)
+func _(a A3) {
+        assert(len(a) == 10)
+}
+
+type T2[P] struct{ P }
+var _ T2[int]
+
+type T3[P] func(P)
+var _ T3[int]
+*/
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index 10d4973b2a..a6b7314dd5 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -143,11 +143,11 @@ func (check *Checker) ordinaryType(pos positioner, typ Type) {
 		if t := asInterface(typ); t != nil {
 			check.completeInterface(pos.Pos(), t) // TODO(gri) is this the correct position?
 			if t.allTypes != nil {
-				check.softErrorf(pos, 0, "interface contains type constraints (%s)", t.allTypes)
+				check.softErrorf(pos, _Todo, "interface contains type constraints (%s)", t.allTypes)
 				return
 			}
 			if t.IsComparable() {
-				check.softErrorf(pos, 0, "interface is (or embeds) comparable")
+				check.softErrorf(pos, _Todo, "interface is (or embeds) comparable")
 			}
 		}
 	})
@@ -171,7 +171,7 @@ func (check *Checker) definedType(e ast.Expr, def *Named) Type {
 	typ := check.typInternal(e, def)
 	assert(isTyped(typ))
 	if isGeneric(typ) {
-		check.errorf(e, 0, "cannot use generic type %s without instantiation", typ)
+		check.errorf(e, _Todo, "cannot use generic type %s without instantiation", typ)
 		typ = Typ[Invalid]
 	}
 	check.recordTypeAndValue(e, typexpr, typ, nil)
@@ -184,7 +184,7 @@ func (check *Checker) genericType(e ast.Expr, reportErr bool) Type {
 	assert(isTyped(typ))
 	if typ != Typ[Invalid] && !isGeneric(typ) {
 		if reportErr {
-			check.errorf(e, 0, "%s is not a generic type", typ)
+			check.errorf(e, _Todo, "%s is not a generic type", typ)
 		}
 		typ = Typ[Invalid]
 	}
@@ -315,7 +315,7 @@ func (check *Checker) funcType(sig *Signature, recvPar *ast.FieldList, ftyp *ast
 		// (A separate check is needed when type-checking interface method signatures because
 		// they don't have a receiver specification.)
 		if recvPar != nil {
-			check.errorf(ftyp.TParams, 0, "methods cannot have type parameters")
+			check.errorf(ftyp.TParams, _Todo, "methods cannot have type parameters")
 		}
 	}
 
@@ -776,7 +776,7 @@ func (check *Checker) interfaceType(ityp *Interface, iface *ast.InterfaceType, d
 				// the author intended to include all types.
 				types = append(types, f.Type)
 				if tlist != nil && tlist != name {
-					check.errorf(name, 0, "cannot have multiple type lists in an interface")
+					check.errorf(name, _Todo, "cannot have multiple type lists in an interface")
 				}
 				tlist = name
 				continue
@@ -795,7 +795,7 @@ func (check *Checker) interfaceType(ityp *Interface, iface *ast.InterfaceType, d
 			// (This extra check is needed here because interface method signatures don't have
 			// a receiver specification.)
 			if sig.tparams != nil {
-				check.errorf(f.Type.(*ast.FuncType).TParams, 0, "methods cannot have type parameters")
+				check.errorf(f.Type.(*ast.FuncType).TParams, _Todo, "methods cannot have type parameters")
 			}
 
 			// use named receiver type if available (for better error messages)
@@ -1072,7 +1072,9 @@ func (check *Checker) structType(styp *Struct, e *ast.StructType) {
 			pos := f.Type.Pos()
 			name := embeddedFieldIdent(f.Type)
 			if name == nil {
-				check.invalidAST(f.Type, "embedded field type %s has no name", f.Type)
+				// TODO(rFindley): using invalidAST here causes test failures (all
+				//                 errors should have codes). Clean this up.
+				check.errorf(f.Type, _Todo, "invalid AST: embedded field type %s has no name", f.Type)
 				name = ast.NewIdent("_")
 				name.NamePos = pos
 				addInvalid(name, pos)
@@ -1157,7 +1159,7 @@ func (check *Checker) collectTypeConstraints(pos token.Pos, types []ast.Expr) []
 				check.completeInterface(types[i].Pos(), t)
 			}
 			if includes(list[:i], t) {
-				check.softErrorf(types[i], 0, "duplicate type %s in type list", t)
+				check.softErrorf(types[i], _Todo, "duplicate type %s in type list", t)
 			}
 		}
 	})
-- 
GitLab


From 92cb157cf3aa51d28e441dbb2b671795f22140f8 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Tue, 29 Dec 2020 22:44:30 -0500
Subject: [PATCH 0526/2400] [dev.regabi] cmd/compile: late expansion of return
 values

By-hand rebase of earlier CL, because that was easier than
letting git try to figure things out.

This will naively insert self-moves; in the case that these
involve memory, the expander detects these and removes them
and their vardefs.

Change-Id: Icf72575eb7ae4a186b0de462bc8cf0bedc84d3e9
Reviewed-on: https://go-review.googlesource.com/c/go/+/279519
Trust: David Chase <drchase@google.com>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
---
 src/cmd/compile/internal/ir/fmt.go           |  5 ++
 src/cmd/compile/internal/ssa/expand_calls.go | 78 ++++++++++++++++----
 src/cmd/compile/internal/ssa/func.go         |  6 +-
 src/cmd/compile/internal/ssa/op.go           | 10 ++-
 src/cmd/compile/internal/ssagen/ssa.go       | 77 ++++++++++++++-----
 5 files changed, 138 insertions(+), 38 deletions(-)

diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 0ebfb84286..01197ad272 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -1119,6 +1119,11 @@ func dumpNode(w io.Writer, n Node, depth int) {
 		return
 	}
 
+	if n == nil {
+		fmt.Fprint(w, "NilIrNode")
+		return
+	}
+
 	if len(n.Init()) != 0 {
 		fmt.Fprintf(w, "%+v-init", n.Op())
 		dumpNodes(w, n.Init(), depth+1)
diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index e1c657d4a4..66ef1b3515 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -24,6 +24,10 @@ type offsetKey struct {
 	pt     *types.Type
 }
 
+func isBlockMultiValueExit(b *Block) bool {
+	return (b.Kind == BlockRet || b.Kind == BlockRetJmp) && len(b.Controls) > 0 && b.Controls[0].Op == OpMakeResult
+}
+
 // expandCalls converts LE (Late Expansion) calls that act like they receive value args into a lower-level form
 // that is more oriented to a platform's ABI.  The SelectN operations that extract results are rewritten into
 // more appropriate forms, and any StructMake or ArrayMake inputs are decomposed until non-struct values are
@@ -624,6 +628,24 @@ func expandCalls(f *Func) {
 		return x
 	}
 
+	rewriteDereference := func(b *Block, base, a, mem *Value, offset, size int64, typ *types.Type, pos src.XPos) *Value {
+		source := a.Args[0]
+		dst := offsetFrom(base, offset, source.Type)
+		if a.Uses == 1 && a.Block == b {
+			a.reset(OpMove)
+			a.Pos = pos
+			a.Type = types.TypeMem
+			a.Aux = typ
+			a.AuxInt = size
+			a.SetArgs3(dst, source, mem)
+			mem = a
+		} else {
+			mem = b.NewValue3A(pos, OpMove, types.TypeMem, typ, dst, source, mem)
+			mem.AuxInt = size
+		}
+		return mem
+	}
+
 	// rewriteArgs removes all the Args from a call and converts the call args into appropriate
 	// stores (or later, register movement).  Extra args for interface and closure calls are ignored,
 	// but removed.
@@ -631,7 +653,7 @@ func expandCalls(f *Func) {
 		// Thread the stores on the memory arg
 		aux := v.Aux.(*AuxCall)
 		pos := v.Pos.WithNotStmt()
-		m0 := v.Args[len(v.Args)-1]
+		m0 := v.MemoryArg()
 		mem := m0
 		for i, a := range v.Args {
 			if i < firstArg {
@@ -647,20 +669,7 @@ func expandCalls(f *Func) {
 				}
 				// "Dereference" of addressed (probably not-SSA-eligible) value becomes Move
 				// TODO this will be more complicated with registers in the picture.
-				source := a.Args[0]
-				dst := f.ConstOffPtrSP(source.Type, aux.OffsetOfArg(auxI), sp)
-				if a.Uses == 1 && a.Block == v.Block {
-					a.reset(OpMove)
-					a.Pos = pos
-					a.Type = types.TypeMem
-					a.Aux = aux.TypeOfArg(auxI)
-					a.AuxInt = aux.SizeOfArg(auxI)
-					a.SetArgs3(dst, source, mem)
-					mem = a
-				} else {
-					mem = v.Block.NewValue3A(pos, OpMove, types.TypeMem, aux.TypeOfArg(auxI), dst, source, mem)
-					mem.AuxInt = aux.SizeOfArg(auxI)
-				}
+				mem = rewriteDereference(v.Block, sp, a, mem, aux.OffsetOfArg(auxI), aux.SizeOfArg(auxI), aux.TypeOfArg(auxI), pos)
 			} else {
 				if debug {
 					fmt.Printf("storeArg %s, %v, %d\n", a.LongString(), aux.TypeOfArg(auxI), aux.OffsetOfArg(auxI))
@@ -692,6 +701,45 @@ func expandCalls(f *Func) {
 				v.SetArgs2(code, mem)
 			}
 		}
+		if isBlockMultiValueExit(b) {
+			// Very similar to code in rewriteArgs, but results instead of args.
+			v := b.Controls[0]
+			m0 := v.MemoryArg()
+			mem := m0
+			aux := f.OwnAux
+			pos := v.Pos.WithNotStmt()
+			for j, a := range v.Args {
+				i := int64(j)
+				if a == m0 {
+					break
+				}
+				auxType := aux.TypeOfResult(i)
+				auxBase := b.NewValue2A(v.Pos, OpLocalAddr, types.NewPtr(auxType), aux.results[i].Name, sp, mem)
+				auxOffset := int64(0)
+				auxSize := aux.SizeOfResult(i)
+				if a.Op == OpDereference {
+					// Avoid a self-move, and if one is detected try to remove the already-inserted VarDef for the assignment that won't happen.
+					if dAddr, dMem := a.Args[0], a.Args[1]; dAddr.Op == OpLocalAddr && dAddr.Args[0].Op == OpSP &&
+						dAddr.Args[1] == dMem && dAddr.Aux == aux.results[i].Name {
+						if dMem.Op == OpVarDef && dMem.Aux == dAddr.Aux {
+							dMem.copyOf(dMem.MemoryArg()) // elide the VarDef
+						}
+						continue
+					}
+					mem = rewriteDereference(v.Block, auxBase, a, mem, auxOffset, auxSize, auxType, pos)
+				} else {
+					if a.Op == OpLoad && a.Args[0].Op == OpLocalAddr {
+						addr := a.Args[0]
+						if addr.MemoryArg() == a.MemoryArg() && addr.Aux == aux.results[i].Name {
+							continue
+						}
+					}
+					mem = storeArgOrLoad(v.Pos, b, auxBase, a, mem, aux.TypeOfResult(i), auxOffset)
+				}
+			}
+			b.SetControl(mem)
+			v.reset(OpInvalid) // otherwise it can have a mem operand which will fail check(), even though it is dead.
+		}
 	}
 
 	for i, name := range f.Names {
diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go
index f753b4407b..de99a8d4af 100644
--- a/src/cmd/compile/internal/ssa/func.go
+++ b/src/cmd/compile/internal/ssa/func.go
@@ -60,6 +60,8 @@ type Func struct {
 
 	// RegArgs is a slice of register-memory pairs that must be spilled and unspilled in the uncommon path of function entry.
 	RegArgs []ArgPair
+	// AuxCall describing parameters and results for this function.
+	OwnAux *AuxCall
 
 	// WBLoads is a list of Blocks that branch on the write
 	// barrier flag. Safe-points are disabled from the OpLoad that
@@ -774,7 +776,7 @@ func DebugNameMatch(evname, name string) bool {
 }
 
 func (f *Func) spSb() (sp, sb *Value) {
-	initpos := f.Entry.Pos
+	initpos := src.NoXPos // These are originally created with no position in ssa.go; if they are optimized out then recreated, should be the same.
 	for _, v := range f.Entry.Values {
 		if v.Op == OpSB {
 			sb = v
@@ -783,7 +785,7 @@ func (f *Func) spSb() (sp, sb *Value) {
 			sp = v
 		}
 		if sb != nil && sp != nil {
-			break
+			return
 		}
 	}
 	if sb == nil {
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index 5e6ce2b508..c64b145107 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -5,6 +5,7 @@
 package ssa
 
 import (
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"fmt"
@@ -70,7 +71,8 @@ type auxType int8
 
 type Param struct {
 	Type   *types.Type
-	Offset int32 // TODO someday this will be a register
+	Offset int32    // Offset of Param if not in a register.
+	Name   *ir.Name // For OwnAux, need to prepend stores with Vardefs
 }
 
 type AuxCall struct {
@@ -199,6 +201,12 @@ func ClosureAuxCall(args []Param, results []Param) *AuxCall {
 
 func (*AuxCall) CanBeAnSSAAux() {}
 
+// OwnAuxCall returns a function's own AuxCall
+func OwnAuxCall(args []Param, results []Param) *AuxCall {
+	// TODO if this remains identical to ClosureAuxCall above after new ABI is done, should deduplicate.
+	return &AuxCall{Fn: nil, args: args, results: results}
+}
+
 const (
 	auxNone         auxType = iota
 	auxBool                 // auxInt is 0/1 for false/true
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 8ed0e6101c..5ba8579f6a 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -459,7 +459,7 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 			args = append(args, ssa.Param{Type: n.Type(), Offset: int32(n.FrameOffset())})
 		case ir.PPARAMOUT:
 			s.decladdrs[n] = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(n.Type()), n, s.sp, s.startmem)
-			results = append(results, ssa.Param{Type: n.Type(), Offset: int32(n.FrameOffset())})
+			results = append(results, ssa.Param{Type: n.Type(), Offset: int32(n.FrameOffset()), Name: n})
 		case ir.PAUTO:
 			// processed at each use, to prevent Addr coming
 			// before the decl.
@@ -467,6 +467,7 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 			s.Fatalf("local variable with class %v unimplemented", n.Class)
 		}
 	}
+	s.f.OwnAux = ssa.OwnAuxCall(args, results)
 
 	// Populate SSAable arguments.
 	for _, n := range fn.Dcl {
@@ -532,6 +533,8 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 		}
 	}
 
+	s.f.HTMLWriter.WritePhase("before insert phis", "before insert phis")
+
 	s.insertPhis()
 
 	// Main call to ssa package to compile function
@@ -1799,6 +1802,7 @@ const shareDeferExits = false
 // It returns a BlockRet block that ends the control flow. Its control value
 // will be set to the final memory state.
 func (s *state) exit() *ssa.Block {
+	lateResultLowering := s.f.DebugTest && ssa.LateCallExpansionEnabledWithin(s.f)
 	if s.hasdefer {
 		if s.hasOpenDefers {
 			if shareDeferExits && s.lastDeferExit != nil && len(s.openDefers) == s.lastDeferCount {
@@ -1815,28 +1819,61 @@ func (s *state) exit() *ssa.Block {
 		}
 	}
 
-	// Store SSAable and heap-escaped PPARAMOUT variables back to stack locations.
-	for _, f := range s.curfn.Type().Results().FieldSlice() {
-		n := f.Nname.(*ir.Name)
-		if s.canSSA(n) {
-			val := s.variable(n, n.Type())
-			s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
-			s.store(n.Type(), s.decladdrs[n], val)
-		} else if !n.OnStack() {
+	var b *ssa.Block
+	var m *ssa.Value
+	// Do actual return.
+	// These currently turn into self-copies (in many cases).
+	if lateResultLowering {
+		resultFields := s.curfn.Type().Results().FieldSlice()
+		results := make([]*ssa.Value, len(resultFields)+1, len(resultFields)+1)
+		m = s.newValue0(ssa.OpMakeResult, s.f.OwnAux.LateExpansionResultType())
+		// Store SSAable and heap-escaped PPARAMOUT variables back to stack locations.
+		for i, f := range resultFields {
+			n := f.Nname.(*ir.Name)
 			s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
-			s.move(n.Type(), s.decladdrs[n], s.expr(n.Heapaddr))
+			if s.canSSA(n) { // result is in some SSA variable
+				results[i] = s.variable(n, n.Type())
+			} else if !n.OnStack() { // result is actually heap allocated
+				ha := s.expr(n.Heapaddr)
+				s.instrumentFields(n.Type(), ha, instrumentRead)
+				results[i] = s.newValue2(ssa.OpDereference, n.Type(), ha, s.mem())
+			} else { // result is not SSA-able; not escaped, so not on heap, but too large for SSA.
+				// Before register ABI this ought to be a self-move, home=dest,
+				// With register ABI, it's still a self-move if parameter is on stack (i.e., too big or overflowed)
+				results[i] = s.newValue2(ssa.OpDereference, n.Type(), s.addr(n), s.mem())
+			}
 		}
-		// TODO: if val is ever spilled, we'd like to use the
-		// PPARAMOUT slot for spilling it. That won't happen
-		// currently.
-	}
 
-	// Run exit code. Today, this is just raceexit, in -race mode.
-	s.stmtList(s.curfn.Exit)
+		// Run exit code. Today, this is just racefuncexit, in -race mode.
+		// TODO this seems risky here with a register-ABI, but not clear it is right to do it earlier either.
+		// Spills in register allocation might just fix it.
+		s.stmtList(s.curfn.Exit)
 
-	// Do actual return.
-	m := s.mem()
-	b := s.endBlock()
+		results[len(results)-1] = s.mem()
+		m.AddArgs(results...)
+	} else {
+		// Store SSAable and heap-escaped PPARAMOUT variables back to stack locations.
+		for _, f := range s.curfn.Type().Results().FieldSlice() {
+			n := f.Nname.(*ir.Name)
+			if s.canSSA(n) {
+				val := s.variable(n, n.Type())
+				s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
+				s.store(n.Type(), s.decladdrs[n], val)
+			} else if !n.OnStack() {
+				s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
+				s.move(n.Type(), s.decladdrs[n], s.expr(n.Heapaddr))
+			} // else, on stack but too large to SSA, the result is already in its destination by construction, so no store needed.
+
+			// TODO: if (SSA) val is ever spilled, we'd like to use the PPARAMOUT slot for spilling it. That won't happen currently.
+		}
+
+		// Run exit code. Today, this is just racefuncexit, in -race mode.
+		s.stmtList(s.curfn.Exit)
+
+		// Do actual return.
+		m = s.mem()
+	}
+	b = s.endBlock()
 	b.Kind = ssa.BlockRet
 	b.SetControl(m)
 	if s.hasdefer && s.hasOpenDefers {
@@ -5253,7 +5290,7 @@ func (s *state) canSSAName(name *ir.Name) bool {
 	// TODO: try to make more variables SSAable?
 }
 
-// canSSA reports whether variables of type t are SSA-able.
+// TypeOK reports whether variables of type t are SSA-able.
 func TypeOK(t *types.Type) bool {
 	types.CalcSize(t)
 	if t.Width > int64(4*types.PtrSize) {
-- 
GitLab


From 89ec17be9a28e07f59aaaa9acd1d26f80c55711f Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 20 Jan 2021 13:54:53 -0800
Subject: [PATCH 0527/2400] [dev.typeparams] cmd/compile: simplify how irgen
 handles qualified idents

This CL moves qualified identifier handling into expr0 with other
selector expressions, rather than as a completely separate special
case handled up front. This has a few benefits:

1. It's marginally simpler/cleaner.

2. It allows extra checking for imported objects that they have the
same type that types2 thought they had.

3. For imported, untyped constants, we now instead handle them with
the "tv.Value != nil" case. In particular, this ensures that they've
always already been coerced to the appropriate concrete type by
types2.

Change-Id: Ibf44ae6901db36aa5251f70934616e9fcbd1cbc5
Reviewed-on: https://go-review.googlesource.com/c/go/+/285053
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/expr.go | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index fba6ad2e4b..d5177ead06 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -27,15 +27,6 @@ func (g *irgen) expr(expr syntax.Expr) ir.Node {
 		return ir.BlankNode
 	}
 
-	// TODO(mdempsky): Is there a better way to recognize and handle qualified identifiers?
-	if expr, ok := expr.(*syntax.SelectorExpr); ok {
-		if name, ok := expr.X.(*syntax.Name); ok {
-			if _, ok := g.info.Uses[name].(*types2.PkgName); ok {
-				return g.use(expr.Sel)
-			}
-		}
-	}
-
 	tv, ok := g.info.Types[expr]
 	if !ok {
 		base.FatalfAt(g.pos(expr), "missing type for %v (%T)", expr, expr)
@@ -89,6 +80,13 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 	case *syntax.ParenExpr:
 		return g.expr(expr.X) // skip parens; unneeded after parse+typecheck
 	case *syntax.SelectorExpr:
+		// Qualified identifier.
+		if name, ok := expr.X.(*syntax.Name); ok {
+			if _, ok := g.info.Uses[name].(*types2.PkgName); ok {
+				return g.use(expr.Sel)
+			}
+		}
+
 		// TODO(mdempsky/danscales): Use g.info.Selections[expr]
 		// to resolve field/method selection. See CL 280633.
 		return ir.NewSelectorExpr(pos, ir.OXDOT, g.expr(expr.X), g.name(expr.Sel))
-- 
GitLab


From 1760d736f61265b3c78a6a48f2e1904341806643 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Tue, 1 Dec 2020 14:48:03 -0800
Subject: [PATCH 0528/2400] [dev.regabi] cmd/compile: exporting, importing, and
 inlining functions with OCLOSURE

I have exporting, importing, and inlining of functions with closures
working in all cases (issue #28727). all.bash runs successfully without
errors.

Approach:
  - Write out the Func type, Dcls, ClosureVars, and Body when exporting
    an OCLOSURE.

  - When importing an OCLOSURE, read in the type, dcls, closure vars,
    and body, and then do roughly equivalent code to (*noder).funcLit

  - During inlining of a closure within inlined function, create new
    nodes for all params and local variables (including closure
    variables), so they can have a new Curfn and some other field
    values. Must substitute not only on the Nbody of the closure, but
    also the Type, Cvars, and Dcl fields.

Fixes #28727

Change-Id: I4da1e2567c3fa31a5121afbe82dc4e5ee32b3170
Reviewed-on: https://go-review.googlesource.com/c/go/+/283112
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Trust: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/escape/escape.go     |   4 +
 src/cmd/compile/internal/inline/inl.go        | 264 ++++++++++++++++--
 src/cmd/compile/internal/ir/fmt.go            |  21 ++
 src/cmd/compile/internal/ir/node.go           |   4 +
 src/cmd/compile/internal/noder/noder.go       |   8 +
 src/cmd/compile/internal/typecheck/func.go    |  22 +-
 src/cmd/compile/internal/typecheck/iexport.go |  49 +++-
 src/cmd/compile/internal/typecheck/iimport.go |  85 ++++--
 test/closure3.dir/main.go                     |  44 +--
 test/closure5.dir/a.go                        |  11 +
 test/closure5.dir/main.go                     |  15 +
 test/closure5.go                              |  10 +
 test/inline.go                                |  22 +-
 13 files changed, 472 insertions(+), 87 deletions(-)
 create mode 100644 test/closure5.dir/a.go
 create mode 100644 test/closure5.dir/main.go
 create mode 100644 test/closure5.go

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index 5ee6d4f498..883e68a730 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -218,6 +218,10 @@ func Batch(fns []*ir.Func, recursive bool) {
 
 	// Construct data-flow graph from syntax trees.
 	for _, fn := range fns {
+		if base.Flag.W > 1 {
+			s := fmt.Sprintf("\nbefore escape %v", fn)
+			ir.Dump(s, fn)
+		}
 		b.initFunc(fn)
 	}
 	for _, fn := range fns {
diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index aa194ebab2..7778bc56c4 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -180,7 +180,7 @@ func CanInline(fn *ir.Func) {
 	n.Func.Inl = &ir.Inline{
 		Cost: inlineMaxBudget - visitor.budget,
 		Dcl:  pruneUnusedAutos(n.Defn.(*ir.Func).Dcl, &visitor),
-		Body: ir.DeepCopyList(src.NoXPos, fn.Body),
+		Body: inlcopylist(fn.Body),
 	}
 
 	if base.Flag.LowerM > 1 {
@@ -217,10 +217,8 @@ func Inline_Flood(n *ir.Name, exportsym func(*ir.Name)) {
 
 	typecheck.ImportedBody(fn)
 
-	// Recursively identify all referenced functions for
-	// reexport. We want to include even non-called functions,
-	// because after inlining they might be callable.
-	ir.VisitList(ir.Nodes(fn.Inl.Body), func(n ir.Node) {
+	var doFlood func(n ir.Node)
+	doFlood = func(n ir.Node) {
 		switch n.Op() {
 		case ir.OMETHEXPR, ir.ODOTMETH:
 			Inline_Flood(ir.MethodExprName(n), exportsym)
@@ -239,15 +237,16 @@ func Inline_Flood(n *ir.Name, exportsym func(*ir.Name)) {
 			// Okay, because we don't yet inline indirect
 			// calls to method values.
 		case ir.OCLOSURE:
-			// If the closure is inlinable, we'll need to
-			// flood it too. But today we don't support
-			// inlining functions that contain closures.
-			//
-			// When we do, we'll probably want:
-			//     inlFlood(n.Func.Closure.Func.Nname)
-			base.Fatalf("unexpected closure in inlinable function")
+			// VisitList doesn't visit closure bodies, so force a
+			// recursive call to VisitList on the body of the closure.
+			ir.VisitList(n.(*ir.ClosureExpr).Func.Body, doFlood)
 		}
-	})
+	}
+
+	// Recursively identify all referenced functions for
+	// reexport. We want to include even non-called functions,
+	// because after inlining they might be callable.
+	ir.VisitList(ir.Nodes(fn.Inl.Body), doFlood)
 }
 
 // hairyVisitor visits a function body to determine its inlining
@@ -360,8 +359,13 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 		// the right panic value, so it needs an argument frame.
 		return errors.New("call to recover")
 
-	case ir.OCLOSURE,
-		ir.ORANGE,
+	case ir.OCLOSURE:
+		// TODO(danscales) - fix some bugs when budget is lowered below 30
+		// Maybe make budget proportional to number of closure variables, e.g.:
+		//v.budget -= int32(len(n.(*ir.ClosureExpr).Func.ClosureVars) * 3)
+		v.budget -= 30
+
+	case ir.ORANGE,
 		ir.OSELECT,
 		ir.OGO,
 		ir.ODEFER,
@@ -449,6 +453,52 @@ func isBigFunc(fn *ir.Func) bool {
 	})
 }
 
+// inlcopylist (together with inlcopy) recursively copies a list of nodes, except
+// that it keeps the same ONAME, OTYPE, and OLITERAL nodes. It is used for copying
+// the body and dcls of an inlineable function.
+func inlcopylist(ll []ir.Node) []ir.Node {
+	s := make([]ir.Node, len(ll))
+	for i, n := range ll {
+		s[i] = inlcopy(n)
+	}
+	return s
+}
+
+// inlcopy is like DeepCopy(), but does extra work to copy closures.
+func inlcopy(n ir.Node) ir.Node {
+	var edit func(ir.Node) ir.Node
+	edit = func(x ir.Node) ir.Node {
+		switch x.Op() {
+		case ir.ONAME, ir.OTYPE, ir.OLITERAL, ir.ONIL:
+			return x
+		}
+		m := ir.Copy(x)
+		ir.EditChildren(m, edit)
+		if x.Op() == ir.OCLOSURE {
+			x := x.(*ir.ClosureExpr)
+			// Need to save/duplicate x.Func.Nname,
+			// x.Func.Nname.Ntype, x.Func.Dcl, x.Func.ClosureVars, and
+			// x.Func.Body for iexport and local inlining.
+			oldfn := x.Func
+			newfn := ir.NewFunc(oldfn.Pos())
+			if oldfn.ClosureCalled() {
+				newfn.SetClosureCalled(true)
+			}
+			m.(*ir.ClosureExpr).Func = newfn
+			newfn.Nname = ir.NewNameAt(oldfn.Nname.Pos(), oldfn.Nname.Sym())
+			// XXX OK to share fn.Type() ??
+			newfn.Nname.SetType(oldfn.Nname.Type())
+			newfn.Nname.Ntype = inlcopy(oldfn.Nname.Ntype).(ir.Ntype)
+			newfn.Body = inlcopylist(oldfn.Body)
+			// Make shallow copy of the Dcl and ClosureVar slices
+			newfn.Dcl = append([]*ir.Name(nil), oldfn.Dcl...)
+			newfn.ClosureVars = append([]*ir.Name(nil), oldfn.ClosureVars...)
+		}
+		return m
+	}
+	return edit(n)
+}
+
 // Inlcalls/nodelist/node walks fn's statements and expressions and substitutes any
 // calls made to inlineable functions. This is the external entry point.
 func InlineCalls(fn *ir.Func) {
@@ -925,6 +975,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 		inlvars:      inlvars,
 		bases:        make(map[*src.PosBase]*src.PosBase),
 		newInlIndex:  newIndex,
+		fn:           fn,
 	}
 	subst.edit = subst.node
 
@@ -1031,6 +1082,12 @@ type inlsubst struct {
 	newInlIndex int
 
 	edit func(ir.Node) ir.Node // cached copy of subst.node method value closure
+
+	// If non-nil, we are inside a closure inside the inlined function, and
+	// newclofn is the Func of the new inlined closure.
+	newclofn *ir.Func
+
+	fn *ir.Func // For debug -- the func that is being inlined
 }
 
 // list inlines a list of nodes.
@@ -1042,6 +1099,157 @@ func (subst *inlsubst) list(ll ir.Nodes) []ir.Node {
 	return s
 }
 
+// fields returns a list of the fields of a struct type representing receiver,
+// params, or results, after duplicating the field nodes and substituting the
+// Nname nodes inside the field nodes.
+func (subst *inlsubst) fields(oldt *types.Type) []*types.Field {
+	oldfields := oldt.FieldSlice()
+	newfields := make([]*types.Field, len(oldfields))
+	for i := range oldfields {
+		newfields[i] = oldfields[i].Copy()
+		if oldfields[i].Nname != nil {
+			newfields[i].Nname = subst.node(oldfields[i].Nname.(*ir.Name))
+		}
+	}
+	return newfields
+}
+
+// clovar creates a new ONAME node for a local variable or param of a closure
+// inside a function being inlined.
+func (subst *inlsubst) clovar(n *ir.Name) *ir.Name {
+	// TODO(danscales): want to get rid of this shallow copy, with code like the
+	// following, but it is hard to copy all the necessary flags in a maintainable way.
+	// m := ir.NewNameAt(n.Pos(), n.Sym())
+	// m.Class = n.Class
+	// m.SetType(n.Type())
+	// m.SetTypecheck(1)
+	//if n.IsClosureVar() {
+	//	m.SetIsClosureVar(true)
+	//}
+	m := &ir.Name{}
+	*m = *n
+	m.Curfn = subst.newclofn
+	if n.Defn != nil && n.Defn.Op() == ir.ONAME {
+		if !n.IsClosureVar() {
+			base.FatalfAt(n.Pos(), "want closure variable, got: %+v", n)
+		}
+		if n.Sym().Pkg != types.LocalPkg {
+			// If the closure came from inlining a function from
+			// another package, must change package of captured
+			// variable to localpkg, so that the fields of the closure
+			// struct are local package and can be accessed even if
+			// name is not exported. If you disable this code, you can
+			// reproduce the problem by running 'go test
+			// go/internal/srcimporter'. TODO(mdempsky) - maybe change
+			// how we create closure structs?
+			m.SetSym(types.LocalPkg.Lookup(n.Sym().Name))
+		}
+		// Make sure any inlvar which is the Defn
+		// of an ONAME closure var is rewritten
+		// during inlining. Don't substitute
+		// if Defn node is outside inlined function.
+		if subst.inlvars[n.Defn.(*ir.Name)] != nil {
+			m.Defn = subst.node(n.Defn)
+		}
+	}
+	if n.Outer != nil {
+		// Either the outer variable is defined in function being inlined,
+		// and we will replace it with the substituted variable, or it is
+		// defined outside the function being inlined, and we should just
+		// skip the outer variable (the closure variable of the function
+		// being inlined).
+		s := subst.node(n.Outer).(*ir.Name)
+		if s == n.Outer {
+			s = n.Outer.Outer
+		}
+		m.Outer = s
+	}
+	return m
+}
+
+// closure does the necessary substitions for a ClosureExpr n and returns the new
+// closure node.
+func (subst *inlsubst) closure(n *ir.ClosureExpr) ir.Node {
+	m := ir.Copy(n)
+	m.SetPos(subst.updatedPos(m.Pos()))
+	ir.EditChildren(m, subst.edit)
+
+	//fmt.Printf("Inlining func %v with closure into %v\n", subst.fn, ir.FuncName(ir.CurFunc))
+
+	// The following is similar to funcLit
+	oldfn := n.Func
+	newfn := ir.NewFunc(oldfn.Pos())
+	// These three lines are not strictly necessary, but just to be clear
+	// that new function needs to redo typechecking and inlinability.
+	newfn.SetTypecheck(0)
+	newfn.SetInlinabilityChecked(false)
+	newfn.Inl = nil
+	newfn.SetIsHiddenClosure(true)
+	newfn.Nname = ir.NewNameAt(n.Pos(), ir.BlankNode.Sym())
+	newfn.Nname.Func = newfn
+	newfn.Nname.Ntype = subst.node(oldfn.Nname.Ntype).(ir.Ntype)
+	newfn.Nname.Defn = newfn
+
+	m.(*ir.ClosureExpr).Func = newfn
+	newfn.OClosure = m.(*ir.ClosureExpr)
+
+	if subst.newclofn != nil {
+		//fmt.Printf("Inlining a closure with a nested closure\n")
+	}
+	prevxfunc := subst.newclofn
+
+	// Mark that we are now substituting within a closure (within the
+	// inlined function), and create new nodes for all the local
+	// vars/params inside this closure.
+	subst.newclofn = newfn
+	newfn.Dcl = nil
+	newfn.ClosureVars = nil
+	for _, oldv := range oldfn.Dcl {
+		newv := subst.clovar(oldv)
+		subst.inlvars[oldv] = newv
+		newfn.Dcl = append(newfn.Dcl, newv)
+	}
+	for _, oldv := range oldfn.ClosureVars {
+		newv := subst.clovar(oldv)
+		subst.inlvars[oldv] = newv
+		newfn.ClosureVars = append(newfn.ClosureVars, newv)
+	}
+
+	// Need to replace ONAME nodes in
+	// newfn.Type().FuncType().Receiver/Params/Results.FieldSlice().Nname
+	oldt := oldfn.Type()
+	newrecvs := subst.fields(oldt.Recvs())
+	var newrecv *types.Field
+	if len(newrecvs) > 0 {
+		newrecv = newrecvs[0]
+	}
+	newt := types.NewSignature(oldt.Pkg(), newrecv,
+		subst.fields(oldt.Params()), subst.fields(oldt.Results()))
+
+	newfn.Nname.SetType(newt)
+	newfn.Body = subst.list(oldfn.Body)
+
+	// Remove the nodes for the current closure from subst.inlvars
+	for _, oldv := range oldfn.Dcl {
+		delete(subst.inlvars, oldv)
+	}
+	for _, oldv := range oldfn.ClosureVars {
+		delete(subst.inlvars, oldv)
+	}
+	// Go back to previous closure func
+	subst.newclofn = prevxfunc
+
+	// Actually create the named function for the closure, now that
+	// the closure is inlined in a specific function.
+	m.SetTypecheck(0)
+	if oldfn.ClosureCalled() {
+		typecheck.Callee(m)
+	} else {
+		typecheck.Expr(m)
+	}
+	return m
+}
+
 // node recursively copies a node from the saved pristine body of the
 // inlined function, substituting references to input/output
 // parameters with ones to the tmpnames, and substituting returns with
@@ -1056,13 +1264,17 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 		n := n.(*ir.Name)
 
 		// Handle captured variables when inlining closures.
-		if n.IsClosureVar() {
+		if n.IsClosureVar() && subst.newclofn == nil {
 			o := n.Outer
 
+			// Deal with case where sequence of closures are inlined.
+			// TODO(danscales) - write test case to see if we need to
+			// go up multiple levels.
+			if o.Curfn != ir.CurFunc {
+				o = o.Outer
+			}
+
 			// make sure the outer param matches the inlining location
-			// NB: if we enabled inlining of functions containing OCLOSURE or refined
-			// the reassigned check via some sort of copy propagation this would most
-			// likely need to be changed to a loop to walk up to the correct Param
 			if o == nil || o.Curfn != ir.CurFunc {
 				base.Fatalf("%v: unresolvable capture %v\n", ir.Line(n), n)
 			}
@@ -1098,6 +1310,10 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 		}
 
 	case ir.ORETURN:
+		if subst.newclofn != nil {
+			// Don't do special substitutions if inside a closure
+			break
+		}
 		// Since we don't handle bodies with closures,
 		// this return is guaranteed to belong to the current inlined function.
 		n := n.(*ir.ReturnStmt)
@@ -1136,6 +1352,10 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 		return m
 
 	case ir.OLABEL:
+		if subst.newclofn != nil {
+			// Don't do special substitutions if inside a closure
+			break
+		}
 		n := n.(*ir.LabelStmt)
 		m := ir.Copy(n).(*ir.LabelStmt)
 		m.SetPos(subst.updatedPos(m.Pos()))
@@ -1143,10 +1363,10 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 		p := fmt.Sprintf("%s·%d", n.Label.Name, inlgen)
 		m.Label = typecheck.Lookup(p)
 		return m
-	}
 
-	if n.Op() == ir.OCLOSURE {
-		base.Fatalf("cannot inline function containing closure: %+v", n)
+	case ir.OCLOSURE:
+		return subst.closure(n.(*ir.ClosureExpr))
+
 	}
 
 	m := ir.Copy(n)
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 01197ad272..1a05079dac 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -1020,6 +1020,15 @@ func dumpNodeHeader(w io.Writer, n Node) {
 		fmt.Fprintf(w, " defn(%p)", n.Name().Defn)
 	}
 
+	if base.Debug.DumpPtrs != 0 && n.Name() != nil && n.Name().Curfn != nil {
+		// Useful to see where Defn is set and what node it points to
+		fmt.Fprintf(w, " curfn(%p)", n.Name().Curfn)
+	}
+	if base.Debug.DumpPtrs != 0 && n.Name() != nil && n.Name().Outer != nil {
+		// Useful to see where Defn is set and what node it points to
+		fmt.Fprintf(w, " outer(%p)", n.Name().Outer)
+	}
+
 	if EscFmt != nil {
 		if esc := EscFmt(n); esc != "" {
 			fmt.Fprintf(w, " %s", esc)
@@ -1187,6 +1196,18 @@ func dumpNode(w io.Writer, n Node, depth int) {
 				dumpNode(w, dcl, depth+1)
 			}
 		}
+		if len(fn.ClosureVars) > 0 {
+			indent(w, depth)
+			fmt.Fprintf(w, "%+v-ClosureVars", n.Op())
+			for _, cv := range fn.ClosureVars {
+				dumpNode(w, cv, depth+1)
+			}
+		}
+		if len(fn.Enter) > 0 {
+			indent(w, depth)
+			fmt.Fprintf(w, "%+v-Enter", n.Op())
+			dumpNodes(w, fn.Enter, depth+1)
+		}
 		if len(fn.Body) > 0 {
 			indent(w, depth)
 			fmt.Fprintf(w, "%+v-body", n.Op())
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 291e1286bb..ffa7daf6b2 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -291,6 +291,10 @@ const (
 	OTSLICE // []int
 
 	// misc
+	// intermediate representation of an inlined call.  Uses Init (assignments
+	// for the captured variables, parameters, retvars, & INLMARK op),
+	// Body (body of the inlined function), and ReturnVars (list of
+	// return values)
 	OINLCALL       // intermediary representation of an inlined call.
 	OEFACE         // itable and data words of an empty-interface value.
 	OITAB          // itable word of an interface value.
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 99c0e4adde..0ea72a28dc 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -142,7 +142,15 @@ func Package() {
 	for i := 0; i < len(typecheck.Target.Decls); i++ {
 		n := typecheck.Target.Decls[i]
 		if n.Op() == ir.ODCLFUNC {
+			if base.Flag.W > 1 {
+				s := fmt.Sprintf("\nbefore typecheck %v", n)
+				ir.Dump(s, n)
+			}
 			typecheck.FuncBody(n.(*ir.Func))
+			if base.Flag.W > 1 {
+				s := fmt.Sprintf("\nafter typecheck %v", n)
+				ir.Dump(s, n)
+			}
 			fcount++
 		}
 	}
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index b576590d4d..f624773c8f 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -145,7 +145,7 @@ func ImportedBody(fn *ir.Func) {
 	// declarations are added to fn.Func.Dcl by funcBody(). Move them
 	// to fn.Func.Inl.Dcl for consistency with how local functions
 	// behave. (Append because ImportedBody may be called multiple
-	// times.)
+	// times on same fn.)
 	fn.Inl.Dcl = append(fn.Inl.Dcl, fn.Dcl...)
 	fn.Dcl = nil
 
@@ -303,8 +303,15 @@ func tcClosure(clo *ir.ClosureExpr, top int) {
 		return
 	}
 
-	fn.Nname.SetSym(closurename(ir.CurFunc))
-	ir.MarkFunc(fn.Nname)
+	// Don't give a name and add to xtop if we are typechecking an inlined
+	// body in ImportedBody(), since we only want to create the named function
+	// when the closure is actually inlined (and then we force a typecheck
+	// explicitly in (*inlsubst).node()).
+	inTypeCheckInl := ir.CurFunc != nil && ir.CurFunc.Body == nil
+	if !inTypeCheckInl {
+		fn.Nname.SetSym(closurename(ir.CurFunc))
+		ir.MarkFunc(fn.Nname)
+	}
 	Func(fn)
 	clo.SetType(fn.Type())
 
@@ -338,7 +345,14 @@ func tcClosure(clo *ir.ClosureExpr, top int) {
 	}
 	fn.ClosureVars = fn.ClosureVars[:out]
 
-	Target.Decls = append(Target.Decls, fn)
+	if base.Flag.W > 1 {
+		s := fmt.Sprintf("New closure func: %s", ir.FuncName(fn))
+		ir.Dump(s, fn)
+	}
+	if !inTypeCheckInl {
+		// Add function to xtop once only when we give it a name
+		Target.Decls = append(Target.Decls, fn)
+	}
 }
 
 // type check function definition
diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index 1ba8771139..be4a689836 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -423,9 +423,13 @@ type exportWriter struct {
 	prevLine   int64
 	prevColumn int64
 
-	// dclIndex maps function-scoped declarations to their index
-	// within their respective Func's Dcl list.
-	dclIndex map[*ir.Name]int
+	// dclIndex maps function-scoped declarations to an int used to refer to
+	// them later in the function. For local variables/params, the int is
+	// non-negative and in order of the appearance in the Func's Dcl list. For
+	// closure variables, the index is negative starting at -2.
+	dclIndex           map[*ir.Name]int
+	maxDclIndex        int
+	maxClosureVarIndex int
 }
 
 func (p *iexporter) doDecl(n *ir.Name) {
@@ -1038,14 +1042,19 @@ func (w *exportWriter) typeExt(t *types.Type) {
 
 // Inline bodies.
 
-func (w *exportWriter) funcBody(fn *ir.Func) {
-	w.int64(int64(len(fn.Inl.Dcl)))
-	for i, n := range fn.Inl.Dcl {
+func (w *exportWriter) writeNames(dcl []*ir.Name) {
+	w.int64(int64(len(dcl)))
+	for i, n := range dcl {
 		w.pos(n.Pos())
 		w.localIdent(n.Sym())
 		w.typ(n.Type())
-		w.dclIndex[n] = i
+		w.dclIndex[n] = w.maxDclIndex + i
 	}
+	w.maxDclIndex += len(dcl)
+}
+
+func (w *exportWriter) funcBody(fn *ir.Func) {
+	w.writeNames(fn.Inl.Dcl)
 
 	w.stmtList(fn.Inl.Body)
 }
@@ -1315,8 +1324,30 @@ func (w *exportWriter) expr(n ir.Node) {
 	// case OTARRAY, OTMAP, OTCHAN, OTSTRUCT, OTINTER, OTFUNC:
 	// 	should have been resolved by typechecking - handled by default case
 
-	// case OCLOSURE:
-	//	unimplemented - handled by default case
+	case ir.OCLOSURE:
+		n := n.(*ir.ClosureExpr)
+		w.op(ir.OCLOSURE)
+		w.pos(n.Pos())
+		w.signature(n.Type())
+
+		// Write out id for the Outer of each conditional variable. The
+		// conditional variable itself for this closure will be re-created
+		// during import.
+		w.int64(int64(len(n.Func.ClosureVars)))
+		for i, cv := range n.Func.ClosureVars {
+			w.pos(cv.Pos())
+			w.localName(cv.Outer)
+			// Closure variable (which will be re-created during
+			// import) is given via a negative id, starting at -2,
+			// which is used to refer to it later in the function
+			// during export. -1 represents blanks.
+			w.dclIndex[cv] = -(i + 2) - w.maxClosureVarIndex
+		}
+		w.maxClosureVarIndex += len(n.Func.ClosureVars)
+
+		// like w.funcBody(n.Func), but not for .Inl
+		w.writeNames(n.Func.Dcl)
+		w.stmtList(n.Func.Body)
 
 	// case OCOMPLIT:
 	// 	should have been resolved by typechecking - handled by default case
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index c2610229ec..f2682257f3 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -265,6 +265,9 @@ type importReader struct {
 
 	// curfn is the current function we're importing into.
 	curfn *ir.Func
+	// Slice of all dcls for function, including any interior closures
+	allDcls        []*ir.Name
+	allClosureVars []*ir.Name
 }
 
 func (p *iimporter) newReader(off uint64, pkg *types.Pkg) *importReader {
@@ -721,6 +724,7 @@ func (r *importReader) doInline(fn *ir.Func) {
 		base.Fatalf("%v already has inline body", fn)
 	}
 
+	//fmt.Printf("Importing %v\n", n)
 	r.funcBody(fn)
 
 	importlist = append(importlist, fn)
@@ -754,6 +758,24 @@ func (r *importReader) funcBody(fn *ir.Func) {
 	r.curfn = fn
 
 	// Import local declarations.
+	fn.Inl.Dcl = r.readFuncDcls(fn)
+
+	// Import function body.
+	body := r.stmtList()
+	if body == nil {
+		// Make sure empty body is not interpreted as
+		// no inlineable body (see also parser.fnbody)
+		// (not doing so can cause significant performance
+		// degradation due to unnecessary calls to empty
+		// functions).
+		body = []ir.Node{}
+	}
+	fn.Inl.Body = body
+
+	r.curfn = outerfn
+}
+
+func (r *importReader) readNames(fn *ir.Func) []*ir.Name {
 	dcls := make([]*ir.Name, r.int64())
 	for i := range dcls {
 		n := ir.NewDeclNameAt(r.pos(), ir.ONAME, r.localIdent())
@@ -762,7 +784,12 @@ func (r *importReader) funcBody(fn *ir.Func) {
 		n.SetType(r.typ())
 		dcls[i] = n
 	}
-	fn.Inl.Dcl = dcls
+	r.allDcls = append(r.allDcls, dcls...)
+	return dcls
+}
+
+func (r *importReader) readFuncDcls(fn *ir.Func) []*ir.Name {
+	dcls := r.readNames(fn)
 
 	// Fixup parameter classes and associate with their
 	// signature's type fields.
@@ -787,28 +814,18 @@ func (r *importReader) funcBody(fn *ir.Func) {
 	for _, f := range typ.Results().FieldSlice() {
 		fix(f, ir.PPARAMOUT)
 	}
-
-	// Import function body.
-	body := r.stmtList()
-	if body == nil {
-		// Make sure empty body is not interpreted as
-		// no inlineable body (see also parser.fnbody)
-		// (not doing so can cause significant performance
-		// degradation due to unnecessary calls to empty
-		// functions).
-		body = []ir.Node{}
-	}
-	fn.Inl.Body = body
-
-	r.curfn = outerfn
+	return dcls
 }
 
 func (r *importReader) localName() *ir.Name {
 	i := r.int64()
-	if i < 0 {
+	if i == -1 {
 		return ir.BlankNode.(*ir.Name)
 	}
-	return r.curfn.Inl.Dcl[i]
+	if i < 0 {
+		return r.allClosureVars[-i-2]
+	}
+	return r.allDcls[i]
 }
 
 func (r *importReader) stmtList() []ir.Node {
@@ -924,8 +941,38 @@ func (r *importReader) node() ir.Node {
 	// case OTARRAY, OTMAP, OTCHAN, OTSTRUCT, OTINTER, OTFUNC:
 	//      unreachable - should have been resolved by typechecking
 
-	// case OCLOSURE:
-	//	unimplemented
+	case ir.OCLOSURE:
+		//println("Importing CLOSURE")
+		pos := r.pos()
+		typ := r.signature(nil)
+
+		// All the remaining code below is similar to (*noder).funcLit(), but
+		// with Dcls and ClosureVars lists already set up
+		fn := ir.NewFunc(pos)
+		fn.SetIsHiddenClosure(true)
+		fn.Nname = ir.NewNameAt(pos, ir.BlankNode.Sym())
+		fn.Nname.Func = fn
+		fn.Nname.Ntype = ir.TypeNode(typ)
+		fn.Nname.Defn = fn
+		fn.Nname.SetType(typ)
+
+		cvars := make([]*ir.Name, r.int64())
+		for i := range cvars {
+			cvars[i] = ir.CaptureName(r.pos(), fn, r.localName().Canonical())
+		}
+		fn.ClosureVars = cvars
+		r.allClosureVars = append(r.allClosureVars, cvars...)
+
+		fn.Dcl = r.readFuncDcls(fn)
+		body := r.stmtList()
+		ir.FinishCaptureNames(pos, r.curfn, fn)
+
+		clo := ir.NewClosureExpr(pos, fn)
+		fn.OClosure = clo
+
+		fn.Body = body
+
+		return clo
 
 	// case OPTRLIT:
 	//	unreachable - mapped to case OADDR below by exporter
diff --git a/test/closure3.dir/main.go b/test/closure3.dir/main.go
index e8e1e99860..2fc33753ed 100644
--- a/test/closure3.dir/main.go
+++ b/test/closure3.dir/main.go
@@ -93,11 +93,11 @@ func main() {
 		y := func(x int) int { // ERROR "can inline main.func11" "func literal does not escape"
 			return x + 2
 		}
-		y, sink = func() (func(int) int, int) { // ERROR "func literal does not escape"
-			return func(x int) int { // ERROR "can inline main.func12" "func literal escapes"
+		y, sink = func() (func(int) int, int) { // ERROR "can inline main.func12"
+			return func(x int) int { // ERROR "can inline main.func12"
 				return x + 1
 			}, 42
-		}()
+		}() // ERROR "func literal does not escape" "inlining call to main.func12"
 		if y(40) != 41 {
 			ppanic("y(40) != 41")
 		}
@@ -105,14 +105,14 @@ func main() {
 
 	{
 		func() { // ERROR "func literal does not escape"
-			y := func(x int) int { // ERROR "can inline main.func13.1" "func literal does not escape"
+			y := func(x int) int { // ERROR "func literal does not escape" "can inline main.func13.1"
 				return x + 2
 			}
-			y, sink = func() (func(int) int, int) { // ERROR "func literal does not escape"
-				return func(x int) int { // ERROR "can inline main.func13.2" "func literal escapes"
+			y, sink = func() (func(int) int, int) { // ERROR "can inline main.func13.2"
+				return func(x int) int { // ERROR "can inline main.func13.2"
 					return x + 1
 				}, 42
-			}()
+			}() // ERROR "inlining call to main.func13.2" "func literal does not escape"
 			if y(40) != 41 {
 				ppanic("y(40) != 41")
 			}
@@ -187,29 +187,29 @@ func main() {
 
 	{
 		x := 42
-		if z := func(y int) int { // ERROR "func literal does not escape"
-			return func() int { // ERROR "can inline main.func22.1"
+		if z := func(y int) int { // ERROR "can inline main.func22"
+			return func() int { // ERROR "can inline main.func22.1" "can inline main.func30"
 				return x + y
 			}() // ERROR "inlining call to main.func22.1"
-		}(1); z != 43 {
+		}(1); z != 43 { // ERROR "inlining call to main.func22" "inlining call to main.func30"
 			ppanic("z != 43")
 		}
-		if z := func(y int) int { // ERROR "func literal does not escape"
-			return func() int { // ERROR "can inline main.func23.1"
+		if z := func(y int) int { // ERROR "func literal does not escape" "can inline main.func23"
+			return func() int { // ERROR "can inline main.func23.1" "can inline main.func31"
 				return x + y
 			}() // ERROR "inlining call to main.func23.1"
-		}; z(1) != 43 {
+		}; z(1) != 43 { // ERROR "inlining call to main.func23" "inlining call to main.func31"
 			ppanic("z(1) != 43")
 		}
 	}
 
 	{
 		a := 1
-		func() { // ERROR "func literal does not escape"
-			func() { // ERROR "can inline main.func24"
+		func() { // ERROR "can inline main.func24"
+			func() { // ERROR "can inline main.func24" "can inline main.func32"
 				a = 2
 			}() // ERROR "inlining call to main.func24"
-		}()
+		}() // ERROR "inlining call to main.func24" "inlining call to main.func32"
 		if a != 2 {
 			ppanic("a != 2")
 		}
@@ -250,12 +250,12 @@ func main() {
 		a := 2
 		if r := func(x int) int { // ERROR "func literal does not escape"
 			b := 3
-			return func(y int) int { // ERROR "func literal does not escape"
+			return func(y int) int { // ERROR "can inline main.func27.1"
 				c := 5
-				return func(z int) int { // ERROR "can inline main.func27.1.1"
+				return func(z int) int { // ERROR "can inline main.func27.1.1" "can inline main.func27.2"
 					return a*x + b*y + c*z
 				}(10) // ERROR "inlining call to main.func27.1.1"
-			}(100)
+			}(100) // ERROR "inlining call to main.func27.1" "inlining call to main.func27.2"
 		}(1000); r != 2350 {
 			ppanic("r != 2350")
 		}
@@ -265,15 +265,15 @@ func main() {
 		a := 2
 		if r := func(x int) int { // ERROR "func literal does not escape"
 			b := 3
-			return func(y int) int { // ERROR "func literal does not escape"
+			return func(y int) int { // ERROR "can inline main.func28.1"
 				c := 5
-				func(z int) { // ERROR "can inline main.func28.1.1"
+				func(z int) { // ERROR "can inline main.func28.1.1" "can inline main.func28.2"
 					a = a * x
 					b = b * y
 					c = c * z
 				}(10) // ERROR "inlining call to main.func28.1.1"
 				return a + c
-			}(100) + b
+			}(100) + b // ERROR "inlining call to main.func28.1" "inlining call to main.func28.2"
 		}(1000); r != 2350 {
 			ppanic("r != 2350")
 		}
diff --git a/test/closure5.dir/a.go b/test/closure5.dir/a.go
new file mode 100644
index 0000000000..de8082b7b1
--- /dev/null
+++ b/test/closure5.dir/a.go
@@ -0,0 +1,11 @@
+// Copyright 2021 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.
+
+// Check correctness of various closure corner cases
+// that are expected to be inlined
+
+package a
+
+func f() bool               { return true }
+func G() func() func() bool { return func() func() bool { return f } }
diff --git a/test/closure5.dir/main.go b/test/closure5.dir/main.go
new file mode 100644
index 0000000000..ee5dba6481
--- /dev/null
+++ b/test/closure5.dir/main.go
@@ -0,0 +1,15 @@
+// Copyright 2021 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.
+
+// Check correctness of various closure corner cases
+// that are expected to be inlined
+package main
+
+import "a"
+
+func main() {
+	if !a.G()()() {
+		panic("FAIL")
+	}
+}
diff --git a/test/closure5.go b/test/closure5.go
new file mode 100644
index 0000000000..a7022b27a6
--- /dev/null
+++ b/test/closure5.go
@@ -0,0 +1,10 @@
+// compiledir
+
+// Copyright 2021 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.
+
+// Check correctness of various closure corner cases
+// that are expected to be inlined
+
+package ignored
diff --git a/test/inline.go b/test/inline.go
index d754f06e03..37965c0d9d 100644
--- a/test/inline.go
+++ b/test/inline.go
@@ -58,7 +58,7 @@ func _() int { // ERROR "can inline _"
 var somethingWrong error
 
 // local closures can be inlined
-func l(x, y int) (int, int, error) {
+func l(x, y int) (int, int, error) { // ERROR "can inline l"
 	e := func(err error) (int, int, error) { // ERROR "can inline l.func1" "func literal does not escape" "leaking param: err to result"
 		return 0, 0, err
 	}
@@ -90,19 +90,19 @@ func n() int {
 // make sure assignment inside closure is detected
 func o() int {
 	foo := func() int { return 1 } // ERROR "can inline o.func1" "func literal does not escape"
-	func(x int) {                  // ERROR "func literal does not escape"
+	func(x int) {                  // ERROR "can inline o.func2"
 		if x > 10 {
-			foo = func() int { return 2 } // ERROR "can inline o.func2" "func literal escapes"
+			foo = func() int { return 2 } // ERROR "can inline o.func2"
 		}
-	}(11)
+	}(11) // ERROR "func literal does not escape" "inlining call to o.func2"
 	return foo()
 }
 
-func p() int {
+func p() int { // ERROR "can inline p"
 	return func() int { return 42 }() // ERROR "can inline p.func1" "inlining call to p.func1"
 }
 
-func q(x int) int {
+func q(x int) int { // ERROR "can inline q"
 	foo := func() int { return x * 2 } // ERROR "can inline q.func1" "func literal does not escape"
 	return foo()                       // ERROR "inlining call to q.func1"
 }
@@ -111,15 +111,15 @@ func r(z int) int {
 	foo := func(x int) int { // ERROR "can inline r.func1" "func literal does not escape"
 		return x + z
 	}
-	bar := func(x int) int { // ERROR "func literal does not escape"
-		return x + func(y int) int { // ERROR "can inline r.func2.1"
+	bar := func(x int) int { // ERROR "func literal does not escape" "can inline r.func2"
+		return x + func(y int) int { // ERROR "can inline r.func2.1" "can inline r.func3"
 			return 2*y + x*z
 		}(x) // ERROR "inlining call to r.func2.1"
 	}
-	return foo(42) + bar(42) // ERROR "inlining call to r.func1"
+	return foo(42) + bar(42) // ERROR "inlining call to r.func1" "inlining call to r.func2" "inlining call to r.func3"
 }
 
-func s0(x int) int {
+func s0(x int) int { // ERROR "can inline s0"
 	foo := func() { // ERROR "can inline s0.func1" "func literal does not escape"
 		x = x + 1
 	}
@@ -127,7 +127,7 @@ func s0(x int) int {
 	return x
 }
 
-func s1(x int) int {
+func s1(x int) int { // ERROR "can inline s1"
 	foo := func() int { // ERROR "can inline s1.func1" "func literal does not escape"
 		return x
 	}
-- 
GitLab


From 0f054c5be06d87d199e5691773af640936ecb588 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 20 Jan 2021 14:08:53 -0800
Subject: [PATCH 0529/2400] [dev.typeparams] cmd/dist: add -G=3 test coverage

Change-Id: Icb85b93f0d98df722fffd70cf9a2554ac2098c60
Reviewed-on: https://go-review.googlesource.com/c/go/+/285052
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/dist/test.go | 28 ++++++++++++++++++++++------
 1 file changed, 22 insertions(+), 6 deletions(-)

diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go
index 955ce2a063..365a77a156 100644
--- a/src/cmd/dist/test.go
+++ b/src/cmd/dist/test.go
@@ -309,14 +309,24 @@ var (
 	benchMatches []string
 )
 
-func (t *tester) registerStdTest(pkg string) {
-	testName := "go_test:" + pkg
+func (t *tester) registerStdTest(pkg string, useG3 bool) {
+	heading := "Testing packages."
+	testPrefix := "go_test:"
+	gcflags := gogcflags
+	if useG3 {
+		heading = "Testing packages with -G=3."
+		testPrefix = "go_test_g3:"
+		gcflags += " -G=3"
+	}
+
+	testName := testPrefix + pkg
 	if t.runRx == nil || t.runRx.MatchString(testName) == t.runRxWant {
 		stdMatches = append(stdMatches, pkg)
 	}
+
 	t.tests = append(t.tests, distTest{
 		name:    testName,
-		heading: "Testing packages.",
+		heading: heading,
 		fn: func(dt *distTest) error {
 			if ranGoTest {
 				return nil
@@ -343,7 +353,7 @@ func (t *tester) registerStdTest(pkg string) {
 				"-short=" + short(),
 				t.tags(),
 				t.timeout(timeoutSec),
-				"-gcflags=all=" + gogcflags,
+				"-gcflags=all=" + gcflags,
 			}
 			if t.race {
 				args = append(args, "-race")
@@ -408,7 +418,10 @@ func (t *tester) registerTests() {
 	if len(t.runNames) > 0 {
 		for _, name := range t.runNames {
 			if strings.HasPrefix(name, "go_test:") {
-				t.registerStdTest(strings.TrimPrefix(name, "go_test:"))
+				t.registerStdTest(strings.TrimPrefix(name, "go_test:"), false)
+			}
+			if strings.HasPrefix(name, "go_test_g3:") {
+				t.registerStdTest(strings.TrimPrefix(name, "go_test_g3:"), true)
 			}
 			if strings.HasPrefix(name, "go_test_bench:") {
 				t.registerRaceBenchTest(strings.TrimPrefix(name, "go_test_bench:"))
@@ -432,7 +445,10 @@ func (t *tester) registerTests() {
 		}
 		pkgs := strings.Fields(string(all))
 		for _, pkg := range pkgs {
-			t.registerStdTest(pkg)
+			t.registerStdTest(pkg, true)
+		}
+		for _, pkg := range pkgs {
+			t.registerStdTest(pkg, false)
 		}
 		if t.race {
 			for _, pkg := range pkgs {
-- 
GitLab


From f03f934ede4db4b022f08c88e351463543832e00 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 20 Jan 2021 15:55:39 -0800
Subject: [PATCH 0530/2400] [dev.typeparams] cmd/compile/internal/types2: make
 predeclared "any" alias for interface{}

If we ever decide to permit the use of the predeclared identifier
"any" in lieu of interface{}, it must be an alias for interface{}.

Change-Id: Ic751d7f9b61133fb57625f56ce95d99f034b32c5
Reviewed-on: https://go-review.googlesource.com/c/go/+/285132
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/types2/api_test.go |  6 +++---
 src/cmd/compile/internal/types2/universe.go | 11 ++++-------
 2 files changed, 7 insertions(+), 10 deletions(-)

diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go
index 6f65b84f7c..9d23b5b2a6 100644
--- a/src/cmd/compile/internal/types2/api_test.go
+++ b/src/cmd/compile/internal/types2/api_test.go
@@ -323,14 +323,14 @@ func TestTypesInfo(t *testing.T) {
 		{broken + `x5; func _() { var x map[string][...]int; x = map[string][...]int{"": {1,2,3}} }`, `x`, `map[string][-1]int`},
 
 		// parameterized functions
-		{`package p0; func f[T any](T); var _ = f[int]`, `f`, `func[T₁ any](T₁)`},
+		{`package p0; func f[T any](T); var _ = f[int]`, `f`, `func[T₁ interface{}](T₁)`},
 		{`package p1; func f[T any](T); var _ = f[int]`, `f[int]`, `func(int)`},
-		{`package p2; func f[T any](T); func _() { f(42) }`, `f`, `func[T₁ any](T₁)`},
+		{`package p2; func f[T any](T); func _() { f(42) }`, `f`, `func[T₁ interface{}](T₁)`},
 		{`package p3; func f[T any](T); func _() { f(42) }`, `f(42)`, `()`},
 
 		// type parameters
 		{`package t0; type t[] int; var _ t`, `t`, `t0.t`}, // t[] is a syntax error that is ignored in this test in favor of t
-		{`package t1; type t[P any] int; var _ t[int]`, `t`, `t1.t[P₁ any]`},
+		{`package t1; type t[P any] int; var _ t[int]`, `t`, `t1.t[P₁ interface{}]`},
 		{`package t2; type t[P interface{}] int; var _ t[int]`, `t`, `t2.t[P₁ interface{}]`},
 		{`package t3; type t[P, Q interface{}] int; var _ t[int, int]`, `t`, `t3.t[P₁, Q₂ interface{}]`},
 		{broken + `t4; type t[P, Q interface{ m() }] int; var _ t[int, int]`, `t`, `broken_t4.t[P₁, Q₂ interface{m()}]`},
diff --git a/src/cmd/compile/internal/types2/universe.go b/src/cmd/compile/internal/types2/universe.go
index c1961d7455..f3dd53af1f 100644
--- a/src/cmd/compile/internal/types2/universe.go
+++ b/src/cmd/compile/internal/types2/universe.go
@@ -24,7 +24,7 @@ var (
 	universeIota  *Const
 	universeByte  *Basic // uint8 alias, but has name "byte"
 	universeRune  *Basic // int32 alias, but has name "rune"
-	universeAny   *Named
+	universeAny   *Interface
 	universeError *Named
 )
 
@@ -34,7 +34,7 @@ var (
 // The *Basic type for Typ[Byte] will have the name "uint8".
 // Use Universe.Lookup("byte").Type() to obtain the specific
 // alias basic type named "byte" (and analogous for "rune").
-var Typ = []*Basic{
+var Typ = [...]*Basic{
 	Invalid: {Invalid, 0, "invalid type", aType{}},
 
 	Bool:          {Bool, IsBoolean, "bool", aType{}},
@@ -82,10 +82,7 @@ func defPredeclaredTypes() {
 	// (Predeclared and entered into universe scope so we do all the
 	// usual checks; but removed again from scope later since it's
 	// only visible as constraint in a type parameter list.)
-	{
-		typ := &Named{underlying: &emptyInterface}
-		def(NewTypeName(nopos, nil, "any", typ))
-	}
+	def(NewTypeName(nopos, nil, "any", &emptyInterface))
 
 	// Error has a nil package in its qualified name since it is in no package
 	{
@@ -241,7 +238,7 @@ func init() {
 	universeIota = Universe.Lookup("iota").(*Const)
 	universeByte = Universe.Lookup("byte").(*TypeName).typ.(*Basic)
 	universeRune = Universe.Lookup("rune").(*TypeName).typ.(*Basic)
-	universeAny = Universe.Lookup("any").(*TypeName).typ.(*Named)
+	universeAny = Universe.Lookup("any").(*TypeName).typ.(*Interface)
 	universeError = Universe.Lookup("error").(*TypeName).typ.(*Named)
 
 	// "any" is only visible as constraint in a type parameter list
-- 
GitLab


From 455c29af83524a484ac407a35f4c69ff710d7acb Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 20 Jan 2021 17:03:36 -0800
Subject: [PATCH 0531/2400] [dev.typeparams] cmd/compile/internal/types2:
 convert untyped arguments to delete

For the predeclared "delete" function, types2 was checking that the
second argument was assignable to the map's key type, but not actually
updating the Types map as appropriate. So this could leave untyped
constants in the AST.

The error "cannot convert" is somewhat less precise than the previous
"not assignable" error, but it's consistent with how types2 reports
other erroneous assignments of untyped constants.

Change-Id: Ic3ca3a3611ad0e4646c050e93088cdf992234e5f
Reviewed-on: https://go-review.googlesource.com/c/go/+/285059
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/types2/builtins.go           | 4 ++--
 src/cmd/compile/internal/types2/testdata/builtins.src | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go
index 43da6a1529..bd1ea0fdc1 100644
--- a/src/cmd/compile/internal/types2/builtins.go
+++ b/src/cmd/compile/internal/types2/builtins.go
@@ -368,8 +368,8 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 			return
 		}
 
-		if !x.assignableTo(check, m.key, nil) {
-			check.invalidArgf(x, "%s is not assignable to %s", x, m.key)
+		check.assignment(x, m.key, "argument to delete")
+		if x.mode == invalid {
 			return
 		}
 
diff --git a/src/cmd/compile/internal/types2/testdata/builtins.src b/src/cmd/compile/internal/types2/testdata/builtins.src
index 69cc48798e..e473bd1df2 100644
--- a/src/cmd/compile/internal/types2/testdata/builtins.src
+++ b/src/cmd/compile/internal/types2/testdata/builtins.src
@@ -283,7 +283,7 @@ func delete1() {
 	delete() // ERROR not enough arguments
 	delete(1) // ERROR not enough arguments
 	delete(1, 2, 3) // ERROR too many arguments
-	delete(m, 0 /* ERROR not assignable */)
+	delete(m, 0 /* ERROR cannot convert */)
 	delete(m, s)
 	_ = delete /* ERROR used as value */ (m, s)
 
-- 
GitLab


From 2427f6e6c07de20a00dd8b9ab464f0abe5ccd13a Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 20 Jan 2021 12:54:23 -0800
Subject: [PATCH 0532/2400] [dev.typeparams] cmd/compile: directly set some
 simple expression types

This CL updates irgen to directly set the type for a bunch of basic
expressions that are easy to handle already. Trickier rewrites are
still handled with typecheck.Expr, but responsibility of calling that
is pushed down to the conversion of individual operations.

Change-Id: I774ac6ab4c72ad854860ab5c741867dd42a066b3
Reviewed-on: https://go-review.googlesource.com/c/go/+/285058
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/noder/decl.go    |  4 ++
 src/cmd/compile/internal/noder/expr.go    | 55 +++++++++++++++--------
 src/cmd/compile/internal/noder/helpers.go | 52 ++++++++++++++-------
 src/cmd/compile/internal/noder/irgen.go   |  5 +++
 src/cmd/compile/internal/noder/types.go   |  7 +++
 5 files changed, 87 insertions(+), 36 deletions(-)

diff --git a/src/cmd/compile/internal/noder/decl.go b/src/cmd/compile/internal/noder/decl.go
index ce5bad88f3..4d20f410bc 100644
--- a/src/cmd/compile/internal/noder/decl.go
+++ b/src/cmd/compile/internal/noder/decl.go
@@ -100,6 +100,9 @@ func (g *irgen) typeDecl(out *ir.Nodes, decl *syntax.TypeDecl) {
 		return
 	}
 
+	// Prevent size calculations until we set the underlying type.
+	types.DeferCheckSize()
+
 	name, obj := g.def(decl.Name)
 	ntyp, otyp := name.Type(), obj.Type()
 	if ir.CurFunc != nil {
@@ -135,6 +138,7 @@ func (g *irgen) typeDecl(out *ir.Nodes, decl *syntax.TypeDecl) {
 	// [mdempsky: Subtleties like these are why I always vehemently
 	// object to new type pragmas.]
 	ntyp.SetUnderlying(g.typeExpr(decl.Type))
+	types.ResumeCheckSize()
 
 	if otyp, ok := otyp.(*types2.Named); ok && otyp.NumMethods() != 0 {
 		methods := make([]*types.Field, otyp.NumMethods())
diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index d5177ead06..be592003e1 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -43,15 +43,36 @@ func (g *irgen) expr(expr syntax.Expr) ir.Node {
 		base.FatalfAt(g.pos(expr), "unrecognized type-checker result")
 	}
 
+	// The gc backend expects all expressions to have a concrete type, and
+	// types2 mostly satisfies this expectation already. But there are a few
+	// cases where the Go spec doesn't require converting to concrete type,
+	// and so types2 leaves them untyped. So we need to fix those up here.
+	typ := tv.Type
+	if basic, ok := typ.(*types2.Basic); ok && basic.Info()&types2.IsUntyped != 0 {
+		switch basic.Kind() {
+		case types2.UntypedNil:
+			// ok; can appear in type switch case clauses
+			// TODO(mdempsky): Handle as part of type switches instead?
+		case types2.UntypedBool:
+			typ = types2.Typ[types2.Bool] // expression in "if" or "for" condition
+		case types2.UntypedString:
+			typ = types2.Typ[types2.String] // argument to "append" or "copy" calls
+		default:
+			base.FatalfAt(g.pos(expr), "unexpected untyped type: %v", basic)
+		}
+	}
+
 	// Constant expression.
 	if tv.Value != nil {
-		return Const(g.pos(expr), g.typ(tv.Type), tv.Value)
+		return Const(g.pos(expr), g.typ(typ), tv.Value)
 	}
 
-	// TODO(mdempsky): Remove dependency on typecheck.Expr.
-	n := typecheck.Expr(g.expr0(tv.Type, expr))
-	if !g.match(n.Type(), tv.Type, tv.HasOk()) {
-		base.FatalfAt(g.pos(expr), "expected %L to have type %v", n, tv.Type)
+	n := g.expr0(typ, expr)
+	if n.Typecheck() != 1 {
+		base.FatalfAt(g.pos(expr), "missed typecheck: %+v", n)
+	}
+	if !g.match(n.Type(), typ, tv.HasOk()) {
+		base.FatalfAt(g.pos(expr), "expected %L to have type %v", n, typ)
 	}
 	return n
 }
@@ -64,7 +85,8 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 		if _, isNil := g.info.Uses[expr].(*types2.Nil); isNil {
 			return Nil(pos, g.typ(typ))
 		}
-		return g.use(expr)
+		// TODO(mdempsky): Remove dependency on typecheck.Expr.
+		return typecheck.Expr(g.use(expr))
 
 	case *syntax.CompositeLit:
 		return g.compLit(typ, expr)
@@ -83,13 +105,14 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 		// Qualified identifier.
 		if name, ok := expr.X.(*syntax.Name); ok {
 			if _, ok := g.info.Uses[name].(*types2.PkgName); ok {
-				return g.use(expr.Sel)
+				// TODO(mdempsky): Remove dependency on typecheck.Expr.
+				return typecheck.Expr(g.use(expr.Sel))
 			}
 		}
 
 		// TODO(mdempsky/danscales): Use g.info.Selections[expr]
 		// to resolve field/method selection. See CL 280633.
-		return ir.NewSelectorExpr(pos, ir.OXDOT, g.expr(expr.X), g.name(expr.Sel))
+		return typecheck.Expr(ir.NewSelectorExpr(pos, ir.OXDOT, g.expr(expr.X), g.name(expr.Sel)))
 	case *syntax.SliceExpr:
 		return Slice(pos, g.expr(expr.X), g.expr(expr.Index[0]), g.expr(expr.Index[1]), g.expr(expr.Index[2]))
 
@@ -131,16 +154,9 @@ func (g *irgen) exprs(exprs []syntax.Expr) []ir.Node {
 
 func (g *irgen) compLit(typ types2.Type, lit *syntax.CompositeLit) ir.Node {
 	if ptr, ok := typ.Underlying().(*types2.Pointer); ok {
-		if _, isNamed := typ.(*types2.Named); isNamed {
-			// TODO(mdempsky): Questionable, but this is
-			// currently allowed by cmd/compile, go/types,
-			// and gccgo:
-			//
-			//	type T *struct{}
-			//	var _ = []T{{}}
-			base.FatalfAt(g.pos(lit), "defined-pointer composite literal")
-		}
-		return ir.NewAddrExpr(g.pos(lit), g.compLit(ptr.Elem(), lit))
+		n := ir.NewAddrExpr(g.pos(lit), g.compLit(ptr.Elem(), lit))
+		n.SetOp(ir.OPTRLIT)
+		return typed(g.typ(typ), n)
 	}
 
 	_, isStruct := typ.Underlying().(*types2.Struct)
@@ -159,7 +175,8 @@ func (g *irgen) compLit(typ types2.Type, lit *syntax.CompositeLit) ir.Node {
 		}
 	}
 
-	return ir.NewCompLitExpr(g.pos(lit), ir.OCOMPLIT, ir.TypeNode(g.typ(typ)), exprs)
+	// TODO(mdempsky): Remove dependency on typecheck.Expr.
+	return typecheck.Expr(ir.NewCompLitExpr(g.pos(lit), ir.OCOMPLIT, ir.TypeNode(g.typ(typ)), exprs))
 }
 
 func (g *irgen) funcLit(typ types2.Type, expr *syntax.FuncLit) ir.Node {
diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
index 2139f16a6c..3c20f74d8b 100644
--- a/src/cmd/compile/internal/noder/helpers.go
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -21,32 +21,41 @@ import (
 // results, rather than leaving the caller responsible for using
 // typecheck.Expr or typecheck.Stmt.
 
+// typed returns n after setting its type to typ.
+func typed(typ *types.Type, n ir.Node) ir.Node {
+	n.SetType(typ)
+	n.SetTypecheck(1)
+	return n
+}
+
 // Values
 
 func Const(pos src.XPos, typ *types.Type, val constant.Value) ir.Node {
-	n := ir.NewBasicLit(pos, val)
-	n.SetType(typ)
-	return n
+	return typed(typ, ir.NewBasicLit(pos, val))
 }
 
 func Nil(pos src.XPos, typ *types.Type) ir.Node {
-	n := ir.NewNilExpr(pos)
-	n.SetType(typ)
-	return n
+	return typed(typ, ir.NewNilExpr(pos))
 }
 
 // Expressions
 
 func Assert(pos src.XPos, x ir.Node, typ *types.Type) ir.Node {
-	return typecheck.Expr(ir.NewTypeAssertExpr(pos, x, ir.TypeNode(typ)))
+	return typed(typ, ir.NewTypeAssertExpr(pos, x, nil))
 }
 
 func Binary(pos src.XPos, op ir.Op, x, y ir.Node) ir.Node {
 	switch op {
 	case ir.OANDAND, ir.OOROR:
-		return ir.NewLogicalExpr(pos, op, x, y)
+		return typed(x.Type(), ir.NewLogicalExpr(pos, op, x, y))
+	case ir.OADD:
+		if x.Type().IsString() {
+			// TODO(mdempsky): Construct OADDSTR directly.
+			return typecheck.Expr(ir.NewBinaryExpr(pos, op, x, y))
+		}
+		fallthrough
 	default:
-		return ir.NewBinaryExpr(pos, op, x, y)
+		return typed(x.Type(), ir.NewBinaryExpr(pos, op, x, y))
 	}
 }
 
@@ -92,13 +101,17 @@ func Call(pos src.XPos, fun ir.Node, args []ir.Node, dots bool) ir.Node {
 }
 
 func Compare(pos src.XPos, typ *types.Type, op ir.Op, x, y ir.Node) ir.Node {
-	n := typecheck.Expr(ir.NewBinaryExpr(pos, op, x, y))
-	n.SetType(typ)
-	return n
+	n := ir.NewBinaryExpr(pos, op, x, y)
+	if !types.Identical(x.Type(), y.Type()) {
+		// TODO(mdempsky): Handle subtleties of constructing mixed-typed comparisons.
+		n = typecheck.Expr(n).(*ir.BinaryExpr)
+	}
+	return typed(typ, n)
 }
 
 func Index(pos src.XPos, x, index ir.Node) ir.Node {
-	return ir.NewIndexExpr(pos, x, index)
+	// TODO(mdempsky): Avoid typecheck.Expr.
+	return typecheck.Expr(ir.NewIndexExpr(pos, x, index))
 }
 
 func Slice(pos src.XPos, x, low, high, max ir.Node) ir.Node {
@@ -106,17 +119,22 @@ func Slice(pos src.XPos, x, low, high, max ir.Node) ir.Node {
 	if max != nil {
 		op = ir.OSLICE3
 	}
-	return ir.NewSliceExpr(pos, op, x, low, high, max)
+	// TODO(mdempsky): Avoid typecheck.Expr.
+	return typecheck.Expr(ir.NewSliceExpr(pos, op, x, low, high, max))
 }
 
 func Unary(pos src.XPos, op ir.Op, x ir.Node) ir.Node {
+	typ := x.Type()
 	switch op {
 	case ir.OADDR:
-		return typecheck.NodAddrAt(pos, x)
+		// TODO(mdempsky): Avoid typecheck.Expr. Probably just need to set OPTRLIT as needed.
+		return typed(types.NewPtr(typ), typecheck.Expr(typecheck.NodAddrAt(pos, x)))
 	case ir.ODEREF:
-		return ir.NewStarExpr(pos, x)
+		return typed(typ.Elem(), ir.NewStarExpr(pos, x))
+	case ir.ORECV:
+		return typed(typ.Elem(), ir.NewUnaryExpr(pos, op, x))
 	default:
-		return ir.NewUnaryExpr(pos, op, x)
+		return typed(typ, ir.NewUnaryExpr(pos, op, x))
 	}
 }
 
diff --git a/src/cmd/compile/internal/noder/irgen.go b/src/cmd/compile/internal/noder/irgen.go
index e127348482..5c779ab810 100644
--- a/src/cmd/compile/internal/noder/irgen.go
+++ b/src/cmd/compile/internal/noder/irgen.go
@@ -103,6 +103,10 @@ func (g *irgen) generate(noders []*noder) {
 	types.LocalPkg.Name = g.self.Name()
 	typecheck.TypecheckAllowed = true
 
+	// Prevent size calculations until we set the underlying type
+	// for all package-block defined types.
+	types.DeferCheckSize()
+
 	// At this point, types2 has already handled name resolution and
 	// type checking. We just need to map from its object and type
 	// representations to those currently used by the rest of the
@@ -152,6 +156,7 @@ Outer:
 			}
 		}
 	}
+	types.ResumeCheckSize()
 
 	// 3. Process all remaining declarations.
 	for _, declList := range declLists {
diff --git a/src/cmd/compile/internal/noder/types.go b/src/cmd/compile/internal/noder/types.go
index aec1846619..e0ed5a3f99 100644
--- a/src/cmd/compile/internal/noder/types.go
+++ b/src/cmd/compile/internal/noder/types.go
@@ -35,6 +35,13 @@ func (g *irgen) typ(typ types2.Type) *types.Type {
 	if !ok {
 		res = g.typ0(typ)
 		g.typs[typ] = res
+
+		// Ensure we calculate the size for all concrete types seen by
+		// the frontend. This is another heavy hammer for something that
+		// should really be the backend's responsibility instead.
+		if !res.IsUntyped() {
+			types.CheckSize(res)
+		}
 	}
 	return res
 }
-- 
GitLab


From 213c3905e9eb4fcc4847d3f7e55ce6a0d3087318 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Thu, 21 Jan 2021 02:35:03 +0700
Subject: [PATCH 0533/2400] [dev.regabi] cmd/compile: use node walked flag to
 prevent double walk for walkSelect

Same as CL 283733, but for walkSelect.

Passes toolstash -cmp.

Change-Id: I3ecb8d6eafd395379191c15fc58c95f75809fec9
Reviewed-on: https://go-review.googlesource.com/c/go/+/284895
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/walk/select.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/walk/select.go b/src/cmd/compile/internal/walk/select.go
index 56ba0fa758..c6069d0ba2 100644
--- a/src/cmd/compile/internal/walk/select.go
+++ b/src/cmd/compile/internal/walk/select.go
@@ -13,9 +13,10 @@ import (
 
 func walkSelect(sel *ir.SelectStmt) {
 	lno := ir.SetPos(sel)
-	if len(sel.Compiled) != 0 {
+	if sel.Walked() {
 		base.Fatalf("double walkSelect")
 	}
+	sel.SetWalked(true)
 
 	init := ir.TakeInit(sel)
 
-- 
GitLab


From 9f036844db39acad54ab2b45bab39fa376c78003 Mon Sep 17 00:00:00 2001
From: Baokun Lee <bk@golangcn.org>
Date: Thu, 7 Jan 2021 11:17:57 +0800
Subject: [PATCH 0534/2400] [dev.regabi] cmd/compile: use ir.DoChildren
 directly in inlining

Passes toolstash -cmp.

Change-Id: Ie35e8163fa0e61ed9e1b259929c8cbe82ee5301e
Reviewed-on: https://go-review.googlesource.com/c/go/+/282212
Run-TryBot: Baokun Lee <bk@golangcn.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Trust: Baokun Lee <bk@golangcn.org>
---
 src/cmd/compile/internal/inline/inl.go | 66 ++++++++++----------------
 1 file changed, 25 insertions(+), 41 deletions(-)

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 7778bc56c4..46f093b1f8 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -27,7 +27,6 @@
 package inline
 
 import (
-	"errors"
 	"fmt"
 	"go/constant"
 	"strings"
@@ -256,17 +255,12 @@ type hairyVisitor struct {
 	reason        string
 	extraCallCost int32
 	usedLocals    map[*ir.Name]bool
-	do            func(ir.Node) error
+	do            func(ir.Node) bool
 }
 
-var errBudget = errors.New("too expensive")
-
 func (v *hairyVisitor) tooHairy(fn *ir.Func) bool {
 	v.do = v.doNode // cache closure
-
-	err := errChildren(fn, v.do)
-	if err != nil {
-		v.reason = err.Error()
+	if ir.DoChildren(fn, v.do) {
 		return true
 	}
 	if v.budget < 0 {
@@ -276,11 +270,10 @@ func (v *hairyVisitor) tooHairy(fn *ir.Func) bool {
 	return false
 }
 
-func (v *hairyVisitor) doNode(n ir.Node) error {
+func (v *hairyVisitor) doNode(n ir.Node) bool {
 	if n == nil {
-		return nil
+		return false
 	}
-
 	switch n.Op() {
 	// Call is okay if inlinable and we have the budget for the body.
 	case ir.OCALLFUNC:
@@ -294,7 +287,8 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 			if name.Class == ir.PFUNC && types.IsRuntimePkg(name.Sym().Pkg) {
 				fn := name.Sym().Name
 				if fn == "getcallerpc" || fn == "getcallersp" {
-					return errors.New("call to " + fn)
+					v.reason = "call to " + fn
+					return true
 				}
 				if fn == "throw" {
 					v.budget -= inlineExtraThrowCost
@@ -357,7 +351,8 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 	case ir.ORECOVER:
 		// recover matches the argument frame pointer to find
 		// the right panic value, so it needs an argument frame.
-		return errors.New("call to recover")
+		v.reason = "call to recover"
+		return true
 
 	case ir.OCLOSURE:
 		// TODO(danscales) - fix some bugs when budget is lowered below 30
@@ -371,24 +366,27 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 		ir.ODEFER,
 		ir.ODCLTYPE, // can't print yet
 		ir.OTAILCALL:
-		return errors.New("unhandled op " + n.Op().String())
+		v.reason = "unhandled op " + n.Op().String()
+		return true
 
 	case ir.OAPPEND:
 		v.budget -= inlineExtraAppendCost
 
 	case ir.ODCLCONST, ir.OFALL:
 		// These nodes don't produce code; omit from inlining budget.
-		return nil
+		return false
 
 	case ir.OFOR, ir.OFORUNTIL:
 		n := n.(*ir.ForStmt)
 		if n.Label != nil {
-			return errors.New("labeled control")
+			v.reason = "labeled control"
+			return true
 		}
 	case ir.OSWITCH:
 		n := n.(*ir.SwitchStmt)
 		if n.Label != nil {
-			return errors.New("labeled control")
+			v.reason = "labeled control"
+			return true
 		}
 	// case ir.ORANGE, ir.OSELECT in "unhandled" above
 
@@ -404,16 +402,9 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 		if ir.IsConst(n.Cond, constant.Bool) {
 			// This if and the condition cost nothing.
 			// TODO(rsc): It seems strange that we visit the dead branch.
-			if err := errList(n.Init(), v.do); err != nil {
-				return err
-			}
-			if err := errList(n.Body, v.do); err != nil {
-				return err
-			}
-			if err := errList(n.Else, v.do); err != nil {
-				return err
-			}
-			return nil
+			return doList(n.Init(), v.do) ||
+				doList(n.Body, v.do) ||
+				doList(n.Else, v.do)
 		}
 
 	case ir.ONAME:
@@ -439,10 +430,11 @@ func (v *hairyVisitor) doNode(n ir.Node) error {
 
 	// When debugging, don't stop early, to get full cost of inlining this function
 	if v.budget < 0 && base.Flag.LowerM < 2 && !logopt.Enabled() {
-		return errBudget
+		v.reason = "too expensive"
+		return true
 	}
 
-	return errChildren(n, v.do)
+	return ir.DoChildren(n, v.do)
 }
 
 func isBigFunc(fn *ir.Func) bool {
@@ -1411,21 +1403,13 @@ func numNonClosures(list []*ir.Func) int {
 	return count
 }
 
-// TODO(mdempsky): Update inl.go to use ir.DoChildren directly.
-func errChildren(n ir.Node, do func(ir.Node) error) (err error) {
-	ir.DoChildren(n, func(x ir.Node) bool {
-		err = do(x)
-		return err != nil
-	})
-	return
-}
-func errList(list []ir.Node, do func(ir.Node) error) error {
+func doList(list []ir.Node, do func(ir.Node) bool) bool {
 	for _, x := range list {
 		if x != nil {
-			if err := do(x); err != nil {
-				return err
+			if do(x) {
+				return true
 			}
 		}
 	}
-	return nil
+	return false
 }
-- 
GitLab


From 19a6db6b63fd53d36b2eef5823e107a25a8062c0 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Wed, 20 Jan 2021 14:26:42 +0700
Subject: [PATCH 0535/2400] [dev.regabi] cmd/compile: make sure mkcall* passed
 non-nil init

So next CL can pass temporaries assignments for function arguments in to
init instead of CallExpr.Rargs.

Passes toolstash -cmp.

Change-Id: I2c3cb6a63e8bf9d0418052b39c1db58050f71305
Reviewed-on: https://go-review.googlesource.com/c/go/+/284893
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/walk/race.go   |  9 ++++-----
 src/cmd/compile/internal/walk/range.go  | 16 +++++++++-------
 src/cmd/compile/internal/walk/select.go |  8 +++++---
 src/cmd/compile/internal/walk/walk.go   | 17 +++++++++++++++++
 4 files changed, 35 insertions(+), 15 deletions(-)

diff --git a/src/cmd/compile/internal/walk/race.go b/src/cmd/compile/internal/walk/race.go
index 77cabe50c6..47cd2fdc22 100644
--- a/src/cmd/compile/internal/walk/race.go
+++ b/src/cmd/compile/internal/walk/race.go
@@ -26,10 +26,9 @@ func instrument(fn *ir.Func) {
 	if base.Flag.Race {
 		lno := base.Pos
 		base.Pos = src.NoXPos
-
 		if ssagen.Arch.LinkArch.Arch.Family != sys.AMD64 {
-			fn.Enter.Prepend(mkcall("racefuncenterfp", nil, nil))
-			fn.Exit.Append(mkcall("racefuncexit", nil, nil))
+			fn.Enter.Prepend(mkcallstmt("racefuncenterfp"))
+			fn.Exit.Append(mkcallstmt("racefuncexit"))
 		} else {
 
 			// nodpc is the PC of the caller as extracted by
@@ -44,8 +43,8 @@ func instrument(fn *ir.Func) {
 			nodpc.SetType(types.Types[types.TUINTPTR])
 			nodpc.SetFrameOffset(int64(-types.PtrSize))
 			fn.Dcl = append(fn.Dcl, nodpc)
-			fn.Enter.Prepend(mkcall("racefuncenter", nil, nil, nodpc))
-			fn.Exit.Append(mkcall("racefuncexit", nil, nil))
+			fn.Enter.Prepend(mkcallstmt("racefuncenter", nodpc))
+			fn.Exit.Append(mkcallstmt("racefuncexit"))
 		}
 		base.Pos = lno
 	}
diff --git a/src/cmd/compile/internal/walk/range.go b/src/cmd/compile/internal/walk/range.go
index 2b28e7442d..5ab24b2188 100644
--- a/src/cmd/compile/internal/walk/range.go
+++ b/src/cmd/compile/internal/walk/range.go
@@ -174,12 +174,12 @@ func walkRange(nrange *ir.RangeStmt) ir.Node {
 		fn := typecheck.LookupRuntime("mapiterinit")
 
 		fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem(), th)
-		init = append(init, mkcall1(fn, nil, nil, reflectdata.TypePtr(t), ha, typecheck.NodAddr(hit)))
+		init = append(init, mkcallstmt1(fn, reflectdata.TypePtr(t), ha, typecheck.NodAddr(hit)))
 		nfor.Cond = ir.NewBinaryExpr(base.Pos, ir.ONE, ir.NewSelectorExpr(base.Pos, ir.ODOT, hit, keysym), typecheck.NodNil())
 
 		fn = typecheck.LookupRuntime("mapiternext")
 		fn = typecheck.SubstArgTypes(fn, th)
-		nfor.Post = mkcall1(fn, nil, nil, typecheck.NodAddr(hit))
+		nfor.Post = mkcallstmt1(fn, typecheck.NodAddr(hit))
 
 		key := ir.NewStarExpr(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, hit, keysym))
 		if v1 == nil {
@@ -269,12 +269,14 @@ func walkRange(nrange *ir.RangeStmt) ir.Node {
 
 		// } else {
 		eif := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-		nif.Else = []ir.Node{eif}
 
 		// hv2, hv1 = decoderune(ha, hv1)
 		eif.Lhs = []ir.Node{hv2, hv1}
 		fn := typecheck.LookupRuntime("decoderune")
-		eif.Rhs = []ir.Node{mkcall1(fn, fn.Type().Results(), nil, ha, hv1)}
+		var fnInit ir.Nodes
+		eif.Rhs = []ir.Node{mkcall1(fn, fn.Type().Results(), &fnInit, ha, hv1)}
+		fnInit.Append(eif)
+		nif.Else = fnInit
 
 		body = append(body, nif)
 
@@ -374,7 +376,7 @@ func mapClear(m ir.Node) ir.Node {
 	// instantiate mapclear(typ *type, hmap map[any]any)
 	fn := typecheck.LookupRuntime("mapclear")
 	fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem())
-	n := mkcall1(fn, nil, nil, reflectdata.TypePtr(t), m)
+	n := mkcallstmt1(fn, reflectdata.TypePtr(t), m)
 	return walkStmt(typecheck.Stmt(n))
 }
 
@@ -449,10 +451,10 @@ func arrayClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
 	if a.Type().Elem().HasPointers() {
 		// memclrHasPointers(hp, hn)
 		ir.CurFunc.SetWBPos(stmt.Pos())
-		fn = mkcall("memclrHasPointers", nil, nil, hp, hn)
+		fn = mkcallstmt("memclrHasPointers", hp, hn)
 	} else {
 		// memclrNoHeapPointers(hp, hn)
-		fn = mkcall("memclrNoHeapPointers", nil, nil, hp, hn)
+		fn = mkcallstmt("memclrNoHeapPointers", hp, hn)
 	}
 
 	n.Body.Append(fn)
diff --git a/src/cmd/compile/internal/walk/select.go b/src/cmd/compile/internal/walk/select.go
index c6069d0ba2..873be289dc 100644
--- a/src/cmd/compile/internal/walk/select.go
+++ b/src/cmd/compile/internal/walk/select.go
@@ -35,7 +35,7 @@ func walkSelectCases(cases []*ir.CommClause) []ir.Node {
 
 	// optimization: zero-case select
 	if ncas == 0 {
-		return []ir.Node{mkcall("block", nil, nil)}
+		return []ir.Node{mkcallstmt("block")}
 	}
 
 	// optimization: one-case select: single op.
@@ -214,7 +214,7 @@ func walkSelectCases(cases []*ir.CommClause) []ir.Node {
 		// TODO(mdempsky): There should be a cleaner way to
 		// handle this.
 		if base.Flag.Race {
-			r := mkcall("selectsetpc", nil, nil, typecheck.NodAddr(ir.NewIndexExpr(base.Pos, pcs, ir.NewInt(int64(i)))))
+			r := mkcallstmt("selectsetpc", typecheck.NodAddr(ir.NewIndexExpr(base.Pos, pcs, ir.NewInt(int64(i)))))
 			init = append(init, r)
 		}
 	}
@@ -229,7 +229,9 @@ func walkSelectCases(cases []*ir.CommClause) []ir.Node {
 	r := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
 	r.Lhs = []ir.Node{chosen, recvOK}
 	fn := typecheck.LookupRuntime("selectgo")
-	r.Rhs = []ir.Node{mkcall1(fn, fn.Type().Results(), nil, bytePtrToIndex(selv, 0), bytePtrToIndex(order, 0), pc0, ir.NewInt(int64(nsends)), ir.NewInt(int64(nrecvs)), ir.NewBool(dflt == nil))}
+	var fnInit ir.Nodes
+	r.Rhs = []ir.Node{mkcall1(fn, fn.Type().Results(), &fnInit, bytePtrToIndex(selv, 0), bytePtrToIndex(order, 0), pc0, ir.NewInt(int64(nsends)), ir.NewInt(int64(nrecvs)), ir.NewBool(dflt == nil))}
+	init = append(init, fnInit...)
 	init = append(init, typecheck.Stmt(r))
 
 	// selv and order are no longer alive after selectgo.
diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index 399fb2462b..4273a62fe5 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -96,6 +96,9 @@ func convas(n *ir.AssignStmt, init *ir.Nodes) *ir.AssignStmt {
 var stop = errors.New("stop")
 
 func vmkcall(fn ir.Node, t *types.Type, init *ir.Nodes, va []ir.Node) *ir.CallExpr {
+	if init == nil {
+		base.Fatalf("mkcall with nil init: %v", fn)
+	}
 	if fn.Type() == nil || fn.Type().Kind() != types.TFUNC {
 		base.Fatalf("mkcall %v %v", fn, fn.Type())
 	}
@@ -115,10 +118,24 @@ func mkcall(name string, t *types.Type, init *ir.Nodes, args ...ir.Node) *ir.Cal
 	return vmkcall(typecheck.LookupRuntime(name), t, init, args)
 }
 
+func mkcallstmt(name string, args ...ir.Node) ir.Node {
+	return mkcallstmt1(typecheck.LookupRuntime(name), args...)
+}
+
 func mkcall1(fn ir.Node, t *types.Type, init *ir.Nodes, args ...ir.Node) *ir.CallExpr {
 	return vmkcall(fn, t, init, args)
 }
 
+func mkcallstmt1(fn ir.Node, args ...ir.Node) ir.Node {
+	var init ir.Nodes
+	n := vmkcall(fn, nil, &init, args)
+	if len(init) == 0 {
+		return n
+	}
+	init.Append(n)
+	return ir.NewBlockStmt(n.Pos(), init)
+}
+
 func chanfn(name string, n int, t *types.Type) ir.Node {
 	if !t.IsChan() {
 		base.Fatalf("chanfn %v", t)
-- 
GitLab


From fd9a391cdd08385cead816b41bed381d694859f6 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Wed, 20 Jan 2021 14:46:38 +0700
Subject: [PATCH 0536/2400] [dev.regabi] cmd/compile: remove CallExpr.Rargs

Instead, push the temps assignments to init. This does not pass
toolstash, since when before this, the temps were evaluated after
function callee, now we evaluate them before.

Change-Id: Icb9cb10e036925b56c1ef3eec468416a11f4932f
Reviewed-on: https://go-review.googlesource.com/c/go/+/284894
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/expr.go     |  1 -
 src/cmd/compile/internal/ir/node_gen.go |  5 ---
 src/cmd/compile/internal/ssagen/ssa.go  | 44 +++----------------------
 src/cmd/compile/internal/walk/expr.go   |  6 ++--
 4 files changed, 8 insertions(+), 48 deletions(-)

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index e944a0b155..b32ed71260 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -159,7 +159,6 @@ type CallExpr struct {
 	origNode
 	X         Node
 	Args      Nodes
-	Rargs     Nodes   // TODO(rsc): Delete.
 	KeepAlive []*Name // vars to be kept alive until call returns
 	IsDDD     bool
 	Use       CallUse
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index af9ee8d86e..fe436867b2 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -250,7 +250,6 @@ func (n *CallExpr) copy() Node {
 	c := *n
 	c.init = copyNodes(c.init)
 	c.Args = copyNodes(c.Args)
-	c.Rargs = copyNodes(c.Rargs)
 	c.KeepAlive = copyNames(c.KeepAlive)
 	return &c
 }
@@ -264,9 +263,6 @@ func (n *CallExpr) doChildren(do func(Node) bool) bool {
 	if doNodes(n.Args, do) {
 		return true
 	}
-	if doNodes(n.Rargs, do) {
-		return true
-	}
 	if doNames(n.KeepAlive, do) {
 		return true
 	}
@@ -278,7 +274,6 @@ func (n *CallExpr) editChildren(edit func(Node) Node) {
 		n.X = edit(n.X).(Node)
 	}
 	editNodes(n.Args, edit)
-	editNodes(n.Rargs, edit)
 	editNames(n.KeepAlive, edit)
 }
 
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 5ba8579f6a..ecf3294082 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -4492,30 +4492,8 @@ func (s *state) intrinsicCall(n *ir.CallExpr) *ssa.Value {
 
 // intrinsicArgs extracts args from n, evaluates them to SSA values, and returns them.
 func (s *state) intrinsicArgs(n *ir.CallExpr) []*ssa.Value {
-	// Construct map of temps; see comments in s.call about the structure of n.
-	temps := map[ir.Node]*ssa.Value{}
-	for _, a := range n.Args {
-		if a.Op() != ir.OAS {
-			s.Fatalf("non-assignment as a temp function argument %v", a.Op())
-		}
-		a := a.(*ir.AssignStmt)
-		l, r := a.X, a.Y
-		if l.Op() != ir.ONAME {
-			s.Fatalf("non-ONAME temp function argument %v", a.Op())
-		}
-		// Evaluate and store to "temporary".
-		// Walk ensures these temporaries are dead outside of n.
-		temps[l] = s.expr(r)
-	}
-	args := make([]*ssa.Value, len(n.Rargs))
-	for i, n := range n.Rargs {
-		// Store a value to an argument slot.
-		if x, ok := temps[n]; ok {
-			// This is a previously computed temporary.
-			args[i] = x
-			continue
-		}
-		// This is an explicit value; evaluate it.
+	args := make([]*ssa.Value, len(n.Args))
+	for i, n := range n.Args {
 		args[i] = s.expr(n)
 	}
 	return args
@@ -4528,13 +4506,6 @@ func (s *state) intrinsicArgs(n *ir.CallExpr) []*ssa.Value {
 // (as well as the deferBits variable), and this will enable us to run the proper
 // defer calls during panics.
 func (s *state) openDeferRecord(n *ir.CallExpr) {
-	// Do any needed expression evaluation for the args (including the
-	// receiver, if any). This may be evaluating something like 'autotmp_3 =
-	// once.mutex'. Such a statement will create a mapping in s.vars[] from
-	// the autotmp name to the evaluated SSA arg value, but won't do any
-	// stores to the stack.
-	s.stmtList(n.Args)
-
 	var args []*ssa.Value
 	var argNodes []*ir.Name
 
@@ -4567,7 +4538,7 @@ func (s *state) openDeferRecord(n *ir.CallExpr) {
 		opendefer.closureNode = opendefer.closure.Aux.(*ir.Name)
 		opendefer.rcvrNode = opendefer.rcvr.Aux.(*ir.Name)
 	}
-	for _, argn := range n.Rargs {
+	for _, argn := range n.Args {
 		var v *ssa.Value
 		if TypeOK(argn.Type()) {
 			v = s.openDeferSave(nil, argn.Type(), s.expr(argn))
@@ -4853,11 +4824,6 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 	types.CalcSize(fn.Type())
 	stksize := fn.Type().ArgWidth() // includes receiver, args, and results
 
-	// Run all assignments of temps.
-	// The temps are introduced to avoid overwriting argument
-	// slots when arguments themselves require function calls.
-	s.stmtList(n.Args)
-
 	var call *ssa.Value
 	if k == callDeferStack {
 		testLateExpansion = ssa.LateCallExpansionEnabledWithin(s.f)
@@ -4891,7 +4857,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		// Then, store all the arguments of the defer call.
 		ft := fn.Type()
 		off := t.FieldOff(12)
-		args := n.Rargs
+		args := n.Args
 
 		// Set receiver (for interface calls). Always a pointer.
 		if rcvr != nil {
@@ -4966,7 +4932,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 
 		// Write args.
 		t := n.X.Type()
-		args := n.Rargs
+		args := n.Args
 		if n.Op() == ir.OCALLMETH {
 			base.Fatalf("OCALLMETH missed by walkCall")
 		}
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 82a76dc239..bc4ae23759 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -535,15 +535,15 @@ func walkCall1(n *ir.CallExpr, init *ir.Nodes) {
 		if mayCall(arg) {
 			// assignment of arg to Temp
 			tmp := typecheck.Temp(param.Type)
-			a := convas(ir.NewAssignStmt(base.Pos, tmp, arg), init)
+			a := convas(typecheck.Stmt(ir.NewAssignStmt(base.Pos, tmp, arg)).(*ir.AssignStmt), init)
 			tempAssigns = append(tempAssigns, a)
 			// replace arg with temp
 			args[i] = tmp
 		}
 	}
 
-	n.Args = tempAssigns
-	n.Rargs = args
+	init.Append(tempAssigns...)
+	n.Args = args
 }
 
 // walkDivMod walks an ODIV or OMOD node.
-- 
GitLab


From 68a46644752b6bc8de8d2b82b7f2354f3b52b50a Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Thu, 21 Jan 2021 12:08:46 +0700
Subject: [PATCH 0537/2400] [dev.regabi] cmd/compile: remove tempAssigns in
 walkCall1

Passes toolstash -cmp.

Change-Id: I588c663324443e02b901cda461b999ff192e150c
Reviewed-on: https://go-review.googlesource.com/c/go/+/284896
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/walk/expr.go | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index bc4ae23759..d7a20206c8 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -521,10 +521,6 @@ func walkCall1(n *ir.CallExpr, init *ir.Nodes) {
 	n.X = walkExpr(n.X, init)
 	walkExprList(args, init)
 
-	// For any argument whose evaluation might require a function call,
-	// store that argument into a temporary variable,
-	// to prevent that calls from clobbering arguments already on the stack.
-	var tempAssigns []ir.Node
 	for i, arg := range args {
 		// Validate argument and parameter types match.
 		param := params.Field(i)
@@ -532,17 +528,18 @@ func walkCall1(n *ir.CallExpr, init *ir.Nodes) {
 			base.FatalfAt(n.Pos(), "assigning %L to parameter %v (type %v)", arg, param.Sym, param.Type)
 		}
 
+		// For any argument whose evaluation might require a function call,
+		// store that argument into a temporary variable,
+		// to prevent that calls from clobbering arguments already on the stack.
 		if mayCall(arg) {
 			// assignment of arg to Temp
 			tmp := typecheck.Temp(param.Type)
-			a := convas(typecheck.Stmt(ir.NewAssignStmt(base.Pos, tmp, arg)).(*ir.AssignStmt), init)
-			tempAssigns = append(tempAssigns, a)
+			init.Append(convas(typecheck.Stmt(ir.NewAssignStmt(base.Pos, tmp, arg)).(*ir.AssignStmt), init))
 			// replace arg with temp
 			args[i] = tmp
 		}
 	}
 
-	init.Append(tempAssigns...)
 	n.Args = args
 }
 
-- 
GitLab


From 18bd7aa62581f313c86164d763b1e246307888a9 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 20 Jan 2021 17:03:36 -0800
Subject: [PATCH 0538/2400] [dev.typeparams] cmd/compile: use nil instead of
 syntax.ImplicitOne

Represent x++/-- as x +=/-= with the RHS of the assignment being nil
rather than syntax.ImplicitOne.

Dependent code already had to check for syntax.ImplicitOne, but
then shared some existing code for regular assignment operations.
Now always handle this case fully explicit, which simplifies the
code.

Change-Id: I28c7918153c27cbbf97b041d0c85ff027c58687c
Reviewed-on: https://go-review.googlesource.com/c/go/+/285172
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/noder/expr.go     |  4 --
 src/cmd/compile/internal/noder/noder.go    | 16 +++---
 src/cmd/compile/internal/noder/stmt.go     |  2 +-
 src/cmd/compile/internal/syntax/nodes.go   |  2 +-
 src/cmd/compile/internal/syntax/parser.go  |  6 +--
 src/cmd/compile/internal/syntax/printer.go |  2 +-
 src/cmd/compile/internal/syntax/walk.go    |  4 +-
 src/cmd/compile/internal/types2/expr.go    |  1 +
 src/cmd/compile/internal/types2/pos.go     |  2 +-
 src/cmd/compile/internal/types2/stmt.go    | 62 +++++++++++-----------
 10 files changed, 48 insertions(+), 53 deletions(-)

diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index be592003e1..76db774229 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -19,10 +19,6 @@ func (g *irgen) expr(expr syntax.Expr) ir.Node {
 		return nil
 	}
 
-	if expr == syntax.ImplicitOne {
-		base.Fatalf("expr of ImplicitOne")
-	}
-
 	if expr, ok := expr.(*syntax.Name); ok && expr.Value == "_" {
 		return ir.BlankNode
 	}
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 0c7d015977..e1ae2569e0 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -677,11 +677,7 @@ func (p *noder) expr(expr syntax.Expr) ir.Node {
 	case *syntax.Name:
 		return p.mkname(expr)
 	case *syntax.BasicLit:
-		pos := base.Pos
-		if expr != syntax.ImplicitOne { // ImplicitOne doesn't have a unique position
-			pos = p.pos(expr)
-		}
-		n := ir.NewBasicLit(pos, p.basicLit(expr))
+		n := ir.NewBasicLit(p.pos(expr), p.basicLit(expr))
 		if expr.Kind == syntax.RuneLit {
 			n.SetType(types.UntypedRune)
 		}
@@ -1039,9 +1035,15 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) ir.Node {
 	case *syntax.DeclStmt:
 		return ir.NewBlockStmt(src.NoXPos, p.decls(stmt.DeclList))
 	case *syntax.AssignStmt:
+		if stmt.Rhs == nil {
+			pos := p.pos(stmt)
+			n := ir.NewAssignOpStmt(pos, p.binOp(stmt.Op), p.expr(stmt.Lhs), ir.NewBasicLit(pos, one))
+			n.IncDec = true
+			return n
+		}
+
 		if stmt.Op != 0 && stmt.Op != syntax.Def {
 			n := ir.NewAssignOpStmt(p.pos(stmt), p.binOp(stmt.Op), p.expr(stmt.Lhs), p.expr(stmt.Rhs))
-			n.IncDec = stmt.Rhs == syntax.ImplicitOne
 			return n
 		}
 
@@ -1502,7 +1504,7 @@ func (p *noder) wrapname(n syntax.Node, x ir.Node) ir.Node {
 }
 
 func (p *noder) setlineno(n syntax.Node) {
-	if n != nil && n != syntax.ImplicitOne {
+	if n != nil {
 		base.Pos = p.pos(n)
 	}
 }
diff --git a/src/cmd/compile/internal/noder/stmt.go b/src/cmd/compile/internal/noder/stmt.go
index 7d79595a04..267a34dbc8 100644
--- a/src/cmd/compile/internal/noder/stmt.go
+++ b/src/cmd/compile/internal/noder/stmt.go
@@ -53,7 +53,7 @@ func (g *irgen) stmt0(stmt syntax.Stmt) ir.Node {
 	case *syntax.AssignStmt:
 		if stmt.Op != 0 && stmt.Op != syntax.Def {
 			op := g.op(stmt.Op, binOps[:])
-			if stmt.Rhs == syntax.ImplicitOne {
+			if stmt.Rhs == nil {
 				return IncDec(g.pos(stmt), op, g.expr(stmt.Lhs))
 			}
 			return ir.NewAssignOpStmt(g.pos(stmt), op, g.expr(stmt.Lhs), g.expr(stmt.Rhs))
diff --git a/src/cmd/compile/internal/syntax/nodes.go b/src/cmd/compile/internal/syntax/nodes.go
index a06d6e85b1..fb9786daa3 100644
--- a/src/cmd/compile/internal/syntax/nodes.go
+++ b/src/cmd/compile/internal/syntax/nodes.go
@@ -367,7 +367,7 @@ type (
 
 	AssignStmt struct {
 		Op       Operator // 0 means no operation
-		Lhs, Rhs Expr     // Rhs == ImplicitOne means Lhs++ (Op == Add) or Lhs-- (Op == Sub)
+		Lhs, Rhs Expr     // Rhs == nil means Lhs++ (Op == Add) or Lhs-- (Op == Sub)
 		simpleStmt
 	}
 
diff --git a/src/cmd/compile/internal/syntax/parser.go b/src/cmd/compile/internal/syntax/parser.go
index e3fb1003a2..c4ccbb82cb 100644
--- a/src/cmd/compile/internal/syntax/parser.go
+++ b/src/cmd/compile/internal/syntax/parser.go
@@ -1874,10 +1874,6 @@ func (p *parser) badExpr() *BadExpr {
 // ----------------------------------------------------------------------------
 // Statements
 
-// We represent x++, x-- as assignments x += ImplicitOne, x -= ImplicitOne.
-// ImplicitOne should not be used elsewhere.
-var ImplicitOne = &BasicLit{Value: "1"}
-
 // SimpleStmt = EmptyStmt | ExpressionStmt | SendStmt | IncDecStmt | Assignment | ShortVarDecl .
 func (p *parser) simpleStmt(lhs Expr, keyword token) SimpleStmt {
 	if trace {
@@ -1910,7 +1906,7 @@ func (p *parser) simpleStmt(lhs Expr, keyword token) SimpleStmt {
 			// lhs++ or lhs--
 			op := p.op
 			p.next()
-			return p.newAssignStmt(pos, op, lhs, ImplicitOne)
+			return p.newAssignStmt(pos, op, lhs, nil)
 
 		case _Arrow:
 			// lhs <- rhs
diff --git a/src/cmd/compile/internal/syntax/printer.go b/src/cmd/compile/internal/syntax/printer.go
index 161eb0d092..9109ce2363 100644
--- a/src/cmd/compile/internal/syntax/printer.go
+++ b/src/cmd/compile/internal/syntax/printer.go
@@ -549,7 +549,7 @@ func (p *printer) printRawNode(n Node) {
 
 	case *AssignStmt:
 		p.print(n.Lhs)
-		if n.Rhs == ImplicitOne {
+		if n.Rhs == nil {
 			// TODO(gri) This is going to break the mayCombine
 			//           check once we enable that again.
 			p.print(n.Op, n.Op) // ++ or --
diff --git a/src/cmd/compile/internal/syntax/walk.go b/src/cmd/compile/internal/syntax/walk.go
index 418b26d674..c26e97a0d8 100644
--- a/src/cmd/compile/internal/syntax/walk.go
+++ b/src/cmd/compile/internal/syntax/walk.go
@@ -207,7 +207,9 @@ func (w *walker) node(n Node) {
 
 	case *AssignStmt:
 		w.node(n.Lhs)
-		w.node(n.Rhs)
+		if n.Rhs != nil {
+			w.node(n.Rhs)
+		}
 
 	case *BranchStmt:
 		if n.Label != nil {
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index b728238d9f..22dc47b1e7 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -889,6 +889,7 @@ var binaryOpPredicates = opPredicates{
 }
 
 // The binary expression e may be nil. It's passed in for better error messages only.
+// TODO(gri) revisit use of e and opPos
 func (check *Checker) binary(x *operand, e *syntax.Operation, lhs, rhs syntax.Expr, op syntax.Operator, opPos syntax.Pos) {
 	var y operand
 
diff --git a/src/cmd/compile/internal/types2/pos.go b/src/cmd/compile/internal/types2/pos.go
index 0a19cd1a23..955bb2ad08 100644
--- a/src/cmd/compile/internal/types2/pos.go
+++ b/src/cmd/compile/internal/types2/pos.go
@@ -286,7 +286,7 @@ func endPos(n syntax.Node) syntax.Pos {
 			return n.Pos()
 		case *syntax.AssignStmt:
 			m = n.Rhs
-			if m == syntax.ImplicitOne {
+			if m == nil {
 				p := endPos(n.Lhs)
 				return syntax.MakePos(p.Base(), p.Line(), p.Col()+2)
 			}
diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go
index 52b9794c10..cbfe97b03c 100644
--- a/src/cmd/compile/internal/types2/stmt.go
+++ b/src/cmd/compile/internal/types2/stmt.go
@@ -367,47 +367,45 @@ func (check *Checker) stmt(ctxt stmtContext, s syntax.Stmt) {
 
 	case *syntax.AssignStmt:
 		lhs := unpackExpr(s.Lhs)
-		rhs := unpackExpr(s.Rhs)
-		if s.Op == 0 || s.Op == syntax.Def {
-			// regular assignment or short variable declaration
-			if len(lhs) == 0 {
-				check.invalidASTf(s, "missing lhs in assignment")
-				return
-			}
-			if s.Op == syntax.Def {
-				check.shortVarDecl(s.Pos(), lhs, rhs)
-			} else {
-				// regular assignment
-				check.assignVars(lhs, rhs)
-			}
-		} else {
-			// assignment operations
-			if len(lhs) != 1 || len(rhs) != 1 {
-				check.errorf(s, "assignment operation %s requires single-valued expressions", s.Op)
+		if s.Rhs == nil {
+			// x++ or x--
+			if len(lhs) != 1 {
+				check.invalidASTf(s, "%s%s requires one operand", s.Op, s.Op)
 				return
 			}
-
-			// provide better error messages for x++ and x--
-			if rhs[0] == syntax.ImplicitOne {
-				var x operand
-				check.expr(&x, lhs[0])
-				if x.mode == invalid {
-					return
-				}
-				if !isNumeric(x.typ) {
-					check.invalidOpf(lhs[0], "%s%s%s (non-numeric type %s)", lhs[0], s.Op, s.Op, x.typ)
-					return
-				}
-			}
-
 			var x operand
-			check.binary(&x, nil, lhs[0], rhs[0], s.Op, rhs[0].Pos()) // TODO(gri) should have TokPos here (like in go/types)
+			check.expr(&x, lhs[0])
 			if x.mode == invalid {
 				return
 			}
+			if !isNumeric(x.typ) {
+				check.invalidOpf(lhs[0], "%s%s%s (non-numeric type %s)", lhs[0], s.Op, s.Op, x.typ)
+				return
+			}
 			check.assignVar(lhs[0], &x)
+			return
+		}
+
+		rhs := unpackExpr(s.Rhs)
+		switch s.Op {
+		case 0:
+			check.assignVars(lhs, rhs)
+			return
+		case syntax.Def:
+			check.shortVarDecl(s.Pos(), lhs, rhs)
+			return
+		}
+
+		// assignment operations
+		if len(lhs) != 1 || len(rhs) != 1 {
+			check.errorf(s, "assignment operation %s requires single-valued expressions", s.Op)
+			return
 		}
 
+		var x operand
+		check.binary(&x, nil, lhs[0], rhs[0], s.Op, s.Pos())
+		check.assignVar(lhs[0], &x)
+
 	// case *syntax.GoStmt:
 	// 	check.suspendedCall("go", s.Call)
 
-- 
GitLab


From 970d8b6cb2ca5302f09a4eb8bfe90c4baea9cf88 Mon Sep 17 00:00:00 2001
From: Baokun Lee <bk@golangcn.org>
Date: Thu, 21 Jan 2021 14:13:36 +0800
Subject: [PATCH 0539/2400] [dev.regabi] cmd/compile: replace ir.Name map with
 ir.NameSet in inlining

As CL 282212 mentioned, we should clean all map[*ir.Name]bool with
ir.NameSet.

Passes toolstash -cmp.

Updates #43819

Change-Id: I1ce5d2055f88539f807dc021cd8e3941b425bc4e
Reviewed-on: https://go-review.googlesource.com/c/go/+/284897
Run-TryBot: Baokun Lee <bk@golangcn.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Baokun Lee <bk@golangcn.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/inline/inl.go | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 46f093b1f8..83f6740a48 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -73,7 +73,7 @@ func InlinePackage() {
 	})
 }
 
-// Caninl determines whether fn is inlineable.
+// CanInline determines whether fn is inlineable.
 // If so, CanInline saves fn->nbody in fn->inl and substitutes it with a copy.
 // fn and ->nbody will already have been typechecked.
 func CanInline(fn *ir.Func) {
@@ -169,7 +169,6 @@ func CanInline(fn *ir.Func) {
 	visitor := hairyVisitor{
 		budget:        inlineMaxBudget,
 		extraCallCost: cc,
-		usedLocals:    make(map[*ir.Name]bool),
 	}
 	if visitor.tooHairy(fn) {
 		reason = visitor.reason
@@ -254,7 +253,7 @@ type hairyVisitor struct {
 	budget        int32
 	reason        string
 	extraCallCost int32
-	usedLocals    map[*ir.Name]bool
+	usedLocals    ir.NameSet
 	do            func(ir.Node) bool
 }
 
@@ -410,7 +409,7 @@ func (v *hairyVisitor) doNode(n ir.Node) bool {
 	case ir.ONAME:
 		n := n.(*ir.Name)
 		if n.Class == ir.PAUTO {
-			v.usedLocals[n] = true
+			v.usedLocals.Add(n)
 		}
 
 	case ir.OBLOCK:
@@ -1383,7 +1382,7 @@ func pruneUnusedAutos(ll []*ir.Name, vis *hairyVisitor) []*ir.Name {
 	s := make([]*ir.Name, 0, len(ll))
 	for _, n := range ll {
 		if n.Class == ir.PAUTO {
-			if _, found := vis.usedLocals[n]; !found {
+			if !vis.usedLocals.Has(n) {
 				continue
 			}
 		}
-- 
GitLab


From 5248f59a224e390cc59c9850f7795479f07757a7 Mon Sep 17 00:00:00 2001
From: Baokun Lee <bk@golangcn.org>
Date: Thu, 21 Jan 2021 15:07:25 +0800
Subject: [PATCH 0540/2400] [dev.regabi] cmd/compile: replace ir.Name map with
 ir.NameSet for SSA

Same as CL 284897, but for SSA.

Passes toolstash -cmp.

Updates #43819

Change-Id: I3c500ad635a3192d95d16fdc36f154ba3ea5df69
Reviewed-on: https://go-review.googlesource.com/c/go/+/284898
Run-TryBot: Baokun Lee <bk@golangcn.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Baokun Lee <bk@golangcn.org>
---
 src/cmd/compile/internal/ssa/deadstore.go | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/deadstore.go b/src/cmd/compile/internal/ssa/deadstore.go
index 530918da4d..0cf9931dbc 100644
--- a/src/cmd/compile/internal/ssa/deadstore.go
+++ b/src/cmd/compile/internal/ssa/deadstore.go
@@ -139,7 +139,7 @@ func dse(f *Func) {
 func elimDeadAutosGeneric(f *Func) {
 	addr := make(map[*Value]*ir.Name) // values that the address of the auto reaches
 	elim := make(map[*Value]*ir.Name) // values that could be eliminated if the auto is
-	used := make(map[*ir.Name]bool)   // used autos that must be kept
+	var used ir.NameSet               // used autos that must be kept
 
 	// visit the value and report whether any of the maps are updated
 	visit := func(v *Value) (changed bool) {
@@ -178,8 +178,8 @@ func elimDeadAutosGeneric(f *Func) {
 			if !ok || n.Class != ir.PAUTO {
 				return
 			}
-			if !used[n] {
-				used[n] = true
+			if !used.Has(n) {
+				used.Add(n)
 				changed = true
 			}
 			return
@@ -212,8 +212,8 @@ func elimDeadAutosGeneric(f *Func) {
 		if v.Type.IsMemory() || v.Type.IsFlags() || v.Op == OpPhi || v.MemoryArg() != nil {
 			for _, a := range args {
 				if n, ok := addr[a]; ok {
-					if !used[n] {
-						used[n] = true
+					if !used.Has(n) {
+						used.Add(n)
 						changed = true
 					}
 				}
@@ -224,7 +224,7 @@ func elimDeadAutosGeneric(f *Func) {
 		// Propagate any auto addresses through v.
 		var node *ir.Name
 		for _, a := range args {
-			if n, ok := addr[a]; ok && !used[n] {
+			if n, ok := addr[a]; ok && !used.Has(n) {
 				if node == nil {
 					node = n
 				} else if node != n {
@@ -233,7 +233,7 @@ func elimDeadAutosGeneric(f *Func) {
 					// multiple pointers (e.g. NeqPtr, Phi etc.).
 					// This is rare, so just propagate the first
 					// value to keep things simple.
-					used[n] = true
+					used.Add(n)
 					changed = true
 				}
 			}
@@ -249,7 +249,7 @@ func elimDeadAutosGeneric(f *Func) {
 		}
 		if addr[v] != node {
 			// This doesn't happen in practice, but catch it just in case.
-			used[node] = true
+			used.Add(node)
 			changed = true
 		}
 		return
@@ -269,8 +269,8 @@ func elimDeadAutosGeneric(f *Func) {
 			}
 			// keep the auto if its address reaches a control value
 			for _, c := range b.ControlValues() {
-				if n, ok := addr[c]; ok && !used[n] {
-					used[n] = true
+				if n, ok := addr[c]; ok && !used.Has(n) {
+					used.Add(n)
 					changed = true
 				}
 			}
@@ -282,7 +282,7 @@ func elimDeadAutosGeneric(f *Func) {
 
 	// Eliminate stores to unread autos.
 	for v, n := range elim {
-		if used[n] {
+		if used.Has(n) {
 			continue
 		}
 		// replace with OpCopy
-- 
GitLab


From d7e71c01ad1c8edd568380ce9276c265dfd3635b Mon Sep 17 00:00:00 2001
From: Baokun Lee <bk@golangcn.org>
Date: Thu, 21 Jan 2021 15:24:38 +0800
Subject: [PATCH 0541/2400] [dev.regabi] cmd/compile: replace ir.Name map with
 ir.NameSet for dwarf

Same as CL 284897, but for dwarf.

Passes toolstash -cmp.

Fixes #43819

Change-Id: Icbe43aa2e3cb96e6a6c318523c643247da8e4c74
Reviewed-on: https://go-review.googlesource.com/c/go/+/284899
Run-TryBot: Baokun Lee <bk@golangcn.org>
Trust: Baokun Lee <bk@golangcn.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/dwarfgen/dwarf.go | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/internal/dwarfgen/dwarf.go b/src/cmd/compile/internal/dwarfgen/dwarf.go
index bf039c8fbb..dd22c033cc 100644
--- a/src/cmd/compile/internal/dwarfgen/dwarf.go
+++ b/src/cmd/compile/internal/dwarfgen/dwarf.go
@@ -136,7 +136,7 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 	// Collect a raw list of DWARF vars.
 	var vars []*dwarf.Var
 	var decls []*ir.Name
-	var selected map[*ir.Name]bool
+	var selected ir.NameSet
 	if base.Ctxt.Flag_locationlists && base.Ctxt.Flag_optimize && fn.DebugInfo != nil && complexOK {
 		decls, vars, selected = createComplexVars(fnsym, fn)
 	} else {
@@ -161,7 +161,7 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 	// For non-SSA-able arguments, however, the correct information
 	// is known -- they have a single home on the stack.
 	for _, n := range dcl {
-		if _, found := selected[n]; found {
+		if selected.Has(n) {
 			continue
 		}
 		c := n.Sym().Name[0]
@@ -244,10 +244,10 @@ func preInliningDcls(fnsym *obj.LSym) []*ir.Name {
 
 // createSimpleVars creates a DWARF entry for every variable declared in the
 // function, claiming that they are permanently on the stack.
-func createSimpleVars(fnsym *obj.LSym, apDecls []*ir.Name) ([]*ir.Name, []*dwarf.Var, map[*ir.Name]bool) {
+func createSimpleVars(fnsym *obj.LSym, apDecls []*ir.Name) ([]*ir.Name, []*dwarf.Var, ir.NameSet) {
 	var vars []*dwarf.Var
 	var decls []*ir.Name
-	selected := make(map[*ir.Name]bool)
+	var selected ir.NameSet
 	for _, n := range apDecls {
 		if ir.IsAutoTmp(n) {
 			continue
@@ -255,7 +255,7 @@ func createSimpleVars(fnsym *obj.LSym, apDecls []*ir.Name) ([]*ir.Name, []*dwarf
 
 		decls = append(decls, n)
 		vars = append(vars, createSimpleVar(fnsym, n))
-		selected[n] = true
+		selected.Add(n)
 	}
 	return decls, vars, selected
 }
@@ -312,19 +312,19 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 
 // createComplexVars creates recomposed DWARF vars with location lists,
 // suitable for describing optimized code.
-func createComplexVars(fnsym *obj.LSym, fn *ir.Func) ([]*ir.Name, []*dwarf.Var, map[*ir.Name]bool) {
+func createComplexVars(fnsym *obj.LSym, fn *ir.Func) ([]*ir.Name, []*dwarf.Var, ir.NameSet) {
 	debugInfo := fn.DebugInfo.(*ssa.FuncDebug)
 
 	// Produce a DWARF variable entry for each user variable.
 	var decls []*ir.Name
 	var vars []*dwarf.Var
-	ssaVars := make(map[*ir.Name]bool)
+	var ssaVars ir.NameSet
 
 	for varID, dvar := range debugInfo.Vars {
 		n := dvar
-		ssaVars[n] = true
+		ssaVars.Add(n)
 		for _, slot := range debugInfo.VarSlots[varID] {
-			ssaVars[debugInfo.Slots[slot].N] = true
+			ssaVars.Add(debugInfo.Slots[slot].N)
 		}
 
 		if dvar := createComplexVar(fnsym, fn, ssa.VarID(varID)); dvar != nil {
-- 
GitLab


From f8654579cdd637167bb38d38f0de76abc812d34c Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 21 Jan 2021 20:20:22 -0800
Subject: [PATCH 0542/2400] [dev.typeparams] cmd/compile/internal/types2:
 adjust errors in branch checking code, fix a bug

The types2.Config.IgnoreBranches flag mistakenly excluded a
set of label-unrelated branch checks. After fixing this and
also adjusting some error messages to match the existing
compiler errors, more errorcheck tests pass now with the -G
option.

Renamed IngnoreBranches to IgnoreLabels since its controlling
label checks, not all branch statement (such as continue, etc)
checks.

Change-Id: I0819f56eb132ce76c9a9628d8942af756691065a
Reviewed-on: https://go-review.googlesource.com/c/go/+/285652
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/noder/irgen.go |  2 +-
 src/cmd/compile/internal/types2/api.go  |  7 +++----
 src/cmd/compile/internal/types2/stmt.go | 23 +++++++++++++----------
 test/run.go                             |  3 ---
 4 files changed, 17 insertions(+), 18 deletions(-)

diff --git a/src/cmd/compile/internal/noder/irgen.go b/src/cmd/compile/internal/noder/irgen.go
index 5c779ab810..95b8946c95 100644
--- a/src/cmd/compile/internal/noder/irgen.go
+++ b/src/cmd/compile/internal/noder/irgen.go
@@ -35,7 +35,7 @@ func check2(noders []*noder) {
 	// typechecking
 	conf := types2.Config{
 		InferFromConstraints:  true,
-		IgnoreBranches:        true, // parser already checked via syntax.CheckBranches mode
+		IgnoreLabels:          true, // parser already checked via syntax.CheckBranches mode
 		CompilerErrorMessages: true, // use error strings matching existing compiler errors
 		Error: func(err error) {
 			terr := err.(types2.Error)
diff --git a/src/cmd/compile/internal/types2/api.go b/src/cmd/compile/internal/types2/api.go
index 7f6653b825..b29c0802ed 100644
--- a/src/cmd/compile/internal/types2/api.go
+++ b/src/cmd/compile/internal/types2/api.go
@@ -119,10 +119,9 @@ type Config struct {
 	//          Do not use casually!
 	FakeImportC bool
 
-	// If IgnoreBranches is set, errors related to incorrectly placed
-	// labels, gotos, break, continue, and fallthrough statements are
-	// ignored.
-	IgnoreBranches bool
+	// If IgnoreLabels is set, correct label use is not checked.
+	// TODO(gri) Consolidate label checking and remove this flag.
+	IgnoreLabels bool
 
 	// If CompilerErrorMessages is set, errors are reported using
 	// cmd/compile error strings to match $GOROOT/test errors.
diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go
index cbfe97b03c..ca0abcd10c 100644
--- a/src/cmd/compile/internal/types2/stmt.go
+++ b/src/cmd/compile/internal/types2/stmt.go
@@ -41,8 +41,7 @@ func (check *Checker) funcBody(decl *declInfo, name string, sig *Signature, body
 
 	check.stmtList(0, body.List)
 
-	if check.hasLabel {
-		assert(!check.conf.IgnoreBranches)
+	if check.hasLabel && !check.conf.IgnoreLabels {
 		check.labels(body)
 	}
 
@@ -321,7 +320,7 @@ func (check *Checker) stmt(ctxt stmtContext, s syntax.Stmt) {
 		check.declStmt(s.DeclList)
 
 	case *syntax.LabeledStmt:
-		check.hasLabel = !check.conf.IgnoreBranches
+		check.hasLabel = true
 		check.stmt(ctxt, s.Stmt)
 
 	case *syntax.ExprStmt:
@@ -446,22 +445,26 @@ func (check *Checker) stmt(ctxt stmtContext, s syntax.Stmt) {
 		}
 
 	case *syntax.BranchStmt:
-		if check.conf.IgnoreBranches {
-			break
-		}
-
 		if s.Label != nil {
 			check.hasLabel = true
-			return // checked in 2nd pass (check.labels)
+			break // checked in 2nd pass (check.labels)
 		}
 		switch s.Tok {
 		case syntax.Break:
 			if ctxt&breakOk == 0 {
-				check.error(s, "break not in for, switch, or select statement")
+				if check.conf.CompilerErrorMessages {
+					check.error(s, "break is not in a loop, switch, or select statement")
+				} else {
+					check.error(s, "break not in for, switch, or select statement")
+				}
 			}
 		case syntax.Continue:
 			if ctxt&continueOk == 0 {
-				check.error(s, "continue not in for statement")
+				if check.conf.CompilerErrorMessages {
+					check.error(s, "continue is not in a loop")
+				} else {
+					check.error(s, "continue not in for statement")
+				}
 			}
 		case syntax.Fallthrough:
 			if ctxt&fallthroughOk == 0 {
diff --git a/test/run.go b/test/run.go
index 5315f9867d..f2f17c4f20 100644
--- a/test/run.go
+++ b/test/run.go
@@ -1937,13 +1937,11 @@ var excluded = map[string]bool{
 	"initializerr.go": true, // types2 reports extra errors
 	"linkname2.go":    true, // error reported by noder (not running for types2 errorcheck test)
 	"shift1.go":       true, // issue #42989
-	"switch4.go":      true, // error reported by noder (not running for types2 errorcheck test)
 	"typecheck.go":    true, // invalid function is not causing errors when called
 
 	"fixedbugs/bug176.go":    true, // types2 reports all errors (pref: types2)
 	"fixedbugs/bug193.go":    true, // types2 bug: shift error not reported (fixed in go/types)
 	"fixedbugs/bug195.go":    true, // types2 reports slightly different (but correct) bugs
-	"fixedbugs/bug213.go":    true, // error reported by noder (not running for types2 errorcheck test)
 	"fixedbugs/bug228.go":    true, // types2 not run after syntax errors
 	"fixedbugs/bug231.go":    true, // types2 bug? (same error reported twice)
 	"fixedbugs/bug255.go":    true, // types2 reports extra errors
@@ -1986,7 +1984,6 @@ var excluded = map[string]bool{
 	"fixedbugs/issue4232.go":   true, // types2 reports (correct) extra errors
 	"fixedbugs/issue4452.go":   true, // types2 reports (correct) extra errors
 	"fixedbugs/issue5609.go":   true, // types2 needs a better error message
-	"fixedbugs/issue6500.go":   true, // error reported by noder (not running for types2 errorcheck test)
 	"fixedbugs/issue6889.go":   true, // types2 can handle this without constant overflow
 	"fixedbugs/issue7525.go":   true, // types2 reports init cycle error on different line - ok otherwise
 	"fixedbugs/issue7525b.go":  true, // types2 reports init cycle error on different line - ok otherwise
-- 
GitLab


From 12cd9cf7e080806f86595d71078a30e654458ebe Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Tue, 19 Jan 2021 13:54:33 -0800
Subject: [PATCH 0543/2400] [dev.typeparams] cmd/compile: disambiguate OXDOT in
 noder using types2 Selection info

By using the types2 Selection information, we can create ODOT, ODOTPTR,
OCALLPART, ODOTMETH, ODOTINTER, and OMETHEXPR nodes directly in noder,
so we don't have to do that functionality in typecheck.go. Intermediate
nodes are created as needed for embedded fields. Don't have to typecheck
the results of g.selectorExpr(), because we set the types of all the
needed nodes.

There is one bug remaining in 'go test reflect' that will be fixed when dev.regabi is merged.

Change-Id: I4599d43197783e318610deb2f208137f9344ab63
Reviewed-on: https://go-review.googlesource.com/c/go/+/285373
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/noder/expr.go     | 92 +++++++++++++++++++++-
 src/cmd/compile/internal/noder/helpers.go  |  6 +-
 src/cmd/compile/internal/noder/irgen.go    |  9 +++
 src/cmd/compile/internal/typecheck/subr.go |  7 +-
 src/reflect/all_test.go                    | 76 +++++++++---------
 5 files changed, 142 insertions(+), 48 deletions(-)

diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index 76db774229..b38e9cfb4e 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -11,6 +11,7 @@ import (
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/compile/internal/types2"
+	"cmd/internal/src"
 )
 
 func (g *irgen) expr(expr syntax.Expr) ir.Node {
@@ -106,9 +107,7 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 			}
 		}
 
-		// TODO(mdempsky/danscales): Use g.info.Selections[expr]
-		// to resolve field/method selection. See CL 280633.
-		return typecheck.Expr(ir.NewSelectorExpr(pos, ir.OXDOT, g.expr(expr.X), g.name(expr.Sel)))
+		return g.selectorExpr(pos, typ, expr)
 	case *syntax.SliceExpr:
 		return Slice(pos, g.expr(expr.X), g.expr(expr.Index[0]), g.expr(expr.Index[1]), g.expr(expr.Index[2]))
 
@@ -129,6 +128,93 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 	}
 }
 
+// selectorExpr resolves the choice of ODOT, ODOTPTR, OCALLPART (eventually
+// ODOTMETH & ODOTINTER), and OMETHEXPR and deals with embedded fields here rather
+// than in typecheck.go.
+func (g *irgen) selectorExpr(pos src.XPos, typ types2.Type, expr *syntax.SelectorExpr) ir.Node {
+	x := g.expr(expr.X)
+	selinfo := g.info.Selections[expr]
+	nindex := len(selinfo.Index())
+
+	// Iterate through the selections from types2. If nindex > 1, then we will
+	// create extra nodes to deal with embedded fields.
+	for i := 0; i < nindex; i++ {
+		var f *types.Field
+		var n *ir.SelectorExpr
+
+		op := ir.ODOT
+		index := selinfo.Index()[i]
+		xt := x.Type()
+		origxt := xt
+		if xt.IsPtr() && !xt.Elem().IsInterface() {
+			// Get to the base type, but remember that we skipped the ptr
+			xt = xt.Elem()
+			op = ir.ODOTPTR
+		}
+		types.CalcSize(xt)
+		// Everything up to the last selection is an embedded field
+		// access, and the last selection is determined by selinfo.Kind().
+		if i < nindex-1 || selinfo.Kind() == types2.FieldVal {
+			f = xt.Field(index)
+			sym := f.Sym
+			n = ir.NewSelectorExpr(pos, op, x, sym)
+			if i < nindex-1 {
+				n.SetImplicit(true)
+				typed(f.Type, n)
+			}
+		} else if selinfo.Kind() == types2.MethodExpr {
+			var ms *types.Fields
+			if xt.IsInterface() {
+				// TODO(danscales,mdempsky): interface method sets
+				// are not sorted the same between types and
+				// types2. In particular, this will likely fail if
+				// an interface contains unexported methods from
+				// two different packages (due to cross-package
+				// interface embedding).
+				ms = xt.Fields()
+			} else {
+				mt := types.ReceiverBaseType(xt)
+				ms = mt.Methods()
+			}
+			f = ms.Slice()[index]
+			n = ir.NewSelectorExpr(pos, ir.OMETHEXPR, x, f.Sym)
+		} else { // types.MethodVal
+			if xt.IsInterface() {
+				f = xt.Field(index)
+			} else {
+				f = xt.Methods().Slice()[index]
+				rcvr := f.Type.Recv().Type
+				if rcvr.IsPtr() && types.Identical(rcvr.Elem(), origxt) {
+					addr := typecheck.NodAddrAt(pos, x)
+					addr.SetImplicit(true)
+					typed(xt.PtrTo(), addr)
+					x = addr
+				} else if op == ir.ODOTPTR && !rcvr.IsPtr() {
+					star := ir.NewStarExpr(pos, x)
+					star.SetImplicit(true)
+					typed(xt, star)
+					x = star
+				}
+			}
+			// We will change OCALLPART to ODOTMETH or ODOTINTER in
+			// Call() if n is actually called.
+			n = ir.NewSelectorExpr(pos, ir.OCALLPART, x, f.Sym)
+		}
+		n.Selection = f
+		x = n
+	}
+
+	// We don't set type on x for the last index (i == nindex - 1), since that
+	// is the actual selection (ignoring embedded fields) and may be an
+	// OMETHEXPR or OCALLPART operation. In those cases, the type to set on the
+	// node will be different from the type derived from the field/method
+	// selection. Instead for the last index, we always set the type (at the
+	// end of the function) from g.typ(typ).
+	typed(g.typ(typ), x)
+	types.CalcSize(x.Type())
+	return x
+}
+
 func (g *irgen) exprList(expr syntax.Expr) []ir.Node {
 	switch expr := expr.(type) {
 	case nil:
diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
index 3c20f74d8b..e43ea630bd 100644
--- a/src/cmd/compile/internal/noder/helpers.go
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -79,9 +79,7 @@ func Call(pos src.XPos, fun ir.Node, args []ir.Node, dots bool) ir.Node {
 		}
 	}
 
-	// We probably already typechecked fun, and typecheck probably
-	// got it wrong because it didn't know the expression was
-	// going to be called immediately. Correct its mistakes.
+	// Add information, now that we know that fun is actually being called.
 	switch fun := fun.(type) {
 	case *ir.ClosureExpr:
 		fun.Func.SetClosureCalled(true)
@@ -92,6 +90,8 @@ func Call(pos src.XPos, fun ir.Node, args []ir.Node, dots bool) ir.Node {
 				op = ir.ODOTINTER
 			}
 			fun.SetOp(op)
+			// Set the type to include the receiver, since that's what
+			// later parts of the compiler expect
 			fun.SetType(fun.Selection.Type)
 		}
 	}
diff --git a/src/cmd/compile/internal/noder/irgen.go b/src/cmd/compile/internal/noder/irgen.go
index 95b8946c95..5456005598 100644
--- a/src/cmd/compile/internal/noder/irgen.go
+++ b/src/cmd/compile/internal/noder/irgen.go
@@ -5,6 +5,7 @@
 package noder
 
 import (
+	"fmt"
 	"os"
 
 	"cmd/compile/internal/base"
@@ -162,6 +163,14 @@ Outer:
 	for _, declList := range declLists {
 		g.target.Decls = append(g.target.Decls, g.decls(declList)...)
 	}
+
+	if base.Flag.W > 1 {
+		for _, n := range g.target.Decls {
+			s := fmt.Sprintf("\nafter noder2 %v", n)
+			ir.Dump(s, n)
+		}
+	}
+
 	typecheck.DeclareUniverse()
 
 	for _, p := range noders {
diff --git a/src/cmd/compile/internal/typecheck/subr.go b/src/cmd/compile/internal/typecheck/subr.go
index 569075d684..a640d105d1 100644
--- a/src/cmd/compile/internal/typecheck/subr.go
+++ b/src/cmd/compile/internal/typecheck/subr.go
@@ -127,10 +127,9 @@ func NodNil() ir.Node {
 	return n
 }
 
-// in T.field
-// find missing fields that
-// will give shortest unique addressing.
-// modify the tree with missing type names.
+// AddImplicitDots finds missing fields in obj.field that
+// will give the shortest unique addressing and
+// modifies the tree with missing field names.
 func AddImplicitDots(n *ir.SelectorExpr) *ir.SelectorExpr {
 	n.X = typecheck(n.X, ctxType|ctxExpr)
 	if n.X.Diag() {
diff --git a/src/reflect/all_test.go b/src/reflect/all_test.go
index b01158635f..d5269152eb 100644
--- a/src/reflect/all_test.go
+++ b/src/reflect/all_test.go
@@ -2997,44 +2997,44 @@ func TestUnexportedMethods(t *testing.T) {
 	}
 }
 
-type InnerInt struct {
-	X int
-}
-
-type OuterInt struct {
-	Y int
-	InnerInt
-}
-
-func (i *InnerInt) M() int {
-	return i.X
-}
-
-func TestEmbeddedMethods(t *testing.T) {
-	typ := TypeOf((*OuterInt)(nil))
-	if typ.NumMethod() != 1 || typ.Method(0).Func.Pointer() != ValueOf((*OuterInt).M).Pointer() {
-		t.Errorf("Wrong method table for OuterInt: (m=%p)", (*OuterInt).M)
-		for i := 0; i < typ.NumMethod(); i++ {
-			m := typ.Method(i)
-			t.Errorf("\t%d: %s %#x\n", i, m.Name, m.Func.Pointer())
-		}
-	}
-
-	i := &InnerInt{3}
-	if v := ValueOf(i).Method(0).Call(nil)[0].Int(); v != 3 {
-		t.Errorf("i.M() = %d, want 3", v)
-	}
-
-	o := &OuterInt{1, InnerInt{2}}
-	if v := ValueOf(o).Method(0).Call(nil)[0].Int(); v != 2 {
-		t.Errorf("i.M() = %d, want 2", v)
-	}
-
-	f := (*OuterInt).M
-	if v := f(o); v != 2 {
-		t.Errorf("f(o) = %d, want 2", v)
-	}
-}
+// type InnerInt struct {
+// 	X int
+// }
+
+// type OuterInt struct {
+// 	Y int
+// 	InnerInt
+// }
+
+// func (i *InnerInt) M() int {
+// 	return i.X
+// }
+
+// func TestEmbeddedMethods(t *testing.T) {
+// 	typ := TypeOf((*OuterInt)(nil))
+// 	if typ.NumMethod() != 1 || typ.Method(0).Func.Pointer() != ValueOf((*OuterInt).M).Pointer() {
+// 		t.Errorf("Wrong method table for OuterInt: (m=%p)", (*OuterInt).M)
+// 		for i := 0; i < typ.NumMethod(); i++ {
+// 			m := typ.Method(i)
+// 			t.Errorf("\t%d: %s %#x\n", i, m.Name, m.Func.Pointer())
+// 		}
+// 	}
+
+// 	i := &InnerInt{3}
+// 	if v := ValueOf(i).Method(0).Call(nil)[0].Int(); v != 3 {
+// 		t.Errorf("i.M() = %d, want 3", v)
+// 	}
+
+// 	o := &OuterInt{1, InnerInt{2}}
+// 	if v := ValueOf(o).Method(0).Call(nil)[0].Int(); v != 2 {
+// 		t.Errorf("i.M() = %d, want 2", v)
+// 	}
+
+// 	f := (*OuterInt).M
+// 	if v := f(o); v != 2 {
+// 		t.Errorf("f(o) = %d, want 2", v)
+// 	}
+// }
 
 type FuncDDD func(...interface{}) error
 
-- 
GitLab


From 626406b703a418acd41c4163b5c58d832c09e1e4 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 19 Jan 2021 17:30:09 -0500
Subject: [PATCH 0544/2400] [dev.typeparams] go/types: import api_test.go
 changes from dev.go2go

This CL imports tests for the go/types API from the dev.go2go branch.
Only parse type parameters for packages with a magic prefix, with the
rationale that while generics are in preview, we want existing
(non-generic) tests to exercise the default mode.

Change-Id: I8ae0d8769b997a8a93b708453a1afaecb262244d
Reviewed-on: https://go-review.googlesource.com/c/go/+/284693
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/api_test.go | 255 +++++++++++++++++++++++++++++++++++++--
 1 file changed, 248 insertions(+), 7 deletions(-)

diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go
index 75cebc9826..014cd5282e 100644
--- a/src/go/types/api_test.go
+++ b/src/go/types/api_test.go
@@ -22,7 +22,8 @@ import (
 
 func pkgFor(path, source string, info *Info) (*Package, error) {
 	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, path, source, 0)
+	mode := modeForSource(source)
+	f, err := parser.ParseFile(fset, path, source, mode)
 	if err != nil {
 		return nil, err
 	}
@@ -42,9 +43,21 @@ func mustTypecheck(t *testing.T, path, source string, info *Info) string {
 	return pkg.Name()
 }
 
-func mayTypecheck(t *testing.T, path, source string, info *Info) string {
+// genericPkg is a prefix for packages that should be type checked with
+// generics.
+const genericPkg = "package generic_"
+
+func modeForSource(src string) parser.Mode {
+	if strings.HasPrefix(src, genericPkg) {
+		return parser.ParseTypeParams
+	}
+	return 0
+}
+
+func mayTypecheck(t *testing.T, path, source string, info *Info) (string, error) {
 	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, path, source, 0)
+	mode := modeForSource(source)
+	f, err := parser.ParseFile(fset, path, source, mode)
 	if f == nil { // ignore errors unless f is nil
 		t.Fatalf("%s: unable to parse: %s", path, err)
 	}
@@ -52,8 +65,8 @@ func mayTypecheck(t *testing.T, path, source string, info *Info) string {
 		Error:    func(err error) {},
 		Importer: importer.Default(),
 	}
-	pkg, _ := conf.Check(f.Name.Name, fset, []*ast.File{f}, info)
-	return pkg.Name()
+	pkg, err := conf.Check(f.Name.Name, fset, []*ast.File{f}, info)
+	return pkg.Name(), err
 }
 
 func TestValuesInfo(t *testing.T) {
@@ -270,15 +283,31 @@ func TestTypesInfo(t *testing.T) {
 		// tests for broken code that doesn't parse or type-check
 		{`package x0; func _() { var x struct {f string}; x.f := 0 }`, `x.f`, `string`},
 		{`package x1; func _() { var z string; type x struct {f string}; y := &x{q: z}}`, `z`, `string`},
-		{`package x2; func _() { var a, b string; type x struct {f string}; z := &x{f: a; f: b;}}`, `b`, `string`},
+		{`package x2; func _() { var a, b string; type x struct {f string}; z := &x{f: a, f: b,}}`, `b`, `string`},
 		{`package x3; var x = panic("");`, `panic`, `func(interface{})`},
 		{`package x4; func _() { panic("") }`, `panic`, `func(interface{})`},
 		{`package x5; func _() { var x map[string][...]int; x = map[string][...]int{"": {1,2,3}} }`, `x`, `map[string][-1]int`},
+
+		// parameterized functions
+		{genericPkg + `p0; func f[T any](T); var _ = f(int)`, `f`, `func[T₁ any](T₁)`},
+		{genericPkg + `p1; func f[T any](T); var _ = f(int)`, `f(int)`, `func(int)`},
+		{genericPkg + `p2; func f[T any](T); var _ = f(42)`, `f`, `func[T₁ any](T₁)`},
+		{genericPkg + `p2; func f[T any](T); var _ = f(42)`, `f(42)`, `()`},
+
+		// type parameters
+		{genericPkg + `t0; type t[] int; var _ t`, `t`, `generic_t0.t`}, // t[] is a syntax error that is ignored in this test in favor of t
+		{genericPkg + `t1; type t[P any] int; var _ t[int]`, `t`, `generic_t1.t[P₁ any]`},
+		{genericPkg + `t2; type t[P interface{}] int; var _ t[int]`, `t`, `generic_t2.t[P₁ interface{}]`},
+		{genericPkg + `t3; type t[P, Q interface{}] int; var _ t[int, int]`, `t`, `generic_t3.t[P₁, Q₂ interface{}]`},
+		{genericPkg + `t4; type t[P, Q interface{ m() }] int; var _ t[int, int]`, `t`, `generic_t4.t[P₁, Q₂ interface{m()}]`},
+
+		// instantiated types must be sanitized
+		{genericPkg + `g0; type t[P any] int; var x struct{ f t[int] }; var _ = x.f`, `x.f`, `generic_g0.t[int]`},
 	}
 
 	for _, test := range tests {
 		info := Info{Types: make(map[ast.Expr]TypeAndValue)}
-		name := mayTypecheck(t, "TypesInfo", test.src, &info)
+		name, _ := mayTypecheck(t, "TypesInfo", test.src, &info)
 
 		// look for expression type
 		var typ Type
@@ -300,6 +329,218 @@ func TestTypesInfo(t *testing.T) {
 	}
 }
 
+func TestInferredInfo(t *testing.T) {
+	var tests = []struct {
+		src   string
+		fun   string
+		targs []string
+		sig   string
+	}{
+		{genericPkg + `p0; func f[T any](T); func _() { f(42) }`,
+			`f`,
+			[]string{`int`},
+			`func(int)`,
+		},
+		{genericPkg + `p1; func f[T any](T) T; func _() { f('@') }`,
+			`f`,
+			[]string{`rune`},
+			`func(rune) rune`,
+		},
+		{genericPkg + `p2; func f[T any](...T) T; func _() { f(0i) }`,
+			`f`,
+			[]string{`complex128`},
+			`func(...complex128) complex128`,
+		},
+		{genericPkg + `p3; func f[A, B, C any](A, *B, []C); func _() { f(1.2, new(string), []byte{}) }`,
+			`f`,
+			[]string{`float64`, `string`, `byte`},
+			`func(float64, *string, []byte)`,
+		},
+		{genericPkg + `p4; func f[A, B any](A, *B, ...[]B); func _() { f(1.2, new(byte)) }`,
+			`f`,
+			[]string{`float64`, `byte`},
+			`func(float64, *byte, ...[]byte)`,
+		},
+
+		{genericPkg + `s1; func f[T any, P interface{type *T}](x T); func _(x string) { f(x) }`,
+			`f`,
+			[]string{`string`, `*string`},
+			`func(x string)`,
+		},
+		{genericPkg + `s2; func f[T any, P interface{type *T}](x []T); func _(x []int) { f(x) }`,
+			`f`,
+			[]string{`int`, `*int`},
+			`func(x []int)`,
+		},
+		{genericPkg + `s3; type C[T any] interface{type chan<- T}; func f[T any, P C[T]](x []T); func _(x []int) { f(x) }`,
+			`f`,
+			[]string{`int`, `chan<- int`},
+			`func(x []int)`,
+		},
+		{genericPkg + `s4; type C[T any] interface{type chan<- T}; func f[T any, P C[T], Q C[[]*P]](x []T); func _(x []int) { f(x) }`,
+			`f`,
+			[]string{`int`, `chan<- int`, `chan<- []*chan<- int`},
+			`func(x []int)`,
+		},
+
+		{genericPkg + `t1; func f[T any, P interface{type *T}]() T; func _() { _ = f[string] }`,
+			`f`,
+			[]string{`string`, `*string`},
+			`func() string`,
+		},
+		{genericPkg + `t2; type C[T any] interface{type chan<- T}; func f[T any, P C[T]]() []T; func _() { _ = f[int] }`,
+			`f`,
+			[]string{`int`, `chan<- int`},
+			`func() []int`,
+		},
+		{genericPkg + `t3; type C[T any] interface{type chan<- T}; func f[T any, P C[T], Q C[[]*P]]() []T; func _() { _ = f[int] }`,
+			`f`,
+			[]string{`int`, `chan<- int`, `chan<- []*chan<- int`},
+			`func() []int`,
+		},
+	}
+
+	for _, test := range tests {
+		info := Info{Inferred: make(map[ast.Expr]Inferred)}
+		name, err := mayTypecheck(t, "InferredInfo", test.src, &info)
+		if err != nil {
+			t.Errorf("package %s: %v", name, err)
+			continue
+		}
+
+		// look for inferred type arguments and signature
+		var targs []Type
+		var sig *Signature
+		for call, inf := range info.Inferred {
+			var fun ast.Expr
+			switch x := call.(type) {
+			case *ast.CallExpr:
+				fun = x.Fun
+			case *ast.IndexExpr:
+				fun = x.X
+			default:
+				panic(fmt.Sprintf("unexpected call expression type %T", call))
+			}
+			if ExprString(fun) == test.fun {
+				targs = inf.Targs
+				sig = inf.Sig
+				break
+			}
+		}
+		if targs == nil {
+			t.Errorf("package %s: no inferred information found for %s", name, test.fun)
+			continue
+		}
+
+		// check that type arguments are correct
+		if len(targs) != len(test.targs) {
+			t.Errorf("package %s: got %d type arguments; want %d", name, len(targs), len(test.targs))
+			continue
+		}
+		for i, targ := range targs {
+			if got := targ.String(); got != test.targs[i] {
+				t.Errorf("package %s, %d. type argument: got %s; want %s", name, i, got, test.targs[i])
+				continue
+			}
+		}
+
+		// check that signature is correct
+		if got := sig.String(); got != test.sig {
+			t.Errorf("package %s: got %s; want %s", name, got, test.sig)
+		}
+	}
+}
+
+func TestDefsInfo(t *testing.T) {
+	var tests = []struct {
+		src  string
+		obj  string
+		want string
+	}{
+		{`package p0; const x = 42`, `x`, `const p0.x untyped int`},
+		{`package p1; const x int = 42`, `x`, `const p1.x int`},
+		{`package p2; var x int`, `x`, `var p2.x int`},
+		{`package p3; type x int`, `x`, `type p3.x int`},
+		{`package p4; func f()`, `f`, `func p4.f()`},
+
+		// generic types must be sanitized
+		// (need to use sufficiently nested types to provoke unexpanded types)
+		{genericPkg + `g0; type t[P any] P; const x = t[int](42)`, `x`, `const generic_g0.x generic_g0.t[int]`},
+		{genericPkg + `g1; type t[P any] P; var x = t[int](42)`, `x`, `var generic_g1.x generic_g1.t[int]`},
+		{genericPkg + `g2; type t[P any] P; type x struct{ f t[int] }`, `x`, `type generic_g2.x struct{f generic_g2.t[int]}`},
+		{genericPkg + `g3; type t[P any] P; func f(x struct{ f t[string] }); var g = f`, `g`, `var generic_g3.g func(x struct{f generic_g3.t[string]})`},
+	}
+
+	for _, test := range tests {
+		info := Info{
+			Defs: make(map[*ast.Ident]Object),
+		}
+		name := mustTypecheck(t, "DefsInfo", test.src, &info)
+
+		// find object
+		var def Object
+		for id, obj := range info.Defs {
+			if id.Name == test.obj {
+				def = obj
+				break
+			}
+		}
+		if def == nil {
+			t.Errorf("package %s: %s not found", name, test.obj)
+			continue
+		}
+
+		if got := def.String(); got != test.want {
+			t.Errorf("package %s: got %s; want %s", name, got, test.want)
+		}
+	}
+}
+
+func TestUsesInfo(t *testing.T) {
+	var tests = []struct {
+		src  string
+		obj  string
+		want string
+	}{
+		{`package p0; func _() { _ = x }; const x = 42`, `x`, `const p0.x untyped int`},
+		{`package p1; func _() { _ = x }; const x int = 42`, `x`, `const p1.x int`},
+		{`package p2; func _() { _ = x }; var x int`, `x`, `var p2.x int`},
+		{`package p3; func _() { type _ x }; type x int`, `x`, `type p3.x int`},
+		{`package p4; func _() { _ = f }; func f()`, `f`, `func p4.f()`},
+
+		// generic types must be sanitized
+		// (need to use sufficiently nested types to provoke unexpanded types)
+		{genericPkg + `g0; func _() { _ = x }; type t[P any] P; const x = t[int](42)`, `x`, `const generic_g0.x generic_g0.t[int]`},
+		{genericPkg + `g1; func _() { _ = x }; type t[P any] P; var x = t[int](42)`, `x`, `var generic_g1.x generic_g1.t[int]`},
+		{genericPkg + `g2; func _() { type _ x }; type t[P any] P; type x struct{ f t[int] }`, `x`, `type generic_g2.x struct{f generic_g2.t[int]}`},
+		{genericPkg + `g3; func _() { _ = f }; type t[P any] P; func f(x struct{ f t[string] })`, `f`, `func generic_g3.f(x struct{f generic_g3.t[string]})`},
+	}
+
+	for _, test := range tests {
+		info := Info{
+			Uses: make(map[*ast.Ident]Object),
+		}
+		name := mustTypecheck(t, "UsesInfo", test.src, &info)
+
+		// find object
+		var use Object
+		for id, obj := range info.Uses {
+			if id.Name == test.obj {
+				use = obj
+				break
+			}
+		}
+		if use == nil {
+			t.Errorf("package %s: %s not found", name, test.obj)
+			continue
+		}
+
+		if got := use.String(); got != test.want {
+			t.Errorf("package %s: got %s; want %s", name, got, test.want)
+		}
+	}
+}
+
 func TestImplicitsInfo(t *testing.T) {
 	testenv.MustHaveGoBuild(t)
 
-- 
GitLab


From e4ef30a66751c39bdd24764763531f1a4c325845 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 22 Jan 2021 01:46:42 -0800
Subject: [PATCH 0545/2400] [dev.typeparams] cmd/compile: refactor irgen's
 handling of ":="

The previous code was stylized after noder, which was written when it
was more idiomatic to simple create a gc.Node and then populate and
shuffle around its fields as appropriate.

Now with package ir, it's somewhat nicer to compute all the fields up
front and pass them to the constructor functions, rather than passing
nil and populating the fields afterwards.

Net addition of lines of code, but I think the new code is overall
still somewhat simpler, and will be easier to refactor out into code
for helpers.go.

Change-Id: I8c6f6b65e0a8317129655a0fc493d8af75527b97
Reviewed-on: https://go-review.googlesource.com/c/go/+/285732
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/noder/stmt.go | 73 +++++++++++++++++---------
 1 file changed, 48 insertions(+), 25 deletions(-)

diff --git a/src/cmd/compile/internal/noder/stmt.go b/src/cmd/compile/internal/noder/stmt.go
index 267a34dbc8..1775116f41 100644
--- a/src/cmd/compile/internal/noder/stmt.go
+++ b/src/cmd/compile/internal/noder/stmt.go
@@ -59,19 +59,17 @@ func (g *irgen) stmt0(stmt syntax.Stmt) ir.Node {
 			return ir.NewAssignOpStmt(g.pos(stmt), op, g.expr(stmt.Lhs), g.expr(stmt.Rhs))
 		}
 
+		names, lhs := g.assignList(stmt.Lhs, stmt.Op == syntax.Def)
 		rhs := g.exprList(stmt.Rhs)
-		if list, ok := stmt.Lhs.(*syntax.ListExpr); ok && len(list.ElemList) != 1 || len(rhs) != 1 {
-			n := ir.NewAssignListStmt(g.pos(stmt), ir.OAS2, nil, nil)
-			n.Def = stmt.Op == syntax.Def
-			n.Lhs = g.assignList(stmt.Lhs, n, n.Def)
-			n.Rhs = rhs
+
+		if len(lhs) == 1 && len(rhs) == 1 {
+			n := ir.NewAssignStmt(g.pos(stmt), lhs[0], rhs[0])
+			n.Def = initDefn(n, names)
 			return n
 		}
 
-		n := ir.NewAssignStmt(g.pos(stmt), nil, nil)
-		n.Def = stmt.Op == syntax.Def
-		n.X = g.assignList(stmt.Lhs, n, n.Def)[0]
-		n.Y = rhs[0]
+		n := ir.NewAssignListStmt(g.pos(stmt), ir.OAS2, lhs, rhs)
+		n.Def = initDefn(n, names)
 		return n
 
 	case *syntax.BranchStmt:
@@ -119,9 +117,9 @@ func (g *irgen) op(op syntax.Operator, ops []ir.Op) ir.Op {
 	return ops[op]
 }
 
-func (g *irgen) assignList(expr syntax.Expr, defn ir.InitNode, colas bool) []ir.Node {
-	if !colas {
-		return g.exprList(expr)
+func (g *irgen) assignList(expr syntax.Expr, def bool) ([]*ir.Name, []ir.Node) {
+	if !def {
+		return nil, g.exprList(expr)
 	}
 
 	var exprs []syntax.Expr
@@ -131,6 +129,7 @@ func (g *irgen) assignList(expr syntax.Expr, defn ir.InitNode, colas bool) []ir.
 		exprs = []syntax.Expr{expr}
 	}
 
+	var names []*ir.Name
 	res := make([]ir.Node, len(exprs))
 	for i, expr := range exprs {
 		expr := expr.(*syntax.Name)
@@ -145,11 +144,28 @@ func (g *irgen) assignList(expr syntax.Expr, defn ir.InitNode, colas bool) []ir.
 		}
 
 		name, _ := g.def(expr)
-		name.Defn = defn
-		defn.PtrInit().Append(ir.NewDecl(name.Pos(), ir.ODCL, name))
+		names = append(names, name)
 		res[i] = name
 	}
-	return res
+
+	return names, res
+}
+
+// initDefn marks the given names as declared by defn and populates
+// its Init field with ODCL nodes. It then reports whether any names
+// were so declared, which can be used to initialize defn.Def.
+func initDefn(defn ir.InitNode, names []*ir.Name) bool {
+	if len(names) == 0 {
+		return false
+	}
+
+	init := make([]ir.Node, len(names))
+	for i, name := range names {
+		name.Defn = defn
+		init[i] = ir.NewDecl(name.Pos(), ir.ODCL, name)
+	}
+	defn.SetInit(init)
+	return true
 }
 
 func (g *irgen) blockStmt(stmt *syntax.BlockStmt) []ir.Node {
@@ -171,18 +187,25 @@ func (g *irgen) ifStmt(stmt *syntax.IfStmt) ir.Node {
 	return g.init(init, n)
 }
 
+// unpackTwo returns the first two nodes in list. If list has fewer
+// than 2 nodes, then the missing nodes are replaced with nils.
+func unpackTwo(list []ir.Node) (fst, snd ir.Node) {
+	switch len(list) {
+	case 0:
+		return nil, nil
+	case 1:
+		return list[0], nil
+	default:
+		return list[0], list[1]
+	}
+}
+
 func (g *irgen) forStmt(stmt *syntax.ForStmt) ir.Node {
 	if r, ok := stmt.Init.(*syntax.RangeClause); ok {
-		n := ir.NewRangeStmt(g.pos(r), nil, nil, g.expr(r.X), nil)
-		if r.Lhs != nil {
-			n.Def = r.Def
-			lhs := g.assignList(r.Lhs, n, n.Def)
-			n.Key = lhs[0]
-			if len(lhs) > 1 {
-				n.Value = lhs[1]
-			}
-		}
-		n.Body = g.blockStmt(stmt.Body)
+		names, lhs := g.assignList(r.Lhs, r.Def)
+		key, value := unpackTwo(lhs)
+		n := ir.NewRangeStmt(g.pos(r), key, value, g.expr(r.X), g.blockStmt(stmt.Body))
+		n.Def = initDefn(n, names)
 		return n
 	}
 
-- 
GitLab


From 51e1819a8d2ecb6ed292ca363cbb8edfea4aea65 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Fri, 22 Jan 2021 14:32:06 -0800
Subject: [PATCH 0546/2400] [dev.regabi] cmd/compile: scan body of closure in
 tooHairy to check for disallowed nodes

Several of the bugs in #43818 are because we were not scanning the body
of an possibly inlined closure in tooHairy(). I think this scanning got
lost in the rebase past some of the ir changes. This fixes the issue
related to the SELRECV2 and the bug reported from cuonglm. There is at
least one other bug related to escape analysis which I'll fix in another
change.

Change-Id: I8f38cd12a287881155403bbabbc540ed5fc2248e
Reviewed-on: https://go-review.googlesource.com/c/go/+/285676
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/inline/inl.go | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 83f6740a48..9f9bb87dd5 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -354,10 +354,16 @@ func (v *hairyVisitor) doNode(n ir.Node) bool {
 		return true
 
 	case ir.OCLOSURE:
-		// TODO(danscales) - fix some bugs when budget is lowered below 30
+		// TODO(danscales) - fix some bugs when budget is lowered below 15
 		// Maybe make budget proportional to number of closure variables, e.g.:
 		//v.budget -= int32(len(n.(*ir.ClosureExpr).Func.ClosureVars) * 3)
-		v.budget -= 30
+		v.budget -= 15
+		// Scan body of closure (which DoChildren doesn't automatically
+		// do) to check for disallowed ops in the body and include the
+		// body in the budget.
+		if doList(n.(*ir.ClosureExpr).Func.Body, v.do) {
+			return true
+		}
 
 	case ir.ORANGE,
 		ir.OSELECT,
-- 
GitLab


From 6923019a716fcc7a99a674df448135d92b603c8a Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Fri, 22 Jan 2021 16:24:05 -0800
Subject: [PATCH 0547/2400] [dev.typeparams] cmd/compile/internal/types2:
 factor out sorting of methods

Cleanup and first step towards uniformly changing the sort criteria.

Change-Id: I0a7b6a10b5b646fc83f4897e4915ef4dae24aa66
Reviewed-on: https://go-review.googlesource.com/c/go/+/285993
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/types2/predicates.go |  8 ++-----
 src/cmd/compile/internal/types2/type.go       |  7 +++---
 src/cmd/compile/internal/types2/typexpr.go    | 23 ++++++++++++++++---
 src/cmd/compile/internal/types2/unify.go      |  6 ++---
 4 files changed, 27 insertions(+), 17 deletions(-)

diff --git a/src/cmd/compile/internal/types2/predicates.go b/src/cmd/compile/internal/types2/predicates.go
index 9cce189140..94a9b64761 100644
--- a/src/cmd/compile/internal/types2/predicates.go
+++ b/src/cmd/compile/internal/types2/predicates.go
@@ -6,10 +6,6 @@
 
 package types2
 
-import (
-	"sort"
-)
-
 // isNamed reports whether typ has a name.
 // isNamed may be called with types that are not fully set up.
 func isNamed(typ Type) bool {
@@ -329,8 +325,8 @@ func (check *Checker) identical0(x, y Type, cmpTags bool, p *ifacePair) bool {
 					p = p.prev
 				}
 				if debug {
-					assert(sort.IsSorted(byUniqueMethodName(a)))
-					assert(sort.IsSorted(byUniqueMethodName(b)))
+					assertSortedMethods(a)
+					assertSortedMethods(b)
 				}
 				for i, f := range a {
 					g := b[i]
diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
index 1bfde41159..22901b2ba9 100644
--- a/src/cmd/compile/internal/types2/type.go
+++ b/src/cmd/compile/internal/types2/type.go
@@ -8,7 +8,6 @@ package types2
 import (
 	"cmd/compile/internal/syntax"
 	"fmt"
-	"sort"
 )
 
 // A Type represents a type of Go.
@@ -481,8 +480,8 @@ func NewInterfaceType(methods []*Func, embeddeds []Type) *Interface {
 	}
 
 	// sort for API stability
-	sort.Sort(byUniqueMethodName(methods))
-	sort.Stable(byUniqueTypeName(embeddeds))
+	sortMethods(methods)
+	sortTypes(embeddeds)
 
 	typ.methods = methods
 	typ.embeddeds = embeddeds
@@ -685,7 +684,7 @@ func (t *Interface) Complete() *Interface {
 	}
 
 	if methods != nil {
-		sort.Sort(byUniqueMethodName(methods))
+		sortMethods(methods)
 		t.allMethods = methods
 	}
 	t.allTypes = allTypes
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index f0461d5895..d0bf229be9 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -876,8 +876,8 @@ func (check *Checker) interfaceType(ityp *Interface, iface *syntax.InterfaceType
 	}
 
 	// sort for API stability
-	sort.Sort(byUniqueMethodName(ityp.methods))
-	sort.Stable(byUniqueTypeName(ityp.embeddeds))
+	sortMethods(ityp.methods)
+	sortTypes(ityp.embeddeds)
 
 	check.later(func() { check.completeInterface(iface.Pos(), ityp) })
 }
@@ -985,7 +985,7 @@ func (check *Checker) completeInterface(pos syntax.Pos, ityp *Interface) {
 	}
 
 	if methods != nil {
-		sort.Sort(byUniqueMethodName(methods))
+		sortMethods(methods)
 		ityp.allMethods = methods
 	}
 	ityp.allTypes = allTypes
@@ -1029,6 +1029,10 @@ func intersect(x, y Type) (r Type) {
 	return NewSum(rtypes)
 }
 
+func sortTypes(list []Type) {
+	sort.Stable(byUniqueTypeName(list))
+}
+
 // byUniqueTypeName named type lists can be sorted by their unique type names.
 type byUniqueTypeName []Type
 
@@ -1043,6 +1047,19 @@ func sortName(t Type) string {
 	return ""
 }
 
+func sortMethods(list []*Func) {
+	sort.Sort(byUniqueMethodName(list))
+}
+
+func assertSortedMethods(list []*Func) {
+	if !debug {
+		panic("internal error: assertSortedMethods called outside debug mode")
+	}
+	if !sort.IsSorted(byUniqueMethodName(list)) {
+		panic("internal error: methods not sorted")
+	}
+}
+
 // byUniqueMethodName method lists can be sorted by their unique method names.
 type byUniqueMethodName []*Func
 
diff --git a/src/cmd/compile/internal/types2/unify.go b/src/cmd/compile/internal/types2/unify.go
index 60ccf625b9..ab19c5a38b 100644
--- a/src/cmd/compile/internal/types2/unify.go
+++ b/src/cmd/compile/internal/types2/unify.go
@@ -6,8 +6,6 @@
 
 package types2
 
-import "sort"
-
 // The unifier maintains two separate sets of type parameters x and y
 // which are used to resolve type parameters in the x and y arguments
 // provided to the unify call. For unidirectional unification, only
@@ -386,8 +384,8 @@ func (u *unifier) nify(x, y Type, p *ifacePair) bool {
 					p = p.prev
 				}
 				if debug {
-					assert(sort.IsSorted(byUniqueMethodName(a)))
-					assert(sort.IsSorted(byUniqueMethodName(b)))
+					assertSortedMethods(a)
+					assertSortedMethods(b)
 				}
 				for i, f := range a {
 					g := b[i]
-- 
GitLab


From 2b95c28b18872b2d61ac9e9b32f63c76b619e86b Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 22 Jan 2021 13:29:59 -0800
Subject: [PATCH 0548/2400] [dev.typeparams] cmd/compile: refactor SelectorExpr
 code into helpers

This CL refactors the SelectorExpr-handling code added in CL 285373
into helper functions that can eventually be reused by iimport.

Change-Id: I15b4a96c242f63cb370d7492ed08168550724f47
Reviewed-on: https://go-review.googlesource.com/c/go/+/285953
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/expr.go    | 121 ++++++++--------------
 src/cmd/compile/internal/noder/helpers.go |  90 ++++++++++++++--
 2 files changed, 125 insertions(+), 86 deletions(-)

diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index b38e9cfb4e..5a2cae12e3 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -107,7 +107,7 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 			}
 		}
 
-		return g.selectorExpr(pos, typ, expr)
+		return g.selectorExpr(pos, expr)
 	case *syntax.SliceExpr:
 		return Slice(pos, g.expr(expr.X), g.expr(expr.Index[0]), g.expr(expr.Index[1]), g.expr(expr.Index[2]))
 
@@ -131,88 +131,55 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 // selectorExpr resolves the choice of ODOT, ODOTPTR, OCALLPART (eventually
 // ODOTMETH & ODOTINTER), and OMETHEXPR and deals with embedded fields here rather
 // than in typecheck.go.
-func (g *irgen) selectorExpr(pos src.XPos, typ types2.Type, expr *syntax.SelectorExpr) ir.Node {
-	x := g.expr(expr.X)
+func (g *irgen) selectorExpr(pos src.XPos, expr *syntax.SelectorExpr) ir.Node {
 	selinfo := g.info.Selections[expr]
-	nindex := len(selinfo.Index())
-
-	// Iterate through the selections from types2. If nindex > 1, then we will
-	// create extra nodes to deal with embedded fields.
-	for i := 0; i < nindex; i++ {
-		var f *types.Field
-		var n *ir.SelectorExpr
-
-		op := ir.ODOT
-		index := selinfo.Index()[i]
-		xt := x.Type()
-		origxt := xt
-		if xt.IsPtr() && !xt.Elem().IsInterface() {
-			// Get to the base type, but remember that we skipped the ptr
-			xt = xt.Elem()
-			op = ir.ODOTPTR
-		}
-		types.CalcSize(xt)
-		// Everything up to the last selection is an embedded field
-		// access, and the last selection is determined by selinfo.Kind().
-		if i < nindex-1 || selinfo.Kind() == types2.FieldVal {
-			f = xt.Field(index)
-			sym := f.Sym
-			n = ir.NewSelectorExpr(pos, op, x, sym)
-			if i < nindex-1 {
-				n.SetImplicit(true)
-				typed(f.Type, n)
-			}
-		} else if selinfo.Kind() == types2.MethodExpr {
-			var ms *types.Fields
-			if xt.IsInterface() {
-				// TODO(danscales,mdempsky): interface method sets
-				// are not sorted the same between types and
-				// types2. In particular, this will likely fail if
-				// an interface contains unexported methods from
-				// two different packages (due to cross-package
-				// interface embedding).
-				ms = xt.Fields()
-			} else {
-				mt := types.ReceiverBaseType(xt)
-				ms = mt.Methods()
-			}
-			f = ms.Slice()[index]
-			n = ir.NewSelectorExpr(pos, ir.OMETHEXPR, x, f.Sym)
-		} else { // types.MethodVal
-			if xt.IsInterface() {
-				f = xt.Field(index)
+
+	// Everything up to the last selection is an implicit embedded field access,
+	// and the last selection is determined by selinfo.Kind().
+	index := selinfo.Index()
+	embeds, last := index[:len(index)-1], index[len(index)-1]
+
+	x := g.expr(expr.X)
+	for _, ix := range embeds {
+		x = Implicit(DotField(pos, x, ix))
+	}
+
+	kind := selinfo.Kind()
+	if kind == types2.FieldVal {
+		return DotField(pos, x, last)
+	}
+
+	// TODO(danscales,mdempsky): Interface method sets are not sorted the
+	// same between types and types2. In particular, using "last" here
+	// without conversion will likely fail if an interface contains
+	// unexported methods from two different packages (due to cross-package
+	// interface embedding).
+
+	method := selinfo.Obj().(*types2.Func)
+
+	// Add implicit addr/deref for method values, if needed.
+	if kind == types2.MethodVal && !x.Type().IsInterface() {
+		recvTyp := method.Type().(*types2.Signature).Recv().Type()
+		_, wantPtr := recvTyp.(*types2.Pointer)
+		havePtr := x.Type().IsPtr()
+
+		if havePtr != wantPtr {
+			if havePtr {
+				x = Implicit(Deref(pos, x))
 			} else {
-				f = xt.Methods().Slice()[index]
-				rcvr := f.Type.Recv().Type
-				if rcvr.IsPtr() && types.Identical(rcvr.Elem(), origxt) {
-					addr := typecheck.NodAddrAt(pos, x)
-					addr.SetImplicit(true)
-					typed(xt.PtrTo(), addr)
-					x = addr
-				} else if op == ir.ODOTPTR && !rcvr.IsPtr() {
-					star := ir.NewStarExpr(pos, x)
-					star.SetImplicit(true)
-					typed(xt, star)
-					x = star
-				}
+				x = Implicit(Addr(pos, x))
 			}
-			// We will change OCALLPART to ODOTMETH or ODOTINTER in
-			// Call() if n is actually called.
-			n = ir.NewSelectorExpr(pos, ir.OCALLPART, x, f.Sym)
 		}
-		n.Selection = f
-		x = n
+		if !g.match(x.Type(), recvTyp, false) {
+			base.FatalfAt(pos, "expected %L to have type %v", x, recvTyp)
+		}
 	}
 
-	// We don't set type on x for the last index (i == nindex - 1), since that
-	// is the actual selection (ignoring embedded fields) and may be an
-	// OMETHEXPR or OCALLPART operation. In those cases, the type to set on the
-	// node will be different from the type derived from the field/method
-	// selection. Instead for the last index, we always set the type (at the
-	// end of the function) from g.typ(typ).
-	typed(g.typ(typ), x)
-	types.CalcSize(x.Type())
-	return x
+	n := DotMethod(pos, x, last)
+	if have, want := n.Sym(), g.selector(method); have != want {
+		base.FatalfAt(pos, "bad Sym: have %v, want %v", have, want)
+	}
+	return n
 }
 
 func (g *irgen) exprList(expr syntax.Expr) []ir.Node {
diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
index e43ea630bd..c84e08e71a 100644
--- a/src/cmd/compile/internal/noder/helpers.go
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -5,11 +5,13 @@
 package noder
 
 import (
+	"go/constant"
+
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
-	"go/constant"
 )
 
 // Helpers for constructing typed IR nodes.
@@ -21,6 +23,17 @@ import (
 // results, rather than leaving the caller responsible for using
 // typecheck.Expr or typecheck.Stmt.
 
+type ImplicitNode interface {
+	ir.Node
+	SetImplicit(x bool)
+}
+
+// Implicit returns n after marking it as Implicit.
+func Implicit(n ImplicitNode) ImplicitNode {
+	n.SetImplicit(true)
+	return n
+}
+
 // typed returns n after setting its type to typ.
 func typed(typ *types.Type, n ir.Node) ir.Node {
 	n.SetType(typ)
@@ -40,6 +53,13 @@ func Nil(pos src.XPos, typ *types.Type) ir.Node {
 
 // Expressions
 
+func Addr(pos src.XPos, x ir.Node) *ir.AddrExpr {
+	// TODO(mdempsky): Avoid typecheck.Expr. Probably just need to set OPTRLIT when appropriate.
+	n := typecheck.Expr(typecheck.NodAddrAt(pos, x)).(*ir.AddrExpr)
+	typed(types.NewPtr(x.Type()), n)
+	return n
+}
+
 func Assert(pos src.XPos, x ir.Node, typ *types.Type) ir.Node {
 	return typed(typ, ir.NewTypeAssertExpr(pos, x, nil))
 }
@@ -109,6 +129,58 @@ func Compare(pos src.XPos, typ *types.Type, op ir.Op, x, y ir.Node) ir.Node {
 	return typed(typ, n)
 }
 
+func Deref(pos src.XPos, x ir.Node) *ir.StarExpr {
+	n := ir.NewStarExpr(pos, x)
+	typed(x.Type().Elem(), n)
+	return n
+}
+
+func DotField(pos src.XPos, x ir.Node, index int) *ir.SelectorExpr {
+	op, typ := ir.ODOT, x.Type()
+	if typ.IsPtr() {
+		op, typ = ir.ODOTPTR, typ.Elem()
+	}
+	if !typ.IsStruct() {
+		base.FatalfAt(pos, "DotField of non-struct: %L", x)
+	}
+
+	// TODO(mdempsky): This is the backend's responsibility.
+	types.CalcSize(typ)
+
+	field := typ.Field(index)
+	return dot(pos, field.Type, op, x, field)
+}
+
+func DotMethod(pos src.XPos, x ir.Node, index int) *ir.SelectorExpr {
+	method := method(x.Type(), index)
+
+	// Method expression.
+	// TODO(mdempsky): Handle with a separate helper?
+	if x.Op() == ir.OTYPE {
+		typ := typecheck.NewMethodType(method.Type, x.Type())
+		return dot(pos, typ, ir.OMETHEXPR, x, method)
+	}
+
+	// Method value.
+	typ := typecheck.NewMethodType(method.Type, nil)
+	return dot(pos, typ, ir.OCALLPART, x, method)
+}
+
+func dot(pos src.XPos, typ *types.Type, op ir.Op, x ir.Node, selection *types.Field) *ir.SelectorExpr {
+	n := ir.NewSelectorExpr(pos, op, x, selection.Sym)
+	n.Selection = selection
+	typed(typ, n)
+	return n
+}
+
+// TODO(mdempsky): Move to package types.
+func method(typ *types.Type, index int) *types.Field {
+	if typ.IsInterface() {
+		return typ.Field(index)
+	}
+	return types.ReceiverBaseType(typ).Methods().Index(index)
+}
+
 func Index(pos src.XPos, x, index ir.Node) ir.Node {
 	// TODO(mdempsky): Avoid typecheck.Expr.
 	return typecheck.Expr(ir.NewIndexExpr(pos, x, index))
@@ -124,18 +196,18 @@ func Slice(pos src.XPos, x, low, high, max ir.Node) ir.Node {
 }
 
 func Unary(pos src.XPos, op ir.Op, x ir.Node) ir.Node {
-	typ := x.Type()
 	switch op {
 	case ir.OADDR:
-		// TODO(mdempsky): Avoid typecheck.Expr. Probably just need to set OPTRLIT as needed.
-		return typed(types.NewPtr(typ), typecheck.Expr(typecheck.NodAddrAt(pos, x)))
+		return Addr(pos, x)
 	case ir.ODEREF:
-		return typed(typ.Elem(), ir.NewStarExpr(pos, x))
-	case ir.ORECV:
-		return typed(typ.Elem(), ir.NewUnaryExpr(pos, op, x))
-	default:
-		return typed(typ, ir.NewUnaryExpr(pos, op, x))
+		return Deref(pos, x)
+	}
+
+	typ := x.Type()
+	if op == ir.ORECV {
+		typ = typ.Elem()
 	}
+	return typed(typ, ir.NewUnaryExpr(pos, op, x))
 }
 
 // Statements
-- 
GitLab


From 5347241b5e64eb9a7b0ef97b12d899f32a05c2b8 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Fri, 22 Jan 2021 16:49:21 -0800
Subject: [PATCH 0549/2400] [dev.typeparams] cmd/compile/internal/types2: use
 same sort criteria for methods as compiler

Note: This invalidates the implementation of MethodSet further (it
also has not been updated to accomodate for type parameters). But
types2 doesn't make use of it. We should remove it.

Change-Id: Ia2601bdd59b3f3ee0b72bc2512153c42bf5053b5
Reviewed-on: https://go-review.googlesource.com/c/go/+/285994
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/types2/object.go  | 30 ++++++++++++++++++++++
 src/cmd/compile/internal/types2/typexpr.go |  2 +-
 2 files changed, 31 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/object.go b/src/cmd/compile/internal/types2/object.go
index 42fae762d3..b42662222f 100644
--- a/src/cmd/compile/internal/types2/object.go
+++ b/src/cmd/compile/internal/types2/object.go
@@ -330,6 +330,36 @@ func (obj *Func) FullName() string {
 // Scope returns the scope of the function's body block.
 func (obj *Func) Scope() *Scope { return obj.typ.(*Signature).scope }
 
+// Less reports whether function a is ordered before function b.
+//
+// Functions are ordered exported before non-exported, then by name,
+// and finally (for non-exported functions) by package path.
+//
+// TODO(gri) The compiler also sorts by package height before package
+//           path for non-exported names.
+func (a *Func) less(b *Func) bool {
+	if a == b {
+		return false
+	}
+
+	// Exported functions before non-exported.
+	ea := isExported(a.name)
+	eb := isExported(b.name)
+	if ea != eb {
+		return ea
+	}
+
+	// Order by name and then (for non-exported names) by package.
+	if a.name != b.name {
+		return a.name < b.name
+	}
+	if !ea {
+		return a.pkg.path < b.pkg.path
+	}
+
+	return false
+}
+
 func (*Func) isDependency() {} // a function may be a dependency of an initialization expression
 
 // A Label represents a declared label.
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index d0bf229be9..9ab84b594b 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -1064,7 +1064,7 @@ func assertSortedMethods(list []*Func) {
 type byUniqueMethodName []*Func
 
 func (a byUniqueMethodName) Len() int           { return len(a) }
-func (a byUniqueMethodName) Less(i, j int) bool { return a[i].Id() < a[j].Id() }
+func (a byUniqueMethodName) Less(i, j int) bool { return a[i].less(a[j]) }
 func (a byUniqueMethodName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
 
 func (check *Checker) tag(t *syntax.BasicLit) string {
-- 
GitLab


From a49e9410276975d187a5cfda1a396194c45d4464 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Fri, 22 Jan 2021 16:59:45 -0800
Subject: [PATCH 0550/2400] [dev.typeparams] cmd/compile/internal/types2:
 remove MethodSet code - not used by types2

We can always re-introduce it if we decide to make use of it.

Change-Id: Ia939fdae978568edc58e21d1af732c6137744aab
Reviewed-on: https://go-review.googlesource.com/c/go/+/285678
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 .../internal/importer/gcimporter_test.go      |   5 +-
 src/cmd/compile/internal/types2/call.go       |  45 ---
 .../compile/internal/types2/example_test.go   |  55 ----
 src/cmd/compile/internal/types2/lookup.go     |  19 ++
 src/cmd/compile/internal/types2/methodset.go  | 262 ------------------
 5 files changed, 21 insertions(+), 365 deletions(-)
 delete mode 100644 src/cmd/compile/internal/types2/methodset.go

diff --git a/src/cmd/compile/internal/importer/gcimporter_test.go b/src/cmd/compile/internal/importer/gcimporter_test.go
index a275524484..7fb8fed59c 100644
--- a/src/cmd/compile/internal/importer/gcimporter_test.go
+++ b/src/cmd/compile/internal/importer/gcimporter_test.go
@@ -384,9 +384,8 @@ func TestCorrectMethodPackage(t *testing.T) {
 	}
 
 	mutex := imports["sync"].Scope().Lookup("Mutex").(*types2.TypeName).Type()
-	mset := types2.NewMethodSet(types2.NewPointer(mutex)) // methods of *sync.Mutex
-	sel := mset.Lookup(nil, "Lock")
-	lock := sel.Obj().(*types2.Func)
+	obj, _, _ := types2.LookupFieldOrMethod(types2.NewPointer(mutex), false, nil, "Lock")
+	lock := obj.(*types2.Func)
 	if got, want := lock.Pkg().Path(), "sync"; got != want {
 		t.Errorf("got package path %q; want %q", got, want)
 	}
diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index 5a7ae221e6..72a33b50b1 100644
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -685,51 +685,6 @@ func (check *Checker) selector(x *operand, e *syntax.SelectorExpr) {
 			// addressability, should we report the type &(x.typ) instead?
 			check.recordSelection(e, MethodVal, x.typ, obj, index, indirect)
 
-			// TODO(gri) The verification pass below is disabled for now because
-			//           method sets don't match method lookup in some cases.
-			//           For instance, if we made a copy above when creating a
-			//           custom method for a parameterized received type, the
-			//           method set method doesn't match (no copy there). There
-			///          may be other situations.
-			disabled := true
-			if !disabled && debug {
-				// Verify that LookupFieldOrMethod and MethodSet.Lookup agree.
-				// TODO(gri) This only works because we call LookupFieldOrMethod
-				// _before_ calling NewMethodSet: LookupFieldOrMethod completes
-				// any incomplete interfaces so they are available to NewMethodSet
-				// (which assumes that interfaces have been completed already).
-				typ := x.typ
-				if x.mode == variable {
-					// If typ is not an (unnamed) pointer or an interface,
-					// use *typ instead, because the method set of *typ
-					// includes the methods of typ.
-					// Variables are addressable, so we can always take their
-					// address.
-					if _, ok := typ.(*Pointer); !ok && !IsInterface(typ) {
-						typ = &Pointer{base: typ}
-					}
-				}
-				// If we created a synthetic pointer type above, we will throw
-				// away the method set computed here after use.
-				// TODO(gri) Method set computation should probably always compute
-				// both, the value and the pointer receiver method set and represent
-				// them in a single structure.
-				// TODO(gri) Consider also using a method set cache for the lifetime
-				// of checker once we rely on MethodSet lookup instead of individual
-				// lookup.
-				mset := NewMethodSet(typ)
-				if m := mset.Lookup(check.pkg, sel); m == nil || m.obj != obj {
-					check.dump("%v: (%s).%v -> %s", posFor(e), typ, obj.name, m)
-					check.dump("%s\n", mset)
-					// Caution: MethodSets are supposed to be used externally
-					// only (after all interface types were completed). It's
-					// now possible that we get here incorrectly. Not urgent
-					// to fix since we only run this code in debug mode.
-					// TODO(gri) fix this eventually.
-					panic("method sets and lookup don't agree")
-				}
-			}
-
 			x.mode = value
 
 			// remove receiver
diff --git a/src/cmd/compile/internal/types2/example_test.go b/src/cmd/compile/internal/types2/example_test.go
index dcdeaca0c0..ffd54fe459 100644
--- a/src/cmd/compile/internal/types2/example_test.go
+++ b/src/cmd/compile/internal/types2/example_test.go
@@ -107,61 +107,6 @@ func Unused() { {}; {{ var x int; _ = x }} } // make sure empty block scopes get
 	// }
 }
 
-// ExampleMethodSet prints the method sets of various types.
-func ExampleMethodSet() {
-	// Parse a single source file.
-	const input = `
-package temperature
-import "fmt"
-type Celsius float64
-func (c Celsius) String() string  { return fmt.Sprintf("%g°C", c) }
-func (c *Celsius) SetF(f float64) { *c = Celsius(f - 32 / 9 * 5) }
-
-type S struct { I; m int }
-type I interface { m() byte }
-`
-	f, err := parseSrc("celsius.go", input)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	// Type-check a package consisting of this file.
-	// Type information for the imported packages
-	// comes from $GOROOT/pkg/$GOOS_$GOOARCH/fmt.a.
-	conf := types2.Config{Importer: defaultImporter()}
-	pkg, err := conf.Check("temperature", []*syntax.File{f}, nil)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	// Print the method sets of Celsius and *Celsius.
-	celsius := pkg.Scope().Lookup("Celsius").Type()
-	for _, t := range []types2.Type{celsius, types2.NewPointer(celsius)} {
-		fmt.Printf("Method set of %s:\n", t)
-		mset := types2.NewMethodSet(t)
-		for i := 0; i < mset.Len(); i++ {
-			fmt.Println(mset.At(i))
-		}
-		fmt.Println()
-	}
-
-	// Print the method set of S.
-	styp := pkg.Scope().Lookup("S").Type()
-	fmt.Printf("Method set of %s:\n", styp)
-	fmt.Println(types2.NewMethodSet(styp))
-
-	// Output:
-	// Method set of temperature.Celsius:
-	// method (temperature.Celsius) String() string
-	//
-	// Method set of *temperature.Celsius:
-	// method (*temperature.Celsius) SetF(f float64)
-	// method (*temperature.Celsius) String() string
-	//
-	// Method set of temperature.S:
-	// MethodSet {}
-}
-
 // ExampleInfo prints various facts recorded by the type checker in a
 // types2.Info struct: definitions of and references to each named object,
 // and the type, value, and mode of every expression in the package.
diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go
index e1e7b5814d..5dfb8bfee7 100644
--- a/src/cmd/compile/internal/types2/lookup.go
+++ b/src/cmd/compile/internal/types2/lookup.go
@@ -491,3 +491,22 @@ func lookupMethod(methods []*Func, pkg *Package, name string) (int, *Func) {
 	}
 	return -1, nil
 }
+
+// ptrRecv reports whether the receiver is of the form *T.
+func ptrRecv(f *Func) bool {
+	// If a method's receiver type is set, use that as the source of truth for the receiver.
+	// Caution: Checker.funcDecl (decl.go) marks a function by setting its type to an empty
+	// signature. We may reach here before the signature is fully set up: we must explicitly
+	// check if the receiver is set (we cannot just look for non-nil f.typ).
+	if sig, _ := f.typ.(*Signature); sig != nil && sig.recv != nil {
+		_, isPtr := deref(sig.recv.typ)
+		return isPtr
+	}
+
+	// If a method's type is not set it may be a method/function that is:
+	// 1) client-supplied (via NewFunc with no signature), or
+	// 2) internally created but not yet type-checked.
+	// For case 1) we can't do anything; the client must know what they are doing.
+	// For case 2) we can use the information gathered by the resolver.
+	return f.hasPtrRecv
+}
diff --git a/src/cmd/compile/internal/types2/methodset.go b/src/cmd/compile/internal/types2/methodset.go
deleted file mode 100644
index eb8f1221cc..0000000000
--- a/src/cmd/compile/internal/types2/methodset.go
+++ /dev/null
@@ -1,262 +0,0 @@
-// UNREVIEWED
-// Copyright 2013 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.
-
-// This file implements method sets.
-
-package types2
-
-import (
-	"bytes"
-	"fmt"
-	"sort"
-)
-
-// A MethodSet is an ordered set of concrete or abstract (interface) methods;
-// a method is a MethodVal selection, and they are ordered by ascending m.Obj().Id().
-// The zero value for a MethodSet is a ready-to-use empty method set.
-type MethodSet struct {
-	list []*Selection
-}
-
-func (s *MethodSet) String() string {
-	if s.Len() == 0 {
-		return "MethodSet {}"
-	}
-
-	// Would like to use strings.Builder but it's not available in Go 1.4.
-	var buf bytes.Buffer
-	fmt.Fprintln(&buf, "MethodSet {")
-	for _, f := range s.list {
-		fmt.Fprintf(&buf, "\t%s\n", f)
-	}
-	fmt.Fprintln(&buf, "}")
-	return buf.String()
-}
-
-// Len returns the number of methods in s.
-func (s *MethodSet) Len() int { return len(s.list) }
-
-// At returns the i'th method in s for 0 <= i < s.Len().
-func (s *MethodSet) At(i int) *Selection { return s.list[i] }
-
-// Lookup returns the method with matching package and name, or nil if not found.
-func (s *MethodSet) Lookup(pkg *Package, name string) *Selection {
-	if s.Len() == 0 {
-		return nil
-	}
-
-	key := Id(pkg, name)
-	i := sort.Search(len(s.list), func(i int) bool {
-		m := s.list[i]
-		return m.obj.Id() >= key
-	})
-	if i < len(s.list) {
-		m := s.list[i]
-		if m.obj.Id() == key {
-			return m
-		}
-	}
-	return nil
-}
-
-// Shared empty method set.
-var emptyMethodSet MethodSet
-
-// Note: NewMethodSet is intended for external use only as it
-//       requires interfaces to be complete. If may be used
-//       internally if LookupFieldOrMethod completed the same
-//       interfaces beforehand.
-
-// NewMethodSet returns the method set for the given type T.
-// It always returns a non-nil method set, even if it is empty.
-func NewMethodSet(T Type) *MethodSet {
-	// WARNING: The code in this function is extremely subtle - do not modify casually!
-	//          This function and lookupFieldOrMethod should be kept in sync.
-
-	// method set up to the current depth, allocated lazily
-	var base methodSet
-
-	typ, isPtr := deref(T)
-
-	// *typ where typ is an interface has no methods.
-	if isPtr && IsInterface(typ) {
-		return &emptyMethodSet
-	}
-
-	// Start with typ as single entry at shallowest depth.
-	current := []embeddedType{{typ, nil, isPtr, false}}
-
-	// Named types that we have seen already, allocated lazily.
-	// Used to avoid endless searches in case of recursive types.
-	// Since only Named types can be used for recursive types, we
-	// only need to track those.
-	// (If we ever allow type aliases to construct recursive types,
-	// we must use type identity rather than pointer equality for
-	// the map key comparison, as we do in consolidateMultiples.)
-	var seen map[*Named]bool
-
-	// collect methods at current depth
-	for len(current) > 0 {
-		var next []embeddedType // embedded types found at current depth
-
-		// field and method sets at current depth, indexed by names (Id's), and allocated lazily
-		var fset map[string]bool // we only care about the field names
-		var mset methodSet
-
-		for _, e := range current {
-			typ := e.typ
-
-			// If we have a named type, we may have associated methods.
-			// Look for those first.
-			if named := typ.Named(); named != nil {
-				if seen[named] {
-					// We have seen this type before, at a more shallow depth
-					// (note that multiples of this type at the current depth
-					// were consolidated before). The type at that depth shadows
-					// this same type at the current depth, so we can ignore
-					// this one.
-					continue
-				}
-				if seen == nil {
-					seen = make(map[*Named]bool)
-				}
-				seen[named] = true
-
-				mset = mset.add(named.methods, e.index, e.indirect, e.multiples)
-
-				// continue with underlying type
-				typ = named.underlying
-			}
-
-			switch t := typ.(type) {
-			case *Struct:
-				for i, f := range t.fields {
-					if fset == nil {
-						fset = make(map[string]bool)
-					}
-					fset[f.Id()] = true
-
-					// Embedded fields are always of the form T or *T where
-					// T is a type name. If typ appeared multiple times at
-					// this depth, f.Type appears multiple times at the next
-					// depth.
-					if f.embedded {
-						typ, isPtr := deref(f.typ)
-						// TODO(gri) optimization: ignore types that can't
-						// have fields or methods (only Named, Struct, and
-						// Interface types need to be considered).
-						next = append(next, embeddedType{typ, concat(e.index, i), e.indirect || isPtr, e.multiples})
-					}
-				}
-
-			case *Interface:
-				mset = mset.add(t.allMethods, e.index, true, e.multiples)
-			}
-		}
-
-		// Add methods and collisions at this depth to base if no entries with matching
-		// names exist already.
-		for k, m := range mset {
-			if _, found := base[k]; !found {
-				// Fields collide with methods of the same name at this depth.
-				if fset[k] {
-					m = nil // collision
-				}
-				if base == nil {
-					base = make(methodSet)
-				}
-				base[k] = m
-			}
-		}
-
-		// Add all (remaining) fields at this depth as collisions (since they will
-		// hide any method further down) if no entries with matching names exist already.
-		for k := range fset {
-			if _, found := base[k]; !found {
-				if base == nil {
-					base = make(methodSet)
-				}
-				base[k] = nil // collision
-			}
-		}
-
-		// It's ok to call consolidateMultiples with a nil *Checker because
-		// MethodSets are not used internally (outside debug mode). When used
-		// externally, interfaces are expected to be completed and then we do
-		// not need a *Checker to complete them when (indirectly) calling
-		// Checker.identical via consolidateMultiples.
-		current = (*Checker)(nil).consolidateMultiples(next)
-	}
-
-	if len(base) == 0 {
-		return &emptyMethodSet
-	}
-
-	// collect methods
-	var list []*Selection
-	for _, m := range base {
-		if m != nil {
-			m.recv = T
-			list = append(list, m)
-		}
-	}
-	// sort by unique name
-	sort.Slice(list, func(i, j int) bool {
-		return list[i].obj.Id() < list[j].obj.Id()
-	})
-	return &MethodSet{list}
-}
-
-// A methodSet is a set of methods and name collisions.
-// A collision indicates that multiple methods with the
-// same unique id, or a field with that id appeared.
-type methodSet map[string]*Selection // a nil entry indicates a name collision
-
-// Add adds all functions in list to the method set s.
-// If multiples is set, every function in list appears multiple times
-// and is treated as a collision.
-func (s methodSet) add(list []*Func, index []int, indirect bool, multiples bool) methodSet {
-	if len(list) == 0 {
-		return s
-	}
-	if s == nil {
-		s = make(methodSet)
-	}
-	for i, f := range list {
-		key := f.Id()
-		// if f is not in the set, add it
-		if !multiples {
-			// TODO(gri) A found method may not be added because it's not in the method set
-			// (!indirect && ptrRecv(f)). A 2nd method on the same level may be in the method
-			// set and may not collide with the first one, thus leading to a false positive.
-			// Is that possible? Investigate.
-			if _, found := s[key]; !found && (indirect || !ptrRecv(f)) {
-				s[key] = &Selection{MethodVal, nil, f, concat(index, i), indirect}
-				continue
-			}
-		}
-		s[key] = nil // collision
-	}
-	return s
-}
-
-// ptrRecv reports whether the receiver is of the form *T.
-func ptrRecv(f *Func) bool {
-	// If a method's receiver type is set, use that as the source of truth for the receiver.
-	// Caution: Checker.funcDecl (decl.go) marks a function by setting its type to an empty
-	// signature. We may reach here before the signature is fully set up: we must explicitly
-	// check if the receiver is set (we cannot just look for non-nil f.typ).
-	if sig, _ := f.typ.(*Signature); sig != nil && sig.recv != nil {
-		_, isPtr := deref(sig.recv.typ)
-		return isPtr
-	}
-
-	// If a method's type is not set it may be a method/function that is:
-	// 1) client-supplied (via NewFunc with no signature), or
-	// 2) internally created but not yet type-checked.
-	// For case 1) we can't do anything; the client must know what they are doing.
-	// For case 2) we can use the information gathered by the resolver.
-	return f.hasPtrRecv
-}
-- 
GitLab


From 48badc5fa863ce5e7e8ac9f268f13955483070e3 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Fri, 22 Jan 2021 16:07:00 -0800
Subject: [PATCH 0551/2400] [dev.regabi] cmd/compile: fix escape analysis
 problem with closures

In reflect.methodWrapper, we call escape analysis without including the
full batch of dependent functions, including the closure functions.
Because of this, we haven't created locations for the params/local
variables of a closure when we are processing a function that
inlines that closure. (Whereas in the normal compilation of the
function, we do call with the full batch.) To deal with this, I am
creating locations for the params/local variables of a closure when
needed.

Without this fix, the new test closure6.go would fail.

Updates #43818

Change-Id: I5f91cfb6f35efe2937ef88cbcc468e403e0da9ad
Reviewed-on: https://go-review.googlesource.com/c/go/+/285677
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/escape/escape.go | 10 ++++++++++
 test/closure6.go                          | 18 ++++++++++++++++++
 2 files changed, 28 insertions(+)
 create mode 100644 test/closure6.go

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index 883e68a730..58cad73c76 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -781,6 +781,16 @@ func (e *escape) exprSkipInit(k hole, n ir.Node) {
 				}
 			}
 
+			for _, n := range fn.Dcl {
+				// Add locations for local variables of the
+				// closure, if needed, in case we're not including
+				// the closure func in the batch for escape
+				// analysis (happens for escape analysis called
+				// from reflectdata.methodWrapper)
+				if n.Op() == ir.ONAME && n.Opt == nil {
+					e.with(fn).newLoc(n, false)
+				}
+			}
 			e.walkFunc(fn)
 		}
 
diff --git a/test/closure6.go b/test/closure6.go
new file mode 100644
index 0000000000..b5592ad3d3
--- /dev/null
+++ b/test/closure6.go
@@ -0,0 +1,18 @@
+// compile
+
+// Copyright 2020 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 p
+
+type Float64Slice []float64
+
+func (a Float64Slice) Search1(x float64) int {
+	f := func(q int) bool { return a[q] >= x }
+	i := 0
+	if !f(3) {
+		i = 5
+	}
+	return i
+}
-- 
GitLab


From 7947df436dbc45ae616ec1f1821266e0867aad80 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Fri, 22 Jan 2021 17:49:57 -0800
Subject: [PATCH 0552/2400] [dev.typeparams] test: set -G=3 and enable more
 errorcheck tests in run.go

Change-Id: I9591f7aeab0448aca661560bf3064e057b48293e
Reviewed-on: https://go-review.googlesource.com/c/go/+/286012
Trust: Robert Griesemer <gri@golang.org>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 test/run.go | 12 +-----------
 1 file changed, 1 insertion(+), 11 deletions(-)

diff --git a/test/run.go b/test/run.go
index a460c4d8b6..edf9d654ed 100644
--- a/test/run.go
+++ b/test/run.go
@@ -786,13 +786,6 @@ func (t *test) run() {
 				"append",
 				"slice",
 				"typeassert",
-				"ssa/check_bce/debug",
-				"ssa/intrinsics/debug",
-				"ssa/opt/debug",
-				"ssa/prove/debug",
-				"ssa/likelyadjust/debug",
-				"ssa/insert_resched_checks/off",
-				"ssa/phiopt/debug",
 				"defer",
 				"nil",
 			} {
@@ -806,7 +799,7 @@ func (t *test) run() {
 		}
 
 		// Run errorcheck again with -G option (new typechecker).
-		cmdline = []string{goTool(), "tool", "compile", "-G", "-C", "-e", "-o", "a.o"}
+		cmdline = []string{goTool(), "tool", "compile", "-G=3", "-C", "-e", "-o", "a.o"}
 		// No need to add -dynlink even if linkshared if we're just checking for errors...
 		cmdline = append(cmdline, flags...)
 		cmdline = append(cmdline, long)
@@ -1938,8 +1931,6 @@ var excluded = map[string]bool{
 	"const2.go":       true, // types2 not run after syntax errors
 	"ddd1.go":         true, // issue #42987
 	"directive.go":    true, // misplaced compiler directive checks
-	"embedfunc.go":    true, // error reported by irgen (only runs with -G=3)
-	"embedvers.go":    true, // error reported by backend (only runs with -G=3)
 	"float_lit3.go":   true, // types2 reports extra errors
 	"import1.go":      true, // types2 reports extra errors
 	"import5.go":      true, // issue #42988
@@ -1967,7 +1958,6 @@ var excluded = map[string]bool{
 	"fixedbugs/issue11614.go":  true, // types2 reports an extra error
 	"fixedbugs/issue13415.go":  true, // declared but not used conflict
 	"fixedbugs/issue14520.go":  true, // missing import path error by types2
-	"fixedbugs/issue14540.go":  true, // error reported by noder (not running for types2 errorcheck test)
 	"fixedbugs/issue16428.go":  true, // types2 reports two instead of one error
 	"fixedbugs/issue17038.go":  true, // types2 doesn't report a follow-on error (pref: types2)
 	"fixedbugs/issue17645.go":  true, // multiple errors on same line
-- 
GitLab


From d05d6fab32cb3d47f8682d19ca11085430f39164 Mon Sep 17 00:00:00 2001
From: Baokun Lee <bk@golangcn.org>
Date: Sat, 23 Jan 2021 17:05:01 +0800
Subject: [PATCH 0553/2400] [dev.regabi] cmd/compile: replace ir.Name map with
 ir.NameSet for SSA 2

Same as CL 284897, the last one.

Passes toolstash -cmp.

Updates #43819

Change-Id: I0bd8958b3717fb58a5a6576f1819a85f33b76e2d
Reviewed-on: https://go-review.googlesource.com/c/go/+/285913
Run-TryBot: Baokun Lee <bk@golangcn.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Trust: Baokun Lee <bk@golangcn.org>
---
 src/cmd/compile/internal/ssa/deadstore.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/deadstore.go b/src/cmd/compile/internal/ssa/deadstore.go
index 0cf9931dbc..31d3f62d4e 100644
--- a/src/cmd/compile/internal/ssa/deadstore.go
+++ b/src/cmd/compile/internal/ssa/deadstore.go
@@ -299,7 +299,7 @@ func elimUnreadAutos(f *Func) {
 	// Loop over all ops that affect autos taking note of which
 	// autos we need and also stores that we might be able to
 	// eliminate.
-	seen := make(map[*ir.Name]bool)
+	var seen ir.NameSet
 	var stores []*Value
 	for _, b := range f.Blocks {
 		for _, v := range b.Values {
@@ -317,7 +317,7 @@ func elimUnreadAutos(f *Func) {
 				// If we haven't seen the auto yet
 				// then this might be a store we can
 				// eliminate.
-				if !seen[n] {
+				if !seen.Has(n) {
 					stores = append(stores, v)
 				}
 			default:
@@ -327,7 +327,7 @@ func elimUnreadAutos(f *Func) {
 				// because dead loads haven't been
 				// eliminated yet.
 				if v.Uses > 0 {
-					seen[n] = true
+					seen.Add(n)
 				}
 			}
 		}
@@ -336,7 +336,7 @@ func elimUnreadAutos(f *Func) {
 	// Eliminate stores to unread autos.
 	for _, store := range stores {
 		n, _ := store.Aux.(*ir.Name)
-		if seen[n] {
+		if seen.Has(n) {
 			continue
 		}
 
-- 
GitLab


From 9456804e860ac6e5a60d4e479182d53328069d13 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Sat, 23 Jan 2021 11:43:46 -0800
Subject: [PATCH 0554/2400] [dev.typeparams] test: fix excluded files lookup so
 it works on Windows

Updates #43866.

Change-Id: I15360de11a48c6f23f25c5ff3a15c117a34127ff
Reviewed-on: https://go-review.googlesource.com/c/go/+/286034
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 test/run.go | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/test/run.go b/test/run.go
index edf9d654ed..0be106c54a 100644
--- a/test/run.go
+++ b/test/run.go
@@ -766,9 +766,10 @@ func (t *test) run() {
 		// eliminate the flag list.
 
 		// Excluded files.
-		if excluded[t.goFileName()] {
+		filename := strings.Replace(t.goFileName(), "\\", "/", -1) // goFileName() uses \ on Windows
+		if excluded[filename] {
 			if *verbose {
-				fmt.Printf("excl\t%s\n", t.goFileName())
+				fmt.Printf("excl\t%s\n", filename)
 			}
 			return // cannot handle file yet
 		}
@@ -791,7 +792,7 @@ func (t *test) run() {
 			} {
 				if strings.Contains(flag, pattern) {
 					if *verbose {
-						fmt.Printf("excl\t%s\t%s\n", t.goFileName(), flags)
+						fmt.Printf("excl\t%s\t%s\n", filename, flags)
 					}
 					return // cannot handle flag
 				}
-- 
GitLab


From 063c72f06d8673f3a2a03fd549c61935ca3e5cc5 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 24 Jan 2021 10:52:00 -0800
Subject: [PATCH 0555/2400] [dev.regabi] cmd/compile: backport changes from
 dev.typeparams (9456804)

This CL backports a bunch of changes that landed on dev.typeparams,
but are not dependent on types2 or generics. By backporting, we reduce
the divergence between development branches, hopefully improving test
coverage and reducing risk of merge conflicts.

Updates #43866.

Change-Id: I382510855c9b5fac52b17066e44a00bd07fe86f5
Reviewed-on: https://go-review.googlesource.com/c/go/+/286172
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/dwarfgen/marker.go   |  94 ++++++
 src/cmd/compile/internal/noder/import.go      | 239 ++++++++--------
 src/cmd/compile/internal/noder/noder.go       | 268 ++++++------------
 src/cmd/compile/internal/noder/posmap.go      |  83 ++++++
 .../compile/internal/reflectdata/reflect.go   |   2 +-
 src/cmd/compile/internal/typecheck/dcl.go     |   5 +-
 src/cmd/compile/internal/typecheck/func.go    |   4 +-
 src/cmd/compile/internal/typecheck/subr.go    |   7 +-
 .../compile/internal/typecheck/typecheck.go   |   8 +-
 src/cmd/compile/internal/types/pkg.go         |   3 +-
 src/cmd/compile/internal/types/scope.go       |   2 +-
 src/cmd/compile/internal/walk/walk.go         |   5 +
 src/cmd/internal/obj/link.go                  |   6 +-
 test/fixedbugs/issue11362.go                  |   2 +-
 14 files changed, 398 insertions(+), 330 deletions(-)
 create mode 100644 src/cmd/compile/internal/dwarfgen/marker.go
 create mode 100644 src/cmd/compile/internal/noder/posmap.go

diff --git a/src/cmd/compile/internal/dwarfgen/marker.go b/src/cmd/compile/internal/dwarfgen/marker.go
new file mode 100644
index 0000000000..ec6ce45a90
--- /dev/null
+++ b/src/cmd/compile/internal/dwarfgen/marker.go
@@ -0,0 +1,94 @@
+// Copyright 2021 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 dwarfgen
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/internal/src"
+)
+
+// A ScopeMarker tracks scope nesting and boundaries for later use
+// during DWARF generation.
+type ScopeMarker struct {
+	parents []ir.ScopeID
+	marks   []ir.Mark
+}
+
+// checkPos validates the given position and returns the current scope.
+func (m *ScopeMarker) checkPos(pos src.XPos) ir.ScopeID {
+	if !pos.IsKnown() {
+		base.Fatalf("unknown scope position")
+	}
+
+	if len(m.marks) == 0 {
+		return 0
+	}
+
+	last := &m.marks[len(m.marks)-1]
+	if xposBefore(pos, last.Pos) {
+		base.FatalfAt(pos, "non-monotonic scope positions\n\t%v: previous scope position", base.FmtPos(last.Pos))
+	}
+	return last.Scope
+}
+
+// Push records a transition to a new child scope of the current scope.
+func (m *ScopeMarker) Push(pos src.XPos) {
+	current := m.checkPos(pos)
+
+	m.parents = append(m.parents, current)
+	child := ir.ScopeID(len(m.parents))
+
+	m.marks = append(m.marks, ir.Mark{Pos: pos, Scope: child})
+}
+
+// Pop records a transition back to the current scope's parent.
+func (m *ScopeMarker) Pop(pos src.XPos) {
+	current := m.checkPos(pos)
+
+	parent := m.parents[current-1]
+
+	m.marks = append(m.marks, ir.Mark{Pos: pos, Scope: parent})
+}
+
+// Unpush removes the current scope, which must be empty.
+func (m *ScopeMarker) Unpush() {
+	i := len(m.marks) - 1
+	current := m.marks[i].Scope
+
+	if current != ir.ScopeID(len(m.parents)) {
+		base.FatalfAt(m.marks[i].Pos, "current scope is not empty")
+	}
+
+	m.parents = m.parents[:current-1]
+	m.marks = m.marks[:i]
+}
+
+// WriteTo writes the recorded scope marks to the given function,
+// and resets the marker for reuse.
+func (m *ScopeMarker) WriteTo(fn *ir.Func) {
+	m.compactMarks()
+
+	fn.Parents = make([]ir.ScopeID, len(m.parents))
+	copy(fn.Parents, m.parents)
+	m.parents = m.parents[:0]
+
+	fn.Marks = make([]ir.Mark, len(m.marks))
+	copy(fn.Marks, m.marks)
+	m.marks = m.marks[:0]
+}
+
+func (m *ScopeMarker) compactMarks() {
+	n := 0
+	for _, next := range m.marks {
+		if n > 0 && next.Pos == m.marks[n-1].Pos {
+			m.marks[n-1].Scope = next.Scope
+			continue
+		}
+		m.marks[n] = next
+		n++
+	}
+	m.marks = m.marks[:n]
+}
diff --git a/src/cmd/compile/internal/noder/import.go b/src/cmd/compile/internal/noder/import.go
index ca041a156c..747c30e6ff 100644
--- a/src/cmd/compile/internal/noder/import.go
+++ b/src/cmd/compile/internal/noder/import.go
@@ -5,18 +5,20 @@
 package noder
 
 import (
+	"errors"
 	"fmt"
-	"go/constant"
 	"os"
-	"path"
+	pathpkg "path"
 	"runtime"
 	"sort"
+	"strconv"
 	"strings"
 	"unicode"
 	"unicode/utf8"
 
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/syntax"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/archive"
@@ -38,160 +40,157 @@ func islocalname(name string) bool {
 		strings.HasPrefix(name, "../") || name == ".."
 }
 
-func findpkg(name string) (file string, ok bool) {
-	if islocalname(name) {
+func openPackage(path string) (*os.File, error) {
+	if islocalname(path) {
 		if base.Flag.NoLocalImports {
-			return "", false
+			return nil, errors.New("local imports disallowed")
 		}
 
 		if base.Flag.Cfg.PackageFile != nil {
-			file, ok = base.Flag.Cfg.PackageFile[name]
-			return file, ok
+			return os.Open(base.Flag.Cfg.PackageFile[path])
 		}
 
-		// try .a before .6.  important for building libraries:
-		// if there is an array.6 in the array.a library,
-		// want to find all of array.a, not just array.6.
-		file = fmt.Sprintf("%s.a", name)
-		if _, err := os.Stat(file); err == nil {
-			return file, true
+		// try .a before .o.  important for building libraries:
+		// if there is an array.o in the array.a library,
+		// want to find all of array.a, not just array.o.
+		if file, err := os.Open(fmt.Sprintf("%s.a", path)); err == nil {
+			return file, nil
 		}
-		file = fmt.Sprintf("%s.o", name)
-		if _, err := os.Stat(file); err == nil {
-			return file, true
+		if file, err := os.Open(fmt.Sprintf("%s.o", path)); err == nil {
+			return file, nil
 		}
-		return "", false
+		return nil, errors.New("file not found")
 	}
 
 	// local imports should be canonicalized already.
 	// don't want to see "encoding/../encoding/base64"
 	// as different from "encoding/base64".
-	if q := path.Clean(name); q != name {
-		base.Errorf("non-canonical import path %q (should be %q)", name, q)
-		return "", false
+	if q := pathpkg.Clean(path); q != path {
+		return nil, fmt.Errorf("non-canonical import path %q (should be %q)", path, q)
 	}
 
 	if base.Flag.Cfg.PackageFile != nil {
-		file, ok = base.Flag.Cfg.PackageFile[name]
-		return file, ok
+		return os.Open(base.Flag.Cfg.PackageFile[path])
 	}
 
 	for _, dir := range base.Flag.Cfg.ImportDirs {
-		file = fmt.Sprintf("%s/%s.a", dir, name)
-		if _, err := os.Stat(file); err == nil {
-			return file, true
+		if file, err := os.Open(fmt.Sprintf("%s/%s.a", dir, path)); err == nil {
+			return file, nil
 		}
-		file = fmt.Sprintf("%s/%s.o", dir, name)
-		if _, err := os.Stat(file); err == nil {
-			return file, true
+		if file, err := os.Open(fmt.Sprintf("%s/%s.o", dir, path)); err == nil {
+			return file, nil
 		}
 	}
 
 	if objabi.GOROOT != "" {
 		suffix := ""
-		suffixsep := ""
 		if base.Flag.InstallSuffix != "" {
-			suffixsep = "_"
-			suffix = base.Flag.InstallSuffix
+			suffix = "_" + base.Flag.InstallSuffix
 		} else if base.Flag.Race {
-			suffixsep = "_"
-			suffix = "race"
+			suffix = "_race"
 		} else if base.Flag.MSan {
-			suffixsep = "_"
-			suffix = "msan"
+			suffix = "_msan"
 		}
 
-		file = fmt.Sprintf("%s/pkg/%s_%s%s%s/%s.a", objabi.GOROOT, objabi.GOOS, objabi.GOARCH, suffixsep, suffix, name)
-		if _, err := os.Stat(file); err == nil {
-			return file, true
+		if file, err := os.Open(fmt.Sprintf("%s/pkg/%s_%s%s/%s.a", objabi.GOROOT, objabi.GOOS, objabi.GOARCH, suffix, path)); err == nil {
+			return file, nil
 		}
-		file = fmt.Sprintf("%s/pkg/%s_%s%s%s/%s.o", objabi.GOROOT, objabi.GOOS, objabi.GOARCH, suffixsep, suffix, name)
-		if _, err := os.Stat(file); err == nil {
-			return file, true
+		if file, err := os.Open(fmt.Sprintf("%s/pkg/%s_%s%s/%s.o", objabi.GOROOT, objabi.GOOS, objabi.GOARCH, suffix, path)); err == nil {
+			return file, nil
 		}
 	}
-
-	return "", false
+	return nil, errors.New("file not found")
 }
 
 // myheight tracks the local package's height based on packages
 // imported so far.
 var myheight int
 
-func importfile(f constant.Value) *types.Pkg {
-	if f.Kind() != constant.String {
-		base.Errorf("import path must be a string")
-		return nil
-	}
-
-	path_ := constant.StringVal(f)
-	if len(path_) == 0 {
-		base.Errorf("import path is empty")
-		return nil
-	}
-
-	if isbadimport(path_, false) {
-		return nil
-	}
-
+// resolveImportPath resolves an import path as it appears in a Go
+// source file to the package's full path.
+func resolveImportPath(path string) (string, error) {
 	// The package name main is no longer reserved,
 	// but we reserve the import path "main" to identify
 	// the main package, just as we reserve the import
 	// path "math" to identify the standard math package.
-	if path_ == "main" {
-		base.Errorf("cannot import \"main\"")
-		base.ErrorExit()
-	}
-
-	if base.Ctxt.Pkgpath != "" && path_ == base.Ctxt.Pkgpath {
-		base.Errorf("import %q while compiling that package (import cycle)", path_)
-		base.ErrorExit()
+	if path == "main" {
+		return "", errors.New("cannot import \"main\"")
 	}
 
-	if mapped, ok := base.Flag.Cfg.ImportMap[path_]; ok {
-		path_ = mapped
+	if base.Ctxt.Pkgpath != "" && path == base.Ctxt.Pkgpath {
+		return "", fmt.Errorf("import %q while compiling that package (import cycle)", path)
 	}
 
-	if path_ == "unsafe" {
-		return ir.Pkgs.Unsafe
+	if mapped, ok := base.Flag.Cfg.ImportMap[path]; ok {
+		path = mapped
 	}
 
-	if islocalname(path_) {
-		if path_[0] == '/' {
-			base.Errorf("import path cannot be absolute path")
-			return nil
+	if islocalname(path) {
+		if path[0] == '/' {
+			return "", errors.New("import path cannot be absolute path")
 		}
 
-		prefix := base.Ctxt.Pathname
-		if base.Flag.D != "" {
-			prefix = base.Flag.D
+		prefix := base.Flag.D
+		if prefix == "" {
+			// Questionable, but when -D isn't specified, historically we
+			// resolve local import paths relative to the directory the
+			// compiler's current directory, not the respective source
+			// file's directory.
+			prefix = base.Ctxt.Pathname
 		}
-		path_ = path.Join(prefix, path_)
+		path = pathpkg.Join(prefix, path)
 
-		if isbadimport(path_, true) {
-			return nil
+		if err := checkImportPath(path, true); err != nil {
+			return "", err
 		}
 	}
 
-	file, found := findpkg(path_)
-	if !found {
-		base.Errorf("can't find import: %q", path_)
-		base.ErrorExit()
+	return path, nil
+}
+
+// TODO(mdempsky): Return an error instead.
+func importfile(decl *syntax.ImportDecl) *types.Pkg {
+	if decl.Path.Kind != syntax.StringLit {
+		base.Errorf("import path must be a string")
+		return nil
 	}
 
-	importpkg := types.NewPkg(path_, "")
-	if importpkg.Imported {
-		return importpkg
+	path, err := strconv.Unquote(decl.Path.Value)
+	if err != nil {
+		base.Errorf("import path must be a string")
+		return nil
+	}
+
+	if err := checkImportPath(path, false); err != nil {
+		base.Errorf("%s", err.Error())
+		return nil
 	}
 
-	importpkg.Imported = true
+	path, err = resolveImportPath(path)
+	if err != nil {
+		base.Errorf("%s", err)
+		return nil
+	}
+
+	importpkg := types.NewPkg(path, "")
+	if importpkg.Direct {
+		return importpkg // already fully loaded
+	}
+	importpkg.Direct = true
+	typecheck.Target.Imports = append(typecheck.Target.Imports, importpkg)
+
+	if path == "unsafe" {
+		return importpkg // initialized with universe
+	}
 
-	imp, err := bio.Open(file)
+	f, err := openPackage(path)
 	if err != nil {
-		base.Errorf("can't open import: %q: %v", path_, err)
+		base.Errorf("could not import %q: %v", path, err)
 		base.ErrorExit()
 	}
+	imp := bio.NewReader(f)
 	defer imp.Close()
+	file := f.Name()
 
 	// check object header
 	p, err := imp.ReadString('\n')
@@ -261,12 +260,12 @@ func importfile(f constant.Value) *types.Pkg {
 	var fingerprint goobj.FingerprintType
 	switch c {
 	case '\n':
-		base.Errorf("cannot import %s: old export format no longer supported (recompile library)", path_)
+		base.Errorf("cannot import %s: old export format no longer supported (recompile library)", path)
 		return nil
 
 	case 'B':
 		if base.Debug.Export != 0 {
-			fmt.Printf("importing %s (%s)\n", path_, file)
+			fmt.Printf("importing %s (%s)\n", path, file)
 		}
 		imp.ReadByte() // skip \n after $$B
 
@@ -285,17 +284,17 @@ func importfile(f constant.Value) *types.Pkg {
 		fingerprint = typecheck.ReadImports(importpkg, imp)
 
 	default:
-		base.Errorf("no import in %q", path_)
+		base.Errorf("no import in %q", path)
 		base.ErrorExit()
 	}
 
 	// assume files move (get installed) so don't record the full path
 	if base.Flag.Cfg.PackageFile != nil {
 		// If using a packageFile map, assume path_ can be recorded directly.
-		base.Ctxt.AddImport(path_, fingerprint)
+		base.Ctxt.AddImport(path, fingerprint)
 	} else {
 		// For file "/Users/foo/go/pkg/darwin_amd64/math.a" record "math.a".
-		base.Ctxt.AddImport(file[len(file)-len(path_)-len(".a"):], fingerprint)
+		base.Ctxt.AddImport(file[len(file)-len(path)-len(".a"):], fingerprint)
 	}
 
 	if importpkg.Height >= myheight {
@@ -315,47 +314,37 @@ var reservedimports = []string{
 	"type",
 }
 
-func isbadimport(path string, allowSpace bool) bool {
+func checkImportPath(path string, allowSpace bool) error {
+	if path == "" {
+		return errors.New("import path is empty")
+	}
+
 	if strings.Contains(path, "\x00") {
-		base.Errorf("import path contains NUL")
-		return true
+		return errors.New("import path contains NUL")
 	}
 
 	for _, ri := range reservedimports {
 		if path == ri {
-			base.Errorf("import path %q is reserved and cannot be used", path)
-			return true
+			return fmt.Errorf("import path %q is reserved and cannot be used", path)
 		}
 	}
 
 	for _, r := range path {
-		if r == utf8.RuneError {
-			base.Errorf("import path contains invalid UTF-8 sequence: %q", path)
-			return true
-		}
-
-		if r < 0x20 || r == 0x7f {
-			base.Errorf("import path contains control character: %q", path)
-			return true
-		}
-
-		if r == '\\' {
-			base.Errorf("import path contains backslash; use slash: %q", path)
-			return true
-		}
-
-		if !allowSpace && unicode.IsSpace(r) {
-			base.Errorf("import path contains space character: %q", path)
-			return true
-		}
-
-		if strings.ContainsRune("!\"#$%&'()*,:;<=>?[]^`{|}", r) {
-			base.Errorf("import path contains invalid character '%c': %q", r, path)
-			return true
+		switch {
+		case r == utf8.RuneError:
+			return fmt.Errorf("import path contains invalid UTF-8 sequence: %q", path)
+		case r < 0x20 || r == 0x7f:
+			return fmt.Errorf("import path contains control character: %q", path)
+		case r == '\\':
+			return fmt.Errorf("import path contains backslash; use slash: %q", path)
+		case !allowSpace && unicode.IsSpace(r):
+			return fmt.Errorf("import path contains space character: %q", path)
+		case strings.ContainsRune("!\"#$%&'()*,:;<=>?[]^`{|}", r):
+			return fmt.Errorf("import path contains invalid character '%c': %q", r, path)
 		}
 	}
 
-	return false
+	return nil
 }
 
 func pkgnotused(lineno src.XPos, path string, name string) {
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 5bb01895cc..6aab18549a 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -17,6 +17,7 @@ import (
 	"unicode/utf8"
 
 	"cmd/compile/internal/base"
+	"cmd/compile/internal/dwarfgen"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/syntax"
 	"cmd/compile/internal/typecheck"
@@ -27,40 +28,26 @@ import (
 
 func LoadPackage(filenames []string) {
 	base.Timer.Start("fe", "parse")
-	lines := ParseFiles(filenames)
-	base.Timer.Stop()
-	base.Timer.AddEvent(int64(lines), "lines")
 
-	// Typecheck.
-	Package()
+	mode := syntax.CheckBranches
 
-	// With all user code typechecked, it's now safe to verify unused dot imports.
-	CheckDotImports()
-	base.ExitIfErrors()
-}
-
-// ParseFiles concurrently parses files into *syntax.File structures.
-// Each declaration in every *syntax.File is converted to a syntax tree
-// and its root represented by *Node is appended to Target.Decls.
-// Returns the total count of parsed lines.
-func ParseFiles(filenames []string) uint {
-	noders := make([]*noder, 0, len(filenames))
 	// Limit the number of simultaneously open files.
 	sem := make(chan struct{}, runtime.GOMAXPROCS(0)+10)
 
-	for _, filename := range filenames {
-		p := &noder{
-			basemap:     make(map[*syntax.PosBase]*src.PosBase),
+	noders := make([]*noder, len(filenames))
+	for i, filename := range filenames {
+		p := noder{
 			err:         make(chan syntax.Error),
 			trackScopes: base.Flag.Dwarf,
 		}
-		noders = append(noders, p)
+		noders[i] = &p
 
-		go func(filename string) {
+		filename := filename
+		go func() {
 			sem <- struct{}{}
 			defer func() { <-sem }()
 			defer close(p.err)
-			base := syntax.NewFileBase(filename)
+			fbase := syntax.NewFileBase(filename)
 
 			f, err := os.Open(filename)
 			if err != nil {
@@ -69,8 +56,8 @@ func ParseFiles(filenames []string) uint {
 			}
 			defer f.Close()
 
-			p.file, _ = syntax.Parse(base, f, p.error, p.pragma, syntax.CheckBranches) // errors are tracked via p.error
-		}(filename)
+			p.file, _ = syntax.Parse(fbase, f, p.error, p.pragma, mode) // errors are tracked via p.error
+		}()
 	}
 
 	var lines uint
@@ -78,30 +65,27 @@ func ParseFiles(filenames []string) uint {
 		for e := range p.err {
 			p.errorAt(e.Pos, "%s", e.Msg)
 		}
+		lines += p.file.Lines
+	}
+	base.Timer.AddEvent(int64(lines), "lines")
 
+	for _, p := range noders {
 		p.node()
-		lines += p.file.Lines
 		p.file = nil // release memory
+	}
 
-		if base.SyntaxErrors() != 0 {
-			base.ErrorExit()
-		}
-		// Always run CheckDclstack here, even when debug_dclstack is not set, as a sanity measure.
-		types.CheckDclstack()
+	if base.SyntaxErrors() != 0 {
+		base.ErrorExit()
 	}
+	types.CheckDclstack()
 
 	for _, p := range noders {
 		p.processPragmas()
 	}
 
+	// Typecheck.
 	types.LocalPkg.Height = myheight
-
-	return lines
-}
-
-func Package() {
 	typecheck.DeclareUniverse()
-
 	typecheck.TypecheckAllowed = true
 
 	// Process top-level declarations in phases.
@@ -166,44 +150,10 @@ func Package() {
 	}
 
 	// Phase 5: With all user code type-checked, it's now safe to verify map keys.
+	// With all user code typechecked, it's now safe to verify unused dot imports.
 	typecheck.CheckMapKeys()
-
-}
-
-// makeSrcPosBase translates from a *syntax.PosBase to a *src.PosBase.
-func (p *noder) makeSrcPosBase(b0 *syntax.PosBase) *src.PosBase {
-	// fast path: most likely PosBase hasn't changed
-	if p.basecache.last == b0 {
-		return p.basecache.base
-	}
-
-	b1, ok := p.basemap[b0]
-	if !ok {
-		fn := b0.Filename()
-		if b0.IsFileBase() {
-			b1 = src.NewFileBase(fn, absFilename(fn))
-		} else {
-			// line directive base
-			p0 := b0.Pos()
-			p0b := p0.Base()
-			if p0b == b0 {
-				panic("infinite recursion in makeSrcPosBase")
-			}
-			p1 := src.MakePos(p.makeSrcPosBase(p0b), p0.Line(), p0.Col())
-			b1 = src.NewLinePragmaBase(p1, fn, fileh(fn), b0.Line(), b0.Col())
-		}
-		p.basemap[b0] = b1
-	}
-
-	// update cache
-	p.basecache.last = b0
-	p.basecache.base = b1
-
-	return b1
-}
-
-func (p *noder) makeXPos(pos syntax.Pos) (_ src.XPos) {
-	return base.Ctxt.PosTable.XPos(src.MakePos(p.makeSrcPosBase(pos.Base()), pos.Line(), pos.Col()))
+	CheckDotImports()
+	base.ExitIfErrors()
 }
 
 func (p *noder) errorAt(pos syntax.Pos, format string, args ...interface{}) {
@@ -221,31 +171,33 @@ func absFilename(name string) string {
 
 // noder transforms package syntax's AST into a Node tree.
 type noder struct {
-	basemap   map[*syntax.PosBase]*src.PosBase
-	basecache struct {
-		last *syntax.PosBase
-		base *src.PosBase
-	}
+	posMap
 
 	file           *syntax.File
 	linknames      []linkname
 	pragcgobuf     [][]string
 	err            chan syntax.Error
-	scope          ir.ScopeID
 	importedUnsafe bool
 	importedEmbed  bool
+	trackScopes    bool
 
-	// scopeVars is a stack tracking the number of variables declared in the
-	// current function at the moment each open scope was opened.
-	trackScopes bool
-	scopeVars   []int
+	funcState *funcState
+}
+
+// funcState tracks all per-function state to make handling nested
+// functions easier.
+type funcState struct {
+	// scopeVars is a stack tracking the number of variables declared in
+	// the current function at the moment each open scope was opened.
+	scopeVars []int
+	marker    dwarfgen.ScopeMarker
 
 	lastCloseScopePos syntax.Pos
 }
 
 func (p *noder) funcBody(fn *ir.Func, block *syntax.BlockStmt) {
-	oldScope := p.scope
-	p.scope = 0
+	outerFuncState := p.funcState
+	p.funcState = new(funcState)
 	typecheck.StartFuncBody(fn)
 
 	if block != nil {
@@ -260,62 +212,34 @@ func (p *noder) funcBody(fn *ir.Func, block *syntax.BlockStmt) {
 	}
 
 	typecheck.FinishFuncBody()
-	p.scope = oldScope
+	p.funcState.marker.WriteTo(fn)
+	p.funcState = outerFuncState
 }
 
 func (p *noder) openScope(pos syntax.Pos) {
+	fs := p.funcState
 	types.Markdcl()
 
 	if p.trackScopes {
-		ir.CurFunc.Parents = append(ir.CurFunc.Parents, p.scope)
-		p.scopeVars = append(p.scopeVars, len(ir.CurFunc.Dcl))
-		p.scope = ir.ScopeID(len(ir.CurFunc.Parents))
-
-		p.markScope(pos)
+		fs.scopeVars = append(fs.scopeVars, len(ir.CurFunc.Dcl))
+		fs.marker.Push(p.makeXPos(pos))
 	}
 }
 
 func (p *noder) closeScope(pos syntax.Pos) {
-	p.lastCloseScopePos = pos
+	fs := p.funcState
+	fs.lastCloseScopePos = pos
 	types.Popdcl()
 
 	if p.trackScopes {
-		scopeVars := p.scopeVars[len(p.scopeVars)-1]
-		p.scopeVars = p.scopeVars[:len(p.scopeVars)-1]
+		scopeVars := fs.scopeVars[len(fs.scopeVars)-1]
+		fs.scopeVars = fs.scopeVars[:len(fs.scopeVars)-1]
 		if scopeVars == len(ir.CurFunc.Dcl) {
 			// no variables were declared in this scope, so we can retract it.
-
-			if int(p.scope) != len(ir.CurFunc.Parents) {
-				base.Fatalf("scope tracking inconsistency, no variables declared but scopes were not retracted")
-			}
-
-			p.scope = ir.CurFunc.Parents[p.scope-1]
-			ir.CurFunc.Parents = ir.CurFunc.Parents[:len(ir.CurFunc.Parents)-1]
-
-			nmarks := len(ir.CurFunc.Marks)
-			ir.CurFunc.Marks[nmarks-1].Scope = p.scope
-			prevScope := ir.ScopeID(0)
-			if nmarks >= 2 {
-				prevScope = ir.CurFunc.Marks[nmarks-2].Scope
-			}
-			if ir.CurFunc.Marks[nmarks-1].Scope == prevScope {
-				ir.CurFunc.Marks = ir.CurFunc.Marks[:nmarks-1]
-			}
-			return
+			fs.marker.Unpush()
+		} else {
+			fs.marker.Pop(p.makeXPos(pos))
 		}
-
-		p.scope = ir.CurFunc.Parents[p.scope-1]
-
-		p.markScope(pos)
-	}
-}
-
-func (p *noder) markScope(pos syntax.Pos) {
-	xpos := p.makeXPos(pos)
-	if i := len(ir.CurFunc.Marks); i > 0 && ir.CurFunc.Marks[i-1].Pos == xpos {
-		ir.CurFunc.Marks[i-1].Scope = p.scope
-	} else {
-		ir.CurFunc.Marks = append(ir.CurFunc.Marks, ir.Mark{Pos: xpos, Scope: p.scope})
 	}
 }
 
@@ -324,7 +248,7 @@ func (p *noder) markScope(pos syntax.Pos) {
 // "if" statements, as their implicit blocks always end at the same
 // position as an explicit block.
 func (p *noder) closeAnotherScope() {
-	p.closeScope(p.lastCloseScopePos)
+	p.closeScope(p.funcState.lastCloseScopePos)
 }
 
 // linkname records a //go:linkname directive.
@@ -335,7 +259,6 @@ type linkname struct {
 }
 
 func (p *noder) node() {
-	types.Block = 1
 	p.importedUnsafe = false
 	p.importedEmbed = false
 
@@ -404,7 +327,7 @@ func (p *noder) decls(decls []syntax.Decl) (l []ir.Node) {
 }
 
 func (p *noder) importDecl(imp *syntax.ImportDecl) {
-	if imp.Path.Bad {
+	if imp.Path == nil || imp.Path.Bad {
 		return // avoid follow-on errors if there was a syntax error
 	}
 
@@ -412,7 +335,7 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
 		p.checkUnused(pragma)
 	}
 
-	ipkg := importfile(p.basicLit(imp.Path))
+	ipkg := importfile(imp)
 	if ipkg == nil {
 		if base.Errors() == 0 {
 			base.Fatalf("phase error in import")
@@ -427,11 +350,6 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
 		p.importedEmbed = true
 	}
 
-	if !ipkg.Direct {
-		typecheck.Target.Imports = append(typecheck.Target.Imports, ipkg)
-	}
-	ipkg.Direct = true
-
 	var my *types.Sym
 	if imp.LocalPkgName != nil {
 		my = p.name(imp.LocalPkgName)
@@ -465,20 +383,7 @@ func (p *noder) varDecl(decl *syntax.VarDecl) []ir.Node {
 	exprs := p.exprList(decl.Values)
 
 	if pragma, ok := decl.Pragma.(*pragmas); ok {
-		if len(pragma.Embeds) > 0 {
-			if !p.importedEmbed {
-				// This check can't be done when building the list pragma.Embeds
-				// because that list is created before the noder starts walking over the file,
-				// so at that point it hasn't seen the imports.
-				// We're left to check now, just before applying the //go:embed lines.
-				for _, e := range pragma.Embeds {
-					p.errorAt(e.Pos, "//go:embed only allowed in Go files that import \"embed\"")
-				}
-			} else {
-				varEmbed(p, names, typ, exprs, pragma.Embeds)
-			}
-			pragma.Embeds = nil
-		}
+		varEmbed(p.makeXPos, names[0], decl, pragma, p.importedEmbed)
 		p.checkUnused(pragma)
 	}
 
@@ -1126,9 +1031,16 @@ func (p *noder) stmtFall(stmt syntax.Stmt, fallOK bool) ir.Node {
 	case *syntax.DeclStmt:
 		return ir.NewBlockStmt(src.NoXPos, p.decls(stmt.DeclList))
 	case *syntax.AssignStmt:
+		if stmt.Rhs == syntax.ImplicitOne {
+			one := constant.MakeInt64(1)
+			pos := p.pos(stmt)
+			n := ir.NewAssignOpStmt(pos, p.binOp(stmt.Op), p.expr(stmt.Lhs), ir.NewBasicLit(pos, one))
+			n.IncDec = true
+			return n
+		}
+
 		if stmt.Op != 0 && stmt.Op != syntax.Def {
 			n := ir.NewAssignOpStmt(p.pos(stmt), p.binOp(stmt.Op), p.expr(stmt.Lhs), p.expr(stmt.Rhs))
-			n.IncDec = stmt.Rhs == syntax.ImplicitOne
 			return n
 		}
 
@@ -1588,15 +1500,6 @@ func (p *noder) wrapname(n syntax.Node, x ir.Node) ir.Node {
 	return x
 }
 
-func (p *noder) pos(n syntax.Node) src.XPos {
-	// TODO(gri): orig.Pos() should always be known - fix package syntax
-	xpos := base.Pos
-	if pos := n.Pos(); pos.IsKnown() {
-		xpos = p.makeXPos(pos)
-	}
-	return xpos
-}
-
 func (p *noder) setlineno(n syntax.Node) {
 	if n != nil {
 		base.Pos = p.pos(n)
@@ -1923,48 +1826,41 @@ func oldname(s *types.Sym) ir.Node {
 	return n
 }
 
-func varEmbed(p *noder, names []*ir.Name, typ ir.Ntype, exprs []ir.Node, embeds []pragmaEmbed) {
-	haveEmbed := false
-	for _, decl := range p.file.DeclList {
-		imp, ok := decl.(*syntax.ImportDecl)
-		if !ok {
-			// imports always come first
-			break
-		}
-		path, _ := strconv.Unquote(imp.Path.Value)
-		if path == "embed" {
-			haveEmbed = true
-			break
-		}
+func varEmbed(makeXPos func(syntax.Pos) src.XPos, name *ir.Name, decl *syntax.VarDecl, pragma *pragmas, haveEmbed bool) {
+	if pragma.Embeds == nil {
+		return
 	}
 
-	pos := embeds[0].Pos
+	pragmaEmbeds := pragma.Embeds
+	pragma.Embeds = nil
+	pos := makeXPos(pragmaEmbeds[0].Pos)
+
 	if !haveEmbed {
-		p.errorAt(pos, "invalid go:embed: missing import \"embed\"")
+		base.ErrorfAt(pos, "go:embed only allowed in Go files that import \"embed\"")
 		return
 	}
-	if len(names) > 1 {
-		p.errorAt(pos, "go:embed cannot apply to multiple vars")
+	if len(decl.NameList) > 1 {
+		base.ErrorfAt(pos, "go:embed cannot apply to multiple vars")
 		return
 	}
-	if len(exprs) > 0 {
-		p.errorAt(pos, "go:embed cannot apply to var with initializer")
+	if decl.Values != nil {
+		base.ErrorfAt(pos, "go:embed cannot apply to var with initializer")
 		return
 	}
-	if typ == nil {
-		// Should not happen, since len(exprs) == 0 now.
-		p.errorAt(pos, "go:embed cannot apply to var without type")
+	if decl.Type == nil {
+		// Should not happen, since Values == nil now.
+		base.ErrorfAt(pos, "go:embed cannot apply to var without type")
 		return
 	}
 	if typecheck.DeclContext != ir.PEXTERN {
-		p.errorAt(pos, "go:embed cannot apply to var inside func")
+		base.ErrorfAt(pos, "go:embed cannot apply to var inside func")
 		return
 	}
 
-	v := names[0]
-	typecheck.Target.Embeds = append(typecheck.Target.Embeds, v)
-	v.Embed = new([]ir.Embed)
-	for _, e := range embeds {
-		*v.Embed = append(*v.Embed, ir.Embed{Pos: p.makeXPos(e.Pos), Patterns: e.Patterns})
+	var embeds []ir.Embed
+	for _, e := range pragmaEmbeds {
+		embeds = append(embeds, ir.Embed{Pos: makeXPos(e.Pos), Patterns: e.Patterns})
 	}
+	typecheck.Target.Embeds = append(typecheck.Target.Embeds, name)
+	name.Embed = &embeds
 }
diff --git a/src/cmd/compile/internal/noder/posmap.go b/src/cmd/compile/internal/noder/posmap.go
new file mode 100644
index 0000000000..a6d3e2d7ef
--- /dev/null
+++ b/src/cmd/compile/internal/noder/posmap.go
@@ -0,0 +1,83 @@
+// Copyright 2021 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 noder
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/syntax"
+	"cmd/internal/src"
+)
+
+// A posMap handles mapping from syntax.Pos to src.XPos.
+type posMap struct {
+	bases map[*syntax.PosBase]*src.PosBase
+	cache struct {
+		last *syntax.PosBase
+		base *src.PosBase
+	}
+}
+
+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 {
+	if !pos.IsKnown() {
+		// TODO(mdempsky): Investigate restoring base.Fatalf.
+		return src.NoXPos
+	}
+
+	posBase := m.makeSrcPosBase(pos.Base())
+	return base.Ctxt.PosTable.XPos(src.MakePos(posBase, pos.Line(), pos.Col()))
+}
+
+// makeSrcPosBase translates from a *syntax.PosBase to a *src.PosBase.
+func (m *posMap) makeSrcPosBase(b0 *syntax.PosBase) *src.PosBase {
+	// fast path: most likely PosBase hasn't changed
+	if m.cache.last == b0 {
+		return m.cache.base
+	}
+
+	b1, ok := m.bases[b0]
+	if !ok {
+		fn := b0.Filename()
+		if b0.IsFileBase() {
+			b1 = src.NewFileBase(fn, absFilename(fn))
+		} else {
+			// line directive base
+			p0 := b0.Pos()
+			p0b := p0.Base()
+			if p0b == b0 {
+				panic("infinite recursion in makeSrcPosBase")
+			}
+			p1 := src.MakePos(m.makeSrcPosBase(p0b), p0.Line(), p0.Col())
+			b1 = src.NewLinePragmaBase(p1, fn, fileh(fn), b0.Line(), b0.Col())
+		}
+		if m.bases == nil {
+			m.bases = make(map[*syntax.PosBase]*src.PosBase)
+		}
+		m.bases[b0] = b1
+	}
+
+	// update cache
+	m.cache.last = b0
+	m.cache.base = b1
+
+	return b1
+}
+
+func (m *posMap) join(other *posMap) {
+	if m.bases == nil {
+		m.bases = make(map[*syntax.PosBase]*src.PosBase)
+	}
+	for k, v := range other.bases {
+		if m.bases[k] != nil {
+			base.Fatalf("duplicate posmap bases")
+		}
+		m.bases[k] = v
+	}
+}
diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index 1ec92e3dd0..3ff14c87f4 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -791,7 +791,7 @@ func dcommontype(lsym *obj.LSym, t *types.Type) int {
 // TrackSym returns the symbol for tracking use of field/method f, assumed
 // to be a member of struct/interface type t.
 func TrackSym(t *types.Type, f *types.Field) *obj.LSym {
-	return base.PkgLinksym("go.track", t.ShortString() + "." + f.Sym.Name, obj.ABI0)
+	return base.PkgLinksym("go.track", t.ShortString()+"."+f.Sym.Name, obj.ABI0)
 }
 
 func TypeSymPrefix(prefix string, t *types.Type) *types.Sym {
diff --git a/src/cmd/compile/internal/typecheck/dcl.go b/src/cmd/compile/internal/typecheck/dcl.go
index c324238bf1..eab0bb09b2 100644
--- a/src/cmd/compile/internal/typecheck/dcl.go
+++ b/src/cmd/compile/internal/typecheck/dcl.go
@@ -304,10 +304,13 @@ func checkembeddedtype(t *types.Type) {
 	}
 }
 
-func fakeRecvField() *types.Field {
+// TODO(mdempsky): Move to package types.
+func FakeRecv() *types.Field {
 	return types.NewField(src.NoXPos, nil, types.FakeRecvType())
 }
 
+var fakeRecvField = FakeRecv
+
 var funcStack []funcStackEnt // stack of previous values of ir.CurFunc/DeclContext
 
 type funcStackEnt struct {
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index f624773c8f..7ab5f68ce3 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -174,7 +174,7 @@ func fnpkg(fn *ir.Name) *types.Pkg {
 
 // closurename generates a new unique name for a closure within
 // outerfunc.
-func closurename(outerfunc *ir.Func) *types.Sym {
+func ClosureName(outerfunc *ir.Func) *types.Sym {
 	outer := "glob."
 	prefix := "func"
 	gen := &globClosgen
@@ -309,7 +309,7 @@ func tcClosure(clo *ir.ClosureExpr, top int) {
 	// explicitly in (*inlsubst).node()).
 	inTypeCheckInl := ir.CurFunc != nil && ir.CurFunc.Body == nil
 	if !inTypeCheckInl {
-		fn.Nname.SetSym(closurename(ir.CurFunc))
+		fn.Nname.SetSym(ClosureName(ir.CurFunc))
 		ir.MarkFunc(fn.Nname)
 	}
 	Func(fn)
diff --git a/src/cmd/compile/internal/typecheck/subr.go b/src/cmd/compile/internal/typecheck/subr.go
index b6a0870672..b88a9f2283 100644
--- a/src/cmd/compile/internal/typecheck/subr.go
+++ b/src/cmd/compile/internal/typecheck/subr.go
@@ -127,10 +127,9 @@ func NodNil() ir.Node {
 	return n
 }
 
-// in T.field
-// find missing fields that
-// will give shortest unique addressing.
-// modify the tree with missing type names.
+// AddImplicitDots finds missing fields in obj.field that
+// will give the shortest unique addressing and
+// modifies the tree with missing field names.
 func AddImplicitDots(n *ir.SelectorExpr) *ir.SelectorExpr {
 	n.X = typecheck(n.X, ctxType|ctxExpr)
 	if n.X.Diag() {
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 7881ea308d..cb434578dd 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -1674,10 +1674,10 @@ func CheckMapKeys() {
 	mapqueue = nil
 }
 
-// typegen tracks the number of function-scoped defined types that
+// TypeGen tracks the number of function-scoped defined types that
 // have been declared. It's used to generate unique linker symbols for
 // their runtime type descriptors.
-var typegen int32
+var TypeGen int32
 
 func typecheckdeftype(n *ir.Name) {
 	if base.EnableTrace && base.Flag.LowerT {
@@ -1686,8 +1686,8 @@ func typecheckdeftype(n *ir.Name) {
 
 	t := types.NewNamed(n)
 	if n.Curfn != nil {
-		typegen++
-		t.Vargen = typegen
+		TypeGen++
+		t.Vargen = TypeGen
 	}
 
 	if n.Pragma()&ir.NotInHeap != 0 {
diff --git a/src/cmd/compile/internal/types/pkg.go b/src/cmd/compile/internal/types/pkg.go
index de45d32bfa..a6d2e2007b 100644
--- a/src/cmd/compile/internal/types/pkg.go
+++ b/src/cmd/compile/internal/types/pkg.go
@@ -31,8 +31,7 @@ type Pkg struct {
 	// height of their imported packages.
 	Height int
 
-	Imported bool // export data of this package was parsed
-	Direct   bool // imported directly
+	Direct bool // imported directly
 }
 
 // NewPkg returns a new Pkg for the given package path and name.
diff --git a/src/cmd/compile/internal/types/scope.go b/src/cmd/compile/internal/types/scope.go
index a9669ffafc..d7c454f379 100644
--- a/src/cmd/compile/internal/types/scope.go
+++ b/src/cmd/compile/internal/types/scope.go
@@ -12,7 +12,7 @@ import (
 // Declaration stack & operations
 
 var blockgen int32 = 1 // max block number
-var Block int32        // current block number
+var Block int32 = 1    // current block number
 
 // A dsym stores a symbol's shadowed declaration so that it can be
 // restored once the block scope ends.
diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index 4273a62fe5..b47d96dc4c 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -49,6 +49,11 @@ func Walk(fn *ir.Func) {
 	if base.Flag.Cfg.Instrumenting {
 		instrument(fn)
 	}
+
+	// Eagerly compute sizes of all variables for SSA.
+	for _, n := range fn.Dcl {
+		types.CalcSize(n.Type())
+	}
 }
 
 // walkRecv walks an ORECV node.
diff --git a/src/cmd/internal/obj/link.go b/src/cmd/internal/obj/link.go
index 7ba8c6d317..35cb53cbf6 100644
--- a/src/cmd/internal/obj/link.go
+++ b/src/cmd/internal/obj/link.go
@@ -809,9 +809,9 @@ type Link struct {
 	Errors             int
 	RegArgs            []RegArg
 
-	InParallel      bool // parallel backend phase in effect
-	UseBASEntries   bool // use Base Address Selection Entries in location lists and PC ranges
-	IsAsm           bool // is the source assembly language, which may contain surprising idioms (e.g., call tables)
+	InParallel    bool // parallel backend phase in effect
+	UseBASEntries bool // use Base Address Selection Entries in location lists and PC ranges
+	IsAsm         bool // is the source assembly language, which may contain surprising idioms (e.g., call tables)
 
 	// state for writing objects
 	Text []*LSym
diff --git a/test/fixedbugs/issue11362.go b/test/fixedbugs/issue11362.go
index 964e5fdf6b..9492ec1273 100644
--- a/test/fixedbugs/issue11362.go
+++ b/test/fixedbugs/issue11362.go
@@ -8,7 +8,7 @@
 
 package main
 
-import _ "unicode//utf8" // GC_ERROR "non-canonical import path .unicode//utf8. \(should be .unicode/utf8.\)" "can't find import: .unicode//utf8."
+import _ "unicode//utf8" // GC_ERROR "non-canonical import path .unicode//utf8. \(should be .unicode/utf8.\)"
 
 func main() {
 }
-- 
GitLab


From 5a76c3d5485e5c5714a147e10a6bc55738ab0b90 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Thu, 21 Jan 2021 12:02:39 -0500
Subject: [PATCH 0556/2400] [dev.regabi] cmd/compile: modify abiutils for
 recently updated ABI

Discovered difficluties posed by earlier design, these modifications
should work better.  Updated tests, also added some helper functions
for use in call lowering.

Change-Id: I459f0f71ad8a6730c571244925c3f395e1df28de
Reviewed-on: https://go-review.googlesource.com/c/go/+/285392
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/abi/abiutils.go      | 146 +++++++++---
 .../compile/internal/test/abiutils_test.go    | 214 ++++++++++--------
 .../compile/internal/test/abiutilsaux_test.go |  18 +-
 3 files changed, 244 insertions(+), 134 deletions(-)

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index 3ac59e6f75..e935821802 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -25,9 +25,8 @@ import (
 type ABIParamResultInfo struct {
 	inparams          []ABIParamAssignment // Includes receiver for method calls.  Does NOT include hidden closure pointer.
 	outparams         []ABIParamAssignment
-	intSpillSlots     int
-	floatSpillSlots   int
 	offsetToSpillArea int64
+	spillAreaSize     int64
 	config            *ABIConfig // to enable String() method
 }
 
@@ -47,18 +46,14 @@ func (a *ABIParamResultInfo) OutParam(i int) ABIParamAssignment {
 	return a.outparams[i]
 }
 
-func (a *ABIParamResultInfo) IntSpillCount() int {
-	return a.intSpillSlots
-}
-
-func (a *ABIParamResultInfo) FloatSpillCount() int {
-	return a.floatSpillSlots
-}
-
 func (a *ABIParamResultInfo) SpillAreaOffset() int64 {
 	return a.offsetToSpillArea
 }
 
+func (a *ABIParamResultInfo) SpillAreaSize() int64 {
+	return a.spillAreaSize
+}
+
 // RegIndex stores the index into the set of machine registers used by
 // the ABI on a specific architecture for parameter passing.  RegIndex
 // values 0 through N-1 (where N is the number of integer registers
@@ -78,7 +73,27 @@ type RegIndex uint8
 type ABIParamAssignment struct {
 	Type      *types.Type
 	Registers []RegIndex
-	Offset    int32
+	offset    int32
+}
+
+// Offset returns the stack offset for addressing the parameter that "a" describes.
+// This will panic if "a" describes a register-allocated parameter.
+func (a *ABIParamAssignment) Offset() int32 {
+	if len(a.Registers) > 0 {
+		panic("Register allocated parameters have no offset")
+	}
+	return a.offset
+}
+
+// SpillOffset returns the offset *within the spill area* for the parameter that "a" describes.
+// Registers will be spilled here; if a memory home is needed (for a pointer method e.g.)
+// then that will be the address.
+// This will panic if "a" describes a stack-allocated parameter.
+func (a *ABIParamAssignment) SpillOffset() int32 {
+	if len(a.Registers) == 0 {
+		panic("Stack-allocated parameters have no spill offset")
+	}
+	return a.offset
 }
 
 // RegAmounts holds a specified number of integer/float registers.
@@ -91,20 +106,58 @@ type RegAmounts struct {
 // by the ABI rules for parameter passing and result returning.
 type ABIConfig struct {
 	// Do we need anything more than this?
-	regAmounts RegAmounts
+	regAmounts       RegAmounts
+	regsForTypeCache map[*types.Type]int
 }
 
 // NewABIConfig returns a new ABI configuration for an architecture with
 // iRegsCount integer/pointer registers and fRegsCount floating point registers.
 func NewABIConfig(iRegsCount, fRegsCount int) *ABIConfig {
-	return &ABIConfig{RegAmounts{iRegsCount, fRegsCount}}
+	return &ABIConfig{regAmounts: RegAmounts{iRegsCount, fRegsCount}, regsForTypeCache: make(map[*types.Type]int)}
+}
+
+// NumParamRegs returns the number of parameter registers used for a given type,
+// without regard for the number available.
+func (a *ABIConfig) NumParamRegs(t *types.Type) int {
+	if n, ok := a.regsForTypeCache[t]; ok {
+		return n
+	}
+
+	if t.IsScalar() || t.IsPtrShaped() {
+		var n int
+		if t.IsComplex() {
+			n = 2
+		} else {
+			n = (int(t.Size()) + types.RegSize - 1) / types.RegSize
+		}
+		a.regsForTypeCache[t] = n
+		return n
+	}
+	typ := t.Kind()
+	n := 0
+	switch typ {
+	case types.TARRAY:
+		n = a.NumParamRegs(t.Elem()) * int(t.NumElem())
+	case types.TSTRUCT:
+		for _, f := range t.FieldSlice() {
+			n += a.NumParamRegs(f.Type)
+		}
+	case types.TSLICE:
+		n = a.NumParamRegs(synthSlice)
+	case types.TSTRING:
+		n = a.NumParamRegs(synthString)
+	case types.TINTER:
+		n = a.NumParamRegs(synthIface)
+	}
+	a.regsForTypeCache[t] = n
+	return n
 }
 
 // ABIAnalyze takes a function type 't' and an ABI rules description
 // 'config' and analyzes the function to determine how its parameters
 // and results will be passed (in registers or on the stack), returning
 // an ABIParamResultInfo object that holds the results of the analysis.
-func ABIAnalyze(t *types.Type, config *ABIConfig) ABIParamResultInfo {
+func (config *ABIConfig) ABIAnalyze(t *types.Type) ABIParamResultInfo {
 	setup()
 	s := assignState{
 		rTotal: config.regAmounts,
@@ -116,28 +169,27 @@ func ABIAnalyze(t *types.Type, config *ABIConfig) ABIParamResultInfo {
 	if t.NumRecvs() != 0 {
 		rfsl := ft.Receiver.FieldSlice()
 		result.inparams = append(result.inparams,
-			s.assignParamOrReturn(rfsl[0].Type))
+			s.assignParamOrReturn(rfsl[0].Type, false))
 	}
 
 	// Inputs
 	ifsl := ft.Params.FieldSlice()
 	for _, f := range ifsl {
 		result.inparams = append(result.inparams,
-			s.assignParamOrReturn(f.Type))
+			s.assignParamOrReturn(f.Type, false))
 	}
 	s.stackOffset = types.Rnd(s.stackOffset, int64(types.RegSize))
 
-	// Record number of spill slots needed.
-	result.intSpillSlots = s.rUsed.intRegs
-	result.floatSpillSlots = s.rUsed.floatRegs
-
 	// Outputs
 	s.rUsed = RegAmounts{}
 	ofsl := ft.Results.FieldSlice()
 	for _, f := range ofsl {
-		result.outparams = append(result.outparams, s.assignParamOrReturn(f.Type))
+		result.outparams = append(result.outparams, s.assignParamOrReturn(f.Type, true))
 	}
-	result.offsetToSpillArea = s.stackOffset
+	// The spill area is at a register-aligned offset and its size is rounded up to a register alignment.
+	// TODO in theory could align offset only to minimum required by spilled data types.
+	result.offsetToSpillArea = alignTo(s.stackOffset, types.RegSize)
+	result.spillAreaSize = alignTo(s.spillOffset, types.RegSize)
 
 	return result
 }
@@ -160,10 +212,14 @@ func (c *RegAmounts) regString(r RegIndex) string {
 // form, suitable for debugging or unit testing.
 func (ri *ABIParamAssignment) toString(config *ABIConfig) string {
 	regs := "R{"
+	offname := "spilloffset" // offset is for spill for register(s)
+	if len(ri.Registers) == 0 {
+		offname = "offset" // offset is for memory arg
+	}
 	for _, r := range ri.Registers {
 		regs += " " + config.regAmounts.regString(r)
 	}
-	return fmt.Sprintf("%s } offset: %d typ: %v", regs, ri.Offset, ri.Type)
+	return fmt.Sprintf("%s } %s: %d typ: %v", regs, offname, ri.offset, ri.Type)
 }
 
 // toString method renders an ABIParamResultInfo in human-readable
@@ -176,8 +232,8 @@ func (ri *ABIParamResultInfo) String() string {
 	for k, r := range ri.outparams {
 		res += fmt.Sprintf("OUT %d: %s\n", k, r.toString(ri.config))
 	}
-	res += fmt.Sprintf("intspill: %d floatspill: %d offsetToSpillArea: %d",
-		ri.intSpillSlots, ri.floatSpillSlots, ri.offsetToSpillArea)
+	res += fmt.Sprintf("offsetToSpillArea: %d spillAreaSize: %d",
+		ri.offsetToSpillArea, ri.spillAreaSize)
 	return res
 }
 
@@ -188,16 +244,27 @@ type assignState struct {
 	rUsed       RegAmounts // regs used by params completely assigned so far
 	pUsed       RegAmounts // regs used by the current param (or pieces therein)
 	stackOffset int64      // current stack offset
+	spillOffset int64      // current spill offset
+}
+
+// align returns a rounded up to t's alignment
+func align(a int64, t *types.Type) int64 {
+	return alignTo(a, int(t.Align))
+}
+
+// alignTo returns a rounded up to t, where t must be 0 or a power of 2.
+func alignTo(a int64, t int) int64 {
+	if t == 0 {
+		return a
+	}
+	return types.Rnd(a, int64(t))
 }
 
 // stackSlot returns a stack offset for a param or result of the
 // specified type.
 func (state *assignState) stackSlot(t *types.Type) int64 {
-	if t.Align > 0 {
-		state.stackOffset = types.Rnd(state.stackOffset, int64(t.Align))
-	}
-	rv := state.stackOffset
-	state.stackOffset += t.Width
+	rv := align(state.stackOffset, t)
+	state.stackOffset = rv + t.Width
 	return rv
 }
 
@@ -225,11 +292,17 @@ func (state *assignState) allocateRegs() []RegIndex {
 // regAllocate creates a register ABIParamAssignment object for a param
 // or result with the specified type, as a final step (this assumes
 // that all of the safety/suitability analysis is complete).
-func (state *assignState) regAllocate(t *types.Type) ABIParamAssignment {
+func (state *assignState) regAllocate(t *types.Type, isReturn bool) ABIParamAssignment {
+	spillLoc := int64(-1)
+	if !isReturn {
+		// Spill for register-resident t must be aligned for storage of a t.
+		spillLoc = align(state.spillOffset, t)
+		state.spillOffset = spillLoc + t.Size()
+	}
 	return ABIParamAssignment{
 		Type:      t,
 		Registers: state.allocateRegs(),
-		Offset:    -1,
+		offset:    int32(spillLoc),
 	}
 }
 
@@ -239,7 +312,7 @@ func (state *assignState) regAllocate(t *types.Type) ABIParamAssignment {
 func (state *assignState) stackAllocate(t *types.Type) ABIParamAssignment {
 	return ABIParamAssignment{
 		Type:   t,
-		Offset: int32(state.stackSlot(t)),
+		offset: int32(state.stackSlot(t)),
 	}
 }
 
@@ -261,6 +334,9 @@ func (state *assignState) floatUsed() int {
 // accordingly).
 func (state *assignState) regassignIntegral(t *types.Type) bool {
 	regsNeeded := int(types.Rnd(t.Width, int64(types.PtrSize)) / int64(types.PtrSize))
+	if t.IsComplex() {
+		regsNeeded = 2
+	}
 
 	// Floating point and complex.
 	if t.IsFloat() || t.IsComplex() {
@@ -371,14 +447,14 @@ func (state *assignState) regassign(pt *types.Type) bool {
 // of type 'pt' to determine whether it can be register assigned.
 // The result of the analysis is recorded in the result
 // ABIParamResultInfo held in 'state'.
-func (state *assignState) assignParamOrReturn(pt *types.Type) ABIParamAssignment {
+func (state *assignState) assignParamOrReturn(pt *types.Type, isReturn bool) ABIParamAssignment {
 	state.pUsed = RegAmounts{}
 	if pt.Width == types.BADWIDTH {
 		panic("should never happen")
 	} else if pt.Width == 0 {
 		return state.stackAllocate(pt)
 	} else if state.regassign(pt) {
-		return state.regAllocate(pt)
+		return state.regAllocate(pt, isReturn)
 	} else {
 		return state.stackAllocate(pt)
 	}
diff --git a/src/cmd/compile/internal/test/abiutils_test.go b/src/cmd/compile/internal/test/abiutils_test.go
index ae7d484062..decc29667e 100644
--- a/src/cmd/compile/internal/test/abiutils_test.go
+++ b/src/cmd/compile/internal/test/abiutils_test.go
@@ -21,7 +21,7 @@ import (
 // AMD64 registers available:
 // - integer: RAX, RBX, RCX, RDI, RSI, R8, R9, r10, R11
 // - floating point: X0 - X14
-var configAMD64 = abi.NewABIConfig(9,15)
+var configAMD64 = abi.NewABIConfig(9, 15)
 
 func TestMain(m *testing.M) {
 	ssagen.Arch.LinkArch = &x86.Linkamd64
@@ -46,9 +46,9 @@ func TestABIUtilsBasic1(t *testing.T) {
 
 	// expected results
 	exp := makeExpectedDump(`
-		IN 0: R{ I0 } offset: -1 typ: int32
-		OUT 0: R{ I0 } offset: -1 typ: int32
-		intspill: 1 floatspill: 0 offsetToSpillArea: 0
+        IN 0: R{ I0 } spilloffset: 0 typ: int32
+        OUT 0: R{ I0 } spilloffset: -1 typ: int32
+        offsetToSpillArea: 0 spillAreaSize: 8
 `)
 
 	abitest(t, ft, exp)
@@ -75,39 +75,39 @@ func TestABIUtilsBasic2(t *testing.T) {
 			i8, i16, i32, i64},
 		[]*types.Type{i32, f64, f64})
 	exp := makeExpectedDump(`
-		IN 0: R{ I0 } offset: -1 typ: int8
-		IN 1: R{ I1 } offset: -1 typ: int16
-		IN 2: R{ I2 } offset: -1 typ: int32
-		IN 3: R{ I3 } offset: -1 typ: int64
-		IN 4: R{ F0 } offset: -1 typ: float32
-		IN 5: R{ F1 } offset: -1 typ: float32
-		IN 6: R{ F2 } offset: -1 typ: float64
-		IN 7: R{ F3 } offset: -1 typ: float64
-		IN 8: R{ I4 } offset: -1 typ: int8
-		IN 9: R{ I5 } offset: -1 typ: int16
-		IN 10: R{ I6 } offset: -1 typ: int32
-		IN 11: R{ I7 } offset: -1 typ: int64
-		IN 12: R{ F4 } offset: -1 typ: float32
-		IN 13: R{ F5 } offset: -1 typ: float32
-		IN 14: R{ F6 } offset: -1 typ: float64
-		IN 15: R{ F7 } offset: -1 typ: float64
-		IN 16: R{ F8 F9 } offset: -1 typ: complex128
-		IN 17: R{ F10 F11 } offset: -1 typ: complex128
-		IN 18: R{ F12 F13 } offset: -1 typ: complex128
-		IN 19: R{ } offset: 0 typ: complex128
-		IN 20: R{ F14 } offset: -1 typ: complex64
-		IN 21: R{ I8 } offset: -1 typ: int8
-		IN 22: R{ } offset: 16 typ: int16
-		IN 23: R{ } offset: 20 typ: int32
-		IN 24: R{ } offset: 24 typ: int64
-		IN 25: R{ } offset: 32 typ: int8
-		IN 26: R{ } offset: 34 typ: int16
-		IN 27: R{ } offset: 36 typ: int32
-		IN 28: R{ } offset: 40 typ: int64
-		OUT 0: R{ I0 } offset: -1 typ: int32
-		OUT 1: R{ F0 } offset: -1 typ: float64
-		OUT 2: R{ F1 } offset: -1 typ: float64
-		intspill: 9 floatspill: 15 offsetToSpillArea: 48
+        IN 0: R{ I0 } spilloffset: 0 typ: int8
+        IN 1: R{ I1 } spilloffset: 2 typ: int16
+        IN 2: R{ I2 } spilloffset: 4 typ: int32
+        IN 3: R{ I3 } spilloffset: 8 typ: int64
+        IN 4: R{ F0 } spilloffset: 16 typ: float32
+        IN 5: R{ F1 } spilloffset: 20 typ: float32
+        IN 6: R{ F2 } spilloffset: 24 typ: float64
+        IN 7: R{ F3 } spilloffset: 32 typ: float64
+        IN 8: R{ I4 } spilloffset: 40 typ: int8
+        IN 9: R{ I5 } spilloffset: 42 typ: int16
+        IN 10: R{ I6 } spilloffset: 44 typ: int32
+        IN 11: R{ I7 } spilloffset: 48 typ: int64
+        IN 12: R{ F4 } spilloffset: 56 typ: float32
+        IN 13: R{ F5 } spilloffset: 60 typ: float32
+        IN 14: R{ F6 } spilloffset: 64 typ: float64
+        IN 15: R{ F7 } spilloffset: 72 typ: float64
+        IN 16: R{ F8 F9 } spilloffset: 80 typ: complex128
+        IN 17: R{ F10 F11 } spilloffset: 96 typ: complex128
+        IN 18: R{ F12 F13 } spilloffset: 112 typ: complex128
+        IN 19: R{ } offset: 0 typ: complex128
+        IN 20: R{ } offset: 16 typ: complex64
+        IN 21: R{ I8 } spilloffset: 128 typ: int8
+        IN 22: R{ } offset: 24 typ: int16
+        IN 23: R{ } offset: 28 typ: int32
+        IN 24: R{ } offset: 32 typ: int64
+        IN 25: R{ } offset: 40 typ: int8
+        IN 26: R{ } offset: 42 typ: int16
+        IN 27: R{ } offset: 44 typ: int32
+        IN 28: R{ } offset: 48 typ: int64
+        OUT 0: R{ I0 } spilloffset: -1 typ: int32
+        OUT 1: R{ F0 } spilloffset: -1 typ: float64
+        OUT 2: R{ F1 } spilloffset: -1 typ: float64
+        offsetToSpillArea: 56 spillAreaSize: 136
 `)
 
 	abitest(t, ft, exp)
@@ -123,15 +123,15 @@ func TestABIUtilsArrays(t *testing.T) {
 		[]*types.Type{a2, a1, ae, aa1})
 
 	exp := makeExpectedDump(`
-		IN 0: R{ I0 } offset: -1 typ: [1]int32
-		IN 1: R{ } offset: 0 typ: [0]int32
-		IN 2: R{ I1 } offset: -1 typ: [1][1]int32
-		IN 3: R{ } offset: 0 typ: [2]int32
-		OUT 0: R{ } offset: 8 typ: [2]int32
-		OUT 1: R{ I0 } offset: -1 typ: [1]int32
-		OUT 2: R{ } offset: 16 typ: [0]int32
-		OUT 3: R{ I1 } offset: -1 typ: [1][1]int32
-		intspill: 2 floatspill: 0 offsetToSpillArea: 16
+        IN 0: R{ I0 } spilloffset: 0 typ: [1]int32
+        IN 1: R{ } offset: 0 typ: [0]int32
+        IN 2: R{ I1 } spilloffset: 4 typ: [1][1]int32
+        IN 3: R{ } offset: 0 typ: [2]int32
+        OUT 0: R{ } offset: 8 typ: [2]int32
+        OUT 1: R{ I0 } spilloffset: -1 typ: [1]int32
+        OUT 2: R{ } offset: 16 typ: [0]int32
+        OUT 3: R{ I1 } spilloffset: -1 typ: [1][1]int32
+        offsetToSpillArea: 16 spillAreaSize: 8
 `)
 
 	abitest(t, ft, exp)
@@ -147,13 +147,13 @@ func TestABIUtilsStruct1(t *testing.T) {
 		[]*types.Type{s, i8, i32})
 
 	exp := makeExpectedDump(`
-		IN 0: R{ I0 } offset: -1 typ: int8
-		IN 1: R{ I1 I2 I3 I4 } offset: -1 typ: struct { int8; int8; struct {}; int8; int16 }
-		IN 2: R{ I5 } offset: -1 typ: int64
-		OUT 0: R{ I0 I1 I2 I3 } offset: -1 typ: struct { int8; int8; struct {}; int8; int16 }
-		OUT 1: R{ I4 } offset: -1 typ: int8
-		OUT 2: R{ I5 } offset: -1 typ: int32
-		intspill: 6 floatspill: 0 offsetToSpillArea: 0
+        IN 0: R{ I0 } spilloffset: 0 typ: int8
+        IN 1: R{ I1 I2 I3 I4 } spilloffset: 2 typ: struct { int8; int8; struct {}; int8; int16 }
+        IN 2: R{ I5 } spilloffset: 8 typ: int64
+        OUT 0: R{ I0 I1 I2 I3 } spilloffset: -1 typ: struct { int8; int8; struct {}; int8; int16 }
+        OUT 1: R{ I4 } spilloffset: -1 typ: int8
+        OUT 2: R{ I5 } spilloffset: -1 typ: int32
+        offsetToSpillArea: 0 spillAreaSize: 16
 `)
 
 	abitest(t, ft, exp)
@@ -168,12 +168,12 @@ func TestABIUtilsStruct2(t *testing.T) {
 		[]*types.Type{fs, fs})
 
 	exp := makeExpectedDump(`
-		IN 0: R{ I0 } offset: -1 typ: struct { int64; struct {} }
-		IN 1: R{ I1 } offset: -1 typ: struct { int64; struct {} }
-		IN 2: R{ I2 F0 } offset: -1 typ: struct { float64; struct { int64; struct {} }; struct {} }
-		OUT 0: R{ I0 F0 } offset: -1 typ: struct { float64; struct { int64; struct {} }; struct {} }
-		OUT 1: R{ I1 F1 } offset: -1 typ: struct { float64; struct { int64; struct {} }; struct {} }
-		intspill: 3 floatspill: 1 offsetToSpillArea: 0
+        IN 0: R{ I0 } spilloffset: 0 typ: struct { int64; struct {} }
+        IN 1: R{ I1 } spilloffset: 16 typ: struct { int64; struct {} }
+        IN 2: R{ I2 F0 } spilloffset: 32 typ: struct { float64; struct { int64; struct {} }; struct {} }
+        OUT 0: R{ I0 F0 } spilloffset: -1 typ: struct { float64; struct { int64; struct {} }; struct {} }
+        OUT 1: R{ I1 F1 } spilloffset: -1 typ: struct { float64; struct { int64; struct {} }; struct {} }
+        offsetToSpillArea: 0 spillAreaSize: 64
 `)
 
 	abitest(t, ft, exp)
@@ -189,19 +189,19 @@ func TestABIUtilsSliceString(t *testing.T) {
 		[]*types.Type{str, i64, str, sli32})
 
 	exp := makeExpectedDump(`
-		IN 0: R{ I0 I1 I2 } offset: -1 typ: []int32
-		IN 1: R{ I3 } offset: -1 typ: int8
-		IN 2: R{ I4 I5 I6 } offset: -1 typ: []int32
-		IN 3: R{ I7 } offset: -1 typ: int8
-		IN 4: R{ } offset: 0 typ: string
-		IN 5: R{ I8 } offset: -1 typ: int8
-		IN 6: R{ } offset: 16 typ: int64
-		IN 7: R{ } offset: 24 typ: []int32
-		OUT 0: R{ I0 I1 } offset: -1 typ: string
-		OUT 1: R{ I2 } offset: -1 typ: int64
-		OUT 2: R{ I3 I4 } offset: -1 typ: string
-		OUT 3: R{ I5 I6 I7 } offset: -1 typ: []int32
-		intspill: 9 floatspill: 0 offsetToSpillArea: 48
+        IN 0: R{ I0 I1 I2 } spilloffset: 0 typ: []int32
+        IN 1: R{ I3 } spilloffset: 24 typ: int8
+        IN 2: R{ I4 I5 I6 } spilloffset: 32 typ: []int32
+        IN 3: R{ I7 } spilloffset: 56 typ: int8
+        IN 4: R{ } offset: 0 typ: string
+        IN 5: R{ I8 } spilloffset: 57 typ: int8
+        IN 6: R{ } offset: 16 typ: int64
+        IN 7: R{ } offset: 24 typ: []int32
+        OUT 0: R{ I0 I1 } spilloffset: -1 typ: string
+        OUT 1: R{ I2 } spilloffset: -1 typ: int64
+        OUT 2: R{ I3 I4 } spilloffset: -1 typ: string
+        OUT 3: R{ I5 I6 I7 } spilloffset: -1 typ: []int32
+        offsetToSpillArea: 48 spillAreaSize: 64
 `)
 
 	abitest(t, ft, exp)
@@ -219,17 +219,17 @@ func TestABIUtilsMethod(t *testing.T) {
 		[]*types.Type{a7, f64, i64})
 
 	exp := makeExpectedDump(`
-		IN 0: R{ I0 I1 I2 } offset: -1 typ: struct { int16; int16; int16 }
-		IN 1: R{ I3 } offset: -1 typ: *struct { int16; int16; int16 }
-		IN 2: R{ } offset: 0 typ: [7]*struct { int16; int16; int16 }
-		IN 3: R{ F0 } offset: -1 typ: float64
-		IN 4: R{ I4 } offset: -1 typ: int16
-		IN 5: R{ I5 } offset: -1 typ: int16
-		IN 6: R{ I6 } offset: -1 typ: int16
-		OUT 0: R{ } offset: 56 typ: [7]*struct { int16; int16; int16 }
-		OUT 1: R{ F0 } offset: -1 typ: float64
-		OUT 2: R{ I0 } offset: -1 typ: int64
-		intspill: 7 floatspill: 1 offsetToSpillArea: 112
+        IN 0: R{ I0 I1 I2 } spilloffset: 0 typ: struct { int16; int16; int16 }
+        IN 1: R{ I3 } spilloffset: 8 typ: *struct { int16; int16; int16 }
+        IN 2: R{ } offset: 0 typ: [7]*struct { int16; int16; int16 }
+        IN 3: R{ F0 } spilloffset: 16 typ: float64
+        IN 4: R{ I4 } spilloffset: 24 typ: int16
+        IN 5: R{ I5 } spilloffset: 26 typ: int16
+        IN 6: R{ I6 } spilloffset: 28 typ: int16
+        OUT 0: R{ } offset: 56 typ: [7]*struct { int16; int16; int16 }
+        OUT 1: R{ F0 } spilloffset: -1 typ: float64
+        OUT 2: R{ I0 } spilloffset: -1 typ: int64
+        offsetToSpillArea: 112 spillAreaSize: 32
 `)
 
 	abitest(t, ft, exp)
@@ -252,18 +252,44 @@ func TestABIUtilsInterfaces(t *testing.T) {
 		[]*types.Type{ei, nei, pei})
 
 	exp := makeExpectedDump(`
-		IN 0: R{ I0 I1 I2 } offset: -1 typ: struct { int16; int16; bool }
-		IN 1: R{ I3 I4 } offset: -1 typ: interface {}
-		IN 2: R{ I5 I6 } offset: -1 typ: interface {}
-		IN 3: R{ I7 I8 } offset: -1 typ: interface { () untyped string }
-		IN 4: R{ } offset: 0 typ: *interface {}
-		IN 5: R{ } offset: 8 typ: interface { () untyped string }
-		IN 6: R{ } offset: 24 typ: int16
-		OUT 0: R{ I0 I1 } offset: -1 typ: interface {}
-		OUT 1: R{ I2 I3 } offset: -1 typ: interface { () untyped string }
-		OUT 2: R{ I4 } offset: -1 typ: *interface {}
-		intspill: 9 floatspill: 0 offsetToSpillArea: 32
+        IN 0: R{ I0 I1 I2 } spilloffset: 0 typ: struct { int16; int16; bool }
+        IN 1: R{ I3 I4 } spilloffset: 8 typ: interface {}
+        IN 2: R{ I5 I6 } spilloffset: 24 typ: interface {}
+        IN 3: R{ I7 I8 } spilloffset: 40 typ: interface { () untyped string }
+        IN 4: R{ } offset: 0 typ: *interface {}
+        IN 5: R{ } offset: 8 typ: interface { () untyped string }
+        IN 6: R{ } offset: 24 typ: int16
+        OUT 0: R{ I0 I1 } spilloffset: -1 typ: interface {}
+        OUT 1: R{ I2 I3 } spilloffset: -1 typ: interface { () untyped string }
+        OUT 2: R{ I4 } spilloffset: -1 typ: *interface {}
+        offsetToSpillArea: 32 spillAreaSize: 56
 `)
 
 	abitest(t, ft, exp)
 }
+
+func TestABINumParamRegs(t *testing.T) {
+	i8 := types.Types[types.TINT8]
+	i16 := types.Types[types.TINT16]
+	i32 := types.Types[types.TINT32]
+	i64 := types.Types[types.TINT64]
+	f32 := types.Types[types.TFLOAT32]
+	f64 := types.Types[types.TFLOAT64]
+	c64 := types.Types[types.TCOMPLEX64]
+	c128 := types.Types[types.TCOMPLEX128]
+
+	s := mkstruct([]*types.Type{i8, i8, mkstruct([]*types.Type{}), i8, i16})
+	a := types.NewArray(s, 3)
+
+	nrtest(t, i8, 1)
+	nrtest(t, i16, 1)
+	nrtest(t, i32, 1)
+	nrtest(t, i64, 1)
+	nrtest(t, f32, 1)
+	nrtest(t, f64, 1)
+	nrtest(t, c64, 2)
+	nrtest(t, c128, 2)
+	nrtest(t, s, 4)
+	nrtest(t, a, 12)
+
+}
\ No newline at end of file
diff --git a/src/cmd/compile/internal/test/abiutilsaux_test.go b/src/cmd/compile/internal/test/abiutilsaux_test.go
index 10fb668745..19dd3a51fd 100644
--- a/src/cmd/compile/internal/test/abiutilsaux_test.go
+++ b/src/cmd/compile/internal/test/abiutilsaux_test.go
@@ -78,9 +78,9 @@ func tokenize(src string) []string {
 
 func verifyParamResultOffset(t *testing.T, f *types.Field, r abi.ABIParamAssignment, which string, idx int) int {
 	n := ir.AsNode(f.Nname).(*ir.Name)
-	if n.FrameOffset() != int64(r.Offset) {
+	if n.FrameOffset() != int64(r.Offset()) {
 		t.Errorf("%s %d: got offset %d wanted %d t=%v",
-			which, idx, r.Offset, n.Offset_, f.Type)
+			which, idx, r.Offset(), n.Offset_, f.Type)
 		return 1
 	}
 	return 0
@@ -106,12 +106,20 @@ func difftokens(atoks []string, etoks []string) string {
 	return ""
 }
 
+func nrtest(t *testing.T, ft *types.Type, expected int) {
+	types.CalcSize(ft)
+	got := configAMD64.NumParamRegs(ft)
+	if got != expected {
+		t.Errorf("]\nexpected num regs = %d, got %d, type %v", expected, got, ft)
+	}
+}
+
 func abitest(t *testing.T, ft *types.Type, exp expectedDump) {
 
 	types.CalcSize(ft)
 
 	// Analyze with full set of registers.
-	regRes := abi.ABIAnalyze(ft, configAMD64)
+	regRes := configAMD64.ABIAnalyze(ft)
 	regResString := strings.TrimSpace(regRes.String())
 
 	// Check results.
@@ -122,8 +130,8 @@ func abitest(t *testing.T, ft *types.Type, exp expectedDump) {
 	}
 
 	// Analyze again with empty register set.
-	empty := &abi.ABIConfig{}
-	emptyRes := abi.ABIAnalyze(ft, empty)
+	empty := abi.NewABIConfig(0, 0)
+	emptyRes := empty.ABIAnalyze(ft)
 	emptyResString := emptyRes.String()
 
 	// Walk the results and make sure the offsets assigned match
-- 
GitLab


From 8ee3d398383170e21ba2a63b3a45e1577f97c329 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 24 Jan 2021 12:26:47 -0800
Subject: [PATCH 0557/2400] [dev.regabi] cmd/go: workaround -race issue on
 ppc64le

The race detector on ppc64le corrupts command-line arguments lists if
they contain an empty string, and cmd/go often generates compiler
argument lists containing `-D ""`. Since this is equivalent to not
specifying the `-D` flag at all, just do that. This allows using a
race-detector-enabled cmd/compile on ppc64le.

Updates #43883.

Change-Id: Ifac5cd9a44932129438b9b0b3ecc6101ad3716b2
Reviewed-on: https://go-review.googlesource.com/c/go/+/286173
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/internal/work/gc.go | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/cmd/go/internal/work/gc.go b/src/cmd/go/internal/work/gc.go
index cc4e2b2b2b..3205fcbffc 100644
--- a/src/cmd/go/internal/work/gc.go
+++ b/src/cmd/go/internal/work/gc.go
@@ -129,7 +129,11 @@ func (gcToolchain) gc(b *Builder, a *Action, archive string, importcfg, embedcfg
 		}
 	}
 
-	args := []interface{}{cfg.BuildToolexec, base.Tool("compile"), "-o", ofile, "-trimpath", a.trimpath(), gcflags, gcargs, "-D", p.Internal.LocalPrefix}
+	args := []interface{}{cfg.BuildToolexec, base.Tool("compile"), "-o", ofile, "-trimpath", a.trimpath(), gcflags, gcargs}
+	if p.Internal.LocalPrefix != "" {
+		// Workaround #43883.
+		args = append(args, "-D", p.Internal.LocalPrefix)
+	}
 	if importcfg != nil {
 		if err := b.writeFile(objdir+"importcfg", importcfg); err != nil {
 			return "", nil, err
-- 
GitLab


From 13f02018aff2b98be8b396635a0a73532ac1722e Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 24 Jan 2021 21:04:39 -0800
Subject: [PATCH 0558/2400] [dev.typeparams] test: enable more errorcheck tests
 w/ -G=3

Change-Id: I170e4f9c5a1db4bad02a5fe4bddc65d4c75f51e8
Reviewed-on: https://go-review.googlesource.com/c/go/+/286232
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 test/run.go | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

diff --git a/test/run.go b/test/run.go
index 0be106c54a..1b0062da24 100644
--- a/test/run.go
+++ b/test/run.go
@@ -777,18 +777,7 @@ func (t *test) run() {
 		// Excluded flags.
 		for _, flag := range flags {
 			for _, pattern := range []string{
-				"-+",
-				"-0",
-				"-e=0",
 				"-m",
-				"-live",
-				"-std",
-				"wb",
-				"append",
-				"slice",
-				"typeassert",
-				"defer",
-				"nil",
 			} {
 				if strings.Contains(flag, pattern) {
 					if *verbose {
@@ -1938,8 +1927,10 @@ var excluded = map[string]bool{
 	"import6.go":      true, // issue #43109
 	"initializerr.go": true, // types2 reports extra errors
 	"linkname2.go":    true, // error reported by noder (not running for types2 errorcheck test)
+	"notinheap.go":    true, // types2 doesn't report errors about conversions that are invalid due to //go:notinheap
 	"shift1.go":       true, // issue #42989
 	"typecheck.go":    true, // invalid function is not causing errors when called
+	"writebarrier.go": true, // correct diagnostics, but different lines (probably irgen's fault)
 
 	"fixedbugs/bug176.go":    true, // types2 reports all errors (pref: types2)
 	"fixedbugs/bug193.go":    true, // types2 bug: shift error not reported (fixed in go/types)
@@ -1962,10 +1953,13 @@ var excluded = map[string]bool{
 	"fixedbugs/issue16428.go":  true, // types2 reports two instead of one error
 	"fixedbugs/issue17038.go":  true, // types2 doesn't report a follow-on error (pref: types2)
 	"fixedbugs/issue17645.go":  true, // multiple errors on same line
+	"fixedbugs/issue18331.go":  true, // missing error about misuse of //go:noescape (irgen needs code from noder)
 	"fixedbugs/issue18393.go":  true, // types2 not run after syntax errors
 	"fixedbugs/issue19012.go":  true, // multiple errors on same line
+	"fixedbugs/issue20298.go":  true, // types2 non-deterministically reports unused imports
 	"fixedbugs/issue20233.go":  true, // types2 reports two instead of one error (pref: compiler)
 	"fixedbugs/issue20245.go":  true, // types2 reports two instead of one error (pref: compiler)
+	"fixedbugs/issue20250.go":  true, // correct diagnostics, but different lines (probably irgen's fault)
 	"fixedbugs/issue20529.go":  true, // types2 doesn't produce "stack frame too large" error
 	"fixedbugs/issue20780.go":  true, // types2 doesn't produce "stack frame too large" error
 	"fixedbugs/issue21979.go":  true, // types2 doesn't report a follow-on error (pref: types2)
-- 
GitLab


From 493eb6e6ec916288ff0ebd8ba9e5cc0cccbdfc74 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 24 Jan 2021 23:31:25 -0800
Subject: [PATCH 0559/2400] [dev.typeparams] cmd/compile: fix -G=3 handling of
 blank methods

Fixes "GO_GCFLAGS=-G=3 go run run.go -- blank.go interface/fail.go".

Change-Id: I669ab06ae29366ce96e2948c89a5c1620afd53db
Reviewed-on: https://go-review.googlesource.com/c/go/+/286214
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/noder/object.go | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/noder/object.go b/src/cmd/compile/internal/noder/object.go
index 9567042156..c740285ca2 100644
--- a/src/cmd/compile/internal/noder/object.go
+++ b/src/cmd/compile/internal/noder/object.go
@@ -79,7 +79,10 @@ func (g *irgen) obj(obj types2.Object) *ir.Name {
 			}
 			typ = g.typ(sig)
 		} else {
-			sym = ir.MethodSym(g.typ(recv.Type()), g.selector(obj))
+			sym = g.selector(obj)
+			if !sym.IsBlank() {
+				sym = ir.MethodSym(g.typ(recv.Type()), sym)
+			}
 			typ = g.signature(g.param(recv), sig)
 		}
 		name = g.objCommon(pos, ir.ONAME, sym, ir.PFUNC, typ)
-- 
GitLab


From be9612a832186637173e35a2aa83ae193cf8d957 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 24 Jan 2021 21:26:14 -0800
Subject: [PATCH 0560/2400] [dev.regabi] os: disable TestDirFS until #42637 is
 fixed

This test is causing nearly every trybot run on dev.regabi and
dev.typeparams to fail. It's already a release blocker for Go 1.16, so
the failures on the development branches is entirely noise; and
because it causes the trybots to short-circuit, it risks masking
actual Windows-specific failures.

This CL disables the test until a proper solution is decided upon and
implemented for Go 1.16.

Updates #42637.

Change-Id: Ibc85edaed591f1c125cf0b210867aa89d2b0a4b6
Reviewed-on: https://go-review.googlesource.com/c/go/+/286213
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/os/os_test.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/os/os_test.go b/src/os/os_test.go
index 698dbca91e..c02dc2c375 100644
--- a/src/os/os_test.go
+++ b/src/os/os_test.go
@@ -2689,6 +2689,9 @@ func TestOpenFileKeepsPermissions(t *testing.T) {
 }
 
 func TestDirFS(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("workaround for dev.regabi/dev.typeparams until #42637 is fixed")
+	}
 	if err := fstest.TestFS(DirFS("./testdata/dirfs"), "a", "b", "dir/x"); err != nil {
 		t.Fatal(err)
 	}
-- 
GitLab


From 6a4739ccc5198449d58d2e90a040c4fb908b3cb0 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 24 Jan 2021 23:39:16 -0800
Subject: [PATCH 0561/2400] [dev.regabi] cmd/compile: enable rational constant
 arithmetic

This allows more precision and matches types2's behavior.

For backwards compatibility with gcimporter, for now we still need to
write out declared constants as limited-precision floating-point
values. To ensure consistent behavior of constant arithmetic whether
it spans package boundaries or not, we include the full-precision
rational representation in the compiler's extension section of the
export data.

Also, this CL simply uses the math/big.Rat.String text representation
as the encoding. This is inefficient, but because it's only in the
compiler's extension section, we can easily revisit this in the
future.

Declaring exported untyped float and complex constants isn't very
common anyway. Within the standard library, only package math declares
any at all, containing just 15. And those 15 are only imported a total
of 12 times elsewhere in the standard library.

Change-Id: I85ea23ab712e93fd3b68e52d60cbedce9be696a0
Reviewed-on: https://go-review.googlesource.com/c/go/+/286215
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/noder.go       |  8 ---
 src/cmd/compile/internal/typecheck/iexport.go | 51 +++++++++++++++++--
 src/cmd/compile/internal/typecheck/iimport.go | 27 +++++++++-
 test/fixedbugs/issue7740.go                   |  2 +-
 test/float_lit3.go                            |  5 +-
 5 files changed, 76 insertions(+), 17 deletions(-)

diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 6aab18549a..5b5b09cb2d 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -1455,14 +1455,6 @@ func (p *noder) basicLit(lit *syntax.BasicLit) constant.Value {
 		p.errorAt(lit.Pos(), "malformed constant: %s", lit.Value)
 	}
 
-	// go/constant uses big.Rat by default, which is more precise, but
-	// causes toolstash -cmp and some tests to fail. For now, convert
-	// to big.Float to match cmd/compile's historical precision.
-	// TODO(mdempsky): Remove.
-	if v.Kind() == constant.Float {
-		v = constant.Make(ir.BigFloat(v))
-	}
-
 	return v
 }
 
diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index be4a689836..6fab74e61f 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -462,12 +462,16 @@ func (p *iexporter) doDecl(n *ir.Name) {
 		}
 
 	case ir.OLITERAL:
+		// TODO(mdempsky): Extend check to all declarations.
+		if n.Typecheck() == 0 {
+			base.FatalfAt(n.Pos(), "missed typecheck: %v", n)
+		}
+
 		// Constant.
-		// TODO(mdempsky): Do we still need this typecheck? If so, why?
-		n = Expr(n).(*ir.Name)
 		w.tag('C')
 		w.pos(n.Pos())
 		w.value(n.Type(), n.Val())
+		w.constExt(n)
 
 	case ir.OTYPE:
 		if types.IsDotAlias(n.Sym()) {
@@ -956,6 +960,17 @@ func (w *exportWriter) mpfloat(v constant.Value, typ *types.Type) {
 	}
 }
 
+func (w *exportWriter) mprat(v constant.Value) {
+	r, ok := constant.Val(v).(*big.Rat)
+	if !w.bool(ok) {
+		return
+	}
+	// TODO(mdempsky): Come up with a more efficient binary
+	// encoding before bumping iexportVersion to expose to
+	// gcimporter.
+	w.string(r.String())
+}
+
 func (w *exportWriter) bool(b bool) bool {
 	var x uint64
 	if b {
@@ -971,7 +986,37 @@ func (w *exportWriter) string(s string) { w.uint64(w.p.stringOff(s)) }
 
 // Compiler-specific extensions.
 
-func (w *exportWriter) varExt(n ir.Node) {
+func (w *exportWriter) constExt(n *ir.Name) {
+	// Internally, we now represent untyped float and complex
+	// constants with infinite-precision rational numbers using
+	// go/constant, but the "public" export data format known to
+	// gcimporter only supports 512-bit floating point constants.
+	// In case rationals turn out to be a bad idea and we want to
+	// switch back to fixed-precision constants, for now we
+	// continue writing out the 512-bit truncation in the public
+	// data section, and write the exact, rational constant in the
+	// compiler's extension data. Also, we only need to worry
+	// about exporting rationals for declared constants, because
+	// constants that appear in an expression will already have
+	// been coerced to a concrete, fixed-precision type.
+	//
+	// Eventually, assuming we stick with using rationals, we
+	// should bump iexportVersion to support rationals, and do the
+	// whole gcimporter update song-and-dance.
+	//
+	// TODO(mdempsky): Prepare vocals for that.
+
+	switch n.Type() {
+	case types.UntypedFloat:
+		w.mprat(n.Val())
+	case types.UntypedComplex:
+		v := n.Val()
+		w.mprat(constant.Real(v))
+		w.mprat(constant.Imag(v))
+	}
+}
+
+func (w *exportWriter) varExt(n *ir.Name) {
 	w.linkname(n.Sym())
 	w.symIdx(n.Sym())
 }
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index f2682257f3..b73ef5176b 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -303,7 +303,9 @@ func (r *importReader) doDecl(sym *types.Sym) *ir.Name {
 		typ := r.typ()
 		val := r.value(typ)
 
-		return importconst(r.p.ipkg, pos, sym, typ, val)
+		n := importconst(r.p.ipkg, pos, sym, typ, val)
+		r.constExt(n)
+		return n
 
 	case 'F':
 		typ := r.signature(nil)
@@ -440,6 +442,15 @@ func (p *importReader) float(typ *types.Type) constant.Value {
 	return constant.Make(&f)
 }
 
+func (p *importReader) mprat(orig constant.Value) constant.Value {
+	if !p.bool() {
+		return orig
+	}
+	var rat big.Rat
+	rat.SetString(p.string())
+	return constant.Make(&rat)
+}
+
 func (r *importReader) ident(selector bool) *types.Sym {
 	name := r.string()
 	if name == "" {
@@ -641,7 +652,19 @@ func (r *importReader) byte() byte {
 
 // Compiler-specific extensions.
 
-func (r *importReader) varExt(n ir.Node) {
+func (r *importReader) constExt(n *ir.Name) {
+	switch n.Type() {
+	case types.UntypedFloat:
+		n.SetVal(r.mprat(n.Val()))
+	case types.UntypedComplex:
+		v := n.Val()
+		re := r.mprat(constant.Real(v))
+		im := r.mprat(constant.Imag(v))
+		n.SetVal(makeComplex(re, im))
+	}
+}
+
+func (r *importReader) varExt(n *ir.Name) {
 	r.linkname(n.Sym())
 	r.symIdx(n.Sym())
 }
diff --git a/test/fixedbugs/issue7740.go b/test/fixedbugs/issue7740.go
index 8f1afe86da..6bc6249d7e 100644
--- a/test/fixedbugs/issue7740.go
+++ b/test/fixedbugs/issue7740.go
@@ -21,7 +21,7 @@ func main() {
 	var prec float64
 	switch runtime.Compiler {
 	case "gc":
-		prec = 512
+		prec = math.Inf(1) // exact precision using rational arithmetic
 	case "gccgo":
 		prec = 256
 	default:
diff --git a/test/float_lit3.go b/test/float_lit3.go
index c4d1aa567c..850d02c9c7 100644
--- a/test/float_lit3.go
+++ b/test/float_lit3.go
@@ -37,12 +37,11 @@ var x = []interface{}{
 
 	// If the compiler's internal floating point representation
 	// is shorter than 1024 bits, it cannot distinguish max64+ulp64/2-1 and max64+ulp64/2.
-	// gc uses fewer than 1024 bits, so allow it to print the overflow error for the -1 case.
 	float64(max64 + ulp64/2 - two1024/two256), // ok
-	float64(max64 + ulp64/2 - 1),              // GC_ERROR "constant 1\.79769e\+308 overflows float64"
+	float64(max64 + ulp64/2 - 1),              // ok
 	float64(max64 + ulp64/2),                  // ERROR "constant 1\.79769e\+308 overflows float64"
 
 	float64(-max64 - ulp64/2 + two1024/two256), // ok
-	float64(-max64 - ulp64/2 + 1),              // GC_ERROR "constant -1\.79769e\+308 overflows float64"
+	float64(-max64 - ulp64/2 + 1),              // ok
 	float64(-max64 - ulp64/2),                  // ERROR "constant -1\.79769e\+308 overflows float64"
 }
-- 
GitLab


From cabffc199d6d71611c589fb21da27c61d683194d Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Thu, 21 Jan 2021 10:19:21 -0500
Subject: [PATCH 0562/2400] [dev.regabi] cmd/compile/internal: add internal ABI
 specification

This adds a document specifying the internal ABI (specifically the
calling convention). This document lives in the Go tree (rather than
the proposal repository) because the intent is for it to track the
reality in the compiler.

Updates #40724.

Change-Id: I583190080cd7d8cb1084f616fd1384d0f1f25725
Reviewed-on: https://go-review.googlesource.com/c/go/+/285292
Trust: Austin Clements <austin@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal-abi.md | 539 ++++++++++++++++++++++++++++++++
 1 file changed, 539 insertions(+)
 create mode 100644 src/cmd/compile/internal-abi.md

diff --git a/src/cmd/compile/internal-abi.md b/src/cmd/compile/internal-abi.md
new file mode 100644
index 0000000000..6f1fddd57a
--- /dev/null
+++ b/src/cmd/compile/internal-abi.md
@@ -0,0 +1,539 @@
+# Go internal ABI specification
+
+This document describes Go’s internal application binary interface
+(ABI), known as ABIInternal.
+This ABI is *unstable* and will change between Go versions.
+If you’re writing assembly code, please instead refer to Go’s
+[assembly documentation](/doc/asm.html), which describes Go’s stable
+ABI, known as ABI0.
+
+All functions defined in Go source follow ABIInternal.
+However, ABIInternal and ABI0 functions are able to call each other
+through transparent *ABI wrappers*, described in the [internal calling
+convention proposal](https://golang.org/design/27539-internal-abi).
+
+Go uses a common ABI design across all architectures.
+We first describe the common ABI, and then cover per-architecture
+specifics.
+
+*Rationale*: For the reasoning behind using a common ABI across
+architectures instead of the platform ABI, see the [register-based Go
+calling convention proposal](https://golang.org/design/40724-register-calling).
+
+## Argument and result passing
+
+Function calls pass arguments and results using a combination of the
+stack and machine registers.
+Each argument or result is passed either entirely in registers or
+entirely on the stack.
+Because access to registers is generally faster than access to the
+stack, arguments and results are preferentially passed in registers.
+However, any argument or result that contains a non-trivial array or
+does not fit entirely in the remaining available registers is passed
+on the stack.
+
+Each architecture defines a sequence of integer registers and a
+sequence of floating-point registers.
+At a high level, arguments and results are recursively broken down
+into values of base types and these base values are assigned to
+registers from these sequences.
+
+Arguments and results can share the same registers, but do not share
+the same stack space.
+Beyond the arguments and results passed on the stack, the caller also
+reserves spill space on the stack for all register-based arguments
+(but does not populate this space).
+
+The receiver, arguments, and results of function or method F are
+assigned to registers using the following algorithm:
+
+1. Start with the full integer and floating-point register sequences
+   and an empty stack frame.
+1. If F is a method, assign F’s receiver.
+1. For each argument A of F, assign A.
+1. Align the stack frame offset to the architecture’s pointer size.
+1. Reset to the full integer and floating-point register sequences
+   (but do not reset the stack frame).
+1. For each result R of F, assign R.
+1. Align the stack frame offset to the architecture’s pointer size.
+1. For each register-assigned receiver and argument of F, let T be its
+   type and stack-assign an empty value of type T.
+   This is the argument's (or receiver's) spill space.
+1. Align the stack frame offset to the architecture’s pointer size.
+
+Assigning a receiver, argument, or result V works as follows:
+
+1. Register-assign V.
+1. If step 1 failed, undo all register and stack assignments it
+   performed and stack-assign V.
+
+Register-assignment of a value V of underlying type T works as follows:
+
+1. If T is a boolean or integral type that fits in an integer
+   register, assign V to the next available integer register.
+1. If T is an integral type that fits in two integer registers, assign
+   the least significant and most significant halves of V to the next
+   two available integer registers, respectively.
+1. If T is a floating-point type and can be represented without loss
+   of precision in a floating-point register, assign V to the next
+   available floating-point register.
+1. If T is a complex type, recursively register-assign its real and
+   imaginary parts.
+1. If T is a pointer type, map type, channel type, or function type,
+   assign V to the next available integer register.
+1. If T is a string type, interface type, or slice type, recursively
+   register-assign V’s components (2 for strings and interfaces, 3 for
+   slices).
+1. If T is a struct type, recursively register-assign each field of V.
+1. If T is an array type of length 0, do nothing.
+1. If T is an array type of length 1, recursively register-assign its
+   one element.
+1. If T is an array type of length > 1, fail.
+1. If there is no available integer or floating-point register
+   available above, fail.
+1. If any recursive assignment above fails, this register-assign fails.
+
+Stack-assignment of a value V of underlying type T works as follows:
+
+1. Align the current stack frame offset to T’s alignment.
+1. Append V to the stack frame.
+
+(Note that any non-zero-sized struct type that ends in a zero-sized
+field is implicitly padded with 1 byte to prevent past-the-end
+pointers.
+This applies to all structs, not just those passed as arguments.)
+
+The following diagram shows what the resulting argument frame looks
+like on the stack:
+
+    +------------------------------+
+    |             . . .            |
+    | 2nd reg argument spill space |
+    | 1st reg argument spill space |
+    | <pointer-sized alignment>    |
+    |             . . .            |
+    | 2nd stack-assigned result    |
+    | 1st stack-assigned result    |
+    | <pointer-sized alignment>    |
+    |             . . .            |
+    | 2nd stack-assigned argument  |
+    | 1st stack-assigned argument  |
+    | stack-assigned receiver      |
+    +------------------------------+ ↓ lower addresses
+
+(Note that, while stack diagrams conventionally have address 0 at the
+bottom, if this were expressed as a Go struct the fields would appear
+in the opposite order, starting with the stack-assigned receiver.)
+
+To perform a call, the caller reserves space starting at the lowest
+address in its stack frame for the call stack frame, stores arguments
+in the registers and argument stack slots determined by the above
+algorithm, and performs the call.
+At the time of a call, spill slots, result stack slots, and result
+registers are assumed to be uninitialized.
+Upon return, the callee must have stored results to all result
+registers and result stack slots determined by the above algorithm.
+
+There are no callee-save registers, so a call may overwrite any
+register that doesn’t have a fixed meaning, including argument
+registers.
+
+### Example
+
+The function `func f(a1 uint8, a2 [2]uintptr, a3 uint8) (r1 struct { x
+uintptr; y [2]uintptr }, r2 string)` has the following argument frame
+layout on a 64-bit host with hypothetical integer registers R0–R9:
+
+    +-------------------+ 48
+    | alignment padding | 42
+    | a3 argument spill | 41
+    | a1 argument spill | 40
+    | r1 result         | 16
+    | a2 argument       | 0
+    +-------------------+
+    On entry: R0=a1, R1=a3
+    On exit:  R0=r2.base, R1=r2.len
+
+There are several things to note in this example.
+First, a2 and r1 are stack-assigned because they contain arrays.
+The other arguments and results are register-assigned.
+Result r2 is decomposed into its components, which are individually
+register-assigned.
+On the stack, the stack-assigned arguments appear below the
+stack-assigned results, which appear below the argument spill area.
+Only arguments, not results, are assigned a spill area.
+
+### Rationale
+
+Each base value is assigned to its own register to optimize
+construction and access.
+An alternative would be to pack multiple sub-word values into
+registers, or to simply map an argument's in-memory layout to
+registers (this is common in C ABIs), but this typically adds cost to
+pack and unpack these values.
+Modern architectures have more than enough registers to pass all
+arguments and results this way for nearly all functions (see the
+appendix), so there’s little downside to spreading base values across
+registers.
+
+Arguments that can’t be fully assigned to registers are passed
+entirely on the stack in case the callee takes the address of that
+argument.
+If an argument could be split across the stack and registers and the
+callee took its address, it would need to be reconstructed in memory,
+a process that would be proportional to the size of the argument.
+
+Non-trivial arrays are always passed on the stack because indexing
+into an array typically requires a computed offset, which generally
+isn’t possible with registers.
+Arrays in general are rare in function signatures (only 0.7% of
+functions in the Go 1.15 standard library and 0.2% in kubelet).
+We considered allowing array fields to be passed on the stack while
+the rest of an argument’s fields are passed in registers, but this
+creates the same problems as other large structs if the callee takes
+the address of an argument, and would benefit <0.1% of functions in
+kubelet (and even these very little).
+
+We make exceptions for 0 and 1-element arrays because these don’t
+require computed offsets, and 1-element arrays are already decomposed
+in the compiler’s SSA.
+
+The stack assignment algorithm above is equivalent to Go’s stack-based
+ABI0 calling convention if there are zero architecture registers.
+This is intended to ease the transition to the register-based internal
+ABI and make it easy for the compiler to generate either calling
+convention.
+An architecture may still define register meanings that aren’t
+compatible with ABI0, but these differences should be easy to account
+for in the compiler.
+
+The algorithm reserves spill space for arguments in the caller’s frame
+so that the compiler can generate a stack growth path that spills into
+this reserved space.
+If the callee has to grow the stack, it may not be able to reserve
+enough additional stack space in its own frame to spill these, which
+is why it’s important that the caller do so.
+These slots also act as the home location if these arguments need to
+be spilled for any other reason, which simplifies traceback printing.
+
+There are several options for how to lay out the argument spill space.
+We chose to lay out each argument in its type's usual memory layout
+but to separate the spill space from the regular argument space.
+Using the usual memory layout simplifies the compiler because it
+already understands this layout.
+Also, if a function takes the address of a register-assigned argument,
+the compiler must spill that argument to memory in its usual in-memory
+layout and it's more convenient to use the argument spill space for
+this purpose.
+
+Alternatively, the spill space could be structured around argument
+registers.
+In this approach, the stack growth spill path would spill each
+argument register to a register-sized stack word.
+However, if the function takes the address of a register-assigned
+argument, the compiler would have to reconstruct it in memory layout
+elsewhere on the stack.
+
+The spill space could also be interleaved with the stack-assigned
+arguments so the arguments appear in order whether they are register-
+or stack-assigned.
+This would be close to ABI0, except that register-assigned arguments
+would be uninitialized on the stack and there's no need to reserve
+stack space for register-assigned results.
+We expect separating the spill space to perform better because of
+memory locality.
+Separating the space is also potentially simpler for `reflect` calls
+because this allows `reflect` to summarize the spill space as a single
+number.
+Finally, the long-term intent is to remove reserved spill slots
+entirely – allowing most functions to be called without any stack
+setup and easing the introduction of callee-save registers – and
+separating the spill space makes that transition easier.
+
+## Closures
+
+A func value (e.g., `var x func()`) is a pointer to a closure object.
+A closure object begins with a pointer-sized program counter
+representing the entry point of the function, followed by zero or more
+bytes containing the closed-over environment.
+
+Closure calls follow the same conventions as static function and
+method calls, with one addition. Each architecture specifies a
+*closure context pointer* register and calls to closures store the
+address of the closure object in the closure context pointer register
+prior to the call.
+
+## Software floating-point mode
+
+In "softfloat" mode, the ABI simply treats the hardware as having zero
+floating-point registers.
+As a result, any arguments containing floating-point values will be
+passed on the stack.
+
+*Rationale*: Softfloat mode is about compatibility over performance
+and is not commonly used.
+Hence, we keep the ABI as simple as possible in this case, rather than
+adding additional rules for passing floating-point values in integer
+registers.
+
+## Architecture specifics
+
+This section describes per-architecture register mappings, as well as
+other per-architecture special cases.
+
+### amd64 architecture
+
+The amd64 architecture uses the following sequence of 9 registers for
+integer arguments and results:
+
+    RAX, RBX, RCX, RDI, RSI, R8, R9, R10, R11
+
+It uses X0 – X14 for floating-point arguments and results.
+
+*Rationale*: These sequences are chosen from the available registers
+to be relatively easy to remember.
+
+Registers R12 and R13 are permanent scratch registers.
+R15 is a scratch register except in dynamically linked binaries.
+
+*Rationale*: Some operations such as stack growth and reflection calls
+need dedicated scratch registers in order to manipulate call frames
+without corrupting arguments or results.
+
+Special-purpose registers are as follows:
+
+| Register | Call meaning | Body meaning |
+| --- | --- | --- |
+| RSP | Stack pointer | Fixed |
+| RBP | Frame pointer | Fixed |
+| RDX | Closure context pointer | Scratch |
+| R12 | None | Scratch |
+| R13 | None | Scratch |
+| R14 | Current goroutine | Scratch |
+| R15 | GOT reference temporary | Fixed if dynlink |
+| X15 | Zero value | Fixed |
+
+TODO: We may start with the existing TLS-based g and move to R14
+later.
+
+*Rationale*: These register meanings are compatible with Go’s
+stack-based calling convention except for R14 and X15, which will have
+to be restored on transitions from ABI0 code to ABIInternal code.
+In ABI0, these are undefined, so transitions from ABIInternal to ABI0
+can ignore these registers.
+
+*Rationale*: For the current goroutine pointer, we chose a register
+that requires an additional REX byte.
+While this adds one byte to every function prologue, it is hardly ever
+accessed outside the function prologue and we expect making more
+single-byte registers available to be a net win.
+
+*Rationale*: We designate X15 as a fixed zero register because
+functions often have to bulk zero their stack frames, and this is more
+efficient with a designated zero register.
+
+#### Stack layout
+
+The stack pointer, RSP, grows down and is always aligned to 8 bytes.
+
+The amd64 architecture does not use a link register.
+
+A function's stack frame is laid out as follows:
+
+    +------------------------------+
+    | return PC                    |
+    | RBP on entry                 |
+    | ... locals ...               |
+    | ... outgoing arguments ...   |
+    +------------------------------+ ↓ lower addresses
+
+The "return PC" is pushed as part of the standard amd64 `CALL`
+operation.
+On entry, a function subtracts from RSP to open its stack frame and
+saves the value of RBP directly below the return PC.
+A leaf function that does not require any stack space may omit the
+saved RBP.
+
+The Go ABI's use of RBP as a frame pointer register is compatible with
+amd64 platform conventions so that Go can inter-operate with platform
+debuggers and profilers.
+
+#### Flags
+
+The direction flag (D) is always cleared (set to the “forward”
+direction) at a call.
+The arithmetic status flags are treated like scratch registers and not
+preserved across calls.
+All other bits in RFLAGS are system flags.
+
+The CPU is always in MMX technology state (not x87 mode).
+
+*Rationale*: Go on amd64 uses the XMM registers and never uses the x87
+registers, so it makes sense to assume the CPU is in MMX mode.
+Otherwise, any function that used the XMM registers would have to
+execute an EMMS instruction before calling another function or
+returning (this is the case in the SysV ABI).
+
+At calls, the MXCSR control bits are always set as follows:
+
+| Flag | Bit | Value | Meaning |
+| --- | --- | --- | --- |
+| FZ | 15 | 0 | Do not flush to zero |
+| RC | 14/13 | 0 (RN) | Round to nearest |
+| PM | 12 | 1 | Precision masked |
+| UM | 11 | 1 | Underflow masked |
+| OM | 10 | 1 | Overflow masked |
+| ZM | 9 | 1 | Divide-by-zero masked |
+| DM | 8 | 1 | Denormal operations masked |
+| IM | 7 | 1 | Invalid operations masked |
+| DAZ | 6 | 0 | Do not zero de-normals |
+
+The MXCSR status bits are callee-save.
+
+*Rationale*: Having a fixed MXCSR control configuration allows Go
+functions to use SSE operations without modifying or saving the MXCSR.
+Functions are allowed to modify it between calls (as long as they
+restore it), but as of this writing Go code never does.
+The above fixed configuration matches the process initialization
+control bits specified by the ELF AMD64 ABI.
+
+The x87 floating-point control word is not used by Go on amd64.
+
+## Future directions
+
+### Spill path improvements
+
+The ABI currently reserves spill space for argument registers so the
+compiler can statically generate an argument spill path before calling
+into `runtime.morestack` to grow the stack.
+This ensures there will be sufficient spill space even when the stack
+is nearly exhausted and keeps stack growth and stack scanning
+essentially unchanged from ABI0.
+
+However, this wastes stack space (the median wastage is 16 bytes per
+call), resulting in larger stacks and increased cache footprint.
+A better approach would be to reserve stack space only when spilling.
+One way to ensure enough space is available to spill would be for
+every function to ensure there is enough space for the function's own
+frame *as well as* the spill space of all functions it calls.
+For most functions, this would change the threshold for the prologue
+stack growth check.
+For `nosplit` functions, this would change the threshold used in the
+linker's static stack size check.
+
+Allocating spill space in the callee rather than the caller may also
+allow for faster reflection calls in the common case where a function
+takes only register arguments, since it would allow reflection to make
+these calls directly without allocating any frame.
+
+The statically-generated spill path also increases code size.
+It is possible to instead have a generic spill path in the runtime, as
+part of `morestack`.
+However, this complicates reserving the spill space, since spilling
+all possible register arguments would, in most cases, take
+significantly more space than spilling only those used by a particular
+function.
+Some options are to spill to a temporary space and copy back only the
+registers used by the function, or to grow the stack if necessary
+before spilling to it (using a temporary space if necessary), or to
+use a heap-allocated space if insufficient stack space is available.
+These options all add enough complexity that we will have to make this
+decision based on the actual code size growth caused by the static
+spill paths.
+
+### Clobber sets
+
+As defined, the ABI does not use callee-save registers.
+This significantly simplifies the garbage collector and the compiler's
+register allocator, but at some performance cost.
+A potentially better balance for Go code would be to use *clobber
+sets*: for each function, the compiler records the set of registers it
+clobbers (including those clobbered by functions it calls) and any
+register not clobbered by function F can remain live across calls to
+F.
+
+This is generally a good fit for Go because Go's package DAG allows
+function metadata like the clobber set to flow up the call graph, even
+across package boundaries.
+Clobber sets would require relatively little change to the garbage
+collector, unlike general callee-save registers.
+One disadvantage of clobber sets over callee-save registers is that
+they don't help with indirect function calls or interface method
+calls, since static information isn't available in these cases.
+
+### Large aggregates
+
+Go encourages passing composite values by value, and this simplifies
+reasoning about mutation and races.
+However, this comes at a performance cost for large composite values.
+It may be possible to instead transparently pass large composite
+values by reference and delay copying until it is actually necessary.
+
+## Appendix: Register usage analysis
+
+In order to understand the impacts of the above design on register
+usage, we
+[analyzed](https://github.com/aclements/go-misc/tree/master/abi) the
+impact of the above ABI on a large code base: cmd/kubelet from
+[Kubernetes](https://github.com/kubernetes/kubernetes) at tag v1.18.8.
+
+The following table shows the impact of different numbers of available
+integer and floating-point registers on argument assignment:
+
+```
+|      |        |       |      stack args |          spills |     stack total |
+| ints | floats | % fit | p50 | p95 | p99 | p50 | p95 | p99 | p50 | p95 | p99 |
+|    0 |      0 |  6.3% |  32 | 152 | 256 |   0 |   0 |   0 |  32 | 152 | 256 |
+|    0 |      8 |  6.4% |  32 | 152 | 256 |   0 |   0 |   0 |  32 | 152 | 256 |
+|    1 |      8 | 21.3% |  24 | 144 | 248 |   8 |   8 |   8 |  32 | 152 | 256 |
+|    2 |      8 | 38.9% |  16 | 128 | 224 |   8 |  16 |  16 |  24 | 136 | 240 |
+|    3 |      8 | 57.0% |   0 | 120 | 224 |  16 |  24 |  24 |  24 | 136 | 240 |
+|    4 |      8 | 73.0% |   0 | 120 | 216 |  16 |  32 |  32 |  24 | 136 | 232 |
+|    5 |      8 | 83.3% |   0 | 112 | 216 |  16 |  40 |  40 |  24 | 136 | 232 |
+|    6 |      8 | 87.5% |   0 | 112 | 208 |  16 |  48 |  48 |  24 | 136 | 232 |
+|    7 |      8 | 89.8% |   0 | 112 | 208 |  16 |  48 |  56 |  24 | 136 | 232 |
+|    8 |      8 | 91.3% |   0 | 112 | 200 |  16 |  56 |  64 |  24 | 136 | 232 |
+|    9 |      8 | 92.1% |   0 | 112 | 192 |  16 |  56 |  72 |  24 | 136 | 232 |
+|   10 |      8 | 92.6% |   0 | 104 | 192 |  16 |  56 |  72 |  24 | 136 | 232 |
+|   11 |      8 | 93.1% |   0 | 104 | 184 |  16 |  56 |  80 |  24 | 128 | 232 |
+|   12 |      8 | 93.4% |   0 | 104 | 176 |  16 |  56 |  88 |  24 | 128 | 232 |
+|   13 |      8 | 94.0% |   0 |  88 | 176 |  16 |  56 |  96 |  24 | 128 | 232 |
+|   14 |      8 | 94.4% |   0 |  80 | 152 |  16 |  64 | 104 |  24 | 128 | 232 |
+|   15 |      8 | 94.6% |   0 |  80 | 152 |  16 |  64 | 112 |  24 | 128 | 232 |
+|   16 |      8 | 94.9% |   0 |  16 | 152 |  16 |  64 | 112 |  24 | 128 | 232 |
+|    ∞ |      8 | 99.8% |   0 |   0 |   0 |  24 | 112 | 216 |  24 | 120 | 216 |
+```
+
+The first two columns show the number of available integer and
+floating-point registers.
+The first row shows the results for 0 integer and 0 floating-point
+registers, which is equivalent to ABI0.
+We found that any reasonable number of floating-point registers has
+the same effect, so we fixed it at 8 for all other rows.
+
+The “% fit” column gives the fraction of functions where all arguments
+and results are register-assigned and no arguments are passed on the
+stack.
+The three “stack args” columns give the median, 95th and 99th
+percentile number of bytes of stack arguments.
+The “spills” columns likewise summarize the number of bytes in
+on-stack spill space.
+And “stack total” summarizes the sum of stack arguments and on-stack
+spill slots.
+Note that these are three different distributions; for example,
+there’s no single function that takes 0 stack argument bytes, 16 spill
+bytes, and 24 total stack bytes.
+
+From this, we can see that the fraction of functions that fit entirely
+in registers grows very slowly once it reaches about 90%, though
+curiously there is a small minority of functions that could benefit
+from a huge number of registers.
+Making 9 integer registers available on amd64 puts it in this realm.
+We also see that the stack space required for most functions is fairly
+small.
+While the increasing space required for spills largely balances out
+the decreasing space required for stack arguments as the number of
+available registers increases, there is a general reduction in the
+total stack space required with more available registers.
+This does, however, suggest that eliminating spill slots in the future
+would noticeably reduce stack requirements.
-- 
GitLab


From 6f5e79f470e8956e1c01cb93802d52aee5c307b5 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Sat, 23 Jan 2021 16:58:34 -0500
Subject: [PATCH 0563/2400] [dev.regabi] cmd/compile/internal: specify memory
 layout

This CL expands internal-abi.md to cover Go's memory layout rules and
then uses this to specify the calling convention more precisely.

Change-Id: Ifeef9e49d9ccc8c7333dec81bdd47b511b028469
Reviewed-on: https://go-review.googlesource.com/c/go/+/286073
Trust: Austin Clements <austin@google.com>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal-abi.md | 223 ++++++++++++++++++++++----------
 1 file changed, 156 insertions(+), 67 deletions(-)

diff --git a/src/cmd/compile/internal-abi.md b/src/cmd/compile/internal-abi.md
index 6f1fddd57a..f4ef2cc869 100644
--- a/src/cmd/compile/internal-abi.md
+++ b/src/cmd/compile/internal-abi.md
@@ -2,6 +2,8 @@
 
 This document describes Go’s internal application binary interface
 (ABI), known as ABIInternal.
+Go's ABI defines the layout of data in memory and the conventions for
+calling between Go functions.
 This ABI is *unstable* and will change between Go versions.
 If you’re writing assembly code, please instead refer to Go’s
 [assembly documentation](/doc/asm.html), which describes Go’s stable
@@ -20,7 +22,89 @@ specifics.
 architectures instead of the platform ABI, see the [register-based Go
 calling convention proposal](https://golang.org/design/40724-register-calling).
 
-## Argument and result passing
+## Memory layout
+
+Go's built-in types have the following sizes and alignments.
+Many, though not all, of these sizes are guaranteed by the [language
+specification](/doc/go_spec.html#Size_and_alignment_guarantees).
+Those that aren't guaranteed may change in future versions of Go (for
+example, we've considered changing the alignment of int64 on 32-bit).
+
+| Type | 64-bit |       | 32-bit |       |
+| ---  | ---    | ---   | ---    | ---   |
+|      | Size   | Align | Size   | Align |
+| bool, uint8, int8  | 1  | 1 | 1  | 1 |
+| uint16, int16      | 2  | 2 | 2  | 2 |
+| uint32, int32      | 4  | 4 | 4  | 4 |
+| uint64, int64      | 8  | 8 | 8  | 4 |
+| int, uint          | 8  | 8 | 4  | 4 |
+| float32            | 4  | 4 | 4  | 4 |
+| float64            | 8  | 8 | 8  | 4 |
+| complex64          | 8  | 4 | 8  | 4 |
+| complex128         | 16 | 8 | 16 | 4 |
+| uintptr, *T, unsafe.Pointer | 8 | 8 | 4 | 4 |
+
+The types `byte` and `rune` are aliases for `uint8` and `int32`,
+respectively, and hence have the same size and alignment as these
+types.
+
+The layout of `map`, `chan`, and `func` types is equivalent to *T.
+
+To describe the layout of the remaining composite types, we first
+define the layout of a *sequence* S of N fields with types
+t<sub>1</sub>, t<sub>2</sub>, ..., t<sub>N</sub>.
+We define the byte offset at which each field begins relative to a
+base address of 0, as well as the size and alignment of the sequence
+as follows:
+
+```
+offset(S, i) = 0  if i = 1
+             = align(offset(S, i-1) + sizeof(t_(i-1)), alignof(t_i))
+alignof(S)   = 1  if N = 0
+             = max(alignof(t_i) | 1 <= i <= N)
+sizeof(S)    = 0  if N = 0
+             = align(offset(S, N) + sizeof(t_N), alignof(S))
+```
+
+Where sizeof(T) and alignof(T) are the size and alignment of type T,
+respectively, and align(x, y) rounds x up to a multiple of y.
+
+The `interface{}` type is a sequence of 1. a pointer to the runtime type
+description for the interface's dynamic type and 2. an `unsafe.Pointer`
+data field.
+Any other interface type (besides the empty interface) is a sequence
+of 1. a pointer to the runtime "itab" that gives the method pointers and
+the type of the data field and 2. an `unsafe.Pointer` data field.
+An interface can be "direct" or "indirect" depending on the dynamic
+type: a direct interface stores the value directly in the data field,
+and an indirect interface stores a pointer to the value in the data
+field.
+An interface can only be direct if the value consists of a single
+pointer word.
+
+An array type `[N]T` is a sequence of N fields of type T.
+
+The slice type `[]T` is a sequence of a `*[cap]T` pointer to the slice
+backing store, an `int` giving the `len` of the slice, and an `int`
+giving the `cap` of the slice.
+
+The `string` type is a sequence of a `*[len]byte` pointer to the
+string backing store, and an `int` giving the `len` of the string.
+
+A struct type `struct { f1 t1; ...; fM tM }` is laid out as the
+sequence t1, ..., tM, tP, where tP is either:
+
+- Type `byte` if sizeof(tM) = 0 and any of sizeof(t*i*) ≠ 0.
+- Empty (size 0 and align 1) otherwise.
+
+The padding byte prevents creating a past-the-end pointer by taking
+the address of the final, empty fN field.
+
+Note that user-written assembly code should generally not depend on Go
+type layout and should instead use the constants defined in
+[`go_asm.h`](/doc/asm.html#data-offsets).
+
+## Function call argument and result passing
 
 Function calls pass arguments and results using a combination of the
 stack and machine registers.
@@ -45,42 +129,48 @@ reserves spill space on the stack for all register-based arguments
 (but does not populate this space).
 
 The receiver, arguments, and results of function or method F are
-assigned to registers using the following algorithm:
+assigned to registers or the stack using the following algorithm:
 
-1. Start with the full integer and floating-point register sequences
-   and an empty stack frame.
+1. Let NI and NFP be the length of integer and floating-point register
+   sequences defined by the architecture.
+   Let I and FP be 0; these are the indexes of the next integer and
+   floating-pointer register.
+   Let S, the type sequence defining the stack frame, be empty.
 1. If F is a method, assign F’s receiver.
 1. For each argument A of F, assign A.
-1. Align the stack frame offset to the architecture’s pointer size.
-1. Reset to the full integer and floating-point register sequences
-   (but do not reset the stack frame).
+1. Add a pointer-alignment field to S. This has size 0 and the same
+   alignment as `uintptr`.
+1. Reset I and FP to 0.
 1. For each result R of F, assign R.
-1. Align the stack frame offset to the architecture’s pointer size.
+1. Add a pointer-alignment field to S.
 1. For each register-assigned receiver and argument of F, let T be its
-   type and stack-assign an empty value of type T.
-   This is the argument's (or receiver's) spill space.
-1. Align the stack frame offset to the architecture’s pointer size.
+   type and add T to the stack sequence S.
+   This is the argument's (or receiver's) spill space and will be
+   uninitialized at the call.
+1. Add a pointer-alignment field to S.
 
-Assigning a receiver, argument, or result V works as follows:
+Assigning a receiver, argument, or result V of underlying type T works
+as follows:
 
-1. Register-assign V.
-1. If step 1 failed, undo all register and stack assignments it
-   performed and stack-assign V.
+1. Remember I and FP.
+1. Try to register-assign V.
+1. If step 2 failed, reset I and FP to the values from step 1, add T
+   to the stack sequence S, and assign V to this field in S.
 
 Register-assignment of a value V of underlying type T works as follows:
 
 1. If T is a boolean or integral type that fits in an integer
-   register, assign V to the next available integer register.
+   register, assign V to register I and increment I.
 1. If T is an integral type that fits in two integer registers, assign
-   the least significant and most significant halves of V to the next
-   two available integer registers, respectively.
+   the least significant and most significant halves of V to registers
+   I and I+1, respectively, and increment I by 2
 1. If T is a floating-point type and can be represented without loss
-   of precision in a floating-point register, assign V to the next
-   available floating-point register.
+   of precision in a floating-point register, assign V to register FP
+   and increment FP.
 1. If T is a complex type, recursively register-assign its real and
    imaginary parts.
 1. If T is a pointer type, map type, channel type, or function type,
-   assign V to the next available integer register.
+   assign V to register I and increment I.
 1. If T is a string type, interface type, or slice type, recursively
    register-assign V’s components (2 for strings and interfaces, 3 for
    slices).
@@ -89,22 +179,17 @@ Register-assignment of a value V of underlying type T works as follows:
 1. If T is an array type of length 1, recursively register-assign its
    one element.
 1. If T is an array type of length > 1, fail.
-1. If there is no available integer or floating-point register
-   available above, fail.
-1. If any recursive assignment above fails, this register-assign fails.
-
-Stack-assignment of a value V of underlying type T works as follows:
-
-1. Align the current stack frame offset to T’s alignment.
-1. Append V to the stack frame.
-
-(Note that any non-zero-sized struct type that ends in a zero-sized
-field is implicitly padded with 1 byte to prevent past-the-end
-pointers.
-This applies to all structs, not just those passed as arguments.)
-
-The following diagram shows what the resulting argument frame looks
-like on the stack:
+1. If I > NI or FP > NFP, fail.
+1. If any recursive assignment above fails, fail.
+
+The above algorithm produces an assignment of each receiver, argument,
+and result to registers or to a field in the stack sequence.
+The final stack sequence looks like: stack-assigned receiver,
+stack-assigned arguments, pointer-alignment, stack-assigned results,
+pointer-alignment, spill space for each register-assigned argument,
+pointer-alignment.
+The following diagram shows what this stack frame looks like on the
+stack, using the typical convention where address 0 is at the bottom:
 
     +------------------------------+
     |             . . .            |
@@ -121,18 +206,14 @@ like on the stack:
     | stack-assigned receiver      |
     +------------------------------+ ↓ lower addresses
 
-(Note that, while stack diagrams conventionally have address 0 at the
-bottom, if this were expressed as a Go struct the fields would appear
-in the opposite order, starting with the stack-assigned receiver.)
-
 To perform a call, the caller reserves space starting at the lowest
 address in its stack frame for the call stack frame, stores arguments
-in the registers and argument stack slots determined by the above
+in the registers and argument stack fields determined by the above
 algorithm, and performs the call.
-At the time of a call, spill slots, result stack slots, and result
-registers are assumed to be uninitialized.
+At the time of a call, spill space, result stack fields, and result
+registers are left uninitialized.
 Upon return, the callee must have stored results to all result
-registers and result stack slots determined by the above algorithm.
+registers and result stack fields determined by the above algorithm.
 
 There are no callee-save registers, so a call may overwrite any
 register that doesn’t have a fixed meaning, including argument
@@ -140,28 +221,35 @@ registers.
 
 ### Example
 
-The function `func f(a1 uint8, a2 [2]uintptr, a3 uint8) (r1 struct { x
-uintptr; y [2]uintptr }, r2 string)` has the following argument frame
-layout on a 64-bit host with hypothetical integer registers R0–R9:
+Consider the function `func f(a1 uint8, a2 [2]uintptr, a3 uint8) (r1
+struct { x uintptr; y [2]uintptr }, r2 string)` on a 64-bit
+architecture with hypothetical integer registers R0–R9.
+
+On entry, `a1` is assigned to `R0`, `a3` is assigned to `R1` and the
+stack frame is laid out in the following sequence:
+
+    a2      [2]uintptr
+    r1.x    uintptr
+    r1.y    [2]uintptr
+    a1Spill uint8
+    a2Spill uint8
+    _       [6]uint8  // alignment padding
+
+In the stack frame, only the `a2` field is initialized on entry; the
+rest of the frame is left uninitialized.
 
-    +-------------------+ 48
-    | alignment padding | 42
-    | a3 argument spill | 41
-    | a1 argument spill | 40
-    | r1 result         | 16
-    | a2 argument       | 0
-    +-------------------+
-    On entry: R0=a1, R1=a3
-    On exit:  R0=r2.base, R1=r2.len
+On exit, `r2.base` is assigned to `R0`, `r2.len` is assigned to `R1`,
+and `r1.x` and `r1.y` are initialized in the stack frame.
 
 There are several things to note in this example.
-First, a2 and r1 are stack-assigned because they contain arrays.
+First, `a2` and `r1` are stack-assigned because they contain arrays.
 The other arguments and results are register-assigned.
-Result r2 is decomposed into its components, which are individually
+Result `r2` is decomposed into its components, which are individually
 register-assigned.
-On the stack, the stack-assigned arguments appear below the
-stack-assigned results, which appear below the argument spill area.
-Only arguments, not results, are assigned a spill area.
+On the stack, the stack-assigned arguments appear at lower addresses
+than the stack-assigned results, which appear at lower addresses than
+the argument spill area.
+Only arguments, not results, are assigned a spill area on the stack.
 
 ### Rationale
 
@@ -196,9 +284,9 @@ kubelet (and even these very little).
 
 We make exceptions for 0 and 1-element arrays because these don’t
 require computed offsets, and 1-element arrays are already decomposed
-in the compiler’s SSA.
+in the compiler’s SSA representation.
 
-The stack assignment algorithm above is equivalent to Go’s stack-based
+The ABI assignment algorithm above is equivalent to Go’s stack-based
 ABI0 calling convention if there are zero architecture registers.
 This is intended to ease the transition to the register-based internal
 ABI and make it easy for the compiler to generate either calling
@@ -217,12 +305,13 @@ These slots also act as the home location if these arguments need to
 be spilled for any other reason, which simplifies traceback printing.
 
 There are several options for how to lay out the argument spill space.
-We chose to lay out each argument in its type's usual memory layout
-but to separate the spill space from the regular argument space.
+We chose to lay out each argument according to its type's usual memory
+layout but to separate the spill space from the regular argument
+space.
 Using the usual memory layout simplifies the compiler because it
 already understands this layout.
 Also, if a function takes the address of a register-assigned argument,
-the compiler must spill that argument to memory in its usual in-memory
+the compiler must spill that argument to memory in its usual memory
 layout and it's more convenient to use the argument spill space for
 this purpose.
 
-- 
GitLab


From 7eaaf28caee0442f2376735ac28de252c7f4baae Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 25 Jan 2021 14:14:10 -0800
Subject: [PATCH 0564/2400] [dev.regabi] cmd/compile: disallow taking address
 of SSA'd values

Adds some extra validation that the frontend is setting flags like
Addrtaken correctly.

Change-Id: Iffde83e32ba1c4c917ab8cb3fe410a4f623cf635
Reviewed-on: https://go-review.googlesource.com/c/go/+/286434
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/ssagen/ssa.go | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index ecf3294082..e49a9716fe 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -434,6 +434,7 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 		// bitmask showing which of the open-coded defers in this function
 		// have been activated.
 		deferBitsTemp := typecheck.TempAt(src.NoXPos, s.curfn, types.Types[types.TUINT8])
+		deferBitsTemp.SetAddrtaken(true)
 		s.deferBitsTemp = deferBitsTemp
 		// For this value, AuxInt is initialized to zero by default
 		startDeferBits := s.entryNewValue0(ssa.OpConst8, types.Types[types.TUINT8])
@@ -5086,6 +5087,10 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 		defer s.popLine()
 	}
 
+	if s.canSSA(n) {
+		s.Fatalf("addr of canSSA expression: %+v", n)
+	}
+
 	t := types.NewPtr(n.Type())
 	linksymOffset := func(lsym *obj.LSym, offset int64) *ssa.Value {
 		v := s.entryNewValue1A(ssa.OpAddr, t, lsym, s.sb)
-- 
GitLab


From 3663a437a781f4e7ce242aa334af2f2ce71ecef9 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 25 Jan 2021 15:18:56 -0800
Subject: [PATCH 0565/2400] [dev.typeparams] go/constant: in ToFloat, convert
 to rational numbers, not floats

Floating-point constants are represented as rational numbers when
possible (i.e., when numerators and denominators are not too large).
If we convert to floats when not necessary, we risk losing precision.

This is the minimal fix for the specific issue, but it's too aggressive:
If the numbers are too large, we still want to convert to floats.
Will address in a separate CL that also does a few related cleanups.

Fixes #43908.

Change-Id: Id575e34fa18361a347c43701cfb4dd7221997f66
Reviewed-on: https://go-review.googlesource.com/c/go/+/286552
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/go/constant/value.go     |  4 ++--
 test/fixedbugs/issue43908.go | 21 +++++++++++++++++++++
 2 files changed, 23 insertions(+), 2 deletions(-)
 create mode 100644 test/fixedbugs/issue43908.go

diff --git a/src/go/constant/value.go b/src/go/constant/value.go
index 223c363d9b..2ed6115d1b 100644
--- a/src/go/constant/value.go
+++ b/src/go/constant/value.go
@@ -871,9 +871,9 @@ func ToInt(x Value) Value {
 func ToFloat(x Value) Value {
 	switch x := x.(type) {
 	case int64Val:
-		return i64tof(x)
+		return i64tor(x)
 	case intVal:
-		return itof(x)
+		return itor(x)
 	case ratVal, floatVal:
 		return x
 	case complexVal:
diff --git a/test/fixedbugs/issue43908.go b/test/fixedbugs/issue43908.go
new file mode 100644
index 0000000000..47709eb191
--- /dev/null
+++ b/test/fixedbugs/issue43908.go
@@ -0,0 +1,21 @@
+// run
+
+// Copyright 2021 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.
+
+// Verify exact constant evaluation independent of
+// (mathematically equivalent) expression form.
+
+package main
+
+import "fmt"
+
+const ulp1 = imag(1i + 2i / 3 - 5i / 3)
+const ulp2 = imag(1i + complex(0, 2) / 3 - 5i / 3)
+
+func main() {
+	if ulp1 != ulp2 {
+		panic(fmt.Sprintf("%g != %g\n", ulp1, ulp2))
+	}
+}
-- 
GitLab


From c97af0036b8cd8ab2a7ed3f68c3ba72968637e4d Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 25 Jan 2021 17:26:07 -0800
Subject: [PATCH 0566/2400] [dev.typeparams] cmd/compile: force untyped
 constants from types2 to expected kind

Currently, types2 sometimes produces constant.Values with a Kind
different than the untyped constant type's Is{Integer,Float,Complex}
info, which irgen expects to always match.

While we mull how best to proceed in #43891, this CL adapts irgen to
types2's current behavior. In particular, fixedbugs/issue11945.go now
passes with -G=3.

Updates #43891.

Change-Id: I24823a32ff49af6045a032d3903dbb55cbec6bef
Reviewed-on: https://go-review.googlesource.com/c/go/+/286652
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/decl.go | 19 ++++++++++++++++++-
 test/fixedbugs/issue11945.go           |  4 ++++
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/noder/decl.go b/src/cmd/compile/internal/noder/decl.go
index c41b77c100..9862f452fd 100644
--- a/src/cmd/compile/internal/noder/decl.go
+++ b/src/cmd/compile/internal/noder/decl.go
@@ -5,6 +5,8 @@
 package noder
 
 import (
+	"go/constant"
+
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/syntax"
@@ -58,7 +60,22 @@ func (g *irgen) constDecl(out *ir.Nodes, decl *syntax.ConstDecl) {
 
 	for _, name := range decl.NameList {
 		name, obj := g.def(name)
-		name.SetVal(obj.(*types2.Const).Val())
+
+		// For untyped numeric constants, make sure the value
+		// representation matches what the rest of the
+		// compiler (really just iexport) expects.
+		// TODO(mdempsky): Revisit after #43891 is resolved.
+		val := obj.(*types2.Const).Val()
+		switch name.Type() {
+		case types.UntypedInt, types.UntypedRune:
+			val = constant.ToInt(val)
+		case types.UntypedFloat:
+			val = constant.ToFloat(val)
+		case types.UntypedComplex:
+			val = constant.ToComplex(val)
+		}
+		name.SetVal(val)
+
 		out.Append(ir.NewDecl(g.pos(decl), ir.ODCLCONST, name))
 	}
 }
diff --git a/test/fixedbugs/issue11945.go b/test/fixedbugs/issue11945.go
index 510b6555c6..218d07a693 100644
--- a/test/fixedbugs/issue11945.go
+++ b/test/fixedbugs/issue11945.go
@@ -13,6 +13,10 @@ const (
 	_ = real(0) // from bug report
 	_ = imag(0) // from bug report
 
+	// same as above, but exported for #43891
+	Real0 = real(0)
+	Imag0 = imag(0)
+
 	// if the arguments are untyped, the results must be untyped
 	// (and compatible with types that can represent the values)
 	_ int = real(1)
-- 
GitLab


From d39685e5e954aadcfca6ec3cf784d4af20fcae5d Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 25 Jan 2021 15:39:37 -0800
Subject: [PATCH 0567/2400] [dev.typeparams] go/constant: choose internal float
 representations more consistently

go/constant represents a Float constant either as a rational number
(if numerator and denominator are small enough), or, as a "catch-all",
as a arbitrary-precision floating-point number.

This CL cleans up some of these transitions by factoring out more
of the decision logic and documents the rationale between the state
transitions better.

This CL also simplifies some unrelated code that was overly complex.

Updates #43908.

Change-Id: Iccdd2d6b7fb7ed13d68ed5e6d992d1bc56a065bb
Reviewed-on: https://go-review.googlesource.com/c/go/+/286572
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/go/constant/value.go | 97 ++++++++++++++++++++++++----------------
 1 file changed, 59 insertions(+), 38 deletions(-)

diff --git a/src/go/constant/value.go b/src/go/constant/value.go
index 2ed6115d1b..8ee7620609 100644
--- a/src/go/constant/value.go
+++ b/src/go/constant/value.go
@@ -72,6 +72,17 @@ const prec = 512
 //           too large (incl. infinity), that could be recorded in unknownVal.
 //           See also #20583 and #42695 for use cases.
 
+// Representation of values:
+//
+// Values of Int and Float Kind have two different representations each: int64Val
+// and intVal, and ratVal and floatVal. When possible, the "smaller", respectively
+// more precise (for Floats) representation is chosen. However, once a Float value
+// is represented as a floatVal, any subsequent results remain floatVals (unless
+// explicitly converted); i.e., no attempt is made to convert a floatVal back into
+// a ratVal. The reasoning is that all representations but floatVal are mathematically
+// exact, but once that precision is lost (by moving to floatVal), moving back to
+// a different representation implies a precision that's not actually there.
+
 type (
 	unknownVal struct{}
 	boolVal    bool
@@ -263,14 +274,8 @@ func i64tor(x int64Val) ratVal   { return ratVal{newRat().SetInt64(int64(x))} }
 func i64tof(x int64Val) floatVal { return floatVal{newFloat().SetInt64(int64(x))} }
 func itor(x intVal) ratVal       { return ratVal{newRat().SetInt(x.val)} }
 func itof(x intVal) floatVal     { return floatVal{newFloat().SetInt(x.val)} }
-
-func rtof(x ratVal) floatVal {
-	a := newFloat().SetInt(x.val.Num())
-	b := newFloat().SetInt(x.val.Denom())
-	return floatVal{a.Quo(a, b)}
-}
-
-func vtoc(x Value) complexVal { return complexVal{x, int64Val(0)} }
+func rtof(x ratVal) floatVal     { return floatVal{newFloat().SetRat(x.val)} }
+func vtoc(x Value) complexVal    { return complexVal{x, int64Val(0)} }
 
 func makeInt(x *big.Int) Value {
 	if x.IsInt64() {
@@ -279,21 +284,15 @@ func makeInt(x *big.Int) Value {
 	return intVal{x}
 }
 
-// Permit fractions with component sizes up to maxExp
-// before switching to using floating-point numbers.
-const maxExp = 4 << 10
-
 func makeRat(x *big.Rat) Value {
 	a := x.Num()
 	b := x.Denom()
-	if a.BitLen() < maxExp && b.BitLen() < maxExp {
+	if smallInt(a) && smallInt(b) {
 		// ok to remain fraction
 		return ratVal{x}
 	}
 	// components too large => switch to float
-	fa := newFloat().SetInt(a)
-	fb := newFloat().SetInt(b)
-	return floatVal{fa.Quo(fa, fb)}
+	return floatVal{newFloat().SetRat(x)}
 }
 
 var floatVal0 = floatVal{newFloat()}
@@ -306,6 +305,9 @@ func makeFloat(x *big.Float) Value {
 	if x.IsInf() {
 		return unknownVal{}
 	}
+	// No attempt is made to "go back" to ratVal, even if possible,
+	// to avoid providing the illusion of a mathematically exact
+	// representation.
 	return floatVal{x}
 }
 
@@ -318,7 +320,7 @@ func makeComplex(re, im Value) Value {
 
 func makeFloatFromLiteral(lit string) Value {
 	if f, ok := newFloat().SetString(lit); ok {
-		if smallRat(f) {
+		if smallFloat(f) {
 			// ok to use rationals
 			if f.Sign() == 0 {
 				// Issue 20228: If the float underflowed to zero, parse just "0".
@@ -337,14 +339,34 @@ func makeFloatFromLiteral(lit string) Value {
 	return nil
 }
 
-// smallRat reports whether x would lead to "reasonably"-sized fraction
+// Permit fractions with component sizes up to maxExp
+// before switching to using floating-point numbers.
+const maxExp = 4 << 10
+
+// smallInt reports whether x would lead to "reasonably"-sized fraction
+// if converted to a *big.Rat.
+func smallInt(x *big.Int) bool {
+	return x.BitLen() < maxExp
+}
+
+// smallFloat64 reports whether x would lead to "reasonably"-sized fraction
 // if converted to a *big.Rat.
-func smallRat(x *big.Float) bool {
-	if !x.IsInf() {
-		e := x.MantExp(nil)
-		return -maxExp < e && e < maxExp
+func smallFloat64(x float64) bool {
+	if math.IsInf(x, 0) {
+		return false
+	}
+	_, e := math.Frexp(x)
+	return -maxExp < e && e < maxExp
+}
+
+// smallFloat reports whether x would lead to "reasonably"-sized fraction
+// if converted to a *big.Rat.
+func smallFloat(x *big.Float) bool {
+	if x.IsInf() {
+		return false
 	}
-	return false
+	e := x.MantExp(nil)
+	return -maxExp < e && e < maxExp
 }
 
 // ----------------------------------------------------------------------------
@@ -377,7 +399,10 @@ func MakeFloat64(x float64) Value {
 	if math.IsInf(x, 0) || math.IsNaN(x) {
 		return unknownVal{}
 	}
-	return ratVal{newRat().SetFloat64(x + 0)} // convert -0 to 0
+	if smallFloat64(x) {
+		return ratVal{newRat().SetFloat64(x + 0)} // convert -0 to 0
+	}
+	return floatVal{newFloat().SetFloat64(x + 0)}
 }
 
 // MakeFromLiteral returns the corresponding integer, floating-point,
@@ -733,7 +758,7 @@ func Num(x Value) Value {
 	case ratVal:
 		return makeInt(x.val.Num())
 	case floatVal:
-		if smallRat(x.val) {
+		if smallFloat(x.val) {
 			r, _ := x.val.Rat(nil)
 			return makeInt(r.Num())
 		}
@@ -755,7 +780,7 @@ func Denom(x Value) Value {
 	case ratVal:
 		return makeInt(x.val.Denom())
 	case floatVal:
-		if smallRat(x.val) {
+		if smallFloat(x.val) {
 			r, _ := x.val.Rat(nil)
 			return makeInt(r.Denom())
 		}
@@ -828,7 +853,7 @@ func ToInt(x Value) Value {
 		// avoid creation of huge integers
 		// (Existing tests require permitting exponents of at least 1024;
 		// allow any value that would also be permissible as a fraction.)
-		if smallRat(x.val) {
+		if smallFloat(x.val) {
 			i := newInt()
 			if _, acc := x.val.Int(i); acc == big.Exact {
 				return makeInt(i)
@@ -871,14 +896,16 @@ func ToInt(x Value) Value {
 func ToFloat(x Value) Value {
 	switch x := x.(type) {
 	case int64Val:
-		return i64tor(x)
+		return i64tor(x) // x is always a small int
 	case intVal:
-		return itor(x)
+		if smallInt(x.val) {
+			return itor(x)
+		}
+		return itof(x)
 	case ratVal, floatVal:
 		return x
 	case complexVal:
-		if im := ToInt(x.im); im.Kind() == Int && Sign(im) == 0 {
-			// imaginary component is 0
+		if Sign(x.im) == 0 {
 			return ToFloat(x.re)
 		}
 	}
@@ -889,13 +916,7 @@ func ToFloat(x Value) Value {
 // Otherwise it returns an Unknown.
 func ToComplex(x Value) Value {
 	switch x := x.(type) {
-	case int64Val:
-		return vtoc(i64tof(x))
-	case intVal:
-		return vtoc(itof(x))
-	case ratVal:
-		return vtoc(x)
-	case floatVal:
+	case int64Val, intVal, ratVal, floatVal:
 		return vtoc(x)
 	case complexVal:
 		return x
-- 
GitLab


From e48d7d3b21d39f8cf82e7e2547bd9ce47df68dde Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 25 Jan 2021 18:04:55 -0800
Subject: [PATCH 0568/2400] [dev.typeparams] go/constant: faster match
 implementation

Shortcut matching code if both operands have the same representation.

Change-Id: I9433455acb5b9d0b88d3c81eb1b3b0ae258193e7
Reviewed-on: https://go-review.googlesource.com/c/go/+/286654
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/go/constant/value.go | 67 +++++++++++++++-------------------------
 1 file changed, 25 insertions(+), 42 deletions(-)

diff --git a/src/go/constant/value.go b/src/go/constant/value.go
index 8ee7620609..78cb3f896f 100644
--- a/src/go/constant/value.go
+++ b/src/go/constant/value.go
@@ -1035,62 +1035,45 @@ func ord(x Value) int {
 // or invalid (say, nil) both results are that value.
 //
 func match(x, y Value) (_, _ Value) {
-	if ord(x) > ord(y) {
-		y, x = match(y, x)
-		return x, y
+	switch ox, oy := ord(x), ord(y); {
+	case ox < oy:
+		x, y = match0(x, y)
+	case ox > oy:
+		y, x = match0(y, x)
 	}
-	// ord(x) <= ord(y)
+	return x, y
+}
 
+// match0 must only be called by match.
+// Invariant: ord(x) < ord(y)
+func match0(x, y Value) (_, _ Value) {
 	// Prefer to return the original x and y arguments when possible,
 	// to avoid unnecessary heap allocations.
 
-	switch x1 := x.(type) {
-	case boolVal, *stringVal, complexVal:
-		return x, y
-
-	case int64Val:
-		switch y.(type) {
+	switch y.(type) {
+	case intVal:
+		switch x1 := x.(type) {
 		case int64Val:
-			return x, y
-		case intVal:
 			return i64toi(x1), y
-		case ratVal:
-			return i64tor(x1), y
-		case floatVal:
-			return i64tof(x1), y
-		case complexVal:
-			return vtoc(x1), y
 		}
-
-	case intVal:
-		switch y.(type) {
+	case ratVal:
+		switch x1 := x.(type) {
+		case int64Val:
+			return i64tor(x1), y
 		case intVal:
-			return x, y
-		case ratVal:
 			return itor(x1), y
-		case floatVal:
-			return itof(x1), y
-		case complexVal:
-			return vtoc(x1), y
 		}
-
-	case ratVal:
-		switch y.(type) {
+	case floatVal:
+		switch x1 := x.(type) {
+		case int64Val:
+			return i64tof(x1), y
+		case intVal:
+			return itof(x1), y
 		case ratVal:
-			return x, y
-		case floatVal:
 			return rtof(x1), y
-		case complexVal:
-			return vtoc(x1), y
-		}
-
-	case floatVal:
-		switch y.(type) {
-		case floatVal:
-			return x, y
-		case complexVal:
-			return vtoc(x1), y
 		}
+	case complexVal:
+		return vtoc(x), y
 	}
 
 	// force unknown and invalid values into "x position" in callers of match
-- 
GitLab


From cecc1dfcba15a06a06a7f3ea79e809e95c166c25 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 25 Jan 2021 21:37:56 -0800
Subject: [PATCH 0569/2400] [dev.typeparams] test: enable excluded test
 fixedbugs/issue7742.go

The test is fine and probably was excluded by mistake.

Change-Id: I98508e603afe01a781ad7c8638830514aa75939c
Reviewed-on: https://go-review.googlesource.com/c/go/+/286732
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 test/run.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/run.go b/test/run.go
index 1b0062da24..a1c68494c3 100644
--- a/test/run.go
+++ b/test/run.go
@@ -1985,6 +1985,5 @@ var excluded = map[string]bool{
 	"fixedbugs/issue7525c.go":  true, // types2 reports init cycle error on different line - ok otherwise
 	"fixedbugs/issue7525d.go":  true, // types2 reports init cycle error on different line - ok otherwise
 	"fixedbugs/issue7525e.go":  true, // types2 reports init cycle error on different line - ok otherwise
-	"fixedbugs/issue7742.go":   true, // types2 type-checking doesn't terminate
 	"fixedbugs/issue7746.go":   true, // types2 type-checking doesn't terminate
 }
-- 
GitLab


From 08a598f8c1c123fda3b7ad30659fa05a8be1ccde Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Sun, 24 Jan 2021 09:59:20 -0800
Subject: [PATCH 0570/2400] [dev.typeparams] cmd/compile: fix MethodExpr
 handling with embedded fields

The recent refactoring of SelectorExpr code to helpers broke the
handling of MethodExprs when there is an embedded field involved (e.g.
test/method7.go, line 48). If there is an embedded field involved, the
node op seen in DotMethod() is an ODOT rather than an OTYPE. Also, the
receiver type of the result should be the original type, but the new
code was using the last type after following the embedding path.

Change-Id: I13f7ea6448b03d3e8f974103ee3a027219ca8388
Reviewed-on: https://go-review.googlesource.com/c/go/+/286176
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/noder/expr.go    | 43 ++++++++-----
 src/cmd/compile/internal/noder/helpers.go | 28 ++++++---
 src/reflect/all_test.go                   | 76 +++++++++++------------
 test/method7.go                           | 12 ++++
 4 files changed, 98 insertions(+), 61 deletions(-)

diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index 5a2cae12e3..9212c67213 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -140,6 +140,7 @@ func (g *irgen) selectorExpr(pos src.XPos, expr *syntax.SelectorExpr) ir.Node {
 	embeds, last := index[:len(index)-1], index[len(index)-1]
 
 	x := g.expr(expr.X)
+	origx := x
 	for _, ix := range embeds {
 		x = Implicit(DotField(pos, x, ix))
 	}
@@ -155,27 +156,37 @@ func (g *irgen) selectorExpr(pos src.XPos, expr *syntax.SelectorExpr) ir.Node {
 	// unexported methods from two different packages (due to cross-package
 	// interface embedding).
 
+	var n ir.Node
 	method := selinfo.Obj().(*types2.Func)
 
-	// Add implicit addr/deref for method values, if needed.
-	if kind == types2.MethodVal && !x.Type().IsInterface() {
-		recvTyp := method.Type().(*types2.Signature).Recv().Type()
-		_, wantPtr := recvTyp.(*types2.Pointer)
-		havePtr := x.Type().IsPtr()
-
-		if havePtr != wantPtr {
-			if havePtr {
-				x = Implicit(Deref(pos, x))
-			} else {
-				x = Implicit(Addr(pos, x))
+	if kind == types2.MethodExpr {
+		// OMETHEXPR is unusual in using directly the node and type of the
+		// original OTYPE node (origx) before passing through embedded
+		// fields, even though the method is selected from the type
+		// (x.Type()) reached after following the embedded fields. We will
+		// actually drop any ODOT nodes we created due to the embedded
+		// fields.
+		n = MethodExpr(pos, origx, x.Type(), last)
+	} else {
+		// Add implicit addr/deref for method values, if needed.
+		if !x.Type().IsInterface() {
+			recvTyp := method.Type().(*types2.Signature).Recv().Type()
+			_, wantPtr := recvTyp.(*types2.Pointer)
+			havePtr := x.Type().IsPtr()
+
+			if havePtr != wantPtr {
+				if havePtr {
+					x = Implicit(Deref(pos, x))
+				} else {
+					x = Implicit(Addr(pos, x))
+				}
+			}
+			if !g.match(x.Type(), recvTyp, false) {
+				base.FatalfAt(pos, "expected %L to have type %v", x, recvTyp)
 			}
 		}
-		if !g.match(x.Type(), recvTyp, false) {
-			base.FatalfAt(pos, "expected %L to have type %v", x, recvTyp)
-		}
+		n = DotMethod(pos, x, last)
 	}
-
-	n := DotMethod(pos, x, last)
 	if have, want := n.Sym(), g.selector(method); have != want {
 		base.FatalfAt(pos, "bad Sym: have %v, want %v", have, want)
 	}
diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
index c84e08e71a..ffd62367ad 100644
--- a/src/cmd/compile/internal/noder/helpers.go
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -154,18 +154,32 @@ func DotField(pos src.XPos, x ir.Node, index int) *ir.SelectorExpr {
 func DotMethod(pos src.XPos, x ir.Node, index int) *ir.SelectorExpr {
 	method := method(x.Type(), index)
 
-	// Method expression.
-	// TODO(mdempsky): Handle with a separate helper?
-	if x.Op() == ir.OTYPE {
-		typ := typecheck.NewMethodType(method.Type, x.Type())
-		return dot(pos, typ, ir.OMETHEXPR, x, method)
-	}
-
 	// Method value.
 	typ := typecheck.NewMethodType(method.Type, nil)
 	return dot(pos, typ, ir.OCALLPART, x, method)
 }
 
+// MethodExpr returns a OMETHEXPR node with the indicated index into the methods
+// of typ. The receiver type is set from recv, which is different from typ if the
+// method was accessed via embedded fields. Similarly, the X value of the
+// ir.SelectorExpr is recv, the original OTYPE node before passing through the
+// embedded fields.
+func MethodExpr(pos src.XPos, recv ir.Node, embed *types.Type, index int) *ir.SelectorExpr {
+	method := method(embed, index)
+	typ := typecheck.NewMethodType(method.Type, recv.Type())
+	// The method expression T.m requires a wrapper when T
+	// is different from m's declared receiver type. We
+	// normally generate these wrappers while writing out
+	// runtime type descriptors, which is always done for
+	// types declared at package scope. However, we need
+	// to make sure to generate wrappers for anonymous
+	// receiver types too.
+	if recv.Sym() == nil {
+		typecheck.NeedRuntimeType(recv.Type())
+	}
+	return dot(pos, typ, ir.OMETHEXPR, recv, method)
+}
+
 func dot(pos src.XPos, typ *types.Type, op ir.Op, x ir.Node, selection *types.Field) *ir.SelectorExpr {
 	n := ir.NewSelectorExpr(pos, op, x, selection.Sym)
 	n.Selection = selection
diff --git a/src/reflect/all_test.go b/src/reflect/all_test.go
index ea7163f66a..1225d6177d 100644
--- a/src/reflect/all_test.go
+++ b/src/reflect/all_test.go
@@ -2997,44 +2997,44 @@ func TestUnexportedMethods(t *testing.T) {
 	}
 }
 
-// type InnerInt struct {
-// 	X int
-// }
-
-// type OuterInt struct {
-// 	Y int
-// 	InnerInt
-// }
-
-// func (i *InnerInt) M() int {
-// 	return i.X
-// }
-
-// func TestEmbeddedMethods(t *testing.T) {
-// 	typ := TypeOf((*OuterInt)(nil))
-// 	if typ.NumMethod() != 1 || typ.Method(0).Func.Pointer() != ValueOf((*OuterInt).M).Pointer() {
-// 		t.Errorf("Wrong method table for OuterInt: (m=%p)", (*OuterInt).M)
-// 		for i := 0; i < typ.NumMethod(); i++ {
-// 			m := typ.Method(i)
-// 			t.Errorf("\t%d: %s %#x\n", i, m.Name, m.Func.Pointer())
-// 		}
-// 	}
-
-// 	i := &InnerInt{3}
-// 	if v := ValueOf(i).Method(0).Call(nil)[0].Int(); v != 3 {
-// 		t.Errorf("i.M() = %d, want 3", v)
-// 	}
-
-// 	o := &OuterInt{1, InnerInt{2}}
-// 	if v := ValueOf(o).Method(0).Call(nil)[0].Int(); v != 2 {
-// 		t.Errorf("i.M() = %d, want 2", v)
-// 	}
-
-// 	f := (*OuterInt).M
-// 	if v := f(o); v != 2 {
-// 		t.Errorf("f(o) = %d, want 2", v)
-// 	}
-// }
+type InnerInt struct {
+	X int
+}
+
+type OuterInt struct {
+	Y int
+	InnerInt
+}
+
+func (i *InnerInt) M() int {
+	return i.X
+}
+
+func TestEmbeddedMethods(t *testing.T) {
+	typ := TypeOf((*OuterInt)(nil))
+	if typ.NumMethod() != 1 || typ.Method(0).Func.Pointer() != ValueOf((*OuterInt).M).Pointer() {
+		t.Errorf("Wrong method table for OuterInt: (m=%p)", (*OuterInt).M)
+		for i := 0; i < typ.NumMethod(); i++ {
+			m := typ.Method(i)
+			t.Errorf("\t%d: %s %#x\n", i, m.Name, m.Func.Pointer())
+		}
+	}
+
+	i := &InnerInt{3}
+	if v := ValueOf(i).Method(0).Call(nil)[0].Int(); v != 3 {
+		t.Errorf("i.M() = %d, want 3", v)
+	}
+
+	o := &OuterInt{1, InnerInt{2}}
+	if v := ValueOf(o).Method(0).Call(nil)[0].Int(); v != 2 {
+		t.Errorf("i.M() = %d, want 2", v)
+	}
+
+	f := (*OuterInt).M
+	if v := f(o); v != 2 {
+		t.Errorf("f(o) = %d, want 2", v)
+	}
+}
 
 type FuncDDD func(...interface{}) error
 
diff --git a/test/method7.go b/test/method7.go
index 15e123e85f..05accb3ee0 100644
--- a/test/method7.go
+++ b/test/method7.go
@@ -25,6 +25,11 @@ type T int
 
 func (T) m2() { got += " m2()" }
 
+type Outer struct{ *Inner }
+type Inner struct{ s string }
+
+func (i Inner) M() string { return i.s }
+
 func main() {
 	// method expressions with named receiver types
 	I.m(S{})
@@ -52,4 +57,11 @@ func main() {
 	if got != want {
 		panic("got" + got + ", want" + want)
 	}
+
+	h := (*Outer).M
+	got := h(&Outer{&Inner{"hello"}})
+	want := "hello"
+	if got != want {
+		panic("got " + got + ", want " + want)
+	}
 }
-- 
GitLab


From f7dad5eae43d5feb77c16fbd892a5a24a4d309ae Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Fri, 22 Jan 2021 22:53:47 -0500
Subject: [PATCH 0571/2400] [dev.regabi] cmd/compile: remove leftover code form
 late call lowering work

It's no longer conditional.

Change-Id: I697bb0e9ffe9644ec4d2766f7e8be8b82d3b0638
Reviewed-on: https://go-review.googlesource.com/c/go/+/286013
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ssa/compile.go       |   1 -
 src/cmd/compile/internal/ssa/config.go        |   8 -
 src/cmd/compile/internal/ssa/decompose.go     |   4 -
 src/cmd/compile/internal/ssa/expand_calls.go  |   3 -
 src/cmd/compile/internal/ssa/gen/dec64.rules  |   8 +-
 .../compile/internal/ssa/gen/decArgs.rules    |  58 ----
 .../compile/internal/ssa/gen/decArgsOps.go    |  20 --
 src/cmd/compile/internal/ssa/rewritedec64.go  |  16 +-
 .../compile/internal/ssa/rewritedecArgs.go    | 247 ------------------
 src/cmd/compile/internal/ssagen/ssa.go        | 211 ++++-----------
 10 files changed, 63 insertions(+), 513 deletions(-)
 delete mode 100644 src/cmd/compile/internal/ssa/gen/decArgs.rules
 delete mode 100644 src/cmd/compile/internal/ssa/gen/decArgsOps.go
 delete mode 100644 src/cmd/compile/internal/ssa/rewritedecArgs.go

diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go
index 63994d1778..c267274366 100644
--- a/src/cmd/compile/internal/ssa/compile.go
+++ b/src/cmd/compile/internal/ssa/compile.go
@@ -431,7 +431,6 @@ var passes = [...]pass{
 	{name: "early copyelim", fn: copyelim},
 	{name: "early deadcode", fn: deadcode}, // remove generated dead code to avoid doing pointless work during opt
 	{name: "short circuit", fn: shortcircuit},
-	{name: "decompose args", fn: decomposeArgs, required: !go116lateCallExpansion, disabled: go116lateCallExpansion}, // handled by late call lowering
 	{name: "decompose user", fn: decomposeUser, required: true},
 	{name: "pre-opt deadcode", fn: deadcode},
 	{name: "opt", fn: opt, required: true},               // NB: some generic rules know the name of the opt pass. TODO: split required rules and optimizing rules
diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go
index 8dc2ee8213..e952c73d9b 100644
--- a/src/cmd/compile/internal/ssa/config.go
+++ b/src/cmd/compile/internal/ssa/config.go
@@ -179,14 +179,6 @@ type Frontend interface {
 	MyImportPath() string
 }
 
-const go116lateCallExpansion = true
-
-// LateCallExpansionEnabledWithin returns true if late call expansion should be tested
-// within compilation of a function/method.
-func LateCallExpansionEnabledWithin(f *Func) bool {
-	return go116lateCallExpansion
-}
-
 // NewConfig returns a new configuration object for the given architecture.
 func NewConfig(arch string, types Types, ctxt *obj.Link, optimize bool) *Config {
 	c := &Config{arch: arch, Types: types}
diff --git a/src/cmd/compile/internal/ssa/decompose.go b/src/cmd/compile/internal/ssa/decompose.go
index bf7f1e826b..ea988e44f6 100644
--- a/src/cmd/compile/internal/ssa/decompose.go
+++ b/src/cmd/compile/internal/ssa/decompose.go
@@ -219,10 +219,6 @@ func decomposeInterfacePhi(v *Value) {
 	v.AddArg(data)
 }
 
-func decomposeArgs(f *Func) {
-	applyRewrite(f, rewriteBlockdecArgs, rewriteValuedecArgs, removeDeadValues)
-}
-
 func decomposeUser(f *Func) {
 	for _, b := range f.Blocks {
 		for _, v := range b.Values {
diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index af994d4b5b..d89d743703 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -42,9 +42,6 @@ func expandCalls(f *Func) {
 
 	// With the current ABI, the outputs need to be converted to loads, which will all use the call's
 	// memory output as their input.
-	if !LateCallExpansionEnabledWithin(f) {
-		return
-	}
 	debug := f.pass.debug > 0
 
 	if debug {
diff --git a/src/cmd/compile/internal/ssa/gen/dec64.rules b/src/cmd/compile/internal/ssa/gen/dec64.rules
index 9297ed8d2e..b0f10d0a0f 100644
--- a/src/cmd/compile/internal/ssa/gen/dec64.rules
+++ b/src/cmd/compile/internal/ssa/gen/dec64.rules
@@ -42,20 +42,20 @@
 		(Store {hi.Type} dst hi mem))
 
 // These are not enabled during decomposeBuiltin if late call expansion, but they are always enabled for softFloat
-(Arg {n} [off]) && is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() && !(go116lateCallExpansion && b.Func.pass.name == "decompose builtin") =>
+(Arg {n} [off]) && is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin") =>
   (Int64Make
     (Arg <typ.Int32> {n} [off+4])
     (Arg <typ.UInt32> {n} [off]))
-(Arg {n} [off]) && is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() && !(go116lateCallExpansion && b.Func.pass.name == "decompose builtin")  =>
+(Arg {n} [off]) && is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")  =>
   (Int64Make
     (Arg <typ.UInt32> {n} [off+4])
     (Arg <typ.UInt32> {n} [off]))
 
-(Arg {n} [off]) && is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() && !(go116lateCallExpansion && b.Func.pass.name == "decompose builtin") =>
+(Arg {n} [off]) && is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin") =>
   (Int64Make
     (Arg <typ.Int32> {n} [off])
     (Arg <typ.UInt32> {n} [off+4]))
-(Arg {n} [off]) && is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() && !(go116lateCallExpansion && b.Func.pass.name == "decompose builtin") =>
+(Arg {n} [off]) && is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin") =>
   (Int64Make
     (Arg <typ.UInt32> {n} [off])
     (Arg <typ.UInt32> {n} [off+4]))
diff --git a/src/cmd/compile/internal/ssa/gen/decArgs.rules b/src/cmd/compile/internal/ssa/gen/decArgs.rules
deleted file mode 100644
index 1c9a0bb23d..0000000000
--- a/src/cmd/compile/internal/ssa/gen/decArgs.rules
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright 2018 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.
-
-// Decompose compound argument values
-// Do this early to simplify tracking names for debugging.
-
-(Arg {n} [off]) && v.Type.IsString() =>
-  (StringMake
-    (Arg <typ.BytePtr> {n} [off])
-    (Arg <typ.Int> {n} [off+int32(config.PtrSize)]))
-
-(Arg {n} [off]) && v.Type.IsSlice() =>
-  (SliceMake
-    (Arg <v.Type.Elem().PtrTo()> {n} [off])
-    (Arg <typ.Int> {n} [off+int32(config.PtrSize)])
-    (Arg <typ.Int> {n} [off+2*int32(config.PtrSize)]))
-
-(Arg {n} [off]) && v.Type.IsInterface() =>
-  (IMake
-    (Arg <typ.Uintptr> {n} [off])
-    (Arg <typ.BytePtr> {n} [off+int32(config.PtrSize)]))
-
-(Arg {n} [off]) && v.Type.IsComplex() && v.Type.Size() == 16 =>
-  (ComplexMake
-    (Arg <typ.Float64> {n} [off])
-    (Arg <typ.Float64> {n} [off+8]))
-
-(Arg {n} [off]) && v.Type.IsComplex() && v.Type.Size() == 8 =>
-  (ComplexMake
-    (Arg <typ.Float32> {n} [off])
-    (Arg <typ.Float32> {n} [off+4]))
-
-(Arg <t>) && t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t) =>
-  (StructMake0)
-(Arg <t> {n} [off]) && t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t) =>
-  (StructMake1
-    (Arg <t.FieldType(0)> {n} [off+int32(t.FieldOff(0))]))
-(Arg <t> {n} [off]) && t.IsStruct() && t.NumFields() == 2 && fe.CanSSA(t) =>
-  (StructMake2
-    (Arg <t.FieldType(0)> {n} [off+int32(t.FieldOff(0))])
-    (Arg <t.FieldType(1)> {n} [off+int32(t.FieldOff(1))]))
-(Arg <t> {n} [off]) && t.IsStruct() && t.NumFields() == 3 && fe.CanSSA(t) =>
-  (StructMake3
-    (Arg <t.FieldType(0)> {n} [off+int32(t.FieldOff(0))])
-    (Arg <t.FieldType(1)> {n} [off+int32(t.FieldOff(1))])
-    (Arg <t.FieldType(2)> {n} [off+int32(t.FieldOff(2))]))
-(Arg <t> {n} [off]) && t.IsStruct() && t.NumFields() == 4 && fe.CanSSA(t) =>
-  (StructMake4
-    (Arg <t.FieldType(0)> {n} [off+int32(t.FieldOff(0))])
-    (Arg <t.FieldType(1)> {n} [off+int32(t.FieldOff(1))])
-    (Arg <t.FieldType(2)> {n} [off+int32(t.FieldOff(2))])
-    (Arg <t.FieldType(3)> {n} [off+int32(t.FieldOff(3))]))
-
-(Arg <t>) && t.IsArray() && t.NumElem() == 0 =>
-  (ArrayMake0)
-(Arg <t> {n} [off]) && t.IsArray() && t.NumElem() == 1 && fe.CanSSA(t) =>
-  (ArrayMake1 (Arg <t.Elem()> {n} [off]))
diff --git a/src/cmd/compile/internal/ssa/gen/decArgsOps.go b/src/cmd/compile/internal/ssa/gen/decArgsOps.go
deleted file mode 100644
index b73d9d3976..0000000000
--- a/src/cmd/compile/internal/ssa/gen/decArgsOps.go
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright 2018 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.
-
-// +build ignore
-
-package main
-
-var decArgsOps = []opData{}
-
-var decArgsBlocks = []blockData{}
-
-func init() {
-	archs = append(archs, arch{
-		name:    "decArgs",
-		ops:     decArgsOps,
-		blocks:  decArgsBlocks,
-		generic: true,
-	})
-}
diff --git a/src/cmd/compile/internal/ssa/rewritedec64.go b/src/cmd/compile/internal/ssa/rewritedec64.go
index c49bc8043e..60b727f45f 100644
--- a/src/cmd/compile/internal/ssa/rewritedec64.go
+++ b/src/cmd/compile/internal/ssa/rewritedec64.go
@@ -184,12 +184,12 @@ func rewriteValuedec64_OpArg(v *Value) bool {
 	config := b.Func.Config
 	typ := &b.Func.Config.Types
 	// match: (Arg {n} [off])
-	// cond: is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() && !(go116lateCallExpansion && b.Func.pass.name == "decompose builtin")
+	// cond: is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")
 	// result: (Int64Make (Arg <typ.Int32> {n} [off+4]) (Arg <typ.UInt32> {n} [off]))
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		n := auxToSym(v.Aux)
-		if !(is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() && !(go116lateCallExpansion && b.Func.pass.name == "decompose builtin")) {
+		if !(is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")) {
 			break
 		}
 		v.reset(OpInt64Make)
@@ -203,12 +203,12 @@ func rewriteValuedec64_OpArg(v *Value) bool {
 		return true
 	}
 	// match: (Arg {n} [off])
-	// cond: is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() && !(go116lateCallExpansion && b.Func.pass.name == "decompose builtin")
+	// cond: is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")
 	// result: (Int64Make (Arg <typ.UInt32> {n} [off+4]) (Arg <typ.UInt32> {n} [off]))
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		n := auxToSym(v.Aux)
-		if !(is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() && !(go116lateCallExpansion && b.Func.pass.name == "decompose builtin")) {
+		if !(is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")) {
 			break
 		}
 		v.reset(OpInt64Make)
@@ -222,12 +222,12 @@ func rewriteValuedec64_OpArg(v *Value) bool {
 		return true
 	}
 	// match: (Arg {n} [off])
-	// cond: is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() && !(go116lateCallExpansion && b.Func.pass.name == "decompose builtin")
+	// cond: is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")
 	// result: (Int64Make (Arg <typ.Int32> {n} [off]) (Arg <typ.UInt32> {n} [off+4]))
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		n := auxToSym(v.Aux)
-		if !(is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() && !(go116lateCallExpansion && b.Func.pass.name == "decompose builtin")) {
+		if !(is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")) {
 			break
 		}
 		v.reset(OpInt64Make)
@@ -241,12 +241,12 @@ func rewriteValuedec64_OpArg(v *Value) bool {
 		return true
 	}
 	// match: (Arg {n} [off])
-	// cond: is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() && !(go116lateCallExpansion && b.Func.pass.name == "decompose builtin")
+	// cond: is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")
 	// result: (Int64Make (Arg <typ.UInt32> {n} [off]) (Arg <typ.UInt32> {n} [off+4]))
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		n := auxToSym(v.Aux)
-		if !(is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() && !(go116lateCallExpansion && b.Func.pass.name == "decompose builtin")) {
+		if !(is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")) {
 			break
 		}
 		v.reset(OpInt64Make)
diff --git a/src/cmd/compile/internal/ssa/rewritedecArgs.go b/src/cmd/compile/internal/ssa/rewritedecArgs.go
deleted file mode 100644
index 23ff417eee..0000000000
--- a/src/cmd/compile/internal/ssa/rewritedecArgs.go
+++ /dev/null
@@ -1,247 +0,0 @@
-// Code generated from gen/decArgs.rules; DO NOT EDIT.
-// generated with: cd gen; go run *.go
-
-package ssa
-
-func rewriteValuedecArgs(v *Value) bool {
-	switch v.Op {
-	case OpArg:
-		return rewriteValuedecArgs_OpArg(v)
-	}
-	return false
-}
-func rewriteValuedecArgs_OpArg(v *Value) bool {
-	b := v.Block
-	config := b.Func.Config
-	fe := b.Func.fe
-	typ := &b.Func.Config.Types
-	// match: (Arg {n} [off])
-	// cond: v.Type.IsString()
-	// result: (StringMake (Arg <typ.BytePtr> {n} [off]) (Arg <typ.Int> {n} [off+int32(config.PtrSize)]))
-	for {
-		off := auxIntToInt32(v.AuxInt)
-		n := auxToSym(v.Aux)
-		if !(v.Type.IsString()) {
-			break
-		}
-		v.reset(OpStringMake)
-		v0 := b.NewValue0(v.Pos, OpArg, typ.BytePtr)
-		v0.AuxInt = int32ToAuxInt(off)
-		v0.Aux = symToAux(n)
-		v1 := b.NewValue0(v.Pos, OpArg, typ.Int)
-		v1.AuxInt = int32ToAuxInt(off + int32(config.PtrSize))
-		v1.Aux = symToAux(n)
-		v.AddArg2(v0, v1)
-		return true
-	}
-	// match: (Arg {n} [off])
-	// cond: v.Type.IsSlice()
-	// result: (SliceMake (Arg <v.Type.Elem().PtrTo()> {n} [off]) (Arg <typ.Int> {n} [off+int32(config.PtrSize)]) (Arg <typ.Int> {n} [off+2*int32(config.PtrSize)]))
-	for {
-		off := auxIntToInt32(v.AuxInt)
-		n := auxToSym(v.Aux)
-		if !(v.Type.IsSlice()) {
-			break
-		}
-		v.reset(OpSliceMake)
-		v0 := b.NewValue0(v.Pos, OpArg, v.Type.Elem().PtrTo())
-		v0.AuxInt = int32ToAuxInt(off)
-		v0.Aux = symToAux(n)
-		v1 := b.NewValue0(v.Pos, OpArg, typ.Int)
-		v1.AuxInt = int32ToAuxInt(off + int32(config.PtrSize))
-		v1.Aux = symToAux(n)
-		v2 := b.NewValue0(v.Pos, OpArg, typ.Int)
-		v2.AuxInt = int32ToAuxInt(off + 2*int32(config.PtrSize))
-		v2.Aux = symToAux(n)
-		v.AddArg3(v0, v1, v2)
-		return true
-	}
-	// match: (Arg {n} [off])
-	// cond: v.Type.IsInterface()
-	// result: (IMake (Arg <typ.Uintptr> {n} [off]) (Arg <typ.BytePtr> {n} [off+int32(config.PtrSize)]))
-	for {
-		off := auxIntToInt32(v.AuxInt)
-		n := auxToSym(v.Aux)
-		if !(v.Type.IsInterface()) {
-			break
-		}
-		v.reset(OpIMake)
-		v0 := b.NewValue0(v.Pos, OpArg, typ.Uintptr)
-		v0.AuxInt = int32ToAuxInt(off)
-		v0.Aux = symToAux(n)
-		v1 := b.NewValue0(v.Pos, OpArg, typ.BytePtr)
-		v1.AuxInt = int32ToAuxInt(off + int32(config.PtrSize))
-		v1.Aux = symToAux(n)
-		v.AddArg2(v0, v1)
-		return true
-	}
-	// match: (Arg {n} [off])
-	// cond: v.Type.IsComplex() && v.Type.Size() == 16
-	// result: (ComplexMake (Arg <typ.Float64> {n} [off]) (Arg <typ.Float64> {n} [off+8]))
-	for {
-		off := auxIntToInt32(v.AuxInt)
-		n := auxToSym(v.Aux)
-		if !(v.Type.IsComplex() && v.Type.Size() == 16) {
-			break
-		}
-		v.reset(OpComplexMake)
-		v0 := b.NewValue0(v.Pos, OpArg, typ.Float64)
-		v0.AuxInt = int32ToAuxInt(off)
-		v0.Aux = symToAux(n)
-		v1 := b.NewValue0(v.Pos, OpArg, typ.Float64)
-		v1.AuxInt = int32ToAuxInt(off + 8)
-		v1.Aux = symToAux(n)
-		v.AddArg2(v0, v1)
-		return true
-	}
-	// match: (Arg {n} [off])
-	// cond: v.Type.IsComplex() && v.Type.Size() == 8
-	// result: (ComplexMake (Arg <typ.Float32> {n} [off]) (Arg <typ.Float32> {n} [off+4]))
-	for {
-		off := auxIntToInt32(v.AuxInt)
-		n := auxToSym(v.Aux)
-		if !(v.Type.IsComplex() && v.Type.Size() == 8) {
-			break
-		}
-		v.reset(OpComplexMake)
-		v0 := b.NewValue0(v.Pos, OpArg, typ.Float32)
-		v0.AuxInt = int32ToAuxInt(off)
-		v0.Aux = symToAux(n)
-		v1 := b.NewValue0(v.Pos, OpArg, typ.Float32)
-		v1.AuxInt = int32ToAuxInt(off + 4)
-		v1.Aux = symToAux(n)
-		v.AddArg2(v0, v1)
-		return true
-	}
-	// match: (Arg <t>)
-	// cond: t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t)
-	// result: (StructMake0)
-	for {
-		t := v.Type
-		if !(t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t)) {
-			break
-		}
-		v.reset(OpStructMake0)
-		return true
-	}
-	// match: (Arg <t> {n} [off])
-	// cond: t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t)
-	// result: (StructMake1 (Arg <t.FieldType(0)> {n} [off+int32(t.FieldOff(0))]))
-	for {
-		t := v.Type
-		off := auxIntToInt32(v.AuxInt)
-		n := auxToSym(v.Aux)
-		if !(t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t)) {
-			break
-		}
-		v.reset(OpStructMake1)
-		v0 := b.NewValue0(v.Pos, OpArg, t.FieldType(0))
-		v0.AuxInt = int32ToAuxInt(off + int32(t.FieldOff(0)))
-		v0.Aux = symToAux(n)
-		v.AddArg(v0)
-		return true
-	}
-	// match: (Arg <t> {n} [off])
-	// cond: t.IsStruct() && t.NumFields() == 2 && fe.CanSSA(t)
-	// result: (StructMake2 (Arg <t.FieldType(0)> {n} [off+int32(t.FieldOff(0))]) (Arg <t.FieldType(1)> {n} [off+int32(t.FieldOff(1))]))
-	for {
-		t := v.Type
-		off := auxIntToInt32(v.AuxInt)
-		n := auxToSym(v.Aux)
-		if !(t.IsStruct() && t.NumFields() == 2 && fe.CanSSA(t)) {
-			break
-		}
-		v.reset(OpStructMake2)
-		v0 := b.NewValue0(v.Pos, OpArg, t.FieldType(0))
-		v0.AuxInt = int32ToAuxInt(off + int32(t.FieldOff(0)))
-		v0.Aux = symToAux(n)
-		v1 := b.NewValue0(v.Pos, OpArg, t.FieldType(1))
-		v1.AuxInt = int32ToAuxInt(off + int32(t.FieldOff(1)))
-		v1.Aux = symToAux(n)
-		v.AddArg2(v0, v1)
-		return true
-	}
-	// match: (Arg <t> {n} [off])
-	// cond: t.IsStruct() && t.NumFields() == 3 && fe.CanSSA(t)
-	// result: (StructMake3 (Arg <t.FieldType(0)> {n} [off+int32(t.FieldOff(0))]) (Arg <t.FieldType(1)> {n} [off+int32(t.FieldOff(1))]) (Arg <t.FieldType(2)> {n} [off+int32(t.FieldOff(2))]))
-	for {
-		t := v.Type
-		off := auxIntToInt32(v.AuxInt)
-		n := auxToSym(v.Aux)
-		if !(t.IsStruct() && t.NumFields() == 3 && fe.CanSSA(t)) {
-			break
-		}
-		v.reset(OpStructMake3)
-		v0 := b.NewValue0(v.Pos, OpArg, t.FieldType(0))
-		v0.AuxInt = int32ToAuxInt(off + int32(t.FieldOff(0)))
-		v0.Aux = symToAux(n)
-		v1 := b.NewValue0(v.Pos, OpArg, t.FieldType(1))
-		v1.AuxInt = int32ToAuxInt(off + int32(t.FieldOff(1)))
-		v1.Aux = symToAux(n)
-		v2 := b.NewValue0(v.Pos, OpArg, t.FieldType(2))
-		v2.AuxInt = int32ToAuxInt(off + int32(t.FieldOff(2)))
-		v2.Aux = symToAux(n)
-		v.AddArg3(v0, v1, v2)
-		return true
-	}
-	// match: (Arg <t> {n} [off])
-	// cond: t.IsStruct() && t.NumFields() == 4 && fe.CanSSA(t)
-	// result: (StructMake4 (Arg <t.FieldType(0)> {n} [off+int32(t.FieldOff(0))]) (Arg <t.FieldType(1)> {n} [off+int32(t.FieldOff(1))]) (Arg <t.FieldType(2)> {n} [off+int32(t.FieldOff(2))]) (Arg <t.FieldType(3)> {n} [off+int32(t.FieldOff(3))]))
-	for {
-		t := v.Type
-		off := auxIntToInt32(v.AuxInt)
-		n := auxToSym(v.Aux)
-		if !(t.IsStruct() && t.NumFields() == 4 && fe.CanSSA(t)) {
-			break
-		}
-		v.reset(OpStructMake4)
-		v0 := b.NewValue0(v.Pos, OpArg, t.FieldType(0))
-		v0.AuxInt = int32ToAuxInt(off + int32(t.FieldOff(0)))
-		v0.Aux = symToAux(n)
-		v1 := b.NewValue0(v.Pos, OpArg, t.FieldType(1))
-		v1.AuxInt = int32ToAuxInt(off + int32(t.FieldOff(1)))
-		v1.Aux = symToAux(n)
-		v2 := b.NewValue0(v.Pos, OpArg, t.FieldType(2))
-		v2.AuxInt = int32ToAuxInt(off + int32(t.FieldOff(2)))
-		v2.Aux = symToAux(n)
-		v3 := b.NewValue0(v.Pos, OpArg, t.FieldType(3))
-		v3.AuxInt = int32ToAuxInt(off + int32(t.FieldOff(3)))
-		v3.Aux = symToAux(n)
-		v.AddArg4(v0, v1, v2, v3)
-		return true
-	}
-	// match: (Arg <t>)
-	// cond: t.IsArray() && t.NumElem() == 0
-	// result: (ArrayMake0)
-	for {
-		t := v.Type
-		if !(t.IsArray() && t.NumElem() == 0) {
-			break
-		}
-		v.reset(OpArrayMake0)
-		return true
-	}
-	// match: (Arg <t> {n} [off])
-	// cond: t.IsArray() && t.NumElem() == 1 && fe.CanSSA(t)
-	// result: (ArrayMake1 (Arg <t.Elem()> {n} [off]))
-	for {
-		t := v.Type
-		off := auxIntToInt32(v.AuxInt)
-		n := auxToSym(v.Aux)
-		if !(t.IsArray() && t.NumElem() == 1 && fe.CanSSA(t)) {
-			break
-		}
-		v.reset(OpArrayMake1)
-		v0 := b.NewValue0(v.Pos, OpArg, t.Elem())
-		v0.AuxInt = int32ToAuxInt(off)
-		v0.Aux = symToAux(n)
-		v.AddArg(v0)
-		return true
-	}
-	return false
-}
-func rewriteBlockdecArgs(b *Block) bool {
-	switch b.Kind {
-	}
-	return false
-}
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index e49a9716fe..99e0812645 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -1803,7 +1803,7 @@ const shareDeferExits = false
 // It returns a BlockRet block that ends the control flow. Its control value
 // will be set to the final memory state.
 func (s *state) exit() *ssa.Block {
-	lateResultLowering := s.f.DebugTest && ssa.LateCallExpansionEnabledWithin(s.f)
+	lateResultLowering := s.f.DebugTest
 	if s.hasdefer {
 		if s.hasOpenDefers {
 			if shareDeferExits && s.lastDeferExit != nil && len(s.openDefers) == s.lastDeferCount {
@@ -4628,7 +4628,6 @@ func (s *state) openDeferExit() {
 	s.lastDeferExit = deferExit
 	s.lastDeferCount = len(s.openDefers)
 	zeroval := s.constInt8(types.Types[types.TUINT8], 0)
-	testLateExpansion := ssa.LateCallExpansionEnabledWithin(s.f)
 	// Test for and run defers in reverse order
 	for i := len(s.openDefers) - 1; i >= 0; i-- {
 		r := s.openDefers[i]
@@ -4670,35 +4669,19 @@ func (s *state) openDeferExit() {
 		if r.rcvr != nil {
 			// rcvr in case of OCALLINTER
 			v := s.load(r.rcvr.Type.Elem(), r.rcvr)
-			addr := s.constOffPtrSP(s.f.Config.Types.UintptrPtr, argStart)
 			ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(argStart)})
-			if testLateExpansion {
-				callArgs = append(callArgs, v)
-			} else {
-				s.store(types.Types[types.TUINTPTR], addr, v)
-			}
+			callArgs = append(callArgs, v)
 		}
 		for j, argAddrVal := range r.argVals {
 			f := getParam(r.n, j)
-			pt := types.NewPtr(f.Type)
 			ACArgs = append(ACArgs, ssa.Param{Type: f.Type, Offset: int32(argStart + f.Offset)})
-			if testLateExpansion {
-				var a *ssa.Value
-				if !TypeOK(f.Type) {
-					a = s.newValue2(ssa.OpDereference, f.Type, argAddrVal, s.mem())
-				} else {
-					a = s.load(f.Type, argAddrVal)
-				}
-				callArgs = append(callArgs, a)
+			var a *ssa.Value
+			if !TypeOK(f.Type) {
+				a = s.newValue2(ssa.OpDereference, f.Type, argAddrVal, s.mem())
 			} else {
-				addr := s.constOffPtrSP(pt, argStart+f.Offset)
-				if !TypeOK(f.Type) {
-					s.move(f.Type, addr, argAddrVal)
-				} else {
-					argVal := s.load(f.Type, argAddrVal)
-					s.storeType(f.Type, addr, argVal, 0, false)
-				}
+				a = s.load(f.Type, argAddrVal)
 			}
+			callArgs = append(callArgs, a)
 		}
 		var call *ssa.Value
 		if r.closure != nil {
@@ -4706,30 +4689,17 @@ func (s *state) openDeferExit() {
 			s.maybeNilCheckClosure(v, callDefer)
 			codeptr := s.rawLoad(types.Types[types.TUINTPTR], v)
 			aux := ssa.ClosureAuxCall(ACArgs, ACResults)
-			if testLateExpansion {
-				callArgs = append(callArgs, s.mem())
-				call = s.newValue2A(ssa.OpClosureLECall, aux.LateExpansionResultType(), aux, codeptr, v)
-				call.AddArgs(callArgs...)
-			} else {
-				call = s.newValue3A(ssa.OpClosureCall, types.TypeMem, aux, codeptr, v, s.mem())
-			}
+			callArgs = append(callArgs, s.mem())
+			call = s.newValue2A(ssa.OpClosureLECall, aux.LateExpansionResultType(), aux, codeptr, v)
+			call.AddArgs(callArgs...)
 		} else {
 			aux := ssa.StaticAuxCall(fn.(*ir.Name).Linksym(), ACArgs, ACResults)
-			if testLateExpansion {
-				callArgs = append(callArgs, s.mem())
-				call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
-				call.AddArgs(callArgs...)
-			} else {
-				// Do a static call if the original call was a static function or method
-				call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, aux, s.mem())
-			}
+			callArgs = append(callArgs, s.mem())
+			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
+			call.AddArgs(callArgs...)
 		}
 		call.AuxInt = stksize
-		if testLateExpansion {
-			s.vars[memVar] = s.newValue1I(ssa.OpSelectN, types.TypeMem, int64(len(ACResults)), call)
-		} else {
-			s.vars[memVar] = call
-		}
+		s.vars[memVar] = s.newValue1I(ssa.OpSelectN, types.TypeMem, int64(len(ACResults)), call)
 		// Make sure that the stack slots with pointers are kept live
 		// through the call (which is a pre-emption point). Also, we will
 		// use the first call of the last defer exit to compute liveness
@@ -4782,12 +4752,10 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		}
 	}
 
-	testLateExpansion := false
 	inRegisters := false
 
 	switch n.Op() {
 	case ir.OCALLFUNC:
-		testLateExpansion = k != callDeferStack && ssa.LateCallExpansionEnabledWithin(s.f)
 		if k == callNormal && fn.Op() == ir.ONAME && fn.(*ir.Name).Class == ir.PFUNC {
 			fn := fn.(*ir.Name)
 			callee = fn
@@ -4813,7 +4781,6 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			s.Fatalf("OCALLINTER: n.Left not an ODOTINTER: %v", fn.Op())
 		}
 		fn := fn.(*ir.SelectorExpr)
-		testLateExpansion = k != callDeferStack && ssa.LateCallExpansionEnabledWithin(s.f)
 		var iclosure *ssa.Value
 		iclosure, rcvr = s.getClosureAndRcvr(fn)
 		if k == callNormal {
@@ -4827,7 +4794,6 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 
 	var call *ssa.Value
 	if k == callDeferStack {
-		testLateExpansion = ssa.LateCallExpansionEnabledWithin(s.f)
 		// Make a defer struct d on the stack.
 		t := deferstruct(stksize)
 		d := typecheck.TempAt(n.Pos(), s.curfn, t)
@@ -4878,15 +4844,9 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		// Call runtime.deferprocStack with pointer to _defer record.
 		ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(base.Ctxt.FixedFrameSize())})
 		aux := ssa.StaticAuxCall(ir.Syms.DeferprocStack, ACArgs, ACResults)
-		if testLateExpansion {
-			callArgs = append(callArgs, addr, s.mem())
-			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
-			call.AddArgs(callArgs...)
-		} else {
-			arg0 := s.constOffPtrSP(types.Types[types.TUINTPTR], base.Ctxt.FixedFrameSize())
-			s.store(types.Types[types.TUINTPTR], arg0, addr)
-			call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, aux, s.mem())
-		}
+		callArgs = append(callArgs, addr, s.mem())
+		call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
+		call.AddArgs(callArgs...)
 		if stksize < int64(types.PtrSize) {
 			// We need room for both the call to deferprocStack and the call to
 			// the deferred function.
@@ -4903,32 +4863,17 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			// Write argsize and closure (args to newproc/deferproc).
 			argsize := s.constInt32(types.Types[types.TUINT32], int32(stksize))
 			ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINT32], Offset: int32(argStart)})
-			if testLateExpansion {
-				callArgs = append(callArgs, argsize)
-			} else {
-				addr := s.constOffPtrSP(s.f.Config.Types.UInt32Ptr, argStart)
-				s.store(types.Types[types.TUINT32], addr, argsize)
-			}
+			callArgs = append(callArgs, argsize)
 			ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(argStart) + int32(types.PtrSize)})
-			if testLateExpansion {
-				callArgs = append(callArgs, closure)
-			} else {
-				addr := s.constOffPtrSP(s.f.Config.Types.UintptrPtr, argStart+int64(types.PtrSize))
-				s.store(types.Types[types.TUINTPTR], addr, closure)
-			}
+			callArgs = append(callArgs, closure)
 			stksize += 2 * int64(types.PtrSize)
 			argStart += 2 * int64(types.PtrSize)
 		}
 
 		// Set receiver (for interface calls).
 		if rcvr != nil {
-			addr := s.constOffPtrSP(s.f.Config.Types.UintptrPtr, argStart)
 			ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(argStart)})
-			if testLateExpansion {
-				callArgs = append(callArgs, rcvr)
-			} else {
-				s.store(types.Types[types.TUINTPTR], addr, rcvr)
-			}
+			callArgs = append(callArgs, rcvr)
 		}
 
 		// Write args.
@@ -4939,7 +4884,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		}
 		for i, n := range args {
 			f := t.Params().Field(i)
-			ACArg, arg := s.putArg(n, f.Type, argStart+f.Offset, testLateExpansion)
+			ACArg, arg := s.putArg(n, f.Type, argStart+f.Offset)
 			ACArgs = append(ACArgs, ACArg)
 			callArgs = append(callArgs, arg)
 		}
@@ -4950,20 +4895,12 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		switch {
 		case k == callDefer:
 			aux := ssa.StaticAuxCall(ir.Syms.Deferproc, ACArgs, ACResults)
-			if testLateExpansion {
-				call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
-				call.AddArgs(callArgs...)
-			} else {
-				call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, aux, s.mem())
-			}
+			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
+			call.AddArgs(callArgs...)
 		case k == callGo:
 			aux := ssa.StaticAuxCall(ir.Syms.Newproc, ACArgs, ACResults)
-			if testLateExpansion {
-				call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
-				call.AddArgs(callArgs...)
-			} else {
-				call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, aux, s.mem())
-			}
+			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
+			call.AddArgs(callArgs...)
 		case closure != nil:
 			// rawLoad because loading the code pointer from a
 			// closure is always safe, but IsSanitizerSafeAddr
@@ -4971,40 +4908,24 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			// critical that we not clobber any arguments already
 			// stored onto the stack.
 			codeptr = s.rawLoad(types.Types[types.TUINTPTR], closure)
-			if testLateExpansion {
-				aux := ssa.ClosureAuxCall(ACArgs, ACResults)
-				call = s.newValue2A(ssa.OpClosureLECall, aux.LateExpansionResultType(), aux, codeptr, closure)
-				call.AddArgs(callArgs...)
-			} else {
-				call = s.newValue3A(ssa.OpClosureCall, types.TypeMem, ssa.ClosureAuxCall(ACArgs, ACResults), codeptr, closure, s.mem())
-			}
+			aux := ssa.ClosureAuxCall(ACArgs, ACResults)
+			call = s.newValue2A(ssa.OpClosureLECall, aux.LateExpansionResultType(), aux, codeptr, closure)
+			call.AddArgs(callArgs...)
 		case codeptr != nil:
-			if testLateExpansion {
-				aux := ssa.InterfaceAuxCall(ACArgs, ACResults)
-				call = s.newValue1A(ssa.OpInterLECall, aux.LateExpansionResultType(), aux, codeptr)
-				call.AddArgs(callArgs...)
-			} else {
-				call = s.newValue2A(ssa.OpInterCall, types.TypeMem, ssa.InterfaceAuxCall(ACArgs, ACResults), codeptr, s.mem())
-			}
+			aux := ssa.InterfaceAuxCall(ACArgs, ACResults)
+			call = s.newValue1A(ssa.OpInterLECall, aux.LateExpansionResultType(), aux, codeptr)
+			call.AddArgs(callArgs...)
 		case callee != nil:
-			if testLateExpansion {
-				aux := ssa.StaticAuxCall(callTargetLSym(callee, s.curfn.LSym), ACArgs, ACResults)
-				call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
-				call.AddArgs(callArgs...)
-			} else {
-				call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, ssa.StaticAuxCall(callTargetLSym(callee, s.curfn.LSym), ACArgs, ACResults), s.mem())
-			}
+			aux := ssa.StaticAuxCall(callTargetLSym(callee, s.curfn.LSym), ACArgs, ACResults)
+			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
+			call.AddArgs(callArgs...)
 		default:
 			s.Fatalf("bad call type %v %v", n.Op(), n)
 		}
 		call.AuxInt = stksize // Call operations carry the argsize of the callee along with them
 	}
-	if testLateExpansion {
-		s.prevCall = call
-		s.vars[memVar] = s.newValue1I(ssa.OpSelectN, types.TypeMem, int64(len(ACResults)), call)
-	} else {
-		s.vars[memVar] = call
-	}
+	s.prevCall = call
+	s.vars[memVar] = s.newValue1I(ssa.OpSelectN, types.TypeMem, int64(len(ACResults)), call)
 	// Insert OVARLIVE nodes
 	for _, name := range n.KeepAlive {
 		s.stmt(ir.NewUnaryExpr(n.Pos(), ir.OVARLIVE, name))
@@ -5033,16 +4954,10 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 	fp := res.Field(0)
 	if returnResultAddr {
 		pt := types.NewPtr(fp.Type)
-		if testLateExpansion {
-			return s.newValue1I(ssa.OpSelectNAddr, pt, 0, call)
-		}
-		return s.constOffPtrSP(pt, fp.Offset+base.Ctxt.FixedFrameSize())
+		return s.newValue1I(ssa.OpSelectNAddr, pt, 0, call)
 	}
 
-	if testLateExpansion {
-		return s.newValue1I(ssa.OpSelectN, fp.Type, 0, call)
-	}
-	return s.load(n.Type(), s.constOffPtrSP(types.NewPtr(fp.Type), fp.Offset+base.Ctxt.FixedFrameSize()))
+	return s.newValue1I(ssa.OpSelectN, fp.Type, 0, call)
 }
 
 // maybeNilCheckClosure checks if a nil check of a closure is needed in some
@@ -5458,7 +5373,6 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
 	s.prevCall = nil
 	// Write args to the stack
 	off := base.Ctxt.FixedFrameSize()
-	testLateExpansion := ssa.LateCallExpansionEnabledWithin(s.f)
 	var ACArgs []ssa.Param
 	var ACResults []ssa.Param
 	var callArgs []*ssa.Value
@@ -5468,12 +5382,7 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
 		off = types.Rnd(off, t.Alignment())
 		size := t.Size()
 		ACArgs = append(ACArgs, ssa.Param{Type: t, Offset: int32(off)})
-		if testLateExpansion {
-			callArgs = append(callArgs, arg)
-		} else {
-			ptr := s.constOffPtrSP(t.PtrTo(), off)
-			s.store(t, ptr, arg)
-		}
+		callArgs = append(callArgs, arg)
 		off += size
 	}
 	off = types.Rnd(off, int64(types.RegSize))
@@ -5489,15 +5398,10 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
 	// Issue call
 	var call *ssa.Value
 	aux := ssa.StaticAuxCall(fn, ACArgs, ACResults)
-	if testLateExpansion {
 		callArgs = append(callArgs, s.mem())
 		call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 		call.AddArgs(callArgs...)
 		s.vars[memVar] = s.newValue1I(ssa.OpSelectN, types.TypeMem, int64(len(ACResults)), call)
-	} else {
-		call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, aux, s.mem())
-		s.vars[memVar] = call
-	}
 
 	if !returns {
 		// Finish block
@@ -5513,24 +5417,15 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
 
 	// Load results
 	res := make([]*ssa.Value, len(results))
-	if testLateExpansion {
-		for i, t := range results {
-			off = types.Rnd(off, t.Alignment())
-			if TypeOK(t) {
-				res[i] = s.newValue1I(ssa.OpSelectN, t, int64(i), call)
-			} else {
-				addr := s.newValue1I(ssa.OpSelectNAddr, types.NewPtr(t), int64(i), call)
-				res[i] = s.rawLoad(t, addr)
-			}
-			off += t.Size()
-		}
-	} else {
-		for i, t := range results {
-			off = types.Rnd(off, t.Alignment())
-			ptr := s.constOffPtrSP(types.NewPtr(t), off)
-			res[i] = s.load(t, ptr)
-			off += t.Size()
+	for i, t := range results {
+		off = types.Rnd(off, t.Alignment())
+		if TypeOK(t) {
+			res[i] = s.newValue1I(ssa.OpSelectN, t, int64(i), call)
+		} else {
+			addr := s.newValue1I(ssa.OpSelectNAddr, types.NewPtr(t), int64(i), call)
+			res[i] = s.rawLoad(t, addr)
 		}
+		off += t.Size()
 	}
 	off = types.Rnd(off, int64(types.PtrSize))
 
@@ -5653,16 +5548,12 @@ func (s *state) storeTypePtrs(t *types.Type, left, right *ssa.Value) {
 // putArg evaluates n for the purpose of passing it as an argument to a function and returns the corresponding Param for the call.
 // If forLateExpandedCall is true, it returns the argument value to pass to the call operation.
 // If forLateExpandedCall is false, then the value is stored at the specified stack offset, and the returned value is nil.
-func (s *state) putArg(n ir.Node, t *types.Type, off int64, forLateExpandedCall bool) (ssa.Param, *ssa.Value) {
+func (s *state) putArg(n ir.Node, t *types.Type, off int64) (ssa.Param, *ssa.Value) {
 	var a *ssa.Value
-	if forLateExpandedCall {
-		if !TypeOK(t) {
-			a = s.newValue2(ssa.OpDereference, t, s.addr(n), s.mem())
-		} else {
-			a = s.expr(n)
-		}
+	if !TypeOK(t) {
+		a = s.newValue2(ssa.OpDereference, t, s.addr(n), s.mem())
 	} else {
-		s.storeArgWithBase(n, t, s.sp, off)
+		a = s.expr(n)
 	}
 	return ssa.Param{Type: t, Offset: int32(off)}, a
 }
-- 
GitLab


From 9b636feafeecd627a72d95ba1fa637e162143027 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Tue, 26 Jan 2021 14:04:02 -0500
Subject: [PATCH 0572/2400] [dev.regabi] cmd/compile: missing last patch set
 for cl286013

Forgot to mail last patch set before committing, repair that.

Change-Id: I1ef72d0d7df56e89369e6fb4d6e5690f254e6aa8
Reviewed-on: https://go-review.googlesource.com/c/go/+/286912
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ssagen/ssa.go | 24 ++++++++----------------
 1 file changed, 8 insertions(+), 16 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 99e0812645..b042c132d5 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -4689,15 +4689,13 @@ func (s *state) openDeferExit() {
 			s.maybeNilCheckClosure(v, callDefer)
 			codeptr := s.rawLoad(types.Types[types.TUINTPTR], v)
 			aux := ssa.ClosureAuxCall(ACArgs, ACResults)
-			callArgs = append(callArgs, s.mem())
 			call = s.newValue2A(ssa.OpClosureLECall, aux.LateExpansionResultType(), aux, codeptr, v)
-			call.AddArgs(callArgs...)
 		} else {
 			aux := ssa.StaticAuxCall(fn.(*ir.Name).Linksym(), ACArgs, ACResults)
-			callArgs = append(callArgs, s.mem())
 			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
-			call.AddArgs(callArgs...)
 		}
+		callArgs = append(callArgs, s.mem())
+		call.AddArgs(callArgs...)
 		call.AuxInt = stksize
 		s.vars[memVar] = s.newValue1I(ssa.OpSelectN, types.TypeMem, int64(len(ACResults)), call)
 		// Make sure that the stack slots with pointers are kept live
@@ -4896,11 +4894,9 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		case k == callDefer:
 			aux := ssa.StaticAuxCall(ir.Syms.Deferproc, ACArgs, ACResults)
 			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
-			call.AddArgs(callArgs...)
 		case k == callGo:
 			aux := ssa.StaticAuxCall(ir.Syms.Newproc, ACArgs, ACResults)
 			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
-			call.AddArgs(callArgs...)
 		case closure != nil:
 			// rawLoad because loading the code pointer from a
 			// closure is always safe, but IsSanitizerSafeAddr
@@ -4910,18 +4906,16 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			codeptr = s.rawLoad(types.Types[types.TUINTPTR], closure)
 			aux := ssa.ClosureAuxCall(ACArgs, ACResults)
 			call = s.newValue2A(ssa.OpClosureLECall, aux.LateExpansionResultType(), aux, codeptr, closure)
-			call.AddArgs(callArgs...)
 		case codeptr != nil:
 			aux := ssa.InterfaceAuxCall(ACArgs, ACResults)
 			call = s.newValue1A(ssa.OpInterLECall, aux.LateExpansionResultType(), aux, codeptr)
-			call.AddArgs(callArgs...)
 		case callee != nil:
 			aux := ssa.StaticAuxCall(callTargetLSym(callee, s.curfn.LSym), ACArgs, ACResults)
 			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
-			call.AddArgs(callArgs...)
 		default:
 			s.Fatalf("bad call type %v %v", n.Op(), n)
 		}
+		call.AddArgs(callArgs...)
 		call.AuxInt = stksize // Call operations carry the argsize of the callee along with them
 	}
 	s.prevCall = call
@@ -5398,10 +5392,10 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
 	// Issue call
 	var call *ssa.Value
 	aux := ssa.StaticAuxCall(fn, ACArgs, ACResults)
-		callArgs = append(callArgs, s.mem())
-		call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
-		call.AddArgs(callArgs...)
-		s.vars[memVar] = s.newValue1I(ssa.OpSelectN, types.TypeMem, int64(len(ACResults)), call)
+	callArgs = append(callArgs, s.mem())
+	call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
+	call.AddArgs(callArgs...)
+	s.vars[memVar] = s.newValue1I(ssa.OpSelectN, types.TypeMem, int64(len(ACResults)), call)
 
 	if !returns {
 		// Finish block
@@ -5545,9 +5539,7 @@ func (s *state) storeTypePtrs(t *types.Type, left, right *ssa.Value) {
 	}
 }
 
-// putArg evaluates n for the purpose of passing it as an argument to a function and returns the corresponding Param for the call.
-// If forLateExpandedCall is true, it returns the argument value to pass to the call operation.
-// If forLateExpandedCall is false, then the value is stored at the specified stack offset, and the returned value is nil.
+// putArg evaluates n for the purpose of passing it as an argument to a function and returns the corresponding Param and value for the call.
 func (s *state) putArg(n ir.Node, t *types.Type, off int64) (ssa.Param, *ssa.Value) {
 	var a *ssa.Value
 	if !TypeOK(t) {
-- 
GitLab


From 217a461f56cecee1756bef29f9ad2dcd389a255b Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 26 Jan 2021 12:08:18 -0800
Subject: [PATCH 0573/2400] [dev.typeparams] cmd/compile/internal/types2:
 report unused packages in source order

1) Rather than map-iterate through all file scopes and collect unused
   packages, collect all imports in the Checker.imports list so that
   errors are reported in source order.

2) From cmd/compile, borrow the idea of a "dotImportRefs" map to map
   dot-imported objects to the package they were dot-imported through
   (we call the map "dotImportMap").

3) From cmd/compile, borrow the "pkgnotused" function
   (called Checker.errorUnusedPkg in this code) and clean up
   unused package error reporting.

4) Adjust unused package error message to match compiler message exactly.

5) Enable one more excluded test case in test/run.go.

Change-Id: I4e4e55512a6043a7fd54f576c7441e3dd4077d6f
Reviewed-on: https://go-review.googlesource.com/c/go/+/287072
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/check.go      | 36 ++++----
 src/cmd/compile/internal/types2/resolver.go   | 87 +++++++++----------
 .../testdata/importdecl0/importdecl0b.src     |  2 +-
 .../testdata/importdecl1/importdecl1b.src     |  2 +-
 src/cmd/compile/internal/types2/typexpr.go    |  8 +-
 test/run.go                                   |  1 -
 6 files changed, 62 insertions(+), 74 deletions(-)

diff --git a/src/cmd/compile/internal/types2/check.go b/src/cmd/compile/internal/types2/check.go
index 6ba8506916..e2c6c4f606 100644
--- a/src/cmd/compile/internal/types2/check.go
+++ b/src/cmd/compile/internal/types2/check.go
@@ -74,6 +74,12 @@ type importKey struct {
 	path, dir string
 }
 
+// A dotImportKey describes a dot-imported object in the given scope.
+type dotImportKey struct {
+	scope *Scope
+	obj   Object
+}
+
 // A Checker maintains the state of the type checker.
 // It must be created with NewChecker.
 type Checker struct {
@@ -92,8 +98,9 @@ type Checker struct {
 	// information collected during type-checking of a set of package files
 	// (initialized by Files, valid only for the duration of check.Files;
 	// maps and lists are allocated on demand)
-	files            []*syntax.File                     // package files
-	unusedDotImports map[*Scope]map[*Package]syntax.Pos // positions of unused dot-imported packages for each file scope
+	files        []*syntax.File            // list of package files
+	imports      []*PkgName                // list of imported packages
+	dotImportMap map[dotImportKey]*PkgName // maps dot-imported objects to the package they were dot-imported through
 
 	firstErr error                    // first error encountered
 	methods  map[*TypeName][]*Func    // maps package scope type names to associated non-blank (non-interface) methods
@@ -110,22 +117,6 @@ type Checker struct {
 	indent int // indentation for tracing
 }
 
-// addUnusedImport adds the position of a dot-imported package
-// pkg to the map of dot imports for the given file scope.
-func (check *Checker) addUnusedDotImport(scope *Scope, pkg *Package, pos syntax.Pos) {
-	mm := check.unusedDotImports
-	if mm == nil {
-		mm = make(map[*Scope]map[*Package]syntax.Pos)
-		check.unusedDotImports = mm
-	}
-	m := mm[scope]
-	if m == nil {
-		m = make(map[*Package]syntax.Pos)
-		mm[scope] = m
-	}
-	m[pkg] = pos
-}
-
 // addDeclDep adds the dependency edge (check.decl -> to) if check.decl exists
 func (check *Checker) addDeclDep(to Object) {
 	from := check.decl
@@ -209,7 +200,8 @@ func NewChecker(conf *Config, pkg *Package, info *Info) *Checker {
 func (check *Checker) initFiles(files []*syntax.File) {
 	// start with a clean slate (check.Files may be called multiple times)
 	check.files = nil
-	check.unusedDotImports = nil
+	check.imports = nil
+	check.dotImportMap = nil
 
 	check.firstErr = nil
 	check.methods = nil
@@ -291,6 +283,9 @@ func (check *Checker) checkFiles(files []*syntax.File) (err error) {
 		print("== unusedImports ==")
 		check.unusedImports()
 	}
+	// no longer needed - release memory
+	check.imports = nil
+	check.dotImportMap = nil
 
 	print("== recordUntyped ==")
 	check.recordUntyped()
@@ -301,6 +296,9 @@ func (check *Checker) checkFiles(files []*syntax.File) (err error) {
 	}
 
 	check.pkg.complete = true
+
+	// TODO(gri) There's more memory we should release at this point.
+
 	return
 }
 
diff --git a/src/cmd/compile/internal/types2/resolver.go b/src/cmd/compile/internal/types2/resolver.go
index 7ea9bde5fa..2a84015cfc 100644
--- a/src/cmd/compile/internal/types2/resolver.go
+++ b/src/cmd/compile/internal/types2/resolver.go
@@ -273,21 +273,26 @@ func (check *Checker) collectObjects() {
 					}
 				}
 
-				obj := NewPkgName(s.Pos(), pkg, name, imp)
+				pkgName := NewPkgName(s.Pos(), pkg, name, imp)
 				if s.LocalPkgName != nil {
 					// in a dot-import, the dot represents the package
-					check.recordDef(s.LocalPkgName, obj)
+					check.recordDef(s.LocalPkgName, pkgName)
 				} else {
-					check.recordImplicit(s, obj)
+					check.recordImplicit(s, pkgName)
 				}
 
 				if path == "C" {
 					// match cmd/compile (not prescribed by spec)
-					obj.used = true
+					pkgName.used = true
 				}
 
 				// add import to file scope
+				check.imports = append(check.imports, pkgName)
 				if name == "." {
+					// dot-import
+					if check.dotImportMap == nil {
+						check.dotImportMap = make(map[dotImportKey]*PkgName)
+					}
 					// merge imported scope with file scope
 					for _, obj := range imp.scope.elems {
 						// A package scope may contain non-exported objects,
@@ -301,16 +306,15 @@ func (check *Checker) collectObjects() {
 							if alt := fileScope.Insert(obj); alt != nil {
 								check.errorf(s.LocalPkgName, "%s redeclared in this block", obj.Name())
 								check.reportAltDecl(alt)
+							} else {
+								check.dotImportMap[dotImportKey{fileScope, obj}] = pkgName
 							}
 						}
 					}
-					// add position to set of dot-import positions for this file
-					// (this is only needed for "imported but not used" errors)
-					check.addUnusedDotImport(fileScope, imp, s.Pos())
 				} else {
 					// declare imported package object in file scope
 					// (no need to provide s.LocalPkgName since we called check.recordDef earlier)
-					check.declare(fileScope, nil, obj, nopos)
+					check.declare(fileScope, nil, pkgName, nopos)
 				}
 
 			case *syntax.ConstDecl:
@@ -673,51 +677,38 @@ func (check *Checker) unusedImports() {
 	// any of its exported identifiers. To import a package solely for its side-effects
 	// (initialization), use the blank identifier as explicit package name."
 
-	// check use of regular imported packages
-	for _, scope := range check.pkg.scope.children /* file scopes */ {
-		for _, obj := range scope.elems {
-			if obj, ok := obj.(*PkgName); ok {
-				// Unused "blank imports" are automatically ignored
-				// since _ identifiers are not entered into scopes.
-				if !obj.used {
-					path := obj.imported.path
-					base := pkgName(path)
-					if obj.name == base {
-						if check.conf.CompilerErrorMessages {
-							check.softErrorf(obj.pos, "%q imported and not used", path)
-						} else {
-							check.softErrorf(obj.pos, "%q imported but not used", path)
-						}
-					} else {
-						if check.conf.CompilerErrorMessages {
-							check.softErrorf(obj.pos, "%q imported and not used as %s", path, obj.name)
-						} else {
-							check.softErrorf(obj.pos, "%q imported but not used as %s", path, obj.name)
-						}
-					}
-				}
-			}
-		}
-	}
-
-	// check use of dot-imported packages
-	for _, unusedDotImports := range check.unusedDotImports {
-		for pkg, pos := range unusedDotImports {
-			if check.conf.CompilerErrorMessages {
-				check.softErrorf(pos, "%q imported and not used", pkg.path)
-			} else {
-				check.softErrorf(pos, "%q imported but not used", pkg.path)
-			}
+	for _, obj := range check.imports {
+		if !obj.used && obj.name != "_" {
+			check.errorUnusedPkg(obj)
 		}
 	}
 }
 
-// pkgName returns the package name (last element) of an import path.
-func pkgName(path string) string {
-	if i := strings.LastIndex(path, "/"); i >= 0 {
-		path = path[i+1:]
+func (check *Checker) errorUnusedPkg(obj *PkgName) {
+	// If the package was imported with a name other than the final
+	// import path element, show it explicitly in the error message.
+	// Note that this handles both renamed imports and imports of
+	// packages containing unconventional package declarations.
+	// Note that this uses / always, even on Windows, because Go import
+	// paths always use forward slashes.
+	path := obj.imported.path
+	elem := path
+	if i := strings.LastIndex(elem, "/"); i >= 0 {
+		elem = elem[i+1:]
+	}
+	if obj.name == "" || obj.name == "." || obj.name == elem {
+		if check.conf.CompilerErrorMessages {
+			check.softErrorf(obj, "imported and not used: %q", path)
+		} else {
+			check.softErrorf(obj, "%q imported but not used", path)
+		}
+	} else {
+		if check.conf.CompilerErrorMessages {
+			check.softErrorf(obj, "imported and not used: %q as %s", path, obj.name)
+		} else {
+			check.softErrorf(obj, "%q imported but not used as %s", path, obj.name)
+		}
 	}
-	return path
 }
 
 // dir makes a good-faith attempt to return the directory
diff --git a/src/cmd/compile/internal/types2/testdata/importdecl0/importdecl0b.src b/src/cmd/compile/internal/types2/testdata/importdecl0/importdecl0b.src
index 48ecb5e46f..19b55aff76 100644
--- a/src/cmd/compile/internal/types2/testdata/importdecl0/importdecl0b.src
+++ b/src/cmd/compile/internal/types2/testdata/importdecl0/importdecl0b.src
@@ -8,7 +8,7 @@ import "math"
 import m "math"
 
 import . "testing" // declares T in file scope
-import . /* ERROR "imported but not used" */ "unsafe"
+import . /* ERROR .unsafe. imported but not used */ "unsafe"
 import . "fmt"     // declares Println in file scope
 
 import (
diff --git a/src/cmd/compile/internal/types2/testdata/importdecl1/importdecl1b.src b/src/cmd/compile/internal/types2/testdata/importdecl1/importdecl1b.src
index ee70bbd8e7..43a7bcd753 100644
--- a/src/cmd/compile/internal/types2/testdata/importdecl1/importdecl1b.src
+++ b/src/cmd/compile/internal/types2/testdata/importdecl1/importdecl1b.src
@@ -4,7 +4,7 @@
 
 package importdecl1
 
-import . /* ERROR "imported but not used" */ "unsafe"
+import . /* ERROR .unsafe. imported but not used */ "unsafe"
 
 type B interface {
 	A
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 9ab84b594b..b758c0f358 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -56,12 +56,12 @@ func (check *Checker) ident(x *operand, e *syntax.Name, def *Named, wantType boo
 	}
 	assert(typ != nil)
 
-	// The object may be dot-imported: If so, remove its package from
-	// the map of unused dot imports for the respective file scope.
+	// The object may have been dot-imported.
+	// If so, mark the respective package as used.
 	// (This code is only needed for dot-imports. Without them,
 	// we only have to mark variables, see *Var case below).
-	if pkg := obj.Pkg(); pkg != check.pkg && pkg != nil {
-		delete(check.unusedDotImports[scope], pkg)
+	if pkgName := check.dotImportMap[dotImportKey{scope, obj}]; pkgName != nil {
+		pkgName.used = true
 	}
 
 	switch obj := obj.(type) {
diff --git a/test/run.go b/test/run.go
index a1c68494c3..8b487aa76f 100644
--- a/test/run.go
+++ b/test/run.go
@@ -1956,7 +1956,6 @@ var excluded = map[string]bool{
 	"fixedbugs/issue18331.go":  true, // missing error about misuse of //go:noescape (irgen needs code from noder)
 	"fixedbugs/issue18393.go":  true, // types2 not run after syntax errors
 	"fixedbugs/issue19012.go":  true, // multiple errors on same line
-	"fixedbugs/issue20298.go":  true, // types2 non-deterministically reports unused imports
 	"fixedbugs/issue20233.go":  true, // types2 reports two instead of one error (pref: compiler)
 	"fixedbugs/issue20245.go":  true, // types2 reports two instead of one error (pref: compiler)
 	"fixedbugs/issue20250.go":  true, // correct diagnostics, but different lines (probably irgen's fault)
-- 
GitLab


From 667e08ba8ccce4c00b0cde4a777030167295faf9 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Wed, 14 Oct 2020 13:05:33 -0400
Subject: [PATCH 0574/2400] [dev.regabi] cmd/go: Use GOMAXPROCS to limit
 default build, compile parallelism

When people want deterministic/single-process builds, they probably
assume that GOMAXPROCS=1 will do that.  It currently does not,
neither for build parallelism nor for compiler internal parallelism.
(Current incantation for that is "go build -p=1 -gcflags=all=-c=1 ... ")

This CL makes
  "GOMAXPROCS=1 go build ..."
behave like
  "go build -p=1 -gcflags=all=-c=1 ... "

RELNOTE=yes

Change-Id: I9cfe50b7deee7334d2f1057b58385f6c98547b9f
Reviewed-on: https://go-review.googlesource.com/c/go/+/284695
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
---
 src/cmd/go/alldocs.go             |  2 +-
 src/cmd/go/internal/cfg/cfg.go    | 24 ++++++++++++------------
 src/cmd/go/internal/work/build.go |  2 +-
 src/cmd/go/internal/work/gc.go    | 17 ++++++++++-------
 4 files changed, 24 insertions(+), 21 deletions(-)

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index 49d390297c..da06e831ae 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -111,7 +111,7 @@
 // 	-p n
 // 		the number of programs, such as build commands or
 // 		test binaries, that can be run in parallel.
-// 		The default is the number of CPUs available.
+// 		The default is GOMAXPROCS, normally the number of CPUs available.
 // 	-race
 // 		enable data race detection.
 // 		Supported only on linux/amd64, freebsd/amd64, darwin/amd64, windows/amd64,
diff --git a/src/cmd/go/internal/cfg/cfg.go b/src/cmd/go/internal/cfg/cfg.go
index c48904eacc..322247962f 100644
--- a/src/cmd/go/internal/cfg/cfg.go
+++ b/src/cmd/go/internal/cfg/cfg.go
@@ -28,18 +28,18 @@ var (
 	BuildA                 bool   // -a flag
 	BuildBuildmode         string // -buildmode flag
 	BuildContext           = defaultContext()
-	BuildMod               string             // -mod flag
-	BuildModExplicit       bool               // whether -mod was set explicitly
-	BuildModReason         string             // reason -mod was set, if set by default
-	BuildI                 bool               // -i flag
-	BuildLinkshared        bool               // -linkshared flag
-	BuildMSan              bool               // -msan flag
-	BuildN                 bool               // -n flag
-	BuildO                 string             // -o flag
-	BuildP                 = runtime.NumCPU() // -p flag
-	BuildPkgdir            string             // -pkgdir flag
-	BuildRace              bool               // -race flag
-	BuildToolexec          []string           // -toolexec flag
+	BuildMod               string                  // -mod flag
+	BuildModExplicit       bool                    // whether -mod was set explicitly
+	BuildModReason         string                  // reason -mod was set, if set by default
+	BuildI                 bool                    // -i flag
+	BuildLinkshared        bool                    // -linkshared flag
+	BuildMSan              bool                    // -msan flag
+	BuildN                 bool                    // -n flag
+	BuildO                 string                  // -o flag
+	BuildP                 = runtime.GOMAXPROCS(0) // -p flag
+	BuildPkgdir            string                  // -pkgdir flag
+	BuildRace              bool                    // -race flag
+	BuildToolexec          []string                // -toolexec flag
 	BuildToolchainName     string
 	BuildToolchainCompiler func() string
 	BuildToolchainLinker   func() string
diff --git a/src/cmd/go/internal/work/build.go b/src/cmd/go/internal/work/build.go
index 780d639c5d..0e7af6d33f 100644
--- a/src/cmd/go/internal/work/build.go
+++ b/src/cmd/go/internal/work/build.go
@@ -71,7 +71,7 @@ and test commands:
 	-p n
 		the number of programs, such as build commands or
 		test binaries, that can be run in parallel.
-		The default is the number of CPUs available.
+		The default is GOMAXPROCS, normally the number of CPUs available.
 	-race
 		enable data race detection.
 		Supported only on linux/amd64, freebsd/amd64, darwin/amd64, windows/amd64,
diff --git a/src/cmd/go/internal/work/gc.go b/src/cmd/go/internal/work/gc.go
index 3205fcbffc..2087855b3c 100644
--- a/src/cmd/go/internal/work/gc.go
+++ b/src/cmd/go/internal/work/gc.go
@@ -239,16 +239,19 @@ CheckFlags:
 	//   - it has no successor packages to compile (usually package main)
 	//   - all paths through the build graph pass through it
 	//   - critical path scheduling says it is high priority
-	// and in such a case, set c to runtime.NumCPU.
+	// and in such a case, set c to runtime.GOMAXPROCS(0).
+	// By default this is the same as runtime.NumCPU.
 	// We do this now when p==1.
+	// To limit parallelism, set GOMAXPROCS below numCPU; this may be useful
+	// on a low-memory builder, or if a deterministic build order is required.
+	c := runtime.GOMAXPROCS(0)
 	if cfg.BuildP == 1 {
-		// No process parallelism. Max out c.
-		return runtime.NumCPU()
+		// No process parallelism, do not cap compiler parallelism.
+		return c
 	}
-	// Some process parallelism. Set c to min(4, numcpu).
-	c := 4
-	if ncpu := runtime.NumCPU(); ncpu < c {
-		c = ncpu
+	// Some process parallelism. Set c to min(4, maxprocs).
+	if c > 4 {
+		c = 4
 	}
 	return c
 }
-- 
GitLab


From aca22bddf231c862a1d6c9d8af8eed804c329d22 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Tue, 26 Jan 2021 19:33:34 -0500
Subject: [PATCH 0575/2400] [dev.regabi] cmd/compile: remove nested functions
 from expands_calls.go

Replace nested function spaghetti with state object and methods.
Still somewhat complex, but a bit more explicit.

Change-Id: I21987c8e4be75821faa5a248af05d2095cdfb0d9
Reviewed-on: https://go-review.googlesource.com/c/go/+/287132
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/expand_calls.go | 1225 +++++++++---------
 1 file changed, 618 insertions(+), 607 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index d89d743703..579818e4f3 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -28,655 +28,666 @@ func isBlockMultiValueExit(b *Block) bool {
 	return (b.Kind == BlockRet || b.Kind == BlockRetJmp) && len(b.Controls) > 0 && b.Controls[0].Op == OpMakeResult
 }
 
-// expandCalls converts LE (Late Expansion) calls that act like they receive value args into a lower-level form
-// that is more oriented to a platform's ABI.  The SelectN operations that extract results are rewritten into
-// more appropriate forms, and any StructMake or ArrayMake inputs are decomposed until non-struct values are
-// reached.  On the callee side, OpArg nodes are not decomposed until this phase is run.
-// TODO results should not be lowered until this phase.
-func expandCalls(f *Func) {
-	// Calls that need lowering have some number of inputs, including a memory input,
-	// and produce a tuple of (value1, value2, ..., mem) where valueK may or may not be SSA-able.
-
-	// With the current ABI those inputs need to be converted into stores to memory,
-	// rethreading the call's memory input to the first, and the new call now receiving the last.
-
-	// With the current ABI, the outputs need to be converted to loads, which will all use the call's
-	// memory output as their input.
-	debug := f.pass.debug > 0
-
-	if debug {
-		fmt.Printf("\nexpandsCalls(%s)\n", f.Name)
+// removeTrivialWrapperTypes unwraps layers of
+// struct { singleField SomeType } and [1]SomeType
+// until a non-wrapper type is reached.  This is useful
+// for working with assignments to/from interface data
+// fields (either second operand to OpIMake or OpIData)
+// where the wrapping or type conversion can be elided
+// because of type conversions/assertions in source code
+// that do not appear in SSA.
+func removeTrivialWrapperTypes(t *types.Type) *types.Type {
+	for {
+		if t.IsStruct() && t.NumFields() == 1 {
+			t = t.Field(0).Type
+			continue
+		}
+		if t.IsArray() && t.NumElem() == 1 {
+			t = t.Elem()
+			continue
+		}
+		break
 	}
+	return t
+}
 
-	canSSAType := f.fe.CanSSA
-	regSize := f.Config.RegSize
-	sp, _ := f.spSb()
-	typ := &f.Config.Types
-	ptrSize := f.Config.PtrSize
+type expandState struct {
+	f            *Func
+	debug        bool
+	canSSAType   func(*types.Type) bool
+	regSize      int64
+	sp           *Value
+	typs         *Types
+	ptrSize      int64
+	hiOffset     int64
+	lowOffset    int64
+	namedSelects map[*Value][]namedVal
+	sdom         SparseTree
+	common       map[selKey]*Value
+	offsets      map[offsetKey]*Value
+}
 
-	// For 32-bit, need to deal with decomposition of 64-bit integers, which depends on endianness.
-	var hiOffset, lowOffset int64
-	if f.Config.BigEndian {
-		lowOffset = 4
-	} else {
-		hiOffset = 4
+// intPairTypes returns the pair of 32-bit int types needed to encode a 64-bit integer type on a target
+// that has no 64-bit integer registers.
+func (x *expandState) intPairTypes(et types.Kind) (tHi, tLo *types.Type) {
+	tHi = x.typs.UInt32
+	if et == types.TINT64 {
+		tHi = x.typs.Int32
 	}
+	tLo = x.typs.UInt32
+	return
+}
 
-	namedSelects := make(map[*Value][]namedVal)
-
-	sdom := f.Sdom()
-
-	common := make(map[selKey]*Value)
-
-	// intPairTypes returns the pair of 32-bit int types needed to encode a 64-bit integer type on a target
-	// that has no 64-bit integer registers.
-	intPairTypes := func(et types.Kind) (tHi, tLo *types.Type) {
-		tHi = typ.UInt32
-		if et == types.TINT64 {
-			tHi = typ.Int32
-		}
-		tLo = typ.UInt32
-		return
+// isAlreadyExpandedAggregateType returns whether a type is an SSA-able "aggregate" (multiple register) type
+// that was expanded in an earlier phase (currently, expand_calls is intended to run after decomposeBuiltin,
+// so this is all aggregate types -- small struct and array, complex, interface, string, slice, and 64-bit
+// integer on 32-bit).
+func (x *expandState) isAlreadyExpandedAggregateType(t *types.Type) bool {
+	if !x.canSSAType(t) {
+		return false
 	}
+	return t.IsStruct() || t.IsArray() || t.IsComplex() || t.IsInterface() || t.IsString() || t.IsSlice() ||
+		t.Size() > x.regSize && t.IsInteger()
+}
 
-	// isAlreadyExpandedAggregateType returns whether a type is an SSA-able "aggregate" (multiple register) type
-	// that was expanded in an earlier phase (currently, expand_calls is intended to run after decomposeBuiltin,
-	// so this is all aggregate types -- small struct and array, complex, interface, string, slice, and 64-bit
-	// integer on 32-bit).
-	isAlreadyExpandedAggregateType := func(t *types.Type) bool {
-		if !canSSAType(t) {
-			return false
-		}
-		return t.IsStruct() || t.IsArray() || t.IsComplex() || t.IsInterface() || t.IsString() || t.IsSlice() ||
-			t.Size() > regSize && t.IsInteger()
+// offsetFrom creates an offset from a pointer, simplifying chained offsets and offsets from SP
+// TODO should also optimize offsets from SB?
+func (x *expandState) offsetFrom(from *Value, offset int64, pt *types.Type) *Value {
+	if offset == 0 && from.Type == pt { // this is not actually likely
+		return from
 	}
-
-	offsets := make(map[offsetKey]*Value)
-
-	// offsetFrom creates an offset from a pointer, simplifying chained offsets and offsets from SP
-	// TODO should also optimize offsets from SB?
-	offsetFrom := func(from *Value, offset int64, pt *types.Type) *Value {
-		if offset == 0 && from.Type == pt { // this is not actually likely
-			return from
-		}
-		// Simplify, canonicalize
-		for from.Op == OpOffPtr {
-			offset += from.AuxInt
-			from = from.Args[0]
-		}
-		if from == sp {
-			return f.ConstOffPtrSP(pt, offset, sp)
-		}
-		key := offsetKey{from, offset, pt}
-		v := offsets[key]
-		if v != nil {
-			return v
-		}
-		v = from.Block.NewValue1I(from.Pos.WithNotStmt(), OpOffPtr, pt, offset, from)
-		offsets[key] = v
+	// Simplify, canonicalize
+	for from.Op == OpOffPtr {
+		offset += from.AuxInt
+		from = from.Args[0]
+	}
+	if from == x.sp {
+		return x.f.ConstOffPtrSP(pt, offset, x.sp)
+	}
+	key := offsetKey{from, offset, pt}
+	v := x.offsets[key]
+	if v != nil {
 		return v
 	}
+	v = from.Block.NewValue1I(from.Pos.WithNotStmt(), OpOffPtr, pt, offset, from)
+	x.offsets[key] = v
+	return v
+}
 
-	// splitSlots splits one "field" (specified by sfx, offset, and ty) out of the LocalSlots in ls and returns the new LocalSlots this generates.
-	splitSlots := func(ls []LocalSlot, sfx string, offset int64, ty *types.Type) []LocalSlot {
-		var locs []LocalSlot
-		for i := range ls {
-			locs = append(locs, f.fe.SplitSlot(&ls[i], sfx, offset, ty))
-		}
-		return locs
+// splitSlots splits one "field" (specified by sfx, offset, and ty) out of the LocalSlots in ls and returns the new LocalSlots this generates.
+func (x *expandState) splitSlots(ls []LocalSlot, sfx string, offset int64, ty *types.Type) []LocalSlot {
+	var locs []LocalSlot
+	for i := range ls {
+		locs = append(locs, x.f.fe.SplitSlot(&ls[i], sfx, offset, ty))
 	}
+	return locs
+}
 
-	// removeTrivialWrapperTypes unwraps layers of
-	// struct { singleField SomeType } and [1]SomeType
-	// until a non-wrapper type is reached.  This is useful
-	// for working with assignments to/from interface data
-	// fields (either second operand to OpIMake or OpIData)
-	// where the wrapping or type conversion can be elided
-	// because of type conversions/assertions in source code
-	// that do not appear in SSA.
-	removeTrivialWrapperTypes := func(t *types.Type) *types.Type {
-		for {
-			if t.IsStruct() && t.NumFields() == 1 {
-				t = t.Field(0).Type
-				continue
-			}
-			if t.IsArray() && t.NumElem() == 1 {
-				t = t.Elem()
-				continue
-			}
-			break
-		}
-		return t
+// Calls that need lowering have some number of inputs, including a memory input,
+// and produce a tuple of (value1, value2, ..., mem) where valueK may or may not be SSA-able.
+
+// With the current ABI those inputs need to be converted into stores to memory,
+// rethreading the call's memory input to the first, and the new call now receiving the last.
+
+// With the current ABI, the outputs need to be converted to loads, which will all use the call's
+// memory output as their input.
+
+// rewriteSelect recursively walks from leaf selector to a root (OpSelectN, OpLoad, OpArg)
+// through a chain of Struct/Array/builtin Select operations.  If the chain of selectors does not
+// end in an expected root, it does nothing (this can happen depending on compiler phase ordering).
+// The "leaf" provides the type, the root supplies the container, and the leaf-to-root path
+// accumulates the offset.
+// It emits the code necessary to implement the leaf select operation that leads to the root.
+//
+// TODO when registers really arrive, must also decompose anything split across two registers or registers and memory.
+func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64) []LocalSlot {
+	if x.debug {
+		fmt.Printf("rewriteSelect(%s, %s, %d)\n", leaf.LongString(), selector.LongString(), offset)
 	}
-
-	// Calls that need lowering have some number of inputs, including a memory input,
-	// and produce a tuple of (value1, value2, ..., mem) where valueK may or may not be SSA-able.
-
-	// With the current ABI those inputs need to be converted into stores to memory,
-	// rethreading the call's memory input to the first, and the new call now receiving the last.
-
-	// With the current ABI, the outputs need to be converted to loads, which will all use the call's
-	// memory output as their input.
-
-	// rewriteSelect recursively walks from leaf selector to a root (OpSelectN, OpLoad, OpArg)
-	// through a chain of Struct/Array/builtin Select operations.  If the chain of selectors does not
-	// end in an expected root, it does nothing (this can happen depending on compiler phase ordering).
-	// The "leaf" provides the type, the root supplies the container, and the leaf-to-root path
-	// accumulates the offset.
-	// It emits the code necessary to implement the leaf select operation that leads to the root.
-	//
-	// TODO when registers really arrive, must also decompose anything split across two registers or registers and memory.
-	var rewriteSelect func(leaf *Value, selector *Value, offset int64) []LocalSlot
-	rewriteSelect = func(leaf *Value, selector *Value, offset int64) []LocalSlot {
-		if debug {
-			fmt.Printf("rewriteSelect(%s, %s, %d)\n", leaf.LongString(), selector.LongString(), offset)
-		}
-		var locs []LocalSlot
-		leafType := leaf.Type
-		if len(selector.Args) > 0 {
-			w := selector.Args[0]
-			if w.Op == OpCopy {
-				for w.Op == OpCopy {
-					w = w.Args[0]
-				}
-				selector.SetArg(0, w)
+	var locs []LocalSlot
+	leafType := leaf.Type
+	if len(selector.Args) > 0 {
+		w := selector.Args[0]
+		if w.Op == OpCopy {
+			for w.Op == OpCopy {
+				w = w.Args[0]
 			}
+			selector.SetArg(0, w)
 		}
-		switch selector.Op {
-		case OpArg:
-			if !isAlreadyExpandedAggregateType(selector.Type) {
-				if leafType == selector.Type { // OpIData leads us here, sometimes.
-					leaf.copyOf(selector)
-				} else {
-					f.Fatalf("Unexpected OpArg type, selector=%s, leaf=%s\n", selector.LongString(), leaf.LongString())
-				}
-				if debug {
-					fmt.Printf("\tOpArg, break\n")
-				}
-				break
-			}
-			switch leaf.Op {
-			case OpIData, OpStructSelect, OpArraySelect:
-				leafType = removeTrivialWrapperTypes(leaf.Type)
-			}
-			aux := selector.Aux
-			auxInt := selector.AuxInt + offset
-			if leaf.Block == selector.Block {
-				leaf.reset(OpArg)
-				leaf.Aux = aux
-				leaf.AuxInt = auxInt
-				leaf.Type = leafType
+	}
+	switch selector.Op {
+	case OpArg:
+		if !x.isAlreadyExpandedAggregateType(selector.Type) {
+			if leafType == selector.Type { // OpIData leads us here, sometimes.
+				leaf.copyOf(selector)
 			} else {
-				w := selector.Block.NewValue0IA(leaf.Pos, OpArg, leafType, auxInt, aux)
-				leaf.copyOf(w)
-				if debug {
-					fmt.Printf("\tnew %s\n", w.LongString())
-				}
+				x.f.Fatalf("Unexpected OpArg type, selector=%s, leaf=%s\n", selector.LongString(), leaf.LongString())
 			}
-			for _, s := range namedSelects[selector] {
-				locs = append(locs, f.Names[s.locIndex])
+			if x.debug {
+				fmt.Printf("\tOpArg, break\n")
 			}
-
-		case OpLoad: // We end up here because of IData of immediate structures.
-			// Failure case:
-			// (note the failure case is very rare; w/o this case, make.bash and run.bash both pass, as well as
-			// the hard cases of building {syscall,math,math/cmplx,math/bits,go/constant} on ppc64le and mips-softfloat).
-			//
-			// GOSSAFUNC='(*dumper).dump' go build -gcflags=-l -tags=math_big_pure_go cmd/compile/internal/gc
-			// cmd/compile/internal/gc/dump.go:136:14: internal compiler error: '(*dumper).dump': not lowered: v827, StructSelect PTR PTR
-			// b2: ← b1
-			// v20 (+142) = StaticLECall <interface {},mem> {AuxCall{reflect.Value.Interface([reflect.Value,0])[interface {},24]}} [40] v8 v1
-			// v21 (142) = SelectN <mem> [1] v20
-			// v22 (142) = SelectN <interface {}> [0] v20
-			// b15: ← b8
-			// v71 (+143) = IData <Nodes> v22 (v[Nodes])
-			// v73 (+146) = StaticLECall <[]*Node,mem> {AuxCall{"".Nodes.Slice([Nodes,0])[[]*Node,8]}} [32] v71 v21
-			//
-			// translates (w/o the "case OpLoad:" above) to:
-			//
-			// b2: ← b1
-			// v20 (+142) = StaticCall <mem> {AuxCall{reflect.Value.Interface([reflect.Value,0])[interface {},24]}} [40] v715
-			// v23 (142) = Load <*uintptr> v19 v20
-			// v823 (142) = IsNonNil <bool> v23
-			// v67 (+143) = Load <*[]*Node> v880 v20
-			// b15: ← b8
-			// v827 (146) = StructSelect <*[]*Node> [0] v67
-			// v846 (146) = Store <mem> {*[]*Node} v769 v827 v20
-			// v73 (+146) = StaticCall <mem> {AuxCall{"".Nodes.Slice([Nodes,0])[[]*Node,8]}} [32] v846
-			// i.e., the struct select is generated and remains in because it is not applied to an actual structure.
-			// The OpLoad was created to load the single field of the IData
-			// This case removes that StructSelect.
-			if leafType != selector.Type {
-				f.Fatalf("Unexpected Load as selector, leaf=%s, selector=%s\n", leaf.LongString(), selector.LongString())
-			}
-			leaf.copyOf(selector)
-			for _, s := range namedSelects[selector] {
-				locs = append(locs, f.Names[s.locIndex])
+			break
+		}
+		switch leaf.Op {
+		case OpIData, OpStructSelect, OpArraySelect:
+			leafType = removeTrivialWrapperTypes(leaf.Type)
+		}
+		aux := selector.Aux
+		auxInt := selector.AuxInt + offset
+		if leaf.Block == selector.Block {
+			leaf.reset(OpArg)
+			leaf.Aux = aux
+			leaf.AuxInt = auxInt
+			leaf.Type = leafType
+		} else {
+			w := selector.Block.NewValue0IA(leaf.Pos, OpArg, leafType, auxInt, aux)
+			leaf.copyOf(w)
+			if x.debug {
+				fmt.Printf("\tnew %s\n", w.LongString())
 			}
+		}
+		for _, s := range x.namedSelects[selector] {
+			locs = append(locs, x.f.Names[s.locIndex])
+		}
 
-		case OpSelectN:
-			// TODO these may be duplicated. Should memoize. Intermediate selectors will go dead, no worries there.
-			call := selector.Args[0]
-			aux := call.Aux.(*AuxCall)
-			which := selector.AuxInt
-			if which == aux.NResults() { // mem is after the results.
-				// rewrite v as a Copy of call -- the replacement call will produce a mem.
-				leaf.copyOf(call)
-			} else {
-				leafType := removeTrivialWrapperTypes(leaf.Type)
-				if canSSAType(leafType) {
-					pt := types.NewPtr(leafType)
-					off := offsetFrom(sp, offset+aux.OffsetOfResult(which), pt)
-					// Any selection right out of the arg area/registers has to be same Block as call, use call as mem input.
-					if leaf.Block == call.Block {
-						leaf.reset(OpLoad)
-						leaf.SetArgs2(off, call)
-						leaf.Type = leafType
-					} else {
-						w := call.Block.NewValue2(leaf.Pos, OpLoad, leafType, off, call)
-						leaf.copyOf(w)
-						if debug {
-							fmt.Printf("\tnew %s\n", w.LongString())
-						}
-					}
-					for _, s := range namedSelects[selector] {
-						locs = append(locs, f.Names[s.locIndex])
-					}
+	case OpLoad: // We end up here because of IData of immediate structures.
+		// Failure case:
+		// (note the failure case is very rare; w/o this case, make.bash and run.bash both pass, as well as
+		// the hard cases of building {syscall,math,math/cmplx,math/bits,go/constant} on ppc64le and mips-softfloat).
+		//
+		// GOSSAFUNC='(*dumper).dump' go build -gcflags=-l -tags=math_big_pure_go cmd/compile/internal/gc
+		// cmd/compile/internal/gc/dump.go:136:14: internal compiler error: '(*dumper).dump': not lowered: v827, StructSelect PTR PTR
+		// b2: ← b1
+		// v20 (+142) = StaticLECall <interface {},mem> {AuxCall{reflect.Value.Interface([reflect.Value,0])[interface {},24]}} [40] v8 v1
+		// v21 (142) = SelectN <mem> [1] v20
+		// v22 (142) = SelectN <interface {}> [0] v20
+		// b15: ← b8
+		// v71 (+143) = IData <Nodes> v22 (v[Nodes])
+		// v73 (+146) = StaticLECall <[]*Node,mem> {AuxCall{"".Nodes.Slice([Nodes,0])[[]*Node,8]}} [32] v71 v21
+		//
+		// translates (w/o the "case OpLoad:" above) to:
+		//
+		// b2: ← b1
+		// v20 (+142) = StaticCall <mem> {AuxCall{reflect.Value.Interface([reflect.Value,0])[interface {},24]}} [40] v715
+		// v23 (142) = Load <*uintptr> v19 v20
+		// v823 (142) = IsNonNil <bool> v23
+		// v67 (+143) = Load <*[]*Node> v880 v20
+		// b15: ← b8
+		// v827 (146) = StructSelect <*[]*Node> [0] v67
+		// v846 (146) = Store <mem> {*[]*Node} v769 v827 v20
+		// v73 (+146) = StaticCall <mem> {AuxCall{"".Nodes.Slice([Nodes,0])[[]*Node,8]}} [32] v846
+		// i.e., the struct select is generated and remains in because it is not applied to an actual structure.
+		// The OpLoad was created to load the single field of the IData
+		// This case removes that StructSelect.
+		if leafType != selector.Type {
+			x.f.Fatalf("Unexpected Load as selector, leaf=%s, selector=%s\n", leaf.LongString(), selector.LongString())
+		}
+		leaf.copyOf(selector)
+		for _, s := range x.namedSelects[selector] {
+			locs = append(locs, x.f.Names[s.locIndex])
+		}
+
+	case OpSelectN:
+		// TODO these may be duplicated. Should memoize. Intermediate selectors will go dead, no worries there.
+		call := selector.Args[0]
+		aux := call.Aux.(*AuxCall)
+		which := selector.AuxInt
+		if which == aux.NResults() { // mem is after the results.
+			// rewrite v as a Copy of call -- the replacement call will produce a mem.
+			leaf.copyOf(call)
+		} else {
+			leafType := removeTrivialWrapperTypes(leaf.Type)
+			if x.canSSAType(leafType) {
+				pt := types.NewPtr(leafType)
+				off := x.offsetFrom(x.sp, offset+aux.OffsetOfResult(which), pt)
+				// Any selection right out of the arg area/registers has to be same Block as call, use call as mem input.
+				if leaf.Block == call.Block {
+					leaf.reset(OpLoad)
+					leaf.SetArgs2(off, call)
+					leaf.Type = leafType
 				} else {
-					f.Fatalf("Should not have non-SSA-able OpSelectN, selector=%s", selector.LongString())
+					w := call.Block.NewValue2(leaf.Pos, OpLoad, leafType, off, call)
+					leaf.copyOf(w)
+					if x.debug {
+						fmt.Printf("\tnew %s\n", w.LongString())
+					}
+				}
+				for _, s := range x.namedSelects[selector] {
+					locs = append(locs, x.f.Names[s.locIndex])
 				}
+			} else {
+				x.f.Fatalf("Should not have non-SSA-able OpSelectN, selector=%s", selector.LongString())
 			}
+		}
 
-		case OpStructSelect:
-			w := selector.Args[0]
-			var ls []LocalSlot
-			if w.Type.Kind() != types.TSTRUCT { // IData artifact
-				ls = rewriteSelect(leaf, w, offset)
-			} else {
-				ls = rewriteSelect(leaf, w, offset+w.Type.FieldOff(int(selector.AuxInt)))
-				if w.Op != OpIData {
-					for _, l := range ls {
-						locs = append(locs, f.fe.SplitStruct(l, int(selector.AuxInt)))
-					}
+	case OpStructSelect:
+		w := selector.Args[0]
+		var ls []LocalSlot
+		if w.Type.Kind() != types.TSTRUCT { // IData artifact
+			ls = x.rewriteSelect(leaf, w, offset)
+		} else {
+			ls = x.rewriteSelect(leaf, w, offset+w.Type.FieldOff(int(selector.AuxInt)))
+			if w.Op != OpIData {
+				for _, l := range ls {
+					locs = append(locs, x.f.fe.SplitStruct(l, int(selector.AuxInt)))
 				}
 			}
+		}
 
-		case OpArraySelect:
-			w := selector.Args[0]
-			rewriteSelect(leaf, w, offset+selector.Type.Size()*selector.AuxInt)
-
-		case OpInt64Hi:
-			w := selector.Args[0]
-			ls := rewriteSelect(leaf, w, offset+hiOffset)
-			locs = splitSlots(ls, ".hi", hiOffset, leafType)
-
-		case OpInt64Lo:
-			w := selector.Args[0]
-			ls := rewriteSelect(leaf, w, offset+lowOffset)
-			locs = splitSlots(ls, ".lo", lowOffset, leafType)
-
-		case OpStringPtr:
-			ls := rewriteSelect(leaf, selector.Args[0], offset)
-			locs = splitSlots(ls, ".ptr", 0, typ.BytePtr)
-
-		case OpSlicePtr:
-			w := selector.Args[0]
-			ls := rewriteSelect(leaf, w, offset)
-			locs = splitSlots(ls, ".ptr", 0, types.NewPtr(w.Type.Elem()))
-
-		case OpITab:
-			w := selector.Args[0]
-			ls := rewriteSelect(leaf, w, offset)
-			sfx := ".itab"
-			if w.Type.IsEmptyInterface() {
-				sfx = ".type"
-			}
-			locs = splitSlots(ls, sfx, 0, typ.Uintptr)
+	case OpArraySelect:
+		w := selector.Args[0]
+		x.rewriteSelect(leaf, w, offset+selector.Type.Size()*selector.AuxInt)
+
+	case OpInt64Hi:
+		w := selector.Args[0]
+		ls := x.rewriteSelect(leaf, w, offset+x.hiOffset)
+		locs = x.splitSlots(ls, ".hi", x.hiOffset, leafType)
+
+	case OpInt64Lo:
+		w := selector.Args[0]
+		ls := x.rewriteSelect(leaf, w, offset+x.lowOffset)
+		locs = x.splitSlots(ls, ".lo", x.lowOffset, leafType)
+
+	case OpStringPtr:
+		ls := x.rewriteSelect(leaf, selector.Args[0], offset)
+		locs = x.splitSlots(ls, ".ptr", 0, x.typs.BytePtr)
+
+	case OpSlicePtr:
+		w := selector.Args[0]
+		ls := x.rewriteSelect(leaf, w, offset)
+		locs = x.splitSlots(ls, ".ptr", 0, types.NewPtr(w.Type.Elem()))
+
+	case OpITab:
+		w := selector.Args[0]
+		ls := x.rewriteSelect(leaf, w, offset)
+		sfx := ".itab"
+		if w.Type.IsEmptyInterface() {
+			sfx = ".type"
+		}
+		locs = x.splitSlots(ls, sfx, 0, x.typs.Uintptr)
 
-		case OpComplexReal:
-			ls := rewriteSelect(leaf, selector.Args[0], offset)
-			locs = splitSlots(ls, ".real", 0, leafType)
+	case OpComplexReal:
+		ls := x.rewriteSelect(leaf, selector.Args[0], offset)
+		locs = x.splitSlots(ls, ".real", 0, leafType)
 
-		case OpComplexImag:
-			ls := rewriteSelect(leaf, selector.Args[0], offset+leafType.Width) // result is FloatNN, width of result is offset of imaginary part.
-			locs = splitSlots(ls, ".imag", leafType.Width, leafType)
+	case OpComplexImag:
+		ls := x.rewriteSelect(leaf, selector.Args[0], offset+leafType.Width) // result is FloatNN, width of result is offset of imaginary part.
+		locs = x.splitSlots(ls, ".imag", leafType.Width, leafType)
 
-		case OpStringLen, OpSliceLen:
-			ls := rewriteSelect(leaf, selector.Args[0], offset+ptrSize)
-			locs = splitSlots(ls, ".len", ptrSize, leafType)
+	case OpStringLen, OpSliceLen:
+		ls := x.rewriteSelect(leaf, selector.Args[0], offset+x.ptrSize)
+		locs = x.splitSlots(ls, ".len", x.ptrSize, leafType)
 
-		case OpIData:
-			ls := rewriteSelect(leaf, selector.Args[0], offset+ptrSize)
-			locs = splitSlots(ls, ".data", ptrSize, leafType)
+	case OpIData:
+		ls := x.rewriteSelect(leaf, selector.Args[0], offset+x.ptrSize)
+		locs = x.splitSlots(ls, ".data", x.ptrSize, leafType)
 
-		case OpSliceCap:
-			ls := rewriteSelect(leaf, selector.Args[0], offset+2*ptrSize)
-			locs = splitSlots(ls, ".cap", 2*ptrSize, leafType)
-
-		case OpCopy: // If it's an intermediate result, recurse
-			locs = rewriteSelect(leaf, selector.Args[0], offset)
-			for _, s := range namedSelects[selector] {
-				// this copy may have had its own name, preserve that, too.
-				locs = append(locs, f.Names[s.locIndex])
-			}
+	case OpSliceCap:
+		ls := x.rewriteSelect(leaf, selector.Args[0], offset+2*x.ptrSize)
+		locs = x.splitSlots(ls, ".cap", 2*x.ptrSize, leafType)
 
-		default:
-			// Ignore dead ends. These can occur if this phase is run before decompose builtin (which is not intended, but allowed).
+	case OpCopy: // If it's an intermediate result, recurse
+		locs = x.rewriteSelect(leaf, selector.Args[0], offset)
+		for _, s := range x.namedSelects[selector] {
+			// this copy may have had its own name, preserve that, too.
+			locs = append(locs, x.f.Names[s.locIndex])
 		}
 
-		return locs
+	default:
+		// Ignore dead ends. These can occur if this phase is run before decompose builtin (which is not intended, but allowed).
 	}
 
-	// storeArgOrLoad converts stores of SSA-able aggregate arguments (passed to a call) into a series of primitive-typed
-	// stores of non-aggregate types.  It recursively walks up a chain of selectors until it reaches a Load or an Arg.
-	// If it does not reach a Load or an Arg, nothing happens; this allows a little freedom in phase ordering.
-	var storeArgOrLoad func(pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offset int64) *Value
+	return locs
+}
 
-	// decomposeArgOrLoad is a helper for storeArgOrLoad.
-	// It decomposes a Load or an Arg into smaller parts, parameterized by the decomposeOne and decomposeTwo functions
-	// passed to it, and returns the new mem. If the type does not match one of the expected aggregate types, it returns nil instead.
-	decomposeArgOrLoad := func(pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offset int64,
-		decomposeOne func(pos src.XPos, b *Block, base, source, mem *Value, t1 *types.Type, offArg, offStore int64) *Value,
-		decomposeTwo func(pos src.XPos, b *Block, base, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64) *Value) *Value {
-		u := source.Type
-		switch u.Kind() {
-		case types.TARRAY:
-			elem := u.Elem()
-			for i := int64(0); i < u.NumElem(); i++ {
-				elemOff := i * elem.Size()
-				mem = decomposeOne(pos, b, base, source, mem, elem, source.AuxInt+elemOff, offset+elemOff)
-				pos = pos.WithNotStmt()
-			}
-			return mem
-		case types.TSTRUCT:
-			for i := 0; i < u.NumFields(); i++ {
-				fld := u.Field(i)
-				mem = decomposeOne(pos, b, base, source, mem, fld.Type, source.AuxInt+fld.Offset, offset+fld.Offset)
-				pos = pos.WithNotStmt()
-			}
-			return mem
-		case types.TINT64, types.TUINT64:
-			if t.Width == regSize {
-				break
-			}
-			tHi, tLo := intPairTypes(t.Kind())
-			mem = decomposeOne(pos, b, base, source, mem, tHi, source.AuxInt+hiOffset, offset+hiOffset)
+func (x *expandState) rewriteDereference(b *Block, base, a, mem *Value, offset, size int64, typ *types.Type, pos src.XPos) *Value {
+	source := a.Args[0]
+	dst := x.offsetFrom(base, offset, source.Type)
+	if a.Uses == 1 && a.Block == b {
+		a.reset(OpMove)
+		a.Pos = pos
+		a.Type = types.TypeMem
+		a.Aux = typ
+		a.AuxInt = size
+		a.SetArgs3(dst, source, mem)
+		mem = a
+	} else {
+		mem = b.NewValue3A(pos, OpMove, types.TypeMem, typ, dst, source, mem)
+		mem.AuxInt = size
+	}
+	return mem
+}
+
+// decomposeArgOrLoad is a helper for storeArgOrLoad.
+// It decomposes a Load or an Arg into smaller parts, parameterized by the decomposeOne and decomposeTwo functions
+// passed to it, and returns the new mem. If the type does not match one of the expected aggregate types, it returns nil instead.
+func (x *expandState) decomposeArgOrLoad(pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offset int64,
+	decomposeOne func(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t1 *types.Type, offArg, offStore int64) *Value,
+	decomposeTwo func(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64) *Value) *Value {
+	u := source.Type
+	switch u.Kind() {
+	case types.TARRAY:
+		elem := u.Elem()
+		for i := int64(0); i < u.NumElem(); i++ {
+			elemOff := i * elem.Size()
+			mem = decomposeOne(x, pos, b, base, source, mem, elem, source.AuxInt+elemOff, offset+elemOff)
 			pos = pos.WithNotStmt()
-			return decomposeOne(pos, b, base, source, mem, tLo, source.AuxInt+lowOffset, offset+lowOffset)
-		case types.TINTER:
-			return decomposeTwo(pos, b, base, source, mem, typ.Uintptr, typ.BytePtr, source.AuxInt, offset)
-		case types.TSTRING:
-			return decomposeTwo(pos, b, base, source, mem, typ.BytePtr, typ.Int, source.AuxInt, offset)
-		case types.TCOMPLEX64:
-			return decomposeTwo(pos, b, base, source, mem, typ.Float32, typ.Float32, source.AuxInt, offset)
-		case types.TCOMPLEX128:
-			return decomposeTwo(pos, b, base, source, mem, typ.Float64, typ.Float64, source.AuxInt, offset)
-		case types.TSLICE:
-			mem = decomposeTwo(pos, b, base, source, mem, typ.BytePtr, typ.Int, source.AuxInt, offset)
-			return decomposeOne(pos, b, base, source, mem, typ.Int, source.AuxInt+2*ptrSize, offset+2*ptrSize)
-		}
-		return nil
-	}
-
-	// storeOneArg creates a decomposed (one step) arg that is then stored.
-	// pos and b locate the store instruction, base is the base of the store target, source is the "base" of the value input,
-	// mem is the input mem, t is the type in question, and offArg and offStore are the offsets from the respective bases.
-	storeOneArg := func(pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offArg, offStore int64) *Value {
-		w := common[selKey{source, offArg, t.Width, t}]
-		if w == nil {
-			w = source.Block.NewValue0IA(source.Pos, OpArg, t, offArg, source.Aux)
-			common[selKey{source, offArg, t.Width, t}] = w
-		}
-		return storeArgOrLoad(pos, b, base, w, mem, t, offStore)
-	}
-
-	// storeOneLoad creates a decomposed (one step) load that is then stored.
-	storeOneLoad := func(pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offArg, offStore int64) *Value {
-		from := offsetFrom(source.Args[0], offArg, types.NewPtr(t))
-		w := source.Block.NewValue2(source.Pos, OpLoad, t, from, mem)
-		return storeArgOrLoad(pos, b, base, w, mem, t, offStore)
-	}
-
-	storeTwoArg := func(pos src.XPos, b *Block, base, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64) *Value {
-		mem = storeOneArg(pos, b, base, source, mem, t1, offArg, offStore)
+		}
+		return mem
+	case types.TSTRUCT:
+		for i := 0; i < u.NumFields(); i++ {
+			fld := u.Field(i)
+			mem = decomposeOne(x, pos, b, base, source, mem, fld.Type, source.AuxInt+fld.Offset, offset+fld.Offset)
+			pos = pos.WithNotStmt()
+		}
+		return mem
+	case types.TINT64, types.TUINT64:
+		if t.Width == x.regSize {
+			break
+		}
+		tHi, tLo := x.intPairTypes(t.Kind())
+		mem = decomposeOne(x, pos, b, base, source, mem, tHi, source.AuxInt+x.hiOffset, offset+x.hiOffset)
 		pos = pos.WithNotStmt()
-		t1Size := t1.Size()
-		return storeOneArg(pos, b, base, source, mem, t2, offArg+t1Size, offStore+t1Size)
+		return decomposeOne(x, pos, b, base, source, mem, tLo, source.AuxInt+x.lowOffset, offset+x.lowOffset)
+	case types.TINTER:
+		return decomposeTwo(x, pos, b, base, source, mem, x.typs.Uintptr, x.typs.BytePtr, source.AuxInt, offset)
+	case types.TSTRING:
+		return decomposeTwo(x, pos, b, base, source, mem, x.typs.BytePtr, x.typs.Int, source.AuxInt, offset)
+	case types.TCOMPLEX64:
+		return decomposeTwo(x, pos, b, base, source, mem, x.typs.Float32, x.typs.Float32, source.AuxInt, offset)
+	case types.TCOMPLEX128:
+		return decomposeTwo(x, pos, b, base, source, mem, x.typs.Float64, x.typs.Float64, source.AuxInt, offset)
+	case types.TSLICE:
+		mem = decomposeTwo(x, pos, b, base, source, mem, x.typs.BytePtr, x.typs.Int, source.AuxInt, offset)
+		return decomposeOne(x, pos, b, base, source, mem, x.typs.Int, source.AuxInt+2*x.ptrSize, offset+2*x.ptrSize)
 	}
+	return nil
+}
 
-	storeTwoLoad := func(pos src.XPos, b *Block, base, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64) *Value {
-		mem = storeOneLoad(pos, b, base, source, mem, t1, offArg, offStore)
-		pos = pos.WithNotStmt()
-		t1Size := t1.Size()
-		return storeOneLoad(pos, b, base, source, mem, t2, offArg+t1Size, offStore+t1Size)
+// storeOneArg creates a decomposed (one step) arg that is then stored.
+// pos and b locate the store instruction, base is the base of the store target, source is the "base" of the value input,
+// mem is the input mem, t is the type in question, and offArg and offStore are the offsets from the respective bases.
+func storeOneArg(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offArg, offStore int64) *Value {
+	w := x.common[selKey{source, offArg, t.Width, t}]
+	if w == nil {
+		w = source.Block.NewValue0IA(source.Pos, OpArg, t, offArg, source.Aux)
+		x.common[selKey{source, offArg, t.Width, t}] = w
 	}
+	return x.storeArgOrLoad(pos, b, base, w, mem, t, offStore)
+}
 
-	storeArgOrLoad = func(pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offset int64) *Value {
-		if debug {
-			fmt.Printf("\tstoreArgOrLoad(%s;  %s;  %s;  %s; %d)\n", base.LongString(), source.LongString(), mem.String(), t.String(), offset)
-		}
+// storeOneLoad creates a decomposed (one step) load that is then stored.
+func storeOneLoad(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offArg, offStore int64) *Value {
+	from := x.offsetFrom(source.Args[0], offArg, types.NewPtr(t))
+	w := source.Block.NewValue2(source.Pos, OpLoad, t, from, mem)
+	return x.storeArgOrLoad(pos, b, base, w, mem, t, offStore)
+}
 
-		switch source.Op {
-		case OpCopy:
-			return storeArgOrLoad(pos, b, base, source.Args[0], mem, t, offset)
+func storeTwoArg(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64) *Value {
+	mem = storeOneArg(x, pos, b, base, source, mem, t1, offArg, offStore)
+	pos = pos.WithNotStmt()
+	t1Size := t1.Size()
+	return storeOneArg(x, pos, b, base, source, mem, t2, offArg+t1Size, offStore+t1Size)
+}
 
-		case OpLoad:
-			ret := decomposeArgOrLoad(pos, b, base, source, mem, t, offset, storeOneLoad, storeTwoLoad)
-			if ret != nil {
-				return ret
-			}
+func storeTwoLoad(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64) *Value {
+	mem = storeOneLoad(x, pos, b, base, source, mem, t1, offArg, offStore)
+	pos = pos.WithNotStmt()
+	t1Size := t1.Size()
+	return storeOneLoad(x, pos, b, base, source, mem, t2, offArg+t1Size, offStore+t1Size)
+}
 
-		case OpArg:
-			ret := decomposeArgOrLoad(pos, b, base, source, mem, t, offset, storeOneArg, storeTwoArg)
-			if ret != nil {
-				return ret
-			}
+// storeArgOrLoad converts stores of SSA-able aggregate arguments (passed to a call) into a series of primitive-typed
+// stores of non-aggregate types.  It recursively walks up a chain of selectors until it reaches a Load or an Arg.
+// If it does not reach a Load or an Arg, nothing happens; this allows a little freedom in phase ordering.
+func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offset int64) *Value {
+	if x.debug {
+		fmt.Printf("\tstoreArgOrLoad(%s;  %s;  %s;  %s; %d)\n", base.LongString(), source.LongString(), mem.String(), t.String(), offset)
+	}
 
-		case OpArrayMake0, OpStructMake0:
-			return mem
+	switch source.Op {
+	case OpCopy:
+		return x.storeArgOrLoad(pos, b, base, source.Args[0], mem, t, offset)
 
-		case OpStructMake1, OpStructMake2, OpStructMake3, OpStructMake4:
-			for i := 0; i < t.NumFields(); i++ {
-				fld := t.Field(i)
-				mem = storeArgOrLoad(pos, b, base, source.Args[i], mem, fld.Type, offset+fld.Offset)
-				pos = pos.WithNotStmt()
-			}
-			return mem
+	case OpLoad:
+		ret := x.decomposeArgOrLoad(pos, b, base, source, mem, t, offset, storeOneLoad, storeTwoLoad)
+		if ret != nil {
+			return ret
+		}
 
-		case OpArrayMake1:
-			return storeArgOrLoad(pos, b, base, source.Args[0], mem, t.Elem(), offset)
+	case OpArg:
+		ret := x.decomposeArgOrLoad(pos, b, base, source, mem, t, offset, storeOneArg, storeTwoArg)
+		if ret != nil {
+			return ret
+		}
 
-		case OpInt64Make:
-			tHi, tLo := intPairTypes(t.Kind())
-			mem = storeArgOrLoad(pos, b, base, source.Args[0], mem, tHi, offset+hiOffset)
-			pos = pos.WithNotStmt()
-			return storeArgOrLoad(pos, b, base, source.Args[1], mem, tLo, offset+lowOffset)
+	case OpArrayMake0, OpStructMake0:
+		return mem
 
-		case OpComplexMake:
-			tPart := typ.Float32
-			wPart := t.Width / 2
-			if wPart == 8 {
-				tPart = typ.Float64
-			}
-			mem = storeArgOrLoad(pos, b, base, source.Args[0], mem, tPart, offset)
+	case OpStructMake1, OpStructMake2, OpStructMake3, OpStructMake4:
+		for i := 0; i < t.NumFields(); i++ {
+			fld := t.Field(i)
+			mem = x.storeArgOrLoad(pos, b, base, source.Args[i], mem, fld.Type, offset+fld.Offset)
 			pos = pos.WithNotStmt()
-			return storeArgOrLoad(pos, b, base, source.Args[1], mem, tPart, offset+wPart)
+		}
+		return mem
 
-		case OpIMake:
-			mem = storeArgOrLoad(pos, b, base, source.Args[0], mem, typ.Uintptr, offset)
-			pos = pos.WithNotStmt()
-			return storeArgOrLoad(pos, b, base, source.Args[1], mem, typ.BytePtr, offset+ptrSize)
+	case OpArrayMake1:
+		return x.storeArgOrLoad(pos, b, base, source.Args[0], mem, t.Elem(), offset)
 
-		case OpStringMake:
-			mem = storeArgOrLoad(pos, b, base, source.Args[0], mem, typ.BytePtr, offset)
-			pos = pos.WithNotStmt()
-			return storeArgOrLoad(pos, b, base, source.Args[1], mem, typ.Int, offset+ptrSize)
+	case OpInt64Make:
+		tHi, tLo := x.intPairTypes(t.Kind())
+		mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, tHi, offset+x.hiOffset)
+		pos = pos.WithNotStmt()
+		return x.storeArgOrLoad(pos, b, base, source.Args[1], mem, tLo, offset+x.lowOffset)
 
-		case OpSliceMake:
-			mem = storeArgOrLoad(pos, b, base, source.Args[0], mem, typ.BytePtr, offset)
-			pos = pos.WithNotStmt()
-			mem = storeArgOrLoad(pos, b, base, source.Args[1], mem, typ.Int, offset+ptrSize)
-			return storeArgOrLoad(pos, b, base, source.Args[2], mem, typ.Int, offset+2*ptrSize)
-		}
-
-		// For nodes that cannot be taken apart -- OpSelectN, other structure selectors.
-		switch t.Kind() {
-		case types.TARRAY:
-			elt := t.Elem()
-			if source.Type != t && t.NumElem() == 1 && elt.Width == t.Width && t.Width == regSize {
-				t = removeTrivialWrapperTypes(t)
-				// it could be a leaf type, but the "leaf" could be complex64 (for example)
-				return storeArgOrLoad(pos, b, base, source, mem, t, offset)
-			}
-			for i := int64(0); i < t.NumElem(); i++ {
-				sel := source.Block.NewValue1I(pos, OpArraySelect, elt, i, source)
-				mem = storeArgOrLoad(pos, b, base, sel, mem, elt, offset+i*elt.Width)
-				pos = pos.WithNotStmt()
-			}
-			return mem
-
-		case types.TSTRUCT:
-			if source.Type != t && t.NumFields() == 1 && t.Field(0).Type.Width == t.Width && t.Width == regSize {
-				// This peculiar test deals with accesses to immediate interface data.
-				// It works okay because everything is the same size.
-				// Example code that triggers this can be found in go/constant/value.go, function ToComplex
-				// v119 (+881) = IData <intVal> v6
-				// v121 (+882) = StaticLECall <floatVal,mem> {AuxCall{"".itof([intVal,0])[floatVal,8]}} [16] v119 v1
-				// This corresponds to the generic rewrite rule "(StructSelect [0] (IData x)) => (IData x)"
-				// Guard against "struct{struct{*foo}}"
-				// Other rewriting phases create minor glitches when they transform IData, for instance the
-				// interface-typed Arg "x" of ToFloat in go/constant/value.go
-				//   v6 (858) = Arg <Value> {x} (x[Value], x[Value])
-				// is rewritten by decomposeArgs into
-				//   v141 (858) = Arg <uintptr> {x}
-				//   v139 (858) = Arg <*uint8> {x} [8]
-				// because of a type case clause on line 862 of go/constant/value.go
-				//  	case intVal:
-				//		   return itof(x)
-				// v139 is later stored as an intVal == struct{val *big.Int} which naively requires the fields of
-				// of a *uint8, which does not succeed.
-				t = removeTrivialWrapperTypes(t)
-				// it could be a leaf type, but the "leaf" could be complex64 (for example)
-				return storeArgOrLoad(pos, b, base, source, mem, t, offset)
-			}
+	case OpComplexMake:
+		tPart := x.typs.Float32
+		wPart := t.Width / 2
+		if wPart == 8 {
+			tPart = x.typs.Float64
+		}
+		mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, tPart, offset)
+		pos = pos.WithNotStmt()
+		return x.storeArgOrLoad(pos, b, base, source.Args[1], mem, tPart, offset+wPart)
 
-			for i := 0; i < t.NumFields(); i++ {
-				fld := t.Field(i)
-				sel := source.Block.NewValue1I(pos, OpStructSelect, fld.Type, int64(i), source)
-				mem = storeArgOrLoad(pos, b, base, sel, mem, fld.Type, offset+fld.Offset)
-				pos = pos.WithNotStmt()
-			}
-			return mem
+	case OpIMake:
+		mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, x.typs.Uintptr, offset)
+		pos = pos.WithNotStmt()
+		return x.storeArgOrLoad(pos, b, base, source.Args[1], mem, x.typs.BytePtr, offset+x.ptrSize)
 
-		case types.TINT64, types.TUINT64:
-			if t.Width == regSize {
-				break
-			}
-			tHi, tLo := intPairTypes(t.Kind())
-			sel := source.Block.NewValue1(pos, OpInt64Hi, tHi, source)
-			mem = storeArgOrLoad(pos, b, base, sel, mem, tHi, offset+hiOffset)
-			pos = pos.WithNotStmt()
-			sel = source.Block.NewValue1(pos, OpInt64Lo, tLo, source)
-			return storeArgOrLoad(pos, b, base, sel, mem, tLo, offset+lowOffset)
+	case OpStringMake:
+		mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, x.typs.BytePtr, offset)
+		pos = pos.WithNotStmt()
+		return x.storeArgOrLoad(pos, b, base, source.Args[1], mem, x.typs.Int, offset+x.ptrSize)
 
-		case types.TINTER:
-			sel := source.Block.NewValue1(pos, OpITab, typ.BytePtr, source)
-			mem = storeArgOrLoad(pos, b, base, sel, mem, typ.BytePtr, offset)
-			pos = pos.WithNotStmt()
-			sel = source.Block.NewValue1(pos, OpIData, typ.BytePtr, source)
-			return storeArgOrLoad(pos, b, base, sel, mem, typ.BytePtr, offset+ptrSize)
+	case OpSliceMake:
+		mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, x.typs.BytePtr, offset)
+		pos = pos.WithNotStmt()
+		mem = x.storeArgOrLoad(pos, b, base, source.Args[1], mem, x.typs.Int, offset+x.ptrSize)
+		return x.storeArgOrLoad(pos, b, base, source.Args[2], mem, x.typs.Int, offset+2*x.ptrSize)
+	}
 
-		case types.TSTRING:
-			sel := source.Block.NewValue1(pos, OpStringPtr, typ.BytePtr, source)
-			mem = storeArgOrLoad(pos, b, base, sel, mem, typ.BytePtr, offset)
+	// For nodes that cannot be taken apart -- OpSelectN, other structure selectors.
+	switch t.Kind() {
+	case types.TARRAY:
+		elt := t.Elem()
+		if source.Type != t && t.NumElem() == 1 && elt.Width == t.Width && t.Width == x.regSize {
+			t = removeTrivialWrapperTypes(t)
+			// it could be a leaf type, but the "leaf" could be complex64 (for example)
+			return x.storeArgOrLoad(pos, b, base, source, mem, t, offset)
+		}
+		for i := int64(0); i < t.NumElem(); i++ {
+			sel := source.Block.NewValue1I(pos, OpArraySelect, elt, i, source)
+			mem = x.storeArgOrLoad(pos, b, base, sel, mem, elt, offset+i*elt.Width)
 			pos = pos.WithNotStmt()
-			sel = source.Block.NewValue1(pos, OpStringLen, typ.Int, source)
-			return storeArgOrLoad(pos, b, base, sel, mem, typ.Int, offset+ptrSize)
+		}
+		return mem
 
-		case types.TSLICE:
-			et := types.NewPtr(t.Elem())
-			sel := source.Block.NewValue1(pos, OpSlicePtr, et, source)
-			mem = storeArgOrLoad(pos, b, base, sel, mem, et, offset)
-			pos = pos.WithNotStmt()
-			sel = source.Block.NewValue1(pos, OpSliceLen, typ.Int, source)
-			mem = storeArgOrLoad(pos, b, base, sel, mem, typ.Int, offset+ptrSize)
-			sel = source.Block.NewValue1(pos, OpSliceCap, typ.Int, source)
-			return storeArgOrLoad(pos, b, base, sel, mem, typ.Int, offset+2*ptrSize)
-
-		case types.TCOMPLEX64:
-			sel := source.Block.NewValue1(pos, OpComplexReal, typ.Float32, source)
-			mem = storeArgOrLoad(pos, b, base, sel, mem, typ.Float32, offset)
-			pos = pos.WithNotStmt()
-			sel = source.Block.NewValue1(pos, OpComplexImag, typ.Float32, source)
-			return storeArgOrLoad(pos, b, base, sel, mem, typ.Float32, offset+4)
+	case types.TSTRUCT:
+		if source.Type != t && t.NumFields() == 1 && t.Field(0).Type.Width == t.Width && t.Width == x.regSize {
+			// This peculiar test deals with accesses to immediate interface data.
+			// It works okay because everything is the same size.
+			// Example code that triggers this can be found in go/constant/value.go, function ToComplex
+			// v119 (+881) = IData <intVal> v6
+			// v121 (+882) = StaticLECall <floatVal,mem> {AuxCall{"".itof([intVal,0])[floatVal,8]}} [16] v119 v1
+			// This corresponds to the generic rewrite rule "(StructSelect [0] (IData x)) => (IData x)"
+			// Guard against "struct{struct{*foo}}"
+			// Other rewriting phases create minor glitches when they transform IData, for instance the
+			// interface-typed Arg "x" of ToFloat in go/constant/value.go
+			//   v6 (858) = Arg <Value> {x} (x[Value], x[Value])
+			// is rewritten by decomposeArgs into
+			//   v141 (858) = Arg <uintptr> {x}
+			//   v139 (858) = Arg <*uint8> {x} [8]
+			// because of a type case clause on line 862 of go/constant/value.go
+			//  	case intVal:
+			//		   return itof(x)
+			// v139 is later stored as an intVal == struct{val *big.Int} which naively requires the fields of
+			// of a *uint8, which does not succeed.
+			t = removeTrivialWrapperTypes(t)
+			// it could be a leaf type, but the "leaf" could be complex64 (for example)
+			return x.storeArgOrLoad(pos, b, base, source, mem, t, offset)
+		}
 
-		case types.TCOMPLEX128:
-			sel := source.Block.NewValue1(pos, OpComplexReal, typ.Float64, source)
-			mem = storeArgOrLoad(pos, b, base, sel, mem, typ.Float64, offset)
+		for i := 0; i < t.NumFields(); i++ {
+			fld := t.Field(i)
+			sel := source.Block.NewValue1I(pos, OpStructSelect, fld.Type, int64(i), source)
+			mem = x.storeArgOrLoad(pos, b, base, sel, mem, fld.Type, offset+fld.Offset)
 			pos = pos.WithNotStmt()
-			sel = source.Block.NewValue1(pos, OpComplexImag, typ.Float64, source)
-			return storeArgOrLoad(pos, b, base, sel, mem, typ.Float64, offset+8)
 		}
+		return mem
 
-		dst := offsetFrom(base, offset, types.NewPtr(t))
-		x := b.NewValue3A(pos, OpStore, types.TypeMem, t, dst, source, mem)
-		if debug {
-			fmt.Printf("\t\tstoreArg returns %s\n", x.LongString())
+	case types.TINT64, types.TUINT64:
+		if t.Width == x.regSize {
+			break
 		}
-		return x
+		tHi, tLo := x.intPairTypes(t.Kind())
+		sel := source.Block.NewValue1(pos, OpInt64Hi, tHi, source)
+		mem = x.storeArgOrLoad(pos, b, base, sel, mem, tHi, offset+x.hiOffset)
+		pos = pos.WithNotStmt()
+		sel = source.Block.NewValue1(pos, OpInt64Lo, tLo, source)
+		return x.storeArgOrLoad(pos, b, base, sel, mem, tLo, offset+x.lowOffset)
+
+	case types.TINTER:
+		sel := source.Block.NewValue1(pos, OpITab, x.typs.BytePtr, source)
+		mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.BytePtr, offset)
+		pos = pos.WithNotStmt()
+		sel = source.Block.NewValue1(pos, OpIData, x.typs.BytePtr, source)
+		return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.BytePtr, offset+x.ptrSize)
+
+	case types.TSTRING:
+		sel := source.Block.NewValue1(pos, OpStringPtr, x.typs.BytePtr, source)
+		mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.BytePtr, offset)
+		pos = pos.WithNotStmt()
+		sel = source.Block.NewValue1(pos, OpStringLen, x.typs.Int, source)
+		return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Int, offset+x.ptrSize)
+
+	case types.TSLICE:
+		et := types.NewPtr(t.Elem())
+		sel := source.Block.NewValue1(pos, OpSlicePtr, et, source)
+		mem = x.storeArgOrLoad(pos, b, base, sel, mem, et, offset)
+		pos = pos.WithNotStmt()
+		sel = source.Block.NewValue1(pos, OpSliceLen, x.typs.Int, source)
+		mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Int, offset+x.ptrSize)
+		sel = source.Block.NewValue1(pos, OpSliceCap, x.typs.Int, source)
+		return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Int, offset+2*x.ptrSize)
+
+	case types.TCOMPLEX64:
+		sel := source.Block.NewValue1(pos, OpComplexReal, x.typs.Float32, source)
+		mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Float32, offset)
+		pos = pos.WithNotStmt()
+		sel = source.Block.NewValue1(pos, OpComplexImag, x.typs.Float32, source)
+		return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Float32, offset+4)
+
+	case types.TCOMPLEX128:
+		sel := source.Block.NewValue1(pos, OpComplexReal, x.typs.Float64, source)
+		mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Float64, offset)
+		pos = pos.WithNotStmt()
+		sel = source.Block.NewValue1(pos, OpComplexImag, x.typs.Float64, source)
+		return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Float64, offset+8)
 	}
 
-	rewriteDereference := func(b *Block, base, a, mem *Value, offset, size int64, typ *types.Type, pos src.XPos) *Value {
-		source := a.Args[0]
-		dst := offsetFrom(base, offset, source.Type)
-		if a.Uses == 1 && a.Block == b {
-			a.reset(OpMove)
-			a.Pos = pos
-			a.Type = types.TypeMem
-			a.Aux = typ
-			a.AuxInt = size
-			a.SetArgs3(dst, source, mem)
-			mem = a
-		} else {
-			mem = b.NewValue3A(pos, OpMove, types.TypeMem, typ, dst, source, mem)
-			mem.AuxInt = size
-		}
-		return mem
+	dst := x.offsetFrom(base, offset, types.NewPtr(t))
+	s := b.NewValue3A(pos, OpStore, types.TypeMem, t, dst, source, mem)
+	if x.debug {
+		fmt.Printf("\t\tstoreArg returns %s\n", s.LongString())
 	}
+	return s
+}
 
-	// rewriteArgs removes all the Args from a call and converts the call args into appropriate
-	// stores (or later, register movement).  Extra args for interface and closure calls are ignored,
-	// but removed.
-	rewriteArgs := func(v *Value, firstArg int) *Value {
-		// Thread the stores on the memory arg
-		aux := v.Aux.(*AuxCall)
-		pos := v.Pos.WithNotStmt()
-		m0 := v.MemoryArg()
-		mem := m0
-		for i, a := range v.Args {
-			if i < firstArg {
-				continue
-			}
-			if a == m0 { // mem is last.
-				break
+// rewriteArgs removes all the Args from a call and converts the call args into appropriate
+// stores (or later, register movement).  Extra args for interface and closure calls are ignored,
+// but removed.
+func (x *expandState) rewriteArgs(v *Value, firstArg int) *Value {
+	// Thread the stores on the memory arg
+	aux := v.Aux.(*AuxCall)
+	pos := v.Pos.WithNotStmt()
+	m0 := v.MemoryArg()
+	mem := m0
+	for i, a := range v.Args {
+		if i < firstArg {
+			continue
+		}
+		if a == m0 { // mem is last.
+			break
+		}
+		auxI := int64(i - firstArg)
+		if a.Op == OpDereference {
+			if a.MemoryArg() != m0 {
+				x.f.Fatalf("Op...LECall and OpDereference have mismatched mem, %s and %s", v.LongString(), a.LongString())
 			}
-			auxI := int64(i - firstArg)
-			if a.Op == OpDereference {
-				if a.MemoryArg() != m0 {
-					f.Fatalf("Op...LECall and OpDereference have mismatched mem, %s and %s", v.LongString(), a.LongString())
-				}
-				// "Dereference" of addressed (probably not-SSA-eligible) value becomes Move
-				// TODO this will be more complicated with registers in the picture.
-				mem = rewriteDereference(v.Block, sp, a, mem, aux.OffsetOfArg(auxI), aux.SizeOfArg(auxI), aux.TypeOfArg(auxI), pos)
-			} else {
-				if debug {
-					fmt.Printf("storeArg %s, %v, %d\n", a.LongString(), aux.TypeOfArg(auxI), aux.OffsetOfArg(auxI))
-				}
-				mem = storeArgOrLoad(pos, v.Block, sp, a, mem, aux.TypeOfArg(auxI), aux.OffsetOfArg(auxI))
+			// "Dereference" of addressed (probably not-SSA-eligible) value becomes Move
+			// TODO this will be more complicated with registers in the picture.
+			mem = x.rewriteDereference(v.Block, x.sp, a, mem, aux.OffsetOfArg(auxI), aux.SizeOfArg(auxI), aux.TypeOfArg(auxI), pos)
+		} else {
+			if x.debug {
+				fmt.Printf("storeArg %s, %v, %d\n", a.LongString(), aux.TypeOfArg(auxI), aux.OffsetOfArg(auxI))
 			}
+			mem = x.storeArgOrLoad(pos, v.Block, x.sp, a, mem, aux.TypeOfArg(auxI), aux.OffsetOfArg(auxI))
 		}
-		v.resetArgs()
-		return mem
+	}
+	v.resetArgs()
+	return mem
+}
+
+// expandCalls converts LE (Late Expansion) calls that act like they receive value args into a lower-level form
+// that is more oriented to a platform's ABI.  The SelectN operations that extract results are rewritten into
+// more appropriate forms, and any StructMake or ArrayMake inputs are decomposed until non-struct values are
+// reached.  On the callee side, OpArg nodes are not decomposed until this phase is run.
+// TODO results should not be lowered until this phase.
+func expandCalls(f *Func) {
+	// Calls that need lowering have some number of inputs, including a memory input,
+	// and produce a tuple of (value1, value2, ..., mem) where valueK may or may not be SSA-able.
+
+	// With the current ABI those inputs need to be converted into stores to memory,
+	// rethreading the call's memory input to the first, and the new call now receiving the last.
+
+	// With the current ABI, the outputs need to be converted to loads, which will all use the call's
+	// memory output as their input.
+	sp, _ := f.spSb()
+	x := &expandState{
+		f:            f,
+		debug:        f.pass.debug > 0,
+		canSSAType:   f.fe.CanSSA,
+		regSize:      f.Config.RegSize,
+		sp:           sp,
+		typs:         &f.Config.Types,
+		ptrSize:      f.Config.PtrSize,
+		namedSelects: make(map[*Value][]namedVal),
+		sdom:         f.Sdom(),
+		common:       make(map[selKey]*Value),
+		offsets:      make(map[offsetKey]*Value),
+	}
+
+	// For 32-bit, need to deal with decomposition of 64-bit integers, which depends on endianness.
+	if f.Config.BigEndian {
+		x.lowOffset = 4
+	} else {
+		x.hiOffset = 4
+	}
+
+	if x.debug {
+		fmt.Printf("\nexpandsCalls(%s)\n", f.Name)
 	}
 
 	// TODO if too slow, whole program iteration can be replaced w/ slices of appropriate values, accumulated in first loop here.
@@ -686,16 +697,16 @@ func expandCalls(f *Func) {
 		for _, v := range b.Values {
 			switch v.Op {
 			case OpStaticLECall:
-				mem := rewriteArgs(v, 0)
+				mem := x.rewriteArgs(v, 0)
 				v.SetArgs1(mem)
 			case OpClosureLECall:
 				code := v.Args[0]
 				context := v.Args[1]
-				mem := rewriteArgs(v, 2)
+				mem := x.rewriteArgs(v, 2)
 				v.SetArgs3(code, context, mem)
 			case OpInterLECall:
 				code := v.Args[0]
-				mem := rewriteArgs(v, 1)
+				mem := x.rewriteArgs(v, 1)
 				v.SetArgs2(code, mem)
 			}
 		}
@@ -712,7 +723,7 @@ func expandCalls(f *Func) {
 					break
 				}
 				auxType := aux.TypeOfResult(i)
-				auxBase := b.NewValue2A(v.Pos, OpLocalAddr, types.NewPtr(auxType), aux.results[i].Name, sp, mem)
+				auxBase := b.NewValue2A(v.Pos, OpLocalAddr, types.NewPtr(auxType), aux.results[i].Name, x.sp, mem)
 				auxOffset := int64(0)
 				auxSize := aux.SizeOfResult(i)
 				if a.Op == OpDereference {
@@ -724,7 +735,7 @@ func expandCalls(f *Func) {
 						}
 						continue
 					}
-					mem = rewriteDereference(v.Block, auxBase, a, mem, auxOffset, auxSize, auxType, pos)
+					mem = x.rewriteDereference(v.Block, auxBase, a, mem, auxOffset, auxSize, auxType, pos)
 				} else {
 					if a.Op == OpLoad && a.Args[0].Op == OpLocalAddr {
 						addr := a.Args[0]
@@ -732,7 +743,7 @@ func expandCalls(f *Func) {
 							continue
 						}
 					}
-					mem = storeArgOrLoad(v.Pos, b, auxBase, a, mem, aux.TypeOfResult(i), auxOffset)
+					mem = x.storeArgOrLoad(v.Pos, b, auxBase, a, mem, aux.TypeOfResult(i), auxOffset)
 				}
 			}
 			b.SetControl(mem)
@@ -742,11 +753,11 @@ func expandCalls(f *Func) {
 
 	for i, name := range f.Names {
 		t := name.Type
-		if isAlreadyExpandedAggregateType(t) {
+		if x.isAlreadyExpandedAggregateType(t) {
 			for j, v := range f.NamedValues[name] {
-				if v.Op == OpSelectN || v.Op == OpArg && isAlreadyExpandedAggregateType(v.Type) {
-					ns := namedSelects[v]
-					namedSelects[v] = append(ns, namedVal{locIndex: i, valIndex: j})
+				if v.Op == OpSelectN || v.Op == OpArg && x.isAlreadyExpandedAggregateType(v.Type) {
+					ns := x.namedSelects[v]
+					x.namedSelects[v] = append(ns, namedVal{locIndex: i, valIndex: j})
 				}
 			}
 		}
@@ -760,22 +771,22 @@ func expandCalls(f *Func) {
 				t := v.Aux.(*types.Type)
 				source := v.Args[1]
 				tSrc := source.Type
-				iAEATt := isAlreadyExpandedAggregateType(t)
+				iAEATt := x.isAlreadyExpandedAggregateType(t)
 
 				if !iAEATt {
 					// guarding against store immediate struct into interface data field -- store type is *uint8
 					// TODO can this happen recursively?
-					iAEATt = isAlreadyExpandedAggregateType(tSrc)
+					iAEATt = x.isAlreadyExpandedAggregateType(tSrc)
 					if iAEATt {
 						t = tSrc
 					}
 				}
 				if iAEATt {
-					if debug {
+					if x.debug {
 						fmt.Printf("Splitting store %s\n", v.LongString())
 					}
 					dst, mem := v.Args[0], v.Args[2]
-					mem = storeArgOrLoad(v.Pos, b, dst, source, mem, t, 0)
+					mem = x.storeArgOrLoad(v.Pos, b, dst, source, mem, t, 0)
 					v.copyOf(mem)
 				}
 			}
@@ -804,7 +815,7 @@ func expandCalls(f *Func) {
 				switch w.Op {
 				case OpStructSelect, OpArraySelect, OpSelectN, OpArg:
 					val2Preds[w] += 1
-					if debug {
+					if x.debug {
 						fmt.Printf("v2p[%s] = %d\n", w.LongString(), val2Preds[w])
 					}
 				}
@@ -813,18 +824,18 @@ func expandCalls(f *Func) {
 			case OpSelectN:
 				if _, ok := val2Preds[v]; !ok {
 					val2Preds[v] = 0
-					if debug {
+					if x.debug {
 						fmt.Printf("v2p[%s] = %d\n", v.LongString(), val2Preds[v])
 					}
 				}
 
 			case OpArg:
-				if !isAlreadyExpandedAggregateType(v.Type) {
+				if !x.isAlreadyExpandedAggregateType(v.Type) {
 					continue
 				}
 				if _, ok := val2Preds[v]; !ok {
 					val2Preds[v] = 0
-					if debug {
+					if x.debug {
 						fmt.Printf("v2p[%s] = %d\n", v.LongString(), val2Preds[v])
 					}
 				}
@@ -835,7 +846,7 @@ func expandCalls(f *Func) {
 				which := v.AuxInt
 				aux := call.Aux.(*AuxCall)
 				pt := v.Type
-				off := offsetFrom(sp, aux.OffsetOfResult(which), pt)
+				off := x.offsetFrom(x.sp, aux.OffsetOfResult(which), pt)
 				v.copyOf(off)
 			}
 		}
@@ -857,7 +868,7 @@ func expandCalls(f *Func) {
 		if bi == bj {
 			return vi.ID < vj.ID
 		}
-		return sdom.domorder(bi) > sdom.domorder(bj) // reverse the order to put dominators last.
+		return x.sdom.domorder(bi) > x.sdom.domorder(bj) // reverse the order to put dominators last.
 	}
 
 	// Accumulate order in allOrdered
@@ -891,7 +902,7 @@ func expandCalls(f *Func) {
 		}
 	}
 
-	common = make(map[selKey]*Value)
+	x.common = make(map[selKey]*Value)
 	// Rewrite duplicate selectors as copies where possible.
 	for i := len(allOrdered) - 1; i >= 0; i-- {
 		v := allOrdered[i]
@@ -923,26 +934,26 @@ func expandCalls(f *Func) {
 		case OpSelectN:
 			offset = w.Aux.(*AuxCall).OffsetOfResult(v.AuxInt)
 		case OpInt64Hi:
-			offset = hiOffset
+			offset = x.hiOffset
 		case OpInt64Lo:
-			offset = lowOffset
+			offset = x.lowOffset
 		case OpStringLen, OpSliceLen, OpIData:
-			offset = ptrSize
+			offset = x.ptrSize
 		case OpSliceCap:
-			offset = 2 * ptrSize
+			offset = 2 * x.ptrSize
 		case OpComplexImag:
 			offset = size
 		}
 		sk := selKey{from: w, size: size, offset: offset, typ: typ}
-		dupe := common[sk]
+		dupe := x.common[sk]
 		if dupe == nil {
-			common[sk] = v
-		} else if sdom.IsAncestorEq(dupe.Block, v.Block) {
+			x.common[sk] = v
+		} else if x.sdom.IsAncestorEq(dupe.Block, v.Block) {
 			v.copyOf(dupe)
 		} else {
 			// Because values are processed in dominator order, the old common[s] will never dominate after a miss is seen.
 			// Installing the new value might match some future values.
-			common[sk] = v
+			x.common[sk] = v
 		}
 	}
 
@@ -951,7 +962,7 @@ func expandCalls(f *Func) {
 
 	// Rewrite selectors.
 	for i, v := range allOrdered {
-		if debug {
+		if x.debug {
 			b := v.Block
 			fmt.Printf("allOrdered[%d] = b%d, %s, uses=%d\n", i, b.ID, v.LongString(), v.Uses)
 		}
@@ -962,13 +973,13 @@ func expandCalls(f *Func) {
 		if v.Op == OpCopy {
 			continue
 		}
-		locs := rewriteSelect(v, v, 0)
+		locs := x.rewriteSelect(v, v, 0)
 		// Install new names.
 		if v.Type.IsMemory() {
 			continue
 		}
 		// Leaf types may have debug locations
-		if !isAlreadyExpandedAggregateType(v.Type) {
+		if !x.isAlreadyExpandedAggregateType(v.Type) {
 			for _, l := range locs {
 				f.NamedValues[l] = append(f.NamedValues[l], v)
 			}
@@ -976,7 +987,7 @@ func expandCalls(f *Func) {
 			continue
 		}
 		// Not-leaf types that had debug locations need to lose them.
-		if ns, ok := namedSelects[v]; ok {
+		if ns, ok := x.namedSelects[v]; ok {
 			toDelete = append(toDelete, ns...)
 		}
 	}
-- 
GitLab


From f7d1c5990b9aed6a402c3cbdae6f43638172918d Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 27 Jan 2021 18:04:46 -0800
Subject: [PATCH 0576/2400] [dev.typeparams] cmd/compile/internal/types2: must
 not import a package called "init"

Updates #43962.

Change-Id: I070153c55baec62d13ca9284f02781b8c1276844
Reviewed-on: https://go-review.googlesource.com/c/go/+/287494
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/resolver.go   | 25 ++++++++++---------
 .../testdata/importdecl0/importdecl0a.src     |  2 +-
 test/fixedbugs/issue43962.dir/a.go            |  5 ++++
 test/fixedbugs/issue43962.dir/b.go            |  7 ++++++
 test/fixedbugs/issue43962.go                  |  9 +++++++
 5 files changed, 35 insertions(+), 13 deletions(-)
 create mode 100644 test/fixedbugs/issue43962.dir/a.go
 create mode 100644 test/fixedbugs/issue43962.dir/b.go
 create mode 100644 test/fixedbugs/issue43962.go

diff --git a/src/cmd/compile/internal/types2/resolver.go b/src/cmd/compile/internal/types2/resolver.go
index 2a84015cfc..44fa51a8e5 100644
--- a/src/cmd/compile/internal/types2/resolver.go
+++ b/src/cmd/compile/internal/types2/resolver.go
@@ -250,14 +250,6 @@ func (check *Checker) collectObjects() {
 					continue
 				}
 
-				// add package to list of explicit imports
-				// (this functionality is provided as a convenience
-				// for clients; it is not needed for type-checking)
-				if !pkgImports[imp] {
-					pkgImports[imp] = true
-					pkg.imports = append(pkg.imports, imp)
-				}
-
 				// local name overrides imported package name
 				name := imp.name
 				if s.LocalPkgName != nil {
@@ -267,10 +259,19 @@ func (check *Checker) collectObjects() {
 						check.errorf(s.LocalPkgName, `cannot rename import "C"`)
 						continue
 					}
-					if name == "init" {
-						check.errorf(s.LocalPkgName, "cannot declare init - must be func")
-						continue
-					}
+				}
+
+				if name == "init" {
+					check.errorf(s.LocalPkgName, "cannot import package as init - init must be a func")
+					continue
+				}
+
+				// add package to list of explicit imports
+				// (this functionality is provided as a convenience
+				// for clients; it is not needed for type-checking)
+				if !pkgImports[imp] {
+					pkgImports[imp] = true
+					pkg.imports = append(pkg.imports, imp)
 				}
 
 				pkgName := NewPkgName(s.Pos(), pkg, name, imp)
diff --git a/src/cmd/compile/internal/types2/testdata/importdecl0/importdecl0a.src b/src/cmd/compile/internal/types2/testdata/importdecl0/importdecl0a.src
index e96fca3cdd..5ceb96e1fa 100644
--- a/src/cmd/compile/internal/types2/testdata/importdecl0/importdecl0a.src
+++ b/src/cmd/compile/internal/types2/testdata/importdecl0/importdecl0a.src
@@ -10,7 +10,7 @@ import (
 	// we can have multiple blank imports (was bug)
 	_ "math"
 	_ "net/rpc"
-	init /* ERROR "cannot declare init" */ "fmt"
+	init /* ERROR "cannot import package as init" */ "fmt"
 	// reflect defines a type "flag" which shows up in the gc export data
 	"reflect"
 	. /* ERROR "imported but not used" */ "reflect"
diff --git a/test/fixedbugs/issue43962.dir/a.go b/test/fixedbugs/issue43962.dir/a.go
new file mode 100644
index 0000000000..168b2063b4
--- /dev/null
+++ b/test/fixedbugs/issue43962.dir/a.go
@@ -0,0 +1,5 @@
+// Copyright 2021 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 init
diff --git a/test/fixedbugs/issue43962.dir/b.go b/test/fixedbugs/issue43962.dir/b.go
new file mode 100644
index 0000000000..f55fea11c1
--- /dev/null
+++ b/test/fixedbugs/issue43962.dir/b.go
@@ -0,0 +1,7 @@
+// Copyright 2021 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 b
+
+import "./a" // ERROR "cannot import package as init"
diff --git a/test/fixedbugs/issue43962.go b/test/fixedbugs/issue43962.go
new file mode 100644
index 0000000000..dca4d077d5
--- /dev/null
+++ b/test/fixedbugs/issue43962.go
@@ -0,0 +1,9 @@
+// errorcheckdir
+
+// Copyright 2021 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.
+
+// Issue 43962: Importing a package called "init" is an error.
+
+package ignored
-- 
GitLab


From c0bf904ddf89b549a4a9d91a634fea1422744c33 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 27 Jan 2021 17:03:00 -0800
Subject: [PATCH 0577/2400] [dev.typeparams] cmd/compile/internal/types2:
 translate syntax to token constants via tables

This makes the respective files match the respective go/types files
a tad more.

Change-Id: Ie555e18ed23c493379a1e56b96276867190106f0
Reviewed-on: https://go-review.googlesource.com/c/go/+/287492
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/expr.go    | 93 ++++++++--------------
 src/cmd/compile/internal/types2/operand.go | 17 ++--
 2 files changed, 44 insertions(+), 66 deletions(-)

diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 22dc47b1e7..3378c606ad 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -83,61 +83,6 @@ func (check *Checker) op(m opPredicates, x *operand, op syntax.Operator) bool {
 	return true
 }
 
-func op2token(op syntax.Operator) token.Token {
-	switch op {
-	case syntax.Def: // :
-		unreachable()
-	case syntax.Not: // !
-		return token.NOT
-	case syntax.Recv: // <-
-		unreachable()
-
-	case syntax.OrOr: // ||
-		return token.LOR
-	case syntax.AndAnd: // &&
-		return token.LAND
-
-	case syntax.Eql: // ==
-		return token.EQL
-	case syntax.Neq: // !=
-		return token.NEQ
-	case syntax.Lss: // <
-		return token.LSS
-	case syntax.Leq: // <=
-		return token.LEQ
-	case syntax.Gtr: // >
-		return token.GTR
-	case syntax.Geq: // >=
-		return token.GEQ
-
-	case syntax.Add: // +
-		return token.ADD
-	case syntax.Sub: // -
-		return token.SUB
-	case syntax.Or: // |
-		return token.OR
-	case syntax.Xor: // ^
-		return token.XOR
-
-	case syntax.Mul: // *
-		return token.MUL
-	case syntax.Div: // /
-		return token.QUO
-	case syntax.Rem: // %
-		return token.REM
-	case syntax.And: // &
-		return token.AND
-	case syntax.AndNot: // &^
-		return token.AND_NOT
-	case syntax.Shl: // <<
-		return token.SHL
-	case syntax.Shr: // >>
-		return token.SHR
-	}
-
-	return token.ILLEGAL
-}
-
 // The unary expression e may be nil. It's passed in for better error messages only.
 func (check *Checker) unary(x *operand, e *syntax.Operation, op syntax.Operator) {
 	switch op {
@@ -182,7 +127,7 @@ func (check *Checker) unary(x *operand, e *syntax.Operation, op syntax.Operator)
 		if isUnsigned(typ) {
 			prec = uint(check.conf.sizeof(typ) * 8)
 		}
-		x.val = constant.UnaryOp(op2token(op), x.val, prec)
+		x.val = constant.UnaryOp(op2tok[op], x.val, prec)
 		// Typed constants must be representable in
 		// their type after each constant operation.
 		if isTyped(typ) {
@@ -738,7 +683,7 @@ func (check *Checker) comparison(x, y *operand, op syntax.Operator) {
 	}
 
 	if x.mode == constant_ && y.mode == constant_ {
-		x.val = constant.MakeBool(constant.Compare(x.val, op2token(op), y.val))
+		x.val = constant.MakeBool(constant.Compare(x.val, op2tok[op], y.val))
 		// The operands are never materialized; no need to update
 		// their types.
 	} else {
@@ -819,7 +764,7 @@ func (check *Checker) shift(x, y *operand, e *syntax.Operation, op syntax.Operat
 				x.typ = Typ[UntypedInt]
 			}
 			// x is a constant so xval != nil and it must be of Int kind.
-			x.val = constant.Shift(xval, op2token(op), uint(s))
+			x.val = constant.Shift(xval, op2tok[op], uint(s))
 			// Typed constants must be representable in
 			// their type after each constant operation.
 			if isTyped(x.typ) {
@@ -965,7 +910,7 @@ func (check *Checker) binary(x *operand, e *syntax.Operation, lhs, rhs syntax.Ex
 		yval := y.val
 		typ := x.typ.Basic()
 		// force integer division of integer operands
-		tok := op2token(op)
+		tok := op2tok[op]
 		if op == syntax.Div && isInteger(typ) {
 			tok = token.QUO_ASSIGN
 		}
@@ -1951,3 +1896,33 @@ func (check *Checker) singleValue(x *operand) {
 		}
 	}
 }
+
+// op2tok translates syntax.Operators into token.Tokens.
+var op2tok = [...]token.Token{
+	syntax.Def:  token.ILLEGAL,
+	syntax.Not:  token.NOT,
+	syntax.Recv: token.ILLEGAL,
+
+	syntax.OrOr:   token.LOR,
+	syntax.AndAnd: token.LAND,
+
+	syntax.Eql: token.EQL,
+	syntax.Neq: token.NEQ,
+	syntax.Lss: token.LSS,
+	syntax.Leq: token.LEQ,
+	syntax.Gtr: token.GTR,
+	syntax.Geq: token.GEQ,
+
+	syntax.Add: token.ADD,
+	syntax.Sub: token.SUB,
+	syntax.Or:  token.OR,
+	syntax.Xor: token.XOR,
+
+	syntax.Mul:    token.MUL,
+	syntax.Div:    token.QUO,
+	syntax.Rem:    token.REM,
+	syntax.And:    token.AND,
+	syntax.AndNot: token.AND_NOT,
+	syntax.Shl:    token.SHL,
+	syntax.Shr:    token.SHR,
+}
diff --git a/src/cmd/compile/internal/types2/operand.go b/src/cmd/compile/internal/types2/operand.go
index a14120c2c9..dcd29fbce0 100644
--- a/src/cmd/compile/internal/types2/operand.go
+++ b/src/cmd/compile/internal/types2/operand.go
@@ -206,29 +206,23 @@ func (x *operand) String() string {
 
 // setConst sets x to the untyped constant for literal lit.
 func (x *operand) setConst(k syntax.LitKind, lit string) {
-	var tok token.Token
 	var kind BasicKind
 	switch k {
 	case syntax.IntLit:
-		tok = token.INT
 		kind = UntypedInt
 	case syntax.FloatLit:
-		tok = token.FLOAT
 		kind = UntypedFloat
 	case syntax.ImagLit:
-		tok = token.IMAG
 		kind = UntypedComplex
 	case syntax.RuneLit:
-		tok = token.CHAR
 		kind = UntypedRune
 	case syntax.StringLit:
-		tok = token.STRING
 		kind = UntypedString
 	default:
 		unreachable()
 	}
 
-	val := constant.MakeFromLiteral(lit, tok, 0)
+	val := constant.MakeFromLiteral(lit, kind2tok[k], 0)
 	if val.Kind() == constant.Unknown {
 		x.mode = invalid
 		x.typ = Typ[Invalid]
@@ -334,3 +328,12 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) bool {
 
 	return false
 }
+
+// kind2tok translates syntax.LitKinds into token.Tokens.
+var kind2tok = [...]token.Token{
+	syntax.IntLit:    token.INT,
+	syntax.FloatLit:  token.FLOAT,
+	syntax.ImagLit:   token.IMAG,
+	syntax.RuneLit:   token.CHAR,
+	syntax.StringLit: token.STRING,
+}
-- 
GitLab


From 2440dd457a451084e4a23b1b0903953f331abea7 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Wed, 27 Jan 2021 12:55:57 -0800
Subject: [PATCH 0578/2400] [dev.typeparams] cmd/compile:  start adding info
 needed for typeparams in types & ir

We are focusing on generic functions first, and ignoring type lists for
now.

The signatures of types.NewSignature() and ir.NewCallExpr() changed (with
addition of type args/params).

Change-Id: I57480be3d1f65690b2946e15dd74929bf42873f2
Reviewed-on: https://go-review.googlesource.com/c/go/+/287416
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Trust: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/inline/inl.go        |   2 +-
 src/cmd/compile/internal/ir/class_string.go   |   7 +-
 src/cmd/compile/internal/ir/expr.go           |   6 +-
 src/cmd/compile/internal/ir/name.go           |  15 +-
 src/cmd/compile/internal/noder/helpers.go     |   2 +-
 src/cmd/compile/internal/noder/noder.go       |   2 +-
 src/cmd/compile/internal/noder/types.go       |   2 +-
 src/cmd/compile/internal/reflectdata/alg.go   |  16 +-
 .../compile/internal/reflectdata/reflect.go   |   6 +-
 src/cmd/compile/internal/ssagen/abi.go        |   2 +-
 .../compile/internal/test/abiutilsaux_test.go |   2 +-
 src/cmd/compile/internal/typecheck/builtin.go | 184 +++++++++---------
 src/cmd/compile/internal/typecheck/dcl.go     |   2 +-
 src/cmd/compile/internal/typecheck/func.go    |   2 +-
 src/cmd/compile/internal/typecheck/iimport.go |   6 +-
 .../compile/internal/typecheck/mkbuiltin.go   |   2 +-
 src/cmd/compile/internal/typecheck/type.go    |   2 +-
 .../compile/internal/typecheck/universe.go    |   2 +-
 src/cmd/compile/internal/types/kind_string.go |  23 +--
 src/cmd/compile/internal/types/sizeof_test.go |   2 +-
 src/cmd/compile/internal/types/type.go        |   9 +-
 src/cmd/compile/internal/walk/builtin.go      |   2 +-
 src/cmd/compile/internal/walk/closure.go      |   2 +-
 src/cmd/compile/internal/walk/compare.go      |   4 +-
 src/cmd/compile/internal/walk/complit.go      |   2 +-
 src/cmd/compile/internal/walk/convert.go      |   4 +-
 src/cmd/compile/internal/walk/expr.go         |   2 +-
 src/cmd/compile/internal/walk/stmt.go         |   4 +-
 src/cmd/compile/internal/walk/walk.go         |   2 +-
 29 files changed, 164 insertions(+), 154 deletions(-)

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index bbbdaa63d4..7d70fca6c9 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -1228,7 +1228,7 @@ func (subst *inlsubst) closure(n *ir.ClosureExpr) ir.Node {
 		newrecv = newrecvs[0]
 	}
 	newt := types.NewSignature(oldt.Pkg(), newrecv,
-		subst.fields(oldt.Params()), subst.fields(oldt.Results()))
+		nil, subst.fields(oldt.Params()), subst.fields(oldt.Results()))
 
 	newfn.Nname.SetType(newt)
 	newfn.Body = subst.list(oldfn.Body)
diff --git a/src/cmd/compile/internal/ir/class_string.go b/src/cmd/compile/internal/ir/class_string.go
index 13b9bd4812..11a94c0047 100644
--- a/src/cmd/compile/internal/ir/class_string.go
+++ b/src/cmd/compile/internal/ir/class_string.go
@@ -14,12 +14,13 @@ func _() {
 	_ = x[PAUTOHEAP-3]
 	_ = x[PPARAM-4]
 	_ = x[PPARAMOUT-5]
-	_ = x[PFUNC-6]
+	_ = x[PTYPEPARAM-6]
+	_ = x[PFUNC-7]
 }
 
-const _Class_name = "PxxxPEXTERNPAUTOPAUTOHEAPPPARAMPPARAMOUTPFUNC"
+const _Class_name = "PxxxPEXTERNPAUTOPAUTOHEAPPPARAMPPARAMOUTPTYPEPARAMPFUNC"
 
-var _Class_index = [...]uint8{0, 4, 11, 16, 25, 31, 40, 45}
+var _Class_index = [...]uint8{0, 4, 11, 16, 25, 31, 40, 50, 55}
 
 func (i Class) String() string {
 	if i >= Class(len(_Class_index)-1) {
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index b32ed71260..92f93e98b8 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -153,11 +153,12 @@ const (
 	CallUseStmt // results not used - call is a statement
 )
 
-// A CallExpr is a function call X(Args).
+// A CallExpr is a function call X[Targs](Args).
 type CallExpr struct {
 	miniExpr
 	origNode
 	X         Node
+	Targs     Nodes
 	Args      Nodes
 	KeepAlive []*Name // vars to be kept alive until call returns
 	IsDDD     bool
@@ -165,11 +166,12 @@ type CallExpr struct {
 	NoInline  bool
 }
 
-func NewCallExpr(pos src.XPos, op Op, fun Node, args []Node) *CallExpr {
+func NewCallExpr(pos src.XPos, op Op, fun Node, targs, args []Node) *CallExpr {
 	n := &CallExpr{X: fun}
 	n.pos = pos
 	n.orig = n
 	n.SetOp(op)
+	n.Targs = targs
 	n.Args = args
 	return n
 }
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index fa0639600c..6240852aaf 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -473,13 +473,14 @@ type Class uint8
 
 //go:generate stringer -type=Class name.go
 const (
-	Pxxx      Class = iota // no class; used during ssa conversion to indicate pseudo-variables
-	PEXTERN                // global variables
-	PAUTO                  // local variables
-	PAUTOHEAP              // local variables or parameters moved to heap
-	PPARAM                 // input arguments
-	PPARAMOUT              // output results
-	PFUNC                  // global functions
+	Pxxx       Class = iota // no class; used during ssa conversion to indicate pseudo-variables
+	PEXTERN                 // global variables
+	PAUTO                   // local variables
+	PAUTOHEAP               // local variables or parameters moved to heap
+	PPARAM                  // input arguments
+	PPARAMOUT               // output results
+	PTYPEPARAM              // type params
+	PFUNC                   // global functions
 
 	// Careful: Class is stored in three bits in Node.flags.
 	_ = uint((1 << 3) - iota) // static assert for iota <= (1 << 3)
diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
index ffd62367ad..a851844ded 100644
--- a/src/cmd/compile/internal/noder/helpers.go
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -82,7 +82,7 @@ func Binary(pos src.XPos, op ir.Op, x, y ir.Node) ir.Node {
 func Call(pos src.XPos, fun ir.Node, args []ir.Node, dots bool) ir.Node {
 	// TODO(mdempsky): This should not be so difficult.
 
-	n := ir.NewCallExpr(pos, ir.OCALL, fun, args)
+	n := ir.NewCallExpr(pos, ir.OCALL, fun, nil, args)
 	n.IsDDD = dots
 
 	// Actually a type conversion.
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 1c38f1a934..492c2c242a 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -755,7 +755,7 @@ func (p *noder) expr(expr syntax.Expr) ir.Node {
 		}
 		return ir.NewBinaryExpr(pos, op, x, y)
 	case *syntax.CallExpr:
-		n := ir.NewCallExpr(p.pos(expr), ir.OCALL, p.expr(expr.Fun), p.exprs(expr.ArgList))
+		n := ir.NewCallExpr(p.pos(expr), ir.OCALL, p.expr(expr.Fun), nil, p.exprs(expr.ArgList))
 		n.IsDDD = expr.HasDots
 		return n
 
diff --git a/src/cmd/compile/internal/noder/types.go b/src/cmd/compile/internal/noder/types.go
index e0ed5a3f99..de191acc90 100644
--- a/src/cmd/compile/internal/noder/types.go
+++ b/src/cmd/compile/internal/noder/types.go
@@ -121,7 +121,7 @@ func (g *irgen) signature(recv *types.Field, sig *types2.Signature) *types.Type
 		params[len(params)-1].SetIsDDD(true)
 	}
 
-	return types.NewSignature(g.tpkg(sig), recv, params, results)
+	return types.NewSignature(g.tpkg(sig), recv, nil, params, results)
 }
 
 func (g *irgen) param(v *types2.Var) *types.Field {
diff --git a/src/cmd/compile/internal/reflectdata/alg.go b/src/cmd/compile/internal/reflectdata/alg.go
index fcd824f164..3d8729069a 100644
--- a/src/cmd/compile/internal/reflectdata/alg.go
+++ b/src/cmd/compile/internal/reflectdata/alg.go
@@ -176,7 +176,7 @@ func genhash(t *types.Type) *obj.LSym {
 		loop.PtrInit().Append(init)
 
 		// h = hashel(&p[i], h)
-		call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil)
+		call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil, nil)
 
 		nx := ir.NewIndexExpr(base.Pos, np, ni)
 		nx.SetBounded(true)
@@ -202,7 +202,7 @@ func genhash(t *types.Type) *obj.LSym {
 			// Hash non-memory fields with appropriate hash function.
 			if !isRegularMemory(f.Type) {
 				hashel := hashfor(f.Type)
-				call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil)
+				call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil, nil)
 				nx := ir.NewSelectorExpr(base.Pos, ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
 				na := typecheck.NodAddr(nx)
 				call.Args.Append(na)
@@ -217,7 +217,7 @@ func genhash(t *types.Type) *obj.LSym {
 
 			// h = hashel(&p.first, size, h)
 			hashel := hashmem(f.Type)
-			call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil)
+			call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil, nil)
 			nx := ir.NewSelectorExpr(base.Pos, ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
 			na := typecheck.NodAddr(nx)
 			call.Args.Append(na)
@@ -289,7 +289,7 @@ func hashfor(t *types.Type) ir.Node {
 
 	n := typecheck.NewName(sym)
 	ir.MarkFunc(n)
-	n.SetType(types.NewSignature(types.NoPkg, nil, []*types.Field{
+	n.SetType(types.NewSignature(types.NoPkg, nil, nil, []*types.Field{
 		types.NewField(base.Pos, nil, types.NewPtr(t)),
 		types.NewField(base.Pos, nil, types.Types[types.TUINTPTR]),
 	}, []*types.Field{
@@ -672,7 +672,7 @@ func EqString(s, t ir.Node) (eqlen *ir.BinaryExpr, eqmem *ir.CallExpr) {
 
 	fn := typecheck.LookupRuntime("memequal")
 	fn = typecheck.SubstArgTypes(fn, types.Types[types.TUINT8], types.Types[types.TUINT8])
-	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, []ir.Node{sptr, tptr, ir.Copy(slen)})
+	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil, []ir.Node{sptr, tptr, ir.Copy(slen)})
 	typecheck.Call(call)
 
 	cmp := ir.NewBinaryExpr(base.Pos, ir.OEQ, slen, tlen)
@@ -709,7 +709,7 @@ func EqInterface(s, t ir.Node) (eqtab *ir.BinaryExpr, eqdata *ir.CallExpr) {
 	sdata.SetTypecheck(1)
 	tdata.SetTypecheck(1)
 
-	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, []ir.Node{stab, sdata, tdata})
+	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil, []ir.Node{stab, sdata, tdata})
 	typecheck.Call(call)
 
 	cmp := ir.NewBinaryExpr(base.Pos, ir.OEQ, stab, ttab)
@@ -725,7 +725,7 @@ func eqmem(p ir.Node, q ir.Node, field *types.Sym, size int64) ir.Node {
 	ny := typecheck.Expr(typecheck.NodAddr(ir.NewSelectorExpr(base.Pos, ir.OXDOT, q, field)))
 
 	fn, needsize := eqmemfunc(size, nx.Type().Elem())
-	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
+	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil, nil)
 	call.Args.Append(nx)
 	call.Args.Append(ny)
 	if needsize {
@@ -777,7 +777,7 @@ func hashmem(t *types.Type) ir.Node {
 
 	n := typecheck.NewName(sym)
 	ir.MarkFunc(n)
-	n.SetType(types.NewSignature(types.NoPkg, nil, []*types.Field{
+	n.SetType(types.NewSignature(types.NoPkg, nil, nil, []*types.Field{
 		types.NewField(base.Pos, nil, types.NewPtr(t)),
 		types.NewField(base.Pos, nil, types.Types[types.TUINTPTR]),
 		types.NewField(base.Pos, nil, types.Types[types.TUINTPTR]),
diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index 3ff14c87f4..c1385e6dab 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -1399,7 +1399,7 @@ func WriteBasicTypes() {
 		// The latter is the type of an auto-generated wrapper.
 		writeType(types.NewPtr(types.ErrorType))
 
-		writeType(types.NewSignature(types.NoPkg, nil, []*types.Field{
+		writeType(types.NewSignature(types.NoPkg, nil, nil, []*types.Field{
 			types.NewField(base.Pos, nil, types.ErrorType),
 		}, []*types.Field{
 			types.NewField(base.Pos, nil, types.Types[types.TSTRING]),
@@ -1747,7 +1747,7 @@ func methodWrapper(rcvr *types.Type, method *types.Field) *obj.LSym {
 		// generating wrapper from *T to T.
 		n := ir.NewIfStmt(base.Pos, nil, nil, nil)
 		n.Cond = ir.NewBinaryExpr(base.Pos, ir.OEQ, nthis, typecheck.NodNil())
-		call := ir.NewCallExpr(base.Pos, ir.OCALL, typecheck.LookupRuntime("panicwrap"), nil)
+		call := ir.NewCallExpr(base.Pos, ir.OCALL, typecheck.LookupRuntime("panicwrap"), nil, nil)
 		n.Body = []ir.Node{call}
 		fn.Body.Append(n)
 	}
@@ -1772,7 +1772,7 @@ func methodWrapper(rcvr *types.Type, method *types.Field) *obj.LSym {
 		fn.Body.Append(ir.NewTailCallStmt(base.Pos, method.Nname.(*ir.Name)))
 	} else {
 		fn.SetWrapper(true) // ignore frame for panic+recover matching
-		call := ir.NewCallExpr(base.Pos, ir.OCALL, dot, nil)
+		call := ir.NewCallExpr(base.Pos, ir.OCALL, dot, nil, nil)
 		call.Args = ir.ParamNames(tfn.Type())
 		call.IsDDD = tfn.Type().IsVariadic()
 		if method.Type.NumResults() > 0 {
diff --git a/src/cmd/compile/internal/ssagen/abi.go b/src/cmd/compile/internal/ssagen/abi.go
index 5bebce1db5..b22a5ef2be 100644
--- a/src/cmd/compile/internal/ssagen/abi.go
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -305,7 +305,7 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 
 		tail = ir.NewTailCallStmt(base.Pos, f.Nname)
 	} else {
-		call := ir.NewCallExpr(base.Pos, ir.OCALL, f.Nname, nil)
+		call := ir.NewCallExpr(base.Pos, ir.OCALL, f.Nname, nil, nil)
 		call.Args = ir.ParamNames(tfn.Type())
 		call.IsDDD = tfn.Type().IsVariadic()
 		tail = call
diff --git a/src/cmd/compile/internal/test/abiutilsaux_test.go b/src/cmd/compile/internal/test/abiutilsaux_test.go
index 19dd3a51fd..bac0c7639d 100644
--- a/src/cmd/compile/internal/test/abiutilsaux_test.go
+++ b/src/cmd/compile/internal/test/abiutilsaux_test.go
@@ -57,7 +57,7 @@ func mkFuncType(rcvr *types.Type, ins []*types.Type, outs []*types.Type) *types.
 	if rcvr != nil {
 		rf = mkParamResultField(rcvr, q, ir.PPARAM)
 	}
-	return types.NewSignature(types.LocalPkg, rf, inf, outf)
+	return types.NewSignature(types.LocalPkg, rf, nil, inf, outf)
 }
 
 type expectedDump struct {
diff --git a/src/cmd/compile/internal/typecheck/builtin.go b/src/cmd/compile/internal/typecheck/builtin.go
index 0dee852529..3f93438dfe 100644
--- a/src/cmd/compile/internal/typecheck/builtin.go
+++ b/src/cmd/compile/internal/typecheck/builtin.go
@@ -211,133 +211,133 @@ func runtimeTypes() []*types.Type {
 	typs[1] = types.NewPtr(typs[0])
 	typs[2] = types.Types[types.TANY]
 	typs[3] = types.NewPtr(typs[2])
-	typs[4] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])})
+	typs[4] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])})
 	typs[5] = types.Types[types.TUINTPTR]
 	typs[6] = types.Types[types.TBOOL]
 	typs[7] = types.Types[types.TUNSAFEPTR]
-	typs[8] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[6])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
-	typs[9] = types.NewSignature(types.NoPkg, nil, nil, nil)
+	typs[8] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[6])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
+	typs[9] = types.NewSignature(types.NoPkg, nil, nil, nil, nil)
 	typs[10] = types.Types[types.TINTER]
-	typs[11] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[10])}, nil)
+	typs[11] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[10])}, nil)
 	typs[12] = types.Types[types.TINT32]
 	typs[13] = types.NewPtr(typs[12])
-	typs[14] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[13])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[10])})
+	typs[14] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[13])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[10])})
 	typs[15] = types.Types[types.TINT]
-	typs[16] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[15])}, nil)
+	typs[16] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[15])}, nil)
 	typs[17] = types.Types[types.TUINT]
-	typs[18] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[17]), types.NewField(src.NoXPos, nil, typs[15])}, nil)
-	typs[19] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])}, nil)
+	typs[18] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[17]), types.NewField(src.NoXPos, nil, typs[15])}, nil)
+	typs[19] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])}, nil)
 	typs[20] = types.Types[types.TFLOAT64]
-	typs[21] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])}, nil)
+	typs[21] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])}, nil)
 	typs[22] = types.Types[types.TINT64]
-	typs[23] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[22])}, nil)
+	typs[23] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[22])}, nil)
 	typs[24] = types.Types[types.TUINT64]
-	typs[25] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[24])}, nil)
+	typs[25] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[24])}, nil)
 	typs[26] = types.Types[types.TCOMPLEX128]
-	typs[27] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[26])}, nil)
+	typs[27] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[26])}, nil)
 	typs[28] = types.Types[types.TSTRING]
-	typs[29] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])}, nil)
-	typs[30] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[2])}, nil)
-	typs[31] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[5])}, nil)
+	typs[29] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])}, nil)
+	typs[30] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[2])}, nil)
+	typs[31] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[5])}, nil)
 	typs[32] = types.NewArray(typs[0], 32)
 	typs[33] = types.NewPtr(typs[32])
-	typs[34] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
-	typs[35] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
-	typs[36] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
-	typs[37] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+	typs[34] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+	typs[35] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+	typs[36] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+	typs[37] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
 	typs[38] = types.NewSlice(typs[28])
-	typs[39] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[38])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
-	typs[40] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15])})
+	typs[39] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[38])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+	typs[40] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15])})
 	typs[41] = types.NewArray(typs[0], 4)
 	typs[42] = types.NewPtr(typs[41])
-	typs[43] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[42]), types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
-	typs[44] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
-	typs[45] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+	typs[43] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[42]), types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+	typs[44] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+	typs[45] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
 	typs[46] = types.RuneType
 	typs[47] = types.NewSlice(typs[46])
-	typs[48] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[47])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+	typs[48] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[47])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
 	typs[49] = types.NewSlice(typs[0])
-	typs[50] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[49])})
+	typs[50] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[49])})
 	typs[51] = types.NewArray(typs[46], 32)
 	typs[52] = types.NewPtr(typs[51])
-	typs[53] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[52]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[47])})
-	typs[54] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[5])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15])})
-	typs[55] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[46]), types.NewField(src.NoXPos, nil, typs[15])})
-	typs[56] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15])})
-	typs[57] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[2])})
-	typs[58] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
-	typs[59] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[2])})
-	typs[60] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[2]), types.NewField(src.NoXPos, nil, typs[6])})
-	typs[61] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[1])}, nil)
-	typs[62] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1])}, nil)
+	typs[53] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[52]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[47])})
+	typs[54] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[5])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15])})
+	typs[55] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[46]), types.NewField(src.NoXPos, nil, typs[15])})
+	typs[56] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15])})
+	typs[57] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[2])})
+	typs[58] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
+	typs[59] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[2])})
+	typs[60] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[2]), types.NewField(src.NoXPos, nil, typs[6])})
+	typs[61] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[1])}, nil)
+	typs[62] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1])}, nil)
 	typs[63] = types.NewPtr(typs[5])
-	typs[64] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[63]), types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[7])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
+	typs[64] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[63]), types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[7])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
 	typs[65] = types.Types[types.TUINT32]
-	typs[66] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[65])})
+	typs[66] = types.NewSignature(types.NoPkg, nil, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[65])})
 	typs[67] = types.NewMap(typs[2], typs[2])
-	typs[68] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[22]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[67])})
-	typs[69] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[67])})
-	typs[70] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[67])})
-	typs[71] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])})
-	typs[72] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])})
-	typs[73] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[1])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])})
-	typs[74] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[6])})
-	typs[75] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[6])})
-	typs[76] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[1])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[6])})
-	typs[77] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
-	typs[78] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[2])}, nil)
-	typs[79] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])}, nil)
-	typs[80] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67])}, nil)
+	typs[68] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[22]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[67])})
+	typs[69] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[67])})
+	typs[70] = types.NewSignature(types.NoPkg, nil, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[67])})
+	typs[71] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])})
+	typs[72] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])})
+	typs[73] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[1])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])})
+	typs[74] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[6])})
+	typs[75] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[6])})
+	typs[76] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[1])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[6])})
+	typs[77] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
+	typs[78] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[2])}, nil)
+	typs[79] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])}, nil)
+	typs[80] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67])}, nil)
 	typs[81] = types.NewChan(typs[2], types.Cboth)
-	typs[82] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[81])})
-	typs[83] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[81])})
+	typs[82] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[81])})
+	typs[83] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[81])})
 	typs[84] = types.NewChan(typs[2], types.Crecv)
-	typs[85] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[84]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
-	typs[86] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[84]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
+	typs[85] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[84]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
+	typs[86] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[84]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
 	typs[87] = types.NewChan(typs[2], types.Csend)
-	typs[88] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[87]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
+	typs[88] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[87]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
 	typs[89] = types.NewArray(typs[0], 3)
 	typs[90] = types.NewStruct(types.NoPkg, []*types.Field{types.NewField(src.NoXPos, Lookup("enabled"), typs[6]), types.NewField(src.NoXPos, Lookup("pad"), typs[89]), types.NewField(src.NoXPos, Lookup("needed"), typs[6]), types.NewField(src.NoXPos, Lookup("cgo"), typs[6]), types.NewField(src.NoXPos, Lookup("alignme"), typs[24])})
-	typs[91] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
-	typs[92] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
-	typs[93] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15])})
-	typs[94] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[87]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
-	typs[95] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[84])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
+	typs[91] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
+	typs[92] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
+	typs[93] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15])})
+	typs[94] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[87]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
+	typs[95] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[84])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
 	typs[96] = types.NewPtr(typs[6])
-	typs[97] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[96]), types.NewField(src.NoXPos, nil, typs[84])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
-	typs[98] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[63])}, nil)
-	typs[99] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[63]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[6])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[6])})
-	typs[100] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
-	typs[101] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[22]), types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
-	typs[102] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[7])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
+	typs[97] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[96]), types.NewField(src.NoXPos, nil, typs[84])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
+	typs[98] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[63])}, nil)
+	typs[99] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[63]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[6])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[6])})
+	typs[100] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
+	typs[101] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[22]), types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
+	typs[102] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[7])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
 	typs[103] = types.NewSlice(typs[2])
-	typs[104] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[103]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[103])})
-	typs[105] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
-	typs[106] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
-	typs[107] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[5])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
-	typs[108] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
-	typs[109] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[7])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
-	typs[110] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[5])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[5])})
-	typs[111] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[5])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[5])})
-	typs[112] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[22]), types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[22])})
-	typs[113] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[24]), types.NewField(src.NoXPos, nil, typs[24])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[24])})
-	typs[114] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[22])})
-	typs[115] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[24])})
-	typs[116] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[65])})
-	typs[117] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])})
-	typs[118] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[24])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])})
-	typs[119] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[65])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])})
-	typs[120] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[26]), types.NewField(src.NoXPos, nil, typs[26])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[26])})
-	typs[121] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
-	typs[122] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
-	typs[123] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
+	typs[104] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[103]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[103])})
+	typs[105] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
+	typs[106] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
+	typs[107] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[5])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
+	typs[108] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
+	typs[109] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[7])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
+	typs[110] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[5])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[5])})
+	typs[111] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[5])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[5])})
+	typs[112] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[22]), types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[22])})
+	typs[113] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[24]), types.NewField(src.NoXPos, nil, typs[24])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[24])})
+	typs[114] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[22])})
+	typs[115] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[24])})
+	typs[116] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[65])})
+	typs[117] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])})
+	typs[118] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[24])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])})
+	typs[119] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[65])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])})
+	typs[120] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[26]), types.NewField(src.NoXPos, nil, typs[26])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[26])})
+	typs[121] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
+	typs[122] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
+	typs[123] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
 	typs[124] = types.NewSlice(typs[7])
-	typs[125] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[124])}, nil)
+	typs[125] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[124])}, nil)
 	typs[126] = types.Types[types.TUINT8]
-	typs[127] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[126]), types.NewField(src.NoXPos, nil, typs[126])}, nil)
+	typs[127] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[126]), types.NewField(src.NoXPos, nil, typs[126])}, nil)
 	typs[128] = types.Types[types.TUINT16]
-	typs[129] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[128]), types.NewField(src.NoXPos, nil, typs[128])}, nil)
-	typs[130] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[65]), types.NewField(src.NoXPos, nil, typs[65])}, nil)
-	typs[131] = types.NewSignature(types.NoPkg, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[24]), types.NewField(src.NoXPos, nil, typs[24])}, nil)
+	typs[129] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[128]), types.NewField(src.NoXPos, nil, typs[128])}, nil)
+	typs[130] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[65]), types.NewField(src.NoXPos, nil, typs[65])}, nil)
+	typs[131] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[24]), types.NewField(src.NoXPos, nil, typs[24])}, nil)
 	return typs[:]
 }
diff --git a/src/cmd/compile/internal/typecheck/dcl.go b/src/cmd/compile/internal/typecheck/dcl.go
index eab0bb09b2..f3058d8811 100644
--- a/src/cmd/compile/internal/typecheck/dcl.go
+++ b/src/cmd/compile/internal/typecheck/dcl.go
@@ -470,5 +470,5 @@ func NewMethodType(sig *types.Type, recv *types.Type) *types.Type {
 		results[i] = types.NewField(base.Pos, nil, t.Type)
 	}
 
-	return types.NewSignature(types.LocalPkg, nil, params, results)
+	return types.NewSignature(types.LocalPkg, nil, nil, params, results)
 }
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index 7ab5f68ce3..a44af10bbb 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -254,7 +254,7 @@ func MethodValueWrapper(dot *ir.SelectorExpr) *ir.Func {
 	ptr.SetByval(true)
 	fn.ClosureVars = append(fn.ClosureVars, ptr)
 
-	call := ir.NewCallExpr(base.Pos, ir.OCALL, ir.NewSelectorExpr(base.Pos, ir.OXDOT, ptr, meth), nil)
+	call := ir.NewCallExpr(base.Pos, ir.OCALL, ir.NewSelectorExpr(base.Pos, ir.OXDOT, ptr, meth), nil, nil)
 	call.Args = ir.ParamNames(tfn.Type())
 	call.IsDDD = tfn.Type().IsVariadic()
 
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index b73ef5176b..201b217e8e 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -607,7 +607,7 @@ func (r *importReader) signature(recv *types.Field) *types.Type {
 	if n := len(params); n > 0 {
 		params[n-1].SetIsDDD(r.bool())
 	}
-	return types.NewSignature(r.currPkg, recv, params, results)
+	return types.NewSignature(r.currPkg, recv, nil, params, results)
 }
 
 func (r *importReader) paramList() []*types.Field {
@@ -1068,7 +1068,7 @@ func (r *importReader) node() ir.Node {
 	case ir.OCALL:
 		pos := r.pos()
 		init := r.stmtList()
-		n := ir.NewCallExpr(pos, ir.OCALL, r.expr(), r.exprList())
+		n := ir.NewCallExpr(pos, ir.OCALL, r.expr(), nil, r.exprList())
 		*n.PtrInit() = init
 		n.IsDDD = r.bool()
 		return n
@@ -1236,5 +1236,5 @@ func (r *importReader) exprsOrNil() (a, b ir.Node) {
 }
 
 func builtinCall(pos src.XPos, op ir.Op) *ir.CallExpr {
-	return ir.NewCallExpr(pos, ir.OCALL, ir.NewIdent(base.Pos, types.BuiltinPkg.Lookup(ir.OpNames[op])), nil)
+	return ir.NewCallExpr(pos, ir.OCALL, ir.NewIdent(base.Pos, types.BuiltinPkg.Lookup(ir.OpNames[op])), nil, nil)
 }
diff --git a/src/cmd/compile/internal/typecheck/mkbuiltin.go b/src/cmd/compile/internal/typecheck/mkbuiltin.go
index 07f4b767e8..75037235ba 100644
--- a/src/cmd/compile/internal/typecheck/mkbuiltin.go
+++ b/src/cmd/compile/internal/typecheck/mkbuiltin.go
@@ -169,7 +169,7 @@ func (i *typeInterner) mktype(t ast.Expr) string {
 		}
 		return fmt.Sprintf("types.NewChan(%s, %s)", i.subtype(t.Value), dir)
 	case *ast.FuncType:
-		return fmt.Sprintf("types.NewSignature(types.NoPkg, nil, %s, %s)", i.fields(t.Params, false), i.fields(t.Results, false))
+		return fmt.Sprintf("types.NewSignature(types.NoPkg, nil, nil, %s, %s)", i.fields(t.Params, false), i.fields(t.Results, false))
 	case *ast.InterfaceType:
 		if len(t.Methods.List) != 0 {
 			log.Fatal("non-empty interfaces unsupported")
diff --git a/src/cmd/compile/internal/typecheck/type.go b/src/cmd/compile/internal/typecheck/type.go
index 6fdafef77d..af694c2d94 100644
--- a/src/cmd/compile/internal/typecheck/type.go
+++ b/src/cmd/compile/internal/typecheck/type.go
@@ -88,7 +88,7 @@ func tcFuncType(n *ir.FuncType) ir.Node {
 		recv = tcField(n.Recv, misc)
 	}
 
-	t := types.NewSignature(types.LocalPkg, recv, tcFields(n.Params, misc), tcFields(n.Results, misc))
+	t := types.NewSignature(types.LocalPkg, recv, nil, tcFields(n.Params, misc), tcFields(n.Results, misc))
 	checkdupfields("argument", t.Recvs().FieldSlice(), t.Params().FieldSlice(), t.Results().FieldSlice())
 
 	base.Pos = lno
diff --git a/src/cmd/compile/internal/typecheck/universe.go b/src/cmd/compile/internal/typecheck/universe.go
index 402b8deeb3..c4c034184b 100644
--- a/src/cmd/compile/internal/typecheck/universe.go
+++ b/src/cmd/compile/internal/typecheck/universe.go
@@ -329,7 +329,7 @@ func InitUniverse() {
 }
 
 func makeErrorInterface() *types.Type {
-	sig := types.NewSignature(types.NoPkg, fakeRecvField(), nil, []*types.Field{
+	sig := types.NewSignature(types.NoPkg, fakeRecvField(), nil, nil, []*types.Field{
 		types.NewField(src.NoXPos, nil, types.Types[types.TSTRING]),
 	})
 	method := types.NewField(src.NoXPos, Lookup("Error"), sig)
diff --git a/src/cmd/compile/internal/types/kind_string.go b/src/cmd/compile/internal/types/kind_string.go
index 1e1e846240..ae24a58b92 100644
--- a/src/cmd/compile/internal/types/kind_string.go
+++ b/src/cmd/compile/internal/types/kind_string.go
@@ -37,20 +37,21 @@ func _() {
 	_ = x[TANY-26]
 	_ = x[TSTRING-27]
 	_ = x[TUNSAFEPTR-28]
-	_ = x[TIDEAL-29]
-	_ = x[TNIL-30]
-	_ = x[TBLANK-31]
-	_ = x[TFUNCARGS-32]
-	_ = x[TCHANARGS-33]
-	_ = x[TSSA-34]
-	_ = x[TTUPLE-35]
-	_ = x[TRESULTS-36]
-	_ = x[NTYPE-37]
+	_ = x[TTYPEPARAM-29]
+	_ = x[TIDEAL-30]
+	_ = x[TNIL-31]
+	_ = x[TBLANK-32]
+	_ = x[TFUNCARGS-33]
+	_ = x[TCHANARGS-34]
+	_ = x[TSSA-35]
+	_ = x[TTUPLE-36]
+	_ = x[TRESULTS-37]
+	_ = x[NTYPE-38]
 }
 
-const _Kind_name = "xxxINT8UINT8INT16UINT16INT32UINT32INT64UINT64INTUINTUINTPTRCOMPLEX64COMPLEX128FLOAT32FLOAT64BOOLPTRFUNCSLICEARRAYSTRUCTCHANMAPINTERFORWANYSTRINGUNSAFEPTRIDEALNILBLANKFUNCARGSCHANARGSSSATUPLERESULTSNTYPE"
+const _Kind_name = "xxxINT8UINT8INT16UINT16INT32UINT32INT64UINT64INTUINTUINTPTRCOMPLEX64COMPLEX128FLOAT32FLOAT64BOOLPTRFUNCSLICEARRAYSTRUCTCHANMAPINTERFORWANYSTRINGUNSAFEPTRTYPEPARAMIDEALNILBLANKFUNCARGSCHANARGSSSATUPLERESULTSNTYPE"
 
-var _Kind_index = [...]uint8{0, 3, 7, 12, 17, 23, 28, 34, 39, 45, 48, 52, 59, 68, 78, 85, 92, 96, 99, 103, 108, 113, 119, 123, 126, 131, 135, 138, 144, 153, 158, 161, 166, 174, 182, 185, 190, 197, 202}
+var _Kind_index = [...]uint8{0, 3, 7, 12, 17, 23, 28, 34, 39, 45, 48, 52, 59, 68, 78, 85, 92, 96, 99, 103, 108, 113, 119, 123, 126, 131, 135, 138, 144, 153, 162, 167, 170, 175, 183, 191, 194, 199, 206, 211}
 
 func (i Kind) String() string {
 	if i >= Kind(len(_Kind_index)-1) {
diff --git a/src/cmd/compile/internal/types/sizeof_test.go b/src/cmd/compile/internal/types/sizeof_test.go
index 675739f7f6..6937283d69 100644
--- a/src/cmd/compile/internal/types/sizeof_test.go
+++ b/src/cmd/compile/internal/types/sizeof_test.go
@@ -24,7 +24,7 @@ func TestSizeof(t *testing.T) {
 		{Type{}, 56, 96},
 		{Map{}, 20, 40},
 		{Forward{}, 20, 32},
-		{Func{}, 24, 40},
+		{Func{}, 28, 48},
 		{Struct{}, 16, 32},
 		{Interface{}, 8, 16},
 		{Chan{}, 8, 16},
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 0dfbef8af1..1d6edcda47 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -72,6 +72,7 @@ const (
 	TANY
 	TSTRING
 	TUNSAFEPTR
+	TTYPEPARAM
 
 	// pseudo-types for literals
 	TIDEAL // untyped numeric constants
@@ -150,6 +151,7 @@ type Type struct {
 	// TARRAY: *Array
 	// TSLICE: Slice
 	// TSSA: string
+	// TTYPEPARAM:  *Interface (though we may not need to store/use the Interface info)
 	Extra interface{}
 
 	// Width is the width of this Type in bytes.
@@ -283,6 +285,7 @@ type Func struct {
 	Receiver *Type // function receiver
 	Results  *Type // function results
 	Params   *Type // function params
+	Tparams  *Type // type params of receiver (if method) or function
 
 	pkg *Pkg
 
@@ -318,6 +321,7 @@ const (
 	FunargRcvr           // receiver
 	FunargParams         // input parameters
 	FunargResults        // output results
+	FunargTparams        // type params
 )
 
 // StructType returns t's extra struct-specific fields.
@@ -1645,8 +1649,8 @@ func NewInterface(pkg *Pkg, methods []*Field) *Type {
 }
 
 // NewSignature returns a new function type for the given receiver,
-// parameters, and results, any of which may be nil.
-func NewSignature(pkg *Pkg, recv *Field, params, results []*Field) *Type {
+// parametes, results, and type parameters, any of which may be nil.
+func NewSignature(pkg *Pkg, recv *Field, tparams, params, results []*Field) *Type {
 	var recvs []*Field
 	if recv != nil {
 		recvs = []*Field{recv}
@@ -1665,6 +1669,7 @@ func NewSignature(pkg *Pkg, recv *Field, params, results []*Field) *Type {
 	}
 
 	ft.Receiver = funargs(recvs, FunargRcvr)
+	ft.Tparams = funargs(tparams, FunargTparams)
 	ft.Params = funargs(params, FunargParams)
 	ft.Results = funargs(results, FunargResults)
 	ft.pkg = pkg
diff --git a/src/cmd/compile/internal/walk/builtin.go b/src/cmd/compile/internal/walk/builtin.go
index 97f9de9c1d..60cbd66370 100644
--- a/src/cmd/compile/internal/walk/builtin.go
+++ b/src/cmd/compile/internal/walk/builtin.go
@@ -631,7 +631,7 @@ func walkPrint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 			continue
 		}
 
-		r := ir.NewCallExpr(base.Pos, ir.OCALL, on, nil)
+		r := ir.NewCallExpr(base.Pos, ir.OCALL, on, nil, nil)
 		if params := on.Type().Params().FieldSlice(); len(params) > 0 {
 			t := params[0].Type
 			if !types.Identical(t, n.Type()) {
diff --git a/src/cmd/compile/internal/walk/closure.go b/src/cmd/compile/internal/walk/closure.go
index 1d1cbc2054..d7d6105816 100644
--- a/src/cmd/compile/internal/walk/closure.go
+++ b/src/cmd/compile/internal/walk/closure.go
@@ -68,7 +68,7 @@ func directClosureCall(n *ir.CallExpr) {
 
 	// Create new function type with parameters prepended, and
 	// then update type and declarations.
-	typ = types.NewSignature(typ.Pkg(), nil, append(params, typ.Params().FieldSlice()...), typ.Results().FieldSlice())
+	typ = types.NewSignature(typ.Pkg(), nil, nil, append(params, typ.Params().FieldSlice()...), typ.Results().FieldSlice())
 	f.SetType(typ)
 	clofn.Dcl = append(decls, clofn.Dcl...)
 
diff --git a/src/cmd/compile/internal/walk/compare.go b/src/cmd/compile/internal/walk/compare.go
index 7c385c0e0d..a076cdbe1a 100644
--- a/src/cmd/compile/internal/walk/compare.go
+++ b/src/cmd/compile/internal/walk/compare.go
@@ -160,7 +160,7 @@ func walkCompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 		}
 
 		fn, needsize := eqFor(t)
-		call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
+		call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil, nil)
 		call.Args.Append(typecheck.NodAddr(cmpl))
 		call.Args.Append(typecheck.NodAddr(cmpr))
 		if needsize {
@@ -428,7 +428,7 @@ func eqFor(t *types.Type) (n ir.Node, needsize bool) {
 		sym := reflectdata.TypeSymPrefix(".eq", t)
 		n := typecheck.NewName(sym)
 		ir.MarkFunc(n)
-		n.SetType(types.NewSignature(types.NoPkg, nil, []*types.Field{
+		n.SetType(types.NewSignature(types.NoPkg, nil, nil, []*types.Field{
 			types.NewField(base.Pos, nil, types.NewPtr(t)),
 			types.NewField(base.Pos, nil, types.NewPtr(t)),
 		}, []*types.Field{
diff --git a/src/cmd/compile/internal/walk/complit.go b/src/cmd/compile/internal/walk/complit.go
index 73442dc404..95f9d18f8c 100644
--- a/src/cmd/compile/internal/walk/complit.go
+++ b/src/cmd/compile/internal/walk/complit.go
@@ -416,7 +416,7 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 
 func maplit(n *ir.CompLitExpr, m ir.Node, init *ir.Nodes) {
 	// make the map var
-	a := ir.NewCallExpr(base.Pos, ir.OMAKE, nil, nil)
+	a := ir.NewCallExpr(base.Pos, ir.OMAKE, nil, nil, nil)
 	a.SetEsc(n.Esc())
 	a.Args = []ir.Node{ir.TypeNode(n.Type()), ir.NewInt(int64(len(n.List)))}
 	litas(m, a, init)
diff --git a/src/cmd/compile/internal/walk/convert.go b/src/cmd/compile/internal/walk/convert.go
index fa8e2c0bb8..30bac5462f 100644
--- a/src/cmd/compile/internal/walk/convert.go
+++ b/src/cmd/compile/internal/walk/convert.go
@@ -145,7 +145,7 @@ func walkConvInterface(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 		types.CalcSize(fromType)
 		fn = typecheck.SubstArgTypes(fn, fromType)
 		types.CalcSize(fn.Type())
-		call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
+		call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil, nil)
 		call.Args = []ir.Node{n.X}
 		e := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), safeExpr(walkExpr(typecheck.Expr(call), init), init))
 		e.SetType(toType)
@@ -180,7 +180,7 @@ func walkConvInterface(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 	fn := typecheck.LookupRuntime(fnname)
 	fn = typecheck.SubstArgTypes(fn, fromType, toType)
 	types.CalcSize(fn.Type())
-	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
+	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil, nil)
 	call.Args = []ir.Node{tab, v}
 	return walkExpr(typecheck.Expr(call), init)
 }
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index d7a20206c8..b7aeb53e43 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -469,7 +469,7 @@ func walkAddString(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
 	}
 
 	cat := typecheck.LookupRuntime(fn)
-	r := ir.NewCallExpr(base.Pos, ir.OCALL, cat, nil)
+	r := ir.NewCallExpr(base.Pos, ir.OCALL, cat, nil, nil)
 	r.Args = args
 	r1 := typecheck.Expr(r)
 	r1 = walkExpr(r1, init)
diff --git a/src/cmd/compile/internal/walk/stmt.go b/src/cmd/compile/internal/walk/stmt.go
index 46a621c2ba..8a076ca558 100644
--- a/src/cmd/compile/internal/walk/stmt.go
+++ b/src/cmd/compile/internal/walk/stmt.go
@@ -278,7 +278,7 @@ func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 		}
 		args[i] = ir.NewConvExpr(base.Pos, origArg.Op(), origArg.Type(), args[i])
 	}
-	call := ir.NewCallExpr(base.Pos, n.Op(), n.X, args)
+	call := ir.NewCallExpr(base.Pos, n.Op(), n.X, nil, args)
 	if !isBuiltinCall {
 		call.SetOp(ir.OCALL)
 		call.IsDDD = n.IsDDD
@@ -291,6 +291,6 @@ func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	typecheck.Stmts(fn.Body)
 	typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
 
-	call = ir.NewCallExpr(base.Pos, ir.OCALL, fn.Nname, n.Args)
+	call = ir.NewCallExpr(base.Pos, ir.OCALL, fn.Nname, nil, n.Args)
 	return walkExpr(typecheck.Stmt(call), init)
 }
diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index b47d96dc4c..91b7e34d54 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -113,7 +113,7 @@ func vmkcall(fn ir.Node, t *types.Type, init *ir.Nodes, va []ir.Node) *ir.CallEx
 		base.Fatalf("vmkcall %v needs %v args got %v", fn, n, len(va))
 	}
 
-	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, va)
+	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil, va)
 	typecheck.Call(call)
 	call.SetType(t)
 	return walkExpr(call, init).(*ir.CallExpr)
-- 
GitLab


From 507e641963c6e4277ae4bc9d5f44469d2b4c9c8f Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 28 Jan 2021 15:52:36 -0800
Subject: [PATCH 0579/2400] [dev.typeparams] cmd/compile/internal/typecheck:
 declutter generated builtin.go (cleanup)

Even though builtin.go is generated, there's no need for
it to be so huge in terms code size. Nor does ultimate
speed matter here.

Added two simple helper functions that are not inlined,
which reduce the amount of code generated for this file
from 77881 bytes to 27641 bytes of assembly (per compiler
-S output) and reduce the compile binary by ~140KiB
(of course that's insignificant given the 22MiB file size).

Change-Id: I3058ec62788b33eaeff2f9d5fe975b8e41cbf172
Reviewed-on: https://go-review.googlesource.com/c/go/+/287772
Trust: Robert Griesemer <gri@golang.org>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/typecheck/builtin.go | 198 ++++++++++--------
 .../compile/internal/typecheck/mkbuiltin.go   |  28 ++-
 2 files changed, 130 insertions(+), 96 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/builtin.go b/src/cmd/compile/internal/typecheck/builtin.go
index 3f93438dfe..f9a4f6aef4 100644
--- a/src/cmd/compile/internal/typecheck/builtin.go
+++ b/src/cmd/compile/internal/typecheck/builtin.go
@@ -205,139 +205,153 @@ var runtimeDecls = [...]struct {
 	{"arm64HasATOMICS", varTag, 6},
 }
 
+// Not inlining this function removes a significant chunk of init code.
+//go:noinline
+func newSig(params, results []*types.Field) *types.Type {
+	return types.NewSignature(types.NoPkg, nil, nil, params, results)
+}
+
+func params(tlist ...*types.Type) []*types.Field {
+	flist := make([]*types.Field, len(tlist))
+	for i, typ := range tlist {
+		flist[i] = types.NewField(src.NoXPos, nil, typ)
+	}
+	return flist
+}
+
 func runtimeTypes() []*types.Type {
 	var typs [132]*types.Type
 	typs[0] = types.ByteType
 	typs[1] = types.NewPtr(typs[0])
 	typs[2] = types.Types[types.TANY]
 	typs[3] = types.NewPtr(typs[2])
-	typs[4] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])})
+	typs[4] = newSig(params(typs[1]), params(typs[3]))
 	typs[5] = types.Types[types.TUINTPTR]
 	typs[6] = types.Types[types.TBOOL]
 	typs[7] = types.Types[types.TUNSAFEPTR]
-	typs[8] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[6])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
-	typs[9] = types.NewSignature(types.NoPkg, nil, nil, nil, nil)
+	typs[8] = newSig(params(typs[5], typs[1], typs[6]), params(typs[7]))
+	typs[9] = newSig(nil, nil)
 	typs[10] = types.Types[types.TINTER]
-	typs[11] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[10])}, nil)
+	typs[11] = newSig(params(typs[10]), nil)
 	typs[12] = types.Types[types.TINT32]
 	typs[13] = types.NewPtr(typs[12])
-	typs[14] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[13])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[10])})
+	typs[14] = newSig(params(typs[13]), params(typs[10]))
 	typs[15] = types.Types[types.TINT]
-	typs[16] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[15])}, nil)
+	typs[16] = newSig(params(typs[15], typs[15]), nil)
 	typs[17] = types.Types[types.TUINT]
-	typs[18] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[17]), types.NewField(src.NoXPos, nil, typs[15])}, nil)
-	typs[19] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])}, nil)
+	typs[18] = newSig(params(typs[17], typs[15]), nil)
+	typs[19] = newSig(params(typs[6]), nil)
 	typs[20] = types.Types[types.TFLOAT64]
-	typs[21] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])}, nil)
+	typs[21] = newSig(params(typs[20]), nil)
 	typs[22] = types.Types[types.TINT64]
-	typs[23] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[22])}, nil)
+	typs[23] = newSig(params(typs[22]), nil)
 	typs[24] = types.Types[types.TUINT64]
-	typs[25] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[24])}, nil)
+	typs[25] = newSig(params(typs[24]), nil)
 	typs[26] = types.Types[types.TCOMPLEX128]
-	typs[27] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[26])}, nil)
+	typs[27] = newSig(params(typs[26]), nil)
 	typs[28] = types.Types[types.TSTRING]
-	typs[29] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])}, nil)
-	typs[30] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[2])}, nil)
-	typs[31] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[5])}, nil)
+	typs[29] = newSig(params(typs[28]), nil)
+	typs[30] = newSig(params(typs[2]), nil)
+	typs[31] = newSig(params(typs[5]), nil)
 	typs[32] = types.NewArray(typs[0], 32)
 	typs[33] = types.NewPtr(typs[32])
-	typs[34] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
-	typs[35] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
-	typs[36] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
-	typs[37] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+	typs[34] = newSig(params(typs[33], typs[28], typs[28]), params(typs[28]))
+	typs[35] = newSig(params(typs[33], typs[28], typs[28], typs[28]), params(typs[28]))
+	typs[36] = newSig(params(typs[33], typs[28], typs[28], typs[28], typs[28]), params(typs[28]))
+	typs[37] = newSig(params(typs[33], typs[28], typs[28], typs[28], typs[28], typs[28]), params(typs[28]))
 	typs[38] = types.NewSlice(typs[28])
-	typs[39] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[38])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
-	typs[40] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15])})
+	typs[39] = newSig(params(typs[33], typs[38]), params(typs[28]))
+	typs[40] = newSig(params(typs[28], typs[28]), params(typs[15]))
 	typs[41] = types.NewArray(typs[0], 4)
 	typs[42] = types.NewPtr(typs[41])
-	typs[43] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[42]), types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
-	typs[44] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
-	typs[45] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+	typs[43] = newSig(params(typs[42], typs[22]), params(typs[28]))
+	typs[44] = newSig(params(typs[33], typs[1], typs[15]), params(typs[28]))
+	typs[45] = newSig(params(typs[1], typs[15]), params(typs[28]))
 	typs[46] = types.RuneType
 	typs[47] = types.NewSlice(typs[46])
-	typs[48] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[47])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])})
+	typs[48] = newSig(params(typs[33], typs[47]), params(typs[28]))
 	typs[49] = types.NewSlice(typs[0])
-	typs[50] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[33]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[49])})
+	typs[50] = newSig(params(typs[33], typs[28]), params(typs[49]))
 	typs[51] = types.NewArray(typs[46], 32)
 	typs[52] = types.NewPtr(typs[51])
-	typs[53] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[52]), types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[47])})
-	typs[54] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[5])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15])})
-	typs[55] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[28]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[46]), types.NewField(src.NoXPos, nil, typs[15])})
-	typs[56] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[28])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15])})
-	typs[57] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[2])})
-	typs[58] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
-	typs[59] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[2])})
-	typs[60] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[2]), types.NewField(src.NoXPos, nil, typs[6])})
-	typs[61] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[1])}, nil)
-	typs[62] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1])}, nil)
+	typs[53] = newSig(params(typs[52], typs[28]), params(typs[47]))
+	typs[54] = newSig(params(typs[3], typs[15], typs[3], typs[15], typs[5]), params(typs[15]))
+	typs[55] = newSig(params(typs[28], typs[15]), params(typs[46], typs[15]))
+	typs[56] = newSig(params(typs[28]), params(typs[15]))
+	typs[57] = newSig(params(typs[1], typs[2]), params(typs[2]))
+	typs[58] = newSig(params(typs[2]), params(typs[7]))
+	typs[59] = newSig(params(typs[1], typs[3]), params(typs[2]))
+	typs[60] = newSig(params(typs[1], typs[2]), params(typs[2], typs[6]))
+	typs[61] = newSig(params(typs[1], typs[1], typs[1]), nil)
+	typs[62] = newSig(params(typs[1]), nil)
 	typs[63] = types.NewPtr(typs[5])
-	typs[64] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[63]), types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[7])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
+	typs[64] = newSig(params(typs[63], typs[7], typs[7]), params(typs[6]))
 	typs[65] = types.Types[types.TUINT32]
-	typs[66] = types.NewSignature(types.NoPkg, nil, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[65])})
+	typs[66] = newSig(nil, params(typs[65]))
 	typs[67] = types.NewMap(typs[2], typs[2])
-	typs[68] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[22]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[67])})
-	typs[69] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[67])})
-	typs[70] = types.NewSignature(types.NoPkg, nil, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[67])})
-	typs[71] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])})
-	typs[72] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])})
-	typs[73] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[1])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])})
-	typs[74] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[6])})
-	typs[75] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[2])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[6])})
-	typs[76] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[1])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[6])})
-	typs[77] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
-	typs[78] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67]), types.NewField(src.NoXPos, nil, typs[2])}, nil)
-	typs[79] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3])}, nil)
-	typs[80] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[67])}, nil)
+	typs[68] = newSig(params(typs[1], typs[22], typs[3]), params(typs[67]))
+	typs[69] = newSig(params(typs[1], typs[15], typs[3]), params(typs[67]))
+	typs[70] = newSig(nil, params(typs[67]))
+	typs[71] = newSig(params(typs[1], typs[67], typs[3]), params(typs[3]))
+	typs[72] = newSig(params(typs[1], typs[67], typs[2]), params(typs[3]))
+	typs[73] = newSig(params(typs[1], typs[67], typs[3], typs[1]), params(typs[3]))
+	typs[74] = newSig(params(typs[1], typs[67], typs[3]), params(typs[3], typs[6]))
+	typs[75] = newSig(params(typs[1], typs[67], typs[2]), params(typs[3], typs[6]))
+	typs[76] = newSig(params(typs[1], typs[67], typs[3], typs[1]), params(typs[3], typs[6]))
+	typs[77] = newSig(params(typs[1], typs[67], typs[3]), nil)
+	typs[78] = newSig(params(typs[1], typs[67], typs[2]), nil)
+	typs[79] = newSig(params(typs[3]), nil)
+	typs[80] = newSig(params(typs[1], typs[67]), nil)
 	typs[81] = types.NewChan(typs[2], types.Cboth)
-	typs[82] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[81])})
-	typs[83] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[81])})
+	typs[82] = newSig(params(typs[1], typs[22]), params(typs[81]))
+	typs[83] = newSig(params(typs[1], typs[15]), params(typs[81]))
 	typs[84] = types.NewChan(typs[2], types.Crecv)
-	typs[85] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[84]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
-	typs[86] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[84]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
+	typs[85] = newSig(params(typs[84], typs[3]), nil)
+	typs[86] = newSig(params(typs[84], typs[3]), params(typs[6]))
 	typs[87] = types.NewChan(typs[2], types.Csend)
-	typs[88] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[87]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
+	typs[88] = newSig(params(typs[87], typs[3]), nil)
 	typs[89] = types.NewArray(typs[0], 3)
 	typs[90] = types.NewStruct(types.NoPkg, []*types.Field{types.NewField(src.NoXPos, Lookup("enabled"), typs[6]), types.NewField(src.NoXPos, Lookup("pad"), typs[89]), types.NewField(src.NoXPos, Lookup("needed"), typs[6]), types.NewField(src.NoXPos, Lookup("cgo"), typs[6]), types.NewField(src.NoXPos, Lookup("alignme"), typs[24])})
-	typs[91] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
-	typs[92] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[3])}, nil)
-	typs[93] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15])})
-	typs[94] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[87]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
-	typs[95] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[84])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
+	typs[91] = newSig(params(typs[1], typs[3], typs[3]), nil)
+	typs[92] = newSig(params(typs[1], typs[3]), nil)
+	typs[93] = newSig(params(typs[1], typs[3], typs[15], typs[3], typs[15]), params(typs[15]))
+	typs[94] = newSig(params(typs[87], typs[3]), params(typs[6]))
+	typs[95] = newSig(params(typs[3], typs[84]), params(typs[6]))
 	typs[96] = types.NewPtr(typs[6])
-	typs[97] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[96]), types.NewField(src.NoXPos, nil, typs[84])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
-	typs[98] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[63])}, nil)
-	typs[99] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[63]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[6])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[6])})
-	typs[100] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
-	typs[101] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[22]), types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
-	typs[102] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[15]), types.NewField(src.NoXPos, nil, typs[7])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[7])})
+	typs[97] = newSig(params(typs[3], typs[96], typs[84]), params(typs[6]))
+	typs[98] = newSig(params(typs[63]), nil)
+	typs[99] = newSig(params(typs[1], typs[1], typs[63], typs[15], typs[15], typs[6]), params(typs[15], typs[6]))
+	typs[100] = newSig(params(typs[1], typs[15], typs[15]), params(typs[7]))
+	typs[101] = newSig(params(typs[1], typs[22], typs[22]), params(typs[7]))
+	typs[102] = newSig(params(typs[1], typs[15], typs[15], typs[7]), params(typs[7]))
 	typs[103] = types.NewSlice(typs[2])
-	typs[104] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[103]), types.NewField(src.NoXPos, nil, typs[15])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[103])})
-	typs[105] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
-	typs[106] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
-	typs[107] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[5])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
-	typs[108] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[3]), types.NewField(src.NoXPos, nil, typs[3])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
-	typs[109] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[7])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[6])})
-	typs[110] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[5])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[5])})
-	typs[111] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[5])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[5])})
-	typs[112] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[22]), types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[22])})
-	typs[113] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[24]), types.NewField(src.NoXPos, nil, typs[24])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[24])})
-	typs[114] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[22])})
-	typs[115] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[24])})
-	typs[116] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[65])})
-	typs[117] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[22])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])})
-	typs[118] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[24])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])})
-	typs[119] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[65])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[20])})
-	typs[120] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[26]), types.NewField(src.NoXPos, nil, typs[26])}, []*types.Field{types.NewField(src.NoXPos, nil, typs[26])})
-	typs[121] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
-	typs[122] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[5]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
-	typs[123] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[1]), types.NewField(src.NoXPos, nil, typs[5])}, nil)
+	typs[104] = newSig(params(typs[1], typs[103], typs[15]), params(typs[103]))
+	typs[105] = newSig(params(typs[3], typs[3], typs[5]), nil)
+	typs[106] = newSig(params(typs[7], typs[5]), nil)
+	typs[107] = newSig(params(typs[3], typs[3], typs[5]), params(typs[6]))
+	typs[108] = newSig(params(typs[3], typs[3]), params(typs[6]))
+	typs[109] = newSig(params(typs[7], typs[7]), params(typs[6]))
+	typs[110] = newSig(params(typs[7], typs[5], typs[5]), params(typs[5]))
+	typs[111] = newSig(params(typs[7], typs[5]), params(typs[5]))
+	typs[112] = newSig(params(typs[22], typs[22]), params(typs[22]))
+	typs[113] = newSig(params(typs[24], typs[24]), params(typs[24]))
+	typs[114] = newSig(params(typs[20]), params(typs[22]))
+	typs[115] = newSig(params(typs[20]), params(typs[24]))
+	typs[116] = newSig(params(typs[20]), params(typs[65]))
+	typs[117] = newSig(params(typs[22]), params(typs[20]))
+	typs[118] = newSig(params(typs[24]), params(typs[20]))
+	typs[119] = newSig(params(typs[65]), params(typs[20]))
+	typs[120] = newSig(params(typs[26], typs[26]), params(typs[26]))
+	typs[121] = newSig(params(typs[5], typs[5]), nil)
+	typs[122] = newSig(params(typs[5], typs[5], typs[5]), nil)
+	typs[123] = newSig(params(typs[7], typs[1], typs[5]), nil)
 	typs[124] = types.NewSlice(typs[7])
-	typs[125] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[7]), types.NewField(src.NoXPos, nil, typs[124])}, nil)
+	typs[125] = newSig(params(typs[7], typs[124]), nil)
 	typs[126] = types.Types[types.TUINT8]
-	typs[127] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[126]), types.NewField(src.NoXPos, nil, typs[126])}, nil)
+	typs[127] = newSig(params(typs[126], typs[126]), nil)
 	typs[128] = types.Types[types.TUINT16]
-	typs[129] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[128]), types.NewField(src.NoXPos, nil, typs[128])}, nil)
-	typs[130] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[65]), types.NewField(src.NoXPos, nil, typs[65])}, nil)
-	typs[131] = types.NewSignature(types.NoPkg, nil, nil, []*types.Field{types.NewField(src.NoXPos, nil, typs[24]), types.NewField(src.NoXPos, nil, typs[24])}, nil)
+	typs[129] = newSig(params(typs[128], typs[128]), nil)
+	typs[130] = newSig(params(typs[65], typs[65]), nil)
+	typs[131] = newSig(params(typs[24], typs[24]), nil)
 	return typs[:]
 }
diff --git a/src/cmd/compile/internal/typecheck/mkbuiltin.go b/src/cmd/compile/internal/typecheck/mkbuiltin.go
index 75037235ba..bef510a578 100644
--- a/src/cmd/compile/internal/typecheck/mkbuiltin.go
+++ b/src/cmd/compile/internal/typecheck/mkbuiltin.go
@@ -102,6 +102,21 @@ func mkbuiltin(w io.Writer, name string) {
 	}
 	fmt.Fprintln(w, "}")
 
+	fmt.Fprintln(w, `
+// Not inlining this function removes a significant chunk of init code.
+//go:noinline
+func newSig(params, results []*types.Field) *types.Type {
+	return types.NewSignature(types.NoPkg, nil, nil, params, results)
+}
+
+func params(tlist ...*types.Type) []*types.Field {
+	flist := make([]*types.Field, len(tlist))
+	for i, typ := range tlist {
+		flist[i] = types.NewField(src.NoXPos, nil, typ)
+	}
+	return flist
+}`)
+
 	fmt.Fprintln(w)
 	fmt.Fprintf(w, "func %sTypes() []*types.Type {\n", name)
 	fmt.Fprintf(w, "var typs [%d]*types.Type\n", len(interner.typs))
@@ -169,7 +184,7 @@ func (i *typeInterner) mktype(t ast.Expr) string {
 		}
 		return fmt.Sprintf("types.NewChan(%s, %s)", i.subtype(t.Value), dir)
 	case *ast.FuncType:
-		return fmt.Sprintf("types.NewSignature(types.NoPkg, nil, nil, %s, %s)", i.fields(t.Params, false), i.fields(t.Results, false))
+		return fmt.Sprintf("newSig(%s, %s)", i.fields(t.Params, false), i.fields(t.Results, false))
 	case *ast.InterfaceType:
 		if len(t.Methods.List) != 0 {
 			log.Fatal("non-empty interfaces unsupported")
@@ -192,22 +207,27 @@ func (i *typeInterner) fields(fl *ast.FieldList, keepNames bool) string {
 	if fl == nil || len(fl.List) == 0 {
 		return "nil"
 	}
+
 	var res []string
 	for _, f := range fl.List {
 		typ := i.subtype(f.Type)
 		if len(f.Names) == 0 {
-			res = append(res, fmt.Sprintf("types.NewField(src.NoXPos, nil, %s)", typ))
+			res = append(res, typ)
 		} else {
 			for _, name := range f.Names {
 				if keepNames {
 					res = append(res, fmt.Sprintf("types.NewField(src.NoXPos, Lookup(%q), %s)", name.Name, typ))
 				} else {
-					res = append(res, fmt.Sprintf("types.NewField(src.NoXPos, nil, %s)", typ))
+					res = append(res, typ)
 				}
 			}
 		}
 	}
-	return fmt.Sprintf("[]*types.Field{%s}", strings.Join(res, ", "))
+
+	if keepNames {
+		return fmt.Sprintf("[]*types.Field{%s}", strings.Join(res, ", "))
+	}
+	return fmt.Sprintf("params(%s)", strings.Join(res, ", "))
 }
 
 func intconst(e ast.Expr) int64 {
-- 
GitLab


From a59cb5109d49ac0dc09337449b9c7760ecc66c0e Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 28 Jan 2021 14:29:25 -0800
Subject: [PATCH 0580/2400] [dev.typeparams] cmd/compile/internal/types2:
 handle untyped constant arithmetic overflow

Factor out the existing "constant representation" check after
untyped constant arithmetic and combine with an overflow check.

Use a better heuristic for determining the error position if we
know the error is for a constant operand that is the result of an
arithmetic expression.

Related cleanups.

With this change, untyped constant arithmetic reports an error
when (integer) constants become too large (> 2048 bits). Before,
such arithmetic was only limited by space and time.

Change-Id: Id3cea66c8ba697ff4c7fd1e848f350d9713e3c75
Reviewed-on: https://go-review.googlesource.com/c/go/+/287832
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/expr.go       | 145 +++++++++++-------
 .../internal/types2/fixedbugs/issue20583.src  |   2 +-
 .../compile/internal/types2/stdlib_test.go    |   1 -
 src/cmd/compile/internal/types2/stmt.go       |   2 +-
 .../internal/types2/testdata/const0.src       |   8 +
 test/run.go                                   |   2 +-
 6 files changed, 99 insertions(+), 61 deletions(-)

diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 3378c606ad..c66e115c1f 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -83,13 +83,67 @@ func (check *Checker) op(m opPredicates, x *operand, op syntax.Operator) bool {
 	return true
 }
 
-// The unary expression e may be nil. It's passed in for better error messages only.
-func (check *Checker) unary(x *operand, e *syntax.Operation, op syntax.Operator) {
-	switch op {
+// overflow checks that the constant x is representable by its type.
+// For untyped constants, it checks that the value doesn't become
+// arbitrarily large.
+func (check *Checker) overflow(x *operand) {
+	assert(x.mode == constant_)
+
+	// If the corresponding expression is an operation, use the
+	// operator position rather than the start of the expression
+	// as error position.
+	pos := startPos(x.expr)
+	what := "" // operator description, if any
+	if op, _ := x.expr.(*syntax.Operation); op != nil {
+		pos = op.Pos()
+		if int(op.Op) < len(op2str) {
+			what = op2str[op.Op]
+		}
+	}
+
+	if x.val.Kind() == constant.Unknown {
+		// TODO(gri) We should report exactly what went wrong. At the
+		//           moment we don't have the (go/constant) API for that.
+		//           See also TODO in go/constant/value.go.
+		check.errorf(pos, "constant result is not representable")
+		return
+	}
+
+	// Typed constants must be representable in
+	// their type after each constant operation.
+	if isTyped(x.typ) {
+		check.representable(x, x.typ.Basic())
+		return
+	}
+
+	// Untyped integer values must not grow arbitrarily.
+	const limit = 4 * 512 // 512 is the constant precision - we need more because old tests had no limits
+	if x.val.Kind() == constant.Int && constant.BitLen(x.val) > limit {
+		check.errorf(pos, "constant %s overflow", what)
+		x.val = constant.MakeUnknown()
+	}
+}
+
+// This is only used for operations that may cause overflow.
+var op2str = [...]string{
+	syntax.Add: "addition",
+	syntax.Sub: "subtraction",
+	syntax.Xor: "bitwise XOR",
+	syntax.Mul: "multiplication",
+	syntax.Shl: "shift",
+}
+
+func (check *Checker) unary(x *operand, e *syntax.Operation) {
+	check.expr(x, e.X)
+	if x.mode == invalid {
+		return
+	}
+
+	switch e.Op {
 	case syntax.And:
 		// spec: "As an exception to the addressability
 		// requirement x may also be a composite literal."
-		if _, ok := unparen(x.expr).(*syntax.CompositeLit); !ok && x.mode != variable {
+		if _, ok := unparen(e.X).(*syntax.CompositeLit); !ok && x.mode != variable {
 			check.invalidOpf(x, "cannot take address of %s", x)
 			x.mode = invalid
 			return
@@ -116,26 +170,23 @@ func (check *Checker) unary(x *operand, e *syntax.Operation, op syntax.Operator)
 		return
 	}
 
-	if !check.op(unaryOpPredicates, x, op) {
+	if !check.op(unaryOpPredicates, x, e.Op) {
 		x.mode = invalid
 		return
 	}
 
 	if x.mode == constant_ {
-		typ := x.typ.Basic()
+		if x.val.Kind() == constant.Unknown {
+			// nothing to do (and don't cause an error below in the overflow check)
+			return
+		}
 		var prec uint
-		if isUnsigned(typ) {
-			prec = uint(check.conf.sizeof(typ) * 8)
-		}
-		x.val = constant.UnaryOp(op2tok[op], x.val, prec)
-		// Typed constants must be representable in
-		// their type after each constant operation.
-		if isTyped(typ) {
-			if e != nil {
-				x.expr = e // for better error message
-			}
-			check.representable(x, typ)
+		if isUnsigned(x.typ) {
+			prec = uint(check.conf.sizeof(x.typ) * 8)
 		}
+		x.val = constant.UnaryOp(op2tok[e.Op], x.val, prec)
+		x.expr = e
+		check.overflow(x)
 		return
 	}
 
@@ -701,7 +752,8 @@ func (check *Checker) comparison(x, y *operand, op syntax.Operator) {
 	x.typ = Typ[UntypedBool]
 }
 
-func (check *Checker) shift(x, y *operand, e *syntax.Operation, op syntax.Operator) {
+// If e != nil, it must be the shift expression; it may be nil for non-constant shifts.
+func (check *Checker) shift(x, y *operand, e syntax.Expr, op syntax.Operator) {
 	// TODO(gri) This function seems overly complex. Revisit.
 
 	var xval constant.Value
@@ -765,14 +817,8 @@ func (check *Checker) shift(x, y *operand, e *syntax.Operation, op syntax.Operat
 			}
 			// x is a constant so xval != nil and it must be of Int kind.
 			x.val = constant.Shift(xval, op2tok[op], uint(s))
-			// Typed constants must be representable in
-			// their type after each constant operation.
-			if isTyped(x.typ) {
-				if e != nil {
-					x.expr = e // for better error message
-				}
-				check.representable(x, x.typ.Basic())
-			}
+			x.expr = e
+			check.overflow(x)
 			return
 		}
 
@@ -833,9 +879,9 @@ var binaryOpPredicates = opPredicates{
 	syntax.OrOr:   isBoolean,
 }
 
-// The binary expression e may be nil. It's passed in for better error messages only.
-// TODO(gri) revisit use of e and opPos
-func (check *Checker) binary(x *operand, e *syntax.Operation, lhs, rhs syntax.Expr, op syntax.Operator, opPos syntax.Pos) {
+// If e != nil, it must be the binary expression; it may be nil for non-constant expressions
+// (when invoked for an assignment operation where the binary expression is implicit).
+func (check *Checker) binary(x *operand, e syntax.Expr, lhs, rhs syntax.Expr, op syntax.Operator) {
 	var y operand
 
 	check.expr(x, lhs)
@@ -906,31 +952,20 @@ func (check *Checker) binary(x *operand, e *syntax.Operation, lhs, rhs syntax.Ex
 	}
 
 	if x.mode == constant_ && y.mode == constant_ {
-		xval := x.val
-		yval := y.val
-		typ := x.typ.Basic()
-		// force integer division of integer operands
+		// if either x or y has an unknown value, the result is unknown
+		if x.val.Kind() == constant.Unknown || y.val.Kind() == constant.Unknown {
+			x.val = constant.MakeUnknown()
+			// x.typ is unchanged
+			return
+		}
+		// force integer division for integer operands
 		tok := op2tok[op]
-		if op == syntax.Div && isInteger(typ) {
+		if op == syntax.Div && isInteger(x.typ) {
 			tok = token.QUO_ASSIGN
 		}
-		x.val = constant.BinaryOp(xval, tok, yval)
-		// report error if valid operands lead to an invalid result
-		if xval.Kind() != constant.Unknown && yval.Kind() != constant.Unknown && x.val.Kind() == constant.Unknown {
-			// TODO(gri) We should report exactly what went wrong. At the
-			//           moment we don't have the (go/constant) API for that.
-			//           See also TODO in go/constant/value.go.
-			check.errorf(opPos, "constant result is not representable")
-			// TODO(gri) Should we mark operands with unknown values as invalid?
-		}
-		// Typed constants must be representable in
-		// their type after each constant operation.
-		if isTyped(typ) {
-			if e != nil {
-				x.expr = e // for better error message
-			}
-			check.representable(x, typ)
-		}
+		x.val = constant.BinaryOp(x.val, tok, y.val)
+		x.expr = e
+		check.overflow(x)
 		return
 	}
 
@@ -1722,11 +1757,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 				break
 			}
 
-			check.expr(x, e.X)
-			if x.mode == invalid {
-				goto Error
-			}
-			check.unary(x, e, e.Op)
+			check.unary(x, e)
 			if x.mode == invalid {
 				goto Error
 			}
@@ -1738,7 +1769,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 		}
 
 		// binary expression
-		check.binary(x, e, e.X, e.Y, e.Op, e.Y.Pos()) // TODO(gri) should have OpPos here (like in go/types)
+		check.binary(x, e, e.X, e.Y, e.Op)
 		if x.mode == invalid {
 			goto Error
 		}
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue20583.src b/src/cmd/compile/internal/types2/fixedbugs/issue20583.src
index efc1acee0f..85f11ecd38 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue20583.src
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue20583.src
@@ -8,5 +8,5 @@ const (
 	_ = 6e886451608i /* ERROR malformed constant */ /2
 	_ = 0 * 1e+1000000000 // ERROR malformed constant
 	x = 1e100000000
-	_ = x*x*x*x*x*x*x /* ERROR not representable */ // TODO(gri) this error should be at the last *
+	_ = x*x*x*x*x*x* /* ERROR not representable */ x
 )
diff --git a/src/cmd/compile/internal/types2/stdlib_test.go b/src/cmd/compile/internal/types2/stdlib_test.go
index ffd423be27..1dd3229852 100644
--- a/src/cmd/compile/internal/types2/stdlib_test.go
+++ b/src/cmd/compile/internal/types2/stdlib_test.go
@@ -178,7 +178,6 @@ func TestStdFixed(t *testing.T) {
 	testTestDir(t, filepath.Join(runtime.GOROOT(), "test", "fixedbugs"),
 		"bug248.go", "bug302.go", "bug369.go", // complex test instructions - ignore
 		"issue6889.go",   // gc-specific test
-		"issue7746.go",   // large constants - consumes too much memory
 		"issue11362.go",  // canonical import path check
 		"issue16369.go",  // go/types handles this correctly - not an issue
 		"issue18459.go",  // go/types doesn't check validity of //go:xxx directives
diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go
index ca0abcd10c..bab56b22ef 100644
--- a/src/cmd/compile/internal/types2/stmt.go
+++ b/src/cmd/compile/internal/types2/stmt.go
@@ -402,7 +402,7 @@ func (check *Checker) stmt(ctxt stmtContext, s syntax.Stmt) {
 		}
 
 		var x operand
-		check.binary(&x, nil, lhs[0], rhs[0], s.Op, s.Pos())
+		check.binary(&x, nil, lhs[0], rhs[0], s.Op)
 		check.assignVar(lhs[0], &x)
 
 	// case *syntax.GoStmt:
diff --git a/src/cmd/compile/internal/types2/testdata/const0.src b/src/cmd/compile/internal/types2/testdata/const0.src
index adbbf2863b..9e0de93d54 100644
--- a/src/cmd/compile/internal/types2/testdata/const0.src
+++ b/src/cmd/compile/internal/types2/testdata/const0.src
@@ -348,3 +348,11 @@ const _ = unsafe.Sizeof(func() {
 	assert(one == 1)
 	assert(iota == 0)
 })
+
+// untyped constants must not get arbitrarily large
+const (
+	huge = 1<<1000
+	// TODO(gri) here the errors should be at the last operator not the last operand
+	_ = huge * huge * huge   // ERROR constant multiplication overflow
+	_ = huge << 1000 << 1000 // ERROR constant shift overflow
+)
diff --git a/test/run.go b/test/run.go
index 8b487aa76f..8bc4104b34 100644
--- a/test/run.go
+++ b/test/run.go
@@ -1984,5 +1984,5 @@ var excluded = map[string]bool{
 	"fixedbugs/issue7525c.go":  true, // types2 reports init cycle error on different line - ok otherwise
 	"fixedbugs/issue7525d.go":  true, // types2 reports init cycle error on different line - ok otherwise
 	"fixedbugs/issue7525e.go":  true, // types2 reports init cycle error on different line - ok otherwise
-	"fixedbugs/issue7746.go":   true, // types2 type-checking doesn't terminate
+	"fixedbugs/issue7746.go":   true, // types2 reports overflow on a different line
 }
-- 
GitLab


From 0aafd6912422570625414da6e5ed5ba2c371fcec Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Thu, 28 Jan 2021 17:43:18 -0800
Subject: [PATCH 0581/2400] [dev.typeparams] cmd/compile: start translating
 type params in noder2

Also, make some fmt changes so that the type parameters and the
typeparam type are displayed in -W=2.

You can now parse a simple generic function (but not generic calls or generic
types) and print out the noder IR via 'go tool compile -G=2 -W=2 func.go'

Change-Id: I1f070fc4a96174a447763ad37999e61c25905901
Reviewed-on: https://go-review.googlesource.com/c/go/+/287833
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/types.go | 16 ++++++++++++++--
 src/cmd/compile/internal/types/fmt.go   | 22 +++++++++++++++++++---
 src/cmd/compile/internal/types/size.go  |  5 +++++
 src/cmd/compile/internal/types/type.go  | 20 +++++++++++++++++---
 src/cmd/compile/internal/types2/type.go |  4 ++++
 5 files changed, 59 insertions(+), 8 deletions(-)

diff --git a/src/cmd/compile/internal/noder/types.go b/src/cmd/compile/internal/noder/types.go
index de191acc90..b4ad9cfc5b 100644
--- a/src/cmd/compile/internal/noder/types.go
+++ b/src/cmd/compile/internal/noder/types.go
@@ -100,6 +100,12 @@ func (g *irgen) typ0(typ types2.Type) *types.Type {
 
 		return types.NewInterface(g.tpkg(typ), append(embeddeds, methods...))
 
+	case *types2.TypeParam:
+		tp := types.NewTypeParam(g.tpkg(typ), g.typ(typ.Bound()))
+		// Save the name of the type parameter in the sym of the type.
+		tp.SetSym(g.sym(typ.Obj()))
+		return tp
+
 	default:
 		base.FatalfAt(src.NoXPos, "unhandled type: %v (%T)", typ, typ)
 		panic("unreachable")
@@ -107,6 +113,13 @@ func (g *irgen) typ0(typ types2.Type) *types.Type {
 }
 
 func (g *irgen) signature(recv *types.Field, sig *types2.Signature) *types.Type {
+	tparams2 := sig.TParams()
+	tparams := make([]*types.Field, len(tparams2))
+	for i := range tparams {
+		tp := tparams2[i]
+		tparams[i] = types.NewField(g.pos(tp), g.sym(tp), g.typ(tp.Type()))
+	}
+
 	do := func(typ *types2.Tuple) []*types.Field {
 		fields := make([]*types.Field, typ.Len())
 		for i := range fields {
@@ -114,14 +127,13 @@ func (g *irgen) signature(recv *types.Field, sig *types2.Signature) *types.Type
 		}
 		return fields
 	}
-
 	params := do(sig.Params())
 	results := do(sig.Results())
 	if sig.Variadic() {
 		params[len(params)-1].SetIsDDD(true)
 	}
 
-	return types.NewSignature(g.tpkg(sig), recv, nil, params, results)
+	return types.NewSignature(g.tpkg(sig), recv, tparams, params, results)
 }
 
 func (g *irgen) param(v *types2.Var) *types.Field {
diff --git a/src/cmd/compile/internal/types/fmt.go b/src/cmd/compile/internal/types/fmt.go
index da224d4019..c59f62e302 100644
--- a/src/cmd/compile/internal/types/fmt.go
+++ b/src/cmd/compile/internal/types/fmt.go
@@ -318,7 +318,7 @@ func tconv2(b *bytes.Buffer, t *Type, verb rune, mode fmtMode, visited map[*Type
 	}
 
 	// Unless the 'L' flag was specified, if the type has a name, just print that name.
-	if verb != 'L' && t.Sym() != nil && t != Types[t.Kind()] {
+	if verb != 'L' && t.Sym() != nil && t != Types[t.Kind()] && t.Kind() != TTYPEPARAM {
 		switch mode {
 		case fmtTypeID, fmtTypeIDName:
 			if verb == 'S' {
@@ -478,6 +478,9 @@ func tconv2(b *bytes.Buffer, t *Type, verb rune, mode fmtMode, visited map[*Type
 			}
 			b.WriteString("func")
 		}
+		if t.NumTParams() > 0 {
+			tconv2(b, t.TParams(), 0, mode, visited)
+		}
 		tconv2(b, t.Params(), 0, mode, visited)
 
 		switch t.NumResults() {
@@ -515,7 +518,11 @@ func tconv2(b *bytes.Buffer, t *Type, verb rune, mode fmtMode, visited map[*Type
 		}
 
 		if funarg := t.StructType().Funarg; funarg != FunargNone {
-			b.WriteByte('(')
+			open, close := '(', ')'
+			if funarg == FunargTparams {
+				open, close = '[', ']'
+			}
+			b.WriteByte(byte(open))
 			fieldVerb := 'v'
 			switch mode {
 			case fmtTypeID, fmtTypeIDName, fmtGo:
@@ -528,7 +535,7 @@ func tconv2(b *bytes.Buffer, t *Type, verb rune, mode fmtMode, visited map[*Type
 				}
 				fldconv(b, f, fieldVerb, mode, visited, funarg)
 			}
-			b.WriteByte(')')
+			b.WriteByte(byte(close))
 		} else {
 			b.WriteString("struct {")
 			for i, f := range t.Fields().Slice() {
@@ -554,6 +561,15 @@ func tconv2(b *bytes.Buffer, t *Type, verb rune, mode fmtMode, visited map[*Type
 	case TUNSAFEPTR:
 		b.WriteString("unsafe.Pointer")
 
+	case TTYPEPARAM:
+		if t.Sym() != nil {
+			sconv2(b, t.Sym(), 'v', mode)
+		} else {
+			b.WriteString("tp")
+			// Print out the pointer value for now to disambiguate type params
+			b.WriteString(fmt.Sprintf("%p", t))
+		}
+
 	case Txxx:
 		b.WriteString("Txxx")
 
diff --git a/src/cmd/compile/internal/types/size.go b/src/cmd/compile/internal/types/size.go
index 98540eefb6..d1203e4a21 100644
--- a/src/cmd/compile/internal/types/size.go
+++ b/src/cmd/compile/internal/types/size.go
@@ -499,6 +499,11 @@ func CalcSize(t *Type) {
 			base.Warn("bad type %v %d\n", t1, w)
 		}
 		t.Align = 1
+
+	case TTYPEPARAM:
+		// TODO(danscales) - remove when we eliminate the need
+		// to do CalcSize in noder2 (which shouldn't be needed in the noder)
+		w = int64(PtrSize)
 	}
 
 	if PtrSize == 4 && w != int64(int32(w)) {
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 1d6edcda47..8d07b88ecd 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -204,7 +204,8 @@ func (t *Type) SetRecur(b bool)      { t.flags.set(typeRecur, b) }
 func (t *Type) Kind() Kind { return t.kind }
 
 // Sym returns the name of type t.
-func (t *Type) Sym() *Sym { return t.sym }
+func (t *Type) Sym() *Sym       { return t.sym }
+func (t *Type) SetSym(sym *Sym) { t.sym = sym }
 
 // Underlying returns the underlying type of type t.
 func (t *Type) Underlying() *Type { return t.underlying }
@@ -285,7 +286,7 @@ type Func struct {
 	Receiver *Type // function receiver
 	Results  *Type // function results
 	Params   *Type // function params
-	Tparams  *Type // type params of receiver (if method) or function
+	TParams  *Type // type params of receiver (if method) or function
 
 	pkg *Pkg
 
@@ -512,6 +513,8 @@ func New(et Kind) *Type {
 		t.Extra = new(Tuple)
 	case TRESULTS:
 		t.Extra = new(Results)
+	case TTYPEPARAM:
+		t.Extra = new(Interface)
 	}
 	return t
 }
@@ -769,10 +772,12 @@ func (t *Type) wantEtype(et Kind) {
 }
 
 func (t *Type) Recvs() *Type   { return t.FuncType().Receiver }
+func (t *Type) TParams() *Type { return t.FuncType().TParams }
 func (t *Type) Params() *Type  { return t.FuncType().Params }
 func (t *Type) Results() *Type { return t.FuncType().Results }
 
 func (t *Type) NumRecvs() int   { return t.FuncType().Receiver.NumFields() }
+func (t *Type) NumTParams() int { return t.FuncType().TParams.NumFields() }
 func (t *Type) NumParams() int  { return t.FuncType().Params.NumFields() }
 func (t *Type) NumResults() int { return t.FuncType().Results.NumFields() }
 
@@ -1648,6 +1653,15 @@ func NewInterface(pkg *Pkg, methods []*Field) *Type {
 	return t
 }
 
+// NewTypeParam returns a new type param with the given constraint (which may
+// not really be needed except for the type checker).
+func NewTypeParam(pkg *Pkg, constraint *Type) *Type {
+	t := New(TTYPEPARAM)
+	t.methods = constraint.methods
+	t.Extra.(*Interface).pkg = pkg
+	return t
+}
+
 // NewSignature returns a new function type for the given receiver,
 // parametes, results, and type parameters, any of which may be nil.
 func NewSignature(pkg *Pkg, recv *Field, tparams, params, results []*Field) *Type {
@@ -1669,7 +1683,7 @@ func NewSignature(pkg *Pkg, recv *Field, tparams, params, results []*Field) *Typ
 	}
 
 	ft.Receiver = funargs(recvs, FunargRcvr)
-	ft.Tparams = funargs(tparams, FunargTparams)
+	ft.TParams = funargs(tparams, FunargTparams)
 	ft.Params = funargs(params, FunargParams)
 	ft.Results = funargs(results, FunargResults)
 	ft.pkg = pkg
diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
index 22901b2ba9..7e51a138b5 100644
--- a/src/cmd/compile/internal/types2/type.go
+++ b/src/cmd/compile/internal/types2/type.go
@@ -837,6 +837,10 @@ type TypeParam struct {
 	aType
 }
 
+func (t *TypeParam) Obj() *TypeName {
+	return t.obj
+}
+
 // NewTypeParam returns a new TypeParam.
 func (check *Checker) NewTypeParam(obj *TypeName, index int, bound Type) *TypeParam {
 	assert(bound != nil)
-- 
GitLab


From ca6999e27c395a30edb277dbda9c5b3c5854aace Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Sun, 31 Jan 2021 10:05:03 -0800
Subject: [PATCH 0582/2400] [dev.regabi] test: add a test for inlining closures

Add a test case for issue 43818. We don't want to mark as inlinable a
function with a closure that has an operation (such as OSELRECV2) that
we don't currently support for exporting. This test case fails to
compile without the fix for #43818.

Updates #43818

Change-Id: Ief322a14aefaefc6913c40a6b8505214bd622fda
Reviewed-on: https://go-review.googlesource.com/c/go/+/288392
Run-TryBot: Dan Scales <danscales@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
---
 test/closure7.go | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 test/closure7.go

diff --git a/test/closure7.go b/test/closure7.go
new file mode 100644
index 0000000000..823333f45f
--- /dev/null
+++ b/test/closure7.go
@@ -0,0 +1,28 @@
+// run
+
+// Copyright 2020 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
+
+func g(f func()) {
+}
+
+// Must have exportable name
+func F() {
+	g(func() {
+		ch := make(chan int)
+		for {
+			select {
+			case <-ch:
+				return
+			default:
+			}
+		}
+	})
+}
+
+func main() {
+	F()
+}
-- 
GitLab


From 13a741298377d30fc2b3fc51fa9aa52eed6d56e4 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Sat, 30 Jan 2021 08:43:58 -0800
Subject: [PATCH 0583/2400] [dev.typeparams] Parse a generic type arg for
 generic function call

Will now run "go tool compile -G=2 -W=2" on a simple generic function
with one type parameter and a call to that function with one explicit
type argument. Next change will handle multiple type arguments.

Change-Id: Ia7d17ea2a02bf99bd50e673ac80ae4aad4c48440
Reviewed-on: https://go-review.googlesource.com/c/go/+/288432
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/noder/expr.go    | 11 +++-
 src/cmd/compile/internal/noder/helpers.go | 62 +++++++++++++++++++----
 src/cmd/compile/internal/noder/irgen.go   |  1 +
 src/cmd/compile/internal/noder/types.go   | 18 ++++++-
 4 files changed, 80 insertions(+), 12 deletions(-)

diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index 9212c67213..79b94638e8 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -93,9 +93,16 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 	case *syntax.AssertExpr:
 		return Assert(pos, g.expr(expr.X), g.typeExpr(expr.Type))
 	case *syntax.CallExpr:
-		return Call(pos, g.expr(expr.Fun), g.exprs(expr.ArgList), expr.HasDots)
+		def := g.info.Inferred[expr]
+		if len(def.Targs) > 0 {
+			panic("Inferred type arguments not handled yet")
+		}
+		return Call(pos, g.typ(typ), g.expr(expr.Fun), g.exprs(expr.ArgList), expr.HasDots)
 	case *syntax.IndexExpr:
-		return Index(pos, g.expr(expr.X), g.expr(expr.Index))
+		if _, ok := expr.Index.(*syntax.ListExpr); ok {
+			panic("more than one type argument")
+		}
+		return Index(pos, g.typ(typ), g.expr(expr.X), g.expr(expr.Index))
 	case *syntax.ParenExpr:
 		return g.expr(expr.X) // skip parens; unneeded after parse+typecheck
 	case *syntax.SelectorExpr:
diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
index a851844ded..2a6f30e026 100644
--- a/src/cmd/compile/internal/noder/helpers.go
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -79,18 +79,18 @@ func Binary(pos src.XPos, op ir.Op, x, y ir.Node) ir.Node {
 	}
 }
 
-func Call(pos src.XPos, fun ir.Node, args []ir.Node, dots bool) ir.Node {
+func Call(pos src.XPos, typ *types.Type, fun ir.Node, args []ir.Node, dots bool) ir.Node {
 	// TODO(mdempsky): This should not be so difficult.
-
-	n := ir.NewCallExpr(pos, ir.OCALL, fun, nil, args)
-	n.IsDDD = dots
-
-	// Actually a type conversion.
 	if fun.Op() == ir.OTYPE {
+		// Actually a type conversion, not a function call.
+		n := ir.NewCallExpr(pos, ir.OCALL, fun, nil, args)
 		return typecheck.Expr(n)
 	}
 
 	if fun, ok := fun.(*ir.Name); ok && fun.BuiltinOp != 0 {
+		// Call to a builtin function.
+		n := ir.NewCallExpr(pos, ir.OCALL, fun, nil, args)
+		n.IsDDD = dots
 		switch fun.BuiltinOp {
 		case ir.OCLOSE, ir.ODELETE, ir.OPANIC, ir.OPRINT, ir.OPRINTN:
 			return typecheck.Stmt(n)
@@ -116,7 +116,46 @@ func Call(pos src.XPos, fun ir.Node, args []ir.Node, dots bool) ir.Node {
 		}
 	}
 
-	typecheck.Call(n)
+	var targs []ir.Node
+	if indexExpr, ok := fun.(*ir.IndexExpr); ok {
+		if indexExpr.Index.Op() == ir.OTYPE {
+			// Called function is an instantiated generic function
+			// TODO this handles just one type argument for now
+			fun = indexExpr.X
+			targs = make([]ir.Node, 1, 1)
+			targs[0] = indexExpr.Index
+		}
+	}
+
+	n := ir.NewCallExpr(pos, ir.OCALL, fun, targs, args)
+	n.IsDDD = dots
+
+	if targs == nil {
+		// If no type params, still do normal typechecking, since we're
+		// still missing some things done by tcCall below (mainly
+		// typecheckargs and typecheckaste).
+		typecheck.Call(n)
+		return n
+	}
+
+	n.Use = ir.CallUseExpr
+	if fun.Type().NumResults() == 0 {
+		n.Use = ir.CallUseStmt
+	}
+
+	// Rewrite call node depending on use.
+	switch fun.Op() {
+	case ir.ODOTINTER:
+		n.SetOp(ir.OCALLINTER)
+
+	case ir.ODOTMETH:
+		n.SetOp(ir.OCALLMETH)
+
+	default:
+		n.SetOp(ir.OCALLFUNC)
+	}
+
+	typed(typ, n)
 	return n
 }
 
@@ -195,8 +234,13 @@ func method(typ *types.Type, index int) *types.Field {
 	return types.ReceiverBaseType(typ).Methods().Index(index)
 }
 
-func Index(pos src.XPos, x, index ir.Node) ir.Node {
-	// TODO(mdempsky): Avoid typecheck.Expr.
+func Index(pos src.XPos, typ *types.Type, x, index ir.Node) ir.Node {
+	if index.Op() == ir.OTYPE {
+		n := ir.NewIndexExpr(pos, x, index)
+		typed(typ, n)
+		return n
+	}
+	// TODO(mdempsky): Avoid typecheck.Expr (which will call tcIndex)
 	return typecheck.Expr(ir.NewIndexExpr(pos, x, index))
 }
 
diff --git a/src/cmd/compile/internal/noder/irgen.go b/src/cmd/compile/internal/noder/irgen.go
index 5456005598..1cef98742d 100644
--- a/src/cmd/compile/internal/noder/irgen.go
+++ b/src/cmd/compile/internal/noder/irgen.go
@@ -62,6 +62,7 @@ func check2(noders []*noder) {
 		Selections: make(map[*syntax.SelectorExpr]*types2.Selection),
 		Implicits:  make(map[syntax.Node]types2.Object),
 		Scopes:     make(map[syntax.Node]*types2.Scope),
+		Inferred:   make(map[syntax.Expr]types2.Inferred),
 		// expand as needed
 	}
 	pkg, err := conf.Check(base.Ctxt.Pkgpath, files, &info)
diff --git a/src/cmd/compile/internal/noder/types.go b/src/cmd/compile/internal/noder/types.go
index b4ad9cfc5b..1e71969858 100644
--- a/src/cmd/compile/internal/noder/types.go
+++ b/src/cmd/compile/internal/noder/types.go
@@ -39,7 +39,7 @@ func (g *irgen) typ(typ types2.Type) *types.Type {
 		// Ensure we calculate the size for all concrete types seen by
 		// the frontend. This is another heavy hammer for something that
 		// should really be the backend's responsibility instead.
-		if !res.IsUntyped() {
+		if res != nil && !res.IsUntyped() && !res.IsFuncArgStruct() {
 			types.CheckSize(res)
 		}
 	}
@@ -106,6 +106,22 @@ func (g *irgen) typ0(typ types2.Type) *types.Type {
 		tp.SetSym(g.sym(typ.Obj()))
 		return tp
 
+	case *types2.Tuple:
+		// Tuples are used for the type of a function call (i.e. the
+		// return value of the function).
+		if typ == nil {
+			return (*types.Type)(nil)
+		}
+		fields := make([]*types.Field, typ.Len())
+		for i := range fields {
+			fields[i] = g.param(typ.At(i))
+		}
+		t := types.NewStruct(types.LocalPkg, fields)
+		types.CheckSize(t)
+		// Can only set after doing the types.CheckSize()
+		t.StructType().Funarg = types.FunargResults
+		return t
+
 	default:
 		base.FatalfAt(src.NoXPos, "unhandled type: %v (%T)", typ, typ)
 		panic("unreachable")
-- 
GitLab


From 3d5c715bf299fb662104d70d612f3f0303e542d9 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Sat, 30 Jan 2021 21:15:40 -0800
Subject: [PATCH 0584/2400] [dev.typeparams] Handling multiple type arguments
 for call via new node OLIST

Will now run "go tool compile -G=2 -W=2" on a simple generic function
with multiple type parameters and a call to that function with multiple
explicit type arguments.

We will likely move to have a separate function/type instantiation node,
in order distinguish these cases from normal index expressions.

Change-Id: I0a571902d63785cc06240ed4ba0495923403b511
Reviewed-on: https://go-review.googlesource.com/c/go/+/288433
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/ir/expr.go       |  14 ++
 src/cmd/compile/internal/ir/node.go       |   1 +
 src/cmd/compile/internal/ir/node_gen.go   |  26 ++++
 src/cmd/compile/internal/ir/op_string.go  | 177 +++++++++++-----------
 src/cmd/compile/internal/noder/expr.go    |  17 ++-
 src/cmd/compile/internal/noder/helpers.go |   9 +-
 6 files changed, 149 insertions(+), 95 deletions(-)

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 92f93e98b8..7c60334c04 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -307,6 +307,20 @@ func (n *IndexExpr) SetOp(op Op) {
 	}
 }
 
+// A ListExpr is list of expressions
+type ListExpr struct {
+	miniExpr
+	List Nodes
+}
+
+func NewListExpr(pos src.XPos, list []Node) *ListExpr {
+	n := &ListExpr{}
+	n.pos = pos
+	n.op = OLIST
+	n.List = list
+	return n
+}
+
 // A KeyExpr is a Key: Value composite literal key.
 type KeyExpr struct {
 	miniExpr
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index ffa7daf6b2..590c428ac5 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -190,6 +190,7 @@ const (
 	OGT            // Left > Right
 	ODEREF         // *Left
 	OINDEX         // Left[Right] (index of array or slice)
+	OLIST          // list of expressions
 	OINDEXMAP      // Left[Right] (index of map)
 	OKEY           // Left:Right (key:value in struct/array/map literal)
 	OSTRUCTKEY     // Sym:Left (key:value in struct literal, after type checking)
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index fe436867b2..6f5eceb86d 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -249,6 +249,7 @@ func (n *CallExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *CallExpr) copy() Node {
 	c := *n
 	c.init = copyNodes(c.init)
+	c.Targs = copyNodes(c.Targs)
 	c.Args = copyNodes(c.Args)
 	c.KeepAlive = copyNames(c.KeepAlive)
 	return &c
@@ -260,6 +261,9 @@ func (n *CallExpr) doChildren(do func(Node) bool) bool {
 	if n.X != nil && do(n.X) {
 		return true
 	}
+	if doNodes(n.Targs, do) {
+		return true
+	}
 	if doNodes(n.Args, do) {
 		return true
 	}
@@ -273,6 +277,7 @@ func (n *CallExpr) editChildren(edit func(Node) Node) {
 	if n.X != nil {
 		n.X = edit(n.X).(Node)
 	}
+	editNodes(n.Targs, edit)
 	editNodes(n.Args, edit)
 	editNames(n.KeepAlive, edit)
 }
@@ -745,6 +750,27 @@ func (n *LinksymOffsetExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
 }
 
+func (n *ListExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *ListExpr) copy() Node {
+	c := *n
+	c.init = copyNodes(c.init)
+	c.List = copyNodes(c.List)
+	return &c
+}
+func (n *ListExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
+	}
+	if doNodes(n.List, do) {
+		return true
+	}
+	return false
+}
+func (n *ListExpr) editChildren(edit func(Node) Node) {
+	editNodes(n.init, edit)
+	editNodes(n.List, edit)
+}
+
 func (n *LogicalExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *LogicalExpr) copy() Node {
 	c := *n
diff --git a/src/cmd/compile/internal/ir/op_string.go b/src/cmd/compile/internal/ir/op_string.go
index 15c60baf44..390b0eecfe 100644
--- a/src/cmd/compile/internal/ir/op_string.go
+++ b/src/cmd/compile/internal/ir/op_string.go
@@ -74,97 +74,98 @@ func _() {
 	_ = x[OGT-63]
 	_ = x[ODEREF-64]
 	_ = x[OINDEX-65]
-	_ = x[OINDEXMAP-66]
-	_ = x[OKEY-67]
-	_ = x[OSTRUCTKEY-68]
-	_ = x[OLEN-69]
-	_ = x[OMAKE-70]
-	_ = x[OMAKECHAN-71]
-	_ = x[OMAKEMAP-72]
-	_ = x[OMAKESLICE-73]
-	_ = x[OMAKESLICECOPY-74]
-	_ = x[OMUL-75]
-	_ = x[ODIV-76]
-	_ = x[OMOD-77]
-	_ = x[OLSH-78]
-	_ = x[ORSH-79]
-	_ = x[OAND-80]
-	_ = x[OANDNOT-81]
-	_ = x[ONEW-82]
-	_ = x[ONOT-83]
-	_ = x[OBITNOT-84]
-	_ = x[OPLUS-85]
-	_ = x[ONEG-86]
-	_ = x[OOROR-87]
-	_ = x[OPANIC-88]
-	_ = x[OPRINT-89]
-	_ = x[OPRINTN-90]
-	_ = x[OPAREN-91]
-	_ = x[OSEND-92]
-	_ = x[OSLICE-93]
-	_ = x[OSLICEARR-94]
-	_ = x[OSLICESTR-95]
-	_ = x[OSLICE3-96]
-	_ = x[OSLICE3ARR-97]
-	_ = x[OSLICEHEADER-98]
-	_ = x[ORECOVER-99]
-	_ = x[ORECV-100]
-	_ = x[ORUNESTR-101]
-	_ = x[OSELRECV2-102]
-	_ = x[OIOTA-103]
-	_ = x[OREAL-104]
-	_ = x[OIMAG-105]
-	_ = x[OCOMPLEX-106]
-	_ = x[OALIGNOF-107]
-	_ = x[OOFFSETOF-108]
-	_ = x[OSIZEOF-109]
-	_ = x[OMETHEXPR-110]
-	_ = x[OSTMTEXPR-111]
-	_ = x[OBLOCK-112]
-	_ = x[OBREAK-113]
-	_ = x[OCASE-114]
-	_ = x[OCONTINUE-115]
-	_ = x[ODEFER-116]
-	_ = x[OFALL-117]
-	_ = x[OFOR-118]
-	_ = x[OFORUNTIL-119]
-	_ = x[OGOTO-120]
-	_ = x[OIF-121]
-	_ = x[OLABEL-122]
-	_ = x[OGO-123]
-	_ = x[ORANGE-124]
-	_ = x[ORETURN-125]
-	_ = x[OSELECT-126]
-	_ = x[OSWITCH-127]
-	_ = x[OTYPESW-128]
-	_ = x[OTCHAN-129]
-	_ = x[OTMAP-130]
-	_ = x[OTSTRUCT-131]
-	_ = x[OTINTER-132]
-	_ = x[OTFUNC-133]
-	_ = x[OTARRAY-134]
-	_ = x[OTSLICE-135]
-	_ = x[OINLCALL-136]
-	_ = x[OEFACE-137]
-	_ = x[OITAB-138]
-	_ = x[OIDATA-139]
-	_ = x[OSPTR-140]
-	_ = x[OCFUNC-141]
-	_ = x[OCHECKNIL-142]
-	_ = x[OVARDEF-143]
-	_ = x[OVARKILL-144]
-	_ = x[OVARLIVE-145]
-	_ = x[ORESULT-146]
-	_ = x[OINLMARK-147]
-	_ = x[OLINKSYMOFFSET-148]
-	_ = x[OTAILCALL-149]
-	_ = x[OGETG-150]
-	_ = x[OEND-151]
+	_ = x[OLIST-66]
+	_ = x[OINDEXMAP-67]
+	_ = x[OKEY-68]
+	_ = x[OSTRUCTKEY-69]
+	_ = x[OLEN-70]
+	_ = x[OMAKE-71]
+	_ = x[OMAKECHAN-72]
+	_ = x[OMAKEMAP-73]
+	_ = x[OMAKESLICE-74]
+	_ = x[OMAKESLICECOPY-75]
+	_ = x[OMUL-76]
+	_ = x[ODIV-77]
+	_ = x[OMOD-78]
+	_ = x[OLSH-79]
+	_ = x[ORSH-80]
+	_ = x[OAND-81]
+	_ = x[OANDNOT-82]
+	_ = x[ONEW-83]
+	_ = x[ONOT-84]
+	_ = x[OBITNOT-85]
+	_ = x[OPLUS-86]
+	_ = x[ONEG-87]
+	_ = x[OOROR-88]
+	_ = x[OPANIC-89]
+	_ = x[OPRINT-90]
+	_ = x[OPRINTN-91]
+	_ = x[OPAREN-92]
+	_ = x[OSEND-93]
+	_ = x[OSLICE-94]
+	_ = x[OSLICEARR-95]
+	_ = x[OSLICESTR-96]
+	_ = x[OSLICE3-97]
+	_ = x[OSLICE3ARR-98]
+	_ = x[OSLICEHEADER-99]
+	_ = x[ORECOVER-100]
+	_ = x[ORECV-101]
+	_ = x[ORUNESTR-102]
+	_ = x[OSELRECV2-103]
+	_ = x[OIOTA-104]
+	_ = x[OREAL-105]
+	_ = x[OIMAG-106]
+	_ = x[OCOMPLEX-107]
+	_ = x[OALIGNOF-108]
+	_ = x[OOFFSETOF-109]
+	_ = x[OSIZEOF-110]
+	_ = x[OMETHEXPR-111]
+	_ = x[OSTMTEXPR-112]
+	_ = x[OBLOCK-113]
+	_ = x[OBREAK-114]
+	_ = x[OCASE-115]
+	_ = x[OCONTINUE-116]
+	_ = x[ODEFER-117]
+	_ = x[OFALL-118]
+	_ = x[OFOR-119]
+	_ = x[OFORUNTIL-120]
+	_ = x[OGOTO-121]
+	_ = x[OIF-122]
+	_ = x[OLABEL-123]
+	_ = x[OGO-124]
+	_ = x[ORANGE-125]
+	_ = x[ORETURN-126]
+	_ = x[OSELECT-127]
+	_ = x[OSWITCH-128]
+	_ = x[OTYPESW-129]
+	_ = x[OTCHAN-130]
+	_ = x[OTMAP-131]
+	_ = x[OTSTRUCT-132]
+	_ = x[OTINTER-133]
+	_ = x[OTFUNC-134]
+	_ = x[OTARRAY-135]
+	_ = x[OTSLICE-136]
+	_ = x[OINLCALL-137]
+	_ = x[OEFACE-138]
+	_ = x[OITAB-139]
+	_ = x[OIDATA-140]
+	_ = x[OSPTR-141]
+	_ = x[OCFUNC-142]
+	_ = x[OCHECKNIL-143]
+	_ = x[OVARDEF-144]
+	_ = x[OVARKILL-145]
+	_ = x[OVARLIVE-146]
+	_ = x[ORESULT-147]
+	_ = x[OINLMARK-148]
+	_ = x[OLINKSYMOFFSET-149]
+	_ = x[OTAILCALL-150]
+	_ = x[OGETG-151]
+	_ = x[OEND-152]
 }
 
-const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKLINKSYMOFFSETTAILCALLGETGEND"
+const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXLISTINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKLINKSYMOFFSETTAILCALLGETGEND"
 
-var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 388, 391, 400, 403, 407, 415, 422, 431, 444, 447, 450, 453, 456, 459, 462, 468, 471, 474, 480, 484, 487, 491, 496, 501, 507, 512, 516, 521, 529, 537, 543, 552, 563, 570, 574, 581, 589, 593, 597, 601, 608, 615, 623, 629, 637, 645, 650, 655, 659, 667, 672, 676, 679, 687, 691, 693, 698, 700, 705, 711, 717, 723, 729, 734, 738, 745, 751, 756, 762, 768, 775, 780, 784, 789, 793, 798, 806, 812, 819, 826, 832, 839, 852, 860, 864, 867}
+var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 384, 392, 395, 404, 407, 411, 419, 426, 435, 448, 451, 454, 457, 460, 463, 466, 472, 475, 478, 484, 488, 491, 495, 500, 505, 511, 516, 520, 525, 533, 541, 547, 556, 567, 574, 578, 585, 593, 597, 601, 605, 612, 619, 627, 633, 641, 649, 654, 659, 663, 671, 676, 680, 683, 691, 695, 697, 702, 704, 709, 715, 721, 727, 733, 738, 742, 749, 755, 760, 766, 772, 779, 784, 788, 793, 797, 802, 810, 816, 823, 830, 836, 843, 856, 864, 868, 871}
 
 func (i Op) String() string {
 	if i >= Op(len(_Op_index)-1) {
diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index 79b94638e8..41d54441d4 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -99,10 +99,23 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 		}
 		return Call(pos, g.typ(typ), g.expr(expr.Fun), g.exprs(expr.ArgList), expr.HasDots)
 	case *syntax.IndexExpr:
+		var index ir.Node
+
+		// We are using IndexExpr in two ways, as an standard index
+		// operation (with expression) and as a function/type
+		// instantiation (with a type list). We will soon make this
+		// clearer by having separate function/type instantiation nodes.
 		if _, ok := expr.Index.(*syntax.ListExpr); ok {
-			panic("more than one type argument")
+			// List of types for a generic function call or type instantiation
+			index = ir.NewListExpr(pos, g.exprList(expr.Index))
+		} else {
+			index = g.expr(expr.Index)
+			if index.Op() == ir.OTYPE {
+				// Single type for a generic function call or type instantiation
+				index = ir.NewListExpr(pos, []ir.Node{index})
+			}
 		}
-		return Index(pos, g.typ(typ), g.expr(expr.X), g.expr(expr.Index))
+		return Index(pos, g.typ(typ), g.expr(expr.X), index)
 	case *syntax.ParenExpr:
 		return g.expr(expr.X) // skip parens; unneeded after parse+typecheck
 	case *syntax.SelectorExpr:
diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
index 2a6f30e026..d97dacfc8b 100644
--- a/src/cmd/compile/internal/noder/helpers.go
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -118,12 +118,11 @@ func Call(pos src.XPos, typ *types.Type, fun ir.Node, args []ir.Node, dots bool)
 
 	var targs []ir.Node
 	if indexExpr, ok := fun.(*ir.IndexExpr); ok {
-		if indexExpr.Index.Op() == ir.OTYPE {
+		if indexExpr.Index.Op() == ir.OLIST {
 			// Called function is an instantiated generic function
-			// TODO this handles just one type argument for now
 			fun = indexExpr.X
-			targs = make([]ir.Node, 1, 1)
-			targs[0] = indexExpr.Index
+			// Don't need to copy, since the node list was just created
+			targs = indexExpr.Index.(*ir.ListExpr).List
 		}
 	}
 
@@ -235,7 +234,7 @@ func method(typ *types.Type, index int) *types.Field {
 }
 
 func Index(pos src.XPos, typ *types.Type, x, index ir.Node) ir.Node {
-	if index.Op() == ir.OTYPE {
+	if index.Op() == ir.OLIST {
 		n := ir.NewIndexExpr(pos, x, index)
 		typed(typ, n)
 		return n
-- 
GitLab


From e633f343ba791e770c6a6c2f8ff3640d2e8ff079 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Tue, 2 Feb 2021 12:17:57 -0800
Subject: [PATCH 0585/2400] [dev.typeparams] cmd/compile:  add
 OFUNCINST/OTYPEINST nodes for generic func/type instantiation

Expresses things more clearly, especially in cases like 'f := min[int]'
where we create a xsgeneric function instantiation, but don't immediately
call it.

min[int](2, 3) now looks like:

.   CALLFUNC tc(1) Use:1 int # min1.go:11 int
.   .   FUNCINST tc(1) FUNC-func(int, int) int # min1.go:11 FUNC-func(int, int) int
.   .   .   NAME-main.min tc(1) Class:PFUNC Offset:0 Used FUNC-func[T](T, T) T # min1.go:3
.   .   FUNCINST-Targs
.   .   .   TYPE .int Offset:0 type int
.   CALLFUNC-Args
.   .   LITERAL-2 tc(1) int # min1.go:11
.   .   LITERAL-3 tc(1) int # min1.go:11

Remove the targs parameter from ir.NewCallExpr(), not needed anymore,
since type arguments are included in the FUNCINST.

Change-Id: I23438b75288330475294d7ace239ba64acfa641e
Reviewed-on: https://go-review.googlesource.com/c/go/+/288951
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/ir/expr.go           |  34 ++--
 src/cmd/compile/internal/ir/node.go           |   3 +-
 src/cmd/compile/internal/ir/node_gen.go       |  53 +++---
 src/cmd/compile/internal/ir/op_string.go      | 179 +++++++++---------
 src/cmd/compile/internal/noder/expr.go        |  31 +--
 src/cmd/compile/internal/noder/helpers.go     |  25 +--
 src/cmd/compile/internal/noder/noder.go       |   2 +-
 src/cmd/compile/internal/reflectdata/alg.go   |  12 +-
 .../compile/internal/reflectdata/reflect.go   |   4 +-
 src/cmd/compile/internal/ssagen/abi.go        |   2 +-
 src/cmd/compile/internal/typecheck/func.go    |   2 +-
 src/cmd/compile/internal/typecheck/iimport.go |   4 +-
 src/cmd/compile/internal/walk/builtin.go      |   2 +-
 src/cmd/compile/internal/walk/compare.go      |   2 +-
 src/cmd/compile/internal/walk/complit.go      |   2 +-
 src/cmd/compile/internal/walk/convert.go      |   4 +-
 src/cmd/compile/internal/walk/expr.go         |   2 +-
 src/cmd/compile/internal/walk/stmt.go         |   4 +-
 src/cmd/compile/internal/walk/walk.go         |   2 +-
 19 files changed, 180 insertions(+), 189 deletions(-)

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 7c60334c04..d68bcfe60c 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -153,12 +153,11 @@ const (
 	CallUseStmt // results not used - call is a statement
 )
 
-// A CallExpr is a function call X[Targs](Args).
+// A CallExpr is a function call X(Args).
 type CallExpr struct {
 	miniExpr
 	origNode
 	X         Node
-	Targs     Nodes
 	Args      Nodes
 	KeepAlive []*Name // vars to be kept alive until call returns
 	IsDDD     bool
@@ -166,12 +165,11 @@ type CallExpr struct {
 	NoInline  bool
 }
 
-func NewCallExpr(pos src.XPos, op Op, fun Node, targs, args []Node) *CallExpr {
+func NewCallExpr(pos src.XPos, op Op, fun Node, args []Node) *CallExpr {
 	n := &CallExpr{X: fun}
 	n.pos = pos
 	n.orig = n
 	n.SetOp(op)
-	n.Targs = targs
 	n.Args = args
 	return n
 }
@@ -307,20 +305,6 @@ func (n *IndexExpr) SetOp(op Op) {
 	}
 }
 
-// A ListExpr is list of expressions
-type ListExpr struct {
-	miniExpr
-	List Nodes
-}
-
-func NewListExpr(pos src.XPos, list []Node) *ListExpr {
-	n := &ListExpr{}
-	n.pos = pos
-	n.op = OLIST
-	n.List = list
-	return n
-}
-
 // A KeyExpr is a Key: Value composite literal key.
 type KeyExpr struct {
 	miniExpr
@@ -686,6 +670,20 @@ func (n *UnaryExpr) SetOp(op Op) {
 	}
 }
 
+// An InstExpr is a generic function or type instantiation.
+type InstExpr struct {
+	miniExpr
+	X     Node
+	Targs []Node
+}
+
+func NewInstExpr(pos src.XPos, op Op, x Node, targs []Node) *InstExpr {
+	n := &InstExpr{X: x, Targs: targs}
+	n.pos = pos
+	n.op = op
+	return n
+}
+
 func IsZero(n Node) bool {
 	switch n.Op() {
 	case ONIL:
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 590c428ac5..59643713fa 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -190,7 +190,6 @@ const (
 	OGT            // Left > Right
 	ODEREF         // *Left
 	OINDEX         // Left[Right] (index of array or slice)
-	OLIST          // list of expressions
 	OINDEXMAP      // Left[Right] (index of map)
 	OKEY           // Left:Right (key:value in struct/array/map literal)
 	OSTRUCTKEY     // Sym:Left (key:value in struct literal, after type checking)
@@ -279,6 +278,8 @@ const (
 	// OTYPESW:  Left := Right.(type) (appears as .Left of OSWITCH)
 	//   Left is nil if there is no type-switch variable
 	OTYPESW
+	OFUNCINST // instantiation of a generic function
+	OTYPEINST // instantiation of a generic type
 
 	// types
 	OTCHAN   // chan int
diff --git a/src/cmd/compile/internal/ir/node_gen.go b/src/cmd/compile/internal/ir/node_gen.go
index 6f5eceb86d..22855d7163 100644
--- a/src/cmd/compile/internal/ir/node_gen.go
+++ b/src/cmd/compile/internal/ir/node_gen.go
@@ -249,7 +249,6 @@ func (n *CallExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *CallExpr) copy() Node {
 	c := *n
 	c.init = copyNodes(c.init)
-	c.Targs = copyNodes(c.Targs)
 	c.Args = copyNodes(c.Args)
 	c.KeepAlive = copyNames(c.KeepAlive)
 	return &c
@@ -261,9 +260,6 @@ func (n *CallExpr) doChildren(do func(Node) bool) bool {
 	if n.X != nil && do(n.X) {
 		return true
 	}
-	if doNodes(n.Targs, do) {
-		return true
-	}
 	if doNodes(n.Args, do) {
 		return true
 	}
@@ -277,7 +273,6 @@ func (n *CallExpr) editChildren(edit func(Node) Node) {
 	if n.X != nil {
 		n.X = edit(n.X).(Node)
 	}
-	editNodes(n.Targs, edit)
 	editNodes(n.Args, edit)
 	editNames(n.KeepAlive, edit)
 }
@@ -674,6 +669,33 @@ func (n *InlinedCallExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.ReturnVars, edit)
 }
 
+func (n *InstExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
+func (n *InstExpr) copy() Node {
+	c := *n
+	c.init = copyNodes(c.init)
+	c.Targs = copyNodes(c.Targs)
+	return &c
+}
+func (n *InstExpr) doChildren(do func(Node) bool) bool {
+	if doNodes(n.init, do) {
+		return true
+	}
+	if n.X != nil && do(n.X) {
+		return true
+	}
+	if doNodes(n.Targs, do) {
+		return true
+	}
+	return false
+}
+func (n *InstExpr) editChildren(edit func(Node) Node) {
+	editNodes(n.init, edit)
+	if n.X != nil {
+		n.X = edit(n.X).(Node)
+	}
+	editNodes(n.Targs, edit)
+}
+
 func (n *InterfaceType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *InterfaceType) copy() Node {
 	c := *n
@@ -750,27 +772,6 @@ func (n *LinksymOffsetExpr) editChildren(edit func(Node) Node) {
 	editNodes(n.init, edit)
 }
 
-func (n *ListExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
-func (n *ListExpr) copy() Node {
-	c := *n
-	c.init = copyNodes(c.init)
-	c.List = copyNodes(c.List)
-	return &c
-}
-func (n *ListExpr) doChildren(do func(Node) bool) bool {
-	if doNodes(n.init, do) {
-		return true
-	}
-	if doNodes(n.List, do) {
-		return true
-	}
-	return false
-}
-func (n *ListExpr) editChildren(edit func(Node) Node) {
-	editNodes(n.init, edit)
-	editNodes(n.List, edit)
-}
-
 func (n *LogicalExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
 func (n *LogicalExpr) copy() Node {
 	c := *n
diff --git a/src/cmd/compile/internal/ir/op_string.go b/src/cmd/compile/internal/ir/op_string.go
index 390b0eecfe..65456df356 100644
--- a/src/cmd/compile/internal/ir/op_string.go
+++ b/src/cmd/compile/internal/ir/op_string.go
@@ -74,98 +74,99 @@ func _() {
 	_ = x[OGT-63]
 	_ = x[ODEREF-64]
 	_ = x[OINDEX-65]
-	_ = x[OLIST-66]
-	_ = x[OINDEXMAP-67]
-	_ = x[OKEY-68]
-	_ = x[OSTRUCTKEY-69]
-	_ = x[OLEN-70]
-	_ = x[OMAKE-71]
-	_ = x[OMAKECHAN-72]
-	_ = x[OMAKEMAP-73]
-	_ = x[OMAKESLICE-74]
-	_ = x[OMAKESLICECOPY-75]
-	_ = x[OMUL-76]
-	_ = x[ODIV-77]
-	_ = x[OMOD-78]
-	_ = x[OLSH-79]
-	_ = x[ORSH-80]
-	_ = x[OAND-81]
-	_ = x[OANDNOT-82]
-	_ = x[ONEW-83]
-	_ = x[ONOT-84]
-	_ = x[OBITNOT-85]
-	_ = x[OPLUS-86]
-	_ = x[ONEG-87]
-	_ = x[OOROR-88]
-	_ = x[OPANIC-89]
-	_ = x[OPRINT-90]
-	_ = x[OPRINTN-91]
-	_ = x[OPAREN-92]
-	_ = x[OSEND-93]
-	_ = x[OSLICE-94]
-	_ = x[OSLICEARR-95]
-	_ = x[OSLICESTR-96]
-	_ = x[OSLICE3-97]
-	_ = x[OSLICE3ARR-98]
-	_ = x[OSLICEHEADER-99]
-	_ = x[ORECOVER-100]
-	_ = x[ORECV-101]
-	_ = x[ORUNESTR-102]
-	_ = x[OSELRECV2-103]
-	_ = x[OIOTA-104]
-	_ = x[OREAL-105]
-	_ = x[OIMAG-106]
-	_ = x[OCOMPLEX-107]
-	_ = x[OALIGNOF-108]
-	_ = x[OOFFSETOF-109]
-	_ = x[OSIZEOF-110]
-	_ = x[OMETHEXPR-111]
-	_ = x[OSTMTEXPR-112]
-	_ = x[OBLOCK-113]
-	_ = x[OBREAK-114]
-	_ = x[OCASE-115]
-	_ = x[OCONTINUE-116]
-	_ = x[ODEFER-117]
-	_ = x[OFALL-118]
-	_ = x[OFOR-119]
-	_ = x[OFORUNTIL-120]
-	_ = x[OGOTO-121]
-	_ = x[OIF-122]
-	_ = x[OLABEL-123]
-	_ = x[OGO-124]
-	_ = x[ORANGE-125]
-	_ = x[ORETURN-126]
-	_ = x[OSELECT-127]
-	_ = x[OSWITCH-128]
-	_ = x[OTYPESW-129]
-	_ = x[OTCHAN-130]
-	_ = x[OTMAP-131]
-	_ = x[OTSTRUCT-132]
-	_ = x[OTINTER-133]
-	_ = x[OTFUNC-134]
-	_ = x[OTARRAY-135]
-	_ = x[OTSLICE-136]
-	_ = x[OINLCALL-137]
-	_ = x[OEFACE-138]
-	_ = x[OITAB-139]
-	_ = x[OIDATA-140]
-	_ = x[OSPTR-141]
-	_ = x[OCFUNC-142]
-	_ = x[OCHECKNIL-143]
-	_ = x[OVARDEF-144]
-	_ = x[OVARKILL-145]
-	_ = x[OVARLIVE-146]
-	_ = x[ORESULT-147]
-	_ = x[OINLMARK-148]
-	_ = x[OLINKSYMOFFSET-149]
-	_ = x[OTAILCALL-150]
-	_ = x[OGETG-151]
-	_ = x[OEND-152]
+	_ = x[OINDEXMAP-66]
+	_ = x[OKEY-67]
+	_ = x[OSTRUCTKEY-68]
+	_ = x[OLEN-69]
+	_ = x[OMAKE-70]
+	_ = x[OMAKECHAN-71]
+	_ = x[OMAKEMAP-72]
+	_ = x[OMAKESLICE-73]
+	_ = x[OMAKESLICECOPY-74]
+	_ = x[OMUL-75]
+	_ = x[ODIV-76]
+	_ = x[OMOD-77]
+	_ = x[OLSH-78]
+	_ = x[ORSH-79]
+	_ = x[OAND-80]
+	_ = x[OANDNOT-81]
+	_ = x[ONEW-82]
+	_ = x[ONOT-83]
+	_ = x[OBITNOT-84]
+	_ = x[OPLUS-85]
+	_ = x[ONEG-86]
+	_ = x[OOROR-87]
+	_ = x[OPANIC-88]
+	_ = x[OPRINT-89]
+	_ = x[OPRINTN-90]
+	_ = x[OPAREN-91]
+	_ = x[OSEND-92]
+	_ = x[OSLICE-93]
+	_ = x[OSLICEARR-94]
+	_ = x[OSLICESTR-95]
+	_ = x[OSLICE3-96]
+	_ = x[OSLICE3ARR-97]
+	_ = x[OSLICEHEADER-98]
+	_ = x[ORECOVER-99]
+	_ = x[ORECV-100]
+	_ = x[ORUNESTR-101]
+	_ = x[OSELRECV2-102]
+	_ = x[OIOTA-103]
+	_ = x[OREAL-104]
+	_ = x[OIMAG-105]
+	_ = x[OCOMPLEX-106]
+	_ = x[OALIGNOF-107]
+	_ = x[OOFFSETOF-108]
+	_ = x[OSIZEOF-109]
+	_ = x[OMETHEXPR-110]
+	_ = x[OSTMTEXPR-111]
+	_ = x[OBLOCK-112]
+	_ = x[OBREAK-113]
+	_ = x[OCASE-114]
+	_ = x[OCONTINUE-115]
+	_ = x[ODEFER-116]
+	_ = x[OFALL-117]
+	_ = x[OFOR-118]
+	_ = x[OFORUNTIL-119]
+	_ = x[OGOTO-120]
+	_ = x[OIF-121]
+	_ = x[OLABEL-122]
+	_ = x[OGO-123]
+	_ = x[ORANGE-124]
+	_ = x[ORETURN-125]
+	_ = x[OSELECT-126]
+	_ = x[OSWITCH-127]
+	_ = x[OTYPESW-128]
+	_ = x[OFUNCINST-129]
+	_ = x[OTYPEINST-130]
+	_ = x[OTCHAN-131]
+	_ = x[OTMAP-132]
+	_ = x[OTSTRUCT-133]
+	_ = x[OTINTER-134]
+	_ = x[OTFUNC-135]
+	_ = x[OTARRAY-136]
+	_ = x[OTSLICE-137]
+	_ = x[OINLCALL-138]
+	_ = x[OEFACE-139]
+	_ = x[OITAB-140]
+	_ = x[OIDATA-141]
+	_ = x[OSPTR-142]
+	_ = x[OCFUNC-143]
+	_ = x[OCHECKNIL-144]
+	_ = x[OVARDEF-145]
+	_ = x[OVARKILL-146]
+	_ = x[OVARLIVE-147]
+	_ = x[ORESULT-148]
+	_ = x[OINLMARK-149]
+	_ = x[OLINKSYMOFFSET-150]
+	_ = x[OTAILCALL-151]
+	_ = x[OGETG-152]
+	_ = x[OEND-153]
 }
 
-const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXLISTINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKLINKSYMOFFSETTAILCALLGETGEND"
+const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWFUNCINSTTYPEINSTTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKLINKSYMOFFSETTAILCALLGETGEND"
 
-var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 384, 392, 395, 404, 407, 411, 419, 426, 435, 448, 451, 454, 457, 460, 463, 466, 472, 475, 478, 484, 488, 491, 495, 500, 505, 511, 516, 520, 525, 533, 541, 547, 556, 567, 574, 578, 585, 593, 597, 601, 605, 612, 619, 627, 633, 641, 649, 654, 659, 663, 671, 676, 680, 683, 691, 695, 697, 702, 704, 709, 715, 721, 727, 733, 738, 742, 749, 755, 760, 766, 772, 779, 784, 788, 793, 797, 802, 810, 816, 823, 830, 836, 843, 856, 864, 868, 871}
+var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 388, 391, 400, 403, 407, 415, 422, 431, 444, 447, 450, 453, 456, 459, 462, 468, 471, 474, 480, 484, 487, 491, 496, 501, 507, 512, 516, 521, 529, 537, 543, 552, 563, 570, 574, 581, 589, 593, 597, 601, 608, 615, 623, 629, 637, 645, 650, 655, 659, 667, 672, 676, 679, 687, 691, 693, 698, 700, 705, 711, 717, 723, 729, 737, 745, 750, 754, 761, 767, 772, 778, 784, 791, 796, 800, 805, 809, 814, 822, 828, 835, 842, 848, 855, 868, 876, 880, 883}
 
 func (i Op) String() string {
 	if i >= Op(len(_Op_index)-1) {
diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index 41d54441d4..3c18bdcc24 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -99,23 +99,28 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 		}
 		return Call(pos, g.typ(typ), g.expr(expr.Fun), g.exprs(expr.ArgList), expr.HasDots)
 	case *syntax.IndexExpr:
-		var index ir.Node
-
-		// We are using IndexExpr in two ways, as an standard index
-		// operation (with expression) and as a function/type
-		// instantiation (with a type list). We will soon make this
-		// clearer by having separate function/type instantiation nodes.
+		var targs []ir.Node
 		if _, ok := expr.Index.(*syntax.ListExpr); ok {
-			// List of types for a generic function call or type instantiation
-			index = ir.NewListExpr(pos, g.exprList(expr.Index))
+			targs = g.exprList(expr.Index)
 		} else {
-			index = g.expr(expr.Index)
-			if index.Op() == ir.OTYPE {
-				// Single type for a generic function call or type instantiation
-				index = ir.NewListExpr(pos, []ir.Node{index})
+			index := g.expr(expr.Index)
+			if index.Op() != ir.OTYPE {
+				// This is just a normal index expression
+				return Index(pos, g.expr(expr.X), index)
 			}
+			// This is generic function instantiation with a single type
+			targs = []ir.Node{index}
+		}
+		// This is a generic function instantiation
+		x := g.expr(expr.X)
+		if x.Op() != ir.ONAME || x.Type().Kind() != types.TFUNC {
+			panic("Incorrect argument for generic func instantiation")
 		}
-		return Index(pos, g.typ(typ), g.expr(expr.X), index)
+		// This could also be an OTYPEINST once we can handle those examples.
+		n := ir.NewInstExpr(pos, ir.OFUNCINST, x, targs)
+		typed(g.typ(typ), n)
+		return n
+
 	case *syntax.ParenExpr:
 		return g.expr(expr.X) // skip parens; unneeded after parse+typecheck
 	case *syntax.SelectorExpr:
diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
index d97dacfc8b..fcbb3a6ce5 100644
--- a/src/cmd/compile/internal/noder/helpers.go
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -83,13 +83,13 @@ func Call(pos src.XPos, typ *types.Type, fun ir.Node, args []ir.Node, dots bool)
 	// TODO(mdempsky): This should not be so difficult.
 	if fun.Op() == ir.OTYPE {
 		// Actually a type conversion, not a function call.
-		n := ir.NewCallExpr(pos, ir.OCALL, fun, nil, args)
+		n := ir.NewCallExpr(pos, ir.OCALL, fun, args)
 		return typecheck.Expr(n)
 	}
 
 	if fun, ok := fun.(*ir.Name); ok && fun.BuiltinOp != 0 {
 		// Call to a builtin function.
-		n := ir.NewCallExpr(pos, ir.OCALL, fun, nil, args)
+		n := ir.NewCallExpr(pos, ir.OCALL, fun, args)
 		n.IsDDD = dots
 		switch fun.BuiltinOp {
 		case ir.OCLOSE, ir.ODELETE, ir.OPANIC, ir.OPRINT, ir.OPRINTN:
@@ -116,20 +116,10 @@ func Call(pos src.XPos, typ *types.Type, fun ir.Node, args []ir.Node, dots bool)
 		}
 	}
 
-	var targs []ir.Node
-	if indexExpr, ok := fun.(*ir.IndexExpr); ok {
-		if indexExpr.Index.Op() == ir.OLIST {
-			// Called function is an instantiated generic function
-			fun = indexExpr.X
-			// Don't need to copy, since the node list was just created
-			targs = indexExpr.Index.(*ir.ListExpr).List
-		}
-	}
-
-	n := ir.NewCallExpr(pos, ir.OCALL, fun, targs, args)
+	n := ir.NewCallExpr(pos, ir.OCALL, fun, args)
 	n.IsDDD = dots
 
-	if targs == nil {
+	if n.X.Op() != ir.OFUNCINST {
 		// If no type params, still do normal typechecking, since we're
 		// still missing some things done by tcCall below (mainly
 		// typecheckargs and typecheckaste).
@@ -233,12 +223,7 @@ func method(typ *types.Type, index int) *types.Field {
 	return types.ReceiverBaseType(typ).Methods().Index(index)
 }
 
-func Index(pos src.XPos, typ *types.Type, x, index ir.Node) ir.Node {
-	if index.Op() == ir.OLIST {
-		n := ir.NewIndexExpr(pos, x, index)
-		typed(typ, n)
-		return n
-	}
+func Index(pos src.XPos, x, index ir.Node) ir.Node {
 	// TODO(mdempsky): Avoid typecheck.Expr (which will call tcIndex)
 	return typecheck.Expr(ir.NewIndexExpr(pos, x, index))
 }
diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 492c2c242a..1c38f1a934 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -755,7 +755,7 @@ func (p *noder) expr(expr syntax.Expr) ir.Node {
 		}
 		return ir.NewBinaryExpr(pos, op, x, y)
 	case *syntax.CallExpr:
-		n := ir.NewCallExpr(p.pos(expr), ir.OCALL, p.expr(expr.Fun), nil, p.exprs(expr.ArgList))
+		n := ir.NewCallExpr(p.pos(expr), ir.OCALL, p.expr(expr.Fun), p.exprs(expr.ArgList))
 		n.IsDDD = expr.HasDots
 		return n
 
diff --git a/src/cmd/compile/internal/reflectdata/alg.go b/src/cmd/compile/internal/reflectdata/alg.go
index 3d8729069a..faa431a9d1 100644
--- a/src/cmd/compile/internal/reflectdata/alg.go
+++ b/src/cmd/compile/internal/reflectdata/alg.go
@@ -176,7 +176,7 @@ func genhash(t *types.Type) *obj.LSym {
 		loop.PtrInit().Append(init)
 
 		// h = hashel(&p[i], h)
-		call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil, nil)
+		call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil)
 
 		nx := ir.NewIndexExpr(base.Pos, np, ni)
 		nx.SetBounded(true)
@@ -202,7 +202,7 @@ func genhash(t *types.Type) *obj.LSym {
 			// Hash non-memory fields with appropriate hash function.
 			if !isRegularMemory(f.Type) {
 				hashel := hashfor(f.Type)
-				call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil, nil)
+				call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil)
 				nx := ir.NewSelectorExpr(base.Pos, ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
 				na := typecheck.NodAddr(nx)
 				call.Args.Append(na)
@@ -217,7 +217,7 @@ func genhash(t *types.Type) *obj.LSym {
 
 			// h = hashel(&p.first, size, h)
 			hashel := hashmem(f.Type)
-			call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil, nil)
+			call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil)
 			nx := ir.NewSelectorExpr(base.Pos, ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
 			na := typecheck.NodAddr(nx)
 			call.Args.Append(na)
@@ -672,7 +672,7 @@ func EqString(s, t ir.Node) (eqlen *ir.BinaryExpr, eqmem *ir.CallExpr) {
 
 	fn := typecheck.LookupRuntime("memequal")
 	fn = typecheck.SubstArgTypes(fn, types.Types[types.TUINT8], types.Types[types.TUINT8])
-	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil, []ir.Node{sptr, tptr, ir.Copy(slen)})
+	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, []ir.Node{sptr, tptr, ir.Copy(slen)})
 	typecheck.Call(call)
 
 	cmp := ir.NewBinaryExpr(base.Pos, ir.OEQ, slen, tlen)
@@ -709,7 +709,7 @@ func EqInterface(s, t ir.Node) (eqtab *ir.BinaryExpr, eqdata *ir.CallExpr) {
 	sdata.SetTypecheck(1)
 	tdata.SetTypecheck(1)
 
-	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil, []ir.Node{stab, sdata, tdata})
+	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, []ir.Node{stab, sdata, tdata})
 	typecheck.Call(call)
 
 	cmp := ir.NewBinaryExpr(base.Pos, ir.OEQ, stab, ttab)
@@ -725,7 +725,7 @@ func eqmem(p ir.Node, q ir.Node, field *types.Sym, size int64) ir.Node {
 	ny := typecheck.Expr(typecheck.NodAddr(ir.NewSelectorExpr(base.Pos, ir.OXDOT, q, field)))
 
 	fn, needsize := eqmemfunc(size, nx.Type().Elem())
-	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil, nil)
+	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
 	call.Args.Append(nx)
 	call.Args.Append(ny)
 	if needsize {
diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index c1385e6dab..632e0f48d4 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -1747,7 +1747,7 @@ func methodWrapper(rcvr *types.Type, method *types.Field) *obj.LSym {
 		// generating wrapper from *T to T.
 		n := ir.NewIfStmt(base.Pos, nil, nil, nil)
 		n.Cond = ir.NewBinaryExpr(base.Pos, ir.OEQ, nthis, typecheck.NodNil())
-		call := ir.NewCallExpr(base.Pos, ir.OCALL, typecheck.LookupRuntime("panicwrap"), nil, nil)
+		call := ir.NewCallExpr(base.Pos, ir.OCALL, typecheck.LookupRuntime("panicwrap"), nil)
 		n.Body = []ir.Node{call}
 		fn.Body.Append(n)
 	}
@@ -1772,7 +1772,7 @@ func methodWrapper(rcvr *types.Type, method *types.Field) *obj.LSym {
 		fn.Body.Append(ir.NewTailCallStmt(base.Pos, method.Nname.(*ir.Name)))
 	} else {
 		fn.SetWrapper(true) // ignore frame for panic+recover matching
-		call := ir.NewCallExpr(base.Pos, ir.OCALL, dot, nil, nil)
+		call := ir.NewCallExpr(base.Pos, ir.OCALL, dot, nil)
 		call.Args = ir.ParamNames(tfn.Type())
 		call.IsDDD = tfn.Type().IsVariadic()
 		if method.Type.NumResults() > 0 {
diff --git a/src/cmd/compile/internal/ssagen/abi.go b/src/cmd/compile/internal/ssagen/abi.go
index b22a5ef2be..5bebce1db5 100644
--- a/src/cmd/compile/internal/ssagen/abi.go
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -305,7 +305,7 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 
 		tail = ir.NewTailCallStmt(base.Pos, f.Nname)
 	} else {
-		call := ir.NewCallExpr(base.Pos, ir.OCALL, f.Nname, nil, nil)
+		call := ir.NewCallExpr(base.Pos, ir.OCALL, f.Nname, nil)
 		call.Args = ir.ParamNames(tfn.Type())
 		call.IsDDD = tfn.Type().IsVariadic()
 		tail = call
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index a44af10bbb..7ab5f68ce3 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -254,7 +254,7 @@ func MethodValueWrapper(dot *ir.SelectorExpr) *ir.Func {
 	ptr.SetByval(true)
 	fn.ClosureVars = append(fn.ClosureVars, ptr)
 
-	call := ir.NewCallExpr(base.Pos, ir.OCALL, ir.NewSelectorExpr(base.Pos, ir.OXDOT, ptr, meth), nil, nil)
+	call := ir.NewCallExpr(base.Pos, ir.OCALL, ir.NewSelectorExpr(base.Pos, ir.OXDOT, ptr, meth), nil)
 	call.Args = ir.ParamNames(tfn.Type())
 	call.IsDDD = tfn.Type().IsVariadic()
 
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 201b217e8e..7b5b113b15 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -1068,7 +1068,7 @@ func (r *importReader) node() ir.Node {
 	case ir.OCALL:
 		pos := r.pos()
 		init := r.stmtList()
-		n := ir.NewCallExpr(pos, ir.OCALL, r.expr(), nil, r.exprList())
+		n := ir.NewCallExpr(pos, ir.OCALL, r.expr(), r.exprList())
 		*n.PtrInit() = init
 		n.IsDDD = r.bool()
 		return n
@@ -1236,5 +1236,5 @@ func (r *importReader) exprsOrNil() (a, b ir.Node) {
 }
 
 func builtinCall(pos src.XPos, op ir.Op) *ir.CallExpr {
-	return ir.NewCallExpr(pos, ir.OCALL, ir.NewIdent(base.Pos, types.BuiltinPkg.Lookup(ir.OpNames[op])), nil, nil)
+	return ir.NewCallExpr(pos, ir.OCALL, ir.NewIdent(base.Pos, types.BuiltinPkg.Lookup(ir.OpNames[op])), nil)
 }
diff --git a/src/cmd/compile/internal/walk/builtin.go b/src/cmd/compile/internal/walk/builtin.go
index 60cbd66370..97f9de9c1d 100644
--- a/src/cmd/compile/internal/walk/builtin.go
+++ b/src/cmd/compile/internal/walk/builtin.go
@@ -631,7 +631,7 @@ func walkPrint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 			continue
 		}
 
-		r := ir.NewCallExpr(base.Pos, ir.OCALL, on, nil, nil)
+		r := ir.NewCallExpr(base.Pos, ir.OCALL, on, nil)
 		if params := on.Type().Params().FieldSlice(); len(params) > 0 {
 			t := params[0].Type
 			if !types.Identical(t, n.Type()) {
diff --git a/src/cmd/compile/internal/walk/compare.go b/src/cmd/compile/internal/walk/compare.go
index a076cdbe1a..f4b5387c06 100644
--- a/src/cmd/compile/internal/walk/compare.go
+++ b/src/cmd/compile/internal/walk/compare.go
@@ -160,7 +160,7 @@ func walkCompare(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 		}
 
 		fn, needsize := eqFor(t)
-		call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil, nil)
+		call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
 		call.Args.Append(typecheck.NodAddr(cmpl))
 		call.Args.Append(typecheck.NodAddr(cmpr))
 		if needsize {
diff --git a/src/cmd/compile/internal/walk/complit.go b/src/cmd/compile/internal/walk/complit.go
index 95f9d18f8c..73442dc404 100644
--- a/src/cmd/compile/internal/walk/complit.go
+++ b/src/cmd/compile/internal/walk/complit.go
@@ -416,7 +416,7 @@ func slicelit(ctxt initContext, n *ir.CompLitExpr, var_ ir.Node, init *ir.Nodes)
 
 func maplit(n *ir.CompLitExpr, m ir.Node, init *ir.Nodes) {
 	// make the map var
-	a := ir.NewCallExpr(base.Pos, ir.OMAKE, nil, nil, nil)
+	a := ir.NewCallExpr(base.Pos, ir.OMAKE, nil, nil)
 	a.SetEsc(n.Esc())
 	a.Args = []ir.Node{ir.TypeNode(n.Type()), ir.NewInt(int64(len(n.List)))}
 	litas(m, a, init)
diff --git a/src/cmd/compile/internal/walk/convert.go b/src/cmd/compile/internal/walk/convert.go
index 30bac5462f..fa8e2c0bb8 100644
--- a/src/cmd/compile/internal/walk/convert.go
+++ b/src/cmd/compile/internal/walk/convert.go
@@ -145,7 +145,7 @@ func walkConvInterface(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 		types.CalcSize(fromType)
 		fn = typecheck.SubstArgTypes(fn, fromType)
 		types.CalcSize(fn.Type())
-		call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil, nil)
+		call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
 		call.Args = []ir.Node{n.X}
 		e := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), safeExpr(walkExpr(typecheck.Expr(call), init), init))
 		e.SetType(toType)
@@ -180,7 +180,7 @@ func walkConvInterface(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 	fn := typecheck.LookupRuntime(fnname)
 	fn = typecheck.SubstArgTypes(fn, fromType, toType)
 	types.CalcSize(fn.Type())
-	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil, nil)
+	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
 	call.Args = []ir.Node{tab, v}
 	return walkExpr(typecheck.Expr(call), init)
 }
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index b7aeb53e43..d7a20206c8 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -469,7 +469,7 @@ func walkAddString(n *ir.AddStringExpr, init *ir.Nodes) ir.Node {
 	}
 
 	cat := typecheck.LookupRuntime(fn)
-	r := ir.NewCallExpr(base.Pos, ir.OCALL, cat, nil, nil)
+	r := ir.NewCallExpr(base.Pos, ir.OCALL, cat, nil)
 	r.Args = args
 	r1 := typecheck.Expr(r)
 	r1 = walkExpr(r1, init)
diff --git a/src/cmd/compile/internal/walk/stmt.go b/src/cmd/compile/internal/walk/stmt.go
index 8a076ca558..46a621c2ba 100644
--- a/src/cmd/compile/internal/walk/stmt.go
+++ b/src/cmd/compile/internal/walk/stmt.go
@@ -278,7 +278,7 @@ func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 		}
 		args[i] = ir.NewConvExpr(base.Pos, origArg.Op(), origArg.Type(), args[i])
 	}
-	call := ir.NewCallExpr(base.Pos, n.Op(), n.X, nil, args)
+	call := ir.NewCallExpr(base.Pos, n.Op(), n.X, args)
 	if !isBuiltinCall {
 		call.SetOp(ir.OCALL)
 		call.IsDDD = n.IsDDD
@@ -291,6 +291,6 @@ func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	typecheck.Stmts(fn.Body)
 	typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
 
-	call = ir.NewCallExpr(base.Pos, ir.OCALL, fn.Nname, nil, n.Args)
+	call = ir.NewCallExpr(base.Pos, ir.OCALL, fn.Nname, n.Args)
 	return walkExpr(typecheck.Stmt(call), init)
 }
diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index 91b7e34d54..b47d96dc4c 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -113,7 +113,7 @@ func vmkcall(fn ir.Node, t *types.Type, init *ir.Nodes, va []ir.Node) *ir.CallEx
 		base.Fatalf("vmkcall %v needs %v args got %v", fn, n, len(va))
 	}
 
-	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil, va)
+	call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, va)
 	typecheck.Call(call)
 	call.SetType(t)
 	return walkExpr(call, init).(*ir.CallExpr)
-- 
GitLab


From 3f845b3b45a2aba58e3412f31fd1b4bd6c581d04 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Tue, 2 Feb 2021 13:04:16 -0800
Subject: [PATCH 0586/2400] [dev.typeparams] cmd/compile: deal with inferred
 type arguments

Create an extra OFUNCINST node as needed, if there are inferred type
arguments for a generic function call.

Change-Id: Id990c5bcbce2893377072a7e41c7c6785d1eab60
Reviewed-on: https://go-review.googlesource.com/c/go/+/288952
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/expr.go    | 26 ++++++++++++++++++-----
 src/cmd/compile/internal/noder/helpers.go |  2 +-
 2 files changed, 22 insertions(+), 6 deletions(-)

diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index 3c18bdcc24..568ec216e3 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -93,11 +93,27 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 	case *syntax.AssertExpr:
 		return Assert(pos, g.expr(expr.X), g.typeExpr(expr.Type))
 	case *syntax.CallExpr:
-		def := g.info.Inferred[expr]
-		if len(def.Targs) > 0 {
-			panic("Inferred type arguments not handled yet")
+		fun := g.expr(expr.Fun)
+		if inferred, ok := g.info.Inferred[expr]; ok && len(inferred.Targs) > 0 {
+			targs := make([]ir.Node, len(inferred.Targs))
+			for i, targ := range inferred.Targs {
+				targs[i] = ir.TypeNode(g.typ(targ))
+			}
+			if fun.Op() == ir.OFUNCINST {
+				// Replace explicit type args with the full list that
+				// includes the additional inferred type args
+				fun.(*ir.InstExpr).Targs = targs
+			} else {
+				// Create a function instantiation here, given
+				// there are only inferred type args (e.g.
+				// min(5,6), where min is a generic function)
+				inst := ir.NewInstExpr(pos, ir.OFUNCINST, fun, targs)
+				typed(fun.Type(), inst)
+				fun = inst
+			}
+
 		}
-		return Call(pos, g.typ(typ), g.expr(expr.Fun), g.exprs(expr.ArgList), expr.HasDots)
+		return Call(pos, g.typ(typ), fun, g.exprs(expr.ArgList), expr.HasDots)
 	case *syntax.IndexExpr:
 		var targs []ir.Node
 		if _, ok := expr.Index.(*syntax.ListExpr); ok {
@@ -111,7 +127,7 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 			// This is generic function instantiation with a single type
 			targs = []ir.Node{index}
 		}
-		// This is a generic function instantiation
+		// This is a generic function instantiation (e.g. min[int])
 		x := g.expr(expr.X)
 		if x.Op() != ir.ONAME || x.Type().Kind() != types.TFUNC {
 			panic("Incorrect argument for generic func instantiation")
diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
index fcbb3a6ce5..bb17a5331a 100644
--- a/src/cmd/compile/internal/noder/helpers.go
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -119,7 +119,7 @@ func Call(pos src.XPos, typ *types.Type, fun ir.Node, args []ir.Node, dots bool)
 	n := ir.NewCallExpr(pos, ir.OCALL, fun, args)
 	n.IsDDD = dots
 
-	if n.X.Op() != ir.OFUNCINST {
+	if fun.Op() != ir.OFUNCINST {
 		// If no type params, still do normal typechecking, since we're
 		// still missing some things done by tcCall below (mainly
 		// typecheckargs and typecheckaste).
-- 
GitLab


From bb53a5ad43732893da095e82334fb9f0ea912878 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 1 Feb 2021 15:39:42 -0800
Subject: [PATCH 0587/2400] [dev.typeparams] cmd/compile/internal/importer:
 adjust importer to match compiler importer

The compiler chooses the literal value export format by type
not by constant.Kind. That is, a floating-point constant is
always exported as a (big) float value, not a (big) rational
value, even though the internal representation may be that
of a rational number. (This is a possibility now that the
compiler also uses the go/constant package.)

Naturally, during import, a floating-point value is read as
a float and represented as a (big) float in go/constant.

The types2 importer (based on the go/types importer) read
the floating-point number elements (mantissa, exponent) but
then constructed the float go/constant value through a series
of elementary operations, typically leading to a rational,
but sometimes even an integer number (e.g. for math.MaxFloat64).

There is no problem with that (the value is the same) but if
we want to impose bitsize limits on overlarge integer values
we quickly run into trouble with large floats represented as
integers.

This change matches the code importing float literals with
the code used by the compiler.

Note: At some point we may want to relax the import/export code
for constant values and export them by representation rather than
by type. As is, we lose accuracy since all floating-point point
values, even the ones internally represented as rational numbers
end up being exported as floating-point numbers.

Change-Id: Ic751b2046a0fd047f751da3d35cbef0a1b5fea3e
Reviewed-on: https://go-review.googlesource.com/c/go/+/288632
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/importer/iimport.go | 52 ++++++++------------
 1 file changed, 20 insertions(+), 32 deletions(-)

diff --git a/src/cmd/compile/internal/importer/iimport.go b/src/cmd/compile/internal/importer/iimport.go
index 6cb8e9377d..33c46a0f90 100644
--- a/src/cmd/compile/internal/importer/iimport.go
+++ b/src/cmd/compile/internal/importer/iimport.go
@@ -17,6 +17,7 @@ import (
 	"go/constant"
 	"go/token"
 	"io"
+	"math/big"
 	"sort"
 )
 
@@ -324,7 +325,9 @@ func (r *importReader) value() (typ types2.Type, val constant.Value) {
 		val = constant.MakeString(r.string())
 
 	case types2.IsInteger:
-		val = r.mpint(b)
+		var x big.Int
+		r.mpint(&x, b)
+		val = constant.Make(&x)
 
 	case types2.IsFloat:
 		val = r.mpfloat(b)
@@ -369,8 +372,8 @@ func intSize(b *types2.Basic) (signed bool, maxBytes uint) {
 	return
 }
 
-func (r *importReader) mpint(b *types2.Basic) constant.Value {
-	signed, maxBytes := intSize(b)
+func (r *importReader) mpint(x *big.Int, typ *types2.Basic) {
+	signed, maxBytes := intSize(typ)
 
 	maxSmall := 256 - maxBytes
 	if signed {
@@ -389,7 +392,8 @@ func (r *importReader) mpint(b *types2.Basic) constant.Value {
 				v = ^v
 			}
 		}
-		return constant.MakeInt64(v)
+		x.SetInt64(v)
+		return
 	}
 
 	v := -n
@@ -399,39 +403,23 @@ func (r *importReader) mpint(b *types2.Basic) constant.Value {
 	if v < 1 || uint(v) > maxBytes {
 		errorf("weird decoding: %v, %v => %v", n, signed, v)
 	}
-
-	buf := make([]byte, v)
-	io.ReadFull(&r.declReader, buf)
-
-	// convert to little endian
-	// TODO(gri) go/constant should have a more direct conversion function
-	//           (e.g., once it supports a big.Float based implementation)
-	for i, j := 0, len(buf)-1; i < j; i, j = i+1, j-1 {
-		buf[i], buf[j] = buf[j], buf[i]
-	}
-
-	x := constant.MakeFromBytes(buf)
+	b := make([]byte, v)
+	io.ReadFull(&r.declReader, b)
+	x.SetBytes(b)
 	if signed && n&1 != 0 {
-		x = constant.UnaryOp(token.SUB, x, 0)
+		x.Neg(x)
 	}
-	return x
 }
 
-func (r *importReader) mpfloat(b *types2.Basic) constant.Value {
-	x := r.mpint(b)
-	if constant.Sign(x) == 0 {
-		return x
-	}
-
-	exp := r.int64()
-	switch {
-	case exp > 0:
-		x = constant.Shift(x, token.SHL, uint(exp))
-	case exp < 0:
-		d := constant.Shift(constant.MakeInt64(1), token.SHL, uint(-exp))
-		x = constant.BinaryOp(x, token.QUO, d)
+func (r *importReader) mpfloat(typ *types2.Basic) constant.Value {
+	var mant big.Int
+	r.mpint(&mant, typ)
+	var f big.Float
+	f.SetInt(&mant)
+	if f.Sign() != 0 {
+		f.SetMantExp(&f, int(r.int64()))
 	}
-	return x
+	return constant.Make(&f)
 }
 
 func (r *importReader) ident() string {
-- 
GitLab


From 3db6e18468d9e5c8f5fcfece26b5b666f86e9742 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 2 Feb 2021 21:50:40 -0800
Subject: [PATCH 0588/2400] [dev.typeparams] test: enable more errorcheck tests

These newly enabled (not anymore excluded) tests pass now
that we run in -G=3 mode when using the new types2 based
noder.

Change-Id: I5e7304c8020f394b79737d67c750bebbe02bd502
Reviewed-on: https://go-review.googlesource.com/c/go/+/289109
Trust: Robert Griesemer <gri@golang.org>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 test/run.go | 27 ++++++++++-----------------
 1 file changed, 10 insertions(+), 17 deletions(-)

diff --git a/test/run.go b/test/run.go
index 8bc4104b34..d85a750a36 100644
--- a/test/run.go
+++ b/test/run.go
@@ -1932,18 +1932,16 @@ var excluded = map[string]bool{
 	"typecheck.go":    true, // invalid function is not causing errors when called
 	"writebarrier.go": true, // correct diagnostics, but different lines (probably irgen's fault)
 
-	"fixedbugs/bug176.go":    true, // types2 reports all errors (pref: types2)
-	"fixedbugs/bug193.go":    true, // types2 bug: shift error not reported (fixed in go/types)
-	"fixedbugs/bug195.go":    true, // types2 reports slightly different (but correct) bugs
-	"fixedbugs/bug228.go":    true, // types2 not run after syntax errors
-	"fixedbugs/bug231.go":    true, // types2 bug? (same error reported twice)
-	"fixedbugs/bug255.go":    true, // types2 reports extra errors
-	"fixedbugs/bug351.go":    true, // types2 reports extra errors
-	"fixedbugs/bug374.go":    true, // types2 reports extra errors
-	"fixedbugs/bug385_32.go": true, // types2 doesn't produce "stack frame too large" error (32-bit specific)
-	"fixedbugs/bug385_64.go": true, // types2 doesn't produce "stack frame too large" error
-	"fixedbugs/bug388.go":    true, // types2 not run due to syntax errors
-	"fixedbugs/bug412.go":    true, // types2 produces a follow-on error
+	"fixedbugs/bug176.go": true, // types2 reports all errors (pref: types2)
+	"fixedbugs/bug193.go": true, // types2 bug: shift error not reported (fixed in go/types)
+	"fixedbugs/bug195.go": true, // types2 reports slightly different (but correct) bugs
+	"fixedbugs/bug228.go": true, // types2 not run after syntax errors
+	"fixedbugs/bug231.go": true, // types2 bug? (same error reported twice)
+	"fixedbugs/bug255.go": true, // types2 reports extra errors
+	"fixedbugs/bug351.go": true, // types2 reports extra errors
+	"fixedbugs/bug374.go": true, // types2 reports extra errors
+	"fixedbugs/bug388.go": true, // types2 not run due to syntax errors
+	"fixedbugs/bug412.go": true, // types2 produces a follow-on error
 
 	"fixedbugs/issue11590.go":  true, // types2 doesn't report a follow-on error (pref: types2)
 	"fixedbugs/issue11610.go":  true, // types2 not run after syntax errors
@@ -1959,13 +1957,8 @@ var excluded = map[string]bool{
 	"fixedbugs/issue20233.go":  true, // types2 reports two instead of one error (pref: compiler)
 	"fixedbugs/issue20245.go":  true, // types2 reports two instead of one error (pref: compiler)
 	"fixedbugs/issue20250.go":  true, // correct diagnostics, but different lines (probably irgen's fault)
-	"fixedbugs/issue20529.go":  true, // types2 doesn't produce "stack frame too large" error
-	"fixedbugs/issue20780.go":  true, // types2 doesn't produce "stack frame too large" error
 	"fixedbugs/issue21979.go":  true, // types2 doesn't report a follow-on error (pref: types2)
-	"fixedbugs/issue22200.go":  true, // types2 doesn't produce "stack frame too large" error
-	"fixedbugs/issue22200b.go": true, // types2 doesn't produce "stack frame too large" error
 	"fixedbugs/issue23732.go":  true, // types2 reports different (but ok) line numbers
-	"fixedbugs/issue25507.go":  true, // types2 doesn't produce "stack frame too large" error
 	"fixedbugs/issue25958.go":  true, // types2 doesn't report a follow-on error (pref: types2)
 	"fixedbugs/issue28079b.go": true, // types2 reports follow-on errors
 	"fixedbugs/issue28268.go":  true, // types2 reports follow-on errors
-- 
GitLab


From c910fd7b771cfbfc1b11a6eef750f835bf66c96c Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 2 Feb 2021 13:20:03 -0800
Subject: [PATCH 0589/2400] [dev.typeparams] cmd/compile: refuse excessively
 long constants

The compiler uses 512 bit of precision for untyped constant
arithmetic but didn't restrict the length of incoming constant
literals in any way, possibly opening the door for excessively
long constants that could bring compilation to a crawl.

Add a simple check that refuses excessively long constants.
Add test.

Change-Id: I797cb2a8e677b8da2864eb92d686d271ab8a004d
Reviewed-on: https://go-review.googlesource.com/c/go/+/289049
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/noder/noder.go | 14 +++++
 src/cmd/compile/internal/types2/expr.go | 17 ++++++
 test/const7.go                          | 77 +++++++++++++++++++++++++
 3 files changed, 108 insertions(+)
 create mode 100644 test/const7.go

diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 1c38f1a934..d692bf97aa 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -1455,6 +1455,20 @@ func (p *noder) basicLit(lit *syntax.BasicLit) constant.Value {
 	switch lit.Kind {
 	case syntax.IntLit, syntax.FloatLit, syntax.ImagLit:
 		checkLangCompat(lit)
+		// The max. mantissa precision for untyped numeric values
+		// is 512 bits, or 4048 bits for each of the two integer
+		// parts of a fraction for floating-point numbers that are
+		// represented accurately in the go/constant package.
+		// Constant literals that are longer than this many bits
+		// are not meaningful; and excessively long constants may
+		// consume a lot of space and time for a useless conversion.
+		// Cap constant length with a generous upper limit that also
+		// allows for separators between all digits.
+		const limit = 10000
+		if len(lit.Value) > limit {
+			p.errorAt(lit.Pos(), "excessively long constant: %s... (%d chars)", lit.Value[:10], len(lit.Value))
+			return constant.MakeUnknown()
+		}
 	}
 
 	v := constant.MakeFromLiteral(lit.Value, tokenForLitKind[lit.Kind], 0)
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index c66e115c1f..a1a626fb33 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -1154,6 +1154,23 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 		if e.Bad {
 			goto Error // error reported during parsing
 		}
+		switch e.Kind {
+		case syntax.IntLit, syntax.FloatLit, syntax.ImagLit:
+			// The max. mantissa precision for untyped numeric values
+			// is 512 bits, or 4048 bits for each of the two integer
+			// parts of a fraction for floating-point numbers that are
+			// represented accurately in the go/constant package.
+			// Constant literals that are longer than this many bits
+			// are not meaningful; and excessively long constants may
+			// consume a lot of space and time for a useless conversion.
+			// Cap constant length with a generous upper limit that also
+			// allows for separators between all digits.
+			const limit = 10000
+			if len(e.Value) > limit {
+				check.errorf(e, "excessively long constant: %s... (%d chars)", e.Value[:10], len(e.Value))
+				goto Error
+			}
+		}
 		x.setConst(e.Kind, e.Value)
 		if x.mode == invalid {
 			// The parser already establishes syntactic correctness.
diff --git a/test/const7.go b/test/const7.go
new file mode 100644
index 0000000000..9ffd678fc5
--- /dev/null
+++ b/test/const7.go
@@ -0,0 +1,77 @@
+// run
+
+// Copyright 2021 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.
+
+// Check that the compiler refuses excessively long constants.
+
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+)
+
+// testProg creates a package called name, with path dir/name.go,
+// which declares an untyped constant of the given length.
+// testProg compiles this package and checks for the absence or
+// presence of a constant literal error.
+func testProg(dir, name string, G_option, length int, ok bool) {
+	var buf bytes.Buffer
+
+	fmt.Fprintf(&buf,
+		"package %s; const _ = %s // %d digits",
+		name, strings.Repeat("9", length), length,
+	)
+
+	filename := filepath.Join(dir, fmt.Sprintf("%s.go", name))
+	if err := os.WriteFile(filename, buf.Bytes(), 0666); err != nil {
+		log.Fatal(err)
+	}
+
+	cmd := exec.Command("go", "tool", "compile", fmt.Sprintf("-G=%d", G_option), filename)
+	cmd.Dir = dir
+	output, err := cmd.CombinedOutput()
+
+	if ok {
+		// no error expected
+		if err != nil {
+			log.Fatalf("%s: compile failed unexpectedly: %v", name, err)
+		}
+		return
+	}
+
+	// error expected
+	if err == nil {
+		log.Fatalf("%s: compile succeeded unexpectedly", name)
+	}
+	if !bytes.Contains(output, []byte("excessively long constant")) {
+		log.Fatalf("%s: wrong compiler error message:\n%s\n", name, output)
+	}
+}
+
+func main() {
+	if runtime.GOOS == "js" || runtime.Compiler != "gc" {
+		return
+	}
+
+	dir, err := ioutil.TempDir("", "const7_")
+	if err != nil {
+		log.Fatalf("creating temp dir: %v\n", err)
+	}
+	defer os.RemoveAll(dir)
+
+	const limit = 10000 // compiler-internal constant length limit
+	testProg(dir, "x1", 0, limit, true)    // -G=0
+	testProg(dir, "x2", 0, limit+1, false) // -G=0
+	testProg(dir, "x1", 1, limit, true)    // -G=1 (new type checker)
+	testProg(dir, "x2", 1, limit+1, false) // -G=1 (new type checker)
+}
-- 
GitLab


From dc122c7a9c45f1ae16125024d4f06953cc322bcd Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 3 Feb 2021 12:09:25 -0800
Subject: [PATCH 0590/2400] [dev.typeparams] test: exclude a failing test again
 (fix 32bit builds)

Change-Id: I6290bc4921ef17586b5028d3f40a88372b175014
Reviewed-on: https://go-review.googlesource.com/c/go/+/289269
Trust: Robert Griesemer <gri@golang.org>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 test/run.go | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/test/run.go b/test/run.go
index d85a750a36..30cab82301 100644
--- a/test/run.go
+++ b/test/run.go
@@ -1932,16 +1932,17 @@ var excluded = map[string]bool{
 	"typecheck.go":    true, // invalid function is not causing errors when called
 	"writebarrier.go": true, // correct diagnostics, but different lines (probably irgen's fault)
 
-	"fixedbugs/bug176.go": true, // types2 reports all errors (pref: types2)
-	"fixedbugs/bug193.go": true, // types2 bug: shift error not reported (fixed in go/types)
-	"fixedbugs/bug195.go": true, // types2 reports slightly different (but correct) bugs
-	"fixedbugs/bug228.go": true, // types2 not run after syntax errors
-	"fixedbugs/bug231.go": true, // types2 bug? (same error reported twice)
-	"fixedbugs/bug255.go": true, // types2 reports extra errors
-	"fixedbugs/bug351.go": true, // types2 reports extra errors
-	"fixedbugs/bug374.go": true, // types2 reports extra errors
-	"fixedbugs/bug388.go": true, // types2 not run due to syntax errors
-	"fixedbugs/bug412.go": true, // types2 produces a follow-on error
+	"fixedbugs/bug176.go":    true, // types2 reports all errors (pref: types2)
+	"fixedbugs/bug193.go":    true, // types2 bug: shift error not reported (fixed in go/types)
+	"fixedbugs/bug195.go":    true, // types2 reports slightly different (but correct) bugs
+	"fixedbugs/bug228.go":    true, // types2 not run after syntax errors
+	"fixedbugs/bug231.go":    true, // types2 bug? (same error reported twice)
+	"fixedbugs/bug255.go":    true, // types2 reports extra errors
+	"fixedbugs/bug351.go":    true, // types2 reports extra errors
+	"fixedbugs/bug374.go":    true, // types2 reports extra errors
+	"fixedbugs/bug385_32.go": true, // types2 doesn't produce missing error "type .* too large" (32-bit specific)
+	"fixedbugs/bug388.go":    true, // types2 not run due to syntax errors
+	"fixedbugs/bug412.go":    true, // types2 produces a follow-on error
 
 	"fixedbugs/issue11590.go":  true, // types2 doesn't report a follow-on error (pref: types2)
 	"fixedbugs/issue11610.go":  true, // types2 not run after syntax errors
-- 
GitLab


From bfc7418e6d3a505fe348718fd113473c9d92b135 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Fri, 29 Jan 2021 12:03:32 -0500
Subject: [PATCH 0591/2400] [dev.regabi] runtime, syscall, etc.: mark Darwin
 syscall wrappers as ABIInternal

Mark the syscall wrappers as ABIInternal, as they have addresses
taken from Go code, and it is important to call to them without
wrappers.

Previously, the wrapper is just a single JMP instruction, which
makes it not matter. In the next CL we'll make the wrapper
actually have a frame. The real wrappers will mess up things
such as stack alignment for C ABI.

This doesn't look really nice, but I don't know how we can do
better...

TODO: other OSes.

Change-Id: Ifb3920494990a7775e3e6902fbcaf137df3cc653
Reviewed-on: https://go-review.googlesource.com/c/go/+/288092
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/dist/build.go                         |   2 +
 src/cmd/internal/objabi/path.go               |   2 +
 .../x509/internal/macos/corefoundation.s      |  21 +-
 src/crypto/x509/internal/macos/security.s     |  11 +-
 src/runtime/sys_darwin_amd64.s                |  96 +++----
 src/syscall/mkasm.go                          |   3 +-
 src/syscall/zsyscall_darwin_amd64.s           | 250 +++++++++---------
 src/syscall/zsyscall_darwin_arm64.s           | 250 +++++++++---------
 src/syscall/zsyscall_openbsd_amd64.s          | 230 ++++++++--------
 src/syscall/zsyscall_openbsd_arm64.s          | 230 ++++++++--------
 10 files changed, 554 insertions(+), 541 deletions(-)

diff --git a/src/cmd/dist/build.go b/src/cmd/dist/build.go
index c8c3212d16..332f2fab58 100644
--- a/src/cmd/dist/build.go
+++ b/src/cmd/dist/build.go
@@ -1765,6 +1765,8 @@ func IsRuntimePackagePath(pkgpath string) bool {
 		rval = true
 	case "syscall":
 		rval = true
+	case "crypto/x509/internal/macos": // libc function wrappers need to be ABIInternal
+		rval = true
 	default:
 		rval = strings.HasPrefix(pkgpath, "runtime/internal")
 	}
diff --git a/src/cmd/internal/objabi/path.go b/src/cmd/internal/objabi/path.go
index fd1c9981c6..1a0784cf7f 100644
--- a/src/cmd/internal/objabi/path.go
+++ b/src/cmd/internal/objabi/path.go
@@ -56,6 +56,8 @@ func IsRuntimePackagePath(pkgpath string) bool {
 		rval = true
 	case "syscall":
 		rval = true
+	case "crypto/x509/internal/macos": // libc function wrappers need to be ABIInternal
+		rval = true
 	default:
 		rval = strings.HasPrefix(pkgpath, "runtime/internal")
 	}
diff --git a/src/crypto/x509/internal/macos/corefoundation.s b/src/crypto/x509/internal/macos/corefoundation.s
index a4495d68dd..1ce39fac9d 100644
--- a/src/crypto/x509/internal/macos/corefoundation.s
+++ b/src/crypto/x509/internal/macos/corefoundation.s
@@ -6,21 +6,24 @@
 
 #include "textflag.h"
 
-TEXT ·x509_CFArrayGetCount_trampoline(SB),NOSPLIT,$0-0
+// The trampolines are ABIInternal as they are address-taken in
+// Go code.
+
+TEXT ·x509_CFArrayGetCount_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	x509_CFArrayGetCount(SB)
-TEXT ·x509_CFArrayGetValueAtIndex_trampoline(SB),NOSPLIT,$0-0
+TEXT ·x509_CFArrayGetValueAtIndex_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	x509_CFArrayGetValueAtIndex(SB)
-TEXT ·x509_CFDataGetBytePtr_trampoline(SB),NOSPLIT,$0-0
+TEXT ·x509_CFDataGetBytePtr_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	x509_CFDataGetBytePtr(SB)
-TEXT ·x509_CFDataGetLength_trampoline(SB),NOSPLIT,$0-0
+TEXT ·x509_CFDataGetLength_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	x509_CFDataGetLength(SB)
-TEXT ·x509_CFStringCreateWithBytes_trampoline(SB),NOSPLIT,$0-0
+TEXT ·x509_CFStringCreateWithBytes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	x509_CFStringCreateWithBytes(SB)
-TEXT ·x509_CFRelease_trampoline(SB),NOSPLIT,$0-0
+TEXT ·x509_CFRelease_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	x509_CFRelease(SB)
-TEXT ·x509_CFDictionaryGetValueIfPresent_trampoline(SB),NOSPLIT,$0-0
+TEXT ·x509_CFDictionaryGetValueIfPresent_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	x509_CFDictionaryGetValueIfPresent(SB)
-TEXT ·x509_CFNumberGetValue_trampoline(SB),NOSPLIT,$0-0
+TEXT ·x509_CFNumberGetValue_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	x509_CFNumberGetValue(SB)
-TEXT ·x509_CFEqual_trampoline(SB),NOSPLIT,$0-0
+TEXT ·x509_CFEqual_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	x509_CFEqual(SB)
diff --git a/src/crypto/x509/internal/macos/security.s b/src/crypto/x509/internal/macos/security.s
index bd446dbcbe..bea265a5ef 100644
--- a/src/crypto/x509/internal/macos/security.s
+++ b/src/crypto/x509/internal/macos/security.s
@@ -6,11 +6,14 @@
 
 #include "textflag.h"
 
-TEXT ·x509_SecTrustSettingsCopyCertificates_trampoline(SB),NOSPLIT,$0-0
+// The trampolines are ABIInternal as they are address-taken in
+// Go code.
+
+TEXT ·x509_SecTrustSettingsCopyCertificates_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	x509_SecTrustSettingsCopyCertificates(SB)
-TEXT ·x509_SecItemExport_trampoline(SB),NOSPLIT,$0-0
+TEXT ·x509_SecItemExport_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	x509_SecItemExport(SB)
-TEXT ·x509_SecTrustSettingsCopyTrustSettings_trampoline(SB),NOSPLIT,$0-0
+TEXT ·x509_SecTrustSettingsCopyTrustSettings_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	x509_SecTrustSettingsCopyTrustSettings(SB)
-TEXT ·x509_SecPolicyCopyProperties_trampoline(SB),NOSPLIT,$0-0
+TEXT ·x509_SecPolicyCopyProperties_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	x509_SecPolicyCopyProperties(SB)
diff --git a/src/runtime/sys_darwin_amd64.s b/src/runtime/sys_darwin_amd64.s
index 630fb5df64..0fe8c7e172 100644
--- a/src/runtime/sys_darwin_amd64.s
+++ b/src/runtime/sys_darwin_amd64.s
@@ -5,6 +5,8 @@
 // System calls and other sys.stuff for AMD64, Darwin
 // System calls are implemented in libSystem, this file contains
 // trampolines that convert from Go to C calling convention.
+// The trampolines are ABIInternal as they are referenced from
+// Go code with funcPC.
 
 #include "go_asm.h"
 #include "go_tls.h"
@@ -13,7 +15,7 @@
 #define CLOCK_REALTIME		0
 
 // Exit the entire program (like C exit)
-TEXT runtime·exit_trampoline(SB),NOSPLIT,$0
+TEXT runtime·exit_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVL	0(DI), DI		// arg 1 exit status
@@ -22,7 +24,7 @@ TEXT runtime·exit_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·open_trampoline(SB),NOSPLIT,$0
+TEXT runtime·open_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVL	8(DI), SI		// arg 2 flags
@@ -33,7 +35,7 @@ TEXT runtime·open_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·close_trampoline(SB),NOSPLIT,$0
+TEXT runtime·close_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVL	0(DI), DI		// arg 1 fd
@@ -41,7 +43,7 @@ TEXT runtime·close_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·read_trampoline(SB),NOSPLIT,$0
+TEXT runtime·read_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI		// arg 2 buf
@@ -57,7 +59,7 @@ noerr:
 	POPQ	BP
 	RET
 
-TEXT runtime·write_trampoline(SB),NOSPLIT,$0
+TEXT runtime·write_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI		// arg 2 buf
@@ -73,7 +75,7 @@ noerr:
 	POPQ	BP
 	RET
 
-TEXT runtime·pipe_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pipe_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	CALL	libc_pipe(SB)		// pointer already in DI
@@ -84,7 +86,7 @@ TEXT runtime·pipe_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·setitimer_trampoline(SB),NOSPLIT,$0
+TEXT runtime·setitimer_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI		// arg 2 new
@@ -94,7 +96,7 @@ TEXT runtime·setitimer_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·madvise_trampoline(SB), NOSPLIT, $0
+TEXT runtime·madvise_trampoline<ABIInternal>(SB), NOSPLIT, $0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI	// arg 2 len
@@ -105,12 +107,12 @@ TEXT runtime·madvise_trampoline(SB), NOSPLIT, $0
 	POPQ	BP
 	RET
 
-TEXT runtime·mlock_trampoline(SB), NOSPLIT, $0
+TEXT runtime·mlock_trampoline<ABIInternal>(SB), NOSPLIT, $0
 	UNDEF // unimplemented
 
 GLOBL timebase<>(SB),NOPTR,$(machTimebaseInfo__size)
 
-TEXT runtime·nanotime_trampoline(SB),NOSPLIT,$0
+TEXT runtime·nanotime_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	DI, BX
@@ -139,7 +141,7 @@ initialized:
 	POPQ	BP
 	RET
 
-TEXT runtime·walltime_trampoline(SB),NOSPLIT,$0
+TEXT runtime·walltime_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP			// make a frame; keep stack aligned
 	MOVQ	SP, BP
 	MOVQ	DI, SI			// arg 2 timespec
@@ -148,7 +150,7 @@ TEXT runtime·walltime_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·sigaction_trampoline(SB),NOSPLIT,$0
+TEXT runtime·sigaction_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI		// arg 2 new
@@ -161,7 +163,7 @@ TEXT runtime·sigaction_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·sigprocmask_trampoline(SB),NOSPLIT,$0
+TEXT runtime·sigprocmask_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI	// arg 2 new
@@ -174,7 +176,7 @@ TEXT runtime·sigprocmask_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·sigaltstack_trampoline(SB),NOSPLIT,$0
+TEXT runtime·sigaltstack_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI		// arg 2 old
@@ -186,7 +188,7 @@ TEXT runtime·sigaltstack_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·raiseproc_trampoline(SB),NOSPLIT,$0
+TEXT runtime·raiseproc_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVL	0(DI), BX	// signal
@@ -212,7 +214,7 @@ TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
 
 // This is the function registered during sigaction and is invoked when
 // a signal is received. It just redirects to the Go function sigtrampgo.
-TEXT runtime·sigtramp(SB),NOSPLIT,$0
+TEXT runtime·sigtramp<ABIInternal>(SB),NOSPLIT,$0
 	// This runs on the signal stack, so we have lots of stack available.
 	// We allocate our own stack space, because if we tell the linker
 	// how much we're using, the NOSPLIT check fails.
@@ -246,7 +248,7 @@ TEXT runtime·sigtramp(SB),NOSPLIT,$0
 
 // Used instead of sigtramp in programs that use cgo.
 // Arguments from kernel are in DI, SI, DX.
-TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0
+TEXT runtime·cgoSigtramp<ABIInternal>(SB),NOSPLIT,$0
 	// If no traceback function, do usual sigtramp.
 	MOVQ	runtime·cgoTraceback(SB), AX
 	TESTQ	AX, AX
@@ -289,12 +291,12 @@ TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0
 	// The first three arguments, and the fifth, are already in registers.
 	// Set the two remaining arguments now.
 	MOVQ	runtime·cgoTraceback(SB), CX
-	MOVQ	$runtime·sigtramp(SB), R9
+	MOVQ	$runtime·sigtramp<ABIInternal>(SB), R9
 	MOVQ	_cgo_callers(SB), AX
 	JMP	AX
 
 sigtramp:
-	JMP	runtime·sigtramp(SB)
+	JMP	runtime·sigtramp<ABIInternal>(SB)
 
 sigtrampnog:
 	// Signal arrived on a non-Go thread. If this is SIGPROF, get a
@@ -320,7 +322,7 @@ sigtrampnog:
 	MOVQ	_cgo_callers(SB), AX
 	JMP	AX
 
-TEXT runtime·mmap_trampoline(SB),NOSPLIT,$0
+TEXT runtime·mmap_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP			// make a frame; keep stack aligned
 	MOVQ	SP, BP
 	MOVQ	DI, BX
@@ -343,7 +345,7 @@ ok:
 	POPQ	BP
 	RET
 
-TEXT runtime·munmap_trampoline(SB),NOSPLIT,$0
+TEXT runtime·munmap_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI		// arg 2 len
@@ -355,7 +357,7 @@ TEXT runtime·munmap_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·usleep_trampoline(SB),NOSPLIT,$0
+TEXT runtime·usleep_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVL	0(DI), DI	// arg 1 usec
@@ -367,7 +369,7 @@ TEXT runtime·settls(SB),NOSPLIT,$32
 	// Nothing to do on Darwin, pthread already set thread-local storage up.
 	RET
 
-TEXT runtime·sysctl_trampoline(SB),NOSPLIT,$0
+TEXT runtime·sysctl_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVL	8(DI), SI		// arg 2 miblen
@@ -380,7 +382,7 @@ TEXT runtime·sysctl_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·sysctlbyname_trampoline(SB),NOSPLIT,$0
+TEXT runtime·sysctlbyname_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI		// arg 2 oldp
@@ -392,14 +394,14 @@ TEXT runtime·sysctlbyname_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·kqueue_trampoline(SB),NOSPLIT,$0
+TEXT runtime·kqueue_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	CALL	libc_kqueue(SB)
 	POPQ	BP
 	RET
 
-TEXT runtime·kevent_trampoline(SB),NOSPLIT,$0
+TEXT runtime·kevent_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI		// arg 2 keventt
@@ -418,7 +420,7 @@ ok:
 	POPQ	BP
 	RET
 
-TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$0
+TEXT runtime·fcntl_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVL	4(DI), SI		// arg 2 cmd
@@ -475,7 +477,7 @@ TEXT runtime·mstart_stub(SB),NOSPLIT,$0
 // A pointer to the arguments is passed in DI.
 // A single int32 result is returned in AX.
 // (For more results, make an args/results structure.)
-TEXT runtime·pthread_attr_init_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_attr_init_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP	// make frame, keep stack 16-byte aligned.
 	MOVQ	SP, BP
 	MOVQ	0(DI), DI // arg 1 attr
@@ -483,7 +485,7 @@ TEXT runtime·pthread_attr_init_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·pthread_attr_getstacksize_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_attr_getstacksize_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI	// arg 2 size
@@ -492,7 +494,7 @@ TEXT runtime·pthread_attr_getstacksize_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·pthread_attr_setdetachstate_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_attr_setdetachstate_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI	// arg 2 state
@@ -501,7 +503,7 @@ TEXT runtime·pthread_attr_setdetachstate_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·pthread_create_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_create_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	SUBQ	$16, SP
@@ -514,7 +516,7 @@ TEXT runtime·pthread_create_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·raise_trampoline(SB),NOSPLIT,$0
+TEXT runtime·raise_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVL	0(DI), DI	// arg 1 signal
@@ -522,7 +524,7 @@ TEXT runtime·raise_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·pthread_mutex_init_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_mutex_init_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI	// arg 2 attr
@@ -531,7 +533,7 @@ TEXT runtime·pthread_mutex_init_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·pthread_mutex_lock_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_mutex_lock_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	0(DI), DI	// arg 1 mutex
@@ -539,7 +541,7 @@ TEXT runtime·pthread_mutex_lock_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·pthread_mutex_unlock_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_mutex_unlock_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	0(DI), DI	// arg 1 mutex
@@ -547,7 +549,7 @@ TEXT runtime·pthread_mutex_unlock_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·pthread_cond_init_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_cond_init_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI	// arg 2 attr
@@ -556,7 +558,7 @@ TEXT runtime·pthread_cond_init_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·pthread_cond_wait_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_cond_wait_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI	// arg 2 mutex
@@ -565,7 +567,7 @@ TEXT runtime·pthread_cond_wait_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·pthread_cond_timedwait_relative_np_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_cond_timedwait_relative_np_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI	// arg 2 mutex
@@ -575,7 +577,7 @@ TEXT runtime·pthread_cond_timedwait_relative_np_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·pthread_cond_signal_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_cond_signal_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	0(DI), DI	// arg 1 cond
@@ -583,7 +585,7 @@ TEXT runtime·pthread_cond_signal_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·pthread_self_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_self_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	DI, BX		// BX is caller-save
@@ -592,7 +594,7 @@ TEXT runtime·pthread_self_trampoline(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·pthread_kill_trampoline(SB),NOSPLIT,$0
+TEXT runtime·pthread_kill_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI	// arg 2 sig
@@ -617,7 +619,7 @@ TEXT runtime·pthread_kill_trampoline(SB),NOSPLIT,$0
 //
 // syscall expects a 32-bit result and tests for 32-bit -1
 // to decide there was an error.
-TEXT runtime·syscall(SB),NOSPLIT,$0
+TEXT runtime·syscall<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	SUBQ	$16, SP
@@ -667,7 +669,7 @@ ok:
 //
 // syscallX is like syscall but expects a 64-bit result
 // and tests for 64-bit -1 to decide there was an error.
-TEXT runtime·syscallX(SB),NOSPLIT,$0
+TEXT runtime·syscallX<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	SUBQ	$16, SP
@@ -703,7 +705,7 @@ ok:
 
 // syscallPtr is like syscallX except that the libc function reports an
 // error by returning NULL and setting errno.
-TEXT runtime·syscallPtr(SB),NOSPLIT,$0
+TEXT runtime·syscallPtr<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	SUBQ	$16, SP
@@ -756,7 +758,7 @@ ok:
 //
 // syscall6 expects a 32-bit result and tests for 32-bit -1
 // to decide there was an error.
-TEXT runtime·syscall6(SB),NOSPLIT,$0
+TEXT runtime·syscall6<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	SUBQ	$16, SP
@@ -809,7 +811,7 @@ ok:
 //
 // syscall6X is like syscall6 but expects a 64-bit result
 // and tests for 64-bit -1 to decide there was an error.
-TEXT runtime·syscall6X(SB),NOSPLIT,$0
+TEXT runtime·syscall6X<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	SUBQ	$16, SP
@@ -845,7 +847,7 @@ ok:
 
 // syscallNoErr is like syscall6 but does not check for errors, and
 // only returns one value, for use with standard C ABI library functions.
-TEXT runtime·syscallNoErr(SB),NOSPLIT,$0
+TEXT runtime·syscallNoErr<ABIInternal>(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	SUBQ	$16, SP
diff --git a/src/syscall/mkasm.go b/src/syscall/mkasm.go
index 2ebaf8d351..e53d14bed1 100644
--- a/src/syscall/mkasm.go
+++ b/src/syscall/mkasm.go
@@ -53,7 +53,8 @@ func main() {
 		fn := line[5 : len(line)-13]
 		if !trampolines[fn] {
 			trampolines[fn] = true
-			fmt.Fprintf(&out, "TEXT ·%s_trampoline(SB),NOSPLIT,$0-0\n", fn)
+			// The trampolines are ABIInternal as they are address-taken in Go code.
+			fmt.Fprintf(&out, "TEXT ·%s_trampoline<ABIInternal>(SB),NOSPLIT,$0-0\n", fn)
 			fmt.Fprintf(&out, "\tJMP\t%s(SB)\n", fn)
 		}
 	}
diff --git a/src/syscall/zsyscall_darwin_amd64.s b/src/syscall/zsyscall_darwin_amd64.s
index 492f947855..5eb48cee44 100644
--- a/src/syscall/zsyscall_darwin_amd64.s
+++ b/src/syscall/zsyscall_darwin_amd64.s
@@ -1,253 +1,253 @@
 // go run mkasm.go darwin amd64
 // Code generated by the command above; DO NOT EDIT.
 #include "textflag.h"
-TEXT ·libc_getfsstat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getfsstat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getfsstat(SB)
-TEXT ·libc_setattrlist_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setattrlist_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setattrlist(SB)
-TEXT ·libc_fdopendir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fdopendir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fdopendir(SB)
-TEXT ·libc_sendfile_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sendfile_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_sendfile(SB)
-TEXT ·libc_getgroups_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getgroups_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getgroups(SB)
-TEXT ·libc_setgroups_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setgroups_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setgroups(SB)
-TEXT ·libc_wait4_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_wait4_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_wait4(SB)
-TEXT ·libc_accept_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_accept_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_accept(SB)
-TEXT ·libc_bind_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_bind_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_bind(SB)
-TEXT ·libc_connect_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_connect_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_connect(SB)
-TEXT ·libc_socket_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_socket_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_socket(SB)
-TEXT ·libc_getsockopt_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getsockopt_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getsockopt(SB)
-TEXT ·libc_setsockopt_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setsockopt_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setsockopt(SB)
-TEXT ·libc_getpeername_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpeername_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getpeername(SB)
-TEXT ·libc_getsockname_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getsockname_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getsockname(SB)
-TEXT ·libc_shutdown_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_shutdown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_shutdown(SB)
-TEXT ·libc_socketpair_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_socketpair_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_socketpair(SB)
-TEXT ·libc_recvfrom_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_recvfrom_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_recvfrom(SB)
-TEXT ·libc_sendto_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sendto_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_sendto(SB)
-TEXT ·libc_recvmsg_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_recvmsg_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_recvmsg(SB)
-TEXT ·libc_sendmsg_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sendmsg_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_sendmsg(SB)
-TEXT ·libc_kevent_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_kevent_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_kevent(SB)
-TEXT ·libc_utimes_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_utimes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_utimes(SB)
-TEXT ·libc_futimes_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_futimes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_futimes(SB)
-TEXT ·libc_fcntl_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fcntl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fcntl(SB)
-TEXT ·libc_pipe_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_pipe_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_pipe(SB)
-TEXT ·libc_kill_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_kill_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_kill(SB)
-TEXT ·libc_access_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_access_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_access(SB)
-TEXT ·libc_adjtime_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_adjtime_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_adjtime(SB)
-TEXT ·libc_chdir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_chdir(SB)
-TEXT ·libc_chflags_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chflags_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_chflags(SB)
-TEXT ·libc_chmod_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chmod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_chmod(SB)
-TEXT ·libc_chown_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_chown(SB)
-TEXT ·libc_chroot_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chroot_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_chroot(SB)
-TEXT ·libc_close_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_close_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_close(SB)
-TEXT ·libc_closedir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_closedir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_closedir(SB)
-TEXT ·libc_dup_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_dup_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_dup(SB)
-TEXT ·libc_dup2_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_dup2_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_dup2(SB)
-TEXT ·libc_exchangedata_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_exchangedata_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_exchangedata(SB)
-TEXT ·libc_fchdir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fchdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fchdir(SB)
-TEXT ·libc_fchflags_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fchflags_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fchflags(SB)
-TEXT ·libc_fchmod_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fchmod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fchmod(SB)
-TEXT ·libc_fchown_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fchown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fchown(SB)
-TEXT ·libc_flock_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_flock_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_flock(SB)
-TEXT ·libc_fpathconf_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fpathconf_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fpathconf(SB)
-TEXT ·libc_fsync_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fsync_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fsync(SB)
-TEXT ·libc_ftruncate_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_ftruncate_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_ftruncate(SB)
-TEXT ·libc_getdtablesize_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getdtablesize_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getdtablesize(SB)
-TEXT ·libc_getegid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getegid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getegid(SB)
-TEXT ·libc_geteuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_geteuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_geteuid(SB)
-TEXT ·libc_getgid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getgid(SB)
-TEXT ·libc_getpgid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getpgid(SB)
-TEXT ·libc_getpgrp_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpgrp_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getpgrp(SB)
-TEXT ·libc_getpid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getpid(SB)
-TEXT ·libc_getppid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getppid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getppid(SB)
-TEXT ·libc_getpriority_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpriority_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getpriority(SB)
-TEXT ·libc_getrlimit_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getrlimit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getrlimit(SB)
-TEXT ·libc_getrusage_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getrusage_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getrusage(SB)
-TEXT ·libc_getsid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getsid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getsid(SB)
-TEXT ·libc_getuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getuid(SB)
-TEXT ·libc_issetugid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_issetugid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_issetugid(SB)
-TEXT ·libc_kqueue_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_kqueue_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_kqueue(SB)
-TEXT ·libc_lchown_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_lchown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_lchown(SB)
-TEXT ·libc_link_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_link_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_link(SB)
-TEXT ·libc_listen_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_listen_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_listen(SB)
-TEXT ·libc_mkdir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mkdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_mkdir(SB)
-TEXT ·libc_mkfifo_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mkfifo_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_mkfifo(SB)
-TEXT ·libc_mknod_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mknod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_mknod(SB)
-TEXT ·libc_mlock_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mlock_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_mlock(SB)
-TEXT ·libc_mlockall_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mlockall_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_mlockall(SB)
-TEXT ·libc_mprotect_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mprotect_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_mprotect(SB)
-TEXT ·libc_munlock_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_munlock_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_munlock(SB)
-TEXT ·libc_munlockall_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_munlockall_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_munlockall(SB)
-TEXT ·libc_open_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_open_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_open(SB)
-TEXT ·libc_pathconf_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_pathconf_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_pathconf(SB)
-TEXT ·libc_pread_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_pread_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_pread(SB)
-TEXT ·libc_pwrite_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_pwrite_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_pwrite(SB)
-TEXT ·libc_read_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_read_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_read(SB)
-TEXT ·libc_readdir_r_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_readdir_r_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_readdir_r(SB)
-TEXT ·libc_readlink_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_readlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_readlink(SB)
-TEXT ·libc_rename_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_rename_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_rename(SB)
-TEXT ·libc_revoke_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_revoke_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_revoke(SB)
-TEXT ·libc_rmdir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_rmdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_rmdir(SB)
-TEXT ·libc_lseek_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_lseek_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_lseek(SB)
-TEXT ·libc_select_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_select_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_select(SB)
-TEXT ·libc_setegid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setegid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setegid(SB)
-TEXT ·libc_seteuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_seteuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_seteuid(SB)
-TEXT ·libc_setgid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setgid(SB)
-TEXT ·libc_setlogin_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setlogin_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setlogin(SB)
-TEXT ·libc_setpgid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setpgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setpgid(SB)
-TEXT ·libc_setpriority_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setpriority_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setpriority(SB)
-TEXT ·libc_setprivexec_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setprivexec_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setprivexec(SB)
-TEXT ·libc_setregid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setregid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setregid(SB)
-TEXT ·libc_setreuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setreuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setreuid(SB)
-TEXT ·libc_setrlimit_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setrlimit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setrlimit(SB)
-TEXT ·libc_setsid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setsid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setsid(SB)
-TEXT ·libc_settimeofday_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_settimeofday_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_settimeofday(SB)
-TEXT ·libc_setuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setuid(SB)
-TEXT ·libc_symlink_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_symlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_symlink(SB)
-TEXT ·libc_sync_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sync_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_sync(SB)
-TEXT ·libc_truncate_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_truncate_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_truncate(SB)
-TEXT ·libc_umask_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_umask_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_umask(SB)
-TEXT ·libc_undelete_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_undelete_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_undelete(SB)
-TEXT ·libc_unlink_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_unlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_unlink(SB)
-TEXT ·libc_unmount_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_unmount_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_unmount(SB)
-TEXT ·libc_write_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_write_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_write(SB)
-TEXT ·libc_writev_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_writev_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_writev(SB)
-TEXT ·libc_mmap_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mmap_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_mmap(SB)
-TEXT ·libc_munmap_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_munmap_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_munmap(SB)
-TEXT ·libc_fork_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fork_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fork(SB)
-TEXT ·libc_ioctl_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_ioctl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_ioctl(SB)
-TEXT ·libc_execve_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_execve_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_execve(SB)
-TEXT ·libc_exit_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_exit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_exit(SB)
-TEXT ·libc_sysctl_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sysctl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_sysctl(SB)
-TEXT ·libc_unlinkat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_unlinkat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_unlinkat(SB)
-TEXT ·libc_openat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_openat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_openat(SB)
-TEXT ·libc_getcwd_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getcwd_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getcwd(SB)
-TEXT ·libc_fstat64_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fstat64_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fstat64(SB)
-TEXT ·libc_fstatfs64_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fstatfs64_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fstatfs64(SB)
-TEXT ·libc_gettimeofday_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_gettimeofday_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_gettimeofday(SB)
-TEXT ·libc_lstat64_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_lstat64_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_lstat64(SB)
-TEXT ·libc_stat64_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_stat64_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_stat64(SB)
-TEXT ·libc_statfs64_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_statfs64_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_statfs64(SB)
-TEXT ·libc_fstatat64_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fstatat64_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fstatat64(SB)
-TEXT ·libc_ptrace_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_ptrace_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_ptrace(SB)
diff --git a/src/syscall/zsyscall_darwin_arm64.s b/src/syscall/zsyscall_darwin_arm64.s
index b606c6e49e..73e4a3fd8d 100644
--- a/src/syscall/zsyscall_darwin_arm64.s
+++ b/src/syscall/zsyscall_darwin_arm64.s
@@ -1,253 +1,253 @@
 // go run mkasm.go darwin arm64
 // Code generated by the command above; DO NOT EDIT.
 #include "textflag.h"
-TEXT ·libc_getfsstat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getfsstat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getfsstat(SB)
-TEXT ·libc_setattrlist_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setattrlist_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setattrlist(SB)
-TEXT ·libc_fdopendir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fdopendir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fdopendir(SB)
-TEXT ·libc_sendfile_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sendfile_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_sendfile(SB)
-TEXT ·libc_getgroups_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getgroups_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getgroups(SB)
-TEXT ·libc_setgroups_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setgroups_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setgroups(SB)
-TEXT ·libc_wait4_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_wait4_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_wait4(SB)
-TEXT ·libc_accept_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_accept_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_accept(SB)
-TEXT ·libc_bind_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_bind_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_bind(SB)
-TEXT ·libc_connect_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_connect_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_connect(SB)
-TEXT ·libc_socket_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_socket_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_socket(SB)
-TEXT ·libc_getsockopt_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getsockopt_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getsockopt(SB)
-TEXT ·libc_setsockopt_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setsockopt_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setsockopt(SB)
-TEXT ·libc_getpeername_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpeername_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getpeername(SB)
-TEXT ·libc_getsockname_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getsockname_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getsockname(SB)
-TEXT ·libc_shutdown_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_shutdown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_shutdown(SB)
-TEXT ·libc_socketpair_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_socketpair_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_socketpair(SB)
-TEXT ·libc_recvfrom_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_recvfrom_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_recvfrom(SB)
-TEXT ·libc_sendto_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sendto_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_sendto(SB)
-TEXT ·libc_recvmsg_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_recvmsg_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_recvmsg(SB)
-TEXT ·libc_sendmsg_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sendmsg_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_sendmsg(SB)
-TEXT ·libc_kevent_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_kevent_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_kevent(SB)
-TEXT ·libc_utimes_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_utimes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_utimes(SB)
-TEXT ·libc_futimes_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_futimes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_futimes(SB)
-TEXT ·libc_fcntl_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fcntl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fcntl(SB)
-TEXT ·libc_pipe_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_pipe_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_pipe(SB)
-TEXT ·libc_kill_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_kill_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_kill(SB)
-TEXT ·libc_access_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_access_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_access(SB)
-TEXT ·libc_adjtime_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_adjtime_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_adjtime(SB)
-TEXT ·libc_chdir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_chdir(SB)
-TEXT ·libc_chflags_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chflags_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_chflags(SB)
-TEXT ·libc_chmod_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chmod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_chmod(SB)
-TEXT ·libc_chown_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_chown(SB)
-TEXT ·libc_chroot_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chroot_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_chroot(SB)
-TEXT ·libc_close_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_close_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_close(SB)
-TEXT ·libc_closedir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_closedir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_closedir(SB)
-TEXT ·libc_dup_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_dup_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_dup(SB)
-TEXT ·libc_dup2_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_dup2_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_dup2(SB)
-TEXT ·libc_exchangedata_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_exchangedata_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_exchangedata(SB)
-TEXT ·libc_fchdir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fchdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fchdir(SB)
-TEXT ·libc_fchflags_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fchflags_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fchflags(SB)
-TEXT ·libc_fchmod_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fchmod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fchmod(SB)
-TEXT ·libc_fchown_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fchown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fchown(SB)
-TEXT ·libc_flock_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_flock_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_flock(SB)
-TEXT ·libc_fpathconf_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fpathconf_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fpathconf(SB)
-TEXT ·libc_fsync_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fsync_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fsync(SB)
-TEXT ·libc_ftruncate_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_ftruncate_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_ftruncate(SB)
-TEXT ·libc_getdtablesize_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getdtablesize_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getdtablesize(SB)
-TEXT ·libc_getegid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getegid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getegid(SB)
-TEXT ·libc_geteuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_geteuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_geteuid(SB)
-TEXT ·libc_getgid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getgid(SB)
-TEXT ·libc_getpgid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getpgid(SB)
-TEXT ·libc_getpgrp_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpgrp_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getpgrp(SB)
-TEXT ·libc_getpid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getpid(SB)
-TEXT ·libc_getppid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getppid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getppid(SB)
-TEXT ·libc_getpriority_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpriority_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getpriority(SB)
-TEXT ·libc_getrlimit_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getrlimit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getrlimit(SB)
-TEXT ·libc_getrusage_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getrusage_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getrusage(SB)
-TEXT ·libc_getsid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getsid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getsid(SB)
-TEXT ·libc_getuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getuid(SB)
-TEXT ·libc_issetugid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_issetugid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_issetugid(SB)
-TEXT ·libc_kqueue_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_kqueue_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_kqueue(SB)
-TEXT ·libc_lchown_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_lchown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_lchown(SB)
-TEXT ·libc_link_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_link_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_link(SB)
-TEXT ·libc_listen_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_listen_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_listen(SB)
-TEXT ·libc_mkdir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mkdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_mkdir(SB)
-TEXT ·libc_mkfifo_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mkfifo_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_mkfifo(SB)
-TEXT ·libc_mknod_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mknod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_mknod(SB)
-TEXT ·libc_mlock_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mlock_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_mlock(SB)
-TEXT ·libc_mlockall_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mlockall_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_mlockall(SB)
-TEXT ·libc_mprotect_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mprotect_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_mprotect(SB)
-TEXT ·libc_munlock_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_munlock_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_munlock(SB)
-TEXT ·libc_munlockall_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_munlockall_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_munlockall(SB)
-TEXT ·libc_open_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_open_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_open(SB)
-TEXT ·libc_pathconf_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_pathconf_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_pathconf(SB)
-TEXT ·libc_pread_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_pread_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_pread(SB)
-TEXT ·libc_pwrite_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_pwrite_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_pwrite(SB)
-TEXT ·libc_read_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_read_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_read(SB)
-TEXT ·libc_readdir_r_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_readdir_r_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_readdir_r(SB)
-TEXT ·libc_readlink_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_readlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_readlink(SB)
-TEXT ·libc_rename_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_rename_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_rename(SB)
-TEXT ·libc_revoke_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_revoke_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_revoke(SB)
-TEXT ·libc_rmdir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_rmdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_rmdir(SB)
-TEXT ·libc_lseek_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_lseek_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_lseek(SB)
-TEXT ·libc_select_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_select_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_select(SB)
-TEXT ·libc_setegid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setegid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setegid(SB)
-TEXT ·libc_seteuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_seteuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_seteuid(SB)
-TEXT ·libc_setgid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setgid(SB)
-TEXT ·libc_setlogin_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setlogin_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setlogin(SB)
-TEXT ·libc_setpgid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setpgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setpgid(SB)
-TEXT ·libc_setpriority_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setpriority_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setpriority(SB)
-TEXT ·libc_setprivexec_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setprivexec_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setprivexec(SB)
-TEXT ·libc_setregid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setregid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setregid(SB)
-TEXT ·libc_setreuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setreuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setreuid(SB)
-TEXT ·libc_setrlimit_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setrlimit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setrlimit(SB)
-TEXT ·libc_setsid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setsid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setsid(SB)
-TEXT ·libc_settimeofday_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_settimeofday_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_settimeofday(SB)
-TEXT ·libc_setuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setuid(SB)
-TEXT ·libc_symlink_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_symlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_symlink(SB)
-TEXT ·libc_sync_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sync_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_sync(SB)
-TEXT ·libc_truncate_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_truncate_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_truncate(SB)
-TEXT ·libc_umask_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_umask_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_umask(SB)
-TEXT ·libc_undelete_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_undelete_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_undelete(SB)
-TEXT ·libc_unlink_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_unlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_unlink(SB)
-TEXT ·libc_unmount_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_unmount_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_unmount(SB)
-TEXT ·libc_write_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_write_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_write(SB)
-TEXT ·libc_writev_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_writev_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_writev(SB)
-TEXT ·libc_mmap_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mmap_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_mmap(SB)
-TEXT ·libc_munmap_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_munmap_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_munmap(SB)
-TEXT ·libc_fork_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fork_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fork(SB)
-TEXT ·libc_ioctl_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_ioctl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_ioctl(SB)
-TEXT ·libc_execve_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_execve_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_execve(SB)
-TEXT ·libc_exit_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_exit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_exit(SB)
-TEXT ·libc_sysctl_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sysctl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_sysctl(SB)
-TEXT ·libc_unlinkat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_unlinkat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_unlinkat(SB)
-TEXT ·libc_openat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_openat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_openat(SB)
-TEXT ·libc_getcwd_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getcwd_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getcwd(SB)
-TEXT ·libc_fstat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fstat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fstat(SB)
-TEXT ·libc_fstatfs_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fstatfs_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fstatfs(SB)
-TEXT ·libc_gettimeofday_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_gettimeofday_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_gettimeofday(SB)
-TEXT ·libc_lstat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_lstat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_lstat(SB)
-TEXT ·libc_stat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_stat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_stat(SB)
-TEXT ·libc_statfs_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_statfs_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_statfs(SB)
-TEXT ·libc_fstatat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fstatat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fstatat(SB)
-TEXT ·libc_ptrace_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_ptrace_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_ptrace(SB)
diff --git a/src/syscall/zsyscall_openbsd_amd64.s b/src/syscall/zsyscall_openbsd_amd64.s
index e5c5dde930..8256a451f5 100644
--- a/src/syscall/zsyscall_openbsd_amd64.s
+++ b/src/syscall/zsyscall_openbsd_amd64.s
@@ -1,233 +1,233 @@
 // go run mkasm.go openbsd amd64
 // Code generated by the command above; DO NOT EDIT.
 #include "textflag.h"
-TEXT ·libc_getgroups_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getgroups_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getgroups(SB)
-TEXT ·libc_setgroups_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setgroups_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setgroups(SB)
-TEXT ·libc_wait4_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_wait4_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_wait4(SB)
-TEXT ·libc_accept_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_accept_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_accept(SB)
-TEXT ·libc_bind_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_bind_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_bind(SB)
-TEXT ·libc_connect_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_connect_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_connect(SB)
-TEXT ·libc_socket_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_socket_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_socket(SB)
-TEXT ·libc_getsockopt_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getsockopt_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getsockopt(SB)
-TEXT ·libc_setsockopt_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setsockopt_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setsockopt(SB)
-TEXT ·libc_getpeername_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpeername_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getpeername(SB)
-TEXT ·libc_getsockname_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getsockname_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getsockname(SB)
-TEXT ·libc_shutdown_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_shutdown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_shutdown(SB)
-TEXT ·libc_socketpair_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_socketpair_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_socketpair(SB)
-TEXT ·libc_recvfrom_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_recvfrom_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_recvfrom(SB)
-TEXT ·libc_sendto_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sendto_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_sendto(SB)
-TEXT ·libc_recvmsg_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_recvmsg_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_recvmsg(SB)
-TEXT ·libc_sendmsg_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sendmsg_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_sendmsg(SB)
-TEXT ·libc_kevent_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_kevent_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_kevent(SB)
-TEXT ·libc_utimes_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_utimes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_utimes(SB)
-TEXT ·libc_futimes_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_futimes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_futimes(SB)
-TEXT ·libc_fcntl_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fcntl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fcntl(SB)
-TEXT ·libc_pipe2_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_pipe2_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_pipe2(SB)
-TEXT ·libc_accept4_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_accept4_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_accept4(SB)
-TEXT ·libc_getdents_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getdents_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getdents(SB)
-TEXT ·libc_access_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_access_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_access(SB)
-TEXT ·libc_adjtime_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_adjtime_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_adjtime(SB)
-TEXT ·libc_chdir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_chdir(SB)
-TEXT ·libc_chflags_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chflags_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_chflags(SB)
-TEXT ·libc_chmod_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chmod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_chmod(SB)
-TEXT ·libc_chown_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_chown(SB)
-TEXT ·libc_chroot_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chroot_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_chroot(SB)
-TEXT ·libc_close_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_close_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_close(SB)
-TEXT ·libc_dup_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_dup_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_dup(SB)
-TEXT ·libc_dup2_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_dup2_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_dup2(SB)
-TEXT ·libc_fchdir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fchdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fchdir(SB)
-TEXT ·libc_fchflags_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fchflags_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fchflags(SB)
-TEXT ·libc_fchmod_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fchmod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fchmod(SB)
-TEXT ·libc_fchown_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fchown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fchown(SB)
-TEXT ·libc_flock_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_flock_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_flock(SB)
-TEXT ·libc_fpathconf_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fpathconf_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fpathconf(SB)
-TEXT ·libc_fstat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fstat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fstat(SB)
-TEXT ·libc_fstatfs_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fstatfs_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fstatfs(SB)
-TEXT ·libc_fsync_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fsync_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fsync(SB)
-TEXT ·libc_ftruncate_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_ftruncate_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_ftruncate(SB)
-TEXT ·libc_getegid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getegid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getegid(SB)
-TEXT ·libc_geteuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_geteuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_geteuid(SB)
-TEXT ·libc_getgid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getgid(SB)
-TEXT ·libc_getpgid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getpgid(SB)
-TEXT ·libc_getpgrp_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpgrp_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getpgrp(SB)
-TEXT ·libc_getpid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getpid(SB)
-TEXT ·libc_getppid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getppid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getppid(SB)
-TEXT ·libc_getpriority_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpriority_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getpriority(SB)
-TEXT ·libc_getrlimit_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getrlimit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getrlimit(SB)
-TEXT ·libc_getrusage_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getrusage_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getrusage(SB)
-TEXT ·libc_getsid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getsid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getsid(SB)
-TEXT ·libc_gettimeofday_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_gettimeofday_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_gettimeofday(SB)
-TEXT ·libc_getuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getuid(SB)
-TEXT ·libc_issetugid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_issetugid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_issetugid(SB)
-TEXT ·libc_kill_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_kill_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_kill(SB)
-TEXT ·libc_kqueue_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_kqueue_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_kqueue(SB)
-TEXT ·libc_lchown_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_lchown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_lchown(SB)
-TEXT ·libc_link_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_link_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_link(SB)
-TEXT ·libc_listen_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_listen_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_listen(SB)
-TEXT ·libc_lstat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_lstat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_lstat(SB)
-TEXT ·libc_mkdir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mkdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_mkdir(SB)
-TEXT ·libc_mkfifo_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mkfifo_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_mkfifo(SB)
-TEXT ·libc_mknod_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mknod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_mknod(SB)
-TEXT ·libc_nanosleep_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_nanosleep_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_nanosleep(SB)
-TEXT ·libc_open_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_open_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_open(SB)
-TEXT ·libc_pathconf_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_pathconf_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_pathconf(SB)
-TEXT ·libc_pread_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_pread_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_pread(SB)
-TEXT ·libc_pwrite_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_pwrite_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_pwrite(SB)
-TEXT ·libc_read_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_read_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_read(SB)
-TEXT ·libc_readlink_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_readlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_readlink(SB)
-TEXT ·libc_rename_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_rename_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_rename(SB)
-TEXT ·libc_revoke_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_revoke_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_revoke(SB)
-TEXT ·libc_rmdir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_rmdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_rmdir(SB)
-TEXT ·libc_select_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_select_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_select(SB)
-TEXT ·libc_setegid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setegid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setegid(SB)
-TEXT ·libc_seteuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_seteuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_seteuid(SB)
-TEXT ·libc_setgid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setgid(SB)
-TEXT ·libc_setlogin_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setlogin_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setlogin(SB)
-TEXT ·libc_setpgid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setpgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setpgid(SB)
-TEXT ·libc_setpriority_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setpriority_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setpriority(SB)
-TEXT ·libc_setregid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setregid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setregid(SB)
-TEXT ·libc_setreuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setreuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setreuid(SB)
-TEXT ·libc_setrlimit_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setrlimit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setrlimit(SB)
-TEXT ·libc_setsid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setsid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setsid(SB)
-TEXT ·libc_settimeofday_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_settimeofday_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_settimeofday(SB)
-TEXT ·libc_setuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setuid(SB)
-TEXT ·libc_stat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_stat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_stat(SB)
-TEXT ·libc_statfs_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_statfs_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_statfs(SB)
-TEXT ·libc_symlink_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_symlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_symlink(SB)
-TEXT ·libc_sync_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sync_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_sync(SB)
-TEXT ·libc_truncate_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_truncate_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_truncate(SB)
-TEXT ·libc_umask_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_umask_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_umask(SB)
-TEXT ·libc_unlink_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_unlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_unlink(SB)
-TEXT ·libc_unmount_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_unmount_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_unmount(SB)
-TEXT ·libc_write_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_write_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_write(SB)
-TEXT ·libc_mmap_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mmap_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_mmap(SB)
-TEXT ·libc_munmap_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_munmap_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_munmap(SB)
-TEXT ·libc_utimensat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_utimensat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_utimensat(SB)
-TEXT ·libc_syscall_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_syscall_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_syscall(SB)
-TEXT ·libc_lseek_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_lseek_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_lseek(SB)
-TEXT ·libc_getcwd_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getcwd_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getcwd(SB)
-TEXT ·libc_sysctl_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sysctl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_sysctl(SB)
-TEXT ·libc_fork_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fork_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fork(SB)
-TEXT ·libc_ioctl_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_ioctl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_ioctl(SB)
-TEXT ·libc_execve_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_execve_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_execve(SB)
-TEXT ·libc_exit_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_exit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_exit(SB)
-TEXT ·libc_ptrace_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_ptrace_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_ptrace(SB)
-TEXT ·libc_getentropy_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getentropy_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getentropy(SB)
-TEXT ·libc_fstatat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fstatat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fstatat(SB)
-TEXT ·libc_unlinkat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_unlinkat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_unlinkat(SB)
-TEXT ·libc_openat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_openat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_openat(SB)
diff --git a/src/syscall/zsyscall_openbsd_arm64.s b/src/syscall/zsyscall_openbsd_arm64.s
index 37778b1db5..f6e0a8da94 100644
--- a/src/syscall/zsyscall_openbsd_arm64.s
+++ b/src/syscall/zsyscall_openbsd_arm64.s
@@ -1,233 +1,233 @@
 // go run mkasm.go openbsd arm64
 // Code generated by the command above; DO NOT EDIT.
 #include "textflag.h"
-TEXT ·libc_getgroups_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getgroups_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getgroups(SB)
-TEXT ·libc_setgroups_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setgroups_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setgroups(SB)
-TEXT ·libc_wait4_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_wait4_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_wait4(SB)
-TEXT ·libc_accept_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_accept_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_accept(SB)
-TEXT ·libc_bind_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_bind_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_bind(SB)
-TEXT ·libc_connect_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_connect_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_connect(SB)
-TEXT ·libc_socket_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_socket_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_socket(SB)
-TEXT ·libc_getsockopt_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getsockopt_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getsockopt(SB)
-TEXT ·libc_setsockopt_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setsockopt_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setsockopt(SB)
-TEXT ·libc_getpeername_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpeername_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getpeername(SB)
-TEXT ·libc_getsockname_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getsockname_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getsockname(SB)
-TEXT ·libc_shutdown_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_shutdown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_shutdown(SB)
-TEXT ·libc_socketpair_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_socketpair_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_socketpair(SB)
-TEXT ·libc_recvfrom_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_recvfrom_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_recvfrom(SB)
-TEXT ·libc_sendto_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sendto_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_sendto(SB)
-TEXT ·libc_recvmsg_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_recvmsg_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_recvmsg(SB)
-TEXT ·libc_sendmsg_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sendmsg_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_sendmsg(SB)
-TEXT ·libc_kevent_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_kevent_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_kevent(SB)
-TEXT ·libc_utimes_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_utimes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_utimes(SB)
-TEXT ·libc_futimes_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_futimes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_futimes(SB)
-TEXT ·libc_fcntl_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fcntl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fcntl(SB)
-TEXT ·libc_pipe2_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_pipe2_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_pipe2(SB)
-TEXT ·libc_accept4_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_accept4_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_accept4(SB)
-TEXT ·libc_getdents_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getdents_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getdents(SB)
-TEXT ·libc_access_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_access_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_access(SB)
-TEXT ·libc_adjtime_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_adjtime_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_adjtime(SB)
-TEXT ·libc_chdir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_chdir(SB)
-TEXT ·libc_chflags_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chflags_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_chflags(SB)
-TEXT ·libc_chmod_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chmod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_chmod(SB)
-TEXT ·libc_chown_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_chown(SB)
-TEXT ·libc_chroot_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_chroot_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_chroot(SB)
-TEXT ·libc_close_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_close_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_close(SB)
-TEXT ·libc_dup_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_dup_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_dup(SB)
-TEXT ·libc_dup2_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_dup2_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_dup2(SB)
-TEXT ·libc_fchdir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fchdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fchdir(SB)
-TEXT ·libc_fchflags_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fchflags_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fchflags(SB)
-TEXT ·libc_fchmod_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fchmod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fchmod(SB)
-TEXT ·libc_fchown_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fchown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fchown(SB)
-TEXT ·libc_flock_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_flock_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_flock(SB)
-TEXT ·libc_fpathconf_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fpathconf_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fpathconf(SB)
-TEXT ·libc_fstat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fstat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fstat(SB)
-TEXT ·libc_fstatfs_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fstatfs_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fstatfs(SB)
-TEXT ·libc_fsync_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fsync_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fsync(SB)
-TEXT ·libc_ftruncate_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_ftruncate_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_ftruncate(SB)
-TEXT ·libc_getegid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getegid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getegid(SB)
-TEXT ·libc_geteuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_geteuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_geteuid(SB)
-TEXT ·libc_getgid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getgid(SB)
-TEXT ·libc_getpgid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getpgid(SB)
-TEXT ·libc_getpgrp_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpgrp_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getpgrp(SB)
-TEXT ·libc_getpid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getpid(SB)
-TEXT ·libc_getppid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getppid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getppid(SB)
-TEXT ·libc_getpriority_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getpriority_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getpriority(SB)
-TEXT ·libc_getrlimit_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getrlimit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getrlimit(SB)
-TEXT ·libc_getrusage_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getrusage_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getrusage(SB)
-TEXT ·libc_getsid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getsid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getsid(SB)
-TEXT ·libc_gettimeofday_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_gettimeofday_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_gettimeofday(SB)
-TEXT ·libc_getuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getuid(SB)
-TEXT ·libc_issetugid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_issetugid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_issetugid(SB)
-TEXT ·libc_kill_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_kill_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_kill(SB)
-TEXT ·libc_kqueue_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_kqueue_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_kqueue(SB)
-TEXT ·libc_lchown_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_lchown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_lchown(SB)
-TEXT ·libc_link_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_link_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_link(SB)
-TEXT ·libc_listen_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_listen_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_listen(SB)
-TEXT ·libc_lstat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_lstat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_lstat(SB)
-TEXT ·libc_mkdir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mkdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_mkdir(SB)
-TEXT ·libc_mkfifo_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mkfifo_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_mkfifo(SB)
-TEXT ·libc_mknod_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mknod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_mknod(SB)
-TEXT ·libc_nanosleep_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_nanosleep_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_nanosleep(SB)
-TEXT ·libc_open_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_open_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_open(SB)
-TEXT ·libc_pathconf_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_pathconf_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_pathconf(SB)
-TEXT ·libc_pread_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_pread_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_pread(SB)
-TEXT ·libc_pwrite_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_pwrite_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_pwrite(SB)
-TEXT ·libc_read_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_read_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_read(SB)
-TEXT ·libc_readlink_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_readlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_readlink(SB)
-TEXT ·libc_rename_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_rename_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_rename(SB)
-TEXT ·libc_revoke_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_revoke_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_revoke(SB)
-TEXT ·libc_rmdir_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_rmdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_rmdir(SB)
-TEXT ·libc_select_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_select_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_select(SB)
-TEXT ·libc_setegid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setegid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setegid(SB)
-TEXT ·libc_seteuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_seteuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_seteuid(SB)
-TEXT ·libc_setgid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setgid(SB)
-TEXT ·libc_setlogin_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setlogin_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setlogin(SB)
-TEXT ·libc_setpgid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setpgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setpgid(SB)
-TEXT ·libc_setpriority_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setpriority_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setpriority(SB)
-TEXT ·libc_setregid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setregid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setregid(SB)
-TEXT ·libc_setreuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setreuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setreuid(SB)
-TEXT ·libc_setrlimit_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setrlimit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setrlimit(SB)
-TEXT ·libc_setsid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setsid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setsid(SB)
-TEXT ·libc_settimeofday_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_settimeofday_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_settimeofday(SB)
-TEXT ·libc_setuid_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_setuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_setuid(SB)
-TEXT ·libc_stat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_stat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_stat(SB)
-TEXT ·libc_statfs_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_statfs_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_statfs(SB)
-TEXT ·libc_symlink_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_symlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_symlink(SB)
-TEXT ·libc_sync_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sync_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_sync(SB)
-TEXT ·libc_truncate_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_truncate_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_truncate(SB)
-TEXT ·libc_umask_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_umask_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_umask(SB)
-TEXT ·libc_unlink_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_unlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_unlink(SB)
-TEXT ·libc_unmount_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_unmount_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_unmount(SB)
-TEXT ·libc_write_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_write_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_write(SB)
-TEXT ·libc_mmap_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_mmap_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_mmap(SB)
-TEXT ·libc_munmap_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_munmap_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_munmap(SB)
-TEXT ·libc_utimensat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_utimensat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_utimensat(SB)
-TEXT ·libc_syscall_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_syscall_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_syscall(SB)
-TEXT ·libc_lseek_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_lseek_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_lseek(SB)
-TEXT ·libc_getcwd_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getcwd_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getcwd(SB)
-TEXT ·libc_sysctl_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_sysctl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_sysctl(SB)
-TEXT ·libc_fork_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fork_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fork(SB)
-TEXT ·libc_ioctl_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_ioctl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_ioctl(SB)
-TEXT ·libc_execve_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_execve_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_execve(SB)
-TEXT ·libc_exit_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_exit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_exit(SB)
-TEXT ·libc_ptrace_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_ptrace_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_ptrace(SB)
-TEXT ·libc_getentropy_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_getentropy_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_getentropy(SB)
-TEXT ·libc_fstatat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_fstatat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_fstatat(SB)
-TEXT ·libc_unlinkat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_unlinkat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_unlinkat(SB)
-TEXT ·libc_openat_trampoline(SB),NOSPLIT,$0-0
+TEXT ·libc_openat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	libc_openat(SB)
-- 
GitLab


From 401d7e5a242f1007c2637a25111a6fa985728c08 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Fri, 29 Jan 2021 13:46:34 -0500
Subject: [PATCH 0592/2400] [dev.regabi] cmd/compile: reserve X15 as zero
 register on AMD64

In ABIInternal, reserve X15 as constant zero, and use it to zero
memory. (Maybe there can be more use of it?)

The register is zeroed when transition to ABIInternal from ABI0.

Caveat: using X15 generates longer instructions than using X0.
Maybe we want to use X0?

Change-Id: I12d5ee92a01fc0b59dad4e5ab023ac71bc2a8b7d
Reviewed-on: https://go-review.googlesource.com/c/go/+/288093
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/amd64/ggen.go       |   4 +-
 src/cmd/compile/internal/amd64/ssa.go        |  43 ++-
 src/cmd/compile/internal/ssa/config.go       |   1 +
 src/cmd/compile/internal/ssa/gen/AMD64.rules |  26 +-
 src/cmd/compile/internal/ssa/gen/AMD64Ops.go |  41 +--
 src/cmd/compile/internal/ssa/op.go           |   4 +-
 src/cmd/compile/internal/ssa/opGen.go        | 281 ++++++++++---------
 src/cmd/compile/internal/ssa/rewriteAMD64.go |  96 +++----
 src/cmd/compile/internal/ssagen/abi.go       |  15 +-
 src/cmd/compile/internal/ssagen/ssa.go       |   5 +-
 src/runtime/duff_amd64.s                     | 128 ++++-----
 src/runtime/mkduff.go                        |  14 +-
 test/codegen/structs.go                      |   4 +-
 13 files changed, 347 insertions(+), 315 deletions(-)

diff --git a/src/cmd/compile/internal/amd64/ggen.go b/src/cmd/compile/internal/amd64/ggen.go
index dacdb07a38..aefdb14a69 100644
--- a/src/cmd/compile/internal/amd64/ggen.go
+++ b/src/cmd/compile/internal/amd64/ggen.go
@@ -22,8 +22,8 @@ var isPlan9 = objabi.GOOS == "plan9"
 const (
 	dzBlocks    = 16 // number of MOV/ADD blocks
 	dzBlockLen  = 4  // number of clears per block
-	dzBlockSize = 19 // size of instructions in a single block
-	dzMovSize   = 4  // size of single MOV instruction w/ offset
+	dzBlockSize = 23 // size of instructions in a single block
+	dzMovSize   = 5  // size of single MOV instruction w/ offset
 	dzLeaqSize  = 4  // size of single LEAQ instruction
 	dzClearStep = 16 // number of bytes cleared by each MOV instruction
 
diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index da355c49d1..d9c97183fd 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -813,6 +813,20 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
 		ssagen.AddAux2(&p.To, v, sc.Off())
+	case ssa.OpAMD64MOVOstorezero:
+		if s.ABI != obj.ABIInternal {
+			v.Fatalf("MOVOstorezero can be only used in ABIInternal functions")
+		}
+		if !base.Flag.ABIWrap {
+			// zeroing X15 manually if wrappers are not used
+			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
+		}
+		p := s.Prog(v.Op.Asm())
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = x86.REG_X15
+		p.To.Type = obj.TYPE_MEM
+		p.To.Reg = v.Args[0].Reg()
+		ssagen.AddAux(&p.To, v)
 	case ssa.OpAMD64MOVQstoreconstidx1, ssa.OpAMD64MOVQstoreconstidx8, ssa.OpAMD64MOVLstoreconstidx1, ssa.OpAMD64MOVLstoreconstidx4, ssa.OpAMD64MOVWstoreconstidx1, ssa.OpAMD64MOVWstoreconstidx2, ssa.OpAMD64MOVBstoreconstidx1,
 		ssa.OpAMD64ADDLconstmodifyidx1, ssa.OpAMD64ADDLconstmodifyidx4, ssa.OpAMD64ADDLconstmodifyidx8, ssa.OpAMD64ADDQconstmodifyidx1, ssa.OpAMD64ADDQconstmodifyidx8,
 		ssa.OpAMD64ANDLconstmodifyidx1, ssa.OpAMD64ANDLconstmodifyidx4, ssa.OpAMD64ANDLconstmodifyidx8, ssa.OpAMD64ANDQconstmodifyidx1, ssa.OpAMD64ANDQconstmodifyidx8,
@@ -900,6 +914,13 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 			v.Fatalf("input[0] and output not in same register %s", v.LongString())
 		}
 	case ssa.OpAMD64DUFFZERO:
+		if s.ABI != obj.ABIInternal {
+			v.Fatalf("MOVOconst can be only used in ABIInternal functions")
+		}
+		if !base.Flag.ABIWrap {
+			// zeroing X15 manually if wrappers are not used
+			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
+		}
 		off := duffStart(v.AuxInt)
 		adj := duffAdj(v.AuxInt)
 		var p *obj.Prog
@@ -915,12 +936,6 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Type = obj.TYPE_ADDR
 		p.To.Sym = ir.Syms.Duffzero
 		p.To.Offset = off
-	case ssa.OpAMD64MOVOconst:
-		if v.AuxInt != 0 {
-			v.Fatalf("MOVOconst can only do constant=0")
-		}
-		r := v.Reg()
-		opregreg(s, x86.AXORPS, r, r)
 	case ssa.OpAMD64DUFFCOPY:
 		p := s.Prog(obj.ADUFFCOPY)
 		p.To.Type = obj.TYPE_ADDR
@@ -1000,7 +1015,17 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 			q.To.Type = obj.TYPE_REG
 			q.To.Reg = r
 		}
-	case ssa.OpAMD64CALLstatic, ssa.OpAMD64CALLclosure, ssa.OpAMD64CALLinter:
+	case ssa.OpAMD64CALLstatic:
+		if s.ABI == obj.ABI0 && v.Aux.(*ssa.AuxCall).Fn.ABI() == obj.ABIInternal {
+			// zeroing X15 when entering ABIInternal from ABI0
+			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
+		}
+		s.Call(v)
+		if s.ABI == obj.ABIInternal && v.Aux.(*ssa.AuxCall).Fn.ABI() == obj.ABI0 {
+			// zeroing X15 when entering ABIInternal from ABI0
+			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
+		}
+	case ssa.OpAMD64CALLclosure, ssa.OpAMD64CALLinter:
 		s.Call(v)
 
 	case ssa.OpAMD64LoweredGetCallerPC:
@@ -1297,6 +1322,10 @@ func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
 	case ssa.BlockRet:
 		s.Prog(obj.ARET)
 	case ssa.BlockRetJmp:
+		if s.ABI == obj.ABI0 && b.Aux.(*obj.LSym).ABI() == obj.ABIInternal {
+			// zeroing X15 when entering ABIInternal from ABI0
+			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
+		}
 		p := s.Prog(obj.ARET)
 		p.To.Type = obj.TYPE_MEM
 		p.To.Name = obj.NAME_EXTERN
diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go
index e952c73d9b..32cfd7e61e 100644
--- a/src/cmd/compile/internal/ssa/config.go
+++ b/src/cmd/compile/internal/ssa/config.go
@@ -194,6 +194,7 @@ func NewConfig(arch string, types Types, ctxt *obj.Link, optimize bool) *Config
 		c.registers = registersAMD64[:]
 		c.gpRegMask = gpRegMaskAMD64
 		c.fpRegMask = fpRegMaskAMD64
+		c.specialRegMask = specialRegMaskAMD64
 		c.FPReg = framepointerRegAMD64
 		c.LinkReg = linkRegAMD64
 		c.hasGReg = false
diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules
index 7d46266411..706336289e 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64.rules
+++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules
@@ -361,31 +361,31 @@
 // Adjust zeros to be a multiple of 16 bytes.
 (Zero [s] destptr mem) && s%16 != 0 && s > 16 && s%16 > 8 && config.useSSE =>
 	(Zero [s-s%16] (OffPtr <destptr.Type> destptr [s%16])
-		(MOVOstore destptr (MOVOconst [0]) mem))
+		(MOVOstorezero destptr mem))
 
 (Zero [s] destptr mem) && s%16 != 0 && s > 16 && s%16 <= 8 && config.useSSE =>
 	(Zero [s-s%16] (OffPtr <destptr.Type> destptr [s%16])
 		(MOVQstoreconst [makeValAndOff32(0,0)] destptr mem))
 
 (Zero [16] destptr mem) && config.useSSE =>
-	(MOVOstore destptr (MOVOconst [0]) mem)
+	(MOVOstorezero destptr mem)
 (Zero [32] destptr mem) && config.useSSE =>
-	(MOVOstore (OffPtr <destptr.Type> destptr [16]) (MOVOconst [0])
-		(MOVOstore destptr (MOVOconst [0]) mem))
+	(MOVOstorezero (OffPtr <destptr.Type> destptr [16])
+		(MOVOstorezero destptr mem))
 (Zero [48] destptr mem) && config.useSSE =>
-	(MOVOstore (OffPtr <destptr.Type> destptr [32]) (MOVOconst [0])
-		(MOVOstore (OffPtr <destptr.Type> destptr [16]) (MOVOconst [0])
-			(MOVOstore destptr (MOVOconst [0]) mem)))
+	(MOVOstorezero (OffPtr <destptr.Type> destptr [32])
+		(MOVOstorezero (OffPtr <destptr.Type> destptr [16])
+			(MOVOstorezero destptr mem)))
 (Zero [64] destptr mem) && config.useSSE =>
-	(MOVOstore (OffPtr <destptr.Type> destptr [48]) (MOVOconst [0])
-		(MOVOstore (OffPtr <destptr.Type> destptr [32]) (MOVOconst [0])
-			(MOVOstore (OffPtr <destptr.Type> destptr [16]) (MOVOconst [0])
-				(MOVOstore destptr (MOVOconst [0]) mem))))
+	(MOVOstorezero (OffPtr <destptr.Type> destptr [48])
+		(MOVOstorezero (OffPtr <destptr.Type> destptr [32])
+			(MOVOstorezero (OffPtr <destptr.Type> destptr [16])
+				(MOVOstorezero destptr mem))))
 
 // Medium zeroing uses a duff device.
 (Zero [s] destptr mem)
 	&& s > 64 && s <= 1024 && s%16 == 0 && !config.noDuffDevice =>
-	(DUFFZERO [s] destptr (MOVOconst [0]) mem)
+	(DUFFZERO [s] destptr mem)
 
 // Large zeroing uses REP STOSQ.
 (Zero [s] destptr mem)
@@ -1900,7 +1900,7 @@
   && c.Val() == 0
   && c2.Val() == 0
   && clobber(x)
-  => (MOVOstore [c2.Off32()] {s} p (MOVOconst [0]) mem)
+  => (MOVOstorezero [c2.Off32()] {s} p mem)
 
 // Combine stores into larger (unaligned) stores. Little endian.
 (MOVBstore [i] {s} p (SHR(W|L|Q)const [8] w) x:(MOVBstore [i-1] {s} p w mem))
diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
index de5372670b..0a411bbdca 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
+++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
@@ -61,7 +61,7 @@ var regNamesAMD64 = []string{
 	"X12",
 	"X13",
 	"X14",
-	"X15",
+	"X15", // constant 0 in ABIInternal
 
 	// If you add registers, update asyncPreempt in runtime
 
@@ -97,7 +97,8 @@ func init() {
 		dx         = buildReg("DX")
 		bx         = buildReg("BX")
 		gp         = buildReg("AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15")
-		fp         = buildReg("X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15")
+		fp         = buildReg("X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14")
+		x15        = buildReg("X15")
 		gpsp       = gp | buildReg("SP")
 		gpspsb     = gpsp | buildReg("SB")
 		callerSave = gp | fp
@@ -684,19 +685,20 @@ func init() {
 		// Note: LEAx{1,2,4,8} must not have OpSB as either argument.
 
 		// auxint+aux == add auxint and the offset of the symbol in aux (if any) to the effective address
-		{name: "MOVBload", argLength: 2, reg: gpload, asm: "MOVBLZX", aux: "SymOff", typ: "UInt8", faultOnNilArg0: true, symEffect: "Read"},  // load byte from arg0+auxint+aux. arg1=mem.  Zero extend.
-		{name: "MOVBQSXload", argLength: 2, reg: gpload, asm: "MOVBQSX", aux: "SymOff", faultOnNilArg0: true, symEffect: "Read"},             // ditto, sign extend to int64
-		{name: "MOVWload", argLength: 2, reg: gpload, asm: "MOVWLZX", aux: "SymOff", typ: "UInt16", faultOnNilArg0: true, symEffect: "Read"}, // load 2 bytes from arg0+auxint+aux. arg1=mem.  Zero extend.
-		{name: "MOVWQSXload", argLength: 2, reg: gpload, asm: "MOVWQSX", aux: "SymOff", faultOnNilArg0: true, symEffect: "Read"},             // ditto, sign extend to int64
-		{name: "MOVLload", argLength: 2, reg: gpload, asm: "MOVL", aux: "SymOff", typ: "UInt32", faultOnNilArg0: true, symEffect: "Read"},    // load 4 bytes from arg0+auxint+aux. arg1=mem.  Zero extend.
-		{name: "MOVLQSXload", argLength: 2, reg: gpload, asm: "MOVLQSX", aux: "SymOff", faultOnNilArg0: true, symEffect: "Read"},             // ditto, sign extend to int64
-		{name: "MOVQload", argLength: 2, reg: gpload, asm: "MOVQ", aux: "SymOff", typ: "UInt64", faultOnNilArg0: true, symEffect: "Read"},    // load 8 bytes from arg0+auxint+aux. arg1=mem
-		{name: "MOVBstore", argLength: 3, reg: gpstore, asm: "MOVB", aux: "SymOff", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"},    // store byte in arg1 to arg0+auxint+aux. arg2=mem
-		{name: "MOVWstore", argLength: 3, reg: gpstore, asm: "MOVW", aux: "SymOff", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"},    // store 2 bytes in arg1 to arg0+auxint+aux. arg2=mem
-		{name: "MOVLstore", argLength: 3, reg: gpstore, asm: "MOVL", aux: "SymOff", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"},    // store 4 bytes in arg1 to arg0+auxint+aux. arg2=mem
-		{name: "MOVQstore", argLength: 3, reg: gpstore, asm: "MOVQ", aux: "SymOff", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"},    // store 8 bytes in arg1 to arg0+auxint+aux. arg2=mem
-		{name: "MOVOload", argLength: 2, reg: fpload, asm: "MOVUPS", aux: "SymOff", typ: "Int128", faultOnNilArg0: true, symEffect: "Read"},  // load 16 bytes from arg0+auxint+aux. arg1=mem
-		{name: "MOVOstore", argLength: 3, reg: fpstore, asm: "MOVUPS", aux: "SymOff", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"},  // store 16 bytes in arg1 to arg0+auxint+aux. arg2=mem
+		{name: "MOVBload", argLength: 2, reg: gpload, asm: "MOVBLZX", aux: "SymOff", typ: "UInt8", faultOnNilArg0: true, symEffect: "Read"},                                   // load byte from arg0+auxint+aux. arg1=mem.  Zero extend.
+		{name: "MOVBQSXload", argLength: 2, reg: gpload, asm: "MOVBQSX", aux: "SymOff", faultOnNilArg0: true, symEffect: "Read"},                                              // ditto, sign extend to int64
+		{name: "MOVWload", argLength: 2, reg: gpload, asm: "MOVWLZX", aux: "SymOff", typ: "UInt16", faultOnNilArg0: true, symEffect: "Read"},                                  // load 2 bytes from arg0+auxint+aux. arg1=mem.  Zero extend.
+		{name: "MOVWQSXload", argLength: 2, reg: gpload, asm: "MOVWQSX", aux: "SymOff", faultOnNilArg0: true, symEffect: "Read"},                                              // ditto, sign extend to int64
+		{name: "MOVLload", argLength: 2, reg: gpload, asm: "MOVL", aux: "SymOff", typ: "UInt32", faultOnNilArg0: true, symEffect: "Read"},                                     // load 4 bytes from arg0+auxint+aux. arg1=mem.  Zero extend.
+		{name: "MOVLQSXload", argLength: 2, reg: gpload, asm: "MOVLQSX", aux: "SymOff", faultOnNilArg0: true, symEffect: "Read"},                                              // ditto, sign extend to int64
+		{name: "MOVQload", argLength: 2, reg: gpload, asm: "MOVQ", aux: "SymOff", typ: "UInt64", faultOnNilArg0: true, symEffect: "Read"},                                     // load 8 bytes from arg0+auxint+aux. arg1=mem
+		{name: "MOVBstore", argLength: 3, reg: gpstore, asm: "MOVB", aux: "SymOff", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"},                                     // store byte in arg1 to arg0+auxint+aux. arg2=mem
+		{name: "MOVWstore", argLength: 3, reg: gpstore, asm: "MOVW", aux: "SymOff", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"},                                     // store 2 bytes in arg1 to arg0+auxint+aux. arg2=mem
+		{name: "MOVLstore", argLength: 3, reg: gpstore, asm: "MOVL", aux: "SymOff", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"},                                     // store 4 bytes in arg1 to arg0+auxint+aux. arg2=mem
+		{name: "MOVQstore", argLength: 3, reg: gpstore, asm: "MOVQ", aux: "SymOff", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"},                                     // store 8 bytes in arg1 to arg0+auxint+aux. arg2=mem
+		{name: "MOVOload", argLength: 2, reg: fpload, asm: "MOVUPS", aux: "SymOff", typ: "Int128", faultOnNilArg0: true, symEffect: "Read"},                                   // load 16 bytes from arg0+auxint+aux. arg1=mem
+		{name: "MOVOstore", argLength: 3, reg: fpstore, asm: "MOVUPS", aux: "SymOff", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"},                                   // store 16 bytes in arg1 to arg0+auxint+aux. arg2=mem
+		{name: "MOVOstorezero", argLength: 2, reg: regInfo{inputs: []regMask{gpspsb, 0}}, asm: "MOVUPS", aux: "SymOff", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"}, // store 16 bytes of zero to arg0+auxint+aux. arg1=mem
 
 		// indexed loads/stores
 		{name: "MOVBloadidx1", argLength: 3, reg: gploadidx, commutative: true, asm: "MOVBLZX", scale: 1, aux: "SymOff", typ: "UInt8", symEffect: "Read"},  // load a byte from arg0+arg1+auxint+aux. arg2=mem
@@ -735,22 +737,20 @@ func init() {
 		{name: "MOVQstoreconstidx8", argLength: 3, reg: gpstoreconstidx, asm: "MOVQ", scale: 8, aux: "SymValAndOff", typ: "Mem", symEffect: "Write"},                    // store 8 bytes of ... 8*arg1 ...
 
 		// arg0 = pointer to start of memory to zero
-		// arg1 = value to store (will always be zero)
-		// arg2 = mem
+		// arg1 = mem
 		// auxint = # of bytes to zero
 		// returns mem
 		{
 			name:      "DUFFZERO",
 			aux:       "Int64",
-			argLength: 3,
+			argLength: 2,
 			reg: regInfo{
-				inputs:   []regMask{buildReg("DI"), buildReg("X0")},
+				inputs:   []regMask{buildReg("DI")},
 				clobbers: buildReg("DI"),
 			},
 			faultOnNilArg0: true,
 			unsafePoint:    true, // FP maintenance around DUFFCOPY can be clobbered by interrupts
 		},
-		{name: "MOVOconst", reg: regInfo{nil, 0, []regMask{fp}}, typ: "Int128", aux: "Int128", rematerializeable: true},
 
 		// arg0 = address of memory to zero
 		// arg1 = # of 8-byte words to zero
@@ -935,6 +935,7 @@ func init() {
 		regnames:        regNamesAMD64,
 		gpregmask:       gp,
 		fpregmask:       fp,
+		specialregmask:  x15,
 		framepointerreg: int8(num["BP"]),
 		linkreg:         -1, // not used
 	})
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index c64b145107..f41d014d41 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -202,9 +202,9 @@ func ClosureAuxCall(args []Param, results []Param) *AuxCall {
 func (*AuxCall) CanBeAnSSAAux() {}
 
 // OwnAuxCall returns a function's own AuxCall
-func OwnAuxCall(args []Param, results []Param) *AuxCall {
+func OwnAuxCall(fn *obj.LSym, args []Param, results []Param) *AuxCall {
 	// TODO if this remains identical to ClosureAuxCall above after new ABI is done, should deduplicate.
-	return &AuxCall{Fn: nil, args: args, results: results}
+	return &AuxCall{Fn: fn, args: args, results: results}
 }
 
 const (
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index e590f6ba5d..9ad4c2f305 100644
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -970,6 +970,7 @@ const (
 	OpAMD64MOVQstore
 	OpAMD64MOVOload
 	OpAMD64MOVOstore
+	OpAMD64MOVOstorezero
 	OpAMD64MOVBloadidx1
 	OpAMD64MOVWloadidx1
 	OpAMD64MOVWloadidx2
@@ -998,7 +999,6 @@ const (
 	OpAMD64MOVQstoreconstidx1
 	OpAMD64MOVQstoreconstidx8
 	OpAMD64DUFFZERO
-	OpAMD64MOVOconst
 	OpAMD64REPSTOSQ
 	OpAMD64CALLstatic
 	OpAMD64CALLclosure
@@ -6162,11 +6162,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AADDSS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-				{1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+				{1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6178,11 +6178,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AADDSD,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-				{1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+				{1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6193,11 +6193,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ASUBSS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-				{1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+				{1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6208,11 +6208,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ASUBSD,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-				{1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+				{1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6224,11 +6224,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AMULSS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-				{1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+				{1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6240,11 +6240,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AMULSD,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-				{1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+				{1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6255,11 +6255,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ADIVSS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-				{1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+				{1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6270,11 +6270,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ADIVSD,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-				{1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+				{1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6290,7 +6290,7 @@ var opcodeTable = [...]opInfo{
 				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6306,7 +6306,7 @@ var opcodeTable = [...]opInfo{
 				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6318,7 +6318,7 @@ var opcodeTable = [...]opInfo{
 		asm:               x86.AMOVSS,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6330,7 +6330,7 @@ var opcodeTable = [...]opInfo{
 		asm:               x86.AMOVSD,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6347,7 +6347,7 @@ var opcodeTable = [...]opInfo{
 				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6364,7 +6364,7 @@ var opcodeTable = [...]opInfo{
 				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6381,7 +6381,7 @@ var opcodeTable = [...]opInfo{
 				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6398,7 +6398,7 @@ var opcodeTable = [...]opInfo{
 				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6411,7 +6411,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVSS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 		},
@@ -6425,7 +6425,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVSD,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 		},
@@ -6439,8 +6439,8 @@ var opcodeTable = [...]opInfo{
 		scale:     1,
 		reg: regInfo{
 			inputs: []inputInfo{
+				{2, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
 				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 		},
@@ -6454,8 +6454,8 @@ var opcodeTable = [...]opInfo{
 		scale:     4,
 		reg: regInfo{
 			inputs: []inputInfo{
+				{2, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
 				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 		},
@@ -6469,8 +6469,8 @@ var opcodeTable = [...]opInfo{
 		scale:     1,
 		reg: regInfo{
 			inputs: []inputInfo{
+				{2, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
 				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 		},
@@ -6484,8 +6484,8 @@ var opcodeTable = [...]opInfo{
 		scale:     8,
 		reg: regInfo{
 			inputs: []inputInfo{
+				{2, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
 				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 		},
@@ -6500,11 +6500,11 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AADDSS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6518,11 +6518,11 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AADDSD,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6536,11 +6536,11 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ASUBSS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6554,11 +6554,11 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ASUBSD,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6572,11 +6572,11 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMULSS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6590,11 +6590,11 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMULSD,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6608,11 +6608,11 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ADIVSS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6626,11 +6626,11 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ADIVSD,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6644,12 +6644,12 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6663,12 +6663,12 @@ var opcodeTable = [...]opInfo{
 		scale:        4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6682,12 +6682,12 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6701,12 +6701,12 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6720,12 +6720,12 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6739,12 +6739,12 @@ var opcodeTable = [...]opInfo{
 		scale:        4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6758,12 +6758,12 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6777,12 +6777,12 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6796,12 +6796,12 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6815,12 +6815,12 @@ var opcodeTable = [...]opInfo{
 		scale:        4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6834,12 +6834,12 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6853,12 +6853,12 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6872,12 +6872,12 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6891,12 +6891,12 @@ var opcodeTable = [...]opInfo{
 		scale:        4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6910,12 +6910,12 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -6929,12 +6929,12 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -8245,8 +8245,8 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.AUCOMISS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-				{1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+				{1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -8256,8 +8256,8 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.AUCOMISD,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-				{1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+				{1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -11628,10 +11628,10 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ASQRTSD,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -11642,10 +11642,10 @@ var opcodeTable = [...]opInfo{
 		asm:     x86.AROUNDSD,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -11656,12 +11656,12 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AVFMADD231SD,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-				{1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-				{2, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+				{1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+				{2, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -12097,7 +12097,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ACVTTSD2SL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
 				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
@@ -12110,7 +12110,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ACVTTSD2SQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
 				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
@@ -12123,7 +12123,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ACVTTSS2SL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
 				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
@@ -12136,7 +12136,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ACVTTSS2SQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
 				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
@@ -12152,7 +12152,7 @@ var opcodeTable = [...]opInfo{
 				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -12165,7 +12165,7 @@ var opcodeTable = [...]opInfo{
 				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -12178,7 +12178,7 @@ var opcodeTable = [...]opInfo{
 				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -12191,7 +12191,7 @@ var opcodeTable = [...]opInfo{
 				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -12201,10 +12201,10 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ACVTSD2SS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -12214,10 +12214,10 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ACVTSS2SD,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -12229,7 +12229,7 @@ var opcodeTable = [...]opInfo{
 				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -12238,7 +12238,7 @@ var opcodeTable = [...]opInfo{
 		argLen: 1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
 				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
@@ -12253,7 +12253,7 @@ var opcodeTable = [...]opInfo{
 				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -12262,7 +12262,7 @@ var opcodeTable = [...]opInfo{
 		argLen: 1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
 				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
@@ -12277,11 +12277,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.APXOR,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-				{1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+				{1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -12720,7 +12720,7 @@ var opcodeTable = [...]opInfo{
 				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 		},
 	},
@@ -12733,7 +12733,20 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVUPS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+				{1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+			},
+		},
+	},
+	{
+		name:           "MOVOstorezero",
+		auxType:        auxSymOff,
+		argLen:         2,
+		faultOnNilArg0: true,
+		symEffect:      SymWrite,
+		asm:            x86.AMOVUPS,
+		reg: regInfo{
+			inputs: []inputInfo{
 				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
 			},
 		},
@@ -13159,28 +13172,16 @@ var opcodeTable = [...]opInfo{
 	{
 		name:           "DUFFZERO",
 		auxType:        auxInt64,
-		argLen:         3,
+		argLen:         2,
 		faultOnNilArg0: true,
 		unsafePoint:    true,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 128},   // DI
-				{1, 65536}, // X0
+				{0, 128}, // DI
 			},
 			clobbers: 128, // DI
 		},
 	},
-	{
-		name:              "MOVOconst",
-		auxType:           auxInt128,
-		argLen:            0,
-		rematerializeable: true,
-		reg: regInfo{
-			outputs: []outputInfo{
-				{0, 4294901760}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
-			},
-		},
-	},
 	{
 		name:           "REPSTOSQ",
 		argLen:         4,
@@ -13201,7 +13202,7 @@ var opcodeTable = [...]opInfo{
 		clobberFlags: true,
 		call:         true,
 		reg: regInfo{
-			clobbers: 4294967279, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+			clobbers: 2147483631, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 		},
 	},
 	{
@@ -13215,7 +13216,7 @@ var opcodeTable = [...]opInfo{
 				{1, 4},     // DX
 				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
 			},
-			clobbers: 4294967279, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+			clobbers: 2147483631, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 		},
 	},
 	{
@@ -13228,7 +13229,7 @@ var opcodeTable = [...]opInfo{
 			inputs: []inputInfo{
 				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
 			},
-			clobbers: 4294967279, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+			clobbers: 2147483631, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 		},
 	},
 	{
@@ -13328,7 +13329,7 @@ var opcodeTable = [...]opInfo{
 				{0, 128}, // DI
 				{1, 879}, // AX CX DX BX BP SI R8 R9
 			},
-			clobbers: 4294901760, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15
+			clobbers: 2147418112, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 		},
 	},
 	{
@@ -36193,8 +36194,8 @@ var registersAMD64 = [...]Register{
 	{32, 0, -1, "SB"},
 }
 var gpRegMaskAMD64 = regMask(65519)
-var fpRegMaskAMD64 = regMask(4294901760)
-var specialRegMaskAMD64 = regMask(0)
+var fpRegMaskAMD64 = regMask(2147418112)
+var specialRegMaskAMD64 = regMask(2147483648)
 var framepointerRegAMD64 = int8(5)
 var linkRegAMD64 = int8(-1)
 var registersARM = [...]Register{
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index db2dc7a004..6087874fa9 100644
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -14226,7 +14226,7 @@ func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *Value) bool {
 	}
 	// match: (MOVQstoreconst [c] {s} p x:(MOVQstoreconst [c2] {s} p mem))
 	// cond: config.useSSE && x.Uses == 1 && c2.Off() + 8 == c.Off() && c.Val() == 0 && c2.Val() == 0 && clobber(x)
-	// result: (MOVOstore [c2.Off32()] {s} p (MOVOconst [0]) mem)
+	// result: (MOVOstorezero [c2.Off32()] {s} p mem)
 	for {
 		c := auxIntToValAndOff(v.AuxInt)
 		s := auxToSym(v.Aux)
@@ -14243,12 +14243,10 @@ func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *Value) bool {
 		if p != x.Args[0] || !(config.useSSE && x.Uses == 1 && c2.Off()+8 == c.Off() && c.Val() == 0 && c2.Val() == 0 && clobber(x)) {
 			break
 		}
-		v.reset(OpAMD64MOVOstore)
+		v.reset(OpAMD64MOVOstorezero)
 		v.AuxInt = int32ToAuxInt(c2.Off32())
 		v.Aux = symToAux(s)
-		v0 := b.NewValue0(x.Pos, OpAMD64MOVOconst, types.TypeInt128)
-		v0.AuxInt = int128ToAuxInt(0)
-		v.AddArg3(p, v0, mem)
+		v.AddArg2(p, mem)
 		return true
 	}
 	// match: (MOVQstoreconst [sc] {sym1} (LEAL [off] {sym2} ptr) mem)
@@ -34163,7 +34161,7 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 	}
 	// match: (Zero [s] destptr mem)
 	// cond: s%16 != 0 && s > 16 && s%16 > 8 && config.useSSE
-	// result: (Zero [s-s%16] (OffPtr <destptr.Type> destptr [s%16]) (MOVOstore destptr (MOVOconst [0]) mem))
+	// result: (Zero [s-s%16] (OffPtr <destptr.Type> destptr [s%16]) (MOVOstorezero destptr mem))
 	for {
 		s := auxIntToInt64(v.AuxInt)
 		destptr := v_0
@@ -34176,10 +34174,8 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 		v0 := b.NewValue0(v.Pos, OpOffPtr, destptr.Type)
 		v0.AuxInt = int64ToAuxInt(s % 16)
 		v0.AddArg(destptr)
-		v1 := b.NewValue0(v.Pos, OpAMD64MOVOstore, types.TypeMem)
-		v2 := b.NewValue0(v.Pos, OpAMD64MOVOconst, types.TypeInt128)
-		v2.AuxInt = int128ToAuxInt(0)
-		v1.AddArg3(destptr, v2, mem)
+		v1 := b.NewValue0(v.Pos, OpAMD64MOVOstorezero, types.TypeMem)
+		v1.AddArg2(destptr, mem)
 		v.AddArg2(v0, v1)
 		return true
 	}
@@ -34206,7 +34202,7 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 	}
 	// match: (Zero [16] destptr mem)
 	// cond: config.useSSE
-	// result: (MOVOstore destptr (MOVOconst [0]) mem)
+	// result: (MOVOstorezero destptr mem)
 	for {
 		if auxIntToInt64(v.AuxInt) != 16 {
 			break
@@ -34216,15 +34212,13 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 		if !(config.useSSE) {
 			break
 		}
-		v.reset(OpAMD64MOVOstore)
-		v0 := b.NewValue0(v.Pos, OpAMD64MOVOconst, types.TypeInt128)
-		v0.AuxInt = int128ToAuxInt(0)
-		v.AddArg3(destptr, v0, mem)
+		v.reset(OpAMD64MOVOstorezero)
+		v.AddArg2(destptr, mem)
 		return true
 	}
 	// match: (Zero [32] destptr mem)
 	// cond: config.useSSE
-	// result: (MOVOstore (OffPtr <destptr.Type> destptr [16]) (MOVOconst [0]) (MOVOstore destptr (MOVOconst [0]) mem))
+	// result: (MOVOstorezero (OffPtr <destptr.Type> destptr [16]) (MOVOstorezero destptr mem))
 	for {
 		if auxIntToInt64(v.AuxInt) != 32 {
 			break
@@ -34234,20 +34228,18 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 		if !(config.useSSE) {
 			break
 		}
-		v.reset(OpAMD64MOVOstore)
+		v.reset(OpAMD64MOVOstorezero)
 		v0 := b.NewValue0(v.Pos, OpOffPtr, destptr.Type)
 		v0.AuxInt = int64ToAuxInt(16)
 		v0.AddArg(destptr)
-		v1 := b.NewValue0(v.Pos, OpAMD64MOVOconst, types.TypeInt128)
-		v1.AuxInt = int128ToAuxInt(0)
-		v2 := b.NewValue0(v.Pos, OpAMD64MOVOstore, types.TypeMem)
-		v2.AddArg3(destptr, v1, mem)
-		v.AddArg3(v0, v1, v2)
+		v1 := b.NewValue0(v.Pos, OpAMD64MOVOstorezero, types.TypeMem)
+		v1.AddArg2(destptr, mem)
+		v.AddArg2(v0, v1)
 		return true
 	}
 	// match: (Zero [48] destptr mem)
 	// cond: config.useSSE
-	// result: (MOVOstore (OffPtr <destptr.Type> destptr [32]) (MOVOconst [0]) (MOVOstore (OffPtr <destptr.Type> destptr [16]) (MOVOconst [0]) (MOVOstore destptr (MOVOconst [0]) mem)))
+	// result: (MOVOstorezero (OffPtr <destptr.Type> destptr [32]) (MOVOstorezero (OffPtr <destptr.Type> destptr [16]) (MOVOstorezero destptr mem)))
 	for {
 		if auxIntToInt64(v.AuxInt) != 48 {
 			break
@@ -34257,25 +34249,23 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 		if !(config.useSSE) {
 			break
 		}
-		v.reset(OpAMD64MOVOstore)
+		v.reset(OpAMD64MOVOstorezero)
 		v0 := b.NewValue0(v.Pos, OpOffPtr, destptr.Type)
 		v0.AuxInt = int64ToAuxInt(32)
 		v0.AddArg(destptr)
-		v1 := b.NewValue0(v.Pos, OpAMD64MOVOconst, types.TypeInt128)
-		v1.AuxInt = int128ToAuxInt(0)
-		v2 := b.NewValue0(v.Pos, OpAMD64MOVOstore, types.TypeMem)
-		v3 := b.NewValue0(v.Pos, OpOffPtr, destptr.Type)
-		v3.AuxInt = int64ToAuxInt(16)
-		v3.AddArg(destptr)
-		v4 := b.NewValue0(v.Pos, OpAMD64MOVOstore, types.TypeMem)
-		v4.AddArg3(destptr, v1, mem)
-		v2.AddArg3(v3, v1, v4)
-		v.AddArg3(v0, v1, v2)
+		v1 := b.NewValue0(v.Pos, OpAMD64MOVOstorezero, types.TypeMem)
+		v2 := b.NewValue0(v.Pos, OpOffPtr, destptr.Type)
+		v2.AuxInt = int64ToAuxInt(16)
+		v2.AddArg(destptr)
+		v3 := b.NewValue0(v.Pos, OpAMD64MOVOstorezero, types.TypeMem)
+		v3.AddArg2(destptr, mem)
+		v1.AddArg2(v2, v3)
+		v.AddArg2(v0, v1)
 		return true
 	}
 	// match: (Zero [64] destptr mem)
 	// cond: config.useSSE
-	// result: (MOVOstore (OffPtr <destptr.Type> destptr [48]) (MOVOconst [0]) (MOVOstore (OffPtr <destptr.Type> destptr [32]) (MOVOconst [0]) (MOVOstore (OffPtr <destptr.Type> destptr [16]) (MOVOconst [0]) (MOVOstore destptr (MOVOconst [0]) mem))))
+	// result: (MOVOstorezero (OffPtr <destptr.Type> destptr [48]) (MOVOstorezero (OffPtr <destptr.Type> destptr [32]) (MOVOstorezero (OffPtr <destptr.Type> destptr [16]) (MOVOstorezero destptr mem))))
 	for {
 		if auxIntToInt64(v.AuxInt) != 64 {
 			break
@@ -34285,30 +34275,28 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 		if !(config.useSSE) {
 			break
 		}
-		v.reset(OpAMD64MOVOstore)
+		v.reset(OpAMD64MOVOstorezero)
 		v0 := b.NewValue0(v.Pos, OpOffPtr, destptr.Type)
 		v0.AuxInt = int64ToAuxInt(48)
 		v0.AddArg(destptr)
-		v1 := b.NewValue0(v.Pos, OpAMD64MOVOconst, types.TypeInt128)
-		v1.AuxInt = int128ToAuxInt(0)
-		v2 := b.NewValue0(v.Pos, OpAMD64MOVOstore, types.TypeMem)
-		v3 := b.NewValue0(v.Pos, OpOffPtr, destptr.Type)
-		v3.AuxInt = int64ToAuxInt(32)
-		v3.AddArg(destptr)
-		v4 := b.NewValue0(v.Pos, OpAMD64MOVOstore, types.TypeMem)
-		v5 := b.NewValue0(v.Pos, OpOffPtr, destptr.Type)
-		v5.AuxInt = int64ToAuxInt(16)
-		v5.AddArg(destptr)
-		v6 := b.NewValue0(v.Pos, OpAMD64MOVOstore, types.TypeMem)
-		v6.AddArg3(destptr, v1, mem)
-		v4.AddArg3(v5, v1, v6)
-		v2.AddArg3(v3, v1, v4)
-		v.AddArg3(v0, v1, v2)
+		v1 := b.NewValue0(v.Pos, OpAMD64MOVOstorezero, types.TypeMem)
+		v2 := b.NewValue0(v.Pos, OpOffPtr, destptr.Type)
+		v2.AuxInt = int64ToAuxInt(32)
+		v2.AddArg(destptr)
+		v3 := b.NewValue0(v.Pos, OpAMD64MOVOstorezero, types.TypeMem)
+		v4 := b.NewValue0(v.Pos, OpOffPtr, destptr.Type)
+		v4.AuxInt = int64ToAuxInt(16)
+		v4.AddArg(destptr)
+		v5 := b.NewValue0(v.Pos, OpAMD64MOVOstorezero, types.TypeMem)
+		v5.AddArg2(destptr, mem)
+		v3.AddArg2(v4, v5)
+		v1.AddArg2(v2, v3)
+		v.AddArg2(v0, v1)
 		return true
 	}
 	// match: (Zero [s] destptr mem)
 	// cond: s > 64 && s <= 1024 && s%16 == 0 && !config.noDuffDevice
-	// result: (DUFFZERO [s] destptr (MOVOconst [0]) mem)
+	// result: (DUFFZERO [s] destptr mem)
 	for {
 		s := auxIntToInt64(v.AuxInt)
 		destptr := v_0
@@ -34318,9 +34306,7 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 		}
 		v.reset(OpAMD64DUFFZERO)
 		v.AuxInt = int64ToAuxInt(s)
-		v0 := b.NewValue0(v.Pos, OpAMD64MOVOconst, types.TypeInt128)
-		v0.AuxInt = int128ToAuxInt(0)
-		v.AddArg3(destptr, v0, mem)
+		v.AddArg2(destptr, mem)
 		return true
 	}
 	// match: (Zero [s] destptr mem)
diff --git a/src/cmd/compile/internal/ssagen/abi.go b/src/cmd/compile/internal/ssagen/abi.go
index 5bebce1db5..7180b3816c 100644
--- a/src/cmd/compile/internal/ssagen/abi.go
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -300,9 +300,20 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 	// to allocate any stack space). Doing this will require some
 	// extra work in typecheck/walk/ssa, might want to add a new node
 	// OTAILCALL or something to this effect.
-	var tail ir.Node
-	if tfn.Type().NumResults() == 0 && tfn.Type().NumParams() == 0 && tfn.Type().NumRecvs() == 0 && !(base.Ctxt.Arch.Name == "ppc64le" && base.Ctxt.Flag_dynlink) {
+	tailcall := tfn.Type().NumResults() == 0 && tfn.Type().NumParams() == 0 && tfn.Type().NumRecvs() == 0
+	if base.Ctxt.Arch.Name == "ppc64le" && base.Ctxt.Flag_dynlink {
+		// cannot tailcall on PPC64 with dynamic linking, as we need
+		// to restore R2 after call.
+		tailcall = false
+	}
+	if base.Ctxt.Arch.Name == "amd64" && wrapperABI == obj.ABIInternal {
+		// cannot tailcall from ABIInternal to ABI0 on AMD64, as we need
+		// to special registers (X15) when returning to ABIInternal.
+		tailcall = false
+	}
 
+	var tail ir.Node
+	if tailcall {
 		tail = ir.NewTailCallStmt(base.Pos, f.Nname)
 	} else {
 		call := ir.NewCallExpr(base.Pos, ir.OCALL, f.Nname, nil)
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index b042c132d5..6b1ddebd32 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -468,7 +468,7 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 			s.Fatalf("local variable with class %v unimplemented", n.Class)
 		}
 	}
-	s.f.OwnAux = ssa.OwnAuxCall(args, results)
+	s.f.OwnAux = ssa.OwnAuxCall(fn.LSym, args, results)
 
 	// Populate SSAable arguments.
 	for _, n := range fn.Dcl {
@@ -6266,6 +6266,8 @@ type Branch struct {
 
 // State contains state needed during Prog generation.
 type State struct {
+	ABI obj.ABI
+
 	pp *objw.Progs
 
 	// Branches remembers all the branch instructions we've seen
@@ -6361,6 +6363,7 @@ func (s *State) DebugFriendlySetPosFrom(v *ssa.Value) {
 // genssa appends entries to pp for each instruction in f.
 func genssa(f *ssa.Func, pp *objw.Progs) {
 	var s State
+	s.ABI = f.OwnAux.Fn.ABI()
 
 	e := f.Frontend().(*ssafn)
 
diff --git a/src/runtime/duff_amd64.s b/src/runtime/duff_amd64.s
index 2ff5bf6dbc..df010f5853 100644
--- a/src/runtime/duff_amd64.s
+++ b/src/runtime/duff_amd64.s
@@ -5,100 +5,100 @@
 #include "textflag.h"
 
 TEXT runtime·duffzero<ABIInternal>(SB), NOSPLIT, $0-0
-	MOVUPS	X0,(DI)
-	MOVUPS	X0,16(DI)
-	MOVUPS	X0,32(DI)
-	MOVUPS	X0,48(DI)
+	MOVUPS	X15,(DI)
+	MOVUPS	X15,16(DI)
+	MOVUPS	X15,32(DI)
+	MOVUPS	X15,48(DI)
 	LEAQ	64(DI),DI
 
-	MOVUPS	X0,(DI)
-	MOVUPS	X0,16(DI)
-	MOVUPS	X0,32(DI)
-	MOVUPS	X0,48(DI)
+	MOVUPS	X15,(DI)
+	MOVUPS	X15,16(DI)
+	MOVUPS	X15,32(DI)
+	MOVUPS	X15,48(DI)
 	LEAQ	64(DI),DI
 
-	MOVUPS	X0,(DI)
-	MOVUPS	X0,16(DI)
-	MOVUPS	X0,32(DI)
-	MOVUPS	X0,48(DI)
+	MOVUPS	X15,(DI)
+	MOVUPS	X15,16(DI)
+	MOVUPS	X15,32(DI)
+	MOVUPS	X15,48(DI)
 	LEAQ	64(DI),DI
 
-	MOVUPS	X0,(DI)
-	MOVUPS	X0,16(DI)
-	MOVUPS	X0,32(DI)
-	MOVUPS	X0,48(DI)
+	MOVUPS	X15,(DI)
+	MOVUPS	X15,16(DI)
+	MOVUPS	X15,32(DI)
+	MOVUPS	X15,48(DI)
 	LEAQ	64(DI),DI
 
-	MOVUPS	X0,(DI)
-	MOVUPS	X0,16(DI)
-	MOVUPS	X0,32(DI)
-	MOVUPS	X0,48(DI)
+	MOVUPS	X15,(DI)
+	MOVUPS	X15,16(DI)
+	MOVUPS	X15,32(DI)
+	MOVUPS	X15,48(DI)
 	LEAQ	64(DI),DI
 
-	MOVUPS	X0,(DI)
-	MOVUPS	X0,16(DI)
-	MOVUPS	X0,32(DI)
-	MOVUPS	X0,48(DI)
+	MOVUPS	X15,(DI)
+	MOVUPS	X15,16(DI)
+	MOVUPS	X15,32(DI)
+	MOVUPS	X15,48(DI)
 	LEAQ	64(DI),DI
 
-	MOVUPS	X0,(DI)
-	MOVUPS	X0,16(DI)
-	MOVUPS	X0,32(DI)
-	MOVUPS	X0,48(DI)
+	MOVUPS	X15,(DI)
+	MOVUPS	X15,16(DI)
+	MOVUPS	X15,32(DI)
+	MOVUPS	X15,48(DI)
 	LEAQ	64(DI),DI
 
-	MOVUPS	X0,(DI)
-	MOVUPS	X0,16(DI)
-	MOVUPS	X0,32(DI)
-	MOVUPS	X0,48(DI)
+	MOVUPS	X15,(DI)
+	MOVUPS	X15,16(DI)
+	MOVUPS	X15,32(DI)
+	MOVUPS	X15,48(DI)
 	LEAQ	64(DI),DI
 
-	MOVUPS	X0,(DI)
-	MOVUPS	X0,16(DI)
-	MOVUPS	X0,32(DI)
-	MOVUPS	X0,48(DI)
+	MOVUPS	X15,(DI)
+	MOVUPS	X15,16(DI)
+	MOVUPS	X15,32(DI)
+	MOVUPS	X15,48(DI)
 	LEAQ	64(DI),DI
 
-	MOVUPS	X0,(DI)
-	MOVUPS	X0,16(DI)
-	MOVUPS	X0,32(DI)
-	MOVUPS	X0,48(DI)
+	MOVUPS	X15,(DI)
+	MOVUPS	X15,16(DI)
+	MOVUPS	X15,32(DI)
+	MOVUPS	X15,48(DI)
 	LEAQ	64(DI),DI
 
-	MOVUPS	X0,(DI)
-	MOVUPS	X0,16(DI)
-	MOVUPS	X0,32(DI)
-	MOVUPS	X0,48(DI)
+	MOVUPS	X15,(DI)
+	MOVUPS	X15,16(DI)
+	MOVUPS	X15,32(DI)
+	MOVUPS	X15,48(DI)
 	LEAQ	64(DI),DI
 
-	MOVUPS	X0,(DI)
-	MOVUPS	X0,16(DI)
-	MOVUPS	X0,32(DI)
-	MOVUPS	X0,48(DI)
+	MOVUPS	X15,(DI)
+	MOVUPS	X15,16(DI)
+	MOVUPS	X15,32(DI)
+	MOVUPS	X15,48(DI)
 	LEAQ	64(DI),DI
 
-	MOVUPS	X0,(DI)
-	MOVUPS	X0,16(DI)
-	MOVUPS	X0,32(DI)
-	MOVUPS	X0,48(DI)
+	MOVUPS	X15,(DI)
+	MOVUPS	X15,16(DI)
+	MOVUPS	X15,32(DI)
+	MOVUPS	X15,48(DI)
 	LEAQ	64(DI),DI
 
-	MOVUPS	X0,(DI)
-	MOVUPS	X0,16(DI)
-	MOVUPS	X0,32(DI)
-	MOVUPS	X0,48(DI)
+	MOVUPS	X15,(DI)
+	MOVUPS	X15,16(DI)
+	MOVUPS	X15,32(DI)
+	MOVUPS	X15,48(DI)
 	LEAQ	64(DI),DI
 
-	MOVUPS	X0,(DI)
-	MOVUPS	X0,16(DI)
-	MOVUPS	X0,32(DI)
-	MOVUPS	X0,48(DI)
+	MOVUPS	X15,(DI)
+	MOVUPS	X15,16(DI)
+	MOVUPS	X15,32(DI)
+	MOVUPS	X15,48(DI)
 	LEAQ	64(DI),DI
 
-	MOVUPS	X0,(DI)
-	MOVUPS	X0,16(DI)
-	MOVUPS	X0,32(DI)
-	MOVUPS	X0,48(DI)
+	MOVUPS	X15,(DI)
+	MOVUPS	X15,16(DI)
+	MOVUPS	X15,32(DI)
+	MOVUPS	X15,48(DI)
 	LEAQ	64(DI),DI
 
 	RET
diff --git a/src/runtime/mkduff.go b/src/runtime/mkduff.go
index 94ae75fbfe..ef297f073e 100644
--- a/src/runtime/mkduff.go
+++ b/src/runtime/mkduff.go
@@ -62,15 +62,15 @@ func gen(arch string, tags, zero, copy func(io.Writer)) {
 func notags(w io.Writer) { fmt.Fprintln(w) }
 
 func zeroAMD64(w io.Writer) {
-	// X0: zero
+	// X15: zero
 	// DI: ptr to memory to be zeroed
 	// DI is updated as a side effect.
-	fmt.Fprintln(w, "TEXT runtime·duffzero(SB), NOSPLIT, $0-0")
+	fmt.Fprintln(w, "TEXT runtime·duffzero<ABIInternal>(SB), NOSPLIT, $0-0")
 	for i := 0; i < 16; i++ {
-		fmt.Fprintln(w, "\tMOVUPS\tX0,(DI)")
-		fmt.Fprintln(w, "\tMOVUPS\tX0,16(DI)")
-		fmt.Fprintln(w, "\tMOVUPS\tX0,32(DI)")
-		fmt.Fprintln(w, "\tMOVUPS\tX0,48(DI)")
+		fmt.Fprintln(w, "\tMOVUPS\tX15,(DI)")
+		fmt.Fprintln(w, "\tMOVUPS\tX15,16(DI)")
+		fmt.Fprintln(w, "\tMOVUPS\tX15,32(DI)")
+		fmt.Fprintln(w, "\tMOVUPS\tX15,48(DI)")
 		fmt.Fprintln(w, "\tLEAQ\t64(DI),DI") // We use lea instead of add, to avoid clobbering flags
 		fmt.Fprintln(w)
 	}
@@ -84,7 +84,7 @@ func copyAMD64(w io.Writer) {
 	//
 	// This is equivalent to a sequence of MOVSQ but
 	// for some reason that is 3.5x slower than this code.
-	fmt.Fprintln(w, "TEXT runtime·duffcopy(SB), NOSPLIT, $0-0")
+	fmt.Fprintln(w, "TEXT runtime·duffcopy<ABIInternal>(SB), NOSPLIT, $0-0")
 	for i := 0; i < 64; i++ {
 		fmt.Fprintln(w, "\tMOVUPS\t(SI), X0")
 		fmt.Fprintln(w, "\tADDQ\t$16, SI")
diff --git a/test/codegen/structs.go b/test/codegen/structs.go
index 9eddc5b16e..c4bcb55c63 100644
--- a/test/codegen/structs.go
+++ b/test/codegen/structs.go
@@ -18,7 +18,7 @@ type Z1 struct {
 }
 
 func Zero1(t *Z1) { // Issue #18370
-	// amd64:`XORPS\tX., X`,`MOVUPS\tX., \(.*\)`,`MOVQ\t\$0, 16\(.*\)`
+	// amd64:`MOVUPS\tX[0-9]+, \(.*\)`,`MOVQ\t\$0, 16\(.*\)`
 	*t = Z1{}
 }
 
@@ -27,7 +27,7 @@ type Z2 struct {
 }
 
 func Zero2(t *Z2) {
-	// amd64:`XORPS\tX., X`,`MOVUPS\tX., \(.*\)`,`MOVQ\t\$0, 16\(.*\)`
+	// amd64:`MOVUPS\tX[0-9]+, \(.*\)`,`MOVQ\t\$0, 16\(.*\)`
 	// amd64:`.*runtime[.]gcWriteBarrier.*\(SB\)`
 	*t = Z2{}
 }
-- 
GitLab


From ca2f15289337f57dcfb938000af249532f79e4d4 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 3 Feb 2021 21:57:06 -0500
Subject: [PATCH 0593/2400] [dev.typeparams] go/types: add missing test from
 dev.go2go

errors_test.go was missed during merging. Add it.

Change-Id: I321f08ae16ca02586875e1c7776f5d78f8690b4d
Reviewed-on: https://go-review.googlesource.com/c/go/+/289549
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/errors_test.go | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 src/go/types/errors_test.go

diff --git a/src/go/types/errors_test.go b/src/go/types/errors_test.go
new file mode 100644
index 0000000000..fdbe07cae0
--- /dev/null
+++ b/src/go/types/errors_test.go
@@ -0,0 +1,25 @@
+// Copyright 2020 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 types
+
+import "testing"
+
+func TestStripAnnotations(t *testing.T) {
+	for _, test := range []struct {
+		in, want string
+	}{
+		{"", ""},
+		{"   ", "   "},
+		{"foo", "foo"},
+		{"foo₀", "foo"},
+		{"foo(T₀)", "foo(T)"},
+		{"#foo(T₀)", "foo(T)"},
+	} {
+		got := stripAnnotations(test.in)
+		if got != test.want {
+			t.Errorf("%q: got %q; want %q", test.in, got, test.want)
+		}
+	}
+}
-- 
GitLab


From afd67f333466fc67cd37433e45ecdb190efc8f51 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 4 Feb 2021 10:27:41 -0500
Subject: [PATCH 0594/2400] [dev.regabi] go/types: no "declared but not used"
 errors for invalid var decls

This is a port of CL 274615, adapted to go/types. The only change was in
the positioning of expected errors in vardecl.src: in go/types they are
positioned on the identifier.

Change-Id: Iab03265a7c4287749373e4380c6db6a95f262f30
Reviewed-on: https://go-review.googlesource.com/c/go/+/289712
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/assignments.go       |  1 +
 src/go/types/decl.go              | 14 ++++++++++++++
 src/go/types/testdata/vardecl.src | 14 +++++++++++++-
 3 files changed, 28 insertions(+), 1 deletion(-)

diff --git a/src/go/types/assignments.go b/src/go/types/assignments.go
index 616564b567..d6f18c9bee 100644
--- a/src/go/types/assignments.go
+++ b/src/go/types/assignments.go
@@ -120,6 +120,7 @@ func (check *Checker) initVar(lhs *Var, x *operand, context string) Type {
 		if lhs.typ == nil {
 			lhs.typ = Typ[Invalid]
 		}
+		lhs.used = true
 		return nil
 	}
 
diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index 1f0bc358a2..df01e92530 100644
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -504,6 +504,20 @@ func (check *Checker) constDecl(obj *Const, typ, init ast.Expr, inherited bool)
 func (check *Checker) varDecl(obj *Var, lhs []*Var, typ, init ast.Expr) {
 	assert(obj.typ == nil)
 
+	// If we have undefined variable types due to errors,
+	// mark variables as used to avoid follow-on errors.
+	// Matches compiler behavior.
+	defer func() {
+		if obj.typ == Typ[Invalid] {
+			obj.used = true
+		}
+		for _, lhs := range lhs {
+			if lhs.typ == Typ[Invalid] {
+				lhs.used = true
+			}
+		}
+	}()
+
 	// determine type, if any
 	if typ != nil {
 		obj.typ = check.typ(typ)
diff --git a/src/go/types/testdata/vardecl.src b/src/go/types/testdata/vardecl.src
index 54f5ef1e10..6e2d1b5bd5 100644
--- a/src/go/types/testdata/vardecl.src
+++ b/src/go/types/testdata/vardecl.src
@@ -158,6 +158,18 @@ func _() {
 	}
 }
 
+
+// Invalid variable declarations must not lead to "declared but not used errors".
+func _() {
+	var a x        // ERROR undeclared name: x
+	var b = x      // ERROR undeclared name: x
+	var c int = x  // ERROR undeclared name: x
+	var d, e, f x  /* ERROR x */ /* ERROR x */ /* ERROR x */
+	var g, h, i = x /* ERROR x */, x /* ERROR x */, x /* ERROR x */
+	var j, k, l float32 = x /* ERROR x */, x /* ERROR x */, x /* ERROR x */
+	// but no "declared but not used" errors
+}
+
 // Invalid (unused) expressions must not lead to spurious "declared but not used errors"
 func _() {
 	var a, b, c int
@@ -203,4 +215,4 @@ func _() {
 	_, _, _ = x, y, z
 }
 
-// TODO(gri) consolidate other var decl checks in this file
\ No newline at end of file
+// TODO(gri) consolidate other var decl checks in this file
-- 
GitLab


From bc451b5770dc99b6a74934c26fd11a8cdc172bb1 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 4 Feb 2021 11:06:15 -0500
Subject: [PATCH 0595/2400] [dev.regabi] go/types: port check_test.go
 ergonomics from dev.typeparams

On the dev.typeparams and dev.go2go branches, check_test.go has been
updated to automatically discover test data. This is convenient, so port
it to dev.regabi.

Change-Id: I5da9a9a5139c35a2693e64364eb9928ece1cd7c6
Reviewed-on: https://go-review.googlesource.com/c/go/+/289713
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/check_test.go                    | 121 +++++++-----------
 .../types/testdata/{ => decls2}/decls2a.src   |   0
 .../types/testdata/{ => decls2}/decls2b.src   |   0
 .../{ => importdecl0}/importdecl0a.src        |   0
 .../{ => importdecl0}/importdecl0b.src        |   0
 .../{ => importdecl1}/importdecl1a.src        |   0
 .../{ => importdecl1}/importdecl1b.src        |   0
 .../testdata/{ => issue25008}/issue25008a.src |   0
 .../testdata/{ => issue25008}/issue25008b.src |   0
 9 files changed, 45 insertions(+), 76 deletions(-)
 rename src/go/types/testdata/{ => decls2}/decls2a.src (100%)
 rename src/go/types/testdata/{ => decls2}/decls2b.src (100%)
 rename src/go/types/testdata/{ => importdecl0}/importdecl0a.src (100%)
 rename src/go/types/testdata/{ => importdecl0}/importdecl0b.src (100%)
 rename src/go/types/testdata/{ => importdecl1}/importdecl1a.src (100%)
 rename src/go/types/testdata/{ => importdecl1}/importdecl1b.src (100%)
 rename src/go/types/testdata/{ => issue25008}/issue25008a.src (100%)
 rename src/go/types/testdata/{ => issue25008}/issue25008b.src (100%)

diff --git a/src/go/types/check_test.go b/src/go/types/check_test.go
index ce31dab68b..47d749b3a3 100644
--- a/src/go/types/check_test.go
+++ b/src/go/types/check_test.go
@@ -27,12 +27,14 @@ package types_test
 
 import (
 	"flag"
+	"fmt"
 	"go/ast"
 	"go/importer"
 	"go/parser"
 	"go/scanner"
 	"go/token"
 	"internal/testenv"
+	"io/ioutil"
 	"os"
 	"path/filepath"
 	"regexp"
@@ -48,54 +50,6 @@ var (
 	testFiles   = flag.String("files", "", "space-separated list of test files")
 )
 
-// The test filenames do not end in .go so that they are invisible
-// to gofmt since they contain comments that must not change their
-// positions relative to surrounding tokens.
-
-// Each tests entry is list of files belonging to the same package.
-var tests = [][]string{
-	{"testdata/errors.src"},
-	{"testdata/importdecl0a.src", "testdata/importdecl0b.src"},
-	{"testdata/importdecl1a.src", "testdata/importdecl1b.src"},
-	{"testdata/importC.src"}, // special handling in checkFiles
-	{"testdata/cycles.src"},
-	{"testdata/cycles1.src"},
-	{"testdata/cycles2.src"},
-	{"testdata/cycles3.src"},
-	{"testdata/cycles4.src"},
-	{"testdata/cycles5.src"},
-	{"testdata/init0.src"},
-	{"testdata/init1.src"},
-	{"testdata/init2.src"},
-	{"testdata/decls0.src"},
-	{"testdata/decls1.src"},
-	{"testdata/decls2a.src", "testdata/decls2b.src"},
-	{"testdata/decls3.src"},
-	{"testdata/decls4.src"},
-	{"testdata/decls5.src"},
-	{"testdata/const0.src"},
-	{"testdata/const1.src"},
-	{"testdata/constdecl.src"},
-	{"testdata/vardecl.src"},
-	{"testdata/expr0.src"},
-	{"testdata/expr1.src"},
-	{"testdata/expr2.src"},
-	{"testdata/expr3.src"},
-	{"testdata/methodsets.src"},
-	{"testdata/shifts.src"},
-	{"testdata/builtins.src"},
-	{"testdata/conversions.src"},
-	{"testdata/conversions2.src"},
-	{"testdata/stmt0.src"},
-	{"testdata/stmt1.src"},
-	{"testdata/gotos.src"},
-	{"testdata/labels.src"},
-	{"testdata/literals.src"},
-	{"testdata/issues.src"},
-	{"testdata/blank.src"},
-	{"testdata/issue25008b.src", "testdata/issue25008a.src"}, // order (b before a) is crucial!
-}
-
 var fset = token.NewFileSet()
 
 // Positioned errors are of the form filename:line:column: message .
@@ -236,9 +190,13 @@ func eliminate(t *testing.T, errmap map[string][]string, errlist []error) {
 	}
 }
 
-func checkFiles(t *testing.T, testfiles []string) {
+func checkFiles(t *testing.T, sources []string) {
+	if len(sources) == 0 {
+		t.Fatal("no source files")
+	}
+
 	// parse files and collect parser errors
-	files, errlist := parseFiles(t, testfiles)
+	files, errlist := parseFiles(t, sources)
 
 	pkgName := "<no package>"
 	if len(files) > 0 {
@@ -254,10 +212,13 @@ func checkFiles(t *testing.T, testfiles []string) {
 
 	// typecheck and collect typechecker errors
 	var conf Config
+
 	// special case for importC.src
-	if len(testfiles) == 1 && strings.HasSuffix(testfiles[0], "importC.src") {
+	if len(sources) == 1 && strings.HasSuffix(sources[0], "importC.src") {
 		conf.FakeImportC = true
 	}
+	// TODO(rFindley) we may need to use the source importer when adding generics
+	// tests.
 	conf.Importer = importer.Default()
 	conf.Error = func(err error) {
 		if *haltOnError {
@@ -306,44 +267,52 @@ func checkFiles(t *testing.T, testfiles []string) {
 	}
 }
 
+// TestCheck is for manual testing of selected input files, provided with -files.
 func TestCheck(t *testing.T) {
-	testenv.MustHaveGoBuild(t)
-
-	// Declare builtins for testing.
-	DefPredeclaredTestFuncs()
-
-	// If explicit test files are specified, only check those.
-	if files := *testFiles; files != "" {
-		checkFiles(t, strings.Split(files, " "))
+	if *testFiles == "" {
 		return
 	}
-
-	// Otherwise, run all the tests.
-	for _, files := range tests {
-		checkFiles(t, files)
-	}
+	testenv.MustHaveGoBuild(t)
+	DefPredeclaredTestFuncs()
+	checkFiles(t, strings.Split(*testFiles, " "))
 }
 
-func TestFixedBugs(t *testing.T) { testDir(t, "fixedbugs") }
+func TestTestdata(t *testing.T)  { DefPredeclaredTestFuncs(); testDir(t, "testdata") }
+func TestFixedbugs(t *testing.T) { testDir(t, "fixedbugs") }
 
 func testDir(t *testing.T, dir string) {
 	testenv.MustHaveGoBuild(t)
 
-	dirs, err := os.ReadDir(dir)
+	fis, err := os.ReadDir(dir)
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
+		return
 	}
 
-	for _, d := range dirs {
-		testname := filepath.Base(d.Name())
-		testname = strings.TrimSuffix(testname, filepath.Ext(testname))
-		t.Run(testname, func(t *testing.T) {
-			filename := filepath.Join(dir, d.Name())
-			if d.IsDir() {
-				t.Errorf("skipped directory %q", filename)
-				return
+	for _, fi := range fis {
+		path := filepath.Join(dir, fi.Name())
+
+		// if fi is a directory, its files make up a single package
+		var files []string
+		if fi.IsDir() {
+			fis, err := ioutil.ReadDir(path)
+			if err != nil {
+				t.Error(err)
+				continue
+			}
+			files = make([]string, len(fis))
+			for i, fi := range fis {
+				// if fi is a directory, checkFiles below will complain
+				files[i] = filepath.Join(path, fi.Name())
+				if testing.Verbose() {
+					fmt.Printf("\t%s\n", files[i])
+				}
 			}
-			checkFiles(t, []string{filename})
+		} else {
+			files = []string{path}
+		}
+		t.Run(filepath.Base(path), func(t *testing.T) {
+			checkFiles(t, files)
 		})
 	}
 }
diff --git a/src/go/types/testdata/decls2a.src b/src/go/types/testdata/decls2/decls2a.src
similarity index 100%
rename from src/go/types/testdata/decls2a.src
rename to src/go/types/testdata/decls2/decls2a.src
diff --git a/src/go/types/testdata/decls2b.src b/src/go/types/testdata/decls2/decls2b.src
similarity index 100%
rename from src/go/types/testdata/decls2b.src
rename to src/go/types/testdata/decls2/decls2b.src
diff --git a/src/go/types/testdata/importdecl0a.src b/src/go/types/testdata/importdecl0/importdecl0a.src
similarity index 100%
rename from src/go/types/testdata/importdecl0a.src
rename to src/go/types/testdata/importdecl0/importdecl0a.src
diff --git a/src/go/types/testdata/importdecl0b.src b/src/go/types/testdata/importdecl0/importdecl0b.src
similarity index 100%
rename from src/go/types/testdata/importdecl0b.src
rename to src/go/types/testdata/importdecl0/importdecl0b.src
diff --git a/src/go/types/testdata/importdecl1a.src b/src/go/types/testdata/importdecl1/importdecl1a.src
similarity index 100%
rename from src/go/types/testdata/importdecl1a.src
rename to src/go/types/testdata/importdecl1/importdecl1a.src
diff --git a/src/go/types/testdata/importdecl1b.src b/src/go/types/testdata/importdecl1/importdecl1b.src
similarity index 100%
rename from src/go/types/testdata/importdecl1b.src
rename to src/go/types/testdata/importdecl1/importdecl1b.src
diff --git a/src/go/types/testdata/issue25008a.src b/src/go/types/testdata/issue25008/issue25008a.src
similarity index 100%
rename from src/go/types/testdata/issue25008a.src
rename to src/go/types/testdata/issue25008/issue25008a.src
diff --git a/src/go/types/testdata/issue25008b.src b/src/go/types/testdata/issue25008/issue25008b.src
similarity index 100%
rename from src/go/types/testdata/issue25008b.src
rename to src/go/types/testdata/issue25008/issue25008b.src
-- 
GitLab


From 52d5cb2822966c00ce2ef97eb08bec4850d76fb2 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Wed, 3 Feb 2021 18:10:04 -0500
Subject: [PATCH 0596/2400] [dev.regabi] cmd/internal/obj: access Attribute
 atomically

Symbol's Attributes and ABI are in the same word. In the
concurrent backend, we may read one symbol's ABI (the callee)
while setting its attributes in another goroutine.

Fix racecompile build.

Change-Id: I500e869bafdd72080119ab243db94eee3afcf926
Reviewed-on: https://go-review.googlesource.com/c/go/+/289290
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/internal/obj/link.go | 64 ++++++++++++++++++++++--------------
 1 file changed, 40 insertions(+), 24 deletions(-)

diff --git a/src/cmd/internal/obj/link.go b/src/cmd/internal/obj/link.go
index 35cb53cbf6..8206902328 100644
--- a/src/cmd/internal/obj/link.go
+++ b/src/cmd/internal/obj/link.go
@@ -39,6 +39,7 @@ import (
 	"cmd/internal/sys"
 	"fmt"
 	"sync"
+	"sync/atomic"
 )
 
 // An Addr is an argument to an instruction.
@@ -647,37 +648,52 @@ const (
 	attrABIBase
 )
 
-func (a Attribute) DuplicateOK() bool        { return a&AttrDuplicateOK != 0 }
-func (a Attribute) MakeTypelink() bool       { return a&AttrMakeTypelink != 0 }
-func (a Attribute) CFunc() bool              { return a&AttrCFunc != 0 }
-func (a Attribute) NoSplit() bool            { return a&AttrNoSplit != 0 }
-func (a Attribute) Leaf() bool               { return a&AttrLeaf != 0 }
-func (a Attribute) OnList() bool             { return a&AttrOnList != 0 }
-func (a Attribute) ReflectMethod() bool      { return a&AttrReflectMethod != 0 }
-func (a Attribute) Local() bool              { return a&AttrLocal != 0 }
-func (a Attribute) Wrapper() bool            { return a&AttrWrapper != 0 }
-func (a Attribute) NeedCtxt() bool           { return a&AttrNeedCtxt != 0 }
-func (a Attribute) NoFrame() bool            { return a&AttrNoFrame != 0 }
-func (a Attribute) Static() bool             { return a&AttrStatic != 0 }
-func (a Attribute) WasInlined() bool         { return a&AttrWasInlined != 0 }
-func (a Attribute) TopFrame() bool           { return a&AttrTopFrame != 0 }
-func (a Attribute) Indexed() bool            { return a&AttrIndexed != 0 }
-func (a Attribute) UsedInIface() bool        { return a&AttrUsedInIface != 0 }
-func (a Attribute) ContentAddressable() bool { return a&AttrContentAddressable != 0 }
-func (a Attribute) ABIWrapper() bool         { return a&AttrABIWrapper != 0 }
+func (a *Attribute) load() Attribute { return Attribute(atomic.LoadUint32((*uint32)(a))) }
+
+func (a *Attribute) DuplicateOK() bool        { return a.load()&AttrDuplicateOK != 0 }
+func (a *Attribute) MakeTypelink() bool       { return a.load()&AttrMakeTypelink != 0 }
+func (a *Attribute) CFunc() bool              { return a.load()&AttrCFunc != 0 }
+func (a *Attribute) NoSplit() bool            { return a.load()&AttrNoSplit != 0 }
+func (a *Attribute) Leaf() bool               { return a.load()&AttrLeaf != 0 }
+func (a *Attribute) OnList() bool             { return a.load()&AttrOnList != 0 }
+func (a *Attribute) ReflectMethod() bool      { return a.load()&AttrReflectMethod != 0 }
+func (a *Attribute) Local() bool              { return a.load()&AttrLocal != 0 }
+func (a *Attribute) Wrapper() bool            { return a.load()&AttrWrapper != 0 }
+func (a *Attribute) NeedCtxt() bool           { return a.load()&AttrNeedCtxt != 0 }
+func (a *Attribute) NoFrame() bool            { return a.load()&AttrNoFrame != 0 }
+func (a *Attribute) Static() bool             { return a.load()&AttrStatic != 0 }
+func (a *Attribute) WasInlined() bool         { return a.load()&AttrWasInlined != 0 }
+func (a *Attribute) TopFrame() bool           { return a.load()&AttrTopFrame != 0 }
+func (a *Attribute) Indexed() bool            { return a.load()&AttrIndexed != 0 }
+func (a *Attribute) UsedInIface() bool        { return a.load()&AttrUsedInIface != 0 }
+func (a *Attribute) ContentAddressable() bool { return a.load()&AttrContentAddressable != 0 }
+func (a *Attribute) ABIWrapper() bool         { return a.load()&AttrABIWrapper != 0 }
 
 func (a *Attribute) Set(flag Attribute, value bool) {
-	if value {
-		*a |= flag
-	} else {
-		*a &^= flag
+	for {
+		v0 := a.load()
+		v := v0
+		if value {
+			v |= flag
+		} else {
+			v &^= flag
+		}
+		if atomic.CompareAndSwapUint32((*uint32)(a), uint32(v0), uint32(v)) {
+			break
+		}
 	}
 }
 
-func (a Attribute) ABI() ABI { return ABI(a / attrABIBase) }
+func (a *Attribute) ABI() ABI { return ABI(a.load() / attrABIBase) }
 func (a *Attribute) SetABI(abi ABI) {
 	const mask = 1 // Only one ABI bit for now.
-	*a = (*a &^ (mask * attrABIBase)) | Attribute(abi)*attrABIBase
+	for {
+		v0 := a.load()
+		v := (v0 &^ (mask * attrABIBase)) | Attribute(abi)*attrABIBase
+		if atomic.CompareAndSwapUint32((*uint32)(a), uint32(v0), uint32(v)) {
+			break
+		}
+	}
 }
 
 var textAttrStrings = [...]struct {
-- 
GitLab


From 120b819f45d1c109a1c2ef380edde9e826862a5c Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 4 Feb 2021 11:16:25 -0500
Subject: [PATCH 0597/2400] [dev.regabi] go/types: report error for invalid
 main function signature

This is a port of CL 279424, which didn't make it into master in time
for go1.16. Move it to dev.regabi so that it may be merged.

Notably, this port no longer removes the _InvalidInitSig error code,
instead opting to deprecate it. Now that error codes are 'locked in' for
go1.16, even if their API may not yet be exposed, we should follow the
practice of not changing their values. In the future, code generation
can make it easier to keep error code values constant.

For #43308

Change-Id: I5260b93fd063393d38d6458e45a67e7f9b7426ed
Reviewed-on: https://go-review.googlesource.com/c/go/+/289714
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/decl.go           | 8 ++++++--
 src/go/types/errorcodes.go     | 7 +++++--
 src/go/types/testdata/main.src | 9 +++++++++
 3 files changed, 20 insertions(+), 4 deletions(-)
 create mode 100644 src/go/types/testdata/main.src

diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index df01e92530..571e172351 100644
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -751,8 +751,12 @@ func (check *Checker) funcDecl(obj *Func, decl *declInfo) {
 	obj.typ = sig // guard against cycles
 	fdecl := decl.fdecl
 	check.funcType(sig, fdecl.Recv, fdecl.Type)
-	if sig.recv == nil && obj.name == "init" && (sig.params.Len() > 0 || sig.results.Len() > 0) {
-		check.errorf(fdecl, _InvalidInitSig, "func init must have no arguments and no return values")
+	if sig.recv == nil {
+		if obj.name == "init" && (sig.params.Len() > 0 || sig.results.Len() > 0) {
+			check.errorf(fdecl, _InvalidInitDecl, "func init must have no arguments and no return values")
+		} else if obj.name == "main" && check.pkg.name == "main" && (sig.params.Len() > 0 || sig.results.Len() > 0) {
+			check.errorf(fdecl, _InvalidMainDecl, "func main must have no arguments and no return values")
+		}
 		// ok to continue
 	}
 
diff --git a/src/go/types/errorcodes.go b/src/go/types/errorcodes.go
index c01a12c346..d27abdf4d4 100644
--- a/src/go/types/errorcodes.go
+++ b/src/go/types/errorcodes.go
@@ -386,8 +386,8 @@ const (
 	// _InvalidInitSig occurs when an init function declares parameters or
 	// results.
 	//
-	// Example:
-	//  func init() int { return 1 }
+	// Deprecated: no longer emitted by the type checker. _InvalidInitDecl is
+	// used instead.
 	_InvalidInitSig
 
 	// _InvalidInitDecl occurs when init is declared as anything other than a
@@ -395,6 +395,9 @@ const (
 	//
 	// Example:
 	//  var init = 1
+	//
+	// Example:
+	//  func init() int { return 1 }
 	_InvalidInitDecl
 
 	// _InvalidMainDecl occurs when main is declared as anything other than a
diff --git a/src/go/types/testdata/main.src b/src/go/types/testdata/main.src
new file mode 100644
index 0000000000..f892938d4a
--- /dev/null
+++ b/src/go/types/testdata/main.src
@@ -0,0 +1,9 @@
+// Copyright 2020 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
+
+func main()
+func /* ERROR "no arguments and no return values" */ main /* ERROR redeclared */ (int)
+func /* ERROR "no arguments and no return values" */ main /* ERROR redeclared */ () int
-- 
GitLab


From 370e9f58432c51bf3d95308cdc7109e25cc141f6 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Fri, 29 Jan 2021 15:29:36 -0800
Subject: [PATCH 0598/2400] [dev.typeparams] cmd/compile/internal/types2: use
 512 bits as max. integer precision

This matches the compiler's existing limitations and thus ensures
that types2 reports the same errors for oversize integer constants.

Change-Id: I4fb7c83f3af69098d96f7b6c53dbe3eaf6ea9ee4
Reviewed-on: https://go-review.googlesource.com/c/go/+/288633
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/typecheck/const.go   |  2 +-
 src/cmd/compile/internal/types2/expr.go       | 45 +++++++++++++++----
 .../compile/internal/types2/stdlib_test.go    |  1 -
 .../internal/types2/testdata/builtins.src     | 10 ++---
 .../internal/types2/testdata/const0.src       | 17 ++++---
 .../internal/types2/testdata/const1.src       | 18 ++++++--
 test/run.go                                   |  1 -
 7 files changed, 69 insertions(+), 25 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/const.go b/src/cmd/compile/internal/typecheck/const.go
index 1a8e58383a..c60d36ba62 100644
--- a/src/cmd/compile/internal/typecheck/const.go
+++ b/src/cmd/compile/internal/typecheck/const.go
@@ -449,7 +449,7 @@ func EvalConst(n ir.Node) ir.Node {
 		n := n.(*ir.BinaryExpr)
 		nl, nr := n.X, n.Y
 		if nl.Op() == ir.OLITERAL && nr.Op() == ir.OLITERAL {
-			// shiftBound from go/types; "so we can express smallestFloat64"
+			// shiftBound from go/types; "so we can express smallestFloat64" (see issue #44057)
 			const shiftBound = 1023 - 1 + 52
 			s, ok := constant.Uint64Val(nr.Val())
 			if !ok || s > shiftBound {
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index a1a626fb33..679495d3f3 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -96,9 +96,7 @@ func (check *Checker) overflow(x *operand) {
 	what := "" // operator description, if any
 	if op, _ := x.expr.(*syntax.Operation); op != nil {
 		pos = op.Pos()
-		if int(op.Op) < len(op2str) {
-			what = op2str[op.Op]
-		}
+		what = opName(op)
 	}
 
 	if x.val.Kind() == constant.Unknown {
@@ -117,15 +115,37 @@ func (check *Checker) overflow(x *operand) {
 	}
 
 	// Untyped integer values must not grow arbitrarily.
-	const limit = 4 * 512 // 512 is the constant precision - we need more because old tests had no limits
-	if x.val.Kind() == constant.Int && constant.BitLen(x.val) > limit {
+	const prec = 512 // 512 is the constant precision
+	if x.val.Kind() == constant.Int && constant.BitLen(x.val) > prec {
 		check.errorf(pos, "constant %s overflow", what)
 		x.val = constant.MakeUnknown()
 	}
 }
 
-// This is only used for operations that may cause overflow.
-var op2str = [...]string{
+// opName returns the name of an operation, or the empty string.
+// For now, only operations that might overflow are handled.
+// TODO(gri) Expand this to a general mechanism giving names to
+//           nodes?
+func opName(e *syntax.Operation) string {
+	op := int(e.Op)
+	if e.Y == nil {
+		if op < len(op2str1) {
+			return op2str1[op]
+		}
+	} else {
+		if op < len(op2str2) {
+			return op2str2[op]
+		}
+	}
+	return ""
+}
+
+// Entries must be "" or end with a space.
+var op2str1 = [...]string{
+	syntax.Xor: "bitwise complement",
+}
+
+var op2str2 = [...]string{
 	syntax.Add: "addition",
 	syntax.Sub: "subtraction",
 	syntax.Xor: "bitwise XOR",
@@ -800,8 +820,17 @@ func (check *Checker) shift(x, y *operand, e syntax.Expr, op syntax.Operator) {
 
 	if x.mode == constant_ {
 		if y.mode == constant_ {
+			// if either x or y has an unknown value, the result is unknown
+			if x.val.Kind() == constant.Unknown || y.val.Kind() == constant.Unknown {
+				x.val = constant.MakeUnknown()
+				// ensure the correct type - see comment below
+				if !isInteger(x.typ) {
+					x.typ = Typ[UntypedInt]
+				}
+				return
+			}
 			// rhs must be within reasonable bounds in constant shifts
-			const shiftBound = 1023 - 1 + 52 // so we can express smallestFloat64
+			const shiftBound = 1023 - 1 + 52 // so we can express smallestFloat64 (see issue #44057)
 			s, ok := constant.Uint64Val(y.val)
 			if !ok || s > shiftBound {
 				check.invalidOpf(y, "invalid shift count %s", y)
diff --git a/src/cmd/compile/internal/types2/stdlib_test.go b/src/cmd/compile/internal/types2/stdlib_test.go
index 1dd3229852..a146619d7e 100644
--- a/src/cmd/compile/internal/types2/stdlib_test.go
+++ b/src/cmd/compile/internal/types2/stdlib_test.go
@@ -182,7 +182,6 @@ func TestStdFixed(t *testing.T) {
 		"issue16369.go",  // go/types handles this correctly - not an issue
 		"issue18459.go",  // go/types doesn't check validity of //go:xxx directives
 		"issue18882.go",  // go/types doesn't check validity of //go:xxx directives
-		"issue20232.go",  // go/types handles larger constants than gc
 		"issue20529.go",  // go/types does not have constraints on stack size
 		"issue22200.go",  // go/types does not have constraints on stack size
 		"issue22200b.go", // go/types does not have constraints on stack size
diff --git a/src/cmd/compile/internal/types2/testdata/builtins.src b/src/cmd/compile/internal/types2/testdata/builtins.src
index e473bd1df2..f866ef059f 100644
--- a/src/cmd/compile/internal/types2/testdata/builtins.src
+++ b/src/cmd/compile/internal/types2/testdata/builtins.src
@@ -514,7 +514,7 @@ func panic1() {
 	panic("foo")
 	panic(false)
 	panic(1<<10)
-	panic(1 /* ERROR overflows */ <<1000)
+	panic(1 << /* ERROR constant shift overflow */ 1000)
 	_ = panic /* ERROR used as value */ (0)
 
 	var s []byte
@@ -538,7 +538,7 @@ func print1() {
 	print(2.718281828)
 	print(false)
 	print(1<<10)
-	print(1 /* ERROR overflows */ <<1000)
+	print(1 << /* ERROR constant shift overflow */ 1000)
 	println(nil /* ERROR untyped nil */ )
 
 	var s []int
@@ -564,7 +564,7 @@ func println1() {
 	println(2.718281828)
 	println(false)
 	println(1<<10)
-	println(1 /* ERROR overflows */ <<1000)
+	println(1 << /* ERROR constant shift overflow */ 1000)
 	println(nil /* ERROR untyped nil */ )
 
 	var s []int
@@ -695,7 +695,7 @@ func Alignof1() {
 	_ = unsafe.Alignof(42)
 	_ = unsafe.Alignof(new(struct{}))
 	_ = unsafe.Alignof(1<<10)
-	_ = unsafe.Alignof(1 /* ERROR overflows */ <<1000)
+	_ = unsafe.Alignof(1 << /* ERROR constant shift overflow */ 1000)
 	_ = unsafe.Alignof(nil /* ERROR "untyped nil */ )
 	unsafe /* ERROR not used */ .Alignof(x)
 
@@ -783,7 +783,7 @@ func Sizeof1() {
 	_ = unsafe.Sizeof(42)
 	_ = unsafe.Sizeof(new(complex128))
 	_ = unsafe.Sizeof(1<<10)
-	_ = unsafe.Sizeof(1 /* ERROR overflows */ <<1000)
+	_ = unsafe.Sizeof(1 << /* ERROR constant shift overflow */ 1000)
 	_ = unsafe.Sizeof(nil /* ERROR untyped nil */ )
 	unsafe /* ERROR not used */ .Sizeof(x)
 
diff --git a/src/cmd/compile/internal/types2/testdata/const0.src b/src/cmd/compile/internal/types2/testdata/const0.src
index 9e0de93d54..5608b1549b 100644
--- a/src/cmd/compile/internal/types2/testdata/const0.src
+++ b/src/cmd/compile/internal/types2/testdata/const0.src
@@ -350,9 +350,14 @@ const _ = unsafe.Sizeof(func() {
 })
 
 // untyped constants must not get arbitrarily large
-const (
-	huge = 1<<1000
-	// TODO(gri) here the errors should be at the last operator not the last operand
-	_ = huge * huge * huge   // ERROR constant multiplication overflow
-	_ = huge << 1000 << 1000 // ERROR constant shift overflow
-)
+const prec = 512 // internal maximum precision for integers
+const maxInt = (1<<(prec/2) - 1) * (1<<(prec/2) + 1) // == 1<<prec - 1
+
+const _ = maxInt + /* ERROR constant addition overflow */ 1
+const _ = -maxInt - /* ERROR constant subtraction overflow */ 1
+const _ = maxInt ^ /* ERROR constant bitwise XOR overflow */ -1
+const _ = maxInt * /* ERROR constant multiplication overflow */ 2
+const _ = maxInt << /* ERROR constant shift overflow */ 2
+const _ = 1 << /* ERROR constant shift overflow */ prec
+
+const _ = ^ /* ERROR constant bitwise complement overflow */ maxInt
diff --git a/src/cmd/compile/internal/types2/testdata/const1.src b/src/cmd/compile/internal/types2/testdata/const1.src
index d82770464f..56b6bd4ca5 100644
--- a/src/cmd/compile/internal/types2/testdata/const1.src
+++ b/src/cmd/compile/internal/types2/testdata/const1.src
@@ -43,7 +43,12 @@ const (
 
 const (
 	smallestFloat32 = 1.0 / (1<<(127 - 1 + 23))
-	smallestFloat64 = 1.0 / (1<<(1023 - 1 + 52))
+	// TODO(gri) The compiler limits integers to 512 bit and thus
+	//           we cannot compute the value (1<<(1023 - 1 + 52))
+	//           without overflow. For now we match the compiler.
+	//           See also issue #44057.
+	// smallestFloat64 = 1.0 / (1<<(1023 - 1 + 52))
+	smallestFloat64 = 4.940656458412465441765687928682213723651e-324
 )
 
 const (
@@ -53,7 +58,12 @@ const (
 
 const (
 	maxFloat32 = 1<<127 * (1<<24 - 1) / (1.0<<23)
-	maxFloat64 = 1<<1023 * (1<<53 - 1) / (1.0<<52)
+	// TODO(gri) The compiler limits integers to 512 bit and thus
+	//           we cannot compute the value 1<<1023
+	//           without overflow. For now we match the compiler.
+	//           See also issue #44057.
+	// maxFloat64 = 1<<1023 * (1<<53 - 1) / (1.0<<52)
+	maxFloat64 = 1.797693134862315708145274237317043567981e+308
 )
 
 const (
@@ -271,7 +281,9 @@ const (
 	_ = assert(float64(smallestFloat32) == smallestFloat32)
 	_ = assert(float64(smallestFloat32/2) == smallestFloat32/2)
 	_ = assert(float64(smallestFloat64) == smallestFloat64)
-	_ = assert(float64(smallestFloat64/2) == 0)
+	// TODO(gri) With the change to the declaration of smallestFloat64
+	//           this now fails to be true. See issue #44058.
+	// _ = assert(float64(smallestFloat64/2) == 0)
 )
 
 const (
diff --git a/test/run.go b/test/run.go
index 30cab82301..492d9de5a6 100644
--- a/test/run.go
+++ b/test/run.go
@@ -1978,5 +1978,4 @@ var excluded = map[string]bool{
 	"fixedbugs/issue7525c.go":  true, // types2 reports init cycle error on different line - ok otherwise
 	"fixedbugs/issue7525d.go":  true, // types2 reports init cycle error on different line - ok otherwise
 	"fixedbugs/issue7525e.go":  true, // types2 reports init cycle error on different line - ok otherwise
-	"fixedbugs/issue7746.go":   true, // types2 reports overflow on a different line
 }
-- 
GitLab


From 1ff2fdaaf189e0d7ec73bdbff72558363239f48b Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 3 Feb 2021 14:56:13 -0800
Subject: [PATCH 0599/2400] [dev.typeparams] cmd/compile/internal/types2: add
 support for language version checking

Add the Config.Lang field which may be set to a Go version string,
such as "go1.12". This is a string rather than explicit semantic
version numbers (such as {1, 12}) for API robustness; a string
is more flexible should we need more or different information.

Add -lang flag to types2 package for use with (manual) testing
when running "go test -run Check$ -lang=... -files=...".

While changing flags, look for comma-separated (rather than space-
separated) files when providing the -file flag.

Check that numeric constant literals, signed shift counts are
accepted according to the selected language version.

Type alias declarations and overlapping embedded interfaces are
not yet checked.

Updates #31793.

Change-Id: I9ff238ed38a88f377eb2267dc3e8816b89a40635
Reviewed-on: https://go-review.googlesource.com/c/go/+/289509
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/api.go        |  7 ++
 src/cmd/compile/internal/types2/check.go      | 37 +++++----
 src/cmd/compile/internal/types2/check_test.go | 32 ++++++--
 src/cmd/compile/internal/types2/expr.go       |  5 ++
 .../compile/internal/types2/stdlib_test.go    | 10 ++-
 .../internal/types2/testdata/go1_12.src       | 34 ++++++++
 src/cmd/compile/internal/types2/version.go    | 81 +++++++++++++++++++
 7 files changed, 183 insertions(+), 23 deletions(-)
 create mode 100644 src/cmd/compile/internal/types2/testdata/go1_12.src
 create mode 100644 src/cmd/compile/internal/types2/version.go

diff --git a/src/cmd/compile/internal/types2/api.go b/src/cmd/compile/internal/types2/api.go
index b29c0802ed..30f0430ff1 100644
--- a/src/cmd/compile/internal/types2/api.go
+++ b/src/cmd/compile/internal/types2/api.go
@@ -99,6 +99,13 @@ type ImporterFrom interface {
 // A Config specifies the configuration for type checking.
 // The zero value for Config is a ready-to-use default configuration.
 type Config struct {
+	// GoVersion describes the accepted Go language version. The string
+	// must follow the format "go%d.%d" (e.g. "go1.12") or ist must be
+	// empty; an empty string indicates the latest language version.
+	// If the format is invalid, invoking the type checker will cause a
+	// panic.
+	GoVersion string
+
 	// If IgnoreFuncBodies is set, function bodies are not
 	// type-checked.
 	IgnoreFuncBodies bool
diff --git a/src/cmd/compile/internal/types2/check.go b/src/cmd/compile/internal/types2/check.go
index e2c6c4f606..95fb4e1076 100644
--- a/src/cmd/compile/internal/types2/check.go
+++ b/src/cmd/compile/internal/types2/check.go
@@ -88,12 +88,13 @@ type Checker struct {
 	conf *Config
 	pkg  *Package
 	*Info
-	nextId uint64                      // unique Id for type parameters (first valid Id is 1)
-	objMap map[Object]*declInfo        // maps package-level objects and (non-interface) methods to declaration info
-	impMap map[importKey]*Package      // maps (import path, source directory) to (complete or fake) package
-	posMap map[*Interface][]syntax.Pos // maps interface types to lists of embedded interface positions
-	typMap map[string]*Named           // maps an instantiated named type hash to a *Named type
-	pkgCnt map[string]int              // counts number of imported packages with a given name (for better error messages)
+	version version                     // accepted language version
+	nextId  uint64                      // unique Id for type parameters (first valid Id is 1)
+	objMap  map[Object]*declInfo        // maps package-level objects and (non-interface) methods to declaration info
+	impMap  map[importKey]*Package      // maps (import path, source directory) to (complete or fake) package
+	posMap  map[*Interface][]syntax.Pos // maps interface types to lists of embedded interface positions
+	typMap  map[string]*Named           // maps an instantiated named type hash to a *Named type
+	pkgCnt  map[string]int              // counts number of imported packages with a given name (for better error messages)
 
 	// information collected during type-checking of a set of package files
 	// (initialized by Files, valid only for the duration of check.Files;
@@ -182,16 +183,22 @@ func NewChecker(conf *Config, pkg *Package, info *Info) *Checker {
 		info = new(Info)
 	}
 
+	version, err := parseGoVersion(conf.GoVersion)
+	if err != nil {
+		panic(fmt.Sprintf("invalid Go version %q (%v)", conf.GoVersion, err))
+	}
+
 	return &Checker{
-		conf:   conf,
-		pkg:    pkg,
-		Info:   info,
-		nextId: 1,
-		objMap: make(map[Object]*declInfo),
-		impMap: make(map[importKey]*Package),
-		posMap: make(map[*Interface][]syntax.Pos),
-		typMap: make(map[string]*Named),
-		pkgCnt: make(map[string]int),
+		conf:    conf,
+		pkg:     pkg,
+		Info:    info,
+		version: version,
+		nextId:  1,
+		objMap:  make(map[Object]*declInfo),
+		impMap:  make(map[importKey]*Package),
+		posMap:  make(map[*Interface][]syntax.Pos),
+		typMap:  make(map[string]*Named),
+		pkgCnt:  make(map[string]int),
 	}
 }
 
diff --git a/src/cmd/compile/internal/types2/check_test.go b/src/cmd/compile/internal/types2/check_test.go
index b03b074b6d..9c1d278520 100644
--- a/src/cmd/compile/internal/types2/check_test.go
+++ b/src/cmd/compile/internal/types2/check_test.go
@@ -44,7 +44,8 @@ import (
 var (
 	haltOnError = flag.Bool("halt", false, "halt on error")
 	listErrors  = flag.Bool("errlist", false, "list errors")
-	testFiles   = flag.String("files", "", "space-separated list of test files")
+	testFiles   = flag.String("files", "", "comma-separated list of test files")
+	goVersion   = flag.String("lang", "", "Go language version (e.g. \"go1.12\"")
 )
 
 func parseFiles(t *testing.T, filenames []string, mode syntax.Mode) ([]*syntax.File, []error) {
@@ -83,7 +84,21 @@ func delta(x, y uint) uint {
 	}
 }
 
-func checkFiles(t *testing.T, sources []string, colDelta uint, trace bool) {
+// goVersionRx matches a Go version string using '_', e.g. "go1_12".
+var goVersionRx = regexp.MustCompile(`^go[1-9][0-9]*_(0|[1-9][0-9]*)$`)
+
+// asGoVersion returns a regular Go language version string
+// if s is a Go version string using '_' rather than '.' to
+// separate the major and minor version numbers (e.g. "go1_12").
+// Otherwise it returns the empty string.
+func asGoVersion(s string) string {
+	if goVersionRx.MatchString(s) {
+		return strings.Replace(s, "_", ".", 1)
+	}
+	return ""
+}
+
+func checkFiles(t *testing.T, sources []string, goVersion string, colDelta uint, trace bool) {
 	if len(sources) == 0 {
 		t.Fatal("no source files")
 	}
@@ -100,6 +115,11 @@ func checkFiles(t *testing.T, sources []string, colDelta uint, trace bool) {
 		pkgName = files[0].PkgName.Value
 	}
 
+	// if no Go version is given, consider the package name
+	if goVersion == "" {
+		goVersion = asGoVersion(pkgName)
+	}
+
 	if *listErrors && len(errlist) > 0 {
 		t.Errorf("--- %s:", pkgName)
 		for _, err := range errlist {
@@ -109,6 +129,7 @@ func checkFiles(t *testing.T, sources []string, colDelta uint, trace bool) {
 
 	// typecheck and collect typechecker errors
 	var conf Config
+	conf.GoVersion = goVersion
 	conf.AcceptMethodTypeParams = true
 	conf.InferFromConstraints = true
 	// special case for importC.src
@@ -220,13 +241,14 @@ func checkFiles(t *testing.T, sources []string, colDelta uint, trace bool) {
 }
 
 // TestCheck is for manual testing of selected input files, provided with -files.
+// The accepted Go language version can be controlled with the -lang flag.
 func TestCheck(t *testing.T) {
 	if *testFiles == "" {
 		return
 	}
 	testenv.MustHaveGoBuild(t)
 	DefPredeclaredTestFuncs()
-	checkFiles(t, strings.Split(*testFiles, " "), 0, testing.Verbose())
+	checkFiles(t, strings.Split(*testFiles, ","), *goVersion, 0, testing.Verbose())
 }
 
 func TestTestdata(t *testing.T)  { DefPredeclaredTestFuncs(); testDir(t, 75, "testdata") } // TODO(gri) narrow column tolerance
@@ -263,7 +285,7 @@ func testDir(t *testing.T, colDelta uint, dir string) {
 					fmt.Printf("\t%s\n", files[i])
 				}
 			}
-			checkFiles(t, files, colDelta, false)
+			checkFiles(t, files, "", colDelta, false)
 			continue
 		}
 
@@ -271,6 +293,6 @@ func testDir(t *testing.T, colDelta uint, dir string) {
 		if testing.Verbose() {
 			fmt.Printf("%3d %s\n", count, path)
 		}
-		checkFiles(t, []string{path}, colDelta, false)
+		checkFiles(t, []string{path}, "", colDelta, false)
 	}
 }
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 679495d3f3..9889e3113d 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -816,6 +816,10 @@ func (check *Checker) shift(x, y *operand, e syntax.Expr, op syntax.Operator) {
 		check.invalidOpf(y, "shift count %s must be integer", y)
 		x.mode = invalid
 		return
+	} else if !isUnsigned(y.typ) && !check.allowVersion(check.pkg, 1, 13) {
+		check.invalidOpf(y, "signed shift count %s requires go1.13 or later", y)
+		x.mode = invalid
+		return
 	}
 
 	if x.mode == constant_ {
@@ -1185,6 +1189,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 		}
 		switch e.Kind {
 		case syntax.IntLit, syntax.FloatLit, syntax.ImagLit:
+			check.langCompat(e)
 			// The max. mantissa precision for untyped numeric values
 			// is 512 bits, or 4048 bits for each of the two integer
 			// parts of a fraction for floating-point numbers that are
diff --git a/src/cmd/compile/internal/types2/stdlib_test.go b/src/cmd/compile/internal/types2/stdlib_test.go
index a146619d7e..2949e23019 100644
--- a/src/cmd/compile/internal/types2/stdlib_test.go
+++ b/src/cmd/compile/internal/types2/stdlib_test.go
@@ -110,6 +110,7 @@ func testTestDir(t *testing.T, path string, ignore ...string) {
 		// get per-file instructions
 		expectErrors := false
 		filename := filepath.Join(path, f.Name())
+		goVersion := ""
 		if comment := firstComment(filename); comment != "" {
 			fields := strings.Fields(comment)
 			switch fields[0] {
@@ -119,13 +120,17 @@ func testTestDir(t *testing.T, path string, ignore ...string) {
 				expectErrors = true
 				for _, arg := range fields[1:] {
 					if arg == "-0" || arg == "-+" || arg == "-std" {
-						// Marked explicitly as not expected errors (-0),
+						// Marked explicitly as not expecting errors (-0),
 						// or marked as compiling runtime/stdlib, which is only done
 						// to trigger runtime/stdlib-only error output.
 						// In both cases, the code should typecheck.
 						expectErrors = false
 						break
 					}
+					const prefix = "-lang="
+					if strings.HasPrefix(arg, prefix) {
+						goVersion = arg[len(prefix):]
+					}
 				}
 			}
 		}
@@ -136,7 +141,7 @@ func testTestDir(t *testing.T, path string, ignore ...string) {
 		}
 		file, err := syntax.ParseFile(filename, nil, nil, 0)
 		if err == nil {
-			conf := Config{Importer: stdLibImporter}
+			conf := Config{GoVersion: goVersion, Importer: stdLibImporter}
 			_, err = conf.Check(filename, []*syntax.File{file}, nil)
 		}
 
@@ -187,7 +192,6 @@ func TestStdFixed(t *testing.T) {
 		"issue22200b.go", // go/types does not have constraints on stack size
 		"issue25507.go",  // go/types does not have constraints on stack size
 		"issue20780.go",  // go/types does not have constraints on stack size
-		"issue31747.go",  // go/types does not have constraints on language level (-lang=go1.12) (see #31793)
 		"issue34329.go",  // go/types does not have constraints on language level (-lang=go1.13) (see #31793)
 		"issue42058a.go", // go/types does not have constraints on channel element size
 		"issue42058b.go", // go/types does not have constraints on channel element size
diff --git a/src/cmd/compile/internal/types2/testdata/go1_12.src b/src/cmd/compile/internal/types2/testdata/go1_12.src
new file mode 100644
index 0000000000..75a602b8ff
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/go1_12.src
@@ -0,0 +1,34 @@
+// Copyright 2021 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.
+
+// Check Go language version-specific errors.
+
+package go1_12 // go1.12
+
+// numeric literals
+const (
+	_ = 1_000 // ERROR "underscores in numeric literals requires go1.13 or later"
+	_ = 0b111 // ERROR "binary literals requires go1.13 or later"
+	_ = 0o567 // ERROR "0o/0O-style octal literals requires go1.13 or later"
+	_ = 0xabc // ok
+	_ = 0x0p1 // ERROR "hexadecimal floating-point literals requires go1.13 or later"
+
+	_ = 0B111 // ERROR "binary"
+	_ = 0O567 // ERROR "octal"
+	_ = 0Xabc // ok
+	_ = 0X0P1 // ERROR "hexadecimal floating-point"
+
+	_ = 1_000i // ERROR "underscores"
+	_ = 0b111i // ERROR "binary"
+	_ = 0o567i // ERROR "octal"
+	_ = 0xabci // ERROR "hexadecimal floating-point"
+	_ = 0x0p1i // ERROR "hexadecimal floating-point"
+)
+
+// signed shift counts
+var (
+	s int
+	_ = 1 << s // ERROR "invalid operation: signed shift count s \(variable of type int\) requires go1.13 or later"
+	_ = 1 >> s // ERROR "signed shift count"
+)
diff --git a/src/cmd/compile/internal/types2/version.go b/src/cmd/compile/internal/types2/version.go
new file mode 100644
index 0000000000..cb497f048e
--- /dev/null
+++ b/src/cmd/compile/internal/types2/version.go
@@ -0,0 +1,81 @@
+// Copyright 2021 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 types2
+
+import (
+	"cmd/compile/internal/syntax"
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// langCompat reports an error if the representation of a numeric
+// literal is not compatible with the current language version.
+func (check *Checker) langCompat(lit *syntax.BasicLit) {
+	s := lit.Value
+	if len(s) <= 2 || check.allowVersion(check.pkg, 1, 13) {
+		return
+	}
+	// len(s) > 2
+	if strings.Contains(s, "_") {
+		check.errorf(lit, "underscores in numeric literals requires go1.13 or later")
+		return
+	}
+	if s[0] != '0' {
+		return
+	}
+	radix := s[1]
+	if radix == 'b' || radix == 'B' {
+		check.errorf(lit, "binary literals requires go1.13 or later")
+		return
+	}
+	if radix == 'o' || radix == 'O' {
+		check.errorf(lit, "0o/0O-style octal literals requires go1.13 or later")
+		return
+	}
+	if lit.Kind != syntax.IntLit && (radix == 'x' || radix == 'X') {
+		check.errorf(lit, "hexadecimal floating-point literals requires go1.13 or later")
+	}
+}
+
+// allowVersion reports whether the given package
+// is allowed to use version major.minor.
+func (check *Checker) allowVersion(pkg *Package, major, minor int) bool {
+	// We assume that imported packages have all been checked,
+	// so we only have to check for the local package.
+	if pkg != check.pkg {
+		return true
+	}
+	ma, mi := check.version.major, check.version.minor
+	return ma == 0 && mi == 0 || ma > major || ma == major && mi >= minor
+}
+
+type version struct {
+	major, minor int
+}
+
+// parseGoVersion parses a Go version string (such as "go1.12")
+// and returns the version, or an error. If s is the empty
+// string, the version is 0.0.
+func parseGoVersion(s string) (v version, err error) {
+	if s == "" {
+		return
+	}
+	matches := goVersionRx.FindStringSubmatch(s)
+	if matches == nil {
+		err = fmt.Errorf(`should be something like "go1.12"`)
+		return
+	}
+	v.major, err = strconv.Atoi(matches[1])
+	if err != nil {
+		return
+	}
+	v.minor, err = strconv.Atoi(matches[2])
+	return
+}
+
+// goVersionRx matches a Go version string, e.g. "go1.12".
+var goVersionRx = regexp.MustCompile(`^go([1-9][0-9]*)\.(0|[1-9][0-9]*)$`)
-- 
GitLab


From 721488498ad91612dc8888be61e661c11707d891 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 3 Feb 2021 22:14:04 -0800
Subject: [PATCH 0600/2400] [dev.typeparams] cmd/compile: pass -lang flag value
 to new type checker

This enables another test.

Change-Id: I80763b97d939e225158a083299b2e0d189268bc7
Reviewed-on: https://go-review.googlesource.com/c/go/+/289569
Trust: Robert Griesemer <gri@golang.org>
Trust: Dan Scales <danscales@google.com>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/noder/irgen.go | 1 +
 test/fixedbugs/issue31747.go            | 4 ++--
 test/run.go                             | 1 -
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/noder/irgen.go b/src/cmd/compile/internal/noder/irgen.go
index 1cef98742d..475e3bbddd 100644
--- a/src/cmd/compile/internal/noder/irgen.go
+++ b/src/cmd/compile/internal/noder/irgen.go
@@ -35,6 +35,7 @@ func check2(noders []*noder) {
 
 	// typechecking
 	conf := types2.Config{
+		GoVersion:             base.Flag.Lang,
 		InferFromConstraints:  true,
 		IgnoreLabels:          true, // parser already checked via syntax.CheckBranches mode
 		CompilerErrorMessages: true, // use error strings matching existing compiler errors
diff --git a/test/fixedbugs/issue31747.go b/test/fixedbugs/issue31747.go
index 420fe30735..319a721337 100644
--- a/test/fixedbugs/issue31747.go
+++ b/test/fixedbugs/issue31747.go
@@ -8,7 +8,7 @@ package p
 
 // numeric literals
 const (
-	_ = 1_000 // ERROR "underscores in numeric literals requires go1.13 or later \(-lang was set to go1.12; check go.mod\)"
+	_ = 1_000 // ERROR "underscores in numeric literals requires go1.13 or later \(-lang was set to go1.12; check go.mod\)|requires go1.13"
 	_ = 0b111 // ERROR "binary literals requires go1.13 or later"
 	_ = 0o567 // ERROR "0o/0O-style octal literals requires go1.13 or later"
 	_ = 0xabc // ok
@@ -29,6 +29,6 @@ const (
 // signed shift counts
 var (
 	s int
-	_ = 1 << s // ERROR "invalid operation: 1 << s \(signed shift count type int\) requires go1.13 or later"
+	_ = 1 << s // ERROR "invalid operation: 1 << s \(signed shift count type int\) requires go1.13 or later|signed shift count"
 	_ = 1 >> s // ERROR "signed shift count"
 )
diff --git a/test/run.go b/test/run.go
index 492d9de5a6..b1d6fe2414 100644
--- a/test/run.go
+++ b/test/run.go
@@ -1963,7 +1963,6 @@ var excluded = map[string]bool{
 	"fixedbugs/issue25958.go":  true, // types2 doesn't report a follow-on error (pref: types2)
 	"fixedbugs/issue28079b.go": true, // types2 reports follow-on errors
 	"fixedbugs/issue28268.go":  true, // types2 reports follow-on errors
-	"fixedbugs/issue31747.go":  true, // types2 is missing support for -lang flag
 	"fixedbugs/issue33460.go":  true, // types2 reports alternative positions in separate error
 	"fixedbugs/issue34329.go":  true, // types2 is missing support for -lang flag
 	"fixedbugs/issue41575.go":  true, // types2 reports alternative positions in separate error
-- 
GitLab


From f37b0c6c12072edef19569c7f0b456ab7e570385 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 3 Feb 2021 22:34:34 -0800
Subject: [PATCH 0601/2400] [dev.typeparams] cmd/compile/internal/types2: type
 alias decl requires go1.9

Add respective check to type checker.
Remove respective check from the compiler's new type2-based noder.

Updates #31793.

Change-Id: I907e3acab4c136027a8c3db1e9bac301d209c2e1
Reviewed-on: https://go-review.googlesource.com/c/go/+/289570
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/noder/decl.go             |  4 ----
 src/cmd/compile/internal/types2/decl.go            |  3 +++
 src/cmd/compile/internal/types2/testdata/go1_8.src | 10 ++++++++++
 3 files changed, 13 insertions(+), 4 deletions(-)
 create mode 100644 src/cmd/compile/internal/types2/testdata/go1_8.src

diff --git a/src/cmd/compile/internal/noder/decl.go b/src/cmd/compile/internal/noder/decl.go
index 9862f452fd..a1596be4a4 100644
--- a/src/cmd/compile/internal/noder/decl.go
+++ b/src/cmd/compile/internal/noder/decl.go
@@ -102,10 +102,6 @@ func (g *irgen) funcDecl(out *ir.Nodes, decl *syntax.FuncDecl) {
 
 func (g *irgen) typeDecl(out *ir.Nodes, decl *syntax.TypeDecl) {
 	if decl.Alias {
-		if !types.AllowsGoVersion(types.LocalPkg, 1, 9) {
-			base.ErrorfAt(g.pos(decl), "type aliases only supported as of -lang=go1.9")
-		}
-
 		name, _ := g.def(decl.Name)
 		g.pragmaFlags(decl.Pragma, 0)
 
diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index 0b7956f287..59d0a112b1 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -629,6 +629,9 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *syntax.TypeDecl, def *Named
 
 	if alias {
 		// type alias declaration
+		if !check.allowVersion(obj.pkg, 1, 9) {
+			check.errorf(tdecl, "type aliases requires go1.9 or later")
+		}
 
 		obj.typ = Typ[Invalid]
 		obj.typ = check.anyType(tdecl.Type)
diff --git a/src/cmd/compile/internal/types2/testdata/go1_8.src b/src/cmd/compile/internal/types2/testdata/go1_8.src
new file mode 100644
index 0000000000..0f3ba9443b
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/go1_8.src
@@ -0,0 +1,10 @@
+// Copyright 2021 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.
+
+// Check Go language version-specific errors.
+
+package go1_8 // go1.8
+
+// type alias declarations
+type any /* ERROR type aliases requires go1.9 or later */ = interface{}
-- 
GitLab


From 63de2110148eec432c4954dced7ff674a4942115 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 2 Feb 2021 17:26:57 -0500
Subject: [PATCH 0602/2400] [dev.regabi] runtime/cgo: call setg_gcc in
 crosscall_amd64

Currently, when using cgo, the g pointer is set via a separate
call to setg_gcc or with inline assembly in threadentry. This CL
changes it to call setg_gcc in crosscall_amd64, like other g-
register platforms. When we have an actual g register on AMD64,
we'll need to set the register immediately before calling into
Go.

Change-Id: Ib1171e05cd0dabba3b7d12e072084d141051cf3d
Reviewed-on: https://go-review.googlesource.com/c/go/+/289192
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/runtime/cgo/gcc_amd64.S           |  7 ++++++-
 src/runtime/cgo/gcc_darwin_amd64.c    | 11 +++++------
 src/runtime/cgo/gcc_dragonfly_amd64.c |  7 +------
 src/runtime/cgo/gcc_freebsd_amd64.c   |  7 +------
 src/runtime/cgo/gcc_linux_amd64.c     |  7 +------
 src/runtime/cgo/gcc_netbsd_amd64.c    |  7 +------
 src/runtime/cgo/gcc_openbsd_amd64.c   |  7 +------
 src/runtime/cgo/gcc_solaris_amd64.c   |  7 +------
 src/runtime/cgo/gcc_windows_amd64.c   | 10 +++++-----
 src/runtime/cgo/libcgo.h              |  2 +-
 10 files changed, 23 insertions(+), 49 deletions(-)

diff --git a/src/runtime/cgo/gcc_amd64.S b/src/runtime/cgo/gcc_amd64.S
index 17d9d47ef4..d75f864666 100644
--- a/src/runtime/cgo/gcc_amd64.S
+++ b/src/runtime/cgo/gcc_amd64.S
@@ -30,9 +30,14 @@ EXT(crosscall_amd64):
 	pushq %r15
 
 #if defined(_WIN64)
+	movq %r8, %rdi	/* arg of setg_gcc */
+	call *%rdx	/* setg_gcc */
 	call *%rcx	/* fn */
 #else
-	call *%rdi	/* fn */
+	movq %rdi, %rbx
+	movq %rdx, %rdi	/* arg of setg_gcc */
+	call *%rsi	/* setg_gcc */
+	call *%rbx	/* fn */
 #endif
 
 	popq %r15
diff --git a/src/runtime/cgo/gcc_darwin_amd64.c b/src/runtime/cgo/gcc_darwin_amd64.c
index 51410d5026..d5b7fd8fd8 100644
--- a/src/runtime/cgo/gcc_darwin_amd64.c
+++ b/src/runtime/cgo/gcc_darwin_amd64.c
@@ -9,13 +9,16 @@
 #include "libcgo_unix.h"
 
 static void* threadentry(void*);
+static void (*setg_gcc)(void*);
 
 void
-x_cgo_init(G *g)
+x_cgo_init(G *g, void (*setg)(void*), void **tlsg, void **tlsbase)
 {
 	pthread_attr_t attr;
 	size_t size;
 
+	setg_gcc = setg;
+
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
 	g->stacklo = (uintptr)&attr - size + 4096;
@@ -57,10 +60,6 @@ threadentry(void *v)
 	ts = *(ThreadStart*)v;
 	free(v);
 
-	// Move the g pointer into the slot reserved in thread local storage.
-	// Constant must match the one in cmd/link/internal/ld/sym.go.
-	asm volatile("movq %0, %%gs:0x30" :: "r"(ts.g));
-
-	crosscall_amd64(ts.fn);
+	crosscall_amd64(ts.fn, setg_gcc, (void*)ts.g);
 	return nil;
 }
diff --git a/src/runtime/cgo/gcc_dragonfly_amd64.c b/src/runtime/cgo/gcc_dragonfly_amd64.c
index d25db91900..0003414bf8 100644
--- a/src/runtime/cgo/gcc_dragonfly_amd64.c
+++ b/src/runtime/cgo/gcc_dragonfly_amd64.c
@@ -61,11 +61,6 @@ threadentry(void *v)
 	ts = *(ThreadStart*)v;
 	free(v);
 
-	/*
-	 * Set specific keys.
-	 */
-	setg_gcc((void*)ts.g);
-
-	crosscall_amd64(ts.fn);
+	crosscall_amd64(ts.fn, setg_gcc, (void*)ts.g);
 	return nil;
 }
diff --git a/src/runtime/cgo/gcc_freebsd_amd64.c b/src/runtime/cgo/gcc_freebsd_amd64.c
index 514a2f8a23..6071ec3909 100644
--- a/src/runtime/cgo/gcc_freebsd_amd64.c
+++ b/src/runtime/cgo/gcc_freebsd_amd64.c
@@ -69,11 +69,6 @@ threadentry(void *v)
 	free(v);
 	_cgo_tsan_release();
 
-	/*
-	 * Set specific keys.
-	 */
-	setg_gcc((void*)ts.g);
-
-	crosscall_amd64(ts.fn);
+	crosscall_amd64(ts.fn, setg_gcc, (void*)ts.g);
 	return nil;
 }
diff --git a/src/runtime/cgo/gcc_linux_amd64.c b/src/runtime/cgo/gcc_linux_amd64.c
index f2bf6482cb..c25e7e769b 100644
--- a/src/runtime/cgo/gcc_linux_amd64.c
+++ b/src/runtime/cgo/gcc_linux_amd64.c
@@ -89,11 +89,6 @@ threadentry(void *v)
 	free(v);
 	_cgo_tsan_release();
 
-	/*
-	 * Set specific keys.
-	 */
-	setg_gcc((void*)ts.g);
-
-	crosscall_amd64(ts.fn);
+	crosscall_amd64(ts.fn, setg_gcc, (void*)ts.g);
 	return nil;
 }
diff --git a/src/runtime/cgo/gcc_netbsd_amd64.c b/src/runtime/cgo/gcc_netbsd_amd64.c
index dc966fc45b..9f4b031a08 100644
--- a/src/runtime/cgo/gcc_netbsd_amd64.c
+++ b/src/runtime/cgo/gcc_netbsd_amd64.c
@@ -62,11 +62,6 @@ threadentry(void *v)
 	ts = *(ThreadStart*)v;
 	free(v);
 
-	/*
-	 * Set specific keys.
-	 */
-	setg_gcc((void*)ts.g);
-
 	// On NetBSD, a new thread inherits the signal stack of the
 	// creating thread. That confuses minit, so we remove that
 	// signal stack here before calling the regular mstart. It's
@@ -78,6 +73,6 @@ threadentry(void *v)
 	ss.ss_flags = SS_DISABLE;
 	sigaltstack(&ss, nil);
 
-	crosscall_amd64(ts.fn);
+	crosscall_amd64(ts.fn, setg_gcc, (void*)ts.g);
 	return nil;
 }
diff --git a/src/runtime/cgo/gcc_openbsd_amd64.c b/src/runtime/cgo/gcc_openbsd_amd64.c
index 34319fb0b8..09d2750f3a 100644
--- a/src/runtime/cgo/gcc_openbsd_amd64.c
+++ b/src/runtime/cgo/gcc_openbsd_amd64.c
@@ -60,11 +60,6 @@ threadentry(void *v)
 	ts = *(ThreadStart*)v;
 	free(v);
 
-	/*
-	 * Set specific keys.
-	 */
-	setg_gcc((void*)ts.g);
-
-	crosscall_amd64(ts.fn);
+	crosscall_amd64(ts.fn, setg_gcc, (void*)ts.g);
 	return nil;
 }
diff --git a/src/runtime/cgo/gcc_solaris_amd64.c b/src/runtime/cgo/gcc_solaris_amd64.c
index 079bd12898..e89e844b1e 100644
--- a/src/runtime/cgo/gcc_solaris_amd64.c
+++ b/src/runtime/cgo/gcc_solaris_amd64.c
@@ -72,11 +72,6 @@ threadentry(void *v)
 	ts = *(ThreadStart*)v;
 	free(v);
 
-	/*
-	 * Set specific keys.
-	 */
-	setg_gcc((void*)ts.g);
-
-	crosscall_amd64(ts.fn);
+	crosscall_amd64(ts.fn, setg_gcc, (void*)ts.g);
 	return nil;
 }
diff --git a/src/runtime/cgo/gcc_windows_amd64.c b/src/runtime/cgo/gcc_windows_amd64.c
index 0f8c817f0e..25cfd086dd 100644
--- a/src/runtime/cgo/gcc_windows_amd64.c
+++ b/src/runtime/cgo/gcc_windows_amd64.c
@@ -12,10 +12,12 @@
 #include "libcgo_windows.h"
 
 static void threadentry(void*);
+static void (*setg_gcc)(void*);
 
 void
-x_cgo_init(G *g)
+x_cgo_init(G *g, void (*setg)(void*), void **tlsg, void **tlsbase)
 {
+	setg_gcc = setg;
 }
 
 
@@ -46,10 +48,8 @@ threadentry(void *v)
 	 */
 	asm volatile (
 	  "movq %0, %%gs:0x28\n"	// MOVL tls0, 0x28(GS)
-	  "movq %%gs:0x28, %%rax\n" // MOVQ 0x28(GS), tmp
-	  "movq %1, 0(%%rax)\n" // MOVQ g, 0(GS)
-	  :: "r"(ts.tls), "r"(ts.g) : "%rax"
+	  :: "r"(ts.tls)
 	);
 
-	crosscall_amd64(ts.fn);
+	crosscall_amd64(ts.fn, setg_gcc, (void*)ts.g);
 }
diff --git a/src/runtime/cgo/libcgo.h b/src/runtime/cgo/libcgo.h
index aba500a301..af4960e7e9 100644
--- a/src/runtime/cgo/libcgo.h
+++ b/src/runtime/cgo/libcgo.h
@@ -66,7 +66,7 @@ uintptr_t _cgo_wait_runtime_init_done(void);
 /*
  * Call fn in the 6c world.
  */
-void crosscall_amd64(void (*fn)(void));
+void crosscall_amd64(void (*fn)(void), void (*setg_gcc)(void*), void *g);
 
 /*
  * Call fn in the 8c world.
-- 
GitLab


From dcb5e0392e73c900db0f7260b392c91611e33540 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Wed, 3 Feb 2021 15:45:26 -0800
Subject: [PATCH 0603/2400] [dev.typeparams] cmd/compile: add stenciling of
 simple generic functions

Allow full compilation and running of simple programs with generic
functions by stenciling on the fly the needed generic functions. Deal
with some simple derived types based on type params.

Include a few new typeparam tests min.go and add.go which involve
fully compiling and running simple generic code.

Change-Id: Ifc2a64ecacdbd860faaeee800e2ef49ffef9df5e
Reviewed-on: https://go-review.googlesource.com/c/go/+/289630
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/ir/package.go    |   3 +
 src/cmd/compile/internal/noder/irgen.go   |  15 ++
 src/cmd/compile/internal/noder/stencil.go | 280 ++++++++++++++++++++++
 test/typeparam/add.go                     |  50 ++++
 test/typeparam/min.go                     |  32 +++
 5 files changed, 380 insertions(+)
 create mode 100644 src/cmd/compile/internal/noder/stencil.go
 create mode 100644 test/typeparam/add.go
 create mode 100644 test/typeparam/min.go

diff --git a/src/cmd/compile/internal/ir/package.go b/src/cmd/compile/internal/ir/package.go
index 3896e2b91b..e4b93d113e 100644
--- a/src/cmd/compile/internal/ir/package.go
+++ b/src/cmd/compile/internal/ir/package.go
@@ -32,4 +32,7 @@ type Package struct {
 
 	// Exported (or re-exported) symbols.
 	Exports []*Name
+
+	// Map from function names of stencils to already-created stencils.
+	Stencils map[*types.Sym]*Func
 }
diff --git a/src/cmd/compile/internal/noder/irgen.go b/src/cmd/compile/internal/noder/irgen.go
index 475e3bbddd..d4f1b7461a 100644
--- a/src/cmd/compile/internal/noder/irgen.go
+++ b/src/cmd/compile/internal/noder/irgen.go
@@ -186,6 +186,21 @@ Outer:
 			return false
 		})
 	}
+
+	// Create any needed stencils of generic functions
+	g.stencil()
+
+	// For now, remove all generic functions from g.target.Decl, since they
+	// have been used for stenciling, but don't compile. TODO: We will
+	// eventually export any exportable generic functions.
+	j := 0
+	for i, decl := range g.target.Decls {
+		if decl.Op() != ir.ODCLFUNC || decl.Type().NumTParams() == 0 {
+			g.target.Decls[j] = g.target.Decls[i]
+			j++
+		}
+	}
+	g.target.Decls = g.target.Decls[:j]
 }
 
 func (g *irgen) unhandled(what string, p poser) {
diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
new file mode 100644
index 0000000000..3c6c7f4a8c
--- /dev/null
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -0,0 +1,280 @@
+// Copyright 2021 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.
+
+// This file will evolve, since we plan to do a mix of stenciling and passing
+// around dictionaries.
+
+package noder
+
+import (
+	"bytes"
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
+	"cmd/compile/internal/types"
+	"fmt"
+)
+
+// stencil scans functions for instantiated generic function calls and
+// creates the required stencils for simple generic functions.
+func (g *irgen) stencil() {
+	g.target.Stencils = make(map[*types.Sym]*ir.Func)
+	for _, decl := range g.target.Decls {
+		if decl.Op() != ir.ODCLFUNC || decl.Type().NumTParams() > 0 {
+			// Skip any non-function declarations and skip generic functions
+			continue
+		}
+
+		// For each non-generic function, search for any function calls using
+		// generic function instantiations. (We don't yet handle generic
+		// function instantiations that are not immediately called.)
+		// Then create the needed instantiated function if it hasn't been
+		// created yet, and change to calling that function directly.
+		f := decl.(*ir.Func)
+		modified := false
+		ir.VisitList(f.Body, func(n ir.Node) {
+			if n.Op() != ir.OCALLFUNC || n.(*ir.CallExpr).X.Op() != ir.OFUNCINST {
+				return
+			}
+			// We have found a function call using a generic function
+			// instantiation.
+			call := n.(*ir.CallExpr)
+			inst := call.X.(*ir.InstExpr)
+			sym := makeInstName(inst)
+			//fmt.Printf("Found generic func call in %v to %v\n", f, s)
+			st := g.target.Stencils[sym]
+			if st == nil {
+				// If instantiation doesn't exist yet, create it and add
+				// to the list of decls.
+				st = genericSubst(sym, inst)
+				g.target.Stencils[sym] = st
+				g.target.Decls = append(g.target.Decls, st)
+				if base.Flag.W > 1 {
+					ir.Dump(fmt.Sprintf("\nstenciled %v", st), st)
+				}
+			}
+			// Replace the OFUNCINST with a direct reference to the
+			// new stenciled function
+			call.X = st.Nname
+			modified = true
+		})
+		if base.Flag.W > 1 && modified {
+			ir.Dump(fmt.Sprintf("\nmodified %v", decl), decl)
+		}
+	}
+
+}
+
+// makeInstName makes the unique name for a stenciled generic function, based on
+// the name of the function and the types of the type params.
+func makeInstName(inst *ir.InstExpr) *types.Sym {
+	b := bytes.NewBufferString("#")
+	b.WriteString(inst.X.(*ir.Name).Name().Sym().Name)
+	b.WriteString("[")
+	for i, targ := range inst.Targs {
+		if i > 0 {
+			b.WriteString(",")
+		}
+		b.WriteString(targ.Name().Sym().Name)
+	}
+	b.WriteString("]")
+	return typecheck.Lookup(b.String())
+}
+
+// Struct containing info needed for doing the substitution as we create the
+// instantiation of a generic function with specified type arguments.
+type subster struct {
+	newf    *ir.Func // Func node for the new stenciled function
+	tparams *types.Fields
+	targs   []ir.Node
+	// The substitution map from name nodes in the generic function to the
+	// name nodes in the new stenciled function.
+	vars map[*ir.Name]*ir.Name
+}
+
+// genericSubst returns a new function with the specified name. The function is an
+// instantiation of a generic function with type params, as specified by inst.
+func genericSubst(name *types.Sym, inst *ir.InstExpr) *ir.Func {
+	// Similar to noder.go: funcDecl
+	nameNode := inst.X.(*ir.Name)
+	gf := nameNode.Func
+	newf := ir.NewFunc(inst.Pos())
+	newf.Nname = ir.NewNameAt(inst.Pos(), name)
+	newf.Nname.Func = newf
+	newf.Nname.Defn = newf
+
+	subst := &subster{
+		newf:    newf,
+		tparams: nameNode.Type().TParams().Fields(),
+		targs:   inst.Targs,
+		vars:    make(map[*ir.Name]*ir.Name),
+	}
+
+	newf.Dcl = make([]*ir.Name, len(gf.Dcl))
+	for i, n := range gf.Dcl {
+		newf.Dcl[i] = subst.node(n).(*ir.Name)
+	}
+	newf.Body = subst.list(gf.Body)
+
+	// Ugly: we have to insert the Name nodes of the parameters/results into
+	// the function type. The current function type has no Nname fields set,
+	// because it came via conversion from the types2 type.
+	oldt := inst.Type()
+	newt := types.NewSignature(oldt.Pkg(), nil, nil, subst.fields(ir.PPARAM, oldt.Params(), newf.Dcl),
+		subst.fields(ir.PPARAMOUT, oldt.Results(), newf.Dcl))
+
+	newf.Nname.Ntype = ir.TypeNode(newt)
+	newf.Nname.SetType(newt)
+	ir.MarkFunc(newf.Nname)
+	newf.SetTypecheck(1)
+	newf.Nname.SetTypecheck(1)
+	// TODO(danscales) - remove later, but avoid confusion for now.
+	newf.Pragma = ir.Noinline
+	return newf
+}
+
+// node is like DeepCopy(), but creates distinct ONAME nodes, and also descends
+// into closures. It substitutes type arguments for type parameters in all the new
+// nodes.
+func (subst *subster) node(n ir.Node) ir.Node {
+	// Use closure to capture all state needed by the ir.EditChildren argument.
+	var edit func(ir.Node) ir.Node
+	edit = func(x ir.Node) ir.Node {
+		switch x.Op() {
+		case ir.ONAME:
+			name := x.(*ir.Name)
+			if v := subst.vars[name]; v != nil {
+				return v
+			}
+			m := ir.NewNameAt(name.Pos(), name.Sym())
+			t := x.Type()
+			newt := subst.typ(t)
+			m.SetType(newt)
+			m.Curfn = subst.newf
+			m.Class = name.Class
+			subst.vars[name] = m
+			m.SetTypecheck(1)
+			return m
+		case ir.OLITERAL, ir.ONIL:
+			if x.Sym() != nil {
+				return x
+			}
+		}
+		m := ir.Copy(x)
+		if _, isExpr := m.(ir.Expr); isExpr {
+			m.SetType(subst.typ(x.Type()))
+		}
+		ir.EditChildren(m, edit)
+		if x.Op() == ir.OCLOSURE {
+			x := x.(*ir.ClosureExpr)
+			// Need to save/duplicate x.Func.Nname,
+			// x.Func.Nname.Ntype, x.Func.Dcl, x.Func.ClosureVars, and
+			// x.Func.Body.
+			oldfn := x.Func
+			newfn := ir.NewFunc(oldfn.Pos())
+			if oldfn.ClosureCalled() {
+				newfn.SetClosureCalled(true)
+			}
+			m.(*ir.ClosureExpr).Func = newfn
+			newfn.Nname = ir.NewNameAt(oldfn.Nname.Pos(), oldfn.Nname.Sym())
+			newfn.Nname.SetType(oldfn.Nname.Type())
+			newfn.Nname.Ntype = subst.node(oldfn.Nname.Ntype).(ir.Ntype)
+			newfn.Body = subst.list(oldfn.Body)
+			// Make shallow copy of the Dcl and ClosureVar slices
+			newfn.Dcl = append([]*ir.Name(nil), oldfn.Dcl...)
+			newfn.ClosureVars = append([]*ir.Name(nil), oldfn.ClosureVars...)
+		}
+		return m
+	}
+
+	return edit(n)
+}
+
+func (subst *subster) list(l []ir.Node) []ir.Node {
+	s := make([]ir.Node, len(l))
+	for i, n := range l {
+		s[i] = subst.node(n)
+	}
+	return s
+}
+
+// typ substitutes any type parameter found with the corresponding type argument.
+func (subst *subster) typ(t *types.Type) *types.Type {
+	for i, tp := range subst.tparams.Slice() {
+		if tp.Type == t {
+			return subst.targs[i].Type()
+		}
+	}
+
+	switch t.Kind() {
+	case types.TARRAY:
+		elem := t.Elem()
+		newelem := subst.typ(elem)
+		if subst.typ(elem) != elem {
+			return types.NewArray(newelem, t.NumElem())
+		}
+
+	case types.TPTR:
+		elem := t.Elem()
+		newelem := subst.typ(elem)
+		if subst.typ(elem) != elem {
+			return types.NewPtr(newelem)
+		}
+
+	case types.TSLICE:
+		elem := t.Elem()
+		newelem := subst.typ(elem)
+		if subst.typ(elem) != elem {
+			return types.NewSlice(newelem)
+		}
+
+	case types.TSTRUCT:
+		newfields := make([]*types.Field, t.NumFields())
+		change := false
+		for i, f := range t.Fields().Slice() {
+			t2 := subst.typ(f.Type)
+			if t2 != f.Type {
+				change = true
+			}
+			newfields[i] = types.NewField(f.Pos, f.Sym, t2)
+		}
+		if change {
+			return types.NewStruct(t.Pkg(), newfields)
+		}
+
+		// TODO: case TFUNC
+		// TODO: case TCHAN
+		// TODO: case TMAP
+		// TODO: case TINTER
+	}
+	return t
+}
+
+// fields sets the Nname field for the Field nodes inside a type signature, based
+// on the corresponding in/out parameters in dcl. It depends on the in and out
+// parameters being in order in dcl.
+func (subst *subster) fields(class ir.Class, oldt *types.Type, dcl []*ir.Name) []*types.Field {
+	oldfields := oldt.FieldSlice()
+	newfields := make([]*types.Field, len(oldfields))
+	var i int
+
+	// Find the starting index in dcl of declarations of the class (either
+	// PPARAM or PPARAMOUT).
+	for i = range dcl {
+		if dcl[i].Class == class {
+			break
+		}
+	}
+
+	// Create newfields nodes that are copies of the oldfields nodes, but
+	// with substitution for any type params, and with Nname set to be the node in
+	// Dcl for the corresponding PPARAM or PPARAMOUT.
+	for j := range oldfields {
+		newfields[j] = oldfields[j].Copy()
+		newfields[j].Type = subst.typ(oldfields[j].Type)
+		newfields[j].Nname = dcl[i]
+		i++
+	}
+	return newfields
+}
diff --git a/test/typeparam/add.go b/test/typeparam/add.go
new file mode 100644
index 0000000000..b0cf76d3ee
--- /dev/null
+++ b/test/typeparam/add.go
@@ -0,0 +1,50 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 (
+	"fmt"
+)
+
+func add[T interface{ type int, float64 }](vec []T) T {
+	var sum T
+	for _, elt := range vec {
+		sum = sum + elt
+	}
+	return sum
+}
+
+func abs(f float64) float64 {
+	if f < 0.0 {
+		return -f
+	}
+	return f
+}
+
+func main() {
+	vec1 := []int{3, 4}
+	vec2 := []float64{5.8, 9.6}
+	want := vec1[0] + vec1[1]
+	got := add[int](vec1)
+	if want != got {
+		panic(fmt.Sprintf("Want %d, got %d", want, got))
+	}
+	got = add(vec1)
+	if want != got {
+		panic(fmt.Sprintf("Want %d, got %d", want, got))
+	}
+
+	fwant := vec2[0] + vec2[1]
+	fgot := add[float64](vec2)
+	if abs(fgot - fwant) > 1e-10 {
+		panic(fmt.Sprintf("Want %f, got %f", fwant, fgot))
+	}
+	fgot = add(vec2)
+	if abs(fgot - fwant) > 1e-10 {
+		panic(fmt.Sprintf("Want %f, got %f", fwant, fgot))
+	}
+}
diff --git a/test/typeparam/min.go b/test/typeparam/min.go
new file mode 100644
index 0000000000..3bd92c5f3e
--- /dev/null
+++ b/test/typeparam/min.go
@@ -0,0 +1,32 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 (
+	"fmt"
+)
+
+
+func min[T interface{ type int }](x, y T) T {
+	if x < y {
+		return x
+	}
+	return y
+}
+
+func main() {
+	want := 2
+	got := min[int](2, 3)
+	if want != got {
+		panic(fmt.Sprintf("Want %d, got %d", want, got))
+	}
+
+	got = min(2, 3)
+	if want != got {
+		panic(fmt.Sprintf("Want %d, got %d", want, got))
+	}
+}
-- 
GitLab


From 7cc6de59f25911ff786a4d54420f2ddbf21c00f2 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Wed, 3 Feb 2021 11:53:35 -0500
Subject: [PATCH 0604/2400] [dev.regabi] runtime: don't mark rt0_go ABIInternal

rt0_go is not actually ABIInternal, and it actually has callers
(e.g. _rt0_amd64).

Change-Id: Id730176e620ad9f443e6bfca6ded81a1367531ba
Reviewed-on: https://go-review.googlesource.com/c/go/+/289193
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/runtime/asm_amd64.s | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index b5d01ba73c..aece84bde8 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -84,9 +84,7 @@ GLOBL _rt0_amd64_lib_argc<>(SB),NOPTR, $8
 DATA _rt0_amd64_lib_argv<>(SB)/8, $0
 GLOBL _rt0_amd64_lib_argv<>(SB),NOPTR, $8
 
-// Defined as ABIInternal since it does not use the stack-based Go ABI (and
-// in addition there are no calls to this entry point from Go code).
-TEXT runtime·rt0_go<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·rt0_go(SB),NOSPLIT,$0
 	// copy arguments forward on an even stack
 	MOVQ	DI, AX		// argc
 	MOVQ	SI, BX		// argv
-- 
GitLab


From e79c2fd428372f64e6183bed9f765c1556816111 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 2 Feb 2021 18:09:03 -0500
Subject: [PATCH 0605/2400] [dev.regabi] runtime: mark racecallbackthunk as
 ABIInternal

racecallbackthunk is called from C, and it needs to follow C ABI.
The assembly code preserves C callee-save registers. It must not
be called via wrappers, which may not preserve those registers.

Change-Id: Icd72c399f4424d73c4882860d85057fe2671f6aa
Reviewed-on: https://go-review.googlesource.com/c/go/+/289194
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/runtime/race_amd64.s | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/runtime/race_amd64.s b/src/runtime/race_amd64.s
index 9818bc6ddf..cf0a51462f 100644
--- a/src/runtime/race_amd64.s
+++ b/src/runtime/race_amd64.s
@@ -419,7 +419,9 @@ call:
 // The overall effect of Go->C->Go call chain is similar to that of mcall.
 // RARG0 contains command code. RARG1 contains command-specific context.
 // See racecallback for command codes.
-TEXT	runtime·racecallbackthunk(SB), NOSPLIT, $56-8
+// Defined as ABIInternal so as to avoid introducing a wrapper,
+// because its address is passed to C via funcPC.
+TEXT	runtime·racecallbackthunk<ABIInternal>(SB), NOSPLIT, $56-8
 	// Handle command raceGetProcCmd (0) here.
 	// First, code below assumes that we are on curg, while raceGetProcCmd
 	// can be executed on g0. Second, it is called frequently, so will
-- 
GitLab


From 397a46a10a2cc8557e965af269915909cb5c0a80 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Wed, 3 Feb 2021 12:09:53 -0500
Subject: [PATCH 0606/2400] [dev.regabi] cmd/asm: define g register on AMD64

Define g register as R14 on AMD64. It is not used now, but will
be in later CLs.

The name "R14" is still recognized.

Change-Id: I9a066b15bf1051113db8c6640605e350cea397b9
Reviewed-on: https://go-review.googlesource.com/c/go/+/289195
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/asm/internal/arch/arch.go        | 4 ++++
 src/cmd/asm/internal/asm/operand_test.go | 1 +
 src/cmd/internal/obj/x86/a.out.go        | 1 +
 3 files changed, 6 insertions(+)

diff --git a/src/cmd/asm/internal/arch/arch.go b/src/cmd/asm/internal/arch/arch.go
index a62e55191e..026d8abf81 100644
--- a/src/cmd/asm/internal/arch/arch.go
+++ b/src/cmd/asm/internal/arch/arch.go
@@ -109,6 +109,10 @@ func archX86(linkArch *obj.LinkArch) *Arch {
 	register["SB"] = RSB
 	register["FP"] = RFP
 	register["PC"] = RPC
+	if linkArch == &x86.Linkamd64 {
+		// Alias g to R14
+		register["g"] = x86.REGG
+	}
 	// Register prefix not used on this architecture.
 
 	instructions := make(map[string]obj.As)
diff --git a/src/cmd/asm/internal/asm/operand_test.go b/src/cmd/asm/internal/asm/operand_test.go
index 2e83e176b2..c6def15e20 100644
--- a/src/cmd/asm/internal/asm/operand_test.go
+++ b/src/cmd/asm/internal/asm/operand_test.go
@@ -259,6 +259,7 @@ var amd64OperandTests = []operandTest{
 	{"R15", "R15"},
 	{"R8", "R8"},
 	{"R9", "R9"},
+	{"g", "R14"},
 	{"SI", "SI"},
 	{"SP", "SP"},
 	{"X0", "X0"},
diff --git a/src/cmd/internal/obj/x86/a.out.go b/src/cmd/internal/obj/x86/a.out.go
index 30c1a6a445..3be4b59da4 100644
--- a/src/cmd/internal/obj/x86/a.out.go
+++ b/src/cmd/internal/obj/x86/a.out.go
@@ -263,6 +263,7 @@ const (
 	FREGRET  = REG_X0
 	REGSP    = REG_SP
 	REGCTXT  = REG_DX
+	REGG     = REG_R14     // g register in ABIInternal
 	REGEXT   = REG_R15     // compiler allocates external registers R15 down
 	FREGMIN  = REG_X0 + 5  // first register variable
 	FREGEXT  = REG_X0 + 15 // first external register
-- 
GitLab


From 946351d5a27d7dc5550f579ddfec926790903fc5 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 2 Feb 2021 18:25:39 -0500
Subject: [PATCH 0607/2400] [dev.regabi] runtime: zero X15 in racecall

racecall can be called in ABIInternal context (e.g. raceread
calling racecalladdr calling racecall) without wrapper. racecall
calls C code, which doesn't preserve our special registers. Set
them explicitly in racecall upon returning from C.

Change-Id: Ic990479c1fca6bb8a3b151325c7a89be8331a530
Reviewed-on: https://go-review.googlesource.com/c/go/+/289709
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
---
 src/runtime/race_amd64.s | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/runtime/race_amd64.s b/src/runtime/race_amd64.s
index cf0a51462f..fd41b5690a 100644
--- a/src/runtime/race_amd64.s
+++ b/src/runtime/race_amd64.s
@@ -412,6 +412,9 @@ call:
 	ANDQ	$~15, SP	// alignment for gcc ABI
 	CALL	AX
 	MOVQ	R12, SP
+	// Back to Go world, set special registers.
+	// The g register (R14) is preserved in C.
+	XORPS	X15, X15
 	RET
 
 // C->Go callback thunk that allows to call runtime·racesymbolize from C code.
-- 
GitLab


From 8fa84772ba035b74975572fbc9df0330523cc388 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 4 Feb 2021 12:59:06 -0500
Subject: [PATCH 0608/2400] [dev.regabi] runtime: delete gosave function

The runtime.gosave function is not used anywhere. Delete.

Note: there is also a gosave<> function, which is actually used
and not deleted.

Change-Id: I64149a7afdd217de26d1e6396233f2becfad7153
Reviewed-on: https://go-review.googlesource.com/c/go/+/289719
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/asm_386.s     | 19 -------------------
 src/runtime/asm_amd64.s   | 20 --------------------
 src/runtime/asm_arm.s     | 17 -----------------
 src/runtime/asm_arm64.s   | 17 -----------------
 src/runtime/asm_mips64x.s | 15 ---------------
 src/runtime/asm_mipsx.s   | 15 ---------------
 src/runtime/asm_ppc64x.s  | 17 -----------------
 src/runtime/asm_riscv64.s | 15 ---------------
 src/runtime/asm_s390x.s   | 15 ---------------
 src/runtime/stubs.go      |  1 -
 10 files changed, 151 deletions(-)

diff --git a/src/runtime/asm_386.s b/src/runtime/asm_386.s
index fa3b1be339..429f3fef82 100644
--- a/src/runtime/asm_386.s
+++ b/src/runtime/asm_386.s
@@ -273,25 +273,6 @@ TEXT runtime·asminit(SB),NOSPLIT,$0-0
  *  go-routine
  */
 
-// void gosave(Gobuf*)
-// save state in Gobuf; setjmp
-TEXT runtime·gosave(SB), NOSPLIT, $0-4
-	MOVL	buf+0(FP), AX		// gobuf
-	LEAL	buf+0(FP), BX		// caller's SP
-	MOVL	BX, gobuf_sp(AX)
-	MOVL	0(SP), BX		// caller's PC
-	MOVL	BX, gobuf_pc(AX)
-	MOVL	$0, gobuf_ret(AX)
-	// Assert ctxt is zero. See func save.
-	MOVL	gobuf_ctxt(AX), BX
-	TESTL	BX, BX
-	JZ	2(PC)
-	CALL	runtime·badctxt(SB)
-	get_tls(CX)
-	MOVL	g(CX), BX
-	MOVL	BX, gobuf_g(AX)
-	RET
-
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
 TEXT runtime·gogo(SB), NOSPLIT, $8-4
diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index aece84bde8..a9456dc9ff 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -254,26 +254,6 @@ TEXT runtime·asminit(SB),NOSPLIT,$0-0
  *  go-routine
  */
 
-// func gosave(buf *gobuf)
-// save state in Gobuf; setjmp
-TEXT runtime·gosave(SB), NOSPLIT, $0-8
-	MOVQ	buf+0(FP), AX		// gobuf
-	LEAQ	buf+0(FP), BX		// caller's SP
-	MOVQ	BX, gobuf_sp(AX)
-	MOVQ	0(SP), BX		// caller's PC
-	MOVQ	BX, gobuf_pc(AX)
-	MOVQ	$0, gobuf_ret(AX)
-	MOVQ	BP, gobuf_bp(AX)
-	// Assert ctxt is zero. See func save.
-	MOVQ	gobuf_ctxt(AX), BX
-	TESTQ	BX, BX
-	JZ	2(PC)
-	CALL	runtime·badctxt(SB)
-	get_tls(CX)
-	MOVQ	g(CX), BX
-	MOVQ	BX, gobuf_g(AX)
-	RET
-
 // func gogo(buf *gobuf)
 // restore state from Gobuf; longjmp
 TEXT runtime·gogo(SB), NOSPLIT, $16-8
diff --git a/src/runtime/asm_arm.s b/src/runtime/asm_arm.s
index c54b4eb006..8eec84d3f2 100644
--- a/src/runtime/asm_arm.s
+++ b/src/runtime/asm_arm.s
@@ -206,23 +206,6 @@ TEXT runtime·asminit(SB),NOSPLIT,$0-0
  *  go-routine
  */
 
-// void gosave(Gobuf*)
-// save state in Gobuf; setjmp
-TEXT runtime·gosave(SB),NOSPLIT|NOFRAME,$0-4
-	MOVW	buf+0(FP), R0
-	MOVW	R13, gobuf_sp(R0)
-	MOVW	LR, gobuf_pc(R0)
-	MOVW	g, gobuf_g(R0)
-	MOVW	$0, R11
-	MOVW	R11, gobuf_lr(R0)
-	MOVW	R11, gobuf_ret(R0)
-	// Assert ctxt is zero. See func save.
-	MOVW	gobuf_ctxt(R0), R0
-	CMP	R0, R11
-	B.EQ	2(PC)
-	CALL	runtime·badctxt(SB)
-	RET
-
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
 TEXT runtime·gogo(SB),NOSPLIT,$8-4
diff --git a/src/runtime/asm_arm64.s b/src/runtime/asm_arm64.s
index a09172f0c9..8e4a1f74f9 100644
--- a/src/runtime/asm_arm64.s
+++ b/src/runtime/asm_arm64.s
@@ -113,23 +113,6 @@ TEXT runtime·asminit(SB),NOSPLIT|NOFRAME,$0-0
  *  go-routine
  */
 
-// void gosave(Gobuf*)
-// save state in Gobuf; setjmp
-TEXT runtime·gosave(SB), NOSPLIT|NOFRAME, $0-8
-	MOVD	buf+0(FP), R3
-	MOVD	RSP, R0
-	MOVD	R0, gobuf_sp(R3)
-	MOVD	R29, gobuf_bp(R3)
-	MOVD	LR, gobuf_pc(R3)
-	MOVD	g, gobuf_g(R3)
-	MOVD	ZR, gobuf_lr(R3)
-	MOVD	ZR, gobuf_ret(R3)
-	// Assert ctxt is zero. See func save.
-	MOVD	gobuf_ctxt(R3), R0
-	CBZ	R0, 2(PC)
-	CALL	runtime·badctxt(SB)
-	RET
-
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
 TEXT runtime·gogo(SB), NOSPLIT, $24-8
diff --git a/src/runtime/asm_mips64x.s b/src/runtime/asm_mips64x.s
index 19781f7885..054a89dc37 100644
--- a/src/runtime/asm_mips64x.s
+++ b/src/runtime/asm_mips64x.s
@@ -89,21 +89,6 @@ TEXT runtime·asminit(SB),NOSPLIT|NOFRAME,$0-0
  *  go-routine
  */
 
-// void gosave(Gobuf*)
-// save state in Gobuf; setjmp
-TEXT runtime·gosave(SB), NOSPLIT|NOFRAME, $0-8
-	MOVV	buf+0(FP), R1
-	MOVV	R29, gobuf_sp(R1)
-	MOVV	R31, gobuf_pc(R1)
-	MOVV	g, gobuf_g(R1)
-	MOVV	R0, gobuf_lr(R1)
-	MOVV	R0, gobuf_ret(R1)
-	// Assert ctxt is zero. See func save.
-	MOVV	gobuf_ctxt(R1), R1
-	BEQ	R1, 2(PC)
-	JAL	runtime·badctxt(SB)
-	RET
-
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
 TEXT runtime·gogo(SB), NOSPLIT, $16-8
diff --git a/src/runtime/asm_mipsx.s b/src/runtime/asm_mipsx.s
index ee87d81436..f57437d590 100644
--- a/src/runtime/asm_mipsx.s
+++ b/src/runtime/asm_mipsx.s
@@ -90,21 +90,6 @@ TEXT runtime·asminit(SB),NOSPLIT,$0-0
  *  go-routine
  */
 
-// void gosave(Gobuf*)
-// save state in Gobuf; setjmp
-TEXT runtime·gosave(SB),NOSPLIT|NOFRAME,$0-4
-	MOVW	buf+0(FP), R1
-	MOVW	R29, gobuf_sp(R1)
-	MOVW	R31, gobuf_pc(R1)
-	MOVW	g, gobuf_g(R1)
-	MOVW	R0, gobuf_lr(R1)
-	MOVW	R0, gobuf_ret(R1)
-	// Assert ctxt is zero. See func save.
-	MOVW	gobuf_ctxt(R1), R1
-	BEQ	R1, 2(PC)
-	JAL	runtime·badctxt(SB)
-	RET
-
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
 TEXT runtime·gogo(SB),NOSPLIT,$8-4
diff --git a/src/runtime/asm_ppc64x.s b/src/runtime/asm_ppc64x.s
index dc34c0e4c8..763a92adf1 100644
--- a/src/runtime/asm_ppc64x.s
+++ b/src/runtime/asm_ppc64x.s
@@ -128,23 +128,6 @@ TEXT runtime·reginit(SB),NOSPLIT|NOFRAME,$0-0
  *  go-routine
  */
 
-// void gosave(Gobuf*)
-// save state in Gobuf; setjmp
-TEXT runtime·gosave(SB), NOSPLIT|NOFRAME, $0-8
-	MOVD	buf+0(FP), R3
-	MOVD	R1, gobuf_sp(R3)
-	MOVD	LR, R31
-	MOVD	R31, gobuf_pc(R3)
-	MOVD	g, gobuf_g(R3)
-	MOVD	R0, gobuf_lr(R3)
-	MOVD	R0, gobuf_ret(R3)
-	// Assert ctxt is zero. See func save.
-	MOVD	gobuf_ctxt(R3), R3
-	CMP	R0, R3
-	BEQ	2(PC)
-	BL	runtime·badctxt(SB)
-	RET
-
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
 TEXT runtime·gogo(SB), NOSPLIT, $16-8
diff --git a/src/runtime/asm_riscv64.s b/src/runtime/asm_riscv64.s
index 01b42dc3de..cf460d1586 100644
--- a/src/runtime/asm_riscv64.s
+++ b/src/runtime/asm_riscv64.s
@@ -297,21 +297,6 @@ TEXT runtime·mcall(SB), NOSPLIT|NOFRAME, $0-8
 	JALR	RA, T1
 	JMP	runtime·badmcall2(SB)
 
-// func gosave(buf *gobuf)
-// save state in Gobuf; setjmp
-TEXT runtime·gosave(SB), NOSPLIT|NOFRAME, $0-8
-	MOV	buf+0(FP), T1
-	MOV	X2, gobuf_sp(T1)
-	MOV	RA, gobuf_pc(T1)
-	MOV	g, gobuf_g(T1)
-	MOV	ZERO, gobuf_lr(T1)
-	MOV	ZERO, gobuf_ret(T1)
-	// Assert ctxt is zero. See func save.
-	MOV	gobuf_ctxt(T1), T1
-	BEQ	T1, ZERO, 2(PC)
-	CALL	runtime·badctxt(SB)
-	RET
-
 // Save state of caller into g->sched. Smashes X31.
 TEXT gosave<>(SB),NOSPLIT|NOFRAME,$0
 	MOV	X1, (g_sched+gobuf_pc)(g)
diff --git a/src/runtime/asm_s390x.s b/src/runtime/asm_s390x.s
index 7baef37324..1cd5eca06f 100644
--- a/src/runtime/asm_s390x.s
+++ b/src/runtime/asm_s390x.s
@@ -174,21 +174,6 @@ TEXT runtime·asminit(SB),NOSPLIT|NOFRAME,$0-0
  *  go-routine
  */
 
-// void gosave(Gobuf*)
-// save state in Gobuf; setjmp
-TEXT runtime·gosave(SB), NOSPLIT, $-8-8
-	MOVD	buf+0(FP), R3
-	MOVD	R15, gobuf_sp(R3)
-	MOVD	LR, gobuf_pc(R3)
-	MOVD	g, gobuf_g(R3)
-	MOVD	$0, gobuf_lr(R3)
-	MOVD	$0, gobuf_ret(R3)
-	// Assert ctxt is zero. See func save.
-	MOVD	gobuf_ctxt(R3), R3
-	CMPBEQ	R3, $0, 2(PC)
-	BL	runtime·badctxt(SB)
-	RET
-
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
 TEXT runtime·gogo(SB), NOSPLIT, $16-8
diff --git a/src/runtime/stubs.go b/src/runtime/stubs.go
index 2ee2c74dfe..36bbc8991a 100644
--- a/src/runtime/stubs.go
+++ b/src/runtime/stubs.go
@@ -167,7 +167,6 @@ func noescape(p unsafe.Pointer) unsafe.Pointer {
 // pointer-declared arguments.
 func cgocallback(fn, frame, ctxt uintptr)
 func gogo(buf *gobuf)
-func gosave(buf *gobuf)
 
 //go:noescape
 func jmpdefer(fv *funcval, argp uintptr)
-- 
GitLab


From a21de9ec73b8a433cafd336448dc8111a4e4571e Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Wed, 3 Feb 2021 15:07:33 -0500
Subject: [PATCH 0609/2400] [dev.regabi] cmd/link: resolve symbol ABI in shared
 linkage

In shared build mode and linkage, currently we assume all
function symbols are ABI0 (except for generated type algorithm
functions), and alias them to ABIInternal. When the two ABIs
actually differ (as it is now), this is not actually correct.
This CL resolves symbol ABI based on their mangled names.
If the symbol's name has a ".abi0" or ".abiinternal" suffix, it
is of the corresponding ABI. The symbol without the suffix is
the other ABI. For functions without ABI wrapper generated,
only one ABI exists but we don't know what it is, so we still
use alias (for now).

Change-Id: I2165f149bc83d513e81eb1eb4ee95464335b0e75
Reviewed-on: https://go-review.googlesource.com/c/go/+/289289
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/ld/lib.go | 44 +++++++++++++++++++++++++++++++--
 1 file changed, 42 insertions(+), 2 deletions(-)

diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index 17d5040827..71cef0b774 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -2091,6 +2091,26 @@ func ldshlibsyms(ctxt *Link, shlib string) {
 		Errorf(nil, "cannot read symbols from shared library: %s", libpath)
 		return
 	}
+
+	// collect text symbol ABI versions.
+	symabi := make(map[string]int) // map (unmangled) symbol name to version
+	if *flagAbiWrap {
+		for _, elfsym := range syms {
+			if elf.ST_TYPE(elfsym.Info) != elf.STT_FUNC {
+				continue
+			}
+			// Demangle the name. Keep in sync with symtab.go:putelfsym.
+			if strings.HasSuffix(elfsym.Name, ".abiinternal") {
+				// ABIInternal symbol has mangled name, so the primary symbol is ABI0.
+				symabi[strings.TrimSuffix(elfsym.Name, ".abiinternal")] = 0
+			}
+			if strings.HasSuffix(elfsym.Name, ".abi0") {
+				// ABI0 symbol has mangled name, so the primary symbol is ABIInternal.
+				symabi[strings.TrimSuffix(elfsym.Name, ".abi0")] = sym.SymVerABIInternal
+			}
+		}
+	}
+
 	for _, elfsym := range syms {
 		if elf.ST_TYPE(elfsym.Info) == elf.STT_NOTYPE || elf.ST_TYPE(elfsym.Info) == elf.STT_SECTION {
 			continue
@@ -2099,12 +2119,23 @@ func ldshlibsyms(ctxt *Link, shlib string) {
 		// Symbols whose names start with "type." are compiler
 		// generated, so make functions with that prefix internal.
 		ver := 0
+		symname := elfsym.Name // (unmangled) symbol name
 		if elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC && strings.HasPrefix(elfsym.Name, "type.") {
 			ver = sym.SymVerABIInternal
+		} else if *flagAbiWrap && elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC {
+			if strings.HasSuffix(elfsym.Name, ".abiinternal") {
+				ver = sym.SymVerABIInternal
+				symname = strings.TrimSuffix(elfsym.Name, ".abiinternal")
+			} else if strings.HasSuffix(elfsym.Name, ".abi0") {
+				ver = 0
+				symname = strings.TrimSuffix(elfsym.Name, ".abi0")
+			} else if abi, ok := symabi[elfsym.Name]; ok {
+				ver = abi
+			}
 		}
 
 		l := ctxt.loader
-		s := l.LookupOrCreateSym(elfsym.Name, ver)
+		s := l.LookupOrCreateSym(symname, ver)
 
 		// Because loadlib above loads all .a files before loading
 		// any shared libraries, any non-dynimport symbols we find
@@ -2129,6 +2160,10 @@ func ldshlibsyms(ctxt *Link, shlib string) {
 			}
 		}
 
+		if symname != elfsym.Name {
+			l.SetSymExtname(s, elfsym.Name)
+		}
+
 		// For function symbols, we don't know what ABI is
 		// available, so alias it under both ABIs.
 		//
@@ -2137,7 +2172,12 @@ func ldshlibsyms(ctxt *Link, shlib string) {
 		// mangle Go function names in the .so to include the
 		// ABI.
 		if elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC && ver == 0 {
-			alias := ctxt.loader.LookupOrCreateSym(elfsym.Name, sym.SymVerABIInternal)
+			if *flagAbiWrap {
+				if _, ok := symabi[symname]; ok {
+					continue // only use alias for functions w/o ABI wrappers
+				}
+			}
+			alias := ctxt.loader.LookupOrCreateSym(symname, sym.SymVerABIInternal)
 			if l.SymType(alias) != 0 {
 				continue
 			}
-- 
GitLab


From 5d7dc53888c3c91ef4122d584a064bc24b6f7540 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 2 Feb 2021 18:20:16 -0500
Subject: [PATCH 0610/2400] [dev.regabi] cmd/compile, runtime: reserve R14 as g
 registers on AMD64

This is a proof-of-concept change for using the g register on
AMD64. getg is now lowered to R14 in the new ABI. The g register
is not yet used in all places where it can be used (e.g. stack
bounds check, runtime assembly code).

Change-Id: I10123ddf38e31782cf58bafcdff170aee0ff0d1b
Reviewed-on: https://go-review.googlesource.com/c/go/+/289196
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/amd64/ssa.go        |   63 +-
 src/cmd/compile/internal/ssa/config.go       |    3 +-
 src/cmd/compile/internal/ssa/gen/AMD64.rules |    2 +-
 src/cmd/compile/internal/ssa/gen/AMD64Ops.go |   42 +-
 src/cmd/compile/internal/ssa/gen/rulegen.go  |    1 +
 src/cmd/compile/internal/ssa/opGen.go        | 2014 +++++++++---------
 src/cmd/compile/internal/ssa/rewriteAMD64.go |   20 +-
 src/runtime/asm_amd64.s                      |   35 +-
 src/runtime/race_amd64.s                     |    7 +-
 src/runtime/sys_linux_amd64.s                |    1 +
 10 files changed, 1113 insertions(+), 1075 deletions(-)

diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index d9c97183fd..4938e4b0e3 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -166,6 +166,34 @@ func duff(size int64) (int64, int64) {
 	return off, adj
 }
 
+func getgFromTLS(s *ssagen.State, r int16) {
+	// See the comments in cmd/internal/obj/x86/obj6.go
+	// near CanUse1InsnTLS for a detailed explanation of these instructions.
+	if x86.CanUse1InsnTLS(base.Ctxt) {
+		// MOVQ (TLS), r
+		p := s.Prog(x86.AMOVQ)
+		p.From.Type = obj.TYPE_MEM
+		p.From.Reg = x86.REG_TLS
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = r
+	} else {
+		// MOVQ TLS, r
+		// MOVQ (r)(TLS*1), r
+		p := s.Prog(x86.AMOVQ)
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = x86.REG_TLS
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = r
+		q := s.Prog(x86.AMOVQ)
+		q.From.Type = obj.TYPE_MEM
+		q.From.Reg = r
+		q.From.Index = x86.REG_TLS
+		q.From.Scale = 1
+		q.To.Type = obj.TYPE_REG
+		q.To.Reg = r
+	}
+}
+
 func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 	switch v.Op {
 	case ssa.OpAMD64VFMADD231SD:
@@ -989,41 +1017,24 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		// Closure pointer is DX.
 		ssagen.CheckLoweredGetClosurePtr(v)
 	case ssa.OpAMD64LoweredGetG:
-		r := v.Reg()
-		// See the comments in cmd/internal/obj/x86/obj6.go
-		// near CanUse1InsnTLS for a detailed explanation of these instructions.
-		if x86.CanUse1InsnTLS(base.Ctxt) {
-			// MOVQ (TLS), r
-			p := s.Prog(x86.AMOVQ)
-			p.From.Type = obj.TYPE_MEM
-			p.From.Reg = x86.REG_TLS
-			p.To.Type = obj.TYPE_REG
-			p.To.Reg = r
-		} else {
-			// MOVQ TLS, r
-			// MOVQ (r)(TLS*1), r
-			p := s.Prog(x86.AMOVQ)
-			p.From.Type = obj.TYPE_REG
-			p.From.Reg = x86.REG_TLS
-			p.To.Type = obj.TYPE_REG
-			p.To.Reg = r
-			q := s.Prog(x86.AMOVQ)
-			q.From.Type = obj.TYPE_MEM
-			q.From.Reg = r
-			q.From.Index = x86.REG_TLS
-			q.From.Scale = 1
-			q.To.Type = obj.TYPE_REG
-			q.To.Reg = r
+		if base.Flag.ABIWrap {
+			v.Fatalf("LoweredGetG should not appear in new ABI")
 		}
+		r := v.Reg()
+		getgFromTLS(s, r)
 	case ssa.OpAMD64CALLstatic:
 		if s.ABI == obj.ABI0 && v.Aux.(*ssa.AuxCall).Fn.ABI() == obj.ABIInternal {
 			// zeroing X15 when entering ABIInternal from ABI0
 			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
+			// set G register from TLS
+			getgFromTLS(s, x86.REG_R14)
 		}
 		s.Call(v)
 		if s.ABI == obj.ABIInternal && v.Aux.(*ssa.AuxCall).Fn.ABI() == obj.ABI0 {
 			// zeroing X15 when entering ABIInternal from ABI0
 			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
+			// set G register from TLS
+			getgFromTLS(s, x86.REG_R14)
 		}
 	case ssa.OpAMD64CALLclosure, ssa.OpAMD64CALLinter:
 		s.Call(v)
@@ -1325,6 +1336,8 @@ func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
 		if s.ABI == obj.ABI0 && b.Aux.(*obj.LSym).ABI() == obj.ABIInternal {
 			// zeroing X15 when entering ABIInternal from ABI0
 			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
+			// set G register from TLS
+			getgFromTLS(s, x86.REG_R14)
 		}
 		p := s.Prog(obj.ARET)
 		p.To.Type = obj.TYPE_MEM
diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go
index 32cfd7e61e..c29bc8fae6 100644
--- a/src/cmd/compile/internal/ssa/config.go
+++ b/src/cmd/compile/internal/ssa/config.go
@@ -5,6 +5,7 @@
 package ssa
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -197,7 +198,7 @@ func NewConfig(arch string, types Types, ctxt *obj.Link, optimize bool) *Config
 		c.specialRegMask = specialRegMaskAMD64
 		c.FPReg = framepointerRegAMD64
 		c.LinkReg = linkRegAMD64
-		c.hasGReg = false
+		c.hasGReg = base.Flag.ABIWrap
 	case "386":
 		c.PtrSize = 4
 		c.RegSize = 4
diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules
index 706336289e..3c75bcfa05 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64.rules
+++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules
@@ -459,7 +459,7 @@
 (IsInBounds idx len) => (SETB (CMPQ idx len))
 (IsSliceInBounds idx len) => (SETBE (CMPQ idx len))
 (NilCheck ...) => (LoweredNilCheck ...)
-(GetG ...) => (LoweredGetG ...)
+(GetG mem) && !base.Flag.ABIWrap => (LoweredGetG mem) // only lower in old ABI. in new ABI we have a G register.
 (GetClosurePtr ...) => (LoweredGetClosurePtr ...)
 (GetCallerPC ...) => (LoweredGetCallerPC ...)
 (GetCallerSP ...) => (LoweredGetCallerSP ...)
diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
index 0a411bbdca..043162e544 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
+++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
@@ -44,7 +44,7 @@ var regNamesAMD64 = []string{
 	"R11",
 	"R12",
 	"R13",
-	"R14",
+	"g", // a.k.a. R14
 	"R15",
 	"X0",
 	"X1",
@@ -96,12 +96,14 @@ func init() {
 		cx         = buildReg("CX")
 		dx         = buildReg("DX")
 		bx         = buildReg("BX")
-		gp         = buildReg("AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15")
+		gp         = buildReg("AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15")
+		g          = buildReg("g")
 		fp         = buildReg("X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14")
 		x15        = buildReg("X15")
 		gpsp       = gp | buildReg("SP")
 		gpspsb     = gpsp | buildReg("SB")
-		callerSave = gp | fp
+		gpspsbg    = gpspsb | g
+		callerSave = gp | fp | g // runtime.setg (and anything calling it) may clobber g
 	)
 	// Common slices of register masks
 	var (
@@ -114,10 +116,10 @@ func init() {
 		gp01           = regInfo{inputs: nil, outputs: gponly}
 		gp11           = regInfo{inputs: []regMask{gp}, outputs: gponly}
 		gp11sp         = regInfo{inputs: []regMask{gpsp}, outputs: gponly}
-		gp11sb         = regInfo{inputs: []regMask{gpspsb}, outputs: gponly}
+		gp11sb         = regInfo{inputs: []regMask{gpspsbg}, outputs: gponly}
 		gp21           = regInfo{inputs: []regMask{gp, gp}, outputs: gponly}
 		gp21sp         = regInfo{inputs: []regMask{gpsp, gp}, outputs: gponly}
-		gp21sb         = regInfo{inputs: []regMask{gpspsb, gpsp}, outputs: gponly}
+		gp21sb         = regInfo{inputs: []regMask{gpspsbg, gpsp}, outputs: gponly}
 		gp21shift      = regInfo{inputs: []regMask{gp, cx}, outputs: []regMask{gp}}
 		gp11div        = regInfo{inputs: []regMask{ax, gpsp &^ dx}, outputs: []regMask{ax, dx}}
 		gp21hmul       = regInfo{inputs: []regMask{ax, gpsp}, outputs: []regMask{dx}, clobbers: ax}
@@ -126,9 +128,9 @@ func init() {
 
 		gp2flags     = regInfo{inputs: []regMask{gpsp, gpsp}}
 		gp1flags     = regInfo{inputs: []regMask{gpsp}}
-		gp0flagsLoad = regInfo{inputs: []regMask{gpspsb, 0}}
-		gp1flagsLoad = regInfo{inputs: []regMask{gpspsb, gpsp, 0}}
-		gp2flagsLoad = regInfo{inputs: []regMask{gpspsb, gpsp, gpsp, 0}}
+		gp0flagsLoad = regInfo{inputs: []regMask{gpspsbg, 0}}
+		gp1flagsLoad = regInfo{inputs: []regMask{gpspsbg, gpsp, 0}}
+		gp2flagsLoad = regInfo{inputs: []regMask{gpspsbg, gpsp, gpsp, 0}}
 		flagsgp      = regInfo{inputs: nil, outputs: gponly}
 
 		gp11flags      = regInfo{inputs: []regMask{gp}, outputs: []regMask{gp, 0}}
@@ -137,24 +139,24 @@ func init() {
 		readflags = regInfo{inputs: nil, outputs: gponly}
 		flagsgpax = regInfo{inputs: nil, clobbers: ax, outputs: []regMask{gp &^ ax}}
 
-		gpload      = regInfo{inputs: []regMask{gpspsb, 0}, outputs: gponly}
-		gp21load    = regInfo{inputs: []regMask{gp, gpspsb, 0}, outputs: gponly}
-		gploadidx   = regInfo{inputs: []regMask{gpspsb, gpsp, 0}, outputs: gponly}
-		gp21loadidx = regInfo{inputs: []regMask{gp, gpspsb, gpsp, 0}, outputs: gponly}
+		gpload      = regInfo{inputs: []regMask{gpspsbg, 0}, outputs: gponly}
+		gp21load    = regInfo{inputs: []regMask{gp, gpspsbg, 0}, outputs: gponly}
+		gploadidx   = regInfo{inputs: []regMask{gpspsbg, gpsp, 0}, outputs: gponly}
+		gp21loadidx = regInfo{inputs: []regMask{gp, gpspsbg, gpsp, 0}, outputs: gponly}
 		gp21pax     = regInfo{inputs: []regMask{gp &^ ax, gp}, outputs: []regMask{gp &^ ax}, clobbers: ax}
 
-		gpstore         = regInfo{inputs: []regMask{gpspsb, gpsp, 0}}
-		gpstoreconst    = regInfo{inputs: []regMask{gpspsb, 0}}
-		gpstoreidx      = regInfo{inputs: []regMask{gpspsb, gpsp, gpsp, 0}}
-		gpstoreconstidx = regInfo{inputs: []regMask{gpspsb, gpsp, 0}}
-		gpstorexchg     = regInfo{inputs: []regMask{gp, gpspsb, 0}, outputs: []regMask{gp}}
+		gpstore         = regInfo{inputs: []regMask{gpspsbg, gpsp, 0}}
+		gpstoreconst    = regInfo{inputs: []regMask{gpspsbg, 0}}
+		gpstoreidx      = regInfo{inputs: []regMask{gpspsbg, gpsp, gpsp, 0}}
+		gpstoreconstidx = regInfo{inputs: []regMask{gpspsbg, gpsp, 0}}
+		gpstorexchg     = regInfo{inputs: []regMask{gp, gpspsbg, 0}, outputs: []regMask{gp}}
 		cmpxchg         = regInfo{inputs: []regMask{gp, ax, gp, 0}, outputs: []regMask{gp, 0}, clobbers: ax}
 
 		fp01        = regInfo{inputs: nil, outputs: fponly}
 		fp21        = regInfo{inputs: []regMask{fp, fp}, outputs: fponly}
 		fp31        = regInfo{inputs: []regMask{fp, fp, fp}, outputs: fponly}
-		fp21load    = regInfo{inputs: []regMask{fp, gpspsb, 0}, outputs: fponly}
-		fp21loadidx = regInfo{inputs: []regMask{fp, gpspsb, gpspsb, 0}, outputs: fponly}
+		fp21load    = regInfo{inputs: []regMask{fp, gpspsbg, 0}, outputs: fponly}
+		fp21loadidx = regInfo{inputs: []regMask{fp, gpspsbg, gpspsb, 0}, outputs: fponly}
 		fpgp        = regInfo{inputs: fponly, outputs: gponly}
 		gpfp        = regInfo{inputs: gponly, outputs: fponly}
 		fp11        = regInfo{inputs: fponly, outputs: fponly}
@@ -830,7 +832,7 @@ func init() {
 		{name: "LoweredNilCheck", argLength: 2, reg: regInfo{inputs: []regMask{gpsp}}, clobberFlags: true, nilCheck: true, faultOnNilArg0: true},
 		// LoweredWB invokes runtime.gcWriteBarrier. arg0=destptr, arg1=srcptr, arg2=mem, aux=runtime.gcWriteBarrier
 		// It saves all GP registers if necessary, but may clobber others.
-		{name: "LoweredWB", argLength: 3, reg: regInfo{inputs: []regMask{buildReg("DI"), buildReg("AX CX DX BX BP SI R8 R9")}, clobbers: callerSave &^ gp}, clobberFlags: true, aux: "Sym", symEffect: "None"},
+		{name: "LoweredWB", argLength: 3, reg: regInfo{inputs: []regMask{buildReg("DI"), buildReg("AX CX DX BX BP SI R8 R9")}, clobbers: callerSave &^ (gp | g)}, clobberFlags: true, aux: "Sym", symEffect: "None"},
 
 		{name: "LoweredHasCPUFeature", argLength: 0, reg: gp01, rematerializeable: true, typ: "UInt64", aux: "Sym", symEffect: "None"},
 
diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go
index aaf9101368..6388aab362 100644
--- a/src/cmd/compile/internal/ssa/gen/rulegen.go
+++ b/src/cmd/compile/internal/ssa/gen/rulegen.go
@@ -582,6 +582,7 @@ func fprint(w io.Writer, n Node) {
 			"math",
 			"cmd/internal/obj",
 			"cmd/internal/objabi",
+			"cmd/compile/internal/base",
 			"cmd/compile/internal/types",
 		}, n.Arch.imports...) {
 			fmt.Fprintf(w, "import %q\n", path)
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index 9ad4c2f305..ccfed93475 100644
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -6287,7 +6287,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVSS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6303,7 +6303,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVSD,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6343,8 +6343,8 @@ var opcodeTable = [...]opInfo{
 		scale:     1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6360,8 +6360,8 @@ var opcodeTable = [...]opInfo{
 		scale:     4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6377,8 +6377,8 @@ var opcodeTable = [...]opInfo{
 		scale:     1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6394,8 +6394,8 @@ var opcodeTable = [...]opInfo{
 		scale:     8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6412,7 +6412,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
 			},
 		},
 	},
@@ -6426,7 +6426,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
 			},
 		},
 	},
@@ -6439,9 +6439,9 @@ var opcodeTable = [...]opInfo{
 		scale:     1,
 		reg: regInfo{
 			inputs: []inputInfo{
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 				{2, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
 			},
 		},
 	},
@@ -6454,9 +6454,9 @@ var opcodeTable = [...]opInfo{
 		scale:     4,
 		reg: regInfo{
 			inputs: []inputInfo{
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 				{2, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
 			},
 		},
 	},
@@ -6469,9 +6469,9 @@ var opcodeTable = [...]opInfo{
 		scale:     1,
 		reg: regInfo{
 			inputs: []inputInfo{
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 				{2, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
 			},
 		},
 	},
@@ -6484,9 +6484,9 @@ var opcodeTable = [...]opInfo{
 		scale:     8,
 		reg: regInfo{
 			inputs: []inputInfo{
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 				{2, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
 			},
 		},
 	},
@@ -6501,7 +6501,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6519,7 +6519,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6537,7 +6537,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6555,7 +6555,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6573,7 +6573,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6591,7 +6591,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6609,7 +6609,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6627,7 +6627,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6645,8 +6645,8 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6664,8 +6664,8 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6683,8 +6683,8 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6702,8 +6702,8 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6721,8 +6721,8 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6740,8 +6740,8 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6759,8 +6759,8 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6778,8 +6778,8 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6797,8 +6797,8 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6816,8 +6816,8 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6835,8 +6835,8 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6854,8 +6854,8 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6873,8 +6873,8 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6892,8 +6892,8 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6911,8 +6911,8 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6930,8 +6930,8 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
-				{2, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{2, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -6946,11 +6946,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AADDQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -6962,11 +6962,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AADDL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -6978,10 +6978,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AADDQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -6993,10 +6993,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AADDL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7010,7 +7010,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AADDQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -7024,7 +7024,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AADDL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -7036,11 +7036,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ASUBQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7052,11 +7052,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ASUBL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7069,10 +7069,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ASUBQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7085,10 +7085,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ASUBL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7101,11 +7101,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AIMULQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7118,11 +7118,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AIMULL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7134,10 +7134,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AIMUL3Q,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7149,10 +7149,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AIMUL3L,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7165,7 +7165,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 1},     // AX
-				{1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			clobbers: 4, // DX
 			outputs: []outputInfo{
@@ -7183,7 +7183,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 1},     // AX
-				{1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			clobbers: 4, // DX
 			outputs: []outputInfo{
@@ -7200,7 +7200,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 1},     // AX
-				{1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			clobbers: 1, // AX
 			outputs: []outputInfo{
@@ -7216,7 +7216,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 1},     // AX
-				{1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			clobbers: 1, // AX
 			outputs: []outputInfo{
@@ -7232,7 +7232,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 1},     // AX
-				{1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			clobbers: 1, // AX
 			outputs: []outputInfo{
@@ -7248,7 +7248,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 1},     // AX
-				{1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			clobbers: 1, // AX
 			outputs: []outputInfo{
@@ -7264,11 +7264,11 @@ var opcodeTable = [...]opInfo{
 		clobberFlags: true,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7281,7 +7281,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 1},     // AX
-				{1, 65531}, // AX CX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{1, 49147}, // AX CX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{0, 1}, // AX
@@ -7298,7 +7298,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 1},     // AX
-				{1, 65531}, // AX CX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{1, 49147}, // AX CX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{0, 1}, // AX
@@ -7315,7 +7315,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 1},     // AX
-				{1, 65531}, // AX CX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{1, 49147}, // AX CX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{0, 1}, // AX
@@ -7331,7 +7331,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 1},     // AX
-				{1, 65531}, // AX CX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{1, 49147}, // AX CX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{0, 1}, // AX
@@ -7347,7 +7347,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 1},     // AX
-				{1, 65531}, // AX CX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{1, 49147}, // AX CX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{0, 1}, // AX
@@ -7363,7 +7363,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 1},     // AX
-				{1, 65531}, // AX CX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{1, 49147}, // AX CX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{0, 1}, // AX
@@ -7378,11 +7378,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ANEGL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{1, 0},
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7394,12 +7394,12 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AADDQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{1, 0},
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7411,12 +7411,12 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AADCQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{1, 0},
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7428,11 +7428,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AADDQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{1, 0},
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7444,11 +7444,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AADCQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{1, 0},
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7459,12 +7459,12 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ASUBQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{1, 0},
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7475,12 +7475,12 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ASBBQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{1, 0},
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7492,11 +7492,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ASUBQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{1, 0},
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7508,11 +7508,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ASBBQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{1, 0},
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7525,7 +7525,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 1},     // AX
-				{1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{0, 4}, // DX
@@ -7542,7 +7542,7 @@ var opcodeTable = [...]opInfo{
 			inputs: []inputInfo{
 				{0, 4},     // DX
 				{1, 1},     // AX
-				{2, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{2, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{0, 1}, // AX
@@ -7559,11 +7559,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AANDQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7576,11 +7576,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AANDL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7593,10 +7593,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AANDQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7609,10 +7609,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AANDL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7626,7 +7626,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AANDQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -7640,7 +7640,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AANDL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -7653,11 +7653,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AORQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7670,11 +7670,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AORL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7687,10 +7687,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AORQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7703,10 +7703,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AORL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7720,7 +7720,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AORQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -7734,7 +7734,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AORL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -7747,11 +7747,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AXORQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7764,11 +7764,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AXORL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7781,10 +7781,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AXORQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7797,10 +7797,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AXORL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7814,7 +7814,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AXORQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -7828,7 +7828,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AXORL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -7838,8 +7838,8 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ACMPQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7849,8 +7849,8 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ACMPL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7860,8 +7860,8 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ACMPW,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7871,8 +7871,8 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ACMPB,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7883,7 +7883,7 @@ var opcodeTable = [...]opInfo{
 		asm:     x86.ACMPQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7894,7 +7894,7 @@ var opcodeTable = [...]opInfo{
 		asm:     x86.ACMPL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7905,7 +7905,7 @@ var opcodeTable = [...]opInfo{
 		asm:     x86.ACMPW,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7916,7 +7916,7 @@ var opcodeTable = [...]opInfo{
 		asm:     x86.ACMPB,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -7929,8 +7929,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ACMPQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -7943,8 +7943,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ACMPL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -7957,8 +7957,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ACMPW,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -7971,8 +7971,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ACMPB,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -7985,7 +7985,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ACMPQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -7998,7 +7998,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ACMPL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8011,7 +8011,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ACMPW,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8024,7 +8024,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ACMPB,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8037,9 +8037,9 @@ var opcodeTable = [...]opInfo{
 		scale:     8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8053,9 +8053,9 @@ var opcodeTable = [...]opInfo{
 		scale:       1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8068,9 +8068,9 @@ var opcodeTable = [...]opInfo{
 		scale:     4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8084,9 +8084,9 @@ var opcodeTable = [...]opInfo{
 		scale:       1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8099,9 +8099,9 @@ var opcodeTable = [...]opInfo{
 		scale:     2,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8115,9 +8115,9 @@ var opcodeTable = [...]opInfo{
 		scale:       1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8131,9 +8131,9 @@ var opcodeTable = [...]opInfo{
 		scale:       1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8146,8 +8146,8 @@ var opcodeTable = [...]opInfo{
 		scale:     8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8161,8 +8161,8 @@ var opcodeTable = [...]opInfo{
 		scale:       1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8175,8 +8175,8 @@ var opcodeTable = [...]opInfo{
 		scale:     4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8190,8 +8190,8 @@ var opcodeTable = [...]opInfo{
 		scale:       1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8204,8 +8204,8 @@ var opcodeTable = [...]opInfo{
 		scale:     2,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8219,8 +8219,8 @@ var opcodeTable = [...]opInfo{
 		scale:       1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8234,8 +8234,8 @@ var opcodeTable = [...]opInfo{
 		scale:       1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8267,8 +8267,8 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ABTL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8278,8 +8278,8 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ABTQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8291,11 +8291,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ABTCL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8307,11 +8307,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ABTCQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8323,11 +8323,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ABTRL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8339,11 +8339,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ABTRQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8355,11 +8355,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ABTSL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8371,11 +8371,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ABTSQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8386,7 +8386,7 @@ var opcodeTable = [...]opInfo{
 		asm:     x86.ABTL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8397,7 +8397,7 @@ var opcodeTable = [...]opInfo{
 		asm:     x86.ABTQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8410,10 +8410,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ABTCL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8426,10 +8426,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ABTCQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8442,10 +8442,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ABTRL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8458,10 +8458,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ABTRQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8474,10 +8474,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ABTSL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8490,10 +8490,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ABTSQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8507,8 +8507,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ABTCQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8522,8 +8522,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ABTCL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8537,8 +8537,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ABTSQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8552,8 +8552,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ABTSL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8567,8 +8567,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ABTRQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8582,8 +8582,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ABTRL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8597,7 +8597,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ABTCQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8611,7 +8611,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ABTCL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8625,7 +8625,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ABTSQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8639,7 +8639,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ABTSL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8653,7 +8653,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ABTRQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8667,7 +8667,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ABTRL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -8678,8 +8678,8 @@ var opcodeTable = [...]opInfo{
 		asm:         x86.ATESTQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8690,8 +8690,8 @@ var opcodeTable = [...]opInfo{
 		asm:         x86.ATESTL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8702,8 +8702,8 @@ var opcodeTable = [...]opInfo{
 		asm:         x86.ATESTW,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8714,8 +8714,8 @@ var opcodeTable = [...]opInfo{
 		asm:         x86.ATESTB,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8726,7 +8726,7 @@ var opcodeTable = [...]opInfo{
 		asm:     x86.ATESTQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8737,7 +8737,7 @@ var opcodeTable = [...]opInfo{
 		asm:     x86.ATESTL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8748,7 +8748,7 @@ var opcodeTable = [...]opInfo{
 		asm:     x86.ATESTW,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8759,7 +8759,7 @@ var opcodeTable = [...]opInfo{
 		asm:     x86.ATESTB,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8772,10 +8772,10 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{1, 2},     // CX
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8788,10 +8788,10 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{1, 2},     // CX
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8804,10 +8804,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ASHLQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8820,10 +8820,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ASHLL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8836,10 +8836,10 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{1, 2},     // CX
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8852,10 +8852,10 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{1, 2},     // CX
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8868,10 +8868,10 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{1, 2},     // CX
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8884,10 +8884,10 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{1, 2},     // CX
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8900,10 +8900,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ASHRQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8916,10 +8916,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ASHRL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8932,10 +8932,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ASHRW,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8948,10 +8948,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ASHRB,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8964,10 +8964,10 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{1, 2},     // CX
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8980,10 +8980,10 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{1, 2},     // CX
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -8996,10 +8996,10 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{1, 2},     // CX
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9012,10 +9012,10 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{1, 2},     // CX
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9028,10 +9028,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ASARQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9044,10 +9044,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ASARL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9060,10 +9060,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ASARW,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9076,10 +9076,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ASARB,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9092,10 +9092,10 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{1, 2},     // CX
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9108,10 +9108,10 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{1, 2},     // CX
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9124,10 +9124,10 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{1, 2},     // CX
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9140,10 +9140,10 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{1, 2},     // CX
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9156,10 +9156,10 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{1, 2},     // CX
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9172,10 +9172,10 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{1, 2},     // CX
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9188,10 +9188,10 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{1, 2},     // CX
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9204,10 +9204,10 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{1, 2},     // CX
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9220,10 +9220,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AROLQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9236,10 +9236,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AROLL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9252,10 +9252,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AROLW,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9268,10 +9268,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.AROLB,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9286,11 +9286,11 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AADDL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9305,11 +9305,11 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AADDQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9324,11 +9324,11 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ASUBQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9343,11 +9343,11 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ASUBL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9362,11 +9362,11 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AANDL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9381,11 +9381,11 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AANDQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9400,11 +9400,11 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AORQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9419,11 +9419,11 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AORL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9438,11 +9438,11 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AXORQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9457,11 +9457,11 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AXORL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9476,12 +9476,12 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9496,12 +9496,12 @@ var opcodeTable = [...]opInfo{
 		scale:        4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9516,12 +9516,12 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9536,12 +9536,12 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9556,12 +9556,12 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9576,12 +9576,12 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9596,12 +9596,12 @@ var opcodeTable = [...]opInfo{
 		scale:        4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9616,12 +9616,12 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9636,12 +9636,12 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9656,12 +9656,12 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9676,12 +9676,12 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9696,12 +9696,12 @@ var opcodeTable = [...]opInfo{
 		scale:        4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9716,12 +9716,12 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9736,12 +9736,12 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9756,12 +9756,12 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9776,12 +9776,12 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9796,12 +9796,12 @@ var opcodeTable = [...]opInfo{
 		scale:        4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9816,12 +9816,12 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9836,12 +9836,12 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9856,12 +9856,12 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9876,12 +9876,12 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9896,12 +9896,12 @@ var opcodeTable = [...]opInfo{
 		scale:        4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9916,12 +9916,12 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9936,12 +9936,12 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9956,12 +9956,12 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -9975,8 +9975,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AADDQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -9990,8 +9990,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ASUBQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10005,8 +10005,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AANDQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10020,8 +10020,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AORQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10035,8 +10035,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AXORQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10050,8 +10050,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AADDL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10065,8 +10065,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ASUBL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10080,8 +10080,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AANDL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10095,8 +10095,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AORL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10110,8 +10110,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AXORL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10125,9 +10125,9 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10141,9 +10141,9 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10157,9 +10157,9 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10173,9 +10173,9 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10189,9 +10189,9 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10205,9 +10205,9 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10221,9 +10221,9 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10237,9 +10237,9 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10253,9 +10253,9 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10269,9 +10269,9 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10285,9 +10285,9 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10301,9 +10301,9 @@ var opcodeTable = [...]opInfo{
 		scale:        4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10317,9 +10317,9 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10333,9 +10333,9 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10349,9 +10349,9 @@ var opcodeTable = [...]opInfo{
 		scale:        4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10365,9 +10365,9 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10381,9 +10381,9 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10397,9 +10397,9 @@ var opcodeTable = [...]opInfo{
 		scale:        4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10413,9 +10413,9 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10429,9 +10429,9 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10445,9 +10445,9 @@ var opcodeTable = [...]opInfo{
 		scale:        4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10461,9 +10461,9 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10477,9 +10477,9 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10493,9 +10493,9 @@ var opcodeTable = [...]opInfo{
 		scale:        4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10509,9 +10509,9 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10525,8 +10525,8 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10540,8 +10540,8 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10555,8 +10555,8 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10570,8 +10570,8 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10585,8 +10585,8 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10600,8 +10600,8 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10615,8 +10615,8 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10630,8 +10630,8 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10645,8 +10645,8 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10660,8 +10660,8 @@ var opcodeTable = [...]opInfo{
 		scale:        4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10675,8 +10675,8 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10690,8 +10690,8 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10705,8 +10705,8 @@ var opcodeTable = [...]opInfo{
 		scale:        4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10720,8 +10720,8 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10735,8 +10735,8 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10750,8 +10750,8 @@ var opcodeTable = [...]opInfo{
 		scale:        4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10765,8 +10765,8 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10780,8 +10780,8 @@ var opcodeTable = [...]opInfo{
 		scale:        1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10795,8 +10795,8 @@ var opcodeTable = [...]opInfo{
 		scale:        4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10810,8 +10810,8 @@ var opcodeTable = [...]opInfo{
 		scale:        8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -10823,10 +10823,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ANEGQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -10838,10 +10838,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ANEGL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -10853,10 +10853,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ANOTQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -10868,10 +10868,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ANOTL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -10881,11 +10881,11 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ABSFQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{1, 0},
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -10896,10 +10896,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ABSFL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -10909,11 +10909,11 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ABSRQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{1, 0},
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -10924,10 +10924,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ABSRL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -10938,11 +10938,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVQEQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -10953,11 +10953,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVQNE,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -10968,11 +10968,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVQLT,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -10983,11 +10983,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVQGT,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -10998,11 +10998,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVQLE,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11013,11 +11013,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVQGE,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11028,11 +11028,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVQLS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11043,11 +11043,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVQHI,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11058,11 +11058,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVQCC,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11073,11 +11073,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVQCS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11088,11 +11088,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVLEQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11103,11 +11103,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVLNE,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11118,11 +11118,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVLLT,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11133,11 +11133,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVLGT,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11148,11 +11148,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVLLE,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11163,11 +11163,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVLGE,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11178,11 +11178,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVLLS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11193,11 +11193,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVLHI,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11208,11 +11208,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVLCC,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11223,11 +11223,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVLCS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11238,11 +11238,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVWEQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11253,11 +11253,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVWNE,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11268,11 +11268,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVWLT,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11283,11 +11283,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVWGT,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11298,11 +11298,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVWLE,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11313,11 +11313,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVWGE,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11328,11 +11328,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVWLS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11343,11 +11343,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVWHI,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11358,11 +11358,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVWCC,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11373,11 +11373,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVWCS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11388,12 +11388,12 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVQNE,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65518}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49134}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			clobbers: 1, // AX
 			outputs: []outputInfo{
-				{0, 65518}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49134}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11404,11 +11404,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVQNE,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11419,11 +11419,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVQHI,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11434,11 +11434,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVQCC,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11449,12 +11449,12 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVLNE,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65518}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49134}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			clobbers: 1, // AX
 			outputs: []outputInfo{
-				{0, 65518}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49134}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11465,11 +11465,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVLNE,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11480,11 +11480,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVLHI,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11495,11 +11495,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVLCC,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11510,12 +11510,12 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVWNE,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65518}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49134}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			clobbers: 1, // AX
 			outputs: []outputInfo{
-				{0, 65518}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49134}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11526,11 +11526,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVWNE,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11541,11 +11541,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVWHI,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11556,11 +11556,11 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ACMOVWCC,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11572,10 +11572,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ABSWAPQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11587,10 +11587,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.ABSWAPL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11601,10 +11601,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.APOPCNTQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11615,10 +11615,10 @@ var opcodeTable = [...]opInfo{
 		asm:          x86.APOPCNTL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11671,7 +11671,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ASBBQ,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11681,7 +11681,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ASBBL,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11691,7 +11691,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ASETEQ,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11701,7 +11701,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ASETNE,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11711,7 +11711,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ASETLT,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11721,7 +11721,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ASETLE,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11731,7 +11731,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ASETGT,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11741,7 +11741,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ASETGE,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11751,7 +11751,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ASETCS,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11761,7 +11761,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ASETLS,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11771,7 +11771,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ASETHI,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11781,7 +11781,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ASETCC,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11791,7 +11791,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ASETOS,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11804,7 +11804,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ASETEQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -11817,7 +11817,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ASETNE,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -11830,7 +11830,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ASETLT,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -11843,7 +11843,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ASETLE,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -11856,7 +11856,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ASETGT,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -11869,7 +11869,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ASETGE,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -11882,7 +11882,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ASETCS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -11895,7 +11895,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ASETLS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -11908,7 +11908,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ASETHI,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -11921,7 +11921,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.ASETCC,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -11933,7 +11933,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			clobbers: 1, // AX
 			outputs: []outputInfo{
-				{0, 65518}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49134}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11945,7 +11945,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			clobbers: 1, // AX
 			outputs: []outputInfo{
-				{0, 65518}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49134}, // CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11955,7 +11955,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ASETPC,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11965,7 +11965,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ASETPS,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11975,7 +11975,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ASETHI,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11985,7 +11985,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ASETCC,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -11995,10 +11995,10 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.AMOVBQSX,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12008,10 +12008,10 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.AMOVBLZX,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12021,10 +12021,10 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.AMOVWQSX,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12034,10 +12034,10 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.AMOVWLZX,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12047,10 +12047,10 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.AMOVLQSX,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12060,10 +12060,10 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.AMOVL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12075,7 +12075,7 @@ var opcodeTable = [...]opInfo{
 		asm:               x86.AMOVL,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12087,7 +12087,7 @@ var opcodeTable = [...]opInfo{
 		asm:               x86.AMOVQ,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12100,7 +12100,7 @@ var opcodeTable = [...]opInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12113,7 +12113,7 @@ var opcodeTable = [...]opInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12126,7 +12126,7 @@ var opcodeTable = [...]opInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12139,7 +12139,7 @@ var opcodeTable = [...]opInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12149,7 +12149,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ACVTSL2SS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -12162,7 +12162,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ACVTSL2SD,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -12175,7 +12175,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ACVTSQ2SS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -12188,7 +12188,7 @@ var opcodeTable = [...]opInfo{
 		asm:    x86.ACVTSQ2SD,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -12226,7 +12226,7 @@ var opcodeTable = [...]opInfo{
 		argLen: 1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -12241,7 +12241,7 @@ var opcodeTable = [...]opInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12250,7 +12250,7 @@ var opcodeTable = [...]opInfo{
 		argLen: 1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -12265,7 +12265,7 @@ var opcodeTable = [...]opInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12294,10 +12294,10 @@ var opcodeTable = [...]opInfo{
 		asm:               x86.ALEAQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12310,10 +12310,10 @@ var opcodeTable = [...]opInfo{
 		asm:               x86.ALEAL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12326,10 +12326,10 @@ var opcodeTable = [...]opInfo{
 		asm:               x86.ALEAW,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12343,11 +12343,11 @@ var opcodeTable = [...]opInfo{
 		scale:       1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12361,11 +12361,11 @@ var opcodeTable = [...]opInfo{
 		scale:       1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12379,11 +12379,11 @@ var opcodeTable = [...]opInfo{
 		scale:       1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12396,11 +12396,11 @@ var opcodeTable = [...]opInfo{
 		scale:     2,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12413,11 +12413,11 @@ var opcodeTable = [...]opInfo{
 		scale:     2,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12430,11 +12430,11 @@ var opcodeTable = [...]opInfo{
 		scale:     2,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12447,11 +12447,11 @@ var opcodeTable = [...]opInfo{
 		scale:     4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12464,11 +12464,11 @@ var opcodeTable = [...]opInfo{
 		scale:     4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12481,11 +12481,11 @@ var opcodeTable = [...]opInfo{
 		scale:     4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12498,11 +12498,11 @@ var opcodeTable = [...]opInfo{
 		scale:     8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12515,11 +12515,11 @@ var opcodeTable = [...]opInfo{
 		scale:     8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12532,11 +12532,11 @@ var opcodeTable = [...]opInfo{
 		scale:     8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12549,10 +12549,10 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVBLZX,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12565,10 +12565,10 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVBQSX,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12581,10 +12581,10 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVWLZX,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12597,10 +12597,10 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVWQSX,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12613,10 +12613,10 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12629,10 +12629,10 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVLQSX,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12645,10 +12645,10 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12661,8 +12661,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVB,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -12675,8 +12675,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVW,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -12689,8 +12689,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -12703,8 +12703,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -12717,7 +12717,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVUPS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
 			},
 			outputs: []outputInfo{
 				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
@@ -12734,7 +12734,7 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
 			},
 		},
 	},
@@ -12747,7 +12747,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVUPS,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295016447}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15 SB
 			},
 		},
 	},
@@ -12761,11 +12761,11 @@ var opcodeTable = [...]opInfo{
 		scale:       1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12779,11 +12779,11 @@ var opcodeTable = [...]opInfo{
 		scale:       1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12796,11 +12796,11 @@ var opcodeTable = [...]opInfo{
 		scale:     2,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12814,11 +12814,11 @@ var opcodeTable = [...]opInfo{
 		scale:       1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12831,11 +12831,11 @@ var opcodeTable = [...]opInfo{
 		scale:     4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12848,11 +12848,11 @@ var opcodeTable = [...]opInfo{
 		scale:     8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12866,11 +12866,11 @@ var opcodeTable = [...]opInfo{
 		scale:       1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12883,11 +12883,11 @@ var opcodeTable = [...]opInfo{
 		scale:     8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -12901,9 +12901,9 @@ var opcodeTable = [...]opInfo{
 		scale:       1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -12917,9 +12917,9 @@ var opcodeTable = [...]opInfo{
 		scale:       1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -12932,9 +12932,9 @@ var opcodeTable = [...]opInfo{
 		scale:     2,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -12948,9 +12948,9 @@ var opcodeTable = [...]opInfo{
 		scale:       1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -12963,9 +12963,9 @@ var opcodeTable = [...]opInfo{
 		scale:     4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -12978,9 +12978,9 @@ var opcodeTable = [...]opInfo{
 		scale:     8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -12994,9 +12994,9 @@ var opcodeTable = [...]opInfo{
 		scale:       1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -13009,9 +13009,9 @@ var opcodeTable = [...]opInfo{
 		scale:     8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -13024,7 +13024,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVB,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -13037,7 +13037,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVW,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -13050,7 +13050,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -13063,7 +13063,7 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -13077,8 +13077,8 @@ var opcodeTable = [...]opInfo{
 		scale:       1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -13092,8 +13092,8 @@ var opcodeTable = [...]opInfo{
 		scale:       1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -13106,8 +13106,8 @@ var opcodeTable = [...]opInfo{
 		scale:     2,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -13121,8 +13121,8 @@ var opcodeTable = [...]opInfo{
 		scale:       1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -13135,8 +13135,8 @@ var opcodeTable = [...]opInfo{
 		scale:     4,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -13150,8 +13150,8 @@ var opcodeTable = [...]opInfo{
 		scale:       1,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -13164,8 +13164,8 @@ var opcodeTable = [...]opInfo{
 		scale:     8,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -13202,7 +13202,7 @@ var opcodeTable = [...]opInfo{
 		clobberFlags: true,
 		call:         true,
 		reg: regInfo{
-			clobbers: 2147483631, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+			clobbers: 2147483631, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 g R15 X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 		},
 	},
 	{
@@ -13214,9 +13214,9 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{1, 4},     // DX
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
-			clobbers: 2147483631, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+			clobbers: 2147483631, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 g R15 X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 		},
 	},
 	{
@@ -13227,9 +13227,9 @@ var opcodeTable = [...]opInfo{
 		call:         true,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
-			clobbers: 2147483631, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+			clobbers: 2147483631, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 g R15 X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
 		},
 	},
 	{
@@ -13272,7 +13272,7 @@ var opcodeTable = [...]opInfo{
 		argLen: 1,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -13292,7 +13292,7 @@ var opcodeTable = [...]opInfo{
 		rematerializeable: true,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -13302,7 +13302,7 @@ var opcodeTable = [...]opInfo{
 		rematerializeable: true,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -13314,7 +13314,7 @@ var opcodeTable = [...]opInfo{
 		faultOnNilArg0: true,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65535}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49151}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -13340,7 +13340,7 @@ var opcodeTable = [...]opInfo{
 		symEffect:         SymNone,
 		reg: regInfo{
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -13414,10 +13414,10 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVB,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -13430,10 +13430,10 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -13446,10 +13446,10 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AMOVQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -13464,11 +13464,11 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AXCHGB,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -13483,11 +13483,11 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AXCHGL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -13502,11 +13502,11 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AXCHGQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -13522,11 +13522,11 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AXADDL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -13542,11 +13542,11 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AXADDQ,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 65519},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{0, 49135},      // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 			outputs: []outputInfo{
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -13572,13 +13572,13 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{1, 1},     // AX
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			clobbers: 1, // AX
 			outputs: []outputInfo{
 				{1, 0},
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -13594,13 +13594,13 @@ var opcodeTable = [...]opInfo{
 		reg: regInfo{
 			inputs: []inputInfo{
 				{1, 1},     // AX
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{2, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{2, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 			clobbers: 1, // AX
 			outputs: []outputInfo{
 				{1, 0},
-				{0, 65519}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
 			},
 		},
 	},
@@ -13615,8 +13615,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AANDB,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -13631,8 +13631,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AANDL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -13647,8 +13647,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AORB,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -13663,8 +13663,8 @@ var opcodeTable = [...]opInfo{
 		asm:            x86.AORL,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{1, 65535},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 SB
+				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
 			},
 		},
 	},
@@ -36173,8 +36173,8 @@ var registersAMD64 = [...]Register{
 	{11, x86.REG_R11, 10, "R11"},
 	{12, x86.REG_R12, 11, "R12"},
 	{13, x86.REG_R13, 12, "R13"},
-	{14, x86.REG_R14, 13, "R14"},
-	{15, x86.REG_R15, 14, "R15"},
+	{14, x86.REGG, -1, "g"},
+	{15, x86.REG_R15, 13, "R15"},
 	{16, x86.REG_X0, -1, "X0"},
 	{17, x86.REG_X1, -1, "X1"},
 	{18, x86.REG_X2, -1, "X2"},
@@ -36193,7 +36193,7 @@ var registersAMD64 = [...]Register{
 	{31, x86.REG_X15, -1, "X15"},
 	{32, 0, -1, "SB"},
 }
-var gpRegMaskAMD64 = regMask(65519)
+var gpRegMaskAMD64 = regMask(49135)
 var fpRegMaskAMD64 = regMask(2147418112)
 var specialRegMaskAMD64 = regMask(2147483648)
 var framepointerRegAMD64 = int8(5)
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index 6087874fa9..03498c719c 100644
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -4,6 +4,7 @@
 package ssa
 
 import "math"
+import "cmd/compile/internal/base"
 import "cmd/compile/internal/types"
 
 func rewriteValueAMD64(v *Value) bool {
@@ -767,8 +768,7 @@ func rewriteValueAMD64(v *Value) bool {
 		v.Op = OpAMD64LoweredGetClosurePtr
 		return true
 	case OpGetG:
-		v.Op = OpAMD64LoweredGetG
-		return true
+		return rewriteValueAMD64_OpGetG(v)
 	case OpHasCPUFeature:
 		return rewriteValueAMD64_OpHasCPUFeature(v)
 	case OpHmul32:
@@ -30126,6 +30126,22 @@ func rewriteValueAMD64_OpFloor(v *Value) bool {
 		return true
 	}
 }
+func rewriteValueAMD64_OpGetG(v *Value) bool {
+	v_0 := v.Args[0]
+	// match: (GetG mem)
+	// cond: !base.Flag.ABIWrap
+	// result: (LoweredGetG mem)
+	for {
+		mem := v_0
+		if !(!base.Flag.ABIWrap) {
+			break
+		}
+		v.reset(OpAMD64LoweredGetG)
+		v.AddArg(mem)
+		return true
+	}
+	return false
+}
 func rewriteValueAMD64_OpHasCPUFeature(v *Value) bool {
 	b := v.Block
 	typ := &b.Func.Config.Types
diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index a9456dc9ff..9f15990b13 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -262,6 +262,7 @@ TEXT runtime·gogo(SB), NOSPLIT, $16-8
 	MOVQ	0(DX), CX		// make sure g != nil
 	get_tls(CX)
 	MOVQ	DX, g(CX)
+	MOVQ	DX, R14		// set the g register
 	MOVQ	gobuf_sp(BX), SP	// restore SP
 	MOVQ	gobuf_ret(BX), AX
 	MOVQ	gobuf_ctxt(BX), DX
@@ -298,6 +299,7 @@ TEXT runtime·mcall(SB), NOSPLIT, $0-8
 	MOVQ	$runtime·badmcall(SB), AX
 	JMP	AX
 	MOVQ	SI, g(CX)	// g = m->g0
+	MOVQ	SI, R14	// set the g register
 	MOVQ	(g_sched+gobuf_sp)(SI), SP	// sp = m->g0->sched.sp
 	PUSHQ	AX
 	MOVQ	DI, DX
@@ -344,6 +346,7 @@ TEXT runtime·systemstack(SB), NOSPLIT, $0-8
 
 	// switch to g0
 	MOVQ	DX, g(CX)
+	MOVQ	DX, R14 // set the g register
 	MOVQ	(g_sched+gobuf_sp)(DX), BX
 	// make it look like mstart called systemstack on g0, to stop traceback
 	SUBQ	$8, BX
@@ -824,6 +827,7 @@ settls:
 TEXT setg_gcc<>(SB),NOSPLIT,$0
 	get_tls(AX)
 	MOVQ	DI, g(AX)
+	MOVQ	DI, R14 // set the g register
 	RET
 
 TEXT runtime·abort(SB),NOSPLIT,$0-0
@@ -1368,24 +1372,24 @@ TEXT runtime·addmoduledata(SB),NOSPLIT,$0-0
 // It clobbers FLAGS. It does not clobber any general-purpose registers,
 // but may clobber others (e.g., SSE registers).
 // Defined as ABIInternal since it does not use the stack-based Go ABI.
-TEXT runtime·gcWriteBarrier<ABIInternal>(SB),NOSPLIT,$120
+TEXT runtime·gcWriteBarrier<ABIInternal>(SB),NOSPLIT,$112
 	// Save the registers clobbered by the fast path. This is slightly
 	// faster than having the caller spill these.
-	MOVQ	R14, 104(SP)
-	MOVQ	R13, 112(SP)
+	MOVQ	R12, 96(SP)
+	MOVQ	R13, 104(SP)
 	// TODO: Consider passing g.m.p in as an argument so they can be shared
 	// across a sequence of write barriers.
 	get_tls(R13)
 	MOVQ	g(R13), R13
 	MOVQ	g_m(R13), R13
 	MOVQ	m_p(R13), R13
-	MOVQ	(p_wbBuf+wbBuf_next)(R13), R14
+	MOVQ	(p_wbBuf+wbBuf_next)(R13), R12
 	// Increment wbBuf.next position.
-	LEAQ	16(R14), R14
-	MOVQ	R14, (p_wbBuf+wbBuf_next)(R13)
-	CMPQ	R14, (p_wbBuf+wbBuf_end)(R13)
+	LEAQ	16(R12), R12
+	MOVQ	R12, (p_wbBuf+wbBuf_next)(R13)
+	CMPQ	R12, (p_wbBuf+wbBuf_end)(R13)
 	// Record the write.
-	MOVQ	AX, -16(R14)	// Record value
+	MOVQ	AX, -16(R12)	// Record value
 	// Note: This turns bad pointer writes into bad
 	// pointer reads, which could be confusing. We could avoid
 	// reading from obviously bad pointers, which would
@@ -1393,12 +1397,12 @@ TEXT runtime·gcWriteBarrier<ABIInternal>(SB),NOSPLIT,$120
 	// patch this up in the signal handler, or use XCHG to
 	// combine the read and the write.
 	MOVQ	(DI), R13
-	MOVQ	R13, -8(R14)	// Record *slot
+	MOVQ	R13, -8(R12)	// Record *slot
 	// Is the buffer full? (flags set in CMPQ above)
 	JEQ	flush
 ret:
-	MOVQ	104(SP), R14
-	MOVQ	112(SP), R13
+	MOVQ	96(SP), R12
+	MOVQ	104(SP), R13
 	// Do the write.
 	MOVQ	AX, (DI)
 	RET
@@ -1428,10 +1432,10 @@ flush:
 	MOVQ	R9, 64(SP)
 	MOVQ	R10, 72(SP)
 	MOVQ	R11, 80(SP)
-	MOVQ	R12, 88(SP)
+	// R12 already saved
 	// R13 already saved
-	// R14 already saved
-	MOVQ	R15, 96(SP)
+	// R14 is g
+	MOVQ	R15, 88(SP)
 
 	// This takes arguments DI and AX
 	CALL	runtime·wbBufFlush(SB)
@@ -1447,8 +1451,7 @@ flush:
 	MOVQ	64(SP), R9
 	MOVQ	72(SP), R10
 	MOVQ	80(SP), R11
-	MOVQ	88(SP), R12
-	MOVQ	96(SP), R15
+	MOVQ	88(SP), R15
 	JMP	ret
 
 // gcWriteBarrierCX is gcWriteBarrier, but with args in DI and CX.
diff --git a/src/runtime/race_amd64.s b/src/runtime/race_amd64.s
index fd41b5690a..7f97025c1a 100644
--- a/src/runtime/race_amd64.s
+++ b/src/runtime/race_amd64.s
@@ -452,12 +452,13 @@ rest:
 	PUSHQ	R15
 	// Set g = g0.
 	get_tls(R12)
-	MOVQ	g(R12), R13
-	MOVQ	g_m(R13), R14
-	MOVQ	m_g0(R14), R15
+	MOVQ	g(R12), R14
+	MOVQ	g_m(R14), R13
+	MOVQ	m_g0(R13), R15
 	CMPQ	R13, R15
 	JEQ	noswitch	// branch if already on g0
 	MOVQ	R15, g(R12)	// g = m->g0
+	MOVQ	R15, R14	// set g register
 	PUSHQ	RARG1	// func arg
 	PUSHQ	RARG0	// func arg
 	CALL	runtime·racecallback(SB)
diff --git a/src/runtime/sys_linux_amd64.s b/src/runtime/sys_linux_amd64.s
index 37cb8dad03..b0a201fc6f 100644
--- a/src/runtime/sys_linux_amd64.s
+++ b/src/runtime/sys_linux_amd64.s
@@ -632,6 +632,7 @@ nog1:
 	get_tls(CX)
 	MOVQ	R13, g_m(R9)
 	MOVQ	R9, g(CX)
+	MOVQ	R9, R14 // set g register
 	CALL	runtime·stackcheck(SB)
 
 nog2:
-- 
GitLab


From 22f9e1ccbc9db9a1d9ecbadca972264e5ad2f169 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 4 Feb 2021 11:41:34 -0500
Subject: [PATCH 0611/2400] [dev.regabi] runtime: initialize special registers
 before sigpanic

In case that we are panicking in ABI0 context or external code,
special registers are not initialized. Initialized them in
injected code before calling sigpanic.

TODO: Windows, Plan 9.

Change-Id: I0919b80e7cc55463f3dd94f1f63cba305717270a
Reviewed-on: https://go-review.googlesource.com/c/go/+/289710
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/asm.s           |  5 +++++
 src/runtime/asm_amd64.s     | 12 ++++++++++++
 src/runtime/signal_amd64.go |  7 +++++--
 src/runtime/stubs.go        |  4 ++++
 4 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/src/runtime/asm.s b/src/runtime/asm.s
index 27d8df9e06..72c744925d 100644
--- a/src/runtime/asm.s
+++ b/src/runtime/asm.s
@@ -11,3 +11,8 @@
 DATA runtime·no_pointers_stackmap+0x00(SB)/4, $2
 DATA runtime·no_pointers_stackmap+0x04(SB)/4, $0
 GLOBL runtime·no_pointers_stackmap(SB),RODATA, $8
+
+#ifndef GOARCH_amd64
+TEXT ·sigpanic0<ABIInternal>(SB),NOSPLIT,$0-0
+	JMP	·sigpanic<ABIInternal>(SB)
+#endif
diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index 9f15990b13..83c08a52f7 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -1364,6 +1364,18 @@ TEXT runtime·addmoduledata(SB),NOSPLIT,$0-0
 	POPQ	R15
 	RET
 
+// Initialize special registers then jump to sigpanic.
+// This function is injected from the signal handler for panicking
+// signals. It is quite painful to set X15 in the signal context,
+// so we do it here.
+TEXT ·sigpanic0<ABIInternal>(SB),NOSPLIT,$0-0
+#ifdef GOEXPERIMENT_REGABI
+	get_tls(R14)
+	MOVQ	g(R14), R14
+	XORPS	X15, X15
+#endif
+	JMP	·sigpanic<ABIInternal>(SB)
+
 // gcWriteBarrier performs a heap pointer write and informs the GC.
 //
 // gcWriteBarrier does NOT follow the Go ABI. It takes two arguments:
diff --git a/src/runtime/signal_amd64.go b/src/runtime/signal_amd64.go
index 6ab1f758c2..3eeb5e044f 100644
--- a/src/runtime/signal_amd64.go
+++ b/src/runtime/signal_amd64.go
@@ -65,11 +65,14 @@ func (c *sigctxt) preparePanic(sig uint32, gp *g) {
 	pc := uintptr(c.rip())
 	sp := uintptr(c.rsp())
 
+	// In case we are panicking from external code, we need to initialize
+	// Go special registers. We inject sigpanic0 (instead of sigpanic),
+	// which takes care of that.
 	if shouldPushSigpanic(gp, pc, *(*uintptr)(unsafe.Pointer(sp))) {
-		c.pushCall(funcPC(sigpanic), pc)
+		c.pushCall(funcPC(sigpanic0), pc)
 	} else {
 		// Not safe to push the call. Just clobber the frame.
-		c.set_rip(uint64(funcPC(sigpanic)))
+		c.set_rip(uint64(funcPC(sigpanic0)))
 	}
 }
 
diff --git a/src/runtime/stubs.go b/src/runtime/stubs.go
index 36bbc8991a..3d1e0c0bb4 100644
--- a/src/runtime/stubs.go
+++ b/src/runtime/stubs.go
@@ -356,3 +356,7 @@ func duffcopy()
 
 // Called from linker-generated .initarray; declared for go vet; do NOT call from Go.
 func addmoduledata()
+
+// Injected by the signal handler for panicking signals. On many platforms it just
+// jumps to sigpanic.
+func sigpanic0()
-- 
GitLab


From 2e60c00f56cdab9bb02e649e089b2ee5761acf26 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 4 Feb 2021 11:43:24 -0500
Subject: [PATCH 0612/2400] [dev.regabi] cmd/internal/obj/x86: use g register
 in stack bounds check

In ABIInternal context, we can directly use the g register for
stack bounds check.

Change-Id: I8b1073a3343984a6cd76cf5734ddc4a8cd5dc73f
Reviewed-on: https://go-review.googlesource.com/c/go/+/289711
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/internal/obj/x86/obj6.go | 29 +++++++++++++++++++----------
 1 file changed, 19 insertions(+), 10 deletions(-)

diff --git a/src/cmd/internal/obj/x86/obj6.go b/src/cmd/internal/obj/x86/obj6.go
index 1674db626f..84de58a4c4 100644
--- a/src/cmd/internal/obj/x86/obj6.go
+++ b/src/cmd/internal/obj/x86/obj6.go
@@ -637,13 +637,19 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 		}
 	}
 
+	var regg int16
 	if !p.From.Sym.NoSplit() || (p.From.Sym.Wrapper() && !p.From.Sym.ABIWrapper()) {
-		p = obj.Appendp(p, newprog)
-		p = load_g_cx(ctxt, p, newprog) // load g into CX
+		if ctxt.Arch.Family == sys.AMD64 && objabi.Regabi_enabled != 0 && cursym.ABI() == obj.ABIInternal {
+			regg = REGG // use the g register directly in ABIInternal
+		} else {
+			p = obj.Appendp(p, newprog)
+			p = load_g_cx(ctxt, p, newprog) // load g into CX
+			regg = REG_CX
+		}
 	}
 
 	if !cursym.Func().Text.From.Sym.NoSplit() {
-		p = stacksplit(ctxt, cursym, p, newprog, autoffset, int32(textarg)) // emit split check
+		p = stacksplit(ctxt, cursym, p, newprog, autoffset, int32(textarg), regg) // emit split check
 	}
 
 	// Delve debugger would like the next instruction to be noted as the end of the function prologue.
@@ -695,7 +701,7 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 		//   g._panic.argp = bottom-of-frame
 		// }
 		//
-		//	MOVQ g_panic(CX), BX
+		//	MOVQ g_panic(g), BX
 		//	TESTQ BX, BX
 		//	JNE checkargp
 		// end:
@@ -718,7 +724,7 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 		p = obj.Appendp(p, newprog)
 		p.As = AMOVQ
 		p.From.Type = obj.TYPE_MEM
-		p.From.Reg = REG_CX
+		p.From.Reg = regg
 		p.From.Offset = 4 * int64(ctxt.Arch.PtrSize) // g_panic
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = REG_BX
@@ -969,9 +975,9 @@ func load_g_cx(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) *obj.Prog {
 
 // Append code to p to check for stack split.
 // Appends to (does not overwrite) p.
-// Assumes g is in CX.
+// Assumes g is in rg.
 // Returns last new instruction.
-func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgAlloc, framesize int32, textarg int32) *obj.Prog {
+func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgAlloc, framesize int32, textarg int32, rg int16) *obj.Prog {
 	cmp := ACMPQ
 	lea := ALEAQ
 	mov := AMOVQ
@@ -993,7 +999,8 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
 		p.As = cmp
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = REG_SP
-		indir_cx(ctxt, &p.To)
+		p.To.Type = obj.TYPE_MEM
+		p.To.Reg = rg
 		p.To.Offset = 2 * int64(ctxt.Arch.PtrSize) // G.stackguard0
 		if cursym.CFunc() {
 			p.To.Offset = 3 * int64(ctxt.Arch.PtrSize) // G.stackguard1
@@ -1021,7 +1028,8 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
 		p.As = cmp
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = REG_AX
-		indir_cx(ctxt, &p.To)
+		p.To.Type = obj.TYPE_MEM
+		p.To.Reg = rg
 		p.To.Offset = 2 * int64(ctxt.Arch.PtrSize) // G.stackguard0
 		if cursym.CFunc() {
 			p.To.Offset = 3 * int64(ctxt.Arch.PtrSize) // G.stackguard1
@@ -1047,7 +1055,8 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
 		p = obj.Appendp(p, newprog)
 
 		p.As = mov
-		indir_cx(ctxt, &p.From)
+		p.From.Type = obj.TYPE_MEM
+		p.From.Reg = rg
 		p.From.Offset = 2 * int64(ctxt.Arch.PtrSize) // G.stackguard0
 		if cursym.CFunc() {
 			p.From.Offset = 3 * int64(ctxt.Arch.PtrSize) // G.stackguard1
-- 
GitLab


From 7b0dfb177f3ae81641af898bb5479256fb21fd5d Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 4 Feb 2021 12:40:04 -0500
Subject: [PATCH 0613/2400] [dev.regabi] runtime: use g register in some
 assembly functions on AMD64

Now that we have a g register, just use it.

Note: functions that can be called from ABI0 context (e.g.
morestack) is unchanged. Functions that switch g is also
unchanged, because we need to set the new g in both the register
and TLS.

TODO: other OSes.

Change-Id: I692a82a7caa8417ff620a59676a6275f56747b94
Reviewed-on: https://go-review.googlesource.com/c/go/+/289718
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/asm_amd64.s       | 22 ++++++++++++++--------
 src/runtime/race_amd64.s      | 12 ++++++++++++
 src/runtime/sys_linux_amd64.s | 16 ++++++++++++++++
 3 files changed, 42 insertions(+), 8 deletions(-)

diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index 83c08a52f7..93280eee4a 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -585,18 +585,20 @@ TEXT runtime·jmpdefer(SB), NOSPLIT, $0-16
 	MOVQ	0(DX), BX
 	JMP	BX	// but first run the deferred function
 
-// Save state of caller into g->sched. Smashes R8, R9.
+// Save state of caller into g->sched. Smashes R9.
 TEXT gosave<>(SB),NOSPLIT,$0
-	get_tls(R8)
-	MOVQ	g(R8), R8
+#ifndef GOEXPERIMENT_REGABI
+	get_tls(R14)
+	MOVQ	g(R14), R14
+#endif
 	MOVQ	0(SP), R9
-	MOVQ	R9, (g_sched+gobuf_pc)(R8)
+	MOVQ	R9, (g_sched+gobuf_pc)(R14)
 	LEAQ	8(SP), R9
-	MOVQ	R9, (g_sched+gobuf_sp)(R8)
-	MOVQ	$0, (g_sched+gobuf_ret)(R8)
-	MOVQ	BP, (g_sched+gobuf_bp)(R8)
+	MOVQ	R9, (g_sched+gobuf_sp)(R14)
+	MOVQ	$0, (g_sched+gobuf_ret)(R14)
+	MOVQ	BP, (g_sched+gobuf_bp)(R14)
 	// Assert ctxt is zero. See func save.
-	MOVQ	(g_sched+gobuf_ctxt)(R8), R9
+	MOVQ	(g_sched+gobuf_ctxt)(R14), R9
 	TESTQ	R9, R9
 	JZ	2(PC)
 	CALL	runtime·badctxt(SB)
@@ -1391,9 +1393,13 @@ TEXT runtime·gcWriteBarrier<ABIInternal>(SB),NOSPLIT,$112
 	MOVQ	R13, 104(SP)
 	// TODO: Consider passing g.m.p in as an argument so they can be shared
 	// across a sequence of write barriers.
+#ifdef GOEXPERIMENT_REGABI
+	MOVQ	g_m(R14), R13
+#else
 	get_tls(R13)
 	MOVQ	g(R13), R13
 	MOVQ	g_m(R13), R13
+#endif
 	MOVQ	m_p(R13), R13
 	MOVQ	(p_wbBuf+wbBuf_next)(R13), R12
 	// Increment wbBuf.next position.
diff --git a/src/runtime/race_amd64.s b/src/runtime/race_amd64.s
index 7f97025c1a..c3b7bbfbfe 100644
--- a/src/runtime/race_amd64.s
+++ b/src/runtime/race_amd64.s
@@ -146,8 +146,10 @@ TEXT	runtime·racewriterangepc1(SB), NOSPLIT, $0-24
 // If addr (RARG1) is out of range, do nothing.
 // Otherwise, setup goroutine context and invoke racecall. Other arguments already set.
 TEXT	racecalladdr<>(SB), NOSPLIT, $0-0
+#ifndef GOEXPERIMENT_REGABI
 	get_tls(R12)
 	MOVQ	g(R12), R14
+#endif
 	MOVQ	g_racectx(R14), RARG0	// goroutine context
 	// Check that addr is within [arenastart, arenaend) or within [racedatastart, racedataend).
 	CMPQ	RARG1, runtime·racearenastart(SB)
@@ -183,8 +185,10 @@ TEXT	runtime·racefuncenter(SB), NOSPLIT, $0-8
 // R11 = caller's return address
 TEXT	racefuncenter<>(SB), NOSPLIT, $0-0
 	MOVQ	DX, R15		// save function entry context (for closures)
+#ifndef GOEXPERIMENT_REGABI
 	get_tls(R12)
 	MOVQ	g(R12), R14
+#endif
 	MOVQ	g_racectx(R14), RARG0	// goroutine context
 	MOVQ	R11, RARG1
 	// void __tsan_func_enter(ThreadState *thr, void *pc);
@@ -197,8 +201,10 @@ TEXT	racefuncenter<>(SB), NOSPLIT, $0-0
 // func runtime·racefuncexit()
 // Called from instrumented code.
 TEXT	runtime·racefuncexit(SB), NOSPLIT, $0-0
+#ifndef GOEXPERIMENT_REGABI
 	get_tls(R12)
 	MOVQ	g(R12), R14
+#endif
 	MOVQ	g_racectx(R14), RARG0	// goroutine context
 	// void __tsan_func_exit(ThreadState *thr);
 	MOVQ	$__tsan_func_exit(SB), AX
@@ -357,8 +363,10 @@ racecallatomic_data:
 	JAE	racecallatomic_ignore
 racecallatomic_ok:
 	// Addr is within the good range, call the atomic function.
+#ifndef GOEXPERIMENT_REGABI
 	get_tls(R12)
 	MOVQ	g(R12), R14
+#endif
 	MOVQ	g_racectx(R14), RARG0	// goroutine context
 	MOVQ	8(SP), RARG1	// caller pc
 	MOVQ	(SP), RARG2	// pc
@@ -370,8 +378,10 @@ racecallatomic_ignore:
 	// An attempt to synchronize on the address would cause crash.
 	MOVQ	AX, R15	// remember the original function
 	MOVQ	$__tsan_go_ignore_sync_begin(SB), AX
+#ifndef GOEXPERIMENT_REGABI
 	get_tls(R12)
 	MOVQ	g(R12), R14
+#endif
 	MOVQ	g_racectx(R14), RARG0	// goroutine context
 	CALL	racecall<>(SB)
 	MOVQ	R15, AX	// restore the original function
@@ -399,8 +409,10 @@ TEXT	runtime·racecall(SB), NOSPLIT, $0-0
 
 // Switches SP to g0 stack and calls (AX). Arguments already set.
 TEXT	racecall<>(SB), NOSPLIT, $0-0
+#ifndef GOEXPERIMENT_REGABI
 	get_tls(R12)
 	MOVQ	g(R12), R14
+#endif
 	MOVQ	g_m(R14), R13
 	// Switch to g0 stack.
 	MOVQ	SP, R12		// callee-saved, preserved across the CALL
diff --git a/src/runtime/sys_linux_amd64.s b/src/runtime/sys_linux_amd64.s
index b0a201fc6f..d48573c2c5 100644
--- a/src/runtime/sys_linux_amd64.s
+++ b/src/runtime/sys_linux_amd64.s
@@ -215,9 +215,13 @@ TEXT runtime·walltime1(SB),NOSPLIT,$16-12
 
 	MOVQ	SP, R12	// Save old SP; R12 unchanged by C code.
 
+#ifdef GOEXPERIMENT_REGABI
+	MOVQ	g_m(R14), BX // BX unchanged by C code.
+#else
 	get_tls(CX)
 	MOVQ	g(CX), AX
 	MOVQ	g_m(AX), BX // BX unchanged by C code.
+#endif
 
 	// Set vdsoPC and vdsoSP for SIGPROF traceback.
 	// Save the old values on stack and restore them on exit,
@@ -232,7 +236,11 @@ TEXT runtime·walltime1(SB),NOSPLIT,$16-12
 	MOVQ	CX, m_vdsoPC(BX)
 	MOVQ	DX, m_vdsoSP(BX)
 
+#ifdef GOEXPERIMENT_REGABI
+	CMPQ	R14, m_curg(BX)	// Only switch if on curg.
+#else
 	CMPQ	AX, m_curg(BX)	// Only switch if on curg.
+#endif
 	JNE	noswitch
 
 	MOVQ	m_g0(BX), DX
@@ -275,9 +283,13 @@ TEXT runtime·nanotime1(SB),NOSPLIT,$16-8
 
 	MOVQ	SP, R12	// Save old SP; R12 unchanged by C code.
 
+#ifdef GOEXPERIMENT_REGABI
+	MOVQ	g_m(R14), BX // BX unchanged by C code.
+#else
 	get_tls(CX)
 	MOVQ	g(CX), AX
 	MOVQ	g_m(AX), BX // BX unchanged by C code.
+#endif
 
 	// Set vdsoPC and vdsoSP for SIGPROF traceback.
 	// Save the old values on stack and restore them on exit,
@@ -292,7 +304,11 @@ TEXT runtime·nanotime1(SB),NOSPLIT,$16-8
 	MOVQ	CX, m_vdsoPC(BX)
 	MOVQ	DX, m_vdsoSP(BX)
 
+#ifdef GOEXPERIMENT_REGABI
+	CMPQ	R14, m_curg(BX)	// Only switch if on curg.
+#else
 	CMPQ	AX, m_curg(BX)	// Only switch if on curg.
+#endif
 	JNE	noswitch
 
 	MOVQ	m_g0(BX), DX
-- 
GitLab


From 0fbde54ea646aa1363fc172610a75e5ba877d4ec Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Mon, 8 Feb 2021 10:23:05 -0800
Subject: [PATCH 0614/2400] [dev.typeparams] cmd/compile: allow generic funcs
 to call other generic funcs for stenciling

 - Handle generic function calling itself or another generic function in
   stenciling. This is easy - after it is created, just scan an
   instantiated generic function for function instantiations (that may
   needed to be stenciled), just like non-generic functions. The types
   in the function instantiation will already have been set by the
   stenciling.

 - Handle OTYPE nodes in subster.node() (allows for generic type
   conversions).

 - Eliminated some duplicated work in subster.typ().

 - Added new test case fact.go that tests a generic function calling
   itself, and simple generic type conversions.

 - Cause an error if a generic function is to be exported (which we
   don't handle yet).

 - Fixed some suggested changes in the add.go test case that I missed in
   the last review.

Change-Id: I5d61704254c27962f358d5a3d2e0c62a5099f148
Reviewed-on: https://go-review.googlesource.com/c/go/+/290469
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/object.go  |  3 ++
 src/cmd/compile/internal/noder/stencil.go | 15 +++++++---
 test/typeparam/fact.go                    | 35 +++++++++++++++++++++++
 test/typeparam/{add.go => sum.go}         | 20 ++++++-------
 4 files changed, 59 insertions(+), 14 deletions(-)
 create mode 100644 test/typeparam/fact.go
 rename test/typeparam/{add.go => sum.go} (61%)

diff --git a/src/cmd/compile/internal/noder/object.go b/src/cmd/compile/internal/noder/object.go
index c740285ca2..b4e5c022db 100644
--- a/src/cmd/compile/internal/noder/object.go
+++ b/src/cmd/compile/internal/noder/object.go
@@ -155,6 +155,9 @@ func (g *irgen) objFinish(name *ir.Name, class ir.Class, typ *types.Type) {
 			break // methods are exported with their receiver type
 		}
 		if types.IsExported(sym.Name) {
+			if name.Class == ir.PFUNC && name.Type().NumTParams() > 0 {
+				base.FatalfAt(name.Pos(), "Cannot export a generic function (yet): %v", name)
+			}
 			typecheck.Export(name)
 		}
 		if base.Flag.AsmHdr != "" && !name.Sym().Asm() {
diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 3c6c7f4a8c..0c4eadcf44 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -20,7 +20,11 @@ import (
 // creates the required stencils for simple generic functions.
 func (g *irgen) stencil() {
 	g.target.Stencils = make(map[*types.Sym]*ir.Func)
-	for _, decl := range g.target.Decls {
+	// Don't use range(g.target.Decls) - we also want to process any new instantiated
+	// functions that are created during this loop, in order to handle generic
+	// functions calling other generic functions.
+	for i := 0; i < len(g.target.Decls); i++ {
+		decl := g.target.Decls[i]
 		if decl.Op() != ir.ODCLFUNC || decl.Type().NumTParams() > 0 {
 			// Skip any non-function declarations and skip generic functions
 			continue
@@ -142,6 +146,9 @@ func (subst *subster) node(n ir.Node) ir.Node {
 	var edit func(ir.Node) ir.Node
 	edit = func(x ir.Node) ir.Node {
 		switch x.Op() {
+		case ir.OTYPE:
+			return ir.TypeNode(subst.typ(x.Type()))
+
 		case ir.ONAME:
 			name := x.(*ir.Name)
 			if v := subst.vars[name]; v != nil {
@@ -211,21 +218,21 @@ func (subst *subster) typ(t *types.Type) *types.Type {
 	case types.TARRAY:
 		elem := t.Elem()
 		newelem := subst.typ(elem)
-		if subst.typ(elem) != elem {
+		if newelem != elem {
 			return types.NewArray(newelem, t.NumElem())
 		}
 
 	case types.TPTR:
 		elem := t.Elem()
 		newelem := subst.typ(elem)
-		if subst.typ(elem) != elem {
+		if newelem != elem {
 			return types.NewPtr(newelem)
 		}
 
 	case types.TSLICE:
 		elem := t.Elem()
 		newelem := subst.typ(elem)
-		if subst.typ(elem) != elem {
+		if newelem != elem {
 			return types.NewSlice(newelem)
 		}
 
diff --git a/test/typeparam/fact.go b/test/typeparam/fact.go
new file mode 100644
index 0000000000..e5e0ad4ff3
--- /dev/null
+++ b/test/typeparam/fact.go
@@ -0,0 +1,35 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 (
+	"fmt"
+)
+
+
+func fact[T interface { type float64 }](n T) T {
+	if n == T(1) {
+		return T(1)
+	}
+	return n * fact(n - T(1))
+}
+
+func main() {
+	got := fact(4.0)
+	want := 24.0
+	if got != want {
+		panic(fmt.Sprintf("Got %f, want %f", got, want))
+	}
+
+	// Re-enable when types2 bug is fixed (can't do T(1) with more than one
+	// type in the type list).
+	//got = fact(5)
+	//want = 120
+	//if want != got {
+	//	panic(fmt.Sprintf("Want %d, got %d", want, got))
+	//}
+}
diff --git a/test/typeparam/add.go b/test/typeparam/sum.go
similarity index 61%
rename from test/typeparam/add.go
rename to test/typeparam/sum.go
index b0cf76d3ee..72511c2fe5 100644
--- a/test/typeparam/add.go
+++ b/test/typeparam/sum.go
@@ -10,7 +10,7 @@ import (
 	"fmt"
 )
 
-func add[T interface{ type int, float64 }](vec []T) T {
+func sum[T interface{ type int, float64 }](vec []T) T {
 	var sum T
 	for _, elt := range vec {
 		sum = sum + elt
@@ -28,23 +28,23 @@ func abs(f float64) float64 {
 func main() {
 	vec1 := []int{3, 4}
 	vec2 := []float64{5.8, 9.6}
+	got := sum[int](vec1)
 	want := vec1[0] + vec1[1]
-	got := add[int](vec1)
-	if want != got {
-		panic(fmt.Sprintf("Want %d, got %d", want, got))
+	if got != want {
+		panic(fmt.Sprintf("Got %d, want %d", got, want))
 	}
-	got = add(vec1)
+	got = sum(vec1)
 	if want != got {
-		panic(fmt.Sprintf("Want %d, got %d", want, got))
+		panic(fmt.Sprintf("Got %d, want %d", got, want))
 	}
 
 	fwant := vec2[0] + vec2[1]
-	fgot := add[float64](vec2)
+	fgot := sum[float64](vec2)
 	if abs(fgot - fwant) > 1e-10 {
-		panic(fmt.Sprintf("Want %f, got %f", fwant, fgot))
+		panic(fmt.Sprintf("Got %f, want %f", fgot, fwant))
 	}
-	fgot = add(vec2)
+	fgot = sum(vec2)
 	if abs(fgot - fwant) > 1e-10 {
-		panic(fmt.Sprintf("Want %f, got %f", fwant, fgot))
+		panic(fmt.Sprintf("Got %f, want %f", fgot, fwant))
 	}
 }
-- 
GitLab


From a360eeb52831c0dfeb38b49eec6881c06176f181 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 4 Feb 2021 17:40:18 -0800
Subject: [PATCH 0615/2400] [dev.typeparams] cmd/compile/internal/types2:
 conversions to type parameters are not constant

Disabled test/typeparam/fact.go for now as there's an issue
with stenciling.

Change-Id: Ie328a217de6d7b6695737f08ef5c944bcdaabd39
Reviewed-on: https://go-review.googlesource.com/c/go/+/290471
Trust: Robert Griesemer <gri@golang.org>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 .../internal/types2/examples/types.go2        | 18 ++++++++-
 src/cmd/compile/internal/types2/predicates.go |  9 ++++-
 test/typeparam/fact.go                        | 40 ++++++++++---------
 3 files changed, 45 insertions(+), 22 deletions(-)

diff --git a/src/cmd/compile/internal/types2/examples/types.go2 b/src/cmd/compile/internal/types2/examples/types.go2
index f094880c49..a081f61c01 100644
--- a/src/cmd/compile/internal/types2/examples/types.go2
+++ b/src/cmd/compile/internal/types2/examples/types.go2
@@ -261,4 +261,20 @@ func _(_ comparable /* ERROR comparable */ , _ C /* ERROR comparable */ )
 func _() {
 	var _ comparable /* ERROR comparable */
 	var _ C /* ERROR comparable */
-}
\ No newline at end of file
+}
+
+// Type parameters are never const types, i.e., it's
+// not possible to declare a constant of type parameter type.
+// (If a type list contains just a single const type, we could
+// allow it, but such type lists don't make much sense in the
+// first place.)
+func _[T interface { type int, float64 }]() {
+	// not valid
+	const _ = T /* ERROR not constant */ (0)
+	const _ T /* ERROR invalid constant type T */ = 1
+
+	// valid
+	var _ = T(0)
+	var _ T = 1
+	_ = T(0)
+}
diff --git a/src/cmd/compile/internal/types2/predicates.go b/src/cmd/compile/internal/types2/predicates.go
index 94a9b64761..b8fa15cdb8 100644
--- a/src/cmd/compile/internal/types2/predicates.go
+++ b/src/cmd/compile/internal/types2/predicates.go
@@ -69,8 +69,13 @@ func isUntyped(typ Type) bool {
 	return !isTyped(typ)
 }
 
-func isOrdered(typ Type) bool   { return is(typ, IsOrdered) }
-func isConstType(typ Type) bool { return is(typ, IsConstType) }
+func isOrdered(typ Type) bool { return is(typ, IsOrdered) }
+
+func isConstType(typ Type) bool {
+	// Type parameters are never const types.
+	t, _ := typ.Under().(*Basic)
+	return t != nil && t.info&IsConstType != 0
+}
 
 // IsInterface reports whether typ is an interface type.
 func IsInterface(typ Type) bool {
diff --git a/test/typeparam/fact.go b/test/typeparam/fact.go
index e5e0ad4ff3..8ed9bce7d8 100644
--- a/test/typeparam/fact.go
+++ b/test/typeparam/fact.go
@@ -6,30 +6,32 @@
 
 package main
 
-import (
-	"fmt"
-)
+import "fmt"
 
+// TODO Stenciling doesn't do the right thing for T(1) at the moment.
 
-func fact[T interface { type float64 }](n T) T {
-	if n == T(1) {
-		return T(1)
-	}
-	return n * fact(n - T(1))
+func fact[T interface { type int, int64, float64 }](n T) T {
+	// TODO remove this return in favor of the correct computation below
+	return n
+	// if n == T(1) {
+	// 	return T(1)
+	// }
+	// return n * fact(n - T(1))
 }
 
 func main() {
-	got := fact(4.0)
-	want := 24.0
-	if got != want {
-		panic(fmt.Sprintf("Got %f, want %f", got, want))
+	// TODO change this to 120 once we can compile the function body above
+	const want = 5 // 120
+
+	if got := fact(5); got != want {
+		panic(fmt.Sprintf("got %d, want %d", got, want))
 	}
 
-	// Re-enable when types2 bug is fixed (can't do T(1) with more than one
-	// type in the type list).
-	//got = fact(5)
-	//want = 120
-	//if want != got {
-	//	panic(fmt.Sprintf("Want %d, got %d", want, got))
-	//}
+	if got := fact[int64](5); got != want {
+		panic(fmt.Sprintf("got %d, want %d", got, want))
+	}
+
+	if got := fact(5.0); got != want {
+		panic(fmt.Sprintf("got %f, want %f", got, want))
+	}
 }
-- 
GitLab


From 618e3c15bdb5c031ac037e7ad5c1b3791a913226 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 4 Feb 2021 11:44:21 -0500
Subject: [PATCH 0616/2400] [dev.regabi] go/types: consistently report nil type
 as "untyped nil"

This is a port of CL 284052 to go/types. The port is not entirely
faithful, as untyped conversion has been refactored in go/types.
Additionally, a comment was added to reference issue #13061 in the
implicitType method.

For #13061

Change-Id: Iec17611f6432c988624023d1d74121ff34eb0c83
Reviewed-on: https://go-review.googlesource.com/c/go/+/289715
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/api_test.go    | 64 +++++++++++++++++++++++++++++++------
 src/go/types/conversions.go |  4 +--
 src/go/types/expr.go        |  2 ++
 3 files changed, 59 insertions(+), 11 deletions(-)

diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go
index 75cebc9826..dde451ee3c 100644
--- a/src/go/types/api_test.go
+++ b/src/go/types/api_test.go
@@ -42,7 +42,7 @@ func mustTypecheck(t *testing.T, path, source string, info *Info) string {
 	return pkg.Name()
 }
 
-func mayTypecheck(t *testing.T, path, source string, info *Info) string {
+func mayTypecheck(t *testing.T, path, source string, info *Info) (string, error) {
 	fset := token.NewFileSet()
 	f, err := parser.ParseFile(fset, path, source, 0)
 	if f == nil { // ignore errors unless f is nil
@@ -52,8 +52,8 @@ func mayTypecheck(t *testing.T, path, source string, info *Info) string {
 		Error:    func(err error) {},
 		Importer: importer.Default(),
 	}
-	pkg, _ := conf.Check(f.Name.Name, fset, []*ast.File{f}, info)
-	return pkg.Name()
+	pkg, err := conf.Check(f.Name.Name, fset, []*ast.File{f}, info)
+	return pkg.Name(), err
 }
 
 func TestValuesInfo(t *testing.T) {
@@ -175,6 +175,9 @@ func TestValuesInfo(t *testing.T) {
 }
 
 func TestTypesInfo(t *testing.T) {
+	// Test sources that are not expected to typecheck must start with the broken prefix.
+	const broken = "package broken_"
+
 	var tests = []struct {
 		src  string
 		expr string // expression
@@ -187,6 +190,39 @@ func TestTypesInfo(t *testing.T) {
 		{`package b3; var x interface{} = 0i`, `0i`, `complex128`},
 		{`package b4; var x interface{} = "foo"`, `"foo"`, `string`},
 
+		// uses of nil
+		{`package n0; var _ *int = nil`, `nil`, `untyped nil`},
+		{`package n1; var _ func() = nil`, `nil`, `untyped nil`},
+		{`package n2; var _ []byte = nil`, `nil`, `untyped nil`},
+		{`package n3; var _ map[int]int = nil`, `nil`, `untyped nil`},
+		{`package n4; var _ chan int = nil`, `nil`, `untyped nil`},
+		{`package n5; var _ interface{} = nil`, `nil`, `untyped nil`},
+		{`package n6; import "unsafe"; var _ unsafe.Pointer = nil`, `nil`, `untyped nil`},
+
+		{`package n10; var (x *int; _ = x == nil)`, `nil`, `untyped nil`},
+		{`package n11; var (x func(); _ = x == nil)`, `nil`, `untyped nil`},
+		{`package n12; var (x []byte; _ = x == nil)`, `nil`, `untyped nil`},
+		{`package n13; var (x map[int]int; _ = x == nil)`, `nil`, `untyped nil`},
+		{`package n14; var (x chan int; _ = x == nil)`, `nil`, `untyped nil`},
+		{`package n15; var (x interface{}; _ = x == nil)`, `nil`, `untyped nil`},
+		{`package n15; import "unsafe"; var (x unsafe.Pointer; _ = x == nil)`, `nil`, `untyped nil`},
+
+		{`package n20; var _ = (*int)(nil)`, `nil`, `untyped nil`},
+		{`package n21; var _ = (func())(nil)`, `nil`, `untyped nil`},
+		{`package n22; var _ = ([]byte)(nil)`, `nil`, `untyped nil`},
+		{`package n23; var _ = (map[int]int)(nil)`, `nil`, `untyped nil`},
+		{`package n24; var _ = (chan int)(nil)`, `nil`, `untyped nil`},
+		{`package n25; var _ = (interface{})(nil)`, `nil`, `untyped nil`},
+		{`package n26; import "unsafe"; var _ = unsafe.Pointer(nil)`, `nil`, `untyped nil`},
+
+		{`package n30; func f(*int) { f(nil) }`, `nil`, `untyped nil`},
+		{`package n31; func f(func()) { f(nil) }`, `nil`, `untyped nil`},
+		{`package n32; func f([]byte) { f(nil) }`, `nil`, `untyped nil`},
+		{`package n33; func f(map[int]int) { f(nil) }`, `nil`, `untyped nil`},
+		{`package n34; func f(chan int) { f(nil) }`, `nil`, `untyped nil`},
+		{`package n35; func f(interface{}) { f(nil) }`, `nil`, `untyped nil`},
+		{`package n35; import "unsafe"; func f(unsafe.Pointer) { f(nil) }`, `nil`, `untyped nil`},
+
 		// comma-ok expressions
 		{`package p0; var x interface{}; var _, _ = x.(int)`,
 			`x.(int)`,
@@ -268,17 +304,27 @@ func TestTypesInfo(t *testing.T) {
 		},
 
 		// tests for broken code that doesn't parse or type-check
-		{`package x0; func _() { var x struct {f string}; x.f := 0 }`, `x.f`, `string`},
-		{`package x1; func _() { var z string; type x struct {f string}; y := &x{q: z}}`, `z`, `string`},
-		{`package x2; func _() { var a, b string; type x struct {f string}; z := &x{f: a; f: b;}}`, `b`, `string`},
-		{`package x3; var x = panic("");`, `panic`, `func(interface{})`},
+		{broken + `x0; func _() { var x struct {f string}; x.f := 0 }`, `x.f`, `string`},
+		{broken + `x1; func _() { var z string; type x struct {f string}; y := &x{q: z}}`, `z`, `string`},
+		{broken + `x2; func _() { var a, b string; type x struct {f string}; z := &x{f: a; f: b;}}`, `b`, `string`},
+		{broken + `x3; var x = panic("");`, `panic`, `func(interface{})`},
 		{`package x4; func _() { panic("") }`, `panic`, `func(interface{})`},
-		{`package x5; func _() { var x map[string][...]int; x = map[string][...]int{"": {1,2,3}} }`, `x`, `map[string][-1]int`},
+		{broken + `x5; func _() { var x map[string][...]int; x = map[string][...]int{"": {1,2,3}} }`, `x`, `map[string][-1]int`},
 	}
 
 	for _, test := range tests {
 		info := Info{Types: make(map[ast.Expr]TypeAndValue)}
-		name := mayTypecheck(t, "TypesInfo", test.src, &info)
+		var name string
+		if strings.HasPrefix(test.src, broken) {
+			var err error
+			name, err = mayTypecheck(t, "TypesInfo", test.src, &info)
+			if err == nil {
+				t.Errorf("package %s: expected to fail but passed", name)
+				continue
+			}
+		} else {
+			name = mustTypecheck(t, "TypesInfo", test.src, &info)
+		}
 
 		// look for expression type
 		var typ Type
diff --git a/src/go/types/conversions.go b/src/go/types/conversions.go
index 1cab1cc70f..c634d27aa9 100644
--- a/src/go/types/conversions.go
+++ b/src/go/types/conversions.go
@@ -55,8 +55,8 @@ func (check *Checker) conversion(x *operand, T Type) {
 		// - Keep untyped nil for untyped nil arguments.
 		// - For integer to string conversions, keep the argument type.
 		//   (See also the TODO below.)
-		if IsInterface(T) || constArg && !isConstType(T) {
-			final = Default(x.typ)
+		if IsInterface(T) || constArg && !isConstType(T) || x.isNil() {
+			final = Default(x.typ) // default type of untyped nil is untyped nil
 		} else if isInteger(x.typ) && isString(T) {
 			final = x.typ
 		}
diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index eb2056125a..f7fb0caedd 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -579,6 +579,8 @@ func (check *Checker) implicitType(x *operand, target Type) Type {
 			if !hasNil(target) {
 				return nil
 			}
+			// Preserve the type of nil as UntypedNil: see #13061.
+			return Typ[UntypedNil]
 		default:
 			return nil
 		}
-- 
GitLab


From 11d15c171bd25337c1dde25a0f7ce4892cb894bb Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 4 Feb 2021 12:03:53 -0500
Subject: [PATCH 0617/2400] [dev.regabi] go/types: convert untyped arguments to
 delete

This is a port of CL 285059 to go/types. The error assertion is updated
to match go/types error for assignment, which has been improved.

Change-Id: Icdd2751edea0abef7c84feadcbf9265d71239ade
Reviewed-on: https://go-review.googlesource.com/c/go/+/289716
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Robert Findley <rfindley@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/builtins.go           | 4 ++--
 src/go/types/testdata/builtins.src | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go
index fd35f78676..078ed4488d 100644
--- a/src/go/types/builtins.go
+++ b/src/go/types/builtins.go
@@ -353,8 +353,8 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 			return
 		}
 
-		if ok, code := x.assignableTo(check, m.key, nil); !ok {
-			check.invalidArg(x, code, "%s is not assignable to %s", x, m.key)
+		check.assignment(x, m.key, "argument to delete")
+		if x.mode == invalid {
 			return
 		}
 
diff --git a/src/go/types/testdata/builtins.src b/src/go/types/testdata/builtins.src
index 98830eb08c..a7613adc35 100644
--- a/src/go/types/testdata/builtins.src
+++ b/src/go/types/testdata/builtins.src
@@ -283,7 +283,7 @@ func delete1() {
 	delete() // ERROR not enough arguments
 	delete(1) // ERROR not enough arguments
 	delete(1, 2, 3) // ERROR too many arguments
-	delete(m, 0 /* ERROR not assignable */)
+	delete(m, 0 /* ERROR cannot use */)
 	delete(m, s)
 	_ = delete /* ERROR used as value */ (m, s)
 
-- 
GitLab


From 813958f13cee9b2e7587f173e7a5e6cc9ff51850 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 4 Feb 2021 12:10:02 -0500
Subject: [PATCH 0618/2400] [dev.regabi] go/types: factor out sorting of
 methods

This is a port of CL 285993 to go/types.

Change-Id: I7560cf1176fea5de2c54786a086e547c73294a60
Reviewed-on: https://go-review.googlesource.com/c/go/+/289717
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/predicates.go |  6 ++----
 src/go/types/type.go       |  8 +++-----
 src/go/types/typexpr.go    | 21 +++++++++++++++++++--
 3 files changed, 24 insertions(+), 11 deletions(-)

diff --git a/src/go/types/predicates.go b/src/go/types/predicates.go
index 148edbfb76..954a7ca987 100644
--- a/src/go/types/predicates.go
+++ b/src/go/types/predicates.go
@@ -6,8 +6,6 @@
 
 package types
 
-import "sort"
-
 func isNamed(typ Type) bool {
 	if _, ok := typ.(*Basic); ok {
 		return ok
@@ -273,8 +271,8 @@ func (check *Checker) identical0(x, y Type, cmpTags bool, p *ifacePair) bool {
 					p = p.prev
 				}
 				if debug {
-					assert(sort.IsSorted(byUniqueMethodName(a)))
-					assert(sort.IsSorted(byUniqueMethodName(b)))
+					assertSortedMethods(a)
+					assertSortedMethods(b)
 				}
 				for i, f := range a {
 					g := b[i]
diff --git a/src/go/types/type.go b/src/go/types/type.go
index 087cda429d..66e194e967 100644
--- a/src/go/types/type.go
+++ b/src/go/types/type.go
@@ -4,8 +4,6 @@
 
 package types
 
-import "sort"
-
 // A Type represents a type of Go.
 // All types implement the Type interface.
 type Type interface {
@@ -301,8 +299,8 @@ func NewInterfaceType(methods []*Func, embeddeds []Type) *Interface {
 	}
 
 	// sort for API stability
-	sort.Sort(byUniqueMethodName(methods))
-	sort.Stable(byUniqueTypeName(embeddeds))
+	sortMethods(methods)
+	sortTypes(embeddeds)
 
 	typ.methods = methods
 	typ.embeddeds = embeddeds
@@ -396,7 +394,7 @@ func (t *Interface) Complete() *Interface {
 	}
 
 	if methods != nil {
-		sort.Sort(byUniqueMethodName(methods))
+		sortMethods(methods)
 		t.allMethods = methods
 	}
 
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index 2b398010f4..311a970051 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -518,8 +518,8 @@ func (check *Checker) interfaceType(ityp *Interface, iface *ast.InterfaceType, d
 	}
 
 	// sort for API stability
-	sort.Sort(byUniqueMethodName(ityp.methods))
-	sort.Stable(byUniqueTypeName(ityp.embeddeds))
+	sortMethods(ityp.methods)
+	sortTypes(ityp.embeddeds)
 
 	check.later(func() { check.completeInterface(ityp) })
 }
@@ -613,6 +613,10 @@ func (check *Checker) completeInterface(ityp *Interface) {
 	}
 }
 
+func sortTypes(list []Type) {
+	sort.Stable(byUniqueTypeName(list))
+}
+
 // byUniqueTypeName named type lists can be sorted by their unique type names.
 type byUniqueTypeName []Type
 
@@ -627,6 +631,19 @@ func sortName(t Type) string {
 	return ""
 }
 
+func sortMethods(list []*Func) {
+	sort.Sort(byUniqueMethodName(list))
+}
+
+func assertSortedMethods(list []*Func) {
+	if !debug {
+		panic("internal error: assertSortedMethods called outside debug mode")
+	}
+	if !sort.IsSorted(byUniqueMethodName(list)) {
+		panic("internal error: methods not sorted")
+	}
+}
+
 // byUniqueMethodName method lists can be sorted by their unique method names.
 type byUniqueMethodName []*Func
 
-- 
GitLab


From c48d1503ba5d0f74bbc5cae5036bf225c6823a44 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 4 Feb 2021 12:24:10 -0500
Subject: [PATCH 0619/2400] [dev.regabi] go/types: report unused packages in
 source order

This is a port of CL 287072 to go/types.

Change-Id: I08f56995f0323c1f238d1b44703a481d393471d5
Reviewed-on: https://go-review.googlesource.com/c/go/+/289720
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/check.go                         | 36 +++++-----
 src/go/types/resolver.go                      | 67 +++++++++----------
 .../testdata/importdecl0/importdecl0b.src     |  2 +-
 .../testdata/importdecl1/importdecl1b.src     |  2 +-
 src/go/types/typexpr.go                       |  8 +--
 5 files changed, 54 insertions(+), 61 deletions(-)

diff --git a/src/go/types/check.go b/src/go/types/check.go
index 280792e838..03798587e7 100644
--- a/src/go/types/check.go
+++ b/src/go/types/check.go
@@ -69,6 +69,12 @@ type importKey struct {
 	path, dir string
 }
 
+// A dotImportKey describes a dot-imported object in the given scope.
+type dotImportKey struct {
+	scope *Scope
+	obj   Object
+}
+
 // A Checker maintains the state of the type checker.
 // It must be created with NewChecker.
 type Checker struct {
@@ -86,8 +92,9 @@ type Checker struct {
 	// information collected during type-checking of a set of package files
 	// (initialized by Files, valid only for the duration of check.Files;
 	// maps and lists are allocated on demand)
-	files            []*ast.File                             // package files
-	unusedDotImports map[*Scope]map[*Package]*ast.ImportSpec // unused dot-imported packages
+	files        []*ast.File               // package files
+	imports      []*PkgName                // list of imported packages
+	dotImportMap map[dotImportKey]*PkgName // maps dot-imported objects to the package they were dot-imported through
 
 	firstErr error                 // first error encountered
 	methods  map[*TypeName][]*Func // maps package scope type names to associated non-blank (non-interface) methods
@@ -104,22 +111,6 @@ type Checker struct {
 	indent int // indentation for tracing
 }
 
-// addUnusedImport adds the position of a dot-imported package
-// pkg to the map of dot imports for the given file scope.
-func (check *Checker) addUnusedDotImport(scope *Scope, pkg *Package, spec *ast.ImportSpec) {
-	mm := check.unusedDotImports
-	if mm == nil {
-		mm = make(map[*Scope]map[*Package]*ast.ImportSpec)
-		check.unusedDotImports = mm
-	}
-	m := mm[scope]
-	if m == nil {
-		m = make(map[*Package]*ast.ImportSpec)
-		mm[scope] = m
-	}
-	m[pkg] = spec
-}
-
 // addDeclDep adds the dependency edge (check.decl -> to) if check.decl exists
 func (check *Checker) addDeclDep(to Object) {
 	from := check.decl
@@ -202,7 +193,8 @@ func NewChecker(conf *Config, fset *token.FileSet, pkg *Package, info *Info) *Ch
 func (check *Checker) initFiles(files []*ast.File) {
 	// start with a clean slate (check.Files may be called multiple times)
 	check.files = nil
-	check.unusedDotImports = nil
+	check.imports = nil
+	check.dotImportMap = nil
 
 	check.firstErr = nil
 	check.methods = nil
@@ -272,10 +264,16 @@ func (check *Checker) checkFiles(files []*ast.File) (err error) {
 	if !check.conf.DisableUnusedImportCheck {
 		check.unusedImports()
 	}
+	// no longer needed - release memory
+	check.imports = nil
+	check.dotImportMap = nil
 
 	check.recordUntyped()
 
 	check.pkg.complete = true
+
+	// TODO(rFindley) There's more memory we should release at this point.
+
 	return
 }
 
diff --git a/src/go/types/resolver.go b/src/go/types/resolver.go
index b637f8b8ca..cb66871883 100644
--- a/src/go/types/resolver.go
+++ b/src/go/types/resolver.go
@@ -275,21 +275,26 @@ func (check *Checker) collectObjects() {
 					}
 				}
 
-				obj := NewPkgName(d.spec.Pos(), pkg, name, imp)
+				pkgName := NewPkgName(d.spec.Pos(), pkg, name, imp)
 				if d.spec.Name != nil {
 					// in a dot-import, the dot represents the package
-					check.recordDef(d.spec.Name, obj)
+					check.recordDef(d.spec.Name, pkgName)
 				} else {
-					check.recordImplicit(d.spec, obj)
+					check.recordImplicit(d.spec, pkgName)
 				}
 
 				if path == "C" {
 					// match cmd/compile (not prescribed by spec)
-					obj.used = true
+					pkgName.used = true
 				}
 
 				// add import to file scope
+				check.imports = append(check.imports, pkgName)
 				if name == "." {
+					// dot-import
+					if check.dotImportMap == nil {
+						check.dotImportMap = make(map[dotImportKey]*PkgName)
+					}
 					// merge imported scope with file scope
 					for _, obj := range imp.scope.elems {
 						// A package scope may contain non-exported objects,
@@ -303,16 +308,15 @@ func (check *Checker) collectObjects() {
 							if alt := fileScope.Insert(obj); alt != nil {
 								check.errorf(d.spec.Name, _DuplicateDecl, "%s redeclared in this block", obj.Name())
 								check.reportAltDecl(alt)
+							} else {
+								check.dotImportMap[dotImportKey{fileScope, obj}] = pkgName
 							}
 						}
 					}
-					// add position to set of dot-import positions for this file
-					// (this is only needed for "imported but not used" errors)
-					check.addUnusedDotImport(fileScope, imp, d.spec)
 				} else {
 					// declare imported package object in file scope
 					// (no need to provide s.Name since we called check.recordDef earlier)
-					check.declare(fileScope, nil, obj, token.NoPos)
+					check.declare(fileScope, nil, pkgName, token.NoPos)
 				}
 			case constDecl:
 				// declare all constants
@@ -566,39 +570,30 @@ func (check *Checker) unusedImports() {
 	// any of its exported identifiers. To import a package solely for its side-effects
 	// (initialization), use the blank identifier as explicit package name."
 
-	// check use of regular imported packages
-	for _, scope := range check.pkg.scope.children /* file scopes */ {
-		for _, obj := range scope.elems {
-			if obj, ok := obj.(*PkgName); ok {
-				// Unused "blank imports" are automatically ignored
-				// since _ identifiers are not entered into scopes.
-				if !obj.used {
-					path := obj.imported.path
-					base := pkgName(path)
-					if obj.name == base {
-						check.softErrorf(obj, _UnusedImport, "%q imported but not used", path)
-					} else {
-						check.softErrorf(obj, _UnusedImport, "%q imported but not used as %s", path, obj.name)
-					}
-				}
-			}
-		}
-	}
-
-	// check use of dot-imported packages
-	for _, unusedDotImports := range check.unusedDotImports {
-		for pkg, pos := range unusedDotImports {
-			check.softErrorf(pos, _UnusedImport, "%q imported but not used", pkg.path)
+	for _, obj := range check.imports {
+		if !obj.used && obj.name != "_" {
+			check.errorUnusedPkg(obj)
 		}
 	}
 }
 
-// pkgName returns the package name (last element) of an import path.
-func pkgName(path string) string {
-	if i := strings.LastIndex(path, "/"); i >= 0 {
-		path = path[i+1:]
+func (check *Checker) errorUnusedPkg(obj *PkgName) {
+	// If the package was imported with a name other than the final
+	// import path element, show it explicitly in the error message.
+	// Note that this handles both renamed imports and imports of
+	// packages containing unconventional package declarations.
+	// Note that this uses / always, even on Windows, because Go import
+	// paths always use forward slashes.
+	path := obj.imported.path
+	elem := path
+	if i := strings.LastIndex(elem, "/"); i >= 0 {
+		elem = elem[i+1:]
+	}
+	if obj.name == "" || obj.name == "." || obj.name == elem {
+		check.softErrorf(obj, _UnusedImport, "%q imported but not used", path)
+	} else {
+		check.softErrorf(obj, _UnusedImport, "%q imported but not used as %s", path, obj.name)
 	}
-	return path
 }
 
 // dir makes a good-faith attempt to return the directory
diff --git a/src/go/types/testdata/importdecl0/importdecl0b.src b/src/go/types/testdata/importdecl0/importdecl0b.src
index 6844e70982..55690423b6 100644
--- a/src/go/types/testdata/importdecl0/importdecl0b.src
+++ b/src/go/types/testdata/importdecl0/importdecl0b.src
@@ -8,7 +8,7 @@ import "math"
 import m "math"
 
 import . "testing" // declares T in file scope
-import . /* ERROR "imported but not used" */ "unsafe"
+import . /* ERROR .unsafe. imported but not used */ "unsafe"
 import . "fmt"     // declares Println in file scope
 
 import (
diff --git a/src/go/types/testdata/importdecl1/importdecl1b.src b/src/go/types/testdata/importdecl1/importdecl1b.src
index ee70bbd8e7..43a7bcd753 100644
--- a/src/go/types/testdata/importdecl1/importdecl1b.src
+++ b/src/go/types/testdata/importdecl1/importdecl1b.src
@@ -4,7 +4,7 @@
 
 package importdecl1
 
-import . /* ERROR "imported but not used" */ "unsafe"
+import . /* ERROR .unsafe. imported but not used */ "unsafe"
 
 type B interface {
 	A
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index 311a970051..6e89ccb027 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -51,12 +51,12 @@ func (check *Checker) ident(x *operand, e *ast.Ident, def *Named, wantType bool)
 	}
 	assert(typ != nil)
 
-	// The object may be dot-imported: If so, remove its package from
-	// the map of unused dot imports for the respective file scope.
+	// The object may have been dot-imported.
+	// If so, mark the respective package as used.
 	// (This code is only needed for dot-imports. Without them,
 	// we only have to mark variables, see *Var case below).
-	if pkg := obj.Pkg(); pkg != check.pkg && pkg != nil {
-		delete(check.unusedDotImports[scope], pkg)
+	if pkgName := check.dotImportMap[dotImportKey{scope, obj}]; pkgName != nil {
+		pkgName.used = true
 	}
 
 	switch obj := obj.(type) {
-- 
GitLab


From 493363ccff354ab5ed133f6d5fac942ba6cc034a Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Mon, 8 Feb 2021 18:24:13 -0500
Subject: [PATCH 0620/2400] [dev.regabi] go/types: must not import a package
 called "init"

This is a port of CL 287494 to go/types. The additional checks in
test/fixedbugs are included, though they won't be executed by go/types.
Support for errorcheckdir checks will be added to go/types in a later
CL.

Change-Id: I37e202ea5daf7d7b8fc6ae93a4c4dbd11762480f
Reviewed-on: https://go-review.googlesource.com/c/go/+/290570
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/go/types/resolver.go                      | 25 ++++++++++---------
 .../testdata/importdecl0/importdecl0a.src     |  2 +-
 test/fixedbugs/issue43962.dir/a.go            |  5 ++++
 test/fixedbugs/issue43962.dir/b.go            |  7 ++++++
 test/fixedbugs/issue43962.go                  |  9 +++++++
 5 files changed, 35 insertions(+), 13 deletions(-)
 create mode 100644 test/fixedbugs/issue43962.dir/a.go
 create mode 100644 test/fixedbugs/issue43962.dir/b.go
 create mode 100644 test/fixedbugs/issue43962.go

diff --git a/src/go/types/resolver.go b/src/go/types/resolver.go
index cb66871883..47e165db36 100644
--- a/src/go/types/resolver.go
+++ b/src/go/types/resolver.go
@@ -252,14 +252,6 @@ func (check *Checker) collectObjects() {
 					return
 				}
 
-				// add package to list of explicit imports
-				// (this functionality is provided as a convenience
-				// for clients; it is not needed for type-checking)
-				if !pkgImports[imp] {
-					pkgImports[imp] = true
-					pkg.imports = append(pkg.imports, imp)
-				}
-
 				// local name overrides imported package name
 				name := imp.name
 				if d.spec.Name != nil {
@@ -269,10 +261,19 @@ func (check *Checker) collectObjects() {
 						check.errorf(d.spec.Name, _ImportCRenamed, `cannot rename import "C"`)
 						return
 					}
-					if name == "init" {
-						check.errorf(d.spec.Name, _InvalidInitDecl, "cannot declare init - must be func")
-						return
-					}
+				}
+
+				if name == "init" {
+					check.errorf(d.spec.Name, _InvalidInitDecl, "cannot import package as init - init must be a func")
+					return
+				}
+
+				// add package to list of explicit imports
+				// (this functionality is provided as a convenience
+				// for clients; it is not needed for type-checking)
+				if !pkgImports[imp] {
+					pkgImports[imp] = true
+					pkg.imports = append(pkg.imports, imp)
 				}
 
 				pkgName := NewPkgName(d.spec.Pos(), pkg, name, imp)
diff --git a/src/go/types/testdata/importdecl0/importdecl0a.src b/src/go/types/testdata/importdecl0/importdecl0a.src
index e96fca3cdd..5ceb96e1fa 100644
--- a/src/go/types/testdata/importdecl0/importdecl0a.src
+++ b/src/go/types/testdata/importdecl0/importdecl0a.src
@@ -10,7 +10,7 @@ import (
 	// we can have multiple blank imports (was bug)
 	_ "math"
 	_ "net/rpc"
-	init /* ERROR "cannot declare init" */ "fmt"
+	init /* ERROR "cannot import package as init" */ "fmt"
 	// reflect defines a type "flag" which shows up in the gc export data
 	"reflect"
 	. /* ERROR "imported but not used" */ "reflect"
diff --git a/test/fixedbugs/issue43962.dir/a.go b/test/fixedbugs/issue43962.dir/a.go
new file mode 100644
index 0000000000..168b2063b4
--- /dev/null
+++ b/test/fixedbugs/issue43962.dir/a.go
@@ -0,0 +1,5 @@
+// Copyright 2021 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 init
diff --git a/test/fixedbugs/issue43962.dir/b.go b/test/fixedbugs/issue43962.dir/b.go
new file mode 100644
index 0000000000..f55fea11c1
--- /dev/null
+++ b/test/fixedbugs/issue43962.dir/b.go
@@ -0,0 +1,7 @@
+// Copyright 2021 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 b
+
+import "./a" // ERROR "cannot import package as init"
diff --git a/test/fixedbugs/issue43962.go b/test/fixedbugs/issue43962.go
new file mode 100644
index 0000000000..dca4d077d5
--- /dev/null
+++ b/test/fixedbugs/issue43962.go
@@ -0,0 +1,9 @@
+// errorcheckdir
+
+// Copyright 2021 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.
+
+// Issue 43962: Importing a package called "init" is an error.
+
+package ignored
-- 
GitLab


From 1c58fcf7ed917f66e2b7f77f251e7e63ca9630e2 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Mon, 8 Feb 2021 18:04:58 -0500
Subject: [PATCH 0621/2400] [dev.regabi] go/types: handle untyped constant
 arithmetic overflow

This is a port of CL 287832 for go/types. It differs from that CL in its
handling of position data. Unlike the syntax package, which has a
unified Operation node, go/types checks operations for ast.UnaryExpr,
IncDecStmt, and BinaryExpr. It was simpler to keep the existing position
logic. Notably, this correctly puts the errors on the operator.

Change-Id: Id1e3aefe863da225eb0a9b3628cfc8a5684c0c4f
Reviewed-on: https://go-review.googlesource.com/c/go/+/290569
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Findley <rfindley@google.com>
---
 src/go/types/expr.go             | 133 +++++++++++++++++++------------
 src/go/types/stdlib_test.go      |   1 -
 src/go/types/testdata/const0.src |   7 ++
 3 files changed, 88 insertions(+), 53 deletions(-)

diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index f7fb0caedd..2741cc635d 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -78,13 +78,60 @@ func (check *Checker) op(m opPredicates, x *operand, op token.Token) bool {
 	return true
 }
 
+// overflow checks that the constant x is representable by its type.
+// For untyped constants, it checks that the value doesn't become
+// arbitrarily large.
+func (check *Checker) overflow(x *operand, op token.Token, opPos token.Pos) {
+	assert(x.mode == constant_)
+
+	what := "" // operator description, if any
+	if int(op) < len(op2str) {
+		what = op2str[op]
+	}
+
+	if x.val.Kind() == constant.Unknown {
+		// TODO(gri) We should report exactly what went wrong. At the
+		//           moment we don't have the (go/constant) API for that.
+		//           See also TODO in go/constant/value.go.
+		check.errorf(atPos(opPos), _InvalidConstVal, "constant result is not representable")
+		return
+	}
+
+	// Typed constants must be representable in
+	// their type after each constant operation.
+	if typ, ok := x.typ.Underlying().(*Basic); ok && isTyped(typ) {
+		check.representable(x, typ)
+		return
+	}
+
+	// Untyped integer values must not grow arbitrarily.
+	const limit = 4 * 512 // 512 is the constant precision - we need more because old tests had no limits
+	if x.val.Kind() == constant.Int && constant.BitLen(x.val) > limit {
+		check.errorf(atPos(opPos), _InvalidConstVal, "constant %s overflow", what)
+		x.val = constant.MakeUnknown()
+	}
+}
+
+// This is only used for operations that may cause overflow.
+var op2str = [...]string{
+	token.ADD: "addition",
+	token.SUB: "subtraction",
+	token.XOR: "bitwise XOR",
+	token.MUL: "multiplication",
+	token.SHL: "shift",
+}
+
 // The unary expression e may be nil. It's passed in for better error messages only.
-func (check *Checker) unary(x *operand, e *ast.UnaryExpr, op token.Token) {
-	switch op {
+func (check *Checker) unary(x *operand, e *ast.UnaryExpr) {
+	check.expr(x, e.X)
+	if x.mode == invalid {
+		return
+	}
+	switch e.Op {
 	case token.AND:
 		// spec: "As an exception to the addressability
 		// requirement x may also be a composite literal."
-		if _, ok := unparen(x.expr).(*ast.CompositeLit); !ok && x.mode != variable {
+		if _, ok := unparen(e.X).(*ast.CompositeLit); !ok && x.mode != variable {
 			check.invalidOp(x, _UnaddressableOperand, "cannot take address of %s", x)
 			x.mode = invalid
 			return
@@ -111,26 +158,23 @@ func (check *Checker) unary(x *operand, e *ast.UnaryExpr, op token.Token) {
 		return
 	}
 
-	if !check.op(unaryOpPredicates, x, op) {
+	if !check.op(unaryOpPredicates, x, e.Op) {
 		x.mode = invalid
 		return
 	}
 
 	if x.mode == constant_ {
-		typ := x.typ.Underlying().(*Basic)
-		var prec uint
-		if isUnsigned(typ) {
-			prec = uint(check.conf.sizeof(typ) * 8)
+		if x.val.Kind() == constant.Unknown {
+			// nothing to do (and don't cause an error below in the overflow check)
+			return
 		}
-		x.val = constant.UnaryOp(op, x.val, prec)
-		// Typed constants must be representable in
-		// their type after each constant operation.
-		if isTyped(typ) {
-			if e != nil {
-				x.expr = e // for better error message
-			}
-			check.representable(x, typ)
+		var prec uint
+		if isUnsigned(x.typ) {
+			prec = uint(check.conf.sizeof(x.typ) * 8)
 		}
+		x.val = constant.UnaryOp(e.Op, x.val, prec)
+		x.expr = e
+		check.overflow(x, e.Op, x.Pos())
 		return
 	}
 
@@ -667,7 +711,8 @@ func (check *Checker) comparison(x, y *operand, op token.Token) {
 	x.typ = Typ[UntypedBool]
 }
 
-func (check *Checker) shift(x, y *operand, e *ast.BinaryExpr, op token.Token) {
+// If e != nil, it must be the shift expression; it may be nil for non-constant shifts.
+func (check *Checker) shift(x, y *operand, e ast.Expr, op token.Token) {
 	untypedx := isUntyped(x.typ)
 
 	var xval constant.Value
@@ -735,14 +780,12 @@ func (check *Checker) shift(x, y *operand, e *ast.BinaryExpr, op token.Token) {
 			}
 			// x is a constant so xval != nil and it must be of Int kind.
 			x.val = constant.Shift(xval, op, uint(s))
-			// Typed constants must be representable in
-			// their type after each constant operation.
-			if isTyped(x.typ) {
-				if e != nil {
-					x.expr = e // for better error message
-				}
-				check.representable(x, x.typ.Underlying().(*Basic))
+			x.expr = e
+			opPos := x.Pos()
+			if b, _ := e.(*ast.BinaryExpr); b != nil {
+				opPos = b.OpPos
 			}
+			check.overflow(x, op, opPos)
 			return
 		}
 
@@ -803,8 +846,9 @@ var binaryOpPredicates = opPredicates{
 	token.LOR:  isBoolean,
 }
 
-// The binary expression e may be nil. It's passed in for better error messages only.
-func (check *Checker) binary(x *operand, e *ast.BinaryExpr, lhs, rhs ast.Expr, op token.Token, opPos token.Pos) {
+// If e != nil, it must be the binary expression; it may be nil for non-constant expressions
+// (when invoked for an assignment operation where the binary expression is implicit).
+func (check *Checker) binary(x *operand, e ast.Expr, lhs, rhs ast.Expr, op token.Token, opPos token.Pos) {
 	var y operand
 
 	check.expr(x, lhs)
@@ -879,30 +923,19 @@ func (check *Checker) binary(x *operand, e *ast.BinaryExpr, lhs, rhs ast.Expr, o
 	}
 
 	if x.mode == constant_ && y.mode == constant_ {
-		xval := x.val
-		yval := y.val
-		typ := x.typ.Underlying().(*Basic)
+		// if either x or y has an unknown value, the result is unknown
+		if x.val.Kind() == constant.Unknown || y.val.Kind() == constant.Unknown {
+			x.val = constant.MakeUnknown()
+			// x.typ is unchanged
+			return
+		}
 		// force integer division of integer operands
-		if op == token.QUO && isInteger(typ) {
+		if op == token.QUO && isInteger(x.typ) {
 			op = token.QUO_ASSIGN
 		}
-		x.val = constant.BinaryOp(xval, op, yval)
-		// report error if valid operands lead to an invalid result
-		if xval.Kind() != constant.Unknown && yval.Kind() != constant.Unknown && x.val.Kind() == constant.Unknown {
-			// TODO(gri) We should report exactly what went wrong. At the
-			//           moment we don't have the (go/constant) API for that.
-			//           See also TODO in go/constant/value.go.
-			check.errorf(atPos(opPos), _InvalidConstVal, "constant result is not representable")
-			// TODO(gri) Should we mark operands with unknown values as invalid?
-		}
-		// Typed constants must be representable in
-		// their type after each constant operation.
-		if isTyped(typ) {
-			if e != nil {
-				x.expr = e // for better error message
-			}
-			check.representable(x, typ)
-		}
+		x.val = constant.BinaryOp(x.val, op, y.val)
+		x.expr = e
+		check.overflow(x, op, opPos)
 		return
 	}
 
@@ -1538,11 +1571,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 		}
 
 	case *ast.UnaryExpr:
-		check.expr(x, e.X)
-		if x.mode == invalid {
-			goto Error
-		}
-		check.unary(x, e, e.Op)
+		check.unary(x, e)
 		if x.mode == invalid {
 			goto Error
 		}
diff --git a/src/go/types/stdlib_test.go b/src/go/types/stdlib_test.go
index 63e31f3d74..8a1e2905a7 100644
--- a/src/go/types/stdlib_test.go
+++ b/src/go/types/stdlib_test.go
@@ -171,7 +171,6 @@ func TestStdFixed(t *testing.T) {
 	testTestDir(t, filepath.Join(runtime.GOROOT(), "test", "fixedbugs"),
 		"bug248.go", "bug302.go", "bug369.go", // complex test instructions - ignore
 		"issue6889.go",   // gc-specific test
-		"issue7746.go",   // large constants - consumes too much memory
 		"issue11362.go",  // canonical import path check
 		"issue16369.go",  // go/types handles this correctly - not an issue
 		"issue18459.go",  // go/types doesn't check validity of //go:xxx directives
diff --git a/src/go/types/testdata/const0.src b/src/go/types/testdata/const0.src
index adbbf2863b..2916af5490 100644
--- a/src/go/types/testdata/const0.src
+++ b/src/go/types/testdata/const0.src
@@ -348,3 +348,10 @@ const _ = unsafe.Sizeof(func() {
 	assert(one == 1)
 	assert(iota == 0)
 })
+
+// untyped constants must not get arbitrarily large
+const (
+	huge = 1<<1000
+	_ = huge * huge * /* ERROR constant multiplication overflow */ huge
+	_ = huge << 1000 << /* ERROR constant shift overflow */ 1000
+)
-- 
GitLab


From 0a62067708938020e10b8142b4017edeac1b1f52 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Mon, 8 Feb 2021 21:53:29 -0500
Subject: [PATCH 0622/2400] [dev.regabi] go/types: adjust importer to match
 compiler importer

This is an exact port of CL 288632 to go/types.

Change-Id: Ie46e13355bdd0713b392e042844bab8491a16504
Reviewed-on: https://go-review.googlesource.com/c/go/+/290629
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/internal/gcimporter/iimport.go | 52 +++++++++++----------------
 1 file changed, 20 insertions(+), 32 deletions(-)

diff --git a/src/go/internal/gcimporter/iimport.go b/src/go/internal/gcimporter/iimport.go
index c59dd16533..a3184e7641 100644
--- a/src/go/internal/gcimporter/iimport.go
+++ b/src/go/internal/gcimporter/iimport.go
@@ -15,6 +15,7 @@ import (
 	"go/token"
 	"go/types"
 	"io"
+	"math/big"
 	"sort"
 )
 
@@ -320,7 +321,9 @@ func (r *importReader) value() (typ types.Type, val constant.Value) {
 		val = constant.MakeString(r.string())
 
 	case types.IsInteger:
-		val = r.mpint(b)
+		var x big.Int
+		r.mpint(&x, b)
+		val = constant.Make(&x)
 
 	case types.IsFloat:
 		val = r.mpfloat(b)
@@ -365,8 +368,8 @@ func intSize(b *types.Basic) (signed bool, maxBytes uint) {
 	return
 }
 
-func (r *importReader) mpint(b *types.Basic) constant.Value {
-	signed, maxBytes := intSize(b)
+func (r *importReader) mpint(x *big.Int, typ *types.Basic) {
+	signed, maxBytes := intSize(typ)
 
 	maxSmall := 256 - maxBytes
 	if signed {
@@ -385,7 +388,8 @@ func (r *importReader) mpint(b *types.Basic) constant.Value {
 				v = ^v
 			}
 		}
-		return constant.MakeInt64(v)
+		x.SetInt64(v)
+		return
 	}
 
 	v := -n
@@ -395,39 +399,23 @@ func (r *importReader) mpint(b *types.Basic) constant.Value {
 	if v < 1 || uint(v) > maxBytes {
 		errorf("weird decoding: %v, %v => %v", n, signed, v)
 	}
-
-	buf := make([]byte, v)
-	io.ReadFull(&r.declReader, buf)
-
-	// convert to little endian
-	// TODO(gri) go/constant should have a more direct conversion function
-	//           (e.g., once it supports a big.Float based implementation)
-	for i, j := 0, len(buf)-1; i < j; i, j = i+1, j-1 {
-		buf[i], buf[j] = buf[j], buf[i]
-	}
-
-	x := constant.MakeFromBytes(buf)
+	b := make([]byte, v)
+	io.ReadFull(&r.declReader, b)
+	x.SetBytes(b)
 	if signed && n&1 != 0 {
-		x = constant.UnaryOp(token.SUB, x, 0)
+		x.Neg(x)
 	}
-	return x
 }
 
-func (r *importReader) mpfloat(b *types.Basic) constant.Value {
-	x := r.mpint(b)
-	if constant.Sign(x) == 0 {
-		return x
-	}
-
-	exp := r.int64()
-	switch {
-	case exp > 0:
-		x = constant.Shift(x, token.SHL, uint(exp))
-	case exp < 0:
-		d := constant.Shift(constant.MakeInt64(1), token.SHL, uint(-exp))
-		x = constant.BinaryOp(x, token.QUO, d)
+func (r *importReader) mpfloat(typ *types.Basic) constant.Value {
+	var mant big.Int
+	r.mpint(&mant, typ)
+	var f big.Float
+	f.SetInt(&mant)
+	if f.Sign() != 0 {
+		f.SetMantExp(&f, int(r.int64()))
 	}
-	return x
+	return constant.Make(&f)
 }
 
 func (r *importReader) ident() string {
-- 
GitLab


From 168d6a49a5ecbdd6a1eb039b2398c2821b3d3865 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Mon, 8 Feb 2021 22:37:48 -0500
Subject: [PATCH 0623/2400] [dev.regabi] go/types: use 512 bits as max. integer
 precision

This is a port of CL 288633 to go/types. It differs from that CL
in the implementation of opName, which now uses ast Exprs.

Additionally, a couple tests had to be updated:
 + TestEvalArith is updated to not overflow.
 + stmt0.src is updated to have an error positioned on the '<<'
   operator.

Change-Id: I628357c33a1e7b0bb5bb7de5736f1fb10ce404e4
Reviewed-on: https://go-review.googlesource.com/c/go/+/290630
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/eval_test.go          |  2 +-
 src/go/types/expr.go               | 46 +++++++++++++++++++++++-------
 src/go/types/stdlib_test.go        |  1 -
 src/go/types/testdata/builtins.src | 10 +++----
 src/go/types/testdata/const0.src   | 16 +++++++----
 src/go/types/testdata/const1.src   | 18 ++++++++++--
 src/go/types/testdata/stmt0.src    |  2 +-
 7 files changed, 69 insertions(+), 26 deletions(-)

diff --git a/src/go/types/eval_test.go b/src/go/types/eval_test.go
index d940bf0e80..3a97ac0471 100644
--- a/src/go/types/eval_test.go
+++ b/src/go/types/eval_test.go
@@ -76,7 +76,7 @@ func TestEvalArith(t *testing.T) {
 		`false == false`,
 		`12345678 + 87654321 == 99999999`,
 		`10 * 20 == 200`,
-		`(1<<1000)*2 >> 100 == 2<<900`,
+		`(1<<500)*2 >> 100 == 2<<400`,
 		`"foo" + "bar" == "foobar"`,
 		`"abc" <= "bcd"`,
 		`len([10]struct{}{}) == 2*5`,
diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 2741cc635d..5e1fe28a43 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -84,11 +84,6 @@ func (check *Checker) op(m opPredicates, x *operand, op token.Token) bool {
 func (check *Checker) overflow(x *operand, op token.Token, opPos token.Pos) {
 	assert(x.mode == constant_)
 
-	what := "" // operator description, if any
-	if int(op) < len(op2str) {
-		what = op2str[op]
-	}
-
 	if x.val.Kind() == constant.Unknown {
 		// TODO(gri) We should report exactly what went wrong. At the
 		//           moment we don't have the (go/constant) API for that.
@@ -105,15 +100,37 @@ func (check *Checker) overflow(x *operand, op token.Token, opPos token.Pos) {
 	}
 
 	// Untyped integer values must not grow arbitrarily.
-	const limit = 4 * 512 // 512 is the constant precision - we need more because old tests had no limits
-	if x.val.Kind() == constant.Int && constant.BitLen(x.val) > limit {
-		check.errorf(atPos(opPos), _InvalidConstVal, "constant %s overflow", what)
+	const prec = 512 // 512 is the constant precision
+	if x.val.Kind() == constant.Int && constant.BitLen(x.val) > prec {
+		check.errorf(atPos(opPos), _InvalidConstVal, "constant %s overflow", opName(x.expr))
 		x.val = constant.MakeUnknown()
 	}
 }
 
+// opName returns the name of an operation, or the empty string.
+// For now, only operations that might overflow are handled.
+// TODO(gri) Expand this to a general mechanism giving names to
+//           nodes?
+func opName(e ast.Expr) string {
+	switch e := e.(type) {
+	case *ast.BinaryExpr:
+		if int(e.Op) < len(op2str2) {
+			return op2str2[e.Op]
+		}
+	case *ast.UnaryExpr:
+		if int(e.Op) < len(op2str1) {
+			return op2str1[e.Op]
+		}
+	}
+	return ""
+}
+
+var op2str1 = [...]string{
+	token.XOR: "bitwise complement",
+}
+
 // This is only used for operations that may cause overflow.
-var op2str = [...]string{
+var op2str2 = [...]string{
 	token.ADD: "addition",
 	token.SUB: "subtraction",
 	token.XOR: "bitwise XOR",
@@ -763,8 +780,17 @@ func (check *Checker) shift(x, y *operand, e ast.Expr, op token.Token) {
 
 	if x.mode == constant_ {
 		if y.mode == constant_ {
+			// if either x or y has an unknown value, the result is unknown
+			if x.val.Kind() == constant.Unknown || y.val.Kind() == constant.Unknown {
+				x.val = constant.MakeUnknown()
+				// ensure the correct type - see comment below
+				if !isInteger(x.typ) {
+					x.typ = Typ[UntypedInt]
+				}
+				return
+			}
 			// rhs must be within reasonable bounds in constant shifts
-			const shiftBound = 1023 - 1 + 52 // so we can express smallestFloat64
+			const shiftBound = 1023 - 1 + 52 // so we can express smallestFloat64 (see issue #44057)
 			s, ok := constant.Uint64Val(yval)
 			if !ok || s > shiftBound {
 				check.invalidOp(y, _InvalidShiftCount, "invalid shift count %s", y)
diff --git a/src/go/types/stdlib_test.go b/src/go/types/stdlib_test.go
index 8a1e2905a7..71e14b85e5 100644
--- a/src/go/types/stdlib_test.go
+++ b/src/go/types/stdlib_test.go
@@ -175,7 +175,6 @@ func TestStdFixed(t *testing.T) {
 		"issue16369.go",  // go/types handles this correctly - not an issue
 		"issue18459.go",  // go/types doesn't check validity of //go:xxx directives
 		"issue18882.go",  // go/types doesn't check validity of //go:xxx directives
-		"issue20232.go",  // go/types handles larger constants than gc
 		"issue20529.go",  // go/types does not have constraints on stack size
 		"issue22200.go",  // go/types does not have constraints on stack size
 		"issue22200b.go", // go/types does not have constraints on stack size
diff --git a/src/go/types/testdata/builtins.src b/src/go/types/testdata/builtins.src
index a7613adc35..6ee28f13b4 100644
--- a/src/go/types/testdata/builtins.src
+++ b/src/go/types/testdata/builtins.src
@@ -514,7 +514,7 @@ func panic1() {
 	panic("foo")
 	panic(false)
 	panic(1<<10)
-	panic(1 /* ERROR overflows */ <<1000)
+	panic(1 << /* ERROR constant shift overflow */ 1000)
 	_ = panic /* ERROR used as value */ (0)
 
 	var s []byte
@@ -538,7 +538,7 @@ func print1() {
 	print(2.718281828)
 	print(false)
 	print(1<<10)
-	print(1 /* ERROR overflows */ <<1000)
+	print(1 << /* ERROR constant shift overflow */ 1000)
 	println(nil /* ERROR untyped nil */ )
 
 	var s []int
@@ -564,7 +564,7 @@ func println1() {
 	println(2.718281828)
 	println(false)
 	println(1<<10)
-	println(1 /* ERROR overflows */ <<1000)
+	println(1 << /* ERROR constant shift overflow */ 1000)
 	println(nil /* ERROR untyped nil */ )
 
 	var s []int
@@ -695,7 +695,7 @@ func Alignof1() {
 	_ = unsafe.Alignof(42)
 	_ = unsafe.Alignof(new(struct{}))
 	_ = unsafe.Alignof(1<<10)
-	_ = unsafe.Alignof(1 /* ERROR overflows */ <<1000)
+	_ = unsafe.Alignof(1 << /* ERROR constant shift overflow */ 1000)
 	_ = unsafe.Alignof(nil /* ERROR "untyped nil */ )
 	unsafe /* ERROR not used */ .Alignof(x)
 
@@ -783,7 +783,7 @@ func Sizeof1() {
 	_ = unsafe.Sizeof(42)
 	_ = unsafe.Sizeof(new(complex128))
 	_ = unsafe.Sizeof(1<<10)
-	_ = unsafe.Sizeof(1 /* ERROR overflows */ <<1000)
+	_ = unsafe.Sizeof(1 << /* ERROR constant shift overflow */ 1000)
 	_ = unsafe.Sizeof(nil /* ERROR untyped nil */ )
 	unsafe /* ERROR not used */ .Sizeof(x)
 
diff --git a/src/go/types/testdata/const0.src b/src/go/types/testdata/const0.src
index 2916af5490..5608b1549b 100644
--- a/src/go/types/testdata/const0.src
+++ b/src/go/types/testdata/const0.src
@@ -350,8 +350,14 @@ const _ = unsafe.Sizeof(func() {
 })
 
 // untyped constants must not get arbitrarily large
-const (
-	huge = 1<<1000
-	_ = huge * huge * /* ERROR constant multiplication overflow */ huge
-	_ = huge << 1000 << /* ERROR constant shift overflow */ 1000
-)
+const prec = 512 // internal maximum precision for integers
+const maxInt = (1<<(prec/2) - 1) * (1<<(prec/2) + 1) // == 1<<prec - 1
+
+const _ = maxInt + /* ERROR constant addition overflow */ 1
+const _ = -maxInt - /* ERROR constant subtraction overflow */ 1
+const _ = maxInt ^ /* ERROR constant bitwise XOR overflow */ -1
+const _ = maxInt * /* ERROR constant multiplication overflow */ 2
+const _ = maxInt << /* ERROR constant shift overflow */ 2
+const _ = 1 << /* ERROR constant shift overflow */ prec
+
+const _ = ^ /* ERROR constant bitwise complement overflow */ maxInt
diff --git a/src/go/types/testdata/const1.src b/src/go/types/testdata/const1.src
index d82770464f..56b6bd4ca5 100644
--- a/src/go/types/testdata/const1.src
+++ b/src/go/types/testdata/const1.src
@@ -43,7 +43,12 @@ const (
 
 const (
 	smallestFloat32 = 1.0 / (1<<(127 - 1 + 23))
-	smallestFloat64 = 1.0 / (1<<(1023 - 1 + 52))
+	// TODO(gri) The compiler limits integers to 512 bit and thus
+	//           we cannot compute the value (1<<(1023 - 1 + 52))
+	//           without overflow. For now we match the compiler.
+	//           See also issue #44057.
+	// smallestFloat64 = 1.0 / (1<<(1023 - 1 + 52))
+	smallestFloat64 = 4.940656458412465441765687928682213723651e-324
 )
 
 const (
@@ -53,7 +58,12 @@ const (
 
 const (
 	maxFloat32 = 1<<127 * (1<<24 - 1) / (1.0<<23)
-	maxFloat64 = 1<<1023 * (1<<53 - 1) / (1.0<<52)
+	// TODO(gri) The compiler limits integers to 512 bit and thus
+	//           we cannot compute the value 1<<1023
+	//           without overflow. For now we match the compiler.
+	//           See also issue #44057.
+	// maxFloat64 = 1<<1023 * (1<<53 - 1) / (1.0<<52)
+	maxFloat64 = 1.797693134862315708145274237317043567981e+308
 )
 
 const (
@@ -271,7 +281,9 @@ const (
 	_ = assert(float64(smallestFloat32) == smallestFloat32)
 	_ = assert(float64(smallestFloat32/2) == smallestFloat32/2)
 	_ = assert(float64(smallestFloat64) == smallestFloat64)
-	_ = assert(float64(smallestFloat64/2) == 0)
+	// TODO(gri) With the change to the declaration of smallestFloat64
+	//           this now fails to be true. See issue #44058.
+	// _ = assert(float64(smallestFloat64/2) == 0)
 )
 
 const (
diff --git a/src/go/types/testdata/stmt0.src b/src/go/types/testdata/stmt0.src
index 13777292a9..de8f936a61 100644
--- a/src/go/types/testdata/stmt0.src
+++ b/src/go/types/testdata/stmt0.src
@@ -90,7 +90,7 @@ func assignments1() {
 
 	// assignments to _
 	_ = nil /* ERROR "use of untyped nil" */
-	_ = 1 /* ERROR overflow */ <<1000
+	_ = 1  << /* ERROR constant shift overflow */ 1000
 	(_) = 0
 }
 
-- 
GitLab


From 12e15d430d408ff9a961bdfb72cfc7f0b521a354 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Mon, 8 Feb 2021 14:33:51 -0800
Subject: [PATCH 0624/2400] [dev.typeparams] cmd/compile: handle calling a
 method on a type param in stenciling

 - Have to delay the extra transformation on methods invoked on a type
   param, since the actual transformation (including path through
   embedded fields) will depend on the instantiated type. I am currently
   doing the transformation during the stencil substitution phase. We
   probably should have a separate pass after noder2 and stenciling,
   which drives the extra transformations that were in the old
   typechecker.

 - We handle method values (that are not called) and method calls. We
   don't currently handle method expressions.

 - Handle type substitution in function types, which is needed for
   function args in generic functions.

 - Added stringer.go and map.go tests, testing the above changes
   (including constraints with embedded interfaces).

Change-Id: I3831a937d2b8814150f75bebf9f23ab10b93fa00
Reviewed-on: https://go-review.googlesource.com/c/go/+/290550
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Dan Scales <danscales@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/expr.go    | 19 +++--
 src/cmd/compile/internal/noder/helpers.go | 10 +++
 src/cmd/compile/internal/noder/stencil.go | 77 +++++++++++++++++---
 src/cmd/compile/internal/types/type.go    |  1 +
 test/typeparam/map.go                     | 39 ++++++++++
 test/typeparam/stringer.go                | 88 +++++++++++++++++++++++
 6 files changed, 219 insertions(+), 15 deletions(-)
 create mode 100644 test/typeparam/map.go
 create mode 100644 test/typeparam/stringer.go

diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index 568ec216e3..3d6fba2dfe 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -87,11 +87,13 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 
 	case *syntax.CompositeLit:
 		return g.compLit(typ, expr)
+
 	case *syntax.FuncLit:
 		return g.funcLit(typ, expr)
 
 	case *syntax.AssertExpr:
 		return Assert(pos, g.expr(expr.X), g.typeExpr(expr.Type))
+
 	case *syntax.CallExpr:
 		fun := g.expr(expr.Fun)
 		if inferred, ok := g.info.Inferred[expr]; ok && len(inferred.Targs) > 0 {
@@ -114,6 +116,7 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 
 		}
 		return Call(pos, g.typ(typ), fun, g.exprs(expr.ArgList), expr.HasDots)
+
 	case *syntax.IndexExpr:
 		var targs []ir.Node
 		if _, ok := expr.Index.(*syntax.ListExpr); ok {
@@ -139,6 +142,7 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 
 	case *syntax.ParenExpr:
 		return g.expr(expr.X) // skip parens; unneeded after parse+typecheck
+
 	case *syntax.SelectorExpr:
 		// Qualified identifier.
 		if name, ok := expr.X.(*syntax.Name); ok {
@@ -147,8 +151,8 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 				return typecheck.Expr(g.use(expr.Sel))
 			}
 		}
+		return g.selectorExpr(pos, typ, expr)
 
-		return g.selectorExpr(pos, expr)
 	case *syntax.SliceExpr:
 		return Slice(pos, g.expr(expr.X), g.expr(expr.Index[0]), g.expr(expr.Index[1]), g.expr(expr.Index[2]))
 
@@ -172,15 +176,22 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 // selectorExpr resolves the choice of ODOT, ODOTPTR, OCALLPART (eventually
 // ODOTMETH & ODOTINTER), and OMETHEXPR and deals with embedded fields here rather
 // than in typecheck.go.
-func (g *irgen) selectorExpr(pos src.XPos, expr *syntax.SelectorExpr) ir.Node {
-	selinfo := g.info.Selections[expr]
+func (g *irgen) selectorExpr(pos src.XPos, typ types2.Type, expr *syntax.SelectorExpr) ir.Node {
+	x := g.expr(expr.X)
+	if x.Type().Kind() == types.TTYPEPARAM {
+		// Leave a method call on a type param as an OXDOT, since it can
+		// only be fully transformed once it has an instantiated type.
+		n := ir.NewSelectorExpr(pos, ir.OXDOT, x, typecheck.Lookup(expr.Sel.Value))
+		typed(g.typ(typ), n)
+		return n
+	}
 
+	selinfo := g.info.Selections[expr]
 	// Everything up to the last selection is an implicit embedded field access,
 	// and the last selection is determined by selinfo.Kind().
 	index := selinfo.Index()
 	embeds, last := index[:len(index)-1], index[len(index)-1]
 
-	x := g.expr(expr.X)
 	origx := x
 	for _, ix := range embeds {
 		x = Implicit(DotField(pos, x, ix))
diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
index bb17a5331a..2bf125bdd8 100644
--- a/src/cmd/compile/internal/noder/helpers.go
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -119,6 +119,16 @@ func Call(pos src.XPos, typ *types.Type, fun ir.Node, args []ir.Node, dots bool)
 	n := ir.NewCallExpr(pos, ir.OCALL, fun, args)
 	n.IsDDD = dots
 
+	if fun.Op() == ir.OXDOT {
+		if fun.(*ir.SelectorExpr).X.Type().Kind() != types.TTYPEPARAM {
+			base.FatalfAt(pos, "Expecting type param receiver in %v", fun)
+		}
+		// For methods called in a generic function, don't do any extra
+		// transformations. We will do those later when we create the
+		// instantiated function and have the correct receiver type.
+		typed(typ, n)
+		return n
+	}
 	if fun.Op() != ir.OFUNCINST {
 		// If no type params, still do normal typechecking, since we're
 		// still missing some things done by tcCall below (mainly
diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 0c4eadcf44..64320237d9 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -173,6 +173,33 @@ func (subst *subster) node(n ir.Node) ir.Node {
 			m.SetType(subst.typ(x.Type()))
 		}
 		ir.EditChildren(m, edit)
+
+		// A method value/call via a type param will have been left as an
+		// OXDOT. When we see this during stenciling, finish the
+		// typechecking, now that we have the instantiated receiver type.
+		// We need to do this now, since the access/selection to the
+		// method for the real type is very different from the selection
+		// for the type param.
+		if x.Op() == ir.OXDOT {
+			// Will transform to an OCALLPART
+			m.SetTypecheck(0)
+			typecheck.Expr(m)
+		}
+		if x.Op() == ir.OCALL {
+			call := m.(*ir.CallExpr)
+			if call.X.Op() != ir.OCALLPART {
+				base.FatalfAt(call.Pos(), "Expecting OXDOT with CALL")
+			}
+			// Redo the typechecking, now that we know the method
+			// value is being called
+			call.X.(*ir.SelectorExpr).SetOp(ir.OXDOT)
+			call.X.SetTypecheck(0)
+			call.X.SetType(nil)
+			typecheck.Callee(call.X)
+			m.SetTypecheck(0)
+			typecheck.Call(m.(*ir.CallExpr))
+		}
+
 		if x.Op() == ir.OCLOSURE {
 			x := x.(*ir.ClosureExpr)
 			// Need to save/duplicate x.Func.Nname,
@@ -206,6 +233,31 @@ func (subst *subster) list(l []ir.Node) []ir.Node {
 	return s
 }
 
+// tstruct substitutes type params in a structure type
+func (subst *subster) tstruct(t *types.Type) *types.Type {
+	if t.NumFields() == 0 {
+		return t
+	}
+	var newfields []*types.Field
+	for i, f := range t.Fields().Slice() {
+		t2 := subst.typ(f.Type)
+		if t2 != f.Type && newfields == nil {
+			newfields = make([]*types.Field, t.NumFields())
+			for j := 0; j < i; j++ {
+				newfields[j] = t.Field(j)
+			}
+		}
+		if newfields != nil {
+			newfields[i] = types.NewField(f.Pos, f.Sym, t2)
+		}
+	}
+	if newfields != nil {
+		return types.NewStruct(t.Pkg(), newfields)
+	}
+	return t
+
+}
+
 // typ substitutes any type parameter found with the corresponding type argument.
 func (subst *subster) typ(t *types.Type) *types.Type {
 	for i, tp := range subst.tparams.Slice() {
@@ -237,20 +289,23 @@ func (subst *subster) typ(t *types.Type) *types.Type {
 		}
 
 	case types.TSTRUCT:
-		newfields := make([]*types.Field, t.NumFields())
-		change := false
-		for i, f := range t.Fields().Slice() {
-			t2 := subst.typ(f.Type)
-			if t2 != f.Type {
-				change = true
-			}
-			newfields[i] = types.NewField(f.Pos, f.Sym, t2)
+		newt := subst.tstruct(t)
+		if newt != t {
+			return newt
 		}
-		if change {
-			return types.NewStruct(t.Pkg(), newfields)
+
+	case types.TFUNC:
+		newrecvs := subst.tstruct(t.Recvs())
+		newparams := subst.tstruct(t.Params())
+		newresults := subst.tstruct(t.Results())
+		if newrecvs != t.Recvs() || newparams != t.Params() || newresults != t.Results() {
+			var newrecv *types.Field
+			if newrecvs.NumFields() > 0 {
+				newrecv = newrecvs.Field(0)
+			}
+			return types.NewSignature(t.Pkg(), newrecv, nil, newparams.FieldSlice(), newresults.FieldSlice())
 		}
 
-		// TODO: case TFUNC
 		// TODO: case TCHAN
 		// TODO: case TMAP
 		// TODO: case TINTER
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 8d07b88ecd..987aa11454 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -1657,6 +1657,7 @@ func NewInterface(pkg *Pkg, methods []*Field) *Type {
 // not really be needed except for the type checker).
 func NewTypeParam(pkg *Pkg, constraint *Type) *Type {
 	t := New(TTYPEPARAM)
+	constraint.wantEtype(TINTER)
 	t.methods = constraint.methods
 	t.Extra.(*Interface).pkg = pkg
 	return t
diff --git a/test/typeparam/map.go b/test/typeparam/map.go
new file mode 100644
index 0000000000..720a52ffbd
--- /dev/null
+++ b/test/typeparam/map.go
@@ -0,0 +1,39 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 (
+	"fmt"
+	"reflect"
+	"strconv"
+)
+
+// Map calls the function f on every element of the slice s,
+// returning a new slice of the results.
+func mapper[F, T any](s []F, f func(F) T) []T {
+	r := make([]T, len(s))
+	for i, v := range s {
+		r[i] = f(v)
+	}
+	return r
+}
+
+func main() {
+	got := mapper([]int{1, 2, 3}, strconv.Itoa)
+	want := []string{"1", "2", "3"}
+	if !reflect.DeepEqual(got, want) {
+		panic(fmt.Sprintf("Got %s, want %s", got, want))
+	}
+
+	fgot := mapper([]float64{2.5, 2.3, 3.5}, func(f float64) string {
+		return strconv.FormatFloat(f, 'f', -1, 64)
+	})
+	fwant := []string{"2.5", "2.3", "3.5"}
+	if !reflect.DeepEqual(fgot, fwant) {
+		panic(fmt.Sprintf("Got %s, want %s", fgot, fwant))
+	}
+}
diff --git a/test/typeparam/stringer.go b/test/typeparam/stringer.go
new file mode 100644
index 0000000000..5086ac72f8
--- /dev/null
+++ b/test/typeparam/stringer.go
@@ -0,0 +1,88 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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.
+
+// Test method calls on type parameters
+
+package main
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+)
+
+// Simple constraint
+type Stringer interface {
+	String() string
+}
+
+func stringify[T Stringer](s []T) (ret []string) {
+	for _, v := range s {
+		ret = append(ret, v.String())
+	}
+	return ret
+}
+
+type myint int
+
+func (i myint) String() string {
+	return strconv.Itoa(int(i))
+}
+
+// Constraint with an embedded interface, but still only requires String()
+type Stringer2 interface {
+	CanBeStringer2() int
+	SubStringer2
+}
+
+type SubStringer2 interface {
+	CanBeSubStringer2() int
+	String() string
+}
+
+func stringify2[T Stringer2](s []T) (ret []string) {
+	for _, v := range s {
+		ret = append(ret, v.String())
+	}
+	return ret
+}
+
+func (myint) CanBeStringer2() int {
+	return 0
+}
+
+func (myint) CanBeSubStringer2() int {
+	return 0
+}
+
+// Test use of method values that are not called
+func stringify3[T Stringer](s []T) (ret []string) {
+	for _, v := range s {
+		f := v.String
+		ret = append(ret, f())
+	}
+	return ret
+}
+
+func main() {
+	x := []myint{myint(1), myint(2), myint(3)}
+
+	got := stringify(x)
+	want := []string{"1", "2", "3"}
+	if !reflect.DeepEqual(got, want) {
+		panic(fmt.Sprintf("Got %s, want %s", got, want))
+	}
+
+	got = stringify2(x)
+	if !reflect.DeepEqual(got, want) {
+		panic(fmt.Sprintf("Got %s, want %s", got, want))
+	}
+
+	got = stringify3(x)
+	if !reflect.DeepEqual(got, want) {
+		panic(fmt.Sprintf("Got %s, want %s", got, want))
+	}
+}
-- 
GitLab


From fdf3496fccfd5c5593ac9e03804ffc8feeb59dbc Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Tue, 9 Feb 2021 15:13:19 -0800
Subject: [PATCH 0625/2400] [dev.typeparams] cmd/compile:  make type
 conversions by type parameters work

When doing a type conversion using a type param, delay the
transformation to OCONV/OCONVNOP until stenciling, since the nodes
created depend on the actual type.

Re-enable the fact.go test.

Change-Id: I3d5861aab3dd0e781d767f67435afaf951dfe451
Reviewed-on: https://go-review.googlesource.com/c/go/+/290752
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/helpers.go |  5 +++
 src/cmd/compile/internal/noder/stencil.go | 40 +++++++++++++----------
 test/typeparam/fact.go                    | 15 +++------
 3 files changed, 33 insertions(+), 27 deletions(-)

diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
index 2bf125bdd8..4cb6bc3eab 100644
--- a/src/cmd/compile/internal/noder/helpers.go
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -84,6 +84,11 @@ func Call(pos src.XPos, typ *types.Type, fun ir.Node, args []ir.Node, dots bool)
 	if fun.Op() == ir.OTYPE {
 		// Actually a type conversion, not a function call.
 		n := ir.NewCallExpr(pos, ir.OCALL, fun, args)
+		if fun.Type().Kind() == types.TTYPEPARAM {
+			// For type params, don't typecheck until we actually know
+			// the type.
+			return typed(typ, n)
+		}
 		return typecheck.Expr(n)
 	}
 
diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 64320237d9..2995496da1 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -174,30 +174,36 @@ func (subst *subster) node(n ir.Node) ir.Node {
 		}
 		ir.EditChildren(m, edit)
 
-		// A method value/call via a type param will have been left as an
-		// OXDOT. When we see this during stenciling, finish the
-		// typechecking, now that we have the instantiated receiver type.
-		// We need to do this now, since the access/selection to the
-		// method for the real type is very different from the selection
-		// for the type param.
 		if x.Op() == ir.OXDOT {
-			// Will transform to an OCALLPART
+			// A method value/call via a type param will have been left as an
+			// OXDOT. When we see this during stenciling, finish the
+			// typechecking, now that we have the instantiated receiver type.
+			// We need to do this now, since the access/selection to the
+			// method for the real type is very different from the selection
+			// for the type param.
 			m.SetTypecheck(0)
+			// m will transform to an OCALLPART
 			typecheck.Expr(m)
 		}
 		if x.Op() == ir.OCALL {
 			call := m.(*ir.CallExpr)
-			if call.X.Op() != ir.OCALLPART {
-				base.FatalfAt(call.Pos(), "Expecting OXDOT with CALL")
+			if call.X.Op() == ir.OTYPE {
+				// Do typechecking on a conversion, now that we
+				// know the type argument.
+				m.SetTypecheck(0)
+				m = typecheck.Expr(m)
+			} else if call.X.Op() == ir.OCALLPART {
+				// Redo the typechecking, now that we know the method
+				// value is being called.
+				call.X.(*ir.SelectorExpr).SetOp(ir.OXDOT)
+				call.X.SetTypecheck(0)
+				call.X.SetType(nil)
+				typecheck.Callee(call.X)
+				m.SetTypecheck(0)
+				typecheck.Call(m.(*ir.CallExpr))
+			} else {
+				base.FatalfAt(call.Pos(), "Expecting OCALLPART or OTYPE with CALL")
 			}
-			// Redo the typechecking, now that we know the method
-			// value is being called
-			call.X.(*ir.SelectorExpr).SetOp(ir.OXDOT)
-			call.X.SetTypecheck(0)
-			call.X.SetType(nil)
-			typecheck.Callee(call.X)
-			m.SetTypecheck(0)
-			typecheck.Call(m.(*ir.CallExpr))
 		}
 
 		if x.Op() == ir.OCLOSURE {
diff --git a/test/typeparam/fact.go b/test/typeparam/fact.go
index 8ed9bce7d8..16b2adf6fb 100644
--- a/test/typeparam/fact.go
+++ b/test/typeparam/fact.go
@@ -8,20 +8,15 @@ package main
 
 import "fmt"
 
-// TODO Stenciling doesn't do the right thing for T(1) at the moment.
-
 func fact[T interface { type int, int64, float64 }](n T) T {
-	// TODO remove this return in favor of the correct computation below
-	return n
-	// if n == T(1) {
-	// 	return T(1)
-	// }
-	// return n * fact(n - T(1))
+	if n == T(1) {
+		return T(1)
+	}
+	return n * fact(n - T(1))
 }
 
 func main() {
-	// TODO change this to 120 once we can compile the function body above
-	const want = 5 // 120
+	const want = 120
 
 	if got := fact(5); got != want {
 		panic(fmt.Sprintf("got %d, want %d", got, want))
-- 
GitLab


From 59703d53e249db738363c3fab9143348ff9559ea Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Fri, 5 Feb 2021 18:07:46 -0500
Subject: [PATCH 0626/2400] [dev.regabi] cmd/link: stop using ABI aliases if
 wrapper is enabled

If ABI wrappers are enabled, we should not see ABI aliases at
link time. Stop resolving them. One exception is shared linkage,
where we still use ABI aliases as we don't always know the ABI
for symbols from shared libraries.

Change-Id: Ia89a788094382adeb4c4ef9b0312aa6e8c2f79ef
Reviewed-on: https://go-review.googlesource.com/c/go/+/290032
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/link/internal/ld/lib.go        | 8 +++++++-
 src/cmd/link/internal/loader/loader.go | 4 ++++
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index 71cef0b774..314896824a 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -489,10 +489,16 @@ func (ctxt *Link) loadlib() {
 	case 0:
 		// nothing to do
 	case 1, 2:
-		flags = loader.FlagStrictDups
+		flags |= loader.FlagStrictDups
 	default:
 		log.Fatalf("invalid -strictdups flag value %d", *FlagStrictDups)
 	}
+	if !*flagAbiWrap || ctxt.linkShared {
+		// Use ABI aliases if ABI wrappers are not used.
+		// TODO: for now we still use ABI aliases in shared linkage, even if
+		// the wrapper is enabled.
+		flags |= loader.FlagUseABIAlias
+	}
 	elfsetstring1 := func(str string, off int) { elfsetstring(ctxt, 0, str, off) }
 	ctxt.loader = loader.NewLoader(flags, elfsetstring1, &ctxt.ErrorReporter.ErrorReporter)
 	ctxt.ErrorReporter.SymName = func(s loader.Sym) string {
diff --git a/src/cmd/link/internal/loader/loader.go b/src/cmd/link/internal/loader/loader.go
index 971cc432ff..98c2131c2b 100644
--- a/src/cmd/link/internal/loader/loader.go
+++ b/src/cmd/link/internal/loader/loader.go
@@ -322,6 +322,7 @@ type extSymPayload struct {
 const (
 	// Loader.flags
 	FlagStrictDups = 1 << iota
+	FlagUseABIAlias
 )
 
 func NewLoader(flags uint32, elfsetstring elfsetstringFunc, reporter *ErrorReporter) *Loader {
@@ -2270,6 +2271,9 @@ func abiToVer(abi uint16, localSymVersion int) int {
 // symbol. If the sym in question is not an alias, the sym itself is
 // returned.
 func (l *Loader) ResolveABIAlias(s Sym) Sym {
+	if l.flags&FlagUseABIAlias == 0 {
+		return s
+	}
 	if s == 0 {
 		return 0
 	}
-- 
GitLab


From ddec18cf827f3e21868892e1b4df48281314d69a Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 10 Feb 2021 12:32:59 -0800
Subject: [PATCH 0627/2400] [dev.typeparams] cmd/compile/internal/types2:
 overlapping embedded interfaces requires go1.14

Add respective check to type checker.
Enables another excluded test in test/run.go.

This CL completes the currently required checks for
language compatibility in types2.

Updates #31793.

Change-Id: Icececff9e6023d38f600c93bcb54cdcafcf501b9
Reviewed-on: https://go-review.googlesource.com/c/go/+/290911
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 .../compile/internal/types2/stdlib_test.go    |  1 -
 .../internal/types2/testdata/go1_13.src       | 21 +++++++++++++++++++
 src/cmd/compile/internal/types2/typexpr.go    |  8 +++++--
 test/run.go                                   |  1 -
 4 files changed, 27 insertions(+), 4 deletions(-)
 create mode 100644 src/cmd/compile/internal/types2/testdata/go1_13.src

diff --git a/src/cmd/compile/internal/types2/stdlib_test.go b/src/cmd/compile/internal/types2/stdlib_test.go
index 2949e23019..0477e54998 100644
--- a/src/cmd/compile/internal/types2/stdlib_test.go
+++ b/src/cmd/compile/internal/types2/stdlib_test.go
@@ -192,7 +192,6 @@ func TestStdFixed(t *testing.T) {
 		"issue22200b.go", // go/types does not have constraints on stack size
 		"issue25507.go",  // go/types does not have constraints on stack size
 		"issue20780.go",  // go/types does not have constraints on stack size
-		"issue34329.go",  // go/types does not have constraints on language level (-lang=go1.13) (see #31793)
 		"issue42058a.go", // go/types does not have constraints on channel element size
 		"issue42058b.go", // go/types does not have constraints on channel element size
 		"bug251.go",      // issue #34333 which was exposed with fix for #34151
diff --git a/src/cmd/compile/internal/types2/testdata/go1_13.src b/src/cmd/compile/internal/types2/testdata/go1_13.src
new file mode 100644
index 0000000000..93cb4c72a7
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/go1_13.src
@@ -0,0 +1,21 @@
+// Copyright 2021 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.
+
+// Check Go language version-specific errors.
+
+package go1_13 // go1.13
+
+// interface embedding
+
+type I interface { m() }
+
+type _ interface {
+	m()
+	I // ERROR "duplicate method m"
+}
+
+type _ interface {
+	I
+	I // ERROR "duplicate method m"
+}
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index b758c0f358..b67a35ed30 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -943,9 +943,13 @@ func (check *Checker) completeInterface(pos syntax.Pos, ityp *Interface) {
 			check.errorf(pos, "duplicate method %s", m.name)
 			check.errorf(mpos[other.(*Func)], "\tother declaration of %s", m.name) // secondary error, \t indented
 		default:
-			// check method signatures after all types are computed (issue #33656)
+			// We have a duplicate method name in an embedded (not explicitly declared) method.
+			// Check method signatures after all types are computed (issue #33656).
+			// If we're pre-go1.14 (overlapping embeddings are not permitted), report that
+			// error here as well (even though we could do it eagerly) because it's the same
+			// error message.
 			check.atEnd(func() {
-				if !check.identical(m.typ, other.Type()) {
+				if !check.allowVersion(m.pkg, 1, 14) || !check.identical(m.typ, other.Type()) {
 					check.errorf(pos, "duplicate method %s", m.name)
 					check.errorf(mpos[other.(*Func)], "\tother declaration of %s", m.name) // secondary error, \t indented
 				}
diff --git a/test/run.go b/test/run.go
index b1d6fe2414..3ff5d9c1e0 100644
--- a/test/run.go
+++ b/test/run.go
@@ -1964,7 +1964,6 @@ var excluded = map[string]bool{
 	"fixedbugs/issue28079b.go": true, // types2 reports follow-on errors
 	"fixedbugs/issue28268.go":  true, // types2 reports follow-on errors
 	"fixedbugs/issue33460.go":  true, // types2 reports alternative positions in separate error
-	"fixedbugs/issue34329.go":  true, // types2 is missing support for -lang flag
 	"fixedbugs/issue41575.go":  true, // types2 reports alternative positions in separate error
 	"fixedbugs/issue42058a.go": true, // types2 doesn't report "channel element type too large"
 	"fixedbugs/issue42058b.go": true, // types2 doesn't report "channel element type too large"
-- 
GitLab


From df23540ddef33f47faf7bba2a6fc37c44a662ab0 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 10 Feb 2021 17:41:26 -0500
Subject: [PATCH 0628/2400] [dev.typeparams] cmd/gofmt: add the -G flag to
 allow generic code

Add support for type parameters to cmd/gofmt, gated behind the -G flag.

The test was based on a test from go/printer, slightly modified to
exercise more formatting.

Change-Id: I489bcb3ad06e1ed4e6d9f5bc79825e60dcfe9953
Reviewed-on: https://go-review.googlesource.com/c/go/+/291011
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/gofmt/doc.go                     |  3 ++
 src/cmd/gofmt/gofmt.go                   | 16 +++++++----
 src/cmd/gofmt/gofmt_test.go              |  2 ++
 src/cmd/gofmt/testdata/typeparams.golden | 35 ++++++++++++++++++++++++
 src/cmd/gofmt/testdata/typeparams.input  | 32 ++++++++++++++++++++++
 5 files changed, 82 insertions(+), 6 deletions(-)
 create mode 100644 src/cmd/gofmt/testdata/typeparams.golden
 create mode 100644 src/cmd/gofmt/testdata/typeparams.input

diff --git a/src/cmd/gofmt/doc.go b/src/cmd/gofmt/doc.go
index e340665594..68476e7d44 100644
--- a/src/cmd/gofmt/doc.go
+++ b/src/cmd/gofmt/doc.go
@@ -26,6 +26,9 @@ The flags are:
 		Do not print reformatted sources to standard output.
 		If a file's formatting is different from gofmt's, print its name
 		to standard output.
+	-G
+		Allow generic code, using type parameters.
+		See golang.org/issues/43651 for more information.
 	-r rule
 		Apply the rewrite rule to the source before reformatting.
 	-s
diff --git a/src/cmd/gofmt/gofmt.go b/src/cmd/gofmt/gofmt.go
index 2793c2c2a4..b82aa7e7a9 100644
--- a/src/cmd/gofmt/gofmt.go
+++ b/src/cmd/gofmt/gofmt.go
@@ -26,12 +26,13 @@ import (
 
 var (
 	// main operation modes
-	list        = flag.Bool("l", false, "list files whose formatting differs from gofmt's")
-	write       = flag.Bool("w", false, "write result to (source) file instead of stdout")
-	rewriteRule = flag.String("r", "", "rewrite rule (e.g., 'a[b:len(a)] -> a[b:]')")
-	simplifyAST = flag.Bool("s", false, "simplify code")
-	doDiff      = flag.Bool("d", false, "display diffs instead of rewriting files")
-	allErrors   = flag.Bool("e", false, "report all errors (not just the first 10 on different lines)")
+	list            = flag.Bool("l", false, "list files whose formatting differs from gofmt's")
+	write           = flag.Bool("w", false, "write result to (source) file instead of stdout")
+	rewriteRule     = flag.String("r", "", "rewrite rule (e.g., 'a[b:len(a)] -> a[b:]')")
+	simplifyAST     = flag.Bool("s", false, "simplify code")
+	doDiff          = flag.Bool("d", false, "display diffs instead of rewriting files")
+	allErrors       = flag.Bool("e", false, "report all errors (not just the first 10 on different lines)")
+	allowTypeParams = flag.Bool("G", false, "allow generic code")
 
 	// debugging
 	cpuprofile = flag.String("cpuprofile", "", "write cpu profile to this file")
@@ -71,6 +72,9 @@ func initParserMode() {
 	if *allErrors {
 		parserMode |= parser.AllErrors
 	}
+	if *allowTypeParams {
+		parserMode |= parser.ParseTypeParams
+	}
 }
 
 func isGoFile(f fs.DirEntry) bool {
diff --git a/src/cmd/gofmt/gofmt_test.go b/src/cmd/gofmt/gofmt_test.go
index bf2adfe64c..60e4f2e03d 100644
--- a/src/cmd/gofmt/gofmt_test.go
+++ b/src/cmd/gofmt/gofmt_test.go
@@ -77,6 +77,8 @@ func runTest(t *testing.T, in, out string) {
 		case "-stdin":
 			// fake flag - pretend input is from stdin
 			stdin = true
+		case "-G":
+			*allowTypeParams = true
 		default:
 			t.Errorf("unrecognized flag name: %s", name)
 		}
diff --git a/src/cmd/gofmt/testdata/typeparams.golden b/src/cmd/gofmt/testdata/typeparams.golden
new file mode 100644
index 0000000000..35f08d1379
--- /dev/null
+++ b/src/cmd/gofmt/testdata/typeparams.golden
@@ -0,0 +1,35 @@
+// Copyright 2020 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.
+
+//gofmt -G
+
+package typeparams
+
+type T[P any] struct{}
+type T[P1, P2, P3 any] struct{}
+
+type T[P C] struct{}
+type T[P1, P2, P3 C] struct{}
+
+type T[P C[P]] struct{}
+type T[P1, P2, P3 C[P1, P2, P3]] struct{}
+
+func f[P any](x P)
+func f[P1, P2, P3 any](x1 P1, x2 P2, x3 P3) struct{}
+
+func f[P interface{}](x P)
+func f[P1, P2, P3 interface {
+	m1(P1)
+	type P2, P3
+}](x1 P1, x2 P2, x3 P3) struct{}
+func f[P any](T1[P], T2[P]) T3[P]
+
+func (x T[P]) m()
+func (T[P]) m(x T[P]) P
+
+func _() {
+	type _ []T[P]
+	var _ []T[P]
+	_ = []T[P]{}
+}
diff --git a/src/cmd/gofmt/testdata/typeparams.input b/src/cmd/gofmt/testdata/typeparams.input
new file mode 100644
index 0000000000..7f3212c8e4
--- /dev/null
+++ b/src/cmd/gofmt/testdata/typeparams.input
@@ -0,0 +1,32 @@
+// Copyright 2020 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.
+
+//gofmt -G
+
+package typeparams
+
+type T[  P any] struct{}
+type T[P1, P2, P3 any] struct{}
+
+type T[P C] struct{}
+type T[P1,P2, P3 C] struct{}
+
+type T[P C[P]] struct{}
+type T[P1, P2, P3 C[P1,P2,P3]] struct{}
+
+func f[P any](x P)
+func f[P1, P2, P3 any](x1 P1, x2 P2, x3 P3) struct{}
+
+func f[P interface{}](x P)
+func f[P1, P2, P3 interface{ m1(P1); type P2, P3 }](x1 P1, x2 P2, x3 P3) struct{}
+func f[P any](T1[P], T2[P]) T3[P]
+
+func (x T[P]) m()
+func ((T[P])) m(x T[P]) P
+
+func _() {
+	type _ []T[P]
+	var _ []T[P]
+	_ = []T[P]{}
+}
-- 
GitLab


From c0aa7bd7602257dd7d5be4db13dd10284bd5f826 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Wed, 10 Feb 2021 15:26:40 -0800
Subject: [PATCH 0629/2400] [dev.typeparams] cmd/compile: small fixes for
 stenciling

 - Create the stencil name using targ.Type.String(), which handles cases
   where, for example, a type argument is a pointer to a named type,
   etc. *obj.

 - Set name.Def properly for a new stenciled func (have the symbol point
   back to the associated function node).  Will be required when exporting.

 - Add missing copying of Func field when making copies of Name nodes.
   (On purpose (it seems), Name nodes don't have a copy() function, so
   we have to copy all the needed fields explicitly.)

 - Deal with nil type in subster.node(), which is the type of the return
   value for a function that doesn't return anything.

 - Fix min to match standard want/go form, and add in float tests.  Changed
   Got -> got in bunch of other typeparam tests.

 - Add new tests index.go, settable.go, and smallest.go (similar to
   examples in the type param proposal), some of which need the above
   changes.

Change-Id: I09a72302bc1fd3635a326da92405222afa222e85
Reviewed-on: https://go-review.googlesource.com/c/go/+/291109
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/stencil.go | 16 +++++++-
 test/typeparam/index.go                   | 46 +++++++++++++++++++++++
 test/typeparam/map.go                     |  4 +-
 test/typeparam/min.go                     | 25 ++++++++----
 test/typeparam/settable.go                | 38 +++++++++++++++++++
 test/typeparam/smallest.go                | 42 +++++++++++++++++++++
 test/typeparam/stringer.go                |  6 +--
 test/typeparam/sum.go                     |  8 ++--
 8 files changed, 166 insertions(+), 19 deletions(-)
 create mode 100644 test/typeparam/index.go
 create mode 100644 test/typeparam/settable.go
 create mode 100644 test/typeparam/smallest.go

diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 2995496da1..74ea2e0927 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -80,7 +80,7 @@ func makeInstName(inst *ir.InstExpr) *types.Sym {
 		if i > 0 {
 			b.WriteString(",")
 		}
-		b.WriteString(targ.Name().Sym().Name)
+		b.WriteString(targ.Type().String())
 	}
 	b.WriteString("]")
 	return typecheck.Lookup(b.String())
@@ -107,6 +107,7 @@ func genericSubst(name *types.Sym, inst *ir.InstExpr) *ir.Func {
 	newf.Nname = ir.NewNameAt(inst.Pos(), name)
 	newf.Nname.Func = newf
 	newf.Nname.Defn = newf
+	name.Def = newf.Nname
 
 	subst := &subster{
 		newf:    newf,
@@ -160,6 +161,7 @@ func (subst *subster) node(n ir.Node) ir.Node {
 			m.SetType(newt)
 			m.Curfn = subst.newf
 			m.Class = name.Class
+			m.Func = name.Func
 			subst.vars[name] = m
 			m.SetTypecheck(1)
 			return m
@@ -170,7 +172,17 @@ func (subst *subster) node(n ir.Node) ir.Node {
 		}
 		m := ir.Copy(x)
 		if _, isExpr := m.(ir.Expr); isExpr {
-			m.SetType(subst.typ(x.Type()))
+			t := x.Type()
+			if t == nil {
+				// t can be nil only if this is a call that has no
+				// return values, so allow that and otherwise give
+				// an error.
+				if _, isCallExpr := m.(*ir.CallExpr); !isCallExpr {
+					base.Fatalf(fmt.Sprintf("Nil type for %v", x))
+				}
+			} else {
+				m.SetType(subst.typ(x.Type()))
+			}
 		}
 		ir.EditChildren(m, edit)
 
diff --git a/test/typeparam/index.go b/test/typeparam/index.go
new file mode 100644
index 0000000000..83e65acdd0
--- /dev/null
+++ b/test/typeparam/index.go
@@ -0,0 +1,46 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 (
+	"fmt"
+)
+
+// Index returns the index of x in s, or -1 if not found.
+func index[T comparable](s []T, x T) int {
+	for i, v := range s {
+		// v and x are type T, which has the comparable
+		// constraint, so we can use == here.
+		if v == x {
+			return i
+		}
+	}
+	return -1
+}
+
+type obj struct {
+	x int
+}
+
+func main() {
+	want := 2
+
+	vec1 := []string{"ab", "cd", "ef"}
+	if got := index(vec1, "ef"); got != want {
+		panic(fmt.Sprintf("got %d, want %d", got, want))
+	}
+
+	vec2 := []byte{'c', '6', '@'}
+	if got := index(vec2, '@'); got != want {
+		panic(fmt.Sprintf("got %d, want %d", got, want))
+	}
+
+	vec3 := []*obj{&obj{2}, &obj{42}, &obj{1}}
+	if got := index(vec3, vec3[2]); got != want {
+		panic(fmt.Sprintf("got %d, want %d", got, want))
+	}
+}
diff --git a/test/typeparam/map.go b/test/typeparam/map.go
index 720a52ffbd..72d05f0872 100644
--- a/test/typeparam/map.go
+++ b/test/typeparam/map.go
@@ -26,7 +26,7 @@ func main() {
 	got := mapper([]int{1, 2, 3}, strconv.Itoa)
 	want := []string{"1", "2", "3"}
 	if !reflect.DeepEqual(got, want) {
-		panic(fmt.Sprintf("Got %s, want %s", got, want))
+		panic(fmt.Sprintf("got %s, want %s", got, want))
 	}
 
 	fgot := mapper([]float64{2.5, 2.3, 3.5}, func(f float64) string {
@@ -34,6 +34,6 @@ func main() {
 	})
 	fwant := []string{"2.5", "2.3", "3.5"}
 	if !reflect.DeepEqual(fgot, fwant) {
-		panic(fmt.Sprintf("Got %s, want %s", fgot, fwant))
+		panic(fmt.Sprintf("got %s, want %s", fgot, fwant))
 	}
 }
diff --git a/test/typeparam/min.go b/test/typeparam/min.go
index 3bd92c5f3e..a3e4464a30 100644
--- a/test/typeparam/min.go
+++ b/test/typeparam/min.go
@@ -10,8 +10,11 @@ import (
 	"fmt"
 )
 
+type Ordered interface {
+	type int, int64, float64
+}
 
-func min[T interface{ type int }](x, y T) T {
+func min[T Ordered](x, y T) T {
 	if x < y {
 		return x
 	}
@@ -19,14 +22,20 @@ func min[T interface{ type int }](x, y T) T {
 }
 
 func main() {
-	want := 2
-	got := min[int](2, 3)
-	if want != got {
-		panic(fmt.Sprintf("Want %d, got %d", want, got))
+	const want = 2
+	if got := min[int](2, 3); got != want {
+		panic(fmt.Sprintf("got %d, want %d", got, want))
+	}
+
+	if got := min(2, 3); got != want {
+		panic(fmt.Sprintf("want %d, got %d", want, got))
+	}
+
+	if got := min[float64](3.5, 2.0); got != want {
+		panic(fmt.Sprintf("got %d, want %d", got, want))
 	}
 
-	got = min(2, 3)
-	if want != got {
-		panic(fmt.Sprintf("Want %d, got %d", want, got))
+	if got := min(3.5, 2.0); got != want {
+		panic(fmt.Sprintf("got %d, want %d", got, want))
 	}
 }
diff --git a/test/typeparam/settable.go b/test/typeparam/settable.go
new file mode 100644
index 0000000000..3bd141f784
--- /dev/null
+++ b/test/typeparam/settable.go
@@ -0,0 +1,38 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 (
+	"fmt"
+	"strconv"
+)
+
+func fromStrings3[T any](s []string, set func(*T, string)) []T {
+        results := make([]T, len(s))
+        for i, v := range s {
+                set(&results[i], v)
+        }
+        return results
+}
+
+type Settable int
+
+func (p *Settable) Set(s string) {
+        i, err := strconv.Atoi(s)
+        if err != nil {
+                panic(err)
+        }
+        *p = Settable(i)
+}
+
+func main() {
+        s := fromStrings3([]string{"1"},
+                func(p *Settable, s string) { p.Set(s) })
+        if len(s) != 1 || s[0] != 1 {
+                panic(fmt.Sprintf("got %v, want %v", s, []int{1}))
+        }
+}
diff --git a/test/typeparam/smallest.go b/test/typeparam/smallest.go
new file mode 100644
index 0000000000..63dd9ddb70
--- /dev/null
+++ b/test/typeparam/smallest.go
@@ -0,0 +1,42 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 (
+	"fmt"
+)
+
+type Ordered interface {
+	type int, int8, int16, int32, int64,
+		uint, uint8, uint16, uint32, uint64, uintptr,
+		float32, float64,
+		string
+}
+
+func smallest[T Ordered](s []T) T {
+	r := s[0] // panics if slice is empty
+	for _, v := range s[1:] {
+		if v < r {
+			r = v
+		}
+	}
+	return r
+}
+
+func main() {
+	vec1 := []float64{5.3, 1.2, 32.8}
+	vec2 := []string{"abc", "def", "aaa"}
+
+	want1 := 1.2
+	if got := smallest(vec1); got != want1 {
+		panic(fmt.Sprintf("got %d, want %d", got, want1))
+	}
+	want2 := "aaa"
+	if got := smallest(vec2); got != want2 {
+		panic(fmt.Sprintf("got %d, want %d", got, want2))
+	}
+}
diff --git a/test/typeparam/stringer.go b/test/typeparam/stringer.go
index 5086ac72f8..81290d599e 100644
--- a/test/typeparam/stringer.go
+++ b/test/typeparam/stringer.go
@@ -73,16 +73,16 @@ func main() {
 	got := stringify(x)
 	want := []string{"1", "2", "3"}
 	if !reflect.DeepEqual(got, want) {
-		panic(fmt.Sprintf("Got %s, want %s", got, want))
+		panic(fmt.Sprintf("got %s, want %s", got, want))
 	}
 
 	got = stringify2(x)
 	if !reflect.DeepEqual(got, want) {
-		panic(fmt.Sprintf("Got %s, want %s", got, want))
+		panic(fmt.Sprintf("got %s, want %s", got, want))
 	}
 
 	got = stringify3(x)
 	if !reflect.DeepEqual(got, want) {
-		panic(fmt.Sprintf("Got %s, want %s", got, want))
+		panic(fmt.Sprintf("got %s, want %s", got, want))
 	}
 }
diff --git a/test/typeparam/sum.go b/test/typeparam/sum.go
index 72511c2fe5..f0f5e6aa07 100644
--- a/test/typeparam/sum.go
+++ b/test/typeparam/sum.go
@@ -31,20 +31,20 @@ func main() {
 	got := sum[int](vec1)
 	want := vec1[0] + vec1[1]
 	if got != want {
-		panic(fmt.Sprintf("Got %d, want %d", got, want))
+		panic(fmt.Sprintf("got %d, want %d", got, want))
 	}
 	got = sum(vec1)
 	if want != got {
-		panic(fmt.Sprintf("Got %d, want %d", got, want))
+		panic(fmt.Sprintf("got %d, want %d", got, want))
 	}
 
 	fwant := vec2[0] + vec2[1]
 	fgot := sum[float64](vec2)
 	if abs(fgot - fwant) > 1e-10 {
-		panic(fmt.Sprintf("Got %f, want %f", fgot, fwant))
+		panic(fmt.Sprintf("got %f, want %f", fgot, fwant))
 	}
 	fgot = sum(vec2)
 	if abs(fgot - fwant) > 1e-10 {
-		panic(fmt.Sprintf("Got %f, want %f", fgot, fwant))
+		panic(fmt.Sprintf("got %f, want %f", fgot, fwant))
 	}
 }
-- 
GitLab


From 58758e0a21c4309f96d44ba24e4c2c9cc12732d9 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 11 Feb 2021 11:46:24 -0500
Subject: [PATCH 0630/2400] [dev.typeparams] go/types: better error message for
 invalid ... use

This is a port of CL 283475 to go/types.

For #43680

Change-Id: Ida630651247a40e28d405594394476e346354866
Reviewed-on: https://go-review.googlesource.com/c/go/+/291321
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/examples/types.go2 | 3 +++
 src/go/types/typexpr.go         | 6 ++++++
 2 files changed, 9 insertions(+)

diff --git a/src/go/types/examples/types.go2 b/src/go/types/examples/types.go2
index 5aa624c131..4dba4f0e57 100644
--- a/src/go/types/examples/types.go2
+++ b/src/go/types/examples/types.go2
@@ -112,6 +112,9 @@ type I1[T any] interface{
 	m1(T)
 }
 
+// There is no such thing as a variadic generic type.
+type _[T ... /* ERROR invalid use of ... */ interface{}] struct{}
+
 // Generic interfaces may be embedded as one would expect.
 type I2 interface {
 	I1(int)     // method!
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index a6b7314dd5..bca0a6664f 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -488,6 +488,12 @@ func (check *Checker) typInternal(e0 ast.Expr, def *Named) (T Type) {
 		typ.elem = check.varType(e.Elt)
 		return typ
 
+	case *ast.Ellipsis:
+		// dots are handled explicitly where they are legal
+		// (array composite literals and parameter lists)
+		check.error(e, _InvalidDotDotDot, "invalid use of '...'")
+		check.use(e.Elt)
+
 	case *ast.StructType:
 		typ := new(Struct)
 		def.setUnderlying(typ)
-- 
GitLab


From 0f43973b4bffcc6593bb0b847cf583f697000134 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 11 Feb 2021 11:50:31 -0500
Subject: [PATCH 0631/2400] [dev.typeparams] go/types: make predeclared "any"
 alias for interface{}

This is a direct port of CL 285132 to go/types.

Change-Id: I35486d8ea1fa6c0c6a32ece199a6ccfd55d44d29
Reviewed-on: https://go-review.googlesource.com/c/go/+/291322
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/api_test.go | 6 +++---
 src/go/types/universe.go | 9 +++------
 2 files changed, 6 insertions(+), 9 deletions(-)

diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go
index 3ea14c9316..eca11358ef 100644
--- a/src/go/types/api_test.go
+++ b/src/go/types/api_test.go
@@ -325,14 +325,14 @@ func TestTypesInfo(t *testing.T) {
 		{broken + `x5; func _() { var x map[string][...]int; x = map[string][...]int{"": {1,2,3}} }`, `x`, `map[string][-1]int`},
 
 		// parameterized functions
-		{genericPkg + `p0; func f[T any](T); var _ = f(int)`, `f`, `func[T₁ any](T₁)`},
+		{genericPkg + `p0; func f[T any](T); var _ = f(int)`, `f`, `func[T₁ interface{}](T₁)`},
 		{genericPkg + `p1; func f[T any](T); var _ = f(int)`, `f(int)`, `func(int)`},
-		{genericPkg + `p2; func f[T any](T); func _() { f(42) }`, `f`, `func[T₁ any](T₁)`},
+		{genericPkg + `p2; func f[T any](T); func _() { f(42) }`, `f`, `func[T₁ interface{}](T₁)`},
 		{genericPkg + `p3; func f[T any](T); func _() { f(42) }`, `f(42)`, `()`},
 
 		// type parameters
 		{genericPkg + `t0; type t[] int; var _ t`, `t`, `generic_t0.t`}, // t[] is a syntax error that is ignored in this test in favor of t
-		{genericPkg + `t1; type t[P any] int; var _ t[int]`, `t`, `generic_t1.t[P₁ any]`},
+		{genericPkg + `t1; type t[P any] int; var _ t[int]`, `t`, `generic_t1.t[P₁ interface{}]`},
 		{genericPkg + `t2; type t[P interface{}] int; var _ t[int]`, `t`, `generic_t2.t[P₁ interface{}]`},
 		{genericPkg + `t3; type t[P, Q interface{}] int; var _ t[int, int]`, `t`, `generic_t3.t[P₁, Q₂ interface{}]`},
 
diff --git a/src/go/types/universe.go b/src/go/types/universe.go
index f2f444fd9d..4ced018f8e 100644
--- a/src/go/types/universe.go
+++ b/src/go/types/universe.go
@@ -24,7 +24,7 @@ var (
 	universeIota  *Const
 	universeByte  *Basic // uint8 alias, but has name "byte"
 	universeRune  *Basic // int32 alias, but has name "rune"
-	universeAny   *Named
+	universeAny   *Interface
 	universeError *Named
 )
 
@@ -82,10 +82,7 @@ func defPredeclaredTypes() {
 	// (Predeclared and entered into universe scope so we do all the
 	// usual checks; but removed again from scope later since it's
 	// only visible as constraint in a type parameter list.)
-	{
-		typ := &Named{underlying: &emptyInterface}
-		def(NewTypeName(token.NoPos, nil, "any", typ))
-	}
+	def(NewTypeName(token.NoPos, nil, "any", &emptyInterface))
 
 	// Error has a nil package in its qualified name since it is in no package
 	{
@@ -241,7 +238,7 @@ func init() {
 	universeIota = Universe.Lookup("iota").(*Const)
 	universeByte = Universe.Lookup("byte").(*TypeName).typ.(*Basic)
 	universeRune = Universe.Lookup("rune").(*TypeName).typ.(*Basic)
-	universeAny = Universe.Lookup("any").(*TypeName).typ.(*Named)
+	universeAny = Universe.Lookup("any").(*TypeName).typ.(*Interface)
 	universeError = Universe.Lookup("error").(*TypeName).typ.(*Named)
 
 	// "any" is only visible as constraint in a type parameter list
-- 
GitLab


From baa6c75dcef23aa51e95bf7818b7ded5262fbaa8 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Thu, 22 Oct 2020 16:02:14 +0000
Subject: [PATCH 0632/2400] [dev.regabi] internal/abi: add new internal/abi
 package for ABI constants

This change creates a new internal std package internal/abi which is
intended to hold constants with platform-specific values related to
our ABI that is useful to different std packages, such as runtime and
reflect.

For #40724.

Change-Id: Ie7ae7f687629cd3d613ba603e9371f0887601fe6
Reviewed-on: https://go-review.googlesource.com/c/go/+/272567
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Austin Clements <austin@google.com>
---
 src/go/build/deps_test.go       |  4 ++--
 src/internal/abi/abi.go         | 12 +++++++++++
 src/internal/abi/abi_amd64.go   | 20 +++++++++++++++++
 src/internal/abi/abi_generic.go | 38 +++++++++++++++++++++++++++++++++
 4 files changed, 72 insertions(+), 2 deletions(-)
 create mode 100644 src/internal/abi/abi.go
 create mode 100644 src/internal/abi/abi_amd64.go
 create mode 100644 src/internal/abi/abi_generic.go

diff --git a/src/go/build/deps_test.go b/src/go/build/deps_test.go
index c97c668cc4..02b29f498a 100644
--- a/src/go/build/deps_test.go
+++ b/src/go/build/deps_test.go
@@ -71,13 +71,13 @@ var depsRules = `
 	# No dependencies allowed for any of these packages.
 	NONE
 	< container/list, container/ring,
-	  internal/cfg, internal/cpu,
+	  internal/abi, internal/cfg, internal/cpu,
 	  internal/goversion, internal/nettrace,
 	  unicode/utf8, unicode/utf16, unicode,
 	  unsafe;
 
 	# RUNTIME is the core runtime group of packages, all of them very light-weight.
-	internal/cpu, unsafe
+	internal/abi, internal/cpu, unsafe
 	< internal/bytealg
 	< internal/unsafeheader
 	< runtime/internal/sys
diff --git a/src/internal/abi/abi.go b/src/internal/abi/abi.go
new file mode 100644
index 0000000000..07ea51df8f
--- /dev/null
+++ b/src/internal/abi/abi.go
@@ -0,0 +1,12 @@
+// Copyright 2020 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 abi
+
+// RegArgs is a struct that has space for each argument
+// and return value register on the current architecture.
+type RegArgs struct {
+	Ints   [IntArgRegs]uintptr
+	Floats [FloatArgRegs]uint64
+}
diff --git a/src/internal/abi/abi_amd64.go b/src/internal/abi/abi_amd64.go
new file mode 100644
index 0000000000..6574d4216d
--- /dev/null
+++ b/src/internal/abi/abi_amd64.go
@@ -0,0 +1,20 @@
+// Copyright 2020 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.
+
+// +build goexperiment.regabi
+
+package abi
+
+const (
+	// See abi_generic.go.
+
+	// RAX, RBX, RCX, RDI, RSI, R8, R9, R10, R11.
+	IntArgRegs = 9
+
+	// X0 -> X14.
+	FloatArgRegs = 15
+
+	// We use SSE2 registers which support 64-bit float operations.
+	EffectiveFloatRegSize = 8
+)
diff --git a/src/internal/abi/abi_generic.go b/src/internal/abi/abi_generic.go
new file mode 100644
index 0000000000..5ef9883dc6
--- /dev/null
+++ b/src/internal/abi/abi_generic.go
@@ -0,0 +1,38 @@
+// Copyright 2020 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.
+
+// +build !goexperiment.regabi
+
+package abi
+
+const (
+	// ABI-related constants.
+	//
+	// In the generic case, these are all zero
+	// which lets them gracefully degrade to ABI0.
+
+	// IntArgRegs is the number of registers dedicated
+	// to passing integer argument values. Result registers are identical
+	// to argument registers, so this number is used for those too.
+	IntArgRegs = 0
+
+	// FloatArgRegs is the number of registers dedicated
+	// to passing floating-point argument values. Result registers are
+	// identical to argument registers, so this number is used for
+	// those too.
+	FloatArgRegs = 0
+
+	// EffectiveFloatRegSize describes the width of floating point
+	// registers on the current platform from the ABI's perspective.
+	//
+	// Since Go only supports 32-bit and 64-bit floating point primitives,
+	// this number should be either 0, 4, or 8. 0 indicates no floating
+	// point registers for the ABI or that floating point values will be
+	// passed via the softfloat ABI.
+	//
+	// For platforms that support larger floating point register widths,
+	// such as x87's 80-bit "registers" (not that we support x87 currently),
+	// use 8.
+	EffectiveFloatRegSize = 0
+)
-- 
GitLab


From f1777cf84c5406fc25e1a0c194775e4fe96f34f2 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 10 Feb 2021 17:06:33 -0800
Subject: [PATCH 0633/2400] [dev.typeparams] cmd/compile/internal/types: review
 of builtin.go

The changes between (equivalent, and reviewed) go/types/builtin.go
and builtin.go can be seen by comparing patchset 1 and 2. The actual
change is just removing the "// UNREVIEWED" marker.

Change-Id: Ibecf2b5bc982f6bf92310267b9f06b588b7148a9
Reviewed-on: https://go-review.googlesource.com/c/go/+/291169
Reviewed-by: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/types2/builtins.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go
index bd1ea0fdc1..591a22f814 100644
--- a/src/cmd/compile/internal/types2/builtins.go
+++ b/src/cmd/compile/internal/types2/builtins.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2012 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.
-- 
GitLab


From 9168590977fca7a8d86b27b6c39fff0cd5efb8a4 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 10 Feb 2021 17:17:45 -0800
Subject: [PATCH 0634/2400] [dev.typeparams] cmd/compile/internal/types: review
 of builtin_test.go

The changes between (equivalent, and reviewed) go/types/builtin_test.go
and builtin_test.go can be seen by comparing patchset 1 and 2. The actual
change is just removing the "// UNREVIEWED" marker.

Change-Id: Ic40d1a9b2f1465c5335bd69e9a0b265ab694c3ef
Reviewed-on: https://go-review.googlesource.com/c/go/+/291170
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/builtins_test.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/builtins_test.go b/src/cmd/compile/internal/types2/builtins_test.go
index 35c38518f6..780d0a15a7 100644
--- a/src/cmd/compile/internal/types2/builtins_test.go
+++ b/src/cmd/compile/internal/types2/builtins_test.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2013 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.
-- 
GitLab


From bab3461123060804628744a82e8ba03c51c27564 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 10 Feb 2021 17:21:23 -0800
Subject: [PATCH 0635/2400] [dev.typeparams] cmd/compile/internal/types: review
 of infer.go

The changes between (equivalent, and reviewed) go/types/infer.go
and infer.go can be seen by comparing patchset 1 and 2. The actual
change is just removing the "// UNREVIEWED" marker and fixing a
few comments.

Change-Id: Ieb0c07c325a2e446550f85b159f99d4dfe5f1d5a
Reviewed-on: https://go-review.googlesource.com/c/go/+/291171
Reviewed-by: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/types2/infer.go | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

diff --git a/src/cmd/compile/internal/types2/infer.go b/src/cmd/compile/internal/types2/infer.go
index 125d3f31b9..09d099e625 100644
--- a/src/cmd/compile/internal/types2/infer.go
+++ b/src/cmd/compile/internal/types2/infer.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2018 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.
@@ -15,7 +14,7 @@ import "bytes"
 // is impossible because unification fails, an error is reported and the resulting types list is
 // nil, and index is 0. Otherwise, types is the list of inferred type arguments, and index is
 // the index of the first type argument in that list that couldn't be inferred (and thus is nil).
-// If all type arguments where inferred successfully, index is < 0.
+// If all type arguments were inferred successfully, index is < 0.
 func (check *Checker) infer(tparams []*TypeName, params *Tuple, args []*operand) (types []Type, index int) {
 	assert(params.Len() == len(args))
 
@@ -70,7 +69,7 @@ func (check *Checker) infer(tparams []*TypeName, params *Tuple, args []*operand)
 			if targ := arg.typ; isTyped(targ) {
 				// If we permit bidirectional unification, and targ is
 				// a generic function, we need to initialize u.y with
-				// the respectice type parameters of targ.
+				// the respective type parameters of targ.
 				if !u.unify(par.typ, targ) {
 					errorf("type", par.typ, targ, arg)
 					return nil, 0
@@ -292,19 +291,17 @@ func (check *Checker) inferB(tparams []*TypeName, targs []Type) (types []Type, i
 		typ := tpar.typ.(*TypeParam)
 		sbound := check.structuralType(typ.bound.Under())
 		if sbound != nil {
-			//check.dump(">>> unify(%s, %s)", tpar, sbound)
 			if !u.unify(typ, sbound) {
 				check.errorf(tpar.pos, "%s does not match %s", tpar, sbound)
 				return nil, 0
 			}
-			//check.dump(">>> => indices = %v, types = %s", u.x.indices, u.types)
 		}
 	}
 
 	// u.x.types() now contains the incoming type arguments plus any additional type
 	// arguments for which there were structural constraints. The newly inferred non-
 	// nil entries may still contain references to other type parameters. For instance,
-	// for [type A interface{}, B interface{type []C}, C interface{type *A}], if A == int
+	// for [A any, B interface{type []C}, C interface{type *A}], if A == int
 	// was given, unification produced the type list [int, []C, *A]. We eliminate the
 	// remaining type parameters by substituting the type parameters in this type list
 	// until nothing changes anymore.
@@ -316,7 +313,7 @@ func (check *Checker) inferB(tparams []*TypeName, targs []Type) (types []Type, i
 	}
 
 	// dirty tracks the indices of all types that may still contain type parameters.
-	// We know that nil types entries and entries corresponding to provided (non-nil)
+	// We know that nil type entries and entries corresponding to provided (non-nil)
 	// type arguments are clean, so exclude them from the start.
 	var dirty []int
 	for i, typ := range types {
@@ -326,8 +323,8 @@ func (check *Checker) inferB(tparams []*TypeName, targs []Type) (types []Type, i
 	}
 
 	for len(dirty) > 0 {
-		// TODO(gri) Instead of creating a new smap for each iteration,
-		// provide an update operation for smaps and only change when
+		// TODO(gri) Instead of creating a new substMap for each iteration,
+		// provide an update operation for substMaps and only change when
 		// needed. Optimization.
 		smap := makeSubstMap(tparams, types)
 		n := 0
@@ -341,7 +338,6 @@ func (check *Checker) inferB(tparams []*TypeName, targs []Type) (types []Type, i
 		}
 		dirty = dirty[:n]
 	}
-	//check.dump(">>> inferred types = %s", types)
 
 	return
 }
-- 
GitLab


From 20746b2f3775631f1fcf041dde9cd11af6b79120 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 10 Feb 2021 17:28:44 -0800
Subject: [PATCH 0636/2400] [dev.typeparams] cmd/compile/internal/types: review
 of labels.go

The changes between (equivalent, and reviewed) go/types/labels.go
and labels.go can be seen by comparing patchset 1 and 2. The actual
change is just removing the "// UNREVIEWED" marker.

Change-Id: I8f1a9927beadff7ac851681739902c13300b6c39
Reviewed-on: https://go-review.googlesource.com/c/go/+/291172
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/labels.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/labels.go b/src/cmd/compile/internal/types2/labels.go
index ca5fe6b389..b20b454dea 100644
--- a/src/cmd/compile/internal/types2/labels.go
+++ b/src/cmd/compile/internal/types2/labels.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2013 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.
-- 
GitLab


From b20f9e2da124ed0473418e41bc5658811ff58ddf Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 10 Feb 2021 17:34:46 -0800
Subject: [PATCH 0637/2400] [dev.typeparams] cmd/compile/internal/types: review
 of object.go

The changes between (equivalent, and reviewed) go/types/object.go
and object.go can be seen by comparing patchset 1 and 2. The actual
change is just removing the "// UNREVIEWED" marker.

Change-Id: I0fcc08c19c94a60f642036697ccd12f0667d22cc
Reviewed-on: https://go-review.googlesource.com/c/go/+/291173
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/object.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/object.go b/src/cmd/compile/internal/types2/object.go
index b42662222f..956646499a 100644
--- a/src/cmd/compile/internal/types2/object.go
+++ b/src/cmd/compile/internal/types2/object.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2013 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.
-- 
GitLab


From 7428318af61d700f9f6abe7e5202fb71761ad995 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 10 Feb 2021 17:38:11 -0800
Subject: [PATCH 0638/2400] [dev.typeparams] cmd/compile/internal/types: review
 of object_test.go

The changes between (equivalent, and reviewed) go/types/object_test.go
and object_test.go can be seen by comparing patchset 1 and 2. The actual
change is just removing the "// UNREVIEWED" marker.

Change-Id: I0ebc564fb8edf42c901bf3bf3bae242760aa7c0c
Reviewed-on: https://go-review.googlesource.com/c/go/+/291174
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/object_test.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/object_test.go b/src/cmd/compile/internal/types2/object_test.go
index 8f11c87451..7f63c79332 100644
--- a/src/cmd/compile/internal/types2/object_test.go
+++ b/src/cmd/compile/internal/types2/object_test.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2016 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.
-- 
GitLab


From 3aee461d5c3105db0663ec1ad9b906183a7e9f0b Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 10 Feb 2021 17:40:59 -0800
Subject: [PATCH 0639/2400] [dev.typeparams] cmd/compile/internal/types: review
 of return.go

The changes between (equivalent, and reviewed) go/types/return.go
and return.go can be seen by comparing patchset 1 and 2. The actual
change is just removing the "// UNREVIEWED" marker.

Change-Id: I7bb3201abec75043804296d6c37307fd243d58f8
Reviewed-on: https://go-review.googlesource.com/c/go/+/291175
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/return.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/return.go b/src/cmd/compile/internal/types2/return.go
index 88234b1723..204e456a91 100644
--- a/src/cmd/compile/internal/types2/return.go
+++ b/src/cmd/compile/internal/types2/return.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2013 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.
-- 
GitLab


From 17587801815071875da2e9251abc322979b5fa86 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 10 Feb 2021 17:48:27 -0800
Subject: [PATCH 0640/2400] [dev.typeparams] cmd/compile/internal/types: review
 of sizes.go

The changes between (equivalent, and reviewed) go/types/sizes.go
and sizes.go can be seen by comparing patchset 1 and 2. The actual
change is just removing the "// UNREVIEWED" marker.

Change-Id: Iacdcffe56023ec53bfaaac8fb112f813a7de0a95
Reviewed-on: https://go-review.googlesource.com/c/go/+/291176
Reviewed-by: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/types2/sizes.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/sizes.go b/src/cmd/compile/internal/types2/sizes.go
index cae71c139c..9945dcd10c 100644
--- a/src/cmd/compile/internal/types2/sizes.go
+++ b/src/cmd/compile/internal/types2/sizes.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2013 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.
-- 
GitLab


From 1b6f0bf1b29303e029d653f4b056326867f73366 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 10 Feb 2021 17:51:35 -0800
Subject: [PATCH 0641/2400] [dev.typeparams] cmd/compile/internal/types: review
 of sizes_test.go

The changes between (equivalent, and reviewed) go/types/sizes_test.go
and sizes_test.go can be seen by comparing patchset 1 and 2. The actual
change is just removing the "// UNREVIEWED" marker.

Change-Id: I36a9a8a9e0e5a869af392a6d04b50c166c8dbedf
Reviewed-on: https://go-review.googlesource.com/c/go/+/291177
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/sizes_test.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/sizes_test.go b/src/cmd/compile/internal/types2/sizes_test.go
index b246909d2a..c9a4942bed 100644
--- a/src/cmd/compile/internal/types2/sizes_test.go
+++ b/src/cmd/compile/internal/types2/sizes_test.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2016 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.
-- 
GitLab


From 0abd7b768b31c0074a10b944067f71f412773328 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 10 Feb 2021 17:54:01 -0800
Subject: [PATCH 0642/2400] [dev.typeparams] cmd/compile/internal/types: review
 of universe.go

The changes between (equivalent, and reviewed) go/types/universe.go
and universe.go can be seen by comparing patchset 1 and 2. The actual
change is just removing the "// UNREVIEWED" marker.

Change-Id: I217a4ace016129e661b4a43821c6b306812850b8
Reviewed-on: https://go-review.googlesource.com/c/go/+/291178
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/universe.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/universe.go b/src/cmd/compile/internal/types2/universe.go
index f3dd53af1f..dc79902777 100644
--- a/src/cmd/compile/internal/types2/universe.go
+++ b/src/cmd/compile/internal/types2/universe.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2011 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.
-- 
GitLab


From 042f88fe300be0ee9669fb4f9c119b4044a2789f Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 10 Feb 2021 17:59:13 -0800
Subject: [PATCH 0643/2400] [dev.typeparams] cmd/compile/internal/types: review
 of errors_test.go

The changes between (equivalent, and reviewed) go/types/errors_test.go
and errors_test.go can be seen by comparing patchset 1 and 2. The actual
change is just removing the "// UNREVIEWED" marker.

Change-Id: I74de039b9e655445f0407a0203ac52a95c6c8a40
Reviewed-on: https://go-review.googlesource.com/c/go/+/291179
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/errors_test.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/errors_test.go b/src/cmd/compile/internal/types2/errors_test.go
index 51ae5fdb73..cb21ff1ad3 100644
--- a/src/cmd/compile/internal/types2/errors_test.go
+++ b/src/cmd/compile/internal/types2/errors_test.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2020 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.
-- 
GitLab


From a06bd9fecb4ec707a0b07a662283aa4970ecd9b8 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 10 Feb 2021 18:06:10 -0800
Subject: [PATCH 0644/2400] [dev.typeparams] cmd/compile/internal/types: review
 of resolver_test.go

The changes between (equivalent, and reviewed) go/types/resolver_test.go
and resolver_test.go can be seen by comparing patchset 1 and 2. The actual
change is just removing the "// UNREVIEWED" marker.

Change-Id: Ibd5850f0d68e393d81e55651bffc886d71665545
Reviewed-on: https://go-review.googlesource.com/c/go/+/291180
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/resolver_test.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/resolver_test.go b/src/cmd/compile/internal/types2/resolver_test.go
index 983e8ec4d6..aee435ff5f 100644
--- a/src/cmd/compile/internal/types2/resolver_test.go
+++ b/src/cmd/compile/internal/types2/resolver_test.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2011 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.
-- 
GitLab


From 060fa49bd23d758a9062f4cb50e65960ec9662f1 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 10 Feb 2021 12:04:31 -0500
Subject: [PATCH 0645/2400] [dev.regabi] go/types: refuse excessively long
 constants

This is a port of CL 289049 to go/types. In that CL, tests were written
using the ability of tests/run.go to generate test packages dynamically.
For this CL, similar functionality is added to the go/types errmap
tests: tests are refactored to decouple the loading of source code from
the filesystem, so that tests for long constants may be generated
dynamically rather than checked-in as a large testdata file.

Change-Id: I92c7cb61a8d42c6593570ef7ae0af86b501fa34e
Reviewed-on: https://go-review.googlesource.com/c/go/+/290949
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/check_test.go | 74 ++++++++++++++++++++++----------------
 src/go/types/expr.go       | 17 +++++++++
 2 files changed, 60 insertions(+), 31 deletions(-)

diff --git a/src/go/types/check_test.go b/src/go/types/check_test.go
index 47d749b3a3..7292f7bcb2 100644
--- a/src/go/types/check_test.go
+++ b/src/go/types/check_test.go
@@ -68,11 +68,11 @@ func splitError(err error) (pos, msg string) {
 	return
 }
 
-func parseFiles(t *testing.T, filenames []string) ([]*ast.File, []error) {
+func parseFiles(t *testing.T, filenames []string, srcs [][]byte) ([]*ast.File, []error) {
 	var files []*ast.File
 	var errlist []error
-	for _, filename := range filenames {
-		file, err := parser.ParseFile(fset, filename, nil, parser.AllErrors)
+	for i, filename := range filenames {
+		file, err := parser.ParseFile(fset, filename, srcs[i], parser.AllErrors)
 		if file == nil {
 			t.Fatalf("%s: %s", filename, err)
 		}
@@ -101,19 +101,17 @@ var errRx = regexp.MustCompile(`^ *ERROR *(HERE)? *"?([^"]*)"?`)
 // errMap collects the regular expressions of ERROR comments found
 // in files and returns them as a map of error positions to error messages.
 //
-func errMap(t *testing.T, testname string, files []*ast.File) map[string][]string {
+// srcs must be a slice of the same length as files, containing the original
+// source for the parsed AST.
+func errMap(t *testing.T, files []*ast.File, srcs [][]byte) map[string][]string {
 	// map of position strings to lists of error message patterns
 	errmap := make(map[string][]string)
 
-	for _, file := range files {
-		filename := fset.Position(file.Package).Filename
-		src, err := os.ReadFile(filename)
-		if err != nil {
-			t.Fatalf("%s: could not read %s", testname, filename)
-		}
-
+	for i, file := range files {
+		tok := fset.File(file.Package)
+		src := srcs[i]
 		var s scanner.Scanner
-		s.Init(fset.AddFile(filename, -1, len(src)), src, nil, scanner.ScanComments)
+		s.Init(tok, src, nil, scanner.ScanComments)
 		var prev token.Pos // position of last non-comment, non-semicolon token
 		var here token.Pos // position immediately after the token at position prev
 
@@ -190,13 +188,13 @@ func eliminate(t *testing.T, errmap map[string][]string, errlist []error) {
 	}
 }
 
-func checkFiles(t *testing.T, sources []string) {
-	if len(sources) == 0 {
+func checkFiles(t *testing.T, filenames []string, srcs [][]byte) {
+	if len(filenames) == 0 {
 		t.Fatal("no source files")
 	}
 
 	// parse files and collect parser errors
-	files, errlist := parseFiles(t, sources)
+	files, errlist := parseFiles(t, filenames, srcs)
 
 	pkgName := "<no package>"
 	if len(files) > 0 {
@@ -214,11 +212,12 @@ func checkFiles(t *testing.T, sources []string) {
 	var conf Config
 
 	// special case for importC.src
-	if len(sources) == 1 && strings.HasSuffix(sources[0], "importC.src") {
-		conf.FakeImportC = true
+	if len(filenames) == 1 {
+		if strings.HasSuffix(filenames[0], "importC.src") {
+			conf.FakeImportC = true
+		}
 	}
-	// TODO(rFindley) we may need to use the source importer when adding generics
-	// tests.
+
 	conf.Importer = importer.Default()
 	conf.Error = func(err error) {
 		if *haltOnError {
@@ -253,7 +252,7 @@ func checkFiles(t *testing.T, sources []string) {
 
 	// match and eliminate errors;
 	// we are expecting the following errors
-	errmap := errMap(t, pkgName, files)
+	errmap := errMap(t, files, srcs)
 	eliminate(t, errmap, errlist)
 
 	// there should be no expected errors left
@@ -274,7 +273,13 @@ func TestCheck(t *testing.T) {
 	}
 	testenv.MustHaveGoBuild(t)
 	DefPredeclaredTestFuncs()
-	checkFiles(t, strings.Split(*testFiles, " "))
+	testPkg(t, strings.Split(*testFiles, " "))
+}
+
+func TestLongConstants(t *testing.T) {
+	format := "package longconst\n\nconst _ = %s\nconst _ = %s // ERROR excessively long constant"
+	src := fmt.Sprintf(format, strings.Repeat("1", 9999), strings.Repeat("1", 10001))
+	checkFiles(t, []string{"longconst.go"}, [][]byte{[]byte(src)})
 }
 
 func TestTestdata(t *testing.T)  { DefPredeclaredTestFuncs(); testDir(t, "testdata") }
@@ -293,26 +298,33 @@ func testDir(t *testing.T, dir string) {
 		path := filepath.Join(dir, fi.Name())
 
 		// if fi is a directory, its files make up a single package
-		var files []string
+		var filenames []string
 		if fi.IsDir() {
 			fis, err := ioutil.ReadDir(path)
 			if err != nil {
 				t.Error(err)
 				continue
 			}
-			files = make([]string, len(fis))
-			for i, fi := range fis {
-				// if fi is a directory, checkFiles below will complain
-				files[i] = filepath.Join(path, fi.Name())
-				if testing.Verbose() {
-					fmt.Printf("\t%s\n", files[i])
-				}
+			for _, fi := range fis {
+				filenames = append(filenames, filepath.Join(path, fi.Name()))
 			}
 		} else {
-			files = []string{path}
+			filenames = []string{path}
 		}
 		t.Run(filepath.Base(path), func(t *testing.T) {
-			checkFiles(t, files)
+			testPkg(t, filenames)
 		})
 	}
 }
+
+func testPkg(t *testing.T, filenames []string) {
+	srcs := make([][]byte, len(filenames))
+	for i, filename := range filenames {
+		src, err := os.ReadFile(filename)
+		if err != nil {
+			t.Fatalf("could not read %s: %v", filename, err)
+		}
+		srcs[i] = src
+	}
+	checkFiles(t, filenames, srcs)
+}
diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 5e1fe28a43..1a3c486af7 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -1140,6 +1140,23 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 		goto Error
 
 	case *ast.BasicLit:
+		switch e.Kind {
+		case token.INT, token.FLOAT, token.IMAG:
+			// The max. mantissa precision for untyped numeric values
+			// is 512 bits, or 4048 bits for each of the two integer
+			// parts of a fraction for floating-point numbers that are
+			// represented accurately in the go/constant package.
+			// Constant literals that are longer than this many bits
+			// are not meaningful; and excessively long constants may
+			// consume a lot of space and time for a useless conversion.
+			// Cap constant length with a generous upper limit that also
+			// allows for separators between all digits.
+			const limit = 10000
+			if len(e.Value) > limit {
+				check.errorf(e, _InvalidConstVal, "excessively long constant: %s... (%d chars)", e.Value[:10], len(e.Value))
+				goto Error
+			}
+		}
 		x.setConst(e.Kind, e.Value)
 		if x.mode == invalid {
 			// The parser already establishes syntactic correctness.
-- 
GitLab


From a7e9b4b94804a1fbefc0c012ec510f4ee0837ffa Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 11 Feb 2021 10:17:39 -0500
Subject: [PATCH 0646/2400] [dev.regabi] go/types: untyped shift counts must
 fit into uint

This is a port of CL 283872 to go/types. It differs from that CL only in
added error codes.

For #43697

Change-Id: I62277834cef1c0359bcf2c6ee4388731babbc855
Reviewed-on: https://go-review.googlesource.com/c/go/+/291316
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/expr.go             | 26 ++++++++++++++++++--------
 src/go/types/testdata/shifts.src | 12 +++++++-----
 2 files changed, 25 insertions(+), 13 deletions(-)

diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 1a3c486af7..7f8aaed411 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -730,14 +730,14 @@ func (check *Checker) comparison(x, y *operand, op token.Token) {
 
 // If e != nil, it must be the shift expression; it may be nil for non-constant shifts.
 func (check *Checker) shift(x, y *operand, e ast.Expr, op token.Token) {
-	untypedx := isUntyped(x.typ)
+	// TODO(gri) This function seems overly complex. Revisit.
 
 	var xval constant.Value
 	if x.mode == constant_ {
 		xval = constant.ToInt(x.val)
 	}
 
-	if isInteger(x.typ) || untypedx && xval != nil && xval.Kind() == constant.Int {
+	if isInteger(x.typ) || isUntyped(x.typ) && xval != nil && xval.Kind() == constant.Int {
 		// The lhs is of integer type or an untyped constant representable
 		// as an integer. Nothing to do.
 	} else {
@@ -749,16 +749,26 @@ func (check *Checker) shift(x, y *operand, e ast.Expr, op token.Token) {
 
 	// spec: "The right operand in a shift expression must have integer type
 	// or be an untyped constant representable by a value of type uint."
-	switch {
-	case isInteger(y.typ):
-		// nothing to do
-	case isUntyped(y.typ):
+
+	// Provide a good error message for negative shift counts.
+	if y.mode == constant_ {
+		yval := constant.ToInt(y.val) // consider -1, 1.0, but not -1.1
+		if yval.Kind() == constant.Int && constant.Sign(yval) < 0 {
+			check.invalidOp(y, _InvalidShiftCount, "negative shift count %s", y)
+			x.mode = invalid
+			return
+		}
+	}
+
+	// Caution: Check for isUntyped first because isInteger includes untyped
+	//          integers (was bug #43697).
+	if isUntyped(y.typ) {
 		check.convertUntyped(y, Typ[Uint])
 		if y.mode == invalid {
 			x.mode = invalid
 			return
 		}
-	default:
+	} else if !isInteger(y.typ) {
 		check.invalidOp(y, _InvalidShiftCount, "shift count %s must be integer", y)
 		x.mode = invalid
 		return
@@ -816,7 +826,7 @@ func (check *Checker) shift(x, y *operand, e ast.Expr, op token.Token) {
 		}
 
 		// non-constant shift with constant lhs
-		if untypedx {
+		if isUntyped(x.typ) {
 			// spec: "If the left operand of a non-constant shift
 			// expression is an untyped constant, the type of the
 			// constant is what it would be if the shift expression
diff --git a/src/go/types/testdata/shifts.src b/src/go/types/testdata/shifts.src
index c9a38ae169..4d3c59a50f 100644
--- a/src/go/types/testdata/shifts.src
+++ b/src/go/types/testdata/shifts.src
@@ -20,7 +20,7 @@ func shifts0() {
 		// This depends on the exact spec wording which is not
 		// done yet.
 		// TODO(gri) revisit and adjust when spec change is done
-		_ = 1<<- /* ERROR "truncated to uint" */ 1.0
+		_ = 1<<- /* ERROR "negative shift count" */ 1.0
 		_ = 1<<1075 /* ERROR "invalid shift" */
 		_ = 2.0<<1
 		_ = 1<<1.0
@@ -60,11 +60,13 @@ func shifts1() {
 		_ uint = 1 << u
 		_ float32 = 1 /* ERROR "must be integer" */ << u
 
-		// for issue 14822
+		// issue #14822
+		_ = 1<<( /* ERROR "overflows uint" */ 1<<64)
 		_ = 1<<( /* ERROR "invalid shift count" */ 1<<64-1)
-		_ = 1<<( /* ERROR "invalid shift count" */ 1<<64)
-		_ = u<<(1<<63) // valid
-		_ = u<<(1<<64) // valid
+
+		// issue #43697
+		_ = u<<( /* ERROR "overflows uint" */ 1<<64)
+		_ = u<<(1<<64-1)
 	)
 }
 
-- 
GitLab


From b81efb7ec4348951211058cf4fdfc045c75255d6 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 11 Feb 2021 10:23:41 -0500
Subject: [PATCH 0647/2400] [dev.regabi] go/types: add support for language
 version checking

This is a port of CL 289509 to go/types. It differs from that CL in
codes added to errors, to fit the new factoring of check_test.go, and to
allow go/types to import regexp in deps_test.go

For #31793

Change-Id: Ia9e4c7f5aac1493001189184227c2ebc79a76e77
Reviewed-on: https://go-review.googlesource.com/c/go/+/291317
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/build/deps_test.go        |  2 +-
 src/go/types/api.go              |  7 +++
 src/go/types/check.go            | 32 ++++++++-----
 src/go/types/check_test.go       | 36 +++++++++++---
 src/go/types/expr.go             |  5 ++
 src/go/types/stdlib_test.go      | 10 ++--
 src/go/types/testdata/go1_12.src | 35 ++++++++++++++
 src/go/types/version.go          | 82 ++++++++++++++++++++++++++++++++
 8 files changed, 186 insertions(+), 23 deletions(-)
 create mode 100644 src/go/types/testdata/go1_12.src
 create mode 100644 src/go/types/version.go

diff --git a/src/go/build/deps_test.go b/src/go/build/deps_test.go
index 02b29f498a..3fea5ecf0d 100644
--- a/src/go/build/deps_test.go
+++ b/src/go/build/deps_test.go
@@ -285,7 +285,7 @@ var depsRules = `
 	math/big, go/token
 	< go/constant;
 
-	container/heap, go/constant, go/parser
+	container/heap, go/constant, go/parser, regexp
 	< go/types;
 
 	FMT
diff --git a/src/go/types/api.go b/src/go/types/api.go
index d625959817..b5bbb2d97d 100644
--- a/src/go/types/api.go
+++ b/src/go/types/api.go
@@ -101,6 +101,13 @@ type ImporterFrom interface {
 // A Config specifies the configuration for type checking.
 // The zero value for Config is a ready-to-use default configuration.
 type Config struct {
+	// GoVersion describes the accepted Go language version. The string
+	// must follow the format "go%d.%d" (e.g. "go1.12") or it must be
+	// empty; an empty string indicates the latest language version.
+	// If the format is invalid, invoking the type checker will cause a
+	// panic.
+	GoVersion string
+
 	// If IgnoreFuncBodies is set, function bodies are not
 	// type-checked.
 	IgnoreFuncBodies bool
diff --git a/src/go/types/check.go b/src/go/types/check.go
index 03798587e7..3bc8ee067c 100644
--- a/src/go/types/check.go
+++ b/src/go/types/check.go
@@ -8,6 +8,7 @@ package types
 
 import (
 	"errors"
+	"fmt"
 	"go/ast"
 	"go/constant"
 	"go/token"
@@ -84,10 +85,11 @@ type Checker struct {
 	fset *token.FileSet
 	pkg  *Package
 	*Info
-	objMap map[Object]*declInfo       // maps package-level objects and (non-interface) methods to declaration info
-	impMap map[importKey]*Package     // maps (import path, source directory) to (complete or fake) package
-	posMap map[*Interface][]token.Pos // maps interface types to lists of embedded interface positions
-	pkgCnt map[string]int             // counts number of imported packages with a given name (for better error messages)
+	version version                    // accepted language version
+	objMap  map[Object]*declInfo       // maps package-level objects and (non-interface) methods to declaration info
+	impMap  map[importKey]*Package     // maps (import path, source directory) to (complete or fake) package
+	posMap  map[*Interface][]token.Pos // maps interface types to lists of embedded interface positions
+	pkgCnt  map[string]int             // counts number of imported packages with a given name (for better error messages)
 
 	// information collected during type-checking of a set of package files
 	// (initialized by Files, valid only for the duration of check.Files;
@@ -176,15 +178,21 @@ func NewChecker(conf *Config, fset *token.FileSet, pkg *Package, info *Info) *Ch
 		info = new(Info)
 	}
 
+	version, err := parseGoVersion(conf.GoVersion)
+	if err != nil {
+		panic(fmt.Sprintf("invalid Go version %q (%v)", conf.GoVersion, err))
+	}
+
 	return &Checker{
-		conf:   conf,
-		fset:   fset,
-		pkg:    pkg,
-		Info:   info,
-		objMap: make(map[Object]*declInfo),
-		impMap: make(map[importKey]*Package),
-		posMap: make(map[*Interface][]token.Pos),
-		pkgCnt: make(map[string]int),
+		conf:    conf,
+		fset:    fset,
+		pkg:     pkg,
+		Info:    info,
+		version: version,
+		objMap:  make(map[Object]*declInfo),
+		impMap:  make(map[importKey]*Package),
+		posMap:  make(map[*Interface][]token.Pos),
+		pkgCnt:  make(map[string]int),
 	}
 }
 
diff --git a/src/go/types/check_test.go b/src/go/types/check_test.go
index 7292f7bcb2..ca7d926ca9 100644
--- a/src/go/types/check_test.go
+++ b/src/go/types/check_test.go
@@ -47,7 +47,8 @@ import (
 var (
 	haltOnError = flag.Bool("halt", false, "halt on error")
 	listErrors  = flag.Bool("errlist", false, "list errors")
-	testFiles   = flag.String("files", "", "space-separated list of test files")
+	testFiles   = flag.String("files", "", "comma-separated list of test files")
+	goVersion   = flag.String("lang", "", "Go language version (e.g. \"go1.12\"")
 )
 
 var fset = token.NewFileSet()
@@ -188,7 +189,21 @@ func eliminate(t *testing.T, errmap map[string][]string, errlist []error) {
 	}
 }
 
-func checkFiles(t *testing.T, filenames []string, srcs [][]byte) {
+// goVersionRx matches a Go version string using '_', e.g. "go1_12".
+var goVersionRx = regexp.MustCompile(`^go[1-9][0-9]*_(0|[1-9][0-9]*)$`)
+
+// asGoVersion returns a regular Go language version string
+// if s is a Go version string using '_' rather than '.' to
+// separate the major and minor version numbers (e.g. "go1_12").
+// Otherwise it returns the empty string.
+func asGoVersion(s string) string {
+	if goVersionRx.MatchString(s) {
+		return strings.Replace(s, "_", ".", 1)
+	}
+	return ""
+}
+
+func checkFiles(t *testing.T, goVersion string, filenames []string, srcs [][]byte) {
 	if len(filenames) == 0 {
 		t.Fatal("no source files")
 	}
@@ -201,6 +216,11 @@ func checkFiles(t *testing.T, filenames []string, srcs [][]byte) {
 		pkgName = files[0].Name.Name
 	}
 
+	// if no Go version is given, consider the package name
+	if goVersion == "" {
+		goVersion = asGoVersion(pkgName)
+	}
+
 	if *listErrors && len(errlist) > 0 {
 		t.Errorf("--- %s:", pkgName)
 		for _, err := range errlist {
@@ -210,6 +230,7 @@ func checkFiles(t *testing.T, filenames []string, srcs [][]byte) {
 
 	// typecheck and collect typechecker errors
 	var conf Config
+	conf.GoVersion = goVersion
 
 	// special case for importC.src
 	if len(filenames) == 1 {
@@ -267,19 +288,20 @@ func checkFiles(t *testing.T, filenames []string, srcs [][]byte) {
 }
 
 // TestCheck is for manual testing of selected input files, provided with -files.
+// The accepted Go language version can be controlled with the -lang flag.
 func TestCheck(t *testing.T) {
 	if *testFiles == "" {
 		return
 	}
 	testenv.MustHaveGoBuild(t)
 	DefPredeclaredTestFuncs()
-	testPkg(t, strings.Split(*testFiles, " "))
+	testPkg(t, strings.Split(*testFiles, ","), *goVersion)
 }
 
 func TestLongConstants(t *testing.T) {
 	format := "package longconst\n\nconst _ = %s\nconst _ = %s // ERROR excessively long constant"
 	src := fmt.Sprintf(format, strings.Repeat("1", 9999), strings.Repeat("1", 10001))
-	checkFiles(t, []string{"longconst.go"}, [][]byte{[]byte(src)})
+	checkFiles(t, "", []string{"longconst.go"}, [][]byte{[]byte(src)})
 }
 
 func TestTestdata(t *testing.T)  { DefPredeclaredTestFuncs(); testDir(t, "testdata") }
@@ -312,12 +334,12 @@ func testDir(t *testing.T, dir string) {
 			filenames = []string{path}
 		}
 		t.Run(filepath.Base(path), func(t *testing.T) {
-			testPkg(t, filenames)
+			testPkg(t, filenames, "")
 		})
 	}
 }
 
-func testPkg(t *testing.T, filenames []string) {
+func testPkg(t *testing.T, filenames []string, goVersion string) {
 	srcs := make([][]byte, len(filenames))
 	for i, filename := range filenames {
 		src, err := os.ReadFile(filename)
@@ -326,5 +348,5 @@ func testPkg(t *testing.T, filenames []string) {
 		}
 		srcs[i] = src
 	}
-	checkFiles(t, filenames, srcs)
+	checkFiles(t, goVersion, filenames, srcs)
 }
diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 7f8aaed411..aec3172327 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -772,6 +772,10 @@ func (check *Checker) shift(x, y *operand, e ast.Expr, op token.Token) {
 		check.invalidOp(y, _InvalidShiftCount, "shift count %s must be integer", y)
 		x.mode = invalid
 		return
+	} else if !isUnsigned(y.typ) && !check.allowVersion(check.pkg, 1, 13) {
+		check.invalidOp(y, _InvalidShiftCount, "signed shift count %s requires go1.13 or later", y)
+		x.mode = invalid
+		return
 	}
 
 	var yval constant.Value
@@ -1152,6 +1156,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 	case *ast.BasicLit:
 		switch e.Kind {
 		case token.INT, token.FLOAT, token.IMAG:
+			check.langCompat(e)
 			// The max. mantissa precision for untyped numeric values
 			// is 512 bits, or 4048 bits for each of the two integer
 			// parts of a fraction for floating-point numbers that are
diff --git a/src/go/types/stdlib_test.go b/src/go/types/stdlib_test.go
index 71e14b85e5..979785de95 100644
--- a/src/go/types/stdlib_test.go
+++ b/src/go/types/stdlib_test.go
@@ -106,6 +106,7 @@ func testTestDir(t *testing.T, path string, ignore ...string) {
 		// get per-file instructions
 		expectErrors := false
 		filename := filepath.Join(path, f.Name())
+		goVersion := ""
 		if comment := firstComment(filename); comment != "" {
 			fields := strings.Fields(comment)
 			switch fields[0] {
@@ -115,13 +116,17 @@ func testTestDir(t *testing.T, path string, ignore ...string) {
 				expectErrors = true
 				for _, arg := range fields[1:] {
 					if arg == "-0" || arg == "-+" || arg == "-std" {
-						// Marked explicitly as not expected errors (-0),
+						// Marked explicitly as not expecting errors (-0),
 						// or marked as compiling runtime/stdlib, which is only done
 						// to trigger runtime/stdlib-only error output.
 						// In both cases, the code should typecheck.
 						expectErrors = false
 						break
 					}
+					const prefix = "-lang="
+					if strings.HasPrefix(arg, prefix) {
+						goVersion = arg[len(prefix):]
+					}
 				}
 			}
 		}
@@ -129,7 +134,7 @@ func testTestDir(t *testing.T, path string, ignore ...string) {
 		// parse and type-check file
 		file, err := parser.ParseFile(fset, filename, nil, 0)
 		if err == nil {
-			conf := Config{Importer: stdLibImporter}
+			conf := Config{GoVersion: goVersion, Importer: stdLibImporter}
 			_, err = conf.Check(filename, fset, []*ast.File{file}, nil)
 		}
 
@@ -180,7 +185,6 @@ func TestStdFixed(t *testing.T) {
 		"issue22200b.go", // go/types does not have constraints on stack size
 		"issue25507.go",  // go/types does not have constraints on stack size
 		"issue20780.go",  // go/types does not have constraints on stack size
-		"issue31747.go",  // go/types does not have constraints on language level (-lang=go1.12) (see #31793)
 		"issue34329.go",  // go/types does not have constraints on language level (-lang=go1.13) (see #31793)
 		"bug251.go",      // issue #34333 which was exposed with fix for #34151
 		"issue42058a.go", // go/types does not have constraints on channel element size
diff --git a/src/go/types/testdata/go1_12.src b/src/go/types/testdata/go1_12.src
new file mode 100644
index 0000000000..1e529f18be
--- /dev/null
+++ b/src/go/types/testdata/go1_12.src
@@ -0,0 +1,35 @@
+// Copyright 2021 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.
+
+// Check Go language version-specific errors.
+
+package go1_12 // go1.12
+
+// numeric literals
+const (
+	_ = 1_000 // ERROR "underscores in numeric literals requires go1.13 or later"
+	_ = 0b111 // ERROR "binary literals requires go1.13 or later"
+	_ = 0o567 // ERROR "0o/0O-style octal literals requires go1.13 or later"
+	_ = 0xabc // ok
+	_ = 0x0p1 // ERROR "hexadecimal floating-point literals requires go1.13 or later"
+
+	_ = 0B111 // ERROR "binary"
+	_ = 0O567 // ERROR "octal"
+	_ = 0Xabc // ok
+	_ = 0X0P1 // ERROR "hexadecimal floating-point"
+
+	_ = 1_000i // ERROR "underscores"
+	_ = 0b111i // ERROR "binary"
+	_ = 0o567i // ERROR "octal"
+	_ = 0xabci // ERROR "hexadecimal floating-point"
+	_ = 0x0p1i // ERROR "hexadecimal floating-point"
+)
+
+// signed shift counts
+var (
+	s int
+	_ = 1 << s // ERROR "invalid operation: signed shift count s \(variable of type int\) requires go1.13 or later"
+	_ = 1 >> s // ERROR "signed shift count"
+)
+
diff --git a/src/go/types/version.go b/src/go/types/version.go
new file mode 100644
index 0000000000..154694169b
--- /dev/null
+++ b/src/go/types/version.go
@@ -0,0 +1,82 @@
+// Copyright 2021 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 types
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// langCompat reports an error if the representation of a numeric
+// literal is not compatible with the current language version.
+func (check *Checker) langCompat(lit *ast.BasicLit) {
+	s := lit.Value
+	if len(s) <= 2 || check.allowVersion(check.pkg, 1, 13) {
+		return
+	}
+	// len(s) > 2
+	if strings.Contains(s, "_") {
+		check.errorf(lit, _InvalidLit, "underscores in numeric literals requires go1.13 or later")
+		return
+	}
+	if s[0] != '0' {
+		return
+	}
+	radix := s[1]
+	if radix == 'b' || radix == 'B' {
+		check.errorf(lit, _InvalidLit, "binary literals requires go1.13 or later")
+		return
+	}
+	if radix == 'o' || radix == 'O' {
+		check.errorf(lit, _InvalidLit, "0o/0O-style octal literals requires go1.13 or later")
+		return
+	}
+	if lit.Kind != token.INT && (radix == 'x' || radix == 'X') {
+		check.errorf(lit, _InvalidLit, "hexadecimal floating-point literals requires go1.13 or later")
+	}
+}
+
+// allowVersion reports whether the given package
+// is allowed to use version major.minor.
+func (check *Checker) allowVersion(pkg *Package, major, minor int) bool {
+	// We assume that imported packages have all been checked,
+	// so we only have to check for the local package.
+	if pkg != check.pkg {
+		return true
+	}
+	ma, mi := check.version.major, check.version.minor
+	return ma == 0 && mi == 0 || ma > major || ma == major && mi >= minor
+}
+
+type version struct {
+	major, minor int
+}
+
+// parseGoVersion parses a Go version string (such as "go1.12")
+// and returns the version, or an error. If s is the empty
+// string, the version is 0.0.
+func parseGoVersion(s string) (v version, err error) {
+	if s == "" {
+		return
+	}
+	matches := goVersionRx.FindStringSubmatch(s)
+	if matches == nil {
+		err = fmt.Errorf(`should be something like "go1.12"`)
+		return
+	}
+	v.major, err = strconv.Atoi(matches[1])
+	if err != nil {
+		return
+	}
+	v.minor, err = strconv.Atoi(matches[2])
+	return
+}
+
+// goVersionRx matches a Go version string, e.g. "go1.12".
+var goVersionRx = regexp.MustCompile(`^go([1-9][0-9]*)\.(0|[1-9][0-9]*)$`)
-- 
GitLab


From e0215315f51c62f6d2c5ea5ed7008b7e7963dd5d Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Thu, 22 Oct 2020 16:29:04 +0000
Subject: [PATCH 0648/2400] [dev.regabi] reflect: support for register ABI on
 amd64 for reflect.(Value).Call

This change adds support for the new register ABI on amd64 to
reflect.(Value).Call. If internal/abi's register counts are non-zero,
reflect will try to set up arguments in registers on the Call path.

Note that because the register ABI becomes ABI0 with zero registers
available, this should keep working as it did before.

This change does not add any tests for the register ABI case because
there's no way to do so at the moment.

For #40724.

Change-Id: I8aa089a5aa5a31b72e56b3d9388dd3f82203985b
Reviewed-on: https://go-review.googlesource.com/c/go/+/272568
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/go/build/deps_test.go      |   6 +-
 src/internal/abi/abi.go        |  45 +++-
 src/reflect/abi.go             | 403 +++++++++++++++++++++++++++++++++
 src/reflect/export_test.go     |  12 +-
 src/reflect/makefunc.go        |  10 +-
 src/reflect/type.go            |  61 ++---
 src/reflect/value.go           | 249 +++++++++++++++-----
 src/runtime/asm_386.s          |  23 +-
 src/runtime/asm_amd64.s        | 100 ++++++--
 src/runtime/asm_arm.s          |  24 +-
 src/runtime/asm_arm64.s        |  23 +-
 src/runtime/asm_mips64x.s      |  23 +-
 src/runtime/asm_mipsx.s        |  23 +-
 src/runtime/asm_ppc64x.s       |  23 +-
 src/runtime/asm_riscv64.s      |  27 +--
 src/runtime/asm_s390x.s        |  23 +-
 src/runtime/asm_wasm.s         |  23 +-
 src/runtime/mbarrier.go        |  10 +-
 src/runtime/mfinal.go          |   7 +-
 src/runtime/panic.go           |  13 +-
 src/runtime/stubs.go           |  56 ++++-
 src/runtime/syscall_windows.go |   7 +-
 22 files changed, 950 insertions(+), 241 deletions(-)
 create mode 100644 src/reflect/abi.go

diff --git a/src/go/build/deps_test.go b/src/go/build/deps_test.go
index 3fea5ecf0d..e5c849e8f5 100644
--- a/src/go/build/deps_test.go
+++ b/src/go/build/deps_test.go
@@ -71,11 +71,15 @@ var depsRules = `
 	# No dependencies allowed for any of these packages.
 	NONE
 	< container/list, container/ring,
-	  internal/abi, internal/cfg, internal/cpu,
+	  internal/cfg, internal/cpu,
 	  internal/goversion, internal/nettrace,
 	  unicode/utf8, unicode/utf16, unicode,
 	  unsafe;
 
+	# These packages depend only on unsafe.
+	unsafe
+	< internal/abi;
+
 	# RUNTIME is the core runtime group of packages, all of them very light-weight.
 	internal/abi, internal/cpu, unsafe
 	< internal/bytealg
diff --git a/src/internal/abi/abi.go b/src/internal/abi/abi.go
index 07ea51df8f..6700facc04 100644
--- a/src/internal/abi/abi.go
+++ b/src/internal/abi/abi.go
@@ -4,9 +4,50 @@
 
 package abi
 
+import "unsafe"
+
 // RegArgs is a struct that has space for each argument
 // and return value register on the current architecture.
+//
+// Assembly code knows the layout of the first two fields
+// of RegArgs.
+//
+// RegArgs also contains additional space to hold pointers
+// when it may not be safe to keep them only in the integer
+// register space otherwise.
 type RegArgs struct {
-	Ints   [IntArgRegs]uintptr
-	Floats [FloatArgRegs]uint64
+	Ints   [IntArgRegs]uintptr  // untyped integer registers
+	Floats [FloatArgRegs]uint64 // untyped float registers
+
+	// Fields above this point are known to assembly.
+
+	// Ptrs is a space that duplicates Ints but with pointer type,
+	// used to make pointers passed or returned  in registers
+	// visible to the GC by making the type unsafe.Pointer.
+	Ptrs [IntArgRegs]unsafe.Pointer
+
+	// ReturnIsPtr is a bitmap that indicates which registers
+	// contain or will contain pointers on the return path from
+	// a reflectcall. The i'th bit indicates whether the i'th
+	// register contains or will contain a valid Go pointer.
+	ReturnIsPtr IntArgRegBitmap
+}
+
+// IntArgRegBitmap is a bitmap large enough to hold one bit per
+// integer argument/return register.
+type IntArgRegBitmap [(IntArgRegs + 7) / 8]uint8
+
+// Set sets the i'th bit of the bitmap to 1.
+func (b *IntArgRegBitmap) Set(i int) {
+	b[i/8] |= uint8(1) << (i % 8)
+}
+
+// Get returns whether the i'th bit of the bitmap is set.
+//
+// nosplit because it's called in extremely sensitive contexts, like
+// on the reflectcall return path.
+//
+//go:nosplit
+func (b *IntArgRegBitmap) Get(i int) bool {
+	return b[i/8]&(uint8(1)<<(i%8)) != 0
 }
diff --git a/src/reflect/abi.go b/src/reflect/abi.go
new file mode 100644
index 0000000000..88af212717
--- /dev/null
+++ b/src/reflect/abi.go
@@ -0,0 +1,403 @@
+// Copyright 2021 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 reflect
+
+import (
+	"internal/abi"
+	"unsafe"
+)
+
+// abiStep represents an ABI "instruction." Each instruction
+// describes one part of how to translate between a Go value
+// in memory and a call frame.
+type abiStep struct {
+	kind abiStepKind
+
+	// offset and size together describe a part of a Go value
+	// in memory.
+	offset uintptr
+	size   uintptr // size in bytes of the part
+
+	// These fields describe the ABI side of the translation.
+	stkOff uintptr // stack offset, used if kind == abiStepStack
+	ireg   int     // integer register index, used if kind == abiStepIntReg or kind == abiStepPointer
+	freg   int     // FP register index, used if kind == abiStepFloatReg
+}
+
+// abiStepKind is the "op-code" for an abiStep instruction.
+type abiStepKind int
+
+const (
+	abiStepBad      abiStepKind = iota
+	abiStepStack                // copy to/from stack
+	abiStepIntReg               // copy to/from integer register
+	abiStepPointer              // copy pointer to/from integer register
+	abiStepFloatReg             // copy to/from FP register
+)
+
+// abiSeq represents a sequence of ABI instructions for copying
+// from a series of reflect.Values to a call frame (for call arguments)
+// or vice-versa (for call results).
+//
+// An abiSeq should be populated by calling its addArg method.
+type abiSeq struct {
+	// steps is the set of instructions.
+	//
+	// The instructions are grouped together by whole arguments,
+	// with the starting index for the instructions
+	// of the i'th Go value available in valueStart.
+	//
+	// For instance, if this abiSeq represents 3 arguments
+	// passed to a function, then the 2nd argument's steps
+	// begin at steps[valueStart[1]].
+	//
+	// Because reflect accepts Go arguments in distinct
+	// Values and each Value is stored separately, each abiStep
+	// that begins a new argument will have its offset
+	// field == 0.
+	steps      []abiStep
+	valueStart []int
+
+	stackBytes   uintptr // stack space used
+	iregs, fregs int     // registers used
+}
+
+func (a *abiSeq) dump() {
+	for i, p := range a.steps {
+		println("part", i, p.kind, p.offset, p.size, p.stkOff, p.ireg, p.freg)
+	}
+	print("values ")
+	for _, i := range a.valueStart {
+		print(i, " ")
+	}
+	println()
+	println("stack", a.stackBytes)
+	println("iregs", a.iregs)
+	println("fregs", a.fregs)
+}
+
+// stepsForValue returns the ABI instructions for translating
+// the i'th Go argument or return value represented by this
+// abiSeq to the Go ABI.
+func (a *abiSeq) stepsForValue(i int) []abiStep {
+	s := a.valueStart[i]
+	var e int
+	if i == len(a.valueStart)-1 {
+		e = len(a.steps)
+	} else {
+		e = a.valueStart[i+1]
+	}
+	return a.steps[s:e]
+}
+
+// addArg extends the abiSeq with a new Go value of type t.
+//
+// If the value was stack-assigned, returns the single
+// abiStep describing that translation, and nil otherwise.
+func (a *abiSeq) addArg(t *rtype) *abiStep {
+	pStart := len(a.steps)
+	a.valueStart = append(a.valueStart, pStart)
+	if !a.regAssign(t, 0) {
+		a.steps = a.steps[:pStart]
+		a.stackAssign(t.size, uintptr(t.align))
+		return &a.steps[len(a.steps)-1]
+	}
+	return nil
+}
+
+// addRcvr extends the abiSeq with a new method call
+// receiver according to the interface calling convention.
+//
+// If the receiver was stack-assigned, returns the single
+// abiStep describing that translation, and nil otherwise.
+// Returns true if the receiver is a pointer.
+func (a *abiSeq) addRcvr(rcvr *rtype) (*abiStep, bool) {
+	// The receiver is always one word.
+	a.valueStart = append(a.valueStart, len(a.steps))
+	var ok, ptr bool
+	if ifaceIndir(rcvr) || rcvr.pointers() {
+		ok = a.assignIntN(0, ptrSize, 1, 0b1)
+		ptr = true
+	} else {
+		// TODO(mknyszek): Is this case even possible?
+		// The interface data work never contains a non-pointer
+		// value. This case was copied over from older code
+		// in the reflect package which only conditionally added
+		// a pointer bit to the reflect.(Value).Call stack frame's
+		// GC bitmap.
+		ok = a.assignIntN(0, ptrSize, 1, 0b0)
+		ptr = false
+	}
+	if !ok {
+		a.stackAssign(ptrSize, ptrSize)
+		return &a.steps[len(a.steps)-1], ptr
+	}
+	return nil, ptr
+}
+
+// regAssign attempts to reserve argument registers for a value of
+// type t, stored at some offset.
+//
+// It returns whether or not the assignment succeeded, but
+// leaves any changes it made to a.steps behind, so the caller
+// must undo that work by adjusting a.steps if it fails.
+//
+// This method along with the assign* methods represent the
+// complete register-assignment algorithm for the Go ABI.
+func (a *abiSeq) regAssign(t *rtype, offset uintptr) bool {
+	switch t.Kind() {
+	case UnsafePointer, Ptr, Chan, Map, Func:
+		return a.assignIntN(offset, t.size, 1, 0b1)
+	case Bool, Int, Uint, Int8, Uint8, Int16, Uint16, Int32, Uint32, Uintptr:
+		return a.assignIntN(offset, t.size, 1, 0b0)
+	case Int64, Uint64:
+		switch ptrSize {
+		case 4:
+			return a.assignIntN(offset, 4, 2, 0b0)
+		case 8:
+			return a.assignIntN(offset, 8, 1, 0b0)
+		}
+	case Float32, Float64:
+		return a.assignFloatN(offset, t.size, 1)
+	case Complex64:
+		return a.assignFloatN(offset, 4, 2)
+	case Complex128:
+		return a.assignFloatN(offset, 8, 2)
+	case String:
+		return a.assignIntN(offset, ptrSize, 2, 0b01)
+	case Interface:
+		return a.assignIntN(offset, ptrSize, 2, 0b10)
+	case Slice:
+		return a.assignIntN(offset, ptrSize, 3, 0b001)
+	case Array:
+		tt := (*arrayType)(unsafe.Pointer(t))
+		switch tt.len {
+		case 0:
+			// There's nothing to assign, so don't modify
+			// a.steps but succeed so the caller doesn't
+			// try to stack-assign this value.
+			return true
+		case 1:
+			return a.regAssign(tt.elem, offset)
+		default:
+			return false
+		}
+	case Struct:
+		if t.size == 0 {
+			// There's nothing to assign, so don't modify
+			// a.steps but succeed so the caller doesn't
+			// try to stack-assign this value.
+			return true
+		}
+		st := (*structType)(unsafe.Pointer(t))
+		for i := range st.fields {
+			f := &st.fields[i]
+			if f.typ.Size() == 0 {
+				// Ignore zero-sized fields.
+				continue
+			}
+			if !a.regAssign(f.typ, offset+f.offset()) {
+				return false
+			}
+		}
+		return true
+	default:
+		print("t.Kind == ", t.Kind(), "\n")
+		panic("unknown type kind")
+	}
+	panic("unhandled register assignment path")
+}
+
+// assignIntN assigns n values to registers, each "size" bytes large,
+// from the data at [offset, offset+n*size) in memory. Each value at
+// [offset+i*size, offset+(i+1)*size) for i < n is assigned to the
+// next n integer registers.
+//
+// Bit i in ptrMap indicates whether the i'th value is a pointer.
+// n must be <= 8.
+//
+// Returns whether assignment succeeded.
+func (a *abiSeq) assignIntN(offset, size uintptr, n int, ptrMap uint8) bool {
+	if n > 8 || n < 0 {
+		panic("invalid n")
+	}
+	if ptrMap != 0 && size != ptrSize {
+		panic("non-empty pointer map passed for non-pointer-size values")
+	}
+	if a.iregs+n > abi.IntArgRegs {
+		return false
+	}
+	for i := 0; i < n; i++ {
+		kind := abiStepIntReg
+		if ptrMap&(uint8(1)<<i) != 0 {
+			kind = abiStepPointer
+		}
+		a.steps = append(a.steps, abiStep{
+			kind:   kind,
+			offset: offset + uintptr(i)*size,
+			size:   size,
+			ireg:   a.iregs,
+		})
+		a.iregs++
+	}
+	return true
+}
+
+// assignFloatN assigns n values to registers, each "size" bytes large,
+// from the data at [offset, offset+n*size) in memory. Each value at
+// [offset+i*size, offset+(i+1)*size) for i < n is assigned to the
+// next n floating-point registers.
+//
+// Returns whether assignment succeeded.
+func (a *abiSeq) assignFloatN(offset, size uintptr, n int) bool {
+	if n < 0 {
+		panic("invalid n")
+	}
+	if a.fregs+n > abi.FloatArgRegs || abi.EffectiveFloatRegSize < size {
+		return false
+	}
+	for i := 0; i < n; i++ {
+		a.steps = append(a.steps, abiStep{
+			kind:   abiStepFloatReg,
+			offset: offset + uintptr(i)*size,
+			size:   size,
+			freg:   a.fregs,
+		})
+		a.fregs++
+	}
+	return true
+}
+
+// stackAssign reserves space for one value that is "size" bytes
+// large with alignment "alignment" to the stack.
+//
+// Should not be called directly; use addArg instead.
+func (a *abiSeq) stackAssign(size, alignment uintptr) {
+	a.stackBytes = align(a.stackBytes, alignment)
+	a.steps = append(a.steps, abiStep{
+		kind:   abiStepStack,
+		offset: 0, // Only used for whole arguments, so the memory offset is 0.
+		size:   size,
+		stkOff: a.stackBytes,
+	})
+	a.stackBytes += size
+}
+
+// abiDesc describes the ABI for a function or method.
+type abiDesc struct {
+	// call and ret represent the translation steps for
+	// the call and return paths of a Go function.
+	call, ret abiSeq
+
+	// These fields describe the stack space allocated
+	// for the call. stackCallArgsSize is the amount of space
+	// reserved for arguments but not return values. retOffset
+	// is the offset at which return values begin, and
+	// spill is the size in bytes of additional space reserved
+	// to spill argument registers into in case of preemption in
+	// reflectcall's stack frame.
+	stackCallArgsSize, retOffset, spill uintptr
+
+	// stackPtrs is a bitmap that indicates whether
+	// each word in the ABI stack space (stack-assigned
+	// args + return values) is a pointer. Used
+	// as the heap pointer bitmap for stack space
+	// passed to reflectcall.
+	stackPtrs *bitVector
+
+	// outRegPtrs is a bitmap whose i'th bit indicates
+	// whether the i'th integer result register contains
+	// a pointer. Used by reflectcall to make result
+	// pointers visible to the GC.
+	outRegPtrs abi.IntArgRegBitmap
+}
+
+func (a *abiDesc) dump() {
+	println("ABI")
+	println("call")
+	a.call.dump()
+	println("ret")
+	a.ret.dump()
+	println("stackCallArgsSize", a.stackCallArgsSize)
+	println("retOffset", a.retOffset)
+	println("spill", a.spill)
+}
+
+func newAbiDesc(t *funcType, rcvr *rtype) abiDesc {
+	// We need to add space for this argument to
+	// the frame so that it can spill args into it.
+	//
+	// The size of this space is just the sum of the sizes
+	// of each register-allocated type.
+	//
+	// TODO(mknyszek): Remove this when we no longer have
+	// caller reserved spill space.
+	spillInt := uintptr(0)
+	spillFloat := uintptr(0)
+
+	// Compute gc program & stack bitmap for stack arguments
+	stackPtrs := new(bitVector)
+
+	// Compute abiSeq for input parameters.
+	var in abiSeq
+	if rcvr != nil {
+		stkStep, isPtr := in.addRcvr(rcvr)
+		if stkStep != nil {
+			if isPtr {
+				stackPtrs.append(1)
+			} else {
+				stackPtrs.append(0)
+			}
+		} else {
+			spillInt += ptrSize
+		}
+	}
+	for _, arg := range t.in() {
+		i, f := in.iregs, in.fregs
+		stkStep := in.addArg(arg)
+		if stkStep != nil {
+			addTypeBits(stackPtrs, stkStep.stkOff, arg)
+		} else {
+			i, f = in.iregs-i, in.fregs-f
+			spillInt += uintptr(i) * ptrSize
+			spillFloat += uintptr(f) * abi.EffectiveFloatRegSize
+		}
+	}
+	spill := align(spillInt+spillFloat, ptrSize)
+
+	// From the input parameters alone, we now know
+	// the stackCallArgsSize and retOffset.
+	stackCallArgsSize := in.stackBytes
+	retOffset := align(in.stackBytes, ptrSize)
+
+	// Compute the stack frame pointer bitmap and register
+	// pointer bitmap for return values.
+	outRegPtrs := abi.IntArgRegBitmap{}
+
+	// Compute abiSeq for output parameters.
+	var out abiSeq
+	// Stack-assigned return values do not share
+	// space with arguments like they do with registers,
+	// so we need to inject a stack offset here.
+	// Fake it by artifically extending stackBytes by
+	// the return offset.
+	out.stackBytes = retOffset
+	for i, res := range t.out() {
+		stkStep := out.addArg(res)
+		if stkStep != nil {
+			addTypeBits(stackPtrs, stkStep.stkOff, res)
+		} else {
+			for _, st := range out.stepsForValue(i) {
+				if st.kind == abiStepPointer {
+					outRegPtrs.Set(st.ireg)
+				}
+			}
+		}
+	}
+	// Undo the faking from earlier so that stackBytes
+	// is accurate.
+	out.stackBytes -= retOffset
+	return abiDesc{in, out, stackCallArgsSize, retOffset, spill, stackPtrs, outRegPtrs}
+}
diff --git a/src/reflect/export_test.go b/src/reflect/export_test.go
index de426b58a8..ddcfca9dee 100644
--- a/src/reflect/export_test.go
+++ b/src/reflect/export_test.go
@@ -23,15 +23,17 @@ const PtrSize = ptrSize
 
 func FuncLayout(t Type, rcvr Type) (frametype Type, argSize, retOffset uintptr, stack []byte, gc []byte, ptrs bool) {
 	var ft *rtype
-	var s *bitVector
+	var abi abiDesc
 	if rcvr != nil {
-		ft, argSize, retOffset, s, _ = funcLayout((*funcType)(unsafe.Pointer(t.(*rtype))), rcvr.(*rtype))
+		ft, _, abi = funcLayout((*funcType)(unsafe.Pointer(t.(*rtype))), rcvr.(*rtype))
 	} else {
-		ft, argSize, retOffset, s, _ = funcLayout((*funcType)(unsafe.Pointer(t.(*rtype))), nil)
+		ft, _, abi = funcLayout((*funcType)(unsafe.Pointer(t.(*rtype))), nil)
 	}
+	argSize = abi.stackCallArgsSize
+	retOffset = abi.retOffset
 	frametype = ft
-	for i := uint32(0); i < s.n; i++ {
-		stack = append(stack, s.data[i/8]>>(i%8)&1)
+	for i := uint32(0); i < abi.stackPtrs.n; i++ {
+		stack = append(stack, abi.stackPtrs.data[i/8]>>(i%8)&1)
 	}
 	if ft.kind&kindGCProg != 0 {
 		panic("can't handle gc programs")
diff --git a/src/reflect/makefunc.go b/src/reflect/makefunc.go
index 67dc4859b9..e17d4ea758 100644
--- a/src/reflect/makefunc.go
+++ b/src/reflect/makefunc.go
@@ -60,9 +60,9 @@ func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value {
 	code := **(**uintptr)(unsafe.Pointer(&dummy))
 
 	// makeFuncImpl contains a stack map for use by the runtime
-	_, argLen, _, stack, _ := funcLayout(ftyp, nil)
+	_, _, abi := funcLayout(ftyp, nil)
 
-	impl := &makeFuncImpl{code: code, stack: stack, argLen: argLen, ftyp: ftyp, fn: fn}
+	impl := &makeFuncImpl{code: code, stack: abi.stackPtrs, argLen: abi.stackCallArgsSize, ftyp: ftyp, fn: fn}
 
 	return Value{t, unsafe.Pointer(impl), flag(Func)}
 }
@@ -112,12 +112,12 @@ func makeMethodValue(op string, v Value) Value {
 	code := **(**uintptr)(unsafe.Pointer(&dummy))
 
 	// methodValue contains a stack map for use by the runtime
-	_, argLen, _, stack, _ := funcLayout(ftyp, nil)
+	_, _, abi := funcLayout(ftyp, nil)
 
 	fv := &methodValue{
 		fn:     code,
-		stack:  stack,
-		argLen: argLen,
+		stack:  abi.stackPtrs,
+		argLen: abi.stackCallArgsSize,
 		method: int(v.flag) >> flagMethodShift,
 		rcvr:   rcvr,
 	}
diff --git a/src/reflect/type.go b/src/reflect/type.go
index d323828c74..d52816628f 100644
--- a/src/reflect/type.go
+++ b/src/reflect/type.go
@@ -2984,21 +2984,20 @@ type layoutKey struct {
 
 type layoutType struct {
 	t         *rtype
-	argSize   uintptr // size of arguments
-	retOffset uintptr // offset of return values.
-	stack     *bitVector
 	framePool *sync.Pool
+	abi       abiDesc
 }
 
 var layoutCache sync.Map // map[layoutKey]layoutType
 
 // funcLayout computes a struct type representing the layout of the
-// function arguments and return values for the function type t.
+// stack-assigned function arguments and return values for the function
+// type t.
 // If rcvr != nil, rcvr specifies the type of the receiver.
 // The returned type exists only for GC, so we only fill out GC relevant info.
 // Currently, that's just size and the GC program. We also fill in
 // the name for possible debugging use.
-func funcLayout(t *funcType, rcvr *rtype) (frametype *rtype, argSize, retOffset uintptr, stk *bitVector, framePool *sync.Pool) {
+func funcLayout(t *funcType, rcvr *rtype) (frametype *rtype, framePool *sync.Pool, abi abiDesc) {
 	if t.Kind() != Func {
 		panic("reflect: funcLayout of non-func type " + t.String())
 	}
@@ -3008,46 +3007,24 @@ func funcLayout(t *funcType, rcvr *rtype) (frametype *rtype, argSize, retOffset
 	k := layoutKey{t, rcvr}
 	if lti, ok := layoutCache.Load(k); ok {
 		lt := lti.(layoutType)
-		return lt.t, lt.argSize, lt.retOffset, lt.stack, lt.framePool
+		return lt.t, lt.framePool, lt.abi
 	}
 
-	// compute gc program & stack bitmap for arguments
-	ptrmap := new(bitVector)
-	var offset uintptr
-	if rcvr != nil {
-		// Reflect uses the "interface" calling convention for
-		// methods, where receivers take one word of argument
-		// space no matter how big they actually are.
-		if ifaceIndir(rcvr) || rcvr.pointers() {
-			ptrmap.append(1)
-		} else {
-			ptrmap.append(0)
-		}
-		offset += ptrSize
-	}
-	for _, arg := range t.in() {
-		offset += -offset & uintptr(arg.align-1)
-		addTypeBits(ptrmap, offset, arg)
-		offset += arg.size
-	}
-	argSize = offset
-	offset += -offset & (ptrSize - 1)
-	retOffset = offset
-	for _, res := range t.out() {
-		offset += -offset & uintptr(res.align-1)
-		addTypeBits(ptrmap, offset, res)
-		offset += res.size
-	}
-	offset += -offset & (ptrSize - 1)
+	// Compute the ABI layout.
+	abi = newAbiDesc(t, rcvr)
 
 	// build dummy rtype holding gc program
 	x := &rtype{
-		align:   ptrSize,
-		size:    offset,
-		ptrdata: uintptr(ptrmap.n) * ptrSize,
+		align: ptrSize,
+		// Don't add spill space here; it's only necessary in
+		// reflectcall's frame, not in the allocated frame.
+		// TODO(mknyszek): Remove this comment when register
+		// spill space in the frame is no longer required.
+		size:    align(abi.retOffset+abi.ret.stackBytes, ptrSize),
+		ptrdata: uintptr(abi.stackPtrs.n) * ptrSize,
 	}
-	if ptrmap.n > 0 {
-		x.gcdata = &ptrmap.data[0]
+	if abi.stackPtrs.n > 0 {
+		x.gcdata = &abi.stackPtrs.data[0]
 	}
 
 	var s string
@@ -3064,13 +3041,11 @@ func funcLayout(t *funcType, rcvr *rtype) (frametype *rtype, argSize, retOffset
 	}}
 	lti, _ := layoutCache.LoadOrStore(k, layoutType{
 		t:         x,
-		argSize:   argSize,
-		retOffset: retOffset,
-		stack:     ptrmap,
 		framePool: framePool,
+		abi:       abi,
 	})
 	lt := lti.(layoutType)
-	return lt.t, lt.argSize, lt.retOffset, lt.stack, lt.framePool
+	return lt.t, lt.framePool, lt.abi
 }
 
 // ifaceIndir reports whether t is stored indirectly in an interface value.
diff --git a/src/reflect/value.go b/src/reflect/value.go
index 1f185b52e4..eae1b9bf29 100644
--- a/src/reflect/value.go
+++ b/src/reflect/value.go
@@ -5,6 +5,7 @@
 package reflect
 
 import (
+	"internal/abi"
 	"internal/unsafeheader"
 	"math"
 	"runtime"
@@ -352,6 +353,8 @@ func (v Value) CallSlice(in []Value) []Value {
 
 var callGC bool // for testing; see TestCallMethodJump
 
+const debugReflectCall = false
+
 func (v Value) call(op string, in []Value) []Value {
 	// Get function pointer, type.
 	t := (*funcType)(unsafe.Pointer(v.typ))
@@ -430,50 +433,112 @@ func (v Value) call(op string, in []Value) []Value {
 	}
 	nout := t.NumOut()
 
+	// Register argument space.
+	var regArgs abi.RegArgs
+
 	// Compute frame type.
-	frametype, _, retOffset, _, framePool := funcLayout(t, rcvrtype)
+	frametype, framePool, abi := funcLayout(t, rcvrtype)
 
-	// Allocate a chunk of memory for frame.
-	var args unsafe.Pointer
-	if nout == 0 {
-		args = framePool.Get().(unsafe.Pointer)
-	} else {
-		// Can't use pool if the function has return values.
-		// We will leak pointer to args in ret, so its lifetime is not scoped.
-		args = unsafe_New(frametype)
+	// Allocate a chunk of memory for frame if needed.
+	var stackArgs unsafe.Pointer
+	if frametype.size != 0 {
+		if nout == 0 {
+			stackArgs = framePool.Get().(unsafe.Pointer)
+		} else {
+			// Can't use pool if the function has return values.
+			// We will leak pointer to args in ret, so its lifetime is not scoped.
+			stackArgs = unsafe_New(frametype)
+		}
+	}
+	frameSize := frametype.size
+
+	if debugReflectCall {
+		println("reflect.call", t.String())
+		abi.dump()
 	}
-	off := uintptr(0)
 
 	// Copy inputs into args.
+
+	// Handle receiver.
+	inStart := 0
 	if rcvrtype != nil {
-		storeRcvr(rcvr, args)
-		off = ptrSize
+		// Guaranteed to only be one word in size,
+		// so it will only take up exactly 1 abiStep (either
+		// in a register or on the stack).
+		switch st := abi.call.steps[0]; st.kind {
+		case abiStepStack:
+			storeRcvr(rcvr, stackArgs)
+		case abiStepIntReg, abiStepPointer:
+			// Even pointers can go into the uintptr slot because
+			// they'll be kept alive by the Values referenced by
+			// this frame. Reflection forces these to be heap-allocated,
+			// so we don't need to worry about stack copying.
+			storeRcvr(rcvr, unsafe.Pointer(&regArgs.Ints[st.ireg]))
+		case abiStepFloatReg:
+			storeRcvr(rcvr, unsafe.Pointer(&regArgs.Floats[st.freg]))
+		default:
+			panic("unknown ABI parameter kind")
+		}
+		inStart = 1
 	}
+
+	// Handle arguments.
 	for i, v := range in {
 		v.mustBeExported()
 		targ := t.In(i).(*rtype)
-		a := uintptr(targ.align)
-		off = (off + a - 1) &^ (a - 1)
-		n := targ.size
-		if n == 0 {
-			// Not safe to compute args+off pointing at 0 bytes,
-			// because that might point beyond the end of the frame,
-			// but we still need to call assignTo to check assignability.
-			v.assignTo("reflect.Value.Call", targ, nil)
-			continue
-		}
-		addr := add(args, off, "n > 0")
-		v = v.assignTo("reflect.Value.Call", targ, addr)
-		if v.flag&flagIndir != 0 {
-			typedmemmove(targ, addr, v.ptr)
-		} else {
-			*(*unsafe.Pointer)(addr) = v.ptr
+		// TODO(mknyszek): Figure out if it's possible to get some
+		// scratch space for this assignment check. Previously, it
+		// was possible to use space in the argument frame.
+		v = v.assignTo("reflect.Value.Call", targ, nil)
+	stepsLoop:
+		for _, st := range abi.call.stepsForValue(i + inStart) {
+			switch st.kind {
+			case abiStepStack:
+				// Copy values to the "stack."
+				addr := add(stackArgs, st.stkOff, "precomputed stack arg offset")
+				if v.flag&flagIndir != 0 {
+					typedmemmove(targ, addr, v.ptr)
+				} else {
+					*(*unsafe.Pointer)(addr) = v.ptr
+				}
+				// There's only one step for a stack-allocated value.
+				break stepsLoop
+			case abiStepIntReg, abiStepPointer:
+				// Copy values to "integer registers."
+				if v.flag&flagIndir != 0 {
+					offset := add(v.ptr, st.offset, "precomputed value offset")
+					memmove(unsafe.Pointer(&regArgs.Ints[st.ireg]), offset, st.size)
+				} else {
+					if st.kind == abiStepPointer {
+						// Duplicate this pointer in the pointer area of the
+						// register space. Otherwise, there's the potential for
+						// this to be the last reference to v.ptr.
+						regArgs.Ptrs[st.ireg] = v.ptr
+					}
+					regArgs.Ints[st.ireg] = uintptr(v.ptr)
+				}
+			case abiStepFloatReg:
+				// Copy values to "float registers."
+				if v.flag&flagIndir == 0 {
+					panic("attempted to copy pointer to FP register")
+				}
+				offset := add(v.ptr, st.offset, "precomputed value offset")
+				memmove(unsafe.Pointer(&regArgs.Floats[st.freg]), offset, st.size)
+			default:
+				panic("unknown ABI part kind")
+			}
 		}
-		off += n
 	}
+	// TODO(mknyszek): Remove this when we no longer have
+	// caller reserved spill space.
+	frameSize = align(frameSize, ptrSize)
+	frameSize += abi.spill
+
+	// Mark pointers in registers for the return path.
+	regArgs.ReturnIsPtr = abi.outRegPtrs
 
 	// Call.
-	call(frametype, fn, args, uint32(frametype.size), uint32(retOffset))
+	call(frametype, fn, stackArgs, uint32(frametype.size), uint32(abi.retOffset), uint32(frameSize), &regArgs)
 
 	// For testing; see TestCallMethodJump.
 	if callGC {
@@ -482,34 +547,82 @@ func (v Value) call(op string, in []Value) []Value {
 
 	var ret []Value
 	if nout == 0 {
-		typedmemclr(frametype, args)
-		framePool.Put(args)
+		if stackArgs != nil {
+			typedmemclr(frametype, stackArgs)
+			framePool.Put(stackArgs)
+		}
 	} else {
-		// Zero the now unused input area of args,
-		// because the Values returned by this function contain pointers to the args object,
-		// and will thus keep the args object alive indefinitely.
-		typedmemclrpartial(frametype, args, 0, retOffset)
+		if stackArgs != nil {
+			// Zero the now unused input area of args,
+			// because the Values returned by this function contain pointers to the args object,
+			// and will thus keep the args object alive indefinitely.
+			typedmemclrpartial(frametype, stackArgs, 0, abi.retOffset)
+		}
 
 		// Wrap Values around return values in args.
 		ret = make([]Value, nout)
-		off = retOffset
 		for i := 0; i < nout; i++ {
 			tv := t.Out(i)
-			a := uintptr(tv.Align())
-			off = (off + a - 1) &^ (a - 1)
-			if tv.Size() != 0 {
+			if tv.Size() == 0 {
+				// For zero-sized return value, args+off may point to the next object.
+				// In this case, return the zero value instead.
+				ret[i] = Zero(tv)
+				continue
+			}
+			steps := abi.ret.stepsForValue(i)
+			if st := steps[0]; st.kind == abiStepStack {
+				// This value is on the stack. If part of a value is stack
+				// allocated, the entire value is according to the ABI. So
+				// just make an indirection into the allocated frame.
 				fl := flagIndir | flag(tv.Kind())
-				ret[i] = Value{tv.common(), add(args, off, "tv.Size() != 0"), fl}
+				ret[i] = Value{tv.common(), add(stackArgs, st.stkOff, "tv.Size() != 0"), fl}
 				// Note: this does introduce false sharing between results -
 				// if any result is live, they are all live.
 				// (And the space for the args is live as well, but as we've
 				// cleared that space it isn't as big a deal.)
-			} else {
-				// For zero-sized return value, args+off may point to the next object.
-				// In this case, return the zero value instead.
-				ret[i] = Zero(tv)
+				continue
+			}
+
+			// Handle pointers passed in registers.
+			if !ifaceIndir(tv.common()) {
+				// Pointer-valued data gets put directly
+				// into v.ptr.
+				if steps[0].kind != abiStepPointer {
+					print("kind=", steps[0].kind, ", type=", tv.String(), "\n")
+					panic("mismatch between ABI description and types")
+				}
+				ret[i] = Value{tv.common(), regArgs.Ptrs[steps[0].ireg], flag(t.Kind())}
+				continue
+			}
+
+			// All that's left is values passed in registers that we need to
+			// create space for and copy values back into.
+			//
+			// TODO(mknyszek): We make a new allocation for each register-allocated
+			// value, but previously we could always point into the heap-allocated
+			// stack frame. This is a regression that could be fixed by adding
+			// additional space to the allocated stack frame and storing the
+			// register-allocated return values into the allocated stack frame and
+			// referring there in the resulting Value.
+			s := unsafe_New(tv.common())
+			for _, st := range steps {
+				switch st.kind {
+				case abiStepIntReg:
+					offset := add(s, st.offset, "precomputed value offset")
+					memmove(offset, unsafe.Pointer(&regArgs.Ints[st.ireg]), st.size)
+				case abiStepPointer:
+					s := add(s, st.offset, "precomputed value offset")
+					*((*unsafe.Pointer)(s)) = regArgs.Ptrs[st.ireg]
+				case abiStepFloatReg:
+					offset := add(s, st.offset, "precomputed value offset")
+					memmove(offset, unsafe.Pointer(&regArgs.Floats[st.freg]), st.size)
+				case abiStepStack:
+					panic("register-based return value has stack component")
+				default:
+					panic("unknown ABI part kind")
+				}
 			}
-			off += tv.Size()
+			ret[i] = Value{tv.common(), s, flagIndir | flag(tv.Kind())}
 		}
 	}
 
@@ -709,7 +822,8 @@ func align(x, n uintptr) uintptr {
 func callMethod(ctxt *methodValue, frame unsafe.Pointer, retValid *bool) {
 	rcvr := ctxt.rcvr
 	rcvrtype, t, fn := methodReceiver("call", rcvr, ctxt.method)
-	frametype, argSize, retOffset, _, framePool := funcLayout(t, rcvrtype)
+	frametype, framePool, abid := funcLayout(t, rcvrtype)
+	argSize, retOffset := abid.stackCallArgsSize, abid.retOffset
 
 	// Make a new frame that is one word bigger so we can store the receiver.
 	// This space is used for both arguments and return values.
@@ -727,10 +841,19 @@ func callMethod(ctxt *methodValue, frame unsafe.Pointer, retValid *bool) {
 		typedmemmovepartial(frametype, add(scratch, argOffset, "argSize > argOffset"), frame, argOffset, argSize-argOffset)
 	}
 
+	frameSize := frametype.size
+	// TODO(mknyszek): Remove this when we no longer have
+	// caller reserved spill space.
+	frameSize = align(frameSize, ptrSize)
+	frameSize += abid.spill
+
 	// Call.
 	// Call copies the arguments from scratch to the stack, calls fn,
 	// and then copies the results back into scratch.
-	call(frametype, fn, scratch, uint32(frametype.size), uint32(retOffset))
+	//
+	// TODO(mknyszek): Have this actually support the register-based ABI.
+	var regs abi.RegArgs
+	call(frametype, fn, scratch, uint32(frametype.size), uint32(retOffset), uint32(frameSize), &regs)
 
 	// Copy return values.
 	// Ignore any changes to args and just copy return values.
@@ -2802,14 +2925,32 @@ func mapiternext(it unsafe.Pointer)
 //go:noescape
 func maplen(m unsafe.Pointer) int
 
-// call calls fn with a copy of the n argument bytes pointed at by arg.
-// After fn returns, reflectcall copies n-retoffset result bytes
-// back into arg+retoffset before returning. If copying result bytes back,
-// the caller must pass the argument frame type as argtype, so that
-// call can execute appropriate write barriers during the copy.
+// call calls fn with "stackArgsSize" bytes of stack arguments laid out
+// at stackArgs and register arguments laid out in regArgs. frameSize is
+// the total amount of stack space that will be reserved by call, so this
+// should include enough space to spill register arguments to the stack in
+// case of preemption.
+//
+// After fn returns, call copies stackArgsSize-stackRetOffset result bytes
+// back into stackArgs+stackRetOffset before returning, for any return
+// values passed on the stack. Register-based return values will be found
+// in the same regArgs structure.
+//
+// regArgs must also be prepared with an appropriate ReturnIsPtr bitmap
+// indicating which registers will contain pointer-valued return values. The
+// purpose of this bitmap is to keep pointers visible to the GC between
+// returning from reflectcall and actually using them.
 //
+// If copying result bytes back from the stack, the caller must pass the
+// argument frame type as stackArgsType, so that call can execute appropriate
+// write barriers during the copy.
+//
+// Arguments passed through to call do not escape. The type is used only in a
+// very limited callee of call, the stackArgs are copied, and regArgs is only
+// used in the call frame.
+//go:noescape
 //go:linkname call runtime.reflectcall
-func call(argtype *rtype, fn, arg unsafe.Pointer, n uint32, retoffset uint32)
+func call(stackArgsType *rtype, f, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
 
 func ifaceE2I(t *rtype, src interface{}, dst unsafe.Pointer)
 
diff --git a/src/runtime/asm_386.s b/src/runtime/asm_386.s
index 429f3fef82..471451df28 100644
--- a/src/runtime/asm_386.s
+++ b/src/runtime/asm_386.s
@@ -458,7 +458,7 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0-0
 	JMP runtime·morestack(SB)
 
 // reflectcall: call a function with the given argument list
-// func call(argtype *_type, f *FuncVal, arg *byte, argsize, retoffset uint32).
+// func call(stackArgsType *_type, f *FuncVal, stackArgs *byte, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
@@ -470,8 +470,8 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0-0
 	JMP	AX
 // Note: can't just "JMP NAME(SB)" - bad inlining results.
 
-TEXT ·reflectcall(SB), NOSPLIT, $0-20
-	MOVL	argsize+12(FP), CX
+TEXT ·reflectcall(SB), NOSPLIT, $0-28
+	MOVL	frameSize+20(FP), CX
 	DISPATCH(runtime·call16, 16)
 	DISPATCH(runtime·call32, 32)
 	DISPATCH(runtime·call64, 64)
@@ -503,11 +503,11 @@ TEXT ·reflectcall(SB), NOSPLIT, $0-20
 	JMP	AX
 
 #define CALLFN(NAME,MAXSIZE)			\
-TEXT NAME(SB), WRAPPER, $MAXSIZE-20;		\
+TEXT NAME(SB), WRAPPER, $MAXSIZE-28;		\
 	NO_LOCAL_POINTERS;			\
 	/* copy arguments to stack */		\
-	MOVL	argptr+8(FP), SI;		\
-	MOVL	argsize+12(FP), CX;		\
+	MOVL	stackArgs+8(FP), SI;		\
+	MOVL	stackArgsSize+12(FP), CX;		\
 	MOVL	SP, DI;				\
 	REP;MOVSB;				\
 	/* call function */			\
@@ -516,10 +516,10 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-20;		\
 	PCDATA  $PCDATA_StackMapIndex, $0;	\
 	CALL	AX;				\
 	/* copy return values back */		\
-	MOVL	argtype+0(FP), DX;		\
-	MOVL	argptr+8(FP), DI;		\
-	MOVL	argsize+12(FP), CX;		\
-	MOVL	retoffset+16(FP), BX;		\
+	MOVL	stackArgsType+0(FP), DX;		\
+	MOVL	stackArgs+8(FP), DI;		\
+	MOVL	stackArgsSize+12(FP), CX;		\
+	MOVL	stackRetOffset+16(FP), BX;		\
 	MOVL	SP, SI;				\
 	ADDL	BX, DI;				\
 	ADDL	BX, SI;				\
@@ -531,11 +531,12 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-20;		\
 // separate function so it can allocate stack space for the arguments
 // to reflectcallmove. It does not follow the Go ABI; it expects its
 // arguments in registers.
-TEXT callRet<>(SB), NOSPLIT, $16-0
+TEXT callRet<>(SB), NOSPLIT, $20-0
 	MOVL	DX, 0(SP)
 	MOVL	DI, 4(SP)
 	MOVL	SI, 8(SP)
 	MOVL	CX, 12(SP)
+	MOVL	$0, 16(SP)
 	CALL	runtime·reflectcallmove(SB)
 	RET
 
diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index 93280eee4a..5e1ed9b2ad 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -445,8 +445,74 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0
 	MOVL	$0, DX
 	JMP	runtime·morestack(SB)
 
+#ifdef GOEXPERIMENT_REGABI
+// spillArgs stores return values from registers to a *internal/abi.RegArgs in R12.
+TEXT spillArgs<>(SB),NOSPLIT,$0-0
+	MOVQ AX, 0(R12)
+	MOVQ BX, 8(R12)
+	MOVQ CX, 16(R12)
+	MOVQ DI, 24(R12)
+	MOVQ SI, 32(R12)
+	MOVQ R8, 40(R12)
+	MOVQ R9, 48(R12)
+	MOVQ R10, 56(R12)
+	MOVQ R11, 64(R12)
+	MOVQ X0, 72(R12)
+	MOVQ X1, 80(R12)
+	MOVQ X2, 88(R12)
+	MOVQ X3, 96(R12)
+	MOVQ X4, 104(R12)
+	MOVQ X5, 112(R12)
+	MOVQ X6, 120(R12)
+	MOVQ X7, 128(R12)
+	MOVQ X8, 136(R12)
+	MOVQ X9, 144(R12)
+	MOVQ X10, 152(R12)
+	MOVQ X11, 160(R12)
+	MOVQ X12, 168(R12)
+	MOVQ X13, 176(R12)
+	MOVQ X14, 184(R12)
+	RET
+
+// unspillArgs loads args into registers from a *internal/abi.RegArgs in R12.
+TEXT unspillArgs<>(SB),NOSPLIT,$0-0
+	MOVQ 0(R12), AX
+	MOVQ 8(R12), BX
+	MOVQ 16(R12), CX
+	MOVQ 24(R12), DI
+	MOVQ 32(R12), SI
+	MOVQ 40(R12), R8
+	MOVQ 48(R12), R9
+	MOVQ 56(R12), R10
+	MOVQ 64(R12), R11
+	MOVQ 72(R12), X0
+	MOVQ 80(R12), X1
+	MOVQ 88(R12), X2
+	MOVQ 96(R12), X3
+	MOVQ 104(R12), X4
+	MOVQ 112(R12), X5
+	MOVQ 120(R12), X6
+	MOVQ 128(R12), X7
+	MOVQ 136(R12), X8
+	MOVQ 144(R12), X9
+	MOVQ 152(R12), X10
+	MOVQ 160(R12), X11
+	MOVQ 168(R12), X12
+	MOVQ 176(R12), X13
+	MOVQ 184(R12), X14
+	RET
+#else
+// spillArgs stores return values from registers to a pointer in R12.
+TEXT spillArgs<>(SB),NOSPLIT,$0-0
+	RET
+
+// unspillArgs loads args into registers from a pointer in R12.
+TEXT unspillArgs<>(SB),NOSPLIT,$0-0
+	RET
+#endif
+
 // reflectcall: call a function with the given argument list
-// func call(argtype *_type, f *FuncVal, arg *byte, argsize, retoffset uint32).
+// func call(stackArgsType *_type, f *FuncVal, stackArgs *byte, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
@@ -458,8 +524,8 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0
 	JMP	AX
 // Note: can't just "JMP NAME(SB)" - bad inlining results.
 
-TEXT ·reflectcall<ABIInternal>(SB), NOSPLIT, $0-32
-	MOVLQZX argsize+24(FP), CX
+TEXT ·reflectcall<ABIInternal>(SB), NOSPLIT, $0-48
+	MOVLQZX frameSize+32(FP), CX
 	DISPATCH(runtime·call16, 16)
 	DISPATCH(runtime·call32, 32)
 	DISPATCH(runtime·call64, 64)
@@ -491,23 +557,28 @@ TEXT ·reflectcall<ABIInternal>(SB), NOSPLIT, $0-32
 	JMP	AX
 
 #define CALLFN(NAME,MAXSIZE)			\
-TEXT NAME(SB), WRAPPER, $MAXSIZE-32;		\
+TEXT NAME(SB), WRAPPER, $MAXSIZE-48;		\
 	NO_LOCAL_POINTERS;			\
 	/* copy arguments to stack */		\
-	MOVQ	argptr+16(FP), SI;		\
-	MOVLQZX argsize+24(FP), CX;		\
+	MOVQ	stackArgs+16(FP), SI;		\
+	MOVLQZX stackArgsSize+24(FP), CX;		\
 	MOVQ	SP, DI;				\
 	REP;MOVSB;				\
+	/* set up argument registers */		\
+	MOVQ    regArgs+40(FP), R12;		\
+	CALL    unspillArgs<>(SB);		\
 	/* call function */			\
 	MOVQ	f+8(FP), DX;			\
 	PCDATA  $PCDATA_StackMapIndex, $0;	\
-	MOVQ	(DX), AX;			\
-	CALL	AX;				\
-	/* copy return values back */		\
-	MOVQ	argtype+0(FP), DX;		\
-	MOVQ	argptr+16(FP), DI;		\
-	MOVLQZX	argsize+24(FP), CX;		\
-	MOVLQZX	retoffset+28(FP), BX;		\
+	MOVQ	(DX), R12;			\
+	CALL	R12;				\
+	/* copy register return values back */		\
+	MOVQ    regArgs+40(FP), R12;		\
+	CALL    spillArgs<>(SB);		\
+	MOVLQZX	stackArgsSize+24(FP), CX;		\
+	MOVLQZX	stackRetOffset+28(FP), BX;		\
+	MOVQ	stackArgs+16(FP), DI;		\
+	MOVQ	stackArgsType+0(FP), DX;		\
 	MOVQ	SP, SI;				\
 	ADDQ	BX, DI;				\
 	ADDQ	BX, SI;				\
@@ -519,12 +590,13 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-32;		\
 // separate function so it can allocate stack space for the arguments
 // to reflectcallmove. It does not follow the Go ABI; it expects its
 // arguments in registers.
-TEXT callRet<>(SB), NOSPLIT, $32-0
+TEXT callRet<>(SB), NOSPLIT, $40-0
 	NO_LOCAL_POINTERS
 	MOVQ	DX, 0(SP)
 	MOVQ	DI, 8(SP)
 	MOVQ	SI, 16(SP)
 	MOVQ	CX, 24(SP)
+	MOVQ	R12, 32(SP)
 	CALL	runtime·reflectcallmove(SB)
 	RET
 
diff --git a/src/runtime/asm_arm.s b/src/runtime/asm_arm.s
index 8eec84d3f2..23619b1408 100644
--- a/src/runtime/asm_arm.s
+++ b/src/runtime/asm_arm.s
@@ -404,7 +404,7 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT|NOFRAME,$0-0
 	B runtime·morestack(SB)
 
 // reflectcall: call a function with the given argument list
-// func call(argtype *_type, f *FuncVal, arg *byte, argsize, retoffset uint32).
+// func call(stackArgsType *_type, f *FuncVal, stackArgs *byte, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
@@ -415,8 +415,8 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT|NOFRAME,$0-0
 	MOVW	$NAME(SB), R1;		\
 	B	(R1)
 
-TEXT ·reflectcall(SB),NOSPLIT|NOFRAME,$0-20
-	MOVW	argsize+12(FP), R0
+TEXT ·reflectcall(SB),NOSPLIT|NOFRAME,$0-28
+	MOVW	frameSize+20(FP), R0
 	DISPATCH(runtime·call16, 16)
 	DISPATCH(runtime·call32, 32)
 	DISPATCH(runtime·call64, 64)
@@ -448,11 +448,11 @@ TEXT ·reflectcall(SB),NOSPLIT|NOFRAME,$0-20
 	B	(R1)
 
 #define CALLFN(NAME,MAXSIZE)			\
-TEXT NAME(SB), WRAPPER, $MAXSIZE-20;		\
+TEXT NAME(SB), WRAPPER, $MAXSIZE-28;		\
 	NO_LOCAL_POINTERS;			\
 	/* copy arguments to stack */		\
-	MOVW	argptr+8(FP), R0;		\
-	MOVW	argsize+12(FP), R2;		\
+	MOVW	stackArgs+8(FP), R0;		\
+	MOVW	stackArgsSize+12(FP), R2;		\
 	ADD	$4, R13, R1;			\
 	CMP	$0, R2;				\
 	B.EQ	5(PC);				\
@@ -466,10 +466,10 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-20;		\
 	PCDATA  $PCDATA_StackMapIndex, $0;	\
 	BL	(R0);				\
 	/* copy return values back */		\
-	MOVW	argtype+0(FP), R4;		\
-	MOVW	argptr+8(FP), R0;		\
-	MOVW	argsize+12(FP), R2;		\
-	MOVW	retoffset+16(FP), R3;		\
+	MOVW	stackArgsType+0(FP), R4;		\
+	MOVW	stackArgs+8(FP), R0;		\
+	MOVW	stackArgsSize+12(FP), R2;		\
+	MOVW	stackArgsRetOffset+16(FP), R3;		\
 	ADD	$4, R13, R1;			\
 	ADD	R3, R1;				\
 	ADD	R3, R0;				\
@@ -481,11 +481,13 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-20;		\
 // separate function so it can allocate stack space for the arguments
 // to reflectcallmove. It does not follow the Go ABI; it expects its
 // arguments in registers.
-TEXT callRet<>(SB), NOSPLIT, $16-0
+TEXT callRet<>(SB), NOSPLIT, $20-0
 	MOVW	R4, 4(R13)
 	MOVW	R0, 8(R13)
 	MOVW	R1, 12(R13)
 	MOVW	R2, 16(R13)
+	MOVW	$0, R7
+	MOVW	R7, 20(R13)
 	BL	runtime·reflectcallmove(SB)
 	RET
 
diff --git a/src/runtime/asm_arm64.s b/src/runtime/asm_arm64.s
index 8e4a1f74f9..0ab92be1e4 100644
--- a/src/runtime/asm_arm64.s
+++ b/src/runtime/asm_arm64.s
@@ -312,7 +312,7 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT|NOFRAME,$0-0
 	B runtime·morestack(SB)
 
 // reflectcall: call a function with the given argument list
-// func call(argtype *_type, f *FuncVal, arg *byte, argsize, retoffset uint32).
+// func call(stackArgsType *_type, f *FuncVal, stackArgs *byte, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
@@ -325,8 +325,8 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT|NOFRAME,$0-0
 	B	(R27)
 // Note: can't just "B NAME(SB)" - bad inlining results.
 
-TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-32
-	MOVWU argsize+24(FP), R16
+TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-48
+	MOVWU	frameSize+32(FP), R16
 	DISPATCH(runtime·call16, 16)
 	DISPATCH(runtime·call32, 32)
 	DISPATCH(runtime·call64, 64)
@@ -358,11 +358,11 @@ TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-32
 	B	(R0)
 
 #define CALLFN(NAME,MAXSIZE)			\
-TEXT NAME(SB), WRAPPER, $MAXSIZE-24;		\
+TEXT NAME(SB), WRAPPER, $MAXSIZE-48;		\
 	NO_LOCAL_POINTERS;			\
 	/* copy arguments to stack */		\
-	MOVD	arg+16(FP), R3;			\
-	MOVWU	argsize+24(FP), R4;		\
+	MOVD	stackArgs+16(FP), R3;			\
+	MOVWU	stackArgsSize+24(FP), R4;		\
 	ADD	$8, RSP, R5;			\
 	BIC	$0xf, R4, R6;			\
 	CBZ	R6, 6(PC);			\
@@ -388,10 +388,10 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-24;		\
 	PCDATA  $PCDATA_StackMapIndex, $0;	\
 	BL	(R0);				\
 	/* copy return values back */		\
-	MOVD	argtype+0(FP), R7;		\
-	MOVD	arg+16(FP), R3;			\
-	MOVWU	n+24(FP), R4;			\
-	MOVWU	retoffset+28(FP), R6;		\
+	MOVD	stackArgsType+0(FP), R7;		\
+	MOVD	stackArgs+16(FP), R3;			\
+	MOVWU	stackArgsSize+24(FP), R4;			\
+	MOVWU	stackRetOffset+28(FP), R6;		\
 	ADD	$8, RSP, R5;			\
 	ADD	R6, R5; 			\
 	ADD	R6, R3;				\
@@ -403,11 +403,12 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-24;		\
 // separate function so it can allocate stack space for the arguments
 // to reflectcallmove. It does not follow the Go ABI; it expects its
 // arguments in registers.
-TEXT callRet<>(SB), NOSPLIT, $40-0
+TEXT callRet<>(SB), NOSPLIT, $48-0
 	MOVD	R7, 8(RSP)
 	MOVD	R3, 16(RSP)
 	MOVD	R5, 24(RSP)
 	MOVD	R4, 32(RSP)
+	MOVD	$0, 40(RSP)
 	BL	runtime·reflectcallmove(SB)
 	RET
 
diff --git a/src/runtime/asm_mips64x.s b/src/runtime/asm_mips64x.s
index 054a89dc37..694950663a 100644
--- a/src/runtime/asm_mips64x.s
+++ b/src/runtime/asm_mips64x.s
@@ -264,7 +264,7 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT|NOFRAME,$0-0
 	JMP	runtime·morestack(SB)
 
 // reflectcall: call a function with the given argument list
-// func call(argtype *_type, f *FuncVal, arg *byte, argsize, retoffset uint32).
+// func call(stackArgsType *_type, f *FuncVal, stackArgs *byte, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
@@ -277,8 +277,8 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT|NOFRAME,$0-0
 	JMP	(R4)
 // Note: can't just "BR NAME(SB)" - bad inlining results.
 
-TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-32
-	MOVWU argsize+24(FP), R1
+TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-48
+	MOVWU	frameSize+32(FP), R1
 	DISPATCH(runtime·call16, 16)
 	DISPATCH(runtime·call32, 32)
 	DISPATCH(runtime·call64, 64)
@@ -310,11 +310,11 @@ TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-32
 	JMP	(R4)
 
 #define CALLFN(NAME,MAXSIZE)			\
-TEXT NAME(SB), WRAPPER, $MAXSIZE-24;		\
+TEXT NAME(SB), WRAPPER, $MAXSIZE-48;		\
 	NO_LOCAL_POINTERS;			\
 	/* copy arguments to stack */		\
-	MOVV	arg+16(FP), R1;			\
-	MOVWU	argsize+24(FP), R2;			\
+	MOVV	stackArgs+16(FP), R1;			\
+	MOVWU	stackArgsSize+24(FP), R2;			\
 	MOVV	R29, R3;				\
 	ADDV	$8, R3;			\
 	ADDV	R3, R2;				\
@@ -330,10 +330,10 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-24;		\
 	PCDATA  $PCDATA_StackMapIndex, $0;	\
 	JAL	(R4);				\
 	/* copy return values back */		\
-	MOVV	argtype+0(FP), R5;		\
-	MOVV	arg+16(FP), R1;			\
-	MOVWU	n+24(FP), R2;			\
-	MOVWU	retoffset+28(FP), R4;		\
+	MOVV	stackArgsType+0(FP), R5;		\
+	MOVV	stackArgs+16(FP), R1;			\
+	MOVWU	stackArgsSize+24(FP), R2;			\
+	MOVWU	stackRetOffset+28(FP), R4;		\
 	ADDV	$8, R29, R3;				\
 	ADDV	R4, R3; 			\
 	ADDV	R4, R1;				\
@@ -345,11 +345,12 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-24;		\
 // separate function so it can allocate stack space for the arguments
 // to reflectcallmove. It does not follow the Go ABI; it expects its
 // arguments in registers.
-TEXT callRet<>(SB), NOSPLIT, $32-0
+TEXT callRet<>(SB), NOSPLIT, $40-0
 	MOVV	R5, 8(R29)
 	MOVV	R1, 16(R29)
 	MOVV	R3, 24(R29)
 	MOVV	R2, 32(R29)
+	MOVV	$0, 40(R29)
 	JAL	runtime·reflectcallmove(SB)
 	RET
 
diff --git a/src/runtime/asm_mipsx.s b/src/runtime/asm_mipsx.s
index f57437d590..8e5753d255 100644
--- a/src/runtime/asm_mipsx.s
+++ b/src/runtime/asm_mipsx.s
@@ -265,7 +265,7 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0-0
 	JMP	runtime·morestack(SB)
 
 // reflectcall: call a function with the given argument list
-// func call(argtype *_type, f *FuncVal, arg *byte, argsize, retoffset uint32).
+// func call(stackArgsType *_type, f *FuncVal, stackArgs *byte, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 
@@ -276,8 +276,8 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0-0
 	MOVW	$NAME(SB), R4;	\
 	JMP	(R4)
 
-TEXT ·reflectcall(SB),NOSPLIT|NOFRAME,$0-20
-	MOVW	argsize+12(FP), R1
+TEXT ·reflectcall(SB),NOSPLIT|NOFRAME,$0-28
+	MOVW	frameSize+20(FP), R1
 
 	DISPATCH(runtime·call16, 16)
 	DISPATCH(runtime·call32, 32)
@@ -310,11 +310,11 @@ TEXT ·reflectcall(SB),NOSPLIT|NOFRAME,$0-20
 	JMP	(R4)
 
 #define CALLFN(NAME,MAXSIZE)	\
-TEXT NAME(SB),WRAPPER,$MAXSIZE-20;	\
+TEXT NAME(SB),WRAPPER,$MAXSIZE-28;	\
 	NO_LOCAL_POINTERS;	\
 	/* copy arguments to stack */		\
-	MOVW	arg+8(FP), R1;	\
-	MOVW	argsize+12(FP), R2;	\
+	MOVW	stackArgs+8(FP), R1;	\
+	MOVW	stackArgsSize+12(FP), R2;	\
 	MOVW	R29, R3;	\
 	ADDU	$4, R3;	\
 	ADDU	R3, R2;	\
@@ -330,10 +330,10 @@ TEXT NAME(SB),WRAPPER,$MAXSIZE-20;	\
 	PCDATA	$PCDATA_StackMapIndex, $0;	\
 	JAL	(R4);	\
 	/* copy return values back */		\
-	MOVW	argtype+0(FP), R5;	\
-	MOVW	arg+8(FP), R1;	\
-	MOVW	n+12(FP), R2;	\
-	MOVW	retoffset+16(FP), R4;	\
+	MOVW	stackArgsType+0(FP), R5;	\
+	MOVW	stackArgs+8(FP), R1;	\
+	MOVW	stackArgsSize+12(FP), R2;	\
+	MOVW	stackRetOffset+16(FP), R4;	\
 	ADDU	$4, R29, R3;	\
 	ADDU	R4, R3;	\
 	ADDU	R4, R1;	\
@@ -345,11 +345,12 @@ TEXT NAME(SB),WRAPPER,$MAXSIZE-20;	\
 // separate function so it can allocate stack space for the arguments
 // to reflectcallmove. It does not follow the Go ABI; it expects its
 // arguments in registers.
-TEXT callRet<>(SB), NOSPLIT, $16-0
+TEXT callRet<>(SB), NOSPLIT, $20-0
 	MOVW	R5, 4(R29)
 	MOVW	R1, 8(R29)
 	MOVW	R3, 12(R29)
 	MOVW	R2, 16(R29)
+	MOVW    $0, 20(R29)
 	JAL	runtime·reflectcallmove(SB)
 	RET
 
diff --git a/src/runtime/asm_ppc64x.s b/src/runtime/asm_ppc64x.s
index 763a92adf1..834023cce1 100644
--- a/src/runtime/asm_ppc64x.s
+++ b/src/runtime/asm_ppc64x.s
@@ -339,7 +339,7 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT|NOFRAME,$0-0
 	BR	runtime·morestack(SB)
 
 // reflectcall: call a function with the given argument list
-// func call(argtype *_type, f *FuncVal, arg *byte, argsize, retoffset uint32).
+// func call(stackArgsType *_type, f *FuncVal, stackArgs *byte, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
@@ -353,8 +353,8 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT|NOFRAME,$0-0
 	BR	(CTR)
 // Note: can't just "BR NAME(SB)" - bad inlining results.
 
-TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-32
-	MOVWZ argsize+24(FP), R3
+TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-48
+	MOVWZ	frameSize+32(FP), R3
 	DISPATCH(runtime·call16, 16)
 	DISPATCH(runtime·call32, 32)
 	DISPATCH(runtime·call64, 64)
@@ -387,11 +387,11 @@ TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-32
 	BR	(CTR)
 
 #define CALLFN(NAME,MAXSIZE)			\
-TEXT NAME(SB), WRAPPER, $MAXSIZE-24;		\
+TEXT NAME(SB), WRAPPER, $MAXSIZE-48;		\
 	NO_LOCAL_POINTERS;			\
 	/* copy arguments to stack */		\
-	MOVD	arg+16(FP), R3;			\
-	MOVWZ	argsize+24(FP), R4;			\
+	MOVD	stackArgs+16(FP), R3;			\
+	MOVWZ	stackArgsSize+24(FP), R4;			\
 	MOVD    R1, R5;				\
 	CMP	R4, $8;				\
 	BLT	tailsetup;			\
@@ -439,10 +439,10 @@ callfn: \
 	MOVD	24(R1), R2;			\
 #endif						\
 	/* copy return values back */		\
-	MOVD	argtype+0(FP), R7;		\
-	MOVD	arg+16(FP), R3;			\
-	MOVWZ	n+24(FP), R4;			\
-	MOVWZ	retoffset+28(FP), R6;		\
+	MOVD	stackArgsType+0(FP), R7;		\
+	MOVD	stackArgs+16(FP), R3;			\
+	MOVWZ	stackArgsSize+24(FP), R4;			\
+	MOVWZ	stackRetOffset+28(FP), R6;		\
 	ADD	$FIXED_FRAME, R1, R5;		\
 	ADD	R6, R5; 			\
 	ADD	R6, R3;				\
@@ -454,11 +454,12 @@ callfn: \
 // separate function so it can allocate stack space for the arguments
 // to reflectcallmove. It does not follow the Go ABI; it expects its
 // arguments in registers.
-TEXT callRet<>(SB), NOSPLIT, $32-0
+TEXT callRet<>(SB), NOSPLIT, $40-0
 	MOVD	R7, FIXED_FRAME+0(R1)
 	MOVD	R3, FIXED_FRAME+8(R1)
 	MOVD	R5, FIXED_FRAME+16(R1)
 	MOVD	R4, FIXED_FRAME+24(R1)
+	MOVD	$0, FIXED_FRAME+32(R1)
 	BL	runtime·reflectcallmove(SB)
 	RET
 
diff --git a/src/runtime/asm_riscv64.s b/src/runtime/asm_riscv64.s
index cf460d1586..31e324d677 100644
--- a/src/runtime/asm_riscv64.s
+++ b/src/runtime/asm_riscv64.s
@@ -359,7 +359,7 @@ TEXT runtime·asminit(SB),NOSPLIT|NOFRAME,$0-0
 	RET
 
 // reflectcall: call a function with the given argument list
-// func call(argtype *_type, f *FuncVal, arg *byte, argsize, retoffset uint32).
+// func call(stackArgsType *_type, f *FuncVal, stackArgs *byte, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
@@ -371,13 +371,13 @@ TEXT runtime·asminit(SB),NOSPLIT|NOFRAME,$0-0
 	JALR	ZERO, T2
 // Note: can't just "BR NAME(SB)" - bad inlining results.
 
-// func call(argtype *rtype, fn, arg unsafe.Pointer, n uint32, retoffset uint32)
+// func call(stackArgsType *rtype, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs).
 TEXT reflect·call(SB), NOSPLIT, $0-0
 	JMP	·reflectcall(SB)
 
-// func reflectcall(argtype *_type, fn, arg unsafe.Pointer, argsize uint32, retoffset uint32)
-TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-32
-	MOVWU argsize+24(FP), T0
+// func call(stackArgsType *_type, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs).
+TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-48
+	MOVWU	frameSize+32(FP), T0
 	DISPATCH(runtime·call16, 16)
 	DISPATCH(runtime·call32, 32)
 	DISPATCH(runtime·call64, 64)
@@ -409,11 +409,11 @@ TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-32
 	JALR	ZERO, T2
 
 #define CALLFN(NAME,MAXSIZE)			\
-TEXT NAME(SB), WRAPPER, $MAXSIZE-24;		\
+TEXT NAME(SB), WRAPPER, $MAXSIZE-48;		\
 	NO_LOCAL_POINTERS;			\
 	/* copy arguments to stack */		\
-	MOV	arg+16(FP), A1;			\
-	MOVWU	argsize+24(FP), A2;		\
+	MOV	stackArgs+16(FP), A1;			\
+	MOVWU	stackArgsSize+24(FP), A2;		\
 	MOV	X2, A3;				\
 	ADD	$8, A3;				\
 	ADD	A3, A2;				\
@@ -429,10 +429,10 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-24;		\
 	PCDATA  $PCDATA_StackMapIndex, $0;	\
 	JALR	RA, A4;				\
 	/* copy return values back */		\
-	MOV	argtype+0(FP), A5;		\
-	MOV	arg+16(FP), A1;			\
-	MOVWU	n+24(FP), A2;			\
-	MOVWU	retoffset+28(FP), A4;		\
+	MOV	stackArgsType+0(FP), A5;		\
+	MOV	stackArgs+16(FP), A1;			\
+	MOVWU	stackArgsSize+24(FP), A2;			\
+	MOVWU	stackRetOffset+28(FP), A4;		\
 	ADD	$8, X2, A3;			\
 	ADD	A4, A3; 			\
 	ADD	A4, A1;				\
@@ -444,11 +444,12 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-24;		\
 // separate function so it can allocate stack space for the arguments
 // to reflectcallmove. It does not follow the Go ABI; it expects its
 // arguments in registers.
-TEXT callRet<>(SB), NOSPLIT, $32-0
+TEXT callRet<>(SB), NOSPLIT, $40-0
 	MOV	A5, 8(X2)
 	MOV	A1, 16(X2)
 	MOV	A3, 24(X2)
 	MOV	A2, 32(X2)
+	MOV	$0, 40(X2)
 	CALL	runtime·reflectcallmove(SB)
 	RET
 
diff --git a/src/runtime/asm_s390x.s b/src/runtime/asm_s390x.s
index 1cd5eca06f..fbd185c353 100644
--- a/src/runtime/asm_s390x.s
+++ b/src/runtime/asm_s390x.s
@@ -353,7 +353,7 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT|NOFRAME,$0-0
 	BR	runtime·morestack(SB)
 
 // reflectcall: call a function with the given argument list
-// func call(argtype *_type, f *FuncVal, arg *byte, argsize, retoffset uint32).
+// func call(stackArgsType *_type, f *FuncVal, stackArgs *byte, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
@@ -366,8 +366,8 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT|NOFRAME,$0-0
 	BR	(R5)
 // Note: can't just "BR NAME(SB)" - bad inlining results.
 
-TEXT ·reflectcall(SB), NOSPLIT, $-8-32
-	MOVWZ argsize+24(FP), R3
+TEXT ·reflectcall(SB), NOSPLIT, $-8-48
+	MOVWZ	frameSize+32(FP), R3
 	DISPATCH(runtime·call16, 16)
 	DISPATCH(runtime·call32, 32)
 	DISPATCH(runtime·call64, 64)
@@ -399,11 +399,11 @@ TEXT ·reflectcall(SB), NOSPLIT, $-8-32
 	BR	(R5)
 
 #define CALLFN(NAME,MAXSIZE)			\
-TEXT NAME(SB), WRAPPER, $MAXSIZE-24;		\
+TEXT NAME(SB), WRAPPER, $MAXSIZE-48;		\
 	NO_LOCAL_POINTERS;			\
 	/* copy arguments to stack */		\
-	MOVD	arg+16(FP), R4;			\
-	MOVWZ	argsize+24(FP), R5;		\
+	MOVD	stackArgs+16(FP), R4;			\
+	MOVWZ	stackArgsSize+24(FP), R5;		\
 	MOVD	$stack-MAXSIZE(SP), R6;		\
 loopArgs: /* copy 256 bytes at a time */	\
 	CMP	R5, $256;			\
@@ -424,11 +424,11 @@ callFunction:					\
 	PCDATA  $PCDATA_StackMapIndex, $0;	\
 	BL	(R8);				\
 	/* copy return values back */		\
-	MOVD	argtype+0(FP), R7;		\
-	MOVD	arg+16(FP), R6;			\
-	MOVWZ	n+24(FP), R5;			\
+	MOVD	stackArgsType+0(FP), R7;		\
+	MOVD	stackArgs+16(FP), R6;			\
+	MOVWZ	stackArgsSize+24(FP), R5;			\
 	MOVD	$stack-MAXSIZE(SP), R4;		\
-	MOVWZ	retoffset+28(FP), R1;		\
+	MOVWZ	stackRetOffset+28(FP), R1;		\
 	ADD	R1, R4;				\
 	ADD	R1, R6;				\
 	SUB	R1, R5;				\
@@ -439,11 +439,12 @@ callFunction:					\
 // separate function so it can allocate stack space for the arguments
 // to reflectcallmove. It does not follow the Go ABI; it expects its
 // arguments in registers.
-TEXT callRet<>(SB), NOSPLIT, $32-0
+TEXT callRet<>(SB), NOSPLIT, $40-0
 	MOVD	R7, 8(R15)
 	MOVD	R6, 16(R15)
 	MOVD	R4, 24(R15)
 	MOVD	R5, 32(R15)
+	MOVD	$0, 40(R15)
 	BL	runtime·reflectcallmove(SB)
 	RET
 
diff --git a/src/runtime/asm_wasm.s b/src/runtime/asm_wasm.s
index fcb780f1dc..cf3d961b74 100644
--- a/src/runtime/asm_wasm.s
+++ b/src/runtime/asm_wasm.s
@@ -296,14 +296,14 @@ TEXT ·asmcgocall(SB), NOSPLIT, $0-0
 		JMP NAME(SB); \
 	End
 
-TEXT ·reflectcall(SB), NOSPLIT, $0-32
+TEXT ·reflectcall(SB), NOSPLIT, $0-48
 	I64Load fn+8(FP)
 	I64Eqz
 	If
 		CALLNORESUME runtime·sigpanic<ABIInternal>(SB)
 	End
 
-	MOVW argsize+24(FP), R0
+	MOVW frameSize+32(FP), R0
 
 	DISPATCH(runtime·call16, 16)
 	DISPATCH(runtime·call32, 32)
@@ -335,18 +335,18 @@ TEXT ·reflectcall(SB), NOSPLIT, $0-32
 	JMP runtime·badreflectcall(SB)
 
 #define CALLFN(NAME, MAXSIZE) \
-TEXT NAME(SB), WRAPPER, $MAXSIZE-32; \
+TEXT NAME(SB), WRAPPER, $MAXSIZE-48; \
 	NO_LOCAL_POINTERS; \
-	MOVW argsize+24(FP), R0; \
+	MOVW stackArgsSize+24(FP), R0; \
 	\
 	Get R0; \
 	I64Eqz; \
 	Not; \
 	If; \
 		Get SP; \
-		I64Load argptr+16(FP); \
+		I64Load stackArgs+16(FP); \
 		I32WrapI64; \
-		I64Load argsize+24(FP); \
+		I64Load stackArgsSize+24(FP); \
 		I64Const $3; \
 		I64ShrU; \
 		I32WrapI64; \
@@ -359,12 +359,12 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-32; \
 	I64Load $0; \
 	CALL; \
 	\
-	I64Load32U retoffset+28(FP); \
+	I64Load32U stackRetOffset+28(FP); \
 	Set R0; \
 	\
-	MOVD argtype+0(FP), RET0; \
+	MOVD stackArgsType+0(FP), RET0; \
 	\
-	I64Load argptr+16(FP); \
+	I64Load stackArgs+16(FP); \
 	Get R0; \
 	I64Add; \
 	Set RET1; \
@@ -375,7 +375,7 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-32; \
 	I64Add; \
 	Set RET2; \
 	\
-	I64Load32U argsize+24(FP); \
+	I64Load32U stackArgsSize+24(FP); \
 	Get R0; \
 	I64Sub; \
 	Set RET3; \
@@ -387,12 +387,13 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-32; \
 // separate function so it can allocate stack space for the arguments
 // to reflectcallmove. It does not follow the Go ABI; it expects its
 // arguments in registers.
-TEXT callRet<>(SB), NOSPLIT, $32-0
+TEXT callRet<>(SB), NOSPLIT, $40-0
 	NO_LOCAL_POINTERS
 	MOVD RET0, 0(SP)
 	MOVD RET1, 8(SP)
 	MOVD RET2, 16(SP)
 	MOVD RET3, 24(SP)
+	MOVD $0,   32(SP)
 	CALL runtime·reflectcallmove(SB)
 	RET
 
diff --git a/src/runtime/mbarrier.go b/src/runtime/mbarrier.go
index 2b5affce52..4994347bde 100644
--- a/src/runtime/mbarrier.go
+++ b/src/runtime/mbarrier.go
@@ -14,6 +14,7 @@
 package runtime
 
 import (
+	"internal/abi"
 	"runtime/internal/sys"
 	"unsafe"
 )
@@ -223,11 +224,18 @@ func reflect_typedmemmovepartial(typ *_type, dst, src unsafe.Pointer, off, size
 // stack map of reflectcall is wrong.
 //
 //go:nosplit
-func reflectcallmove(typ *_type, dst, src unsafe.Pointer, size uintptr) {
+func reflectcallmove(typ *_type, dst, src unsafe.Pointer, size uintptr, regs *abi.RegArgs) {
 	if writeBarrier.needed && typ != nil && typ.ptrdata != 0 && size >= sys.PtrSize {
 		bulkBarrierPreWrite(uintptr(dst), uintptr(src), size)
 	}
 	memmove(dst, src, size)
+
+	// Move pointers returned in registers to a place where the GC can see them.
+	for i := range regs.Ints {
+		if regs.ReturnIsPtr.Get(i) {
+			regs.Ptrs[i] = unsafe.Pointer(regs.Ints[i])
+		}
+	}
 }
 
 //go:nosplit
diff --git a/src/runtime/mfinal.go b/src/runtime/mfinal.go
index f4dbd77252..7d0313be12 100644
--- a/src/runtime/mfinal.go
+++ b/src/runtime/mfinal.go
@@ -7,6 +7,7 @@
 package runtime
 
 import (
+	"internal/abi"
 	"runtime/internal/atomic"
 	"runtime/internal/sys"
 	"unsafe"
@@ -219,7 +220,11 @@ func runfinq() {
 					throw("bad kind in runfinq")
 				}
 				fingRunning = true
-				reflectcall(nil, unsafe.Pointer(f.fn), frame, uint32(framesz), uint32(framesz))
+				// Pass a dummy RegArgs for now.
+				//
+				// TODO(mknyszek): Pass arguments in registers.
+				var regs abi.RegArgs
+				reflectcall(nil, unsafe.Pointer(f.fn), frame, uint32(framesz), uint32(framesz), uint32(framesz), &regs)
 				fingRunning = false
 
 				// Drop finalizer queue heap references
diff --git a/src/runtime/panic.go b/src/runtime/panic.go
index 5b2ccdd874..e320eaa596 100644
--- a/src/runtime/panic.go
+++ b/src/runtime/panic.go
@@ -5,6 +5,7 @@
 package runtime
 
 import (
+	"internal/abi"
 	"runtime/internal/atomic"
 	"runtime/internal/sys"
 	"unsafe"
@@ -874,7 +875,13 @@ func reflectcallSave(p *_panic, fn, arg unsafe.Pointer, argsize uint32) {
 		p.pc = getcallerpc()
 		p.sp = unsafe.Pointer(getcallersp())
 	}
-	reflectcall(nil, fn, arg, argsize, argsize)
+	// Pass a dummy RegArgs for now since no function actually implements
+	// the register-based ABI.
+	//
+	// TODO(mknyszek): Implement this properly, setting up arguments in
+	// registers as necessary in the caller.
+	var regs abi.RegArgs
+	reflectcall(nil, fn, arg, argsize, argsize, argsize, &regs)
 	if p != nil {
 		p.pc = 0
 		p.sp = unsafe.Pointer(nil)
@@ -968,7 +975,9 @@ func gopanic(e interface{}) {
 			}
 		} else {
 			p.argp = unsafe.Pointer(getargp(0))
-			reflectcall(nil, unsafe.Pointer(d.fn), deferArgs(d), uint32(d.siz), uint32(d.siz))
+
+			var regs abi.RegArgs
+			reflectcall(nil, unsafe.Pointer(d.fn), deferArgs(d), uint32(d.siz), uint32(d.siz), uint32(d.siz), &regs)
 		}
 		p.argp = nil
 
diff --git a/src/runtime/stubs.go b/src/runtime/stubs.go
index 3d1e0c0bb4..c0cc95ec65 100644
--- a/src/runtime/stubs.go
+++ b/src/runtime/stubs.go
@@ -4,7 +4,10 @@
 
 package runtime
 
-import "unsafe"
+import (
+	"internal/abi"
+	"unsafe"
+)
 
 // Should be a built-in for unsafe.Pointer?
 //go:nosplit
@@ -174,19 +177,50 @@ func asminit()
 func setg(gg *g)
 func breakpoint()
 
-// reflectcall calls fn with a copy of the n argument bytes pointed at by arg.
-// After fn returns, reflectcall copies n-retoffset result bytes
-// back into arg+retoffset before returning. If copying result bytes back,
-// the caller should pass the argument frame type as argtype, so that
-// call can execute appropriate write barriers during the copy.
+// reflectcall calls fn with arguments described by stackArgs, stackArgsSize,
+// frameSize, and regArgs.
 //
-// Package reflect always passes a frame type. In package runtime,
-// Windows callbacks are the only use of this that copies results
-// back, and those cannot have pointers in their results, so runtime
-// passes nil for the frame type.
+// Arguments passed on the stack and space for return values passed on the stack
+// must be laid out at the space pointed to by stackArgs (with total length
+// stackArgsSize) according to the ABI.
+//
+// stackRetOffset must be some value <= stackArgsSize that indicates the
+// offset within stackArgs where the return value space begins.
+//
+// frameSize is the total size of the argument frame at stackArgs and must
+// therefore be >= stackArgsSize. It must include additional space for spilling
+// register arguments for stack growth and preemption.
+//
+// TODO(mknyszek): Once we don't need the additional spill space, remove frameSize,
+// since frameSize will be redundant with stackArgsSize.
+//
+// Arguments passed in registers must be laid out in regArgs according to the ABI.
+// regArgs will hold any return values passed in registers after the call.
+//
+// reflectcall copies stack arguments from stackArgs to the goroutine stack, and
+// then copies back stackArgsSize-stackRetOffset bytes back to the return space
+// in stackArgs once fn has completed. It also "unspills" argument registers from
+// regArgs before calling fn, and spills them back into regArgs immediately
+// following the call to fn. If there are results being returned on the stack,
+// the caller should pass the argument frame type as stackArgsType so that
+// reflectcall can execute appropriate write barriers during the copy.
+//
+// reflectcall expects regArgs.ReturnIsPtr to be populated indicating which
+// registers on the return path will contain Go pointers. It will then store
+// these pointers in regArgs.Ptrs such that they are visible to the GC.
+//
+// Package reflect passes a frame type. In package runtime, there is only
+// one call that copies results back, in callbackWrap in syscall_windows.go, and it
+// does NOT pass a frame type, meaning there are no write barriers invoked. See that
+// call site for justification.
 //
 // Package reflect accesses this symbol through a linkname.
-func reflectcall(argtype *_type, fn, arg unsafe.Pointer, argsize uint32, retoffset uint32)
+//
+// Arguments passed through to reflectcall do not escape. The type is used
+// only in a very limited callee of reflectcall, the stackArgs are copied, and
+// regArgs is only used in the reflectcall frame.
+//go:noescape
+func reflectcall(stackArgsType *_type, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
 
 func procyield(cycles uint32)
 
diff --git a/src/runtime/syscall_windows.go b/src/runtime/syscall_windows.go
index 7835b492f7..add40bb0b3 100644
--- a/src/runtime/syscall_windows.go
+++ b/src/runtime/syscall_windows.go
@@ -5,6 +5,7 @@
 package runtime
 
 import (
+	"internal/abi"
 	"runtime/internal/sys"
 	"unsafe"
 )
@@ -242,7 +243,11 @@ func callbackWrap(a *callbackArgs) {
 
 	// Even though this is copying back results, we can pass a nil
 	// type because those results must not require write barriers.
-	reflectcall(nil, unsafe.Pointer(c.fn), noescape(goArgs), uint32(c.retOffset)+sys.PtrSize, uint32(c.retOffset))
+	//
+	// Pass a dummy RegArgs for now.
+	// TODO(mknyszek): Pass arguments in registers.
+	var regs abi.RegArgs
+	reflectcall(nil, unsafe.Pointer(c.fn), noescape(goArgs), uint32(c.retOffset)+sys.PtrSize, uint32(c.retOffset), uint32(c.retOffset)+sys.PtrSize, &regs)
 
 	// Extract the result.
 	a.result = *(*uintptr)(unsafe.Pointer(&frame[c.retOffset]))
-- 
GitLab


From 098504c73ff6ece19566a1ac811ceed73be7c81d Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 16 Feb 2021 10:20:58 -0500
Subject: [PATCH 0649/2400] cmd/link: generate trampoline for inter-dependent
 packages

Currently, in the trampoline generation pass we expect packages
are laid out in dependency order, so a cross-package jump always
has a known target address so we can check if a trampoline is
needed. With linknames, there can be cycles in the package
dependency graph, making this algorithm no longer work. For them,
as the target address is unkown we conservatively generate a
trampoline. This may generate unnecessary trampolines (if the
packages turn out laid together), but package cycles are extremely
rare so this is fine.

Updates #44073.

Change-Id: I2dc2998edacbda27d726fc79452313a21d07787a
Reviewed-on: https://go-review.googlesource.com/c/go/+/292490
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/arm/asm.go   | 16 +++++++++++-----
 src/cmd/link/internal/ld/data.go   | 12 +++++-------
 src/cmd/link/internal/ppc64/asm.go | 12 +++++++++---
 3 files changed, 25 insertions(+), 15 deletions(-)

diff --git a/src/cmd/link/internal/arm/asm.go b/src/cmd/link/internal/arm/asm.go
index 755b472694..03caeae7be 100644
--- a/src/cmd/link/internal/arm/asm.go
+++ b/src/cmd/link/internal/arm/asm.go
@@ -370,10 +370,16 @@ func trampoline(ctxt *ld.Link, ldr *loader.Loader, ri int, rs, s loader.Sym) {
 	r := relocs.At(ri)
 	switch r.Type() {
 	case objabi.R_CALLARM:
-		// r.Add is the instruction
-		// low 24-bit encodes the target address
-		t := (ldr.SymValue(rs) + int64(signext24(r.Add()&0xffffff)*4) - (ldr.SymValue(s) + int64(r.Off()))) / 4
-		if t > 0x7fffff || t < -0x800000 || (*ld.FlagDebugTramp > 1 && ldr.SymPkg(s) != ldr.SymPkg(rs)) {
+		var t int64
+		// ldr.SymValue(rs) == 0 indicates a cross-package jump to a function that is not yet
+		// laid out. Conservatively use a trampoline. This should be rare, as we lay out packages
+		// in dependency order.
+		if ldr.SymValue(rs) != 0 {
+			// r.Add is the instruction
+			// low 24-bit encodes the target address
+			t = (ldr.SymValue(rs) + int64(signext24(r.Add()&0xffffff)*4) - (ldr.SymValue(s) + int64(r.Off()))) / 4
+		}
+		if t > 0x7fffff || t < -0x800000 || ldr.SymValue(rs) == 0 || (*ld.FlagDebugTramp > 1 && ldr.SymPkg(s) != ldr.SymPkg(rs)) {
 			// direct call too far, need to insert trampoline.
 			// look up existing trampolines first. if we found one within the range
 			// of direct call, we can reuse it. otherwise create a new one.
@@ -445,7 +451,7 @@ func gentramp(arch *sys.Arch, linkmode ld.LinkMode, ldr *loader.Loader, tramp *l
 	arch.ByteOrder.PutUint32(P[8:], o3)
 	tramp.SetData(P)
 
-	if linkmode == ld.LinkExternal {
+	if linkmode == ld.LinkExternal || ldr.SymValue(target) == 0 {
 		r, _ := tramp.AddRel(objabi.R_ADDR)
 		r.SetOff(8)
 		r.SetSiz(4)
diff --git a/src/cmd/link/internal/ld/data.go b/src/cmd/link/internal/ld/data.go
index 6013e0ab0a..52035e9630 100644
--- a/src/cmd/link/internal/ld/data.go
+++ b/src/cmd/link/internal/ld/data.go
@@ -106,14 +106,12 @@ func trampoline(ctxt *Link, s loader.Sym) {
 		}
 		rs = ldr.ResolveABIAlias(rs)
 		if ldr.SymValue(rs) == 0 && (ldr.SymType(rs) != sym.SDYNIMPORT && ldr.SymType(rs) != sym.SUNDEFEXT) {
-			if ldr.SymPkg(rs) != ldr.SymPkg(s) {
-				if !isRuntimeDepPkg(ldr.SymPkg(s)) || !isRuntimeDepPkg(ldr.SymPkg(rs)) {
-					ctxt.Errorf(s, "unresolved inter-package jump to %s(%s) from %s", ldr.SymName(rs), ldr.SymPkg(rs), ldr.SymPkg(s))
-				}
-				// runtime and its dependent packages may call to each other.
-				// they are fine, as they will be laid down together.
+			if ldr.SymPkg(rs) == ldr.SymPkg(s) {
+				continue // symbols in the same package are laid out together
+			}
+			if isRuntimeDepPkg(ldr.SymPkg(s)) && isRuntimeDepPkg(ldr.SymPkg(rs)) {
+				continue // runtime packages are laid out together
 			}
-			continue
 		}
 
 		thearch.Trampoline(ctxt, ldr, ri, rs, s)
diff --git a/src/cmd/link/internal/ppc64/asm.go b/src/cmd/link/internal/ppc64/asm.go
index 5bf3898eb9..602f0b5299 100644
--- a/src/cmd/link/internal/ppc64/asm.go
+++ b/src/cmd/link/internal/ppc64/asm.go
@@ -656,13 +656,19 @@ func trampoline(ctxt *ld.Link, ldr *loader.Loader, ri int, rs, s loader.Sym) {
 
 	relocs := ldr.Relocs(s)
 	r := relocs.At(ri)
-	t := ldr.SymValue(rs) + r.Add() - (ldr.SymValue(s) + int64(r.Off()))
+	var t int64
+	// ldr.SymValue(rs) == 0 indicates a cross-package jump to a function that is not yet
+	// laid out. Conservatively use a trampoline. This should be rare, as we lay out packages
+	// in dependency order.
+	if ldr.SymValue(rs) != 0 {
+		t = ldr.SymValue(rs) + r.Add() - (ldr.SymValue(s) + int64(r.Off()))
+	}
 	switch r.Type() {
 	case objabi.R_CALLPOWER:
 
 		// If branch offset is too far then create a trampoline.
 
-		if (ctxt.IsExternal() && ldr.SymSect(s) != ldr.SymSect(rs)) || (ctxt.IsInternal() && int64(int32(t<<6)>>6) != t) || (*ld.FlagDebugTramp > 1 && ldr.SymPkg(s) != ldr.SymPkg(rs)) {
+		if (ctxt.IsExternal() && ldr.SymSect(s) != ldr.SymSect(rs)) || (ctxt.IsInternal() && int64(int32(t<<6)>>6) != t) || ldr.SymValue(rs) == 0 || (*ld.FlagDebugTramp > 1 && ldr.SymPkg(s) != ldr.SymPkg(rs)) {
 			var tramp loader.Sym
 			for i := 0; ; i++ {
 
@@ -749,7 +755,7 @@ func gentramp(ctxt *ld.Link, ldr *loader.Loader, tramp *loader.SymbolBuilder, ta
 
 		// With external linking, the target address must be
 		// relocated using LO and HA
-		if ctxt.IsExternal() {
+		if ctxt.IsExternal() || ldr.SymValue(target) == 0 {
 			r, _ := tramp.AddRel(objabi.R_ADDRPOWER)
 			r.SetOff(0)
 			r.SetSiz(8) // generates 2 relocations: HA + LO
-- 
GitLab


From d28aae26b00ec047da1c27192d7eb4b64e30db45 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 16 Feb 2021 12:58:48 -0500
Subject: [PATCH 0650/2400] [dev.regabi] cmd/link: recognize internal/abi as
 runtime package

The runtime imports the internal/abi package. Recognize
internal/abi as a runtime dependent, to make trampoline generation
algorithm work.

Fix ARM build.

Change-Id: I26b6778aa41dcb959bc226ff04abe08a5a82c4f6
Reviewed-on: https://go-review.googlesource.com/c/go/+/292610
Reviewed-by: Than McIntosh <thanm@google.com>
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/link/internal/ld/data.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/cmd/link/internal/ld/data.go b/src/cmd/link/internal/ld/data.go
index 6013e0ab0a..2fb790a6ea 100644
--- a/src/cmd/link/internal/ld/data.go
+++ b/src/cmd/link/internal/ld/data.go
@@ -55,6 +55,7 @@ func isRuntimeDepPkg(pkg string) bool {
 	switch pkg {
 	case "runtime",
 		"sync/atomic",      // runtime may call to sync/atomic, due to go:linkname
+		"internal/abi",     // used by reflectcall (and maybe more)
 		"internal/bytealg", // for IndexByte
 		"internal/cpu":     // for cpu features
 		return true
-- 
GitLab


From 6f3da9d2f6b4f7dbbe5d15260d87ed2a84488fde Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Tue, 16 Feb 2021 10:16:06 -0800
Subject: [PATCH 0651/2400] README: pull gopher image from website

Fixes breakage accidentally introduced by https://golang.org/cl/291711.

Fixes #44295

Change-Id: I76f3e5577d1d24027d4ed2a725b5b749ab2d059c
Reviewed-on: https://go-review.googlesource.com/c/go/+/292629
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 4ca3956de8..837734b6e5 100644
--- a/README.md
+++ b/README.md
@@ -3,7 +3,7 @@
 Go is an open source programming language that makes it easy to build simple,
 reliable, and efficient software.
 
-![Gopher image](doc/gopher/fiveyears.jpg)
+![Gopher image](https://golang.org/doc/gopher/fiveyears.jpg)
 *Gopher image by [Renee French][rf], licensed under [Creative Commons 3.0 Attributions license][cc3-by].*
 
 Our canonical Git repository is located at https://go.googlesource.com/go.
-- 
GitLab


From 8cfbf34dd956125524ea63469342cf8a319b5bd1 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Tue, 16 Feb 2021 18:29:18 +0000
Subject: [PATCH 0652/2400] internal/abi: set register count constants to zero
 for regabi experiment

This change sets the register count constants to zero for the
GOEXPERIMENT regabi because currently the users of it (i.e. reflect)
will be broken, since they expect Go functions that implement the new
ABI.

Change-Id: Id3e874c61821a36605eb4e1cccdee36a2759f303
Reviewed-on: https://go-review.googlesource.com/c/go/+/292649
Reviewed-by: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
---
 src/internal/abi/abi_amd64.go | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/internal/abi/abi_amd64.go b/src/internal/abi/abi_amd64.go
index 6574d4216d..70e2ed1feb 100644
--- a/src/internal/abi/abi_amd64.go
+++ b/src/internal/abi/abi_amd64.go
@@ -9,12 +9,16 @@ package abi
 const (
 	// See abi_generic.go.
 
+	// Currently these values are zero because whatever uses
+	// them will expect the register ABI, which isn't ready
+	// yet.
+
 	// RAX, RBX, RCX, RDI, RSI, R8, R9, R10, R11.
-	IntArgRegs = 9
+	IntArgRegs = 0 // 9
 
 	// X0 -> X14.
-	FloatArgRegs = 15
+	FloatArgRegs = 0 // 15
 
 	// We use SSE2 registers which support 64-bit float operations.
-	EffectiveFloatRegSize = 8
+	EffectiveFloatRegSize = 0 // 8
 )
-- 
GitLab


From c2358a1ae77d7bd09fb8b728d25641b5757a7a58 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Tue, 16 Feb 2021 20:15:13 +0000
Subject: [PATCH 0653/2400] [dev.regabi] runtime: stub out spillArgs and
 unspillArgs

Currently these two functions assume that constants in internal/abi are
set correctly, but we actually just made them zero if
GOEXPERIMENT_REGABI is set. This means reflectcall is broken. Fix it by
stubbing out these routines even if GOEXPERIMENT_REGABI is set.

Change-Id: I4c8df6d6af28562c5bb7b85f48c03d37daa9ee0d
Reviewed-on: https://go-review.googlesource.com/c/go/+/292650
Reviewed-by: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/asm_amd64.s | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index 5e1ed9b2ad..05422c9699 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -445,7 +445,10 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0
 	MOVL	$0, DX
 	JMP	runtime·morestack(SB)
 
-#ifdef GOEXPERIMENT_REGABI
+// REFLECTCALL_USE_REGABI is not defined. It must be defined in conjunction with the
+// register constants in the internal/abi package.
+
+#ifdef REFLECTCALL_USE_REGABI
 // spillArgs stores return values from registers to a *internal/abi.RegArgs in R12.
 TEXT spillArgs<>(SB),NOSPLIT,$0-0
 	MOVQ AX, 0(R12)
-- 
GitLab


From 7696c9433406c3f5b9f127cb557120b74e3c3952 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 11 Feb 2021 10:45:49 -0500
Subject: [PATCH 0654/2400] [dev.regabi] go/types: type alias decl requires
 go1.9

This is a port of CL 289570 to go/types. It has some notable differences
with that CL:
 + A new _BadDecl error code is added, to indicate declarations with bad
   syntax.
 + declInfo is updated hold not an 'alias' bool, but an aliasPos
   token.Pos to identify the location of the type aliasing '=' token.
   This allows for error messages to be accurately placed on the '='

For #31793

Change-Id: Ib15969f9cd5be30228b7a4c6406f978d6fc58018
Reviewed-on: https://go-review.googlesource.com/c/go/+/291318
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/decl.go            | 18 ++++++++++++------
 src/go/types/errorcodes.go      |  3 +++
 src/go/types/resolver.go        |  8 ++++----
 src/go/types/testdata/go1_8.src | 11 +++++++++++
 4 files changed, 30 insertions(+), 10 deletions(-)
 create mode 100644 src/go/types/testdata/go1_8.src

diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index 571e172351..b861cde496 100644
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -189,7 +189,7 @@ func (check *Checker) objDecl(obj Object, def *Named) {
 		check.varDecl(obj, d.lhs, d.typ, d.init)
 	case *TypeName:
 		// invalid recursive types are detected via path
-		check.typeDecl(obj, d.typ, def, d.alias)
+		check.typeDecl(obj, d.typ, def, d.aliasPos)
 	case *Func:
 		// functions may be recursive - no need to track dependencies
 		check.funcDecl(obj, d)
@@ -234,7 +234,7 @@ func (check *Checker) cycle(obj Object) (isCycle bool) {
 			// this information explicitly in the object.
 			var alias bool
 			if d := check.objMap[obj]; d != nil {
-				alias = d.alias // package-level object
+				alias = d.aliasPos.IsValid() // package-level object
 			} else {
 				alias = obj.IsAlias() // function local object
 			}
@@ -640,14 +640,17 @@ func (n *Named) setUnderlying(typ Type) {
 	}
 }
 
-func (check *Checker) typeDecl(obj *TypeName, typ ast.Expr, def *Named, alias bool) {
+func (check *Checker) typeDecl(obj *TypeName, typ ast.Expr, def *Named, aliasPos token.Pos) {
 	assert(obj.typ == nil)
 
 	check.later(func() {
 		check.validType(obj.typ, nil)
 	})
 
-	if alias {
+	if aliasPos.IsValid() {
+		if !check.allowVersion(obj.pkg, 1, 9) {
+			check.errorf(atPos(aliasPos), _BadDecl, "type aliases requires go1.9 or later")
+		}
 
 		obj.typ = Typ[Invalid]
 		obj.typ = check.typ(typ)
@@ -678,9 +681,12 @@ func (check *Checker) typeDecl(obj *TypeName, typ ast.Expr, def *Named, alias bo
 
 	}
 
+	// TODO(rFindley): move to the callsite, as this is only needed for top-level
+	//                 decls.
 	check.addMethodDecls(obj)
 }
 
+// TODO(rFindley): rename to collectMethods, to be consistent with types2.
 func (check *Checker) addMethodDecls(obj *TypeName) {
 	// get associated methods
 	// (Checker.collectObjects only collects methods with non-blank names;
@@ -691,7 +697,7 @@ func (check *Checker) addMethodDecls(obj *TypeName) {
 		return
 	}
 	delete(check.methods, obj)
-	assert(!check.objMap[obj].alias) // don't use TypeName.IsAlias (requires fully set up object)
+	assert(!check.objMap[obj].aliasPos.IsValid()) // don't use TypeName.IsAlias (requires fully set up object)
 
 	// use an objset to check for name conflicts
 	var mset objset
@@ -864,7 +870,7 @@ func (check *Checker) declStmt(d ast.Decl) {
 			check.declare(check.scope, d.spec.Name, obj, scopePos)
 			// mark and unmark type before calling typeDecl; its type is still nil (see Checker.objDecl)
 			obj.setColor(grey + color(check.push(obj)))
-			check.typeDecl(obj, d.spec.Type, nil, d.spec.Assign.IsValid())
+			check.typeDecl(obj, d.spec.Type, nil, d.spec.Assign)
 			check.pop().setColor(black)
 		default:
 			check.invalidAST(d.node(), "unknown ast.Decl node %T", d.node())
diff --git a/src/go/types/errorcodes.go b/src/go/types/errorcodes.go
index d27abdf4d4..ac28c3bd13 100644
--- a/src/go/types/errorcodes.go
+++ b/src/go/types/errorcodes.go
@@ -1366,4 +1366,7 @@ const (
 	//  	return i
 	//  }
 	_InvalidGo
+
+	// _BadDecl occurs when a declaration has invalid syntax.
+	_BadDecl
 )
diff --git a/src/go/types/resolver.go b/src/go/types/resolver.go
index 47e165db36..e4411592e8 100644
--- a/src/go/types/resolver.go
+++ b/src/go/types/resolver.go
@@ -23,7 +23,7 @@ type declInfo struct {
 	init      ast.Expr      // init/orig expression, or nil
 	inherited bool          // if set, the init expression is inherited from a previous constant declaration
 	fdecl     *ast.FuncDecl // func declaration, or nil
-	alias     bool          // type alias declaration
+	aliasPos  token.Pos     // If valid, the decl is a type alias and aliasPos is the position of '='.
 
 	// The deps field tracks initialization expression dependencies.
 	deps map[Object]bool // lazily initialized
@@ -366,7 +366,7 @@ func (check *Checker) collectObjects() {
 				}
 			case typeDecl:
 				obj := NewTypeName(d.spec.Name.Pos(), pkg, d.spec.Name.Name, nil)
-				check.declarePkgObj(d.spec.Name, obj, &declInfo{file: fileScope, typ: d.spec.Type, alias: d.spec.Assign.IsValid()})
+				check.declarePkgObj(d.spec.Name, obj, &declInfo{file: fileScope, typ: d.spec.Type, aliasPos: d.spec.Assign})
 			case funcDecl:
 				info := &declInfo{file: fileScope, fdecl: d.decl}
 				name := d.decl.Name.Name
@@ -493,7 +493,7 @@ func (check *Checker) resolveBaseTypeName(typ ast.Expr) (ptr bool, base *TypeNam
 		// we're done if tdecl defined tname as a new type
 		// (rather than an alias)
 		tdecl := check.objMap[tname] // must exist for objects in package scope
-		if !tdecl.alias {
+		if !tdecl.aliasPos.IsValid() {
 			return ptr, tname
 		}
 
@@ -534,7 +534,7 @@ func (check *Checker) packageObjects() {
 	// phase 1
 	for _, obj := range objList {
 		// If we have a type alias, collect it for the 2nd phase.
-		if tname, _ := obj.(*TypeName); tname != nil && check.objMap[tname].alias {
+		if tname, _ := obj.(*TypeName); tname != nil && check.objMap[tname].aliasPos.IsValid() {
 			aliasList = append(aliasList, tname)
 			continue
 		}
diff --git a/src/go/types/testdata/go1_8.src b/src/go/types/testdata/go1_8.src
new file mode 100644
index 0000000000..3ead1e981b
--- /dev/null
+++ b/src/go/types/testdata/go1_8.src
@@ -0,0 +1,11 @@
+// Copyright 2021 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.
+
+// Check Go language version-specific errors.
+
+package go1_8 // go1.8
+
+// type alias declarations
+type any = /* ERROR type aliases requires go1.9 or later */ interface{}
+
-- 
GitLab


From ed55da46ab994abb4ea1b20aaab3cff6b650959f Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 11 Feb 2021 10:51:52 -0500
Subject: [PATCH 0655/2400] [dev.regabi] go/types: overlapping embedded
 interfaces requires go1.14

This is an exact port of CL 290911 to go/types.

For #31793

Change-Id: I28c42727735f467a5984594b455ca58ab3375591
Reviewed-on: https://go-review.googlesource.com/c/go/+/291319
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/stdlib_test.go      |  1 -
 src/go/types/testdata/go1_13.src | 22 ++++++++++++++++++++++
 src/go/types/typexpr.go          |  8 ++++++--
 3 files changed, 28 insertions(+), 3 deletions(-)
 create mode 100644 src/go/types/testdata/go1_13.src

diff --git a/src/go/types/stdlib_test.go b/src/go/types/stdlib_test.go
index 979785de95..29f71137df 100644
--- a/src/go/types/stdlib_test.go
+++ b/src/go/types/stdlib_test.go
@@ -185,7 +185,6 @@ func TestStdFixed(t *testing.T) {
 		"issue22200b.go", // go/types does not have constraints on stack size
 		"issue25507.go",  // go/types does not have constraints on stack size
 		"issue20780.go",  // go/types does not have constraints on stack size
-		"issue34329.go",  // go/types does not have constraints on language level (-lang=go1.13) (see #31793)
 		"bug251.go",      // issue #34333 which was exposed with fix for #34151
 		"issue42058a.go", // go/types does not have constraints on channel element size
 		"issue42058b.go", // go/types does not have constraints on channel element size
diff --git a/src/go/types/testdata/go1_13.src b/src/go/types/testdata/go1_13.src
new file mode 100644
index 0000000000..6aa1364e8a
--- /dev/null
+++ b/src/go/types/testdata/go1_13.src
@@ -0,0 +1,22 @@
+// Copyright 2021 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.
+
+// Check Go language version-specific errors.
+
+package go1_13 // go1.13
+
+// interface embedding
+
+type I interface { m() }
+
+type _ interface {
+	m()
+	I // ERROR "duplicate method m"
+}
+
+type _ interface {
+	I
+	I // ERROR "duplicate method m"
+}
+
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index 6e89ccb027..b9249494fa 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -578,9 +578,13 @@ func (check *Checker) completeInterface(ityp *Interface) {
 			check.errorf(atPos(pos), _DuplicateDecl, "duplicate method %s", m.name)
 			check.errorf(atPos(mpos[other.(*Func)]), _DuplicateDecl, "\tother declaration of %s", m.name) // secondary error, \t indented
 		default:
-			// check method signatures after all types are computed (issue #33656)
+			// We have a duplicate method name in an embedded (not explicitly declared) method.
+			// Check method signatures after all types are computed (issue #33656).
+			// If we're pre-go1.14 (overlapping embeddings are not permitted), report that
+			// error here as well (even though we could do it eagerly) because it's the same
+			// error message.
 			check.atEnd(func() {
-				if !check.identical(m.typ, other.Type()) {
+				if !check.allowVersion(m.pkg, 1, 14) || !check.identical(m.typ, other.Type()) {
 					check.errorf(atPos(pos), _DuplicateDecl, "duplicate method %s", m.name)
 					check.errorf(atPos(mpos[other.(*Func)]), _DuplicateDecl, "\tother declaration of %s", m.name) // secondary error, \t indented
 				}
-- 
GitLab


From 5faf941df067b33485edb9cd2e880869e7feb6a3 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Thu, 3 Dec 2020 13:39:30 -0500
Subject: [PATCH 0656/2400] internal/goversion: update Version to 1.17

(The corresponding update for the last release cycle was CL 248038.)

For #40705.

Change-Id: I13becdc4c3718a1c6986876ec56879cce3bcb34f
Reviewed-on: https://go-review.googlesource.com/c/go/+/275297
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 src/internal/goversion/goversion.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/internal/goversion/goversion.go b/src/internal/goversion/goversion.go
index 513be456bd..4cc15688c0 100644
--- a/src/internal/goversion/goversion.go
+++ b/src/internal/goversion/goversion.go
@@ -9,4 +9,4 @@ package goversion
 //
 // It should be updated at the start of each development cycle to be
 // the version of the next Go 1.x release. See golang.org/issue/40705.
-const Version = 16
+const Version = 17
-- 
GitLab


From b8fb049c7ad4940901613d16629a88b38c6a82da Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 16 Feb 2021 15:55:54 -0500
Subject: [PATCH 0657/2400] [dev.regabi] cmd/go: copy internal/abi in
 TestNewReleaseRebuildsStalePackagesInGOPATH

The internal/abi package is used by runtime and needs to be
copied.

Fix longtest builders.

Change-Id: I7a962df3db2c6bf68cc6a7da74b579f381920009
Reviewed-on: https://go-review.googlesource.com/c/go/+/292592
Reviewed-by: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/go/go_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/cmd/go/go_test.go b/src/cmd/go/go_test.go
index 3ce32388d0..d14b2328bf 100644
--- a/src/cmd/go/go_test.go
+++ b/src/cmd/go/go_test.go
@@ -811,6 +811,7 @@ func TestNewReleaseRebuildsStalePackagesInGOPATH(t *testing.T) {
 	// so that we can change files.
 	for _, copydir := range []string{
 		"src/runtime",
+		"src/internal/abi",
 		"src/internal/bytealg",
 		"src/internal/cpu",
 		"src/math/bits",
-- 
GitLab


From d3cd4830adf45ce53c586a83f9d78421484737fd Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 11 Feb 2021 19:55:07 -0500
Subject: [PATCH 0658/2400] [dev.regabi] test: run abi/regabipragma test with
 -c=1

Currently, we call Warnl in SSA backend when we see a function
(defined or called) with regparams pragma. Calling Warnl in
concurrent environment is racy. As the debugging output is
temporary, for testing purposes we just pass -c=1. We'll remove
the pragma and the debugging print some time soon.

Change-Id: I6f925a665b953259453fc458490c5ff91f67c91a
Reviewed-on: https://go-review.googlesource.com/c/go/+/291710
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
---
 test/abi/regabipragma.go | 2 +-
 test/run.go              | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/abi/regabipragma.go b/test/abi/regabipragma.go
index 6a1b1938ea..e7ecd58fc8 100644
--- a/test/abi/regabipragma.go
+++ b/test/abi/regabipragma.go
@@ -1,4 +1,4 @@
-// runindir
+// runindir -gcflags=-c=1
 // +build !windows
 
 // Copyright 2021 The Go Authors. All rights reserved.
diff --git a/test/run.go b/test/run.go
index 116f983a97..dba4d16d63 100644
--- a/test/run.go
+++ b/test/run.go
@@ -902,6 +902,7 @@ func (t *test) run() {
 		if *linkshared {
 			cmd = append(cmd, "-linkshared")
 		}
+		cmd = append(cmd, flags...)
 		cmd = append(cmd, ".")
 		out, err := runcmd(cmd...)
 		if err != nil {
-- 
GitLab


From 70c37ee7d0eb68777bd81a1acc06d85ee3da4052 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 16 Feb 2021 17:55:27 -0500
Subject: [PATCH 0659/2400] cmd/compile/internal/test: gofmt abiutils_test.go

Turns out that file is not formatted properly in the dev.regabi
branch.

Change-Id: I93125e65d5d3e8448c6ec1f077332c9bf7f0dd26
Reviewed-on: https://go-review.googlesource.com/c/go/+/292594
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 src/cmd/compile/internal/test/abiutils_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/test/abiutils_test.go b/src/cmd/compile/internal/test/abiutils_test.go
index decc29667e..a0a11671e1 100644
--- a/src/cmd/compile/internal/test/abiutils_test.go
+++ b/src/cmd/compile/internal/test/abiutils_test.go
@@ -292,4 +292,4 @@ func TestABINumParamRegs(t *testing.T) {
 	nrtest(t, s, 4)
 	nrtest(t, a, 12)
 
-}
\ No newline at end of file
+}
-- 
GitLab


From 2f0da6d9e29d9b9d5a4d10427ca9f71d12bbacc8 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 16 Feb 2021 20:01:32 -0500
Subject: [PATCH 0660/2400] go/types: revert "no 'declared but not used' errors
 for invalid var decls"

This reverts commit CL 289712 (afd67f3). It breaks x/tools tests, and
those tests highlight that perhaps I didn't think through the
repercussions of this change as much as I should have.

Fixes #44316

Change-Id: I5db39b4e2a3714131aa22423abfe0f34a0376192
Reviewed-on: https://go-review.googlesource.com/c/go/+/292751
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/go/types/assignments.go       |  1 -
 src/go/types/decl.go              | 14 --------------
 src/go/types/testdata/vardecl.src | 14 +-------------
 3 files changed, 1 insertion(+), 28 deletions(-)

diff --git a/src/go/types/assignments.go b/src/go/types/assignments.go
index d6f18c9bee..616564b567 100644
--- a/src/go/types/assignments.go
+++ b/src/go/types/assignments.go
@@ -120,7 +120,6 @@ func (check *Checker) initVar(lhs *Var, x *operand, context string) Type {
 		if lhs.typ == nil {
 			lhs.typ = Typ[Invalid]
 		}
-		lhs.used = true
 		return nil
 	}
 
diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index b861cde496..6462edbd75 100644
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -504,20 +504,6 @@ func (check *Checker) constDecl(obj *Const, typ, init ast.Expr, inherited bool)
 func (check *Checker) varDecl(obj *Var, lhs []*Var, typ, init ast.Expr) {
 	assert(obj.typ == nil)
 
-	// If we have undefined variable types due to errors,
-	// mark variables as used to avoid follow-on errors.
-	// Matches compiler behavior.
-	defer func() {
-		if obj.typ == Typ[Invalid] {
-			obj.used = true
-		}
-		for _, lhs := range lhs {
-			if lhs.typ == Typ[Invalid] {
-				lhs.used = true
-			}
-		}
-	}()
-
 	// determine type, if any
 	if typ != nil {
 		obj.typ = check.typ(typ)
diff --git a/src/go/types/testdata/vardecl.src b/src/go/types/testdata/vardecl.src
index 6e2d1b5bd5..54f5ef1e10 100644
--- a/src/go/types/testdata/vardecl.src
+++ b/src/go/types/testdata/vardecl.src
@@ -158,18 +158,6 @@ func _() {
 	}
 }
 
-
-// Invalid variable declarations must not lead to "declared but not used errors".
-func _() {
-	var a x        // ERROR undeclared name: x
-	var b = x      // ERROR undeclared name: x
-	var c int = x  // ERROR undeclared name: x
-	var d, e, f x  /* ERROR x */ /* ERROR x */ /* ERROR x */
-	var g, h, i = x /* ERROR x */, x /* ERROR x */, x /* ERROR x */
-	var j, k, l float32 = x /* ERROR x */, x /* ERROR x */, x /* ERROR x */
-	// but no "declared but not used" errors
-}
-
 // Invalid (unused) expressions must not lead to spurious "declared but not used errors"
 func _() {
 	var a, b, c int
@@ -215,4 +203,4 @@ func _() {
 	_, _, _ = x, y, z
 }
 
-// TODO(gri) consolidate other var decl checks in this file
+// TODO(gri) consolidate other var decl checks in this file
\ No newline at end of file
-- 
GitLab


From e196cb8258647652f552757d024b261731d95218 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Tue, 16 Feb 2021 18:24:48 -0800
Subject: [PATCH 0661/2400] [dev.typeparams] cmd/dist:  disable -G=3 on the std
 go tests for now

Disable -G=3 tests on the std go tests, in order to see if -G=3 is
causing the flakiness for the dev.typeparams builder, as opposed to
other changes in typeparams branch. It's possible that -G=3 is using
more CPU/RAM that causes flakiness, as opposed to more specific bugs.

Change-Id: I610bce2aabd26b2b1fddc5e63f85ffe4e958e0d8
Reviewed-on: https://go-review.googlesource.com/c/go/+/292850
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Dan Scales <danscales@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/dist/test.go | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go
index 365a77a156..2b1f82246a 100644
--- a/src/cmd/dist/test.go
+++ b/src/cmd/dist/test.go
@@ -444,8 +444,12 @@ func (t *tester) registerTests() {
 			fatalf("Error running go list std cmd: %v:\n%s", err, cmd.Stderr)
 		}
 		pkgs := strings.Fields(string(all))
-		for _, pkg := range pkgs {
-			t.registerStdTest(pkg, true)
+		if false {
+			// Disable -G=3 option for standard tests for now, since
+			// they are flaky on the builder.
+			for _, pkg := range pkgs {
+				t.registerStdTest(pkg, true /* -G=3 flag */)
+			}
 		}
 		for _, pkg := range pkgs {
 			t.registerStdTest(pkg, false)
-- 
GitLab


From 07ef3135253321176704bce6e629a07ac02bf1c6 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Wed, 17 Feb 2021 12:03:13 -0800
Subject: [PATCH 0662/2400] runtime/cgo: add cast in C code to avoid C compiler
 warning

Fixes #44340

Change-Id: Id80dd1f44a988b653933732afcc8e49a826affc4
Reviewed-on: https://go-review.googlesource.com/c/go/+/293209
Reviewed-by: Andrew G. Morgan <agm@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
---
 src/runtime/cgo/linux_syscall.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/cgo/linux_syscall.c b/src/runtime/cgo/linux_syscall.c
index 56f3d67d8b..59761c8b40 100644
--- a/src/runtime/cgo/linux_syscall.c
+++ b/src/runtime/cgo/linux_syscall.c
@@ -32,7 +32,7 @@ typedef struct {
 
 #define SET_RETVAL(fn) \
   uintptr_t ret = (uintptr_t) fn ; \
-  if (ret == -1) {                 \
+  if (ret == (uintptr_t) -1) {	   \
     x->retval = (uintptr_t) errno; \
   } else                           \
     x->retval = ret
-- 
GitLab


From f0be3cc5476bd726707985a6382ae6a2d6fa8968 Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Wed, 17 Feb 2021 20:34:34 +1100
Subject: [PATCH 0663/2400] runtime: unbreak linux/riscv64 following regabi
 merge

Unbreak the linux/riscv64 port by storing the zero value register to memory,
rather than the current code that is moving a zero intermediate to the stack
pointer register (ideally this should be caught by the assembler). This was
broken in CL#272568.

On riscv64 a zero immediate value cannot be moved directly to memory, rather
a register needs to be loaded with zero and then stored. Alternatively, the
the zero value register (aka X0) can be used directly.

Change-Id: Id57121541d50c9993cec5c2270b638b184ab9bc1
Reviewed-on: https://go-review.googlesource.com/c/go/+/292894
Trust: Joel Sing <joel@sing.id.au>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/asm_riscv64.s | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/asm_riscv64.s b/src/runtime/asm_riscv64.s
index 31e324d677..3d0349471a 100644
--- a/src/runtime/asm_riscv64.s
+++ b/src/runtime/asm_riscv64.s
@@ -449,7 +449,7 @@ TEXT callRet<>(SB), NOSPLIT, $40-0
 	MOV	A1, 16(X2)
 	MOV	A3, 24(X2)
 	MOV	A2, 32(X2)
-	MOV	$0, 40(X2)
+	MOV	ZERO, 40(X2)
 	CALL	runtime·reflectcallmove(SB)
 	RET
 
-- 
GitLab


From 7b679617f3bb532fe65d8e83365b9f1f41b01b00 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 11 Feb 2021 11:54:46 -0500
Subject: [PATCH 0664/2400] [dev.typeparams] go/types: conversions to type
 parameters are not constant

This is a port of CL 290471 to go/types. However, this change preserves
the existing check for constant types in recordTypeAndValue, which uses
is(..., isConstType) rather than the isConstType predicate. In types2,
this code path is not hit with type parameters because convertUntyped
walks the type list in order before calling updateExprType with the type
parameter, at which point the expression type would have already been
recorded as the first element of the type list -- probably something
that should be corrected.

Longer term, I believe we actually could allow const type parameters if
the optype is a sum of constant types.

Change-Id: Iaa91ffa740b5f08a5696bd96918a866bffd7aef6
Reviewed-on: https://go-review.googlesource.com/c/go/+/291323
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/check.go           |  4 +++-
 src/go/types/examples/types.go2 | 17 +++++++++++++++++
 src/go/types/predicates.go      |  9 +++++++--
 3 files changed, 27 insertions(+), 3 deletions(-)

diff --git a/src/go/types/check.go b/src/go/types/check.go
index 57c6a2e7b8..4cc3024de9 100644
--- a/src/go/types/check.go
+++ b/src/go/types/check.go
@@ -340,7 +340,9 @@ func (check *Checker) recordTypeAndValue(x ast.Expr, mode operandMode, typ Type,
 	}
 	if mode == constant_ {
 		assert(val != nil)
-		assert(typ == Typ[Invalid] || isConstType(typ))
+		// We check is(typ, IsConstType) here as constant expressions may be
+		// recorded as type parameters.
+		assert(typ == Typ[Invalid] || is(typ, IsConstType))
 	}
 	if m := check.Types; m != nil {
 		m[x] = TypeAndValue{mode, typ, val}
diff --git a/src/go/types/examples/types.go2 b/src/go/types/examples/types.go2
index 4dba4f0e57..20abefbe05 100644
--- a/src/go/types/examples/types.go2
+++ b/src/go/types/examples/types.go2
@@ -267,3 +267,20 @@ func _() {
 	var _ comparable /* ERROR comparable */
 	var _ C /* ERROR comparable */
 }
+
+// Type parameters are never const types, i.e., it's
+// not possible to declare a constant of type parameter type.
+// (If a type list contains just a single const type, we could
+// allow it, but such type lists don't make much sense in the
+// first place.)
+func _[T interface { type int, float64 }]() {
+	// not valid
+	const _ = T /* ERROR not constant */ (0)
+	const _ T /* ERROR invalid constant type T */ = 1
+
+	// valid
+	var _ = T(0)
+	var _ T = 1
+	_ = T(0)
+}
+
diff --git a/src/go/types/predicates.go b/src/go/types/predicates.go
index 7a99c1ff99..0ff8fcbbf7 100644
--- a/src/go/types/predicates.go
+++ b/src/go/types/predicates.go
@@ -73,8 +73,13 @@ func isUntyped(typ Type) bool {
 	return !isTyped(typ)
 }
 
-func isOrdered(typ Type) bool   { return is(typ, IsOrdered) }
-func isConstType(typ Type) bool { return is(typ, IsConstType) }
+func isOrdered(typ Type) bool { return is(typ, IsOrdered) }
+
+func isConstType(typ Type) bool {
+	// Type parameters are never const types.
+	t, _ := under(typ).(*Basic)
+	return t != nil && t.info&IsConstType != 0
+}
 
 // IsInterface reports whether typ is an interface type.
 func IsInterface(typ Type) bool {
-- 
GitLab


From 609d82b28992e6a7fac48add680f170c4eee83fd Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Fri, 12 Feb 2021 21:34:11 +0100
Subject: [PATCH 0665/2400] cmd/dist: set GOARM=7 for windows/arm

GOARM=6 executables fail to launch on windows/arm, so set this to ARMv7
like we do for Android.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.

Change-Id: Ifa13685e7ab6edd367f3dfec10296e376319dbd4
Reviewed-on: https://go-review.googlesource.com/c/go/+/291629
Reviewed-by: Russ Cox <rsc@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/dist/util.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/cmd/dist/util.go b/src/cmd/dist/util.go
index 0a419e465f..e99375f538 100644
--- a/src/cmd/dist/util.go
+++ b/src/cmd/dist/util.go
@@ -389,6 +389,10 @@ func xgetgoarm() string {
 		// sense to auto-detect the setting.
 		return "7"
 	}
+	if goos == "windows" {
+		// windows/arm only works with ARMv7 executables.
+		return "7"
+	}
 	if gohostarch != "arm" || goos != gohostos {
 		// Conservative default for cross-compilation.
 		return "5"
-- 
GitLab


From a76efea1fe18045ecb8d1cf2c1104208e636fbae Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Thu, 28 Jan 2021 10:18:24 -0500
Subject: [PATCH 0666/2400] cmd/go/internal/mvs: don't emit duplicates from Req
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Req is supposed to return “a minimal requirement list”
that includes each of the module paths listed in base.
Currently, if base contains duplicates Req emits duplicates,
and a list containing duplicates is certainly not minimal.

That, in turn, requires callers to be careful to deduplicate the base
slice, and there are multiple callers that are already quite
complicated to reason about even without the added complication of
deduplicating slices.

For #36460

Change-Id: I391a1dc0641fe1dd424c16b7a1082da0d00c7292
Reviewed-on: https://go-review.googlesource.com/c/go/+/287632
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/mvs/mvs.go      |  5 +++++
 src/cmd/go/internal/mvs/mvs_test.go | 13 +++++++++++++
 2 files changed, 18 insertions(+)

diff --git a/src/cmd/go/internal/mvs/mvs.go b/src/cmd/go/internal/mvs/mvs.go
index b630b610f1..f016d8ff15 100644
--- a/src/cmd/go/internal/mvs/mvs.go
+++ b/src/cmd/go/internal/mvs/mvs.go
@@ -293,10 +293,15 @@ func Req(target module.Version, base []string, reqs Reqs) ([]module.Version, err
 	}
 	// First walk the base modules that must be listed.
 	var min []module.Version
+	haveBase := map[string]bool{}
 	for _, path := range base {
+		if haveBase[path] {
+			continue
+		}
 		m := module.Version{Path: path, Version: max[path]}
 		min = append(min, m)
 		walk(m)
+		haveBase[path] = true
 	}
 	// Now the reverse postorder to bring in anything else.
 	for i := len(postorder) - 1; i >= 0; i-- {
diff --git a/src/cmd/go/internal/mvs/mvs_test.go b/src/cmd/go/internal/mvs/mvs_test.go
index 721cd9635c..995a38fa92 100644
--- a/src/cmd/go/internal/mvs/mvs_test.go
+++ b/src/cmd/go/internal/mvs/mvs_test.go
@@ -327,6 +327,19 @@ B1: Cnone D1
 E1: Fnone
 build M: M B1 D1 E1
 req M: B1 E1
+
+name: reqdup
+M: A1 B1
+A1: B1
+B1:
+req M A A: A1
+
+name: reqcross
+M: A1 B1 C1
+A1: B1 C1
+B1: C1
+C1:
+req M A B: A1 B1
 `
 
 func Test(t *testing.T) {
-- 
GitLab


From a5c8a15f649ffe29b3a80144e6d422046adb2cf0 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Thu, 28 Jan 2021 17:01:54 -0500
Subject: [PATCH 0667/2400] cmd/go/internal/mvs: clarify and annotate test
 cases

For #36460

Change-Id: I5a8be8f36fb8825ffa08ed1427cb1e15b106b31a
Reviewed-on: https://go-review.googlesource.com/c/go/+/287732
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/mvs/mvs_test.go | 94 ++++++++++++++++++++++-------
 1 file changed, 72 insertions(+), 22 deletions(-)

diff --git a/src/cmd/go/internal/mvs/mvs_test.go b/src/cmd/go/internal/mvs/mvs_test.go
index 995a38fa92..b8ff3bd8c2 100644
--- a/src/cmd/go/internal/mvs/mvs_test.go
+++ b/src/cmd/go/internal/mvs/mvs_test.go
@@ -28,9 +28,11 @@ D4: E2 F1
 D5: E2
 G1: C4
 A2: B1 C4 D4
-build A: A B1 C2 D4 E2 F1
-upgrade* A: A B1 C4 D5 E2 F1 G1
-upgrade A C4: A B1 C4 D4 E2 F1 G1
+build A:       A B1 C2 D4 E2 F1
+upgrade* A:    A B1 C4 D5 E2 F1 G1
+upgrade A C4:  A B1 C4 D4 E2 F1 G1
+build A2:     A2 B1 C4 D4 E2 F1 G1
+# BUG: selected versions E2 and F1 are not preserved.
 downgrade A2 D2: A2 C4 D2
 
 name: trim
@@ -68,7 +70,7 @@ B2: D1
 C: D2
 D1: E2
 D2: E1
-build A: A B1 C D2 E1
+build A:      A B1 C D2 E1
 upgrade A B2: A B2 C D2 E2
 
 name: cross1R
@@ -136,17 +138,17 @@ name: cross5
 A: D1
 D1: E2
 D2: E1
-build A: A D1 E2
-upgrade* A: A D2 E2
-upgrade A D2: A D2 E2
+build A:       A D1 E2
+upgrade* A:    A D2 E2
+upgrade A D2:  A D2 E2
 upgradereq A D2: D2 E2
 
 name: cross6
 A: D2
 D1: E2
 D2: E1
-build A: A D2 E1
-upgrade* A: A D2 E2
+build A:      A D2 E1
+upgrade* A:   A D2 E2
 upgrade A E2: A D2 E2
 
 name: cross7
@@ -175,7 +177,7 @@ B1: D1
 B2:
 C2:
 D2:
-build A: A B1 C1 D1
+build A:    A B1 C1 D1
 upgrade* A: A B2 C2 D2
 
 name: simplify
@@ -194,7 +196,7 @@ B4:
 B5.hidden:
 C2:
 C3:
-build A: A B1 C1
+build A:    A B1 C1
 upgrade* A: A B4 C3
 
 name: up2
@@ -206,14 +208,15 @@ B4:
 B5.hidden:
 C2:
 C3:
-build A: A B5.hidden C1
+build A:    A B5.hidden C1
 upgrade* A: A B5.hidden C3
 
 name: down1
 A: B2
 B1: C1
 B2: C2
-build A: A B2 C2
+build A:        A B2 C2
+# BUG: build list from downgrade omits selected version C1.
 downgrade A C1: A B1
 
 name: down2
@@ -227,12 +230,56 @@ D2: B2
 E2: D2
 E1:
 F1:
+build A:        A B2 C2 D2 E2 F2
+# BUG: selected versions C1 and D1 are not preserved, and
+# requested version F1 is not selected.
 downgrade A F1: A B1 E1
 
+# https://research.swtch.com/vgo-mvs#algorithm_4:
+# “[D]owngrades are constrained to only downgrade packages, not also upgrade
+# them; if an upgrade before downgrade is needed, the user must ask for it
+# explicitly.”
+#
+# Here, downgrading B2 to B1 upgrades C1 to C2, and C2 does not depend on D2.
+# However, C2 would be an upgrade — not a downgrade — so B1 must also be
+# rejected.
+name: downcross1
+A: B2 C1
+B1: C2
+B2: C1
+C1: D2
+C2:
+D1:
+D2:
+build A:        A B2 C1 D2
+# BUG: requested version D1 is not selected.
+downgrade A D1: A
+
+# https://research.swtch.com/vgo-mvs#algorithm_4:
+# “Unlike upgrades, downgrades must work by removing requirements, not adding
+# them.”
+#
+# However, downgrading a requirement may introduce a new requirement on a
+# previously-unrequired module. If each dependency's requirements are complete
+# (“tidy”), that can't change the behavior of any other package whose version is
+# not also being downgraded, so we should allow it.
+name: downcross2
+A: B2
+B1: C1
+B2: D2
+C1:
+D1:
+D2:
+build A:        A B2 D2
+# BUG: requested version D1 is not selected,
+# and selected version C1 is omitted from the returned build list.
+downgrade A D1: A B1
+
 name: downcycle
 A: A B2
 B2: A
 B1:
+build A:        A B2
 downgrade A B1: A B1
 
 # golang.org/issue/25542.
@@ -240,6 +287,7 @@ name: noprev1
 A: B4 C2
 B2.hidden:
 C2:
+build A:               A B4        C2
 downgrade A B2.hidden: A B2.hidden C2
 
 name: noprev2
@@ -247,6 +295,7 @@ A: B4 C2
 B2.hidden:
 B1:
 C2:
+build A:               A B4        C2
 downgrade A B2.hidden: A B2.hidden C2
 
 name: noprev3
@@ -254,6 +303,7 @@ A: B4 C2
 B3:
 B2.hidden:
 C2:
+build A:               A B4        C2
 downgrade A B2.hidden: A B2.hidden C2
 
 # Cycles involving the target.
@@ -264,9 +314,9 @@ A: B1
 B1: A1
 B2: A2
 B3: A3
-build A: A B1
+build A:      A B1
 upgrade A B2: A B2
-upgrade* A: A B3
+upgrade* A:   A B3
 
 # golang.org/issue/29773:
 # Requirements of older versions of the target
@@ -280,7 +330,7 @@ B2: A2
 C1: A2
 C2:
 D2:
-build A: A B1 C1 D1
+build A:    A B1 C1 D1
 upgrade* A: A B2 C2 D2
 
 # Cycles with multiple possible solutions.
@@ -293,23 +343,23 @@ B2: C2
 C1:
 C2: B2
 build M: M A1 B2 C2
-req M: A1 B2
-req M A: A1 B2
-req M C: A1 C2
+req M:     A1 B2
+req M A:   A1 B2
+req M C:   A1 C2
 
 # Requirement minimization.
 
 name: req1
 A: B1 C1 D1 E1 F1
 B1: C1 E1 F1
-req A: B1 D1
+req A:   B1    D1
 req A C: B1 C1 D1
 
 name: req2
 A: G1 H1
 G1: H1
 H1: G1
-req A: G1
+req A:   G1
 req A G: G1
 req A H: H1
 
@@ -326,7 +376,7 @@ M: Anone B1 D1 E1
 B1: Cnone D1
 E1: Fnone
 build M: M B1 D1 E1
-req M: B1 E1
+req M:     B1    E1
 
 name: reqdup
 M: A1 B1
-- 
GitLab


From f3c2208e2cca69911fa72c22211361a6a57f4e26 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 29 Jan 2021 21:02:46 -0500
Subject: [PATCH 0668/2400] cmd/go: add script tests for potential upgrades due
 to downgrades

For #36460

Change-Id: I1620c23819263ef82e571fc4d4c778277842c02d
Reviewed-on: https://go-review.googlesource.com/c/go/+/288535
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 .../script/mod_get_downadd_indirect.txt       |  81 ++++++++++++++
 .../script/mod_get_downup_indirect.txt        | 101 ++++++++++++++++++
 2 files changed, 182 insertions(+)
 create mode 100644 src/cmd/go/testdata/script/mod_get_downadd_indirect.txt
 create mode 100644 src/cmd/go/testdata/script/mod_get_downup_indirect.txt

diff --git a/src/cmd/go/testdata/script/mod_get_downadd_indirect.txt b/src/cmd/go/testdata/script/mod_get_downadd_indirect.txt
new file mode 100644
index 0000000000..efc38f77c8
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_get_downadd_indirect.txt
@@ -0,0 +1,81 @@
+# This test illustrates a case where downgrading one module may upgrade another.
+# Compare to the downcross2 test case in cmd/go/internal/mvs/mvs_test.go.
+
+# The initial package import graph used in this test looks like:
+#
+# a ---- b ---- d
+#
+# The module dependency graph originally looks like:
+#
+# a ---- b.2 ---- d.2
+#
+# b.1 ---- c.1
+#
+# If we downgrade module d to version 1, we must downgrade b as well.
+# If that downgrade selects b version 1, we will add a new dependency on module c.
+
+cp go.mod go.mod.orig
+go mod tidy
+cmp go.mod.orig go.mod
+
+go get -d example.com/d@v0.1.0
+go list -m all
+stdout '^example.com/b v0.1.0 '
+stdout '^example.com/c v0.1.0 '
+stdout '^example.com/d v0.1.0 '
+
+-- go.mod --
+module example.com/a
+
+go 1.15
+
+require example.com/b v0.2.0
+
+replace (
+	example.com/b v0.1.0 => ./b1
+	example.com/b v0.2.0 => ./b2
+	example.com/c v0.1.0 => ./c
+	example.com/d v0.1.0 => ./d
+	example.com/d v0.2.0 => ./d
+)
+-- a.go --
+package a
+
+import _ "example.com/b"
+
+-- b1/go.mod --
+module example.com/b
+
+go 1.15
+
+require example.com/c v0.1.0
+-- b1/b.go --
+package b
+
+import _ "example.com/c"
+
+-- b2/go.mod --
+module example.com/b
+
+go 1.15
+
+require example.com/d v0.2.0
+-- b2/b.go --
+package b
+
+import _ "example.com/d"
+
+-- c/go.mod --
+module example.com/c
+
+go 1.15
+
+-- c/c.go --
+package c
+
+-- d/go.mod --
+module example.com/d
+
+go 1.15
+-- d/d.go --
+package d
diff --git a/src/cmd/go/testdata/script/mod_get_downup_indirect.txt b/src/cmd/go/testdata/script/mod_get_downup_indirect.txt
new file mode 100644
index 0000000000..ced1dcd6b1
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_get_downup_indirect.txt
@@ -0,0 +1,101 @@
+# This test illustrates a case where downgrading one module may upgrade another.
+# Compare to the downcross1 test case in cmd/go/internal/mvs/mvs_test.go.
+
+# The package import graph used in this test looks like:
+#
+# a ---- b
+#   \     \
+#    \     \
+#     ----- c ---- d
+#
+# The module dependency graph originally looks like:
+#
+# a ---- b.2
+#   \      \
+#    \      \
+#     ----- c.1 ---- d.2
+#
+# b.1 ---- c.2
+#
+# If we downgrade module d to version 1, we must downgrade b as well.
+# If that downgrade selects b version 1, we will upgrade module c to version 2.
+# So 'go get d@1' should instead downgrade both b and c to "none".
+
+cp go.mod go.mod.orig
+go mod tidy
+cmp go.mod.orig go.mod
+
+go get -d example.com/d@v0.1.0
+go list -m all
+! stdout '^example.com/b '
+! stdout '^example.com/c '
+stdout '^example.com/d v0.1.0 '
+
+-- go.mod --
+module example.com/a
+
+go 1.15
+
+require (
+	example.com/b v0.2.0
+	example.com/c v0.1.0
+)
+
+replace (
+	example.com/b v0.1.0 => ./b1
+	example.com/b v0.2.0 => ./b2
+	example.com/c v0.1.0 => ./c1
+	example.com/c v0.2.0 => ./c2
+	example.com/d v0.1.0 => ./d
+	example.com/d v0.2.0 => ./d
+)
+-- a.go --
+package a
+
+import (
+	_ "example.com/b"
+	_ "example.com/c"
+)
+
+-- b1/go.mod --
+module example.com/b
+
+go 1.15
+
+require example.com/c v0.2.0
+-- b1/b.go --
+package b
+
+import _ "example.com/c"
+
+-- b2/go.mod --
+module example.com/b
+
+go 1.15
+
+require example.com/c v0.1.0
+-- b2/b.go --
+package b
+
+import _ "example.com/c"
+
+-- c1/go.mod --
+module example.com/c
+
+go 1.15
+
+require example.com/d v0.2.0
+-- c1/c.go --
+package c
+
+-- c2/go.mod --
+module example.com/c
+
+go 1.15
+-- c2/c.go --
+package c
+
+-- d/go.mod --
+module example.com/d
+
+go 1.15
-- 
GitLab


From 5ecb9a788716be799d73c5d8192368ecb9557d48 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 16 Feb 2021 19:56:38 -0500
Subject: [PATCH 0669/2400] [dev.typeparams] go/types: use a new ast.ListExpr
 for multi-type instances

Modify go/parser to consistently represent type instantiation as an
ast.IndexExpr, rather than use an ast.CallExpr (with Brackets:true) for
instantiations with multiple type parameters. To enable this, introduce
a new ast expr type: ListExpr.

This brings go/types in line with types2, with the exception of a small
change to funcInst to eliminate redundant errors if values are
erroneously used as types. In a subsequent CL, call.go and expr.go will
be marked as reviewed.

This also catches some type instance syntax using '()' that was
previously accepted incorrectly. Tests are updated accordingly.

Change-Id: I30cd0181c7608f1be7486a9a8b63df993b412e85
Reviewed-on: https://go-review.googlesource.com/c/go/+/293010
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/ast/ast.go                    |  47 ++++--
 src/go/ast/example_test.go           |  33 +++--
 src/go/parser/parser.go              |  15 +-
 src/go/printer/nodes.go              |  43 +++---
 src/go/types/api_test.go             |   4 +-
 src/go/types/assignments.go          |  14 ++
 src/go/types/call.go                 | 205 +++++++++++++--------------
 src/go/types/examples/functions.go2  |   4 +-
 src/go/types/expr.go                 |   5 +-
 src/go/types/exprstring.go           |  16 ++-
 src/go/types/resolver.go             |   9 +-
 src/go/types/testdata/issues.go2     |   8 +-
 src/go/types/testdata/typeparams.go2 |  12 +-
 src/go/types/typexpr.go              |  42 +++---
 14 files changed, 232 insertions(+), 225 deletions(-)

diff --git a/src/go/ast/ast.go b/src/go/ast/ast.go
index 2456020c5e..6eb4d13f4d 100644
--- a/src/go/ast/ast.go
+++ b/src/go/ast/ast.go
@@ -372,9 +372,13 @@ type (
 		Args     []Expr    // function arguments; or nil
 		Ellipsis token.Pos // position of "..." (token.NoPos if there is no "...")
 		Rparen   token.Pos // position of ")"
-		// TODO(rFindley) use a new ListExpr type rather than overloading CallExpr
-		//                via Brackets, as is done in the syntax package
-		Brackets bool // if set, "[" and "]" are used instead of "(" and ")"
+	}
+
+	// A ListExpr node represents a list of expressions separated by commas.
+	// ListExpr nodes are used as index in IndexExpr nodes representing type
+	// or function instantiations with more than one type argument.
+	ListExpr struct {
+		ElemList []Expr
 	}
 
 	// A StarExpr node represents an expression of the form "*" Expression.
@@ -493,12 +497,18 @@ func (x *IndexExpr) Pos() token.Pos      { return x.X.Pos() }
 func (x *SliceExpr) Pos() token.Pos      { return x.X.Pos() }
 func (x *TypeAssertExpr) Pos() token.Pos { return x.X.Pos() }
 func (x *CallExpr) Pos() token.Pos       { return x.Fun.Pos() }
-func (x *StarExpr) Pos() token.Pos       { return x.Star }
-func (x *UnaryExpr) Pos() token.Pos      { return x.OpPos }
-func (x *BinaryExpr) Pos() token.Pos     { return x.X.Pos() }
-func (x *KeyValueExpr) Pos() token.Pos   { return x.Key.Pos() }
-func (x *ArrayType) Pos() token.Pos      { return x.Lbrack }
-func (x *StructType) Pos() token.Pos     { return x.Struct }
+func (x *ListExpr) Pos() token.Pos {
+	if len(x.ElemList) > 0 {
+		return x.ElemList[0].Pos()
+	}
+	return token.NoPos
+}
+func (x *StarExpr) Pos() token.Pos     { return x.Star }
+func (x *UnaryExpr) Pos() token.Pos    { return x.OpPos }
+func (x *BinaryExpr) Pos() token.Pos   { return x.X.Pos() }
+func (x *KeyValueExpr) Pos() token.Pos { return x.Key.Pos() }
+func (x *ArrayType) Pos() token.Pos    { return x.Lbrack }
+func (x *StructType) Pos() token.Pos   { return x.Struct }
 func (x *FuncType) Pos() token.Pos {
 	if x.Func.IsValid() || x.Params == nil { // see issue 3870
 		return x.Func
@@ -526,12 +536,18 @@ func (x *IndexExpr) End() token.Pos      { return x.Rbrack + 1 }
 func (x *SliceExpr) End() token.Pos      { return x.Rbrack + 1 }
 func (x *TypeAssertExpr) End() token.Pos { return x.Rparen + 1 }
 func (x *CallExpr) End() token.Pos       { return x.Rparen + 1 }
-func (x *StarExpr) End() token.Pos       { return x.X.End() }
-func (x *UnaryExpr) End() token.Pos      { return x.X.End() }
-func (x *BinaryExpr) End() token.Pos     { return x.Y.End() }
-func (x *KeyValueExpr) End() token.Pos   { return x.Value.End() }
-func (x *ArrayType) End() token.Pos      { return x.Elt.End() }
-func (x *StructType) End() token.Pos     { return x.Fields.End() }
+func (x *ListExpr) End() token.Pos {
+	if len(x.ElemList) > 0 {
+		return x.ElemList[len(x.ElemList)-1].End()
+	}
+	return token.NoPos
+}
+func (x *StarExpr) End() token.Pos     { return x.X.End() }
+func (x *UnaryExpr) End() token.Pos    { return x.X.End() }
+func (x *BinaryExpr) End() token.Pos   { return x.Y.End() }
+func (x *KeyValueExpr) End() token.Pos { return x.Value.End() }
+func (x *ArrayType) End() token.Pos    { return x.Elt.End() }
+func (x *StructType) End() token.Pos   { return x.Fields.End() }
 func (x *FuncType) End() token.Pos {
 	if x.Results != nil {
 		return x.Results.End()
@@ -557,6 +573,7 @@ func (*IndexExpr) exprNode()      {}
 func (*SliceExpr) exprNode()      {}
 func (*TypeAssertExpr) exprNode() {}
 func (*CallExpr) exprNode()       {}
+func (*ListExpr) exprNode()       {}
 func (*StarExpr) exprNode()       {}
 func (*UnaryExpr) exprNode()      {}
 func (*BinaryExpr) exprNode()     {}
diff --git a/src/go/ast/example_test.go b/src/go/ast/example_test.go
index c2b35205bb..e3013f64be 100644
--- a/src/go/ast/example_test.go
+++ b/src/go/ast/example_test.go
@@ -119,23 +119,22 @@ func main() {
 	//     40  .  .  .  .  .  .  .  }
 	//     41  .  .  .  .  .  .  .  Ellipsis: -
 	//     42  .  .  .  .  .  .  .  Rparen: 4:25
-	//     43  .  .  .  .  .  .  .  Brackets: false
-	//     44  .  .  .  .  .  .  }
-	//     45  .  .  .  .  .  }
-	//     46  .  .  .  .  }
-	//     47  .  .  .  .  Rbrace: 5:1
-	//     48  .  .  .  }
-	//     49  .  .  }
-	//     50  .  }
-	//     51  .  Scope: *ast.Scope {
-	//     52  .  .  Objects: map[string]*ast.Object (len = 1) {
-	//     53  .  .  .  "main": *(obj @ 11)
-	//     54  .  .  }
-	//     55  .  }
-	//     56  .  Unresolved: []*ast.Ident (len = 1) {
-	//     57  .  .  0: *(obj @ 29)
-	//     58  .  }
-	//     59  }
+	//     43  .  .  .  .  .  .  }
+	//     44  .  .  .  .  .  }
+	//     45  .  .  .  .  }
+	//     46  .  .  .  .  Rbrace: 5:1
+	//     47  .  .  .  }
+	//     48  .  .  }
+	//     49  .  }
+	//     50  .  Scope: *ast.Scope {
+	//     51  .  .  Objects: map[string]*ast.Object (len = 1) {
+	//     52  .  .  .  "main": *(obj @ 11)
+	//     53  .  .  }
+	//     54  .  }
+	//     55  .  Unresolved: []*ast.Ident (len = 1) {
+	//     56  .  .  0: *(obj @ 29)
+	//     57  .  }
+	//     58  }
 }
 
 // This example illustrates how to remove a variable declaration
diff --git a/src/go/parser/parser.go b/src/go/parser/parser.go
index ccbcef8f26..e12eee79bf 100644
--- a/src/go/parser/parser.go
+++ b/src/go/parser/parser.go
@@ -754,7 +754,7 @@ func (p *parser) parseArrayFieldOrTypeInstance(x *ast.Ident) (*ast.Ident, ast.Ex
 	}
 
 	// x[P], x[P1, P2], ...
-	return nil, &ast.CallExpr{Fun: x, Lparen: lbrack, Args: args, Rparen: rbrack, Brackets: true}
+	return nil, &ast.IndexExpr{X: x, Lbrack: lbrack, Index: &ast.ListExpr{ElemList: args}, Rbrack: rbrack}
 }
 
 func (p *parser) parseFieldDecl(scope *ast.Scope) *ast.Field {
@@ -1153,7 +1153,7 @@ func (p *parser) parseMethodSpec(scope *ast.Scope) *ast.Field {
 					p.exprLev--
 				}
 				rbrack := p.expectClosing(token.RBRACK, "type argument list")
-				typ = &ast.CallExpr{Fun: ident, Lparen: lbrack, Args: list, Rparen: rbrack, Brackets: true}
+				typ = &ast.IndexExpr{X: ident, Lbrack: lbrack, Index: &ast.ListExpr{ElemList: list}, Rbrack: rbrack}
 			}
 		case p.tok == token.LPAREN:
 			// ordinary method
@@ -1281,7 +1281,7 @@ func (p *parser) parseTypeInstance(typ ast.Expr) ast.Expr {
 
 	closing := p.expectClosing(token.RBRACK, "type argument list")
 
-	return &ast.CallExpr{Fun: typ, Lparen: opening, Args: list, Rparen: closing, Brackets: true}
+	return &ast.IndexExpr{X: typ, Lbrack: opening, Index: &ast.ListExpr{ElemList: list}, Rbrack: closing}
 }
 
 // If the result is an identifier, it is not resolved.
@@ -1557,7 +1557,7 @@ func (p *parser) parseIndexOrSliceOrInstance(x ast.Expr) ast.Expr {
 	}
 
 	// instance expression
-	return &ast.CallExpr{Fun: x, Lparen: lbrack, Args: args, Rparen: rbrack, Brackets: true}
+	return &ast.IndexExpr{X: x, Lbrack: lbrack, Index: &ast.ListExpr{ElemList: args}, Rbrack: rbrack}
 }
 
 func (p *parser) parseCallOrConversion(fun ast.Expr) *ast.CallExpr {
@@ -1773,17 +1773,12 @@ func (p *parser) parsePrimaryExpr(lhs bool) (x ast.Expr) {
 			// type; accept it but complain if we have a complit
 			t := unparen(x)
 			// determine if '{' belongs to a composite literal or a block statement
-			switch t := t.(type) {
+			switch t.(type) {
 			case *ast.BadExpr, *ast.Ident, *ast.SelectorExpr:
 				if p.exprLev < 0 {
 					return
 				}
 				// x is possibly a composite literal type
-			case *ast.CallExpr:
-				if !t.Brackets || p.exprLev < 0 {
-					return
-				}
-				// x is possibly a composite literal type
 			case *ast.IndexExpr:
 				if p.exprLev < 0 {
 					return
diff --git a/src/go/printer/nodes.go b/src/go/printer/nodes.go
index cc795532b0..1c0a14ec15 100644
--- a/src/go/printer/nodes.go
+++ b/src/go/printer/nodes.go
@@ -870,7 +870,11 @@ func (p *printer) expr1(expr ast.Expr, prec1, depth int) {
 		// TODO(gri): should treat[] like parentheses and undo one level of depth
 		p.expr1(x.X, token.HighestPrec, 1)
 		p.print(x.Lbrack, token.LBRACK)
-		p.expr0(x.Index, depth+1)
+		if e, _ := x.Index.(*ast.ListExpr); e != nil {
+			p.exprList(x.Lbrack, e.ElemList, depth+1, commaTerm, x.Rbrack, false)
+		} else {
+			p.expr0(x.Index, depth+1)
+		}
 		p.print(x.Rbrack, token.RBRACK)
 
 	case *ast.SliceExpr:
@@ -919,32 +923,25 @@ func (p *printer) expr1(expr ast.Expr, prec1, depth int) {
 			depth++
 		}
 		var wasIndented bool
-		if x.Brackets {
+		if _, ok := x.Fun.(*ast.FuncType); ok {
+			// conversions to literal function types require parentheses around the type
+			p.print(token.LPAREN)
 			wasIndented = p.possibleSelectorExpr(x.Fun, token.HighestPrec, depth)
-			p.print(x.Lparen, token.LBRACK)
-			p.exprList(x.Lparen, x.Args, depth, commaTerm, x.Rparen, false)
-			p.print(x.Rparen, token.RBRACK)
+			p.print(token.RPAREN)
 		} else {
-			if _, ok := x.Fun.(*ast.FuncType); ok {
-				// conversions to literal function types require parentheses around the type
-				p.print(token.LPAREN)
-				wasIndented = p.possibleSelectorExpr(x.Fun, token.HighestPrec, depth)
-				p.print(token.RPAREN)
-			} else {
-				wasIndented = p.possibleSelectorExpr(x.Fun, token.HighestPrec, depth)
-			}
-			p.print(x.Lparen, token.LPAREN)
-			if x.Ellipsis.IsValid() {
-				p.exprList(x.Lparen, x.Args, depth, 0, x.Ellipsis, false)
-				p.print(x.Ellipsis, token.ELLIPSIS)
-				if x.Rparen.IsValid() && p.lineFor(x.Ellipsis) < p.lineFor(x.Rparen) {
-					p.print(token.COMMA, formfeed)
-				}
-			} else {
-				p.exprList(x.Lparen, x.Args, depth, commaTerm, x.Rparen, false)
+			wasIndented = p.possibleSelectorExpr(x.Fun, token.HighestPrec, depth)
+		}
+		p.print(x.Lparen, token.LPAREN)
+		if x.Ellipsis.IsValid() {
+			p.exprList(x.Lparen, x.Args, depth, 0, x.Ellipsis, false)
+			p.print(x.Ellipsis, token.ELLIPSIS)
+			if x.Rparen.IsValid() && p.lineFor(x.Ellipsis) < p.lineFor(x.Rparen) {
+				p.print(token.COMMA, formfeed)
 			}
-			p.print(x.Rparen, token.RPAREN)
+		} else {
+			p.exprList(x.Lparen, x.Args, depth, commaTerm, x.Rparen, false)
 		}
+		p.print(x.Rparen, token.RPAREN)
 		if wasIndented {
 			p.print(unindent)
 		}
diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go
index eca11358ef..20648f1cf6 100644
--- a/src/go/types/api_test.go
+++ b/src/go/types/api_test.go
@@ -325,8 +325,8 @@ func TestTypesInfo(t *testing.T) {
 		{broken + `x5; func _() { var x map[string][...]int; x = map[string][...]int{"": {1,2,3}} }`, `x`, `map[string][-1]int`},
 
 		// parameterized functions
-		{genericPkg + `p0; func f[T any](T); var _ = f(int)`, `f`, `func[T₁ interface{}](T₁)`},
-		{genericPkg + `p1; func f[T any](T); var _ = f(int)`, `f(int)`, `func(int)`},
+		{genericPkg + `p0; func f[T any](T); var _ = f[int]`, `f`, `func[T₁ interface{}](T₁)`},
+		{genericPkg + `p1; func f[T any](T); var _ = f[int]`, `f[int]`, `func(int)`},
 		{genericPkg + `p2; func f[T any](T); func _() { f(42) }`, `f`, `func[T₁ interface{}](T₁)`},
 		{genericPkg + `p3; func f[T any](T); func _() { f(42) }`, `f(42)`, `()`},
 
diff --git a/src/go/types/assignments.go b/src/go/types/assignments.go
index 3aa06e8939..f223cb7574 100644
--- a/src/go/types/assignments.go
+++ b/src/go/types/assignments.go
@@ -303,6 +303,20 @@ func (check *Checker) assignVars(lhs, origRHS []ast.Expr) {
 	}
 }
 
+// unpack unpacks an *ast.ListExpr into a list of ast.Expr.
+// TODO(gri) Should find a more efficient solution that doesn't
+//           require introduction of a new slice for simple
+//           expressions.
+func unpackExpr(x ast.Expr) []ast.Expr {
+	if x, _ := x.(*ast.ListExpr); x != nil {
+		return x.ElemList
+	}
+	if x != nil {
+		return []ast.Expr{x}
+	}
+	return nil
+}
+
 func (check *Checker) shortVarDecl(pos positioner, lhs, rhs []ast.Expr) {
 	top := len(check.delayed)
 	scope := check.scope
diff --git a/src/go/types/call.go b/src/go/types/call.go
index d9a7b440ec..b502122a26 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -14,25 +14,103 @@ import (
 	"unicode"
 )
 
-// TODO(rFindley) this has diverged a bit from types2. Bring it up to date.
-// If call == nil, the "call" was an index expression, and orig is of type *ast.IndexExpr.
-func (check *Checker) call(x *operand, call *ast.CallExpr, orig ast.Expr) exprKind {
-	assert(orig != nil)
-	if call != nil {
-		assert(call == orig)
-		check.exprOrType(x, call.Fun)
-	} else {
-		// We must have an index expression.
-		// x has already been set up (evaluation of orig.X).
-		// Set up fake call so we can use its fields below.
-		expr := orig.(*ast.IndexExpr)
-		call = &ast.CallExpr{Fun: expr.X, Lparen: expr.Lbrack, Args: []ast.Expr{expr.Index}, Rparen: expr.Rbrack, Brackets: true}
+// funcInst type-checks a function instantiaton inst and returns the result in x.
+// The operand x must be the evaluation of inst.X and its type must be a signature.
+func (check *Checker) funcInst(x *operand, inst *ast.IndexExpr) {
+	args, ok := check.exprOrTypeList(unpackExpr(inst.Index))
+	if !ok {
+		x.mode = invalid
+		x.expr = inst
+		return
+	}
+	if len(args) > 0 && args[0].mode != typexpr {
+		check.errorf(args[0], _NotAType, "%s is not a type", args[0])
+		ok = false
+	}
+
+	// check number of type arguments
+	n := len(args)
+	sig := x.typ.(*Signature)
+	if n > len(sig.tparams) {
+		check.errorf(args[n-1], _Todo, "got %d type arguments but want %d", n, len(sig.tparams))
+		x.mode = invalid
+		x.expr = inst
+		return
+	}
+
+	// collect types
+	targs := make([]Type, n)
+	// TODO(rFindley) use a positioner here? instantiate would need to be
+	//                updated accordingly.
+	poslist := make([]token.Pos, n)
+	for i, a := range args {
+		if a.mode != typexpr {
+			// error was reported earlier
+			x.mode = invalid
+			x.expr = inst
+			return
+		}
+		targs[i] = a.typ
+		poslist[i] = a.Pos()
+	}
+
+	// if we don't have enough type arguments, use constraint type inference
+	var inferred bool
+	if n < len(sig.tparams) {
+		var failed int
+		targs, failed = check.inferB(sig.tparams, targs)
+		if targs == nil {
+			// error was already reported
+			x.mode = invalid
+			x.expr = inst
+			return
+		}
+		if failed >= 0 {
+			// at least one type argument couldn't be inferred
+			assert(targs[failed] == nil)
+			tpar := sig.tparams[failed]
+			check.errorf(inNode(inst, inst.Rbrack), 0, "cannot infer %s (%v) (%s)", tpar.name, tpar.pos, targs)
+			x.mode = invalid
+			x.expr = inst
+			return
+		}
+		// all type arguments were inferred sucessfully
+		if debug {
+			for _, targ := range targs {
+				assert(targ != nil)
+			}
+		}
+		n = len(targs)
+		inferred = true
 	}
+	assert(n == len(sig.tparams))
+
+	// instantiate function signature
+	for i, typ := range targs {
+		// some positions may be missing if types are inferred
+		var pos token.Pos
+		if i < len(poslist) {
+			pos = poslist[i]
+		}
+		check.ordinaryType(atPos(pos), typ)
+	}
+	res := check.instantiate(x.Pos(), sig, targs, poslist).(*Signature)
+	assert(res.tparams == nil) // signature is not generic anymore
+	if inferred {
+		check.recordInferred(inst, targs, res)
+	}
+	x.typ = res
+	x.mode = value
+	x.expr = inst
+}
+
+func (check *Checker) call(x *operand, call *ast.CallExpr) exprKind {
+	check.exprOrType(x, call.Fun)
 
 	switch x.mode {
 	case invalid:
 		check.use(call.Args...)
-		x.expr = orig
+		x.expr = call
 		return statement
 
 	case typexpr:
@@ -72,7 +150,7 @@ func (check *Checker) call(x *operand, call *ast.CallExpr, orig ast.Expr) exprKi
 			check.use(call.Args...)
 			check.errorf(call.Args[n-1], _WrongArgCount, "too many arguments in conversion to %s", T)
 		}
-		x.expr = orig
+		x.expr = call
 		return conversion
 
 	case builtin:
@@ -80,7 +158,7 @@ func (check *Checker) call(x *operand, call *ast.CallExpr, orig ast.Expr) exprKi
 		if !check.builtin(x, call, id) {
 			x.mode = invalid
 		}
-		x.expr = orig
+		x.expr = call
 		// a non-constant result implies a function call
 		if x.mode != invalid && x.mode != constant_ {
 			check.hasCallOrRecv = true
@@ -95,109 +173,18 @@ func (check *Checker) call(x *operand, call *ast.CallExpr, orig ast.Expr) exprKi
 		if sig == nil {
 			check.invalidOp(x, _InvalidCall, "cannot call non-function %s", x)
 			x.mode = invalid
-			x.expr = orig
+			x.expr = call
 			return statement
 		}
 
 		// evaluate arguments
 		args, ok := check.exprOrTypeList(call.Args)
-		if ok && call.Brackets && len(args) > 0 && args[0].mode != typexpr {
-			check.errorf(args[0], _NotAType, "%s is not a type", args[0])
-			ok = false
-		}
 		if !ok {
 			x.mode = invalid
-			x.expr = orig
-			return expression
-		}
-
-		// instantiate function if needed
-		if n := len(args); n > 0 && len(sig.tparams) > 0 && args[0].mode == typexpr {
-			// If the first argument is a type, assume we have explicit type arguments.
-
-			// check number of type arguments
-			if n > len(sig.tparams) {
-				check.errorf(args[n-1], _Todo, "got %d type arguments but want %d", n, len(sig.tparams))
-				x.mode = invalid
-				x.expr = orig
-				return expression
-			}
-
-			// collect types
-			targs := make([]Type, n)
-			// TODO(rFindley) use a positioner here? instantiate would need to be
-			//                updated accordingly.
-			poslist := make([]token.Pos, n)
-			for i, a := range args {
-				if a.mode != typexpr {
-					// error was reported earlier
-					x.mode = invalid
-					x.expr = orig
-					return expression
-				}
-				targs[i] = a.typ
-				poslist[i] = a.Pos()
-			}
-
-			// if we don't have enough type arguments, use constraint type inference
-			var inferred bool
-			if n < len(sig.tparams) {
-				var failed int
-				targs, failed = check.inferB(sig.tparams, targs)
-				if targs == nil {
-					// error was already reported
-					x.mode = invalid
-					x.expr = orig
-					return expression
-				}
-				if failed >= 0 {
-					// at least one type argument couldn't be inferred
-					assert(targs[failed] == nil)
-					tpar := sig.tparams[failed]
-					ppos := check.fset.Position(tpar.pos).String()
-					check.errorf(inNode(call, call.Rparen), 0, "cannot infer %s (%s) (%s)", tpar.name, ppos, targs)
-					x.mode = invalid
-					x.expr = orig
-					return expression
-				}
-				// all type arguments were inferred sucessfully
-				if debug {
-					for _, targ := range targs {
-						assert(targ != nil)
-					}
-				}
-				n = len(targs)
-				inferred = true
-			}
-			assert(n == len(sig.tparams))
-
-			// instantiate function signature
-			for i, typ := range targs {
-				// some positions may be missing if types are inferred
-				var pos token.Pos
-				if i < len(poslist) {
-					pos = poslist[i]
-				}
-				check.ordinaryType(atPos(pos), typ)
-			}
-			res := check.instantiate(x.Pos(), sig, targs, poslist).(*Signature)
-			assert(res.tparams == nil) // signature is not generic anymore
-			if inferred {
-				check.recordInferred(orig, targs, res)
-			}
-			x.typ = res
-			x.mode = value
-			x.expr = orig
+			x.expr = call
 			return expression
 		}
 
-		// If we reach here, orig must have been a regular call, not an index
-		// expression.
-		// TODO(rFindley) with a manually constructed AST it is possible to reach
-		//                this assertion. We should return an invalidAST error here
-		//                rather than panicking.
-		assert(!call.Brackets)
-
 		sig = check.arguments(call, sig, args)
 
 		// determine result
diff --git a/src/go/types/examples/functions.go2 b/src/go/types/examples/functions.go2
index c6ad511bd6..fb74ae7ae2 100644
--- a/src/go/types/examples/functions.go2
+++ b/src/go/types/examples/functions.go2
@@ -50,7 +50,7 @@ func new[T any]() *T {
 // result type from the assignment to keep things simple and
 // easy to understand.
 var _ = new[int]()
-var _ *float64 = new(float64)() // the result type is indeed *float64
+var _ *float64 = new[float64]() // the result type is indeed *float64
 
 // A function may have multiple type parameters, of course.
 func foo[A, B, C any](a A, b []B, c *C) B {
@@ -59,7 +59,7 @@ func foo[A, B, C any](a A, b []B, c *C) B {
 }
 
 // As before, we can pass type parameters explicitly.
-var s = foo[int, string, float64](1, []string{"first"}, new(float64)())
+var s = foo[int, string, float64](1, []string{"first"}, new[float64]())
 
 // Or we can use type inference.
 var _ float64 = foo(42, []float64{1.0}, &s)
diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 45cf8c6b41..77807e3b5b 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -1459,7 +1459,8 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 
 		if x.mode == value {
 			if sig := asSignature(x.typ); sig != nil && len(sig.tparams) > 0 {
-				return check.call(x, nil, e)
+				check.funcInst(x, e)
+				return expression
 			}
 		}
 
@@ -1739,7 +1740,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 		x.typ = T
 
 	case *ast.CallExpr:
-		return check.call(x, e, e)
+		return check.call(x, e)
 
 	case *ast.StarExpr:
 		check.exprOrType(x, e.X)
diff --git a/src/go/types/exprstring.go b/src/go/types/exprstring.go
index 0d9ae58dfc..9e073b1de0 100644
--- a/src/go/types/exprstring.go
+++ b/src/go/types/exprstring.go
@@ -72,6 +72,14 @@ func WriteExpr(buf *bytes.Buffer, x ast.Expr) {
 		WriteExpr(buf, x.Index)
 		buf.WriteByte(']')
 
+	case *ast.ListExpr:
+		for i, e := range x.ElemList {
+			if i > 0 {
+				buf.WriteString(", ")
+			}
+			WriteExpr(buf, e)
+		}
+
 	case *ast.SliceExpr:
 		WriteExpr(buf, x.X)
 		buf.WriteByte('[')
@@ -98,16 +106,12 @@ func WriteExpr(buf *bytes.Buffer, x ast.Expr) {
 
 	case *ast.CallExpr:
 		WriteExpr(buf, x.Fun)
-		var l, r byte = '(', ')'
-		if x.Brackets {
-			l, r = '[', ']'
-		}
-		buf.WriteByte(l)
+		buf.WriteByte('(')
 		writeExprList(buf, x.Args)
 		if x.Ellipsis.IsValid() {
 			buf.WriteString("...")
 		}
-		buf.WriteByte(r)
+		buf.WriteByte(')')
 
 	case *ast.StarExpr:
 		buf.WriteByte('*')
diff --git a/src/go/types/resolver.go b/src/go/types/resolver.go
index 36f9a45cca..763ea48d38 100644
--- a/src/go/types/resolver.go
+++ b/src/go/types/resolver.go
@@ -494,13 +494,10 @@ L: // unpack receiver type
 	}
 
 	// unpack type parameters, if any
-	switch ptyp := rtyp.(type) {
-	case *ast.IndexExpr:
-		panic("unimplemented")
-	case *ast.CallExpr:
-		rtyp = ptyp.Fun
+	if ptyp, _ := rtyp.(*ast.IndexExpr); ptyp != nil {
+		rtyp = ptyp.X
 		if unpackParams {
-			for _, arg := range ptyp.Args {
+			for _, arg := range unpackExpr(ptyp.Index) {
 				var par *ast.Ident
 				switch arg := arg.(type) {
 				case *ast.Ident:
diff --git a/src/go/types/testdata/issues.go2 b/src/go/types/testdata/issues.go2
index ac2dee36cb..2d4bb32c4b 100644
--- a/src/go/types/testdata/issues.go2
+++ b/src/go/types/testdata/issues.go2
@@ -21,7 +21,7 @@ func _() {
 	eql(x, x)
 	eql(y, y)
 	eql(y, nil)
-	eql(io.Reader)(nil, nil)
+	eql[io.Reader](nil, nil)
 }
 
 // If we have a receiver of pointer type (below: *T) we must ignore
@@ -55,8 +55,8 @@ func (T) m1()
 func (*T) m2()
 
 func _() {
-	f2(T /* ERROR wrong method signature */ )()
-	f2(*T)()
+	f2[T /* ERROR wrong method signature */]()
+	f2[*T]()
 }
 
 // When a type parameter is used as an argument to instantiate a parameterized
@@ -244,7 +244,7 @@ func append[T interface{}, S sliceOf[T], T2 interface{ type T }](s S, t ...T2) S
 
 var f           func()
 var cancelSlice []context.CancelFunc
-var _ = append(context.CancelFunc, []context.CancelFunc, context.CancelFunc)(cancelSlice, f)
+var _ = append[context.CancelFunc, []context.CancelFunc, context.CancelFunc](cancelSlice, f)
 
 // A generic function must be instantiated with a type, not a value.
 
diff --git a/src/go/types/testdata/typeparams.go2 b/src/go/types/testdata/typeparams.go2
index bdf6d56082..2dd8f64dc0 100644
--- a/src/go/types/testdata/typeparams.go2
+++ b/src/go/types/testdata/typeparams.go2
@@ -38,7 +38,7 @@ var _ = f(0 /* ERROR cannot use 0 .* as \[\]chan int */ )
 func swap[A, B any](a A, b B) (B, A) { return b, a }
 
 var _ = swap /* ERROR single value is expected */ [int, float32](1, 2)
-var f32, i = swap[int, float32](swap(float32, int)(1, 2))
+var f32, i = swap[int, float32](swap[float32, int](1, 2))
 var _ float32 = f32
 var _ int = i
 
@@ -76,11 +76,11 @@ var _ *int = new[int]()
 func _[T any](map[T /* ERROR incomparable map key type T \(missing comparable constraint\) */]int) // w/o constraint we don't know if T is comparable
 
 func f1[T1 any](struct{T1}) int
-var _ = f1(int)(struct{T1}{})
+var _ = f1[int](struct{T1}{})
 type T1 = int
 
 func f2[t1 any](struct{t1; x float32}) int
-var _ = f2(t1)(struct{t1; x float32}{})
+var _ = f2[t1](struct{t1; x float32}{})
 type t1 = int
 
 
@@ -216,9 +216,9 @@ var _ = f8(1) /* ERROR not enough arguments */
 var _ = f8(1, 2.3)
 var _ = f8(1, 2.3, 3.4, 4.5)
 var _ = f8(1, 2.3, 3.4, 4 /* ERROR does not match */ )
-var _ = f8(int, float64)(1, 2.3, 3.4, 4)
+var _ = f8[int, float64](1, 2.3, 3.4, 4)
 
-var _ = f8(int, float64)(0, 0, nil...) // test case for #18268
+var _ = f8[int, float64](0, 0, nil...) // test case for #18268
 
 // init functions cannot have type parameters
 
@@ -271,7 +271,7 @@ type A[T any] T
 func (a A[T]) m() A[T]
 
 func _[T any]() {
-	f12(A[T])()
+	f12[A[T]]()
 }
 
 // method expressions
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index 503f9c71ac..53c87f20d5 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -208,21 +208,28 @@ func isubst(x ast.Expr, smap map[*ast.Ident]*ast.Ident) ast.Expr {
 			new.X = X
 			return &new
 		}
-	case *ast.CallExpr:
-		var args []ast.Expr
-		for i, arg := range n.Args {
-			new := isubst(arg, smap)
-			if new != arg {
-				if args == nil {
-					args = make([]ast.Expr, len(n.Args))
-					copy(args, n.Args)
+	case *ast.IndexExpr:
+		index := isubst(n.Index, smap)
+		if index != n.Index {
+			new := *n
+			new.Index = index
+			return &new
+		}
+	case *ast.ListExpr:
+		var elems []ast.Expr
+		for i, elem := range n.ElemList {
+			new := isubst(elem, smap)
+			if new != elem {
+				if elems == nil {
+					elems = make([]ast.Expr, len(n.ElemList))
+					copy(elems, n.ElemList)
 				}
-				args[i] = new
+				elems[i] = new
 			}
 		}
-		if args != nil {
+		if elems != nil {
 			new := *n
-			new.Args = args
+			new.ElemList = elems
 			return &new
 		}
 	case *ast.ParenExpr:
@@ -460,14 +467,7 @@ func (check *Checker) typInternal(e0 ast.Expr, def *Named) (T Type) {
 		}
 
 	case *ast.IndexExpr:
-		return check.instantiatedType(e.X, []ast.Expr{e.Index}, def)
-
-	case *ast.CallExpr:
-		if e.Brackets {
-			return check.instantiatedType(e.Fun, e.Args, def)
-		} else {
-			check.errorf(e0, _NotAType, "%s is not a type", e0)
-		}
+		return check.instantiatedType(e.X, unpackExpr(e.Index), def)
 
 	case *ast.ParenExpr:
 		// Generic types must be instantiated before they can be used in any form.
@@ -1158,10 +1158,6 @@ func embeddedFieldIdent(e ast.Expr) *ast.Ident {
 		return e.Sel
 	case *ast.IndexExpr:
 		return embeddedFieldIdent(e.X)
-	case *ast.CallExpr:
-		if e.Brackets {
-			return embeddedFieldIdent(e.Fun)
-		}
 	}
 	return nil // invalid embedded field
 }
-- 
GitLab


From 5e4da8670b13370392a9195930e3b4bbe5f1944f Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 17 Feb 2021 16:04:59 -0800
Subject: [PATCH 0670/2400] [dev.typeparams] cmd/compile/internal/types2: use
 converter functions rather than methods

This change replaces methods with functions to reduce the API surface of
types2.Type and to match the approach taken in go/types. The converter
methods for Named and TypeParam will be addressed in a follow-up CL.

Also: Fixed behavior of optype to return the underlying type for
      arguments that are not type parameters.

Change-Id: Ia369c796754bc33bbaf0c9c8478badecb729279b
Reviewed-on: https://go-review.googlesource.com/c/go/+/293291
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/importer/support.go  |  11 --
 .../compile/internal/types2/assignments.go    |   2 +-
 src/cmd/compile/internal/types2/builtins.go   |  14 +-
 src/cmd/compile/internal/types2/call.go       |   4 +-
 .../compile/internal/types2/conversions.go    |  14 +-
 src/cmd/compile/internal/types2/expr.go       |  18 +-
 .../compile/internal/types2/issues_test.go    |   4 +-
 src/cmd/compile/internal/types2/lookup.go     |   8 +-
 src/cmd/compile/internal/types2/predicates.go |   2 +-
 src/cmd/compile/internal/types2/sizes.go      |   2 +-
 .../compile/internal/types2/stdlib_test.go    |   2 +-
 src/cmd/compile/internal/types2/stmt.go       |   4 +-
 src/cmd/compile/internal/types2/type.go       | 166 +++++++-----------
 src/cmd/compile/internal/types2/typestring.go |   4 +-
 src/cmd/compile/internal/types2/typexpr.go    |   8 +-
 15 files changed, 108 insertions(+), 155 deletions(-)

diff --git a/src/cmd/compile/internal/importer/support.go b/src/cmd/compile/internal/importer/support.go
index 4f013f4a51..cac87745fe 100644
--- a/src/cmd/compile/internal/importer/support.go
+++ b/src/cmd/compile/internal/importer/support.go
@@ -129,16 +129,5 @@ func (t anyType) Under() types2.Type      { return t }
 func (t anyType) String() string          { return "any" }
 
 // types2.aType is not exported for now so we need to implemented these here.
-func (anyType) Basic() *types2.Basic         { return nil }
-func (anyType) Array() *types2.Array         { return nil }
-func (anyType) Slice() *types2.Slice         { return nil }
-func (anyType) Struct() *types2.Struct       { return nil }
-func (anyType) Pointer() *types2.Pointer     { return nil }
-func (anyType) Tuple() *types2.Tuple         { return nil }
-func (anyType) Signature() *types2.Signature { return nil }
-func (anyType) Sum() *types2.Sum             { return nil }
-func (anyType) Interface() *types2.Interface { return nil }
-func (anyType) Map() *types2.Map             { return nil }
-func (anyType) Chan() *types2.Chan           { return nil }
 func (anyType) Named() *types2.Named         { return nil }
 func (anyType) TypeParam() *types2.TypeParam { return nil }
diff --git a/src/cmd/compile/internal/types2/assignments.go b/src/cmd/compile/internal/types2/assignments.go
index 6caa4863d5..00495f3976 100644
--- a/src/cmd/compile/internal/types2/assignments.go
+++ b/src/cmd/compile/internal/types2/assignments.go
@@ -52,7 +52,7 @@ func (check *Checker) assignment(x *operand, T Type, context string) {
 	// x.typ is typed
 
 	// A generic (non-instantiated) function value cannot be assigned to a variable.
-	if sig := x.typ.Signature(); sig != nil && len(sig.tparams) > 0 {
+	if sig := asSignature(x.typ); sig != nil && len(sig.tparams) > 0 {
 		check.errorf(x, "cannot use generic function %s without instantiation in %s", x, context)
 	}
 
diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go
index 591a22f814..763122bc5b 100644
--- a/src/cmd/compile/internal/types2/builtins.go
+++ b/src/cmd/compile/internal/types2/builtins.go
@@ -82,7 +82,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 		// of S and the respective parameter passing rules apply."
 		S := x.typ
 		var T Type
-		if s := S.Slice(); s != nil {
+		if s := asSlice(S); s != nil {
 			T = s.elem
 		} else {
 			check.invalidArgf(x, "%s is not a slice", x)
@@ -210,7 +210,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 
 	case _Close:
 		// close(c)
-		c := x.typ.Chan()
+		c := asChan(x.typ)
 		if c == nil {
 			check.invalidArgf(x, "%s is not a channel", x)
 			return
@@ -286,7 +286,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 
 		// the argument types must be of floating-point type
 		f := func(x Type) Type {
-			if t := x.Basic(); t != nil {
+			if t := asBasic(x); t != nil {
 				switch t.kind {
 				case Float32:
 					return Typ[Complex64]
@@ -320,7 +320,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 	case _Copy:
 		// copy(x, y []T) int
 		var dst Type
-		if t := x.typ.Slice(); t != nil {
+		if t := asSlice(x.typ); t != nil {
 			dst = t.elem
 		}
 
@@ -357,7 +357,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 
 	case _Delete:
 		// delete(m, k)
-		m := x.typ.Map()
+		m := asMap(x.typ)
 		if m == nil {
 			check.invalidArgf(x, "%s is not a map", x)
 			return
@@ -404,7 +404,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 
 		// the argument must be of complex type
 		f := func(x Type) Type {
-			if t := x.Basic(); t != nil {
+			if t := asBasic(x); t != nil {
 				switch t.kind {
 				case Complex64:
 					return Typ[Float32]
@@ -757,7 +757,7 @@ func makeSig(res Type, args ...Type) *Signature {
 //
 func implicitArrayDeref(typ Type) Type {
 	if p, ok := typ.(*Pointer); ok {
-		if a := p.base.Array(); a != nil {
+		if a := asArray(p.base); a != nil {
 			return a
 		}
 	}
diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index 72a33b50b1..10db701324 100644
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -121,7 +121,7 @@ func (check *Checker) call(x *operand, call *syntax.CallExpr) exprKind {
 		case 1:
 			check.expr(x, call.ArgList[0])
 			if x.mode != invalid {
-				if t := T.Interface(); t != nil {
+				if t := asInterface(T); t != nil {
 					check.completeInterface(nopos, t)
 					if t.IsConstraint() {
 						check.errorf(call, "cannot use interface %s in conversion (contains type list or is comparable)", T)
@@ -157,7 +157,7 @@ func (check *Checker) call(x *operand, call *syntax.CallExpr) exprKind {
 		// function/method call
 		cgocall := x.mode == cgofunc
 
-		sig := x.typ.Signature()
+		sig := asSignature(x.typ)
 		if sig == nil {
 			check.invalidOpf(x, "cannot call non-function %s", x)
 			x.mode = invalid
diff --git a/src/cmd/compile/internal/types2/conversions.go b/src/cmd/compile/internal/types2/conversions.go
index 90c08fb72f..c9603b263c 100644
--- a/src/cmd/compile/internal/types2/conversions.go
+++ b/src/cmd/compile/internal/types2/conversions.go
@@ -21,7 +21,7 @@ func (check *Checker) conversion(x *operand, T Type) {
 	switch {
 	case constArg && isConstType(T):
 		// constant conversion
-		switch t := T.Basic(); {
+		switch t := asBasic(T); {
 		case representableConst(x.val, check, t, &x.val):
 			ok = true
 		case isInteger(x.typ) && isString(t):
@@ -140,26 +140,26 @@ func (x *operand) convertibleTo(check *Checker, T Type) bool {
 }
 
 func isUintptr(typ Type) bool {
-	t := typ.Basic()
+	t := asBasic(typ)
 	return t != nil && t.kind == Uintptr
 }
 
 func isUnsafePointer(typ Type) bool {
-	// TODO(gri): Is this typ.Basic() instead of typ.(*Basic) correct?
+	// TODO(gri): Is this asBasic(typ) instead of typ.(*Basic) correct?
 	//            (The former calls typ.Under(), while the latter doesn't.)
 	//            The spec does not say so, but gc claims it is. See also
 	//            issue 6326.
-	t := typ.Basic()
+	t := asBasic(typ)
 	return t != nil && t.kind == UnsafePointer
 }
 
 func isPointer(typ Type) bool {
-	return typ.Pointer() != nil
+	return asPointer(typ) != nil
 }
 
 func isBytesOrRunes(typ Type) bool {
-	if s := typ.Slice(); s != nil {
-		t := s.elem.Basic()
+	if s := asSlice(typ); s != nil {
+		t := asBasic(s.elem)
 		return t != nil && (t.kind == Byte || t.kind == Rune)
 	}
 	return false
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 9889e3113d..07b23c9eff 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -110,7 +110,7 @@ func (check *Checker) overflow(x *operand) {
 	// Typed constants must be representable in
 	// their type after each constant operation.
 	if isTyped(x.typ) {
-		check.representable(x, x.typ.Basic())
+		check.representable(x, asBasic(x.typ))
 		return
 	}
 
@@ -173,7 +173,7 @@ func (check *Checker) unary(x *operand, e *syntax.Operation) {
 		return
 
 	case syntax.Recv:
-		typ := x.typ.Chan()
+		typ := asChan(x.typ)
 		if typ == nil {
 			check.invalidOpf(x, "cannot receive from non-channel %s", x)
 			x.mode = invalid
@@ -543,7 +543,7 @@ func (check *Checker) updateExprType(x syntax.Expr, typ Type, final bool) {
 	// If the new type is not final and still untyped, just
 	// update the recorded type.
 	if !final && isUntyped(typ) {
-		old.typ = typ.Basic()
+		old.typ = asBasic(typ)
 		check.untyped[x] = old
 		return
 	}
@@ -1396,7 +1396,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 					duplicate := false
 					// if the key is of interface type, the type is also significant when checking for duplicates
 					xkey := keyVal(x.val)
-					if utyp.key.Interface() != nil {
+					if asInterface(utyp.key) != nil {
 						for _, vtyp := range visited[xkey] {
 							if check.identical(vtyp, x.typ) {
 								duplicate = true
@@ -1465,7 +1465,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 		}
 
 		if x.mode == value {
-			if sig := x.typ.Signature(); sig != nil && len(sig.tparams) > 0 {
+			if sig := asSignature(x.typ); sig != nil && len(sig.tparams) > 0 {
 				// function instantiation
 				check.funcInst(x, e)
 				return expression
@@ -1498,7 +1498,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 			x.typ = typ.elem
 
 		case *Pointer:
-			if typ := typ.base.Array(); typ != nil {
+			if typ := asArray(typ.base); typ != nil {
 				valid = true
 				length = typ.len
 				x.mode = variable
@@ -1536,7 +1536,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 				case *Array:
 					e = t.elem
 				case *Pointer:
-					if t := t.base.Array(); t != nil {
+					if t := asArray(t.base); t != nil {
 						e = t.elem
 					}
 				case *Slice:
@@ -1665,7 +1665,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 			x.typ = &Slice{elem: typ.elem}
 
 		case *Pointer:
-			if typ := typ.base.Array(); typ != nil {
+			if typ := asArray(typ.base); typ != nil {
 				valid = true
 				length = typ.len
 				x.typ = &Slice{elem: typ.elem}
@@ -1797,7 +1797,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 				case typexpr:
 					x.typ = &Pointer{base: x.typ}
 				default:
-					if typ := x.typ.Pointer(); typ != nil {
+					if typ := asPointer(x.typ); typ != nil {
 						x.mode = variable
 						x.typ = typ.base
 					} else {
diff --git a/src/cmd/compile/internal/types2/issues_test.go b/src/cmd/compile/internal/types2/issues_test.go
index 9a73a46d11..5a32fa590a 100644
--- a/src/cmd/compile/internal/types2/issues_test.go
+++ b/src/cmd/compile/internal/types2/issues_test.go
@@ -391,7 +391,7 @@ func TestIssue28005(t *testing.T) {
 		if obj == nil {
 			t.Fatal("object X not found")
 		}
-		iface := obj.Type().Interface() // object X must be an interface
+		iface := obj.Type().Underlying().(*Interface) // object X must be an interface
 		if iface == nil {
 			t.Fatalf("%s is not an interface", obj)
 		}
@@ -414,7 +414,7 @@ func TestIssue28282(t *testing.T) {
 	it := NewInterfaceType(nil, []Type{et})
 	it.Complete()
 	// verify that after completing the interface, the embedded method remains unchanged
-	want := et.Interface().Method(0)
+	want := et.Underlying().(*Interface).Method(0)
 	got := it.Method(0)
 	if got != want {
 		t.Fatalf("%s.Method(0): got %q (%p); want %q (%p)", it, got, got, want, want)
diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go
index 5dfb8bfee7..df25c9cf70 100644
--- a/src/cmd/compile/internal/types2/lookup.go
+++ b/src/cmd/compile/internal/types2/lookup.go
@@ -314,7 +314,7 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
 		return
 	}
 
-	if ityp := V.Interface(); ityp != nil {
+	if ityp := asInterface(V); ityp != nil {
 		check.completeInterface(nopos, ityp)
 		// TODO(gri) allMethods is sorted - can do this more efficiently
 		for _, m := range T.allMethods {
@@ -434,7 +434,7 @@ func (check *Checker) assertableTo(V *Interface, T Type, strict bool) (method, w
 	// no static check is required if T is an interface
 	// spec: "If T is an interface type, x.(T) asserts that the
 	//        dynamic type of x implements the interface T."
-	if T.Interface() != nil && !(strict || forceStrict) {
+	if asInterface(T) != nil && !(strict || forceStrict) {
 		return
 	}
 	return check.missingMethod(T, V, false)
@@ -452,8 +452,8 @@ func deref(typ Type) (Type, bool) {
 // derefStructPtr dereferences typ if it is a (named or unnamed) pointer to a
 // (named or unnamed) struct and returns its base. Otherwise it returns typ.
 func derefStructPtr(typ Type) Type {
-	if p := typ.Pointer(); p != nil {
-		if p.base.Struct() != nil {
+	if p := asPointer(typ); p != nil {
+		if asStruct(p.base) != nil {
 			return p.base
 		}
 	}
diff --git a/src/cmd/compile/internal/types2/predicates.go b/src/cmd/compile/internal/types2/predicates.go
index b8fa15cdb8..a7972c6928 100644
--- a/src/cmd/compile/internal/types2/predicates.go
+++ b/src/cmd/compile/internal/types2/predicates.go
@@ -79,7 +79,7 @@ func isConstType(typ Type) bool {
 
 // IsInterface reports whether typ is an interface type.
 func IsInterface(typ Type) bool {
-	return typ.Interface() != nil
+	return asInterface(typ) != nil
 }
 
 // Comparable reports whether values of type T are comparable.
diff --git a/src/cmd/compile/internal/types2/sizes.go b/src/cmd/compile/internal/types2/sizes.go
index 9945dcd10c..9d8f3ae5ad 100644
--- a/src/cmd/compile/internal/types2/sizes.go
+++ b/src/cmd/compile/internal/types2/sizes.go
@@ -241,7 +241,7 @@ func (conf *Config) offsetsof(T *Struct) []int64 {
 func (conf *Config) offsetof(typ Type, index []int) int64 {
 	var o int64
 	for _, i := range index {
-		s := typ.Struct()
+		s := asStruct(typ)
 		o += conf.offsetsof(s)[i]
 		typ = s.fields[i].typ
 	}
diff --git a/src/cmd/compile/internal/types2/stdlib_test.go b/src/cmd/compile/internal/types2/stdlib_test.go
index 0477e54998..34925687e3 100644
--- a/src/cmd/compile/internal/types2/stdlib_test.go
+++ b/src/cmd/compile/internal/types2/stdlib_test.go
@@ -241,7 +241,7 @@ func typecheck(t *testing.T, path string, filenames []string) {
 	// Perform checks of API invariants.
 
 	// All Objects have a package, except predeclared ones.
-	errorError := Universe.Lookup("error").Type().Interface().ExplicitMethod(0) // (error).Error
+	errorError := Universe.Lookup("error").Type().Underlying().(*Interface).ExplicitMethod(0) // (error).Error
 	for id, obj := range info.Uses {
 		predeclared := obj == Universe.Lookup(obj.Name()) || obj == errorError
 		if predeclared == (obj.Pkg() != nil) {
diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go
index bab56b22ef..9d74e0e588 100644
--- a/src/cmd/compile/internal/types2/stmt.go
+++ b/src/cmd/compile/internal/types2/stmt.go
@@ -351,7 +351,7 @@ func (check *Checker) stmt(ctxt stmtContext, s syntax.Stmt) {
 			return
 		}
 
-		tch := ch.typ.Chan()
+		tch := asChan(ch.typ)
 		if tch == nil {
 			check.invalidOpf(s, "cannot send to non-chan type %s", ch.typ)
 			return
@@ -890,7 +890,7 @@ func rangeKeyVal(typ Type, wantKey, wantVal bool) (Type, Type, string) {
 	case *Slice:
 		return Typ[Int], typ.elem, ""
 	case *Pointer:
-		if typ := typ.base.Array(); typ != nil {
+		if typ := asArray(typ.base); typ != nil {
 			return Typ[Int], typ.elem, ""
 		}
 	case *Map:
diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
index 7e51a138b5..f90abba8da 100644
--- a/src/cmd/compile/internal/types2/type.go
+++ b/src/cmd/compile/internal/types2/type.go
@@ -27,24 +27,6 @@ type Type interface {
 	// String returns a string representation of a type.
 	String() string
 
-	// Converters
-	// A converter must only be called when a type is
-	// known to be fully set up. A converter returns
-	// a type's operational type (see comment for optype)
-	// or nil if the type is receiver is not of the
-	// respective type.
-	Basic() *Basic
-	Array() *Array
-	Slice() *Slice
-	Struct() *Struct
-	Pointer() *Pointer
-	Tuple() *Tuple
-	Signature() *Signature
-	Sum() *Sum
-	Interface() *Interface
-	Map() *Map
-	Chan() *Chan
-
 	// If the receiver for Named and TypeParam is of
 	// the respective type (possibly after unpacking
 	// an instance type), these methods return that
@@ -61,21 +43,6 @@ func (aType) Underlying() Type { panic("unreachable") }
 func (aType) Under() Type      { panic("unreachable") }
 func (aType) String() string   { panic("unreachable") }
 
-// Each type is implementing its version of these methods
-// (Basic must implement Basic, etc.), the other methods
-// are inherited.
-func (aType) Basic() *Basic         { return nil }
-func (aType) Array() *Array         { return nil }
-func (aType) Slice() *Slice         { return nil }
-func (aType) Struct() *Struct       { return nil }
-func (aType) Pointer() *Pointer     { return nil }
-func (aType) Tuple() *Tuple         { return nil }
-func (aType) Signature() *Signature { return nil }
-func (aType) Sum() *Sum             { return nil }
-func (aType) Interface() *Interface { return nil }
-func (aType) Map() *Map             { return nil }
-func (aType) Chan() *Chan           { return nil }
-
 func (aType) Named() *Named         { return nil }
 func (aType) TypeParam() *TypeParam { return nil }
 
@@ -256,18 +223,6 @@ func NewTuple(x ...*Var) *Tuple {
 // but add all because missing one leads to very confusing bugs.
 // TODO(gri) Don't represent empty tuples with a (*Tuple)(nil) pointer;
 //           it's too subtle and causes problems.
-func (*Tuple) Basic() *Basic     { return nil }
-func (*Tuple) Array() *Array     { return nil }
-func (*Tuple) Slice() *Slice     { return nil }
-func (*Tuple) Struct() *Struct   { return nil }
-func (*Tuple) Pointer() *Pointer { return nil }
-
-// func (*Tuple) Tuple() *Tuple      // implemented below
-func (*Tuple) Signature() *Signature { return nil }
-func (*Tuple) Sum() *Sum             { return nil }
-func (*Tuple) Interface() *Interface { return nil }
-func (*Tuple) Map() *Map             { return nil }
-func (*Tuple) Chan() *Chan           { return nil }
 
 func (*Tuple) Named() *Named         { return nil }
 func (*Tuple) TypeParam() *TypeParam { return nil }
@@ -408,7 +363,7 @@ func unpack(typ Type) []Type {
 	if typ == nil {
 		return nil
 	}
-	if sum := typ.Sum(); sum != nil {
+	if sum := asSum(typ); sum != nil {
 		return sum.types
 	}
 	return []Type{typ}
@@ -594,7 +549,7 @@ func (t *Interface) iterate(f func(*Interface) bool, seen map[*Interface]bool) b
 	}
 	for _, e := range t.embeddeds {
 		// e should be an interface but be careful (it may be invalid)
-		if e := e.Interface(); e != nil {
+		if e := asInterface(e); e != nil {
 			// Cyclic interfaces such as "type E interface { E }" are not permitted
 			// but they are still constructed and we need to detect such cycles.
 			if seen[e] {
@@ -661,7 +616,7 @@ func (t *Interface) Complete() *Interface {
 
 	for _, typ := range t.embeddeds {
 		utyp := typ.Under()
-		etyp := utyp.Interface()
+		etyp := asInterface(utyp)
 		if etyp == nil {
 			if utyp != Typ[Invalid] {
 				panic(fmt.Sprintf("%s is not an interface", typ))
@@ -775,18 +730,6 @@ func (check *Checker) NewNamed(obj *TypeName, underlying Type, methods []*Func)
 // Obj returns the type name for the named type t.
 func (t *Named) Obj() *TypeName { return t.obj }
 
-// Converter methods
-func (t *Named) Basic() *Basic         { return t.Under().Basic() }
-func (t *Named) Array() *Array         { return t.Under().Array() }
-func (t *Named) Slice() *Slice         { return t.Under().Slice() }
-func (t *Named) Struct() *Struct       { return t.Under().Struct() }
-func (t *Named) Pointer() *Pointer     { return t.Under().Pointer() }
-func (t *Named) Tuple() *Tuple         { return t.Under().Tuple() }
-func (t *Named) Signature() *Signature { return t.Under().Signature() }
-func (t *Named) Interface() *Interface { return t.Under().Interface() }
-func (t *Named) Map() *Map             { return t.Under().Map() }
-func (t *Named) Chan() *Chan           { return t.Under().Chan() }
-
 // func (t *Named) Named() *Named      // declared below
 func (t *Named) TypeParam() *TypeParam { return t.Under().TypeParam() }
 
@@ -853,7 +796,7 @@ func (check *Checker) NewTypeParam(obj *TypeName, index int, bound Type) *TypePa
 }
 
 func (t *TypeParam) Bound() *Interface {
-	iface := t.bound.Interface()
+	iface := asInterface(t.bound)
 	// use the type bound position if we have one
 	pos := nopos
 	if n, _ := t.bound.(*Named); n != nil {
@@ -884,22 +827,9 @@ func optype(typ Type) Type {
 		}
 		return theTop
 	}
-	return typ
+	return typ.Under()
 }
 
-// Converter methods
-func (t *TypeParam) Basic() *Basic         { return optype(t).Basic() }
-func (t *TypeParam) Array() *Array         { return optype(t).Array() }
-func (t *TypeParam) Slice() *Slice         { return optype(t).Slice() }
-func (t *TypeParam) Struct() *Struct       { return optype(t).Struct() }
-func (t *TypeParam) Pointer() *Pointer     { return optype(t).Pointer() }
-func (t *TypeParam) Tuple() *Tuple         { return optype(t).Tuple() }
-func (t *TypeParam) Signature() *Signature { return optype(t).Signature() }
-func (t *TypeParam) Sum() *Sum             { return optype(t).Sum() }
-func (t *TypeParam) Interface() *Interface { return optype(t).Interface() }
-func (t *TypeParam) Map() *Map             { return optype(t).Map() }
-func (t *TypeParam) Chan() *Chan           { return optype(t).Chan() }
-
 // func (t *TypeParam) Named() *Named         // Named does not unpack type parameters
 // func (t *TypeParam) TypeParam() *TypeParam // declared below
 
@@ -917,19 +847,6 @@ type instance struct {
 	aType
 }
 
-// Converter methods
-func (t *instance) Basic() *Basic         { return t.Under().Basic() }
-func (t *instance) Array() *Array         { return t.Under().Array() }
-func (t *instance) Slice() *Slice         { return t.Under().Slice() }
-func (t *instance) Struct() *Struct       { return t.Under().Struct() }
-func (t *instance) Pointer() *Pointer     { return t.Under().Pointer() }
-func (t *instance) Tuple() *Tuple         { return t.Under().Tuple() }
-func (t *instance) Signature() *Signature { return t.Under().Signature() }
-func (t *instance) Sum() *Sum             { return t.Under().Sum() }
-func (t *instance) Interface() *Interface { return t.Under().Interface() }
-func (t *instance) Map() *Map             { return t.Under().Map() }
-func (t *instance) Chan() *Chan           { return t.Under().Chan() }
-
 func (t *instance) Named() *Named         { return t.expand().Named() }
 func (t *instance) TypeParam() *TypeParam { return t.expand().TypeParam() }
 
@@ -991,19 +908,6 @@ type top struct {
 // theTop is the singleton top type.
 var theTop = &top{}
 
-// Type-specific implementations of type converters.
-func (t *Basic) Basic() *Basic             { return t }
-func (t *Array) Array() *Array             { return t }
-func (t *Slice) Slice() *Slice             { return t }
-func (t *Struct) Struct() *Struct          { return t }
-func (t *Pointer) Pointer() *Pointer       { return t }
-func (t *Tuple) Tuple() *Tuple             { return t }
-func (t *Signature) Signature() *Signature { return t }
-func (t *Sum) Sum() *Sum                   { return t }
-func (t *Interface) Interface() *Interface { return t }
-func (t *Map) Map() *Map                   { return t }
-func (t *Chan) Chan() *Chan                { return t }
-
 func (t *Named) Named() *Named             { return t }
 func (t *TypeParam) TypeParam() *TypeParam { return t }
 
@@ -1061,3 +965,63 @@ func (t *TypeParam) String() string { return TypeString(t, nil) }
 func (t *instance) String() string  { return TypeString(t, nil) }
 func (t *bottom) String() string    { return TypeString(t, nil) }
 func (t *top) String() string       { return TypeString(t, nil) }
+
+// Converters
+//
+// A converter must only be called when a type is
+// known to be fully set up. A converter returns
+// a type's operational type (see comment for optype)
+// or nil if the type argument is not of the
+// respective type.
+
+func asBasic(t Type) *Basic {
+	op, _ := optype(t).(*Basic)
+	return op
+}
+
+func asArray(t Type) *Array {
+	op, _ := optype(t).(*Array)
+	return op
+}
+
+func asSlice(t Type) *Slice {
+	op, _ := optype(t).(*Slice)
+	return op
+}
+
+func asStruct(t Type) *Struct {
+	op, _ := optype(t).(*Struct)
+	return op
+}
+
+func asPointer(t Type) *Pointer {
+	op, _ := optype(t).(*Pointer)
+	return op
+}
+
+// asTuple is not needed - not provided
+
+func asSignature(t Type) *Signature {
+	op, _ := optype(t).(*Signature)
+	return op
+}
+
+func asSum(t Type) *Sum {
+	op, _ := optype(t).(*Sum)
+	return op
+}
+
+func asInterface(t Type) *Interface {
+	op, _ := optype(t).(*Interface)
+	return op
+}
+
+func asMap(t Type) *Map {
+	op, _ := optype(t).(*Map)
+	return op
+}
+
+func asChan(t Type) *Chan {
+	op, _ := optype(t).(*Chan)
+	return op
+}
diff --git a/src/cmd/compile/internal/types2/typestring.go b/src/cmd/compile/internal/types2/typestring.go
index 6b6d7ad2be..4d778df43f 100644
--- a/src/cmd/compile/internal/types2/typestring.go
+++ b/src/cmd/compile/internal/types2/typestring.go
@@ -327,7 +327,7 @@ func writeTParamList(buf *bytes.Buffer, list []*TypeName, qf Qualifier, visited
 	var writeBounds bool
 	for _, p := range list {
 		// bound(p) should be an interface but be careful (it may be invalid)
-		b := bound(p).Interface()
+		b := asInterface(bound(p))
 		if b != nil && !b.Empty() {
 			writeBounds = true
 			break
@@ -395,7 +395,7 @@ func writeTuple(buf *bytes.Buffer, tup *Tuple, variadic bool, qf Qualifier, visi
 				} else {
 					// special case:
 					// append(s, "foo"...) leads to signature func([]byte, string...)
-					if t := typ.Basic(); t == nil || t.kind != String {
+					if t := asBasic(typ); t == nil || t.kind != String {
 						panic("internal error: string type expected")
 					}
 					writeType(buf, typ, qf, visited)
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index b67a35ed30..7ee28abac3 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -142,7 +142,7 @@ func (check *Checker) ordinaryType(pos syntax.Pos, typ Type) {
 	// are in the middle of type-checking parameter declarations that might belong to
 	// interface methods. Delay this check to the end of type-checking.
 	check.atEnd(func() {
-		if t := typ.Interface(); t != nil {
+		if t := asInterface(typ); t != nil {
 			check.completeInterface(pos, t) // TODO(gri) is this the correct position?
 			if t.allTypes != nil {
 				check.softErrorf(pos, "interface contains type constraints (%s)", t.allTypes)
@@ -403,7 +403,7 @@ func (check *Checker) funcType(sig *Signature, recvPar *syntax.Field, tparams []
 						err = "pointer or interface type"
 					}
 				}
-			} else if T := t.Basic(); T != nil {
+			} else if T := asBasic(t); T != nil {
 				err = "basic or unnamed type"
 				if check.conf.CompilerErrorMessages {
 					check.errorf(recv.pos, "cannot define new methods on non-local type %s", recv.typ)
@@ -968,7 +968,7 @@ func (check *Checker) completeInterface(pos syntax.Pos, ityp *Interface) {
 	for i, typ := range ityp.embeddeds {
 		pos := posList[i] // embedding position
 		utyp := typ.Under()
-		etyp := utyp.Interface()
+		etyp := asInterface(utyp)
 		if etyp == nil {
 			if utyp != Typ[Invalid] {
 				var format string
@@ -1226,7 +1226,7 @@ func (check *Checker) collectTypeConstraints(pos syntax.Pos, types []syntax.Expr
 	// Note: This is a quadratic algorithm, but type lists tend to be short.
 	check.atEnd(func() {
 		for i, t := range list {
-			if t := t.Interface(); t != nil {
+			if t := asInterface(t); t != nil {
 				check.completeInterface(types[i].Pos(), t)
 			}
 			if includes(list[:i], t) {
-- 
GitLab


From 653386a89a702b54bb01be893cfd30cddb0e6107 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 17 Feb 2021 17:06:53 -0800
Subject: [PATCH 0671/2400] [dev.typeparams] cmd/compile/internal/types2:
 replace Named, TypeParam methods with functions

This removes two more converter methods in favor of functions.
This further reduces the API surface of types2.Type and matches
the approach taken in go/types.

Change-Id: I3cdd54c5e0d1e7664a69f3697fc081a66315b969
Reviewed-on: https://go-review.googlesource.com/c/go/+/293292
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/importer/support.go  |  4 --
 src/cmd/compile/internal/types2/builtins.go   |  6 +--
 src/cmd/compile/internal/types2/call.go       |  2 +-
 src/cmd/compile/internal/types2/decl.go       |  6 +--
 src/cmd/compile/internal/types2/expr.go       |  2 +-
 src/cmd/compile/internal/types2/lookup.go     |  8 +--
 src/cmd/compile/internal/types2/operand.go    |  2 +-
 src/cmd/compile/internal/types2/predicates.go |  2 +-
 src/cmd/compile/internal/types2/subst.go      |  4 +-
 src/cmd/compile/internal/types2/type.go       | 51 +++++++------------
 src/cmd/compile/internal/types2/typexpr.go    | 10 ++--
 src/cmd/compile/internal/types2/unify.go      |  6 +--
 src/cmd/compile/internal/types2/universe.go   |  2 +-
 13 files changed, 43 insertions(+), 62 deletions(-)

diff --git a/src/cmd/compile/internal/importer/support.go b/src/cmd/compile/internal/importer/support.go
index cac87745fe..b143913583 100644
--- a/src/cmd/compile/internal/importer/support.go
+++ b/src/cmd/compile/internal/importer/support.go
@@ -127,7 +127,3 @@ type anyType struct{}
 func (t anyType) Underlying() types2.Type { return t }
 func (t anyType) Under() types2.Type      { return t }
 func (t anyType) String() string          { return "any" }
-
-// types2.aType is not exported for now so we need to implemented these here.
-func (anyType) Named() *types2.Named         { return nil }
-func (anyType) TypeParam() *types2.TypeParam { return nil }
diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go
index 763122bc5b..16e294d226 100644
--- a/src/cmd/compile/internal/types2/builtins.go
+++ b/src/cmd/compile/internal/types2/builtins.go
@@ -577,7 +577,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 
 	case _Alignof:
 		// unsafe.Alignof(x T) uintptr
-		if x.typ.TypeParam() != nil {
+		if asTypeParam(x.typ) != nil {
 			check.invalidOpf(call, "unsafe.Alignof undefined for %s", x)
 			return
 		}
@@ -638,7 +638,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 
 	case _Sizeof:
 		// unsafe.Sizeof(x T) uintptr
-		if x.typ.TypeParam() != nil {
+		if asTypeParam(x.typ) != nil {
 			check.invalidOpf(call, "unsafe.Sizeof undefined for %s", x)
 			return
 		}
@@ -705,7 +705,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 // applyTypeFunc returns nil.
 // If x is not a type parameter, the result is f(x).
 func (check *Checker) applyTypeFunc(f func(Type) Type, x Type) Type {
-	if tp := x.TypeParam(); tp != nil {
+	if tp := asTypeParam(x); tp != nil {
 		// Test if t satisfies the requirements for the argument
 		// type and collect possible result types at the same time.
 		var rtypes []Type
diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index 10db701324..67a76d14fb 100644
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -563,7 +563,7 @@ func (check *Checker) selector(x *operand, e *syntax.SelectorExpr) {
 			check.errorf(e.Sel, "cannot call pointer method %s on %s", sel, x.typ)
 		default:
 			var why string
-			if tpar := x.typ.TypeParam(); tpar != nil {
+			if tpar := asTypeParam(x.typ); tpar != nil {
 				// Type parameter bounds don't specify fields, so don't mention "field".
 				switch obj := tpar.Bound().obj.(type) {
 				case nil:
diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index 59d0a112b1..e9fc08df37 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -559,7 +559,7 @@ func (n0 *Named) Under() Type {
 
 	// If the underlying type of a defined type is not a defined
 	// type, then that is the desired underlying type.
-	n := u.Named()
+	n := asNamed(u)
 	if n == nil {
 		return u // common case
 	}
@@ -573,7 +573,7 @@ func (n0 *Named) Under() Type {
 			u = Typ[Invalid]
 			break
 		}
-		n1 := u.Named()
+		n1 := asNamed(u)
 		if n1 == nil {
 			break // end of chain
 		}
@@ -760,7 +760,7 @@ func (check *Checker) collectMethods(obj *TypeName) {
 
 	// spec: "If the base type is a struct type, the non-blank method
 	// and field names must be distinct."
-	base := obj.typ.Named() // shouldn't fail but be conservative
+	base := asNamed(obj.typ) // shouldn't fail but be conservative
 	if base != nil {
 		if t, _ := base.underlying.(*Struct); t != nil {
 			for _, fld := range t.fields {
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 07b23c9eff..57c8896e0d 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -615,7 +615,7 @@ func (check *Checker) convertUntyped(x *operand, target Type) {
 	// TODO(gri) We should not need this because we have the code
 	// for Sum types in convertUntypedInternal. But at least one
 	// test fails. Investigate.
-	if t := target.TypeParam(); t != nil {
+	if t := asTypeParam(target); t != nil {
 		types := t.Bound().allTypes
 		if types == nil {
 			goto Error
diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go
index df25c9cf70..e210850ba0 100644
--- a/src/cmd/compile/internal/types2/lookup.go
+++ b/src/cmd/compile/internal/types2/lookup.go
@@ -54,7 +54,7 @@ func (check *Checker) lookupFieldOrMethod(T Type, addressable bool, pkg *Package
 	// Thus, if we have a named pointer type, proceed with the underlying
 	// pointer type but discard the result if it is a method since we would
 	// not have found it for T (see also issue 8590).
-	if t := T.Named(); t != nil {
+	if t := asNamed(T); t != nil {
 		if p, _ := t.underlying.(*Pointer); p != nil {
 			obj, index, indirect = check.rawLookupFieldOrMethod(p, false, pkg, name)
 			if _, ok := obj.(*Func); ok {
@@ -112,7 +112,7 @@ func (check *Checker) rawLookupFieldOrMethod(T Type, addressable bool, pkg *Pack
 
 			// If we have a named type, we may have associated methods.
 			// Look for those first.
-			if named := typ.Named(); named != nil {
+			if named := asNamed(typ); named != nil {
 				if seen[named] {
 					// We have seen this type before, at a more shallow depth
 					// (note that multiples of this type at the current depth
@@ -142,7 +142,7 @@ func (check *Checker) rawLookupFieldOrMethod(T Type, addressable bool, pkg *Pack
 				// continue with underlying type, but only if it's not a type parameter
 				// TODO(gri) is this what we want to do for type parameters? (spec question)
 				typ = named.Under()
-				if typ.TypeParam() != nil {
+				if asTypeParam(typ) != nil {
 					continue
 				}
 			}
@@ -352,7 +352,7 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
 
 	// A concrete type implements T if it implements all methods of T.
 	Vd, _ := deref(V)
-	Vn := Vd.Named()
+	Vn := asNamed(Vd)
 	for _, m := range T.allMethods {
 		// TODO(gri) should this be calling lookupFieldOrMethod instead (and why not)?
 		obj, _, _ := check.rawLookupFieldOrMethod(V, false, m.pkg, m.name)
diff --git a/src/cmd/compile/internal/types2/operand.go b/src/cmd/compile/internal/types2/operand.go
index dcd29fbce0..238c9b8ee0 100644
--- a/src/cmd/compile/internal/types2/operand.go
+++ b/src/cmd/compile/internal/types2/operand.go
@@ -180,7 +180,7 @@ func operandString(x *operand, qf Qualifier) string {
 			switch {
 			case isGeneric(x.typ):
 				intro = " of generic type "
-			case x.typ.TypeParam() != nil:
+			case asTypeParam(x.typ) != nil:
 				intro = " of type parameter type "
 			default:
 				intro = " of type "
diff --git a/src/cmd/compile/internal/types2/predicates.go b/src/cmd/compile/internal/types2/predicates.go
index a7972c6928..a48e72b9c4 100644
--- a/src/cmd/compile/internal/types2/predicates.go
+++ b/src/cmd/compile/internal/types2/predicates.go
@@ -104,7 +104,7 @@ func comparable(T Type, seen map[Type]bool) bool {
 	//     interface{ comparable; type []byte }
 	//
 	// is not comparable because []byte is not comparable.
-	if t := T.TypeParam(); t != nil && optype(t) == theTop {
+	if t := asTypeParam(T); t != nil && optype(t) == theTop {
 		return t.Bound().IsComparable()
 	}
 
diff --git a/src/cmd/compile/internal/types2/subst.go b/src/cmd/compile/internal/types2/subst.go
index 27405d8f41..fc4b228e33 100644
--- a/src/cmd/compile/internal/types2/subst.go
+++ b/src/cmd/compile/internal/types2/subst.go
@@ -146,7 +146,7 @@ func (check *Checker) instantiate(pos syntax.Pos, typ Type, targs []Type, poslis
 			// If the type argument is a pointer to a type parameter, the type argument's
 			// method set is empty.
 			// TODO(gri) is this what we want? (spec question)
-			if base, isPtr := deref(targ); isPtr && base.TypeParam() != nil {
+			if base, isPtr := deref(targ); isPtr && asTypeParam(base) != nil {
 				check.errorf(pos, "%s has no methods", targ)
 				break
 			}
@@ -179,7 +179,7 @@ func (check *Checker) instantiate(pos syntax.Pos, typ Type, targs []Type, poslis
 
 		// If targ is itself a type parameter, each of its possible types, but at least one, must be in the
 		// list of iface types (i.e., the targ type list must be a non-empty subset of the iface types).
-		if targ := targ.TypeParam(); targ != nil {
+		if targ := asTypeParam(targ); targ != nil {
 			targBound := targ.Bound()
 			if targBound.allTypes == nil {
 				check.softErrorf(pos, "%s does not satisfy %s (%s has no type constraints)", targ, tpar.bound, targ)
diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
index f90abba8da..4b6f507393 100644
--- a/src/cmd/compile/internal/types2/type.go
+++ b/src/cmd/compile/internal/types2/type.go
@@ -26,13 +26,6 @@ type Type interface {
 
 	// String returns a string representation of a type.
 	String() string
-
-	// If the receiver for Named and TypeParam is of
-	// the respective type (possibly after unpacking
-	// an instance type), these methods return that
-	// type. Otherwise the result is nil.
-	Named() *Named
-	TypeParam() *TypeParam
 }
 
 // aType implements default type behavior
@@ -43,9 +36,6 @@ func (aType) Underlying() Type { panic("unreachable") }
 func (aType) Under() Type      { panic("unreachable") }
 func (aType) String() string   { panic("unreachable") }
 
-func (aType) Named() *Named         { return nil }
-func (aType) TypeParam() *TypeParam { return nil }
-
 // BasicKind describes the kind of basic type.
 type BasicKind int
 
@@ -209,6 +199,9 @@ type Tuple struct {
 	aType
 }
 
+// TODO(gri) Don't represent empty tuples with a (*Tuple)(nil) pointer;
+//           it's too subtle and causes problems. Use a singleton instead.
+
 // NewTuple returns a new tuple for the given variables.
 func NewTuple(x ...*Var) *Tuple {
 	if len(x) > 0 {
@@ -217,16 +210,6 @@ func NewTuple(x ...*Var) *Tuple {
 	return nil
 }
 
-// We cannot rely on the embedded X() *X methods because (*Tuple)(nil)
-// is a valid *Tuple value but (*Tuple)(nil).X() would panic without
-// these implementations. At the moment we only need X = Basic, Named,
-// but add all because missing one leads to very confusing bugs.
-// TODO(gri) Don't represent empty tuples with a (*Tuple)(nil) pointer;
-//           it's too subtle and causes problems.
-
-func (*Tuple) Named() *Named         { return nil }
-func (*Tuple) TypeParam() *TypeParam { return nil }
-
 // Len returns the number variables of tuple t.
 func (t *Tuple) Len() int {
 	if t != nil {
@@ -730,9 +713,6 @@ func (check *Checker) NewNamed(obj *TypeName, underlying Type, methods []*Func)
 // Obj returns the type name for the named type t.
 func (t *Named) Obj() *TypeName { return t.obj }
 
-// func (t *Named) Named() *Named      // declared below
-func (t *Named) TypeParam() *TypeParam { return t.Under().TypeParam() }
-
 // TODO(gri) Come up with a better representation and API to distinguish
 //           between parameterized instantiated and non-instantiated types.
 
@@ -814,7 +794,7 @@ func (t *TypeParam) Bound() *Interface {
 // result may be the bottom or top type, but it is never
 // the incoming type parameter.
 func optype(typ Type) Type {
-	if t := typ.TypeParam(); t != nil {
+	if t := asTypeParam(typ); t != nil {
 		// If the optype is typ, return the top type as we have
 		// no information. It also prevents infinite recursion
 		// via the TypeParam converter methods. This can happen
@@ -830,9 +810,6 @@ func optype(typ Type) Type {
 	return typ.Under()
 }
 
-// func (t *TypeParam) Named() *Named         // Named does not unpack type parameters
-// func (t *TypeParam) TypeParam() *TypeParam // declared below
-
 // An instance represents an instantiated generic type syntactically
 // (without expanding the instantiation). Type instances appear only
 // during type-checking and are replaced by their fully instantiated
@@ -847,9 +824,6 @@ type instance struct {
 	aType
 }
 
-func (t *instance) Named() *Named         { return t.expand().Named() }
-func (t *instance) TypeParam() *TypeParam { return t.expand().TypeParam() }
-
 // expand returns the instantiated (= expanded) type of t.
 // The result is either an instantiated *Named type, or
 // Typ[Invalid] if there was an error.
@@ -908,9 +882,6 @@ type top struct {
 // theTop is the singleton top type.
 var theTop = &top{}
 
-func (t *Named) Named() *Named             { return t }
-func (t *TypeParam) TypeParam() *TypeParam { return t }
-
 // Type-specific implementations of Underlying.
 func (t *Basic) Underlying() Type     { return t }
 func (t *Array) Underlying() Type     { return t }
@@ -1025,3 +996,17 @@ func asChan(t Type) *Chan {
 	op, _ := optype(t).(*Chan)
 	return op
 }
+
+// If the argument to asNamed and asTypeParam is of the respective types
+// (possibly after expanding an instance type), these methods return that type.
+// Otherwise the result is nil.
+
+func asNamed(t Type) *Named {
+	e, _ := expand(t).(*Named)
+	return e
+}
+
+func asTypeParam(t Type) *TypeParam {
+	u, _ := t.Under().(*TypeParam)
+	return u
+}
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 7ee28abac3..cf9d7c0a40 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -302,7 +302,7 @@ func (check *Checker) funcType(sig *Signature, recvPar *syntax.Field, tparams []
 				// Also: Don't report an error via genericType since it will be reported
 				//       again when we type-check the signature.
 				// TODO(gri) maybe the receiver should be marked as invalid instead?
-				if recv := check.genericType(rname, false).Named(); recv != nil {
+				if recv := asNamed(check.genericType(rname, false)); recv != nil {
 					recvTParams = recv.tparams
 				}
 			}
@@ -382,7 +382,7 @@ func (check *Checker) funcType(sig *Signature, recvPar *syntax.Field, tparams []
 		// (ignore invalid types - error was reported before)
 		if t := rtyp; t != Typ[Invalid] {
 			var err string
-			if T := t.Named(); T != nil {
+			if T := asNamed(t); T != nil {
 				// spec: "The type denoted by T is called the receiver base type; it must not
 				// be a pointer or interface type and it must be declared in the same package
 				// as the method."
@@ -575,7 +575,7 @@ func (check *Checker) typInternal(e0 syntax.Expr, def *Named) (T Type) {
 		check.atEnd(func() {
 			if !Comparable(typ.key) {
 				var why string
-				if typ.key.TypeParam() != nil {
+				if asTypeParam(typ.key) != nil {
 					why = " (missing comparable constraint)"
 				}
 				check.errorf(e.Key, "invalid map key type %s%s", typ.key, why)
@@ -644,7 +644,7 @@ func (check *Checker) instantiatedType(x syntax.Expr, targs []syntax.Expr, def *
 	if b == Typ[Invalid] {
 		return b // error already reported
 	}
-	base := b.Named()
+	base := asNamed(b)
 	if base == nil {
 		unreachable() // should have been caught by genericType
 	}
@@ -1045,7 +1045,7 @@ func (a byUniqueTypeName) Less(i, j int) bool { return sortName(a[i]) < sortName
 func (a byUniqueTypeName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
 
 func sortName(t Type) string {
-	if named := t.Named(); named != nil {
+	if named := asNamed(t); named != nil {
 		return named.obj.Id()
 	}
 	return ""
diff --git a/src/cmd/compile/internal/types2/unify.go b/src/cmd/compile/internal/types2/unify.go
index ab19c5a38b..153df9d622 100644
--- a/src/cmd/compile/internal/types2/unify.go
+++ b/src/cmd/compile/internal/types2/unify.go
@@ -211,12 +211,12 @@ func (u *unifier) nify(x, y Type, p *ifacePair) bool {
 		// match a type name against an unnamed type literal, consider
 		// the underlying type of the named type.
 		// (Subtle: We use isNamed to include any type with a name (incl.
-		// basic types and type parameters. We use Named() because we only
+		// basic types and type parameters. We use asNamed because we only
 		// want *Named types.)
 		switch {
-		case !isNamed(x) && y != nil && y.Named() != nil:
+		case !isNamed(x) && y != nil && asNamed(y) != nil:
 			return u.nify(x, y.Under(), p)
-		case x != nil && x.Named() != nil && !isNamed(y):
+		case x != nil && asNamed(x) != nil && !isNamed(y):
 			return u.nify(x.Under(), y, p)
 		}
 	}
diff --git a/src/cmd/compile/internal/types2/universe.go b/src/cmd/compile/internal/types2/universe.go
index dc79902777..994e298a6c 100644
--- a/src/cmd/compile/internal/types2/universe.go
+++ b/src/cmd/compile/internal/types2/universe.go
@@ -255,7 +255,7 @@ func def(obj Object) {
 		return // nothing to do
 	}
 	// fix Obj link for named types
-	if typ := obj.Type().Named(); typ != nil {
+	if typ := asNamed(obj.Type()); typ != nil {
 		typ.obj = obj.(*TypeName)
 	}
 	// exported identifiers go into package unsafe
-- 
GitLab


From 099374b55e8aed17d1e77a1084f8fb78ff2f8162 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 17 Feb 2021 17:56:34 -0800
Subject: [PATCH 0672/2400] [dev.typeparams] cmd/compile/internal/types2:
 remove Type.Under method in favor of function

This removes the need for the aType embedded type and brings the types2.Type
API in sync with the go/types.Type API.

For reasons not fully understood yet, introducing the new under function
causes a very long initialization cycle error, which doesn't exist in
go/types. For now, circumvent the problem through a helper function variable.

This CL also eliminates superflous (former) Under() method calls
inside optype calls (optype takes care of this).

Plus some minor misc. cleanups and comment adjustments.

Change-Id: I86e13ccf6f0b34d7496240ace61a1c84856b6033
Reviewed-on: https://go-review.googlesource.com/c/go/+/293470
Reviewed-by: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/importer/support.go  |   1 -
 src/cmd/compile/internal/types2/builtins.go   |   8 +-
 .../compile/internal/types2/conversions.go    |   8 +-
 src/cmd/compile/internal/types2/decl.go       |  12 +-
 src/cmd/compile/internal/types2/expr.go       |  14 +--
 src/cmd/compile/internal/types2/infer.go      |   4 +-
 src/cmd/compile/internal/types2/lookup.go     |   2 +-
 src/cmd/compile/internal/types2/object.go     |   2 +-
 src/cmd/compile/internal/types2/operand.go    |   4 +-
 src/cmd/compile/internal/types2/predicates.go |   8 +-
 src/cmd/compile/internal/types2/sizes.go      |   4 +-
 src/cmd/compile/internal/types2/stmt.go       |   6 +-
 src/cmd/compile/internal/types2/subst.go      |   6 +-
 src/cmd/compile/internal/types2/type.go       | 108 ++++++------------
 src/cmd/compile/internal/types2/typexpr.go    |  12 +-
 src/cmd/compile/internal/types2/unify.go      |   4 +-
 src/cmd/compile/internal/types2/universe.go   |  60 +++++-----
 17 files changed, 113 insertions(+), 150 deletions(-)

diff --git a/src/cmd/compile/internal/importer/support.go b/src/cmd/compile/internal/importer/support.go
index b143913583..40b9c7c958 100644
--- a/src/cmd/compile/internal/importer/support.go
+++ b/src/cmd/compile/internal/importer/support.go
@@ -125,5 +125,4 @@ var predeclared = []types2.Type{
 type anyType struct{}
 
 func (t anyType) Underlying() types2.Type { return t }
-func (t anyType) Under() types2.Type      { return t }
 func (t anyType) String() string          { return "any" }
diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go
index 16e294d226..a6a9b51dd1 100644
--- a/src/cmd/compile/internal/types2/builtins.go
+++ b/src/cmd/compile/internal/types2/builtins.go
@@ -142,7 +142,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 		mode := invalid
 		var typ Type
 		var val constant.Value
-		switch typ = implicitArrayDeref(optype(x.typ.Under())); t := typ.(type) {
+		switch typ = implicitArrayDeref(optype(x.typ)); t := typ.(type) {
 		case *Basic:
 			if isString(t) && id == _Len {
 				if x.mode == constant_ {
@@ -178,7 +178,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 
 		case *Sum:
 			if t.is(func(t Type) bool {
-				switch t := t.Under().(type) {
+				switch t := under(t).(type) {
 				case *Basic:
 					if isString(t) && id == _Len {
 						return true
@@ -330,7 +330,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 			return
 		}
 		var src Type
-		switch t := optype(y.typ.Under()).(type) {
+		switch t := optype(y.typ).(type) {
 		case *Basic:
 			if isString(y.typ) {
 				src = universeByte
@@ -453,7 +453,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 		var valid func(t Type) bool
 		valid = func(t Type) bool {
 			var m int
-			switch t := optype(t.Under()).(type) {
+			switch t := optype(t).(type) {
 			case *Slice:
 				m = 2
 			case *Map, *Chan:
diff --git a/src/cmd/compile/internal/types2/conversions.go b/src/cmd/compile/internal/types2/conversions.go
index c9603b263c..dc0621919e 100644
--- a/src/cmd/compile/internal/types2/conversions.go
+++ b/src/cmd/compile/internal/types2/conversions.go
@@ -90,8 +90,8 @@ func (x *operand) convertibleTo(check *Checker, T Type) bool {
 
 	// "x's type and T have identical underlying types if tags are ignored"
 	V := x.typ
-	Vu := V.Under()
-	Tu := T.Under()
+	Vu := under(V)
+	Tu := under(T)
 	if check.identicalIgnoreTags(Vu, Tu) {
 		return true
 	}
@@ -100,7 +100,7 @@ func (x *operand) convertibleTo(check *Checker, T Type) bool {
 	// have identical underlying types if tags are ignored"
 	if V, ok := V.(*Pointer); ok {
 		if T, ok := T.(*Pointer); ok {
-			if check.identicalIgnoreTags(V.base.Under(), T.base.Under()) {
+			if check.identicalIgnoreTags(under(V.base), under(T.base)) {
 				return true
 			}
 		}
@@ -146,7 +146,7 @@ func isUintptr(typ Type) bool {
 
 func isUnsafePointer(typ Type) bool {
 	// TODO(gri): Is this asBasic(typ) instead of typ.(*Basic) correct?
-	//            (The former calls typ.Under(), while the latter doesn't.)
+	//            (The former calls under(), while the latter doesn't.)
 	//            The spec does not say so, but gc claims it is. See also
 	//            issue 6326.
 	t := asBasic(typ)
diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index e9fc08df37..677172d40f 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -445,7 +445,7 @@ func (check *Checker) constDecl(obj *Const, typ, init syntax.Expr, inherited boo
 		if !isConstType(t) {
 			// don't report an error if the type is an invalid C (defined) type
 			// (issue #22090)
-			if t.Under() != Typ[Invalid] {
+			if under(t) != Typ[Invalid] {
 				check.errorf(typ, "invalid constant type %s", t)
 			}
 			obj.typ = Typ[Invalid]
@@ -545,13 +545,13 @@ func (check *Checker) varDecl(obj *Var, lhs []*Var, typ, init syntax.Expr) {
 	check.initVars(lhs, []syntax.Expr{init}, nopos)
 }
 
-// Under returns the expanded underlying type of n0; possibly by following
+// under returns the expanded underlying type of n0; possibly by following
 // forward chains of named types. If an underlying type is found, resolve
 // the chain by setting the underlying type for each defined type in the
 // chain before returning it. If no underlying type is found or a cycle
 // is detected, the result is Typ[Invalid]. If a cycle is detected and
 // n0.check != nil, the cycle is reported.
-func (n0 *Named) Under() Type {
+func (n0 *Named) under() Type {
 	u := n0.underlying
 	if u == nil {
 		return Typ[Invalid]
@@ -584,6 +584,8 @@ func (n0 *Named) Under() Type {
 
 		if i, ok := seen[n]; ok {
 			// cycle
+			// TODO(gri) revert this to a method on Checker. Having a possibly
+			// nil Checker on Named and TypeParam is too subtle.
 			if n0.check != nil {
 				n0.check.cycleError(path[i:])
 			}
@@ -667,7 +669,7 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *syntax.TypeDecl, def *Named
 		// any forward chain.
 		// TODO(gri) Investigate if we can just use named.origin here
 		//           and rely on lazy computation of the underlying type.
-		named.underlying = named.Under()
+		named.underlying = under(named)
 	}
 
 }
@@ -716,7 +718,7 @@ func (check *Checker) collectTypeParams(list []*syntax.Field) (tparams []*TypeNa
 		//           we may not have a complete interface yet:
 		//           type C(type T C) interface {}
 		//           (issue #39724).
-		if _, ok := bound.Under().(*Interface); ok {
+		if _, ok := under(bound).(*Interface); ok {
 			// set the type bounds
 			for i < j {
 				tparams[i].typ.(*TypeParam).bound = bound
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 57c8896e0d..a284c8c8b6 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -656,7 +656,7 @@ func (check *Checker) convertUntypedInternal(x *operand, target Type) {
 	}
 
 	// typed target
-	switch t := optype(target.Under()).(type) {
+	switch t := optype(target).(type) {
 	case *Basic:
 		if x.mode == constant_ {
 			check.representable(x, t)
@@ -1258,7 +1258,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 		case hint != nil:
 			// no composite literal type present - use hint (element type of enclosing type)
 			typ = hint
-			base, _ = deref(typ.Under()) // *T implies &T{}
+			base, _ = deref(under(typ)) // *T implies &T{}
 
 		default:
 			// TODO(gri) provide better error messages depending on context
@@ -1266,7 +1266,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 			goto Error
 		}
 
-		switch utyp := optype(base.Under()).(type) {
+		switch utyp := optype(base).(type) {
 		case *Struct:
 			if len(e.ElemList) == 0 {
 				break
@@ -1475,7 +1475,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 		// ordinary index expression
 		valid := false
 		length := int64(-1) // valid if >= 0
-		switch typ := optype(x.typ.Under()).(type) {
+		switch typ := optype(x.typ).(type) {
 		case *Basic:
 			if isString(typ) {
 				valid = true
@@ -1528,7 +1528,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 			nmaps := 0           // number of map types in sum type
 			if typ.is(func(t Type) bool {
 				var e Type
-				switch t := t.Under().(type) {
+				switch t := under(t).(type) {
 				case *Basic:
 					if isString(t) {
 						e = universeByte
@@ -1637,7 +1637,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 
 		valid := false
 		length := int64(-1) // valid if >= 0
-		switch typ := optype(x.typ.Under()).(type) {
+		switch typ := optype(x.typ).(type) {
 		case *Basic:
 			if isString(typ) {
 				if e.Full {
@@ -1738,7 +1738,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 		if x.mode == invalid {
 			goto Error
 		}
-		xtyp, _ := x.typ.Under().(*Interface)
+		xtyp, _ := under(x.typ).(*Interface)
 		if xtyp == nil {
 			check.errorf(x, "%s is not an interface type", x)
 			goto Error
diff --git a/src/cmd/compile/internal/types2/infer.go b/src/cmd/compile/internal/types2/infer.go
index 09d099e625..061b919239 100644
--- a/src/cmd/compile/internal/types2/infer.go
+++ b/src/cmd/compile/internal/types2/infer.go
@@ -289,7 +289,7 @@ func (check *Checker) inferB(tparams []*TypeName, targs []Type) (types []Type, i
 	// Unify type parameters with their structural constraints, if any.
 	for _, tpar := range tparams {
 		typ := tpar.typ.(*TypeParam)
-		sbound := check.structuralType(typ.bound.Under())
+		sbound := check.structuralType(typ.bound)
 		if sbound != nil {
 			if !u.unify(typ, sbound) {
 				check.errorf(tpar.pos, "%s does not match %s", tpar, sbound)
@@ -344,7 +344,7 @@ func (check *Checker) inferB(tparams []*TypeName, targs []Type) (types []Type, i
 
 // structuralType returns the structural type of a constraint, if any.
 func (check *Checker) structuralType(constraint Type) Type {
-	if iface, _ := constraint.(*Interface); iface != nil {
+	if iface, _ := under(constraint).(*Interface); iface != nil {
 		check.completeInterface(nopos, iface)
 		types := unpack(iface.allTypes)
 		if len(types) == 1 {
diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go
index e210850ba0..34d18acdfc 100644
--- a/src/cmd/compile/internal/types2/lookup.go
+++ b/src/cmd/compile/internal/types2/lookup.go
@@ -141,7 +141,7 @@ func (check *Checker) rawLookupFieldOrMethod(T Type, addressable bool, pkg *Pack
 
 				// continue with underlying type, but only if it's not a type parameter
 				// TODO(gri) is this what we want to do for type parameters? (spec question)
-				typ = named.Under()
+				typ = under(named)
 				if asTypeParam(typ) != nil {
 					continue
 				}
diff --git a/src/cmd/compile/internal/types2/object.go b/src/cmd/compile/internal/types2/object.go
index 956646499a..844bc34b6a 100644
--- a/src/cmd/compile/internal/types2/object.go
+++ b/src/cmd/compile/internal/types2/object.go
@@ -461,7 +461,7 @@ func writeObject(buf *bytes.Buffer, obj Object, qf Qualifier) {
 		if tname.IsAlias() {
 			buf.WriteString(" =")
 		} else {
-			typ = typ.Under()
+			typ = under(typ)
 		}
 	}
 
diff --git a/src/cmd/compile/internal/types2/operand.go b/src/cmd/compile/internal/types2/operand.go
index 238c9b8ee0..001e905a7b 100644
--- a/src/cmd/compile/internal/types2/operand.go
+++ b/src/cmd/compile/internal/types2/operand.go
@@ -257,8 +257,8 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) bool {
 		return true
 	}
 
-	Vu := optype(V.Under())
-	Tu := optype(T.Under())
+	Vu := optype(V)
+	Tu := optype(T)
 
 	// x is an untyped value representable by a value of type T
 	// TODO(gri) This is borrowing from checker.convertUntyped and
diff --git a/src/cmd/compile/internal/types2/predicates.go b/src/cmd/compile/internal/types2/predicates.go
index a48e72b9c4..ae186a0b5d 100644
--- a/src/cmd/compile/internal/types2/predicates.go
+++ b/src/cmd/compile/internal/types2/predicates.go
@@ -25,7 +25,7 @@ func isGeneric(typ Type) bool {
 }
 
 func is(typ Type, what BasicInfo) bool {
-	switch t := optype(typ.Under()).(type) {
+	switch t := optype(typ).(type) {
 	case *Basic:
 		return t.info&what != 0
 	case *Sum:
@@ -73,7 +73,7 @@ func isOrdered(typ Type) bool { return is(typ, IsOrdered) }
 
 func isConstType(typ Type) bool {
 	// Type parameters are never const types.
-	t, _ := typ.Under().(*Basic)
+	t, _ := under(typ).(*Basic)
 	return t != nil && t.info&IsConstType != 0
 }
 
@@ -108,7 +108,7 @@ func comparable(T Type, seen map[Type]bool) bool {
 		return t.Bound().IsComparable()
 	}
 
-	switch t := optype(T.Under()).(type) {
+	switch t := optype(T).(type) {
 	case *Basic:
 		// assume invalid types to be comparable
 		// to avoid follow-up errors
@@ -137,7 +137,7 @@ func comparable(T Type, seen map[Type]bool) bool {
 
 // hasNil reports whether a type includes the nil value.
 func hasNil(typ Type) bool {
-	switch t := optype(typ.Under()).(type) {
+	switch t := optype(typ).(type) {
 	case *Basic:
 		return t.kind == UnsafePointer
 	case *Slice, *Pointer, *Signature, *Interface, *Map, *Chan:
diff --git a/src/cmd/compile/internal/types2/sizes.go b/src/cmd/compile/internal/types2/sizes.go
index 9d8f3ae5ad..aa0fbf40fc 100644
--- a/src/cmd/compile/internal/types2/sizes.go
+++ b/src/cmd/compile/internal/types2/sizes.go
@@ -48,7 +48,7 @@ type StdSizes struct {
 func (s *StdSizes) Alignof(T Type) int64 {
 	// For arrays and structs, alignment is defined in terms
 	// of alignment of the elements and fields, respectively.
-	switch t := optype(T.Under()).(type) {
+	switch t := optype(T).(type) {
 	case *Array:
 		// spec: "For a variable x of array type: unsafe.Alignof(x)
 		// is the same as unsafe.Alignof(x[0]), but at least 1."
@@ -118,7 +118,7 @@ var basicSizes = [...]byte{
 }
 
 func (s *StdSizes) Sizeof(T Type) int64 {
-	switch t := optype(T.Under()).(type) {
+	switch t := optype(T).(type) {
 	case *Basic:
 		assert(isTyped(T))
 		k := t.kind
diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go
index 9d74e0e588..490cd0fc19 100644
--- a/src/cmd/compile/internal/types2/stmt.go
+++ b/src/cmd/compile/internal/types2/stmt.go
@@ -680,7 +680,7 @@ func (check *Checker) typeSwitchStmt(inner stmtContext, s *syntax.SwitchStmt, gu
 	if x.mode == invalid {
 		return
 	}
-	xtyp, _ := x.typ.Under().(*Interface)
+	xtyp, _ := under(x.typ).(*Interface)
 	if xtyp == nil {
 		check.errorf(&x, "%s is not an interface type", &x)
 		return
@@ -769,7 +769,7 @@ func (check *Checker) rangeStmt(inner stmtContext, s *syntax.ForStmt, rclause *s
 	// determine key/value types
 	var key, val Type
 	if x.mode != invalid {
-		typ := optype(x.typ.Under())
+		typ := optype(x.typ)
 		if _, ok := typ.(*Chan); ok && sValue != nil {
 			// TODO(gri) this also needs to happen for channels in generic variables
 			check.softErrorf(sValue, "range over %s permits only one iteration variable", &x)
@@ -906,7 +906,7 @@ func rangeKeyVal(typ Type, wantKey, wantVal bool) (Type, Type, string) {
 		var key, val Type
 		var msg string
 		typ.is(func(t Type) bool {
-			k, v, m := rangeKeyVal(t.Under(), wantKey, wantVal)
+			k, v, m := rangeKeyVal(under(t), wantKey, wantVal)
 			if k == nil || m != "" {
 				key, val, msg = k, v, m
 				return false
diff --git a/src/cmd/compile/internal/types2/subst.go b/src/cmd/compile/internal/types2/subst.go
index fc4b228e33..d730642831 100644
--- a/src/cmd/compile/internal/types2/subst.go
+++ b/src/cmd/compile/internal/types2/subst.go
@@ -61,7 +61,7 @@ func (check *Checker) instantiate(pos syntax.Pos, typ Type, targs []Type, poslis
 			check.indent--
 			var under Type
 			if res != nil {
-				// Calling Under() here may lead to endless instantiations.
+				// Calling under() here may lead to endless instantiations.
 				// Test case: type T[P any] T[P]
 				// TODO(gri) investigate if that's a bug or to be expected.
 				under = res.Underlying()
@@ -186,7 +186,7 @@ func (check *Checker) instantiate(pos syntax.Pos, typ Type, targs []Type, poslis
 				break
 			}
 			for _, t := range unpack(targBound.allTypes) {
-				if !iface.isSatisfiedBy(t.Under()) {
+				if !iface.isSatisfiedBy(t) {
 					// TODO(gri) match this error message with the one below (or vice versa)
 					check.softErrorf(pos, "%s does not satisfy %s (%s type constraint %s not found in %s)", targ, tpar.bound, targ, t, iface.allTypes)
 					break
@@ -197,7 +197,7 @@ func (check *Checker) instantiate(pos syntax.Pos, typ Type, targs []Type, poslis
 
 		// Otherwise, targ's type or underlying type must also be one of the interface types listed, if any.
 		if !iface.isSatisfiedBy(targ) {
-			check.softErrorf(pos, "%s does not satisfy %s (%s not found in %s)", targ, tpar.bound, targ.Under(), iface.allTypes)
+			check.softErrorf(pos, "%s does not satisfy %s (%s not found in %s)", targ, tpar.bound, under(targ), iface.allTypes)
 			break
 		}
 	}
diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
index 4b6f507393..c1c3a4629e 100644
--- a/src/cmd/compile/internal/types2/type.go
+++ b/src/cmd/compile/internal/types2/type.go
@@ -18,24 +18,10 @@ type Type interface {
 	// client packages (here for backward-compatibility).
 	Underlying() Type
 
-	// Under returns the true expanded underlying type.
-	// If it doesn't exist, the result is Typ[Invalid].
-	// Under must only be called when a type is known
-	// to be fully set up.
-	Under() Type
-
 	// String returns a string representation of a type.
 	String() string
 }
 
-// aType implements default type behavior
-type aType struct{}
-
-// These methods must be implemented by each type.
-func (aType) Underlying() Type { panic("unreachable") }
-func (aType) Under() Type      { panic("unreachable") }
-func (aType) String() string   { panic("unreachable") }
-
 // BasicKind describes the kind of basic type.
 type BasicKind int
 
@@ -99,7 +85,6 @@ type Basic struct {
 	kind BasicKind
 	info BasicInfo
 	name string
-	aType
 }
 
 // Kind returns the kind of basic type b.
@@ -115,7 +100,6 @@ func (b *Basic) Name() string { return b.name }
 type Array struct {
 	len  int64
 	elem Type
-	aType
 }
 
 // NewArray returns a new array type for the given element type and length.
@@ -132,7 +116,6 @@ func (a *Array) Elem() Type { return a.elem }
 // A Slice represents a slice type.
 type Slice struct {
 	elem Type
-	aType
 }
 
 // NewSlice returns a new slice type for the given element type.
@@ -145,7 +128,6 @@ func (s *Slice) Elem() Type { return s.elem }
 type Struct struct {
 	fields []*Var
 	tags   []string // field tags; nil if there are no tags
-	aType
 }
 
 // NewStruct returns a new struct with the given fields and corresponding field tags.
@@ -182,7 +164,6 @@ func (s *Struct) Tag(i int) string {
 // A Pointer represents a pointer type.
 type Pointer struct {
 	base Type // element type
-	aType
 }
 
 // NewPointer returns a new pointer type for the given element (base) type.
@@ -196,17 +177,15 @@ func (p *Pointer) Elem() Type { return p.base }
 // assignments; they are not first class types of Go.
 type Tuple struct {
 	vars []*Var
-	aType
 }
 
-// TODO(gri) Don't represent empty tuples with a (*Tuple)(nil) pointer;
-//           it's too subtle and causes problems. Use a singleton instead.
-
 // NewTuple returns a new tuple for the given variables.
 func NewTuple(x ...*Var) *Tuple {
 	if len(x) > 0 {
 		return &Tuple{vars: x}
 	}
+	// TODO(gri) Don't represent empty tuples with a (*Tuple)(nil) pointer;
+	//           it's too subtle and causes problems.
 	return nil
 }
 
@@ -235,7 +214,6 @@ type Signature struct {
 	params   *Tuple      // (incoming) parameters from left to right; or nil
 	results  *Tuple      // (outgoing) results from left to right; or nil
 	variadic bool        // true if the last parameter's type is of the form ...T (or string, for append built-in only)
-	aType
 }
 
 // NewSignature returns a new function type for the given receiver, parameters,
@@ -284,7 +262,6 @@ func (s *Signature) Variadic() bool { return s.variadic }
 // first class types of Go.
 type Sum struct {
 	types []Type // types are unique
-	aType
 }
 
 // NewSum returns a new Sum type consisting of the provided
@@ -336,8 +313,6 @@ type Interface struct {
 	allTypes   Type    // intersection of all embedded and locally declared types  (TODO(gri) need better field name)
 
 	obj Object // type declaration defining this interface; or nil (for better error messages)
-
-	aType
 }
 
 // unpack unpacks a type into a list of types.
@@ -468,10 +443,7 @@ func (t *Interface) Empty() bool {
 		return len(t.allMethods) == 0 && t.allTypes == nil
 	}
 	return !t.iterate(func(t *Interface) bool {
-		if len(t.methods) > 0 || t.types != nil {
-			return true
-		}
-		return false
+		return len(t.methods) > 0 || t.types != nil
 	}, nil)
 }
 
@@ -483,10 +455,7 @@ func (t *Interface) HasTypeList() bool {
 	}
 
 	return t.iterate(func(t *Interface) bool {
-		if t.types != nil {
-			return true
-		}
-		return false
+		return t.types != nil
 	}, nil)
 }
 
@@ -560,7 +529,7 @@ func (t *Interface) isSatisfiedBy(typ Type) bool {
 		return true
 	}
 	types := unpack(t.allTypes)
-	return includes(types, typ) || includes(types, typ.Under())
+	return includes(types, typ) || includes(types, under(typ))
 }
 
 // Complete computes the interface's method set. It must be called by users of
@@ -598,7 +567,7 @@ func (t *Interface) Complete() *Interface {
 	allTypes := t.types
 
 	for _, typ := range t.embeddeds {
-		utyp := typ.Under()
+		utyp := under(typ)
 		etyp := asInterface(utyp)
 		if etyp == nil {
 			if utyp != Typ[Invalid] {
@@ -633,7 +602,6 @@ func (t *Interface) Complete() *Interface {
 // A Map represents a map type.
 type Map struct {
 	key, elem Type
-	aType
 }
 
 // NewMap returns a new map for the given key and element types.
@@ -651,7 +619,6 @@ func (m *Map) Elem() Type { return m.elem }
 type Chan struct {
 	dir  ChanDir
 	elem Type
-	aType
 }
 
 // A ChanDir value indicates a channel direction.
@@ -677,7 +644,7 @@ func (c *Chan) Elem() Type { return c.elem }
 
 // A Named represents a named (defined) type.
 type Named struct {
-	check      *Checker    // for Named.Under implementation
+	check      *Checker    // for Named.under implementation
 	info       typeInfo    // for cycle detection
 	obj        *TypeName   // corresponding declared object
 	orig       Type        // type (on RHS of declaration) this *Named type is derived of (for cycle reporting)
@@ -685,7 +652,6 @@ type Named struct {
 	tparams    []*TypeName // type parameters, or nil
 	targs      []Type      // type arguments (after instantiation), or nil
 	methods    []*Func     // methods declared for this type (not the method set of this type); signatures are type-checked lazily
-	aType
 }
 
 // NewNamed returns a new named type for the given type name, underlying type, and associated methods.
@@ -757,7 +723,6 @@ type TypeParam struct {
 	obj   *TypeName // corresponding type name
 	index int       // parameter index
 	bound Type      // *Named or *Interface; underlying type is always *Interface
-	aType
 }
 
 func (t *TypeParam) Obj() *TypeName {
@@ -788,7 +753,7 @@ func (t *TypeParam) Bound() *Interface {
 
 // optype returns a type's operational type. Except for
 // type parameters, the operational type is the same
-// as the underlying type (as returned by Under). For
+// as the underlying type (as returned by under). For
 // Type parameters, the operational type is determined
 // by the corresponding type bound's type list. The
 // result may be the bottom or top type, but it is never
@@ -802,12 +767,12 @@ func optype(typ Type) Type {
 		// (type T interface { type T }).
 		// See also issue #39680.
 		if u := t.Bound().allTypes; u != nil && u != typ {
-			// u != typ and u is a type parameter => u.Under() != typ, so this is ok
-			return u.Under()
+			// u != typ and u is a type parameter => under(u) != typ, so this is ok
+			return under(u)
 		}
 		return theTop
 	}
-	return typ.Under()
+	return under(typ)
 }
 
 // An instance represents an instantiated generic type syntactically
@@ -821,7 +786,6 @@ type instance struct {
 	targs   []Type       // type arguments
 	poslist []syntax.Pos // position of each targ; for error reporting only
 	value   Type         // base(targs...) after instantiation or Typ[Invalid]; nil if not yet set
-	aType
 }
 
 // expand returns the instantiated (= expanded) type of t.
@@ -863,9 +827,7 @@ func init() { expandf = expand }
 // It is the underlying type of a type parameter that
 // cannot be satisfied by any type, usually because
 // the intersection of type constraints left nothing).
-type bottom struct {
-	aType
-}
+type bottom struct{}
 
 // theBottom is the singleton bottom type.
 var theBottom = &bottom{}
@@ -875,9 +837,7 @@ var theBottom = &bottom{}
 // can be satisfied by any type (ignoring methods),
 // usually because the type constraint has no type
 // list.
-type top struct {
-	aType
-}
+type top struct{}
 
 // theTop is the singleton top type.
 var theTop = &top{}
@@ -900,25 +860,6 @@ func (t *instance) Underlying() Type  { return t }
 func (t *bottom) Underlying() Type    { return t }
 func (t *top) Underlying() Type       { return t }
 
-// Type-specific implementations of Under.
-func (t *Basic) Under() Type     { return t }
-func (t *Array) Under() Type     { return t }
-func (t *Slice) Under() Type     { return t }
-func (t *Struct) Under() Type    { return t }
-func (t *Pointer) Under() Type   { return t }
-func (t *Tuple) Under() Type     { return t }
-func (t *Signature) Under() Type { return t }
-func (t *Sum) Under() Type       { return t } // TODO(gri) is this correct?
-func (t *Interface) Under() Type { return t }
-func (t *Map) Under() Type       { return t }
-func (t *Chan) Under() Type      { return t }
-
-// see decl.go for implementation of Named.Under
-func (t *TypeParam) Under() Type { return t }
-func (t *instance) Under() Type  { return t.expand().Under() }
-func (t *bottom) Under() Type    { return t }
-func (t *top) Under() Type       { return t }
-
 // Type-specific implementations of String.
 func (t *Basic) String() string     { return TypeString(t, nil) }
 func (t *Array) String() string     { return TypeString(t, nil) }
@@ -937,6 +878,27 @@ func (t *instance) String() string  { return TypeString(t, nil) }
 func (t *bottom) String() string    { return TypeString(t, nil) }
 func (t *top) String() string       { return TypeString(t, nil) }
 
+// under returns the true expanded underlying type.
+// If it doesn't exist, the result is Typ[Invalid].
+// under must only be called when a type is known
+// to be fully set up.
+//
+// under is set to underf to avoid an initialization cycle.
+// TODO(gri) this doesn't happen in go/types - investigate
+var under func(Type) Type
+
+func init() {
+	under = underf
+}
+
+func underf(t Type) Type {
+	// TODO(gri) is this correct for *Sum?
+	if n := asNamed(t); n != nil {
+		return n.under()
+	}
+	return t
+}
+
 // Converters
 //
 // A converter must only be called when a type is
@@ -1007,6 +969,6 @@ func asNamed(t Type) *Named {
 }
 
 func asTypeParam(t Type) *TypeParam {
-	u, _ := t.Under().(*TypeParam)
+	u, _ := under(t).(*TypeParam)
 	return u
 }
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index cf9d7c0a40..87eabbe28d 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -138,7 +138,7 @@ func (check *Checker) varType(e syntax.Expr) Type {
 // ordinaryType reports an error if typ is an interface type containing
 // type lists or is (or embeds) the predeclared type comparable.
 func (check *Checker) ordinaryType(pos syntax.Pos, typ Type) {
-	// We don't want to call Under() (via Interface) or complete interfaces while we
+	// We don't want to call under() (via Interface) or complete interfaces while we
 	// are in the middle of type-checking parameter declarations that might belong to
 	// interface methods. Delay this check to the end of type-checking.
 	check.atEnd(func() {
@@ -393,7 +393,7 @@ func (check *Checker) funcType(sig *Signature, recvPar *syntax.Field, tparams []
 						err = ""
 					}
 				} else {
-					switch u := optype(T.Under()).(type) {
+					switch u := optype(T).(type) {
 					case *Basic:
 						// unsafe.Pointer is treated like a regular pointer
 						if u.kind == UnsafePointer {
@@ -442,7 +442,7 @@ func (check *Checker) typInternal(e0 syntax.Expr, def *Named) (T Type) {
 			check.indent--
 			var under Type
 			if T != nil {
-				// Calling Under() here may lead to endless instantiations.
+				// Calling under() here may lead to endless instantiations.
 				// Test case: type T[P any] *T[P]
 				// TODO(gri) investigate if that's a bug or to be expected
 				// (see also analogous comment in Checker.instantiate).
@@ -967,7 +967,7 @@ func (check *Checker) completeInterface(pos syntax.Pos, ityp *Interface) {
 	posList := check.posMap[ityp]
 	for i, typ := range ityp.embeddeds {
 		pos := posList[i] // embedding position
-		utyp := typ.Under()
+		utyp := under(typ)
 		etyp := asInterface(utyp)
 		if etyp == nil {
 			if utyp != Typ[Invalid] {
@@ -1159,12 +1159,12 @@ func (check *Checker) structType(styp *Struct, e *syntax.StructType) {
 			// Because we have a name, typ must be of the form T or *T, where T is the name
 			// of a (named or alias) type, and t (= deref(typ)) must be the type of T.
 			// We must delay this check to the end because we don't want to instantiate
-			// (via t.Under()) a possibly incomplete type.
+			// (via under(t)) a possibly incomplete type.
 			embeddedTyp := typ // for closure below
 			embeddedPos := pos
 			check.atEnd(func() {
 				t, isPtr := deref(embeddedTyp)
-				switch t := optype(t.Under()).(type) {
+				switch t := optype(t).(type) {
 				case *Basic:
 					if t == Typ[Invalid] {
 						// error was reported before
diff --git a/src/cmd/compile/internal/types2/unify.go b/src/cmd/compile/internal/types2/unify.go
index 153df9d622..d2ea2b952b 100644
--- a/src/cmd/compile/internal/types2/unify.go
+++ b/src/cmd/compile/internal/types2/unify.go
@@ -215,9 +215,9 @@ func (u *unifier) nify(x, y Type, p *ifacePair) bool {
 		// want *Named types.)
 		switch {
 		case !isNamed(x) && y != nil && asNamed(y) != nil:
-			return u.nify(x, y.Under(), p)
+			return u.nify(x, under(y), p)
 		case x != nil && asNamed(x) != nil && !isNamed(y):
-			return u.nify(x.Under(), y, p)
+			return u.nify(under(x), y, p)
 		}
 	}
 
diff --git a/src/cmd/compile/internal/types2/universe.go b/src/cmd/compile/internal/types2/universe.go
index 994e298a6c..3654ab4945 100644
--- a/src/cmd/compile/internal/types2/universe.go
+++ b/src/cmd/compile/internal/types2/universe.go
@@ -34,39 +34,39 @@ var (
 // Use Universe.Lookup("byte").Type() to obtain the specific
 // alias basic type named "byte" (and analogous for "rune").
 var Typ = [...]*Basic{
-	Invalid: {Invalid, 0, "invalid type", aType{}},
-
-	Bool:          {Bool, IsBoolean, "bool", aType{}},
-	Int:           {Int, IsInteger, "int", aType{}},
-	Int8:          {Int8, IsInteger, "int8", aType{}},
-	Int16:         {Int16, IsInteger, "int16", aType{}},
-	Int32:         {Int32, IsInteger, "int32", aType{}},
-	Int64:         {Int64, IsInteger, "int64", aType{}},
-	Uint:          {Uint, IsInteger | IsUnsigned, "uint", aType{}},
-	Uint8:         {Uint8, IsInteger | IsUnsigned, "uint8", aType{}},
-	Uint16:        {Uint16, IsInteger | IsUnsigned, "uint16", aType{}},
-	Uint32:        {Uint32, IsInteger | IsUnsigned, "uint32", aType{}},
-	Uint64:        {Uint64, IsInteger | IsUnsigned, "uint64", aType{}},
-	Uintptr:       {Uintptr, IsInteger | IsUnsigned, "uintptr", aType{}},
-	Float32:       {Float32, IsFloat, "float32", aType{}},
-	Float64:       {Float64, IsFloat, "float64", aType{}},
-	Complex64:     {Complex64, IsComplex, "complex64", aType{}},
-	Complex128:    {Complex128, IsComplex, "complex128", aType{}},
-	String:        {String, IsString, "string", aType{}},
-	UnsafePointer: {UnsafePointer, 0, "Pointer", aType{}},
-
-	UntypedBool:    {UntypedBool, IsBoolean | IsUntyped, "untyped bool", aType{}},
-	UntypedInt:     {UntypedInt, IsInteger | IsUntyped, "untyped int", aType{}},
-	UntypedRune:    {UntypedRune, IsInteger | IsUntyped, "untyped rune", aType{}},
-	UntypedFloat:   {UntypedFloat, IsFloat | IsUntyped, "untyped float", aType{}},
-	UntypedComplex: {UntypedComplex, IsComplex | IsUntyped, "untyped complex", aType{}},
-	UntypedString:  {UntypedString, IsString | IsUntyped, "untyped string", aType{}},
-	UntypedNil:     {UntypedNil, IsUntyped, "untyped nil", aType{}},
+	Invalid: {Invalid, 0, "invalid type"},
+
+	Bool:          {Bool, IsBoolean, "bool"},
+	Int:           {Int, IsInteger, "int"},
+	Int8:          {Int8, IsInteger, "int8"},
+	Int16:         {Int16, IsInteger, "int16"},
+	Int32:         {Int32, IsInteger, "int32"},
+	Int64:         {Int64, IsInteger, "int64"},
+	Uint:          {Uint, IsInteger | IsUnsigned, "uint"},
+	Uint8:         {Uint8, IsInteger | IsUnsigned, "uint8"},
+	Uint16:        {Uint16, IsInteger | IsUnsigned, "uint16"},
+	Uint32:        {Uint32, IsInteger | IsUnsigned, "uint32"},
+	Uint64:        {Uint64, IsInteger | IsUnsigned, "uint64"},
+	Uintptr:       {Uintptr, IsInteger | IsUnsigned, "uintptr"},
+	Float32:       {Float32, IsFloat, "float32"},
+	Float64:       {Float64, IsFloat, "float64"},
+	Complex64:     {Complex64, IsComplex, "complex64"},
+	Complex128:    {Complex128, IsComplex, "complex128"},
+	String:        {String, IsString, "string"},
+	UnsafePointer: {UnsafePointer, 0, "Pointer"},
+
+	UntypedBool:    {UntypedBool, IsBoolean | IsUntyped, "untyped bool"},
+	UntypedInt:     {UntypedInt, IsInteger | IsUntyped, "untyped int"},
+	UntypedRune:    {UntypedRune, IsInteger | IsUntyped, "untyped rune"},
+	UntypedFloat:   {UntypedFloat, IsFloat | IsUntyped, "untyped float"},
+	UntypedComplex: {UntypedComplex, IsComplex | IsUntyped, "untyped complex"},
+	UntypedString:  {UntypedString, IsString | IsUntyped, "untyped string"},
+	UntypedNil:     {UntypedNil, IsUntyped, "untyped nil"},
 }
 
 var aliases = [...]*Basic{
-	{Byte, IsInteger | IsUnsigned, "byte", aType{}},
-	{Rune, IsInteger, "rune", aType{}},
+	{Byte, IsInteger | IsUnsigned, "byte"},
+	{Rune, IsInteger, "rune"},
 }
 
 func defPredeclaredTypes() {
-- 
GitLab


From c2314babb8c21a352e7a0625963e9aed0f3890bd Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 17 Feb 2021 21:18:07 -0800
Subject: [PATCH 0673/2400] [dev.typeparams] cmd/compile/internal/types: review
 of type.go

The changes between (equivalent, and reviewed) go/types/type.go
and type.go can be seen by comparing patchset 1 and 3. The actual
change is just removing the "// UNREVIEWED" marker and some
comment adjustments.

Change-Id: Ied0e2f942bc96a9fcae0466761cfaa60a87668db
Reviewed-on: https://go-review.googlesource.com/c/go/+/293471
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/type.go | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
index c1c3a4629e..a9ac90246d 100644
--- a/src/cmd/compile/internal/types2/type.go
+++ b/src/cmd/compile/internal/types2/type.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2011 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.
@@ -207,7 +206,7 @@ type Signature struct {
 	// and store it in the Func Object) because when type-checking a function
 	// literal we call the general type checker which returns a general Type.
 	// We then unpack the *Signature and use the scope for the literal body.
-	rparams  []*TypeName // reveiver type parameters from left to right; or nil
+	rparams  []*TypeName // receiver type parameters from left to right; or nil
 	tparams  []*TypeName // type parameters from left to right; or nil
 	scope    *Scope      // function scope, present for package-local signatures
 	recv     *Var        // nil if not a method
@@ -725,9 +724,8 @@ type TypeParam struct {
 	bound Type      // *Named or *Interface; underlying type is always *Interface
 }
 
-func (t *TypeParam) Obj() *TypeName {
-	return t.obj
-}
+// Obj returns the type name for the type parameter t.
+func (t *TypeParam) Obj() *TypeName { return t.obj }
 
 // NewTypeParam returns a new TypeParam.
 func (check *Checker) NewTypeParam(obj *TypeName, index int, bound Type) *TypeParam {
@@ -747,6 +745,7 @@ func (t *TypeParam) Bound() *Interface {
 	if n, _ := t.bound.(*Named); n != nil {
 		pos = n.obj.pos
 	}
+	// TODO(gri) switch this to an unexported method on Checker.
 	t.check.completeInterface(pos, iface)
 	return iface
 }
@@ -762,7 +761,7 @@ func optype(typ Type) Type {
 	if t := asTypeParam(typ); t != nil {
 		// If the optype is typ, return the top type as we have
 		// no information. It also prevents infinite recursion
-		// via the TypeParam converter methods. This can happen
+		// via the asTypeParam converter function. This can happen
 		// for a type parameter list of the form:
 		// (type T interface { type T }).
 		// See also issue #39680.
-- 
GitLab


From d6bdd1aeefed83b69318bf7a3d84e9e275a4f686 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 17 Feb 2021 21:31:41 -0800
Subject: [PATCH 0674/2400] [dev.typeparams] cmd/compile/internal/types: review
 of typestring.go

The changes between (equivalent, and reviewed) go/types/typestring.go
and typestring.go can be seen by comparing patchset 1 and 3. The actual
change is just removing the "// UNREVIEWED" marker plus an adjustment
to writeTParamList (we now always write type constraints).

Change-Id: Ieb109c17756addc954e1ca0da606fa5b335ff30d
Reviewed-on: https://go-review.googlesource.com/c/go/+/293472
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/typestring.go | 32 ++++---------------
 1 file changed, 7 insertions(+), 25 deletions(-)

diff --git a/src/cmd/compile/internal/types2/typestring.go b/src/cmd/compile/internal/types2/typestring.go
index 4d778df43f..47b2c259e5 100644
--- a/src/cmd/compile/internal/types2/typestring.go
+++ b/src/cmd/compile/internal/types2/typestring.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2013 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.
@@ -314,33 +313,16 @@ func writeTypeList(buf *bytes.Buffer, list []Type, qf Qualifier, visited []Type)
 }
 
 func writeTParamList(buf *bytes.Buffer, list []*TypeName, qf Qualifier, visited []Type) {
-	// bound returns the type bound for tname. The result is never nil.
-	bound := func(tname *TypeName) Type {
-		// be careful to avoid crashes in case of inconsistencies
-		if t, _ := tname.typ.(*TypeParam); t != nil && t.bound != nil {
-			return t.bound
-		}
-		return &emptyInterface
-	}
-
-	// If a single type bound is not the empty interface, we have to write them all.
-	var writeBounds bool
-	for _, p := range list {
-		// bound(p) should be an interface but be careful (it may be invalid)
-		b := asInterface(bound(p))
-		if b != nil && !b.Empty() {
-			writeBounds = true
-			break
-		}
-	}
-	writeBounds = true // always write the bounds for new type parameter list syntax
-
 	buf.WriteString("[")
 	var prev Type
 	for i, p := range list {
-		b := bound(p)
+		// TODO(gri) support 'any' sugar here.
+		var b Type = &emptyInterface
+		if t, _ := p.typ.(*TypeParam); t != nil && t.bound != nil {
+			b = t.bound
+		}
 		if i > 0 {
-			if writeBounds && b != prev {
+			if b != prev {
 				// type bound changed - write previous one before advancing
 				buf.WriteByte(' ')
 				writeType(buf, prev, qf, visited)
@@ -355,7 +337,7 @@ func writeTParamList(buf *bytes.Buffer, list []*TypeName, qf Qualifier, visited
 			buf.WriteString(p.name)
 		}
 	}
-	if writeBounds && prev != nil {
+	if prev != nil {
 		buf.WriteByte(' ')
 		writeType(buf, prev, qf, visited)
 	}
-- 
GitLab


From 6f3878b942ab0395ede1bd0644c4e778adfcf908 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 17 Feb 2021 21:42:36 -0800
Subject: [PATCH 0675/2400] [dev.typeparams] cmd/compile/internal/types: review
 of typestring_test.go

The changes between (equivalent, and reviewed) go/types/typestring_test.go
and typestring_test.go can be seen by comparing patchset 1 and 2. The actual
change is just removing the "// UNREVIEWED" marker.

Change-Id: I66150c0ab738763d2d8b94483ef8314cbe28a374
Reviewed-on: https://go-review.googlesource.com/c/go/+/293473
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/typestring_test.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/typestring_test.go b/src/cmd/compile/internal/types2/typestring_test.go
index f1f7e34bf8..97a4fdf73d 100644
--- a/src/cmd/compile/internal/types2/typestring_test.go
+++ b/src/cmd/compile/internal/types2/typestring_test.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2012 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.
-- 
GitLab


From 8960ce773549007f80e6ebd7a9f6c642308087b9 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 18 Feb 2021 09:12:19 -0800
Subject: [PATCH 0676/2400] [dev.typeparams] cmd/compile/internal/types2: minor
 adjustments to match go/types more closely

Change-Id: Ib0144e0dd33e9202037e461a85f72f5db08ebd3a
Reviewed-on: https://go-review.googlesource.com/c/go/+/293631
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/call.go    | 9 ++++-----
 src/cmd/compile/internal/types2/typexpr.go | 2 --
 2 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index 67a76d14fb..72805c453b 100644
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -17,15 +17,15 @@ import (
 // The operand x must be the evaluation of inst.X and its type must be a signature.
 func (check *Checker) funcInst(x *operand, inst *syntax.IndexExpr) {
 	args, ok := check.exprOrTypeList(unpackExpr(inst.Index))
-	if ok && len(args) > 0 && args[0].mode != typexpr {
-		check.errorf(args[0], "%s is not a type", args[0])
-		ok = false
-	}
 	if !ok {
 		x.mode = invalid
 		x.expr = inst
 		return
 	}
+	if len(args) > 0 && args[0].mode != typexpr {
+		check.errorf(args[0], "%s is not a type", args[0])
+		ok = false
+	}
 
 	// check number of type arguments
 	n := len(args)
@@ -77,7 +77,6 @@ func (check *Checker) funcInst(x *operand, inst *syntax.IndexExpr) {
 				assert(targ != nil)
 			}
 		}
-		//check.dump("### inferred targs = %s", targs)
 		n = len(targs)
 		inferred = true
 	}
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 87eabbe28d..7190cb446a 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -1204,8 +1204,6 @@ func embeddedFieldIdent(e syntax.Expr) *syntax.Name {
 		return e.Sel
 	case *syntax.IndexExpr:
 		return embeddedFieldIdent(e.X)
-	case *syntax.ParenExpr:
-		return embeddedFieldIdent(e.X)
 	}
 	return nil // invalid embedded field
 }
-- 
GitLab


From 3b7277d3651b5c5856c5b0879ba3fb7a5f279508 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Thu, 4 Feb 2021 10:59:17 -0500
Subject: [PATCH 0677/2400] cmd/go: add a script test for artifacts resulting
 from 'go get -u'

For #36460

Change-Id: I4f8bf0fb8dfa508b346acb3868302452409ee9da
Reviewed-on: https://go-review.googlesource.com/c/go/+/289696
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 .../script/mod_get_downup_artifact.txt        | 165 ++++++++++++++++++
 1 file changed, 165 insertions(+)
 create mode 100644 src/cmd/go/testdata/script/mod_get_downup_artifact.txt

diff --git a/src/cmd/go/testdata/script/mod_get_downup_artifact.txt b/src/cmd/go/testdata/script/mod_get_downup_artifact.txt
new file mode 100644
index 0000000000..b35d4c4fd0
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_get_downup_artifact.txt
@@ -0,0 +1,165 @@
+# This test illustrates a case where an upgrade–downgrade–upgrade cycle can
+# result in upgrades of otherwise-irrelevant dependencies.
+#
+# This case has no corresponding test in the mvs package, because it is an
+# artifact that results from the composition of *multiple* MVS operations.
+
+# The initial package import graph used in the test looks like:
+#
+# m ---- a
+# |      |
+# +----- b
+# |      |
+# +----- c
+# |
+# +----- d
+#
+# b version 2 adds its own import of package d.
+#
+# The module dependency graph initially looks like:
+#
+# m ---- a.1
+# |       |
+# +----- b.1
+# |       |
+# +----- c.1
+# |
+# +----- d.1
+#
+# b.2 ---- c.2
+#  |
+#  +------ d.2
+#  |
+#  +------ e.1
+#
+# If we upgrade module b to version 2, we will upgrade c and d and add a new
+# dependency on e. If b version 2 is disallowed because of any of those
+# dependencies, the other dependencies should not be upgraded as a side-effect.
+
+cp go.mod go.mod.orig
+go mod tidy
+cmp go.mod go.mod.orig
+
+go list -m all
+stdout '^example.com/a v0.1.0 '
+stdout '^example.com/b v0.1.0 '
+stdout '^example.com/c v0.1.0 '
+stdout '^example.com/d v0.1.0 '
+! stdout '^example.com/e '
+
+# b is imported by a, so the -u flag would normally upgrade it to v0.2.0.
+# However, that would conflict with the explicit c@v0.1.0 constraint,
+# so b must remain at v0.1.0.
+#
+# If we're not careful, we might temporarily add b@v0.2.0 and pull in its
+# upgrades of module d and addition of module e, which are not relevant to
+# b@v0.1.0 and should not be added to the main module's dependencies.
+
+go get -u -d example.com/a@latest example.com/c@v0.1.0
+
+go list -m all
+stdout '^example.com/a v0.1.0 '
+stdout '^example.com/b v0.1.0 '
+stdout '^example.com/c v0.1.0 '
+
+	# BUG: d should remain at v0.1.0, because it is not transitively imported by a
+	# with b@v0.1.0. Today, it is spuriously upgraded to v0.2.0.
+stdout '^example.com/d v0.2.0 '
+
+	# BUG: e should not be added, because it is not transitively imported by a
+	# with b@v0.1.0. Today, it is spuriously added.
+stdout '^example.com/e v0.1.0 '
+
+-- go.mod --
+module example.com/m
+
+go 1.16
+
+require (
+	example.com/a v0.1.0
+	example.com/b v0.1.0
+	example.com/c v0.1.0
+	example.com/d v0.1.0
+)
+
+replace (
+	example.com/a v0.1.0 => ./a1
+	example.com/b v0.1.0 => ./b1
+	example.com/b v0.2.0 => ./b2
+	example.com/c v0.1.0 => ./c
+	example.com/c v0.2.0 => ./c
+	example.com/d v0.1.0 => ./d
+	example.com/d v0.2.0 => ./d
+	example.com/e v0.1.0 => ./e
+)
+-- m.go --
+package m
+
+import (
+	_ "example.com/a"
+	_ "example.com/b"
+	_ "example.com/c"
+	_ "example.com/d"
+)
+
+-- a1/go.mod --
+module example.com/a
+
+go 1.16
+
+require example.com/b v0.1.0
+-- a1/a.go --
+package a
+
+import _ "example.com/b"
+
+-- b1/go.mod --
+module example.com/b
+
+go 1.16
+
+require example.com/c v0.1.0
+-- b1/b.go --
+package b
+
+import _ "example.com/c"
+
+-- b2/go.mod --
+module example.com/b
+
+go 1.16
+
+require (
+	example.com/c v0.2.0
+	example.com/d v0.2.0
+	example.com/e v0.1.0
+)
+-- b2/b.go --
+package b
+
+import (
+	"example.com/c"
+	"example.com/d"
+	"example.com/e"
+)
+
+-- c/go.mod --
+module example.com/c
+
+go 1.16
+-- c/c.go --
+package c
+
+-- d/go.mod --
+module example.com/d
+
+go 1.16
+-- d/d.go --
+package d
+
+-- e/go.mod --
+module example.com/e
+
+go 1.16
+-- e/e.go --
+package e
-- 
GitLab


From eb982727e33263c0bb67de607beb44c5e0bd2bea Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Thu, 28 Jan 2021 09:10:57 -0500
Subject: [PATCH 0678/2400] cmd/go/internal/mvs: fix Downgrade to match
 Algorithm 4
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

mvs.Downgrade is pretty clearly intended to match Algorithm 4 from the
MVS blog post (https://research.swtch.com/vgo-mvs#algorithm_4).

Per the blog post:
“Downgrading one module may require downgrading other modules, but we
want to downgrade as few other modules as possible. … To avoid an
unnecessary downgrade to E 1.1, we must also add a new requirement on
E 1.2. We can apply Algorithm R to find the minimal set of new
requirements to write to go.mod.”

mvs.Downgrade does not match that behavior today: it fails to retain
the selected versions of transitive dependencies that are not implied
by downgraded direct dependencies of the target (module E in the
post). This bug is currently masked by the fact that we only call
Downgrade today with a *modload.mvsReqs, for which the Required method
happens to return the complete build list — rather than only the
direct dependencies as documented for the mvs.Reqs interface.

For #36460

Change-Id: If9c8f413b156b5f67c02787d9359394e169951b0
Reviewed-on: https://go-review.googlesource.com/c/go/+/287633
Trust: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/mvs/mvs.go                | 27 +++++++++++++++----
 src/cmd/go/internal/mvs/mvs_test.go           | 19 +++++--------
 .../go/testdata/script/mod_load_badchain.txt  |  3 +--
 3 files changed, 29 insertions(+), 20 deletions(-)

diff --git a/src/cmd/go/internal/mvs/mvs.go b/src/cmd/go/internal/mvs/mvs.go
index f016d8ff15..bed4d5c1ba 100644
--- a/src/cmd/go/internal/mvs/mvs.go
+++ b/src/cmd/go/internal/mvs/mvs.go
@@ -375,10 +375,19 @@ func Upgrade(target module.Version, reqs Reqs, upgrade ...module.Version) ([]mod
 // reqs.Previous, but the methods of reqs must otherwise handle such versions
 // correctly.
 func Downgrade(target module.Version, reqs Reqs, downgrade ...module.Version) ([]module.Version, error) {
-	list, err := reqs.Required(target)
+	// Per https://research.swtch.com/vgo-mvs#algorithm_4:
+	// “To avoid an unnecessary downgrade to E 1.1, we must also add a new
+	// requirement on E 1.2. We can apply Algorithm R to find the minimal set of
+	// new requirements to write to go.mod.”
+	//
+	// In order to generate those new requirements, we need to identify versions
+	// for every module in the build list — not just reqs.Required(target).
+	list, err := BuildList(target, reqs)
 	if err != nil {
 		return nil, err
 	}
+	list = list[1:] // remove target
+
 	max := make(map[string]string)
 	for _, r := range list {
 		max[r.Path] = r.Version
@@ -411,6 +420,9 @@ func Downgrade(target module.Version, reqs Reqs, downgrade ...module.Version) ([
 		}
 		added[m] = true
 		if v, ok := max[m.Path]; ok && reqs.Max(m.Version, v) != v {
+			// m would upgrade an existing dependency — it is not a strict downgrade,
+			// and because it was already present as a dependency, it could affect the
+			// behavior of other relevant packages.
 			exclude(m)
 			return
 		}
@@ -427,6 +439,7 @@ func Downgrade(target module.Version, reqs Reqs, downgrade ...module.Version) ([
 			// is transient (we couldn't download go.mod), return the error from
 			// Downgrade. Currently, we can't tell what kind of error it is.
 			exclude(m)
+			return
 		}
 		for _, r := range list {
 			add(r)
@@ -438,8 +451,8 @@ func Downgrade(target module.Version, reqs Reqs, downgrade ...module.Version) ([
 		}
 	}
 
-	var out []module.Version
-	out = append(out, target)
+	downgraded := make([]module.Version, 0, len(list)+1)
+	downgraded = append(downgraded, target)
 List:
 	for _, r := range list {
 		add(r)
@@ -466,10 +479,14 @@ List:
 			add(p)
 			r = p
 		}
-		out = append(out, r)
+		downgraded = append(downgraded, r)
 	}
 
-	return out, nil
+	return BuildList(target, &override{
+		target: target,
+		list:   downgraded,
+		Reqs:   reqs,
+	})
 }
 
 type override struct {
diff --git a/src/cmd/go/internal/mvs/mvs_test.go b/src/cmd/go/internal/mvs/mvs_test.go
index b8ff3bd8c2..742e396e0d 100644
--- a/src/cmd/go/internal/mvs/mvs_test.go
+++ b/src/cmd/go/internal/mvs/mvs_test.go
@@ -32,8 +32,7 @@ build A:       A B1 C2 D4 E2 F1
 upgrade* A:    A B1 C4 D5 E2 F1 G1
 upgrade A C4:  A B1 C4 D4 E2 F1 G1
 build A2:     A2 B1 C4 D4 E2 F1 G1
-# BUG: selected versions E2 and F1 are not preserved.
-downgrade A2 D2: A2 C4 D2
+downgrade A2 D2: A2 C4 D2 E2 F1 G1
 
 name: trim
 A: B1 C2
@@ -216,8 +215,7 @@ A: B2
 B1: C1
 B2: C2
 build A:        A B2 C2
-# BUG: build list from downgrade omits selected version C1.
-downgrade A C1: A B1
+downgrade A C1: A B1 C1
 
 name: down2
 A: B2 E2
@@ -231,9 +229,7 @@ E2: D2
 E1:
 F1:
 build A:        A B2 C2 D2 E2 F2
-# BUG: selected versions C1 and D1 are not preserved, and
-# requested version F1 is not selected.
-downgrade A F1: A B1 E1
+downgrade A F1: A B1 C1 D1 E1 F1
 
 # https://research.swtch.com/vgo-mvs#algorithm_4:
 # “[D]owngrades are constrained to only downgrade packages, not also upgrade
@@ -252,8 +248,7 @@ C2:
 D1:
 D2:
 build A:        A B2 C1 D2
-# BUG: requested version D1 is not selected.
-downgrade A D1: A
+downgrade A D1: A       D1
 
 # https://research.swtch.com/vgo-mvs#algorithm_4:
 # “Unlike upgrades, downgrades must work by removing requirements, not adding
@@ -270,10 +265,8 @@ B2: D2
 C1:
 D1:
 D2:
-build A:        A B2 D2
-# BUG: requested version D1 is not selected,
-# and selected version C1 is omitted from the returned build list.
-downgrade A D1: A B1
+build A:        A B2    D2
+downgrade A D1: A B1 C1 D1
 
 name: downcycle
 A: A B2
diff --git a/src/cmd/go/testdata/script/mod_load_badchain.txt b/src/cmd/go/testdata/script/mod_load_badchain.txt
index c0c382bfa6..32d9fb24d1 100644
--- a/src/cmd/go/testdata/script/mod_load_badchain.txt
+++ b/src/cmd/go/testdata/script/mod_load_badchain.txt
@@ -74,8 +74,7 @@ go get: example.com/badchain/c@v1.0.0 updating to
 	module declares its path as: badchain.example.com/c
 	        but was required as: example.com/badchain/c
 -- update-a-expected --
-go get: example.com/badchain/a@v1.0.0 updating to
-	example.com/badchain/a@v1.1.0 requires
+go get: example.com/badchain/a@v1.1.0 requires
 	example.com/badchain/b@v1.1.0 requires
 	example.com/badchain/c@v1.1.0: parsing go.mod:
 	module declares its path as: badchain.example.com/c
-- 
GitLab


From 2ff1e05a4ce132dec2a640d9fa941c2d33f90c36 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 18 Feb 2021 14:29:14 -0800
Subject: [PATCH 0679/2400] [dev.typeparams] all: update parent repository

Change-Id: Ib38d42f99e6a28970970e64c31cccac5bc3f25b3
Reviewed-on: https://go-review.googlesource.com/c/go/+/293955
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 codereview.cfg | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/codereview.cfg b/codereview.cfg
index d21d2ff61f..1f58fdbeb2 100644
--- a/codereview.cfg
+++ b/codereview.cfg
@@ -1,2 +1,2 @@
 branch: dev.typeparams
-parent-branch: dev.regabi
+parent-branch: master
-- 
GitLab


From 20050a15fee5b03735d6a14fcd96c059a05e149c Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Thu, 11 Feb 2021 10:50:20 -0800
Subject: [PATCH 0680/2400] [dev.typeparams] cmd/compile:  support generic
 types (with stenciling of method calls)

A type may now have a type param in it, either because it has been
composed from a function type param, or it has been declared as or
derived from a reference to a generic type. No objects or types with
type params can be exported yet. No generic type has a runtime
descriptor (but will likely eventually be associated with a dictionary).

types.Type now has an RParam field, which for a Named type can specify
the type params (in order) that must be supplied to fully instantiate
the type. Also, there is a new flag HasTParam to indicate if there is
a type param (TTYPEPARAM) anywhere in the type.

An instantiated generic type (whether fully instantiated or
re-instantiated to new type params) is a defined type, even though there
was no explicit declaration. This allows us to handle recursive
instantiated types (and improves printing of types).

To avoid the need to transform later in the compiler, an instantiation
of a method of a generic type is immediately represented as a function
with the method as the first argument.

Added 5 tests on generic types to test/typeparams, including list.go,
which tests recursive generic types.

Change-Id: Ib7ff27abd369a06d1c8ea84edc6ca1fd74bbb7c2
Reviewed-on: https://go-review.googlesource.com/c/go/+/292652
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Dan Scales <danscales@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/gc/export.go         |   5 +
 src/cmd/compile/internal/noder/expr.go        |  50 +++++-
 src/cmd/compile/internal/noder/irgen.go       |   2 +-
 src/cmd/compile/internal/noder/stencil.go     | 144 +++++++++++++++---
 src/cmd/compile/internal/noder/types.go       |  71 +++++++++
 .../compile/internal/reflectdata/reflect.go   |   5 +
 src/cmd/compile/internal/types/sizeof_test.go |   2 +-
 src/cmd/compile/internal/types/type.go        |  52 +++++++
 src/cmd/compile/internal/types2/selection.go  |  16 ++
 test/typeparam/list.go                        |  65 ++++++++
 test/typeparam/pair.go                        |  32 ++++
 test/typeparam/stringable.go                  |  46 ++++++
 test/typeparam/struct.go                      |  49 ++++++
 test/typeparam/value.go                       |  75 +++++++++
 14 files changed, 582 insertions(+), 32 deletions(-)
 create mode 100644 test/typeparam/list.go
 create mode 100644 test/typeparam/pair.go
 create mode 100644 test/typeparam/stringable.go
 create mode 100644 test/typeparam/struct.go
 create mode 100644 test/typeparam/value.go

diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index 356fcfa671..4d8221f53b 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -25,6 +25,11 @@ func exportf(bout *bio.Writer, format string, args ...interface{}) {
 func dumpexport(bout *bio.Writer) {
 	p := &exporter{marked: make(map[*types.Type]bool)}
 	for _, n := range typecheck.Target.Exports {
+		// Must catch it here rather than Export(), because the type can be
+		// not fully set (still TFORW) when Export() is called.
+		if n.Type() != nil && n.Type().HasTParam() {
+			base.Fatalf("Cannot (yet) export a generic type: %v", n)
+		}
 		p.markObject(n)
 	}
 
diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index 3d6fba2dfe..2819c8252d 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -209,7 +209,7 @@ func (g *irgen) selectorExpr(pos src.XPos, typ types2.Type, expr *syntax.Selecto
 	// interface embedding).
 
 	var n ir.Node
-	method := selinfo.Obj().(*types2.Func)
+	method2 := selinfo.Obj().(*types2.Func)
 
 	if kind == types2.MethodExpr {
 		// OMETHEXPR is unusual in using directly the node and type of the
@@ -221,9 +221,11 @@ func (g *irgen) selectorExpr(pos src.XPos, typ types2.Type, expr *syntax.Selecto
 		n = MethodExpr(pos, origx, x.Type(), last)
 	} else {
 		// Add implicit addr/deref for method values, if needed.
-		if !x.Type().IsInterface() {
-			recvTyp := method.Type().(*types2.Signature).Recv().Type()
-			_, wantPtr := recvTyp.(*types2.Pointer)
+		if x.Type().IsInterface() {
+			n = DotMethod(pos, x, last)
+		} else {
+			recvType2 := method2.Type().(*types2.Signature).Recv().Type()
+			_, wantPtr := recvType2.(*types2.Pointer)
 			havePtr := x.Type().IsPtr()
 
 			if havePtr != wantPtr {
@@ -233,13 +235,45 @@ func (g *irgen) selectorExpr(pos src.XPos, typ types2.Type, expr *syntax.Selecto
 					x = Implicit(Addr(pos, x))
 				}
 			}
-			if !g.match(x.Type(), recvTyp, false) {
-				base.FatalfAt(pos, "expected %L to have type %v", x, recvTyp)
+			recvType2Base := recvType2
+			if wantPtr {
+				recvType2Base = recvType2.Pointer().Elem()
+			}
+			if len(recvType2Base.Named().TParams()) > 0 {
+				// recvType2 is the original generic type that is
+				// instantiated for this method call.
+				// selinfo.Recv() is the instantiated type
+				recvType2 = recvType2Base
+				// method is the generic method associated with the gen type
+				method := g.obj(recvType2.Named().Method(last))
+				n = ir.NewSelectorExpr(pos, ir.OCALLPART, x, method.Sym())
+				n.(*ir.SelectorExpr).Selection = types.NewField(pos, method.Sym(), method.Type())
+				n.(*ir.SelectorExpr).Selection.Nname = method
+				typed(method.Type(), n)
+
+				// selinfo.Targs() are the types used to
+				// instantiate the type of receiver
+				targs2 := selinfo.TArgs()
+				targs := make([]ir.Node, len(targs2))
+				for i, targ2 := range targs2 {
+					targs[i] = ir.TypeNode(g.typ(targ2))
+				}
+
+				// Create function instantiation with the type
+				// args for the receiver type for the method call.
+				n = ir.NewInstExpr(pos, ir.OFUNCINST, n, targs)
+				typed(g.typ(typ), n)
+				return n
+			}
+
+			if !g.match(x.Type(), recvType2, false) {
+				base.FatalfAt(pos, "expected %L to have type %v", x, recvType2)
+			} else {
+				n = DotMethod(pos, x, last)
 			}
 		}
-		n = DotMethod(pos, x, last)
 	}
-	if have, want := n.Sym(), g.selector(method); have != want {
+	if have, want := n.Sym(), g.selector(method2); have != want {
 		base.FatalfAt(pos, "bad Sym: have %v, want %v", have, want)
 	}
 	return n
diff --git a/src/cmd/compile/internal/noder/irgen.go b/src/cmd/compile/internal/noder/irgen.go
index d4f1b7461a..28536cc1f7 100644
--- a/src/cmd/compile/internal/noder/irgen.go
+++ b/src/cmd/compile/internal/noder/irgen.go
@@ -195,7 +195,7 @@ Outer:
 	// eventually export any exportable generic functions.
 	j := 0
 	for i, decl := range g.target.Decls {
-		if decl.Op() != ir.ODCLFUNC || decl.Type().NumTParams() == 0 {
+		if decl.Op() != ir.ODCLFUNC || !decl.Type().HasTParam() {
 			g.target.Decls[j] = g.target.Decls[i]
 			j++
 		}
diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 74ea2e0927..69461a8190 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -13,7 +13,9 @@ import (
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
+	"cmd/internal/src"
 	"fmt"
+	"strings"
 )
 
 // stencil scans functions for instantiated generic function calls and
@@ -61,6 +63,17 @@ func (g *irgen) stencil() {
 			// Replace the OFUNCINST with a direct reference to the
 			// new stenciled function
 			call.X = st.Nname
+			if inst.X.Op() == ir.OCALLPART {
+				// When we create an instantiation of a method
+				// call, we make it a function. So, move the
+				// receiver to be the first arg of the function
+				// call.
+				withRecv := make([]ir.Node, len(call.Args)+1)
+				dot := inst.X.(*ir.SelectorExpr)
+				withRecv[0] = dot.X
+				copy(withRecv[1:], call.Args)
+				call.Args = withRecv
+			}
 			modified = true
 		})
 		if base.Flag.W > 1 && modified {
@@ -74,7 +87,12 @@ func (g *irgen) stencil() {
 // the name of the function and the types of the type params.
 func makeInstName(inst *ir.InstExpr) *types.Sym {
 	b := bytes.NewBufferString("#")
-	b.WriteString(inst.X.(*ir.Name).Name().Sym().Name)
+	if meth, ok := inst.X.(*ir.SelectorExpr); ok {
+		// Write the name of the generic method, including receiver type
+		b.WriteString(meth.Selection.Nname.Sym().Name)
+	} else {
+		b.WriteString(inst.X.(*ir.Name).Name().Sym().Name)
+	}
 	b.WriteString("[")
 	for i, targ := range inst.Targs {
 		if i > 0 {
@@ -90,18 +108,38 @@ func makeInstName(inst *ir.InstExpr) *types.Sym {
 // instantiation of a generic function with specified type arguments.
 type subster struct {
 	newf    *ir.Func // Func node for the new stenciled function
-	tparams *types.Fields
+	tparams []*types.Field
 	targs   []ir.Node
 	// The substitution map from name nodes in the generic function to the
 	// name nodes in the new stenciled function.
 	vars map[*ir.Name]*ir.Name
+	seen map[*types.Type]*types.Type
 }
 
 // genericSubst returns a new function with the specified name. The function is an
-// instantiation of a generic function with type params, as specified by inst.
+// instantiation of a generic function or method with type params, as specified by
+// inst. For a method with a generic receiver, it returns an instantiated function
+// type where the receiver becomes the first parameter. Otherwise the instantiated
+// method would still need to be transformed by later compiler phases.
 func genericSubst(name *types.Sym, inst *ir.InstExpr) *ir.Func {
-	// Similar to noder.go: funcDecl
-	nameNode := inst.X.(*ir.Name)
+	var nameNode *ir.Name
+	var tparams []*types.Field
+	if selExpr, ok := inst.X.(*ir.SelectorExpr); ok {
+		// Get the type params from the method receiver (after skipping
+		// over any pointer)
+		nameNode = ir.AsNode(selExpr.Selection.Nname).(*ir.Name)
+		recvType := selExpr.Type().Recv().Type
+		if recvType.IsPtr() {
+			recvType = recvType.Elem()
+		}
+		tparams = make([]*types.Field, len(recvType.RParams))
+		for i, rparam := range recvType.RParams {
+			tparams[i] = types.NewField(src.NoXPos, nil, rparam)
+		}
+	} else {
+		nameNode = inst.X.(*ir.Name)
+		tparams = nameNode.Type().TParams().Fields().Slice()
+	}
 	gf := nameNode.Func
 	newf := ir.NewFunc(inst.Pos())
 	newf.Nname = ir.NewNameAt(inst.Pos(), name)
@@ -111,9 +149,10 @@ func genericSubst(name *types.Sym, inst *ir.InstExpr) *ir.Func {
 
 	subst := &subster{
 		newf:    newf,
-		tparams: nameNode.Type().TParams().Fields(),
+		tparams: tparams,
 		targs:   inst.Targs,
 		vars:    make(map[*ir.Name]*ir.Name),
+		seen:    make(map[*types.Type]*types.Type),
 	}
 
 	newf.Dcl = make([]*ir.Name, len(gf.Dcl))
@@ -125,9 +164,12 @@ func genericSubst(name *types.Sym, inst *ir.InstExpr) *ir.Func {
 	// Ugly: we have to insert the Name nodes of the parameters/results into
 	// the function type. The current function type has no Nname fields set,
 	// because it came via conversion from the types2 type.
-	oldt := inst.Type()
-	newt := types.NewSignature(oldt.Pkg(), nil, nil, subst.fields(ir.PPARAM, oldt.Params(), newf.Dcl),
-		subst.fields(ir.PPARAMOUT, oldt.Results(), newf.Dcl))
+	oldt := inst.X.Type()
+	// We also transform a generic method type to the corresponding
+	// instantiated function type where the receiver is the first parameter.
+	newt := types.NewSignature(oldt.Pkg(), nil, nil,
+		subst.fields(ir.PPARAM, append(oldt.Recvs().FieldSlice(), oldt.Params().FieldSlice()...), newf.Dcl),
+		subst.fields(ir.PPARAMOUT, oldt.Results().FieldSlice(), newf.Dcl))
 
 	newf.Nname.Ntype = ir.TypeNode(newt)
 	newf.Nname.SetType(newt)
@@ -276,41 +318,81 @@ func (subst *subster) tstruct(t *types.Type) *types.Type {
 
 }
 
-// typ substitutes any type parameter found with the corresponding type argument.
-func (subst *subster) typ(t *types.Type) *types.Type {
-	for i, tp := range subst.tparams.Slice() {
-		if tp.Type == t {
-			return subst.targs[i].Type()
+// instTypeName creates a name for an instantiated type, based on the type args
+func instTypeName(name string, targs []ir.Node) string {
+	b := bytes.NewBufferString(name)
+	b.WriteByte('[')
+	for i, targ := range targs {
+		if i > 0 {
+			b.WriteByte(',')
 		}
+		b.WriteString(targ.Type().String())
+	}
+	b.WriteByte(']')
+	return b.String()
+}
+
+// typ computes the type obtained by substituting any type parameter in t with the
+// corresponding type argument in subst. If t contains no type parameters, the
+// result is t; otherwise the result is a new type.
+// It deals with recursive types by using a map and TFORW types.
+// TODO(danscales) deal with recursion besides ptr/struct cases.
+func (subst *subster) typ(t *types.Type) *types.Type {
+	if !t.HasTParam() {
+		return t
+	}
+	if subst.seen[t] != nil {
+		// We've hit a recursive type
+		return subst.seen[t]
 	}
 
+	var newt *types.Type
 	switch t.Kind() {
+	case types.TTYPEPARAM:
+		for i, tp := range subst.tparams {
+			if tp.Type == t {
+				return subst.targs[i].Type()
+			}
+		}
+		return t
+
 	case types.TARRAY:
 		elem := t.Elem()
 		newelem := subst.typ(elem)
 		if newelem != elem {
-			return types.NewArray(newelem, t.NumElem())
+			newt = types.NewArray(newelem, t.NumElem())
 		}
 
 	case types.TPTR:
 		elem := t.Elem()
+		// In order to deal with recursive generic types, create a TFORW
+		// type initially and store it in the seen map, so it can be
+		// accessed if this type appears recursively within the type.
+		forw := types.New(types.TFORW)
+		subst.seen[t] = forw
 		newelem := subst.typ(elem)
 		if newelem != elem {
-			return types.NewPtr(newelem)
+			forw.SetUnderlying(types.NewPtr(newelem))
+			newt = forw
 		}
+		delete(subst.seen, t)
 
 	case types.TSLICE:
 		elem := t.Elem()
 		newelem := subst.typ(elem)
 		if newelem != elem {
-			return types.NewSlice(newelem)
+			newt = types.NewSlice(newelem)
 		}
 
 	case types.TSTRUCT:
-		newt := subst.tstruct(t)
+		forw := types.New(types.TFORW)
+		subst.seen[t] = forw
+		newt = subst.tstruct(t)
 		if newt != t {
-			return newt
+			forw.SetUnderlying(newt)
+			newt = forw
 		}
+		delete(subst.seen, t)
 
 	case types.TFUNC:
 		newrecvs := subst.tstruct(t.Recvs())
@@ -321,21 +403,39 @@ func (subst *subster) typ(t *types.Type) *types.Type {
 			if newrecvs.NumFields() > 0 {
 				newrecv = newrecvs.Field(0)
 			}
-			return types.NewSignature(t.Pkg(), newrecv, nil, newparams.FieldSlice(), newresults.FieldSlice())
+			newt = types.NewSignature(t.Pkg(), newrecv, nil, newparams.FieldSlice(), newresults.FieldSlice())
 		}
 
 		// TODO: case TCHAN
 		// TODO: case TMAP
 		// TODO: case TINTER
 	}
+	if newt != nil {
+		if t.Sym() != nil {
+			// Since we've substituted types, we also need to change
+			// the defined name of the type, by removing the old types
+			// (in brackets) from the name, and adding the new types.
+			oldname := t.Sym().Name
+			i := strings.Index(oldname, "[")
+			oldname = oldname[:i]
+			sym := t.Sym().Pkg.Lookup(instTypeName(oldname, subst.targs))
+			if sym.Def != nil {
+				// We've already created this instantiated defined type.
+				return sym.Def.Type()
+			}
+			newt.SetSym(sym)
+			sym.Def = ir.TypeNode(newt)
+		}
+		return newt
+	}
+
 	return t
 }
 
 // fields sets the Nname field for the Field nodes inside a type signature, based
 // on the corresponding in/out parameters in dcl. It depends on the in and out
 // parameters being in order in dcl.
-func (subst *subster) fields(class ir.Class, oldt *types.Type, dcl []*ir.Name) []*types.Field {
-	oldfields := oldt.FieldSlice()
+func (subst *subster) fields(class ir.Class, oldfields []*types.Field, dcl []*ir.Name) []*types.Field {
 	newfields := make([]*types.Field, len(oldfields))
 	var i int
 
diff --git a/src/cmd/compile/internal/noder/types.go b/src/cmd/compile/internal/noder/types.go
index 1e71969858..c23295c3a1 100644
--- a/src/cmd/compile/internal/noder/types.go
+++ b/src/cmd/compile/internal/noder/types.go
@@ -5,6 +5,7 @@
 package noder
 
 import (
+	"bytes"
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/typecheck"
@@ -25,6 +26,8 @@ func (g *irgen) pkg(pkg *types2.Package) *types.Pkg {
 	return types.NewPkg(pkg.Path(), pkg.Name())
 }
 
+// typ converts a types2.Type to a types.Type, including caching of previously
+// translated types.
 func (g *irgen) typ(typ types2.Type) *types.Type {
 	// Caching type mappings isn't strictly needed, because typ0 preserves
 	// type identity; but caching minimizes memory blow-up from mapping the
@@ -46,11 +49,79 @@ func (g *irgen) typ(typ types2.Type) *types.Type {
 	return res
 }
 
+// instTypeName2 creates a name for an instantiated type, base on the type args
+// (given as types2 types).
+func instTypeName2(name string, targs []types2.Type) string {
+	b := bytes.NewBufferString(name)
+	b.WriteByte('[')
+	for i, targ := range targs {
+		if i > 0 {
+			b.WriteByte(',')
+		}
+		b.WriteString(types2.TypeString(targ,
+			func(*types2.Package) string { return "" }))
+	}
+	b.WriteByte(']')
+	return b.String()
+}
+
+// typ0 converts a types2.Type to a types.Type, but doesn't do the caching check
+// at the top level.
 func (g *irgen) typ0(typ types2.Type) *types.Type {
 	switch typ := typ.(type) {
 	case *types2.Basic:
 		return g.basic(typ)
 	case *types2.Named:
+		if typ.TParams() != nil {
+			// typ is an instantiation of a defined (named) generic type.
+			// This instantiation should also be a defined (named) type.
+			// types2 gives us the substituted type in t.Underlying()
+			// The substituted type may or may not still have type
+			// params. We might, for example, be substituting one type
+			// param for another type param.
+
+			if typ.TArgs() == nil {
+				base.Fatalf("In typ0, Targs should be set if TParams is set")
+			}
+
+			// When converted to types.Type, typ must have a name,
+			// based on the names of the type arguments. We need a
+			// name to deal with recursive generic types (and it also
+			// looks better when printing types).
+			instName := instTypeName2(typ.Obj().Name(), typ.TArgs())
+			s := g.pkg(typ.Obj().Pkg()).Lookup(instName)
+			if s.Def != nil {
+				// We have already encountered this instantiation,
+				// so use the type we previously created, since there
+				// must be exactly one instance of a defined type.
+				return s.Def.Type()
+			}
+
+			// Create a forwarding type first and put it in the g.typs
+			// map, in order to deal with recursive generic types.
+			ntyp := types.New(types.TFORW)
+			g.typs[typ] = ntyp
+			ntyp.SetUnderlying(g.typ(typ.Underlying()))
+			ntyp.SetSym(s)
+
+			if ntyp.HasTParam() {
+				// If ntyp still has type params, then we must be
+				// referencing something like 'value[T2]', as when
+				// specifying the generic receiver of a method,
+				// where value was defined as "type value[T any]
+				// ...". Save the type args, which will now be the
+				// new type params of the current type.
+				ntyp.RParams = make([]*types.Type, len(typ.TArgs()))
+				for i, targ := range typ.TArgs() {
+					ntyp.RParams[i] = g.typ(targ)
+				}
+			}
+
+			// Make sure instantiated type can be uniquely found from
+			// the sym
+			s.Def = ir.TypeNode(ntyp)
+			return ntyp
+		}
 		obj := g.obj(typ.Obj())
 		if obj.Op() != ir.OTYPE {
 			base.FatalfAt(obj.Pos(), "expected type: %L", obj)
diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index 632e0f48d4..06a7f91c52 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -1288,6 +1288,11 @@ func ITabSym(it *obj.LSym, offset int64) *obj.LSym {
 
 // NeedRuntimeType ensures that a runtime type descriptor is emitted for t.
 func NeedRuntimeType(t *types.Type) {
+	if t.HasTParam() {
+		// Generic types don't have a runtime type descriptor (but will
+		// have a dictionary)
+		return
+	}
 	if _, ok := signatset[t]; !ok {
 		signatset[t] = struct{}{}
 		signatslice = append(signatslice, t)
diff --git a/src/cmd/compile/internal/types/sizeof_test.go b/src/cmd/compile/internal/types/sizeof_test.go
index 6937283d69..f80de937be 100644
--- a/src/cmd/compile/internal/types/sizeof_test.go
+++ b/src/cmd/compile/internal/types/sizeof_test.go
@@ -21,7 +21,7 @@ func TestSizeof(t *testing.T) {
 		_64bit uintptr     // size on 64bit platforms
 	}{
 		{Sym{}, 44, 72},
-		{Type{}, 56, 96},
+		{Type{}, 68, 120},
 		{Map{}, 20, 40},
 		{Forward{}, 20, 32},
 		{Func{}, 28, 48},
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 987aa11454..b6374e49a5 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -176,6 +176,11 @@ type Type struct {
 	Align uint8 // the required alignment of this type, in bytes (0 means Width and Align have not yet been computed)
 
 	flags bitset8
+
+	// Type params (in order) of this named type that need to be instantiated.
+	// TODO(danscales): for space reasons, should probably be a pointer to a
+	// slice, possibly change the name of this field.
+	RParams []*Type
 }
 
 func (*Type) CanBeAnSSAAux() {}
@@ -186,6 +191,7 @@ const (
 	typeNoalg                  // suppress hash and eq algorithm generation
 	typeDeferwidth             // width computation has been deferred and type is on deferredTypeStack
 	typeRecur
+	typeHasTParam // there is a typeparam somewhere in the type (generic function or type)
 )
 
 func (t *Type) NotInHeap() bool  { return t.flags&typeNotInHeap != 0 }
@@ -193,12 +199,14 @@ func (t *Type) Broke() bool      { return t.flags&typeBroke != 0 }
 func (t *Type) Noalg() bool      { return t.flags&typeNoalg != 0 }
 func (t *Type) Deferwidth() bool { return t.flags&typeDeferwidth != 0 }
 func (t *Type) Recur() bool      { return t.flags&typeRecur != 0 }
+func (t *Type) HasTParam() bool  { return t.flags&typeHasTParam != 0 }
 
 func (t *Type) SetNotInHeap(b bool)  { t.flags.set(typeNotInHeap, b) }
 func (t *Type) SetBroke(b bool)      { t.flags.set(typeBroke, b) }
 func (t *Type) SetNoalg(b bool)      { t.flags.set(typeNoalg, b) }
 func (t *Type) SetDeferwidth(b bool) { t.flags.set(typeDeferwidth, b) }
 func (t *Type) SetRecur(b bool)      { t.flags.set(typeRecur, b) }
+func (t *Type) SetHasTParam(b bool)  { t.flags.set(typeHasTParam, b) }
 
 // Kind returns the kind of type t.
 func (t *Type) Kind() Kind { return t.kind }
@@ -527,6 +535,9 @@ func NewArray(elem *Type, bound int64) *Type {
 	t := New(TARRAY)
 	t.Extra = &Array{Elem: elem, Bound: bound}
 	t.SetNotInHeap(elem.NotInHeap())
+	if elem.HasTParam() {
+		t.SetHasTParam(true)
+	}
 	return t
 }
 
@@ -542,6 +553,9 @@ func NewSlice(elem *Type) *Type {
 	t := New(TSLICE)
 	t.Extra = Slice{Elem: elem}
 	elem.cache.slice = t
+	if elem.HasTParam() {
+		t.SetHasTParam(true)
+	}
 	return t
 }
 
@@ -551,6 +565,9 @@ func NewChan(elem *Type, dir ChanDir) *Type {
 	ct := t.ChanType()
 	ct.Elem = elem
 	ct.Dir = dir
+	if elem.HasTParam() {
+		t.SetHasTParam(true)
+	}
 	return t
 }
 
@@ -558,6 +575,9 @@ func NewTuple(t1, t2 *Type) *Type {
 	t := New(TTUPLE)
 	t.Extra.(*Tuple).first = t1
 	t.Extra.(*Tuple).second = t2
+	if t1.HasTParam() || t2.HasTParam() {
+		t.SetHasTParam(true)
+	}
 	return t
 }
 
@@ -579,6 +599,9 @@ func NewMap(k, v *Type) *Type {
 	mt := t.MapType()
 	mt.Key = k
 	mt.Elem = v
+	if k.HasTParam() || v.HasTParam() {
+		t.SetHasTParam(true)
+	}
 	return t
 }
 
@@ -597,6 +620,12 @@ func NewPtr(elem *Type) *Type {
 		if t.Elem() != elem {
 			base.Fatalf("NewPtr: elem mismatch")
 		}
+		if elem.HasTParam() {
+			// Extra check when reusing the cache, since the elem
+			// might have still been undetermined (i.e. a TFORW type)
+			// when this entry was cached.
+			t.SetHasTParam(true)
+		}
 		return t
 	}
 
@@ -607,6 +636,9 @@ func NewPtr(elem *Type) *Type {
 	if NewPtrCacheEnabled {
 		elem.cache.ptr = t
 	}
+	if elem.HasTParam() {
+		t.SetHasTParam(true)
+	}
 	return t
 }
 
@@ -1611,6 +1643,9 @@ func (t *Type) SetUnderlying(underlying *Type) {
 	if underlying.Broke() {
 		t.SetBroke(true)
 	}
+	if underlying.HasTParam() {
+		t.SetHasTParam(true)
+	}
 
 	// spec: "The declared type does not inherit any methods bound
 	// to the existing type, but the method set of an interface
@@ -1633,6 +1668,15 @@ func (t *Type) SetUnderlying(underlying *Type) {
 	}
 }
 
+func fieldsHasTParam(fields []*Field) bool {
+	for _, f := range fields {
+		if f.Type != nil && f.Type.HasTParam() {
+			return true
+		}
+	}
+	return false
+}
+
 // NewBasic returns a new basic type of the given kind.
 func NewBasic(kind Kind, obj Object) *Type {
 	t := New(kind)
@@ -1660,6 +1704,7 @@ func NewTypeParam(pkg *Pkg, constraint *Type) *Type {
 	constraint.wantEtype(TINTER)
 	t.methods = constraint.methods
 	t.Extra.(*Interface).pkg = pkg
+	t.SetHasTParam(true)
 	return t
 }
 
@@ -1688,6 +1733,10 @@ func NewSignature(pkg *Pkg, recv *Field, tparams, params, results []*Field) *Typ
 	ft.Params = funargs(params, FunargParams)
 	ft.Results = funargs(results, FunargResults)
 	ft.pkg = pkg
+	if len(tparams) > 0 || fieldsHasTParam(recvs) || fieldsHasTParam(params) ||
+		fieldsHasTParam(results) {
+		t.SetHasTParam(true)
+	}
 
 	return t
 }
@@ -1700,6 +1749,9 @@ func NewStruct(pkg *Pkg, fields []*Field) *Type {
 		t.SetBroke(true)
 	}
 	t.Extra.(*Struct).pkg = pkg
+	if fieldsHasTParam(fields) {
+		t.SetHasTParam(true)
+	}
 	return t
 }
 
diff --git a/src/cmd/compile/internal/types2/selection.go b/src/cmd/compile/internal/types2/selection.go
index 8128aeee2e..4358458b88 100644
--- a/src/cmd/compile/internal/types2/selection.go
+++ b/src/cmd/compile/internal/types2/selection.go
@@ -51,6 +51,22 @@ func (s *Selection) Kind() SelectionKind { return s.kind }
 // Recv returns the type of x in x.f.
 func (s *Selection) Recv() Type { return s.recv }
 
+// Work-around for bug where a (*instance) shows up in a final type.
+// TODO(gri):  fix this bug.
+func (s *Selection) TArgs() []Type {
+	r := s.recv
+	if r.Pointer() != nil {
+		r = r.Pointer().Elem()
+	}
+	if r.Named() != nil {
+		return r.Named().TArgs()
+	}
+	// The base type (after skipping any pointer) must be a Named type. The
+	// bug is that sometimes it can be an instance type (which is supposed to
+	// be an internal type only).
+	return r.(*instance).targs
+}
+
 // Obj returns the object denoted by x.f; a *Var for
 // a field selection, and a *Func in all other cases.
 func (s *Selection) Obj() Object { return s.obj }
diff --git a/test/typeparam/list.go b/test/typeparam/list.go
new file mode 100644
index 0000000000..64230060de
--- /dev/null
+++ b/test/typeparam/list.go
@@ -0,0 +1,65 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 (
+	"fmt"
+)
+
+type Ordered interface {
+        type int, int8, int16, int32, int64,
+                uint, uint8, uint16, uint32, uint64, uintptr,
+                float32, float64,
+                string
+}
+
+// List is a linked list of ordered values of type T.
+type list[T Ordered] struct {
+	next *list[T]
+	val  T
+}
+
+func (l *list[T]) largest() T {
+	var max T
+	for p := l; p != nil; p = p.next {
+		if p.val > max {
+			max = p.val
+		}
+	}
+	return max
+}
+
+
+func main() {
+	i3 := &list[int]{nil, 1}
+	i2 := &list[int]{i3, 3}
+	i1 := &list[int]{i2, 2}
+	if got, want := i1.largest(), 3; got != want {
+                panic(fmt.Sprintf("got %d, want %d", got, want))
+	}
+
+	b3 := &list[byte]{nil, byte(1)}
+	b2 := &list[byte]{b3, byte(3)}
+	b1 := &list[byte]{b2, byte(2)}
+	if got, want := b1.largest(), byte(3); got != want {
+                panic(fmt.Sprintf("got %d, want %d", got, want))
+	}
+
+	f3 := &list[float64]{nil, 13.5}
+	f2 := &list[float64]{f3, 1.2}
+	f1 := &list[float64]{f2, 4.5}
+	if got, want := f1.largest(), 13.5; got != want {
+                panic(fmt.Sprintf("got %f, want %f", got, want))
+	}
+
+	s3 := &list[string]{nil, "dd"}
+	s2 := &list[string]{s3, "aa"}
+	s1 := &list[string]{s2, "bb"}
+	if got, want := s1.largest(), "dd"; got != want {
+                panic(fmt.Sprintf("got %s, want %s", got, want))
+	}
+}
diff --git a/test/typeparam/pair.go b/test/typeparam/pair.go
new file mode 100644
index 0000000000..7faf083c89
--- /dev/null
+++ b/test/typeparam/pair.go
@@ -0,0 +1,32 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 (
+	"fmt"
+	"unsafe"
+)
+
+type pair[F1, F2 any] struct {
+	f1 F1
+	f2 F2
+}
+
+func main() {
+	p := pair[int32, int64]{1, 2}
+	if got, want := unsafe.Sizeof(p.f1), uintptr(4); got != want {
+		panic(fmt.Sprintf("unexpected f1 size == %d, want %d", got, want))
+	}
+	if got, want := unsafe.Sizeof(p.f2), uintptr(8); got != want {
+		panic(fmt.Sprintf("unexpected f2 size == %d, want %d", got, want))
+	}
+	type mypair struct { f1 int32; f2 int64 }
+	mp := mypair(p)
+	if mp.f1 != 1 || mp.f2 != 2 {
+		panic(fmt.Sprintf("mp == %#v, want %#v", mp, mypair{1, 2}))
+	}
+}
diff --git a/test/typeparam/stringable.go b/test/typeparam/stringable.go
new file mode 100644
index 0000000000..9340a3b10a
--- /dev/null
+++ b/test/typeparam/stringable.go
@@ -0,0 +1,46 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+type Stringer interface {
+	String() string
+}
+
+// stringableList is a slice of some type, where the type
+// must have a String method.
+type stringableList[T Stringer] []T
+
+func (s stringableList[T]) String() string {
+	var sb strings.Builder
+	for i, v := range s {
+		if i > 0 {
+			sb.WriteString(", ")
+		}
+		sb.WriteString(v.String())
+	}
+	return sb.String()
+}
+
+type myint int
+
+func (a myint) String() string {
+	return strconv.Itoa(int(a))
+}
+
+func main() {
+	v := stringableList[myint]{ myint(1), myint(2) }
+
+	if got, want := v.String(), "1, 2"; got != want {
+                panic(fmt.Sprintf("got %s, want %s", got, want))
+	}
+}
diff --git a/test/typeparam/struct.go b/test/typeparam/struct.go
new file mode 100644
index 0000000000..98f0fcd888
--- /dev/null
+++ b/test/typeparam/struct.go
@@ -0,0 +1,49 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 (
+	"fmt"
+)
+
+type _E[T any] struct {
+	v T
+}
+
+type _S1 struct {
+	_E[int]
+	v string
+}
+
+type _Eint = _E[int]
+type _Ebool = _E[bool]
+
+type _S2 struct {
+	_Eint
+	_Ebool
+	v string
+}
+
+type _S3 struct {
+	*_E[int]
+}
+
+func main() {
+	s1 := _S1{_Eint{2}, "foo"}
+	if got, want := s1._E.v, 2; got != want {
+                panic(fmt.Sprintf("got %d, want %d", got, want))
+	}
+	s2 := _S2{_Eint{3}, _Ebool{true}, "foo"}
+	if got, want := s2._Eint.v, 3; got != want {
+                panic(fmt.Sprintf("got %d, want %d", got, want))
+	}
+	var s3 _S3
+	s3._E = &_Eint{4}
+	if got, want := s3._E.v, 4; got != want {
+                panic(fmt.Sprintf("got %d, want %d", got, want))
+	}
+}
diff --git a/test/typeparam/value.go b/test/typeparam/value.go
new file mode 100644
index 0000000000..5dd7449d9c
--- /dev/null
+++ b/test/typeparam/value.go
@@ -0,0 +1,75 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 "fmt"
+
+type value[T any] struct {
+	val T
+}
+
+func get[T2 any](v *value[T2]) T2 {
+	return v.val
+}
+
+func set[T any](v *value[T], val T) {
+	v.val = val
+}
+
+func (v *value[T2]) set(val T2) {
+	v.val = val
+}
+
+func (v *value[T2]) get() T2 {
+	return v.val
+}
+
+func main() {
+	var v1 value[int]
+	set(&v1, 1)
+	if got, want := get(&v1), 1; got != want {
+		panic(fmt.Sprintf("get() == %d, want %d", got, want))
+	}
+
+	v1.set(2)
+	if got, want := v1.get(), 2; got != want {
+		panic(fmt.Sprintf("get() == %d, want %d", got, want))
+	}
+
+	v1p := new(value[int])
+	set(v1p, 3)
+	if got, want := get(v1p), 3; got != want {
+		panic(fmt.Sprintf("get() == %d, want %d", got, want))
+	}
+
+	v1p.set(4)
+	if got, want := v1p.get(), 4; got != want {
+		panic(fmt.Sprintf("get() == %d, want %d", got, want))
+	}
+
+	var v2 value[string]
+	set(&v2, "a")
+	if got, want := get(&v2), "a"; got != want {
+		panic(fmt.Sprintf("get() == %q, want %q", got, want))
+	}
+
+	v2.set("b")
+	if got, want := get(&v2), "b"; got != want {
+		panic(fmt.Sprintf("get() == %q, want %q", got, want))
+	}
+
+	v2p := new(value[string])
+	set(v2p, "c")
+	if got, want := get(v2p), "c"; got != want {
+		panic(fmt.Sprintf("get() == %d, want %d", got, want))
+	}
+
+	v2p.set("d")
+	if got, want := v2p.get(), "d"; got != want {
+		panic(fmt.Sprintf("get() == %d, want %d", got, want))
+	}
+}
-- 
GitLab


From a789be78145e9aa33f1616fd3b19570db53887e0 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 18 Feb 2021 15:09:38 -0800
Subject: [PATCH 0681/2400] [dev.typeparams] cmd/compile: use new converter
 functions rather than methods (fix build)

Change-Id: I4dcaca1f2e67ee32f70c22b2efa586232ca519bb
Reviewed-on: https://go-review.googlesource.com/c/go/+/293958
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/noder/expr.go       | 6 +++---
 src/cmd/compile/internal/types2/selection.go | 8 ++++----
 src/cmd/compile/internal/types2/type.go      | 5 +++++
 3 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index 2819c8252d..b166d34ead 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -237,15 +237,15 @@ func (g *irgen) selectorExpr(pos src.XPos, typ types2.Type, expr *syntax.Selecto
 			}
 			recvType2Base := recvType2
 			if wantPtr {
-				recvType2Base = recvType2.Pointer().Elem()
+				recvType2Base = types2.AsPointer(recvType2).Elem()
 			}
-			if len(recvType2Base.Named().TParams()) > 0 {
+			if len(types2.AsNamed(recvType2Base).TParams()) > 0 {
 				// recvType2 is the original generic type that is
 				// instantiated for this method call.
 				// selinfo.Recv() is the instantiated type
 				recvType2 = recvType2Base
 				// method is the generic method associated with the gen type
-				method := g.obj(recvType2.Named().Method(last))
+				method := g.obj(types2.AsNamed(recvType2).Method(last))
 				n = ir.NewSelectorExpr(pos, ir.OCALLPART, x, method.Sym())
 				n.(*ir.SelectorExpr).Selection = types.NewField(pos, method.Sym(), method.Type())
 				n.(*ir.SelectorExpr).Selection.Nname = method
diff --git a/src/cmd/compile/internal/types2/selection.go b/src/cmd/compile/internal/types2/selection.go
index 4358458b88..67d1aa7e1d 100644
--- a/src/cmd/compile/internal/types2/selection.go
+++ b/src/cmd/compile/internal/types2/selection.go
@@ -55,11 +55,11 @@ func (s *Selection) Recv() Type { return s.recv }
 // TODO(gri):  fix this bug.
 func (s *Selection) TArgs() []Type {
 	r := s.recv
-	if r.Pointer() != nil {
-		r = r.Pointer().Elem()
+	if p := asPointer(r); p != nil {
+		r = p.Elem()
 	}
-	if r.Named() != nil {
-		return r.Named().TArgs()
+	if n := asNamed(r); n != nil {
+		return n.TArgs()
 	}
 	// The base type (after skipping any pointer) must be a Named type. The
 	// bug is that sometimes it can be an instance type (which is supposed to
diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
index a9ac90246d..1025c18b23 100644
--- a/src/cmd/compile/internal/types2/type.go
+++ b/src/cmd/compile/internal/types2/type.go
@@ -971,3 +971,8 @@ func asTypeParam(t Type) *TypeParam {
 	u, _ := under(t).(*TypeParam)
 	return u
 }
+
+// Exported for the compiler.
+
+func AsPointer(t Type) *Pointer { return asPointer(t) }
+func AsNamed(t Type) *Named     { return asNamed(t) }
-- 
GitLab


From e7ee3c1fa87556245e38b662ea5b3002bbeb32b9 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 30 Jan 2021 07:27:24 -0500
Subject: [PATCH 0682/2400] os: report Windows exit status in hex
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

We print things like “exit status 3221225477”
but the standard Windows form is 0xc0000005.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.
This CL is, however, not windows/arm64-specific.
It is cleanup meant to make the port (and future ports) easier.

Change-Id: Iefe447d4d1781b53bef9619f68d386f2866b2934
Reviewed-on: https://go-review.googlesource.com/c/go/+/288792
Trust: Russ Cox <rsc@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/os/exec_posix.go |  7 ++++++-
 src/os/str.go        | 36 ++++++++++++++++++++++++++++++++++--
 2 files changed, 40 insertions(+), 3 deletions(-)

diff --git a/src/os/exec_posix.go b/src/os/exec_posix.go
index 7ecddaed37..39f11c7ec1 100644
--- a/src/os/exec_posix.go
+++ b/src/os/exec_posix.go
@@ -102,7 +102,12 @@ func (p *ProcessState) String() string {
 	res := ""
 	switch {
 	case status.Exited():
-		res = "exit status " + itoa(status.ExitStatus())
+		code := status.ExitStatus()
+		if runtime.GOOS == "windows" && code >= 1<<16 { // windows uses large hex numbers
+			res = "exit status " + uitox(uint(code))
+		} else { // unix systems use small decimal integers
+			res = "exit status " + itoa(code) // unix
+		}
 	case status.Signaled():
 		res = "signal: " + status.Signal().String()
 	case status.Stopped():
diff --git a/src/os/str.go b/src/os/str.go
index cba9fa3e8d..9bfcc15aa8 100644
--- a/src/os/str.go
+++ b/src/os/str.go
@@ -6,7 +6,7 @@
 
 package os
 
-// Convert integer to decimal string
+// itoa converts val (an int) to a decimal string.
 func itoa(val int) string {
 	if val < 0 {
 		return "-" + uitoa(uint(-val))
@@ -14,7 +14,7 @@ func itoa(val int) string {
 	return uitoa(uint(val))
 }
 
-// Convert unsigned integer to decimal string
+// uitoa converts val (a uint) to a decimal string.
 func uitoa(val uint) string {
 	if val == 0 { // avoid string allocation
 		return "0"
@@ -31,3 +31,35 @@ func uitoa(val uint) string {
 	buf[i] = byte('0' + val)
 	return string(buf[i:])
 }
+
+// itox converts val (an int) to a hexdecimal string.
+func itox(val int) string {
+	if val < 0 {
+		return "-" + uitox(uint(-val))
+	}
+	return uitox(uint(val))
+}
+
+const hex = "0123456789abcdef"
+
+// uitox converts val (a uint) to a hexdecimal string.
+func uitox(val uint) string {
+	if val == 0 { // avoid string allocation
+		return "0x0"
+	}
+	var buf [20]byte // big enough for 64bit value base 16 + 0x
+	i := len(buf) - 1
+	for val >= 16 {
+		q := val / 16
+		buf[i] = hex[val%16]
+		i--
+		val = q
+	}
+	// val < 16
+	buf[i] = hex[val%16]
+	i--
+	buf[i] = 'x'
+	i--
+	buf[i] = '0'
+	return string(buf[i:])
+}
-- 
GitLab


From 0d94f989d12a52ddc3869dbaa02255873f7a8196 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 30 Jan 2021 07:07:42 -0500
Subject: [PATCH 0683/2400] runtime: clean up system calls during cgo callback
 init

During a cgocallback, the runtime calls needm to get an m.
The calls made during needm cannot themselves assume that
there is an m or a g (which is attached to the m).

In the old days of making direct system calls, the only thing
you had to do for such functions was mark them //go:nosplit,
to avoid the use of g in the stack split prologue.

But now, on operating systems that make system calls through
shared libraries and use code that saves state in the g or m
before doing so, it's not safe to assume g exists. In fact, it is
not even safe to call getg(), because it might fault deferencing
the TLS storage to find the g pointer (that storage may not be
initialized yet, at least on Windows, and perhaps on other systems
in the future).

The specific routines that are problematic are usleep and osyield,
which are called during lock contention in lockextra, called
from needm.

All this is rather subtle and hidden, so in addition to fixing the
problem on Windows, this CL makes the fact of not running on
a g much clearer by introducing variants usleep_no_g and
osyield_no_g whose names should make clear that there is no g.
And then we can remove the various sketchy getg() == nil checks
in the existing routines.

As part of this cleanup, this CL also deletes onosstack on Windows.
onosstack is from back when the runtime was implemented in C.
It predates systemstack but does essentially the same thing.
Instead of having two different copies of this code, we can use
systemstack consistently. This way we need not port onosstack
to each architecture.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.
This CL is, however, not windows/arm64-specific.
It is cleanup meant to make the port (and future ports) easier.

Change-Id: I3352de1fd0a3c26267c6e209063e6e86abd26187
Reviewed-on: https://go-review.googlesource.com/c/go/+/288793
Trust: Russ Cox <rsc@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
---
 src/runtime/asm_386.s              | 16 ++++++
 src/runtime/asm_amd64.s            | 17 ++++++
 src/runtime/asm_arm.s              | 15 ++++++
 src/runtime/asm_arm64.s            | 13 ++++-
 src/runtime/asm_mips64x.s          |  9 ++++
 src/runtime/os2_aix.go             | 42 +++++++--------
 src/runtime/os3_solaris.go         | 20 +++----
 src/runtime/os_darwin.go           |  5 ++
 src/runtime/os_dragonfly.go        |  5 ++
 src/runtime/os_freebsd.go          |  5 ++
 src/runtime/os_js.go               | 10 ++++
 src/runtime/os_linux.go            |  5 ++
 src/runtime/os_netbsd.go           |  5 ++
 src/runtime/os_openbsd_syscall1.go |  5 ++
 src/runtime/os_openbsd_syscall2.go |  5 ++
 src/runtime/os_plan9.go            | 10 ++++
 src/runtime/os_windows.go          | 38 +++++++++-----
 src/runtime/proc.go                |  6 +--
 src/runtime/stubs2.go              |  5 ++
 src/runtime/stubs_386.go           |  3 ++
 src/runtime/stubs_amd64.go         |  5 ++
 src/runtime/stubs_arm.go           |  5 ++
 src/runtime/stubs_arm64.go         |  5 ++
 src/runtime/stubs_mips64x.go       |  5 ++
 src/runtime/sys_darwin.go          |  6 +++
 src/runtime/sys_openbsd1.go        |  5 ++
 src/runtime/sys_openbsd2.go        |  6 +++
 src/runtime/sys_windows_386.s      | 79 ++++------------------------
 src/runtime/sys_windows_amd64.s    | 71 ++++---------------------
 src/runtime/sys_windows_arm.s      | 84 ++++--------------------------
 30 files changed, 254 insertions(+), 256 deletions(-)

diff --git a/src/runtime/asm_386.s b/src/runtime/asm_386.s
index 471451df28..3030101f03 100644
--- a/src/runtime/asm_386.s
+++ b/src/runtime/asm_386.s
@@ -621,6 +621,22 @@ TEXT gosave<>(SB),NOSPLIT,$0
 	POPL	AX
 	RET
 
+// func asmcgocall_no_g(fn, arg unsafe.Pointer)
+// Call fn(arg) aligned appropriately for the gcc ABI.
+// Called on a system stack, and there may be no g yet (during needm).
+TEXT ·asmcgocall_no_g(SB),NOSPLIT,$0-8
+	MOVL	fn+0(FP), AX
+	MOVL	arg+4(FP), BX
+	MOVL	SP, DX
+	SUBL	$32, SP
+	ANDL	$~15, SP	// alignment, perhaps unnecessary
+	MOVL	DX, 8(SP)	// save old SP
+	MOVL	BX, 0(SP)	// first argument in x86-32 ABI
+	CALL	AX
+	MOVL	8(SP), DX
+	MOVL	DX, SP
+	RET
+
 // func asmcgocall(fn, arg unsafe.Pointer) int32
 // Call fn(arg) on the scheduler stack,
 // aligned appropriately for the gcc ABI.
diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index 05422c9699..9362ce1213 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -679,6 +679,23 @@ TEXT gosave<>(SB),NOSPLIT,$0
 	CALL	runtime·badctxt(SB)
 	RET
 
+// func asmcgocall_no_g(fn, arg unsafe.Pointer)
+// Call fn(arg) aligned appropriately for the gcc ABI.
+// Called on a system stack, and there may be no g yet (during needm).
+TEXT ·asmcgocall_no_g(SB),NOSPLIT,$0-16
+	MOVQ	fn+0(FP), AX
+	MOVQ	arg+8(FP), BX
+	MOVQ	SP, DX
+	SUBQ	$32, SP
+	ANDQ	$~15, SP	// alignment
+	MOVQ	DX, 8(SP)
+	MOVQ	BX, DI		// DI = first argument in AMD64 ABI
+	MOVQ	BX, CX		// CX = first argument in Win64
+	CALL	AX
+	MOVQ	8(SP), DX
+	MOVQ	DX, SP
+	RET
+
 // func asmcgocall(fn, arg unsafe.Pointer) int32
 // Call fn(arg) on the scheduler stack,
 // aligned appropriately for the gcc ABI.
diff --git a/src/runtime/asm_arm.s b/src/runtime/asm_arm.s
index 23619b1408..109030aada 100644
--- a/src/runtime/asm_arm.s
+++ b/src/runtime/asm_arm.s
@@ -552,6 +552,21 @@ TEXT gosave<>(SB),NOSPLIT|NOFRAME,$0
 	CALL	runtime·badctxt(SB)
 	RET
 
+// func asmcgocall_no_g(fn, arg unsafe.Pointer)
+// Call fn(arg) aligned appropriately for the gcc ABI.
+// Called on a system stack, and there may be no g yet (during needm).
+TEXT ·asmcgocall_no_g(SB),NOSPLIT,$0-8
+	MOVW	fn+0(FP), R1
+	MOVW	arg+4(FP), R0
+	MOVW	R13, R2
+	SUB	$32, R13
+	BIC	$0x7, R13	// alignment for gcc ABI
+	MOVW	R2, 8(R13)
+	BL	(R1)
+	MOVW	8(R13), R2
+	MOVW	R2, R13
+	RET
+
 // func asmcgocall(fn, arg unsafe.Pointer) int32
 // Call fn(arg) on the scheduler stack,
 // aligned appropriately for the gcc ABI.
diff --git a/src/runtime/asm_arm64.s b/src/runtime/asm_arm64.s
index 0ab92be1e4..79efd4cb17 100644
--- a/src/runtime/asm_arm64.s
+++ b/src/runtime/asm_arm64.s
@@ -873,6 +873,17 @@ TEXT gosave<>(SB),NOSPLIT|NOFRAME,$0
 	CALL	runtime·badctxt(SB)
 	RET
 
+// func asmcgocall_no_g(fn, arg unsafe.Pointer)
+// Call fn(arg) aligned appropriately for the gcc ABI.
+// Called on a system stack, and there may be no g yet (during needm).
+TEXT ·asmcgocall_no_g(SB),NOSPLIT,$0-16
+	MOVD	fn+0(FP), R1
+	MOVD	arg+8(FP), R0
+	SUB	$16, RSP	// skip over saved frame pointer below RSP
+	BL	(R1)
+	ADD	$16, RSP	// skip over saved frame pointer below RSP
+	RET
+
 // func asmcgocall(fn, arg unsafe.Pointer) int32
 // Call fn(arg) on the scheduler stack,
 // aligned appropriately for the gcc ABI.
@@ -951,7 +962,7 @@ nosave:
 	BL	(R1)
 	// Restore stack pointer.
 	MOVD	8(RSP), R2
-	MOVD	R2, RSP	
+	MOVD	R2, RSP
 	MOVD	R0, ret+16(FP)
 	RET
 
diff --git a/src/runtime/asm_mips64x.s b/src/runtime/asm_mips64x.s
index 694950663a..6e1d25cd90 100644
--- a/src/runtime/asm_mips64x.s
+++ b/src/runtime/asm_mips64x.s
@@ -413,6 +413,15 @@ TEXT gosave<>(SB),NOSPLIT|NOFRAME,$0
 	JAL	runtime·badctxt(SB)
 	RET
 
+// func asmcgocall_no_g(fn, arg unsafe.Pointer)
+// Call fn(arg) aligned appropriately for the gcc ABI.
+// Called on a system stack, and there may be no g yet (during needm).
+TEXT ·asmcgocall_no_g(SB),NOSPLIT,$0-16
+	MOVV	fn+0(FP), R25
+	MOVV	arg+8(FP), R4
+	JAL	(R25)
+	RET
+
 // func asmcgocall(fn, arg unsafe.Pointer) int32
 // Call fn(arg) on the scheduler stack,
 // aligned appropriately for the gcc ABI.
diff --git a/src/runtime/os2_aix.go b/src/runtime/os2_aix.go
index abd1010be9..4d77f0de6d 100644
--- a/src/runtime/os2_aix.go
+++ b/src/runtime/os2_aix.go
@@ -527,20 +527,17 @@ func internal_cpu_getsystemcfg(label uint) uint {
 func usleep1(us uint32)
 
 //go:nosplit
-func usleep(us uint32) {
-	_g_ := getg()
+func usleep_no_g(us uint32) {
+	usleep1(us)
+}
 
-	// Check the validity of m because we might be called in cgo callback
-	// path early enough where there isn't a g or a m available yet.
-	if _g_ != nil && _g_.m != nil {
-		r, err := syscall1(&libc_usleep, uintptr(us))
-		if int32(r) == -1 {
-			println("syscall usleep failed: ", hex(err))
-			throw("syscall usleep")
-		}
-		return
+//go:nosplit
+func usleep(us uint32) {
+	r, err := syscall1(&libc_usleep, uintptr(us))
+	if int32(r) == -1 {
+		println("syscall usleep failed: ", hex(err))
+		throw("syscall usleep")
 	}
-	usleep1(us)
 }
 
 //go:nosplit
@@ -611,20 +608,17 @@ func raiseproc(sig uint32) {
 func osyield1()
 
 //go:nosplit
-func osyield() {
-	_g_ := getg()
+func osyield_no_g() {
+	osyield1()
+}
 
-	// Check the validity of m because it might be called during a cgo
-	// callback early enough where m isn't available yet.
-	if _g_ != nil && _g_.m != nil {
-		r, err := syscall0(&libc_sched_yield)
-		if int32(r) == -1 {
-			println("syscall osyield failed: ", hex(err))
-			throw("syscall osyield")
-		}
-		return
+//go:nosplit
+func osyield() {
+	r, err := syscall0(&libc_sched_yield)
+	if int32(r) == -1 {
+		println("syscall osyield failed: ", hex(err))
+		throw("syscall osyield")
 	}
-	osyield1()
 }
 
 //go:nosplit
diff --git a/src/runtime/os3_solaris.go b/src/runtime/os3_solaris.go
index 6ba11afd93..4b65139eb8 100644
--- a/src/runtime/os3_solaris.go
+++ b/src/runtime/os3_solaris.go
@@ -521,6 +521,11 @@ func sysconf(name int32) int64 {
 
 func usleep1(usec uint32)
 
+//go:nosplit
+func usleep_no_g(µs uint32) {
+	usleep1(µs)
+}
+
 //go:nosplit
 func usleep(µs uint32) {
 	usleep1(µs)
@@ -569,18 +574,15 @@ func setNonblock(fd int32) {
 func osyield1()
 
 //go:nosplit
-func osyield() {
-	_g_ := getg()
-
-	// Check the validity of m because we might be called in cgo callback
-	// path early enough where there isn't a m available yet.
-	if _g_ != nil && _g_.m != nil {
-		sysvicall0(&libc_sched_yield)
-		return
-	}
+func osyield_no_g() {
 	osyield1()
 }
 
+//go:nosplit
+func osyield() {
+	sysvicall0(&libc_sched_yield)
+}
+
 //go:linkname executablePath os.executablePath
 var executablePath string
 
diff --git a/src/runtime/os_darwin.go b/src/runtime/os_darwin.go
index 9ca17c20df..470698d0a3 100644
--- a/src/runtime/os_darwin.go
+++ b/src/runtime/os_darwin.go
@@ -330,6 +330,11 @@ func unminit() {
 func mdestroy(mp *m) {
 }
 
+//go:nosplit
+func osyield_no_g() {
+	usleep_no_g(1)
+}
+
 //go:nosplit
 func osyield() {
 	usleep(1)
diff --git a/src/runtime/os_dragonfly.go b/src/runtime/os_dragonfly.go
index 383df54bd4..b786c8ab5f 100644
--- a/src/runtime/os_dragonfly.go
+++ b/src/runtime/os_dragonfly.go
@@ -51,6 +51,11 @@ func sys_umtx_wakeup(addr *uint32, val int32) int32
 
 func osyield()
 
+//go:nosplit
+func osyield_no_g() {
+	osyield()
+}
+
 func kqueue() int32
 
 //go:noescape
diff --git a/src/runtime/os_freebsd.go b/src/runtime/os_freebsd.go
index 09065ccb68..09dd50ce59 100644
--- a/src/runtime/os_freebsd.go
+++ b/src/runtime/os_freebsd.go
@@ -36,6 +36,11 @@ func sys_umtx_op(addr *uint32, mode int32, val uint32, uaddr1 uintptr, ut *umtx_
 
 func osyield()
 
+//go:nosplit
+func osyield_no_g() {
+	osyield()
+}
+
 func kqueue() int32
 
 //go:noescape
diff --git a/src/runtime/os_js.go b/src/runtime/os_js.go
index 24261e88a2..5b2c53795a 100644
--- a/src/runtime/os_js.go
+++ b/src/runtime/os_js.go
@@ -30,12 +30,22 @@ func wasmWrite(fd uintptr, p unsafe.Pointer, n int32)
 
 func usleep(usec uint32)
 
+//go:nosplit
+func usleep_no_g(usec uint32) {
+	usleep(usec)
+}
+
 func exitThread(wait *uint32)
 
 type mOS struct{}
 
 func osyield()
 
+//go:nosplit
+func osyield_no_g() {
+	osyield()
+}
+
 const _SIGSEGV = 0xb
 
 func sigpanic() {
diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index 058c7daf9c..21d3ae653e 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -410,6 +410,11 @@ func raiseproc(sig uint32)
 func sched_getaffinity(pid, len uintptr, buf *byte) int32
 func osyield()
 
+//go:nosplit
+func osyield_no_g() {
+	osyield()
+}
+
 func pipe() (r, w int32, errno int32)
 func pipe2(flags int32) (r, w int32, errno int32)
 func setNonblock(fd int32)
diff --git a/src/runtime/os_netbsd.go b/src/runtime/os_netbsd.go
index 2b742a3711..0328fa57ae 100644
--- a/src/runtime/os_netbsd.go
+++ b/src/runtime/os_netbsd.go
@@ -67,6 +67,11 @@ func lwp_self() int32
 
 func osyield()
 
+//go:nosplit
+func osyield_no_g() {
+	osyield()
+}
+
 func kqueue() int32
 
 //go:noescape
diff --git a/src/runtime/os_openbsd_syscall1.go b/src/runtime/os_openbsd_syscall1.go
index b0bef4c504..f37da04194 100644
--- a/src/runtime/os_openbsd_syscall1.go
+++ b/src/runtime/os_openbsd_syscall1.go
@@ -13,3 +13,8 @@ func thrsleep(ident uintptr, clock_id int32, tsp *timespec, lock uintptr, abort
 func thrwakeup(ident uintptr, n int32) int32
 
 func osyield()
+
+//go:nosplit
+func osyield_no_g() {
+	osyield()
+}
diff --git a/src/runtime/os_openbsd_syscall2.go b/src/runtime/os_openbsd_syscall2.go
index ab940510af..81cfb085aa 100644
--- a/src/runtime/os_openbsd_syscall2.go
+++ b/src/runtime/os_openbsd_syscall2.go
@@ -32,6 +32,11 @@ func closefd(fd int32) int32
 func exit(code int32)
 func usleep(usec uint32)
 
+//go:nosplit
+func usleep_no_g(usec uint32) {
+	usleep(usec)
+}
+
 // write calls the write system call.
 // It returns a non-negative number of bytes written or a negative errno value.
 //go:noescape
diff --git a/src/runtime/os_plan9.go b/src/runtime/os_plan9.go
index 2a84a73716..77665f461a 100644
--- a/src/runtime/os_plan9.go
+++ b/src/runtime/os_plan9.go
@@ -339,6 +339,11 @@ func osyield() {
 	sleep(0)
 }
 
+//go:nosplit
+func osyield_no_g() {
+	osyield()
+}
+
 //go:nosplit
 func usleep(µs uint32) {
 	ms := int32(µs / 1000)
@@ -348,6 +353,11 @@ func usleep(µs uint32) {
 	sleep(ms)
 }
 
+//go:nosplit
+func usleep_no_g(usec uint32) {
+	usleep(usec)
+}
+
 //go:nosplit
 func nanotime1() int64 {
 	var scratch int64
diff --git a/src/runtime/os_windows.go b/src/runtime/os_windows.go
index e6b22e3167..1bf3309dfd 100644
--- a/src/runtime/os_windows.go
+++ b/src/runtime/os_windows.go
@@ -461,15 +461,12 @@ func initHighResTimer() {
 	h := createHighResTimer()
 	if h != 0 {
 		haveHighResTimer = true
-		usleep2Addr = unsafe.Pointer(funcPC(usleep2HighRes))
 		stdcall1(_CloseHandle, h)
 	}
 }
 
 func osinit() {
 	asmstdcallAddr = unsafe.Pointer(funcPC(asmstdcall))
-	usleep2Addr = unsafe.Pointer(funcPC(usleep2))
-	switchtothreadAddr = unsafe.Pointer(funcPC(switchtothread))
 
 	setBadSignalMsg()
 
@@ -1061,26 +1058,39 @@ func stdcall7(fn stdFunction, a0, a1, a2, a3, a4, a5, a6 uintptr) uintptr {
 	return stdcall(fn)
 }
 
-// In sys_windows_386.s and sys_windows_amd64.s.
-func onosstack(fn unsafe.Pointer, arg uint32)
-
-// These are not callable functions. They should only be called via onosstack.
-func usleep2(usec uint32)
-func usleep2HighRes(usec uint32)
+// These must run on the system stack only.
+func usleep2(dt int32)
+func usleep2HighRes(dt int32)
 func switchtothread()
 
-var usleep2Addr unsafe.Pointer
-var switchtothreadAddr unsafe.Pointer
+//go:nosplit
+func osyield_no_g() {
+	switchtothread()
+}
 
 //go:nosplit
 func osyield() {
-	onosstack(switchtothreadAddr, 0)
+	systemstack(switchtothread)
+}
+
+//go:nosplit
+func usleep_no_g(us uint32) {
+	dt := -10 * int32(us) // relative sleep (negative), 100ns units
+	usleep2(dt)
 }
 
 //go:nosplit
 func usleep(us uint32) {
-	// Have 1us units; want 100ns units.
-	onosstack(usleep2Addr, 10*us)
+	systemstack(func() {
+		dt := -10 * int32(us) // relative sleep (negative), 100ns units
+		// If the high-res timer is available and its handle has been allocated for this m, use it.
+		// Otherwise fall back to the low-res one, which doesn't need a handle.
+		if haveHighResTimer && getg().m.highResTimer != 0 {
+			usleep2HighRes(dt)
+		} else {
+			usleep2(dt)
+		}
+	})
 }
 
 func ctrlhandler1(_type uint32) uint32 {
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 73a789c189..4092dd55cb 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -2012,7 +2012,7 @@ func lockextra(nilokay bool) *m {
 	for {
 		old := atomic.Loaduintptr(&extram)
 		if old == locked {
-			osyield()
+			osyield_no_g()
 			continue
 		}
 		if old == 0 && !nilokay {
@@ -2023,13 +2023,13 @@ func lockextra(nilokay bool) *m {
 				atomic.Xadd(&extraMWaiters, 1)
 				incr = true
 			}
-			usleep(1)
+			usleep_no_g(1)
 			continue
 		}
 		if atomic.Casuintptr(&extram, old, locked) {
 			return (*m)(unsafe.Pointer(old))
 		}
-		osyield()
+		osyield_no_g()
 		continue
 	}
 }
diff --git a/src/runtime/stubs2.go b/src/runtime/stubs2.go
index 85088b3ab9..96096d236b 100644
--- a/src/runtime/stubs2.go
+++ b/src/runtime/stubs2.go
@@ -23,6 +23,11 @@ func closefd(fd int32) int32
 func exit(code int32)
 func usleep(usec uint32)
 
+//go:nosplit
+func usleep_no_g(usec uint32) {
+	usleep(usec)
+}
+
 // write calls the write system call.
 // It returns a non-negative number of bytes written or a negative errno value.
 //go:noescape
diff --git a/src/runtime/stubs_386.go b/src/runtime/stubs_386.go
index 5108294d83..300f167fff 100644
--- a/src/runtime/stubs_386.go
+++ b/src/runtime/stubs_386.go
@@ -15,3 +15,6 @@ func stackcheck()
 // Called from assembly only; declared for go vet.
 func setldt(slot uintptr, base unsafe.Pointer, size uintptr)
 func emptyfunc()
+
+//go:noescape
+func asmcgocall_no_g(fn, arg unsafe.Pointer)
diff --git a/src/runtime/stubs_amd64.go b/src/runtime/stubs_amd64.go
index 8c14bc2271..bf98493e9d 100644
--- a/src/runtime/stubs_amd64.go
+++ b/src/runtime/stubs_amd64.go
@@ -4,6 +4,8 @@
 
 package runtime
 
+import "unsafe"
+
 // Called from compiled code; declared for vet; do NOT call from Go.
 func gcWriteBarrierCX()
 func gcWriteBarrierDX()
@@ -35,3 +37,6 @@ func retpolineR12()
 func retpolineR13()
 func retpolineR14()
 func retpolineR15()
+
+//go:noescape
+func asmcgocall_no_g(fn, arg unsafe.Pointer)
diff --git a/src/runtime/stubs_arm.go b/src/runtime/stubs_arm.go
index c13bf16de2..52c32937ae 100644
--- a/src/runtime/stubs_arm.go
+++ b/src/runtime/stubs_arm.go
@@ -4,6 +4,8 @@
 
 package runtime
 
+import "unsafe"
+
 // Called from compiler-generated code; declared for go vet.
 func udiv()
 func _div()
@@ -18,3 +20,6 @@ func save_g()
 func emptyfunc()
 func _initcgo()
 func read_tls_fallback()
+
+//go:noescape
+func asmcgocall_no_g(fn, arg unsafe.Pointer)
diff --git a/src/runtime/stubs_arm64.go b/src/runtime/stubs_arm64.go
index 44c566e602..6e6e7df6b8 100644
--- a/src/runtime/stubs_arm64.go
+++ b/src/runtime/stubs_arm64.go
@@ -4,6 +4,11 @@
 
 package runtime
 
+import "unsafe"
+
 // Called from assembly only; declared for go vet.
 func load_g()
 func save_g()
+
+//go:noescape
+func asmcgocall_no_g(fn, arg unsafe.Pointer)
diff --git a/src/runtime/stubs_mips64x.go b/src/runtime/stubs_mips64x.go
index 4e62c1ce90..652e7a9e34 100644
--- a/src/runtime/stubs_mips64x.go
+++ b/src/runtime/stubs_mips64x.go
@@ -6,6 +6,11 @@
 
 package runtime
 
+import "unsafe"
+
 // Called from assembly only; declared for go vet.
 func load_g()
 func save_g()
+
+//go:noescape
+func asmcgocall_no_g(fn, arg unsafe.Pointer)
diff --git a/src/runtime/sys_darwin.go b/src/runtime/sys_darwin.go
index 4a3f2fc453..dacce2ee1a 100644
--- a/src/runtime/sys_darwin.go
+++ b/src/runtime/sys_darwin.go
@@ -227,6 +227,12 @@ func usleep(usec uint32) {
 }
 func usleep_trampoline()
 
+//go:nosplit
+//go:cgo_unsafe_args
+func usleep_no_g(usec uint32) {
+	asmcgocall_no_g(unsafe.Pointer(funcPC(usleep_trampoline)), unsafe.Pointer(&usec))
+}
+
 //go:nosplit
 //go:cgo_unsafe_args
 func write1(fd uintptr, p unsafe.Pointer, n int32) int32 {
diff --git a/src/runtime/sys_openbsd1.go b/src/runtime/sys_openbsd1.go
index e2886218db..44c7871ceb 100644
--- a/src/runtime/sys_openbsd1.go
+++ b/src/runtime/sys_openbsd1.go
@@ -27,6 +27,11 @@ func osyield() {
 }
 func sched_yield_trampoline()
 
+//go:nosplit
+func osyield_no_g() {
+	asmcgocall_no_g(unsafe.Pointer(funcPC(sched_yield_trampoline)), unsafe.Pointer(nil))
+}
+
 //go:cgo_import_dynamic libc_thrsleep __thrsleep "libc.so"
 //go:cgo_import_dynamic libc_thrwakeup __thrwakeup "libc.so"
 //go:cgo_import_dynamic libc_sched_yield sched_yield "libc.so"
diff --git a/src/runtime/sys_openbsd2.go b/src/runtime/sys_openbsd2.go
index 474e7145e7..33032596c3 100644
--- a/src/runtime/sys_openbsd2.go
+++ b/src/runtime/sys_openbsd2.go
@@ -128,6 +128,12 @@ func usleep(usec uint32) {
 }
 func usleep_trampoline()
 
+//go:nosplit
+//go:cgo_unsafe_args
+func usleep_no_g(usec uint32) {
+	asmcgocall_no_g(unsafe.Pointer(funcPC(usleep_trampoline)), unsafe.Pointer(&usec))
+}
+
 //go:nosplit
 //go:cgo_unsafe_args
 func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, ndst uintptr) int32 {
diff --git a/src/runtime/sys_windows_386.s b/src/runtime/sys_windows_386.s
index ef8a3dd3c2..b3972ac78d 100644
--- a/src/runtime/sys_windows_386.s
+++ b/src/runtime/sys_windows_386.s
@@ -347,60 +347,11 @@ TEXT runtime·setldt(SB),NOSPLIT,$0
 	MOVL	CX, 0x14(FS)
 	RET
 
-// onosstack calls fn on OS stack.
-// func onosstack(fn unsafe.Pointer, arg uint32)
-TEXT runtime·onosstack(SB),NOSPLIT,$0
-	MOVL	fn+0(FP), AX		// to hide from 8l
-	MOVL	arg+4(FP), BX
-
-	// Execute call on m->g0 stack, in case we are not actually
-	// calling a system call wrapper, like when running under WINE.
-	get_tls(CX)
-	CMPL	CX, $0
-	JNE	3(PC)
-	// Not a Go-managed thread. Do not switch stack.
-	CALL	AX
-	RET
-
-	MOVL	g(CX), BP
-	MOVL	g_m(BP), BP
-
-	// leave pc/sp for cpu profiler
-	MOVL	(SP), SI
-	MOVL	SI, m_libcallpc(BP)
-	MOVL	g(CX), SI
-	MOVL	SI, m_libcallg(BP)
-	// sp must be the last, because once async cpu profiler finds
-	// all three values to be non-zero, it will use them
-	LEAL	fn+0(FP), SI
-	MOVL	SI, m_libcallsp(BP)
-
-	MOVL	m_g0(BP), SI
-	CMPL	g(CX), SI
-	JNE	switch
-	// executing on m->g0 already
-	CALL	AX
-	JMP	ret
-
-switch:
-	// Switch to m->g0 stack and back.
-	MOVL	(g_sched+gobuf_sp)(SI), SI
-	MOVL	SP, -4(SI)
-	LEAL	-4(SI), SP
-	CALL	AX
-	MOVL	0(SP), SP
-
-ret:
-	get_tls(CX)
-	MOVL	g(CX), BP
-	MOVL	g_m(BP), BP
-	MOVL	$0, m_libcallsp(BP)
-	RET
-
-// Runs on OS stack. duration (in 100ns units) is in BX.
-TEXT runtime·usleep2(SB),NOSPLIT,$20
-	// Want negative 100ns units.
-	NEGL	BX
+// Runs on OS stack.
+// duration (in -100ns units) is in dt+0(FP).
+// g may be nil.
+TEXT runtime·usleep2(SB),NOSPLIT,$20-4
+	MOVL	dt+0(FP), BX
 	MOVL	$-1, hi-4(SP)
 	MOVL	BX, lo-8(SP)
 	LEAL	lo-8(SP), BX
@@ -413,17 +364,15 @@ TEXT runtime·usleep2(SB),NOSPLIT,$20
 	MOVL	BP, SP
 	RET
 
-// Runs on OS stack. duration (in 100ns units) is in BX.
-TEXT runtime·usleep2HighRes(SB),NOSPLIT,$36
-	get_tls(CX)
-	CMPL	CX, $0
-	JE	gisnotset
-
-	// Want negative 100ns units.
-	NEGL	BX
+// Runs on OS stack.
+// duration (in -100ns units) is in dt+0(FP).
+// g is valid.
+TEXT runtime·usleep2HighRes(SB),NOSPLIT,$36-4
+	MOVL	dt+0(FP), BX
 	MOVL	$-1, hi-4(SP)
 	MOVL	BX, lo-8(SP)
 
+	get_tls(CX)
 	MOVL	g(CX), CX
 	MOVL	g_m(CX), CX
 	MOVL	(m_mOS+mOS_highResTimer)(CX), CX
@@ -452,12 +401,6 @@ TEXT runtime·usleep2HighRes(SB),NOSPLIT,$36
 
 	RET
 
-gisnotset:
-	// TLS is not configured. Call usleep2 instead.
-	MOVL	$runtime·usleep2(SB), AX
-	CALL	AX
-	RET
-
 // Runs on OS stack.
 TEXT runtime·switchtothread(SB),NOSPLIT,$0
 	MOVL	SP, BP
diff --git a/src/runtime/sys_windows_amd64.s b/src/runtime/sys_windows_amd64.s
index d1690cad58..2bd7b74848 100644
--- a/src/runtime/sys_windows_amd64.s
+++ b/src/runtime/sys_windows_amd64.s
@@ -388,61 +388,16 @@ TEXT runtime·settls(SB),NOSPLIT,$0
 	MOVQ	DI, 0x28(GS)
 	RET
 
-// func onosstack(fn unsafe.Pointer, arg uint32)
-TEXT runtime·onosstack(SB),NOSPLIT,$0
-	MOVQ	fn+0(FP), AX		// to hide from 6l
-	MOVL	arg+8(FP), BX
-
-	// Execute call on m->g0 stack, in case we are not actually
-	// calling a system call wrapper, like when running under WINE.
-	get_tls(R15)
-	CMPQ	R15, $0
-	JNE	3(PC)
-	// Not a Go-managed thread. Do not switch stack.
-	CALL	AX
-	RET
-
-	MOVQ	g(R15), R13
-	MOVQ	g_m(R13), R13
-
-	// leave pc/sp for cpu profiler
-	MOVQ	(SP), R12
-	MOVQ	R12, m_libcallpc(R13)
-	MOVQ	g(R15), R12
-	MOVQ	R12, m_libcallg(R13)
-	// sp must be the last, because once async cpu profiler finds
-	// all three values to be non-zero, it will use them
-	LEAQ	fn+0(FP), R12
-	MOVQ	R12, m_libcallsp(R13)
-
-	MOVQ	m_g0(R13), R14
-	CMPQ	g(R15), R14
-	JNE	switch
-	// executing on m->g0 already
-	CALL	AX
-	JMP	ret
-
-switch:
-	// Switch to m->g0 stack and back.
-	MOVQ	(g_sched+gobuf_sp)(R14), R14
-	MOVQ	SP, -8(R14)
-	LEAQ	-8(R14), SP
-	CALL	AX
-	MOVQ	0(SP), SP
-
-ret:
-	MOVQ	$0, m_libcallsp(R13)
-	RET
-
-// Runs on OS stack. duration (in 100ns units) is in BX.
+// Runs on OS stack.
+// duration (in -100ns units) is in dt+0(FP).
+// g may be nil.
 // The function leaves room for 4 syscall parameters
 // (as per windows amd64 calling convention).
-TEXT runtime·usleep2(SB),NOSPLIT|NOFRAME,$48
+TEXT runtime·usleep2(SB),NOSPLIT|NOFRAME,$48-4
+	MOVLQSX	dt+0(FP), BX
 	MOVQ	SP, AX
 	ANDQ	$~15, SP	// alignment as per Windows requirement
 	MOVQ	AX, 40(SP)
-	// Want negative 100ns units.
-	NEGQ	BX
 	LEAQ	32(SP), R8  // ptime
 	MOVQ	BX, (R8)
 	MOVQ	$-1, CX // handle
@@ -452,11 +407,11 @@ TEXT runtime·usleep2(SB),NOSPLIT|NOFRAME,$48
 	MOVQ	40(SP), SP
 	RET
 
-// Runs on OS stack. duration (in 100ns units) is in BX.
-TEXT runtime·usleep2HighRes(SB),NOSPLIT|NOFRAME,$72
+// Runs on OS stack. duration (in -100ns units) is in dt+0(FP).
+// g is valid.
+TEXT runtime·usleep2HighRes(SB),NOSPLIT|NOFRAME,$72-4
+	MOVLQSX	dt+0(FP), BX
 	get_tls(CX)
-	CMPQ	CX, $0
-	JE	gisnotset
 
 	MOVQ	SP, AX
 	ANDQ	$~15, SP	// alignment as per Windows requirement
@@ -466,8 +421,6 @@ TEXT runtime·usleep2HighRes(SB),NOSPLIT|NOFRAME,$72
 	MOVQ	g_m(CX), CX
 	MOVQ	(m_mOS+mOS_highResTimer)(CX), CX	// hTimer
 	MOVQ	CX, 48(SP)				// save hTimer for later
-	// Want negative 100ns units.
-	NEGQ	BX
 	LEAQ	56(SP), DX				// lpDueTime
 	MOVQ	BX, (DX)
 	MOVQ	$0, R8					// lPeriod
@@ -487,12 +440,6 @@ TEXT runtime·usleep2HighRes(SB),NOSPLIT|NOFRAME,$72
 	MOVQ	64(SP), SP
 	RET
 
-gisnotset:
-	// TLS is not configured. Call usleep2 instead.
-	MOVQ	$runtime·usleep2(SB), AX
-	CALL	AX
-	RET
-
 // Runs on OS stack.
 TEXT runtime·switchtothread(SB),NOSPLIT|NOFRAME,$0
 	MOVQ	SP, AX
diff --git a/src/runtime/sys_windows_arm.s b/src/runtime/sys_windows_arm.s
index fe267080cc..1d928a4f7d 100644
--- a/src/runtime/sys_windows_arm.s
+++ b/src/runtime/sys_windows_arm.s
@@ -377,79 +377,11 @@ TEXT runtime·tstart_stdcall(SB),NOSPLIT|NOFRAME,$0
 	MOVW	$0, R0
 	MOVM.IA.W (R13), [R4-R11, R15]		// pop {r4-r11, pc}
 
-// onosstack calls fn on OS stack.
-// adapted from asm_arm.s : systemstack
-// func onosstack(fn unsafe.Pointer, arg uint32)
-TEXT runtime·onosstack(SB),NOSPLIT,$0
-	MOVW	fn+0(FP), R5		// R5 = fn
-	MOVW	arg+4(FP), R6		// R6 = arg
-
-	// This function can be called when there is no g,
-	// for example, when we are handling a callback on a non-go thread.
-	// In this case we're already on the system stack.
-	CMP	$0, g
-	BEQ	noswitch
-
-	MOVW	g_m(g), R1		// R1 = m
-
-	MOVW	m_gsignal(R1), R2	// R2 = gsignal
-	CMP	g, R2
-	B.EQ	noswitch
-
-	MOVW	m_g0(R1), R2		// R2 = g0
-	CMP	g, R2
-	B.EQ	noswitch
-
-	MOVW	m_curg(R1), R3
-	CMP	g, R3
-	B.EQ	switch
-
-	// Bad: g is not gsignal, not g0, not curg. What is it?
-	// Hide call from linker nosplit analysis.
-	MOVW	$runtime·badsystemstack(SB), R0
-	BL	(R0)
-	B	runtime·abort(SB)
-
-switch:
-	// save our state in g->sched. Pretend to
-	// be systemstack_switch if the G stack is scanned.
-	MOVW	$runtime·systemstack_switch(SB), R3
-	ADD	$4, R3, R3 // get past push {lr}
-	MOVW	R3, (g_sched+gobuf_pc)(g)
-	MOVW	R13, (g_sched+gobuf_sp)(g)
-	MOVW	LR, (g_sched+gobuf_lr)(g)
-	MOVW	g, (g_sched+gobuf_g)(g)
-
-	// switch to g0
-	MOVW	R2, g
-	MOVW	(g_sched+gobuf_sp)(R2), R3
-	// make it look like mstart called systemstack on g0, to stop traceback
-	SUB	$4, R3, R3
-	MOVW	$runtime·mstart(SB), R4
-	MOVW	R4, 0(R3)
-	MOVW	R3, R13
-
-	// call target function
-	MOVW	R6, R0		// arg
-	BL	(R5)
-
-	// switch back to g
-	MOVW	g_m(g), R1
-	MOVW	m_curg(R1), g
-	MOVW	(g_sched+gobuf_sp)(g), R13
-	MOVW	$0, R3
-	MOVW	R3, (g_sched+gobuf_sp)(g)
-	RET
-
-noswitch:
-	// Using a tail call here cleans up tracebacks since we won't stop
-	// at an intermediate systemstack.
-	MOVW.P	4(R13), R14	// restore LR
-	MOVW	R6, R0		// arg
-	B	(R5)
-
-// Runs on OS stack. Duration (in 100ns units) is in R0.
-TEXT runtime·usleep2(SB),NOSPLIT|NOFRAME,$0
+// Runs on OS stack.
+// duration (in -100ns units) is in dt+0(FP).
+// g may be nil.
+TEXT runtime·usleep2(SB),NOSPLIT|NOFRAME,$0-4
+	MOVW	dt+0(FP), R0
 	MOVM.DB.W [R4, R14], (R13)	// push {r4, lr}
 	MOVW	R13, R4			// Save SP
 	SUB	$8, R13			// R13 = R13 - 8
@@ -465,9 +397,11 @@ TEXT runtime·usleep2(SB),NOSPLIT|NOFRAME,$0
 	MOVW	R4, R13			// Restore SP
 	MOVM.IA.W (R13), [R4, R15]	// pop {R4, pc}
 
-// Runs on OS stack. Duration (in 100ns units) is in R0.
+// Runs on OS stack.
+// duration (in -100ns units) is in dt+0(FP).
+// g is valid.
 // TODO: neeeds to be implemented properly.
-TEXT runtime·usleep2HighRes(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·usleep2HighRes(SB),NOSPLIT|NOFRAME,$0-4
 	B	runtime·abort(SB)
 
 // Runs on OS stack.
-- 
GitLab


From 678568a5cfe1806c16bf478234d6dac283c3474d Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 30 Jan 2021 16:18:51 -0500
Subject: [PATCH 0684/2400] runtime: delete windows setlasterror (unused)

This is dead code and need not be ported to each architecture.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.
This CL is, however, not windows/arm64-specific.
It is cleanup meant to make the port (and future ports) easier.

Change-Id: I2d0072b377f73e49d7158ea304670c26f5486c59
Reviewed-on: https://go-review.googlesource.com/c/go/+/288794
Trust: Russ Cox <rsc@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
---
 src/runtime/os_windows.go       | 1 -
 src/runtime/sys_windows_386.s   | 5 -----
 src/runtime/sys_windows_amd64.s | 6 ------
 src/runtime/sys_windows_arm.s   | 5 -----
 4 files changed, 17 deletions(-)

diff --git a/src/runtime/os_windows.go b/src/runtime/os_windows.go
index 1bf3309dfd..a2a124cd9d 100644
--- a/src/runtime/os_windows.go
+++ b/src/runtime/os_windows.go
@@ -379,7 +379,6 @@ const (
 // in sys_windows_386.s and sys_windows_amd64.s:
 func externalthreadhandler()
 func getlasterror() uint32
-func setlasterror(err uint32)
 
 // When loading DLLs, we prefer to use LoadLibraryEx with
 // LOAD_LIBRARY_SEARCH_* flags, if available. LoadLibraryEx is not
diff --git a/src/runtime/sys_windows_386.s b/src/runtime/sys_windows_386.s
index b3972ac78d..c556e3a3c2 100644
--- a/src/runtime/sys_windows_386.s
+++ b/src/runtime/sys_windows_386.s
@@ -66,11 +66,6 @@ TEXT runtime·getlasterror(SB),NOSPLIT,$0
 	MOVL	AX, ret+0(FP)
 	RET
 
-TEXT runtime·setlasterror(SB),NOSPLIT,$0
-	MOVL	err+0(FP), AX
-	MOVL	AX, 0x34(FS)
-	RET
-
 // Called by Windows as a Vectored Exception Handler (VEH).
 // First argument is pointer to struct containing
 // exception record and context pointers.
diff --git a/src/runtime/sys_windows_amd64.s b/src/runtime/sys_windows_amd64.s
index 2bd7b74848..9cd14016b0 100644
--- a/src/runtime/sys_windows_amd64.s
+++ b/src/runtime/sys_windows_amd64.s
@@ -103,12 +103,6 @@ TEXT runtime·getlasterror(SB),NOSPLIT,$0
 	MOVL	AX, ret+0(FP)
 	RET
 
-TEXT runtime·setlasterror(SB),NOSPLIT,$0
-	MOVL	err+0(FP), AX
-	MOVQ	0x30(GS),	CX
-	MOVL	AX, 0x68(CX)
-	RET
-
 // Called by Windows as a Vectored Exception Handler (VEH).
 // First argument is pointer to struct containing
 // exception record and context pointers.
diff --git a/src/runtime/sys_windows_arm.s b/src/runtime/sys_windows_arm.s
index 1d928a4f7d..d2bdc50e3b 100644
--- a/src/runtime/sys_windows_arm.s
+++ b/src/runtime/sys_windows_arm.s
@@ -103,11 +103,6 @@ TEXT runtime·getlasterror(SB),NOSPLIT,$0
 	MOVW	R0, ret+0(FP)
 	RET
 
-TEXT runtime·setlasterror(SB),NOSPLIT|NOFRAME,$0
-	MRC	15, 0, R1, C13, C0, 2
-	MOVW	R0, 0x34(R1)
-	RET
-
 // Called by Windows as a Vectored Exception Handler (VEH).
 // First argument is pointer to struct containing
 // exception record and context pointers.
-- 
GitLab


From 8ac23a1f151a9b1842797652ed7761f397055b5b Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Jan 2021 01:06:52 -0500
Subject: [PATCH 0685/2400] runtime: document, clean up internal/sys

Document what the values in internal/sys mean.

Remove various special cases for arm64 in the code using StackAlign.

Delete Uintreg - it was for GOARCH=amd64p32,
which was specific to GOOS=nacl and has been retired.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.
This CL is, however, not windows/arm64-specific.
It is cleanup meant to make the port (and future ports) easier.

Change-Id: I40e8fa07b4e192298b6536b98a72a751951a4383
Reviewed-on: https://go-review.googlesource.com/c/go/+/288795
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/runtime/cgocall.go                    |  9 +-----
 src/runtime/export_test.go                |  2 --
 src/runtime/internal/sys/arch.go          | 38 +++++++++++++++++++++++
 src/runtime/internal/sys/arch_386.go      | 13 +++-----
 src/runtime/internal/sys/arch_amd64.go    | 13 +++-----
 src/runtime/internal/sys/arch_arm.go      | 13 +++-----
 src/runtime/internal/sys/arch_arm64.go    | 13 +++-----
 src/runtime/internal/sys/arch_mips.go     | 13 +++-----
 src/runtime/internal/sys/arch_mips64.go   | 13 +++-----
 src/runtime/internal/sys/arch_mips64le.go | 13 +++-----
 src/runtime/internal/sys/arch_mipsle.go   | 13 +++-----
 src/runtime/internal/sys/arch_ppc64.go    | 13 +++-----
 src/runtime/internal/sys/arch_ppc64le.go  | 13 +++-----
 src/runtime/internal/sys/arch_riscv64.go  | 15 +++------
 src/runtime/internal/sys/arch_s390x.go    | 13 +++-----
 src/runtime/internal/sys/arch_wasm.go     | 13 +++-----
 src/runtime/internal/sys/stubs.go         | 16 ----------
 src/runtime/os3_plan9.go                  |  4 ---
 src/runtime/proc.go                       | 12 +++----
 src/runtime/runtime2.go                   |  2 +-
 src/runtime/runtime_test.go               |  4 +--
 src/runtime/signal_arm64.go               |  2 +-
 src/runtime/stack.go                      |  4 +--
 src/runtime/sys_wasm.go                   |  4 ---
 src/runtime/sys_x86.go                    |  4 ---
 src/runtime/traceback.go                  | 20 +++++-------
 26 files changed, 124 insertions(+), 168 deletions(-)
 delete mode 100644 src/runtime/internal/sys/stubs.go

diff --git a/src/runtime/cgocall.go b/src/runtime/cgocall.go
index 20cacd6043..534a2c4295 100644
--- a/src/runtime/cgocall.go
+++ b/src/runtime/cgocall.go
@@ -306,14 +306,7 @@ func unwindm(restore *bool) {
 		// unwind of g's stack (see comment at top of file).
 		mp := acquirem()
 		sched := &mp.g0.sched
-		switch GOARCH {
-		default:
-			throw("unwindm not implemented")
-		case "386", "amd64", "arm", "ppc64", "ppc64le", "mips64", "mips64le", "s390x", "mips", "mipsle", "riscv64":
-			sched.sp = *(*uintptr)(unsafe.Pointer(sched.sp + sys.MinFrameSize))
-		case "arm64":
-			sched.sp = *(*uintptr)(unsafe.Pointer(sched.sp + 16))
-		}
+		sched.sp = *(*uintptr)(unsafe.Pointer(sched.sp + alignUp(sys.MinFrameSize, sys.StackAlign)))
 
 		// Do the accounting that cgocall will not have a chance to do
 		// during an unwind.
diff --git a/src/runtime/export_test.go b/src/runtime/export_test.go
index 22fef3134f..a48bb2636f 100644
--- a/src/runtime/export_test.go
+++ b/src/runtime/export_test.go
@@ -200,8 +200,6 @@ func GostringW(w []uint16) (s string) {
 	return
 }
 
-type Uintreg sys.Uintreg
-
 var Open = open
 var Close = closefd
 var Read = read
diff --git a/src/runtime/internal/sys/arch.go b/src/runtime/internal/sys/arch.go
index 13c00cf639..69278bf2d5 100644
--- a/src/runtime/internal/sys/arch.go
+++ b/src/runtime/internal/sys/arch.go
@@ -18,3 +18,41 @@ const (
 	S390X
 	WASM
 )
+
+// PtrSize is the size of a pointer in bytes - unsafe.Sizeof(uintptr(0)) but as an ideal constant.
+// It is also the size of the machine's native word size (that is, 4 on 32-bit systems, 8 on 64-bit).
+const PtrSize = 4 << (^uintptr(0) >> 63)
+
+// AIX requires a larger stack for syscalls.
+const StackGuardMultiplier = StackGuardMultiplierDefault*(1-GoosAix) + 2*GoosAix
+
+// ArchFamily is the architecture family (AMD64, ARM, ...)
+const ArchFamily ArchFamilyType = _ArchFamily
+
+// BigEndian reports whether the architecture is big-endian.
+const BigEndian = GoarchArmbe|GoarchArm64be|GoarchMips|GoarchMips64|GoarchPpc|GoarchPpc64|GoarchS390|GoarchS390x|GoarchSparc|GoarchSparc64 == 1
+
+// DefaultPhysPageSize is the default physical page size.
+const DefaultPhysPageSize = _DefaultPhysPageSize
+
+// PCQuantum is the minimal unit for a program counter (1 on x86, 4 on most other systems).
+// The various PC tables record PC deltas pre-divided by PCQuantum.
+const PCQuantum = _PCQuantum
+
+// Int64Align is the required alignment for a 64-bit integer (4 on 32-bit systems, 8 on 64-bit).
+const Int64Align = PtrSize
+
+// MinFrameSize is the size of the system-reserved words at the bottom
+// of a frame (just above the architectural stack pointer).
+// It is zero on x86 and PtrSize on most non-x86 (LR-based) systems.
+// On PowerPC it is larger, to cover three more reserved words:
+// the compiler word, the link editor word, and the TOC save word.
+const MinFrameSize = _MinFrameSize
+
+// StackAlign is the required alignment of the SP register.
+// The stack must be at least word aligned, but some architectures require more.
+const StackAlign = _StackAlign
+
+// DefaultGoroot is set by the linker for use by package runtime.
+// It doesn't really belong in this file or this package.
+var DefaultGoroot string
diff --git a/src/runtime/internal/sys/arch_386.go b/src/runtime/internal/sys/arch_386.go
index b51f70a512..1ebce3435e 100644
--- a/src/runtime/internal/sys/arch_386.go
+++ b/src/runtime/internal/sys/arch_386.go
@@ -5,12 +5,9 @@
 package sys
 
 const (
-	ArchFamily          = I386
-	BigEndian           = false
-	DefaultPhysPageSize = 4096
-	PCQuantum           = 1
-	Int64Align          = 4
-	MinFrameSize        = 0
+	_ArchFamily          = I386
+	_DefaultPhysPageSize = 4096
+	_PCQuantum           = 1
+	_MinFrameSize        = 0
+	_StackAlign          = PtrSize
 )
-
-type Uintreg uint32
diff --git a/src/runtime/internal/sys/arch_amd64.go b/src/runtime/internal/sys/arch_amd64.go
index 3d6776e71e..7f003d0f1d 100644
--- a/src/runtime/internal/sys/arch_amd64.go
+++ b/src/runtime/internal/sys/arch_amd64.go
@@ -5,12 +5,9 @@
 package sys
 
 const (
-	ArchFamily          = AMD64
-	BigEndian           = false
-	DefaultPhysPageSize = 4096
-	PCQuantum           = 1
-	Int64Align          = 8
-	MinFrameSize        = 0
+	_ArchFamily          = AMD64
+	_DefaultPhysPageSize = 4096
+	_PCQuantum           = 1
+	_MinFrameSize        = 0
+	_StackAlign          = PtrSize
 )
-
-type Uintreg uint64
diff --git a/src/runtime/internal/sys/arch_arm.go b/src/runtime/internal/sys/arch_arm.go
index 97960d6f83..ef2048bb71 100644
--- a/src/runtime/internal/sys/arch_arm.go
+++ b/src/runtime/internal/sys/arch_arm.go
@@ -5,12 +5,9 @@
 package sys
 
 const (
-	ArchFamily          = ARM
-	BigEndian           = false
-	DefaultPhysPageSize = 65536
-	PCQuantum           = 4
-	Int64Align          = 4
-	MinFrameSize        = 4
+	_ArchFamily          = ARM
+	_DefaultPhysPageSize = 65536
+	_PCQuantum           = 4
+	_MinFrameSize        = 4
+	_StackAlign          = PtrSize
 )
-
-type Uintreg uint32
diff --git a/src/runtime/internal/sys/arch_arm64.go b/src/runtime/internal/sys/arch_arm64.go
index 911a9485e1..b9f2f7b1fe 100644
--- a/src/runtime/internal/sys/arch_arm64.go
+++ b/src/runtime/internal/sys/arch_arm64.go
@@ -5,12 +5,9 @@
 package sys
 
 const (
-	ArchFamily          = ARM64
-	BigEndian           = false
-	DefaultPhysPageSize = 65536
-	PCQuantum           = 4
-	Int64Align          = 8
-	MinFrameSize        = 8
+	_ArchFamily          = ARM64
+	_DefaultPhysPageSize = 65536
+	_PCQuantum           = 4
+	_MinFrameSize        = 8
+	_StackAlign          = 16
 )
-
-type Uintreg uint64
diff --git a/src/runtime/internal/sys/arch_mips.go b/src/runtime/internal/sys/arch_mips.go
index 75cdb2e07f..4cb0eebea7 100644
--- a/src/runtime/internal/sys/arch_mips.go
+++ b/src/runtime/internal/sys/arch_mips.go
@@ -5,12 +5,9 @@
 package sys
 
 const (
-	ArchFamily          = MIPS
-	BigEndian           = true
-	DefaultPhysPageSize = 65536
-	PCQuantum           = 4
-	Int64Align          = 4
-	MinFrameSize        = 4
+	_ArchFamily          = MIPS
+	_DefaultPhysPageSize = 65536
+	_PCQuantum           = 4
+	_MinFrameSize        = 4
+	_StackAlign          = PtrSize
 )
-
-type Uintreg uint32
diff --git a/src/runtime/internal/sys/arch_mips64.go b/src/runtime/internal/sys/arch_mips64.go
index 494291a802..57636ac4a4 100644
--- a/src/runtime/internal/sys/arch_mips64.go
+++ b/src/runtime/internal/sys/arch_mips64.go
@@ -5,12 +5,9 @@
 package sys
 
 const (
-	ArchFamily          = MIPS64
-	BigEndian           = true
-	DefaultPhysPageSize = 16384
-	PCQuantum           = 4
-	Int64Align          = 8
-	MinFrameSize        = 8
+	_ArchFamily          = MIPS64
+	_DefaultPhysPageSize = 16384
+	_PCQuantum           = 4
+	_MinFrameSize        = 8
+	_StackAlign          = PtrSize
 )
-
-type Uintreg uint64
diff --git a/src/runtime/internal/sys/arch_mips64le.go b/src/runtime/internal/sys/arch_mips64le.go
index d36d1202f6..57636ac4a4 100644
--- a/src/runtime/internal/sys/arch_mips64le.go
+++ b/src/runtime/internal/sys/arch_mips64le.go
@@ -5,12 +5,9 @@
 package sys
 
 const (
-	ArchFamily          = MIPS64
-	BigEndian           = false
-	DefaultPhysPageSize = 16384
-	PCQuantum           = 4
-	Int64Align          = 8
-	MinFrameSize        = 8
+	_ArchFamily          = MIPS64
+	_DefaultPhysPageSize = 16384
+	_PCQuantum           = 4
+	_MinFrameSize        = 8
+	_StackAlign          = PtrSize
 )
-
-type Uintreg uint64
diff --git a/src/runtime/internal/sys/arch_mipsle.go b/src/runtime/internal/sys/arch_mipsle.go
index 323bf82059..4240f5ce47 100644
--- a/src/runtime/internal/sys/arch_mipsle.go
+++ b/src/runtime/internal/sys/arch_mipsle.go
@@ -5,12 +5,9 @@
 package sys
 
 const (
-	ArchFamily          = MIPS
-	BigEndian           = false
-	DefaultPhysPageSize = 65536
-	PCQuantum           = 4
-	Int64Align          = 4
-	MinFrameSize        = 4
+	_ArchFamily          = MIPS
+	_DefaultPhysPageSize = 65536
+	_PCQuantum           = 4
+	_MinFrameSize        = 4
+	_StackAlign          = PtrSize
 )
-
-type Uintreg uint32
diff --git a/src/runtime/internal/sys/arch_ppc64.go b/src/runtime/internal/sys/arch_ppc64.go
index da1fe3d596..1869213ce2 100644
--- a/src/runtime/internal/sys/arch_ppc64.go
+++ b/src/runtime/internal/sys/arch_ppc64.go
@@ -5,12 +5,9 @@
 package sys
 
 const (
-	ArchFamily          = PPC64
-	BigEndian           = true
-	DefaultPhysPageSize = 65536
-	PCQuantum           = 4
-	Int64Align          = 8
-	MinFrameSize        = 32
+	_ArchFamily          = PPC64
+	_DefaultPhysPageSize = 65536
+	_PCQuantum           = 4
+	_MinFrameSize        = 32
+	_StackAlign          = 16
 )
-
-type Uintreg uint64
diff --git a/src/runtime/internal/sys/arch_ppc64le.go b/src/runtime/internal/sys/arch_ppc64le.go
index 605979903a..1869213ce2 100644
--- a/src/runtime/internal/sys/arch_ppc64le.go
+++ b/src/runtime/internal/sys/arch_ppc64le.go
@@ -5,12 +5,9 @@
 package sys
 
 const (
-	ArchFamily          = PPC64
-	BigEndian           = false
-	DefaultPhysPageSize = 65536
-	PCQuantum           = 4
-	Int64Align          = 8
-	MinFrameSize        = 32
+	_ArchFamily          = PPC64
+	_DefaultPhysPageSize = 65536
+	_PCQuantum           = 4
+	_MinFrameSize        = 32
+	_StackAlign          = 16
 )
-
-type Uintreg uint64
diff --git a/src/runtime/internal/sys/arch_riscv64.go b/src/runtime/internal/sys/arch_riscv64.go
index 7cdcc8fcbd..360d236e32 100644
--- a/src/runtime/internal/sys/arch_riscv64.go
+++ b/src/runtime/internal/sys/arch_riscv64.go
@@ -5,14 +5,9 @@
 package sys
 
 const (
-	ArchFamily          = RISCV64
-	BigEndian           = false
-	CacheLineSize       = 64
-	DefaultPhysPageSize = 4096
-	PCQuantum           = 4
-	Int64Align          = 8
-	HugePageSize        = 1 << 21
-	MinFrameSize        = 8
+	_ArchFamily          = RISCV64
+	_DefaultPhysPageSize = 4096
+	_PCQuantum           = 4
+	_MinFrameSize        = 8
+	_StackAlign          = PtrSize
 )
-
-type Uintreg uint64
diff --git a/src/runtime/internal/sys/arch_s390x.go b/src/runtime/internal/sys/arch_s390x.go
index 12cb8a0fcb..e33e0b7f2b 100644
--- a/src/runtime/internal/sys/arch_s390x.go
+++ b/src/runtime/internal/sys/arch_s390x.go
@@ -5,12 +5,9 @@
 package sys
 
 const (
-	ArchFamily          = S390X
-	BigEndian           = true
-	DefaultPhysPageSize = 4096
-	PCQuantum           = 2
-	Int64Align          = 8
-	MinFrameSize        = 8
+	_ArchFamily          = S390X
+	_DefaultPhysPageSize = 4096
+	_PCQuantum           = 2
+	_MinFrameSize        = 8
+	_StackAlign          = PtrSize
 )
-
-type Uintreg uint64
diff --git a/src/runtime/internal/sys/arch_wasm.go b/src/runtime/internal/sys/arch_wasm.go
index eb825df626..ee919ff9e6 100644
--- a/src/runtime/internal/sys/arch_wasm.go
+++ b/src/runtime/internal/sys/arch_wasm.go
@@ -5,12 +5,9 @@
 package sys
 
 const (
-	ArchFamily          = WASM
-	BigEndian           = false
-	DefaultPhysPageSize = 65536
-	PCQuantum           = 1
-	Int64Align          = 8
-	MinFrameSize        = 0
+	_ArchFamily          = WASM
+	_DefaultPhysPageSize = 65536
+	_PCQuantum           = 1
+	_MinFrameSize        = 0
+	_StackAlign          = PtrSize
 )
-
-type Uintreg uint64
diff --git a/src/runtime/internal/sys/stubs.go b/src/runtime/internal/sys/stubs.go
deleted file mode 100644
index 10b0173f60..0000000000
--- a/src/runtime/internal/sys/stubs.go
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright 2014 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 sys
-
-// Declarations for runtime services implemented in C or assembly.
-
-const PtrSize = 4 << (^uintptr(0) >> 63)           // unsafe.Sizeof(uintptr(0)) but an ideal const
-const RegSize = 4 << (^Uintreg(0) >> 63)           // unsafe.Sizeof(uintreg(0)) but an ideal const
-const SpAlign = 1*(1-GoarchArm64) + 16*GoarchArm64 // SP alignment: 1 normally, 16 for ARM64
-
-var DefaultGoroot string // set at link time
-
-// AIX requires a larger stack for syscalls.
-const StackGuardMultiplier = StackGuardMultiplierDefault*(1-GoosAix) + 2*GoosAix
diff --git a/src/runtime/os3_plan9.go b/src/runtime/os3_plan9.go
index 15ca3359d2..b6ee98cab6 100644
--- a/src/runtime/os3_plan9.go
+++ b/src/runtime/os3_plan9.go
@@ -92,10 +92,6 @@ func sighandler(_ureg *ureg, note *byte, gp *g) int {
 			if usesLR {
 				c.setlr(pc)
 			} else {
-				if sys.RegSize > sys.PtrSize {
-					sp -= sys.PtrSize
-					*(*uintptr)(unsafe.Pointer(sp)) = 0
-				}
 				sp -= sys.PtrSize
 				*(*uintptr)(unsafe.Pointer(sp)) = pc
 				c.setsp(sp)
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 4092dd55cb..1dbd01ed40 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -1900,7 +1900,7 @@ func oneNewExtraM() {
 	gp := malg(4096)
 	gp.sched.pc = funcPC(goexit) + sys.PCQuantum
 	gp.sched.sp = gp.stack.hi
-	gp.sched.sp -= 4 * sys.RegSize // extra space in case of reads slightly beyond frame
+	gp.sched.sp -= 4 * sys.PtrSize // extra space in case of reads slightly beyond frame
 	gp.sched.lr = 0
 	gp.sched.g = guintptr(unsafe.Pointer(gp))
 	gp.syscallpc = gp.sched.pc
@@ -4009,9 +4009,9 @@ func newproc1(fn *funcval, argp unsafe.Pointer, narg int32, callergp *g, callerp
 
 	// We could allocate a larger initial stack if necessary.
 	// Not worth it: this is almost always an error.
-	// 4*sizeof(uintreg): extra space added below
-	// sizeof(uintreg): caller's LR (arm) or return address (x86, in gostartcall).
-	if siz >= _StackMin-4*sys.RegSize-sys.RegSize {
+	// 4*PtrSize: extra space added below
+	// PtrSize: caller's LR (arm) or return address (x86, in gostartcall).
+	if siz >= _StackMin-4*sys.PtrSize-sys.PtrSize {
 		throw("newproc: function arguments too large for new goroutine")
 	}
 
@@ -4030,8 +4030,8 @@ func newproc1(fn *funcval, argp unsafe.Pointer, narg int32, callergp *g, callerp
 		throw("newproc1: new g is not Gdead")
 	}
 
-	totalSize := 4*sys.RegSize + uintptr(siz) + sys.MinFrameSize // extra space in case of reads slightly beyond frame
-	totalSize += -totalSize & (sys.SpAlign - 1)                  // align to spAlign
+	totalSize := 4*sys.PtrSize + uintptr(siz) + sys.MinFrameSize // extra space in case of reads slightly beyond frame
+	totalSize += -totalSize & (sys.StackAlign - 1)               // align to StackAlign
 	sp := newg.stack.hi - totalSize
 	spArg := sp
 	if usesLR {
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index b7c7b4cff2..675c613b6e 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -327,7 +327,7 @@ type gobuf struct {
 	pc   uintptr
 	g    guintptr
 	ctxt unsafe.Pointer
-	ret  sys.Uintreg
+	ret  uintptr
 	lr   uintptr
 	bp   uintptr // for framepointer-enabled architectures
 }
diff --git a/src/runtime/runtime_test.go b/src/runtime/runtime_test.go
index e5d2d97d05..4572a25195 100644
--- a/src/runtime/runtime_test.go
+++ b/src/runtime/runtime_test.go
@@ -266,8 +266,8 @@ func TestTrailingZero(t *testing.T) {
 		n int64
 		z struct{}
 	}
-	if unsafe.Sizeof(T2{}) != 8+unsafe.Sizeof(Uintreg(0)) {
-		t.Errorf("sizeof(%#v)==%d, want %d", T2{}, unsafe.Sizeof(T2{}), 8+unsafe.Sizeof(Uintreg(0)))
+	if unsafe.Sizeof(T2{}) != 8+unsafe.Sizeof(uintptr(0)) {
+		t.Errorf("sizeof(%#v)==%d, want %d", T2{}, unsafe.Sizeof(T2{}), 8+unsafe.Sizeof(uintptr(0)))
 	}
 	type T3 struct {
 		n byte
diff --git a/src/runtime/signal_arm64.go b/src/runtime/signal_arm64.go
index 3c20139c99..b559b93938 100644
--- a/src/runtime/signal_arm64.go
+++ b/src/runtime/signal_arm64.go
@@ -63,7 +63,7 @@ func (c *sigctxt) preparePanic(sig uint32, gp *g) {
 	// functions are correctly handled. This smashes
 	// the stack frame but we're not going back there
 	// anyway.
-	sp := c.sp() - sys.SpAlign // needs only sizeof uint64, but must align the stack
+	sp := c.sp() - sys.StackAlign // needs only sizeof uint64, but must align the stack
 	c.set_sp(sp)
 	*(*uint64)(unsafe.Pointer(uintptr(sp))) = c.lr()
 
diff --git a/src/runtime/stack.go b/src/runtime/stack.go
index 7b9dce5393..8c90e7b46f 100644
--- a/src/runtime/stack.go
+++ b/src/runtime/stack.go
@@ -651,7 +651,7 @@ func adjustframe(frame *stkframe, arg unsafe.Pointer) bool {
 
 	// Adjust saved base pointer if there is one.
 	// TODO what about arm64 frame pointer adjustment?
-	if sys.ArchFamily == sys.AMD64 && frame.argp-frame.varp == 2*sys.RegSize {
+	if sys.ArchFamily == sys.AMD64 && frame.argp-frame.varp == 2*sys.PtrSize {
 		if stackDebug >= 3 {
 			print("      saved bp\n")
 		}
@@ -1245,7 +1245,7 @@ func getStackMap(frame *stkframe, cache *pcvalueCache, debug bool) (locals, args
 	var minsize uintptr
 	switch sys.ArchFamily {
 	case sys.ARM64:
-		minsize = sys.SpAlign
+		minsize = sys.StackAlign
 	default:
 		minsize = sys.MinFrameSize
 	}
diff --git a/src/runtime/sys_wasm.go b/src/runtime/sys_wasm.go
index 9bf710ba0e..3ed621f92e 100644
--- a/src/runtime/sys_wasm.go
+++ b/src/runtime/sys_wasm.go
@@ -30,10 +30,6 @@ func wasmExit(code int32)
 // and then did an immediate gosave.
 func gostartcall(buf *gobuf, fn, ctxt unsafe.Pointer) {
 	sp := buf.sp
-	if sys.RegSize > sys.PtrSize {
-		sp -= sys.PtrSize
-		*(*uintptr)(unsafe.Pointer(sp)) = 0
-	}
 	sp -= sys.PtrSize
 	*(*uintptr)(unsafe.Pointer(sp)) = buf.pc
 	buf.sp = sp
diff --git a/src/runtime/sys_x86.go b/src/runtime/sys_x86.go
index f917cb8bd7..5b7a666679 100644
--- a/src/runtime/sys_x86.go
+++ b/src/runtime/sys_x86.go
@@ -15,10 +15,6 @@ import (
 // and then did an immediate gosave.
 func gostartcall(buf *gobuf, fn, ctxt unsafe.Pointer) {
 	sp := buf.sp
-	if sys.RegSize > sys.PtrSize {
-		sp -= sys.PtrSize
-		*(*uintptr)(unsafe.Pointer(sp)) = 0
-	}
 	sp -= sys.PtrSize
 	*(*uintptr)(unsafe.Pointer(sp)) = buf.pc
 	buf.sp = sp
diff --git a/src/runtime/traceback.go b/src/runtime/traceback.go
index 2601cd697f..127f54e42e 100644
--- a/src/runtime/traceback.go
+++ b/src/runtime/traceback.go
@@ -144,8 +144,8 @@ func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max in
 			frame.pc = *(*uintptr)(unsafe.Pointer(frame.sp))
 			frame.lr = 0
 		} else {
-			frame.pc = uintptr(*(*sys.Uintreg)(unsafe.Pointer(frame.sp)))
-			frame.sp += sys.RegSize
+			frame.pc = uintptr(*(*uintptr)(unsafe.Pointer(frame.sp)))
+			frame.sp += sys.PtrSize
 		}
 	}
 
@@ -208,7 +208,7 @@ func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max in
 			frame.fp = frame.sp + uintptr(funcspdelta(f, frame.pc, &cache))
 			if !usesLR {
 				// On x86, call instruction pushes return PC before entering new function.
-				frame.fp += sys.RegSize
+				frame.fp += sys.PtrSize
 			}
 		}
 		var flr funcInfo
@@ -235,8 +235,8 @@ func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max in
 				}
 			} else {
 				if frame.lr == 0 {
-					lrPtr = frame.fp - sys.RegSize
-					frame.lr = uintptr(*(*sys.Uintreg)(unsafe.Pointer(lrPtr)))
+					lrPtr = frame.fp - sys.PtrSize
+					frame.lr = uintptr(*(*uintptr)(unsafe.Pointer(lrPtr)))
 				}
 			}
 			flr = findfunc(frame.lr)
@@ -266,13 +266,13 @@ func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max in
 		frame.varp = frame.fp
 		if !usesLR {
 			// On x86, call instruction pushes return PC before entering new function.
-			frame.varp -= sys.RegSize
+			frame.varp -= sys.PtrSize
 		}
 
 		// For architectures with frame pointers, if there's
 		// a frame, then there's a saved frame pointer here.
 		if frame.varp > frame.sp && (GOARCH == "amd64" || GOARCH == "arm64") {
-			frame.varp -= sys.RegSize
+			frame.varp -= sys.PtrSize
 		}
 
 		// Derive size of arguments.
@@ -490,11 +490,7 @@ func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max in
 		// before faking a call.
 		if usesLR && injectedCall {
 			x := *(*uintptr)(unsafe.Pointer(frame.sp))
-			frame.sp += sys.MinFrameSize
-			if GOARCH == "arm64" {
-				// arm64 needs 16-byte aligned SP, always
-				frame.sp += sys.PtrSize
-			}
+			frame.sp += alignUp(sys.MinFrameSize, sys.StackAlign)
 			f = findfunc(frame.pc)
 			frame.fn = f
 			if !f.valid() {
-- 
GitLab


From a78879ac67d62c4919492fcb5e05c8b21058217d Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Jan 2021 10:47:38 -0500
Subject: [PATCH 0686/2400] runtime: move sys.DefaultGoroot to
 runtime.defaultGOROOT

The default GOROOT has nothing to do with system details.
Move it next to its one use in package runtime.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.
This CL is, however, not windows/arm64-specific.
It is cleanup meant to make the port (and future ports) easier.

Change-Id: I1a601fad6335336b4616b834bb21bd8437ee1313
Reviewed-on: https://go-review.googlesource.com/c/go/+/288796
Trust: Russ Cox <rsc@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
---
 src/cmd/link/internal/ld/main.go | 2 +-
 src/runtime/extern.go            | 4 +++-
 src/runtime/internal/sys/arch.go | 4 ----
 3 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/cmd/link/internal/ld/main.go b/src/cmd/link/internal/ld/main.go
index cbd811846b..68dee18598 100644
--- a/src/cmd/link/internal/ld/main.go
+++ b/src/cmd/link/internal/ld/main.go
@@ -116,7 +116,7 @@ func Main(arch *sys.Arch, theArch Arch) {
 	}
 
 	final := gorootFinal()
-	addstrdata1(ctxt, "runtime/internal/sys.DefaultGoroot="+final)
+	addstrdata1(ctxt, "runtime.defaultGOROOT="+final)
 	addstrdata1(ctxt, "cmd/internal/objabi.defaultGOROOT="+final)
 
 	// TODO(matloob): define these above and then check flag values here
diff --git a/src/runtime/extern.go b/src/runtime/extern.go
index dacdf4f383..bbe41dd0d4 100644
--- a/src/runtime/extern.go
+++ b/src/runtime/extern.go
@@ -229,6 +229,8 @@ func Callers(skip int, pc []uintptr) int {
 	return callers(skip, pc)
 }
 
+var defaultGOROOT string // set by cmd/link
+
 // GOROOT returns the root of the Go tree. It uses the
 // GOROOT environment variable, if set at process start,
 // or else the root used during the Go build.
@@ -237,7 +239,7 @@ func GOROOT() string {
 	if s != "" {
 		return s
 	}
-	return sys.DefaultGoroot
+	return defaultGOROOT
 }
 
 // Version returns the Go tree's version string.
diff --git a/src/runtime/internal/sys/arch.go b/src/runtime/internal/sys/arch.go
index 69278bf2d5..3c99a2f7da 100644
--- a/src/runtime/internal/sys/arch.go
+++ b/src/runtime/internal/sys/arch.go
@@ -52,7 +52,3 @@ const MinFrameSize = _MinFrameSize
 // StackAlign is the required alignment of the SP register.
 // The stack must be at least word aligned, but some architectures require more.
 const StackAlign = _StackAlign
-
-// DefaultGoroot is set by the linker for use by package runtime.
-// It doesn't really belong in this file or this package.
-var DefaultGoroot string
-- 
GitLab


From c80da0a33a240469892a0b0713f09607efb28752 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Jan 2021 11:00:21 -0500
Subject: [PATCH 0687/2400] runtime: handle nil gp in cpuprof

This can happen on Windows when recording profile samples for system threads.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.
This CL is, however, not windows/arm64-specific.
It is cleanup meant to make the port (and future ports) easier.

Change-Id: I5a7ba32b1900a69f3b7acada9cb6cf8396d8a03f
Reviewed-on: https://go-review.googlesource.com/c/go/+/288797
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/runtime/cpuprof.go | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/runtime/cpuprof.go b/src/runtime/cpuprof.go
index 9bfdfe7c74..e5d0193b9c 100644
--- a/src/runtime/cpuprof.go
+++ b/src/runtime/cpuprof.go
@@ -103,7 +103,16 @@ func (p *cpuProfile) add(gp *g, stk []uintptr) {
 		// because otherwise its write barrier behavior may not
 		// be correct. See the long comment there before
 		// changing the argument here.
-		cpuprof.log.write(&gp.labels, nanotime(), hdr[:], stk)
+		//
+		// Note: it can happen on Windows, where we are calling
+		// p.add with a gp that is not the current g, that gp is nil,
+		// meaning we interrupted a system thread with no g.
+		// Avoid faulting in that case.
+		var tagPtr *unsafe.Pointer
+		if gp != nil {
+			tagPtr = &gp.labels
+		}
+		cpuprof.log.write(tagPtr, nanotime(), hdr[:], stk)
 	}
 
 	atomic.Store(&prof.signalLock, 0)
-- 
GitLab


From 229695a2833ead7bbee53071f52f34e2ce1c2802 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 28 Jan 2021 09:32:55 -0500
Subject: [PATCH 0688/2400] runtime: clean up funcID assignment

Large enum sets should be sorted by name when the
values don't matter, as they don't here. Do that.

Also replace the large switch with a map lookup.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.
This CL is, however, not windows/arm64-specific.
It is cleanup meant to make the port (and future ports) easier.

Change-Id: Ibe727b5d8866bf4c40c96020e1f4632bde7efd59
Reviewed-on: https://go-review.googlesource.com/c/go/+/288798
Trust: Russ Cox <rsc@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/cmd/internal/objabi/funcid.go | 113 +++++++++++++-----------------
 src/runtime/symtab.go             |  26 +++----
 2 files changed, 61 insertions(+), 78 deletions(-)

diff --git a/src/cmd/internal/objabi/funcid.go b/src/cmd/internal/objabi/funcid.go
index 1d098ee172..e921a82c0c 100644
--- a/src/cmd/internal/objabi/funcid.go
+++ b/src/cmd/internal/objabi/funcid.go
@@ -4,6 +4,8 @@
 
 package objabi
 
+import "strings"
+
 // A FuncID identifies particular functions that need to be treated
 // specially by the runtime.
 // Note that in some situations involving plugins, there may be multiple
@@ -13,88 +15,69 @@ type FuncID uint8
 
 const (
 	FuncID_normal FuncID = iota // not a special function
-	FuncID_runtime_main
+	FuncID_asmcgocall
+	FuncID_asyncPreempt
+	FuncID_cgocallback
+	FuncID_debugCallV1
+	FuncID_externalthreadhandler
+	FuncID_gcBgMarkWorker
 	FuncID_goexit
+	FuncID_gogo
+	FuncID_gopanic
+	FuncID_handleAsyncEvent
 	FuncID_jmpdefer
 	FuncID_mcall
 	FuncID_morestack
 	FuncID_mstart
+	FuncID_panicwrap
 	FuncID_rt0_go
-	FuncID_asmcgocall
-	FuncID_sigpanic
 	FuncID_runfinq
-	FuncID_gcBgMarkWorker
-	FuncID_systemstack_switch
+	FuncID_runtime_main
+	FuncID_sigpanic
 	FuncID_systemstack
-	FuncID_cgocallback
-	FuncID_gogo
-	FuncID_externalthreadhandler
-	FuncID_debugCallV1
-	FuncID_gopanic
-	FuncID_panicwrap
-	FuncID_handleAsyncEvent
-	FuncID_asyncPreempt
+	FuncID_systemstack_switch
 	FuncID_wrapper // any autogenerated code (hash/eq algorithms, method wrappers, etc.)
 )
 
+var funcIDs = map[string]FuncID{
+	"asmcgocall":            FuncID_asmcgocall,
+	"asyncPreempt":          FuncID_asyncPreempt,
+	"cgocallback":           FuncID_cgocallback,
+	"debugCallV1":           FuncID_debugCallV1,
+	"externalthreadhandler": FuncID_externalthreadhandler,
+	"gcBgMarkWorker":        FuncID_gcBgMarkWorker,
+	"go":                    FuncID_rt0_go,
+	"goexit":                FuncID_goexit,
+	"gogo":                  FuncID_gogo,
+	"gopanic":               FuncID_gopanic,
+	"handleAsyncEvent":      FuncID_handleAsyncEvent,
+	"jmpdefer":              FuncID_jmpdefer,
+	"main":                  FuncID_runtime_main,
+	"mcall":                 FuncID_mcall,
+	"morestack":             FuncID_morestack,
+	"mstart":                FuncID_mstart,
+	"panicwrap":             FuncID_panicwrap,
+	"runfinq":               FuncID_runfinq,
+	"sigpanic":              FuncID_sigpanic,
+	"switch":                FuncID_systemstack_switch,
+	"systemstack":           FuncID_systemstack,
+
+	// Don't show in call stack but otherwise not special.
+	"deferreturn":       FuncID_wrapper,
+	"runOpenDeferFrame": FuncID_wrapper,
+	"reflectcallSave":   FuncID_wrapper,
+}
+
 // Get the function ID for the named function in the named file.
 // The function should be package-qualified.
 func GetFuncID(name string, isWrapper bool) FuncID {
 	if isWrapper {
 		return FuncID_wrapper
 	}
-	switch name {
-	case "runtime.main":
-		return FuncID_runtime_main
-	case "runtime.goexit":
-		return FuncID_goexit
-	case "runtime.jmpdefer":
-		return FuncID_jmpdefer
-	case "runtime.mcall":
-		return FuncID_mcall
-	case "runtime.morestack":
-		return FuncID_morestack
-	case "runtime.mstart":
-		return FuncID_mstart
-	case "runtime.rt0_go":
-		return FuncID_rt0_go
-	case "runtime.asmcgocall":
-		return FuncID_asmcgocall
-	case "runtime.sigpanic":
-		return FuncID_sigpanic
-	case "runtime.runfinq":
-		return FuncID_runfinq
-	case "runtime.gcBgMarkWorker":
-		return FuncID_gcBgMarkWorker
-	case "runtime.systemstack_switch":
-		return FuncID_systemstack_switch
-	case "runtime.systemstack":
-		return FuncID_systemstack
-	case "runtime.cgocallback":
-		return FuncID_cgocallback
-	case "runtime.gogo":
-		return FuncID_gogo
-	case "runtime.externalthreadhandler":
-		return FuncID_externalthreadhandler
-	case "runtime.debugCallV1":
-		return FuncID_debugCallV1
-	case "runtime.gopanic":
-		return FuncID_gopanic
-	case "runtime.panicwrap":
-		return FuncID_panicwrap
-	case "runtime.handleAsyncEvent":
-		return FuncID_handleAsyncEvent
-	case "runtime.asyncPreempt":
-		return FuncID_asyncPreempt
-	case "runtime.deferreturn":
-		// Don't show in the call stack (used when invoking defer functions)
-		return FuncID_wrapper
-	case "runtime.runOpenDeferFrame":
-		// Don't show in the call stack (used when invoking defer functions)
-		return FuncID_wrapper
-	case "runtime.reflectcallSave":
-		// Don't show in the call stack (used when invoking defer functions)
-		return FuncID_wrapper
+	if strings.HasPrefix(name, "runtime.") {
+		if id, ok := funcIDs[name[len("runtime."):]]; ok {
+			return id
+		}
 	}
 	return FuncID_normal
 }
diff --git a/src/runtime/symtab.go b/src/runtime/symtab.go
index 7667f23f1d..fc93c00c2d 100644
--- a/src/runtime/symtab.go
+++ b/src/runtime/symtab.go
@@ -308,27 +308,27 @@ type funcID uint8
 
 const (
 	funcID_normal funcID = iota // not a special function
-	funcID_runtime_main
+	funcID_asmcgocall
+	funcID_asyncPreempt
+	funcID_cgocallback
+	funcID_debugCallV1
+	funcID_externalthreadhandler
+	funcID_gcBgMarkWorker
 	funcID_goexit
+	funcID_gogo
+	funcID_gopanic
+	funcID_handleAsyncEvent
 	funcID_jmpdefer
 	funcID_mcall
 	funcID_morestack
 	funcID_mstart
+	funcID_panicwrap
 	funcID_rt0_go
-	funcID_asmcgocall
-	funcID_sigpanic
 	funcID_runfinq
-	funcID_gcBgMarkWorker
-	funcID_systemstack_switch
+	funcID_runtime_main
+	funcID_sigpanic
 	funcID_systemstack
-	funcID_cgocallback
-	funcID_gogo
-	funcID_externalthreadhandler
-	funcID_debugCallV1
-	funcID_gopanic
-	funcID_panicwrap
-	funcID_handleAsyncEvent
-	funcID_asyncPreempt
+	funcID_systemstack_switch
 	funcID_wrapper // any autogenerated code (hash/eq algorithms, method wrappers, etc.)
 )
 
-- 
GitLab


From 01f05d8ff1a88c4a63bdaaff5a095a92ce476f58 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 1 Feb 2021 22:58:28 -0500
Subject: [PATCH 0689/2400] runtime: unify asmcgocall and systemstack traceback
 setup

Both asmcgocall and systemstack need to save the calling Go code's
context for use by traceback, but they do it differently.
Systemstack's appraoch is better, because it doesn't require a
special case in traceback.
So make them both use that.

While we are here, the fake mstart caller in systemstack is
no longer needed and can be removed.
(traceback knows to stop in systemstack because of the writes to SP.)

Also remove the fake mstarts in sys_windows_*.s.

And while we are there, fix the control flow guard code in sys_windows_arm.s.
The current code is using pointers to a stack frame that technically is gone
once we hit the RET instruction. Clearly it's working OK, but better not to depend
on data below SP being preserved, even for just a few instructions.
Store the value we need in other registers instead.
(This code is only used for pushing a sigpanic call, which does not
actually return to the site of the fault and therefore doesn't need to
preserve any of the registers.)

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.
This CL is, however, not windows/arm64-specific.
It is cleanup meant to make the port (and future ports) easier.

Change-Id: Id1e3ef5e54f7ad786e4b87043f2626eba7c3bbd9
Reviewed-on: https://go-review.googlesource.com/c/go/+/288799
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 misc/cgo/test/callback.go       |  2 +-
 src/runtime/asm_386.s           | 19 ++++++-------
 src/runtime/asm_amd64.s         | 22 ++++++---------
 src/runtime/asm_arm.s           | 34 ++++++++++------------
 src/runtime/asm_arm64.s         | 31 +++++++++-----------
 src/runtime/asm_mips64x.s       | 26 ++++++++---------
 src/runtime/asm_mipsx.s         | 26 ++++++++---------
 src/runtime/asm_ppc64x.s        | 28 ++++++++----------
 src/runtime/asm_riscv64.s       | 26 ++++++++---------
 src/runtime/asm_s390x.s         | 29 +++++++++----------
 src/runtime/sys_windows_386.s   | 12 +++-----
 src/runtime/sys_windows_amd64.s | 12 ++------
 src/runtime/sys_windows_arm.s   | 50 +++++++++++++++------------------
 13 files changed, 137 insertions(+), 180 deletions(-)

diff --git a/misc/cgo/test/callback.go b/misc/cgo/test/callback.go
index 814888e3ac..08dd9b39d8 100644
--- a/misc/cgo/test/callback.go
+++ b/misc/cgo/test/callback.go
@@ -182,7 +182,7 @@ func testCallbackCallers(t *testing.T) {
 		"runtime.cgocallbackg1",
 		"runtime.cgocallbackg",
 		"runtime.cgocallback",
-		"runtime.asmcgocall",
+		"runtime.systemstack_switch",
 		"runtime.cgocall",
 		"test._Cfunc_callback",
 		"test.nestedCall.func1",
diff --git a/src/runtime/asm_386.s b/src/runtime/asm_386.s
index 3030101f03..a59054226c 100644
--- a/src/runtime/asm_386.s
+++ b/src/runtime/asm_386.s
@@ -352,18 +352,12 @@ TEXT runtime·systemstack(SB), NOSPLIT, $0-4
 	// switch stacks
 	// save our state in g->sched. Pretend to
 	// be systemstack_switch if the G stack is scanned.
-	MOVL	$runtime·systemstack_switch(SB), (g_sched+gobuf_pc)(AX)
-	MOVL	SP, (g_sched+gobuf_sp)(AX)
-	MOVL	AX, (g_sched+gobuf_g)(AX)
+	CALL	gosave_systemstack_switch<>(SB)
 
 	// switch to g0
 	get_tls(CX)
 	MOVL	DX, g(CX)
 	MOVL	(g_sched+gobuf_sp)(DX), BX
-	// make it look like mstart called systemstack on g0, to stop traceback
-	SUBL	$4, BX
-	MOVL	$runtime·mstart(SB), DX
-	MOVL	DX, 0(BX)
 	MOVL	BX, SP
 
 	// call target function
@@ -601,15 +595,18 @@ TEXT runtime·jmpdefer(SB), NOSPLIT, $0-8
 	MOVL	0(DX), BX
 	JMP	BX	// but first run the deferred function
 
-// Save state of caller into g->sched.
-TEXT gosave<>(SB),NOSPLIT,$0
+// Save state of caller into g->sched,
+// but using fake PC from systemstack_switch.
+// Must only be called from functions with no locals ($0)
+// or else unwinding from systemstack_switch is incorrect.
+TEXT gosave_systemstack_switch<>(SB),NOSPLIT,$0
 	PUSHL	AX
 	PUSHL	BX
 	get_tls(BX)
 	MOVL	g(BX), BX
 	LEAL	arg+0(FP), AX
 	MOVL	AX, (g_sched+gobuf_sp)(BX)
-	MOVL	-4(AX), AX
+	MOVL	$runtime·systemstack_switch(SB), AX
 	MOVL	AX, (g_sched+gobuf_pc)(BX)
 	MOVL	$0, (g_sched+gobuf_ret)(BX)
 	// Assert ctxt is zero. See func save.
@@ -661,7 +658,7 @@ TEXT ·asmcgocall(SB),NOSPLIT,$0-12
 	JEQ	noswitch
 	CMPL	DI, m_gsignal(BP)
 	JEQ	noswitch
-	CALL	gosave<>(SB)
+	CALL	gosave_systemstack_switch<>(SB)
 	get_tls(CX)
 	MOVL	SI, g(CX)
 	MOVL	(g_sched+gobuf_sp)(SI), SP
diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index 9362ce1213..cd5ce3effb 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -338,20 +338,12 @@ TEXT runtime·systemstack(SB), NOSPLIT, $0-8
 	// switch stacks
 	// save our state in g->sched. Pretend to
 	// be systemstack_switch if the G stack is scanned.
-	MOVQ	$runtime·systemstack_switch(SB), SI
-	MOVQ	SI, (g_sched+gobuf_pc)(AX)
-	MOVQ	SP, (g_sched+gobuf_sp)(AX)
-	MOVQ	AX, (g_sched+gobuf_g)(AX)
-	MOVQ	BP, (g_sched+gobuf_bp)(AX)
+	CALL	gosave_systemstack_switch<>(SB)
 
 	// switch to g0
 	MOVQ	DX, g(CX)
 	MOVQ	DX, R14 // set the g register
 	MOVQ	(g_sched+gobuf_sp)(DX), BX
-	// make it look like mstart called systemstack on g0, to stop traceback
-	SUBQ	$8, BX
-	MOVQ	$runtime·mstart(SB), DX
-	MOVQ	DX, 0(BX)
 	MOVQ	BX, SP
 
 	// call target function
@@ -660,13 +652,17 @@ TEXT runtime·jmpdefer(SB), NOSPLIT, $0-16
 	MOVQ	0(DX), BX
 	JMP	BX	// but first run the deferred function
 
-// Save state of caller into g->sched. Smashes R9.
-TEXT gosave<>(SB),NOSPLIT,$0
+// Save state of caller into g->sched,
+// but using fake PC from systemstack_switch.
+// Must only be called from functions with no locals ($0)
+// or else unwinding from systemstack_switch is incorrect.
+// Smashes R9.
+TEXT gosave_systemstack_switch<>(SB),NOSPLIT,$0
 #ifndef GOEXPERIMENT_REGABI
 	get_tls(R14)
 	MOVQ	g(R14), R14
 #endif
-	MOVQ	0(SP), R9
+	MOVQ	$runtime·systemstack_switch(SB), R9
 	MOVQ	R9, (g_sched+gobuf_pc)(R14)
 	LEAQ	8(SP), R9
 	MOVQ	R9, (g_sched+gobuf_sp)(R14)
@@ -724,7 +720,7 @@ TEXT ·asmcgocall(SB),NOSPLIT,$0-20
 
 	// Switch to system stack.
 	MOVQ	m_g0(R8), SI
-	CALL	gosave<>(SB)
+	CALL	gosave_systemstack_switch<>(SB)
 	MOVQ	SI, g(CX)
 	MOVQ	(g_sched+gobuf_sp)(SI), SP
 
diff --git a/src/runtime/asm_arm.s b/src/runtime/asm_arm.s
index 109030aada..c8c53e70db 100644
--- a/src/runtime/asm_arm.s
+++ b/src/runtime/asm_arm.s
@@ -305,24 +305,14 @@ TEXT runtime·systemstack(SB),NOSPLIT,$0-4
 switch:
 	// save our state in g->sched. Pretend to
 	// be systemstack_switch if the G stack is scanned.
-	MOVW	$runtime·systemstack_switch(SB), R3
-	ADD	$4, R3, R3 // get past push {lr}
-	MOVW	R3, (g_sched+gobuf_pc)(g)
-	MOVW	R13, (g_sched+gobuf_sp)(g)
-	MOVW	LR, (g_sched+gobuf_lr)(g)
-	MOVW	g, (g_sched+gobuf_g)(g)
+	BL	gosave_systemstack_switch<>(SB)
 
 	// switch to g0
 	MOVW	R0, R5
 	MOVW	R2, R0
 	BL	setg<>(SB)
 	MOVW	R5, R0
-	MOVW	(g_sched+gobuf_sp)(R2), R3
-	// make it look like mstart called systemstack on g0, to stop traceback
-	SUB	$4, R3, R3
-	MOVW	$runtime·mstart(SB), R4
-	MOVW	R4, 0(R3)
-	MOVW	R3, R13
+	MOVW	(g_sched+gobuf_sp)(R2), R13
 
 	// call target function
 	MOVW	R0, R7
@@ -537,19 +527,25 @@ TEXT runtime·jmpdefer(SB),NOSPLIT,$0-8
 	MOVW	0(R7), R1
 	B	(R1)
 
-// Save state of caller into g->sched. Smashes R11.
-TEXT gosave<>(SB),NOSPLIT|NOFRAME,$0
-	MOVW	LR, (g_sched+gobuf_pc)(g)
+// Save state of caller into g->sched,
+// but using fake PC from systemstack_switch.
+// Must only be called from functions with no locals ($0)
+// or else unwinding from systemstack_switch is incorrect.
+// Smashes R11.
+TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
+	MOVW	$runtime·systemstack_switch(SB), R11
+	ADD	$4, R11 // get past push {lr}
+	MOVW	R11, (g_sched+gobuf_pc)(g)
 	MOVW	R13, (g_sched+gobuf_sp)(g)
+	MOVW	g, (g_sched+gobuf_g)(g)
 	MOVW	$0, R11
 	MOVW	R11, (g_sched+gobuf_lr)(g)
 	MOVW	R11, (g_sched+gobuf_ret)(g)
-	MOVW	R11, (g_sched+gobuf_ctxt)(g)
 	// Assert ctxt is zero. See func save.
 	MOVW	(g_sched+gobuf_ctxt)(g), R11
-	CMP	$0, R11
+	TST	R11, R11
 	B.EQ	2(PC)
-	CALL	runtime·badctxt(SB)
+	BL	runtime·badctxt(SB)
 	RET
 
 // func asmcgocall_no_g(fn, arg unsafe.Pointer)
@@ -590,7 +586,7 @@ TEXT ·asmcgocall(SB),NOSPLIT,$0-12
 	MOVW	m_g0(R8), R3
 	CMP	R3, g
 	BEQ	nosave
-	BL	gosave<>(SB)
+	BL	gosave_systemstack_switch<>(SB)
 	MOVW	R0, R5
 	MOVW	R3, R0
 	BL	setg<>(SB)
diff --git a/src/runtime/asm_arm64.s b/src/runtime/asm_arm64.s
index 79efd4cb17..31a6fe57b9 100644
--- a/src/runtime/asm_arm64.s
+++ b/src/runtime/asm_arm64.s
@@ -205,24 +205,12 @@ TEXT runtime·systemstack(SB), NOSPLIT, $0-8
 switch:
 	// save our state in g->sched. Pretend to
 	// be systemstack_switch if the G stack is scanned.
-	MOVD	$runtime·systemstack_switch(SB), R6
-	ADD	$8, R6	// get past prologue
-	MOVD	R6, (g_sched+gobuf_pc)(g)
-	MOVD	RSP, R0
-	MOVD	R0, (g_sched+gobuf_sp)(g)
-	MOVD	R29, (g_sched+gobuf_bp)(g)
-	MOVD	$0, (g_sched+gobuf_lr)(g)
-	MOVD	g, (g_sched+gobuf_g)(g)
+	BL	gosave_systemstack_switch<>(SB)
 
 	// switch to g0
 	MOVD	R5, g
 	BL	runtime·save_g(SB)
 	MOVD	(g_sched+gobuf_sp)(g), R3
-	// make it look like mstart called systemstack on g0, to stop traceback
-	SUB	$16, R3
-	AND	$~15, R3
-	MOVD	$runtime·mstart(SB), R4
-	MOVD	R4, 0(R3)
 	MOVD	R3, RSP
 	MOVD	(g_sched+gobuf_bp)(g), R29
 
@@ -859,14 +847,21 @@ TEXT runtime·jmpdefer(SB), NOSPLIT|NOFRAME, $0-16
 	MOVD	0(R26), R3
 	B	(R3)
 
-// Save state of caller into g->sched. Smashes R0.
-TEXT gosave<>(SB),NOSPLIT|NOFRAME,$0
-	MOVD	LR, (g_sched+gobuf_pc)(g)
+// Save state of caller into g->sched,
+// but using fake PC from systemstack_switch.
+// Must only be called from functions with no locals ($0)
+// or else unwinding from systemstack_switch is incorrect.
+// Smashes R0.
+TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
+	MOVD	$runtime·systemstack_switch(SB), R0
+	ADD	$8, R0	// get past prologue
+	MOVD	R0, (g_sched+gobuf_pc)(g)
 	MOVD	RSP, R0
 	MOVD	R0, (g_sched+gobuf_sp)(g)
 	MOVD	R29, (g_sched+gobuf_bp)(g)
 	MOVD	$0, (g_sched+gobuf_lr)(g)
 	MOVD	$0, (g_sched+gobuf_ret)(g)
+	MOVD	g, (g_sched+gobuf_g)(g)
 	// Assert ctxt is zero. See func save.
 	MOVD	(g_sched+gobuf_ctxt)(g), R0
 	CBZ	R0, 2(PC)
@@ -908,8 +903,8 @@ TEXT ·asmcgocall(SB),NOSPLIT,$0-20
 	BEQ	nosave
 
 	// Switch to system stack.
-	MOVD	R0, R9	// gosave<> and save_g might clobber R0
-	BL	gosave<>(SB)
+	MOVD	R0, R9	// gosave_systemstack_switch<> and save_g might clobber R0
+	BL	gosave_systemstack_switch<>(SB)
 	MOVD	R3, g
 	BL	runtime·save_g(SB)
 	MOVD	(g_sched+gobuf_sp)(g), R0
diff --git a/src/runtime/asm_mips64x.s b/src/runtime/asm_mips64x.s
index 6e1d25cd90..75bb223066 100644
--- a/src/runtime/asm_mips64x.s
+++ b/src/runtime/asm_mips64x.s
@@ -169,21 +169,12 @@ TEXT runtime·systemstack(SB), NOSPLIT, $0-8
 switch:
 	// save our state in g->sched. Pretend to
 	// be systemstack_switch if the G stack is scanned.
-	MOVV	$runtime·systemstack_switch(SB), R4
-	ADDV	$8, R4	// get past prologue
-	MOVV	R4, (g_sched+gobuf_pc)(g)
-	MOVV	R29, (g_sched+gobuf_sp)(g)
-	MOVV	R0, (g_sched+gobuf_lr)(g)
-	MOVV	g, (g_sched+gobuf_g)(g)
+	JAL	gosave_systemstack_switch<>(SB)
 
 	// switch to g0
 	MOVV	R3, g
 	JAL	runtime·save_g(SB)
 	MOVV	(g_sched+gobuf_sp)(g), R1
-	// make it look like mstart called systemstack on g0, to stop traceback
-	ADDV	$-8, R1
-	MOVV	$runtime·mstart(SB), R2
-	MOVV	R2, 0(R1)
 	MOVV	R1, R29
 
 	// call target function
@@ -401,12 +392,19 @@ TEXT runtime·jmpdefer(SB), NOSPLIT|NOFRAME, $0-16
 	MOVV	0(REGCTXT), R4
 	JMP	(R4)
 
-// Save state of caller into g->sched. Smashes R1.
-TEXT gosave<>(SB),NOSPLIT|NOFRAME,$0
-	MOVV	R31, (g_sched+gobuf_pc)(g)
+// Save state of caller into g->sched,
+// but using fake PC from systemstack_switch.
+// Must only be called from functions with no locals ($0)
+// or else unwinding from systemstack_switch is incorrect.
+// Smashes R1.
+TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
+	MOVV	$runtime·systemstack_switch(SB), R1
+	ADDV	$8, R1	// get past prologue
+	MOVV	R1, (g_sched+gobuf_pc)(g)
 	MOVV	R29, (g_sched+gobuf_sp)(g)
 	MOVV	R0, (g_sched+gobuf_lr)(g)
 	MOVV	R0, (g_sched+gobuf_ret)(g)
+	MOVV	g, (g_sched+gobuf_g)(g)
 	// Assert ctxt is zero. See func save.
 	MOVV	(g_sched+gobuf_ctxt)(g), R1
 	BEQ	R1, 2(PC)
@@ -440,7 +438,7 @@ TEXT ·asmcgocall(SB),NOSPLIT,$0-20
 	MOVV	m_g0(R5), R6
 	BEQ	R6, g, g0
 
-	JAL	gosave<>(SB)
+	JAL	gosave_systemstack_switch<>(SB)
 	MOVV	R6, g
 	JAL	runtime·save_g(SB)
 	MOVV	(g_sched+gobuf_sp)(g), R29
diff --git a/src/runtime/asm_mipsx.s b/src/runtime/asm_mipsx.s
index 8e5753d255..341da8e8d7 100644
--- a/src/runtime/asm_mipsx.s
+++ b/src/runtime/asm_mipsx.s
@@ -170,21 +170,12 @@ TEXT runtime·systemstack(SB),NOSPLIT,$0-4
 switch:
 	// save our state in g->sched.  Pretend to
 	// be systemstack_switch if the G stack is scanned.
-	MOVW	$runtime·systemstack_switch(SB), R4
-	ADDU	$8, R4	// get past prologue
-	MOVW	R4, (g_sched+gobuf_pc)(g)
-	MOVW	R29, (g_sched+gobuf_sp)(g)
-	MOVW	R0, (g_sched+gobuf_lr)(g)
-	MOVW	g, (g_sched+gobuf_g)(g)
+	JAL	gosave_systemstack_switch<>(SB)
 
 	// switch to g0
 	MOVW	R3, g
 	JAL	runtime·save_g(SB)
 	MOVW	(g_sched+gobuf_sp)(g), R1
-	// make it look like mstart called systemstack on g0, to stop traceback
-	ADDU	$-4, R1
-	MOVW	$runtime·mstart(SB), R2
-	MOVW	R2, 0(R1)
 	MOVW	R1, R29
 
 	// call target function
@@ -401,12 +392,19 @@ TEXT runtime·jmpdefer(SB),NOSPLIT,$0-8
 	MOVW	0(REGCTXT), R4
 	JMP	(R4)
 
-// Save state of caller into g->sched. Smashes R1.
-TEXT gosave<>(SB),NOSPLIT|NOFRAME,$0
-	MOVW	R31, (g_sched+gobuf_pc)(g)
+// Save state of caller into g->sched,
+// but using fake PC from systemstack_switch.
+// Must only be called from functions with no locals ($0)
+// or else unwinding from systemstack_switch is incorrect.
+// Smashes R1.
+TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
+	MOVW	$runtime·systemstack_switch(SB), R1
+	ADDU	$8, R1	// get past prologue
+	MOVW	R1, (g_sched+gobuf_pc)(g)
 	MOVW	R29, (g_sched+gobuf_sp)(g)
 	MOVW	R0, (g_sched+gobuf_lr)(g)
 	MOVW	R0, (g_sched+gobuf_ret)(g)
+	MOVW	g, (g_sched+gobuf_g)(g)
 	// Assert ctxt is zero. See func save.
 	MOVW	(g_sched+gobuf_ctxt)(g), R1
 	BEQ	R1, 2(PC)
@@ -431,7 +429,7 @@ TEXT ·asmcgocall(SB),NOSPLIT,$0-12
 	MOVW	m_g0(R5), R6
 	BEQ	R6, g, g0
 
-	JAL	gosave<>(SB)
+	JAL	gosave_systemstack_switch<>(SB)
 	MOVW	R6, g
 	JAL	runtime·save_g(SB)
 	MOVW	(g_sched+gobuf_sp)(g), R29
diff --git a/src/runtime/asm_ppc64x.s b/src/runtime/asm_ppc64x.s
index 834023cce1..a99a61fd88 100644
--- a/src/runtime/asm_ppc64x.s
+++ b/src/runtime/asm_ppc64x.s
@@ -229,22 +229,12 @@ TEXT runtime·systemstack(SB), NOSPLIT, $0-8
 switch:
 	// save our state in g->sched. Pretend to
 	// be systemstack_switch if the G stack is scanned.
-	MOVD	$runtime·systemstack_switch(SB), R6
-	ADD     $16, R6 // get past prologue (including r2-setting instructions when they're there)
-	MOVD	R6, (g_sched+gobuf_pc)(g)
-	MOVD	R1, (g_sched+gobuf_sp)(g)
-	MOVD	R0, (g_sched+gobuf_lr)(g)
-	MOVD	g, (g_sched+gobuf_g)(g)
+	BL	gosave_systemstack_switch<>(SB)
 
 	// switch to g0
 	MOVD	R5, g
 	BL	runtime·save_g(SB)
-	MOVD	(g_sched+gobuf_sp)(g), R3
-	// make it look like mstart called systemstack on g0, to stop traceback
-	SUB	$FIXED_FRAME, R3
-	MOVD	$runtime·mstart(SB), R4
-	MOVD	R4, 0(R3)
-	MOVD	R3, R1
+	MOVD	(g_sched+gobuf_sp)(g), R1
 
 	// call target function
 	MOVD	0(R11), R12	// code pointer
@@ -534,13 +524,19 @@ TEXT runtime·jmpdefer(SB), NOSPLIT|NOFRAME, $0-16
 	MOVD	R12, CTR
 	BR	(CTR)
 
-// Save state of caller into g->sched. Smashes R31.
-TEXT gosave<>(SB),NOSPLIT|NOFRAME,$0
-	MOVD	LR, R31
+// Save state of caller into g->sched,
+// but using fake PC from systemstack_switch.
+// Must only be called from functions with no locals ($0)
+// or else unwinding from systemstack_switch is incorrect.
+// Smashes R31.
+TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
+	MOVD	$runtime·systemstack_switch(SB), R31
+	ADD     $16, R31 // get past prologue (including r2-setting instructions when they're there)
 	MOVD	R31, (g_sched+gobuf_pc)(g)
 	MOVD	R1, (g_sched+gobuf_sp)(g)
 	MOVD	R0, (g_sched+gobuf_lr)(g)
 	MOVD	R0, (g_sched+gobuf_ret)(g)
+	MOVD	g, (g_sched+gobuf_g)(g)
 	// Assert ctxt is zero. See func save.
 	MOVD	(g_sched+gobuf_ctxt)(g), R31
 	CMP	R0, R31
@@ -577,7 +573,7 @@ TEXT ·asmcgocall(SB),NOSPLIT,$0-20
 	MOVD	m_g0(R8), R6
 	CMP	R6, g
 	BEQ	g0
-	BL	gosave<>(SB)
+	BL	gosave_systemstack_switch<>(SB)
 	MOVD	R6, g
 	BL	runtime·save_g(SB)
 	MOVD	(g_sched+gobuf_sp)(g), R1
diff --git a/src/runtime/asm_riscv64.s b/src/runtime/asm_riscv64.s
index 3d0349471a..fb7c6530dc 100644
--- a/src/runtime/asm_riscv64.s
+++ b/src/runtime/asm_riscv64.s
@@ -114,21 +114,12 @@ TEXT runtime·systemstack(SB), NOSPLIT, $0-8
 switch:
 	// save our state in g->sched. Pretend to
 	// be systemstack_switch if the G stack is scanned.
-	MOV	$runtime·systemstack_switch(SB), T2
-	ADD	$8, T2	// get past prologue
-	MOV	T2, (g_sched+gobuf_pc)(g)
-	MOV	X2, (g_sched+gobuf_sp)(g)
-	MOV	ZERO, (g_sched+gobuf_lr)(g)
-	MOV	g, (g_sched+gobuf_g)(g)
+	CALL	gosave_systemstack_switch<>(SB)
 
 	// switch to g0
 	MOV	T1, g
 	CALL	runtime·save_g(SB)
 	MOV	(g_sched+gobuf_sp)(g), T0
-	// make it look like mstart called systemstack on g0, to stop traceback
-	ADD	$-8, T0
-	MOV	$runtime·mstart(SB), T1
-	MOV	T1, 0(T0)
 	MOV	T0, X2
 
 	// call target function
@@ -297,12 +288,19 @@ TEXT runtime·mcall(SB), NOSPLIT|NOFRAME, $0-8
 	JALR	RA, T1
 	JMP	runtime·badmcall2(SB)
 
-// Save state of caller into g->sched. Smashes X31.
-TEXT gosave<>(SB),NOSPLIT|NOFRAME,$0
-	MOV	X1, (g_sched+gobuf_pc)(g)
+// Save state of caller into g->sched,
+// but using fake PC from systemstack_switch.
+// Must only be called from functions with no locals ($0)
+// or else unwinding from systemstack_switch is incorrect.
+// Smashes X31.
+TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
+	MOV	$runtime·systemstack_switch(SB), X31
+	ADD	$8, X31	// get past prologue
+	MOV	X31, (g_sched+gobuf_pc)(g)
 	MOV	X2, (g_sched+gobuf_sp)(g)
 	MOV	ZERO, (g_sched+gobuf_lr)(g)
 	MOV	ZERO, (g_sched+gobuf_ret)(g)
+	MOV	g, (g_sched+gobuf_g)(g)
 	// Assert ctxt is zero. See func save.
 	MOV	(g_sched+gobuf_ctxt)(g), X31
 	BEQ	ZERO, X31, 2(PC)
@@ -327,7 +325,7 @@ TEXT ·asmcgocall(SB),NOSPLIT,$0-20
 	MOV	m_g0(X6), X7
 	BEQ	X7, g, g0
 
-	CALL	gosave<>(SB)
+	CALL	gosave_systemstack_switch<>(SB)
 	MOV	X7, g
 	CALL	runtime·save_g(SB)
 	MOV	(g_sched+gobuf_sp)(g), X2
diff --git a/src/runtime/asm_s390x.s b/src/runtime/asm_s390x.s
index fbd185c353..43244d961f 100644
--- a/src/runtime/asm_s390x.s
+++ b/src/runtime/asm_s390x.s
@@ -256,22 +256,12 @@ TEXT runtime·systemstack(SB), NOSPLIT, $0-8
 switch:
 	// save our state in g->sched.  Pretend to
 	// be systemstack_switch if the G stack is scanned.
-	MOVD	$runtime·systemstack_switch(SB), R6
-	ADD	$16, R6	// get past prologue
-	MOVD	R6, (g_sched+gobuf_pc)(g)
-	MOVD	R15, (g_sched+gobuf_sp)(g)
-	MOVD	$0, (g_sched+gobuf_lr)(g)
-	MOVD	g, (g_sched+gobuf_g)(g)
+	BL	gosave_systemstack_switch<>(SB)
 
 	// switch to g0
 	MOVD	R5, g
 	BL	runtime·save_g(SB)
-	MOVD	(g_sched+gobuf_sp)(g), R3
-	// make it look like mstart called systemstack on g0, to stop traceback
-	SUB	$8, R3
-	MOVD	$runtime·mstart(SB), R4
-	MOVD	R4, 0(R3)
-	MOVD	R3, R15
+	MOVD	(g_sched+gobuf_sp)(g), R15
 
 	// call target function
 	MOVD	0(R12), R3	// code pointer
@@ -498,12 +488,19 @@ TEXT runtime·jmpdefer(SB),NOSPLIT|NOFRAME,$0-16
 	MOVD	0(R12), R3
 	BR	(R3)
 
-// Save state of caller into g->sched. Smashes R1.
-TEXT gosave<>(SB),NOSPLIT|NOFRAME,$0
-	MOVD	LR, (g_sched+gobuf_pc)(g)
+// Save state of caller into g->sched,
+// but using fake PC from systemstack_switch.
+// Must only be called from functions with no locals ($0)
+// or else unwinding from systemstack_switch is incorrect.
+// Smashes R1.
+TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
+	MOVD	$runtime·systemstack_switch(SB), R1
+	ADD	$16, R1	// get past prologue
+	MOVD	R1, (g_sched+gobuf_pc)(g)
 	MOVD	R15, (g_sched+gobuf_sp)(g)
 	MOVD	$0, (g_sched+gobuf_lr)(g)
 	MOVD	$0, (g_sched+gobuf_ret)(g)
+	MOVD	g, (g_sched+gobuf_g)(g)
 	// Assert ctxt is zero. See func save.
 	MOVD	(g_sched+gobuf_ctxt)(g), R1
 	CMPBEQ	R1, $0, 2(PC)
@@ -529,7 +526,7 @@ TEXT ·asmcgocall(SB),NOSPLIT,$0-20
 	MOVD	g_m(g), R6
 	MOVD	m_g0(R6), R6
 	CMPBEQ	R6, g, g0
-	BL	gosave<>(SB)
+	BL	gosave_systemstack_switch<>(SB)
 	MOVD	R6, g
 	BL	runtime·save_g(SB)
 	MOVD	(g_sched+gobuf_sp)(g), R15
diff --git a/src/runtime/sys_windows_386.s b/src/runtime/sys_windows_386.s
index c556e3a3c2..576dd28771 100644
--- a/src/runtime/sys_windows_386.s
+++ b/src/runtime/sys_windows_386.s
@@ -94,7 +94,7 @@ TEXT sigtramp<>(SB),NOSPLIT,$0-0
 	JNE	2(PC)
 	CALL	runtime·badsignal2(SB)
 
-	// save g and SP in case of stack switch
+	// save g in case of stack switch
 	MOVL	DX, 32(SP)	// g
 	MOVL	SP, 36(SP)
 
@@ -108,13 +108,9 @@ TEXT sigtramp<>(SB),NOSPLIT,$0-0
 	get_tls(BP)
 	MOVL	BX, g(BP)
 	MOVL	(g_sched+gobuf_sp)(BX), DI
-	// make it look like mstart called us on g0, to stop traceback
-	SUBL	$4, DI
-	MOVL	$runtime·mstart(SB), 0(DI)
-	// traceback will think that we've done SUBL
-	// on this stack, so subtract them here to match.
-	// (we need room for sighandler arguments anyway).
+	// make room for sighandler arguments
 	// and re-save old SP for restoring later.
+	// (note that the 36(DI) here must match the 36(SP) above.)
 	SUBL	$40, DI
 	MOVL	SP, 36(DI)
 	MOVL	DI, SP
@@ -132,7 +128,7 @@ g0:
 	// switch back to original stack and g
 	// no-op if we never left.
 	MOVL	36(SP), SP
-	MOVL	32(SP), DX
+	MOVL	32(SP), DX	// note: different SP
 	get_tls(BP)
 	MOVL	DX, g(BP)
 
diff --git a/src/runtime/sys_windows_amd64.s b/src/runtime/sys_windows_amd64.s
index 9cd14016b0..6f2abb5444 100644
--- a/src/runtime/sys_windows_amd64.s
+++ b/src/runtime/sys_windows_amd64.s
@@ -151,16 +151,10 @@ TEXT sigtramp<>(SB),NOSPLIT|NOFRAME,$0-0
 	get_tls(BP)
 	MOVQ	BX, g(BP)
 	MOVQ	(g_sched+gobuf_sp)(BX), DI
-	// make it look like mstart called us on g0, to stop traceback
-	SUBQ	$8, DI
-	MOVQ	$runtime·mstart(SB), SI
-	MOVQ	SI, 0(DI)
-	// traceback will think that we've done PUSHFQ and SUBQ
-	// on this stack, so subtract them here to match.
-	// (we need room for sighandler arguments anyway).
+	// make room for sighandler arguments
 	// and re-save old SP for restoring later.
-	SUBQ	$(112+8), DI
-	// save g, save old stack pointer.
+	// (note that the 104(DI) here must match the 104(SP) above.)
+	SUBQ	$120, DI
 	MOVQ	SP, 104(DI)
 	MOVQ	DI, SP
 
diff --git a/src/runtime/sys_windows_arm.s b/src/runtime/sys_windows_arm.s
index d2bdc50e3b..7d134dd3f4 100644
--- a/src/runtime/sys_windows_arm.s
+++ b/src/runtime/sys_windows_arm.s
@@ -6,6 +6,8 @@
 #include "go_tls.h"
 #include "textflag.h"
 
+// Note: For system ABI, R0-R3 are args, R4-R11 are callee-save.
+
 // void runtime·asmstdcall(void *c);
 TEXT runtime·asmstdcall(SB),NOSPLIT|NOFRAME,$0
 	MOVM.DB.W [R4, R5, R14], (R13)	// push {r4, r5, lr}
@@ -139,11 +141,10 @@ TEXT sigtramp<>(SB),NOSPLIT|NOFRAME,$0
 	MOVW	(g_sched+gobuf_sp)(g), R3	// R3 = g->gobuf.sp
 	BL      runtime·save_g(SB)
 
-	// traceback will think that we've done PUSH and SUB
-	// on this stack, so subtract them here to match.
-	// (we need room for sighandler arguments anyway).
+	// make room for sighandler arguments
 	// and re-save old SP for restoring later.
-	SUB	$(40+8+20), R3
+	// (note that the 24(R3) here must match the 24(R13) above.)
+	SUB	$40, R3
 	MOVW	R13, 24(R3)		// save old stack pointer
 	MOVW	R3, R13			// switch stack
 
@@ -151,22 +152,14 @@ g0:
 	MOVW	0(R6), R2	// R2 = ExceptionPointers->ExceptionRecord
 	MOVW	4(R6), R3	// R3 = ExceptionPointers->ContextRecord
 
-	// make it look like mstart called us on g0, to stop traceback
-	MOVW    $runtime·mstart(SB), R4
-
-	MOVW	R4, 0(R13)	// Save link register for traceback
+	MOVW	$0, R4
+	MOVW	R4, 0(R13)	// No saved link register.
 	MOVW	R2, 4(R13)	// Move arg0 (ExceptionRecord) into position
 	MOVW	R3, 8(R13)	// Move arg1 (ContextRecord) into position
 	MOVW	R5, 12(R13)	// Move arg2 (original g) into position
 	BL	(R7)		// Call the go routine
 	MOVW	16(R13), R4	// Fetch return value from stack
 
-	// Compute the value of the g0 stack pointer after deallocating
-	// this frame, then allocating 8 bytes. We may need to store
-	// the resume SP and PC on the g0 stack to work around
-	// control flow guard when we resume from the exception.
-	ADD	$(40+20), R13, R12
-
 	// switch back to original stack and g
 	MOVW	24(R13), R13
 	MOVW	20(R13), g
@@ -192,33 +185,36 @@ done:
 	// If returntramp has already been set up by a previous exception
 	// handler, don't clobber the stored SP and PC on the stack.
 	MOVW	4(R3), R3			// PEXCEPTION_POINTERS->Context
-	MOVW	0x40(R3), R2			// load PC from context record
+	MOVW	context_pc(R3), R2		// load PC from context record
 	MOVW	$returntramp<>(SB), R1
 	CMP	R1, R2
 	B.EQ	return				// do not clobber saved SP/PC
 
-	// Save resume SP and PC on g0 stack
-	MOVW	0x38(R3), R2			// load SP from context record
-	MOVW	R2, 0(R12)			// Store resume SP on g0 stack
-	MOVW	0x40(R3), R2			// load PC from context record
-	MOVW	R2, 4(R12)			// Store resume PC on g0 stack
+	// Save resume SP and PC into R0, R1.
+	MOVW	context_spr(R3), R2
+	MOVW	R2, context_r0(R3)
+	MOVW	context_pc(R3), R2
+	MOVW	R2, context_r1(R3)
 
 	// Set up context record to return to returntramp on g0 stack
-	MOVW	R12, 0x38(R3)			// save g0 stack pointer
-						// in context record
-	MOVW	$returntramp<>(SB), R2	// save resume address
-	MOVW	R2, 0x40(R3)			// in context record
+	MOVW	R12, context_spr(R3)
+	MOVW	$returntramp<>(SB), R2
+	MOVW	R2, context_pc(R3)
 
 return:
 	B	(R14)				// return
 
-//
 // Trampoline to resume execution from exception handler.
 // This is part of the control flow guard workaround.
 // It switches stacks and jumps to the continuation address.
-//
+// R0 and R1 are set above at the end of sigtramp<>
+// in the context that starts executing at returntramp<>.
 TEXT returntramp<>(SB),NOSPLIT|NOFRAME,$0
-	MOVM.IA	(R13), [R13, R15]		// ldm sp, [sp, pc]
+	// Important: do not smash LR,
+	// which is set to a live value when handling
+	// a signal by pushing a call to sigpanic onto the stack.
+	MOVW	R0, R13
+	B	(R1)
 
 TEXT runtime·exceptiontramp(SB),NOSPLIT|NOFRAME,$0
 	MOVW	$runtime·exceptionhandler(SB), R1
-- 
GitLab


From 6fe8981620aa61cb43476538f8230231623f9e13 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 15 Feb 2021 13:58:45 -0500
Subject: [PATCH 0690/2400] cmd/internal/obj/riscv: fix JMP name<>(SB)

It was being rejected. Now it isn't and can be used in the runtime.

Change-Id: I4626bf9fc2e0bc26fffb87d11bede459964324b3
Reviewed-on: https://go-review.googlesource.com/c/go/+/292129
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/internal/obj/riscv/obj.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/cmd/internal/obj/riscv/obj.go b/src/cmd/internal/obj/riscv/obj.go
index 9257a6453a..5ef334dd6a 100644
--- a/src/cmd/internal/obj/riscv/obj.go
+++ b/src/cmd/internal/obj/riscv/obj.go
@@ -119,7 +119,7 @@ func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
 			switch p.To.Name {
 			case obj.NAME_NONE:
 				p.As = AJALR
-			case obj.NAME_EXTERN:
+			case obj.NAME_EXTERN, obj.NAME_STATIC:
 				// Handled in preprocess.
 			default:
 				ctxt.Diag("unsupported name %d for %v", p.To.Name, p)
@@ -267,7 +267,7 @@ func rewriteMOV(ctxt *obj.Link, newprog obj.ProgAlloc, p *obj.Prog) {
 				p.As = movToStore(p.As)
 				p.To.Reg = addrToReg(p.To)
 
-			case obj.NAME_EXTERN:
+			case obj.NAME_EXTERN, obj.NAME_STATIC:
 				// AUIPC $off_hi, TMP
 				// S $off_lo, TMP, R
 				as := p.As
@@ -666,7 +666,7 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 			switch p.To.Type {
 			case obj.TYPE_MEM:
 				switch p.To.Name {
-				case obj.NAME_EXTERN:
+				case obj.NAME_EXTERN, obj.NAME_STATIC:
 					// JMP to symbol.
 					jalrToSym(ctxt, p, newprog, REG_ZERO)
 				}
-- 
GitLab


From aa0388f2ed937669e9f938da8a65c75ea144ebfd Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 15 Feb 2021 09:25:55 -0500
Subject: [PATCH 0691/2400] runtime: remove unnecessary writes to gp.sched.g

A g's sched.g is set in newproc1:

	newg.sched.g = guintptr(unsafe.Pointer(newg))

After that, it never changes. Yet lots of assembly code does
"g.sched.g = g" unnecessarily. Remove all those lines to avoid
confusion about whether it ever changes.

Also, split gogo into two functions, one that does the nil g check
and a second that does the actual switch. This way, if the nil g check
fails, we get a stack trace showing the call stack that led to the failure.
(The SP write would otherwise cause the stack trace to abort.)

Also restore the proper nil g check in a handful of assembly functions.
(There is little point in checking for nil g *after* installing it as the real g.)

Change-Id: I22866b093f901f765de1d074e36eeec10366abfb
Reviewed-on: https://go-review.googlesource.com/c/go/+/292109
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/asm_386.s     |  7 ++++---
 src/runtime/asm_amd64.s   |  7 ++++---
 src/runtime/asm_arm.s     | 19 +++++--------------
 src/runtime/asm_arm64.s   | 12 +++++++-----
 src/runtime/asm_mips64x.s | 11 +++++++----
 src/runtime/asm_mipsx.s   | 13 +++++++------
 src/runtime/asm_ppc64x.s  | 12 +++++++-----
 src/runtime/asm_riscv64.s | 12 +++++++-----
 src/runtime/asm_s390x.s   | 11 +++++++----
 src/runtime/asm_wasm.s    |  7 +++----
 src/runtime/proc.go       | 24 ++++++++++++++++++++----
 11 files changed, 78 insertions(+), 57 deletions(-)

diff --git a/src/runtime/asm_386.s b/src/runtime/asm_386.s
index a59054226c..fcf74a03cf 100644
--- a/src/runtime/asm_386.s
+++ b/src/runtime/asm_386.s
@@ -275,10 +275,13 @@ TEXT runtime·asminit(SB),NOSPLIT,$0-0
 
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
-TEXT runtime·gogo(SB), NOSPLIT, $8-4
+TEXT runtime·gogo(SB), NOSPLIT, $0-4
 	MOVL	buf+0(FP), BX		// gobuf
 	MOVL	gobuf_g(BX), DX
 	MOVL	0(DX), CX		// make sure g != nil
+	JMP	gogo<>(SB)
+
+TEXT gogo<>(SB), NOSPLIT, $0
 	get_tls(CX)
 	MOVL	DX, g(CX)
 	MOVL	gobuf_sp(BX), SP	// restore SP
@@ -303,7 +306,6 @@ TEXT runtime·mcall(SB), NOSPLIT, $0-4
 	MOVL	BX, (g_sched+gobuf_pc)(AX)
 	LEAL	fn+0(FP), BX	// caller's SP
 	MOVL	BX, (g_sched+gobuf_sp)(AX)
-	MOVL	AX, (g_sched+gobuf_g)(AX)
 
 	// switch to m->g0 & its stack, call fn
 	MOVL	g(DX), BX
@@ -432,7 +434,6 @@ TEXT runtime·morestack(SB),NOSPLIT,$0-0
 	// Set g->sched to context in f.
 	MOVL	0(SP), AX	// f's PC
 	MOVL	AX, (g_sched+gobuf_pc)(SI)
-	MOVL	SI, (g_sched+gobuf_g)(SI)
 	LEAL	4(SP), AX	// f's SP
 	MOVL	AX, (g_sched+gobuf_sp)(SI)
 	MOVL	DX, (g_sched+gobuf_ctxt)(SI)
diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index cd5ce3effb..8ee2ac2123 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -256,10 +256,13 @@ TEXT runtime·asminit(SB),NOSPLIT,$0-0
 
 // func gogo(buf *gobuf)
 // restore state from Gobuf; longjmp
-TEXT runtime·gogo(SB), NOSPLIT, $16-8
+TEXT runtime·gogo(SB), NOSPLIT, $0-8
 	MOVQ	buf+0(FP), BX		// gobuf
 	MOVQ	gobuf_g(BX), DX
 	MOVQ	0(DX), CX		// make sure g != nil
+	JMP	gogo<>(SB)
+
+TEXT gogo<>(SB), NOSPLIT, $0
 	get_tls(CX)
 	MOVQ	DX, g(CX)
 	MOVQ	DX, R14		// set the g register
@@ -287,7 +290,6 @@ TEXT runtime·mcall(SB), NOSPLIT, $0-8
 	MOVQ	BX, (g_sched+gobuf_pc)(AX)
 	LEAQ	fn+0(FP), BX	// caller's SP
 	MOVQ	BX, (g_sched+gobuf_sp)(AX)
-	MOVQ	AX, (g_sched+gobuf_g)(AX)
 	MOVQ	BP, (g_sched+gobuf_bp)(AX)
 
 	// switch to m->g0 & its stack, call fn
@@ -418,7 +420,6 @@ TEXT runtime·morestack(SB),NOSPLIT,$0-0
 	// Set g->sched to context in f.
 	MOVQ	0(SP), AX // f's PC
 	MOVQ	AX, (g_sched+gobuf_pc)(SI)
-	MOVQ	SI, (g_sched+gobuf_g)(SI)
 	LEAQ	8(SP), AX // f's SP
 	MOVQ	AX, (g_sched+gobuf_sp)(SI)
 	MOVQ	BP, (g_sched+gobuf_bp)(SI)
diff --git a/src/runtime/asm_arm.s b/src/runtime/asm_arm.s
index c8c53e70db..92d7854306 100644
--- a/src/runtime/asm_arm.s
+++ b/src/runtime/asm_arm.s
@@ -208,21 +208,14 @@ TEXT runtime·asminit(SB),NOSPLIT,$0-0
 
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
-TEXT runtime·gogo(SB),NOSPLIT,$8-4
+TEXT runtime·gogo(SB),NOSPLIT|NOFRAME,$0-4
 	MOVW	buf+0(FP), R1
 	MOVW	gobuf_g(R1), R0
-	BL	setg<>(SB)
+	MOVW	0(R0), R2	// make sure g != nil
+	B	gogo<>(SB)
 
-	// NOTE: We updated g above, and we are about to update SP.
-	// Until LR and PC are also updated, the g/SP/LR/PC quadruple
-	// are out of sync and must not be used as the basis of a traceback.
-	// Sigprof skips the traceback when SP is not within g's bounds,
-	// and when the PC is inside this function, runtime.gogo.
-	// Since we are about to update SP, until we complete runtime.gogo
-	// we must not leave this function. In particular, no calls
-	// after this point: it must be straight-line code until the
-	// final B instruction.
-	// See large comment in sigprof for more details.
+TEXT gogo<>(SB),NOSPLIT|NOFRAME,$0
+	BL	setg<>(SB)
 	MOVW	gobuf_sp(R1), R13	// restore SP==R13
 	MOVW	gobuf_lr(R1), LR
 	MOVW	gobuf_ret(R1), R0
@@ -246,7 +239,6 @@ TEXT runtime·mcall(SB),NOSPLIT|NOFRAME,$0-4
 	MOVW	LR, (g_sched+gobuf_pc)(g)
 	MOVW	$0, R11
 	MOVW	R11, (g_sched+gobuf_lr)(g)
-	MOVW	g, (g_sched+gobuf_g)(g)
 
 	// Switch to m->g0 & its stack, call fn.
 	MOVW	g, R1
@@ -537,7 +529,6 @@ TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
 	ADD	$4, R11 // get past push {lr}
 	MOVW	R11, (g_sched+gobuf_pc)(g)
 	MOVW	R13, (g_sched+gobuf_sp)(g)
-	MOVW	g, (g_sched+gobuf_g)(g)
 	MOVW	$0, R11
 	MOVW	R11, (g_sched+gobuf_lr)(g)
 	MOVW	R11, (g_sched+gobuf_ret)(g)
diff --git a/src/runtime/asm_arm64.s b/src/runtime/asm_arm64.s
index 31a6fe57b9..4f0a680fa4 100644
--- a/src/runtime/asm_arm64.s
+++ b/src/runtime/asm_arm64.s
@@ -115,12 +115,16 @@ TEXT runtime·asminit(SB),NOSPLIT|NOFRAME,$0-0
 
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
-TEXT runtime·gogo(SB), NOSPLIT, $24-8
+TEXT runtime·gogo(SB), NOSPLIT|NOFRAME, $0-8
 	MOVD	buf+0(FP), R5
-	MOVD	gobuf_g(R5), g
+	MOVD	gobuf_g(R5), R6
+	MOVD	0(R6), R4	// make sure g != nil
+	B	gogo<>(SB)
+
+TEXT gogo<>(SB), NOSPLIT|NOFRAME, $0
+	MOVD	R6, g
 	BL	runtime·save_g(SB)
 
-	MOVD	0(g), R4	// make sure g is not nil
 	MOVD	gobuf_sp(R5), R0
 	MOVD	R0, RSP
 	MOVD	gobuf_bp(R5), R29
@@ -147,7 +151,6 @@ TEXT runtime·mcall(SB), NOSPLIT|NOFRAME, $0-8
 	MOVD	R29, (g_sched+gobuf_bp)(g)
 	MOVD	LR, (g_sched+gobuf_pc)(g)
 	MOVD	$0, (g_sched+gobuf_lr)(g)
-	MOVD	g, (g_sched+gobuf_g)(g)
 
 	// Switch to m->g0 & its stack, call fn.
 	MOVD	g, R3
@@ -861,7 +864,6 @@ TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
 	MOVD	R29, (g_sched+gobuf_bp)(g)
 	MOVD	$0, (g_sched+gobuf_lr)(g)
 	MOVD	$0, (g_sched+gobuf_ret)(g)
-	MOVD	g, (g_sched+gobuf_g)(g)
 	// Assert ctxt is zero. See func save.
 	MOVD	(g_sched+gobuf_ctxt)(g), R0
 	CBZ	R0, 2(PC)
diff --git a/src/runtime/asm_mips64x.s b/src/runtime/asm_mips64x.s
index 75bb223066..f6d8931a15 100644
--- a/src/runtime/asm_mips64x.s
+++ b/src/runtime/asm_mips64x.s
@@ -91,9 +91,14 @@ TEXT runtime·asminit(SB),NOSPLIT|NOFRAME,$0-0
 
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
-TEXT runtime·gogo(SB), NOSPLIT, $16-8
+TEXT runtime·gogo(SB), NOSPLIT|NOFRAME, $0-8
 	MOVV	buf+0(FP), R3
-	MOVV	gobuf_g(R3), g	// make sure g is not nil
+	MOVV	gobuf_g(R3), R4
+	MOVV	0(R4), R5	// make sure g != nil
+	JMP	gogo<>(SB)
+
+TEXT gogo<>(SB), NOSPLIT|NOFRAME, $0
+	MOVV	R5, g
 	JAL	runtime·save_g(SB)
 
 	MOVV	0(g), R2
@@ -117,7 +122,6 @@ TEXT runtime·mcall(SB), NOSPLIT|NOFRAME, $0-8
 	MOVV	R29, (g_sched+gobuf_sp)(g)
 	MOVV	R31, (g_sched+gobuf_pc)(g)
 	MOVV	R0, (g_sched+gobuf_lr)(g)
-	MOVV	g, (g_sched+gobuf_g)(g)
 
 	// Switch to m->g0 & its stack, call fn.
 	MOVV	g, R1
@@ -404,7 +408,6 @@ TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
 	MOVV	R29, (g_sched+gobuf_sp)(g)
 	MOVV	R0, (g_sched+gobuf_lr)(g)
 	MOVV	R0, (g_sched+gobuf_ret)(g)
-	MOVV	g, (g_sched+gobuf_g)(g)
 	// Assert ctxt is zero. See func save.
 	MOVV	(g_sched+gobuf_ctxt)(g), R1
 	BEQ	R1, 2(PC)
diff --git a/src/runtime/asm_mipsx.s b/src/runtime/asm_mipsx.s
index 341da8e8d7..cf4b1b42cc 100644
--- a/src/runtime/asm_mipsx.s
+++ b/src/runtime/asm_mipsx.s
@@ -92,12 +92,15 @@ TEXT runtime·asminit(SB),NOSPLIT,$0-0
 
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
-TEXT runtime·gogo(SB),NOSPLIT,$8-4
+TEXT runtime·gogo(SB),NOSPLIT|NOFRAME,$0-4
 	MOVW	buf+0(FP), R3
-	MOVW	gobuf_g(R3), g	// make sure g is not nil
-	JAL	runtime·save_g(SB)
+	MOVW	gobuf_g(R3), R4
+	MOVW	0(R4), R5	// make sure g != nil
+	JMP	gogo<>(SB)
 
-	MOVW	0(g), R2
+TEXT gogo<>(SB),NOSPLIT|NOFRAME,$0
+	MOVW	R4, g
+	JAL	runtime·save_g(SB)
 	MOVW	gobuf_sp(R3), R29
 	MOVW	gobuf_lr(R3), R31
 	MOVW	gobuf_ret(R3), R1
@@ -118,7 +121,6 @@ TEXT runtime·mcall(SB),NOSPLIT|NOFRAME,$0-4
 	MOVW	R29, (g_sched+gobuf_sp)(g)
 	MOVW	R31, (g_sched+gobuf_pc)(g)
 	MOVW	R0, (g_sched+gobuf_lr)(g)
-	MOVW	g, (g_sched+gobuf_g)(g)
 
 	// Switch to m->g0 & its stack, call fn.
 	MOVW	g, R1
@@ -404,7 +406,6 @@ TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
 	MOVW	R29, (g_sched+gobuf_sp)(g)
 	MOVW	R0, (g_sched+gobuf_lr)(g)
 	MOVW	R0, (g_sched+gobuf_ret)(g)
-	MOVW	g, (g_sched+gobuf_g)(g)
 	// Assert ctxt is zero. See func save.
 	MOVW	(g_sched+gobuf_ctxt)(g), R1
 	BEQ	R1, 2(PC)
diff --git a/src/runtime/asm_ppc64x.s b/src/runtime/asm_ppc64x.s
index a99a61fd88..90f14d8e54 100644
--- a/src/runtime/asm_ppc64x.s
+++ b/src/runtime/asm_ppc64x.s
@@ -130,12 +130,16 @@ TEXT runtime·reginit(SB),NOSPLIT|NOFRAME,$0-0
 
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
-TEXT runtime·gogo(SB), NOSPLIT, $16-8
+TEXT runtime·gogo(SB), NOSPLIT|NOFRAME, $0-8
 	MOVD	buf+0(FP), R5
-	MOVD	gobuf_g(R5), g	// make sure g is not nil
+	MOVD	gobuf_g(R5), R6
+	MOVD	0(R6), R4	// make sure g != nil
+	BR	gogo<>(SB)
+
+TEXT gogo<>(SB), NOSPLIT|NOFRAME, $0
+	MOVD	R6, g
 	BL	runtime·save_g(SB)
 
-	MOVD	0(g), R4
 	MOVD	gobuf_sp(R5), R1
 	MOVD	gobuf_lr(R5), R31
 #ifndef GOOS_aix
@@ -163,7 +167,6 @@ TEXT runtime·mcall(SB), NOSPLIT|NOFRAME, $0-8
 	MOVD	LR, R31
 	MOVD	R31, (g_sched+gobuf_pc)(g)
 	MOVD	R0, (g_sched+gobuf_lr)(g)
-	MOVD	g, (g_sched+gobuf_g)(g)
 
 	// Switch to m->g0 & its stack, call fn.
 	MOVD	g, R3
@@ -536,7 +539,6 @@ TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
 	MOVD	R1, (g_sched+gobuf_sp)(g)
 	MOVD	R0, (g_sched+gobuf_lr)(g)
 	MOVD	R0, (g_sched+gobuf_ret)(g)
-	MOVD	g, (g_sched+gobuf_g)(g)
 	// Assert ctxt is zero. See func save.
 	MOVD	(g_sched+gobuf_ctxt)(g), R31
 	CMP	R0, R31
diff --git a/src/runtime/asm_riscv64.s b/src/runtime/asm_riscv64.s
index fb7c6530dc..d06c77b948 100644
--- a/src/runtime/asm_riscv64.s
+++ b/src/runtime/asm_riscv64.s
@@ -224,12 +224,16 @@ TEXT runtime·return0(SB), NOSPLIT, $0
 // restore state from Gobuf; longjmp
 
 // func gogo(buf *gobuf)
-TEXT runtime·gogo(SB), NOSPLIT, $16-8
+TEXT runtime·gogo(SB), NOSPLIT|NOFRAME, $0-8
 	MOV	buf+0(FP), T0
-	MOV	gobuf_g(T0), g	// make sure g is not nil
+	MOV	gobuf_g(T0), T1
+	MOV	0(T1), ZERO // make sure g != nil
+	JMP	gogo<>(SB)
+
+TEXT gogo<>(SB), NOSPLIT|NOFRAME, $0
+	MOV	T1, g
 	CALL	runtime·save_g(SB)
 
-	MOV	(g), ZERO // make sure g is not nil
 	MOV	gobuf_sp(T0), X2
 	MOV	gobuf_lr(T0), RA
 	MOV	gobuf_ret(T0), A0
@@ -270,7 +274,6 @@ TEXT runtime·mcall(SB), NOSPLIT|NOFRAME, $0-8
 	MOV	X2, (g_sched+gobuf_sp)(g)
 	MOV	RA, (g_sched+gobuf_pc)(g)
 	MOV	ZERO, (g_sched+gobuf_lr)(g)
-	MOV	g, (g_sched+gobuf_g)(g)
 
 	// Switch to m->g0 & its stack, call fn.
 	MOV	g, T0
@@ -300,7 +303,6 @@ TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
 	MOV	X2, (g_sched+gobuf_sp)(g)
 	MOV	ZERO, (g_sched+gobuf_lr)(g)
 	MOV	ZERO, (g_sched+gobuf_ret)(g)
-	MOV	g, (g_sched+gobuf_g)(g)
 	// Assert ctxt is zero. See func save.
 	MOV	(g_sched+gobuf_ctxt)(g), X31
 	BEQ	ZERO, X31, 2(PC)
diff --git a/src/runtime/asm_s390x.s b/src/runtime/asm_s390x.s
index 43244d961f..203754f32c 100644
--- a/src/runtime/asm_s390x.s
+++ b/src/runtime/asm_s390x.s
@@ -176,9 +176,14 @@ TEXT runtime·asminit(SB),NOSPLIT|NOFRAME,$0-0
 
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
-TEXT runtime·gogo(SB), NOSPLIT, $16-8
+TEXT runtime·gogo(SB), NOSPLIT|NOFRAME, $0-8
 	MOVD	buf+0(FP), R5
-	MOVD	gobuf_g(R5), g	// make sure g is not nil
+	MOVD	gobuf_g(R5), R6
+	MOVD	0(R6), R7	// make sure g != nil
+	BR	gogo<>(SB)
+
+TEXT gogo<>(SB), NOSPLIT|NOFRAME, $0
+	MOVD	R6, g
 	BL	runtime·save_g(SB)
 
 	MOVD	0(g), R4
@@ -203,7 +208,6 @@ TEXT runtime·mcall(SB), NOSPLIT, $-8-8
 	MOVD	R15, (g_sched+gobuf_sp)(g)
 	MOVD	LR, (g_sched+gobuf_pc)(g)
 	MOVD	$0, (g_sched+gobuf_lr)(g)
-	MOVD	g, (g_sched+gobuf_g)(g)
 
 	// Switch to m->g0 & its stack, call fn.
 	MOVD	g, R3
@@ -500,7 +504,6 @@ TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
 	MOVD	R15, (g_sched+gobuf_sp)(g)
 	MOVD	$0, (g_sched+gobuf_lr)(g)
 	MOVD	$0, (g_sched+gobuf_ret)(g)
-	MOVD	g, (g_sched+gobuf_g)(g)
 	// Assert ctxt is zero. See func save.
 	MOVD	(g_sched+gobuf_ctxt)(g), R1
 	CMPBEQ	R1, $0, 2(PC)
diff --git a/src/runtime/asm_wasm.s b/src/runtime/asm_wasm.s
index cf3d961b74..3765c756b3 100644
--- a/src/runtime/asm_wasm.s
+++ b/src/runtime/asm_wasm.s
@@ -34,7 +34,9 @@ TEXT ·checkASM(SB), NOSPLIT, $0-1
 
 TEXT runtime·gogo(SB), NOSPLIT, $0-8
 	MOVD buf+0(FP), R0
-	MOVD gobuf_g(R0), g
+	MOVD gobuf_g(R0), R1
+	MOVD 0(R1), R2	// make sure g != nil
+	MOVD R1, g
 	MOVD gobuf_sp(R0), SP
 
 	// Put target PC at -8(SP), wasm_pc_f_loop will pick it up
@@ -69,7 +71,6 @@ TEXT runtime·mcall(SB), NOSPLIT, $0-8
 	// save state in g->sched
 	MOVD 0(SP), g_sched+gobuf_pc(g)     // caller's PC
 	MOVD $fn+0(FP), g_sched+gobuf_sp(g) // caller's SP
-	MOVD g, g_sched+gobuf_g(g)
 
 	// if g == g0 call badmcall
 	Get g
@@ -143,7 +144,6 @@ TEXT runtime·systemstack(SB), NOSPLIT, $0-8
 	MOVD $runtime·systemstack_switch(SB), g_sched+gobuf_pc(g)
 
 	MOVD SP, g_sched+gobuf_sp(g)
-	MOVD g, g_sched+gobuf_g(g)
 
 	// switch to g0
 	MOVD R2, g
@@ -270,7 +270,6 @@ TEXT runtime·morestack(SB), NOSPLIT, $0-0
 
 	// Set g->sched to context in f.
 	MOVD 0(SP), g_sched+gobuf_pc(g)
-	MOVD g, g_sched+gobuf_g(g)
 	MOVD $8(SP), g_sched+gobuf_sp(g) // f's SP
 	MOVD CTXT, g_sched+gobuf_ctxt(g)
 
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 1dbd01ed40..388d843004 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -1281,6 +1281,9 @@ func mstart() {
 	mexit(osStack)
 }
 
+// The go:noinline is to guarantee the getcallerpc/getcallersp below are safe,
+// so that we can set up g0.sched to return to the call of mstart1 above.
+//go:noinline
 func mstart1() {
 	_g_ := getg()
 
@@ -1288,11 +1291,16 @@ func mstart1() {
 		throw("bad runtime·mstart")
 	}
 
-	// Record the caller for use as the top of stack in mcall and
-	// for terminating the thread.
+	// Set up m.g0.sched as a label returning returning to just
+	// after the mstart1 call in mstart0 above, for use by goexit0 and mcall.
 	// We're never coming back to mstart1 after we call schedule,
 	// so other calls can reuse the current frame.
-	save(getcallerpc(), getcallersp())
+	// And goexit0 does a gogo that needs to return from mstart1
+	// and let mstart0 exit the thread.
+	_g_.sched.g = guintptr(unsafe.Pointer(_g_))
+	_g_.sched.pc = getcallerpc()
+	_g_.sched.sp = getcallersp()
+
 	asminit()
 	minit()
 
@@ -3445,11 +3453,19 @@ func goexit0(gp *g) {
 func save(pc, sp uintptr) {
 	_g_ := getg()
 
+	if _g_ == _g_.m.g0 || _g_ == _g_.m.gsignal {
+		// m.g0.sched is special and must describe the context
+		// for exiting the thread. mstart1 writes to it directly.
+		// m.gsignal.sched should not be used at all.
+		// This check makes sure save calls do not accidentally
+		// run in contexts where they'd write to system g's.
+		throw("save on system g not allowed")
+	}
+
 	_g_.sched.pc = pc
 	_g_.sched.sp = sp
 	_g_.sched.lr = 0
 	_g_.sched.ret = 0
-	_g_.sched.g = guintptr(unsafe.Pointer(_g_))
 	// We need to ensure ctxt is zero, but can't have a write
 	// barrier here. However, it should always already be zero.
 	// Assert that.
-- 
GitLab


From 4dd77bdc910494adcd57fe9d87cd46f72d8d8985 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 28 Jan 2021 15:21:33 -0500
Subject: [PATCH 0692/2400] cmd/asm, cmd/link, runtime: introduce FuncInfo flag
 bits

The runtime traceback code has its own definition of which functions
mark the top frame of a stack, separate from the TOPFRAME bits that
exist in the assembly and are passed along in DWARF information.
It's error-prone and redundant to have two different sources of truth.
This CL provides the actual TOPFRAME bits to the runtime, so that
the runtime can use those bits instead of reinventing its own category.

This CL also adds a new bit, SPWRITE, which marks functions that
write directly to SP (anything but adding and subtracting constants).
Such functions must stop a traceback, because the traceback has no
way to rederive the SP on entry. Again, the runtime has its own definition
which is mostly correct, but also missing some functions. During ordinary
goroutine context switches, such functions do not appear on the stack,
so the incompleteness in the runtime usually doesn't matter.
But profiling signals can arrive at any moment, and the runtime may
crash during traceback if it attempts to unwind an SP-writing frame
and gets out-of-sync with the actual stack. The runtime contains code
to try to detect likely candidates but again it is incomplete.
Deriving the SPWRITE bit automatically from the actual assembly code
provides the complete truth, and passing it to the runtime lets the
runtime use it.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.
This CL is, however, not windows/arm64-specific.
It is cleanup meant to make the port (and future ports) easier.

Change-Id: I227f53b23ac5b3dabfcc5e8ee3f00df4e113cf58
Reviewed-on: https://go-review.googlesource.com/c/go/+/288800
Trust: Russ Cox <rsc@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
---
 src/cmd/asm/internal/asm/endtoend_test.go     |  2 +
 src/cmd/asm/internal/flags/flags.go           |  2 +
 src/cmd/asm/main.go                           |  1 +
 .../compile/internal/test/fixedbugs_test.go   |  2 +-
 src/cmd/compile/internal/test/global_test.go  |  4 +-
 src/cmd/internal/goobj/funcinfo.go            | 60 +++++--------------
 src/cmd/internal/goobj/objfile.go             |  2 -
 src/cmd/internal/obj/arm/obj5.go              | 16 +++++
 src/cmd/internal/obj/arm64/obj7.go            | 16 +++++
 src/cmd/internal/obj/link.go                  | 23 ++++---
 src/cmd/internal/obj/mips/obj0.go             | 16 +++++
 src/cmd/internal/obj/objfile.go               | 12 ++--
 src/cmd/internal/obj/plist.go                 | 10 +++-
 src/cmd/internal/obj/ppc64/obj9.go            | 16 +++++
 src/cmd/internal/obj/riscv/obj.go             | 16 +++++
 src/cmd/internal/obj/s390x/objz.go            | 16 +++++
 src/cmd/internal/obj/util.go                  |  2 +-
 src/cmd/internal/obj/x86/obj6.go              | 15 +++++
 src/cmd/internal/objabi/funcid.go             | 11 +++-
 src/cmd/link/internal/ld/dwarf.go             |  4 +-
 src/cmd/link/internal/ld/pcln.go              |  9 ++-
 src/cmd/link/internal/loader/loader.go        | 37 ++++--------
 src/runtime/runtime2.go                       |  9 +--
 src/runtime/symtab.go                         |  9 +++
 24 files changed, 209 insertions(+), 101 deletions(-)

diff --git a/src/cmd/asm/internal/asm/endtoend_test.go b/src/cmd/asm/internal/asm/endtoend_test.go
index 7472507caf..a4153f3af1 100644
--- a/src/cmd/asm/internal/asm/endtoend_test.go
+++ b/src/cmd/asm/internal/asm/endtoend_test.go
@@ -36,6 +36,7 @@ func testEndToEnd(t *testing.T, goarch, file string) {
 	var ok bool
 	testOut = new(bytes.Buffer) // The assembler writes test output to this buffer.
 	ctxt.Bso = bufio.NewWriter(os.Stdout)
+	ctxt.IsAsm = true
 	defer ctxt.Bso.Flush()
 	failed := false
 	ctxt.DiagFunc = func(format string, args ...interface{}) {
@@ -278,6 +279,7 @@ func testErrors(t *testing.T, goarch, file string) {
 	var ok bool
 	testOut = new(bytes.Buffer) // The assembler writes test output to this buffer.
 	ctxt.Bso = bufio.NewWriter(os.Stdout)
+	ctxt.IsAsm = true
 	defer ctxt.Bso.Flush()
 	failed := false
 	var errBuf bytes.Buffer
diff --git a/src/cmd/asm/internal/flags/flags.go b/src/cmd/asm/internal/flags/flags.go
index 1335860315..dd947c7b5b 100644
--- a/src/cmd/asm/internal/flags/flags.go
+++ b/src/cmd/asm/internal/flags/flags.go
@@ -32,11 +32,13 @@ var (
 	D        MultiFlag
 	I        MultiFlag
 	PrintOut int
+	DebugV   bool
 )
 
 func init() {
 	flag.Var(&D, "D", "predefined symbol with optional simple value -D=identifier=value; can be set multiple times")
 	flag.Var(&I, "I", "include directory; can be set multiple times")
+	flag.BoolVar(&DebugV, "v", false, "print debug output")
 	objabi.AddVersionFlag() // -V
 	objabi.Flagcount("S", "print assembly and machine code", &PrintOut)
 }
diff --git a/src/cmd/asm/main.go b/src/cmd/asm/main.go
index 31636e3045..98618a67ef 100644
--- a/src/cmd/asm/main.go
+++ b/src/cmd/asm/main.go
@@ -36,6 +36,7 @@ func main() {
 
 	ctxt := obj.Linknew(architecture.LinkArch)
 	ctxt.Debugasm = flags.PrintOut
+	ctxt.Debugvlog = flags.DebugV
 	ctxt.Flag_dynlink = *flags.Dynlink
 	ctxt.Flag_linkshared = *flags.Linkshared
 	ctxt.Flag_shared = *flags.Shared || *flags.Dynlink
diff --git a/src/cmd/compile/internal/test/fixedbugs_test.go b/src/cmd/compile/internal/test/fixedbugs_test.go
index e7e2f7e58e..376b45edfc 100644
--- a/src/cmd/compile/internal/test/fixedbugs_test.go
+++ b/src/cmd/compile/internal/test/fixedbugs_test.go
@@ -75,7 +75,7 @@ func TestIssue16214(t *testing.T) {
 	cmd := exec.Command(testenv.GoToolPath(t), "tool", "compile", "-S", "-o", filepath.Join(dir, "out.o"), src)
 	out, err := cmd.CombinedOutput()
 	if err != nil {
-		t.Fatalf("fail to run go tool compile: %v", err)
+		t.Fatalf("go tool compile: %v\n%s", err, out)
 	}
 
 	if strings.Contains(string(out), "unknown line number") {
diff --git a/src/cmd/compile/internal/test/global_test.go b/src/cmd/compile/internal/test/global_test.go
index 5f5f7d6198..93de894f37 100644
--- a/src/cmd/compile/internal/test/global_test.go
+++ b/src/cmd/compile/internal/test/global_test.go
@@ -50,7 +50,7 @@ func main() {
 	cmd := exec.Command(testenv.GoToolPath(t), "build", "-o", dst, src)
 	out, err := cmd.CombinedOutput()
 	if err != nil {
-		t.Fatalf("could not build target: %v", err)
+		t.Fatalf("could not build target: %v\n%s", err, out)
 	}
 
 	// Check destination to see if scanf code was included.
@@ -95,7 +95,7 @@ func main() {
 	cmd := exec.Command(testenv.GoToolPath(t), "build", "-gcflags", "-S", "-o", filepath.Join(dir, "test"), src)
 	out, err := cmd.CombinedOutput()
 	if err != nil {
-		t.Fatalf("could not build target: %v", err)
+		t.Fatalf("could not build target: %v\n%s", err, out)
 	}
 
 	patterns := []string{
diff --git a/src/cmd/internal/goobj/funcinfo.go b/src/cmd/internal/goobj/funcinfo.go
index 2cca8f6c4e..6d33a10a51 100644
--- a/src/cmd/internal/goobj/funcinfo.go
+++ b/src/cmd/internal/goobj/funcinfo.go
@@ -19,9 +19,10 @@ type CUFileIndex uint32
 //
 // TODO: make each pcdata a separate symbol?
 type FuncInfo struct {
-	Args   uint32
-	Locals uint32
-	FuncID objabi.FuncID
+	Args     uint32
+	Locals   uint32
+	FuncID   objabi.FuncID
+	FuncFlag objabi.FuncFlag
 
 	Pcsp        SymRef
 	Pcfile      SymRef
@@ -35,6 +36,9 @@ type FuncInfo struct {
 }
 
 func (a *FuncInfo) Write(w *bytes.Buffer) {
+	writeUint8 := func(x uint8) {
+		w.WriteByte(x)
+	}
 	var b [4]byte
 	writeUint32 := func(x uint32) {
 		binary.LittleEndian.PutUint32(b[:], x)
@@ -47,8 +51,10 @@ func (a *FuncInfo) Write(w *bytes.Buffer) {
 
 	writeUint32(a.Args)
 	writeUint32(a.Locals)
-	writeUint32(uint32(a.FuncID))
-
+	writeUint8(uint8(a.FuncID))
+	writeUint8(uint8(a.FuncFlag))
+	writeUint8(0) // pad to uint32 boundary
+	writeUint8(0)
 	writeSymRef(a.Pcsp)
 	writeSymRef(a.Pcfile)
 	writeSymRef(a.Pcline)
@@ -72,46 +78,6 @@ func (a *FuncInfo) Write(w *bytes.Buffer) {
 	}
 }
 
-func (a *FuncInfo) Read(b []byte) {
-	readUint32 := func() uint32 {
-		x := binary.LittleEndian.Uint32(b)
-		b = b[4:]
-		return x
-	}
-	readSymIdx := func() SymRef {
-		return SymRef{readUint32(), readUint32()}
-	}
-
-	a.Args = readUint32()
-	a.Locals = readUint32()
-	a.FuncID = objabi.FuncID(readUint32())
-
-	a.Pcsp = readSymIdx()
-	a.Pcfile = readSymIdx()
-	a.Pcline = readSymIdx()
-	a.Pcinline = readSymIdx()
-	a.Pcdata = make([]SymRef, readUint32())
-	for i := range a.Pcdata {
-		a.Pcdata[i] = readSymIdx()
-	}
-
-	funcdataofflen := readUint32()
-	a.Funcdataoff = make([]uint32, funcdataofflen)
-	for i := range a.Funcdataoff {
-		a.Funcdataoff[i] = readUint32()
-	}
-	filelen := readUint32()
-	a.File = make([]CUFileIndex, filelen)
-	for i := range a.File {
-		a.File[i] = CUFileIndex(readUint32())
-	}
-	inltreelen := readUint32()
-	a.InlTree = make([]InlTreeNode, inltreelen)
-	for i := range a.InlTree {
-		b = a.InlTree[i].Read(b)
-	}
-}
-
 // FuncInfoLengths is a cache containing a roadmap of offsets and
 // lengths for things within a serialized FuncInfo. Each length field
 // stores the number of items (e.g. files, inltree nodes, etc), and the
@@ -159,7 +125,9 @@ func (*FuncInfo) ReadArgs(b []byte) uint32 { return binary.LittleEndian.Uint32(b
 
 func (*FuncInfo) ReadLocals(b []byte) uint32 { return binary.LittleEndian.Uint32(b[4:]) }
 
-func (*FuncInfo) ReadFuncID(b []byte) uint32 { return binary.LittleEndian.Uint32(b[8:]) }
+func (*FuncInfo) ReadFuncID(b []byte) objabi.FuncID { return objabi.FuncID(b[8]) }
+
+func (*FuncInfo) ReadFuncFlag(b []byte) objabi.FuncFlag { return objabi.FuncFlag(b[9]) }
 
 func (*FuncInfo) ReadPcsp(b []byte) SymRef {
 	return SymRef{binary.LittleEndian.Uint32(b[12:]), binary.LittleEndian.Uint32(b[16:])}
diff --git a/src/cmd/internal/goobj/objfile.go b/src/cmd/internal/goobj/objfile.go
index e6447e455d..d1b838f676 100644
--- a/src/cmd/internal/goobj/objfile.go
+++ b/src/cmd/internal/goobj/objfile.go
@@ -298,7 +298,6 @@ const (
 	SymFlagNoSplit
 	SymFlagReflectMethod
 	SymFlagGoType
-	SymFlagTopFrame
 )
 
 // Sym.Flag2
@@ -332,7 +331,6 @@ func (s *Sym) Leaf() bool          { return s.Flag()&SymFlagLeaf != 0 }
 func (s *Sym) NoSplit() bool       { return s.Flag()&SymFlagNoSplit != 0 }
 func (s *Sym) ReflectMethod() bool { return s.Flag()&SymFlagReflectMethod != 0 }
 func (s *Sym) IsGoType() bool      { return s.Flag()&SymFlagGoType != 0 }
-func (s *Sym) TopFrame() bool      { return s.Flag()&SymFlagTopFrame != 0 }
 func (s *Sym) UsedInIface() bool   { return s.Flag2()&SymFlagUsedInIface != 0 }
 func (s *Sym) IsItab() bool        { return s.Flag2()&SymFlagItab != 0 }
 
diff --git a/src/cmd/internal/obj/arm/obj5.go b/src/cmd/internal/obj/arm/obj5.go
index 29d3a5867d..7de04302d9 100644
--- a/src/cmd/internal/obj/arm/obj5.go
+++ b/src/cmd/internal/obj/arm/obj5.go
@@ -34,6 +34,7 @@ import (
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
 	"cmd/internal/sys"
+	"log"
 )
 
 var progedit_tlsfallback *obj.LSym
@@ -613,6 +614,21 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 				p.From.Reg = REGSP
 			}
 		}
+
+		if p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP && p.Spadj == 0 {
+			f := c.cursym.Func()
+			if f.FuncFlag&objabi.FuncFlag_SPWRITE == 0 {
+				c.cursym.Func().FuncFlag |= objabi.FuncFlag_SPWRITE
+				if ctxt.Debugvlog || !ctxt.IsAsm {
+					ctxt.Logf("auto-SPWRITE: %s %v\n", c.cursym.Name, p)
+					if !ctxt.IsAsm {
+						ctxt.Diag("invalid auto-SPWRITE in non-assembly")
+						ctxt.DiagFlush()
+						log.Fatalf("bad SPWRITE")
+					}
+				}
+			}
+		}
 	}
 }
 
diff --git a/src/cmd/internal/obj/arm64/obj7.go b/src/cmd/internal/obj/arm64/obj7.go
index 0baf51973a..3b88543852 100644
--- a/src/cmd/internal/obj/arm64/obj7.go
+++ b/src/cmd/internal/obj/arm64/obj7.go
@@ -35,6 +35,7 @@ import (
 	"cmd/internal/objabi"
 	"cmd/internal/src"
 	"cmd/internal/sys"
+	"log"
 	"math"
 )
 
@@ -970,6 +971,21 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 				p = q5
 			}
 		}
+
+		if p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP && p.Spadj == 0 {
+			f := c.cursym.Func()
+			if f.FuncFlag&objabi.FuncFlag_SPWRITE == 0 {
+				c.cursym.Func().FuncFlag |= objabi.FuncFlag_SPWRITE
+				if ctxt.Debugvlog || !ctxt.IsAsm {
+					ctxt.Logf("auto-SPWRITE: %s %v\n", c.cursym.Name, p)
+					if !ctxt.IsAsm {
+						ctxt.Diag("invalid auto-SPWRITE in non-assembly")
+						ctxt.DiagFlush()
+						log.Fatalf("bad SPWRITE")
+					}
+				}
+			}
+		}
 	}
 }
 
diff --git a/src/cmd/internal/obj/link.go b/src/cmd/internal/obj/link.go
index 8206902328..a48db3bdc8 100644
--- a/src/cmd/internal/obj/link.go
+++ b/src/cmd/internal/obj/link.go
@@ -454,6 +454,7 @@ type FuncInfo struct {
 	Locals   int32
 	Align    int32
 	FuncID   objabi.FuncID
+	FuncFlag objabi.FuncFlag
 	Text     *Prog
 	Autot    map[*LSym]struct{}
 	Pcln     Pcln
@@ -619,10 +620,6 @@ const (
 	// target of an inline during compilation
 	AttrWasInlined
 
-	// TopFrame means that this function is an entry point and unwinders should not
-	// keep unwinding beyond this frame.
-	AttrTopFrame
-
 	// Indexed indicates this symbol has been assigned with an index (when using the
 	// new object file format).
 	AttrIndexed
@@ -663,7 +660,6 @@ func (a *Attribute) NeedCtxt() bool           { return a.load()&AttrNeedCtxt !=
 func (a *Attribute) NoFrame() bool            { return a.load()&AttrNoFrame != 0 }
 func (a *Attribute) Static() bool             { return a.load()&AttrStatic != 0 }
 func (a *Attribute) WasInlined() bool         { return a.load()&AttrWasInlined != 0 }
-func (a *Attribute) TopFrame() bool           { return a.load()&AttrTopFrame != 0 }
 func (a *Attribute) Indexed() bool            { return a.load()&AttrIndexed != 0 }
 func (a *Attribute) UsedInIface() bool        { return a.load()&AttrUsedInIface != 0 }
 func (a *Attribute) ContentAddressable() bool { return a.load()&AttrContentAddressable != 0 }
@@ -713,14 +709,13 @@ var textAttrStrings = [...]struct {
 	{bit: AttrNoFrame, s: "NOFRAME"},
 	{bit: AttrStatic, s: "STATIC"},
 	{bit: AttrWasInlined, s: ""},
-	{bit: AttrTopFrame, s: "TOPFRAME"},
 	{bit: AttrIndexed, s: ""},
 	{bit: AttrContentAddressable, s: ""},
 	{bit: AttrABIWrapper, s: "ABIWRAPPER"},
 }
 
-// TextAttrString formats a for printing in as part of a TEXT prog.
-func (a Attribute) TextAttrString() string {
+// String formats a for printing in as part of a TEXT prog.
+func (a Attribute) String() string {
 	var s string
 	for _, x := range textAttrStrings {
 		if a&x.bit != 0 {
@@ -746,6 +741,18 @@ func (a Attribute) TextAttrString() string {
 	return s
 }
 
+// TextAttrString formats the symbol attributes for printing in as part of a TEXT prog.
+func (s *LSym) TextAttrString() string {
+	attr := s.Attribute.String()
+	if s.Func().FuncFlag&objabi.FuncFlag_TOPFRAME != 0 {
+		if attr != "" {
+			attr += "|"
+		}
+		attr += "TOPFRAME"
+	}
+	return attr
+}
+
 func (s *LSym) String() string {
 	return s.Name
 }
diff --git a/src/cmd/internal/obj/mips/obj0.go b/src/cmd/internal/obj/mips/obj0.go
index 135a8df3aa..91bba90d41 100644
--- a/src/cmd/internal/obj/mips/obj0.go
+++ b/src/cmd/internal/obj/mips/obj0.go
@@ -35,6 +35,7 @@ import (
 	"cmd/internal/sys"
 	"encoding/binary"
 	"fmt"
+	"log"
 	"math"
 )
 
@@ -536,6 +537,21 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 				p.From.Reg = REGSP
 			}
 		}
+
+		if p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP && p.Spadj == 0 {
+			f := c.cursym.Func()
+			if f.FuncFlag&objabi.FuncFlag_SPWRITE == 0 {
+				c.cursym.Func().FuncFlag |= objabi.FuncFlag_SPWRITE
+				if ctxt.Debugvlog || !ctxt.IsAsm {
+					ctxt.Logf("auto-SPWRITE: %s %v\n", c.cursym.Name, p)
+					if !ctxt.IsAsm {
+						ctxt.Diag("invalid auto-SPWRITE in non-assembly")
+						ctxt.DiagFlush()
+						log.Fatalf("bad SPWRITE")
+					}
+				}
+			}
+		}
 	}
 
 	if c.ctxt.Arch.Family == sys.MIPS {
diff --git a/src/cmd/internal/obj/objfile.go b/src/cmd/internal/obj/objfile.go
index bb58b4f0c2..85f0570e5d 100644
--- a/src/cmd/internal/obj/objfile.go
+++ b/src/cmd/internal/obj/objfile.go
@@ -330,9 +330,6 @@ func (w *writer) Sym(s *LSym) {
 	if s.ReflectMethod() {
 		flag |= goobj.SymFlagReflectMethod
 	}
-	if s.TopFrame() {
-		flag |= goobj.SymFlagTopFrame
-	}
 	if strings.HasPrefix(s.Name, "type.") && s.Name[5] != '.' && s.Type == objabi.SRODATA {
 		flag |= goobj.SymFlagGoType
 	}
@@ -673,9 +670,10 @@ func genFuncInfoSyms(ctxt *Link) {
 			continue
 		}
 		o := goobj.FuncInfo{
-			Args:   uint32(fn.Args),
-			Locals: uint32(fn.Locals),
-			FuncID: objabi.FuncID(fn.FuncID),
+			Args:     uint32(fn.Args),
+			Locals:   uint32(fn.Locals),
+			FuncID:   fn.FuncID,
+			FuncFlag: fn.FuncFlag,
 		}
 		pc := &fn.Pcln
 		o.Pcsp = makeSymRef(preparePcSym(pc.Pcsp))
@@ -788,7 +786,7 @@ func (ctxt *Link) writeSymDebugNamed(s *LSym, name string) {
 	if s.NoSplit() {
 		fmt.Fprintf(ctxt.Bso, "nosplit ")
 	}
-	if s.TopFrame() {
+	if s.Func() != nil && s.Func().FuncFlag&objabi.FuncFlag_TOPFRAME != 0 {
 		fmt.Fprintf(ctxt.Bso, "topframe ")
 	}
 	fmt.Fprintf(ctxt.Bso, "size=%d", s.Size)
diff --git a/src/cmd/internal/obj/plist.go b/src/cmd/internal/obj/plist.go
index 679ce7eb8f..177083261c 100644
--- a/src/cmd/internal/obj/plist.go
+++ b/src/cmd/internal/obj/plist.go
@@ -134,6 +134,7 @@ func (ctxt *Link) InitTextSym(s *LSym, flag int) {
 	}
 	name := strings.Replace(s.Name, "\"\"", ctxt.Pkgpath, -1)
 	s.Func().FuncID = objabi.GetFuncID(name, flag&WRAPPER != 0)
+	s.Func().FuncFlag = toFuncFlag(flag)
 	s.Set(AttrOnList, true)
 	s.Set(AttrDuplicateOK, flag&DUPOK != 0)
 	s.Set(AttrNoSplit, flag&NOSPLIT != 0)
@@ -142,7 +143,6 @@ func (ctxt *Link) InitTextSym(s *LSym, flag int) {
 	s.Set(AttrABIWrapper, flag&ABIWRAPPER != 0)
 	s.Set(AttrNeedCtxt, flag&NEEDCTXT != 0)
 	s.Set(AttrNoFrame, flag&NOFRAME != 0)
-	s.Set(AttrTopFrame, flag&TOPFRAME != 0)
 	s.Type = objabi.STEXT
 	ctxt.Text = append(ctxt.Text, s)
 
@@ -150,6 +150,14 @@ func (ctxt *Link) InitTextSym(s *LSym, flag int) {
 	ctxt.dwarfSym(s)
 }
 
+func toFuncFlag(flag int) objabi.FuncFlag {
+	var out objabi.FuncFlag
+	if flag&TOPFRAME != 0 {
+		out |= objabi.FuncFlag_TOPFRAME
+	}
+	return out
+}
+
 func (ctxt *Link) Globl(s *LSym, size int64, flag int) {
 	if s.OnList() {
 		ctxt.Diag("symbol %s listed multiple times", s.Name)
diff --git a/src/cmd/internal/obj/ppc64/obj9.go b/src/cmd/internal/obj/ppc64/obj9.go
index fddf552156..a77be29cf0 100644
--- a/src/cmd/internal/obj/ppc64/obj9.go
+++ b/src/cmd/internal/obj/ppc64/obj9.go
@@ -34,6 +34,7 @@ import (
 	"cmd/internal/objabi"
 	"cmd/internal/src"
 	"cmd/internal/sys"
+	"log"
 )
 
 func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
@@ -984,6 +985,21 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 				p.From.Reg = REGSP
 			}
 		}
+
+		if p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP && p.Spadj == 0 && p.As != ACMPU {
+			f := c.cursym.Func()
+			if f.FuncFlag&objabi.FuncFlag_SPWRITE == 0 {
+				c.cursym.Func().FuncFlag |= objabi.FuncFlag_SPWRITE
+				if ctxt.Debugvlog || !ctxt.IsAsm {
+					ctxt.Logf("auto-SPWRITE: %s %v\n", c.cursym.Name, p)
+					if !ctxt.IsAsm {
+						ctxt.Diag("invalid auto-SPWRITE in non-assembly")
+						ctxt.DiagFlush()
+						log.Fatalf("bad SPWRITE")
+					}
+				}
+			}
+		}
 	}
 }
 
diff --git a/src/cmd/internal/obj/riscv/obj.go b/src/cmd/internal/obj/riscv/obj.go
index 5ef334dd6a..d104f1cfa5 100644
--- a/src/cmd/internal/obj/riscv/obj.go
+++ b/src/cmd/internal/obj/riscv/obj.go
@@ -25,6 +25,7 @@ import (
 	"cmd/internal/objabi"
 	"cmd/internal/sys"
 	"fmt"
+	"log"
 )
 
 func buildop(ctxt *obj.Link) {}
@@ -716,6 +717,21 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 				p.Spadj = int32(-p.From.Offset)
 			}
 		}
+
+		if p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP && p.Spadj == 0 {
+			f := cursym.Func()
+			if f.FuncFlag&objabi.FuncFlag_SPWRITE == 0 {
+				f.FuncFlag |= objabi.FuncFlag_SPWRITE
+				if ctxt.Debugvlog || !ctxt.IsAsm {
+					ctxt.Logf("auto-SPWRITE: %s %v\n", cursym.Name, p)
+					if !ctxt.IsAsm {
+						ctxt.Diag("invalid auto-SPWRITE in non-assembly")
+						ctxt.DiagFlush()
+						log.Fatalf("bad SPWRITE")
+					}
+				}
+			}
+		}
 	}
 
 	// Rewrite MOV pseudo-instructions. This cannot be done in
diff --git a/src/cmd/internal/obj/s390x/objz.go b/src/cmd/internal/obj/s390x/objz.go
index 970cf827d6..a02c4fc17f 100644
--- a/src/cmd/internal/obj/s390x/objz.go
+++ b/src/cmd/internal/obj/s390x/objz.go
@@ -33,6 +33,7 @@ import (
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
 	"cmd/internal/sys"
+	"log"
 	"math"
 )
 
@@ -545,6 +546,21 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 				p.From.Reg = REGSP
 			}
 		}
+
+		if p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP && p.Spadj == 0 {
+			f := c.cursym.Func()
+			if f.FuncFlag&objabi.FuncFlag_SPWRITE == 0 {
+				c.cursym.Func().FuncFlag |= objabi.FuncFlag_SPWRITE
+				if ctxt.Debugvlog || !ctxt.IsAsm {
+					ctxt.Logf("auto-SPWRITE: %s\n", c.cursym.Name)
+					if !ctxt.IsAsm {
+						ctxt.Diag("invalid auto-SPWRITE in non-assembly")
+						ctxt.DiagFlush()
+						log.Fatalf("bad SPWRITE")
+					}
+				}
+			}
+		}
 	}
 	if wasSplit {
 		c.stacksplitPost(pLast, pPre, pPreempt, autosize) // emit post part of split check
diff --git a/src/cmd/internal/obj/util.go b/src/cmd/internal/obj/util.go
index b9bacb7a22..1c34b4e833 100644
--- a/src/cmd/internal/obj/util.go
+++ b/src/cmd/internal/obj/util.go
@@ -187,7 +187,7 @@ func (p *Prog) WriteInstructionString(w io.Writer) {
 		// In short, print one of these two:
 		// TEXT	foo(SB), DUPOK|NOSPLIT, $0
 		// TEXT	foo(SB), $0
-		s := p.From.Sym.Attribute.TextAttrString()
+		s := p.From.Sym.TextAttrString()
 		if s != "" {
 			fmt.Fprintf(w, "%s%s", sep, s)
 			sep = ", "
diff --git a/src/cmd/internal/obj/x86/obj6.go b/src/cmd/internal/obj/x86/obj6.go
index 84de58a4c4..bc3a3b4bbe 100644
--- a/src/cmd/internal/obj/x86/obj6.go
+++ b/src/cmd/internal/obj/x86/obj6.go
@@ -35,6 +35,7 @@ import (
 	"cmd/internal/objabi"
 	"cmd/internal/src"
 	"cmd/internal/sys"
+	"log"
 	"math"
 	"strings"
 )
@@ -839,6 +840,20 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 
 		switch p.As {
 		default:
+			if p.To.Type == obj.TYPE_REG && p.To.Reg == REG_SP && p.As != ACMPL && p.As != ACMPQ {
+				f := cursym.Func()
+				if f.FuncFlag&objabi.FuncFlag_SPWRITE == 0 {
+					f.FuncFlag |= objabi.FuncFlag_SPWRITE
+					if ctxt.Debugvlog || !ctxt.IsAsm {
+						ctxt.Logf("auto-SPWRITE: %s %v\n", cursym.Name, p)
+						if !ctxt.IsAsm {
+							ctxt.Diag("invalid auto-SPWRITE in non-assembly")
+							ctxt.DiagFlush()
+							log.Fatalf("bad SPWRITE")
+						}
+					}
+				}
+			}
 			continue
 
 		case APUSHL, APUSHFL:
diff --git a/src/cmd/internal/objabi/funcid.go b/src/cmd/internal/objabi/funcid.go
index e921a82c0c..6e188e31bb 100644
--- a/src/cmd/internal/objabi/funcid.go
+++ b/src/cmd/internal/objabi/funcid.go
@@ -6,13 +6,22 @@ package objabi
 
 import "strings"
 
+// A FuncFlag records bits about a function, passed to the runtime.
+type FuncFlag uint8
+
+// Note: This list must match the list in runtime/symtab.go.
+const (
+	FuncFlag_TOPFRAME = 1 << iota
+	FuncFlag_SPWRITE
+)
+
 // A FuncID identifies particular functions that need to be treated
 // specially by the runtime.
 // Note that in some situations involving plugins, there may be multiple
 // copies of a particular special runtime function.
-// Note: this list must match the list in runtime/symtab.go.
 type FuncID uint8
 
+// Note: this list must match the list in runtime/symtab.go.
 const (
 	FuncID_normal FuncID = iota // not a special function
 	FuncID_asmcgocall
diff --git a/src/cmd/link/internal/ld/dwarf.go b/src/cmd/link/internal/ld/dwarf.go
index 2ab9a55e96..561f6f1475 100644
--- a/src/cmd/link/internal/ld/dwarf.go
+++ b/src/cmd/link/internal/ld/dwarf.go
@@ -1454,7 +1454,7 @@ func (d *dwctxt) writeframes(fs loader.Sym) dwarfSecInfo {
 		// Emit a FDE, Section 6.4.1.
 		// First build the section contents into a byte buffer.
 		deltaBuf = deltaBuf[:0]
-		if haslr && d.ldr.AttrTopFrame(fn) {
+		if haslr && fi.TopFrame() {
 			// Mark the link register as having an undefined value.
 			// This stops call stack unwinders progressing any further.
 			// TODO: similar mark on non-LR architectures.
@@ -1480,7 +1480,7 @@ func (d *dwctxt) writeframes(fs loader.Sym) dwarfSecInfo {
 				spdelta += int64(d.arch.PtrSize)
 			}
 
-			if haslr && !d.ldr.AttrTopFrame(fn) {
+			if haslr && !fi.TopFrame() {
 				// TODO(bryanpkc): This is imprecise. In general, the instruction
 				// that stores the return address to the stack frame is not the
 				// same one that allocates the frame.
diff --git a/src/cmd/link/internal/ld/pcln.go b/src/cmd/link/internal/ld/pcln.go
index 72bf33e611..fb733117be 100644
--- a/src/cmd/link/internal/ld/pcln.go
+++ b/src/cmd/link/internal/ld/pcln.go
@@ -796,7 +796,14 @@ func writeFuncs(ctxt *Link, sb *loader.SymbolBuilder, funcs []loader.Sym, inlSym
 		}
 		off = uint32(sb.SetUint8(ctxt.Arch, int64(off), uint8(funcID)))
 
-		off += 2 // pad
+		// flag uint8
+		var flag objabi.FuncFlag
+		if fi.Valid() {
+			flag = fi.FuncFlag()
+		}
+		off = uint32(sb.SetUint8(ctxt.Arch, int64(off), uint8(flag)))
+
+		off += 1 // pad
 
 		// nfuncdata must be the final entry.
 		funcdata, funcdataoff = funcData(fi, 0, funcdata, funcdataoff)
diff --git a/src/cmd/link/internal/loader/loader.go b/src/cmd/link/internal/loader/loader.go
index 98c2131c2b..68dc3de273 100644
--- a/src/cmd/link/internal/loader/loader.go
+++ b/src/cmd/link/internal/loader/loader.go
@@ -241,7 +241,6 @@ type Loader struct {
 	attrExternal         Bitmap // external symbols, indexed by ext sym index
 
 	attrReadOnly         map[Sym]bool     // readonly data for this sym
-	attrTopFrame         map[Sym]struct{} // top frame symbols
 	attrSpecial          map[Sym]struct{} // "special" frame symbols
 	attrCgoExportDynamic map[Sym]struct{} // "cgo_export_dynamic" symbols
 	attrCgoExportStatic  map[Sym]struct{} // "cgo_export_static" symbols
@@ -349,7 +348,6 @@ func NewLoader(flags uint32, elfsetstring elfsetstringFunc, reporter *ErrorRepor
 		plt:                  make(map[Sym]int32),
 		got:                  make(map[Sym]int32),
 		dynid:                make(map[Sym]int32),
-		attrTopFrame:         make(map[Sym]struct{}),
 		attrSpecial:          make(map[Sym]struct{}),
 		attrCgoExportDynamic: make(map[Sym]struct{}),
 		attrCgoExportStatic:  make(map[Sym]struct{}),
@@ -1009,24 +1007,6 @@ func (l *Loader) SetAttrExternal(i Sym, v bool) {
 	}
 }
 
-// AttrTopFrame returns true for a function symbol that is an entry
-// point, meaning that unwinders should stop when they hit this
-// function.
-func (l *Loader) AttrTopFrame(i Sym) bool {
-	_, ok := l.attrTopFrame[i]
-	return ok
-}
-
-// SetAttrTopFrame sets the "top frame" property for a symbol (see
-// AttrTopFrame).
-func (l *Loader) SetAttrTopFrame(i Sym, v bool) {
-	if v {
-		l.attrTopFrame[i] = struct{}{}
-	} else {
-		delete(l.attrTopFrame, i)
-	}
-}
-
 // AttrSpecial returns true for a symbols that do not have their
 // address (i.e. Value) computed by the usual mechanism of
 // data.go:dodata() & data.go:address().
@@ -1905,7 +1885,11 @@ func (fi *FuncInfo) Locals() int {
 }
 
 func (fi *FuncInfo) FuncID() objabi.FuncID {
-	return objabi.FuncID((*goobj.FuncInfo)(nil).ReadFuncID(fi.data))
+	return (*goobj.FuncInfo)(nil).ReadFuncID(fi.data)
+}
+
+func (fi *FuncInfo) FuncFlag() objabi.FuncFlag {
+	return (*goobj.FuncInfo)(nil).ReadFuncFlag(fi.data)
 }
 
 func (fi *FuncInfo) Pcsp() Sym {
@@ -1992,6 +1976,13 @@ func (fi *FuncInfo) File(k int) goobj.CUFileIndex {
 	return (*goobj.FuncInfo)(nil).ReadFile(fi.data, fi.lengths.FileOff, uint32(k))
 }
 
+// TopFrame returns true if the function associated with this FuncInfo
+// is an entry point, meaning that unwinders should stop when they hit
+// this function.
+func (fi *FuncInfo) TopFrame() bool {
+	return (fi.FuncFlag() & objabi.FuncFlag_TOPFRAME) != 0
+}
+
 type InlTreeNode struct {
 	Parent   int32
 	File     goobj.CUFileIndex
@@ -2151,9 +2142,6 @@ func (st *loadState) preloadSyms(r *oReader, kind int) {
 		}
 		gi := st.addSym(name, v, r, i, kind, osym)
 		r.syms[i] = gi
-		if osym.TopFrame() {
-			l.SetAttrTopFrame(gi, true)
-		}
 		if osym.Local() {
 			l.SetAttrLocal(gi, true)
 		}
@@ -2411,7 +2399,6 @@ func (l *Loader) CopyAttributes(src Sym, dst Sym) {
 		// when copying attributes from a dupOK ABI wrapper symbol to
 		// the real target symbol (which may not be marked dupOK).
 	}
-	l.SetAttrTopFrame(dst, l.AttrTopFrame(src))
 	l.SetAttrSpecial(dst, l.AttrSpecial(src))
 	l.SetAttrCgoExportDynamic(dst, l.AttrCgoExportDynamic(src))
 	l.SetAttrCgoExportStatic(dst, l.AttrCgoExportStatic(src))
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index 675c613b6e..05520d07b2 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -833,10 +833,11 @@ type _func struct {
 	pcfile    uint32
 	pcln      uint32
 	npcdata   uint32
-	cuOffset  uint32  // runtime.cutab offset of this function's CU
-	funcID    funcID  // set for certain special runtime functions
-	_         [2]byte // pad
-	nfuncdata uint8   // must be last
+	cuOffset  uint32 // runtime.cutab offset of this function's CU
+	funcID    funcID // set for certain special runtime functions
+	flag      funcFlag
+	_         [1]byte // pad
+	nfuncdata uint8   // must be last, must end on a uint32-aligned boundary
 }
 
 // Pseudo-Func that is returned for PCs that occur in inlined code.
diff --git a/src/runtime/symtab.go b/src/runtime/symtab.go
index fc93c00c2d..d7da255e43 100644
--- a/src/runtime/symtab.go
+++ b/src/runtime/symtab.go
@@ -332,6 +332,15 @@ const (
 	funcID_wrapper // any autogenerated code (hash/eq algorithms, method wrappers, etc.)
 )
 
+// A FuncFlag holds bits about a function.
+// This list must match the list in cmd/internal/objabi/funcid.go.
+type funcFlag uint8
+
+const (
+	funcFlag_TOPFRAME funcFlag = 1 << iota
+	funcFlag_SPWRITE
+)
+
 // pcHeader holds data used by the pclntab lookups.
 type pcHeader struct {
 	magic          uint32  // 0xFFFFFFFA
-- 
GitLab


From fbe74dbf4263841819368a2a3c90e599392e0808 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 28 Jan 2021 16:10:58 -0500
Subject: [PATCH 0693/2400] runtime: use FuncInfo SPWRITE flag to identify
 untraceable profile samples

The old code was very clever about predicting whether a traceback was safe.
That cleverness has not aged well. In particular, the setsSP function is missing
a bunch of functions that write to SP and will confuse traceback.
And one such function - jmpdefer - was handled as a special case in
gentraceback instead of simply listing it in setsSP.

Throw away all the clever prediction about whether traceback will crash.
Instead, make traceback NOT crash, by checking whether the function
being walked writes to SP.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.
This CL is, however, not windows/arm64-specific.
It is cleanup meant to make the port (and future ports) easier.

Change-Id: I3d55fe257a22745e4919ac4dc9a9378c984ba0da
Reviewed-on: https://go-review.googlesource.com/c/go/+/288801
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/asm_arm.s           |  4 --
 src/runtime/pprof/pprof_test.go | 18 +++++--
 src/runtime/proc.go             | 95 +--------------------------------
 src/runtime/traceback.go        | 52 +++++++++---------
 4 files changed, 42 insertions(+), 127 deletions(-)

diff --git a/src/runtime/asm_arm.s b/src/runtime/asm_arm.s
index 92d7854306..4620f19074 100644
--- a/src/runtime/asm_arm.s
+++ b/src/runtime/asm_arm.s
@@ -506,10 +506,6 @@ CALLFN(·call1073741824, 1073741824)
 // 1. grab stored LR for caller
 // 2. sub 4 bytes to get back to BL deferreturn
 // 3. B to fn
-// TODO(rsc): Push things on stack and then use pop
-// to load all registers simultaneously, so that a profiling
-// interrupt can never see mismatched SP/LR/PC.
-// (And double-check that pop is atomic in that way.)
 TEXT runtime·jmpdefer(SB),NOSPLIT,$0-8
 	MOVW	0(R13), LR
 	MOVW	$-4(LR), LR	// BL deferreturn
diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go
index b6ee160e84..37f12de0d9 100644
--- a/src/runtime/pprof/pprof_test.go
+++ b/src/runtime/pprof/pprof_test.go
@@ -514,8 +514,10 @@ func TestGoroutineSwitch(t *testing.T) {
 		}
 		StopCPUProfile()
 
-		// Read profile to look for entries for runtime.gogo with an attempt at a traceback.
-		// The special entry
+		// Read profile to look for entries for gogo with an attempt at a traceback.
+		// "runtime.gogo" is OK, because that's the part of the context switch
+		// before the actual switch begins. But we should not see "gogo",
+		// aka "gogo<>(SB)", which does the actual switch and is marked SPWRITE.
 		parseProfile(t, prof.Bytes(), func(count uintptr, stk []*profile.Location, _ map[string][]string) {
 			// An entry with two frames with 'System' in its top frame
 			// exists to record a PC without a traceback. Those are okay.
@@ -526,13 +528,19 @@ func TestGoroutineSwitch(t *testing.T) {
 				}
 			}
 
-			// Otherwise, should not see runtime.gogo.
+			// An entry with just one frame is OK too:
+			// it knew to stop at gogo.
+			if len(stk) == 1 {
+				return
+			}
+
+			// Otherwise, should not see gogo.
 			// The place we'd see it would be the inner most frame.
 			name := stk[0].Line[0].Function.Name
-			if name == "runtime.gogo" {
+			if name == "gogo" {
 				var buf bytes.Buffer
 				fprintStack(&buf, stk)
-				t.Fatalf("found profile entry for runtime.gogo:\n%s", buf.String())
+				t.Fatalf("found profile entry for gogo:\n%s", buf.String())
 			}
 		})
 	}
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 388d843004..e6670135db 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -4420,75 +4420,6 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
 	// See golang.org/issue/17165.
 	getg().m.mallocing++
 
-	// Define that a "user g" is a user-created goroutine, and a "system g"
-	// is one that is m->g0 or m->gsignal.
-	//
-	// We might be interrupted for profiling halfway through a
-	// goroutine switch. The switch involves updating three (or four) values:
-	// g, PC, SP, and (on arm) LR. The PC must be the last to be updated,
-	// because once it gets updated the new g is running.
-	//
-	// When switching from a user g to a system g, LR is not considered live,
-	// so the update only affects g, SP, and PC. Since PC must be last, there
-	// the possible partial transitions in ordinary execution are (1) g alone is updated,
-	// (2) both g and SP are updated, and (3) SP alone is updated.
-	// If SP or g alone is updated, we can detect the partial transition by checking
-	// whether the SP is within g's stack bounds. (We could also require that SP
-	// be changed only after g, but the stack bounds check is needed by other
-	// cases, so there is no need to impose an additional requirement.)
-	//
-	// There is one exceptional transition to a system g, not in ordinary execution.
-	// When a signal arrives, the operating system starts the signal handler running
-	// with an updated PC and SP. The g is updated last, at the beginning of the
-	// handler. There are two reasons this is okay. First, until g is updated the
-	// g and SP do not match, so the stack bounds check detects the partial transition.
-	// Second, signal handlers currently run with signals disabled, so a profiling
-	// signal cannot arrive during the handler.
-	//
-	// When switching from a system g to a user g, there are three possibilities.
-	//
-	// First, it may be that the g switch has no PC update, because the SP
-	// either corresponds to a user g throughout (as in asmcgocall)
-	// or because it has been arranged to look like a user g frame
-	// (as in cgocallback). In this case, since the entire
-	// transition is a g+SP update, a partial transition updating just one of
-	// those will be detected by the stack bounds check.
-	//
-	// Second, when returning from a signal handler, the PC and SP updates
-	// are performed by the operating system in an atomic update, so the g
-	// update must be done before them. The stack bounds check detects
-	// the partial transition here, and (again) signal handlers run with signals
-	// disabled, so a profiling signal cannot arrive then anyway.
-	//
-	// Third, the common case: it may be that the switch updates g, SP, and PC
-	// separately. If the PC is within any of the functions that does this,
-	// we don't ask for a traceback. C.F. the function setsSP for more about this.
-	//
-	// There is another apparently viable approach, recorded here in case
-	// the "PC within setsSP function" check turns out not to be usable.
-	// It would be possible to delay the update of either g or SP until immediately
-	// before the PC update instruction. Then, because of the stack bounds check,
-	// the only problematic interrupt point is just before that PC update instruction,
-	// and the sigprof handler can detect that instruction and simulate stepping past
-	// it in order to reach a consistent state. On ARM, the update of g must be made
-	// in two places (in R10 and also in a TLS slot), so the delayed update would
-	// need to be the SP update. The sigprof handler must read the instruction at
-	// the current PC and if it was the known instruction (for example, JMP BX or
-	// MOV R2, PC), use that other register in place of the PC value.
-	// The biggest drawback to this solution is that it requires that we can tell
-	// whether it's safe to read from the memory pointed at by PC.
-	// In a correct program, we can test PC == nil and otherwise read,
-	// but if a profiling signal happens at the instant that a program executes
-	// a bad jump (before the program manages to handle the resulting fault)
-	// the profiling handler could fault trying to read nonexistent memory.
-	//
-	// To recap, there are no constraints on the assembly being used for the
-	// transition. We simply require that g and SP match and that the PC is not
-	// in gogo.
-	traceback := true
-	if gp == nil || sp < gp.stack.lo || gp.stack.hi < sp || setsSP(pc) || (mp != nil && mp.vdsoSP != 0) {
-		traceback = false
-	}
 	var stk [maxCPUProfStack]uintptr
 	n := 0
 	if mp.ncgo > 0 && mp.curg != nil && mp.curg.syscallpc != 0 && mp.curg.syscallsp != 0 {
@@ -4511,7 +4442,7 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
 		if n > 0 {
 			n += cgoOff
 		}
-	} else if traceback {
+	} else {
 		n = gentraceback(pc, sp, lr, gp, 0, &stk[0], len(stk), nil, nil, _TraceTrap|_TraceJumpStack)
 	}
 
@@ -4590,30 +4521,6 @@ func sigprofNonGoPC(pc uintptr) {
 	}
 }
 
-// Reports whether a function will set the SP
-// to an absolute value. Important that
-// we don't traceback when these are at the bottom
-// of the stack since we can't be sure that we will
-// find the caller.
-//
-// If the function is not on the bottom of the stack
-// we assume that it will have set it up so that traceback will be consistent,
-// either by being a traceback terminating function
-// or putting one on the stack at the right offset.
-func setsSP(pc uintptr) bool {
-	f := findfunc(pc)
-	if !f.valid() {
-		// couldn't find the function for this PC,
-		// so assume the worst and stop traceback
-		return true
-	}
-	switch f.funcID {
-	case funcID_gogo, funcID_systemstack, funcID_mcall, funcID_morestack:
-		return true
-	}
-	return false
-}
-
 // setcpuprofilerate sets the CPU profiling rate to hz times per second.
 // If hz <= 0, setcpuprofilerate turns off CPU profiling.
 func setcpuprofilerate(hz int32) {
diff --git a/src/runtime/traceback.go b/src/runtime/traceback.go
index 127f54e42e..18d8a42854 100644
--- a/src/runtime/traceback.go
+++ b/src/runtime/traceback.go
@@ -15,24 +15,9 @@ import (
 // The most important fact about a given architecture is whether it uses a link register.
 // On systems with link registers, the prologue for a non-leaf function stores the
 // incoming value of LR at the bottom of the newly allocated stack frame.
-// On systems without link registers, the architecture pushes a return PC during
+// On systems without link registers (x86), the architecture pushes a return PC during
 // the call instruction, so the return PC ends up above the stack frame.
 // In this file, the return PC is always called LR, no matter how it was found.
-//
-// To date, the opposite of a link register architecture is an x86 architecture.
-// This code may need to change if some other kind of non-link-register
-// architecture comes along.
-//
-// The other important fact is the size of a pointer: on 32-bit systems the LR
-// takes up only 4 bytes on the stack, while on 64-bit systems it takes up 8 bytes.
-// Typically this is ptrSize.
-//
-// As an exception, amd64p32 had ptrSize == 4 but the CALL instruction still
-// stored an 8-byte return PC onto the stack. To accommodate this, we used regSize
-// as the size of the architecture-pushed return PC.
-//
-// usesLR is defined below in terms of minFrameSize, which is defined in
-// arch_$GOARCH.go. ptrSize and regSize are defined in stubs.go.
 
 const usesLR = sys.MinFrameSize > 0
 
@@ -180,6 +165,16 @@ func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max in
 			break
 		}
 
+		// Compute function info flags.
+		flag := f.flag
+		if f.funcID == funcID_cgocallback {
+			// cgocallback does write SP to switch from the g0 to the curg stack,
+			// but it carefully arranges that during the transition BOTH stacks
+			// have cgocallback frame valid for unwinding through.
+			// So we don't need to exclude it with the other SP-writing functions.
+			flag &^= funcFlag_SPWRITE
+		}
+
 		// Found an actual function.
 		// Derive frame pointer and link register.
 		if frame.fp == 0 {
@@ -196,6 +191,7 @@ func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max in
 					frame.pc = gp.m.curg.sched.pc
 					frame.fn = findfunc(frame.pc)
 					f = frame.fn
+					flag = f.flag
 					frame.sp = gp.m.curg.sched.sp
 					cgoCtxt = gp.m.curg.cgoCtxt
 				case funcID_systemstack:
@@ -203,6 +199,7 @@ func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max in
 					// stack transition.
 					frame.sp = gp.m.curg.sched.sp
 					cgoCtxt = gp.m.curg.cgoCtxt
+					flag &^= funcFlag_SPWRITE
 				}
 			}
 			frame.fp = frame.sp + uintptr(funcspdelta(f, frame.pc, &cache))
@@ -213,19 +210,26 @@ func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max in
 		}
 		var flr funcInfo
 		if topofstack(f, gp.m != nil && gp == gp.m.g0) {
+			// This function marks the top of the stack. Stop the traceback.
 			frame.lr = 0
 			flr = funcInfo{}
-		} else if usesLR && f.funcID == funcID_jmpdefer {
-			// jmpdefer modifies SP/LR/PC non-atomically.
-			// If a profiling interrupt arrives during jmpdefer,
-			// the stack unwind may see a mismatched register set
-			// and get confused. Stop if we see PC within jmpdefer
-			// to avoid that confusion.
-			// See golang.org/issue/8153.
+		} else if flag&funcFlag_SPWRITE != 0 {
+			// The function we are in does a write to SP that we don't know
+			// how to encode in the spdelta table. Examples include context
+			// switch routines like runtime.gogo but also any code that switches
+			// to the g0 stack to run host C code. Since we can't reliably unwind
+			// the SP (we might not even be on the stack we think we are),
+			// we stop the traceback here.
 			if callback != nil {
-				throw("traceback_arm: found jmpdefer when tracing with callback")
+				// Finding an SPWRITE should only happen for a profiling signal, which can
+				// arrive at any time. For a GC stack traversal (callback != nil),
+				// we shouldn't see this case, and we must be sure to walk the
+				// entire stack or the GC is invalid. So crash.
+				println("traceback: unexpected SPWRITE function", funcname(f))
+				throw("traceback")
 			}
 			frame.lr = 0
+			flr = funcInfo{}
 		} else {
 			var lrPtr uintptr
 			if usesLR {
-- 
GitLab


From 54da3ab385686dec5554164ba9558214445deec9 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 28 Jan 2021 16:22:52 -0500
Subject: [PATCH 0694/2400] runtime: use TOPFRAME to identify top-of-frame
 functions

No change to actual runtime, but helps reduce the laundry list
of functions.

mcall, morestack, and asmcgocall are not actually top-of-frame,
so those need more attention in follow-up CLs.

mstart moved to assembly so that it can be marked TOPFRAME.

Since TOPFRAME also tells DWARF consumers not to unwind
this way, this change should also improve debuggers a
marginal amount.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.
This CL is, however, not windows/arm64-specific.
It is cleanup meant to make the port (and future ports) easier.

Change-Id: If1e0d46ca973de5e46b62948d076f675f285b5d9
Reviewed-on: https://go-review.googlesource.com/c/go/+/288802
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/asm_386.s           | 8 ++++++--
 src/runtime/asm_amd64.s         | 8 ++++++--
 src/runtime/asm_arm.s           | 6 +++++-
 src/runtime/asm_arm64.s         | 6 +++++-
 src/runtime/asm_mips64x.s       | 6 +++++-
 src/runtime/asm_mipsx.s         | 6 +++++-
 src/runtime/asm_ppc64x.s        | 6 +++++-
 src/runtime/asm_riscv64.s       | 6 +++++-
 src/runtime/asm_s390x.s         | 6 +++++-
 src/runtime/asm_wasm.s          | 8 ++++++--
 src/runtime/proc.go             | 7 +++++--
 src/runtime/sys_windows_386.s   | 2 +-
 src/runtime/sys_windows_amd64.s | 2 +-
 src/runtime/sys_windows_arm.s   | 2 +-
 src/runtime/traceback.go        | 5 +----
 15 files changed, 62 insertions(+), 22 deletions(-)

diff --git a/src/runtime/asm_386.s b/src/runtime/asm_386.s
index fcf74a03cf..5b0852f780 100644
--- a/src/runtime/asm_386.s
+++ b/src/runtime/asm_386.s
@@ -89,7 +89,7 @@ GLOBL _rt0_386_lib_argc<>(SB),NOPTR, $4
 DATA _rt0_386_lib_argv<>(SB)/4, $0
 GLOBL _rt0_386_lib_argv<>(SB),NOPTR, $4
 
-TEXT runtime·rt0_go(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·rt0_go(SB),NOSPLIT|NOFRAME|TOPFRAME,$0
 	// Copy arguments forward on an even stack.
 	// Users of this function jump to it, they don't call it.
 	MOVL	0(SP), AX
@@ -269,6 +269,10 @@ TEXT runtime·asminit(SB),NOSPLIT,$0-0
 	FLDCW	runtime·controlWord64(SB)
 	RET
 
+TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
+	CALL	runtime·mstart0(SB)
+	RET // not reached
+
 /*
  *  go-routine
  */
@@ -1307,7 +1311,7 @@ TEXT _cgo_topofstack(SB),NOSPLIT,$0
 
 // The top-most function running on a goroutine
 // returns to goexit+PCQuantum.
-TEXT runtime·goexit(SB),NOSPLIT,$0-0
+TEXT runtime·goexit(SB),NOSPLIT|TOPFRAME,$0-0
 	BYTE	$0x90	// NOP
 	CALL	runtime·goexit1(SB)	// does not return
 	// traceback from goexit1 must hit code range of goexit
diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index 8ee2ac2123..a68dc72ae5 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -84,7 +84,7 @@ GLOBL _rt0_amd64_lib_argc<>(SB),NOPTR, $8
 DATA _rt0_amd64_lib_argv<>(SB)/8, $0
 GLOBL _rt0_amd64_lib_argv<>(SB),NOPTR, $8
 
-TEXT runtime·rt0_go(SB),NOSPLIT,$0
+TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
 	// copy arguments forward on an even stack
 	MOVQ	DI, AX		// argc
 	MOVQ	SI, BX		// argv
@@ -250,6 +250,10 @@ TEXT runtime·asminit(SB),NOSPLIT,$0-0
 	// No per-thread init.
 	RET
 
+TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
+	CALL	runtime·mstart0(SB)
+	RET // not reached
+
 /*
  *  go-routine
  */
@@ -1440,7 +1444,7 @@ TEXT _cgo_topofstack(SB),NOSPLIT,$0
 // so as to make it identifiable to traceback (this
 // function it used as a sentinel; traceback wants to
 // see the func PC, not a wrapper PC).
-TEXT runtime·goexit<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT runtime·goexit<ABIInternal>(SB),NOSPLIT|TOPFRAME,$0-0
 	BYTE	$0x90	// NOP
 	CALL	runtime·goexit1(SB)	// does not return
 	// traceback from goexit1 must hit code range of goexit
diff --git a/src/runtime/asm_arm.s b/src/runtime/asm_arm.s
index 4620f19074..f9535bb1bc 100644
--- a/src/runtime/asm_arm.s
+++ b/src/runtime/asm_arm.s
@@ -112,7 +112,7 @@ GLOBL _rt0_arm_lib_argv<>(SB),NOPTR,$4
 
 // using NOFRAME means do not save LR on stack.
 // argc is in R0, argv is in R1.
-TEXT runtime·rt0_go(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·rt0_go(SB),NOSPLIT|NOFRAME|TOPFRAME,$0
 	MOVW	$0xcafebabe, R12
 
 	// copy arguments forward on an even stack
@@ -202,6 +202,10 @@ TEXT runtime·asminit(SB),NOSPLIT,$0-0
 	WORD	$0xeee1ba10	// vmsr fpscr, r11
 	RET
 
+TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
+	BL	runtime·mstart0(SB)
+	RET // not reached
+
 /*
  *  go-routine
  */
diff --git a/src/runtime/asm_arm64.s b/src/runtime/asm_arm64.s
index 4f0a680fa4..d81759537e 100644
--- a/src/runtime/asm_arm64.s
+++ b/src/runtime/asm_arm64.s
@@ -8,7 +8,7 @@
 #include "funcdata.h"
 #include "textflag.h"
 
-TEXT runtime·rt0_go(SB),NOSPLIT,$0
+TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
 	// SP = stack; R0 = argc; R1 = argv
 
 	SUB	$32, RSP
@@ -109,6 +109,10 @@ TEXT runtime·breakpoint(SB),NOSPLIT|NOFRAME,$0-0
 TEXT runtime·asminit(SB),NOSPLIT|NOFRAME,$0-0
 	RET
 
+TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
+	BL	runtime·mstart0(SB)
+	RET // not reached
+
 /*
  *  go-routine
  */
diff --git a/src/runtime/asm_mips64x.s b/src/runtime/asm_mips64x.s
index f6d8931a15..af27b9b555 100644
--- a/src/runtime/asm_mips64x.s
+++ b/src/runtime/asm_mips64x.s
@@ -11,7 +11,7 @@
 
 #define	REGCTXT	R22
 
-TEXT runtime·rt0_go(SB),NOSPLIT,$0
+TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
 	// R29 = stack; R4 = argc; R5 = argv
 
 	ADDV	$-24, R29
@@ -85,6 +85,10 @@ TEXT runtime·breakpoint(SB),NOSPLIT|NOFRAME,$0-0
 TEXT runtime·asminit(SB),NOSPLIT|NOFRAME,$0-0
 	RET
 
+TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
+	JAL	runtime·mstart0(SB)
+	RET // not reached
+
 /*
  *  go-routine
  */
diff --git a/src/runtime/asm_mipsx.s b/src/runtime/asm_mipsx.s
index cf4b1b42cc..0c7d28dcf7 100644
--- a/src/runtime/asm_mipsx.s
+++ b/src/runtime/asm_mipsx.s
@@ -11,7 +11,7 @@
 
 #define	REGCTXT	R22
 
-TEXT runtime·rt0_go(SB),NOSPLIT,$0
+TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
 	// R29 = stack; R4 = argc; R5 = argv
 
 	ADDU	$-12, R29
@@ -86,6 +86,10 @@ TEXT runtime·breakpoint(SB),NOSPLIT,$0-0
 TEXT runtime·asminit(SB),NOSPLIT,$0-0
 	RET
 
+TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
+	JAL	runtime·mstart0(SB)
+	RET // not reached
+
 /*
  *  go-routine
  */
diff --git a/src/runtime/asm_ppc64x.s b/src/runtime/asm_ppc64x.s
index 90f14d8e54..56e73742ea 100644
--- a/src/runtime/asm_ppc64x.s
+++ b/src/runtime/asm_ppc64x.s
@@ -16,7 +16,7 @@
 #define cgoCalleeStackSize 32
 #endif
 
-TEXT runtime·rt0_go(SB),NOSPLIT,$0
+TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
 	// R1 = stack; R3 = argc; R4 = argv; R13 = C TLS base pointer
 
 	// initialize essential registers
@@ -124,6 +124,10 @@ TEXT runtime·reginit(SB),NOSPLIT|NOFRAME,$0-0
 	XOR R0, R0
 	RET
 
+TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
+	BL	runtime·mstart0(SB)
+	RET // not reached
+
 /*
  *  go-routine
  */
diff --git a/src/runtime/asm_riscv64.s b/src/runtime/asm_riscv64.s
index d06c77b948..30f2bd2e4a 100644
--- a/src/runtime/asm_riscv64.s
+++ b/src/runtime/asm_riscv64.s
@@ -7,7 +7,7 @@
 #include "textflag.h"
 
 // func rt0_go()
-TEXT runtime·rt0_go(SB),NOSPLIT,$0
+TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
 	// X2 = stack; A0 = argc; A1 = argv
 	ADD	$-24, X2
 	MOV	A0, 8(X2)	// argc
@@ -70,6 +70,10 @@ nocgo:
 	WORD $0 // crash if reached
 	RET
 
+TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
+	CALL	runtime·mstart0(SB)
+	RET // not reached
+
 // void setg_gcc(G*); set g called from gcc with g in A0
 TEXT setg_gcc<>(SB),NOSPLIT,$0-0
 	MOV	A0, g
diff --git a/src/runtime/asm_s390x.s b/src/runtime/asm_s390x.s
index 203754f32c..f9fb1a4c55 100644
--- a/src/runtime/asm_s390x.s
+++ b/src/runtime/asm_s390x.s
@@ -84,7 +84,7 @@ GLOBL _rt0_s390x_lib_argc<>(SB), NOPTR, $8
 DATA _rt0_s90x_lib_argv<>(SB)/8, $0
 GLOBL _rt0_s390x_lib_argv<>(SB), NOPTR, $8
 
-TEXT runtime·rt0_go(SB),NOSPLIT,$0
+TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
 	// R2 = argc; R3 = argv; R11 = temp; R13 = g; R15 = stack pointer
 	// C TLS base pointer in AR0:AR1
 
@@ -170,6 +170,10 @@ TEXT runtime·breakpoint(SB),NOSPLIT|NOFRAME,$0-0
 TEXT runtime·asminit(SB),NOSPLIT|NOFRAME,$0-0
 	RET
 
+TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
+	CALL	runtime·mstart0(SB)
+	RET // not reached
+
 /*
  *  go-routine
  */
diff --git a/src/runtime/asm_wasm.s b/src/runtime/asm_wasm.s
index 3765c756b3..33c335ba5a 100644
--- a/src/runtime/asm_wasm.s
+++ b/src/runtime/asm_wasm.s
@@ -7,7 +7,7 @@
 #include "funcdata.h"
 #include "textflag.h"
 
-TEXT runtime·rt0_go(SB), NOSPLIT|NOFRAME, $0
+TEXT runtime·rt0_go(SB), NOSPLIT|NOFRAME|TOPFRAME, $0
 	// save m->g0 = g0
 	MOVD $runtime·g0(SB), runtime·m0+m_g0(SB)
 	// save m0 to g0->m
@@ -24,6 +24,10 @@ TEXT runtime·rt0_go(SB), NOSPLIT|NOFRAME, $0
 	CALL runtime·mstart(SB) // WebAssembly stack will unwind when switching to another goroutine
 	UNDEF
 
+TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
+	CALL	runtime·mstart0(SB)
+	RET // not reached
+
 DATA  runtime·mainPC+0(SB)/8,$runtime·main(SB)
 GLOBL runtime·mainPC(SB),RODATA,$8
 
@@ -424,7 +428,7 @@ CALLFN(·call268435456, 268435456)
 CALLFN(·call536870912, 536870912)
 CALLFN(·call1073741824, 1073741824)
 
-TEXT runtime·goexit(SB), NOSPLIT, $0-0
+TEXT runtime·goexit(SB), NOSPLIT|TOPFRAME, $0-0
 	NOP // first PC of goexit is skipped
 	CALL runtime·goexit1(SB) // does not return
 	UNDEF
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index e6670135db..ccfe085691 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -1234,7 +1234,10 @@ func mStackIsSystemAllocated() bool {
 }
 
 // mstart is the entry-point for new Ms.
-//
+// It is written in assembly, marked TOPFRAME, and calls mstart0.
+func mstart()
+
+// mstart0 is the Go entry-point for new Ms.
 // This must not split the stack because we may not even have stack
 // bounds set up yet.
 //
@@ -1243,7 +1246,7 @@ func mStackIsSystemAllocated() bool {
 //
 //go:nosplit
 //go:nowritebarrierrec
-func mstart() {
+func mstart0() {
 	_g_ := getg()
 
 	osStack := _g_.stack.lo == 0
diff --git a/src/runtime/sys_windows_386.s b/src/runtime/sys_windows_386.s
index 576dd28771..4f00c58c16 100644
--- a/src/runtime/sys_windows_386.s
+++ b/src/runtime/sys_windows_386.s
@@ -174,7 +174,7 @@ TEXT runtime·profileloop(SB),NOSPLIT,$0
 	ADDL	$12, SP
 	JMP	CX
 
-TEXT runtime·externalthreadhandler(SB),NOSPLIT,$0
+TEXT runtime·externalthreadhandler(SB),NOSPLIT|TOPFRAME,$0
 	PUSHL	BP
 	MOVL	SP, BP
 	PUSHL	BX
diff --git a/src/runtime/sys_windows_amd64.s b/src/runtime/sys_windows_amd64.s
index 6f2abb5444..aba2811e59 100644
--- a/src/runtime/sys_windows_amd64.s
+++ b/src/runtime/sys_windows_amd64.s
@@ -215,7 +215,7 @@ TEXT runtime·profileloop(SB),NOSPLIT|NOFRAME,$8
 	CALL	runtime·externalthreadhandler(SB)
 	RET
 
-TEXT runtime·externalthreadhandler(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·externalthreadhandler(SB),NOSPLIT|NOFRAME|TOPFRAME,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	PUSHQ	BX
diff --git a/src/runtime/sys_windows_arm.s b/src/runtime/sys_windows_arm.s
index 7d134dd3f4..a55f474d39 100644
--- a/src/runtime/sys_windows_arm.s
+++ b/src/runtime/sys_windows_arm.s
@@ -257,7 +257,7 @@ TEXT runtime·profileloop(SB),NOSPLIT|NOFRAME,$0
 // 0 | retval         |
 //   +----------------+
 //
-TEXT runtime·externalthreadhandler(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·externalthreadhandler(SB),NOSPLIT|NOFRAME|TOPFRAME,$0
 	MOVM.DB.W [R4-R11, R14], (R13)		// push {r4-r11, lr}
 	SUB	$(m__size + g__size + 20), R13	// space for locals
 	MOVW	R0, 12(R13)
diff --git a/src/runtime/traceback.go b/src/runtime/traceback.go
index 18d8a42854..e2bd968919 100644
--- a/src/runtime/traceback.go
+++ b/src/runtime/traceback.go
@@ -1002,12 +1002,9 @@ func tracebackHexdump(stk stack, frame *stkframe, bad uintptr) {
 
 // Does f mark the top of a goroutine stack?
 func topofstack(f funcInfo, g0 bool) bool {
-	return f.funcID == funcID_goexit ||
-		f.funcID == funcID_mstart ||
+	return f.flag&funcFlag_TOPFRAME != 0 ||
 		f.funcID == funcID_mcall ||
 		f.funcID == funcID_morestack ||
-		f.funcID == funcID_rt0_go ||
-		f.funcID == funcID_externalthreadhandler ||
 		// asmcgocall is TOS on the system stack because it
 		// switches to the system stack, but in this case we
 		// can come back to the regular stack and still want
-- 
GitLab


From 5ecd9e34dfe0491f1d76372e272d782578ad5bdb Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 28 Jan 2021 17:17:38 -0500
Subject: [PATCH 0695/2400] runtime: do not treat mcall as a topofstack

I added mcall to this list in 2013 without explaining why.
(https://codereview.appspot.com/11085043/diff/61001/src/pkg/runtime/traceback_x86.c)
I suspect I was stopping crashes during profiling where the unwind
tried to walk up past mcall and got confused.

mcall is not something you can unwind past, because it switches
stacks, but it's also not something you should expect as a
standard top-of-stack frame. So if you do see it during say
a garbage collection stack walk, it would be important to crash
instead of silently stopping the walk prematurely.

This CL removes it from the topofstack list to avoid the silent stop.
Now that mcall is detected as SPWRITE, that will stop the
unwind (with a crash if encountered during GC, which we want).

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.
This CL is, however, not windows/arm64-specific.
It is cleanup meant to make the port (and future ports) easier.

Change-Id: I666487ce24efd72292f2bc3eac7fe0477e16bddd
Reviewed-on: https://go-review.googlesource.com/c/go/+/288803
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/symtab.go    | 14 ++++++++++++++
 src/runtime/traceback.go |  1 -
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/src/runtime/symtab.go b/src/runtime/symtab.go
index d7da255e43..00f802aaa7 100644
--- a/src/runtime/symtab.go
+++ b/src/runtime/symtab.go
@@ -337,7 +337,21 @@ const (
 type funcFlag uint8
 
 const (
+	// TOPFRAME indicates a function that appears at the top of its stack.
+	// The traceback routine stop at such a function and consider that a
+	// successful, complete traversal of the stack.
+	// Examples of TOPFRAME functions include goexit, which appears
+	// at the top of a user goroutine stack, and mstart, which appears
+	// at the top of a system goroutine stack.
 	funcFlag_TOPFRAME funcFlag = 1 << iota
+
+	// SPWRITE indicates a function that writes an arbitrary value to SP
+	// (any write other than adding or subtracting a constant amount).
+	// The traceback routines cannot encode such changes into the
+	// pcsp tables, so the function traceback cannot safely unwind past
+	// SPWRITE functions. Stopping at an SPWRITE function is considered
+	// to be an incomplete unwinding of the stack. In certain contexts
+	// (in particular garbage collector stack scans) that is a fatal error.
 	funcFlag_SPWRITE
 )
 
diff --git a/src/runtime/traceback.go b/src/runtime/traceback.go
index e2bd968919..c89a8913ae 100644
--- a/src/runtime/traceback.go
+++ b/src/runtime/traceback.go
@@ -1003,7 +1003,6 @@ func tracebackHexdump(stk stack, frame *stkframe, bad uintptr) {
 // Does f mark the top of a goroutine stack?
 func topofstack(f funcInfo, g0 bool) bool {
 	return f.flag&funcFlag_TOPFRAME != 0 ||
-		f.funcID == funcID_mcall ||
 		f.funcID == funcID_morestack ||
 		// asmcgocall is TOS on the system stack because it
 		// switches to the system stack, but in this case we
-- 
GitLab


From 776ee4079a1d5fabd855a05b300aebdc3ea53efb Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 29 Jan 2021 09:05:10 -0500
Subject: [PATCH 0696/2400] runtime: do not treat morestack as a topofstack
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

I added morestack to this list in 2013 with an explanation
that they were needed if we “start a garbage collection on g0
during a stack split or unsplit”.
(https://golang.org/cl/11533043)

This explanation no longer applies for a handful of reasons,
most importantly that if we did stop a stack scan in the middle
of a call to morestack, we'd ignore pointers above the split,
which would lead to memory corruption. But we don't scan
goroutine stacks during morestack now, so that can't happen.
If we did see morestack during a GC, that would be a good time
to crash the program.

The real problem with morestack is during profiling, as noted
in the code review conversation during 2013. And in profiling
we just need to know to stop and not unwind further, which
the new SPWRITE bit will do for us.

So remove from topofstack and let the program crash if GC
sees morestack and otherwise let the SPWRITE stop morestack
unwinding during profiling.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.
This CL is, however, not windows/arm64-specific.
It is cleanup meant to make the port (and future ports) easier.

Change-Id: I06d95920b18c599c7c46f64c21028104978215d7
Reviewed-on: https://go-review.googlesource.com/c/go/+/288804
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/traceback.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/runtime/traceback.go b/src/runtime/traceback.go
index c89a8913ae..dbc2bddf42 100644
--- a/src/runtime/traceback.go
+++ b/src/runtime/traceback.go
@@ -1003,7 +1003,6 @@ func tracebackHexdump(stk stack, frame *stkframe, bad uintptr) {
 // Does f mark the top of a goroutine stack?
 func topofstack(f funcInfo, g0 bool) bool {
 	return f.flag&funcFlag_TOPFRAME != 0 ||
-		f.funcID == funcID_morestack ||
 		// asmcgocall is TOS on the system stack because it
 		// switches to the system stack, but in this case we
 		// can come back to the regular stack and still want
-- 
GitLab


From a54f7fc0fde79e8edc696de002fe8a73604f077f Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 29 Jan 2021 09:55:03 -0500
Subject: [PATCH 0697/2400] runtime: do not treat asmcgocall as a topofstack on
 g0

This was added in 2018 to fix a runtime crash during unwind
during a unhandled-panic-induced crash.
(See https://golang.org/cl/90895 and #23576.)
Clearly we cannot unwind past this function, and the change
did stop the unwind. But it's not a top-of-stack function, and
the real issue is that SP is changed.

The new SPWRITE bit takes care of this instead, so we can drop
it from the topofstack function.

At this point the topofstack function is only checking the
TOPFRAME bit, so we can inline that into the one call site.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.
This CL is, however, not windows/arm64-specific.
It is cleanup meant to make the port (and future ports) easier.

Change-Id: I856552298032770e48e06c95a20823a1dbd5e38c
Reviewed-on: https://go-review.googlesource.com/c/go/+/288805
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/traceback.go | 13 +------------
 1 file changed, 1 insertion(+), 12 deletions(-)

diff --git a/src/runtime/traceback.go b/src/runtime/traceback.go
index dbc2bddf42..7321790b78 100644
--- a/src/runtime/traceback.go
+++ b/src/runtime/traceback.go
@@ -209,7 +209,7 @@ func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max in
 			}
 		}
 		var flr funcInfo
-		if topofstack(f, gp.m != nil && gp == gp.m.g0) {
+		if flag&funcFlag_TOPFRAME != 0 {
 			// This function marks the top of the stack. Stop the traceback.
 			frame.lr = 0
 			flr = funcInfo{}
@@ -1000,17 +1000,6 @@ func tracebackHexdump(stk stack, frame *stkframe, bad uintptr) {
 	})
 }
 
-// Does f mark the top of a goroutine stack?
-func topofstack(f funcInfo, g0 bool) bool {
-	return f.flag&funcFlag_TOPFRAME != 0 ||
-		// asmcgocall is TOS on the system stack because it
-		// switches to the system stack, but in this case we
-		// can come back to the regular stack and still want
-		// to be able to unwind through the call that appeared
-		// on the regular stack.
-		(g0 && f.funcID == funcID_asmcgocall)
-}
-
 // isSystemGoroutine reports whether the goroutine g must be omitted
 // in stack dumps and deadlock detector. This is any goroutine that
 // starts at a runtime.* entry point, except for runtime.main,
-- 
GitLab


From ece954d8b8e13a76de891c8078c27c5e7f884f9f Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Jan 2021 11:06:04 -0500
Subject: [PATCH 0698/2400] runtime: find g in Windows profiler using SP

The architecture-specific interpretation of m->tls[0]
is unnecessary and fragile. Delete it.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.
This CL is, however, not windows/arm64-specific.
It is cleanup meant to make the port (and future ports) easier.

Change-Id: I927345e52fa2f1741d4914478a29d1fb8acb0dc3
Reviewed-on: https://go-review.googlesource.com/c/go/+/288806
Trust: Russ Cox <rsc@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/os_windows.go     | 22 +++++++++++-----------
 src/runtime/sys_windows_arm.s | 34 ----------------------------------
 2 files changed, 11 insertions(+), 45 deletions(-)

diff --git a/src/runtime/os_windows.go b/src/runtime/os_windows.go
index a2a124cd9d..a8406460e2 100644
--- a/src/runtime/os_windows.go
+++ b/src/runtime/os_windows.go
@@ -1132,21 +1132,21 @@ func profilem(mp *m, thread uintptr) {
 	c.contextflags = _CONTEXT_CONTROL
 	stdcall2(_GetThreadContext, thread, uintptr(unsafe.Pointer(c)))
 
-	gp := gFromTLS(mp)
+	gp := gFromSP(mp, c.sp())
 
 	sigprof(c.ip(), c.sp(), c.lr(), gp, mp)
 }
 
-func gFromTLS(mp *m) *g {
-	switch GOARCH {
-	case "arm":
-		tls := &mp.tls[0]
-		return **((***g)(unsafe.Pointer(tls)))
-	case "386", "amd64":
-		tls := &mp.tls[0]
-		return *((**g)(unsafe.Pointer(tls)))
+func gFromSP(mp *m, sp uintptr) *g {
+	if gp := mp.g0; gp != nil && gp.stack.lo < sp && sp < gp.stack.hi {
+		return gp
+	}
+	if gp := mp.gsignal; gp != nil && gp.stack.lo < sp && sp < gp.stack.hi {
+		return gp
+	}
+	if gp := mp.curg; gp != nil && gp.stack.lo < sp && sp < gp.stack.hi {
+		return gp
 	}
-	throw("unsupported architecture")
 	return nil
 }
 
@@ -1295,7 +1295,7 @@ func preemptM(mp *m) {
 	unlock(&suspendLock)
 
 	// Does it want a preemption and is it safe to preempt?
-	gp := gFromTLS(mp)
+	gp := gFromSP(mp, c.sp())
 	if wantAsyncPreempt(gp) {
 		if ok, newpc := isAsyncSafePoint(gp, c.ip(), c.sp(), c.lr()); ok {
 			// Inject call to asyncPreempt
diff --git a/src/runtime/sys_windows_arm.s b/src/runtime/sys_windows_arm.s
index a55f474d39..a30d63513a 100644
--- a/src/runtime/sys_windows_arm.s
+++ b/src/runtime/sys_windows_arm.s
@@ -350,9 +350,6 @@ TEXT runtime·tstart_stdcall(SB),NOSPLIT|NOFRAME,$0
 	MOVW	R0, g_m(g)
 	BL	runtime·save_g(SB)
 
-	// do per-thread TLS initialization
-	BL	init_thread_tls<>(SB)
-
 	// Layout new m scheduler stack on os stack.
 	MOVW	R13, R0
 	MOVW	R0, g_stack+stack_hi(g)
@@ -581,39 +578,8 @@ TEXT runtime·_initcgo(SB),NOSPLIT|NOFRAME,$0
 	MOVW 	$runtime·tls_g(SB), R1
 	MOVW	R0, (R1)
 
-	BL	init_thread_tls<>(SB)
-
 	MOVW	R4, R13
 	MOVM.IA.W (R13), [R4, R15]	// pop {r4, pc}
 
-// void init_thread_tls()
-//
-// Does per-thread TLS initialization. Saves a pointer to the TLS slot
-// holding G, in the current m.
-//
-//     g->m->tls[0] = &_TEB->TlsSlots[tls_g]
-//
-// The purpose of this is to enable the profiling handler to get the
-// current g associated with the thread. We cannot use m->curg because curg
-// only holds the current user g. If the thread is executing system code or
-// external code, m->curg will be NULL. The thread's TLS slot always holds
-// the current g, so save a reference to this location so the profiling
-// handler can get the real g from the thread's m.
-//
-// Clobbers R0-R3
-TEXT init_thread_tls<>(SB),NOSPLIT|NOFRAME,$0
-	// compute &_TEB->TlsSlots[tls_g]
-	MRC	15, 0, R0, C13, C0, 2
-	ADD	$0xe10, R0
-	MOVW 	$runtime·tls_g(SB), R1
-	MOVW	(R1), R1
-	MOVW	R1<<2, R1
-	ADD	R1, R0
-
-	// save in g->m->tls[0]
-	MOVW	g_m(g), R1
-	MOVW	R0, m_tls(R1)
-	RET
-
 // Holds the TLS Slot, which was allocated by TlsAlloc()
 GLOBL runtime·tls_g+0(SB), NOPTR, $4
-- 
GitLab


From 76ab626bfc52fad9ce8c12fac56177ce68ff744b Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Jan 2021 11:01:00 -0500
Subject: [PATCH 0699/2400] runtime: factor common code out of
 defs_windows_*.go

Also give up on the fiction that these files can be regenerated.
They contain many manual edits, and they're fairly small anyway.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.
This CL is, however, not windows/arm64-specific.
It is cleanup meant to make the port (and future ports) easier.

Change-Id: Ib4e4e20a43d8beb1d5390fd184160c33607641f6
Reviewed-on: https://go-review.googlesource.com/c/go/+/288807
Trust: Russ Cox <rsc@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/defs_windows.go       | 127 ++++++++++++++++--------------
 src/runtime/defs_windows_386.go   |  84 +-------------------
 src/runtime/defs_windows_amd64.go |  87 ++------------------
 src/runtime/defs_windows_arm.go   |  79 +------------------
 src/runtime/signal_windows.go     |   4 +-
 5 files changed, 78 insertions(+), 303 deletions(-)

diff --git a/src/runtime/defs_windows.go b/src/runtime/defs_windows.go
index 43f358d56a..656fd2b8b6 100644
--- a/src/runtime/defs_windows.go
+++ b/src/runtime/defs_windows.go
@@ -2,77 +2,82 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build ignore
-
-/*
-Input to cgo.
-
-GOARCH=amd64 go tool cgo -cdefs defs_windows.go > defs_windows_amd64.h
-GOARCH=386 go tool cgo -cdefs defs_windows.go > defs_windows_386.h
-*/
+// Windows architecture-independent definitions.
 
 package runtime
 
-/*
-#include <signal.h>
-#include <stdarg.h>
-#include <windef.h>
-#include <winbase.h>
-#include <wincon.h>
+const (
+	_PROT_NONE  = 0
+	_PROT_READ  = 1
+	_PROT_WRITE = 2
+	_PROT_EXEC  = 4
 
-#ifndef _X86_
-typedef struct {} FLOATING_SAVE_AREA;
-#endif
-#ifndef _AMD64_
-typedef struct {} M128A;
-#endif
-*/
-import "C"
+	_MAP_ANON    = 1
+	_MAP_PRIVATE = 2
 
-const (
-	PROT_NONE  = 0
-	PROT_READ  = 1
-	PROT_WRITE = 2
-	PROT_EXEC  = 4
+	_DUPLICATE_SAME_ACCESS   = 0x2
+	_THREAD_PRIORITY_HIGHEST = 0x2
 
-	MAP_ANON    = 1
-	MAP_PRIVATE = 2
+	_SIGINT              = 0x2
+	_SIGTERM             = 0xF
+	_CTRL_C_EVENT        = 0x0
+	_CTRL_BREAK_EVENT    = 0x1
+	_CTRL_CLOSE_EVENT    = 0x2
+	_CTRL_LOGOFF_EVENT   = 0x5
+	_CTRL_SHUTDOWN_EVENT = 0x6
 
-	DUPLICATE_SAME_ACCESS   = C.DUPLICATE_SAME_ACCESS
-	THREAD_PRIORITY_HIGHEST = C.THREAD_PRIORITY_HIGHEST
+	_EXCEPTION_ACCESS_VIOLATION     = 0xc0000005
+	_EXCEPTION_BREAKPOINT           = 0x80000003
+	_EXCEPTION_FLT_DENORMAL_OPERAND = 0xc000008d
+	_EXCEPTION_FLT_DIVIDE_BY_ZERO   = 0xc000008e
+	_EXCEPTION_FLT_INEXACT_RESULT   = 0xc000008f
+	_EXCEPTION_FLT_OVERFLOW         = 0xc0000091
+	_EXCEPTION_FLT_UNDERFLOW        = 0xc0000093
+	_EXCEPTION_INT_DIVIDE_BY_ZERO   = 0xc0000094
+	_EXCEPTION_INT_OVERFLOW         = 0xc0000095
 
-	SIGINT              = C.SIGINT
-	SIGTERM             = C.SIGTERM
-	CTRL_C_EVENT        = C.CTRL_C_EVENT
-	CTRL_BREAK_EVENT    = C.CTRL_BREAK_EVENT
-	CTRL_CLOSE_EVENT    = C.CTRL_CLOSE_EVENT
-	CTRL_LOGOFF_EVENT   = C.CTRL_LOGOFF_EVENT
-	CTRL_SHUTDOWN_EVENT = C.CTRL_SHUTDOWN_EVENT
+	_INFINITE     = 0xffffffff
+	_WAIT_TIMEOUT = 0x102
 
-	CONTEXT_CONTROL = C.CONTEXT_CONTROL
-	CONTEXT_FULL    = C.CONTEXT_FULL
+	_EXCEPTION_CONTINUE_EXECUTION = -0x1
+	_EXCEPTION_CONTINUE_SEARCH    = 0x0
+)
 
-	EXCEPTION_ACCESS_VIOLATION     = C.STATUS_ACCESS_VIOLATION
-	EXCEPTION_BREAKPOINT           = C.STATUS_BREAKPOINT
-	EXCEPTION_FLT_DENORMAL_OPERAND = C.STATUS_FLOAT_DENORMAL_OPERAND
-	EXCEPTION_FLT_DIVIDE_BY_ZERO   = C.STATUS_FLOAT_DIVIDE_BY_ZERO
-	EXCEPTION_FLT_INEXACT_RESULT   = C.STATUS_FLOAT_INEXACT_RESULT
-	EXCEPTION_FLT_OVERFLOW         = C.STATUS_FLOAT_OVERFLOW
-	EXCEPTION_FLT_UNDERFLOW        = C.STATUS_FLOAT_UNDERFLOW
-	EXCEPTION_INT_DIVIDE_BY_ZERO   = C.STATUS_INTEGER_DIVIDE_BY_ZERO
-	EXCEPTION_INT_OVERFLOW         = C.STATUS_INTEGER_OVERFLOW
+type systeminfo struct {
+	anon0                       [4]byte
+	dwpagesize                  uint32
+	lpminimumapplicationaddress *byte
+	lpmaximumapplicationaddress *byte
+	dwactiveprocessormask       uintptr
+	dwnumberofprocessors        uint32
+	dwprocessortype             uint32
+	dwallocationgranularity     uint32
+	wprocessorlevel             uint16
+	wprocessorrevision          uint16
+}
 
-	INFINITE     = C.INFINITE
-	WAIT_TIMEOUT = C.WAIT_TIMEOUT
+type exceptionrecord struct {
+	exceptioncode        uint32
+	exceptionflags       uint32
+	exceptionrecord      *exceptionrecord
+	exceptionaddress     *byte
+	numberparameters     uint32
+	exceptioninformation [15]uintptr
+}
 
-	EXCEPTION_CONTINUE_EXECUTION = C.EXCEPTION_CONTINUE_EXECUTION
-	EXCEPTION_CONTINUE_SEARCH    = C.EXCEPTION_CONTINUE_SEARCH
-)
+type overlapped struct {
+	internal     uintptr
+	internalhigh uintptr
+	anon0        [8]byte
+	hevent       *byte
+}
 
-type SystemInfo C.SYSTEM_INFO
-type ExceptionRecord C.EXCEPTION_RECORD
-type FloatingSaveArea C.FLOATING_SAVE_AREA
-type M128a C.M128A
-type Context C.CONTEXT
-type Overlapped C.OVERLAPPED
-type MemoryBasicInformation C.MEMORY_BASIC_INFORMATION
+type memoryBasicInformation struct {
+	baseAddress       uintptr
+	allocationBase    uintptr
+	allocationProtect uint32
+	regionSize        uintptr
+	state             uint32
+	protect           uint32
+	type_             uint32
+}
diff --git a/src/runtime/defs_windows_386.go b/src/runtime/defs_windows_386.go
index 3c5057b86f..37fe74c542 100644
--- a/src/runtime/defs_windows_386.go
+++ b/src/runtime/defs_windows_386.go
@@ -1,69 +1,10 @@
-// created by cgo -cdefs and then converted to Go
-// cgo -cdefs defs_windows.go
+// Copyright 2009 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 runtime
 
-const (
-	_PROT_NONE  = 0
-	_PROT_READ  = 1
-	_PROT_WRITE = 2
-	_PROT_EXEC  = 4
-
-	_MAP_ANON    = 1
-	_MAP_PRIVATE = 2
-
-	_DUPLICATE_SAME_ACCESS   = 0x2
-	_THREAD_PRIORITY_HIGHEST = 0x2
-
-	_SIGINT              = 0x2
-	_SIGTERM             = 0xF
-	_CTRL_C_EVENT        = 0x0
-	_CTRL_BREAK_EVENT    = 0x1
-	_CTRL_CLOSE_EVENT    = 0x2
-	_CTRL_LOGOFF_EVENT   = 0x5
-	_CTRL_SHUTDOWN_EVENT = 0x6
-
-	_CONTEXT_CONTROL = 0x10001
-	_CONTEXT_FULL    = 0x10007
-
-	_EXCEPTION_ACCESS_VIOLATION     = 0xc0000005
-	_EXCEPTION_BREAKPOINT           = 0x80000003
-	_EXCEPTION_FLT_DENORMAL_OPERAND = 0xc000008d
-	_EXCEPTION_FLT_DIVIDE_BY_ZERO   = 0xc000008e
-	_EXCEPTION_FLT_INEXACT_RESULT   = 0xc000008f
-	_EXCEPTION_FLT_OVERFLOW         = 0xc0000091
-	_EXCEPTION_FLT_UNDERFLOW        = 0xc0000093
-	_EXCEPTION_INT_DIVIDE_BY_ZERO   = 0xc0000094
-	_EXCEPTION_INT_OVERFLOW         = 0xc0000095
-
-	_INFINITE     = 0xffffffff
-	_WAIT_TIMEOUT = 0x102
-
-	_EXCEPTION_CONTINUE_EXECUTION = -0x1
-	_EXCEPTION_CONTINUE_SEARCH    = 0x0
-)
-
-type systeminfo struct {
-	anon0                       [4]byte
-	dwpagesize                  uint32
-	lpminimumapplicationaddress *byte
-	lpmaximumapplicationaddress *byte
-	dwactiveprocessormask       uint32
-	dwnumberofprocessors        uint32
-	dwprocessortype             uint32
-	dwallocationgranularity     uint32
-	wprocessorlevel             uint16
-	wprocessorrevision          uint16
-}
-
-type exceptionrecord struct {
-	exceptioncode        uint32
-	exceptionflags       uint32
-	exceptionrecord      *exceptionrecord
-	exceptionaddress     *byte
-	numberparameters     uint32
-	exceptioninformation [15]uint32
-}
+const _CONTEXT_CONTROL = 0x10001
 
 type floatingsavearea struct {
 	controlword   uint32
@@ -130,20 +71,3 @@ func dumpregs(r *context) {
 	print("fs      ", hex(r.segfs), "\n")
 	print("gs      ", hex(r.seggs), "\n")
 }
-
-type overlapped struct {
-	internal     uint32
-	internalhigh uint32
-	anon0        [8]byte
-	hevent       *byte
-}
-
-type memoryBasicInformation struct {
-	baseAddress       uintptr
-	allocationBase    uintptr
-	allocationProtect uint32
-	regionSize        uintptr
-	state             uint32
-	protect           uint32
-	type_             uint32
-}
diff --git a/src/runtime/defs_windows_amd64.go b/src/runtime/defs_windows_amd64.go
index ebb1506e2f..ac636a68ec 100644
--- a/src/runtime/defs_windows_amd64.go
+++ b/src/runtime/defs_windows_amd64.go
@@ -1,70 +1,10 @@
-// created by cgo -cdefs and then converted to Go
-// cgo -cdefs defs_windows.go
+// Copyright 2009 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 runtime
 
-const (
-	_PROT_NONE  = 0
-	_PROT_READ  = 1
-	_PROT_WRITE = 2
-	_PROT_EXEC  = 4
-
-	_MAP_ANON    = 1
-	_MAP_PRIVATE = 2
-
-	_DUPLICATE_SAME_ACCESS   = 0x2
-	_THREAD_PRIORITY_HIGHEST = 0x2
-
-	_SIGINT              = 0x2
-	_SIGTERM             = 0xF
-	_CTRL_C_EVENT        = 0x0
-	_CTRL_BREAK_EVENT    = 0x1
-	_CTRL_CLOSE_EVENT    = 0x2
-	_CTRL_LOGOFF_EVENT   = 0x5
-	_CTRL_SHUTDOWN_EVENT = 0x6
-
-	_CONTEXT_CONTROL = 0x100001
-	_CONTEXT_FULL    = 0x10000b
-
-	_EXCEPTION_ACCESS_VIOLATION     = 0xc0000005
-	_EXCEPTION_BREAKPOINT           = 0x80000003
-	_EXCEPTION_FLT_DENORMAL_OPERAND = 0xc000008d
-	_EXCEPTION_FLT_DIVIDE_BY_ZERO   = 0xc000008e
-	_EXCEPTION_FLT_INEXACT_RESULT   = 0xc000008f
-	_EXCEPTION_FLT_OVERFLOW         = 0xc0000091
-	_EXCEPTION_FLT_UNDERFLOW        = 0xc0000093
-	_EXCEPTION_INT_DIVIDE_BY_ZERO   = 0xc0000094
-	_EXCEPTION_INT_OVERFLOW         = 0xc0000095
-
-	_INFINITE     = 0xffffffff
-	_WAIT_TIMEOUT = 0x102
-
-	_EXCEPTION_CONTINUE_EXECUTION = -0x1
-	_EXCEPTION_CONTINUE_SEARCH    = 0x0
-)
-
-type systeminfo struct {
-	anon0                       [4]byte
-	dwpagesize                  uint32
-	lpminimumapplicationaddress *byte
-	lpmaximumapplicationaddress *byte
-	dwactiveprocessormask       uint64
-	dwnumberofprocessors        uint32
-	dwprocessortype             uint32
-	dwallocationgranularity     uint32
-	wprocessorlevel             uint16
-	wprocessorrevision          uint16
-}
-
-type exceptionrecord struct {
-	exceptioncode        uint32
-	exceptionflags       uint32
-	exceptionrecord      *exceptionrecord
-	exceptionaddress     *byte
-	numberparameters     uint32
-	pad_cgo_0            [4]byte
-	exceptioninformation [15]uint64
-}
+const _CONTEXT_CONTROL = 0x100001
 
 type m128a struct {
 	low  uint64
@@ -123,7 +63,7 @@ type context struct {
 func (c *context) ip() uintptr { return uintptr(c.rip) }
 func (c *context) sp() uintptr { return uintptr(c.rsp) }
 
-// Amd64 does not have link register, so this returns 0.
+// AMD64 does not have link register, so this returns 0.
 func (c *context) lr() uintptr      { return 0 }
 func (c *context) set_lr(x uintptr) {}
 
@@ -152,20 +92,3 @@ func dumpregs(r *context) {
 	print("fs      ", hex(r.segfs), "\n")
 	print("gs      ", hex(r.seggs), "\n")
 }
-
-type overlapped struct {
-	internal     uint64
-	internalhigh uint64
-	anon0        [8]byte
-	hevent       *byte
-}
-
-type memoryBasicInformation struct {
-	baseAddress       uintptr
-	allocationBase    uintptr
-	allocationProtect uint32
-	regionSize        uintptr
-	state             uint32
-	protect           uint32
-	type_             uint32
-}
diff --git a/src/runtime/defs_windows_arm.go b/src/runtime/defs_windows_arm.go
index b275b0572a..4021f77ba8 100644
--- a/src/runtime/defs_windows_arm.go
+++ b/src/runtime/defs_windows_arm.go
@@ -4,67 +4,7 @@
 
 package runtime
 
-const (
-	_PROT_NONE  = 0
-	_PROT_READ  = 1
-	_PROT_WRITE = 2
-	_PROT_EXEC  = 4
-
-	_MAP_ANON    = 1
-	_MAP_PRIVATE = 2
-
-	_DUPLICATE_SAME_ACCESS   = 0x2
-	_THREAD_PRIORITY_HIGHEST = 0x2
-
-	_SIGINT              = 0x2
-	_SIGTERM             = 0xF
-	_CTRL_C_EVENT        = 0x0
-	_CTRL_BREAK_EVENT    = 0x1
-	_CTRL_CLOSE_EVENT    = 0x2
-	_CTRL_LOGOFF_EVENT   = 0x5
-	_CTRL_SHUTDOWN_EVENT = 0x6
-
-	_CONTEXT_CONTROL = 0x10001
-	_CONTEXT_FULL    = 0x10007
-
-	_EXCEPTION_ACCESS_VIOLATION     = 0xc0000005
-	_EXCEPTION_BREAKPOINT           = 0x80000003
-	_EXCEPTION_FLT_DENORMAL_OPERAND = 0xc000008d
-	_EXCEPTION_FLT_DIVIDE_BY_ZERO   = 0xc000008e
-	_EXCEPTION_FLT_INEXACT_RESULT   = 0xc000008f
-	_EXCEPTION_FLT_OVERFLOW         = 0xc0000091
-	_EXCEPTION_FLT_UNDERFLOW        = 0xc0000093
-	_EXCEPTION_INT_DIVIDE_BY_ZERO   = 0xc0000094
-	_EXCEPTION_INT_OVERFLOW         = 0xc0000095
-
-	_INFINITE     = 0xffffffff
-	_WAIT_TIMEOUT = 0x102
-
-	_EXCEPTION_CONTINUE_EXECUTION = -0x1
-	_EXCEPTION_CONTINUE_SEARCH    = 0x0
-)
-
-type systeminfo struct {
-	anon0                       [4]byte
-	dwpagesize                  uint32
-	lpminimumapplicationaddress *byte
-	lpmaximumapplicationaddress *byte
-	dwactiveprocessormask       uint32
-	dwnumberofprocessors        uint32
-	dwprocessortype             uint32
-	dwallocationgranularity     uint32
-	wprocessorlevel             uint16
-	wprocessorrevision          uint16
-}
-
-type exceptionrecord struct {
-	exceptioncode        uint32
-	exceptionflags       uint32
-	exceptionrecord      *exceptionrecord
-	exceptionaddress     *byte
-	numberparameters     uint32
-	exceptioninformation [15]uint32
-}
+const _CONTEXT_CONTROL = 0x10001
 
 type neon128 struct {
 	low  uint64
@@ -132,23 +72,6 @@ func dumpregs(r *context) {
 	print("cpsr ", hex(r.cpsr), "\n")
 }
 
-type overlapped struct {
-	internal     uint32
-	internalhigh uint32
-	anon0        [8]byte
-	hevent       *byte
-}
-
-type memoryBasicInformation struct {
-	baseAddress       uintptr
-	allocationBase    uintptr
-	allocationProtect uint32
-	regionSize        uintptr
-	state             uint32
-	protect           uint32
-	type_             uint32
-}
-
 func stackcheck() {
 	// TODO: not implemented on ARM
 }
diff --git a/src/runtime/signal_windows.go b/src/runtime/signal_windows.go
index 3af2e39b08..89d12617f4 100644
--- a/src/runtime/signal_windows.go
+++ b/src/runtime/signal_windows.go
@@ -112,8 +112,8 @@ func exceptionhandler(info *exceptionrecord, r *context, gp *g) int32 {
 	// augmenting the stack frame would break
 	// the unwinding code.
 	gp.sig = info.exceptioncode
-	gp.sigcode0 = uintptr(info.exceptioninformation[0])
-	gp.sigcode1 = uintptr(info.exceptioninformation[1])
+	gp.sigcode0 = info.exceptioninformation[0]
+	gp.sigcode1 = info.exceptioninformation[1]
 	gp.sigpc = r.ip()
 
 	// Only push runtime·sigpanic if r.ip() != 0.
-- 
GitLab


From 75e273fc2c183896a11bf23f0688c38059933336 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Jan 2021 11:02:33 -0500
Subject: [PATCH 0700/2400] runtime: fix windows/arm CONTEXT_CONTROL
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The constant was wrong, and the “right” constant doesn't work either.
But with the actually-right constant (and possibly earlier fixes in this
stack as well), profiling now works.

Change-Id: If8caff1da556826db40961fb9bcfe2b1f31ea9f9
Reviewed-on: https://go-review.googlesource.com/c/go/+/288808
Trust: Russ Cox <rsc@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
---
 src/runtime/defs_windows_arm.go | 8 +++++++-
 src/runtime/pprof/pprof_test.go | 4 ----
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/runtime/defs_windows_arm.go b/src/runtime/defs_windows_arm.go
index 4021f77ba8..370470e35d 100644
--- a/src/runtime/defs_windows_arm.go
+++ b/src/runtime/defs_windows_arm.go
@@ -4,7 +4,13 @@
 
 package runtime
 
-const _CONTEXT_CONTROL = 0x10001
+// NOTE(rsc): _CONTEXT_CONTROL is actually 0x200001 and should include PC, SP, and LR.
+// However, empirically, LR doesn't come along on Windows 10
+// unless you also set _CONTEXT_INTEGER (0x200002).
+// Without LR, we skip over the next-to-bottom function in profiles
+// when the bottom function is frameless.
+// So we set both here, to make a working _CONTEXT_CONTROL.
+const _CONTEXT_CONTROL = 0x200003
 
 type neon128 struct {
 	low  uint64
diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go
index 37f12de0d9..f7c1349bc6 100644
--- a/src/runtime/pprof/pprof_test.go
+++ b/src/runtime/pprof/pprof_test.go
@@ -285,10 +285,6 @@ func testCPUProfile(t *testing.T, matches matchFunc, need []string, avoid []stri
 		if runtime.GOARCH == "arm" || runtime.GOARCH == "arm64" {
 			broken = true
 		}
-	case "windows":
-		if runtime.GOARCH == "arm" {
-			broken = true // See https://golang.org/issues/42862
-		}
 	}
 
 	maxDuration := 5 * time.Second
-- 
GitLab


From a1e9148e3dbb20a18e0139583e7d835cc7a820bf Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 26 Jan 2021 21:26:01 -0500
Subject: [PATCH 0701/2400] runtime: print hex numbers with hex prefixes in
 traceback debug

If traceback fails, it prints a helpful hex dump of the stack.
But the hex numbers have no 0x prefix, which might make it
a little unclear that they are hex.
We only print two per line, so there is plenty of room for the 0x.
Print it, which lets us delete a custom hex formatter.

Also, in the translated <name+off> hints, print off in hex
(with a 0x prefix). The offsets were previously decimal, which
could have been confused for hex since none of the hex had
0x prefixes. And decimal is kind of useless anyway since the
offsets shown in the main traceback are hex, so you can't
easily match them up without mental base conversions.

Just print hex everywhere, clearly marked by 0x.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.
This CL is, however, not windows/arm64-specific.
It is cleanup meant to make the port (and future ports) easier.

Change-Id: I72d26a4e41ada38b620bf8fe3576d787a2e59b47
Reviewed-on: https://go-review.googlesource.com/c/go/+/288809
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/print.go | 26 ++++++++------------------
 1 file changed, 8 insertions(+), 18 deletions(-)

diff --git a/src/runtime/print.go b/src/runtime/print.go
index 64055a34cc..f15296cf02 100644
--- a/src/runtime/print.go
+++ b/src/runtime/print.go
@@ -216,13 +216,15 @@ func printint(v int64) {
 	printuint(uint64(v))
 }
 
+var minhexdigits = 0 // protected by printlock
+
 func printhex(v uint64) {
 	const dig = "0123456789abcdef"
 	var buf [100]byte
 	i := len(buf)
 	for i--; i > 0; i-- {
 		buf[i] = dig[v%16]
-		if v < 16 {
+		if v < 16 && len(buf)-i >= minhexdigits {
 			break
 		}
 		v /= 16
@@ -265,29 +267,16 @@ func printiface(i iface) {
 // and should return a character mark to appear just before that
 // word's value. It can return 0 to indicate no mark.
 func hexdumpWords(p, end uintptr, mark func(uintptr) byte) {
-	p1 := func(x uintptr) {
-		var buf [2 * sys.PtrSize]byte
-		for i := len(buf) - 1; i >= 0; i-- {
-			if x&0xF < 10 {
-				buf[i] = byte(x&0xF) + '0'
-			} else {
-				buf[i] = byte(x&0xF) - 10 + 'a'
-			}
-			x >>= 4
-		}
-		gwrite(buf[:])
-	}
-
 	printlock()
 	var markbuf [1]byte
 	markbuf[0] = ' '
+	minhexdigits = int(unsafe.Sizeof(uintptr(0)) * 2)
 	for i := uintptr(0); p+i < end; i += sys.PtrSize {
 		if i%16 == 0 {
 			if i != 0 {
 				println()
 			}
-			p1(p + i)
-			print(": ")
+			print(hex(p+i), ": ")
 		}
 
 		if mark != nil {
@@ -298,15 +287,16 @@ func hexdumpWords(p, end uintptr, mark func(uintptr) byte) {
 		}
 		gwrite(markbuf[:])
 		val := *(*uintptr)(unsafe.Pointer(p + i))
-		p1(val)
+		print(hex(val))
 		print(" ")
 
 		// Can we symbolize val?
 		fn := findfunc(val)
 		if fn.valid() {
-			print("<", funcname(fn), "+", val-fn.entry, "> ")
+			print("<", funcname(fn), "+", hex(val-fn.entry), "> ")
 		}
 	}
+	minhexdigits = 0
 	println()
 	printunlock()
 }
-- 
GitLab


From 38672d3dcf2eae297c45dc2a899c39528148f14b Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Jan 2021 11:15:33 -0500
Subject: [PATCH 0702/2400] runtime: crash earlier on windows for runtime.abort

The isAbort check was wrong for non-x86 systems.
That was causing the exception chain to be passed back to Windows.
That was causing some other kind of fault - not sure what.
That was leading back to lastcontinuehandler to print a larger
stack trace, and then the throwing = 1 print added runtime.abort,
which made TestAbort pass even though it wasn't really working.

Recognize abort properly and handle it as Go, not as something
for Windows to try to handle.

Keep the throwing = 1 print, because more detail on throw is
always better.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.
This CL is, however, not windows/arm64-specific.
It is cleanup meant to make the port (and future ports) easier.

Change-Id: If614f4ab2884bd90410d29e28311bf969ceeac09
Reviewed-on: https://go-review.googlesource.com/c/go/+/288810
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/signal_windows.go | 45 +++++++++++++++++++----------------
 1 file changed, 24 insertions(+), 21 deletions(-)

diff --git a/src/runtime/signal_windows.go b/src/runtime/signal_windows.go
index 89d12617f4..18834b0ec5 100644
--- a/src/runtime/signal_windows.go
+++ b/src/runtime/signal_windows.go
@@ -43,13 +43,17 @@ func initExceptionHandler() {
 //
 //go:nosplit
 func isAbort(r *context) bool {
-	// In the case of an abort, the exception IP is one byte after
-	// the INT3 (this differs from UNIX OSes).
-	return isAbortPC(r.ip() - 1)
+	pc := r.ip()
+	if GOARCH == "386" || GOARCH == "amd64" {
+		// In the case of an abort, the exception IP is one byte after
+		// the INT3 (this differs from UNIX OSes).
+		pc--
+	}
+	return isAbortPC(pc)
 }
 
 // isgoexception reports whether this exception should be translated
-// into a Go panic.
+// into a Go panic or throw.
 //
 // It is nosplit to avoid growing the stack in case we're aborting
 // because of a stack overflow.
@@ -63,11 +67,6 @@ func isgoexception(info *exceptionrecord, r *context) bool {
 		return false
 	}
 
-	if isAbort(r) {
-		// Never turn abort into a panic.
-		return false
-	}
-
 	// Go will only handle some exceptions.
 	switch info.exceptioncode {
 	default:
@@ -99,14 +98,16 @@ func exceptionhandler(info *exceptionrecord, r *context, gp *g) int32 {
 		return _EXCEPTION_CONTINUE_SEARCH
 	}
 
-	// After this point, it is safe to grow the stack.
-
-	if gp.throwsplit {
-		// We can't safely sigpanic because it may grow the
-		// stack. Let it fall through.
-		return _EXCEPTION_CONTINUE_SEARCH
+	if gp.throwsplit || isAbort(r) {
+		// We can't safely sigpanic because it may grow the stack.
+		// Or this is a call to abort.
+		// Don't go through any more of the Windows handler chain.
+		// Crash now.
+		winthrow(info, r, gp)
 	}
 
+	// After this point, it is safe to grow the stack.
+
 	// Make it look like a call to the signal func.
 	// Have to pass arguments out of band since
 	// augmenting the stack frame would break
@@ -181,6 +182,12 @@ func lastcontinuehandler(info *exceptionrecord, r *context, gp *g) int32 {
 		return _EXCEPTION_CONTINUE_SEARCH
 	}
 
+	winthrow(info, r, gp)
+	return 0 // not reached
+}
+
+//go:nosplit
+func winthrow(info *exceptionrecord, r *context, gp *g) {
 	_g_ := getg()
 
 	if panicking != 0 { // traceback already printed
@@ -206,11 +213,8 @@ func lastcontinuehandler(info *exceptionrecord, r *context, gp *g) int32 {
 	}
 	print("\n")
 
-	// TODO(jordanrh1): This may be needed for 386/AMD64 as well.
-	if GOARCH == "arm" {
-		_g_.m.throwing = 1
-		_g_.m.caughtsig.set(gp)
-	}
+	_g_.m.throwing = 1
+	_g_.m.caughtsig.set(gp)
 
 	level, _, docrash := gotraceback()
 	if level > 0 {
@@ -224,7 +228,6 @@ func lastcontinuehandler(info *exceptionrecord, r *context, gp *g) int32 {
 	}
 
 	exit(2)
-	return 0 // not reached
 }
 
 func sigpanic() {
-- 
GitLab


From 91cc484ea914fc75e7321d23017d59c9751f5066 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Jan 2021 11:22:02 -0500
Subject: [PATCH 0703/2400] runtime: fix time on windows/arm under WINE
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This code has clearly never run successfully,
since one of the “tail calls" calls the wrong function,
and both of them appear in functions with stack frames
that are never going to be properly unwound.
Probably there is no windows/arm under WINE at all.
But might as well fix the code.

Change-Id: I5fa62274b3661bc6bce098657b5bcf11d59655eb
Reviewed-on: https://go-review.googlesource.com/c/go/+/288811
Trust: Russ Cox <rsc@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
---
 src/runtime/sys_windows_arm.s | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/runtime/sys_windows_arm.s b/src/runtime/sys_windows_arm.s
index a30d63513a..42278dcbe7 100644
--- a/src/runtime/sys_windows_arm.s
+++ b/src/runtime/sys_windows_arm.s
@@ -419,7 +419,7 @@ TEXT runtime·read_tls_fallback(SB),NOSPLIT|NOFRAME,$0
 #define time_hi1 4
 #define time_hi2 8
 
-TEXT runtime·nanotime1(SB),NOSPLIT,$0-8
+TEXT runtime·nanotime1(SB),NOSPLIT|NOFRAME,$0-8
 	MOVW	$0, R0
 	MOVB	runtime·useQPCTime(SB), R0
 	CMP	$0, R0
@@ -443,9 +443,8 @@ loop:
 	RET
 useQPC:
 	B	runtime·nanotimeQPC(SB)		// tail call
-	RET
 
-TEXT time·now(SB),NOSPLIT,$0-20
+TEXT time·now(SB),NOSPLIT|NOFRAME,$0-20
 	MOVW    $0, R0
 	MOVB    runtime·useQPCTime(SB), R0
 	CMP	$0, R0
@@ -519,8 +518,7 @@ wall:
 	MOVW	R1,nsec+8(FP)
 	RET
 useQPC:
-	B	runtime·nanotimeQPC(SB)		// tail call
-	RET
+	B	runtime·nowQPC(SB)		// tail call
 
 // save_g saves the g register (R10) into thread local memory
 // so that we can call externally compiled
-- 
GitLab


From 5421c37a1db5098659f86b21d011fc263d93524e Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Jan 2021 11:27:25 -0500
Subject: [PATCH 0704/2400] runtime: fix windows/arm externalthreadhandler

Externalthreadhandler was not handling its own stack correctly.
It incorrectly referred to the saved LR slot (uninitialized, it turned out)
as holding the return value from the called function.

Externalthreadhandler is used to call two different functions:
profileloop1 and ctrlhandler1.
Profileloop1 does not return, so no harm done.
Ctrlhandler1 returns a boolean indicating whether the handler
took care of the control event (if true, no other handlers run).

It's hard to say exactly what uninitialized values are likely to
have been returned instead of ctrlhandler1's result, but it
probably wasn't helping matters.

Change-Id: Ia02f1c033df618cb82c2193b3a8241ed048a8b18
Reviewed-on: https://go-review.googlesource.com/c/go/+/288812
Trust: Russ Cox <rsc@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
---
 src/runtime/sys_windows_arm.s | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/runtime/sys_windows_arm.s b/src/runtime/sys_windows_arm.s
index 42278dcbe7..3f01714c66 100644
--- a/src/runtime/sys_windows_arm.s
+++ b/src/runtime/sys_windows_arm.s
@@ -250,16 +250,17 @@ TEXT runtime·profileloop(SB),NOSPLIT|NOFRAME,$0
 //   +----------------+
 // 12| argument (r0)  |
 //---+----------------+
-// 8 | param1         |
+// 8 | param1         | (also return value for called Go function)
 //   +----------------+
 // 4 | param0         |
 //   +----------------+
-// 0 | retval         |
+// 0 | slot for LR    |
 //   +----------------+
 //
 TEXT runtime·externalthreadhandler(SB),NOSPLIT|NOFRAME|TOPFRAME,$0
 	MOVM.DB.W [R4-R11, R14], (R13)		// push {r4-r11, lr}
 	SUB	$(m__size + g__size + 20), R13	// space for locals
+	MOVW	R14, 0(R13)			// push LR again for anything unwinding the stack
 	MOVW	R0, 12(R13)
 	MOVW	R1, 16(R13)
 
@@ -298,7 +299,7 @@ TEXT runtime·externalthreadhandler(SB),NOSPLIT|NOFRAME|TOPFRAME,$0
 	MOVW	$0, g
 	BL	runtime·save_g(SB)
 
-	MOVW	0(R13), R0			// load return value
+	MOVW	8(R13), R0			// load return value
 	ADD	$(m__size + g__size + 20), R13	// free locals
 	MOVM.IA.W (R13), [R4-R11, R15]		// pop {r4-r11, pc}
 
-- 
GitLab


From b19e7b518e564cd309d3eb68dfd2da8839a7433b Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 28 Jan 2021 09:23:35 -0500
Subject: [PATCH 0705/2400] runtime: clean up windows a bit

Document the various hard-coded architecture checks
or remove them in favor of more general checks.
This should be a no-op now but will make the arm64 port
have fewer diffs.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.
This CL is, however, not windows/arm64-specific.
It is cleanup meant to make the port (and future ports) easier.

Change-Id: Ifd6b19e44e8c9ca4a0d2590f314928ce235821b3
Reviewed-on: https://go-review.googlesource.com/c/go/+/288813
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
---
 src/runtime/os_windows.go      | 12 ++++++++----
 src/runtime/signal_windows.go  | 13 ++++++-------
 src/runtime/syscall_windows.go |  3 ++-
 3 files changed, 16 insertions(+), 12 deletions(-)

diff --git a/src/runtime/os_windows.go b/src/runtime/os_windows.go
index a8406460e2..375c34ed99 100644
--- a/src/runtime/os_windows.go
+++ b/src/runtime/os_windows.go
@@ -236,6 +236,8 @@ func windowsLoadSystemLib(name []byte) uintptr {
 	}
 }
 
+const haveCputicksAsm = GOARCH == "386" || GOARCH == "amd64"
+
 func loadOptionalSyscalls() {
 	var kernel32dll = []byte("kernel32.dll\000")
 	k32 := stdcall1(_LoadLibraryA, uintptr(unsafe.Pointer(&kernel32dll[0])))
@@ -262,7 +264,7 @@ func loadOptionalSyscalls() {
 	}
 	_NtWaitForSingleObject = windowsFindfunc(n32, []byte("NtWaitForSingleObject\000"))
 
-	if GOARCH == "arm" {
+	if !haveCputicksAsm {
 		_QueryPerformanceCounter = windowsFindfunc(k32, []byte("QueryPerformanceCounter\000"))
 		if _QueryPerformanceCounter == nil {
 			throw("could not find QPC syscalls")
@@ -452,8 +454,10 @@ func createHighResTimer() uintptr {
 		_SYNCHRONIZE|_TIMER_QUERY_STATE|_TIMER_MODIFY_STATE)
 }
 
+const highResTimerSupported = GOARCH == "386" || GOARCH == "amd64"
+
 func initHighResTimer() {
-	if GOARCH == "arm" {
+	if !highResTimerSupported {
 		// TODO: Not yet implemented.
 		return
 	}
@@ -1217,14 +1221,14 @@ func setThreadCPUProfiler(hz int32) {
 	atomic.Store((*uint32)(unsafe.Pointer(&getg().m.profilehz)), uint32(hz))
 }
 
-const preemptMSupported = GOARCH != "arm"
+const preemptMSupported = GOARCH == "386" || GOARCH == "amd64"
 
 // suspendLock protects simultaneous SuspendThread operations from
 // suspending each other.
 var suspendLock mutex
 
 func preemptM(mp *m) {
-	if GOARCH == "arm" {
+	if !preemptMSupported {
 		// TODO: Implement call injection
 		return
 	}
diff --git a/src/runtime/signal_windows.go b/src/runtime/signal_windows.go
index 18834b0ec5..cb1fbe9f81 100644
--- a/src/runtime/signal_windows.go
+++ b/src/runtime/signal_windows.go
@@ -5,6 +5,7 @@
 package runtime
 
 import (
+	"runtime/internal/sys"
 	"unsafe"
 )
 
@@ -132,16 +133,14 @@ func exceptionhandler(info *exceptionrecord, r *context, gp *g) int32 {
 	// overwrite the PC. (See issue #35773)
 	if r.ip() != 0 && r.ip() != funcPC(asyncPreempt) {
 		sp := unsafe.Pointer(r.sp())
-		sp = add(sp, ^(unsafe.Sizeof(uintptr(0)) - 1)) // sp--
+		delta := uintptr(sys.StackAlign)
+		sp = add(sp, -delta)
 		r.set_sp(uintptr(sp))
-		switch GOARCH {
-		default:
-			panic("unsupported architecture")
-		case "386", "amd64":
-			*((*uintptr)(sp)) = r.ip()
-		case "arm":
+		if usesLR {
 			*((*uintptr)(sp)) = r.lr()
 			r.set_lr(r.ip())
+		} else {
+			*((*uintptr)(sp)) = r.ip()
 		}
 	}
 	r.set_ip(funcPC(sigpanic))
diff --git a/src/runtime/syscall_windows.go b/src/runtime/syscall_windows.go
index add40bb0b3..6052cc333c 100644
--- a/src/runtime/syscall_windows.go
+++ b/src/runtime/syscall_windows.go
@@ -116,13 +116,14 @@ func compileCallback(fn eface, cdecl bool) (code uintptr) {
 			// registers and the stack.
 			panic("compileCallback: argument size is larger than uintptr")
 		}
-		if k := t.kind & kindMask; (GOARCH == "amd64" || GOARCH == "arm") && (k == kindFloat32 || k == kindFloat64) {
+		if k := t.kind & kindMask; GOARCH != "386" && (k == kindFloat32 || k == kindFloat64) {
 			// In fastcall, floating-point arguments in
 			// the first four positions are passed in
 			// floating-point registers, which we don't
 			// currently spill. arm passes floating-point
 			// arguments in VFP registers, which we also
 			// don't support.
+			// So basically we only support 386.
 			panic("compileCallback: float arguments not supported")
 		}
 
-- 
GitLab


From 09e059afb1270498f416f5b5c75a6a5683b6d1da Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Jan 2021 11:34:42 -0500
Subject: [PATCH 0706/2400] runtime: enable framepointer on all arm64

Frame pointers were already enabled on linux, darwin, ios,
but not freebsd, android, openbsd, netbsd.

But the space was reserved on all platforms, leading to
two different arm64 framepointer conditions in different
parts of the code, one of which had no name
(framepointer_enabled || GOARCH == "arm64",
which might have been "framepointer_space_reserved").

So on the disabled systems, the stack layouts were still
set up for frame pointers and the only difference was not
actually maintaining the FP register in the generated code.

Reduce complexity by just enabling the frame pointer
completely on all the arm64 systems.

This commit passes on freebsd, android, netbsd.
I have not been able to try it on openbsd.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.
This CL is, however, not windows/arm64-specific.
It is cleanup meant to make the port (and future ports) easier.

Change-Id: I83bd23369d24b76db4c6a648fa74f6917819a093
Reviewed-on: https://go-review.googlesource.com/c/go/+/288814
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/dwarfgen/dwarf.go |   3 +-
 src/cmd/compile/internal/ssagen/pgen.go    |   3 +-
 src/cmd/internal/obj/arm64/a.out.go        |   2 +-
 src/cmd/internal/obj/arm64/obj7.go         | 293 +++++++++++----------
 src/cmd/internal/objabi/util.go            |   2 +-
 src/runtime/runtime2.go                    |   2 +-
 src/runtime/traceback.go                   |  17 +-
 7 files changed, 175 insertions(+), 147 deletions(-)

diff --git a/src/cmd/compile/internal/dwarfgen/dwarf.go b/src/cmd/compile/internal/dwarfgen/dwarf.go
index dd22c033cc..70168cffeb 100644
--- a/src/cmd/compile/internal/dwarfgen/dwarf.go
+++ b/src/cmd/compile/internal/dwarfgen/dwarf.go
@@ -271,8 +271,7 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 		if base.Ctxt.FixedFrameSize() == 0 {
 			offs -= int64(types.PtrSize)
 		}
-		if objabi.Framepointer_enabled || objabi.GOARCH == "arm64" {
-			// There is a word space for FP on ARM64 even if the frame pointer is disabled
+		if objabi.Framepointer_enabled {
 			offs -= int64(types.PtrSize)
 		}
 
diff --git a/src/cmd/compile/internal/ssagen/pgen.go b/src/cmd/compile/internal/ssagen/pgen.go
index 182f8408cf..40f07a8d45 100644
--- a/src/cmd/compile/internal/ssagen/pgen.go
+++ b/src/cmd/compile/internal/ssagen/pgen.go
@@ -213,8 +213,7 @@ func StackOffset(slot ssa.LocalSlot) int32 {
 		if base.Ctxt.FixedFrameSize() == 0 {
 			off -= int64(types.PtrSize)
 		}
-		if objabi.Framepointer_enabled || objabi.GOARCH == "arm64" {
-			// There is a word space for FP on ARM64 even if the frame pointer is disabled
+		if objabi.Framepointer_enabled {
 			off -= int64(types.PtrSize)
 		}
 	case ir.PPARAM, ir.PPARAMOUT:
diff --git a/src/cmd/internal/obj/arm64/a.out.go b/src/cmd/internal/obj/arm64/a.out.go
index 1d1bea505c..7ab9c1475f 100644
--- a/src/cmd/internal/obj/arm64/a.out.go
+++ b/src/cmd/internal/obj/arm64/a.out.go
@@ -239,7 +239,7 @@ const (
 	REGCTXT = REG_R26 // environment for closures
 	REGTMP  = REG_R27 // reserved for liblink
 	REGG    = REG_R28 // G
-	REGFP   = REG_R29 // frame pointer, unused in the Go toolchain
+	REGFP   = REG_R29 // frame pointer
 	REGLINK = REG_R30
 
 	// ARM64 uses R31 as both stack pointer and zero register,
diff --git a/src/cmd/internal/obj/arm64/obj7.go b/src/cmd/internal/obj/arm64/obj7.go
index 3b88543852..8f7648e5d5 100644
--- a/src/cmd/internal/obj/arm64/obj7.go
+++ b/src/cmd/internal/obj/arm64/obj7.go
@@ -622,25 +622,24 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 
 			prologueEnd.Pos = prologueEnd.Pos.WithXlogue(src.PosPrologueEnd)
 
-			if objabi.Framepointer_enabled {
-				q1 = obj.Appendp(q1, c.newprog)
-				q1.Pos = p.Pos
-				q1.As = AMOVD
-				q1.From.Type = obj.TYPE_REG
-				q1.From.Reg = REGFP
-				q1.To.Type = obj.TYPE_MEM
-				q1.To.Reg = REGSP
-				q1.To.Offset = -8
-
-				q1 = obj.Appendp(q1, c.newprog)
-				q1.Pos = p.Pos
-				q1.As = ASUB
-				q1.From.Type = obj.TYPE_CONST
-				q1.From.Offset = 8
-				q1.Reg = REGSP
-				q1.To.Type = obj.TYPE_REG
-				q1.To.Reg = REGFP
-			}
+			// Frame pointer.
+			q1 = obj.Appendp(q1, c.newprog)
+			q1.Pos = p.Pos
+			q1.As = AMOVD
+			q1.From.Type = obj.TYPE_REG
+			q1.From.Reg = REGFP
+			q1.To.Type = obj.TYPE_MEM
+			q1.To.Reg = REGSP
+			q1.To.Offset = -8
+
+			q1 = obj.Appendp(q1, c.newprog)
+			q1.Pos = p.Pos
+			q1.As = ASUB
+			q1.From.Type = obj.TYPE_CONST
+			q1.From.Offset = 8
+			q1.Reg = REGSP
+			q1.To.Type = obj.TYPE_REG
+			q1.To.Reg = REGFP
 
 			if c.cursym.Func().Text.From.Sym.Wrapper() {
 				// if(g->panic != nil && g->panic->argp == FP) g->panic->argp = bottom-of-frame
@@ -765,28 +764,26 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 					p.To.Reg = REGSP
 					p.Spadj = -c.autosize
 
-					if objabi.Framepointer_enabled {
-						p = obj.Appendp(p, c.newprog)
-						p.As = ASUB
-						p.From.Type = obj.TYPE_CONST
-						p.From.Offset = 8
-						p.Reg = REGSP
-						p.To.Type = obj.TYPE_REG
-						p.To.Reg = REGFP
-					}
+					// Frame pointer.
+					p = obj.Appendp(p, c.newprog)
+					p.As = ASUB
+					p.From.Type = obj.TYPE_CONST
+					p.From.Offset = 8
+					p.Reg = REGSP
+					p.To.Type = obj.TYPE_REG
+					p.To.Reg = REGFP
 				}
 			} else {
 				/* want write-back pre-indexed SP+autosize -> SP, loading REGLINK*/
 
-				if objabi.Framepointer_enabled {
-					p.As = AMOVD
-					p.From.Type = obj.TYPE_MEM
-					p.From.Reg = REGSP
-					p.From.Offset = -8
-					p.To.Type = obj.TYPE_REG
-					p.To.Reg = REGFP
-					p = obj.Appendp(p, c.newprog)
-				}
+				// Frame pointer.
+				p.As = AMOVD
+				p.From.Type = obj.TYPE_MEM
+				p.From.Reg = REGSP
+				p.From.Offset = -8
+				p.To.Type = obj.TYPE_REG
+				p.To.Reg = REGFP
+				p = obj.Appendp(p, c.newprog)
 
 				aoffset := c.autosize
 
@@ -821,6 +818,28 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 				}
 			}
 
+			// If enabled, this code emits 'MOV PC, R27' before every 'MOV LR, PC',
+			// so that if you are debugging a low-level crash where PC and LR are zero,
+			// you can look at R27 to see what jumped to the zero.
+			// This is useful when bringing up Go on a new system.
+			// (There is similar code in ../ppc64/obj9.go:/if.false.)
+			const debugRETZERO = false
+			if debugRETZERO {
+				if p.As != obj.ARET {
+					q = newprog()
+					q.Pos = p.Pos
+					q.Link = p.Link
+					p.Link = q
+					p = q
+				}
+				p.As = AADR
+				p.From.Type = obj.TYPE_BRANCH
+				p.From.Offset = 0
+				p.To.Type = obj.TYPE_REG
+				p.To.Reg = REGTMP
+
+			}
+
 			if p.As != obj.ARET {
 				q = newprog()
 				q.Pos = p.Pos
@@ -866,110 +885,106 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 			}
 
 		case obj.ADUFFCOPY:
-			if objabi.Framepointer_enabled {
-				//  ADR	ret_addr, R27
-				//  STP	(FP, R27), -24(SP)
-				//  SUB	24, SP, FP
-				//  DUFFCOPY
-				// ret_addr:
-				//  SUB	8, SP, FP
-
-				q1 := p
-				// copy DUFFCOPY from q1 to q4
-				q4 := obj.Appendp(p, c.newprog)
-				q4.Pos = p.Pos
-				q4.As = obj.ADUFFCOPY
-				q4.To = p.To
-
-				q1.As = AADR
-				q1.From.Type = obj.TYPE_BRANCH
-				q1.To.Type = obj.TYPE_REG
-				q1.To.Reg = REG_R27
-
-				q2 := obj.Appendp(q1, c.newprog)
-				q2.Pos = p.Pos
-				q2.As = ASTP
-				q2.From.Type = obj.TYPE_REGREG
-				q2.From.Reg = REGFP
-				q2.From.Offset = int64(REG_R27)
-				q2.To.Type = obj.TYPE_MEM
-				q2.To.Reg = REGSP
-				q2.To.Offset = -24
-
-				// maintaine FP for DUFFCOPY
-				q3 := obj.Appendp(q2, c.newprog)
-				q3.Pos = p.Pos
-				q3.As = ASUB
-				q3.From.Type = obj.TYPE_CONST
-				q3.From.Offset = 24
-				q3.Reg = REGSP
-				q3.To.Type = obj.TYPE_REG
-				q3.To.Reg = REGFP
-
-				q5 := obj.Appendp(q4, c.newprog)
-				q5.Pos = p.Pos
-				q5.As = ASUB
-				q5.From.Type = obj.TYPE_CONST
-				q5.From.Offset = 8
-				q5.Reg = REGSP
-				q5.To.Type = obj.TYPE_REG
-				q5.To.Reg = REGFP
-				q1.From.SetTarget(q5)
-				p = q5
-			}
+			//  ADR	ret_addr, R27
+			//  STP	(FP, R27), -24(SP)
+			//  SUB	24, SP, FP
+			//  DUFFCOPY
+			// ret_addr:
+			//  SUB	8, SP, FP
+
+			q1 := p
+			// copy DUFFCOPY from q1 to q4
+			q4 := obj.Appendp(p, c.newprog)
+			q4.Pos = p.Pos
+			q4.As = obj.ADUFFCOPY
+			q4.To = p.To
+
+			q1.As = AADR
+			q1.From.Type = obj.TYPE_BRANCH
+			q1.To.Type = obj.TYPE_REG
+			q1.To.Reg = REG_R27
+
+			q2 := obj.Appendp(q1, c.newprog)
+			q2.Pos = p.Pos
+			q2.As = ASTP
+			q2.From.Type = obj.TYPE_REGREG
+			q2.From.Reg = REGFP
+			q2.From.Offset = int64(REG_R27)
+			q2.To.Type = obj.TYPE_MEM
+			q2.To.Reg = REGSP
+			q2.To.Offset = -24
+
+			// maintain FP for DUFFCOPY
+			q3 := obj.Appendp(q2, c.newprog)
+			q3.Pos = p.Pos
+			q3.As = ASUB
+			q3.From.Type = obj.TYPE_CONST
+			q3.From.Offset = 24
+			q3.Reg = REGSP
+			q3.To.Type = obj.TYPE_REG
+			q3.To.Reg = REGFP
+
+			q5 := obj.Appendp(q4, c.newprog)
+			q5.Pos = p.Pos
+			q5.As = ASUB
+			q5.From.Type = obj.TYPE_CONST
+			q5.From.Offset = 8
+			q5.Reg = REGSP
+			q5.To.Type = obj.TYPE_REG
+			q5.To.Reg = REGFP
+			q1.From.SetTarget(q5)
+			p = q5
 
 		case obj.ADUFFZERO:
-			if objabi.Framepointer_enabled {
-				//  ADR	ret_addr, R27
-				//  STP	(FP, R27), -24(SP)
-				//  SUB	24, SP, FP
-				//  DUFFZERO
-				// ret_addr:
-				//  SUB	8, SP, FP
-
-				q1 := p
-				// copy DUFFZERO from q1 to q4
-				q4 := obj.Appendp(p, c.newprog)
-				q4.Pos = p.Pos
-				q4.As = obj.ADUFFZERO
-				q4.To = p.To
-
-				q1.As = AADR
-				q1.From.Type = obj.TYPE_BRANCH
-				q1.To.Type = obj.TYPE_REG
-				q1.To.Reg = REG_R27
-
-				q2 := obj.Appendp(q1, c.newprog)
-				q2.Pos = p.Pos
-				q2.As = ASTP
-				q2.From.Type = obj.TYPE_REGREG
-				q2.From.Reg = REGFP
-				q2.From.Offset = int64(REG_R27)
-				q2.To.Type = obj.TYPE_MEM
-				q2.To.Reg = REGSP
-				q2.To.Offset = -24
-
-				// maintaine FP for DUFFZERO
-				q3 := obj.Appendp(q2, c.newprog)
-				q3.Pos = p.Pos
-				q3.As = ASUB
-				q3.From.Type = obj.TYPE_CONST
-				q3.From.Offset = 24
-				q3.Reg = REGSP
-				q3.To.Type = obj.TYPE_REG
-				q3.To.Reg = REGFP
-
-				q5 := obj.Appendp(q4, c.newprog)
-				q5.Pos = p.Pos
-				q5.As = ASUB
-				q5.From.Type = obj.TYPE_CONST
-				q5.From.Offset = 8
-				q5.Reg = REGSP
-				q5.To.Type = obj.TYPE_REG
-				q5.To.Reg = REGFP
-				q1.From.SetTarget(q5)
-				p = q5
-			}
+			//  ADR	ret_addr, R27
+			//  STP	(FP, R27), -24(SP)
+			//  SUB	24, SP, FP
+			//  DUFFZERO
+			// ret_addr:
+			//  SUB	8, SP, FP
+
+			q1 := p
+			// copy DUFFZERO from q1 to q4
+			q4 := obj.Appendp(p, c.newprog)
+			q4.Pos = p.Pos
+			q4.As = obj.ADUFFZERO
+			q4.To = p.To
+
+			q1.As = AADR
+			q1.From.Type = obj.TYPE_BRANCH
+			q1.To.Type = obj.TYPE_REG
+			q1.To.Reg = REG_R27
+
+			q2 := obj.Appendp(q1, c.newprog)
+			q2.Pos = p.Pos
+			q2.As = ASTP
+			q2.From.Type = obj.TYPE_REGREG
+			q2.From.Reg = REGFP
+			q2.From.Offset = int64(REG_R27)
+			q2.To.Type = obj.TYPE_MEM
+			q2.To.Reg = REGSP
+			q2.To.Offset = -24
+
+			// maintain FP for DUFFZERO
+			q3 := obj.Appendp(q2, c.newprog)
+			q3.Pos = p.Pos
+			q3.As = ASUB
+			q3.From.Type = obj.TYPE_CONST
+			q3.From.Offset = 24
+			q3.Reg = REGSP
+			q3.To.Type = obj.TYPE_REG
+			q3.To.Reg = REGFP
+
+			q5 := obj.Appendp(q4, c.newprog)
+			q5.Pos = p.Pos
+			q5.As = ASUB
+			q5.From.Type = obj.TYPE_CONST
+			q5.From.Offset = 8
+			q5.Reg = REGSP
+			q5.To.Type = obj.TYPE_REG
+			q5.To.Reg = REGFP
+			q1.From.SetTarget(q5)
+			p = q5
 		}
 
 		if p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP && p.Spadj == 0 {
diff --git a/src/cmd/internal/objabi/util.go b/src/cmd/internal/objabi/util.go
index a73ab479a1..1f99f8ed5d 100644
--- a/src/cmd/internal/objabi/util.go
+++ b/src/cmd/internal/objabi/util.go
@@ -137,7 +137,7 @@ func init() {
 }
 
 // Note: must agree with runtime.framepointer_enabled.
-var Framepointer_enabled = GOARCH == "amd64" || GOARCH == "arm64" && (GOOS == "linux" || GOOS == "darwin" || GOOS == "ios")
+var Framepointer_enabled = GOARCH == "amd64" || GOARCH == "arm64"
 
 func addexp(s string) {
 	// Could do general integer parsing here, but the runtime copy doesn't yet.
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index 05520d07b2..5bd283d12f 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -1106,4 +1106,4 @@ var (
 )
 
 // Must agree with cmd/internal/objabi.Framepointer_enabled.
-const framepointer_enabled = GOARCH == "amd64" || GOARCH == "arm64" && (GOOS == "linux" || GOOS == "darwin" || GOOS == "ios")
+const framepointer_enabled = GOARCH == "amd64" || GOARCH == "arm64"
diff --git a/src/runtime/traceback.go b/src/runtime/traceback.go
index 7321790b78..eb185eecd3 100644
--- a/src/runtime/traceback.go
+++ b/src/runtime/traceback.go
@@ -275,7 +275,22 @@ func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max in
 
 		// For architectures with frame pointers, if there's
 		// a frame, then there's a saved frame pointer here.
-		if frame.varp > frame.sp && (GOARCH == "amd64" || GOARCH == "arm64") {
+		//
+		// NOTE: This code is not as general as it looks.
+		// On x86, the ABI is to save the frame pointer word at the
+		// top of the stack frame, so we have to back down over it.
+		// On arm64, the frame pointer should be at the bottom of
+		// the stack (with R29 (aka FP) = RSP), in which case we would
+		// not want to do the subtraction here. But we started out without
+		// any frame pointer, and when we wanted to add it, we didn't
+		// want to break all the assembly doing direct writes to 8(RSP)
+		// to set the first parameter to a called function.
+		// So we decided to write the FP link *below* the stack pointer
+		// (with R29 = RSP - 8 in Go functions).
+		// This is technically ABI-compatible but not standard.
+		// And it happens to end up mimicking the x86 layout.
+		// Other architectures may make different decisions.
+		if frame.varp > frame.sp && framepointer_enabled {
 			frame.varp -= sys.PtrSize
 		}
 
-- 
GitLab


From b6379f190b3820c2765c7589c1fd6292e5581407 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Jan 2021 11:39:48 -0500
Subject: [PATCH 0707/2400] syscall: clean up windows a bit

The files being deleted contain no code.
They exist because back when we used Makefiles
that listed all the Go sources to be compiled, we wrote
patterns like syscall_$GOOS_$GOARCH.go,
and it was easier to create dummy empty files
than introduce conditionals to not look for that
file on Windows.

Now that we have the go command instead,
we don't need those dummy files.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.
This CL is, however, not windows/arm64-specific.
It is cleanup meant to make the port (and future ports) easier.

Change-Id: Ie0066d1dd2bf09802c74c6a496276e8c593e4bc2
Reviewed-on: https://go-review.googlesource.com/c/go/+/288815
Trust: Russ Cox <rsc@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
---
 src/syscall/syscall_windows.go       | 27 +++++++++++++++------------
 src/syscall/syscall_windows_386.go   |  5 -----
 src/syscall/syscall_windows_amd64.go |  5 -----
 src/syscall/zerrors_windows_386.go   |  5 -----
 src/syscall/zerrors_windows_amd64.go |  5 -----
 src/syscall/zsysnum_windows_386.go   |  3 ---
 src/syscall/zsysnum_windows_amd64.go |  3 ---
 7 files changed, 15 insertions(+), 38 deletions(-)
 delete mode 100644 src/syscall/syscall_windows_386.go
 delete mode 100644 src/syscall/syscall_windows_amd64.go
 delete mode 100644 src/syscall/zerrors_windows_386.go
 delete mode 100644 src/syscall/zerrors_windows_amd64.go
 delete mode 100644 src/syscall/zsysnum_windows_386.go
 delete mode 100644 src/syscall/zsysnum_windows_amd64.go

diff --git a/src/syscall/syscall_windows.go b/src/syscall/syscall_windows.go
index ba69133d81..4a576486d1 100644
--- a/src/syscall/syscall_windows.go
+++ b/src/syscall/syscall_windows.go
@@ -414,19 +414,22 @@ const ptrSize = unsafe.Sizeof(uintptr(0))
 // See https://msdn.microsoft.com/en-us/library/windows/desktop/aa365542(v=vs.85).aspx
 func setFilePointerEx(handle Handle, distToMove int64, newFilePointer *int64, whence uint32) error {
 	var e1 Errno
-	switch runtime.GOARCH {
-	default:
-		panic("unsupported architecture")
-	case "amd64":
+	if unsafe.Sizeof(uintptr(0)) == 8 {
 		_, _, e1 = Syscall6(procSetFilePointerEx.Addr(), 4, uintptr(handle), uintptr(distToMove), uintptr(unsafe.Pointer(newFilePointer)), uintptr(whence), 0, 0)
-	case "386":
-		// distToMove is a LARGE_INTEGER:
-		// https://msdn.microsoft.com/en-us/library/windows/desktop/aa383713(v=vs.85).aspx
-		_, _, e1 = Syscall6(procSetFilePointerEx.Addr(), 5, uintptr(handle), uintptr(distToMove), uintptr(distToMove>>32), uintptr(unsafe.Pointer(newFilePointer)), uintptr(whence), 0)
-	case "arm":
-		// distToMove must be 8-byte aligned per ARM calling convention
-		// https://msdn.microsoft.com/en-us/library/dn736986.aspx#Anchor_7
-		_, _, e1 = Syscall6(procSetFilePointerEx.Addr(), 6, uintptr(handle), 0, uintptr(distToMove), uintptr(distToMove>>32), uintptr(unsafe.Pointer(newFilePointer)), uintptr(whence))
+	} else {
+		// Different 32-bit systems disgaree about whether distToMove starts 8-byte aligned.
+		switch runtime.GOARCH {
+		default:
+			panic("unsupported 32-bit architecture")
+		case "386":
+			// distToMove is a LARGE_INTEGER:
+			// https://msdn.microsoft.com/en-us/library/windows/desktop/aa383713(v=vs.85).aspx
+			_, _, e1 = Syscall6(procSetFilePointerEx.Addr(), 5, uintptr(handle), uintptr(distToMove), uintptr(distToMove>>32), uintptr(unsafe.Pointer(newFilePointer)), uintptr(whence), 0)
+		case "arm":
+			// distToMove must be 8-byte aligned per ARM calling convention
+			// https://msdn.microsoft.com/en-us/library/dn736986.aspx#Anchor_7
+			_, _, e1 = Syscall6(procSetFilePointerEx.Addr(), 6, uintptr(handle), 0, uintptr(distToMove), uintptr(distToMove>>32), uintptr(unsafe.Pointer(newFilePointer)), uintptr(whence))
+		}
 	}
 	if e1 != 0 {
 		return errnoErr(e1)
diff --git a/src/syscall/syscall_windows_386.go b/src/syscall/syscall_windows_386.go
deleted file mode 100644
index e82b540b4b..0000000000
--- a/src/syscall/syscall_windows_386.go
+++ /dev/null
@@ -1,5 +0,0 @@
-// Copyright 2009 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 syscall
diff --git a/src/syscall/syscall_windows_amd64.go b/src/syscall/syscall_windows_amd64.go
deleted file mode 100644
index e82b540b4b..0000000000
--- a/src/syscall/syscall_windows_amd64.go
+++ /dev/null
@@ -1,5 +0,0 @@
-// Copyright 2009 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 syscall
diff --git a/src/syscall/zerrors_windows_386.go b/src/syscall/zerrors_windows_386.go
deleted file mode 100644
index 8bc5b6b194..0000000000
--- a/src/syscall/zerrors_windows_386.go
+++ /dev/null
@@ -1,5 +0,0 @@
-// Copyright 2011 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 syscall
diff --git a/src/syscall/zerrors_windows_amd64.go b/src/syscall/zerrors_windows_amd64.go
deleted file mode 100644
index 8bc5b6b194..0000000000
--- a/src/syscall/zerrors_windows_amd64.go
+++ /dev/null
@@ -1,5 +0,0 @@
-// Copyright 2011 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 syscall
diff --git a/src/syscall/zsysnum_windows_386.go b/src/syscall/zsysnum_windows_386.go
deleted file mode 100644
index 36bf065d1f..0000000000
--- a/src/syscall/zsysnum_windows_386.go
+++ /dev/null
@@ -1,3 +0,0 @@
-// nothing to see here
-
-package syscall
diff --git a/src/syscall/zsysnum_windows_amd64.go b/src/syscall/zsysnum_windows_amd64.go
deleted file mode 100644
index 36bf065d1f..0000000000
--- a/src/syscall/zsysnum_windows_amd64.go
+++ /dev/null
@@ -1,3 +0,0 @@
-// nothing to see here
-
-package syscall
-- 
GitLab


From 1c659f25257f29003b7012d90072b63f88d12f8b Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Jan 2021 11:50:58 -0500
Subject: [PATCH 0708/2400] cmd/link: clean up windows PE generation

A bunch of places are a bit too picky about the architecture.
Simplify them.

Also use a large PEBASE for 64-bit systems.
This more closely matches what is usually used on Windows x86-64
and is required for Windows arm64.
Unfortunately, we still need a special case for x86-64 because
of some cgo relocations. This may be fixable separately.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.
This CL is, however, not windows/arm64-specific.
It is cleanup meant to make the port (and future ports) easier.

Change-Id: I65212d28ad4d8c40e2b70dc29f7fce072babecb5
Reviewed-on: https://go-review.googlesource.com/c/go/+/288816
Trust: Russ Cox <rsc@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/link/internal/ld/pe.go | 70 ++++++++++++++++------------------
 1 file changed, 32 insertions(+), 38 deletions(-)

diff --git a/src/cmd/link/internal/ld/pe.go b/src/cmd/link/internal/ld/pe.go
index 5edaf54dd2..c46036c7ea 100644
--- a/src/cmd/link/internal/ld/pe.go
+++ b/src/cmd/link/internal/ld/pe.go
@@ -42,11 +42,11 @@ type IMAGE_EXPORT_DIRECTORY struct {
 	AddressOfNameOrdinals uint32
 }
 
-const (
-	PEBASE = 0x00400000
-)
-
 var (
+	// PEBASE is the base address for the executable.
+	// It is small for 32-bit and large for 64-bit.
+	PEBASE int64
+
 	// SectionAlignment must be greater than or equal to FileAlignment.
 	// The default is the page size for the architecture.
 	PESECTALIGN int64 = 0x1000
@@ -316,8 +316,8 @@ func (sect *peSection) checkOffset(off int64) {
 // checkSegment verifies COFF section sect matches address
 // and file offset provided in segment seg.
 func (sect *peSection) checkSegment(seg *sym.Segment) {
-	if seg.Vaddr-PEBASE != uint64(sect.virtualAddress) {
-		Errorf(nil, "%s.VirtualAddress = %#x, want %#x", sect.name, uint64(int64(sect.virtualAddress)), uint64(int64(seg.Vaddr-PEBASE)))
+	if seg.Vaddr-uint64(PEBASE) != uint64(sect.virtualAddress) {
+		Errorf(nil, "%s.VirtualAddress = %#x, want %#x", sect.name, uint64(int64(sect.virtualAddress)), uint64(int64(seg.Vaddr-uint64(PEBASE))))
 		errorexit()
 	}
 	if seg.Fileoff != uint64(sect.pointerToRawData) {
@@ -852,8 +852,8 @@ func (f *peFile) writeOptionalHeader(ctxt *Link) {
 	}
 	oh64.BaseOfCode = f.textSect.virtualAddress
 	oh.BaseOfCode = f.textSect.virtualAddress
-	oh64.ImageBase = PEBASE
-	oh.ImageBase = PEBASE
+	oh64.ImageBase = uint64(PEBASE)
+	oh.ImageBase = uint32(PEBASE)
 	oh64.SectionAlignment = uint32(PESECTALIGN)
 	oh.SectionAlignment = uint32(PESECTALIGN)
 	oh64.FileAlignment = uint32(PEFILEALIGN)
@@ -891,13 +891,7 @@ func (f *peFile) writeOptionalHeader(ctxt *Link) {
 	oh.DllCharacteristics |= pe.IMAGE_DLLCHARACTERISTICS_NX_COMPAT
 
 	// The DLL can be relocated at load time.
-	switch ctxt.Arch.Family {
-	case sys.AMD64, sys.I386:
-		if ctxt.BuildMode == BuildModePIE {
-			oh64.DllCharacteristics |= pe.IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE
-			oh.DllCharacteristics |= pe.IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE
-		}
-	case sys.ARM:
+	if needPEBaseReloc(ctxt) {
 		oh64.DllCharacteristics |= pe.IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE
 		oh.DllCharacteristics |= pe.IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE
 	}
@@ -975,18 +969,23 @@ var pefile peFile
 func Peinit(ctxt *Link) {
 	var l int
 
-	switch ctxt.Arch.Family {
-	// 64-bit architectures
-	case sys.AMD64:
+	if ctxt.Arch.PtrSize == 8 {
+		// 64-bit architectures
 		pe64 = 1
+		PEBASE = 1 << 32
+		if ctxt.Arch.Family == sys.AMD64 {
+			// TODO(rsc): For cgo we currently use 32-bit relocations
+			// that fail when PEBASE is too large.
+			// We need to fix this, but for now, use a smaller PEBASE.
+			PEBASE = 1 << 22
+		}
 		var oh64 pe.OptionalHeader64
 		l = binary.Size(&oh64)
-
-	// 32-bit architectures
-	default:
+	} else {
+		// 32-bit architectures
+		PEBASE = 1 << 22
 		var oh pe.OptionalHeader32
 		l = binary.Size(&oh)
-
 	}
 
 	if ctxt.LinkMode == LinkExternal {
@@ -1210,7 +1209,7 @@ func addimports(ctxt *Link, datsect *peSection) {
 	endoff := ctxt.Out.Offset()
 
 	// write FirstThunks (allocated in .data section)
-	ftbase := uint64(ldr.SymValue(dynamic)) - uint64(datsect.virtualAddress) - PEBASE
+	ftbase := uint64(ldr.SymValue(dynamic)) - uint64(datsect.virtualAddress) - uint64(PEBASE)
 
 	ctxt.Out.SeekSet(int64(uint64(datsect.pointerToRawData) + ftbase))
 	for d := dr; d != nil; d = d.next {
@@ -1463,17 +1462,18 @@ func addPEBaseRelocSym(ldr *loader.Loader, s loader.Sym, rt *peBaseRelocTable) {
 	}
 }
 
+func needPEBaseReloc(ctxt *Link) bool {
+	// Non-PIE x86 binaries don't need the base relocation table.
+	// Everyone else does.
+	if (ctxt.Arch.Family == sys.I386 || ctxt.Arch.Family == sys.AMD64) && ctxt.BuildMode != BuildModePIE {
+		return false
+	}
+	return true
+}
+
 func addPEBaseReloc(ctxt *Link) {
-	// Arm does not work without base relocation table.
-	// 386 and amd64 will only require the table for BuildModePIE.
-	switch ctxt.Arch.Family {
-	default:
+	if !needPEBaseReloc(ctxt) {
 		return
-	case sys.I386, sys.AMD64:
-		if ctxt.BuildMode != BuildModePIE {
-			return
-		}
-	case sys.ARM:
 	}
 
 	var rt peBaseRelocTable
@@ -1562,12 +1562,6 @@ func addpersrc(ctxt *Link) {
 }
 
 func asmbPe(ctxt *Link) {
-	switch ctxt.Arch.Family {
-	default:
-		Exitf("unknown PE architecture: %v", ctxt.Arch.Family)
-	case sys.AMD64, sys.I386, sys.ARM:
-	}
-
 	t := pefile.addSection(".text", int(Segtext.Length), int(Segtext.Length))
 	t.characteristics = IMAGE_SCN_CNT_CODE | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ
 	if ctxt.LinkMode == LinkExternal {
-- 
GitLab


From a1222b75350a098e70106bf95d4e6a962c37f373 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 22 Jan 2021 11:13:32 -0500
Subject: [PATCH 0709/2400] cmd/link: add debug print in deadcode

This matches the prints that deadcode prints later
as the algorithm progresses under -v=2.
It helps to see the initial conditions with -v=2 as well.

Change-Id: I06ae86fe9bd8314d003148f3d941832c9b10aef1
Reviewed-on: https://go-review.googlesource.com/c/go/+/288817
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/link/internal/ld/deadcode.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/cmd/link/internal/ld/deadcode.go b/src/cmd/link/internal/ld/deadcode.go
index 245076a83a..1874103b93 100644
--- a/src/cmd/link/internal/ld/deadcode.go
+++ b/src/cmd/link/internal/ld/deadcode.go
@@ -91,6 +91,10 @@ func (d *deadcodePass) init() {
 		names = append(names, exp)
 	}
 
+	if d.ctxt.Debugvlog > 1 {
+		d.ctxt.Logf("deadcode start names: %v\n", names)
+	}
+
 	for _, name := range names {
 		// Mark symbol as a data/ABI0 symbol.
 		d.mark(d.ldr.Lookup(name, 0), 0)
-- 
GitLab


From bb6efb96092cc8ae398c29e3b052a0051c746f88 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 26 Jan 2021 21:14:43 -0500
Subject: [PATCH 0710/2400] build: set GOPATH consistently in run.bash,
 run.bat, run.rc

We used to clear GOPATH in all the build scripts.
Clearing GOPATH is misleading at best, since you just end up
with the default GOPATH (%USERPROFILE%\go on Windows).
Unless that's your GOROOT, in which case you end up with a
fatal error from the go command (#43938).

run.bash changed to setting GOPATH=/dev/null, which has no
clear analogue on Windows.

run.rc still clears GOPATH.

Change them all to set GOPATH to a non-existent directory
/nonexist-gopath or c:\nonexist-gopath.

Change-Id: I51edd66d37ff6a891b0d0541d91ecba97fbbb03d
Reviewed-on: https://go-review.googlesource.com/c/go/+/288818
Trust: Russ Cox <rsc@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
---
 src/run.bash | 10 +---------
 src/run.bat  |  4 +---
 src/run.rc   |  9 ++++-----
 3 files changed, 6 insertions(+), 17 deletions(-)

diff --git a/src/run.bash b/src/run.bash
index 706b4b60ee..2123c509f8 100755
--- a/src/run.bash
+++ b/src/run.bash
@@ -23,15 +23,7 @@ fi
 
 eval $(../bin/go env)
 export GOROOT   # The api test requires GOROOT to be set, so set it to match ../bin/go.
-
-# We disallow local import for non-local packages, if $GOROOT happens
-# to be under $GOPATH, then some tests below will fail.  $GOPATH needs
-# to be set to a non-empty string, else Go will set a default value
-# that may also conflict with $GOROOT.  The $GOPATH value doesn't need
-# to point to an actual directory, it just needs to pass the semantic
-# checks performed by Go.  Use $GOROOT to define $GOPATH so that we
-# don't blunder into a user-defined symbolic link.
-export GOPATH=/dev/null
+export GOPATH=/nonexist-gopath
 
 unset CDPATH	# in case user has it set
 export GOBIN=$GOROOT/bin  # Issue 14340
diff --git a/src/run.bat b/src/run.bat
index c299671c13..edcaf52659 100644
--- a/src/run.bat
+++ b/src/run.bat
@@ -18,9 +18,7 @@ setlocal
 
 set GOBUILDFAIL=0
 
-:: we disallow local import for non-local packages, if %GOROOT% happens
-:: to be under %GOPATH%, then some tests below will fail
-set GOPATH=
+set GOPATH=c:\nonexist-gopath
 :: Issue 14340: ignore GOBIN during all.bat.
 set GOBIN=
 set GOFLAGS=
diff --git a/src/run.rc b/src/run.rc
index ab7abfa991..a7b4801207 100755
--- a/src/run.rc
+++ b/src/run.rc
@@ -12,10 +12,9 @@ if(! test -f ../bin/go){
 
 eval `{../bin/go env}
 
-GOPATH = () # we disallow local import for non-local packages, if $GOROOT happens
-            # to be under $GOPATH, then some tests below will fail
-GOBIN = () # Issue 14340
-GOFLAGS = ()
-GO111MODULE = ()
+GOPATH=/nonexist-gopath
+GOBIN=() # Issue 14340
+GOFLAGS=()
+GO111MODULE=()
 
 exec ../bin/go tool dist test -rebuild $*
-- 
GitLab


From 0c633125f25966fa749ff8003393216aa454e909 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 22 Jan 2021 09:25:40 -0500
Subject: [PATCH 0711/2400] cmd/dist: add windows/arm64 support

- Add Windows SystemInfo constant for arm64
- Add windows/arm64 to GOOS/GOARCH list

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.

Change-Id: I6109bd87512b5cb1d227d7a85fd0ac20eb2259e5
Reviewed-on: https://go-review.googlesource.com/c/go/+/288819
Trust: Russ Cox <rsc@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/cmd/dist/build.go       | 1 +
 src/cmd/dist/sys_windows.go | 5 +++++
 2 files changed, 6 insertions(+)

diff --git a/src/cmd/dist/build.go b/src/cmd/dist/build.go
index 332f2fab58..c02b92818c 100644
--- a/src/cmd/dist/build.go
+++ b/src/cmd/dist/build.go
@@ -1575,6 +1575,7 @@ var cgoEnabled = map[string]bool{
 	"windows/386":     true,
 	"windows/amd64":   true,
 	"windows/arm":     false,
+	"windows/arm64":   false,
 }
 
 // List of platforms which are supported but not complete yet. These get
diff --git a/src/cmd/dist/sys_windows.go b/src/cmd/dist/sys_windows.go
index 2f6a1b0dce..265f729d0f 100644
--- a/src/cmd/dist/sys_windows.go
+++ b/src/cmd/dist/sys_windows.go
@@ -29,10 +29,13 @@ type systeminfo struct {
 	wProcessorRevision          uint16
 }
 
+// See https://docs.microsoft.com/en-us/windows/win32/api/sysinfoapi/ns-sysinfoapi-system_info
 const (
 	PROCESSOR_ARCHITECTURE_AMD64 = 9
 	PROCESSOR_ARCHITECTURE_INTEL = 0
 	PROCESSOR_ARCHITECTURE_ARM   = 5
+	PROCESSOR_ARCHITECTURE_ARM64 = 12
+	PROCESSOR_ARCHITECTURE_IA64  = 6
 )
 
 var sysinfo systeminfo
@@ -46,6 +49,8 @@ func sysinit() {
 		gohostarch = "386"
 	case PROCESSOR_ARCHITECTURE_ARM:
 		gohostarch = "arm"
+	case PROCESSOR_ARCHITECTURE_ARM64:
+		gohostarch = "arm64"
 	default:
 		fatalf("unknown processor architecture")
 	}
-- 
GitLab


From 0ca0551f02257283d00c01303100a16433c526c6 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 22 Jan 2021 09:32:38 -0500
Subject: [PATCH 0712/2400] debug/pe: recognize arm64 executables

We still need to add test data, but as yet we haven't identified
a good Windows arm64 compiler to produce small binaries.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.

Change-Id: Ifbecb9a6e25f7af38e20b7d7830df7f5efe2798a
Reviewed-on: https://go-review.googlesource.com/c/go/+/288820
Trust: Russ Cox <rsc@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
---
 src/debug/pe/file.go | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/debug/pe/file.go b/src/debug/pe/file.go
index 7d763fff19..e50229e5a3 100644
--- a/src/debug/pe/file.go
+++ b/src/debug/pe/file.go
@@ -75,7 +75,7 @@ func NewFile(r io.ReaderAt) (*File, error) {
 		var sign [4]byte
 		r.ReadAt(sign[:], signoff)
 		if !(sign[0] == 'P' && sign[1] == 'E' && sign[2] == 0 && sign[3] == 0) {
-			return nil, fmt.Errorf("Invalid PE COFF file signature of %v.", sign)
+			return nil, fmt.Errorf("invalid PE file signature: % x", sign)
 		}
 		base = signoff + 4
 	} else {
@@ -86,9 +86,14 @@ func NewFile(r io.ReaderAt) (*File, error) {
 		return nil, err
 	}
 	switch f.FileHeader.Machine {
-	case IMAGE_FILE_MACHINE_UNKNOWN, IMAGE_FILE_MACHINE_ARMNT, IMAGE_FILE_MACHINE_AMD64, IMAGE_FILE_MACHINE_I386:
+	case IMAGE_FILE_MACHINE_AMD64,
+		IMAGE_FILE_MACHINE_ARM64,
+		IMAGE_FILE_MACHINE_ARMNT,
+		IMAGE_FILE_MACHINE_I386,
+		IMAGE_FILE_MACHINE_UNKNOWN:
+		// ok
 	default:
-		return nil, fmt.Errorf("Unrecognised COFF file header machine value of 0x%x.", f.FileHeader.Machine)
+		return nil, fmt.Errorf("unrecognized PE machine: %#x", f.FileHeader.Machine)
 	}
 
 	var err error
@@ -112,7 +117,7 @@ func NewFile(r io.ReaderAt) (*File, error) {
 	// Seek past file header.
 	_, err = sr.Seek(base+int64(binary.Size(f.FileHeader)), seekStart)
 	if err != nil {
-		return nil, fmt.Errorf("failure to seek past the file header: %v", err)
+		return nil, err
 	}
 
 	// Read optional header.
@@ -309,7 +314,7 @@ func (f *File) ImportedSymbols() ([]string, error) {
 		return nil, nil
 	}
 
-	pe64 := f.Machine == IMAGE_FILE_MACHINE_AMD64
+	pe64 := f.Machine == IMAGE_FILE_MACHINE_AMD64 || f.Machine == IMAGE_FILE_MACHINE_ARM64
 
 	// grab the number of data directory entries
 	var dd_length uint32
-- 
GitLab


From 95a44d2409dc9b37cb4722d74a1de9b671f67128 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 22 Jan 2021 09:23:49 -0500
Subject: [PATCH 0713/2400] cmd/internal/objfile: recognize Windows ARM64
 executables

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.

Change-Id: I5ec459063d394b9f434d1b8b5030960b45061038
Reviewed-on: https://go-review.googlesource.com/c/go/+/288821
Trust: Russ Cox <rsc@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
---
 src/cmd/internal/objfile/pe.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/cmd/internal/objfile/pe.go b/src/cmd/internal/objfile/pe.go
index b20cda9a44..9088866fcf 100644
--- a/src/cmd/internal/objfile/pe.go
+++ b/src/cmd/internal/objfile/pe.go
@@ -189,6 +189,8 @@ func (f *peFile) goarch() string {
 		return "amd64"
 	case pe.IMAGE_FILE_MACHINE_ARMNT:
 		return "arm"
+	case pe.IMAGE_FILE_MACHINE_ARM64:
+		return "arm64"
 	default:
 		return ""
 	}
-- 
GitLab


From 985d0877829bf13f51120c4743c08ac82c0c8d62 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Jan 2021 12:35:16 -0500
Subject: [PATCH 0714/2400] cmd/link: add windows/arm64 support

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.

Change-Id: I397c1d238bb18cbe78b3fca00910660cf1d66b8d
Reviewed-on: https://go-review.googlesource.com/c/go/+/288822
Trust: Russ Cox <rsc@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
---
 src/cmd/link/internal/arm64/asm.go | 34 ++++++++++++++++++++++++++++++
 src/cmd/link/internal/arm64/obj.go |  5 +++++
 src/cmd/link/internal/ld/config.go |  6 +++---
 src/cmd/link/internal/ld/pe.go     | 28 +++++++++++++++++++++++-
 4 files changed, 69 insertions(+), 4 deletions(-)

diff --git a/src/cmd/link/internal/arm64/asm.go b/src/cmd/link/internal/arm64/asm.go
index 14a20a17d5..72093268c2 100644
--- a/src/cmd/link/internal/arm64/asm.go
+++ b/src/cmd/link/internal/arm64/asm.go
@@ -568,6 +568,40 @@ func machoreloc1(arch *sys.Arch, out *ld.OutBuf, ldr *loader.Loader, s loader.Sy
 	return true
 }
 
+func pereloc1(arch *sys.Arch, out *ld.OutBuf, ldr *loader.Loader, s loader.Sym, r loader.ExtReloc, sectoff int64) bool {
+	var v uint32
+
+	rs := r.Xsym
+	rt := r.Type
+
+	if ldr.SymDynid(rs) < 0 {
+		ldr.Errorf(s, "reloc %d (%s) to non-coff symbol %s type=%d (%s)", rt, sym.RelocName(arch, rt), ldr.SymName(rs), ldr.SymType(rs), ldr.SymType(rs))
+		return false
+	}
+
+	out.Write32(uint32(sectoff))
+	out.Write32(uint32(ldr.SymDynid(rs)))
+
+	switch rt {
+	default:
+		return false
+
+	case objabi.R_DWARFSECREF:
+		v = ld.IMAGE_REL_ARM64_SECREL
+
+	case objabi.R_ADDR:
+		if r.Size == 8 {
+			v = ld.IMAGE_REL_ARM64_ADDR64
+		} else {
+			v = ld.IMAGE_REL_ARM64_ADDR32
+		}
+	}
+
+	out.Write16(uint16(v))
+
+	return true
+}
+
 func archreloc(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, r loader.Reloc, s loader.Sym, val int64) (int64, int, bool) {
 	const noExtReloc = 0
 	const isOk = true
diff --git a/src/cmd/link/internal/arm64/obj.go b/src/cmd/link/internal/arm64/obj.go
index bd13295e61..18a32531e9 100644
--- a/src/cmd/link/internal/arm64/obj.go
+++ b/src/cmd/link/internal/arm64/obj.go
@@ -58,6 +58,7 @@ func Init() (*sys.Arch, ld.Arch) {
 		GenSymsLate:      gensymlate,
 		Machoreloc1:      machoreloc1,
 		MachorelocSize:   8,
+		PEreloc1:         pereloc1,
 
 		Androiddynld: "/system/bin/linker64",
 		Linuxdynld:   "/lib/ld-linux-aarch64.so.1",
@@ -108,5 +109,9 @@ func archinit(ctxt *ld.Link) {
 		if *ld.FlagRound == -1 {
 			*ld.FlagRound = 16384 // 16K page alignment
 		}
+
+	case objabi.Hwindows: /* PE executable */
+		// ld.HEADR, ld.FlagTextAddr, ld.FlagRound are set in ld.Peinit
+		return
 	}
 }
diff --git a/src/cmd/link/internal/ld/config.go b/src/cmd/link/internal/ld/config.go
index d1e06239a5..481dc67475 100644
--- a/src/cmd/link/internal/ld/config.go
+++ b/src/cmd/link/internal/ld/config.go
@@ -36,7 +36,7 @@ func (mode *BuildMode) Set(s string) error {
 		return fmt.Errorf("invalid buildmode: %q", s)
 	case "exe":
 		switch objabi.GOOS + "/" + objabi.GOARCH {
-		case "darwin/arm64", "windows/arm": // On these platforms, everything is PIE
+		case "darwin/arm64", "windows/arm", "windows/arm64": // On these platforms, everything is PIE
 			*mode = BuildModePIE
 		default:
 			*mode = BuildModeExe
@@ -65,7 +65,7 @@ func (mode *BuildMode) Set(s string) error {
 			}
 		case "windows":
 			switch objabi.GOARCH {
-			case "amd64", "386", "arm":
+			case "amd64", "386", "arm", "arm64":
 			default:
 				return badmode()
 			}
@@ -220,7 +220,7 @@ func mustLinkExternal(ctxt *Link) (res bool, reason string) {
 	case BuildModePIE:
 		switch objabi.GOOS + "/" + objabi.GOARCH {
 		case "linux/amd64", "linux/arm64", "android/arm64":
-		case "windows/386", "windows/amd64", "windows/arm":
+		case "windows/386", "windows/amd64", "windows/arm", "windows/arm64":
 		case "darwin/amd64", "darwin/arm64":
 		default:
 			// Internal linking does not support TLS_IE.
diff --git a/src/cmd/link/internal/ld/pe.go b/src/cmd/link/internal/ld/pe.go
index c46036c7ea..36c8e0da9a 100644
--- a/src/cmd/link/internal/ld/pe.go
+++ b/src/cmd/link/internal/ld/pe.go
@@ -69,6 +69,7 @@ const (
 	IMAGE_SCN_ALIGN_32BYTES          = 0x600000
 )
 
+// See https://docs.microsoft.com/en-us/windows/win32/debug/pe-format.
 // TODO(crawshaw): add these constants to debug/pe.
 const (
 	// TODO: the Microsoft doco says IMAGE_SYM_DTYPE_ARRAY is 3 and IMAGE_SYM_DTYPE_FUNCTION is 2
@@ -95,6 +96,25 @@ const (
 	IMAGE_REL_ARM_BRANCH11 = 0x0004
 	IMAGE_REL_ARM_SECREL   = 0x000F
 
+	IMAGE_REL_ARM64_ABSOLUTE       = 0x0000
+	IMAGE_REL_ARM64_ADDR32         = 0x0001
+	IMAGE_REL_ARM64_ADDR32NB       = 0x0002
+	IMAGE_REL_ARM64_BRANCH26       = 0x0003
+	IMAGE_REL_ARM64_PAGEBASE_REL21 = 0x0004
+	IMAGE_REL_ARM64_REL21          = 0x0005
+	IMAGE_REL_ARM64_PAGEOFFSET_12A = 0x0006
+	IMAGE_REL_ARM64_PAGEOFFSET_12L = 0x0007
+	IMAGE_REL_ARM64_SECREL         = 0x0008
+	IMAGE_REL_ARM64_SECREL_LOW12A  = 0x0009
+	IMAGE_REL_ARM64_SECREL_HIGH12A = 0x000A
+	IMAGE_REL_ARM64_SECREL_LOW12L  = 0x000B
+	IMAGE_REL_ARM64_TOKEN          = 0x000C
+	IMAGE_REL_ARM64_SECTION        = 0x000D
+	IMAGE_REL_ARM64_ADDR64         = 0x000E
+	IMAGE_REL_ARM64_BRANCH19       = 0x000F
+	IMAGE_REL_ARM64_BRANCH14       = 0x0010
+	IMAGE_REL_ARM64_REL32          = 0x0011
+
 	IMAGE_REL_BASED_HIGHLOW = 3
 	IMAGE_REL_BASED_DIR64   = 10
 )
@@ -465,6 +485,8 @@ func (f *peFile) addInitArray(ctxt *Link) *peSection {
 		size = 8
 	case "arm":
 		size = 4
+	case "arm64":
+		size = 8
 	}
 	sect := f.addSection(".ctors", size, size)
 	sect.characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ
@@ -477,7 +499,7 @@ func (f *peFile) addInitArray(ctxt *Link) *peSection {
 	switch objabi.GOARCH {
 	case "386", "arm":
 		ctxt.Out.Write32(uint32(addr))
-	case "amd64":
+	case "amd64", "arm64":
 		ctxt.Out.Write64(addr)
 	}
 	return sect
@@ -594,6 +616,8 @@ dwarfLoop:
 			ctxt.Out.Write16(IMAGE_REL_AMD64_ADDR64)
 		case "arm":
 			ctxt.Out.Write16(IMAGE_REL_ARM_ADDR32)
+		case "arm64":
+			ctxt.Out.Write16(IMAGE_REL_ARM64_ADDR64)
 		}
 		return 1
 	})
@@ -788,6 +812,8 @@ func (f *peFile) writeFileHeader(ctxt *Link) {
 		fh.Machine = pe.IMAGE_FILE_MACHINE_I386
 	case sys.ARM:
 		fh.Machine = pe.IMAGE_FILE_MACHINE_ARMNT
+	case sys.ARM64:
+		fh.Machine = pe.IMAGE_FILE_MACHINE_ARM64
 	}
 
 	fh.NumberOfSections = uint16(len(f.sections))
-- 
GitLab


From a3b97e7628680984ae6f29e5af945c11a30e6bdc Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Jan 2021 01:01:18 -0500
Subject: [PATCH 0715/2400] test: disable nilptr on windows/arm64

The address space starts at 4GB, so dummy is too far out.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.

Change-Id: I5f67e268ce729086d9f9fc8541722fabccfd0145
Reviewed-on: https://go-review.googlesource.com/c/go/+/288823
Trust: Russ Cox <rsc@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
---
 test/nilptr.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/nilptr.go b/test/nilptr.go
index c9a044dd36..b296c88c99 100644
--- a/test/nilptr.go
+++ b/test/nilptr.go
@@ -9,7 +9,8 @@
 
 // +build !aix
 // +build !darwin !arm64
-// Address space starts at 1<<32 on AIX and on darwin/arm64, so dummy is too far.
+// +build !windows !arm64
+// Address space starts at 1<<32 on AIX and on darwin/arm64 and on windows/arm64, so dummy is too far.
 
 package main
 
-- 
GitLab


From ac024a0c7bd799dcb3d8cd1f9b55a3047a14556e Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 26 Jan 2021 21:23:55 -0500
Subject: [PATCH 0716/2400] cmd/vendor: get golang.org/x/sys@beda7e5e158

This brings in the windows/arm64 support, along with other recent changes.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.

Change-Id: Ifaca710093376c658ecf91239aa05cc33af98a31
Reviewed-on: https://go-review.googlesource.com/c/go/+/288824
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
---
 src/cmd/go.mod                                |    2 +-
 src/cmd/go.sum                                |    4 +-
 .../vendor/golang.org/x/sys/unix/mkerrors.sh  |    6 +-
 .../golang.org/x/sys/unix/ptrace_darwin.go    |   11 +
 .../golang.org/x/sys/unix/ptrace_ios.go       |   11 +
 .../golang.org/x/sys/unix/syscall_aix.go      |   10 +-
 .../golang.org/x/sys/unix/syscall_bsd.go      |    8 +-
 .../golang.org/x/sys/unix/syscall_darwin.go   |   24 +-
 .../x/sys/unix/syscall_darwin_386.go          |    2 +-
 .../x/sys/unix/syscall_darwin_amd64.go        |    2 +-
 .../x/sys/unix/syscall_darwin_arm.go          |    2 +-
 .../x/sys/unix/syscall_darwin_arm64.go        |    2 +-
 .../x/sys/unix/syscall_dragonfly.go           |   17 +-
 .../golang.org/x/sys/unix/syscall_freebsd.go  |    8 +-
 .../golang.org/x/sys/unix/syscall_illumos.go  |   13 -
 .../golang.org/x/sys/unix/syscall_linux.go    |   18 +-
 .../x/sys/unix/syscall_linux_386.go           |    6 +-
 .../x/sys/unix/syscall_linux_amd64.go         |    2 +-
 .../x/sys/unix/syscall_linux_arm.go           |   10 +-
 .../x/sys/unix/syscall_linux_arm64.go         |    2 +-
 .../x/sys/unix/syscall_linux_mips64x.go       |    2 +-
 .../x/sys/unix/syscall_linux_mipsx.go         |    8 +-
 .../x/sys/unix/syscall_linux_ppc64x.go        |    4 +-
 .../x/sys/unix/syscall_linux_riscv64.go       |    2 +-
 .../x/sys/unix/syscall_linux_s390x.go         |    2 +-
 .../x/sys/unix/syscall_linux_sparc64.go       |    4 +-
 .../golang.org/x/sys/unix/syscall_netbsd.go   |   21 +-
 .../golang.org/x/sys/unix/syscall_openbsd.go  |    4 +-
 .../golang.org/x/sys/unix/syscall_solaris.go  |   16 +-
 .../golang.org/x/sys/unix/timestruct.go       |   26 +-
 .../x/sys/unix/zerrors_darwin_amd64.go        |   62 +-
 .../x/sys/unix/zerrors_darwin_arm64.go        |   62 +-
 .../golang.org/x/sys/unix/zerrors_linux.go    |  157 +-
 .../x/sys/unix/zerrors_linux_386.go           |    6 +-
 .../x/sys/unix/zerrors_linux_amd64.go         |    6 +-
 .../x/sys/unix/zerrors_linux_arm.go           |    6 +-
 .../x/sys/unix/zerrors_linux_arm64.go         |    9 +-
 .../x/sys/unix/zerrors_linux_mips.go          |    6 +-
 .../x/sys/unix/zerrors_linux_mips64.go        |    6 +-
 .../x/sys/unix/zerrors_linux_mips64le.go      |    6 +-
 .../x/sys/unix/zerrors_linux_mipsle.go        |    6 +-
 .../x/sys/unix/zerrors_linux_ppc64.go         |    6 +-
 .../x/sys/unix/zerrors_linux_ppc64le.go       |    6 +-
 .../x/sys/unix/zerrors_linux_riscv64.go       |    6 +-
 .../x/sys/unix/zerrors_linux_s390x.go         |    6 +-
 .../x/sys/unix/zerrors_linux_sparc64.go       |    6 +-
 .../x/sys/unix/zsyscall_darwin_386.go         |    8 +-
 .../x/sys/unix/zsyscall_darwin_amd64.go       |    8 +-
 .../x/sys/unix/zsyscall_darwin_arm.go         |    6 +-
 .../x/sys/unix/zsyscall_darwin_arm64.go       |    8 +-
 .../x/sys/unix/zsyscall_dragonfly_amd64.go    |    6 +-
 .../x/sys/unix/zsyscall_illumos_amd64.go      |   15 +-
 .../x/sys/unix/zsyscall_netbsd_386.go         |   10 +
 .../x/sys/unix/zsyscall_netbsd_amd64.go       |   10 +
 .../x/sys/unix/zsyscall_netbsd_arm.go         |   10 +
 .../x/sys/unix/zsyscall_netbsd_arm64.go       |   10 +
 .../x/sys/unix/zsyscall_solaris_amd64.go      |   27 +
 .../x/sys/unix/zsysnum_linux_386.go           |    2 +
 .../x/sys/unix/zsysnum_linux_amd64.go         |    2 +
 .../x/sys/unix/zsysnum_linux_arm.go           |    2 +
 .../x/sys/unix/zsysnum_linux_arm64.go         |    2 +
 .../x/sys/unix/zsysnum_linux_mips.go          |    2 +
 .../x/sys/unix/zsysnum_linux_mips64.go        |    2 +
 .../x/sys/unix/zsysnum_linux_mips64le.go      |    2 +
 .../x/sys/unix/zsysnum_linux_mipsle.go        |    2 +
 .../x/sys/unix/zsysnum_linux_ppc64.go         |    2 +
 .../x/sys/unix/zsysnum_linux_ppc64le.go       |    2 +
 .../x/sys/unix/zsysnum_linux_riscv64.go       |    2 +
 .../x/sys/unix/zsysnum_linux_s390x.go         |    2 +
 .../x/sys/unix/zsysnum_linux_sparc64.go       |    2 +
 .../golang.org/x/sys/unix/ztypes_aix_ppc.go   |    1 +
 .../golang.org/x/sys/unix/ztypes_aix_ppc64.go |    1 +
 .../x/sys/unix/ztypes_darwin_amd64.go         |    8 +
 .../x/sys/unix/ztypes_darwin_arm64.go         |    8 +
 .../x/sys/unix/ztypes_dragonfly_amd64.go      |    1 +
 .../x/sys/unix/ztypes_freebsd_386.go          |    1 +
 .../x/sys/unix/ztypes_freebsd_amd64.go        |    1 +
 .../x/sys/unix/ztypes_freebsd_arm.go          |    1 +
 .../x/sys/unix/ztypes_freebsd_arm64.go        |    1 +
 .../golang.org/x/sys/unix/ztypes_linux.go     | 1496 ++++++++++++-----
 .../golang.org/x/sys/unix/ztypes_linux_386.go |    2 +-
 .../x/sys/unix/ztypes_linux_amd64.go          |    2 +-
 .../golang.org/x/sys/unix/ztypes_linux_arm.go |    2 +-
 .../x/sys/unix/ztypes_linux_arm64.go          |    2 +-
 .../x/sys/unix/ztypes_linux_mips.go           |    2 +-
 .../x/sys/unix/ztypes_linux_mips64.go         |    2 +-
 .../x/sys/unix/ztypes_linux_mips64le.go       |    2 +-
 .../x/sys/unix/ztypes_linux_mipsle.go         |    2 +-
 .../x/sys/unix/ztypes_linux_ppc64.go          |    2 +-
 .../x/sys/unix/ztypes_linux_ppc64le.go        |    2 +-
 .../x/sys/unix/ztypes_linux_riscv64.go        |    2 +-
 .../x/sys/unix/ztypes_linux_s390x.go          |    2 +-
 .../x/sys/unix/ztypes_linux_sparc64.go        |    2 +-
 .../x/sys/unix/ztypes_netbsd_386.go           |    1 +
 .../x/sys/unix/ztypes_netbsd_amd64.go         |    1 +
 .../x/sys/unix/ztypes_netbsd_arm.go           |    1 +
 .../x/sys/unix/ztypes_netbsd_arm64.go         |    1 +
 .../x/sys/unix/ztypes_openbsd_386.go          |    1 +
 .../x/sys/unix/ztypes_openbsd_amd64.go        |    1 +
 .../x/sys/unix/ztypes_openbsd_arm.go          |    1 +
 .../x/sys/unix/ztypes_openbsd_arm64.go        |    1 +
 .../x/sys/unix/ztypes_openbsd_mips64.go       |    1 +
 .../x/sys/unix/ztypes_solaris_amd64.go        |    1 +
 .../x/sys/windows/syscall_windows.go          |   35 +-
 .../golang.org/x/sys/windows/types_windows.go |  311 +++-
 .../x/sys/windows/types_windows_arm64.go      |   34 +
 .../x/sys/windows/zsyscall_windows.go         |  154 +-
 src/cmd/vendor/modules.txt                    |    2 +-
 src/go.mod                                    |    2 +-
 src/go.sum                                    |    4 +-
 src/vendor/modules.txt                        |    2 +-
 111 files changed, 2226 insertions(+), 628 deletions(-)
 create mode 100644 src/cmd/vendor/golang.org/x/sys/unix/ptrace_darwin.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/unix/ptrace_ios.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/windows/types_windows_arm64.go

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index 235e28f64f..5414e5e688 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -7,6 +7,6 @@ require (
 	golang.org/x/arch v0.0.0-20201008161808-52c3e6f60cff
 	golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897
 	golang.org/x/mod v0.4.1
-	golang.org/x/sys v0.0.0-20201204225414-ed752295db88 // indirect
+	golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e // indirect
 	golang.org/x/tools v0.0.0-20210107193943-4ed967dd8eff
 )
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 70aae0b4cc..3dc0565f65 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -25,8 +25,8 @@ golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5h
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201204225414-ed752295db88 h1:KmZPnMocC93w341XZp26yTJg8Za7lhb2KhkYmixoeso=
-golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e h1:f5mksnk+hgXHnImpZoWj64ja99j9zV7YUgrVG95uFE4=
+golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/mkerrors.sh b/src/cmd/vendor/golang.org/x/sys/unix/mkerrors.sh
index c0f9f2d523..ca98cb485f 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/mkerrors.sh
+++ b/src/cmd/vendor/golang.org/x/sys/unix/mkerrors.sh
@@ -65,6 +65,7 @@ includes_Darwin='
 #include <sys/ptrace.h>
 #include <sys/select.h>
 #include <sys/socket.h>
+#include <sys/un.h>
 #include <sys/sockio.h>
 #include <sys/sys_domain.h>
 #include <sys/sysctl.h>
@@ -204,6 +205,7 @@ struct ltchars {
 #include <linux/devlink.h>
 #include <linux/dm-ioctl.h>
 #include <linux/errqueue.h>
+#include <linux/ethtool_netlink.h>
 #include <linux/falloc.h>
 #include <linux/fanotify.h>
 #include <linux/filter.h>
@@ -479,7 +481,7 @@ ccflags="$@"
 		$2 ~ /^LOCK_(SH|EX|NB|UN)$/ ||
 		$2 ~ /^LO_(KEY|NAME)_SIZE$/ ||
 		$2 ~ /^LOOP_(CLR|CTL|GET|SET)_/ ||
-		$2 ~ /^(AF|SOCK|SO|SOL|IPPROTO|IP|IPV6|ICMP6|TCP|MCAST|EVFILT|NOTE|EV|SHUT|PROT|MAP|MFD|T?PACKET|MSG|SCM|MCL|DT|MADV|PR)_/ ||
+		$2 ~ /^(AF|SOCK|SO|SOL|IPPROTO|IP|IPV6|ICMP6|TCP|MCAST|EVFILT|NOTE|EV|SHUT|PROT|MAP|MFD|T?PACKET|MSG|SCM|MCL|DT|MADV|PR|LOCAL)_/ ||
 		$2 ~ /^TP_STATUS_/ ||
 		$2 ~ /^FALLOC_/ ||
 		$2 == "ICMPV6_FILTER" ||
@@ -561,7 +563,9 @@ ccflags="$@"
 		$2 ~ /^(HDIO|WIN|SMART)_/ ||
 		$2 ~ /^CRYPTO_/ ||
 		$2 ~ /^TIPC_/ ||
+		$2 !~  "DEVLINK_RELOAD_LIMITS_VALID_MASK" &&
 		$2 ~ /^DEVLINK_/ ||
+		$2 ~ /^ETHTOOL_/ ||
 		$2 ~ /^LWTUNNEL_IP/ ||
 		$2 !~ "WMESGLEN" &&
 		$2 ~ /^W[A-Z0-9]+$/ ||
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ptrace_darwin.go b/src/cmd/vendor/golang.org/x/sys/unix/ptrace_darwin.go
new file mode 100644
index 0000000000..fc568b5403
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ptrace_darwin.go
@@ -0,0 +1,11 @@
+// Copyright 2020 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.
+
+// +build darwin,!ios
+
+package unix
+
+func ptrace(request int, pid int, addr uintptr, data uintptr) error {
+	return ptrace1(request, pid, addr, data)
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ptrace_ios.go b/src/cmd/vendor/golang.org/x/sys/unix/ptrace_ios.go
new file mode 100644
index 0000000000..183441c9a5
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ptrace_ios.go
@@ -0,0 +1,11 @@
+// Copyright 2020 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.
+
+// +build ios
+
+package unix
+
+func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
+	return ENOTSUP
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix.go
index 4408153822..423dcced7e 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix.go
@@ -419,8 +419,8 @@ func (w WaitStatus) TrapCause() int { return -1 }
 //sys	Mknod(path string, mode uint32, dev int) (err error)
 //sys	Mknodat(dirfd int, path string, mode uint32, dev int) (err error)
 //sys	Nanosleep(time *Timespec, leftover *Timespec) (err error)
-//sys   Open(path string, mode int, perm uint32) (fd int, err error) = open64
-//sys   Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error)
+//sys	Open(path string, mode int, perm uint32) (fd int, err error) = open64
+//sys	Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error)
 //sys	read(fd int, p []byte) (n int, err error)
 //sys	Readlink(path string, buf []byte) (n int, err error)
 //sys	Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error)
@@ -439,8 +439,8 @@ func (w WaitStatus) TrapCause() int { return -1 }
 //sysnb	Times(tms *Tms) (ticks uintptr, err error)
 //sysnb	Umask(mask int) (oldmask int)
 //sysnb	Uname(buf *Utsname) (err error)
-//sys   Unlink(path string) (err error)
-//sys   Unlinkat(dirfd int, path string, flags int) (err error)
+//sys	Unlink(path string) (err error)
+//sys	Unlinkat(dirfd int, path string, flags int) (err error)
 //sys	Ustat(dev int, ubuf *Ustat_t) (err error)
 //sys	write(fd int, p []byte) (n int, err error)
 //sys	readlen(fd int, p *byte, np int) (n int, err error) = read
@@ -514,7 +514,7 @@ func Munmap(b []byte) (err error) {
 //sys	Munlock(b []byte) (err error)
 //sys	Munlockall() (err error)
 
-//sysnb pipe(p *[2]_C_int) (err error)
+//sysnb	pipe(p *[2]_C_int) (err error)
 
 func Pipe(p []int) (err error) {
 	if len(p) != 2 {
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_bsd.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_bsd.go
index bc634a280a..678fb27777 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_bsd.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_bsd.go
@@ -318,7 +318,7 @@ func Getsockname(fd int) (sa Sockaddr, err error) {
 	return anyToSockaddr(fd, &rsa)
 }
 
-//sysnb socketpair(domain int, typ int, proto int, fd *[2]int32) (err error)
+//sysnb	socketpair(domain int, typ int, proto int, fd *[2]int32) (err error)
 
 // GetsockoptString returns the string value of the socket option opt for the
 // socket associated with fd at the given socket level.
@@ -332,8 +332,8 @@ func GetsockoptString(fd, level, opt int) (string, error) {
 	return string(buf[:vallen-1]), nil
 }
 
-//sys   recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error)
-//sys   sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error)
+//sys	recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error)
+//sys	sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error)
 //sys	recvmsg(s int, msg *Msghdr, flags int) (n int, err error)
 
 func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) {
@@ -626,7 +626,7 @@ func Futimes(fd int, tv []Timeval) error {
 	return futimes(fd, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
 }
 
-//sys   poll(fds *PollFd, nfds int, timeout int) (n int, err error)
+//sys	poll(fds *PollFd, nfds int, timeout int) (n int, err error)
 
 func Poll(fds []PollFd, timeout int) (n int, err error) {
 	if len(fds) == 0 {
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.go
index b625738900..e771a3c5ef 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.go
@@ -119,13 +119,16 @@ type attrList struct {
 	Forkattr    uint32
 }
 
-//sysnb pipe() (r int, w int, err error)
+//sysnb	pipe(p *[2]int32) (err error)
 
 func Pipe(p []int) (err error) {
 	if len(p) != 2 {
 		return EINVAL
 	}
-	p[0], p[1], err = pipe()
+	var x [2]int32
+	err = pipe(&x)
+	p[0] = int(x[0])
+	p[1] = int(x[1])
 	return
 }
 
@@ -269,7 +272,7 @@ func setattrlistTimes(path string, times []Timespec, flags int) error {
 		options)
 }
 
-//sys setattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error)
+//sys	setattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error)
 
 func utimensat(dirfd int, path string, times *[2]Timespec, flags int) error {
 	// Darwin doesn't support SYS_UTIMENSAT
@@ -317,7 +320,7 @@ func IoctlSetIfreqMTU(fd int, ifreq *IfreqMTU) error {
 	return err
 }
 
-//sys   sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS_SYSCTL
+//sys	sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS_SYSCTL
 
 func Uname(uname *Utsname) error {
 	mib := []_C_int{CTL_KERN, KERN_OSTYPE}
@@ -375,6 +378,15 @@ func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err e
 	return
 }
 
+// GetsockoptXucred is a getsockopt wrapper that returns an Xucred struct.
+// The usual level and opt are SOL_LOCAL and LOCAL_PEERCRED, respectively.
+func GetsockoptXucred(fd, level, opt int) (*Xucred, error) {
+	x := new(Xucred)
+	vallen := _Socklen(unsafe.Sizeof(Xucred{}))
+	err := getsockopt(fd, level, opt, unsafe.Pointer(x), &vallen)
+	return x, err
+}
+
 //sys	sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error)
 
 /*
@@ -469,8 +481,8 @@ func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err e
 //sys	Unlinkat(dirfd int, path string, flags int) (err error)
 //sys	Unmount(path string, flags int) (err error)
 //sys	write(fd int, p []byte) (n int, err error)
-//sys   mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)
-//sys   munmap(addr uintptr, length uintptr) (err error)
+//sys	mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)
+//sys	munmap(addr uintptr, length uintptr) (err error)
 //sys	readlen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_READ
 //sys	writelen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_WRITE
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_386.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_386.go
index 6c1f4ab95b..ee065fcf2d 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_386.go
@@ -45,6 +45,6 @@ func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr,
 //sys	Fstatfs(fd int, stat *Statfs_t) (err error) = SYS_FSTATFS64
 //sys	getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) = SYS_GETFSSTAT64
 //sys	Lstat(path string, stat *Stat_t) (err error) = SYS_LSTAT64
-//sys	ptrace(request int, pid int, addr uintptr, data uintptr) (err error)
+//sys	ptrace1(request int, pid int, addr uintptr, data uintptr) (err error) = SYS_ptrace
 //sys	Stat(path string, stat *Stat_t) (err error) = SYS_STAT64
 //sys	Statfs(path string, stat *Statfs_t) (err error) = SYS_STATFS64
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_amd64.go
index 0582ae256e..7a1f64a7b6 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_amd64.go
@@ -45,6 +45,6 @@ func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr,
 //sys	Fstatfs(fd int, stat *Statfs_t) (err error) = SYS_FSTATFS64
 //sys	getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) = SYS_GETFSSTAT64
 //sys	Lstat(path string, stat *Stat_t) (err error) = SYS_LSTAT64
-//sys	ptrace(request int, pid int, addr uintptr, data uintptr) (err error)
+//sys	ptrace1(request int, pid int, addr uintptr, data uintptr) (err error) = SYS_ptrace
 //sys	Stat(path string, stat *Stat_t) (err error) = SYS_STAT64
 //sys	Statfs(path string, stat *Statfs_t) (err error) = SYS_STATFS64
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_arm.go
index c6a9733b4c..d30735c5d6 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_arm.go
@@ -6,7 +6,7 @@ package unix
 
 import "syscall"
 
-func ptrace(request int, pid int, addr uintptr, data uintptr) error {
+func ptrace1(request int, pid int, addr uintptr, data uintptr) error {
 	return ENOTSUP
 }
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_arm64.go
index 253afa4de5..9f85fd4046 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_arm64.go
@@ -45,6 +45,6 @@ func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr,
 //sys	Fstatfs(fd int, stat *Statfs_t) (err error)
 //sys	getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) = SYS_GETFSSTAT
 //sys	Lstat(path string, stat *Stat_t) (err error)
-//sys	ptrace(request int, pid int, addr uintptr, data uintptr) (err error)
+//sys	ptrace1(request int, pid int, addr uintptr, data uintptr) (err error) = SYS_ptrace
 //sys	Stat(path string, stat *Stat_t) (err error)
 //sys	Statfs(path string, stat *Statfs_t) (err error)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_dragonfly.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_dragonfly.go
index a4f2944a24..474141b625 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_dragonfly.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_dragonfly.go
@@ -95,7 +95,7 @@ func direntNamlen(buf []byte) (uint64, bool) {
 	return readInt(buf, unsafe.Offsetof(Dirent{}.Namlen), unsafe.Sizeof(Dirent{}.Namlen))
 }
 
-//sysnb pipe() (r int, w int, err error)
+//sysnb	pipe() (r int, w int, err error)
 
 func Pipe(p []int) (err error) {
 	if len(p) != 2 {
@@ -105,16 +105,13 @@ func Pipe(p []int) (err error) {
 	return
 }
 
-//sysnb	pipe2(p *[2]_C_int, flags int) (err error)
+//sysnb	pipe2(flags int) (r int, w int, err error)
 
-func Pipe2(p []int, flags int) error {
+func Pipe2(p []int, flags int) (err error) {
 	if len(p) != 2 {
 		return EINVAL
 	}
-	var pp [2]_C_int
-	err := pipe2(&pp, flags)
-	p[0] = int(pp[0])
-	p[1] = int(pp[1])
+	p[0], p[1], err = pipe2(flags)
 	return err
 }
 
@@ -170,7 +167,7 @@ func setattrlistTimes(path string, times []Timespec, flags int) error {
 
 //sys	ioctl(fd int, req uint, arg uintptr) (err error)
 
-//sys   sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL
+//sys	sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL
 
 func sysctlUname(mib []_C_int, old *byte, oldlen *uintptr) error {
 	err := sysctl(mib, old, oldlen, nil, 0)
@@ -337,8 +334,8 @@ func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err e
 //sys	Unlinkat(dirfd int, path string, flags int) (err error)
 //sys	Unmount(path string, flags int) (err error)
 //sys	write(fd int, p []byte) (n int, err error)
-//sys   mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)
-//sys   munmap(addr uintptr, length uintptr) (err error)
+//sys	mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)
+//sys	munmap(addr uintptr, length uintptr) (err error)
 //sys	readlen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_READ
 //sys	writelen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_WRITE
 //sys	accept4(fd int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (nfd int, err error)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd.go
index acc00c2e6a..15af63dd55 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd.go
@@ -188,9 +188,9 @@ func setattrlistTimes(path string, times []Timespec, flags int) error {
 	return ENOSYS
 }
 
-//sys   ioctl(fd int, req uint, arg uintptr) (err error)
+//sys	ioctl(fd int, req uint, arg uintptr) (err error)
 
-//sys   sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL
+//sys	sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL
 
 func Uname(uname *Utsname) error {
 	mib := []_C_int{CTL_KERN, KERN_OSTYPE}
@@ -665,8 +665,8 @@ func PtraceSingleStep(pid int) (err error) {
 //sys	Unlinkat(dirfd int, path string, flags int) (err error)
 //sys	Unmount(path string, flags int) (err error)
 //sys	write(fd int, p []byte) (n int, err error)
-//sys   mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)
-//sys   munmap(addr uintptr, length uintptr) (err error)
+//sys	mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)
+//sys	munmap(addr uintptr, length uintptr) (err error)
 //sys	readlen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_READ
 //sys	writelen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_WRITE
 //sys	accept4(fd int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (nfd int, err error)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_illumos.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_illumos.go
index bbc4f3ea54..7a2d4120fc 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_illumos.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_illumos.go
@@ -75,16 +75,3 @@ func Accept4(fd int, flags int) (nfd int, sa Sockaddr, err error) {
 	}
 	return
 }
-
-//sysnb	pipe2(p *[2]_C_int, flags int) (err error)
-
-func Pipe2(p []int, flags int) error {
-	if len(p) != 2 {
-		return EINVAL
-	}
-	var pp [2]_C_int
-	err := pipe2(&pp, flags)
-	p[0] = int(pp[0])
-	p[1] = int(pp[1])
-	return err
-}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go
index 28be1306ec..1b21035700 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go
@@ -1482,8 +1482,8 @@ func KeyctlRestrictKeyring(ringid int, keyType string, restriction string) error
 	return keyctlRestrictKeyringByType(KEYCTL_RESTRICT_KEYRING, ringid, keyType, restriction)
 }
 
-//sys keyctlRestrictKeyringByType(cmd int, arg2 int, keyType string, restriction string) (err error) = SYS_KEYCTL
-//sys keyctlRestrictKeyring(cmd int, arg2 int) (err error) = SYS_KEYCTL
+//sys	keyctlRestrictKeyringByType(cmd int, arg2 int, keyType string, restriction string) (err error) = SYS_KEYCTL
+//sys	keyctlRestrictKeyring(cmd int, arg2 int) (err error) = SYS_KEYCTL
 
 func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) {
 	var msg Msghdr
@@ -1860,8 +1860,8 @@ func Getpgrp() (pid int) {
 //sys	Nanosleep(time *Timespec, leftover *Timespec) (err error)
 //sys	PerfEventOpen(attr *PerfEventAttr, pid int, cpu int, groupFd int, flags int) (fd int, err error)
 //sys	PivotRoot(newroot string, putold string) (err error) = SYS_PIVOT_ROOT
-//sysnb prlimit(pid int, resource int, newlimit *Rlimit, old *Rlimit) (err error) = SYS_PRLIMIT64
-//sys   Prctl(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error)
+//sysnb	prlimit(pid int, resource int, newlimit *Rlimit, old *Rlimit) (err error) = SYS_PRLIMIT64
+//sys	Prctl(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error)
 //sys	Pselect(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timespec, sigmask *Sigset_t) (n int, err error) = SYS_PSELECT6
 //sys	read(fd int, p []byte) (n int, err error)
 //sys	Removexattr(path string, attr string) (err error)
@@ -1934,9 +1934,9 @@ func Signalfd(fd int, sigmask *Sigset_t, flags int) (newfd int, err error) {
 //sys	Syncfs(fd int) (err error)
 //sysnb	Sysinfo(info *Sysinfo_t) (err error)
 //sys	Tee(rfd int, wfd int, len int, flags int) (n int64, err error)
-//sysnb TimerfdCreate(clockid int, flags int) (fd int, err error)
-//sysnb TimerfdGettime(fd int, currValue *ItimerSpec) (err error)
-//sysnb TimerfdSettime(fd int, flags int, newValue *ItimerSpec, oldValue *ItimerSpec) (err error)
+//sysnb	TimerfdCreate(clockid int, flags int) (fd int, err error)
+//sysnb	TimerfdGettime(fd int, currValue *ItimerSpec) (err error)
+//sysnb	TimerfdSettime(fd int, flags int, newValue *ItimerSpec, oldValue *ItimerSpec) (err error)
 //sysnb	Tgkill(tgid int, tid int, sig syscall.Signal) (err error)
 //sysnb	Times(tms *Tms) (ticks uintptr, err error)
 //sysnb	Umask(mask int) (oldmask int)
@@ -2196,8 +2196,8 @@ func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
 	return EACCES
 }
 
-//sys nameToHandleAt(dirFD int, pathname string, fh *fileHandle, mountID *_C_int, flags int) (err error) = SYS_NAME_TO_HANDLE_AT
-//sys openByHandleAt(mountFD int, fh *fileHandle, flags int) (fd int, err error) = SYS_OPEN_BY_HANDLE_AT
+//sys	nameToHandleAt(dirFD int, pathname string, fh *fileHandle, mountID *_C_int, flags int) (err error) = SYS_NAME_TO_HANDLE_AT
+//sys	openByHandleAt(mountFD int, fh *fileHandle, flags int) (fd int, err error) = SYS_OPEN_BY_HANDLE_AT
 
 // fileHandle is the argument to nameToHandleAt and openByHandleAt. We
 // originally tried to generate it via unix/linux/types.go with "type
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_386.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_386.go
index c97c2ee53e..70e61bd5db 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_386.go
@@ -31,7 +31,7 @@ func Pipe(p []int) (err error) {
 	return
 }
 
-//sysnb pipe2(p *[2]_C_int, flags int) (err error)
+//sysnb	pipe2(p *[2]_C_int, flags int) (err error)
 
 func Pipe2(p []int, flags int) (err error) {
 	if len(p) != 2 {
@@ -98,7 +98,7 @@ type rlimit32 struct {
 	Max uint32
 }
 
-//sysnb getrlimit(resource int, rlim *rlimit32) (err error) = SYS_GETRLIMIT
+//sysnb	getrlimit(resource int, rlim *rlimit32) (err error) = SYS_GETRLIMIT
 
 const rlimInf32 = ^uint32(0)
 const rlimInf64 = ^uint64(0)
@@ -129,7 +129,7 @@ func Getrlimit(resource int, rlim *Rlimit) (err error) {
 	return
 }
 
-//sysnb setrlimit(resource int, rlim *rlimit32) (err error) = SYS_SETRLIMIT
+//sysnb	setrlimit(resource int, rlim *rlimit32) (err error) = SYS_SETRLIMIT
 
 func Setrlimit(resource int, rlim *Rlimit) (err error) {
 	err = prlimit(0, resource, rlim, nil)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_amd64.go
index 72efe86ed4..4be2acd32b 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_amd64.go
@@ -138,7 +138,7 @@ func Pipe(p []int) (err error) {
 	return
 }
 
-//sysnb pipe2(p *[2]_C_int, flags int) (err error)
+//sysnb	pipe2(p *[2]_C_int, flags int) (err error)
 
 func Pipe2(p []int, flags int) (err error) {
 	if len(p) != 2 {
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_arm.go
index 496837b1e3..322b8e0fb9 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_arm.go
@@ -35,7 +35,7 @@ func Pipe(p []int) (err error) {
 	return
 }
 
-//sysnb pipe2(p *[2]_C_int, flags int) (err error)
+//sysnb	pipe2(p *[2]_C_int, flags int) (err error)
 
 func Pipe2(p []int, flags int) (err error) {
 	if len(p) != 2 {
@@ -129,8 +129,8 @@ func Utime(path string, buf *Utimbuf) error {
 
 //sys	utimes(path string, times *[2]Timeval) (err error)
 
-//sys   Pread(fd int, p []byte, offset int64) (n int, err error) = SYS_PREAD64
-//sys   Pwrite(fd int, p []byte, offset int64) (n int, err error) = SYS_PWRITE64
+//sys	Pread(fd int, p []byte, offset int64) (n int, err error) = SYS_PREAD64
+//sys	Pwrite(fd int, p []byte, offset int64) (n int, err error) = SYS_PWRITE64
 //sys	Truncate(path string, length int64) (err error) = SYS_TRUNCATE64
 //sys	Ftruncate(fd int, length int64) (err error) = SYS_FTRUNCATE64
 
@@ -177,7 +177,7 @@ type rlimit32 struct {
 	Max uint32
 }
 
-//sysnb getrlimit(resource int, rlim *rlimit32) (err error) = SYS_UGETRLIMIT
+//sysnb	getrlimit(resource int, rlim *rlimit32) (err error) = SYS_UGETRLIMIT
 
 const rlimInf32 = ^uint32(0)
 const rlimInf64 = ^uint64(0)
@@ -208,7 +208,7 @@ func Getrlimit(resource int, rlim *Rlimit) (err error) {
 	return
 }
 
-//sysnb setrlimit(resource int, rlim *rlimit32) (err error) = SYS_SETRLIMIT
+//sysnb	setrlimit(resource int, rlim *rlimit32) (err error) = SYS_SETRLIMIT
 
 func Setrlimit(resource int, rlim *Rlimit) (err error) {
 	err = prlimit(0, resource, rlim, nil)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go
index c6de6b9134..9315cf415b 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go
@@ -155,7 +155,7 @@ func Pipe(p []int) (err error) {
 	return
 }
 
-//sysnb pipe2(p *[2]_C_int, flags int) (err error)
+//sysnb	pipe2(p *[2]_C_int, flags int) (err error)
 
 func Pipe2(p []int, flags int) (err error) {
 	if len(p) != 2 {
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_mips64x.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_mips64x.go
index f0287476cd..5fc8a47f41 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_mips64x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_mips64x.go
@@ -104,7 +104,7 @@ func Pipe(p []int) (err error) {
 	return
 }
 
-//sysnb pipe2(p *[2]_C_int, flags int) (err error)
+//sysnb	pipe2(p *[2]_C_int, flags int) (err error)
 
 func Pipe2(p []int, flags int) (err error) {
 	if len(p) != 2 {
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_mipsx.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_mipsx.go
index c11328111d..20b9825f87 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_mipsx.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_mipsx.go
@@ -112,7 +112,7 @@ func setTimeval(sec, usec int64) Timeval {
 	return Timeval{Sec: int32(sec), Usec: int32(usec)}
 }
 
-//sysnb pipe2(p *[2]_C_int, flags int) (err error)
+//sysnb	pipe2(p *[2]_C_int, flags int) (err error)
 
 func Pipe2(p []int, flags int) (err error) {
 	if len(p) != 2 {
@@ -125,7 +125,7 @@ func Pipe2(p []int, flags int) (err error) {
 	return
 }
 
-//sysnb pipe() (p1 int, p2 int, err error)
+//sysnb	pipe() (p1 int, p2 int, err error)
 
 func Pipe(p []int) (err error) {
 	if len(p) != 2 {
@@ -153,7 +153,7 @@ type rlimit32 struct {
 	Max uint32
 }
 
-//sysnb getrlimit(resource int, rlim *rlimit32) (err error) = SYS_GETRLIMIT
+//sysnb	getrlimit(resource int, rlim *rlimit32) (err error) = SYS_GETRLIMIT
 
 func Getrlimit(resource int, rlim *Rlimit) (err error) {
 	err = prlimit(0, resource, nil, rlim)
@@ -181,7 +181,7 @@ func Getrlimit(resource int, rlim *Rlimit) (err error) {
 	return
 }
 
-//sysnb setrlimit(resource int, rlim *rlimit32) (err error) = SYS_SETRLIMIT
+//sysnb	setrlimit(resource int, rlim *rlimit32) (err error) = SYS_SETRLIMIT
 
 func Setrlimit(resource int, rlim *Rlimit) (err error) {
 	err = prlimit(0, resource, rlim, nil)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_ppc64x.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_ppc64x.go
index 349374409b..5162c39b0e 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_ppc64x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_ppc64x.go
@@ -99,7 +99,7 @@ func (cmsg *Cmsghdr) SetLen(length int) {
 	cmsg.Len = uint64(length)
 }
 
-//sysnb pipe(p *[2]_C_int) (err error)
+//sysnb	pipe(p *[2]_C_int) (err error)
 
 func Pipe(p []int) (err error) {
 	if len(p) != 2 {
@@ -112,7 +112,7 @@ func Pipe(p []int) (err error) {
 	return
 }
 
-//sysnb pipe2(p *[2]_C_int, flags int) (err error)
+//sysnb	pipe2(p *[2]_C_int, flags int) (err error)
 
 func Pipe2(p []int, flags int) (err error) {
 	if len(p) != 2 {
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go
index b0b1505565..a6a66ece09 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go
@@ -154,7 +154,7 @@ func Pipe(p []int) (err error) {
 	return
 }
 
-//sysnb pipe2(p *[2]_C_int, flags int) (err error)
+//sysnb	pipe2(p *[2]_C_int, flags int) (err error)
 
 func Pipe2(p []int, flags int) (err error) {
 	if len(p) != 2 {
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_s390x.go
index 2363f74991..fcef0d1daf 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_s390x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_s390x.go
@@ -76,7 +76,7 @@ func setTimeval(sec, usec int64) Timeval {
 	return Timeval{Sec: sec, Usec: usec}
 }
 
-//sysnb pipe2(p *[2]_C_int, flags int) (err error)
+//sysnb	pipe2(p *[2]_C_int, flags int) (err error)
 
 func Pipe(p []int) (err error) {
 	if len(p) != 2 {
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go
index d389f1518f..3b88044830 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go
@@ -115,7 +115,7 @@ func (cmsg *Cmsghdr) SetLen(length int) {
 	cmsg.Len = uint64(length)
 }
 
-//sysnb pipe(p *[2]_C_int) (err error)
+//sysnb	pipe(p *[2]_C_int) (err error)
 
 func Pipe(p []int) (err error) {
 	if len(p) != 2 {
@@ -128,7 +128,7 @@ func Pipe(p []int) (err error) {
 	return
 }
 
-//sysnb pipe2(p *[2]_C_int, flags int) (err error)
+//sysnb	pipe2(p *[2]_C_int, flags int) (err error)
 
 func Pipe2(p []int, flags int) (err error) {
 	if len(p) != 2 {
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_netbsd.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_netbsd.go
index 1e6843b4c3..853d5f0f43 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_netbsd.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_netbsd.go
@@ -110,7 +110,8 @@ func direntNamlen(buf []byte) (uint64, bool) {
 	return readInt(buf, unsafe.Offsetof(Dirent{}.Namlen), unsafe.Sizeof(Dirent{}.Namlen))
 }
 
-//sysnb pipe() (fd1 int, fd2 int, err error)
+//sysnb	pipe() (fd1 int, fd2 int, err error)
+
 func Pipe(p []int) (err error) {
 	if len(p) != 2 {
 		return EINVAL
@@ -119,7 +120,21 @@ func Pipe(p []int) (err error) {
 	return
 }
 
-//sys Getdents(fd int, buf []byte) (n int, err error)
+//sysnb	pipe2(p *[2]_C_int, flags int) (err error)
+
+func Pipe2(p []int, flags int) error {
+	if len(p) != 2 {
+		return EINVAL
+	}
+	var pp [2]_C_int
+	err := pipe2(&pp, flags)
+	p[0] = int(pp[0])
+	p[1] = int(pp[1])
+	return err
+}
+
+//sys	Getdents(fd int, buf []byte) (n int, err error)
+
 func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) {
 	n, err = Getdents(fd, buf)
 	if err != nil || basep == nil {
@@ -159,7 +174,7 @@ func setattrlistTimes(path string, times []Timespec, flags int) error {
 
 //sys	ioctl(fd int, req uint, arg uintptr) (err error)
 
-//sys   sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL
+//sys	sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL
 
 func IoctlGetPtmget(fd int, req uint) (*Ptmget, error) {
 	var value Ptmget
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd.go
index 6a50b50bd6..22b5503850 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd.go
@@ -92,7 +92,7 @@ func Pipe2(p []int, flags int) error {
 	return err
 }
 
-//sys Getdents(fd int, buf []byte) (n int, err error)
+//sys	Getdents(fd int, buf []byte) (n int, err error)
 func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) {
 	n, err = Getdents(fd, buf)
 	if err != nil || basep == nil {
@@ -154,7 +154,7 @@ func setattrlistTimes(path string, times []Timespec, flags int) error {
 
 //sys	ioctl(fd int, req uint, arg uintptr) (err error)
 
-//sys   sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL
+//sys	sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL
 
 //sys	ppoll(fds *PollFd, nfds int, timeout *Timespec, sigmask *Sigset_t) (n int, err error)
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_solaris.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_solaris.go
index fee6e99528..169497f062 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_solaris.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_solaris.go
@@ -68,6 +68,19 @@ func Pipe(p []int) (err error) {
 	return nil
 }
 
+//sysnb	pipe2(p *[2]_C_int, flags int) (err error)
+
+func Pipe2(p []int, flags int) error {
+	if len(p) != 2 {
+		return EINVAL
+	}
+	var pp [2]_C_int
+	err := pipe2(&pp, flags)
+	p[0] = int(pp[0])
+	p[1] = int(pp[1])
+	return err
+}
+
 func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) {
 	if sa.Port < 0 || sa.Port > 0xFFFF {
 		return nil, 0, EINVAL
@@ -566,7 +579,7 @@ func IoctlGetTermio(fd int, req uint) (*Termio, error) {
 	return &value, err
 }
 
-//sys   poll(fds *PollFd, nfds int, timeout int) (n int, err error)
+//sys	poll(fds *PollFd, nfds int, timeout int) (n int, err error)
 
 func Poll(fds []PollFd, timeout int) (n int, err error) {
 	if len(fds) == 0 {
@@ -669,6 +682,7 @@ func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err e
 //sys	Statvfs(path string, vfsstat *Statvfs_t) (err error)
 //sys	Symlink(path string, link string) (err error)
 //sys	Sync() (err error)
+//sys	Sysconf(which int) (n int64, err error)
 //sysnb	Times(tms *Tms) (ticks uintptr, err error)
 //sys	Truncate(path string, length int64) (err error)
 //sys	Fsync(fd int) (err error)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/timestruct.go b/src/cmd/vendor/golang.org/x/sys/unix/timestruct.go
index 4a672f5694..103604299e 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/timestruct.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/timestruct.go
@@ -8,12 +8,10 @@ package unix
 
 import "time"
 
-// TimespecToNsec converts a Timespec value into a number of
-// nanoseconds since the Unix epoch.
-func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
+// TimespecToNSec returns the time stored in ts as nanoseconds.
+func TimespecToNsec(ts Timespec) int64 { return ts.Nano() }
 
-// NsecToTimespec takes a number of nanoseconds since the Unix epoch
-// and returns the corresponding Timespec value.
+// NsecToTimespec converts a number of nanoseconds into a Timespec.
 func NsecToTimespec(nsec int64) Timespec {
 	sec := nsec / 1e9
 	nsec = nsec % 1e9
@@ -42,12 +40,10 @@ func TimeToTimespec(t time.Time) (Timespec, error) {
 	return ts, nil
 }
 
-// TimevalToNsec converts a Timeval value into a number of nanoseconds
-// since the Unix epoch.
-func TimevalToNsec(tv Timeval) int64 { return int64(tv.Sec)*1e9 + int64(tv.Usec)*1e3 }
+// TimevalToNsec returns the time stored in tv as nanoseconds.
+func TimevalToNsec(tv Timeval) int64 { return tv.Nano() }
 
-// NsecToTimeval takes a number of nanoseconds since the Unix epoch
-// and returns the corresponding Timeval value.
+// NsecToTimeval converts a number of nanoseconds into a Timeval.
 func NsecToTimeval(nsec int64) Timeval {
 	nsec += 999 // round up to microsecond
 	usec := nsec % 1e9 / 1e3
@@ -59,24 +55,22 @@ func NsecToTimeval(nsec int64) Timeval {
 	return setTimeval(sec, usec)
 }
 
-// Unix returns ts as the number of seconds and nanoseconds elapsed since the
-// Unix epoch.
+// Unix returns the time stored in ts as seconds plus nanoseconds.
 func (ts *Timespec) Unix() (sec int64, nsec int64) {
 	return int64(ts.Sec), int64(ts.Nsec)
 }
 
-// Unix returns tv as the number of seconds and nanoseconds elapsed since the
-// Unix epoch.
+// Unix returns the time stored in tv as seconds plus nanoseconds.
 func (tv *Timeval) Unix() (sec int64, nsec int64) {
 	return int64(tv.Sec), int64(tv.Usec) * 1000
 }
 
-// Nano returns ts as the number of nanoseconds elapsed since the Unix epoch.
+// Nano returns the time stored in ts as nanoseconds.
 func (ts *Timespec) Nano() int64 {
 	return int64(ts.Sec)*1e9 + int64(ts.Nsec)
 }
 
-// Nano returns tv as the number of nanoseconds elapsed since the Unix epoch.
+// Nano returns the time stored in tv as nanoseconds.
 func (tv *Timeval) Nano() int64 {
 	return int64(tv.Sec)*1e9 + int64(tv.Usec)*1000
 }
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
index fea5dfaadb..dcb96c26c0 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
@@ -32,7 +32,7 @@ const (
 	AF_LAT                            = 0xe
 	AF_LINK                           = 0x12
 	AF_LOCAL                          = 0x1
-	AF_MAX                            = 0x28
+	AF_MAX                            = 0x29
 	AF_NATM                           = 0x1f
 	AF_NDRV                           = 0x1b
 	AF_NETBIOS                        = 0x21
@@ -49,6 +49,7 @@ const (
 	AF_UNIX                           = 0x1
 	AF_UNSPEC                         = 0x0
 	AF_UTUN                           = 0x26
+	AF_VSOCK                          = 0x28
 	ALTWERASE                         = 0x200
 	ATTR_BIT_MAP_COUNT                = 0x5
 	ATTR_CMN_ACCESSMASK               = 0x20000
@@ -83,7 +84,7 @@ const (
 	ATTR_CMN_PAROBJID                 = 0x80
 	ATTR_CMN_RETURNED_ATTRS           = 0x80000000
 	ATTR_CMN_SCRIPT                   = 0x100
-	ATTR_CMN_SETMASK                  = 0x41c7ff00
+	ATTR_CMN_SETMASK                  = 0x51c7ff00
 	ATTR_CMN_USERACCESS               = 0x200000
 	ATTR_CMN_UUID                     = 0x800000
 	ATTR_CMN_VALIDMASK                = 0xffffffff
@@ -357,7 +358,7 @@ const (
 	DLT_LINUX_SLL                     = 0x71
 	DLT_LOOP                          = 0x6c
 	DLT_LTALK                         = 0x72
-	DLT_MATCHING_MAX                  = 0xf5
+	DLT_MATCHING_MAX                  = 0x10a
 	DLT_MATCHING_MIN                  = 0x68
 	DLT_MFR                           = 0xb6
 	DLT_MOST                          = 0xd3
@@ -398,6 +399,7 @@ const (
 	DLT_SYMANTEC_FIREWALL             = 0x63
 	DLT_TZSP                          = 0x80
 	DLT_USB                           = 0xba
+	DLT_USB_DARWIN                    = 0x10a
 	DLT_USB_LINUX                     = 0xbd
 	DLT_USB_LINUX_MMAPPED             = 0xdc
 	DLT_USER0                         = 0x93
@@ -442,8 +444,8 @@ const (
 	EVFILT_PROC                       = -0x5
 	EVFILT_READ                       = -0x1
 	EVFILT_SIGNAL                     = -0x6
-	EVFILT_SYSCOUNT                   = 0xf
-	EVFILT_THREADMARKER               = 0xf
+	EVFILT_SYSCOUNT                   = 0x11
+	EVFILT_THREADMARKER               = 0x11
 	EVFILT_TIMER                      = -0x7
 	EVFILT_USER                       = -0xa
 	EVFILT_VM                         = -0xc
@@ -481,9 +483,12 @@ const (
 	FSOPT_NOINMEMUPDATE               = 0x2
 	FSOPT_PACK_INVAL_ATTRS            = 0x8
 	FSOPT_REPORT_FULLSIZE             = 0x4
+	FSOPT_RETURN_REALDEV              = 0x200
 	F_ADDFILESIGS                     = 0x3d
 	F_ADDFILESIGS_FOR_DYLD_SIM        = 0x53
+	F_ADDFILESIGS_INFO                = 0x67
 	F_ADDFILESIGS_RETURN              = 0x61
+	F_ADDFILESUPPL                    = 0x68
 	F_ADDSIGS                         = 0x3b
 	F_ALLOCATEALL                     = 0x4
 	F_ALLOCATECONTIG                  = 0x2
@@ -505,8 +510,10 @@ const (
 	F_GETOWN                          = 0x5
 	F_GETPATH                         = 0x32
 	F_GETPATH_MTMINFO                 = 0x47
+	F_GETPATH_NOFIRMLINK              = 0x66
 	F_GETPROTECTIONCLASS              = 0x3f
 	F_GETPROTECTIONLEVEL              = 0x4d
+	F_GETSIGSINFO                     = 0x69
 	F_GLOBAL_NOCACHE                  = 0x37
 	F_LOG2PHYS                        = 0x31
 	F_LOG2PHYS_EXT                    = 0x41
@@ -531,6 +538,7 @@ const (
 	F_SETPROTECTIONCLASS              = 0x40
 	F_SETSIZE                         = 0x2b
 	F_SINGLE_WRITER                   = 0x4c
+	F_SPECULATIVE_READ                = 0x65
 	F_THAW_FS                         = 0x36
 	F_TRANSCODEKEY                    = 0x4b
 	F_TRIM_ACTIVE_FILE                = 0x64
@@ -562,6 +570,7 @@ const (
 	IFF_UP                            = 0x1
 	IFNAMSIZ                          = 0x10
 	IFT_1822                          = 0x2
+	IFT_6LOWPAN                       = 0x40
 	IFT_AAL5                          = 0x31
 	IFT_ARCNET                        = 0x23
 	IFT_ARCNETPLUS                    = 0x24
@@ -766,6 +775,9 @@ const (
 	IPV6_2292PKTINFO                  = 0x13
 	IPV6_2292PKTOPTIONS               = 0x19
 	IPV6_2292RTHDR                    = 0x18
+	IPV6_ADDR_MC_FLAGS_PREFIX         = 0x20
+	IPV6_ADDR_MC_FLAGS_TRANSIENT      = 0x10
+	IPV6_ADDR_MC_FLAGS_UNICAST_BASED  = 0x30
 	IPV6_BINDV6ONLY                   = 0x1b
 	IPV6_BOUND_IF                     = 0x7d
 	IPV6_CHECKSUM                     = 0x1a
@@ -775,7 +787,7 @@ const (
 	IPV6_FAITH                        = 0x1d
 	IPV6_FLOWINFO_MASK                = 0xffffff0f
 	IPV6_FLOWLABEL_MASK               = 0xffff0f00
-	IPV6_FLOW_ECN_MASK                = 0x300
+	IPV6_FLOW_ECN_MASK                = 0x3000
 	IPV6_FRAGTTL                      = 0x3c
 	IPV6_FW_ADD                       = 0x1e
 	IPV6_FW_DEL                       = 0x1f
@@ -818,6 +830,7 @@ const (
 	IP_DEFAULT_MULTICAST_LOOP         = 0x1
 	IP_DEFAULT_MULTICAST_TTL          = 0x1
 	IP_DF                             = 0x4000
+	IP_DONTFRAG                       = 0x1c
 	IP_DROP_MEMBERSHIP                = 0xd
 	IP_DROP_SOURCE_MEMBERSHIP         = 0x47
 	IP_DUMMYNET_CONFIGURE             = 0x3c
@@ -889,6 +902,12 @@ const (
 	KERN_OSRELEASE                    = 0x2
 	KERN_OSTYPE                       = 0x1
 	KERN_VERSION                      = 0x4
+	LOCAL_PEERCRED                    = 0x1
+	LOCAL_PEEREPID                    = 0x3
+	LOCAL_PEEREUUID                   = 0x5
+	LOCAL_PEERPID                     = 0x2
+	LOCAL_PEERTOKEN                   = 0x6
+	LOCAL_PEERUUID                    = 0x4
 	LOCK_EX                           = 0x2
 	LOCK_NB                           = 0x4
 	LOCK_SH                           = 0x1
@@ -904,6 +923,7 @@ const (
 	MADV_SEQUENTIAL                   = 0x2
 	MADV_WILLNEED                     = 0x3
 	MADV_ZERO_WIRED_PAGES             = 0x6
+	MAP_32BIT                         = 0x8000
 	MAP_ANON                          = 0x1000
 	MAP_ANONYMOUS                     = 0x1000
 	MAP_COPY                          = 0x2
@@ -920,6 +940,17 @@ const (
 	MAP_RESILIENT_CODESIGN            = 0x2000
 	MAP_RESILIENT_MEDIA               = 0x4000
 	MAP_SHARED                        = 0x1
+	MAP_TRANSLATED_ALLOW_EXECUTE      = 0x20000
+	MAP_UNIX03                        = 0x40000
+	MCAST_BLOCK_SOURCE                = 0x54
+	MCAST_EXCLUDE                     = 0x2
+	MCAST_INCLUDE                     = 0x1
+	MCAST_JOIN_GROUP                  = 0x50
+	MCAST_JOIN_SOURCE_GROUP           = 0x52
+	MCAST_LEAVE_GROUP                 = 0x51
+	MCAST_LEAVE_SOURCE_GROUP          = 0x53
+	MCAST_UNBLOCK_SOURCE              = 0x55
+	MCAST_UNDEFINED                   = 0x0
 	MCL_CURRENT                       = 0x1
 	MCL_FUTURE                        = 0x2
 	MNT_ASYNC                         = 0x40
@@ -931,6 +962,7 @@ const (
 	MNT_DOVOLFS                       = 0x8000
 	MNT_DWAIT                         = 0x4
 	MNT_EXPORTED                      = 0x100
+	MNT_EXT_ROOT_DATA_VOL             = 0x1
 	MNT_FORCE                         = 0x80000
 	MNT_IGNORE_OWNERSHIP              = 0x200000
 	MNT_JOURNALED                     = 0x800000
@@ -947,12 +979,15 @@ const (
 	MNT_QUOTA                         = 0x2000
 	MNT_RDONLY                        = 0x1
 	MNT_RELOAD                        = 0x40000
+	MNT_REMOVABLE                     = 0x200
 	MNT_ROOTFS                        = 0x4000
+	MNT_SNAPSHOT                      = 0x40000000
+	MNT_STRICTATIME                   = 0x80000000
 	MNT_SYNCHRONOUS                   = 0x2
 	MNT_UNION                         = 0x20
 	MNT_UNKNOWNPERMISSIONS            = 0x200000
 	MNT_UPDATE                        = 0x10000
-	MNT_VISFLAGMASK                   = 0x17f0f5ff
+	MNT_VISFLAGMASK                   = 0xd7f0f7ff
 	MNT_WAIT                          = 0x1
 	MSG_CTRUNC                        = 0x20
 	MSG_DONTROUTE                     = 0x4
@@ -963,6 +998,7 @@ const (
 	MSG_HAVEMORE                      = 0x2000
 	MSG_HOLD                          = 0x800
 	MSG_NEEDSA                        = 0x10000
+	MSG_NOSIGNAL                      = 0x80000
 	MSG_OOB                           = 0x1
 	MSG_PEEK                          = 0x2
 	MSG_RCVMORE                       = 0x4000
@@ -979,9 +1015,10 @@ const (
 	NET_RT_DUMP                       = 0x1
 	NET_RT_DUMP2                      = 0x7
 	NET_RT_FLAGS                      = 0x2
+	NET_RT_FLAGS_PRIV                 = 0xa
 	NET_RT_IFLIST                     = 0x3
 	NET_RT_IFLIST2                    = 0x6
-	NET_RT_MAXID                      = 0xa
+	NET_RT_MAXID                      = 0xb
 	NET_RT_STAT                       = 0x4
 	NET_RT_TRASH                      = 0x5
 	NFDBITS                           = 0x20
@@ -1019,6 +1056,7 @@ const (
 	NOTE_LEEWAY                       = 0x10
 	NOTE_LINK                         = 0x10
 	NOTE_LOWAT                        = 0x1
+	NOTE_MACHTIME                     = 0x100
 	NOTE_MACH_CONTINUOUS_TIME         = 0x80
 	NOTE_NONE                         = 0x80
 	NOTE_NSECONDS                     = 0x4
@@ -1065,6 +1103,7 @@ const (
 	O_NDELAY                          = 0x4
 	O_NOCTTY                          = 0x20000
 	O_NOFOLLOW                        = 0x100
+	O_NOFOLLOW_ANY                    = 0x20000000
 	O_NONBLOCK                        = 0x4
 	O_POPUP                           = 0x80000000
 	O_RDONLY                          = 0x0
@@ -1136,6 +1175,7 @@ const (
 	RTF_BROADCAST                     = 0x400000
 	RTF_CLONING                       = 0x100
 	RTF_CONDEMNED                     = 0x2000000
+	RTF_DEAD                          = 0x20000000
 	RTF_DELCLONE                      = 0x80
 	RTF_DONE                          = 0x40
 	RTF_DYNAMIC                       = 0x10
@@ -1143,6 +1183,7 @@ const (
 	RTF_HOST                          = 0x4
 	RTF_IFREF                         = 0x4000000
 	RTF_IFSCOPE                       = 0x1000000
+	RTF_LLDATA                        = 0x400
 	RTF_LLINFO                        = 0x400
 	RTF_LOCAL                         = 0x200000
 	RTF_MODIFIED                      = 0x20
@@ -1210,6 +1251,7 @@ const (
 	SIOCGDRVSPEC                      = 0xc028697b
 	SIOCGETVLAN                       = 0xc020697f
 	SIOCGHIWAT                        = 0x40047301
+	SIOCGIF6LOWPAN                    = 0xc02069c5
 	SIOCGIFADDR                       = 0xc0206921
 	SIOCGIFALTMTU                     = 0xc0206948
 	SIOCGIFASYNCMAP                   = 0xc020697c
@@ -1220,6 +1262,7 @@ const (
 	SIOCGIFDEVMTU                     = 0xc0206944
 	SIOCGIFDSTADDR                    = 0xc0206922
 	SIOCGIFFLAGS                      = 0xc0206911
+	SIOCGIFFUNCTIONALTYPE             = 0xc02069ad
 	SIOCGIFGENERIC                    = 0xc020693a
 	SIOCGIFKPI                        = 0xc0206987
 	SIOCGIFMAC                        = 0xc0206982
@@ -1233,6 +1276,7 @@ const (
 	SIOCGIFSTATUS                     = 0xc331693d
 	SIOCGIFVLAN                       = 0xc020697f
 	SIOCGIFWAKEFLAGS                  = 0xc0206988
+	SIOCGIFXMEDIA                     = 0xc02c6948
 	SIOCGLOWAT                        = 0x40047303
 	SIOCGPGRP                         = 0x40047309
 	SIOCIFCREATE                      = 0xc0206978
@@ -1243,6 +1287,7 @@ const (
 	SIOCSDRVSPEC                      = 0x8028697b
 	SIOCSETVLAN                       = 0x8020697e
 	SIOCSHIWAT                        = 0x80047300
+	SIOCSIF6LOWPAN                    = 0x802069c4
 	SIOCSIFADDR                       = 0x8020690c
 	SIOCSIFALTMTU                     = 0x80206945
 	SIOCSIFASYNCMAP                   = 0x8020697d
@@ -1270,6 +1315,7 @@ const (
 	SOCK_RDM                          = 0x4
 	SOCK_SEQPACKET                    = 0x5
 	SOCK_STREAM                       = 0x1
+	SOL_LOCAL                         = 0x0
 	SOL_SOCKET                        = 0xffff
 	SOMAXCONN                         = 0x80
 	SO_ACCEPTCONN                     = 0x2
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
index b40fb1f696..8602b13633 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
@@ -32,7 +32,7 @@ const (
 	AF_LAT                            = 0xe
 	AF_LINK                           = 0x12
 	AF_LOCAL                          = 0x1
-	AF_MAX                            = 0x28
+	AF_MAX                            = 0x29
 	AF_NATM                           = 0x1f
 	AF_NDRV                           = 0x1b
 	AF_NETBIOS                        = 0x21
@@ -49,6 +49,7 @@ const (
 	AF_UNIX                           = 0x1
 	AF_UNSPEC                         = 0x0
 	AF_UTUN                           = 0x26
+	AF_VSOCK                          = 0x28
 	ALTWERASE                         = 0x200
 	ATTR_BIT_MAP_COUNT                = 0x5
 	ATTR_CMN_ACCESSMASK               = 0x20000
@@ -83,7 +84,7 @@ const (
 	ATTR_CMN_PAROBJID                 = 0x80
 	ATTR_CMN_RETURNED_ATTRS           = 0x80000000
 	ATTR_CMN_SCRIPT                   = 0x100
-	ATTR_CMN_SETMASK                  = 0x41c7ff00
+	ATTR_CMN_SETMASK                  = 0x51c7ff00
 	ATTR_CMN_USERACCESS               = 0x200000
 	ATTR_CMN_UUID                     = 0x800000
 	ATTR_CMN_VALIDMASK                = 0xffffffff
@@ -357,7 +358,7 @@ const (
 	DLT_LINUX_SLL                     = 0x71
 	DLT_LOOP                          = 0x6c
 	DLT_LTALK                         = 0x72
-	DLT_MATCHING_MAX                  = 0xf5
+	DLT_MATCHING_MAX                  = 0x10a
 	DLT_MATCHING_MIN                  = 0x68
 	DLT_MFR                           = 0xb6
 	DLT_MOST                          = 0xd3
@@ -398,6 +399,7 @@ const (
 	DLT_SYMANTEC_FIREWALL             = 0x63
 	DLT_TZSP                          = 0x80
 	DLT_USB                           = 0xba
+	DLT_USB_DARWIN                    = 0x10a
 	DLT_USB_LINUX                     = 0xbd
 	DLT_USB_LINUX_MMAPPED             = 0xdc
 	DLT_USER0                         = 0x93
@@ -442,8 +444,8 @@ const (
 	EVFILT_PROC                       = -0x5
 	EVFILT_READ                       = -0x1
 	EVFILT_SIGNAL                     = -0x6
-	EVFILT_SYSCOUNT                   = 0xf
-	EVFILT_THREADMARKER               = 0xf
+	EVFILT_SYSCOUNT                   = 0x11
+	EVFILT_THREADMARKER               = 0x11
 	EVFILT_TIMER                      = -0x7
 	EVFILT_USER                       = -0xa
 	EVFILT_VM                         = -0xc
@@ -481,9 +483,12 @@ const (
 	FSOPT_NOINMEMUPDATE               = 0x2
 	FSOPT_PACK_INVAL_ATTRS            = 0x8
 	FSOPT_REPORT_FULLSIZE             = 0x4
+	FSOPT_RETURN_REALDEV              = 0x200
 	F_ADDFILESIGS                     = 0x3d
 	F_ADDFILESIGS_FOR_DYLD_SIM        = 0x53
+	F_ADDFILESIGS_INFO                = 0x67
 	F_ADDFILESIGS_RETURN              = 0x61
+	F_ADDFILESUPPL                    = 0x68
 	F_ADDSIGS                         = 0x3b
 	F_ALLOCATEALL                     = 0x4
 	F_ALLOCATECONTIG                  = 0x2
@@ -505,8 +510,10 @@ const (
 	F_GETOWN                          = 0x5
 	F_GETPATH                         = 0x32
 	F_GETPATH_MTMINFO                 = 0x47
+	F_GETPATH_NOFIRMLINK              = 0x66
 	F_GETPROTECTIONCLASS              = 0x3f
 	F_GETPROTECTIONLEVEL              = 0x4d
+	F_GETSIGSINFO                     = 0x69
 	F_GLOBAL_NOCACHE                  = 0x37
 	F_LOG2PHYS                        = 0x31
 	F_LOG2PHYS_EXT                    = 0x41
@@ -531,6 +538,7 @@ const (
 	F_SETPROTECTIONCLASS              = 0x40
 	F_SETSIZE                         = 0x2b
 	F_SINGLE_WRITER                   = 0x4c
+	F_SPECULATIVE_READ                = 0x65
 	F_THAW_FS                         = 0x36
 	F_TRANSCODEKEY                    = 0x4b
 	F_TRIM_ACTIVE_FILE                = 0x64
@@ -562,6 +570,7 @@ const (
 	IFF_UP                            = 0x1
 	IFNAMSIZ                          = 0x10
 	IFT_1822                          = 0x2
+	IFT_6LOWPAN                       = 0x40
 	IFT_AAL5                          = 0x31
 	IFT_ARCNET                        = 0x23
 	IFT_ARCNETPLUS                    = 0x24
@@ -766,6 +775,9 @@ const (
 	IPV6_2292PKTINFO                  = 0x13
 	IPV6_2292PKTOPTIONS               = 0x19
 	IPV6_2292RTHDR                    = 0x18
+	IPV6_ADDR_MC_FLAGS_PREFIX         = 0x20
+	IPV6_ADDR_MC_FLAGS_TRANSIENT      = 0x10
+	IPV6_ADDR_MC_FLAGS_UNICAST_BASED  = 0x30
 	IPV6_BINDV6ONLY                   = 0x1b
 	IPV6_BOUND_IF                     = 0x7d
 	IPV6_CHECKSUM                     = 0x1a
@@ -775,7 +787,7 @@ const (
 	IPV6_FAITH                        = 0x1d
 	IPV6_FLOWINFO_MASK                = 0xffffff0f
 	IPV6_FLOWLABEL_MASK               = 0xffff0f00
-	IPV6_FLOW_ECN_MASK                = 0x300
+	IPV6_FLOW_ECN_MASK                = 0x3000
 	IPV6_FRAGTTL                      = 0x3c
 	IPV6_FW_ADD                       = 0x1e
 	IPV6_FW_DEL                       = 0x1f
@@ -818,6 +830,7 @@ const (
 	IP_DEFAULT_MULTICAST_LOOP         = 0x1
 	IP_DEFAULT_MULTICAST_TTL          = 0x1
 	IP_DF                             = 0x4000
+	IP_DONTFRAG                       = 0x1c
 	IP_DROP_MEMBERSHIP                = 0xd
 	IP_DROP_SOURCE_MEMBERSHIP         = 0x47
 	IP_DUMMYNET_CONFIGURE             = 0x3c
@@ -889,6 +902,12 @@ const (
 	KERN_OSRELEASE                    = 0x2
 	KERN_OSTYPE                       = 0x1
 	KERN_VERSION                      = 0x4
+	LOCAL_PEERCRED                    = 0x1
+	LOCAL_PEEREPID                    = 0x3
+	LOCAL_PEEREUUID                   = 0x5
+	LOCAL_PEERPID                     = 0x2
+	LOCAL_PEERTOKEN                   = 0x6
+	LOCAL_PEERUUID                    = 0x4
 	LOCK_EX                           = 0x2
 	LOCK_NB                           = 0x4
 	LOCK_SH                           = 0x1
@@ -904,6 +923,7 @@ const (
 	MADV_SEQUENTIAL                   = 0x2
 	MADV_WILLNEED                     = 0x3
 	MADV_ZERO_WIRED_PAGES             = 0x6
+	MAP_32BIT                         = 0x8000
 	MAP_ANON                          = 0x1000
 	MAP_ANONYMOUS                     = 0x1000
 	MAP_COPY                          = 0x2
@@ -920,6 +940,17 @@ const (
 	MAP_RESILIENT_CODESIGN            = 0x2000
 	MAP_RESILIENT_MEDIA               = 0x4000
 	MAP_SHARED                        = 0x1
+	MAP_TRANSLATED_ALLOW_EXECUTE      = 0x20000
+	MAP_UNIX03                        = 0x40000
+	MCAST_BLOCK_SOURCE                = 0x54
+	MCAST_EXCLUDE                     = 0x2
+	MCAST_INCLUDE                     = 0x1
+	MCAST_JOIN_GROUP                  = 0x50
+	MCAST_JOIN_SOURCE_GROUP           = 0x52
+	MCAST_LEAVE_GROUP                 = 0x51
+	MCAST_LEAVE_SOURCE_GROUP          = 0x53
+	MCAST_UNBLOCK_SOURCE              = 0x55
+	MCAST_UNDEFINED                   = 0x0
 	MCL_CURRENT                       = 0x1
 	MCL_FUTURE                        = 0x2
 	MNT_ASYNC                         = 0x40
@@ -931,6 +962,7 @@ const (
 	MNT_DOVOLFS                       = 0x8000
 	MNT_DWAIT                         = 0x4
 	MNT_EXPORTED                      = 0x100
+	MNT_EXT_ROOT_DATA_VOL             = 0x1
 	MNT_FORCE                         = 0x80000
 	MNT_IGNORE_OWNERSHIP              = 0x200000
 	MNT_JOURNALED                     = 0x800000
@@ -947,12 +979,15 @@ const (
 	MNT_QUOTA                         = 0x2000
 	MNT_RDONLY                        = 0x1
 	MNT_RELOAD                        = 0x40000
+	MNT_REMOVABLE                     = 0x200
 	MNT_ROOTFS                        = 0x4000
+	MNT_SNAPSHOT                      = 0x40000000
+	MNT_STRICTATIME                   = 0x80000000
 	MNT_SYNCHRONOUS                   = 0x2
 	MNT_UNION                         = 0x20
 	MNT_UNKNOWNPERMISSIONS            = 0x200000
 	MNT_UPDATE                        = 0x10000
-	MNT_VISFLAGMASK                   = 0x17f0f5ff
+	MNT_VISFLAGMASK                   = 0xd7f0f7ff
 	MNT_WAIT                          = 0x1
 	MSG_CTRUNC                        = 0x20
 	MSG_DONTROUTE                     = 0x4
@@ -963,6 +998,7 @@ const (
 	MSG_HAVEMORE                      = 0x2000
 	MSG_HOLD                          = 0x800
 	MSG_NEEDSA                        = 0x10000
+	MSG_NOSIGNAL                      = 0x80000
 	MSG_OOB                           = 0x1
 	MSG_PEEK                          = 0x2
 	MSG_RCVMORE                       = 0x4000
@@ -979,9 +1015,10 @@ const (
 	NET_RT_DUMP                       = 0x1
 	NET_RT_DUMP2                      = 0x7
 	NET_RT_FLAGS                      = 0x2
+	NET_RT_FLAGS_PRIV                 = 0xa
 	NET_RT_IFLIST                     = 0x3
 	NET_RT_IFLIST2                    = 0x6
-	NET_RT_MAXID                      = 0xa
+	NET_RT_MAXID                      = 0xb
 	NET_RT_STAT                       = 0x4
 	NET_RT_TRASH                      = 0x5
 	NFDBITS                           = 0x20
@@ -1019,6 +1056,7 @@ const (
 	NOTE_LEEWAY                       = 0x10
 	NOTE_LINK                         = 0x10
 	NOTE_LOWAT                        = 0x1
+	NOTE_MACHTIME                     = 0x100
 	NOTE_MACH_CONTINUOUS_TIME         = 0x80
 	NOTE_NONE                         = 0x80
 	NOTE_NSECONDS                     = 0x4
@@ -1065,6 +1103,7 @@ const (
 	O_NDELAY                          = 0x4
 	O_NOCTTY                          = 0x20000
 	O_NOFOLLOW                        = 0x100
+	O_NOFOLLOW_ANY                    = 0x20000000
 	O_NONBLOCK                        = 0x4
 	O_POPUP                           = 0x80000000
 	O_RDONLY                          = 0x0
@@ -1136,6 +1175,7 @@ const (
 	RTF_BROADCAST                     = 0x400000
 	RTF_CLONING                       = 0x100
 	RTF_CONDEMNED                     = 0x2000000
+	RTF_DEAD                          = 0x20000000
 	RTF_DELCLONE                      = 0x80
 	RTF_DONE                          = 0x40
 	RTF_DYNAMIC                       = 0x10
@@ -1143,6 +1183,7 @@ const (
 	RTF_HOST                          = 0x4
 	RTF_IFREF                         = 0x4000000
 	RTF_IFSCOPE                       = 0x1000000
+	RTF_LLDATA                        = 0x400
 	RTF_LLINFO                        = 0x400
 	RTF_LOCAL                         = 0x200000
 	RTF_MODIFIED                      = 0x20
@@ -1210,6 +1251,7 @@ const (
 	SIOCGDRVSPEC                      = 0xc028697b
 	SIOCGETVLAN                       = 0xc020697f
 	SIOCGHIWAT                        = 0x40047301
+	SIOCGIF6LOWPAN                    = 0xc02069c5
 	SIOCGIFADDR                       = 0xc0206921
 	SIOCGIFALTMTU                     = 0xc0206948
 	SIOCGIFASYNCMAP                   = 0xc020697c
@@ -1220,6 +1262,7 @@ const (
 	SIOCGIFDEVMTU                     = 0xc0206944
 	SIOCGIFDSTADDR                    = 0xc0206922
 	SIOCGIFFLAGS                      = 0xc0206911
+	SIOCGIFFUNCTIONALTYPE             = 0xc02069ad
 	SIOCGIFGENERIC                    = 0xc020693a
 	SIOCGIFKPI                        = 0xc0206987
 	SIOCGIFMAC                        = 0xc0206982
@@ -1233,6 +1276,7 @@ const (
 	SIOCGIFSTATUS                     = 0xc331693d
 	SIOCGIFVLAN                       = 0xc020697f
 	SIOCGIFWAKEFLAGS                  = 0xc0206988
+	SIOCGIFXMEDIA                     = 0xc02c6948
 	SIOCGLOWAT                        = 0x40047303
 	SIOCGPGRP                         = 0x40047309
 	SIOCIFCREATE                      = 0xc0206978
@@ -1243,6 +1287,7 @@ const (
 	SIOCSDRVSPEC                      = 0x8028697b
 	SIOCSETVLAN                       = 0x8020697e
 	SIOCSHIWAT                        = 0x80047300
+	SIOCSIF6LOWPAN                    = 0x802069c4
 	SIOCSIFADDR                       = 0x8020690c
 	SIOCSIFALTMTU                     = 0x80206945
 	SIOCSIFASYNCMAP                   = 0x8020697d
@@ -1270,6 +1315,7 @@ const (
 	SOCK_RDM                          = 0x4
 	SOCK_SEQPACKET                    = 0x5
 	SOCK_STREAM                       = 0x1
+	SOL_LOCAL                         = 0x0
 	SOL_SOCKET                        = 0xffff
 	SOMAXCONN                         = 0x80
 	SO_ACCEPTCONN                     = 0x2
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux.go
index b46110354d..c5e2f47930 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux.go
@@ -65,6 +65,7 @@ const (
 	ALG_OP_ENCRYPT                              = 0x1
 	ALG_SET_AEAD_ASSOCLEN                       = 0x4
 	ALG_SET_AEAD_AUTHSIZE                       = 0x5
+	ALG_SET_DRBG_ENTROPY                        = 0x6
 	ALG_SET_IV                                  = 0x2
 	ALG_SET_KEY                                 = 0x1
 	ALG_SET_OP                                  = 0x3
@@ -179,8 +180,10 @@ const (
 	BPF_F_ANY_ALIGNMENT                         = 0x2
 	BPF_F_QUERY_EFFECTIVE                       = 0x1
 	BPF_F_REPLACE                               = 0x4
+	BPF_F_SLEEPABLE                             = 0x10
 	BPF_F_STRICT_ALIGNMENT                      = 0x1
 	BPF_F_TEST_RND_HI32                         = 0x4
+	BPF_F_TEST_RUN_ON_CPU                       = 0x1
 	BPF_F_TEST_STATE_FREQ                       = 0x8
 	BPF_H                                       = 0x8
 	BPF_IMM                                     = 0x0
@@ -219,6 +222,7 @@ const (
 	BPF_NET_OFF                                 = -0x100000
 	BPF_OBJ_NAME_LEN                            = 0x10
 	BPF_OR                                      = 0x40
+	BPF_PSEUDO_BTF_ID                           = 0x3
 	BPF_PSEUDO_CALL                             = 0x1
 	BPF_PSEUDO_MAP_FD                           = 0x1
 	BPF_PSEUDO_MAP_VALUE                        = 0x2
@@ -309,6 +313,7 @@ const (
 	CAN_J1939                                   = 0x7
 	CAN_MAX_DLC                                 = 0x8
 	CAN_MAX_DLEN                                = 0x8
+	CAN_MAX_RAW_DLC                             = 0xf
 	CAN_MCNET                                   = 0x5
 	CAN_MTU                                     = 0x10
 	CAN_NPROTO                                  = 0x8
@@ -429,10 +434,13 @@ const (
 	DEBUGFS_MAGIC                               = 0x64626720
 	DEVLINK_CMD_ESWITCH_MODE_GET                = 0x1d
 	DEVLINK_CMD_ESWITCH_MODE_SET                = 0x1e
+	DEVLINK_FLASH_OVERWRITE_IDENTIFIERS         = 0x2
+	DEVLINK_FLASH_OVERWRITE_SETTINGS            = 0x1
 	DEVLINK_GENL_MCGRP_CONFIG_NAME              = "config"
 	DEVLINK_GENL_NAME                           = "devlink"
 	DEVLINK_GENL_VERSION                        = 0x1
 	DEVLINK_SB_THRESHOLD_TO_ALPHA_MAX           = 0x14
+	DEVLINK_SUPPORTED_FLASH_OVERWRITE_SECTIONS  = 0x3
 	DEVMEM_MAGIC                                = 0x454d444d
 	DEVPTS_SUPER_MAGIC                          = 0x1cd1
 	DMA_BUF_MAGIC                               = 0x444d4142
@@ -477,9 +485,9 @@ const (
 	DM_UUID_FLAG                                = 0x4000
 	DM_UUID_LEN                                 = 0x81
 	DM_VERSION                                  = 0xc138fd00
-	DM_VERSION_EXTRA                            = "-ioctl (2020-02-27)"
+	DM_VERSION_EXTRA                            = "-ioctl (2020-10-01)"
 	DM_VERSION_MAJOR                            = 0x4
-	DM_VERSION_MINOR                            = 0x2a
+	DM_VERSION_MINOR                            = 0x2b
 	DM_VERSION_PATCHLEVEL                       = 0x0
 	DT_BLK                                      = 0x6
 	DT_CHR                                      = 0x2
@@ -520,6 +528,119 @@ const (
 	EPOLL_CTL_DEL                               = 0x2
 	EPOLL_CTL_MOD                               = 0x3
 	EROFS_SUPER_MAGIC_V1                        = 0xe0f5e1e2
+	ESP_V4_FLOW                                 = 0xa
+	ESP_V6_FLOW                                 = 0xc
+	ETHER_FLOW                                  = 0x12
+	ETHTOOL_BUSINFO_LEN                         = 0x20
+	ETHTOOL_EROMVERS_LEN                        = 0x20
+	ETHTOOL_FEC_AUTO                            = 0x2
+	ETHTOOL_FEC_BASER                           = 0x10
+	ETHTOOL_FEC_LLRS                            = 0x20
+	ETHTOOL_FEC_NONE                            = 0x1
+	ETHTOOL_FEC_OFF                             = 0x4
+	ETHTOOL_FEC_RS                              = 0x8
+	ETHTOOL_FLAG_ALL                            = 0x7
+	ETHTOOL_FLAG_COMPACT_BITSETS                = 0x1
+	ETHTOOL_FLAG_OMIT_REPLY                     = 0x2
+	ETHTOOL_FLAG_STATS                          = 0x4
+	ETHTOOL_FLASHDEV                            = 0x33
+	ETHTOOL_FLASH_MAX_FILENAME                  = 0x80
+	ETHTOOL_FWVERS_LEN                          = 0x20
+	ETHTOOL_F_COMPAT                            = 0x4
+	ETHTOOL_F_UNSUPPORTED                       = 0x1
+	ETHTOOL_F_WISH                              = 0x2
+	ETHTOOL_GCHANNELS                           = 0x3c
+	ETHTOOL_GCOALESCE                           = 0xe
+	ETHTOOL_GDRVINFO                            = 0x3
+	ETHTOOL_GEEE                                = 0x44
+	ETHTOOL_GEEPROM                             = 0xb
+	ETHTOOL_GENL_NAME                           = "ethtool"
+	ETHTOOL_GENL_VERSION                        = 0x1
+	ETHTOOL_GET_DUMP_DATA                       = 0x40
+	ETHTOOL_GET_DUMP_FLAG                       = 0x3f
+	ETHTOOL_GET_TS_INFO                         = 0x41
+	ETHTOOL_GFEATURES                           = 0x3a
+	ETHTOOL_GFECPARAM                           = 0x50
+	ETHTOOL_GFLAGS                              = 0x25
+	ETHTOOL_GGRO                                = 0x2b
+	ETHTOOL_GGSO                                = 0x23
+	ETHTOOL_GLINK                               = 0xa
+	ETHTOOL_GLINKSETTINGS                       = 0x4c
+	ETHTOOL_GMODULEEEPROM                       = 0x43
+	ETHTOOL_GMODULEINFO                         = 0x42
+	ETHTOOL_GMSGLVL                             = 0x7
+	ETHTOOL_GPAUSEPARAM                         = 0x12
+	ETHTOOL_GPERMADDR                           = 0x20
+	ETHTOOL_GPFLAGS                             = 0x27
+	ETHTOOL_GPHYSTATS                           = 0x4a
+	ETHTOOL_GREGS                               = 0x4
+	ETHTOOL_GRINGPARAM                          = 0x10
+	ETHTOOL_GRSSH                               = 0x46
+	ETHTOOL_GRXCLSRLALL                         = 0x30
+	ETHTOOL_GRXCLSRLCNT                         = 0x2e
+	ETHTOOL_GRXCLSRULE                          = 0x2f
+	ETHTOOL_GRXCSUM                             = 0x14
+	ETHTOOL_GRXFH                               = 0x29
+	ETHTOOL_GRXFHINDIR                          = 0x38
+	ETHTOOL_GRXNTUPLE                           = 0x36
+	ETHTOOL_GRXRINGS                            = 0x2d
+	ETHTOOL_GSET                                = 0x1
+	ETHTOOL_GSG                                 = 0x18
+	ETHTOOL_GSSET_INFO                          = 0x37
+	ETHTOOL_GSTATS                              = 0x1d
+	ETHTOOL_GSTRINGS                            = 0x1b
+	ETHTOOL_GTSO                                = 0x1e
+	ETHTOOL_GTUNABLE                            = 0x48
+	ETHTOOL_GTXCSUM                             = 0x16
+	ETHTOOL_GUFO                                = 0x21
+	ETHTOOL_GWOL                                = 0x5
+	ETHTOOL_MCGRP_MONITOR_NAME                  = "monitor"
+	ETHTOOL_NWAY_RST                            = 0x9
+	ETHTOOL_PERQUEUE                            = 0x4b
+	ETHTOOL_PHYS_ID                             = 0x1c
+	ETHTOOL_PHY_EDPD_DFLT_TX_MSECS              = 0xffff
+	ETHTOOL_PHY_EDPD_DISABLE                    = 0x0
+	ETHTOOL_PHY_EDPD_NO_TX                      = 0xfffe
+	ETHTOOL_PHY_FAST_LINK_DOWN_OFF              = 0xff
+	ETHTOOL_PHY_FAST_LINK_DOWN_ON               = 0x0
+	ETHTOOL_PHY_GTUNABLE                        = 0x4e
+	ETHTOOL_PHY_STUNABLE                        = 0x4f
+	ETHTOOL_RESET                               = 0x34
+	ETHTOOL_RXNTUPLE_ACTION_CLEAR               = -0x2
+	ETHTOOL_RXNTUPLE_ACTION_DROP                = -0x1
+	ETHTOOL_RX_FLOW_SPEC_RING                   = 0xffffffff
+	ETHTOOL_RX_FLOW_SPEC_RING_VF                = 0xff00000000
+	ETHTOOL_RX_FLOW_SPEC_RING_VF_OFF            = 0x20
+	ETHTOOL_SCHANNELS                           = 0x3d
+	ETHTOOL_SCOALESCE                           = 0xf
+	ETHTOOL_SEEE                                = 0x45
+	ETHTOOL_SEEPROM                             = 0xc
+	ETHTOOL_SET_DUMP                            = 0x3e
+	ETHTOOL_SFEATURES                           = 0x3b
+	ETHTOOL_SFECPARAM                           = 0x51
+	ETHTOOL_SFLAGS                              = 0x26
+	ETHTOOL_SGRO                                = 0x2c
+	ETHTOOL_SGSO                                = 0x24
+	ETHTOOL_SLINKSETTINGS                       = 0x4d
+	ETHTOOL_SMSGLVL                             = 0x8
+	ETHTOOL_SPAUSEPARAM                         = 0x13
+	ETHTOOL_SPFLAGS                             = 0x28
+	ETHTOOL_SRINGPARAM                          = 0x11
+	ETHTOOL_SRSSH                               = 0x47
+	ETHTOOL_SRXCLSRLDEL                         = 0x31
+	ETHTOOL_SRXCLSRLINS                         = 0x32
+	ETHTOOL_SRXCSUM                             = 0x15
+	ETHTOOL_SRXFH                               = 0x2a
+	ETHTOOL_SRXFHINDIR                          = 0x39
+	ETHTOOL_SRXNTUPLE                           = 0x35
+	ETHTOOL_SSET                                = 0x2
+	ETHTOOL_SSG                                 = 0x19
+	ETHTOOL_STSO                                = 0x1f
+	ETHTOOL_STUNABLE                            = 0x49
+	ETHTOOL_STXCSUM                             = 0x17
+	ETHTOOL_SUFO                                = 0x22
+	ETHTOOL_SWOL                                = 0x6
+	ETHTOOL_TEST                                = 0x1a
 	ETH_P_1588                                  = 0x88f7
 	ETH_P_8021AD                                = 0x88a8
 	ETH_P_8021AH                                = 0x88e7
@@ -544,6 +665,7 @@ const (
 	ETH_P_CAIF                                  = 0xf7
 	ETH_P_CAN                                   = 0xc
 	ETH_P_CANFD                                 = 0xd
+	ETH_P_CFM                                   = 0x8902
 	ETH_P_CONTROL                               = 0x16
 	ETH_P_CUST                                  = 0x6006
 	ETH_P_DDCMP                                 = 0x6
@@ -714,7 +836,6 @@ const (
 	FSCRYPT_POLICY_FLAGS_PAD_4                  = 0x0
 	FSCRYPT_POLICY_FLAGS_PAD_8                  = 0x1
 	FSCRYPT_POLICY_FLAGS_PAD_MASK               = 0x3
-	FSCRYPT_POLICY_FLAGS_VALID                  = 0x1f
 	FSCRYPT_POLICY_FLAG_DIRECT_KEY              = 0x4
 	FSCRYPT_POLICY_FLAG_IV_INO_LBLK_32          = 0x10
 	FSCRYPT_POLICY_FLAG_IV_INO_LBLK_64          = 0x8
@@ -745,7 +866,7 @@ const (
 	FS_POLICY_FLAGS_PAD_4                       = 0x0
 	FS_POLICY_FLAGS_PAD_8                       = 0x1
 	FS_POLICY_FLAGS_PAD_MASK                    = 0x3
-	FS_POLICY_FLAGS_VALID                       = 0x1f
+	FS_POLICY_FLAGS_VALID                       = 0x7
 	FS_VERITY_FL                                = 0x100000
 	FS_VERITY_HASH_ALG_SHA256                   = 0x1
 	FS_VERITY_HASH_ALG_SHA512                   = 0x2
@@ -989,6 +1110,7 @@ const (
 	IPV6_DONTFRAG                               = 0x3e
 	IPV6_DROP_MEMBERSHIP                        = 0x15
 	IPV6_DSTOPTS                                = 0x3b
+	IPV6_FLOW                                   = 0x11
 	IPV6_FREEBIND                               = 0x4e
 	IPV6_HDRINCL                                = 0x24
 	IPV6_HOPLIMIT                               = 0x34
@@ -1017,6 +1139,7 @@ const (
 	IPV6_PMTUDISC_WANT                          = 0x1
 	IPV6_RECVDSTOPTS                            = 0x3a
 	IPV6_RECVERR                                = 0x19
+	IPV6_RECVERR_RFC4884                        = 0x1f
 	IPV6_RECVFRAGSIZE                           = 0x4d
 	IPV6_RECVHOPLIMIT                           = 0x33
 	IPV6_RECVHOPOPTS                            = 0x35
@@ -1038,6 +1161,7 @@ const (
 	IPV6_TRANSPARENT                            = 0x4b
 	IPV6_UNICAST_HOPS                           = 0x10
 	IPV6_UNICAST_IF                             = 0x4c
+	IPV6_USER_FLOW                              = 0xe
 	IPV6_V6ONLY                                 = 0x1a
 	IPV6_XFRM_POLICY                            = 0x23
 	IP_ADD_MEMBERSHIP                           = 0x23
@@ -1080,6 +1204,7 @@ const (
 	IP_PMTUDISC_PROBE                           = 0x3
 	IP_PMTUDISC_WANT                            = 0x1
 	IP_RECVERR                                  = 0xb
+	IP_RECVERR_RFC4884                          = 0x1a
 	IP_RECVFRAGSIZE                             = 0x19
 	IP_RECVOPTS                                 = 0x6
 	IP_RECVORIGDSTADDR                          = 0x14
@@ -1094,6 +1219,7 @@ const (
 	IP_TTL                                      = 0x2
 	IP_UNBLOCK_SOURCE                           = 0x25
 	IP_UNICAST_IF                               = 0x32
+	IP_USER_FLOW                                = 0xd
 	IP_XFRM_POLICY                              = 0x11
 	ISOFS_SUPER_MAGIC                           = 0x9660
 	ISTRIP                                      = 0x20
@@ -1331,6 +1457,7 @@ const (
 	MS_NOREMOTELOCK                             = 0x8000000
 	MS_NOSEC                                    = 0x10000000
 	MS_NOSUID                                   = 0x2
+	MS_NOSYMFOLLOW                              = 0x100
 	MS_NOUSER                                   = -0x80000000
 	MS_POSIXACL                                 = 0x10000
 	MS_PRIVATE                                  = 0x40000
@@ -1572,7 +1699,7 @@ const (
 	PERF_MEM_REMOTE_REMOTE                      = 0x1
 	PERF_MEM_REMOTE_SHIFT                       = 0x25
 	PERF_MEM_SNOOPX_FWD                         = 0x1
-	PERF_MEM_SNOOPX_SHIFT                       = 0x25
+	PERF_MEM_SNOOPX_SHIFT                       = 0x26
 	PERF_MEM_SNOOP_HIT                          = 0x4
 	PERF_MEM_SNOOP_HITM                         = 0x10
 	PERF_MEM_SNOOP_MISS                         = 0x8
@@ -1672,6 +1799,13 @@ const (
 	PR_MCE_KILL_SET                             = 0x1
 	PR_MPX_DISABLE_MANAGEMENT                   = 0x2c
 	PR_MPX_ENABLE_MANAGEMENT                    = 0x2b
+	PR_MTE_TAG_MASK                             = 0x7fff8
+	PR_MTE_TAG_SHIFT                            = 0x3
+	PR_MTE_TCF_ASYNC                            = 0x4
+	PR_MTE_TCF_MASK                             = 0x6
+	PR_MTE_TCF_NONE                             = 0x0
+	PR_MTE_TCF_SHIFT                            = 0x1
+	PR_MTE_TCF_SYNC                             = 0x2
 	PR_PAC_APDAKEY                              = 0x4
 	PR_PAC_APDBKEY                              = 0x8
 	PR_PAC_APGAKEY                              = 0x10
@@ -1709,6 +1843,7 @@ const (
 	PR_SET_SECCOMP                              = 0x16
 	PR_SET_SECUREBITS                           = 0x1c
 	PR_SET_SPECULATION_CTRL                     = 0x35
+	PR_SET_SYSCALL_USER_DISPATCH                = 0x3b
 	PR_SET_TAGGED_ADDR_CTRL                     = 0x37
 	PR_SET_THP_DISABLE                          = 0x29
 	PR_SET_TIMERSLACK                           = 0x1d
@@ -1728,6 +1863,8 @@ const (
 	PR_SVE_SET_VL_ONEXEC                        = 0x40000
 	PR_SVE_VL_INHERIT                           = 0x20000
 	PR_SVE_VL_LEN_MASK                          = 0xffff
+	PR_SYS_DISPATCH_OFF                         = 0x0
+	PR_SYS_DISPATCH_ON                          = 0x1
 	PR_TAGGED_ADDR_ENABLE                       = 0x1
 	PR_TASK_PERF_EVENTS_DISABLE                 = 0x1f
 	PR_TASK_PERF_EVENTS_ENABLE                  = 0x20
@@ -1973,12 +2110,13 @@ const (
 	RTM_SETLINK                                 = 0x13
 	RTM_SETNEIGHTBL                             = 0x43
 	RTNH_ALIGNTO                                = 0x4
-	RTNH_COMPARE_MASK                           = 0x19
+	RTNH_COMPARE_MASK                           = 0x59
 	RTNH_F_DEAD                                 = 0x1
 	RTNH_F_LINKDOWN                             = 0x10
 	RTNH_F_OFFLOAD                              = 0x8
 	RTNH_F_ONLINK                               = 0x4
 	RTNH_F_PERVASIVE                            = 0x2
+	RTNH_F_TRAP                                 = 0x40
 	RTNH_F_UNRESOLVED                           = 0x20
 	RTN_MAX                                     = 0xb
 	RTPROT_BABEL                                = 0x2a
@@ -2206,7 +2344,7 @@ const (
 	STATX_ATTR_APPEND                           = 0x20
 	STATX_ATTR_AUTOMOUNT                        = 0x1000
 	STATX_ATTR_COMPRESSED                       = 0x4
-	STATX_ATTR_DAX                              = 0x2000
+	STATX_ATTR_DAX                              = 0x200000
 	STATX_ATTR_ENCRYPTED                        = 0x800
 	STATX_ATTR_IMMUTABLE                        = 0x10
 	STATX_ATTR_MOUNT_ROOT                       = 0x2000
@@ -2325,6 +2463,8 @@ const (
 	TCP_TX_DELAY                                = 0x25
 	TCP_ULP                                     = 0x1f
 	TCP_USER_TIMEOUT                            = 0x12
+	TCP_V4_FLOW                                 = 0x1
+	TCP_V6_FLOW                                 = 0x5
 	TCP_WINDOW_CLAMP                            = 0xa
 	TCP_ZEROCOPY_RECEIVE                        = 0x23
 	TFD_TIMER_ABSTIME                           = 0x1
@@ -2390,6 +2530,7 @@ const (
 	TIPC_NODE_STATE                             = 0x0
 	TIPC_OK                                     = 0x0
 	TIPC_PUBLISHED                              = 0x1
+	TIPC_REKEYING_NOW                           = 0xffffffff
 	TIPC_RESERVED_TYPES                         = 0x40
 	TIPC_RETDATA                                = 0x2
 	TIPC_SERVICE_ADDR                           = 0x2
@@ -2446,10 +2587,12 @@ const (
 	VMADDR_CID_HOST                             = 0x2
 	VMADDR_CID_HYPERVISOR                       = 0x0
 	VMADDR_CID_LOCAL                            = 0x1
+	VMADDR_FLAG_TO_HOST                         = 0x1
 	VMADDR_PORT_ANY                             = 0xffffffff
 	VM_SOCKETS_INVALID_VERSION                  = 0xffffffff
 	VQUIT                                       = 0x1
 	VT0                                         = 0x0
+	WAKE_MAGIC                                  = 0x20
 	WALL                                        = 0x40000000
 	WCLONE                                      = 0x80000000
 	WCONTINUED                                  = 0x8
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
index dd282c08b7..c8d5b324c7 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
@@ -4,7 +4,7 @@
 // +build 386,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include -m32 _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include -m32 /build/_const.go
 
 package unix
 
@@ -165,6 +165,7 @@ const (
 	PERF_EVENT_IOC_SET_OUTPUT        = 0x2405
 	PPPIOCATTACH                     = 0x4004743d
 	PPPIOCATTCHAN                    = 0x40047438
+	PPPIOCBRIDGECHAN                 = 0x40047435
 	PPPIOCCONNECT                    = 0x4004743a
 	PPPIOCDETACH                     = 0x4004743c
 	PPPIOCDISCONN                    = 0x7439
@@ -192,6 +193,7 @@ const (
 	PPPIOCSPASS                      = 0x40087447
 	PPPIOCSRASYNCMAP                 = 0x40047454
 	PPPIOCSXASYNCMAP                 = 0x4020744f
+	PPPIOCUNBRIDGECHAN               = 0x7434
 	PPPIOCXFERUNIT                   = 0x744e
 	PR_SET_PTRACER_ANY               = 0xffffffff
 	PTRACE_GETFPREGS                 = 0xe
@@ -268,6 +270,7 @@ const (
 	SO_BROADCAST                     = 0x6
 	SO_BSDCOMPAT                     = 0xe
 	SO_BUSY_POLL                     = 0x2e
+	SO_BUSY_POLL_BUDGET              = 0x46
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
@@ -290,6 +293,7 @@ const (
 	SO_PEERCRED                      = 0x11
 	SO_PEERGROUPS                    = 0x3b
 	SO_PEERSEC                       = 0x1f
+	SO_PREFER_BUSY_POLL              = 0x45
 	SO_PROTOCOL                      = 0x26
 	SO_RCVBUF                        = 0x8
 	SO_RCVBUFFORCE                   = 0x21
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
index 82fc93c7bb..e605c08b0e 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
@@ -4,7 +4,7 @@
 // +build amd64,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include -m64 _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include -m64 /build/_const.go
 
 package unix
 
@@ -165,6 +165,7 @@ const (
 	PERF_EVENT_IOC_SET_OUTPUT        = 0x2405
 	PPPIOCATTACH                     = 0x4004743d
 	PPPIOCATTCHAN                    = 0x40047438
+	PPPIOCBRIDGECHAN                 = 0x40047435
 	PPPIOCCONNECT                    = 0x4004743a
 	PPPIOCDETACH                     = 0x4004743c
 	PPPIOCDISCONN                    = 0x7439
@@ -192,6 +193,7 @@ const (
 	PPPIOCSPASS                      = 0x40107447
 	PPPIOCSRASYNCMAP                 = 0x40047454
 	PPPIOCSXASYNCMAP                 = 0x4020744f
+	PPPIOCUNBRIDGECHAN               = 0x7434
 	PPPIOCXFERUNIT                   = 0x744e
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
 	PTRACE_ARCH_PRCTL                = 0x1e
@@ -269,6 +271,7 @@ const (
 	SO_BROADCAST                     = 0x6
 	SO_BSDCOMPAT                     = 0xe
 	SO_BUSY_POLL                     = 0x2e
+	SO_BUSY_POLL_BUDGET              = 0x46
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
@@ -291,6 +294,7 @@ const (
 	SO_PEERCRED                      = 0x11
 	SO_PEERGROUPS                    = 0x3b
 	SO_PEERSEC                       = 0x1f
+	SO_PREFER_BUSY_POLL              = 0x45
 	SO_PROTOCOL                      = 0x26
 	SO_RCVBUF                        = 0x8
 	SO_RCVBUFFORCE                   = 0x21
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
index fe7094f276..0279fa1abd 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
@@ -4,7 +4,7 @@
 // +build arm,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go
 
 package unix
 
@@ -163,6 +163,7 @@ const (
 	PERF_EVENT_IOC_SET_OUTPUT        = 0x2405
 	PPPIOCATTACH                     = 0x4004743d
 	PPPIOCATTCHAN                    = 0x40047438
+	PPPIOCBRIDGECHAN                 = 0x40047435
 	PPPIOCCONNECT                    = 0x4004743a
 	PPPIOCDETACH                     = 0x4004743c
 	PPPIOCDISCONN                    = 0x7439
@@ -190,6 +191,7 @@ const (
 	PPPIOCSPASS                      = 0x40087447
 	PPPIOCSRASYNCMAP                 = 0x40047454
 	PPPIOCSXASYNCMAP                 = 0x4020744f
+	PPPIOCUNBRIDGECHAN               = 0x7434
 	PPPIOCXFERUNIT                   = 0x744e
 	PR_SET_PTRACER_ANY               = 0xffffffff
 	PTRACE_GETCRUNCHREGS             = 0x19
@@ -275,6 +277,7 @@ const (
 	SO_BROADCAST                     = 0x6
 	SO_BSDCOMPAT                     = 0xe
 	SO_BUSY_POLL                     = 0x2e
+	SO_BUSY_POLL_BUDGET              = 0x46
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
@@ -297,6 +300,7 @@ const (
 	SO_PEERCRED                      = 0x11
 	SO_PEERGROUPS                    = 0x3b
 	SO_PEERSEC                       = 0x1f
+	SO_PREFER_BUSY_POLL              = 0x45
 	SO_PROTOCOL                      = 0x26
 	SO_RCVBUF                        = 0x8
 	SO_RCVBUFFORCE                   = 0x21
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
index 3b6cc58803..20c286a112 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
@@ -4,7 +4,7 @@
 // +build arm64,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include -fsigned-char _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include -fsigned-char /build/_const.go
 
 package unix
 
@@ -166,6 +166,7 @@ const (
 	PERF_EVENT_IOC_SET_OUTPUT        = 0x2405
 	PPPIOCATTACH                     = 0x4004743d
 	PPPIOCATTCHAN                    = 0x40047438
+	PPPIOCBRIDGECHAN                 = 0x40047435
 	PPPIOCCONNECT                    = 0x4004743a
 	PPPIOCDETACH                     = 0x4004743c
 	PPPIOCDISCONN                    = 0x7439
@@ -193,9 +194,13 @@ const (
 	PPPIOCSPASS                      = 0x40107447
 	PPPIOCSRASYNCMAP                 = 0x40047454
 	PPPIOCSXASYNCMAP                 = 0x4020744f
+	PPPIOCUNBRIDGECHAN               = 0x7434
 	PPPIOCXFERUNIT                   = 0x744e
 	PROT_BTI                         = 0x10
+	PROT_MTE                         = 0x20
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
+	PTRACE_PEEKMTETAGS               = 0x21
+	PTRACE_POKEMTETAGS               = 0x22
 	PTRACE_SYSEMU                    = 0x1f
 	PTRACE_SYSEMU_SINGLESTEP         = 0x20
 	RLIMIT_AS                        = 0x9
@@ -262,6 +267,7 @@ const (
 	SO_BROADCAST                     = 0x6
 	SO_BSDCOMPAT                     = 0xe
 	SO_BUSY_POLL                     = 0x2e
+	SO_BUSY_POLL_BUDGET              = 0x46
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
@@ -284,6 +290,7 @@ const (
 	SO_PEERCRED                      = 0x11
 	SO_PEERGROUPS                    = 0x3b
 	SO_PEERSEC                       = 0x1f
+	SO_PREFER_BUSY_POLL              = 0x45
 	SO_PROTOCOL                      = 0x26
 	SO_RCVBUF                        = 0x8
 	SO_RCVBUFFORCE                   = 0x21
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
index ce3d9ae156..1785f33d66 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
@@ -4,7 +4,7 @@
 // +build mips,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go
 
 package unix
 
@@ -163,6 +163,7 @@ const (
 	PERF_EVENT_IOC_SET_OUTPUT        = 0x20002405
 	PPPIOCATTACH                     = 0x8004743d
 	PPPIOCATTCHAN                    = 0x80047438
+	PPPIOCBRIDGECHAN                 = 0x80047435
 	PPPIOCCONNECT                    = 0x8004743a
 	PPPIOCDETACH                     = 0x8004743c
 	PPPIOCDISCONN                    = 0x20007439
@@ -190,6 +191,7 @@ const (
 	PPPIOCSPASS                      = 0x80087447
 	PPPIOCSRASYNCMAP                 = 0x80047454
 	PPPIOCSXASYNCMAP                 = 0x8020744f
+	PPPIOCUNBRIDGECHAN               = 0x20007434
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PR_SET_PTRACER_ANY               = 0xffffffff
 	PTRACE_GETFPREGS                 = 0xe
@@ -268,6 +270,7 @@ const (
 	SO_BROADCAST                     = 0x20
 	SO_BSDCOMPAT                     = 0xe
 	SO_BUSY_POLL                     = 0x2e
+	SO_BUSY_POLL_BUDGET              = 0x46
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
@@ -290,6 +293,7 @@ const (
 	SO_PEERCRED                      = 0x12
 	SO_PEERGROUPS                    = 0x3b
 	SO_PEERSEC                       = 0x1e
+	SO_PREFER_BUSY_POLL              = 0x45
 	SO_PROTOCOL                      = 0x1028
 	SO_RCVBUF                        = 0x1002
 	SO_RCVBUFFORCE                   = 0x21
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
index 7a85215ce5..acb1ef1bf5 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
@@ -4,7 +4,7 @@
 // +build mips64,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go
 
 package unix
 
@@ -163,6 +163,7 @@ const (
 	PERF_EVENT_IOC_SET_OUTPUT        = 0x20002405
 	PPPIOCATTACH                     = 0x8004743d
 	PPPIOCATTCHAN                    = 0x80047438
+	PPPIOCBRIDGECHAN                 = 0x80047435
 	PPPIOCCONNECT                    = 0x8004743a
 	PPPIOCDETACH                     = 0x8004743c
 	PPPIOCDISCONN                    = 0x20007439
@@ -190,6 +191,7 @@ const (
 	PPPIOCSPASS                      = 0x80107447
 	PPPIOCSRASYNCMAP                 = 0x80047454
 	PPPIOCSXASYNCMAP                 = 0x8020744f
+	PPPIOCUNBRIDGECHAN               = 0x20007434
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
 	PTRACE_GETFPREGS                 = 0xe
@@ -268,6 +270,7 @@ const (
 	SO_BROADCAST                     = 0x20
 	SO_BSDCOMPAT                     = 0xe
 	SO_BUSY_POLL                     = 0x2e
+	SO_BUSY_POLL_BUDGET              = 0x46
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
@@ -290,6 +293,7 @@ const (
 	SO_PEERCRED                      = 0x12
 	SO_PEERGROUPS                    = 0x3b
 	SO_PEERSEC                       = 0x1e
+	SO_PREFER_BUSY_POLL              = 0x45
 	SO_PROTOCOL                      = 0x1028
 	SO_RCVBUF                        = 0x1002
 	SO_RCVBUFFORCE                   = 0x21
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
index 07d4cc1bd5..468a4e68c7 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
@@ -4,7 +4,7 @@
 // +build mips64le,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go
 
 package unix
 
@@ -163,6 +163,7 @@ const (
 	PERF_EVENT_IOC_SET_OUTPUT        = 0x20002405
 	PPPIOCATTACH                     = 0x8004743d
 	PPPIOCATTCHAN                    = 0x80047438
+	PPPIOCBRIDGECHAN                 = 0x80047435
 	PPPIOCCONNECT                    = 0x8004743a
 	PPPIOCDETACH                     = 0x8004743c
 	PPPIOCDISCONN                    = 0x20007439
@@ -190,6 +191,7 @@ const (
 	PPPIOCSPASS                      = 0x80107447
 	PPPIOCSRASYNCMAP                 = 0x80047454
 	PPPIOCSXASYNCMAP                 = 0x8020744f
+	PPPIOCUNBRIDGECHAN               = 0x20007434
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
 	PTRACE_GETFPREGS                 = 0xe
@@ -268,6 +270,7 @@ const (
 	SO_BROADCAST                     = 0x20
 	SO_BSDCOMPAT                     = 0xe
 	SO_BUSY_POLL                     = 0x2e
+	SO_BUSY_POLL_BUDGET              = 0x46
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
@@ -290,6 +293,7 @@ const (
 	SO_PEERCRED                      = 0x12
 	SO_PEERGROUPS                    = 0x3b
 	SO_PEERSEC                       = 0x1e
+	SO_PREFER_BUSY_POLL              = 0x45
 	SO_PROTOCOL                      = 0x1028
 	SO_RCVBUF                        = 0x1002
 	SO_RCVBUFFORCE                   = 0x21
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
index d4842ba1c2..6c9c7f2c76 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
@@ -4,7 +4,7 @@
 // +build mipsle,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go
 
 package unix
 
@@ -163,6 +163,7 @@ const (
 	PERF_EVENT_IOC_SET_OUTPUT        = 0x20002405
 	PPPIOCATTACH                     = 0x8004743d
 	PPPIOCATTCHAN                    = 0x80047438
+	PPPIOCBRIDGECHAN                 = 0x80047435
 	PPPIOCCONNECT                    = 0x8004743a
 	PPPIOCDETACH                     = 0x8004743c
 	PPPIOCDISCONN                    = 0x20007439
@@ -190,6 +191,7 @@ const (
 	PPPIOCSPASS                      = 0x80087447
 	PPPIOCSRASYNCMAP                 = 0x80047454
 	PPPIOCSXASYNCMAP                 = 0x8020744f
+	PPPIOCUNBRIDGECHAN               = 0x20007434
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PR_SET_PTRACER_ANY               = 0xffffffff
 	PTRACE_GETFPREGS                 = 0xe
@@ -268,6 +270,7 @@ const (
 	SO_BROADCAST                     = 0x20
 	SO_BSDCOMPAT                     = 0xe
 	SO_BUSY_POLL                     = 0x2e
+	SO_BUSY_POLL_BUDGET              = 0x46
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
@@ -290,6 +293,7 @@ const (
 	SO_PEERCRED                      = 0x12
 	SO_PEERGROUPS                    = 0x3b
 	SO_PEERSEC                       = 0x1e
+	SO_PREFER_BUSY_POLL              = 0x45
 	SO_PROTOCOL                      = 0x1028
 	SO_RCVBUF                        = 0x1002
 	SO_RCVBUFFORCE                   = 0x21
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
index 941e20dace..8961206e5f 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
@@ -4,7 +4,7 @@
 // +build ppc64,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go
 
 package unix
 
@@ -165,6 +165,7 @@ const (
 	PERF_EVENT_IOC_SET_OUTPUT        = 0x20002405
 	PPPIOCATTACH                     = 0x8004743d
 	PPPIOCATTCHAN                    = 0x80047438
+	PPPIOCBRIDGECHAN                 = 0x80047435
 	PPPIOCCONNECT                    = 0x8004743a
 	PPPIOCDETACH                     = 0x8004743c
 	PPPIOCDISCONN                    = 0x20007439
@@ -192,6 +193,7 @@ const (
 	PPPIOCSPASS                      = 0x80107447
 	PPPIOCSRASYNCMAP                 = 0x80047454
 	PPPIOCSXASYNCMAP                 = 0x8020744f
+	PPPIOCUNBRIDGECHAN               = 0x20007434
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PROT_SAO                         = 0x10
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
@@ -327,6 +329,7 @@ const (
 	SO_BROADCAST                     = 0x6
 	SO_BSDCOMPAT                     = 0xe
 	SO_BUSY_POLL                     = 0x2e
+	SO_BUSY_POLL_BUDGET              = 0x46
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
@@ -349,6 +352,7 @@ const (
 	SO_PEERCRED                      = 0x15
 	SO_PEERGROUPS                    = 0x3b
 	SO_PEERSEC                       = 0x1f
+	SO_PREFER_BUSY_POLL              = 0x45
 	SO_PROTOCOL                      = 0x26
 	SO_RCVBUF                        = 0x8
 	SO_RCVBUFFORCE                   = 0x21
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
index 63d3bc5662..6bcf79dc2e 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
@@ -4,7 +4,7 @@
 // +build ppc64le,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go
 
 package unix
 
@@ -165,6 +165,7 @@ const (
 	PERF_EVENT_IOC_SET_OUTPUT        = 0x20002405
 	PPPIOCATTACH                     = 0x8004743d
 	PPPIOCATTCHAN                    = 0x80047438
+	PPPIOCBRIDGECHAN                 = 0x80047435
 	PPPIOCCONNECT                    = 0x8004743a
 	PPPIOCDETACH                     = 0x8004743c
 	PPPIOCDISCONN                    = 0x20007439
@@ -192,6 +193,7 @@ const (
 	PPPIOCSPASS                      = 0x80107447
 	PPPIOCSRASYNCMAP                 = 0x80047454
 	PPPIOCSXASYNCMAP                 = 0x8020744f
+	PPPIOCUNBRIDGECHAN               = 0x20007434
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PROT_SAO                         = 0x10
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
@@ -327,6 +329,7 @@ const (
 	SO_BROADCAST                     = 0x6
 	SO_BSDCOMPAT                     = 0xe
 	SO_BUSY_POLL                     = 0x2e
+	SO_BUSY_POLL_BUDGET              = 0x46
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
@@ -349,6 +352,7 @@ const (
 	SO_PEERCRED                      = 0x15
 	SO_PEERGROUPS                    = 0x3b
 	SO_PEERSEC                       = 0x1f
+	SO_PREFER_BUSY_POLL              = 0x45
 	SO_PROTOCOL                      = 0x26
 	SO_RCVBUF                        = 0x8
 	SO_RCVBUFFORCE                   = 0x21
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
index 490bee1ab1..e861d97f1c 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
@@ -4,7 +4,7 @@
 // +build riscv64,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go
 
 package unix
 
@@ -163,6 +163,7 @@ const (
 	PERF_EVENT_IOC_SET_OUTPUT        = 0x2405
 	PPPIOCATTACH                     = 0x4004743d
 	PPPIOCATTCHAN                    = 0x40047438
+	PPPIOCBRIDGECHAN                 = 0x40047435
 	PPPIOCCONNECT                    = 0x4004743a
 	PPPIOCDETACH                     = 0x4004743c
 	PPPIOCDISCONN                    = 0x7439
@@ -190,6 +191,7 @@ const (
 	PPPIOCSPASS                      = 0x40107447
 	PPPIOCSRASYNCMAP                 = 0x40047454
 	PPPIOCSXASYNCMAP                 = 0x4020744f
+	PPPIOCUNBRIDGECHAN               = 0x7434
 	PPPIOCXFERUNIT                   = 0x744e
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
 	RLIMIT_AS                        = 0x9
@@ -256,6 +258,7 @@ const (
 	SO_BROADCAST                     = 0x6
 	SO_BSDCOMPAT                     = 0xe
 	SO_BUSY_POLL                     = 0x2e
+	SO_BUSY_POLL_BUDGET              = 0x46
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
@@ -278,6 +281,7 @@ const (
 	SO_PEERCRED                      = 0x11
 	SO_PEERGROUPS                    = 0x3b
 	SO_PEERSEC                       = 0x1f
+	SO_PREFER_BUSY_POLL              = 0x45
 	SO_PROTOCOL                      = 0x26
 	SO_RCVBUF                        = 0x8
 	SO_RCVBUFFORCE                   = 0x21
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
index 467b8218e8..d39278bee5 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
@@ -4,7 +4,7 @@
 // +build s390x,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include -fsigned-char _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include -fsigned-char /build/_const.go
 
 package unix
 
@@ -163,6 +163,7 @@ const (
 	PERF_EVENT_IOC_SET_OUTPUT        = 0x2405
 	PPPIOCATTACH                     = 0x4004743d
 	PPPIOCATTCHAN                    = 0x40047438
+	PPPIOCBRIDGECHAN                 = 0x40047435
 	PPPIOCCONNECT                    = 0x4004743a
 	PPPIOCDETACH                     = 0x4004743c
 	PPPIOCDISCONN                    = 0x7439
@@ -190,6 +191,7 @@ const (
 	PPPIOCSPASS                      = 0x40107447
 	PPPIOCSRASYNCMAP                 = 0x40047454
 	PPPIOCSXASYNCMAP                 = 0x4020744f
+	PPPIOCUNBRIDGECHAN               = 0x7434
 	PPPIOCXFERUNIT                   = 0x744e
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
 	PTRACE_DISABLE_TE                = 0x5010
@@ -329,6 +331,7 @@ const (
 	SO_BROADCAST                     = 0x6
 	SO_BSDCOMPAT                     = 0xe
 	SO_BUSY_POLL                     = 0x2e
+	SO_BUSY_POLL_BUDGET              = 0x46
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
@@ -351,6 +354,7 @@ const (
 	SO_PEERCRED                      = 0x11
 	SO_PEERGROUPS                    = 0x3b
 	SO_PEERSEC                       = 0x1f
+	SO_PREFER_BUSY_POLL              = 0x45
 	SO_PROTOCOL                      = 0x26
 	SO_RCVBUF                        = 0x8
 	SO_RCVBUFFORCE                   = 0x21
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
index 79fbafbcf6..6a742fa7ee 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
@@ -4,7 +4,7 @@
 // +build sparc64,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include _const.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go
 
 package unix
 
@@ -168,6 +168,7 @@ const (
 	PERF_EVENT_IOC_SET_OUTPUT        = 0x20002405
 	PPPIOCATTACH                     = 0x8004743d
 	PPPIOCATTCHAN                    = 0x80047438
+	PPPIOCBRIDGECHAN                 = 0x80047435
 	PPPIOCCONNECT                    = 0x8004743a
 	PPPIOCDETACH                     = 0x8004743c
 	PPPIOCDISCONN                    = 0x20007439
@@ -195,6 +196,7 @@ const (
 	PPPIOCSPASS                      = 0x80107447
 	PPPIOCSRASYNCMAP                 = 0x80047454
 	PPPIOCSXASYNCMAP                 = 0x8020744f
+	PPPIOCUNBRIDGECHAN               = 0x20007434
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
 	PTRACE_GETFPAREGS                = 0x14
@@ -322,6 +324,7 @@ const (
 	SO_BROADCAST                     = 0x20
 	SO_BSDCOMPAT                     = 0x400
 	SO_BUSY_POLL                     = 0x30
+	SO_BUSY_POLL_BUDGET              = 0x49
 	SO_CNX_ADVICE                    = 0x37
 	SO_COOKIE                        = 0x3b
 	SO_DETACH_REUSEPORT_BPF          = 0x47
@@ -344,6 +347,7 @@ const (
 	SO_PEERCRED                      = 0x40
 	SO_PEERGROUPS                    = 0x3d
 	SO_PEERSEC                       = 0x1e
+	SO_PREFER_BUSY_POLL              = 0x48
 	SO_PROTOCOL                      = 0x1028
 	SO_RCVBUF                        = 0x1002
 	SO_RCVBUFFORCE                   = 0x100b
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.go
index 7f0f117d32..3877183483 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.go
@@ -462,10 +462,8 @@ func libc_munlockall_trampoline()
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func pipe() (r int, w int, err error) {
-	r0, r1, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), 0, 0, 0)
-	r = int(r0)
-	w = int(r1)
+func pipe(p *[2]int32) (err error) {
+	_, _, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), uintptr(unsafe.Pointer(p)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -2381,7 +2379,7 @@ func libc_lstat64_trampoline()
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
+func ptrace1(request int, pid int, addr uintptr, data uintptr) (err error) {
 	_, _, e1 := syscall_syscall6(funcPC(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
index 2daf0bd628..508e5639bf 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
@@ -462,10 +462,8 @@ func libc_munlockall_trampoline()
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func pipe() (r int, w int, err error) {
-	r0, r1, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), 0, 0, 0)
-	r = int(r0)
-	w = int(r1)
+func pipe(p *[2]int32) (err error) {
+	_, _, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), uintptr(unsafe.Pointer(p)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -2381,7 +2379,7 @@ func libc_lstat64_trampoline()
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
+func ptrace1(request int, pid int, addr uintptr, data uintptr) (err error) {
 	_, _, e1 := syscall_syscall6(funcPC(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.go
index 8e79ad377b..c0c771f402 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.go
@@ -462,10 +462,8 @@ func libc_munlockall_trampoline()
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func pipe() (r int, w int, err error) {
-	r0, r1, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), 0, 0, 0)
-	r = int(r0)
-	w = int(r1)
+func pipe(p *[2]int32) (err error) {
+	_, _, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), uintptr(unsafe.Pointer(p)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
index 23be592a9f..9b01a79c41 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
@@ -462,10 +462,8 @@ func libc_munlockall_trampoline()
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func pipe() (r int, w int, err error) {
-	r0, r1, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), 0, 0, 0)
-	r = int(r0)
-	w = int(r1)
+func pipe(p *[2]int32) (err error) {
+	_, _, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), uintptr(unsafe.Pointer(p)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -2381,7 +2379,7 @@ func libc_lstat_trampoline()
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
+func ptrace1(request int, pid int, addr uintptr, data uintptr) (err error) {
 	_, _, e1 := syscall_syscall6(funcPC(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_dragonfly_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_dragonfly_amd64.go
index 1aaccd3615..104f77d5b8 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_dragonfly_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_dragonfly_amd64.go
@@ -362,8 +362,10 @@ func pipe() (r int, w int, err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func pipe2(p *[2]_C_int, flags int) (err error) {
-	_, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
+func pipe2(flags int) (r int, w int, err error) {
+	r0, r1, e1 := RawSyscall(SYS_PIPE2, uintptr(flags), 0, 0)
+	r = int(r0)
+	w = int(r1)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_illumos_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_illumos_amd64.go
index d3af083f4e..665dd9e4b4 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_illumos_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_illumos_amd64.go
@@ -14,22 +14,19 @@ import (
 //go:cgo_import_dynamic libc_writev writev "libc.so"
 //go:cgo_import_dynamic libc_pwritev pwritev "libc.so"
 //go:cgo_import_dynamic libc_accept4 accept4 "libsocket.so"
-//go:cgo_import_dynamic libc_pipe2 pipe2 "libc.so"
 
 //go:linkname procreadv libc_readv
 //go:linkname procpreadv libc_preadv
 //go:linkname procwritev libc_writev
 //go:linkname procpwritev libc_pwritev
 //go:linkname procaccept4 libc_accept4
-//go:linkname procpipe2 libc_pipe2
 
 var (
 	procreadv,
 	procpreadv,
 	procwritev,
 	procpwritev,
-	procaccept4,
-	procpipe2 syscallFunc
+	procaccept4 syscallFunc
 )
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -102,13 +99,3 @@ func accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int,
 	}
 	return
 }
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func pipe2(p *[2]_C_int, flags int) (err error) {
-	_, _, e1 := rawSysvicall6(uintptr(unsafe.Pointer(&procpipe2)), 2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0, 0, 0, 0)
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_386.go
index 3bbd9e39cd..1d6f71d99a 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_386.go
@@ -362,6 +362,16 @@ func pipe() (fd1 int, fd2 int, err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func pipe2(p *[2]_C_int, flags int) (err error) {
+	_, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Getdents(fd int, buf []byte) (n int, err error) {
 	var _p0 unsafe.Pointer
 	if len(buf) > 0 {
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_amd64.go
index d8cf5012c2..82f50506ad 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_amd64.go
@@ -362,6 +362,16 @@ func pipe() (fd1 int, fd2 int, err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func pipe2(p *[2]_C_int, flags int) (err error) {
+	_, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Getdents(fd int, buf []byte) (n int, err error) {
 	var _p0 unsafe.Pointer
 	if len(buf) > 0 {
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm.go
index 1153fe69b8..b4db55a0c8 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm.go
@@ -362,6 +362,16 @@ func pipe() (fd1 int, fd2 int, err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func pipe2(p *[2]_C_int, flags int) (err error) {
+	_, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Getdents(fd int, buf []byte) (n int, err error) {
 	var _p0 unsafe.Pointer
 	if len(buf) > 0 {
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm64.go
index 24b4ebb41f..e9f6d7975a 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm64.go
@@ -362,6 +362,16 @@ func pipe() (fd1 int, fd2 int, err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func pipe2(p *[2]_C_int, flags int) (err error) {
+	_, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Getdents(fd int, buf []byte) (n int, err error) {
 	var _p0 unsafe.Pointer
 	if len(buf) > 0 {
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go
index a96165d4bf..9898ce1f47 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go
@@ -11,6 +11,7 @@ import (
 )
 
 //go:cgo_import_dynamic libc_pipe pipe "libc.so"
+//go:cgo_import_dynamic libc_pipe2 pipe2 "libc.so"
 //go:cgo_import_dynamic libc_getsockname getsockname "libsocket.so"
 //go:cgo_import_dynamic libc_getcwd getcwd "libc.so"
 //go:cgo_import_dynamic libc_getgroups getgroups "libc.so"
@@ -114,6 +115,7 @@ import (
 //go:cgo_import_dynamic libc_statvfs statvfs "libc.so"
 //go:cgo_import_dynamic libc_symlink symlink "libc.so"
 //go:cgo_import_dynamic libc_sync sync "libc.so"
+//go:cgo_import_dynamic libc_sysconf sysconf "libc.so"
 //go:cgo_import_dynamic libc_times times "libc.so"
 //go:cgo_import_dynamic libc_truncate truncate "libc.so"
 //go:cgo_import_dynamic libc_fsync fsync "libc.so"
@@ -140,6 +142,7 @@ import (
 //go:cgo_import_dynamic libc_recvfrom recvfrom "libsocket.so"
 
 //go:linkname procpipe libc_pipe
+//go:linkname procpipe2 libc_pipe2
 //go:linkname procgetsockname libc_getsockname
 //go:linkname procGetcwd libc_getcwd
 //go:linkname procgetgroups libc_getgroups
@@ -243,6 +246,7 @@ import (
 //go:linkname procStatvfs libc_statvfs
 //go:linkname procSymlink libc_symlink
 //go:linkname procSync libc_sync
+//go:linkname procSysconf libc_sysconf
 //go:linkname procTimes libc_times
 //go:linkname procTruncate libc_truncate
 //go:linkname procFsync libc_fsync
@@ -270,6 +274,7 @@ import (
 
 var (
 	procpipe,
+	procpipe2,
 	procgetsockname,
 	procGetcwd,
 	procgetgroups,
@@ -373,6 +378,7 @@ var (
 	procStatvfs,
 	procSymlink,
 	procSync,
+	procSysconf,
 	procTimes,
 	procTruncate,
 	procFsync,
@@ -412,6 +418,16 @@ func pipe(p *[2]_C_int) (n int, err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func pipe2(p *[2]_C_int, flags int) (err error) {
+	_, _, e1 := rawSysvicall6(uintptr(unsafe.Pointer(&procpipe2)), 2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0, 0, 0, 0)
+	if e1 != 0 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
 	_, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procgetsockname)), 3, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), 0, 0, 0)
 	if e1 != 0 {
@@ -1674,6 +1690,17 @@ func Sync() (err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func Sysconf(which int) (n int64, err error) {
+	r0, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procSysconf)), 1, uintptr(which), 0, 0, 0, 0, 0)
+	n = int64(r0)
+	if e1 != 0 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Times(tms *Tms) (ticks uintptr, err error) {
 	r0, _, e1 := rawSysvicall6(uintptr(unsafe.Pointer(&procTimes)), 1, uintptr(unsafe.Pointer(tms)), 0, 0, 0, 0, 0)
 	ticks = uintptr(r0)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
index 0f5a3f6970..c80f3c7bdd 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
@@ -435,4 +435,6 @@ const (
 	SYS_OPENAT2                      = 437
 	SYS_PIDFD_GETFD                  = 438
 	SYS_FACCESSAT2                   = 439
+	SYS_PROCESS_MADVISE              = 440
+	SYS_EPOLL_PWAIT2                 = 441
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
index 36d5219ef8..2369995cec 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
@@ -357,4 +357,6 @@ const (
 	SYS_OPENAT2                = 437
 	SYS_PIDFD_GETFD            = 438
 	SYS_FACCESSAT2             = 439
+	SYS_PROCESS_MADVISE        = 440
+	SYS_EPOLL_PWAIT2           = 441
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
index 3622ba14b4..971c5af6d4 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
@@ -399,4 +399,6 @@ const (
 	SYS_OPENAT2                      = 437
 	SYS_PIDFD_GETFD                  = 438
 	SYS_FACCESSAT2                   = 439
+	SYS_PROCESS_MADVISE              = 440
+	SYS_EPOLL_PWAIT2                 = 441
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
index 6193c3dc07..a5e410b24f 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
@@ -302,4 +302,6 @@ const (
 	SYS_OPENAT2                = 437
 	SYS_PIDFD_GETFD            = 438
 	SYS_FACCESSAT2             = 439
+	SYS_PROCESS_MADVISE        = 440
+	SYS_EPOLL_PWAIT2           = 441
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
index 640b974345..438a6ea4e6 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
@@ -420,4 +420,6 @@ const (
 	SYS_OPENAT2                      = 4437
 	SYS_PIDFD_GETFD                  = 4438
 	SYS_FACCESSAT2                   = 4439
+	SYS_PROCESS_MADVISE              = 4440
+	SYS_EPOLL_PWAIT2                 = 4441
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
index 3467fbb5ff..622472da22 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
@@ -350,4 +350,6 @@ const (
 	SYS_OPENAT2                = 5437
 	SYS_PIDFD_GETFD            = 5438
 	SYS_FACCESSAT2             = 5439
+	SYS_PROCESS_MADVISE        = 5440
+	SYS_EPOLL_PWAIT2           = 5441
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
index 0fc38d5a72..e029b989b8 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
@@ -350,4 +350,6 @@ const (
 	SYS_OPENAT2                = 5437
 	SYS_PIDFD_GETFD            = 5438
 	SYS_FACCESSAT2             = 5439
+	SYS_PROCESS_MADVISE        = 5440
+	SYS_EPOLL_PWAIT2           = 5441
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
index 999fd55bcc..86a497b58d 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
@@ -420,4 +420,6 @@ const (
 	SYS_OPENAT2                      = 4437
 	SYS_PIDFD_GETFD                  = 4438
 	SYS_FACCESSAT2                   = 4439
+	SYS_PROCESS_MADVISE              = 4440
+	SYS_EPOLL_PWAIT2                 = 4441
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
index 1df0d79935..b6b0b5e602 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
@@ -399,4 +399,6 @@ const (
 	SYS_OPENAT2                = 437
 	SYS_PIDFD_GETFD            = 438
 	SYS_FACCESSAT2             = 439
+	SYS_PROCESS_MADVISE        = 440
+	SYS_EPOLL_PWAIT2           = 441
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
index 4db39cca4d..b344db0146 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
@@ -399,4 +399,6 @@ const (
 	SYS_OPENAT2                = 437
 	SYS_PIDFD_GETFD            = 438
 	SYS_FACCESSAT2             = 439
+	SYS_PROCESS_MADVISE        = 440
+	SYS_EPOLL_PWAIT2           = 441
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
index e692740144..9b8fa53dcc 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
@@ -301,4 +301,6 @@ const (
 	SYS_OPENAT2                = 437
 	SYS_PIDFD_GETFD            = 438
 	SYS_FACCESSAT2             = 439
+	SYS_PROCESS_MADVISE        = 440
+	SYS_EPOLL_PWAIT2           = 441
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
index a585aec4e7..8261f72c0b 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
@@ -364,4 +364,6 @@ const (
 	SYS_OPENAT2                = 437
 	SYS_PIDFD_GETFD            = 438
 	SYS_FACCESSAT2             = 439
+	SYS_PROCESS_MADVISE        = 440
+	SYS_EPOLL_PWAIT2           = 441
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
index d047e567af..f4bbeb3db5 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
@@ -378,4 +378,6 @@ const (
 	SYS_OPENAT2                = 437
 	SYS_PIDFD_GETFD            = 438
 	SYS_FACCESSAT2             = 439
+	SYS_PROCESS_MADVISE        = 440
+	SYS_EPOLL_PWAIT2           = 441
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc.go
index 2c1f815e6f..295859c503 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc.go
@@ -219,6 +219,7 @@ const (
 	SizeofSockaddrUnix     = 0x401
 	SizeofSockaddrDatalink = 0x80
 	SizeofLinger           = 0x8
+	SizeofIovec            = 0x8
 	SizeofIPMreq           = 0x8
 	SizeofIPv6Mreq         = 0x14
 	SizeofIPv6MTUInfo      = 0x20
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc64.go
index b4a069ecbd..a9ee0ffd44 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc64.go
@@ -223,6 +223,7 @@ const (
 	SizeofSockaddrUnix     = 0x401
 	SizeofSockaddrDatalink = 0x80
 	SizeofLinger           = 0x8
+	SizeofIovec            = 0x10
 	SizeofIPMreq           = 0x8
 	SizeofIPv6Mreq         = 0x14
 	SizeofIPv6MTUInfo      = 0x20
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go
index 080ffce325..bb39542f7a 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go
@@ -210,6 +210,13 @@ type RawSockaddrCtl struct {
 
 type _Socklen uint32
 
+type Xucred struct {
+	Version uint32
+	Uid     uint32
+	Ngroups int16
+	Groups  [16]uint32
+}
+
 type Linger struct {
 	Onoff  int32
 	Linger int32
@@ -273,6 +280,7 @@ const (
 	SizeofSockaddrUnix     = 0x6a
 	SizeofSockaddrDatalink = 0x14
 	SizeofSockaddrCtl      = 0x20
+	SizeofXucred           = 0x4c
 	SizeofLinger           = 0x8
 	SizeofIovec            = 0x10
 	SizeofIPMreq           = 0x8
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go
index c9492428bf..ec5b559272 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go
@@ -210,6 +210,13 @@ type RawSockaddrCtl struct {
 
 type _Socklen uint32
 
+type Xucred struct {
+	Version uint32
+	Uid     uint32
+	Ngroups int16
+	Groups  [16]uint32
+}
+
 type Linger struct {
 	Onoff  int32
 	Linger int32
@@ -273,6 +280,7 @@ const (
 	SizeofSockaddrUnix     = 0x6a
 	SizeofSockaddrDatalink = 0x14
 	SizeofSockaddrCtl      = 0x20
+	SizeofXucred           = 0x4c
 	SizeofLinger           = 0x8
 	SizeofIovec            = 0x10
 	SizeofIPMreq           = 0x8
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_dragonfly_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_dragonfly_amd64.go
index c4772df23b..85506a05d4 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_dragonfly_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_dragonfly_amd64.go
@@ -234,6 +234,7 @@ const (
 	SizeofSockaddrUnix     = 0x6a
 	SizeofSockaddrDatalink = 0x36
 	SizeofLinger           = 0x8
+	SizeofIovec            = 0x10
 	SizeofIPMreq           = 0x8
 	SizeofIPv6Mreq         = 0x14
 	SizeofMsghdr           = 0x30
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go
index 2a3ec615f7..3e9dad33e3 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go
@@ -313,6 +313,7 @@ const (
 	SizeofSockaddrUnix     = 0x6a
 	SizeofSockaddrDatalink = 0x36
 	SizeofLinger           = 0x8
+	SizeofIovec            = 0x8
 	SizeofIPMreq           = 0x8
 	SizeofIPMreqn          = 0xc
 	SizeofIPv6Mreq         = 0x14
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go
index e11e95499e..e00e615544 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go
@@ -309,6 +309,7 @@ const (
 	SizeofSockaddrUnix     = 0x6a
 	SizeofSockaddrDatalink = 0x36
 	SizeofLinger           = 0x8
+	SizeofIovec            = 0x10
 	SizeofIPMreq           = 0x8
 	SizeofIPMreqn          = 0xc
 	SizeofIPv6Mreq         = 0x14
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go
index b91c2ae0f0..5da13c871b 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go
@@ -311,6 +311,7 @@ const (
 	SizeofSockaddrUnix     = 0x6a
 	SizeofSockaddrDatalink = 0x36
 	SizeofLinger           = 0x8
+	SizeofIovec            = 0x8
 	SizeofIPMreq           = 0x8
 	SizeofIPMreqn          = 0xc
 	SizeofIPv6Mreq         = 0x14
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go
index c6fe1d097d..995ecf9d4e 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go
@@ -309,6 +309,7 @@ const (
 	SizeofSockaddrUnix     = 0x6a
 	SizeofSockaddrDatalink = 0x36
 	SizeofLinger           = 0x8
+	SizeofIovec            = 0x10
 	SizeofIPMreq           = 0x8
 	SizeofIPMreqn          = 0xc
 	SizeofIPv6Mreq         = 0x14
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go
index 504ef131fb..ddd655769d 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go
@@ -288,7 +288,8 @@ type RawSockaddrVM struct {
 	Reserved1 uint16
 	Port      uint32
 	Cid       uint32
-	Zero      [4]uint8
+	Flags     uint8
+	Zero      [3]uint8
 }
 
 type RawSockaddrXDP struct {
@@ -999,7 +1000,7 @@ const (
 	PERF_SAMPLE_PHYS_ADDR                 = 0x80000
 	PERF_SAMPLE_AUX                       = 0x100000
 	PERF_SAMPLE_CGROUP                    = 0x200000
-	PERF_SAMPLE_MAX                       = 0x400000
+	PERF_SAMPLE_MAX                       = 0x1000000
 	PERF_SAMPLE_BRANCH_USER_SHIFT         = 0x0
 	PERF_SAMPLE_BRANCH_KERNEL_SHIFT       = 0x1
 	PERF_SAMPLE_BRANCH_HV_SHIFT           = 0x2
@@ -1381,6 +1382,11 @@ const (
 	IFLA_PROP_LIST                             = 0x34
 	IFLA_ALT_IFNAME                            = 0x35
 	IFLA_PERM_ADDRESS                          = 0x36
+	IFLA_PROTO_DOWN_REASON                     = 0x37
+	IFLA_PROTO_DOWN_REASON_UNSPEC              = 0x0
+	IFLA_PROTO_DOWN_REASON_MASK                = 0x1
+	IFLA_PROTO_DOWN_REASON_VALUE               = 0x2
+	IFLA_PROTO_DOWN_REASON_MAX                 = 0x2
 	IFLA_INET_UNSPEC                           = 0x0
 	IFLA_INET_CONF                             = 0x1
 	IFLA_INET6_UNSPEC                          = 0x0
@@ -1475,6 +1481,7 @@ const (
 	IFLA_BRPORT_ISOLATED                       = 0x21
 	IFLA_BRPORT_BACKUP_PORT                    = 0x22
 	IFLA_BRPORT_MRP_RING_OPEN                  = 0x23
+	IFLA_BRPORT_MRP_IN_OPEN                    = 0x24
 	IFLA_INFO_UNSPEC                           = 0x0
 	IFLA_INFO_KIND                             = 0x1
 	IFLA_INFO_DATA                             = 0x2
@@ -1673,6 +1680,7 @@ const (
 	IFLA_HSR_SUPERVISION_ADDR                  = 0x4
 	IFLA_HSR_SEQ_NR                            = 0x5
 	IFLA_HSR_VERSION                           = 0x6
+	IFLA_HSR_PROTOCOL                          = 0x7
 	IFLA_STATS_UNSPEC                          = 0x0
 	IFLA_STATS_LINK_64                         = 0x1
 	IFLA_STATS_LINK_XSTATS                     = 0x2
@@ -2217,10 +2225,12 @@ const (
 )
 
 const (
-	NETNSA_NONE = 0x0
-	NETNSA_NSID = 0x1
-	NETNSA_PID  = 0x2
-	NETNSA_FD   = 0x3
+	NETNSA_NONE         = 0x0
+	NETNSA_NSID         = 0x1
+	NETNSA_PID          = 0x2
+	NETNSA_FD           = 0x3
+	NETNSA_TARGET_NSID  = 0x4
+	NETNSA_CURRENT_NSID = 0x5
 )
 
 type XDPRingOffset struct {
@@ -2370,281 +2380,309 @@ const (
 )
 
 const (
-	BPF_REG_0                               = 0x0
-	BPF_REG_1                               = 0x1
-	BPF_REG_2                               = 0x2
-	BPF_REG_3                               = 0x3
-	BPF_REG_4                               = 0x4
-	BPF_REG_5                               = 0x5
-	BPF_REG_6                               = 0x6
-	BPF_REG_7                               = 0x7
-	BPF_REG_8                               = 0x8
-	BPF_REG_9                               = 0x9
-	BPF_REG_10                              = 0xa
-	BPF_MAP_CREATE                          = 0x0
-	BPF_MAP_LOOKUP_ELEM                     = 0x1
-	BPF_MAP_UPDATE_ELEM                     = 0x2
-	BPF_MAP_DELETE_ELEM                     = 0x3
-	BPF_MAP_GET_NEXT_KEY                    = 0x4
-	BPF_PROG_LOAD                           = 0x5
-	BPF_OBJ_PIN                             = 0x6
-	BPF_OBJ_GET                             = 0x7
-	BPF_PROG_ATTACH                         = 0x8
-	BPF_PROG_DETACH                         = 0x9
-	BPF_PROG_TEST_RUN                       = 0xa
-	BPF_PROG_GET_NEXT_ID                    = 0xb
-	BPF_MAP_GET_NEXT_ID                     = 0xc
-	BPF_PROG_GET_FD_BY_ID                   = 0xd
-	BPF_MAP_GET_FD_BY_ID                    = 0xe
-	BPF_OBJ_GET_INFO_BY_FD                  = 0xf
-	BPF_PROG_QUERY                          = 0x10
-	BPF_RAW_TRACEPOINT_OPEN                 = 0x11
-	BPF_BTF_LOAD                            = 0x12
-	BPF_BTF_GET_FD_BY_ID                    = 0x13
-	BPF_TASK_FD_QUERY                       = 0x14
-	BPF_MAP_LOOKUP_AND_DELETE_ELEM          = 0x15
-	BPF_MAP_FREEZE                          = 0x16
-	BPF_BTF_GET_NEXT_ID                     = 0x17
-	BPF_MAP_LOOKUP_BATCH                    = 0x18
-	BPF_MAP_LOOKUP_AND_DELETE_BATCH         = 0x19
-	BPF_MAP_UPDATE_BATCH                    = 0x1a
-	BPF_MAP_DELETE_BATCH                    = 0x1b
-	BPF_LINK_CREATE                         = 0x1c
-	BPF_LINK_UPDATE                         = 0x1d
-	BPF_LINK_GET_FD_BY_ID                   = 0x1e
-	BPF_LINK_GET_NEXT_ID                    = 0x1f
-	BPF_ENABLE_STATS                        = 0x20
-	BPF_ITER_CREATE                         = 0x21
-	BPF_MAP_TYPE_UNSPEC                     = 0x0
-	BPF_MAP_TYPE_HASH                       = 0x1
-	BPF_MAP_TYPE_ARRAY                      = 0x2
-	BPF_MAP_TYPE_PROG_ARRAY                 = 0x3
-	BPF_MAP_TYPE_PERF_EVENT_ARRAY           = 0x4
-	BPF_MAP_TYPE_PERCPU_HASH                = 0x5
-	BPF_MAP_TYPE_PERCPU_ARRAY               = 0x6
-	BPF_MAP_TYPE_STACK_TRACE                = 0x7
-	BPF_MAP_TYPE_CGROUP_ARRAY               = 0x8
-	BPF_MAP_TYPE_LRU_HASH                   = 0x9
-	BPF_MAP_TYPE_LRU_PERCPU_HASH            = 0xa
-	BPF_MAP_TYPE_LPM_TRIE                   = 0xb
-	BPF_MAP_TYPE_ARRAY_OF_MAPS              = 0xc
-	BPF_MAP_TYPE_HASH_OF_MAPS               = 0xd
-	BPF_MAP_TYPE_DEVMAP                     = 0xe
-	BPF_MAP_TYPE_SOCKMAP                    = 0xf
-	BPF_MAP_TYPE_CPUMAP                     = 0x10
-	BPF_MAP_TYPE_XSKMAP                     = 0x11
-	BPF_MAP_TYPE_SOCKHASH                   = 0x12
-	BPF_MAP_TYPE_CGROUP_STORAGE             = 0x13
-	BPF_MAP_TYPE_REUSEPORT_SOCKARRAY        = 0x14
-	BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE      = 0x15
-	BPF_MAP_TYPE_QUEUE                      = 0x16
-	BPF_MAP_TYPE_STACK                      = 0x17
-	BPF_MAP_TYPE_SK_STORAGE                 = 0x18
-	BPF_MAP_TYPE_DEVMAP_HASH                = 0x19
-	BPF_MAP_TYPE_STRUCT_OPS                 = 0x1a
-	BPF_MAP_TYPE_RINGBUF                    = 0x1b
-	BPF_PROG_TYPE_UNSPEC                    = 0x0
-	BPF_PROG_TYPE_SOCKET_FILTER             = 0x1
-	BPF_PROG_TYPE_KPROBE                    = 0x2
-	BPF_PROG_TYPE_SCHED_CLS                 = 0x3
-	BPF_PROG_TYPE_SCHED_ACT                 = 0x4
-	BPF_PROG_TYPE_TRACEPOINT                = 0x5
-	BPF_PROG_TYPE_XDP                       = 0x6
-	BPF_PROG_TYPE_PERF_EVENT                = 0x7
-	BPF_PROG_TYPE_CGROUP_SKB                = 0x8
-	BPF_PROG_TYPE_CGROUP_SOCK               = 0x9
-	BPF_PROG_TYPE_LWT_IN                    = 0xa
-	BPF_PROG_TYPE_LWT_OUT                   = 0xb
-	BPF_PROG_TYPE_LWT_XMIT                  = 0xc
-	BPF_PROG_TYPE_SOCK_OPS                  = 0xd
-	BPF_PROG_TYPE_SK_SKB                    = 0xe
-	BPF_PROG_TYPE_CGROUP_DEVICE             = 0xf
-	BPF_PROG_TYPE_SK_MSG                    = 0x10
-	BPF_PROG_TYPE_RAW_TRACEPOINT            = 0x11
-	BPF_PROG_TYPE_CGROUP_SOCK_ADDR          = 0x12
-	BPF_PROG_TYPE_LWT_SEG6LOCAL             = 0x13
-	BPF_PROG_TYPE_LIRC_MODE2                = 0x14
-	BPF_PROG_TYPE_SK_REUSEPORT              = 0x15
-	BPF_PROG_TYPE_FLOW_DISSECTOR            = 0x16
-	BPF_PROG_TYPE_CGROUP_SYSCTL             = 0x17
-	BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE   = 0x18
-	BPF_PROG_TYPE_CGROUP_SOCKOPT            = 0x19
-	BPF_PROG_TYPE_TRACING                   = 0x1a
-	BPF_PROG_TYPE_STRUCT_OPS                = 0x1b
-	BPF_PROG_TYPE_EXT                       = 0x1c
-	BPF_PROG_TYPE_LSM                       = 0x1d
-	BPF_CGROUP_INET_INGRESS                 = 0x0
-	BPF_CGROUP_INET_EGRESS                  = 0x1
-	BPF_CGROUP_INET_SOCK_CREATE             = 0x2
-	BPF_CGROUP_SOCK_OPS                     = 0x3
-	BPF_SK_SKB_STREAM_PARSER                = 0x4
-	BPF_SK_SKB_STREAM_VERDICT               = 0x5
-	BPF_CGROUP_DEVICE                       = 0x6
-	BPF_SK_MSG_VERDICT                      = 0x7
-	BPF_CGROUP_INET4_BIND                   = 0x8
-	BPF_CGROUP_INET6_BIND                   = 0x9
-	BPF_CGROUP_INET4_CONNECT                = 0xa
-	BPF_CGROUP_INET6_CONNECT                = 0xb
-	BPF_CGROUP_INET4_POST_BIND              = 0xc
-	BPF_CGROUP_INET6_POST_BIND              = 0xd
-	BPF_CGROUP_UDP4_SENDMSG                 = 0xe
-	BPF_CGROUP_UDP6_SENDMSG                 = 0xf
-	BPF_LIRC_MODE2                          = 0x10
-	BPF_FLOW_DISSECTOR                      = 0x11
-	BPF_CGROUP_SYSCTL                       = 0x12
-	BPF_CGROUP_UDP4_RECVMSG                 = 0x13
-	BPF_CGROUP_UDP6_RECVMSG                 = 0x14
-	BPF_CGROUP_GETSOCKOPT                   = 0x15
-	BPF_CGROUP_SETSOCKOPT                   = 0x16
-	BPF_TRACE_RAW_TP                        = 0x17
-	BPF_TRACE_FENTRY                        = 0x18
-	BPF_TRACE_FEXIT                         = 0x19
-	BPF_MODIFY_RETURN                       = 0x1a
-	BPF_LSM_MAC                             = 0x1b
-	BPF_TRACE_ITER                          = 0x1c
-	BPF_CGROUP_INET4_GETPEERNAME            = 0x1d
-	BPF_CGROUP_INET6_GETPEERNAME            = 0x1e
-	BPF_CGROUP_INET4_GETSOCKNAME            = 0x1f
-	BPF_CGROUP_INET6_GETSOCKNAME            = 0x20
-	BPF_XDP_DEVMAP                          = 0x21
-	BPF_LINK_TYPE_UNSPEC                    = 0x0
-	BPF_LINK_TYPE_RAW_TRACEPOINT            = 0x1
-	BPF_LINK_TYPE_TRACING                   = 0x2
-	BPF_LINK_TYPE_CGROUP                    = 0x3
-	BPF_LINK_TYPE_ITER                      = 0x4
-	BPF_LINK_TYPE_NETNS                     = 0x5
-	BPF_ANY                                 = 0x0
-	BPF_NOEXIST                             = 0x1
-	BPF_EXIST                               = 0x2
-	BPF_F_LOCK                              = 0x4
-	BPF_F_NO_PREALLOC                       = 0x1
-	BPF_F_NO_COMMON_LRU                     = 0x2
-	BPF_F_NUMA_NODE                         = 0x4
-	BPF_F_RDONLY                            = 0x8
-	BPF_F_WRONLY                            = 0x10
-	BPF_F_STACK_BUILD_ID                    = 0x20
-	BPF_F_ZERO_SEED                         = 0x40
-	BPF_F_RDONLY_PROG                       = 0x80
-	BPF_F_WRONLY_PROG                       = 0x100
-	BPF_F_CLONE                             = 0x200
-	BPF_F_MMAPABLE                          = 0x400
-	BPF_STATS_RUN_TIME                      = 0x0
-	BPF_STACK_BUILD_ID_EMPTY                = 0x0
-	BPF_STACK_BUILD_ID_VALID                = 0x1
-	BPF_STACK_BUILD_ID_IP                   = 0x2
-	BPF_F_RECOMPUTE_CSUM                    = 0x1
-	BPF_F_INVALIDATE_HASH                   = 0x2
-	BPF_F_HDR_FIELD_MASK                    = 0xf
-	BPF_F_PSEUDO_HDR                        = 0x10
-	BPF_F_MARK_MANGLED_0                    = 0x20
-	BPF_F_MARK_ENFORCE                      = 0x40
-	BPF_F_INGRESS                           = 0x1
-	BPF_F_TUNINFO_IPV6                      = 0x1
-	BPF_F_SKIP_FIELD_MASK                   = 0xff
-	BPF_F_USER_STACK                        = 0x100
-	BPF_F_FAST_STACK_CMP                    = 0x200
-	BPF_F_REUSE_STACKID                     = 0x400
-	BPF_F_USER_BUILD_ID                     = 0x800
-	BPF_F_ZERO_CSUM_TX                      = 0x2
-	BPF_F_DONT_FRAGMENT                     = 0x4
-	BPF_F_SEQ_NUMBER                        = 0x8
-	BPF_F_INDEX_MASK                        = 0xffffffff
-	BPF_F_CURRENT_CPU                       = 0xffffffff
-	BPF_F_CTXLEN_MASK                       = 0xfffff00000000
-	BPF_F_CURRENT_NETNS                     = -0x1
-	BPF_CSUM_LEVEL_QUERY                    = 0x0
-	BPF_CSUM_LEVEL_INC                      = 0x1
-	BPF_CSUM_LEVEL_DEC                      = 0x2
-	BPF_CSUM_LEVEL_RESET                    = 0x3
-	BPF_F_ADJ_ROOM_FIXED_GSO                = 0x1
-	BPF_F_ADJ_ROOM_ENCAP_L3_IPV4            = 0x2
-	BPF_F_ADJ_ROOM_ENCAP_L3_IPV6            = 0x4
-	BPF_F_ADJ_ROOM_ENCAP_L4_GRE             = 0x8
-	BPF_F_ADJ_ROOM_ENCAP_L4_UDP             = 0x10
-	BPF_F_ADJ_ROOM_NO_CSUM_RESET            = 0x20
-	BPF_ADJ_ROOM_ENCAP_L2_MASK              = 0xff
-	BPF_ADJ_ROOM_ENCAP_L2_SHIFT             = 0x38
-	BPF_F_SYSCTL_BASE_NAME                  = 0x1
-	BPF_SK_STORAGE_GET_F_CREATE             = 0x1
-	BPF_F_GET_BRANCH_RECORDS_SIZE           = 0x1
-	BPF_RB_NO_WAKEUP                        = 0x1
-	BPF_RB_FORCE_WAKEUP                     = 0x2
-	BPF_RB_AVAIL_DATA                       = 0x0
-	BPF_RB_RING_SIZE                        = 0x1
-	BPF_RB_CONS_POS                         = 0x2
-	BPF_RB_PROD_POS                         = 0x3
-	BPF_RINGBUF_BUSY_BIT                    = 0x80000000
-	BPF_RINGBUF_DISCARD_BIT                 = 0x40000000
-	BPF_RINGBUF_HDR_SZ                      = 0x8
-	BPF_ADJ_ROOM_NET                        = 0x0
-	BPF_ADJ_ROOM_MAC                        = 0x1
-	BPF_HDR_START_MAC                       = 0x0
-	BPF_HDR_START_NET                       = 0x1
-	BPF_LWT_ENCAP_SEG6                      = 0x0
-	BPF_LWT_ENCAP_SEG6_INLINE               = 0x1
-	BPF_LWT_ENCAP_IP                        = 0x2
-	BPF_OK                                  = 0x0
-	BPF_DROP                                = 0x2
-	BPF_REDIRECT                            = 0x7
-	BPF_LWT_REROUTE                         = 0x80
-	BPF_SOCK_OPS_RTO_CB_FLAG                = 0x1
-	BPF_SOCK_OPS_RETRANS_CB_FLAG            = 0x2
-	BPF_SOCK_OPS_STATE_CB_FLAG              = 0x4
-	BPF_SOCK_OPS_RTT_CB_FLAG                = 0x8
-	BPF_SOCK_OPS_ALL_CB_FLAGS               = 0xf
-	BPF_SOCK_OPS_VOID                       = 0x0
-	BPF_SOCK_OPS_TIMEOUT_INIT               = 0x1
-	BPF_SOCK_OPS_RWND_INIT                  = 0x2
-	BPF_SOCK_OPS_TCP_CONNECT_CB             = 0x3
-	BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB      = 0x4
-	BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB     = 0x5
-	BPF_SOCK_OPS_NEEDS_ECN                  = 0x6
-	BPF_SOCK_OPS_BASE_RTT                   = 0x7
-	BPF_SOCK_OPS_RTO_CB                     = 0x8
-	BPF_SOCK_OPS_RETRANS_CB                 = 0x9
-	BPF_SOCK_OPS_STATE_CB                   = 0xa
-	BPF_SOCK_OPS_TCP_LISTEN_CB              = 0xb
-	BPF_SOCK_OPS_RTT_CB                     = 0xc
-	BPF_TCP_ESTABLISHED                     = 0x1
-	BPF_TCP_SYN_SENT                        = 0x2
-	BPF_TCP_SYN_RECV                        = 0x3
-	BPF_TCP_FIN_WAIT1                       = 0x4
-	BPF_TCP_FIN_WAIT2                       = 0x5
-	BPF_TCP_TIME_WAIT                       = 0x6
-	BPF_TCP_CLOSE                           = 0x7
-	BPF_TCP_CLOSE_WAIT                      = 0x8
-	BPF_TCP_LAST_ACK                        = 0x9
-	BPF_TCP_LISTEN                          = 0xa
-	BPF_TCP_CLOSING                         = 0xb
-	BPF_TCP_NEW_SYN_RECV                    = 0xc
-	BPF_TCP_MAX_STATES                      = 0xd
-	TCP_BPF_IW                              = 0x3e9
-	TCP_BPF_SNDCWND_CLAMP                   = 0x3ea
-	BPF_DEVCG_ACC_MKNOD                     = 0x1
-	BPF_DEVCG_ACC_READ                      = 0x2
-	BPF_DEVCG_ACC_WRITE                     = 0x4
-	BPF_DEVCG_DEV_BLOCK                     = 0x1
-	BPF_DEVCG_DEV_CHAR                      = 0x2
-	BPF_FIB_LOOKUP_DIRECT                   = 0x1
-	BPF_FIB_LOOKUP_OUTPUT                   = 0x2
-	BPF_FIB_LKUP_RET_SUCCESS                = 0x0
-	BPF_FIB_LKUP_RET_BLACKHOLE              = 0x1
-	BPF_FIB_LKUP_RET_UNREACHABLE            = 0x2
-	BPF_FIB_LKUP_RET_PROHIBIT               = 0x3
-	BPF_FIB_LKUP_RET_NOT_FWDED              = 0x4
-	BPF_FIB_LKUP_RET_FWD_DISABLED           = 0x5
-	BPF_FIB_LKUP_RET_UNSUPP_LWT             = 0x6
-	BPF_FIB_LKUP_RET_NO_NEIGH               = 0x7
-	BPF_FIB_LKUP_RET_FRAG_NEEDED            = 0x8
-	BPF_FD_TYPE_RAW_TRACEPOINT              = 0x0
-	BPF_FD_TYPE_TRACEPOINT                  = 0x1
-	BPF_FD_TYPE_KPROBE                      = 0x2
-	BPF_FD_TYPE_KRETPROBE                   = 0x3
-	BPF_FD_TYPE_UPROBE                      = 0x4
-	BPF_FD_TYPE_URETPROBE                   = 0x5
-	BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG     = 0x1
-	BPF_FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL = 0x2
-	BPF_FLOW_DISSECTOR_F_STOP_AT_ENCAP      = 0x4
+	BPF_REG_0                                  = 0x0
+	BPF_REG_1                                  = 0x1
+	BPF_REG_2                                  = 0x2
+	BPF_REG_3                                  = 0x3
+	BPF_REG_4                                  = 0x4
+	BPF_REG_5                                  = 0x5
+	BPF_REG_6                                  = 0x6
+	BPF_REG_7                                  = 0x7
+	BPF_REG_8                                  = 0x8
+	BPF_REG_9                                  = 0x9
+	BPF_REG_10                                 = 0xa
+	BPF_MAP_CREATE                             = 0x0
+	BPF_MAP_LOOKUP_ELEM                        = 0x1
+	BPF_MAP_UPDATE_ELEM                        = 0x2
+	BPF_MAP_DELETE_ELEM                        = 0x3
+	BPF_MAP_GET_NEXT_KEY                       = 0x4
+	BPF_PROG_LOAD                              = 0x5
+	BPF_OBJ_PIN                                = 0x6
+	BPF_OBJ_GET                                = 0x7
+	BPF_PROG_ATTACH                            = 0x8
+	BPF_PROG_DETACH                            = 0x9
+	BPF_PROG_TEST_RUN                          = 0xa
+	BPF_PROG_GET_NEXT_ID                       = 0xb
+	BPF_MAP_GET_NEXT_ID                        = 0xc
+	BPF_PROG_GET_FD_BY_ID                      = 0xd
+	BPF_MAP_GET_FD_BY_ID                       = 0xe
+	BPF_OBJ_GET_INFO_BY_FD                     = 0xf
+	BPF_PROG_QUERY                             = 0x10
+	BPF_RAW_TRACEPOINT_OPEN                    = 0x11
+	BPF_BTF_LOAD                               = 0x12
+	BPF_BTF_GET_FD_BY_ID                       = 0x13
+	BPF_TASK_FD_QUERY                          = 0x14
+	BPF_MAP_LOOKUP_AND_DELETE_ELEM             = 0x15
+	BPF_MAP_FREEZE                             = 0x16
+	BPF_BTF_GET_NEXT_ID                        = 0x17
+	BPF_MAP_LOOKUP_BATCH                       = 0x18
+	BPF_MAP_LOOKUP_AND_DELETE_BATCH            = 0x19
+	BPF_MAP_UPDATE_BATCH                       = 0x1a
+	BPF_MAP_DELETE_BATCH                       = 0x1b
+	BPF_LINK_CREATE                            = 0x1c
+	BPF_LINK_UPDATE                            = 0x1d
+	BPF_LINK_GET_FD_BY_ID                      = 0x1e
+	BPF_LINK_GET_NEXT_ID                       = 0x1f
+	BPF_ENABLE_STATS                           = 0x20
+	BPF_ITER_CREATE                            = 0x21
+	BPF_LINK_DETACH                            = 0x22
+	BPF_PROG_BIND_MAP                          = 0x23
+	BPF_MAP_TYPE_UNSPEC                        = 0x0
+	BPF_MAP_TYPE_HASH                          = 0x1
+	BPF_MAP_TYPE_ARRAY                         = 0x2
+	BPF_MAP_TYPE_PROG_ARRAY                    = 0x3
+	BPF_MAP_TYPE_PERF_EVENT_ARRAY              = 0x4
+	BPF_MAP_TYPE_PERCPU_HASH                   = 0x5
+	BPF_MAP_TYPE_PERCPU_ARRAY                  = 0x6
+	BPF_MAP_TYPE_STACK_TRACE                   = 0x7
+	BPF_MAP_TYPE_CGROUP_ARRAY                  = 0x8
+	BPF_MAP_TYPE_LRU_HASH                      = 0x9
+	BPF_MAP_TYPE_LRU_PERCPU_HASH               = 0xa
+	BPF_MAP_TYPE_LPM_TRIE                      = 0xb
+	BPF_MAP_TYPE_ARRAY_OF_MAPS                 = 0xc
+	BPF_MAP_TYPE_HASH_OF_MAPS                  = 0xd
+	BPF_MAP_TYPE_DEVMAP                        = 0xe
+	BPF_MAP_TYPE_SOCKMAP                       = 0xf
+	BPF_MAP_TYPE_CPUMAP                        = 0x10
+	BPF_MAP_TYPE_XSKMAP                        = 0x11
+	BPF_MAP_TYPE_SOCKHASH                      = 0x12
+	BPF_MAP_TYPE_CGROUP_STORAGE                = 0x13
+	BPF_MAP_TYPE_REUSEPORT_SOCKARRAY           = 0x14
+	BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE         = 0x15
+	BPF_MAP_TYPE_QUEUE                         = 0x16
+	BPF_MAP_TYPE_STACK                         = 0x17
+	BPF_MAP_TYPE_SK_STORAGE                    = 0x18
+	BPF_MAP_TYPE_DEVMAP_HASH                   = 0x19
+	BPF_MAP_TYPE_STRUCT_OPS                    = 0x1a
+	BPF_MAP_TYPE_RINGBUF                       = 0x1b
+	BPF_MAP_TYPE_INODE_STORAGE                 = 0x1c
+	BPF_PROG_TYPE_UNSPEC                       = 0x0
+	BPF_PROG_TYPE_SOCKET_FILTER                = 0x1
+	BPF_PROG_TYPE_KPROBE                       = 0x2
+	BPF_PROG_TYPE_SCHED_CLS                    = 0x3
+	BPF_PROG_TYPE_SCHED_ACT                    = 0x4
+	BPF_PROG_TYPE_TRACEPOINT                   = 0x5
+	BPF_PROG_TYPE_XDP                          = 0x6
+	BPF_PROG_TYPE_PERF_EVENT                   = 0x7
+	BPF_PROG_TYPE_CGROUP_SKB                   = 0x8
+	BPF_PROG_TYPE_CGROUP_SOCK                  = 0x9
+	BPF_PROG_TYPE_LWT_IN                       = 0xa
+	BPF_PROG_TYPE_LWT_OUT                      = 0xb
+	BPF_PROG_TYPE_LWT_XMIT                     = 0xc
+	BPF_PROG_TYPE_SOCK_OPS                     = 0xd
+	BPF_PROG_TYPE_SK_SKB                       = 0xe
+	BPF_PROG_TYPE_CGROUP_DEVICE                = 0xf
+	BPF_PROG_TYPE_SK_MSG                       = 0x10
+	BPF_PROG_TYPE_RAW_TRACEPOINT               = 0x11
+	BPF_PROG_TYPE_CGROUP_SOCK_ADDR             = 0x12
+	BPF_PROG_TYPE_LWT_SEG6LOCAL                = 0x13
+	BPF_PROG_TYPE_LIRC_MODE2                   = 0x14
+	BPF_PROG_TYPE_SK_REUSEPORT                 = 0x15
+	BPF_PROG_TYPE_FLOW_DISSECTOR               = 0x16
+	BPF_PROG_TYPE_CGROUP_SYSCTL                = 0x17
+	BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE      = 0x18
+	BPF_PROG_TYPE_CGROUP_SOCKOPT               = 0x19
+	BPF_PROG_TYPE_TRACING                      = 0x1a
+	BPF_PROG_TYPE_STRUCT_OPS                   = 0x1b
+	BPF_PROG_TYPE_EXT                          = 0x1c
+	BPF_PROG_TYPE_LSM                          = 0x1d
+	BPF_PROG_TYPE_SK_LOOKUP                    = 0x1e
+	BPF_CGROUP_INET_INGRESS                    = 0x0
+	BPF_CGROUP_INET_EGRESS                     = 0x1
+	BPF_CGROUP_INET_SOCK_CREATE                = 0x2
+	BPF_CGROUP_SOCK_OPS                        = 0x3
+	BPF_SK_SKB_STREAM_PARSER                   = 0x4
+	BPF_SK_SKB_STREAM_VERDICT                  = 0x5
+	BPF_CGROUP_DEVICE                          = 0x6
+	BPF_SK_MSG_VERDICT                         = 0x7
+	BPF_CGROUP_INET4_BIND                      = 0x8
+	BPF_CGROUP_INET6_BIND                      = 0x9
+	BPF_CGROUP_INET4_CONNECT                   = 0xa
+	BPF_CGROUP_INET6_CONNECT                   = 0xb
+	BPF_CGROUP_INET4_POST_BIND                 = 0xc
+	BPF_CGROUP_INET6_POST_BIND                 = 0xd
+	BPF_CGROUP_UDP4_SENDMSG                    = 0xe
+	BPF_CGROUP_UDP6_SENDMSG                    = 0xf
+	BPF_LIRC_MODE2                             = 0x10
+	BPF_FLOW_DISSECTOR                         = 0x11
+	BPF_CGROUP_SYSCTL                          = 0x12
+	BPF_CGROUP_UDP4_RECVMSG                    = 0x13
+	BPF_CGROUP_UDP6_RECVMSG                    = 0x14
+	BPF_CGROUP_GETSOCKOPT                      = 0x15
+	BPF_CGROUP_SETSOCKOPT                      = 0x16
+	BPF_TRACE_RAW_TP                           = 0x17
+	BPF_TRACE_FENTRY                           = 0x18
+	BPF_TRACE_FEXIT                            = 0x19
+	BPF_MODIFY_RETURN                          = 0x1a
+	BPF_LSM_MAC                                = 0x1b
+	BPF_TRACE_ITER                             = 0x1c
+	BPF_CGROUP_INET4_GETPEERNAME               = 0x1d
+	BPF_CGROUP_INET6_GETPEERNAME               = 0x1e
+	BPF_CGROUP_INET4_GETSOCKNAME               = 0x1f
+	BPF_CGROUP_INET6_GETSOCKNAME               = 0x20
+	BPF_XDP_DEVMAP                             = 0x21
+	BPF_CGROUP_INET_SOCK_RELEASE               = 0x22
+	BPF_XDP_CPUMAP                             = 0x23
+	BPF_SK_LOOKUP                              = 0x24
+	BPF_XDP                                    = 0x25
+	BPF_LINK_TYPE_UNSPEC                       = 0x0
+	BPF_LINK_TYPE_RAW_TRACEPOINT               = 0x1
+	BPF_LINK_TYPE_TRACING                      = 0x2
+	BPF_LINK_TYPE_CGROUP                       = 0x3
+	BPF_LINK_TYPE_ITER                         = 0x4
+	BPF_LINK_TYPE_NETNS                        = 0x5
+	BPF_LINK_TYPE_XDP                          = 0x6
+	BPF_ANY                                    = 0x0
+	BPF_NOEXIST                                = 0x1
+	BPF_EXIST                                  = 0x2
+	BPF_F_LOCK                                 = 0x4
+	BPF_F_NO_PREALLOC                          = 0x1
+	BPF_F_NO_COMMON_LRU                        = 0x2
+	BPF_F_NUMA_NODE                            = 0x4
+	BPF_F_RDONLY                               = 0x8
+	BPF_F_WRONLY                               = 0x10
+	BPF_F_STACK_BUILD_ID                       = 0x20
+	BPF_F_ZERO_SEED                            = 0x40
+	BPF_F_RDONLY_PROG                          = 0x80
+	BPF_F_WRONLY_PROG                          = 0x100
+	BPF_F_CLONE                                = 0x200
+	BPF_F_MMAPABLE                             = 0x400
+	BPF_F_PRESERVE_ELEMS                       = 0x800
+	BPF_F_INNER_MAP                            = 0x1000
+	BPF_STATS_RUN_TIME                         = 0x0
+	BPF_STACK_BUILD_ID_EMPTY                   = 0x0
+	BPF_STACK_BUILD_ID_VALID                   = 0x1
+	BPF_STACK_BUILD_ID_IP                      = 0x2
+	BPF_F_RECOMPUTE_CSUM                       = 0x1
+	BPF_F_INVALIDATE_HASH                      = 0x2
+	BPF_F_HDR_FIELD_MASK                       = 0xf
+	BPF_F_PSEUDO_HDR                           = 0x10
+	BPF_F_MARK_MANGLED_0                       = 0x20
+	BPF_F_MARK_ENFORCE                         = 0x40
+	BPF_F_INGRESS                              = 0x1
+	BPF_F_TUNINFO_IPV6                         = 0x1
+	BPF_F_SKIP_FIELD_MASK                      = 0xff
+	BPF_F_USER_STACK                           = 0x100
+	BPF_F_FAST_STACK_CMP                       = 0x200
+	BPF_F_REUSE_STACKID                        = 0x400
+	BPF_F_USER_BUILD_ID                        = 0x800
+	BPF_F_ZERO_CSUM_TX                         = 0x2
+	BPF_F_DONT_FRAGMENT                        = 0x4
+	BPF_F_SEQ_NUMBER                           = 0x8
+	BPF_F_INDEX_MASK                           = 0xffffffff
+	BPF_F_CURRENT_CPU                          = 0xffffffff
+	BPF_F_CTXLEN_MASK                          = 0xfffff00000000
+	BPF_F_CURRENT_NETNS                        = -0x1
+	BPF_CSUM_LEVEL_QUERY                       = 0x0
+	BPF_CSUM_LEVEL_INC                         = 0x1
+	BPF_CSUM_LEVEL_DEC                         = 0x2
+	BPF_CSUM_LEVEL_RESET                       = 0x3
+	BPF_F_ADJ_ROOM_FIXED_GSO                   = 0x1
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV4               = 0x2
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV6               = 0x4
+	BPF_F_ADJ_ROOM_ENCAP_L4_GRE                = 0x8
+	BPF_F_ADJ_ROOM_ENCAP_L4_UDP                = 0x10
+	BPF_F_ADJ_ROOM_NO_CSUM_RESET               = 0x20
+	BPF_ADJ_ROOM_ENCAP_L2_MASK                 = 0xff
+	BPF_ADJ_ROOM_ENCAP_L2_SHIFT                = 0x38
+	BPF_F_SYSCTL_BASE_NAME                     = 0x1
+	BPF_LOCAL_STORAGE_GET_F_CREATE             = 0x1
+	BPF_SK_STORAGE_GET_F_CREATE                = 0x1
+	BPF_F_GET_BRANCH_RECORDS_SIZE              = 0x1
+	BPF_RB_NO_WAKEUP                           = 0x1
+	BPF_RB_FORCE_WAKEUP                        = 0x2
+	BPF_RB_AVAIL_DATA                          = 0x0
+	BPF_RB_RING_SIZE                           = 0x1
+	BPF_RB_CONS_POS                            = 0x2
+	BPF_RB_PROD_POS                            = 0x3
+	BPF_RINGBUF_BUSY_BIT                       = 0x80000000
+	BPF_RINGBUF_DISCARD_BIT                    = 0x40000000
+	BPF_RINGBUF_HDR_SZ                         = 0x8
+	BPF_SK_LOOKUP_F_REPLACE                    = 0x1
+	BPF_SK_LOOKUP_F_NO_REUSEPORT               = 0x2
+	BPF_ADJ_ROOM_NET                           = 0x0
+	BPF_ADJ_ROOM_MAC                           = 0x1
+	BPF_HDR_START_MAC                          = 0x0
+	BPF_HDR_START_NET                          = 0x1
+	BPF_LWT_ENCAP_SEG6                         = 0x0
+	BPF_LWT_ENCAP_SEG6_INLINE                  = 0x1
+	BPF_LWT_ENCAP_IP                           = 0x2
+	BPF_OK                                     = 0x0
+	BPF_DROP                                   = 0x2
+	BPF_REDIRECT                               = 0x7
+	BPF_LWT_REROUTE                            = 0x80
+	BPF_SOCK_OPS_RTO_CB_FLAG                   = 0x1
+	BPF_SOCK_OPS_RETRANS_CB_FLAG               = 0x2
+	BPF_SOCK_OPS_STATE_CB_FLAG                 = 0x4
+	BPF_SOCK_OPS_RTT_CB_FLAG                   = 0x8
+	BPF_SOCK_OPS_PARSE_ALL_HDR_OPT_CB_FLAG     = 0x10
+	BPF_SOCK_OPS_PARSE_UNKNOWN_HDR_OPT_CB_FLAG = 0x20
+	BPF_SOCK_OPS_WRITE_HDR_OPT_CB_FLAG         = 0x40
+	BPF_SOCK_OPS_ALL_CB_FLAGS                  = 0x7f
+	BPF_SOCK_OPS_VOID                          = 0x0
+	BPF_SOCK_OPS_TIMEOUT_INIT                  = 0x1
+	BPF_SOCK_OPS_RWND_INIT                     = 0x2
+	BPF_SOCK_OPS_TCP_CONNECT_CB                = 0x3
+	BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB         = 0x4
+	BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB        = 0x5
+	BPF_SOCK_OPS_NEEDS_ECN                     = 0x6
+	BPF_SOCK_OPS_BASE_RTT                      = 0x7
+	BPF_SOCK_OPS_RTO_CB                        = 0x8
+	BPF_SOCK_OPS_RETRANS_CB                    = 0x9
+	BPF_SOCK_OPS_STATE_CB                      = 0xa
+	BPF_SOCK_OPS_TCP_LISTEN_CB                 = 0xb
+	BPF_SOCK_OPS_RTT_CB                        = 0xc
+	BPF_SOCK_OPS_PARSE_HDR_OPT_CB              = 0xd
+	BPF_SOCK_OPS_HDR_OPT_LEN_CB                = 0xe
+	BPF_SOCK_OPS_WRITE_HDR_OPT_CB              = 0xf
+	BPF_TCP_ESTABLISHED                        = 0x1
+	BPF_TCP_SYN_SENT                           = 0x2
+	BPF_TCP_SYN_RECV                           = 0x3
+	BPF_TCP_FIN_WAIT1                          = 0x4
+	BPF_TCP_FIN_WAIT2                          = 0x5
+	BPF_TCP_TIME_WAIT                          = 0x6
+	BPF_TCP_CLOSE                              = 0x7
+	BPF_TCP_CLOSE_WAIT                         = 0x8
+	BPF_TCP_LAST_ACK                           = 0x9
+	BPF_TCP_LISTEN                             = 0xa
+	BPF_TCP_CLOSING                            = 0xb
+	BPF_TCP_NEW_SYN_RECV                       = 0xc
+	BPF_TCP_MAX_STATES                         = 0xd
+	TCP_BPF_IW                                 = 0x3e9
+	TCP_BPF_SNDCWND_CLAMP                      = 0x3ea
+	TCP_BPF_DELACK_MAX                         = 0x3eb
+	TCP_BPF_RTO_MIN                            = 0x3ec
+	TCP_BPF_SYN                                = 0x3ed
+	TCP_BPF_SYN_IP                             = 0x3ee
+	TCP_BPF_SYN_MAC                            = 0x3ef
+	BPF_LOAD_HDR_OPT_TCP_SYN                   = 0x1
+	BPF_WRITE_HDR_TCP_CURRENT_MSS              = 0x1
+	BPF_WRITE_HDR_TCP_SYNACK_COOKIE            = 0x2
+	BPF_DEVCG_ACC_MKNOD                        = 0x1
+	BPF_DEVCG_ACC_READ                         = 0x2
+	BPF_DEVCG_ACC_WRITE                        = 0x4
+	BPF_DEVCG_DEV_BLOCK                        = 0x1
+	BPF_DEVCG_DEV_CHAR                         = 0x2
+	BPF_FIB_LOOKUP_DIRECT                      = 0x1
+	BPF_FIB_LOOKUP_OUTPUT                      = 0x2
+	BPF_FIB_LKUP_RET_SUCCESS                   = 0x0
+	BPF_FIB_LKUP_RET_BLACKHOLE                 = 0x1
+	BPF_FIB_LKUP_RET_UNREACHABLE               = 0x2
+	BPF_FIB_LKUP_RET_PROHIBIT                  = 0x3
+	BPF_FIB_LKUP_RET_NOT_FWDED                 = 0x4
+	BPF_FIB_LKUP_RET_FWD_DISABLED              = 0x5
+	BPF_FIB_LKUP_RET_UNSUPP_LWT                = 0x6
+	BPF_FIB_LKUP_RET_NO_NEIGH                  = 0x7
+	BPF_FIB_LKUP_RET_FRAG_NEEDED               = 0x8
+	BPF_FD_TYPE_RAW_TRACEPOINT                 = 0x0
+	BPF_FD_TYPE_TRACEPOINT                     = 0x1
+	BPF_FD_TYPE_KPROBE                         = 0x2
+	BPF_FD_TYPE_KRETPROBE                      = 0x3
+	BPF_FD_TYPE_UPROBE                         = 0x4
+	BPF_FD_TYPE_URETPROBE                      = 0x5
+	BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG        = 0x1
+	BPF_FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL    = 0x2
+	BPF_FLOW_DISSECTOR_F_STOP_AT_ENCAP         = 0x4
 )
 
 const (
@@ -2681,6 +2719,7 @@ const (
 	RTNLGRP_IPV4_MROUTE_R = 0x1e
 	RTNLGRP_IPV6_MROUTE_R = 0x1f
 	RTNLGRP_NEXTHOP       = 0x20
+	RTNLGRP_BRVLAN        = 0x21
 )
 
 type CapUserHeader struct {
@@ -2775,132 +2814,317 @@ const (
 )
 
 const (
-	DEVLINK_CMD_UNSPEC                        = 0x0
-	DEVLINK_CMD_GET                           = 0x1
-	DEVLINK_CMD_SET                           = 0x2
-	DEVLINK_CMD_NEW                           = 0x3
-	DEVLINK_CMD_DEL                           = 0x4
-	DEVLINK_CMD_PORT_GET                      = 0x5
-	DEVLINK_CMD_PORT_SET                      = 0x6
-	DEVLINK_CMD_PORT_NEW                      = 0x7
-	DEVLINK_CMD_PORT_DEL                      = 0x8
-	DEVLINK_CMD_PORT_SPLIT                    = 0x9
-	DEVLINK_CMD_PORT_UNSPLIT                  = 0xa
-	DEVLINK_CMD_SB_GET                        = 0xb
-	DEVLINK_CMD_SB_SET                        = 0xc
-	DEVLINK_CMD_SB_NEW                        = 0xd
-	DEVLINK_CMD_SB_DEL                        = 0xe
-	DEVLINK_CMD_SB_POOL_GET                   = 0xf
-	DEVLINK_CMD_SB_POOL_SET                   = 0x10
-	DEVLINK_CMD_SB_POOL_NEW                   = 0x11
-	DEVLINK_CMD_SB_POOL_DEL                   = 0x12
-	DEVLINK_CMD_SB_PORT_POOL_GET              = 0x13
-	DEVLINK_CMD_SB_PORT_POOL_SET              = 0x14
-	DEVLINK_CMD_SB_PORT_POOL_NEW              = 0x15
-	DEVLINK_CMD_SB_PORT_POOL_DEL              = 0x16
-	DEVLINK_CMD_SB_TC_POOL_BIND_GET           = 0x17
-	DEVLINK_CMD_SB_TC_POOL_BIND_SET           = 0x18
-	DEVLINK_CMD_SB_TC_POOL_BIND_NEW           = 0x19
-	DEVLINK_CMD_SB_TC_POOL_BIND_DEL           = 0x1a
-	DEVLINK_CMD_SB_OCC_SNAPSHOT               = 0x1b
-	DEVLINK_CMD_SB_OCC_MAX_CLEAR              = 0x1c
-	DEVLINK_CMD_ESWITCH_GET                   = 0x1d
-	DEVLINK_CMD_ESWITCH_SET                   = 0x1e
-	DEVLINK_CMD_DPIPE_TABLE_GET               = 0x1f
-	DEVLINK_CMD_DPIPE_ENTRIES_GET             = 0x20
-	DEVLINK_CMD_DPIPE_HEADERS_GET             = 0x21
-	DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET      = 0x22
-	DEVLINK_CMD_MAX                           = 0x48
-	DEVLINK_PORT_TYPE_NOTSET                  = 0x0
-	DEVLINK_PORT_TYPE_AUTO                    = 0x1
-	DEVLINK_PORT_TYPE_ETH                     = 0x2
-	DEVLINK_PORT_TYPE_IB                      = 0x3
-	DEVLINK_SB_POOL_TYPE_INGRESS              = 0x0
-	DEVLINK_SB_POOL_TYPE_EGRESS               = 0x1
-	DEVLINK_SB_THRESHOLD_TYPE_STATIC          = 0x0
-	DEVLINK_SB_THRESHOLD_TYPE_DYNAMIC         = 0x1
-	DEVLINK_ESWITCH_MODE_LEGACY               = 0x0
-	DEVLINK_ESWITCH_MODE_SWITCHDEV            = 0x1
-	DEVLINK_ESWITCH_INLINE_MODE_NONE          = 0x0
-	DEVLINK_ESWITCH_INLINE_MODE_LINK          = 0x1
-	DEVLINK_ESWITCH_INLINE_MODE_NETWORK       = 0x2
-	DEVLINK_ESWITCH_INLINE_MODE_TRANSPORT     = 0x3
-	DEVLINK_ESWITCH_ENCAP_MODE_NONE           = 0x0
-	DEVLINK_ESWITCH_ENCAP_MODE_BASIC          = 0x1
-	DEVLINK_ATTR_UNSPEC                       = 0x0
-	DEVLINK_ATTR_BUS_NAME                     = 0x1
-	DEVLINK_ATTR_DEV_NAME                     = 0x2
-	DEVLINK_ATTR_PORT_INDEX                   = 0x3
-	DEVLINK_ATTR_PORT_TYPE                    = 0x4
-	DEVLINK_ATTR_PORT_DESIRED_TYPE            = 0x5
-	DEVLINK_ATTR_PORT_NETDEV_IFINDEX          = 0x6
-	DEVLINK_ATTR_PORT_NETDEV_NAME             = 0x7
-	DEVLINK_ATTR_PORT_IBDEV_NAME              = 0x8
-	DEVLINK_ATTR_PORT_SPLIT_COUNT             = 0x9
-	DEVLINK_ATTR_PORT_SPLIT_GROUP             = 0xa
-	DEVLINK_ATTR_SB_INDEX                     = 0xb
-	DEVLINK_ATTR_SB_SIZE                      = 0xc
-	DEVLINK_ATTR_SB_INGRESS_POOL_COUNT        = 0xd
-	DEVLINK_ATTR_SB_EGRESS_POOL_COUNT         = 0xe
-	DEVLINK_ATTR_SB_INGRESS_TC_COUNT          = 0xf
-	DEVLINK_ATTR_SB_EGRESS_TC_COUNT           = 0x10
-	DEVLINK_ATTR_SB_POOL_INDEX                = 0x11
-	DEVLINK_ATTR_SB_POOL_TYPE                 = 0x12
-	DEVLINK_ATTR_SB_POOL_SIZE                 = 0x13
-	DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE       = 0x14
-	DEVLINK_ATTR_SB_THRESHOLD                 = 0x15
-	DEVLINK_ATTR_SB_TC_INDEX                  = 0x16
-	DEVLINK_ATTR_SB_OCC_CUR                   = 0x17
-	DEVLINK_ATTR_SB_OCC_MAX                   = 0x18
-	DEVLINK_ATTR_ESWITCH_MODE                 = 0x19
-	DEVLINK_ATTR_ESWITCH_INLINE_MODE          = 0x1a
-	DEVLINK_ATTR_DPIPE_TABLES                 = 0x1b
-	DEVLINK_ATTR_DPIPE_TABLE                  = 0x1c
-	DEVLINK_ATTR_DPIPE_TABLE_NAME             = 0x1d
-	DEVLINK_ATTR_DPIPE_TABLE_SIZE             = 0x1e
-	DEVLINK_ATTR_DPIPE_TABLE_MATCHES          = 0x1f
-	DEVLINK_ATTR_DPIPE_TABLE_ACTIONS          = 0x20
-	DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED = 0x21
-	DEVLINK_ATTR_DPIPE_ENTRIES                = 0x22
-	DEVLINK_ATTR_DPIPE_ENTRY                  = 0x23
-	DEVLINK_ATTR_DPIPE_ENTRY_INDEX            = 0x24
-	DEVLINK_ATTR_DPIPE_ENTRY_MATCH_VALUES     = 0x25
-	DEVLINK_ATTR_DPIPE_ENTRY_ACTION_VALUES    = 0x26
-	DEVLINK_ATTR_DPIPE_ENTRY_COUNTER          = 0x27
-	DEVLINK_ATTR_DPIPE_MATCH                  = 0x28
-	DEVLINK_ATTR_DPIPE_MATCH_VALUE            = 0x29
-	DEVLINK_ATTR_DPIPE_MATCH_TYPE             = 0x2a
-	DEVLINK_ATTR_DPIPE_ACTION                 = 0x2b
-	DEVLINK_ATTR_DPIPE_ACTION_VALUE           = 0x2c
-	DEVLINK_ATTR_DPIPE_ACTION_TYPE            = 0x2d
-	DEVLINK_ATTR_DPIPE_VALUE                  = 0x2e
-	DEVLINK_ATTR_DPIPE_VALUE_MASK             = 0x2f
-	DEVLINK_ATTR_DPIPE_VALUE_MAPPING          = 0x30
-	DEVLINK_ATTR_DPIPE_HEADERS                = 0x31
-	DEVLINK_ATTR_DPIPE_HEADER                 = 0x32
-	DEVLINK_ATTR_DPIPE_HEADER_NAME            = 0x33
-	DEVLINK_ATTR_DPIPE_HEADER_ID              = 0x34
-	DEVLINK_ATTR_DPIPE_HEADER_FIELDS          = 0x35
-	DEVLINK_ATTR_DPIPE_HEADER_GLOBAL          = 0x36
-	DEVLINK_ATTR_DPIPE_HEADER_INDEX           = 0x37
-	DEVLINK_ATTR_DPIPE_FIELD                  = 0x38
-	DEVLINK_ATTR_DPIPE_FIELD_NAME             = 0x39
-	DEVLINK_ATTR_DPIPE_FIELD_ID               = 0x3a
-	DEVLINK_ATTR_DPIPE_FIELD_BITWIDTH         = 0x3b
-	DEVLINK_ATTR_DPIPE_FIELD_MAPPING_TYPE     = 0x3c
-	DEVLINK_ATTR_PAD                          = 0x3d
-	DEVLINK_ATTR_ESWITCH_ENCAP_MODE           = 0x3e
-	DEVLINK_ATTR_MAX                          = 0x94
-	DEVLINK_DPIPE_FIELD_MAPPING_TYPE_NONE     = 0x0
-	DEVLINK_DPIPE_FIELD_MAPPING_TYPE_IFINDEX  = 0x1
-	DEVLINK_DPIPE_MATCH_TYPE_FIELD_EXACT      = 0x0
-	DEVLINK_DPIPE_ACTION_TYPE_FIELD_MODIFY    = 0x0
-	DEVLINK_DPIPE_FIELD_ETHERNET_DST_MAC      = 0x0
-	DEVLINK_DPIPE_FIELD_IPV4_DST_IP           = 0x0
-	DEVLINK_DPIPE_FIELD_IPV6_DST_IP           = 0x0
-	DEVLINK_DPIPE_HEADER_ETHERNET             = 0x0
-	DEVLINK_DPIPE_HEADER_IPV4                 = 0x1
-	DEVLINK_DPIPE_HEADER_IPV6                 = 0x2
+	DEVLINK_CMD_UNSPEC                                 = 0x0
+	DEVLINK_CMD_GET                                    = 0x1
+	DEVLINK_CMD_SET                                    = 0x2
+	DEVLINK_CMD_NEW                                    = 0x3
+	DEVLINK_CMD_DEL                                    = 0x4
+	DEVLINK_CMD_PORT_GET                               = 0x5
+	DEVLINK_CMD_PORT_SET                               = 0x6
+	DEVLINK_CMD_PORT_NEW                               = 0x7
+	DEVLINK_CMD_PORT_DEL                               = 0x8
+	DEVLINK_CMD_PORT_SPLIT                             = 0x9
+	DEVLINK_CMD_PORT_UNSPLIT                           = 0xa
+	DEVLINK_CMD_SB_GET                                 = 0xb
+	DEVLINK_CMD_SB_SET                                 = 0xc
+	DEVLINK_CMD_SB_NEW                                 = 0xd
+	DEVLINK_CMD_SB_DEL                                 = 0xe
+	DEVLINK_CMD_SB_POOL_GET                            = 0xf
+	DEVLINK_CMD_SB_POOL_SET                            = 0x10
+	DEVLINK_CMD_SB_POOL_NEW                            = 0x11
+	DEVLINK_CMD_SB_POOL_DEL                            = 0x12
+	DEVLINK_CMD_SB_PORT_POOL_GET                       = 0x13
+	DEVLINK_CMD_SB_PORT_POOL_SET                       = 0x14
+	DEVLINK_CMD_SB_PORT_POOL_NEW                       = 0x15
+	DEVLINK_CMD_SB_PORT_POOL_DEL                       = 0x16
+	DEVLINK_CMD_SB_TC_POOL_BIND_GET                    = 0x17
+	DEVLINK_CMD_SB_TC_POOL_BIND_SET                    = 0x18
+	DEVLINK_CMD_SB_TC_POOL_BIND_NEW                    = 0x19
+	DEVLINK_CMD_SB_TC_POOL_BIND_DEL                    = 0x1a
+	DEVLINK_CMD_SB_OCC_SNAPSHOT                        = 0x1b
+	DEVLINK_CMD_SB_OCC_MAX_CLEAR                       = 0x1c
+	DEVLINK_CMD_ESWITCH_GET                            = 0x1d
+	DEVLINK_CMD_ESWITCH_SET                            = 0x1e
+	DEVLINK_CMD_DPIPE_TABLE_GET                        = 0x1f
+	DEVLINK_CMD_DPIPE_ENTRIES_GET                      = 0x20
+	DEVLINK_CMD_DPIPE_HEADERS_GET                      = 0x21
+	DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET               = 0x22
+	DEVLINK_CMD_RESOURCE_SET                           = 0x23
+	DEVLINK_CMD_RESOURCE_DUMP                          = 0x24
+	DEVLINK_CMD_RELOAD                                 = 0x25
+	DEVLINK_CMD_PARAM_GET                              = 0x26
+	DEVLINK_CMD_PARAM_SET                              = 0x27
+	DEVLINK_CMD_PARAM_NEW                              = 0x28
+	DEVLINK_CMD_PARAM_DEL                              = 0x29
+	DEVLINK_CMD_REGION_GET                             = 0x2a
+	DEVLINK_CMD_REGION_SET                             = 0x2b
+	DEVLINK_CMD_REGION_NEW                             = 0x2c
+	DEVLINK_CMD_REGION_DEL                             = 0x2d
+	DEVLINK_CMD_REGION_READ                            = 0x2e
+	DEVLINK_CMD_PORT_PARAM_GET                         = 0x2f
+	DEVLINK_CMD_PORT_PARAM_SET                         = 0x30
+	DEVLINK_CMD_PORT_PARAM_NEW                         = 0x31
+	DEVLINK_CMD_PORT_PARAM_DEL                         = 0x32
+	DEVLINK_CMD_INFO_GET                               = 0x33
+	DEVLINK_CMD_HEALTH_REPORTER_GET                    = 0x34
+	DEVLINK_CMD_HEALTH_REPORTER_SET                    = 0x35
+	DEVLINK_CMD_HEALTH_REPORTER_RECOVER                = 0x36
+	DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE               = 0x37
+	DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET               = 0x38
+	DEVLINK_CMD_HEALTH_REPORTER_DUMP_CLEAR             = 0x39
+	DEVLINK_CMD_FLASH_UPDATE                           = 0x3a
+	DEVLINK_CMD_FLASH_UPDATE_END                       = 0x3b
+	DEVLINK_CMD_FLASH_UPDATE_STATUS                    = 0x3c
+	DEVLINK_CMD_TRAP_GET                               = 0x3d
+	DEVLINK_CMD_TRAP_SET                               = 0x3e
+	DEVLINK_CMD_TRAP_NEW                               = 0x3f
+	DEVLINK_CMD_TRAP_DEL                               = 0x40
+	DEVLINK_CMD_TRAP_GROUP_GET                         = 0x41
+	DEVLINK_CMD_TRAP_GROUP_SET                         = 0x42
+	DEVLINK_CMD_TRAP_GROUP_NEW                         = 0x43
+	DEVLINK_CMD_TRAP_GROUP_DEL                         = 0x44
+	DEVLINK_CMD_TRAP_POLICER_GET                       = 0x45
+	DEVLINK_CMD_TRAP_POLICER_SET                       = 0x46
+	DEVLINK_CMD_TRAP_POLICER_NEW                       = 0x47
+	DEVLINK_CMD_TRAP_POLICER_DEL                       = 0x48
+	DEVLINK_CMD_HEALTH_REPORTER_TEST                   = 0x49
+	DEVLINK_CMD_MAX                                    = 0x49
+	DEVLINK_PORT_TYPE_NOTSET                           = 0x0
+	DEVLINK_PORT_TYPE_AUTO                             = 0x1
+	DEVLINK_PORT_TYPE_ETH                              = 0x2
+	DEVLINK_PORT_TYPE_IB                               = 0x3
+	DEVLINK_SB_POOL_TYPE_INGRESS                       = 0x0
+	DEVLINK_SB_POOL_TYPE_EGRESS                        = 0x1
+	DEVLINK_SB_THRESHOLD_TYPE_STATIC                   = 0x0
+	DEVLINK_SB_THRESHOLD_TYPE_DYNAMIC                  = 0x1
+	DEVLINK_ESWITCH_MODE_LEGACY                        = 0x0
+	DEVLINK_ESWITCH_MODE_SWITCHDEV                     = 0x1
+	DEVLINK_ESWITCH_INLINE_MODE_NONE                   = 0x0
+	DEVLINK_ESWITCH_INLINE_MODE_LINK                   = 0x1
+	DEVLINK_ESWITCH_INLINE_MODE_NETWORK                = 0x2
+	DEVLINK_ESWITCH_INLINE_MODE_TRANSPORT              = 0x3
+	DEVLINK_ESWITCH_ENCAP_MODE_NONE                    = 0x0
+	DEVLINK_ESWITCH_ENCAP_MODE_BASIC                   = 0x1
+	DEVLINK_PORT_FLAVOUR_PHYSICAL                      = 0x0
+	DEVLINK_PORT_FLAVOUR_CPU                           = 0x1
+	DEVLINK_PORT_FLAVOUR_DSA                           = 0x2
+	DEVLINK_PORT_FLAVOUR_PCI_PF                        = 0x3
+	DEVLINK_PORT_FLAVOUR_PCI_VF                        = 0x4
+	DEVLINK_PORT_FLAVOUR_VIRTUAL                       = 0x5
+	DEVLINK_PORT_FLAVOUR_UNUSED                        = 0x6
+	DEVLINK_PARAM_CMODE_RUNTIME                        = 0x0
+	DEVLINK_PARAM_CMODE_DRIVERINIT                     = 0x1
+	DEVLINK_PARAM_CMODE_PERMANENT                      = 0x2
+	DEVLINK_PARAM_CMODE_MAX                            = 0x2
+	DEVLINK_PARAM_FW_LOAD_POLICY_VALUE_DRIVER          = 0x0
+	DEVLINK_PARAM_FW_LOAD_POLICY_VALUE_FLASH           = 0x1
+	DEVLINK_PARAM_FW_LOAD_POLICY_VALUE_DISK            = 0x2
+	DEVLINK_PARAM_FW_LOAD_POLICY_VALUE_UNKNOWN         = 0x3
+	DEVLINK_PARAM_RESET_DEV_ON_DRV_PROBE_VALUE_UNKNOWN = 0x0
+	DEVLINK_PARAM_RESET_DEV_ON_DRV_PROBE_VALUE_ALWAYS  = 0x1
+	DEVLINK_PARAM_RESET_DEV_ON_DRV_PROBE_VALUE_NEVER   = 0x2
+	DEVLINK_PARAM_RESET_DEV_ON_DRV_PROBE_VALUE_DISK    = 0x3
+	DEVLINK_ATTR_STATS_RX_PACKETS                      = 0x0
+	DEVLINK_ATTR_STATS_RX_BYTES                        = 0x1
+	DEVLINK_ATTR_STATS_RX_DROPPED                      = 0x2
+	DEVLINK_ATTR_STATS_MAX                             = 0x2
+	DEVLINK_FLASH_OVERWRITE_SETTINGS_BIT               = 0x0
+	DEVLINK_FLASH_OVERWRITE_IDENTIFIERS_BIT            = 0x1
+	DEVLINK_FLASH_OVERWRITE_MAX_BIT                    = 0x1
+	DEVLINK_TRAP_ACTION_DROP                           = 0x0
+	DEVLINK_TRAP_ACTION_TRAP                           = 0x1
+	DEVLINK_TRAP_ACTION_MIRROR                         = 0x2
+	DEVLINK_TRAP_TYPE_DROP                             = 0x0
+	DEVLINK_TRAP_TYPE_EXCEPTION                        = 0x1
+	DEVLINK_TRAP_TYPE_CONTROL                          = 0x2
+	DEVLINK_ATTR_TRAP_METADATA_TYPE_IN_PORT            = 0x0
+	DEVLINK_ATTR_TRAP_METADATA_TYPE_FA_COOKIE          = 0x1
+	DEVLINK_RELOAD_ACTION_UNSPEC                       = 0x0
+	DEVLINK_RELOAD_ACTION_DRIVER_REINIT                = 0x1
+	DEVLINK_RELOAD_ACTION_FW_ACTIVATE                  = 0x2
+	DEVLINK_RELOAD_ACTION_MAX                          = 0x2
+	DEVLINK_RELOAD_LIMIT_UNSPEC                        = 0x0
+	DEVLINK_RELOAD_LIMIT_NO_RESET                      = 0x1
+	DEVLINK_RELOAD_LIMIT_MAX                           = 0x1
+	DEVLINK_ATTR_UNSPEC                                = 0x0
+	DEVLINK_ATTR_BUS_NAME                              = 0x1
+	DEVLINK_ATTR_DEV_NAME                              = 0x2
+	DEVLINK_ATTR_PORT_INDEX                            = 0x3
+	DEVLINK_ATTR_PORT_TYPE                             = 0x4
+	DEVLINK_ATTR_PORT_DESIRED_TYPE                     = 0x5
+	DEVLINK_ATTR_PORT_NETDEV_IFINDEX                   = 0x6
+	DEVLINK_ATTR_PORT_NETDEV_NAME                      = 0x7
+	DEVLINK_ATTR_PORT_IBDEV_NAME                       = 0x8
+	DEVLINK_ATTR_PORT_SPLIT_COUNT                      = 0x9
+	DEVLINK_ATTR_PORT_SPLIT_GROUP                      = 0xa
+	DEVLINK_ATTR_SB_INDEX                              = 0xb
+	DEVLINK_ATTR_SB_SIZE                               = 0xc
+	DEVLINK_ATTR_SB_INGRESS_POOL_COUNT                 = 0xd
+	DEVLINK_ATTR_SB_EGRESS_POOL_COUNT                  = 0xe
+	DEVLINK_ATTR_SB_INGRESS_TC_COUNT                   = 0xf
+	DEVLINK_ATTR_SB_EGRESS_TC_COUNT                    = 0x10
+	DEVLINK_ATTR_SB_POOL_INDEX                         = 0x11
+	DEVLINK_ATTR_SB_POOL_TYPE                          = 0x12
+	DEVLINK_ATTR_SB_POOL_SIZE                          = 0x13
+	DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE                = 0x14
+	DEVLINK_ATTR_SB_THRESHOLD                          = 0x15
+	DEVLINK_ATTR_SB_TC_INDEX                           = 0x16
+	DEVLINK_ATTR_SB_OCC_CUR                            = 0x17
+	DEVLINK_ATTR_SB_OCC_MAX                            = 0x18
+	DEVLINK_ATTR_ESWITCH_MODE                          = 0x19
+	DEVLINK_ATTR_ESWITCH_INLINE_MODE                   = 0x1a
+	DEVLINK_ATTR_DPIPE_TABLES                          = 0x1b
+	DEVLINK_ATTR_DPIPE_TABLE                           = 0x1c
+	DEVLINK_ATTR_DPIPE_TABLE_NAME                      = 0x1d
+	DEVLINK_ATTR_DPIPE_TABLE_SIZE                      = 0x1e
+	DEVLINK_ATTR_DPIPE_TABLE_MATCHES                   = 0x1f
+	DEVLINK_ATTR_DPIPE_TABLE_ACTIONS                   = 0x20
+	DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED          = 0x21
+	DEVLINK_ATTR_DPIPE_ENTRIES                         = 0x22
+	DEVLINK_ATTR_DPIPE_ENTRY                           = 0x23
+	DEVLINK_ATTR_DPIPE_ENTRY_INDEX                     = 0x24
+	DEVLINK_ATTR_DPIPE_ENTRY_MATCH_VALUES              = 0x25
+	DEVLINK_ATTR_DPIPE_ENTRY_ACTION_VALUES             = 0x26
+	DEVLINK_ATTR_DPIPE_ENTRY_COUNTER                   = 0x27
+	DEVLINK_ATTR_DPIPE_MATCH                           = 0x28
+	DEVLINK_ATTR_DPIPE_MATCH_VALUE                     = 0x29
+	DEVLINK_ATTR_DPIPE_MATCH_TYPE                      = 0x2a
+	DEVLINK_ATTR_DPIPE_ACTION                          = 0x2b
+	DEVLINK_ATTR_DPIPE_ACTION_VALUE                    = 0x2c
+	DEVLINK_ATTR_DPIPE_ACTION_TYPE                     = 0x2d
+	DEVLINK_ATTR_DPIPE_VALUE                           = 0x2e
+	DEVLINK_ATTR_DPIPE_VALUE_MASK                      = 0x2f
+	DEVLINK_ATTR_DPIPE_VALUE_MAPPING                   = 0x30
+	DEVLINK_ATTR_DPIPE_HEADERS                         = 0x31
+	DEVLINK_ATTR_DPIPE_HEADER                          = 0x32
+	DEVLINK_ATTR_DPIPE_HEADER_NAME                     = 0x33
+	DEVLINK_ATTR_DPIPE_HEADER_ID                       = 0x34
+	DEVLINK_ATTR_DPIPE_HEADER_FIELDS                   = 0x35
+	DEVLINK_ATTR_DPIPE_HEADER_GLOBAL                   = 0x36
+	DEVLINK_ATTR_DPIPE_HEADER_INDEX                    = 0x37
+	DEVLINK_ATTR_DPIPE_FIELD                           = 0x38
+	DEVLINK_ATTR_DPIPE_FIELD_NAME                      = 0x39
+	DEVLINK_ATTR_DPIPE_FIELD_ID                        = 0x3a
+	DEVLINK_ATTR_DPIPE_FIELD_BITWIDTH                  = 0x3b
+	DEVLINK_ATTR_DPIPE_FIELD_MAPPING_TYPE              = 0x3c
+	DEVLINK_ATTR_PAD                                   = 0x3d
+	DEVLINK_ATTR_ESWITCH_ENCAP_MODE                    = 0x3e
+	DEVLINK_ATTR_RESOURCE_LIST                         = 0x3f
+	DEVLINK_ATTR_RESOURCE                              = 0x40
+	DEVLINK_ATTR_RESOURCE_NAME                         = 0x41
+	DEVLINK_ATTR_RESOURCE_ID                           = 0x42
+	DEVLINK_ATTR_RESOURCE_SIZE                         = 0x43
+	DEVLINK_ATTR_RESOURCE_SIZE_NEW                     = 0x44
+	DEVLINK_ATTR_RESOURCE_SIZE_VALID                   = 0x45
+	DEVLINK_ATTR_RESOURCE_SIZE_MIN                     = 0x46
+	DEVLINK_ATTR_RESOURCE_SIZE_MAX                     = 0x47
+	DEVLINK_ATTR_RESOURCE_SIZE_GRAN                    = 0x48
+	DEVLINK_ATTR_RESOURCE_UNIT                         = 0x49
+	DEVLINK_ATTR_RESOURCE_OCC                          = 0x4a
+	DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_ID               = 0x4b
+	DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_UNITS            = 0x4c
+	DEVLINK_ATTR_PORT_FLAVOUR                          = 0x4d
+	DEVLINK_ATTR_PORT_NUMBER                           = 0x4e
+	DEVLINK_ATTR_PORT_SPLIT_SUBPORT_NUMBER             = 0x4f
+	DEVLINK_ATTR_PARAM                                 = 0x50
+	DEVLINK_ATTR_PARAM_NAME                            = 0x51
+	DEVLINK_ATTR_PARAM_GENERIC                         = 0x52
+	DEVLINK_ATTR_PARAM_TYPE                            = 0x53
+	DEVLINK_ATTR_PARAM_VALUES_LIST                     = 0x54
+	DEVLINK_ATTR_PARAM_VALUE                           = 0x55
+	DEVLINK_ATTR_PARAM_VALUE_DATA                      = 0x56
+	DEVLINK_ATTR_PARAM_VALUE_CMODE                     = 0x57
+	DEVLINK_ATTR_REGION_NAME                           = 0x58
+	DEVLINK_ATTR_REGION_SIZE                           = 0x59
+	DEVLINK_ATTR_REGION_SNAPSHOTS                      = 0x5a
+	DEVLINK_ATTR_REGION_SNAPSHOT                       = 0x5b
+	DEVLINK_ATTR_REGION_SNAPSHOT_ID                    = 0x5c
+	DEVLINK_ATTR_REGION_CHUNKS                         = 0x5d
+	DEVLINK_ATTR_REGION_CHUNK                          = 0x5e
+	DEVLINK_ATTR_REGION_CHUNK_DATA                     = 0x5f
+	DEVLINK_ATTR_REGION_CHUNK_ADDR                     = 0x60
+	DEVLINK_ATTR_REGION_CHUNK_LEN                      = 0x61
+	DEVLINK_ATTR_INFO_DRIVER_NAME                      = 0x62
+	DEVLINK_ATTR_INFO_SERIAL_NUMBER                    = 0x63
+	DEVLINK_ATTR_INFO_VERSION_FIXED                    = 0x64
+	DEVLINK_ATTR_INFO_VERSION_RUNNING                  = 0x65
+	DEVLINK_ATTR_INFO_VERSION_STORED                   = 0x66
+	DEVLINK_ATTR_INFO_VERSION_NAME                     = 0x67
+	DEVLINK_ATTR_INFO_VERSION_VALUE                    = 0x68
+	DEVLINK_ATTR_SB_POOL_CELL_SIZE                     = 0x69
+	DEVLINK_ATTR_FMSG                                  = 0x6a
+	DEVLINK_ATTR_FMSG_OBJ_NEST_START                   = 0x6b
+	DEVLINK_ATTR_FMSG_PAIR_NEST_START                  = 0x6c
+	DEVLINK_ATTR_FMSG_ARR_NEST_START                   = 0x6d
+	DEVLINK_ATTR_FMSG_NEST_END                         = 0x6e
+	DEVLINK_ATTR_FMSG_OBJ_NAME                         = 0x6f
+	DEVLINK_ATTR_FMSG_OBJ_VALUE_TYPE                   = 0x70
+	DEVLINK_ATTR_FMSG_OBJ_VALUE_DATA                   = 0x71
+	DEVLINK_ATTR_HEALTH_REPORTER                       = 0x72
+	DEVLINK_ATTR_HEALTH_REPORTER_NAME                  = 0x73
+	DEVLINK_ATTR_HEALTH_REPORTER_STATE                 = 0x74
+	DEVLINK_ATTR_HEALTH_REPORTER_ERR_COUNT             = 0x75
+	DEVLINK_ATTR_HEALTH_REPORTER_RECOVER_COUNT         = 0x76
+	DEVLINK_ATTR_HEALTH_REPORTER_DUMP_TS               = 0x77
+	DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD       = 0x78
+	DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER          = 0x79
+	DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME                = 0x7a
+	DEVLINK_ATTR_FLASH_UPDATE_COMPONENT                = 0x7b
+	DEVLINK_ATTR_FLASH_UPDATE_STATUS_MSG               = 0x7c
+	DEVLINK_ATTR_FLASH_UPDATE_STATUS_DONE              = 0x7d
+	DEVLINK_ATTR_FLASH_UPDATE_STATUS_TOTAL             = 0x7e
+	DEVLINK_ATTR_PORT_PCI_PF_NUMBER                    = 0x7f
+	DEVLINK_ATTR_PORT_PCI_VF_NUMBER                    = 0x80
+	DEVLINK_ATTR_STATS                                 = 0x81
+	DEVLINK_ATTR_TRAP_NAME                             = 0x82
+	DEVLINK_ATTR_TRAP_ACTION                           = 0x83
+	DEVLINK_ATTR_TRAP_TYPE                             = 0x84
+	DEVLINK_ATTR_TRAP_GENERIC                          = 0x85
+	DEVLINK_ATTR_TRAP_METADATA                         = 0x86
+	DEVLINK_ATTR_TRAP_GROUP_NAME                       = 0x87
+	DEVLINK_ATTR_RELOAD_FAILED                         = 0x88
+	DEVLINK_ATTR_HEALTH_REPORTER_DUMP_TS_NS            = 0x89
+	DEVLINK_ATTR_NETNS_FD                              = 0x8a
+	DEVLINK_ATTR_NETNS_PID                             = 0x8b
+	DEVLINK_ATTR_NETNS_ID                              = 0x8c
+	DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP             = 0x8d
+	DEVLINK_ATTR_TRAP_POLICER_ID                       = 0x8e
+	DEVLINK_ATTR_TRAP_POLICER_RATE                     = 0x8f
+	DEVLINK_ATTR_TRAP_POLICER_BURST                    = 0x90
+	DEVLINK_ATTR_PORT_FUNCTION                         = 0x91
+	DEVLINK_ATTR_INFO_BOARD_SERIAL_NUMBER              = 0x92
+	DEVLINK_ATTR_PORT_LANES                            = 0x93
+	DEVLINK_ATTR_PORT_SPLITTABLE                       = 0x94
+	DEVLINK_ATTR_PORT_EXTERNAL                         = 0x95
+	DEVLINK_ATTR_PORT_CONTROLLER_NUMBER                = 0x96
+	DEVLINK_ATTR_FLASH_UPDATE_STATUS_TIMEOUT           = 0x97
+	DEVLINK_ATTR_FLASH_UPDATE_OVERWRITE_MASK           = 0x98
+	DEVLINK_ATTR_RELOAD_ACTION                         = 0x99
+	DEVLINK_ATTR_RELOAD_ACTIONS_PERFORMED              = 0x9a
+	DEVLINK_ATTR_RELOAD_LIMITS                         = 0x9b
+	DEVLINK_ATTR_DEV_STATS                             = 0x9c
+	DEVLINK_ATTR_RELOAD_STATS                          = 0x9d
+	DEVLINK_ATTR_RELOAD_STATS_ENTRY                    = 0x9e
+	DEVLINK_ATTR_RELOAD_STATS_LIMIT                    = 0x9f
+	DEVLINK_ATTR_RELOAD_STATS_VALUE                    = 0xa0
+	DEVLINK_ATTR_REMOTE_RELOAD_STATS                   = 0xa1
+	DEVLINK_ATTR_RELOAD_ACTION_INFO                    = 0xa2
+	DEVLINK_ATTR_RELOAD_ACTION_STATS                   = 0xa3
+	DEVLINK_ATTR_MAX                                   = 0xa3
+	DEVLINK_DPIPE_FIELD_MAPPING_TYPE_NONE              = 0x0
+	DEVLINK_DPIPE_FIELD_MAPPING_TYPE_IFINDEX           = 0x1
+	DEVLINK_DPIPE_MATCH_TYPE_FIELD_EXACT               = 0x0
+	DEVLINK_DPIPE_ACTION_TYPE_FIELD_MODIFY             = 0x0
+	DEVLINK_DPIPE_FIELD_ETHERNET_DST_MAC               = 0x0
+	DEVLINK_DPIPE_FIELD_IPV4_DST_IP                    = 0x0
+	DEVLINK_DPIPE_FIELD_IPV6_DST_IP                    = 0x0
+	DEVLINK_DPIPE_HEADER_ETHERNET                      = 0x0
+	DEVLINK_DPIPE_HEADER_IPV4                          = 0x1
+	DEVLINK_DPIPE_HEADER_IPV6                          = 0x2
+	DEVLINK_RESOURCE_UNIT_ENTRY                        = 0x0
+	DEVLINK_PORT_FUNCTION_ATTR_UNSPEC                  = 0x0
+	DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR                 = 0x1
+	DEVLINK_PORT_FUNCTION_ATTR_MAX                     = 0x1
 )
 
 type FsverityDigest struct {
@@ -2999,3 +3223,461 @@ const (
 	MPLS_IPTUNNEL_TTL    = 0x2
 	MPLS_IPTUNNEL_MAX    = 0x2
 )
+
+const (
+	ETHTOOL_ID_UNSPEC                                                       = 0x0
+	ETHTOOL_RX_COPYBREAK                                                    = 0x1
+	ETHTOOL_TX_COPYBREAK                                                    = 0x2
+	ETHTOOL_PFC_PREVENTION_TOUT                                             = 0x3
+	ETHTOOL_TUNABLE_UNSPEC                                                  = 0x0
+	ETHTOOL_TUNABLE_U8                                                      = 0x1
+	ETHTOOL_TUNABLE_U16                                                     = 0x2
+	ETHTOOL_TUNABLE_U32                                                     = 0x3
+	ETHTOOL_TUNABLE_U64                                                     = 0x4
+	ETHTOOL_TUNABLE_STRING                                                  = 0x5
+	ETHTOOL_TUNABLE_S8                                                      = 0x6
+	ETHTOOL_TUNABLE_S16                                                     = 0x7
+	ETHTOOL_TUNABLE_S32                                                     = 0x8
+	ETHTOOL_TUNABLE_S64                                                     = 0x9
+	ETHTOOL_PHY_ID_UNSPEC                                                   = 0x0
+	ETHTOOL_PHY_DOWNSHIFT                                                   = 0x1
+	ETHTOOL_PHY_FAST_LINK_DOWN                                              = 0x2
+	ETHTOOL_PHY_EDPD                                                        = 0x3
+	ETHTOOL_LINK_EXT_STATE_AUTONEG                                          = 0x0
+	ETHTOOL_LINK_EXT_STATE_LINK_TRAINING_FAILURE                            = 0x1
+	ETHTOOL_LINK_EXT_STATE_LINK_LOGICAL_MISMATCH                            = 0x2
+	ETHTOOL_LINK_EXT_STATE_BAD_SIGNAL_INTEGRITY                             = 0x3
+	ETHTOOL_LINK_EXT_STATE_NO_CABLE                                         = 0x4
+	ETHTOOL_LINK_EXT_STATE_CABLE_ISSUE                                      = 0x5
+	ETHTOOL_LINK_EXT_STATE_EEPROM_ISSUE                                     = 0x6
+	ETHTOOL_LINK_EXT_STATE_CALIBRATION_FAILURE                              = 0x7
+	ETHTOOL_LINK_EXT_STATE_POWER_BUDGET_EXCEEDED                            = 0x8
+	ETHTOOL_LINK_EXT_STATE_OVERHEAT                                         = 0x9
+	ETHTOOL_LINK_EXT_SUBSTATE_AN_NO_PARTNER_DETECTED                        = 0x1
+	ETHTOOL_LINK_EXT_SUBSTATE_AN_ACK_NOT_RECEIVED                           = 0x2
+	ETHTOOL_LINK_EXT_SUBSTATE_AN_NEXT_PAGE_EXCHANGE_FAILED                  = 0x3
+	ETHTOOL_LINK_EXT_SUBSTATE_AN_NO_PARTNER_DETECTED_FORCE_MODE             = 0x4
+	ETHTOOL_LINK_EXT_SUBSTATE_AN_FEC_MISMATCH_DURING_OVERRIDE               = 0x5
+	ETHTOOL_LINK_EXT_SUBSTATE_AN_NO_HCD                                     = 0x6
+	ETHTOOL_LINK_EXT_SUBSTATE_LT_KR_FRAME_LOCK_NOT_ACQUIRED                 = 0x1
+	ETHTOOL_LINK_EXT_SUBSTATE_LT_KR_LINK_INHIBIT_TIMEOUT                    = 0x2
+	ETHTOOL_LINK_EXT_SUBSTATE_LT_KR_LINK_PARTNER_DID_NOT_SET_RECEIVER_READY = 0x3
+	ETHTOOL_LINK_EXT_SUBSTATE_LT_REMOTE_FAULT                               = 0x4
+	ETHTOOL_LINK_EXT_SUBSTATE_LLM_PCS_DID_NOT_ACQUIRE_BLOCK_LOCK            = 0x1
+	ETHTOOL_LINK_EXT_SUBSTATE_LLM_PCS_DID_NOT_ACQUIRE_AM_LOCK               = 0x2
+	ETHTOOL_LINK_EXT_SUBSTATE_LLM_PCS_DID_NOT_GET_ALIGN_STATUS              = 0x3
+	ETHTOOL_LINK_EXT_SUBSTATE_LLM_FC_FEC_IS_NOT_LOCKED                      = 0x4
+	ETHTOOL_LINK_EXT_SUBSTATE_LLM_RS_FEC_IS_NOT_LOCKED                      = 0x5
+	ETHTOOL_LINK_EXT_SUBSTATE_BSI_LARGE_NUMBER_OF_PHYSICAL_ERRORS           = 0x1
+	ETHTOOL_LINK_EXT_SUBSTATE_BSI_UNSUPPORTED_RATE                          = 0x2
+	ETHTOOL_LINK_EXT_SUBSTATE_CI_UNSUPPORTED_CABLE                          = 0x1
+	ETHTOOL_LINK_EXT_SUBSTATE_CI_CABLE_TEST_FAILURE                         = 0x2
+	ETHTOOL_FLASH_ALL_REGIONS                                               = 0x0
+	ETHTOOL_F_UNSUPPORTED__BIT                                              = 0x0
+	ETHTOOL_F_WISH__BIT                                                     = 0x1
+	ETHTOOL_F_COMPAT__BIT                                                   = 0x2
+	ETHTOOL_FEC_NONE_BIT                                                    = 0x0
+	ETHTOOL_FEC_AUTO_BIT                                                    = 0x1
+	ETHTOOL_FEC_OFF_BIT                                                     = 0x2
+	ETHTOOL_FEC_RS_BIT                                                      = 0x3
+	ETHTOOL_FEC_BASER_BIT                                                   = 0x4
+	ETHTOOL_FEC_LLRS_BIT                                                    = 0x5
+	ETHTOOL_LINK_MODE_10baseT_Half_BIT                                      = 0x0
+	ETHTOOL_LINK_MODE_10baseT_Full_BIT                                      = 0x1
+	ETHTOOL_LINK_MODE_100baseT_Half_BIT                                     = 0x2
+	ETHTOOL_LINK_MODE_100baseT_Full_BIT                                     = 0x3
+	ETHTOOL_LINK_MODE_1000baseT_Half_BIT                                    = 0x4
+	ETHTOOL_LINK_MODE_1000baseT_Full_BIT                                    = 0x5
+	ETHTOOL_LINK_MODE_Autoneg_BIT                                           = 0x6
+	ETHTOOL_LINK_MODE_TP_BIT                                                = 0x7
+	ETHTOOL_LINK_MODE_AUI_BIT                                               = 0x8
+	ETHTOOL_LINK_MODE_MII_BIT                                               = 0x9
+	ETHTOOL_LINK_MODE_FIBRE_BIT                                             = 0xa
+	ETHTOOL_LINK_MODE_BNC_BIT                                               = 0xb
+	ETHTOOL_LINK_MODE_10000baseT_Full_BIT                                   = 0xc
+	ETHTOOL_LINK_MODE_Pause_BIT                                             = 0xd
+	ETHTOOL_LINK_MODE_Asym_Pause_BIT                                        = 0xe
+	ETHTOOL_LINK_MODE_2500baseX_Full_BIT                                    = 0xf
+	ETHTOOL_LINK_MODE_Backplane_BIT                                         = 0x10
+	ETHTOOL_LINK_MODE_1000baseKX_Full_BIT                                   = 0x11
+	ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT                                 = 0x12
+	ETHTOOL_LINK_MODE_10000baseKR_Full_BIT                                  = 0x13
+	ETHTOOL_LINK_MODE_10000baseR_FEC_BIT                                    = 0x14
+	ETHTOOL_LINK_MODE_20000baseMLD2_Full_BIT                                = 0x15
+	ETHTOOL_LINK_MODE_20000baseKR2_Full_BIT                                 = 0x16
+	ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT                                 = 0x17
+	ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT                                 = 0x18
+	ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT                                 = 0x19
+	ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT                                 = 0x1a
+	ETHTOOL_LINK_MODE_56000baseKR4_Full_BIT                                 = 0x1b
+	ETHTOOL_LINK_MODE_56000baseCR4_Full_BIT                                 = 0x1c
+	ETHTOOL_LINK_MODE_56000baseSR4_Full_BIT                                 = 0x1d
+	ETHTOOL_LINK_MODE_56000baseLR4_Full_BIT                                 = 0x1e
+	ETHTOOL_LINK_MODE_25000baseCR_Full_BIT                                  = 0x1f
+	ETHTOOL_LINK_MODE_25000baseKR_Full_BIT                                  = 0x20
+	ETHTOOL_LINK_MODE_25000baseSR_Full_BIT                                  = 0x21
+	ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT                                 = 0x22
+	ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT                                 = 0x23
+	ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT                                = 0x24
+	ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT                                = 0x25
+	ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT                                = 0x26
+	ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT                            = 0x27
+	ETHTOOL_LINK_MODE_50000baseSR2_Full_BIT                                 = 0x28
+	ETHTOOL_LINK_MODE_1000baseX_Full_BIT                                    = 0x29
+	ETHTOOL_LINK_MODE_10000baseCR_Full_BIT                                  = 0x2a
+	ETHTOOL_LINK_MODE_10000baseSR_Full_BIT                                  = 0x2b
+	ETHTOOL_LINK_MODE_10000baseLR_Full_BIT                                  = 0x2c
+	ETHTOOL_LINK_MODE_10000baseLRM_Full_BIT                                 = 0x2d
+	ETHTOOL_LINK_MODE_10000baseER_Full_BIT                                  = 0x2e
+	ETHTOOL_LINK_MODE_2500baseT_Full_BIT                                    = 0x2f
+	ETHTOOL_LINK_MODE_5000baseT_Full_BIT                                    = 0x30
+	ETHTOOL_LINK_MODE_FEC_NONE_BIT                                          = 0x31
+	ETHTOOL_LINK_MODE_FEC_RS_BIT                                            = 0x32
+	ETHTOOL_LINK_MODE_FEC_BASER_BIT                                         = 0x33
+	ETHTOOL_LINK_MODE_50000baseKR_Full_BIT                                  = 0x34
+	ETHTOOL_LINK_MODE_50000baseSR_Full_BIT                                  = 0x35
+	ETHTOOL_LINK_MODE_50000baseCR_Full_BIT                                  = 0x36
+	ETHTOOL_LINK_MODE_50000baseLR_ER_FR_Full_BIT                            = 0x37
+	ETHTOOL_LINK_MODE_50000baseDR_Full_BIT                                  = 0x38
+	ETHTOOL_LINK_MODE_100000baseKR2_Full_BIT                                = 0x39
+	ETHTOOL_LINK_MODE_100000baseSR2_Full_BIT                                = 0x3a
+	ETHTOOL_LINK_MODE_100000baseCR2_Full_BIT                                = 0x3b
+	ETHTOOL_LINK_MODE_100000baseLR2_ER2_FR2_Full_BIT                        = 0x3c
+	ETHTOOL_LINK_MODE_100000baseDR2_Full_BIT                                = 0x3d
+	ETHTOOL_LINK_MODE_200000baseKR4_Full_BIT                                = 0x3e
+	ETHTOOL_LINK_MODE_200000baseSR4_Full_BIT                                = 0x3f
+	ETHTOOL_LINK_MODE_200000baseLR4_ER4_FR4_Full_BIT                        = 0x40
+	ETHTOOL_LINK_MODE_200000baseDR4_Full_BIT                                = 0x41
+	ETHTOOL_LINK_MODE_200000baseCR4_Full_BIT                                = 0x42
+	ETHTOOL_LINK_MODE_100baseT1_Full_BIT                                    = 0x43
+	ETHTOOL_LINK_MODE_1000baseT1_Full_BIT                                   = 0x44
+	ETHTOOL_LINK_MODE_400000baseKR8_Full_BIT                                = 0x45
+	ETHTOOL_LINK_MODE_400000baseSR8_Full_BIT                                = 0x46
+	ETHTOOL_LINK_MODE_400000baseLR8_ER8_FR8_Full_BIT                        = 0x47
+	ETHTOOL_LINK_MODE_400000baseDR8_Full_BIT                                = 0x48
+	ETHTOOL_LINK_MODE_400000baseCR8_Full_BIT                                = 0x49
+	ETHTOOL_LINK_MODE_FEC_LLRS_BIT                                          = 0x4a
+	ETHTOOL_LINK_MODE_100000baseKR_Full_BIT                                 = 0x4b
+	ETHTOOL_LINK_MODE_100000baseSR_Full_BIT                                 = 0x4c
+	ETHTOOL_LINK_MODE_100000baseLR_ER_FR_Full_BIT                           = 0x4d
+	ETHTOOL_LINK_MODE_100000baseCR_Full_BIT                                 = 0x4e
+	ETHTOOL_LINK_MODE_100000baseDR_Full_BIT                                 = 0x4f
+	ETHTOOL_LINK_MODE_200000baseKR2_Full_BIT                                = 0x50
+	ETHTOOL_LINK_MODE_200000baseSR2_Full_BIT                                = 0x51
+	ETHTOOL_LINK_MODE_200000baseLR2_ER2_FR2_Full_BIT                        = 0x52
+	ETHTOOL_LINK_MODE_200000baseDR2_Full_BIT                                = 0x53
+	ETHTOOL_LINK_MODE_200000baseCR2_Full_BIT                                = 0x54
+	ETHTOOL_LINK_MODE_400000baseKR4_Full_BIT                                = 0x55
+	ETHTOOL_LINK_MODE_400000baseSR4_Full_BIT                                = 0x56
+	ETHTOOL_LINK_MODE_400000baseLR4_ER4_FR4_Full_BIT                        = 0x57
+	ETHTOOL_LINK_MODE_400000baseDR4_Full_BIT                                = 0x58
+	ETHTOOL_LINK_MODE_400000baseCR4_Full_BIT                                = 0x59
+	ETHTOOL_LINK_MODE_100baseFX_Half_BIT                                    = 0x5a
+	ETHTOOL_LINK_MODE_100baseFX_Full_BIT                                    = 0x5b
+
+	ETHTOOL_MSG_USER_NONE                     = 0x0
+	ETHTOOL_MSG_STRSET_GET                    = 0x1
+	ETHTOOL_MSG_LINKINFO_GET                  = 0x2
+	ETHTOOL_MSG_LINKINFO_SET                  = 0x3
+	ETHTOOL_MSG_LINKMODES_GET                 = 0x4
+	ETHTOOL_MSG_LINKMODES_SET                 = 0x5
+	ETHTOOL_MSG_LINKSTATE_GET                 = 0x6
+	ETHTOOL_MSG_DEBUG_GET                     = 0x7
+	ETHTOOL_MSG_DEBUG_SET                     = 0x8
+	ETHTOOL_MSG_WOL_GET                       = 0x9
+	ETHTOOL_MSG_WOL_SET                       = 0xa
+	ETHTOOL_MSG_FEATURES_GET                  = 0xb
+	ETHTOOL_MSG_FEATURES_SET                  = 0xc
+	ETHTOOL_MSG_PRIVFLAGS_GET                 = 0xd
+	ETHTOOL_MSG_PRIVFLAGS_SET                 = 0xe
+	ETHTOOL_MSG_RINGS_GET                     = 0xf
+	ETHTOOL_MSG_RINGS_SET                     = 0x10
+	ETHTOOL_MSG_CHANNELS_GET                  = 0x11
+	ETHTOOL_MSG_CHANNELS_SET                  = 0x12
+	ETHTOOL_MSG_COALESCE_GET                  = 0x13
+	ETHTOOL_MSG_COALESCE_SET                  = 0x14
+	ETHTOOL_MSG_PAUSE_GET                     = 0x15
+	ETHTOOL_MSG_PAUSE_SET                     = 0x16
+	ETHTOOL_MSG_EEE_GET                       = 0x17
+	ETHTOOL_MSG_EEE_SET                       = 0x18
+	ETHTOOL_MSG_TSINFO_GET                    = 0x19
+	ETHTOOL_MSG_CABLE_TEST_ACT                = 0x1a
+	ETHTOOL_MSG_CABLE_TEST_TDR_ACT            = 0x1b
+	ETHTOOL_MSG_TUNNEL_INFO_GET               = 0x1c
+	ETHTOOL_MSG_USER_MAX                      = 0x1c
+	ETHTOOL_MSG_KERNEL_NONE                   = 0x0
+	ETHTOOL_MSG_STRSET_GET_REPLY              = 0x1
+	ETHTOOL_MSG_LINKINFO_GET_REPLY            = 0x2
+	ETHTOOL_MSG_LINKINFO_NTF                  = 0x3
+	ETHTOOL_MSG_LINKMODES_GET_REPLY           = 0x4
+	ETHTOOL_MSG_LINKMODES_NTF                 = 0x5
+	ETHTOOL_MSG_LINKSTATE_GET_REPLY           = 0x6
+	ETHTOOL_MSG_DEBUG_GET_REPLY               = 0x7
+	ETHTOOL_MSG_DEBUG_NTF                     = 0x8
+	ETHTOOL_MSG_WOL_GET_REPLY                 = 0x9
+	ETHTOOL_MSG_WOL_NTF                       = 0xa
+	ETHTOOL_MSG_FEATURES_GET_REPLY            = 0xb
+	ETHTOOL_MSG_FEATURES_SET_REPLY            = 0xc
+	ETHTOOL_MSG_FEATURES_NTF                  = 0xd
+	ETHTOOL_MSG_PRIVFLAGS_GET_REPLY           = 0xe
+	ETHTOOL_MSG_PRIVFLAGS_NTF                 = 0xf
+	ETHTOOL_MSG_RINGS_GET_REPLY               = 0x10
+	ETHTOOL_MSG_RINGS_NTF                     = 0x11
+	ETHTOOL_MSG_CHANNELS_GET_REPLY            = 0x12
+	ETHTOOL_MSG_CHANNELS_NTF                  = 0x13
+	ETHTOOL_MSG_COALESCE_GET_REPLY            = 0x14
+	ETHTOOL_MSG_COALESCE_NTF                  = 0x15
+	ETHTOOL_MSG_PAUSE_GET_REPLY               = 0x16
+	ETHTOOL_MSG_PAUSE_NTF                     = 0x17
+	ETHTOOL_MSG_EEE_GET_REPLY                 = 0x18
+	ETHTOOL_MSG_EEE_NTF                       = 0x19
+	ETHTOOL_MSG_TSINFO_GET_REPLY              = 0x1a
+	ETHTOOL_MSG_CABLE_TEST_NTF                = 0x1b
+	ETHTOOL_MSG_CABLE_TEST_TDR_NTF            = 0x1c
+	ETHTOOL_MSG_TUNNEL_INFO_GET_REPLY         = 0x1d
+	ETHTOOL_MSG_KERNEL_MAX                    = 0x1d
+	ETHTOOL_A_HEADER_UNSPEC                   = 0x0
+	ETHTOOL_A_HEADER_DEV_INDEX                = 0x1
+	ETHTOOL_A_HEADER_DEV_NAME                 = 0x2
+	ETHTOOL_A_HEADER_FLAGS                    = 0x3
+	ETHTOOL_A_HEADER_MAX                      = 0x3
+	ETHTOOL_A_BITSET_BIT_UNSPEC               = 0x0
+	ETHTOOL_A_BITSET_BIT_INDEX                = 0x1
+	ETHTOOL_A_BITSET_BIT_NAME                 = 0x2
+	ETHTOOL_A_BITSET_BIT_VALUE                = 0x3
+	ETHTOOL_A_BITSET_BIT_MAX                  = 0x3
+	ETHTOOL_A_BITSET_BITS_UNSPEC              = 0x0
+	ETHTOOL_A_BITSET_BITS_BIT                 = 0x1
+	ETHTOOL_A_BITSET_BITS_MAX                 = 0x1
+	ETHTOOL_A_BITSET_UNSPEC                   = 0x0
+	ETHTOOL_A_BITSET_NOMASK                   = 0x1
+	ETHTOOL_A_BITSET_SIZE                     = 0x2
+	ETHTOOL_A_BITSET_BITS                     = 0x3
+	ETHTOOL_A_BITSET_VALUE                    = 0x4
+	ETHTOOL_A_BITSET_MASK                     = 0x5
+	ETHTOOL_A_BITSET_MAX                      = 0x5
+	ETHTOOL_A_STRING_UNSPEC                   = 0x0
+	ETHTOOL_A_STRING_INDEX                    = 0x1
+	ETHTOOL_A_STRING_VALUE                    = 0x2
+	ETHTOOL_A_STRING_MAX                      = 0x2
+	ETHTOOL_A_STRINGS_UNSPEC                  = 0x0
+	ETHTOOL_A_STRINGS_STRING                  = 0x1
+	ETHTOOL_A_STRINGS_MAX                     = 0x1
+	ETHTOOL_A_STRINGSET_UNSPEC                = 0x0
+	ETHTOOL_A_STRINGSET_ID                    = 0x1
+	ETHTOOL_A_STRINGSET_COUNT                 = 0x2
+	ETHTOOL_A_STRINGSET_STRINGS               = 0x3
+	ETHTOOL_A_STRINGSET_MAX                   = 0x3
+	ETHTOOL_A_STRINGSETS_UNSPEC               = 0x0
+	ETHTOOL_A_STRINGSETS_STRINGSET            = 0x1
+	ETHTOOL_A_STRINGSETS_MAX                  = 0x1
+	ETHTOOL_A_STRSET_UNSPEC                   = 0x0
+	ETHTOOL_A_STRSET_HEADER                   = 0x1
+	ETHTOOL_A_STRSET_STRINGSETS               = 0x2
+	ETHTOOL_A_STRSET_COUNTS_ONLY              = 0x3
+	ETHTOOL_A_STRSET_MAX                      = 0x3
+	ETHTOOL_A_LINKINFO_UNSPEC                 = 0x0
+	ETHTOOL_A_LINKINFO_HEADER                 = 0x1
+	ETHTOOL_A_LINKINFO_PORT                   = 0x2
+	ETHTOOL_A_LINKINFO_PHYADDR                = 0x3
+	ETHTOOL_A_LINKINFO_TP_MDIX                = 0x4
+	ETHTOOL_A_LINKINFO_TP_MDIX_CTRL           = 0x5
+	ETHTOOL_A_LINKINFO_TRANSCEIVER            = 0x6
+	ETHTOOL_A_LINKINFO_MAX                    = 0x6
+	ETHTOOL_A_LINKMODES_UNSPEC                = 0x0
+	ETHTOOL_A_LINKMODES_HEADER                = 0x1
+	ETHTOOL_A_LINKMODES_AUTONEG               = 0x2
+	ETHTOOL_A_LINKMODES_OURS                  = 0x3
+	ETHTOOL_A_LINKMODES_PEER                  = 0x4
+	ETHTOOL_A_LINKMODES_SPEED                 = 0x5
+	ETHTOOL_A_LINKMODES_DUPLEX                = 0x6
+	ETHTOOL_A_LINKMODES_MASTER_SLAVE_CFG      = 0x7
+	ETHTOOL_A_LINKMODES_MASTER_SLAVE_STATE    = 0x8
+	ETHTOOL_A_LINKMODES_MAX                   = 0x8
+	ETHTOOL_A_LINKSTATE_UNSPEC                = 0x0
+	ETHTOOL_A_LINKSTATE_HEADER                = 0x1
+	ETHTOOL_A_LINKSTATE_LINK                  = 0x2
+	ETHTOOL_A_LINKSTATE_SQI                   = 0x3
+	ETHTOOL_A_LINKSTATE_SQI_MAX               = 0x4
+	ETHTOOL_A_LINKSTATE_EXT_STATE             = 0x5
+	ETHTOOL_A_LINKSTATE_EXT_SUBSTATE          = 0x6
+	ETHTOOL_A_LINKSTATE_MAX                   = 0x6
+	ETHTOOL_A_DEBUG_UNSPEC                    = 0x0
+	ETHTOOL_A_DEBUG_HEADER                    = 0x1
+	ETHTOOL_A_DEBUG_MSGMASK                   = 0x2
+	ETHTOOL_A_DEBUG_MAX                       = 0x2
+	ETHTOOL_A_WOL_UNSPEC                      = 0x0
+	ETHTOOL_A_WOL_HEADER                      = 0x1
+	ETHTOOL_A_WOL_MODES                       = 0x2
+	ETHTOOL_A_WOL_SOPASS                      = 0x3
+	ETHTOOL_A_WOL_MAX                         = 0x3
+	ETHTOOL_A_FEATURES_UNSPEC                 = 0x0
+	ETHTOOL_A_FEATURES_HEADER                 = 0x1
+	ETHTOOL_A_FEATURES_HW                     = 0x2
+	ETHTOOL_A_FEATURES_WANTED                 = 0x3
+	ETHTOOL_A_FEATURES_ACTIVE                 = 0x4
+	ETHTOOL_A_FEATURES_NOCHANGE               = 0x5
+	ETHTOOL_A_FEATURES_MAX                    = 0x5
+	ETHTOOL_A_PRIVFLAGS_UNSPEC                = 0x0
+	ETHTOOL_A_PRIVFLAGS_HEADER                = 0x1
+	ETHTOOL_A_PRIVFLAGS_FLAGS                 = 0x2
+	ETHTOOL_A_PRIVFLAGS_MAX                   = 0x2
+	ETHTOOL_A_RINGS_UNSPEC                    = 0x0
+	ETHTOOL_A_RINGS_HEADER                    = 0x1
+	ETHTOOL_A_RINGS_RX_MAX                    = 0x2
+	ETHTOOL_A_RINGS_RX_MINI_MAX               = 0x3
+	ETHTOOL_A_RINGS_RX_JUMBO_MAX              = 0x4
+	ETHTOOL_A_RINGS_TX_MAX                    = 0x5
+	ETHTOOL_A_RINGS_RX                        = 0x6
+	ETHTOOL_A_RINGS_RX_MINI                   = 0x7
+	ETHTOOL_A_RINGS_RX_JUMBO                  = 0x8
+	ETHTOOL_A_RINGS_TX                        = 0x9
+	ETHTOOL_A_RINGS_MAX                       = 0x9
+	ETHTOOL_A_CHANNELS_UNSPEC                 = 0x0
+	ETHTOOL_A_CHANNELS_HEADER                 = 0x1
+	ETHTOOL_A_CHANNELS_RX_MAX                 = 0x2
+	ETHTOOL_A_CHANNELS_TX_MAX                 = 0x3
+	ETHTOOL_A_CHANNELS_OTHER_MAX              = 0x4
+	ETHTOOL_A_CHANNELS_COMBINED_MAX           = 0x5
+	ETHTOOL_A_CHANNELS_RX_COUNT               = 0x6
+	ETHTOOL_A_CHANNELS_TX_COUNT               = 0x7
+	ETHTOOL_A_CHANNELS_OTHER_COUNT            = 0x8
+	ETHTOOL_A_CHANNELS_COMBINED_COUNT         = 0x9
+	ETHTOOL_A_CHANNELS_MAX                    = 0x9
+	ETHTOOL_A_COALESCE_UNSPEC                 = 0x0
+	ETHTOOL_A_COALESCE_HEADER                 = 0x1
+	ETHTOOL_A_COALESCE_RX_USECS               = 0x2
+	ETHTOOL_A_COALESCE_RX_MAX_FRAMES          = 0x3
+	ETHTOOL_A_COALESCE_RX_USECS_IRQ           = 0x4
+	ETHTOOL_A_COALESCE_RX_MAX_FRAMES_IRQ      = 0x5
+	ETHTOOL_A_COALESCE_TX_USECS               = 0x6
+	ETHTOOL_A_COALESCE_TX_MAX_FRAMES          = 0x7
+	ETHTOOL_A_COALESCE_TX_USECS_IRQ           = 0x8
+	ETHTOOL_A_COALESCE_TX_MAX_FRAMES_IRQ      = 0x9
+	ETHTOOL_A_COALESCE_STATS_BLOCK_USECS      = 0xa
+	ETHTOOL_A_COALESCE_USE_ADAPTIVE_RX        = 0xb
+	ETHTOOL_A_COALESCE_USE_ADAPTIVE_TX        = 0xc
+	ETHTOOL_A_COALESCE_PKT_RATE_LOW           = 0xd
+	ETHTOOL_A_COALESCE_RX_USECS_LOW           = 0xe
+	ETHTOOL_A_COALESCE_RX_MAX_FRAMES_LOW      = 0xf
+	ETHTOOL_A_COALESCE_TX_USECS_LOW           = 0x10
+	ETHTOOL_A_COALESCE_TX_MAX_FRAMES_LOW      = 0x11
+	ETHTOOL_A_COALESCE_PKT_RATE_HIGH          = 0x12
+	ETHTOOL_A_COALESCE_RX_USECS_HIGH          = 0x13
+	ETHTOOL_A_COALESCE_RX_MAX_FRAMES_HIGH     = 0x14
+	ETHTOOL_A_COALESCE_TX_USECS_HIGH          = 0x15
+	ETHTOOL_A_COALESCE_TX_MAX_FRAMES_HIGH     = 0x16
+	ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL   = 0x17
+	ETHTOOL_A_COALESCE_MAX                    = 0x17
+	ETHTOOL_A_PAUSE_UNSPEC                    = 0x0
+	ETHTOOL_A_PAUSE_HEADER                    = 0x1
+	ETHTOOL_A_PAUSE_AUTONEG                   = 0x2
+	ETHTOOL_A_PAUSE_RX                        = 0x3
+	ETHTOOL_A_PAUSE_TX                        = 0x4
+	ETHTOOL_A_PAUSE_STATS                     = 0x5
+	ETHTOOL_A_PAUSE_MAX                       = 0x5
+	ETHTOOL_A_PAUSE_STAT_UNSPEC               = 0x0
+	ETHTOOL_A_PAUSE_STAT_PAD                  = 0x1
+	ETHTOOL_A_PAUSE_STAT_TX_FRAMES            = 0x2
+	ETHTOOL_A_PAUSE_STAT_RX_FRAMES            = 0x3
+	ETHTOOL_A_PAUSE_STAT_MAX                  = 0x3
+	ETHTOOL_A_EEE_UNSPEC                      = 0x0
+	ETHTOOL_A_EEE_HEADER                      = 0x1
+	ETHTOOL_A_EEE_MODES_OURS                  = 0x2
+	ETHTOOL_A_EEE_MODES_PEER                  = 0x3
+	ETHTOOL_A_EEE_ACTIVE                      = 0x4
+	ETHTOOL_A_EEE_ENABLED                     = 0x5
+	ETHTOOL_A_EEE_TX_LPI_ENABLED              = 0x6
+	ETHTOOL_A_EEE_TX_LPI_TIMER                = 0x7
+	ETHTOOL_A_EEE_MAX                         = 0x7
+	ETHTOOL_A_TSINFO_UNSPEC                   = 0x0
+	ETHTOOL_A_TSINFO_HEADER                   = 0x1
+	ETHTOOL_A_TSINFO_TIMESTAMPING             = 0x2
+	ETHTOOL_A_TSINFO_TX_TYPES                 = 0x3
+	ETHTOOL_A_TSINFO_RX_FILTERS               = 0x4
+	ETHTOOL_A_TSINFO_PHC_INDEX                = 0x5
+	ETHTOOL_A_TSINFO_MAX                      = 0x5
+	ETHTOOL_A_CABLE_TEST_UNSPEC               = 0x0
+	ETHTOOL_A_CABLE_TEST_HEADER               = 0x1
+	ETHTOOL_A_CABLE_TEST_MAX                  = 0x1
+	ETHTOOL_A_CABLE_RESULT_CODE_UNSPEC        = 0x0
+	ETHTOOL_A_CABLE_RESULT_CODE_OK            = 0x1
+	ETHTOOL_A_CABLE_RESULT_CODE_OPEN          = 0x2
+	ETHTOOL_A_CABLE_RESULT_CODE_SAME_SHORT    = 0x3
+	ETHTOOL_A_CABLE_RESULT_CODE_CROSS_SHORT   = 0x4
+	ETHTOOL_A_CABLE_PAIR_A                    = 0x0
+	ETHTOOL_A_CABLE_PAIR_B                    = 0x1
+	ETHTOOL_A_CABLE_PAIR_C                    = 0x2
+	ETHTOOL_A_CABLE_PAIR_D                    = 0x3
+	ETHTOOL_A_CABLE_RESULT_UNSPEC             = 0x0
+	ETHTOOL_A_CABLE_RESULT_PAIR               = 0x1
+	ETHTOOL_A_CABLE_RESULT_CODE               = 0x2
+	ETHTOOL_A_CABLE_RESULT_MAX                = 0x2
+	ETHTOOL_A_CABLE_FAULT_LENGTH_UNSPEC       = 0x0
+	ETHTOOL_A_CABLE_FAULT_LENGTH_PAIR         = 0x1
+	ETHTOOL_A_CABLE_FAULT_LENGTH_CM           = 0x2
+	ETHTOOL_A_CABLE_FAULT_LENGTH_MAX          = 0x2
+	ETHTOOL_A_CABLE_TEST_NTF_STATUS_UNSPEC    = 0x0
+	ETHTOOL_A_CABLE_TEST_NTF_STATUS_STARTED   = 0x1
+	ETHTOOL_A_CABLE_TEST_NTF_STATUS_COMPLETED = 0x2
+	ETHTOOL_A_CABLE_NEST_UNSPEC               = 0x0
+	ETHTOOL_A_CABLE_NEST_RESULT               = 0x1
+	ETHTOOL_A_CABLE_NEST_FAULT_LENGTH         = 0x2
+	ETHTOOL_A_CABLE_NEST_MAX                  = 0x2
+	ETHTOOL_A_CABLE_TEST_NTF_UNSPEC           = 0x0
+	ETHTOOL_A_CABLE_TEST_NTF_HEADER           = 0x1
+	ETHTOOL_A_CABLE_TEST_NTF_STATUS           = 0x2
+	ETHTOOL_A_CABLE_TEST_NTF_NEST             = 0x3
+	ETHTOOL_A_CABLE_TEST_NTF_MAX              = 0x3
+	ETHTOOL_A_CABLE_TEST_TDR_CFG_UNSPEC       = 0x0
+	ETHTOOL_A_CABLE_TEST_TDR_CFG_FIRST        = 0x1
+	ETHTOOL_A_CABLE_TEST_TDR_CFG_LAST         = 0x2
+	ETHTOOL_A_CABLE_TEST_TDR_CFG_STEP         = 0x3
+	ETHTOOL_A_CABLE_TEST_TDR_CFG_PAIR         = 0x4
+	ETHTOOL_A_CABLE_TEST_TDR_CFG_MAX          = 0x4
+	ETHTOOL_A_CABLE_TEST_TDR_UNSPEC           = 0x0
+	ETHTOOL_A_CABLE_TEST_TDR_HEADER           = 0x1
+	ETHTOOL_A_CABLE_TEST_TDR_CFG              = 0x2
+	ETHTOOL_A_CABLE_TEST_TDR_MAX              = 0x2
+	ETHTOOL_A_CABLE_AMPLITUDE_UNSPEC          = 0x0
+	ETHTOOL_A_CABLE_AMPLITUDE_PAIR            = 0x1
+	ETHTOOL_A_CABLE_AMPLITUDE_mV              = 0x2
+	ETHTOOL_A_CABLE_AMPLITUDE_MAX             = 0x2
+	ETHTOOL_A_CABLE_PULSE_UNSPEC              = 0x0
+	ETHTOOL_A_CABLE_PULSE_mV                  = 0x1
+	ETHTOOL_A_CABLE_PULSE_MAX                 = 0x1
+	ETHTOOL_A_CABLE_STEP_UNSPEC               = 0x0
+	ETHTOOL_A_CABLE_STEP_FIRST_DISTANCE       = 0x1
+	ETHTOOL_A_CABLE_STEP_LAST_DISTANCE        = 0x2
+	ETHTOOL_A_CABLE_STEP_STEP_DISTANCE        = 0x3
+	ETHTOOL_A_CABLE_STEP_MAX                  = 0x3
+	ETHTOOL_A_CABLE_TDR_NEST_UNSPEC           = 0x0
+	ETHTOOL_A_CABLE_TDR_NEST_STEP             = 0x1
+	ETHTOOL_A_CABLE_TDR_NEST_AMPLITUDE        = 0x2
+	ETHTOOL_A_CABLE_TDR_NEST_PULSE            = 0x3
+	ETHTOOL_A_CABLE_TDR_NEST_MAX              = 0x3
+	ETHTOOL_A_CABLE_TEST_TDR_NTF_UNSPEC       = 0x0
+	ETHTOOL_A_CABLE_TEST_TDR_NTF_HEADER       = 0x1
+	ETHTOOL_A_CABLE_TEST_TDR_NTF_STATUS       = 0x2
+	ETHTOOL_A_CABLE_TEST_TDR_NTF_NEST         = 0x3
+	ETHTOOL_A_CABLE_TEST_TDR_NTF_MAX          = 0x3
+	ETHTOOL_UDP_TUNNEL_TYPE_VXLAN             = 0x0
+	ETHTOOL_UDP_TUNNEL_TYPE_GENEVE            = 0x1
+	ETHTOOL_UDP_TUNNEL_TYPE_VXLAN_GPE         = 0x2
+	ETHTOOL_A_TUNNEL_UDP_ENTRY_UNSPEC         = 0x0
+	ETHTOOL_A_TUNNEL_UDP_ENTRY_PORT           = 0x1
+	ETHTOOL_A_TUNNEL_UDP_ENTRY_TYPE           = 0x2
+	ETHTOOL_A_TUNNEL_UDP_ENTRY_MAX            = 0x2
+	ETHTOOL_A_TUNNEL_UDP_TABLE_UNSPEC         = 0x0
+	ETHTOOL_A_TUNNEL_UDP_TABLE_SIZE           = 0x1
+	ETHTOOL_A_TUNNEL_UDP_TABLE_TYPES          = 0x2
+	ETHTOOL_A_TUNNEL_UDP_TABLE_ENTRY          = 0x3
+	ETHTOOL_A_TUNNEL_UDP_TABLE_MAX            = 0x3
+	ETHTOOL_A_TUNNEL_UDP_UNSPEC               = 0x0
+	ETHTOOL_A_TUNNEL_UDP_TABLE                = 0x1
+	ETHTOOL_A_TUNNEL_UDP_MAX                  = 0x1
+	ETHTOOL_A_TUNNEL_INFO_UNSPEC              = 0x0
+	ETHTOOL_A_TUNNEL_INFO_HEADER              = 0x1
+	ETHTOOL_A_TUNNEL_INFO_UDP_PORTS           = 0x2
+	ETHTOOL_A_TUNNEL_INFO_MAX                 = 0x2
+)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_386.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_386.go
index d54618aa61..088bd77e3b 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_386.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include -m32 linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include -m32 /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build 386,linux
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go
index 741d25be95..078d958ec9 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include -m64 linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include -m64 /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build amd64,linux
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go
index e8d982c3df..2d39122f41 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build arm,linux
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go
index 311cf2155d..304cbd0453 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include -fsigned-char linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include -fsigned-char /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build arm64,linux
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go
index 1312bdf77f..7d9d57006a 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build mips,linux
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go
index 2a99348195..a1eb2577b0 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build mips64,linux
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go
index f964307b29..2e5ce3b6a6 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build mips64le,linux
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go
index ca0fab2702..bbaa1200b6 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build mipsle,linux
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go
index 257e004247..0e6e8a7748 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build ppc64,linux
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go
index 980dd31736..7382f385fa 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build ppc64le,linux
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
index d9fdab20b8..28d5522166 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build riscv64,linux
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go
index c25de8c679..a91a7a44bd 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include -fsigned-char linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include -fsigned-char /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build s390x,linux
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go
index 97fca65340..f824b2358d 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go
@@ -1,4 +1,4 @@
-// cgo -godefs -- -Wall -Werror -static -I/tmp/include linux/types.go | go run mkpost.go
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
 // +build sparc64,linux
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_386.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_386.go
index a89100c08a..3f11f88e3c 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_386.go
@@ -248,6 +248,7 @@ const (
 	SizeofSockaddrUnix     = 0x6a
 	SizeofSockaddrDatalink = 0x14
 	SizeofLinger           = 0x8
+	SizeofIovec            = 0x8
 	SizeofIPMreq           = 0x8
 	SizeofIPv6Mreq         = 0x14
 	SizeofMsghdr           = 0x1c
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_amd64.go
index 289184e0b3..0bed83af57 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_amd64.go
@@ -255,6 +255,7 @@ const (
 	SizeofSockaddrUnix     = 0x6a
 	SizeofSockaddrDatalink = 0x14
 	SizeofLinger           = 0x8
+	SizeofIovec            = 0x10
 	SizeofIPMreq           = 0x8
 	SizeofIPv6Mreq         = 0x14
 	SizeofMsghdr           = 0x30
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm.go
index 428c450e4c..e4e3bf736d 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm.go
@@ -253,6 +253,7 @@ const (
 	SizeofSockaddrUnix     = 0x6a
 	SizeofSockaddrDatalink = 0x14
 	SizeofLinger           = 0x8
+	SizeofIovec            = 0x8
 	SizeofIPMreq           = 0x8
 	SizeofIPv6Mreq         = 0x14
 	SizeofMsghdr           = 0x1c
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm64.go
index 6f1f2842cc..efac861bb7 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm64.go
@@ -255,6 +255,7 @@ const (
 	SizeofSockaddrUnix     = 0x6a
 	SizeofSockaddrDatalink = 0x14
 	SizeofLinger           = 0x8
+	SizeofIovec            = 0x10
 	SizeofIPMreq           = 0x8
 	SizeofIPv6Mreq         = 0x14
 	SizeofMsghdr           = 0x30
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_386.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_386.go
index 61ea0019a2..80fa295f1d 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_386.go
@@ -231,6 +231,7 @@ const (
 	SizeofSockaddrUnix     = 0x6a
 	SizeofSockaddrDatalink = 0x20
 	SizeofLinger           = 0x8
+	SizeofIovec            = 0x8
 	SizeofIPMreq           = 0x8
 	SizeofIPv6Mreq         = 0x14
 	SizeofMsghdr           = 0x1c
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_amd64.go
index 87a493f68f..560dd6d08a 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_amd64.go
@@ -235,6 +235,7 @@ const (
 	SizeofSockaddrUnix     = 0x6a
 	SizeofSockaddrDatalink = 0x20
 	SizeofLinger           = 0x8
+	SizeofIovec            = 0x10
 	SizeofIPMreq           = 0x8
 	SizeofIPv6Mreq         = 0x14
 	SizeofMsghdr           = 0x30
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm.go
index d80836efab..0c1700fa43 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm.go
@@ -235,6 +235,7 @@ const (
 	SizeofSockaddrUnix     = 0x6a
 	SizeofSockaddrDatalink = 0x20
 	SizeofLinger           = 0x8
+	SizeofIovec            = 0x8
 	SizeofIPMreq           = 0x8
 	SizeofIPv6Mreq         = 0x14
 	SizeofMsghdr           = 0x1c
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm64.go
index 4e158746f1..5b3e46633e 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm64.go
@@ -231,6 +231,7 @@ const (
 	SizeofSockaddrUnix     = 0x6a
 	SizeofSockaddrDatalink = 0x20
 	SizeofLinger           = 0x8
+	SizeofIovec            = 0x10
 	SizeofIPMreq           = 0x8
 	SizeofIPv6Mreq         = 0x14
 	SizeofMsghdr           = 0x30
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_mips64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_mips64.go
index 992a1f8c01..62bff16709 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_mips64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_mips64.go
@@ -231,6 +231,7 @@ const (
 	SizeofSockaddrUnix     = 0x6a
 	SizeofSockaddrDatalink = 0x20
 	SizeofLinger           = 0x8
+	SizeofIovec            = 0x10
 	SizeofIPMreq           = 0x8
 	SizeofIPv6Mreq         = 0x14
 	SizeofMsghdr           = 0x30
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_solaris_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_solaris_amd64.go
index db817f3ba8..ca512aff7f 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_solaris_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_solaris_amd64.go
@@ -234,6 +234,7 @@ const (
 	SizeofSockaddrUnix     = 0x6e
 	SizeofSockaddrDatalink = 0xfc
 	SizeofLinger           = 0x8
+	SizeofIovec            = 0x10
 	SizeofIPMreq           = 0x8
 	SizeofIPv6Mreq         = 0x14
 	SizeofMsghdr           = 0x30
diff --git a/src/cmd/vendor/golang.org/x/sys/windows/syscall_windows.go b/src/cmd/vendor/golang.org/x/sys/windows/syscall_windows.go
index c71bad127d..0197df8727 100644
--- a/src/cmd/vendor/golang.org/x/sys/windows/syscall_windows.go
+++ b/src/cmd/vendor/golang.org/x/sys/windows/syscall_windows.go
@@ -18,9 +18,11 @@ import (
 )
 
 type Handle uintptr
+type HWND uintptr
 
 const (
 	InvalidHandle = ^Handle(0)
+	InvalidHWND   = ^HWND(0)
 
 	// Flags for DefineDosDevice.
 	DDD_EXACT_MATCH_ON_REMOVE = 0x00000004
@@ -214,6 +216,10 @@ func NewCallbackCDecl(fn interface{}) uintptr {
 //sys	CreateProcess(appName *uint16, commandLine *uint16, procSecurity *SecurityAttributes, threadSecurity *SecurityAttributes, inheritHandles bool, creationFlags uint32, env *uint16, currentDir *uint16, startupInfo *StartupInfo, outProcInfo *ProcessInformation) (err error) = CreateProcessW
 //sys	OpenProcess(desiredAccess uint32, inheritHandle bool, processId uint32) (handle Handle, err error)
 //sys	ShellExecute(hwnd Handle, verb *uint16, file *uint16, args *uint16, cwd *uint16, showCmd int32) (err error) [failretval<=32] = shell32.ShellExecuteW
+//sys	GetWindowThreadProcessId(hwnd HWND, pid *uint32) (tid uint32, err error) = user32.GetWindowThreadProcessId
+//sys	GetShellWindow() (shellWindow HWND) = user32.GetShellWindow
+//sys	MessageBox(hwnd HWND, text *uint16, caption *uint16, boxtype uint32) (ret int32, err error) [failretval==0] = user32.MessageBoxW
+//sys	ExitWindowsEx(flags uint32, reason uint32) (err error) = user32.ExitWindowsEx
 //sys	shGetKnownFolderPath(id *KNOWNFOLDERID, flags uint32, token Token, path **uint16) (ret error) = shell32.SHGetKnownFolderPath
 //sys	TerminateProcess(handle Handle, exitcode uint32) (err error)
 //sys	GetExitCodeProcess(handle Handle, exitcode *uint32) (err error)
@@ -259,22 +265,35 @@ func NewCallbackCDecl(fn interface{}) uintptr {
 //sys	VirtualProtect(address uintptr, size uintptr, newprotect uint32, oldprotect *uint32) (err error) = kernel32.VirtualProtect
 //sys	TransmitFile(s Handle, handle Handle, bytesToWrite uint32, bytsPerSend uint32, overlapped *Overlapped, transmitFileBuf *TransmitFileBuffers, flags uint32) (err error) = mswsock.TransmitFile
 //sys	ReadDirectoryChanges(handle Handle, buf *byte, buflen uint32, watchSubTree bool, mask uint32, retlen *uint32, overlapped *Overlapped, completionRoutine uintptr) (err error) = kernel32.ReadDirectoryChangesW
+//sys	FindFirstChangeNotification(path string, watchSubtree bool, notifyFilter uint32) (handle Handle, err error) [failretval==InvalidHandle] = kernel32.FindFirstChangeNotificationW
+//sys	FindNextChangeNotification(handle Handle) (err error)
+//sys	FindCloseChangeNotification(handle Handle) (err error)
 //sys	CertOpenSystemStore(hprov Handle, name *uint16) (store Handle, err error) = crypt32.CertOpenSystemStoreW
-//sys   CertOpenStore(storeProvider uintptr, msgAndCertEncodingType uint32, cryptProv uintptr, flags uint32, para uintptr) (handle Handle, err error) = crypt32.CertOpenStore
+//sys	CertOpenStore(storeProvider uintptr, msgAndCertEncodingType uint32, cryptProv uintptr, flags uint32, para uintptr) (handle Handle, err error) = crypt32.CertOpenStore
 //sys	CertEnumCertificatesInStore(store Handle, prevContext *CertContext) (context *CertContext, err error) [failretval==nil] = crypt32.CertEnumCertificatesInStore
-//sys   CertAddCertificateContextToStore(store Handle, certContext *CertContext, addDisposition uint32, storeContext **CertContext) (err error) = crypt32.CertAddCertificateContextToStore
+//sys	CertAddCertificateContextToStore(store Handle, certContext *CertContext, addDisposition uint32, storeContext **CertContext) (err error) = crypt32.CertAddCertificateContextToStore
 //sys	CertCloseStore(store Handle, flags uint32) (err error) = crypt32.CertCloseStore
 //sys	CertDeleteCertificateFromStore(certContext *CertContext) (err error) = crypt32.CertDeleteCertificateFromStore
-//sys   CertGetCertificateChain(engine Handle, leaf *CertContext, time *Filetime, additionalStore Handle, para *CertChainPara, flags uint32, reserved uintptr, chainCtx **CertChainContext) (err error) = crypt32.CertGetCertificateChain
-//sys   CertFreeCertificateChain(ctx *CertChainContext) = crypt32.CertFreeCertificateChain
-//sys   CertCreateCertificateContext(certEncodingType uint32, certEncoded *byte, encodedLen uint32) (context *CertContext, err error) [failretval==nil] = crypt32.CertCreateCertificateContext
-//sys   CertFreeCertificateContext(ctx *CertContext) (err error) = crypt32.CertFreeCertificateContext
-//sys   CertVerifyCertificateChainPolicy(policyOID uintptr, chain *CertChainContext, para *CertChainPolicyPara, status *CertChainPolicyStatus) (err error) = crypt32.CertVerifyCertificateChainPolicy
+//sys	CertDuplicateCertificateContext(certContext *CertContext) (dupContext *CertContext) = crypt32.CertDuplicateCertificateContext
+//sys	PFXImportCertStore(pfx *CryptDataBlob, password *uint16, flags uint32) (store Handle, err error) = crypt32.PFXImportCertStore
+//sys	CertGetCertificateChain(engine Handle, leaf *CertContext, time *Filetime, additionalStore Handle, para *CertChainPara, flags uint32, reserved uintptr, chainCtx **CertChainContext) (err error) = crypt32.CertGetCertificateChain
+//sys	CertFreeCertificateChain(ctx *CertChainContext) = crypt32.CertFreeCertificateChain
+//sys	CertCreateCertificateContext(certEncodingType uint32, certEncoded *byte, encodedLen uint32) (context *CertContext, err error) [failretval==nil] = crypt32.CertCreateCertificateContext
+//sys	CertFreeCertificateContext(ctx *CertContext) (err error) = crypt32.CertFreeCertificateContext
+//sys	CertVerifyCertificateChainPolicy(policyOID uintptr, chain *CertChainContext, para *CertChainPolicyPara, status *CertChainPolicyStatus) (err error) = crypt32.CertVerifyCertificateChainPolicy
+//sys	CertGetNameString(certContext *CertContext, nameType uint32, flags uint32, typePara unsafe.Pointer, name *uint16, size uint32) (chars uint32) = crypt32.CertGetNameStringW
+//sys	CertFindExtension(objId *byte, countExtensions uint32, extensions *CertExtension) (ret *CertExtension) = crypt32.CertFindExtension
+//sys	CryptQueryObject(objectType uint32, object unsafe.Pointer, expectedContentTypeFlags uint32, expectedFormatTypeFlags uint32, flags uint32, msgAndCertEncodingType *uint32, contentType *uint32, formatType *uint32, certStore *Handle, msg *Handle, context *unsafe.Pointer) (err error) = crypt32.CryptQueryObject
+//sys	CryptDecodeObject(encodingType uint32, structType *byte, encodedBytes *byte, lenEncodedBytes uint32, flags uint32, decoded unsafe.Pointer, decodedLen *uint32) (err error) = crypt32.CryptDecodeObject
+//sys	CryptProtectData(dataIn *DataBlob, name *uint16, optionalEntropy *DataBlob, reserved uintptr, promptStruct *CryptProtectPromptStruct, flags uint32, dataOut *DataBlob) (err error) = crypt32.CryptProtectData
+//sys	CryptUnprotectData(dataIn *DataBlob, name **uint16, optionalEntropy *DataBlob, reserved uintptr, promptStruct *CryptProtectPromptStruct, flags uint32, dataOut *DataBlob) (err error) = crypt32.CryptUnprotectData
+//sys	WinVerifyTrustEx(hwnd HWND, actionId *GUID, data *WinTrustData) (ret error) = wintrust.WinVerifyTrustEx
 //sys	RegOpenKeyEx(key Handle, subkey *uint16, options uint32, desiredAccess uint32, result *Handle) (regerrno error) = advapi32.RegOpenKeyExW
 //sys	RegCloseKey(key Handle) (regerrno error) = advapi32.RegCloseKey
 //sys	RegQueryInfoKey(key Handle, class *uint16, classLen *uint32, reserved *uint32, subkeysLen *uint32, maxSubkeyLen *uint32, maxClassLen *uint32, valuesLen *uint32, maxValueNameLen *uint32, maxValueLen *uint32, saLen *uint32, lastWriteTime *Filetime) (regerrno error) = advapi32.RegQueryInfoKeyW
 //sys	RegEnumKeyEx(key Handle, index uint32, name *uint16, nameLen *uint32, reserved *uint32, class *uint16, classLen *uint32, lastWriteTime *Filetime) (regerrno error) = advapi32.RegEnumKeyExW
 //sys	RegQueryValueEx(key Handle, name *uint16, reserved *uint32, valtype *uint32, buf *byte, buflen *uint32) (regerrno error) = advapi32.RegQueryValueExW
+//sys	RegNotifyChangeKeyValue(key Handle, watchSubtree bool, notifyFilter uint32, event Handle, asynchronous bool) (regerrno error) = advapi32.RegNotifyChangeKeyValue
 //sys	GetCurrentProcessId() (pid uint32) = kernel32.GetCurrentProcessId
 //sys	ProcessIdToSessionId(pid uint32, sessionid *uint32) (err error) = kernel32.ProcessIdToSessionId
 //sys	GetConsoleMode(console Handle, mode *uint32) (err error) = kernel32.GetConsoleMode
@@ -341,8 +360,6 @@ func NewCallbackCDecl(fn interface{}) uintptr {
 //sys	QueryDosDevice(deviceName *uint16, targetPath *uint16, max uint32) (n uint32, err error) [failretval==0] = QueryDosDeviceW
 //sys	SetVolumeLabel(rootPathName *uint16, volumeName *uint16) (err error) = SetVolumeLabelW
 //sys	SetVolumeMountPoint(volumeMountPoint *uint16, volumeName *uint16) (err error) = SetVolumeMountPointW
-//sys	MessageBox(hwnd Handle, text *uint16, caption *uint16, boxtype uint32) (ret int32, err error) [failretval==0] = user32.MessageBoxW
-//sys	ExitWindowsEx(flags uint32, reason uint32) (err error) = user32.ExitWindowsEx
 //sys	InitiateSystemShutdownEx(machineName *uint16, message *uint16, timeout uint32, forceAppsClosed bool, rebootAfterShutdown bool, reason uint32) (err error) = advapi32.InitiateSystemShutdownExW
 //sys	SetProcessShutdownParameters(level uint32, flags uint32) (err error) = kernel32.SetProcessShutdownParameters
 //sys	GetProcessShutdownParameters(level *uint32, flags *uint32) (err error) = kernel32.GetProcessShutdownParameters
diff --git a/src/cmd/vendor/golang.org/x/sys/windows/types_windows.go b/src/cmd/vendor/golang.org/x/sys/windows/types_windows.go
index 265d797cac..fd4260762a 100644
--- a/src/cmd/vendor/golang.org/x/sys/windows/types_windows.go
+++ b/src/cmd/vendor/golang.org/x/sys/windows/types_windows.go
@@ -227,7 +227,7 @@ const (
 )
 
 const (
-	// filters for ReadDirectoryChangesW
+	// filters for ReadDirectoryChangesW and FindFirstChangeNotificationW
 	FILE_NOTIFY_CHANGE_FILE_NAME   = 0x001
 	FILE_NOTIFY_CHANGE_DIR_NAME    = 0x002
 	FILE_NOTIFY_CHANGE_ATTRIBUTES  = 0x004
@@ -249,24 +249,27 @@ const (
 
 const (
 	// wincrypt.h
-	PROV_RSA_FULL                    = 1
-	PROV_RSA_SIG                     = 2
-	PROV_DSS                         = 3
-	PROV_FORTEZZA                    = 4
-	PROV_MS_EXCHANGE                 = 5
-	PROV_SSL                         = 6
-	PROV_RSA_SCHANNEL                = 12
-	PROV_DSS_DH                      = 13
-	PROV_EC_ECDSA_SIG                = 14
-	PROV_EC_ECNRA_SIG                = 15
-	PROV_EC_ECDSA_FULL               = 16
-	PROV_EC_ECNRA_FULL               = 17
-	PROV_DH_SCHANNEL                 = 18
-	PROV_SPYRUS_LYNKS                = 20
-	PROV_RNG                         = 21
-	PROV_INTEL_SEC                   = 22
-	PROV_REPLACE_OWF                 = 23
-	PROV_RSA_AES                     = 24
+	/* certenrolld_begin -- PROV_RSA_*/
+	PROV_RSA_FULL      = 1
+	PROV_RSA_SIG       = 2
+	PROV_DSS           = 3
+	PROV_FORTEZZA      = 4
+	PROV_MS_EXCHANGE   = 5
+	PROV_SSL           = 6
+	PROV_RSA_SCHANNEL  = 12
+	PROV_DSS_DH        = 13
+	PROV_EC_ECDSA_SIG  = 14
+	PROV_EC_ECNRA_SIG  = 15
+	PROV_EC_ECDSA_FULL = 16
+	PROV_EC_ECNRA_FULL = 17
+	PROV_DH_SCHANNEL   = 18
+	PROV_SPYRUS_LYNKS  = 20
+	PROV_RNG           = 21
+	PROV_INTEL_SEC     = 22
+	PROV_REPLACE_OWF   = 23
+	PROV_RSA_AES       = 24
+
+	/* dwFlags definitions for CryptAcquireContext */
 	CRYPT_VERIFYCONTEXT              = 0xF0000000
 	CRYPT_NEWKEYSET                  = 0x00000008
 	CRYPT_DELETEKEYSET               = 0x00000010
@@ -274,6 +277,17 @@ const (
 	CRYPT_SILENT                     = 0x00000040
 	CRYPT_DEFAULT_CONTAINER_OPTIONAL = 0x00000080
 
+	/* Flags for PFXImportCertStore */
+	CRYPT_EXPORTABLE                   = 0x00000001
+	CRYPT_USER_PROTECTED               = 0x00000002
+	CRYPT_USER_KEYSET                  = 0x00001000
+	PKCS12_PREFER_CNG_KSP              = 0x00000100
+	PKCS12_ALWAYS_CNG_KSP              = 0x00000200
+	PKCS12_ALLOW_OVERWRITE_KEY         = 0x00004000
+	PKCS12_NO_PERSIST_KEY              = 0x00008000
+	PKCS12_INCLUDE_EXTENDED_PROPERTIES = 0x00000010
+
+	/* Default usage match type is AND with value zero */
 	USAGE_MATCH_TYPE_AND = 0
 	USAGE_MATCH_TYPE_OR  = 1
 
@@ -409,6 +423,71 @@ const (
 	CERT_CHAIN_POLICY_EV                = 8
 	CERT_CHAIN_POLICY_SSL_F12           = 9
 
+	/* Certificate Store close flags */
+	CERT_CLOSE_STORE_FORCE_FLAG = 0x00000001
+	CERT_CLOSE_STORE_CHECK_FLAG = 0x00000002
+
+	/* CryptQueryObject object type */
+	CERT_QUERY_OBJECT_FILE = 1
+	CERT_QUERY_OBJECT_BLOB = 2
+
+	/* CryptQueryObject content type flags */
+	CERT_QUERY_CONTENT_CERT                    = 1
+	CERT_QUERY_CONTENT_CTL                     = 2
+	CERT_QUERY_CONTENT_CRL                     = 3
+	CERT_QUERY_CONTENT_SERIALIZED_STORE        = 4
+	CERT_QUERY_CONTENT_SERIALIZED_CERT         = 5
+	CERT_QUERY_CONTENT_SERIALIZED_CTL          = 6
+	CERT_QUERY_CONTENT_SERIALIZED_CRL          = 7
+	CERT_QUERY_CONTENT_PKCS7_SIGNED            = 8
+	CERT_QUERY_CONTENT_PKCS7_UNSIGNED          = 9
+	CERT_QUERY_CONTENT_PKCS7_SIGNED_EMBED      = 10
+	CERT_QUERY_CONTENT_PKCS10                  = 11
+	CERT_QUERY_CONTENT_PFX                     = 12
+	CERT_QUERY_CONTENT_CERT_PAIR               = 13
+	CERT_QUERY_CONTENT_PFX_AND_LOAD            = 14
+	CERT_QUERY_CONTENT_FLAG_CERT               = (1 << CERT_QUERY_CONTENT_CERT)
+	CERT_QUERY_CONTENT_FLAG_CTL                = (1 << CERT_QUERY_CONTENT_CTL)
+	CERT_QUERY_CONTENT_FLAG_CRL                = (1 << CERT_QUERY_CONTENT_CRL)
+	CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE   = (1 << CERT_QUERY_CONTENT_SERIALIZED_STORE)
+	CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT    = (1 << CERT_QUERY_CONTENT_SERIALIZED_CERT)
+	CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL     = (1 << CERT_QUERY_CONTENT_SERIALIZED_CTL)
+	CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL     = (1 << CERT_QUERY_CONTENT_SERIALIZED_CRL)
+	CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED       = (1 << CERT_QUERY_CONTENT_PKCS7_SIGNED)
+	CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED     = (1 << CERT_QUERY_CONTENT_PKCS7_UNSIGNED)
+	CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED = (1 << CERT_QUERY_CONTENT_PKCS7_SIGNED_EMBED)
+	CERT_QUERY_CONTENT_FLAG_PKCS10             = (1 << CERT_QUERY_CONTENT_PKCS10)
+	CERT_QUERY_CONTENT_FLAG_PFX                = (1 << CERT_QUERY_CONTENT_PFX)
+	CERT_QUERY_CONTENT_FLAG_CERT_PAIR          = (1 << CERT_QUERY_CONTENT_CERT_PAIR)
+	CERT_QUERY_CONTENT_FLAG_PFX_AND_LOAD       = (1 << CERT_QUERY_CONTENT_PFX_AND_LOAD)
+	CERT_QUERY_CONTENT_FLAG_ALL                = (CERT_QUERY_CONTENT_FLAG_CERT | CERT_QUERY_CONTENT_FLAG_CTL | CERT_QUERY_CONTENT_FLAG_CRL | CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE | CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT | CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL | CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL | CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED | CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED | CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED | CERT_QUERY_CONTENT_FLAG_PKCS10 | CERT_QUERY_CONTENT_FLAG_PFX | CERT_QUERY_CONTENT_FLAG_CERT_PAIR)
+	CERT_QUERY_CONTENT_FLAG_ALL_ISSUER_CERT    = (CERT_QUERY_CONTENT_FLAG_CERT | CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE | CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT | CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED | CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED)
+
+	/* CryptQueryObject format type flags */
+	CERT_QUERY_FORMAT_BINARY                     = 1
+	CERT_QUERY_FORMAT_BASE64_ENCODED             = 2
+	CERT_QUERY_FORMAT_ASN_ASCII_HEX_ENCODED      = 3
+	CERT_QUERY_FORMAT_FLAG_BINARY                = (1 << CERT_QUERY_FORMAT_BINARY)
+	CERT_QUERY_FORMAT_FLAG_BASE64_ENCODED        = (1 << CERT_QUERY_FORMAT_BASE64_ENCODED)
+	CERT_QUERY_FORMAT_FLAG_ASN_ASCII_HEX_ENCODED = (1 << CERT_QUERY_FORMAT_ASN_ASCII_HEX_ENCODED)
+	CERT_QUERY_FORMAT_FLAG_ALL                   = (CERT_QUERY_FORMAT_FLAG_BINARY | CERT_QUERY_FORMAT_FLAG_BASE64_ENCODED | CERT_QUERY_FORMAT_FLAG_ASN_ASCII_HEX_ENCODED)
+
+	/* CertGetNameString name types */
+	CERT_NAME_EMAIL_TYPE            = 1
+	CERT_NAME_RDN_TYPE              = 2
+	CERT_NAME_ATTR_TYPE             = 3
+	CERT_NAME_SIMPLE_DISPLAY_TYPE   = 4
+	CERT_NAME_FRIENDLY_DISPLAY_TYPE = 5
+	CERT_NAME_DNS_TYPE              = 6
+	CERT_NAME_URL_TYPE              = 7
+	CERT_NAME_UPN_TYPE              = 8
+
+	/* CertGetNameString flags */
+	CERT_NAME_ISSUER_FLAG              = 0x1
+	CERT_NAME_DISABLE_IE4_UTF8_FLAG    = 0x10000
+	CERT_NAME_SEARCH_ALL_NAMES_FLAG    = 0x2
+	CERT_NAME_STR_ENABLE_PUNYCODE_FLAG = 0x00200000
+
 	/* AuthType values for SSLExtraCertChainPolicyPara struct */
 	AUTHTYPE_CLIENT = 1
 	AUTHTYPE_SERVER = 2
@@ -419,6 +498,22 @@ const (
 	SECURITY_FLAG_IGNORE_WRONG_USAGE       = 0x00000200
 	SECURITY_FLAG_IGNORE_CERT_CN_INVALID   = 0x00001000
 	SECURITY_FLAG_IGNORE_CERT_DATE_INVALID = 0x00002000
+
+	/* Flags for Crypt[Un]ProtectData */
+	CRYPTPROTECT_UI_FORBIDDEN      = 0x1
+	CRYPTPROTECT_LOCAL_MACHINE     = 0x4
+	CRYPTPROTECT_CRED_SYNC         = 0x8
+	CRYPTPROTECT_AUDIT             = 0x10
+	CRYPTPROTECT_NO_RECOVERY       = 0x20
+	CRYPTPROTECT_VERIFY_PROTECTION = 0x40
+	CRYPTPROTECT_CRED_REGENERATE   = 0x80
+
+	/* Flags for CryptProtectPromptStruct */
+	CRYPTPROTECT_PROMPT_ON_UNPROTECT   = 1
+	CRYPTPROTECT_PROMPT_ON_PROTECT     = 2
+	CRYPTPROTECT_PROMPT_RESERVED       = 4
+	CRYPTPROTECT_PROMPT_STRONG         = 8
+	CRYPTPROTECT_PROMPT_REQUIRE_STRONG = 16
 )
 
 const (
@@ -441,10 +536,58 @@ const (
 	REALTIME_PRIORITY_CLASS       = 0x00000100
 )
 
+/* wintrust.h constants for WinVerifyTrustEx */
+const (
+	WTD_UI_ALL    = 1
+	WTD_UI_NONE   = 2
+	WTD_UI_NOBAD  = 3
+	WTD_UI_NOGOOD = 4
+
+	WTD_REVOKE_NONE       = 0
+	WTD_REVOKE_WHOLECHAIN = 1
+
+	WTD_CHOICE_FILE    = 1
+	WTD_CHOICE_CATALOG = 2
+	WTD_CHOICE_BLOB    = 3
+	WTD_CHOICE_SIGNER  = 4
+	WTD_CHOICE_CERT    = 5
+
+	WTD_STATEACTION_IGNORE           = 0x00000000
+	WTD_STATEACTION_VERIFY           = 0x00000010
+	WTD_STATEACTION_CLOSE            = 0x00000002
+	WTD_STATEACTION_AUTO_CACHE       = 0x00000003
+	WTD_STATEACTION_AUTO_CACHE_FLUSH = 0x00000004
+
+	WTD_USE_IE4_TRUST_FLAG                  = 0x1
+	WTD_NO_IE4_CHAIN_FLAG                   = 0x2
+	WTD_NO_POLICY_USAGE_FLAG                = 0x4
+	WTD_REVOCATION_CHECK_NONE               = 0x10
+	WTD_REVOCATION_CHECK_END_CERT           = 0x20
+	WTD_REVOCATION_CHECK_CHAIN              = 0x40
+	WTD_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT = 0x80
+	WTD_SAFER_FLAG                          = 0x100
+	WTD_HASH_ONLY_FLAG                      = 0x200
+	WTD_USE_DEFAULT_OSVER_CHECK             = 0x400
+	WTD_LIFETIME_SIGNING_FLAG               = 0x800
+	WTD_CACHE_ONLY_URL_RETRIEVAL            = 0x1000
+	WTD_DISABLE_MD2_MD4                     = 0x2000
+	WTD_MOTW                                = 0x4000
+
+	WTD_UICONTEXT_EXECUTE = 0
+	WTD_UICONTEXT_INSTALL = 1
+)
+
 var (
 	OID_PKIX_KP_SERVER_AUTH = []byte("1.3.6.1.5.5.7.3.1\x00")
 	OID_SERVER_GATED_CRYPTO = []byte("1.3.6.1.4.1.311.10.3.3\x00")
 	OID_SGC_NETSCAPE        = []byte("2.16.840.1.113730.4.1\x00")
+
+	WINTRUST_ACTION_GENERIC_VERIFY_V2 = GUID{
+		Data1: 0xaac56b,
+		Data2: 0xcd44,
+		Data3: 0x11d0,
+		Data4: [8]byte{0x8c, 0xc2, 0x0, 0xc0, 0x4f, 0xc2, 0x95, 0xee},
+	}
 )
 
 // Pointer represents a pointer to an arbitrary Windows type.
@@ -1033,7 +1176,57 @@ type MibIfRow struct {
 }
 
 type CertInfo struct {
-	// Not implemented
+	Version              uint32
+	SerialNumber         CryptIntegerBlob
+	SignatureAlgorithm   CryptAlgorithmIdentifier
+	Issuer               CertNameBlob
+	NotBefore            Filetime
+	NotAfter             Filetime
+	Subject              CertNameBlob
+	SubjectPublicKeyInfo CertPublicKeyInfo
+	IssuerUniqueId       CryptBitBlob
+	SubjectUniqueId      CryptBitBlob
+	CountExtensions      uint32
+	Extensions           *CertExtension
+}
+
+type CertExtension struct {
+	ObjId    *byte
+	Critical int32
+	Value    CryptObjidBlob
+}
+
+type CryptAlgorithmIdentifier struct {
+	ObjId      *byte
+	Parameters CryptObjidBlob
+}
+
+type CertPublicKeyInfo struct {
+	Algorithm CryptAlgorithmIdentifier
+	PublicKey CryptBitBlob
+}
+
+type DataBlob struct {
+	Size uint32
+	Data *byte
+}
+type CryptIntegerBlob DataBlob
+type CryptUintBlob DataBlob
+type CryptObjidBlob DataBlob
+type CertNameBlob DataBlob
+type CertRdnValueBlob DataBlob
+type CertBlob DataBlob
+type CrlBlob DataBlob
+type CryptDataBlob DataBlob
+type CryptHashBlob DataBlob
+type CryptDigestBlob DataBlob
+type CryptDerBlob DataBlob
+type CryptAttrBlob DataBlob
+
+type CryptBitBlob struct {
+	Size       uint32
+	Data       *byte
+	UnusedBits uint32
 }
 
 type CertContext struct {
@@ -1139,6 +1332,66 @@ type CertChainPolicyStatus struct {
 	ExtraPolicyStatus Pointer
 }
 
+type CertPolicyInfo struct {
+	Identifier      *byte
+	CountQualifiers uint32
+	Qualifiers      *CertPolicyQualifierInfo
+}
+
+type CertPoliciesInfo struct {
+	Count       uint32
+	PolicyInfos *CertPolicyInfo
+}
+
+type CertPolicyQualifierInfo struct {
+	// Not implemented
+}
+
+type CertStrongSignPara struct {
+	Size                      uint32
+	InfoChoice                uint32
+	InfoOrSerializedInfoOrOID unsafe.Pointer
+}
+
+type CryptProtectPromptStruct struct {
+	Size        uint32
+	PromptFlags uint32
+	App         HWND
+	Prompt      *uint16
+}
+
+type WinTrustData struct {
+	Size                            uint32
+	PolicyCallbackData              uintptr
+	SIPClientData                   uintptr
+	UIChoice                        uint32
+	RevocationChecks                uint32
+	UnionChoice                     uint32
+	FileOrCatalogOrBlobOrSgnrOrCert unsafe.Pointer
+	StateAction                     uint32
+	StateData                       Handle
+	URLReference                    *uint16
+	ProvFlags                       uint32
+	UIContext                       uint32
+	SignatureSettings               *WinTrustSignatureSettings
+}
+
+type WinTrustFileInfo struct {
+	Size         uint32
+	FilePath     *uint16
+	File         Handle
+	KnownSubject *GUID
+}
+
+type WinTrustSignatureSettings struct {
+	Size             uint32
+	Index            uint32
+	Flags            uint32
+	SecondarySigs    uint32
+	VerifiedSigIndex uint32
+	CryptoPolicy     *CertStrongSignPara
+}
+
 const (
 	// do not reorder
 	HKEY_CLASSES_ROOT = 0x80000000 + iota
@@ -1820,3 +2073,21 @@ const (
 	LOAD_LIBRARY_SEARCH_SYSTEM32_NO_FORWARDER = 0x00004000
 	LOAD_LIBRARY_OS_INTEGRITY_CONTINUITY      = 0x00008000
 )
+
+// RegNotifyChangeKeyValue notifyFilter flags.
+const (
+	// REG_NOTIFY_CHANGE_NAME notifies the caller if a subkey is added or deleted.
+	REG_NOTIFY_CHANGE_NAME = 0x00000001
+
+	// REG_NOTIFY_CHANGE_ATTRIBUTES notifies the caller of changes to the attributes of the key, such as the security descriptor information.
+	REG_NOTIFY_CHANGE_ATTRIBUTES = 0x00000002
+
+	// REG_NOTIFY_CHANGE_LAST_SET notifies the caller of changes to a value of the key. This can include adding or deleting a value, or changing an existing value.
+	REG_NOTIFY_CHANGE_LAST_SET = 0x00000004
+
+	// REG_NOTIFY_CHANGE_SECURITY notifies the caller of changes to the security descriptor of the key.
+	REG_NOTIFY_CHANGE_SECURITY = 0x00000008
+
+	// REG_NOTIFY_THREAD_AGNOSTIC indicates that the lifetime of the registration must not be tied to the lifetime of the thread issuing the RegNotifyChangeKeyValue call. Note: This flag value is only supported in Windows 8 and later.
+	REG_NOTIFY_THREAD_AGNOSTIC = 0x10000000
+)
diff --git a/src/cmd/vendor/golang.org/x/sys/windows/types_windows_arm64.go b/src/cmd/vendor/golang.org/x/sys/windows/types_windows_arm64.go
new file mode 100644
index 0000000000..fdddc0c70a
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/windows/types_windows_arm64.go
@@ -0,0 +1,34 @@
+// Copyright 2011 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 windows
+
+type WSAData struct {
+	Version      uint16
+	HighVersion  uint16
+	MaxSockets   uint16
+	MaxUdpDg     uint16
+	VendorInfo   *byte
+	Description  [WSADESCRIPTION_LEN + 1]byte
+	SystemStatus [WSASYS_STATUS_LEN + 1]byte
+}
+
+type Servent struct {
+	Name    *byte
+	Aliases **byte
+	Proto   *byte
+	Port    uint16
+}
+
+type JOBOBJECT_BASIC_LIMIT_INFORMATION struct {
+	PerProcessUserTimeLimit int64
+	PerJobUserTimeLimit     int64
+	LimitFlags              uint32
+	MinimumWorkingSetSize   uintptr
+	MaximumWorkingSetSize   uintptr
+	ActiveProcessLimit      uint32
+	Affinity                uintptr
+	PriorityClass           uint32
+	SchedulingClass         uint32
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/windows/zsyscall_windows.go b/src/cmd/vendor/golang.org/x/sys/windows/zsyscall_windows.go
index a933c0ee37..c38c59d772 100644
--- a/src/cmd/vendor/golang.org/x/sys/windows/zsyscall_windows.go
+++ b/src/cmd/vendor/golang.org/x/sys/windows/zsyscall_windows.go
@@ -51,6 +51,7 @@ var (
 	modshell32  = NewLazySystemDLL("shell32.dll")
 	moduser32   = NewLazySystemDLL("user32.dll")
 	moduserenv  = NewLazySystemDLL("userenv.dll")
+	modwintrust = NewLazySystemDLL("wintrust.dll")
 	modws2_32   = NewLazySystemDLL("ws2_32.dll")
 	modwtsapi32 = NewLazySystemDLL("wtsapi32.dll")
 
@@ -117,6 +118,7 @@ var (
 	procQueryServiceStatusEx                                 = modadvapi32.NewProc("QueryServiceStatusEx")
 	procRegCloseKey                                          = modadvapi32.NewProc("RegCloseKey")
 	procRegEnumKeyExW                                        = modadvapi32.NewProc("RegEnumKeyExW")
+	procRegNotifyChangeKeyValue                              = modadvapi32.NewProc("RegNotifyChangeKeyValue")
 	procRegOpenKeyExW                                        = modadvapi32.NewProc("RegOpenKeyExW")
 	procRegQueryInfoKeyW                                     = modadvapi32.NewProc("RegQueryInfoKeyW")
 	procRegQueryValueExW                                     = modadvapi32.NewProc("RegQueryValueExW")
@@ -142,13 +144,21 @@ var (
 	procCertCloseStore                                       = modcrypt32.NewProc("CertCloseStore")
 	procCertCreateCertificateContext                         = modcrypt32.NewProc("CertCreateCertificateContext")
 	procCertDeleteCertificateFromStore                       = modcrypt32.NewProc("CertDeleteCertificateFromStore")
+	procCertDuplicateCertificateContext                      = modcrypt32.NewProc("CertDuplicateCertificateContext")
 	procCertEnumCertificatesInStore                          = modcrypt32.NewProc("CertEnumCertificatesInStore")
+	procCertFindExtension                                    = modcrypt32.NewProc("CertFindExtension")
 	procCertFreeCertificateChain                             = modcrypt32.NewProc("CertFreeCertificateChain")
 	procCertFreeCertificateContext                           = modcrypt32.NewProc("CertFreeCertificateContext")
 	procCertGetCertificateChain                              = modcrypt32.NewProc("CertGetCertificateChain")
+	procCertGetNameStringW                                   = modcrypt32.NewProc("CertGetNameStringW")
 	procCertOpenStore                                        = modcrypt32.NewProc("CertOpenStore")
 	procCertOpenSystemStoreW                                 = modcrypt32.NewProc("CertOpenSystemStoreW")
 	procCertVerifyCertificateChainPolicy                     = modcrypt32.NewProc("CertVerifyCertificateChainPolicy")
+	procCryptDecodeObject                                    = modcrypt32.NewProc("CryptDecodeObject")
+	procCryptProtectData                                     = modcrypt32.NewProc("CryptProtectData")
+	procCryptQueryObject                                     = modcrypt32.NewProc("CryptQueryObject")
+	procCryptUnprotectData                                   = modcrypt32.NewProc("CryptUnprotectData")
+	procPFXImportCertStore                                   = modcrypt32.NewProc("PFXImportCertStore")
 	procDnsNameCompare_W                                     = moddnsapi.NewProc("DnsNameCompare_W")
 	procDnsQuery_W                                           = moddnsapi.NewProc("DnsQuery_W")
 	procDnsRecordListFree                                    = moddnsapi.NewProc("DnsRecordListFree")
@@ -180,9 +190,12 @@ var (
 	procDuplicateHandle                                      = modkernel32.NewProc("DuplicateHandle")
 	procExitProcess                                          = modkernel32.NewProc("ExitProcess")
 	procFindClose                                            = modkernel32.NewProc("FindClose")
+	procFindCloseChangeNotification                          = modkernel32.NewProc("FindCloseChangeNotification")
+	procFindFirstChangeNotificationW                         = modkernel32.NewProc("FindFirstChangeNotificationW")
 	procFindFirstFileW                                       = modkernel32.NewProc("FindFirstFileW")
 	procFindFirstVolumeMountPointW                           = modkernel32.NewProc("FindFirstVolumeMountPointW")
 	procFindFirstVolumeW                                     = modkernel32.NewProc("FindFirstVolumeW")
+	procFindNextChangeNotification                           = modkernel32.NewProc("FindNextChangeNotification")
 	procFindNextFileW                                        = modkernel32.NewProc("FindNextFileW")
 	procFindNextVolumeMountPointW                            = modkernel32.NewProc("FindNextVolumeMountPointW")
 	procFindNextVolumeW                                      = modkernel32.NewProc("FindNextVolumeW")
@@ -338,10 +351,13 @@ var (
 	procSHGetKnownFolderPath                                 = modshell32.NewProc("SHGetKnownFolderPath")
 	procShellExecuteW                                        = modshell32.NewProc("ShellExecuteW")
 	procExitWindowsEx                                        = moduser32.NewProc("ExitWindowsEx")
+	procGetShellWindow                                       = moduser32.NewProc("GetShellWindow")
+	procGetWindowThreadProcessId                             = moduser32.NewProc("GetWindowThreadProcessId")
 	procMessageBoxW                                          = moduser32.NewProc("MessageBoxW")
 	procCreateEnvironmentBlock                               = moduserenv.NewProc("CreateEnvironmentBlock")
 	procDestroyEnvironmentBlock                              = moduserenv.NewProc("DestroyEnvironmentBlock")
 	procGetUserProfileDirectoryW                             = moduserenv.NewProc("GetUserProfileDirectoryW")
+	procWinVerifyTrustEx                                     = modwintrust.NewProc("WinVerifyTrustEx")
 	procFreeAddrInfoW                                        = modws2_32.NewProc("FreeAddrInfoW")
 	procGetAddrInfoW                                         = modws2_32.NewProc("GetAddrInfoW")
 	procWSACleanup                                           = modws2_32.NewProc("WSACleanup")
@@ -931,6 +947,22 @@ func RegEnumKeyEx(key Handle, index uint32, name *uint16, nameLen *uint32, reser
 	return
 }
 
+func RegNotifyChangeKeyValue(key Handle, watchSubtree bool, notifyFilter uint32, event Handle, asynchronous bool) (regerrno error) {
+	var _p0 uint32
+	if watchSubtree {
+		_p0 = 1
+	}
+	var _p1 uint32
+	if asynchronous {
+		_p1 = 1
+	}
+	r0, _, _ := syscall.Syscall6(procRegNotifyChangeKeyValue.Addr(), 5, uintptr(key), uintptr(_p0), uintptr(notifyFilter), uintptr(event), uintptr(_p1), 0)
+	if r0 != 0 {
+		regerrno = syscall.Errno(r0)
+	}
+	return
+}
+
 func RegOpenKeyEx(key Handle, subkey *uint16, options uint32, desiredAccess uint32, result *Handle) (regerrno error) {
 	r0, _, _ := syscall.Syscall6(procRegOpenKeyExW.Addr(), 5, uintptr(key), uintptr(unsafe.Pointer(subkey)), uintptr(options), uintptr(desiredAccess), uintptr(unsafe.Pointer(result)), 0)
 	if r0 != 0 {
@@ -1163,6 +1195,12 @@ func CertDeleteCertificateFromStore(certContext *CertContext) (err error) {
 	return
 }
 
+func CertDuplicateCertificateContext(certContext *CertContext) (dupContext *CertContext) {
+	r0, _, _ := syscall.Syscall(procCertDuplicateCertificateContext.Addr(), 1, uintptr(unsafe.Pointer(certContext)), 0, 0)
+	dupContext = (*CertContext)(unsafe.Pointer(r0))
+	return
+}
+
 func CertEnumCertificatesInStore(store Handle, prevContext *CertContext) (context *CertContext, err error) {
 	r0, _, e1 := syscall.Syscall(procCertEnumCertificatesInStore.Addr(), 2, uintptr(store), uintptr(unsafe.Pointer(prevContext)), 0)
 	context = (*CertContext)(unsafe.Pointer(r0))
@@ -1172,6 +1210,12 @@ func CertEnumCertificatesInStore(store Handle, prevContext *CertContext) (contex
 	return
 }
 
+func CertFindExtension(objId *byte, countExtensions uint32, extensions *CertExtension) (ret *CertExtension) {
+	r0, _, _ := syscall.Syscall(procCertFindExtension.Addr(), 3, uintptr(unsafe.Pointer(objId)), uintptr(countExtensions), uintptr(unsafe.Pointer(extensions)))
+	ret = (*CertExtension)(unsafe.Pointer(r0))
+	return
+}
+
 func CertFreeCertificateChain(ctx *CertChainContext) {
 	syscall.Syscall(procCertFreeCertificateChain.Addr(), 1, uintptr(unsafe.Pointer(ctx)), 0, 0)
 	return
@@ -1193,6 +1237,12 @@ func CertGetCertificateChain(engine Handle, leaf *CertContext, time *Filetime, a
 	return
 }
 
+func CertGetNameString(certContext *CertContext, nameType uint32, flags uint32, typePara unsafe.Pointer, name *uint16, size uint32) (chars uint32) {
+	r0, _, _ := syscall.Syscall6(procCertGetNameStringW.Addr(), 6, uintptr(unsafe.Pointer(certContext)), uintptr(nameType), uintptr(flags), uintptr(typePara), uintptr(unsafe.Pointer(name)), uintptr(size))
+	chars = uint32(r0)
+	return
+}
+
 func CertOpenStore(storeProvider uintptr, msgAndCertEncodingType uint32, cryptProv uintptr, flags uint32, para uintptr) (handle Handle, err error) {
 	r0, _, e1 := syscall.Syscall6(procCertOpenStore.Addr(), 5, uintptr(storeProvider), uintptr(msgAndCertEncodingType), uintptr(cryptProv), uintptr(flags), uintptr(para), 0)
 	handle = Handle(r0)
@@ -1219,6 +1269,47 @@ func CertVerifyCertificateChainPolicy(policyOID uintptr, chain *CertChainContext
 	return
 }
 
+func CryptDecodeObject(encodingType uint32, structType *byte, encodedBytes *byte, lenEncodedBytes uint32, flags uint32, decoded unsafe.Pointer, decodedLen *uint32) (err error) {
+	r1, _, e1 := syscall.Syscall9(procCryptDecodeObject.Addr(), 7, uintptr(encodingType), uintptr(unsafe.Pointer(structType)), uintptr(unsafe.Pointer(encodedBytes)), uintptr(lenEncodedBytes), uintptr(flags), uintptr(decoded), uintptr(unsafe.Pointer(decodedLen)), 0, 0)
+	if r1 == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func CryptProtectData(dataIn *DataBlob, name *uint16, optionalEntropy *DataBlob, reserved uintptr, promptStruct *CryptProtectPromptStruct, flags uint32, dataOut *DataBlob) (err error) {
+	r1, _, e1 := syscall.Syscall9(procCryptProtectData.Addr(), 7, uintptr(unsafe.Pointer(dataIn)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(optionalEntropy)), uintptr(reserved), uintptr(unsafe.Pointer(promptStruct)), uintptr(flags), uintptr(unsafe.Pointer(dataOut)), 0, 0)
+	if r1 == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func CryptQueryObject(objectType uint32, object unsafe.Pointer, expectedContentTypeFlags uint32, expectedFormatTypeFlags uint32, flags uint32, msgAndCertEncodingType *uint32, contentType *uint32, formatType *uint32, certStore *Handle, msg *Handle, context *unsafe.Pointer) (err error) {
+	r1, _, e1 := syscall.Syscall12(procCryptQueryObject.Addr(), 11, uintptr(objectType), uintptr(object), uintptr(expectedContentTypeFlags), uintptr(expectedFormatTypeFlags), uintptr(flags), uintptr(unsafe.Pointer(msgAndCertEncodingType)), uintptr(unsafe.Pointer(contentType)), uintptr(unsafe.Pointer(formatType)), uintptr(unsafe.Pointer(certStore)), uintptr(unsafe.Pointer(msg)), uintptr(unsafe.Pointer(context)), 0)
+	if r1 == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func CryptUnprotectData(dataIn *DataBlob, name **uint16, optionalEntropy *DataBlob, reserved uintptr, promptStruct *CryptProtectPromptStruct, flags uint32, dataOut *DataBlob) (err error) {
+	r1, _, e1 := syscall.Syscall9(procCryptUnprotectData.Addr(), 7, uintptr(unsafe.Pointer(dataIn)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(optionalEntropy)), uintptr(reserved), uintptr(unsafe.Pointer(promptStruct)), uintptr(flags), uintptr(unsafe.Pointer(dataOut)), 0, 0)
+	if r1 == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func PFXImportCertStore(pfx *CryptDataBlob, password *uint16, flags uint32) (store Handle, err error) {
+	r0, _, e1 := syscall.Syscall(procPFXImportCertStore.Addr(), 3, uintptr(unsafe.Pointer(pfx)), uintptr(unsafe.Pointer(password)), uintptr(flags))
+	store = Handle(r0)
+	if store == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
 func DnsNameCompare(name1 *uint16, name2 *uint16) (same bool) {
 	r0, _, _ := syscall.Syscall(procDnsNameCompare_W.Addr(), 2, uintptr(unsafe.Pointer(name1)), uintptr(unsafe.Pointer(name2)), 0)
 	same = r0 != 0
@@ -1489,6 +1580,36 @@ func FindClose(handle Handle) (err error) {
 	return
 }
 
+func FindCloseChangeNotification(handle Handle) (err error) {
+	r1, _, e1 := syscall.Syscall(procFindCloseChangeNotification.Addr(), 1, uintptr(handle), 0, 0)
+	if r1 == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func FindFirstChangeNotification(path string, watchSubtree bool, notifyFilter uint32) (handle Handle, err error) {
+	var _p0 *uint16
+	_p0, err = syscall.UTF16PtrFromString(path)
+	if err != nil {
+		return
+	}
+	return _FindFirstChangeNotification(_p0, watchSubtree, notifyFilter)
+}
+
+func _FindFirstChangeNotification(path *uint16, watchSubtree bool, notifyFilter uint32) (handle Handle, err error) {
+	var _p1 uint32
+	if watchSubtree {
+		_p1 = 1
+	}
+	r0, _, e1 := syscall.Syscall(procFindFirstChangeNotificationW.Addr(), 3, uintptr(unsafe.Pointer(path)), uintptr(_p1), uintptr(notifyFilter))
+	handle = Handle(r0)
+	if handle == InvalidHandle {
+		err = errnoErr(e1)
+	}
+	return
+}
+
 func findFirstFile1(name *uint16, data *win32finddata1) (handle Handle, err error) {
 	r0, _, e1 := syscall.Syscall(procFindFirstFileW.Addr(), 2, uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(data)), 0)
 	handle = Handle(r0)
@@ -1516,6 +1637,14 @@ func FindFirstVolume(volumeName *uint16, bufferLength uint32) (handle Handle, er
 	return
 }
 
+func FindNextChangeNotification(handle Handle) (err error) {
+	r1, _, e1 := syscall.Syscall(procFindNextChangeNotification.Addr(), 1, uintptr(handle), 0, 0)
+	if r1 == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
 func findNextFile1(handle Handle, data *win32finddata1) (err error) {
 	r1, _, e1 := syscall.Syscall(procFindNextFileW.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(data)), 0)
 	if r1 == 0 {
@@ -2862,7 +2991,22 @@ func ExitWindowsEx(flags uint32, reason uint32) (err error) {
 	return
 }
 
-func MessageBox(hwnd Handle, text *uint16, caption *uint16, boxtype uint32) (ret int32, err error) {
+func GetShellWindow() (shellWindow HWND) {
+	r0, _, _ := syscall.Syscall(procGetShellWindow.Addr(), 0, 0, 0, 0)
+	shellWindow = HWND(r0)
+	return
+}
+
+func GetWindowThreadProcessId(hwnd HWND, pid *uint32) (tid uint32, err error) {
+	r0, _, e1 := syscall.Syscall(procGetWindowThreadProcessId.Addr(), 2, uintptr(hwnd), uintptr(unsafe.Pointer(pid)), 0)
+	tid = uint32(r0)
+	if tid == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func MessageBox(hwnd HWND, text *uint16, caption *uint16, boxtype uint32) (ret int32, err error) {
 	r0, _, e1 := syscall.Syscall6(procMessageBoxW.Addr(), 4, uintptr(hwnd), uintptr(unsafe.Pointer(text)), uintptr(unsafe.Pointer(caption)), uintptr(boxtype), 0, 0)
 	ret = int32(r0)
 	if ret == 0 {
@@ -2899,6 +3043,14 @@ func GetUserProfileDirectory(t Token, dir *uint16, dirLen *uint32) (err error) {
 	return
 }
 
+func WinVerifyTrustEx(hwnd HWND, actionId *GUID, data *WinTrustData) (ret error) {
+	r0, _, _ := syscall.Syscall(procWinVerifyTrustEx.Addr(), 3, uintptr(hwnd), uintptr(unsafe.Pointer(actionId)), uintptr(unsafe.Pointer(data)))
+	if r0 != 0 {
+		ret = syscall.Errno(r0)
+	}
+	return
+}
+
 func FreeAddrInfoW(addrinfo *AddrinfoW) {
 	syscall.Syscall(procFreeAddrInfoW.Addr(), 1, uintptr(unsafe.Pointer(addrinfo)), 0, 0)
 	return
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index e033984956..616fb6c1e6 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -39,7 +39,7 @@ golang.org/x/mod/sumdb/dirhash
 golang.org/x/mod/sumdb/note
 golang.org/x/mod/sumdb/tlog
 golang.org/x/mod/zip
-# golang.org/x/sys v0.0.0-20201204225414-ed752295db88
+# golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e
 ## explicit
 golang.org/x/sys/internal/unsafeheader
 golang.org/x/sys/unix
diff --git a/src/go.mod b/src/go.mod
index 4ae14eea5c..999dc96787 100644
--- a/src/go.mod
+++ b/src/go.mod
@@ -5,6 +5,6 @@ go 1.16
 require (
 	golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897
 	golang.org/x/net v0.0.0-20201209123823-ac852fbbde11
-	golang.org/x/sys v0.0.0-20201204225414-ed752295db88 // indirect
+	golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e // indirect
 	golang.org/x/text v0.3.4 // indirect
 )
diff --git a/src/go.sum b/src/go.sum
index 5586aa9a4e..6dd5f4eafd 100644
--- a/src/go.sum
+++ b/src/go.sum
@@ -7,8 +7,8 @@ golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201204225414-ed752295db88 h1:KmZPnMocC93w341XZp26yTJg8Za7lhb2KhkYmixoeso=
-golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e h1:f5mksnk+hgXHnImpZoWj64ja99j9zV7YUgrVG95uFE4=
+golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
diff --git a/src/vendor/modules.txt b/src/vendor/modules.txt
index 04bb67e58d..06e6ef1945 100644
--- a/src/vendor/modules.txt
+++ b/src/vendor/modules.txt
@@ -18,7 +18,7 @@ golang.org/x/net/idna
 golang.org/x/net/lif
 golang.org/x/net/nettest
 golang.org/x/net/route
-# golang.org/x/sys v0.0.0-20201204225414-ed752295db88
+# golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e
 ## explicit
 golang.org/x/sys/cpu
 # golang.org/x/text v0.3.4
-- 
GitLab


From f6c4b4bf9646f2a3dce6f09ecb93498ddf06d96c Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 26 Jan 2021 21:18:01 -0500
Subject: [PATCH 0717/2400] syscall: add windows/arm64 support

types_windows_arm64.go is a copy of types_windows_amd64.go.
All that matters for these types seems to be that they are 64-bit vs 32-bit.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.

Change-Id: Ia7788d6e88e5db899371c75dc7dea7d912a689ad
Reviewed-on: https://go-review.googlesource.com/c/go/+/288825
Trust: Russ Cox <rsc@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
---
 src/syscall/types_windows_arm64.go | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 src/syscall/types_windows_arm64.go

diff --git a/src/syscall/types_windows_arm64.go b/src/syscall/types_windows_arm64.go
new file mode 100644
index 0000000000..7d45ddbc0b
--- /dev/null
+++ b/src/syscall/types_windows_arm64.go
@@ -0,0 +1,22 @@
+// Copyright 2011 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 syscall
+
+type WSAData struct {
+	Version      uint16
+	HighVersion  uint16
+	MaxSockets   uint16
+	MaxUdpDg     uint16
+	VendorInfo   *byte
+	Description  [WSADESCRIPTION_LEN + 1]byte
+	SystemStatus [WSASYS_STATUS_LEN + 1]byte
+}
+
+type Servent struct {
+	Name    *byte
+	Aliases **byte
+	Proto   *byte
+	Port    uint16
+}
-- 
GitLab


From 427bd7599d1aa2bc89faecff09777a5a662e5bf8 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 22 Jan 2021 15:16:13 -0500
Subject: [PATCH 0718/2400] runtime: generate windows/arm64 callback asm

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.

Change-Id: I5e2b589797808626bcca771cdf860d5cb85586cb
Reviewed-on: https://go-review.googlesource.com/c/go/+/288826
Trust: Russ Cox <rsc@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
---
 src/runtime/syscall_windows.go        |    4 +-
 src/runtime/wincallback.go            |   29 +
 src/runtime/zcallback_windows_arm64.s | 4012 +++++++++++++++++++++++++
 3 files changed, 4043 insertions(+), 2 deletions(-)
 create mode 100644 src/runtime/zcallback_windows_arm64.s

diff --git a/src/runtime/syscall_windows.go b/src/runtime/syscall_windows.go
index 6052cc333c..666ec5f69e 100644
--- a/src/runtime/syscall_windows.go
+++ b/src/runtime/syscall_windows.go
@@ -71,8 +71,8 @@ func callbackasmAddr(i int) uintptr {
 		panic("unsupported architecture")
 	case "386", "amd64":
 		entrySize = 5
-	case "arm":
-		// On ARM, each entry is a MOV instruction
+	case "arm", "arm64":
+		// On ARM and ARM64, each entry is a MOV instruction
 		// followed by a branch instruction
 		entrySize = 8
 	}
diff --git a/src/runtime/wincallback.go b/src/runtime/wincallback.go
index fb452222da..cf3327c6fe 100644
--- a/src/runtime/wincallback.go
+++ b/src/runtime/wincallback.go
@@ -72,6 +72,34 @@ TEXT runtime·callbackasm(SB),NOSPLIT|NOFRAME,$0
 	}
 }
 
+func genasmArm64() {
+	var buf bytes.Buffer
+
+	buf.WriteString(`// Code generated by wincallback.go using 'go generate'. DO NOT EDIT.
+
+// External code calls into callbackasm at an offset corresponding
+// to the callback index. Callbackasm is a table of MOV and B instructions.
+// The MOV instruction loads R12 with the callback index, and the
+// B instruction branches to callbackasm1.
+// callbackasm1 takes the callback index from R12 and
+// indexes into an array that stores information about each callback.
+// It then calls the Go implementation for that callback.
+#include "textflag.h"
+
+TEXT runtime·callbackasm(SB),NOSPLIT|NOFRAME,$0
+`)
+	for i := 0; i < maxCallback; i++ {
+		buf.WriteString(fmt.Sprintf("\tMOVD\t$%d, R12\n", i))
+		buf.WriteString("\tB\truntime·callbackasm1(SB)\n")
+	}
+
+	err := os.WriteFile("zcallback_windows_arm64.s", buf.Bytes(), 0666)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "wincallback: %s\n", err)
+		os.Exit(2)
+	}
+}
+
 func gengo() {
 	var buf bytes.Buffer
 
@@ -91,5 +119,6 @@ const cb_max = %d // maximum number of windows callbacks allowed
 func main() {
 	genasm386Amd64()
 	genasmArm()
+	genasmArm64()
 	gengo()
 }
diff --git a/src/runtime/zcallback_windows_arm64.s b/src/runtime/zcallback_windows_arm64.s
new file mode 100644
index 0000000000..69fb05788c
--- /dev/null
+++ b/src/runtime/zcallback_windows_arm64.s
@@ -0,0 +1,4012 @@
+// Code generated by wincallback.go using 'go generate'. DO NOT EDIT.
+
+// External code calls into callbackasm at an offset corresponding
+// to the callback index. Callbackasm is a table of MOV and B instructions.
+// The MOV instruction loads R12 with the callback index, and the
+// B instruction branches to callbackasm1.
+// callbackasm1 takes the callback index from R12 and
+// indexes into an array that stores information about each callback.
+// It then calls the Go implementation for that callback.
+#include "textflag.h"
+
+TEXT runtime·callbackasm(SB),NOSPLIT|NOFRAME,$0
+	MOVD	$0, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$2, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$3, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$4, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$5, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$6, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$7, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$8, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$9, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$10, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$11, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$12, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$13, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$14, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$15, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$16, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$17, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$18, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$19, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$20, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$21, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$22, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$23, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$24, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$25, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$26, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$27, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$28, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$29, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$30, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$31, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$32, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$33, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$34, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$35, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$36, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$37, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$38, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$39, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$40, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$41, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$42, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$43, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$44, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$45, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$46, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$47, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$48, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$49, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$50, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$51, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$52, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$53, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$54, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$55, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$56, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$57, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$58, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$59, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$60, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$61, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$62, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$63, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$64, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$65, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$66, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$67, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$68, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$69, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$70, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$71, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$72, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$73, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$74, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$75, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$76, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$77, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$78, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$79, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$80, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$81, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$82, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$83, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$84, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$85, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$86, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$87, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$88, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$89, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$90, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$91, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$92, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$93, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$94, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$95, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$96, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$97, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$98, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$99, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$100, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$101, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$102, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$103, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$104, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$105, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$106, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$107, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$108, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$109, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$110, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$111, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$112, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$113, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$114, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$115, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$116, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$117, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$118, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$119, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$120, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$121, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$122, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$123, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$124, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$125, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$126, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$127, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$128, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$129, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$130, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$131, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$132, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$133, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$134, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$135, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$136, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$137, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$138, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$139, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$140, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$141, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$142, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$143, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$144, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$145, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$146, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$147, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$148, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$149, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$150, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$151, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$152, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$153, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$154, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$155, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$156, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$157, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$158, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$159, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$160, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$161, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$162, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$163, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$164, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$165, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$166, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$167, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$168, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$169, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$170, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$171, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$172, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$173, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$174, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$175, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$176, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$177, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$178, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$179, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$180, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$181, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$182, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$183, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$184, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$185, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$186, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$187, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$188, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$189, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$190, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$191, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$192, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$193, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$194, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$195, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$196, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$197, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$198, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$199, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$200, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$201, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$202, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$203, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$204, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$205, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$206, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$207, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$208, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$209, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$210, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$211, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$212, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$213, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$214, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$215, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$216, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$217, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$218, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$219, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$220, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$221, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$222, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$223, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$224, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$225, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$226, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$227, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$228, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$229, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$230, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$231, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$232, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$233, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$234, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$235, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$236, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$237, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$238, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$239, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$240, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$241, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$242, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$243, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$244, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$245, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$246, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$247, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$248, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$249, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$250, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$251, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$252, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$253, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$254, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$255, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$256, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$257, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$258, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$259, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$260, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$261, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$262, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$263, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$264, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$265, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$266, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$267, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$268, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$269, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$270, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$271, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$272, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$273, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$274, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$275, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$276, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$277, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$278, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$279, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$280, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$281, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$282, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$283, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$284, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$285, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$286, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$287, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$288, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$289, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$290, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$291, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$292, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$293, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$294, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$295, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$296, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$297, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$298, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$299, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$300, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$301, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$302, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$303, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$304, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$305, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$306, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$307, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$308, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$309, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$310, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$311, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$312, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$313, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$314, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$315, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$316, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$317, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$318, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$319, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$320, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$321, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$322, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$323, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$324, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$325, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$326, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$327, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$328, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$329, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$330, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$331, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$332, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$333, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$334, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$335, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$336, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$337, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$338, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$339, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$340, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$341, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$342, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$343, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$344, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$345, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$346, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$347, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$348, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$349, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$350, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$351, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$352, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$353, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$354, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$355, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$356, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$357, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$358, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$359, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$360, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$361, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$362, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$363, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$364, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$365, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$366, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$367, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$368, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$369, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$370, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$371, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$372, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$373, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$374, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$375, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$376, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$377, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$378, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$379, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$380, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$381, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$382, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$383, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$384, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$385, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$386, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$387, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$388, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$389, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$390, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$391, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$392, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$393, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$394, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$395, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$396, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$397, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$398, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$399, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$400, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$401, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$402, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$403, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$404, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$405, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$406, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$407, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$408, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$409, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$410, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$411, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$412, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$413, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$414, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$415, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$416, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$417, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$418, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$419, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$420, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$421, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$422, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$423, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$424, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$425, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$426, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$427, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$428, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$429, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$430, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$431, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$432, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$433, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$434, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$435, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$436, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$437, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$438, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$439, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$440, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$441, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$442, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$443, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$444, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$445, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$446, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$447, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$448, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$449, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$450, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$451, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$452, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$453, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$454, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$455, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$456, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$457, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$458, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$459, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$460, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$461, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$462, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$463, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$464, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$465, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$466, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$467, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$468, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$469, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$470, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$471, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$472, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$473, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$474, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$475, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$476, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$477, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$478, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$479, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$480, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$481, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$482, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$483, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$484, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$485, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$486, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$487, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$488, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$489, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$490, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$491, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$492, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$493, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$494, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$495, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$496, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$497, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$498, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$499, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$500, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$501, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$502, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$503, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$504, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$505, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$506, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$507, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$508, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$509, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$510, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$511, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$512, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$513, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$514, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$515, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$516, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$517, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$518, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$519, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$520, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$521, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$522, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$523, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$524, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$525, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$526, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$527, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$528, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$529, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$530, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$531, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$532, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$533, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$534, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$535, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$536, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$537, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$538, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$539, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$540, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$541, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$542, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$543, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$544, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$545, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$546, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$547, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$548, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$549, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$550, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$551, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$552, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$553, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$554, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$555, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$556, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$557, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$558, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$559, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$560, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$561, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$562, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$563, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$564, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$565, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$566, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$567, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$568, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$569, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$570, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$571, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$572, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$573, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$574, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$575, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$576, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$577, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$578, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$579, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$580, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$581, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$582, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$583, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$584, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$585, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$586, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$587, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$588, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$589, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$590, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$591, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$592, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$593, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$594, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$595, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$596, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$597, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$598, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$599, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$600, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$601, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$602, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$603, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$604, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$605, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$606, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$607, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$608, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$609, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$610, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$611, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$612, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$613, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$614, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$615, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$616, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$617, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$618, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$619, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$620, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$621, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$622, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$623, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$624, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$625, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$626, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$627, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$628, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$629, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$630, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$631, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$632, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$633, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$634, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$635, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$636, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$637, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$638, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$639, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$640, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$641, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$642, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$643, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$644, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$645, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$646, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$647, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$648, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$649, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$650, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$651, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$652, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$653, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$654, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$655, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$656, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$657, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$658, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$659, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$660, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$661, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$662, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$663, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$664, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$665, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$666, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$667, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$668, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$669, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$670, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$671, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$672, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$673, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$674, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$675, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$676, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$677, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$678, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$679, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$680, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$681, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$682, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$683, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$684, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$685, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$686, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$687, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$688, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$689, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$690, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$691, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$692, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$693, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$694, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$695, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$696, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$697, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$698, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$699, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$700, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$701, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$702, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$703, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$704, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$705, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$706, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$707, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$708, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$709, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$710, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$711, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$712, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$713, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$714, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$715, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$716, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$717, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$718, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$719, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$720, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$721, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$722, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$723, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$724, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$725, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$726, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$727, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$728, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$729, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$730, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$731, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$732, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$733, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$734, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$735, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$736, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$737, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$738, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$739, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$740, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$741, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$742, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$743, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$744, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$745, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$746, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$747, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$748, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$749, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$750, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$751, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$752, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$753, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$754, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$755, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$756, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$757, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$758, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$759, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$760, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$761, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$762, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$763, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$764, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$765, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$766, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$767, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$768, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$769, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$770, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$771, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$772, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$773, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$774, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$775, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$776, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$777, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$778, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$779, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$780, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$781, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$782, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$783, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$784, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$785, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$786, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$787, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$788, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$789, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$790, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$791, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$792, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$793, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$794, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$795, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$796, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$797, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$798, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$799, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$800, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$801, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$802, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$803, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$804, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$805, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$806, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$807, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$808, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$809, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$810, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$811, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$812, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$813, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$814, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$815, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$816, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$817, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$818, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$819, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$820, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$821, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$822, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$823, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$824, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$825, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$826, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$827, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$828, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$829, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$830, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$831, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$832, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$833, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$834, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$835, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$836, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$837, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$838, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$839, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$840, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$841, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$842, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$843, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$844, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$845, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$846, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$847, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$848, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$849, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$850, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$851, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$852, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$853, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$854, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$855, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$856, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$857, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$858, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$859, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$860, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$861, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$862, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$863, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$864, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$865, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$866, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$867, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$868, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$869, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$870, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$871, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$872, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$873, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$874, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$875, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$876, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$877, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$878, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$879, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$880, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$881, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$882, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$883, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$884, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$885, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$886, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$887, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$888, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$889, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$890, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$891, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$892, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$893, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$894, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$895, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$896, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$897, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$898, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$899, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$900, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$901, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$902, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$903, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$904, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$905, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$906, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$907, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$908, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$909, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$910, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$911, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$912, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$913, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$914, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$915, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$916, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$917, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$918, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$919, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$920, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$921, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$922, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$923, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$924, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$925, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$926, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$927, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$928, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$929, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$930, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$931, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$932, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$933, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$934, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$935, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$936, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$937, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$938, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$939, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$940, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$941, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$942, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$943, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$944, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$945, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$946, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$947, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$948, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$949, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$950, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$951, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$952, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$953, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$954, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$955, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$956, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$957, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$958, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$959, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$960, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$961, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$962, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$963, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$964, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$965, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$966, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$967, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$968, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$969, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$970, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$971, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$972, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$973, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$974, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$975, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$976, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$977, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$978, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$979, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$980, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$981, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$982, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$983, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$984, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$985, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$986, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$987, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$988, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$989, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$990, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$991, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$992, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$993, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$994, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$995, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$996, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$997, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$998, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$999, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1000, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1001, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1002, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1003, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1004, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1005, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1006, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1007, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1008, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1009, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1010, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1011, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1012, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1013, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1014, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1015, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1016, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1017, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1018, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1019, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1020, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1021, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1022, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1023, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1024, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1025, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1026, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1027, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1028, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1029, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1030, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1031, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1032, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1033, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1034, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1035, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1036, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1037, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1038, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1039, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1040, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1041, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1042, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1043, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1044, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1045, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1046, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1047, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1048, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1049, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1050, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1051, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1052, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1053, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1054, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1055, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1056, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1057, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1058, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1059, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1060, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1061, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1062, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1063, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1064, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1065, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1066, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1067, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1068, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1069, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1070, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1071, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1072, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1073, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1074, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1075, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1076, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1077, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1078, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1079, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1080, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1081, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1082, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1083, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1084, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1085, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1086, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1087, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1088, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1089, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1090, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1091, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1092, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1093, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1094, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1095, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1096, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1097, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1098, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1099, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1100, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1101, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1102, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1103, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1104, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1105, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1106, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1107, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1108, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1109, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1110, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1111, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1112, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1113, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1114, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1115, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1116, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1117, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1118, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1119, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1120, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1121, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1122, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1123, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1124, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1125, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1126, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1127, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1128, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1129, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1130, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1131, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1132, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1133, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1134, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1135, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1136, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1137, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1138, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1139, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1140, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1141, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1142, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1143, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1144, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1145, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1146, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1147, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1148, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1149, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1150, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1151, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1152, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1153, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1154, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1155, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1156, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1157, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1158, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1159, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1160, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1161, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1162, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1163, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1164, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1165, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1166, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1167, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1168, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1169, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1170, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1171, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1172, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1173, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1174, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1175, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1176, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1177, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1178, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1179, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1180, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1181, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1182, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1183, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1184, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1185, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1186, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1187, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1188, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1189, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1190, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1191, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1192, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1193, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1194, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1195, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1196, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1197, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1198, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1199, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1200, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1201, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1202, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1203, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1204, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1205, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1206, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1207, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1208, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1209, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1210, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1211, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1212, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1213, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1214, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1215, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1216, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1217, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1218, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1219, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1220, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1221, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1222, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1223, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1224, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1225, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1226, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1227, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1228, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1229, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1230, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1231, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1232, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1233, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1234, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1235, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1236, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1237, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1238, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1239, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1240, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1241, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1242, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1243, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1244, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1245, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1246, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1247, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1248, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1249, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1250, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1251, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1252, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1253, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1254, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1255, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1256, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1257, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1258, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1259, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1260, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1261, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1262, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1263, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1264, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1265, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1266, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1267, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1268, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1269, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1270, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1271, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1272, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1273, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1274, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1275, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1276, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1277, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1278, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1279, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1280, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1281, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1282, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1283, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1284, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1285, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1286, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1287, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1288, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1289, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1290, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1291, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1292, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1293, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1294, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1295, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1296, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1297, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1298, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1299, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1300, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1301, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1302, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1303, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1304, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1305, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1306, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1307, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1308, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1309, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1310, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1311, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1312, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1313, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1314, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1315, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1316, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1317, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1318, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1319, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1320, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1321, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1322, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1323, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1324, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1325, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1326, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1327, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1328, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1329, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1330, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1331, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1332, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1333, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1334, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1335, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1336, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1337, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1338, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1339, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1340, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1341, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1342, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1343, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1344, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1345, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1346, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1347, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1348, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1349, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1350, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1351, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1352, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1353, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1354, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1355, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1356, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1357, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1358, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1359, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1360, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1361, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1362, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1363, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1364, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1365, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1366, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1367, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1368, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1369, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1370, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1371, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1372, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1373, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1374, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1375, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1376, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1377, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1378, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1379, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1380, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1381, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1382, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1383, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1384, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1385, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1386, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1387, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1388, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1389, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1390, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1391, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1392, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1393, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1394, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1395, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1396, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1397, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1398, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1399, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1400, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1401, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1402, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1403, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1404, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1405, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1406, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1407, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1408, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1409, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1410, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1411, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1412, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1413, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1414, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1415, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1416, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1417, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1418, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1419, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1420, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1421, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1422, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1423, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1424, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1425, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1426, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1427, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1428, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1429, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1430, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1431, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1432, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1433, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1434, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1435, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1436, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1437, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1438, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1439, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1440, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1441, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1442, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1443, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1444, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1445, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1446, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1447, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1448, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1449, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1450, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1451, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1452, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1453, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1454, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1455, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1456, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1457, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1458, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1459, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1460, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1461, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1462, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1463, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1464, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1465, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1466, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1467, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1468, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1469, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1470, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1471, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1472, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1473, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1474, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1475, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1476, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1477, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1478, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1479, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1480, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1481, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1482, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1483, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1484, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1485, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1486, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1487, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1488, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1489, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1490, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1491, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1492, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1493, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1494, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1495, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1496, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1497, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1498, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1499, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1500, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1501, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1502, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1503, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1504, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1505, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1506, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1507, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1508, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1509, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1510, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1511, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1512, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1513, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1514, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1515, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1516, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1517, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1518, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1519, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1520, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1521, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1522, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1523, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1524, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1525, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1526, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1527, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1528, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1529, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1530, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1531, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1532, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1533, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1534, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1535, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1536, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1537, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1538, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1539, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1540, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1541, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1542, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1543, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1544, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1545, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1546, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1547, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1548, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1549, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1550, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1551, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1552, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1553, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1554, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1555, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1556, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1557, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1558, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1559, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1560, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1561, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1562, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1563, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1564, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1565, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1566, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1567, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1568, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1569, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1570, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1571, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1572, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1573, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1574, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1575, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1576, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1577, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1578, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1579, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1580, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1581, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1582, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1583, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1584, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1585, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1586, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1587, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1588, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1589, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1590, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1591, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1592, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1593, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1594, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1595, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1596, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1597, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1598, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1599, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1600, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1601, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1602, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1603, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1604, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1605, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1606, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1607, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1608, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1609, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1610, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1611, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1612, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1613, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1614, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1615, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1616, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1617, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1618, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1619, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1620, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1621, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1622, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1623, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1624, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1625, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1626, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1627, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1628, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1629, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1630, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1631, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1632, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1633, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1634, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1635, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1636, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1637, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1638, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1639, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1640, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1641, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1642, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1643, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1644, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1645, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1646, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1647, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1648, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1649, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1650, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1651, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1652, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1653, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1654, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1655, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1656, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1657, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1658, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1659, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1660, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1661, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1662, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1663, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1664, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1665, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1666, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1667, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1668, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1669, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1670, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1671, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1672, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1673, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1674, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1675, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1676, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1677, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1678, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1679, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1680, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1681, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1682, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1683, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1684, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1685, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1686, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1687, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1688, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1689, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1690, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1691, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1692, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1693, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1694, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1695, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1696, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1697, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1698, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1699, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1700, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1701, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1702, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1703, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1704, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1705, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1706, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1707, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1708, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1709, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1710, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1711, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1712, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1713, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1714, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1715, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1716, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1717, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1718, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1719, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1720, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1721, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1722, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1723, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1724, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1725, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1726, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1727, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1728, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1729, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1730, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1731, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1732, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1733, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1734, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1735, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1736, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1737, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1738, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1739, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1740, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1741, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1742, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1743, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1744, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1745, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1746, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1747, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1748, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1749, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1750, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1751, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1752, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1753, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1754, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1755, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1756, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1757, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1758, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1759, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1760, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1761, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1762, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1763, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1764, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1765, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1766, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1767, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1768, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1769, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1770, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1771, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1772, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1773, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1774, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1775, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1776, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1777, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1778, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1779, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1780, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1781, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1782, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1783, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1784, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1785, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1786, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1787, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1788, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1789, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1790, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1791, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1792, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1793, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1794, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1795, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1796, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1797, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1798, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1799, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1800, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1801, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1802, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1803, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1804, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1805, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1806, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1807, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1808, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1809, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1810, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1811, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1812, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1813, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1814, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1815, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1816, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1817, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1818, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1819, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1820, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1821, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1822, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1823, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1824, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1825, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1826, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1827, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1828, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1829, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1830, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1831, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1832, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1833, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1834, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1835, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1836, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1837, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1838, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1839, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1840, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1841, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1842, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1843, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1844, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1845, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1846, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1847, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1848, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1849, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1850, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1851, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1852, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1853, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1854, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1855, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1856, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1857, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1858, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1859, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1860, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1861, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1862, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1863, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1864, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1865, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1866, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1867, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1868, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1869, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1870, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1871, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1872, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1873, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1874, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1875, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1876, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1877, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1878, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1879, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1880, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1881, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1882, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1883, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1884, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1885, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1886, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1887, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1888, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1889, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1890, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1891, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1892, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1893, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1894, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1895, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1896, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1897, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1898, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1899, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1900, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1901, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1902, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1903, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1904, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1905, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1906, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1907, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1908, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1909, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1910, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1911, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1912, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1913, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1914, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1915, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1916, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1917, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1918, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1919, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1920, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1921, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1922, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1923, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1924, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1925, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1926, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1927, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1928, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1929, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1930, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1931, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1932, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1933, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1934, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1935, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1936, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1937, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1938, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1939, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1940, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1941, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1942, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1943, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1944, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1945, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1946, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1947, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1948, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1949, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1950, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1951, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1952, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1953, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1954, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1955, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1956, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1957, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1958, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1959, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1960, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1961, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1962, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1963, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1964, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1965, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1966, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1967, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1968, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1969, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1970, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1971, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1972, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1973, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1974, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1975, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1976, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1977, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1978, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1979, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1980, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1981, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1982, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1983, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1984, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1985, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1986, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1987, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1988, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1989, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1990, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1991, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1992, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1993, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1994, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1995, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1996, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1997, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1998, R12
+	B	runtime·callbackasm1(SB)
+	MOVD	$1999, R12
+	B	runtime·callbackasm1(SB)
-- 
GitLab


From 3527caa7d63eab821c9936383e6c442d7a013de1 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 22 Jan 2021 10:30:10 -0500
Subject: [PATCH 0719/2400] runtime: initial windows/arm64 implementation files

This CL adds a few small files - defs, os, and rt0 - to start
on windows/arm64 support for the runtime.

It also copies sys_windows_arm.s to sys_windows_arm64.s,
with the addition of "#ifdef NOT_PORTED" around the entire file.
This is meant to make future CLs easier to review, since the
general pattern is to translate the 32-bit ARM assembly into
64-bit ARM assembly.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.

Change-Id: I922037eb3890e77bac48281ecaa8e489595675be
Reviewed-on: https://go-review.googlesource.com/c/go/+/288827
Trust: Russ Cox <rsc@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
---
 src/runtime/defs_windows_arm64.go |  83 +++++
 src/runtime/os_windows_arm64.go   |  14 +
 src/runtime/rt0_windows_arm64.s   |  12 +
 src/runtime/sys_windows_arm64.s   | 588 ++++++++++++++++++++++++++++++
 4 files changed, 697 insertions(+)
 create mode 100644 src/runtime/defs_windows_arm64.go
 create mode 100644 src/runtime/os_windows_arm64.go
 create mode 100644 src/runtime/rt0_windows_arm64.s
 create mode 100644 src/runtime/sys_windows_arm64.s

diff --git a/src/runtime/defs_windows_arm64.go b/src/runtime/defs_windows_arm64.go
new file mode 100644
index 0000000000..9ccce46f09
--- /dev/null
+++ b/src/runtime/defs_windows_arm64.go
@@ -0,0 +1,83 @@
+// Copyright 2018 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 runtime
+
+// NOTE(rsc): _CONTEXT_CONTROL is actually 0x400001 and should include PC, SP, and LR.
+// However, empirically, LR doesn't come along on Windows 10
+// unless you also set _CONTEXT_INTEGER (0x400002).
+// Without LR, we skip over the next-to-bottom function in profiles
+// when the bottom function is frameless.
+// So we set both here, to make a working _CONTEXT_CONTROL.
+const _CONTEXT_CONTROL = 0x400003
+
+type neon128 struct {
+	low  uint64
+	high int64
+}
+
+// See https://docs.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-arm64_nt_context
+type context struct {
+	contextflags uint32
+	cpsr         uint32
+	x            [31]uint64 // fp is x[29], lr is x[30]
+	xsp          uint64
+	pc           uint64
+	v            [32]neon128
+	fpcr         uint32
+	fpsr         uint32
+	bcr          [8]uint32
+	bvr          [8]uint64
+	wcr          [2]uint32
+	wvr          [2]uint64
+}
+
+func (c *context) ip() uintptr { return uintptr(c.pc) }
+func (c *context) sp() uintptr { return uintptr(c.xsp) }
+func (c *context) lr() uintptr { return uintptr(c.x[30]) }
+
+func (c *context) set_ip(x uintptr) { c.pc = uint64(x) }
+func (c *context) set_sp(x uintptr) { c.xsp = uint64(x) }
+func (c *context) set_lr(x uintptr) { c.x[30] = uint64(x) }
+
+func dumpregs(r *context) {
+	print("r0   ", hex(r.x[0]), "\n")
+	print("r1   ", hex(r.x[1]), "\n")
+	print("r2   ", hex(r.x[2]), "\n")
+	print("r3   ", hex(r.x[3]), "\n")
+	print("r4   ", hex(r.x[4]), "\n")
+	print("r5   ", hex(r.x[5]), "\n")
+	print("r6   ", hex(r.x[6]), "\n")
+	print("r7   ", hex(r.x[7]), "\n")
+	print("r8   ", hex(r.x[8]), "\n")
+	print("r9   ", hex(r.x[9]), "\n")
+	print("r10  ", hex(r.x[10]), "\n")
+	print("r11  ", hex(r.x[11]), "\n")
+	print("r12  ", hex(r.x[12]), "\n")
+	print("r13  ", hex(r.x[13]), "\n")
+	print("r14  ", hex(r.x[14]), "\n")
+	print("r15  ", hex(r.x[15]), "\n")
+	print("r16  ", hex(r.x[16]), "\n")
+	print("r17  ", hex(r.x[17]), "\n")
+	print("r18  ", hex(r.x[18]), "\n")
+	print("r19  ", hex(r.x[19]), "\n")
+	print("r20  ", hex(r.x[20]), "\n")
+	print("r21  ", hex(r.x[21]), "\n")
+	print("r22  ", hex(r.x[22]), "\n")
+	print("r23  ", hex(r.x[23]), "\n")
+	print("r24  ", hex(r.x[24]), "\n")
+	print("r25  ", hex(r.x[25]), "\n")
+	print("r26  ", hex(r.x[26]), "\n")
+	print("r27  ", hex(r.x[27]), "\n")
+	print("r28  ", hex(r.x[28]), "\n")
+	print("r29  ", hex(r.x[29]), "\n")
+	print("lr   ", hex(r.x[30]), "\n")
+	print("sp   ", hex(r.xsp), "\n")
+	print("pc   ", hex(r.pc), "\n")
+	print("cpsr ", hex(r.cpsr), "\n")
+}
+
+func stackcheck() {
+	// TODO: not implemented on ARM
+}
diff --git a/src/runtime/os_windows_arm64.go b/src/runtime/os_windows_arm64.go
new file mode 100644
index 0000000000..7e413445ba
--- /dev/null
+++ b/src/runtime/os_windows_arm64.go
@@ -0,0 +1,14 @@
+// Copyright 2018 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 runtime
+
+import "unsafe"
+
+//go:nosplit
+func cputicks() int64 {
+	var counter int64
+	stdcall1(_QueryPerformanceCounter, uintptr(unsafe.Pointer(&counter)))
+	return counter
+}
diff --git a/src/runtime/rt0_windows_arm64.s b/src/runtime/rt0_windows_arm64.s
new file mode 100644
index 0000000000..1e71a068d3
--- /dev/null
+++ b/src/runtime/rt0_windows_arm64.s
@@ -0,0 +1,12 @@
+// Copyright 2018 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.
+
+#include "go_asm.h"
+#include "go_tls.h"
+#include "textflag.h"
+
+// This is the entry point for the program from the
+// kernel for an ordinary -buildmode=exe program.
+TEXT _rt0_arm64_windows(SB),NOSPLIT|NOFRAME,$0
+	B	·rt0_go(SB)
diff --git a/src/runtime/sys_windows_arm64.s b/src/runtime/sys_windows_arm64.s
new file mode 100644
index 0000000000..b279f25de8
--- /dev/null
+++ b/src/runtime/sys_windows_arm64.s
@@ -0,0 +1,588 @@
+// Copyright 2018 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.
+
+#include "go_asm.h"
+#include "go_tls.h"
+#include "textflag.h"
+
+#ifdef NOT_PORTED
+
+// Note: For system ABI, R0-R3 are args, R4-R11 are callee-save.
+
+// void runtime·asmstdcall(void *c);
+TEXT runtime·asmstdcall(SB),NOSPLIT|NOFRAME,$0
+	MOVM.DB.W [R4, R5, R14], (R13)	// push {r4, r5, lr}
+	MOVW	R0, R4			// put libcall * in r4
+	MOVW	R13, R5			// save stack pointer in r5
+
+	// SetLastError(0)
+	MOVW	$0, R0
+	MRC	15, 0, R1, C13, C0, 2
+	MOVW	R0, 0x34(R1)
+
+	MOVW	8(R4), R12	// libcall->args
+
+	// Do we have more than 4 arguments?
+	MOVW	4(R4), R0	// libcall->n
+	SUB.S	$4, R0, R2
+	BLE	loadregs
+
+	// Reserve stack space for remaining args
+	SUB	R2<<2, R13
+	BIC	$0x7, R13	// alignment for ABI
+
+	// R0: count of arguments
+	// R1:
+	// R2: loop counter, from 0 to (n-4)
+	// R3: scratch
+	// R4: pointer to libcall struct
+	// R12: libcall->args
+	MOVW	$0, R2
+stackargs:
+	ADD	$4, R2, R3		// r3 = args[4 + i]
+	MOVW	R3<<2(R12), R3
+	MOVW	R3, R2<<2(R13)		// stack[i] = r3
+
+	ADD	$1, R2			// i++
+	SUB	$4, R0, R3		// while (i < (n - 4))
+	CMP	R3, R2
+	BLT	stackargs
+
+loadregs:
+	CMP	$3, R0
+	MOVW.GT 12(R12), R3
+
+	CMP	$2, R0
+	MOVW.GT 8(R12), R2
+
+	CMP	$1, R0
+	MOVW.GT 4(R12), R1
+
+	CMP	$0, R0
+	MOVW.GT 0(R12), R0
+
+	BIC	$0x7, R13		// alignment for ABI
+	MOVW	0(R4), R12		// branch to libcall->fn
+	BL	(R12)
+
+	MOVW	R5, R13			// free stack space
+	MOVW	R0, 12(R4)		// save return value to libcall->r1
+	MOVW	R1, 16(R4)
+
+	// GetLastError
+	MRC	15, 0, R1, C13, C0, 2
+	MOVW	0x34(R1), R0
+	MOVW	R0, 20(R4)		// store in libcall->err
+
+	MOVM.IA.W (R13), [R4, R5, R15]
+
+TEXT runtime·badsignal2(SB),NOSPLIT|NOFRAME,$0
+	MOVM.DB.W [R4, R14], (R13)	// push {r4, lr}
+	MOVW	R13, R4			// save original stack pointer
+	SUB	$8, R13			// space for 2 variables
+	BIC	$0x7, R13		// alignment for ABI
+
+	// stderr
+	MOVW	runtime·_GetStdHandle(SB), R1
+	MOVW	$-12, R0
+	BL	(R1)
+
+	MOVW	$runtime·badsignalmsg(SB), R1	// lpBuffer
+	MOVW	$runtime·badsignallen(SB), R2	// lpNumberOfBytesToWrite
+	MOVW	(R2), R2
+	ADD	$0x4, R13, R3		// lpNumberOfBytesWritten
+	MOVW	$0, R12			// lpOverlapped
+	MOVW	R12, (R13)
+
+	MOVW	runtime·_WriteFile(SB), R12
+	BL	(R12)
+
+	MOVW	R4, R13			// restore SP
+	MOVM.IA.W (R13), [R4, R15]	// pop {r4, pc}
+
+TEXT runtime·getlasterror(SB),NOSPLIT,$0
+	MRC	15, 0, R0, C13, C0, 2
+	MOVW	0x34(R0), R0
+	MOVW	R0, ret+0(FP)
+	RET
+
+// Called by Windows as a Vectored Exception Handler (VEH).
+// First argument is pointer to struct containing
+// exception record and context pointers.
+// Handler function is stored in R1
+// Return 0 for 'not handled', -1 for handled.
+// int32_t sigtramp(
+//     PEXCEPTION_POINTERS ExceptionInfo,
+//     func *GoExceptionHandler);
+TEXT sigtramp<>(SB),NOSPLIT|NOFRAME,$0
+	MOVM.DB.W [R0, R4-R11, R14], (R13)	// push {r0, r4-r11, lr} (SP-=40)
+	SUB	$(8+20), R13		// reserve space for g, sp, and
+					// parameters/retval to go call
+
+	MOVW	R0, R6			// Save param0
+	MOVW	R1, R7			// Save param1
+
+	BL      runtime·load_g(SB)
+	CMP	$0, g			// is there a current g?
+	BL.EQ	runtime·badsignal2(SB)
+
+	// save g and SP in case of stack switch
+	MOVW	R13, 24(R13)
+	MOVW	g, 20(R13)
+
+	// do we need to switch to the g0 stack?
+	MOVW	g, R5			// R5 = g
+	MOVW	g_m(R5), R2		// R2 = m
+	MOVW	m_g0(R2), R4		// R4 = g0
+	CMP	R5, R4			// if curg == g0
+	BEQ	g0
+
+	// switch to g0 stack
+	MOVW	R4, g				// g = g0
+	MOVW	(g_sched+gobuf_sp)(g), R3	// R3 = g->gobuf.sp
+	BL      runtime·save_g(SB)
+
+	// make room for sighandler arguments
+	// and re-save old SP for restoring later.
+	// (note that the 24(R3) here must match the 24(R13) above.)
+	SUB	$40, R3
+	MOVW	R13, 24(R3)		// save old stack pointer
+	MOVW	R3, R13			// switch stack
+
+g0:
+	MOVW	0(R6), R2	// R2 = ExceptionPointers->ExceptionRecord
+	MOVW	4(R6), R3	// R3 = ExceptionPointers->ContextRecord
+
+	MOVW	$0, R4
+	MOVW	R4, 0(R13)	// No saved link register.
+	MOVW	R2, 4(R13)	// Move arg0 (ExceptionRecord) into position
+	MOVW	R3, 8(R13)	// Move arg1 (ContextRecord) into position
+	MOVW	R5, 12(R13)	// Move arg2 (original g) into position
+	BL	(R7)		// Call the go routine
+	MOVW	16(R13), R4	// Fetch return value from stack
+
+	// switch back to original stack and g
+	MOVW	24(R13), R13
+	MOVW	20(R13), g
+	BL      runtime·save_g(SB)
+
+done:
+	MOVW	R4, R0				// move retval into position
+	ADD	$(8 + 20), R13			// free locals
+	MOVM.IA.W (R13), [R3, R4-R11, R14]	// pop {r3, r4-r11, lr}
+
+	// if return value is CONTINUE_SEARCH, do not set up control
+	// flow guard workaround
+	CMP	$0, R0
+	BEQ	return
+
+	// Check if we need to set up the control flow guard workaround.
+	// On Windows/ARM, the stack pointer must lie within system
+	// stack limits when we resume from exception.
+	// Store the resume SP and PC on the g0 stack,
+	// and return to returntramp on the g0 stack. returntramp
+	// pops the saved PC and SP from the g0 stack, resuming execution
+	// at the desired location.
+	// If returntramp has already been set up by a previous exception
+	// handler, don't clobber the stored SP and PC on the stack.
+	MOVW	4(R3), R3			// PEXCEPTION_POINTERS->Context
+	MOVW	context_pc(R3), R2		// load PC from context record
+	MOVW	$returntramp<>(SB), R1
+	CMP	R1, R2
+	B.EQ	return				// do not clobber saved SP/PC
+
+	// Save resume SP and PC into R0, R1.
+	MOVW	context_spr(R3), R2
+	MOVW	R2, context_r0(R3)
+	MOVW	context_pc(R3), R2
+	MOVW	R2, context_r1(R3)
+
+	// Set up context record to return to returntramp on g0 stack
+	MOVW	R12, context_spr(R3)
+	MOVW	$returntramp<>(SB), R2
+	MOVW	R2, context_pc(R3)
+
+return:
+	B	(R14)				// return
+
+// Trampoline to resume execution from exception handler.
+// This is part of the control flow guard workaround.
+// It switches stacks and jumps to the continuation address.
+// R0 and R1 are set above at the end of sigtramp<>
+// in the context that starts executing at returntramp<>.
+TEXT returntramp<>(SB),NOSPLIT|NOFRAME,$0
+	// Important: do not smash LR,
+	// which is set to a live value when handling
+	// a signal by pushing a call to sigpanic onto the stack.
+	MOVW	R0, R13
+	B	(R1)
+
+TEXT runtime·exceptiontramp(SB),NOSPLIT|NOFRAME,$0
+	MOVW	$runtime·exceptionhandler(SB), R1
+	B	sigtramp<>(SB)
+
+TEXT runtime·firstcontinuetramp(SB),NOSPLIT|NOFRAME,$0
+	MOVW	$runtime·firstcontinuehandler(SB), R1
+	B	sigtramp<>(SB)
+
+TEXT runtime·lastcontinuetramp(SB),NOSPLIT|NOFRAME,$0
+	MOVW	$runtime·lastcontinuehandler(SB), R1
+	B	sigtramp<>(SB)
+
+TEXT runtime·ctrlhandler(SB),NOSPLIT|NOFRAME,$0
+	MOVW	$runtime·ctrlhandler1(SB), R1
+	B	runtime·externalthreadhandler(SB)
+
+TEXT runtime·profileloop(SB),NOSPLIT|NOFRAME,$0
+	MOVW	$runtime·profileloop1(SB), R1
+	B	runtime·externalthreadhandler(SB)
+
+// int32 externalthreadhandler(uint32 arg, int (*func)(uint32))
+// stack layout:
+//   +----------------+
+//   | callee-save    |
+//   | registers      |
+//   +----------------+
+//   | m              |
+//   +----------------+
+// 20| g              |
+//   +----------------+
+// 16| func ptr (r1)  |
+//   +----------------+
+// 12| argument (r0)  |
+//---+----------------+
+// 8 | param1         | (also return value for called Go function)
+//   +----------------+
+// 4 | param0         |
+//   +----------------+
+// 0 | slot for LR    |
+//   +----------------+
+//
+TEXT runtime·externalthreadhandler(SB),NOSPLIT|NOFRAME|TOPFRAME,$0
+	MOVM.DB.W [R4-R11, R14], (R13)		// push {r4-r11, lr}
+	SUB	$(m__size + g__size + 20), R13	// space for locals
+	MOVW	R14, 0(R13)			// push LR again for anything unwinding the stack
+	MOVW	R0, 12(R13)
+	MOVW	R1, 16(R13)
+
+	// zero out m and g structures
+	ADD	$20, R13, R0			// compute pointer to g
+	MOVW	R0, 4(R13)
+	MOVW	$(m__size + g__size), R0
+	MOVW	R0, 8(R13)
+	BL	runtime·memclrNoHeapPointers(SB)
+
+	// initialize m and g structures
+	ADD	$20, R13, R2			// R2 = g
+	ADD	$(20 + g__size), R13, R3	// R3 = m
+	MOVW	R2, m_g0(R3)			// m->g0 = g
+	MOVW	R3, g_m(R2)			// g->m = m
+	MOVW	R2, m_curg(R3)			// m->curg = g
+
+	MOVW	R2, g
+	BL	runtime·save_g(SB)
+
+	// set up stackguard stuff
+	MOVW	R13, R0
+	MOVW	R0, g_stack+stack_hi(g)
+	SUB	$(32*1024), R0
+	MOVW	R0, (g_stack+stack_lo)(g)
+	MOVW	R0, g_stackguard0(g)
+	MOVW	R0, g_stackguard1(g)
+
+	// move argument into position and call function
+	MOVW	12(R13), R0
+	MOVW	R0, 4(R13)
+	MOVW	16(R13), R1
+	BL	(R1)
+
+	// clear g
+	MOVW	$0, g
+	BL	runtime·save_g(SB)
+
+	MOVW	8(R13), R0			// load return value
+	ADD	$(m__size + g__size + 20), R13	// free locals
+	MOVM.IA.W (R13), [R4-R11, R15]		// pop {r4-r11, pc}
+
+GLOBL runtime·cbctxts(SB), NOPTR, $4
+
+TEXT runtime·callbackasm1(SB),NOSPLIT|NOFRAME,$0
+	// On entry, the trampoline in zcallback_windows_arm.s left
+	// the callback index in R12 (which is volatile in the C ABI).
+
+	// Push callback register arguments r0-r3. We do this first so
+	// they're contiguous with stack arguments.
+	MOVM.DB.W [R0-R3], (R13)
+	// Push C callee-save registers r4-r11 and lr.
+	MOVM.DB.W [R4-R11, R14], (R13)
+	SUB	$(16 + callbackArgs__size), R13	// space for locals
+
+	// Create a struct callbackArgs on our stack.
+	MOVW	R12, (16+callbackArgs_index)(R13)	// callback index
+	MOVW	$(16+callbackArgs__size+4*9)(R13), R0
+	MOVW	R0, (16+callbackArgs_args)(R13)		// address of args vector
+	MOVW	$0, R0
+	MOVW	R0, (16+callbackArgs_result)(R13)	// result
+
+	// Prepare for entry to Go.
+	BL	runtime·load_g(SB)
+
+	// Call cgocallback, which will call callbackWrap(frame).
+	MOVW	$0, R0
+	MOVW	R0, 12(R13)	// context
+	MOVW	$16(R13), R1	// R1 = &callbackArgs{...}
+	MOVW	R1, 8(R13)	// frame (address of callbackArgs)
+	MOVW	$·callbackWrap(SB), R1
+	MOVW	R1, 4(R13)	// PC of function to call
+	BL	runtime·cgocallback(SB)
+
+	// Get callback result.
+	MOVW	(16+callbackArgs_result)(R13), R0
+
+	ADD	$(16 + callbackArgs__size), R13	// free locals
+	MOVM.IA.W (R13), [R4-R11, R12]	// pop {r4-r11, lr=>r12}
+	ADD	$(4*4), R13	// skip r0-r3
+	B	(R12)	// return
+
+// uint32 tstart_stdcall(M *newm);
+TEXT runtime·tstart_stdcall(SB),NOSPLIT|NOFRAME,$0
+	MOVM.DB.W [R4-R11, R14], (R13)		// push {r4-r11, lr}
+
+	MOVW	m_g0(R0), g
+	MOVW	R0, g_m(g)
+	BL	runtime·save_g(SB)
+
+	// Layout new m scheduler stack on os stack.
+	MOVW	R13, R0
+	MOVW	R0, g_stack+stack_hi(g)
+	SUB	$(64*1024), R0
+	MOVW	R0, (g_stack+stack_lo)(g)
+	MOVW	R0, g_stackguard0(g)
+	MOVW	R0, g_stackguard1(g)
+
+	BL	runtime·emptyfunc(SB)	// fault if stack check is wrong
+	BL	runtime·mstart(SB)
+
+	// Exit the thread.
+	MOVW	$0, R0
+	MOVM.IA.W (R13), [R4-R11, R15]		// pop {r4-r11, pc}
+
+// Runs on OS stack.
+// duration (in -100ns units) is in dt+0(FP).
+// g may be nil.
+TEXT runtime·usleep2(SB),NOSPLIT|NOFRAME,$0-4
+	MOVW	dt+0(FP), R0
+	MOVM.DB.W [R4, R14], (R13)	// push {r4, lr}
+	MOVW	R13, R4			// Save SP
+	SUB	$8, R13			// R13 = R13 - 8
+	BIC	$0x7, R13		// Align SP for ABI
+	RSB	$0, R0, R3		// R3 = -R0
+	MOVW	$0, R1			// R1 = FALSE (alertable)
+	MOVW	$-1, R0			// R0 = handle
+	MOVW	R13, R2			// R2 = pTime
+	MOVW	R3, 0(R2)		// time_lo
+	MOVW	R0, 4(R2)		// time_hi
+	MOVW	runtime·_NtWaitForSingleObject(SB), R3
+	BL	(R3)
+	MOVW	R4, R13			// Restore SP
+	MOVM.IA.W (R13), [R4, R15]	// pop {R4, pc}
+
+// Runs on OS stack.
+// duration (in -100ns units) is in dt+0(FP).
+// g is valid.
+// TODO: neeeds to be implemented properly.
+TEXT runtime·usleep2HighRes(SB),NOSPLIT|NOFRAME,$0-4
+	B	runtime·abort(SB)
+
+// Runs on OS stack.
+TEXT runtime·switchtothread(SB),NOSPLIT|NOFRAME,$0
+	MOVM.DB.W [R4, R14], (R13)  	// push {R4, lr}
+	MOVW    R13, R4
+	BIC	$0x7, R13		// alignment for ABI
+	MOVW	runtime·_SwitchToThread(SB), R0
+	BL	(R0)
+	MOVW 	R4, R13			// restore stack pointer
+	MOVM.IA.W (R13), [R4, R15]	// pop {R4, pc}
+
+TEXT ·publicationBarrier(SB),NOSPLIT|NOFRAME,$0-0
+	B	runtime·armPublicationBarrier(SB)
+
+// never called (cgo not supported)
+TEXT runtime·read_tls_fallback(SB),NOSPLIT|NOFRAME,$0
+	MOVW	$0xabcd, R0
+	MOVW	R0, (R0)
+	RET
+
+// See http://www.dcl.hpi.uni-potsdam.de/research/WRK/2007/08/getting-os-information-the-kuser_shared_data-structure/
+// Must read hi1, then lo, then hi2. The snapshot is valid if hi1 == hi2.
+#define _INTERRUPT_TIME 0x7ffe0008
+#define _SYSTEM_TIME 0x7ffe0014
+#define time_lo 0
+#define time_hi1 4
+#define time_hi2 8
+
+TEXT runtime·nanotime1(SB),NOSPLIT|NOFRAME,$0-8
+	MOVW	$0, R0
+	MOVB	runtime·useQPCTime(SB), R0
+	CMP	$0, R0
+	BNE	useQPC
+	MOVW	$_INTERRUPT_TIME, R3
+loop:
+	MOVW	time_hi1(R3), R1
+	MOVW	time_lo(R3), R0
+	MOVW	time_hi2(R3), R2
+	CMP	R1, R2
+	BNE	loop
+
+	// wintime = R1:R0, multiply by 100
+	MOVW	$100, R2
+	MULLU	R0, R2, (R4, R3)    // R4:R3 = R1:R0 * R2
+	MULA	R1, R2, R4, R4
+
+	// wintime*100 = R4:R3
+	MOVW	R3, ret_lo+0(FP)
+	MOVW	R4, ret_hi+4(FP)
+	RET
+useQPC:
+	B	runtime·nanotimeQPC(SB)		// tail call
+
+TEXT time·now(SB),NOSPLIT|NOFRAME,$0-20
+	MOVW    $0, R0
+	MOVB    runtime·useQPCTime(SB), R0
+	CMP	$0, R0
+	BNE	useQPC
+	MOVW	$_INTERRUPT_TIME, R3
+loop:
+	MOVW	time_hi1(R3), R1
+	MOVW	time_lo(R3), R0
+	MOVW	time_hi2(R3), R2
+	CMP	R1, R2
+	BNE	loop
+
+	// wintime = R1:R0, multiply by 100
+	MOVW	$100, R2
+	MULLU	R0, R2, (R4, R3)    // R4:R3 = R1:R0 * R2
+	MULA	R1, R2, R4, R4
+
+	// wintime*100 = R4:R3
+	MOVW	R3, mono+12(FP)
+	MOVW	R4, mono+16(FP)
+
+	MOVW	$_SYSTEM_TIME, R3
+wall:
+	MOVW	time_hi1(R3), R1
+	MOVW	time_lo(R3), R0
+	MOVW	time_hi2(R3), R2
+	CMP	R1, R2
+	BNE	wall
+
+	// w = R1:R0 in 100ns untis
+	// convert to Unix epoch (but still 100ns units)
+	#define delta 116444736000000000
+	SUB.S   $(delta & 0xFFFFFFFF), R0
+	SBC     $(delta >> 32), R1
+
+	// Convert to nSec
+	MOVW    $100, R2
+	MULLU   R0, R2, (R4, R3)    // R4:R3 = R1:R0 * R2
+	MULA    R1, R2, R4, R4
+	// w = R2:R1 in nSec
+	MOVW    R3, R1	      // R4:R3 -> R2:R1
+	MOVW    R4, R2
+
+	// multiply nanoseconds by reciprocal of 10**9 (scaled by 2**61)
+	// to get seconds (96 bit scaled result)
+	MOVW	$0x89705f41, R3		// 2**61 * 10**-9
+	MULLU	R1,R3,(R6,R5)		// R7:R6:R5 = R2:R1 * R3
+	MOVW	$0,R7
+	MULALU	R2,R3,(R7,R6)
+
+	// unscale by discarding low 32 bits, shifting the rest by 29
+	MOVW	R6>>29,R6		// R7:R6 = (R7:R6:R5 >> 61)
+	ORR	R7<<3,R6
+	MOVW	R7>>29,R7
+
+	// subtract (10**9 * sec) from nsec to get nanosecond remainder
+	MOVW	$1000000000, R5	// 10**9
+	MULLU	R6,R5,(R9,R8)   // R9:R8 = R7:R6 * R5
+	MULA	R7,R5,R9,R9
+	SUB.S	R8,R1		// R2:R1 -= R9:R8
+	SBC	R9,R2
+
+	// because reciprocal was a truncated repeating fraction, quotient
+	// may be slightly too small -- adjust to make remainder < 10**9
+	CMP	R5,R1	// if remainder > 10**9
+	SUB.HS	R5,R1   //    remainder -= 10**9
+	ADD.HS	$1,R6	//    sec += 1
+
+	MOVW	R6,sec_lo+0(FP)
+	MOVW	R7,sec_hi+4(FP)
+	MOVW	R1,nsec+8(FP)
+	RET
+useQPC:
+	B	runtime·nowQPC(SB)		// tail call
+
+// save_g saves the g register (R10) into thread local memory
+// so that we can call externally compiled
+// ARM code that will overwrite those registers.
+// NOTE: runtime.gogo assumes that R1 is preserved by this function.
+//       runtime.mcall assumes this function only clobbers R0 and R11.
+// Returns with g in R0.
+// Save the value in the _TEB->TlsSlots array.
+// Effectively implements TlsSetValue().
+// tls_g stores the TLS slot allocated TlsAlloc().
+TEXT runtime·save_g(SB),NOSPLIT|NOFRAME,$0
+	MRC	15, 0, R0, C13, C0, 2
+	ADD	$0xe10, R0
+	MOVW 	$runtime·tls_g(SB), R11
+	MOVW	(R11), R11
+	MOVW	g, R11<<2(R0)
+	MOVW	g, R0	// preserve R0 across call to setg<>
+	RET
+
+// load_g loads the g register from thread-local memory,
+// for use after calling externally compiled
+// ARM code that overwrote those registers.
+// Get the value from the _TEB->TlsSlots array.
+// Effectively implements TlsGetValue().
+TEXT runtime·load_g(SB),NOSPLIT|NOFRAME,$0
+	MRC	15, 0, R0, C13, C0, 2
+	ADD	$0xe10, R0
+	MOVW 	$runtime·tls_g(SB), g
+	MOVW	(g), g
+	MOVW	g<<2(R0), g
+	RET
+
+// This is called from rt0_go, which runs on the system stack
+// using the initial stack allocated by the OS.
+// It calls back into standard C using the BL below.
+// To do that, the stack pointer must be 8-byte-aligned.
+TEXT runtime·_initcgo(SB),NOSPLIT|NOFRAME,$0
+	MOVM.DB.W [R4, R14], (R13)	// push {r4, lr}
+
+	// Ensure stack is 8-byte aligned before calling C code
+	MOVW	R13, R4
+	BIC	$0x7, R13
+
+	// Allocate a TLS slot to hold g across calls to external code
+	MOVW 	$runtime·_TlsAlloc(SB), R0
+	MOVW	(R0), R0
+	BL	(R0)
+
+	// Assert that slot is less than 64 so we can use _TEB->TlsSlots
+	CMP	$64, R0
+	MOVW	$runtime·abort(SB), R1
+	BL.GE	(R1)
+
+	// Save Slot into tls_g
+	MOVW 	$runtime·tls_g(SB), R1
+	MOVW	R0, (R1)
+
+	MOVW	R4, R13
+	MOVM.IA.W (R13), [R4, R15]	// pop {r4, pc}
+
+// Holds the TLS Slot, which was allocated by TlsAlloc()
+GLOBL runtime·tls_g+0(SB), NOPTR, $4
+
+#endif
-- 
GitLab


From c7c6c113be96b7b68f54696d2986f98dc9df64d6 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 1 Feb 2021 15:12:08 -0500
Subject: [PATCH 0720/2400] runtime: convert windows/arm64 assembly

The assembly is mostly a straightforward conversion of the
equivalent arm assembly.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.

Change-Id: I61b15d712ade4d3a7285c7680de8e0987aacba10
Reviewed-on: https://go-review.googlesource.com/c/go/+/288828
Trust: Russ Cox <rsc@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/asm_arm64.s         |   7 +
 src/runtime/defs_windows.go     |   1 +
 src/runtime/memclr_arm.s        |   1 +
 src/runtime/memclr_arm64.s      |   1 +
 src/runtime/os_windows.go       |   3 +
 src/runtime/signal_windows.go   |   1 +
 src/runtime/stubs_arm64.go      |   2 +
 src/runtime/sys_windows_arm.s   |  18 +-
 src/runtime/sys_windows_arm64.s | 807 ++++++++++++++++----------------
 src/runtime/syscall_windows.go  |   1 +
 src/runtime/tls_arm64.h         |  12 +-
 src/runtime/tls_arm64.s         |   8 +-
 12 files changed, 441 insertions(+), 421 deletions(-)

diff --git a/src/runtime/asm_arm64.s b/src/runtime/asm_arm64.s
index d81759537e..699fc99d58 100644
--- a/src/runtime/asm_arm64.s
+++ b/src/runtime/asm_arm64.s
@@ -73,6 +73,10 @@ nocgo:
 
 	BL	runtime·check(SB)
 
+#ifdef GOOS_windows
+	BL	runtime·wintls(SB)
+#endif
+
 	MOVW	8(RSP), R0	// copy argc
 	MOVW	R0, -8(RSP)
 	MOVD	16(RSP), R0		// copy argv
@@ -1111,6 +1115,9 @@ TEXT setg_gcc<>(SB),NOSPLIT,$8
 	MOVD	savedR27-8(SP), R27
 	RET
 
+TEXT runtime·emptyfunc(SB),0,$0-0
+	RET
+
 TEXT runtime·abort(SB),NOSPLIT|NOFRAME,$0-0
 	MOVD	ZR, R0
 	MOVD	(R0), R0
diff --git a/src/runtime/defs_windows.go b/src/runtime/defs_windows.go
index 656fd2b8b6..8d4e38120e 100644
--- a/src/runtime/defs_windows.go
+++ b/src/runtime/defs_windows.go
@@ -28,6 +28,7 @@ const (
 
 	_EXCEPTION_ACCESS_VIOLATION     = 0xc0000005
 	_EXCEPTION_BREAKPOINT           = 0x80000003
+	_EXCEPTION_ILLEGAL_INSTRUCTION  = 0xc000001d
 	_EXCEPTION_FLT_DENORMAL_OPERAND = 0xc000008d
 	_EXCEPTION_FLT_DIVIDE_BY_ZERO   = 0xc000008e
 	_EXCEPTION_FLT_INEXACT_RESULT   = 0xc000008f
diff --git a/src/runtime/memclr_arm.s b/src/runtime/memclr_arm.s
index f113a1aa2d..f02d058ead 100644
--- a/src/runtime/memclr_arm.s
+++ b/src/runtime/memclr_arm.s
@@ -33,6 +33,7 @@
 // See memclrNoHeapPointers Go doc for important implementation constraints.
 
 // func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
+// Also called from assembly in sys_windows_arm.s without g (but using Go stack convention).
 TEXT runtime·memclrNoHeapPointers(SB),NOSPLIT,$0-8
 	MOVW	ptr+0(FP), TO
 	MOVW	n+4(FP), N
diff --git a/src/runtime/memclr_arm64.s b/src/runtime/memclr_arm64.s
index bef77651e4..c1a0dcef58 100644
--- a/src/runtime/memclr_arm64.s
+++ b/src/runtime/memclr_arm64.s
@@ -7,6 +7,7 @@
 // See memclrNoHeapPointers Go doc for important implementation constraints.
 
 // func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
+// Also called from assembly in sys_windows_arm64.s without g (but using Go stack convention).
 TEXT runtime·memclrNoHeapPointers(SB),NOSPLIT,$0-16
 	MOVD	ptr+0(FP), R0
 	MOVD	n+8(FP), R1
diff --git a/src/runtime/os_windows.go b/src/runtime/os_windows.go
index 375c34ed99..f4e21a93ed 100644
--- a/src/runtime/os_windows.go
+++ b/src/runtime/os_windows.go
@@ -148,6 +148,9 @@ func tstart_stdcall(newm *m)
 // Called by OS using stdcall ABI.
 func ctrlhandler()
 
+// Init-time helper
+func wintls()
+
 type mOS struct {
 	threadLock mutex   // protects "thread" and prevents closing
 	thread     uintptr // thread handle
diff --git a/src/runtime/signal_windows.go b/src/runtime/signal_windows.go
index cb1fbe9f81..6215d0ba2d 100644
--- a/src/runtime/signal_windows.go
+++ b/src/runtime/signal_windows.go
@@ -81,6 +81,7 @@ func isgoexception(info *exceptionrecord, r *context) bool {
 	case _EXCEPTION_FLT_OVERFLOW:
 	case _EXCEPTION_FLT_UNDERFLOW:
 	case _EXCEPTION_BREAKPOINT:
+	case _EXCEPTION_ILLEGAL_INSTRUCTION: // breakpoint arrives this way on arm64
 	}
 	return true
 }
diff --git a/src/runtime/stubs_arm64.go b/src/runtime/stubs_arm64.go
index 6e6e7df6b8..f5e3bb4854 100644
--- a/src/runtime/stubs_arm64.go
+++ b/src/runtime/stubs_arm64.go
@@ -12,3 +12,5 @@ func save_g()
 
 //go:noescape
 func asmcgocall_no_g(fn, arg unsafe.Pointer)
+
+func emptyfunc()
diff --git a/src/runtime/sys_windows_arm.s b/src/runtime/sys_windows_arm.s
index 3f01714c66..cd230ccffd 100644
--- a/src/runtime/sys_windows_arm.s
+++ b/src/runtime/sys_windows_arm.s
@@ -176,17 +176,17 @@ done:
 	BEQ	return
 
 	// Check if we need to set up the control flow guard workaround.
-	// On Windows/ARM, the stack pointer must lie within system
-	// stack limits when we resume from exception.
+	// On Windows, the stack pointer in the context must lie within
+	// system stack limits when we resume from exception.
 	// Store the resume SP and PC on the g0 stack,
-	// and return to returntramp on the g0 stack. returntramp
+	// and return to sigresume on the g0 stack. sigresume
 	// pops the saved PC and SP from the g0 stack, resuming execution
 	// at the desired location.
-	// If returntramp has already been set up by a previous exception
+	// If sigresume has already been set up by a previous exception
 	// handler, don't clobber the stored SP and PC on the stack.
 	MOVW	4(R3), R3			// PEXCEPTION_POINTERS->Context
 	MOVW	context_pc(R3), R2		// load PC from context record
-	MOVW	$returntramp<>(SB), R1
+	MOVW	$sigresume<>(SB), R1
 	CMP	R1, R2
 	B.EQ	return				// do not clobber saved SP/PC
 
@@ -196,9 +196,9 @@ done:
 	MOVW	context_pc(R3), R2
 	MOVW	R2, context_r1(R3)
 
-	// Set up context record to return to returntramp on g0 stack
+	// Set up context record to return to sigresume on g0 stack
 	MOVW	R12, context_spr(R3)
-	MOVW	$returntramp<>(SB), R2
+	MOVW	$sigresume<>(SB), R2
 	MOVW	R2, context_pc(R3)
 
 return:
@@ -208,8 +208,8 @@ return:
 // This is part of the control flow guard workaround.
 // It switches stacks and jumps to the continuation address.
 // R0 and R1 are set above at the end of sigtramp<>
-// in the context that starts executing at returntramp<>.
-TEXT returntramp<>(SB),NOSPLIT|NOFRAME,$0
+// in the context that starts executing at sigresume<>.
+TEXT sigresume<>(SB),NOSPLIT|NOFRAME,$0
 	// Important: do not smash LR,
 	// which is set to a live value when handling
 	// a signal by pushing a call to sigpanic onto the stack.
diff --git a/src/runtime/sys_windows_arm64.s b/src/runtime/sys_windows_arm64.s
index b279f25de8..53960488f9 100644
--- a/src/runtime/sys_windows_arm64.s
+++ b/src/runtime/sys_windows_arm64.s
@@ -5,108 +5,150 @@
 #include "go_asm.h"
 #include "go_tls.h"
 #include "textflag.h"
+#include "funcdata.h"
 
-#ifdef NOT_PORTED
+// Offsets into Thread Environment Block (pointer in R18)
+#define TEB_error 0x68
+#define TEB_TlsSlots 0x1480
 
-// Note: For system ABI, R0-R3 are args, R4-R11 are callee-save.
+// Note: R0-R7 are args, R8 is indirect return value address,
+// R9-R15 are caller-save, R19-R29 are callee-save.
+//
+// load_g and save_g (in tls_arm64.s) clobber R27 (REGTMP) and R0.
 
 // void runtime·asmstdcall(void *c);
 TEXT runtime·asmstdcall(SB),NOSPLIT|NOFRAME,$0
-	MOVM.DB.W [R4, R5, R14], (R13)	// push {r4, r5, lr}
-	MOVW	R0, R4			// put libcall * in r4
-	MOVW	R13, R5			// save stack pointer in r5
+	STP.W	(R29, R30), -32(RSP)	// allocate C ABI stack frame
+	STP	(R19, R20), 16(RSP) // save old R19, R20
+	MOVD	R0, R19	// save libcall pointer
+	MOVD	RSP, R20	// save stack pointer
 
 	// SetLastError(0)
-	MOVW	$0, R0
-	MRC	15, 0, R1, C13, C0, 2
-	MOVW	R0, 0x34(R1)
-
-	MOVW	8(R4), R12	// libcall->args
-
-	// Do we have more than 4 arguments?
-	MOVW	4(R4), R0	// libcall->n
-	SUB.S	$4, R0, R2
-	BLE	loadregs
+	MOVD	$0,	TEB_error(R18_PLATFORM)
+	MOVD	libcall_args(R19), R12	// libcall->args
+
+	// Do we have more than 8 arguments?
+	MOVD	libcall_n(R19), R0
+	CMP	$0,	R0; BEQ	_0args
+	CMP	$1,	R0; BEQ	_1args
+	CMP	$2,	R0; BEQ	_2args
+	CMP	$3,	R0; BEQ	_3args
+	CMP	$4,	R0; BEQ	_4args
+	CMP	$5,	R0; BEQ	_5args
+	CMP	$6,	R0; BEQ	_6args
+	CMP	$7,	R0; BEQ	_7args
+	CMP	$8,	R0; BEQ	_8args
 
 	// Reserve stack space for remaining args
-	SUB	R2<<2, R13
-	BIC	$0x7, R13	// alignment for ABI
-
-	// R0: count of arguments
-	// R1:
-	// R2: loop counter, from 0 to (n-4)
-	// R3: scratch
-	// R4: pointer to libcall struct
-	// R12: libcall->args
-	MOVW	$0, R2
+	SUB	$8, R0, R2
+	ADD	$1, R2, R3 // make even number of words for stack alignment
+	AND	$~1, R3
+	LSL	$3, R3
+	SUB	R3, RSP
+
+	// R4: size of stack arguments (n-8)*8
+	// R5: &args[8]
+	// R6: loop counter, from 0 to (n-8)*8
+	// R7: scratch
+	// R8: copy of RSP - (R2)(RSP) assembles as (R2)(ZR)
+	SUB	$8, R0, R4
+	LSL	$3, R4
+	ADD	$(8*8), R12, R5
+	MOVD	$0, R6
+	MOVD	RSP, R8
 stackargs:
-	ADD	$4, R2, R3		// r3 = args[4 + i]
-	MOVW	R3<<2(R12), R3
-	MOVW	R3, R2<<2(R13)		// stack[i] = r3
-
-	ADD	$1, R2			// i++
-	SUB	$4, R0, R3		// while (i < (n - 4))
-	CMP	R3, R2
-	BLT	stackargs
-
-loadregs:
-	CMP	$3, R0
-	MOVW.GT 12(R12), R3
-
-	CMP	$2, R0
-	MOVW.GT 8(R12), R2
-
-	CMP	$1, R0
-	MOVW.GT 4(R12), R1
-
-	CMP	$0, R0
-	MOVW.GT 0(R12), R0
-
-	BIC	$0x7, R13		// alignment for ABI
-	MOVW	0(R4), R12		// branch to libcall->fn
+	MOVD	(R6)(R5), R7
+	MOVD	R7, (R6)(R8)
+	ADD	$8, R6
+	CMP	R6, R4
+	BNE	stackargs
+
+_8args:
+	MOVD	(7*8)(R12), R7
+_7args:
+	MOVD	(6*8)(R12), R6
+_6args:
+	MOVD	(5*8)(R12), R5
+_5args:
+	MOVD	(4*8)(R12), R4
+_4args:
+	MOVD	(3*8)(R12), R3
+_3args:
+	MOVD	(2*8)(R12), R2
+_2args:
+	MOVD	(1*8)(R12), R1
+_1args:
+	MOVD	(0*8)(R12), R0
+_0args:
+
+	MOVD	libcall_fn(R19), R12	// branch to libcall->fn
 	BL	(R12)
 
-	MOVW	R5, R13			// free stack space
-	MOVW	R0, 12(R4)		// save return value to libcall->r1
-	MOVW	R1, 16(R4)
+	MOVD	R20, RSP			// free stack space
+	MOVD	R0, libcall_r1(R19)		// save return value to libcall->r1
+	// TODO(rsc) floating point like amd64 in libcall->r2?
 
 	// GetLastError
-	MRC	15, 0, R1, C13, C0, 2
-	MOVW	0x34(R1), R0
-	MOVW	R0, 20(R4)		// store in libcall->err
+	MOVD	TEB_error(R18_PLATFORM), R0
+	MOVD	R0, libcall_err(R19)
 
-	MOVM.IA.W (R13), [R4, R5, R15]
+	// Restore callee-saved registers.
+	LDP	16(RSP), (R19, R20)
+	LDP.P	32(RSP), (R29, R30)
+	RET
 
-TEXT runtime·badsignal2(SB),NOSPLIT|NOFRAME,$0
-	MOVM.DB.W [R4, R14], (R13)	// push {r4, lr}
-	MOVW	R13, R4			// save original stack pointer
-	SUB	$8, R13			// space for 2 variables
-	BIC	$0x7, R13		// alignment for ABI
+TEXT runtime·badsignal2(SB),NOSPLIT,$16-0
+	NO_LOCAL_POINTERS
 
 	// stderr
-	MOVW	runtime·_GetStdHandle(SB), R1
-	MOVW	$-12, R0
+	MOVD	runtime·_GetStdHandle(SB), R1
+	MOVD	$-12, R0
+	SUB	$16, RSP	// skip over saved frame pointer below RSP
 	BL	(R1)
-
-	MOVW	$runtime·badsignalmsg(SB), R1	// lpBuffer
-	MOVW	$runtime·badsignallen(SB), R2	// lpNumberOfBytesToWrite
-	MOVW	(R2), R2
-	ADD	$0x4, R13, R3		// lpNumberOfBytesWritten
-	MOVW	$0, R12			// lpOverlapped
-	MOVW	R12, (R13)
-
-	MOVW	runtime·_WriteFile(SB), R12
+	ADD	$16, RSP
+
+	// handle in R0 already
+	MOVD	$runtime·badsignalmsg(SB), R1	// lpBuffer
+	MOVD	$runtime·badsignallen(SB), R2	// lpNumberOfBytesToWrite
+	MOVD	(R2), R2
+	MOVD	R13, R3		// lpNumberOfBytesWritten
+	MOVD	$0, R4			// lpOverlapped
+	MOVD	runtime·_WriteFile(SB), R12
+	SUB	$16, RSP	// skip over saved frame pointer below RSP
 	BL	(R12)
+	ADD	$16, RSP
 
-	MOVW	R4, R13			// restore SP
-	MOVM.IA.W (R13), [R4, R15]	// pop {r4, pc}
+	RET
 
-TEXT runtime·getlasterror(SB),NOSPLIT,$0
-	MRC	15, 0, R0, C13, C0, 2
-	MOVW	0x34(R0), R0
-	MOVW	R0, ret+0(FP)
+TEXT runtime·getlasterror(SB),NOSPLIT|NOFRAME,$0
+	MOVD	TEB_error(R18_PLATFORM), R0
+	MOVD	R0, ret+0(FP)
 	RET
 
+#define SAVE_R19_TO_R28(offset) \
+	MOVD	R19, savedR19+((offset)+0*8)(SP); \
+	MOVD	R20, savedR20+((offset)+1*8)(SP); \
+	MOVD	R21, savedR21+((offset)+2*8)(SP); \
+	MOVD	R22, savedR22+((offset)+3*8)(SP); \
+	MOVD	R23, savedR23+((offset)+4*8)(SP); \
+	MOVD	R24, savedR24+((offset)+5*8)(SP); \
+	MOVD	R25, savedR25+((offset)+6*8)(SP); \
+	MOVD	R26, savedR26+((offset)+7*8)(SP); \
+	MOVD	R27, savedR27+((offset)+8*8)(SP); \
+	MOVD	g, savedR28+((offset)+9*8)(SP);
+
+#define RESTORE_R19_TO_R28(offset) \
+	MOVD	savedR19+((offset)+0*8)(SP), R19; \
+	MOVD	savedR20+((offset)+1*8)(SP), R20; \
+	MOVD	savedR21+((offset)+2*8)(SP), R21; \
+	MOVD	savedR22+((offset)+3*8)(SP), R22; \
+	MOVD	savedR23+((offset)+4*8)(SP), R23; \
+	MOVD	savedR24+((offset)+5*8)(SP), R24; \
+	MOVD	savedR25+((offset)+6*8)(SP), R25; \
+	MOVD	savedR26+((offset)+7*8)(SP), R26; \
+	MOVD	savedR27+((offset)+8*8)(SP), R27; \
+	MOVD	savedR28+((offset)+9*8)(SP), g; /* R28 */
+
 // Called by Windows as a Vectored Exception Handler (VEH).
 // First argument is pointer to struct containing
 // exception record and context pointers.
@@ -116,61 +158,83 @@ TEXT runtime·getlasterror(SB),NOSPLIT,$0
 //     PEXCEPTION_POINTERS ExceptionInfo,
 //     func *GoExceptionHandler);
 TEXT sigtramp<>(SB),NOSPLIT|NOFRAME,$0
-	MOVM.DB.W [R0, R4-R11, R14], (R13)	// push {r0, r4-r11, lr} (SP-=40)
-	SUB	$(8+20), R13		// reserve space for g, sp, and
-					// parameters/retval to go call
+	// Save R0, R1 (args) as well as LR, R27, R28 (callee-save).
+	MOVD	R0, R5
+	MOVD	R1, R6
+	MOVD	LR, R7
+	MOVD	R27, R16		// saved R27 (callee-save)
+	MOVD	g, R17 			// saved R28 (callee-save from Windows, not really g)
+
+	BL      runtime·load_g(SB)	// smashes R0, R27, R28 (g)
+	CMP	$0, g			// is there a current g?
+	BNE	2(PC)
+	BL	runtime·badsignal2(SB)
+
+	// Do we need to switch to the g0 stack?
+	MOVD	g, R3			// R3 = oldg (for sigtramp_g0)
+	MOVD	g_m(g), R2		// R2 = m
+	MOVD	m_g0(R2), R2		// R2 = g0
+	CMP	g, R2			// if curg == g0
+	BNE	switch
+
+	// No: on g0 stack already, tail call to sigtramp_g0.
+	// Restore all the callee-saves so sigtramp_g0 can return to our caller.
+	// We also pass R2 = g0, R3 = oldg, both set above.
+	MOVD	R5, R0
+	MOVD	R6, R1
+	MOVD	R7, LR
+	MOVD	R16, R27		// restore R27
+	MOVD	R17, g 			// restore R28
+	B	sigtramp_g0<>(SB)
+
+switch:
+	// switch to g0 stack (but do not update g - that's sigtramp_g0's job)
+	MOVD	RSP, R8
+	MOVD	(g_sched+gobuf_sp)(R2), R4	// R4 = g->gobuf.sp
+	SUB	$(6*8), R4			// alloc space for saves - 2 words below SP for frame pointer, 3 for us to use, 1 for alignment
+	MOVD	R4, RSP				// switch to g0 stack
+
+	MOVD	$0, (0*8)(RSP)	// fake saved LR
+	MOVD	R7, (1*8)(RSP)	// saved LR
+	MOVD	R8, (2*8)(RSP)	// saved SP
+
+	MOVD	R5, R0		// original args
+	MOVD	R6, R1		// original args
+	MOVD	R16, R27
+	MOVD	R17, g 		// R28
+	BL	sigtramp_g0<>(SB)
+
+	// switch back to original stack; g already updated
+	MOVD	(1*8)(RSP), R7	// saved LR
+	MOVD	(2*8)(RSP), R8	// saved SP
+	MOVD	R7, LR
+	MOVD	R8, RSP
+	RET
 
-	MOVW	R0, R6			// Save param0
-	MOVW	R1, R7			// Save param1
+// sigtramp_g0 is running on the g0 stack, with R2 = g0, R3 = oldg.
+// But g itself is not set - that's R28, a callee-save register,
+// and it still holds the value from the Windows DLL caller.
+TEXT sigtramp_g0<>(SB),NOSPLIT,$128
+	NO_LOCAL_POINTERS
 
-	BL      runtime·load_g(SB)
-	CMP	$0, g			// is there a current g?
-	BL.EQ	runtime·badsignal2(SB)
-
-	// save g and SP in case of stack switch
-	MOVW	R13, 24(R13)
-	MOVW	g, 20(R13)
-
-	// do we need to switch to the g0 stack?
-	MOVW	g, R5			// R5 = g
-	MOVW	g_m(R5), R2		// R2 = m
-	MOVW	m_g0(R2), R4		// R4 = g0
-	CMP	R5, R4			// if curg == g0
-	BEQ	g0
-
-	// switch to g0 stack
-	MOVW	R4, g				// g = g0
-	MOVW	(g_sched+gobuf_sp)(g), R3	// R3 = g->gobuf.sp
-	BL      runtime·save_g(SB)
-
-	// make room for sighandler arguments
-	// and re-save old SP for restoring later.
-	// (note that the 24(R3) here must match the 24(R13) above.)
-	SUB	$40, R3
-	MOVW	R13, 24(R3)		// save old stack pointer
-	MOVW	R3, R13			// switch stack
-
-g0:
-	MOVW	0(R6), R2	// R2 = ExceptionPointers->ExceptionRecord
-	MOVW	4(R6), R3	// R3 = ExceptionPointers->ContextRecord
-
-	MOVW	$0, R4
-	MOVW	R4, 0(R13)	// No saved link register.
-	MOVW	R2, 4(R13)	// Move arg0 (ExceptionRecord) into position
-	MOVW	R3, 8(R13)	// Move arg1 (ContextRecord) into position
-	MOVW	R5, 12(R13)	// Move arg2 (original g) into position
-	BL	(R7)		// Call the go routine
-	MOVW	16(R13), R4	// Fetch return value from stack
-
-	// switch back to original stack and g
-	MOVW	24(R13), R13
-	MOVW	20(R13), g
-	BL      runtime·save_g(SB)
-
-done:
-	MOVW	R4, R0				// move retval into position
-	ADD	$(8 + 20), R13			// free locals
-	MOVM.IA.W (R13), [R3, R4-R11, R14]	// pop {r3, r4-r11, lr}
+	// Push C callee-save registers R19-R28. LR, FP already saved.
+	SAVE_R19_TO_R28(-10*8)
+
+	MOVD	0(R0), R5	// R5 = ExceptionPointers->ExceptionRecord
+	MOVD	8(R0), R6	// R6 = ExceptionPointers->ContextRecord
+	MOVD	R6, context-(11*8)(SP)
+
+	MOVD	R2, g 			// g0
+	BL      runtime·save_g(SB)	// smashes R0
+
+	MOVD	R5, (1*8)(RSP)	// arg0 (ExceptionRecord)
+	MOVD	R6, (2*8)(RSP)	// arg1 (ContextRecord)
+	MOVD	R3, (3*8)(RSP)	// arg2 (original g)
+	MOVD	R3, oldg-(12*8)(SP)
+	BL	(R1)
+	MOVD	oldg-(12*8)(SP), g
+	BL      runtime·save_g(SB)	// smashes R0
+	MOVW	(4*8)(RSP), R0	// return value (0 or -1)
 
 	// if return value is CONTINUE_SEARCH, do not set up control
 	// flow guard workaround
@@ -178,240 +242,232 @@ done:
 	BEQ	return
 
 	// Check if we need to set up the control flow guard workaround.
-	// On Windows/ARM, the stack pointer must lie within system
-	// stack limits when we resume from exception.
-	// Store the resume SP and PC on the g0 stack,
-	// and return to returntramp on the g0 stack. returntramp
-	// pops the saved PC and SP from the g0 stack, resuming execution
-	// at the desired location.
-	// If returntramp has already been set up by a previous exception
-	// handler, don't clobber the stored SP and PC on the stack.
-	MOVW	4(R3), R3			// PEXCEPTION_POINTERS->Context
-	MOVW	context_pc(R3), R2		// load PC from context record
-	MOVW	$returntramp<>(SB), R1
+	// On Windows, the stack pointer in the context must lie within
+	// system stack limits when we resume from exception.
+	// Store the resume SP and PC in alternate registers
+	// and return to sigresume on the g0 stack.
+	// sigresume makes no use of the stack at all,
+	// loading SP from R0 and jumping to R1.
+	// Note that smashing R0 and R1 is only safe because we know sigpanic
+	// will not actually return to the original frame, so the registers
+	// are effectively dead. But this does mean we can't use the
+	// same mechanism for async preemption.
+	MOVD	context-(11*8)(SP), R6
+	MOVD	context_pc(R6), R2		// load PC from context record
+	MOVD	$sigresume<>(SB), R1
+
 	CMP	R1, R2
-	B.EQ	return				// do not clobber saved SP/PC
+	BEQ	return				// do not clobber saved SP/PC
 
 	// Save resume SP and PC into R0, R1.
-	MOVW	context_spr(R3), R2
-	MOVW	R2, context_r0(R3)
-	MOVW	context_pc(R3), R2
-	MOVW	R2, context_r1(R3)
+	MOVD	context_xsp(R6), R2
+	MOVD	R2, (context_x+0*8)(R6)
+	MOVD	context_pc(R6), R2
+	MOVD	R2, (context_x+1*8)(R6)
 
-	// Set up context record to return to returntramp on g0 stack
-	MOVW	R12, context_spr(R3)
-	MOVW	$returntramp<>(SB), R2
-	MOVW	R2, context_pc(R3)
+	// Set up context record to return to sigresume on g0 stack
+	MOVD	RSP, R2
+	MOVD	R2, context_xsp(R6)
+	MOVD	$sigresume<>(SB), R2
+	MOVD	R2, context_pc(R6)
 
 return:
-	B	(R14)				// return
+	RESTORE_R19_TO_R28(-10*8)		// smashes g
+	RET
 
 // Trampoline to resume execution from exception handler.
 // This is part of the control flow guard workaround.
 // It switches stacks and jumps to the continuation address.
 // R0 and R1 are set above at the end of sigtramp<>
-// in the context that starts executing at returntramp<>.
-TEXT returntramp<>(SB),NOSPLIT|NOFRAME,$0
+// in the context that starts executing at sigresume<>.
+TEXT sigresume<>(SB),NOSPLIT|NOFRAME,$0
 	// Important: do not smash LR,
 	// which is set to a live value when handling
 	// a signal by pushing a call to sigpanic onto the stack.
-	MOVW	R0, R13
+	MOVD	R0, RSP
 	B	(R1)
 
 TEXT runtime·exceptiontramp(SB),NOSPLIT|NOFRAME,$0
-	MOVW	$runtime·exceptionhandler(SB), R1
+	MOVD	$runtime·exceptionhandler(SB), R1
 	B	sigtramp<>(SB)
 
 TEXT runtime·firstcontinuetramp(SB),NOSPLIT|NOFRAME,$0
-	MOVW	$runtime·firstcontinuehandler(SB), R1
+	MOVD	$runtime·firstcontinuehandler(SB), R1
 	B	sigtramp<>(SB)
 
 TEXT runtime·lastcontinuetramp(SB),NOSPLIT|NOFRAME,$0
-	MOVW	$runtime·lastcontinuehandler(SB), R1
+	MOVD	$runtime·lastcontinuehandler(SB), R1
 	B	sigtramp<>(SB)
 
 TEXT runtime·ctrlhandler(SB),NOSPLIT|NOFRAME,$0
-	MOVW	$runtime·ctrlhandler1(SB), R1
+	MOVD	$runtime·ctrlhandler1(SB), R1
 	B	runtime·externalthreadhandler(SB)
 
 TEXT runtime·profileloop(SB),NOSPLIT|NOFRAME,$0
-	MOVW	$runtime·profileloop1(SB), R1
+	MOVD	$runtime·profileloop1(SB), R1
 	B	runtime·externalthreadhandler(SB)
 
-// int32 externalthreadhandler(uint32 arg, int (*func)(uint32))
-// stack layout:
-//   +----------------+
-//   | callee-save    |
-//   | registers      |
-//   +----------------+
-//   | m              |
-//   +----------------+
-// 20| g              |
-//   +----------------+
-// 16| func ptr (r1)  |
-//   +----------------+
-// 12| argument (r0)  |
-//---+----------------+
-// 8 | param1         | (also return value for called Go function)
-//   +----------------+
-// 4 | param0         |
-//   +----------------+
-// 0 | slot for LR    |
-//   +----------------+
-//
-TEXT runtime·externalthreadhandler(SB),NOSPLIT|NOFRAME|TOPFRAME,$0
-	MOVM.DB.W [R4-R11, R14], (R13)		// push {r4-r11, lr}
-	SUB	$(m__size + g__size + 20), R13	// space for locals
-	MOVW	R14, 0(R13)			// push LR again for anything unwinding the stack
-	MOVW	R0, 12(R13)
-	MOVW	R1, 16(R13)
-
-	// zero out m and g structures
-	ADD	$20, R13, R0			// compute pointer to g
-	MOVW	R0, 4(R13)
-	MOVW	$(m__size + g__size), R0
-	MOVW	R0, 8(R13)
+// externalthreadhander called with R0 = uint32 arg, R1 = Go function f.
+// Need to call f(arg), which returns a uint32, and return it in R0.
+TEXT runtime·externalthreadhandler(SB),NOSPLIT|TOPFRAME,$96-0
+	NO_LOCAL_POINTERS
+
+	// Push C callee-save registers R19-R28. LR, FP already saved.
+	SAVE_R19_TO_R28(-10*8)
+
+	// Allocate space for args, saved R0+R1, g, and m structures.
+	// Hide from nosplit check.
+	#define extra ((64+g__size+m__size+15)&~15)
+	SUB	$extra, RSP, R2	// hide from nosplit overflow check
+	MOVD	R2, RSP
+
+	// Save R0 and R1 (our args).
+	MOVD	R0, 32(RSP)
+	MOVD	R1, 40(RSP)
+
+	// Zero out m and g structures.
+	MOVD	$64(RSP), R0
+	MOVD	R0, 8(RSP)
+	MOVD	$(m__size + g__size), R0
+	MOVD	R0, 16(RSP)
+	MOVD	$0, 0(RSP)	// not-saved LR
 	BL	runtime·memclrNoHeapPointers(SB)
 
-	// initialize m and g structures
-	ADD	$20, R13, R2			// R2 = g
-	ADD	$(20 + g__size), R13, R3	// R3 = m
-	MOVW	R2, m_g0(R3)			// m->g0 = g
-	MOVW	R3, g_m(R2)			// g->m = m
-	MOVW	R2, m_curg(R3)			// m->curg = g
-
-	MOVW	R2, g
+	// Initialize m and g structures.
+	MOVD	$64(RSP), g
+	MOVD	$g__size(g), R3		// m
+	MOVD	R3, g_m(g)		// g->m = m
+	MOVD	g, m_g0(R3)		// m->g0 = g
+	MOVD	g, m_curg(R3)		// m->curg = g
+	MOVD	RSP, R0
+	MOVD	R0, g_stack+stack_hi(g)
+	SUB	$(32*1024), R0
+	MOVD	R0, (g_stack+stack_lo)(g)
+	MOVD	R0, g_stackguard0(g)
+	MOVD	R0, g_stackguard1(g)
 	BL	runtime·save_g(SB)
 
-	// set up stackguard stuff
-	MOVW	R13, R0
-	MOVW	R0, g_stack+stack_hi(g)
-	SUB	$(32*1024), R0
-	MOVW	R0, (g_stack+stack_lo)(g)
-	MOVW	R0, g_stackguard0(g)
-	MOVW	R0, g_stackguard1(g)
-
-	// move argument into position and call function
-	MOVW	12(R13), R0
-	MOVW	R0, 4(R13)
-	MOVW	16(R13), R1
+	// Call function.
+	MOVD	32(RSP), R0
+	MOVD	40(RSP), R1
+	MOVW	R0, 8(RSP)
 	BL	(R1)
 
-	// clear g
-	MOVW	$0, g
+	// Clear g.
+	MOVD	$0, g
 	BL	runtime·save_g(SB)
 
-	MOVW	8(R13), R0			// load return value
-	ADD	$(m__size + g__size + 20), R13	// free locals
-	MOVM.IA.W (R13), [R4-R11, R15]		// pop {r4-r11, pc}
+	// Load return value (save_g would have smashed)
+	MOVW	(2*8)(RSP), R0
+
+	ADD	$extra, RSP, R2
+	MOVD	R2, RSP
+	#undef extra
+
+	RESTORE_R19_TO_R28(-10*8)
+	RET
 
 GLOBL runtime·cbctxts(SB), NOPTR, $4
 
-TEXT runtime·callbackasm1(SB),NOSPLIT|NOFRAME,$0
-	// On entry, the trampoline in zcallback_windows_arm.s left
+TEXT runtime·callbackasm1(SB),NOSPLIT,$208-0
+	NO_LOCAL_POINTERS
+
+	// On entry, the trampoline in zcallback_windows_arm64.s left
 	// the callback index in R12 (which is volatile in the C ABI).
 
-	// Push callback register arguments r0-r3. We do this first so
-	// they're contiguous with stack arguments.
-	MOVM.DB.W [R0-R3], (R13)
-	// Push C callee-save registers r4-r11 and lr.
-	MOVM.DB.W [R4-R11, R14], (R13)
-	SUB	$(16 + callbackArgs__size), R13	// space for locals
+	// Save callback register arguments R0-R7.
+	// We do this at the top of the frame so they're contiguous with stack arguments.
+	MOVD	R0, arg0-(8*8)(SP)
+	MOVD	R1, arg1-(7*8)(SP)
+	MOVD	R2, arg2-(6*8)(SP)
+	MOVD	R3, arg3-(5*8)(SP)
+	MOVD	R4, arg4-(4*8)(SP)
+	MOVD	R5, arg5-(3*8)(SP)
+	MOVD	R6, arg6-(2*8)(SP)
+	MOVD	R7, arg7-(1*8)(SP)
+
+	// Push C callee-save registers R19-R28.
+	// LR, FP already saved.
+	SAVE_R19_TO_R28(-18*8)
 
 	// Create a struct callbackArgs on our stack.
-	MOVW	R12, (16+callbackArgs_index)(R13)	// callback index
-	MOVW	$(16+callbackArgs__size+4*9)(R13), R0
-	MOVW	R0, (16+callbackArgs_args)(R13)		// address of args vector
-	MOVW	$0, R0
-	MOVW	R0, (16+callbackArgs_result)(R13)	// result
-
-	// Prepare for entry to Go.
-	BL	runtime·load_g(SB)
+	MOVD	$cbargs-(18*8+callbackArgs__size)(SP), R13
+	MOVD	R12, callbackArgs_index(R13)	// callback index
+	MOVD	$arg0-(8*8)(SP), R0
+	MOVD	R0, callbackArgs_args(R13)		// address of args vector
+	MOVD	$0, R0
+	MOVD	R0, callbackArgs_result(R13)	// result
 
 	// Call cgocallback, which will call callbackWrap(frame).
-	MOVW	$0, R0
-	MOVW	R0, 12(R13)	// context
-	MOVW	$16(R13), R1	// R1 = &callbackArgs{...}
-	MOVW	R1, 8(R13)	// frame (address of callbackArgs)
-	MOVW	$·callbackWrap(SB), R1
-	MOVW	R1, 4(R13)	// PC of function to call
+	MOVD	$·callbackWrap(SB), R0	// PC of function to call
+	MOVD	R13, R1	// frame (&callbackArgs{...})
+	MOVD	$0, R2	// context
+	MOVD	R0, (1*8)(RSP)
+	MOVD	R1, (2*8)(RSP)
+	MOVD	R2, (3*8)(RSP)
 	BL	runtime·cgocallback(SB)
 
 	// Get callback result.
-	MOVW	(16+callbackArgs_result)(R13), R0
+	MOVD	$cbargs-(18*8+callbackArgs__size)(SP), R13
+	MOVD	callbackArgs_result(R13), R0
 
-	ADD	$(16 + callbackArgs__size), R13	// free locals
-	MOVM.IA.W (R13), [R4-R11, R12]	// pop {r4-r11, lr=>r12}
-	ADD	$(4*4), R13	// skip r0-r3
-	B	(R12)	// return
+	RESTORE_R19_TO_R28(-18*8)
+
+	RET
 
 // uint32 tstart_stdcall(M *newm);
-TEXT runtime·tstart_stdcall(SB),NOSPLIT|NOFRAME,$0
-	MOVM.DB.W [R4-R11, R14], (R13)		// push {r4-r11, lr}
+TEXT runtime·tstart_stdcall(SB),NOSPLIT,$96-0
+	SAVE_R19_TO_R28(-10*8)
 
-	MOVW	m_g0(R0), g
-	MOVW	R0, g_m(g)
+	MOVD	m_g0(R0), g
+	MOVD	R0, g_m(g)
 	BL	runtime·save_g(SB)
 
-	// Layout new m scheduler stack on os stack.
-	MOVW	R13, R0
-	MOVW	R0, g_stack+stack_hi(g)
+	// Set up stack guards for OS stack.
+	MOVD	RSP, R0
+	MOVD	R0, g_stack+stack_hi(g)
 	SUB	$(64*1024), R0
-	MOVW	R0, (g_stack+stack_lo)(g)
-	MOVW	R0, g_stackguard0(g)
-	MOVW	R0, g_stackguard1(g)
+	MOVD	R0, (g_stack+stack_lo)(g)
+	MOVD	R0, g_stackguard0(g)
+	MOVD	R0, g_stackguard1(g)
 
 	BL	runtime·emptyfunc(SB)	// fault if stack check is wrong
 	BL	runtime·mstart(SB)
 
+	RESTORE_R19_TO_R28(-10*8)
+
 	// Exit the thread.
-	MOVW	$0, R0
-	MOVM.IA.W (R13), [R4-R11, R15]		// pop {r4-r11, pc}
+	MOVD	$0, R0
+	RET
 
 // Runs on OS stack.
 // duration (in -100ns units) is in dt+0(FP).
 // g may be nil.
-TEXT runtime·usleep2(SB),NOSPLIT|NOFRAME,$0-4
+TEXT runtime·usleep2(SB),NOSPLIT,$32-4
 	MOVW	dt+0(FP), R0
-	MOVM.DB.W [R4, R14], (R13)	// push {r4, lr}
-	MOVW	R13, R4			// Save SP
-	SUB	$8, R13			// R13 = R13 - 8
-	BIC	$0x7, R13		// Align SP for ABI
-	RSB	$0, R0, R3		// R3 = -R0
-	MOVW	$0, R1			// R1 = FALSE (alertable)
-	MOVW	$-1, R0			// R0 = handle
-	MOVW	R13, R2			// R2 = pTime
-	MOVW	R3, 0(R2)		// time_lo
-	MOVW	R0, 4(R2)		// time_hi
-	MOVW	runtime·_NtWaitForSingleObject(SB), R3
+	MOVD	$16(RSP), R2		// R2 = pTime
+	MOVD	R0, 0(R2)		// *pTime = -dt
+	MOVD	$-1, R0			// R0 = handle
+	MOVD	$0, R1			// R1 = FALSE (alertable)
+	MOVD	runtime·_NtWaitForSingleObject(SB), R3
+	SUB	$16, RSP	// skip over saved frame pointer below RSP
 	BL	(R3)
-	MOVW	R4, R13			// Restore SP
-	MOVM.IA.W (R13), [R4, R15]	// pop {R4, pc}
+	ADD	$16, RSP
+	RET
 
 // Runs on OS stack.
 // duration (in -100ns units) is in dt+0(FP).
 // g is valid.
 // TODO: neeeds to be implemented properly.
-TEXT runtime·usleep2HighRes(SB),NOSPLIT|NOFRAME,$0-4
+TEXT runtime·usleep2HighRes(SB),NOSPLIT,$0-4
 	B	runtime·abort(SB)
 
 // Runs on OS stack.
-TEXT runtime·switchtothread(SB),NOSPLIT|NOFRAME,$0
-	MOVM.DB.W [R4, R14], (R13)  	// push {R4, lr}
-	MOVW    R13, R4
-	BIC	$0x7, R13		// alignment for ABI
-	MOVW	runtime·_SwitchToThread(SB), R0
+TEXT runtime·switchtothread(SB),NOSPLIT,$16-0
+	MOVD	runtime·_SwitchToThread(SB), R0
+	SUB	$16, RSP	// skip over saved frame pointer below RSP
 	BL	(R0)
-	MOVW 	R4, R13			// restore stack pointer
-	MOVM.IA.W (R13), [R4, R15]	// pop {R4, pc}
-
-TEXT ·publicationBarrier(SB),NOSPLIT|NOFRAME,$0-0
-	B	runtime·armPublicationBarrier(SB)
-
-// never called (cgo not supported)
-TEXT runtime·read_tls_fallback(SB),NOSPLIT|NOFRAME,$0
-	MOVW	$0xabcd, R0
-	MOVW	R0, (R0)
+	ADD	$16, RSP
 	RET
 
 // See http://www.dcl.hpi.uni-potsdam.de/research/WRK/2007/08/getting-os-information-the-kuser_shared_data-structure/
@@ -423,166 +479,101 @@ TEXT runtime·read_tls_fallback(SB),NOSPLIT|NOFRAME,$0
 #define time_hi2 8
 
 TEXT runtime·nanotime1(SB),NOSPLIT|NOFRAME,$0-8
-	MOVW	$0, R0
 	MOVB	runtime·useQPCTime(SB), R0
 	CMP	$0, R0
 	BNE	useQPC
-	MOVW	$_INTERRUPT_TIME, R3
+	MOVD	$_INTERRUPT_TIME, R3
 loop:
-	MOVW	time_hi1(R3), R1
-	MOVW	time_lo(R3), R0
-	MOVW	time_hi2(R3), R2
+	MOVWU	time_hi1(R3), R1
+	MOVWU	time_lo(R3), R0
+	MOVWU	time_hi2(R3), R2
 	CMP	R1, R2
 	BNE	loop
 
 	// wintime = R1:R0, multiply by 100
-	MOVW	$100, R2
-	MULLU	R0, R2, (R4, R3)    // R4:R3 = R1:R0 * R2
-	MULA	R1, R2, R4, R4
-
-	// wintime*100 = R4:R3
-	MOVW	R3, ret_lo+0(FP)
-	MOVW	R4, ret_hi+4(FP)
+	ORR	R1<<32, R0
+	MOVD	$100, R1
+	MUL	R1, R0
+	MOVD	R0, ret+0(FP)
 	RET
 useQPC:
 	B	runtime·nanotimeQPC(SB)		// tail call
 
-TEXT time·now(SB),NOSPLIT|NOFRAME,$0-20
-	MOVW    $0, R0
+TEXT time·now(SB),NOSPLIT|NOFRAME,$0-24
 	MOVB    runtime·useQPCTime(SB), R0
 	CMP	$0, R0
 	BNE	useQPC
-	MOVW	$_INTERRUPT_TIME, R3
+	MOVD	$_INTERRUPT_TIME, R3
 loop:
-	MOVW	time_hi1(R3), R1
-	MOVW	time_lo(R3), R0
-	MOVW	time_hi2(R3), R2
+	MOVWU	time_hi1(R3), R1
+	MOVWU	time_lo(R3), R0
+	MOVWU	time_hi2(R3), R2
 	CMP	R1, R2
 	BNE	loop
 
 	// wintime = R1:R0, multiply by 100
-	MOVW	$100, R2
-	MULLU	R0, R2, (R4, R3)    // R4:R3 = R1:R0 * R2
-	MULA	R1, R2, R4, R4
-
-	// wintime*100 = R4:R3
-	MOVW	R3, mono+12(FP)
-	MOVW	R4, mono+16(FP)
+	ORR	R1<<32, R0
+	MOVD	$100, R1
+	MUL	R1, R0
+	MOVD	R0, mono+16(FP)
 
-	MOVW	$_SYSTEM_TIME, R3
+	MOVD	$_SYSTEM_TIME, R3
 wall:
-	MOVW	time_hi1(R3), R1
-	MOVW	time_lo(R3), R0
-	MOVW	time_hi2(R3), R2
+	MOVWU	time_hi1(R3), R1
+	MOVWU	time_lo(R3), R0
+	MOVWU	time_hi2(R3), R2
 	CMP	R1, R2
 	BNE	wall
 
-	// w = R1:R0 in 100ns untis
+	// w = R1:R0 in 100ns units
 	// convert to Unix epoch (but still 100ns units)
 	#define delta 116444736000000000
-	SUB.S   $(delta & 0xFFFFFFFF), R0
-	SBC     $(delta >> 32), R1
+	ORR	R1<<32, R0
+	SUB	$delta, R0
 
 	// Convert to nSec
-	MOVW    $100, R2
-	MULLU   R0, R2, (R4, R3)    // R4:R3 = R1:R0 * R2
-	MULA    R1, R2, R4, R4
-	// w = R2:R1 in nSec
-	MOVW    R3, R1	      // R4:R3 -> R2:R1
-	MOVW    R4, R2
-
-	// multiply nanoseconds by reciprocal of 10**9 (scaled by 2**61)
-	// to get seconds (96 bit scaled result)
-	MOVW	$0x89705f41, R3		// 2**61 * 10**-9
-	MULLU	R1,R3,(R6,R5)		// R7:R6:R5 = R2:R1 * R3
-	MOVW	$0,R7
-	MULALU	R2,R3,(R7,R6)
-
-	// unscale by discarding low 32 bits, shifting the rest by 29
-	MOVW	R6>>29,R6		// R7:R6 = (R7:R6:R5 >> 61)
-	ORR	R7<<3,R6
-	MOVW	R7>>29,R7
-
-	// subtract (10**9 * sec) from nsec to get nanosecond remainder
-	MOVW	$1000000000, R5	// 10**9
-	MULLU	R6,R5,(R9,R8)   // R9:R8 = R7:R6 * R5
-	MULA	R7,R5,R9,R9
-	SUB.S	R8,R1		// R2:R1 -= R9:R8
-	SBC	R9,R2
-
-	// because reciprocal was a truncated repeating fraction, quotient
-	// may be slightly too small -- adjust to make remainder < 10**9
-	CMP	R5,R1	// if remainder > 10**9
-	SUB.HS	R5,R1   //    remainder -= 10**9
-	ADD.HS	$1,R6	//    sec += 1
-
-	MOVW	R6,sec_lo+0(FP)
-	MOVW	R7,sec_hi+4(FP)
-	MOVW	R1,nsec+8(FP)
+	MOVD	$100, R1
+	MUL	R1, R0
+
+	// Code stolen from compiler output for:
+	//
+	//	var x uint64
+	//	func f() (sec uint64, nsec uint32) { return x / 1000000000, uint32(x % 100000000) }
+	//
+	LSR	$1, R0, R1
+	MOVD	$-8543223759426509416, R2
+	UMULH	R2, R1, R1
+	LSR	$28, R1, R1
+	MOVD	R1, sec+0(FP)
+	MOVD	$-6067343680855748867, R1
+	UMULH	R0, R1, R1
+	LSR	$26, R1, R1
+	MOVD	$100000000, R2
+	MSUB	R1, R0, R2, R0
+	MOVW	R0, nsec+8(FP)
 	RET
 useQPC:
 	B	runtime·nowQPC(SB)		// tail call
 
-// save_g saves the g register (R10) into thread local memory
-// so that we can call externally compiled
-// ARM code that will overwrite those registers.
-// NOTE: runtime.gogo assumes that R1 is preserved by this function.
-//       runtime.mcall assumes this function only clobbers R0 and R11.
-// Returns with g in R0.
-// Save the value in the _TEB->TlsSlots array.
-// Effectively implements TlsSetValue().
-// tls_g stores the TLS slot allocated TlsAlloc().
-TEXT runtime·save_g(SB),NOSPLIT|NOFRAME,$0
-	MRC	15, 0, R0, C13, C0, 2
-	ADD	$0xe10, R0
-	MOVW 	$runtime·tls_g(SB), R11
-	MOVW	(R11), R11
-	MOVW	g, R11<<2(R0)
-	MOVW	g, R0	// preserve R0 across call to setg<>
-	RET
-
-// load_g loads the g register from thread-local memory,
-// for use after calling externally compiled
-// ARM code that overwrote those registers.
-// Get the value from the _TEB->TlsSlots array.
-// Effectively implements TlsGetValue().
-TEXT runtime·load_g(SB),NOSPLIT|NOFRAME,$0
-	MRC	15, 0, R0, C13, C0, 2
-	ADD	$0xe10, R0
-	MOVW 	$runtime·tls_g(SB), g
-	MOVW	(g), g
-	MOVW	g<<2(R0), g
-	RET
-
 // This is called from rt0_go, which runs on the system stack
 // using the initial stack allocated by the OS.
 // It calls back into standard C using the BL below.
-// To do that, the stack pointer must be 8-byte-aligned.
-TEXT runtime·_initcgo(SB),NOSPLIT|NOFRAME,$0
-	MOVM.DB.W [R4, R14], (R13)	// push {r4, lr}
-
-	// Ensure stack is 8-byte aligned before calling C code
-	MOVW	R13, R4
-	BIC	$0x7, R13
-
+TEXT runtime·wintls(SB),NOSPLIT,$0
 	// Allocate a TLS slot to hold g across calls to external code
-	MOVW 	$runtime·_TlsAlloc(SB), R0
-	MOVW	(R0), R0
+	MOVD	runtime·_TlsAlloc(SB), R0
+	SUB	$16, RSP	// skip over saved frame pointer below RSP
 	BL	(R0)
+	ADD	$16, RSP
 
 	// Assert that slot is less than 64 so we can use _TEB->TlsSlots
 	CMP	$64, R0
-	MOVW	$runtime·abort(SB), R1
-	BL.GE	(R1)
-
-	// Save Slot into tls_g
-	MOVW 	$runtime·tls_g(SB), R1
-	MOVW	R0, (R1)
-
-	MOVW	R4, R13
-	MOVM.IA.W (R13), [R4, R15]	// pop {r4, pc}
-
-// Holds the TLS Slot, which was allocated by TlsAlloc()
-GLOBL runtime·tls_g+0(SB), NOPTR, $4
+	BLT	ok
+	MOVD	$runtime·abort(SB), R1
+	BL	(R1)
+ok:
 
-#endif
+	// Save offset from R18 into tls_g.
+	LSL	$3, R1
+	ADD	$TEB_TlsSlots, R1
+	MOVD	R1, runtime·tls_g(SB)
+	RET
diff --git a/src/runtime/syscall_windows.go b/src/runtime/syscall_windows.go
index 666ec5f69e..7cf9318bdb 100644
--- a/src/runtime/syscall_windows.go
+++ b/src/runtime/syscall_windows.go
@@ -148,6 +148,7 @@ func compileCallback(fn eface, cdecl bool) (code uintptr) {
 		}
 
 		// cdecl, stdcall, fastcall, and arm pad arguments to word size.
+		// TODO(rsc): On arm and arm64 do we need to skip the caller's saved LR?
 		src += sys.PtrSize
 		// The Go ABI packs arguments.
 		dst += t.size
diff --git a/src/runtime/tls_arm64.h b/src/runtime/tls_arm64.h
index 0804fa3502..fe5e4cee12 100644
--- a/src/runtime/tls_arm64.h
+++ b/src/runtime/tls_arm64.h
@@ -41,8 +41,16 @@
 #define MRS_TPIDR_R0 WORD $0xd53bd040 // MRS TPIDR_EL0, R0
 #endif
 
+#ifdef GOOS_windows
+#define TLS_windows
+#endif
+#ifdef TLS_windows
+#define TLSG_IS_VARIABLE
+#define MRS_TPIDR_R0 MOVD R18_PLATFORM, R0
+#endif
+
 // Define something that will break the build if
 // the GOOS is unknown.
-#ifndef TPIDR
-#define MRS_TPIDR_R0 TPIDR_UNKNOWN
+#ifndef MRS_TPIDR_R0
+#define MRS_TPIDR_R0 unknown_TLS_implementation_in_tls_arm64_h
 #endif
diff --git a/src/runtime/tls_arm64.s b/src/runtime/tls_arm64.s
index 085012f791..52b3e8f222 100644
--- a/src/runtime/tls_arm64.s
+++ b/src/runtime/tls_arm64.s
@@ -9,11 +9,13 @@
 #include "tls_arm64.h"
 
 TEXT runtime·load_g(SB),NOSPLIT,$0
-#ifndef TLS_darwin
+#ifndef GOOS_darwin
 #ifndef GOOS_openbsd
+#ifndef GOOS_windows
 	MOVB	runtime·iscgo(SB), R0
 	CBZ	R0, nocgo
 #endif
+#endif
 #endif
 
 	MRS_TPIDR_R0
@@ -28,11 +30,13 @@ nocgo:
 	RET
 
 TEXT runtime·save_g(SB),NOSPLIT,$0
-#ifndef TLS_darwin
+#ifndef GOOS_darwin
 #ifndef GOOS_openbsd
+#ifndef GOOS_windows
 	MOVB	runtime·iscgo(SB), R0
 	CBZ	R0, nocgo
 #endif
+#endif
 #endif
 
 	MRS_TPIDR_R0
-- 
GitLab


From 474d5f4f4d0547d1c6d7a14f1ba02afffc4725d4 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 10 Feb 2021 23:41:23 -0500
Subject: [PATCH 0721/2400] math: remove most 387 implementations

The Surface Pro X's 386 simulator is not completely faithful to a real 387.
The most egregious problem is that it computes Log2(8) as 2.9999999999999996,
but it has some other subtler problems as well. All the problems occur in
routines that we don't even bother with assembly for on amd64.
If the speed of Go code is OK on amd64 it should be OK on 386 too.
Just remove all the 386-only assembly functions.

This leaves Ceil, Floor, Trunc, Hypot, and Sqrt in 386 assembly,
all of which are also in assembly on amd64 and all of which pass
their tests on Surface Pro X.

Compared to amd64, the 386 port omits assembly for Min, Max, and Log.
It never had Min and Max, and this CL deletes Log because Log2 wasn't
even correct. (None of the other architectures have assembly Log either.)

Change-Id: I5eb6c61084467035269d4098a36001447b7a0601
Reviewed-on: https://go-review.googlesource.com/c/go/+/291229
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
---
 src/math/asin_386.s      | 30 ---------------------
 src/math/atan2_386.s     | 13 ---------
 src/math/atan_386.s      | 13 ---------
 src/math/exp2_386.s      | 40 ----------------------------
 src/math/expm1_386.s     | 57 ----------------------------------------
 src/math/frexp_386.s     | 25 ------------------
 src/math/ldexp_386.s     | 14 ----------
 src/math/log10_386.s     | 21 ---------------
 src/math/log1p_386.s     | 27 -------------------
 src/math/log_386.s       | 13 ---------
 src/math/mod_386.s       | 17 ------------
 src/math/modf_386.s      | 34 ------------------------
 src/math/remainder_386.s | 17 ------------
 src/math/stubs_386.s     | 45 +++++++++++++++++++++++++++++++
 14 files changed, 45 insertions(+), 321 deletions(-)
 delete mode 100644 src/math/asin_386.s
 delete mode 100644 src/math/atan2_386.s
 delete mode 100644 src/math/atan_386.s
 delete mode 100644 src/math/exp2_386.s
 delete mode 100644 src/math/expm1_386.s
 delete mode 100644 src/math/frexp_386.s
 delete mode 100644 src/math/ldexp_386.s
 delete mode 100644 src/math/log10_386.s
 delete mode 100644 src/math/log1p_386.s
 delete mode 100644 src/math/log_386.s
 delete mode 100644 src/math/mod_386.s
 delete mode 100644 src/math/modf_386.s
 delete mode 100644 src/math/remainder_386.s

diff --git a/src/math/asin_386.s b/src/math/asin_386.s
deleted file mode 100644
index 7dab390623..0000000000
--- a/src/math/asin_386.s
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright 2010 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.
-
-#include "textflag.h"
-
-// func Asin(x float64) float64
-TEXT ·Asin(SB),NOSPLIT,$0
-	FMOVD   x+0(FP), F0  // F0=sin(x)
-	FMOVD   F0, F1       // F0=sin(x), F1=sin(x)
-	FMULD   F0, F0       // F0=sin(x)*sin(x), F1=sin(x)
-	FLD1                 // F0=1, F1=sin(x)*sin(x), F2=sin(x)
-	FSUBRDP F0, F1       // F0=1-sin(x)*sin(x) (=cos(x)*cos(x)), F1=sin(x)
-	FSQRT                // F0=cos(x), F1=sin(x)
-	FPATAN               // F0=arcsin(sin(x))=x
-	FMOVDP  F0, ret+8(FP)
-	RET
-
-// func Acos(x float64) float64
-TEXT ·Acos(SB),NOSPLIT,$0
-	FMOVD   x+0(FP), F0  // F0=cos(x)
-	FMOVD   F0, F1       // F0=cos(x), F1=cos(x)
-	FMULD   F0, F0       // F0=cos(x)*cos(x), F1=cos(x)
-	FLD1                 // F0=1, F1=cos(x)*cos(x), F2=cos(x)
-	FSUBRDP F0, F1       // F0=1-cos(x)*cos(x) (=sin(x)*sin(x)), F1=cos(x)
-	FSQRT                // F0=sin(x), F1=cos(x)
-	FXCHD   F0, F1       // F0=cos(x), F1=sin(x)
-	FPATAN               // F0=arccos(cos(x))=x
-	FMOVDP	F0, ret+8(FP)
-	RET
diff --git a/src/math/atan2_386.s b/src/math/atan2_386.s
deleted file mode 100644
index 90d211bf5b..0000000000
--- a/src/math/atan2_386.s
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2010 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.
-
-#include "textflag.h"
-
-// func Atan2(y, x float64) float64	// =atan(y/x)
-TEXT ·Atan2(SB),NOSPLIT,$0
-	FMOVD   y+0(FP), F0  // F0=y
-	FMOVD   x+8(FP), F0  // F0=x, F1=y
-	FPATAN               // F0=atan(F1/F0)
-	FMOVDP  F0, ret+16(FP)
-	RET
diff --git a/src/math/atan_386.s b/src/math/atan_386.s
deleted file mode 100644
index 43e79b92b6..0000000000
--- a/src/math/atan_386.s
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2010 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.
-
-#include "textflag.h"
-
-// func Atan(x float64) float64
-TEXT ·Atan(SB),NOSPLIT,$0
-	FMOVD   x+0(FP), F0  // F0=x
-	FLD1                 // F0=1, F1=x
-	FPATAN               // F0=atan(F1/F0)
-	FMOVDP  F0, ret+8(FP)
-	RET
diff --git a/src/math/exp2_386.s b/src/math/exp2_386.s
deleted file mode 100644
index d04cad6a55..0000000000
--- a/src/math/exp2_386.s
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2010 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.
-
-#include "textflag.h"
-
-// func Exp2(x float64) float64
-TEXT ·Exp2(SB),NOSPLIT,$0
-// test bits for not-finite
-	MOVL    x_hi+4(FP), AX
-	ANDL    $0x7ff00000, AX
-	CMPL    AX, $0x7ff00000
-	JEQ     not_finite
-	FMOVD   x+0(FP), F0   // F0=x
-	FMOVD   F0, F1        // F0=x, F1=x
-	FRNDINT               // F0=int(x), F1=x
-	FSUBD   F0, F1        // F0=int(x), F1=x-int(x)
-	FXCHD   F0, F1        // F0=x-int(x), F1=int(x)
-	F2XM1                 // F0=2**(x-int(x))-1, F1=int(x)
-	FLD1                  // F0=1, F1=2**(x-int(x))-1, F2=int(x)
-	FADDDP  F0, F1        // F0=2**(x-int(x)), F1=int(x)
-	FSCALE                // F0=2**x, F1=int(x)
-	FMOVDP  F0, F1        // F0=2**x
-	FMOVDP  F0, ret+8(FP)
-	RET
-not_finite:
-// test bits for -Inf
-	MOVL    x_hi+4(FP), BX
-	MOVL    x_lo+0(FP), CX
-	CMPL    BX, $0xfff00000
-	JNE     not_neginf
-	CMPL    CX, $0
-	JNE     not_neginf
-	MOVL    $0, ret_lo+8(FP)
-	MOVL    $0, ret_hi+12(FP)
-	RET
-not_neginf:
-	MOVL    CX, ret_lo+8(FP)
-	MOVL    BX, ret_hi+12(FP)
-	RET
diff --git a/src/math/expm1_386.s b/src/math/expm1_386.s
deleted file mode 100644
index d020296ca7..0000000000
--- a/src/math/expm1_386.s
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2010 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.
-
-#include "textflag.h"
-
-// func Expm1(x float64) float64
-TEXT ·Expm1(SB),NOSPLIT,$0
-	FLDLN2               // F0=log(2) = 1/log2(e) ~ 0.693147
-	FMOVD   x+0(FP), F0  // F0=x, F1=1/log2(e)
-	FABS                 // F0=|x|, F1=1/log2(e)
-	FUCOMPP F0, F1       // compare F0 to F1
-	FSTSW   AX
-	SAHF
-	JCC     use_exp      // jump if F0 >= F1
-	FLDL2E                // F0=log2(e)
-	FMULD   x+0(FP), F0   // F0=x*log2(e) (-1<F0<1)
-	F2XM1                 // F0=e**x-1 = 2**(x*log2(e))-1
-	FMOVDP  F0, ret+8(FP)
-	RET
-use_exp:
-// test bits for not-finite
-	MOVL    x_hi+4(FP), AX
-	ANDL    $0x7ff00000, AX
-	CMPL    AX, $0x7ff00000
-	JEQ     not_finite
-	FLDL2E                // F0=log2(e)
-	FMULD   x+0(FP), F0   // F0=x*log2(e)
-	FMOVD   F0, F1        // F0=x*log2(e), F1=x*log2(e)
-	FRNDINT               // F0=int(x*log2(e)), F1=x*log2(e)
-	FSUBD   F0, F1        // F0=int(x*log2(e)), F1=x*log2(e)-int(x*log2(e))
-	FXCHD   F0, F1        // F0=x*log2(e)-int(x*log2(e)), F1=int(x*log2(e))
-	F2XM1                 // F0=2**(x*log2(e)-int(x*log2(e)))-1, F1=int(x*log2(e))
-	FLD1                  // F0=1, F1=2**(x*log2(e)-int(x*log2(e)))-1, F2=int(x*log2(e))
-	FADDDP  F0, F1        // F0=2**(x*log2(e)-int(x*log2(e))), F1=int(x*log2(e))
-	FSCALE                // F0=e**x, F1=int(x*log2(e))
-	FMOVDP  F0, F1        // F0=e**x
-	FLD1                  // F0=1, F1=e**x
-	FSUBDP  F0, F1        // F0=e**x-1
-	FMOVDP  F0, ret+8(FP)
-	RET
-not_finite:
-// test bits for -Inf
-	MOVL    x_hi+4(FP), BX
-	MOVL    x_lo+0(FP), CX
-	CMPL    BX, $0xfff00000
-	JNE     not_neginf
-	CMPL    CX, $0
-	JNE     not_neginf
-	FLD1                 // F0=1
-	FCHS                 // F0=-1
-	FMOVDP  F0, ret+8(FP)
-	RET
-not_neginf:
-	MOVL    CX, ret_lo+8(FP)
-	MOVL    BX, ret_hi+12(FP)
-	RET
diff --git a/src/math/frexp_386.s b/src/math/frexp_386.s
deleted file mode 100644
index 832b435fe8..0000000000
--- a/src/math/frexp_386.s
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright 2010 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.
-
-#include "textflag.h"
-
-// func Frexp(f float64) (frac float64, exp int)
-TEXT ·Frexp(SB),NOSPLIT,$0
-	FMOVD   f+0(FP), F0   // F0=f
-	FXAM
-	FSTSW   AX
-	SAHF
-	JNP     nan_zero_inf
-	JCS     nan_zero_inf
-	FXTRACT               // F0=f (0<=f<1), F1=e
-	FMULD  $(0.5), F0     // F0=f (0.5<=f<1), F1=e
-	FMOVDP  F0, frac+8(FP)   // F0=e
-	FLD1                  // F0=1, F1=e
-	FADDDP  F0, F1        // F0=e+1
-	FMOVLP  F0, exp+16(FP)  // (int=int32)
-	RET
-nan_zero_inf:
-	FMOVDP  F0, frac+8(FP)   // F0=e
-	MOVL    $0, exp+16(FP)  // exp=0
-	RET
diff --git a/src/math/ldexp_386.s b/src/math/ldexp_386.s
deleted file mode 100644
index 6f67ae1d13..0000000000
--- a/src/math/ldexp_386.s
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright 2010 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.
-
-#include "textflag.h"
-
-// func Ldexp(frac float64, exp int) float64
-TEXT ·Ldexp(SB),NOSPLIT,$0
-	FMOVL   exp+8(FP), F0   // F0=exp
-	FMOVD   frac+0(FP), F0   // F0=frac, F1=e
-	FSCALE                // F0=x*2**e, F1=e
-	FMOVDP  F0, F1        // F0=x*2**e
-	FMOVDP  F0, ret+12(FP)
-	RET
diff --git a/src/math/log10_386.s b/src/math/log10_386.s
deleted file mode 100644
index 10eecd90e2..0000000000
--- a/src/math/log10_386.s
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright 2010 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.
-
-#include "textflag.h"
-
-// func Log10(x float64) float64
-TEXT ·Log10(SB),NOSPLIT,$0
-	FLDLG2               // F0=log10(2)
-	FMOVD   x+0(FP), F0  // F0=x, F1=log10(2)
-	FYL2X                // F0=log10(x)=log2(x)*log10(2)
-	FMOVDP  F0, ret+8(FP)
-	RET
-
-// func Log2(x float64) float64
-TEXT ·Log2(SB),NOSPLIT,$0
-	FLD1                 // F0=1
-	FMOVD   x+0(FP), F0  // F0=x, F1=1
-	FYL2X                // F0=log2(x)
-	FMOVDP  F0, ret+8(FP)
-	RET
diff --git a/src/math/log1p_386.s b/src/math/log1p_386.s
deleted file mode 100644
index 63b7e62283..0000000000
--- a/src/math/log1p_386.s
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2010 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.
-
-#include "textflag.h"
-
-// func Log1p(x float64) float64
-TEXT ·Log1p(SB),NOSPLIT,$0
-	FMOVD   $(2.928932188134524e-01), F0
-	FMOVD   x+0(FP), F0  // F0=x, F1=1-sqrt(2)/2 = 0.29289321881345247559915564
-	FABS                 // F0=|x|, F1=1-sqrt(2)/2
-	FUCOMPP F0, F1       // compare F0 to F1
-	FSTSW   AX
-	FLDLN2               // F0=log(2)
-	ANDW    $0x0100, AX
-	JEQ     use_fyl2x    // jump if F0 >= F1
-	FMOVD   x+0(FP), F0  // F0=x, F1=log(2)
-	FYL2XP1              // F0=log(1+x)=log2(1+x)*log(2)
-	FMOVDP  F0, ret+8(FP)
-	RET
-use_fyl2x:
-	FLD1                 // F0=1, F2=log(2)
-	FADDD   x+0(FP), F0  // F0=1+x, F1=log(2)
-	FYL2X                // F0=log(1+x)=log2(1+x)*log(2)
-	FMOVDP  F0, ret+8(FP)
-	RET
-
diff --git a/src/math/log_386.s b/src/math/log_386.s
deleted file mode 100644
index 0b64b507b2..0000000000
--- a/src/math/log_386.s
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2010 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.
-
-#include "textflag.h"
-
-// func Log(x float64) float64
-TEXT ·Log(SB),NOSPLIT,$0
-	FLDLN2               // F0=log(2)
-	FMOVD   x+0(FP), F0  // F0=x, F1=log(2)
-	FYL2X                // F0=log(x)=log2(x)*log(2)
-	FMOVDP  F0, ret+8(FP)
-	RET
diff --git a/src/math/mod_386.s b/src/math/mod_386.s
deleted file mode 100644
index 10ad98be3e..0000000000
--- a/src/math/mod_386.s
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright 2010 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.
-
-#include "textflag.h"
-
-// func Mod(x, y float64) float64
-TEXT ·Mod(SB),NOSPLIT,$0
-	FMOVD   y+8(FP), F0  // F0=y
-	FMOVD   x+0(FP), F0  // F0=x, F1=y
-	FPREM                // F0=reduced_x, F1=y
-	FSTSW   AX           // AX=status word
-	ANDW    $0x0400, AX
-	JNE     -3(PC)       // jump if reduction incomplete
-	FMOVDP  F0, F1       // F0=x-q*y
-	FMOVDP  F0, ret+16(FP)
-	RET
diff --git a/src/math/modf_386.s b/src/math/modf_386.s
deleted file mode 100644
index e9160735d3..0000000000
--- a/src/math/modf_386.s
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright 2010 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.
-
-#include "textflag.h"
-
-// func Modf(f float64) (int float64, frac float64)
-TEXT ·Modf(SB),NOSPLIT,$0
-	// special case for f == -0.0
-	MOVL f_hi+4(FP), DX	// high word
-	MOVL f_lo+0(FP), AX	// low word
-	CMPL DX, $(1<<31)	// beginning of -0.0
-	JNE notNegativeZero
-	CMPL AX, $0			// could be denormalized
-	JNE notNegativeZero
-	MOVL AX, int_lo+8(FP)
-	MOVL DX, int_hi+12(FP)
-	MOVL AX, frac_lo+16(FP)
-	MOVL DX, frac_hi+20(FP)
-	RET
-notNegativeZero:
-	FMOVD   f+0(FP), F0  // F0=f
-	FMOVD   F0, F1       // F0=f, F1=f
-	FSTCW   -2(SP)       // save old Control Word
-	MOVW    -2(SP), AX
-	ORW     $0x0c00, AX  // Rounding Control set to truncate
-	MOVW    AX, -4(SP)   // store new Control Word
-	FLDCW   -4(SP)       // load new Control Word
-	FRNDINT              // F0=trunc(f), F1=f
-	FLDCW   -2(SP)       // load old Control Word
-	FSUBD   F0, F1       // F0=trunc(f), F1=f-trunc(f)
-	FMOVDP  F0, int+8(FP)  // F0=f-trunc(f)
-	FMOVDP  F0, frac+16(FP)
-	RET
diff --git a/src/math/remainder_386.s b/src/math/remainder_386.s
deleted file mode 100644
index 318fa2c465..0000000000
--- a/src/math/remainder_386.s
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright 2010 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.
-
-#include "textflag.h"
-
-// func Remainder(x, y float64) float64
-TEXT ·Remainder(SB),NOSPLIT,$0
-	FMOVD   y+8(FP), F0  // F0=y
-	FMOVD   x+0(FP), F0  // F0=x, F1=y
-	FPREM1               // F0=reduced_x, F1=y
-	FSTSW   AX           // AX=status word
-	ANDW    $0x0400, AX
-	JNE     -3(PC)       // jump if reduction incomplete
-	FMOVDP  F0, F1       // F0=x-q*y
-	FMOVDP  F0, ret+16(FP)
-	RET
diff --git a/src/math/stubs_386.s b/src/math/stubs_386.s
index 92c8621523..bccb3edd11 100644
--- a/src/math/stubs_386.s
+++ b/src/math/stubs_386.s
@@ -4,12 +4,24 @@
 
 #include "textflag.h"
 
+TEXT ·Acos(SB), NOSPLIT, $0
+	JMP ·acos(SB)
+
 TEXT ·Acosh(SB), NOSPLIT, $0
 	JMP ·acosh(SB)
 
+TEXT ·Asin(SB), NOSPLIT, $0
+	JMP ·asin(SB)
+
 TEXT ·Asinh(SB), NOSPLIT, $0
 	JMP ·asinh(SB)
 
+TEXT ·Atan(SB), NOSPLIT, $0
+	JMP ·atan(SB)
+
+TEXT ·Atan2(SB), NOSPLIT, $0
+	JMP ·atan2(SB)
+
 TEXT ·Atanh(SB), NOSPLIT, $0
 	JMP ·atanh(SB)
 
@@ -31,15 +43,48 @@ TEXT ·Erfc(SB), NOSPLIT, $0
 TEXT ·Exp(SB), NOSPLIT, $0
 	JMP ·exp(SB)
 
+TEXT ·Exp2(SB), NOSPLIT, $0
+	JMP ·exp2(SB)
+
+TEXT ·Expm1(SB), NOSPLIT, $0
+	JMP ·expm1(SB)
+
+TEXT ·Frexp(SB), NOSPLIT, $0
+	JMP ·frexp(SB)
+
+TEXT ·Ldexp(SB), NOSPLIT, $0
+	JMP ·ldexp(SB)
+
+TEXT ·Log10(SB), NOSPLIT, $0
+	JMP ·log10(SB)
+
+TEXT ·Log2(SB), NOSPLIT, $0
+	JMP ·log2(SB)
+
+TEXT ·Log1p(SB), NOSPLIT, $0
+	JMP ·log1p(SB)
+
+TEXT ·Log(SB), NOSPLIT, $0
+	JMP ·log(SB)
+
 TEXT ·Max(SB), NOSPLIT, $0
 	JMP ·max(SB)
 
 TEXT ·Min(SB), NOSPLIT, $0
 	JMP ·min(SB)
 
+TEXT ·Mod(SB), NOSPLIT, $0
+	JMP ·mod(SB)
+
+TEXT ·Modf(SB), NOSPLIT, $0
+	JMP ·modf(SB)
+
 TEXT ·Pow(SB), NOSPLIT, $0
 	JMP ·pow(SB)
 
+TEXT ·Remainder(SB), NOSPLIT, $0
+	JMP ·remainder(SB)
+
 TEXT ·Sin(SB), NOSPLIT, $0
 	JMP ·sin(SB)
 
-- 
GitLab


From b110a43628526787f73db44e11829520d92e5b2b Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 15 Feb 2021 11:26:58 -0500
Subject: [PATCH 0722/2400] runtime: delete gosave (dead code)

Change-Id: Ie811526534df8622d89c5b1b81dbe19ece1c962b
Reviewed-on: https://go-review.googlesource.com/c/go/+/292110
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/runtime/proc.go     | 2 +-
 src/runtime/stack.go    | 2 +-
 src/runtime/stubs.go    | 1 +
 src/runtime/sys_wasm.go | 2 +-
 src/runtime/sys_x86.go  | 2 +-
 5 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index ccfe085691..dbb430fd25 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -3482,7 +3482,7 @@ func save(pc, sp uintptr) {
 // This is called only from the go syscall library and cgocall,
 // not from the low-level system calls used by the runtime.
 //
-// Entersyscall cannot split the stack: the gosave must
+// Entersyscall cannot split the stack: the save must
 // make g->sched refer to the caller's stack segment, because
 // entersyscall is going to return immediately after.
 //
diff --git a/src/runtime/stack.go b/src/runtime/stack.go
index 8c90e7b46f..d971e5e26f 100644
--- a/src/runtime/stack.go
+++ b/src/runtime/stack.go
@@ -1089,7 +1089,7 @@ func nilfunc() {
 }
 
 // adjust Gobuf as if it executed a call to fn
-// and then did an immediate gosave.
+// and then stopped before the first instruction in fn.
 func gostartcallfn(gobuf *gobuf, fv *funcval) {
 	var fn unsafe.Pointer
 	if fv != nil {
diff --git a/src/runtime/stubs.go b/src/runtime/stubs.go
index c0cc95ec65..b9b313a711 100644
--- a/src/runtime/stubs.go
+++ b/src/runtime/stubs.go
@@ -169,6 +169,7 @@ func noescape(p unsafe.Pointer) unsafe.Pointer {
 // This in turn calls cgocallbackg, which is where we'll find
 // pointer-declared arguments.
 func cgocallback(fn, frame, ctxt uintptr)
+
 func gogo(buf *gobuf)
 
 //go:noescape
diff --git a/src/runtime/sys_wasm.go b/src/runtime/sys_wasm.go
index 3ed621f92e..057ed4ccd9 100644
--- a/src/runtime/sys_wasm.go
+++ b/src/runtime/sys_wasm.go
@@ -27,7 +27,7 @@ func wasmTruncU()
 func wasmExit(code int32)
 
 // adjust Gobuf as it if executed a call to fn with context ctxt
-// and then did an immediate gosave.
+// and then stopped before the first instruction in fn.
 func gostartcall(buf *gobuf, fn, ctxt unsafe.Pointer) {
 	sp := buf.sp
 	sp -= sys.PtrSize
diff --git a/src/runtime/sys_x86.go b/src/runtime/sys_x86.go
index 5b7a666679..8f21585d28 100644
--- a/src/runtime/sys_x86.go
+++ b/src/runtime/sys_x86.go
@@ -12,7 +12,7 @@ import (
 )
 
 // adjust Gobuf as if it executed a call to fn with context ctxt
-// and then did an immediate gosave.
+// and then stopped before the first instruction in fn.
 func gostartcall(buf *gobuf, fn, ctxt unsafe.Pointer) {
 	sp := buf.sp
 	sp -= sys.PtrSize
-- 
GitLab


From b445d6ea34661328a7310beda285c64d6823624d Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 15 Feb 2021 17:02:30 -0500
Subject: [PATCH 0723/2400] runtime/pprof: expect tests to pass on macOS

macOS tests have been disabled since CL 12429045 (Aug 2013).
At the time, macOS required a kernel patch to get a working profiler
(https://research.swtch.com/macpprof), which we didn't want
to require, of course.

macOS has improved - it no longer requires the kernel patch - but
we never updated the list of exceptions.

As far as I can tell, the builders have no problem passing the pprof test now.
(It is possible that the iOS builders have trouble, but that is now a different GOOS.)

Remove the exception for macOS. The test should now pass.

Fixes #6047.

Change-Id: Iab49036cacc1025e56f515bd19d084390c2f5357
Reviewed-on: https://go-review.googlesource.com/c/go/+/292229
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/pprof/pprof_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go
index f7c1349bc6..d7571953a9 100644
--- a/src/runtime/pprof/pprof_test.go
+++ b/src/runtime/pprof/pprof_test.go
@@ -279,7 +279,7 @@ func testCPUProfile(t *testing.T, matches matchFunc, need []string, avoid []stri
 
 	broken := false
 	switch runtime.GOOS {
-	case "darwin", "ios", "dragonfly", "netbsd", "illumos", "solaris":
+	case "ios", "dragonfly", "netbsd", "illumos", "solaris":
 		broken = true
 	case "openbsd":
 		if runtime.GOARCH == "arm" || runtime.GOARCH == "arm64" {
-- 
GitLab


From 40765ffa95e87e603845d83591f75efa54049eca Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 18 Feb 2021 11:27:23 -0500
Subject: [PATCH 0724/2400] os/exec: disable failing LookPathTest on
 windows/arm64

For #44379.

Change-Id: I9a3cf4d511a8286117f877c2ff9dbde56fa55983
Reviewed-on: https://go-review.googlesource.com/c/go/+/293709
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: Russ Cox <rsc@golang.org>
---
 src/os/exec/lp_windows_test.go | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/src/os/exec/lp_windows_test.go b/src/os/exec/lp_windows_test.go
index c6f3d5d406..56cb54f800 100644
--- a/src/os/exec/lp_windows_test.go
+++ b/src/os/exec/lp_windows_test.go
@@ -143,7 +143,7 @@ func (test lookPathTest) run(t *testing.T, tmpdir, printpathExe string) {
 	if errCmd == nil && errLP == nil {
 		// both succeeded
 		if should != have {
-			t.Fatalf("test=%+v failed: expected to find %q, but found %q", test, should, have)
+			t.Fatalf("test=%+v:\ncmd /c ran: %s\nlookpath found: %s", test, should, have)
 		}
 		return
 	}
@@ -316,12 +316,17 @@ func TestLookPath(t *testing.T) {
 
 	// Run all tests.
 	for i, test := range lookPathTests {
-		dir := filepath.Join(tmp, "d"+strconv.Itoa(i))
-		err := os.Mkdir(dir, 0700)
-		if err != nil {
-			t.Fatal("Mkdir failed: ", err)
-		}
-		test.run(t, dir, printpathExe)
+		t.Run(fmt.Sprint(i), func(t *testing.T) {
+			if i == 16 {
+				t.Skip("golang.org/issue/44379")
+			}
+			dir := filepath.Join(tmp, "d"+strconv.Itoa(i))
+			err := os.Mkdir(dir, 0700)
+			if err != nil {
+				t.Fatal("Mkdir failed: ", err)
+			}
+			test.run(t, dir, printpathExe)
+		})
 	}
 }
 
-- 
GitLab


From ee7038f6a5f12d68a49b8b8193702341e5b8b151 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 18 Feb 2021 11:47:47 -0500
Subject: [PATCH 0725/2400] net: disable Windows netsh tests when netsh won't
 run

On my Surface Pro X running the insider preview,
running "netsh help" from Powershell started from the task bar works.
But running "powershell" at a cmd.exe prompt and then running
"netsh help" produces missing DLL errors.
These aren't our fault, so just skip the netsh-based tests if this happens.

Change-Id: I13a17e01143d823d3b5242d827db056bd253e3e9
Reviewed-on: https://go-review.googlesource.com/c/go/+/293849
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/net/net_windows_test.go | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/src/net/net_windows_test.go b/src/net/net_windows_test.go
index a0000950c6..2a563a078c 100644
--- a/src/net/net_windows_test.go
+++ b/src/net/net_windows_test.go
@@ -204,12 +204,17 @@ func runCmd(args ...string) ([]byte, error) {
 	return removeUTF8BOM(out), nil
 }
 
-func netshSpeaksEnglish(t *testing.T) bool {
+func checkNetsh(t *testing.T) {
 	out, err := runCmd("netsh", "help")
 	if err != nil {
 		t.Fatal(err)
 	}
-	return bytes.Contains(out, []byte("The following commands are available:"))
+	if bytes.Contains(out, []byte("The following helper DLL cannot be loaded")) {
+		t.Skipf("powershell failure:\n%s", err)
+	}
+	if !bytes.Contains(out, []byte("The following commands are available:")) {
+		t.Skipf("powershell does not speak English:\n%s", out)
+	}
 }
 
 func netshInterfaceIPShowInterface(ipver string, ifaces map[string]bool) error {
@@ -256,9 +261,7 @@ func netshInterfaceIPShowInterface(ipver string, ifaces map[string]bool) error {
 }
 
 func TestInterfacesWithNetsh(t *testing.T) {
-	if !netshSpeaksEnglish(t) {
-		t.Skip("English version of netsh required for this test")
-	}
+	checkNetsh(t)
 
 	toString := func(name string, isup bool) string {
 		if isup {
@@ -427,9 +430,7 @@ func netshInterfaceIPv6ShowAddress(name string, netshOutput []byte) []string {
 }
 
 func TestInterfaceAddrsWithNetsh(t *testing.T) {
-	if !netshSpeaksEnglish(t) {
-		t.Skip("English version of netsh required for this test")
-	}
+	checkNetsh(t)
 
 	outIPV4, err := runCmd("netsh", "interface", "ipv4", "show", "address")
 	if err != nil {
-- 
GitLab


From 5f2e24efb3c7e021308d15a26d93e5a7aa3c05f0 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 18 Feb 2021 13:01:10 -0500
Subject: [PATCH 0726/2400] cmd/internal/diff: skip over Cygwin warning in diff
 output

This happens on Windows. Don't let it stop us.

Change-Id: Ie2115d5825e1c2217f237ed373adb35594a5aaff
Reviewed-on: https://go-review.googlesource.com/c/go/+/293850
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/internal/diff/diff.go | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/src/cmd/internal/diff/diff.go b/src/cmd/internal/diff/diff.go
index c0ca2f3106..0ec2d7f8f9 100644
--- a/src/cmd/internal/diff/diff.go
+++ b/src/cmd/internal/diff/diff.go
@@ -7,6 +7,7 @@
 package diff
 
 import (
+	"bytes"
 	exec "internal/execabs"
 	"io/ioutil"
 	"os"
@@ -38,6 +39,25 @@ func Diff(prefix string, b1, b2 []byte) ([]byte, error) {
 		// Ignore that failure as long as we get output.
 		err = nil
 	}
+
+	// If we are on Windows and the diff is Cygwin diff,
+	// machines can get into a state where every Cygwin
+	// command works fine but prints a useless message like:
+	//
+	//	Cygwin WARNING:
+	//	  Couldn't compute FAST_CWD pointer.  This typically occurs if you're using
+	//	  an older Cygwin version on a newer Windows.  Please update to the latest
+	//	  available Cygwin version from https://cygwin.com/.  If the problem persists,
+	//	  please see https://cygwin.com/problems.html
+	//
+	// Skip over that message and just return the actual diff.
+	if len(data) > 0 && !bytes.HasPrefix(data, []byte("--- ")) {
+		i := bytes.Index(data, []byte("\n--- "))
+		if i >= 0 && i < 80*10 && bytes.Contains(data[:i], []byte("://cygwin.com/")) {
+			data = data[i+1:]
+		}
+	}
+
 	return data, err
 }
 
-- 
GitLab


From 4da0188c6c1ec83db2a3659af8e4eaace155ab80 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Thu, 4 Feb 2021 09:42:48 -0500
Subject: [PATCH 0727/2400] cmd/go/internal/modget: split resolveCandidates
 into two methods

It turns out that the existing call sites of the resolveCandidates
method pass only *either* a slice of queries or a slice of upgrades
(never both), and the behaviors triggered by the two parameters don't
overlap much at all. To clarify the two different operations, split
them into two separate methods.

For #36460

Change-Id: I64651637734fd44fea68740a3cdfbacfb73c19b6
Reviewed-on: https://go-review.googlesource.com/c/go/+/289697
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modget/get.go | 106 +++++++++++++++++-------------
 1 file changed, 60 insertions(+), 46 deletions(-)

diff --git a/src/cmd/go/internal/modget/get.go b/src/cmd/go/internal/modget/get.go
index dccacd3d1e..6b328d8bc8 100644
--- a/src/cmd/go/internal/modget/get.go
+++ b/src/cmd/go/internal/modget/get.go
@@ -310,7 +310,7 @@ func runGet(ctx context.Context, cmd *base.Command, args []string) {
 		r.performWildcardQueries(ctx)
 		r.performPatternAllQueries(ctx)
 
-		if changed := r.resolveCandidates(ctx, queries, nil); changed {
+		if changed := r.resolveQueries(ctx, queries); changed {
 			// 'go get' arguments can be (and often are) package patterns rather than
 			// (just) modules. A package can be provided by any module with a prefix
 			// of its import path, and a wildcard can even match packages in modules
@@ -347,12 +347,12 @@ func runGet(ctx context.Context, cmd *base.Command, args []string) {
 		// - ambiguous import errors.
 		//   TODO(#27899): Try to resolve ambiguous import errors automatically.
 		upgrades := r.findAndUpgradeImports(ctx, queries)
-		if changed := r.resolveCandidates(ctx, nil, upgrades); changed {
+		if changed := r.applyUpgrades(ctx, upgrades); changed {
 			continue
 		}
 
 		r.findMissingWildcards(ctx)
-		if changed := r.resolveCandidates(ctx, r.wildcardQueries, nil); changed {
+		if changed := r.resolveQueries(ctx, r.wildcardQueries); changed {
 			continue
 		}
 
@@ -460,9 +460,8 @@ type resolver struct {
 	// that resolved the module to that version (the “reason”).
 	resolvedVersion map[string]versionReason
 
-	buildList                 []module.Version
-	buildListResolvedVersions int               // len(resolvedVersion) when buildList was computed
-	buildListVersion          map[string]string // index of buildList (module path → version)
+	buildList        []module.Version
+	buildListVersion map[string]string // index of buildList (module path → version)
 
 	initialVersion map[string]string // index of the initial build list at the start of 'go get'
 
@@ -1176,24 +1175,19 @@ func (r *resolver) loadPackages(ctx context.Context, patterns []string, findPack
 // to be updated before its dependencies can be loaded.
 var errVersionChange = errors.New("version change needed")
 
-// resolveCandidates resolves candidates sets that are attached to the given
+// resolveQueries resolves candidate sets that are attached to the given
 // queries and/or needed to provide the given missing-package dependencies.
 //
-// resolveCandidates starts by resolving one module version from each
+// resolveQueries starts by resolving one module version from each
 // unambiguous pathSet attached to the given queries.
 //
 // If no unambiguous query results in a change to the build list,
-// resolveCandidates modifies the build list by adding one module version from
-// each pathSet in missing, but does not mark those versions as resolved
-// (so they can still be modified by other queries).
-//
-// If that still does not result in any changes to the build list,
-// resolveCandidates revisits the ambiguous query candidates and resolves them
+// resolveQueries revisits the ambiguous query candidates and resolves them
 // arbitrarily in order to guarantee forward progress.
 //
 // If all pathSets are resolved without any changes to the build list,
-// resolveCandidates returns with changed=false.
-func (r *resolver) resolveCandidates(ctx context.Context, queries []*query, upgrades []pathSet) (changed bool) {
+// resolveQueries returns with changed=false.
+func (r *resolver) resolveQueries(ctx context.Context, queries []*query) (changed bool) {
 	defer base.ExitIfErrors()
 
 	// Note: this is O(N²) with the number of pathSets in the worst case.
@@ -1247,12 +1241,52 @@ func (r *resolver) resolveCandidates(ctx context.Context, queries []*query, upgr
 		}
 	}
 
-	if changed := r.updateBuildList(ctx, nil); changed {
-		// The build list has changed, so disregard any missing packages: they might
-		// now be determined by requirements in the build list, which we would
-		// prefer to use instead of arbitrary "latest" versions.
-		return true
+	if resolved > 0 {
+		if changed = r.updateBuildList(ctx, nil); changed {
+			// The build list has changed, so disregard any remaining ambiguous queries:
+			// they might now be determined by requirements in the build list, which we
+			// would prefer to use instead of arbitrary versions.
+			return true
+		}
+	}
+
+	// The build list will be the same on the next iteration as it was on this
+	// iteration, so any ambiguous queries will remain so. In order to make
+	// progress, resolve them arbitrarily but deterministically.
+	//
+	// If that results in conflicting versions, the user can re-run 'go get'
+	// with additional explicit versions for the conflicting packages or
+	// modules.
+	resolvedArbitrarily := 0
+	for _, q := range queries {
+		for _, cs := range q.candidates {
+			isPackage, m := r.chooseArbitrarily(cs)
+			if isPackage {
+				q.matchesPackages = true
+			}
+			r.resolve(q, m)
+			resolvedArbitrarily++
+		}
+	}
+	if resolvedArbitrarily > 0 {
+		changed = r.updateBuildList(ctx, nil)
 	}
+	return changed
+}
+
+// applyUpgrades disambiguates candidate sets that are needed to upgrade (or
+// provide) transitive dependencies imported by previously-resolved packages.
+//
+// applyUpgrades modifies the build list by adding one module version from each
+// pathSet in upgrades, then downgrading (or further upgrading) those modules as
+// needed to maintain any already-resolved versions of other modules.
+// applyUpgrades does not mark the new versions as resolved, so they can still
+// be further modified by other queries (such as wildcards).
+//
+// If all pathSets are resolved without any changes to the build list,
+// applyUpgrades returns with changed=false.
+func (r *resolver) applyUpgrades(ctx context.Context, upgrades []pathSet) (changed bool) {
+	defer base.ExitIfErrors()
 
 	// Arbitrarily add a "latest" version that provides each missing package, but
 	// do not mark the version as resolved: we still want to allow the explicit
@@ -1276,27 +1310,9 @@ func (r *resolver) resolveCandidates(ctx context.Context, queries []*query, upgr
 		tentative = append(tentative, m)
 	}
 	base.ExitIfErrors()
-	if changed := r.updateBuildList(ctx, tentative); changed {
-		return true
-	}
 
-	// The build list will be the same on the next iteration as it was on this
-	// iteration, so any ambiguous queries will remain so. In order to make
-	// progress, resolve them arbitrarily but deterministically.
-	//
-	// If that results in conflicting versions, the user can re-run 'go get'
-	// with additional explicit versions for the conflicting packages or
-	// modules.
-	for _, q := range queries {
-		for _, cs := range q.candidates {
-			isPackage, m := r.chooseArbitrarily(cs)
-			if isPackage {
-				q.matchesPackages = true
-			}
-			r.resolve(q, m)
-		}
-	}
-	return r.updateBuildList(ctx, nil)
+	changed = r.updateBuildList(ctx, tentative)
+	return changed
 }
 
 // disambiguate eliminates candidates from cs that conflict with other module
@@ -1614,11 +1630,10 @@ func (r *resolver) resolve(q *query, m module.Version) {
 //
 // If the additional modules conflict with the resolved versions, they will be
 // downgraded to a non-conflicting version (possibly "none").
+//
+// If the resulting build list is the same as the one resulting from the last
+// call to updateBuildList, updateBuildList returns with changed=false.
 func (r *resolver) updateBuildList(ctx context.Context, additions []module.Version) (changed bool) {
-	if len(additions) == 0 && len(r.resolvedVersion) == r.buildListResolvedVersions {
-		return false
-	}
-
 	defer base.ExitIfErrors()
 
 	resolved := make([]module.Version, 0, len(r.resolvedVersion))
@@ -1649,7 +1664,6 @@ func (r *resolver) updateBuildList(ctx context.Context, additions []module.Versi
 	}
 
 	buildList := modload.LoadAllModules(ctx)
-	r.buildListResolvedVersions = len(r.resolvedVersion)
 	if reflect.DeepEqual(r.buildList, buildList) {
 		return false
 	}
-- 
GitLab


From 87f425da1433a172c1fa02134a8dab9a3784e24f Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Tue, 9 Feb 2021 15:38:18 -0500
Subject: [PATCH 0728/2400] cmd/go/internal/mvs: split Reqs into narrower
 per-function interfaces

Reqs currently combines requirements with upgrades and downgrades.
However, only Upgrade needs the Upgrade method, and only Downgrade
needs the Previous method.

When we eventually add lazy loading, the lazily-loaded module graph
will not be able to compute upgrades and downgrades, so the
implementation work from here to there will be clearer if we are
explicit about which are still needed.

For #36460

Change-Id: I7bf8c2a84ce6bc4ef493a383e3d26850e9a6a6c0
Reviewed-on: https://go-review.googlesource.com/c/go/+/290771
Trust: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/mvs/mvs.go | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/src/cmd/go/internal/mvs/mvs.go b/src/cmd/go/internal/mvs/mvs.go
index bed4d5c1ba..ff2c5f963c 100644
--- a/src/cmd/go/internal/mvs/mvs.go
+++ b/src/cmd/go/internal/mvs/mvs.go
@@ -41,6 +41,11 @@ type Reqs interface {
 	// Note that v1 < v2 can be written Max(v1, v2) != v1
 	// and similarly v1 <= v2 can be written Max(v1, v2) == v2.
 	Max(v1, v2 string) string
+}
+
+// An UpgradeReqs is a Reqs that can also identify available upgrades.
+type UpgradeReqs interface {
+	Reqs
 
 	// Upgrade returns the upgraded version of m,
 	// for use during an UpgradeAll operation.
@@ -54,6 +59,11 @@ type Reqs interface {
 	// TODO(rsc): Upgrade must be able to return errors,
 	// but should "no latest version" just return m instead?
 	Upgrade(m module.Version) (module.Version, error)
+}
+
+// A DowngradeReqs is a Reqs that can also identify available downgrades.
+type DowngradeReqs interface {
+	Reqs
 
 	// Previous returns the version of m.Path immediately prior to m.Version,
 	// or "none" if no such version is known.
@@ -323,7 +333,7 @@ func Req(target module.Version, base []string, reqs Reqs) ([]module.Version, err
 
 // UpgradeAll returns a build list for the target module
 // in which every module is upgraded to its latest version.
-func UpgradeAll(target module.Version, reqs Reqs) ([]module.Version, error) {
+func UpgradeAll(target module.Version, reqs UpgradeReqs) ([]module.Version, error) {
 	return buildList(target, reqs, func(m module.Version) (module.Version, error) {
 		if m.Path == target.Path {
 			return target, nil
@@ -335,7 +345,7 @@ func UpgradeAll(target module.Version, reqs Reqs) ([]module.Version, error) {
 
 // Upgrade returns a build list for the target module
 // in which the given additional modules are upgraded.
-func Upgrade(target module.Version, reqs Reqs, upgrade ...module.Version) ([]module.Version, error) {
+func Upgrade(target module.Version, reqs UpgradeReqs, upgrade ...module.Version) ([]module.Version, error) {
 	list, err := reqs.Required(target)
 	if err != nil {
 		return nil, err
@@ -374,7 +384,7 @@ func Upgrade(target module.Version, reqs Reqs, upgrade ...module.Version) ([]mod
 // The versions to be downgraded may be unreachable from reqs.Latest and
 // reqs.Previous, but the methods of reqs must otherwise handle such versions
 // correctly.
-func Downgrade(target module.Version, reqs Reqs, downgrade ...module.Version) ([]module.Version, error) {
+func Downgrade(target module.Version, reqs DowngradeReqs, downgrade ...module.Version) ([]module.Version, error) {
 	// Per https://research.swtch.com/vgo-mvs#algorithm_4:
 	// “To avoid an unnecessary downgrade to E 1.1, we must also add a new
 	// requirement on E 1.2. We can apply Algorithm R to find the minimal set of
-- 
GitLab


From 8654db4555bd0537162a72c4514c601a9a8b5c30 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 18 Feb 2021 17:01:54 -0800
Subject: [PATCH 0729/2400] [dev.typeparams] go/types: adjust printing of
 embedded struct fields (fixes x/tools/cmd/guru tests)

Prior to 1.16, go/types printed an embedded struct field by simply
printing its type, which may have included a package qualification.
Just printing the type is not useful with generic types and we now
must print the actual field name derived from the type - this leads
to different output for non-generic imported embedded types. Fix by
printing a package qualification in that case.

Change-Id: I2cb2484da7732428d13fdfb5fe4ec1fa1ee813a2
Reviewed-on: https://go-review.googlesource.com/c/go/+/293961
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/go/types/typestring.go | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/go/types/typestring.go b/src/go/types/typestring.go
index 64bbb33505..6ddba08bdc 100644
--- a/src/go/types/typestring.go
+++ b/src/go/types/typestring.go
@@ -126,6 +126,13 @@ func writeType(buf *bytes.Buffer, typ Type, qf Qualifier, visited []Type) {
 			if i > 0 {
 				buf.WriteString("; ")
 			}
+			// For compatibility with versions < go1.16, qualify the field name
+			// of embedded fields with the package name. Various tests (such as
+			// in x/tools/cmd/guru) depend on this output; and x/tools packages
+			// are run against earlier versions of Go.
+			if n, _ := f.typ.(*Named); f.embedded && n != nil && n.obj != nil && n.obj.pkg != nil {
+				writePackage(buf, n.obj.pkg, qf)
+			}
 			buf.WriteString(f.name)
 			if f.embedded {
 				// emphasize that the embedded field's name
-- 
GitLab


From 2f37939a21d534940382b1c3d3c3863ff1b9f50d Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 18 Feb 2021 20:08:42 -0500
Subject: [PATCH 0730/2400] go/parser: improve error recovery from invalid
 selector exprs

Before this CL, the parser consumed the next token following an invalid
selector expr no matter what it was. This leads to poor error recovery
when this next token is a closing delimiter or other reasonable element
of a stop set. As a side-effect, x/tools tests broke when parser logic
for type parameters was introduced, as they threw off the parser
synchronization to the point where the x/tools test bailed out.

This CL introduces a targeted fix that allows the x/tools tests to pass.
More general improvement for parser error recovery should be done for
go1.17.

Change-Id: I44d73d34b6063e62d16a23d24ab7cbce6500239d
Reviewed-on: https://go-review.googlesource.com/c/go/+/293792
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/go/parser/parser.go | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/go/parser/parser.go b/src/go/parser/parser.go
index e12eee79bf..41c3f2943e 100644
--- a/src/go/parser/parser.go
+++ b/src/go/parser/parser.go
@@ -1754,7 +1754,14 @@ func (p *parser) parsePrimaryExpr(lhs bool) (x ast.Expr) {
 			default:
 				pos := p.pos
 				p.errorExpected(pos, "selector or type assertion")
-				p.next() // make progress
+				// TODO(rFindley) The check for token.RBRACE below is a targeted fix
+				//                to error recovery sufficient to make the x/tools tests to
+				//                pass with the new parsing logic introduced for type
+				//                parameters. Remove this once error recovery has been
+				//                more generally reconsidered.
+				if p.tok != token.RBRACE {
+					p.next() // make progress
+				}
 				sel := &ast.Ident{NamePos: pos, Name: "_"}
 				x = &ast.SelectorExpr{X: x, Sel: sel}
 			}
-- 
GitLab


From 7764ee5614df2228e03326487af7670c7c5d268a Mon Sep 17 00:00:00 2001
From: Meng Zhuo <mzh@golangcn.org>
Date: Fri, 19 Feb 2021 14:31:57 +0800
Subject: [PATCH 0731/2400] runtime: fix invalid nil g check for for mips64x

In CL 292109 we removed unnecessary writes to gp.sched.g
but put wrong register to save g (R4 saves pointer to g) on mips64x

Change-Id: I9777846a7b0a46e1af83dcfc73b74649e0dba3c9
Reviewed-on: https://go-review.googlesource.com/c/go/+/293989
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Joel Sing <joel@sing.id.au>
Trust: Meng Zhuo <mzh@golangcn.org>
Run-TryBot: Meng Zhuo <mzh@golangcn.org>
---
 src/runtime/asm_mips64x.s | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/runtime/asm_mips64x.s b/src/runtime/asm_mips64x.s
index af27b9b555..c123e96a71 100644
--- a/src/runtime/asm_mips64x.s
+++ b/src/runtime/asm_mips64x.s
@@ -98,11 +98,11 @@ TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
 TEXT runtime·gogo(SB), NOSPLIT|NOFRAME, $0-8
 	MOVV	buf+0(FP), R3
 	MOVV	gobuf_g(R3), R4
-	MOVV	0(R4), R5	// make sure g != nil
+	MOVV	0(R4), R0	// make sure g != nil
 	JMP	gogo<>(SB)
 
 TEXT gogo<>(SB), NOSPLIT|NOFRAME, $0
-	MOVV	R5, g
+	MOVV	R4, g
 	JAL	runtime·save_g(SB)
 
 	MOVV	0(g), R2
-- 
GitLab


From dfe0ef961b02916ae8403ced9a9a7c9a9ec19a7e Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 18 Feb 2021 18:06:01 -0800
Subject: [PATCH 0732/2400] [dev.typeparams] go/types, types2: revert fancy
 struct printing (fixes x/tools tests)

An embedded struct field is embedded by mentioning its type.
The fact that the field name may be different and derived
from the type doesn't matter for the struct type.

Do print the embedded type rather than the derived field
name, as we have always done in the past. Remove the fancy
new code which was just plain wrong.

The struct output printing is only relevant for debugging
and test cases. Reverting to the original code (pre-generics)
fixes a couple of x/tools tests.

Unfortunately, the original code is (also) not correct for
embedded type aliases. Adjusted a gccgoimporter test
accordingly and filed issue #44410.

This is a follow-up on https://golang.org/cl/293961 which
addressed the issue only partially and left the incorrect
code in place.

Change-Id: Icb7a89c12ef7929c221fb1a5792f144f7fcd5855
Reviewed-on: https://go-review.googlesource.com/c/go/+/293962
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/typestring.go | 36 +++-------------
 .../internal/gccgoimporter/importer_test.go   |  2 +-
 src/go/types/typestring.go                    | 43 +++----------------
 3 files changed, 13 insertions(+), 68 deletions(-)

diff --git a/src/cmd/compile/internal/types2/typestring.go b/src/cmd/compile/internal/types2/typestring.go
index 47b2c259e5..af44624d2c 100644
--- a/src/cmd/compile/internal/types2/typestring.go
+++ b/src/cmd/compile/internal/types2/typestring.go
@@ -126,19 +126,14 @@ func writeType(buf *bytes.Buffer, typ Type, qf Qualifier, visited []Type) {
 			if i > 0 {
 				buf.WriteString("; ")
 			}
-			buf.WriteString(f.name)
-			if f.embedded {
-				// emphasize that the embedded field's name
-				// doesn't match the field's type name
-				if f.name != embeddedFieldName(f.typ) {
-					buf.WriteString(" /* = ")
-					writeType(buf, f.typ, qf, visited)
-					buf.WriteString(" */")
-				}
-			} else {
+			// This doesn't do the right thing for embedded type
+			// aliases where we should print the alias name, not
+			// the aliased type (see issue #44410).
+			if !f.embedded {
+				buf.WriteString(f.name)
 				buf.WriteByte(' ')
-				writeType(buf, f.typ, qf, visited)
 			}
+			writeType(buf, f.typ, qf, visited)
 			if tag := t.Tag(i); tag != "" {
 				fmt.Fprintf(buf, " %q", tag)
 			}
@@ -423,25 +418,6 @@ func writeSignature(buf *bytes.Buffer, sig *Signature, qf Qualifier, visited []T
 	writeTuple(buf, sig.results, false, qf, visited)
 }
 
-// embeddedFieldName returns an embedded field's name given its type.
-// The result is "" if the type doesn't have an embedded field name.
-func embeddedFieldName(typ Type) string {
-	switch t := typ.(type) {
-	case *Basic:
-		return t.name
-	case *Named:
-		return t.obj.name
-	case *Pointer:
-		// *T is ok, but **T is not
-		if _, ok := t.base.(*Pointer); !ok {
-			return embeddedFieldName(t.base)
-		}
-	case *instance:
-		return t.base.obj.name
-	}
-	return "" // not a (pointer to) a defined type
-}
-
 // subscript returns the decimal (utf8) representation of x using subscript digits.
 func subscript(x uint64) string {
 	const w = len("₀") // all digits 0...9 have the same utf8 width
diff --git a/src/go/internal/gccgoimporter/importer_test.go b/src/go/internal/gccgoimporter/importer_test.go
index c5b520feb4..b3f39312be 100644
--- a/src/go/internal/gccgoimporter/importer_test.go
+++ b/src/go/internal/gccgoimporter/importer_test.go
@@ -94,7 +94,7 @@ var importerTests = [...]importerTest{
 	{pkgpath: "nointerface", name: "I", want: "type I int"},
 	{pkgpath: "issue29198", name: "FooServer", gccgoVersion: 7, want: "type FooServer struct{FooServer *FooServer; user string; ctx context.Context}"},
 	{pkgpath: "issue30628", name: "Apple", want: "type Apple struct{hey sync.RWMutex; x int; RQ [517]struct{Count uintptr; NumBytes uintptr; Last uintptr}}"},
-	{pkgpath: "issue31540", name: "S", gccgoVersion: 7, want: "type S struct{b int; A2 /* = map[Y]Z */}"},
+	{pkgpath: "issue31540", name: "S", gccgoVersion: 7, want: "type S struct{b int; map[Y]Z}"}, // should want "type S struct{b int; A2}" (issue  #44410)
 	{pkgpath: "issue34182", name: "T1", want: "type T1 struct{f *T2}"},
 	{pkgpath: "notinheap", name: "S", want: "type S struct{}"},
 }
diff --git a/src/go/types/typestring.go b/src/go/types/typestring.go
index 6ddba08bdc..4697bd31e6 100644
--- a/src/go/types/typestring.go
+++ b/src/go/types/typestring.go
@@ -126,26 +126,14 @@ func writeType(buf *bytes.Buffer, typ Type, qf Qualifier, visited []Type) {
 			if i > 0 {
 				buf.WriteString("; ")
 			}
-			// For compatibility with versions < go1.16, qualify the field name
-			// of embedded fields with the package name. Various tests (such as
-			// in x/tools/cmd/guru) depend on this output; and x/tools packages
-			// are run against earlier versions of Go.
-			if n, _ := f.typ.(*Named); f.embedded && n != nil && n.obj != nil && n.obj.pkg != nil {
-				writePackage(buf, n.obj.pkg, qf)
-			}
-			buf.WriteString(f.name)
-			if f.embedded {
-				// emphasize that the embedded field's name
-				// doesn't match the field's type name
-				if f.name != embeddedFieldName(f.typ) {
-					buf.WriteString(" /* = ")
-					writeType(buf, f.typ, qf, visited)
-					buf.WriteString(" */")
-				}
-			} else {
+			// This doesn't do the right thing for embedded type
+			// aliases where we should print the alias name, not
+			// the aliased type (see issue #44410).
+			if !f.embedded {
+				buf.WriteString(f.name)
 				buf.WriteByte(' ')
-				writeType(buf, f.typ, qf, visited)
 			}
+			writeType(buf, f.typ, qf, visited)
 			if tag := t.Tag(i); tag != "" {
 				fmt.Fprintf(buf, " %q", tag)
 			}
@@ -431,25 +419,6 @@ func writeSignature(buf *bytes.Buffer, sig *Signature, qf Qualifier, visited []T
 	writeTuple(buf, sig.results, false, qf, visited)
 }
 
-// embeddedFieldName returns an embedded field's name given its type.
-// The result is "" if the type doesn't have an embedded field name.
-func embeddedFieldName(typ Type) string {
-	switch t := typ.(type) {
-	case *Basic:
-		return t.name
-	case *Named:
-		return t.obj.name
-	case *Pointer:
-		// *T is ok, but **T is not
-		if _, ok := t.base.(*Pointer); !ok {
-			return embeddedFieldName(t.base)
-		}
-	case *instance:
-		return t.base.obj.name
-	}
-	return "" // not a (pointer to) a defined type
-}
-
 // subscript returns the decimal (utf8) representation of x using subscript digits.
 func subscript(x uint64) string {
 	const w = len("₀") // all digits 0...9 have the same utf8 width
-- 
GitLab


From fce2a94d84dd5e39e0d53e60beda22da7b6f55b0 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Wed, 17 Feb 2021 15:51:05 -0500
Subject: [PATCH 0733/2400] cmd/compile: fix buglet in inlined info abstract
 function dwarf-gen

When generating DWARF inlined info records, it's possible to have a
local function whose only callsites are inlined away, meaning that we
emit an abstract function DIE but no regular subprogram DIE. When
emitting DWARF scope info we need to handle this case (specifically
when scoping PCs, check for the case that the func in question has
been entirely deleted).

Fixes #44344.

Change-Id: I9f5bc692f225aa4c5c23f7bd2e50bcf7fe4fc5f3
Reviewed-on: https://go-review.googlesource.com/c/go/+/293309
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Russ Cox <rsc@golang.org>
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/dwarfgen/scope.go |  4 ++-
 test/fixedbugs/issue44344.go               | 30 ++++++++++++++++++++++
 2 files changed, 33 insertions(+), 1 deletion(-)
 create mode 100644 test/fixedbugs/issue44344.go

diff --git a/src/cmd/compile/internal/dwarfgen/scope.go b/src/cmd/compile/internal/dwarfgen/scope.go
index 1c040edc28..4957e24e44 100644
--- a/src/cmd/compile/internal/dwarfgen/scope.go
+++ b/src/cmd/compile/internal/dwarfgen/scope.go
@@ -37,7 +37,9 @@ func assembleScopes(fnsym *obj.LSym, fn *ir.Func, dwarfVars []*dwarf.Var, varSco
 	}
 
 	scopeVariables(dwarfVars, varScopes, dwarfScopes)
-	scopePCs(fnsym, fn.Marks, dwarfScopes)
+	if fnsym.Func().Text != nil {
+		scopePCs(fnsym, fn.Marks, dwarfScopes)
+	}
 	return compactScopes(dwarfScopes)
 }
 
diff --git a/test/fixedbugs/issue44344.go b/test/fixedbugs/issue44344.go
new file mode 100644
index 0000000000..06c4cb6cb8
--- /dev/null
+++ b/test/fixedbugs/issue44344.go
@@ -0,0 +1,30 @@
+// compile
+
+// Copyright 2021 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.
+
+// Issue #44344: a crash in DWARF scope generation (trying to
+// scope the PCs of a function that was inlined away).
+
+package main
+
+func main() {
+	pv := []int{3, 4, 5}
+	if pv[1] != 9 {
+		pv = append(pv, 9)
+	}
+	tryit := func() bool {
+		lpv := len(pv)
+		if lpv == 101 {
+			return false
+		}
+		if worst := pv[pv[1]&1]; worst != 101 {
+			return true
+		}
+		return false
+	}()
+	if tryit {
+		println(pv[0])
+	}
+}
-- 
GitLab


From 49add6ad90c3c6e150266b35ae98067d7b52c021 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 19 Feb 2021 05:22:35 -0500
Subject: [PATCH 0734/2400] runtime: fix spurious stack overflow detection

The regabi builders are unhappy about badctxt calling throw
calling systemstack calling gosave_systemstack_switch calling
badctxt, all nosplit, repeating. This wouldn't actually happen
since after one systemstack we'd end up on the system stack
and the next one wouldn't call gosave_systemstack_switch at all.

The badctxt call itself is in a very unlikely assertion failure
inside gosave_systemstack_switch.
Keep the assertion check but call runtime.abort instead on failure,
breaking the detected (but not real) cycle.

Change-Id: Iaf5c0fc065783b8c1c6d0f62d848f023a0714b96
Reviewed-on: https://go-review.googlesource.com/c/go/+/294069
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/asm_386.s     | 2 +-
 src/runtime/asm_amd64.s   | 2 +-
 src/runtime/asm_arm.s     | 2 +-
 src/runtime/asm_arm64.s   | 2 +-
 src/runtime/asm_mips64x.s | 2 +-
 src/runtime/asm_mipsx.s   | 2 +-
 src/runtime/asm_ppc64x.s  | 2 +-
 src/runtime/asm_riscv64.s | 2 +-
 src/runtime/asm_s390x.s   | 2 +-
 9 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/runtime/asm_386.s b/src/runtime/asm_386.s
index 5b0852f780..5cf6827c21 100644
--- a/src/runtime/asm_386.s
+++ b/src/runtime/asm_386.s
@@ -618,7 +618,7 @@ TEXT gosave_systemstack_switch<>(SB),NOSPLIT,$0
 	MOVL	(g_sched+gobuf_ctxt)(BX), AX
 	TESTL	AX, AX
 	JZ	2(PC)
-	CALL	runtime·badctxt(SB)
+	CALL	runtime·abort(SB)
 	POPL	BX
 	POPL	AX
 	RET
diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index a68dc72ae5..517c5a9d3e 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -677,7 +677,7 @@ TEXT gosave_systemstack_switch<>(SB),NOSPLIT,$0
 	MOVQ	(g_sched+gobuf_ctxt)(R14), R9
 	TESTQ	R9, R9
 	JZ	2(PC)
-	CALL	runtime·badctxt(SB)
+	CALL	runtime·abort(SB)
 	RET
 
 // func asmcgocall_no_g(fn, arg unsafe.Pointer)
diff --git a/src/runtime/asm_arm.s b/src/runtime/asm_arm.s
index f9535bb1bc..9896ab4383 100644
--- a/src/runtime/asm_arm.s
+++ b/src/runtime/asm_arm.s
@@ -536,7 +536,7 @@ TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
 	MOVW	(g_sched+gobuf_ctxt)(g), R11
 	TST	R11, R11
 	B.EQ	2(PC)
-	BL	runtime·badctxt(SB)
+	BL	runtime·abort(SB)
 	RET
 
 // func asmcgocall_no_g(fn, arg unsafe.Pointer)
diff --git a/src/runtime/asm_arm64.s b/src/runtime/asm_arm64.s
index 699fc99d58..3709f1d95e 100644
--- a/src/runtime/asm_arm64.s
+++ b/src/runtime/asm_arm64.s
@@ -875,7 +875,7 @@ TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
 	// Assert ctxt is zero. See func save.
 	MOVD	(g_sched+gobuf_ctxt)(g), R0
 	CBZ	R0, 2(PC)
-	CALL	runtime·badctxt(SB)
+	CALL	runtime·abort(SB)
 	RET
 
 // func asmcgocall_no_g(fn, arg unsafe.Pointer)
diff --git a/src/runtime/asm_mips64x.s b/src/runtime/asm_mips64x.s
index c123e96a71..cee4b528bb 100644
--- a/src/runtime/asm_mips64x.s
+++ b/src/runtime/asm_mips64x.s
@@ -415,7 +415,7 @@ TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
 	// Assert ctxt is zero. See func save.
 	MOVV	(g_sched+gobuf_ctxt)(g), R1
 	BEQ	R1, 2(PC)
-	JAL	runtime·badctxt(SB)
+	JAL	runtime·abort(SB)
 	RET
 
 // func asmcgocall_no_g(fn, arg unsafe.Pointer)
diff --git a/src/runtime/asm_mipsx.s b/src/runtime/asm_mipsx.s
index 0c7d28dcf7..17fbc902c2 100644
--- a/src/runtime/asm_mipsx.s
+++ b/src/runtime/asm_mipsx.s
@@ -413,7 +413,7 @@ TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
 	// Assert ctxt is zero. See func save.
 	MOVW	(g_sched+gobuf_ctxt)(g), R1
 	BEQ	R1, 2(PC)
-	JAL	runtime·badctxt(SB)
+	JAL	runtime·abort(SB)
 	RET
 
 // func asmcgocall(fn, arg unsafe.Pointer) int32
diff --git a/src/runtime/asm_ppc64x.s b/src/runtime/asm_ppc64x.s
index 56e73742ea..6544048497 100644
--- a/src/runtime/asm_ppc64x.s
+++ b/src/runtime/asm_ppc64x.s
@@ -547,7 +547,7 @@ TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
 	MOVD	(g_sched+gobuf_ctxt)(g), R31
 	CMP	R0, R31
 	BEQ	2(PC)
-	BL	runtime·badctxt(SB)
+	BL	runtime·abort(SB)
 	RET
 
 #ifdef GOOS_aix
diff --git a/src/runtime/asm_riscv64.s b/src/runtime/asm_riscv64.s
index 30f2bd2e4a..d8d5252ed5 100644
--- a/src/runtime/asm_riscv64.s
+++ b/src/runtime/asm_riscv64.s
@@ -310,7 +310,7 @@ TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
 	// Assert ctxt is zero. See func save.
 	MOV	(g_sched+gobuf_ctxt)(g), X31
 	BEQ	ZERO, X31, 2(PC)
-	CALL	runtime·badctxt(SB)
+	CALL	runtime·abort(SB)
 	RET
 
 // func asmcgocall(fn, arg unsafe.Pointer) int32
diff --git a/src/runtime/asm_s390x.s b/src/runtime/asm_s390x.s
index f9fb1a4c55..4748e00aa8 100644
--- a/src/runtime/asm_s390x.s
+++ b/src/runtime/asm_s390x.s
@@ -511,7 +511,7 @@ TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
 	// Assert ctxt is zero. See func save.
 	MOVD	(g_sched+gobuf_ctxt)(g), R1
 	CMPBEQ	R1, $0, 2(PC)
-	BL	runtime·badctxt(SB)
+	BL	runtime·abort(SB)
 	RET
 
 // func asmcgocall(fn, arg unsafe.Pointer) int32
-- 
GitLab


From 01eb70e3dd4d7bf00ee915841e6b3c56fc94fe44 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 19 Feb 2021 05:29:51 -0500
Subject: [PATCH 0735/2400] os: fix hex exit code print on 32-bit windows

We want to print hex exit codes for the large values,
but on 32-bit Windows the large values are negative.

Change-Id: I0e350b128414a9468c93eddc62d660f552c1ee05
Reviewed-on: https://go-review.googlesource.com/c/go/+/294070
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/os/exec_posix.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/os/exec_posix.go b/src/os/exec_posix.go
index 39f11c7ec1..8aa1e5e499 100644
--- a/src/os/exec_posix.go
+++ b/src/os/exec_posix.go
@@ -103,7 +103,7 @@ func (p *ProcessState) String() string {
 	switch {
 	case status.Exited():
 		code := status.ExitStatus()
-		if runtime.GOOS == "windows" && code >= 1<<16 { // windows uses large hex numbers
+		if runtime.GOOS == "windows" && uint(code) >= 1<<16 { // windows uses large hex numbers
 			res = "exit status " + uitox(uint(code))
 		} else { // unix systems use small decimal integers
 			res = "exit status " + itoa(code) // unix
-- 
GitLab


From fa18f224c378f5831210077944e5df718efb8df5 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 19 Feb 2021 05:42:20 -0500
Subject: [PATCH 0736/2400] runtime/pprof: disable TestMorestack on macOS under
 race detector

This is failing but only under the race detector.
It doesn't really seem fair to expect pprof to find
specific profile events with the race detector slowing
everything down anyway.

Change-Id: I4b353d3d63944c87884d117e07d119b2c7bf4684
Reviewed-on: https://go-review.googlesource.com/c/go/+/294071
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/pprof/pprof_test.go | 25 ++++++++++++++-----------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go
index d7571953a9..168c1d4496 100644
--- a/src/runtime/pprof/pprof_test.go
+++ b/src/runtime/pprof/pprof_test.go
@@ -11,6 +11,7 @@ import (
 	"context"
 	"fmt"
 	"internal/profile"
+	"internal/race"
 	"internal/testenv"
 	"io"
 	"math/big"
@@ -261,18 +262,13 @@ func parseProfile(t *testing.T, valBytes []byte, f func(uintptr, []*profile.Loca
 // as interpreted by matches, and returns the parsed profile.
 func testCPUProfile(t *testing.T, matches matchFunc, need []string, avoid []string, f func(dur time.Duration)) *profile.Profile {
 	switch runtime.GOOS {
-	case "darwin", "ios":
-		switch runtime.GOARCH {
-		case "arm64":
-			// nothing
-		default:
-			out, err := exec.Command("uname", "-a").CombinedOutput()
-			if err != nil {
-				t.Fatal(err)
-			}
-			vers := string(out)
-			t.Logf("uname -a: %v", vers)
+	case "darwin":
+		out, err := exec.Command("uname", "-a").CombinedOutput()
+		if err != nil {
+			t.Fatal(err)
 		}
+		vers := string(out)
+		t.Logf("uname -a: %v", vers)
 	case "plan9":
 		t.Skip("skipping on plan9")
 	}
@@ -588,6 +584,13 @@ func stackContainsAll(spec string, count uintptr, stk []*profile.Location, label
 }
 
 func TestMorestack(t *testing.T) {
+	if runtime.GOOS == "darwin" && race.Enabled {
+		// For whatever reason, using the race detector on macOS keeps us
+		// from finding the newstack/growstack calls in the profile.
+		// Not worth worrying about.
+		// https://build.golang.org/log/280d387327806e17c8aabeb38b9503dbbd942ed1
+		t.Skip("skipping on darwin race detector")
+	}
 	testCPUProfile(t, stackContainsAll, []string{"runtime.newstack,runtime/pprof.growstack"}, avoidFunctions(), func(duration time.Duration) {
 		t := time.After(duration)
 		c := make(chan bool)
-- 
GitLab


From 02e5a8fdfcc8e237f5b55618ccbe9ad845014427 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 19 Feb 2021 06:01:25 -0500
Subject: [PATCH 0737/2400] runtime: ignore SPWRITE in syscall functions

netbsd/amd64's Syscall9 changes SP using ADD and SUB,
which are treated as SPWRITEs (they are not accounted for
in the sp-adjust tracking, and there are too many functions that
would report mismatched stack adjustments at RET if they were).
A traceback starting in Syscall9 as saved by entersyscall complains
about the SPWRITE-ness unnecessarily, since the PC/SP are saved
at the start of the function. Ignore SPWRITE in that case.

netbsd/arm's Syscall6 also changes SP (R13), using a direct write.
So even if we could handle the ADD/SUB in the amd64 case or
rewrote that assembly, we'd still be stuck with a more difficult
problem in this case. Ignoring the SPWRITE fixes it.

Example crashes:
https://build.golang.org/log/160fc7b051a2cf90782b75a99984fff129329e66
https://build.golang.org/log/7879e2fecdb400eee616294285e1f952e5b17301

Change-Id: I0c8e9696066e90dafed6d4a93d11697da23f0080
Reviewed-on: https://go-review.googlesource.com/c/go/+/294072
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
---
 src/runtime/traceback.go | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/runtime/traceback.go b/src/runtime/traceback.go
index eb185eecd3..53eb689848 100644
--- a/src/runtime/traceback.go
+++ b/src/runtime/traceback.go
@@ -174,6 +174,12 @@ func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max in
 			// So we don't need to exclude it with the other SP-writing functions.
 			flag &^= funcFlag_SPWRITE
 		}
+		if frame.pc == pc0 && frame.sp == sp0 && pc0 == gp.syscallpc && sp0 == gp.syscallsp {
+			// Some Syscall functions write to SP, but they do so only after
+			// saving the entry PC/SP using entersyscall.
+			// Since we are using the entry PC/SP, the later SP write doesn't matter.
+			flag &^= funcFlag_SPWRITE
+		}
 
 		// Found an actual function.
 		// Derive frame pointer and link register.
-- 
GitLab


From 9322eec8a267196d38cba657495624c3c91565f1 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 19 Feb 2021 13:39:43 -0500
Subject: [PATCH 0738/2400] codereview.cfg: add codereview.cfg for master
 branch

The codereview sync-branch command wants all involved
branches to have codereview.cfg, and this will help us when
we transition from master to main later this year.

Change-Id: Ia8e4c8b8c86864ed9d730e5d96be1ff386e2e1cb
Reviewed-on: https://go-review.googlesource.com/c/go/+/294291
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 codereview.cfg | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 codereview.cfg

diff --git a/codereview.cfg b/codereview.cfg
new file mode 100644
index 0000000000..77a74f108e
--- /dev/null
+++ b/codereview.cfg
@@ -0,0 +1 @@
+branch: master
-- 
GitLab


From 06b86e98031aacdd6f0499799cc4f50200ecfd18 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Thu, 18 Feb 2021 18:07:09 -0800
Subject: [PATCH 0739/2400] cmd/compile:  fix check to avoid creating new
 closure function when typechecking inline body

By default, when typechecking a closure, tcClosure() creates a new
closure function. This should really be done separate from typechecking.
For now, we explicitly avoid creating a new closure function when
typechecking an inline body (in ImportedBody). However, the heuristic
for determining when we are typechecking an inline body was not correct
for double nested closures in an inline body, since CurFunc will then be
the inner closure, which has a body.

So, use a simple global variable to indicate when we typechecking an
inline body. The global variable is fine (just like ir.CurFunc), since
the front-end runs serially.

Fixes #44325

Change-Id: If2829fe1ebb195a7b1a240192b57fe6f04d1a36b
Reviewed-on: https://go-review.googlesource.com/c/go/+/294211
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/typecheck/func.go | 11 ++++++++++-
 test/fixedbugs/issue44325.dir/a.go         | 13 +++++++++++++
 test/fixedbugs/issue44325.dir/b.go         | 13 +++++++++++++
 test/fixedbugs/issue44325.go               |  7 +++++++
 4 files changed, 43 insertions(+), 1 deletion(-)
 create mode 100644 test/fixedbugs/issue44325.dir/a.go
 create mode 100644 test/fixedbugs/issue44325.dir/b.go
 create mode 100644 test/fixedbugs/issue44325.go

diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index 7ab5f68ce3..6e2354c281 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -100,6 +100,11 @@ func PartialCallType(n *ir.SelectorExpr) *types.Type {
 	return t
 }
 
+// True if we are typechecking an inline body in ImportedBody below. We use this
+// flag to not create a new closure function in tcClosure when we are just
+// typechecking an inline body, as opposed to the body of a real function.
+var inTypeCheckInl bool
+
 // Lazy typechecking of imported bodies. For local functions, CanInline will set ->typecheck
 // because they're a copy of an already checked body.
 func ImportedBody(fn *ir.Func) {
@@ -138,7 +143,12 @@ func ImportedBody(fn *ir.Func) {
 
 	savefn := ir.CurFunc
 	ir.CurFunc = fn
+	if inTypeCheckInl {
+		base.Fatalf("inTypeCheckInl should not be set recursively")
+	}
+	inTypeCheckInl = true
 	Stmts(fn.Inl.Body)
+	inTypeCheckInl = false
 	ir.CurFunc = savefn
 
 	// During ImportBody (which imports fn.Func.Inl.Body),
@@ -307,7 +317,6 @@ func tcClosure(clo *ir.ClosureExpr, top int) {
 	// body in ImportedBody(), since we only want to create the named function
 	// when the closure is actually inlined (and then we force a typecheck
 	// explicitly in (*inlsubst).node()).
-	inTypeCheckInl := ir.CurFunc != nil && ir.CurFunc.Body == nil
 	if !inTypeCheckInl {
 		fn.Nname.SetSym(ClosureName(ir.CurFunc))
 		ir.MarkFunc(fn.Nname)
diff --git a/test/fixedbugs/issue44325.dir/a.go b/test/fixedbugs/issue44325.dir/a.go
new file mode 100644
index 0000000000..5a22b455b7
--- /dev/null
+++ b/test/fixedbugs/issue44325.dir/a.go
@@ -0,0 +1,13 @@
+// Copyright 2021 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 a
+
+func FM() func() {
+	return func() {
+		_ = func() int {
+			return 0
+		}
+	}
+}
diff --git a/test/fixedbugs/issue44325.dir/b.go b/test/fixedbugs/issue44325.dir/b.go
new file mode 100644
index 0000000000..c4d77e311a
--- /dev/null
+++ b/test/fixedbugs/issue44325.dir/b.go
@@ -0,0 +1,13 @@
+// Copyright 2021 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 b
+
+import (
+	"./a"
+)
+
+func F() {
+	a.FM()
+}
diff --git a/test/fixedbugs/issue44325.go b/test/fixedbugs/issue44325.go
new file mode 100644
index 0000000000..d406838588
--- /dev/null
+++ b/test/fixedbugs/issue44325.go
@@ -0,0 +1,7 @@
+// compiledir
+
+// Copyright 2021 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 ignored
-- 
GitLab


From 6521c7b3786a69bc6ad3840ef2e3ba2088ad1cae Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Fri, 19 Feb 2021 09:39:01 -0800
Subject: [PATCH 0740/2400] [dev.typeparams] cmd/compile/internal/types2:
 resolve decl cycle the same way as in go/types

Minor adjustment to match go/types more closely.

Change-Id: Id79c51f0ecd8cda0f5b68f6e961500f7f22f7115
Reviewed-on: https://go-review.googlesource.com/c/go/+/294270
Reviewed-by: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/types2/expr.go | 44 +++++++++++++++----------
 src/cmd/compile/internal/types2/type.go | 11 +------
 2 files changed, 28 insertions(+), 27 deletions(-)

diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index a284c8c8b6..584b8ee6a0 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -59,11 +59,16 @@ the type (and constant value, if any) is recorded via Info.Types, if present.
 
 type opPredicates map[syntax.Operator]func(Type) bool
 
-var unaryOpPredicates = opPredicates{
-	syntax.Add: isNumeric,
-	syntax.Sub: isNumeric,
-	syntax.Xor: isInteger,
-	syntax.Not: isBoolean,
+var unaryOpPredicates opPredicates
+
+func init() {
+	// Setting unaryOpPredicates in init avoids declaration cycles.
+	unaryOpPredicates = opPredicates{
+		syntax.Add: isNumeric,
+		syntax.Sub: isNumeric,
+		syntax.Xor: isInteger,
+		syntax.Not: isBoolean,
+	}
 }
 
 func (check *Checker) op(m opPredicates, x *operand, op syntax.Operator) bool {
@@ -896,20 +901,25 @@ func (check *Checker) shift(x, y *operand, e syntax.Expr, op syntax.Operator) {
 	x.mode = value
 }
 
-var binaryOpPredicates = opPredicates{
-	syntax.Add: isNumericOrString,
-	syntax.Sub: isNumeric,
-	syntax.Mul: isNumeric,
-	syntax.Div: isNumeric,
-	syntax.Rem: isInteger,
+var binaryOpPredicates opPredicates
 
-	syntax.And:    isInteger,
-	syntax.Or:     isInteger,
-	syntax.Xor:    isInteger,
-	syntax.AndNot: isInteger,
+func init() {
+	// Setting binaryOpPredicates in init avoids declaration cycles.
+	binaryOpPredicates = opPredicates{
+		syntax.Add: isNumericOrString,
+		syntax.Sub: isNumeric,
+		syntax.Mul: isNumeric,
+		syntax.Div: isNumeric,
+		syntax.Rem: isInteger,
 
-	syntax.AndAnd: isBoolean,
-	syntax.OrOr:   isBoolean,
+		syntax.And:    isInteger,
+		syntax.Or:     isInteger,
+		syntax.Xor:    isInteger,
+		syntax.AndNot: isInteger,
+
+		syntax.AndAnd: isBoolean,
+		syntax.OrOr:   isBoolean,
+	}
 }
 
 // If e != nil, it must be the binary expression; it may be nil for non-constant expressions
diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
index 1025c18b23..52bd99deab 100644
--- a/src/cmd/compile/internal/types2/type.go
+++ b/src/cmd/compile/internal/types2/type.go
@@ -881,16 +881,7 @@ func (t *top) String() string       { return TypeString(t, nil) }
 // If it doesn't exist, the result is Typ[Invalid].
 // under must only be called when a type is known
 // to be fully set up.
-//
-// under is set to underf to avoid an initialization cycle.
-// TODO(gri) this doesn't happen in go/types - investigate
-var under func(Type) Type
-
-func init() {
-	under = underf
-}
-
-func underf(t Type) Type {
+func under(t Type) Type {
 	// TODO(gri) is this correct for *Sum?
 	if n := asNamed(t); n != nil {
 		return n.under()
-- 
GitLab


From 26713b5fefc158feb1f0f3d5d30627de226f7668 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Fri, 19 Feb 2021 17:37:17 -0500
Subject: [PATCH 0741/2400] go/types: don't write during sanitizeInfo if
 nothing has changed

In its final phase, the typechecker walks the types it produces to
ensure that no unexpanded type instances leak through the API. However,
this also walks shared types (such as those in the universe scope),
resulting in a potential data race during concurrent typechecking
passes.

Fix this by being careful not to write if nothing needs to be changed.
Since any shared types should already be sanitized, this should
eliminate data races.

For #44434

Change-Id: Iadb2e78863efe0e974e69a00e255f26cfaf9386a
Reviewed-on: https://go-review.googlesource.com/c/go/+/294411
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/go/types/sanitize.go | 82 ++++++++++++++++++++++++++++++----------
 1 file changed, 63 insertions(+), 19 deletions(-)

diff --git a/src/go/types/sanitize.go b/src/go/types/sanitize.go
index c4e729ec9b..3a6896c5c2 100644
--- a/src/go/types/sanitize.go
+++ b/src/go/types/sanitize.go
@@ -6,6 +6,11 @@ package types
 
 // sanitizeInfo walks the types contained in info to ensure that all instances
 // are expanded.
+//
+// This includes some objects that may be shared across concurrent
+// type-checking passes (such as those in the universe scope), so we are
+// careful here not to write types that are already sanitized. This avoids a
+// data race as any shared types should already be sanitized.
 func sanitizeInfo(info *Info) {
 	var s sanitizer = make(map[Type]Type)
 
@@ -13,27 +18,42 @@ func sanitizeInfo(info *Info) {
 	// If modified, they must be assigned back.
 
 	for e, tv := range info.Types {
-		tv.Type = s.typ(tv.Type)
-		info.Types[e] = tv
+		if typ := s.typ(tv.Type); typ != tv.Type {
+			tv.Type = typ
+			info.Types[e] = tv
+		}
 	}
 
 	for e, inf := range info.Inferred {
+		changed := false
 		for i, targ := range inf.Targs {
-			inf.Targs[i] = s.typ(targ)
+			if typ := s.typ(targ); typ != targ {
+				inf.Targs[i] = typ
+				changed = true
+			}
+		}
+		if typ := s.typ(inf.Sig); typ != inf.Sig {
+			inf.Sig = typ.(*Signature)
+			changed = true
+		}
+		if changed {
+			info.Inferred[e] = inf
 		}
-		inf.Sig = s.typ(inf.Sig).(*Signature)
-		info.Inferred[e] = inf
 	}
 
 	for _, obj := range info.Defs {
 		if obj != nil {
-			obj.setType(s.typ(obj.Type()))
+			if typ := s.typ(obj.Type()); typ != obj.Type() {
+				obj.setType(typ)
+			}
 		}
 	}
 
 	for _, obj := range info.Uses {
 		if obj != nil {
-			obj.setType(s.typ(obj.Type()))
+			if typ := s.typ(obj.Type()); typ != obj.Type() {
+				obj.setType(typ)
+			}
 		}
 	}
 
@@ -57,16 +77,22 @@ func (s sanitizer) typ(typ Type) Type {
 		// nothing to do
 
 	case *Array:
-		t.elem = s.typ(t.elem)
+		if elem := s.typ(t.elem); elem != t.elem {
+			t.elem = elem
+		}
 
 	case *Slice:
-		t.elem = s.typ(t.elem)
+		if elem := s.typ(t.elem); elem != t.elem {
+			t.elem = elem
+		}
 
 	case *Struct:
 		s.varList(t.fields)
 
 	case *Pointer:
-		t.base = s.typ(t.base)
+		if base := s.typ(t.base); base != t.base {
+			t.base = base
+		}
 
 	case *Tuple:
 		s.tuple(t)
@@ -87,20 +113,32 @@ func (s sanitizer) typ(typ Type) Type {
 		s.typ(t.allTypes)
 
 	case *Map:
-		t.key = s.typ(t.key)
-		t.elem = s.typ(t.elem)
+		if key := s.typ(t.key); key != t.key {
+			t.key = key
+		}
+		if elem := s.typ(t.elem); elem != t.elem {
+			t.elem = elem
+		}
 
 	case *Chan:
-		t.elem = s.typ(t.elem)
+		if elem := s.typ(t.elem); elem != t.elem {
+			t.elem = elem
+		}
 
 	case *Named:
-		t.orig = s.typ(t.orig)
-		t.underlying = s.typ(t.underlying)
+		if orig := s.typ(t.orig); orig != t.orig {
+			t.orig = orig
+		}
+		if under := s.typ(t.underlying); under != t.underlying {
+			t.underlying = under
+		}
 		s.typeList(t.targs)
 		s.funcList(t.methods)
 
 	case *TypeParam:
-		t.bound = s.typ(t.bound)
+		if bound := s.typ(t.bound); bound != t.bound {
+			t.bound = bound
+		}
 
 	case *instance:
 		typ = t.expand()
@@ -115,7 +153,9 @@ func (s sanitizer) typ(typ Type) Type {
 
 func (s sanitizer) var_(v *Var) {
 	if v != nil {
-		v.typ = s.typ(v.typ)
+		if typ := s.typ(v.typ); typ != v.typ {
+			v.typ = typ
+		}
 	}
 }
 
@@ -133,7 +173,9 @@ func (s sanitizer) tuple(t *Tuple) {
 
 func (s sanitizer) func_(f *Func) {
 	if f != nil {
-		f.typ = s.typ(f.typ)
+		if typ := s.typ(f.typ); typ != f.typ {
+			f.typ = typ
+		}
 	}
 }
 
@@ -145,6 +187,8 @@ func (s sanitizer) funcList(list []*Func) {
 
 func (s sanitizer) typeList(list []Type) {
 	for i, t := range list {
-		list[i] = s.typ(t)
+		if typ := s.typ(t); typ != t {
+			list[i] = typ
+		}
 	}
 }
-- 
GitLab


From 078f08f0ee1eb6cb172fc1f9d53f34c5783e522d Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 16 Feb 2021 21:05:08 -0800
Subject: [PATCH 0742/2400] spec: every type has a method set (minor
 clarification)

The spec states that a type "may" have a method set associated with it.
Yet every type has a method set, which may be empty. This is clarified
later in the same paragraph. Be clear in the first sentence as well.

Per the suggestion from https://github.com/DQNEO.

Fixes #44318.

Change-Id: I6097b1c7062853e404b7fead56d18a7f9c576fc3
Reviewed-on: https://go-review.googlesource.com/c/go/+/292853
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 doc/go_spec.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index 59c9ce3c43..e22fabd699 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1,6 +1,6 @@
 <!--{
 	"Title": "The Go Programming Language Specification",
-	"Subtitle": "Version of Feb 10, 2021",
+	"Subtitle": "Version of Feb 19, 2021",
 	"Path": "/ref/spec"
 }-->
 
@@ -830,7 +830,7 @@ The underlying type of <code>[]B1</code>, <code>B3</code>, and <code>B4</code> i
 
 <h3 id="Method_sets">Method sets</h3>
 <p>
-A type may have a <i>method set</i> associated with it.
+A type has a (possibly empty) <i>method set</i> associated with it.
 The method set of an <a href="#Interface_types">interface type</a> is its interface.
 The method set of any other type <code>T</code> consists of all
 <a href="#Method_declarations">methods</a> declared with receiver type <code>T</code>.
-- 
GitLab


From a8942d2cffd80c68febe1c908a0eb464d2f5bb40 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 19 Feb 2021 17:01:35 -0500
Subject: [PATCH 0743/2400] runtime/pprof: disable TestMorestack on
 darwin/arm64

Something is weird about darwin and TestMorestack,
but it is only manifesting on arm64 and race+amd64.
Disable for now.

Change-Id: I5862372fdd0b5ffae802fdefb65b2aa04e266fcc
Reviewed-on: https://go-review.googlesource.com/c/go/+/294409
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/pprof/pprof_test.go | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go
index 168c1d4496..14321b0934 100644
--- a/src/runtime/pprof/pprof_test.go
+++ b/src/runtime/pprof/pprof_test.go
@@ -591,6 +591,11 @@ func TestMorestack(t *testing.T) {
 		// https://build.golang.org/log/280d387327806e17c8aabeb38b9503dbbd942ed1
 		t.Skip("skipping on darwin race detector")
 	}
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
+		// For whatever reason, darwin/arm64 also doesn't work.
+		// https://build.golang.org/log/c45e82cc25f152642e6fb90d882ef5a8cd130ce5
+		t.Skip("skipping on darwin/arm64")
+	}
 	testCPUProfile(t, stackContainsAll, []string{"runtime.newstack,runtime/pprof.growstack"}, avoidFunctions(), func(duration time.Duration) {
 		t := time.After(duration)
 		c := make(chan bool)
-- 
GitLab


From 5b76343a1040571e3d2249168a00a4dc814e920a Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 22 Jun 2020 13:27:10 -0400
Subject: [PATCH 0744/2400] go/build: prefer //go:build over // +build lines

Part of //go:build change (#41184).
See https://golang.org/design/draft-gobuild

- Reject files with multiple //go:build lines.
- If a file has both //go:build and // +build lines, only use the //go:build line.
- Otherwise fall back to // +build lines
- Use go/build/constraint for parsing both //go:build and // +build lines.

For Go 1.17.

Change-Id: I32e2404d8ce266230f767718dc7cc24e77b425e8
Reviewed-on: https://go-review.googlesource.com/c/go/+/240607
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/go/build/build.go      | 139 ++++++++++++++++++-------------------
 src/go/build/build_test.go |  88 +++++++++++++++--------
 src/go/build/deps_test.go  |   2 +-
 3 files changed, 127 insertions(+), 102 deletions(-)

diff --git a/src/go/build/build.go b/src/go/build/build.go
index 217fadf5bd..0732f6aa19 100644
--- a/src/go/build/build.go
+++ b/src/go/build/build.go
@@ -9,6 +9,7 @@ import (
 	"errors"
 	"fmt"
 	"go/ast"
+	"go/build/constraint"
 	"go/doc"
 	"go/token"
 	exec "internal/execabs"
@@ -1423,7 +1424,7 @@ func (ctxt *Context) matchFile(dir, name string, allTags map[string]bool, binary
 	// Look for +build comments to accept or reject the file.
 	ok, sawBinaryOnly, err := ctxt.shouldBuild(info.header, allTags)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("%s: %v", name, err)
 	}
 	if !ok && !ctxt.UseAllFiles {
 		return nil, nil
@@ -1459,11 +1460,12 @@ var (
 	bSlashSlash = []byte(slashSlash)
 	bStarSlash  = []byte(starSlash)
 	bSlashStar  = []byte(slashStar)
+	bPlusBuild  = []byte("+build")
 
 	goBuildComment = []byte("//go:build")
 
 	errGoBuildWithoutBuild = errors.New("//go:build comment without // +build comment")
-	errMultipleGoBuild     = errors.New("multiple //go:build comments") // unused in Go 1.(N-1)
+	errMultipleGoBuild     = errors.New("multiple //go:build comments")
 )
 
 func isGoBuildComment(line []byte) bool {
@@ -1498,8 +1500,7 @@ var binaryOnlyComment = []byte("//go:binary-only-package")
 // shouldBuild reports whether the file should be built
 // and whether a //go:binary-only-package comment was found.
 func (ctxt *Context) shouldBuild(content []byte, allTags map[string]bool) (shouldBuild, binaryOnly bool, err error) {
-
-	// Pass 1. Identify leading run of // comments and blank lines,
+	// Identify leading run of // comments and blank lines,
 	// which must be followed by a blank line.
 	// Also identify any //go:build comments.
 	content, goBuild, sawBinaryOnly, err := parseFileHeader(content)
@@ -1507,44 +1508,42 @@ func (ctxt *Context) shouldBuild(content []byte, allTags map[string]bool) (shoul
 		return false, false, err
 	}
 
-	// Pass 2.  Process each +build line in the run.
-	p := content
-	shouldBuild = true
-	sawBuild := false
-	for len(p) > 0 {
-		line := p
-		if i := bytes.IndexByte(line, '\n'); i >= 0 {
-			line, p = line[:i], p[i+1:]
-		} else {
-			p = p[len(p):]
-		}
-		line = bytes.TrimSpace(line)
-		if !bytes.HasPrefix(line, bSlashSlash) {
-			continue
+	// If //go:build line is present, it controls.
+	// Otherwise fall back to +build processing.
+	switch {
+	case goBuild != nil:
+		x, err := constraint.Parse(string(goBuild))
+		if err != nil {
+			return false, false, fmt.Errorf("parsing //go:build line: %v", err)
 		}
-		line = bytes.TrimSpace(line[len(bSlashSlash):])
-		if len(line) > 0 && line[0] == '+' {
-			// Looks like a comment +line.
-			f := strings.Fields(string(line))
-			if f[0] == "+build" {
-				sawBuild = true
-				ok := false
-				for _, tok := range f[1:] {
-					if ctxt.match(tok, allTags) {
-						ok = true
-					}
-				}
-				if !ok {
+		shouldBuild = ctxt.eval(x, allTags)
+
+	default:
+		shouldBuild = true
+		p := content
+		for len(p) > 0 {
+			line := p
+			if i := bytes.IndexByte(line, '\n'); i >= 0 {
+				line, p = line[:i], p[i+1:]
+			} else {
+				p = p[len(p):]
+			}
+			line = bytes.TrimSpace(line)
+			if !bytes.HasPrefix(line, bSlashSlash) || !bytes.Contains(line, bPlusBuild) {
+				continue
+			}
+			text := string(line)
+			if !constraint.IsPlusBuild(text) {
+				continue
+			}
+			if x, err := constraint.Parse(text); err == nil {
+				if !ctxt.eval(x, allTags) {
 					shouldBuild = false
 				}
 			}
 		}
 	}
 
-	if goBuild != nil && !sawBuild {
-		return false, false, errGoBuildWithoutBuild
-	}
-
 	return shouldBuild, sawBinaryOnly, nil
 }
 
@@ -1580,7 +1579,7 @@ Lines:
 		}
 
 		if !inSlashStar && isGoBuildComment(line) {
-			if false && goBuild != nil { // enabled in Go 1.N
+			if goBuild != nil {
 				return nil, nil, false, errMultipleGoBuild
 			}
 			goBuild = line
@@ -1649,7 +1648,7 @@ func (ctxt *Context) saveCgo(filename string, di *Package, cg *ast.CommentGroup)
 		if len(cond) > 0 {
 			ok := false
 			for _, c := range cond {
-				if ctxt.match(c, nil) {
+				if ctxt.matchAuto(c, nil) {
 					ok = true
 					break
 				}
@@ -1831,50 +1830,44 @@ func splitQuoted(s string) (r []string, err error) {
 	return args, err
 }
 
-// match reports whether the name is one of:
+// matchAuto interprets text as either a +build or //go:build expression (whichever works),
+// reporting whether the expression matches the build context.
 //
+// matchAuto is only used for testing of tag evaluation
+// and in #cgo lines, which accept either syntax.
+func (ctxt *Context) matchAuto(text string, allTags map[string]bool) bool {
+	if strings.ContainsAny(text, "&|()") {
+		text = "//go:build " + text
+	} else {
+		text = "// +build " + text
+	}
+	x, err := constraint.Parse(text)
+	if err != nil {
+		return false
+	}
+	return ctxt.eval(x, allTags)
+}
+
+func (ctxt *Context) eval(x constraint.Expr, allTags map[string]bool) bool {
+	return x.Eval(func(tag string) bool { return ctxt.matchTag(tag, allTags) })
+}
+
+// matchTag reports whether the name is one of:
+//
+//	cgo (if cgo is enabled)
 //	$GOOS
 //	$GOARCH
-//	cgo (if cgo is enabled)
-//	!cgo (if cgo is disabled)
 //	ctxt.Compiler
-//	!ctxt.Compiler
+//	linux (if GOOS = android)
+//	solaris (if GOOS = illumos)
 //	tag (if tag is listed in ctxt.BuildTags or ctxt.ReleaseTags)
-//	!tag (if tag is not listed in ctxt.BuildTags or ctxt.ReleaseTags)
-//	a comma-separated list of any of these
 //
-func (ctxt *Context) match(name string, allTags map[string]bool) bool {
-	if name == "" {
-		if allTags != nil {
-			allTags[name] = true
-		}
-		return false
-	}
-	if i := strings.Index(name, ","); i >= 0 {
-		// comma-separated list
-		ok1 := ctxt.match(name[:i], allTags)
-		ok2 := ctxt.match(name[i+1:], allTags)
-		return ok1 && ok2
-	}
-	if strings.HasPrefix(name, "!!") { // bad syntax, reject always
-		return false
-	}
-	if strings.HasPrefix(name, "!") { // negation
-		return len(name) > 1 && !ctxt.match(name[1:], allTags)
-	}
-
+// It records all consulted tags in allTags.
+func (ctxt *Context) matchTag(name string, allTags map[string]bool) bool {
 	if allTags != nil {
 		allTags[name] = true
 	}
 
-	// Tags must be letters, digits, underscores or dots.
-	// Unlike in Go identifiers, all digits are fine (e.g., "386").
-	for _, c := range name {
-		if !unicode.IsLetter(c) && !unicode.IsDigit(c) && c != '_' && c != '.' {
-			return false
-		}
-	}
-
 	// special tags
 	if ctxt.CgoEnabled && name == "cgo" {
 		return true
@@ -1946,10 +1939,10 @@ func (ctxt *Context) goodOSArchFile(name string, allTags map[string]bool) bool {
 	}
 	n := len(l)
 	if n >= 2 && knownOS[l[n-2]] && knownArch[l[n-1]] {
-		return ctxt.match(l[n-1], allTags) && ctxt.match(l[n-2], allTags)
+		return ctxt.matchTag(l[n-1], allTags) && ctxt.matchTag(l[n-2], allTags)
 	}
 	if n >= 1 && (knownOS[l[n-1]] || knownArch[l[n-1]]) {
-		return ctxt.match(l[n-1], allTags)
+		return ctxt.matchTag(l[n-1], allTags)
 	}
 	return true
 }
diff --git a/src/go/build/build_test.go b/src/go/build/build_test.go
index d8f264cac7..0762a150eb 100644
--- a/src/go/build/build_test.go
+++ b/src/go/build/build_test.go
@@ -30,7 +30,7 @@ func TestMatch(t *testing.T) {
 	match := func(tag string, want map[string]bool) {
 		t.Helper()
 		m := make(map[string]bool)
-		if !ctxt.match(tag, m) {
+		if !ctxt.matchAuto(tag, m) {
 			t.Errorf("%s context should match %s, does not", what, tag)
 		}
 		if !reflect.DeepEqual(m, want) {
@@ -40,7 +40,7 @@ func TestMatch(t *testing.T) {
 	nomatch := func(tag string, want map[string]bool) {
 		t.Helper()
 		m := make(map[string]bool)
-		if ctxt.match(tag, m) {
+		if ctxt.matchAuto(tag, m) {
 			t.Errorf("%s context should NOT match %s, does", what, tag)
 		}
 		if !reflect.DeepEqual(m, want) {
@@ -153,6 +153,13 @@ var shouldBuildTests = []struct {
 		tags:        map[string]bool{"yes": true},
 		shouldBuild: true,
 	},
+	{
+		name: "Yes2",
+		content: "//go:build yes\n" +
+			"package main\n",
+		tags:        map[string]bool{"yes": true},
+		shouldBuild: true,
+	},
 	{
 		name: "Or",
 		content: "// +build no yes\n\n" +
@@ -160,6 +167,13 @@ var shouldBuildTests = []struct {
 		tags:        map[string]bool{"yes": true, "no": true},
 		shouldBuild: true,
 	},
+	{
+		name: "Or2",
+		content: "//go:build no || yes\n" +
+			"package main\n",
+		tags:        map[string]bool{"yes": true, "no": true},
+		shouldBuild: true,
+	},
 	{
 		name: "And",
 		content: "// +build no,yes\n\n" +
@@ -167,6 +181,13 @@ var shouldBuildTests = []struct {
 		tags:        map[string]bool{"yes": true, "no": true},
 		shouldBuild: false,
 	},
+	{
+		name: "And2",
+		content: "//go:build no && yes\n" +
+			"package main\n",
+		tags:        map[string]bool{"yes": true, "no": true},
+		shouldBuild: false,
+	},
 	{
 		name: "Cgo",
 		content: "// +build cgo\n\n" +
@@ -177,12 +198,23 @@ var shouldBuildTests = []struct {
 		tags:        map[string]bool{"cgo": true},
 		shouldBuild: false,
 	},
+	{
+		name: "Cgo2",
+		content: "//go:build cgo\n" +
+			"// Copyright The Go Authors.\n\n" +
+			"// This package implements parsing of tags like\n" +
+			"// +build tag1\n" +
+			"package build",
+		tags:        map[string]bool{"cgo": true},
+		shouldBuild: false,
+	},
 	{
 		name: "AfterPackage",
 		content: "// Copyright The Go Authors.\n\n" +
 			"package build\n\n" +
 			"// shouldBuild checks tags given by lines of the form\n" +
 			"// +build tag\n" +
+			"//go:build tag\n" +
 			"func shouldBuild(content []byte)\n",
 		tags:        map[string]bool{},
 		shouldBuild: true,
@@ -194,6 +226,13 @@ var shouldBuildTests = []struct {
 		tags:        map[string]bool{},
 		shouldBuild: true,
 	},
+	{
+		name: "TooClose2",
+		content: "//go:build yes\n" +
+			"package main\n",
+		tags:        map[string]bool{"yes": true},
+		shouldBuild: true,
+	},
 	{
 		name: "TooCloseNo",
 		content: "// +build no\n" +
@@ -201,6 +240,13 @@ var shouldBuildTests = []struct {
 		tags:        map[string]bool{},
 		shouldBuild: true,
 	},
+	{
+		name: "TooCloseNo2",
+		content: "//go:build no\n" +
+			"package main\n",
+		tags:        map[string]bool{"no": true},
+		shouldBuild: false,
+	},
 	{
 		name: "BinaryOnly",
 		content: "//go:binary-only-package\n" +
@@ -211,41 +257,30 @@ var shouldBuildTests = []struct {
 		shouldBuild: true,
 	},
 	{
-		name: "ValidGoBuild",
-		content: "// +build yes\n\n" +
+		name: "BinaryOnly2",
+		content: "//go:binary-only-package\n" +
 			"//go:build no\n" +
 			"package main\n",
-		tags:        map[string]bool{"yes": true},
-		shouldBuild: true,
-	},
-	{
-		name: "MissingBuild",
-		content: "//go:build no\n" +
-			"package main\n",
-		tags:        map[string]bool{},
+		tags:        map[string]bool{"no": true},
+		binaryOnly:  true,
 		shouldBuild: false,
-		err:         errGoBuildWithoutBuild,
 	},
 	{
-		name: "MissingBuild2",
-		content: "/* */\n" +
-			"// +build yes\n\n" +
+		name: "ValidGoBuild",
+		content: "// +build yes\n\n" +
 			"//go:build no\n" +
 			"package main\n",
-		tags:        map[string]bool{},
+		tags:        map[string]bool{"no": true},
 		shouldBuild: false,
-		err:         errGoBuildWithoutBuild,
 	},
 	{
 		name: "MissingBuild2",
-		content: "/*\n" +
+		content: "/* */\n" +
 			"// +build yes\n\n" +
-			"*/\n" +
 			"//go:build no\n" +
 			"package main\n",
-		tags:        map[string]bool{},
+		tags:        map[string]bool{"no": true},
 		shouldBuild: false,
-		err:         errGoBuildWithoutBuild,
 	},
 	{
 		name: "Comment1",
@@ -263,9 +298,8 @@ var shouldBuildTests = []struct {
 			"*/\n\n" +
 			"//go:build no\n" +
 			"package main\n",
-		tags:        map[string]bool{},
+		tags:        map[string]bool{"no": true},
 		shouldBuild: false,
-		err:         errGoBuildWithoutBuild,
 	},
 	{
 		name: "Comment3",
@@ -274,9 +308,8 @@ var shouldBuildTests = []struct {
 			"*/\n\n" +
 			"//go:build no\n" +
 			"package main\n",
-		tags:        map[string]bool{},
+		tags:        map[string]bool{"no": true},
 		shouldBuild: false,
-		err:         errGoBuildWithoutBuild,
 	},
 	{
 		name: "Comment4",
@@ -290,9 +323,8 @@ var shouldBuildTests = []struct {
 		content: "/**/\n" +
 			"//go:build no\n" +
 			"package main\n",
-		tags:        map[string]bool{},
+		tags:        map[string]bool{"no": true},
 		shouldBuild: false,
-		err:         errGoBuildWithoutBuild,
 	},
 }
 
diff --git a/src/go/build/deps_test.go b/src/go/build/deps_test.go
index e5c849e8f5..42184276ea 100644
--- a/src/go/build/deps_test.go
+++ b/src/go/build/deps_test.go
@@ -295,7 +295,7 @@ var depsRules = `
 	FMT
 	< go/build/constraint;
 
-	go/doc, go/parser, internal/goroot, internal/goversion
+	go/build/constraint, go/doc, go/parser, internal/goroot, internal/goversion
 	< go/build;
 
 	DEBUG, go/build, go/types, text/scanner
-- 
GitLab


From 9fd6cc105db89107bf163d2f0c1f8f55e442ec4d Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 26 Jun 2020 16:22:35 -0400
Subject: [PATCH 0745/2400] go/printer: canonicalize //go:build and // +build
 lines while formatting

Part of //go:build change (#41184).
See https://golang.org/design/draft-gobuild

Gofmt and any other go/printer-using program will now:

 - move //go:build and //+build lines to the appropriate file location
 - if there's no //go:build line, add one derived from the // +build lines
 - if there is a //go:build line, recompute and replace any // +build lines
   to match what the //go:build line says

For Go 1.17.

Change-Id: Ide5cc3b4a07507ba9ed6f8b0de846e840876f49f
Reviewed-on: https://go-review.googlesource.com/c/go/+/240608
Trust: Russ Cox <rsc@golang.org>
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/go/build/deps_test.go               |   8 +-
 src/go/format/format_test.go            |   4 +
 src/go/printer/gobuild.go               | 170 ++++++++++++++++++++++++
 src/go/printer/printer.go               |  14 ++
 src/go/printer/printer_test.go          |  20 ++-
 src/go/printer/testdata/gobuild1.golden |   6 +
 src/go/printer/testdata/gobuild1.input  |   7 +
 src/go/printer/testdata/gobuild2.golden |   8 ++
 src/go/printer/testdata/gobuild2.input  |   9 ++
 src/go/printer/testdata/gobuild3.golden |  10 ++
 src/go/printer/testdata/gobuild3.input  |  11 ++
 src/go/printer/testdata/gobuild4.golden |   6 +
 src/go/printer/testdata/gobuild4.input  |   5 +
 src/go/printer/testdata/gobuild5.golden |   4 +
 src/go/printer/testdata/gobuild5.input  |   4 +
 src/go/printer/testdata/gobuild6.golden |   5 +
 src/go/printer/testdata/gobuild6.input  |   4 +
 src/go/printer/testdata/gobuild7.golden |  11 ++
 src/go/printer/testdata/gobuild7.input  |  11 ++
 19 files changed, 307 insertions(+), 10 deletions(-)
 create mode 100644 src/go/printer/gobuild.go
 create mode 100644 src/go/printer/testdata/gobuild1.golden
 create mode 100644 src/go/printer/testdata/gobuild1.input
 create mode 100644 src/go/printer/testdata/gobuild2.golden
 create mode 100644 src/go/printer/testdata/gobuild2.input
 create mode 100644 src/go/printer/testdata/gobuild3.golden
 create mode 100644 src/go/printer/testdata/gobuild3.input
 create mode 100644 src/go/printer/testdata/gobuild4.golden
 create mode 100644 src/go/printer/testdata/gobuild4.input
 create mode 100644 src/go/printer/testdata/gobuild5.golden
 create mode 100644 src/go/printer/testdata/gobuild5.input
 create mode 100644 src/go/printer/testdata/gobuild6.golden
 create mode 100644 src/go/printer/testdata/gobuild6.input
 create mode 100644 src/go/printer/testdata/gobuild7.golden
 create mode 100644 src/go/printer/testdata/gobuild7.input

diff --git a/src/go/build/deps_test.go b/src/go/build/deps_test.go
index 42184276ea..e05d0aac2e 100644
--- a/src/go/build/deps_test.go
+++ b/src/go/build/deps_test.go
@@ -279,7 +279,10 @@ var depsRules = `
 	< go/ast
 	< go/parser;
 
-	go/parser, text/tabwriter
+	FMT
+	< go/build/constraint;
+
+	go/build/constraint, go/parser, text/tabwriter
 	< go/printer
 	< go/format;
 
@@ -292,9 +295,6 @@ var depsRules = `
 	container/heap, go/constant, go/parser, regexp
 	< go/types;
 
-	FMT
-	< go/build/constraint;
-
 	go/build/constraint, go/doc, go/parser, internal/goroot, internal/goversion
 	< go/build;
 
diff --git a/src/go/format/format_test.go b/src/go/format/format_test.go
index 27f4c74cdf..6cc0278b79 100644
--- a/src/go/format/format_test.go
+++ b/src/go/format/format_test.go
@@ -151,6 +151,10 @@ var tests = []string{
 	// erroneous programs
 	"ERROR1 + 2 +",
 	"ERRORx :=  0",
+
+	// build comments
+	"// copyright\n\n//go:build x\n\npackage p\n",
+	"// copyright\n\n//go:build x\n// +build x\n\npackage p\n",
 }
 
 func String(s string) (string, error) {
diff --git a/src/go/printer/gobuild.go b/src/go/printer/gobuild.go
new file mode 100644
index 0000000000..f00492d077
--- /dev/null
+++ b/src/go/printer/gobuild.go
@@ -0,0 +1,170 @@
+// Copyright 2020 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 printer
+
+import (
+	"go/build/constraint"
+	"sort"
+	"text/tabwriter"
+)
+
+func (p *printer) fixGoBuildLines() {
+	if len(p.goBuild)+len(p.plusBuild) == 0 {
+		return
+	}
+
+	// Find latest possible placement of //go:build and // +build comments.
+	// That's just after the last blank line before we find a non-comment.
+	// (We'll add another blank line after our comment block.)
+	// When we start dropping // +build comments, we can skip over /* */ comments too.
+	// Note that we are processing tabwriter input, so every comment
+	// begins and ends with a tabwriter.Escape byte.
+	// And some newlines have turned into \f bytes.
+	insert := 0
+	for pos := 0; ; {
+		// Skip leading space at beginning of line.
+		blank := true
+		for pos < len(p.output) && (p.output[pos] == ' ' || p.output[pos] == '\t') {
+			pos++
+		}
+		// Skip over // comment if any.
+		if pos+3 < len(p.output) && p.output[pos] == tabwriter.Escape && p.output[pos+1] == '/' && p.output[pos+2] == '/' {
+			blank = false
+			for pos < len(p.output) && !isNL(p.output[pos]) {
+				pos++
+			}
+		}
+		// Skip over \n at end of line.
+		if pos >= len(p.output) || !isNL(p.output[pos]) {
+			break
+		}
+		pos++
+
+		if blank {
+			insert = pos
+		}
+	}
+
+	// If there is a //go:build comment before the place we identified,
+	// use that point instead. (Earlier in the file is always fine.)
+	if len(p.goBuild) > 0 && p.goBuild[0] < insert {
+		insert = p.goBuild[0]
+	} else if len(p.plusBuild) > 0 && p.plusBuild[0] < insert {
+		insert = p.plusBuild[0]
+	}
+
+	var x constraint.Expr
+	switch len(p.goBuild) {
+	case 0:
+		// Synthesize //go:build expression from // +build lines.
+		for _, pos := range p.plusBuild {
+			y, err := constraint.Parse(p.commentTextAt(pos))
+			if err != nil {
+				x = nil
+				break
+			}
+			if x == nil {
+				x = y
+			} else {
+				x = &constraint.AndExpr{X: x, Y: y}
+			}
+		}
+	case 1:
+		// Parse //go:build expression.
+		x, _ = constraint.Parse(p.commentTextAt(p.goBuild[0]))
+	}
+
+	var block []byte
+	if x == nil {
+		// Don't have a valid //go:build expression to treat as truth.
+		// Bring all the lines together but leave them alone.
+		// Note that these are already tabwriter-escaped.
+		for _, pos := range p.goBuild {
+			block = append(block, p.lineAt(pos)...)
+		}
+		for _, pos := range p.plusBuild {
+			block = append(block, p.lineAt(pos)...)
+		}
+	} else {
+		block = append(block, tabwriter.Escape)
+		block = append(block, "//go:build "...)
+		block = append(block, x.String()...)
+		block = append(block, tabwriter.Escape, '\n')
+		if len(p.plusBuild) > 0 {
+			lines, err := constraint.PlusBuildLines(x)
+			if err != nil {
+				lines = []string{"// +build error: " + err.Error()}
+			}
+			for _, line := range lines {
+				block = append(block, tabwriter.Escape)
+				block = append(block, line...)
+				block = append(block, tabwriter.Escape, '\n')
+			}
+		}
+	}
+	block = append(block, '\n')
+
+	// Build sorted list of lines to delete from remainder of output.
+	toDelete := append(p.goBuild, p.plusBuild...)
+	sort.Ints(toDelete)
+
+	// Collect output after insertion point, with lines deleted, into after.
+	var after []byte
+	start := insert
+	for _, end := range toDelete {
+		if end < start {
+			continue
+		}
+		after = appendLines(after, p.output[start:end])
+		start = end + len(p.lineAt(end))
+	}
+	after = appendLines(after, p.output[start:])
+	if n := len(after); n >= 2 && isNL(after[n-1]) && isNL(after[n-2]) {
+		after = after[:n-1]
+	}
+
+	p.output = p.output[:insert]
+	p.output = append(p.output, block...)
+	p.output = append(p.output, after...)
+}
+
+// appendLines is like append(x, y...)
+// but it avoids creating doubled blank lines,
+// which would not be gofmt-standard output.
+// It assumes that only whole blocks of lines are being appended,
+// not line fragments.
+func appendLines(x, y []byte) []byte {
+	if len(y) > 0 && isNL(y[0]) && // y starts in blank line
+		(len(x) == 0 || len(x) >= 2 && isNL(x[len(x)-1]) && isNL(x[len(x)-2])) { // x is empty or ends in blank line
+		y = y[1:] // delete y's leading blank line
+	}
+	return append(x, y...)
+}
+
+func (p *printer) lineAt(start int) []byte {
+	pos := start
+	for pos < len(p.output) && !isNL(p.output[pos]) {
+		pos++
+	}
+	if pos < len(p.output) {
+		pos++
+	}
+	return p.output[start:pos]
+}
+
+func (p *printer) commentTextAt(start int) string {
+	if start < len(p.output) && p.output[start] == tabwriter.Escape {
+		start++
+	}
+	pos := start
+	for pos < len(p.output) && p.output[pos] != tabwriter.Escape && !isNL(p.output[pos]) {
+		pos++
+	}
+	return string(p.output[start:pos])
+}
+
+func isNL(b byte) bool {
+	return b == '\n' || b == '\f'
+}
diff --git a/src/go/printer/printer.go b/src/go/printer/printer.go
index 0077afeaff..f02c1b847b 100644
--- a/src/go/printer/printer.go
+++ b/src/go/printer/printer.go
@@ -8,6 +8,7 @@ package printer
 import (
 	"fmt"
 	"go/ast"
+	"go/build/constraint"
 	"go/token"
 	"io"
 	"os"
@@ -64,6 +65,8 @@ type printer struct {
 	lastTok      token.Token  // last token printed (token.ILLEGAL if it's whitespace)
 	prevOpen     token.Token  // previous non-brace "open" token (, [, or token.ILLEGAL
 	wsbuf        []whiteSpace // delayed white space
+	goBuild      []int        // start index of all //go:build comments in output
+	plusBuild    []int        // start index of all // +build comments in output
 
 	// Positions
 	// The out position differs from the pos position when the result
@@ -649,6 +652,11 @@ func (p *printer) writeComment(comment *ast.Comment) {
 
 	// shortcut common case of //-style comments
 	if text[1] == '/' {
+		if constraint.IsGoBuild(text) {
+			p.goBuild = append(p.goBuild, len(p.output))
+		} else if constraint.IsPlusBuild(text) {
+			p.plusBuild = append(p.plusBuild, len(p.output))
+		}
 		p.writeString(pos, trimRight(text), true)
 		return
 	}
@@ -1122,6 +1130,8 @@ func (p *printer) printNode(node interface{}) error {
 	// get comments ready for use
 	p.nextComment()
 
+	p.print(pmode(0))
+
 	// format node
 	switch n := node.(type) {
 	case ast.Expr:
@@ -1313,6 +1323,10 @@ func (cfg *Config) fprint(output io.Writer, fset *token.FileSet, node interface{
 	p.impliedSemi = false // EOF acts like a newline
 	p.flush(token.Position{Offset: infinity, Line: infinity}, token.EOF)
 
+	// output is buffered in p.output now.
+	// fix //go:build and // +build comments if needed.
+	p.fixGoBuildLines()
+
 	// redirect output through a trimmer to eliminate trailing whitespace
 	// (Input to a tabwriter must be untrimmed since trailing tabs provide
 	// formatting information. The tabwriter could provide trimming
diff --git a/src/go/printer/printer_test.go b/src/go/printer/printer_test.go
index b15dcbf000..03c4badb04 100644
--- a/src/go/printer/printer_test.go
+++ b/src/go/printer/printer_test.go
@@ -88,8 +88,11 @@ func lineAt(text []byte, offs int) []byte {
 
 // diff compares a and b.
 func diff(aname, bname string, a, b []byte) error {
-	var buf bytes.Buffer // holding long error message
+	if bytes.Equal(a, b) {
+		return nil
+	}
 
+	var buf bytes.Buffer // holding long error message
 	// compare lengths
 	if len(a) != len(b) {
 		fmt.Fprintf(&buf, "\nlength changed: len(%s) = %d, len(%s) = %d", aname, len(a), bname, len(b))
@@ -97,7 +100,7 @@ func diff(aname, bname string, a, b []byte) error {
 
 	// compare contents
 	line := 1
-	offs := 1
+	offs := 0
 	for i := 0; i < len(a) && i < len(b); i++ {
 		ch := a[i]
 		if ch != b[i] {
@@ -112,10 +115,8 @@ func diff(aname, bname string, a, b []byte) error {
 		}
 	}
 
-	if buf.Len() > 0 {
-		return errors.New(buf.String())
-	}
-	return nil
+	fmt.Fprintf(&buf, "\n%s:\n%s\n%s:\n%s", aname, a, bname, b)
+	return errors.New(buf.String())
 }
 
 func runcheck(t *testing.T, source, golden string, mode checkMode) {
@@ -207,6 +208,13 @@ var data = []entry{
 	{"go2numbers.input", "go2numbers.golden", idempotent},
 	{"go2numbers.input", "go2numbers.norm", normNumber | idempotent},
 	{"generics.input", "generics.golden", idempotent},
+	{"gobuild1.input", "gobuild1.golden", idempotent},
+	{"gobuild2.input", "gobuild2.golden", idempotent},
+	{"gobuild3.input", "gobuild3.golden", idempotent},
+	{"gobuild4.input", "gobuild4.golden", idempotent},
+	{"gobuild5.input", "gobuild5.golden", idempotent},
+	{"gobuild6.input", "gobuild6.golden", idempotent},
+	{"gobuild7.input", "gobuild7.golden", idempotent},
 }
 
 func TestFiles(t *testing.T) {
diff --git a/src/go/printer/testdata/gobuild1.golden b/src/go/printer/testdata/gobuild1.golden
new file mode 100644
index 0000000000..649da40e91
--- /dev/null
+++ b/src/go/printer/testdata/gobuild1.golden
@@ -0,0 +1,6 @@
+//go:build x
+// +build x
+
+package p
+
+func f()
diff --git a/src/go/printer/testdata/gobuild1.input b/src/go/printer/testdata/gobuild1.input
new file mode 100644
index 0000000000..6538ee61af
--- /dev/null
+++ b/src/go/printer/testdata/gobuild1.input
@@ -0,0 +1,7 @@
+package p
+
+//go:build x
+
+func f()
+
+// +build y
diff --git a/src/go/printer/testdata/gobuild2.golden b/src/go/printer/testdata/gobuild2.golden
new file mode 100644
index 0000000000..c46fd34c55
--- /dev/null
+++ b/src/go/printer/testdata/gobuild2.golden
@@ -0,0 +1,8 @@
+//go:build x
+// +build x
+
+// other comment
+
+package p
+
+func f()
diff --git a/src/go/printer/testdata/gobuild2.input b/src/go/printer/testdata/gobuild2.input
new file mode 100644
index 0000000000..f0f772a7b2
--- /dev/null
+++ b/src/go/printer/testdata/gobuild2.input
@@ -0,0 +1,9 @@
+// +build y
+
+// other comment
+
+package p
+
+func f()
+
+//go:build x
diff --git a/src/go/printer/testdata/gobuild3.golden b/src/go/printer/testdata/gobuild3.golden
new file mode 100644
index 0000000000..db92c5787e
--- /dev/null
+++ b/src/go/printer/testdata/gobuild3.golden
@@ -0,0 +1,10 @@
+// other comment
+
+//go:build x
+// +build x
+
+// yet another comment
+
+package p
+
+func f()
diff --git a/src/go/printer/testdata/gobuild3.input b/src/go/printer/testdata/gobuild3.input
new file mode 100644
index 0000000000..d0c97b27ad
--- /dev/null
+++ b/src/go/printer/testdata/gobuild3.input
@@ -0,0 +1,11 @@
+// other comment
+
+// +build y
+
+// yet another comment
+
+package p
+
+//go:build x
+
+func f()
diff --git a/src/go/printer/testdata/gobuild4.golden b/src/go/printer/testdata/gobuild4.golden
new file mode 100644
index 0000000000..b16477f9ad
--- /dev/null
+++ b/src/go/printer/testdata/gobuild4.golden
@@ -0,0 +1,6 @@
+//go:build (x || y) && z
+// +build x y
+// +build z
+
+// doc comment
+package p
diff --git a/src/go/printer/testdata/gobuild4.input b/src/go/printer/testdata/gobuild4.input
new file mode 100644
index 0000000000..29d5a0ae14
--- /dev/null
+++ b/src/go/printer/testdata/gobuild4.input
@@ -0,0 +1,5 @@
+// doc comment
+package p
+
+// +build x y
+// +build z
diff --git a/src/go/printer/testdata/gobuild5.golden b/src/go/printer/testdata/gobuild5.golden
new file mode 100644
index 0000000000..2808a53cce
--- /dev/null
+++ b/src/go/printer/testdata/gobuild5.golden
@@ -0,0 +1,4 @@
+//go:build !(x || y) && z
+// +build !x,!y,z
+
+package p
diff --git a/src/go/printer/testdata/gobuild5.input b/src/go/printer/testdata/gobuild5.input
new file mode 100644
index 0000000000..ec5815cdc6
--- /dev/null
+++ b/src/go/printer/testdata/gobuild5.input
@@ -0,0 +1,4 @@
+//go:build !(x || y) && z
+// +build something else
+
+package p
diff --git a/src/go/printer/testdata/gobuild6.golden b/src/go/printer/testdata/gobuild6.golden
new file mode 100644
index 0000000000..abb1e2acbb
--- /dev/null
+++ b/src/go/printer/testdata/gobuild6.golden
@@ -0,0 +1,5 @@
+//go:build !(x || y) && z
+
+// no +build line
+
+package p
diff --git a/src/go/printer/testdata/gobuild6.input b/src/go/printer/testdata/gobuild6.input
new file mode 100644
index 0000000000..162189754f
--- /dev/null
+++ b/src/go/printer/testdata/gobuild6.input
@@ -0,0 +1,4 @@
+//go:build !(x || y) && z
+// no +build line
+
+package p
diff --git a/src/go/printer/testdata/gobuild7.golden b/src/go/printer/testdata/gobuild7.golden
new file mode 100644
index 0000000000..bf41dd4b59
--- /dev/null
+++ b/src/go/printer/testdata/gobuild7.golden
@@ -0,0 +1,11 @@
+// Copyright 2013 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.
+
+// TODO(rsc): Delete this file once Go 1.17 comes out and we can retire Go 1.15 support.
+
+//go:build !go1.16
+// +build !go1.16
+
+// Package buildtag defines an Analyzer that checks build tags.
+package buildtag
diff --git a/src/go/printer/testdata/gobuild7.input b/src/go/printer/testdata/gobuild7.input
new file mode 100644
index 0000000000..bf41dd4b59
--- /dev/null
+++ b/src/go/printer/testdata/gobuild7.input
@@ -0,0 +1,11 @@
+// Copyright 2013 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.
+
+// TODO(rsc): Delete this file once Go 1.17 comes out and we can retire Go 1.15 support.
+
+//go:build !go1.16
+// +build !go1.16
+
+// Package buildtag defines an Analyzer that checks build tags.
+package buildtag
-- 
GitLab


From 0625460f79eed41039939f957baceaff5e269672 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 19 Feb 2021 09:01:32 -0500
Subject: [PATCH 0746/2400] cmd/vet: update buildtag check for //go:build lines

Brings in golang.org/x/tools@2363391a
and adjusts, adds cmd/vet tests accordingly.

Part of //go:build change (#41184).
See https://golang.org/design/draft-gobuild

This brings in the new //go:build checks in cmd/vet.

Change-Id: I8a9735cc014171691012b307ec30e94c81aadfe1
Reviewed-on: https://go-review.googlesource.com/c/go/+/240609
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go.mod                                |   2 +-
 src/cmd/go.sum                                |   6 +-
 .../go/analysis/passes/buildtag/buildtag.go   | 318 ++++++++++++++----
 .../analysis/passes/buildtag/buildtag_old.go  | 174 ++++++++++
 .../passes/loopclosure/loopclosure.go         |  67 +++-
 .../go/analysis/unitchecker/unitchecker.go    |   2 +-
 .../go/analysis/unitchecker/unitchecker112.go |   1 +
 src/cmd/vendor/modules.txt                    |   2 +-
 src/cmd/vet/testdata/asm/asm1.s               |   1 +
 src/cmd/vet/testdata/buildtag/buildtag.go     |   6 +-
 src/cmd/vet/testdata/buildtag/buildtag2.go    |  22 ++
 src/cmd/vet/testdata/buildtag/buildtag3.go    |  15 +
 src/cmd/vet/testdata/buildtag/buildtag4.go    |  11 +
 src/cmd/vet/testdata/buildtag/buildtag5.go    |  11 +
 src/cmd/vet/testdata/buildtag/buildtag6.s     |   9 +
 src/cmd/vet/testdata/buildtag/buildtag7.s     |  11 +
 src/cmd/vet/testdata/tagtest/file1.go         |   1 +
 src/cmd/vet/testdata/tagtest/file2.go         |   1 +
 src/cmd/vet/vet_test.go                       |   9 +-
 19 files changed, 582 insertions(+), 87 deletions(-)
 create mode 100644 src/cmd/vendor/golang.org/x/tools/go/analysis/passes/buildtag/buildtag_old.go
 create mode 100644 src/cmd/vet/testdata/buildtag/buildtag2.go
 create mode 100644 src/cmd/vet/testdata/buildtag/buildtag3.go
 create mode 100644 src/cmd/vet/testdata/buildtag/buildtag4.go
 create mode 100644 src/cmd/vet/testdata/buildtag/buildtag5.go
 create mode 100644 src/cmd/vet/testdata/buildtag/buildtag6.s
 create mode 100644 src/cmd/vet/testdata/buildtag/buildtag7.s

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index 5414e5e688..24ad6c2432 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -8,5 +8,5 @@ require (
 	golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897
 	golang.org/x/mod v0.4.1
 	golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e // indirect
-	golang.org/x/tools v0.0.0-20210107193943-4ed967dd8eff
+	golang.org/x/tools v0.1.1-0.20210220032852-2363391a5b2f
 )
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 3dc0565f65..e9b62f46e1 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -13,7 +13,6 @@ golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897 h1:pLI5jrR7OSLijeIDcmRxNmw2api+jEfxLoykJVice/E=
 golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.1 h1:Kvvh58BN8Y9/lBi7hTekvtMpm07eUZ0ck5pRHpsMWrY=
 golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
@@ -25,14 +24,15 @@ golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5h
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e h1:f5mksnk+hgXHnImpZoWj64ja99j9zV7YUgrVG95uFE4=
 golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20210107193943-4ed967dd8eff h1:6EkB024TP1fu6cmQqeCNw685zYDVt5g8N1BXh755SQM=
-golang.org/x/tools v0.0.0-20210107193943-4ed967dd8eff/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.1.1-0.20210220032852-2363391a5b2f h1:R8L2zr6nSvQoIIw/EiaPP6HfmxeiArf+Nh/CWTC60wQ=
+golang.org/x/tools v0.1.1-0.20210220032852-2363391a5b2f/go.mod h1:9bzcO0MWcOuT0tm1iBGzDVPshzfwoVvREIui8C+MHqU=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/buildtag/buildtag.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/buildtag/buildtag.go
index 841b928578..c4407ad91f 100644
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/buildtag/buildtag.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/buildtag/buildtag.go
@@ -2,14 +2,17 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.16
+// +build go1.16
+
 // Package buildtag defines an Analyzer that checks build tags.
 package buildtag
 
 import (
-	"bytes"
-	"fmt"
 	"go/ast"
+	"go/build/constraint"
 	"go/parser"
+	"go/token"
 	"strings"
 	"unicode"
 
@@ -52,118 +55,313 @@ func runBuildTag(pass *analysis.Pass) (interface{}, error) {
 }
 
 func checkGoFile(pass *analysis.Pass, f *ast.File) {
-	pastCutoff := false
+	var check checker
+	check.init(pass)
+	defer check.finish()
+
 	for _, group := range f.Comments {
 		// A +build comment is ignored after or adjoining the package declaration.
 		if group.End()+1 >= f.Package {
-			pastCutoff = true
+			check.plusBuildOK = false
 		}
-
-		// "+build" is ignored within or after a /*...*/ comment.
-		if !strings.HasPrefix(group.List[0].Text, "//") {
-			pastCutoff = true
-			continue
+		// A //go:build comment is ignored after the package declaration
+		// (but adjoining it is OK, in contrast to +build comments).
+		if group.Pos() >= f.Package {
+			check.goBuildOK = false
 		}
 
 		// Check each line of a //-comment.
 		for _, c := range group.List {
-			if !strings.Contains(c.Text, "+build") {
-				continue
-			}
-			if err := checkLine(c.Text, pastCutoff); err != nil {
-				pass.Reportf(c.Pos(), "%s", err)
+			// "+build" is ignored within or after a /*...*/ comment.
+			if !strings.HasPrefix(c.Text, "//") {
+				check.plusBuildOK = false
 			}
+			check.comment(c.Slash, c.Text)
 		}
 	}
 }
 
 func checkOtherFile(pass *analysis.Pass, filename string) error {
+	var check checker
+	check.init(pass)
+	defer check.finish()
+
+	// We cannot use the Go parser, since this may not be a Go source file.
+	// Read the raw bytes instead.
 	content, tf, err := analysisutil.ReadFile(pass.Fset, filename)
 	if err != nil {
 		return err
 	}
 
-	// We must look at the raw lines, as build tags may appear in non-Go
-	// files such as assembly files.
-	lines := bytes.SplitAfter(content, nl)
+	check.file(token.Pos(tf.Base()), string(content))
+	return nil
+}
+
+type checker struct {
+	pass         *analysis.Pass
+	plusBuildOK  bool            // "+build" lines still OK
+	goBuildOK    bool            // "go:build" lines still OK
+	crossCheck   bool            // cross-check go:build and +build lines when done reading file
+	inStar       bool            // currently in a /* */ comment
+	goBuildPos   token.Pos       // position of first go:build line found
+	plusBuildPos token.Pos       // position of first "+build" line found
+	goBuild      constraint.Expr // go:build constraint found
+	plusBuild    constraint.Expr // AND of +build constraints found
+}
+
+func (check *checker) init(pass *analysis.Pass) {
+	check.pass = pass
+	check.goBuildOK = true
+	check.plusBuildOK = true
+	check.crossCheck = true
+}
 
+func (check *checker) file(pos token.Pos, text string) {
 	// Determine cutpoint where +build comments are no longer valid.
 	// They are valid in leading // comments in the file followed by
 	// a blank line.
 	//
 	// This must be done as a separate pass because of the
 	// requirement that the comment be followed by a blank line.
-	var cutoff int
-	for i, line := range lines {
-		line = bytes.TrimSpace(line)
-		if !bytes.HasPrefix(line, slashSlash) {
-			if len(line) > 0 {
-				break
-			}
-			cutoff = i
+	var plusBuildCutoff int
+	fullText := text
+	for text != "" {
+		i := strings.Index(text, "\n")
+		if i < 0 {
+			i = len(text)
+		} else {
+			i++
+		}
+		offset := len(fullText) - len(text)
+		line := text[:i]
+		text = text[i:]
+		line = strings.TrimSpace(line)
+		if !strings.HasPrefix(line, "//") && line != "" {
+			break
+		}
+		if line == "" {
+			plusBuildCutoff = offset
 		}
 	}
 
-	for i, line := range lines {
-		line = bytes.TrimSpace(line)
-		if !bytes.HasPrefix(line, slashSlash) {
-			continue
+	// Process each line.
+	// Must stop once we hit goBuildOK == false
+	text = fullText
+	check.inStar = false
+	for text != "" {
+		i := strings.Index(text, "\n")
+		if i < 0 {
+			i = len(text)
+		} else {
+			i++
 		}
-		if !bytes.Contains(line, []byte("+build")) {
+		offset := len(fullText) - len(text)
+		line := text[:i]
+		text = text[i:]
+		check.plusBuildOK = offset < plusBuildCutoff
+
+		if strings.HasPrefix(line, "//") {
+			check.comment(pos+token.Pos(offset), line)
 			continue
 		}
-		if err := checkLine(string(line), i >= cutoff); err != nil {
-			pass.Reportf(analysisutil.LineStart(tf, i+1), "%s", err)
-			continue
+
+		// Keep looking for the point at which //go:build comments
+		// stop being allowed. Skip over, cut out any /* */ comments.
+		for {
+			line = strings.TrimSpace(line)
+			if check.inStar {
+				i := strings.Index(line, "*/")
+				if i < 0 {
+					line = ""
+					break
+				}
+				line = line[i+len("*/"):]
+				check.inStar = false
+				continue
+			}
+			if strings.HasPrefix(line, "/*") {
+				check.inStar = true
+				line = line[len("/*"):]
+				continue
+			}
+			break
+		}
+		if line != "" {
+			// Found non-comment non-blank line.
+			// Ends space for valid //go:build comments,
+			// but also ends the fraction of the file we can
+			// reliably parse. From this point on we might
+			// incorrectly flag "comments" inside multiline
+			// string constants or anything else (this might
+			// not even be a Go program). So stop.
+			break
 		}
 	}
-	return nil
 }
 
-// checkLine checks a line that starts with "//" and contains "+build".
-func checkLine(line string, pastCutoff bool) error {
-	line = strings.TrimPrefix(line, "//")
-	line = strings.TrimSpace(line)
-
-	if strings.HasPrefix(line, "+build") {
-		fields := strings.Fields(line)
-		if fields[0] != "+build" {
-			// Comment is something like +buildasdf not +build.
-			return fmt.Errorf("possible malformed +build comment")
+func (check *checker) comment(pos token.Pos, text string) {
+	if strings.HasPrefix(text, "//") {
+		if strings.Contains(text, "+build") {
+			check.plusBuildLine(pos, text)
 		}
-		if pastCutoff {
-			return fmt.Errorf("+build comment must appear before package clause and be followed by a blank line")
+		if strings.Contains(text, "//go:build") {
+			check.goBuildLine(pos, text)
 		}
-		if err := checkArguments(fields); err != nil {
-			return err
+	}
+	if strings.HasPrefix(text, "/*") {
+		if i := strings.Index(text, "\n"); i >= 0 {
+			// multiline /* */ comment - process interior lines
+			check.inStar = true
+			i++
+			pos += token.Pos(i)
+			text = text[i:]
+			for text != "" {
+				i := strings.Index(text, "\n")
+				if i < 0 {
+					i = len(text)
+				} else {
+					i++
+				}
+				line := text[:i]
+				if strings.HasPrefix(line, "//") {
+					check.comment(pos, line)
+				}
+				pos += token.Pos(i)
+				text = text[i:]
+			}
+			check.inStar = false
+		}
+	}
+}
+
+func (check *checker) goBuildLine(pos token.Pos, line string) {
+	if !constraint.IsGoBuild(line) {
+		if !strings.HasPrefix(line, "//go:build") && constraint.IsGoBuild("//"+strings.TrimSpace(line[len("//"):])) {
+			check.pass.Reportf(pos, "malformed //go:build line (space between // and go:build)")
 		}
+		return
+	}
+	if !check.goBuildOK || check.inStar {
+		check.pass.Reportf(pos, "misplaced //go:build comment")
+		check.crossCheck = false
+		return
+	}
+
+	if check.goBuildPos == token.NoPos {
+		check.goBuildPos = pos
 	} else {
+		check.pass.Reportf(pos, "unexpected extra //go:build line")
+		check.crossCheck = false
+	}
+
+	// testing hack: stop at // ERROR
+	if i := strings.Index(line, " // ERROR "); i >= 0 {
+		line = line[:i]
+	}
+
+	x, err := constraint.Parse(line)
+	if err != nil {
+		check.pass.Reportf(pos, "%v", err)
+		check.crossCheck = false
+		return
+	}
+
+	if check.goBuild == nil {
+		check.goBuild = x
+	}
+}
+
+func (check *checker) plusBuildLine(pos token.Pos, line string) {
+	line = strings.TrimSpace(line)
+	if !constraint.IsPlusBuild(line) {
 		// Comment with +build but not at beginning.
-		if !pastCutoff {
-			return fmt.Errorf("possible malformed +build comment")
+		// Only report early in file.
+		if check.plusBuildOK && !strings.HasPrefix(line, "// want") {
+			check.pass.Reportf(pos, "possible malformed +build comment")
 		}
+		return
+	}
+	if !check.plusBuildOK { // inStar implies !plusBuildOK
+		check.pass.Reportf(pos, "misplaced +build comment")
+		check.crossCheck = false
 	}
-	return nil
-}
 
-func checkArguments(fields []string) error {
+	if check.plusBuildPos == token.NoPos {
+		check.plusBuildPos = pos
+	}
+
+	// testing hack: stop at // ERROR
+	if i := strings.Index(line, " // ERROR "); i >= 0 {
+		line = line[:i]
+	}
+
+	fields := strings.Fields(line[len("//"):])
+	// IsPlusBuildConstraint check above implies fields[0] == "+build"
 	for _, arg := range fields[1:] {
 		for _, elem := range strings.Split(arg, ",") {
 			if strings.HasPrefix(elem, "!!") {
-				return fmt.Errorf("invalid double negative in build constraint: %s", arg)
+				check.pass.Reportf(pos, "invalid double negative in build constraint: %s", arg)
+				check.crossCheck = false
+				continue
 			}
 			elem = strings.TrimPrefix(elem, "!")
 			for _, c := range elem {
 				if !unicode.IsLetter(c) && !unicode.IsDigit(c) && c != '_' && c != '.' {
-					return fmt.Errorf("invalid non-alphanumeric build constraint: %s", arg)
+					check.pass.Reportf(pos, "invalid non-alphanumeric build constraint: %s", arg)
+					check.crossCheck = false
+					break
 				}
 			}
 		}
 	}
-	return nil
+
+	if check.crossCheck {
+		y, err := constraint.Parse(line)
+		if err != nil {
+			// Should never happen - constraint.Parse never rejects a // +build line.
+			// Also, we just checked the syntax above.
+			// Even so, report.
+			check.pass.Reportf(pos, "%v", err)
+			check.crossCheck = false
+			return
+		}
+		if check.plusBuild == nil {
+			check.plusBuild = y
+		} else {
+			check.plusBuild = &constraint.AndExpr{X: check.plusBuild, Y: y}
+		}
+	}
 }
 
-var (
-	nl         = []byte("\n")
-	slashSlash = []byte("//")
-)
+func (check *checker) finish() {
+	if !check.crossCheck || check.plusBuildPos == token.NoPos || check.goBuildPos == token.NoPos {
+		return
+	}
+
+	// Have both //go:build and // +build,
+	// with no errors found (crossCheck still true).
+	// Check they match.
+	var want constraint.Expr
+	lines, err := constraint.PlusBuildLines(check.goBuild)
+	if err != nil {
+		check.pass.Reportf(check.goBuildPos, "%v", err)
+		return
+	}
+	for _, line := range lines {
+		y, err := constraint.Parse(line)
+		if err != nil {
+			// Definitely should not happen, but not the user's fault.
+			// Do not report.
+			return
+		}
+		if want == nil {
+			want = y
+		} else {
+			want = &constraint.AndExpr{X: want, Y: y}
+		}
+	}
+	if want.String() != check.plusBuild.String() {
+		check.pass.Reportf(check.plusBuildPos, "+build lines do not match //go:build condition")
+		return
+	}
+}
diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/buildtag/buildtag_old.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/buildtag/buildtag_old.go
new file mode 100644
index 0000000000..e9234925f9
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/buildtag/buildtag_old.go
@@ -0,0 +1,174 @@
+// Copyright 2013 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.
+
+// TODO(rsc): Delete this file once Go 1.17 comes out and we can retire Go 1.15 support.
+
+//go:build !go1.16
+// +build !go1.16
+
+// Package buildtag defines an Analyzer that checks build tags.
+package buildtag
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"strings"
+	"unicode"
+
+	"golang.org/x/tools/go/analysis"
+	"golang.org/x/tools/go/analysis/passes/internal/analysisutil"
+)
+
+const Doc = "check that +build tags are well-formed and correctly located"
+
+var Analyzer = &analysis.Analyzer{
+	Name: "buildtag",
+	Doc:  Doc,
+	Run:  runBuildTag,
+}
+
+func runBuildTag(pass *analysis.Pass) (interface{}, error) {
+	for _, f := range pass.Files {
+		checkGoFile(pass, f)
+	}
+	for _, name := range pass.OtherFiles {
+		if err := checkOtherFile(pass, name); err != nil {
+			return nil, err
+		}
+	}
+	for _, name := range pass.IgnoredFiles {
+		if strings.HasSuffix(name, ".go") {
+			f, err := parser.ParseFile(pass.Fset, name, nil, parser.ParseComments)
+			if err != nil {
+				// Not valid Go source code - not our job to diagnose, so ignore.
+				return nil, nil
+			}
+			checkGoFile(pass, f)
+		} else {
+			if err := checkOtherFile(pass, name); err != nil {
+				return nil, err
+			}
+		}
+	}
+	return nil, nil
+}
+
+func checkGoFile(pass *analysis.Pass, f *ast.File) {
+	pastCutoff := false
+	for _, group := range f.Comments {
+		// A +build comment is ignored after or adjoining the package declaration.
+		if group.End()+1 >= f.Package {
+			pastCutoff = true
+		}
+
+		// "+build" is ignored within or after a /*...*/ comment.
+		if !strings.HasPrefix(group.List[0].Text, "//") {
+			pastCutoff = true
+			continue
+		}
+
+		// Check each line of a //-comment.
+		for _, c := range group.List {
+			if !strings.Contains(c.Text, "+build") {
+				continue
+			}
+			if err := checkLine(c.Text, pastCutoff); err != nil {
+				pass.Reportf(c.Pos(), "%s", err)
+			}
+		}
+	}
+}
+
+func checkOtherFile(pass *analysis.Pass, filename string) error {
+	content, tf, err := analysisutil.ReadFile(pass.Fset, filename)
+	if err != nil {
+		return err
+	}
+
+	// We must look at the raw lines, as build tags may appear in non-Go
+	// files such as assembly files.
+	lines := bytes.SplitAfter(content, nl)
+
+	// Determine cutpoint where +build comments are no longer valid.
+	// They are valid in leading // comments in the file followed by
+	// a blank line.
+	//
+	// This must be done as a separate pass because of the
+	// requirement that the comment be followed by a blank line.
+	var cutoff int
+	for i, line := range lines {
+		line = bytes.TrimSpace(line)
+		if !bytes.HasPrefix(line, slashSlash) {
+			if len(line) > 0 {
+				break
+			}
+			cutoff = i
+		}
+	}
+
+	for i, line := range lines {
+		line = bytes.TrimSpace(line)
+		if !bytes.HasPrefix(line, slashSlash) {
+			continue
+		}
+		if !bytes.Contains(line, []byte("+build")) {
+			continue
+		}
+		if err := checkLine(string(line), i >= cutoff); err != nil {
+			pass.Reportf(analysisutil.LineStart(tf, i+1), "%s", err)
+			continue
+		}
+	}
+	return nil
+}
+
+// checkLine checks a line that starts with "//" and contains "+build".
+func checkLine(line string, pastCutoff bool) error {
+	line = strings.TrimPrefix(line, "//")
+	line = strings.TrimSpace(line)
+
+	if strings.HasPrefix(line, "+build") {
+		fields := strings.Fields(line)
+		if fields[0] != "+build" {
+			// Comment is something like +buildasdf not +build.
+			return fmt.Errorf("possible malformed +build comment")
+		}
+		if pastCutoff {
+			return fmt.Errorf("+build comment must appear before package clause and be followed by a blank line")
+		}
+		if err := checkArguments(fields); err != nil {
+			return err
+		}
+	} else {
+		// Comment with +build but not at beginning.
+		if !pastCutoff {
+			return fmt.Errorf("possible malformed +build comment")
+		}
+	}
+	return nil
+}
+
+func checkArguments(fields []string) error {
+	for _, arg := range fields[1:] {
+		for _, elem := range strings.Split(arg, ",") {
+			if strings.HasPrefix(elem, "!!") {
+				return fmt.Errorf("invalid double negative in build constraint: %s", arg)
+			}
+			elem = strings.TrimPrefix(elem, "!")
+			for _, c := range elem {
+				if !unicode.IsLetter(c) && !unicode.IsDigit(c) && c != '_' && c != '.' {
+					return fmt.Errorf("invalid non-alphanumeric build constraint: %s", arg)
+				}
+			}
+		}
+	}
+	return nil
+}
+
+var (
+	nl         = []byte("\n")
+	slashSlash = []byte("//")
+)
diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/loopclosure/loopclosure.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/loopclosure/loopclosure.go
index a14e7eb55d..3ea91574dc 100644
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/loopclosure/loopclosure.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/loopclosure/loopclosure.go
@@ -8,22 +8,14 @@ package loopclosure
 
 import (
 	"go/ast"
+	"go/types"
 
 	"golang.org/x/tools/go/analysis"
 	"golang.org/x/tools/go/analysis/passes/inspect"
 	"golang.org/x/tools/go/ast/inspector"
+	"golang.org/x/tools/go/types/typeutil"
 )
 
-// TODO(adonovan): also report an error for the following structure,
-// which is often used to ensure that deferred calls do not accumulate
-// in a loop:
-//
-//	for i, x := range c {
-//		func() {
-//			...reference to i or x...
-//		}()
-//	}
-
 const Doc = `check references to loop variables from within nested functions
 
 This analyzer checks for references to loop variables from within a
@@ -95,16 +87,19 @@ func run(pass *analysis.Pass) (interface{}, error) {
 		if len(body.List) == 0 {
 			return
 		}
-		var last *ast.CallExpr
+		// The function invoked in the last return statement.
+		var fun ast.Expr
 		switch s := body.List[len(body.List)-1].(type) {
 		case *ast.GoStmt:
-			last = s.Call
+			fun = s.Call.Fun
 		case *ast.DeferStmt:
-			last = s.Call
-		default:
-			return
+			fun = s.Call.Fun
+		case *ast.ExprStmt: // check for errgroup.Group.Go()
+			if call, ok := s.X.(*ast.CallExpr); ok {
+				fun = goInvokes(pass.TypesInfo, call)
+			}
 		}
-		lit, ok := last.Fun.(*ast.FuncLit)
+		lit, ok := fun.(*ast.FuncLit)
 		if !ok {
 			return
 		}
@@ -128,3 +123,43 @@ func run(pass *analysis.Pass) (interface{}, error) {
 	})
 	return nil, nil
 }
+
+// goInvokes returns a function expression that would be called asynchronously
+// (but not awaited) in another goroutine as a consequence of the call.
+// For example, given the g.Go call below, it returns the function literal expression.
+//
+//   import "sync/errgroup"
+//   var g errgroup.Group
+//   g.Go(func() error { ... })
+//
+// Currently only "golang.org/x/sync/errgroup.Group()" is considered.
+func goInvokes(info *types.Info, call *ast.CallExpr) ast.Expr {
+	f := typeutil.StaticCallee(info, call)
+	// Note: Currently only supports: golang.org/x/sync/errgroup.Go.
+	if f == nil || f.Name() != "Go" {
+		return nil
+	}
+	recv := f.Type().(*types.Signature).Recv()
+	if recv == nil {
+		return nil
+	}
+	rtype, ok := recv.Type().(*types.Pointer)
+	if !ok {
+		return nil
+	}
+	named, ok := rtype.Elem().(*types.Named)
+	if !ok {
+		return nil
+	}
+	if named.Obj().Name() != "Group" {
+		return nil
+	}
+	pkg := f.Pkg()
+	if pkg == nil {
+		return nil
+	}
+	if pkg.Path() != "golang.org/x/sync/errgroup" {
+		return nil
+	}
+	return call.Args[0]
+}
diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/unitchecker/unitchecker.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/unitchecker/unitchecker.go
index 713e1380ef..5424489f8b 100644
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/unitchecker/unitchecker.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/unitchecker/unitchecker.go
@@ -97,7 +97,7 @@ func Main(analyzers ...*analysis.Analyzer) {
 
 Usage of %[1]s:
 	%.16[1]s unit.cfg	# execute analysis specified by config file
-	%.16[1]s help    	# general help
+	%.16[1]s help    	# general help, including listing analyzers and flags
 	%.16[1]s help name	# help on specific analyzer and its flags
 `, progname)
 		os.Exit(1)
diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/unitchecker/unitchecker112.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/unitchecker/unitchecker112.go
index 9051456e39..3180f4abe1 100644
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/unitchecker/unitchecker112.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/unitchecker/unitchecker112.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.12
 // +build go1.12
 
 package unitchecker
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 616fb6c1e6..abe70ae87e 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -44,7 +44,7 @@ golang.org/x/mod/zip
 golang.org/x/sys/internal/unsafeheader
 golang.org/x/sys/unix
 golang.org/x/sys/windows
-# golang.org/x/tools v0.0.0-20210107193943-4ed967dd8eff
+# golang.org/x/tools v0.1.1-0.20210220032852-2363391a5b2f
 ## explicit
 golang.org/x/tools/go/analysis
 golang.org/x/tools/go/analysis/internal/analysisflags
diff --git a/src/cmd/vet/testdata/asm/asm1.s b/src/cmd/vet/testdata/asm/asm1.s
index a5bb6dd0af..050c498d12 100644
--- a/src/cmd/vet/testdata/asm/asm1.s
+++ b/src/cmd/vet/testdata/asm/asm1.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build amd64
 // +build amd64
 
 TEXT ·arg1(SB),0,$0-2
diff --git a/src/cmd/vet/testdata/buildtag/buildtag.go b/src/cmd/vet/testdata/buildtag/buildtag.go
index c2fd6aaaf2..7371e6ef6f 100644
--- a/src/cmd/vet/testdata/buildtag/buildtag.go
+++ b/src/cmd/vet/testdata/buildtag/buildtag.go
@@ -4,12 +4,14 @@
 
 // This file contains tests for the buildtag checker.
 
-// +builder // ERROR "possible malformed \+build comment"
+// ERRORNEXT "possible malformed [+]build comment"
+// +builder
 // +build !ignore
 
 package testdata
 
-// +build toolate // ERROR "build comment must appear before package clause and be followed by a blank line$"
+// ERRORNEXT "misplaced \+build comment"
+// +build toolate
 
 var _ = 3
 
diff --git a/src/cmd/vet/testdata/buildtag/buildtag2.go b/src/cmd/vet/testdata/buildtag/buildtag2.go
new file mode 100644
index 0000000000..d8808dd6a2
--- /dev/null
+++ b/src/cmd/vet/testdata/buildtag/buildtag2.go
@@ -0,0 +1,22 @@
+// Copyright 2013 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.
+
+// This file contains tests for the buildtag checker.
+
+// ERRORNEXT "possible malformed [+]build comment"
+// +builder
+// +build !ignore
+
+package testdata
+
+// ERRORNEXT "misplaced \+build comment"
+// +build toolate
+// ERRORNEXT "misplaced //go:build comment"
+//go:build toolate
+
+var _ = 3
+
+var _ = `
+// +build notacomment
+`
diff --git a/src/cmd/vet/testdata/buildtag/buildtag3.go b/src/cmd/vet/testdata/buildtag/buildtag3.go
new file mode 100644
index 0000000000..241a7dbaac
--- /dev/null
+++ b/src/cmd/vet/testdata/buildtag/buildtag3.go
@@ -0,0 +1,15 @@
+// Copyright 2020 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.
+
+// This file contains tests for the buildtag checker.
+
+//go:build good
+// ERRORNEXT "[+]build lines do not match //go:build condition"
+// +build bad
+
+package testdata
+
+var _ = `
+// +build notacomment
+`
diff --git a/src/cmd/vet/testdata/buildtag/buildtag4.go b/src/cmd/vet/testdata/buildtag/buildtag4.go
new file mode 100644
index 0000000000..5b40d6951b
--- /dev/null
+++ b/src/cmd/vet/testdata/buildtag/buildtag4.go
@@ -0,0 +1,11 @@
+// Copyright 2020 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.
+
+// This file contains tests for the buildtag checker.
+
+//go:build !(bad || worse)
+// +build !bad
+// +build !worse
+
+package testdata
diff --git a/src/cmd/vet/testdata/buildtag/buildtag5.go b/src/cmd/vet/testdata/buildtag/buildtag5.go
new file mode 100644
index 0000000000..12aeb82b9b
--- /dev/null
+++ b/src/cmd/vet/testdata/buildtag/buildtag5.go
@@ -0,0 +1,11 @@
+// Copyright 2020 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.
+
+// This file contains tests for the buildtag checker.
+
+//go:build !(bad || worse)
+
+package testdata
+
+// +build other // ERROR "misplaced \+build comment"
diff --git a/src/cmd/vet/testdata/buildtag/buildtag6.s b/src/cmd/vet/testdata/buildtag/buildtag6.s
new file mode 100644
index 0000000000..40fe14c5d6
--- /dev/null
+++ b/src/cmd/vet/testdata/buildtag/buildtag6.s
@@ -0,0 +1,9 @@
+// Copyright 2020 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.
+
+#include "go_asm.h"
+
+// ok because we cannot parse assembly files.
+// +build no
+
diff --git a/src/cmd/vet/testdata/buildtag/buildtag7.s b/src/cmd/vet/testdata/buildtag/buildtag7.s
new file mode 100644
index 0000000000..b622d48f1b
--- /dev/null
+++ b/src/cmd/vet/testdata/buildtag/buildtag7.s
@@ -0,0 +1,11 @@
+// Copyright 2020 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.
+
+// +build ignore
+
+#include "go_asm.h"
+
+// ok because we cannot parse assembly files
+// the assembler would complain if we did assemble this file.
+//go:build no
diff --git a/src/cmd/vet/testdata/tagtest/file1.go b/src/cmd/vet/testdata/tagtest/file1.go
index 47fe3c80af..2204524821 100644
--- a/src/cmd/vet/testdata/tagtest/file1.go
+++ b/src/cmd/vet/testdata/tagtest/file1.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build testtag
 // +build testtag
 
 package main
diff --git a/src/cmd/vet/testdata/tagtest/file2.go b/src/cmd/vet/testdata/tagtest/file2.go
index 1f45efcbf2..979b0d451d 100644
--- a/src/cmd/vet/testdata/tagtest/file2.go
+++ b/src/cmd/vet/testdata/tagtest/file2.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !testtag
 // +build !testtag
 
 package main
diff --git a/src/cmd/vet/vet_test.go b/src/cmd/vet/vet_test.go
index d15d1ce377..50dd0735fa 100644
--- a/src/cmd/vet/vet_test.go
+++ b/src/cmd/vet/vet_test.go
@@ -334,8 +334,8 @@ type wantedError struct {
 }
 
 var (
-	errRx       = regexp.MustCompile(`// (?:GC_)?ERROR (.*)`)
-	errAutoRx   = regexp.MustCompile(`// (?:GC_)?ERRORAUTO (.*)`)
+	errRx       = regexp.MustCompile(`// (?:GC_)?ERROR(NEXT)? (.*)`)
+	errAutoRx   = regexp.MustCompile(`// (?:GC_)?ERRORAUTO(NEXT)? (.*)`)
 	errQuotesRx = regexp.MustCompile(`"([^"]*)"`)
 	lineRx      = regexp.MustCompile(`LINE(([+-])([0-9]+))?`)
 )
@@ -364,7 +364,10 @@ func wantedErrors(file, short string) (errs []wantedError) {
 		if m == nil {
 			continue
 		}
-		all := m[1]
+		if m[1] == "NEXT" {
+			lineNum++
+		}
+		all := m[2]
 		mm := errQuotesRx.FindAllStringSubmatch(all, -1)
 		if mm == nil {
 			log.Fatalf("%s:%d: invalid errchk line: %s", file, lineNum, line)
-- 
GitLab


From d4b26382342c98a95b85140b2863bc30c48edd68 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 19 Feb 2021 18:35:10 -0500
Subject: [PATCH 0747/2400] all: go fmt std cmd (but revert vendor)

Make all our package sources use Go 1.17 gofmt format
(adding //go:build lines).

Part of //go:build change (#41184).
See https://golang.org/design/draft-gobuild

Change-Id: Ia0534360e4957e58cd9a18429c39d0e32a6addb4
Reviewed-on: https://go-review.googlesource.com/c/go/+/294430
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/archive/tar/stat_actime1.go               |  1 +
 src/archive/tar/stat_actime2.go               |  1 +
 src/archive/tar/stat_unix.go                  |  1 +
 src/bytes/boundary_test.go                    |  1 +
 src/cmd/api/run.go                            |  1 +
 src/cmd/compile/internal/gc/bootstrap.go      |  1 +
 src/cmd/compile/internal/gc/pprof.go          |  1 +
 src/cmd/compile/internal/gc/trace.go          |  1 +
 src/cmd/compile/internal/ir/mknode.go         |  1 +
 src/cmd/compile/internal/logopt/escape.go     |  1 +
 .../internal/logopt/escape_bootstrap.go       |  1 +
 src/cmd/compile/internal/ssa/flags_test.go    |  1 +
 .../internal/typecheck/mapfile_mmap.go        |  1 +
 .../internal/typecheck/mapfile_read.go        |  1 +
 .../compile/internal/typecheck/mkbuiltin.go   |  1 +
 .../compile/internal/types2/example_test.go   |  1 +
 src/cmd/dist/sys_default.go                   |  1 +
 src/cmd/dist/test_linux.go                    |  1 +
 src/cmd/dist/util_gc.go                       |  1 +
 src/cmd/dist/util_gccgo.go                    |  1 +
 src/cmd/go/go11.go                            |  1 +
 src/cmd/go/go_unix_test.go                    |  1 +
 src/cmd/go/internal/base/signal_notunix.go    |  1 +
 src/cmd/go/internal/base/signal_unix.go       |  1 +
 .../internal/filelock/filelock_fcntl.go       |  1 +
 .../internal/filelock/filelock_other.go       |  1 +
 .../internal/filelock/filelock_plan9.go       |  1 +
 .../internal/filelock/filelock_test.go        |  1 +
 .../internal/filelock/filelock_unix.go        |  1 +
 .../internal/filelock/filelock_windows.go     |  1 +
 .../lockedfile/lockedfile_filelock.go         |  1 +
 .../internal/lockedfile/lockedfile_plan9.go   |  1 +
 .../go/internal/lockedfile/lockedfile_test.go |  1 +
 .../go/internal/lockedfile/transform_test.go  |  1 +
 src/cmd/go/internal/modfetch/bootstrap.go     |  1 +
 .../go/internal/modfetch/codehost/shell.go    |  1 +
 src/cmd/go/internal/modfetch/sumdb.go         |  1 +
 src/cmd/go/internal/modload/stat_openfile.go  |  1 +
 src/cmd/go/internal/modload/stat_unix.go      |  1 +
 src/cmd/go/internal/modload/stat_windows.go   |  1 +
 src/cmd/go/internal/renameio/renameio_test.go |  1 +
 src/cmd/go/internal/renameio/umask_test.go    |  1 +
 .../go/internal/robustio/robustio_flaky.go    |  1 +
 .../go/internal/robustio/robustio_other.go    |  1 +
 src/cmd/go/internal/test/genflags.go          |  1 +
 src/cmd/go/internal/web/bootstrap.go          |  1 +
 src/cmd/go/internal/web/http.go               |  1 +
 src/cmd/go/internal/web/url_other.go          |  1 +
 src/cmd/go/internal/web/url_other_test.go     |  1 +
 src/cmd/go/internal/work/testgo.go            |  1 +
 src/cmd/internal/bio/buf_mmap.go              |  1 +
 src/cmd/internal/bio/buf_nommap.go            |  1 +
 src/cmd/internal/goobj/mkbuiltin.go           |  1 +
 src/cmd/internal/obj/stringer.go              |  1 +
 src/cmd/link/elf_test.go                      |  1 +
 src/cmd/link/internal/ld/elf_test.go          |  1 +
 src/cmd/link/internal/ld/execarchive.go       |  1 +
 .../link/internal/ld/execarchive_noexec.go    |  1 +
 src/cmd/link/internal/ld/fallocate_test.go    |  1 +
 src/cmd/link/internal/ld/outbuf_mmap.go       |  1 +
 .../link/internal/ld/outbuf_nofallocate.go    |  1 +
 src/cmd/link/internal/ld/outbuf_nommap.go     |  1 +
 src/cmd/link/internal/ld/outbuf_notdarwin.go  |  1 +
 src/cmd/nm/nm_cgo_test.go                     |  1 +
 src/cmd/pprof/readlineui.go                   |  1 +
 src/cmd/trace/annotations_test.go             |  1 +
 src/cmd/trace/trace_test.go                   |  1 +
 src/cmd/trace/trace_unix_test.go              |  1 +
 src/crypto/aes/aes_gcm.go                     |  1 +
 src/crypto/aes/cipher_asm.go                  |  1 +
 src/crypto/aes/cipher_generic.go              |  1 +
 src/crypto/aes/gcm_ppc64le.go                 |  1 +
 src/crypto/cipher/xor_generic.go              |  1 +
 src/crypto/cipher/xor_ppc64x.go               |  1 +
 src/crypto/ecdsa/ecdsa_noasm.go               |  1 +
 src/crypto/ecdsa/ecdsa_s390x_test.go          |  1 +
 src/crypto/elliptic/fuzz_test.go              |  1 +
 src/crypto/elliptic/p256.go                   |  1 +
 src/crypto/elliptic/p256_asm.go               |  1 +
 src/crypto/elliptic/p256_generic.go           |  1 +
 src/crypto/elliptic/p256_ppc64le.go           |  1 +
 src/crypto/elliptic/p256_s390x.go             |  1 +
 src/crypto/internal/subtle/aliasing.go        |  1 +
 .../internal/subtle/aliasing_appengine.go     |  1 +
 src/crypto/md5/gen.go                         |  1 +
 src/crypto/md5/md5block_decl.go               |  1 +
 src/crypto/md5/md5block_generic.go            |  1 +
 src/crypto/rand/eagain.go                     |  1 +
 src/crypto/rand/rand_batched.go               |  1 +
 src/crypto/rand/rand_batched_test.go          |  1 +
 src/crypto/rand/rand_js.go                    |  1 +
 src/crypto/rand/rand_unix.go                  |  1 +
 src/crypto/sha1/fallback_test.go              |  1 +
 src/crypto/sha1/issue15617_test.go            |  1 +
 src/crypto/sha1/sha1block_decl.go             |  1 +
 src/crypto/sha1/sha1block_generic.go          |  1 +
 src/crypto/sha256/fallback_test.go            |  1 +
 src/crypto/sha256/sha256block_decl.go         |  1 +
 src/crypto/sha256/sha256block_generic.go      |  1 +
 src/crypto/sha512/fallback_test.go            |  1 +
 src/crypto/sha512/sha512block_amd64.go        |  1 +
 src/crypto/sha512/sha512block_decl.go         |  1 +
 src/crypto/sha512/sha512block_generic.go      |  1 +
 src/crypto/tls/generate_cert.go               |  1 +
 src/crypto/tls/handshake_unix_test.go         |  1 +
 .../x509/internal/macos/corefoundation.go     |  1 +
 src/crypto/x509/internal/macos/security.go    |  1 +
 src/crypto/x509/root_bsd.go                   |  1 +
 src/crypto/x509/root_darwin.go                |  1 +
 src/crypto/x509/root_ios.go                   |  4 ++--
 src/crypto/x509/root_ios_gen.go               |  1 +
 src/crypto/x509/root_js.go                    |  1 +
 src/crypto/x509/root_omit.go                  |  1 +
 src/crypto/x509/root_omit_test.go             |  1 +
 src/crypto/x509/root_plan9.go                 |  1 +
 src/crypto/x509/root_unix.go                  |  1 +
 src/crypto/x509/root_unix_test.go             |  1 +
 src/crypto/x509/x509_test_import.go           |  1 +
 src/debug/pe/file_cgo_test.go                 |  1 +
 src/encoding/csv/fuzz.go                      |  1 +
 src/encoding/gob/debug.go                     |  1 +
 src/encoding/gob/decgen.go                    |  1 +
 src/encoding/gob/dump.go                      |  1 +
 src/encoding/gob/encgen.go                    |  1 +
 src/encoding/json/fuzz.go                     |  1 +
 src/go/build/gc.go                            |  1 +
 src/go/build/gccgo.go                         |  1 +
 src/go/doc/headscan.go                        |  1 +
 src/go/types/example_test.go                  |  1 +
 src/go/types/gotype.go                        |  1 +
 src/hash/crc32/crc32_otherarch.go             |  1 +
 src/hash/crc32/gen_const_ppc64le.go           |  1 +
 src/html/fuzz.go                              |  1 +
 src/image/color/palette/gen.go                |  1 +
 src/image/internal/imageutil/gen.go           |  1 +
 src/image/png/fuzz.go                         |  1 +
 src/index/suffixarray/gen.go                  |  1 +
 src/internal/abi/abi_amd64.go                 |  1 +
 src/internal/abi/abi_generic.go               |  1 +
 src/internal/bytealg/compare_generic.go       |  1 +
 src/internal/bytealg/compare_native.go        |  1 +
 src/internal/bytealg/count_generic.go         |  1 +
 src/internal/bytealg/count_native.go          |  1 +
 src/internal/bytealg/index_generic.go         |  1 +
 src/internal/bytealg/index_native.go          |  1 +
 src/internal/bytealg/indexbyte_generic.go     |  1 +
 src/internal/bytealg/indexbyte_native.go      |  1 +
 src/internal/cpu/cpu_arm64_android.go         |  1 +
 src/internal/cpu/cpu_arm64_darwin.go          |  5 ++---
 src/internal/cpu/cpu_arm64_freebsd.go         |  1 +
 src/internal/cpu/cpu_arm64_hwcap.go           |  4 ++--
 src/internal/cpu/cpu_arm64_linux.go           |  5 ++---
 src/internal/cpu/cpu_arm64_other.go           |  1 +
 src/internal/cpu/cpu_mips64x.go               |  1 +
 src/internal/cpu/cpu_no_name.go               |  4 ++--
 src/internal/cpu/cpu_ppc64x.go                |  1 +
 src/internal/cpu/cpu_ppc64x_aix.go            |  1 +
 src/internal/cpu/cpu_ppc64x_linux.go          |  1 +
 src/internal/cpu/cpu_x86.go                   |  1 +
 src/internal/cpu/cpu_x86_test.go              |  1 +
 src/internal/goroot/gc.go                     |  1 +
 src/internal/goroot/gccgo.go                  |  1 +
 src/internal/poll/errno_unix.go               |  1 +
 src/internal/poll/errno_windows.go            |  1 +
 src/internal/poll/error_stub_test.go          |  1 +
 src/internal/poll/export_posix_test.go        |  1 +
 src/internal/poll/fcntl_js.go                 |  1 +
 src/internal/poll/fcntl_libc.go               |  1 +
 src/internal/poll/fcntl_syscall.go            |  1 +
 src/internal/poll/fd_fsync_posix.go           |  1 +
 src/internal/poll/fd_poll_js.go               |  1 +
 src/internal/poll/fd_poll_runtime.go          |  1 +
 src/internal/poll/fd_posix.go                 |  1 +
 src/internal/poll/fd_posix_test.go            |  1 +
 src/internal/poll/fd_unix.go                  |  1 +
 src/internal/poll/fd_writev_darwin.go         |  1 +
 src/internal/poll/fd_writev_illumos.go        |  1 +
 src/internal/poll/fd_writev_unix.go           |  1 +
 src/internal/poll/hook_cloexec.go             |  1 +
 src/internal/poll/hook_unix.go                |  1 +
 src/internal/poll/iovec_illumos.go            |  1 +
 src/internal/poll/iovec_unix.go               |  1 +
 src/internal/poll/sendfile_bsd.go             |  1 +
 src/internal/poll/sock_cloexec.go             |  1 +
 src/internal/poll/sockopt.go                  |  1 +
 src/internal/poll/sockopt_unix.go             |  1 +
 src/internal/poll/sockoptip.go                |  1 +
 src/internal/poll/strconv.go                  |  1 +
 src/internal/poll/sys_cloexec.go              |  1 +
 src/internal/poll/writev.go                   |  1 +
 src/internal/race/norace.go                   |  1 +
 src/internal/race/race.go                     |  1 +
 .../syscall/execenv/execenv_default.go        |  1 +
 .../syscall/execenv/execenv_windows.go        |  1 +
 src/internal/syscall/unix/at.go               |  1 +
 src/internal/syscall/unix/at_libc.go          |  1 +
 .../syscall/unix/at_sysnum_fstatat64_linux.go |  1 +
 .../syscall/unix/at_sysnum_fstatat_linux.go   |  1 +
 .../unix/at_sysnum_newfstatat_linux.go        |  1 +
 .../syscall/unix/fcntl_linux_32bit.go         |  1 +
 src/internal/syscall/unix/nonblocking.go      |  1 +
 src/internal/syscall/unix/nonblocking_js.go   |  1 +
 src/internal/syscall/unix/nonblocking_libc.go |  1 +
 src/internal/syscall/unix/pipe2_illumos.go    |  1 +
 .../syscall/unix/sysnum_linux_generic.go      |  1 +
 .../syscall/unix/sysnum_linux_mips64x.go      |  1 +
 .../syscall/unix/sysnum_linux_mipsx.go        |  1 +
 .../syscall/unix/sysnum_linux_ppc64x.go       |  1 +
 src/internal/syscall/unix/writev_illumos.go   |  1 +
 src/internal/testenv/testenv_cgo.go           |  1 +
 src/internal/testenv/testenv_notwin.go        |  1 +
 src/log/syslog/example_test.go                |  1 +
 src/log/syslog/syslog.go                      |  1 +
 src/log/syslog/syslog_test.go                 |  1 +
 src/log/syslog/syslog_unix.go                 |  1 +
 src/math/big/arith_amd64.go                   |  1 +
 src/math/big/arith_decl.go                    |  1 +
 src/math/big/arith_decl_pure.go               |  1 +
 src/math/big/arith_decl_s390x.go              |  1 +
 src/math/big/arith_s390x_test.go              |  1 +
 src/math/bits/bits_errors.go                  |  1 +
 src/math/bits/bits_errors_bootstrap.go        |  1 +
 src/math/bits/make_examples.go                |  1 +
 src/math/bits/make_tables.go                  |  1 +
 src/math/cmplx/huge_test.go                   |  1 +
 src/math/exp_asm.go                           |  1 +
 src/math/huge_test.go                         |  1 +
 src/math/rand/gen_cooked.go                   |  1 +
 src/mime/type_unix.go                         |  1 +
 src/net/addrselect.go                         |  1 +
 src/net/addrselect_test.go                    |  1 +
 src/net/cgo_aix.go                            |  1 +
 src/net/cgo_android.go                        |  1 +
 src/net/cgo_bsd.go                            |  4 +++-
 src/net/cgo_linux.go                          |  1 +
 src/net/cgo_netbsd.go                         |  1 +
 src/net/cgo_openbsd.go                        |  1 +
 src/net/cgo_resnew.go                         |  4 +++-
 src/net/cgo_resold.go                         |  4 +++-
 src/net/cgo_socknew.go                        |  4 +++-
 src/net/cgo_sockold.go                        |  4 +++-
 src/net/cgo_solaris.go                        |  1 +
 src/net/cgo_stub.go                           |  1 +
 src/net/cgo_unix.go                           |  4 +++-
 src/net/cgo_unix_test.go                      |  4 +++-
 src/net/cgo_windows.go                        |  1 +
 src/net/conf.go                               |  1 +
 src/net/conf_netcgo.go                        |  1 +
 src/net/conf_test.go                          |  1 +
 src/net/conn_test.go                          |  1 +
 src/net/dial_test.go                          |  1 +
 src/net/dial_unix_test.go                     |  1 +
 src/net/dnsclient_unix.go                     |  1 +
 src/net/dnsclient_unix_test.go                |  1 +
 src/net/dnsconfig_unix.go                     |  1 +
 src/net/dnsconfig_unix_test.go                |  1 +
 src/net/dnsname_test.go                       |  1 +
 src/net/error_posix.go                        |  1 +
 src/net/error_posix_test.go                   |  1 +
 src/net/error_test.go                         |  1 +
 src/net/error_unix.go                         |  1 +
 src/net/error_unix_test.go                    |  1 +
 src/net/external_test.go                      |  1 +
 src/net/fd_posix.go                           |  1 +
 src/net/fd_unix.go                            |  1 +
 src/net/file_stub.go                          |  1 +
 src/net/file_test.go                          |  1 +
 src/net/file_unix.go                          |  1 +
 src/net/hook_unix.go                          |  1 +
 src/net/http/cgi/plan9_test.go                |  1 +
 src/net/http/cgi/posix_test.go                |  1 +
 src/net/http/h2_bundle.go                     |  1 +
 src/net/http/omithttp2.go                     |  1 +
 src/net/http/roundtrip.go                     |  1 +
 src/net/http/roundtrip_js.go                  |  1 +
 src/net/http/triv.go                          |  1 +
 src/net/interface_bsd.go                      |  1 +
 src/net/interface_bsd_test.go                 |  1 +
 src/net/interface_bsdvar.go                   |  1 +
 src/net/interface_stub.go                     |  1 +
 src/net/interface_test.go                     |  1 +
 src/net/interface_unix_test.go                |  1 +
 src/net/internal/socktest/main_test.go        |  1 +
 src/net/internal/socktest/main_unix_test.go   |  1 +
 src/net/internal/socktest/switch_posix.go     |  1 +
 src/net/internal/socktest/switch_stub.go      |  1 +
 src/net/internal/socktest/switch_unix.go      |  1 +
 src/net/internal/socktest/sys_cloexec.go      |  1 +
 src/net/internal/socktest/sys_unix.go         |  1 +
 src/net/ip_test.go                            |  1 +
 src/net/iprawsock_posix.go                    |  1 +
 src/net/iprawsock_test.go                     |  1 +
 src/net/ipsock_posix.go                       |  1 +
 src/net/listen_test.go                        |  1 +
 src/net/lookup_fake.go                        |  1 +
 src/net/lookup_test.go                        |  1 +
 src/net/lookup_unix.go                        |  1 +
 src/net/main_cloexec_test.go                  |  1 +
 src/net/main_conf_test.go                     |  1 +
 src/net/main_noconf_test.go                   |  1 +
 src/net/main_posix_test.go                    |  1 +
 src/net/main_test.go                          |  1 +
 src/net/main_unix_test.go                     |  1 +
 src/net/mockserver_test.go                    |  1 +
 src/net/net_fake.go                           |  1 +
 src/net/net_test.go                           |  1 +
 src/net/netgo_unix_test.go                    |  1 +
 src/net/nss.go                                |  1 +
 src/net/nss_test.go                           |  1 +
 src/net/packetconn_test.go                    |  1 +
 src/net/port_unix.go                          |  1 +
 src/net/protoconn_test.go                     |  1 +
 src/net/rawconn_stub_test.go                  |  1 +
 src/net/rawconn_test.go                       |  1 +
 src/net/rawconn_unix_test.go                  |  1 +
 src/net/sendfile_stub.go                      |  1 +
 src/net/sendfile_test.go                      |  1 +
 src/net/sendfile_unix_alt.go                  |  1 +
 src/net/server_test.go                        |  1 +
 src/net/sock_bsd.go                           |  1 +
 src/net/sock_cloexec.go                       |  1 +
 src/net/sock_posix.go                         |  1 +
 src/net/sock_stub.go                          |  1 +
 src/net/sockaddr_posix.go                     |  1 +
 src/net/sockopt_bsd.go                        |  1 +
 src/net/sockopt_posix.go                      |  1 +
 src/net/sockopt_stub.go                       |  1 +
 src/net/sockoptip_bsdvar.go                   |  1 +
 src/net/sockoptip_posix.go                    |  1 +
 src/net/sockoptip_stub.go                     |  1 +
 src/net/splice_stub.go                        |  1 +
 src/net/splice_test.go                        |  1 +
 src/net/sys_cloexec.go                        |  1 +
 src/net/tcpsock_posix.go                      |  1 +
 src/net/tcpsock_test.go                       |  1 +
 src/net/tcpsock_unix_test.go                  |  1 +
 src/net/tcpsockopt_posix.go                   |  1 +
 src/net/tcpsockopt_stub.go                    |  1 +
 src/net/tcpsockopt_unix.go                    |  1 +
 src/net/timeout_test.go                       |  1 +
 src/net/udpsock_posix.go                      |  1 +
 src/net/udpsock_test.go                       |  1 +
 src/net/unixsock_posix.go                     |  1 +
 src/net/unixsock_test.go                      |  1 +
 src/net/unixsock_windows_test.go              |  1 +
 src/net/write_unix_test.go                    |  1 +
 src/net/writev_test.go                        |  1 +
 src/net/writev_unix.go                        |  1 +
 src/os/dir_unix.go                            |  1 +
 src/os/endian_big.go                          |  1 +
 src/os/endian_little.go                       |  1 +
 src/os/env_unix_test.go                       |  1 +
 src/os/error_errno.go                         |  1 +
 src/os/error_posix.go                         |  1 +
 src/os/error_unix_test.go                     |  1 +
 src/os/error_windows_test.go                  |  1 +
 src/os/exec/exec_linux_test.go                |  1 +
 src/os/exec/exec_posix_test.go                |  1 +
 src/os/exec/exec_unix.go                      |  1 +
 src/os/exec/lp_js.go                          |  1 +
 src/os/exec/lp_unix.go                        |  1 +
 src/os/exec/lp_unix_test.go                   |  1 +
 src/os/exec/read3.go                          |  1 +
 src/os/exec_posix.go                          |  1 +
 src/os/exec_unix.go                           |  1 +
 src/os/exec_unix_test.go                      |  1 +
 src/os/executable_path.go                     |  1 +
 src/os/executable_plan9.go                    |  1 +
 src/os/executable_procfs.go                   |  1 +
 src/os/executable_sysctl.go                   |  1 +
 src/os/export_unix_test.go                    |  1 +
 src/os/fifo_test.go                           |  1 +
 src/os/file_posix.go                          |  1 +
 src/os/file_unix.go                           |  1 +
 src/os/os_unix_test.go                        |  1 +
 src/os/path_unix.go                           |  1 +
 src/os/pipe2_bsd.go                           |  1 +
 src/os/pipe2_illumos.go                       |  1 +
 src/os/pipe_bsd.go                            |  1 +
 src/os/pipe_test.go                           |  1 +
 src/os/rawconn.go                             |  1 +
 src/os/rawconn_test.go                        |  1 +
 src/os/readfrom_stub.go                       |  1 +
 src/os/removeall_at.go                        |  1 +
 src/os/removeall_noat.go                      |  1 +
 src/os/signal/example_unix_test.go            |  1 +
 src/os/signal/internal/pty/pty.go             |  1 +
 src/os/signal/signal_cgo_test.go              |  1 +
 src/os/signal/signal_linux_test.go            |  1 +
 src/os/signal/signal_test.go                  |  1 +
 src/os/signal/signal_unix.go                  |  1 +
 src/os/stat_js.go                             |  1 +
 src/os/stat_unix.go                           |  1 +
 src/os/sticky_bsd.go                          |  1 +
 src/os/sticky_notbsd.go                       |  1 +
 src/os/sys_bsd.go                             |  1 +
 src/os/sys_js.go                              |  1 +
 src/os/sys_unix.go                            |  1 +
 src/os/timeout_test.go                        |  5 ++---
 src/os/types_unix.go                          |  4 ++--
 src/os/user/cgo_lookup_unix.go                |  4 +++-
 src/os/user/cgo_unix_test.go                  |  4 +++-
 src/os/user/getgrouplist_darwin.go            |  1 +
 src/os/user/getgrouplist_unix.go              |  4 +++-
 src/os/user/listgroups_aix.go                 |  1 +
 src/os/user/listgroups_solaris.go             |  1 +
 src/os/user/listgroups_unix.go                |  4 +++-
 src/os/user/lookup_android.go                 |  1 +
 src/os/user/lookup_stubs.go                   |  1 +
 src/os/user/lookup_unix.go                    |  1 +
 src/os/user/lookup_unix_test.go               |  1 +
 src/os/wait_unimp.go                          |  1 +
 src/os/wait_wait6.go                          |  1 +
 src/os/wait_waitid.go                         |  1 +
 src/path/filepath/example_unix_test.go        |  1 +
 src/path/filepath/example_unix_walk_test.go   |  1 +
 src/path/filepath/path_unix.go                |  1 +
 src/path/filepath/symlink_unix.go             |  1 +
 src/plugin/plugin_dlopen.go                   |  1 +
 src/plugin/plugin_stubs.go                    |  1 +
 src/plugin/plugin_test.go                     |  1 +
 src/regexp/exec2_test.go                      |  1 +
 src/runtime/auxv_none.go                      |  8 ++------
 src/runtime/cgo/callbacks_traceback.go        |  1 +
 src/runtime/cgo/dragonfly.go                  |  1 +
 src/runtime/cgo/freebsd.go                    |  1 +
 src/runtime/cgo/linux.go                      |  1 +
 src/runtime/cgo/mmap.go                       |  1 +
 src/runtime/cgo/netbsd.go                     |  1 +
 src/runtime/cgo/openbsd.go                    |  1 +
 src/runtime/cgo/setenv.go                     |  1 +
 src/runtime/cgo/sigaction.go                  |  1 +
 src/runtime/cgo_mmap.go                       |  1 +
 src/runtime/cgo_ppc64x.go                     |  1 +
 src/runtime/cgo_sigaction.go                  |  1 +
 src/runtime/cputicks.go                       |  9 ++-------
 src/runtime/crash_cgo_test.go                 |  1 +
 src/runtime/crash_nonunix_test.go             |  1 +
 src/runtime/crash_unix_test.go                |  1 +
 src/runtime/debug/panic_test.go               |  1 +
 src/runtime/debug_test.go                     |  5 ++---
 src/runtime/debugcall.go                      |  1 +
 src/runtime/debuglog_off.go                   |  1 +
 src/runtime/debuglog_on.go                    |  1 +
 src/runtime/defs1_linux.go                    |  1 +
 src/runtime/defs2_linux.go                    |  1 +
 src/runtime/defs3_linux.go                    |  1 +
 src/runtime/defs_aix.go                       |  1 +
 src/runtime/defs_aix_ppc64.go                 |  1 +
 src/runtime/defs_arm_linux.go                 |  1 +
 src/runtime/defs_darwin.go                    |  1 +
 src/runtime/defs_dragonfly.go                 |  1 +
 src/runtime/defs_freebsd.go                   |  1 +
 src/runtime/defs_linux.go                     |  1 +
 src/runtime/defs_linux_mips64x.go             |  1 +
 src/runtime/defs_linux_mipsx.go               |  1 +
 src/runtime/defs_netbsd.go                    |  1 +
 src/runtime/defs_netbsd_386.go                |  1 +
 src/runtime/defs_netbsd_amd64.go              |  1 +
 src/runtime/defs_netbsd_arm.go                |  1 +
 src/runtime/defs_openbsd.go                   |  1 +
 src/runtime/defs_solaris.go                   |  1 +
 src/runtime/defs_solaris_amd64.go             |  1 +
 src/runtime/env_posix.go                      |  1 +
 src/runtime/export_debug_test.go              |  4 ++--
 src/runtime/export_futex_test.go              |  1 +
 src/runtime/export_mmap_test.go               |  1 +
 src/runtime/export_pipe2_test.go              |  1 +
 src/runtime/export_pipe_test.go               |  1 +
 src/runtime/export_unix_test.go               |  1 +
 src/runtime/futex_test.go                     |  1 +
 src/runtime/hash32.go                         |  1 +
 src/runtime/hash64.go                         |  1 +
 src/runtime/internal/atomic/atomic_386.go     |  1 +
 src/runtime/internal/atomic/atomic_arm.go     |  1 +
 src/runtime/internal/atomic/atomic_arm64.go   |  1 +
 src/runtime/internal/atomic/atomic_mips64x.go |  1 +
 src/runtime/internal/atomic/atomic_mipsx.go   |  1 +
 src/runtime/internal/atomic/atomic_ppc64x.go  |  1 +
 src/runtime/internal/atomic/stubs.go          |  1 +
 src/runtime/internal/sys/gengoos.go           |  1 +
 src/runtime/internal/sys/intrinsics.go        |  1 +
 src/runtime/internal/sys/intrinsics_stubs.go  |  1 +
 src/runtime/internal/sys/zgoarch_386.go       |  1 +
 src/runtime/internal/sys/zgoarch_amd64.go     |  1 +
 src/runtime/internal/sys/zgoarch_arm.go       |  1 +
 src/runtime/internal/sys/zgoarch_arm64.go     |  1 +
 src/runtime/internal/sys/zgoarch_arm64be.go   |  1 +
 src/runtime/internal/sys/zgoarch_armbe.go     |  1 +
 src/runtime/internal/sys/zgoarch_mips.go      |  1 +
 src/runtime/internal/sys/zgoarch_mips64.go    |  1 +
 src/runtime/internal/sys/zgoarch_mips64le.go  |  1 +
 src/runtime/internal/sys/zgoarch_mips64p32.go |  1 +
 .../internal/sys/zgoarch_mips64p32le.go       |  1 +
 src/runtime/internal/sys/zgoarch_mipsle.go    |  1 +
 src/runtime/internal/sys/zgoarch_ppc.go       |  1 +
 src/runtime/internal/sys/zgoarch_ppc64.go     |  1 +
 src/runtime/internal/sys/zgoarch_ppc64le.go   |  1 +
 src/runtime/internal/sys/zgoarch_riscv.go     |  1 +
 src/runtime/internal/sys/zgoarch_riscv64.go   |  1 +
 src/runtime/internal/sys/zgoarch_s390.go      |  1 +
 src/runtime/internal/sys/zgoarch_s390x.go     |  1 +
 src/runtime/internal/sys/zgoarch_sparc.go     |  1 +
 src/runtime/internal/sys/zgoarch_sparc64.go   |  1 +
 src/runtime/internal/sys/zgoarch_wasm.go      |  1 +
 src/runtime/internal/sys/zgoos_aix.go         |  1 +
 src/runtime/internal/sys/zgoos_android.go     |  1 +
 src/runtime/internal/sys/zgoos_darwin.go      |  4 ++--
 src/runtime/internal/sys/zgoos_dragonfly.go   |  1 +
 src/runtime/internal/sys/zgoos_freebsd.go     |  1 +
 src/runtime/internal/sys/zgoos_hurd.go        |  1 +
 src/runtime/internal/sys/zgoos_illumos.go     |  1 +
 src/runtime/internal/sys/zgoos_ios.go         |  1 +
 src/runtime/internal/sys/zgoos_js.go          |  1 +
 src/runtime/internal/sys/zgoos_linux.go       |  4 ++--
 src/runtime/internal/sys/zgoos_netbsd.go      |  1 +
 src/runtime/internal/sys/zgoos_openbsd.go     |  1 +
 src/runtime/internal/sys/zgoos_plan9.go       |  1 +
 src/runtime/internal/sys/zgoos_solaris.go     |  4 ++--
 src/runtime/internal/sys/zgoos_windows.go     |  1 +
 src/runtime/internal/sys/zgoos_zos.go         |  1 +
 src/runtime/lfstack_32bit.go                  |  1 +
 src/runtime/lfstack_64bit.go                  |  1 +
 src/runtime/libfuzzer.go                      |  1 +
 src/runtime/lock_futex.go                     |  1 +
 src/runtime/lock_js.go                        |  1 +
 src/runtime/lock_sema.go                      |  1 +
 src/runtime/lockrank_off.go                   |  1 +
 src/runtime/lockrank_on.go                    |  1 +
 src/runtime/mem_bsd.go                        |  1 +
 src/runtime/mem_js.go                         |  1 +
 src/runtime/mkduff.go                         |  1 +
 src/runtime/mkfastlog2table.go                |  1 +
 src/runtime/mkpreempt.go                      |  1 +
 src/runtime/mksizeclasses.go                  |  1 +
 src/runtime/mmap.go                           |  1 +
 src/runtime/mpagealloc_32bit.go               |  1 +
 src/runtime/mpagealloc_64bit.go               |  1 +
 src/runtime/msan.go                           |  1 +
 src/runtime/msan0.go                          |  1 +
 src/runtime/nbpipe_fcntl_libc_test.go         |  1 +
 src/runtime/nbpipe_fcntl_unix_test.go         |  1 +
 src/runtime/nbpipe_pipe.go                    |  1 +
 src/runtime/nbpipe_pipe2.go                   |  1 +
 src/runtime/nbpipe_test.go                    |  1 +
 src/runtime/netpoll.go                        |  1 +
 src/runtime/netpoll_epoll.go                  |  1 +
 src/runtime/netpoll_fake.go                   |  1 +
 src/runtime/netpoll_kqueue.go                 |  1 +
 src/runtime/netpoll_stub.go                   |  1 +
 src/runtime/norace_linux_test.go              |  1 +
 src/runtime/norace_test.go                    |  1 +
 src/runtime/os_aix.go                         |  1 +
 src/runtime/os_freebsd2.go                    |  1 +
 src/runtime/os_freebsd_noauxv.go              |  4 ++--
 src/runtime/os_js.go                          |  1 +
 src/runtime/os_linux_arm64.go                 |  1 +
 src/runtime/os_linux_be64.go                  |  1 +
 src/runtime/os_linux_generic.go               |  9 ++-------
 src/runtime/os_linux_mips64x.go               |  1 +
 src/runtime/os_linux_mipsx.go                 |  1 +
 src/runtime/os_linux_noauxv.go                |  4 ++--
 src/runtime/os_linux_novdso.go                |  4 ++--
 src/runtime/os_linux_ppc64x.go                |  1 +
 src/runtime/os_linux_x86.go                   |  1 +
 src/runtime/os_nonopenbsd.go                  |  1 +
 src/runtime/os_only_solaris.go                |  1 +
 src/runtime/os_openbsd_libc.go                |  1 +
 src/runtime/os_openbsd_syscall.go             |  4 ++--
 src/runtime/os_openbsd_syscall1.go            |  1 +
 src/runtime/os_openbsd_syscall2.go            |  1 +
 src/runtime/panic32.go                        |  1 +
 src/runtime/pprof/mprof_test.go               | 19 ++++++++++---------
 src/runtime/pprof/pprof_norusage.go           |  1 +
 src/runtime/pprof/pprof_rusage.go             |  1 +
 src/runtime/pprof/pprof_test.go               |  1 +
 src/runtime/preempt_nonwindows.go             |  1 +
 src/runtime/race.go                           |  1 +
 src/runtime/race/output_test.go               |  1 +
 src/runtime/race/race.go                      |  1 +
 src/runtime/race/race_linux_test.go           |  1 +
 src/runtime/race/race_test.go                 |  1 +
 src/runtime/race/race_unix_test.go            |  1 +
 src/runtime/race/race_windows_test.go         |  1 +
 src/runtime/race/sched_test.go                |  1 +
 src/runtime/race/syso_test.go                 |  1 +
 src/runtime/race/timer_test.go                |  1 +
 src/runtime/race0.go                          |  1 +
 src/runtime/relax_stub.go                     |  1 +
 src/runtime/runtime_mmap_test.go              |  1 +
 src/runtime/runtime_unix_test.go              |  1 +
 src/runtime/semasleep_test.go                 |  1 +
 src/runtime/sigaction.go                      |  1 +
 src/runtime/signal_386.go                     |  1 +
 src/runtime/signal_aix_ppc64.go               |  1 +
 src/runtime/signal_amd64.go                   |  1 +
 src/runtime/signal_arm.go                     |  1 +
 src/runtime/signal_arm64.go                   |  1 +
 src/runtime/signal_linux_mips64x.go           |  1 +
 src/runtime/signal_linux_mipsx.go             |  1 +
 src/runtime/signal_linux_ppc64x.go            |  1 +
 src/runtime/signal_mips64x.go                 |  1 +
 src/runtime/signal_mipsx.go                   |  1 +
 src/runtime/signal_ppc64x.go                  |  1 +
 src/runtime/signal_riscv64.go                 |  1 +
 src/runtime/signal_unix.go                    |  1 +
 src/runtime/signal_windows_test.go            |  1 +
 src/runtime/sigqueue.go                       |  1 +
 src/runtime/sigqueue_note.go                  |  4 ++--
 src/runtime/sigtab_linux_generic.go           |  7 ++-----
 src/runtime/sigtab_linux_mipsx.go             |  1 +
 src/runtime/stubs2.go                         |  9 ++-------
 src/runtime/stubs3.go                         |  8 ++------
 src/runtime/stubs_linux.go                    |  1 +
 src/runtime/stubs_mips64x.go                  |  1 +
 src/runtime/stubs_mipsx.go                    |  1 +
 src/runtime/stubs_nonlinux.go                 |  1 +
 src/runtime/stubs_ppc64x.go                   |  1 +
 src/runtime/sys_libc.go                       |  1 +
 src/runtime/sys_mips64x.go                    |  1 +
 src/runtime/sys_mipsx.go                      |  1 +
 src/runtime/sys_nonppc64x.go                  |  1 +
 src/runtime/sys_openbsd.go                    |  1 +
 src/runtime/sys_openbsd1.go                   |  1 +
 src/runtime/sys_openbsd2.go                   |  1 +
 src/runtime/sys_openbsd3.go                   |  1 +
 src/runtime/sys_ppc64x.go                     |  1 +
 src/runtime/sys_x86.go                        |  1 +
 src/runtime/time_fake.go                      |  4 ++--
 src/runtime/time_nofake.go                    |  1 +
 src/runtime/timeasm.go                        |  1 +
 src/runtime/timestub.go                       |  1 +
 src/runtime/timestub2.go                      |  8 ++------
 src/runtime/vdso_elf32.go                     |  1 +
 src/runtime/vdso_elf64.go                     |  1 +
 src/runtime/vdso_freebsd.go                   |  1 +
 src/runtime/vdso_freebsd_x86.go               |  1 +
 src/runtime/vdso_in_none.go                   |  1 +
 src/runtime/vdso_linux.go                     |  1 +
 src/runtime/vdso_linux_mips64x.go             |  1 +
 src/runtime/vdso_linux_ppc64x.go              |  1 +
 src/runtime/vlrt.go                           |  1 +
 src/runtime/wincallback.go                    |  1 +
 src/runtime/write_err.go                      |  1 +
 src/sort/genzfunc.go                          |  1 +
 src/sort/slice_go113.go                       |  1 +
 src/sort/slice_go14.go                        |  1 +
 src/sort/slice_go18.go                        |  1 +
 src/strconv/bytealg.go                        |  1 +
 src/strconv/bytealg_bootstrap.go              |  1 +
 src/strconv/makeisprint.go                    |  1 +
 src/sync/pool_test.go                         |  1 +
 src/sync/runtime2.go                          |  1 +
 src/sync/runtime2_lockrank.go                 |  1 +
 src/syscall/bpf_bsd.go                        |  1 +
 src/syscall/creds_test.go                     |  1 +
 src/syscall/dirent.go                         |  1 +
 src/syscall/dirent_test.go                    |  1 +
 src/syscall/endian_big.go                     |  1 +
 src/syscall/endian_little.go                  |  1 +
 src/syscall/env_unix.go                       |  1 +
 src/syscall/exec_aix_test.go                  |  1 +
 src/syscall/exec_bsd.go                       |  1 +
 src/syscall/exec_libc.go                      |  1 +
 src/syscall/exec_libc2.go                     |  1 +
 src/syscall/exec_linux.go                     |  1 +
 src/syscall/exec_linux_test.go                |  1 +
 src/syscall/exec_solaris_test.go              |  1 +
 src/syscall/exec_unix.go                      |  1 +
 src/syscall/exec_unix_test.go                 |  1 +
 src/syscall/export_unix_test.go               |  1 +
 src/syscall/flock.go                          |  1 +
 src/syscall/flock_linux_32bit.go              |  1 +
 src/syscall/forkpipe.go                       |  1 +
 src/syscall/forkpipe2.go                      |  1 +
 src/syscall/fs_js.go                          |  1 +
 src/syscall/getdirentries_test.go             |  1 +
 src/syscall/mkasm.go                          |  1 +
 src/syscall/mkpost.go                         |  1 +
 src/syscall/mksyscall_windows.go              |  1 +
 src/syscall/mmap_unix_test.go                 |  1 +
 src/syscall/msan.go                           |  1 +
 src/syscall/msan0.go                          |  1 +
 src/syscall/net_js.go                         |  1 +
 src/syscall/ptrace_darwin.go                  |  1 +
 src/syscall/route_bsd.go                      |  1 +
 src/syscall/route_freebsd_32bit.go            |  1 +
 src/syscall/route_freebsd_64bit.go            |  1 +
 src/syscall/setuidgid_32_linux.go             |  1 +
 src/syscall/setuidgid_linux.go                |  4 ++--
 src/syscall/sockcmsg_unix.go                  |  1 +
 src/syscall/sockcmsg_unix_other.go            |  1 +
 src/syscall/syscall_bsd.go                    |  1 +
 src/syscall/syscall_bsd_test.go               |  1 +
 src/syscall/syscall_dup2_linux.go             |  1 +
 src/syscall/syscall_dup3_linux.go             |  1 +
 src/syscall/syscall_freebsd_test.go           |  1 +
 src/syscall/syscall_illumos.go                |  1 +
 src/syscall/syscall_js.go                     |  1 +
 src/syscall/syscall_linux_mips64x.go          |  1 +
 src/syscall/syscall_linux_mipsx.go            |  1 +
 src/syscall/syscall_linux_ppc64x.go           |  1 +
 src/syscall/syscall_openbsd1.go               |  1 +
 src/syscall/syscall_openbsd_libc.go           |  1 +
 src/syscall/syscall_ptrace_test.go            |  1 +
 src/syscall/syscall_unix.go                   |  1 +
 src/syscall/syscall_unix_test.go              |  1 +
 src/syscall/tables_js.go                      |  1 +
 src/syscall/time_fake.go                      |  1 +
 src/syscall/time_nofake.go                    |  1 +
 src/syscall/timestruct.go                     |  1 +
 src/syscall/types_aix.go                      |  1 +
 src/syscall/types_darwin.go                   |  1 +
 src/syscall/types_dragonfly.go                |  1 +
 src/syscall/types_freebsd.go                  |  1 +
 src/syscall/types_illumos_amd64.go            |  1 +
 src/syscall/types_linux.go                    |  1 +
 src/syscall/types_netbsd.go                   |  1 +
 src/syscall/types_openbsd.go                  |  1 +
 src/syscall/types_solaris.go                  |  1 +
 src/syscall/zerrors_darwin_amd64.go           |  1 +
 src/syscall/zerrors_darwin_arm64.go           |  1 +
 src/syscall/zerrors_dragonfly_amd64.go        |  1 +
 src/syscall/zerrors_freebsd_386.go            |  1 +
 src/syscall/zerrors_freebsd_amd64.go          |  1 +
 src/syscall/zerrors_freebsd_arm.go            |  1 +
 src/syscall/zerrors_freebsd_arm64.go          |  1 +
 src/syscall/zerrors_linux_386.go              |  1 +
 src/syscall/zerrors_linux_amd64.go            |  1 +
 src/syscall/zerrors_linux_arm.go              |  1 +
 src/syscall/zerrors_linux_arm64.go            |  1 +
 src/syscall/zerrors_linux_ppc64.go            |  1 +
 src/syscall/zerrors_linux_ppc64le.go          |  1 +
 src/syscall/zerrors_netbsd_386.go             |  1 +
 src/syscall/zerrors_netbsd_amd64.go           |  1 +
 src/syscall/zerrors_netbsd_arm.go             |  1 +
 src/syscall/zerrors_netbsd_arm64.go           |  1 +
 src/syscall/zerrors_openbsd_386.go            |  1 +
 src/syscall/zerrors_openbsd_amd64.go          |  1 +
 src/syscall/zerrors_openbsd_arm.go            |  1 +
 src/syscall/zerrors_solaris_amd64.go          |  1 +
 src/syscall/zsyscall_aix_ppc64.go             |  1 +
 src/syscall/zsyscall_darwin_amd64.go          |  1 +
 src/syscall/zsyscall_darwin_arm64.go          |  1 +
 src/syscall/zsyscall_dragonfly_amd64.go       |  1 +
 src/syscall/zsyscall_freebsd_386.go           |  1 +
 src/syscall/zsyscall_freebsd_amd64.go         |  1 +
 src/syscall/zsyscall_freebsd_arm.go           |  1 +
 src/syscall/zsyscall_freebsd_arm64.go         |  1 +
 src/syscall/zsyscall_linux_386.go             |  1 +
 src/syscall/zsyscall_linux_amd64.go           |  1 +
 src/syscall/zsyscall_linux_arm.go             |  1 +
 src/syscall/zsyscall_linux_arm64.go           |  1 +
 src/syscall/zsyscall_linux_mips.go            |  1 +
 src/syscall/zsyscall_linux_mips64.go          |  1 +
 src/syscall/zsyscall_linux_mips64le.go        |  1 +
 src/syscall/zsyscall_linux_mipsle.go          |  1 +
 src/syscall/zsyscall_linux_ppc64.go           |  1 +
 src/syscall/zsyscall_linux_ppc64le.go         |  1 +
 src/syscall/zsyscall_linux_riscv64.go         |  1 +
 src/syscall/zsyscall_linux_s390x.go           |  1 +
 src/syscall/zsyscall_netbsd_386.go            |  1 +
 src/syscall/zsyscall_netbsd_amd64.go          |  1 +
 src/syscall/zsyscall_netbsd_arm.go            |  1 +
 src/syscall/zsyscall_netbsd_arm64.go          |  1 +
 src/syscall/zsyscall_openbsd_386.go           |  1 +
 src/syscall/zsyscall_openbsd_amd64.go         |  1 +
 src/syscall/zsyscall_openbsd_arm.go           |  1 +
 src/syscall/zsyscall_openbsd_arm64.go         |  1 +
 src/syscall/zsyscall_openbsd_mips64.go        |  1 +
 src/syscall/zsyscall_plan9_386.go             |  1 +
 src/syscall/zsyscall_plan9_amd64.go           |  1 +
 src/syscall/zsyscall_plan9_arm.go             |  1 +
 src/syscall/zsyscall_solaris_amd64.go         |  1 +
 src/syscall/zsysnum_darwin_amd64.go           |  1 +
 src/syscall/zsysnum_darwin_arm64.go           |  1 +
 src/syscall/zsysnum_dragonfly_amd64.go        |  1 +
 src/syscall/zsysnum_freebsd_386.go            |  1 +
 src/syscall/zsysnum_freebsd_amd64.go          |  1 +
 src/syscall/zsysnum_freebsd_arm.go            |  1 +
 src/syscall/zsysnum_freebsd_arm64.go          |  1 +
 src/syscall/zsysnum_linux_386.go              |  1 +
 src/syscall/zsysnum_linux_amd64.go            |  1 +
 src/syscall/zsysnum_linux_arm.go              |  1 +
 src/syscall/zsysnum_linux_arm64.go            |  1 +
 src/syscall/zsysnum_linux_ppc64.go            |  1 +
 src/syscall/zsysnum_linux_ppc64le.go          |  1 +
 src/syscall/zsysnum_netbsd_386.go             |  1 +
 src/syscall/zsysnum_netbsd_amd64.go           |  1 +
 src/syscall/zsysnum_netbsd_arm.go             |  1 +
 src/syscall/zsysnum_netbsd_arm64.go           |  1 +
 src/syscall/zsysnum_openbsd_386.go            |  1 +
 src/syscall/zsysnum_openbsd_amd64.go          |  1 +
 src/syscall/zsysnum_openbsd_arm.go            |  1 +
 src/syscall/zsysnum_solaris_amd64.go          |  1 +
 src/syscall/ztypes_darwin_amd64.go            |  1 +
 src/syscall/ztypes_darwin_arm64.go            |  1 +
 src/syscall/ztypes_dragonfly_amd64.go         |  1 +
 src/syscall/ztypes_freebsd_386.go             |  1 +
 src/syscall/ztypes_freebsd_amd64.go           |  1 +
 src/syscall/ztypes_freebsd_arm.go             |  1 +
 src/syscall/ztypes_freebsd_arm64.go           |  1 +
 src/syscall/ztypes_linux_386.go               |  1 +
 src/syscall/ztypes_linux_amd64.go             |  1 +
 src/syscall/ztypes_linux_arm.go               |  1 +
 src/syscall/ztypes_linux_arm64.go             |  1 +
 src/syscall/ztypes_linux_ppc64.go             |  1 +
 src/syscall/ztypes_linux_ppc64le.go           |  1 +
 src/syscall/ztypes_netbsd_386.go              |  1 +
 src/syscall/ztypes_netbsd_amd64.go            |  1 +
 src/syscall/ztypes_netbsd_arm.go              |  1 +
 src/syscall/ztypes_netbsd_arm64.go            |  1 +
 src/syscall/ztypes_openbsd_386.go             |  1 +
 src/syscall/ztypes_openbsd_amd64.go           |  1 +
 src/syscall/ztypes_solaris_amd64.go           |  1 +
 src/testing/run_example.go                    |  1 +
 src/testing/run_example_js.go                 |  1 +
 src/time/embed.go                             |  1 +
 src/time/genzabbrs.go                         |  1 +
 src/time/sys_plan9.go                         |  1 +
 src/time/sys_unix.go                          |  1 +
 src/time/tzdata/generate_zipdata.go           |  1 +
 src/time/zoneinfo_ios.go                      |  1 +
 src/time/zoneinfo_js.go                       |  1 +
 src/time/zoneinfo_unix.go                     |  1 +
 src/time/zoneinfo_unix_test.go                |  1 +
 826 files changed, 883 insertions(+), 106 deletions(-)

diff --git a/src/archive/tar/stat_actime1.go b/src/archive/tar/stat_actime1.go
index 1bdd1c9dcb..4fdf2a04b3 100644
--- a/src/archive/tar/stat_actime1.go
+++ b/src/archive/tar/stat_actime1.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || linux || dragonfly || openbsd || solaris
 // +build aix linux dragonfly openbsd solaris
 
 package tar
diff --git a/src/archive/tar/stat_actime2.go b/src/archive/tar/stat_actime2.go
index 6f17dbe307..5a9a35cbb4 100644
--- a/src/archive/tar/stat_actime2.go
+++ b/src/archive/tar/stat_actime2.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || freebsd || netbsd
 // +build darwin freebsd netbsd
 
 package tar
diff --git a/src/archive/tar/stat_unix.go b/src/archive/tar/stat_unix.go
index 581d87dca9..3957349d6e 100644
--- a/src/archive/tar/stat_unix.go
+++ b/src/archive/tar/stat_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || linux || darwin || dragonfly || freebsd || openbsd || netbsd || solaris
 // +build aix linux darwin dragonfly freebsd openbsd netbsd solaris
 
 package tar
diff --git a/src/bytes/boundary_test.go b/src/bytes/boundary_test.go
index ea84f1e40f..5a47526593 100644
--- a/src/bytes/boundary_test.go
+++ b/src/bytes/boundary_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //
+//go:build linux
 // +build linux
 
 package bytes_test
diff --git a/src/cmd/api/run.go b/src/cmd/api/run.go
index ecb1d0f81a..8c9fb723a5 100644
--- a/src/cmd/api/run.go
+++ b/src/cmd/api/run.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // The run program is invoked via the dist tool.
diff --git a/src/cmd/compile/internal/gc/bootstrap.go b/src/cmd/compile/internal/gc/bootstrap.go
index 2e13d6b57a..37b0d59ede 100644
--- a/src/cmd/compile/internal/gc/bootstrap.go
+++ b/src/cmd/compile/internal/gc/bootstrap.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !go1.8
 // +build !go1.8
 
 package gc
diff --git a/src/cmd/compile/internal/gc/pprof.go b/src/cmd/compile/internal/gc/pprof.go
index 256c659259..5f9b030621 100644
--- a/src/cmd/compile/internal/gc/pprof.go
+++ b/src/cmd/compile/internal/gc/pprof.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.8
 // +build go1.8
 
 package gc
diff --git a/src/cmd/compile/internal/gc/trace.go b/src/cmd/compile/internal/gc/trace.go
index c6eb23a090..8cdbd4b0f3 100644
--- a/src/cmd/compile/internal/gc/trace.go
+++ b/src/cmd/compile/internal/gc/trace.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.7
 // +build go1.7
 
 package gc
diff --git a/src/cmd/compile/internal/ir/mknode.go b/src/cmd/compile/internal/ir/mknode.go
index 326f491a69..5a0aaadf16 100644
--- a/src/cmd/compile/internal/ir/mknode.go
+++ b/src/cmd/compile/internal/ir/mknode.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 package main
diff --git a/src/cmd/compile/internal/logopt/escape.go b/src/cmd/compile/internal/logopt/escape.go
index 802f967aa6..9660e938b4 100644
--- a/src/cmd/compile/internal/logopt/escape.go
+++ b/src/cmd/compile/internal/logopt/escape.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.8
 // +build go1.8
 
 package logopt
diff --git a/src/cmd/compile/internal/logopt/escape_bootstrap.go b/src/cmd/compile/internal/logopt/escape_bootstrap.go
index 66ff0b8f22..cc04eaadfd 100644
--- a/src/cmd/compile/internal/logopt/escape_bootstrap.go
+++ b/src/cmd/compile/internal/logopt/escape_bootstrap.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !go1.8
 // +build !go1.8
 
 package logopt
diff --git a/src/cmd/compile/internal/ssa/flags_test.go b/src/cmd/compile/internal/ssa/flags_test.go
index d64abf652c..0bc1097199 100644
--- a/src/cmd/compile/internal/ssa/flags_test.go
+++ b/src/cmd/compile/internal/ssa/flags_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build amd64 || arm64
 // +build amd64 arm64
 
 package ssa
diff --git a/src/cmd/compile/internal/typecheck/mapfile_mmap.go b/src/cmd/compile/internal/typecheck/mapfile_mmap.go
index 2f3aa16dec..298b385bcb 100644
--- a/src/cmd/compile/internal/typecheck/mapfile_mmap.go
+++ b/src/cmd/compile/internal/typecheck/mapfile_mmap.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd
 // +build darwin dragonfly freebsd linux netbsd openbsd
 
 package typecheck
diff --git a/src/cmd/compile/internal/typecheck/mapfile_read.go b/src/cmd/compile/internal/typecheck/mapfile_read.go
index 4059f261d4..9637ab97ab 100644
--- a/src/cmd/compile/internal/typecheck/mapfile_read.go
+++ b/src/cmd/compile/internal/typecheck/mapfile_read.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd
 // +build !darwin,!dragonfly,!freebsd,!linux,!netbsd,!openbsd
 
 package typecheck
diff --git a/src/cmd/compile/internal/typecheck/mkbuiltin.go b/src/cmd/compile/internal/typecheck/mkbuiltin.go
index bef510a578..6dbd1869b3 100644
--- a/src/cmd/compile/internal/typecheck/mkbuiltin.go
+++ b/src/cmd/compile/internal/typecheck/mkbuiltin.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // Generate builtin.go from builtin/runtime.go.
diff --git a/src/cmd/compile/internal/types2/example_test.go b/src/cmd/compile/internal/types2/example_test.go
index ffd54fe459..974acb82ef 100644
--- a/src/cmd/compile/internal/types2/example_test.go
+++ b/src/cmd/compile/internal/types2/example_test.go
@@ -6,6 +6,7 @@
 // Only run where builders (build.golang.org) have
 // access to compiled packages for import.
 //
+//go:build !arm && !arm64
 // +build !arm,!arm64
 
 package types2_test
diff --git a/src/cmd/dist/sys_default.go b/src/cmd/dist/sys_default.go
index 821dc273d6..e87c84ce3e 100644
--- a/src/cmd/dist/sys_default.go
+++ b/src/cmd/dist/sys_default.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !windows
 // +build !windows
 
 package main
diff --git a/src/cmd/dist/test_linux.go b/src/cmd/dist/test_linux.go
index b6d0aedbbf..43d28dc661 100644
--- a/src/cmd/dist/test_linux.go
+++ b/src/cmd/dist/test_linux.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux
 // +build linux
 
 package main
diff --git a/src/cmd/dist/util_gc.go b/src/cmd/dist/util_gc.go
index 17a0e6fbb5..2db6d3a25e 100644
--- a/src/cmd/dist/util_gc.go
+++ b/src/cmd/dist/util_gc.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !gccgo
 // +build !gccgo
 
 package main
diff --git a/src/cmd/dist/util_gccgo.go b/src/cmd/dist/util_gccgo.go
index dc897236fb..3255b80365 100644
--- a/src/cmd/dist/util_gccgo.go
+++ b/src/cmd/dist/util_gccgo.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build gccgo
 // +build gccgo
 
 package main
diff --git a/src/cmd/go/go11.go b/src/cmd/go/go11.go
index 7e383f4b5b..a1f2727825 100644
--- a/src/cmd/go/go11.go
+++ b/src/cmd/go/go11.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.1
 // +build go1.1
 
 package main
diff --git a/src/cmd/go/go_unix_test.go b/src/cmd/go/go_unix_test.go
index f6e10ca59c..7d5ff9bbb7 100644
--- a/src/cmd/go/go_unix_test.go
+++ b/src/cmd/go/go_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package main_test
diff --git a/src/cmd/go/internal/base/signal_notunix.go b/src/cmd/go/internal/base/signal_notunix.go
index 9e869b03ea..5cc0b0f101 100644
--- a/src/cmd/go/internal/base/signal_notunix.go
+++ b/src/cmd/go/internal/base/signal_notunix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build plan9 || windows
 // +build plan9 windows
 
 package base
diff --git a/src/cmd/go/internal/base/signal_unix.go b/src/cmd/go/internal/base/signal_unix.go
index 342775a118..cdc2658372 100644
--- a/src/cmd/go/internal/base/signal_unix.go
+++ b/src/cmd/go/internal/base/signal_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || js || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd js linux netbsd openbsd solaris
 
 package base
diff --git a/src/cmd/go/internal/lockedfile/internal/filelock/filelock_fcntl.go b/src/cmd/go/internal/lockedfile/internal/filelock/filelock_fcntl.go
index 1fa4327a89..a37b2ad6d1 100644
--- a/src/cmd/go/internal/lockedfile/internal/filelock/filelock_fcntl.go
+++ b/src/cmd/go/internal/lockedfile/internal/filelock/filelock_fcntl.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || (solaris && !illumos)
 // +build aix solaris,!illumos
 
 // This code implements the filelock API using POSIX 'fcntl' locks, which attach
diff --git a/src/cmd/go/internal/lockedfile/internal/filelock/filelock_other.go b/src/cmd/go/internal/lockedfile/internal/filelock/filelock_other.go
index bc480343fc..70f5d7a688 100644
--- a/src/cmd/go/internal/lockedfile/internal/filelock/filelock_other.go
+++ b/src/cmd/go/internal/lockedfile/internal/filelock/filelock_other.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !aix && !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !plan9 && !solaris && !windows
 // +build !aix,!darwin,!dragonfly,!freebsd,!linux,!netbsd,!openbsd,!plan9,!solaris,!windows
 
 package filelock
diff --git a/src/cmd/go/internal/lockedfile/internal/filelock/filelock_plan9.go b/src/cmd/go/internal/lockedfile/internal/filelock/filelock_plan9.go
index 0798ee469a..908afb6c8c 100644
--- a/src/cmd/go/internal/lockedfile/internal/filelock/filelock_plan9.go
+++ b/src/cmd/go/internal/lockedfile/internal/filelock/filelock_plan9.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build plan9
 // +build plan9
 
 package filelock
diff --git a/src/cmd/go/internal/lockedfile/internal/filelock/filelock_test.go b/src/cmd/go/internal/lockedfile/internal/filelock/filelock_test.go
index 2ac2052b8f..640d4406f4 100644
--- a/src/cmd/go/internal/lockedfile/internal/filelock/filelock_test.go
+++ b/src/cmd/go/internal/lockedfile/internal/filelock/filelock_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js && !plan9
 // +build !js,!plan9
 
 package filelock_test
diff --git a/src/cmd/go/internal/lockedfile/internal/filelock/filelock_unix.go b/src/cmd/go/internal/lockedfile/internal/filelock/filelock_unix.go
index ed07bac608..878a1e770d 100644
--- a/src/cmd/go/internal/lockedfile/internal/filelock/filelock_unix.go
+++ b/src/cmd/go/internal/lockedfile/internal/filelock/filelock_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || illumos || linux || netbsd || openbsd
 // +build darwin dragonfly freebsd illumos linux netbsd openbsd
 
 package filelock
diff --git a/src/cmd/go/internal/lockedfile/internal/filelock/filelock_windows.go b/src/cmd/go/internal/lockedfile/internal/filelock/filelock_windows.go
index 19de27eb9b..dd27ce92bd 100644
--- a/src/cmd/go/internal/lockedfile/internal/filelock/filelock_windows.go
+++ b/src/cmd/go/internal/lockedfile/internal/filelock/filelock_windows.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build windows
 // +build windows
 
 package filelock
diff --git a/src/cmd/go/internal/lockedfile/lockedfile_filelock.go b/src/cmd/go/internal/lockedfile/lockedfile_filelock.go
index efc66461ed..729df5c681 100644
--- a/src/cmd/go/internal/lockedfile/lockedfile_filelock.go
+++ b/src/cmd/go/internal/lockedfile/lockedfile_filelock.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !plan9
 // +build !plan9
 
 package lockedfile
diff --git a/src/cmd/go/internal/lockedfile/lockedfile_plan9.go b/src/cmd/go/internal/lockedfile/lockedfile_plan9.go
index 70d6eddf2d..3d4b97d78e 100644
--- a/src/cmd/go/internal/lockedfile/lockedfile_plan9.go
+++ b/src/cmd/go/internal/lockedfile/lockedfile_plan9.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build plan9
 // +build plan9
 
 package lockedfile
diff --git a/src/cmd/go/internal/lockedfile/lockedfile_test.go b/src/cmd/go/internal/lockedfile/lockedfile_test.go
index 34327dd841..3acc6695a7 100644
--- a/src/cmd/go/internal/lockedfile/lockedfile_test.go
+++ b/src/cmd/go/internal/lockedfile/lockedfile_test.go
@@ -3,6 +3,7 @@
 // license that can be found in the LICENSE file.
 
 // js does not support inter-process file locking.
+//go:build !js
 // +build !js
 
 package lockedfile_test
diff --git a/src/cmd/go/internal/lockedfile/transform_test.go b/src/cmd/go/internal/lockedfile/transform_test.go
index 407d48ea4a..b753346e7d 100644
--- a/src/cmd/go/internal/lockedfile/transform_test.go
+++ b/src/cmd/go/internal/lockedfile/transform_test.go
@@ -3,6 +3,7 @@
 // license that can be found in the LICENSE file.
 
 // js does not support inter-process file locking.
+//go:build !js
 // +build !js
 
 package lockedfile_test
diff --git a/src/cmd/go/internal/modfetch/bootstrap.go b/src/cmd/go/internal/modfetch/bootstrap.go
index e4020b0b41..ed694581a7 100644
--- a/src/cmd/go/internal/modfetch/bootstrap.go
+++ b/src/cmd/go/internal/modfetch/bootstrap.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build cmd_go_bootstrap
 // +build cmd_go_bootstrap
 
 package modfetch
diff --git a/src/cmd/go/internal/modfetch/codehost/shell.go b/src/cmd/go/internal/modfetch/codehost/shell.go
index ce8b501d53..0e9f381966 100644
--- a/src/cmd/go/internal/modfetch/codehost/shell.go
+++ b/src/cmd/go/internal/modfetch/codehost/shell.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // Interactive debugging shell for codehost.Repo implementations.
diff --git a/src/cmd/go/internal/modfetch/sumdb.go b/src/cmd/go/internal/modfetch/sumdb.go
index 4fbc54d15c..fbe2bda2e5 100644
--- a/src/cmd/go/internal/modfetch/sumdb.go
+++ b/src/cmd/go/internal/modfetch/sumdb.go
@@ -4,6 +4,7 @@
 
 // Go checksum database lookup
 
+//go:build !cmd_go_bootstrap
 // +build !cmd_go_bootstrap
 
 package modfetch
diff --git a/src/cmd/go/internal/modload/stat_openfile.go b/src/cmd/go/internal/modload/stat_openfile.go
index 5842b858f0..368f893198 100644
--- a/src/cmd/go/internal/modload/stat_openfile.go
+++ b/src/cmd/go/internal/modload/stat_openfile.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (js && wasm) || plan9
 // +build js,wasm plan9
 
 // On plan9, per http://9p.io/magic/man2html/2/access: “Since file permissions
diff --git a/src/cmd/go/internal/modload/stat_unix.go b/src/cmd/go/internal/modload/stat_unix.go
index f49278ec3a..e079d73990 100644
--- a/src/cmd/go/internal/modload/stat_unix.go
+++ b/src/cmd/go/internal/modload/stat_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package modload
diff --git a/src/cmd/go/internal/modload/stat_windows.go b/src/cmd/go/internal/modload/stat_windows.go
index 0ac2391347..825e60b27a 100644
--- a/src/cmd/go/internal/modload/stat_windows.go
+++ b/src/cmd/go/internal/modload/stat_windows.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build windows
 // +build windows
 
 package modload
diff --git a/src/cmd/go/internal/renameio/renameio_test.go b/src/cmd/go/internal/renameio/renameio_test.go
index 5b2ed83624..dc3c1415db 100644
--- a/src/cmd/go/internal/renameio/renameio_test.go
+++ b/src/cmd/go/internal/renameio/renameio_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !plan9
 // +build !plan9
 
 package renameio
diff --git a/src/cmd/go/internal/renameio/umask_test.go b/src/cmd/go/internal/renameio/umask_test.go
index 65e4fa587b..bed45af6ed 100644
--- a/src/cmd/go/internal/renameio/umask_test.go
+++ b/src/cmd/go/internal/renameio/umask_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !plan9 && !windows && !js
 // +build !plan9,!windows,!js
 
 package renameio
diff --git a/src/cmd/go/internal/robustio/robustio_flaky.go b/src/cmd/go/internal/robustio/robustio_flaky.go
index 5bd44bd345..d5c241857b 100644
--- a/src/cmd/go/internal/robustio/robustio_flaky.go
+++ b/src/cmd/go/internal/robustio/robustio_flaky.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build windows || darwin
 // +build windows darwin
 
 package robustio
diff --git a/src/cmd/go/internal/robustio/robustio_other.go b/src/cmd/go/internal/robustio/robustio_other.go
index 6fe7b7e4e4..3a20cac6cf 100644
--- a/src/cmd/go/internal/robustio/robustio_other.go
+++ b/src/cmd/go/internal/robustio/robustio_other.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !windows && !darwin
 // +build !windows,!darwin
 
 package robustio
diff --git a/src/cmd/go/internal/test/genflags.go b/src/cmd/go/internal/test/genflags.go
index 30334b0f30..9277de7fee 100644
--- a/src/cmd/go/internal/test/genflags.go
+++ b/src/cmd/go/internal/test/genflags.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 package main
diff --git a/src/cmd/go/internal/web/bootstrap.go b/src/cmd/go/internal/web/bootstrap.go
index 781702100a..08686cdfcf 100644
--- a/src/cmd/go/internal/web/bootstrap.go
+++ b/src/cmd/go/internal/web/bootstrap.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build cmd_go_bootstrap
 // +build cmd_go_bootstrap
 
 // This code is compiled only into the bootstrap 'go' binary.
diff --git a/src/cmd/go/internal/web/http.go b/src/cmd/go/internal/web/http.go
index 72fa2b2ca6..a77e0f9317 100644
--- a/src/cmd/go/internal/web/http.go
+++ b/src/cmd/go/internal/web/http.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !cmd_go_bootstrap
 // +build !cmd_go_bootstrap
 
 // This code is compiled into the real 'go' binary, but it is not
diff --git a/src/cmd/go/internal/web/url_other.go b/src/cmd/go/internal/web/url_other.go
index 2641ee62bf..453af402b4 100644
--- a/src/cmd/go/internal/web/url_other.go
+++ b/src/cmd/go/internal/web/url_other.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !windows
 // +build !windows
 
 package web
diff --git a/src/cmd/go/internal/web/url_other_test.go b/src/cmd/go/internal/web/url_other_test.go
index aa5663355e..4d6ed2ec7f 100644
--- a/src/cmd/go/internal/web/url_other_test.go
+++ b/src/cmd/go/internal/web/url_other_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !windows
 // +build !windows
 
 package web
diff --git a/src/cmd/go/internal/work/testgo.go b/src/cmd/go/internal/work/testgo.go
index 931f49a069..8b77871b23 100644
--- a/src/cmd/go/internal/work/testgo.go
+++ b/src/cmd/go/internal/work/testgo.go
@@ -4,6 +4,7 @@
 
 // This file contains extra hooks for testing the go command.
 
+//go:build testgo
 // +build testgo
 
 package work
diff --git a/src/cmd/internal/bio/buf_mmap.go b/src/cmd/internal/bio/buf_mmap.go
index 4b43d74f26..b9755c7e50 100644
--- a/src/cmd/internal/bio/buf_mmap.go
+++ b/src/cmd/internal/bio/buf_mmap.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd
 // +build darwin dragonfly freebsd linux netbsd openbsd
 
 package bio
diff --git a/src/cmd/internal/bio/buf_nommap.go b/src/cmd/internal/bio/buf_nommap.go
index f43c67ac2d..533a93180c 100644
--- a/src/cmd/internal/bio/buf_nommap.go
+++ b/src/cmd/internal/bio/buf_nommap.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd
 // +build !darwin,!dragonfly,!freebsd,!linux,!netbsd,!openbsd
 
 package bio
diff --git a/src/cmd/internal/goobj/mkbuiltin.go b/src/cmd/internal/goobj/mkbuiltin.go
index 22608e7e69..4e46970648 100644
--- a/src/cmd/internal/goobj/mkbuiltin.go
+++ b/src/cmd/internal/goobj/mkbuiltin.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // Generate builtinlist.go from cmd/compile/internal/gc/builtin/runtime.go.
diff --git a/src/cmd/internal/obj/stringer.go b/src/cmd/internal/obj/stringer.go
index f67b89091c..a4d507d49a 100644
--- a/src/cmd/internal/obj/stringer.go
+++ b/src/cmd/internal/obj/stringer.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // This is a mini version of the stringer tool customized for the Anames table
diff --git a/src/cmd/link/elf_test.go b/src/cmd/link/elf_test.go
index 20754d09f5..b4441297e6 100644
--- a/src/cmd/link/elf_test.go
+++ b/src/cmd/link/elf_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly || freebsd || linux || netbsd || openbsd
 // +build dragonfly freebsd linux netbsd openbsd
 
 package main
diff --git a/src/cmd/link/internal/ld/elf_test.go b/src/cmd/link/internal/ld/elf_test.go
index 776fc1b4f9..70e743fa65 100644
--- a/src/cmd/link/internal/ld/elf_test.go
+++ b/src/cmd/link/internal/ld/elf_test.go
@@ -1,3 +1,4 @@
+//go:build cgo
 // +build cgo
 
 // Copyright 2019 The Go Authors. All rights reserved.
diff --git a/src/cmd/link/internal/ld/execarchive.go b/src/cmd/link/internal/ld/execarchive.go
index 4687c624de..918b86cdc5 100644
--- a/src/cmd/link/internal/ld/execarchive.go
+++ b/src/cmd/link/internal/ld/execarchive.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !wasm && !windows
 // +build !wasm,!windows
 
 package ld
diff --git a/src/cmd/link/internal/ld/execarchive_noexec.go b/src/cmd/link/internal/ld/execarchive_noexec.go
index a70dea9fda..5e1f2669d3 100644
--- a/src/cmd/link/internal/ld/execarchive_noexec.go
+++ b/src/cmd/link/internal/ld/execarchive_noexec.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build wasm || windows
 // +build wasm windows
 
 package ld
diff --git a/src/cmd/link/internal/ld/fallocate_test.go b/src/cmd/link/internal/ld/fallocate_test.go
index 244b70f061..56d2321826 100644
--- a/src/cmd/link/internal/ld/fallocate_test.go
+++ b/src/cmd/link/internal/ld/fallocate_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || linux
 // +build darwin linux
 
 package ld
diff --git a/src/cmd/link/internal/ld/outbuf_mmap.go b/src/cmd/link/internal/ld/outbuf_mmap.go
index 807fe24375..40a3222788 100644
--- a/src/cmd/link/internal/ld/outbuf_mmap.go
+++ b/src/cmd/link/internal/ld/outbuf_mmap.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd
 // +build aix darwin dragonfly freebsd linux netbsd openbsd
 
 package ld
diff --git a/src/cmd/link/internal/ld/outbuf_nofallocate.go b/src/cmd/link/internal/ld/outbuf_nofallocate.go
index 6bf96bcb2b..6564bd54a3 100644
--- a/src/cmd/link/internal/ld/outbuf_nofallocate.go
+++ b/src/cmd/link/internal/ld/outbuf_nofallocate.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !darwin && !linux
 // +build !darwin,!linux
 
 package ld
diff --git a/src/cmd/link/internal/ld/outbuf_nommap.go b/src/cmd/link/internal/ld/outbuf_nommap.go
index 6b4025384b..c870fa2c18 100644
--- a/src/cmd/link/internal/ld/outbuf_nommap.go
+++ b/src/cmd/link/internal/ld/outbuf_nommap.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !aix && !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !windows
 // +build !aix,!darwin,!dragonfly,!freebsd,!linux,!netbsd,!openbsd,!windows
 
 package ld
diff --git a/src/cmd/link/internal/ld/outbuf_notdarwin.go b/src/cmd/link/internal/ld/outbuf_notdarwin.go
index 8c5666f216..f9caa413e3 100644
--- a/src/cmd/link/internal/ld/outbuf_notdarwin.go
+++ b/src/cmd/link/internal/ld/outbuf_notdarwin.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !darwin
 // +build !darwin
 
 package ld
diff --git a/src/cmd/nm/nm_cgo_test.go b/src/cmd/nm/nm_cgo_test.go
index e0414e6b22..536e87e4ae 100644
--- a/src/cmd/nm/nm_cgo_test.go
+++ b/src/cmd/nm/nm_cgo_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build cgo
 // +build cgo
 
 package main
diff --git a/src/cmd/pprof/readlineui.go b/src/cmd/pprof/readlineui.go
index 0c9fafdad7..dbbb9c2787 100644
--- a/src/cmd/pprof/readlineui.go
+++ b/src/cmd/pprof/readlineui.go
@@ -5,6 +5,7 @@
 // This file contains a driver.UI implementation
 // that provides the readline functionality if possible.
 
+//go:build (darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || windows) && !appengine && !android
 // +build darwin dragonfly freebsd linux netbsd openbsd solaris windows
 // +build !appengine
 // +build !android
diff --git a/src/cmd/trace/annotations_test.go b/src/cmd/trace/annotations_test.go
index 9c2d027366..acd5693c7d 100644
--- a/src/cmd/trace/annotations_test.go
+++ b/src/cmd/trace/annotations_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js
 // +build !js
 
 package main
diff --git a/src/cmd/trace/trace_test.go b/src/cmd/trace/trace_test.go
index ea0cc6f880..2b1a68d7f3 100644
--- a/src/cmd/trace/trace_test.go
+++ b/src/cmd/trace/trace_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js
 // +build !js
 
 package main
diff --git a/src/cmd/trace/trace_unix_test.go b/src/cmd/trace/trace_unix_test.go
index c569b40bb2..8dc56a8c7b 100644
--- a/src/cmd/trace/trace_unix_test.go
+++ b/src/cmd/trace/trace_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package main
diff --git a/src/crypto/aes/aes_gcm.go b/src/crypto/aes/aes_gcm.go
index 49b78c3a8b..1de0e457a2 100644
--- a/src/crypto/aes/aes_gcm.go
+++ b/src/crypto/aes/aes_gcm.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build amd64 || arm64
 // +build amd64 arm64
 
 package aes
diff --git a/src/crypto/aes/cipher_asm.go b/src/crypto/aes/cipher_asm.go
index 646bdfa5c0..4251805ef9 100644
--- a/src/crypto/aes/cipher_asm.go
+++ b/src/crypto/aes/cipher_asm.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build amd64 || arm64
 // +build amd64 arm64
 
 package aes
diff --git a/src/crypto/aes/cipher_generic.go b/src/crypto/aes/cipher_generic.go
index 80a68b4ef0..22ce3be7f3 100644
--- a/src/crypto/aes/cipher_generic.go
+++ b/src/crypto/aes/cipher_generic.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !amd64 && !s390x && !ppc64le && !arm64
 // +build !amd64,!s390x,!ppc64le,!arm64
 
 package aes
diff --git a/src/crypto/aes/gcm_ppc64le.go b/src/crypto/aes/gcm_ppc64le.go
index 084edddc4d..01b4e08757 100644
--- a/src/crypto/aes/gcm_ppc64le.go
+++ b/src/crypto/aes/gcm_ppc64le.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64le
 // +build ppc64le
 
 package aes
diff --git a/src/crypto/cipher/xor_generic.go b/src/crypto/cipher/xor_generic.go
index ca9c4bbf39..03208402d7 100644
--- a/src/crypto/cipher/xor_generic.go
+++ b/src/crypto/cipher/xor_generic.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !amd64 && !ppc64 && !ppc64le && !arm64
 // +build !amd64,!ppc64,!ppc64le,!arm64
 
 package cipher
diff --git a/src/crypto/cipher/xor_ppc64x.go b/src/crypto/cipher/xor_ppc64x.go
index 8d2e43d327..f520208a37 100644
--- a/src/crypto/cipher/xor_ppc64x.go
+++ b/src/crypto/cipher/xor_ppc64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 package cipher
diff --git a/src/crypto/ecdsa/ecdsa_noasm.go b/src/crypto/ecdsa/ecdsa_noasm.go
index 72196211e5..68670a4f93 100644
--- a/src/crypto/ecdsa/ecdsa_noasm.go
+++ b/src/crypto/ecdsa/ecdsa_noasm.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !s390x
 // +build !s390x
 
 package ecdsa
diff --git a/src/crypto/ecdsa/ecdsa_s390x_test.go b/src/crypto/ecdsa/ecdsa_s390x_test.go
index a434575dbc..e8b16b3668 100644
--- a/src/crypto/ecdsa/ecdsa_s390x_test.go
+++ b/src/crypto/ecdsa/ecdsa_s390x_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build s390x
 // +build s390x
 
 package ecdsa
diff --git a/src/crypto/elliptic/fuzz_test.go b/src/crypto/elliptic/fuzz_test.go
index b9209a789b..f5c9841a12 100644
--- a/src/crypto/elliptic/fuzz_test.go
+++ b/src/crypto/elliptic/fuzz_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build amd64 || arm64 || ppc64le
 // +build amd64 arm64 ppc64le
 
 package elliptic
diff --git a/src/crypto/elliptic/p256.go b/src/crypto/elliptic/p256.go
index c23e414156..3bb7bb70b6 100644
--- a/src/crypto/elliptic/p256.go
+++ b/src/crypto/elliptic/p256.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !amd64 && !arm64
 // +build !amd64,!arm64
 
 package elliptic
diff --git a/src/crypto/elliptic/p256_asm.go b/src/crypto/elliptic/p256_asm.go
index 6cf7742e1b..c405718b5e 100644
--- a/src/crypto/elliptic/p256_asm.go
+++ b/src/crypto/elliptic/p256_asm.go
@@ -10,6 +10,7 @@
 // https://link.springer.com/article/10.1007%2Fs13389-014-0090-x
 // https://eprint.iacr.org/2013/816.pdf
 
+//go:build amd64 || arm64
 // +build amd64 arm64
 
 package elliptic
diff --git a/src/crypto/elliptic/p256_generic.go b/src/crypto/elliptic/p256_generic.go
index f74c607a88..8ad56638e9 100644
--- a/src/crypto/elliptic/p256_generic.go
+++ b/src/crypto/elliptic/p256_generic.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !amd64 && !s390x && !arm64 && !ppc64le
 // +build !amd64,!s390x,!arm64,!ppc64le
 
 package elliptic
diff --git a/src/crypto/elliptic/p256_ppc64le.go b/src/crypto/elliptic/p256_ppc64le.go
index 160bdb12e3..40d9ed9d40 100644
--- a/src/crypto/elliptic/p256_ppc64le.go
+++ b/src/crypto/elliptic/p256_ppc64le.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64le
 // +build ppc64le
 
 package elliptic
diff --git a/src/crypto/elliptic/p256_s390x.go b/src/crypto/elliptic/p256_s390x.go
index 0d9478bfd6..91e613b631 100644
--- a/src/crypto/elliptic/p256_s390x.go
+++ b/src/crypto/elliptic/p256_s390x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build s390x
 // +build s390x
 
 package elliptic
diff --git a/src/crypto/internal/subtle/aliasing.go b/src/crypto/internal/subtle/aliasing.go
index 812ce3c655..86e0f3cfe7 100644
--- a/src/crypto/internal/subtle/aliasing.go
+++ b/src/crypto/internal/subtle/aliasing.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !appengine
 // +build !appengine
 
 // Package subtle implements functions that are often useful in cryptographic
diff --git a/src/crypto/internal/subtle/aliasing_appengine.go b/src/crypto/internal/subtle/aliasing_appengine.go
index 844f901d18..35b442f7a2 100644
--- a/src/crypto/internal/subtle/aliasing_appengine.go
+++ b/src/crypto/internal/subtle/aliasing_appengine.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build appengine
 // +build appengine
 
 // Package subtle implements functions that are often useful in cryptographic
diff --git a/src/crypto/md5/gen.go b/src/crypto/md5/gen.go
index 1468924cbc..29729fad01 100644
--- a/src/crypto/md5/gen.go
+++ b/src/crypto/md5/gen.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // This program generates md5block.go
diff --git a/src/crypto/md5/md5block_decl.go b/src/crypto/md5/md5block_decl.go
index f251e03d7f..bc2d58c069 100644
--- a/src/crypto/md5/md5block_decl.go
+++ b/src/crypto/md5/md5block_decl.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build amd64 || 386 || arm || ppc64le || ppc64 || s390x || arm64
 // +build amd64 386 arm ppc64le ppc64 s390x arm64
 
 package md5
diff --git a/src/crypto/md5/md5block_generic.go b/src/crypto/md5/md5block_generic.go
index 0b46e70b60..ea4fbcd0b4 100644
--- a/src/crypto/md5/md5block_generic.go
+++ b/src/crypto/md5/md5block_generic.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !amd64 && !386 && !arm && !ppc64le && !ppc64 && !s390x && !arm64
 // +build !amd64,!386,!arm,!ppc64le,!ppc64,!s390x,!arm64
 
 package md5
diff --git a/src/crypto/rand/eagain.go b/src/crypto/rand/eagain.go
index c9499715dc..85d4d9d47f 100644
--- a/src/crypto/rand/eagain.go
+++ b/src/crypto/rand/eagain.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package rand
diff --git a/src/crypto/rand/rand_batched.go b/src/crypto/rand/rand_batched.go
index 60267fd4bc..45e9351a31 100644
--- a/src/crypto/rand/rand_batched.go
+++ b/src/crypto/rand/rand_batched.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux || freebsd
 // +build linux freebsd
 
 package rand
diff --git a/src/crypto/rand/rand_batched_test.go b/src/crypto/rand/rand_batched_test.go
index 837db83f77..fd50735c7d 100644
--- a/src/crypto/rand/rand_batched_test.go
+++ b/src/crypto/rand/rand_batched_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux || freebsd
 // +build linux freebsd
 
 package rand
diff --git a/src/crypto/rand/rand_js.go b/src/crypto/rand/rand_js.go
index 7e939742ac..7ddc2b6169 100644
--- a/src/crypto/rand/rand_js.go
+++ b/src/crypto/rand/rand_js.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build js && wasm
 // +build js,wasm
 
 package rand
diff --git a/src/crypto/rand/rand_unix.go b/src/crypto/rand/rand_unix.go
index 548a5e4cb9..81277eb6a5 100644
--- a/src/crypto/rand/rand_unix.go
+++ b/src/crypto/rand/rand_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || plan9 || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd plan9 solaris
 
 // Unix cryptographically secure pseudorandom number
diff --git a/src/crypto/sha1/fallback_test.go b/src/crypto/sha1/fallback_test.go
index 08acd044d0..4bb8b3324f 100644
--- a/src/crypto/sha1/fallback_test.go
+++ b/src/crypto/sha1/fallback_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build s390x
 // +build s390x
 
 package sha1
diff --git a/src/crypto/sha1/issue15617_test.go b/src/crypto/sha1/issue15617_test.go
index 98038e5807..436f78c745 100644
--- a/src/crypto/sha1/issue15617_test.go
+++ b/src/crypto/sha1/issue15617_test.go
@@ -1,3 +1,4 @@
+//go:build amd64 && (linux || darwin)
 // +build amd64
 // +build linux darwin
 
diff --git a/src/crypto/sha1/sha1block_decl.go b/src/crypto/sha1/sha1block_decl.go
index 9c7df4e40a..93054efa7c 100644
--- a/src/crypto/sha1/sha1block_decl.go
+++ b/src/crypto/sha1/sha1block_decl.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build arm || 386 || s390x
 // +build arm 386 s390x
 
 package sha1
diff --git a/src/crypto/sha1/sha1block_generic.go b/src/crypto/sha1/sha1block_generic.go
index f95ea0eee4..feaba5a23a 100644
--- a/src/crypto/sha1/sha1block_generic.go
+++ b/src/crypto/sha1/sha1block_generic.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !amd64 && !386 && !arm && !s390x && !arm64
 // +build !amd64,!386,!arm,!s390x,!arm64
 
 package sha1
diff --git a/src/crypto/sha256/fallback_test.go b/src/crypto/sha256/fallback_test.go
index 5917a4862a..7ce88cbb2a 100644
--- a/src/crypto/sha256/fallback_test.go
+++ b/src/crypto/sha256/fallback_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build s390x
 // +build s390x
 
 package sha256
diff --git a/src/crypto/sha256/sha256block_decl.go b/src/crypto/sha256/sha256block_decl.go
index fe07e53b84..a6bb396f13 100644
--- a/src/crypto/sha256/sha256block_decl.go
+++ b/src/crypto/sha256/sha256block_decl.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build 386 || amd64 || s390x || ppc64le
 // +build 386 amd64 s390x ppc64le
 
 package sha256
diff --git a/src/crypto/sha256/sha256block_generic.go b/src/crypto/sha256/sha256block_generic.go
index 61362f4126..620c048b93 100644
--- a/src/crypto/sha256/sha256block_generic.go
+++ b/src/crypto/sha256/sha256block_generic.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !amd64 && !386 && !s390x && !ppc64le && !arm64
 // +build !amd64,!386,!s390x,!ppc64le,!arm64
 
 package sha256
diff --git a/src/crypto/sha512/fallback_test.go b/src/crypto/sha512/fallback_test.go
index 9024ce668a..faf732670a 100644
--- a/src/crypto/sha512/fallback_test.go
+++ b/src/crypto/sha512/fallback_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build s390x
 // +build s390x
 
 package sha512
diff --git a/src/crypto/sha512/sha512block_amd64.go b/src/crypto/sha512/sha512block_amd64.go
index 18151cea24..e2386f29ab 100644
--- a/src/crypto/sha512/sha512block_amd64.go
+++ b/src/crypto/sha512/sha512block_amd64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build amd64
 // +build amd64
 
 package sha512
diff --git a/src/crypto/sha512/sha512block_decl.go b/src/crypto/sha512/sha512block_decl.go
index 613d1e02a3..6c22f44801 100644
--- a/src/crypto/sha512/sha512block_decl.go
+++ b/src/crypto/sha512/sha512block_decl.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build s390x || ppc64le
 // +build s390x ppc64le
 
 package sha512
diff --git a/src/crypto/sha512/sha512block_generic.go b/src/crypto/sha512/sha512block_generic.go
index 3eabd2c7c0..865a7356f1 100644
--- a/src/crypto/sha512/sha512block_generic.go
+++ b/src/crypto/sha512/sha512block_generic.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !amd64 && !s390x && !ppc64le
 // +build !amd64,!s390x,!ppc64le
 
 package sha512
diff --git a/src/crypto/tls/generate_cert.go b/src/crypto/tls/generate_cert.go
index 1857185fe4..7ea90f8a7b 100644
--- a/src/crypto/tls/generate_cert.go
+++ b/src/crypto/tls/generate_cert.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // Generate a self-signed X.509 certificate for a TLS server. Outputs to
diff --git a/src/crypto/tls/handshake_unix_test.go b/src/crypto/tls/handshake_unix_test.go
index 72718544ae..19fc698676 100644
--- a/src/crypto/tls/handshake_unix_test.go
+++ b/src/crypto/tls/handshake_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package tls
diff --git a/src/crypto/x509/internal/macos/corefoundation.go b/src/crypto/x509/internal/macos/corefoundation.go
index 0572c6ccd8..abcdcdd91e 100644
--- a/src/crypto/x509/internal/macos/corefoundation.go
+++ b/src/crypto/x509/internal/macos/corefoundation.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin && !ios
 // +build darwin,!ios
 
 // Package macOS provides cgo-less wrappers for Core Foundation and
diff --git a/src/crypto/x509/internal/macos/security.go b/src/crypto/x509/internal/macos/security.go
index 3163e3a4f7..f346ff4c7f 100644
--- a/src/crypto/x509/internal/macos/security.go
+++ b/src/crypto/x509/internal/macos/security.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin && !ios
 // +build darwin,!ios
 
 package macOS
diff --git a/src/crypto/x509/root_bsd.go b/src/crypto/x509/root_bsd.go
index f04b6bd0d6..822e8573ff 100644
--- a/src/crypto/x509/root_bsd.go
+++ b/src/crypto/x509/root_bsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly || freebsd || netbsd || openbsd
 // +build dragonfly freebsd netbsd openbsd
 
 package x509
diff --git a/src/crypto/x509/root_darwin.go b/src/crypto/x509/root_darwin.go
index c9ea7e80f3..05593bb105 100644
--- a/src/crypto/x509/root_darwin.go
+++ b/src/crypto/x509/root_darwin.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !ios
 // +build !ios
 
 package x509
diff --git a/src/crypto/x509/root_ios.go b/src/crypto/x509/root_ios.go
index d2dfb62b77..50432f3d2c 100644
--- a/src/crypto/x509/root_ios.go
+++ b/src/crypto/x509/root_ios.go
@@ -1,8 +1,8 @@
 // Code generated by root_ios_gen.go -version 55188.40.9; DO NOT EDIT.
 // Update the version in root.go and regenerate with "go generate".
 
-// +build ios
-// +build !x509omitbundledroots
+//go:build ios && !x509omitbundledroots
+// +build ios,!x509omitbundledroots
 
 package x509
 
diff --git a/src/crypto/x509/root_ios_gen.go b/src/crypto/x509/root_ios_gen.go
index 8bc6e7d9c4..05bd672d5d 100644
--- a/src/crypto/x509/root_ios_gen.go
+++ b/src/crypto/x509/root_ios_gen.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // Generates root_ios.go.
diff --git a/src/crypto/x509/root_js.go b/src/crypto/x509/root_js.go
index 4e537a4fe5..f2c2c0af38 100644
--- a/src/crypto/x509/root_js.go
+++ b/src/crypto/x509/root_js.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build js && wasm
 // +build js,wasm
 
 package x509
diff --git a/src/crypto/x509/root_omit.go b/src/crypto/x509/root_omit.go
index 0055b3b862..81f2f112d0 100644
--- a/src/crypto/x509/root_omit.go
+++ b/src/crypto/x509/root_omit.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ((darwin && arm64) || (darwin && amd64 && ios)) && x509omitbundledroots
 // +build darwin,arm64 darwin,amd64,ios
 // +build x509omitbundledroots
 
diff --git a/src/crypto/x509/root_omit_test.go b/src/crypto/x509/root_omit_test.go
index 5ab6c931de..158bd7f91a 100644
--- a/src/crypto/x509/root_omit_test.go
+++ b/src/crypto/x509/root_omit_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ((darwin && arm64) || (darwin && amd64 && ios)) && x509omitbundledroots
 // +build darwin,arm64 darwin,amd64,ios
 // +build x509omitbundledroots
 
diff --git a/src/crypto/x509/root_plan9.go b/src/crypto/x509/root_plan9.go
index 2dc4aaf5d7..2bdb2fe713 100644
--- a/src/crypto/x509/root_plan9.go
+++ b/src/crypto/x509/root_plan9.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build plan9
 // +build plan9
 
 package x509
diff --git a/src/crypto/x509/root_unix.go b/src/crypto/x509/root_unix.go
index 262fc079d5..dede825edd 100644
--- a/src/crypto/x509/root_unix.go
+++ b/src/crypto/x509/root_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
 // +build aix dragonfly freebsd js,wasm linux netbsd openbsd solaris
 
 package x509
diff --git a/src/crypto/x509/root_unix_test.go b/src/crypto/x509/root_unix_test.go
index 878ed7c2fa..38038a65f3 100644
--- a/src/crypto/x509/root_unix_test.go
+++ b/src/crypto/x509/root_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build dragonfly freebsd linux netbsd openbsd solaris
 
 package x509
diff --git a/src/crypto/x509/x509_test_import.go b/src/crypto/x509/x509_test_import.go
index b778df261a..ef3ee807bf 100644
--- a/src/crypto/x509/x509_test_import.go
+++ b/src/crypto/x509/x509_test_import.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // This file is run by the x509 tests to ensure that a program with minimal
diff --git a/src/debug/pe/file_cgo_test.go b/src/debug/pe/file_cgo_test.go
index 739671d73f..bba3a068d6 100644
--- a/src/debug/pe/file_cgo_test.go
+++ b/src/debug/pe/file_cgo_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build cgo
 // +build cgo
 
 package pe
diff --git a/src/encoding/csv/fuzz.go b/src/encoding/csv/fuzz.go
index 8be21d5d28..a03fa83d8c 100644
--- a/src/encoding/csv/fuzz.go
+++ b/src/encoding/csv/fuzz.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build gofuzz
 // +build gofuzz
 
 package csv
diff --git a/src/encoding/gob/debug.go b/src/encoding/gob/debug.go
index 8f93742f49..5965fea921 100644
--- a/src/encoding/gob/debug.go
+++ b/src/encoding/gob/debug.go
@@ -3,6 +3,7 @@
 // license that can be found in the LICENSE file.
 
 // Delete the next line to include in the gob package.
+//go:build ignore
 // +build ignore
 
 package gob
diff --git a/src/encoding/gob/decgen.go b/src/encoding/gob/decgen.go
index 1c31e66625..994be877d9 100644
--- a/src/encoding/gob/decgen.go
+++ b/src/encoding/gob/decgen.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // encgen writes the helper functions for encoding. Intended to be
diff --git a/src/encoding/gob/dump.go b/src/encoding/gob/dump.go
index 17238c98df..8c0bbc4ff2 100644
--- a/src/encoding/gob/dump.go
+++ b/src/encoding/gob/dump.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 package main
diff --git a/src/encoding/gob/encgen.go b/src/encoding/gob/encgen.go
index 409b8c9d95..b562da177d 100644
--- a/src/encoding/gob/encgen.go
+++ b/src/encoding/gob/encgen.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // encgen writes the helper functions for encoding. Intended to be
diff --git a/src/encoding/json/fuzz.go b/src/encoding/json/fuzz.go
index be03f0d7ff..d3fa2d1113 100644
--- a/src/encoding/json/fuzz.go
+++ b/src/encoding/json/fuzz.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build gofuzz
 // +build gofuzz
 
 package json
diff --git a/src/go/build/gc.go b/src/go/build/gc.go
index 3025cd5681..e16e186e0d 100644
--- a/src/go/build/gc.go
+++ b/src/go/build/gc.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build gc
 // +build gc
 
 package build
diff --git a/src/go/build/gccgo.go b/src/go/build/gccgo.go
index c6aac9aa1b..c8ec7041fb 100644
--- a/src/go/build/gccgo.go
+++ b/src/go/build/gccgo.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build gccgo
 // +build gccgo
 
 package build
diff --git a/src/go/doc/headscan.go b/src/go/doc/headscan.go
index fe26a0ea84..28cb84f91d 100644
--- a/src/go/doc/headscan.go
+++ b/src/go/doc/headscan.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/go/types/example_test.go b/src/go/types/example_test.go
index 3747f3b15a..32a25a4117 100644
--- a/src/go/types/example_test.go
+++ b/src/go/types/example_test.go
@@ -5,6 +5,7 @@
 // Only run where builders (build.golang.org) have
 // access to compiled packages for import.
 //
+//go:build !arm && !arm64
 // +build !arm,!arm64
 
 package types_test
diff --git a/src/go/types/gotype.go b/src/go/types/gotype.go
index 52709df17b..ca1d42c14d 100644
--- a/src/go/types/gotype.go
+++ b/src/go/types/gotype.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // Build this command explicitly: go build gotype.go
diff --git a/src/hash/crc32/crc32_otherarch.go b/src/hash/crc32/crc32_otherarch.go
index 1a5e542ab6..936e5bf3e0 100644
--- a/src/hash/crc32/crc32_otherarch.go
+++ b/src/hash/crc32/crc32_otherarch.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !amd64 && !s390x && !ppc64le && !arm64
 // +build !amd64,!s390x,!ppc64le,!arm64
 
 package crc32
diff --git a/src/hash/crc32/gen_const_ppc64le.go b/src/hash/crc32/gen_const_ppc64le.go
index d7af018af4..c98454c685 100644
--- a/src/hash/crc32/gen_const_ppc64le.go
+++ b/src/hash/crc32/gen_const_ppc64le.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // Generate the constant table associated with the poly used by the
diff --git a/src/html/fuzz.go b/src/html/fuzz.go
index ffa3e257f4..ecaf4f9069 100644
--- a/src/html/fuzz.go
+++ b/src/html/fuzz.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build gofuzz
 // +build gofuzz
 
 package html
diff --git a/src/image/color/palette/gen.go b/src/image/color/palette/gen.go
index 3243e53981..7bb257d865 100644
--- a/src/image/color/palette/gen.go
+++ b/src/image/color/palette/gen.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 package main
diff --git a/src/image/internal/imageutil/gen.go b/src/image/internal/imageutil/gen.go
index 36de5dc9cc..38f41303fa 100644
--- a/src/image/internal/imageutil/gen.go
+++ b/src/image/internal/imageutil/gen.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 package main
diff --git a/src/image/png/fuzz.go b/src/image/png/fuzz.go
index d9cb3921e5..6508533f44 100644
--- a/src/image/png/fuzz.go
+++ b/src/image/png/fuzz.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build gofuzz
 // +build gofuzz
 
 package png
diff --git a/src/index/suffixarray/gen.go b/src/index/suffixarray/gen.go
index 94184d71b6..3bc9b1e2ae 100644
--- a/src/index/suffixarray/gen.go
+++ b/src/index/suffixarray/gen.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // Gen generates sais2.go by duplicating functions in sais.go
diff --git a/src/internal/abi/abi_amd64.go b/src/internal/abi/abi_amd64.go
index 70e2ed1feb..77589d4c34 100644
--- a/src/internal/abi/abi_amd64.go
+++ b/src/internal/abi/abi_amd64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build goexperiment.regabi
 // +build goexperiment.regabi
 
 package abi
diff --git a/src/internal/abi/abi_generic.go b/src/internal/abi/abi_generic.go
index 5ef9883dc6..1e36f36e80 100644
--- a/src/internal/abi/abi_generic.go
+++ b/src/internal/abi/abi_generic.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !goexperiment.regabi
 // +build !goexperiment.regabi
 
 package abi
diff --git a/src/internal/bytealg/compare_generic.go b/src/internal/bytealg/compare_generic.go
index bd4489a6b9..0690d0cf31 100644
--- a/src/internal/bytealg/compare_generic.go
+++ b/src/internal/bytealg/compare_generic.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !386 && !amd64 && !s390x && !arm && !arm64 && !ppc64 && !ppc64le && !mips && !mipsle && !wasm && !mips64 && !mips64le
 // +build !386,!amd64,!s390x,!arm,!arm64,!ppc64,!ppc64le,!mips,!mipsle,!wasm,!mips64,!mips64le
 
 package bytealg
diff --git a/src/internal/bytealg/compare_native.go b/src/internal/bytealg/compare_native.go
index b53ba97463..baa188ff7a 100644
--- a/src/internal/bytealg/compare_native.go
+++ b/src/internal/bytealg/compare_native.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build 386 || amd64 || s390x || arm || arm64 || ppc64 || ppc64le || mips || mipsle || wasm || mips64 || mips64le
 // +build 386 amd64 s390x arm arm64 ppc64 ppc64le mips mipsle wasm mips64 mips64le
 
 package bytealg
diff --git a/src/internal/bytealg/count_generic.go b/src/internal/bytealg/count_generic.go
index 5575e81ab8..1891d29b24 100644
--- a/src/internal/bytealg/count_generic.go
+++ b/src/internal/bytealg/count_generic.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !amd64 && !arm && !arm64 && !ppc64le && !ppc64 && !riscv64 && !s390x
 // +build !amd64,!arm,!arm64,!ppc64le,!ppc64,!riscv64,!s390x
 
 package bytealg
diff --git a/src/internal/bytealg/count_native.go b/src/internal/bytealg/count_native.go
index b1ff1d265a..a19a6f8223 100644
--- a/src/internal/bytealg/count_native.go
+++ b/src/internal/bytealg/count_native.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build amd64 || arm || arm64 || ppc64le || ppc64 || riscv64 || s390x
 // +build amd64 arm arm64 ppc64le ppc64 riscv64 s390x
 
 package bytealg
diff --git a/src/internal/bytealg/index_generic.go b/src/internal/bytealg/index_generic.go
index 98e859f925..2b8b139aeb 100644
--- a/src/internal/bytealg/index_generic.go
+++ b/src/internal/bytealg/index_generic.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !amd64 && !arm64 && !s390x
 // +build !amd64,!arm64,!s390x
 
 package bytealg
diff --git a/src/internal/bytealg/index_native.go b/src/internal/bytealg/index_native.go
index fde4214245..af56d8a294 100644
--- a/src/internal/bytealg/index_native.go
+++ b/src/internal/bytealg/index_native.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build amd64 || arm64 || s390x
 // +build amd64 arm64 s390x
 
 package bytealg
diff --git a/src/internal/bytealg/indexbyte_generic.go b/src/internal/bytealg/indexbyte_generic.go
index 0b012a8850..6ef639fafd 100644
--- a/src/internal/bytealg/indexbyte_generic.go
+++ b/src/internal/bytealg/indexbyte_generic.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !386 && !amd64 && !s390x && !arm && !arm64 && !ppc64 && !ppc64le && !mips && !mipsle && !mips64 && !mips64le && !riscv64 && !wasm
 // +build !386,!amd64,!s390x,!arm,!arm64,!ppc64,!ppc64le,!mips,!mipsle,!mips64,!mips64le,!riscv64,!wasm
 
 package bytealg
diff --git a/src/internal/bytealg/indexbyte_native.go b/src/internal/bytealg/indexbyte_native.go
index f96c5be491..965f38fe52 100644
--- a/src/internal/bytealg/indexbyte_native.go
+++ b/src/internal/bytealg/indexbyte_native.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build 386 || amd64 || s390x || arm || arm64 || ppc64 || ppc64le || mips || mipsle || mips64 || mips64le || riscv64 || wasm
 // +build 386 amd64 s390x arm arm64 ppc64 ppc64le mips mipsle mips64 mips64le riscv64 wasm
 
 package bytealg
diff --git a/src/internal/cpu/cpu_arm64_android.go b/src/internal/cpu/cpu_arm64_android.go
index 3c9e57c52a..ac6eee54b2 100644
--- a/src/internal/cpu/cpu_arm64_android.go
+++ b/src/internal/cpu/cpu_arm64_android.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build arm64
 // +build arm64
 
 package cpu
diff --git a/src/internal/cpu/cpu_arm64_darwin.go b/src/internal/cpu/cpu_arm64_darwin.go
index e094b97f97..ce1b250a18 100644
--- a/src/internal/cpu/cpu_arm64_darwin.go
+++ b/src/internal/cpu/cpu_arm64_darwin.go
@@ -2,9 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build arm64
-// +build darwin
-// +build !ios
+//go:build arm64 && darwin && !ios
+// +build arm64,darwin,!ios
 
 package cpu
 
diff --git a/src/internal/cpu/cpu_arm64_freebsd.go b/src/internal/cpu/cpu_arm64_freebsd.go
index 9de2005c2e..8c481370da 100644
--- a/src/internal/cpu/cpu_arm64_freebsd.go
+++ b/src/internal/cpu/cpu_arm64_freebsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build arm64
 // +build arm64
 
 package cpu
diff --git a/src/internal/cpu/cpu_arm64_hwcap.go b/src/internal/cpu/cpu_arm64_hwcap.go
index fdaf43e1a2..8ac04fd8f9 100644
--- a/src/internal/cpu/cpu_arm64_hwcap.go
+++ b/src/internal/cpu/cpu_arm64_hwcap.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build arm64
-// +build linux
+//go:build arm64 && linux
+// +build arm64,linux
 
 package cpu
 
diff --git a/src/internal/cpu/cpu_arm64_linux.go b/src/internal/cpu/cpu_arm64_linux.go
index 2f7411ff1e..c3a3f9a8e9 100644
--- a/src/internal/cpu/cpu_arm64_linux.go
+++ b/src/internal/cpu/cpu_arm64_linux.go
@@ -2,9 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build arm64
-// +build linux
-// +build !android
+//go:build arm64 && linux && !android
+// +build arm64,linux,!android
 
 package cpu
 
diff --git a/src/internal/cpu/cpu_arm64_other.go b/src/internal/cpu/cpu_arm64_other.go
index f191db28d2..e8b5d529a4 100644
--- a/src/internal/cpu/cpu_arm64_other.go
+++ b/src/internal/cpu/cpu_arm64_other.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build arm64 && !linux && !freebsd && !android && (!darwin || ios)
 // +build arm64
 // +build !linux
 // +build !freebsd
diff --git a/src/internal/cpu/cpu_mips64x.go b/src/internal/cpu/cpu_mips64x.go
index 0c4794a70a..d2f9d4499b 100644
--- a/src/internal/cpu/cpu_mips64x.go
+++ b/src/internal/cpu/cpu_mips64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips64 || mips64le
 // +build mips64 mips64le
 
 package cpu
diff --git a/src/internal/cpu/cpu_no_name.go b/src/internal/cpu/cpu_no_name.go
index ce1c37a3c7..8d563b536c 100644
--- a/src/internal/cpu/cpu_no_name.go
+++ b/src/internal/cpu/cpu_no_name.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !386
-// +build !amd64
+//go:build !386 && !amd64
+// +build !386,!amd64
 
 package cpu
 
diff --git a/src/internal/cpu/cpu_ppc64x.go b/src/internal/cpu/cpu_ppc64x.go
index beb1765427..2e7fd3ebb9 100644
--- a/src/internal/cpu/cpu_ppc64x.go
+++ b/src/internal/cpu/cpu_ppc64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 package cpu
diff --git a/src/internal/cpu/cpu_ppc64x_aix.go b/src/internal/cpu/cpu_ppc64x_aix.go
index b840b823ba..3d17a9c730 100644
--- a/src/internal/cpu/cpu_ppc64x_aix.go
+++ b/src/internal/cpu/cpu_ppc64x_aix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 package cpu
diff --git a/src/internal/cpu/cpu_ppc64x_linux.go b/src/internal/cpu/cpu_ppc64x_linux.go
index 73b191436d..b7c7345111 100644
--- a/src/internal/cpu/cpu_ppc64x_linux.go
+++ b/src/internal/cpu/cpu_ppc64x_linux.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 package cpu
diff --git a/src/internal/cpu/cpu_x86.go b/src/internal/cpu/cpu_x86.go
index ba6bf69034..fd1217a05d 100644
--- a/src/internal/cpu/cpu_x86.go
+++ b/src/internal/cpu/cpu_x86.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build 386 || amd64
 // +build 386 amd64
 
 package cpu
diff --git a/src/internal/cpu/cpu_x86_test.go b/src/internal/cpu/cpu_x86_test.go
index 61db93bd51..e3e16cc161 100644
--- a/src/internal/cpu/cpu_x86_test.go
+++ b/src/internal/cpu/cpu_x86_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build 386 || amd64
 // +build 386 amd64
 
 package cpu_test
diff --git a/src/internal/goroot/gc.go b/src/internal/goroot/gc.go
index ce72bc3896..2338b78f3a 100644
--- a/src/internal/goroot/gc.go
+++ b/src/internal/goroot/gc.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build gc
 // +build gc
 
 package goroot
diff --git a/src/internal/goroot/gccgo.go b/src/internal/goroot/gccgo.go
index 3530e59a15..b1041da11d 100644
--- a/src/internal/goroot/gccgo.go
+++ b/src/internal/goroot/gccgo.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build gccgo
 // +build gccgo
 
 package goroot
diff --git a/src/internal/poll/errno_unix.go b/src/internal/poll/errno_unix.go
index 0b23fc3210..55c548824f 100644
--- a/src/internal/poll/errno_unix.go
+++ b/src/internal/poll/errno_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package poll
diff --git a/src/internal/poll/errno_windows.go b/src/internal/poll/errno_windows.go
index e3bddb4bb2..c55f5f0df5 100644
--- a/src/internal/poll/errno_windows.go
+++ b/src/internal/poll/errno_windows.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build windows
 // +build windows
 
 package poll
diff --git a/src/internal/poll/error_stub_test.go b/src/internal/poll/error_stub_test.go
index c40ffcd20f..bcc25dd666 100644
--- a/src/internal/poll/error_stub_test.go
+++ b/src/internal/poll/error_stub_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !linux
 // +build !linux
 
 package poll_test
diff --git a/src/internal/poll/export_posix_test.go b/src/internal/poll/export_posix_test.go
index abadf50930..f59c1f6dfa 100644
--- a/src/internal/poll/export_posix_test.go
+++ b/src/internal/poll/export_posix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || windows
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris windows
 
 // Export guts for testing on posix.
diff --git a/src/internal/poll/fcntl_js.go b/src/internal/poll/fcntl_js.go
index 120fc1195f..7bf0ddc792 100644
--- a/src/internal/poll/fcntl_js.go
+++ b/src/internal/poll/fcntl_js.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build js && wasm
 // +build js,wasm
 
 package poll
diff --git a/src/internal/poll/fcntl_libc.go b/src/internal/poll/fcntl_libc.go
index 642472bc2b..cc609e48ad 100644
--- a/src/internal/poll/fcntl_libc.go
+++ b/src/internal/poll/fcntl_libc.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || solaris
 // +build aix darwin solaris
 
 package poll
diff --git a/src/internal/poll/fcntl_syscall.go b/src/internal/poll/fcntl_syscall.go
index 5ac814359a..8db5b66504 100644
--- a/src/internal/poll/fcntl_syscall.go
+++ b/src/internal/poll/fcntl_syscall.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly || freebsd || linux || netbsd || openbsd
 // +build dragonfly freebsd linux netbsd openbsd
 
 package poll
diff --git a/src/internal/poll/fd_fsync_posix.go b/src/internal/poll/fd_fsync_posix.go
index dd7956f14d..651a5ecd8b 100644
--- a/src/internal/poll/fd_fsync_posix.go
+++ b/src/internal/poll/fd_fsync_posix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
 // +build aix dragonfly freebsd js,wasm linux netbsd openbsd solaris
 
 package poll
diff --git a/src/internal/poll/fd_poll_js.go b/src/internal/poll/fd_poll_js.go
index d6b28e503c..760e24802e 100644
--- a/src/internal/poll/fd_poll_js.go
+++ b/src/internal/poll/fd_poll_js.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build js && wasm
 // +build js,wasm
 
 package poll
diff --git a/src/internal/poll/fd_poll_runtime.go b/src/internal/poll/fd_poll_runtime.go
index 222e5c6707..beb0f7d6a6 100644
--- a/src/internal/poll/fd_poll_runtime.go
+++ b/src/internal/poll/fd_poll_runtime.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || windows || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd windows solaris
 
 package poll
diff --git a/src/internal/poll/fd_posix.go b/src/internal/poll/fd_posix.go
index 4edfa953a4..487f3285ee 100644
--- a/src/internal/poll/fd_posix.go
+++ b/src/internal/poll/fd_posix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris || windows
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris windows
 
 package poll
diff --git a/src/internal/poll/fd_posix_test.go b/src/internal/poll/fd_posix_test.go
index 4449eb3a15..1dcf51d419 100644
--- a/src/internal/poll/fd_posix_test.go
+++ b/src/internal/poll/fd_posix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || windows
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris windows
 
 package poll_test
diff --git a/src/internal/poll/fd_unix.go b/src/internal/poll/fd_unix.go
index 2e77e76c87..fe8a5c8ec0 100644
--- a/src/internal/poll/fd_unix.go
+++ b/src/internal/poll/fd_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris
 
 package poll
diff --git a/src/internal/poll/fd_writev_darwin.go b/src/internal/poll/fd_writev_darwin.go
index e2024471d4..805fa2ccd9 100644
--- a/src/internal/poll/fd_writev_darwin.go
+++ b/src/internal/poll/fd_writev_darwin.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin
 // +build darwin
 
 package poll
diff --git a/src/internal/poll/fd_writev_illumos.go b/src/internal/poll/fd_writev_illumos.go
index 1fa47ab1a3..a0b11ed5ae 100644
--- a/src/internal/poll/fd_writev_illumos.go
+++ b/src/internal/poll/fd_writev_illumos.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build illumos
 // +build illumos
 
 package poll
diff --git a/src/internal/poll/fd_writev_unix.go b/src/internal/poll/fd_writev_unix.go
index daeec96c38..87f284a56a 100644
--- a/src/internal/poll/fd_writev_unix.go
+++ b/src/internal/poll/fd_writev_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly || freebsd || linux || netbsd || openbsd
 // +build dragonfly freebsd linux netbsd openbsd
 
 package poll
diff --git a/src/internal/poll/hook_cloexec.go b/src/internal/poll/hook_cloexec.go
index 5fd5449bb0..d519f602c1 100644
--- a/src/internal/poll/hook_cloexec.go
+++ b/src/internal/poll/hook_cloexec.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly || freebsd || illumos || linux || netbsd || openbsd
 // +build dragonfly freebsd illumos linux netbsd openbsd
 
 package poll
diff --git a/src/internal/poll/hook_unix.go b/src/internal/poll/hook_unix.go
index 11f90e9696..c88d65cdc8 100644
--- a/src/internal/poll/hook_unix.go
+++ b/src/internal/poll/hook_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris
 
 package poll
diff --git a/src/internal/poll/iovec_illumos.go b/src/internal/poll/iovec_illumos.go
index 057067465b..f4058b298f 100644
--- a/src/internal/poll/iovec_illumos.go
+++ b/src/internal/poll/iovec_illumos.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build illumos
 // +build illumos
 
 package poll
diff --git a/src/internal/poll/iovec_unix.go b/src/internal/poll/iovec_unix.go
index 6f98947866..6fd5d86630 100644
--- a/src/internal/poll/iovec_unix.go
+++ b/src/internal/poll/iovec_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd
 // +build darwin dragonfly freebsd linux netbsd openbsd
 
 package poll
diff --git a/src/internal/poll/sendfile_bsd.go b/src/internal/poll/sendfile_bsd.go
index 66005a9f5c..9eda85882c 100644
--- a/src/internal/poll/sendfile_bsd.go
+++ b/src/internal/poll/sendfile_bsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly || freebsd
 // +build dragonfly freebsd
 
 package poll
diff --git a/src/internal/poll/sock_cloexec.go b/src/internal/poll/sock_cloexec.go
index ff7982ca9e..52191d85c6 100644
--- a/src/internal/poll/sock_cloexec.go
+++ b/src/internal/poll/sock_cloexec.go
@@ -5,6 +5,7 @@
 // This file implements sysSocket and accept for platforms that
 // provide a fast path for setting SetNonblock and CloseOnExec.
 
+//go:build dragonfly || freebsd || illumos || linux || netbsd || openbsd
 // +build dragonfly freebsd illumos linux netbsd openbsd
 
 package poll
diff --git a/src/internal/poll/sockopt.go b/src/internal/poll/sockopt.go
index bb5ea02c0a..4f2e2fb455 100644
--- a/src/internal/poll/sockopt.go
+++ b/src/internal/poll/sockopt.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || windows
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris windows
 
 package poll
diff --git a/src/internal/poll/sockopt_unix.go b/src/internal/poll/sockopt_unix.go
index bd942c2934..4fb9600dee 100644
--- a/src/internal/poll/sockopt_unix.go
+++ b/src/internal/poll/sockopt_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package poll
diff --git a/src/internal/poll/sockoptip.go b/src/internal/poll/sockoptip.go
index c55a1e3c5b..d86c4c1f81 100644
--- a/src/internal/poll/sockoptip.go
+++ b/src/internal/poll/sockoptip.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || windows
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris windows
 
 package poll
diff --git a/src/internal/poll/strconv.go b/src/internal/poll/strconv.go
index 21cb40db70..fd5e20f1f4 100644
--- a/src/internal/poll/strconv.go
+++ b/src/internal/poll/strconv.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build plan9
 // +build plan9
 
 // Simple conversions to avoid depending on strconv.
diff --git a/src/internal/poll/sys_cloexec.go b/src/internal/poll/sys_cloexec.go
index 4b3c642173..69207a4b89 100644
--- a/src/internal/poll/sys_cloexec.go
+++ b/src/internal/poll/sys_cloexec.go
@@ -5,6 +5,7 @@
 // This file implements sysSocket and accept for platforms that do not
 // provide a fast path for setting SetNonblock and CloseOnExec.
 
+//go:build aix || darwin || (js && wasm) || (solaris && !illumos)
 // +build aix darwin js,wasm solaris,!illumos
 
 package poll
diff --git a/src/internal/poll/writev.go b/src/internal/poll/writev.go
index 0123fc33de..824de7569e 100644
--- a/src/internal/poll/writev.go
+++ b/src/internal/poll/writev.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || illumos || linux || netbsd || openbsd
 // +build darwin dragonfly freebsd illumos linux netbsd openbsd
 
 package poll
diff --git a/src/internal/race/norace.go b/src/internal/race/norace.go
index d83c0165b2..67b1305713 100644
--- a/src/internal/race/norace.go
+++ b/src/internal/race/norace.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !race
 // +build !race
 
 package race
diff --git a/src/internal/race/race.go b/src/internal/race/race.go
index 2e7d97beaa..40f2c99383 100644
--- a/src/internal/race/race.go
+++ b/src/internal/race/race.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build race
 // +build race
 
 package race
diff --git a/src/internal/syscall/execenv/execenv_default.go b/src/internal/syscall/execenv/execenv_default.go
index 4bdbb55edb..73289f1cd0 100644
--- a/src/internal/syscall/execenv/execenv_default.go
+++ b/src/internal/syscall/execenv/execenv_default.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !windows
 // +build !windows
 
 package execenv
diff --git a/src/internal/syscall/execenv/execenv_windows.go b/src/internal/syscall/execenv/execenv_windows.go
index b50029c198..6c0654943e 100644
--- a/src/internal/syscall/execenv/execenv_windows.go
+++ b/src/internal/syscall/execenv/execenv_windows.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build windows
 // +build windows
 
 package execenv
diff --git a/src/internal/syscall/unix/at.go b/src/internal/syscall/unix/at.go
index f857d68280..9b08864f7f 100644
--- a/src/internal/syscall/unix/at.go
+++ b/src/internal/syscall/unix/at.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux || openbsd || netbsd || dragonfly
 // +build linux openbsd netbsd dragonfly
 
 package unix
diff --git a/src/internal/syscall/unix/at_libc.go b/src/internal/syscall/unix/at_libc.go
index 6c3a8c9160..4cc351ea27 100644
--- a/src/internal/syscall/unix/at_libc.go
+++ b/src/internal/syscall/unix/at_libc.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || solaris
 // +build aix solaris
 
 package unix
diff --git a/src/internal/syscall/unix/at_sysnum_fstatat64_linux.go b/src/internal/syscall/unix/at_sysnum_fstatat64_linux.go
index c6ea206c12..050d401bc0 100644
--- a/src/internal/syscall/unix/at_sysnum_fstatat64_linux.go
+++ b/src/internal/syscall/unix/at_sysnum_fstatat64_linux.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build arm || mips || mipsle || 386
 // +build arm mips mipsle 386
 
 package unix
diff --git a/src/internal/syscall/unix/at_sysnum_fstatat_linux.go b/src/internal/syscall/unix/at_sysnum_fstatat_linux.go
index 31fe6a5a7b..e53a2d1b75 100644
--- a/src/internal/syscall/unix/at_sysnum_fstatat_linux.go
+++ b/src/internal/syscall/unix/at_sysnum_fstatat_linux.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build arm64 || riscv64
 // +build arm64 riscv64
 
 package unix
diff --git a/src/internal/syscall/unix/at_sysnum_newfstatat_linux.go b/src/internal/syscall/unix/at_sysnum_newfstatat_linux.go
index e76c1cbdce..4cb4a5976b 100644
--- a/src/internal/syscall/unix/at_sysnum_newfstatat_linux.go
+++ b/src/internal/syscall/unix/at_sysnum_newfstatat_linux.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build amd64 || mips64 || mips64le || ppc64 || ppc64le || s390x
 // +build amd64 mips64 mips64le ppc64 ppc64le s390x
 
 package unix
diff --git a/src/internal/syscall/unix/fcntl_linux_32bit.go b/src/internal/syscall/unix/fcntl_linux_32bit.go
index 6c75afc2ab..46a4f6b030 100644
--- a/src/internal/syscall/unix/fcntl_linux_32bit.go
+++ b/src/internal/syscall/unix/fcntl_linux_32bit.go
@@ -5,6 +5,7 @@
 // On 32-bit Linux systems, use SYS_FCNTL64.
 // If you change the build tags here, see syscall/flock_linux_32bit.go.
 
+//go:build (linux && 386) || (linux && arm) || (linux && mips) || (linux && mipsle)
 // +build linux,386 linux,arm linux,mips linux,mipsle
 
 package unix
diff --git a/src/internal/syscall/unix/nonblocking.go b/src/internal/syscall/unix/nonblocking.go
index db25fcca98..a22986cb8a 100644
--- a/src/internal/syscall/unix/nonblocking.go
+++ b/src/internal/syscall/unix/nonblocking.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly || freebsd || linux || netbsd || openbsd
 // +build dragonfly freebsd linux netbsd openbsd
 
 package unix
diff --git a/src/internal/syscall/unix/nonblocking_js.go b/src/internal/syscall/unix/nonblocking_js.go
index a360b53c3d..a5a5080d46 100644
--- a/src/internal/syscall/unix/nonblocking_js.go
+++ b/src/internal/syscall/unix/nonblocking_js.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build js && wasm
 // +build js,wasm
 
 package unix
diff --git a/src/internal/syscall/unix/nonblocking_libc.go b/src/internal/syscall/unix/nonblocking_libc.go
index 37cc7943ee..d9565efcb6 100644
--- a/src/internal/syscall/unix/nonblocking_libc.go
+++ b/src/internal/syscall/unix/nonblocking_libc.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || solaris
 // +build aix darwin solaris
 
 package unix
diff --git a/src/internal/syscall/unix/pipe2_illumos.go b/src/internal/syscall/unix/pipe2_illumos.go
index f3ac8d29df..b0aac89580 100644
--- a/src/internal/syscall/unix/pipe2_illumos.go
+++ b/src/internal/syscall/unix/pipe2_illumos.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build illumos
 // +build illumos
 
 package unix
diff --git a/src/internal/syscall/unix/sysnum_linux_generic.go b/src/internal/syscall/unix/sysnum_linux_generic.go
index f48da40188..a76025454c 100644
--- a/src/internal/syscall/unix/sysnum_linux_generic.go
+++ b/src/internal/syscall/unix/sysnum_linux_generic.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (arm64 || riscv64)
 // +build linux
 // +build arm64 riscv64
 
diff --git a/src/internal/syscall/unix/sysnum_linux_mips64x.go b/src/internal/syscall/unix/sysnum_linux_mips64x.go
index 6680942cb8..f353d4d73e 100644
--- a/src/internal/syscall/unix/sysnum_linux_mips64x.go
+++ b/src/internal/syscall/unix/sysnum_linux_mips64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips64 || mips64le
 // +build mips64 mips64le
 
 package unix
diff --git a/src/internal/syscall/unix/sysnum_linux_mipsx.go b/src/internal/syscall/unix/sysnum_linux_mipsx.go
index 185d8320c9..4ed471532a 100644
--- a/src/internal/syscall/unix/sysnum_linux_mipsx.go
+++ b/src/internal/syscall/unix/sysnum_linux_mipsx.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips || mipsle
 // +build mips mipsle
 
 package unix
diff --git a/src/internal/syscall/unix/sysnum_linux_ppc64x.go b/src/internal/syscall/unix/sysnum_linux_ppc64x.go
index 576937e3f5..b484ffef80 100644
--- a/src/internal/syscall/unix/sysnum_linux_ppc64x.go
+++ b/src/internal/syscall/unix/sysnum_linux_ppc64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 package unix
diff --git a/src/internal/syscall/unix/writev_illumos.go b/src/internal/syscall/unix/writev_illumos.go
index eb7973d65b..f60949f662 100644
--- a/src/internal/syscall/unix/writev_illumos.go
+++ b/src/internal/syscall/unix/writev_illumos.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build illumos
 // +build illumos
 
 package unix
diff --git a/src/internal/testenv/testenv_cgo.go b/src/internal/testenv/testenv_cgo.go
index e3d4d16b33..02f08f57c7 100644
--- a/src/internal/testenv/testenv_cgo.go
+++ b/src/internal/testenv/testenv_cgo.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build cgo
 // +build cgo
 
 package testenv
diff --git a/src/internal/testenv/testenv_notwin.go b/src/internal/testenv/testenv_notwin.go
index ccb5d5585f..846ec93856 100644
--- a/src/internal/testenv/testenv_notwin.go
+++ b/src/internal/testenv/testenv_notwin.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !windows
 // +build !windows
 
 package testenv
diff --git a/src/log/syslog/example_test.go b/src/log/syslog/example_test.go
index 4288d37dee..993976569e 100644
--- a/src/log/syslog/example_test.go
+++ b/src/log/syslog/example_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !windows && !plan9
 // +build !windows,!plan9
 
 package syslog_test
diff --git a/src/log/syslog/syslog.go b/src/log/syslog/syslog.go
index 97c10f31df..6abd4ad124 100644
--- a/src/log/syslog/syslog.go
+++ b/src/log/syslog/syslog.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !windows && !plan9
 // +build !windows,!plan9
 
 package syslog
diff --git a/src/log/syslog/syslog_test.go b/src/log/syslog/syslog_test.go
index 207bcf57c1..62c6250845 100644
--- a/src/log/syslog/syslog_test.go
+++ b/src/log/syslog/syslog_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !windows && !plan9 && !js
 // +build !windows,!plan9,!js
 
 package syslog
diff --git a/src/log/syslog/syslog_unix.go b/src/log/syslog/syslog_unix.go
index a64eed29f1..2e45f0764f 100644
--- a/src/log/syslog/syslog_unix.go
+++ b/src/log/syslog/syslog_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !windows && !plan9
 // +build !windows,!plan9
 
 package syslog
diff --git a/src/math/big/arith_amd64.go b/src/math/big/arith_amd64.go
index 1d2d37cf93..89108fe149 100644
--- a/src/math/big/arith_amd64.go
+++ b/src/math/big/arith_amd64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !math_big_pure_go
 // +build !math_big_pure_go
 
 package big
diff --git a/src/math/big/arith_decl.go b/src/math/big/arith_decl.go
index d519bdc87b..eea3d6b325 100644
--- a/src/math/big/arith_decl.go
+++ b/src/math/big/arith_decl.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !math_big_pure_go
 // +build !math_big_pure_go
 
 package big
diff --git a/src/math/big/arith_decl_pure.go b/src/math/big/arith_decl_pure.go
index 5faa3bd281..059f6f1325 100644
--- a/src/math/big/arith_decl_pure.go
+++ b/src/math/big/arith_decl_pure.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build math_big_pure_go
 // +build math_big_pure_go
 
 package big
diff --git a/src/math/big/arith_decl_s390x.go b/src/math/big/arith_decl_s390x.go
index f1a69e1df0..4193f3231c 100644
--- a/src/math/big/arith_decl_s390x.go
+++ b/src/math/big/arith_decl_s390x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !math_big_pure_go
 // +build !math_big_pure_go
 
 package big
diff --git a/src/math/big/arith_s390x_test.go b/src/math/big/arith_s390x_test.go
index ce6bca8885..8375ddbdd4 100644
--- a/src/math/big/arith_s390x_test.go
+++ b/src/math/big/arith_s390x_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build s390x && !math_big_pure_go
 // +build s390x,!math_big_pure_go
 
 package big
diff --git a/src/math/bits/bits_errors.go b/src/math/bits/bits_errors.go
index 192b4bee00..61cb5c9457 100644
--- a/src/math/bits/bits_errors.go
+++ b/src/math/bits/bits_errors.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !compiler_bootstrap
 // +build !compiler_bootstrap
 
 package bits
diff --git a/src/math/bits/bits_errors_bootstrap.go b/src/math/bits/bits_errors_bootstrap.go
index 5df5738848..4d610d33b8 100644
--- a/src/math/bits/bits_errors_bootstrap.go
+++ b/src/math/bits/bits_errors_bootstrap.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build compiler_bootstrap
 // +build compiler_bootstrap
 
 // This version used only for bootstrap (on this path we want
diff --git a/src/math/bits/make_examples.go b/src/math/bits/make_examples.go
index 1d3ad53fe6..ac4004df41 100644
--- a/src/math/bits/make_examples.go
+++ b/src/math/bits/make_examples.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // This program generates example_test.go.
diff --git a/src/math/bits/make_tables.go b/src/math/bits/make_tables.go
index b068d5e0e3..5ab0b5fc57 100644
--- a/src/math/bits/make_tables.go
+++ b/src/math/bits/make_tables.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // This program generates bits_tables.go.
diff --git a/src/math/cmplx/huge_test.go b/src/math/cmplx/huge_test.go
index f8e60c265f..78b42316de 100644
--- a/src/math/cmplx/huge_test.go
+++ b/src/math/cmplx/huge_test.go
@@ -5,6 +5,7 @@
 // Disabled for s390x because it uses assembly routines that are not
 // accurate for huge arguments.
 
+//go:build !s390x
 // +build !s390x
 
 package cmplx
diff --git a/src/math/exp_asm.go b/src/math/exp_asm.go
index 8dad3c810b..654ccce481 100644
--- a/src/math/exp_asm.go
+++ b/src/math/exp_asm.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build amd64
 // +build amd64
 
 package math
diff --git a/src/math/huge_test.go b/src/math/huge_test.go
index 9448edc339..ec81a4a31d 100644
--- a/src/math/huge_test.go
+++ b/src/math/huge_test.go
@@ -5,6 +5,7 @@
 // Disabled for s390x because it uses assembly routines that are not
 // accurate for huge arguments.
 
+//go:build !s390x
 // +build !s390x
 
 package math_test
diff --git a/src/math/rand/gen_cooked.go b/src/math/rand/gen_cooked.go
index 0afc10d727..7950e09fd7 100644
--- a/src/math/rand/gen_cooked.go
+++ b/src/math/rand/gen_cooked.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // This program computes the value of rngCooked in rng.go,
diff --git a/src/mime/type_unix.go b/src/mime/type_unix.go
index 3a25002842..851d5a0fb0 100644
--- a/src/mime/type_unix.go
+++ b/src/mime/type_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris
 
 package mime
diff --git a/src/net/addrselect.go b/src/net/addrselect.go
index 7c0dfe261c..ae93c595af 100644
--- a/src/net/addrselect.go
+++ b/src/net/addrselect.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 // Minimal RFC 6724 address selection.
diff --git a/src/net/addrselect_test.go b/src/net/addrselect_test.go
index d6e0e63c3b..dc13917018 100644
--- a/src/net/addrselect_test.go
+++ b/src/net/addrselect_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package net
diff --git a/src/net/cgo_aix.go b/src/net/cgo_aix.go
index d0ad414a32..a94405ecc0 100644
--- a/src/net/cgo_aix.go
+++ b/src/net/cgo_aix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build cgo && !netgo
 // +build cgo,!netgo
 
 package net
diff --git a/src/net/cgo_android.go b/src/net/cgo_android.go
index ab0368d14b..4b1a2e3e1d 100644
--- a/src/net/cgo_android.go
+++ b/src/net/cgo_android.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build cgo && !netgo
 // +build cgo,!netgo
 
 package net
diff --git a/src/net/cgo_bsd.go b/src/net/cgo_bsd.go
index a923c556d3..23be72140b 100644
--- a/src/net/cgo_bsd.go
+++ b/src/net/cgo_bsd.go
@@ -2,7 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build cgo,!netgo
+//go:build cgo && !netgo && (darwin || dragonfly || freebsd)
+// +build cgo
+// +build !netgo
 // +build darwin dragonfly freebsd
 
 package net
diff --git a/src/net/cgo_linux.go b/src/net/cgo_linux.go
index 86d8f4dc1e..1bd6be93f7 100644
--- a/src/net/cgo_linux.go
+++ b/src/net/cgo_linux.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !android && cgo && !netgo
 // +build !android,cgo,!netgo
 
 package net
diff --git a/src/net/cgo_netbsd.go b/src/net/cgo_netbsd.go
index 4610246561..3714793a52 100644
--- a/src/net/cgo_netbsd.go
+++ b/src/net/cgo_netbsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build cgo && !netgo
 // +build cgo,!netgo
 
 package net
diff --git a/src/net/cgo_openbsd.go b/src/net/cgo_openbsd.go
index 4610246561..3714793a52 100644
--- a/src/net/cgo_openbsd.go
+++ b/src/net/cgo_openbsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build cgo && !netgo
 // +build cgo,!netgo
 
 package net
diff --git a/src/net/cgo_resnew.go b/src/net/cgo_resnew.go
index 3e3e77e17d..154405270f 100644
--- a/src/net/cgo_resnew.go
+++ b/src/net/cgo_resnew.go
@@ -2,7 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build cgo,!netgo
+//go:build cgo && !netgo && (darwin || (linux && !android) || netbsd || solaris)
+// +build cgo
+// +build !netgo
 // +build darwin linux,!android netbsd solaris
 
 package net
diff --git a/src/net/cgo_resold.go b/src/net/cgo_resold.go
index abd04a814d..c4aab33eaa 100644
--- a/src/net/cgo_resold.go
+++ b/src/net/cgo_resold.go
@@ -2,7 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build cgo,!netgo
+//go:build cgo && !netgo && (android || freebsd || dragonfly || openbsd)
+// +build cgo
+// +build !netgo
 // +build android freebsd dragonfly openbsd
 
 package net
diff --git a/src/net/cgo_socknew.go b/src/net/cgo_socknew.go
index 3b13926107..f9cfad9909 100644
--- a/src/net/cgo_socknew.go
+++ b/src/net/cgo_socknew.go
@@ -2,7 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build cgo,!netgo
+//go:build cgo && !netgo && (android || linux || solaris)
+// +build cgo
+// +build !netgo
 // +build android linux solaris
 
 package net
diff --git a/src/net/cgo_sockold.go b/src/net/cgo_sockold.go
index e1e642bb41..22c67252f5 100644
--- a/src/net/cgo_sockold.go
+++ b/src/net/cgo_sockold.go
@@ -2,7 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build cgo,!netgo
+//go:build cgo && !netgo && (aix || darwin || dragonfly || freebsd || netbsd || openbsd)
+// +build cgo
+// +build !netgo
 // +build aix darwin dragonfly freebsd netbsd openbsd
 
 package net
diff --git a/src/net/cgo_solaris.go b/src/net/cgo_solaris.go
index 25c0721242..a84f5b0d34 100644
--- a/src/net/cgo_solaris.go
+++ b/src/net/cgo_solaris.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build cgo && !netgo
 // +build cgo,!netgo
 
 package net
diff --git a/src/net/cgo_stub.go b/src/net/cgo_stub.go
index 041f8af129..039e4be88b 100644
--- a/src/net/cgo_stub.go
+++ b/src/net/cgo_stub.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !cgo || netgo
 // +build !cgo netgo
 
 package net
diff --git a/src/net/cgo_unix.go b/src/net/cgo_unix.go
index 69c99fe7db..2ea86e074f 100644
--- a/src/net/cgo_unix.go
+++ b/src/net/cgo_unix.go
@@ -2,7 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build cgo,!netgo
+//go:build cgo && !netgo && (aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris)
+// +build cgo
+// +build !netgo
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package net
diff --git a/src/net/cgo_unix_test.go b/src/net/cgo_unix_test.go
index 99d79a60c4..1f3d9ea207 100644
--- a/src/net/cgo_unix_test.go
+++ b/src/net/cgo_unix_test.go
@@ -2,7 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build cgo,!netgo
+//go:build cgo && !netgo && (aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris)
+// +build cgo
+// +build !netgo
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package net
diff --git a/src/net/cgo_windows.go b/src/net/cgo_windows.go
index 8968b757a9..1fd1f29787 100644
--- a/src/net/cgo_windows.go
+++ b/src/net/cgo_windows.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build cgo && !netgo
 // +build cgo,!netgo
 
 package net
diff --git a/src/net/conf.go b/src/net/conf.go
index f1bbfedad0..6b9569cd92 100644
--- a/src/net/conf.go
+++ b/src/net/conf.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package net
diff --git a/src/net/conf_netcgo.go b/src/net/conf_netcgo.go
index db4c703b06..8f387ebc03 100644
--- a/src/net/conf_netcgo.go
+++ b/src/net/conf_netcgo.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build netcgo
 // +build netcgo
 
 package net
diff --git a/src/net/conf_test.go b/src/net/conf_test.go
index 1fe3cf41b1..b1f2c55ea5 100644
--- a/src/net/conf_test.go
+++ b/src/net/conf_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package net
diff --git a/src/net/conn_test.go b/src/net/conn_test.go
index 771cabcd3c..45e271c264 100644
--- a/src/net/conn_test.go
+++ b/src/net/conn_test.go
@@ -5,6 +5,7 @@
 // This file implements API tests across platforms and will never have a build
 // tag.
 
+//go:build !js
 // +build !js
 
 package net
diff --git a/src/net/dial_test.go b/src/net/dial_test.go
index 57cf5554ad..394bdb047e 100644
--- a/src/net/dial_test.go
+++ b/src/net/dial_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js
 // +build !js
 
 package net
diff --git a/src/net/dial_unix_test.go b/src/net/dial_unix_test.go
index 3cfc9d81b8..108b973099 100644
--- a/src/net/dial_unix_test.go
+++ b/src/net/dial_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package net
diff --git a/src/net/dnsclient_unix.go b/src/net/dnsclient_unix.go
index d7db0c8133..a3242ff3b2 100644
--- a/src/net/dnsclient_unix.go
+++ b/src/net/dnsclient_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 // DNS client: see RFC 1035.
diff --git a/src/net/dnsclient_unix_test.go b/src/net/dnsclient_unix_test.go
index 0530c92c2e..b47b83af15 100644
--- a/src/net/dnsclient_unix_test.go
+++ b/src/net/dnsclient_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package net
diff --git a/src/net/dnsconfig_unix.go b/src/net/dnsconfig_unix.go
index 877e77c049..db9213a13f 100644
--- a/src/net/dnsconfig_unix.go
+++ b/src/net/dnsconfig_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 // Read system DNS config from /etc/resolv.conf
diff --git a/src/net/dnsconfig_unix_test.go b/src/net/dnsconfig_unix_test.go
index 0d7897a813..0e2317c469 100644
--- a/src/net/dnsconfig_unix_test.go
+++ b/src/net/dnsconfig_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package net
diff --git a/src/net/dnsname_test.go b/src/net/dnsname_test.go
index 2964982311..d851bf7566 100644
--- a/src/net/dnsname_test.go
+++ b/src/net/dnsname_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js
 // +build !js
 
 package net
diff --git a/src/net/error_posix.go b/src/net/error_posix.go
index d709a273b7..50eb66fc61 100644
--- a/src/net/error_posix.go
+++ b/src/net/error_posix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris || windows
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris windows
 
 package net
diff --git a/src/net/error_posix_test.go b/src/net/error_posix_test.go
index b411a378df..ea52a45ee8 100644
--- a/src/net/error_posix_test.go
+++ b/src/net/error_posix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !plan9
 // +build !plan9
 
 package net
diff --git a/src/net/error_test.go b/src/net/error_test.go
index 556eb8c8d4..c304390819 100644
--- a/src/net/error_test.go
+++ b/src/net/error_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js
 // +build !js
 
 package net
diff --git a/src/net/error_unix.go b/src/net/error_unix.go
index e615330388..d0b5e2ce96 100644
--- a/src/net/error_unix.go
+++ b/src/net/error_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || js || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd js linux netbsd openbsd solaris
 
 package net
diff --git a/src/net/error_unix_test.go b/src/net/error_unix_test.go
index 9ce9e12c5e..533a45e648 100644
--- a/src/net/error_unix_test.go
+++ b/src/net/error_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !plan9 && !windows
 // +build !plan9,!windows
 
 package net
diff --git a/src/net/external_test.go b/src/net/external_test.go
index f3c69c407f..b8753cc092 100644
--- a/src/net/external_test.go
+++ b/src/net/external_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js
 // +build !js
 
 package net
diff --git a/src/net/fd_posix.go b/src/net/fd_posix.go
index 53abd152c7..2945e46a48 100644
--- a/src/net/fd_posix.go
+++ b/src/net/fd_posix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || windows
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris windows
 
 package net
diff --git a/src/net/fd_unix.go b/src/net/fd_unix.go
index 1c9bba3b19..a7bbdd26b4 100644
--- a/src/net/fd_unix.go
+++ b/src/net/fd_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package net
diff --git a/src/net/file_stub.go b/src/net/file_stub.go
index bfb8100f53..9f988fe899 100644
--- a/src/net/file_stub.go
+++ b/src/net/file_stub.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build js && wasm
 // +build js,wasm
 
 package net
diff --git a/src/net/file_test.go b/src/net/file_test.go
index 8c09c0da1b..a70ef1b312 100644
--- a/src/net/file_test.go
+++ b/src/net/file_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js
 // +build !js
 
 package net
diff --git a/src/net/file_unix.go b/src/net/file_unix.go
index dba69554ca..4520d4b839 100644
--- a/src/net/file_unix.go
+++ b/src/net/file_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package net
diff --git a/src/net/hook_unix.go b/src/net/hook_unix.go
index a28f1e066d..b9153d1947 100644
--- a/src/net/hook_unix.go
+++ b/src/net/hook_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris
 
 package net
diff --git a/src/net/http/cgi/plan9_test.go b/src/net/http/cgi/plan9_test.go
index cc20fe03e4..f998bac6ea 100644
--- a/src/net/http/cgi/plan9_test.go
+++ b/src/net/http/cgi/plan9_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build plan9
 // +build plan9
 
 package cgi
diff --git a/src/net/http/cgi/posix_test.go b/src/net/http/cgi/posix_test.go
index 9396ce036a..bc58ea94cc 100644
--- a/src/net/http/cgi/posix_test.go
+++ b/src/net/http/cgi/posix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !plan9
 // +build !plan9
 
 package cgi
diff --git a/src/net/http/h2_bundle.go b/src/net/http/h2_bundle.go
index 6bef310feb..0379848e70 100644
--- a/src/net/http/h2_bundle.go
+++ b/src/net/http/h2_bundle.go
@@ -1,3 +1,4 @@
+//go:build !nethttpomithttp2
 // +build !nethttpomithttp2
 
 // Code generated by golang.org/x/tools/cmd/bundle. DO NOT EDIT.
diff --git a/src/net/http/omithttp2.go b/src/net/http/omithttp2.go
index 30c6e48cfc..79599d006a 100644
--- a/src/net/http/omithttp2.go
+++ b/src/net/http/omithttp2.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build nethttpomithttp2
 // +build nethttpomithttp2
 
 package http
diff --git a/src/net/http/roundtrip.go b/src/net/http/roundtrip.go
index 2ec736bfb1..eef7c79293 100644
--- a/src/net/http/roundtrip.go
+++ b/src/net/http/roundtrip.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js || !wasm
 // +build !js !wasm
 
 package http
diff --git a/src/net/http/roundtrip_js.go b/src/net/http/roundtrip_js.go
index c6a221ac62..74c83a9172 100644
--- a/src/net/http/roundtrip_js.go
+++ b/src/net/http/roundtrip_js.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build js && wasm
 // +build js,wasm
 
 package http
diff --git a/src/net/http/triv.go b/src/net/http/triv.go
index 23e65d56e8..4dc62407c6 100644
--- a/src/net/http/triv.go
+++ b/src/net/http/triv.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 package main
diff --git a/src/net/interface_bsd.go b/src/net/interface_bsd.go
index d791cb3016..7578b1a16a 100644
--- a/src/net/interface_bsd.go
+++ b/src/net/interface_bsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || netbsd || openbsd
 // +build darwin dragonfly freebsd netbsd openbsd
 
 package net
diff --git a/src/net/interface_bsd_test.go b/src/net/interface_bsd_test.go
index 947dde71e6..8d0d9c3671 100644
--- a/src/net/interface_bsd_test.go
+++ b/src/net/interface_bsd_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || netbsd || openbsd
 // +build darwin dragonfly freebsd netbsd openbsd
 
 package net
diff --git a/src/net/interface_bsdvar.go b/src/net/interface_bsdvar.go
index a809b5f5ce..6230e0bfee 100644
--- a/src/net/interface_bsdvar.go
+++ b/src/net/interface_bsdvar.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly || netbsd || openbsd
 // +build dragonfly netbsd openbsd
 
 package net
diff --git a/src/net/interface_stub.go b/src/net/interface_stub.go
index ec58665e19..efe67c24d3 100644
--- a/src/net/interface_stub.go
+++ b/src/net/interface_stub.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build js && wasm
 // +build js,wasm
 
 package net
diff --git a/src/net/interface_test.go b/src/net/interface_test.go
index b2ef21e8ac..754db36e3c 100644
--- a/src/net/interface_test.go
+++ b/src/net/interface_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js
 // +build !js
 
 package net
diff --git a/src/net/interface_unix_test.go b/src/net/interface_unix_test.go
index bf41a0fb82..0d69fa5da4 100644
--- a/src/net/interface_unix_test.go
+++ b/src/net/interface_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd
 // +build darwin dragonfly freebsd linux netbsd openbsd
 
 package net
diff --git a/src/net/internal/socktest/main_test.go b/src/net/internal/socktest/main_test.go
index 3b0a48aef4..8af85d382e 100644
--- a/src/net/internal/socktest/main_test.go
+++ b/src/net/internal/socktest/main_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js && !plan9
 // +build !js,!plan9
 
 package socktest_test
diff --git a/src/net/internal/socktest/main_unix_test.go b/src/net/internal/socktest/main_unix_test.go
index 4d9d414356..6aa8875b66 100644
--- a/src/net/internal/socktest/main_unix_test.go
+++ b/src/net/internal/socktest/main_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js && !plan9 && !windows
 // +build !js,!plan9,!windows
 
 package socktest_test
diff --git a/src/net/internal/socktest/switch_posix.go b/src/net/internal/socktest/switch_posix.go
index 863edef0d3..cda74e8639 100644
--- a/src/net/internal/socktest/switch_posix.go
+++ b/src/net/internal/socktest/switch_posix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !plan9
 // +build !plan9
 
 package socktest
diff --git a/src/net/internal/socktest/switch_stub.go b/src/net/internal/socktest/switch_stub.go
index 28ce72cb85..5aa2ecec08 100644
--- a/src/net/internal/socktest/switch_stub.go
+++ b/src/net/internal/socktest/switch_stub.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build plan9
 // +build plan9
 
 package socktest
diff --git a/src/net/internal/socktest/switch_unix.go b/src/net/internal/socktest/switch_unix.go
index 7dc3518410..bfe9d4dbd3 100644
--- a/src/net/internal/socktest/switch_unix.go
+++ b/src/net/internal/socktest/switch_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris
 
 package socktest
diff --git a/src/net/internal/socktest/sys_cloexec.go b/src/net/internal/socktest/sys_cloexec.go
index 421352c7b4..c7f8331c2e 100644
--- a/src/net/internal/socktest/sys_cloexec.go
+++ b/src/net/internal/socktest/sys_cloexec.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly || freebsd || illumos || linux || netbsd || openbsd
 // +build dragonfly freebsd illumos linux netbsd openbsd
 
 package socktest
diff --git a/src/net/internal/socktest/sys_unix.go b/src/net/internal/socktest/sys_unix.go
index 0525512bff..e7cc45922e 100644
--- a/src/net/internal/socktest/sys_unix.go
+++ b/src/net/internal/socktest/sys_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris
 
 package socktest
diff --git a/src/net/ip_test.go b/src/net/ip_test.go
index a5fc5e644a..1e09ae9db4 100644
--- a/src/net/ip_test.go
+++ b/src/net/ip_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js
 // +build !js
 
 package net
diff --git a/src/net/iprawsock_posix.go b/src/net/iprawsock_posix.go
index e653f6ae17..c1514f1698 100644
--- a/src/net/iprawsock_posix.go
+++ b/src/net/iprawsock_posix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris || windows
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris windows
 
 package net
diff --git a/src/net/iprawsock_test.go b/src/net/iprawsock_test.go
index 8e3543dfc7..a96448ee6c 100644
--- a/src/net/iprawsock_test.go
+++ b/src/net/iprawsock_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js
 // +build !js
 
 package net
diff --git a/src/net/ipsock_posix.go b/src/net/ipsock_posix.go
index 8763d579fb..8d8a896501 100644
--- a/src/net/ipsock_posix.go
+++ b/src/net/ipsock_posix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris || windows
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris windows
 
 package net
diff --git a/src/net/listen_test.go b/src/net/listen_test.go
index d8c72096ed..b1dce29ac2 100644
--- a/src/net/listen_test.go
+++ b/src/net/listen_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js && !plan9
 // +build !js,!plan9
 
 package net
diff --git a/src/net/lookup_fake.go b/src/net/lookup_fake.go
index 3b3c39bc7d..f4fcaed5cf 100644
--- a/src/net/lookup_fake.go
+++ b/src/net/lookup_fake.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build js && wasm
 // +build js,wasm
 
 package net
diff --git a/src/net/lookup_test.go b/src/net/lookup_test.go
index 32a0d377da..3faaf00710 100644
--- a/src/net/lookup_test.go
+++ b/src/net/lookup_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js
 // +build !js
 
 package net
diff --git a/src/net/lookup_unix.go b/src/net/lookup_unix.go
index 9055826d40..c09afb300f 100644
--- a/src/net/lookup_unix.go
+++ b/src/net/lookup_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package net
diff --git a/src/net/main_cloexec_test.go b/src/net/main_cloexec_test.go
index 46b9ba5008..742be2fcd8 100644
--- a/src/net/main_cloexec_test.go
+++ b/src/net/main_cloexec_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly || freebsd || illumos || linux || netbsd || openbsd
 // +build dragonfly freebsd illumos linux netbsd openbsd
 
 package net
diff --git a/src/net/main_conf_test.go b/src/net/main_conf_test.go
index a92dff56c2..645b267b78 100644
--- a/src/net/main_conf_test.go
+++ b/src/net/main_conf_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js && !plan9 && !windows
 // +build !js,!plan9,!windows
 
 package net
diff --git a/src/net/main_noconf_test.go b/src/net/main_noconf_test.go
index bac84aa300..bcea630cd3 100644
--- a/src/net/main_noconf_test.go
+++ b/src/net/main_noconf_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (js && wasm) || plan9 || windows
 // +build js,wasm plan9 windows
 
 package net
diff --git a/src/net/main_posix_test.go b/src/net/main_posix_test.go
index f2484f306d..c9ab25a4ad 100644
--- a/src/net/main_posix_test.go
+++ b/src/net/main_posix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js && !plan9
 // +build !js,!plan9
 
 package net
diff --git a/src/net/main_test.go b/src/net/main_test.go
index 2d5be2ee5f..dc17d3fbb8 100644
--- a/src/net/main_test.go
+++ b/src/net/main_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js
 // +build !js
 
 package net
diff --git a/src/net/main_unix_test.go b/src/net/main_unix_test.go
index 8b9897699c..c8cff2d305 100644
--- a/src/net/main_unix_test.go
+++ b/src/net/main_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package net
diff --git a/src/net/mockserver_test.go b/src/net/mockserver_test.go
index 867e31e9ae..b50a1e59a1 100644
--- a/src/net/mockserver_test.go
+++ b/src/net/mockserver_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js
 // +build !js
 
 package net
diff --git a/src/net/net_fake.go b/src/net/net_fake.go
index 0c48dd5c03..49dc57c6ff 100644
--- a/src/net/net_fake.go
+++ b/src/net/net_fake.go
@@ -4,6 +4,7 @@
 
 // Fake networking for js/wasm. It is intended to allow tests of other package to pass.
 
+//go:build js && wasm
 // +build js,wasm
 
 package net
diff --git a/src/net/net_test.go b/src/net/net_test.go
index 409e1400af..6d6299e74a 100644
--- a/src/net/net_test.go
+++ b/src/net/net_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js
 // +build !js
 
 package net
diff --git a/src/net/netgo_unix_test.go b/src/net/netgo_unix_test.go
index c672d3e8eb..0dfd6c2cd7 100644
--- a/src/net/netgo_unix_test.go
+++ b/src/net/netgo_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (!cgo || netgo) && (darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris)
 // +build !cgo netgo
 // +build darwin dragonfly freebsd linux netbsd openbsd solaris
 
diff --git a/src/net/nss.go b/src/net/nss.go
index 96b9cdd121..85177cab9b 100644
--- a/src/net/nss.go
+++ b/src/net/nss.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package net
diff --git a/src/net/nss_test.go b/src/net/nss_test.go
index 371deb502d..4b73886c51 100644
--- a/src/net/nss_test.go
+++ b/src/net/nss_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package net
diff --git a/src/net/packetconn_test.go b/src/net/packetconn_test.go
index a377d333d6..aeb9845fa7 100644
--- a/src/net/packetconn_test.go
+++ b/src/net/packetconn_test.go
@@ -5,6 +5,7 @@
 // This file implements API tests across platforms and will never have a build
 // tag.
 
+//go:build !js
 // +build !js
 
 package net
diff --git a/src/net/port_unix.go b/src/net/port_unix.go
index 4fdd9a37bc..a9a96a2323 100644
--- a/src/net/port_unix.go
+++ b/src/net/port_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris
 
 // Read system port mappings from /etc/services
diff --git a/src/net/protoconn_test.go b/src/net/protoconn_test.go
index 6f83f52681..fc9b386256 100644
--- a/src/net/protoconn_test.go
+++ b/src/net/protoconn_test.go
@@ -5,6 +5,7 @@
 // This file implements API tests across platforms and will never have a build
 // tag.
 
+//go:build !js
 // +build !js
 
 package net
diff --git a/src/net/rawconn_stub_test.go b/src/net/rawconn_stub_test.go
index cec977f75d..975aa8d956 100644
--- a/src/net/rawconn_stub_test.go
+++ b/src/net/rawconn_stub_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (js && wasm) || plan9
 // +build js,wasm plan9
 
 package net
diff --git a/src/net/rawconn_test.go b/src/net/rawconn_test.go
index a08ff89d1a..3ef7af33b7 100644
--- a/src/net/rawconn_test.go
+++ b/src/net/rawconn_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js
 // +build !js
 
 package net
diff --git a/src/net/rawconn_unix_test.go b/src/net/rawconn_unix_test.go
index 0194ba67c8..75bbab8b27 100644
--- a/src/net/rawconn_unix_test.go
+++ b/src/net/rawconn_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package net
diff --git a/src/net/sendfile_stub.go b/src/net/sendfile_stub.go
index 53bc53af43..5753bc0289 100644
--- a/src/net/sendfile_stub.go
+++ b/src/net/sendfile_stub.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || (js && wasm) || netbsd || openbsd
 // +build aix darwin js,wasm netbsd openbsd
 
 package net
diff --git a/src/net/sendfile_test.go b/src/net/sendfile_test.go
index d6057fd839..db72daa328 100644
--- a/src/net/sendfile_test.go
+++ b/src/net/sendfile_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js
 // +build !js
 
 package net
diff --git a/src/net/sendfile_unix_alt.go b/src/net/sendfile_unix_alt.go
index 8cededce58..54667d672f 100644
--- a/src/net/sendfile_unix_alt.go
+++ b/src/net/sendfile_unix_alt.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly || freebsd || solaris
 // +build dragonfly freebsd solaris
 
 package net
diff --git a/src/net/server_test.go b/src/net/server_test.go
index 4ac5443e6a..8d4db7233d 100644
--- a/src/net/server_test.go
+++ b/src/net/server_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js
 // +build !js
 
 package net
diff --git a/src/net/sock_bsd.go b/src/net/sock_bsd.go
index 73fb6be814..4c883ada78 100644
--- a/src/net/sock_bsd.go
+++ b/src/net/sock_bsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || netbsd || openbsd
 // +build darwin dragonfly freebsd netbsd openbsd
 
 package net
diff --git a/src/net/sock_cloexec.go b/src/net/sock_cloexec.go
index 5f345f0f4a..efc91fdb53 100644
--- a/src/net/sock_cloexec.go
+++ b/src/net/sock_cloexec.go
@@ -5,6 +5,7 @@
 // This file implements sysSocket and accept for platforms that
 // provide a fast path for setting SetNonblock and CloseOnExec.
 
+//go:build dragonfly || freebsd || illumos || linux || netbsd || openbsd
 // +build dragonfly freebsd illumos linux netbsd openbsd
 
 package net
diff --git a/src/net/sock_posix.go b/src/net/sock_posix.go
index 80b4169ec6..9b1e7880ae 100644
--- a/src/net/sock_posix.go
+++ b/src/net/sock_posix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || windows
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris windows
 
 package net
diff --git a/src/net/sock_stub.go b/src/net/sock_stub.go
index c9f86af4e7..d804bfaacc 100644
--- a/src/net/sock_stub.go
+++ b/src/net/sock_stub.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || (js && wasm) || solaris
 // +build aix js,wasm solaris
 
 package net
diff --git a/src/net/sockaddr_posix.go b/src/net/sockaddr_posix.go
index a3710dd3f7..9d77cb569b 100644
--- a/src/net/sockaddr_posix.go
+++ b/src/net/sockaddr_posix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris || windows
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris windows
 
 package net
diff --git a/src/net/sockopt_bsd.go b/src/net/sockopt_bsd.go
index 8fd1e882c6..216e5d52f1 100644
--- a/src/net/sockopt_bsd.go
+++ b/src/net/sockopt_bsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || netbsd || openbsd
 // +build darwin dragonfly freebsd netbsd openbsd
 
 package net
diff --git a/src/net/sockopt_posix.go b/src/net/sockopt_posix.go
index de7255667f..50b9bfa0a7 100644
--- a/src/net/sockopt_posix.go
+++ b/src/net/sockopt_posix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || windows
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris windows
 
 package net
diff --git a/src/net/sockopt_stub.go b/src/net/sockopt_stub.go
index 52624a35d8..99b5277ed0 100644
--- a/src/net/sockopt_stub.go
+++ b/src/net/sockopt_stub.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build js && wasm
 // +build js,wasm
 
 package net
diff --git a/src/net/sockoptip_bsdvar.go b/src/net/sockoptip_bsdvar.go
index 20a6dc9549..56022fd1a5 100644
--- a/src/net/sockoptip_bsdvar.go
+++ b/src/net/sockoptip_bsdvar.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd netbsd openbsd solaris
 
 package net
diff --git a/src/net/sockoptip_posix.go b/src/net/sockoptip_posix.go
index b14963ff32..a2143aec2c 100644
--- a/src/net/sockoptip_posix.go
+++ b/src/net/sockoptip_posix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || windows
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris windows
 
 package net
diff --git a/src/net/sockoptip_stub.go b/src/net/sockoptip_stub.go
index 57cd289040..4175922cec 100644
--- a/src/net/sockoptip_stub.go
+++ b/src/net/sockoptip_stub.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build js && wasm
 // +build js,wasm
 
 package net
diff --git a/src/net/splice_stub.go b/src/net/splice_stub.go
index 9106cb2c18..ce2e9046a9 100644
--- a/src/net/splice_stub.go
+++ b/src/net/splice_stub.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !linux
 // +build !linux
 
 package net
diff --git a/src/net/splice_test.go b/src/net/splice_test.go
index 8a0cda6564..be13cc924d 100644
--- a/src/net/splice_test.go
+++ b/src/net/splice_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux
 // +build linux
 
 package net
diff --git a/src/net/sys_cloexec.go b/src/net/sys_cloexec.go
index 967b8bea9d..4d7112051f 100644
--- a/src/net/sys_cloexec.go
+++ b/src/net/sys_cloexec.go
@@ -5,6 +5,7 @@
 // This file implements sysSocket and accept for platforms that do not
 // provide a fast path for setting SetNonblock and CloseOnExec.
 
+//go:build aix || darwin || (solaris && !illumos)
 // +build aix darwin solaris,!illumos
 
 package net
diff --git a/src/net/tcpsock_posix.go b/src/net/tcpsock_posix.go
index 257c11976f..7c4523c5ee 100644
--- a/src/net/tcpsock_posix.go
+++ b/src/net/tcpsock_posix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris || windows
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris windows
 
 package net
diff --git a/src/net/tcpsock_test.go b/src/net/tcpsock_test.go
index d6172bc503..9c9f1eae93 100644
--- a/src/net/tcpsock_test.go
+++ b/src/net/tcpsock_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js
 // +build !js
 
 package net
diff --git a/src/net/tcpsock_unix_test.go b/src/net/tcpsock_unix_test.go
index 2bd591b594..41bd229132 100644
--- a/src/net/tcpsock_unix_test.go
+++ b/src/net/tcpsock_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js && !plan9 && !windows
 // +build !js,!plan9,!windows
 
 package net
diff --git a/src/net/tcpsockopt_posix.go b/src/net/tcpsockopt_posix.go
index 5e00ba1564..d08832adc0 100644
--- a/src/net/tcpsockopt_posix.go
+++ b/src/net/tcpsockopt_posix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || windows
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris windows
 
 package net
diff --git a/src/net/tcpsockopt_stub.go b/src/net/tcpsockopt_stub.go
index d043da123d..028d5fd29c 100644
--- a/src/net/tcpsockopt_stub.go
+++ b/src/net/tcpsockopt_stub.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build js && wasm
 // +build js,wasm
 
 package net
diff --git a/src/net/tcpsockopt_unix.go b/src/net/tcpsockopt_unix.go
index fb0ecb8dc7..a945889e00 100644
--- a/src/net/tcpsockopt_unix.go
+++ b/src/net/tcpsockopt_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || freebsd || linux || netbsd
 // +build aix freebsd linux netbsd
 
 package net
diff --git a/src/net/timeout_test.go b/src/net/timeout_test.go
index 205aaa430b..e1cf1467c3 100644
--- a/src/net/timeout_test.go
+++ b/src/net/timeout_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js
 // +build !js
 
 package net
diff --git a/src/net/udpsock_posix.go b/src/net/udpsock_posix.go
index bbfa4ed9c7..58c69f18ad 100644
--- a/src/net/udpsock_posix.go
+++ b/src/net/udpsock_posix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris || windows
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris windows
 
 package net
diff --git a/src/net/udpsock_test.go b/src/net/udpsock_test.go
index 327eba6541..7a1ed4eb18 100644
--- a/src/net/udpsock_test.go
+++ b/src/net/udpsock_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js
 // +build !js
 
 package net
diff --git a/src/net/unixsock_posix.go b/src/net/unixsock_posix.go
index 275c7c936d..1d1f27449f 100644
--- a/src/net/unixsock_posix.go
+++ b/src/net/unixsock_posix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris || windows
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris windows
 
 package net
diff --git a/src/net/unixsock_test.go b/src/net/unixsock_test.go
index 0b13bf655f..71092e88fb 100644
--- a/src/net/unixsock_test.go
+++ b/src/net/unixsock_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js && !plan9 && !windows
 // +build !js,!plan9,!windows
 
 package net
diff --git a/src/net/unixsock_windows_test.go b/src/net/unixsock_windows_test.go
index 5dccc14653..29244f6471 100644
--- a/src/net/unixsock_windows_test.go
+++ b/src/net/unixsock_windows_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build windows
 // +build windows
 
 package net
diff --git a/src/net/write_unix_test.go b/src/net/write_unix_test.go
index 6d8cb6a6f8..f79f2d0865 100644
--- a/src/net/write_unix_test.go
+++ b/src/net/write_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package net
diff --git a/src/net/writev_test.go b/src/net/writev_test.go
index d603b7f70a..bf40ca2023 100644
--- a/src/net/writev_test.go
+++ b/src/net/writev_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js
 // +build !js
 
 package net
diff --git a/src/net/writev_unix.go b/src/net/writev_unix.go
index 8b20f42b34..a0fedc2f99 100644
--- a/src/net/writev_unix.go
+++ b/src/net/writev_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || illumos || linux || netbsd || openbsd
 // +build darwin dragonfly freebsd illumos linux netbsd openbsd
 
 package net
diff --git a/src/os/dir_unix.go b/src/os/dir_unix.go
index 0e1eab1c96..ef5c00aee0 100644
--- a/src/os/dir_unix.go
+++ b/src/os/dir_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
 // +build aix dragonfly freebsd js,wasm linux netbsd openbsd solaris
 
 package os
diff --git a/src/os/endian_big.go b/src/os/endian_big.go
index c98f124782..0529dccd6f 100644
--- a/src/os/endian_big.go
+++ b/src/os/endian_big.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //
+//go:build ppc64 || s390x || mips || mips64
 // +build ppc64 s390x mips mips64
 
 package os
diff --git a/src/os/endian_little.go b/src/os/endian_little.go
index 3efc5e0d8d..6be6020f53 100644
--- a/src/os/endian_little.go
+++ b/src/os/endian_little.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //
+//go:build 386 || amd64 || arm || arm64 || ppc64le || mips64le || mipsle || riscv64 || wasm
 // +build 386 amd64 arm arm64 ppc64le mips64le mipsle riscv64 wasm
 
 package os
diff --git a/src/os/env_unix_test.go b/src/os/env_unix_test.go
index 89430b3e20..d45e1deb83 100644
--- a/src/os/env_unix_test.go
+++ b/src/os/env_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package os_test
diff --git a/src/os/error_errno.go b/src/os/error_errno.go
index 31ae05a21e..580e915b73 100644
--- a/src/os/error_errno.go
+++ b/src/os/error_errno.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !plan9
 // +build !plan9
 
 package os
diff --git a/src/os/error_posix.go b/src/os/error_posix.go
index 2aeca82304..268b3a923a 100644
--- a/src/os/error_posix.go
+++ b/src/os/error_posix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris || windows
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris windows
 
 package os
diff --git a/src/os/error_unix_test.go b/src/os/error_unix_test.go
index 18bcf3f4e4..e45282a0fd 100644
--- a/src/os/error_unix_test.go
+++ b/src/os/error_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris
 
 package os_test
diff --git a/src/os/error_windows_test.go b/src/os/error_windows_test.go
index b8191c5ebc..aa0c14b7d4 100644
--- a/src/os/error_windows_test.go
+++ b/src/os/error_windows_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build windows
 // +build windows
 
 package os_test
diff --git a/src/os/exec/exec_linux_test.go b/src/os/exec/exec_linux_test.go
index 6f850204d6..3cfa30ee72 100644
--- a/src/os/exec/exec_linux_test.go
+++ b/src/os/exec/exec_linux_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && cgo
 // +build linux,cgo
 
 // On systems that use glibc, calling malloc can create a new arena,
diff --git a/src/os/exec/exec_posix_test.go b/src/os/exec/exec_posix_test.go
index d4d67ac933..7b2c0c0c11 100644
--- a/src/os/exec/exec_posix_test.go
+++ b/src/os/exec/exec_posix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package exec_test
diff --git a/src/os/exec/exec_unix.go b/src/os/exec/exec_unix.go
index 51c52427c2..467c069e1c 100644
--- a/src/os/exec/exec_unix.go
+++ b/src/os/exec/exec_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !plan9 && !windows
 // +build !plan9,!windows
 
 package exec
diff --git a/src/os/exec/lp_js.go b/src/os/exec/lp_js.go
index 6750fb99b0..4eac25fe6f 100644
--- a/src/os/exec/lp_js.go
+++ b/src/os/exec/lp_js.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build js && wasm
 // +build js,wasm
 
 package exec
diff --git a/src/os/exec/lp_unix.go b/src/os/exec/lp_unix.go
index 66c1df76fb..d1d246accf 100644
--- a/src/os/exec/lp_unix.go
+++ b/src/os/exec/lp_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package exec
diff --git a/src/os/exec/lp_unix_test.go b/src/os/exec/lp_unix_test.go
index 296480fd04..75bcdb1fdd 100644
--- a/src/os/exec/lp_unix_test.go
+++ b/src/os/exec/lp_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package exec
diff --git a/src/os/exec/read3.go b/src/os/exec/read3.go
index 8cc24da8cb..a8c71831d8 100644
--- a/src/os/exec/read3.go
+++ b/src/os/exec/read3.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // This is a test program that verifies that it can read from
diff --git a/src/os/exec_posix.go b/src/os/exec_posix.go
index 8aa1e5e499..443d4e0218 100644
--- a/src/os/exec_posix.go
+++ b/src/os/exec_posix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris || windows
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris windows
 
 package os
diff --git a/src/os/exec_unix.go b/src/os/exec_unix.go
index a1703a1259..d1bbeb7529 100644
--- a/src/os/exec_unix.go
+++ b/src/os/exec_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris
 
 package os
diff --git a/src/os/exec_unix_test.go b/src/os/exec_unix_test.go
index d942cdb5e5..f14b3519fb 100644
--- a/src/os/exec_unix_test.go
+++ b/src/os/exec_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package os_test
diff --git a/src/os/executable_path.go b/src/os/executable_path.go
index 7b8b83652c..625430ecfc 100644
--- a/src/os/executable_path.go
+++ b/src/os/executable_path.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || openbsd
 // +build aix openbsd
 
 package os
diff --git a/src/os/executable_plan9.go b/src/os/executable_plan9.go
index a5947eaae1..105c03f0c1 100644
--- a/src/os/executable_plan9.go
+++ b/src/os/executable_plan9.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build plan9
 // +build plan9
 
 package os
diff --git a/src/os/executable_procfs.go b/src/os/executable_procfs.go
index 5ee41a4b2e..9c64a0d474 100644
--- a/src/os/executable_procfs.go
+++ b/src/os/executable_procfs.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux || netbsd || (js && wasm)
 // +build linux netbsd js,wasm
 
 package os
diff --git a/src/os/executable_sysctl.go b/src/os/executable_sysctl.go
index f9a4b18f60..039448b557 100644
--- a/src/os/executable_sysctl.go
+++ b/src/os/executable_sysctl.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build freebsd || dragonfly
 // +build freebsd dragonfly
 
 package os
diff --git a/src/os/export_unix_test.go b/src/os/export_unix_test.go
index 39866a68de..10f8312831 100644
--- a/src/os/export_unix_test.go
+++ b/src/os/export_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris
 
 package os
diff --git a/src/os/fifo_test.go b/src/os/fifo_test.go
index 2439192a9d..c3607344ec 100644
--- a/src/os/fifo_test.go
+++ b/src/os/fifo_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd
 // +build darwin dragonfly freebsd linux netbsd openbsd
 
 package os_test
diff --git a/src/os/file_posix.go b/src/os/file_posix.go
index 795c547856..211f2a1798 100644
--- a/src/os/file_posix.go
+++ b/src/os/file_posix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris || windows
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris windows
 
 package os
diff --git a/src/os/file_unix.go b/src/os/file_unix.go
index f88450018e..e8b286c9ee 100644
--- a/src/os/file_unix.go
+++ b/src/os/file_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris
 
 package os
diff --git a/src/os/os_unix_test.go b/src/os/os_unix_test.go
index 51693fd82a..9b4c0ab290 100644
--- a/src/os/os_unix_test.go
+++ b/src/os/os_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris
 
 package os_test
diff --git a/src/os/path_unix.go b/src/os/path_unix.go
index c99a8240c5..db38359492 100644
--- a/src/os/path_unix.go
+++ b/src/os/path_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris
 
 package os
diff --git a/src/os/pipe2_bsd.go b/src/os/pipe2_bsd.go
index 0ef894b476..0af8019525 100644
--- a/src/os/pipe2_bsd.go
+++ b/src/os/pipe2_bsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build freebsd || netbsd || openbsd
 // +build freebsd netbsd openbsd
 
 package os
diff --git a/src/os/pipe2_illumos.go b/src/os/pipe2_illumos.go
index 026ce62b9a..71b8cb8e25 100644
--- a/src/os/pipe2_illumos.go
+++ b/src/os/pipe2_illumos.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build illumos
 // +build illumos
 
 package os
diff --git a/src/os/pipe_bsd.go b/src/os/pipe_bsd.go
index 115d6baa19..57959a2ea4 100644
--- a/src/os/pipe_bsd.go
+++ b/src/os/pipe_bsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || (js && wasm) || (solaris && !illumos)
 // +build aix darwin dragonfly js,wasm solaris,!illumos
 
 package os
diff --git a/src/os/pipe_test.go b/src/os/pipe_test.go
index b98e53845c..b663618502 100644
--- a/src/os/pipe_test.go
+++ b/src/os/pipe_test.go
@@ -3,6 +3,7 @@
 // license that can be found in the LICENSE file.
 
 // Test broken pipes on Unix systems.
+//go:build !plan9 && !js
 // +build !plan9,!js
 
 package os_test
diff --git a/src/os/rawconn.go b/src/os/rawconn.go
index 9e11cda8c9..ffc598b061 100644
--- a/src/os/rawconn.go
+++ b/src/os/rawconn.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !plan9
 // +build !plan9
 
 package os
diff --git a/src/os/rawconn_test.go b/src/os/rawconn_test.go
index 2554f5b087..8aebaf87a6 100644
--- a/src/os/rawconn_test.go
+++ b/src/os/rawconn_test.go
@@ -3,6 +3,7 @@
 // license that can be found in the LICENSE file.
 
 // Test use of raw connections.
+//go:build !plan9 && !js
 // +build !plan9,!js
 
 package os_test
diff --git a/src/os/readfrom_stub.go b/src/os/readfrom_stub.go
index 65429d0cab..826760f3df 100644
--- a/src/os/readfrom_stub.go
+++ b/src/os/readfrom_stub.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !linux
 // +build !linux
 
 package os
diff --git a/src/os/removeall_at.go b/src/os/removeall_at.go
index c1a1b726af..d04540bc63 100644
--- a/src/os/removeall_at.go
+++ b/src/os/removeall_at.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package os
diff --git a/src/os/removeall_noat.go b/src/os/removeall_noat.go
index 7c888baaa9..853e0eddfc 100644
--- a/src/os/removeall_noat.go
+++ b/src/os/removeall_noat.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !aix && !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris
 // +build !aix,!darwin,!dragonfly,!freebsd,!linux,!netbsd,!openbsd,!solaris
 
 package os
diff --git a/src/os/signal/example_unix_test.go b/src/os/signal/example_unix_test.go
index a0af37a5bb..3f7795b8cf 100644
--- a/src/os/signal/example_unix_test.go
+++ b/src/os/signal/example_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package signal_test
diff --git a/src/os/signal/internal/pty/pty.go b/src/os/signal/internal/pty/pty.go
index f8813ce6be..8d2eac7103 100644
--- a/src/os/signal/internal/pty/pty.go
+++ b/src/os/signal/internal/pty/pty.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (aix || darwin || dragonfly || freebsd || (linux && !android) || netbsd || openbsd) && cgo
 // +build aix darwin dragonfly freebsd linux,!android netbsd openbsd
 // +build cgo
 
diff --git a/src/os/signal/signal_cgo_test.go b/src/os/signal/signal_cgo_test.go
index a8a485613f..e1e4509e2a 100644
--- a/src/os/signal/signal_cgo_test.go
+++ b/src/os/signal/signal_cgo_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (darwin || dragonfly || freebsd || (linux && !android) || netbsd || openbsd) && cgo
 // +build darwin dragonfly freebsd linux,!android netbsd openbsd
 // +build cgo
 
diff --git a/src/os/signal/signal_linux_test.go b/src/os/signal/signal_linux_test.go
index 2e553d0b0f..7abe1ec5a0 100644
--- a/src/os/signal/signal_linux_test.go
+++ b/src/os/signal/signal_linux_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux
 // +build linux
 
 package signal
diff --git a/src/os/signal/signal_test.go b/src/os/signal/signal_test.go
index bbc68af9fb..292d24c6f1 100644
--- a/src/os/signal/signal_test.go
+++ b/src/os/signal/signal_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package signal
diff --git a/src/os/signal/signal_unix.go b/src/os/signal/signal_unix.go
index 90a1eca156..9e241c43ac 100644
--- a/src/os/signal/signal_unix.go
+++ b/src/os/signal/signal_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris || windows
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris windows
 
 package signal
diff --git a/src/os/stat_js.go b/src/os/stat_js.go
index 8d20ccddfc..3badf5ba57 100644
--- a/src/os/stat_js.go
+++ b/src/os/stat_js.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build js && wasm
 // +build js,wasm
 
 package os
diff --git a/src/os/stat_unix.go b/src/os/stat_unix.go
index 66c356fc62..8c17805f71 100644
--- a/src/os/stat_unix.go
+++ b/src/os/stat_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris
 
 package os
diff --git a/src/os/sticky_bsd.go b/src/os/sticky_bsd.go
index c09b1ac202..ab23d8111d 100644
--- a/src/os/sticky_bsd.go
+++ b/src/os/sticky_bsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd js,wasm netbsd openbsd solaris
 
 package os
diff --git a/src/os/sticky_notbsd.go b/src/os/sticky_notbsd.go
index c15850692c..9979b43e8e 100644
--- a/src/os/sticky_notbsd.go
+++ b/src/os/sticky_notbsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !aix && !darwin && !dragonfly && !freebsd && (!js || !wasm) && !netbsd && !openbsd && !solaris
 // +build !aix
 // +build !darwin
 // +build !dragonfly
diff --git a/src/os/sys_bsd.go b/src/os/sys_bsd.go
index b1698f5d4c..1e245eb53a 100644
--- a/src/os/sys_bsd.go
+++ b/src/os/sys_bsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || (js && wasm) || netbsd || openbsd
 // +build darwin dragonfly freebsd js,wasm netbsd openbsd
 
 package os
diff --git a/src/os/sys_js.go b/src/os/sys_js.go
index e860654f81..4d6a64e8eb 100644
--- a/src/os/sys_js.go
+++ b/src/os/sys_js.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build js && wasm
 // +build js,wasm
 
 package os
diff --git a/src/os/sys_unix.go b/src/os/sys_unix.go
index 8491bad242..e316eaf06c 100644
--- a/src/os/sys_unix.go
+++ b/src/os/sys_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package os
diff --git a/src/os/timeout_test.go b/src/os/timeout_test.go
index 0a39f46333..6d65e420f0 100644
--- a/src/os/timeout_test.go
+++ b/src/os/timeout_test.go
@@ -2,9 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !js
-// +build !plan9
-// +build !windows
+//go:build !js && !plan9 && !windows
+// +build !js,!plan9,!windows
 
 package os_test
 
diff --git a/src/os/types_unix.go b/src/os/types_unix.go
index c0259ae0e8..e9b8b8ba3a 100644
--- a/src/os/types_unix.go
+++ b/src/os/types_unix.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !windows
-// +build !plan9
+//go:build !windows && !plan9
+// +build !windows,!plan9
 
 package os
 
diff --git a/src/os/user/cgo_lookup_unix.go b/src/os/user/cgo_lookup_unix.go
index 3307f790ea..abc9e9ce6d 100644
--- a/src/os/user/cgo_lookup_unix.go
+++ b/src/os/user/cgo_lookup_unix.go
@@ -2,8 +2,10 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (aix || darwin || dragonfly || freebsd || (!android && linux) || netbsd || openbsd || solaris) && cgo && !osusergo
 // +build aix darwin dragonfly freebsd !android,linux netbsd openbsd solaris
-// +build cgo,!osusergo
+// +build cgo
+// +build !osusergo
 
 package user
 
diff --git a/src/os/user/cgo_unix_test.go b/src/os/user/cgo_unix_test.go
index 1d341aa427..9ec32b3a78 100644
--- a/src/os/user/cgo_unix_test.go
+++ b/src/os/user/cgo_unix_test.go
@@ -2,8 +2,10 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (darwin || dragonfly || freebsd || (!android && linux) || netbsd || openbsd || solaris) && cgo && !osusergo
 // +build darwin dragonfly freebsd !android,linux netbsd openbsd solaris
-// +build cgo,!osusergo
+// +build cgo
+// +build !osusergo
 
 package user
 
diff --git a/src/os/user/getgrouplist_darwin.go b/src/os/user/getgrouplist_darwin.go
index e8fe26c47f..23d12e3247 100644
--- a/src/os/user/getgrouplist_darwin.go
+++ b/src/os/user/getgrouplist_darwin.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build cgo && !osusergo
 // +build cgo,!osusergo
 
 package user
diff --git a/src/os/user/getgrouplist_unix.go b/src/os/user/getgrouplist_unix.go
index 9685414fc0..8393c5a474 100644
--- a/src/os/user/getgrouplist_unix.go
+++ b/src/os/user/getgrouplist_unix.go
@@ -2,8 +2,10 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (dragonfly || freebsd || (!android && linux) || netbsd || openbsd) && cgo && !osusergo
 // +build dragonfly freebsd !android,linux netbsd openbsd
-// +build cgo,!osusergo
+// +build cgo
+// +build !osusergo
 
 package user
 
diff --git a/src/os/user/listgroups_aix.go b/src/os/user/listgroups_aix.go
index 17de3e98d4..d2fdfdc6b1 100644
--- a/src/os/user/listgroups_aix.go
+++ b/src/os/user/listgroups_aix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build cgo && !osusergo
 // +build cgo,!osusergo
 
 package user
diff --git a/src/os/user/listgroups_solaris.go b/src/os/user/listgroups_solaris.go
index f3cbf6ce4a..d993d30570 100644
--- a/src/os/user/listgroups_solaris.go
+++ b/src/os/user/listgroups_solaris.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build cgo && !osusergo
 // +build cgo,!osusergo
 
 // Even though this file requires no C, it is used to provide a
diff --git a/src/os/user/listgroups_unix.go b/src/os/user/listgroups_unix.go
index 70f7af7f97..c7b72062d5 100644
--- a/src/os/user/listgroups_unix.go
+++ b/src/os/user/listgroups_unix.go
@@ -2,8 +2,10 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (dragonfly || darwin || freebsd || (!android && linux) || netbsd || openbsd) && cgo && !osusergo
 // +build dragonfly darwin freebsd !android,linux netbsd openbsd
-// +build cgo,!osusergo
+// +build cgo
+// +build !osusergo
 
 package user
 
diff --git a/src/os/user/lookup_android.go b/src/os/user/lookup_android.go
index 8ca30b8c27..151aab49c2 100644
--- a/src/os/user/lookup_android.go
+++ b/src/os/user/lookup_android.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build android
 // +build android
 
 package user
diff --git a/src/os/user/lookup_stubs.go b/src/os/user/lookup_stubs.go
index 178d814dda..c975a11964 100644
--- a/src/os/user/lookup_stubs.go
+++ b/src/os/user/lookup_stubs.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (!cgo && !windows && !plan9) || android || (osusergo && !windows && !plan9)
 // +build !cgo,!windows,!plan9 android osusergo,!windows,!plan9
 
 package user
diff --git a/src/os/user/lookup_unix.go b/src/os/user/lookup_unix.go
index 0890cd8f2b..ed8c2dee9d 100644
--- a/src/os/user/lookup_unix.go
+++ b/src/os/user/lookup_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (aix || darwin || dragonfly || freebsd || (js && wasm) || (!android && linux) || netbsd || openbsd || solaris) && (!cgo || osusergo)
 // +build aix darwin dragonfly freebsd js,wasm !android,linux netbsd openbsd solaris
 // +build !cgo osusergo
 
diff --git a/src/os/user/lookup_unix_test.go b/src/os/user/lookup_unix_test.go
index 72d3b47534..c697802171 100644
--- a/src/os/user/lookup_unix_test.go
+++ b/src/os/user/lookup_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (aix || darwin || dragonfly || freebsd || (!android && linux) || netbsd || openbsd || solaris) && !cgo
 // +build aix darwin dragonfly freebsd !android,linux netbsd openbsd solaris
 // +build !cgo
 
diff --git a/src/os/wait_unimp.go b/src/os/wait_unimp.go
index 0f4cdc4533..28dc2a5939 100644
--- a/src/os/wait_unimp.go
+++ b/src/os/wait_unimp.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || (js && wasm) || netbsd || openbsd || solaris
 // +build aix darwin dragonfly js,wasm netbsd openbsd solaris
 
 package os
diff --git a/src/os/wait_wait6.go b/src/os/wait_wait6.go
index 5420b2db73..895f21069a 100644
--- a/src/os/wait_wait6.go
+++ b/src/os/wait_wait6.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build freebsd
 // +build freebsd
 
 package os
diff --git a/src/os/wait_waitid.go b/src/os/wait_waitid.go
index 9c56eb2d41..1f3cb1cfe2 100644
--- a/src/os/wait_waitid.go
+++ b/src/os/wait_waitid.go
@@ -5,6 +5,7 @@
 // We used to used this code for Darwin, but according to issue #19314
 // waitid returns if the process is stopped, even when using WEXITED.
 
+//go:build linux
 // +build linux
 
 package os
diff --git a/src/path/filepath/example_unix_test.go b/src/path/filepath/example_unix_test.go
index c9d6944518..4ce10095e6 100644
--- a/src/path/filepath/example_unix_test.go
+++ b/src/path/filepath/example_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !windows && !plan9
 // +build !windows,!plan9
 
 package filepath_test
diff --git a/src/path/filepath/example_unix_walk_test.go b/src/path/filepath/example_unix_walk_test.go
index c8a818fd6e..d72efcebe6 100644
--- a/src/path/filepath/example_unix_walk_test.go
+++ b/src/path/filepath/example_unix_walk_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !windows && !plan9
 // +build !windows,!plan9
 
 package filepath_test
diff --git a/src/path/filepath/path_unix.go b/src/path/filepath/path_unix.go
index ec497d9e26..d4b6f967a3 100644
--- a/src/path/filepath/path_unix.go
+++ b/src/path/filepath/path_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris
 
 package filepath
diff --git a/src/path/filepath/symlink_unix.go b/src/path/filepath/symlink_unix.go
index d20e63a987..657945a81a 100644
--- a/src/path/filepath/symlink_unix.go
+++ b/src/path/filepath/symlink_unix.go
@@ -1,3 +1,4 @@
+//go:build !windows
 // +build !windows
 
 package filepath
diff --git a/src/plugin/plugin_dlopen.go b/src/plugin/plugin_dlopen.go
index 9200fdc3cb..aa85d4831c 100644
--- a/src/plugin/plugin_dlopen.go
+++ b/src/plugin/plugin_dlopen.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (linux && cgo) || (darwin && cgo) || (freebsd && cgo)
 // +build linux,cgo darwin,cgo freebsd,cgo
 
 package plugin
diff --git a/src/plugin/plugin_stubs.go b/src/plugin/plugin_stubs.go
index 1893203017..67855bed4b 100644
--- a/src/plugin/plugin_stubs.go
+++ b/src/plugin/plugin_stubs.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (!linux && !freebsd && !darwin) || !cgo
 // +build !linux,!freebsd,!darwin !cgo
 
 package plugin
diff --git a/src/plugin/plugin_test.go b/src/plugin/plugin_test.go
index 30b79edaad..4ce912132c 100644
--- a/src/plugin/plugin_test.go
+++ b/src/plugin/plugin_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !linux || (linux && !arm64)
 // +build !linux linux,!arm64
 
 package plugin_test
diff --git a/src/regexp/exec2_test.go b/src/regexp/exec2_test.go
index 7b86b41156..6444bc12f9 100644
--- a/src/regexp/exec2_test.go
+++ b/src/regexp/exec2_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !race
 // +build !race
 
 package regexp
diff --git a/src/runtime/auxv_none.go b/src/runtime/auxv_none.go
index 3ca617b21e..3178f1a154 100644
--- a/src/runtime/auxv_none.go
+++ b/src/runtime/auxv_none.go
@@ -2,12 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !linux
-// +build !darwin
-// +build !dragonfly
-// +build !freebsd
-// +build !netbsd
-// +build !solaris
+//go:build !linux && !darwin && !dragonfly && !freebsd && !netbsd && !solaris
+// +build !linux,!darwin,!dragonfly,!freebsd,!netbsd,!solaris
 
 package runtime
 
diff --git a/src/runtime/cgo/callbacks_traceback.go b/src/runtime/cgo/callbacks_traceback.go
index cdadf9e66f..7302c1eedf 100644
--- a/src/runtime/cgo/callbacks_traceback.go
+++ b/src/runtime/cgo/callbacks_traceback.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || linux
 // +build darwin linux
 
 package cgo
diff --git a/src/runtime/cgo/dragonfly.go b/src/runtime/cgo/dragonfly.go
index d6d69187b8..cfa6fe86e2 100644
--- a/src/runtime/cgo/dragonfly.go
+++ b/src/runtime/cgo/dragonfly.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly
 // +build dragonfly
 
 package cgo
diff --git a/src/runtime/cgo/freebsd.go b/src/runtime/cgo/freebsd.go
index 5c9ddbdc71..d56702ec70 100644
--- a/src/runtime/cgo/freebsd.go
+++ b/src/runtime/cgo/freebsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build freebsd
 // +build freebsd
 
 package cgo
diff --git a/src/runtime/cgo/linux.go b/src/runtime/cgo/linux.go
index 76c0192c20..070d531bee 100644
--- a/src/runtime/cgo/linux.go
+++ b/src/runtime/cgo/linux.go
@@ -5,6 +5,7 @@
 // Linux system call wrappers that provide POSIX semantics through the
 // corresponding cgo->libc (nptl) wrappers for various system calls.
 
+//go:build linux
 // +build linux
 
 package cgo
diff --git a/src/runtime/cgo/mmap.go b/src/runtime/cgo/mmap.go
index 00fb7fced6..347ae6b363 100644
--- a/src/runtime/cgo/mmap.go
+++ b/src/runtime/cgo/mmap.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (linux && amd64) || (linux && arm64)
 // +build linux,amd64 linux,arm64
 
 package cgo
diff --git a/src/runtime/cgo/netbsd.go b/src/runtime/cgo/netbsd.go
index 74d0aed014..7e17d1fcd2 100644
--- a/src/runtime/cgo/netbsd.go
+++ b/src/runtime/cgo/netbsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build netbsd
 // +build netbsd
 
 package cgo
diff --git a/src/runtime/cgo/openbsd.go b/src/runtime/cgo/openbsd.go
index 81c73bf399..f6215613c3 100644
--- a/src/runtime/cgo/openbsd.go
+++ b/src/runtime/cgo/openbsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build openbsd
 // +build openbsd
 
 package cgo
diff --git a/src/runtime/cgo/setenv.go b/src/runtime/cgo/setenv.go
index 6495fcb5f8..e6e8040ae0 100644
--- a/src/runtime/cgo/setenv.go
+++ b/src/runtime/cgo/setenv.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package cgo
diff --git a/src/runtime/cgo/sigaction.go b/src/runtime/cgo/sigaction.go
index 076fbc1a0a..ee63ea4c09 100644
--- a/src/runtime/cgo/sigaction.go
+++ b/src/runtime/cgo/sigaction.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (linux && amd64) || (freebsd && amd64) || (linux && arm64)
 // +build linux,amd64 freebsd,amd64 linux,arm64
 
 package cgo
diff --git a/src/runtime/cgo_mmap.go b/src/runtime/cgo_mmap.go
index d5e0cc1e3e..17d26b4cc8 100644
--- a/src/runtime/cgo_mmap.go
+++ b/src/runtime/cgo_mmap.go
@@ -4,6 +4,7 @@
 
 // Support for memory sanitizer. See runtime/cgo/mmap.go.
 
+//go:build (linux && amd64) || (linux && arm64)
 // +build linux,amd64 linux,arm64
 
 package runtime
diff --git a/src/runtime/cgo_ppc64x.go b/src/runtime/cgo_ppc64x.go
index fb2da32c7e..4dc92ea321 100644
--- a/src/runtime/cgo_ppc64x.go
+++ b/src/runtime/cgo_ppc64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 package runtime
diff --git a/src/runtime/cgo_sigaction.go b/src/runtime/cgo_sigaction.go
index de634dc957..15690ecb0b 100644
--- a/src/runtime/cgo_sigaction.go
+++ b/src/runtime/cgo_sigaction.go
@@ -4,6 +4,7 @@
 
 // Support for memory sanitizer. See runtime/cgo/sigaction.go.
 
+//go:build (linux && amd64) || (freebsd && amd64) || (linux && arm64)
 // +build linux,amd64 freebsd,amd64 linux,arm64
 
 package runtime
diff --git a/src/runtime/cputicks.go b/src/runtime/cputicks.go
index 7beb57ea12..7c926f4a2b 100644
--- a/src/runtime/cputicks.go
+++ b/src/runtime/cputicks.go
@@ -2,13 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !arm
-// +build !arm64
-// +build !mips64
-// +build !mips64le
-// +build !mips
-// +build !mipsle
-// +build !wasm
+//go:build !arm && !arm64 && !mips64 && !mips64le && !mips && !mipsle && !wasm
+// +build !arm,!arm64,!mips64,!mips64le,!mips,!mipsle,!wasm
 
 package runtime
 
diff --git a/src/runtime/crash_cgo_test.go b/src/runtime/crash_cgo_test.go
index 140c170ddc..7d25c51aa2 100644
--- a/src/runtime/crash_cgo_test.go
+++ b/src/runtime/crash_cgo_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build cgo
 // +build cgo
 
 package runtime_test
diff --git a/src/runtime/crash_nonunix_test.go b/src/runtime/crash_nonunix_test.go
index 06c197ec2b..5f61476f21 100644
--- a/src/runtime/crash_nonunix_test.go
+++ b/src/runtime/crash_nonunix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build windows || plan9 || (js && wasm)
 // +build windows plan9 js,wasm
 
 package runtime_test
diff --git a/src/runtime/crash_unix_test.go b/src/runtime/crash_unix_test.go
index 803b031873..341c35ca56 100644
--- a/src/runtime/crash_unix_test.go
+++ b/src/runtime/crash_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package runtime_test
diff --git a/src/runtime/debug/panic_test.go b/src/runtime/debug/panic_test.go
index b67a3de4f9..b93631e1d8 100644
--- a/src/runtime/debug/panic_test.go
+++ b/src/runtime/debug/panic_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd
 // +build aix darwin dragonfly freebsd linux netbsd openbsd
 
 // TODO: test on Windows?
diff --git a/src/runtime/debug_test.go b/src/runtime/debug_test.go
index a0b3f84382..c4c41f95f2 100644
--- a/src/runtime/debug_test.go
+++ b/src/runtime/debug_test.go
@@ -9,9 +9,8 @@
 // spends all of its time in the race runtime, which isn't a safe
 // point.
 
-// +build amd64
-// +build linux
-// +build !race
+//go:build amd64 && linux && !race
+// +build amd64,linux,!race
 
 package runtime_test
 
diff --git a/src/runtime/debugcall.go b/src/runtime/debugcall.go
index efc68a767d..2fe0b1d12f 100644
--- a/src/runtime/debugcall.go
+++ b/src/runtime/debugcall.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build amd64
 // +build amd64
 
 package runtime
diff --git a/src/runtime/debuglog_off.go b/src/runtime/debuglog_off.go
index bb3e172498..dd38156999 100644
--- a/src/runtime/debuglog_off.go
+++ b/src/runtime/debuglog_off.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !debuglog
 // +build !debuglog
 
 package runtime
diff --git a/src/runtime/debuglog_on.go b/src/runtime/debuglog_on.go
index 3d477e8ef5..2fcdbe70d1 100644
--- a/src/runtime/debuglog_on.go
+++ b/src/runtime/debuglog_on.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build debuglog
 // +build debuglog
 
 package runtime
diff --git a/src/runtime/defs1_linux.go b/src/runtime/defs1_linux.go
index 4085d6f418..df9c05dd5e 100644
--- a/src/runtime/defs1_linux.go
+++ b/src/runtime/defs1_linux.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/runtime/defs2_linux.go b/src/runtime/defs2_linux.go
index 87e19c1598..d016db7d02 100644
--- a/src/runtime/defs2_linux.go
+++ b/src/runtime/defs2_linux.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/runtime/defs3_linux.go b/src/runtime/defs3_linux.go
index 31f2191c76..0a06aa2370 100644
--- a/src/runtime/defs3_linux.go
+++ b/src/runtime/defs3_linux.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/runtime/defs_aix.go b/src/runtime/defs_aix.go
index 23a6cac2bb..1605002ea2 100644
--- a/src/runtime/defs_aix.go
+++ b/src/runtime/defs_aix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/runtime/defs_aix_ppc64.go b/src/runtime/defs_aix_ppc64.go
index a53fcc5933..f84ff1160d 100644
--- a/src/runtime/defs_aix_ppc64.go
+++ b/src/runtime/defs_aix_ppc64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix
 // +build aix
 
 package runtime
diff --git a/src/runtime/defs_arm_linux.go b/src/runtime/defs_arm_linux.go
index e51dd32b5b..f6b6dd2c09 100644
--- a/src/runtime/defs_arm_linux.go
+++ b/src/runtime/defs_arm_linux.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/runtime/defs_darwin.go b/src/runtime/defs_darwin.go
index cc8c475387..2d41a97b57 100644
--- a/src/runtime/defs_darwin.go
+++ b/src/runtime/defs_darwin.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/runtime/defs_dragonfly.go b/src/runtime/defs_dragonfly.go
index 95014fe6e7..225258901f 100644
--- a/src/runtime/defs_dragonfly.go
+++ b/src/runtime/defs_dragonfly.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/runtime/defs_freebsd.go b/src/runtime/defs_freebsd.go
index e196dff076..c258759549 100644
--- a/src/runtime/defs_freebsd.go
+++ b/src/runtime/defs_freebsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/runtime/defs_linux.go b/src/runtime/defs_linux.go
index 7b14063386..022ef19427 100644
--- a/src/runtime/defs_linux.go
+++ b/src/runtime/defs_linux.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/runtime/defs_linux_mips64x.go b/src/runtime/defs_linux_mips64x.go
index 1fb423b198..2cafad20cf 100644
--- a/src/runtime/defs_linux_mips64x.go
+++ b/src/runtime/defs_linux_mips64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (mips64 || mips64le) && linux
 // +build mips64 mips64le
 // +build linux
 
diff --git a/src/runtime/defs_linux_mipsx.go b/src/runtime/defs_linux_mipsx.go
index 9315ba9346..3a8dfe2e99 100644
--- a/src/runtime/defs_linux_mipsx.go
+++ b/src/runtime/defs_linux_mipsx.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (mips || mipsle) && linux
 // +build mips mipsle
 // +build linux
 
diff --git a/src/runtime/defs_netbsd.go b/src/runtime/defs_netbsd.go
index 3f5ce5adca..755992d18e 100644
--- a/src/runtime/defs_netbsd.go
+++ b/src/runtime/defs_netbsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/runtime/defs_netbsd_386.go b/src/runtime/defs_netbsd_386.go
index c26f246077..03c9c2de59 100644
--- a/src/runtime/defs_netbsd_386.go
+++ b/src/runtime/defs_netbsd_386.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/runtime/defs_netbsd_amd64.go b/src/runtime/defs_netbsd_amd64.go
index f18a7b1fe3..9fda1d7d22 100644
--- a/src/runtime/defs_netbsd_amd64.go
+++ b/src/runtime/defs_netbsd_amd64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/runtime/defs_netbsd_arm.go b/src/runtime/defs_netbsd_arm.go
index cb0dce66b4..e7f4f6cece 100644
--- a/src/runtime/defs_netbsd_arm.go
+++ b/src/runtime/defs_netbsd_arm.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/runtime/defs_openbsd.go b/src/runtime/defs_openbsd.go
index ff7e21c71e..8d323449d1 100644
--- a/src/runtime/defs_openbsd.go
+++ b/src/runtime/defs_openbsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/runtime/defs_solaris.go b/src/runtime/defs_solaris.go
index 22df59094d..e644f9c6dd 100644
--- a/src/runtime/defs_solaris.go
+++ b/src/runtime/defs_solaris.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/runtime/defs_solaris_amd64.go b/src/runtime/defs_solaris_amd64.go
index 0493178880..a0b38319a5 100644
--- a/src/runtime/defs_solaris_amd64.go
+++ b/src/runtime/defs_solaris_amd64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/runtime/env_posix.go b/src/runtime/env_posix.go
index af353bbcd9..95517b2a95 100644
--- a/src/runtime/env_posix.go
+++ b/src/runtime/env_posix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris || windows || plan9
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris windows plan9
 
 package runtime
diff --git a/src/runtime/export_debug_test.go b/src/runtime/export_debug_test.go
index ed4242ef24..18ccecd5cd 100644
--- a/src/runtime/export_debug_test.go
+++ b/src/runtime/export_debug_test.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build amd64
-// +build linux
+//go:build amd64 && linux
+// +build amd64,linux
 
 package runtime
 
diff --git a/src/runtime/export_futex_test.go b/src/runtime/export_futex_test.go
index a727a93114..34c970d6d2 100644
--- a/src/runtime/export_futex_test.go
+++ b/src/runtime/export_futex_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly || freebsd || linux
 // +build dragonfly freebsd linux
 
 package runtime
diff --git a/src/runtime/export_mmap_test.go b/src/runtime/export_mmap_test.go
index aeaf37f64b..bf4a815899 100644
--- a/src/runtime/export_mmap_test.go
+++ b/src/runtime/export_mmap_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 // Export guts for testing.
diff --git a/src/runtime/export_pipe2_test.go b/src/runtime/export_pipe2_test.go
index 9d580d3313..31c8e43b3f 100644
--- a/src/runtime/export_pipe2_test.go
+++ b/src/runtime/export_pipe2_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build freebsd || linux || netbsd || openbsd || solaris
 // +build freebsd linux netbsd openbsd solaris
 
 package runtime
diff --git a/src/runtime/export_pipe_test.go b/src/runtime/export_pipe_test.go
index 8f66770fb9..82032e6bfb 100644
--- a/src/runtime/export_pipe_test.go
+++ b/src/runtime/export_pipe_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly
 // +build aix darwin dragonfly
 
 package runtime
diff --git a/src/runtime/export_unix_test.go b/src/runtime/export_unix_test.go
index 307c63fd68..215e234286 100644
--- a/src/runtime/export_unix_test.go
+++ b/src/runtime/export_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package runtime
diff --git a/src/runtime/futex_test.go b/src/runtime/futex_test.go
index 3051bd5880..10a735327a 100644
--- a/src/runtime/futex_test.go
+++ b/src/runtime/futex_test.go
@@ -6,6 +6,7 @@
 // The race detector emits calls to split stack functions so it breaks
 // the test.
 
+//go:build (dragonfly || freebsd || linux) && !race
 // +build dragonfly freebsd linux
 // +build !race
 
diff --git a/src/runtime/hash32.go b/src/runtime/hash32.go
index 966f70e1aa..7fa8eb7cab 100644
--- a/src/runtime/hash32.go
+++ b/src/runtime/hash32.go
@@ -6,6 +6,7 @@
 //   xxhash: https://code.google.com/p/xxhash/
 // cityhash: https://code.google.com/p/cityhash/
 
+//go:build 386 || arm || mips || mipsle
 // +build 386 arm mips mipsle
 
 package runtime
diff --git a/src/runtime/hash64.go b/src/runtime/hash64.go
index d1283824ad..1bee666bd7 100644
--- a/src/runtime/hash64.go
+++ b/src/runtime/hash64.go
@@ -6,6 +6,7 @@
 //   xxhash: https://code.google.com/p/xxhash/
 // cityhash: https://code.google.com/p/cityhash/
 
+//go:build amd64 || arm64 || mips64 || mips64le || ppc64 || ppc64le || riscv64 || s390x || wasm
 // +build amd64 arm64 mips64 mips64le ppc64 ppc64le riscv64 s390x wasm
 
 package runtime
diff --git a/src/runtime/internal/atomic/atomic_386.go b/src/runtime/internal/atomic/atomic_386.go
index 1bfcb1143d..d4aed6b671 100644
--- a/src/runtime/internal/atomic/atomic_386.go
+++ b/src/runtime/internal/atomic/atomic_386.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build 386
 // +build 386
 
 package atomic
diff --git a/src/runtime/internal/atomic/atomic_arm.go b/src/runtime/internal/atomic/atomic_arm.go
index 546b3d6120..2e9374ca26 100644
--- a/src/runtime/internal/atomic/atomic_arm.go
+++ b/src/runtime/internal/atomic/atomic_arm.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build arm
 // +build arm
 
 package atomic
diff --git a/src/runtime/internal/atomic/atomic_arm64.go b/src/runtime/internal/atomic/atomic_arm64.go
index d49bee8936..131c687e1b 100644
--- a/src/runtime/internal/atomic/atomic_arm64.go
+++ b/src/runtime/internal/atomic/atomic_arm64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build arm64
 // +build arm64
 
 package atomic
diff --git a/src/runtime/internal/atomic/atomic_mips64x.go b/src/runtime/internal/atomic/atomic_mips64x.go
index b0109d72b0..5b407ebc7a 100644
--- a/src/runtime/internal/atomic/atomic_mips64x.go
+++ b/src/runtime/internal/atomic/atomic_mips64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips64 || mips64le
 // +build mips64 mips64le
 
 package atomic
diff --git a/src/runtime/internal/atomic/atomic_mipsx.go b/src/runtime/internal/atomic/atomic_mipsx.go
index 1336b50121..80cd65b333 100644
--- a/src/runtime/internal/atomic/atomic_mipsx.go
+++ b/src/runtime/internal/atomic/atomic_mipsx.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips || mipsle
 // +build mips mipsle
 
 // Export some functions via linkname to assembly in sync/atomic.
diff --git a/src/runtime/internal/atomic/atomic_ppc64x.go b/src/runtime/internal/atomic/atomic_ppc64x.go
index e4b109f0ec..98101e3287 100644
--- a/src/runtime/internal/atomic/atomic_ppc64x.go
+++ b/src/runtime/internal/atomic/atomic_ppc64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 package atomic
diff --git a/src/runtime/internal/atomic/stubs.go b/src/runtime/internal/atomic/stubs.go
index 62e30d1788..1275884b2f 100644
--- a/src/runtime/internal/atomic/stubs.go
+++ b/src/runtime/internal/atomic/stubs.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !wasm
 // +build !wasm
 
 package atomic
diff --git a/src/runtime/internal/sys/gengoos.go b/src/runtime/internal/sys/gengoos.go
index 9bbc48d94f..51f64a6e5c 100644
--- a/src/runtime/internal/sys/gengoos.go
+++ b/src/runtime/internal/sys/gengoos.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 package main
diff --git a/src/runtime/internal/sys/intrinsics.go b/src/runtime/internal/sys/intrinsics.go
index 3c8898236c..e76d8dd064 100644
--- a/src/runtime/internal/sys/intrinsics.go
+++ b/src/runtime/internal/sys/intrinsics.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !386
 // +build !386
 
 // TODO finish intrinsifying 386, deadcode the assembly, remove build tags, merge w/ intrinsics_common
diff --git a/src/runtime/internal/sys/intrinsics_stubs.go b/src/runtime/internal/sys/intrinsics_stubs.go
index 9cbf48216c..bf1494d48a 100644
--- a/src/runtime/internal/sys/intrinsics_stubs.go
+++ b/src/runtime/internal/sys/intrinsics_stubs.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build 386
 // +build 386
 
 package sys
diff --git a/src/runtime/internal/sys/zgoarch_386.go b/src/runtime/internal/sys/zgoarch_386.go
index c286d0df2b..98a2401bfe 100644
--- a/src/runtime/internal/sys/zgoarch_386.go
+++ b/src/runtime/internal/sys/zgoarch_386.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build 386
 // +build 386
 
 package sys
diff --git a/src/runtime/internal/sys/zgoarch_amd64.go b/src/runtime/internal/sys/zgoarch_amd64.go
index d21c1d7d2a..d8faa5c786 100644
--- a/src/runtime/internal/sys/zgoarch_amd64.go
+++ b/src/runtime/internal/sys/zgoarch_amd64.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build amd64
 // +build amd64
 
 package sys
diff --git a/src/runtime/internal/sys/zgoarch_arm.go b/src/runtime/internal/sys/zgoarch_arm.go
index 9085fb0ea8..b64a69c9b4 100644
--- a/src/runtime/internal/sys/zgoarch_arm.go
+++ b/src/runtime/internal/sys/zgoarch_arm.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build arm
 // +build arm
 
 package sys
diff --git a/src/runtime/internal/sys/zgoarch_arm64.go b/src/runtime/internal/sys/zgoarch_arm64.go
index ed7ef2ebcb..de6f85347b 100644
--- a/src/runtime/internal/sys/zgoarch_arm64.go
+++ b/src/runtime/internal/sys/zgoarch_arm64.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build arm64
 // +build arm64
 
 package sys
diff --git a/src/runtime/internal/sys/zgoarch_arm64be.go b/src/runtime/internal/sys/zgoarch_arm64be.go
index faf3111053..b762bb069f 100644
--- a/src/runtime/internal/sys/zgoarch_arm64be.go
+++ b/src/runtime/internal/sys/zgoarch_arm64be.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build arm64be
 // +build arm64be
 
 package sys
diff --git a/src/runtime/internal/sys/zgoarch_armbe.go b/src/runtime/internal/sys/zgoarch_armbe.go
index cb28301e0b..e5297e4b16 100644
--- a/src/runtime/internal/sys/zgoarch_armbe.go
+++ b/src/runtime/internal/sys/zgoarch_armbe.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build armbe
 // +build armbe
 
 package sys
diff --git a/src/runtime/internal/sys/zgoarch_mips.go b/src/runtime/internal/sys/zgoarch_mips.go
index 315dea1c84..b5f4ed390c 100644
--- a/src/runtime/internal/sys/zgoarch_mips.go
+++ b/src/runtime/internal/sys/zgoarch_mips.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build mips
 // +build mips
 
 package sys
diff --git a/src/runtime/internal/sys/zgoarch_mips64.go b/src/runtime/internal/sys/zgoarch_mips64.go
index 5258cbfbe7..73777cceb2 100644
--- a/src/runtime/internal/sys/zgoarch_mips64.go
+++ b/src/runtime/internal/sys/zgoarch_mips64.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build mips64
 // +build mips64
 
 package sys
diff --git a/src/runtime/internal/sys/zgoarch_mips64le.go b/src/runtime/internal/sys/zgoarch_mips64le.go
index 1721698518..0c81c36c09 100644
--- a/src/runtime/internal/sys/zgoarch_mips64le.go
+++ b/src/runtime/internal/sys/zgoarch_mips64le.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build mips64le
 // +build mips64le
 
 package sys
diff --git a/src/runtime/internal/sys/zgoarch_mips64p32.go b/src/runtime/internal/sys/zgoarch_mips64p32.go
index 44c4624da9..d63ce27d24 100644
--- a/src/runtime/internal/sys/zgoarch_mips64p32.go
+++ b/src/runtime/internal/sys/zgoarch_mips64p32.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build mips64p32
 // +build mips64p32
 
 package sys
diff --git a/src/runtime/internal/sys/zgoarch_mips64p32le.go b/src/runtime/internal/sys/zgoarch_mips64p32le.go
index eb63225430..2d577890b2 100644
--- a/src/runtime/internal/sys/zgoarch_mips64p32le.go
+++ b/src/runtime/internal/sys/zgoarch_mips64p32le.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build mips64p32le
 // +build mips64p32le
 
 package sys
diff --git a/src/runtime/internal/sys/zgoarch_mipsle.go b/src/runtime/internal/sys/zgoarch_mipsle.go
index e0ebfbf038..8af919d03a 100644
--- a/src/runtime/internal/sys/zgoarch_mipsle.go
+++ b/src/runtime/internal/sys/zgoarch_mipsle.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build mipsle
 // +build mipsle
 
 package sys
diff --git a/src/runtime/internal/sys/zgoarch_ppc.go b/src/runtime/internal/sys/zgoarch_ppc.go
index ef26aa3201..f6f12a5ddc 100644
--- a/src/runtime/internal/sys/zgoarch_ppc.go
+++ b/src/runtime/internal/sys/zgoarch_ppc.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build ppc
 // +build ppc
 
 package sys
diff --git a/src/runtime/internal/sys/zgoarch_ppc64.go b/src/runtime/internal/sys/zgoarch_ppc64.go
index 32c2d46d4c..a8379601f4 100644
--- a/src/runtime/internal/sys/zgoarch_ppc64.go
+++ b/src/runtime/internal/sys/zgoarch_ppc64.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build ppc64
 // +build ppc64
 
 package sys
diff --git a/src/runtime/internal/sys/zgoarch_ppc64le.go b/src/runtime/internal/sys/zgoarch_ppc64le.go
index 3a6e56763c..f2ec5dcba7 100644
--- a/src/runtime/internal/sys/zgoarch_ppc64le.go
+++ b/src/runtime/internal/sys/zgoarch_ppc64le.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build ppc64le
 // +build ppc64le
 
 package sys
diff --git a/src/runtime/internal/sys/zgoarch_riscv.go b/src/runtime/internal/sys/zgoarch_riscv.go
index d8f6b49093..83a3312f5f 100644
--- a/src/runtime/internal/sys/zgoarch_riscv.go
+++ b/src/runtime/internal/sys/zgoarch_riscv.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build riscv
 // +build riscv
 
 package sys
diff --git a/src/runtime/internal/sys/zgoarch_riscv64.go b/src/runtime/internal/sys/zgoarch_riscv64.go
index 0ba843b5ac..1dfcc84997 100644
--- a/src/runtime/internal/sys/zgoarch_riscv64.go
+++ b/src/runtime/internal/sys/zgoarch_riscv64.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build riscv64
 // +build riscv64
 
 package sys
diff --git a/src/runtime/internal/sys/zgoarch_s390.go b/src/runtime/internal/sys/zgoarch_s390.go
index 20a1b234a6..91aba5a0f6 100644
--- a/src/runtime/internal/sys/zgoarch_s390.go
+++ b/src/runtime/internal/sys/zgoarch_s390.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build s390
 // +build s390
 
 package sys
diff --git a/src/runtime/internal/sys/zgoarch_s390x.go b/src/runtime/internal/sys/zgoarch_s390x.go
index ffdda0c827..edce50234e 100644
--- a/src/runtime/internal/sys/zgoarch_s390x.go
+++ b/src/runtime/internal/sys/zgoarch_s390x.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build s390x
 // +build s390x
 
 package sys
diff --git a/src/runtime/internal/sys/zgoarch_sparc.go b/src/runtime/internal/sys/zgoarch_sparc.go
index b4949510d5..5ae9560ab0 100644
--- a/src/runtime/internal/sys/zgoarch_sparc.go
+++ b/src/runtime/internal/sys/zgoarch_sparc.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build sparc
 // +build sparc
 
 package sys
diff --git a/src/runtime/internal/sys/zgoarch_sparc64.go b/src/runtime/internal/sys/zgoarch_sparc64.go
index 0f6df411ce..e2a0134aff 100644
--- a/src/runtime/internal/sys/zgoarch_sparc64.go
+++ b/src/runtime/internal/sys/zgoarch_sparc64.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build sparc64
 // +build sparc64
 
 package sys
diff --git a/src/runtime/internal/sys/zgoarch_wasm.go b/src/runtime/internal/sys/zgoarch_wasm.go
index e69afb0cb3..52e85dea37 100644
--- a/src/runtime/internal/sys/zgoarch_wasm.go
+++ b/src/runtime/internal/sys/zgoarch_wasm.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build wasm
 // +build wasm
 
 package sys
diff --git a/src/runtime/internal/sys/zgoos_aix.go b/src/runtime/internal/sys/zgoos_aix.go
index 0631d02aa5..f3b907471f 100644
--- a/src/runtime/internal/sys/zgoos_aix.go
+++ b/src/runtime/internal/sys/zgoos_aix.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build aix
 // +build aix
 
 package sys
diff --git a/src/runtime/internal/sys/zgoos_android.go b/src/runtime/internal/sys/zgoos_android.go
index d356a40bec..e28baf7c48 100644
--- a/src/runtime/internal/sys/zgoos_android.go
+++ b/src/runtime/internal/sys/zgoos_android.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build android
 // +build android
 
 package sys
diff --git a/src/runtime/internal/sys/zgoos_darwin.go b/src/runtime/internal/sys/zgoos_darwin.go
index 6aa2db7e3a..3c7f7b543e 100644
--- a/src/runtime/internal/sys/zgoos_darwin.go
+++ b/src/runtime/internal/sys/zgoos_darwin.go
@@ -1,7 +1,7 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
-// +build !ios
-// +build darwin
+//go:build !ios && darwin
+// +build !ios,darwin
 
 package sys
 
diff --git a/src/runtime/internal/sys/zgoos_dragonfly.go b/src/runtime/internal/sys/zgoos_dragonfly.go
index 88ee1174f1..f844d29e2a 100644
--- a/src/runtime/internal/sys/zgoos_dragonfly.go
+++ b/src/runtime/internal/sys/zgoos_dragonfly.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build dragonfly
 // +build dragonfly
 
 package sys
diff --git a/src/runtime/internal/sys/zgoos_freebsd.go b/src/runtime/internal/sys/zgoos_freebsd.go
index 8de2ec0559..8999a2797a 100644
--- a/src/runtime/internal/sys/zgoos_freebsd.go
+++ b/src/runtime/internal/sys/zgoos_freebsd.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build freebsd
 // +build freebsd
 
 package sys
diff --git a/src/runtime/internal/sys/zgoos_hurd.go b/src/runtime/internal/sys/zgoos_hurd.go
index 183ccb02a1..a546488bf8 100644
--- a/src/runtime/internal/sys/zgoos_hurd.go
+++ b/src/runtime/internal/sys/zgoos_hurd.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build hurd
 // +build hurd
 
 package sys
diff --git a/src/runtime/internal/sys/zgoos_illumos.go b/src/runtime/internal/sys/zgoos_illumos.go
index d04134e1df..02a4ca06e8 100644
--- a/src/runtime/internal/sys/zgoos_illumos.go
+++ b/src/runtime/internal/sys/zgoos_illumos.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build illumos
 // +build illumos
 
 package sys
diff --git a/src/runtime/internal/sys/zgoos_ios.go b/src/runtime/internal/sys/zgoos_ios.go
index cf6e9d61f0..033eec623d 100644
--- a/src/runtime/internal/sys/zgoos_ios.go
+++ b/src/runtime/internal/sys/zgoos_ios.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build ios
 // +build ios
 
 package sys
diff --git a/src/runtime/internal/sys/zgoos_js.go b/src/runtime/internal/sys/zgoos_js.go
index 1d9279ab38..28226ad60a 100644
--- a/src/runtime/internal/sys/zgoos_js.go
+++ b/src/runtime/internal/sys/zgoos_js.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build js
 // +build js
 
 package sys
diff --git a/src/runtime/internal/sys/zgoos_linux.go b/src/runtime/internal/sys/zgoos_linux.go
index 0f718d704f..01546e4b9f 100644
--- a/src/runtime/internal/sys/zgoos_linux.go
+++ b/src/runtime/internal/sys/zgoos_linux.go
@@ -1,7 +1,7 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
-// +build !android
-// +build linux
+//go:build !android && linux
+// +build !android,linux
 
 package sys
 
diff --git a/src/runtime/internal/sys/zgoos_netbsd.go b/src/runtime/internal/sys/zgoos_netbsd.go
index 2ae149ff13..9d658b20ee 100644
--- a/src/runtime/internal/sys/zgoos_netbsd.go
+++ b/src/runtime/internal/sys/zgoos_netbsd.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build netbsd
 // +build netbsd
 
 package sys
diff --git a/src/runtime/internal/sys/zgoos_openbsd.go b/src/runtime/internal/sys/zgoos_openbsd.go
index 7d4d61e4ca..0f55454a95 100644
--- a/src/runtime/internal/sys/zgoos_openbsd.go
+++ b/src/runtime/internal/sys/zgoos_openbsd.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build openbsd
 // +build openbsd
 
 package sys
diff --git a/src/runtime/internal/sys/zgoos_plan9.go b/src/runtime/internal/sys/zgoos_plan9.go
index 30aec46df3..d0347464d6 100644
--- a/src/runtime/internal/sys/zgoos_plan9.go
+++ b/src/runtime/internal/sys/zgoos_plan9.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build plan9
 // +build plan9
 
 package sys
diff --git a/src/runtime/internal/sys/zgoos_solaris.go b/src/runtime/internal/sys/zgoos_solaris.go
index 4bb8c99bce..05c3007e2c 100644
--- a/src/runtime/internal/sys/zgoos_solaris.go
+++ b/src/runtime/internal/sys/zgoos_solaris.go
@@ -1,7 +1,7 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
-// +build !illumos
-// +build solaris
+//go:build !illumos && solaris
+// +build !illumos,solaris
 
 package sys
 
diff --git a/src/runtime/internal/sys/zgoos_windows.go b/src/runtime/internal/sys/zgoos_windows.go
index d1f4290204..7d07fa3a45 100644
--- a/src/runtime/internal/sys/zgoos_windows.go
+++ b/src/runtime/internal/sys/zgoos_windows.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build windows
 // +build windows
 
 package sys
diff --git a/src/runtime/internal/sys/zgoos_zos.go b/src/runtime/internal/sys/zgoos_zos.go
index d22be46fc0..d6e5b9b0cb 100644
--- a/src/runtime/internal/sys/zgoos_zos.go
+++ b/src/runtime/internal/sys/zgoos_zos.go
@@ -1,5 +1,6 @@
 // Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
 
+//go:build zos
 // +build zos
 
 package sys
diff --git a/src/runtime/lfstack_32bit.go b/src/runtime/lfstack_32bit.go
index f07ff1c06b..c00f0965bd 100644
--- a/src/runtime/lfstack_32bit.go
+++ b/src/runtime/lfstack_32bit.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build 386 || arm || mips || mipsle
 // +build 386 arm mips mipsle
 
 package runtime
diff --git a/src/runtime/lfstack_64bit.go b/src/runtime/lfstack_64bit.go
index 9d821b989e..4812dd1156 100644
--- a/src/runtime/lfstack_64bit.go
+++ b/src/runtime/lfstack_64bit.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build amd64 || arm64 || mips64 || mips64le || ppc64 || ppc64le || riscv64 || s390x || wasm
 // +build amd64 arm64 mips64 mips64le ppc64 ppc64le riscv64 s390x wasm
 
 package runtime
diff --git a/src/runtime/libfuzzer.go b/src/runtime/libfuzzer.go
index 0161955f09..578bce0414 100644
--- a/src/runtime/libfuzzer.go
+++ b/src/runtime/libfuzzer.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build libfuzzer
 // +build libfuzzer
 
 package runtime
diff --git a/src/runtime/lock_futex.go b/src/runtime/lock_futex.go
index 91467fdfae..017b481c64 100644
--- a/src/runtime/lock_futex.go
+++ b/src/runtime/lock_futex.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly || freebsd || linux
 // +build dragonfly freebsd linux
 
 package runtime
diff --git a/src/runtime/lock_js.go b/src/runtime/lock_js.go
index 14bdc76842..04e7e85c12 100644
--- a/src/runtime/lock_js.go
+++ b/src/runtime/lock_js.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build js && wasm
 // +build js,wasm
 
 package runtime
diff --git a/src/runtime/lock_sema.go b/src/runtime/lock_sema.go
index 671e524e45..3c0a7ca67e 100644
--- a/src/runtime/lock_sema.go
+++ b/src/runtime/lock_sema.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || netbsd || openbsd || plan9 || solaris || windows
 // +build aix darwin netbsd openbsd plan9 solaris windows
 
 package runtime
diff --git a/src/runtime/lockrank_off.go b/src/runtime/lockrank_off.go
index 7dcd8f5fe9..f3d2c00914 100644
--- a/src/runtime/lockrank_off.go
+++ b/src/runtime/lockrank_off.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !goexperiment.staticlockranking
 // +build !goexperiment.staticlockranking
 
 package runtime
diff --git a/src/runtime/lockrank_on.go b/src/runtime/lockrank_on.go
index 88ac95a004..702bf5f24c 100644
--- a/src/runtime/lockrank_on.go
+++ b/src/runtime/lockrank_on.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build goexperiment.staticlockranking
 // +build goexperiment.staticlockranking
 
 package runtime
diff --git a/src/runtime/mem_bsd.go b/src/runtime/mem_bsd.go
index bc672019fb..dcbb9a1d51 100644
--- a/src/runtime/mem_bsd.go
+++ b/src/runtime/mem_bsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly || freebsd || netbsd || openbsd || solaris
 // +build dragonfly freebsd netbsd openbsd solaris
 
 package runtime
diff --git a/src/runtime/mem_js.go b/src/runtime/mem_js.go
index 957ed36ffa..fe940360c0 100644
--- a/src/runtime/mem_js.go
+++ b/src/runtime/mem_js.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build js && wasm
 // +build js,wasm
 
 package runtime
diff --git a/src/runtime/mkduff.go b/src/runtime/mkduff.go
index ef297f073e..8632fe08a3 100644
--- a/src/runtime/mkduff.go
+++ b/src/runtime/mkduff.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // runtime·duffzero is a Duff's device for zeroing memory.
diff --git a/src/runtime/mkfastlog2table.go b/src/runtime/mkfastlog2table.go
index d650292394..8d78a3923a 100644
--- a/src/runtime/mkfastlog2table.go
+++ b/src/runtime/mkfastlog2table.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // fastlog2Table contains log2 approximations for 5 binary digits.
diff --git a/src/runtime/mkpreempt.go b/src/runtime/mkpreempt.go
index 1d614dd003..3069d6ed04 100644
--- a/src/runtime/mkpreempt.go
+++ b/src/runtime/mkpreempt.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // mkpreempt generates the asyncPreempt functions for each
diff --git a/src/runtime/mksizeclasses.go b/src/runtime/mksizeclasses.go
index b92d1fed5f..b4a117d343 100644
--- a/src/runtime/mksizeclasses.go
+++ b/src/runtime/mksizeclasses.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // Generate tables for small malloc size classes.
diff --git a/src/runtime/mmap.go b/src/runtime/mmap.go
index 1b1848b79e..7460eb3104 100644
--- a/src/runtime/mmap.go
+++ b/src/runtime/mmap.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !aix && !darwin && !js && (!linux || !amd64) && (!linux || !arm64) && !openbsd && !plan9 && !solaris && !windows
 // +build !aix
 // +build !darwin
 // +build !js
diff --git a/src/runtime/mpagealloc_32bit.go b/src/runtime/mpagealloc_32bit.go
index 331dadade9..fceb4e7a18 100644
--- a/src/runtime/mpagealloc_32bit.go
+++ b/src/runtime/mpagealloc_32bit.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build 386 || arm || mips || mipsle || wasm || (ios && arm64)
 // +build 386 arm mips mipsle wasm ios,arm64
 
 // wasm is a treated as a 32-bit architecture for the purposes of the page
diff --git a/src/runtime/mpagealloc_64bit.go b/src/runtime/mpagealloc_64bit.go
index ffacb46c18..16577346a7 100644
--- a/src/runtime/mpagealloc_64bit.go
+++ b/src/runtime/mpagealloc_64bit.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build amd64 || (!ios && arm64) || mips64 || mips64le || ppc64 || ppc64le || riscv64 || s390x
 // +build amd64 !ios,arm64 mips64 mips64le ppc64 ppc64le riscv64 s390x
 
 // See mpagealloc_32bit.go for why ios/arm64 is excluded here.
diff --git a/src/runtime/msan.go b/src/runtime/msan.go
index 6a5960b0a8..25aaf94e26 100644
--- a/src/runtime/msan.go
+++ b/src/runtime/msan.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build msan
 // +build msan
 
 package runtime
diff --git a/src/runtime/msan0.go b/src/runtime/msan0.go
index 374d13f30b..b1096a6750 100644
--- a/src/runtime/msan0.go
+++ b/src/runtime/msan0.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !msan
 // +build !msan
 
 // Dummy MSan support API, used when not built with -msan.
diff --git a/src/runtime/nbpipe_fcntl_libc_test.go b/src/runtime/nbpipe_fcntl_libc_test.go
index b38c58399b..076a722eb7 100644
--- a/src/runtime/nbpipe_fcntl_libc_test.go
+++ b/src/runtime/nbpipe_fcntl_libc_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || solaris
 // +build aix darwin solaris
 
 package runtime_test
diff --git a/src/runtime/nbpipe_fcntl_unix_test.go b/src/runtime/nbpipe_fcntl_unix_test.go
index 75acdb62dd..6d5e4ff021 100644
--- a/src/runtime/nbpipe_fcntl_unix_test.go
+++ b/src/runtime/nbpipe_fcntl_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly || freebsd || linux || netbsd || openbsd
 // +build dragonfly freebsd linux netbsd openbsd
 
 package runtime_test
diff --git a/src/runtime/nbpipe_pipe.go b/src/runtime/nbpipe_pipe.go
index 822b2944db..d92cf97217 100644
--- a/src/runtime/nbpipe_pipe.go
+++ b/src/runtime/nbpipe_pipe.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly
 // +build aix darwin dragonfly
 
 package runtime
diff --git a/src/runtime/nbpipe_pipe2.go b/src/runtime/nbpipe_pipe2.go
index e3639d99b1..f138d1f956 100644
--- a/src/runtime/nbpipe_pipe2.go
+++ b/src/runtime/nbpipe_pipe2.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build freebsd || linux || netbsd || openbsd || solaris
 // +build freebsd linux netbsd openbsd solaris
 
 package runtime
diff --git a/src/runtime/nbpipe_test.go b/src/runtime/nbpipe_test.go
index d739f57864..1d6a9b525c 100644
--- a/src/runtime/nbpipe_test.go
+++ b/src/runtime/nbpipe_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package runtime_test
diff --git a/src/runtime/netpoll.go b/src/runtime/netpoll.go
index 77eb3aa4c6..afb208a455 100644
--- a/src/runtime/netpoll.go
+++ b/src/runtime/netpoll.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris || windows
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris windows
 
 package runtime
diff --git a/src/runtime/netpoll_epoll.go b/src/runtime/netpoll_epoll.go
index 58f4fa8754..371ac59f8e 100644
--- a/src/runtime/netpoll_epoll.go
+++ b/src/runtime/netpoll_epoll.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux
 // +build linux
 
 package runtime
diff --git a/src/runtime/netpoll_fake.go b/src/runtime/netpoll_fake.go
index b2af3b89b2..8366f28914 100644
--- a/src/runtime/netpoll_fake.go
+++ b/src/runtime/netpoll_fake.go
@@ -5,6 +5,7 @@
 // Fake network poller for wasm/js.
 // Should never be used, because wasm/js network connections do not honor "SetNonblock".
 
+//go:build js && wasm
 // +build js,wasm
 
 package runtime
diff --git a/src/runtime/netpoll_kqueue.go b/src/runtime/netpoll_kqueue.go
index 3bd93c1f20..80d1b0cf18 100644
--- a/src/runtime/netpoll_kqueue.go
+++ b/src/runtime/netpoll_kqueue.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || netbsd || openbsd
 // +build darwin dragonfly freebsd netbsd openbsd
 
 package runtime
diff --git a/src/runtime/netpoll_stub.go b/src/runtime/netpoll_stub.go
index 3599f2d01b..33ab8eba58 100644
--- a/src/runtime/netpoll_stub.go
+++ b/src/runtime/netpoll_stub.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build plan9
 // +build plan9
 
 package runtime
diff --git a/src/runtime/norace_linux_test.go b/src/runtime/norace_linux_test.go
index 3517a5ddbe..94b7c7a467 100644
--- a/src/runtime/norace_linux_test.go
+++ b/src/runtime/norace_linux_test.go
@@ -3,6 +3,7 @@
 // license that can be found in the LICENSE file.
 
 // The file contains tests that cannot run under race detector for some reason.
+//go:build !race
 // +build !race
 
 package runtime_test
diff --git a/src/runtime/norace_test.go b/src/runtime/norace_test.go
index e90128bb6d..9ad5dde382 100644
--- a/src/runtime/norace_test.go
+++ b/src/runtime/norace_test.go
@@ -3,6 +3,7 @@
 // license that can be found in the LICENSE file.
 
 // The file contains tests that cannot run under race detector for some reason.
+//go:build !race
 // +build !race
 
 package runtime_test
diff --git a/src/runtime/os_aix.go b/src/runtime/os_aix.go
index 303f0876de..557b17cc75 100644
--- a/src/runtime/os_aix.go
+++ b/src/runtime/os_aix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix
 // +build aix
 
 package runtime
diff --git a/src/runtime/os_freebsd2.go b/src/runtime/os_freebsd2.go
index 6947a05d04..fde6fbf1b1 100644
--- a/src/runtime/os_freebsd2.go
+++ b/src/runtime/os_freebsd2.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build freebsd && !amd64
 // +build freebsd,!amd64
 
 package runtime
diff --git a/src/runtime/os_freebsd_noauxv.go b/src/runtime/os_freebsd_noauxv.go
index 01efb9b7c9..8fe0cb6718 100644
--- a/src/runtime/os_freebsd_noauxv.go
+++ b/src/runtime/os_freebsd_noauxv.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build freebsd
-// +build !arm
+//go:build freebsd && !arm
+// +build freebsd,!arm
 
 package runtime
 
diff --git a/src/runtime/os_js.go b/src/runtime/os_js.go
index 5b2c53795a..52b64e7602 100644
--- a/src/runtime/os_js.go
+++ b/src/runtime/os_js.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build js && wasm
 // +build js,wasm
 
 package runtime
diff --git a/src/runtime/os_linux_arm64.go b/src/runtime/os_linux_arm64.go
index c5fd742048..5260f22f57 100644
--- a/src/runtime/os_linux_arm64.go
+++ b/src/runtime/os_linux_arm64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build arm64
 // +build arm64
 
 package runtime
diff --git a/src/runtime/os_linux_be64.go b/src/runtime/os_linux_be64.go
index 9860002ee4..806d02fee8 100644
--- a/src/runtime/os_linux_be64.go
+++ b/src/runtime/os_linux_be64.go
@@ -4,6 +4,7 @@
 
 // The standard GNU/Linux sigset type on big-endian 64-bit machines.
 
+//go:build linux && (ppc64 || s390x)
 // +build linux
 // +build ppc64 s390x
 
diff --git a/src/runtime/os_linux_generic.go b/src/runtime/os_linux_generic.go
index e1d0952ddf..fe1973dbde 100644
--- a/src/runtime/os_linux_generic.go
+++ b/src/runtime/os_linux_generic.go
@@ -2,13 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !mips
-// +build !mipsle
-// +build !mips64
-// +build !mips64le
-// +build !s390x
-// +build !ppc64
-// +build linux
+//go:build !mips && !mipsle && !mips64 && !mips64le && !s390x && !ppc64 && linux
+// +build !mips,!mipsle,!mips64,!mips64le,!s390x,!ppc64,linux
 
 package runtime
 
diff --git a/src/runtime/os_linux_mips64x.go b/src/runtime/os_linux_mips64x.go
index 815a83a04b..bd76442dbd 100644
--- a/src/runtime/os_linux_mips64x.go
+++ b/src/runtime/os_linux_mips64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (mips64 || mips64le)
 // +build linux
 // +build mips64 mips64le
 
diff --git a/src/runtime/os_linux_mipsx.go b/src/runtime/os_linux_mipsx.go
index 00fb02e4bf..ef8b3f7d43 100644
--- a/src/runtime/os_linux_mipsx.go
+++ b/src/runtime/os_linux_mipsx.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (mips || mipsle)
 // +build linux
 // +build mips mipsle
 
diff --git a/src/runtime/os_linux_noauxv.go b/src/runtime/os_linux_noauxv.go
index 895b4cd5f4..59b5aacaeb 100644
--- a/src/runtime/os_linux_noauxv.go
+++ b/src/runtime/os_linux_noauxv.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build linux
-// +build !arm,!arm64,!mips,!mipsle,!mips64,!mips64le,!s390x,!ppc64,!ppc64le
+//go:build linux && !arm && !arm64 && !mips && !mipsle && !mips64 && !mips64le && !s390x && !ppc64 && !ppc64le
+// +build linux,!arm,!arm64,!mips,!mipsle,!mips64,!mips64le,!s390x,!ppc64,!ppc64le
 
 package runtime
 
diff --git a/src/runtime/os_linux_novdso.go b/src/runtime/os_linux_novdso.go
index 155f415e71..8104f63627 100644
--- a/src/runtime/os_linux_novdso.go
+++ b/src/runtime/os_linux_novdso.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build linux
-// +build !386,!amd64,!arm,!arm64,!mips64,!mips64le,!ppc64,!ppc64le
+//go:build linux && !386 && !amd64 && !arm && !arm64 && !mips64 && !mips64le && !ppc64 && !ppc64le
+// +build linux,!386,!amd64,!arm,!arm64,!mips64,!mips64le,!ppc64,!ppc64le
 
 package runtime
 
diff --git a/src/runtime/os_linux_ppc64x.go b/src/runtime/os_linux_ppc64x.go
index 3aedc23ef9..c093d2ec0f 100644
--- a/src/runtime/os_linux_ppc64x.go
+++ b/src/runtime/os_linux_ppc64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (ppc64 || ppc64le)
 // +build linux
 // +build ppc64 ppc64le
 
diff --git a/src/runtime/os_linux_x86.go b/src/runtime/os_linux_x86.go
index d91fa1a0d1..5667774d82 100644
--- a/src/runtime/os_linux_x86.go
+++ b/src/runtime/os_linux_x86.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (386 || amd64)
 // +build linux
 // +build 386 amd64
 
diff --git a/src/runtime/os_nonopenbsd.go b/src/runtime/os_nonopenbsd.go
index e65697bdb3..6134b6c02f 100644
--- a/src/runtime/os_nonopenbsd.go
+++ b/src/runtime/os_nonopenbsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !openbsd
 // +build !openbsd
 
 package runtime
diff --git a/src/runtime/os_only_solaris.go b/src/runtime/os_only_solaris.go
index e2f5409354..3829683c80 100644
--- a/src/runtime/os_only_solaris.go
+++ b/src/runtime/os_only_solaris.go
@@ -4,6 +4,7 @@
 
 // Solaris code that doesn't also apply to illumos.
 
+//go:build !illumos
 // +build !illumos
 
 package runtime
diff --git a/src/runtime/os_openbsd_libc.go b/src/runtime/os_openbsd_libc.go
index 2edb0358b0..3f43ade558 100644
--- a/src/runtime/os_openbsd_libc.go
+++ b/src/runtime/os_openbsd_libc.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (openbsd && amd64) || (openbsd && arm64)
 // +build openbsd,amd64 openbsd,arm64
 
 package runtime
diff --git a/src/runtime/os_openbsd_syscall.go b/src/runtime/os_openbsd_syscall.go
index 16ff2b8e25..6facf31593 100644
--- a/src/runtime/os_openbsd_syscall.go
+++ b/src/runtime/os_openbsd_syscall.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build openbsd,!amd64
-// +build openbsd,!arm64
+//go:build openbsd && !amd64 && openbsd && !arm64
+// +build openbsd,!amd64,openbsd,!arm64
 
 package runtime
 
diff --git a/src/runtime/os_openbsd_syscall1.go b/src/runtime/os_openbsd_syscall1.go
index f37da04194..0f3d5f0b73 100644
--- a/src/runtime/os_openbsd_syscall1.go
+++ b/src/runtime/os_openbsd_syscall1.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build openbsd && !amd64 && !arm64
 // +build openbsd,!amd64,!arm64
 
 package runtime
diff --git a/src/runtime/os_openbsd_syscall2.go b/src/runtime/os_openbsd_syscall2.go
index 81cfb085aa..3b1707126b 100644
--- a/src/runtime/os_openbsd_syscall2.go
+++ b/src/runtime/os_openbsd_syscall2.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build openbsd && !amd64 && !arm64
 // +build openbsd,!amd64,!arm64
 
 package runtime
diff --git a/src/runtime/panic32.go b/src/runtime/panic32.go
index aea8401a37..acbdd1ff45 100644
--- a/src/runtime/panic32.go
+++ b/src/runtime/panic32.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build 386 || arm || mips || mipsle
 // +build 386 arm mips mipsle
 
 package runtime
diff --git a/src/runtime/pprof/mprof_test.go b/src/runtime/pprof/mprof_test.go
index c11a45fd69..3ef40d3de7 100644
--- a/src/runtime/pprof/mprof_test.go
+++ b/src/runtime/pprof/mprof_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js
 // +build !js
 
 package pprof
@@ -93,31 +94,31 @@ func TestMemoryProfiler(t *testing.T) {
 	}{{
 		stk: []string{"runtime/pprof.allocatePersistent1K", "runtime/pprof.TestMemoryProfiler"},
 		legacy: fmt.Sprintf(`%v: %v \[%v: %v\] @ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+
-#	0x[0-9,a-f]+	runtime/pprof\.allocatePersistent1K\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test\.go:47
-#	0x[0-9,a-f]+	runtime/pprof\.TestMemoryProfiler\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test\.go:82
+#	0x[0-9,a-f]+	runtime/pprof\.allocatePersistent1K\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test\.go:48
+#	0x[0-9,a-f]+	runtime/pprof\.TestMemoryProfiler\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test\.go:83
 `, 32*memoryProfilerRun, 1024*memoryProfilerRun, 32*memoryProfilerRun, 1024*memoryProfilerRun),
 	}, {
 		stk: []string{"runtime/pprof.allocateTransient1M", "runtime/pprof.TestMemoryProfiler"},
 		legacy: fmt.Sprintf(`0: 0 \[%v: %v\] @ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+
-#	0x[0-9,a-f]+	runtime/pprof\.allocateTransient1M\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test.go:24
-#	0x[0-9,a-f]+	runtime/pprof\.TestMemoryProfiler\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test.go:79
+#	0x[0-9,a-f]+	runtime/pprof\.allocateTransient1M\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test.go:25
+#	0x[0-9,a-f]+	runtime/pprof\.TestMemoryProfiler\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test.go:80
 `, (1<<10)*memoryProfilerRun, (1<<20)*memoryProfilerRun),
 	}, {
 		stk: []string{"runtime/pprof.allocateTransient2M", "runtime/pprof.TestMemoryProfiler"},
 		legacy: fmt.Sprintf(`0: 0 \[%v: %v\] @ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+
-#	0x[0-9,a-f]+	runtime/pprof\.allocateTransient2M\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test.go:30
-#	0x[0-9,a-f]+	runtime/pprof\.TestMemoryProfiler\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test.go:80
+#	0x[0-9,a-f]+	runtime/pprof\.allocateTransient2M\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test.go:31
+#	0x[0-9,a-f]+	runtime/pprof\.TestMemoryProfiler\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test.go:81
 `, memoryProfilerRun, (2<<20)*memoryProfilerRun),
 	}, {
 		stk: []string{"runtime/pprof.allocateTransient2MInline", "runtime/pprof.TestMemoryProfiler"},
 		legacy: fmt.Sprintf(`0: 0 \[%v: %v\] @ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+
-#	0x[0-9,a-f]+	runtime/pprof\.allocateTransient2MInline\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test.go:34
-#	0x[0-9,a-f]+	runtime/pprof\.TestMemoryProfiler\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test.go:81
+#	0x[0-9,a-f]+	runtime/pprof\.allocateTransient2MInline\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test.go:35
+#	0x[0-9,a-f]+	runtime/pprof\.TestMemoryProfiler\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test.go:82
 `, memoryProfilerRun, (2<<20)*memoryProfilerRun),
 	}, {
 		stk: []string{"runtime/pprof.allocateReflectTransient"},
 		legacy: fmt.Sprintf(`0: 0 \[%v: %v\] @( 0x[0-9,a-f]+)+
-#	0x[0-9,a-f]+	runtime/pprof\.allocateReflectTransient\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test.go:55
+#	0x[0-9,a-f]+	runtime/pprof\.allocateReflectTransient\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test.go:56
 `, memoryProfilerRun, (2<<20)*memoryProfilerRun),
 	}}
 
diff --git a/src/runtime/pprof/pprof_norusage.go b/src/runtime/pprof/pprof_norusage.go
index 6fdcc6cc38..e175dd380c 100644
--- a/src/runtime/pprof/pprof_norusage.go
+++ b/src/runtime/pprof/pprof_norusage.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !darwin && !linux
 // +build !darwin,!linux
 
 package pprof
diff --git a/src/runtime/pprof/pprof_rusage.go b/src/runtime/pprof/pprof_rusage.go
index 7954673811..269f21bc2f 100644
--- a/src/runtime/pprof/pprof_rusage.go
+++ b/src/runtime/pprof/pprof_rusage.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || linux
 // +build darwin linux
 
 package pprof
diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go
index 14321b0934..1b86dbff5b 100644
--- a/src/runtime/pprof/pprof_test.go
+++ b/src/runtime/pprof/pprof_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js
 // +build !js
 
 package pprof
diff --git a/src/runtime/preempt_nonwindows.go b/src/runtime/preempt_nonwindows.go
index 3066a1521e..365e86a611 100644
--- a/src/runtime/preempt_nonwindows.go
+++ b/src/runtime/preempt_nonwindows.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !windows
 // +build !windows
 
 package runtime
diff --git a/src/runtime/race.go b/src/runtime/race.go
index 79fd21765d..cc8c5db1bd 100644
--- a/src/runtime/race.go
+++ b/src/runtime/race.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build race
 // +build race
 
 package runtime
diff --git a/src/runtime/race/output_test.go b/src/runtime/race/output_test.go
index 17dc32013f..4a959d9aba 100644
--- a/src/runtime/race/output_test.go
+++ b/src/runtime/race/output_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build race
 // +build race
 
 package race_test
diff --git a/src/runtime/race/race.go b/src/runtime/race/race.go
index d6a14b79e7..fe50900ec8 100644
--- a/src/runtime/race/race.go
+++ b/src/runtime/race/race.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (race && linux && amd64) || (race && freebsd && amd64) || (race && netbsd && amd64) || (race && darwin && amd64) || (race && windows && amd64) || (race && linux && ppc64le) || (race && linux && arm64) || (race && darwin && arm64)
 // +build race,linux,amd64 race,freebsd,amd64 race,netbsd,amd64 race,darwin,amd64 race,windows,amd64 race,linux,ppc64le race,linux,arm64 race,darwin,arm64
 
 package race
diff --git a/src/runtime/race/race_linux_test.go b/src/runtime/race/race_linux_test.go
index c00ce4d3df..9c0d48d6bd 100644
--- a/src/runtime/race/race_linux_test.go
+++ b/src/runtime/race/race_linux_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && race
 // +build linux,race
 
 package race_test
diff --git a/src/runtime/race/race_test.go b/src/runtime/race/race_test.go
index d433af6bd0..8c880b8570 100644
--- a/src/runtime/race/race_test.go
+++ b/src/runtime/race/race_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build race
 // +build race
 
 // This program is used to verify the race detector
diff --git a/src/runtime/race/race_unix_test.go b/src/runtime/race/race_unix_test.go
index 84f0acece6..acd6e47f98 100644
--- a/src/runtime/race/race_unix_test.go
+++ b/src/runtime/race/race_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build race && (darwin || freebsd || linux)
 // +build race
 // +build darwin freebsd linux
 
diff --git a/src/runtime/race/race_windows_test.go b/src/runtime/race/race_windows_test.go
index 307a1ea6c0..e490d766dd 100644
--- a/src/runtime/race/race_windows_test.go
+++ b/src/runtime/race/race_windows_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build windows && race
 // +build windows,race
 
 package race_test
diff --git a/src/runtime/race/sched_test.go b/src/runtime/race/sched_test.go
index d6bb323cde..e904ebd20d 100644
--- a/src/runtime/race/sched_test.go
+++ b/src/runtime/race/sched_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build race
 // +build race
 
 package race_test
diff --git a/src/runtime/race/syso_test.go b/src/runtime/race/syso_test.go
index db846c5d2a..cbce5a8f18 100644
--- a/src/runtime/race/syso_test.go
+++ b/src/runtime/race/syso_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !android && !js && !ppc64le
 // +build !android,!js,!ppc64le
 
 // Note: we don't run on Android or ppc64 because if there is any non-race test
diff --git a/src/runtime/race/timer_test.go b/src/runtime/race/timer_test.go
index a6c34a8352..f11f8456a0 100644
--- a/src/runtime/race/timer_test.go
+++ b/src/runtime/race/timer_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build race
 // +build race
 
 package race_test
diff --git a/src/runtime/race0.go b/src/runtime/race0.go
index 180f707b1a..0e431b8103 100644
--- a/src/runtime/race0.go
+++ b/src/runtime/race0.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !race
 // +build !race
 
 // Dummy race detection API, used when not built with -race.
diff --git a/src/runtime/relax_stub.go b/src/runtime/relax_stub.go
index 81ed1291b8..5b92879c20 100644
--- a/src/runtime/relax_stub.go
+++ b/src/runtime/relax_stub.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !windows
 // +build !windows
 
 package runtime
diff --git a/src/runtime/runtime_mmap_test.go b/src/runtime/runtime_mmap_test.go
index bb0b747606..f71f8afa57 100644
--- a/src/runtime/runtime_mmap_test.go
+++ b/src/runtime/runtime_mmap_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package runtime_test
diff --git a/src/runtime/runtime_unix_test.go b/src/runtime/runtime_unix_test.go
index b0cbbbe3e6..0251c676e6 100644
--- a/src/runtime/runtime_unix_test.go
+++ b/src/runtime/runtime_unix_test.go
@@ -6,6 +6,7 @@
 // We need a fast system call to provoke the race,
 // and Close(-1) is nearly universally fast.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || plan9
 // +build aix darwin dragonfly freebsd linux netbsd openbsd plan9
 
 package runtime_test
diff --git a/src/runtime/semasleep_test.go b/src/runtime/semasleep_test.go
index 9b371b0732..905e932b7d 100644
--- a/src/runtime/semasleep_test.go
+++ b/src/runtime/semasleep_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !plan9 && !windows && !js
 // +build !plan9,!windows,!js
 
 package runtime_test
diff --git a/src/runtime/sigaction.go b/src/runtime/sigaction.go
index 3c888579d0..76f37b1b53 100644
--- a/src/runtime/sigaction.go
+++ b/src/runtime/sigaction.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (linux && !amd64 && !arm64) || (freebsd && !amd64)
 // +build linux,!amd64,!arm64 freebsd,!amd64
 
 package runtime
diff --git a/src/runtime/signal_386.go b/src/runtime/signal_386.go
index 065aff48d3..5824eaddb5 100644
--- a/src/runtime/signal_386.go
+++ b/src/runtime/signal_386.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly || freebsd || linux || netbsd || openbsd
 // +build dragonfly freebsd linux netbsd openbsd
 
 package runtime
diff --git a/src/runtime/signal_aix_ppc64.go b/src/runtime/signal_aix_ppc64.go
index c17563e2a5..a0becd431e 100644
--- a/src/runtime/signal_aix_ppc64.go
+++ b/src/runtime/signal_aix_ppc64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix
 // +build aix
 
 package runtime
diff --git a/src/runtime/signal_amd64.go b/src/runtime/signal_amd64.go
index 3eeb5e044f..e45fbb4a87 100644
--- a/src/runtime/signal_amd64.go
+++ b/src/runtime/signal_amd64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build amd64 && (darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris)
 // +build amd64
 // +build darwin dragonfly freebsd linux netbsd openbsd solaris
 
diff --git a/src/runtime/signal_arm.go b/src/runtime/signal_arm.go
index 156d9d384c..4d9c6224a2 100644
--- a/src/runtime/signal_arm.go
+++ b/src/runtime/signal_arm.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly || freebsd || linux || netbsd || openbsd
 // +build dragonfly freebsd linux netbsd openbsd
 
 package runtime
diff --git a/src/runtime/signal_arm64.go b/src/runtime/signal_arm64.go
index b559b93938..f04750084f 100644
--- a/src/runtime/signal_arm64.go
+++ b/src/runtime/signal_arm64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || freebsd || linux || netbsd || openbsd
 // +build darwin freebsd linux netbsd openbsd
 
 package runtime
diff --git a/src/runtime/signal_linux_mips64x.go b/src/runtime/signal_linux_mips64x.go
index b608197d60..f0a75ac3ea 100644
--- a/src/runtime/signal_linux_mips64x.go
+++ b/src/runtime/signal_linux_mips64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (mips64 || mips64le)
 // +build linux
 // +build mips64 mips64le
 
diff --git a/src/runtime/signal_linux_mipsx.go b/src/runtime/signal_linux_mipsx.go
index c88ac4d521..f3969c5aac 100644
--- a/src/runtime/signal_linux_mipsx.go
+++ b/src/runtime/signal_linux_mipsx.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (mips || mipsle)
 // +build linux
 // +build mips mipsle
 
diff --git a/src/runtime/signal_linux_ppc64x.go b/src/runtime/signal_linux_ppc64x.go
index 97cb26d587..d9d3e55ec2 100644
--- a/src/runtime/signal_linux_ppc64x.go
+++ b/src/runtime/signal_linux_ppc64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (ppc64 || ppc64le)
 // +build linux
 // +build ppc64 ppc64le
 
diff --git a/src/runtime/signal_mips64x.go b/src/runtime/signal_mips64x.go
index 2a347ff4cb..1616b57027 100644
--- a/src/runtime/signal_mips64x.go
+++ b/src/runtime/signal_mips64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (linux || openbsd) && (mips64 || mips64le)
 // +build linux openbsd
 // +build mips64 mips64le
 
diff --git a/src/runtime/signal_mipsx.go b/src/runtime/signal_mipsx.go
index 8c29f59bd1..dcc7f1e9dd 100644
--- a/src/runtime/signal_mipsx.go
+++ b/src/runtime/signal_mipsx.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (mips || mipsle)
 // +build linux
 // +build mips mipsle
 
diff --git a/src/runtime/signal_ppc64x.go b/src/runtime/signal_ppc64x.go
index 5de93a330a..f2225da9a1 100644
--- a/src/runtime/signal_ppc64x.go
+++ b/src/runtime/signal_ppc64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (aix || linux) && (ppc64 || ppc64le)
 // +build aix linux
 // +build ppc64 ppc64le
 
diff --git a/src/runtime/signal_riscv64.go b/src/runtime/signal_riscv64.go
index 93363a4746..e6b1b14130 100644
--- a/src/runtime/signal_riscv64.go
+++ b/src/runtime/signal_riscv64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && riscv64
 // +build linux,riscv64
 
 package runtime
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index 3f70707ab4..f2e526973d 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package runtime
diff --git a/src/runtime/signal_windows_test.go b/src/runtime/signal_windows_test.go
index 33a9b92ee7..05bc6f8e71 100644
--- a/src/runtime/signal_windows_test.go
+++ b/src/runtime/signal_windows_test.go
@@ -1,3 +1,4 @@
+//go:build windows
 // +build windows
 
 package runtime_test
diff --git a/src/runtime/sigqueue.go b/src/runtime/sigqueue.go
index 28b9e26d0f..a282c7aca7 100644
--- a/src/runtime/sigqueue.go
+++ b/src/runtime/sigqueue.go
@@ -28,6 +28,7 @@
 // unnecessary rechecks of sig.mask, but it cannot lead to missed signals
 // nor deadlocks.
 
+//go:build !plan9
 // +build !plan9
 
 package runtime
diff --git a/src/runtime/sigqueue_note.go b/src/runtime/sigqueue_note.go
index 16aeeb2ef0..e23446bea4 100644
--- a/src/runtime/sigqueue_note.go
+++ b/src/runtime/sigqueue_note.go
@@ -7,8 +7,8 @@
 // signal_recv thread. This file holds the non-Darwin implementations of
 // those functions. These functions will never be called.
 
-// +build !darwin
-// +build !plan9
+//go:build !darwin && !plan9
+// +build !darwin,!plan9
 
 package runtime
 
diff --git a/src/runtime/sigtab_linux_generic.go b/src/runtime/sigtab_linux_generic.go
index 38d686544f..dc1debddab 100644
--- a/src/runtime/sigtab_linux_generic.go
+++ b/src/runtime/sigtab_linux_generic.go
@@ -2,11 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !mips
-// +build !mipsle
-// +build !mips64
-// +build !mips64le
-// +build linux
+//go:build !mips && !mipsle && !mips64 && !mips64le && linux
+// +build !mips,!mipsle,!mips64,!mips64le,linux
 
 package runtime
 
diff --git a/src/runtime/sigtab_linux_mipsx.go b/src/runtime/sigtab_linux_mipsx.go
index 51ef470ce7..af9c7e56eb 100644
--- a/src/runtime/sigtab_linux_mipsx.go
+++ b/src/runtime/sigtab_linux_mipsx.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (mips || mipsle || mips64 || mips64le) && linux
 // +build mips mipsle mips64 mips64le
 // +build linux
 
diff --git a/src/runtime/stubs2.go b/src/runtime/stubs2.go
index 96096d236b..525b324c81 100644
--- a/src/runtime/stubs2.go
+++ b/src/runtime/stubs2.go
@@ -2,13 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !aix
-// +build !darwin
-// +build !js
-// +build !openbsd
-// +build !plan9
-// +build !solaris
-// +build !windows
+//go:build !aix && !darwin && !js && !openbsd && !plan9 && !solaris && !windows
+// +build !aix,!darwin,!js,!openbsd,!plan9,!solaris,!windows
 
 package runtime
 
diff --git a/src/runtime/stubs3.go b/src/runtime/stubs3.go
index 1885d32051..b895be4c70 100644
--- a/src/runtime/stubs3.go
+++ b/src/runtime/stubs3.go
@@ -2,12 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !aix
-// +build !darwin
-// +build !freebsd
-// +build !openbsd
-// +build !plan9
-// +build !solaris
+//go:build !aix && !darwin && !freebsd && !openbsd && !plan9 && !solaris
+// +build !aix,!darwin,!freebsd,!openbsd,!plan9,!solaris
 
 package runtime
 
diff --git a/src/runtime/stubs_linux.go b/src/runtime/stubs_linux.go
index e75fcf6c95..ba267009ca 100644
--- a/src/runtime/stubs_linux.go
+++ b/src/runtime/stubs_linux.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux
 // +build linux
 
 package runtime
diff --git a/src/runtime/stubs_mips64x.go b/src/runtime/stubs_mips64x.go
index 652e7a9e34..05a4d0d38d 100644
--- a/src/runtime/stubs_mips64x.go
+++ b/src/runtime/stubs_mips64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips64 || mips64le
 // +build mips64 mips64le
 
 package runtime
diff --git a/src/runtime/stubs_mipsx.go b/src/runtime/stubs_mipsx.go
index 707b295f7a..9bffb35b67 100644
--- a/src/runtime/stubs_mipsx.go
+++ b/src/runtime/stubs_mipsx.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips || mipsle
 // +build mips mipsle
 
 package runtime
diff --git a/src/runtime/stubs_nonlinux.go b/src/runtime/stubs_nonlinux.go
index e1ea05cf0b..f9b98595fc 100644
--- a/src/runtime/stubs_nonlinux.go
+++ b/src/runtime/stubs_nonlinux.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !linux
 // +build !linux
 
 package runtime
diff --git a/src/runtime/stubs_ppc64x.go b/src/runtime/stubs_ppc64x.go
index 26f5bb20ca..0841b413fd 100644
--- a/src/runtime/stubs_ppc64x.go
+++ b/src/runtime/stubs_ppc64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 package runtime
diff --git a/src/runtime/sys_libc.go b/src/runtime/sys_libc.go
index 996c032105..99d073517b 100644
--- a/src/runtime/sys_libc.go
+++ b/src/runtime/sys_libc.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || (openbsd && amd64) || (openbsd && arm64)
 // +build darwin openbsd,amd64 openbsd,arm64
 
 package runtime
diff --git a/src/runtime/sys_mips64x.go b/src/runtime/sys_mips64x.go
index cb429c3147..842a4a7084 100644
--- a/src/runtime/sys_mips64x.go
+++ b/src/runtime/sys_mips64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips64 || mips64le
 // +build mips64 mips64le
 
 package runtime
diff --git a/src/runtime/sys_mipsx.go b/src/runtime/sys_mipsx.go
index 2819218d5f..2038eb7d79 100644
--- a/src/runtime/sys_mipsx.go
+++ b/src/runtime/sys_mipsx.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips || mipsle
 // +build mips mipsle
 
 package runtime
diff --git a/src/runtime/sys_nonppc64x.go b/src/runtime/sys_nonppc64x.go
index 440937498f..66821b1f76 100644
--- a/src/runtime/sys_nonppc64x.go
+++ b/src/runtime/sys_nonppc64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !ppc64 && !ppc64le
 // +build !ppc64,!ppc64le
 
 package runtime
diff --git a/src/runtime/sys_openbsd.go b/src/runtime/sys_openbsd.go
index fcddf4d6a5..362fa777ef 100644
--- a/src/runtime/sys_openbsd.go
+++ b/src/runtime/sys_openbsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (openbsd && amd64) || (openbsd && arm64)
 // +build openbsd,amd64 openbsd,arm64
 
 package runtime
diff --git a/src/runtime/sys_openbsd1.go b/src/runtime/sys_openbsd1.go
index 44c7871ceb..43e0058985 100644
--- a/src/runtime/sys_openbsd1.go
+++ b/src/runtime/sys_openbsd1.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (openbsd && amd64) || (openbsd && arm64)
 // +build openbsd,amd64 openbsd,arm64
 
 package runtime
diff --git a/src/runtime/sys_openbsd2.go b/src/runtime/sys_openbsd2.go
index 33032596c3..73157043be 100644
--- a/src/runtime/sys_openbsd2.go
+++ b/src/runtime/sys_openbsd2.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (openbsd && amd64) || (openbsd && arm64)
 // +build openbsd,amd64 openbsd,arm64
 
 package runtime
diff --git a/src/runtime/sys_openbsd3.go b/src/runtime/sys_openbsd3.go
index 4d4c88e3ac..751c00c2b3 100644
--- a/src/runtime/sys_openbsd3.go
+++ b/src/runtime/sys_openbsd3.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (openbsd && amd64) || (openbsd && arm64)
 // +build openbsd,amd64 openbsd,arm64
 
 package runtime
diff --git a/src/runtime/sys_ppc64x.go b/src/runtime/sys_ppc64x.go
index 796f27c4e3..69bd99fa09 100644
--- a/src/runtime/sys_ppc64x.go
+++ b/src/runtime/sys_ppc64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 package runtime
diff --git a/src/runtime/sys_x86.go b/src/runtime/sys_x86.go
index 8f21585d28..0866e3140e 100644
--- a/src/runtime/sys_x86.go
+++ b/src/runtime/sys_x86.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build amd64 || 386
 // +build amd64 386
 
 package runtime
diff --git a/src/runtime/time_fake.go b/src/runtime/time_fake.go
index c64d2994a9..1238744ebf 100644
--- a/src/runtime/time_fake.go
+++ b/src/runtime/time_fake.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build faketime
-// +build !windows
+//go:build faketime && !windows
+// +build faketime,!windows
 
 // Faketime isn't currently supported on Windows. This would require:
 //
diff --git a/src/runtime/time_nofake.go b/src/runtime/time_nofake.go
index 1912a94e87..13bf1c2d4f 100644
--- a/src/runtime/time_nofake.go
+++ b/src/runtime/time_nofake.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !faketime
 // +build !faketime
 
 package runtime
diff --git a/src/runtime/timeasm.go b/src/runtime/timeasm.go
index 82cf63edff..fe38a086fc 100644
--- a/src/runtime/timeasm.go
+++ b/src/runtime/timeasm.go
@@ -4,6 +4,7 @@
 
 // Declarations for operating systems implementing time.now directly in assembly.
 
+//go:build windows
 // +build windows
 
 package runtime
diff --git a/src/runtime/timestub.go b/src/runtime/timestub.go
index 459bf8e543..2ef8d4665f 100644
--- a/src/runtime/timestub.go
+++ b/src/runtime/timestub.go
@@ -5,6 +5,7 @@
 // Declarations for operating systems implementing time.now
 // indirectly, in terms of walltime and nanotime assembly.
 
+//go:build !windows
 // +build !windows
 
 package runtime
diff --git a/src/runtime/timestub2.go b/src/runtime/timestub2.go
index 68777ee4a9..53b10885af 100644
--- a/src/runtime/timestub2.go
+++ b/src/runtime/timestub2.go
@@ -2,12 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !aix
-// +build !darwin
-// +build !freebsd
-// +build !openbsd
-// +build !solaris
-// +build !windows
+//go:build !aix && !darwin && !freebsd && !openbsd && !solaris && !windows
+// +build !aix,!darwin,!freebsd,!openbsd,!solaris,!windows
 
 package runtime
 
diff --git a/src/runtime/vdso_elf32.go b/src/runtime/vdso_elf32.go
index 2720f33eed..456173b0f5 100644
--- a/src/runtime/vdso_elf32.go
+++ b/src/runtime/vdso_elf32.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (386 || arm)
 // +build linux
 // +build 386 arm
 
diff --git a/src/runtime/vdso_elf64.go b/src/runtime/vdso_elf64.go
index 6ded9d621a..9923bd4697 100644
--- a/src/runtime/vdso_elf64.go
+++ b/src/runtime/vdso_elf64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (amd64 || arm64 || mips64 || mips64le || ppc64 || ppc64le)
 // +build linux
 // +build amd64 arm64 mips64 mips64le ppc64 ppc64le
 
diff --git a/src/runtime/vdso_freebsd.go b/src/runtime/vdso_freebsd.go
index 122cc8b128..74b2f1435a 100644
--- a/src/runtime/vdso_freebsd.go
+++ b/src/runtime/vdso_freebsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build freebsd
 // +build freebsd
 
 package runtime
diff --git a/src/runtime/vdso_freebsd_x86.go b/src/runtime/vdso_freebsd_x86.go
index 1fa5d80dcc..23a5a8c322 100644
--- a/src/runtime/vdso_freebsd_x86.go
+++ b/src/runtime/vdso_freebsd_x86.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build freebsd && (386 || amd64)
 // +build freebsd
 // +build 386 amd64
 
diff --git a/src/runtime/vdso_in_none.go b/src/runtime/vdso_in_none.go
index 7f4019c0d6..c66fbf8216 100644
--- a/src/runtime/vdso_in_none.go
+++ b/src/runtime/vdso_in_none.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (linux && !386 && !amd64 && !arm && !arm64 && !mips64 && !mips64le && !ppc64 && !ppc64le) || !linux
 // +build linux,!386,!amd64,!arm,!arm64,!mips64,!mips64le,!ppc64,!ppc64le !linux
 
 package runtime
diff --git a/src/runtime/vdso_linux.go b/src/runtime/vdso_linux.go
index 6e2942498d..ae211f96b1 100644
--- a/src/runtime/vdso_linux.go
+++ b/src/runtime/vdso_linux.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (386 || amd64 || arm || arm64 || mips64 || mips64le || ppc64 || ppc64le)
 // +build linux
 // +build 386 amd64 arm arm64 mips64 mips64le ppc64 ppc64le
 
diff --git a/src/runtime/vdso_linux_mips64x.go b/src/runtime/vdso_linux_mips64x.go
index 3a0f947612..395ddbba69 100644
--- a/src/runtime/vdso_linux_mips64x.go
+++ b/src/runtime/vdso_linux_mips64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (mips64 || mips64le)
 // +build linux
 // +build mips64 mips64le
 
diff --git a/src/runtime/vdso_linux_ppc64x.go b/src/runtime/vdso_linux_ppc64x.go
index f30946e4c5..b741dbfcdc 100644
--- a/src/runtime/vdso_linux_ppc64x.go
+++ b/src/runtime/vdso_linux_ppc64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (ppc64 || ppc64le)
 // +build linux
 // +build ppc64 ppc64le
 
diff --git a/src/runtime/vlrt.go b/src/runtime/vlrt.go
index 996c0611fd..cf631bdcca 100644
--- a/src/runtime/vlrt.go
+++ b/src/runtime/vlrt.go
@@ -23,6 +23,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+//go:build arm || 386 || mips || mipsle
 // +build arm 386 mips mipsle
 
 package runtime
diff --git a/src/runtime/wincallback.go b/src/runtime/wincallback.go
index cf3327c6fe..56f0674f4e 100644
--- a/src/runtime/wincallback.go
+++ b/src/runtime/wincallback.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // Generate Windows callback assembly file.
diff --git a/src/runtime/write_err.go b/src/runtime/write_err.go
index 6b1467b1c4..a4656fd728 100644
--- a/src/runtime/write_err.go
+++ b/src/runtime/write_err.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !android
 // +build !android
 
 package runtime
diff --git a/src/sort/genzfunc.go b/src/sort/genzfunc.go
index e7eb573737..ed04e33568 100644
--- a/src/sort/genzfunc.go
+++ b/src/sort/genzfunc.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // This program is run via "go generate" (via a directive in sort.go)
diff --git a/src/sort/slice_go113.go b/src/sort/slice_go113.go
index bf24db714a..53542dbd1a 100644
--- a/src/sort/slice_go113.go
+++ b/src/sort/slice_go113.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.13
 // +build go1.13
 
 package sort
diff --git a/src/sort/slice_go14.go b/src/sort/slice_go14.go
index 3bf5cbc00b..5d5949f3ca 100644
--- a/src/sort/slice_go14.go
+++ b/src/sort/slice_go14.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !go1.8
 // +build !go1.8
 
 package sort
diff --git a/src/sort/slice_go18.go b/src/sort/slice_go18.go
index e1766040a7..1538477bc5 100644
--- a/src/sort/slice_go18.go
+++ b/src/sort/slice_go18.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.8 && !go1.13
 // +build go1.8,!go1.13
 
 package sort
diff --git a/src/strconv/bytealg.go b/src/strconv/bytealg.go
index 7f66f2a8bb..9780c28ef3 100644
--- a/src/strconv/bytealg.go
+++ b/src/strconv/bytealg.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !compiler_bootstrap
 // +build !compiler_bootstrap
 
 package strconv
diff --git a/src/strconv/bytealg_bootstrap.go b/src/strconv/bytealg_bootstrap.go
index a3a547d1b6..875a0eb147 100644
--- a/src/strconv/bytealg_bootstrap.go
+++ b/src/strconv/bytealg_bootstrap.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build compiler_bootstrap
 // +build compiler_bootstrap
 
 package strconv
diff --git a/src/strconv/makeisprint.go b/src/strconv/makeisprint.go
index 0e6e90a6c6..79678341d4 100644
--- a/src/strconv/makeisprint.go
+++ b/src/strconv/makeisprint.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 //
diff --git a/src/sync/pool_test.go b/src/sync/pool_test.go
index ad98350b2b..65666daab4 100644
--- a/src/sync/pool_test.go
+++ b/src/sync/pool_test.go
@@ -3,6 +3,7 @@
 // license that can be found in the LICENSE file.
 
 // Pool is no-op under race detector, so all these tests do not work.
+//go:build !race
 // +build !race
 
 package sync_test
diff --git a/src/sync/runtime2.go b/src/sync/runtime2.go
index f10c4e8e0e..c4b44893f0 100644
--- a/src/sync/runtime2.go
+++ b/src/sync/runtime2.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !goexperiment.staticlockranking
 // +build !goexperiment.staticlockranking
 
 package sync
diff --git a/src/sync/runtime2_lockrank.go b/src/sync/runtime2_lockrank.go
index aaa1c27626..e91fdb6c1f 100644
--- a/src/sync/runtime2_lockrank.go
+++ b/src/sync/runtime2_lockrank.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build goexperiment.staticlockranking
 // +build goexperiment.staticlockranking
 
 package sync
diff --git a/src/syscall/bpf_bsd.go b/src/syscall/bpf_bsd.go
index f67ee6064b..452d4cf14b 100644
--- a/src/syscall/bpf_bsd.go
+++ b/src/syscall/bpf_bsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly || freebsd || netbsd || openbsd
 // +build dragonfly freebsd netbsd openbsd
 
 // Berkeley packet filter for BSD variants
diff --git a/src/syscall/creds_test.go b/src/syscall/creds_test.go
index 524689ae2d..463033d558 100644
--- a/src/syscall/creds_test.go
+++ b/src/syscall/creds_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux
 // +build linux
 
 package syscall_test
diff --git a/src/syscall/dirent.go b/src/syscall/dirent.go
index fab123d4a7..9e1222e81c 100644
--- a/src/syscall/dirent.go
+++ b/src/syscall/dirent.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris
 
 package syscall
diff --git a/src/syscall/dirent_test.go b/src/syscall/dirent_test.go
index 7dac98ff4b..8ed3caa9d4 100644
--- a/src/syscall/dirent_test.go
+++ b/src/syscall/dirent_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package syscall_test
diff --git a/src/syscall/endian_big.go b/src/syscall/endian_big.go
index 3c26005ab5..dc0947fa6e 100644
--- a/src/syscall/endian_big.go
+++ b/src/syscall/endian_big.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //
+//go:build ppc64 || s390x || mips || mips64
 // +build ppc64 s390x mips mips64
 
 package syscall
diff --git a/src/syscall/endian_little.go b/src/syscall/endian_little.go
index 43b081d640..a894445f73 100644
--- a/src/syscall/endian_little.go
+++ b/src/syscall/endian_little.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //
+//go:build 386 || amd64 || arm || arm64 || ppc64le || mips64le || mipsle || riscv64 || wasm
 // +build 386 amd64 arm arm64 ppc64le mips64le mipsle riscv64 wasm
 
 package syscall
diff --git a/src/syscall/env_unix.go b/src/syscall/env_unix.go
index a4bb28cc45..022ef6ed73 100644
--- a/src/syscall/env_unix.go
+++ b/src/syscall/env_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris || plan9
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris plan9
 
 // Unix environment variables.
diff --git a/src/syscall/exec_aix_test.go b/src/syscall/exec_aix_test.go
index 22b752cf27..17c7ac0664 100644
--- a/src/syscall/exec_aix_test.go
+++ b/src/syscall/exec_aix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix
 // +build aix
 
 package syscall
diff --git a/src/syscall/exec_bsd.go b/src/syscall/exec_bsd.go
index 940a81b58e..9c1fbbaeab 100644
--- a/src/syscall/exec_bsd.go
+++ b/src/syscall/exec_bsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly || freebsd || netbsd || (openbsd && !amd64 && !arm64)
 // +build dragonfly freebsd netbsd openbsd,!amd64,!arm64
 
 package syscall
diff --git a/src/syscall/exec_libc.go b/src/syscall/exec_libc.go
index 3722858325..3c8e87d32f 100644
--- a/src/syscall/exec_libc.go
+++ b/src/syscall/exec_libc.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || solaris
 // +build aix solaris
 
 // This file handles forkAndExecInChild function for OS using libc syscall like AIX or Solaris.
diff --git a/src/syscall/exec_libc2.go b/src/syscall/exec_libc2.go
index 45d3f85baf..507eff8ab3 100644
--- a/src/syscall/exec_libc2.go
+++ b/src/syscall/exec_libc2.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || (openbsd && amd64) || (openbsd && arm64)
 // +build darwin openbsd,amd64 openbsd,arm64
 
 package syscall
diff --git a/src/syscall/exec_linux.go b/src/syscall/exec_linux.go
index b6acad96ea..b0099cb4b0 100644
--- a/src/syscall/exec_linux.go
+++ b/src/syscall/exec_linux.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux
 // +build linux
 
 package syscall
diff --git a/src/syscall/exec_linux_test.go b/src/syscall/exec_linux_test.go
index ac3a5754ae..7d89eaae63 100644
--- a/src/syscall/exec_linux_test.go
+++ b/src/syscall/exec_linux_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux
 // +build linux
 
 package syscall_test
diff --git a/src/syscall/exec_solaris_test.go b/src/syscall/exec_solaris_test.go
index 6b8f1ad383..f54fc8385d 100644
--- a/src/syscall/exec_solaris_test.go
+++ b/src/syscall/exec_solaris_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build solaris
 // +build solaris
 
 package syscall
diff --git a/src/syscall/exec_unix.go b/src/syscall/exec_unix.go
index 1f49c78ef9..1f38de22b2 100644
--- a/src/syscall/exec_unix.go
+++ b/src/syscall/exec_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 // Fork, exec, wait, etc.
diff --git a/src/syscall/exec_unix_test.go b/src/syscall/exec_unix_test.go
index d6b6f51fa6..10bad5ac46 100644
--- a/src/syscall/exec_unix_test.go
+++ b/src/syscall/exec_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package syscall_test
diff --git a/src/syscall/export_unix_test.go b/src/syscall/export_unix_test.go
index 4c3d0f6d2a..2d2c67673d 100644
--- a/src/syscall/export_unix_test.go
+++ b/src/syscall/export_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly || freebsd || linux || netbsd || openbsd
 // +build dragonfly freebsd linux netbsd openbsd
 
 package syscall
diff --git a/src/syscall/flock.go b/src/syscall/flock.go
index 568efca7d4..3b43b6aede 100644
--- a/src/syscall/flock.go
+++ b/src/syscall/flock.go
@@ -1,3 +1,4 @@
+//go:build linux || freebsd || openbsd || netbsd || dragonfly
 // +build linux freebsd openbsd netbsd dragonfly
 
 // Copyright 2014 The Go Authors. All rights reserved.
diff --git a/src/syscall/flock_linux_32bit.go b/src/syscall/flock_linux_32bit.go
index e11aed6ed1..2f3277497c 100644
--- a/src/syscall/flock_linux_32bit.go
+++ b/src/syscall/flock_linux_32bit.go
@@ -5,6 +5,7 @@
 // If you change the build tags here, see
 // internal/syscall/unix/fcntl_linux_32bit.go.
 
+//go:build (linux && 386) || (linux && arm) || (linux && mips) || (linux && mipsle)
 // +build linux,386 linux,arm linux,mips linux,mipsle
 
 package syscall
diff --git a/src/syscall/forkpipe.go b/src/syscall/forkpipe.go
index d9999cb8b8..c7ddcf26ab 100644
--- a/src/syscall/forkpipe.go
+++ b/src/syscall/forkpipe.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || solaris
 // +build aix darwin dragonfly solaris
 
 package syscall
diff --git a/src/syscall/forkpipe2.go b/src/syscall/forkpipe2.go
index c9a0c4996e..cd98779ac9 100644
--- a/src/syscall/forkpipe2.go
+++ b/src/syscall/forkpipe2.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build freebsd || netbsd || openbsd
 // +build freebsd netbsd openbsd
 
 package syscall
diff --git a/src/syscall/fs_js.go b/src/syscall/fs_js.go
index 673feea77f..0170516201 100644
--- a/src/syscall/fs_js.go
+++ b/src/syscall/fs_js.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build js && wasm
 // +build js,wasm
 
 package syscall
diff --git a/src/syscall/getdirentries_test.go b/src/syscall/getdirentries_test.go
index 66bb8acba2..936c8a163a 100644
--- a/src/syscall/getdirentries_test.go
+++ b/src/syscall/getdirentries_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || freebsd || netbsd || openbsd
 // +build darwin freebsd netbsd openbsd
 
 package syscall_test
diff --git a/src/syscall/mkasm.go b/src/syscall/mkasm.go
index e53d14bed1..39461145e9 100644
--- a/src/syscall/mkasm.go
+++ b/src/syscall/mkasm.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // mkasm.go generates assembly trampolines to call library routines from Go.
diff --git a/src/syscall/mkpost.go b/src/syscall/mkpost.go
index ef89128310..94e8d92eff 100644
--- a/src/syscall/mkpost.go
+++ b/src/syscall/mkpost.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // mkpost processes the output of cgo -godefs to
diff --git a/src/syscall/mksyscall_windows.go b/src/syscall/mksyscall_windows.go
index 240254b2c7..d8e8a713c5 100644
--- a/src/syscall/mksyscall_windows.go
+++ b/src/syscall/mksyscall_windows.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // mksyscall_windows wraps golang.org/x/sys/windows/mkwinsyscall.
diff --git a/src/syscall/mmap_unix_test.go b/src/syscall/mmap_unix_test.go
index d0b3644b59..e3909f1afb 100644
--- a/src/syscall/mmap_unix_test.go
+++ b/src/syscall/mmap_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd
 // +build aix darwin dragonfly freebsd linux netbsd openbsd
 
 package syscall_test
diff --git a/src/syscall/msan.go b/src/syscall/msan.go
index baaad6df98..89fb75f03c 100644
--- a/src/syscall/msan.go
+++ b/src/syscall/msan.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build msan
 // +build msan
 
 package syscall
diff --git a/src/syscall/msan0.go b/src/syscall/msan0.go
index ff10be9d25..85097025a0 100644
--- a/src/syscall/msan0.go
+++ b/src/syscall/msan0.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !msan
 // +build !msan
 
 package syscall
diff --git a/src/syscall/net_js.go b/src/syscall/net_js.go
index 25f171bda8..ed462025bb 100644
--- a/src/syscall/net_js.go
+++ b/src/syscall/net_js.go
@@ -5,6 +5,7 @@
 // js/wasm uses fake networking directly implemented in the net package.
 // This file only exists to make the compiler happy.
 
+//go:build js && wasm
 // +build js,wasm
 
 package syscall
diff --git a/src/syscall/ptrace_darwin.go b/src/syscall/ptrace_darwin.go
index a873d826b8..b968c7c7f3 100644
--- a/src/syscall/ptrace_darwin.go
+++ b/src/syscall/ptrace_darwin.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !ios
 // +build !ios
 
 package syscall
diff --git a/src/syscall/route_bsd.go b/src/syscall/route_bsd.go
index b364eeaba5..e9321a4e64 100644
--- a/src/syscall/route_bsd.go
+++ b/src/syscall/route_bsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || netbsd || openbsd
 // +build darwin dragonfly freebsd netbsd openbsd
 
 package syscall
diff --git a/src/syscall/route_freebsd_32bit.go b/src/syscall/route_freebsd_32bit.go
index aed8682237..412833a37c 100644
--- a/src/syscall/route_freebsd_32bit.go
+++ b/src/syscall/route_freebsd_32bit.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (freebsd && 386) || (freebsd && arm)
 // +build freebsd,386 freebsd,arm
 
 package syscall
diff --git a/src/syscall/route_freebsd_64bit.go b/src/syscall/route_freebsd_64bit.go
index e70ba3df89..5300bed471 100644
--- a/src/syscall/route_freebsd_64bit.go
+++ b/src/syscall/route_freebsd_64bit.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (freebsd && amd64) || (freebsd && arm64)
 // +build freebsd,amd64 freebsd,arm64
 
 package syscall
diff --git a/src/syscall/setuidgid_32_linux.go b/src/syscall/setuidgid_32_linux.go
index b0b7f61d22..64897fe43c 100644
--- a/src/syscall/setuidgid_32_linux.go
+++ b/src/syscall/setuidgid_32_linux.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (386 || arm)
 // +build linux
 // +build 386 arm
 
diff --git a/src/syscall/setuidgid_linux.go b/src/syscall/setuidgid_linux.go
index 38c83c92f9..3b36f66fa2 100644
--- a/src/syscall/setuidgid_linux.go
+++ b/src/syscall/setuidgid_linux.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build linux
-// +build !386,!arm
+//go:build linux && !386 && !arm
+// +build linux,!386,!arm
 
 package syscall
 
diff --git a/src/syscall/sockcmsg_unix.go b/src/syscall/sockcmsg_unix.go
index 1ff97a5ae1..99913b9a88 100644
--- a/src/syscall/sockcmsg_unix.go
+++ b/src/syscall/sockcmsg_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 // Socket control messages
diff --git a/src/syscall/sockcmsg_unix_other.go b/src/syscall/sockcmsg_unix_other.go
index 40f03142a6..bd8dcfa34c 100644
--- a/src/syscall/sockcmsg_unix_other.go
+++ b/src/syscall/sockcmsg_unix_other.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin freebsd linux netbsd openbsd solaris
 
 package syscall
diff --git a/src/syscall/syscall_bsd.go b/src/syscall/syscall_bsd.go
index 1c7ec588bc..595e705856 100644
--- a/src/syscall/syscall_bsd.go
+++ b/src/syscall/syscall_bsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || netbsd || openbsd
 // +build darwin dragonfly freebsd netbsd openbsd
 
 // BSD system call wrappers shared by *BSD based systems
diff --git a/src/syscall/syscall_bsd_test.go b/src/syscall/syscall_bsd_test.go
index f2bc3f5147..2d8a8cbfe6 100644
--- a/src/syscall/syscall_bsd_test.go
+++ b/src/syscall/syscall_bsd_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || openbsd
 // +build darwin dragonfly freebsd openbsd
 
 package syscall_test
diff --git a/src/syscall/syscall_dup2_linux.go b/src/syscall/syscall_dup2_linux.go
index f03a923112..351a96edc1 100644
--- a/src/syscall/syscall_dup2_linux.go
+++ b/src/syscall/syscall_dup2_linux.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !android && (386 || amd64 || arm || mips || mipsle || mips64 || mips64le || ppc64 || ppc64le || s390x)
 // +build !android
 // +build 386 amd64 arm mips mipsle mips64 mips64le ppc64 ppc64le s390x
 
diff --git a/src/syscall/syscall_dup3_linux.go b/src/syscall/syscall_dup3_linux.go
index 1ebdcb20a2..66ec67b0ab 100644
--- a/src/syscall/syscall_dup3_linux.go
+++ b/src/syscall/syscall_dup3_linux.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build android || arm64 || riscv64
 // +build android arm64 riscv64
 
 package syscall
diff --git a/src/syscall/syscall_freebsd_test.go b/src/syscall/syscall_freebsd_test.go
index 3ccfe5d463..89c7959d0c 100644
--- a/src/syscall/syscall_freebsd_test.go
+++ b/src/syscall/syscall_freebsd_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build freebsd
 // +build freebsd
 
 package syscall_test
diff --git a/src/syscall/syscall_illumos.go b/src/syscall/syscall_illumos.go
index d70a436d13..ef95fe58f7 100644
--- a/src/syscall/syscall_illumos.go
+++ b/src/syscall/syscall_illumos.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build illumos
 // +build illumos
 
 // Illumos system calls not present on Solaris.
diff --git a/src/syscall/syscall_js.go b/src/syscall/syscall_js.go
index 0ab8c3fba4..c17c6fcdcf 100644
--- a/src/syscall/syscall_js.go
+++ b/src/syscall/syscall_js.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build js && wasm
 // +build js,wasm
 
 package syscall
diff --git a/src/syscall/syscall_linux_mips64x.go b/src/syscall/syscall_linux_mips64x.go
index ab25b7be6f..dd51f3d00a 100644
--- a/src/syscall/syscall_linux_mips64x.go
+++ b/src/syscall/syscall_linux_mips64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (mips64 || mips64le)
 // +build linux
 // +build mips64 mips64le
 
diff --git a/src/syscall/syscall_linux_mipsx.go b/src/syscall/syscall_linux_mipsx.go
index 377946fc92..7894bdd465 100644
--- a/src/syscall/syscall_linux_mipsx.go
+++ b/src/syscall/syscall_linux_mipsx.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (mips || mipsle)
 // +build linux
 // +build mips mipsle
 
diff --git a/src/syscall/syscall_linux_ppc64x.go b/src/syscall/syscall_linux_ppc64x.go
index 45bf667407..495ae29757 100644
--- a/src/syscall/syscall_linux_ppc64x.go
+++ b/src/syscall/syscall_linux_ppc64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (ppc64 || ppc64le)
 // +build linux
 // +build ppc64 ppc64le
 
diff --git a/src/syscall/syscall_openbsd1.go b/src/syscall/syscall_openbsd1.go
index 2c7d0f8c90..0d6761d49e 100644
--- a/src/syscall/syscall_openbsd1.go
+++ b/src/syscall/syscall_openbsd1.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build openbsd && !amd64 && !arm64
 // +build openbsd,!amd64,!arm64
 
 package syscall
diff --git a/src/syscall/syscall_openbsd_libc.go b/src/syscall/syscall_openbsd_libc.go
index 042615bf2a..610c66fd34 100644
--- a/src/syscall/syscall_openbsd_libc.go
+++ b/src/syscall/syscall_openbsd_libc.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (openbsd && amd64) || (openbsd && arm64)
 // +build openbsd,amd64 openbsd,arm64
 
 package syscall
diff --git a/src/syscall/syscall_ptrace_test.go b/src/syscall/syscall_ptrace_test.go
index 6b7f54dcfd..45729d9e8e 100644
--- a/src/syscall/syscall_ptrace_test.go
+++ b/src/syscall/syscall_ptrace_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd
 // +build darwin dragonfly freebsd linux netbsd openbsd
 
 package syscall_test
diff --git a/src/syscall/syscall_unix.go b/src/syscall/syscall_unix.go
index 786ad34170..40fc8b8a30 100644
--- a/src/syscall/syscall_unix.go
+++ b/src/syscall/syscall_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package syscall
diff --git a/src/syscall/syscall_unix_test.go b/src/syscall/syscall_unix_test.go
index 7e6a8c9043..a05fff5136 100644
--- a/src/syscall/syscall_unix_test.go
+++ b/src/syscall/syscall_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package syscall_test
diff --git a/src/syscall/tables_js.go b/src/syscall/tables_js.go
index a7c4f8c890..64d958415d 100644
--- a/src/syscall/tables_js.go
+++ b/src/syscall/tables_js.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build js && wasm
 // +build js,wasm
 
 package syscall
diff --git a/src/syscall/time_fake.go b/src/syscall/time_fake.go
index 5dec57a25a..cf88aeb921 100644
--- a/src/syscall/time_fake.go
+++ b/src/syscall/time_fake.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build faketime
 // +build faketime
 
 package syscall
diff --git a/src/syscall/time_nofake.go b/src/syscall/time_nofake.go
index c94cef8686..5eaa2daabd 100644
--- a/src/syscall/time_nofake.go
+++ b/src/syscall/time_nofake.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !faketime
 // +build !faketime
 
 package syscall
diff --git a/src/syscall/timestruct.go b/src/syscall/timestruct.go
index bca51df08d..e4f3d50f56 100644
--- a/src/syscall/timestruct.go
+++ b/src/syscall/timestruct.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris
 
 package syscall
diff --git a/src/syscall/types_aix.go b/src/syscall/types_aix.go
index cbc47cc6c1..6588d690ea 100644
--- a/src/syscall/types_aix.go
+++ b/src/syscall/types_aix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/syscall/types_darwin.go b/src/syscall/types_darwin.go
index 7b3a9d2335..c2a32c0782 100644
--- a/src/syscall/types_darwin.go
+++ b/src/syscall/types_darwin.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/syscall/types_dragonfly.go b/src/syscall/types_dragonfly.go
index 53bc12403b..9f8d5bc3dd 100644
--- a/src/syscall/types_dragonfly.go
+++ b/src/syscall/types_dragonfly.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/syscall/types_freebsd.go b/src/syscall/types_freebsd.go
index f686021121..d741411703 100644
--- a/src/syscall/types_freebsd.go
+++ b/src/syscall/types_freebsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/syscall/types_illumos_amd64.go b/src/syscall/types_illumos_amd64.go
index abb282f3e4..254e3e7cfe 100644
--- a/src/syscall/types_illumos_amd64.go
+++ b/src/syscall/types_illumos_amd64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build illumos
 // +build illumos
 
 // Illumos consts not present on Solaris. These are added manually rather than
diff --git a/src/syscall/types_linux.go b/src/syscall/types_linux.go
index 9de32d9c01..bf76be978b 100644
--- a/src/syscall/types_linux.go
+++ b/src/syscall/types_linux.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/syscall/types_netbsd.go b/src/syscall/types_netbsd.go
index 30ab2dc845..0bd25ea3c9 100644
--- a/src/syscall/types_netbsd.go
+++ b/src/syscall/types_netbsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/syscall/types_openbsd.go b/src/syscall/types_openbsd.go
index 922864815b..8b41cdca23 100644
--- a/src/syscall/types_openbsd.go
+++ b/src/syscall/types_openbsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/syscall/types_solaris.go b/src/syscall/types_solaris.go
index 76a74508d2..179f791481 100644
--- a/src/syscall/types_solaris.go
+++ b/src/syscall/types_solaris.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 /*
diff --git a/src/syscall/zerrors_darwin_amd64.go b/src/syscall/zerrors_darwin_amd64.go
index 58799fbde7..0b9897284c 100644
--- a/src/syscall/zerrors_darwin_amd64.go
+++ b/src/syscall/zerrors_darwin_amd64.go
@@ -4,6 +4,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs -- -m64 _const.go
 
+//go:build amd64 && darwin
 // +build amd64,darwin
 
 package syscall
diff --git a/src/syscall/zerrors_darwin_arm64.go b/src/syscall/zerrors_darwin_arm64.go
index 8b433616ee..5f210fd1c4 100644
--- a/src/syscall/zerrors_darwin_arm64.go
+++ b/src/syscall/zerrors_darwin_arm64.go
@@ -4,6 +4,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs -- -m64 _const.go
 
+//go:build arm64 && darwin
 // +build arm64,darwin
 
 package syscall
diff --git a/src/syscall/zerrors_dragonfly_amd64.go b/src/syscall/zerrors_dragonfly_amd64.go
index 3434a85d34..b572f44a6b 100644
--- a/src/syscall/zerrors_dragonfly_amd64.go
+++ b/src/syscall/zerrors_dragonfly_amd64.go
@@ -4,6 +4,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs -- -m64 _const.go
 
+//go:build amd64 && dragonfly
 // +build amd64,dragonfly
 
 package syscall
diff --git a/src/syscall/zerrors_freebsd_386.go b/src/syscall/zerrors_freebsd_386.go
index 85786a5b4e..aec26ad778 100644
--- a/src/syscall/zerrors_freebsd_386.go
+++ b/src/syscall/zerrors_freebsd_386.go
@@ -4,6 +4,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs -- -m32 _const.go
 
+//go:build 386 && freebsd
 // +build 386,freebsd
 
 package syscall
diff --git a/src/syscall/zerrors_freebsd_amd64.go b/src/syscall/zerrors_freebsd_amd64.go
index b3ebf3d474..d6d13e4155 100644
--- a/src/syscall/zerrors_freebsd_amd64.go
+++ b/src/syscall/zerrors_freebsd_amd64.go
@@ -4,6 +4,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs -- -m64 _const.go
 
+//go:build amd64 && freebsd
 // +build amd64,freebsd
 
 package syscall
diff --git a/src/syscall/zerrors_freebsd_arm.go b/src/syscall/zerrors_freebsd_arm.go
index 29eabb1d2d..15c714fad8 100644
--- a/src/syscall/zerrors_freebsd_arm.go
+++ b/src/syscall/zerrors_freebsd_arm.go
@@ -4,6 +4,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs -- _const.go
 
+//go:build arm && freebsd
 // +build arm,freebsd
 
 package syscall
diff --git a/src/syscall/zerrors_freebsd_arm64.go b/src/syscall/zerrors_freebsd_arm64.go
index 82ee158478..b20ce7d823 100644
--- a/src/syscall/zerrors_freebsd_arm64.go
+++ b/src/syscall/zerrors_freebsd_arm64.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -m64
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build freebsd && arm64
 // +build freebsd,arm64
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
diff --git a/src/syscall/zerrors_linux_386.go b/src/syscall/zerrors_linux_386.go
index 53a442d108..fb64932ad6 100644
--- a/src/syscall/zerrors_linux_386.go
+++ b/src/syscall/zerrors_linux_386.go
@@ -4,6 +4,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs -- -m32 _const.go
 
+//go:build 386 && linux
 // +build 386,linux
 
 package syscall
diff --git a/src/syscall/zerrors_linux_amd64.go b/src/syscall/zerrors_linux_amd64.go
index 0b4c60dd4c..3a92bcdbb4 100644
--- a/src/syscall/zerrors_linux_amd64.go
+++ b/src/syscall/zerrors_linux_amd64.go
@@ -4,6 +4,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs -- -m64 _const.go
 
+//go:build amd64 && linux
 // +build amd64,linux
 
 package syscall
diff --git a/src/syscall/zerrors_linux_arm.go b/src/syscall/zerrors_linux_arm.go
index 9a8d9e8579..e013d8e7fd 100644
--- a/src/syscall/zerrors_linux_arm.go
+++ b/src/syscall/zerrors_linux_arm.go
@@ -4,6 +4,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs -- _const.go
 
+//go:build arm && linux
 // +build arm,linux
 
 package syscall
diff --git a/src/syscall/zerrors_linux_arm64.go b/src/syscall/zerrors_linux_arm64.go
index f0caf552b2..1a4d33e3fd 100644
--- a/src/syscall/zerrors_linux_arm64.go
+++ b/src/syscall/zerrors_linux_arm64.go
@@ -4,6 +4,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs -- _const.go
 
+//go:build arm64 && linux
 // +build arm64,linux
 
 package syscall
diff --git a/src/syscall/zerrors_linux_ppc64.go b/src/syscall/zerrors_linux_ppc64.go
index f064731ae5..1dda43be70 100644
--- a/src/syscall/zerrors_linux_ppc64.go
+++ b/src/syscall/zerrors_linux_ppc64.go
@@ -4,6 +4,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs -- -m64 _const.go
 
+//go:build ppc64 && linux
 // +build ppc64,linux
 
 package syscall
diff --git a/src/syscall/zerrors_linux_ppc64le.go b/src/syscall/zerrors_linux_ppc64le.go
index 41e21a510e..6d56f1c998 100644
--- a/src/syscall/zerrors_linux_ppc64le.go
+++ b/src/syscall/zerrors_linux_ppc64le.go
@@ -4,6 +4,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs -- -m64 _const.go
 
+//go:build ppc64le && linux
 // +build ppc64le,linux
 
 package syscall
diff --git a/src/syscall/zerrors_netbsd_386.go b/src/syscall/zerrors_netbsd_386.go
index bf1e4a74c3..6a58946a4a 100644
--- a/src/syscall/zerrors_netbsd_386.go
+++ b/src/syscall/zerrors_netbsd_386.go
@@ -4,6 +4,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs -- -m32 _const.go
 
+//go:build 386 && netbsd
 // +build 386,netbsd
 
 package syscall
diff --git a/src/syscall/zerrors_netbsd_amd64.go b/src/syscall/zerrors_netbsd_amd64.go
index 247e78e6c6..f5c5c2f49c 100644
--- a/src/syscall/zerrors_netbsd_amd64.go
+++ b/src/syscall/zerrors_netbsd_amd64.go
@@ -4,6 +4,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs -- -m64 _const.go
 
+//go:build amd64 && netbsd
 // +build amd64,netbsd
 
 package syscall
diff --git a/src/syscall/zerrors_netbsd_arm.go b/src/syscall/zerrors_netbsd_arm.go
index f23cd8693f..c9d4579b41 100644
--- a/src/syscall/zerrors_netbsd_arm.go
+++ b/src/syscall/zerrors_netbsd_arm.go
@@ -4,6 +4,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs -- -marm _const.go
 
+//go:build arm && netbsd
 // +build arm,netbsd
 
 package syscall
diff --git a/src/syscall/zerrors_netbsd_arm64.go b/src/syscall/zerrors_netbsd_arm64.go
index 6f6453f6ee..e35bff7f3e 100644
--- a/src/syscall/zerrors_netbsd_arm64.go
+++ b/src/syscall/zerrors_netbsd_arm64.go
@@ -4,6 +4,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs -- -m64 _const.go
 
+//go:build arm64 && netbsd
 // +build arm64,netbsd
 
 package syscall
diff --git a/src/syscall/zerrors_openbsd_386.go b/src/syscall/zerrors_openbsd_386.go
index 7985abe3f0..04d1b3f177 100644
--- a/src/syscall/zerrors_openbsd_386.go
+++ b/src/syscall/zerrors_openbsd_386.go
@@ -4,6 +4,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs -- -m32 _const.go
 
+//go:build 386 && openbsd
 // +build 386,openbsd
 
 package syscall
diff --git a/src/syscall/zerrors_openbsd_amd64.go b/src/syscall/zerrors_openbsd_amd64.go
index 9c4ff2955f..923a3a47c5 100644
--- a/src/syscall/zerrors_openbsd_amd64.go
+++ b/src/syscall/zerrors_openbsd_amd64.go
@@ -4,6 +4,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs -- -m64 _const.go
 
+//go:build amd64 && openbsd
 // +build amd64,openbsd
 
 package syscall
diff --git a/src/syscall/zerrors_openbsd_arm.go b/src/syscall/zerrors_openbsd_arm.go
index 493a8389f2..89a4e6d89a 100644
--- a/src/syscall/zerrors_openbsd_arm.go
+++ b/src/syscall/zerrors_openbsd_arm.go
@@ -4,6 +4,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs -- _const.go
 
+//go:build arm && openbsd
 // +build arm,openbsd
 
 package syscall
diff --git a/src/syscall/zerrors_solaris_amd64.go b/src/syscall/zerrors_solaris_amd64.go
index eba401544a..b7dee69602 100644
--- a/src/syscall/zerrors_solaris_amd64.go
+++ b/src/syscall/zerrors_solaris_amd64.go
@@ -4,6 +4,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs -- -m64 _const.go
 
+//go:build amd64 && solaris
 // +build amd64,solaris
 
 package syscall
diff --git a/src/syscall/zsyscall_aix_ppc64.go b/src/syscall/zsyscall_aix_ppc64.go
index 20625c1a3e..134ae41165 100644
--- a/src/syscall/zsyscall_aix_ppc64.go
+++ b/src/syscall/zsyscall_aix_ppc64.go
@@ -1,6 +1,7 @@
 // mksyscall_libc.pl -aix -tags aix,ppc64 syscall_aix.go syscall_aix_ppc64.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build aix && ppc64
 // +build aix,ppc64
 
 package syscall
diff --git a/src/syscall/zsyscall_darwin_amd64.go b/src/syscall/zsyscall_darwin_amd64.go
index 4f2cdf861e..13dfacdba2 100644
--- a/src/syscall/zsyscall_darwin_amd64.go
+++ b/src/syscall/zsyscall_darwin_amd64.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -darwin -tags darwin,amd64 syscall_bsd.go syscall_darwin.go syscall_darwin_amd64.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build darwin && amd64
 // +build darwin,amd64
 
 package syscall
diff --git a/src/syscall/zsyscall_darwin_arm64.go b/src/syscall/zsyscall_darwin_arm64.go
index 0d8598d816..79576eedf7 100644
--- a/src/syscall/zsyscall_darwin_arm64.go
+++ b/src/syscall/zsyscall_darwin_arm64.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -darwin -tags darwin,arm64 syscall_bsd.go syscall_darwin.go syscall_darwin_arm64.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build darwin && arm64
 // +build darwin,arm64
 
 package syscall
diff --git a/src/syscall/zsyscall_dragonfly_amd64.go b/src/syscall/zsyscall_dragonfly_amd64.go
index 578b5a3e9e..4799d1dcb0 100644
--- a/src/syscall/zsyscall_dragonfly_amd64.go
+++ b/src/syscall/zsyscall_dragonfly_amd64.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -dragonfly -tags dragonfly,amd64 syscall_bsd.go syscall_dragonfly.go syscall_dragonfly_amd64.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build dragonfly && amd64
 // +build dragonfly,amd64
 
 package syscall
diff --git a/src/syscall/zsyscall_freebsd_386.go b/src/syscall/zsyscall_freebsd_386.go
index ddc265f190..7137d66f0b 100644
--- a/src/syscall/zsyscall_freebsd_386.go
+++ b/src/syscall/zsyscall_freebsd_386.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -l32 -tags freebsd,386 syscall_bsd.go syscall_freebsd.go syscall_freebsd_386.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build freebsd && 386
 // +build freebsd,386
 
 package syscall
diff --git a/src/syscall/zsyscall_freebsd_amd64.go b/src/syscall/zsyscall_freebsd_amd64.go
index a0f79522b9..d721dafde2 100644
--- a/src/syscall/zsyscall_freebsd_amd64.go
+++ b/src/syscall/zsyscall_freebsd_amd64.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -tags freebsd,amd64 syscall_bsd.go syscall_freebsd.go syscall_freebsd_amd64.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build freebsd && amd64
 // +build freebsd,amd64
 
 package syscall
diff --git a/src/syscall/zsyscall_freebsd_arm.go b/src/syscall/zsyscall_freebsd_arm.go
index 2cd23d3db6..d9dbea921a 100644
--- a/src/syscall/zsyscall_freebsd_arm.go
+++ b/src/syscall/zsyscall_freebsd_arm.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -l32 -arm -tags freebsd,arm syscall_bsd.go syscall_freebsd.go syscall_freebsd_arm.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build freebsd && arm
 // +build freebsd,arm
 
 package syscall
diff --git a/src/syscall/zsyscall_freebsd_arm64.go b/src/syscall/zsyscall_freebsd_arm64.go
index 1b177383c2..a24f0115e2 100644
--- a/src/syscall/zsyscall_freebsd_arm64.go
+++ b/src/syscall/zsyscall_freebsd_arm64.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -tags freebsd,arm64 syscall_bsd.go syscall_freebsd.go syscall_freebsd_arm64.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build freebsd && arm64
 // +build freebsd,arm64
 
 package syscall
diff --git a/src/syscall/zsyscall_linux_386.go b/src/syscall/zsyscall_linux_386.go
index 5a749ff3f3..ac822d6f7a 100644
--- a/src/syscall/zsyscall_linux_386.go
+++ b/src/syscall/zsyscall_linux_386.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -l32 -tags linux,386 syscall_linux.go syscall_linux_386.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build linux && 386
 // +build linux,386
 
 package syscall
diff --git a/src/syscall/zsyscall_linux_amd64.go b/src/syscall/zsyscall_linux_amd64.go
index 34b624c1d4..ed37fa8dec 100644
--- a/src/syscall/zsyscall_linux_amd64.go
+++ b/src/syscall/zsyscall_linux_amd64.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -tags linux,amd64 syscall_linux.go syscall_linux_amd64.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build linux && amd64
 // +build linux,amd64
 
 package syscall
diff --git a/src/syscall/zsyscall_linux_arm.go b/src/syscall/zsyscall_linux_arm.go
index 4d133766f7..213aaf3bac 100644
--- a/src/syscall/zsyscall_linux_arm.go
+++ b/src/syscall/zsyscall_linux_arm.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -l32 -arm -tags linux,arm syscall_linux.go syscall_linux_arm.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build linux && arm
 // +build linux,arm
 
 package syscall
diff --git a/src/syscall/zsyscall_linux_arm64.go b/src/syscall/zsyscall_linux_arm64.go
index e7f7b7e3f8..e2f9c0fd9b 100644
--- a/src/syscall/zsyscall_linux_arm64.go
+++ b/src/syscall/zsyscall_linux_arm64.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -tags linux,arm64 syscall_linux.go syscall_linux_arm64.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build linux && arm64
 // +build linux,arm64
 
 package syscall
diff --git a/src/syscall/zsyscall_linux_mips.go b/src/syscall/zsyscall_linux_mips.go
index a8522dc571..617c2f5466 100644
--- a/src/syscall/zsyscall_linux_mips.go
+++ b/src/syscall/zsyscall_linux_mips.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -b32 -arm -tags linux,mips syscall_linux.go syscall_linux_mipsx.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build linux && mips
 // +build linux,mips
 
 package syscall
diff --git a/src/syscall/zsyscall_linux_mips64.go b/src/syscall/zsyscall_linux_mips64.go
index 1219fcc6cb..793d4b9884 100644
--- a/src/syscall/zsyscall_linux_mips64.go
+++ b/src/syscall/zsyscall_linux_mips64.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -tags linux,mips64 syscall_linux.go syscall_linux_mips64x.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build linux && mips64
 // +build linux,mips64
 
 package syscall
diff --git a/src/syscall/zsyscall_linux_mips64le.go b/src/syscall/zsyscall_linux_mips64le.go
index c3737bf3cf..54e1760bda 100644
--- a/src/syscall/zsyscall_linux_mips64le.go
+++ b/src/syscall/zsyscall_linux_mips64le.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -tags linux,mips64le syscall_linux.go syscall_linux_mips64x.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build linux && mips64le
 // +build linux,mips64le
 
 package syscall
diff --git a/src/syscall/zsyscall_linux_mipsle.go b/src/syscall/zsyscall_linux_mipsle.go
index 5006f4a409..ba7e2118c0 100644
--- a/src/syscall/zsyscall_linux_mipsle.go
+++ b/src/syscall/zsyscall_linux_mipsle.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -l32 -arm -tags linux,mipsle syscall_linux.go syscall_linux_mipsx.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build linux && mipsle
 // +build linux,mipsle
 
 package syscall
diff --git a/src/syscall/zsyscall_linux_ppc64.go b/src/syscall/zsyscall_linux_ppc64.go
index 323be988be..c3437722e0 100644
--- a/src/syscall/zsyscall_linux_ppc64.go
+++ b/src/syscall/zsyscall_linux_ppc64.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -tags linux,ppc64 syscall_linux.go syscall_linux_ppc64x.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build linux && ppc64
 // +build linux,ppc64
 
 package syscall
diff --git a/src/syscall/zsyscall_linux_ppc64le.go b/src/syscall/zsyscall_linux_ppc64le.go
index 99aea6b559..acc34a76d2 100644
--- a/src/syscall/zsyscall_linux_ppc64le.go
+++ b/src/syscall/zsyscall_linux_ppc64le.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -tags linux,ppc64le syscall_linux.go syscall_linux_ppc64x.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build linux && ppc64le
 // +build linux,ppc64le
 
 package syscall
diff --git a/src/syscall/zsyscall_linux_riscv64.go b/src/syscall/zsyscall_linux_riscv64.go
index afa8945944..d662d780db 100644
--- a/src/syscall/zsyscall_linux_riscv64.go
+++ b/src/syscall/zsyscall_linux_riscv64.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -tags linux,riscv64 syscall_linux.go syscall_linux_riscv64.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build linux && riscv64
 // +build linux,riscv64
 
 package syscall
diff --git a/src/syscall/zsyscall_linux_s390x.go b/src/syscall/zsyscall_linux_s390x.go
index 5717206f28..20f8c61366 100644
--- a/src/syscall/zsyscall_linux_s390x.go
+++ b/src/syscall/zsyscall_linux_s390x.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -tags linux,s390x syscall_linux.go syscall_linux_s390x.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build linux && s390x
 // +build linux,s390x
 
 package syscall
diff --git a/src/syscall/zsyscall_netbsd_386.go b/src/syscall/zsyscall_netbsd_386.go
index 7e0210081e..07ff5fba5f 100644
--- a/src/syscall/zsyscall_netbsd_386.go
+++ b/src/syscall/zsyscall_netbsd_386.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -l32 -netbsd -tags netbsd,386 syscall_bsd.go syscall_netbsd.go syscall_netbsd_386.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build netbsd && 386
 // +build netbsd,386
 
 package syscall
diff --git a/src/syscall/zsyscall_netbsd_amd64.go b/src/syscall/zsyscall_netbsd_amd64.go
index e9ee790501..ffb4e059a4 100644
--- a/src/syscall/zsyscall_netbsd_amd64.go
+++ b/src/syscall/zsyscall_netbsd_amd64.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -netbsd -tags netbsd,amd64 syscall_bsd.go syscall_netbsd.go syscall_netbsd_amd64.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build netbsd && amd64
 // +build netbsd,amd64
 
 package syscall
diff --git a/src/syscall/zsyscall_netbsd_arm.go b/src/syscall/zsyscall_netbsd_arm.go
index 37438b020b..37df77e5e8 100644
--- a/src/syscall/zsyscall_netbsd_arm.go
+++ b/src/syscall/zsyscall_netbsd_arm.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -l32 -netbsd -arm -tags netbsd,arm syscall_bsd.go syscall_netbsd.go syscall_netbsd_arm.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build netbsd && arm
 // +build netbsd,arm
 
 package syscall
diff --git a/src/syscall/zsyscall_netbsd_arm64.go b/src/syscall/zsyscall_netbsd_arm64.go
index 758f398228..c5eb57a226 100644
--- a/src/syscall/zsyscall_netbsd_arm64.go
+++ b/src/syscall/zsyscall_netbsd_arm64.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -netbsd -tags netbsd,arm64 syscall_bsd.go syscall_netbsd.go syscall_netbsd_arm64.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build netbsd && arm64
 // +build netbsd,arm64
 
 package syscall
diff --git a/src/syscall/zsyscall_openbsd_386.go b/src/syscall/zsyscall_openbsd_386.go
index decd169f0d..7d4c4d342a 100644
--- a/src/syscall/zsyscall_openbsd_386.go
+++ b/src/syscall/zsyscall_openbsd_386.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -l32 -openbsd -tags openbsd,386 syscall_bsd.go syscall_openbsd.go syscall_openbsd_386.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build openbsd && 386
 // +build openbsd,386
 
 package syscall
diff --git a/src/syscall/zsyscall_openbsd_amd64.go b/src/syscall/zsyscall_openbsd_amd64.go
index 733050ad1d..b4698b79e2 100644
--- a/src/syscall/zsyscall_openbsd_amd64.go
+++ b/src/syscall/zsyscall_openbsd_amd64.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -openbsd -libc -tags openbsd,amd64 syscall_bsd.go syscall_openbsd.go syscall_openbsd_libc.go syscall_openbsd_amd64.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build openbsd && amd64
 // +build openbsd,amd64
 
 package syscall
diff --git a/src/syscall/zsyscall_openbsd_arm.go b/src/syscall/zsyscall_openbsd_arm.go
index dce0a540e6..31425b3558 100644
--- a/src/syscall/zsyscall_openbsd_arm.go
+++ b/src/syscall/zsyscall_openbsd_arm.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -l32 -openbsd -arm -tags openbsd,arm syscall_bsd.go syscall_openbsd.go syscall_openbsd_arm.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build openbsd && arm
 // +build openbsd,arm
 
 package syscall
diff --git a/src/syscall/zsyscall_openbsd_arm64.go b/src/syscall/zsyscall_openbsd_arm64.go
index 2093eb74e5..de6db1e3fa 100644
--- a/src/syscall/zsyscall_openbsd_arm64.go
+++ b/src/syscall/zsyscall_openbsd_arm64.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -openbsd -libc -tags openbsd,arm64 syscall_bsd.go syscall_openbsd.go syscall_openbsd_libc.go syscall_openbsd_arm64.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build openbsd && arm64
 // +build openbsd,arm64
 
 package syscall
diff --git a/src/syscall/zsyscall_openbsd_mips64.go b/src/syscall/zsyscall_openbsd_mips64.go
index ded05686c4..70fd1474fd 100644
--- a/src/syscall/zsyscall_openbsd_mips64.go
+++ b/src/syscall/zsyscall_openbsd_mips64.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -openbsd -tags openbsd,mips64 syscall_bsd.go syscall_openbsd.go syscall_openbsd_mips64x.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build openbsd && mips64
 // +build openbsd,mips64
 
 package syscall
diff --git a/src/syscall/zsyscall_plan9_386.go b/src/syscall/zsyscall_plan9_386.go
index 998c6c555e..8b7727b343 100644
--- a/src/syscall/zsyscall_plan9_386.go
+++ b/src/syscall/zsyscall_plan9_386.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -l32 -plan9 -tags plan9,386 syscall_plan9.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build plan9 && 386
 // +build plan9,386
 
 package syscall
diff --git a/src/syscall/zsyscall_plan9_amd64.go b/src/syscall/zsyscall_plan9_amd64.go
index 02a28294ea..bed9108ea6 100644
--- a/src/syscall/zsyscall_plan9_amd64.go
+++ b/src/syscall/zsyscall_plan9_amd64.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -l32 -plan9 -tags plan9,amd64 syscall_plan9.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build plan9 && amd64
 // +build plan9,amd64
 
 package syscall
diff --git a/src/syscall/zsyscall_plan9_arm.go b/src/syscall/zsyscall_plan9_arm.go
index 449823976d..7bbcf9b4b7 100644
--- a/src/syscall/zsyscall_plan9_arm.go
+++ b/src/syscall/zsyscall_plan9_arm.go
@@ -1,6 +1,7 @@
 // mksyscall.pl -l32 -plan9 -tags plan9,arm syscall_plan9.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build plan9 && arm
 // +build plan9,arm
 
 package syscall
diff --git a/src/syscall/zsyscall_solaris_amd64.go b/src/syscall/zsyscall_solaris_amd64.go
index 446ebfc503..9b37dc0950 100644
--- a/src/syscall/zsyscall_solaris_amd64.go
+++ b/src/syscall/zsyscall_solaris_amd64.go
@@ -1,6 +1,7 @@
 // mksyscall_libc.pl -solaris -tags solaris,amd64 syscall_solaris.go syscall_solaris_amd64.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build solaris && amd64
 // +build solaris,amd64
 
 package syscall
diff --git a/src/syscall/zsysnum_darwin_amd64.go b/src/syscall/zsysnum_darwin_amd64.go
index a2331bee8a..f66f7d2715 100644
--- a/src/syscall/zsysnum_darwin_amd64.go
+++ b/src/syscall/zsysnum_darwin_amd64.go
@@ -1,6 +1,7 @@
 // mksysnum_darwin.pl /usr/include/sys/syscall.h
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build amd64 && darwin
 // +build amd64,darwin
 
 package syscall
diff --git a/src/syscall/zsysnum_darwin_arm64.go b/src/syscall/zsysnum_darwin_arm64.go
index 9548717945..6fa146368a 100644
--- a/src/syscall/zsysnum_darwin_arm64.go
+++ b/src/syscall/zsysnum_darwin_arm64.go
@@ -1,6 +1,7 @@
 // mksysnum_darwin.pl /usr/include/sys/syscall.h
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build arm64 && darwin
 // +build arm64,darwin
 
 package syscall
diff --git a/src/syscall/zsysnum_dragonfly_amd64.go b/src/syscall/zsysnum_dragonfly_amd64.go
index 9ce11f5899..855188f045 100644
--- a/src/syscall/zsysnum_dragonfly_amd64.go
+++ b/src/syscall/zsysnum_dragonfly_amd64.go
@@ -1,6 +1,7 @@
 // mksysnum_dragonfly.pl
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build amd64 && dragonfly
 // +build amd64,dragonfly
 
 package syscall
diff --git a/src/syscall/zsysnum_freebsd_386.go b/src/syscall/zsysnum_freebsd_386.go
index bb6e9d7ac3..1ed7e3ee8d 100644
--- a/src/syscall/zsysnum_freebsd_386.go
+++ b/src/syscall/zsysnum_freebsd_386.go
@@ -1,6 +1,7 @@
 // mksysnum_freebsd.pl
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build 386 && freebsd
 // +build 386,freebsd
 
 package syscall
diff --git a/src/syscall/zsysnum_freebsd_amd64.go b/src/syscall/zsysnum_freebsd_amd64.go
index f5d81abc51..d72dbc944a 100644
--- a/src/syscall/zsysnum_freebsd_amd64.go
+++ b/src/syscall/zsysnum_freebsd_amd64.go
@@ -1,6 +1,7 @@
 // mksysnum_freebsd.pl
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build amd64 && freebsd
 // +build amd64,freebsd
 
 package syscall
diff --git a/src/syscall/zsysnum_freebsd_arm.go b/src/syscall/zsysnum_freebsd_arm.go
index 006b49c245..4f4dc4db79 100644
--- a/src/syscall/zsysnum_freebsd_arm.go
+++ b/src/syscall/zsysnum_freebsd_arm.go
@@ -1,6 +1,7 @@
 // mksysnum_freebsd.pl
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build arm && freebsd
 // +build arm,freebsd
 
 package syscall
diff --git a/src/syscall/zsysnum_freebsd_arm64.go b/src/syscall/zsysnum_freebsd_arm64.go
index 0ce3d05cf2..ab1a05258e 100644
--- a/src/syscall/zsysnum_freebsd_arm64.go
+++ b/src/syscall/zsysnum_freebsd_arm64.go
@@ -1,6 +1,7 @@
 // mksysnum_freebsd.pl
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build arm64 && freebsd
 // +build arm64,freebsd
 
 package syscall
diff --git a/src/syscall/zsysnum_linux_386.go b/src/syscall/zsysnum_linux_386.go
index 6bcd22185e..792f43550e 100644
--- a/src/syscall/zsysnum_linux_386.go
+++ b/src/syscall/zsysnum_linux_386.go
@@ -1,6 +1,7 @@
 // mksysnum_linux.pl /usr/include/asm/unistd_32.h
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build 386 && linux
 // +build 386,linux
 
 package syscall
diff --git a/src/syscall/zsysnum_linux_amd64.go b/src/syscall/zsysnum_linux_amd64.go
index 70ca68639f..9ea18d6111 100644
--- a/src/syscall/zsysnum_linux_amd64.go
+++ b/src/syscall/zsysnum_linux_amd64.go
@@ -1,6 +1,7 @@
 // mksysnum_linux.pl /usr/include/asm/unistd_64.h
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build amd64 && linux
 // +build amd64,linux
 
 package syscall
diff --git a/src/syscall/zsysnum_linux_arm.go b/src/syscall/zsysnum_linux_arm.go
index 39ddc6536b..ccae9c15e3 100644
--- a/src/syscall/zsysnum_linux_arm.go
+++ b/src/syscall/zsysnum_linux_arm.go
@@ -1,6 +1,7 @@
 // mksysnum_linux.pl
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build arm && linux
 // +build arm,linux
 
 package syscall
diff --git a/src/syscall/zsysnum_linux_arm64.go b/src/syscall/zsysnum_linux_arm64.go
index 22a88b4dfe..17c54a2c83 100644
--- a/src/syscall/zsysnum_linux_arm64.go
+++ b/src/syscall/zsysnum_linux_arm64.go
@@ -1,6 +1,7 @@
 // mksysnum_linux.pl /usr/include/asm-generic/unistd.h
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build arm64 && linux
 // +build arm64,linux
 
 package syscall
diff --git a/src/syscall/zsysnum_linux_ppc64.go b/src/syscall/zsysnum_linux_ppc64.go
index 5882a7c058..a0d37ff1f2 100644
--- a/src/syscall/zsysnum_linux_ppc64.go
+++ b/src/syscall/zsysnum_linux_ppc64.go
@@ -1,6 +1,7 @@
 // mksysnum_linux.pl /usr/include/asm/unistd.h
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build ppc64 && linux
 // +build ppc64,linux
 
 package syscall
diff --git a/src/syscall/zsysnum_linux_ppc64le.go b/src/syscall/zsysnum_linux_ppc64le.go
index 4fb3f6cd29..f8f82d2043 100644
--- a/src/syscall/zsysnum_linux_ppc64le.go
+++ b/src/syscall/zsysnum_linux_ppc64le.go
@@ -1,6 +1,7 @@
 // mksysnum_linux.pl /usr/include/powerpc64le-linux-gnu/asm/unistd.h
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build ppc64le && linux
 // +build ppc64le,linux
 
 package syscall
diff --git a/src/syscall/zsysnum_netbsd_386.go b/src/syscall/zsysnum_netbsd_386.go
index 514d1f8cfd..4ff8d80341 100644
--- a/src/syscall/zsysnum_netbsd_386.go
+++ b/src/syscall/zsysnum_netbsd_386.go
@@ -1,6 +1,7 @@
 // mksysnum_netbsd.pl
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build 386 && netbsd
 // +build 386,netbsd
 
 package syscall
diff --git a/src/syscall/zsysnum_netbsd_amd64.go b/src/syscall/zsysnum_netbsd_amd64.go
index db05c03ecd..929da07604 100644
--- a/src/syscall/zsysnum_netbsd_amd64.go
+++ b/src/syscall/zsysnum_netbsd_amd64.go
@@ -1,6 +1,7 @@
 // mksysnum_netbsd.pl
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build amd64 && netbsd
 // +build amd64,netbsd
 
 package syscall
diff --git a/src/syscall/zsysnum_netbsd_arm.go b/src/syscall/zsysnum_netbsd_arm.go
index 9a10a4383a..998238518b 100644
--- a/src/syscall/zsysnum_netbsd_arm.go
+++ b/src/syscall/zsysnum_netbsd_arm.go
@@ -1,6 +1,7 @@
 // mksysnum_netbsd.pl
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build arm && netbsd
 // +build arm,netbsd
 
 package syscall
diff --git a/src/syscall/zsysnum_netbsd_arm64.go b/src/syscall/zsysnum_netbsd_arm64.go
index 31e13bf3b6..b3f5034390 100644
--- a/src/syscall/zsysnum_netbsd_arm64.go
+++ b/src/syscall/zsysnum_netbsd_arm64.go
@@ -1,6 +1,7 @@
 // mksysnum_netbsd.pl
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build arm64 && netbsd
 // +build arm64,netbsd
 
 package syscall
diff --git a/src/syscall/zsysnum_openbsd_386.go b/src/syscall/zsysnum_openbsd_386.go
index 39b9c78288..b289886d6c 100644
--- a/src/syscall/zsysnum_openbsd_386.go
+++ b/src/syscall/zsysnum_openbsd_386.go
@@ -1,6 +1,7 @@
 // mksysnum_openbsd.pl
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build 386 && openbsd
 // +build 386,openbsd
 
 package syscall
diff --git a/src/syscall/zsysnum_openbsd_amd64.go b/src/syscall/zsysnum_openbsd_amd64.go
index e176c4e23e..8cf2b68dcd 100644
--- a/src/syscall/zsysnum_openbsd_amd64.go
+++ b/src/syscall/zsysnum_openbsd_amd64.go
@@ -1,6 +1,7 @@
 // mksysnum_openbsd.pl
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build amd64 && openbsd
 // +build amd64,openbsd
 
 package syscall
diff --git a/src/syscall/zsysnum_openbsd_arm.go b/src/syscall/zsysnum_openbsd_arm.go
index 96bbdb09f5..cc33773a05 100644
--- a/src/syscall/zsysnum_openbsd_arm.go
+++ b/src/syscall/zsysnum_openbsd_arm.go
@@ -1,6 +1,7 @@
 // mksysnum_openbsd.pl
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build arm && openbsd
 // +build arm,openbsd
 
 package syscall
diff --git a/src/syscall/zsysnum_solaris_amd64.go b/src/syscall/zsysnum_solaris_amd64.go
index be198f899b..23c9c715b5 100644
--- a/src/syscall/zsysnum_solaris_amd64.go
+++ b/src/syscall/zsysnum_solaris_amd64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build amd64 && solaris
 // +build amd64,solaris
 
 package syscall
diff --git a/src/syscall/ztypes_darwin_amd64.go b/src/syscall/ztypes_darwin_amd64.go
index da56f0da22..8feacc47ab 100644
--- a/src/syscall/ztypes_darwin_amd64.go
+++ b/src/syscall/ztypes_darwin_amd64.go
@@ -1,6 +1,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs types_darwin.go
 
+//go:build amd64 && darwin
 // +build amd64,darwin
 
 package syscall
diff --git a/src/syscall/ztypes_darwin_arm64.go b/src/syscall/ztypes_darwin_arm64.go
index 82685ff659..8079d22429 100644
--- a/src/syscall/ztypes_darwin_arm64.go
+++ b/src/syscall/ztypes_darwin_arm64.go
@@ -1,6 +1,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs types_darwin.go
 
+//go:build arm64 && darwin
 // +build arm64,darwin
 
 package syscall
diff --git a/src/syscall/ztypes_dragonfly_amd64.go b/src/syscall/ztypes_dragonfly_amd64.go
index e9e811f776..a51e0038bb 100644
--- a/src/syscall/ztypes_dragonfly_amd64.go
+++ b/src/syscall/ztypes_dragonfly_amd64.go
@@ -1,6 +1,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs types_dragonfly.go
 
+//go:build amd64 && dragonfly
 // +build amd64,dragonfly
 
 package syscall
diff --git a/src/syscall/ztypes_freebsd_386.go b/src/syscall/ztypes_freebsd_386.go
index 27d82dea10..1739726883 100644
--- a/src/syscall/ztypes_freebsd_386.go
+++ b/src/syscall/ztypes_freebsd_386.go
@@ -1,6 +1,7 @@
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
 // cgo -godefs types_freebsd.go | go run mkpost.go
 
+//go:build 386 && freebsd
 // +build 386,freebsd
 
 package syscall
diff --git a/src/syscall/ztypes_freebsd_amd64.go b/src/syscall/ztypes_freebsd_amd64.go
index 8abfbb45d6..0457d8e995 100644
--- a/src/syscall/ztypes_freebsd_amd64.go
+++ b/src/syscall/ztypes_freebsd_amd64.go
@@ -1,6 +1,7 @@
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
 // cgo -godefs types_freebsd.go | go run mkpost.go
 
+//go:build amd64 && freebsd
 // +build amd64,freebsd
 
 package syscall
diff --git a/src/syscall/ztypes_freebsd_arm.go b/src/syscall/ztypes_freebsd_arm.go
index ff552a6a63..29c8380d89 100644
--- a/src/syscall/ztypes_freebsd_arm.go
+++ b/src/syscall/ztypes_freebsd_arm.go
@@ -1,6 +1,7 @@
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
 // cgo -godefs -- -fsigned-char types_freebsd.go
 
+//go:build arm && freebsd
 // +build arm,freebsd
 
 package syscall
diff --git a/src/syscall/ztypes_freebsd_arm64.go b/src/syscall/ztypes_freebsd_arm64.go
index 6d56fc85cf..6472db0080 100644
--- a/src/syscall/ztypes_freebsd_arm64.go
+++ b/src/syscall/ztypes_freebsd_arm64.go
@@ -1,6 +1,7 @@
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
 // cgo -godefs types_freebsd.go | go run mkpost.go
 
+//go:build arm64 && freebsd
 // +build arm64,freebsd
 
 package syscall
diff --git a/src/syscall/ztypes_linux_386.go b/src/syscall/ztypes_linux_386.go
index 0252620f48..251a0c0b4a 100644
--- a/src/syscall/ztypes_linux_386.go
+++ b/src/syscall/ztypes_linux_386.go
@@ -1,6 +1,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs types_linux.go
 
+//go:build 386 && linux
 // +build 386,linux
 
 package syscall
diff --git a/src/syscall/ztypes_linux_amd64.go b/src/syscall/ztypes_linux_amd64.go
index 1fb0ee566f..34c953fc8b 100644
--- a/src/syscall/ztypes_linux_amd64.go
+++ b/src/syscall/ztypes_linux_amd64.go
@@ -1,6 +1,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs types_linux.go
 
+//go:build amd64 && linux
 // +build amd64,linux
 
 package syscall
diff --git a/src/syscall/ztypes_linux_arm.go b/src/syscall/ztypes_linux_arm.go
index a88b577bed..4de656b491 100644
--- a/src/syscall/ztypes_linux_arm.go
+++ b/src/syscall/ztypes_linux_arm.go
@@ -1,6 +1,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs types_linux.go
 
+//go:build arm && linux
 // +build arm,linux
 
 package syscall
diff --git a/src/syscall/ztypes_linux_arm64.go b/src/syscall/ztypes_linux_arm64.go
index f63391cdad..bed9cb0851 100644
--- a/src/syscall/ztypes_linux_arm64.go
+++ b/src/syscall/ztypes_linux_arm64.go
@@ -1,6 +1,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs -- -fsigned-char types_linux.go
 
+//go:build arm64 && linux
 // +build arm64,linux
 
 package syscall
diff --git a/src/syscall/ztypes_linux_ppc64.go b/src/syscall/ztypes_linux_ppc64.go
index 8b6be21e2e..355533fb27 100644
--- a/src/syscall/ztypes_linux_ppc64.go
+++ b/src/syscall/ztypes_linux_ppc64.go
@@ -1,6 +1,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs types_linux.go
 
+//go:build ppc64 && linux
 // +build ppc64,linux
 
 package syscall
diff --git a/src/syscall/ztypes_linux_ppc64le.go b/src/syscall/ztypes_linux_ppc64le.go
index a9c3ee2626..94e12c742c 100644
--- a/src/syscall/ztypes_linux_ppc64le.go
+++ b/src/syscall/ztypes_linux_ppc64le.go
@@ -1,6 +1,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs types_linux.go
 
+//go:build ppc64le && linux
 // +build ppc64le,linux
 
 package syscall
diff --git a/src/syscall/ztypes_netbsd_386.go b/src/syscall/ztypes_netbsd_386.go
index 737abb87c7..321460f45a 100644
--- a/src/syscall/ztypes_netbsd_386.go
+++ b/src/syscall/ztypes_netbsd_386.go
@@ -1,6 +1,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs types_netbsd.go
 
+//go:build 386 && netbsd
 // +build 386,netbsd
 
 package syscall
diff --git a/src/syscall/ztypes_netbsd_amd64.go b/src/syscall/ztypes_netbsd_amd64.go
index cf059f79ff..370d717263 100644
--- a/src/syscall/ztypes_netbsd_amd64.go
+++ b/src/syscall/ztypes_netbsd_amd64.go
@@ -1,6 +1,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs types_netbsd.go
 
+//go:build amd64 && netbsd
 // +build amd64,netbsd
 
 package syscall
diff --git a/src/syscall/ztypes_netbsd_arm.go b/src/syscall/ztypes_netbsd_arm.go
index c532b3a7af..557c634533 100644
--- a/src/syscall/ztypes_netbsd_arm.go
+++ b/src/syscall/ztypes_netbsd_arm.go
@@ -1,6 +1,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs types_netbsd.go
 
+//go:build arm && netbsd
 // +build arm,netbsd
 
 package syscall
diff --git a/src/syscall/ztypes_netbsd_arm64.go b/src/syscall/ztypes_netbsd_arm64.go
index 6d7f9edf34..19f3690341 100644
--- a/src/syscall/ztypes_netbsd_arm64.go
+++ b/src/syscall/ztypes_netbsd_arm64.go
@@ -1,6 +1,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs types_netbsd.go
 
+//go:build arm64 && netbsd
 // +build arm64,netbsd
 
 package syscall
diff --git a/src/syscall/ztypes_openbsd_386.go b/src/syscall/ztypes_openbsd_386.go
index c2a03ebdd8..222c6c7e46 100644
--- a/src/syscall/ztypes_openbsd_386.go
+++ b/src/syscall/ztypes_openbsd_386.go
@@ -1,6 +1,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs types_openbsd.go
 
+//go:build 386 && openbsd
 // +build 386,openbsd
 
 package syscall
diff --git a/src/syscall/ztypes_openbsd_amd64.go b/src/syscall/ztypes_openbsd_amd64.go
index 1a659ba2fe..644ee9b3df 100644
--- a/src/syscall/ztypes_openbsd_amd64.go
+++ b/src/syscall/ztypes_openbsd_amd64.go
@@ -1,6 +1,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs types_openbsd.go
 
+//go:build amd64 && openbsd
 // +build amd64,openbsd
 
 package syscall
diff --git a/src/syscall/ztypes_solaris_amd64.go b/src/syscall/ztypes_solaris_amd64.go
index f846666fff..64e16b4943 100644
--- a/src/syscall/ztypes_solaris_amd64.go
+++ b/src/syscall/ztypes_solaris_amd64.go
@@ -1,6 +1,7 @@
 // Created by cgo -godefs - DO NOT EDIT
 // cgo -godefs types_solaris.go
 
+//go:build amd64 && solaris
 // +build amd64,solaris
 
 package syscall
diff --git a/src/testing/run_example.go b/src/testing/run_example.go
index 4dc83f7d32..d9e342d495 100644
--- a/src/testing/run_example.go
+++ b/src/testing/run_example.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !js
 // +build !js
 
 // TODO(@musiol, @odeke-em): re-unify this entire file back into
diff --git a/src/testing/run_example_js.go b/src/testing/run_example_js.go
index 1d4164b61f..d914633ba9 100644
--- a/src/testing/run_example_js.go
+++ b/src/testing/run_example_js.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build js
 // +build js
 
 package testing
diff --git a/src/time/embed.go b/src/time/embed.go
index cb4fdac4ef..34490c859d 100644
--- a/src/time/embed.go
+++ b/src/time/embed.go
@@ -5,6 +5,7 @@
 // This file is used with build tag timetzdata to embed tzdata into
 // the binary.
 
+//go:build timetzdata
 // +build timetzdata
 
 package time
diff --git a/src/time/genzabbrs.go b/src/time/genzabbrs.go
index 9825e705d2..9fd2f2b762 100644
--- a/src/time/genzabbrs.go
+++ b/src/time/genzabbrs.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 //
diff --git a/src/time/sys_plan9.go b/src/time/sys_plan9.go
index b7fba0802c..4dc55e44aa 100644
--- a/src/time/sys_plan9.go
+++ b/src/time/sys_plan9.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build plan9
 // +build plan9
 
 package time
diff --git a/src/time/sys_unix.go b/src/time/sys_unix.go
index 97b1140bbc..60fc090dc9 100644
--- a/src/time/sys_unix.go
+++ b/src/time/sys_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris
 
 package time
diff --git a/src/time/tzdata/generate_zipdata.go b/src/time/tzdata/generate_zipdata.go
index 21357fbf1c..64b5b1b22c 100644
--- a/src/time/tzdata/generate_zipdata.go
+++ b/src/time/tzdata/generate_zipdata.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // This program generates zipdata.go from $GOROOT/lib/time/zoneinfo.zip.
diff --git a/src/time/zoneinfo_ios.go b/src/time/zoneinfo_ios.go
index 0f1e9334b5..044691e130 100644
--- a/src/time/zoneinfo_ios.go
+++ b/src/time/zoneinfo_ios.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ios
 // +build ios
 
 package time
diff --git a/src/time/zoneinfo_js.go b/src/time/zoneinfo_js.go
index 2d76a571f2..8245614d2e 100644
--- a/src/time/zoneinfo_js.go
+++ b/src/time/zoneinfo_js.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build js && wasm
 // +build js,wasm
 
 package time
diff --git a/src/time/zoneinfo_unix.go b/src/time/zoneinfo_unix.go
index d2465eef65..4ea029dbde 100644
--- a/src/time/zoneinfo_unix.go
+++ b/src/time/zoneinfo_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || (darwin && !ios) || dragonfly || freebsd || (linux && !android) || netbsd || openbsd || solaris
 // +build aix darwin,!ios dragonfly freebsd linux,!android netbsd openbsd solaris
 
 // Parse "zoneinfo" time zone file.
diff --git a/src/time/zoneinfo_unix_test.go b/src/time/zoneinfo_unix_test.go
index f290ae754f..b75b374c3d 100644
--- a/src/time/zoneinfo_unix_test.go
+++ b/src/time/zoneinfo_unix_test.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || (darwin && !ios) || dragonfly || freebsd || (linux && !android) || netbsd || openbsd || solaris
 // +build aix darwin,!ios dragonfly freebsd linux,!android netbsd openbsd solaris
 
 package time_test
-- 
GitLab


From 40656f3a758728276e164ecb48822527a80e5f7b Mon Sep 17 00:00:00 2001
From: Alberto Donizetti <alb.donizetti@gmail.com>
Date: Sat, 20 Feb 2021 17:53:43 +0100
Subject: [PATCH 0748/2400] doc/1.16: fix link to fs.FileInfo

Updates #40700

Change-Id: Ifff622ccadaa31c0c0684c3c695aadcaa2305623
Reviewed-on: https://go-review.googlesource.com/c/go/+/294669
Trust: Alberto Donizetti <alb.donizetti@gmail.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 doc/go1.16.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/go1.16.html b/doc/go1.16.html
index 0beb62d160..f2370e8363 100644
--- a/doc/go1.16.html
+++ b/doc/go1.16.html
@@ -548,7 +548,7 @@ func TestFoo(t *testing.T) {
       (note: returns a slice of
       <a href="/pkg/os/#DirEntry"><code>os.DirEntry</code></a>
       rather than a slice of
-      <a href="/pkg/fs/#FileInfo"><code>fs.FileInfo</code></a>)
+      <a href="/pkg/io/fs/#FileInfo"><code>fs.FileInfo</code></a>)
     </li>
     <li><a href="/pkg/io/ioutil/#ReadFile"><code>ReadFile</code></a>
       => <a href="/pkg/os/#ReadFile"><code>os.ReadFile</code></a></li>
-- 
GitLab


From 03d36d8198428a6970ba01f5de41c264acbff8fc Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Sat, 20 Feb 2021 11:25:15 -0800
Subject: [PATCH 0749/2400] syscall: add explicit ios build tag

This permits analysis of the syscall package by tools built with
older versions of Go that do not recognize ios as a GOOS.

Fixes #44459

Change-Id: I79cec2ffe0dbcbc2dc45a385e556dc9e62033125
Reviewed-on: https://go-review.googlesource.com/c/go/+/294634
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/syscall/ptrace_ios.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/syscall/ptrace_ios.go b/src/syscall/ptrace_ios.go
index 2f61a88a08..5209d1e0dd 100644
--- a/src/syscall/ptrace_ios.go
+++ b/src/syscall/ptrace_ios.go
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ios
+// +build ios
+
 package syscall
 
 // Nosplit because it is called from forkAndExecInChild.
-- 
GitLab


From e78e04ce39b9df316edda08f43f253f5e9ac509e Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Fri, 19 Feb 2021 10:09:15 -0500
Subject: [PATCH 0750/2400] cmd/compile: fix panic in DWARF-gen handling
 obfuscated code

DWARF generation uses variable source positions (file/line/col) as a
way to uniquely identify locals and parameters, as part of the process
of matching up post-optimization variables with the corresponding
pre-optimization versions (since the DWARF needs to be in terms of the
original source constructs).

This strategy can run into problems when compiling obfuscated or
machine-generated code, where you can in some circumstances wind up
with two local variables that appear to have the same name, file,
line, and column. This patch changes DWARF generation to skip over
such duplicates as opposed to issuing a fatal error (if an
obfuscation tool is in use, it is unlikely that a human being will be
able to make much sense of DWARF info in any case).

Fixes #44378.

Change-Id: I198022d184701aa9ec3dce42c005d29b72d2e321
Reviewed-on: https://go-review.googlesource.com/c/go/+/294289
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/dwarfgen/dwinl.go |  3 +-
 test/fixedbugs/issue44378.go               | 40 ++++++++++++++++++++++
 2 files changed, 42 insertions(+), 1 deletion(-)
 create mode 100644 test/fixedbugs/issue44378.go

diff --git a/src/cmd/compile/internal/dwarfgen/dwinl.go b/src/cmd/compile/internal/dwarfgen/dwinl.go
index d5687cb1d7..8adb36fc88 100644
--- a/src/cmd/compile/internal/dwarfgen/dwinl.go
+++ b/src/cmd/compile/internal/dwarfgen/dwinl.go
@@ -247,7 +247,8 @@ func makePreinlineDclMap(fnsym *obj.LSym) map[varPos]int {
 			DeclCol:  pos.Col(),
 		}
 		if _, found := m[vp]; found {
-			base.Fatalf("child dcl collision on symbol %s within %v\n", n.Sym().Name, fnsym.Name)
+			// We can see collisions (variables with the same name/file/line/col) in obfuscated or machine-generated code -- see issue 44378 for an example. Skip duplicates in such cases, since it is unlikely that a human will be debugging such code.
+			continue
 		}
 		m[vp] = i
 	}
diff --git a/test/fixedbugs/issue44378.go b/test/fixedbugs/issue44378.go
new file mode 100644
index 0000000000..58c88d573f
--- /dev/null
+++ b/test/fixedbugs/issue44378.go
@@ -0,0 +1,40 @@
+// compile
+
+// Copyright 2021 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.
+
+// This test case caused a panic in the compiler's DWARF gen code.
+
+// Note to future maintainers of this code:
+//
+//    ** Do NOT run gofmt when editing this file **
+//
+// In order for the buggy behavior to be triggered in the compiler,
+// we need to have a the function of interest all on one gigantic line.
+
+package a
+
+type O interface{}
+type IO int
+type OS int
+
+type A struct {
+	x int
+}
+
+// original versions of the two function
+func (p *A) UO(o O) {
+	p.r(o, o)
+}
+func (p *A) r(o1, o2 O) {
+	switch x := o1.(type) {
+	case *IO:
+		p.x = int(*x)
+	case *OS:
+		p.x = int(*x + 2)
+	}
+}
+
+// see note above about the importance of all this code winding up on one line.
+var myverylongname0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 int ; func (p *A) UO2(o O) { p.r2(o, o); }; func (p *A) r2(o1, o2 O) { switch x := o1.(type) { case *IO:	p.x = int(*x); 	case *OS: 	p.x = int(*x + 2); } }
-- 
GitLab


From 0f66fb7b856b02497cf801ce72d80f375f53358b Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Fri, 19 Feb 2021 10:34:55 -0500
Subject: [PATCH 0751/2400] go/internal/gccgoimporter: fix up gccgo
 installation test

Change the TestInstallationImporter testpoint to query type
information for sort.Search instead of sort.Ints. The latter function
changed recently (1.16 timeframe), parameter "a" is now "x". A better
candidate for this sort of query is sort.Search, which has been stable
for a while.

Fixes #44425.

Change-Id: I314476eac0b0802f86f5cbce32195cab2926db83
Reviewed-on: https://go-review.googlesource.com/c/go/+/294290
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/go/internal/gccgoimporter/gccgoinstallation_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/go/internal/gccgoimporter/gccgoinstallation_test.go b/src/go/internal/gccgoimporter/gccgoinstallation_test.go
index b332babc7b..df0188ace7 100644
--- a/src/go/internal/gccgoimporter/gccgoinstallation_test.go
+++ b/src/go/internal/gccgoimporter/gccgoinstallation_test.go
@@ -184,7 +184,7 @@ func TestInstallationImporter(t *testing.T) {
 		{pkgpath: "io", name: "ReadWriter", want: "type ReadWriter interface{Reader; Writer}"},
 		{pkgpath: "math", name: "Pi", want: "const Pi untyped float"},
 		{pkgpath: "math", name: "Sin", want: "func Sin(x float64) float64"},
-		{pkgpath: "sort", name: "Ints", want: "func Ints(a []int)"},
+		{pkgpath: "sort", name: "Search", want: "func Search(n int, f func(int) bool) int"},
 		{pkgpath: "unsafe", name: "Pointer", want: "type Pointer"},
 	} {
 		runImporterTest(t, imp, nil, &test)
-- 
GitLab


From b2bdadfe88c205baed2f3dde6aa4709940ce4a7b Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Mon, 2 Nov 2020 15:05:40 -0600
Subject: [PATCH 0752/2400] cmd/internal: cleanup ppc64 optab structure

This is no-functionality change to begin the process of supporting
more than 6 operands.

This rewrites the table to use named arguments, and removes default
initialized argument values.  The following sed regexes rewrote the table:

  s/{\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\)}/{as:\1,a1:\2,a2:\3,a3:\4,a4:\5,type_:\6,size:\7,param:\8}
  s/a[1-4]: C_NONE, //g
  s/, param: 0//

Change-Id: I5f4de9da75f2fb3964d625d6b4e2f1ce1e29cc47
Reviewed-on: https://go-review.googlesource.com/c/go/+/294189
Trust: Lynn Boger <laboger@linux.vnet.ibm.com>
Run-TryBot: Lynn Boger <laboger@linux.vnet.ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Carlos Eduardo Seo <carlos.seo@linaro.org>
---
 src/cmd/internal/obj/ppc64/asm9.go | 912 +++++++++++++++--------------
 1 file changed, 459 insertions(+), 453 deletions(-)

diff --git a/src/cmd/internal/obj/ppc64/asm9.go b/src/cmd/internal/obj/ppc64/asm9.go
index 41e263b2c0..97b4cb2317 100644
--- a/src/cmd/internal/obj/ppc64/asm9.go
+++ b/src/cmd/internal/obj/ppc64/asm9.go
@@ -73,558 +73,564 @@ type Optab struct {
 	param int16
 }
 
-// This optab contains a list of opcodes with the operand
-// combinations that are implemented. Not all opcodes are in this
-// table, but are added later in buildop by calling opset for those
-// opcodes which allow the same operand combinations as an opcode
-// already in the table.
+// optab contains an array to be sliced of accepted operand combinations for an
+// instruction. Unused arguments and fields are not explicitly enumerated, and
+// should not be listed for clarity. Unused arguments and values should always
+// assume the default value for the given type.
 //
-// The type field in the Optabl identifies the case in asmout where
-// the instruction word is assembled.
+// optab does not list every valid ppc64 opcode, it enumerates representative
+// operand combinations for a class of instruction.  The variable oprange indexes
+// all valid ppc64 opcodes.
+//
+// oprange is initialized to point a slice within optab which contains the valid
+// operand combinations for a given instruction.  This is initialized from buildop.
+//
+// Likewise, each slice of optab is dynamically sorted using the ocmp Sort interface
+// to arrange entries to minimize text size of each opcode.
 var optab = []Optab{
-	{obj.ATEXT, C_LEXT, C_NONE, C_NONE, C_TEXTSIZE, 0, 0, 0},
-	{obj.ATEXT, C_LEXT, C_NONE, C_LCON, C_TEXTSIZE, 0, 0, 0},
-	{obj.ATEXT, C_ADDR, C_NONE, C_NONE, C_TEXTSIZE, 0, 0, 0},
-	{obj.ATEXT, C_ADDR, C_NONE, C_LCON, C_TEXTSIZE, 0, 0, 0},
+	{as: obj.ATEXT, a1: C_LEXT, a4: C_TEXTSIZE, type_: 0, size: 0},
+	{as: obj.ATEXT, a1: C_LEXT, a3: C_LCON, a4: C_TEXTSIZE, type_: 0, size: 0},
+	{as: obj.ATEXT, a1: C_ADDR, a4: C_TEXTSIZE, type_: 0, size: 0},
+	{as: obj.ATEXT, a1: C_ADDR, a3: C_LCON, a4: C_TEXTSIZE, type_: 0, size: 0},
 	/* move register */
-	{AMOVD, C_REG, C_NONE, C_NONE, C_REG, 1, 4, 0},
-	{AMOVB, C_REG, C_NONE, C_NONE, C_REG, 12, 4, 0},
-	{AMOVBZ, C_REG, C_NONE, C_NONE, C_REG, 13, 4, 0},
-	{AMOVW, C_REG, C_NONE, C_NONE, C_REG, 12, 4, 0},
-	{AMOVWZ, C_REG, C_NONE, C_NONE, C_REG, 13, 4, 0},
-	{AADD, C_REG, C_REG, C_NONE, C_REG, 2, 4, 0},
-	{AADD, C_REG, C_NONE, C_NONE, C_REG, 2, 4, 0},
-	{AADD, C_SCON, C_REG, C_NONE, C_REG, 4, 4, 0},
-	{AADD, C_SCON, C_NONE, C_NONE, C_REG, 4, 4, 0},
-	{AADD, C_ADDCON, C_REG, C_NONE, C_REG, 4, 4, 0},
-	{AADD, C_ADDCON, C_NONE, C_NONE, C_REG, 4, 4, 0},
-	{AADD, C_UCON, C_REG, C_NONE, C_REG, 20, 4, 0},
-	{AADD, C_UCON, C_NONE, C_NONE, C_REG, 20, 4, 0},
-	{AADD, C_ANDCON, C_REG, C_NONE, C_REG, 22, 8, 0},
-	{AADD, C_ANDCON, C_NONE, C_NONE, C_REG, 22, 8, 0},
-	{AADD, C_LCON, C_REG, C_NONE, C_REG, 22, 12, 0},
-	{AADD, C_LCON, C_NONE, C_NONE, C_REG, 22, 12, 0},
-	{AADDIS, C_ADDCON, C_REG, C_NONE, C_REG, 20, 4, 0},
-	{AADDIS, C_ADDCON, C_NONE, C_NONE, C_REG, 20, 4, 0},
-	{AADDC, C_REG, C_REG, C_NONE, C_REG, 2, 4, 0},
-	{AADDC, C_REG, C_NONE, C_NONE, C_REG, 2, 4, 0},
-	{AADDC, C_ADDCON, C_REG, C_NONE, C_REG, 4, 4, 0},
-	{AADDC, C_ADDCON, C_NONE, C_NONE, C_REG, 4, 4, 0},
-	{AADDC, C_LCON, C_REG, C_NONE, C_REG, 22, 12, 0},
-	{AADDC, C_LCON, C_NONE, C_NONE, C_REG, 22, 12, 0},
-	{AAND, C_REG, C_REG, C_NONE, C_REG, 6, 4, 0}, /* logical, no literal */
-	{AAND, C_REG, C_NONE, C_NONE, C_REG, 6, 4, 0},
-	{AANDCC, C_REG, C_REG, C_NONE, C_REG, 6, 4, 0},
-	{AANDCC, C_REG, C_NONE, C_NONE, C_REG, 6, 4, 0},
-	{AANDCC, C_ANDCON, C_NONE, C_NONE, C_REG, 58, 4, 0},
-	{AANDCC, C_ANDCON, C_REG, C_NONE, C_REG, 58, 4, 0},
-	{AANDCC, C_UCON, C_NONE, C_NONE, C_REG, 59, 4, 0},
-	{AANDCC, C_UCON, C_REG, C_NONE, C_REG, 59, 4, 0},
-	{AANDCC, C_ADDCON, C_NONE, C_NONE, C_REG, 23, 8, 0},
-	{AANDCC, C_ADDCON, C_REG, C_NONE, C_REG, 23, 8, 0},
-	{AANDCC, C_LCON, C_NONE, C_NONE, C_REG, 23, 12, 0},
-	{AANDCC, C_LCON, C_REG, C_NONE, C_REG, 23, 12, 0},
-	{AANDISCC, C_ANDCON, C_NONE, C_NONE, C_REG, 59, 4, 0},
-	{AANDISCC, C_ANDCON, C_REG, C_NONE, C_REG, 59, 4, 0},
-	{AMULLW, C_REG, C_REG, C_NONE, C_REG, 2, 4, 0},
-	{AMULLW, C_REG, C_NONE, C_NONE, C_REG, 2, 4, 0},
-	{AMULLW, C_ADDCON, C_REG, C_NONE, C_REG, 4, 4, 0},
-	{AMULLW, C_ADDCON, C_NONE, C_NONE, C_REG, 4, 4, 0},
-	{AMULLW, C_ANDCON, C_REG, C_NONE, C_REG, 4, 4, 0},
-	{AMULLW, C_ANDCON, C_NONE, C_NONE, C_REG, 4, 4, 0},
-	{AMULLW, C_LCON, C_REG, C_NONE, C_REG, 22, 12, 0},
-	{AMULLW, C_LCON, C_NONE, C_NONE, C_REG, 22, 12, 0},
-	{ASUBC, C_REG, C_REG, C_NONE, C_REG, 10, 4, 0},
-	{ASUBC, C_REG, C_NONE, C_NONE, C_REG, 10, 4, 0},
-	{ASUBC, C_REG, C_NONE, C_ADDCON, C_REG, 27, 4, 0},
-	{ASUBC, C_REG, C_NONE, C_LCON, C_REG, 28, 12, 0},
-	{AOR, C_REG, C_REG, C_NONE, C_REG, 6, 4, 0}, /* logical, literal not cc (or/xor) */
-	{AOR, C_REG, C_NONE, C_NONE, C_REG, 6, 4, 0},
-	{AOR, C_ANDCON, C_NONE, C_NONE, C_REG, 58, 4, 0},
-	{AOR, C_ANDCON, C_REG, C_NONE, C_REG, 58, 4, 0},
-	{AOR, C_UCON, C_NONE, C_NONE, C_REG, 59, 4, 0},
-	{AOR, C_UCON, C_REG, C_NONE, C_REG, 59, 4, 0},
-	{AOR, C_ADDCON, C_NONE, C_NONE, C_REG, 23, 8, 0},
-	{AOR, C_ADDCON, C_REG, C_NONE, C_REG, 23, 8, 0},
-	{AOR, C_LCON, C_NONE, C_NONE, C_REG, 23, 12, 0},
-	{AOR, C_LCON, C_REG, C_NONE, C_REG, 23, 12, 0},
-	{AORIS, C_ANDCON, C_NONE, C_NONE, C_REG, 59, 4, 0},
-	{AORIS, C_ANDCON, C_REG, C_NONE, C_REG, 59, 4, 0},
-	{ADIVW, C_REG, C_REG, C_NONE, C_REG, 2, 4, 0}, /* op r1[,r2],r3 */
-	{ADIVW, C_REG, C_NONE, C_NONE, C_REG, 2, 4, 0},
-	{ASUB, C_REG, C_REG, C_NONE, C_REG, 10, 4, 0}, /* op r2[,r1],r3 */
-	{ASUB, C_REG, C_NONE, C_NONE, C_REG, 10, 4, 0},
-	{ASLW, C_REG, C_NONE, C_NONE, C_REG, 6, 4, 0},
-	{ASLW, C_REG, C_REG, C_NONE, C_REG, 6, 4, 0},
-	{ASLD, C_REG, C_NONE, C_NONE, C_REG, 6, 4, 0},
-	{ASLD, C_REG, C_REG, C_NONE, C_REG, 6, 4, 0},
-	{ASLD, C_SCON, C_REG, C_NONE, C_REG, 25, 4, 0},
-	{ASLD, C_SCON, C_NONE, C_NONE, C_REG, 25, 4, 0},
-	{AEXTSWSLI, C_SCON, C_NONE, C_NONE, C_REG, 25, 4, 0},
-	{AEXTSWSLI, C_SCON, C_REG, C_NONE, C_REG, 25, 4, 0},
-	{ASLW, C_SCON, C_REG, C_NONE, C_REG, 57, 4, 0},
-	{ASLW, C_SCON, C_NONE, C_NONE, C_REG, 57, 4, 0},
-	{ASRAW, C_REG, C_NONE, C_NONE, C_REG, 6, 4, 0},
-	{ASRAW, C_REG, C_REG, C_NONE, C_REG, 6, 4, 0},
-	{ASRAW, C_SCON, C_REG, C_NONE, C_REG, 56, 4, 0},
-	{ASRAW, C_SCON, C_NONE, C_NONE, C_REG, 56, 4, 0},
-	{ASRAD, C_REG, C_NONE, C_NONE, C_REG, 6, 4, 0},
-	{ASRAD, C_REG, C_REG, C_NONE, C_REG, 6, 4, 0},
-	{ASRAD, C_SCON, C_REG, C_NONE, C_REG, 56, 4, 0},
-	{ASRAD, C_SCON, C_NONE, C_NONE, C_REG, 56, 4, 0},
-	{ARLWMI, C_SCON, C_REG, C_LCON, C_REG, 62, 4, 0},
-	{ARLWMI, C_REG, C_REG, C_LCON, C_REG, 63, 4, 0},
-	{ACLRLSLWI, C_SCON, C_REG, C_LCON, C_REG, 62, 4, 0},
-	{ARLDMI, C_SCON, C_REG, C_LCON, C_REG, 30, 4, 0},
-	{ARLDC, C_SCON, C_REG, C_LCON, C_REG, 29, 4, 0},
-	{ARLDCL, C_SCON, C_REG, C_LCON, C_REG, 29, 4, 0},
-	{ARLDCL, C_REG, C_REG, C_LCON, C_REG, 14, 4, 0},
-	{ARLDICL, C_REG, C_REG, C_LCON, C_REG, 14, 4, 0},
-	{ARLDICL, C_SCON, C_REG, C_LCON, C_REG, 14, 4, 0},
-	{ARLDCL, C_REG, C_NONE, C_LCON, C_REG, 14, 4, 0},
-	{AFADD, C_FREG, C_NONE, C_NONE, C_FREG, 2, 4, 0},
-	{AFADD, C_FREG, C_FREG, C_NONE, C_FREG, 2, 4, 0},
-	{AFABS, C_FREG, C_NONE, C_NONE, C_FREG, 33, 4, 0},
-	{AFABS, C_NONE, C_NONE, C_NONE, C_FREG, 33, 4, 0},
-	{AFMOVD, C_FREG, C_NONE, C_NONE, C_FREG, 33, 4, 0},
-	{AFMADD, C_FREG, C_FREG, C_FREG, C_FREG, 34, 4, 0},
-	{AFMUL, C_FREG, C_NONE, C_NONE, C_FREG, 32, 4, 0},
-	{AFMUL, C_FREG, C_FREG, C_NONE, C_FREG, 32, 4, 0},
+	{as: AMOVD, a1: C_REG, a4: C_REG, type_: 1, size: 4},
+	{as: AMOVB, a1: C_REG, a4: C_REG, type_: 12, size: 4},
+	{as: AMOVBZ, a1: C_REG, a4: C_REG, type_: 13, size: 4},
+	{as: AMOVW, a1: C_REG, a4: C_REG, type_: 12, size: 4},
+	{as: AMOVWZ, a1: C_REG, a4: C_REG, type_: 13, size: 4},
+	{as: AADD, a1: C_REG, a2: C_REG, a4: C_REG, type_: 2, size: 4},
+	{as: AADD, a1: C_REG, a4: C_REG, type_: 2, size: 4},
+	{as: AADD, a1: C_SCON, a2: C_REG, a4: C_REG, type_: 4, size: 4},
+	{as: AADD, a1: C_SCON, a4: C_REG, type_: 4, size: 4},
+	{as: AADD, a1: C_ADDCON, a2: C_REG, a4: C_REG, type_: 4, size: 4},
+	{as: AADD, a1: C_ADDCON, a4: C_REG, type_: 4, size: 4},
+	{as: AADD, a1: C_UCON, a2: C_REG, a4: C_REG, type_: 20, size: 4},
+	{as: AADD, a1: C_UCON, a4: C_REG, type_: 20, size: 4},
+	{as: AADD, a1: C_ANDCON, a2: C_REG, a4: C_REG, type_: 22, size: 8},
+	{as: AADD, a1: C_ANDCON, a4: C_REG, type_: 22, size: 8},
+	{as: AADD, a1: C_LCON, a2: C_REG, a4: C_REG, type_: 22, size: 12},
+	{as: AADD, a1: C_LCON, a4: C_REG, type_: 22, size: 12},
+	{as: AADDIS, a1: C_ADDCON, a2: C_REG, a4: C_REG, type_: 20, size: 4},
+	{as: AADDIS, a1: C_ADDCON, a4: C_REG, type_: 20, size: 4},
+	{as: AADDC, a1: C_REG, a2: C_REG, a4: C_REG, type_: 2, size: 4},
+	{as: AADDC, a1: C_REG, a4: C_REG, type_: 2, size: 4},
+	{as: AADDC, a1: C_ADDCON, a2: C_REG, a4: C_REG, type_: 4, size: 4},
+	{as: AADDC, a1: C_ADDCON, a4: C_REG, type_: 4, size: 4},
+	{as: AADDC, a1: C_LCON, a2: C_REG, a4: C_REG, type_: 22, size: 12},
+	{as: AADDC, a1: C_LCON, a4: C_REG, type_: 22, size: 12},
+	{as: AAND, a1: C_REG, a2: C_REG, a4: C_REG, type_: 6, size: 4}, /* logical, no literal */
+	{as: AAND, a1: C_REG, a4: C_REG, type_: 6, size: 4},
+	{as: AANDCC, a1: C_REG, a2: C_REG, a4: C_REG, type_: 6, size: 4},
+	{as: AANDCC, a1: C_REG, a4: C_REG, type_: 6, size: 4},
+	{as: AANDCC, a1: C_ANDCON, a4: C_REG, type_: 58, size: 4},
+	{as: AANDCC, a1: C_ANDCON, a2: C_REG, a4: C_REG, type_: 58, size: 4},
+	{as: AANDCC, a1: C_UCON, a4: C_REG, type_: 59, size: 4},
+	{as: AANDCC, a1: C_UCON, a2: C_REG, a4: C_REG, type_: 59, size: 4},
+	{as: AANDCC, a1: C_ADDCON, a4: C_REG, type_: 23, size: 8},
+	{as: AANDCC, a1: C_ADDCON, a2: C_REG, a4: C_REG, type_: 23, size: 8},
+	{as: AANDCC, a1: C_LCON, a4: C_REG, type_: 23, size: 12},
+	{as: AANDCC, a1: C_LCON, a2: C_REG, a4: C_REG, type_: 23, size: 12},
+	{as: AANDISCC, a1: C_ANDCON, a4: C_REG, type_: 59, size: 4},
+	{as: AANDISCC, a1: C_ANDCON, a2: C_REG, a4: C_REG, type_: 59, size: 4},
+	{as: AMULLW, a1: C_REG, a2: C_REG, a4: C_REG, type_: 2, size: 4},
+	{as: AMULLW, a1: C_REG, a4: C_REG, type_: 2, size: 4},
+	{as: AMULLW, a1: C_ADDCON, a2: C_REG, a4: C_REG, type_: 4, size: 4},
+	{as: AMULLW, a1: C_ADDCON, a4: C_REG, type_: 4, size: 4},
+	{as: AMULLW, a1: C_ANDCON, a2: C_REG, a4: C_REG, type_: 4, size: 4},
+	{as: AMULLW, a1: C_ANDCON, a4: C_REG, type_: 4, size: 4},
+	{as: AMULLW, a1: C_LCON, a2: C_REG, a4: C_REG, type_: 22, size: 12},
+	{as: AMULLW, a1: C_LCON, a4: C_REG, type_: 22, size: 12},
+	{as: ASUBC, a1: C_REG, a2: C_REG, a4: C_REG, type_: 10, size: 4},
+	{as: ASUBC, a1: C_REG, a4: C_REG, type_: 10, size: 4},
+	{as: ASUBC, a1: C_REG, a3: C_ADDCON, a4: C_REG, type_: 27, size: 4},
+	{as: ASUBC, a1: C_REG, a3: C_LCON, a4: C_REG, type_: 28, size: 12},
+	{as: AOR, a1: C_REG, a2: C_REG, a4: C_REG, type_: 6, size: 4}, /* logical, literal not cc (or/xor) */
+	{as: AOR, a1: C_REG, a4: C_REG, type_: 6, size: 4},
+	{as: AOR, a1: C_ANDCON, a4: C_REG, type_: 58, size: 4},
+	{as: AOR, a1: C_ANDCON, a2: C_REG, a4: C_REG, type_: 58, size: 4},
+	{as: AOR, a1: C_UCON, a4: C_REG, type_: 59, size: 4},
+	{as: AOR, a1: C_UCON, a2: C_REG, a4: C_REG, type_: 59, size: 4},
+	{as: AOR, a1: C_ADDCON, a4: C_REG, type_: 23, size: 8},
+	{as: AOR, a1: C_ADDCON, a2: C_REG, a4: C_REG, type_: 23, size: 8},
+	{as: AOR, a1: C_LCON, a4: C_REG, type_: 23, size: 12},
+	{as: AOR, a1: C_LCON, a2: C_REG, a4: C_REG, type_: 23, size: 12},
+	{as: AORIS, a1: C_ANDCON, a4: C_REG, type_: 59, size: 4},
+	{as: AORIS, a1: C_ANDCON, a2: C_REG, a4: C_REG, type_: 59, size: 4},
+	{as: ADIVW, a1: C_REG, a2: C_REG, a4: C_REG, type_: 2, size: 4}, /* op r1[,r2],r3 */
+	{as: ADIVW, a1: C_REG, a4: C_REG, type_: 2, size: 4},
+	{as: ASUB, a1: C_REG, a2: C_REG, a4: C_REG, type_: 10, size: 4}, /* op r2[,r1],r3 */
+	{as: ASUB, a1: C_REG, a4: C_REG, type_: 10, size: 4},
+	{as: ASLW, a1: C_REG, a4: C_REG, type_: 6, size: 4},
+	{as: ASLW, a1: C_REG, a2: C_REG, a4: C_REG, type_: 6, size: 4},
+	{as: ASLD, a1: C_REG, a4: C_REG, type_: 6, size: 4},
+	{as: ASLD, a1: C_REG, a2: C_REG, a4: C_REG, type_: 6, size: 4},
+	{as: ASLD, a1: C_SCON, a2: C_REG, a4: C_REG, type_: 25, size: 4},
+	{as: ASLD, a1: C_SCON, a4: C_REG, type_: 25, size: 4},
+	{as: AEXTSWSLI, a1: C_SCON, a4: C_REG, type_: 25, size: 4},
+	{as: AEXTSWSLI, a1: C_SCON, a2: C_REG, a4: C_REG, type_: 25, size: 4},
+	{as: ASLW, a1: C_SCON, a2: C_REG, a4: C_REG, type_: 57, size: 4},
+	{as: ASLW, a1: C_SCON, a4: C_REG, type_: 57, size: 4},
+	{as: ASRAW, a1: C_REG, a4: C_REG, type_: 6, size: 4},
+	{as: ASRAW, a1: C_REG, a2: C_REG, a4: C_REG, type_: 6, size: 4},
+	{as: ASRAW, a1: C_SCON, a2: C_REG, a4: C_REG, type_: 56, size: 4},
+	{as: ASRAW, a1: C_SCON, a4: C_REG, type_: 56, size: 4},
+	{as: ASRAD, a1: C_REG, a4: C_REG, type_: 6, size: 4},
+	{as: ASRAD, a1: C_REG, a2: C_REG, a4: C_REG, type_: 6, size: 4},
+	{as: ASRAD, a1: C_SCON, a2: C_REG, a4: C_REG, type_: 56, size: 4},
+	{as: ASRAD, a1: C_SCON, a4: C_REG, type_: 56, size: 4},
+	{as: ARLWMI, a1: C_SCON, a2: C_REG, a3: C_LCON, a4: C_REG, type_: 62, size: 4},
+	{as: ARLWMI, a1: C_REG, a2: C_REG, a3: C_LCON, a4: C_REG, type_: 63, size: 4},
+	{as: ACLRLSLWI, a1: C_SCON, a2: C_REG, a3: C_LCON, a4: C_REG, type_: 62, size: 4},
+	{as: ARLDMI, a1: C_SCON, a2: C_REG, a3: C_LCON, a4: C_REG, type_: 30, size: 4},
+	{as: ARLDC, a1: C_SCON, a2: C_REG, a3: C_LCON, a4: C_REG, type_: 29, size: 4},
+	{as: ARLDCL, a1: C_SCON, a2: C_REG, a3: C_LCON, a4: C_REG, type_: 29, size: 4},
+	{as: ARLDCL, a1: C_REG, a2: C_REG, a3: C_LCON, a4: C_REG, type_: 14, size: 4},
+	{as: ARLDICL, a1: C_REG, a2: C_REG, a3: C_LCON, a4: C_REG, type_: 14, size: 4},
+	{as: ARLDICL, a1: C_SCON, a2: C_REG, a3: C_LCON, a4: C_REG, type_: 14, size: 4},
+	{as: ARLDCL, a1: C_REG, a3: C_LCON, a4: C_REG, type_: 14, size: 4},
+	{as: AFADD, a1: C_FREG, a4: C_FREG, type_: 2, size: 4},
+	{as: AFADD, a1: C_FREG, a2: C_FREG, a4: C_FREG, type_: 2, size: 4},
+	{as: AFABS, a1: C_FREG, a4: C_FREG, type_: 33, size: 4},
+	{as: AFABS, a4: C_FREG, type_: 33, size: 4},
+	{as: AFMOVD, a1: C_FREG, a4: C_FREG, type_: 33, size: 4},
+	{as: AFMADD, a1: C_FREG, a2: C_FREG, a3: C_FREG, a4: C_FREG, type_: 34, size: 4},
+	{as: AFMUL, a1: C_FREG, a4: C_FREG, type_: 32, size: 4},
+	{as: AFMUL, a1: C_FREG, a2: C_FREG, a4: C_FREG, type_: 32, size: 4},
 
 	/* store, short offset */
-	{AMOVD, C_REG, C_REG, C_NONE, C_ZOREG, 7, 4, REGZERO},
-	{AMOVW, C_REG, C_REG, C_NONE, C_ZOREG, 7, 4, REGZERO},
-	{AMOVWZ, C_REG, C_REG, C_NONE, C_ZOREG, 7, 4, REGZERO},
-	{AMOVBZ, C_REG, C_REG, C_NONE, C_ZOREG, 7, 4, REGZERO},
-	{AMOVBZU, C_REG, C_REG, C_NONE, C_ZOREG, 7, 4, REGZERO},
-	{AMOVB, C_REG, C_REG, C_NONE, C_ZOREG, 7, 4, REGZERO},
-	{AMOVBU, C_REG, C_REG, C_NONE, C_ZOREG, 7, 4, REGZERO},
-	{AMOVD, C_REG, C_NONE, C_NONE, C_SEXT, 7, 4, REGSB},
-	{AMOVW, C_REG, C_NONE, C_NONE, C_SEXT, 7, 4, REGSB},
-	{AMOVWZ, C_REG, C_NONE, C_NONE, C_SEXT, 7, 4, REGSB},
-	{AMOVBZ, C_REG, C_NONE, C_NONE, C_SEXT, 7, 4, REGSB},
-	{AMOVB, C_REG, C_NONE, C_NONE, C_SEXT, 7, 4, REGSB},
-	{AMOVD, C_REG, C_NONE, C_NONE, C_SAUTO, 7, 4, REGSP},
-	{AMOVW, C_REG, C_NONE, C_NONE, C_SAUTO, 7, 4, REGSP},
-	{AMOVWZ, C_REG, C_NONE, C_NONE, C_SAUTO, 7, 4, REGSP},
-	{AMOVBZ, C_REG, C_NONE, C_NONE, C_SAUTO, 7, 4, REGSP},
-	{AMOVB, C_REG, C_NONE, C_NONE, C_SAUTO, 7, 4, REGSP},
-	{AMOVD, C_REG, C_NONE, C_NONE, C_SOREG, 7, 4, REGZERO},
-	{AMOVW, C_REG, C_NONE, C_NONE, C_SOREG, 7, 4, REGZERO},
-	{AMOVWZ, C_REG, C_NONE, C_NONE, C_SOREG, 7, 4, REGZERO},
-	{AMOVBZ, C_REG, C_NONE, C_NONE, C_SOREG, 7, 4, REGZERO},
-	{AMOVBZU, C_REG, C_NONE, C_NONE, C_SOREG, 7, 4, REGZERO},
-	{AMOVB, C_REG, C_NONE, C_NONE, C_SOREG, 7, 4, REGZERO},
-	{AMOVBU, C_REG, C_NONE, C_NONE, C_SOREG, 7, 4, REGZERO},
+	{as: AMOVD, a1: C_REG, a2: C_REG, a4: C_ZOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVW, a1: C_REG, a2: C_REG, a4: C_ZOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVWZ, a1: C_REG, a2: C_REG, a4: C_ZOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVBZ, a1: C_REG, a2: C_REG, a4: C_ZOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVBZU, a1: C_REG, a2: C_REG, a4: C_ZOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVB, a1: C_REG, a2: C_REG, a4: C_ZOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVBU, a1: C_REG, a2: C_REG, a4: C_ZOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVD, a1: C_REG, a4: C_SEXT, type_: 7, size: 4, param: REGSB},
+	{as: AMOVW, a1: C_REG, a4: C_SEXT, type_: 7, size: 4, param: REGSB},
+	{as: AMOVWZ, a1: C_REG, a4: C_SEXT, type_: 7, size: 4, param: REGSB},
+	{as: AMOVBZ, a1: C_REG, a4: C_SEXT, type_: 7, size: 4, param: REGSB},
+	{as: AMOVB, a1: C_REG, a4: C_SEXT, type_: 7, size: 4, param: REGSB},
+	{as: AMOVD, a1: C_REG, a4: C_SAUTO, type_: 7, size: 4, param: REGSP},
+	{as: AMOVW, a1: C_REG, a4: C_SAUTO, type_: 7, size: 4, param: REGSP},
+	{as: AMOVWZ, a1: C_REG, a4: C_SAUTO, type_: 7, size: 4, param: REGSP},
+	{as: AMOVBZ, a1: C_REG, a4: C_SAUTO, type_: 7, size: 4, param: REGSP},
+	{as: AMOVB, a1: C_REG, a4: C_SAUTO, type_: 7, size: 4, param: REGSP},
+	{as: AMOVD, a1: C_REG, a4: C_SOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVW, a1: C_REG, a4: C_SOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVWZ, a1: C_REG, a4: C_SOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVBZ, a1: C_REG, a4: C_SOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVBZU, a1: C_REG, a4: C_SOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVB, a1: C_REG, a4: C_SOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVBU, a1: C_REG, a4: C_SOREG, type_: 7, size: 4, param: REGZERO},
 
 	/* load, short offset */
-	{AMOVD, C_ZOREG, C_REG, C_NONE, C_REG, 8, 4, REGZERO},
-	{AMOVW, C_ZOREG, C_REG, C_NONE, C_REG, 8, 4, REGZERO},
-	{AMOVWZ, C_ZOREG, C_REG, C_NONE, C_REG, 8, 4, REGZERO},
-	{AMOVBZ, C_ZOREG, C_REG, C_NONE, C_REG, 8, 4, REGZERO},
-	{AMOVBZU, C_ZOREG, C_REG, C_NONE, C_REG, 8, 4, REGZERO},
-	{AMOVB, C_ZOREG, C_REG, C_NONE, C_REG, 9, 8, REGZERO},
-	{AMOVBU, C_ZOREG, C_REG, C_NONE, C_REG, 9, 8, REGZERO},
-	{AMOVD, C_SEXT, C_NONE, C_NONE, C_REG, 8, 4, REGSB},
-	{AMOVW, C_SEXT, C_NONE, C_NONE, C_REG, 8, 4, REGSB},
-	{AMOVWZ, C_SEXT, C_NONE, C_NONE, C_REG, 8, 4, REGSB},
-	{AMOVBZ, C_SEXT, C_NONE, C_NONE, C_REG, 8, 4, REGSB},
-	{AMOVB, C_SEXT, C_NONE, C_NONE, C_REG, 9, 8, REGSB},
-	{AMOVD, C_SAUTO, C_NONE, C_NONE, C_REG, 8, 4, REGSP},
-	{AMOVW, C_SAUTO, C_NONE, C_NONE, C_REG, 8, 4, REGSP},
-	{AMOVWZ, C_SAUTO, C_NONE, C_NONE, C_REG, 8, 4, REGSP},
-	{AMOVBZ, C_SAUTO, C_NONE, C_NONE, C_REG, 8, 4, REGSP},
-	{AMOVB, C_SAUTO, C_NONE, C_NONE, C_REG, 9, 8, REGSP},
-	{AMOVD, C_SOREG, C_NONE, C_NONE, C_REG, 8, 4, REGZERO},
-	{AMOVW, C_SOREG, C_NONE, C_NONE, C_REG, 8, 4, REGZERO},
-	{AMOVWZ, C_SOREG, C_NONE, C_NONE, C_REG, 8, 4, REGZERO},
-	{AMOVBZ, C_SOREG, C_NONE, C_NONE, C_REG, 8, 4, REGZERO},
-	{AMOVBZU, C_SOREG, C_NONE, C_NONE, C_REG, 8, 4, REGZERO},
-	{AMOVB, C_SOREG, C_NONE, C_NONE, C_REG, 9, 8, REGZERO},
-	{AMOVBU, C_SOREG, C_NONE, C_NONE, C_REG, 9, 8, REGZERO},
+	{as: AMOVD, a1: C_ZOREG, a2: C_REG, a4: C_REG, type_: 8, size: 4, param: REGZERO},
+	{as: AMOVW, a1: C_ZOREG, a2: C_REG, a4: C_REG, type_: 8, size: 4, param: REGZERO},
+	{as: AMOVWZ, a1: C_ZOREG, a2: C_REG, a4: C_REG, type_: 8, size: 4, param: REGZERO},
+	{as: AMOVBZ, a1: C_ZOREG, a2: C_REG, a4: C_REG, type_: 8, size: 4, param: REGZERO},
+	{as: AMOVBZU, a1: C_ZOREG, a2: C_REG, a4: C_REG, type_: 8, size: 4, param: REGZERO},
+	{as: AMOVB, a1: C_ZOREG, a2: C_REG, a4: C_REG, type_: 9, size: 8, param: REGZERO},
+	{as: AMOVBU, a1: C_ZOREG, a2: C_REG, a4: C_REG, type_: 9, size: 8, param: REGZERO},
+	{as: AMOVD, a1: C_SEXT, a4: C_REG, type_: 8, size: 4, param: REGSB},
+	{as: AMOVW, a1: C_SEXT, a4: C_REG, type_: 8, size: 4, param: REGSB},
+	{as: AMOVWZ, a1: C_SEXT, a4: C_REG, type_: 8, size: 4, param: REGSB},
+	{as: AMOVBZ, a1: C_SEXT, a4: C_REG, type_: 8, size: 4, param: REGSB},
+	{as: AMOVB, a1: C_SEXT, a4: C_REG, type_: 9, size: 8, param: REGSB},
+	{as: AMOVD, a1: C_SAUTO, a4: C_REG, type_: 8, size: 4, param: REGSP},
+	{as: AMOVW, a1: C_SAUTO, a4: C_REG, type_: 8, size: 4, param: REGSP},
+	{as: AMOVWZ, a1: C_SAUTO, a4: C_REG, type_: 8, size: 4, param: REGSP},
+	{as: AMOVBZ, a1: C_SAUTO, a4: C_REG, type_: 8, size: 4, param: REGSP},
+	{as: AMOVB, a1: C_SAUTO, a4: C_REG, type_: 9, size: 8, param: REGSP},
+	{as: AMOVD, a1: C_SOREG, a4: C_REG, type_: 8, size: 4, param: REGZERO},
+	{as: AMOVW, a1: C_SOREG, a4: C_REG, type_: 8, size: 4, param: REGZERO},
+	{as: AMOVWZ, a1: C_SOREG, a4: C_REG, type_: 8, size: 4, param: REGZERO},
+	{as: AMOVBZ, a1: C_SOREG, a4: C_REG, type_: 8, size: 4, param: REGZERO},
+	{as: AMOVBZU, a1: C_SOREG, a4: C_REG, type_: 8, size: 4, param: REGZERO},
+	{as: AMOVB, a1: C_SOREG, a4: C_REG, type_: 9, size: 8, param: REGZERO},
+	{as: AMOVBU, a1: C_SOREG, a4: C_REG, type_: 9, size: 8, param: REGZERO},
 
 	/* store, long offset */
-	{AMOVD, C_REG, C_NONE, C_NONE, C_LEXT, 35, 8, REGSB},
-	{AMOVW, C_REG, C_NONE, C_NONE, C_LEXT, 35, 8, REGSB},
-	{AMOVWZ, C_REG, C_NONE, C_NONE, C_LEXT, 35, 8, REGSB},
-	{AMOVBZ, C_REG, C_NONE, C_NONE, C_LEXT, 35, 8, REGSB},
-	{AMOVB, C_REG, C_NONE, C_NONE, C_LEXT, 35, 8, REGSB},
-	{AMOVD, C_REG, C_NONE, C_NONE, C_LAUTO, 35, 8, REGSP},
-	{AMOVW, C_REG, C_NONE, C_NONE, C_LAUTO, 35, 8, REGSP},
-	{AMOVWZ, C_REG, C_NONE, C_NONE, C_LAUTO, 35, 8, REGSP},
-	{AMOVBZ, C_REG, C_NONE, C_NONE, C_LAUTO, 35, 8, REGSP},
-	{AMOVB, C_REG, C_NONE, C_NONE, C_LAUTO, 35, 8, REGSP},
-	{AMOVD, C_REG, C_NONE, C_NONE, C_LOREG, 35, 8, REGZERO},
-	{AMOVW, C_REG, C_NONE, C_NONE, C_LOREG, 35, 8, REGZERO},
-	{AMOVWZ, C_REG, C_NONE, C_NONE, C_LOREG, 35, 8, REGZERO},
-	{AMOVBZ, C_REG, C_NONE, C_NONE, C_LOREG, 35, 8, REGZERO},
-	{AMOVB, C_REG, C_NONE, C_NONE, C_LOREG, 35, 8, REGZERO},
-	{AMOVD, C_REG, C_NONE, C_NONE, C_ADDR, 74, 8, 0},
-	{AMOVW, C_REG, C_NONE, C_NONE, C_ADDR, 74, 8, 0},
-	{AMOVWZ, C_REG, C_NONE, C_NONE, C_ADDR, 74, 8, 0},
-	{AMOVBZ, C_REG, C_NONE, C_NONE, C_ADDR, 74, 8, 0},
-	{AMOVB, C_REG, C_NONE, C_NONE, C_ADDR, 74, 8, 0},
+	{as: AMOVD, a1: C_REG, a4: C_LEXT, type_: 35, size: 8, param: REGSB},
+	{as: AMOVW, a1: C_REG, a4: C_LEXT, type_: 35, size: 8, param: REGSB},
+	{as: AMOVWZ, a1: C_REG, a4: C_LEXT, type_: 35, size: 8, param: REGSB},
+	{as: AMOVBZ, a1: C_REG, a4: C_LEXT, type_: 35, size: 8, param: REGSB},
+	{as: AMOVB, a1: C_REG, a4: C_LEXT, type_: 35, size: 8, param: REGSB},
+	{as: AMOVD, a1: C_REG, a4: C_LAUTO, type_: 35, size: 8, param: REGSP},
+	{as: AMOVW, a1: C_REG, a4: C_LAUTO, type_: 35, size: 8, param: REGSP},
+	{as: AMOVWZ, a1: C_REG, a4: C_LAUTO, type_: 35, size: 8, param: REGSP},
+	{as: AMOVBZ, a1: C_REG, a4: C_LAUTO, type_: 35, size: 8, param: REGSP},
+	{as: AMOVB, a1: C_REG, a4: C_LAUTO, type_: 35, size: 8, param: REGSP},
+	{as: AMOVD, a1: C_REG, a4: C_LOREG, type_: 35, size: 8, param: REGZERO},
+	{as: AMOVW, a1: C_REG, a4: C_LOREG, type_: 35, size: 8, param: REGZERO},
+	{as: AMOVWZ, a1: C_REG, a4: C_LOREG, type_: 35, size: 8, param: REGZERO},
+	{as: AMOVBZ, a1: C_REG, a4: C_LOREG, type_: 35, size: 8, param: REGZERO},
+	{as: AMOVB, a1: C_REG, a4: C_LOREG, type_: 35, size: 8, param: REGZERO},
+	{as: AMOVD, a1: C_REG, a4: C_ADDR, type_: 74, size: 8},
+	{as: AMOVW, a1: C_REG, a4: C_ADDR, type_: 74, size: 8},
+	{as: AMOVWZ, a1: C_REG, a4: C_ADDR, type_: 74, size: 8},
+	{as: AMOVBZ, a1: C_REG, a4: C_ADDR, type_: 74, size: 8},
+	{as: AMOVB, a1: C_REG, a4: C_ADDR, type_: 74, size: 8},
 
 	/* load, long offset */
-	{AMOVD, C_LEXT, C_NONE, C_NONE, C_REG, 36, 8, REGSB},
-	{AMOVW, C_LEXT, C_NONE, C_NONE, C_REG, 36, 8, REGSB},
-	{AMOVWZ, C_LEXT, C_NONE, C_NONE, C_REG, 36, 8, REGSB},
-	{AMOVBZ, C_LEXT, C_NONE, C_NONE, C_REG, 36, 8, REGSB},
-	{AMOVB, C_LEXT, C_NONE, C_NONE, C_REG, 37, 12, REGSB},
-	{AMOVD, C_LAUTO, C_NONE, C_NONE, C_REG, 36, 8, REGSP},
-	{AMOVW, C_LAUTO, C_NONE, C_NONE, C_REG, 36, 8, REGSP},
-	{AMOVWZ, C_LAUTO, C_NONE, C_NONE, C_REG, 36, 8, REGSP},
-	{AMOVBZ, C_LAUTO, C_NONE, C_NONE, C_REG, 36, 8, REGSP},
-	{AMOVB, C_LAUTO, C_NONE, C_NONE, C_REG, 37, 12, REGSP},
-	{AMOVD, C_LOREG, C_NONE, C_NONE, C_REG, 36, 8, REGZERO},
-	{AMOVW, C_LOREG, C_NONE, C_NONE, C_REG, 36, 8, REGZERO},
-	{AMOVWZ, C_LOREG, C_NONE, C_NONE, C_REG, 36, 8, REGZERO},
-	{AMOVBZ, C_LOREG, C_NONE, C_NONE, C_REG, 36, 8, REGZERO},
-	{AMOVB, C_LOREG, C_NONE, C_NONE, C_REG, 37, 12, REGZERO},
-	{AMOVD, C_ADDR, C_NONE, C_NONE, C_REG, 75, 8, 0},
-	{AMOVW, C_ADDR, C_NONE, C_NONE, C_REG, 75, 8, 0},
-	{AMOVWZ, C_ADDR, C_NONE, C_NONE, C_REG, 75, 8, 0},
-	{AMOVBZ, C_ADDR, C_NONE, C_NONE, C_REG, 75, 8, 0},
-	{AMOVB, C_ADDR, C_NONE, C_NONE, C_REG, 76, 12, 0},
-
-	{AMOVD, C_TLS_LE, C_NONE, C_NONE, C_REG, 79, 4, 0},
-	{AMOVD, C_TLS_IE, C_NONE, C_NONE, C_REG, 80, 8, 0},
-
-	{AMOVD, C_GOTADDR, C_NONE, C_NONE, C_REG, 81, 8, 0},
-	{AMOVD, C_TOCADDR, C_NONE, C_NONE, C_REG, 95, 8, 0},
+	{as: AMOVD, a1: C_LEXT, a4: C_REG, type_: 36, size: 8, param: REGSB},
+	{as: AMOVW, a1: C_LEXT, a4: C_REG, type_: 36, size: 8, param: REGSB},
+	{as: AMOVWZ, a1: C_LEXT, a4: C_REG, type_: 36, size: 8, param: REGSB},
+	{as: AMOVBZ, a1: C_LEXT, a4: C_REG, type_: 36, size: 8, param: REGSB},
+	{as: AMOVB, a1: C_LEXT, a4: C_REG, type_: 37, size: 12, param: REGSB},
+	{as: AMOVD, a1: C_LAUTO, a4: C_REG, type_: 36, size: 8, param: REGSP},
+	{as: AMOVW, a1: C_LAUTO, a4: C_REG, type_: 36, size: 8, param: REGSP},
+	{as: AMOVWZ, a1: C_LAUTO, a4: C_REG, type_: 36, size: 8, param: REGSP},
+	{as: AMOVBZ, a1: C_LAUTO, a4: C_REG, type_: 36, size: 8, param: REGSP},
+	{as: AMOVB, a1: C_LAUTO, a4: C_REG, type_: 37, size: 12, param: REGSP},
+	{as: AMOVD, a1: C_LOREG, a4: C_REG, type_: 36, size: 8, param: REGZERO},
+	{as: AMOVW, a1: C_LOREG, a4: C_REG, type_: 36, size: 8, param: REGZERO},
+	{as: AMOVWZ, a1: C_LOREG, a4: C_REG, type_: 36, size: 8, param: REGZERO},
+	{as: AMOVBZ, a1: C_LOREG, a4: C_REG, type_: 36, size: 8, param: REGZERO},
+	{as: AMOVB, a1: C_LOREG, a4: C_REG, type_: 37, size: 12, param: REGZERO},
+	{as: AMOVD, a1: C_ADDR, a4: C_REG, type_: 75, size: 8},
+	{as: AMOVW, a1: C_ADDR, a4: C_REG, type_: 75, size: 8},
+	{as: AMOVWZ, a1: C_ADDR, a4: C_REG, type_: 75, size: 8},
+	{as: AMOVBZ, a1: C_ADDR, a4: C_REG, type_: 75, size: 8},
+	{as: AMOVB, a1: C_ADDR, a4: C_REG, type_: 76, size: 12},
+
+	{as: AMOVD, a1: C_TLS_LE, a4: C_REG, type_: 79, size: 4},
+	{as: AMOVD, a1: C_TLS_IE, a4: C_REG, type_: 80, size: 8},
+
+	{as: AMOVD, a1: C_GOTADDR, a4: C_REG, type_: 81, size: 8},
+	{as: AMOVD, a1: C_TOCADDR, a4: C_REG, type_: 95, size: 8},
 
 	/* load constant */
-	{AMOVD, C_SECON, C_NONE, C_NONE, C_REG, 3, 4, REGSB},
-	{AMOVD, C_SACON, C_NONE, C_NONE, C_REG, 3, 4, REGSP},
-	{AMOVD, C_LECON, C_NONE, C_NONE, C_REG, 26, 8, REGSB},
-	{AMOVD, C_LACON, C_NONE, C_NONE, C_REG, 26, 8, REGSP},
-	{AMOVD, C_ADDCON, C_NONE, C_NONE, C_REG, 3, 4, REGZERO},
-	{AMOVD, C_ANDCON, C_NONE, C_NONE, C_REG, 3, 4, REGZERO},
-	{AMOVW, C_SECON, C_NONE, C_NONE, C_REG, 3, 4, REGSB}, /* TO DO: check */
-	{AMOVW, C_SACON, C_NONE, C_NONE, C_REG, 3, 4, REGSP},
-	{AMOVW, C_LECON, C_NONE, C_NONE, C_REG, 26, 8, REGSB},
-	{AMOVW, C_LACON, C_NONE, C_NONE, C_REG, 26, 8, REGSP},
-	{AMOVW, C_ADDCON, C_NONE, C_NONE, C_REG, 3, 4, REGZERO},
-	{AMOVW, C_ANDCON, C_NONE, C_NONE, C_REG, 3, 4, REGZERO},
-	{AMOVWZ, C_SECON, C_NONE, C_NONE, C_REG, 3, 4, REGSB}, /* TO DO: check */
-	{AMOVWZ, C_SACON, C_NONE, C_NONE, C_REG, 3, 4, REGSP},
-	{AMOVWZ, C_LECON, C_NONE, C_NONE, C_REG, 26, 8, REGSB},
-	{AMOVWZ, C_LACON, C_NONE, C_NONE, C_REG, 26, 8, REGSP},
-	{AMOVWZ, C_ADDCON, C_NONE, C_NONE, C_REG, 3, 4, REGZERO},
-	{AMOVWZ, C_ANDCON, C_NONE, C_NONE, C_REG, 3, 4, REGZERO},
+	{as: AMOVD, a1: C_SECON, a4: C_REG, type_: 3, size: 4, param: REGSB},
+	{as: AMOVD, a1: C_SACON, a4: C_REG, type_: 3, size: 4, param: REGSP},
+	{as: AMOVD, a1: C_LECON, a4: C_REG, type_: 26, size: 8, param: REGSB},
+	{as: AMOVD, a1: C_LACON, a4: C_REG, type_: 26, size: 8, param: REGSP},
+	{as: AMOVD, a1: C_ADDCON, a4: C_REG, type_: 3, size: 4, param: REGZERO},
+	{as: AMOVD, a1: C_ANDCON, a4: C_REG, type_: 3, size: 4, param: REGZERO},
+	{as: AMOVW, a1: C_SECON, a4: C_REG, type_: 3, size: 4, param: REGSB}, /* TO DO: check */
+	{as: AMOVW, a1: C_SACON, a4: C_REG, type_: 3, size: 4, param: REGSP},
+	{as: AMOVW, a1: C_LECON, a4: C_REG, type_: 26, size: 8, param: REGSB},
+	{as: AMOVW, a1: C_LACON, a4: C_REG, type_: 26, size: 8, param: REGSP},
+	{as: AMOVW, a1: C_ADDCON, a4: C_REG, type_: 3, size: 4, param: REGZERO},
+	{as: AMOVW, a1: C_ANDCON, a4: C_REG, type_: 3, size: 4, param: REGZERO},
+	{as: AMOVWZ, a1: C_SECON, a4: C_REG, type_: 3, size: 4, param: REGSB}, /* TO DO: check */
+	{as: AMOVWZ, a1: C_SACON, a4: C_REG, type_: 3, size: 4, param: REGSP},
+	{as: AMOVWZ, a1: C_LECON, a4: C_REG, type_: 26, size: 8, param: REGSB},
+	{as: AMOVWZ, a1: C_LACON, a4: C_REG, type_: 26, size: 8, param: REGSP},
+	{as: AMOVWZ, a1: C_ADDCON, a4: C_REG, type_: 3, size: 4, param: REGZERO},
+	{as: AMOVWZ, a1: C_ANDCON, a4: C_REG, type_: 3, size: 4, param: REGZERO},
 
 	/* load unsigned/long constants (TO DO: check) */
-	{AMOVD, C_UCON, C_NONE, C_NONE, C_REG, 3, 4, REGZERO},
-	{AMOVD, C_LCON, C_NONE, C_NONE, C_REG, 19, 8, 0},
-	{AMOVW, C_UCON, C_NONE, C_NONE, C_REG, 3, 4, REGZERO},
-	{AMOVW, C_LCON, C_NONE, C_NONE, C_REG, 19, 8, 0},
-	{AMOVWZ, C_UCON, C_NONE, C_NONE, C_REG, 3, 4, REGZERO},
-	{AMOVWZ, C_LCON, C_NONE, C_NONE, C_REG, 19, 8, 0},
-	{AMOVHBR, C_ZOREG, C_REG, C_NONE, C_REG, 45, 4, 0},
-	{AMOVHBR, C_ZOREG, C_NONE, C_NONE, C_REG, 45, 4, 0},
-	{AMOVHBR, C_REG, C_REG, C_NONE, C_ZOREG, 44, 4, 0},
-	{AMOVHBR, C_REG, C_NONE, C_NONE, C_ZOREG, 44, 4, 0},
-	{ASYSCALL, C_NONE, C_NONE, C_NONE, C_NONE, 5, 4, 0},
-	{ASYSCALL, C_REG, C_NONE, C_NONE, C_NONE, 77, 12, 0},
-	{ASYSCALL, C_SCON, C_NONE, C_NONE, C_NONE, 77, 12, 0},
-	{ABEQ, C_NONE, C_NONE, C_NONE, C_SBRA, 16, 4, 0},
-	{ABEQ, C_CREG, C_NONE, C_NONE, C_SBRA, 16, 4, 0},
-	{ABR, C_NONE, C_NONE, C_NONE, C_LBRA, 11, 4, 0},
-	{ABR, C_NONE, C_NONE, C_NONE, C_LBRAPIC, 11, 8, 0},
-	{ABC, C_SCON, C_REG, C_NONE, C_SBRA, 16, 4, 0},
-	{ABC, C_SCON, C_REG, C_NONE, C_LBRA, 17, 4, 0},
-	{ABR, C_NONE, C_NONE, C_NONE, C_LR, 18, 4, 0},
-	{ABR, C_NONE, C_NONE, C_SCON, C_LR, 18, 4, 0},
-	{ABR, C_NONE, C_NONE, C_NONE, C_CTR, 18, 4, 0},
-	{ABR, C_REG, C_NONE, C_NONE, C_CTR, 18, 4, 0},
-	{ABR, C_NONE, C_NONE, C_NONE, C_ZOREG, 15, 8, 0},
-	{ABC, C_NONE, C_REG, C_NONE, C_LR, 18, 4, 0},
-	{ABC, C_NONE, C_REG, C_NONE, C_CTR, 18, 4, 0},
-	{ABC, C_SCON, C_REG, C_NONE, C_LR, 18, 4, 0},
-	{ABC, C_SCON, C_REG, C_NONE, C_CTR, 18, 4, 0},
-	{ABC, C_NONE, C_NONE, C_NONE, C_ZOREG, 15, 8, 0},
-	{AFMOVD, C_SEXT, C_NONE, C_NONE, C_FREG, 8, 4, REGSB},
-	{AFMOVD, C_SAUTO, C_NONE, C_NONE, C_FREG, 8, 4, REGSP},
-	{AFMOVD, C_SOREG, C_NONE, C_NONE, C_FREG, 8, 4, REGZERO},
-	{AFMOVD, C_LEXT, C_NONE, C_NONE, C_FREG, 36, 8, REGSB},
-	{AFMOVD, C_LAUTO, C_NONE, C_NONE, C_FREG, 36, 8, REGSP},
-	{AFMOVD, C_LOREG, C_NONE, C_NONE, C_FREG, 36, 8, REGZERO},
-	{AFMOVD, C_ZCON, C_NONE, C_NONE, C_FREG, 24, 4, 0},
-	{AFMOVD, C_ADDCON, C_NONE, C_NONE, C_FREG, 24, 8, 0},
-	{AFMOVD, C_ADDR, C_NONE, C_NONE, C_FREG, 75, 8, 0},
-	{AFMOVD, C_FREG, C_NONE, C_NONE, C_SEXT, 7, 4, REGSB},
-	{AFMOVD, C_FREG, C_NONE, C_NONE, C_SAUTO, 7, 4, REGSP},
-	{AFMOVD, C_FREG, C_NONE, C_NONE, C_SOREG, 7, 4, REGZERO},
-	{AFMOVD, C_FREG, C_NONE, C_NONE, C_LEXT, 35, 8, REGSB},
-	{AFMOVD, C_FREG, C_NONE, C_NONE, C_LAUTO, 35, 8, REGSP},
-	{AFMOVD, C_FREG, C_NONE, C_NONE, C_LOREG, 35, 8, REGZERO},
-	{AFMOVD, C_FREG, C_NONE, C_NONE, C_ADDR, 74, 8, 0},
-	{AFMOVSX, C_ZOREG, C_REG, C_NONE, C_FREG, 45, 4, 0},
-	{AFMOVSX, C_ZOREG, C_NONE, C_NONE, C_FREG, 45, 4, 0},
-	{AFMOVSX, C_FREG, C_REG, C_NONE, C_ZOREG, 44, 4, 0},
-	{AFMOVSX, C_FREG, C_NONE, C_NONE, C_ZOREG, 44, 4, 0},
-	{AFMOVSZ, C_ZOREG, C_REG, C_NONE, C_FREG, 45, 4, 0},
-	{AFMOVSZ, C_ZOREG, C_NONE, C_NONE, C_FREG, 45, 4, 0},
-	{ASYNC, C_NONE, C_NONE, C_NONE, C_NONE, 46, 4, 0},
-	{AWORD, C_LCON, C_NONE, C_NONE, C_NONE, 40, 4, 0},
-	{ADWORD, C_LCON, C_NONE, C_NONE, C_NONE, 31, 8, 0},
-	{ADWORD, C_DCON, C_NONE, C_NONE, C_NONE, 31, 8, 0},
-	{AADDME, C_REG, C_NONE, C_NONE, C_REG, 47, 4, 0},
-	{AEXTSB, C_REG, C_NONE, C_NONE, C_REG, 48, 4, 0},
-	{AEXTSB, C_NONE, C_NONE, C_NONE, C_REG, 48, 4, 0},
-	{AISEL, C_LCON, C_REG, C_REG, C_REG, 84, 4, 0},
-	{AISEL, C_ZCON, C_REG, C_REG, C_REG, 84, 4, 0},
-	{ANEG, C_REG, C_NONE, C_NONE, C_REG, 47, 4, 0},
-	{ANEG, C_NONE, C_NONE, C_NONE, C_REG, 47, 4, 0},
-	{AREM, C_REG, C_NONE, C_NONE, C_REG, 50, 12, 0},
-	{AREM, C_REG, C_REG, C_NONE, C_REG, 50, 12, 0},
-	{AREMU, C_REG, C_NONE, C_NONE, C_REG, 50, 16, 0},
-	{AREMU, C_REG, C_REG, C_NONE, C_REG, 50, 16, 0},
-	{AREMD, C_REG, C_NONE, C_NONE, C_REG, 51, 12, 0},
-	{AREMD, C_REG, C_REG, C_NONE, C_REG, 51, 12, 0},
-	{AMTFSB0, C_SCON, C_NONE, C_NONE, C_NONE, 52, 4, 0},
-	{AMOVFL, C_FPSCR, C_NONE, C_NONE, C_FREG, 53, 4, 0},
-	{AMOVFL, C_FREG, C_NONE, C_NONE, C_FPSCR, 64, 4, 0},
-	{AMOVFL, C_FREG, C_NONE, C_LCON, C_FPSCR, 64, 4, 0},
-	{AMOVFL, C_LCON, C_NONE, C_NONE, C_FPSCR, 65, 4, 0},
-	{AMOVD, C_MSR, C_NONE, C_NONE, C_REG, 54, 4, 0},  /* mfmsr */
-	{AMOVD, C_REG, C_NONE, C_NONE, C_MSR, 54, 4, 0},  /* mtmsrd */
-	{AMOVWZ, C_REG, C_NONE, C_NONE, C_MSR, 54, 4, 0}, /* mtmsr */
+	{as: AMOVD, a1: C_UCON, a4: C_REG, type_: 3, size: 4, param: REGZERO},
+	{as: AMOVD, a1: C_LCON, a4: C_REG, type_: 19, size: 8},
+	{as: AMOVW, a1: C_UCON, a4: C_REG, type_: 3, size: 4, param: REGZERO},
+	{as: AMOVW, a1: C_LCON, a4: C_REG, type_: 19, size: 8},
+	{as: AMOVWZ, a1: C_UCON, a4: C_REG, type_: 3, size: 4, param: REGZERO},
+	{as: AMOVWZ, a1: C_LCON, a4: C_REG, type_: 19, size: 8},
+	{as: AMOVHBR, a1: C_ZOREG, a2: C_REG, a4: C_REG, type_: 45, size: 4},
+	{as: AMOVHBR, a1: C_ZOREG, a4: C_REG, type_: 45, size: 4},
+	{as: AMOVHBR, a1: C_REG, a2: C_REG, a4: C_ZOREG, type_: 44, size: 4},
+	{as: AMOVHBR, a1: C_REG, a4: C_ZOREG, type_: 44, size: 4},
+	{as: ASYSCALL, type_: 5, size: 4},
+	{as: ASYSCALL, a1: C_REG, type_: 77, size: 12},
+	{as: ASYSCALL, a1: C_SCON, type_: 77, size: 12},
+	{as: ABEQ, a4: C_SBRA, type_: 16, size: 4},
+	{as: ABEQ, a1: C_CREG, a4: C_SBRA, type_: 16, size: 4},
+	{as: ABR, a4: C_LBRA, type_: 11, size: 4},
+	{as: ABR, a4: C_LBRAPIC, type_: 11, size: 8},
+	{as: ABC, a1: C_SCON, a2: C_REG, a4: C_SBRA, type_: 16, size: 4},
+	{as: ABC, a1: C_SCON, a2: C_REG, a4: C_LBRA, type_: 17, size: 4},
+	{as: ABR, a4: C_LR, type_: 18, size: 4},
+	{as: ABR, a3: C_SCON, a4: C_LR, type_: 18, size: 4},
+	{as: ABR, a4: C_CTR, type_: 18, size: 4},
+	{as: ABR, a1: C_REG, a4: C_CTR, type_: 18, size: 4},
+	{as: ABR, a4: C_ZOREG, type_: 15, size: 8},
+	{as: ABC, a2: C_REG, a4: C_LR, type_: 18, size: 4},
+	{as: ABC, a2: C_REG, a4: C_CTR, type_: 18, size: 4},
+	{as: ABC, a1: C_SCON, a2: C_REG, a4: C_LR, type_: 18, size: 4},
+	{as: ABC, a1: C_SCON, a2: C_REG, a4: C_CTR, type_: 18, size: 4},
+	{as: ABC, a4: C_ZOREG, type_: 15, size: 8},
+	{as: AFMOVD, a1: C_SEXT, a4: C_FREG, type_: 8, size: 4, param: REGSB},
+	{as: AFMOVD, a1: C_SAUTO, a4: C_FREG, type_: 8, size: 4, param: REGSP},
+	{as: AFMOVD, a1: C_SOREG, a4: C_FREG, type_: 8, size: 4, param: REGZERO},
+	{as: AFMOVD, a1: C_LEXT, a4: C_FREG, type_: 36, size: 8, param: REGSB},
+	{as: AFMOVD, a1: C_LAUTO, a4: C_FREG, type_: 36, size: 8, param: REGSP},
+	{as: AFMOVD, a1: C_LOREG, a4: C_FREG, type_: 36, size: 8, param: REGZERO},
+	{as: AFMOVD, a1: C_ZCON, a4: C_FREG, type_: 24, size: 4},
+	{as: AFMOVD, a1: C_ADDCON, a4: C_FREG, type_: 24, size: 8},
+	{as: AFMOVD, a1: C_ADDR, a4: C_FREG, type_: 75, size: 8},
+	{as: AFMOVD, a1: C_FREG, a4: C_SEXT, type_: 7, size: 4, param: REGSB},
+	{as: AFMOVD, a1: C_FREG, a4: C_SAUTO, type_: 7, size: 4, param: REGSP},
+	{as: AFMOVD, a1: C_FREG, a4: C_SOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AFMOVD, a1: C_FREG, a4: C_LEXT, type_: 35, size: 8, param: REGSB},
+	{as: AFMOVD, a1: C_FREG, a4: C_LAUTO, type_: 35, size: 8, param: REGSP},
+	{as: AFMOVD, a1: C_FREG, a4: C_LOREG, type_: 35, size: 8, param: REGZERO},
+	{as: AFMOVD, a1: C_FREG, a4: C_ADDR, type_: 74, size: 8},
+	{as: AFMOVSX, a1: C_ZOREG, a2: C_REG, a4: C_FREG, type_: 45, size: 4},
+	{as: AFMOVSX, a1: C_ZOREG, a4: C_FREG, type_: 45, size: 4},
+	{as: AFMOVSX, a1: C_FREG, a2: C_REG, a4: C_ZOREG, type_: 44, size: 4},
+	{as: AFMOVSX, a1: C_FREG, a4: C_ZOREG, type_: 44, size: 4},
+	{as: AFMOVSZ, a1: C_ZOREG, a2: C_REG, a4: C_FREG, type_: 45, size: 4},
+	{as: AFMOVSZ, a1: C_ZOREG, a4: C_FREG, type_: 45, size: 4},
+	{as: ASYNC, type_: 46, size: 4},
+	{as: AWORD, a1: C_LCON, type_: 40, size: 4},
+	{as: ADWORD, a1: C_LCON, type_: 31, size: 8},
+	{as: ADWORD, a1: C_DCON, type_: 31, size: 8},
+	{as: AADDME, a1: C_REG, a4: C_REG, type_: 47, size: 4},
+	{as: AEXTSB, a1: C_REG, a4: C_REG, type_: 48, size: 4},
+	{as: AEXTSB, a4: C_REG, type_: 48, size: 4},
+	{as: AISEL, a1: C_LCON, a2: C_REG, a3: C_REG, a4: C_REG, type_: 84, size: 4},
+	{as: AISEL, a1: C_ZCON, a2: C_REG, a3: C_REG, a4: C_REG, type_: 84, size: 4},
+	{as: ANEG, a1: C_REG, a4: C_REG, type_: 47, size: 4},
+	{as: ANEG, a4: C_REG, type_: 47, size: 4},
+	{as: AREM, a1: C_REG, a4: C_REG, type_: 50, size: 12},
+	{as: AREM, a1: C_REG, a2: C_REG, a4: C_REG, type_: 50, size: 12},
+	{as: AREMU, a1: C_REG, a4: C_REG, type_: 50, size: 16},
+	{as: AREMU, a1: C_REG, a2: C_REG, a4: C_REG, type_: 50, size: 16},
+	{as: AREMD, a1: C_REG, a4: C_REG, type_: 51, size: 12},
+	{as: AREMD, a1: C_REG, a2: C_REG, a4: C_REG, type_: 51, size: 12},
+	{as: AMTFSB0, a1: C_SCON, type_: 52, size: 4},
+	{as: AMOVFL, a1: C_FPSCR, a4: C_FREG, type_: 53, size: 4},
+	{as: AMOVFL, a1: C_FREG, a4: C_FPSCR, type_: 64, size: 4},
+	{as: AMOVFL, a1: C_FREG, a3: C_LCON, a4: C_FPSCR, type_: 64, size: 4},
+	{as: AMOVFL, a1: C_LCON, a4: C_FPSCR, type_: 65, size: 4},
+	{as: AMOVD, a1: C_MSR, a4: C_REG, type_: 54, size: 4},  /* mfmsr */
+	{as: AMOVD, a1: C_REG, a4: C_MSR, type_: 54, size: 4},  /* mtmsrd */
+	{as: AMOVWZ, a1: C_REG, a4: C_MSR, type_: 54, size: 4}, /* mtmsr */
 
 	/* Other ISA 2.05+ instructions */
-	{APOPCNTD, C_REG, C_NONE, C_NONE, C_REG, 93, 4, 0}, /* population count, x-form */
-	{ACMPB, C_REG, C_REG, C_NONE, C_REG, 92, 4, 0},     /* compare byte, x-form */
-	{ACMPEQB, C_REG, C_REG, C_NONE, C_CREG, 92, 4, 0},  /* compare equal byte, x-form, ISA 3.0 */
-	{ACMPEQB, C_REG, C_NONE, C_NONE, C_REG, 70, 4, 0},
-	{AFTDIV, C_FREG, C_FREG, C_NONE, C_SCON, 92, 4, 0},  /* floating test for sw divide, x-form */
-	{AFTSQRT, C_FREG, C_NONE, C_NONE, C_SCON, 93, 4, 0}, /* floating test for sw square root, x-form */
-	{ACOPY, C_REG, C_NONE, C_NONE, C_REG, 92, 4, 0},     /* copy/paste facility, x-form */
-	{ADARN, C_SCON, C_NONE, C_NONE, C_REG, 92, 4, 0},    /* deliver random number, x-form */
-	{ALDMX, C_SOREG, C_NONE, C_NONE, C_REG, 45, 4, 0},   /* load doubleword monitored, x-form */
-	{AMADDHD, C_REG, C_REG, C_REG, C_REG, 83, 4, 0},     /* multiply-add high/low doubleword, va-form */
-	{AADDEX, C_REG, C_REG, C_SCON, C_REG, 94, 4, 0},     /* add extended using alternate carry, z23-form */
-	{ACRAND, C_CREG, C_NONE, C_NONE, C_CREG, 2, 4, 0},   /* logical ops for condition registers xl-form */
+	{as: APOPCNTD, a1: C_REG, a4: C_REG, type_: 93, size: 4},            /* population count, x-form */
+	{as: ACMPB, a1: C_REG, a2: C_REG, a4: C_REG, type_: 92, size: 4},    /* compare byte, x-form */
+	{as: ACMPEQB, a1: C_REG, a2: C_REG, a4: C_CREG, type_: 92, size: 4}, /* compare equal byte, x-form, ISA 3.0 */
+	{as: ACMPEQB, a1: C_REG, a4: C_REG, type_: 70, size: 4},
+	{as: AFTDIV, a1: C_FREG, a2: C_FREG, a4: C_SCON, type_: 92, size: 4},          /* floating test for sw divide, x-form */
+	{as: AFTSQRT, a1: C_FREG, a4: C_SCON, type_: 93, size: 4},                     /* floating test for sw square root, x-form */
+	{as: ACOPY, a1: C_REG, a4: C_REG, type_: 92, size: 4},                         /* copy/paste facility, x-form */
+	{as: ADARN, a1: C_SCON, a4: C_REG, type_: 92, size: 4},                        /* deliver random number, x-form */
+	{as: ALDMX, a1: C_SOREG, a4: C_REG, type_: 45, size: 4},                       /* load doubleword monitored, x-form */
+	{as: AMADDHD, a1: C_REG, a2: C_REG, a3: C_REG, a4: C_REG, type_: 83, size: 4}, /* multiply-add high/low doubleword, va-form */
+	{as: AADDEX, a1: C_REG, a2: C_REG, a3: C_SCON, a4: C_REG, type_: 94, size: 4}, /* add extended using alternate carry, z23-form */
+	{as: ACRAND, a1: C_CREG, a4: C_CREG, type_: 2, size: 4},                       /* logical ops for condition registers xl-form */
 
 	/* Vector instructions */
 
 	/* Vector load */
-	{ALV, C_SOREG, C_NONE, C_NONE, C_VREG, 45, 4, 0}, /* vector load, x-form */
+	{as: ALV, a1: C_SOREG, a4: C_VREG, type_: 45, size: 4}, /* vector load, x-form */
 
 	/* Vector store */
-	{ASTV, C_VREG, C_NONE, C_NONE, C_SOREG, 44, 4, 0}, /* vector store, x-form */
+	{as: ASTV, a1: C_VREG, a4: C_SOREG, type_: 44, size: 4}, /* vector store, x-form */
 
 	/* Vector logical */
-	{AVAND, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector and, vx-form */
-	{AVOR, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0},  /* vector or, vx-form */
+	{as: AVAND, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4}, /* vector and, vx-form */
+	{as: AVOR, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},  /* vector or, vx-form */
 
 	/* Vector add */
-	{AVADDUM, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector add unsigned modulo, vx-form */
-	{AVADDCU, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector add & write carry unsigned, vx-form */
-	{AVADDUS, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector add unsigned saturate, vx-form */
-	{AVADDSS, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector add signed saturate, vx-form */
-	{AVADDE, C_VREG, C_VREG, C_VREG, C_VREG, 83, 4, 0},  /* vector add extended, va-form */
+	{as: AVADDUM, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},            /* vector add unsigned modulo, vx-form */
+	{as: AVADDCU, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},            /* vector add & write carry unsigned, vx-form */
+	{as: AVADDUS, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},            /* vector add unsigned saturate, vx-form */
+	{as: AVADDSS, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},            /* vector add signed saturate, vx-form */
+	{as: AVADDE, a1: C_VREG, a2: C_VREG, a3: C_VREG, a4: C_VREG, type_: 83, size: 4}, /* vector add extended, va-form */
 
 	/* Vector subtract */
-	{AVSUBUM, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector subtract unsigned modulo, vx-form */
-	{AVSUBCU, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector subtract & write carry unsigned, vx-form */
-	{AVSUBUS, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector subtract unsigned saturate, vx-form */
-	{AVSUBSS, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector subtract signed saturate, vx-form */
-	{AVSUBE, C_VREG, C_VREG, C_VREG, C_VREG, 83, 4, 0},  /* vector subtract extended, va-form */
+	{as: AVSUBUM, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},            /* vector subtract unsigned modulo, vx-form */
+	{as: AVSUBCU, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},            /* vector subtract & write carry unsigned, vx-form */
+	{as: AVSUBUS, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},            /* vector subtract unsigned saturate, vx-form */
+	{as: AVSUBSS, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},            /* vector subtract signed saturate, vx-form */
+	{as: AVSUBE, a1: C_VREG, a2: C_VREG, a3: C_VREG, a4: C_VREG, type_: 83, size: 4}, /* vector subtract extended, va-form */
 
 	/* Vector multiply */
-	{AVMULESB, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 9},  /* vector multiply, vx-form */
-	{AVPMSUM, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0},   /* vector polynomial multiply & sum, vx-form */
-	{AVMSUMUDM, C_VREG, C_VREG, C_VREG, C_VREG, 83, 4, 0}, /* vector multiply-sum, va-form */
+	{as: AVMULESB, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4, param: 9},    /* vector multiply, vx-form */
+	{as: AVPMSUM, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},               /* vector polynomial multiply & sum, vx-form */
+	{as: AVMSUMUDM, a1: C_VREG, a2: C_VREG, a3: C_VREG, a4: C_VREG, type_: 83, size: 4}, /* vector multiply-sum, va-form */
 
 	/* Vector rotate */
-	{AVR, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector rotate, vx-form */
+	{as: AVR, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4}, /* vector rotate, vx-form */
 
 	/* Vector shift */
-	{AVS, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0},     /* vector shift, vx-form */
-	{AVSA, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0},    /* vector shift algebraic, vx-form */
-	{AVSOI, C_ANDCON, C_VREG, C_VREG, C_VREG, 83, 4, 0}, /* vector shift by octet immediate, va-form */
+	{as: AVS, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},                 /* vector shift, vx-form */
+	{as: AVSA, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},                /* vector shift algebraic, vx-form */
+	{as: AVSOI, a1: C_ANDCON, a2: C_VREG, a3: C_VREG, a4: C_VREG, type_: 83, size: 4}, /* vector shift by octet immediate, va-form */
 
 	/* Vector count */
-	{AVCLZ, C_VREG, C_NONE, C_NONE, C_VREG, 85, 4, 0},    /* vector count leading zeros, vx-form */
-	{AVPOPCNT, C_VREG, C_NONE, C_NONE, C_VREG, 85, 4, 0}, /* vector population count, vx-form */
+	{as: AVCLZ, a1: C_VREG, a4: C_VREG, type_: 85, size: 4},    /* vector count leading zeros, vx-form */
+	{as: AVPOPCNT, a1: C_VREG, a4: C_VREG, type_: 85, size: 4}, /* vector population count, vx-form */
 
 	/* Vector compare */
-	{AVCMPEQ, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0},   /* vector compare equal, vc-form */
-	{AVCMPGT, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0},   /* vector compare greater than, vc-form */
-	{AVCMPNEZB, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector compare not equal, vx-form */
+	{as: AVCMPEQ, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},   /* vector compare equal, vc-form */
+	{as: AVCMPGT, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},   /* vector compare greater than, vc-form */
+	{as: AVCMPNEZB, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4}, /* vector compare not equal, vx-form */
 
 	/* Vector merge */
-	{AVMRGOW, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector merge odd word, vx-form */
+	{as: AVMRGOW, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4}, /* vector merge odd word, vx-form */
 
 	/* Vector permute */
-	{AVPERM, C_VREG, C_VREG, C_VREG, C_VREG, 83, 4, 0}, /* vector permute, va-form */
+	{as: AVPERM, a1: C_VREG, a2: C_VREG, a3: C_VREG, a4: C_VREG, type_: 83, size: 4}, /* vector permute, va-form */
 
 	/* Vector bit permute */
-	{AVBPERMQ, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector bit permute, vx-form */
+	{as: AVBPERMQ, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4}, /* vector bit permute, vx-form */
 
 	/* Vector select */
-	{AVSEL, C_VREG, C_VREG, C_VREG, C_VREG, 83, 4, 0}, /* vector select, va-form */
+	{as: AVSEL, a1: C_VREG, a2: C_VREG, a3: C_VREG, a4: C_VREG, type_: 83, size: 4}, /* vector select, va-form */
 
 	/* Vector splat */
-	{AVSPLTB, C_SCON, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector splat, vx-form */
-	{AVSPLTB, C_ADDCON, C_VREG, C_NONE, C_VREG, 82, 4, 0},
-	{AVSPLTISB, C_SCON, C_NONE, C_NONE, C_VREG, 82, 4, 0}, /* vector splat immediate, vx-form */
-	{AVSPLTISB, C_ADDCON, C_NONE, C_NONE, C_VREG, 82, 4, 0},
+	{as: AVSPLTB, a1: C_SCON, a2: C_VREG, a4: C_VREG, type_: 82, size: 4}, /* vector splat, vx-form */
+	{as: AVSPLTB, a1: C_ADDCON, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},
+	{as: AVSPLTISB, a1: C_SCON, a4: C_VREG, type_: 82, size: 4}, /* vector splat immediate, vx-form */
+	{as: AVSPLTISB, a1: C_ADDCON, a4: C_VREG, type_: 82, size: 4},
 
 	/* Vector AES */
-	{AVCIPH, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0},  /* vector AES cipher, vx-form */
-	{AVNCIPH, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector AES inverse cipher, vx-form */
-	{AVSBOX, C_VREG, C_NONE, C_NONE, C_VREG, 82, 4, 0},  /* vector AES subbytes, vx-form */
+	{as: AVCIPH, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},  /* vector AES cipher, vx-form */
+	{as: AVNCIPH, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4}, /* vector AES inverse cipher, vx-form */
+	{as: AVSBOX, a1: C_VREG, a4: C_VREG, type_: 82, size: 4},              /* vector AES subbytes, vx-form */
 
 	/* Vector SHA */
-	{AVSHASIGMA, C_ANDCON, C_VREG, C_ANDCON, C_VREG, 82, 4, 0}, /* vector SHA sigma, vx-form */
+	{as: AVSHASIGMA, a1: C_ANDCON, a2: C_VREG, a3: C_ANDCON, a4: C_VREG, type_: 82, size: 4}, /* vector SHA sigma, vx-form */
 
 	/* VSX vector load */
-	{ALXVD2X, C_SOREG, C_NONE, C_NONE, C_VSREG, 87, 4, 0}, /* vsx vector load, xx1-form */
-	{ALXV, C_SOREG, C_NONE, C_NONE, C_VSREG, 96, 4, 0},    /* vsx vector load, dq-form */
-	{ALXVL, C_REG, C_REG, C_NONE, C_VSREG, 98, 4, 0},      /* vsx vector load length */
+	{as: ALXVD2X, a1: C_SOREG, a4: C_VSREG, type_: 87, size: 4},        /* vsx vector load, xx1-form */
+	{as: ALXV, a1: C_SOREG, a4: C_VSREG, type_: 96, size: 4},           /* vsx vector load, dq-form */
+	{as: ALXVL, a1: C_REG, a2: C_REG, a4: C_VSREG, type_: 98, size: 4}, /* vsx vector load length */
 
 	/* VSX vector store */
-	{ASTXVD2X, C_VSREG, C_NONE, C_NONE, C_SOREG, 86, 4, 0}, /* vsx vector store, xx1-form */
-	{ASTXV, C_VSREG, C_NONE, C_NONE, C_SOREG, 97, 4, 0},    /* vsx vector store, dq-form */
-	{ASTXVL, C_VSREG, C_REG, C_NONE, C_REG, 99, 4, 0},      /* vsx vector store with length x-form */
+	{as: ASTXVD2X, a1: C_VSREG, a4: C_SOREG, type_: 86, size: 4},        /* vsx vector store, xx1-form */
+	{as: ASTXV, a1: C_VSREG, a4: C_SOREG, type_: 97, size: 4},           /* vsx vector store, dq-form */
+	{as: ASTXVL, a1: C_VSREG, a2: C_REG, a4: C_REG, type_: 99, size: 4}, /* vsx vector store with length x-form */
 
 	/* VSX scalar load */
-	{ALXSDX, C_SOREG, C_NONE, C_NONE, C_VSREG, 87, 4, 0}, /* vsx scalar load, xx1-form */
+	{as: ALXSDX, a1: C_SOREG, a4: C_VSREG, type_: 87, size: 4}, /* vsx scalar load, xx1-form */
 
 	/* VSX scalar store */
-	{ASTXSDX, C_VSREG, C_NONE, C_NONE, C_SOREG, 86, 4, 0}, /* vsx scalar store, xx1-form */
+	{as: ASTXSDX, a1: C_VSREG, a4: C_SOREG, type_: 86, size: 4}, /* vsx scalar store, xx1-form */
 
 	/* VSX scalar as integer load */
-	{ALXSIWAX, C_SOREG, C_NONE, C_NONE, C_VSREG, 87, 4, 0}, /* vsx scalar as integer load, xx1-form */
+	{as: ALXSIWAX, a1: C_SOREG, a4: C_VSREG, type_: 87, size: 4}, /* vsx scalar as integer load, xx1-form */
 
 	/* VSX scalar store as integer */
-	{ASTXSIWX, C_VSREG, C_NONE, C_NONE, C_SOREG, 86, 4, 0}, /* vsx scalar as integer store, xx1-form */
+	{as: ASTXSIWX, a1: C_VSREG, a4: C_SOREG, type_: 86, size: 4}, /* vsx scalar as integer store, xx1-form */
 
 	/* VSX move from VSR */
-	{AMFVSRD, C_VSREG, C_NONE, C_NONE, C_REG, 88, 4, 0}, /* vsx move from vsr, xx1-form */
-	{AMFVSRD, C_FREG, C_NONE, C_NONE, C_REG, 88, 4, 0},
-	{AMFVSRD, C_VREG, C_NONE, C_NONE, C_REG, 88, 4, 0},
+	{as: AMFVSRD, a1: C_VSREG, a4: C_REG, type_: 88, size: 4}, /* vsx move from vsr, xx1-form */
+	{as: AMFVSRD, a1: C_FREG, a4: C_REG, type_: 88, size: 4},
+	{as: AMFVSRD, a1: C_VREG, a4: C_REG, type_: 88, size: 4},
 
 	/* VSX move to VSR */
-	{AMTVSRD, C_REG, C_NONE, C_NONE, C_VSREG, 88, 4, 0}, /* vsx move to vsr, xx1-form */
-	{AMTVSRD, C_REG, C_REG, C_NONE, C_VSREG, 88, 4, 0},
-	{AMTVSRD, C_REG, C_NONE, C_NONE, C_FREG, 88, 4, 0},
-	{AMTVSRD, C_REG, C_NONE, C_NONE, C_VREG, 88, 4, 0},
+	{as: AMTVSRD, a1: C_REG, a4: C_VSREG, type_: 88, size: 4}, /* vsx move to vsr, xx1-form */
+	{as: AMTVSRD, a1: C_REG, a2: C_REG, a4: C_VSREG, type_: 88, size: 4},
+	{as: AMTVSRD, a1: C_REG, a4: C_FREG, type_: 88, size: 4},
+	{as: AMTVSRD, a1: C_REG, a4: C_VREG, type_: 88, size: 4},
 
 	/* VSX logical */
-	{AXXLAND, C_VSREG, C_VSREG, C_NONE, C_VSREG, 90, 4, 0}, /* vsx and, xx3-form */
-	{AXXLOR, C_VSREG, C_VSREG, C_NONE, C_VSREG, 90, 4, 0},  /* vsx or, xx3-form */
+	{as: AXXLAND, a1: C_VSREG, a2: C_VSREG, a4: C_VSREG, type_: 90, size: 4}, /* vsx and, xx3-form */
+	{as: AXXLOR, a1: C_VSREG, a2: C_VSREG, a4: C_VSREG, type_: 90, size: 4},  /* vsx or, xx3-form */
 
 	/* VSX select */
-	{AXXSEL, C_VSREG, C_VSREG, C_VSREG, C_VSREG, 91, 4, 0}, /* vsx select, xx4-form */
+	{as: AXXSEL, a1: C_VSREG, a2: C_VSREG, a3: C_VSREG, a4: C_VSREG, type_: 91, size: 4}, /* vsx select, xx4-form */
 
 	/* VSX merge */
-	{AXXMRGHW, C_VSREG, C_VSREG, C_NONE, C_VSREG, 90, 4, 0}, /* vsx merge, xx3-form */
+	{as: AXXMRGHW, a1: C_VSREG, a2: C_VSREG, a4: C_VSREG, type_: 90, size: 4}, /* vsx merge, xx3-form */
 
 	/* VSX splat */
-	{AXXSPLTW, C_VSREG, C_NONE, C_SCON, C_VSREG, 89, 4, 0},  /* vsx splat, xx2-form */
-	{AXXSPLTIB, C_SCON, C_NONE, C_NONE, C_VSREG, 100, 4, 0}, /* vsx splat, xx2-form */
+	{as: AXXSPLTW, a1: C_VSREG, a3: C_SCON, a4: C_VSREG, type_: 89, size: 4}, /* vsx splat, xx2-form */
+	{as: AXXSPLTIB, a1: C_SCON, a4: C_VSREG, type_: 100, size: 4},            /* vsx splat, xx2-form */
 
 	/* VSX permute */
-	{AXXPERM, C_VSREG, C_VSREG, C_NONE, C_VSREG, 90, 4, 0}, /* vsx permute, xx3-form */
+	{as: AXXPERM, a1: C_VSREG, a2: C_VSREG, a4: C_VSREG, type_: 90, size: 4}, /* vsx permute, xx3-form */
 
 	/* VSX shift */
-	{AXXSLDWI, C_VSREG, C_VSREG, C_SCON, C_VSREG, 90, 4, 0}, /* vsx shift immediate, xx3-form */
+	{as: AXXSLDWI, a1: C_VSREG, a2: C_VSREG, a3: C_SCON, a4: C_VSREG, type_: 90, size: 4}, /* vsx shift immediate, xx3-form */
 
 	/* VSX reverse bytes */
-	{AXXBRQ, C_VSREG, C_NONE, C_NONE, C_VSREG, 101, 4, 0}, /* vsx reverse bytes */
+	{as: AXXBRQ, a1: C_VSREG, a4: C_VSREG, type_: 101, size: 4}, /* vsx reverse bytes */
 
 	/* VSX scalar FP-FP conversion */
-	{AXSCVDPSP, C_VSREG, C_NONE, C_NONE, C_VSREG, 89, 4, 0}, /* vsx scalar fp-fp conversion, xx2-form */
+	{as: AXSCVDPSP, a1: C_VSREG, a4: C_VSREG, type_: 89, size: 4}, /* vsx scalar fp-fp conversion, xx2-form */
 
 	/* VSX vector FP-FP conversion */
-	{AXVCVDPSP, C_VSREG, C_NONE, C_NONE, C_VSREG, 89, 4, 0}, /* vsx vector fp-fp conversion, xx2-form */
+	{as: AXVCVDPSP, a1: C_VSREG, a4: C_VSREG, type_: 89, size: 4}, /* vsx vector fp-fp conversion, xx2-form */
 
 	/* VSX scalar FP-integer conversion */
-	{AXSCVDPSXDS, C_VSREG, C_NONE, C_NONE, C_VSREG, 89, 4, 0}, /* vsx scalar fp-integer conversion, xx2-form */
+	{as: AXSCVDPSXDS, a1: C_VSREG, a4: C_VSREG, type_: 89, size: 4}, /* vsx scalar fp-integer conversion, xx2-form */
 
 	/* VSX scalar integer-FP conversion */
-	{AXSCVSXDDP, C_VSREG, C_NONE, C_NONE, C_VSREG, 89, 4, 0}, /* vsx scalar integer-fp conversion, xx2-form */
+	{as: AXSCVSXDDP, a1: C_VSREG, a4: C_VSREG, type_: 89, size: 4}, /* vsx scalar integer-fp conversion, xx2-form */
 
 	/* VSX vector FP-integer conversion */
-	{AXVCVDPSXDS, C_VSREG, C_NONE, C_NONE, C_VSREG, 89, 4, 0}, /* vsx vector fp-integer conversion, xx2-form */
+	{as: AXVCVDPSXDS, a1: C_VSREG, a4: C_VSREG, type_: 89, size: 4}, /* vsx vector fp-integer conversion, xx2-form */
 
 	/* VSX vector integer-FP conversion */
-	{AXVCVSXDDP, C_VSREG, C_NONE, C_NONE, C_VSREG, 89, 4, 0}, /* vsx vector integer-fp conversion, xx2-form */
+	{as: AXVCVSXDDP, a1: C_VSREG, a4: C_VSREG, type_: 89, size: 4}, /* vsx vector integer-fp conversion, xx2-form */
 
 	/* 64-bit special registers */
-	{AMOVD, C_REG, C_NONE, C_NONE, C_SPR, 66, 4, 0},
-	{AMOVD, C_REG, C_NONE, C_NONE, C_LR, 66, 4, 0},
-	{AMOVD, C_REG, C_NONE, C_NONE, C_CTR, 66, 4, 0},
-	{AMOVD, C_REG, C_NONE, C_NONE, C_XER, 66, 4, 0},
-	{AMOVD, C_SPR, C_NONE, C_NONE, C_REG, 66, 4, 0},
-	{AMOVD, C_LR, C_NONE, C_NONE, C_REG, 66, 4, 0},
-	{AMOVD, C_CTR, C_NONE, C_NONE, C_REG, 66, 4, 0},
-	{AMOVD, C_XER, C_NONE, C_NONE, C_REG, 66, 4, 0},
+	{as: AMOVD, a1: C_REG, a4: C_SPR, type_: 66, size: 4},
+	{as: AMOVD, a1: C_REG, a4: C_LR, type_: 66, size: 4},
+	{as: AMOVD, a1: C_REG, a4: C_CTR, type_: 66, size: 4},
+	{as: AMOVD, a1: C_REG, a4: C_XER, type_: 66, size: 4},
+	{as: AMOVD, a1: C_SPR, a4: C_REG, type_: 66, size: 4},
+	{as: AMOVD, a1: C_LR, a4: C_REG, type_: 66, size: 4},
+	{as: AMOVD, a1: C_CTR, a4: C_REG, type_: 66, size: 4},
+	{as: AMOVD, a1: C_XER, a4: C_REG, type_: 66, size: 4},
 
 	/* 32-bit special registers (gloss over sign-extension or not?) */
-	{AMOVW, C_REG, C_NONE, C_NONE, C_SPR, 66, 4, 0},
-	{AMOVW, C_REG, C_NONE, C_NONE, C_CTR, 66, 4, 0},
-	{AMOVW, C_REG, C_NONE, C_NONE, C_XER, 66, 4, 0},
-	{AMOVW, C_SPR, C_NONE, C_NONE, C_REG, 66, 4, 0},
-	{AMOVW, C_XER, C_NONE, C_NONE, C_REG, 66, 4, 0},
-	{AMOVWZ, C_REG, C_NONE, C_NONE, C_SPR, 66, 4, 0},
-	{AMOVWZ, C_REG, C_NONE, C_NONE, C_CTR, 66, 4, 0},
-	{AMOVWZ, C_REG, C_NONE, C_NONE, C_XER, 66, 4, 0},
-	{AMOVWZ, C_SPR, C_NONE, C_NONE, C_REG, 66, 4, 0},
-	{AMOVWZ, C_XER, C_NONE, C_NONE, C_REG, 66, 4, 0},
-	{AMOVFL, C_FPSCR, C_NONE, C_NONE, C_CREG, 73, 4, 0},
-	{AMOVFL, C_CREG, C_NONE, C_NONE, C_CREG, 67, 4, 0},
-	{AMOVW, C_CREG, C_NONE, C_NONE, C_REG, 68, 4, 0},
-	{AMOVWZ, C_CREG, C_NONE, C_NONE, C_REG, 68, 4, 0},
-	{AMOVFL, C_REG, C_NONE, C_NONE, C_LCON, 69, 4, 0},
-	{AMOVFL, C_REG, C_NONE, C_NONE, C_CREG, 69, 4, 0},
-	{AMOVW, C_REG, C_NONE, C_NONE, C_CREG, 69, 4, 0},
-	{AMOVWZ, C_REG, C_NONE, C_NONE, C_CREG, 69, 4, 0},
-	{ACMP, C_REG, C_NONE, C_NONE, C_REG, 70, 4, 0},
-	{ACMP, C_REG, C_REG, C_NONE, C_REG, 70, 4, 0},
-	{ACMP, C_REG, C_NONE, C_NONE, C_ADDCON, 71, 4, 0},
-	{ACMP, C_REG, C_REG, C_NONE, C_ADDCON, 71, 4, 0},
-	{ACMPU, C_REG, C_NONE, C_NONE, C_REG, 70, 4, 0},
-	{ACMPU, C_REG, C_REG, C_NONE, C_REG, 70, 4, 0},
-	{ACMPU, C_REG, C_NONE, C_NONE, C_ANDCON, 71, 4, 0},
-	{ACMPU, C_REG, C_REG, C_NONE, C_ANDCON, 71, 4, 0},
-	{AFCMPO, C_FREG, C_NONE, C_NONE, C_FREG, 70, 4, 0},
-	{AFCMPO, C_FREG, C_REG, C_NONE, C_FREG, 70, 4, 0},
-	{ATW, C_LCON, C_REG, C_NONE, C_REG, 60, 4, 0},
-	{ATW, C_LCON, C_REG, C_NONE, C_ADDCON, 61, 4, 0},
-	{ADCBF, C_ZOREG, C_NONE, C_NONE, C_NONE, 43, 4, 0},
-	{ADCBF, C_SOREG, C_NONE, C_NONE, C_NONE, 43, 4, 0},
-	{ADCBF, C_ZOREG, C_REG, C_NONE, C_SCON, 43, 4, 0},
-	{ADCBF, C_SOREG, C_NONE, C_NONE, C_SCON, 43, 4, 0},
-	{AECOWX, C_REG, C_REG, C_NONE, C_ZOREG, 44, 4, 0},
-	{AECIWX, C_ZOREG, C_REG, C_NONE, C_REG, 45, 4, 0},
-	{AECOWX, C_REG, C_NONE, C_NONE, C_ZOREG, 44, 4, 0},
-	{AECIWX, C_ZOREG, C_NONE, C_NONE, C_REG, 45, 4, 0},
-	{ALDAR, C_ZOREG, C_NONE, C_NONE, C_REG, 45, 4, 0},
-	{ALDAR, C_ZOREG, C_NONE, C_ANDCON, C_REG, 45, 4, 0},
-	{AEIEIO, C_NONE, C_NONE, C_NONE, C_NONE, 46, 4, 0},
-	{ATLBIE, C_REG, C_NONE, C_NONE, C_NONE, 49, 4, 0},
-	{ATLBIE, C_SCON, C_NONE, C_NONE, C_REG, 49, 4, 0},
-	{ASLBMFEE, C_REG, C_NONE, C_NONE, C_REG, 55, 4, 0},
-	{ASLBMTE, C_REG, C_NONE, C_NONE, C_REG, 55, 4, 0},
-	{ASTSW, C_REG, C_NONE, C_NONE, C_ZOREG, 44, 4, 0},
-	{ASTSW, C_REG, C_NONE, C_LCON, C_ZOREG, 41, 4, 0},
-	{ALSW, C_ZOREG, C_NONE, C_NONE, C_REG, 45, 4, 0},
-	{ALSW, C_ZOREG, C_NONE, C_LCON, C_REG, 42, 4, 0},
-	{obj.AUNDEF, C_NONE, C_NONE, C_NONE, C_NONE, 78, 4, 0},
-	{obj.APCDATA, C_LCON, C_NONE, C_NONE, C_LCON, 0, 0, 0},
-	{obj.AFUNCDATA, C_SCON, C_NONE, C_NONE, C_ADDR, 0, 0, 0},
-	{obj.ANOP, C_NONE, C_NONE, C_NONE, C_NONE, 0, 0, 0},
-	{obj.ANOP, C_LCON, C_NONE, C_NONE, C_NONE, 0, 0, 0}, // NOP operand variations added for #40689
-	{obj.ANOP, C_REG, C_NONE, C_NONE, C_NONE, 0, 0, 0},  // to preserve previous behavior
-	{obj.ANOP, C_FREG, C_NONE, C_NONE, C_NONE, 0, 0, 0},
-	{obj.ADUFFZERO, C_NONE, C_NONE, C_NONE, C_LBRA, 11, 4, 0}, // same as ABR/ABL
-	{obj.ADUFFCOPY, C_NONE, C_NONE, C_NONE, C_LBRA, 11, 4, 0}, // same as ABR/ABL
-	{obj.APCALIGN, C_LCON, C_NONE, C_NONE, C_NONE, 0, 0, 0},   // align code
-
-	{obj.AXXX, C_NONE, C_NONE, C_NONE, C_NONE, 0, 4, 0},
+	{as: AMOVW, a1: C_REG, a4: C_SPR, type_: 66, size: 4},
+	{as: AMOVW, a1: C_REG, a4: C_CTR, type_: 66, size: 4},
+	{as: AMOVW, a1: C_REG, a4: C_XER, type_: 66, size: 4},
+	{as: AMOVW, a1: C_SPR, a4: C_REG, type_: 66, size: 4},
+	{as: AMOVW, a1: C_XER, a4: C_REG, type_: 66, size: 4},
+	{as: AMOVWZ, a1: C_REG, a4: C_SPR, type_: 66, size: 4},
+	{as: AMOVWZ, a1: C_REG, a4: C_CTR, type_: 66, size: 4},
+	{as: AMOVWZ, a1: C_REG, a4: C_XER, type_: 66, size: 4},
+	{as: AMOVWZ, a1: C_SPR, a4: C_REG, type_: 66, size: 4},
+	{as: AMOVWZ, a1: C_XER, a4: C_REG, type_: 66, size: 4},
+	{as: AMOVFL, a1: C_FPSCR, a4: C_CREG, type_: 73, size: 4},
+	{as: AMOVFL, a1: C_CREG, a4: C_CREG, type_: 67, size: 4},
+	{as: AMOVW, a1: C_CREG, a4: C_REG, type_: 68, size: 4},
+	{as: AMOVWZ, a1: C_CREG, a4: C_REG, type_: 68, size: 4},
+	{as: AMOVFL, a1: C_REG, a4: C_LCON, type_: 69, size: 4},
+	{as: AMOVFL, a1: C_REG, a4: C_CREG, type_: 69, size: 4},
+	{as: AMOVW, a1: C_REG, a4: C_CREG, type_: 69, size: 4},
+	{as: AMOVWZ, a1: C_REG, a4: C_CREG, type_: 69, size: 4},
+	{as: ACMP, a1: C_REG, a4: C_REG, type_: 70, size: 4},
+	{as: ACMP, a1: C_REG, a2: C_REG, a4: C_REG, type_: 70, size: 4},
+	{as: ACMP, a1: C_REG, a4: C_ADDCON, type_: 71, size: 4},
+	{as: ACMP, a1: C_REG, a2: C_REG, a4: C_ADDCON, type_: 71, size: 4},
+	{as: ACMPU, a1: C_REG, a4: C_REG, type_: 70, size: 4},
+	{as: ACMPU, a1: C_REG, a2: C_REG, a4: C_REG, type_: 70, size: 4},
+	{as: ACMPU, a1: C_REG, a4: C_ANDCON, type_: 71, size: 4},
+	{as: ACMPU, a1: C_REG, a2: C_REG, a4: C_ANDCON, type_: 71, size: 4},
+	{as: AFCMPO, a1: C_FREG, a4: C_FREG, type_: 70, size: 4},
+	{as: AFCMPO, a1: C_FREG, a2: C_REG, a4: C_FREG, type_: 70, size: 4},
+	{as: ATW, a1: C_LCON, a2: C_REG, a4: C_REG, type_: 60, size: 4},
+	{as: ATW, a1: C_LCON, a2: C_REG, a4: C_ADDCON, type_: 61, size: 4},
+	{as: ADCBF, a1: C_ZOREG, type_: 43, size: 4},
+	{as: ADCBF, a1: C_SOREG, type_: 43, size: 4},
+	{as: ADCBF, a1: C_ZOREG, a2: C_REG, a4: C_SCON, type_: 43, size: 4},
+	{as: ADCBF, a1: C_SOREG, a4: C_SCON, type_: 43, size: 4},
+	{as: AECOWX, a1: C_REG, a2: C_REG, a4: C_ZOREG, type_: 44, size: 4},
+	{as: AECIWX, a1: C_ZOREG, a2: C_REG, a4: C_REG, type_: 45, size: 4},
+	{as: AECOWX, a1: C_REG, a4: C_ZOREG, type_: 44, size: 4},
+	{as: AECIWX, a1: C_ZOREG, a4: C_REG, type_: 45, size: 4},
+	{as: ALDAR, a1: C_ZOREG, a4: C_REG, type_: 45, size: 4},
+	{as: ALDAR, a1: C_ZOREG, a3: C_ANDCON, a4: C_REG, type_: 45, size: 4},
+	{as: AEIEIO, type_: 46, size: 4},
+	{as: ATLBIE, a1: C_REG, type_: 49, size: 4},
+	{as: ATLBIE, a1: C_SCON, a4: C_REG, type_: 49, size: 4},
+	{as: ASLBMFEE, a1: C_REG, a4: C_REG, type_: 55, size: 4},
+	{as: ASLBMTE, a1: C_REG, a4: C_REG, type_: 55, size: 4},
+	{as: ASTSW, a1: C_REG, a4: C_ZOREG, type_: 44, size: 4},
+	{as: ASTSW, a1: C_REG, a3: C_LCON, a4: C_ZOREG, type_: 41, size: 4},
+	{as: ALSW, a1: C_ZOREG, a4: C_REG, type_: 45, size: 4},
+	{as: ALSW, a1: C_ZOREG, a3: C_LCON, a4: C_REG, type_: 42, size: 4},
+	{as: obj.AUNDEF, type_: 78, size: 4},
+	{as: obj.APCDATA, a1: C_LCON, a4: C_LCON, type_: 0, size: 0},
+	{as: obj.AFUNCDATA, a1: C_SCON, a4: C_ADDR, type_: 0, size: 0},
+	{as: obj.ANOP, type_: 0, size: 0},
+	{as: obj.ANOP, a1: C_LCON, type_: 0, size: 0}, // NOP operand variations added for #40689
+	{as: obj.ANOP, a1: C_REG, type_: 0, size: 0},  // to preserve previous behavior
+	{as: obj.ANOP, a1: C_FREG, type_: 0, size: 0},
+	{as: obj.ADUFFZERO, a4: C_LBRA, type_: 11, size: 4}, // same as ABR/ABL
+	{as: obj.ADUFFCOPY, a4: C_LBRA, type_: 11, size: 4}, // same as ABR/ABL
+	{as: obj.APCALIGN, a1: C_LCON, type_: 0, size: 0},   // align code
+
+	{as: obj.AXXX, type_: 0, size: 4},
 }
 
 var oprange [ALAST & obj.AMask][]Optab
-- 
GitLab


From 87e984ab2988afccdb75a4c235b318ec6be46e6a Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Mon, 22 Feb 2021 11:11:51 -0800
Subject: [PATCH 0753/2400] test: add test for issue 38698

It was fixed by CL 294289, for #44378.
This is a different style of test that uses
line directives instead of extremely long lines.

Fixes #38698.

Change-Id: I50a1585030978b35fffa9981d6ed96b99216dc3e
Reviewed-on: https://go-review.googlesource.com/c/go/+/295129
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 test/fixedbugs/issue38698.go | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 test/fixedbugs/issue38698.go

diff --git a/test/fixedbugs/issue38698.go b/test/fixedbugs/issue38698.go
new file mode 100644
index 0000000000..819e223791
--- /dev/null
+++ b/test/fixedbugs/issue38698.go
@@ -0,0 +1,23 @@
+// compile
+
+// Copyright 2021 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.
+
+// This test case caused a panic in the compiler's DWARF gen code.
+
+package p
+
+func ff( /*line :10*/ x string) bool {
+	{
+		var _ /*line :10*/, x int
+		_ = x
+	}
+	return x == ""
+}
+
+
+func h(a string) bool {
+	return ff(a)
+}
+
-- 
GitLab


From 04903476fe6a1bba4ed751f5e234bccb5a651a9b Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Mon, 22 Feb 2021 11:55:14 -0800
Subject: [PATCH 0754/2400] cmd/compile: reject some rare looping CFGs in
 shortcircuit

One CFGs that shortcircuit looks for is:

p   q
 \ /
  b
 / \
t   u

The test case creates a CFG like that in which p == t.
That caused the compiler to generate a (short-lived) invalid phi value.

Fix this with a relatively big hammer: Disallow single-length loops entirely.
This is probably overkill, but it such loops are very rare.
This doesn't change the generated code for anything in std.

It generates worse code for the test case:
It no longer compiles the entire function away.

Fixes #44465

Change-Id: Ib8cdcd6cc9d7f48b4dab253652038ace24eae152
Reviewed-on: https://go-review.googlesource.com/c/go/+/295130
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/ssa/shortcircuit.go |  7 +++++++
 test/fixedbugs/issue44465.go                 | 21 ++++++++++++++++++++
 2 files changed, 28 insertions(+)
 create mode 100644 test/fixedbugs/issue44465.go

diff --git a/src/cmd/compile/internal/ssa/shortcircuit.go b/src/cmd/compile/internal/ssa/shortcircuit.go
index 7b4ee2e81c..c72c86a67e 100644
--- a/src/cmd/compile/internal/ssa/shortcircuit.go
+++ b/src/cmd/compile/internal/ssa/shortcircuit.go
@@ -266,6 +266,13 @@ func shortcircuitPhiPlan(b *Block, ctl *Value, cidx int, ti int64) func(*Value,
 	// u is the "untaken" branch: the successor we never go to when coming in from p.
 	u := b.Succs[1^ti].b
 
+	// In the following CFG matching, ensure that b's preds are entirely distinct from b's succs.
+	// This is probably a stronger condition than required, but this happens extremely rarely,
+	// and it makes it easier to avoid getting deceived by pretty ASCII charts. See #44465.
+	if p0, p1 := b.Preds[0].b, b.Preds[1].b; p0 == t || p1 == t || p0 == u || p1 == u {
+		return nil
+	}
+
 	// Look for some common CFG structures
 	// in which the outbound paths from b merge,
 	// with no other preds joining them.
diff --git a/test/fixedbugs/issue44465.go b/test/fixedbugs/issue44465.go
new file mode 100644
index 0000000000..8cb62adaac
--- /dev/null
+++ b/test/fixedbugs/issue44465.go
@@ -0,0 +1,21 @@
+// compile -d=ssa/check/seed
+
+// Copyright 2021 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.
+
+// This code caused an internal consistency error due to a bad shortcircuit optimization.
+
+package p
+
+func f() {
+	var b bool
+	if b {
+		b = true
+	}
+l:
+	for !b {
+		b = true
+		goto l
+	}
+}
-- 
GitLab


From 1391d4142cab5e5b83ca3362be67af80ba2f95e8 Mon Sep 17 00:00:00 2001
From: zhengjianxun <zhuimengshaonian04@gmail.com>
Date: Mon, 22 Feb 2021 13:30:03 +0000
Subject: [PATCH 0755/2400] fix typo in issue16760.go

fix typo in issue16760.go, unconditinally ->  unconditionally

Change-Id: I3a04fbcb23395c562821b35bc2d81cfaec0bc1ed
GitHub-Last-Rev: 5ce52a3deb52826bc28022776c3fe3ffa7376084
GitHub-Pull-Request: golang/go#44495
Reviewed-on: https://go-review.googlesource.com/c/go/+/294969
Trust: Alberto Donizetti <alb.donizetti@gmail.com>
Reviewed-by: zhengjianxun <zhuimengshaonian04@gmail.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 test/fixedbugs/issue16760.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/fixedbugs/issue16760.go b/test/fixedbugs/issue16760.go
index d0e08b5ead..a7eede4d10 100644
--- a/test/fixedbugs/issue16760.go
+++ b/test/fixedbugs/issue16760.go
@@ -6,7 +6,7 @@
 
 // Make sure we don't start marshaling (writing to the stack)
 // arguments until those arguments are evaluated and known
-// not to unconditinally panic. If they unconditionally panic,
+// not to unconditionally panic. If they unconditionally panic,
 // we write some args but never do the call. That messes up
 // the logic which decides how big the argout section needs to be.
 
-- 
GitLab


From 094048b93845c08e0f2db8639764f9564e64835b Mon Sep 17 00:00:00 2001
From: cui <cuiweixie@gmail.com>
Date: Thu, 18 Feb 2021 17:51:24 +0000
Subject: [PATCH 0756/2400] cmd/compile/internal: loop opt

Change-Id: I5fe767237b8046934e9b0f33bd3dafabdb727dd6
GitHub-Last-Rev: 94fea3d57279e8b2d62f7f6be4301698dc8841e3
GitHub-Pull-Request: golang/go#44384
Reviewed-on: https://go-review.googlesource.com/c/go/+/293809
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/types/size.go | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/types/size.go b/src/cmd/compile/internal/types/size.go
index d1203e4a21..799cf3a1f6 100644
--- a/src/cmd/compile/internal/types/size.go
+++ b/src/cmd/compile/internal/types/size.go
@@ -624,9 +624,11 @@ func PtrDataSize(t *Type) int64 {
 	case TSTRUCT:
 		// Find the last field that has pointers.
 		var lastPtrField *Field
-		for _, t1 := range t.Fields().Slice() {
-			if t1.Type.HasPointers() {
-				lastPtrField = t1
+		fs := t.Fields().Slice()
+		for i := len(fs) - 1; i >= 0; i-- {
+			if fs[i].Type.HasPointers() {
+				lastPtrField = fs[i]
+				break
 			}
 		}
 		return lastPtrField.Offset + PtrDataSize(lastPtrField.Type)
-- 
GitLab


From 1678829d9555761c0fa6571fd3bcaec016add3d2 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Mon, 22 Feb 2021 17:43:08 -0500
Subject: [PATCH 0757/2400] cmd/compile: correctly use X15 to zero frame

In CL 288093 we reserve X15 as the zero register and use that to
zero values. It only covered zeroing generated in SSA but missed
zeroing the frame generated late in the compilation. The latter
still uses X0, but now DUFFZERO expects X15, so it doesn't
actually zero the frame. Change it to use X15.

Should fix #44333.

Change-Id: I239d2b78a5f6468bc86b70aecdd294045311759f
Reviewed-on: https://go-review.googlesource.com/c/go/+/295210
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/amd64/ggen.go | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/cmd/compile/internal/amd64/ggen.go b/src/cmd/compile/internal/amd64/ggen.go
index aefdb14a69..14c3bd1129 100644
--- a/src/cmd/compile/internal/amd64/ggen.go
+++ b/src/cmd/compile/internal/amd64/ggen.go
@@ -56,8 +56,8 @@ func dzDI(b int64) int64 {
 
 func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.Prog {
 	const (
-		ax = 1 << iota
-		x0
+		ax  = 1 << iota // if AX is already zeroed.
+		x15             // if X15 is already zeroed. Note: in new ABI, X15 is always zero.
 	)
 
 	if cnt == 0 {
@@ -85,29 +85,29 @@ func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.
 		}
 		p = pp.Append(p, x86.AMOVQ, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_MEM, x86.REG_SP, off)
 	} else if !isPlan9 && cnt <= int64(8*types.RegSize) {
-		if *state&x0 == 0 {
-			p = pp.Append(p, x86.AXORPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_REG, x86.REG_X0, 0)
-			*state |= x0
+		if objabi.Regabi_enabled == 0 && *state&x15 == 0 {
+			p = pp.Append(p, x86.AXORPS, obj.TYPE_REG, x86.REG_X15, 0, obj.TYPE_REG, x86.REG_X15, 0)
+			*state |= x15
 		}
 
 		for i := int64(0); i < cnt/16; i++ {
-			p = pp.Append(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_MEM, x86.REG_SP, off+i*16)
+			p = pp.Append(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X15, 0, obj.TYPE_MEM, x86.REG_SP, off+i*16)
 		}
 
 		if cnt%16 != 0 {
-			p = pp.Append(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_MEM, x86.REG_SP, off+cnt-int64(16))
+			p = pp.Append(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X15, 0, obj.TYPE_MEM, x86.REG_SP, off+cnt-int64(16))
 		}
 	} else if !isPlan9 && (cnt <= int64(128*types.RegSize)) {
-		if *state&x0 == 0 {
-			p = pp.Append(p, x86.AXORPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_REG, x86.REG_X0, 0)
-			*state |= x0
+		if objabi.Regabi_enabled == 0 && *state&x15 == 0 {
+			p = pp.Append(p, x86.AXORPS, obj.TYPE_REG, x86.REG_X15, 0, obj.TYPE_REG, x86.REG_X15, 0)
+			*state |= x15
 		}
 		p = pp.Append(p, leaptr, obj.TYPE_MEM, x86.REG_SP, off+dzDI(cnt), obj.TYPE_REG, x86.REG_DI, 0)
 		p = pp.Append(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_ADDR, 0, dzOff(cnt))
 		p.To.Sym = ir.Syms.Duffzero
 
 		if cnt%16 != 0 {
-			p = pp.Append(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_MEM, x86.REG_DI, -int64(8))
+			p = pp.Append(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X15, 0, obj.TYPE_MEM, x86.REG_DI, -int64(8))
 		}
 	} else {
 		if *state&ax == 0 {
-- 
GitLab


From 1126bbb82ab2f81dcb33df696a1bb601a98d3174 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Mon, 22 Feb 2021 15:39:00 -0500
Subject: [PATCH 0758/2400] go/parser: return ast.BadExpr for missing index
 operands

The parser was returning the indexed operand when a slice or index or
instance expression was missing any index arguments (as in the
expression `a[]`). This can result in returning an *ast.Ident for the
LHS of the (invalid) assignment `a[] = ...` -- in this case parsing the
LHS as just `a`. Unfortunately, as the indexed operand `a` has already
been resolved, this results in a panic for duplicate resolution.

Fix this by instead returning an ast.BadExpr. This can suppress some
subsequent errors from the typechecker, but those errors may or may not
be correct anyway. Other interpretations, such as an *ast.IndexExpr with
bad or missing X, run into potential misinterpretations downstream (both
caused errors in go/types and/or gopls).

Fixes #44504

Change-Id: I5ca8bed4a1861bcc7db8898770b08937110981d4
Reviewed-on: https://go-review.googlesource.com/c/go/+/295151
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/parser/parser.go               |  3 ++-
 src/go/parser/testdata/issue44504.src | 13 +++++++++++++
 src/go/types/fixedbugs/issue39634.go2 |  2 +-
 3 files changed, 16 insertions(+), 2 deletions(-)
 create mode 100644 src/go/parser/testdata/issue44504.src

diff --git a/src/go/parser/parser.go b/src/go/parser/parser.go
index 41c3f2943e..5c4cea8638 100644
--- a/src/go/parser/parser.go
+++ b/src/go/parser/parser.go
@@ -1485,8 +1485,9 @@ func (p *parser) parseIndexOrSliceOrInstance(x ast.Expr) ast.Expr {
 		// empty index, slice or index expressions are not permitted;
 		// accept them for parsing tolerance, but complain
 		p.errorExpected(p.pos, "operand")
+		rbrack := p.pos
 		p.next()
-		return x
+		return &ast.BadExpr{From: x.Pos(), To: rbrack}
 	}
 	p.exprLev++
 
diff --git a/src/go/parser/testdata/issue44504.src b/src/go/parser/testdata/issue44504.src
new file mode 100644
index 0000000000..7791f4a809
--- /dev/null
+++ b/src/go/parser/testdata/issue44504.src
@@ -0,0 +1,13 @@
+// Copyright 2021 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.
+
+// Test case for issue 44504: panic due to duplicate resolution of slice/index
+// operands. We should not try to resolve a LHS expression with invalid syntax.
+
+package p
+
+func _() {
+  var items []bool
+  items[] /* ERROR "operand" */ = false
+}
diff --git a/src/go/types/fixedbugs/issue39634.go2 b/src/go/types/fixedbugs/issue39634.go2
index 249542d541..78dee00383 100644
--- a/src/go/types/fixedbugs/issue39634.go2
+++ b/src/go/types/fixedbugs/issue39634.go2
@@ -84,7 +84,7 @@ var x T25 /* ERROR without instantiation */ .m1
 
 // crash 26
 type T26 = interface{ F26[ /* ERROR methods cannot have type parameters */ Z any]() }
-func F26[Z any]() T26 { return F26 /* ERROR without instantiation */ /* ERROR missing method */ [] /* ERROR operand */ }
+func F26[Z any]() T26 { return F26[] /* ERROR operand */ }
 
 // crash 27
 func e27[T any]() interface{ x27 /* ERROR not a type */ }
-- 
GitLab


From f113e9a14f08d23be78f75050185f9796a1d243f Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 18 Feb 2021 14:18:53 -0500
Subject: [PATCH 0759/2400] cmd/dist: match goexperiment.regabi tag when
 GOEXPERIMENT is on

Change-Id: I5e4347dde6dcb49cd96608e4f67e54c7b3050bc2
Reviewed-on: https://go-review.googlesource.com/c/go/+/293851
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/cmd/dist/build.go | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/cmd/dist/build.go b/src/cmd/dist/build.go
index c02b92818c..07ede42574 100644
--- a/src/cmd/dist/build.go
+++ b/src/cmd/dist/build.go
@@ -982,6 +982,11 @@ func matchtag(tag string) bool {
 		}
 		return !matchtag(tag[1:])
 	}
+	if os.Getenv("GOEXPERIMENT") == "regabi" && tag == "goexperiment.regabi" {
+		// TODO: maybe we can handle GOEXPERIMENT more generally.
+		// Or remove once we commit to regabi (#40724).
+		return true
+	}
 	return tag == "gc" || tag == goos || tag == goarch || tag == "cmd_go_bootstrap" || tag == "go1.1" ||
 		(goos == "android" && tag == "linux") ||
 		(goos == "illumos" && tag == "solaris") ||
-- 
GitLab


From 7af821a661be57cdd13212695cd6c1095487f2b4 Mon Sep 17 00:00:00 2001
From: yangwenmai <yangwen.yw@gmail.com>
Date: Fri, 25 Dec 2020 09:36:41 +0800
Subject: [PATCH 0760/2400] all: faster midpoint computation in binary search
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

On my machine (3.1 GHz Quad-Core Intel Core i7, macOS 10.15.7 10.15.7), go 1.15.6

benchstat:
name          old time/op  new time/op  delta
SearchInts-8  20.3ns ± 1%  16.6ns ± 6%  -18.37%  (p=0.000 n=9+10)

Change-Id: I346e5955fd6df6ce10254b22267dbc8d5a2b16c0
Reviewed-on: https://go-review.googlesource.com/c/go/+/279439
Reviewed-by: Ben Shi <powerman1st@163.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Griesemer <gri@golang.org>
---
 src/go/token/position.go            |  2 +-
 src/go/token/position_bench_test.go | 24 ++++++++++++++++++++++++
 src/reflect/type.go                 |  2 +-
 src/strconv/makeisprint.go          |  4 ++--
 src/strconv/quote.go                |  4 ++--
 5 files changed, 30 insertions(+), 6 deletions(-)
 create mode 100644 src/go/token/position_bench_test.go

diff --git a/src/go/token/position.go b/src/go/token/position.go
index a21f5fd056..bbcd8b022b 100644
--- a/src/go/token/position.go
+++ b/src/go/token/position.go
@@ -540,7 +540,7 @@ func searchInts(a []int, x int) int {
 	// TODO(gri): Remove this when compilers have caught up.
 	i, j := 0, len(a)
 	for i < j {
-		h := i + (j-i)/2 // avoid overflow when computing h
+		h := i + (j-i)>>1 // avoid overflow when computing h
 		// i ≤ h < j
 		if a[h] <= x {
 			i = h + 1
diff --git a/src/go/token/position_bench_test.go b/src/go/token/position_bench_test.go
new file mode 100644
index 0000000000..41be7285b7
--- /dev/null
+++ b/src/go/token/position_bench_test.go
@@ -0,0 +1,24 @@
+// Copyright 2021 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 token
+
+import (
+	"testing"
+)
+
+func BenchmarkSearchInts(b *testing.B) {
+	data := make([]int, 10000)
+	for i := 0; i < 10000; i++ {
+		data[i] = i
+	}
+	const x = 8
+	if r := searchInts(data, x); r != x {
+		b.Errorf("got index = %d; want %d", r, x)
+	}
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		searchInts(data, x)
+	}
+}
diff --git a/src/reflect/type.go b/src/reflect/type.go
index d52816628f..eb2030063a 100644
--- a/src/reflect/type.go
+++ b/src/reflect/type.go
@@ -1723,7 +1723,7 @@ func typesByString(s string) []*rtype {
 		// This is a copy of sort.Search, with f(h) replaced by (*typ[h].String() >= s).
 		i, j := 0, len(offs)
 		for i < j {
-			h := i + (j-i)/2 // avoid overflow when computing h
+			h := i + (j-i)>>1 // avoid overflow when computing h
 			// i ≤ h < j
 			if !(rtypeOff(section, offs[h]).String() >= s) {
 				i = h + 1 // preserves f(i-1) == false
diff --git a/src/strconv/makeisprint.go b/src/strconv/makeisprint.go
index 79678341d4..909f9e4787 100644
--- a/src/strconv/makeisprint.go
+++ b/src/strconv/makeisprint.go
@@ -37,7 +37,7 @@ var (
 func bsearch16(a []uint16, x uint16) int {
 	i, j := 0, len(a)
 	for i < j {
-		h := i + (j-i)/2
+		h := i + (j-i)>>1
 		if a[h] < x {
 			i = h + 1
 		} else {
@@ -52,7 +52,7 @@ func bsearch16(a []uint16, x uint16) int {
 func bsearch32(a []uint32, x uint32) int {
 	i, j := 0, len(a)
 	for i < j {
-		h := i + (j-i)/2
+		h := i + (j-i)>>1
 		if a[h] < x {
 			i = h + 1
 		} else {
diff --git a/src/strconv/quote.go b/src/strconv/quote.go
index 4ffa10b72e..db0dbb288b 100644
--- a/src/strconv/quote.go
+++ b/src/strconv/quote.go
@@ -440,7 +440,7 @@ func Unquote(s string) (string, error) {
 func bsearch16(a []uint16, x uint16) int {
 	i, j := 0, len(a)
 	for i < j {
-		h := i + (j-i)/2
+		h := i + (j-i)>>1
 		if a[h] < x {
 			i = h + 1
 		} else {
@@ -455,7 +455,7 @@ func bsearch16(a []uint16, x uint16) int {
 func bsearch32(a []uint32, x uint32) int {
 	i, j := 0, len(a)
 	for i < j {
-		h := i + (j-i)/2
+		h := i + (j-i)>>1
 		if a[h] < x {
 			i = h + 1
 		} else {
-- 
GitLab


From 5f3dabbb79fb3dc8eea9a5050557e9241793dce3 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Fri, 19 Feb 2021 09:40:35 -0800
Subject: [PATCH 0761/2400] cmd/compile: fix import of functions of multiple
 nested closure

For import of functions with closures, the connections among closure
variables are constructed on-the-fly via CaptureName(). For multiple
nested closures, we need to temporarily set r.curfn to each closure we
construct, so that the processing of closure variables will be correct
for any nested closure inside that closure.

Fixes #44335

Change-Id: I34f99e2822250542528ff6b2232bf36756140868
Reviewed-on: https://go-review.googlesource.com/c/go/+/294212
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/typecheck/iimport.go | 12 ++++++++----
 test/fixedbugs/issue44335.dir/a.go            | 17 +++++++++++++++++
 test/fixedbugs/issue44335.dir/b.go            | 11 +++++++++++
 test/fixedbugs/issue44335.go                  |  7 +++++++
 4 files changed, 43 insertions(+), 4 deletions(-)
 create mode 100644 test/fixedbugs/issue44335.dir/a.go
 create mode 100644 test/fixedbugs/issue44335.dir/b.go
 create mode 100644 test/fixedbugs/issue44335.go

diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 7b5b113b15..29090a9178 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -986,15 +986,19 @@ func (r *importReader) node() ir.Node {
 		fn.ClosureVars = cvars
 		r.allClosureVars = append(r.allClosureVars, cvars...)
 
-		fn.Dcl = r.readFuncDcls(fn)
-		body := r.stmtList()
+		fn.Inl = &ir.Inline{}
+		// Read in the Dcls and Body of the closure after temporarily
+		// setting r.curfn to fn.
+		r.funcBody(fn)
+		fn.Dcl = fn.Inl.Dcl
+		fn.Body = fn.Inl.Body
+		fn.Inl = nil
+
 		ir.FinishCaptureNames(pos, r.curfn, fn)
 
 		clo := ir.NewClosureExpr(pos, fn)
 		fn.OClosure = clo
 
-		fn.Body = body
-
 		return clo
 
 	// case OPTRLIT:
diff --git a/test/fixedbugs/issue44335.dir/a.go b/test/fixedbugs/issue44335.dir/a.go
new file mode 100644
index 0000000000..2c9c217813
--- /dev/null
+++ b/test/fixedbugs/issue44335.dir/a.go
@@ -0,0 +1,17 @@
+// Copyright 2021 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 a
+
+type W struct {
+	M func(string) string
+}
+
+func FM(m string) func(W) {
+	return func(pw W) {
+		pw.M = func(string) string {
+			return m
+		}
+	}
+}
diff --git a/test/fixedbugs/issue44335.dir/b.go b/test/fixedbugs/issue44335.dir/b.go
new file mode 100644
index 0000000000..e72c2abc6a
--- /dev/null
+++ b/test/fixedbugs/issue44335.dir/b.go
@@ -0,0 +1,11 @@
+// Copyright 2021 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 b
+
+import "./a"
+
+func F() {
+	a.FM("")
+}
diff --git a/test/fixedbugs/issue44335.go b/test/fixedbugs/issue44335.go
new file mode 100644
index 0000000000..d406838588
--- /dev/null
+++ b/test/fixedbugs/issue44335.go
@@ -0,0 +1,7 @@
+// compiledir
+
+// Copyright 2021 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 ignored
-- 
GitLab


From 1901e2647f5724df38e9a9a3756dad01704bc783 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Wed, 17 Feb 2021 01:14:19 +0700
Subject: [PATCH 0762/2400] test: add test for findTypeLoop with symbols from
 other packages

CL 274294 improved findTypeLoop but also fixed a new found bug on master
branch. This Cl adds test cases for this.

Updates #44266

Change-Id: Ie4a07a3487758a1e4ad2f2847dcde975b10d2a77
Reviewed-on: https://go-review.googlesource.com/c/go/+/292889
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 test/fixedbugs/issue44266.go | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 test/fixedbugs/issue44266.go

diff --git a/test/fixedbugs/issue44266.go b/test/fixedbugs/issue44266.go
new file mode 100644
index 0000000000..c683e56075
--- /dev/null
+++ b/test/fixedbugs/issue44266.go
@@ -0,0 +1,23 @@
+// errorcheck
+
+// Copyright 2021 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 p
+
+import "io"
+
+type T1 interface {
+	io.Reader
+}
+
+type T2 struct {
+	io.SectionReader
+}
+
+type T3 struct { // ERROR "invalid recursive type T3"
+	T1
+	T2
+	parent T3
+}
-- 
GitLab


From 378f73e2d56998fba872decd61583d96cd9b1f77 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Fri, 19 Feb 2021 16:47:04 -0800
Subject: [PATCH 0763/2400] cmd/compile/internal/types2: enable TestIssue25627

Since we have syntax.Walk, we can make this test work again.

Change-Id: I55cbde7303e5bcbe1123b6679f2ce859d377fd86
Reviewed-on: https://go-review.googlesource.com/c/go/+/294472
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 .../compile/internal/types2/issues_test.go    | 23 ++++++++-----------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/src/cmd/compile/internal/types2/issues_test.go b/src/cmd/compile/internal/types2/issues_test.go
index 5a32fa590a..ba7cefb892 100644
--- a/src/cmd/compile/internal/types2/issues_test.go
+++ b/src/cmd/compile/internal/types2/issues_test.go
@@ -300,8 +300,6 @@ func TestIssue22525(t *testing.T) {
 }
 
 func TestIssue25627(t *testing.T) {
-	t.Skip("requires syntax tree inspection")
-
 	const prefix = `package p; import "unsafe"; type P *struct{}; type I interface{}; type T `
 	// The src strings (without prefix) are constructed such that the number of semicolons
 	// plus one corresponds to the number of fields expected in the respective struct.
@@ -325,20 +323,17 @@ func TestIssue25627(t *testing.T) {
 			}
 		}
 
-		unimplemented()
-		/*
-			ast.Inspect(f, func(n syntax.Node) bool {
-				if spec, _ := n.(*syntax.TypeDecl); spec != nil {
-					if tv, ok := info.Types[spec.Type]; ok && spec.Name.Value == "T" {
-						want := strings.Count(src, ";") + 1
-						if got := tv.Type.(*Struct).NumFields(); got != want {
-							t.Errorf("%s: got %d fields; want %d", src, got, want)
-						}
+		syntax.Walk(f, func(n syntax.Node) bool {
+			if decl, _ := n.(*syntax.TypeDecl); decl != nil {
+				if tv, ok := info.Types[decl.Type]; ok && decl.Name.Value == "T" {
+					want := strings.Count(src, ";") + 1
+					if got := tv.Type.(*Struct).NumFields(); got != want {
+						t.Errorf("%s: got %d fields; want %d", src, got, want)
 					}
 				}
-				return true
-			})
-		*/
+			}
+			return false
+		})
 	}
 }
 
-- 
GitLab


From 89eb2b55b9d128f0bd2bfada5d8b2bb115e1d6d8 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Fri, 19 Feb 2021 16:58:24 -0800
Subject: [PATCH 0764/2400] cmd/compile/internal/types2: review of
 issues_test.go

The changes between (equivalent, and reviewed) go/types/issues_test.go
and issues_test.go can be seen by comparing patchset 1 and 3. The actual
change is just removing the "// UNREVIEWED" marker and making making
some minor code adjustments to match go/types's version more closely.

Change-Id: I26f3f700d12db69fc68161a6b0dc081a0e9cd0d4
Reviewed-on: https://go-review.googlesource.com/c/go/+/294473
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 .../compile/internal/types2/issues_test.go    | 19 +++++++------------
 1 file changed, 7 insertions(+), 12 deletions(-)

diff --git a/src/cmd/compile/internal/types2/issues_test.go b/src/cmd/compile/internal/types2/issues_test.go
index ba7cefb892..a36b832f04 100644
--- a/src/cmd/compile/internal/types2/issues_test.go
+++ b/src/cmd/compile/internal/types2/issues_test.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2013 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.
@@ -29,7 +28,6 @@ func mustParse(t *testing.T, src string) *syntax.File {
 func TestIssue5770(t *testing.T) {
 	f := mustParse(t, `package p; type S struct{T}`)
 	var conf Config
-	// conf := Config{Importer: importer.Default()}
 	_, err := conf.Check(f.PkgName.Value, []*syntax.File{f}, nil) // do not crash
 	want := "undeclared name: T"
 	if err == nil || !strings.Contains(err.Error(), want) {
@@ -76,7 +74,7 @@ var (
 			}
 		case *syntax.Name:
 			if x.Value == "nil" {
-				want = NewInterfaceType(nil, nil) // interface{}
+				want = NewInterfaceType(nil, nil) // interface{} (for now, go/types types this as "untyped nil")
 			}
 		}
 		if want != nil && !Identical(tv.Type, want) {
@@ -387,9 +385,6 @@ func TestIssue28005(t *testing.T) {
 			t.Fatal("object X not found")
 		}
 		iface := obj.Type().Underlying().(*Interface) // object X must be an interface
-		if iface == nil {
-			t.Fatalf("%s is not an interface", obj)
-		}
 
 		// Each iface method m is embedded; and m's receiver base type name
 		// must match the method's name per the choice in the source file.
@@ -529,22 +524,22 @@ func TestIssue34921(t *testing.T) {
 
 func TestIssue43088(t *testing.T) {
 	// type T1 struct {
-	//         x T2
+	//         _ T2
 	// }
 	//
 	// type T2 struct {
-	//         x struct {
-	//                 x T2
+	//         _ struct {
+	//                 _ T2
 	//         }
 	// }
 	n1 := NewTypeName(syntax.Pos{}, nil, "T1", nil)
 	T1 := NewNamed(n1, nil, nil)
 	n2 := NewTypeName(syntax.Pos{}, nil, "T2", nil)
 	T2 := NewNamed(n2, nil, nil)
-	s1 := NewStruct([]*Var{NewField(syntax.Pos{}, nil, "x", T2, false)}, nil)
+	s1 := NewStruct([]*Var{NewField(syntax.Pos{}, nil, "_", T2, false)}, nil)
 	T1.SetUnderlying(s1)
-	s2 := NewStruct([]*Var{NewField(syntax.Pos{}, nil, "x", T2, false)}, nil)
-	s3 := NewStruct([]*Var{NewField(syntax.Pos{}, nil, "x", s2, false)}, nil)
+	s2 := NewStruct([]*Var{NewField(syntax.Pos{}, nil, "_", T2, false)}, nil)
+	s3 := NewStruct([]*Var{NewField(syntax.Pos{}, nil, "_", s2, false)}, nil)
 	T2.SetUnderlying(s3)
 
 	// These calls must terminate (no endless recursion).
-- 
GitLab


From 5a0e4fc4e7188fb36e64a7d7d25bab943f081811 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Fri, 19 Feb 2021 20:00:33 -0800
Subject: [PATCH 0765/2400] cmd/compile/internal/types2: review of
 conversions.go

The changes between (equivalent, and reviewed) go/types/conversions.go
and conversions.go can be seen by comparing patchset 1 and 2. The actual
change is just removing the "// UNREVIEWED" marker.

Change-Id: I86d20d8100ec29fe3be996b975c9b4aff01be85e
Reviewed-on: https://go-review.googlesource.com/c/go/+/294509
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/conversions.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/conversions.go b/src/cmd/compile/internal/types2/conversions.go
index dc0621919e..d04ccec411 100644
--- a/src/cmd/compile/internal/types2/conversions.go
+++ b/src/cmd/compile/internal/types2/conversions.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2012 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.
-- 
GitLab


From a2e150c7cded1367fb092e87abb37ce2a1673d11 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 22 Feb 2021 17:02:46 -0800
Subject: [PATCH 0766/2400] go/types, cmd/compile/internal/types2: use regular
 type printing for unsafe.Pointer

Type string printing special-cased printing of unsafe.Pointer because
it's a built-in type; yet it's declared in a package like any other
imported or used-defined type (unlike built-in types such as int).

Use the same mechanism for printing unsafe.Pointer like any other
(non-basic) type. This will make it possible to use the package
Qualifier if so desired.

Fixes #44515.

Change-Id: I0dd1026f850737ecfc4bb99135cfb8e3c18be9e7
Reviewed-on: https://go-review.googlesource.com/c/go/+/295271
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 .../compile/internal/types2/issues_test.go    | 22 +++++++++++++++++++
 src/cmd/compile/internal/types2/typestring.go | 10 +++++++--
 src/go/types/issues_test.go                   | 22 +++++++++++++++++++
 src/go/types/typestring.go                    | 11 ++++++++--
 4 files changed, 61 insertions(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/types2/issues_test.go b/src/cmd/compile/internal/types2/issues_test.go
index a36b832f04..e1f5c92fc4 100644
--- a/src/cmd/compile/internal/types2/issues_test.go
+++ b/src/cmd/compile/internal/types2/issues_test.go
@@ -546,3 +546,25 @@ func TestIssue43088(t *testing.T) {
 	Comparable(T1)
 	Comparable(T2)
 }
+
+func TestIssue44515(t *testing.T) {
+	typ := Unsafe.Scope().Lookup("Pointer").Type()
+
+	got := TypeString(typ, nil)
+	want := "unsafe.Pointer"
+	if got != want {
+		t.Errorf("got %q; want %q", got, want)
+	}
+
+	qf := func(pkg *Package) string {
+		if pkg == Unsafe {
+			return "foo"
+		}
+		return ""
+	}
+	got = TypeString(typ, qf)
+	want = "foo.Pointer"
+	if got != want {
+		t.Errorf("got %q; want %q", got, want)
+	}
+}
diff --git a/src/cmd/compile/internal/types2/typestring.go b/src/cmd/compile/internal/types2/typestring.go
index af44624d2c..40016697b7 100644
--- a/src/cmd/compile/internal/types2/typestring.go
+++ b/src/cmd/compile/internal/types2/typestring.go
@@ -98,9 +98,15 @@ func writeType(buf *bytes.Buffer, typ Type, qf Qualifier, visited []Type) {
 		buf.WriteString("<nil>")
 
 	case *Basic:
-		if t.kind == UnsafePointer {
-			buf.WriteString("unsafe.")
+		// exported basic types go into package unsafe
+		// (currently this is just unsafe.Pointer)
+		if isExported(t.name) {
+			if obj, _ := Unsafe.scope.Lookup(t.name).(*TypeName); obj != nil {
+				writeTypeName(buf, obj, qf)
+				break
+			}
 		}
+
 		if gcCompatibilityMode {
 			// forget the alias names
 			switch t.kind {
diff --git a/src/go/types/issues_test.go b/src/go/types/issues_test.go
index 34850eb034..9ed2934c74 100644
--- a/src/go/types/issues_test.go
+++ b/src/go/types/issues_test.go
@@ -549,3 +549,25 @@ func TestIssue43088(t *testing.T) {
 	Comparable(T1)
 	Comparable(T2)
 }
+
+func TestIssue44515(t *testing.T) {
+	typ := Unsafe.Scope().Lookup("Pointer").Type()
+
+	got := TypeString(typ, nil)
+	want := "unsafe.Pointer"
+	if got != want {
+		t.Errorf("got %q; want %q", got, want)
+	}
+
+	qf := func(pkg *Package) string {
+		if pkg == Unsafe {
+			return "foo"
+		}
+		return ""
+	}
+	got = TypeString(typ, qf)
+	want = "foo.Pointer"
+	if got != want {
+		t.Errorf("got %q; want %q", got, want)
+	}
+}
diff --git a/src/go/types/typestring.go b/src/go/types/typestring.go
index 4697bd31e6..a0caded160 100644
--- a/src/go/types/typestring.go
+++ b/src/go/types/typestring.go
@@ -9,6 +9,7 @@ package types
 import (
 	"bytes"
 	"fmt"
+	"go/token"
 	"unicode/utf8"
 )
 
@@ -98,9 +99,15 @@ func writeType(buf *bytes.Buffer, typ Type, qf Qualifier, visited []Type) {
 		buf.WriteString("<nil>")
 
 	case *Basic:
-		if t.kind == UnsafePointer {
-			buf.WriteString("unsafe.")
+		// exported basic types go into package unsafe
+		// (currently this is just unsafe.Pointer)
+		if token.IsExported(t.name) {
+			if obj, _ := Unsafe.scope.Lookup(t.name).(*TypeName); obj != nil {
+				writeTypeName(buf, obj, qf)
+				break
+			}
 		}
+
 		if gcCompatibilityMode {
 			// forget the alias names
 			switch t.kind {
-- 
GitLab


From 975ba6e2b2547e0c4065a09644686723704283e1 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Fri, 27 Nov 2020 11:00:29 +0700
Subject: [PATCH 0767/2400] cmd/compile: mark OpSB, OpSP as poor statement Op

So that would make them last choice for a statement boundary.

This is follow up of CL 273506.

Change-Id: I0203aa0e0d95d538064c2113143c85c4fbb1e65e
Reviewed-on: https://go-review.googlesource.com/c/go/+/273666
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/numberlines.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ssa/numberlines.go b/src/cmd/compile/internal/ssa/numberlines.go
index 2a9c8e4f32..54a158ff87 100644
--- a/src/cmd/compile/internal/ssa/numberlines.go
+++ b/src/cmd/compile/internal/ssa/numberlines.go
@@ -16,7 +16,7 @@ func isPoorStatementOp(op Op) bool {
 	// so that a debugger-user sees the stop before the panic, and can examine the value.
 	case OpAddr, OpLocalAddr, OpOffPtr, OpStructSelect, OpPhi, OpITab, OpIData,
 		OpIMake, OpStringMake, OpSliceMake, OpStructMake0, OpStructMake1, OpStructMake2, OpStructMake3, OpStructMake4,
-		OpConstBool, OpConst8, OpConst16, OpConst32, OpConst64, OpConst32F, OpConst64F:
+		OpConstBool, OpConst8, OpConst16, OpConst32, OpConst64, OpConst32F, OpConst64F, OpSB, OpSP:
 		return true
 	}
 	return false
-- 
GitLab


From 6a40dd05d833b2bd78eb68ac67d7e860edff6878 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Fri, 19 Feb 2021 20:06:24 -0800
Subject: [PATCH 0768/2400] cmd/compile/internal/types2: review of sanitize.go

Remove the "// UNREVIEWED" marker and add guards (as in go/types)
to prevent data races. To see the added guards, see compare patch
sets 3 and 4. The equivalent changes for go/types were done in
https://golang.org/cl/294411.

Change-Id: Ibef07eaae400bd32bff32b102cc743580290d135
Reviewed-on: https://go-review.googlesource.com/c/go/+/294510
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/sanitize.go | 87 ++++++++++++++++-----
 1 file changed, 66 insertions(+), 21 deletions(-)

diff --git a/src/cmd/compile/internal/types2/sanitize.go b/src/cmd/compile/internal/types2/sanitize.go
index bac569416b..cd1719c8c0 100644
--- a/src/cmd/compile/internal/types2/sanitize.go
+++ b/src/cmd/compile/internal/types2/sanitize.go
@@ -1,10 +1,16 @@
-// UNREVIEWED
 // Copyright 2020 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 types2
 
+// sanitizeInfo walks the types contained in info to ensure that all instances
+// are expanded.
+//
+// This includes some objects that may be shared across concurrent
+// type-checking passes (such as those in the universe scope), so we are
+// careful here not to write types that are already sanitized. This avoids a
+// data race as any shared types should already be sanitized.
 func sanitizeInfo(info *Info) {
 	var s sanitizer = make(map[Type]Type)
 
@@ -12,27 +18,42 @@ func sanitizeInfo(info *Info) {
 	// If modified, they must be assigned back.
 
 	for e, tv := range info.Types {
-		tv.Type = s.typ(tv.Type)
-		info.Types[e] = tv
+		if typ := s.typ(tv.Type); typ != tv.Type {
+			tv.Type = typ
+			info.Types[e] = tv
+		}
 	}
 
 	for e, inf := range info.Inferred {
+		changed := false
 		for i, targ := range inf.Targs {
-			inf.Targs[i] = s.typ(targ)
+			if typ := s.typ(targ); typ != targ {
+				inf.Targs[i] = typ
+				changed = true
+			}
+		}
+		if typ := s.typ(inf.Sig); typ != inf.Sig {
+			inf.Sig = typ.(*Signature)
+			changed = true
+		}
+		if changed {
+			info.Inferred[e] = inf
 		}
-		inf.Sig = s.typ(inf.Sig).(*Signature)
-		info.Inferred[e] = inf
 	}
 
 	for _, obj := range info.Defs {
 		if obj != nil {
-			obj.setType(s.typ(obj.Type()))
+			if typ := s.typ(obj.Type()); typ != obj.Type() {
+				obj.setType(typ)
+			}
 		}
 	}
 
 	for _, obj := range info.Uses {
 		if obj != nil {
-			obj.setType(s.typ(obj.Type()))
+			if typ := s.typ(obj.Type()); typ != obj.Type() {
+				obj.setType(typ)
+			}
 		}
 	}
 
@@ -56,16 +77,22 @@ func (s sanitizer) typ(typ Type) Type {
 		// nothing to do
 
 	case *Array:
-		t.elem = s.typ(t.elem)
+		if elem := s.typ(t.elem); elem != t.elem {
+			t.elem = elem
+		}
 
 	case *Slice:
-		t.elem = s.typ(t.elem)
+		if elem := s.typ(t.elem); elem != t.elem {
+			t.elem = elem
+		}
 
 	case *Struct:
 		s.varList(t.fields)
 
 	case *Pointer:
-		t.base = s.typ(t.base)
+		if base := s.typ(t.base); base != t.base {
+			t.base = base
+		}
 
 	case *Tuple:
 		s.tuple(t)
@@ -86,27 +113,39 @@ func (s sanitizer) typ(typ Type) Type {
 		s.typ(t.allTypes)
 
 	case *Map:
-		t.key = s.typ(t.key)
-		t.elem = s.typ(t.elem)
+		if key := s.typ(t.key); key != t.key {
+			t.key = key
+		}
+		if elem := s.typ(t.elem); elem != t.elem {
+			t.elem = elem
+		}
 
 	case *Chan:
-		t.elem = s.typ(t.elem)
+		if elem := s.typ(t.elem); elem != t.elem {
+			t.elem = elem
+		}
 
 	case *Named:
-		t.orig = s.typ(t.orig)
-		t.underlying = s.typ(t.underlying)
+		if orig := s.typ(t.orig); orig != t.orig {
+			t.orig = orig
+		}
+		if under := s.typ(t.underlying); under != t.underlying {
+			t.underlying = under
+		}
 		s.typeList(t.targs)
 		s.funcList(t.methods)
 
 	case *TypeParam:
-		t.bound = s.typ(t.bound)
+		if bound := s.typ(t.bound); bound != t.bound {
+			t.bound = bound
+		}
 
 	case *instance:
 		typ = t.expand()
 		s[t] = typ
 
 	default:
-		unimplemented()
+		panic("unimplemented")
 	}
 
 	return typ
@@ -114,7 +153,9 @@ func (s sanitizer) typ(typ Type) Type {
 
 func (s sanitizer) var_(v *Var) {
 	if v != nil {
-		v.typ = s.typ(v.typ)
+		if typ := s.typ(v.typ); typ != v.typ {
+			v.typ = typ
+		}
 	}
 }
 
@@ -132,7 +173,9 @@ func (s sanitizer) tuple(t *Tuple) {
 
 func (s sanitizer) func_(f *Func) {
 	if f != nil {
-		f.typ = s.typ(f.typ)
+		if typ := s.typ(f.typ); typ != f.typ {
+			f.typ = typ
+		}
 	}
 }
 
@@ -144,6 +187,8 @@ func (s sanitizer) funcList(list []*Func) {
 
 func (s sanitizer) typeList(list []Type) {
 	for i, t := range list {
-		list[i] = s.typ(t)
+		if typ := s.typ(t); typ != t {
+			list[i] = typ
+		}
 	}
 }
-- 
GitLab


From 5e804ba17da12f53c0d66c1ce1e0e7845feb7f69 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Sat, 28 Nov 2020 02:46:00 +0700
Subject: [PATCH 0769/2400] cmd/compile: use transitive relations for slice
 len/cap in poset

Currently, we keep track of slice len by mapping from slice ID to
len/cap SSA value. However, slice len/cap can have multiple SSA values,
so when updating fact table for slice len/cap, we only update in one
place.

Instead, we can take advantage of the transitive relations provided by
poset. So all duplicated slice lens are set as equal to one another.
When updating fact table for one, that fact will be reflected to all
others. The same mechanism is applied for slice cap.

Removes 15 bounds checks from std/cmd.

Fixes #42603

Change-Id: I32c07968824cc33765b1e441b3ae2c4b5f5997c3
Reviewed-on: https://go-review.googlesource.com/c/go/+/273670
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/ssa/prove.go | 16 ++++++++++++++--
 test/prove.go                         | 16 ++++++++++++++++
 2 files changed, 30 insertions(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/prove.go b/src/cmd/compile/internal/ssa/prove.go
index 8a2e7c09bc..bcfdfc13f0 100644
--- a/src/cmd/compile/internal/ssa/prove.go
+++ b/src/cmd/compile/internal/ssa/prove.go
@@ -778,7 +778,14 @@ func prove(f *Func) {
 				if ft.lens == nil {
 					ft.lens = map[ID]*Value{}
 				}
-				ft.lens[v.Args[0].ID] = v
+				// Set all len Values for the same slice as equal in the poset.
+				// The poset handles transitive relations, so Values related to
+				// any OpSliceLen for this slice will be correctly related to others.
+				if l, ok := ft.lens[v.Args[0].ID]; ok {
+					ft.update(b, v, l, signed, eq)
+				} else {
+					ft.lens[v.Args[0].ID] = v
+				}
 				ft.update(b, v, ft.zero, signed, gt|eq)
 				if v.Args[0].Op == OpSliceMake {
 					if lensVars == nil {
@@ -790,7 +797,12 @@ func prove(f *Func) {
 				if ft.caps == nil {
 					ft.caps = map[ID]*Value{}
 				}
-				ft.caps[v.Args[0].ID] = v
+				// Same as case OpSliceLen above, but for slice cap.
+				if c, ok := ft.caps[v.Args[0].ID]; ok {
+					ft.update(b, v, c, signed, eq)
+				} else {
+					ft.caps[v.Args[0].ID] = v
+				}
 				ft.update(b, v, ft.zero, signed, gt|eq)
 				if v.Args[0].Op == OpSliceMake {
 					if lensVars == nil {
diff --git a/test/prove.go b/test/prove.go
index d37021d283..af9c06a6f7 100644
--- a/test/prove.go
+++ b/test/prove.go
@@ -629,6 +629,22 @@ func trans3(a, b []int, i int) {
 	_ = b[i] // ERROR "Proved IsInBounds$"
 }
 
+func trans4(b []byte, x int) {
+	// Issue #42603: slice len/cap transitive relations.
+	switch x {
+	case 0:
+		if len(b) < 20 {
+			return
+		}
+		_ = b[:2] // ERROR "Proved IsSliceInBounds$"
+	case 1:
+		if len(b) < 40 {
+			return
+		}
+		_ = b[:2] // ERROR "Proved IsSliceInBounds$"
+	}
+}
+
 // Derived from nat.cmp
 func natcmp(x, y []uint) (r int) {
 	m := len(x)
-- 
GitLab


From 4048491234203e1ee803d489d11a02c90b14596a Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Wed, 17 Feb 2021 11:36:58 +0700
Subject: [PATCH 0770/2400] cmd/compile,runtime: make selectnbrecv return two
 values

The only different between selectnbrecv and selectnbrecv2 is the later
set the input pointer value by second return value from chanrecv.

So by making selectnbrecv return two values from chanrecv, we can get
rid of selectnbrecv2, the compiler can now call only selectnbrecv and
generate simpler code.

Change-Id: Ifaf6cf1314c4f47b06ed9606b1578319be808507
Reviewed-on: https://go-review.googlesource.com/c/go/+/292890
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/typecheck/builtin.go |  2 +-
 .../internal/typecheck/builtin/runtime.go     |  2 +-
 src/cmd/compile/internal/walk/select.go       | 20 +++++--------
 src/runtime/chan.go                           | 30 ++-----------------
 4 files changed, 13 insertions(+), 41 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/builtin.go b/src/cmd/compile/internal/typecheck/builtin.go
index f9a4f6aef4..17393f801c 100644
--- a/src/cmd/compile/internal/typecheck/builtin.go
+++ b/src/cmd/compile/internal/typecheck/builtin.go
@@ -316,7 +316,7 @@ func runtimeTypes() []*types.Type {
 	typs[92] = newSig(params(typs[1], typs[3]), nil)
 	typs[93] = newSig(params(typs[1], typs[3], typs[15], typs[3], typs[15]), params(typs[15]))
 	typs[94] = newSig(params(typs[87], typs[3]), params(typs[6]))
-	typs[95] = newSig(params(typs[3], typs[84]), params(typs[6]))
+	typs[95] = newSig(params(typs[3], typs[84]), params(typs[6], typs[6]))
 	typs[96] = types.NewPtr(typs[6])
 	typs[97] = newSig(params(typs[3], typs[96], typs[84]), params(typs[6]))
 	typs[98] = newSig(params(typs[63]), nil)
diff --git a/src/cmd/compile/internal/typecheck/builtin/runtime.go b/src/cmd/compile/internal/typecheck/builtin/runtime.go
index acb69c7b28..77a6fdb026 100644
--- a/src/cmd/compile/internal/typecheck/builtin/runtime.go
+++ b/src/cmd/compile/internal/typecheck/builtin/runtime.go
@@ -166,7 +166,7 @@ func typedmemclr(typ *byte, dst *any)
 func typedslicecopy(typ *byte, dstPtr *any, dstLen int, srcPtr *any, srcLen int) int
 
 func selectnbsend(hchan chan<- any, elem *any) bool
-func selectnbrecv(elem *any, hchan <-chan any) bool
+func selectnbrecv(elem *any, hchan <-chan any) (bool, bool)
 func selectnbrecv2(elem *any, received *bool, hchan <-chan any) bool
 
 func selectsetpc(pc *uintptr)
diff --git a/src/cmd/compile/internal/walk/select.go b/src/cmd/compile/internal/walk/select.go
index 873be289dc..d2b67ddf55 100644
--- a/src/cmd/compile/internal/walk/select.go
+++ b/src/cmd/compile/internal/walk/select.go
@@ -106,7 +106,7 @@ func walkSelectCases(cases []*ir.CommClause) []ir.Node {
 		ir.SetPos(n)
 		r := ir.NewIfStmt(base.Pos, nil, nil, nil)
 		*r.PtrInit() = cas.Init()
-		var call ir.Node
+		var cond ir.Node
 		switch n.Op() {
 		default:
 			base.Fatalf("select %v", n.Op())
@@ -115,7 +115,7 @@ func walkSelectCases(cases []*ir.CommClause) []ir.Node {
 			// if selectnbsend(c, v) { body } else { default body }
 			n := n.(*ir.SendStmt)
 			ch := n.Chan
-			call = mkcall1(chanfn("selectnbsend", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), ch, n.Value)
+			cond = mkcall1(chanfn("selectnbsend", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), ch, n.Value)
 
 		case ir.OSELRECV2:
 			n := n.(*ir.AssignListStmt)
@@ -125,18 +125,14 @@ func walkSelectCases(cases []*ir.CommClause) []ir.Node {
 			if ir.IsBlank(elem) {
 				elem = typecheck.NodNil()
 			}
-			if ir.IsBlank(n.Lhs[1]) {
-				// if selectnbrecv(&v, c) { body } else { default body }
-				call = mkcall1(chanfn("selectnbrecv", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), elem, ch)
-			} else {
-				// TODO(cuonglm): make this use selectnbrecv()
-				// if selectnbrecv2(&v, &received, c) { body } else { default body }
-				receivedp := typecheck.Expr(typecheck.NodAddr(n.Lhs[1]))
-				call = mkcall1(chanfn("selectnbrecv2", 2, ch.Type()), types.Types[types.TBOOL], r.PtrInit(), elem, receivedp, ch)
-			}
+			cond = typecheck.Temp(types.Types[types.TBOOL])
+			fn := chanfn("selectnbrecv", 2, ch.Type())
+			call := mkcall1(fn, fn.Type().Results(), r.PtrInit(), elem, ch)
+			as := ir.NewAssignListStmt(r.Pos(), ir.OAS2, []ir.Node{cond, n.Lhs[1]}, []ir.Node{call})
+			r.PtrInit().Append(typecheck.Stmt(as))
 		}
 
-		r.Cond = typecheck.Expr(call)
+		r.Cond = typecheck.Expr(cond)
 		r.Body = cas.Body
 		r.Else = append(dflt.Init(), dflt.Body...)
 		return []ir.Node{r, ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)}
diff --git a/src/runtime/chan.go b/src/runtime/chan.go
index ba56e2cc40..f2a75b30f4 100644
--- a/src/runtime/chan.go
+++ b/src/runtime/chan.go
@@ -687,28 +687,6 @@ func selectnbsend(c *hchan, elem unsafe.Pointer) (selected bool) {
 	return chansend(c, elem, false, getcallerpc())
 }
 
-// compiler implements
-//
-//	select {
-//	case v = <-c:
-//		... foo
-//	default:
-//		... bar
-//	}
-//
-// as
-//
-//	if selectnbrecv(&v, c) {
-//		... foo
-//	} else {
-//		... bar
-//	}
-//
-func selectnbrecv(elem unsafe.Pointer, c *hchan) (selected bool) {
-	selected, _ = chanrecv(c, elem, false)
-	return
-}
-
 // compiler implements
 //
 //	select {
@@ -720,16 +698,14 @@ func selectnbrecv(elem unsafe.Pointer, c *hchan) (selected bool) {
 //
 // as
 //
-//	if c != nil && selectnbrecv2(&v, &ok, c) {
+//	if selected, ok = selectnbrecv(&v, c); selected {
 //		... foo
 //	} else {
 //		... bar
 //	}
 //
-func selectnbrecv2(elem unsafe.Pointer, received *bool, c *hchan) (selected bool) {
-	// TODO(khr): just return 2 values from this function, now that it is in Go.
-	selected, *received = chanrecv(c, elem, false)
-	return
+func selectnbrecv(elem unsafe.Pointer, c *hchan) (selected, received bool) {
+	return chanrecv(c, elem, false)
 }
 
 //go:linkname reflect_chansend reflect.chansend
-- 
GitLab


From 86deb459de6a309503aa445a7d686bd139354e5e Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Wed, 17 Feb 2021 11:38:14 +0700
Subject: [PATCH 0771/2400] cmd/compile: remove selectnbrecv2

Previous CL did remove selectnbrecv2 in runtime, the compiler now only
call selectnbrecv, so remove this. Make this as separated CL because it
adds much of noise to git stat.

Change-Id: I06e89c823c0403e9bd66f2633409c455a46d6e79
Reviewed-on: https://go-review.googlesource.com/c/go/+/292891
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/typecheck/builtin.go | 197 +++++++++---------
 .../internal/typecheck/builtin/runtime.go     |   1 -
 2 files changed, 97 insertions(+), 101 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/builtin.go b/src/cmd/compile/internal/typecheck/builtin.go
index 17393f801c..b095a014f0 100644
--- a/src/cmd/compile/internal/typecheck/builtin.go
+++ b/src/cmd/compile/internal/typecheck/builtin.go
@@ -128,76 +128,75 @@ var runtimeDecls = [...]struct {
 	{"typedslicecopy", funcTag, 93},
 	{"selectnbsend", funcTag, 94},
 	{"selectnbrecv", funcTag, 95},
-	{"selectnbrecv2", funcTag, 97},
-	{"selectsetpc", funcTag, 98},
-	{"selectgo", funcTag, 99},
+	{"selectsetpc", funcTag, 96},
+	{"selectgo", funcTag, 97},
 	{"block", funcTag, 9},
-	{"makeslice", funcTag, 100},
-	{"makeslice64", funcTag, 101},
-	{"makeslicecopy", funcTag, 102},
-	{"growslice", funcTag, 104},
-	{"memmove", funcTag, 105},
-	{"memclrNoHeapPointers", funcTag, 106},
-	{"memclrHasPointers", funcTag, 106},
-	{"memequal", funcTag, 107},
-	{"memequal0", funcTag, 108},
-	{"memequal8", funcTag, 108},
-	{"memequal16", funcTag, 108},
-	{"memequal32", funcTag, 108},
-	{"memequal64", funcTag, 108},
-	{"memequal128", funcTag, 108},
-	{"f32equal", funcTag, 109},
-	{"f64equal", funcTag, 109},
-	{"c64equal", funcTag, 109},
-	{"c128equal", funcTag, 109},
-	{"strequal", funcTag, 109},
-	{"interequal", funcTag, 109},
-	{"nilinterequal", funcTag, 109},
-	{"memhash", funcTag, 110},
-	{"memhash0", funcTag, 111},
-	{"memhash8", funcTag, 111},
-	{"memhash16", funcTag, 111},
-	{"memhash32", funcTag, 111},
-	{"memhash64", funcTag, 111},
-	{"memhash128", funcTag, 111},
-	{"f32hash", funcTag, 111},
-	{"f64hash", funcTag, 111},
-	{"c64hash", funcTag, 111},
-	{"c128hash", funcTag, 111},
-	{"strhash", funcTag, 111},
-	{"interhash", funcTag, 111},
-	{"nilinterhash", funcTag, 111},
-	{"int64div", funcTag, 112},
-	{"uint64div", funcTag, 113},
-	{"int64mod", funcTag, 112},
-	{"uint64mod", funcTag, 113},
-	{"float64toint64", funcTag, 114},
-	{"float64touint64", funcTag, 115},
-	{"float64touint32", funcTag, 116},
-	{"int64tofloat64", funcTag, 117},
-	{"uint64tofloat64", funcTag, 118},
-	{"uint32tofloat64", funcTag, 119},
-	{"complex128div", funcTag, 120},
+	{"makeslice", funcTag, 98},
+	{"makeslice64", funcTag, 99},
+	{"makeslicecopy", funcTag, 100},
+	{"growslice", funcTag, 102},
+	{"memmove", funcTag, 103},
+	{"memclrNoHeapPointers", funcTag, 104},
+	{"memclrHasPointers", funcTag, 104},
+	{"memequal", funcTag, 105},
+	{"memequal0", funcTag, 106},
+	{"memequal8", funcTag, 106},
+	{"memequal16", funcTag, 106},
+	{"memequal32", funcTag, 106},
+	{"memequal64", funcTag, 106},
+	{"memequal128", funcTag, 106},
+	{"f32equal", funcTag, 107},
+	{"f64equal", funcTag, 107},
+	{"c64equal", funcTag, 107},
+	{"c128equal", funcTag, 107},
+	{"strequal", funcTag, 107},
+	{"interequal", funcTag, 107},
+	{"nilinterequal", funcTag, 107},
+	{"memhash", funcTag, 108},
+	{"memhash0", funcTag, 109},
+	{"memhash8", funcTag, 109},
+	{"memhash16", funcTag, 109},
+	{"memhash32", funcTag, 109},
+	{"memhash64", funcTag, 109},
+	{"memhash128", funcTag, 109},
+	{"f32hash", funcTag, 109},
+	{"f64hash", funcTag, 109},
+	{"c64hash", funcTag, 109},
+	{"c128hash", funcTag, 109},
+	{"strhash", funcTag, 109},
+	{"interhash", funcTag, 109},
+	{"nilinterhash", funcTag, 109},
+	{"int64div", funcTag, 110},
+	{"uint64div", funcTag, 111},
+	{"int64mod", funcTag, 110},
+	{"uint64mod", funcTag, 111},
+	{"float64toint64", funcTag, 112},
+	{"float64touint64", funcTag, 113},
+	{"float64touint32", funcTag, 114},
+	{"int64tofloat64", funcTag, 115},
+	{"uint64tofloat64", funcTag, 116},
+	{"uint32tofloat64", funcTag, 117},
+	{"complex128div", funcTag, 118},
 	{"racefuncenter", funcTag, 31},
 	{"racefuncenterfp", funcTag, 9},
 	{"racefuncexit", funcTag, 9},
 	{"raceread", funcTag, 31},
 	{"racewrite", funcTag, 31},
-	{"racereadrange", funcTag, 121},
-	{"racewriterange", funcTag, 121},
-	{"msanread", funcTag, 121},
-	{"msanwrite", funcTag, 121},
-	{"msanmove", funcTag, 122},
-	{"checkptrAlignment", funcTag, 123},
-	{"checkptrArithmetic", funcTag, 125},
-	{"libfuzzerTraceCmp1", funcTag, 127},
-	{"libfuzzerTraceCmp2", funcTag, 129},
-	{"libfuzzerTraceCmp4", funcTag, 130},
-	{"libfuzzerTraceCmp8", funcTag, 131},
-	{"libfuzzerTraceConstCmp1", funcTag, 127},
-	{"libfuzzerTraceConstCmp2", funcTag, 129},
-	{"libfuzzerTraceConstCmp4", funcTag, 130},
-	{"libfuzzerTraceConstCmp8", funcTag, 131},
+	{"racereadrange", funcTag, 119},
+	{"racewriterange", funcTag, 119},
+	{"msanread", funcTag, 119},
+	{"msanwrite", funcTag, 119},
+	{"msanmove", funcTag, 120},
+	{"checkptrAlignment", funcTag, 121},
+	{"checkptrArithmetic", funcTag, 123},
+	{"libfuzzerTraceCmp1", funcTag, 125},
+	{"libfuzzerTraceCmp2", funcTag, 127},
+	{"libfuzzerTraceCmp4", funcTag, 128},
+	{"libfuzzerTraceCmp8", funcTag, 129},
+	{"libfuzzerTraceConstCmp1", funcTag, 125},
+	{"libfuzzerTraceConstCmp2", funcTag, 127},
+	{"libfuzzerTraceConstCmp4", funcTag, 128},
+	{"libfuzzerTraceConstCmp8", funcTag, 129},
 	{"x86HasPOPCNT", varTag, 6},
 	{"x86HasSSE41", varTag, 6},
 	{"x86HasFMA", varTag, 6},
@@ -220,7 +219,7 @@ func params(tlist ...*types.Type) []*types.Field {
 }
 
 func runtimeTypes() []*types.Type {
-	var typs [132]*types.Type
+	var typs [130]*types.Type
 	typs[0] = types.ByteType
 	typs[1] = types.NewPtr(typs[0])
 	typs[2] = types.Types[types.TANY]
@@ -317,41 +316,39 @@ func runtimeTypes() []*types.Type {
 	typs[93] = newSig(params(typs[1], typs[3], typs[15], typs[3], typs[15]), params(typs[15]))
 	typs[94] = newSig(params(typs[87], typs[3]), params(typs[6]))
 	typs[95] = newSig(params(typs[3], typs[84]), params(typs[6], typs[6]))
-	typs[96] = types.NewPtr(typs[6])
-	typs[97] = newSig(params(typs[3], typs[96], typs[84]), params(typs[6]))
-	typs[98] = newSig(params(typs[63]), nil)
-	typs[99] = newSig(params(typs[1], typs[1], typs[63], typs[15], typs[15], typs[6]), params(typs[15], typs[6]))
-	typs[100] = newSig(params(typs[1], typs[15], typs[15]), params(typs[7]))
-	typs[101] = newSig(params(typs[1], typs[22], typs[22]), params(typs[7]))
-	typs[102] = newSig(params(typs[1], typs[15], typs[15], typs[7]), params(typs[7]))
-	typs[103] = types.NewSlice(typs[2])
-	typs[104] = newSig(params(typs[1], typs[103], typs[15]), params(typs[103]))
-	typs[105] = newSig(params(typs[3], typs[3], typs[5]), nil)
-	typs[106] = newSig(params(typs[7], typs[5]), nil)
-	typs[107] = newSig(params(typs[3], typs[3], typs[5]), params(typs[6]))
-	typs[108] = newSig(params(typs[3], typs[3]), params(typs[6]))
-	typs[109] = newSig(params(typs[7], typs[7]), params(typs[6]))
-	typs[110] = newSig(params(typs[7], typs[5], typs[5]), params(typs[5]))
-	typs[111] = newSig(params(typs[7], typs[5]), params(typs[5]))
-	typs[112] = newSig(params(typs[22], typs[22]), params(typs[22]))
-	typs[113] = newSig(params(typs[24], typs[24]), params(typs[24]))
-	typs[114] = newSig(params(typs[20]), params(typs[22]))
-	typs[115] = newSig(params(typs[20]), params(typs[24]))
-	typs[116] = newSig(params(typs[20]), params(typs[65]))
-	typs[117] = newSig(params(typs[22]), params(typs[20]))
-	typs[118] = newSig(params(typs[24]), params(typs[20]))
-	typs[119] = newSig(params(typs[65]), params(typs[20]))
-	typs[120] = newSig(params(typs[26], typs[26]), params(typs[26]))
-	typs[121] = newSig(params(typs[5], typs[5]), nil)
-	typs[122] = newSig(params(typs[5], typs[5], typs[5]), nil)
-	typs[123] = newSig(params(typs[7], typs[1], typs[5]), nil)
-	typs[124] = types.NewSlice(typs[7])
-	typs[125] = newSig(params(typs[7], typs[124]), nil)
-	typs[126] = types.Types[types.TUINT8]
+	typs[96] = newSig(params(typs[63]), nil)
+	typs[97] = newSig(params(typs[1], typs[1], typs[63], typs[15], typs[15], typs[6]), params(typs[15], typs[6]))
+	typs[98] = newSig(params(typs[1], typs[15], typs[15]), params(typs[7]))
+	typs[99] = newSig(params(typs[1], typs[22], typs[22]), params(typs[7]))
+	typs[100] = newSig(params(typs[1], typs[15], typs[15], typs[7]), params(typs[7]))
+	typs[101] = types.NewSlice(typs[2])
+	typs[102] = newSig(params(typs[1], typs[101], typs[15]), params(typs[101]))
+	typs[103] = newSig(params(typs[3], typs[3], typs[5]), nil)
+	typs[104] = newSig(params(typs[7], typs[5]), nil)
+	typs[105] = newSig(params(typs[3], typs[3], typs[5]), params(typs[6]))
+	typs[106] = newSig(params(typs[3], typs[3]), params(typs[6]))
+	typs[107] = newSig(params(typs[7], typs[7]), params(typs[6]))
+	typs[108] = newSig(params(typs[7], typs[5], typs[5]), params(typs[5]))
+	typs[109] = newSig(params(typs[7], typs[5]), params(typs[5]))
+	typs[110] = newSig(params(typs[22], typs[22]), params(typs[22]))
+	typs[111] = newSig(params(typs[24], typs[24]), params(typs[24]))
+	typs[112] = newSig(params(typs[20]), params(typs[22]))
+	typs[113] = newSig(params(typs[20]), params(typs[24]))
+	typs[114] = newSig(params(typs[20]), params(typs[65]))
+	typs[115] = newSig(params(typs[22]), params(typs[20]))
+	typs[116] = newSig(params(typs[24]), params(typs[20]))
+	typs[117] = newSig(params(typs[65]), params(typs[20]))
+	typs[118] = newSig(params(typs[26], typs[26]), params(typs[26]))
+	typs[119] = newSig(params(typs[5], typs[5]), nil)
+	typs[120] = newSig(params(typs[5], typs[5], typs[5]), nil)
+	typs[121] = newSig(params(typs[7], typs[1], typs[5]), nil)
+	typs[122] = types.NewSlice(typs[7])
+	typs[123] = newSig(params(typs[7], typs[122]), nil)
+	typs[124] = types.Types[types.TUINT8]
+	typs[125] = newSig(params(typs[124], typs[124]), nil)
+	typs[126] = types.Types[types.TUINT16]
 	typs[127] = newSig(params(typs[126], typs[126]), nil)
-	typs[128] = types.Types[types.TUINT16]
-	typs[129] = newSig(params(typs[128], typs[128]), nil)
-	typs[130] = newSig(params(typs[65], typs[65]), nil)
-	typs[131] = newSig(params(typs[24], typs[24]), nil)
+	typs[128] = newSig(params(typs[65], typs[65]), nil)
+	typs[129] = newSig(params(typs[24], typs[24]), nil)
 	return typs[:]
 }
diff --git a/src/cmd/compile/internal/typecheck/builtin/runtime.go b/src/cmd/compile/internal/typecheck/builtin/runtime.go
index 77a6fdb026..ad82a9b349 100644
--- a/src/cmd/compile/internal/typecheck/builtin/runtime.go
+++ b/src/cmd/compile/internal/typecheck/builtin/runtime.go
@@ -167,7 +167,6 @@ func typedslicecopy(typ *byte, dstPtr *any, dstLen int, srcPtr *any, srcLen int)
 
 func selectnbsend(hchan chan<- any, elem *any) bool
 func selectnbrecv(elem *any, hchan <-chan any) (bool, bool)
-func selectnbrecv2(elem *any, received *bool, hchan <-chan any) bool
 
 func selectsetpc(pc *uintptr)
 func selectgo(cas0 *byte, order0 *byte, pc0 *uintptr, nsends int, nrecvs int, block bool) (int, bool)
-- 
GitLab


From e52149822b54811cedaaa87013de3fa4bc634e95 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Wed, 17 Feb 2021 15:14:21 +0700
Subject: [PATCH 0772/2400] cmd/compile: simplify assert{E,I}2I{,2} calling
 conventions

This CL rebases CL 273694 on top of master with @mdempsky's permission.

For assertE2I and assertI2I, there's no need to pass through the
interface's data pointer: it's always going to come back unmodified.

For assertE2I2 and assertI2I2, there's no need for an extra bool
result parameter: it's redundant with testing the returned interface
value for nil.

Change-Id: Ic92d4409ad381952f875d3d74b8cf11c32702fa6
Reviewed-on: https://go-review.googlesource.com/c/go/+/292892
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ssagen/ssa.go        | 23 +++++++++------
 src/cmd/compile/internal/typecheck/builtin.go | 10 +++----
 .../internal/typecheck/builtin/runtime.go     |  8 +++---
 src/runtime/iface.go                          | 28 ++++++-------------
 src/runtime/mfinal.go                         |  4 +--
 5 files changed, 34 insertions(+), 39 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 6b1ddebd32..e13ca90d33 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -6075,18 +6075,23 @@ func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Val
 		if base.Debug.TypeAssert > 0 {
 			base.WarnfAt(n.Pos(), "type assertion not inlined")
 		}
-		if n.X.Type().IsEmptyInterface() {
-			if commaok {
-				call := s.rtcall(ir.Syms.AssertE2I2, true, []*types.Type{n.Type(), types.Types[types.TBOOL]}, target, iface)
-				return call[0], call[1]
+		if !commaok {
+			fn := ir.Syms.AssertI2I
+			if n.X.Type().IsEmptyInterface() {
+				fn = ir.Syms.AssertE2I
 			}
-			return s.rtcall(ir.Syms.AssertE2I, true, []*types.Type{n.Type()}, target, iface)[0], nil
+			data := s.newValue1(ssa.OpIData, types.Types[types.TUNSAFEPTR], iface)
+			tab := s.newValue1(ssa.OpITab, byteptr, iface)
+			tab = s.rtcall(fn, true, []*types.Type{byteptr}, target, tab)[0]
+			return s.newValue2(ssa.OpIMake, n.Type(), tab, data), nil
 		}
-		if commaok {
-			call := s.rtcall(ir.Syms.AssertI2I2, true, []*types.Type{n.Type(), types.Types[types.TBOOL]}, target, iface)
-			return call[0], call[1]
+		fn := ir.Syms.AssertI2I2
+		if n.X.Type().IsEmptyInterface() {
+			fn = ir.Syms.AssertE2I2
 		}
-		return s.rtcall(ir.Syms.AssertI2I, true, []*types.Type{n.Type()}, target, iface)[0], nil
+		res = s.rtcall(fn, true, []*types.Type{n.Type()}, target, iface)[0]
+		resok = s.newValue2(ssa.OpNeqInter, types.Types[types.TBOOL], res, s.constInterface(n.Type()))
+		return
 	}
 
 	if base.Debug.TypeAssert > 0 {
diff --git a/src/cmd/compile/internal/typecheck/builtin.go b/src/cmd/compile/internal/typecheck/builtin.go
index b095a014f0..3c7776d9ae 100644
--- a/src/cmd/compile/internal/typecheck/builtin.go
+++ b/src/cmd/compile/internal/typecheck/builtin.go
@@ -80,10 +80,10 @@ var runtimeDecls = [...]struct {
 	{"convT2Enoptr", funcTag, 59},
 	{"convT2I", funcTag, 59},
 	{"convT2Inoptr", funcTag, 59},
-	{"assertE2I", funcTag, 57},
-	{"assertE2I2", funcTag, 60},
-	{"assertI2I", funcTag, 57},
-	{"assertI2I2", funcTag, 60},
+	{"assertE2I", funcTag, 60},
+	{"assertE2I2", funcTag, 57},
+	{"assertI2I", funcTag, 60},
+	{"assertI2I2", funcTag, 57},
 	{"panicdottypeE", funcTag, 61},
 	{"panicdottypeI", funcTag, 61},
 	{"panicnildottype", funcTag, 62},
@@ -280,7 +280,7 @@ func runtimeTypes() []*types.Type {
 	typs[57] = newSig(params(typs[1], typs[2]), params(typs[2]))
 	typs[58] = newSig(params(typs[2]), params(typs[7]))
 	typs[59] = newSig(params(typs[1], typs[3]), params(typs[2]))
-	typs[60] = newSig(params(typs[1], typs[2]), params(typs[2], typs[6]))
+	typs[60] = newSig(params(typs[1], typs[1]), params(typs[1]))
 	typs[61] = newSig(params(typs[1], typs[1], typs[1]), nil)
 	typs[62] = newSig(params(typs[1]), nil)
 	typs[63] = types.NewPtr(typs[5])
diff --git a/src/cmd/compile/internal/typecheck/builtin/runtime.go b/src/cmd/compile/internal/typecheck/builtin/runtime.go
index ad82a9b349..d5e00afcf8 100644
--- a/src/cmd/compile/internal/typecheck/builtin/runtime.go
+++ b/src/cmd/compile/internal/typecheck/builtin/runtime.go
@@ -101,10 +101,10 @@ func convT2I(tab *byte, elem *any) (ret any)
 func convT2Inoptr(tab *byte, elem *any) (ret any)
 
 // interface type assertions x.(T)
-func assertE2I(typ *byte, iface any) (ret any)
-func assertE2I2(typ *byte, iface any) (ret any, b bool)
-func assertI2I(typ *byte, iface any) (ret any)
-func assertI2I2(typ *byte, iface any) (ret any, b bool)
+func assertE2I(inter *byte, typ *byte) *byte
+func assertE2I2(inter *byte, eface any) (ret any)
+func assertI2I(inter *byte, tab *byte) *byte
+func assertI2I2(inter *byte, iface any) (ret any)
 func panicdottypeE(have, want, iface *byte)
 func panicdottypeI(have, want, iface *byte)
 func panicnildottype(want *byte)
diff --git a/src/runtime/iface.go b/src/runtime/iface.go
index 0504b89363..02b18dabff 100644
--- a/src/runtime/iface.go
+++ b/src/runtime/iface.go
@@ -447,23 +447,18 @@ func convI2I(inter *interfacetype, i iface) (r iface) {
 	return
 }
 
-func assertI2I(inter *interfacetype, i iface) (r iface) {
-	tab := i.tab
+func assertI2I(inter *interfacetype, tab *itab) *itab {
 	if tab == nil {
 		// explicit conversions require non-nil interface value.
 		panic(&TypeAssertionError{nil, nil, &inter.typ, ""})
 	}
 	if tab.inter == inter {
-		r.tab = tab
-		r.data = i.data
-		return
+		return tab
 	}
-	r.tab = getitab(inter, tab._type, false)
-	r.data = i.data
-	return
+	return getitab(inter, tab._type, false)
 }
 
-func assertI2I2(inter *interfacetype, i iface) (r iface, b bool) {
+func assertI2I2(inter *interfacetype, i iface) (r iface) {
 	tab := i.tab
 	if tab == nil {
 		return
@@ -476,22 +471,18 @@ func assertI2I2(inter *interfacetype, i iface) (r iface, b bool) {
 	}
 	r.tab = tab
 	r.data = i.data
-	b = true
 	return
 }
 
-func assertE2I(inter *interfacetype, e eface) (r iface) {
-	t := e._type
+func assertE2I(inter *interfacetype, t *_type) *itab {
 	if t == nil {
 		// explicit conversions require non-nil interface value.
 		panic(&TypeAssertionError{nil, nil, &inter.typ, ""})
 	}
-	r.tab = getitab(inter, t, false)
-	r.data = e.data
-	return
+	return getitab(inter, t, false)
 }
 
-func assertE2I2(inter *interfacetype, e eface) (r iface, b bool) {
+func assertE2I2(inter *interfacetype, e eface) (r iface) {
 	t := e._type
 	if t == nil {
 		return
@@ -502,18 +493,17 @@ func assertE2I2(inter *interfacetype, e eface) (r iface, b bool) {
 	}
 	r.tab = tab
 	r.data = e.data
-	b = true
 	return
 }
 
 //go:linkname reflect_ifaceE2I reflect.ifaceE2I
 func reflect_ifaceE2I(inter *interfacetype, e eface, dst *iface) {
-	*dst = assertE2I(inter, e)
+	*dst = iface{assertE2I(inter, e._type), e.data}
 }
 
 //go:linkname reflectlite_ifaceE2I internal/reflectlite.ifaceE2I
 func reflectlite_ifaceE2I(inter *interfacetype, e eface, dst *iface) {
-	*dst = assertE2I(inter, e)
+	*dst = iface{assertE2I(inter, e._type), e.data}
 }
 
 func iterate_itabs(fn func(*itab)) {
diff --git a/src/runtime/mfinal.go b/src/runtime/mfinal.go
index 7d0313be12..e92ec80e3c 100644
--- a/src/runtime/mfinal.go
+++ b/src/runtime/mfinal.go
@@ -214,7 +214,7 @@ func runfinq() {
 					if len(ityp.mhdr) != 0 {
 						// convert to interface with methods
 						// this conversion is guaranteed to succeed - we checked in SetFinalizer
-						*(*iface)(frame) = assertE2I(ityp, *(*eface)(frame))
+						(*iface)(frame).tab = assertE2I(ityp, (*eface)(frame)._type)
 					}
 				default:
 					throw("bad kind in runfinq")
@@ -403,7 +403,7 @@ func SetFinalizer(obj interface{}, finalizer interface{}) {
 			// ok - satisfies empty interface
 			goto okarg
 		}
-		if _, ok := assertE2I2(ityp, *efaceOf(&obj)); ok {
+		if iface := assertE2I2(ityp, *efaceOf(&obj)); iface.tab != nil {
 			goto okarg
 		}
 	}
-- 
GitLab


From 2a18e37c4e78e26c9f1e613dfa97aaf275ea0b4d Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Wed, 17 Feb 2021 15:27:42 +0700
Subject: [PATCH 0773/2400] cmd/compile: remove backend's "scratch mem" support

This CL rebases CL 273987 on top of master with @mdempsky's permission.

The last (only?) use for this feature was 387 support, which was
removed in golang.org/cl/258957.

Change-Id: I4f79fee8d0c336c9b6082bcd5eb6ece52c032dc0
Reviewed-on: https://go-review.googlesource.com/c/go/+/292893
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ssa/config.go     |  1 -
 src/cmd/compile/internal/ssa/gen/386Ops.go | 32 ++++++-------
 src/cmd/compile/internal/ssa/gen/main.go   |  6 ---
 src/cmd/compile/internal/ssa/opGen.go      | 54 +++++++++-------------
 src/cmd/compile/internal/ssagen/pgen.go    | 10 ----
 src/cmd/compile/internal/ssagen/ssa.go     | 27 ++---------
 6 files changed, 42 insertions(+), 88 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go
index c29bc8fae6..f3a3a88a66 100644
--- a/src/cmd/compile/internal/ssa/config.go
+++ b/src/cmd/compile/internal/ssa/config.go
@@ -42,7 +42,6 @@ type Config struct {
 	useHmul        bool          // Use optimizations that need Hmul* operations
 	SoftFloat      bool          //
 	Race           bool          // race detector enabled
-	NeedsFpScratch bool          // No direct move between GP and FP register sets
 	BigEndian      bool          //
 	UseFMA         bool          // Use hardware FMA operation
 }
diff --git a/src/cmd/compile/internal/ssa/gen/386Ops.go b/src/cmd/compile/internal/ssa/gen/386Ops.go
index 737b99c371..2b7185e537 100644
--- a/src/cmd/compile/internal/ssa/gen/386Ops.go
+++ b/src/cmd/compile/internal/ssa/gen/386Ops.go
@@ -146,14 +146,14 @@ func init() {
 
 	var _386ops = []opData{
 		// fp ops
-		{name: "ADDSS", argLength: 2, reg: fp21, asm: "ADDSS", commutative: true, resultInArg0: true, usesScratch: true}, // fp32 add
-		{name: "ADDSD", argLength: 2, reg: fp21, asm: "ADDSD", commutative: true, resultInArg0: true},                    // fp64 add
-		{name: "SUBSS", argLength: 2, reg: fp21, asm: "SUBSS", resultInArg0: true, usesScratch: true},                    // fp32 sub
-		{name: "SUBSD", argLength: 2, reg: fp21, asm: "SUBSD", resultInArg0: true},                                       // fp64 sub
-		{name: "MULSS", argLength: 2, reg: fp21, asm: "MULSS", commutative: true, resultInArg0: true, usesScratch: true}, // fp32 mul
-		{name: "MULSD", argLength: 2, reg: fp21, asm: "MULSD", commutative: true, resultInArg0: true},                    // fp64 mul
-		{name: "DIVSS", argLength: 2, reg: fp21, asm: "DIVSS", resultInArg0: true, usesScratch: true},                    // fp32 div
-		{name: "DIVSD", argLength: 2, reg: fp21, asm: "DIVSD", resultInArg0: true},                                       // fp64 div
+		{name: "ADDSS", argLength: 2, reg: fp21, asm: "ADDSS", commutative: true, resultInArg0: true}, // fp32 add
+		{name: "ADDSD", argLength: 2, reg: fp21, asm: "ADDSD", commutative: true, resultInArg0: true}, // fp64 add
+		{name: "SUBSS", argLength: 2, reg: fp21, asm: "SUBSS", resultInArg0: true},                    // fp32 sub
+		{name: "SUBSD", argLength: 2, reg: fp21, asm: "SUBSD", resultInArg0: true},                    // fp64 sub
+		{name: "MULSS", argLength: 2, reg: fp21, asm: "MULSS", commutative: true, resultInArg0: true}, // fp32 mul
+		{name: "MULSD", argLength: 2, reg: fp21, asm: "MULSD", commutative: true, resultInArg0: true}, // fp64 mul
+		{name: "DIVSS", argLength: 2, reg: fp21, asm: "DIVSS", resultInArg0: true},                    // fp32 div
+		{name: "DIVSD", argLength: 2, reg: fp21, asm: "DIVSD", resultInArg0: true},                    // fp64 div
 
 		{name: "MOVSSload", argLength: 2, reg: fpload, asm: "MOVSS", aux: "SymOff", faultOnNilArg0: true, symEffect: "Read"}, // fp32 load
 		{name: "MOVSDload", argLength: 2, reg: fpload, asm: "MOVSD", aux: "SymOff", faultOnNilArg0: true, symEffect: "Read"}, // fp64 load
@@ -246,8 +246,8 @@ func init() {
 		{name: "CMPWconstload", argLength: 2, reg: gp0flagsLoad, asm: "CMPW", aux: "SymValAndOff", typ: "Flags", symEffect: "Read", faultOnNilArg0: true},
 		{name: "CMPBconstload", argLength: 2, reg: gp0flagsLoad, asm: "CMPB", aux: "SymValAndOff", typ: "Flags", symEffect: "Read", faultOnNilArg0: true},
 
-		{name: "UCOMISS", argLength: 2, reg: fp2flags, asm: "UCOMISS", typ: "Flags", usesScratch: true}, // arg0 compare to arg1, f32
-		{name: "UCOMISD", argLength: 2, reg: fp2flags, asm: "UCOMISD", typ: "Flags", usesScratch: true}, // arg0 compare to arg1, f64
+		{name: "UCOMISS", argLength: 2, reg: fp2flags, asm: "UCOMISS", typ: "Flags"}, // arg0 compare to arg1, f32
+		{name: "UCOMISD", argLength: 2, reg: fp2flags, asm: "UCOMISD", typ: "Flags"}, // arg0 compare to arg1, f64
 
 		{name: "TESTL", argLength: 2, reg: gp2flags, commutative: true, asm: "TESTL", typ: "Flags"}, // (arg0 & arg1) compare to 0
 		{name: "TESTW", argLength: 2, reg: gp2flags, commutative: true, asm: "TESTW", typ: "Flags"}, // (arg0 & arg1) compare to 0
@@ -341,12 +341,12 @@ func init() {
 
 		{name: "MOVLconst", reg: gp01, asm: "MOVL", typ: "UInt32", aux: "Int32", rematerializeable: true}, // 32 low bits of auxint
 
-		{name: "CVTTSD2SL", argLength: 1, reg: fpgp, asm: "CVTTSD2SL", usesScratch: true}, // convert float64 to int32
-		{name: "CVTTSS2SL", argLength: 1, reg: fpgp, asm: "CVTTSS2SL", usesScratch: true}, // convert float32 to int32
-		{name: "CVTSL2SS", argLength: 1, reg: gpfp, asm: "CVTSL2SS", usesScratch: true},   // convert int32 to float32
-		{name: "CVTSL2SD", argLength: 1, reg: gpfp, asm: "CVTSL2SD", usesScratch: true},   // convert int32 to float64
-		{name: "CVTSD2SS", argLength: 1, reg: fp11, asm: "CVTSD2SS", usesScratch: true},   // convert float64 to float32
-		{name: "CVTSS2SD", argLength: 1, reg: fp11, asm: "CVTSS2SD"},                      // convert float32 to float64
+		{name: "CVTTSD2SL", argLength: 1, reg: fpgp, asm: "CVTTSD2SL"}, // convert float64 to int32
+		{name: "CVTTSS2SL", argLength: 1, reg: fpgp, asm: "CVTTSS2SL"}, // convert float32 to int32
+		{name: "CVTSL2SS", argLength: 1, reg: gpfp, asm: "CVTSL2SS"},   // convert int32 to float32
+		{name: "CVTSL2SD", argLength: 1, reg: gpfp, asm: "CVTSL2SD"},   // convert int32 to float64
+		{name: "CVTSD2SS", argLength: 1, reg: fp11, asm: "CVTSD2SS"},   // convert float64 to float32
+		{name: "CVTSS2SD", argLength: 1, reg: fp11, asm: "CVTSS2SD"},   // convert float32 to float64
 
 		{name: "PXOR", argLength: 2, reg: fp21, asm: "PXOR", commutative: true, resultInArg0: true}, // exclusive or, applied to X regs for float negation.
 
diff --git a/src/cmd/compile/internal/ssa/gen/main.go b/src/cmd/compile/internal/ssa/gen/main.go
index dfa146a28a..e7a4ef0629 100644
--- a/src/cmd/compile/internal/ssa/gen/main.go
+++ b/src/cmd/compile/internal/ssa/gen/main.go
@@ -63,7 +63,6 @@ type opData struct {
 	nilCheck          bool   // this op is a nil check on arg0
 	faultOnNilArg0    bool   // this op will fault if arg0 is nil (and aux encodes a small offset)
 	faultOnNilArg1    bool   // this op will fault if arg1 is nil (and aux encodes a small offset)
-	usesScratch       bool   // this op requires scratch memory space
 	hasSideEffects    bool   // for "reasons", not to be eliminated.  E.g., atomic store, #19182.
 	zeroWidth         bool   // op never translates into any machine code. example: copy, which may sometimes translate to machine code, is not zero-width.
 	unsafePoint       bool   // this op is an unsafe point, i.e. not safe for async preemption
@@ -320,9 +319,6 @@ func genOp() {
 					log.Fatalf("faultOnNilArg1 with aux %s not allowed", v.aux)
 				}
 			}
-			if v.usesScratch {
-				fmt.Fprintln(w, "usesScratch: true,")
-			}
 			if v.hasSideEffects {
 				fmt.Fprintln(w, "hasSideEffects: true,")
 			}
@@ -404,8 +400,6 @@ func genOp() {
 	// generate op string method
 	fmt.Fprintln(w, "func (o Op) String() string {return opcodeTable[o].name }")
 
-	fmt.Fprintln(w, "func (o Op) UsesScratch() bool { return opcodeTable[o].usesScratch }")
-
 	fmt.Fprintln(w, "func (o Op) SymEffect() SymEffect { return opcodeTable[o].symEffect }")
 	fmt.Fprintln(w, "func (o Op) IsCall() bool { return opcodeTable[o].call }")
 	fmt.Fprintln(w, "func (o Op) HasSideEffects() bool { return opcodeTable[o].hasSideEffects }")
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index ccfed93475..e4087bd021 100644
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -2912,7 +2912,6 @@ var opcodeTable = [...]opInfo{
 		argLen:       2,
 		commutative:  true,
 		resultInArg0: true,
-		usesScratch:  true,
 		asm:          x86.AADDSS,
 		reg: regInfo{
 			inputs: []inputInfo{
@@ -2944,7 +2943,6 @@ var opcodeTable = [...]opInfo{
 		name:         "SUBSS",
 		argLen:       2,
 		resultInArg0: true,
-		usesScratch:  true,
 		asm:          x86.ASUBSS,
 		reg: regInfo{
 			inputs: []inputInfo{
@@ -2976,7 +2974,6 @@ var opcodeTable = [...]opInfo{
 		argLen:       2,
 		commutative:  true,
 		resultInArg0: true,
-		usesScratch:  true,
 		asm:          x86.AMULSS,
 		reg: regInfo{
 			inputs: []inputInfo{
@@ -3008,7 +3005,6 @@ var opcodeTable = [...]opInfo{
 		name:         "DIVSS",
 		argLen:       2,
 		resultInArg0: true,
-		usesScratch:  true,
 		asm:          x86.ADIVSS,
 		reg: regInfo{
 			inputs: []inputInfo{
@@ -4072,10 +4068,9 @@ var opcodeTable = [...]opInfo{
 		},
 	},
 	{
-		name:        "UCOMISS",
-		argLen:      2,
-		usesScratch: true,
-		asm:         x86.AUCOMISS,
+		name:   "UCOMISS",
+		argLen: 2,
+		asm:    x86.AUCOMISS,
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 65280}, // X0 X1 X2 X3 X4 X5 X6 X7
@@ -4084,10 +4079,9 @@ var opcodeTable = [...]opInfo{
 		},
 	},
 	{
-		name:        "UCOMISD",
-		argLen:      2,
-		usesScratch: true,
-		asm:         x86.AUCOMISD,
+		name:   "UCOMISD",
+		argLen: 2,
+		asm:    x86.AUCOMISD,
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 65280}, // X0 X1 X2 X3 X4 X5 X6 X7
@@ -5027,10 +5021,9 @@ var opcodeTable = [...]opInfo{
 		},
 	},
 	{
-		name:        "CVTTSD2SL",
-		argLen:      1,
-		usesScratch: true,
-		asm:         x86.ACVTTSD2SL,
+		name:   "CVTTSD2SL",
+		argLen: 1,
+		asm:    x86.ACVTTSD2SL,
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 65280}, // X0 X1 X2 X3 X4 X5 X6 X7
@@ -5041,10 +5034,9 @@ var opcodeTable = [...]opInfo{
 		},
 	},
 	{
-		name:        "CVTTSS2SL",
-		argLen:      1,
-		usesScratch: true,
-		asm:         x86.ACVTTSS2SL,
+		name:   "CVTTSS2SL",
+		argLen: 1,
+		asm:    x86.ACVTTSS2SL,
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 65280}, // X0 X1 X2 X3 X4 X5 X6 X7
@@ -5055,10 +5047,9 @@ var opcodeTable = [...]opInfo{
 		},
 	},
 	{
-		name:        "CVTSL2SS",
-		argLen:      1,
-		usesScratch: true,
-		asm:         x86.ACVTSL2SS,
+		name:   "CVTSL2SS",
+		argLen: 1,
+		asm:    x86.ACVTSL2SS,
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 239}, // AX CX DX BX BP SI DI
@@ -5069,10 +5060,9 @@ var opcodeTable = [...]opInfo{
 		},
 	},
 	{
-		name:        "CVTSL2SD",
-		argLen:      1,
-		usesScratch: true,
-		asm:         x86.ACVTSL2SD,
+		name:   "CVTSL2SD",
+		argLen: 1,
+		asm:    x86.ACVTSL2SD,
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 239}, // AX CX DX BX BP SI DI
@@ -5083,10 +5073,9 @@ var opcodeTable = [...]opInfo{
 		},
 	},
 	{
-		name:        "CVTSD2SS",
-		argLen:      1,
-		usesScratch: true,
-		asm:         x86.ACVTSD2SS,
+		name:   "CVTSD2SS",
+		argLen: 1,
+		asm:    x86.ACVTSD2SS,
 		reg: regInfo{
 			inputs: []inputInfo{
 				{0, 65280}, // X0 X1 X2 X3 X4 X5 X6 X7
@@ -36128,7 +36117,6 @@ var opcodeTable = [...]opInfo{
 func (o Op) Asm() obj.As          { return opcodeTable[o].asm }
 func (o Op) Scale() int16         { return int16(opcodeTable[o].scale) }
 func (o Op) String() string       { return opcodeTable[o].name }
-func (o Op) UsesScratch() bool    { return opcodeTable[o].usesScratch }
 func (o Op) SymEffect() SymEffect { return opcodeTable[o].symEffect }
 func (o Op) IsCall() bool         { return opcodeTable[o].call }
 func (o Op) HasSideEffects() bool { return opcodeTable[o].hasSideEffects }
diff --git a/src/cmd/compile/internal/ssagen/pgen.go b/src/cmd/compile/internal/ssagen/pgen.go
index 40f07a8d45..25b09e1f5d 100644
--- a/src/cmd/compile/internal/ssagen/pgen.go
+++ b/src/cmd/compile/internal/ssagen/pgen.go
@@ -15,7 +15,6 @@ import (
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/objw"
 	"cmd/compile/internal/ssa"
-	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
@@ -90,7 +89,6 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 		}
 	}
 
-	scratchUsed := false
 	for _, b := range f.Blocks {
 		for _, v := range b.Values {
 			if n, ok := v.Aux.(*ir.Name); ok {
@@ -104,17 +102,9 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 					n.SetUsed(true)
 				}
 			}
-			if !scratchUsed {
-				scratchUsed = v.Op.UsesScratch()
-			}
-
 		}
 	}
 
-	if f.Config.NeedsFpScratch && scratchUsed {
-		s.scratchFpMem = typecheck.TempAt(src.NoXPos, s.curfn, types.Types[types.TUINT64])
-	}
-
 	sort.Sort(byStackVar(fn.Dcl))
 
 	// Reassign stack offsets of the locals that are used.
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index e13ca90d33..cfc54ae0ab 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -6282,9 +6282,6 @@ type State struct {
 	// bstart remembers where each block starts (indexed by block ID)
 	bstart []*obj.Prog
 
-	// Some architectures require a 64-bit temporary for FP-related register shuffling. Examples include PPC and Sparc V8.
-	ScratchFpMem *ir.Name
-
 	maxarg int64 // largest frame size for arguments to calls made by the function
 
 	// Map from GC safe points to liveness index, generated by
@@ -6398,8 +6395,6 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 		progToBlock[s.pp.Next] = f.Blocks[0]
 	}
 
-	s.ScratchFpMem = e.scratchFpMem
-
 	if base.Ctxt.Flag_locationlists {
 		if cap(f.Cache.ValueToProgAfter) < f.NumValues() {
 			f.Cache.ValueToProgAfter = make([]*obj.Prog, f.NumValues())
@@ -6948,17 +6943,6 @@ func AddrAuto(a *obj.Addr, v *ssa.Value) {
 	}
 }
 
-func (s *State) AddrScratch(a *obj.Addr) {
-	if s.ScratchFpMem == nil {
-		panic("no scratch memory available; forgot to declare usesScratch for Op?")
-	}
-	a.Type = obj.TYPE_MEM
-	a.Name = obj.NAME_AUTO
-	a.Sym = s.ScratchFpMem.Linksym()
-	a.Reg = int16(Arch.REGSP)
-	a.Offset = s.ScratchFpMem.Offset_
-}
-
 // Call returns a new CALL instruction for the SSA value v.
 // It uses PrepareCall to prepare the call.
 func (s *State) Call(v *ssa.Value) *obj.Prog {
@@ -7061,12 +7045,11 @@ func fieldIdx(n *ir.SelectorExpr) int {
 // ssafn holds frontend information about a function that the backend is processing.
 // It also exports a bunch of compiler services for the ssa backend.
 type ssafn struct {
-	curfn        *ir.Func
-	strings      map[string]*obj.LSym // map from constant string to data symbols
-	scratchFpMem *ir.Name             // temp for floating point register / memory moves on some architectures
-	stksize      int64                // stack size for current frame
-	stkptrsize   int64                // prefix of stack containing pointers
-	log          bool                 // print ssa debug to the stdout
+	curfn      *ir.Func
+	strings    map[string]*obj.LSym // map from constant string to data symbols
+	stksize    int64                // stack size for current frame
+	stkptrsize int64                // prefix of stack containing pointers
+	log        bool                 // print ssa debug to the stdout
 }
 
 // StringData returns a symbol which
-- 
GitLab


From c4b771348c3e5c5372bd00254f2e796b627c13dc Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 22 Feb 2021 12:56:33 -0500
Subject: [PATCH 0774/2400] runtime: fix windows/arm signal handling assembly

Bug introduced in CL 288799: R12 is used but not set.

Fixes windows/arm builder.

Change-Id: I015a5a83cfa3bdd23da1ffb73713623764f2f817
Reviewed-on: https://go-review.googlesource.com/c/go/+/295109
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/sys_windows_arm.s | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/runtime/sys_windows_arm.s b/src/runtime/sys_windows_arm.s
index cd230ccffd..4be5ce7da0 100644
--- a/src/runtime/sys_windows_arm.s
+++ b/src/runtime/sys_windows_arm.s
@@ -160,6 +160,11 @@ g0:
 	BL	(R7)		// Call the go routine
 	MOVW	16(R13), R4	// Fetch return value from stack
 
+	// Save system stack pointer for sigresume setup below.
+	// The exact value does not matter - nothing is read or written
+	// from this address. It just needs to be on the system stack.
+	MOVW	R13, R12
+
 	// switch back to original stack and g
 	MOVW	24(R13), R13
 	MOVW	20(R13), g
-- 
GitLab


From 6525abddcee2886ca0095decdfe1e97de19d06f2 Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Sat, 16 Jan 2021 03:09:15 +1100
Subject: [PATCH 0775/2400] cmd/internal/obj/riscv: clean up branch tests

Address review comments from earlier changes, which would have previously
caused unwanted conflicts.

Change-Id: If2c61ffe977d721cccf276f931825b003521fda1
Reviewed-on: https://go-review.googlesource.com/c/go/+/284116
Trust: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
---
 .../riscv/testdata/testbranch/branch_test.go  | 117 ++++++++----------
 .../riscv/testdata/testbranch/branch_test.s   |  28 ++---
 2 files changed, 67 insertions(+), 78 deletions(-)

diff --git a/src/cmd/internal/obj/riscv/testdata/testbranch/branch_test.go b/src/cmd/internal/obj/riscv/testdata/testbranch/branch_test.go
index 279aeb2c32..3fa95222ff 100644
--- a/src/cmd/internal/obj/riscv/testdata/testbranch/branch_test.go
+++ b/src/cmd/internal/obj/riscv/testdata/testbranch/branch_test.go
@@ -25,84 +25,73 @@ func testBLTU(a, b int64) (r bool)
 func testBLTZ(a int64) (r bool)
 func testBNEZ(a int64) (r bool)
 
+func testGoBGE(a, b int64) bool { return a >= b }
+func testGoBGEU(a, b int64) bool { return uint64(a) >= uint64(b) }
+func testGoBGT(a, b int64) bool { return a > b }
+func testGoBGTU(a, b int64) bool { return uint64(a) > uint64(b) }
+func testGoBLE(a, b int64) bool { return a <= b }
+func testGoBLEU(a, b int64) bool { return uint64(a) <= uint64(b) }
+func testGoBLT(a, b int64) bool { return a < b }
+func testGoBLTZ(a, b int64) bool { return uint64(a) < uint64(b) }
+
 func TestBranchCondition(t *testing.T) {
 	tests := []struct {
 		ins  string
 		a    int64
 		b    int64
 		fn   func(a, b int64) bool
+		goFn func(a, b int64) bool
 		want bool
 	}{
-		{"BGE", 0, 1, testBGE, false},
-		{"BGE", 0, 0, testBGE, true},
-		{"BGE", 0, -1, testBGE, true},
-		{"BGE", -1, 0, testBGE, false},
-		{"BGE", 1, 0, testBGE, true},
-		{"BGEU", 0, 1, testBGEU, false},
-		{"BGEU", 0, 0, testBGEU, true},
-		{"BGEU", 0, -1, testBGEU, false},
-		{"BGEU", -1, 0, testBGEU, true},
-		{"BGEU", 1, 0, testBGEU, true},
-		{"BGT", 0, 1, testBGT, false},
-		{"BGT", 0, 0, testBGT, false},
-		{"BGT", 0, -1, testBGT, true},
-		{"BGT", -1, 0, testBGT, false},
-		{"BGT", 1, 0, testBGT, true},
-		{"BGTU", 0, 1, testBGTU, false},
-		{"BGTU", 0, 0, testBGTU, false},
-		{"BGTU", 0, -1, testBGTU, false},
-		{"BGTU", -1, 0, testBGTU, true},
-		{"BGTU", 1, 0, testBGTU, true},
-		{"BLE", 0, 1, testBLE, true},
-		{"BLE", 0, 0, testBLE, true},
-		{"BLE", 0, -1, testBLE, false},
-		{"BLE", -1, 0, testBLE, true},
-		{"BLE", 1, 0, testBLE, false},
-		{"BLEU", 0, 1, testBLEU, true},
-		{"BLEU", 0, 0, testBLEU, true},
-		{"BLEU", 0, -1, testBLEU, true},
-		{"BLEU", -1, 0, testBLEU, false},
-		{"BLEU", 1, 0, testBLEU, false},
-		{"BLT", 0, 1, testBLT, true},
-		{"BLT", 0, 0, testBLT, false},
-		{"BLT", 0, -1, testBLT, false},
-		{"BLT", -1, 0, testBLT, true},
-		{"BLT", 1, 0, testBLT, false},
-		{"BLTU", 0, 1, testBLTU, true},
-		{"BLTU", 0, 0, testBLTU, false},
-		{"BLTU", 0, -1, testBLTU, true},
-		{"BLTU", -1, 0, testBLTU, false},
-		{"BLTU", 1, 0, testBLTU, false},
+		{"BGE", 0, 1, testBGE, testGoBGE, false},
+		{"BGE", 0, 0, testBGE, testGoBGE, true},
+		{"BGE", 0, -1, testBGE, testGoBGE, true},
+		{"BGE", -1, 0, testBGE, testGoBGE, false},
+		{"BGE", 1, 0, testBGE, testGoBGE, true},
+		{"BGEU", 0, 1, testBGEU, testGoBGEU, false},
+		{"BGEU", 0, 0, testBGEU, testGoBGEU, true},
+		{"BGEU", 0, -1, testBGEU, testGoBGEU, false},
+		{"BGEU", -1, 0, testBGEU, testGoBGEU, true},
+		{"BGEU", 1, 0, testBGEU, testGoBGEU, true},
+		{"BGT", 0, 1, testBGT, testGoBGT, false},
+		{"BGT", 0, 0, testBGT, testGoBGT, false},
+		{"BGT", 0, -1, testBGT, testGoBGT, true},
+		{"BGT", -1, 0, testBGT, testGoBGT, false},
+		{"BGT", 1, 0, testBGT, testGoBGT, true},
+		{"BGTU", 0, 1, testBGTU, testGoBGTU, false},
+		{"BGTU", 0, 0, testBGTU, testGoBGTU, false},
+		{"BGTU", 0, -1, testBGTU, testGoBGTU, false},
+		{"BGTU", -1, 0, testBGTU, testGoBGTU, true},
+		{"BGTU", 1, 0, testBGTU, testGoBGTU, true},
+		{"BLE", 0, 1, testBLE, testGoBLE, true},
+		{"BLE", 0, 0, testBLE, testGoBLE, true},
+		{"BLE", 0, -1, testBLE, testGoBLE, false},
+		{"BLE", -1, 0, testBLE, testGoBLE, true},
+		{"BLE", 1, 0, testBLE, testGoBLE, false},
+		{"BLEU", 0, 1, testBLEU, testGoBLEU, true},
+		{"BLEU", 0, 0, testBLEU, testGoBLEU, true},
+		{"BLEU", 0, -1, testBLEU, testGoBLEU, true},
+		{"BLEU", -1, 0, testBLEU, testGoBLEU, false},
+		{"BLEU", 1, 0, testBLEU, testGoBLEU, false},
+		{"BLT", 0, 1, testBLT, testGoBLT, true},
+		{"BLT", 0, 0, testBLT, testGoBLT, false},
+		{"BLT", 0, -1, testBLT, testGoBLT, false},
+		{"BLT", -1, 0, testBLT, testGoBLT, true},
+		{"BLT", 1, 0, testBLT, testGoBLT, false},
+		{"BLTU", 0, 1, testBLTU, testGoBLTU, true},
+		{"BLTU", 0, 0, testBLTU, testGoBLTU, false},
+		{"BLTU", 0, -1, testBLTU, testGoBLTU, true},
+		{"BLTU", -1, 0, testBLTU, testGoBLTU, false},
+		{"BLTU", 1, 0, testBLTU, testGoBLTU, false},
 	}
 	for _, test := range tests {
 		t.Run(test.ins, func(t *testing.T) {
-			var fn func(a, b int64) bool
-			switch test.ins {
-			case "BGE":
-				fn = func(a, b int64) bool { return a >= b }
-			case "BGEU":
-				fn = func(a, b int64) bool { return uint64(a) >= uint64(b) }
-			case "BGT":
-				fn = func(a, b int64) bool { return a > b }
-			case "BGTU":
-				fn = func(a, b int64) bool { return uint64(a) > uint64(b) }
-			case "BLE":
-				fn = func(a, b int64) bool { return a <= b }
-			case "BLEU":
-				fn = func(a, b int64) bool { return uint64(a) <= uint64(b) }
-			case "BLT":
-				fn = func(a, b int64) bool { return a < b }
-			case "BLTU":
-				fn = func(a, b int64) bool { return uint64(a) < uint64(b) }
-			default:
-				t.Fatalf("Unknown instruction %q", test.ins)
-			}
-			if got := fn(test.a, test.b); got != test.want {
-				t.Errorf("Go %v %v, %v = %v, want %v", test.ins, test.a, test.b, got, test.want)
-			}
 			if got := test.fn(test.a, test.b); got != test.want {
 				t.Errorf("Assembly %v %v, %v = %v, want %v", test.ins, test.a, test.b, got, test.want)
 			}
+			if got := test.goFn(test.a, test.b); got != test.want {
+				t.Errorf("Go %v %v, %v = %v, want %v", test.ins, test.a, test.b, got, test.want)
+			}
 		})
 	}
 }
diff --git a/src/cmd/internal/obj/riscv/testdata/testbranch/branch_test.s b/src/cmd/internal/obj/riscv/testdata/testbranch/branch_test.s
index 8dd6f563af..cce296feb5 100644
--- a/src/cmd/internal/obj/riscv/testdata/testbranch/branch_test.s
+++ b/src/cmd/internal/obj/riscv/testdata/testbranch/branch_test.s
@@ -7,7 +7,7 @@
 #include "textflag.h"
 
 // func testBEQZ(a int64) (r bool)
-TEXT ·testBEQZ(SB),NOSPLIT,$0-0
+TEXT ·testBEQZ(SB),NOSPLIT,$0-9
 	MOV	a+0(FP), X5
 	MOV	$1, X6
 	BEQZ	X5, b
@@ -17,7 +17,7 @@ b:
 	RET
 
 // func testBGE(a, b int64) (r bool)
-TEXT ·testBGE(SB),NOSPLIT,$0-0
+TEXT ·testBGE(SB),NOSPLIT,$0-17
 	MOV	a+0(FP), X5
 	MOV	b+8(FP), X6
 	MOV	$1, X7
@@ -28,7 +28,7 @@ b:
 	RET
 
 // func testBGEU(a, b int64) (r bool)
-TEXT ·testBGEU(SB),NOSPLIT,$0-0
+TEXT ·testBGEU(SB),NOSPLIT,$0-17
 	MOV	a+0(FP), X5
 	MOV	b+8(FP), X6
 	MOV	$1, X7
@@ -39,7 +39,7 @@ b:
 	RET
 
 // func testBGEZ(a int64) (r bool)
-TEXT ·testBGEZ(SB),NOSPLIT,$0-0
+TEXT ·testBGEZ(SB),NOSPLIT,$0-9
 	MOV	a+0(FP), X5
 	MOV	$1, X6
 	BGEZ	X5, b
@@ -49,7 +49,7 @@ b:
 	RET
 
 // func testBGT(a, b int64) (r bool)
-TEXT ·testBGT(SB),NOSPLIT,$0-0
+TEXT ·testBGT(SB),NOSPLIT,$0-17
 	MOV	a+0(FP), X5
 	MOV	b+8(FP), X6
 	MOV	$1, X7
@@ -60,7 +60,7 @@ b:
 	RET
 
 // func testBGTU(a, b int64) (r bool)
-TEXT ·testBGTU(SB),NOSPLIT,$0-0
+TEXT ·testBGTU(SB),NOSPLIT,$0-17
 	MOV	a+0(FP), X5
 	MOV	b+8(FP), X6
 	MOV	$1, X7
@@ -71,7 +71,7 @@ b:
 	RET
 
 // func testBGTZ(a int64) (r bool)
-TEXT ·testBGTZ(SB),NOSPLIT,$0-0
+TEXT ·testBGTZ(SB),NOSPLIT,$0-9
 	MOV	a+0(FP), X5
 	MOV	$1, X6
 	BGTZ	X5, b
@@ -81,7 +81,7 @@ b:
 	RET
 
 // func testBLE(a, b int64) (r bool)
-TEXT ·testBLE(SB),NOSPLIT,$0-0
+TEXT ·testBLE(SB),NOSPLIT,$0-17
 	MOV	a+0(FP), X5
 	MOV	b+8(FP), X6
 	MOV	$1, X7
@@ -92,7 +92,7 @@ b:
 	RET
 
 // func testBLEU(a, b int64) (r bool)
-TEXT ·testBLEU(SB),NOSPLIT,$0-0
+TEXT ·testBLEU(SB),NOSPLIT,$0-17
 	MOV	a+0(FP), X5
 	MOV	b+8(FP), X6
 	MOV	$1, X7
@@ -103,7 +103,7 @@ b:
 	RET
 
 // func testBLEZ(a int64) (r bool)
-TEXT ·testBLEZ(SB),NOSPLIT,$0-0
+TEXT ·testBLEZ(SB),NOSPLIT,$0-9
 	MOV	a+0(FP), X5
 	MOV	$1, X6
 	BLEZ	X5, b
@@ -113,7 +113,7 @@ b:
 	RET
 
 // func testBLT(a, b int64) (r bool)
-TEXT ·testBLT(SB),NOSPLIT,$0-0
+TEXT ·testBLT(SB),NOSPLIT,$0-17
 	MOV	a+0(FP), X5
 	MOV	b+8(FP), X6
 	MOV	$1, X7
@@ -124,7 +124,7 @@ b:
 	RET
 
 // func testBLTU(a, b int64) (r bool)
-TEXT ·testBLTU(SB),NOSPLIT,$0-0
+TEXT ·testBLTU(SB),NOSPLIT,$0-17
 	MOV	a+0(FP), X5
 	MOV	b+8(FP), X6
 	MOV	$1, X7
@@ -135,7 +135,7 @@ b:
 	RET
 
 // func testBLTZ(a int64) (r bool)
-TEXT ·testBLTZ(SB),NOSPLIT,$0-0
+TEXT ·testBLTZ(SB),NOSPLIT,$0-9
 	MOV	a+0(FP), X5
 	MOV	$1, X6
 	BLTZ	X5, b
@@ -145,7 +145,7 @@ b:
 	RET
 
 // func testBNEZ(a int64) (r bool)
-TEXT ·testBNEZ(SB),NOSPLIT,$0-0
+TEXT ·testBNEZ(SB),NOSPLIT,$0-9
 	MOV	a+0(FP), X5
 	MOV	$1, X6
 	BNEZ	X5, b
-- 
GitLab


From 0398a771d2fb4c4702e31bbb485924198b1b2603 Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Wed, 17 Feb 2021 21:03:59 +1100
Subject: [PATCH 0776/2400] cmd/internal/obj/riscv: prevent constant loads that
 do not target registers

Check that the target of a constant load is a register and add test coverage
for this error condition. While here, rename the RISC-V testdata and tests
to be consistent with other platforms.

Change-Id: I7fd0bfcee8cf9df0597d72e65cd74a2d0bfd349a
Reviewed-on: https://go-review.googlesource.com/c/go/+/292895
Trust: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/asm/internal/asm/endtoend_test.go          |  8 ++++++--
 .../asm/testdata/{riscvenc.s => riscv64.s}         |  0
 src/cmd/asm/internal/asm/testdata/riscv64error.s   | 14 ++++++++++++++
 src/cmd/internal/obj/riscv/obj.go                  |  5 ++++-
 4 files changed, 24 insertions(+), 3 deletions(-)
 rename src/cmd/asm/internal/asm/testdata/{riscvenc.s => riscv64.s} (100%)
 create mode 100644 src/cmd/asm/internal/asm/testdata/riscv64error.s

diff --git a/src/cmd/asm/internal/asm/endtoend_test.go b/src/cmd/asm/internal/asm/endtoend_test.go
index a4153f3af1..92cf64575b 100644
--- a/src/cmd/asm/internal/asm/endtoend_test.go
+++ b/src/cmd/asm/internal/asm/endtoend_test.go
@@ -439,8 +439,12 @@ func TestPPC64EndToEnd(t *testing.T) {
 	testEndToEnd(t, "ppc64", "ppc64")
 }
 
-func TestRISCVEncoder(t *testing.T) {
-	testEndToEnd(t, "riscv64", "riscvenc")
+func TestRISCVEndToEnd(t *testing.T) {
+	testEndToEnd(t, "riscv64", "riscv64")
+}
+
+func TestRISCVErrors(t *testing.T) {
+	testErrors(t, "riscv64", "riscv64error")
 }
 
 func TestS390XEndToEnd(t *testing.T) {
diff --git a/src/cmd/asm/internal/asm/testdata/riscvenc.s b/src/cmd/asm/internal/asm/testdata/riscv64.s
similarity index 100%
rename from src/cmd/asm/internal/asm/testdata/riscvenc.s
rename to src/cmd/asm/internal/asm/testdata/riscv64.s
diff --git a/src/cmd/asm/internal/asm/testdata/riscv64error.s b/src/cmd/asm/internal/asm/testdata/riscv64error.s
new file mode 100644
index 0000000000..fb43e68fc1
--- /dev/null
+++ b/src/cmd/asm/internal/asm/testdata/riscv64error.s
@@ -0,0 +1,14 @@
+// Copyright 2021 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.
+
+TEXT errors(SB),$0
+	MOV	$0, 0(SP)			// ERROR "constant load must target register"
+	MOV	$0, 8(SP)			// ERROR "constant load must target register"
+	MOV	$1234, 0(SP)			// ERROR "constant load must target register"
+	MOV	$1234, 8(SP)			// ERROR "constant load must target register"
+	MOVB	$1, X5				// ERROR "unsupported constant load"
+	MOVH	$1, X5				// ERROR "unsupported constant load"
+	MOVW	$1, X5				// ERROR "unsupported constant load"
+	MOVF	$1, X5				// ERROR "unsupported constant load"
+	RET
diff --git a/src/cmd/internal/obj/riscv/obj.go b/src/cmd/internal/obj/riscv/obj.go
index d104f1cfa5..391c2486ca 100644
--- a/src/cmd/internal/obj/riscv/obj.go
+++ b/src/cmd/internal/obj/riscv/obj.go
@@ -302,7 +302,10 @@ func rewriteMOV(ctxt *obj.Link, newprog obj.ProgAlloc, p *obj.Prog) {
 		//   LUI top20bits(c), R
 		//   ADD bottom12bits(c), R, R
 		if p.As != AMOV {
-			ctxt.Diag("unsupported constant load at %v", p)
+			ctxt.Diag("%v: unsupported constant load", p)
+		}
+		if p.To.Type != obj.TYPE_REG {
+			ctxt.Diag("%v: constant load must target register", p)
 		}
 		off := p.From.Offset
 		to := p.To
-- 
GitLab


From 08543f071520074854f280ad789cf79c5a00af7d Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Tue, 16 Feb 2021 10:36:10 +0100
Subject: [PATCH 0777/2400] ios/fs: mention f.dir in (*subFS).fixErr godoc

There is no dir parameter to (f *subFS).fixErr.

Change-Id: I49e42bac5e102cfab0d289658d9871429cfec515
Reviewed-on: https://go-review.googlesource.com/c/go/+/292389
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/io/fs/sub.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/io/fs/sub.go b/src/io/fs/sub.go
index 64cdffe6de..d689b9e2bc 100644
--- a/src/io/fs/sub.go
+++ b/src/io/fs/sub.go
@@ -68,7 +68,7 @@ func (f *subFS) shorten(name string) (rel string, ok bool) {
 	return "", false
 }
 
-// fixErr shortens any reported names in PathErrors by stripping dir.
+// fixErr shortens any reported names in PathErrors by stripping f.dir.
 func (f *subFS) fixErr(err error) error {
 	if e, ok := err.(*PathError); ok {
 		if short, ok := f.shorten(e.Path); ok {
-- 
GitLab


From a78b0e67211034743a1f03645312aed35e5c5ba2 Mon Sep 17 00:00:00 2001
From: Andy Pan <panjf2000@gmail.com>
Date: Thu, 19 Nov 2020 17:30:27 +0800
Subject: [PATCH 0778/2400] internal/poll: fix the verbose condition in splice

Change-Id: I0b433ea1a78632de20ea58c48c9be0f1fb6eb083
Reviewed-on: https://go-review.googlesource.com/c/go/+/271499
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/internal/poll/splice_linux.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/internal/poll/splice_linux.go b/src/internal/poll/splice_linux.go
index 01baf14ed7..968bc44a5f 100644
--- a/src/internal/poll/splice_linux.go
+++ b/src/internal/poll/splice_linux.go
@@ -52,7 +52,7 @@ func Splice(dst, src *FD, remain int64) (written int64, handled bool, sc string,
 		// If inPipe == 0 && err == nil, src is at EOF, and the
 		// transfer is complete.
 		handled = handled || (err != syscall.EINVAL)
-		if err != nil || (inPipe == 0 && err == nil) {
+		if err != nil || inPipe == 0 {
 			break
 		}
 		n, err = splicePump(dst, prfd, inPipe)
-- 
GitLab


From b3b65f21762fad1ec37bdb0cd47f79a53814bb16 Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Tue, 8 Dec 2020 04:14:34 +1100
Subject: [PATCH 0779/2400] runtime: enable race detector on openbsd/amd64

Now that this commit[1] has landed in LLVM the .syso file can be generated for
OpenBSD.

With the changes to src/runtime running the sample race[2] detects the data
race as expected.

Based on golang/go#39464 (https://go-review.googlesource.com/c/go/+/237057) from
Aaron Bieber <deftly@gmail.com>, however the race_openbsd_amd64.syso file has
been built on OpenBSD 6.4 and necessary changes added to race.bash.

[1] https://github.com/llvm/llvm-project/commit/fcf6ae2f070eba73074b6ec8d8281e54d29dbeeb
[2] https://golang.org/doc/articles/race_detector.html

Change-Id: Ic2479ccfa91d6b2cb4585346a11d813d96450f68
Reviewed-on: https://go-review.googlesource.com/c/go/+/275892
Trust: Joel Sing <joel@sing.id.au>
Run-TryBot: Joel Sing <joel@sing.id.au>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/dist/test.go                     |   2 +-
 src/cmd/internal/sys/supported.go        |   2 +-
 src/race.bash                            |   7 ++++++-
 src/runtime/race/README                  |   1 +
 src/runtime/race/race.go                 |   4 ++--
 src/runtime/race/race_openbsd_amd64.syso | Bin 0 -> 688784 bytes
 6 files changed, 11 insertions(+), 5 deletions(-)
 create mode 100644 src/runtime/race/race_openbsd_amd64.syso

diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go
index a22397aa16..0c8e2c56bc 100644
--- a/src/cmd/dist/test.go
+++ b/src/cmd/dist/test.go
@@ -1633,7 +1633,7 @@ func raceDetectorSupported(goos, goarch string) bool {
 		return goarch == "amd64" || goarch == "ppc64le" || goarch == "arm64"
 	case "darwin":
 		return goarch == "amd64" || goarch == "arm64"
-	case "freebsd", "netbsd", "windows":
+	case "freebsd", "netbsd", "openbsd", "windows":
 		return goarch == "amd64"
 	default:
 		return false
diff --git a/src/cmd/internal/sys/supported.go b/src/cmd/internal/sys/supported.go
index ef7c017bd4..291acf0862 100644
--- a/src/cmd/internal/sys/supported.go
+++ b/src/cmd/internal/sys/supported.go
@@ -15,7 +15,7 @@ func RaceDetectorSupported(goos, goarch string) bool {
 		return goarch == "amd64" || goarch == "ppc64le" || goarch == "arm64"
 	case "darwin":
 		return goarch == "amd64" || goarch == "arm64"
-	case "freebsd", "netbsd", "windows":
+	case "freebsd", "netbsd", "openbsd", "windows":
 		return goarch == "amd64"
 	default:
 		return false
diff --git a/src/race.bash b/src/race.bash
index e2b96bcffe..81fb4be606 100755
--- a/src/race.bash
+++ b/src/race.bash
@@ -9,7 +9,7 @@
 set -e
 
 function usage {
-	echo 'race detector is only supported on linux/amd64, linux/ppc64le, linux/arm64, freebsd/amd64, netbsd/amd64, darwin/amd64, and darwin/arm64' 1>&2
+	echo 'race detector is only supported on linux/amd64, linux/ppc64le, linux/arm64, freebsd/amd64, netbsd/amd64, openbsd/amd64, darwin/amd64, and darwin/arm64' 1>&2
 	exit 1
 }
 
@@ -34,6 +34,11 @@ case $(uname) in
 		usage
 	fi
 	;;
+"OpenBSD")
+	if [ $(uname -m) != "amd64" ]; then
+		usage
+	fi
+	;;
 *)
 	usage
 	;;
diff --git a/src/runtime/race/README b/src/runtime/race/README
index 178ab94ab5..dbff42dc8a 100644
--- a/src/runtime/race/README
+++ b/src/runtime/race/README
@@ -12,3 +12,4 @@ race_netbsd_amd64.syso built with LLVM 89f7ccea6f6488c443655880229c54db1f180153
 race_windows_amd64.syso built with LLVM 89f7ccea6f6488c443655880229c54db1f180153 and Go f62d3202bf9dbb3a00ad2a2c63ff4fa4188c5d3b.
 race_linux_arm64.syso built with LLVM 89f7ccea6f6488c443655880229c54db1f180153 and Go f62d3202bf9dbb3a00ad2a2c63ff4fa4188c5d3b.
 race_darwin_arm64.syso built with LLVM 00da38ce2d36c07f12c287dc515d37bb7bc410e9 and Go fe70a3a0fd31441bcbb9932ecab11a6083cf2119.
+race_openbsd_amd64.syso built with LLVM fcf6ae2f070eba73074b6ec8d8281e54d29dbeeb and Go 8f2db14cd35bbd674cb2988a508306de6655e425.
diff --git a/src/runtime/race/race.go b/src/runtime/race/race.go
index fe50900ec8..84050e8771 100644
--- a/src/runtime/race/race.go
+++ b/src/runtime/race/race.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (race && linux && amd64) || (race && freebsd && amd64) || (race && netbsd && amd64) || (race && darwin && amd64) || (race && windows && amd64) || (race && linux && ppc64le) || (race && linux && arm64) || (race && darwin && arm64)
-// +build race,linux,amd64 race,freebsd,amd64 race,netbsd,amd64 race,darwin,amd64 race,windows,amd64 race,linux,ppc64le race,linux,arm64 race,darwin,arm64
+//go:build (race && linux && amd64) || (race && freebsd && amd64) || (race && netbsd && amd64) || (race && darwin && amd64) || (race && windows && amd64) || (race && linux && ppc64le) || (race && linux && arm64) || (race && darwin && arm64) || (race && openbsd && amd64)
+// +build race,linux,amd64 race,freebsd,amd64 race,netbsd,amd64 race,darwin,amd64 race,windows,amd64 race,linux,ppc64le race,linux,arm64 race,darwin,arm64 race,openbsd,amd64
 
 package race
 
diff --git a/src/runtime/race/race_openbsd_amd64.syso b/src/runtime/race/race_openbsd_amd64.syso
new file mode 100644
index 0000000000000000000000000000000000000000..9fefd87ec63d71e7f4f421aa33c9f42b41bd138e
GIT binary patch
literal 688784
zcmb<-^>JfjWMqH=Mg}_u1P><4z#!ns1?M<`Sq==(7#JCRx@AE;A7dF6$6&{35ba|P
z7Aj#nbLQ}w5hZVU080p*K>;Y?!5@BrUy$A7xVr!-3_Uu3U}{HEk10)B_!8khkIoN<
z-wZE#bRK^Raub^Q;f`UBApxG9Upzbic{cz1UdC>C;N@fn1_saOV;ml>mmK$VFfcIq
z@Vox<ZGFPuGL?aWp^Ft{jtxVp!v@ASFuUbI36DpwElBtUh-d&a8A>Ifg8Tme|NkE>
za}2DW5kfIQrF}Y|`E-8r>HG;+;?a75zhwsl1B1s-#{;kTSZ&D3^62F7Xg<K<(R_r%
zF~%{@F&;D6a5;tQj`ip@1$hz4!7$IX9^h~F`2YXEPv`d+?d;49&{Sgh4HE89E{^d3
z?%DazxAhx;%UVWcpZj*Z{qVFr!Qc9Z5ga8yJokXY@_#)8gXeKJkVAZ1|Cflsd|6`W
zYx%6K?&T&11_nYQ!r!uvfq}u-@)>{ID+UIJm*R}L^$;7OzLw9*EqyvacpQA8;L*zq
za-T=H$w80SZzW1Dou3ZA5^1mzV<-{x=w>+xj_2D93=I6+L<C-50Yx|@2_ZrlIl{q#
zh|5o;xX%c?`=pWF#}9R1Nj%7HucM*q6yY#%LWRXUo>Xag39jeAPv=Jr|A6Gdc?GWQ
zBiQKIi{Vy^f&y{hBxwc)u*@0M^b_g`%D|zHA;BKaZyY>3|9f<UbC^e`i;Bg54+aJX
zP~HdY^z1z9dE6Cb8iQwVEeBZ4x3iYRqc=u{<J(~lpH3YW{?<ko1_qzr6cvltX3zwS
zZpv}b<Ln?)JbUXQhIn@7bNF`FGWd4>_3V7lAAZ22^TumVsO~do_yrj}nhyy0SUxEF
z;?r59!m%Gz8+mlz`w#Y-M{|ve0Rw-FEhhtmN4JZLhG(a%gim*gihytHH;-PhZ+!S&
zK6o5I3`+Ti2Ru5Ddi1(7IyThEF*11cMl+Va_2{i;g!^+R$Z;O6xA|M9g0fQcZ-pWW
z&t4um56ct$&CQ@>)_Kr_@usKcx#9}LlOCP-Jv7gIG#~%}?J#qRYUjJ=XUrbo?;*M0
zk$;;AUxx^XNAp2OkLF{HrSCkN|1<M9nJ_Xiyk<Ic1}5*wzb%B1u_J_o5zJ!h2;pD?
zvzR+VIG8<}53+bzo-Muj@(<VvH$9pkKJe%beBjY}&Ew!ZR*=aa&A$?g1r0Abd^^U>
z-`WMrlzYL7UwJe?df?G~=z+(<SFF8NjLpxPK`!>tyl!}Df+N2Gi<l$7fRC5}zaWbM
zzo3tRfFr+vi<kmf(12giML+>0Y5*2>0E-5IL>)k)0btPtuxJ5DGyx=9;L-f5!K3*&
zOX&iTYf3CUnhyzp0w<yQ*n@-bSeuVALINrcWWS5p2S<JZ9x;&i5B!2W0v^qW6hJ;I
zedJ+zn!k1WzyJSVvqMvaN9WCBEF27;ovs?7XqG^a=A)2kMyPMU;n8`+qy2_QuQMpt
z^+2(n%UJr{qqi0#*5C5C^n+vlFC^CWz_DHn4#k5Wj4wg4UIdEu_t02(_;!@JM6UB5
z#5c(CNsahE4Ug}aq{R2FK@#8hnxBy#-)H$-=c2~<OK5ysbi1f1ICi=^I39O(0q4^0
z92E{9%fH|vh`)8x@BjZ_nzAx5_;$X77e8l+EPw2LJO6ohzCY%o!ohINMTHYYaDfPJ
z5Wxc?ctHdoh~Nhi0w6*VL<oThVGtn#B1A!i7>E!D5fUIm5=2OW2x$-@10rNWgdB*F
z2N4P&LJ>qLfe2*~p#maQL4+EJPzMnjAVL#FXn_cA5TOGibU}n3h|mWS1|Y%^L>Pex
zV-R5iB1}Pq8Hg}vKq^stOH?>e%hZ?5@G{j+!lye0RHi;bl&KF4-@ax%<JtMvvp1K~
zxxq$<q4X1|81?9U53U_Nn*TELx6A?Mr{2*29?icLisU?dd2~FQ5B>+|t5#6H>gCY@
z33ytbft083JT%XFG#~r-?GST`s!Qjq=10sP-*3I<fM$PCc`3uwAp<Q>4}r_me`w_?
zPlpHxsO;o{m!~}N@{|W&o_ZpcrxzjltMGwm=LgS&FIYXB4={Q({{xk$-yFXkKrT;x
zI^TITKYQTOeCz?J<n66Pl&9Yfzk$j#786i$XaXuv4fq9p48Y~73Aj8p0hOl)pz_oJ
zT%MYM%Tp6jd1?SEPYuB3sR_6|H35~U2B7lPpunT~9ke_Jxdv389usiseBb;$q51fO
zgYQ|JkAq$D{XWQk7ZY%KYQit*VgM>n4Lq8UDR?v=X9Sg}r_jpNV=fy189Y1PG(Zt7
z;oFKF!LEjHC-`)}_36!JbVS6j4>W!~;qmJUk6&-}`1L}KUr^v7#V<U15%s+z|28Vc
zFLHfJLi~CRmiWaMy^#8nl=yXmMKHAZbaQY#?uJr)^0(gj^&j5yvvyIjC{^+3W>N8I
zKH?DV7~>cV>N3S*_L-n<OmJR@<xaHrC8&An+4+xP8SL9x&f(Mf17s1VJqWWwER_Cl
z=MT;cEBH&QJX$aDw}5&r9=%Tg9Xl^LHa}qZ==|x?{DZy7+^6$^hvo&3&Y!QD&zw2q
z&|&D%QOM}fQOM-bQONAjQOM%ZQON4hQOM@dQONGmd=T7OEWPgAdY~l9^ZSk0ydZ1g
z*rCG^RJDT&h|<rm9X*;K{qSJ?<ze}&%+w?Km`CS9kAn|6JU9<}be{7#_)Nfq^PC5$
zL-RnvgY$z&=g$cqosJwHos1sM2L(JVFBW~k+R2C8hCMtzj~@rMa=`v^Zm6+iWbo~+
zXDt2V*;|ij()hOi=Wl5R_xt`U6iImZ^4Nh(-Fi@|+j-E3@u!dF$FdT`lRlmQp{*Im
zZ^xNS6kIz0L7Ow6@Pf5ZL7oP;$)N35ZIauso|flJFTVT?8V>+P4YBQ4pUz){qdfx-
z7xV@VxV**Pe)Y6G&)+)x-~azk$5<>FNKW6N{Notv7~;|VCIG2x=Hb!nqQbF)qg2_W
z*GI*JKl}iqeuVayJS<NXeR=7?$N;M6M^uyMn2U-9$kUb}!U{xKg9sZCVGAPcK!iPr
zZ~zgGAi@bmID-fm5a9|U+(3jog9oV7=>cjT?Pp?OU_dmH92iRKK;2IP2L6^6piI^6
zq9WmO@CCC6xDUx-z`)SW)7W~Fzr~jc)Q|%AMLoJ1Tn)b=_YXVIJ2pQ5|Np-||E`B}
z{7nUn3=BS<KRph<<nrk5IibM7!2ptHW?=B{71{4`@DXdbkDx*8$<kx5nOzOP!BT~_
zi;4$->laY>yYqub^N|2p!Hrp-?yo@Y*B^6)3<Y`i)<JvZ$K47*?Q8z<1CIQHZXS-u
z+%gzEkGmy+1VPON4d2!$K9JECUw)V8p2xwRuGcJ}V#~RqMh8?L<$}v2q%M|k>s$Vo
zP$mWj&*r}hMKa))0;o^z1!^FI%A=Q_mS^~ztr-~@KxGoFhvf+BVad3FI**{9^#o9P
z1Zv-*mq)*m$|I0GvF*RZ@bKnreE8#kJ%dko3I_)$$oUx<JP$r+@$G!-%lMbSrGtTi
z0b9_4h9fY7&hxli04TIjf(|r3A>rBS=HameRDA#c&%ofR><Vgp1vv9>cd_Ad>~u?T
z?yj+cMnk7t0ZR0?DE|BZ|D^yk11Jfh%CLiEzA=H44&kn1KWJ#+5V#!1H#7i=Ptf>)
z2&g?P0&349#s@^e?O72}dlqSYKm^>L6#=zp1widt0dRX(1l*n#0kvlZK<!xptm6aV
zIL2DOih$d*B3Q-;JT1@ix1RqCE?+f3A!z^#WCM@Z13vt&KRk~g0R{AHZcxI6V&{e$
zbx`_DQDH3o?AcqRf?Q)h;csaM*O-4GHKsba#)S6&eHb5lTAnX10;SI9@EY?7bBUZw
z=QC)H$q4G7i11?>??J9FLGqyV$q(<J@WcBj{7C(iGw}NIA*6po%y^Ga=OaS(r8p=)
z#Zlu^92}qGXz?iyj!$v4_!I}nr#Qj*e1<syFab1PBo2;Gajfxq2Gaj`I>w>^icbYl
zd|H6|C;S2~DiWab$O1L#^Zfq*AA3_29OEeMMUR8;m_0y~0}PPTc|+^T635p(V1-bk
z^Mop>F#dj!fq}uHR0G_g0~f{TB^WpuRR4qe#JwyH9tR(=cKa}b3gWYd2VP4-)Ip07
z)&Kkq3?2s`uy`=D@M9LhP@5nWiu=Izedj;)V&=GOr#WK0^td}x>Fn;|c+4GCI=e$k
zXM&Ar6#H8Lm*jT-0C~9H@&|wG1O^6%&L0O~aH}$WkY@mmE`uj4Jd#g&Fdp=1{K>!|
zz)&3E(am$tqxs>#5<$>-mt`eKiKs_6r$_6_($CF@7#n{v2rw{|o_;Oj(FqzDl_=r%
z=q?m+jDA^E#KeGY!U-CA9=+fJ-F=f77#JLPfUE-dEIJQ5cK$$9(#rrJ&PE;2_Go@1
z081U6E-D<5fqlkOV~@^fhX0{eH>hjV4Vhf9_EF&|Rr6>*B7hl7h6g;5RF&L<x&iDc
zNYsHzl<)+{A80=88)z)O6YQb=AO4{XqaShnc7(qq!sGY>0mlFTCpaE!VF9UN05LxP
z19|>f3(F@M<1>u$1;+RaV|;@#zJnN`8LrYzuXQ|oTU0>i`B*+EljjdV;M4gKrTpU;
zg!VlS7Jc#URQKsr1=UkNozKA@^XzU>Iq{Ey!LySMGC#qHJn4WjnR^DUe}XcfVBp#L
z4=FM<AhS#@2l!j>vN15gjE4--!-Be#5v~K$T<X;YIS)3Z<kJnF?(po?hbil3@Mt|y
z65-L!;n8}sBmfi&hHqbUfujaYG+4TqYBy9e`j@IUR5AsX$~ROpJC;f|RI)gi3O7`;
zx|Z@bRI=Ifw^Xq)FuZ0w12PFTS=f5A^vG)_!?)02vG-^^{(?b*0h&rZI^TgMe7eEG
z=h#rAlEhGw;@K?^or>9Sp}@dkcnPcsH01!DS7|;V;L+*I(A5kwtHYJ!SgU{nsOi|d
zS3-e-0X+TNssdsOwt@uqF|a^Wx@R}LN9T$Y3<3=MHQ12S6Ugl22X6fQ|Nk{B*uTeG
zSV0OHj<v9Af@b)RwXkYIX>BO21EqDLv>ue!2hpGqEZyY+o$7&lObldw_YRQt9^LH!
z1w1-i71$UUJiGfqiN&M!B!BA-R!|$)mjTRq#tKS8>p+q|oh2#)KAoiuo;w*n{QrL+
z<XcE!bTc&nU@lVe?41ZIF`(INABb&u032=z9iF>DsenO&fx%-p3us2!fPrB@NTuUm
z4gm%R$K4DZ3=E*T9Tyc2SHu6VhEL$*|DL_AAKw4}?*nRT1~4%&`1Y25fF>S@1Dw2j
zMZ`TC4?VDFVDRYm{sA(^Mg{5|pU!VSop&Lw>3ofF2Eu6`-8L$|txrl4yn1<-f?Vm{
z%d*I$`N0FQv6_c`I{$%2G%Y{zx7x6P#-?BRYCiC6KJdZw;v0`0e?aY%|NrYf6_0py
z`>1gEXg>64JotwlRDHZ;@;vy0*~juAf9oq|1_saG)*mpB%mOu1dUJnZ^$3Fl*du>X
zJmS&$&bRXp*dxB3k8ykCTS>TAFV9w}M>at`Vj}LLc?{GK*F5E6d5yodnHlPl51!2j
zet2GdhwPDKKAksxG(UPAL~_3t#QmTI0FH>a=&8US99oTs6dXYD2r4)r-3!ooVdqT(
zF8AsD?%Vms1Ju8m4l=lxXD!J6p1mxqAnq3t_dtn=&!BYB`NC84g~!FW2)BDE9tB5&
zhvrL<#)F`A2J?h(=Nli(gC#aE6PXxb6Z7EQcIJ$4=QE_3X-fMCn!*3-+1m>9Y?JW+
z|NlKZ-+1g``1Ak2Imm&a8N~Bmy)2p@px|RX>&tlFV<*GE|No^yD<>FFdw`IS3WsNJ
zCn%AF8li0_e?en(;L@;RFE~4t@a$&+_vBvuIL*x9(Os(H0Vy8AvFroMWWKEjJi234
z1bn)|RXKla8mKP{Ep$7<W$bY<37V7zl|Pzbo(Dt_6pZkK8eH`Dx@$C_U|+#sVh9n3
zmgB@w9-UwlJiFOEx;JPrN<e0$p-H&ef}uoizX-@bkj&qC5Sj%I4|JXb`^cj+Mn%Ho
zxC^L!WMJ@Uy<Ni5-QDqzf#Egl&V%xx(umEYdq)O?0E17ji;9Hdw_TvF8CYxQQLwFG
zNw7fcTmIHEMh1rcpk_I=xbaB7VE7F*xpyC|#Iu|27z3kcH(SFF5k?6Hh7v6T&VvLv
z$Rod@p7OAEQPJRU-3W^F<|77p2UD95vU_x%ecAgH-kOD0HT!n*LhAsJ=Hov+dwF(w
zXdd*@eE!<bqwx?ZuX}19^6upk_h>u_=5=0x1{_TPc7*=(98mopn(sXhK4<d8Xj&l@
zLoy&ZD9{Z2DGus^LZS&x>KAS)V@XiQ9%5edSu}mDd<Y|<84F4UASde1<6!+zDKLfE
z{(_8`p|k^`so%4kt$D`}1_=g+I&ElD@#uUAnzI5M+iau4R3qfs&6WvP^nw{0?!Mi2
zJ3&dw@W2O8{*C<(3<3-#)sA~WLav5yU#o-N0VDQnfd()jf#cYGl+m+!KS%>ZiH&3P
zU(WgmpC=Fpk@c1yF+A|Wmw)4OkV&Q6!H$JyKctN6+0FLBqp<;`22`tfcC&SF@L&*N
z04)pZ1SLU8j6zepXE&SUHpcD^K429kg3t(o$~taigtoOD8}@^Tvr1UO);jWU`v+!p
z9yC1Aa<YWovAg{N$Z({#a;dHds6`E(IlydLyBdCj*<0H2dOFl*u&HOxyabgwu)sub
zUxM4$p^hP*ouCFbwDIK$YS6bHDCOHP1M3%fcCx5=^cMX0Xg$W?3K~&@4#_DnFnIOa
z?DY74!$a}7NAvRszKs98dU-a2d)JKTJQR<4X#Rud8?bv?4)C{p1CNyaKpolh=~Zcj
ztOR2AY<$AN@c+M0uTG<9<5BRaPUBOM2&}<d;teeiJS~s%w}Cn@o|Z>^_?;g3biVV^
zd<L}-)&vJx30i03(+Mu@p;|$06{cc?*FlhYXT+hk#0Ob@5v&<wc)+LgA9&5#L*LF9
zh@nAnU?aHb?R#(#AV&{a04Z|N;|J0H_w2j^i6l^yxb-%FM=WTV57PBkU|{g;)!E?L
z{Pcn6E>Kea|DTz`1GH9!fq{V$)KCPafd&Q!Xji?4fx#0pVg~Ab?*!{e{{P=Y@up|<
zGj`8|&$K)_&-rqm^X&HL@azs{@aVkeWB3ge_btqzhEjJZ2UG}Re+{ViIL6;10g)8I
zDya*Rl)x(K3i3?zVMfnRd5_MU9tU4)H9TbB0V;kyE<f;SKJee8^RAELQ4htV-w*$n
zXJFuO@c`*K_}ZxPF^KPxd6<ELi4mGA6BrmgI1l=Cs=V}UKE~+T?F#DC@V9~n?|nfH
z=WbUH&}z5VT(FZ|1;Ctj5RL?x^PZ7`0blLn*;~cvVfl~0`NO~e|3N-dJmz6}j=$|8
zh}-&_f9e5`)>r&f4_RE`Z#@fIeX+^2*NM@?@)&>fZIF`A3qFbmz|D{|ATFAY9UvVI
za2>}$N)S4>gScoq7K4T>y+Q3Fm^JG_st}sygSZGy2Q5zUw|0XxiGf#0LRNz!5|1ai
zh+=3!PAD&XL1uIw10@BBG&tVR@wc*rg09z#5flW?%%JuVM81KM!K3vAe``C)q9RaQ
z!=`%%vhHXM-7Qi7{{Qzp?h5LqFnD%DVyh(xms^g5T6{3KfT|Q|nt-~cMG|5fcs;OZ
zw<|chTLf{Lb`)e<^C3nb%WM42GeJoX#b+%y{({{m0m@%5PyYoqRj>PWp7!ZH>d|?~
z<KQc;=11(Hg@y-TYBfJ(_s~4W-@ynPvG4rlV|mT9^Mz;UP5!nBke@pb`Y4|C;5^0O
z!pFqG@X`f5^i0SsM+~#9K&@JYSy3Rf)WBjmoC9jUf_&G;3-XHMK_8G48bR9r`~f9x
z9NH>D?z6nc-?j&=3hwxcAe}4zzybm?if81}dB~^psE^_yPs=IiLF4}X&2vF@9B6X)
zrC#$xriPD94F{PT9<n$5WZ`c$Wn^G@nFO+-6BGit3@NVlXuZKd<>1R6P{e@EGV)YB
z;A`0ewZk9OcK{_o!$1H3zZ8T7v&X@g5ceEIa!+xvPwNTK&JX;pZ$OKlo`DQRj%i3#
zd3OHdZ`}n_0P2{cBrGHa^Zx$-|8f&(5Ea#g5B#mBAgL~p6xg-84G)<ecY~Teo|hkc
zcHRWL;e}`CuTl>m%WGxM9^Y?yT3#-*MhXC=AZ(h($iT1>7HBO-j0_A7KbiPjU4DbQ
zN54EfZ-N{JE9;CIL0!yJ4tNd{0QqAlB=$TGzQpMk{?=!|K;8Xo{B3tZ%NoFL;%~bM
zVuO7F4oxI?O*+_e5@a*T{$KnpD}Md|{}QxL9pVd+J&+Zrm!JE9;$|w$^d69j-*0(X
zUgvLX0I?yaqr_;&umAsFd*d+45N47FNH^3Z84w#{5-1fSxwDz^*Z=>%o#h^$o$dj?
zo%s$vo&S-`d~jXvfmvde8hS#?m*Q}gB*5P~2UN~&XJBC1$O22sS)ihP7LLN8!Uml4
zz{|E^dA7vobp^zKXyIBs2^3sY54M~v^?d32ACxx_LgNi7JWH)XDaXtM?E5l3tS0eK
zKG<@SzlHJt|Nq}^Haui*_{q%Q%J=jCe`wk$74z*Z6@V9xUw-`m|MDIv7{R?{22e@b
zdECeFJJk2!THt)CFeFsY7n^#tUMSuBavC^;AM-f)POJGDN+Ecz!qUg`dKt)@KA<x1
zT#4`NY`9C0`6wRqwA=#D!o^!aex3qyZY!w7f9(QM21-PGLHWkx@>8GI6Q#N!^E5oZ
z-}A8iTBZO|V+4vigi-vUWXa#k11kO@#eRu9NQL1yWN(}+wf2M*_eCmDW02Bcu>it3
zhyVWn|GM0x^+HLJZ)d5*%X8mBF@m+Utl$U5iMJ=Xa4k`L?Fca$<O$@M(*mhdg~psL
zL=8%L2JwN{-~azzIzKc&VD{}SIm+-d^!xw+$Sp{e{u`qG2p-Ar<WceLyz1Hc*|YP9
z=YCM71sVbbPbAxdsuD<35HuLot>D>wgweNC!Kd>fmgbmm=QCf$bDoOF9KRm{wZHgV
zBtgTKkOD6OG|&6S$g%MWNXj$w2&if1*?Go?^8qxh85k6NIA3~o@_g{@cChfYb}%TF
z^XWY9(|OpZ^Q>>@J#e$w7v#*Bo}D*9YJ561JewUXIDES`K+f$jU<A$I>&*86wR!i0
zTd<%uFQh%nz{ubMO{)wH9uR+mQYplH$^ZZRD8BS;e$4K9@UfOB=V?#Q%bwjH93HTi
z?mf_OS?fRkmYJX$1J>BR=L72Z?S=?Jnz#_5yAUBr!xkd+9~79)M;U!PHGDc>VhKN=
z&euMQr#;$lcqoFFQagS>3JNOz7Je2`*u6D!Y<vn5@XS043Oi81b@Qlrbn@KrY(C8B
z0c+3-fmbKQGI+oWc~ch9m@%Y@)S3g~fLl1Ni$Ml=Yj}V<(486{SRLi5_|jAHAj~P*
zp!V9qw?+_`cpzK?iDU)_2d_?^6QD@>@iG8Zxj<va1vzFQyJJvd20By<>W#o-#uL0F
z2|N{uBaVDA<LJK!D2`5os%oS-`p4e_+MDCi9SV=5fBY@{XmRw9zr~2CIQonkM^iv!
zuLsfN2%54XT@UbTzfP8$D6!Sc3|dWq6k8iXAq;KMwnEkhL)xRQilC@#J|ciz9ijIn
zL2J{%U63en^X{6D;yF<JyUiQaj%z*2KlQLj>mg7V<T8J&IjG(77bMYJ59zm9plZ?t
z$)RZy1!+0~l7MLvL)F9%l0(z<8Pw9643dCp`T}lZz@7K>&;S3PAWa9s&O2ankiYdJ
zNK+hGQ;iD5eVX7F`86NKZ(vVJfr@RAE+kK}foj`pAPLZ-18`7)ggiRoy1s*qMAP*c
z<f{cJx<Eomx~^c+bpWIbRF{JnIDqW}2_fm)2-Ah+uel&yCZI+rv}{96d_a;pC?$2?
zczFcWaOphm+j-2V^E9~Z^8}62e|T8~Zb%>Z0ZqLkkJ;}57u}$87H*DDw~GqL%LCxH
z<uM;aa5>Z}3QFU>{*aDYASk&(GB2nK2erNSgW7;vpve(XGY6vQ5wf0h7<yXffUJOa
z$2_2^w`B@Q5Mc&r?T{zTULi~~QbEd(yMjAm9+29Yza<tVh%f`}_U7Y^KA>(kJEj?W
zAmzthAzd%U-=H1`YCs_h8sE;x;NXF7*89)Q@X{KbDj@;&kH1wF6cfEZpu~5Mzu5wm
z{ZK>78I(kuIT#qgZH9Y3t^fF2>rpgiU}$QQ2U&t1RN^2(s5k%dw^pDS5`<~UbBI4t
z!|Far5MjtJP@FX%Vf3+l#^1adGpsg%l*7Vm@o!MG_pDFnVMMdkxAT_g!Pi=j&5zlA
zG;i^Dbc1RZ%YUAoH+(x^`gUISgr_+EwqGDOb{_QD2Tp{ba$NBvxZ^s9g@NJa9q^nS
ze$$`hG2II^UXRUm7FGs^mpWisL@VnyimO3w5Fe1MZ}YeDgW9ujCweL#^Wpr&-(mtX
z1k|8Kc-^NH)et>a1_qcR8-9Qqby&RW1~O;T4^Tkfg0|E=IuH4Fp7l{Y<<oiC({joQ
zNH=!_sNw;4KM>vAmlHrOtWNwI7lAZF(;#Sg?F6W!D*+99SQqv@*t%l~>!zdY0&TzO
z{K?<S0BXdqCZxR#m-gk~|NnmpYEbxgUi3vB+_;Yt1@}Ph40x^YWBJS%G|2JWxAPQ#
zn+vFk2<qot1SglbpyXlz7Q+>xpv^}<md`vpZ}Ydk`SJh1r{W<W&P)6)0ifW&4UQaK
zTD`#02+=wntn#3bBE;e(knZLmpc3P<Z|6ZoQt<7(i{hCu(5ySEXHNKbzV__A#orcy
zYGxtGOdD{5xaiY)ACV?}6hHZP9!12E4=8t{CkSxM2P|j=N~xWPd@Z*?6Oa+83TVCH
z*?ED#^(814tiT}#>iR)Ch@X5qkrIFesF49u{(--B0Z2JFC>%O3`*z+%bJIbDoBn~K
z9Ws=15R^oq$&L{;dWWqDXl?)c|NqNRpbj2ErJ|tjf9co%|Dg>eNYw*NmewHI6kM`X
zfBygfQU@dp4jbeSlSikG3d}@s_Q2xK(qJFUe`S8)9+iknnJaPtoPztlsfYzJjDp1!
z{+1Hh$ja_7pfqzHRC2;v+!sLM-5JXPtqDQBmCm31EiGUE|9|-!l0?ut>BP94zttIJ
zmE}MFHmfiH|3iJi-=+)VfWrb3_XuBr`i58?|LZeoGzt_|V0|cI2#q{w_}%7jz4aM1
z(({kM?c!&st=IY6j)K@=&FGdkuloG||LX`yxZ*cC4Q6sI$TaZi1b<r~h>hK3v(KQi
zHNwNQ(;>jKGs6MgJ3NZiJo4;(@lqS4AL<EkVucqrh?<_iwF49vCqN;9tQ0)h7Y`~G
zD?x#ZEalq?&E?3ZRDzU7gOq|D4Du~_<j&*rV-HYc?UYaJ1&H+sU8SKume0xpz|nWH
z%mWfmkU;!|NPj<(hVh^#?1gn``CGhUiSG?KMBeyzo`QGxKuc?V5Q&e!Wj83Y=YvNg
zKm`QIk%$q73!q}ObtyO^p7FQM0R<j3A|`;?V1I$iA4K6(0W$9-DCoeF*vzwrnP&tt
z18SZchz-_)?%QT=P?D*H1O>8r9-TiuJ8yvl5ghvPVwb=5=_gRCe8%5)=MywlUgU4P
z0Agdc0+bc7MPbX_PZ((mG_Q)>$wG|zff~c58SqBzd{7`DCldZvR#1}=GzN>*B-{p?
zFMzirA7N_p1$A2PfMT5GW#{kz|2ML{WCC|}5cSwi(0BoCw%{yit`t-bfTqttp$2c#
zctBfSw?K=}`9Zy4cxZSi{_?P#avIVCaRUt%LR}8d>HMHEL})?P3R<=Pax%C{io*qW
z!7g~l-=+q!16GTIg6gFZL<}~ju82t1&CH;QrPd2z+xS~S2TQ!H2m2J3G97n-M({i@
z!v=*wEy>msrS70Y+X+1MeWA<><Yh=}2ia4g0Zgb5TCV*@9>$aat?2567SWK2J<$BH
zPiL$Ew4(vj_wL>Q|1W#s2^Bdl`m|mEjiWv*!#a+N@FU0>{4Fd0B0IqK187+hcnGG{
z4ar*m7VQuJ|G#txl_1cuDMol_;#;W?Jf*dO5>4v`$k`<?%RvE*r2e>%;eDUh|NO19
z5h?9Fe=}&-3pDK7_i`C%Hm&oZ=fRg+j?E9*eIT=`%@5f<HBa()z>||a$Xv8$wkPLF
z{uXd@VuZ?qL;jeD;y(||EzsnYh>@H?!?VypZS@4z=b(vak50tMFCsyo<L>|^I3LUB
z{B3_h{)Dy$&+)gM10`cnnu5ppF(1Wmp73^%95gwBY~yb=1?9cn5EG#FD~{x32}({T
zp5Jf!TAnD=K^TtgDNu<4^FjMhq&gllb_QDf=F=G~0a5aD>l;X?05WF+s{}x4M%Tyk
zc^PCF`ZMY<G{PewyZBp6K^-zk$G5}-sr*<2id9HQu1Fo~SWm@cuoAgg*r)XZKO_i@
zKz(-`P(-y};BNs<?||I+^5|QT>mVK5Z~U#G#P12|MHeA56LORmE2Ffdz@|fd%HLWA
zs`NY|c0k2itibzwVkKU#eGRe+YpGF@;A8pBr}Hp>8#tMQTkR#qFZ;j|hE)fDM<ckL
z0d+Y&JAd-GT?T~&ys!hcib4IiiJ(*h8svq94O*u4={yXY3U~&J1JFDYJPte+k9l_9
z@PQ>_NF03p2^vVh(fokfr!(d#!^>`zcy$CXcJsXa2qknNflvxbRNyk|5>lc%<kJc1
zks&&OAgdsn_*-?pqgt5r3N&($W4s<?y~hnuG=RL$02;GLtoH!-!WmeQ*L#361_J|V
zl?Qxy$OFQ9{2y(V2V{vyDT7DnchHOu|E|aS#RWdC_xW2|Km`eGVD+0%>plLK`4Az<
zz$!!t6iS}mp^(9Euuv<gssznzHA7~AF8C;(0Izgt2gN?p5(I;T{NUvzuM0gP-fCcA
z0NXqrY)vVLN9QLW!%se~xA<EQK!gO4gkC~~B;Z1&nm(47id8&1KR|3Olk@=DcF?2s
z9skq=KCQ<}IY3r|_GEYvTxxO_X{iY)i+hl^)MPVgKpc6g$t|#J!PNqP>n{igQo6`8
z;a_UvV|kswxfon?e)3T~<zab>zbysC1$pie#B&yh_*(-&GmYE80UrU92Ce;o1iUAR
z3sQ}=D8&?{x&y4*79@>Otq0<wsRj+dz6=MIz#zvYfK<RjnZGR%#06;pImUs1>Tw_N
zBC&t}|2r7`;%`y-|Ns9>UC<z?<t6@RbC6<$UJVczL$44_?-NjKi3O&Y52P5O_djSf
z8bj~PzfgNufb`x5FUf$eZb4)VNQKJ4!r%$X7R(F`FF}6v0MBcJ5@9RoFfLHgH-SP5
zQrbY;vY<W}cyf}z8KmVU6SzYUS``DzBdyQD#n?6e<}^?wLkIt$6RZ3!paE*nUS9!l
zkq^l(O)w3jpbUN-)FuKga{(ug7SPbNXRogWl6sKa!SSYwQ2%oGUr^Kbjt{7#e*(Gg
z{RCZv;-Ptsze50|!}30VQv`?sn$D61t+aq_7)2Dzprz*U<tmY&;@<Kae-mh40emb#
z9!QTZDDZJDamj({;R2}w9VO5R(t~$FNexWT2T)@aq-P>X&m#~IY!75U_nfEYmg|s)
z?FCQ-gGwnJu>)#tzDxo66r$f#@u06|4^;DEkY;zVB&<COn^5+!ykBGmol7=?n|;g|
z)K&pm4~~4#&Rf2nkNKNeK(P!N3@DL)DTd(rb{>SPX$2kk=-Y|3^a8YQ{pD9s*npet
zD76?Us2_k@2hgt66%ZS&3?upN1hoJ_D;pt>#4x4@q!nsR1Bi{?7|>w+YkM4KB!Ton
z%?JarA!b0r5*!lz&351cWkTyHKr04(TJM+YgSvT^*L^z=f&=g|I8%e-0K<PLKxNc2
zL~8cXyjH;jik%$L0d|V7QxR@PjypeS+_^!djXb*{iwQhHGb{&v6wiaEZzdn~01XsF
zBGDdYB}D!&_)3Tpk=Gi~ybF&{wAB%gpcZc=IF-VDsEzEyqKi;xfLEU&3Xi5!Am44l
z;yV|J?`$FZK(UJKJ2j~9<RH@ET+w;lL-8MM%>;i_0eE)HR|2|%qr?zatUWK)0|lQV
zWW>`5G>!$Ef%deV1IZapMxf%h)9_^mc&HuLiU)-~zlY_0pU%TY?jQ%Mymo-N0OY`3
zpi;}@@*}7Mh#NnZ!QF^t3na}nok3g0@aqStEd*M}fTKMGTEF1gc^bTY;k#$&Pw4c6
z0s{kRJwQtnDCa@ezJdnVyA>hJ7ZmX<U$}<6e4!9D2?psUgQnFEqAy?Y;5-3s2qLdt
zaJ2BWb~Gqe@##G8+j+*P^Qv#>J&(@M;3+(h&U@e$46l4UA9{8>T7XwDID%F%Xo6ha
zF_#Inc3Nj2cm)Hbp$lroL7GB{6%2@V3y-1e7M`<v9(=Cl$$8$h+mpki8{BsD?fm0o
z_}`O%*HeA|<`_^|bYAypz0Th<A2hTJYsEbSO<T1b1XWnD>2ZkAeTWdG6$ch-1yx@@
zmf!fB!Rw4cbE?<CGqHXk!$EVZ(0NXS6a1~9F2T#Qpe9c@#BX-sQPE!>y*kst-UHQH
z3=AmVgU%>{8mZ`${}7LQG(TeZIQU4*gYy)UM?E{Qdl+7adh|1>&S-tk-x2_EKV((%
zKcCiT{4I|lLXfs9M92y>whe2mf`wZDf=mFd?fe3+3g9!xPqFy&BB(w}0nM~Q;s~@j
z78=ToV9P))*6%)s&q4k377d7y0Jvcd5o&-4NgxT`0L}h^7m8@&StxQDa}feNXlerQ
zB7_q@oiaB-xd6Uggb6$qkcwC?0@|7c9k}Li^#si;K)R&-tvMj$yEQ$)%SAMCEf;y^
zsdxysTqG70xaiA8pjigIC<2jxKnq7Mcs4s){CEj!^Y~bP=WmVx*M^^b6fc1rxSp`t
z^h2Ok=Ti?`+~S8Uo=gX=afXM#4=D1_fs;5i@c)B_zCwf`fe#UqK@NO~kTX$%k7Wf&
z8EBFVZ{Q#F>6Ez%>UYBfzYsL%*;$JS{28DCgU+9~?tpN>jlR~~AP#}mAK<KM2CjCl
z`6xoNraEkC1=1o3VbDMcxJU=(WeHRboLDq`1vM%dL3IGAslObo;ggTzCvddPfN4OA
zmKKl=zTm#WcmC#YFb$A+d=Ara7#xp>z+Hn&fByeBxXj-&`|tn%FOP!ew?HZ2JgUwE
z*mSOj>P!UboCnr<jlWqGtP`Gh*^qR?7QlQ0`3lq{04KI`um*Ty%Rtg_jDIS`k-<=_
zKpuMO2D54}xCsQeY8_~)EvPU=3h`MWt3Z7!uvOqC0G)8F1YlMj1cwKxSIXb|`}hC<
zpq^<rC?wy3Rx*Hs9<(F})VGBOy%a1*AcrLDUr0!v1BJ&Aup_VYH#5QV5+u?<OLD*~
zZjg1}gL-cYNGE9h4XCfvd>a-p5S?dWu0__l9jX(w?C9kxn4MctbuNYJME2(dkj{hr
zEeaqzn?X831GT4N`+*TPx+iF7Fn9_CltVjjzDxp7)}Ht6Jm=GS8C<)9+twdng4R-l
z23<ORR5*M)ulaP!sDPz?x@A;+J3sk=wg7v=E7zB&K&x0meLQf1+zQ(D3yP&C&<bZr
zYX;H?z2s>*<s_t+aT?UV(*l)^pyd{jy74l&*7(NX90V$7pnW`8LE5q%WC^T~2hjlP
zGJ$g}Xz{-Xq>l$3j^=Nf0#Og?<3ZGe264ga!E4qb>R;x7R|!EH8c5!RE^}dEVE{EW
zAnP=07#LnggOloUA470q*ZLgn=Ii`T<zR6{gBvuQ4fSgbDCw?(`4v(_Du9;ZgK9`{
zO9I`m9w5VDeuZcNjh2A>r+(nT0ksT4g&w$QYf*)$hxiqu9$bloEQmv>fB6@@H2bSB
zMt}AZa(~tn?6&v(O`u%|9-#hg7-;)JGsqxtpAWMA0=$3~HlZ>JtmhkllK`lF3+iVs
z2kBt~@o?!`3e$5QG@}dB16pwN@*s$ZOV3uAo~<BNAU&r*_ACeSz<R(fcg1U-mRl}D
zQrZ(xwm1NGJ0f<FQX*(o-OB}Fc~D;+LqBNU+RFy;PVA?c0rv|z;OfDSyU*Wr9Aq3Q
z;Ceug+X>=<9R~?G(4krIfq)ZWJ=ge~LO?+U@(^g@>q|Ef50{?XFg?N`RUkbdK=!bL
zc)0YuhUxhU3M!Bu2GH;fWHKG$anOi5G~lL#0uHnV9XSglC2Kd3{AIY`pi`Vs&0QeL
zZD2`IsDpYlpcKsDarv>2<$LHrz~?fQfq+{+iq}B>LCY=RjN{w+j=u@C2MRhdTO$3k
z6J#J{SODD7y#-R!S`6}9XDV#50Dnu*xBvfNUI66@aJL#{Iefm>@*96s&Nt|U=XL(J
z1P~jn45N&41sT%@8eRp<V;Ca=(hBXw^MKf3Wf;bM{QCd@YbQt`Vwmv`v<w4k#v>3L
zyBWv7f(D`zJv=)d13Wu39l(Y2S)@|iv-9Q4MR5HfYY@Q=8+SnoZXd;OC}DlexAP5T
z+yxQb;h@$#YH+{dZ*>F}d7u;3p{=ZzS)g$8#Sz@s_?xOgVFUGJ9*B+PN2K%=3^E4K
zxQiM{E7TY%5F5KO|3SfxYux1zD2SkDd;qZ_W<chGz^RVE`35+wE0Mz*$9(p2NUx+c
z-?#IfkL7nrlH_kH05=ps$sQvugo3h#F?ehST7{H`_;%j%fezff;cr?5mPBYq3Lx-)
zza-E^A$%4PG=5;~WBH!HX$~lzwtg$|dkH$22xa_(zhgCcF!Vk&JAn!&P+R}yPmmsP
z2%sjI_eFu=;gHW|o{(f~1WGF1kZcJa@44lpcpX081ImO=pmoNGZ7<@W31CS2D3N{%
z8UTRS<B%`{>1bUHa#Uw3Yyz3T<<Y1A|6h87iYF{?x?cntfcjhp8-PM}laJzeBnLrK
zv)Mo7DP#uF95K{QBCk`?9Q39%*r&4=;h0OHH5x0xj)6sUHfl6GfMWs?Q;0gHDG=1;
z1dY&xhloHeg;G!CXfB!p4Oj5!6(Wk8T0rTe1Z*(!5Rn<E%q#?r4|%`NLW^6_0s20m
z(PvP53|w1-4i|a30cYH5LgQ8u?uKI^x1p51{7rqJ{0tf*hxA=bB*0#QH1MW?V$SkC
zfAeM#qf-$QsV|j2f@Us30fL&G?iWEuu0A71t~x=p(4Yu}mi7EiU7(gOl6~4>`~Lg1
zzAvrxvAka-4INzrW!27uzOd@ODG1!)wS1`rUbuoBXz4zd?;$SZZ<+xLjn;1^6-bk%
zpqd`p<B*!G3A}NxQ}Ja8XvG0aMoaUtyzkq2kiQA!e^6wUzXSz7Bp5+nhK<+3EiO_9
zhxMm2X^0~9@}LQ{rOu`E0eG@B<tW3;`|pv15Mdt3-XaC4VG>ZoKtTZyKd;}QS<oL~
zlWLAKycGHf8~Fo`{+&7F(Rsn6^OGy+u$^-rod-cn0#Htf@j<>131xp%fM@3!&(3Qe
zpnXHX!Pn#bR)_C-2k()$+2Gmy{DEh){eS+J`|6+*PJ}^I8XcEGZ20J*NAn>@&rV^F
z&WoUxI2aqzulgun1<ei~0`1Uo0WHn<=nPRY;BQ$AvJEnr1)66C6($UzE!5B*NT5-W
z&I=v~Ul^%^bb4eS0PXGZ;QZmyDf7ao^Sej$b9T_;K>n6~UeG%83m%FeK$nDYo^@>j
zoxb?OrSpIZqYMAG1E2$#4?fWM=yXvLaOr%}{D2w6bnxi>1v+mFWXA(7AI=w^-QFCY
z-R2&h-#rYEdq8HtK#OcZ>oXwJ!>xDuTR=+=JX+uLw<Lqcyt>Odpz7hOz>=VKPM+Q6
zpb-_2VW^UzBR@U6%RvKM7?Q1E^C6al1^_MZ^Eb}~CGyVi;G+3Fe;YV$LP85P?%8?X
zv-L0k)PtbyJyQ=GoG#6MIgbHxN)XsNv+=nVG*gb#t>A41INaI->d%2fto0jz>q5{-
zUnjdKC`3T~OCUZd1V9`yP{$Nx3WyU0;(!hsX#T_K+nb{DpTFfSHv@x9=O@q*X6q&X
z)(p^W(@t)%C!i4l3yUsrH3|=lY7iH)FA5wMzdc*;g632`TJP~sJ?vm{pT89}yZgEy
zl3C82IfG_iILH7**m{7t_{~!VInD-Dl%vLy7Dy|?Bxw*AzeztpmBJ^GI#iQDTQ@<2
zo}jAuJb#-rNCn&^aAY6$X#EHFCM02jQfccu{#MXteFuZz{4JmxEM9Vh^r4z83KBxN
z5j4FD&26A_FF?r%hsk%q)5O2|TR@I^2^v2^3rEn-ek3=a1T~e2a`Swc$)K6&mlHwy
zP~8j~_Chkb2c!a5>W6v;93KDpTN6OzJvaGV`al644AKb6+Ys%bse;z?{H@@HdJrLS
zDm%~L><a3S9DJwW{EXQLbO?nq$bg5SAyI4wfJVBZL$@#kK)JyKVL;O-&;ZYIcj%!E
z<pSXP{1vEb#AYDqLMt=_!CUN+3|t2>5WLL=T$X?uf6H(g_#RY(pnCBHs1JZ-U>3wc
z@ctn1F(B~V*_s4u^=NT`w&S^|NPwqpZhCZn_Bi-jtNAgzN9RWm&CC29;h->6_E8b=
z;5_XMnt6H!+C(J5-?|bcfv~*S^S_7XdH(ivP}jB>+{MFV>THl^Y^JUSwPP?%-3~H!
zB1jIyfoG76;%}`2sln9$9Hc)EG^hyLwt?=)XGlhPcD~?mmBMZcXpzIqf8YTq(3#ww
zpd|uEphVnx)kpEVZ|6-<%RSHqf~!DL(^{e;0NSvU4eo*w(gJD+dcd^Y1H~iEf=@o3
zmwgm3`E=g*gfD0XAH4)p?b-Pov=yTjbXdU4YLHK0+P?dCUi4AC4%*rSbysmA*aFYa
z+n}u|t;V2HJr9r;Xo>+HHSS}13=+@$&CDQq(22FMG><CZ!~l}_1!X{}e#>J}*ED?s
zZCYqXlLFh?v==0G43wrJYX=ca7Qf&2w7dba9Gu9?Jdm;rB!QKgf)XYu<&<iJSm3pp
zpn3xy^q{q7NM`W2rh`NODkvCWwHUY_?{wz?*N?5=JUefDcD~|oF#x&Dkr<cpx3Pdm
zZ!i*C+gorK<f8}3h5W7ep*+H_Y}o=@WC$9!gf8TSH6}g2-}bP)#ox9NWE7@-T_E93
zn0+-+9@sw6a62NsB>wpS|8+dnaI_!?rTI2BkX}p+_(8&O3mBn1umvc=-u&!4XvwIH
ziiBsUvxjGAae!}UwS!OReV@*|uz?S7q<VJV0*!2=v=myefi~&P!(I}X!nU|TO5tKZ
zSZV|n;h;X_%WI%jlARx6t9?B>KYD6jtOx-|0%$pJE9l@!jHFba@e*?U3M?CYD8BcA
zWt7?Ai~?S^4M`oP2`@p5Z(#uljvmj;kHAZ6PnE&WzyLWBnowOp$rF?eO07UFNQfa>
z0X}~MVm5yZXdw=wJHGWBC@7&R7F4N}%6N9V3qUIbn4W&n0L&9mGQ_NGN)?d2Yk9ud
z3lV0;TV9^T8eXA@@B-gEfSwl0Ghc#N4Z@2TB+nGjhlCesQ7+Vdt?xl+Lqy{UFi#}+
zK?BST6ina%(*dzC0}Pb2VTMlvFKL4Yk%UL<w^Aj~PIn22G+ISh3EHOx8V2+1{OD<T
z5Nb1M&b{?yX)%-wS_Wr%vd9Q-^(PO-SFrs9#nPDG696?H&V!11q{0tejx>Qn4(uA#
zME()91qUPt>RTLquLbVueDu(~UZDyOdJoR?5cii>BOK+?>-pc)@?^Qq>ojOkf|DL-
znaTJ29+tl#I?B+()6?=~8Mg5J<O8azE`iEISWSW)sy3jquiHn(!LyU)JX$CkfBFC4
zvo~MCquEA<!IR(Ry=U_u4*sSxZqQ*1E-D7dYimz<b{>a%0kl4V^E_w<s^ui;@O)@n
zE`fo;hx32u2@^*CZ3jU8HVqGGUrxcL6VxpRiFtVT`l$Ty=sW>FB(ImH6?8BuNJ7G+
z6VxJUe)t2#aPVY2=hK@j;L-US)N_340J^jhG`s>?Y+?C{zc~>k)OiX#v3`iZEeOPg
zF2?}vKe*=E`kjC3A&=IN{8JBFoZ@dO;sR~6<pg(Cz<mtpv>YgZgUr(d8GtZP9>m3G
zo)XBspP-G?sP1A0X+)Uw1*8I>Ikz|&7+#(OsX{f!0M#5t5ErXC4*XM(L8AcNoc;+q
zXqdnC0|x_xgTW{MmP(KXk1#EG0}?_w^e%`?iUn(67D#|Bm<Q61>Vp*^A%q1pL0nQS
z$bea}or8hlWfVv|ss$+^A%q2?ATDTF6?{0LN9Q5W*6ZK{>n?&40z@k~gg)}OYH~0z
z7+m0Qi2)fc1Jc-e%ERy%G);gz9H01GH9<`_h(=g4(FV7zUg|eLWcIN3QPJRUe#g$h
z@G>4;(P1%SFQyUTt<wjQjA+`!4!UO7^#^FlyJt7#XzZ3Ppp{#_!2+QBp$z{)V;JnR
zfBdcB)3Kr5HWmiZxN9?LX^#hzvEXFTlm{{eG#dsQ6!Ha~ea_#K4zjKnbk^ZH4-At}
zfyzHrlR@*em?kSCOnxZ}Vz>IJDDby}E^dJaBQ(sKoIqjLdCKG9D<hB2bKoZIHE_#!
z%VqEk;iN+?mpnUvgB{$$1X_&*8hG&lnFkhYUCG7(JNO1{<~9DNX&@maGcSOru5Nl-
z!p(dM-iU)Rq!6S7n*KmRc8$L&4kQFO#0NZS32{;rsB(E}2a*Swz~3qfVxlC4CN_`|
zcHN-UBwvEgHur$bV|u%p50o~*#!o>Cf!1T7>yklRHE(+MhW_yE_Wc1mD!oM*6fl!P
zT0j?uy)*Ivt<Adt@1=YO2W2yO!yMd9-_Fy%orgeySX%rt89V`g&f_31y<b3457LX!
z#@`Csmi^icuRlOL>A<n&*$LVZ53-KG^#yocP>hO&XJ@sCXQy|7XQwl$@d#eV08#=y
zlo7O|t~*A>;^jrq>L8@_i)2`H7x?gn3%;E<J$i#VU_sIfK47fdM#ZDk3Y2YpI$wFT
zo`g7_zoi7U4SzqV`a?1lA_=mdzZrC5%S%5rTagvWf!YJ$#dSy~AUn$g)Zd2eaX;r_
zY@&jaNlQbaTyT>8S6qgih4`CYKm${~!2%$MgW?x5o(T60D5pZ)!r!tTRJim8OT6?3
z`34k0rAMLXK!MG^R<sQfKaf+#AVcYs54~0f6(5io_fb6VX}RYkB%S1gtOpszKlM<{
zC5TPnU}<p&&Dq>)c*NZBi<!UG8no)P6BP0wheAS_za<2uyAz9_)lmH$h3aS7|NsAk
zFMS867XDU{Q&2rpiQOZh62iChG}wWy%RsGAJ*@sJ?uVER%1?0hW#Byopv(kHIiP?o
zl?R#R(P;(o_e;>~3Xk4k3D0hD30d+GWH?5A2B7$@ND-t6BV>!YU@mwahwOQXO(1KF
zB0M^+UOon8WKj4cBued3!@>X&7QUcuEZ4xp5%BU2CDvLef|5qJi;9P5XU)+MFG1S}
zz^xnv;o0pB^8W{rsqmT()Rt@g&fl^gl=UIS8@P)31ewDJ=QJ!eW6S<;pta<_3@C=d
zbiRT}a$u8eMY0K;ct7zsgJ(_=^*Cs2AM`+9@K7;wJ$}&OU}?e2WuRemXe9%)bT7ox
zAJ{ByVf>EAxvmgNtj=xe1WER~egNI}0lK~73W(oX`vDv>AOSYe@g2}QyVVE60i`ki
z)|sH5b@O4+fpb4Rn~y4ZHveJgZ!ZOn?1DyJJbH7EGI%y0;{aWhCg7u;qT&E*Q+srW
zs2D)+{d)ZWzi;ak{uUlS1_lqsL!O;iq2U6GHqN8q=J%_HkBt1=4tjtNvWB*|IS_Lv
z2ELu&L941?GoJD3`~hvi%YaNf0i8&Jo(|_>h}4J#4PCc@M=l@@0dN@q<8R3XC0fX$
zYlM23B>4Vb$ntAU$s-V*poQ2NlC4NKfs@2P{^pgS^oUrTJqyGI^|PQ&yK|ncU%@je
zpZKR9GB{OQ3!ZI7q;(Jrnp<JcYlpZ1w3Hgd1uanLffiL`N`lw6L6%ozO4@<iHlPFc
zK+_?h#YUi8TRcEv1QOT_kre<<#<haR8a+VffMndEb1S}#*Fno^J)4jG=WmS!%~;6u
zK>8?9_rpS@1(a?OAp%ZDkPHi+5%>x|7Y!5~7MJ;3L6aq~7l1+mfziwZ?`}hw=L9ky
zr+F$Mhk@3@q8S1|%?z?o7qo8-nk}(7>JO+o<p9+jkW>Zp8R#Yq@PT6xLqKlFVhDOS
z=NEq~X!D(e!Ds%K%^>H=gM5H$GI7qsV)6&@T*qhr7I2I_0u6ein*0VNgb2O6ATDO;
zVKI3#%w*6mzn4ov`cO??4-!I{ya2?-k@62ig9+TJ`NZE^0-Z%!0t)DKkjBnypcD(y
z4$cVY_*->A837^$j)8Oh&7k#$9tU6PgRaoF7E$4E2A`|<8`SK;X2KOr6IOr{I+6)Z
zY#{65t13gmIiTeqsFK2FBKkbaIsWF4AWM)<JP6VZKU*zS0+gp(Am{vI@g)`$K^r-c
zec1#$h0X(ddKhSE1SKz?1&xGH<^UZo3~K#&bYAy>4Dh&gegv<%JkQ?&K31ypB50_G
z!-MlYq$=lcJp>92L<oZi!_M)yw}NIYmVwtX;xrMmU=PE@qgZAy&hfWj1ev%JB!|s)
z_dw1-xQ@RSyl)QET|Ysl6yP%D2f8UbAeES=2!j?gg3exsEH5zf=)8v9YJpCofDRG%
zXbn-}0B^^K1=uH$3m}JGgO(=X&<mMOf#`kt4wO8=3mHJF!LupQJ|)y9aNhuA6LkKf
zwGR}b9Z=tZha#_G(FWPf9iqYk(`F0O76{UYNQ_W-Hw%E|u7K($47nyDkem-F7a-)I
zW;TIlVQ?nA5YV)N6sT{Bsc{2nIs>!@9TLc(B`>g5h901?!`~2>l{rIedQb+3B)>8P
zkQQagHFk(_19y2LAqE;XglOk)O$1M{faaOtRT(6DTtTPFf-*CBkn$IQi#Etb8lbER
zHWZhO_}jn>kuj1@8)W$_B*F8y-UT(8zy^V16}#(Nwu3?lRN8{P1etL{4F&9TE9dyz
zAag4)+aPl*uoMUB{zJl|89cWVhueI0kV7$jBLEVHW;y;=CMXY@*pPhF{2V;B0`47y
zrdEOjJUg>Ny<^zC3TUS#s8@_pESZ6(2>xI%nM+lXqTTXbaVT<W*K7}}Bthdwo}CwA
z^D2<C%v1AZML5W>pyUCbT>*`vA(;h9Lgm>n7l6__JbsXl8Y!Lv$<>e}cy5D^dQW~S
z4XW$GszJ#DK0^hbU^#&~!E&z51?C9Q1Pd%)kZeIru>9h0*$e8Y!jJjh0G?ohrdUt{
zEtT=;bQOTMw_vHY3lw^1z!NMObw;Tol8-IV6$c`PUh(Fam%uYDSVArW=4f!pffjlq
znF9^E97wMh92TIIjpV1|8IX{J&$ImEZv{0tUL&PG^q@nV8t||@2bvmyB<oTgkb59W
z4#^tuG2zf)Xl(*dwLk+4RFRgdcyzi#rdobsB)P+&g_xb7g-M+kF(zAF5T5n4JXu_c
z6lhS}nnb`wwW|b%!C4@KK?h!YbY6oVrw&Pw9-8MWl0e=7B}fm>b5N67!DEvsxehds
zQucBau4KvI3^{cOQfYvW?*}DK{?^7n|Np<P2iX8AKHvfD@%^5s<p+p;WpN0<LFa7B
zyg_<Et}1l|u^_?h(|O%T@fvsr26~zhs4RsT!ruzo#r0YkBV39VL08Bbcyzj)1@!_M
zQ5qispZ@=UEeVd3=3}T*rl4h(%|`-|PxnGULfNPDzAyALLU4D|1$2fkV!X|_^Yu%e
z8>p)jVe1niApsiNKwqMWvOdu<+%XJv-@Iq%Ki_UO&~8lMPBqWY@7T8`dqU2A0}Ul9
zKJ`>Q3O!uCB*PPPKQbhGL2C**4?=sp;GM}oygFH4dUm^6cv`y|l=Ap=eg}^vf<$~e
zEj*juEI4rAPXtr_x)0GG!t@X5KGuJ}-FBc3nQx~Z<Z^ZN3wxla;DP<}$5Zi$<M-pB
zRgWcpo(JC>fo=l_T`-q<9J~Y)t6v<vI$0iq-1`IHjj3=KuYkE26yyP(o##M1g*!iZ
zbpGrD-x}L;sl?8s^<;?(=z3Fmk8ZG_N4J$n^KlMvG#>Kl{OQ~I0UTO}mwY<^`*eN-
z+Z^W@|MK_}Mh57;O&-u|b+3Z1);sA6z26IF`<XK!`$172?Av+Fv-7-X=M~4!uO6Mh
zcQ7(AFnr)Y2)+)m`3H9q&weJ@^;-Pg&|9WJjuZ6gyzkQa&ZqMc#6|yM_s@Zr#NKo1
zeC5;m(6{r4Z|6s_Tfqdvder-SQP#&QfKP7qQQ`3D6jAZ){0=(i9&*PXcxDlLw=aLI
z38*0IEm09b-0&NtBH+>O47xR`RM?|8n*+356?$VUc!z7R$A6DbZw{C4lx7~E&IcX`
zU-0;Ln;diLeA@UFa(DAn7U*CN=#qBDqrROwdXD_t+d<b2ra5-H=<zr<?4Ja>celjA
zr&~wGxAkp_wr97yg{QSUI2l9FaOrjjZ=~;bw*cL%>e=aT@tVW%_G@FX((ZB%56ust
zDbvnF(AYA(ZFmwKLZFak?vCI98O-Y0>~8VHu`@=G15~(hcpQAm?AUk)bU`&VD;a>6
zZ>n^_V#V4;MWWQiqxpyezT(92HZ+X*TVI135tl(dZO9#QU?)H#$)odv;U$mG;~t&o
zUKT83WWbWYJeuD~c!F<agE;`S(ih710bk7kzlqt)qqjtb0})dtDjYtY&wV<7`9RYL
zR2%5(M1fKTkLDv1jxmmLj`5h+$QgcneFPe8NbW^(A4+->fVz?KqQ}8k%!rWl=#`n^
zaqtlnC|EsuO+e$63?98U9Uhj~JbGO^SUmV$kAqSihlk}2{<Z{APp@~m1cLyBXYYCj
z1`Y<p1IYIcyL4;2f^H&J2lXvFWmJwcGcYhPyyk#}=9x2&-$9o&Iq<hSgOY9MYmnkj
zeI`%@zHNL8x_aEB^M%L37hIm*EyqDuj(5Ind<dS5=;i73IQWp&qt}MRr8|eiz^C&Y
z*x#PrZ2}<6Y#SID82DR3#&2MBY-3SrIZy%$T(F`Y4j@-BojK##-3M0P8~ER|a~g>0
z*xl17!o<Mf*gai_L4W~Nx*UAR<=MUEJJ|a3jn5(0+wAu^_?)#<#Lls^AEc0aCV4a;
z_{ZN0+JWPEj75b3=Am8>M$b;LYaKh+v`H{AFu1n9_2|6I-wL`@>?LS`<;)q-)f4~!
z+k1Aqad<#O0JL6v17n*j11JDsS4TqvfbooHw;zWG*z;i=j@>?eJdWMdSr|B=-sbV_
zHu>HO@-p}a_vb7S?}8MNtr6tA(vD-Ups89n4iB)e{5V`YbJ_$pFnV;$sCYCVX7R9&
zQQ_ck+6S5hVKO|R0=jn_?|ll;ln*Q3d89zMYho7fsO2lHu=i+wqX0g!?W<?!e^`#|
zbWxE&zpVV2<F{k{CDG8!%0c(NJ05Fc1KlqUy04rKc3(Lg?7ng~*nQ<}u=~o{VE2`?
z!R{+(L%XlM4P=~;<%co_@O9-MU-Q873W!F%ue_AOr?UoBWTdDF__qEp;dJco2bIaM
zAy>d6-w27g3YG);Dp<$P<KPP;A=2QyVR*^#q)+E}mrlsdmay;um!fi@QWSR!1R4uq
zV?eG&yAK@{-k`9C83_tv50D2uK(}IhwEi#Q=mys*uUU71uCRsPxd~d+-@OlXlP&+Y
zlc39NLBrdfr#cUU?Q!fp2Dy$KqyQ`eGal?>S(nZaU`JyuG%*~EQeJ}G3u+8_G{13h
z?EH#a<66M1>1OchUI4Nje785~(qKW*J-33OWyHNMpxeG-m&yC6WPm3@AA;t-duvoA
zz^w|$cJ|f-r8=+8Kp}RVMFmtq?hj^QVAusZR1vhRm%-KWfUDt2@U@j-AMOCPJs|qd
zf$pdW?K^VmeCg56a>BE-ZO1<b2L5#)3=cTAyQoMs|6nRnY&}rw4D~B4i)=AM&LSxG
zHZd?TfUkH(w-@GRYZn!ZQcI8KBMt=90?fLFMu;nIp)LV?1>|WY>=@<=O?QUhd^*27
z#-Z&Xf<;LHxJ|xq#y`*rLjOyOe7lz|0JEQzr1^A%uL|`99j?>*tyB<k5vm8MQCG^~
z(OdW5qxCy~>thDw9Y(&4f4q8mc6jx&ECAnt+Wg>w2jh9rZYag?kh@UJxORaqg$Fy_
zw|n0Tu#Nvq@_f6OZ2+^Mlq3;rdub-L&IKKUM3T*p$J!?UV_;x}#YQ&+^!8rI?rosl
z4{rBDubTx2A98qu-Hr%wjP&l=`ES1l8v_IU8eq_pxZ?+I{QUnPTHdjPq(S8!yCx_w
z9FMiIYrz=WFoq6{p$lW^!5I1=2B`g4y2<l6=$>r`s7D$qk{C*4p&SpeuTFq!;BNN+
z0-l}i3T&WZYCG($ADE9&{Sy{|?w4a8P`|K2bb!iln19${{$YdphYjW*Hkg0dVE$o)
z`G*a~KOnym=btu^e?WKUHXq?|jKgftLEHz9KL`^{BBy`PZa#2v0vfb|7WKZM#&_@D
z3k(trphizCh|zMOB*Lc?)&g$>-$K!Ppd{cmGid)&ug8DS&OVT!V|PoN3=62?(|d(M
zf&sD-lFPGu%GC=D0t}tU8lQn1J_nz1cJdfGcD8~Pd3M9hE8XgNjGe)=+eQV{CxbP{
zppglVSqW%G1C3M9?roqD_#eOl&gr-kEv)=_gLIWPI3yqhYJ7wG>mi`_w@2p(a8=F=
zDojCZEd?B#>tz`DTfy58pqDduTY{VlO6ZVs&I4Mbcy=E1ZT(h~2-Z>>2<`cRrZSb;
zeLKH6cKauIc0z8c^lUy-;oDoE0PTI1hGVwpJsOXJLKoa6eFV;ZA3Ph~IR1f#4Wa!v
zYZn#5jr;A$xftSk^!tXvi395Y3nRn-9-SWyzj<^Xg5?v;^bqP85)4Ta7eEW_K@B{}
z=s{<Q3M^H81`T_{hi_1a7a(Irj^O&xr}H0Z<pokY=~jmf3#nrt6Y}YN?4$VF19pNQ
zbVvxY5{1yP&~cWVpwtUVh2FlMUwoDI9lPBVd^^`12dydc?ab#uPk-q|r$5jEJ<!|<
z>0BCsI+yScGG=)MD?(m^)^r(ud%YZMdK`@pl=5ISK1TBgC=<iWYgjo26F@1iP{wBz
zzy&yXyb(0qA^|Q3_*+2-XL~>zxS+8+pY9Eyu7_v0AEav`58CJ4d<@pJU~4^4YV_I$
zX4{!FDD8YK{R_w#3bcO#(tQqOi%0hikS)#C5)Aw;*BKcYx}6JJ5Ae5eFfuS0zJ0A_
z_}>vU_zo+XJT2S7gD>Fo<H6Hua0hsFcY``BKHVxW!Hd2?Q{|4$H7W&6r6!=B3}~m0
zPqzkiQwFHcRXpp_?NQ)k`I5g~8a!c}Q2?!NOT=Hd`F5{Sxxm1{02ShIE&Tugzu|vS
zF(~jKQqFhRs0d(lUO89u0Y=YGuv0<hs$+L~1!$BBRJM9{x@WY0E0OeQJPxY79r?G1
z*S%<P04-p5uK-18w{rpLc*V|x9+qeMo7DdQ{}1hPu~DbL1&Ifw0$QTf8q|%27tpbo
zB{Z}^hP9YLH$3@vz5q8lpi;<em@+IKGnmvNlrADT4pGu8xV;hT2x@USfLmPuJfKah
zP9GHukJd{ix`yAtg9#p;hah$%T09o~E#MngkcL>Hx*IB!82DR2DFfb@s$~E-)h@Xj
z9)Q)v-(bx(s4kD@g94zI9)~CBy2cU}1&`w{DjJ};0wo3m#271R&rf#)sO<^LR|1~h
zZ3q5=PHX^e0R-L6+PwqTLhTK=@aaua;Q)Ez+5Z5I51x(g;D(zgiaMXpXa55{z=P_T
zzAOa|nGo(KgF^>vdk)%uv2g4>>(O}uHt-K`*cv!~J1W56st6iBg#><=XA<awXz&_&
z$Y~oM-PWMsLk>Kj&R?+b^Xxq0*!UE50#*qRD4*!81he%)Y#B%EHc*$c)ck{Iql*gI
z^GJ!(fWHNFXU<Dd4s_vs;n?Y-qJylh<RnaS^8o?S;!V&Hi3DiON&yrp8px5N;em)0
z4x~sC@aSgtfX9hX=Od5iLl&N$&tVNRNW8$^hNAW#&Ui5>mG@{qVgb)iICB#$V!){%
z%Xk)Od<fLOBoIHKAs=W$g~ktf3m%E_BLWIsNc@y?zyh3hK@3Xw|L7aO;P#{8Nl@9r
z2Wff38uu_78WB(mr948ZKLb2EuY$%EIZ%h~K&1lc*ms6b9+htg9ZL8>XTY$yf@-s)
zpe=#Dtqh<Oc@Dnd@c<nI%FEv#0h;3IRs&U69X_C$1<<+?@HHMjy*4YrN7C#DwWk07
zXJ&vN=Lotc526aRwi`4u4?eL4TB{}h`|qRp(6jTcXY*5b&x233JUP$$a$W_EsDp+&
zLHB07@@W0V-(n3~jsV*G4G}_^1Cj(Ce-GXVj!iNcq7!nx#w+N0R`A-$U;HicAW883
z;A%K~El{U|mf)b=bPc^PJP&ljFy3kH6Og$%@TJ#B89^hotq1s9!&yONIQpL5?x5L7
z{?-W~bGqFHJV27CARNe9li<1mbZF;0==ub(>(BAG&Szs_0Nu>&V|kCixtX1T!AJ3e
zkL3maR?tyYp2yw6M@GB^o%#hjq_t%aXc`Z4#W>hA|G?*9F9RQud#kMe<s6WF>oNY8
z4Il=F!dXy-VJ|0u<UtCTfEXAG`=APSUxL>#gA~pHDck{08eprBfvs+WDCBRi1W7~d
z!)^;u0S!s;hzhPd1T@?G5?lm%b{_3!QBegK%|eddzB=Czg4m^OoCh5{eRVv$^+4?r
z&rUt?iT4K|7<h8KGC-&C|NrOrR6K(H9B9zyQ}{I+9!PNwI~uwS<aXkYhEDM0Jmb@;
za>KFPRi^pJ{}NqT?cwU!T&uxQnh0%%z}gpWg2+SAp2@x%;PEWbCP>F_aJ}Q$=_=#d
z&F0zZs_<GFR?u}bH0*fKAi=;;BH+lsD^*9Xh{LhbR|hl!?Ao2G(e0wb;==gAvC~z<
z6|}DabT^e_x2ulhcE%5$jjo`z+5cTz{`0qj4gqv+eNtKnHMq+mspUXP0hH$fuChRb
z_?;yx1|FdHEvUU<0jjthkSi_+q>4)csp8Ur8H7BN3DPZrvsUupZ#4mJG9<9_#j&|g
zhM_dUvp2WGvo|imvzrY$yPk0D_5%%2odY#w;qBtnppvV%L`4GO^b!>b=-`wG=+4tu
z;B*Eyo4*BAL_*yU8oc9g2?aMWAl(s)L#CTWWrYB!Eg(>8rOLp-pipA$0jmm;D{zo|
zeLCNIG#|BqR`=gLI$!+{(D3Q}_F5PmmQZP^_HGsx$Ij!92j8=R_Eso3@=rO2(tL1i
ze$EIs$)od?Yv+&u0S2xd-+j7ER0L3xM$6N`|Np;C2H(Vx8-N%9^yob3sm$lt?Uvx#
z*>emfe2YNg19C5c@I?;P*46+1|3^=jEtw#@pMw{#L012~tOXxF2jO^PscT*qg3orj
z?%Da$r}H!Twi)zN6Lc}0XRkNpE^*KranH_Qkb={*^PW%VS^kz(&{AGsP-e$g>L!5d
z448h<R#%8-{#HBCeH-wjgdin(iy1-pfcklG_ki|sp}VIQbP|i_ad!bw3*NKa9a1Zt
z0Xg#N&;S1ozrA$$3#MlN1D#oV2Qpj@Ir;V_=;Sx>^7T{v9a5m`yYsP+<vq{N8y=ni
z_}el-S)ubF><UIT(7Nmpuqxc9fY&)dO#y|MXXh{eHh=IM%Y(2x6)QmoS%bwuC*5Lk
z3*`9Xd;D!Ipil!}tj6E67NqSnK5d&o#}ZlI<8QkNUTX`t5PT-_UhuWWP?v)a8$>P(
zKxgoIDE{<-Z5VC_??P%l30{~Ei+NDiez_Pq00<h>&j7lN5@gKFrJ#flJ`Nb0E+55<
zo|ap#fwD?*Ik<G^1g)hu1xEoWln7}G0BgDdI%kCeG`7+C%g6E}#O0tHXj;~RWI%V7
zff5k1OzTFF%q~zqvb@OO@(9H11)W50d6B=h1H^L$ty_nm0Sel~&fszRsYmBekJc05
z+jt+BI`~-LE3*b)0eiK~7<wQgD5*gX3IydAq+2r~3nD?ugTEEj0`u*B3~%Wy09~*F
z8nK16b|5|grJ@#2kXz1y7nj2hwS+VTJTE^0c?xtNG{{VlcU$j(Rse&N!e!9WwBK)e
zT3+C9I}T!lJpwxU(F4tG;CcYMG8SZxXXh`FQ7sd{{r~?Ge7+x8D`@pH{P<$f4VDR@
z)!QJe!oMTVG4=+r!Rm2a)vWgY|NqyakkG;~mKWv&7Lco<hvfc19FmJAbRj-yz6?Gw
zH_yYf(=EWav(5pwdhq2okV(kn2oN@`nNg0?%s^{{GzlWjOJkONrLxdcs@M&bFciUe
zvbBJY)_n=O6cyyygRd}hI_L()d;D#nm64!OQ2gn^d8(w~C8$n<=)jihk@9J=C@9rK
zmYIX1tTg2%=t5Qx%b)x$+d*q$l0e2nR`tTuZR?LxZ%}e|gC<uyh#HJ|f*lS6U1tt5
zpT7mvs6`y)llm33lN4N-m&*Hg<_kazV5C&*1Uj4sa-;GwA4AmYrc@FZXio4zE7|e#
z0I1LamlT)*<^gKXw}DQI1i2a#U=e7isNyNuisL{5Hs#=JH;{JBfB_j_<_rxOYls@$
z0fU^6yFtOt2@d(sp!NWyCMxCk?aY^e1jkEr(22iTl8yqjn^NrKq4>kY@&`mYe+y`P
z!b|Yd0~~=739hWb5z_`beb7VkxCiI2lH8Y|Ywd_jK*f;o04)Xwo6~w2v>3b);&V`*
zgcmU$tx$)7E?mC{zHr^s@&f$$V~}+O3Kag<G?3vU9+p2LUM%GVh0aU)&!DqnK?j`r
zcIq5|De(FKf7JC?DE;+>P9GH!&(2GrKDz{DRS>ju)ajxU0ljbtbh{J0>*d+ogx*)z
z1l23xrh2!AN9$Yu4$v|=#5xPVUXux)&Ceb{FAn_A%mD2gqjuOqVUE^e_fUN4+j$kK
z!|uuX7t+J+_T=#FHUr)DVfe}eblasCsHxOl2Dt$9l?TEwkR)hdqGxv*<SI;bNj->8
zSg##bCwL1%^HD}<PecP}cg{!gH+;eo)``;r9{};zsPQRi8MjB~QP9e5AI=9LFGzU6
zJLzoTemF?6FQ_Bw2I-{7gD%YJc7t@%=R-J<<{0Rp5zo#aSX-RIpx%7*K}H|TbNtPq
zRTDmn2Yf6K@Pp5@@I3AY?x(-526xiWg8Iaudy3ETw;cqrEl-stz63361WTU=2|=az
zgV>g*%A8(q1@)gn{p^z<A*eKHzl@LNsWRo4pzX3?-N%uncZ1lLr}*19fiy$Y7o_tI
zA074RE>YnC?I@7&>AVQ;6M_2PE-E58JKvBf>DB=Cz&$!4ch13j;E=on?tvd8Daw*T
zNg2K04T>^QtpaKkFYx3%=hJC&!?C$m=6?w>y<?B=7!{7@Y8i%7AK%{63Xk6G1RrJV
zZs!D_&OL`gO*D9K@hhlN*IS~3G(uaVq5<zMzW3?;1P&Rni5}g|pbk26&!(lDfq}uL
zyF^9AvGJJzXlp|^sGrB+*?dI6r!z%G!=p1s#Q_v<5};1C2dFC-fap27s01K&str84
zn_)xr7LJXeW#$T{A@Ie4?1<4}kKPy+4QP+h@T3RmIyX>n@wFAWcZas*A_7tpL)!xo
z?;z>NW<F?(iHKwK0|Cc_FIW&37@!*u>N1xU!<?E0@o{$!Xf!8>6mPe}y$uaqlvPon
zK-2gi;Nj8v9?Sen1b?d{XpKqpkp%cCH?~Qm?iv*iu;*Wb&ZRZ{_EHR-HNeYCLsS&N
zQrOB%pY9M9g_p}g`(!(R`+&w;G1>u;)z_ZAo{(<mR#2kqybr4kU-7q016^4IK8+bi
zA>s-u5n=j4Ww{UNwnR{6%HNs^y1wbS8}txcNb%H?h|fKxHE_3Npu4429bz1`zv%`k
z;BJB(2s%~OxAO$3CdAU#<L?0VOF;LFTAuUhyvN_>2FkdI?j;YXduIghU7f~hgf&?H
zrjO-0&(2pKo%i|MW`OP$0+|A8JMy=H`ll~jz+#|Y6Gj7yzatggNj%5j2D+ukQ}KWg
z=OO+U(1kKDMZjT#LmNnikL5X^&g1-T;$ZU+f*PWnr}$fDfLspR#S8a5sM+eH_z%>I
zP`v2@N;w|z3td6?tRos7uOOq>FH684gL)jFcF0a<aF4PT95*2MA~g6Y9z?OPI3HwJ
zt0ibW0JLf!60&&I`+BsV1bMR62-N?)3%24uxW)1cbl83iH%J&%YJtYWKn<B!zMVJu
zTLnSFpwS>7%Y*zat{~n~@E!BVK~2Ker=U%`<tY6~SRcxx^QK4Z3E$3xr4~Mx=gN%1
zjnC_4+MvJ#@2ETEqxcI_*H})0^l%{U&R6`ccHqw9LGUVm(8#zyn4ibt38{slX{4nD
zWIG><?TBVw=Y4R?4&n_jaL4x?f14v{1OeJ@GzGEYeK}mN@c?bJyUE|e4zg@1xCsyI
zroz1H19Ia!m=#Mw#zOmb;L~AnThUwzI^8uG5+tBjDXcRC%I2*<_*+}Seb96KZ8e~N
zC&<vN{A~pwHXcI*K=Po(>C>6-;nC?H;L};|;L~{(Qj~SRddUoOA(jTaEVOt4_4RIg
zK>K>2;ry4U!Tts%NsOFV5dmu9v_blI2R#&Tg8F(HFG0I5&=Vy{667verYRNzC1OZ7
z?^S8cOLtItZF!TwMF4cWY!o6`U;*vXdZW}Cl$z|IsmTnY2Go_oh`-4PL9PE+{4F0)
z_7Jmy&h~+%qf!~)&O8CnZg61-OH|K5!vgA{9yOK_l7xkj6DWCuL#Sl;OUN#D?4jca
z4jsthN3hU|d)WgIPehi*2%SVw=s<Q1zv6EN9cceL9O7S4Qb7(A2T+(mhH0)N57S_T
z2|R~^PLO}i=>ZDtAK-2sI1E4?mpqA=kkjKas<TpAPe^+f)S<iKVR-|5_%bMIyaZ3?
z;^@tVKuUG~Ht^Znu%&<=oVQ96UxH720PDjO4k;+%paklWBK7}~!ojoiRjCIkC?GxE
z>t#qiUED!&5!87T^su}M($4AInJ4k`(HEqi+p(9IzreTAg6C&Jv$I^F<_~1qCGyNH
zp7~fv{|@V%tS9oU>;M1%dHI|5K!bhVdf-l+5~xOn%%?&w0)foBLZ+=iv#t<1lujIU
zCKfbn2vL{(??1Q`_r|mN3A^XPCt9AIXM8!2AkVr!@&R2~CJ1VCz-C<`Lh2A9NUsed
zWD603^wl6jpdmj{7r?Vq4`)jsc?{z;MmKFQXh0FY%@3Xb1aB5bo>e^ppH<xm+Nay8
z4j*g01zI-+8E52g6##eGpyTH^!1?Z&kKr?))@%H&mq2omG|k_<8Faxcw2y{;F7+9x
zWeD$ngZJH^<8K4q<PPd`)xSIjk_Yw3KtdiE3U@&|Uu9u0!E>!3g&-kJg`mMGkcql4
zLDR3`P8>)GX&y!qGM5UObUnr2-U_lAr90=i2ee}sQXQhssQPrmXH>DzntDK|SpM_F
zBM5tZdUn1?#HXj?c~8aTunsrmf&{b<H)>46`f&{&oTt4yWqvf&sE9B)cDri0@OwOP
z(F9LmmS#8}ca;H6A%o}TN+UsYen{Z}o{s{}0V2;yd3O52Hkk6a#)I+>QS(yZO*0L(
zNem?wkm=e&Sf_*H`97FI$TOinov%PEc|e^Q3GkHM{{RbcKMLequrmgDCRTzKv<vlt
z2Z700_$V|lD0#y+?1M%|z(Yugu9GLclzIue$=3&TqXRf6c3uZ(M$ps@w0h-lUIQv#
zI$uD>Ou*9w(x78F6+s0As9t^sIuIL_h2203VLc>OP#*xCg+WzQ>kn|326oK{csQ58
z<pb<C31quLQ{iyC3qeLA+ugbcVi2@%1T9N?Kn_~}8$1cO1~kpm32o*>nn)=3c7kp~
z_3Q-oZ#+8R@wY{R5+$f}^U(v;(U1dmG(g=ZA3R3*gDM2D5uTkdKq1nm2JY7!1a%ES
zrhumPUJ8N55KR#jSJZ)m$MPJ1+eMInpk1VyAj=Qn(>4#H4HTqpOCen(n4O@LtX@t8
z&vrsR530uzg@T77WCrdfY!ZyW8I<i|6*_;5FX+76sUQnrUMFY((%jp0a5o0zTWq>~
z6c56zEiM6B*?JSyT~Y@JJ~5g=eI}5vTi1j7J@28(!t$VJ=S@%qv~+-k`#^gqI$!v}
zg<JbT!e>D#0@P>P3gRVzf(WGI6@P0INFWtgujM6p^6h4+6{sC!>H+Sml<9iFoBOzD
zxA<E@feCUOY;{o*xZ9M@;R&e=q3NdO9jGVs6LrE3e6*71<;R|#FML`LfDGyU#ou}a
z)~DGG>M?-aa+$wvJ%~+&d%)H~0t$2n(@XG~pkRH-%~x>W$r0401SL!h&@?cpn{%DN
zO$WpVs|PjjvHQE39keem0unrE#)4z+E35<c2Gl8nn*0F7CS>yN@1S}0G|btyDIott
zX4t?zD)8v<GmqAPpt&;eP!Fj8^b*#80^Ny)(LP4XmK9Op9s+py08}Kr1ofY?pjTYr
zN~Io(@Eldl4@%mgPE={!OK)%w>Lq^*E2sw*g9sOJ{CZq|?9uw7)D@Jp9Kb!O%Vic2
zHMoNq)Q#eA0o{v*m>-)6?n8kKR8Su(9Wg%!E}2>iK~uU@V0|cX*dX_upkY&T^yMLN
zdko}Dj6$;_030rm!>A5=D1yT!0eY1MNC&noj~p%upl|_opZHr%K%o%{@hK>kAcuw%
zC^T%Lp<xP9gF7@p9Vq@*&}GM<-qTC|mVe;h6SPWr0QL^3VgV%wDOh*O!9($dhvf_Y
z7SIgf%OhY#ARl1**%$2RMIaT5M?E-Sl_b2J3gW=KNO+3YVk8ecgE~oZ5YK=-jOZl2
zD0K&U*a__6>t$9DHH172x`q8UpNHj3P!BO(;^l;|pbiq~LPg(BmE$iPzrs35xcfg2
zo}e*O6BX3us1{hdKA-~Hvs=!i^)`QpG^ntKG#n`G`rP#GB-r)g0u}M7T^|LA5OUYY
z3?hWw_3;5!M9qg8Jv-$<0|N(Nq8}*a(Rmj+>du0$U_1<(i{fwD1ZvY9d~MYD7{vF;
zJPewfLTxH{^Qd@q^1J|TwS%oBU5?i0xq#f~VFUGRATzc6Eogn7y&ySQpJyJyKF?cF
z&jO<>a~;&yvpiK+{}MEH1@57MgfP1@u-U9I#B3Hw2vZ?wDHx>Bvk+t>sB;7oLTc+n
z`#e)2R`a*_fEeAjps66wZhNfjM@3W+ot-1dogEhy0T1vD6^jb=*edW0)luyI9D-{^
zZ-b&Af4>#f>;XCTfG6i!pH7_{piMtA|4ZaNyV+r@IfWegccrN4$Q5xqHu|W5*K<O8
zJyE{BIVu>-@bGqf!ay$SML$~yK7n=LrxUW=5xSKM+~3Fpxk-beG!52Wf%bbiKr0m$
zJi1v_Kyy_ZpdJgc+ewh-rl30)K)N{$PeM97E-K*Fs9@VOXkshaI-KiGE%;jnLH8vz
zA927pM+EQUNc;o0_CYhRFfqh93)Y^FGI;6YQAisBbc7tJ&$1EJWQ6ru7J^C><laV$
zDyU-tniYcSx(e<efmg%Bbb(g&!8%8;_*<DE*9Ai7g1{9sf6Fh-o(|FsP!_tqt*1b}
z0`wJ!vp|m73pNSb!pEq!_&aFQy|D)ONl?2tph+sos4^B;z`HlkKpsKv-dqJ6g|*7%
z??CR}?84H$Sq5sm6Wu!j<#Tw$gU;QXcVu>Nj(~b3nBAMXAYshz&0>)76<GJ?6o^*}
z3L<FtrW_=IxSJi+`hbi=d0u`1DqcZr3u)TDVFo#X1+{+#Zt!7rZ*Ic6Hy1!ndT93s
z)aN0lQH0dJnF#7o;pyIl!MZoTpe_xx69Ve<5VEIPhCug*3+4kxhz~q0uk*Ko`aA?p
zzJRNHvl3*|$nM@OBhbBR19fj!j&^S#t;pix*S%Sa+P#?u@7^G<-)nZ4VJs0qKb6%n
z7`mVaw)%Fx0P-dur2Y}5`n%m_S`U<nH6Qrj=`KUi89Pv%0o^@_vY(UM<~at#_D2VU
zPOE~S&|{+l9_}_g@WGRRW4{A~07FToBY5K5@b+sBxXU1n{h-x^&{Il5{j28vAPo#9
zR?WXT>mPldKpaHUS$fRyzz1Lcjq5??l<owd$&=jR0Xo02lkJ0NV>?J3Gz1SikO$r<
z#M~YWaUODda18D=Z$8A>8O{Pe1I?Yo1G*Wn@!tV?1_u6S(CXFBi;kTq92+0}|8LLW
zX?cRb71Um6KE~+LS+3yG>#nhaza+%t_yGo{|Np_~6CG<|*8nZ}I@ZFj38l55v^JF1
zfzrBAS`SL=gJ|$MQ@dWPcr+ddnd4!3yi9^W{J?8=sQdW^8NeI8EPoVz!SrP3N3_HY
z+U(%C1LPgZ&=;hhfF<>1j0_B5aj4-K`?<qF3Bj@3O``QciMS*G_Aoh*&hMSaUZ{Z@
z#Ly*?pm4{19u!jkaSTRTKMOi9!Ur-1=Go2A`O%~EyvM=!TprymKS1X<K~K#*_>j}5
zmxrUfh2sw+14Hu<#u91J)>j=S28Ldb{~sLrH+F&~N}s;`$;iOaS)#(@+pPe;gaUNH
zwX5M<574nWi1Ryl)G;tH_-MXx?KWuyb<Lq?PJ$-IJ$v`4fX<%+9YoavX0;qBQSj+J
z3LfRJQIP-#6=+qD1bDpl1!&Es0OVjw`1zoo-TWTCh5tP}%^kaA`dJ*i*QkKbodPZG
zgPh9w1?0KTn+Wf9>hL*s&H<~UNHh4H$_DV6R_u^dD*0VIOWHX+n~yU3b}M*VUgd9v
z41Tf0PTB<Rh4<_Q9Y_H=ehcnv4%A~exe)0C>_pJnqvDR;J|O>10lOS=>L|p2pd&cJ
z!z9l+!AEfRfK^eX8R|dqIh-&LcKfLCIClE9bC7t{#6(8qG9KYOl=2lVy&8Z|-28w#
z9H!yQzdc6<bbc^@iwkJz3o;c89@}vNEuRD}J<{@M{0TZ9vP8r~@rI|R%Q=l=F3(Pv
za~cj?8DBFQzV++|4R3(Qx8X{K;7U1QN*%k|d@NrSS9Kmd_>!&pfxRRD_7D{{56g?C
zvYiJ!4nAP^WCmS*-p$}~@P(G6r5j7B|4Us^r?ERkMPeT)-Fs-BgYN0~=;rJe*#tS^
zovZN?=%6%^8IL$Un5TRMrBIJvmP4S$n^2?pTR`joeL7iGJiFZ#d@Nsh^1B`N>~vEA
zEfwVem!B>w0>@oc6u?DsFKmsbM{|t|2SZ7zZ*QFjxO@aHp%nmK+ogEZ(~`f~!LyU!
zVJmozxB#f=0}WURfX;W4C^Geco8sAgoC9J~>HgQ6$kBBMRa5b4B&AavyZJmV&z5O8
zcDu23o;vu7t@$A+&`Lmo_Q|K4MWs}-^Q6bYhs>VLJ}MHgT|q()-;OethP<x!>@HD}
z*bfP`>+l1%gt|@kK`s^Mf}Ab~(*KOpgL%s@NTBhY^H7%bIQT#dG!xHx14MR8g3K(@
zbnIqx>@Jh=>~=Y(;o0fN(fX}K)Dcvq`g9(DaTT<`4pyLcLw2oNyQpY@k5D#%S8LeT
z!$OL5aM^@jexsDPko1do47Ub25vhO+Oz`dA-EImVmKQwu-7k1{hABAmZ+B5q@vuBp
z#tlB^8FIoZDidrop=1Ew;s7eR!OP6xCztv5=4lw-Mm~QTw7_4$6LfV~x1opPI}giG
z#cZCPr3{-HLDxig3VJjj<N%$TA^^JQRic>Nv-v1!(SPaj*Di?k0!n0{at|!C_O+G|
z=m`9OKAn)`>|o<opztjTf>xMdUl`u@JkFv5%BtTEGvbZ0|1Xq({{Ii#6@Y9ai7|#!
zKf>Ez9?fqwJUg#>c78!UR0$Lzek!2hiWbn;BhT(|1rN(ppvd{|)A<bS2k7u9Gw57I
zHb-lA{?==ZAhsWiqqRQ^f9nZQHHj!e!axNGe=BHk2~+@p3K2I6k8TDZ#TTB|?i~DW
zGe9MXwYva+TOar|qyIjg&k(EW;VD%Cviue~G#z0B+M)md|A*J~9FXB4E>%#O<8kl-
zrw4P(MNsDP>~xcG?Dm&%?DPY9(_bddvC~h*k$-!=T$*ENoth_jiwfutc~~LI-})3(
z<U*E9fjunlaqy8AXbzk6nrCMjhhw+7XLreW4P+5<$4)WF?r;{z&M+3oZh6P<a+c0p
zpt9kyy@%zmQjX4B9=$9VUhBZ}zGt^UH_Hyt3F-&mLmb_C8|rLmo@cq?q0HfN@R^ne
z=SPoD(3)3?56umrRtfyXQ)?F$1^$+D(A+s__pWDm7`X*9EMD3(K%?oPbPb7ipH34M
zXfe!j+(ktKTnu+Y4)O($1h*b23H0oZ*YNCof}Y<vJi3K_6kmBDau)|EcL@}8do&*g
z=b@XgMSYMBg9;yV<QH(`;12<(0{$>C<;XAS#^Kn_?%2uZ*zL~Z*y+aN*v$`OA{D`9
zY95xKN_jw~C#dxGlXz|6*<D6nd3*4ImXETgC+AV0PEE(=dI^RSL!|tuz~8zBG$Ge~
zL<3%mVz!&p9GmM@7)p+V7cd`uq2*x<Dg;WmLw90<rrtsAeg+1XdInErHvtdJ6Q#32
z>rlHpK=IuCld-fL!Q?p(j(yOX$FF%ns$j{%vD;0-vD00`k$=0JN}6M*y9|h>24cyf
zxVgm#G%t))vP1I~tl<ti;>8hs<TN<XBh`o~<q1mpF90u4z<M0{x4Wx=wokP@V_;x#
z<lpYE=FuC-<Z<zp$H9ke9?b_GJTx!*SbpShzQM}CkOnHd&w`JE&R2sd2C1?<$ltsO
zR6ul_sCcw~E0u-$qT9lw@i-_~!;2-5ie9(>o}DZzt{|&HN0h07?{9m~=F@r5L-VIc
z^G^r<<_D|{46fZVTUb20O+oW79^Ga>o%caK1E21me;^}WI&U{V29+M3owqy>KH~K5
zH4*ga)d9JV0bDd52Ccm5u9xs={;R;>Tm@?DU3%Hf1ZwhuJk+EQy6~2X73OQueW8+|
z&0pRA5+MDp>L96Ze+4kd6fDC63M#zbV^Q${A5F`n;@Iud!s6KJu7GH3;Vkod<0U*h
z-6dA=m(+S3Kga-@_U1*3%`<0?wQzv8YcL#Z;a~(MsADZ0Oi-E`O0z&|Rw&H|rP)C=
zsJ<-S_1eX=H(mldcf=olAkDG4UWI|b6?7Bk%T7>3y%)SI#KZDnnIx#Y3GdIq`<o|<
zzWDa$tARGwLXtOVxni2*ad#C)226ufK#P<Nzy`DEdsu!blk(8K>~Zihrw`+4uU?kJ
z9+t<8*$pqfd<*K0b;f{N%C9_{A3gBsje6kGdBfx23s#rj2u8=|$IKqhzY~gi3=jCW
z-Y%_sxq^X#!Mj&R(4+Zqfp4$#e^1Q=h6i4A!o!STfQ6l3z=vIcU(khl0>7XS^8$VW
z7j^}Zm;p#^14!%uNX!8w761~v01|ru5=#Jy6@bJ(@C))Vdo;gj@N7Q7Qo6#o^>&Fq
z)M5e8@3&t=&tpch531(?cq47;6A#O)KA;_JC8mh}C;v7U@eUR-{%tPej2$jwj35S6
zhl>~!h{4?9BF5~|e2B%v@@nZ-aFq3moZA6P03MnzI<IpccldUkzr+D_yGW2n=Zn{j
zXO6M3F&uMYV+0XQAc7f0uz(0w5CN8D2aOqUc-VprDn0vJ9Hd{!gYg2m!eH`fJ|y5_
zd8p`%M>lilA<kFd4)K>5gD$V}2bs^naLj>`;g|yx!!ZYDhGPya496T;8IC!yF&uM%
zn%jKzN9py~iXOc@CqM}Z`*_8PqA!m8+kF{&9U0RcJ6#z(x|w%Dn%Aegc_x6fS_mTp
zgG;B(1oY%oD*5s$=x$+9BzLlGf+pUUi;!~5mBFLegURFKOOJyO*gTpKICyBD@Ui^B
z->d*Gm>@Y<%A>oM0j)^l4?h4NO+wDLkb8HJc^rJl)p-!nNB3av`2;F@z8&N*$@MsX
z2%J$_K<+u#A_xjqhGQ*)(EKR~&7XqM{3!^{pMuc*DG1G<g3$bVh@*7ZYYUKBAZ&O5
z<n|`enYFKzz~^001ep(N<%xjKGv^m%1Roq|d9mmVhz|+VKv0;5GI(?g!}@vMJexpa
z+HwXoIS;8wV3kKRGvWk+G}q2@6_4g4q})}(h@>B_UIJaF3%kSuO^O+}E?!XE4Lptl
zu9-l=0LQrNvjXUSFwovor;ADkEM?3E$Gp2lH@F^d{=vxK(#6QY0II`4tE@p~7^tHe
z;n?l2(CMO*0IG{r(mF#_Qb4t$T3V-zN}6Lgd#8(vgJ-Whs8!0+>7(KT+O6r~$S>f|
z!7m89)4Mkx((`5TJkAbkFF>TwTSM*~;G?vm2W0lTs5pS^RsiQc7Zr`;E-Dt_##(O;
zbn~K5rwz`goKH7su;B?mc)zMg=OfT`xdL)~&Ii0}v)e^Q!=szSv(p!n^E*L&YZn!R
zVsTK1$)__%g~P`>M@67m)3^0W>8aQDpw1Iy?<CkrkIqM^3X86Thd;i;nt?u@;47mb
z&MEEec2RL~>}2nDQE_qXbZ6lgVCENeWk_qTQAuGa5$rBeNdOI2r1^AyfAQ+|fB2mx
z)-Ea;;0{v(ym3aLi;I@344FZ-IxNYd_J2LV3xmKN2FUmef6HvpE?-dV1GGD?8MI3c
zv0lZq^Mj}20gr?444NO>^KTDV^RT>D3T>i#F#Aiqw)E-tmw=X8pP;Q1pKdY7Zjp(o
z11Tpx4nE@aWS#;pGCX>DPC;*w2Q?#=1${UVfm+(i?i|oHLoD?S9-Id~I{i63y2}MT
zI`O!8E~qIBKcS88E*3y{G2z)1Rc6#7X59JN0Ny@@H6lT&7SuonwY^GAJ;9w_@JIx_
zvkS_kXnomIi%#fZn484w6mZtV)?d}&Zvox>3r$Yoa);br8KTFH=r@=7ds@2-lzF1s
z4;lipW-kRD$i?Dl?aspA0-D5kJkACxJz%~D4NLI1ya2BU0xy;VI}SXA0qN>t^Rx`Y
z)9_I{ca{>bm!Kn)$@LhLNu@U6t`X`OB^RhOYUy%bqeu?C(Gyjc4<=j8VtD&C(`H6c
z<_ERtL93G>1t<0)L+DshNup<OzJ?FzJX@sp9e8}mqgxQvUj^NlV)@B~-|ZTRhv>b+
z#)dqgV?(E3i@}O5@W>EMe6uGc<Xdi+WYM&b>Z7a)8WV){QBmT#6|_RhqxlHlAwGCz
zh+4im26wZ=#)A2`g9ma-c_8V)gV{~uwS@<{!wm2d6%S>O4U8Vv{v2iO9@hQ>{L>C#
z_MMSkcLsHS4LqI&y1((7XXk(D*^Z#PzMCDiiw!d2qh)x>@<&Nf<9|>dDDm>__7i|g
z>;m;LEPs@kLFM#d3COXV-?Q80yavXAf;-ZHLNO@BeH0&ha31vR^ts02*v;>&oN`{n
zlk<pgXUa9ui~;CsO02gmkvkUQqxb-&sP_OD_0YkEa>E1AK``X{y7Sn<cWj-9nje8i
zrt8!^EdQ1AbYAi}_=wq)IZWcUp=WoU#7;;%`J-pIK{ro7By_kSjZ=`)hnybFke;ze
zugFCoMJ12s1B{OR+x=8LEKd~81D*2>y0Rq(auE&Mf$k{fF=l#_Mx-ZbX<!L1RzQoK
zeY)LX)!`{<SJ$VT)3IA*0^|}_F64OyPv$8nK`m&cc?C;%meK%^ZZ{6d+85ZUUWtgu
zE>MFA)Wi2syx;*YU^F~HJAhFO7zs>u#Vm#gUNdcA#GOhZNfKPueE01911(#h`*i;E
z>HGw_st_fFP{PL%JRb@=)Y|8mhNq>QLOFZ$Ax7{(c{iv~m+<WNIi~^I&W1K$`t1?Y
zU@<5%;&8bTF=PXpdWBX`psP5){=eqgT&KWL;^5N@KAOa*7rX(^2hzAVy!{&7AMt3t
z?bG?rli%fwXLraw4bT-_|2;Zi{=et}np3xqQz*LY*lp(69mWFAf>6x|JUd^2=5di)
zVgDb1Gd7C<!EIJ|2@gnf7u*m=Y3=e0x^v+27}zwl@`38+ZTANaj+g3yN3&W_mfCqh
z#&k*py1~OarOBAigN8AzcXS_gPa$*x1DezW+)@v5OFcr8Li0Z)JweL{Vesf6xF845
zu^)Qy|382D0nm7=1hk^UHQWk{Ivi8*DDelL<^i3i?9u#7zD&%cmqpCO@&|ugJ*ZjP
z%OVaMs3~(byyVmC^xs$W0w^0dKV&YE^Z0%fHs0aHzl}xAse?t_v-uFHC(2m**0cEs
zGk+84YK7N~XW;Tq{M%f_7@ay?#2LX%CJ>Ve%wz^JnLV2ivG`bCDn0uWG;-(JdC9Z+
z(F4z3rw5SYfYqhfk<qdF0kcQ*5779}N#E83rFkzwmofN)dhD7f4NtyiJi{-*!pAS*
z!zaKm$imMr=)*6-FW|xl8t&l(4fpUXfW!<yVxZw3KG1LvzXM1t03-$)?%@Ls_wXlx
z#0or`Up9C)9|Vv094OHT^|U>|-*}BQ{|(ahfnR`!k6+M*A2i;>@6miv!L#`QW9bu5
z%S-&N2S6R}&L5cR43Ytm;v)?-23I2H(GBaUwjL;v0(DlW9(c`Uc!1yvA&kBc$Oa_y
z9fLi({W&~3Pk`owEkBf`dvyB?Ah;2o9}d1?Ykp=A&McNEN_jdzfM$_BnBBo`2Y6rS
z5Uj=0&Cty=5p<u>!B?>A=bOhtaP@NmTDE@#P3^)vC?1L@aD@ZNtssozUQ8E#1WnI^
zdtVlytPJgak>DbpkBA<ghccdu0pu9;_7$Qq_Go?syMGo|WIF!81{-ex%?)_;%7PlV
z9<WjwTt>SZzI}~4p6d&`0`;8-zsqNr&X)&Yvbl7=fK26s`kNO^1t9gUCnyfUx1e}-
zhr^~t&O<9%@Z9|_@X+~tlseXfdCE^{JRI`q7C`d2;vrB)@Z1qpha3g94ct{cEsydy
z<sqgS3=bfA2)s5Hmxoa9_oSzP4!+XD?v3*Q|NlF7n}eqHe7iy8Es#|gh;-O_+*9!f
zXji3Y=RwbdFSS5NI(33Z?7<x@u-6F<f?-P^-To5I2N^s4B|N&>`L_qCSzfG-@kl=D
z)9rvXy$8P3#iyIgvD;*WN9QLGQ09T(Oy|kG1w8rb(OJ&HzuiFvJoln`!lU_z!%hcK
zsm$+m!lRevoJXg-z-!l18~*JDDxfysBR0^?xUNTcfP_b9I7DkQXe|Sq2d3^*VBPE<
zkjo44=SY<N2)(wv^Pk7TXDlAQ;5$4F4|p(sEaC95{8h&6(M>Qzp_&Jo(dqo@aquCF
zPcL}B5EP?_JQz=vaCun%D`WNQc45TVhCne7+?We>3<0glIrxkP+7$BbRs(Ik^6gaf
zWc-f(!T>~<-B<Ccr{YoQJ!d5ugzh+l>}&&_56Ah#tCQs==%Ra1Yd7$n;n4H0yWK2&
zIxRe#-7G-;i&#jj8@(`xb!A@nLDLnCLh&EueiXw4&ERCp01Yvp&SM_@E+0HB|CL*M
zG#~sAohR!&<#F&4ix1-=!vh|cA3gY;FL+q~DiTNN=65;Zqj}up;C~hmqUtBm%2;p|
z;Y%?n?)BKg2n8OU?u^IXIYB+R<L&}4z!O1WvphQ8B_N|n9m1eXZ2T3DyMr&iNjvVY
z!@%GHUTO-`=F#bIaLnC;(WBGdA?>)k2Lt0Vb_PtBpxBQnuOZjYc=pCKdO&uZ?E{?!
z0BP+bpX{gL(HX(vne4~m(fIQO18C9bZ7$G7&te|EJf0rC(DZ6@%Cno#GdYaIqgNyd
zE?RPt16jD!<)VONvl|DaXKy?crmdZrRuxdgDrTarVx@*vEJRr~i<1fg$V!w|`qZ$B
zjVP;*a8SWl>_k}=Ne!zwh_dP(I~9DzNt9Kfn@>EuDa=<~L|G+44PS8+Wz|~H<t~)^
ziiaqxoTy=y0ESi2$ySf%qXHhC8W_dl8SwH43ZqQ|!&aYe@Zg1K^HBjGEVhD{5>cF3
z6fkVX=E2vX?bVdVpbAk|HBiGU4Wg_PrG`~H7*_dUsl`@-7dum!LUf6;%AOil8DLn2
zEm>RvuOXt)S0+SRl}Qb&EHJFX7FYkk6XO*6$^na2m<7jVDp-~8fyF8XkIoF#CYuH|
ztnwtvs=W-9R+!kV@#(BU_EB*ZWn~}IC~h=*#{+Fh^P2(#gX0cR%NN`>MjM|*w5L59
z-+<3^hb^{fQ2_-y^vG$)W9*Ec&?|KukGTslKu4&3JJTgVD<~NmKn;3N(26)npU<<?
zT?4dq%z%LbB+tOW$jHdx+39ZLc+A~~(eb!DsO!t%c+A~}kzWJcZE)llboYR&1w}!p
zdj!aU1V%>3W9~^H+cOwISJ%PKF91nbFn|oHVt@>zwod>r7!qs;-Sz5ttQ~Yx4TIzH
z_9YAq44}?Pn&a_y(DE`y1`n7q?Vxi79gnwzyM2rdj36bTW6u~t`VN4`dq913xN1;1
zf|P)+mt<t{*bD6pF?x2czYccw`b!`u9BaQ1(&~7;9d!N-C~O>$wLbw19cu@zbYgTo
z)(%>g$>4ab{W(Y+;UG{nIUZ~O01|aP*8Y)!fdQl%bayHPXsZ*4XXjVX&VP=_+Cg`O
zGk}(?80`81a%JazpH9g7{bMdF4vfcIR6skV7>>25Oad8ptVIPp@d35Uqq9W?r0sZ%
ziU1=6gA)S-NG0gdSVpjMKArzPI`4s8!{FJO$LM(64cystJnjbW?fG`5fukN0vYwr8
z3XaF!ApJbY<8Gji-VTtzLD;j?&A{=Pn+2n9XPSdg=hHOD<8B@xPq8t87BYj}2A(Hy
zQBi>9odZJ9MFpUhGy)($3V49L2VG+WVnTchI__P;ryG2Jdk)eKtKj92^&F7Zi=b|3
zj0$)si-vFOTmBZ%;jf@2G728B8(9qxc<g0RV_;wuU|@mFu5I&S{qNEI)2dAQwGOQB
z4x&LW(m+*G&h5d!_-xTr(2_cB&^j9d@F~jRumdgEQ2<R!qv<I-^ZF`IM>;mtu`rbK
zfC37%QuUY{2ZLi5IH5Rlw1c9^vD@7QI#}4r*lfvAk^ybyb#DbF`qpnH;m~pbI?>U*
z7bMP5X9mr=hVb=`9^EB(89-w+(52+fhZ#MRTS2Npds{3)J6vjR9|sG7V#=|hzKVgr
z1$1D>u@)83Fd_qd^w<E+&Kea72L8S_&<fDr8WjWhd=_}*)bK56(ZHEAps*3}=&sQa
z@aSgW1<JWTo&Wv^aCq?V>j9e&TIB}584o%>)pDSe*{Aa*RG*24M|X$@2iOC?oj<@~
z?g91#XscB7Q3-@EraCs)8E_PbIX2gsFc&AmoNWy$>Pk~Q8jpaAKoSbqCI!SoJ5;|z
z+yNU&2J^rKR27&FN=<0xu}5zkC{KbG&kB3=wnNy*irEbhyaW|u`~qzJ0)7Jgg6#Z)
z{sR00ZVLPYeg^!4?h5>Z{s#O4ZVvncegXV~?hgEd{sH^~ZVCJXeg*u3?g{*Y{ssI3
zZJ^-g7w7|(ll+ikl3%bN%oAt>MLEAfAE-d&7X+7`{DS>po<JL@B;*(90~LGxg6&|Q
zU_Xer1607h=7x9$O!9BzVe8;w=ilbT#@OM*&In>Kb@;F|ff&pkKJ3gM%?DUKY(ai2
zy@Wa5gH$Cozmb3p^T3J)978;4wJU$~RRu~banIg(EFEn8eVTY`*oxVI!`96EB2NVm
zV(GMD>8W*6!zy^ej)*}l9Su2ZSfz-WSg=^NS&j+;s6>=i9@MZ(nJBC7%2MvDd@NmE
z=uMc-hXp)3B`{j&>C~_lv)2nAHbCnL{E?x82QmAH;4Fq_)kJDoWr#i6(5zCUhE>?Q
zqL^{DTbc?1h@&ft=Bof|SY=6606vwXg0HNIvZ{(2R#_8e6+bnsvLVW<C6ZJKK+ItS
zY^8;zBm)De?JYoA7ud5m--Rfzos@ty|2ZhL&$k!LSOv7v4INtbK_9m8lb}3Q<9#rE
zi8-1D>SPG;H{TPdf_(u**vH>oObx3-h_Z@<8dgORWz}3UDg<B*QC1mI!K(ZO46Cr!
zWXDA*_f>u(QC7uJ!>S~rtokTIxv%0gFswq&(ipQP)zq-H0K-;rTL*2PT7Vi>Rba6S
zbDnysFcreGk|?XJs9{wVQC6K7qSRMDoxeSrUpHXbhFJphHz!hTn`iHQ(3OWo+4fnG
zQonij&Ifh;iL$Mg8n%HJb`oWqI2CML4;szDunn_x1dShZ@Ha0JpgcI&gGOjDti;v?
zGNXoVpn+@*+b})I-+Y3f3Vs6(Iud1D6g6xEjXGhmO#`Fr`G$`QeglpDW3df$8mf*O
zwt<(DVk}t#4N;)=p9H938|c;-qWrdqmkJ>Xx*wP*+f1lo8)%+}DBF(lP{D7Yi9w=l
zi=c*WpdnTa+pv`-uehn;H_)^ehHc<B30j)0p@wasabqmDVdghJYS;!kM1UyU7EoaY
z9eDbWDBFyvVcTWUv>!2L$q_27qg#K4Slhy=VcS(=ZF@n5)pYAYN23uHZ&lQ=4K!Cw
zlx;lJunm0O1Tm>(9u=0=t-ncZyctl#wp+y7c8Cg#>(<{U*0vC8*mj3l+n!Nj3E%p=
z#M)Lt4cqP!Ya16eYy+*vAS%Djp~9-V^`I$H4BN2P-Fnop4YaHT!!~UFfCE%mTelvx
zc!en2f~a8|Xo(C_wmqT33cK~7g*ZgnRz?lmKuZ9y*oN81;h=_XpyfnZY{P7G&7#6m
zyY-+&OGMeGLk-(NOQVRg4Rk9sWwQXDjmJT&uCUpLwg{m(gfg2ToBAaXi&3C!x4;{P
zU|X3n7Wbj=Zv^k33h@9hq__^+MAiC@zXfzcD`=y!0KX=Sif3n;0PK`g!vmgskQYIL
zR%}4lK*_#V12674bLI@_6i?9dC%9xew<rJNGeyrqtDjWBr<g#NW_fm(L2mMHJ^)?>
z0x{|G>pReeH_a6)4E5~C9aKPT#P~H>R6rY{1w5LMNI-V!V=fH=I{{@s5M)slWK9(E
zk|-Q{K?b1chlEc6Y?)*CcF?d<>$j3%=sF$f>M6(O{U8a3Is+fbjv-gWC$Rm}-rXk8
zL936To5PxqFnT6~SI>A_9;tcccpS_It(*ey;f9{kfWBxG<S-~kaUarRn8r7d;X3eY
zNzmdw&{*Ly7nOPjP`pByZFZwA!E$V_<6x+(_UwF)W$_g&*hbH8Htegfd{pW^T2Gc1
z`E<T)IZ(<DU3~>sj%(4CXR;fI2g;hOh0w_Mux?QSIk?o$qwxsHBZ!2J8CTH2hoy2X
ztE@nUC+ILJ^z`o0_y*Lw^z8iAa-hVJU(-d!fM3%`#erWlL?wV<Ge#wWUo%CefM0Ws
z3V11$<`xx@WB4`qsDL8ar_)D8!>1Fp5V6xoMFO<kQoy6LM1=$9i_R7ma9_Fe0VoE*
zo%G%o6>x>$*`fj-NZJ9q^2q?yyy<LF0S{#LP65+~|9v{Iy;vK{1Ya;`4Kb}$(xdSR
z$k{kU0?E5)0$^@wJy05s#EwK_M<cOgk=XG_>_jNLVF#!M!BCpq4PMIyw(9={s3hnd
z!R08tr6|0`D7=Lzy!mh*)QXb1V8g+w4ng2b@6B%%JUh=r&Ll%h;hioj65u=7N~}G*
z*}EAWJKf>2W9_0M!QU#%!oWcAw0QUdB#1lcKvy9h#BxpGYY)ZCphbj=prw$o+qCz9
zHavoc@)#IE*PvtEG{<=YvImj@yp!~$M<>q>TsuiMz&lBOyY(HrbKyy&+X8fbp5Zsc
zORk0oTn$gcZp{NZq!Z*2kJj6s@a@k&oi!>PB{|@5DUAT#Y}kCX!ne0B!LysqNAZAT
zw_k#1XUjQI25bOVAdLL2%Rs@@TcRRh`2Rn62Qz5RssQvpI`HD(SK#PE*aC9j2aiT)
zj(`9E|L@FEVe##@^KJd_u^&{rfr5d*19bK=WDz$5_;N^@6`swHA3#Mw%eO(}kqitq
zpnag=BVd&O{r6G)>Dm00-Sgm6El<v~9-uKq28IKS3_hH%Jv*<04l(iUHU{mhHoWE2
z`ij3r9^7Uq=0FlMg$RMJg!F)_@`eb3u7rdMC4z*Sk2Csq+WB<;^uUa3pU%HNibp*_
zyM>Sc2VD@-0y_KG^Wb|U$HwO%0ng0i;Hw}xfB1B&yZ|jT_3UN_9kJUAIs($OQ`)oJ
z8FZX7e`_?j(dH}wmfR2FNPsvk%%F3>Ai>bU$lw9GbNil$;a#8BxBRVFz^MuxF#nku
zJem(OdRU(2Z~g^}D$qeW7Z8zw6zZ*@QpWSRvjiv}UM^-}U;tnLcms5PH1vu_@F9`=
z;09ZMDyx6F19XlB=vK!=ND8-s1W^=*y<7wm11VgCq;LU95JjQxOVIs~V5_GgDeM9%
zgrroEpDYjYx0i#2K!<>J`>3#VdT<cRgPw{nJQWW>vR+A$2WDpb0ncm>UY$G#KpE->
ztONrW3N5ce_sv0;<APH)Y<u=gbMSS5-+ej{gT)cS>e+eY^%S4Z@4lUP!7{#`uRTFy
zz>w4nPxFWvd3pIS=zik+o}h7Q1_p5C9tY(`!}~s+uY6kH^S4@p;vRDL7AP#hR|lTw
zZ(abpZCmkykL3e|X$XgSbiVfO{O#F!mA_@y-~az#>VQ%M#D1_HM?E^h2?%7zTmIG$
zSnN2<-^>O|T8ckBEPr6P<1@&DR?oknV~m_ZRTzV3HzfJCI70m8fthH1JKuoQE$EsN
z=w+&Kf1TxT<^dhvjx*hQbbj{j{O#NMl)v>p__9Q2(Be>#wUCT*3*^~Lf57)UrvCo_
z-=h<BYO7ZBGj?c6-TaW<L-QPe$1YItwIYR`Z|86RR#uRQ5n*k4p1<uA$UV*fnEBfd
zfle=e49b?Bhdd9y(sFEm#11`|vH2mpr{*dC4zT`KtT_(J<)E7(k$i4>mcLC1<eBDQ
z%=~Rq%nS@KnL%8fwpfB(iPIMT)~lc+C6Rn_mcQ)~$Uw09ejxKVgSa@&_W+xZH_k&r
zVT)>o6X?1|uobZ&D~v%Zz@cvhIwl{Y7G$vEd5_M6K8g=LE%$r_RWAI^U%;i$Nq*2R
z&ya-6-)aIfqYRWRJCA}gFBUUA6fb&O?s*3>1Kf;i1)1>@oS2Ez)djH`N9yKp?f(7$
z|I3x26aY1^{RZe9>h>GZ=mY!bH0Wp|#h;#*bHHvXj`C<diNi#2ev$n3|NqMnQ2Mic
z_|hH}SC$uF@`G+Vw7iH-AAd^-NXLKBrIwaIUlxLNfX_SwUCIc)64B%GV;{7%Txtt-
zA}DWJo-fn$_<qmB@^hIQ$gu}sf^OaRQ9R~pxdmLo^MfwLh6O$7umyOXbQ2r}kisOI
z1Dd_Dxf0~H7H`m{jjSjRbOag4;CcC>2hJ1=%h9}`dlexG1?=jx{B6H}{QvLy{g$ug
zMgBI>h4*mRAM#N=<Y_qt;d*RtLgcxYjiAdN!9#lRpd-R%{H>jsZYl%a@d0&H7DyUw
zBIxdIWH&YYgD!n6fH)WwQ%Kg~&04=e*V?0o!gJ6~hEN-CgQT(BcmSlVGY)#!eVhZV
zzCu(Bh(LO|0dzrR=W!3i_a3d+OI46k3#5iA4)g)nF8nQjL1ilFATJz+X+?@p>jVB)
z@VFb2yU+8tfv1|9|1p;pyoB_CK!q`Z;-HuVw0CFf!Pjv<mJj(`8bFqJgR&{u&!B)r
zO7f*8Nba^gUzQ3@<*|@p2c>e9JF4O7ee%H;9C;L!)cIRLcLRUB+3=9L;U_bHYYQk~
zAvIeG_iG!_kwG4<2TF}0ImWXyTEMg08B_rw!WSvbL6xu*=&ngC@LiLzAXh+gIyA_A
zAwgcU{3Rba+kt`$qwcE600;LQP?(?wH+U8W6x<~*&w*r#D}85yl!8mnmXi<<@waY6
zyLcWs$jgx2ZF#;d9UA2Egn}HohzSEV86ZJcs_)sEFM%!KUh;nX{~w$Pru_T=AACG_
z>w%Jso}Gt04PSY-UMiJCa!K<+Mo-IA#hH*0d?|@1{3=k&N<>7#JkJEu3lCXO%TxSq
z??GV%ZUlf%&V32#yMtnfKw{=^?gi-thwke{NC<(FFuW|l>y*-Jga<t>PnG3(e81;u
z`LQeoVi0<X0}5bl;Ry5B!{7h^zt-@ve2807DW_*=w8YCPU;h8^ywUuC*|SsT@XNL@
z|NkSp-e4Bl{cju4?RwpyUA<@>a4}E=wfTqw-XR`JJK%dk^);0{;GT5tfG-CH6G<I#
zko({raF0$M6)JSVnQ?T$9}JET_+L<;{U8w?aM0Zg$Q|$)P~#p_&hxh(fN(&?IzQeH
z_*HPKg7=eQ9q`|vsKVKi;UBskaF1>t6%YFKz+Ztn5!ia*X4LC}UxM^hY1jjw32MX8
zvIp(~s!ori^}rn<{-R+I{2r(mc^s_=eiP)`i;y083Ml%(tq_b>4Cy^^b}IJ3RX|-7
zcoh#CFKZJ7d8YXnJG2MR1mfcCArtC>U%@p0Ajm+l`QRS-CJ+~=`5vGmr4?^CAp{h*
zs9tb{^uXEq+rT|=BajMk=o4(E4Bj4i7cF|=5}^JxNj>mjkdA*tpa<?nQ4gF4)SX35
zR6mh=;BUcwM$j>;#J4?R<8>{d4(CfUdf*+HZYo9UfoFoG!F@w?H#Pf_*#rLx>SCjY
z!ZT105ZVL31(L>Y<9?7bVte50!J!H34$`y-&OX$8;LV_bg|y7b?14Lidf=Ay>4CGC
z4U--?&tU6;v-7u&h#vT4lpc61dJi0L|NAWH)cj7gE1jY9-x{9Xt_+Udz8syX{qGiA
zP;UjPrH!~n!?RlsJZae}=h1l+%LFKBwo37;hvL!ihe6Yw{4Lq6pqX0Gydr3R*W=)8
zqsGS|8IR1vkcm)~Y3`pMojfn#)7(PfwLn+FlV_ftuR!9kW0QTmYZ)B7T{${kK$FO7
zzO7IAJ3yD~K_`k87#O^IWp;QpKYrl38`c@~gmm^nlgN<CFVG}1WL|MGs1N%9G^Y!i
z5<2)$3v?w6WUkJEk-?MmEcj}pZefqkYd(hWJo$G$(dTcP&H(osXd12cAAgGqsHxT+
z%mGmc9ZdpR1Cq>!ND5$;+ys%7z$V!W9ye0F=wo@3zZI0?J$t<wJuJ@^S3rk^KzbEV
zd4Og{|1dBxyiV`{*>?^!RRMO)MIXbL9-y^rkg3PkkNhp7AU)l|0v?@MBx4|w5?Cd3
zK<hG_k1+ans$oAl+o$s>vb)ZLr^AncBAvelbdf0j1GG>0bc($2Y(C290i76cWCm^b
z*Y<!-jBf-x4l=XY3O+U(GIq${3R(@zzwUzvY$+3X1%%@cM$mz3;E4yH&Tl@QmwY;Z
zLX*@HVv;kY?gv?_2=WRnVJ`)RE=F>OBr(u}4$c!E$63JkKo(WR_;x<^Y(84y*&7F1
zRDm2qCy<v{fbM;VFR@qxvKH3}5BNMY$P$Zg7Zn!APWBI;jV>x2p!81AWAOXcJrwUE
zW!F2P;ZFR%f_RaE!2z6Co82r>C(2vTvk|d+rt`Xo;&~s-^Zc!6L4BXzYDN#sfBek{
zKwTxsngEc`6+eN~w8p>x|6eWzb@E$J@waG#CdZH>1)T2Ng#Utuhwt&X{r>y^|4UYo
z8iXBf$aYj>wc`j#TO7=eN7&S~odHQ(-sEqa4pO`iqy}LJXztDv<_{x~9ELv<K-$DX
zhJgGr8=IQ8R**Ev4r7qwau5%sxErhDQjj!AF&jv6I*8Z#-M8}!INAAjK6=^o>;He)
z#Lr7VP!M%ORvEq&2Q9Dw-3=b1!U0x}t(^4f4pHHF=>s<RtZ(N9kIrL0hVP(DCBVhn
zIsR65&;T2xK;mzPtYUfT(|W?U^ALZl%b)-MUxtCA5}VGM$U194bD*s!_*)b}UWJZd
zctBct{4Ej)H}rZ7K-~dZP5^etHU8FPpyLyJgBd+6ukkm7uCVv)gt?>TCaCv&98?f6
zctA^wmP@}uVFUJ7ueStNBe#Q$Y(C8BV|kCic_}Dsw7vlOt7RI(yqBO(so}SmkkG#m
zxyD(m`4Kzlgt>z+wLldLXf?oNkoL}(9<3)lL5m9<LEg2z$KPfFDo4OG<!?ZDziWcH
zorgRQzQSULDQFZD?yFX2kPkp+`~vkw!De`ZmL<FfadDZE1hN3)jn?y^<N-3^7)S@$
z0MN?xm)k*HTn1EwT;6(uzqK5uI}fBBth*m%eLP6K^FCr;!UH)cz~^b3LG>#{k$&?-
zriPD94F{PT9<n$5WC4Y7t1u`yl0mLT3|qj*{5=$}d$hjbpK=JXaDW$7N)&=a85Dfj
zru(izmIs)DRu4gg;0&mX3>qVbxCGQ~#Npg{Q1$`&yB?(F6e#V&q5>SF5ugrcF2op=
zX&umF6L74T`ukYkEA#UBe#_JHVwn>}DQ+8^_A)XsY(xr@mQY3phK8R^{H<c3K5yr5
zc%7Ke2&yBqIiUH)xATx^=S%*UN1%D`)1dqW?xBKQwI7rTJT5;+WRBK7KcGeDW>6pW
z`z;U4>-=rYL4uv&+yT~$+nJLNwOoQ(SO~HZbfhE1Z^#yUKm$A)WH2br1tHny24WMi
zr&;mG|NpN;F-`UXMarx1P)|Grb;zNfxC&wuGIqmv(4wn656@1w0MAbFM7d8VywUk`
zHOLI)wlHQ%R;mSSkcER1Wor>AC4zQ(ZDc`8&(5Hm+o$0uA1VUCI+uY?x&#Fd_!igZ
zU(97OFF{AILOhK#4vITKx~Cp&IqBPZs5I=QF6ho4u)on_pwt7D0-Zg;;ZtT!z*v6J
z#5gD~w%qym|36{|d<LlF3@MpQC4D-x1)yarSZVdQ|NmdE0+k3@0!kPbP_`beFG`QR
zTnlPKV=rhboI!qS1<m$@ir=;-kWx^H_`j}#1R^+xBQ*rhfiz4x=xMnHoX?Brymo_l
z5IqpAK!IQi4Fp|?8k}JZUJV2CS?hIBqXJY_Kx&XuZl6v~-_AoXJHLXLmVs(U<Ql2e
z!xK_<6lp`&N`MDm@swaqAiqMhNegH(l251ROC7M`paKn}KBy3dC@xI|`6tE$6gZl%
zLm>V^^D`)2kmzklw&rhr@aO-3@D)_dKAk#;U(QDFexlyziL~DUy#5+r|5Fpx|Mcwk
z<?ul7fZ9{91DZ>_4yb3hD+lN>Uk=}HihH2VxO<=pr1U^RmnnOIJAI&@Dq0T|)OGU!
zclxkMZU!~ex`V0N13eF_y}^#b(#aHq*oVCb3YxR<06PYY&Rj}*pj{x%2j3VuHa-D$
zNj)=<fX5*qy&6cz4ZR22fYt-u0CqXF2l^bs0nZG#>as8}(5(l$3>3Qf`)ZW;Ko^6&
zM??=4beJ-S=OF2Vo+Ygd3hLLvyKehI%_ZapE4T})4yw|ZfI1<d-k1icCP1orAYD))
zPy-QEdH(|S##lgV5ZyyizYcCk1y(x_gS5rM?0ASxO&h2&=L72TO#><33sQry!w$Kd
zYY39V@CT?7`%(;M$1H4W+FC%;AUljec9em5AWwH;Ra^p+1}O%0xnHJ%c&J^_25@fx
z+UxWM1rbIUR73?&4^%|ur7zf2NL!S|4yY>`9Z*G(N6|Z=k_b1D(*eDO=rBSXOZ+XD
zLESe<6C2d3fHaqoTM+!MI6I)z5$3%FtxGoi_A&$PLb5xc?EGyccR*P{J^-co-=Ov$
zcs?840eu7FVsF;*cOZ8_FMtvU$bjP@9bf~%9nc*hE-nM$9ncDx?tGAPux@Y%Gyx<&
zR63w%LA^=RI-m_8Etnn9NIG^v#fj^HJ_hv%L1h+ZqZFwFx);_Z+yd$bg8L@?Z7V>6
zklX?8$>3?ALt3if9&ZuILi`=j7?8oBG#89yn>&b2z@BC$d>zo&uny=WP=^ufiEAJ>
zA!9e<?|`lWnK4iuQ1(ID0iB7j16o7d4k&xspzDBkf%}Nyni0ABpiT!=7i>6@9Z>c%
z+IK+bpm#uV&wm<#_y1n<?EK=<`4=`V)ajz4(OfITP~zy>&F<Lk&+&o(Acte8zW_{u
zwTp@df9o1h7qt0^0dZ@PJ-TBVKog@Lov{qqXGT3c?|CX-^He+rn?UjdHBu4X4vdC8
z>IUG4UY$H2Ji1*iJgi*}N`*W+-}`i4hBTWxZ-K-?2evf3T5x!F%R6?vgC<5rJUVk!
zIDEQu89-Oobnt<?3!t4*44|F09=$p<Jer?AK<XhPO@+Py`2jR?4V?;w%pHQKLeGI)
z`aazb93I`F4B+X?Z=U?Sp6c^Atp*LzKzsz75G?|AAG$*!6QbXsv$Nn4`(ykqkgiiG
zWI_~OG6od>-Jy`~D4JyJLXb_07om;^&FEVG<Oh!xL2tAMZ5itIz%ohd1DYgdW`s|Y
zD#0Ci(Z}#3vI7tDw@imfLb|Bvl00w+V$o>;I+zDMiRq%k;nS%BoeXGr$i9QYfq}u}
z@&k|N1OI(H-yr4zJr&P*Djso!Y*OWK0r}ta;9Dcd#;1^e>QRh-s$Zwb1JCATj2_*t
z44|FCt?n$KVc=2*5759w>jC~&&}l>--L8;L#Bae4c7^m*BSFI=xF<@xQ$Wss=F@q}
zv-6%u=S^rzJL=i3qvFwgl+m+OM+G#ljkyKdqw_VwPacY=LHo^7Hoj+q0u^HiE+pAN
z`rjVMSwJU_F*r8YsK_vsR)99AOL+FiR(OEsqda=E5<I$@kS#gU?Umrs*>VaryzkNJ
z!~vf_y$AAgZ;6TmY>PVRq9+B<#v>9S2~Zw-=Fxcz>^X3bg7bX3Yg8n<T~tIqIPxE4
z>vT~O@ojxu!ui3o(G@(u3X*c{bQkdHE>R)4``81r1Oeo4#n%|&kp{|__`?GdIFKpV
z8|ZtJHTYY=%Rf<?2%zazkIok!pg9)M{a*|omhU|}kMg(XgE}{moDR+-6_AP72#_#x
zZxNhNZi702wje2}3m6$ZKwUv_iw?Q}3sT*-6{HYhwB<4WHt=@ixgc?HFBPkceu26&
z2yMMk7d-|EW4H*kz4+w`uoMFrfL!#6za<Q02fFGu2aqVjXv>5AZ5$vkX@JCWyQmdp
zK0+JJMR_1$bUWI&gL;_3U@5SJK!s83C;k@D1{;)_Bybp=1}Q`s4RR5vgZ*+dNE}ki
z!VK6876MJ?{|Bd>PhbO<gG5mcFa^1wA0*!S-WNJ^;oJG@<@}$Z2~NnRTrWYrclb<j
zFKBF{y9SiSOH?F$JFkIrfN$p~P;!=d3G%;Z=Ud;-%buM#eLH`6bRP5V{NiKy4Q=MP
z12owNNe1Aw<OwQo`J3;85;RhRIpN!R+^6%jZ|5!F&SyTIZ~0pzK<jv;!CCMaXpIks
z$*y1{z<x(IIRX?A$R>Ms{^M_v26_FsD|pK}tgvel{tcSdfqKBR^Q}j(FL>Ix^E=2N
z$jv1FR#A{YAOrJY+kzOubI71I!O#Ws;5fMe_lIZaKaf9K)`9w+uxVvT!P>I?7ly^)
z$>q*ZAd3+Tk6QonxBdlHWBcLWY(5Ujj8Y)qL!5|aF@K8(!pfI6zyAMsHGJ|?2NVEE
zz2%3Xg;}858#M0>x;hjZZ(zetfLz{s4`c-*>MYOkx19zFfoE|GL9@7fKwP+?9+2ZM
zV1`}<Ng_uCdeF2^2Cc+JwE)y@1x-@$w><+{PzX}ddEDdRd#&c@>>iyL;jTW<-yw`1
z(?}Lv1N*=pq#e})9gtA-e`fwR4bX;hSr8YO4~)<)041f?3!rWws-d9HDa6(8AVb%I
zRABGXfsQ}n@PKVYZvF`_WI*eq5!2f*oxsz^pc4bYvsaKr2XczyHI$^rKjn}|cZ>>$
zm*tkrpjwT;xd>EnJpiRt__p(dufc{u5)jyse;%M*?P0m)K135}>n2L%V+7+5&`Q|p
zpy(vZQ*|IuAxAto*k*zZ34$AfGWUe6*r)StX*#sx2IVx%b7c|GX}AE$2mwYfA2m>$
znwgNN#8HctmJ6`yab-}K8P*26&B(w2DR_K3OF5tg1Uwx0TV8_ti+90U2ozZ$$2;x;
z&60aweu69Pz}dfbJ*XRsnp)<7gh2EASNPi|eEa_&wHO7NPr!$e*>tGKVC9S($cf-X
z>cEjiloKJjL=xm4R41~5gudVRwEV;0_6yv(Bf?qD7ry@g|GEegNnrbTK!WH2N)Ull
zLpR7!R68p`LZD!|z~7bwVuSrbASjxhKq^5A+NZPJ!=uwZz@szY0eNoT8l(U;Zu$)B
z3UJTj97-Ak@1{P--#i&q)*>fH{?=!pol>yYu@5Yny!7cT6!7SF1htcqlF9im|NndR
zdP=<1|Mma>MwXWqpgI&@x<FS#LdwUAG^leR1#anV)Fj^nDNaBW+OHcRAxbDDoIw-%
zD2|_c@O3ssFDN!(t2$8Z<!_Y-YlGJ>pi-U(Bm^CuVgRv;i3!L$0BE9w<R$)=B$PD)
z8$SR456xTrEn7efY_P<OHc~)9;-xqV&B>LZi54kPF^3~;bI~-s1IH_hA3;kmKw(@~
z`4V&}8m`p>DB(HfAgt)T4k<cQ{{R2~8oG}iXAqYbBl*bkTv-aVG>d^m4S{F{?a_v(
zFley0a)Z)UudjqhH@HDjs_4_H2v_vd^Ao5|_rjysL&Brm0hB~b?t_=EJ%d&s;2dzR
zv>du*8&t|R9|E;!imY(0LO^b5!0H_j%RQgL;m`y=i4$1~+%ZrWw}8%i@aZ&sx%MMy
z9Ry;e2&oxT;eZlr=ti`HkDNj+GC-&5fg{o9Wh*F(!RZudM4*{i8j2b(ZqRtKBQ9RR
z1Inn$y|wr^Xc@$Z<_F9^oh3&ZUhe+@+XzqY_>+@oH@hcj{K<p=AcrT$0MrIh`<Rvk
zP(d^sfb#5i2QQ3}AZr8)yc7ca2o!iJ1Zg8srJ#lpt`VqL5J~JKQ1PG$p#2CGWW@$(
zhz!d((k!?Gu}Jd69f(EJnBoyAkpD>?f$~Bhftn9?BXk7n1B3%Aw)k6P25bZhybK2a
zhzphxC;_rYpdNy}OzsGj0BEdL;)5suK{n7jBMH<oD6pjGpc#Y;05zeB8-&UM^&$|1
z7_b4BP>?Xj0LzWP|Np<V0!blN*r)hgPJo5L6+bAGD4qh3kASvPBaH!r2BE;K^}$OW
za1Z%>2RR<oMGrv27%p-Hx#%cZ3T4PA7~~>!)otMMGlbEgAs_Hs3Gl&hxLwo)G9RH0
z7Dm}1VRSp%w}6I#z!88thI9{`>NfEB8Nz6gi;6)8Yyhi9@zO4^5F(HvgHTIAqNoOd
zc09c70g0myLd`}VglY#bQGl)mK^cS+KpTV-cnR`9YVV24gHWJT>t0fA5K02%b@V|f
z0eTEVtwxLpLEDV{ElX%S2<3{f@}(to5K0pi0NC5?{2inYLb3C=QDYEl0%!yXwOLsU
z5&|z3c?KGU$^&u9AB3_2X-Bm{6C~99pB*{~B?aQbg9U9E4f`O}S<ny@s-e3;LSR>e
z2ccGjxZnmcfgZ*X8HD-@8b6|R5NaC8kU=yEr9jFc)HBcs4_SjyYe2&}sHp|KJOVV@
za)rOGmuiDh&LAg}H3%h!=|pCb5OfggJ9rd_m_ews#1BGsfDA<qmQs)qC|EA=w`GFZ
zMCBlRkV<@mP!=EsSOz<g2Rb2x9h473ouTR=6gxk7SH<udgjzfJ2BFx8;UJXTARdHT
zMT<cw_Od}b2(<?^2t~>G6KMTYI|u)|510#})`EJjv>bo(r`h<^AX)%b4C<TW8h(PD
zUVvi(R4gd`X+Qj=40j-wL8KWFN$d-tc;ODjqSKJ#;U|#)NgaOjKp%dZ3w9%P_~{*l
z0~vmb8nEG~EKs15Jp4r70;u~SFOxg`1YQ8;*bZL)#J}zX>gdzpS^))KfJ5BiQyyrP
z1~GU68(0Yk31bYbfUgj+0ZE|_KAi#!A;v`@gHNDg7_`AB@NtiGK&o*M_51{NoiSbX
z2qcW*BGB=UFOP$zP)2I74xY7vPNhJ0(Lw$;cF^dRI(`?mfXv5qQ7%Xr!$sRbV@E+?
zDHIoB9XxA01yYDG8Z`J+3Nm05NE~(aY7bZl5y+6ir)3~fR0B*v2K0f%Q3s#qArC%v
z;v9U!Tmc30KTQXp!l}9fN($t4^uZ?~dJI0TMT`W&2cMSFcJRp^VdYC}=-`t!C;;H2
zEGU!lqz^tZQ)lpL5@_THwFe41IRZ4N30(nI08&Bz;FBFlJE{fRAR)vGC>anJ9xOx+
zKAi^*Euk6;Iv)b!YVhFGT968&y3Rvm1=M%YxDlm;PcuM<45Gm&B~k{TUVuh+$QpcF
z2O7pfO)axQLZDHWEBtN!R2zJ91v!zd!6yljdr+Oo3KD`2KK%rb-VihRbe{OZC-8<G
zR6EN-_JD%r0)JaJh)q-uas;WwH~3@)Qb4D{r*l*td}1DMgHP)R-{2GTFdTgH7{r55
zYiKd}#5`CBpZ0+UpV045MLGWk|Nc8?==vuQ@BkF%0;r9kzAG&Upn_>O05zBvK$U@p
z8*q(4y@p6)UjUT=iU8V=K&e68zyUsO6n&T7Y=|WG5hww;1F?)inNU0e1@b?sBT(Mx
zBTx&#ZiJ3NeS~lzBT%seHUb4YKnHY>9%O5wM<(XhLTp>`$XfvQ2;^mQN1z}Jpgh|l
z%bzgDpa$6rD1T5dl(<2tY|!`%Vh{s12o(Yn#u#7$9X$5Z5+sE>2z4ARgcu)z3_@)L
zi6V>!t$+d_7Bdqhj(ZU58_4kpZ7>(z2MJ@i$Q3k(bObDgGUO8kvIAXp8+iN-VKivS
z2Xs2lOYp@TxLwo;G9RH0=AtZ+FuEP>pi3-Yf+GNR3<=z=L08=d9zR1E4RTQtXbfpR
z*lZLp?F0)U0vR$0wHPFdYJefg0MJ=19;ky*vyca&Kqt{+--d^|0t)1RnhrvNwvAG6
z1(Y}_NYDqN_~|hS1wL&MZ5!TV+73dwAPquUKnI~TKmh<BZJ}@wib^Y>`avT=s6Ejd
zkPvt+5qJeuE{IG1Ae1#oJE{d5AR)vGC`k|(9xOx+LY)B(F`*i|6C?z7HFywe6^Khz
z7kX$6LVW>^A5l68H5FvYAR2^{CuI=oDQJWTTv~&p6|~cX$ZdG5LBlzysRevODQL9i
z3V&M<)dr!QKu#oU5K0u&iA*3N=pfWL@F)&3gHUIPAB1WL8HyS#B_JVCuw3A8%K)*#
zK}~24p&dvizCkE+kODdlLY=1SAk?s10kvlE4MGja6;Q5&co1qOEe4?m?Fy*f&_O8h
zO|%dK&w41>5l^5qpgcNHgYU-q>e>0HyO;xV*i4CtM>ltOFi+=)5BwVi9XpS|)MjB|
z=qyp;fNrP+ogPc@3>?qSchIw*j)Kna;cwXo>gq!}Z=fS?FcyEHp7rz+bk>t+w~LB}
zr?rcUL8-7$=X0cO&tMs!P7Tjy7ZnQ*pKk4LXP!<M6&~Mi8x`Ny{~nz&DiZu1Cqa8?
z;m19B^~$V(+=c`1+#rskfb?U)ci{X09aIF`#SA(433`5v10#b6=nfng6%G&ZB{&}7
zOK_g+7u7-cbv7_Ecy|5+Upr$A9<d1q9r@&8_|B*G8-ELA84>8RnQJhizYtZR<DDQv
zr4=5a8*Xlv79efigsht_j)e+=^g!>qc?G)X#ua8K14ssP(6EQ$OCQh$H>nUI(7+K)
z=oCZ<bgd0c=pFcIUmX?C=HraMoi-|<D}XT1H1h5Ii*SLb;#p6{qmJK?L!wp$G|Y4m
z<9=C0WOJVI>lAqbIy4D(qYV>iNTd^Xqm56ujtb=N8tCc${H>WF1&~w5`CB)GIjo>~
z^XSHMr48tiCZEoi;3Hf-JC9M}geLHkFpM;c>?5?{p%S0Y*Pgw36~4VWDhZz5EU@eA
zK;f-;!m-;&CBd_^<qT*;v1g}?3gUbwWsu)c2Zw4@6g(S`gU)C20iDnE&!ZD^#SJRY
zv-2+K<fYCJ-99Qj9~}8N`Z73n9`|ki20o+74SYtEXSa+B=u9@xP8k)@d1jdL>Ve}H
z9DUGH78nPzp#%Vg138lE1vn@E03FyN;b{4te~L5OS#lZd;45+PpCtz#2=TGJ&)*8Z
zSq5^d2WbCxZ$0E#nC0k$E8vrfAA*KrdO&MiT5s{Ud<Ut4H2T1S4>_3_e3mdo6l5Ui
z9Dr3IZ6`sh5%xxcxR~}jfrOEVP{8(Pf(!sHBk}>+I|-Ybwi=Kq<ct%ry%+i0z-J1l
zfW#5@egSoyG3^C+1~BaX2pVQN1Uh&YWUnsBBy=@xpgVS;<u%OST_A1$VcIycYWoaw
z2c$3rYdgr_)(p~i8>FrCxo_una3=HZ`~^M)!lx5@w$cSq=tDW6RQd7%_?YA8KAj;d
z0$?qkyFuBPfq{_$bfu2KOVBY;zM!*}Kv(KO%0K>AIZ%m>h$Tqb$KPzv1UkRuv`^~|
z@GS&~K`V!<K#|*d45kxw@Cmel0y!L}b0zqumK)##re!|JbLgiUgN_k~x&v~mG0eof
z3=9lNA=nE&66r1YkPMJpK!$?c(*hbq@_-G#ID<#FTYSNzJ~u%(20>0Xh8YVw)(y#6
z$jJo!&Bs93m$aUMo5>4yE9ig`hL?=LL5CdufB76FhBS=u5`J9JDgKUcAOkv2dVp>M
zi34R`L@<I9yEjM(e6-O&(4{gqATBPWeBi+ib53g^Xs`#>#5j-;*u(_THZp$@7ng~(
z;AnvRt`&5E2vTf;94G_Q4>oQh$T(gQ7ngC<z{Wvhwe=)ua0S(A+dx8KvsQu3S`Ol3
z@8@}1P63z6{LOPfhfaVMA)Qt96O;z9-@OC6as_<%&KFRb&fok3R2bBO(l6N67{?NM
zT5h=lQ7H<#cM1{JtxBM?jMcyqg0=sPa3iSX@M(qm`y%L^-}hh(LE1p01+X(ve8B0T
zGzuk%%e<i{Kse(#0RnDM(`TexcVJ1Nr3H4h5a@tm57<?7bHEOOU%LZU?b~^pzr_~h
zKyZl-4pw9b`gS5`pjKhfP!?(wGJu4jhqQo3hM-v#Y!XIq9qw|_(Lu;g*aaF6It`9Q
zj4(oqfd!yZ8dUpxK|)ab8$oOWHaEw7|NsAWG9+k`y$X*nMUW||mhgdupq4O!*n}*(
z3m(YHQStEXbWsWL?2J)yKy4Vmyb2mqL79Mo7LlbINT~r*JQjz75^<|7=)9TN3=9k#
zSzdC0kF9|nU;;hf64V&hJXH|~R(%K*nyB6YA2toTdL`@S5|Au@UlezN%$a(y<s>ww
zN>g5Hz>ncU4Z0JhVMwmFJXhupO~dw(fX1B?K<D*9&F619iE>WQCeT<7^zI&655(O)
zaOD%f{{R0HyulY%zm&=%IRhGaUOufSN)Nm|0roNW5DNhLv=wxt5t4RLVFx~m2^3;6
zFF|Djj^lYix~G6H^8pte#r?0LCxoGgkq3(DWtPw|G9(m6pu=}yo^D+VD*r%L6{OK!
z%J0#s36*@=02*<Ehea4h^@a0#AFvNV7nDH?N$~NwK8TFhvI-n{nlI(S7GMuVWrT*(
zT2!Crf!1V}nZHhh_!KQ%psp_^J9rMYT!Nax-wK+w>U`1sfY}3d15o~F*vU79`r8gj
z{cQ{6{<a6A!!7R7%?-Je=EDaM{*8j3oyT8-&MxujEKw1F1~z$}?xQsAbb~u<oh~X0
zNZoD?{*Ke2DuI-4H~6$0?A`7JQo7w1pe7->3k>gL&xHtq7I#1!U@hRTC-`0+s45b>
z-EUC3-K-D`Kr1(39cu9A7Vs5A7hyu@A*ztO-JikT?i>{k^84MAr1!hoLA_0+es_)v
z2Y;&(NDxvW^0($eIN(-n>rOC-o*i%SN*KCyytP1n>n%|+Kpc!*qhdf@#~XAcqku=}
z2aj$a6@?F;puV@~VCZ{mc!K-h60kzY+C{~JzqK6F_jbU0jys|+x)anh#O#YM0tut{
zGu!Whn!VsdO+bCoParjr#sMhBLk6na?jS@#eKSx6xE!SI2uK`ZFL>n#roG_9V=(MZ
z0~w$M>UDzb?FE^HuBHuibu6^_1lxO&zfB*cEgqyAVeflTw+hqV8z5nHGuz*Rdc&Y|
ziNSq-@F~jZYTATA=A-uc!AB&6j(G-aV*x3^(Dn{wA!^^d0c6`X%)Yk<_<9#;-y3v&
zFsvgEPM9zEBRby_SUTSlFOMO5r?6_Bzf}=bZbKpu6kL#I4u3P~AYw>+9n{%v-3RJ?
zH-lmqq4O$sof}}?G*BtiG7IEA^xpR*ghNn!-}gZ+14J0Ydf%Urdfz!J93U69_<;=u
zca`B63%Mhk3p#ulTKc!%LNyoG{RUkn18!%)3}r(Y`Vw@vtgGSwm*Cx8;NBhRB0`kL
zF@MKzr2cmbs56HMNl=0h1PL|&V&`vT26aiDKwMl#1taypq3&tT1oekejSK?`fsITD
z842DLgv-cQa8#V|>4ur72GWdbo-jxVY~D<ec`P6<F7xJr&AS0MkH2+4sDq7a*cy-!
z*sx6?!{&mx`1=L?&7d_}kd_=$7yLIU!iejFKL%y)W>8uLI~z|IToBd;hXn`dGM|^a
z;79>=6mj<}nzccB3)BY(CF<6rpg!(bu$3TvC@oM(Cp;Rp$?5}boV!3girb>5pD3Mh
zs6$&iVZHEFPzM>-3ttF!0a7m<q8!`}*9SRq9;n0thd;6tA=w%niJ+X+$^tSIH6A~L
zx~0%A>QnG7J>W4duu-@j59x;^Ibs#4BYqYfl^Ed!>JLDa^0)SbtV4A{4M+&;f&vhm
zfZfgBpq_XNBz%#53+{=7V~rnV45}@EK>cQ@EgwK^LbjYH*cCqvGKRFSxCN*y{ua^|
zXTsAJj|X+ET91Ij6V)3VK|;;H*vqnCg1epgeSzE+hr~c>>PvN;eerPAr0fAr$_|jA
z#+@1<eQ}5d{4K{(I^*+@I^%LEopG4@8c=WC3|tt&hB9#V#`nKG3GzQU_hS^%6_DQe
za*zttK$`**0tH&k%T5pztRGx@K-7UMJH>OLASb3b?ui;oR?tu~A{0uH-Z<3Ptqak*
z;{xFBI7IekCb+u{3ypB3HV&jdBf3An4s_WvQvPd!+(xYVk{xUV_71rUQbk!>kLue3
z4^TK-yv~657B&09tDjP`!wB3ZhlB!uYwe%^{}Fxi5Trgi%KW#-j(>M{%_s{o67cAB
z7vR?bcW3wo*&U;OjAc}OtYsM(7#K>J&YU?6>CB_==Wq;n408+#@a(+i+4<eG^N(Y<
ziHc*liwcWlFOON{!~g&P%R6@Rs91h1=4d{^=-BC^!s65U(c|DtS;m8oojxioj-4MI
zn;+Qox9nhKU~t^&z`(%Zt9j7Z@*{uSaS$6cKU@gv%QgQ~DAM%qWnuAXJ|N-U%VX|g
zd4j)LkC}nNyO+hlhY@sRj)afp5B@eOW(Eeslb*eG|2;I%`*eQtXnw?8qV3&l!s5|<
zOv2;)t=Bwo&zw1P#*u#;3x5X-pGWgSMvvx0jHT~9KwD&+enX4~*(d#)3!%f2f13z@
zM+nDXNB(Ug{EQtT9RI*9rj8Jf|6mq#hX{v9^FbC*%X6g{UxF^q^=&=L-vU~B?AiQN
zp-36w4H141%M1L?Q<)eTJbPVKBETMKXJTM5yyVh(;QI~D3qGC4Jet4RduU$sXnw$4
zqU_yk!{X6=T*Bk~jn^z7S2^-;;}P%R5eK>5qxk^X{r{MYf_H$z(ns@vhvo%O#tTsI
zOZzbX@@PK9Z212*J4o}HGiUg>`B?q!@Ui;~V*KmyvHJ&N{O|Cw`_I3P$Et(J&ZGG_
zi-+Zp(yP9V=Y2KLdG?m5NbCZe-ue8+Uy#$A|2Y&%LW24Lc+mCVi>Dy*&f|{F&+L6c
zk+=rL2SuVh$fJlDY-0e&pb02iJuQzHR~jDh>@EB6p?M5q9&?EjD9SjYt_8;z54&TB
z4~qoIw;*4azVT@O$IRaZx?D1C0w_En@{au5eApR5N+rQeCJ<8!%wz^Jr9GMtuy|S?
zD?RfPbo-T0=Le7G2M;`Y3m$lMe)2f@inZ5^vH2mhNAtggVgbWT9<3+&Tk9DZ7+!*h
z=6VbNduU!WyyVC)z#{I*FW@6C;K(oNA|m0)FX$tp;m9xGBCY@yHvo%UfW<w);tpW(
z0I+xjSUdwPo&Xjv0E<^R@(cEefQLYvUp06%A7d$<;?a7t#K7bGP1N*=)qaoWLkgfI
zU3%Zs@)&=ME@)<JF{o+R`O%~K;RBCe#|MxTzgc_37@Hq4do=$@D2_G!=FxhIzZKLP
zc?mk&`}@7-XYxLsr#v)2K@+Wp;eYh}Bfw%0a<{zzzo3i72Yx{w&@u!C56fSrk6XX-
zw;KQb|NrH|zyJS(lWya2u$OwB{(ESCF#HCJF98;FkbZNJe)9?Zf<ER8K%rp{4n1=N
zenA)W4It42U{P?`nFoMGFMvcJfJMO}XI=mj1-Zc7qxoF}D0)j5c(h(BffXDY9^Y?)
z;tOG)0Z6rhNAocSa7udQWBHN4^#G`Y(|m-(F~%{@F&<A@2uhSF<tbu+TR^uzM|V6=
zx4VExXN}5*?tGEgtRUrQKnrj>JUT^G96L|Cbo!{A>3rFFsPly31&_|_iZ={Tcy^xf
z>2y)~;nHo^oyP(?B721k;|a%J9=67V6-%<N`*fD5JUDoe9kjcpgV{%=!|;dV3CCU$
z4Z|NGn?Cf)2s9oJ+kX7T!NWYACm2r~yQp+1-sleF@aPOtc>&_}iir2x2s9qQU7(<H
z@VFr3{mvVPClr4ep6Jfw0o|e1(JP|m30hrIqjIB{MS%6)xxEJu9uVvNWq6D6hvK2`
zJb}&}l{t(r4R7`Ga5WxW&tLQP;6e7zLyQLve<_~o&J*d(QJG@+i}7`@j8x-ctz+%(
z2M_Zwp6)zlcu4V<;USmqFbNmN>n@!kDhphCd8`~84+^^(tZ+PdP_Xls;VDPPn=Xo{
zy6a>*YgA4!{xCe{(ksK{*m#(6s@q@3gNMaj8Be=(o-n-OqIkpbMt7J(XNbxS#*4i?
z9E}HW%xK6wc#z$N@uo}X4Hv@`iYHtQPjrW=bcU$3FkbG}k!U=+{<}-}!J|B#r(6tg
zF`iX?<<jk@;mUZ>rPD=ahl}AYr(O}R#zPyU|NlRDNRaVW=L^FViWdw|bl2%PGXCzY
zQCZ^FD<k39czECSm`;#m92qZnUNC$Ca?6YEID^g@l>>}7U3yhG92<`)2~Nm%Ja~lN
zrSpd21y{y9E{YGj{Y)6o8eZsS(O{iiIOFfZ13WH_4_rE*x)|P7JnCY2w>!>)@s?xf
zO_yFBEyu>Aea@B391k89bYwi*dDO-5sf*%U7sIFBVKyLZLsX79_UdRi9#!Pn;(73>
zm<!`u$IjQThOZqJ54#$^c41CYS>fI*qwLstI7wCRo8!U5td5MYT|4hM8oqH=eB)^N
z#)a{MV=oH}tHWl80|yUqx-i~w>^$OXc*jxk4Txm?>)xxP<Jfp4Fe*;X@!%0YN5&(r
zolhMNkGd+}bu>Kc!uZv-ca83<<J(?39y}`I%J|f!6XZUSPo8$is7!HWyzSa6qwUyu
zI95Ra8pr{zjIUif@46Viby0i@A{h^Wf+ASNg$ZIm$d`A)zP#(mc*PZBedDu*H=x$L
zbUrma>Y{kp@Tg07h{_yS#;Z=fYjjWizWn^)Q4tr$r;eR(T@9Z)Djsz;eCom+qtfCI
zvH#iGhl(Kk!2xjB(eSOS;!{V%w=SKhIzv>pFkW!$)zNTlJbI1Y{IKJ}qnxgccU?MP
zxES701QD)`f82Ui6dW6mwDVs50&<Bf;~SUG2QJ`vcQJg?U86FC@o%q=M&r@9B2lgo
zr-1Z7Z~+<cz>)E^W9K=S&JvY9PQ5G=tgJ5|uRM5wmGOmR=V3>~*RG0>9SvXmbo;2h
zaAiCTb@7kI@BcU+Jk06Hc-XZQ6xxo8Z$V++U88csmGO^rFON>+!JAC^=?4$;xiH>z
z>^$RYcn1_aAiv*r>2^^$;KF#+v3HGbmycHO!J{IKXB`dSFx~)1xRd3t{|67SfE@6~
z(eR9;;Sop1-|oFSGLDT$8^0B{J03jB?Z|i(>O8~O%swhhTzh4>9UBiTCC<%tJa||D
z9Fs2%54srMWW4IqtD@=Hc!bB|>0if#N5nyCz4NAv;Y%08hs-W2D|%TNSzTW3TXOIK
z3plwybTPbXcn}<UI+~3~SDwG;eeftZ<I&E8E`|>cU%E2>cJ2J-)+;0F*myX>dp9WQ
z3OF*p?u1z9(p{sn0}>~Sj*UkO_Uzw>uoP^k3*!fnmB;F4YoJ;Qy1(p!3**;bkhQ<m
z7rsKa7F6=xaAdp;wYb&b{S}Z$kt}9TQCZ;DtE1@Hc$8JPgT?XSQE_lexe2oMC9{i4
z3&>i_3s-J}t$pFr`4a3?7sjJ5kPv!0^Y$~xgGaa>8IOQG3ksm_7?mTAjJKV7btD^)
z{-{|bfAFY)3n(i+G&~3ji?eRMGMbK!hf~AW9C18&Slos2gCi&xJ^X&rg%f0RuMVSQ
z<53qS%`c7zkFvQkUU6l-+xg=A1s6_G;)SN%>HoEy9S<JiV$M<70#3a*Kng%fxR*zx
z@!)dhDXR}2<OgM$DK3l;T|oLdPq-L9aO)M3aBMtexnS}i$AgDNT^Wx$GM;kjd;rpY
z!SI9=DEl6cj7~jxfX$KdiVNd~&hy`|a~^jwyzbPiquzLQ(ixuqgGaes7=JPzb?LnR
z{W|A+!{fa?{EY`|zr6nswlYLz1>?)k<KM4yo;Q5&*2^O9*m&S#Y)h--!2_a>j3<~~
zRAzL(|9;(t^SI&pUK{qt<NkFk@(&(ob74Hrc(?P!_Y0gqTnrC@bKiq!I{ywH<zoEH
z?4z;()PBCe`NHr=FAE2&h%@8jg9rE-U$`*4sO;(d`TZj2LBp4By)2B5jRzJAa`<_4
zi>N?sJiuI|GN<z;D0mMV9_;0@Y&_Uh7ySL;K{gl0gUmT9OCWA_F+AR@qu+Sc^pn+I
zun$kTfFu~ta=te_-^;?zy8F^~Es$+3o#&Z-RL+2H2ZfE{dnd3rCSGoP4O$b}aqzgP
zNBa%N8zAC0vx~|H<{XtD9?i!bJem(3;BP$x8j$I(QMu6R&(Rsr)9EhInJ)sGUuizV
zfp69V+}Ob0Ukmo={OsBJubbPk^NeHj6MLs)F3J)OKE2fvptd=qXY&_(&*neu{O#Z+
z3ye2FZF85-N1TVg9pW#E^KE@nQs&tkqVoUyMbPqx=3neZ#vYxgd^8`uW;%1`7z4vG
z2S$ct4onQk9GDr7Ij}Gsb6{mS=D@~q%z>T3qxk@bNAn?$((A1!OY}Xy-#i9d{CI#7
z+*bYkTGq4q$q!G)Bc7H=$^`kt52Q`t7X;}M@UeVQ^u=)xsM`VVdw6u-_v!riqVC)O
z|Aq%VAa3;R^-=lJc?#mrGEjTHrHcX7vkFo94s)rcM{ghp$f>aY57F)gHNNdYjc;C9
z(1K|+_j@!y{NcfP(8KZ|s{1`GPZWLW=I(Z8=@kJruNgXpJAwl`PaS;4+7TQGqIo-l
zgATqF?eGrna1QB64(&X6@TEY9ci6!f5*^Or$e!-}`u~5IGlydbTbDDZV}~1Kmot}R
zhZ|FuGq+=h8*`U4k7I`$OP4dRV}~1SmouMZhZ|d$Grwbp8+(_tfMbUnN0+mpV}~1O
zm$Q&#hZ|Ryv#?`_8+Vtph+~HvPnWZ(V}~1Wm$R5-hZ|p)v$$i28^6c#0~w$zj~LG!
zYhj)N8WlL!!aNg7&w|pkq4XRmJr_#PgVOUsG$;X-?gFJ;>}_k5_OxS|N8=mNd^v2^
zuCqmD185uyY23m^1w7r@`4cvLp~<4+3A#%1yGQ3akIqBjSsstxJt_-8BRZYmApGtY
zFyEtlipmO*f!(}d$65D)%`cVqXgmV4*D(&W`R{==aCznos(UfVO{gm0`LXp|iCptP
z{$dl4<Ln?8<8+=!uP8`<pA{DagR9{Ih_4|ohe=s;F)%pp;Adc90Ly}tGqQg?y7@g?
zPnHUxj|DjfLxTWjkQ<U6sQ!hG5B=N8$iTp0cmOmZ%vX}+2wsloYWU=}*nTZWkObHT
zj?G6HJ)7+qN-P|k|8Ukn`8<I*2-8=3!tlTcU;d4DrTaa|>c4&PXk-U%=Ee+FNZ?>A
zPdz*T?O<YHU;tmlvVyTB)Yb6+Yozgt=Kq}aTEzL|^MuztsNr#((X*Rv1!L(>oIO#L
z@CLd6-~a#riF3b4vpquz;n;2E0u89a(h!P$&_sC5or3|Fl_=`>3xHC=H^WQd==J~&
z@qwxf+`7^8S6F~&=Re0zGtb^S4zL-X$K47*>6}0OfFr-4n}_2uw+sf)<8BEcL2x3#
zl7r!qi5{Q);RpBy+d<_UzhFCPpn_k}y@FrRJ%eA+J%V4*-Gg7y-GX1xU4viHU4mcG
zo#S{rsPq8YMU?-+=DRC+9CtUsr3WRv9Krte?A`}*i%0AK5_UsK`Q_PNSAfQkK;t{0
z@iox+0w6xW;Wt<yy#%=k#zD{Wh!8_{A2@#pd$j)NZ?OW+@^;(%g4lXswkpU(pI%cC
z1s`wp>@L^v><+g84K%fYY6Rcz7!?WM*4z9o2N@U`zy*Whf!7=`8$CM@cy#{s>~&!D
z=&fXQYOrBqD1Gg5{5U9^g4!D%%?JNGHq=-%GI;dXGnRhvwER(&>DhS!<U4oI&Wo;w
zm;8EJgbWWr$6p-zx5+R%TFEe%ih>6aEq@ffc`XOC?aUd^=0l90%?BAhEl-sldo6#)
z@X~7?-_`>qqMpqM{`+(u0*w<nHdr(G_C_<7ermANE9Ld*bz*9$V$}EGceyaZvD@Fl
zx7%I9@PJPz<SrXuNT9Sb{r~?TXT1k4Q4J5kRe<9IE&YQ7x*t?ufyPup;bnN>HEMgL
z!G@i|qt}74^qa@=gP=h2=nX(Fk3cueH`MTfg3FV!^rMI6DNu0z0JUyxT@6oqcK-6~
zW#M-<ybTR6XZ~#>QchMPa;4m!&4(F1El(G{c`XbMAy7zJ9xOZm8Z;<q4hkfBNFW_Y
zD*rs1k25ydF?jTrF_wOAu-7Z)^XPSFYN!VVm+SG@%pRRTaAh5Eq#zBcf%bDjYA|Sh
z=Ge{F{DY6b1+-)UbfG=?USJdzp51O5o|bL~{4HBSwSO-(N$P@<q(?7!dc*MTYi_Vj
z5W=V1=7r$_Xmo&!7{`Ws5eAQ5@Z5+;FQlEo?|RUu^PMNZ>lcsKw;ud1A3VFmISdbY
zbl!((={7e!(EN|FR1n#q*ZgPBoIw`w?5?)}s|W4>0z0+a&%i_TpvS?V%pR6!`J3|p
z|NrmV?dITV>E^-Tat7=LTaep*P<&!|8<Af;x^-@JyE3#MC~<B6!B|=kN{9a;mUM@D
zcyyNrfJEMdMY>B9AkK6_cGYVqNJv0PkZPFzQUj0fPzR50UkjgZR|TJLUk#8fWUb9>
zQDiebx@!x-R)Duyfqc;I=K=TGY5t~Ah|dZ<yZtIWED!RxgoBC<6kp+vAID~U#u5v(
zSn4)+Y^WDt@acTz$?tLn5f`4_^%`KOcy_x%tZP2X=m8qjKIC!m7qf@u)uPoeZ-Vj^
zTFUW@@a!&2@X$QR-vYYf(&OMiW}jYg%7KQytKomcw;tUrFFm>?Krv`|33P@1_irBE
zEEhexIrcpV%|yYHl1Jw)m@5Rlx@{ow4hlX<RCsp7tpizvYLo#;9VD1NyWIr5x@#;T
zwI4_vtA5Ys;{qO*U-_G2K~vT+kAX^eQ27!IYE8sK3K*2~9NNr2&H!qyVb7K*>Ivjs
zPzpj(kHtt-`EbWDPz8UCjlr|mjl=O+8wUdi1H%gbk_eCE2N)QB{GZ@>tc49M2x4%8
zWI+rr7=s(e;DIrCVGKSPgCE2I_d_<lmhtTE0~rVEunF*oAAt2Y!TmMI<85GLK%L0r
zZ2}-|;B*2m3Oqa8Bp5gtJbT*|7&sUlkF_Z<2!Nd$3w0`Ve(qQc8(0S9Ohu3q5JL&Z
zP=+y7U<_3lLk-4I2QiS`3o;Iud%?y)+^Yf7hT>iW1_1`o<82mD3D4tg4hW_Pl<CpS
zdIG#=2JA~8NZRq(aX_Ad0o42U=md)&2b2H*+cO|%dx$8gfC9I4z-ssf!BjW6-10d1
zoY@1?B7ijlA?AV9Yl0Q>qfow``!XP|E`YkvkzcTF27>?ti0**W6$}Cl{NV>YkGHKr
zQndl1@c>lFv$yR6Nd2+43k(wAm`aAl6!QG;u@*M4JSdtjf)s)nmtc&`Fvb-a<0_1C
z4aT?*Vj#sA$T(c_1vUl}UpGM7P~z(Wg9L+T<GvjX0t}%2*yU25jmJQq+Q-4bz~IyQ
z9h8k7qrv$Y!o<>SL&;x=%G9IzO+e>gXnqG>AL-!<nxJN2NMK-qcI$k4Q&a@@8G%~t
zpjln$CgRQ<6&|1Dx1O1A85o!teS2;6V1{%vbazNFN-#7Z<O4g<<MK0~&i_80k09k<
zuZ*5Y<6#B{21cm)2%}w~X7A(BU|;}`>_GIus#7dB>;RQe9+w~Z_NwT4HXh;7U|{q(
z_=0yQsN@3GGubz9cyvPw>+W0z-`2OKg8OA)JzdYvqduLv44#bly?a^oJy_W_7#Kaj
z-}O{H>Z|#t%nEdsfhlO1%K*Hs_!-#!%|HJ0xBLP{Pd7N3dNl87044MiZqM&`KKL+#
zTNe94TNn-D{Tt|@Li0fZk4_HIUgS;>4v*swpiU6OaR&*I_TvuV?#nTU5>Ns@=3v0U
zFX*7aFX&KlyaCkc2dVKuF~{S01L*c+kOaSA189)K<9GvTY~!Fj0|UQ62dG2B9|CTs
z@P|PtL5QGW!wIna!Ga#vJ}Mri3Lecz0uWUKX8DYqyW!Db02KvQKaYGmANqE_0EZD&
z7#6=h+Q=P8P-TGL-|7VKa6S0U$cOWoN2hsbc!Fc|K}MHO{}fPpAn2aqaooKE<kQAq
zpz?>m`3nOBgG=WL$Ib(ejSoPjkEi7U{?`AX?9lC^q5+ykQ2=eCmGJ3~Q4#2MV)W>2
z2St-dFSt9mg1;mjl;@fL|9{N}anP|A_KtrH3=GFw*gK(g7nJUX(mhbR7fSa*>3$Fm
z&gZ*ct9bNo2btqxd8|x=Kl}i^zXKh=^sxL;^rdq;NJ(cu$UvXY`7{23a`E&9V5)xw
zm}=kfkAVSaG{8c3DQL9}xJdTsJcupmmw`)gh!n)1FcPIafUn>A=Gpn*ryHDxJ-ba*
zJX*gY=NFI8W1gKRDjuLUHLc%E6Ffkvj)6gefx(yYpI0x>4zFI84d7)3pam3+=RLmP
z^HBWmp?J(g^Iw_RE;dlALmH0(7g(US2(AfsXgUIW3{1crkDh+WbHB3><9~<~eH6b@
z+liRr8|oMWSsmpADUdw7T^T%D50vsD7f7xQKD`D1JzJ0Qw_XD+d}93P*?HXa`+Z-<
ze;~CY$ZC)KcGfb0<(}_iW?*30DI@?I$OCouTn$fx%UsAPfk*R?|0RylZ0op%5ng6R
z`gDH$;K6?oToU*&f>vaScvyFUa!QdcM(Bg1z@?i5YLG`aEdRS2J~2Gt+xf$%^OH~K
zM~Je{2aYk0;07knR18)KCa}dPIIRAGR^uFeq3hB7gQ?8j6O!JNKud*q%zZ2mmPh(_
ze(-F3z`*eTzpv$o(j=eG@1W@bP*Krxpd=4_Z3s06T*E<HBhWF@$-JP92=M^a_pqEc
zg%>(HiY7i4Qwyjx{N~g73+yv60ZO(g>A|BDY%gZWfK)<ofN$qP&(0GbofkVld364R
zS_|#)!cB#!1(B%cL+U1<ZU#_qJlEs+0Z^hq>EAZgu!H*k4veK=J-Y=!t7F_eS`U<j
z!pcL#Z>Z~g__y&GS@D>c3b&jr;q+)e#^_;rtmsvP4U=t&yJvR*hbL%4r}a|lal-?c
z-U3M)9zeC<%C>~hvs(Zp<<WYn^!@7-9*h@2Lou)SWB3P>zdah?%mA%Fhj`ATvqfbB
z69Yp7I4BwTTjN0M1NVX215TiN0JJmkxQmJeNB|sOoh~Xe9=$ax0v^2~DjFWWJ}Mmh
zSQx;g;;x1#!Ad~+M9HJKM<oGNZbF;9(8K|%rlG+PT6-fvBeT1}d9meWi83_l86J4e
zeCEuVhM%Bur9=GNyuiy7TTYg~ea&Qez@znmN3RE?4`d9(li%gEN3Y|1Xww=xJZ5<5
zHRBm@lr@7U*p4$c*a$Ls^ae4OzVhky`tM_TlfOlgnSp`7Z8fOKX+6o`#{=3-30kD6
z<k8C_2pTK$vAn_GX2{6E;ML0_1rh-D)|(YTgZBSDJ1=-@{_t!*@XztvLFN)Qm(Fv|
z&zL>F-$NSz;ort$>D0j@4;lvoxux`-XY&tc{-#At3=E+0JD5EGHWy1qrw$i+Mi7e$
z#9{)mm_aON&>BQf%b%qeUuJ=}S6JTUZ%zbl1p&D^0+cp-i~e~w{}kYF0v+Gr*UKUW
za+OafX!)Z@^8qFw%LDxFiXg4MEP`01*uZAMeOxAp?AxXn;H@<$JewbU@a%Q?09iQ4
z;?o<(=+XScfWKLU5tN$#JAOOF%-<RVT52~NG@8+Q-lO^X1CL(!2cDe=JP*EL^#sSm
zkAz}D!*7n?4lwh#g4S2R1Pz1xbe{8Qe)hnl`Pc)GgYQ^--55a|YMT#0mdPQ9rvQr~
zzkrXSfD^wai<}d`rjMKezkrLO0!YxniC@!2P5~@x01|Zoi3Wg09l)XiAkhSnXaQI>
z0W4a8ST6^1SBZs3^DzOJ&J)cK5}FS@IQW9K`2g5G-)~F+>Hoklz+(v3{=tb~lSdA+
ze(nHc=_60epZqN#|Ga$g_y2#F-ZDnV=4Z^F&By+GYJPJy{O{FkV#zPyV)Wj-m&KZ2
z(1qzeh<6{vx({NV2eHnBSo=Y&{hrOo4|sysJ|6S@ejgORB`&VuNoxbg<|7{*558dm
z&HXqwKVkO#e#f)(l&|J5-_Co!n*R*HdG@jx@e8;xz4z>8F#{R)-lO^02hZjsjHOR}
zEf1Eccr-u%;BovIXuiZl^PdOfHE@38-^OC-)WHJs)Bnm(PRCrN{xiTTK5IzHQ!4M#
zcmz};5z~G_DW5S*NaXo8$6$)(A>${|Vqm|80%#>MxP<fUJPz|k^8o?RPIkvGHpdQk
z4##8d0t%r1XYYOq1qM(b#F1aHT}6Qb)W2>A3GHKGfmVS&oj<Twte|omhEe?M(cO3A
z9|Hqu7EuK{n`rLQxeqMXX^!bzXl(~A0r&kB2jwfQbC<u6q+nKqX*B!6eYJ)ipaDFF
z62ASQa^LWqWAw|T7Z|ZLvq9stoj*LFV-=mpz%5m<v2el%QVaQl#+$)s6+j1uA;TDu
z0T9s4ET{tm8OiW~2!h%s$H2~EgnF~rU8DH~`wIRNLx?y7@f5Tn0gKXZ29NFy8jKPQ
zU<U_4&4&e}u_UM;22KWO^9lP!z`c90l*bIr_&{%;?bimC`_Kp>LOm7}QR0V?yhrmJ
z_+eR~qrs5<y8|>X<k9&M-rWYBEC%f<Tl=VRl!|#Y9}&Q`0U9`9Kc6{sCi6e&o=tGL
zf#aAY_kr3c9?fqQVD9R4Q2}-S_%&HnJdV4lfIIrI)C8Iriv=|=Iw1oJKHV-V0-$8n
z@&MF7>gG}L>@E23(s=+}@c&~j<}v){3R;kTpw#Jgl&9taFn5ASx6Q}ydI1;4?;hPD
zA33^%1Q>sLbk}?oaOo}=aAdp&5|waaE)oDO8TYjOP<js3yp!_i<@xCG{YKgZk8VMT
z>_HAtqpS2iavJD72n`*>11_E4I!}QE$)mYOMS!8i7CMs$n%?F*0|y@6EGk~zEI+yn
z1U$M0Ji0wNK<!}2%ok|?zK?Z{ia^m#pKkE+gC%C5MR**bqu6wiIx3*{S1v3Nkp@=o
zeehufPaneMtX)(jO3gi*k0@X-iJ;DhrTj_Yln<M_hDt&_1<A&Uz6{9Kpk9n`=MRVi
z)K(zYu?$ckpr)5_$1q25fA61fcb<W-cAkb$=L?U6FPMCiA9(fJJOvd3@B|C$;dR$(
zcpiMq?3?`7we>B3i!37pgI_NTXrCK{XY&t*A|bC{7Ix6a2m$Y27IqKI<HhWTC!sBd
zgC00n^7DWa&ZW}wm!JVR57=sZaC=LD#hhQj#~id<0krU5(8nCqelQ2MAIuFvTMs}B
z?*)C#LG1@~Q2W6gyivj20kl!U9Mpa=2elu}!P^wf6TqTK?FUegA`sMk0Bze~I&+3!
zz{MQYUN8q6{lSr6kjEU-UO2>9`slS<7Yn~*2Md3f3qPY{hYLSrmkU1=h{4q5!p{t1
zFhlmzoG88O*<Ggro&WajtkdxBWqI$}>1N^G%ktc_)6D>PzY`QsFpL>rp#4kVL9-4G
z`zC=#bV_u5TmP5ncy_y4cv`y|l=8qPazP?KofaSpH0lGg`!y$M5sN8E$g{gl!$b3f
z$H5oOorj=F4b(w~^e{k~kj14tfdgbVt7o&D#SfRx2lxg-pbkcLZ&(0m>0jqBxcT1<
zPkMA-gD-PxJy62p(p|ve0@}=Sgah01C8)VD3e|i>`gLq>d+?8efzdO$4K!%wk$D0%
z-s=IXNEtzc#6G<?g5XY<;Q`ReEGB{_Igk^%T@By9R)Cp)<_zk3mZOZGphYJZj?I5b
zTHgcF2V38xUb-K8Z7Ha`qRa*xAnoSt?u3j$GwuR)|2!@~f^4?qZ9D|pi{_zt%BNRl
zl6SAjbI=+@?@pKJ3Wnc6Lne^&%CXBW!nwocxdznp|37#_*8|}k(m-v$c_bf)1r%t=
z0vu2tj3+QFAw>9~gg>m9LmEnl4RnJ>x3QUnsz13M5?Kepk=4x)-Tw&Qrg;i<CSJos
z_I;pv9FNP-JerUF_fY)g(aUlHdQK~7WTcyg5t}t|2cy~tD@74Q|1kIBG6Y3G%6x=_
zBk0WCtDvKOEI?aXBwRs@LeBCtFnEGe9RmXc3xfw}9)y9R1~dwMz=V;1+W|-ZZ6`f?
zMLa;;TNFGFKG63#_|U+E^PoqkkBY#{eLM^daHoSAK9-mGoB#2G<{3_TU>r2@6eIz)
zjgbMAvs%CMPd(((`jLO?L5oxTtw(qn7+$LLBTNOG2O3BNO(|oTw}Oy)?I826^D!`h
z&FKLt@5JJ+VvqzrcLjmW>4%xK0Hhq7IUwu6c^EVggW^92{;9{Hq1ymzvHyf}Y8V*!
zTLX9*7#s{f@we#mF)+Mz0*!rvg3$+;HO3$btj@)2%^x19HOD}{dB+0{l^;AfV(UIg
zf^=(Ez^sV}Su+b}%@UAl*aEE^Bmv6L&_Fxn(R!7C>H&||i=d<dnKlE5*+>4?cpe4@
zgA4pEEFhzUctGhiMuo?tyGBI<wA;%BwA07{+`zz^sJmlSctE>13|zW>R7_q5gKP#L
zCIUJ<x%D<^e9Q70fAcF)JM!QQeNa=;+C@cyzd4JCf#Ibv=-eKJ@^;W51W0)^XmkTv
zd6PE}1B2&rchEc{gC}T{TI&J+7H5!PufG6je8cb^*v4%z8$so%2Z|A*Ah$t|_Vny_
zm+%0Yzy~n_da4N61ke$KJ|IV6n(%;|fdP6r=*uhI(4cbdJmLykw|m^<;Crp+=j_O5
ziJa%}0G(RddC|l2yldx2*Ukqnpa4UJB!AOR(2*M4%)}Wc#>~Kg+c2aI(4@)C!0=KT
z<X)u9P!NZVp6Bl<g_(t{tplX(Cl~05)@vTPbgqTz^zHnFtoZ;)^CB)ZuN?F^_!7JU
ze?Mqw_dmE~{|8QA9+q3qgQg7mo3Dd96s;~Q0{l}BzI@1tX2LO#gYS$$uGx(+;XY_9
zf`o_Vp3e{yK(XclGa(O@d=NYTk+j`|YTI%dqU{vSVkCdG{^Vp}c<BmqDD23EV;<Pd
zI1Moad<p@`YGgBJgUnzAnSqoBu_gf|T}{lOp|}7}1_tDmOGsC<`rrTmUz(%oLNc})
ze95{p9tEKDpkBV<0F_#x=+bR?$h;fU9(nBX{l16gZ>(-83-|2x`tM<RuFMbAYEkx4
z5hz8Rg>uXTcZ7q^N5E<%f9qNB(B(Dom4l!mi(iZk44$3&9MDXUn&es>IT#pTf-js0
zM-`C{M+%#^|LmX*7hrGjw|xSguGM+a1LPI{)+bON!SsvMJ4hC_f@XqWPJ|l?aw@2V
zVF0!HKw<m~NpV{lva2$onjo%<hVsC!I)vIH=q^!_@UWb64xBKXniv=uUh2S=gKR{N
zRn)+2d(MUw6t_UPNy3BT43r196i>_|{NUU9iNAR&8>l3?0?F;2`5qpf?g2iX^$xC`
z_gp&9x^x}}S1iby9=UdYcI>?2*!l8h5!g=9$r#YqUJa<4KUXT_WBIMv2|0)GH{Swf
z0nj1(9_=?gIzd~LJPy9rYJQAT8lSER02Q96i&9>KT4kU#3-u4q++92aQmBBAI7JDq
z()^dopp|OyWakKuOwY@YJig!dw7gZ8;Mwa3&Kuz%dq7cF>I-5KvXLKj!U~F2{4G0C
zj#-If1qCW7hX{aXT9rLJ^97(48k#->RtAQbvf$&IFoRJ76pVJr!C1T%a^?!&AasWW
zVf0JTCK+NpR6GX~gi{W-oCGC`*4Kak|9_nT(F#hF=pp9;3pwz?u;7q0g{THsBRJ!V
zACwKjHgx{||KGRsnrE-S1T<huMLjw-Q9=i~?EyK?9GtxFm6rHeek<}oI>r^7h2ZL=
zSP8{vh-A#)$_`48S3#8vQt^*sKYtUbsp8S8`LYXCOW+N2F>sipXfM)yT?q*kP!NLC
z9=IU6?O}NfMPXSGtdRBusRswAy)UQ-4l3y}4*KyxDMFwjitIDc5%u7MT0A>-j=wy|
zgy>j+dn;$oI5z+0sIl_wb!GQ4eBsgjgQM7ZH)zuTxQmJosQCsu2SCE7Tfw*W34bSO
zJ^jm06hj=Ff3tw~Gb8kawyS{jgGR%V^j9Xo^hMDNa)M*?Z>Abe&t6wXAHx@hw?Qu8
zpLDp_nX%JFMF&~4+Die@!6mmr27@cRZWk4p!#Y6cfI-$nBG!)h_1diPY<~X0r}F{y
zq@2h9|9dE&aOr&6{E)qu=cWhrnvu>E&@Kz8k==RCgY$!H%K;C5*MlCNN1<gI1Nbmh
z*OrqW{4OuRuJY)1;PC9`2ldJfUwO2C<!=F%-yW^M_*;H{1g)y}=YYxm;%_ng1QrrN
z63T`MNg#w;K_-CvX_cU)h}l&rOM&_h<eX0AZo)x>gQe~---EP)To4X18`%Y`AwtM5
z_zw|6azRV*=l}mfQ&?ax`gAHl?-6Wx$i4&8s|THf^WV4g88k#e<0FdaJQa^Qem?@a
zkt7FX!ofF2j*U-10-l*iz(WO)8!JEq0Gua4M|WCyb@F@w=Y!6hmmhgFA7%9HW(T$L
zTfqi&>cd+U-5>*@U5M7b5DvIE(E91~|Nq@SDmtAfJQ<HVYM$nA)&Kkdzen>CyvJ>V
z5*-r8F<t;Za_Ea^=U-5|Z!rO%82i$r`5}9W_zrNk&^+N|`GCI}bQ+K+<55q|Bc8pj
z3?Kgg_c-{1#{+b(H!puX=<phk9UxKAnTp=MJUSkY2minS{~tWZeIL~9-3uDA1+8@Q
zY(BycN~z5ce!zyCtQ|A>o56P>Ktk`q|NkD~AZuU-PnUyEjAHO$d;vLD#)QKI)D2n+
zGIie%aMSz0y^rEEk6x1v9*iG7nh*Z)u)N6MybyF!&cQd#{4Jon3Oo-!Ve)ML!?FvM
zS3UXNuXr>c`tNb@6%+Vy8b<Ig8ZnTOy#*Q`y_NqxG_M<8LSBF7(^+!u2EU-owFe%@
zU9Noqc?Tr)gI|#48b|~(N6~zU!=w2)Q|U#I-XccO&RKB7@#P&*KeHRWO~R+!+PC$8
zsQ}7CB%e-euU;OgKS9C&!1Ll856}%IAph0-C_eM){NZu%1&c?o%|Xxt-Oe+fmVb&h
zkmj>NTaGz=J55wT3+13|BR!jsD0o`_DSB*p$*1#y=lAcRg(BBHdUZZ}e!uUj_};hk
zudn7)&<afp&{|Dn@R>vJz>Od9GR+3Cv%zz1@Fh=tpn>@BH$HeUg2h25KlkZ`XlgmY
z-{KDLEdS+i0~rHy_4f-Nj7L2>-+3H-#|m1w(D?z>+iw1wP|Od~{1enzNPY<#eelpc
z1`czd&Yx)$d^!#J1syp&jyr-DjxhLi7Ao)yI%;?vceH?neW3%tpreP!amNTKKY?G+
zF~j4yBY2^sNAt@DkLE)x9+uZiw}1wXV>}K%Vuc*r#NqM%hT%6*<RZ<#_;i{W@(Z#U
zc^r2!g2pB2Fq;F6rB7cg7+wMo(SkPji1>7xTmVf<3bK6gIPUTRtd@wCpRlPEF#*sd
zBHC06Oi~<05)^{)Idk}8G0+6dE1%AnzMT&s3W%FvK@1T>ju``8$mP-a6ErF9xF1CN
z@H_o<<lok#G6gcz%-;%{^Kd-Y0v2F&+ySbLASndAPVFbyc9=W^x%U8-gn8h*1L&Yn
zr_M|0Aa(QqdQW8*6=)@vz|i2qc?hy#4K)6bh=Z2`kmGE@4t%`;I>rwRV`l-xWH?g!
zh!Q^kJiFz<J8nAVJUh>Oc3$!9{7TB@MkU^OJ$1sTQ|ASANEz%YF%QmD;Gq47<`XyY
zDZG$T_1CMBoO=evz2`hTuX}caq7-z&ngl}$i{Yi$xnxI)4{5F!Q2{&uzfUK46C_eZ
zv?JZh{CX9#^O48<o82WCOGFy{*&BS&PRnyd-yuB#C4(Rvh*ZCIyGyhlDA8#?@W0bt
z0&`<-LppmsL5pUgTZCl3W3WdzyN5MfDX&MjJBNq08wdZC1E9rZxW?*1?nKcKo$q!4
z*S`N@vlX2#Di$zy^8o?SZUPRU&Kea3&``dH2l7GUpmvLaM|Xn)xHIaaBH-EGegKqj
zK{MwtGrAc(x_6vl5Mc1=X7}t3vjCaE@jpNTwD-y5-~$6sZZ>H1=Kp_w55<F?oqirL
zy`W>gOQk?<47?M>;4B969&&s-1|t$DXyt)p=NXUA%buWhn14Nbn?daa<kmwA6KG)V
zLGuGf{?-c6g2cU`5{QAnRfm&-;aDq(!|2mp%K+LD+Ytb&qakC+3JeTBy(Tj}o1Z=K
zgftvL%|(bDsM7>FS@ZG#|2~R8Jv;AuHa}(eJor@0lk==cw=aihx0y%hcOS#|p8UI>
z>+?4+1-B`W^S6MGQT7C%^L5R~@Ex=v3No+t7=KG8s8P`!20H8?Qxe?b=nezjwud3v
z3JNKxVW9aJ%VYe_;Eq`51>~`k51`{1+xCE$5uWFtdcddk6#vwN2GD(dFBgMW7(sjp
zYQwi4=Wi(lyQqxAqw|xG;VY;OVCNp<Z&?D76u>HZ9U>`#MY7ZuY7p3|hl=$;v!#%u
zvO&E<#S0#mC(0y!ThH@PJ?PVV4(!llr5qr4f^KSY=}b{!0WDha=*&^!@ae2&@ag;s
zoi#&kU;lw7Kydr|jHlue_>F&{-k0Y=d^i3b^y?IP=m~C7vw5^0aOqA_VetT+KF!|>
zUenmA=h^MX0d8wA2Yb~GG%&&6dK<!lw5^4hVQCCe(}K?3<ABt6j^OhaJUZX`bYAl4
zya|d#2FJ!H?4Yq=&IFwg9*qv*Tkt?jWDw;ZW;uWyoX7d0H$i=Z)@$G(J>+3|iodNH
zG(-Rj)<ckBwK&Azn*aCz|CbS<Q5{IkgX82Fe{%__6M!xGM8gb$B%ebT7x-J<L52up
z8sdY?5YTah;0Q)CL>^?wInbfONG>_f-&_MW<O8%u1A7OQLipQ~VJ-oA$AN$9aUama
zeBZzS|2r7`;%{jNokeU9(u`!@A^v7hkWeQU^9-<>Cj~Rl7-Sv~NHeN=Vjv-G=KcNi
z|3BE1DDHdy2kJiXY2P<N=UPK9X1)rJf6vZWFO$F~9``YP5A8UEbKH6UR?xx+s1P`w
z&hs}FgVkam*07v%7Cb20><0>38OXd7sPKRkXkb&%@wb|S8sZQku&L+xn?YR)&*N^O
zJ{kkKKnKkmss8={-?P^bH1h;91k|Wz08R3Gv|i(H1#M`8ww=I+T;p%f1(^$*dvXKk
zh?aMMz-EBvo-oY-jTWPsQHwC+<t9*gf{OZ^pt-Mu@3fkqvHNzu@I3fJ%dz<ZyN~8E
z{*DrmdL+M`=WjX-5(4eSZv;&=><96{(<Gn+mO)pg9(<_<I(JC(6n_Wg9sp2_p8@QN
zb4b~~NevWLt(W*)K=XPpB|tn}=73K5M~){Hb1s4ot^}FG4w?l6-3164cf;Zy9#DOR
z<Qo)o7Q@T|t(bl}6~qI(2RvYiG7Vw5<tii{<bjf~2*^<I5H99G7(B)N2c;O0M<H%A
zLas)RdB6=!1Q~c39HgKmh%zjP<nHrD-k_~KmY>RS-Q5N*T0NlF`*fZL2fT0RE&ird
z&|C<ls4Y=?IT^u2QU%t{-&zKqM#<xVr`Y0O|Np;)<ae0!K=IGuarrsU=&=W#)D1mI
z-5A6s6jXd5OAur0pfDh4$yw0&G}MxVAT}XO=KTEs|8*>AF!SI`qHJgdnF_U`62yku
zfK<;Of`vDKb2zvuo$KMz=^EhES?b`?`QEql8n{66?fmr80%QPcPf$`2rKj16QCgMy
zA_wt#jM!=l0u}X8S9PMz=|B?#f3q$qfhB=z7Vs4cpe*mBd8|Sf#ccj2&<SE5t=~%Y
zUV?T<A%Y1!&;uGHMoEnE(8LIyr2x%Mfa-ORZb)efDqA3pJ8)HV&cpH(|Kx)nmY<M(
zz~6KpWp+a12WVgt+yW?(eytBpe@Gg@3A9wqw=++`vm06zJ_cPW@By5{FaysG#e?W3
z6>Wof5qAb|();)S|LcB`XCMV7DAdGI3@u6pg_!p1IEY!GRE0gbY@xx0n2<n=EpYHb
zqYTNZ{7ow%HHHM#&m}4zkaU7nbzCo1M=tWO7l-(CY9bi|4!M`xL01u=q=0l3zo2X2
zZvqXngZx+Vaw-F8iWhVgJX$FRaW<rEL^6QC33LmPPp9TfN3gB1k^^htAn60Uv`7mY
zSW1vkH9~H-ATnH2|DXT=UBFWczMVS9US9u-dLJ94Wr$<FGfMxb0M@7KbWzCwEzP>_
z+4;qz^RG`gcuB5jx1C4xaSqUGR!Ex@y!Q|?y5iY+6f`iW{OvGfsi<SOtIi6>Qr>UJ
z8B3fU`FEx2a1>d8@N9I2v_PRt$gEvdGWc6(v4V~RJW_zSO$yP`P?5v{YNreEw={y{
z0V3)F?SLwPq%3?oQ&b#4-Ny*nO;(@|XarIRRKugY71jYY@a$$o^gMk!Uwbqkw(#i9
z0d-{Gd34_TAK-wZ0yH?-odY_4?iRRr%GR*s9cT}KNswc6t<3)tZ?I?OikuxAeRUWZ
z7#ub*wj3z6hHPA8<Zm?ub%K%aw+77?Dfo0kPV|6>&`TN6yvl)=10_d2yJH1ByF(Q`
z4n8*U<c?*4tMTk+^XXmzS`qKr?VAA}z`YGxpwJnjA^~l!gZj$tH#`(Uv$>wlM<sTE
z#>E`lK}W@u8oag!cZScLIdhyv1=LE}AI!kOunQEhpcOTs6XaYCPlAT<AS0&W6VITU
z&w_#|VjpOiFX-43i0i=xyhrDIkIs8wCTQeQ(?vzW<G70o`0OjtW;_MMlb{780^lwG
zkX7;EAOM}kssZi6K#T)Ln*?ah%E9+Wjn6?77bwjJ!;`L{(_lhW6u_3@G6Zy}^*@M;
z&ifwF!C!po7%~0bdb`8`9&sI@RN7mj5`aimB`N{1(+WO#G&)0*c8!Vw=o~6`=&EJt
z{tl!KA)eiAA3Pcx92f)`KqKa$(1?JUWBAta8;s4r?t^1{E<^KQCjJ%;Mh1q~x1cgX
zfWJk61GLDX9er$K*`NRa8(`xRoE)&eBBKxFFa-V%VNg>I(%Vn~O;+ga@MwMtACF*R
zfOY&BVT&(o7#KVe%Nrrp7<i20rDyYVcF%*)wLCe`gJzBdJi0wOJi1F6z{3>(J^6P%
z)#q;pmCHV@*ZEtHfSPpOp&TBa*L)2B`Ltf+Z@CW<f(%YTg#JQ=AVU&hA@G$hK9=YB
zn?cjdAl-`JJV4h+tpSZKv>xT3deEcw5dYKz1}FGiK_|GqG+<<4KuOJ@={s<$ay2}F
zlA6I`>Dh}BiV45}|9`pl-~a#6ox=?b3}8P@0K2Y~1L8xl&~}KB0Fux>h>!%55G$w)
z4?2DbwD-fOQv=#bK%2hv>3r>@_!*S;z?s$Y`%zGW=WpQv=|1?@$g%M$NWe4mDEidh
zL7z^Qo8SQq$R2b4*6*Ncjm}yIk8W4UkOKJj`fgXqkU}UZ6?D6TJ5a5l@hnh26FAlY
z8oPpzD}YPpmNZav0@6?e=O7=;^Zd=Ajw@&wM)4DP6hH+ORG_Fh<k5PJf9he2Tl}p8
zpw_|)aKuS~n`PHPo9;mo#|cw?7#wkjEH3l6e*OFZ|I70K|NnzE`~vqt;Tk|I9XvtC
zBWbt}(%=TxaGt+89c;rVAE<jGkZd@{KlKo}7w`P<|9^wa{4Ik2|Nnn!2D%af<P!%}
zorc(S%0P8q2elmeVLByIb#h_T3Gx=m&bc6+pzE-~q4x>wJ-BN@y>_to4uV7P0NAzX
z{{H_D8lFl9=>*-PVEFCjEl``eyG8|idpsy>fqToa(L@%8msddp4xOjLjiUcPotHsr
zv=wwXiErmkAItNepzhC8u=Sue2&l0K3bSs|rK+&?PR&O_K?}W09+Xu<rd;E1Wdx-t
zP(EA)O5ev_AwBudTOQCv)v_9N4Or)8-_Fw>y}pnx{XdV^d;G1v;Kii(_?tDsIzjah
zgKy_ePq1Ea8f*cL$oRnYLb~!0y`a05eJt<sH)kUBz61?E7=C-%3`&~tCY*2Q50rj;
z6xhA@`J0x2bb@;8>7d^FG!PHmtA+HA!Q*_e-a5!@;E*~84k_?Z3aDQV%H=OlqxH{G
zbnXJ%2GKSZq!6U-Jjg=OO^}c-FBS_yDnQ<As)p%#0@9NU;(;9r>Ux7R4k+3^EVo<-
z^|~Qp$KP}f<Q2$hhzB$?w-|%2N8AKXnz&*Z?6p~7y^u(R$KXp)xn~L13~t<dDjow>
zsRBNhTdsjD=5MY7CC50BUT`-HxrOgzdB4a8+Eg`xHB~#0AvqqrN)_gKNsu9s!l^{!
zWi^5aRnVFN3enD54!G;QL9PQ|0tL4l)+<JeGgZ*21+<qc31Wj4V^8TnLH%sdp*j%f
zf_wur(Z>=JmnT7K3~Jn75F3wibASE+|JntcS@-yxW`Q(A4eA52AqIhiI79^$#HS!Z
zTnLf`MYm69J$R*`M`ykRxafTezTOa07Q<!-7aAdE2hk=Dw-}-Hr&0AqV|KRx`?Ov!
zH30`Dq@bt+rvzNdh`%`wlo$drdeS_gl#mVTDJi~AL4*b<hk#aTf@FQ6>BJQxZ3Iqb
z9^G5OD=tBWm*RI1%YWcb@;?tyne`f_bL<B$2*Gt(3EyiaXbSP@yj3dZ(^)G3&kSlm
z|Nnov8k`7@`xyTBXuV#l<<oi7!}5I5b(qbahcHUOrdm+lwH39e3-*;8#8==IbqB$t
zCdj_hfci=SZZ<~h=WkL31!}La1k{lwx*+d@+;+cI3luc6kg~!EoG?nj2?LV%nx2Ep
zSId_HpeqUC#U7{^4tAR}#BDYZ%Ry-w*=?#&x5+}JA;u%8yQU7%#{JG8%@3G;I%|$H
zynOln|9@EL;LMpbofkYhKY}`au7)QaI}ac_l2A1m^M#P}Ts)7vfma+r+LfTTu4kv4
zgy(TL(B^Xn$K!4qpk9aLaW_y$2|Q)i0y;h%dgpMOWAi@nsp2K#j@{cptvg5l?bAR@
zCVe{pzqr}^?>~R|Nk@LcK2Rq1JnmKjIt$B@U!V;%X2Tx>Uh%;n2BtvA#(_lB9GmM(
z7)nGOyUPk3`L~CaflTU$o8*__dE6}kYK&V1h8b=Vuf-ktxA%cu1=`-O;K;w-uLQ(0
z#5?f_%dh7papu<xNK$C~wL$Z*ko~2g1Dl|8Q2!Yid=x*zI_urwSs+jZ!F%Q4Lc_E3
z2zbE^<o-1S$IcU=6SV9Z7(6Xcl*ajj`mrvZFI4~AgO0-a?_qhORLTdsQ`xuk-D^>#
z-MX)Ze4xjufADN{Q33aLd^$hi-hYW!Ao;=0VFM)@l=Ol!{-Dr#+Nayxv)fO=vpY}1
zv-6Fo<{8iCKR@_eRKX45Kg^(&aGu?H3Z9+sJwbQ9{qQ*WgBiT+>osUZpwmZ%12hFK
z0NNWS(HWz{;?c{}0NRba8<ZA3_+4-KSU&dTce>-zYXe%x#Q+L6XlNY;P209igbWG`
zcsBo6D3bE(<+1RzJj>q<I{Dtamq#Bo>)G4`+CzWRqxtB656!b4+TfYPUml(Jz!%Rc
zgSNpUpD)Y5O@_m<BZij&bmIZ&FyYd-9?gH5Jvu-0H-XNq;om00;n)$v%fP=ago6>p
zVg#|6KrAK@iy6d%Zi+o$dg0|`25|rFp=W2F#7k~)W%(1bF}U)9N9R8e&}kyjE580G
zfHswb7E{%Or(`{PtNwdvemDGvv>uCJfW?4cz{dczKiI_-bP9xzDQJVRfdWVryg}Gh
z0krAY6tqFu0JK5a0K7ri6ud#$6tqFu0JK5a0K7ri6ud#$6uLq9I7{h#&<0^m*al%n
z(EeZp(EebE$)NqgKBf%t4Z;sSEzk3}E&#QuyXyp?-DuEQr&q5Icr&#R<6Dr&J$qg5
zGI(~nDRhHkxjRHf0$i0GbN#_^%=IV3G1p%V$6S9i9CQ7{aLn~D!!g%?498smgSx05
zo!4I6&;^a-x&G*g-~eqc$2a(dXT3mxZ|5=4u0st_a^nEqu>n~;2wGH`eB3AV0jRg;
z-)p1e*$6rzg%Lc4^1++`U<;_sV_d;l;%WGH0%&8bHqpn$^P=pp1<xt7uV5_Q1zNNZ
zJqrP`DV7hhH2mNTUZ2j39tU6YHXr=2c*0|bN3TwUZ@0^P1y9Qx{O$k2TNfHY>mEHo
z=l{G1Z#;MnI{(N3bb*<IN8@9L2cTZsVgA-Dpv@J{hyMHa>b&=CJ}LlO`XS)jUGrYR
zvH7?|Nwp7X5X!UpzrYSquJhz~KMv~JLUtAO+8hOy`>uxH;91Y3^Y}4#hGXuG49DD=
z7>>C!GaPegVL0Z_%5cn`jp3L(JA-5Me@6b6W8k9ze|*2t{D9H1`9D*sGPrLK+T_v#
z+NrS&lr8^*d-~v`7G8qJ4LT3{bpG<tJOx$?KJVoi%Xx-lF6S9R1QUp01`#YEf)zxt
zfe3aG!2u#TK?E0w;06&qAc7Y}@PP<^P_Ab3usl_|qV+(DI+133^|Ji;>E*fa*j&rN
z0Cp?*2tyB$gTV)KdUoC}(f91-dEwD~ki+m2%6VEI-G(0BCf7VVO|FAV6W8ui1|Q2$
zMK64mLsS&N18JZP$L-kV^FpJ83ncB^dEK+|IVk#EI=}id-hqy!{r@iy8ZPw!N7rlk
z`Rm@@GJhaT$ZS0nKR5hjERk(F$=?b(PTQkX=KV_-X4EC?o}I@$HUD{n4@=Hv^0j=&
z-z>=t+F^0RQ}c&U=K)9&{er()3N-f68Ka`%)9It)0NU_t;nB;};BoLJ6F8xG@VlJw
zv3%*t?{pTFs}wwXZNL|&fD(!ibgPSJ=M8YZc7VSHbmAfC#DrqdxzOD;pcP3mDh@9N
z7*U;f#-sTs6aSQh9<6Wrryf!`#lP*8hvwOrbs)!pbU}_=I071ob0`L#xd6KQvW(sE
zz)Mhi1Gyh`#39x@B6+}fM3xr6oDQmdVE03Uu7`x(4#^?{DmX<z#i=-`I28vMdLrQB
zR0LF<ii3(%ad2@e0xnKPK*gyzs5lh|7pEfN;#8!-qxlu&PRIqIwVj$C&4&a)SJN<^
z0hOoXpz>54bl!pps66EnfnNss$kXybNk!*P&7U64hyR1Jp(bcJ*hBNTNApAG5>b!u
zH~F`Tuse2$fbKnI1XWR>`%r%~7dd-s9`NktVex1_$n3%R!=w2Cv*9K1c@o=V1pao!
z2>#{Y79;SlBS!Eai1EK8M({uXHW`5q89~r;R!_?drB|WFw@0^&ih^%1&k@kd!R{0l
z4@hc<3@-lvFAoZP4X0x)-x-{axqN2?lT2We8BDT(Nmek)1}51-hm*bc?Db>xv3$wj
zvXX&;p*NJ#Mf20QLyRRRAX7NN>Nvq97ntM*lRRLO7fkYjNqz>;UOy%u%daJ=o|<Pp
zdU?)!G#}(g<cDL99~q80equQ0_?h9D;}?cwj$av$Ieud}=J=iAnBxzIV~#%=jye8f
zIOh19;h5tehGUL@8IC#rV>sscpWzrIsC*FcY(Dz0bUXBXeNZL>Ew6{3);|Fh<{p+W
z%f5q#@q8_>^S4!j1_4^%`hfa^rCgv(JNR3IK>g&--(Zd1E-D-z-4)>b9AG2OKD{R3
zGejVn1+oqkG&sxQ(dj7Q(aG4E2|9ztqw{`AktgU@R#4Lha;2^g_^3A?0}soe{B81#
zpsu4wuLwWr)>se56QFqaY(B;TDu_Ha&l#Saz`req>u*O42Ppoz{&mD~fa0I)e@6@l
zDE_%RWI$?JKzHF@1w}kZcLoP&6uSx3QU?oobThd0y8iR(W;p;^X>NG38FI8Aw5{yH
z?|RC^@?d!)D9yS+YqidM9tWSXcracwJn3V3+JoQeoQLJXB0Gd$ewT|LniooRK<xky
zk8VE!Q2VS~<fT`q$iZeej{l%jZ44MncsvgNU;%}Ufk!7J@>o6S=m+r8U<3}x1+}Na
z$FO8R0L=#>wYL7kTU!+`7lDg}tp6UGUk$&Zl;8ZY^H}%=Sq%6EeGEXQ1N1Z&enA%l
z1&|o1Y=EA{0uploiGfN6=t(Rfu>_D9w3&63rE~?T)YpeKvyj${!_Q*@X+pjI^oghC
zIsTR~P;VYIHjCD3?-c<xl5T>V$DoEg6yt8c3wU(?_5h8yfd`hMmtlaGwY3y8fo^@t
zVD#xW_U%q{@azur@a(+qtNGls`Tr087Ey5X{y#G)2Y7ae1$cH|_0@a|9xMOJ>|^<p
zzZo==3A#fSywudAm!%V}QUBYM-|0R^quv8NE6Lx|2WiwhcsBo4D3bB&<<S6Lw$Kbt
zk)1Dn7+->$^`N;g(EOB*ibwNt@LkfH&wV;yc|aTXlAwk?sJz`K!-3MA2j3qJZq7?H
zGB8X4wddi@`Hm1?NNc_$gcs77?+D>#h8%Enw)DzNP;c71SLBapXPC!JK5$zeysN^a
z7f)Nh`XzV`D7-C?dLIb9J<l)bV#>fTh|-z|iGdOra$6oG21;PaEqRa_D1jlh<Cmi(
zFvNXF`~ohJ_B=?>2atV;*8F2n%d;NcHY)tBD<Lg<2WXYx*_r3y)hqHB)E4w$d<F8p
zM=uY!OXk7&(zDYq09;gbIQ{5I`Ux4i5a{sw1z|~ac>RX36gs^AKv)_bUVkAhgAT8M
z9tU4obU1-_9tq%W+k=uc?(}Tn0a~g457yD{1fMqzE~z}b<r{Xt0Z;w1J2uxTFqD`W
z9)Rx>@=?*?Z*>4I`Di|3fX{x9UKbUP6&$5fpfgHA=ZJypSIGT$;QI((2OM)z0X0Ka
zK+RAUP%~5o)C^StHA7WE%}^CShGQ-&{2)RAL<oWiArK)9B1AxhD2NaP5#kIUy(KCf
z`<+2e<x9{*PCYU~cAT1J?UCuDA^<uZ&4clvM`w2c=rsNAz89d?+N~$~TdP1#rcNCd
zpYBu!-_B)V@#8L_lLHwT4BvY6#;7QO-0ulGm)o=3M+NC(lVVlJZW|SkZk87w-31o#
zn=v|%g6cES!husSPlKEUH3j9qc93}jAoC<Z$Gk%>N-0)^m}l|=i&^Jh)+5YHn*h>Z
z0McK9q+bc5AM73tEM}Z~Z3p!dSib{EKjJ!*v;57VQEZ4ASlw{Svs)hA<$xTP)D60&
zprm3iXa)pyoSG^q;XyI#c}d3^J(_oeR5O&=ID&2xdq8a0(6JezxAX|a-qj$JO1FcK
zZ1d=5=w<*Nspr!PTEPHnl7R|SiT$Aa1$-a}AbK*}gVP7N$p7Hc*bLGR8oJxS$iM9a
zShVFpiM}D|-UU$fgL5ymezpds`W7zG-eeEM0|@1%7kxTmH<|D^H-avmVBEmiu=5Kj
z_msML9&f{L(g9E-2r_gHwivB)VirXVr-9|6p@}wrhBCfX;MsWvDKlsIwm#u+VFFF<
zLzj|(_91}RRCvJFRDdKvJrxZP*a8aJ`UxwTg(x%5pgII){RC{$0l4oE(R&WGQpEst
zKyk!AK2S=9T#g3zg=4dg3Il)NUuKZ+{`>Tns6_a5{`ENcl-0AlL`MK|Fqw}I2j~t-
zj?Qxj-wAY{Klok(G^ZWm(LEP5nc&gg3aZ>ZJCAy5-t}z$`-i_J33PgH=SR<jf0;l_
z(S5qXbLPIF&f7ik+1o#ud@Nt^gL<S4pdP;k=u&cp&Kebw&Jq=g&JYzDP^ZiTUysef
zqt^yB<p&;B^XPmH_7S)a{>I+|nql+kZU(sy)ByGDyiu%ScoKYmKX?!e7My3idRbO`
zbb{UQ+j;KgDtPnsELd@|fM+j{o`>ZL@VR&wK{Jf78}9K`nXm>KZ1@YMeFPo<0@Ysw
zUtgXp$#UsD1!}}vXnyi+KKS2L^Q5QdNATF9n8){96F}pMsO=BW=AX<(Cb09oiEe+K
zE4|{`y#o{>hTmZQYmd&=AOWvl7U&+&7apCEc2YN}&))0P%iz)34H}OJHK9SH4Kkn&
z@7*;jBH+Z@;qj*<;IBhR!9RzNivQsDTr!J_r{!_}9uv^)^KloI0MMb`tq1t~6d6JF
z2K2reux_8;9F+jW+o<P}gRWRQ_<+@i@qtUX%M1m_UI)hJA529VE}aKd|NsAA?*h6I
z;v{IFL+62mFSu11KFBi|Uh+sj1**jwe=>k>ifQf!w*XDfdo(}$S0atl9(S>H<0!H6
z=r#l0f$*vM5M$#n(ETx`dkrrcetWHX20WPpF3Z7N_}(Gk9S2IZ9-v(|&Br8QN+7Ae
z`7k4_sOe^C*ztlvf&nuA=h1wF0n`t-1ogxDo8&;VXrN)dWEK?<%cJ}~e?e1FoS;=x
z;D7>^#}T0OKOk3HVJ;{_*h1{OB2d~gXxD50%T%HSI)d^LsH*}h=olD0KubSL9HC_`
z*e58(8^(efuo9RPK$`i%8P}uv2>um)kb)iB-`h8d0d$=KD5k*X!4D;c$%6_Nung2;
zFmY1nK*469wD&;sE1;cUo}JfVz5vyc&Gj-2rEbu5bfAWuGJCgwf=6cycqZGYw>|;7
zG_2Iqqw^VJQJ9H}N8>RG76u0J<jE(neK2#aT~s(q<v{yyu+JA6etQi&MG~wJl(s;a
zX!m;Ia<50HI|u#TJfz)=(q0Gv%_VVwE+K^Gj!qX9@Uepe9=%QI3-F9U^=r4DZ|htB
z4mD6q8NSxer#nSOz^~V40qE=tPsl>L|I7@qC1#8akSS6I(567h1OjL`4Mbh?zyCgp
zFFl)|uzMbSqUFhX#+UPmXSW}RXSX?M8J6KAkJeZGEyCc^t(*f%2(;qHv%4I!p$?+T
z9-<1ejSeCd3KD8Q%IMpv2kvdZ)WTeu2Ay;S<pRaipppx9jhY=R1A{02HEQ6loJS|i
zO~~{e<WvcD@F_g%@KYrMK<2<sm1u)-AWMWGeg9)VhR-}&-|@HlvoSD$ZleS*7&Bl8
z&4nKD0o4JZd!jv$yMuS(LuR{LkMXxW0ZqH3Zecmc-v-(n=3{xPtp4Q@kUU5sNC@@F
zEzp{^9pF`8r^>=!u7fEA31KQ+1XZZ}at2HxNC+uUDjowbU+jS><ZlOUDuXq=yX`?s
zt05D(kOkYIJ<8o7pn*P6rwr86_Ut_3*zKYs13vNK0O&#>>o(BgpZu*cpz#yLMsUzt
zL&&yS78TFEp!WO!|Nr?t6^}xO_0i+lqw_9u9G~@2Jo^3cf6(1hEg_&-$GhttmUbB$
zJUNeow!nj&r~%sICC0(P(0t&(BdFW#xRsH=^)$%I$6ZupKrV7@u9IQlZw0Nd^6bq~
zsXz*+&V!!He4f2=369-v37(xj$3QI-&rUxMXqn63x(DQ}-VzlF!~g$9K|uqm(j=fo
zuSe&7kIq-%BGdyizSvNm#K7MII*J>#>0E<>zcmmvnhMR-(DmaIkhw1K*lH(ee{*k%
ziUY!Y7ZnGjMdS*e-EFW%<QkxJQsCQ{eL5d`G#|2X<llA{RCP=I53oSYnS&kD`UEst
z<pIihw1~1PAg>V@Wd~qU29ArC=in<+-XaHD>uFGHM9pz4qa**W6cru0B2LFf9~IE_
zr2~q(#sB_;&d!Cd4FLJGBokKgQ8$30q3Yq&`5k@;GBhTwT~s{yTPJ}!bOgq5eL)RP
zl9HSgC|L0%IUi_}a|K-x3O+vt6bSsSU7$6Uk3d--Iv)Bm9+@-$&;S4MP93DkN2wZK
zF8l>LitCU^C%F9Ud<`xFLFZj~_Ifgc%9G~J;GJq0d=x>YphxFj{+6Yn)omJ}Jc6Rj
z7nI~+x^zHSqrkPaHvRhlALDq?D)5;OhhcWV2ipzW9tF3%0%T<84Vc}3`CCEfKzJT^
z2TlBf&KZT2;9{T!e3rld|2O>h^5j1-<q!7wdB~b4$oj~KppDnC1(|}NBCYeMkL5X^
z&TIT_QJ@;N^Pq>~M-R?Z{4H{z?T&7s8W*(W6|`g#ixK`{`J3PceK$Nh|MIu31T7!y
zJm{l%5Nt{Y$dsvIF&svKW(h&{Oj`&jd=wA(a311snF-S73|g!QUZ{!1=6RsNwLAxk
zj5ZCh`EWb8fi#PNx5z;~4_fGnT>hT(0J-p@Cw%E8Xula~g9qpUIQ|w;EWVry_S$Jk
z=wUO!L-8iU0LcB(CqZX}P6s7pu(Pr0@=-hp(^U*w+Qi=)16oL@4i0=!5E0Vk>(P1=
z<m*<WAOHWqd=E{TmIpmMe}aTtxIw~wp!NHmH+(D)`gYy~#Y?LoNcb3Nl^f_{U<(lM
z@ej~qgM%PltxrL_+u}goNAS`~&<Zz5P3d|00ccS}>j}@!pQTnlmgmY$J-*-aw7gKJ
z3mFRrt^S10c7w8m;wMkoVrS6FZ2YaD!1V0=32%hdgI%1CI4tu5$N?>dAP0bUazRW5
zI{@4*^t}AYv-5^e>j9Wg+`ogIeU87)?)(4$V7FZ2Z!-e1!A{5T9?#AjP;*-TfBXOc
zCFq0#gpK<_gNGiMpZkCoJRE`9vm0bKbam-^5SxHK&0XLB|9>5U)mV^UTPwaneUJ~@
zu?96c8N?=JvfVdOQI+Q5+36PG+gaxTE7x9%gWLt_@j<F(2piUmvlar)Il>Pbf|OaU
z_ey1<#Z0lAPv=Ds#S@@OnilZV)AOJnD>xNnWWI_haDD}iUO@7Z2j{7hte2prg}8Hz
zkK#pmy5|RFHPCUDrExFyz}pNi^0$Ci@V}117HAhrT|w#2!2=vpWfl-MxZ@dgIwgP0
zRg_h&-@k&ke7b{nXq3wMcBUgvql6?s(2l;BzrOtc4=ssX@0Ciz!o~?6HYG=2f_w5f
z!X*G4E}&~e5#f^X5;RIkT(~5F!UbFewTgop1(6V+g7N|)WnL(C0)>VxG&FGS@<hvp
z$3cU}oIaKp`CI;hr-`74OTPg}Gq~adCx_;Pj6Rm<ihX=KFN1cqS>E7pISFb@fmVq?
zJb{@U!oW4iW&Sqsp#re&a2}kuN)k|Zb9NrXQwA3!c^-6z1M)ssWY4>UJnsbcycHyX
za3=*w5p?R$|NpP~d@L`Pa{6|rOT2vb`Tu{H&Iip8n0-4{j=#M98D%jp`u#i};MKVv
zoxeOFdo(>Ddo&@%Bcvk%I@7-M6ztm2;|}2F_i+dC^4kxvV?i(v0s##@fH6vco@Dz7
z+kj#|Xgmh8-t`)I8Sx)bi(P`DBpTGMC}=%UVgb5s0&RY%M+Gz>>D6uX5;ULB?bG?q
z@&9$O2GB@%=Rr@)vqd+FUaWcuW%WGTd;-XQxW<bH>-dXfh)44q3DglT0q_V{98wb)
zWrPcT#3&xr>gIs;hCl-v9G;Cw-~(OHd^#axUEpCaI1knVuy#=qC{^@mJ|cnZ{xr~?
zD(j$wd*CVpobn(9O8P(<pHXn^{N~d6@!(4im(EWIUkMz1C*jepk3I!*#8dN*XY-#w
z{4JWGHs!%TOrT*1kM6yoMB~}{*HiN@=%m1dp!tsn{LK%+g^rC%XNd|=XNZbGr;myV
zY!&fNP_x#9-}Qu#<wH+?r!$}#5eei;53t)kJCB1#fm(V%ZLRKBaPJkg@Bp;rMgz3G
zwHY*?313YNTAL19c3`3czMn($oQLK;(6WQ(N8t5Yw?O0ljvX@m;B`XHhZsTYv;Hyj
zH-VPwfaY64<Nb~uBK)AG!l32D{E!6)jvXQVkQE0Y7JSLU#h0LNo>wo+V(1*pOVHpE
zXz&NTrUlOwO3h1f<pE!Hzz&I?Gw}5Wj{Jfwpi6%s_X{B{A4a-g2x<8+()~h6%ZJUu
z>)p(u>spSplr8`*JAf}A2Cct<tv3LzcQXgCcQc1CAASU0aA2as-?|<&3e&w86#CFL
z2R@x(o_8<Ha;V=ya~Kkyy*&LMoxPyc(Cwol(jB5A&|RX!<I+*^r^DlKN5DUajsnn1
z0tI|C`OvTcQ7GvZOSy_7-}=9#xbp{i9>eknWE-nv=TFCjFS#8XA3|m_d?5GD8GiFf
zKIg-D5_A+Ig8)NukY_i`36JInpy>>h^3bw^qeRrB8+_yN=jLOKjsL*Y83$kUcytE{
zcr+i7c+FyX3ESnZ&<qG`mtl;`J9hp+QvyoJ;4}~NI25D!4?OgTB@m!$K@^Jm&JXw%
zqt|~}RHK-OC@&z@i7V(*HqaK19iTxdPsQW>Eg)~Y8oo8W4PBq-*{yR2Jm>VnruhM*
zN3V?rXgLtrm!6%+d_n7*K-U1ihNXW{HQ&wX(U}R_Zd>}%r&AMjAfs>RS0BsYMVk!&
z`*eOlnQ!vw{0rLG4nADB^pi*H+Y&Lb;U33bK|@&#uh|U`yq0h^{I(xd+JM&cfu)Z*
za4`6E5?D?GUYr7pzjk5db~Pxd!5AfcK=m24zIE*U0=^Sm7vu`?mDSx1pz{TqD<l~B
zTR=A}><5jo!X3mPet=)F0hDd{1sg!w40MM*zo0_~zo0_|zo3H$zo3H!zo3H#zo3Hz
zzn}xh@di*E3~YKQyGy5nXE(b~X90(AcPRsS?#%GO2T%TueW0!JCAE&=b`_{z&;+|0
zL7=XeIKt@Jybq*>p~S|q`44A33F{>gdco@@eEBzmO)A|^c3T1DN{sMDnn37gK%S)Y
z?Y0B$K>~#cXa@E_IG#O^gU(f8z&=NWVLl>#do;gs@aa75(|Odh^DOw3&2OHafA%|o
z78rapge)<D9M1rbI0prf;|}0+89cjnR6M$4H9WdQ4L}Eof@{kk{4Jn+bwOjI;N|@s
zo(CbjZ#=p~EkLGg-uD5Wl=qX_$MPY6Go+;+qap!Yqo)B{G+_XmKe2$V*27kLqO9?T
zcpsF-{_{gCPgf1(eK_a%!Bf%Ry*zfHzF>1R$Zsb-Kr4$N3-&y;Yg8ma>-|A>C-Qnd
z#|{}j<ofeJX8p+rt3UbR^(P;^{^Wz!pXW<q^{2>VkIqnom%QL5d!%o_!M6SYRDYU*
z){C2gR)iwepJw3o;%1;Vp-A<o8F;<88E91~QvGQLu0PF)tv}7c^`{wf{dpb~ppXT7
z9^JLD`}cf0OEtWEMV^6t4Jy<XJbQVLd35?(fQH^JKoiskAYl#AqGb-ym5&0jwR=Y)
z7y3Y!?}2X6fh^wxu^`L$KrG1eJrE1Le6JJ4vgq*o4{n*gFj56gM|8R}K)70<6WSO*
zcyzjQfEq3b!TT|HfQCmdKj?H7fGE=cc0q-)!&Sud;9CR7hNp}!9l4?}9)JhqTrGS$
zYe6HEB`n7rI2b`^hZ0%0<IjHzomV|Uqtd@Uy16~N9Sc0VJwa>EN|YSC!#O+-{$w`%
z2D+cS+vbC%IDg9x&>4E*>($Q{z1|PXitwV<r(4;xJ4U6zvpYnk!n5-#WD(B~{uT{z
z3-&KFs9)pRJw*l7b_5;G3TiQa1la&u4&MyAH43^V$wft?GY7m44!mL(DG$Q;SqLES
zvjFEo*pi(V(CBWri%J1#!47ycoB?><Y$s>{53&e{zqtmQ2}@KsklU}HzzbGHJ-&n6
zuc+%)Jeoo6S1Cr=ec&P-M6H)SS9;|oXbYHEugGi9&JdM~m!L&>@a5QenyytZmw;OJ
z@TMzDdkNlt9VF|2AWc`#?i!T>Xv5XBGe@Pst5*cPz#qI?HbkWYl-mS6dU?RxslaPy
zd%($|8x-B3n;2mE544RNlKDU^Nah2vAej%uf@D4r3zGRjEKufi?DpsA<nZkFSMccc
z;BaiNFJSWQJjOr8LBQ}fVt<5VLyf!vgGX;PW9b)A3Wl9v<I((^k-r6$Eq!{O|AThw
z6e)T3ipYC3AJX@*yujZKYBPBBib#MCxcBTWH}J5$R$LA`Q0ShA<~5JzWB(k#9bhg|
zcIiCc{G8e2`+aEp%#nYakGMexj{s=*6X=q8(0)o#f&vZZzGgfFmj^QpJA4Ef!7QT=
z9|0yX%eccwfEl()<-$u*a2bBcqxsPTkKUpO9-ZGk4!&mvncVr(qxm2B@^*)B$C>$C
z7lKBcK)K7O^BBtI?RkvNPnjVbLP5*@QPP(qXaT-~Bfo%;xdVL3KUgpTESLaVmk(N#
zZ2(f_0=i~ZpvN4Pvq2J|h1sC(mI5v2ps_kfet{lyP(KVL2U?(Q04?c{vXo8(IkLna
z99{{{#~&Pg&)R&P5gK-g_1a*oK~^EV2T}nXXDof_X?daZEPrd+zyJS_xk&s6?Xi?_
z>~^nl>~vFb>~^nk>~s_Hgzet$-VbX3feQ`KPB#tE@%1bY9T|i-Re}mqC`M^7p|ocd
zJV1w;Lrc>Lk8aNd56y!msvg~;0-&<a@EdqPpGUXN2M<tzx)wA|0WDBp?FVf$2PH?a
z<9xcUJ-g#0JiEgakefK*NhWB+#<M#-15(t2>lA3i2DH}}QIvufZVKRT&z!|5Nx>b4
zxBM+#;F8om0=xkMIu3A-zZul^@P-wnt=J3FSKxwF2DJHr6&zyF@c@+e3@G`7HXk63
z2N2bsIa_)Wx}8|$v1ey^!pr~Q^^}CSAfRt29>ndLv;3{g!K2Fc5zz9~x3fF~)RqDH
z*t3`CooA<i259xH0H{orfR>x^3xzswdK`QSDL_FiNC66BK?+b13sQiBSdan~!~zwd
z;PWXunLR*fGj%$19CH?6=&qFjr$~=ZX9<E^kHPVcCx3W$egkc}0k<}g@&~A;aS72s
z?KZjKV`;|UvKpK}4l#OIo+=_Pe<*;P8<2)SD1Uf#UiHwt3vSOr^9N`x15*BgZp=Yy
zX28eEFq;{koku~NGNHS3+#@_dgJd!uy*wJ=E%(!)NfEj`ryX1N@aTkO4>?fwU;_u&
z8A$#>+iwrgAdF`q<7GtcxA(9-3*T=K%^;u#KPUhQjh3Nj5JdS4Z*PFcuLgd<J*Y+3
zx)eQw<VSe*ihvqh3_hUUIpGPQtO0Ls_<*+Pfbxus3M{*TCkG+91k`+h<Ps1Il1o4=
zNG<`fAh`s@0_75)P6LnQ4&YOzjyVW0dK`BEFX19Ccc6{WdvvpRZU7B4U>O*KBoEa6
z{2txxxK%<l1c38v#7j^&9VCL1A3@_M&^5WBZvJubi6bDDu(5B-d;A#ofyQfs13Wts
zcWHPw|6}w4Z4SNtAJlF{*%<24db>mzV`m)b5(v*u&~*%*EGmwjF)AEhy*!ZJSgj}d
zTU0?q*Udi_iX>s1w0sy}d01X37Vzj5;qbA1RmN_3>E&fmqq_4Hq~R3x0JQMx;Ct5I
za>nLo%pT3Z6N&{u$J>14Zw2kgd3gq;x;O5>hvsj?|48RgfZ8Lr44|fvtpL9uiv_=+
zkA(nOPysAxz%S@x0csyvfEq0>whmy?0FWrCaby8%MY-4}fJF;HqM&AxMS(~2`v#BZ
z!{GBLzLf-dG#?l6_<j%EJ``}V{Qy?Z08$Rx5^3Sld|Ux^=TGUw*XoX4F`^6|G6Eo)
zu_H!+5yW8Xh!J1{F_=4IAdN>4%ZsH~d|SVjaDsLi3HWuI{6M)A1y{O4iBFH_Hwv(%
z0=^Lgx+6>iwj(TU0_d6~&=M-k6GdO>v>(hzg@XaSAIt^1AFLa)%Fa4OMWR#^yes&K
z0;d0<gTvtb0?H{6jN)HVegUOlP^Y!?y9adNFMkUUXfMD4@ChuS`3cxoI#5~!-EHgG
zP|v}@-vYXAw)sClfAcR;T1r0d(aQ_UYd+m72OYaiR2&-q<&~;!%mXjY038ns9u93e
z$=?DRuyy3$#v@|IW988s#8~pmw_6{y?@T#uf@g0j2WVq@=cgBrL7*El50s|+LQc&r
zeGE0Ws5EF(5qOZ&qZfP@uHgZA{n~P=M8J`Mn+T7Uh@nTXCu7OG*Xp3<xvk$yWIaGT
zry;8yd^$fNh81644`g64Jb(~DzvcxRl(3=PEJ@^{Tr|lj6iL+b4W&IT02;XK{N~XO
z9^wVpy`XJLu7*!Q$yn3}vXjfV^<)XBW3wGYiJGh76YvdaNAT{VbZn^0U?{l^j+j<Z
z8v`CO9^EnrySN*E=9Ox1fW(Tc;S*>GBEs)L$t?bDEW%bSM&PJ<@7e8U0NR?y0WDa4
zlEJCZxAhW#pB|{M23hWB_|3E1=7SY~sXVBU$<TQU+COZ$R3gp4O@!G>gx#apfwAO0
zC|~<nUaPtA60{Jip~h5$fxiWGVhCt-nfXi?w+AG7`*c3@IQWd!qua*Fg1=PLr&q@a
zZ1QW={k1J8OJw-B@vvL*Fhk4-O(*(Vo+;Y)S{sz&J-Ta*I6$Lf9N>)5a)7^80qkmU
zT7@a@bb(k3zWD>R<pAngSCB7TKuZK6YgfCteUlHl8a^@n@7Zng+lsGL5$vYUQ;6`p
zRH6>?FB`-?pq{Ib<?)(xFYQ5{I7pTB(%|3!|E`8l8ft7o-dFwi|GzINcY%($1R4Jp
zULwQ81H8MPsPK?R2@lYoP9Mv&McZEP2d&vc4~|k;LW8O6dpRAf4(!lw2GHgnA<yno
z4rnrm?o$2W*z796=-a99+nr|dG8Lo)lCfZUq!uL`KsCc8(eel=o?sYj`2?z8LDy+H
zf_DIeatXr+PyT~#pbe2L7)wG8Z^OgC`8Q`h+2{8hX7uca8d|!|x4Z2Cg8+kX>wyv{
z*!)z9g=cpgXp5%dNsnF;PZvv_3#BrimM6**Ji1FRa2Wod;Av^{r$h`A>Hmv9f`++$
zEDsi4G(7NH(4*Vug1`pQ{eC5^ADSHn7(aM6f~|udbie^0_rzJ6!$R;FBLf3CL8F8h
zQu)&O#sSn_===k(&stP0Kno!u+10a~p<xGj%QSxruM`7A!;X)j9iaRz^`N!>y)K~R
zlwDLLJbP<YJixncK_j36plJjF=(*?r|JQpc-tycBD)K>x+4wS-s5p2Ye8=R`dCmiR
zGCkur&_PHCUx0>)Js<<a;E5#Ax;e%V;QhBAjNc*a;6Y25JT5;4UHWHv%!A+Q7^u)u
z@UVRE!SDVa)YUJ5sIzN+$mH0tM`bGL$`tVRdi*XQ9rrSWjw9lCc?TMb4De{Z?ZWT*
z&a+zsl2$zU54J+nN~Ga!l=(jj(~Czp)Zo%>pp(o&mu9sdfUd<ZG4SZ_1tk`b=7R!;
zmmv4Ax>#m@DCP38Ed0UW5&|A`J_I`FMZ&}KP|@QL9*tn*K<NQAFQnO`(!j{Tz^~b&
zQUIkBpmYGJO$gad0J;RJn?(gQ^LY@wWn>rRF49My$vrBdEeRf(CqZXlfkyT`6km8K
zUhwE;IS4&vA9OlaHwz=^sB2IUz}AD`<%37>6cvy?9=$y(AbVh2hCRBiJ-VS%-90Lx
zlR;ger+9<P)hclYhW((CGWb9bsB6}F^q4CH!!cJzhGVWw498rV8IHNKFdTDbWjN-_
z#&FD)odMLDk?`m?fDHA)&KFla2XY2zNwZIHi%JB@yPYq=NgnD9kd#Mv4>*L7o$*8r
zbWp|`l^>uUYqvBc1$gowY%X9BU|7Le5^IPkUC*2$?Yu8x*m+;Ro%g|R@$LK#+Ai1)
zHN13#PdB$?!_HTb%ybx(;W}eLhaqhNhiLZ{aHx6i|95BCjIt0T0iVu2Dhoh<JNSs1
zUjtm`f?|6DNT_#>3Ydl-Nbk|RM+G$F0NcY1@;jK{-J)Uus^~jUc^rJj0qXxpc!1dg
z9-UKEKv#}JxDp^P$kh<80*Lzn)N}(Y)&OxKn|na!7=XAJz_OsNrUzeIcy#ut8~_V|
z5()=swM_;j%?W_m&?~SdKx_kuxB^Ja35XViM_+1yghBhUAgT;NT+m!Lh}-F-;^A@d
zg@s3FiwdaY2%1#^g$0)2>E5COP67mi$)|e?B-r4=<f0Pb(|N(;;0q3rEui6B2v-2a
z1&yFWxDp^PXp|SiRRD28gX9pd2B>(_fUpffQlNwn;aY&CDtx-RJ-a(Az^67$YycGu
zny2_%lNcde$-7-t9DKTCR4g1DcD@EDmR8Ui#4l%qiUi1s(hQ6YXvME5=*)Z2EUttH
z|E`Ay#a<q*m-$<_gVKBJZT?PI5e9~rk)W0E-Hf2IU)B%J4g!qGWeTh=u!htH{4MGr
zEm>d#F7vm@{`&tPRJ4MRALnlcUw`vK80=tZtoo=VfLIwI!UOD0nAbrZ4G;$uL?9Xz
zav&NMpdcC)&LA3+9$Hi&37|y<67!JQ1{oUxN)C`j+oJ+Wtt~2$WZI$vNuMn$kc8O+
zPLGHX1g(F083|fie()EoNAp1m!*8I0L=VuJZjjJUo8Zx1`NGrkN2$7pb>@dsMIY<H
zAEnZu5-7mKnvuT+bh#Z${orHm_@h+P)ACoTh=;XiDL+)H;|JIX-Z4<|t>9sKt!Rm>
z;eWVeS}uaB-|o%{-~`Y(1DpU(@VD#&<y6p_N8qF6!0!10K0_`Cbj`(U56k<-I-nD{
z3PAmL%X?+|9+rQh^+}NtWRB&a0I0G!_A(!ISvY9@3TSc?qP+Yfs1SwgC_d*3ZvcRs
zavt4~a?!W*xNqmxA}MIQ%<zCO^qvUc&d<J`uY5ayeDG`pmuaA?$hGAOe`~KG=x{v9
zA%BpyAw4Rf61Ak*5nKx!-hQosych&xO!Hwz&*nW~g$yOupvv|(u_tICYb`x$c;JIC
z|Hds~lR!skfQw3xZVr#`ouEAC(cK8nW1WXQG=F(C|9ZgR;xEL&-~mnuhZsG&H+Fzx
zpz|~6thLS?9tVH0f@i%%z_)bNfG!a!QIUYHECjFh@!)s;;bD0lRGun$@H_qTIQX0u
zRI`B^K?R<j=Rj$b!L#$GPv>Xw#KKAbmbHQm3?ALhAP0Fi|5WhoyaAr4<p3S*)ZE0y
zz~J4>!v|h0QOX7CLW24w60mt%ZO|#h;PD%jm4+BI3+93h43JS%5u#=lPL^JL$qaTF
zxXaVc>A0P-`6m;9QvjmX4!T+7D%eBdLdmo96*SL)Dl=&L1im~Ra!|=JNa6VrG!*aA
z`N`wpD+y3AIY8J7AhrdB4L*!B1Hv`{i6=nV79e&6Y9jj&DnkN5Wq=2N3%FA3)&}?T
zA*ZMGf>T>QJhjPzy9~%l4z$a^c`ryALx~kAtvw<kt$9FomL4-a@WF?F<5rM4r8}WT
zrcbwpXZL(aW^M;%X82(qANX6If==K(_?HE;4xoPlD9d-A^8_se_y9WJ41AJD9q6{1
zP9GJ}j1~A0TzDe$v3&2z@ATK>;ByvO`hv_#fX`O^#@`YLGQYbWY&-0<I0H}1GyKij
zY~VCy0!~wLY_K#X083LKC!o&#J9fzMfI20hq6D^f^#dC`Me)Ga-SEKI-SEKI-S9xy
z-JC1E_;L>$s5saIZXbd#M+e<bF5=U@2i#QiZT$}xbmVur>e0>Y0l6CoevXTx00Tqk
zWwb+Fv|pPNy#EH)_5nBQpy#*v^sZ5H0Cnj*-*?{g>HGyw#$W<ejtYQRe@p?p)2F)y
z+zRu7HeP)?-@{H)1{LcP;NoNo*aIM?pw<OQDX0mKqLdq2AcK7dUX=%FQR#bhgIC}+
zKKk(=R1lcJ`bwZGN%5kGbswnmE7J6^?gLd|<q96Xd%#YIEeHdJ6vRA;LEsg!9^IVK
zE*IFCQyvFj>Nh@w+Q8vqJq>KAgopJsu%Y~DhWhkw0owuEq1jymy`cv@!uAauNTAEt
zg}6bHX$;G3pml$s)L&BMxCgY3$ME)RMQ~<2a|YJ_1#1PD(EC6t$;fY>%@Cd7{N~HQ
zaT&;*(w(55o&+>}eY%xF%@Js0dMZ08Oi|j=9=l=fXphc0l((a&K-<wLAjO-Dih)Nb
zhz)KSLYgEXF1TR`3IK>KxM2uspnzn-jUY%n1;hon4M7nDQrzjHBH(cl(v$|p8fgCp
zv>6I%S%X@oVB2<pTg@OY*fvNb3B(2425K3D^ujz18JzMs_yTM>q@@K?47ME70J{Kc
zdx6_#(AG7meMXJe^%`jF8WMQE;9EO6d^=xy9(*a_+xg1#;42B=&exs?UxRMe@;LZj
z!>9AD$HBJ-KArD84!*PS=;ro8slq{pp5`CV=06YkTl!f*ry2ZV1r5`AbkBrT;h-aH
zHGhK#7Jjh$SU%uywgl(?Jt_>Ko<ipq70{ux9-V7cK<9aTbna0B5BPP?Q32iD<kLAt
z1#~l!PiK#c1z4YpN(HE|18Tox)c-z~&pr8_{vfLUJt`ca#RHw^LGjPv0h%+t4cc?q
z`J2B5d{+ys_WuDnubcriq1PM<Y72tTIXuDN>;t+^>?CN7o`whLFhlU+h924w=lgVm
zR=yw_0O(7#{zFbGXJm$y*hH<=I#GJ%<pq!n4nAe^VSMe`IUiJkd34@*2|8@l^WYO!
zU&iM?ojXAdD4)(BFD02l4W~z}9*oyLAfg_fKVC9$g3eL-NbqR$;+LS|eGk~`F68-D
z78B5VN)xp8lqTTylqP8FDNVrZDNWGUQ<{L+Q<^|m*}(QAs6x-#gr9u~n#(l-ucb7B
zETuWbSo+A*@*JqWCBWZ$4}7WPeo%c1UxTn5#PdA(l*O0vsc+|ca0r3cZTT=h@a${{
zRq3FGjNLve3LPFFK;?2khsQ?{?a|@!2}C<|czg!Y79Ad6Ky*fj$5#-Y(Bbh7L`QUZ
zd<UJ-RL~Ldqod%b2l)7Jfew#f5SB!T$8QKrp~K@3gr(8p@fX4}=<xXGaqyKzN5Fqj
ze-2bsf>zAG{J;u|l!Le<#mVrSN9!g2R?uAyFG0td_;jAcshYpp3e<#v=$OmK!0>V}
zsL_HEm9$uz2ik5U09v02+fM?r1oQmL6X1Nq-+Bmi9$oitP)i#cg&v)&K|D}$_GEnH
z)43RwoISc*z!}zq5p;4EsQduUpn!@!22hRXqEZ2>;KAiUH?&;nhLjT?-H>tv)MEmd
zBi+z)rQ1hEpu^(<C`t`FJRX8ZVL(+whsPrj6I3j8csvF%K~+MB#}g0}R2_79JOwd9
zRY8ZxGY}J019W&i2QfhfbBD(Z5EE1pba=c3F+r6;hsP@r6I20oc)SKNL4|*Z#~Tn6
zRMK~Nyah2qrF@6SI}j68vUhmAcj?IZ;L_pn(WS%VlS@ayXP1tMFAg0QUmZF!zBzOh
ze5WuSqSn!nK0*tqUFO-nMFpIhx?5CcfSbZcJvG02Hvj#=-vYX!*c0ATo}vQESD+NG
z`4Ln-9{j-qZYqO94m8XG?l8dH%Z}g%vk$-P4`0jozWh#qJ)sR|pU(dtoo7KI&*0hl
z0=!)I0DlW)xoiu>Da|OwG3bDBPgrpbIza)n;R|&4R`ap{9-8Mov`bVB2o=Qtn4tl{
z-vqk!0n{NQx-h;4TCoc*jNf^7ZUG09N9Tu^-x&yGW*%^6F3ow_4Qd?>vTRwRBEa9e
z3%qh=4>-`F`O>p<4VVimTRj=y`gX1Xd)Slly)S6&lR*HyjC?Q@te%Z+u!0pdY$O4l
z14Ozm(xaOhdB=!PH@s;LPJM>AK^sRPr+xFU`_LZC(EOXJM6>las1N}SN0)j-2V7v&
zIH-3+;Xm9B*7t!K2HLB{1sb=9UD3Hmr32IeYW-gVJBHljcneqzG)DtsgL*U|_HoF(
z0*DDJ=Rk7{puM_qZQYR371%Igs|RS%s__VDMhQMe6^m_-3VNU;N~KSuO%zxweJmR&
zPJ$|Z3I5ip??Bu7cYx{$P%Iq=$Cyv&W{?1=_ov_iKGyJqM`tsn=I~J|@L~Mu(b)~E
zHhepO_;$W>>2LrS{1KED{E#C4Ij9Qp0GIkcDjDD+-$x|@T;BVr7(feqNF4z#>>;%Q
zxUh%R2H?UTQX9N?=?M4$D*GWd!bcDjQX_l<F(Ea=XAl!o(|}tj8sHWRWSu&+kx~I|
zqy$h{IehSJYyl6|fm$h`r46mYfB*k~8G#sa0tY`@ZtxNX4Pd~Jo<N;YMm}8-))__L
ze~7+*2Rw(yq5?X;5wv@c!K3q$;Yo<iplwRsB`O>*qK|`4aySkZ1&stEXCPQka8Z#c
z6$7n-!<Op73tPYjpsjzyRE)YF1Uk3`xip!*vz)^NdR7ng+_dBF1)w~7%)NwxKm5Qk
zcLN4~L3agyLHCN|?VyMRNurwJal9QA*&qpi!FEuR@i^WNN)({0wD<-3LCJ+b1UwMP
z9|oZWA%cSKptOd?#YlmT5#G??0WFB?B-8x_Y($#h=HK3b1XS_0o-7qWU!mg|jFy&^
z#6a^F2cWTn@B@;0j=|vdPtg7N$OnrHfR5lQ4ME<I&(`gi;L+Ivz8TNAcONK7eR|Vi
z2T$_1g6edXZTX;LhXZ;D8hE$`GB5={H4U_&7EMEq3J2(>HIOG6N~Ap+kAt@KJ9cja
zl^2fu+oyr9KzWg^0J?4M0O%eyQ1p5pZv(jn6uqDe*C6o=F20d2Tmy;1(g}F`zZt&m
z|AznJuHbJi`wzNp-tgN?L(tKvkSvKDsF>jy>KGCXI^qCkA!yJ8yxsSo=kYdJ;&g1T
z11%vd1$CyudvEz$KsSp*&&LCGK${sDJ-h9Fy48I;AA*je!Z-@?v5(?wqyrF-fHtM^
zw}9rWJrBMya%_A867bAC0-pK?o!SJx%g2NBpvQ5Ro1hHh+pP{d&q9Ww!~-<UGzqkz
zfWHOQQ}XSu=K!yM14R;OJ)woCwTp^DDKBg$94zM3X#u7^nh$V*R&QFo&i7T;Q2`xw
zk>K08<_IW<`gZ21aQODF1I3YVZ;A>c!E6L2Wzg~OuyY(R5)9<jJdi6J_NYKy*P8Sn
zv~K9_YlzLB-6bj-9-1FK4!&USgdJB3+C2>|<XR7uu()(*fc#Rz=Gp9`V)4VZa~-H+
zfJF{CH5h<W1H59#%#h&tez^>CR9F=DbO6g?nCT%T0FiO|TbF>m4J|gh8M-?p7$q2*
z5Ar$g1Fbmry!^~3xt_zPTNM;Pp4}!Ypi_Va_shU;tn=tR=GkeY;?Z08-=p<=X{l%C
zakS`VJm|@I&V%th=$=Kz@1R>xHUE`~?E>xM1+52ljDc+B1+O1Q7C<jh(25gBq~ZiB
z1r8N30rNYEM)iLfC?kNDB13%)$_wxk0JPtPoDv{Yh6*KsHYm;=<1ix|CHGf>a{pvx
z52N}o+%XKaeiU>D3oJ!}R?mTbEaurc4V2yYgRU|2WZnnr`FcPuzVhtc2dZp5kGFvY
zL2U%bZa)s!Za)FXZZ`>j0XGhQ0Y3@wLZW9z9-RL?I*mHL5}FS%b~>f-hhO3s49f60
z?o<IvBp!`F4}cEGZ02ERVCX#H*m=OQ@xlN9_6(k&Lr6uL85nvU89h3iAj5l2pgg&P
zza-G(_yGo{|Nqk_9BW|$Es<e3*22^YDgchPFm*xcZYbRYrF)@tAC&F~(V)y<y6d%y
zNAD((IUbhB$|U&15&J#(1wn^A2zXe2DEiXb1ybVD*#$C@U$AM$KL!SV!LAkm7#L7@
zhI@8{Z_@PWbky+d2A7#0-5weqogSd&XP__zbDIx3cyxLgKm)#^B8j0y6UqS{IMKc1
z1Zc{$o87a!OyGZj0Nl{V1E4!3peeGO!6O-*2|b#Ba_~3*2NlTh^I2h*?*c{9|HuFT
zdngNd9DJzd!FkaGv=wn5$SpXFXy4AKzKVZ66^}Z8hZfF`Ak*;|&R)k^z<CpDwP$x9
zD5ZdQJVHg9D`Xf--F=iTx;+wnI`^Ca#VEW&PC%5eUqJ;8j?<u@!={Pgc@bP1BdfMi
zfmeb!tKtU|<Yh#tPmVQ!3Ux+Ulz~p9=5Ga^h5<g6I>s>;QdFUrOyDBt<yKH>j9gJi
z{Qv*|W!``AagM@>G8)#?Tnakwbq6S`fb~POG)xwBdmHRbDl{oj6g%!<hnK);O#ouc
z14PXZ^}R=T1#CAvOayui7J_R5%HaquXje9aV?$jD1Ai;{&`oIG05=t&Y0(~h5CV7^
z+z!YxxCb812mbqZ{_$0O<EePW@%wR5yMVt1k`~_^IW|5A31HSFoCm#*vw+SYVt~2;
zobvoUx;cClUv>v1cy#t$03|+9+QgOsUlEf4eY?T#_EpyR?OX>c456t3oSRjl9JJiL
z9h86n2S`BmLep?*I?CDSHY$$Y<rS^pN+e<JNdE2NbuV<q{((*w1s9!2%`uoopfp%&
zjX(Vv{)d=cy6p8{a9V<-#cwachv%au57hn+xV;T(9|m}Kp7-p$>H%6h@dvcNGy`;=
zUF#<X1_ocyv93En(~geqY^?`MO<vo9>Qxv<86&~C-vc(C3mS)HfapI5+H%7IYLpdt
zbTWf>8Sr>^gN6ke7(6>&L027@aDxOu6@+IeJO8>5h6fzm*_wYal_<6zD0N254y26O
zz+3}rXW(gGq1k}i(M8E$Nb7r>-w6129(U|K+j$v$FA`EH@_~*cMGHl}*A|cvBt85<
zfdlGkc(fh>P0n(ZRCspp0k6FB=<bJv8gyY`>&X&(P-gS&gf8!D{a@nUozDSYJ?&w6
zw6qM(tEsA>n+8CYiwAUVr|0n&6;Oc>%J^tTm2Pzeb=V!db5sf}zw$SO2D5ry89^sn
z7j(XN{4b*7(Rm!?SaAEc)8>Uo>wo^1R8W-z+Q#G3&ER5rl)o7?THEbk08Ve9Lk~Pb
zOGrWKuDeAAoSmBwGJ1AGMnya=PZW!KHXmU0?Sx4BSRUkW)dv~b4VpIW^<ebu^iioe
z?hYD4V*m~4aCmh3Yj||J3v|SnG}m)5l(4vT=GS<D4%hkjKR|&N$*c1PD8s@N7}kL~
z@DK&8v`0>1Xfcwe3R*l1U1tl)%P?K(s)!ynR2OtJ0Js!@3c*yTsNxyR$ySA~UPm7<
z0ktPX0z5nadv^OniUiP+lD@s=5=bS2(Q6w>S_YA%r)S^p<)C<m#)P{BHFG*>cB%OY
z2dtNYUUj2|5pq0$`~t#+^7|Rj&a2RU_}-8Z5(Ld+_ZB0Ekilyr??Zx>P$=bPGx%H|
z#?F^6-OdG$mM{3*K#}0l-3-oH-8Lt{84GmGr%ShcfoJm%M*h}23=9m%-3yq&QyBRQ
zE}iKWurx0L4QXl@sd#rm;R$IpsXwr^h$j9IUjqKG$^bbf3!L;p@dm>v@dvK&z@s4o
zkn_CY$r^Nz5?Zn*X8jYk`10&-2bIF$n;r8&69CNz{(E+U#auccx^}x4xLQ8oZv&N3
zp55)BIP~dOIRU<Hs|3_2?DkP90Nu)4>gfquV+P)H$KSFMB-It8QUWQ3!J~?f4K*qy
z3?&?(QIi73QclO?E-D3}jTfHXEGj;o&;JJqwA?P0dmY^TlaasG1Y`oH3UE!_e1ft0
z2Qz;wXagD86c*5w*l`yX@Hwb3;{+fFSc1dY5j2&-0J@cffq|9@D$X$;vrmkcG?4Qx
zn$#nFspbier1lJ-rnlfa64V|7hXa~@A5`!ZvoBH1g``lF^oc%R4qBAS;c?tW1u|NW
z=puIS0G&PO(QA4Zl)!pJR3N+QK=US`bCOHcyB#=SyF{&hR3u6@v5%EQS^|)rjUFI{
zCD)-I0(%a9d>OU9<Jo!L6Lc!xUr*S5aG*mre0xigi$2rW_7IOkNz&^F$8Ohx-Jmu}
z>wyw?!`o>44L!TTXH$A~>)ZrQzzKSQ))4-4{C}n8K&co=E9khv&VwG7r;DzDO?l1S
z9m_$B6x(@&f@&WcIw<w8N9PBR?s5$eYlBkB=K2DL5@C<#3J!)+Igic?(98rlZyFvz
zuhif}@5rqIxcLDdoj*L1Pqm&bQEB`I>V6iR!xBn2r$_frP`c{8=FxcwvZWuI8epvm
zJ8_IQ2TaOd9MpCMnFvcdU^`LLH){F;r*6m2@1Rp=VJRpL)Ryawm2mC+;|e|x4BXCW
zXKp=Es{Pu8i1n!Vz_x?yPq41@uHCK$u9iRe+uT4#L+<tS>ehJxngs)27tmZ=z)%ta
zIf=IU2SZ7&3;#CP5?|0c^57j+-L9ZIm6^X4R5~AbEdUjb9>-n5p$|E`<UM$(_<sP0
zPv?8stgz!Y#@A|R&YXeu<hl*uTdu(_blA!WJ|xQ3@SEXVaB^&C2DN<TL6^gTjt+3?
z{Gh_<z;U$1_H{luBq0P!{=v9#%mcb@0H(Rr1bIC+ET6W3PJBU&S(Gxg8UL1MG_9vp
zLF*(Qg1v<%bq1xxLz6`9x}ixjfOTRslMz(cgK9ajBxUK@6?b}eBO*P6+Y_PS6Ql(^
zJFkGZ!y=l>o}lXzP@Br;uN@)L2q#hElc@f)OXo{SBjN>r8zVSPLmLq~CwxH{*0F->
zd2ph(0-aL|UMc<Te}I8wb8P{0se>al34215FjUQdNag+x9H_755y=)BFVMo|HLK$>
z*Ahl>f_0>NuUvrWE&nLV6}4Zq6-TYU9h{<Iv)Ql+2mmc~BD*~F#+`nANKQZ3!RZHS
z-~hC47Jc}I^7<5<eq2-vTtPhvP~RTjM+Y653@Uy=mkoD&fEuAJ{4JmZ-9TI6KZ1tO
zK%?HE%Z?!jVO3}h=5!#d2JO^BQ!uQel2^miL{n4))ncF`9-I--v?{3Ktp1dcq+n?a
zM1w1F@Wei7-#~XKsDAC<4w`rH=sfSyc?dkX4pIokDD@?3`GS!?l&}meQ8|6w0v9l#
zg@d5Q{wycJy_&nA>qNU9K-D4>f9o4Y(CzgGppiTN7Fk9H2E%Xg(-O{r&Ku-0Z#h}w
z-{Au~!Ec+7Ib+Mo62lH314GbhgXT;vCrdOtd<=}hJm!{@C5jzB2F4!E$5=d?|2Y)x
z-v>IQ_qBjW^Et-XTprEmm|nAZG#_L3=;bl+Xg+AL3ncBK`Kj|d=Xr;3$N5WYLF;Q<
zCNeNE?6(IcS<UawkJvq$|Faj_dN6_xPCS6JpYRwX!!bt?W@0$z$jorek%i%yBP+u(
zM>d9Ij_eE`%?CjTcXE_o2OYF-2RcX#^}LH?j370P;O#q~U(0$lKl<Upc*?`_RGA=u
z_yN%QG@$*60v?tZi@qFl$fsFfi5ey6d>kd`LX?sdEl(^4RmY%l25^SKGQJENKl<j`
z`F{hWV_Q1|0|!IPff7H@-u)mZSP%G+574O&p!4}WdOiMwZnJajc4^~r?Cxh_;9!8<
zUc%$qEpol{SmU$*{Gj#l&saKnj2t`LK?<NIlpb<C2DX90w|BV&g8&2AN)V&vKuIKG
ztw5UqX#HI4fs(+q2@w1GKq8LaEp4C$v5wvSGN73{@KrHfp50TfOE7RSfNcgXgy=Qd
z2091@VmnBoXE)5i(v6PCSX3B5<IA{)oKW(&XXgix&L5uL9Vb9DfR+bKbwINjmIq7i
zJ&!kl#K6O@$3Y|m!Co+E*Rp3PWQ7e{95G5ji$awCg<~*iJ(eK52Xv7WrVZ%*KgX~D
z&(43I-E{&UNQ<&OkGp~Ur?9iRkGp}^4nRTy%Y-(xpo3B<;Q=b|JUc;&#k0E}#SYLB
zJi=bRHlSHV2GFiNaLR$4)8#JU*~#wOS<Zodehz98ltQtu+nob+o{E_x_-;AFOW^Z|
z%LQB*Pxy4RT=VD#o#D)L&8L&)7$|>tyK{6Ny!g_w`QU%hA%Ry3hZj<Rr|}JFHpvsz
z+d-^sf{d*@HrO-pw>YpffEJbUYr3c?fV%wP$u-b5=nDHlHxz*V3)-(>-~qXTnZFq{
z;^)y=qoM)I5al9R)q?kjGG5pTGQvaiV&^f=a}M8*@t2f?#@ky!>z4O{bbDxC16?iG
z{ExlJ98`QY9s*t93d)biK!rOa!!ZXYhGP!Q496T;7>+rxG8}VYV>spjDjyGUcr+gZ
zmyah)>^#2TMC+d)V_@)TJ^(5M8B4+C<HH}Io2M-g!pldHynqMj{H`4!SEhOJ=N(An
zuLte+0=fPe0|V$r6$Q}dK?CUFObvTKgYra)u499}eyO@+Lp@_bse)reJyTJsq+>%p
zbAG9iV?#Ylaw)fCLp`fLe~TCB+QVKS6^H#=3=9nW=75*&8~|;zg)9SWJy0qFIs-tJ
z;R6GMEkgqX1AmJcD+8!fE8zm!!r#Kq%D|Au{~qEt2T&9RfE)n|b_dib3V=rus3ir8
zA`eg?L!t;nEy!9AEKvl$Vy*>rnlyS8nINKQ0!i^>PbhxmJeuM0BLwp7gwOo-@Cf>h
z7C`|XAh&~JxH|`Qd_s;2<TOCTOFq5eOCDb{o^fihkzxRyTvhtjx7YW-N3YX=AIlRy
z{7#_Gice>X3I~4+C~bp}Tk;0AHb4jKNqP6OaDy)VZgvI<^|EOCSl-}oGXu9SJip)d
z0NrDE)uZ#eC%^mO9iYyj<1R3%`OEY80ni?KPt6aWnm-)B9bzug_pyA{dEJrU?XTvK
z<_F9k-)|tbPn`I-@yK=fm@<IQ!2+e!(zl+Vq0pwkppmuC?;hW;`&hp6;dg)Kqxs&W
zS47XF`4F>LFOQr@^Fe0AZxi^pxfuTKa54G|V*KlHG5QB${O@ov`p>_O#ju0L2;7vh
z{9bzXC3ujz^NTC!7=#!V2M^Ffbnszg{4H}qCzEvNsCa<8aQ&eAsq?-M^e`9jmA11%
zbx-qN(9kjie@iZC|Je7tAAA_W2Dr9-^X+^F$|4;6Epebr6hW8X`hx9x2|AR-r}G^6
zNakL*2cDe=JP*EL1x=%QH2(md-~1nRlr(?qD$x1Opi>S(TN%IK01ak*zwcrB!-L=b
zhsXEp9?j1mcr+h>06PA;*PRg*lFbMHduaYZIj_)(UxP*7iC@D<UVvZF#g>6z(8pH5
ziC@D-UI8o$I<L?cbY7vY0a(-lEDAcW&=z!Fp>05#6Mw#od;(aw;4^={i!JEHLR;vG
zg$Gzl=Ym{Y5&=50(6jS`C&-~MJig!Xv^?O*?|$I>h2{qd%?BPFe8Jj$0PM)`H(n#1
zzY8(`gA>07k386P(4Hn+2FMAA2N+B5ds=?vZ=Lz~|9_`rF1(;dZw)A>{+F0_i5s45
zxm2R)(fJQ4{WSd2_uzLq$G<I%5tM>jE|tCo-SXHQ$mqfEa{V=v;U%BWhsf$J89>M2
zm45f=b^Z@J8^Q9B2fy<L@J^Bv@w5s2+gQw74wUeAxETHi83;Pa;`K2XzW)q9oex0u
zQ}f~f4HgWbv&>3AgYE|Y{~F~y?S@)L29Mrc#?o(w2S79Js%Ygg=$t?HmXjsC9X_m}
zjLqm_d86o+Z|4^e#-ong7(r(Pfszq&;%rU+`~N>u3M*v>ou=6hUewxb0a_UgVS|ng
zf^@|V4|sIm0_AE3(0V!tkKPc_Sq?rb0*;`GYZh0-ldxmZLA#yXK+W{-5*7HBh#&_j
zfE=$6x+*~fRQIcTfU*N*hjjCg|0Sg!(5z6x?fL!Q2Omc8xr4A#3u{QlTB_{Pcm!1K
z5-}GGaV>6-;F9<0{N&U5@wFt(>TUyQ+Y3~;yz=RM>DhS$q8Ac0uwH17HgYc%+BiXN
zZ^4XgJy1e;eYG9R`EFRva}4(AcE@rsB|<T({f@z1>|J6O7fR*98_^->WwjhAk>}sW
z!q2}=1bh;P#f6eLh9@m9@J~M2%fi`w;6JEMhP7n`u?D66h15Q3exu;o`OUXGPXW5k
z#}j^13g{RL4xeOjCmK{u^nq@N1`QqyK$`=OT_P%=GPUL_gOzxx{BF?XOy@<Ydry|g
zfYQ8-6^}gV6#kNTpj_o+d9LRC%QfJH=c2;VP-6f(_7A+)3pyDB8uI7?9jbi$wE)EB
z5E5h;EMhwEfjR;n-8Kdm;-wlsy*38mBh*m(mo1k-=OK#dJ6eh8fbu2C{=<x*>4>eb
zHNfM;H3l58f*y2gS1_pThdKgufQIGiqHY%m-?ux@02(^3ttaceJ-Wfm2tZEqO+E+;
z0h#Ys!liOxS9D$kpa0%+vLpcHe;q3xZJ7PX7=0{{)m(fDnk0sr2c=vM--5Q)HXp%z
zofoLuhlLqv{t`BU017kERKDSDM41F~98JSZ8B|Y0!Ur_f0}5GKc!9fxpmSqkzH2?n
z-zN!Liw8Mf(y@z0#WVRPXo2=Ok8Yb!R_vupkgz)lKfe%ko+UK=^bz6bVR^6S?8}Sb
zOVoTo>BkV1e)fU+;B*SQ=o%Cp>p;r_-y)U4AUmNaYI=Zn+(S>0WCy1oBXH71O+N=f
z>4!z$(TYU|mVS>idRU$<+WImOY#;PIO~?@?EeA?PVbReHQP=xY6Ra*rMZl-CmH`?W
z;Nypi#5}vp(N2=|>8@q?;MnXg!06kp_wwCev<o(I=U)NO&VP=_+%gzIcL;QT^-PZA
z@Myiw-**p`%Q}5jI6S+>9J_eHIo0Nq6@RH3B&<(h_}7tt8;gz=3tD)ed^v@Ifx)q%
z#tanJpmgTh?WO=8kgA4cRM4GcAR9cp!vs9wnG<weskBe8jS<+omXjqq{M&f+9j$nf
z^JDuB56c@K?Kg_{zcz$qbSMcvuN09#OHIL+f-)vtOON3Jf-`^JE-D;8ofaDyUtfV5
z45d)Q6V(3&t=|TnuL<b|yF)w(x@f`G@QJJ8ThH!z0jK5~WdR2MmOY@=9gL5CyWKcE
zyZr<_558aqEr@Er!oa{#>I)j!Za%=s-*Oie0j(!WG(GtDo^ad=8msZV{Ls_#Ab;C^
zP>6!3*gP*k@U%Qo#PJfeOwzOSpik#_AJ~~nAhWyKJbD8eJv+k$I%H0C)SO`S=)C1|
z@RdME$O$G0Q=%i}1T%!G&=GQi1;W(m2syzDVH$LVoM7`f_}Zc)<^;QEx4Q!Pe4geb
z3Z9ln`J0qM`Lg*431@DegPpkvt#M&hYda%y)ruzB4Js}=5BheVz*;LqWWiF92ttV;
zkK^v(p$+i3iF<~}arXewMjw6+aGvKE2#??wm=9{9^M_pI*8p#t;19dPFBl%dF9=?-
z;c?u(0<0tCCV$u+enGHe*!YVFsBy#qn(6lFbeHfr?hd-7gW<S4c&72VyAG(giKk}8
z;$BdC0^NKDUjGknuYu}P3(rnI&(80@oo)h-$KAl=435X$Ag9Vh8bF}cuKX<^k3dTc
z$c{L08m<AIix#4y0czP9Aoj|DyXy@Kpz{ejK?kRIw}V#2f~=E(nbFPQ(G6b%-y3ED
zGJ)fNfP!bYn}El`2L_(pY#!i&nE(I(^Lr>B^z8KWfa$e%QL!kM0^LQ0eUJwl%SaIi
z2@cfpNa*Mwc$_#6wB>-|$A6@<8KmV{3p;3FlHphjJ0k-J1BhmV(#%jAG~x&nXNB_F
zpfo#(M(jTTk3@P{{s8SiIN;Iw6Ve{x7X*!k2zXc?Ec$XBJa`F;R*&QD93b7GoZ1VG
zsCEI+&}VNuXz=k^J7^S>VFiClILz75`y7t7u!E(JwXjQqhEI;QuuDN{X($aEqXfBE
z7Rr}{(()i0;og3bIUbe=!S03Ef5_*nA8!X61#;x^b_I}b5EJfR4bY(J@pc2K1ootg
zlAj#I0ziGugD;q&r=J=yFm&@Yx*C3KJz1*xx*F6z0$-iL<<Z@99uyF&|3Tg0UX}*X
z?%-}8MuXOqB_W+BKv#s?^Y3~nSA5<Btbr4BB2ztsDrnrr<KP1p4`vqr5)D}LVqox4
z=J04f$nLrC2PnV&XJqhHJm=H-5uAQrGrNLzB!2)8;}ROc#5;e3)V^(e16sK63A%jn
zKP*wh7O{4|_c-_-IS6ESx`G-HouE!WBmsajl839|C74$54o?@A09V7?oi{*Rd|D5b
zM0Dq<aCE+K?0g3*c^pbTK;w6gjnDr7|8MWp3EGs#<=MUFI4BrFqRb2o{=F*OKnHaA
zS>~uR@V9{MbL%cqHE?bHR>I}d`2lQB$)0YOogkwvUzAP-9RmSATh0J<6nE<!aCupy
zqTvEMNzJ9xMMVU19^40C{)5{=DFM0~p1&1zfSlofP@a$Y4?eLRw5LD9qq|iA)Zhgj
z(hE91U)HC0DOjMpM#aOY^BFioK*OFAphak)!FrF*UXTKp?kTOH!FtFMpIpA(OTZp;
z>AV0<B03Eo2cNR~_R8q^cIxQ(c9!S}I39P=ffjczI+*3%CeWI<UKSl#VP^qq=LUd6
zJ_6L+C;)N6N3T~H{`ct&QBm;d-2%Q;%%?L(#lf@l8q8lUU{Q~5cyXBE+1&;!4l`g;
zh*}(q=y)_A0vCx9{{s|!x<gbHKu7;MfGo8DZ8!iIkj$_Y3@RW`cy_wzc(`=CsED|L
zPC)@5#e$TPa#T1RJF^X3IxjVXt_Eo6eDQ&QqsUJF7Efjd2G^F8pkOrsEnSh|Z`}#H
zWM0PbEn0l=w|4&f|Nmt=_;mE!t+)AGt}!t%blw0b4F1-WOrZJD+sNZ9jgLXe4SX8Z
z3wUyCd<@FAKD{clky2YRBLjm|cZ{k5$k=*>u_b$67J?E!;~P*CYY74^rv-(!Yv)mT
zV#)-U0wpRDpqRJ~33t!V+aS+G_&|>W1}8N{1r?(b;nCd;N;)34pqkCK^96tFHE@*g
z2bFxtb45a+GbLe5>S|OtTsvRv0L?Rk#$UR-!DjRZ{`csd3}SXq=>{c4SJ<r4HIIYu
zxIDYJd<SK;&Wnu?L4Nn><>~Y|_>k45lZVf-b2_LT^`M?f%?JMRgSVm{1D)Os@no+D
zqemyit)Rm^I(wQWm>3vdvw1SU@$9_k-OI8KRD^<#_ijGQ;o5Sbqz>H6hn(%`%TQ7W
z$;gJcUn_y?MHoh2PXuZOH`g*Sl$e7KcYI3H;f}Qo45cR_Cp(rhl<t4c4_>nM!Gr&x
zE5i!LQU%}6$FPiI4O#17l8;=;8{UT0ry!dtIA0#LfNKR~=}t`RN+<es-tcHV0xGug
zjUTzTfDUUdDc=Peb$}ei8q86$3EbH*ybW@m2?+t?*<8)RP<ryUByu?Wc76sQ?FW)t
z2eBfXqjbqjumAu5LxRnd|DZF+3P%1GbI^vfx1d9`wTQL#H9xvtM;Sf4LB^GCfB78L
zfBp7y#UEHV5T*VGjlWuc;BPSkRRf?J%LO!A4>>N`0JL!dROvAL^zs;b9(>8{(|O3V
zm!-+Sm#51^^HZ6oZ|7;x=EHw{7(wS(GyC?6ba^%(`s2}j;E(6=1E6Xd+zq+$nh(^m
z@$VIBas>BOd@N6tO1%Va)&-?WuU?i0kerX@3I3K^P<N)A3pBUY3cCKbn*%y`+R4>=
zvefwXr88$5A419}(3$vL9?)EhnnyhtMfkdX_&`mIg`MXbpD{2nIFwFrJy~(M5w!iR
z0h$b9-HqK+ph6Hb?~2*xK~uaLNimw#QYp|fx`U7!4|T9`nG|x52IOrxMv9LvaKq7t
zq144Ocmrb_nAdWkga>L5*kDKr%1|l+72F33XRr)pjD!(FF*rthK-zUa#xg2C*5KKk
z5~ed}4hKLKFnV<Ugym19Ay1FaQ((iu1lWy8?t`805C9$^_~zO9-?#OD39o1Kzwc!V
zh6i452KC}Efjgehz-=#-z2Q3@54_%EwIL_Vx7+=Pr{xL$R?snFp3TQNJe!aI056~K
zV_;x_2Z95oK>!UQ#~q+9pHJsApUz*f79x1iVI!#V+YFli#J#};mm8?=O6avQFvr4O
z3W+VyZTI}G{{R2~_v!rp!V)wbgqpzeq+tsLJUcIXc76a|vLWaJ$%TfOJimYNu{=@4
z@5{gb1ZX0u^Axz%8-OJN_;eof>4cni07(NV@$Uhf1^?A@pu`X~)osA9>7(MnuNk5e
zz^@sjlEAN-qEf)Gxdz;V;@1S7Tn4&tVUG&vzy_aA9~BLsPS6B-r;iG_87kn>3A$Pr
z(rpDDsR>%p=F#~8!~`AF;n9mYtQ^$6_5jBws1XQK0Xnw_bgKb~-p>dcP3gS$qG}>&
z)(4z>JYW+ElF*3+ocSB#S@iL9@Op_0;Cl#vdbFM_5rqe-$M=sumLK?=Kn02q|N4)h
zX`=5woyWlDfRopH&;=TuA2|<xJIG&B;oJI+zXdct?b%!Q-=*^-Xto}7H03|`A~TQ9
zb3U5iJUS17+WW_t7>+qHG8}UP(aa3ToLCr+Ik7Svb7EsS<^-CrKLlUTbh5+`%X}~s
z18A)S=t$zy&#!eoo1gvgWIX0+d8|y4Km344=RvgoGPFPIWBIY@3pmqa=`dkQCmx-r
zV3`T*WpG&mB2dx`X#4^+9_HEk4|WDcuZzlmpVkNbt)MvbVEo|u{f?*N5zlTu$YAd&
z56we9mXB(4d?432`F7WW=I~3A&aChRowZ)e;Mwc`->3CQX*TFY$?x|)6^}#n5GX33
zm(6#&ad>nd^kMwz*~teRv~9gq!tc>}+^6&3|4T4yH4pk&KCChFWIW>AnZ`kIDHhnr
zU;<jkz^am!(ir7D*6;`paO}JSUMK@Qi{7W(8g$^Z0ODv4Pmmj}VZN;PVSM2U_T_%i
zcmsH{d?%9tXt5)x25>bz>C^cS;v~@YS}c4Fc_*l?%upiZ)A<Y3I0N_Gd>DUu9DF6>
zVLcHfS?mjncX$&Ce-;5-0VcXRT=};hf%+W0u?RA|2MrRi8ZZG$6$p$J9v;2!|2<lN
zl)|@VTmJCicRKFT3C_Fd6&HM41k}oX8!!VKJ^y-iLMB+E(GA1u9>-v4?aDv(0A?sa
zwII3QF&I)hGvZW??jBOjcjzGKerRwT9sn2VXU+t8c7F8i`~|6?S`L(YxwafAb%i<<
zk&!!jRNy*&J1_WjUIfP#R16lxoHEGi87c`@2qr*5f)XA``Q7vQaZtjX;M`DS$H?H@
zThCbf1)ir<!7KY%R9X&{fG(#48|DMOmc_L@mjh|OeLrX|ui*ig&UfIM+Mi&x%|HH^
zazR)YEG2iqi}rBmT97m07{$H8h9?_r_#qSe-#m^V0=d|u*Ae;tMvvx${~Kz=K$G%8
zjHMqzw?wiS9(e5!T2AV2c)+vshpXX9zg`i3SHs(&^4pnzn~a2$m5f}es3)k=Z+W@s
z&1*@x^=CYr4>E$5Zg^UrEIaX<!>9AYYi5tmAJMqd5Q=-D)z53B^$-m;>>#%}FqVGB
zY6PnO*8e4XUHpazT27WodUXDJ&3LBaCuse{A^vS%;5D!<Cqe5U4uF;?c<{R%Coma|
zp1z?*D<H)m|Gtx!A3;X(Z}VsLXg<!^a<cR_R+mD;2*tgy^yJa}26ik9XgEg$vJ4Me
zrGR!(+A#39fTj&V1N)jN2h=^^$G`$@8-d141VBr>SQr@io6m!qe~mRN9H8!fxsXRE
zhDy*KP@r{PpetmMmfqEXx+g85Zsk6ZR-~nOHqdolfByf6kH3<%zKi1ZcPtDHi1l{@
z9^EV|;N^GVHAbNNg#}cfLhDJ7&gY;t4)CU?2k3YxNV5{US;VK?Mg`QwHvlc;-~cV-
zP(v!{LG_HEXY(F#Q;z}rIt~{VjZ!&}<|78Ub0>1C;@Mrw0Of<623ncn+xY{W(V@by
zk_p%H3)J}n$1sn^H=x6UJv%>ncK)MYqZQF!1uakU?RFFJ?DmrYP2M%n2c;|21}x}2
zV^DJy(tri6wMA~gdUm@>cy`-)Fdld8E)&o^2D&8-)Hw3#yae{SXEz(ja8N-6%C9vX
zp#1L1So+no(@z3qwU6b&Vi#D^ZVkE2r_|e{@d(K0*p8$^3rkKFSO$T_J}iv+(Zs>7
z0reXp%0P>R&OvJ(NZtjJNck7EQxUWs1$6a$7e~v<k_ykx13s1q_?tj|`-Y#=rG5<+
zjM1fT9=!pK8>J!RK`kdsg!s2{f!eSQKXXezcr^cFES2<VKEMQOATyq6u!5{c{N7OY
zpP@vvi_4?)Ld(h06|dzsO8ZzIC}DQ&-~g4cT^@{})qpK0OM724dv+dh1Z4!YzA#3U
z!bS!(=mF`%gFJ&?zVYwlci`W5&GJ-<S?4*A&L6KC&p5PvD-q=1R{*xn@>A)1kJbaF
z(%=%7A5<S8mCqiG$2~fK;3@k+Rw9KTw7(td7~<J^4ZKqq+N?c(6jV_`!ppg#Mh8^C
z<}#Lk@$9W-gs-gzFGOqwjpu+a9+&X$<<ar5Ji*@#x~&-8D1PZ<`LL`6)Np+7p?Th;
z`S^dwZ%3I+6kIyrfo?edeh<9<1bp{vhX@C#LjhWO1G?knKQn)mHX{QA$bT?-NB(Ug
zJd7P79E@NVQ%48~6PU%^5yAnz=j3eZ#h0LkzdoHWA!nusKJe%S4Y#s_O!jF01zOB_
z$>G~EX8u;tG1AZj)<Kt`Kk#Ti^uXibE7smB#^&eDAlG_mUN^in!I58pMFe!+u?XmT
zWdVLc9|7?7$|B(Fl|?|y6$L=c6$QZ8D~mXQm4cQl3V@a?3V^Ry76D(cECRY-Spc+H
zQJ}!1`Bj5QGw3{gkZVdTJem&)fWsxB`PhSl?^v6Ufp3BSeh*~7iwNkxWgZcJK^Fng
zb;|-C&4(b@Ek6QX_1-%BA80Wmiw1*dC%Z3bnLEy-sL<0Jxc~Xjv)c}O_A`Gt=$uM7
z9?xDk8ApCWwiWy(3696yWEdQexygbEIS?TaA{0P`B8X4|5y~J!1w^QV2sIF)4k9!_
zgeHj40ukCELWco-Np0(aQqR|kp1poLpjkyB{_q2@8P6ckCpsQ;LnxJdZ3arekmC*9
z44^KC8dM_X*<EMh(arDK>1W~5db0F}=W#dCh&;pVbD-V_wo(dY8rpsbr1`k!Hv%r5
zr+qt*clxOCc!G{T`s&&F2V6vX9zTZ2A5IN5rl9;$2F@RK$ob<NKjctz&=o)up1nMJ
z;QUboF24_gjw-f%Syl+jAD=ulPk}Cb?7Z*z?HF^3oJ;37XbxdK!@n(tm!U%jC4c;4
z?)=T)1iBpqv>r5sm!U(1gMV8HFF1RE7~tFiVjyLXbEQ{af_6vvbbch5IY28eUxGS<
zKAoW3h;U^NQ2yi>a1mwT7w{29WDk&#0!RocbAZGgKw?N)10<FJ62q1;mV+~f9VBCX
zYkr2FF<wLGw?T${02u<hjT|j|JO<t4)j9`~Jq#E;J6Tk~=X-X$sPKS}A(C+HVt4Ft
zQIT=%a%TiFWF5QQnLrFV$1Znf5JTRv%bf+pP;l&WX9Y179lPAwKnx|vE_bkYWydae
z4v>h7W0yN8h@tA(<<13Ss5y4IbAuS_j$Q6NAclrxmpd<rq3PJ=&Ie*>Id-}8gBaS5
z9Wg38gq8|Hk}aG>DbG>UFK9T7!=>}6W9J!<&dcE8fdBhJEdzKN?%8=1y#4o^N9Qe<
z&WDbjFMPUvpl3yRHrE?4cpi5J4F@okXn1zJJNR^J_;%(ycy_xRfa*TaPIm*>mM0}j
zo|f?f#WJ3q@dB^KKni?2^DV$b@lX||_lWltihn%1-7P>jBg%od!h`+nVOhXY&gNlR
zAW+T&n)YlxQ2NI3z-y)rIC{xQ=E0gU%{xHD5)36W9-TiyV;11WIUbBZJr2GU@v!ay
zNfzT?Pzx>szy#PmNalmq&w_^*JYY6(dwjqD!GjTBCmTgStUnU$0UFL*%gDgcV8_7U
zvV@U=0dx)VfBu&FATj&6Qa;Dc;NDIt$ICA86_vLQFL`$UO`G7zzs;AS;ip!qfUDu{
zO^l!=RHd(9f{sl9-Q*6sCALeh;in3J3+Q~AmfQR-?u-l!ou_;|Uqb5p7RY_<fsCMz
zWWz75(s!Wc4kvv(UqIzgmZ&-MZ}R|mG8=xXl)eMqcrNX0dBUgjyeGfY58u`Up8PI9
zUyHaJ9`J2FS^Ctc^El|Rgci`Mvt#TGjvE;bZzIKL=S`2^NX7;mK8DiIp!&9<Mw9{4
z1pDICTlC+@@?$ZptKp^B0iK|;=oe#&yNBjw&(80zhEM!@Mbr#WBG!_EA_UZ4;CHkN
z;bkc02DK?b1COs?3xjSX@@ziN=m?&C^0d5DcF6D~sQhwlsNn_K=gC<5#kJ*R3HK%y
zAIsw<Oq;Yi#C=;Ym1sMDJIq+Z>S_6@RKc^?gbQ?2o2%h%(2+{ux$oBku7)QK|G(4#
zO{{^_A)b-0mfQSO4z^t4pL&4f#Ov!I=c4u}Anm_nmM2O@UQ2+b&+zYqbZae7l(4m&
zEd5~kAAcJUB|SmsXz(=&QPhLeUx-KJn;D=r7l=;C1P~XTqn*IDmy3$PaToA)O^{2i
zJ6%*{K>M5oKr8t*JbHapIQD_YRa^}ZxIzzb2leKZKwS?|5=84DNPs4GAQNO=;LHeG
zgbD2>7#={4Uo7JZpg{!CVRyYAjL>~Wp8PJSJ$fDA!+N5Su_DO+y=Kq_pr8$B#~B-J
z1R*Kyl~1qNe;>=6{4JpIcK)^%p!4NGi-FI8=Knz(j+8ulSp-3C5AZ&tTt)^4uU-}@
zkbsBfLH_0#(2~Ocpy^J{AD+zz{yBa-$Xuf4(s>SAk8?sI^URqu{M%S8ojO?LK|>Xw
zR%z)w&~~DtG<bammFM5)V#(;#;UdonVljbOOdu9Bhy`k&vUpnlEWP+z*T?c^v4(H!
z$vS0^-lBh=%|8W-gOSHawy_vGb+E{R(rx7@r(-Ts|6xmfL9-X2nB{Lx0>y9R5m2n-
z+L!9r%OVBxnNQ~d56ugp{*sU7f%1huy)1&5!d*zARVIiWQcXGk|Nr;xJmJ~=;Dcwc
z!v~MfV;%?JvH0|Yw#WQ1;BN-q-Q#NbAG9$Ga{KN}&{?NGo#(;Zi+bI$Y)|?I+VI2Q
z3R-FY611TXGzHcC?14w~u?HRp-?8?(fw%d9_ac2T{DwY1A;4nDFW_S+;KZ-VBIm@f
z=_3ca@5&I=fH5?1;@5PMQvi#C?z=JsHDL?`z@iRdQP6!?hM-1_VF6e)0W4bJ(fqE#
zqxk?!=>m}3K<)cu0xq2=Ft;8};1_T){J<~3V+hv%!HHiJv~}#50;qxo-GTL!zr`K2
z#Ad<Y|NmWj%NQM-pD}wjAN%jA`OVevf7%4EUK2}x0T-k9-n}f={DLk_??Jr#Al7{l
z>pX~c9>m%YV(s^AK7PQn`4~&-G0*S!L7`mY>Dqb5vH6LCWAl*@jtAecI5r<)bZmaY
z44OIVJmstT%eV8MujW6)Z{Yr#XD^EpzkmzVd(U1LGmwezJ(`bw02QyLPkb#8^0$Dt
zMtL+p|KM@_7-*lJhvq*I#%nK2|Nj3E&Gm@76O<`%mp_m}I9R3K*`fkUs~!YOAy>mE
zL=;4tp3VOy_JN8WPkyKGh*AkWdjT35g4_w?ll%Z?y*0%8QYFxdf%tO@sy8wG2k{m-
z5J3AN!Q~xNesyZF;er%OUqN#-9=%@wJuDA;@H-s@A8-#@t9^jKg%^}%!Pg{t_VO_L
zSbpSh15Isu_VTd#Sf1o>+YKsHzj=PY58euS-J|oOC%^mo{oqZI;MpBV%~Qx*Ay0tQ
zf{Ksjug;5({BGwp&x5+b-|vI=Kk_+t@R)%LD^Q^Y+yB@D>iTzn@ce$k$MTmCzxyv=
z%^#k<B4(idk3Nj&KxZ(3(kK5mAG^ODK30E0jDH<IR{ubZ{~bP7|M|D^*mdw&f%?Iq
z8=kMe1l<d0c;KZuXthY^G01*IzXzV3ClLD)e}cO3(EW((LHiN^fGebn9^Y?*u9X7q
zNBrr*@BR~gKcYWl^Fz=m!G90UpBVcQ`9Yfr`2`&L1zGGsH{RI^fVLj;gEu7d8-OmS
zvjg9GX9wPr$PeC<$R7X}2j6;U7XVfd-jm2*02WUGn*-gHc#x%Z2DlsuLf(}4)8qS1
zPs<aI{O%{dUu=Gu(0uU0!I!Mf2f;4=e)BaeD0`d%n+)EL$PYFcd`q4kWIN(P#?l8K
zmLK?AMgRT(?|6)bjRE`OXRtv~0!w-Xt+arp^VS0;agZ_C{}+(Nys(IwVG&cpBE|<1
zgE;N~0|<?C!VJ}Y;PV8K+!5&0`5nb!pgn;o0{ZAG<j@6pK{u;{4*iUCjQ;-s|L6eP
z_`pWSHgJ9g4ZrbE!8(bD;(pK;%m4f>%Rp%q)S{mYT0#I>H{;O^?iDbU*uq)%aFz$0
z6=-+>#x6~QHi>qCIvG1b?W@<$;NlQ8hH&V$IZPU~fdjl&@3jg{2$b!?8#`VL!h}Hj
zcY?${I;}hoK4kIgEMerpY$+o72R7&1da_g;I`fGhjTj@IZnB8QPv8`YWFBPv5j6LL
zy8l1}>nsZcBc!bfpJicSWZ-WGpL7bIW%<v*0G(w)RSBDAVPIrHKH#9t1GF9uGzz%y
zKj`vb!~q9p&{-CS|Nmbzo}usj3IijS`4w0z7BZjm30!r6re3-@8h&z>YQN?O?XU;!
z<k<!mkOGYmzj-YV4(>Cct{SK<(eRV2<XOwf()X}Q7c=;ziw-1%g3Sdr)8XrO;N4hk
zTWCR3FQ5$<2G}z+axDnUz(@<hz>}>XNu7Mb7{A1vct=TJ&{T?<sv%(mB2m;M#!oyu
z&v|xUg$#;&_QwAAX?@M#3R+_X-BJo#7YZ7gF!Ql|QS9Q&_{Q+R;U)A16VTP^?KeCW
zL3_s_qv9T#H(whdmSK2wx-$4!z9`y*$AHd*;E~;Q4&Tml0guiT@E&F?rq7_^4$bBJ
zw#p*Uuw#T@xMP@O2<V72_zVEZQ=*2Kb_yY{{qX2K{#ppP1Cd<^Dp;ZG^3V$hP;jI6
zcfm;xmO4O}-+)SFOh17&LJ9N<A((FPh6na8whniWW9<T<ol&4tM6g{&0d!|ayMzL$
zlfNHCfhTO?#y~UI{s~MIm<%t$g`u{gmH*)J@^8Ma-%9lNfi!?t%YnwnK)J>g?h@$m
z63+*ZMo>x3Q1CbZFRp3^rU{-kc7e>@2_g&+_;!APgb-vx3>K$2=O#gpMoG`0{yb#d
z4>Zkc2y!@jW;cSl09$6qk+q=%18_HkTFm6krDD1lRNsHw4_Y-3AEWf?G&tVC0jkqL
zwJ0cgVOc>2G6{k`IzNE!SUe7kN!0KFnSTxHW5^Cy2@lZjGE}dC108(yt!F2jCrQT@
zp{DQ7j|X3JH9iAR<7XZNZzpGVIWK@Og`>FF)$o94@&S+TkmCYi=YST41bbM1D(CU&
z?PA!##Nc81v0TrqJLI?oNXi0Tir=&O0Fz_m56}{YqOGqb9Ged?Iv#w$<)I0h6=TXg
z*1T_lz6&GPh72S)QT+o-PmuL?phH=Gd$)oz8fargD~JJEZ3F2#d3LvIfU;ccfs%C3
z?p{#7bLmcL1g+lw@7W2Kb8P&>$RNN_T!|DP%taEO-R=S&Nb%v)`3M{zj>p&-Tsj}%
zp6K^YUTUDgz~I^Vhk-$WfggM*I_M@FW(I~5Gsj*R6-LL-R*(v)#YOEdoe$B9%NjY*
ziZ_scu${2N0Tk4RklAv_?p}}?ou>}|l0W!LjPcaLUtAu^r#w4d&I-78gI$2dF8(HQ
z(9KMJXx5d&t@G)GoR5kc-iZ3hqxnq$WDp-Iw3s|PZB&ZX!22V+4fwa6bm<1?6sRqr
z33TWw8{IZ4zTI^k;Em7S&Kw?=7fKb83}WVQk^!wk={ACDefbTvfhM^Nl<z#6e>(Cv
zgXEj7|ARI<ag<8J&NT-$#yC8>ZB#m$yTOWk9T_{Dz`BxOb~AUnyy9p8U8*4J+06!O
zhYKJyxV+-&2CHoT!3bZX2g;Mo{7wDL44^4Oq;&8yl^L}9y+#Ez<kotCzt0lnz|I&I
zfo|r`g9l%7d35`n7l3T-$~*whX`MbQ4xrUM79NZzKw~i=wgG4_{{aw70oK3jc6r6&
z)?M?82Wm_X+?X36V|;p5v^OxexyXW!r4xjm5eN51w~H)C^A8UGmQW@J2A9qn&^V}x
zwny_Zj@AQp7QUbpntfCRx;cG%O|(6mkIA?i{zo0pbhPyQP@>@2e4Np<`Iv~K<?))g
zujO0~|GQY*@wf0ZGBCXS4eAbeyQmm+GdNnheJK_6?K}pS1)aG05_HxgXpOUmW2f7f
zZYIZ0w;$c08LdvYKR%s@J-V4aI`97%aO`A*NB2fXk4_&Ih2|g3MX?^;&Y(aBtuwpl
z(XFGBHo+tLgh#i}Spo1BQlK@-VLp}*LFLU(P$uxPd|qzg(d~0o0wiUPE+qsS7qkVJ
zHrrpzdUoD>t=oKn@!$h4pUy|1InINxm@+Sc${fZ+pnYos-5jWg9)nU6G-yjyG(etg
z{ma0>fV>{fvDclklg%^vIOy^Yfo@KZUY!QVPM<YAAOk@`)akND02B@`Yd{Bf$vAep
ztdW4FJ`hI+OF-~9^@0X^AvJ;F0Z>T5#$z$UBM{xw+VJo&Lzm)34i5?Pf&#qw5HyVg
z%`FH1d&~fBi0^Uw`~Uwp7Zn9Ya7dJBg95<8qq{`KqPfO^gP}wU#P;xLJ`#Z3UIf>R
z@E`ys0##`F0nPfL4ktD(Xy%|d?x4D1ZInK6$p)H%2N$H!$^^ariC(^e4uJq2@Am`h
zKu|{Y@a$~^Z9HAUUy=;o+x+1_N_sff!qy31sC=x2tqaEJhB10zj9wU{560++F(!Z*
z;C;@UUdwp)_JNE8tw<2y4?i#gc|8IsggLqyzy*b8cg_h|c>^sdbl?RAXb*xw2`_BP
zsZY0yia>LXEC)lKvqvwBHpni|-ae4q3@^DFK0)?RcZq;VXNe$a3|fGNUl269euU8@
z*}$Xukcg+{mzw*a>9{A3pmUg9Tc7avZ3fT&opjs{8f<;dc*eE2M&&;!d-TdQxOT6Z
z2eQPmd(AwMCmp+6=FMReVCZyFaq#SJnKy+=fB_W57QU8uOT|Fv7J`mdZ~b4t>m_JH
z0~~424SV!J!Ou{_3zeMv(w-4i*1b3g+Q3<IK)|K*1+?J(0Vy#>>^3mAvDmd7D6s}@
zl$7x4ybhX+HUMpk)c_S%3gAQm+K(y$N~8)9*Ml~-YJeu74Zs0rnPbNSxi`%DSPR$<
zjLkK6pj${m1Am^qEb}~ALB8`$J_*`A>DsxbuZJms(Xn$)-vkide2}p_M8(0eb4uSF
zrT|7zxnkkjIi+t3Qvl;}22gN;dk79J;AnNR*5GdeO(A&nve<zlsM&&{&dsBj$Iheq
zAdgGuBk1^duZ@vM@_&zBoBiFH0*;+)_JIPFUx3k(U$A8#$T{F~(qs#d=7S<0mj7zb
zJ2HN8?R@TdjETXu^N(xmfBybR(Eb`|8`|1M#e=^UblWL<Mn%tHuAO|KLw$-}I!}1^
z`l)#KP6PQ0V?M*9^;_q6M}C)|&By<HB>(Tu`r*-;`2^%%$L>A*Kmp{@S^1{B>VrpT
z<rl|>3JwO)IuC{t=I*LLot1yOtvW5iK4?Cu07`NmmLE#jI38>3U}9ik1bG6MGr<mT
zaR(jB0qLE9qZF;bgp$7nTsx0;o(6X`zk`wm?AlPrZWa~LDVu80mLLDN)2{s6j=FSr
zfZGue)4^Q~uoa%&`Jly+93GZ0OLZZ7nTv!xkXLqs)q&==L9;=Q&2B7=FBgJ351^B&
zuQD(&wA?PSz@yW#+m8h_I@Aif*w^v68w+UX56E$zoo*biEpJQ0J(7FDZUeWBK#}Lz
zZ1*2@3MEIW2>9+`$W{r*PPT5aLQt!y6|5uqreil-r^{Uq(5hk%h7ul6&`neS{|j`w
z+~py(N&>Bny(x#>w?~t_D~A|(Lz8-dTj~Wyv5nFnLA3v`dv<<<F1L5=c4Yv?pAxhl
z!O{+eUEk>2ohIPf?atw2`JmJTqK~;q2z+lWESkY_=h*Dd^1rkOra}~IGSnZ?)x)09
z!&V%-*+Kp949D&s6;K#AAN*h82x{s2Bp>wZ6*&Yte$=J&I5huSvV1Dx0ZoQ>{$%`E
z`SG>5cQ4Bk?{1$X93GuMA2=MFTfm0=$KB6>x&l_y{gY#00G~?Y2=1bR-48A~Ap}bJ
zA@T$4ZWP#Aub_r6Q;{U-eqvCA3~C1`)kDr7g?N&`B^osA0@}>qJrV5JL;oubJd!_o
z^xAy%Xg<!7Ho=m;gtz(7e~;$lKUyzUeta$D(e3h)!=sbExe=t{zhgH$xc>6(&N&CG
zzg~cfZQsr}o{VocGlIHvF1n!BE_~~RW3!7c3!~$47hTX+M+R_<#IbE2xX*XHgvYaY
zABYL|xo7V_P+!ltyG;Sq7whf=^#VN)zF-2aU2X?umC|JR!9$0@nes%5J?6nf;H(E8
z+=d=JBnJ%=Sg?bppI|p&dV-E4ItQ^IYGZdB$Qh6$iKc<v;MgVJA=2U470%cZ(!uE1
z70%QV(!u1|70%od(!uO_tPSJ^2IQ6!dI5~)0BW2rgx((N<ZC@ySM1n%!lSnjRJwcg
zhN*zoz98+#@NK>1(s{v=-{nB_f&V_qC%PSfcyu~F@$O~m>~3j;l<!V&x*b1wbUJ+j
z^}QTHfeyOXuG{mEOQ+YLZpKa~&*np*Q)Wa!3rT$~FO;r=74U?{Q@h<b8g_u{0)`Ua
zV+~-2N4FaXXaxq2K@F7j4=O((<5BSa3*h}X`#{4x;Kc3&J!1uR2hJ_*15uzHhG9Nv
zd?Gl&7j*ITdGJQ!ubsb<=2yY?86N1o=hOKL*6Hp%*!=T<sVq1FHCwQh+y)JlLH7T2
zGdOm#86J4eyMYljgvREPeA2U%A2gZ=PbxS(4sslN{DS-sav!)7{Nma97qndhl;PMR
zV<(XH*RW<IXs6NysC&WtlOACYojZ=8WmWhV{X*RWqA<e?bpHB3&u%vUZ5$rpi@-q5
zJI8J}j^+dZn}0CzH*E!-l`jICPll|~@qtf^`&cTJazR@JKHUnA-DMoj|NfVV`dTgn
zWv7z5{h)iiq2)DHop0|x9svdh&t5;Ch6)3Q5+!Jk_JPccflo>XC58XK&>@l6l28@M
zQV+n9wGUJ?BlcrDcDiwZssd%-PO$x;Xu`Fg#iti^MhOEXe8K5&CultY$Y#iR6KV>)
z0o}bd!LebF7%ymx1^CS3kNd$X_oORGAEeR;I}EL?&<34504~kIvY>c?;m)7XFzP%9
z?wX;*4|G2?RrZxY8=RexqfhZ}fd&NxXq_l%PYGzJ2xx%>hz2_zHVbIo1HSmPl=!XB
zU@xQi50oD;?;^kM*$L|aHtYbc=VvG}c5JZFFV%Hys9-E8RdZ~pU@9t=cWkI&&M%d4
zY^Y#KE){eHA64MkPyss58?;Qq@IdoF#+{683=I6PCz}5;?P6jAF)!{14a)D_09vti
z0JfvrvGbT?^S}T6E&ZUFYW~N>-#?3if#H~o3M+_U0}<@t{Rp1P-;TMMurlt~L}Unv
zZswZD4K*sP3?+P!82tuK_YE~FYz!rWU_nTNg=C|K8Wnbi5;KT6I2l32q4~rEbhmGb
z>T3sx$3UeIqDW##R#YnM(g`|@N&tH)2~CUO$U|$NgTmhtl>b3X0Ki+wpM$Do$i9Ba
zdQZoO8aB{|AP2_MFCMmY`9WLTKt}m?tAh$I)IFAt-Q^sh<yJqK%Tt?wFqR}Z9(U*X
z|NsAg#|FFN(wt4j;5^{b3!X%WnBQ`#!~nErlg&zm1GFo!<Q=N2mP;i?sPeB>K&FCn
z{%dn^;6cL~Bnq>uWQu3=aUP6v16F>5TQK-a2as8yD0zL=k$<0=BmcfIMo0dAeoU_X
z``nma`S<y;xbp7{V|C@<7suwxzpsqlqxlW&oJ`OzEC$Cg$6&`GP(Xq1Ie_$cG1EVy
zJqS9557bB2@a#Mb>Ks{sy2%0_$3f*M18C4y!s9r|LGTsX8yG=@3<}_twHHBSp^*LT
zKHa4ZzOCO-_p=}K=`3Xc^>P(FEsy!|JAd%$%uz7_2?+RfTYyqlD!e`hiAs2MYk)4x
z^9L=dK|W*r7}z3E{$YTxan|zqe)oe1<e2f-vS)l5zk!T^*#u%kEh$|BDyhFi$J8M~
z18T{7bTWceN%(XcfR3oGQLzAZ)iuBh96OIVHvjq0-?9L7;uCZ+Iyj+%ZmaZYu2BJ<
z^$9xY!|?5K7Zo1RWE|@Fs!!)<56#yg3j{ovHPR-4S3rUG`#$sNeC5%36KoCW0QJ^I
zuq)F+O#sN5%%CH<d{i_b4ixa|)&N~cZ3{9?0vd1zKH&QV;ij~tg4Sh0%UYx<wfi4@
zAj`m^Db@vgbQw59_;lx}7<3+Nc*xG*S_5w2=Q4O&zT<DV|NsC0%PK|&25`~=6CTMY
zJehqNJUe|ES`Y9~IRLtqQGtKTL5_pqbhi_fVEA1RZe%QF>Go0K0qtG^n_RN$r6R~6
zSSY;&or`<s%o(I`V*yz}e0YIQ*n#-lf~DjJC{TzCA<&8au;PpK5GsxH?1qL;AZSV@
z9^_~wOm_IJfRslKKiNuEk=u))00pNPuwOx2M;H#MF!66Y0NQ%U_xC@jjZ_-2f$_B;
zI0!ttH9)I=-j>*dhGiu@x+Osel^c10ZvKPZJqSu{Euh*3BM>~k-~Qmi2tG>(JPPXo
zZ)0Mc=!YgUq^UCS2{b=_J70jE3N80xg&^vzG0bix-QfK2(zo-+>jPM2Z+Udy^z3}`
zdJ$4+W2;ZV_r>FGe}k4B4OIIZrMy)DukpC<(fQW{dO^)*P#d4W<pwAVcbcd`_kVkK
z%cyv?-YykKTC~xA19XC2`wh=d8PIvfpfUimE~oQo^WXpcEtA1U#HdL4be4dQRsP}e
z{Q_vDm4iS0fUDtK-_AFXsg7^~Ps=OC(w?1HeLLUzYChv{*8xrW%w~dTdH-G$6;Q&G
z@Ui^h!|(pV*Ycll=U-obr*}S<ulSqaf>xAS=5rJa!_FWEox;*>qvFvWF5uD4?!kBg
zv>Q_MV&^%|W1yQ|_*-Uzs(8@iC-4D9uvNO(d@cX^bbj{acfarP{j!JVJ<tg<p!;6j
zJ-=TA4bpP>Sbp>2cmL+Y_zAQ?s`(Hjcs(#l>!X~ooF~J;09u{|+Nx3d`L!a_{UV}Z
z^O48jLHjj)I`ajfVbxXwx<JwLFMoR{c#2Hkhw(A2eD8ec(RmA2-GiF);@~_1D%$V9
z1nsGYC1Q`{8@|0dGOY*r!w-~j`da?wZ;Jc(|39>thE{&C$N~rXH&~Dhz=9kmjXk_q
z!@_$nXpX73^gq&$ej^{vN1)KuyhTztmU(=?30?FB4Y(B0od^P;qJ|Uf(QbxLX2aX4
zzIe?9It&za(J$U|1#!a*KX`x~6hDyrcR*pknep{*w33BI0W>xH5J$Pg3YG<xD`1DA
zwEvOvW8<3#pm2f~YMm`Apv~o;o&TZhtw_JohZ~e8dVN$PaNg*{-wJB&cDtxVs3LCl
zX$9S_>Tw*h1Dff~8OMeieNg)swEx)ydH=I#=P~dVu_>T75oimvjAt*4zNh6e{^p;c
z6w>*@gYktA=weyWiP@mJ_?I4<2SK~+9YEWlwK`ulKVrtbFV2yFn+&^ShYTAeR~%w2
zee2QulbOHi59oA8#xtO^=Gh%Pc-TPq;juG1cKEP?c0~KIGl7_(Ezv&g%pfK+c+T7M
zXzAIP2SKF~G-SIOz^6xnwv_pFD}awhn*j=`<^vqAhTqaAI5ya*1e9umhNl@FOBF#h
zQwZqNq#6}wk5WMppT)Ms3*KJz=>~08;P7pIQhMZNEXbnH7aq+I9(eS6Jn-l|1=>;#
z+H3F8{4;^S8FW^s;mL1@nE6{Dg3390P^+%_2rGY!2*?e`58MY;=_vP=I5yO<D>8t3
z2Blv>$x+iq1>4<9;KCJ}z(Q0wKrP4s-`*$%&~Y3BpgxNP$Z3r=Dv+C&<UyMRAU7@f
zblwK*^X$A0nt+061(moCST0@SZ`lfRD5&&2&d9)ke({nqC@(|q#v&y@^S6N7c<6ch
zWh!`T?;ET#wua;h{uUmP6CmT|V3&J9x4SnVeBg2LC2MaXBWTxA^RfRPn&%8pqV0D9
z?Puo)ZBmD<cjp7GQ|ANkXy*s-XoswK=L4^I=L7F)=Lhd;hpcz!1Fv`I1Mh0*2k&Z!
ztas-FuXpDw@MwP7-~rlQG6Qt6lCwwiK><)YPiQ{$;NUCP=0l9oG>_O1<;XAK!Vlix
z4qo5R2VUO}x;X?i{RCd$ew4rUz#s7Xc0J^sOQ7<BzxB&M(3y1~JQ|OHiVrf&HIL&i
zDgmHVsl9ty#66l1D1cIv0p#RhR?y)QKAktgd!|9_COkSXg4R!HfP4bloS}IT#1-)P
zehb`9bLqSQy7}n)4UicYpgXF0J(^E3zTD0LsnS9BUHEoBZTMwX;@o+`xAQ4l{Inb>
z5pv|;<_g}qX=7FT-naE_sidpn+m=fu{I40$AfLzJ%lOo%^QDjGL(g6oE|2B|N*=Z#
zU+}lHgBJ6E66s`6QUP7U)gb^L+iPh8Rhhl6|9v|T`f5J(1Z{1T2Kx}ym}mi&z`Y_I
zp1mb1j2@QPipzF^y4fzB?=-KuXg>4Qyx^<(z@zyYbBVOa_j{1`GN`-~>5u`PNdUg!
z2(q7zzey5teuE51-jRP>j0j^#3}~iwTZ{-(M~ncdu!<33?uZd!_GmuD;$eBQ^x{j<
z20Wk6Qy$Ha9(eR-Jpi?v558yZEr+D(zX`=WhW|ZUzm=B0Tn=_^-hU6xzlQ%o$;gHg
zl&)<A`2}4p82JT#ECj)#ieOPgkf<U^)DSG{2o?<liGs3#MIcx-5iD8=5={iDE%a!9
z-{8@Fl%;f@N9(r|bC9=rVNC}x4Qf6%p9R^>q65;bBfu}nqQNidqags<q;ZU~^tPwv
zMQA<7-wL`h12n%K06L?xZ3if(KoN9|g+t$?*O3t_b%4LEnuUSEv-#Hp{uW3qhNyr_
zB+usG3Ptju!65_w=E>k7FyZn6UtFr_WBHH24Rrnn=y>w$9-7}hnvcsneme|`ukIWb
z3sCzB6kp~YG6s-I-lL3=^EP0vYXbEOJs_!x1>F7ujlGz6gc$q<9kyZ4*b!pz56oif
z2r>8%W-)h&fJ|fYwESFp@#P~>BL{TShLGX6Z!Rht%>1pO4b?9}hi7~A+HiR^A1?%*
z>@5JDj{}uQ=AeKx2i*r|K7n7*$9w@OF3iEjkvZrL0rL$Y(F0&naA9N)Iz_<z0!Z`$
zSQK0onS;&|FbAEGVGh}Uca)`c0oV;C=1{8zK~_s3ueU(6AF3O)|L!Pb=_Ak*1qF}J
zf1Z}VVL{Zo5LD!JyQl;}bDg56<pKV-7ohru*+<2}@t6yjA_J%ba)32jlpCz{OXV7>
z7z;`z8mgFzN`)G#nDa|{8md^5OW7K#SoKRHd^&HVHB>;`Xd}P{eCvS{NpRid*?HTs
zp_YNcw>OoMzjfp9|Nmd>p|)RO%1SDs>)VjjH~#()o}_jF*ZLcOfp|5b8|D7<w=4$n
zI-kQ1`2+V+O+a3PUZcg|()jEDf6wpmaSV)FsqEMP|1VR2{{IhcJb@ad4h=Qh(8kkO
ztc|A%Q27LEJV}Ap#dumCE3O8eM9=ubqx}Zt!j<AIP}Aw1hvqTRq%FAVBn7HcKust9
zZ9L4NrVzZT^v<LCA2WZG5+efxOpbq>4>P2d1Y$uNNgx(#8|mW9cc83<v*}VS0ByE_
zu9bNSno+}F>GBJ(aPtfJaD(@hLF-t40T*u2u2OFBjxtyc3latGD&-CUZSR8BuOLy-
zu2OFBZZeG8bpfb$HN#cAf;5A+lyZYjM5|CAc~~ChZ(Rl1Fb1kn!Dn}Y)-HgPMeEDI
z|Np<7`UAdO6E=Ks3=~tHkfV!y7%zG>A5=u^27pw6lPfG~AdM}+MkXNBHfS1AM<&3f
zDuO`iFM!Y60!0DLicaWJ`klX^BCrVqOHh_G0cSZqaF){mXE~(?P?nPcWw}x@SI}@H
zWH8ejVor(E>o|~T=R>r-2=-U&fl|R8pq_#<iwgJ(P)GhL$DsCt_ELk&xl%dMSbXCV
zkRu(jEL4Yj9c&)hlW6`6@aYEMROi@P$FU!2&dp<nXD4`y8a!%^#bB^u*ybBSr^~ip
zDk%i5JY_m_#<{`9j-jLmbQXfA<@KTup1tLa(0jtbj`D2&uTWIs4O;hPd7_xptCz>Z
z$MR!&nos9Xa1*Gv@_|R^Kk&ZlFmP+G`F{d`GiW9sd_^IDs{yEC9|B4(klV+=QyyTW
zT@C-g1Rns7W+i9<x&~x#afjha&))j~9-8NUI{$$i8cLuVmmB7}GvNEeMfk9s7xfyn
zP88H%16@4VA;JNwn)tv6;(%G;6LG*SX2f|>=Swew50wTv4BSiat@`hw`5o<kasd`I
zQ2k^Es@M(q1$_*_tz|QC^<)OBo(w?eKY=bU7jQ8HS5Ic3>d63f{*wW?rECVSp3Fei
zlL6@bCj;pIaM1ZrpmqD29?i!<4M<4+EZ|}WZV!WYR~vxpBT(%MX$?Q}v^>w>dJ}S>
zjRg_AJ<-PJKqHgiN~DqNzXlt2h7wM232OPF=p+8g>@#Q11bB3Qgr#|;432rQH#E*r
z(zipyvF{EI{|w7TJaz~(G%#>5Ffnv~^tk+@`2i!2H3TU7J-~Yd{3Sqx9v-_G)EF2T
z1sGWPx0P`G_h|lSRVMmc(xVe14HqnD^Wb0nspvTlpP`tKG#&vu<@6tDy^?Qto`iR=
zj*e$<D5K#4kNu1YTR|6O{<AI9eJuj@Ea*NO{>9(<o362gwi}r+d3KgbfWnr4TM0yQ
z`ODI~;0|~bX!`JW+JuH0S<qd=prgsb*VDo3y`pCxy~U_Gv-7w|^KS+ICQ#Yp)ytv{
zI+)n<crmAEFN?f~<<X*I(3m8+>s|1`qw^D}>)q=G-c8*6FM+=qbVr!sCGf&F(CW^Y
z4cPLiXXkOl+b=-_YuKy@-NZ2!R8fN5(OdyO^2DRJ_&=z2?!4vE{D`?k2{fdEv|fdO
zn-434V+RjAC>TH^0if{=P$ezE$iM(TG_Ls|GtziF|F#guzm6Ru>>$QJ$BqzoMiA>i
zh{eReO@tA|fQ)Uxf~xfN%fsN%d<nYn%)8e_$D{dJfk$uUfAA4*sPjSm0xn_`_yv5#
z7J#;Ui-X$!;-JO0VjDn$pySV6#KE0kanOMeVi!Q74?q>EIJoO84m$8b3{<;{fd#?+
zUU8)J+&o%OmS{rVAmH)+CdfXRau%p{pk+6pBwYFk-pt`|-2$nS<rzSU&a=Bt!lSpG
z5tM#>dv$C;>%SelVr&>2ek+x5HvCqHj9q#3x-)rpx=A>8`PeYEoaCQ!s6-pA%;F|!
zU4=Vy+61sP|27^LQ20ZXuvpwIeF54>(Q=8uH5PR7wdMy9m%jyc<qF6u!?*D99mj?m
zT~GoA9T(&QzA^A<(QA*+-yXfCD5=w<`LBX!=MDZQkV4O19t|JHhaSxbnLI2{6!UuY
z@@RmLs%r`cr8($u1@@Yxn~8w|T9dp3-BT<98eZ%5XY%Y7vGHg=#AJBDV=p2Les*a1
zXH}+xlzu#VO~9eXzfFb-<YoSCU^V5>J@^-YEq(~jd!YM44c|ihuTcMafm}w6|3C^6
z{$oV-pDxH0y#C8U`0pObe;gqHq1Tj#Z(nMH8sAugx%Dl7O9IFiXm~eI`1k+6;Yp9)
z(Ep$v7M<_F)us%n+62$%Ir5_)Aotdz`4=;P(+P0?6JhaaKE#R?e*D{Fxc+v?aDeE4
z9Wfk?AjbcW7!D@>Z8BUPF_5zsJuJ_bUVRBV{Sn%BK-BUtLDxiMOCTVZLy9>_N@?DP
z&E?<<AF2Gn>HZrC_p^}c{;8lfAa9ScXfXID`*DD-j_vOUwO)>Z#b1K9?R)pyuy`~d
zFY@S(`tPCn+3*{`fQvb({4ig@FUSIE4uFI}rHA<eenA&#V*n%uDm%;{fW#n80gxD|
zC@=>JA-4k#vy`p?wFC5_wh4jCP{jFm=1@&g>pYr4z0*UCrB6I8&+@l2{rmqP<OR=W
zHwi|#KS1}Iyab(%0X4D^?g6y%CXl0O?H@r>{PX57#6M84)LHp<vpIJ08-DZXwJG!L
z*7;%O%TOu<9+>Jpoi?H6c8NV`Oheo%MihK*O37Q$&<5xN-*d2bN^%Ey=XUc?5&mY-
zVX?h|jGYreLOz`~CteGBcGvt6@aX3E=sfmcu;oBWB;H}f){~_?sB0J?T?kx_Ar!T}
z;Kn_;H4N<uc=Un~o!OVD0NQy7YVm_*;SCCu_DOJnPqIHKq1HM1bhEp3i5dR)>6NMX
z?&i7SVkKCrvI8<)cNr-^wA?NU;NK?0W+lT28bmL74?4re$MSp)yyt=lonl*f$ar*`
zoY=q!>TF;+Io!Lu<_36jv6}&OzAE@qPS8;rkTGfeK0@&i%K9VEJ+KDdYf-rO&mf&m
z0A7OM4Qt+ofZBY&tjZK$-$AH8bH)?i{(~wg-|NZ0_)5`pkJd}2o1iJ8xk81Zp8dFk
z3Mjllp2W3E5Uu?Tc5kR-2x!fkXXkgMV=KB1K;whCp2v@XmLMU8zjH&4I_P}R6cxtO
z&mP@;p!R{AZ|jqiAV~dVcnPh2vW-R1(TYX9RHWqqs9k=D(Z}*p(MzWW8%5g^SC4K#
z@bw&^BTkQk&N_n3>NHz0l-j(G1Z_J6Z6`wRFEv=&mhge>Z9c{U()Io|yC>rr&*meH
zu&}UTD3SMVeFBX(Pkz@c(4>i2(+D0g0%aISegQWDeofFhnrQ-_&`UuL4|wi{MIETh
z1<g#c{P$@7X;o$jzO4tcFcQ+PaRax95lYJMqWa&HfAQI3F;J@o&8TOuH-p^24(4p+
zDCE~*QE}uKbQ1vWpuoLyACyio(;sNPf=BZk3#h@MaeD(t(Af{)!B>ofmt%nTQMMi^
z<waTo(8=rp83fqD(7?dp!|#3obfKIE=mb0k(9oTLPp^-Pj87+IO)uyk`)QzQ!R{Ot
z4aaSa;M0?t7#SEq!<Q=1Ak9$`@C2Q!2U^8sc)(*fEKor+_~7$BLKy#hH2<<HlY6ZW
z@(T!ig6^*d1r@lJ43aJ9_TXQ9x#$_FMhQdOjp7MfY~|VQq5_Tqxbm`#uWvbSV{~nK
zTUy#30@}X{KA6VU@EaojVL@Z<qGC`I`?}Vn8yqUl)!=O849-T-IB-!B@ae8mQ2=%7
zRZ$m5l>~Y;?*<K$fDd!W97%LhF(_364WBe0v49uBnB6vL>I4^)Foz)(zObPtA{N1b
z!Vf7ucy^xfNcQLOX#5E}Nvqf%G@ake;|VGXK}?WTFOR2Br^^WrB)&&y$O(aFcMeAM
z{Q?+g;d}!Z@gTFoZU@<pUcP|NC-~=h+zq_X0(u&=0IZ31KnQw{x@RXFxX{8j420w#
z$KYe^jIb+-kGTslK#zk2-yXb!fq{_$T>N#qD<C8^(vG`>Ze{~7CSzn|Wbo*8H#z2R
z!+6{sw3(CPn7a!jzXrI*;}>-I@PMcTbqPD&Bhrq$ConP|b58=<ngOx^VQ|4Q_X>uz
z<L;FV44`RT$aTm3g6*L6aI76vwlExTU&6q^&>_sgkaoNsbOa-4=ooC3M`t@|{qga3
zsCA5K$J;@DJw}G(?VwwnKp6&ZRXZqz(~h@;R(UWoc<f+=0*}u2>tKhrUji-dZ3o?L
z&2YROG;atBhhyzeK*k(vf6BnXz<8`3bgdi1vG(U6L4?_$m^;=EI&h!iSUYF~Hsi7O
zPaq}7+QBQ8F_SAKn&Bi${2+}tG{13xCFV{S6$?o1;@hht?%90gzhf60r~o<7#K7Qd
z`G>#l7!w17Pj8Nj0r*TOAI+a0n&3%E4v*d(6#>xD^!J+{ojfY98P9n3`Z3z5mPYXJ
zV{HCWP!iGnBZ<Ei)D82se9qsT$Hc(U1zwE{J{=a+=YTB3NA&+X_(5ZZVAT$w1=OHj
z0tZ01Y&?Bwz{J4d*unmigOPy&Ww5gIHC(?(@&}L1W9eyWX&#-2JPy9H_c-`NiSa_O
z2t%*Uq|Q&8zZwo1bOg&cALI0BKK#G=pHTT(k6vd5AIlf~%@;tEl^|z==Gr}aixoY4
zLFY7!`&ho?Z{7?lO)VerH-q{co}Dj1%k4Nkdv*9dx<Pl(*l>dyIv$pPJvx7R@Vj3H
z&CfRfQs8e21a+P)|9bGd|Mlp+>7n@(Jd|yD0<?naCxpxBVR?=pe7-igdGqXnN3Y)l
zkIu6m2j8;x)<VvQ|CvziZuk~_4D2@0Idq`YZ5@xXtAYZ{v-2D@#$=&BXetGr;RxE!
z@7a0Wv-ubkSibbhOHdQtqu2kxhvrMex1jMqegPM4MScMvZ9~xbf<9<psgJ%ONE9>(
zsT~LwRRj%N=o^AW6G3VV!J>{}(LjEI7VSm`1_pkC9_@*s<?Q@|F8YaJxk8WTw+$Z6
zp!4WFTK|_Qdwd6-5sAe<kLIHapztew;KBI8!}40GIQY7#qj0D5w}P%ze(m7Fc+aEx
zn4(YTQBbSfv-3FrHn;zd9qgcB@UeVXEC3SrwR~Rm96BF`WWwWr|Nr}1J}))`?O%Z<
zerp#Mi&9(AMc(i#0Ndh6)TX9~B9@(ypsdP(dY%Tj{RUd^{ts5Bf({A-EA)Z%!9AOg
z3;1+e_;eO<9CHw0fbJ6U=}eIDO!k9S4gAeVL9?9QVjiIC0n(=T=rlP6y6!7EjKiZ>
zBnaB-_vkFS$bl@}>2guPvDu9SHg>WP;Q+X;jA+&sM|o0a73k0$9A`2?D^qCWZy#nA
zg;HL<W<3K+75v-S`S+dZ4gB8xi?!%o^G}76mp0lZE;hQQE+A>hMo9jB=DltgntyPX
zIT&8@0Pl_b|NnozYwH2X-U`q<itjf;Ef<g0OCJ252VZuBN@vg+&ERefTz~likfDZ`
zJa^8T2?mnL<JUfxr#yOjgg`sMp<8r3_?=IA@bCM!Lmy<G<_8bUgXN$&;qz!dbb)`L
zdFO}b0~bI>Hvix%I)Li3zBJH=X3Ik!{7#3k7v(77(fo_6#K<H06j~@|DuMcPT(I@z
z@UkDo09lMZ`~+-tOC@}I;~630_gWOf2GvckIU!e@dUpPH<lo2L8+gIh@KW<H&hi+f
zK!KbW>1%n)yH`ZWqgP~-C*;B@Pk!f19{l@GLc`;PhvlJi4xe5TF3;ve7aaNbc{748
zlIlFseBc5oMD}fD1g)>&d@W#j64a;RY&q%4@A})L(+(x5>Nq_u4|(!C9eOS3(+N6$
z6BLuakeI|Cav<NMwRb@C5tmBTTn!Jv>kB9TeLU=zA4|AFm#lbNUMPC^n#~8##U?26
z0c!F}dGtE{ckI022wH~I{DZle7jzE!fzpWA<%S1d7yEV|^whj)c;Gc`d}W`w<tNbn
zQ69bFjG)7|LAOb{UhwGkXX4-I&Sd$)gWvU(N3T0G|Gsc$kV@Bs-~&rRh3H|>HJFN?
z-)|uG_xShmgG_Ka4vJ`yA4=ci3l7xs3FLkS!vo0an|~V*n*|ShDd;E>Mh{SUfKJ5b
zpL>9R+ksvdhUNqR@fwe8zK7*^{$@}U%cJ!Ye_sQrvTy#SP$cEi%Od6hTBrzG+3EpW
z0%iGuzYVk-%@uS)t<!&B%?qI1+We3iRAt<JjoiO<;@`$1=G4I=4&77A2s<BE0kU2Z
zF7L#@%|#4!qO~|9m<c-4TAT^Y1f6Lu&g|KIh{eb9Qt8>3PeJqdZTCSHHOQscK#X1|
zP}fI*ziBs^$0O!p`Lhf(uq^Ij`H{bUDX1$I3@YD2hj2GP_~6?c@Bx%C558n^>GfoE
zY<|e>+5F3ZzZulLb2a=A8trQZ?Q{emb>Z20$+P*<1K(b+2R@xAJr2HPb?J3v1SKKQ
z=AWQ7M<;z-50n<X1TEY5?e+NYsd>`yBzS!czW@s#zkm-PXm*gFU(kmiG?~B$n&;;O
z%?<K{<_7seQwe;aS$;my%pgB#IFKJSk-!I<<L3j-3-W`;1Np)0=R844YXvB2>4RqY
zLCFhgJd|I+g%30y$j2|}!Vj7q<o9Skr~poAPdqIz@wb2)&M)0SYgBqgK#}snr&mVI
zv-$7`-`>Lio|@-C^T0^vIr9s!SUd9zvRFCu3%FQ+aOM|uvHAdJKLE2IfY}$o><jSI
zqfdB#zYjY2U&*7_>w}NxPtWf+A>$d~@DOAHx#|Px3W3sho|YFN8`DYzd^8V$(lcZ>
z=zryBkIo<Hy(X0W?9#;#I+Negr3<tN7d)QrYH_f{*roH3N9RXy__tgt5#rw#2-?of
z=xA{fbU)I`QX!WvA9nDKNv<s?OV8k#S_BtJDE5K!pSIyi<oxHtzm0|8#fpWmRLt-I
z=o)ls(9Dg8<;9|>uLZzaaWdYlh+;mZy&n?n(d+--qc`sT21e*&8PFzgNcrv9d4vV*
z8Srdi^HD~p1{*O3-`*g`(kHH<68Tbz46^&28f^F(N;pA5?P+<j=!2)_#ZnH>&WkU@
zSwZWBivD|cUiQ^I?bpk~?`wIFzZukR^0fTG-`oOfnu4;I9xHgAnL?42S1*egXfacB
z9TRA7jzs`;xNut`XvX4zPv<2MP0(2i;G@|~v>Y3rFgx;ZI|EwLk6a#r#u^<vWI&6?
z!QKF^F9T0Euz-%t=K-Y)W@PvCZxdnb2x0uozb%A~u_J`>ABe%!5yJQ%#9;0a0YxK=
zr{$s2t1nwvKwc{T4|cy3*!|!5`!d1n<o+oX$$9m%n1S8@8eB$z*K+;``{5R7ME^i<
z7PE`yS&v??e;%3#eKb#cG(Tl7QSkVF7rFf2Cc}nsKV*FzX!$iWXrUhHmH^F@9-0Te
zdUZHF82@@SA7utLked%M8-9bP|7|e_e>-AK|MG8(G5FUJWBL!o_}>v@`k#NBj6p|?
zDFbMMtcT^t(kn05F*7jug5qEm=)f~jsk@Mwfx-Ehi@<*dP~p{l@E?CiA4snGp8$VT
z0yqp=#6XjEo|XrS1-*M&K$BcxKeju8LZ|b)XY=z9p1uAbK&LDme8J+=8^P$&{L_HH
zIfI#j!SE7jIUs-QHf9EfmtUC~82H<?z;5`)-=_$+=kPz@-byCWY7fne9<3*R`2Bu)
zHXr}*t9jnD`M&^v(;IMV@Mt{=YO;aKO3i~Fj6XdYzkx355clZi5eF@C_vrlUp?MTE
zKhd-s)M@Sf=h^)1gJ*Bv2anDd9tU5r^m;%hrvDo7H-8034tQeP8#E<W1M1y&UVyD4
z_v}3FdGIwWsF4C%MPBR*^8|Q~;}@tK2-^M%T5_K80Mz#dm)?<#j?IsmJ(~X}@Hc}x
z_J${YTW|BXf>xlvEMsI~@ar|<_iR2^01oDd4?LiYr(Jq086BISGlTr>sd?V;62Ab8
z7-$X{w35q3YyzkoCAI)GsS7IN#lTCs#5RCM4}e5Lg}fMeDVNv<u;>GjD5#hh125$g
z124xC1Kt1S3BLae6d$1b0YLYEVL1gHbUy%Mx>*3M8?@F|0aOZs?gu!;-vYXg;$_UA
z|Ns4ZZ9tv%0^i=`|DKv>3{QgY(}LAcpe`am*!}z<_d}~FuqfF5{2=#3D=Dxj*!}z<
z_d}~GuqfCC{GfH-p3O&CN*DOH-Y(IE)KlR5N#XSqNHqsoH3y`II?M=i?=k)s&>+ss
zf<K@oW?AojAVVDQeKgN{Fn;yujr<Rq6W0Wtmum>V4@|&?l>szW&%!U@!U{6ah2;Z?
z37(W^0XdHq<Wd(F(4`ayJem))l%DqZegiblZsyUO^&XTCds+0M=6}CwcpIht!Y|+=
z%fK(lBH__|_yagl-}+j9FA?|E{0y#NK<yVf=MEML&*sDbD?c7{5&zHN4ZRBl)I*JP
zjK|VHg(dHU|2;Gh8eRgmus{R7pj#7Uz$r=UJ(zzV6iQO}!R+&3_IWUSKbXDWqxsMQ
zaCd#5$M;*{l;YykdD=tsGWdpXgXV)D4!&e*J_ycApb?)BpsP6;?}ID^StH;g_1>db
z2DIt`#A-eS@!%t0%YXbW=AfQV^V1I=#}9(e!t&63>BD#tbe|XtpJN9LD9-*@etIeR
z|Nnn*JqaUF>NAhd9}N}^pn0Xz?~uAl0#sk}f$B*<mkt-u6wN_KP-Xezm<!{72K-mo
zfUQ6=AJm=$otF{p(;NQYqu1~K21e-RYp#YTA?2-O=K&T*SliRH`536a<YVyd^<*r4
z;@Ru?-^20(e>3R7FmUU)2wZ8L<nMb9uJnE?fGRy6J`c;E{B2oG&>9MKmjY-fi>u)`
zU(f{@pFEon{RiLZqUzZ2095N;08MB@>TA&b2xd+lJmw&~A?sT_!Sm~_tPBjV8PCAw
zo%px;m@zta_?Uy*zdmM6ASS5&>tn_YVuEh<VDYv5SbFxQ7idjJ>m~jcM^**~A5hB|
z)N(fhyZr!vpBmWhKOk;r1H1h;_(B>Uc2HZm4RkV%tKlV=UN6wP`hPx}mpnmDcL~q$
zH`6A7+#}}H!2@a<g70_&t;YdX&=<hf$3b7si+;T_;-1ZinIWsnnNizA{M$nK{yKJq
zaD!@WKF|UkZcvrY2U?)R{U5aW&ap!Tbn_C6r{&4gi!Uodm*KWmfD8v+sFTmaz~FSu
zg&$PEf$qHf$KMeHs#%+V2=F&8U<StkX!pl|Q1f2Us~6m0_z&_{dlRUB>O26sIVRu(
zs7G?}C5ullsO<-8*!M7jPQ1Dey2paQ^#Q0N(F0d--@z5!0sg*sprsbQQUAb$rl1ki
z){~ClbMk%p{Z4=`&f#y`$IQS0mUcC~<e_=dhu`y}XXkHU&C6cBJZzqpr;COCdS%!>
zIzReoUIg72)YJ<yyz`W2^P>-*y<Q(YJI{F@e8=M28wag^Ko#$8u*1HA>mOZE#p?yu
zbk4K+*#pnsum_;d$H7;ukVO0|0aC$%_DJmm4J>{K-9^-S2+}=?dH~vr0<Pd-eVX41
z{LP?E6QBz2B!8<XXaNIg9S>|11@vA^m)<C_lR(9or{-nDOVIH+c>TsN$Rf@!=mS{{
z1*zQl1zp5J{TIkmC`i=?5(D*LAPb=&6&pwl)PI4jgYpCw!7D(~Py)Wb&$aWEWAmc~
z$L2#191p%?b!<Mw=-B*-+4K7?=y)fjeghc->d%OSR!4!tqV$Qc<wyP&TTo1v{Q3Xi
zw>R>?r{-zHlW65P_4{9-^%$Ve4YdDt6Q#Y1qyKe~5#-(r{4E`z2x#~Nx~&JLDFMB|
z+pCvH4phW*zW3@Ckp~s?g5auv6I>Mtf~x{fa8)1(t_nE8Re|7s&*sAiz%7P-p5MV~
zyd)TWI0BA)dp`MU-tz4H@2hzqExbH?MYurr3%>X46#;L#5`6E`eDH&3^AX0<N1)qt
zTR^AgftqU`#}9#O1|Q8&K8&Z}<0ad8#5zEYyhHyhKfeUc+xYa_h<i342i4?ap3O(z
z`}Su4_tpFg+WG`qZ_F>iVgl-4nuGe0CgA?1Ik<mm0`6a$gZq~z;Qpog1<&SV2RuRB
zZBBT8zXxhsD0ws=dhet8$@BYdNO=!VuY#ba{h<$_CSmD2U(1UnVm_Leq4L{!<T`ld
zL6ZrUpPi1eurq*a=~ze)6uq;FzFrzqhbf@M_cj*3mIEa`9pEl4xGsC+(aXXQ8fMTu
z;nH~wvaPzL415v?=spRL-XhS>JICe+>>i*E)Mh@62R$?|Lh~C@`vMPglwJo70N8;#
z|ET+opxb`I9sbX+Wj&i8{P1Kv;AwfFOprhPKpO14QXk6$MPG=hZjr}_Aop>A&x85s
z32LN)X7Ct5mpZjyVPRkZT|)2E>(1`e3A&o+hi~U~&*tYp3{QH1b{)+F9a~}fi@y!D
zrpl-Dgva+Ao}IrvH9z}U-tggfzv21)wrBHi=5j8>lOCNvUV1ZvwhZ6!Xnyd=qc`9W
zq%3E0=`94^Z^Z~2pK37$RT;f$poVN3|N8@mC)4=fpG=#;zg>hsjX&>F8h^s2H2%a}
z{M$qLnUDl7rSa!KPUA0nBA>=z^jIQ|Kj}^y|LYrR{P~B{_=_HZL?3}fFQoCmz6jFH
zlE$BRD2+eiKpKDI0gwP&8h_rYH2#E>Y5a*N)A;irz)X7p(sv|{|MlTC{`{LD<3Xl9
z1c{zb<9~h1qxm3*XY&yz{?>5NC1<VQN_;`)p}X!DOefeKmq9xDxATBJbrI?*kRLEr
z9ZKVWeK3u`;Dlcq|LYTJ9{hDDeJpR3sCzK}0FAvu(-&yZE&o1`{~nwdJuE*IbNX0b
z0JYDGo`W`rHEV&QsrdxEXY+?2zKlOS558aqr6kZ5bo_0MAj#c-Knqy@|F`#5JPf+(
z{h(*B^B>669TRLd@eiJ20Z?p!R}+_3zg!F&Xa}{mG%rAek^0l0`SV4trSZSM@R>i~
z<(dG<51;w-eXc2d=FgA0X7HImKjoT38vpBuY5cDredf;(xfYPd{~8o35FH6={I8FI
zbrgU?3UnVVXk&Bfa!><b*Q1x^ng{6W2l#zSpZW6xKBV!#KJ=MCA7tAp@P5wbgN&t5
zL3X2tpReVO5-G1<lY2<_QF8NvmeKfF{ww<8Y5AYOsT<Vn0;O#5)=ABuK8)u*n*X!#
zHzk3BtMi9v^MgOofPyDv@D^N1GHwG8MTCJCXM)29eLrrRBYz$!MMF}vBmZ_6aB{wY
zloW_g&LFc~_*r0y8EhCRHJ>0iHG>x1^0!8UdJ3)IN_@Zuf|4_`>o61QDUdthej++C
zds_Y|QS@azj=mmfAG-(VLC}1nujQ}O51?U!DF?vIA8<@*AxaC-K|!sRfBye}dGOEw
z|B&DZ-K^Sb{2z3#4#-=m^N1ZvpknDHctQ}|8$p||fQ;Wk7Yr%DrYu1#a6CKDf{*n4
z2R`rvd{x_aHU@^)Z~T1+*ccc<o3WFRc`_aY?aa(k;c)C?w^8M9eGBR%7(#7=P@rjS
z0nk_qM+c)vvx|xVWAiaaknf>dcCj)rxOTZSdiLgngqa*0e&~AgyS#Vlie+%^yy@6*
z@Pgq1$A+Jr<)NTcYi{!IJK4+9(97c3eBc8AHeW`M=A(?Ary34jX!yld^vH1!D7QEK
z)GPIBsAbeDb@5CNW$<YJrBSX9x-pK~SD-hD!?81z;k7cvd1qWYZ^AW|oPI6r+3m~W
z(HqF&*%`{=(R`H2rCZUZE0n?TwqwJuD*h>lJs4kuSS8{O);Xm@4b_Y}4*XM&B5GK}
zw;*Z$DTf>zesb|oI_SW^?XOFhPBqA1C9JNkPbzpF8~zqMZY}0-)duy8I!#m@I9_pF
z^y#&!cI4mpw>N%8^KXUnQrH|^=Rc2Rn|U6L-$AD;ar}Sone5Bp(DJrKy7{L@xwS{<
zDNp85fnHAz$4*}ck8Yut%R!46KyGbyU}RtbDH8MS4i)fVJk@*<uBZugPyw<}y9Hl@
z)=o74R|Q+c-&)7Qz|eBiquWG<zqJU|qXC`y?E@NUwE->AWl(*o_wWDzmXrLgA)xWf
zWM2l4=ARn;?VxQC9-SvVnOzZ%67Ya&ZsG#9CdC*T7(i?FrC1mkz~RCLieUaW3l;{3
z&g0+jgT(k<e}H@nF*E{H=%5(-6140AqyQ8YWni1XfEA$zht^90W`sY$qmpo!f_C<z
zyVOSolveqhBmVyX|ME5iIQ;nA-7riB9~lmg=+*_0Q08w3Z8AX*X|0zNz#;9*;nC~C
z;o0fS;n58bjbg!L43JaHK=mDHot}UXsERwrPyxv)J3;3%I_?0S0tV^Wflhf4@ag=P
z#gN7DB4{?~sF@=Ipg8I^VQW6dgp{q4LA{J6fBygX>_)a5=D&(R|NnO}yv)Q<AOM=Y
zhAf%!;CH#u#RXbNvyOp*0dzQf2WSbB;Q^HXii_m~{$9}B8fYi7fRE+ZV$KdwS^(vA
z{%t-?py6)N>YD2>kAT-0gmQTFdVxctTgcV$q+`Qx0|)*o$3QEh-!}Y=aNwVEd^1<W
z&(ad6%>oV`fBCnacH!T4z_H^a%<rLD3@^fGLA?Gl15{_Bq+`vOa^T_D&V%1?TAr_o
zdkHH1!07|j@kGroFG1^`KxYAgCO)9^r#_b7iUm6Oz@nhF9^iB9kUeq_Vlsa(=xD{x
zU*B(mm3Cg#Jox?kw}XtO9GwR(f0W9<E(Dn*c#KT}EDtxT*MrgWM@dNM1<e!S@i>qw
zZ46aDmfwn`nh*RdeehZnT2MhLkospB>Oo4kc3uE26=FOAN(P<Bz~yUc+{^i(ea_v8
zVE0JYf`+>z|CEEEL$bc#^5FNm>T&R`Jt(Mmg68>Qft|$=`r_3LNMJLws34il-{SV`
z|NoW){H;>I{{M$(@OIELCeY9kG$k`YQZlS+v360BfZRI<8sa{p0Po9S8FPddfS~w;
z-js)0xrHfXStJ8n_)&~a62mAW1)xC>rclQ7NWG5@%hWcid5v#C#feAf1@Nv!@Jf1*
z&M7M36Ky)5f!e~I2VYo%Qa@y&G-#VHND_Q%DM%}(4amWW+CTK@H17-to#4eU=q})K
z+#R%ZhvAre2BSyvDey_~pkuT>nvZLAUf}$(g1@8~G=vA*tmo0|_`mrPyGQd6_96?A
zV>M5_W(SAPnKQ@O8IHL#G8}VfVmRi`%y7(|h2fYxE5k8&Hil#F><k{w$2mZ^5tLpB
z%}v^Y#vRf6gJ3m`;E~7AuVo?UXZ-|^o<aMA?4V0WJuJ@`eL?U3VysZrR{<?t0WI_d
z$27=^DB+FL{xR_E{0>W}oh~XG{M-C9z=w>q27|h8t^fI3{(~;<>Ge_3@aT0H@aSYw
z@#!s50fnH)E(RrV?~>uQ5Xcq;24xw?E_NHvlCQp<e{Hx*6gm%r7z!m%!TG=CWQj27
zj(hO=D4_cf-+>NDkpLZ#a-f7SZGtoSye8jX(0NV1jDKyE`CC9&2l-mQ=WmGtkGs7=
zDUU%b(N#c;)fLKxJop!%D&_$#xb(GrUi#Fx^N&xmJBM%Ufx2>!ZgInJh9^C`bw0Hm
zD2Yb&7koN@qnKyq%1|l<YGm<mb7ln1;kFzoeQkIEbZSE>FX((O4jU`}mR+D4viTTe
z^Fc-*%VV`tj$P~!qf6I=R$c!FDKEMB`i|jA7to!`PeE;zZ^t-Fg+UWIY@W@>1bi*e
z6+y;dj=89CfX=7o1QA>yf*VBefCyd?!3QGvL4*K^5CjoIAVL^Kh=2%D5FrL4#6g4v
zh>!#kQXoPaM96>$Sr8!yBIH4Y0*Fuq5lSFJ8APan2vrcF1|rlMKqsVhvwI}p^yp@}
z0jjk*d^?}{YX0-=tz(4W@&*zY0JYa!+Cf!R^FM_m2_MS`{LSD~UOEr@Fn$E>eQpNb
z&;c4kxaZRO$VKxPD6Tv;&-iNo0dGE4!OS0^y+QmPG8~|(9dIUj=h^&+*`xC_e-r4c
z@d=>wP57bv#rfg;#rfg;#rcu;i=QjK_!6{>78I?Z{lWJ^k<*$CTG|OZ)Y7N(BhD@I
z#XR6mjise8!N>3QLN}VHO+Yz+gaxvp3^YE6bo>c)OBq-cyuTcL{0Y+ja&z$ha`5pd
zMC~s(2k$QjZ$kr(xT5SYKgZuX4}3p~i;95LF%|;`(BXFAYzx2htMmOa7kLdv(EbL{
zRjr7;3_fe5gcr1f)VK3Jf2#>-jt^Gwg6<2A@Mu0_fVU2VszzGR4=#zo1hiy^RaqS>
zpz;0#$WmZ7qAUTiP|7dZ?kN+<?kQKp+uq$QH(aa)N+rP)0WO`FS}v7Hfo3tl#}Run
zmb?cIGWuGcuDNP>;5DaHLyf!!1OHUqH|8PP=h6AWr`uftG&U#Uaqt1F2eZ2X!6JB%
z3IhY|UIUQ(5tp$Z5b)?^M+<|;D#&#@NIjDMj={&=4H!Tj-WE1c8}AZ$ynP#sSj&MD
zpAHvs1MrHhmIEdF9WLUAAP!T@ff9`l7jYvHhq>iIiDHL~xH0%}rsiJ`MTd8Rs)pAB
zpaZR5b9pqMVtNhQKFSPUGuC{-U?)f#bjdFCtjUr>P;b2jwB>G}J!p&wamlWs2P0_u
z=fDJ_#zPNrfa<@KC3c|ICTR5^sIhebveX1#{~ZKf--I$A>S1}J=*uzpd<M)49~5c`
z-0fb_e1ft02Xm>&arXkyCCMJg-8Dcf{5`ta|0@KbMZgF22tWz{<L#j8AGCrKr?n{R
zoA-m%<4s=yF8tfvOF*m9lwG>r3qT`xrN)>p_2_osi2VNm&9w}wpyUG1C1^5?stgR^
z+n~Xch~PNWP+!7O!q!}0z*x$D+`RyFdMhX(5(J=Xj=L9t&ZYL~ELZ3ZuK?|f>2{Ft
z=sfrT0Yt%ZchH7#29M5i4Uf)nfe!zY=6Vj$brhZMH4xPbJ_yxk&K!3y00lNE<w8Oa
z!~@%?0X7gNyukOd{`2fKbL<S`aP0KsaqV;y@a(OV0Q<u6xEt6k$Ud4jP|$)liB&ju
z*Kv3pe9jDAqYb^-(X+D+RJlMEgLaiT@(Z?sww-|J1)$^$T1Sm-&kfjNPy)q$9^L(*
zadgm7rIAN>JIGLv?g^kRFCLxK!MxT>rQ9CJ!CO|q9&JAO-=h<(3CE%}6!YQp;{o6s
zB|sb29Gh!YBp6Dv9lKpr3R(}8*rKg>@a*nU0r}IXTjwU|G;1O79<6VV|F5?kC=~|l
z0#|PbJuFWbU2-*i>jOFz=?DkB)W%H7Xi4di5h#(lLQiE!a&L3J1Vc#(DAj`IHY`25
zr-K|~_#dVH<k8LY3v>supoe9FLMeB*M?v#Rmgb)<rQDzewLX@|i|!g8AXti`x&azB
zU<%1S(D@Gde$MOQ>z@C5cKc?4%B@y4(8{IWQi&bl4BXDvdZ5(&wIkRR1aX{21r%}n
zgBchYc7e8CK&OunxEh`WHRZm6lj06g9&rR4an7;Zw*ZtPj6J)jf&<_iVl?c`8INw3
zPayyE_*f=rl(IEf6fl%lgL}i4=ZYTjulrzlz_FdJ`3F;pV(WoYXSA^2f)e&9ZUY@S
z0<Pp-4N={Of6wGG2LlG**8e4~@blWX@tC)qEb;H~0Udd>&BvUv<z$IrhmV0Fs3~pE
z)N-;!v%|;02+U({Ia#9E;bUM7Uh~%c&!K4lK2RkAszc5(g6fcS;5y_OvqvwFfk*Q}
z18^1Nq4}xvI_G(ZZ^!vdYQeKXpp7j1A$7=ia98R-dy%aN_}Dwt@s(qY496Tnn2F(-
zBQwJ>M;3--j;svF9N8F-IfD912f-U?LG{TcP<?U>Z9n`mMh19O5nP`<`T?q{EKkAb
z*FbfR0BB9imtzk33@<Z5ttHf+_Cg~>%LF66d3OG5t^?g-XAW-Y?gN!93?9eZK&1jG
zC6$<Zc7ux@kIoGsG0)CzphC#AyA7lgH1g%y31&KW`|)^Ko+#IO2|5HCrmS-tXaO)d
z$)c*`Z#xEBNzlCyB=6bX4>7wB!~^ZC<@P)dwiV<A@cKfSCH@5-%|BWATjznc5<yF6
zM^N$Xh$x?-mzV`;ICi^BG#_Ae>~xoK?Di9AKKS4AU{RoF^FB~9$l!S#yxk9EMTwGU
zcN=J<o=+$Ex@_OheITA^cN<70$d|8$p<=$B`#?n{%u677?6bLOd4XFE)R_g<;NUC>
z&9W%*u^%)a1}&&OW?+_VsQrJ(V2^J0ZU+vm>Y&D>&Zl~G^Y8fopPxb5kq4J1B=>l9
zvx76}2mXT|JdF=Q8XJFt$P&WM#%eVNhMk~$iye1>NQ94(%y$fi?qkH|7LXr2IzNDR
z%s~<~sHb(!qw^4Gyb^i`0g8Fx`X?m72eJjq)$o7X1Xsf+-rX$!Rxp;DfaeT8Pr!tZ
z%|{raiugS`4|+78Wc=XGzmex(iK1ikAI`ed$nk<uTypvKgEOG<0nf(&AWxP~#y1TF
z@(g<X86JS$J;DK%KI73X!r{^U=$}U?h(5sKVaveKz)<=ER~VuAznk5fjeipE&H%do
z;P8S@A4wpMod|e#{)03;K-Z0fMzI+@Am_k&G#^VT;eg#U?`rtOrx$!+pJ(TD$a)9w
z?wF?x9?g&cl_-P9N4lLkI$2aaI%8Box_mkzd+$BEr9ns7KLV}tfL@SYdepbuPr$SJ
zClh}YXuiO+n-8+d2zCC=r}Hps{oHxqqc{G)$Hmtko%cKrK4bAX_?)F%#L!yAvRK}O
z@jSl(JLr4>55{x+0&M((?4WJo{DN#C+mC>zntd%#l&*exmjQAb?wK<_ou~K(7{OW&
zK4Re)U=idOWQ1s95j4Ey(RmHkJs!O*pj(C+eR^4hK)0LwSe_`7_O(1wWDDA+82Pdp
zZZaf>K|44PK4a-NF$AqE?F6kW^*H#L#o9!&h#52#*Llp>@<j1rP_jSxfTf#-(Wmn`
z$V=8NmPO2-ogYA}9W1Yv=zAP|#NyHU0qj6c78Q?!4?vD(1l`aIbuFVu=O-V~#!=9G
zsb}-S|NO1;peaUZm)6=vMW9sPqxpyg;ieQK`=XX7KHcsDpte)F;Ypv)L*V!ZZ{)i8
z%GdHjS-DR)Klsq%2P}@3CX7WQpf&rJr^@fV7K4NZhy<;y0<C$rJXL<g@W3umS?ptZ
zuw2vA@<dsn$H9jzh6fxiO*p|4rNW-wE}R@5-2nm~%?Bi2vlt#Qyo8xC(8}FY;I$nW
z!G1uKf*%nHatQ>Z<R=f%{$9*G=pZT~B#L^+umI4ABPbr5Z~X6c=jc4(Vao{GJ=81?
zaz!r-=(<k^@Y0-caCHk>HR;pqF92FN;AwfVSk$YR1#~nSXsbgR=mhka|3S56=P}UY
zJm2292fm%RJP*ENb?x<n?jib}P%P+bcnQ3J2vmo@1fBK{TASvpdD+$Qk`riwk`s8v
zxD&sii@1OjXi=Sl6KEMYi1ZON0E>f2A8`k;IEeHS3jm9QNFVV8usDeH5i0<TgUB9n
zkcFPjuNuH>?52R$sMUdX-XQJg!C}8=^C1P$9+A@fuYJ%W<sP`61f2x{8+UN(Vli{-
za4{Ef>T&@sS#>cN1hGInw#<b<EYOB6b79ZsV=TUwA4)HPTC=Pkoj%tEJdU>ufX^;q
zU;vlRgnCQ(=GO&WJI{dDQ+8hW?ELD{`P;Gi4<mmYJ80yz8(ao@bh|Qu&+`HeF!*$4
z3mkU_?L=qrZ2Sj42D@o4C@L+F@wb7t<~x2n&d%QoTA=0G>-WJ2wBolGEPuSL0yG@U
z04YyhEFTqTcy^a_cvv1QiubX6SHjzQy*G%lGnm7pv*fpcujO};yt%`-W9+5&9+n@=
ztb8p0d3Js;Kl<7Ld^`x~UM3E3>Ia?W%;C}L%7Ddj&B>s$q4|gayfnZ)r2`xBdZz|j
zp77DP^9R^?m(GW1QOTkXYVv^k8ej!zvQX_{DM)5Qt)DzQKe}|gbNE`G;BSiuojng)
z-{#Iy66@M|$g%kcbD1G%7~iXx2b`(AdU;NIFoJf^3xGyjJiK~Yu7j51c=hs}2ki&&
zusm37Y<S75m*qT27&Hk18h`TW=DFa}$#Wev7VBeqsp!3rv5bn3wJfM0Dq%Wv=CDiW
zrRGO}JbJzUKz6V&x%4_Pf_CD0H2>r&<}o|~8vCev32GCAt!g|7&J?``pi>A95AX}P
z9Gt)};B#;Rzo5%;0e(TB;|d@#&;eZsK?igl2aT~FcL0fj4(K}g0HiJeq%Hv@2HIP9
z5F}K<FW7S&WHiL}$5=|2fQnvgk6xbRpbZT^j3+#LS&oC27lBsk!RB-L1sp!`3vloY
zI)306<OC@Mt7tyJSo*}r@)CdRYtV2pJLpcdV6^zrR|iEe%IXue`~hk|xODq-fNJd`
zP1nv7j^8i%bc;JSKVWoh{>fA-Yk0sBd=eXImvt*>S=P(r3=9m02VR0&&@P<^JT(u(
zlt9;ud3W=C^6#$s!~r@nQuCCD=0^{Hr&FHYB8NOWzk6t2_t5<0!S8h4xAQZo%fsy1
z392f6G=F$%e)r*b`r+Npatk!~rg_jq^MeP!(?L(m<3-Xwoi{-H{6VYP=f9SMr!^46
zv)7FgCfDrRdZ0uT<O0ubn?s(RA3QZrcxZm~<aas&=KS!`{O-x`^uxpQrzgMDG3>2=
zkfBHzrG5Z)Ao*KB6#{{2wqx!b49DC#8IHMgF&uN}W;o`~!*I-<m*JQ@AHy+seg@F#
zDaYIe8IHLNF&uLjW;o_9!f?!8l;N1W7{f7lafV~=5)8-OB^i#nOEDaCmu5KTF2iul
zU6$dPyBxzYcX@_m?g|XY+!Yy)xhpXob5~|K=B~nU%w3h?n7bOoF?V%_W9}LZ$J{j;
zj=5_w9CO!ZIOeXyaLiqo;h4J~!!dV#22g+Nn7bjvF?S<|WA4Tb$J|XAj=7sM9CJ5g
zIOcB7aLnC;;h4K6!!dU&hGXv549DDU7>>EyG8}WaV>sq+&+uBsqu1R5bTv@tPt^7l
zzaX?fd$8yWXrvRg9tg9FM+7iR_(I3uy6ZR$A>$mL-E|5GrU8`c`0W@!e~Tk%i|#Qt
z2FGJ=j39yuL@<L077)P-BEYijAQlIR-~<s|Ac7l2@PG(j5Wxo`_(6mKh!6x3LLfpI
zM2LV0Q4k>pBE&(21c;CX5mF#R8bru|2w4yz2O{J_gaU|A1QALgLK#G;fCyC(p#~z<
zL4*c~&;$`$AVM2N=zs`a5TOSm^g)CHh%f{ZMj*l%M3{gGQxIVWBFsUA1&FW&5mq3=
z8bsKD2wM<g2O{hlUdwv+x`Cq6r}HB;|02hq=W#a;Q2gPmdQsyq+%XKizb3%3^Bj2n
z+E>rcKOV;qgG_<chmH+3vY>N#qCxjR_Esa!*ntj%Z3ETD&A%0jB)ocgv^^|O@Hc~t
z%+7-zj5mEOUzU}Ex{&uhG|zi9AO8=!i9o6I9_V(G@AshY2c5~x%Yb~K^IMPR|IGYN
z+Mo+0!1vvRfaSpo;S+Sc@CiCz_ynDY<>}H3FF|!Z=wO%ThYvh@10R6f|L<7ABWR#&
z2?Px<Iea_D3~33x+zT4k1)p5|zyrEbqPGfiz{~Of;L~G4vu>iGQ@VUa1^5M7KoyDr
z_yA~8@Bz@GpiSNapiL42;LB1(!4q_%pl#j)pluQY-~*sV!4q_%ppD)Fpp6m&hy!Ei
zgIojI00;`1gyv%p4!&arO$|R|_V|7eG(YGf3YxF;5oO>PbP)he*g-b{9%C$h=wW%9
zzjYR9g&B(k1L!O;4&Tli6#>`I63{VUNAL~XLh`i7aduGE3tDFY?&Uj%d3J)PW+5#Y
z&u%-9*8e4};5Gwj?c#UGIIuE^X4LkBWAJEsi&EZtSpF!J<_||b&p{Bn9^-h?7i{G$
zYW@VD2j<yr2Q5fJ#{wgm8c^nF@d_#(sZqSjgNj!l%MWE@pjZQ+H{i%G2wrdDX?d*Z
zGrocqnj=u-4^+N_&l^I-p>KAb2KdfZN8j!=317zNsP(aDw~Y!kUOl^OR1g(wjfwzF
zy!nWQujQZ8E1>col6jAC;5xw)#XZN|GYCz9BB}Ri-VZt)jiFS-qj^8L1SpmB=-dtx
z^XQxo5<qXegGLy^rw77%EHl-S=Yl{%gk(Nq{snT{nP<0~LbC+}e~Te#r(d_51ZW;a
zwTr{iioaA2(nVuD16p7C9efTMkAR~Uk2vTW?vhu&y=fA@-F^a~9<dGdz}Wwu-7G&W
zI7*elE#l5okov6U5`W7b(CJv)L<}6QM9e*U%NR>uLFSgu7oG8h-uwn1A4FbH<cWO$
z8~6lA&~6t`(ETM6-n~5f;Q9|V&FBGIu=3K!@@H8sXr$&nwElAhUHqot()kWr12Uh1
z+-Cq<e*&3wI0n6shrh`hRQ*BkGXTkhsy{;OQ_hxNe8~(N=ICTmd3gym00KLT8c#h4
znppv_HTCIy1-^9&dp!u-{{>pFA`Uu=OdPd31Ra_#;3JM!9fA%`7w{2Bs}9A%)uA}H
z>Tm&~Is}Ik*7{H!R3Gw)V^)WcK!=RCc0=w*&|m<aBI?`i#^DJX=sfs>*~juAKlsqT
z(sWSY5_F_y3+Vg+kJb|<_8$CuPdI`n?>sL*^t3$4-v&CH4KgI^dHI2-<$)qOv<_Pj
zsPzNA6UDRhAo#4)bD(^|0J71s%S{4&a91JdKyrZ&mQ#*hE-H*2E~gkl45kj3Q%oQR
zbBD_*W)Op=!{rnUh{4+7a*7qiVC!%>#Rg)qcetEl_w06)z<szWn%hukK+z;YJA}dR
zL=y+Cy)rxro4Q4l1Z{-z04>Hl0oDr2%&7H$vpoY5GZm-~Lml4)^=~~p|M~XT6+ni=
z-9Ve=*?c?e6!yJfhMs=uc+AZKRNyCohzthU39BC6E-D6|oo(QI;WS)SK!^B)XP6)+
zwSkH)B6^T0<&#IJxkooxC#Wc5ag6@|09&064GJ)Ys=u4vqq_kVT;%C@3=8n--VRzt
z?%VpUL<}^3;@QpS)A{{>fQD~(83*X5?|1ksB^38S!uP*#w>jwUcD9xSh^YlwFgkYE
zLz;fA2SCf5K>f8i$9UYnMlm1cQ_!{4M6Qp5j*NFZ6f{^Qmbz_91W$iKmt{cv2Q8OM
z4EeW-a9D{Ldh~+UW1*^=&~m9n6h+?fz-!kHjISLbwF~rEKkE4y#lKjBg*5rF0C13b
zb{;c4@WF?FBlvjmQkM;kZQyfHL5F_Ufx0M=={Q(SBe%ejr^=AbDB0s<`Jwa?Y>uhh
z!sGZcP^WG}LybA8J6Fb7`W0+7G?VYshMiUi)zZBKlwlxB@U446b_*y21a$t~4_Yr_
zc%Tzf6oQQa$v`kl_#6ZKlELFRga*wp;~)J;84u&%20pnIGy_mdc!m_@K}czi;vy9H
zcr=4sFAOC*aF#Zlr3Ghc!dV)I2VNUMXH{P-!5ES-h5(Gg4rO?BT5Mp%l4>Af10s>!
z1D&h%umn4*L>tD?gfaAB3}YC>!tlV$I`BC^9-Sv%n?Y@bw4F3yJka>?Ybh8Hw4&=Z
z4~z$zE{EhC(71qOC+OgVn~;sIhZ*;QqDk|bPx3dvUYoB!{{R2)3EJ3Zd7`+o`5zO1
z&s)&m9nk$z8a|LMF}{rVynA^*fZIj-kRvKAyn97%cvxQKZv*c;`3Ci*S1%998s-W7
z+d>Tgc8C~&=zkp{2B6zt4F7k87=SK+G3*F2U<NHE@wEJ2di7;369WU-;u6qVcA#PF
zY>*3j%m4ef{)fc1FTekBPw?RqdZ5)jt^dJAj3>W8XpH*5N3V#1N9T1=^UU%(e>*ow
z3FAGVUU0hd?iKmy(R}DXl7d%^3=H7FG(72}`OAaf^Au=jtmY~2UYm~|mcNQcyn00}
zynAhKLQQM}+2*<H11RVH|6lK`cnEYzgh%IjkAv@7Tzb<P9h;vpLr!M`-9HC9mF@|D
zD`@-F%W`n@4Ri_C1CQRY2ap}otS-=_>^wk289d-4A4;oUg3j~<2W#`80#ER@H|Gsc
zLd#En0T(XNcsLj6z6uV0K_3p#0d-uU;cza{a5x8O?1BSyKphuoIGhVK9L@n6x!?dD
zP{#!t4(H+*bm0IETW}PB&iw%$e^|N#)Y8_6S}FjVgM#h{0@(-E!~(GnGzJcydV1n%
z`JKN7w9Mlr+dt50MLHIq%|}0Y_wsxMpFq$XqVnHE^Oxa&<n>Ve0xXuGQxa?$_yt@n
z!RP<jg3kZ31fTz73p)SD5`6xT?FEnK;|D-%RYB+f+y@=8Z|2#2{DY_Fe^18aFiSi@
zN7daiyaeBW0h-VS9WMkrcH#qQdc5?lujPdjRUgf3NJ$g1-k*P)h#};{OVIgsh=OYa
zBkradC||=cQvP-fCSpGfq=JCyK63`Wyd~8<RP~I8kQ2Na9{m3g+DCryg*s@LN-;Zl
zwase}kIo++2VdxTfY!sZgBP*AHu30fXZY~{zsJEBJRY|H{{QDK=jGpa33QPugNNpY
z*CHMV-)kBk@M!*Tz(4hX2jc;c<^!xAj3x)M7ken~LD^rD0J>L~!=qC~1+p#=S}}ok
z3Pga85Z823ap2c<Q854!3LpY@Qab1$et}(}aV>CB57|-+KKTCNOA*h5FGPI0eN+@Y
z555!u9aXR4dGNi6Pj`%pf#<>3A|Bl_Di$7KMvjVu$HBKEper>!JP*DSfnLq$dGMWx
zNAnvFXdf4}9*F_Gi1OM05*3dBB`OmC!PU59m}5|AFsLwvxT5(8d@Z-Ni%LYPf=Ba_
z1R`etz`EfH0C#wyogaS9qw_Op>&0;w6$9`f!EqNA$U5fZE-K)yOVFwx6j}zLYYQ|$
z*A^&%77#J8xEey{p+GH=<)G5FGe?C3w5mh^w82@zr@KVO0JMWq!H4mykL6eXHh1tL
zH&1*!zq=Z~McV)G*k$g(zwcZpWXmyUIe+uP3(Y_I%iLdrj!i#vrt?$7q4^EJSj)wl
z53U4B=)Js&yo3WJzrW!ZD}Ouaj=|=GC!2rr^S6VJ+=le$K_}HUA7lhsDgg>4&x21{
zJdzK2G9LBpJkP()5Y(@B;NN$x^K!%C3k|<H%lVoQU1<KrUv}-a3rKzE2bTFZtmP8T
zhgO0_54_d`i6XE=!?FDi4gWyyJ9HAHVjk*v4QQ{Deu<O~ca0c$J%%IyHh0j*Y(^XX
z5*8b-`u8^aj{H-OyaZiv4l>oD;a?DcD`-8wV?#Y-F@NiCP^+h*o~f9>6|}w5v7w&X
zioX?fN-4OE0<Cv)<lkoRz`yT2JP^6Sfyh<-=(SPjFO=}(Dn9pG4rC7ugXBTsSH2A#
zc3j2lJbV2a4ZppXhN$r9W!dJDe95EN#0eZ=me2sZ4i7M1aDZ`^U43nO=FFMSA4uWF
zS$5#H0>m5`>CkX|zeB@+)^d(!P<U~c&GR_;jLW6-feIu4whKO;?-9B2e~1dl1jhz@
zF5ljI#?o&-mVf!%&;I@YAJo?|1LZ>v(0(Z$pU&?do%g`Gp!vuDk}y~~&<tKU$WX%V
z@%{D(4@U3|GE5G9ia02PIS`w{U^<a@o_KWL^60$j+xY=(H$1n1cNy-(b!jO|{=`z`
zp~yomZP)=`Zd1ayAJqIZ{N@<_GE|%a`$!#li2+h2fX;^;9_?y)5~>EpK1l!XyGQf?
z|0S%T1A2tOSCRZL;R1WHo58V@-KFybzHTy#d0<^Q7EVGF1d4i){h)TGXXiK1&Obho
zWgNcUwV)NorGj9ufQ|I*Jnq|B%i!7T{@<td2Y+iD=#WRo2cF;Wdnz8^4=T-eftsy5
znFK)V9YC!sSI{^cbgdgGmAHF!gBx)k%{xI8QVb<BKApclc<>(t$DR-4FOP$-L_Dk~
zf+UNraaY}7=X7&4|KurEGd%G68Z;Gvg~0?C0k9RWpvB++VSA>afq^<+0;(Ed^Kak~
z`49Ins5R)>8~5L*^)r9#KL!Q{|6Ub4pU&qVo!7v&dUhTKk3Sv+1x)K}{ua=vqYvY2
z&+qp<74P|Ue)iFPU19*rZHS!1-vYY#0-EGJu;m_K#y7r<-+eXzlz4%be7pL#J}Gek
zU%>PXY%BOyXz)d;(4ITY5NXfvcRu)l_K+|zyyo-md<QqFbQ|bCXYdVCF^)J+VFD$@
zo6vBCR;v4!Xd@3Cqe(7Bm4rG5OU`}qS_bA{Bw3%%M?ReoVXJ7+%tp`GR7k(2WuTin
ziBG!`q@-PU+-Vo;GjP-)h;CTJ1vQ0YD266kL$v#;u!cu4=KV>~%@oj^g0SA7<kMU5
z-?Q}?e=F$j3}41)o}EWLzu)myeCE-5pi~&SG&thZsSK8S1IhP7sQLamESq_NvVIhn
z;QNG>^+6Y-!n1xZOtH0(ib1K92mY&vz@g~Ut>M`Gm#5U(wdH?_o#6pw6H4|Wha)l@
ztQCs@xUlf-e7+CVHiMQK521>|a^PtC?$i0tr4xKM19TlWG<wc}yQ44D{=tsvM2R2h
z)~412{8Ml(QifI&Fym0iW5I@l9fQ*d6#Iy-??99E3?*s}_WGrY4fTu#rP2-cOhu)l
z4fV|VrTh)`EXk#u4fU-0{8J9#*aro3FpB-17dt<BbpG298mGX&tRJQw)xVBm9?fqg
z96SHPN{vnz6#>WQe@yjN$6Qp9H&cV#W*|d6lfNBvG2vz0uL)jg1r997&SQ?v|CnnY
zH`J)`GL-P`X9LN7gSx1pMum@|L=Y?po|;04^TWkKV>D24m|MULh^1Y?2SG>>b+<Uk
zeW>B{6KpGdYz}|b4bqMlKCt=BYo49o9XtQLW<0YWR1t$t8hQr4c<UoL0GfaNFXe}@
zELckJfG_{>m;oNX#Bpd7*e(!(;$CojAq2X)4Qd~_iFClFlV<jT_JcLPnE*O{rSlss
z@H<;nKvgV!zq(`RamVKW|M^=$r?h}NPaOL}ojy=NKw2TqKNx)_pLl-1;=`Sy62afH
z6J%cVpa1+VXFzo}r0L_?T?*Qti`?|_=sf1xS<2wi>-OKH^#gw^$b28h2Oi(=c_<$9
z>@;&V{ATzcoG-z1Rj!67U7^cCL4}_uzsoUrdDH`TGJoqN&<Jwl5s;4vRu-`OS5OB}
z{VRe`Qdoz9!Q=QrP@~NA_yG_FP6$|vKJc(6SP~TRP>d4)9*}tG{D~F~$N>%=W(IXD
zBAS0NdPpAd=mr;@9@bO90Z=OM@%@4a=LrvJ5MYcjBRdWM_zE~ZhB}6TE_mv^;@Js4
z^!Pvj)Pn~fvNWG$1XoV3oez9FA=$vQ^QdR@-~XkWU{AV$YF@CPT@Bwtg9emdp80fs
z^6C5uR^!w80(TUFLkJ~&VD9l~eq(?!NTLBY(WCP@gl?`;;b16rKuj%^@F05}KBO%U
z4{H|{0e%5cQOW??o&g=J_vtoK0S^H<Zf68_)apR<ZUR1xAACAL`dU8aZwGDdK<fX4
zmH|h3bQ^kf2ZGLE2mlT0NO)LYD^URN>r(<vp@IfkEwAyngXX+_ET5IL`dGdyRs!ux
zI|y|mELqy?BPUB&!~Z^(plrubVhwVOnNN3$3J0jw3hFfabi!M$CDkxb!CI``NG(>F
zoHgi(0#}#LAD~kTa7P2kM;#vBf*#$4$Ugd18Uk|h!<U|*h24+|8%W4wwohR#P$GJk
zpu2cv(L%uzHUELf;6Ih2tI|YO1#uB9Ahl2=!6^$uprkJk(3V}?Z3mDJB=sKM?%*XG
z`5xW;9?bp%psTS1J-RtOI{7@hJvcl%{Wv_jJv2Nz{RBLYyMfv}4BZ|U%?}wpI{h@d
z11!EBVk+VGXg<jV=d+Y>cr>460r5SW-6aAxFoIeG1XrD)rV@}V5g5t6Nc}I5<~JI!
zWYFoNq5z3FT4f#R4Cns;{Gb~dz;=0d9*0IUwAKfuXKT>eass}LUwwL2L7iTo&d(Ek
zEMFHpcyt?kbO&>I^g0KChC?Ml?Z)S@GQ^|#a6st|sA;hHMhz0EB;2b1CFc7;j)6@A
zgFAYl4WF<ufn^(k4<3!+5`po<|Nr2kz#29G)qwKf{}M?4gVlupOUls=;`aQG?E+8*
z@D3>r_@E7DgA(d=aG=2qh4<}tfjqGjL>M0M?fikG_xH=E^C!`xIw<J{ZXxI@-4Z8I
zA<%lM#0oS&W_SQH9@$_OP%7O}#TZ^H+EB&hQp(>@#cW%m4R0@k^fVvj0NqA>1(cYv
z_^|m9i$~{$*H6KT7R7#thX0@@F{U1{QZRv{9<+9oqro1e2fJM;^Qox$!2^Dz0L<5&
zE-DV7gU+D2quWJA0hIbIz=QEDDjvsOR3KXyJD=|ZZNP!XQHY9wN8>M$0Dto-a8sm4
zg##2v<w72qD!W-!JQy$R1StodByx=NoWr+c{3Yd}9r-Pw8{)tT)dO*oh&gC`cH<$?
zlmuvf1U=6a*#UAT=<L@6Y5esrDgqweEGnS$nY&$7EI<oBGCaCvR6u!H0n|D%@L_zJ
zHo*h5Mp_S4>vdcBbUSc#2UvJC9{^`#i*JWmO7tDOL{zMVOVz<$gEY|k20PFhMJ84v
z#vY)xYVT0TpFw@))zD0VJ+pgu+WU60Ic{SFji%azW;{4RqdTS^o%dneL&5nSG^P%V
zYIuG}%BEnC_*jFtUX|GUw!ST~f)CPS3^lcbA{tup!3@JOQ0q`?4C&N(;K}x`pyQKn
z^S9dm|NsAGIWaXXD3^P7-oRQ0z(#goK$0kG)rdL*gqoi~>v<dmh|hoB?9CS3cq>qJ
z^SiMR`-1Z}h`?0eeBe*>5B73?j~UPjOOI}rgRfyL4)D1Z!@SO)&~7ZOQH_01JV+l5
zqqqm$(Zg>eih3+c@s3AeQIBFCfwdJNH>0QrwVyqj-zb24v&fx(3DBe%Y#mgoolj?t
z3I|xorSm&D&9ojU^@n8^&>@Yb86M3?6tEARL)H0o8-TTT3qZ3gsMdyTn*oaxs|=D_
z!CKJAlR<ug8UresA-(|j(80=E50siAE^+j*bW!2ppMpGoB~fY&_69~5$tU>$)X}gq
z#!?s55(gU#l>xI+#|yyj>HGofk#_p1NPu1A(Ru7eG5Fk!5)}@x2v~FLfl^a6_mw!p
z`~wc<0P>v&b9gw|;b?0d!PbM42Nw53OEJ(X&)_7mA2c=t)<F00gp5zYLIgB8<+%^k
z!v<Zf3U(G~AXMt_|NkDH&%k_`Gj)6{O;k#qVLHJ>NkO2!=-9@Qh>2`iXeQzhO|<rf
zA+AwKaL|JZjQr^s0veNpxg6|g(CpEFpKfrQ*b~%XXgyHMhdf>kYC|0G>1Ao~1>LCz
z+5!n`x4`mqi3zASfkrDRDEM1J=kP!(A<zn2tP37px>Hnm(k4Kr=&+1G$%4bW88qGn
zX89yDcsBpwD@_MYZ*Y3d@BuAenR2Wfl;XkTfsm8yx=U1epo4N?Z7`35-PMwTUeiG`
zKP>dW>VkHRLIxY4xezAxPnUsVCm(E4A2?{i1V;FR^C&bhz-b(%*Hco3Yrp`y8UoZ$
zv4E|zYz4Rc;j><#(fB-=hv2OM&+qp>_%MRI4dAf@k4|upf?t3|g<lZNgbp>pbb@of
z6gcN&jTxxVQGyTNB>)w&pFm?1uu(G95Jau)&tR^vF}$=BWwrsme)8!2Vff$h66#c>
zN9Qq^I*-l^yFlw9LAz-?kG<Uc3^q^?j*T;CJUTCcPPzCF(z4(gs8a==$OiRsA?<NU
zGu)@!ox`W|kdNl4qI!>Rb|1?hrPAKLEOv$`eZg1Mp77}8_vj1<wd_j8U%Pqt^4R$>
z9`LX{SegwLE-?f}l@5414^r!Zq9+3u$k?I>M|Fl8f?j$!)1bc|1A}KLB%Q<TAv<EA
z;ROp<C>OQ7Mp-{3;M#f4rSov-S&z;T6%NSo7`RY`c6%K=kGr=1=kEaR0N`&0-Ob+o
z_kW2FBs0PW>-R^2hVCyJ9_V}rPG1mN7_a&F{}Lmx5V*AtH5jZ19O;G!pwq8lHE^C|
z^S}QkCSb9BpvnYAA4I^V6B0*YMW9haC>NAJzz*@~Jlg!1xkjz|C?m@GEX_y%L-jyi
z-29ih{uN|>l1F!l3ZxJOFVO{?0~*CH6$LYqq6W+d1qXEQ0@=fGA;_8xuxI$8cEX$u
z8AQW-wgEH(p)mrFR+RFo^JC{PaA+DH=)Bf>3hXKZa~3H2L8~SqGeXv&XoRLjyp38E
z{gC<=bvg(%_RO=Nn}LA=w78SO)$jl``as!9zx9A4|CD2}#11ONOMPJ#3zow$z&`3W
zfU0k{U?|asmS&)FeyDq)g)_*olFd+Qutv0MtYq5jhp73X^P)%Rr_O(1*CHH>Hv~!W
zKX|7IlIKNTK$RKPFCJj$n!kpuUxa(n5!_w@d6W<86Q}{m+Db{7<w9|9^M6LXoh|hC
zGOYa%vm8|ad3OHu0Iz-w0CizIT~v6$VcqGXBH{r(P!H6Y;PL2uxDPz{bqR8y9#~cD
z0sdCd@->fU8x;ormNyIx42X6K=%_1DYo+<Xf5S^2-#>cvRxo<-um1@h4unqDf<^*C
zs(N`CJQ@!wfbOho{0TZMdk2UB9kJlC^DH#;czl28aqtzB#}4QUV|x$93m&~J4WOg8
zQ5*?zqEF{9s4Gj0Kw}lYopzp`ZXBMSZUV3n0N1s}c<S2Z6VP~rH8d3U5r^HONhzU>
z)_Y)RHO15lb|2JtU<zI^fO%-`$<7}v7i>7oS(}evcr6EAna0|DeC2Dw&L1rMn~$Hg
zVFPzb`JI0>|L4MbQWr}4@#r=OZ4@^=fH<@Q9GuCgJbGCiLA!yPk1_J^3;W-BvEkqa
z&?PGZ(8X~#URyvM2$GrK@DsdVaAor^&a!=I>+vo&9NZ6*hp&&r(y4_Q1twA4N0NU9
zNb#>E*s?Qc&VUZK@<=}A!FU3jcLl-T<uAMW+7hY(&A<Ev{L5c9j|Bgs*5{s`-#nV@
zJs9{~cZ0HKH#?}0%i+_V&f(Ktui?`9yZJGT$HCW3E}egypE7w|e7hgC@D)B~>)Ck}
zyh`jn=z<9jpUy{}Hyt}6BS4<bbp{Nc$6Y~#><lHEp51N^KAjrAop}zP-EIb;(+E8~
z-3%PR9cL*~_O(nCD3<l@OcQu54pQOUnP&kmFJMYa?}AR$gpXwrKGtU?N;ZLpD~v*k
zf5>?ot=~#Q!TAJsESx9kK*>^1TrG9@)SehLmxD4qbY>5<y&2lvehoS>4s5PxHydc{
zBzV3aOQi*K8kol7J__A|-&z#=KnDnej+(?6uK+s@OrWR-mG?f~=04C#3oB5I*wm-H
z9@K0uL7%fQf`%4isT|T^D2}Evw5mpGNr6{I5I^03T7M&@|He1q<3FJmbhdyG@daJB
zq5xXt4LS*{(^UdI67Qm7;BnkV1$4|R1E>-(Kpl*CfDgu>1?8f~8WjuhV7v%cwV+Lv
zLv=jf0o1)T01wFfN`U7N-h=L==+03w@aaua$?@ooQK<nPTFL+ZfJbMJiU4T-0DPzz
zvn%LKEB@v?pxPHSckRdlE^9ox9W}ZGEj*eJ26%M(N;rb9Y2a_^VP;@xe#GwE`rotj
z+c6iF8U|l}m+zlJQvxyIiGcveZ%24Qy$}gdglUvSA9GR30bP!e3nKDBL_UZp01<^C
zq6kD3gNPCkQ3@i;Ktwr+r~na_AfgIHR5QF*1E+Nm;nVpLr9beQzaDzP&&{IGo|?x#
z^Vd7GcpP^Y0hM*2D2FuATn(Q<=C6D@pZfHsGCDTY=rS;regu`CKF|>XPtXBuEvrEr
z%)wiAntv%2$$9tk=zwp02hD4=FfcH9_40r&C;#thdA1mQPT?~T&2t{j$Nqgg#9X4%
z`KtL5Gw7BE*m+rw{M%x98IUh%c<a&pkD0#-bfdy+63>4*TYBLoH)w99^CILXhQbG+
zgQO0=U<DmL>CyZzp;*xHo8z|w%>1oApv!g7gR(&9JCEjP4?LQWJ@7dAj<vTAasJD9
z!*7oK0xqWD^IuFs8{R>OhZzWf1;OXPn1VLEBVEv7>HyjsZwlJ*4!xk^vm<}Liz#@=
zyJ-O^QJ`PZFc;*W5)Y5&V*;J;o1Z5%AAfN0J!|uEurt2jM?0SwVjO4#ypJgZ*f`LM
zFwiR;jx(0t_pm(0-`e)?|9?n)IvsOS0A0N8q7ndFwh;lEiIQ;aJm=W_jK%ZdJ0{1@
zGmgzqm^?4OL9H!4z_q0ZXuW=kiUzpn=+gPowetbEhVW?KqXJqw&ENs6G}S%2TU0<x
zj66CuJUZ7vnB6U4RiFwKzTW^Q*SQ9~ItN^Jf_9P!fU;wbXXhOdUE|RS(fZ9rMS`V7
z43v{OKm*nZ#as|}r;AF0M|X{i0%%MYl7>CHeI-Db|ADqlfU<k5!5`2a^WY^nu+}Qt
zJa~7EiUDX^%nalL3y;>fB|09R_dQ@;=O6z|VlZj}kMDOscrb#e!C-RMkm9&h*`x6Y
zsF)_A@`nT?v^YnqFF+Seb-wiMya7>wI@W?QT7}*o{^-&93%dHzqm!r}Ge-UB+4;?}
z^FMsPdjCmq&)KE(pHJr}u$xd9_uU6KusvpAuMpAP2RbRP^VfbY1_p+GbN>JTPeh*-
z#eL}d9l=}DU_D5z{d#o$oxh+9^*XP45Hq5HqTds8(NyQJ{Z5QfFW|Kty}t>H9ap%{
zlZ5nw%kyre@jy@T;mrF%MI$);c7g&CzbPp0M<46$`~j)f;4}B2>zVdPgJawS8r`i2
zN?5vGR5)OhIMzNY5~X6`9wJ7w3)=q!Cliq4&zw24zZ_)RNy7s#K@|>Wdg%PMKOCgu
z06Fn7!cX-(=I+37%-xaUn7b3hF?VN%W9}{t$J|{Rj=8%r9CLSPIOgubaLnD4;h4J@
z!!dVnhGXtN49DDk8IHO8F&uOEXE^2_z;Mhxkl~nn5W_L|V1{GvAq>adLm7^_hcO&;
z563zajgp=mq32Wi1%Q^m#evIm$SntYu>LS~$b^LZ5pcEtp@|Dtk|Q6o4^3+z3dMaM
z&2I!eI{$%hO+Z|l;DBZlDVHXIlQyV-hpQKhV!vnS2@lYk^v-|#rND_Cq8)2N1#&!k
zd9h!epf2<aY5t?!0D+d@VB>+w1dWBd28Vvoj2ix82fKb~`K`bRI+GN1G9Td*7$rPC
zU>*Q>?4iS>_(BuS{m0n<A9H8?f6Sff|1o#w|JdRX#Xhw1g`j#+{}Mc38Q}<?qlC2&
zI$cx(TszGjkGr#grfYqB(>Wlg(ztVY9(R`jm5ks{8oZ_59WLR~_zTo8<8KFD+u+$)
zF970|3u34PPk<t=n1bECR0?VWwRD22T98hp6;q~&6;o++y?+VpR{;hFXcqSDe6kNT
z$O@XGd+q{VGYxLN>|$VGVgLz4R`5D@y0d^<9fHt|i<l3A1+cY?N<gWMNAr;gT<4%c
zwSqGsJaMAuH>Cb{^P2$32I}romgax|`CHgo85s716aFQ`lZFRCd!Zq7DUkN)aR<oS
zw_aBc(CDipcw)zKJ0qxLDe)S1TM}r#FIK|U@V`g5uYgB)sRZa8D$Ni4ZA(ENk!}$c
zk8U9k#!sEcIj@7xQY<L|pKlG?dEfy)*Wr8f19p$*|LjGE9*oC4G|#0?IL5?q%!!fV
zm=lO*W;o`=!f?!qmEo8Z8^bXt(0wO|;P;&zC~@-megmyPag2!pbQCkFiC+5owW3G!
zgC8D@7d$L4l!=1(GlPZ{1ew6su3H`|`Zxj9@AYW>2})A@ZF5-|7`jVYJi0?U_9K@m
z$tS>x?=7hN-2C%DsGZK?xog%;Fp%VLIl#=o-~u|Q5;O|!)2#qn6t3XeE5hU2`PtL*
z3iR^c&JYy?{$?{K1_q?{<c|E?V^lc6iN5&<qbtA5O>hvgfNn_a@=@XKJOLUK=5PND
z?xwn^@bT}v*jx0y`5$XB`1~aPZJ_%!8R4Qu@0x!pl)P;Csa>Mp@Kd)`ZYL;*^6wMq
zExOSBkF!k4)$m*ENl<Ki)aSge1zn8-p7(*PD8B~^JJ2LQ_`E=0%WK}fCT1SJCfhtA
zNA7s?JAd=w-*;)RJ}8bguX<R%E9da(H8JvRK6ZhBpFroe=3^H?W;FlfDmnnQt4<iP
z5XRH;m=C}6hu6}et(4zy__luY06P-2>cgkEkkN<V^Mg<4H;;qwID9%myW0dn3J<=J
z@ag>QaqzW*Pv=*UgKsr_JHL7!d~4v_`Q7v2dkfHnvPZYSfG6x+G|&ympw^%TXrRKO
zv>22!!6&38fwup*o^a`mQ4xWRUua^Ul@<jGe{lT|Ju8jlWh&?_7SO3^kaK{*i2!6H
zBz6(W!KE8ya5uP@$?nk`$OyV8%%#KRghNNk2}V%Q)1f2e1QUp1(GhZjxg+KTi$h1w
z309YmoD*y=9W^J|L2?G5#fToBjCVXOukbfr{rmqv<S6WKpqrH)!JCFbojeKtmIhF_
zusc-3qqm6x#I$x%QQ&Vr42qpz86gkLTl~#oAaToBfnovB^@p(S=N=$Upt+fD22dX9
zya`&N3N3H>TR?lb!O30{q`9~FKT?rv1S)bhZ@p$bL(2M8{+4sU|NjTwdB+JavOvRG
z&9M9KUatF%ww&OMN4L9xtKomw&U@f|F$H8mH-C4@!5<!-?_HtO(cl!^a=?Y(<)f?N
z|Cjk7Ma>U?crb!4&f{;3`2GJs?7Tm4{$~K6fo^%C=;KS9-=J>Wx7Q+|txJ&JDPpP;
zGSeAAME4h31?;27Np#Sn9cCo*seEWsJB>m6#X+lf;q?GYeGjg`LHoa&-y}G8egI7c
zLVM_)E-Dd@-F#3xTn(Ric0PqyUhl!C`S#XvfYJbq;YsjxJ7o2H%Yl*t&u%}^_+v?m
zZ?~HO_z*%@&<U2U;HyA8Pk{11e~T9+o0XJeW-cG}%oT#>FJv#f8a_d)6(jgtK?m-*
zbUpx`HiCOoizg_f{`Y~d`vf`Iv)hdWlp8%e!z7Nea4>-RkbPaRk?xylsNn#eC+5jm
z`qiWPCtHz+NAtm7hKTcZ8f*l(O0^nl1Q-KKl^bdVm;y>=8fpZXGfPDqY6MtPO8FXU
z1X!&~458;0fh!}+Q)S1|{n289z80$Uq6g!_lIx(X*nEHubQR?RM*eLa*ot;tP|>af
z3TVjr2>kmjdi^gn|Ku#wFua5)X<b_n)R%z^c}7QYVFp)MegmZ0@RH|FSS{vbdCH@g
zN64d>r_<y3AyB2^!S8&^gMZ)ueUO6wpNHkgat@DP5q^*6Ll^k>S#<tvJ_sr3e{vNa
zK(V!s)5G$R2fx#y*Mgun?)RG@+dx;#^LriyEh(6K1SL*ebU>E~ya%tKL>b<qMs|W1
zHDCrt{_yPl=h$5aY7>>9EL`*Lt^-e_nEG~?fo}2z&8MKO1j9C;0$&M+efS9GX{7Nn
z@Mbyq6&UFG0Oeo+O!s^20BsYfug7t=21o;ne@RsjE<Zv%8sE$S*L~lS3y>C-37{Mf
zPF7B!x(2kA@wkf$=oVtgeeIntDl(u{-&><109s`NK97fEA85lXWd0sp%z&1eXnHpP
zm)HmDH+b?pefQ|?QAq%ediR3&JsKW>%?tV@KY)dxHN^T-C7;d*9*svp?jx?Hj2a%D
zKN~C=K<6-)eg|D@4m#jk+oSp5KhSA&tf1gK<HEm<!Nc;0N3X;GGB(GCANr+lJ$gNu
zK<W84v#a3&XkLMjFE-SOfy$2{#?r4K)gJsV2SGQTD;S=Hj9>F_v*B>Cvf(S0a%lNq
z0=iIx5p)s7i!K%cmdiFw{F4Z55Jz!8O8Z^_)R^J$X#LOM;tdMDZg&3d0T!UfJO6eE
zGyd%-JowjN1YO|{ItSLHTSvvCyH>%cS4ZC?`IBF-ik=7Kd(fpOP!Actg}Ar5M*jn2
zDYr+rjJ}8EEf0S8%N~qpJuKgqJ_GHJYyn+c0yazYD)eXswD!1Tb1eg7X{~Q}t$-)v
zd*AL-4PVB8p#5I0-%7+mw^V(<;i-5Wx;?nW>SaCJ5|d*doyHyzHLc&!HWqty8c%@g
zEcNnaJm&HJo{!=;AI*P0o&Q0H@qk+6P``UJo&~wLH5XLq5_d}tICX*vv|PE!1hiBf
zw&EI`N)QA}{4^i`V|bwXKYO{^&g-Bvniu~p*6~O_j<m0#o1ys!W2rcFFcO@Z8Y&YQ
zN?E}p!B{%zDCU#A{upC~6Lo&pquZUMy8$%ffAK~01IFe9_|J9(`5MJN9^m~Ur96!l
zETGvG{;32KGkSlOkbgn$^XTpX-|^V#FX7Sck>Jtkui??%0J;yxqtjghiwPiCA~1@3
zv8bk09)0}km<4KLK{X$A{y->b|MfS|&i}54PkceScM520J!rqYE$Hqp{&vtTB+@ch
z$1RMl2TF=S0|<~~j+!m_N_?P;u3QbDfJYn*FG0t%96OIXf)+kHLE9tX-3g!phj-wa
ze8^gBkXcCQ8-ONHh2Se7Aqzzvw=lYNKEU1Jf`u@2SRBShO<&;p1kxULfUE<CmFJx<
zDxgE;`CAM@XI8d;<8J{qDIHq=^S6Lnl|H>WDjHy?`#|TiKr7QSn4m`}qizc4ZwUq+
zHrcJB;?tR;BH`Qmgui7nxI_$55%6Jr1ZvMdhxG?MEUy<=gVsrPyK{In9}n>8tWlBh
zv3yaU23p?M`oHuZTJA@kaf6f(ozFZvkAs;YXT1m8#i9b5n&j|cJm}fU@7c))^C{>k
zFa8!CMh1qL^&n?jzT<Ci0yAFlw^f3*hNx(Gbb^LMJS;zX@VkBTXapUZ<N!Ky!NG&y
z>6~XLyNBip&rUWUOYoin{+9Ego4-K*1P!i%4zmLtrOe*~I?K<e6Mmcwcw1aP*b30P
zTL#!l5dM~aP?Gx&Z@r+p6_k}<US?omAh-~Q;9h&AC~3|8_y51=anRNQ22aSP9Wd{-
z8iGn`Xio(cUZoKp%|{$?CqA?&3bjPeb7+!b*d)Pmho&$CRUyV|zbH$jg@PEe4al-k
zuV88RL8qS~9ZzU)4Ch&FpiG5Yeh?_nJwfAppyMk*EA|;Yj)T@>Gk8G4981}UX+EfY
z0`FHrZux=EkZGusU?{Qo>~<6IIQW3sr&r|w=$HZ(-)=j!`X9Ch+q3z&hiCJV9i{I)
zkGp|~7GKLi#*E=tgzjT-04=@$4vq}RV{Q_RKAk2i$6Qo67(IGzoxyEP$N(x*`V;^U
zlj7Xv0*zC!ks$A(mPbhKC&<Yho}Jgh%a0)01A0gbXvjblv^f}l^ki?1iUN4x8f-3P
zv<9{%7*x@FG}fqSfQA&y!K;uk)OLeRLmK0T?h58_0o~vS9&-WRVt~Fg*cLSC0^J!5
zzt4e`@fXnj&^OWI2W9-_wX6qx*aUt*G<>k+3)=o*1JFpZ!Z8L0$A)^)1<;1z3$ffe
z7(mBXD1b^K$Ob{fOV9=nXgyMc4HpCGj*HT7zP*0`J$j4&`&gdy;deUc3o7(;z@`65
z{+2jUhokwYLXnhLuL-B8<rn^DX+{PH?_Lug56g4>ZG509mv5fm?|FQ`<!O1%qw|6%
zzx%P>pasm}YC`k4=kWvoKqoqDe(=;h;PCA@bBURc<)_XIj{I)NJlbz)f^JT2e$4Fg
z{Wi+_BK~bGe2yI~CZKh*po`;6-+4CwVCHW+3o14{zk7VY?qm7Mhu{5^kLGvJUJ(<I
z=0nULj2}Ik4>B8md(C);f18Wp-wqd}zaYlH4i}?;Ajba=7o-3D+gJ=cSd2jDJ$r!9
zdxn(up`gw4{4Iqb3m_K{gO)KVK<jUh<{A|P2L9GKurx~N7<Bt6c+EOE75a3Z126mO
zt$X0v`NI>wM(96ijnIG4njHSt<)Ae}p#32potHhn-v*sT`Tf3!<!=vu_un4huX{8<
zf8f!4{DH^8_pH6~jG)kIKK$Q9^S2>l{RF=T3qQYx4?pN40~Q-cenB4_0e%e^eg%-A
z0qA678_-P!J~jp*Q3sG{09e!ktTrHxKi`Ev0VG`T*^$5A#U=qPUf|LEzQLpUFiYt?
zkW)({KwS~f&I_L3Z-7R9zu)$>yy3|2e&hS)=En)mhaVh#&Dwkz>_W8o1DpSWUxSAq
zVm#=CWgZ)k=Hm+B*nHq=`H{c%$lw3}osY5bFhE1MWzj#-PNftT1;+;PLigp&44{>0
zISionH=tEXDn1^)E-H}aZw@PXN`j8LsKkJj#Da)85D^a|5<o;Eh)4nv$si&HM5Ka<
zG!T&vA~HZkCWy!a5!no{B|xXu=1lm^Uk}f4pCK6uv{@JA4)EH$0*~X6l|-OPHXrby
zWsQmhI0eA&IpYBrbWp;vp+*MOA;o^*8R&ux5Ac0wp1nLW;Jy5y4j8EE!+6uv@=S3F
z`h91Lpj*8_H+ezZlc2r)JjmCbz4HKHcc#n8zyQkcFnLG*Z6Q4H>&|%K*PZd8Tz7Wy
z<yUYqf764|b!Xt^ZlF<c(BAjvN4Ty#1Kl^qA_7{&CL(}x-I)k@xtj=Rxf{}TXCe+@
zrJ&_*(Cf~?>(fNQ%iTo4%iYi~Je%k6?HDue3(p|>LF?OiL_i4%?ZUGM;0w=YLN7c6
z%~v>pmbG~_*Ge$(_i=)5Ej0vn3_#Ov0<VpHI@f?#p!sy>s8oP^iy$op-&|B!7(ufE
z0{pF8KzV#O{K#RCZdU=PW*ZAe{?=un)r{RS76Km3u?$|_J{B4tj5k43RT6I9B^E3$
zonM=uGP-n@sIWLTKVx#d_zrai9b&zC=RMHegoH=ut<IOOu;XN#Yg7v0YtH#wg1}8U
zNK*Cb)POl0RAm%^22ar3UBcsG8KV+V%nF*B3ILs3?vd;&;n{rL!qf5ye~%g1H1Mh&
z3(x{NNP-7v4^X?q3{=@@fL1^2pf-0);$Te$Z2JLWa@LT;&`MPe4?qvqB4WfJlI19F
z*`c=QVC^jp)b^HwBYoOi5I;ee$AZd6YMihI8ifJHwuA?wCqlweJ3+8mLW)7`N9};-
z%Qc7@1%#Q1(jNas$|*X~!WCou0u+Cs{w?;^?U2OMumd!H!BA2SZJUCYB!dIqvGa&y
z^Pm4ENuHh0;Nywl*33?O@B$a`A%T!Zi_mU8e=F!<60mO2PVGyshOpg|F3{7$V1BiR
zEa@yUd&vSRR6IJL8U6?B1ocxDJPtnOYCYh??*c!Y4yuE{71Z_f>HGm*3yQlJhH1HL
z>)W~wp2<g#v9K^8>I=5cgAE5Scs3tnZ1~Al^seOqe@hJm0|R8d(UE@}LcZld2`gw<
z(koZPCm>oSZGv|%&k_&*eFuDcRY3iT3n=PA=G}vB<nFcu9SdXb%fJ2)S|ISZ=z_`<
zNT&-N1g?fpP_&hvL~L^dAKq+-)tG0XWy#wSi2*%5ps!B^ZMXvse|zizb$daLRZzwd
z0JZnPBjn&sc%V)i()f7mfl`fb7Zo1p5TOTny`l+@^@<qX&=zZ?PAZaz;ciALe=ywJ
z8=}GiUeCA><XBjfG}A?egW=RHYY%4dAwiIXslo0dejO#u0kH8hsM+AyfXRVq0`3D(
zEtIHmyl?@v8@efX4~l)@{jwgg)B`>*3N$<f8fX{r1aFZx2OWOdS)u~z>3~MDj=QMX
zfV$hDY8-O1RHuuI#&H)F9Z(R0qS^q|(u2%{7$R@B1P{-Ej)Vd!QULA81f>;pB_;JB
zX#>!N3b@G#F$gKafF@M(Kxz~~Y6M{Bps9$5`O4Zw#i2CCqxpyjwzD%}Wz+$1#DED(
zg}{b@q85x%!W%RF!Q(dtG&xAYx?QkkXU?2~r8n4E%UT=cu_Cnfb>Q)VV2{Q(44~CF
zotIs@wx}3@I%1HL9JHwa2Ll5`!%waf`G%hY{H@-gTO(S&mB>Q_3G7!e;oEw<l+(54
z8-HskX!g6|ha7)1=n5a#7SO$9E(#wU8@@5R8eVd3Iawm*+VZVb)T3M65xnc(!}3!x
z`!Ob6k7jm8m##f37NCB%#sU6qCk<~KzD4WLdo=%*<8R&s>K<S6>AV5jmfI=v#-lfv
z(WCkB4^PX}o}Gt_Z#nXBJ7D>u&cUPep@-&8SN?4`d^&G=Xuj%|xeDr6aGw5ln4?q=
ze2;?2MGwnUWr?5*L_zmE!tZCkSoGz!cjt@d1OF?7UTy+i`e6CG#L7|gwP*5WkAshx
zq2>KCMuuaKAk4&Y%#oSlm?I0rF-KO0V~%VL#~eZHxeju8G#~m=dL0xHEnbWa49y4r
zSEPc1!35NQ0PV7EwmHL48U#9p(eh(4`!PlXP)Im7A7TVqeh<80-<9KBiRo*%GiTuH
zm7wYcK}S6wI`D|4;gmv$AhOOYt{mq|g`vvWk1>J+7-VegfeJ^*hVP7y2cEM!HXJwi
zNIv1ncnEZnMA`(<7Cp-k#p3+iLeBiyY|!wFtA^R7^Ebog4hfLipshpow?T%$^H+-s
zD2<ecx^!OfXgmT+NztI$Vch#D!RZA|V5B0v0(d3C=AqY5;Pef;zyNgMIc(QHs7liC
z>^ut@p!e){6#$8Vx=XGM;9F^0|AWtu;%@=nU}E@oKWOU}wD|UDztIUASb-j9<JbTi
zyeQFyW;W<B(7p+v)Oi5BfC}ua&ZCWg`xzM+`1?U){T|70LA?YHk6s%M$NeC+J3xfy
z3y<UvP=gE)blwE(gxSaVy74#2g!*WY<li35H7XpAn)e}lJba+Xj5FS_1sPLo>9_|(
zgU^k783Nk80Oof72hYSqjwA=G<nIN|Wk6KF1l`^Za+QK-rz>c@Lj^Sc;mQD=buoOq
zA2fD}*zt}nOrU|G4fO*oFu)oQz=ladLGj-n6cnDI+4bbNp1n5uj(b3gc7O<ip#ag$
z1J-=lr}MuD<8epLJCK$mQc!@*;_rP5DoMbGzxKuLJBamYK7<a|qJ$d6P*8Bfh9Vfx
zI5yPC!^a;Wr$mEBEimqD^yq}FI_l2lKpBsNo=?;Xny&JI#yV)a3O4n{QgYYv7#rxq
z4gMBTTiCIS-M8~c%Yl+gaC`m-Xn9i8Qw9bG8|hO2hDyfhQg_fQpbgT{@~P!Oi6H+r
z(1K7#o7~cm9?icPOQk%T4>Ealo&uFW4OWoh%I^(T{~1bDx|lpVFSZ;gUGZ9SgS3z3
z!4hW24hGO>ye>!3wnWC31Esx=pfOcw4bgg_gcUR!eZj}NMuh`(W)18}A;?HJsIsny
z6%|N59QgGUFgfsHzMi0ye2M6rLX+4&8yVOH8B)^^l5vm(U{;`XhaM4or39$HK*A{X
zIc&bqv-6*Cw;HHd@7t;7+4<e4^P$JVms$-E*};k0<MIR0I#kcSpjAiznHd;-6`y)4
z9(DYF<i9)vLrI3`!8b;ZjZZ)v&&(qX3`~q3pt&#xh6Dx%56*+oE58^R6nr>;cy+S8
z^z3%C@U(U_DCL2z907^=bXs^eyIFv4md0^$2Tb+rK7@xb{R29`{hx2Q9cWvgZ>JsT
z!X_+!*@N)QA5X<2j^B@ioL}PSdGNiFW8-rW$20RdZofEqb+SAJxfgVLGsw+YkBWl3
z7~G`<xf*6Ij0TA@uz&{j7#Kh_OdLj|%Y*qy1WX-_21}7(9!wvMM%NE&DuXas91p>$
z?3&)W`s{m{5*Qz5E{q1tli)tEdIkmtYMBRf2aE=rPl9`3`d~D=elQ=20EHb0BMISU
z!pw!yV8ux8LrL!_?E?Xi&aWQb@fsf8?iL=JH#`phU<Mu7)B4ttf9f%>UK0byy`aX8
zujW_KqOZn(AdU~e+Y7JW76XR=|Nr~&yFUPpHgb4&UiW2u=h<B^06Nc?9eN8qX!K6l
ztJelJ0L%a%69FCb>)Gip;MvLU+F8y4I;AzktC#03$k`sC`5`6mUJ)ISUXjZlmKXS&
zIl-55iahq{HR15EyvE-KYI+%7^6E8t?9qIT89YA|BlfpLMu2}?jM%@97y(8Q<9|nt
z02BW<8L^HS0cOyZiyoF2ORs{q&vJNny9;=A>b!95_UCB+$;96Ty1U7<o86_?@t;>W
z%K^xCM#Hzzn^vI>0uO%IcOI5U%VRv65C4bMdZ2x{2cNTeFn%|@<YD>RgWu`8hvlIn
zE5l1Lt^6*ZJTyO)Xn1yq3p5}6@6pY3%Bz#-kYlqu$A8FRTnUfI!5=K3@fr?~PDaqS
zEqs-MXXgu#&Qst!(0j8UfVMs#e9zij&Ir1#z4>oKv6yG)O~d~lt>1h)PxH4ngT{?l
zgVq6b-t_8~dF;`AxWJ<~@4tuUU&H@M_eBc0ScC50v<BV3X~8e(V*$E<(;9UDrZwpP
zO$*Tdn--w^H?2YUZ(4)y-?RYTzi9!wf72Rtm8Lbnpo<0Q{!I($tj|%F(iISAl<0c(
z>OA&nJ}Thx{T^h$hJXv`eoP-*27W;nh<%XBoMViok3B3e`g9)UZwdPM|Nl$zfB*k8
zFyKzV3NE0-j~qb_+fSaIKYY6lKvRw#%AlqaXrTlHg92zPkIn>-=BE!}bqXVc$39S6
zV`yMt@BodfGceRJFhKV!JpTXRNAY9xBX*}=kyjoEA8C1To&qg*<^0%Cqr$`B!S8y?
zv-7+s=W*ATlc13`Ptd9H-JuK~o!5N~|9kT9dalpkJePri!K3v)e+#Iu2ike!(Rt0s
z@Sg{0ZUbUj>p%XM``}(@r~p<;c90i9Yx%M0Yz3PSF^qwQ!Nc+&e{&be%Fb&Z`(cHE
zhvGjE%X4L=o~_6ErylfZJ;XotfWe8<)R&-p{lJcU39+98;&h~t0J&TSV!r@ZNq>l>
z1Xjr=@HFo+M&C{YpU#h1+62CxU!Z}_%)sEOcm`aR9s|{${4J9~nh(A+a%_AC67bAC
zhEbjRb&5O$g)4(g=gZ5FKsB~Uw<`l^CqZis6KJtPErUn5D+gErw8IHBTLR{YfVTQ{
zyMoUD=Wopiahi`P;LB{#WC9N2@BGcipy3M4Am(qA0<C%h1@mEWFdwqG%-;&SJ@)lH
zXpDnR_{ZPOhs%VofB*jnM--9?5C8uE|1uIZsEHcW&%kG=V#G9m8|Yp_bVGK63=sht
z0!ip#m)z%XW&yk8y2oxra=Gted7i)RHL^<__@^HCX#K?B3fijTVDOv2<s>Lq9tXJq
z)x3)!p-wF3?Z9f@qQC$DgUzc1nKuQb8P&XbAR%n#wPH0dA7-8=$h<_5W>oXCK|<Kf
z3xb&k%_3m$+W!6j-{2sB%WY8T8T|eK->37q59r`Em(J5Zogpd$;Py7?(p3S+&YM1<
zYg=Esfo(YMWB4E1kOh?~t>^h$lR?=G(zXSM{(1gp&>}aFgD>=(A24_OsPHs=WaQs=
z(vg4LM~_~fLhy{O8OY{|EDQ`Domh-~foY@wC_Updvgr$G%g=FF4p7kt%M&ecK!Ux#
z0#Iup<s#VS-}zfX)izol-~i=(s5K=jJe{8#J~Q%f`|QZS?WaetNu7t~2mYoRATy7H
z8!#Tw?A9_7B-ZOIfz_Uypt5Th$XyKJ5W3Fa3|?;swI@V{r{NPL|F%nz5E3Z@H4B>T
zK_)_Md1?IT|9{uc)4rXDKx^y{zSC-c#tv=6H$P<e&^*WAaRTIU<XG_Syx`h-lfMZx
zgxh%$v;d{)G7|&COBrSc1_EY*lt3dH?B4S*v*!K&{~v0WJ~IQu%RbPirOsm>SY4C?
ziZNst@i%27^p}J5N8{5!8&kg^LjO9Den!wnsLs=%ssDp7jX+_8Ts`=99`dx@assq-
zlfM~s$qgbcdK`SH@5sOHv&X?_1|FQ}K({<iIoNX2xAOvj%MZ{p$7zsI0vUPmosmc9
zag>q-Z1SED5R*Zvh=9p2K?_4c*OVW8W#j=qeG$}S1RY1Kc-*J+n5X5Q3lOtj{{8<S
z!>o%Q2Ok-Ls_E7Xo}C}~TUCGk|NrtUD84%ndSLOlPv>!jzd=nu3==;h{O#HKgTHm>
z&;S2lE(VzhO_K0T>)Lq}k}ARZ78E|s)gZ;!KuH>^7%87Xl*6(LNO@BhNcmY%VumV*
zn~h{J$Q4b-AeB}im0*AAHaukB4a#L6mmgzEjYVOg`?xGWm-*rIUa0|&!~qYXNziz2
zT@0FI?7RuDTepK2xOUcZz{`>aKmPxJxgMNkLE%ooef&)YKmPxRxRJjt<p-9CMT!Rg
zRws~Zu*WeHGP+wq`MO02<Qh=d65>ISYrw4rkIRoxLW{rY>vyO-KJmA`{Eo#PNC}L;
z^*Bg1)E&DJwdWyE%PG*TwDkM`|F0_$)?$q${-zX=LErCrSbpYji@;_riucVxs-f0)
z9z$v7!M)!s`2GKX-_8mT&rXK`&&~`7pU&f;Nk!x~4ru%nTcuKJh7u~p@%ZZ}W>7r~
z>J36l0E_~+A_K)Z{wC1<nc$+asQe{pw;v>Ua7JZu1HM$tKlNbC$<nfy0-%NsI8Z>*
zi#42!;vh+^EDWE4r4|I-!$0|8%Sry0`Tzd^|8}$CA#=k|X8zVaU;qDyrv6efpUzqV
zcy+hv>;L~Rd47TpxyPu!ON~&1rZ^g3NEfeo3A%?8S14zq7{%WNS{n=r<%*Y}1`q*X
z6}R9E6n;>V&)>TG@Bja=3n3=q4(0%8FoQa>&;|{(5<yDFrCJbUa7H^nsI=j4wE(rH
zK&=H>^8vJd0&CL&)Wh{aZaNfsVb&vx$2={!fNPLq9Sjd6XKsjxcm4VQ|0VbyVrYqs
zy#WH+Cgsy<`EuK5P&8w$<SV36;>V}+cu_4Rdh}kGK!O4kqFBo%kYY%nek#KZR3uj;
z0u`k=>ipqhIpsXK+Jpq^<KO@PyLA3&e!%S0S#y-(<-bp$zBQ=Tg`<BB>RbPD>^uQF
zi`2mrl$=1rjSQZ9L3%(3{dz(=CN&HUo`_1j+n>X?ThOQTvWMYk5B^=x^ox^yT7UDm
zFoULByCXR~I&XLwe(-7i!QUbW5fVTWvV;gpz=cW+eJpPj=XiA9@KOBWVR@n~(Wmtt
z|I`CMt*`l~9yB;u8u+poG{CV3?5G9?2C!wyU}G{lJUU-{7=8u|`9OpOkc2>Mbv?T?
zC6I)cfo4y@@zHtF@$w_jZbop|@gzudr=e%JBcxvmY6E$8I|_g$tw4R&ZbwMJvYv^7
z0lB;d9g^>34L%>Mgz3zg!#<X``J2ChmZo-IfcS{N?J0;0_LXnzEB>j6EpG6)UIZ;e
z+2&(;gTMJExUUBFKY!aPxN2}1fK_h;sqO%)-iNAsJr>ooL4|iXX!s7~m@6O^2*(@+
zaY2qb?A!Xvfq&{z-_}R`tsr9@3|{lMDE$Bb|K&oE8j#-AV9Q>>JTeC)4%X|_`W75X
zPx)KhL2BA>7=Y#w`CA@<>@ESR1L>~=$#uf@=Yz!2^+$o!!1XTx>30XI1L+S0$szPR
zfy6=j4}$GK?9=*`zg73&|NjOz`CCBu55H6Zb=5nMdK!N9ZT-vND#gga;A?r8zxgAm
zM+M35E}aJ<9WwrHIVyiVdU-OzJ+i-`9$7qS!~&rmv?mj+-3`$;MA9At)*cAb-gFMs
z&phr3?tQ^hPRlWnV6UeD=n_t-i$I&+z(#^nBD7|3={yAK06|?Ok_GMob%07qNDs&p
zn*3TCAtp+I?x{BX;@kR%zx5tyACcu9{^rLBKRPyiV07f)c7cCe3CN8ikS>)A!oZiH
zA{b=I!8clt%}>}try?DEsnz_D-Ba@nf5$IqxHb7Pflf)e=xKR|zX^1{$xB;MX6QWP
ziCv!)XfJ@}UH+yse?Wy1L|+J~+qL`8|Npq{tAOciN7B~?(pLu7cii*fdo9Q2=P2$x
z&)=~OtnUtgQzlH`dHyEQHq4h1@OHG3N9Q3Q#ZU0kviT<i$WPEj0IJ0Jw}E03-pPQ}
zi{K4uFPDNMzVna=sN>Rp15|3Y-|$iV>|r_QI=JX<w)_Y3C_%&a{Qm#{WdztTP}>>9
zP4oW}Fs3yZWP%vj1h8{F6_5E?Zh^Xj_22*h&^SMV%}1@CAl)|*2?Tp8ZvOG>|Nqyq
zm^GKL<=rAT&+m79EFYEG!S!OXsZ;@?8Qp`BDk>aQ%)-jpbP%VrkOQ7uW`O#2;GPn^
z$+rvA|9J$;F-;Y}{{M%#fxj*17oqU-`UR@Cu?05REiGCg+m3;{aoBD9`x9Z?$Df33
zI}dIPVzaGz%g_J+Unf9<1-UigYk7yiX(QN{`#zSx_}iBLBoK)$2umQb52^l}bHL)|
z9v+?U0Y07n4#@QrxIX|de@b<HE$<eG!^<6Lx`kwbULJ5!)|?J1f^UH;T^#wmA`~1S
z+rjw=l*fybU#^0OBwExLPr{d8AT9l*m$oP^eWYkF3V}p<nGZf=O7$S&i)J^pRS&9@
z5UqN<AOHVD(_E>TXJ?@Ryl_<kbt&h8QW>lYDAfRkS1`WtD&F%Fbci*svaKQv99E#<
zap?qyRmw~7@IE-zp}Dts8a_`#%B5BzP+Nd@d2}<ZhJjQ$B?Ta#fvcL*TwlvOMfTA4
zHzWmu%b#Lxd}R-$(H#S-UO`h;(6EH+xWK=y23$i`fvY^oEQjICS>Hgl1@=<Ef*<6J
zWN>JnFH(FR35j~NtX1UX`5lz4%B-L^VJjC)Wg&WvAfAC_Cvfr5y5`US|D7M2A254%
znjCz|^$pgR1~o%b+S8!*5}uv^J$9^K1p%Jl(>XwU+d98_cKZu>9DKpzVR?|h-Gh;V
zp)?tOq7`TrlSk``5_`;}cEUhy)E%Ib&-3yFPs;;Ea?n*`uq7hMN9~{=n&U6v*$qCy
z%Cj?Ez@wMP)3HmeL*#^GR~TbQ$O%Trt}rIhNmh<sVa%X|tQ@<-SUN&ZusC*wv37)<
zV0G*YW9tYx!RFW%#@-Qfg59wzjH4su1czf+7-vVw2~NkZFs_b}6I_m6VcZ=dC%7HE
z!gxADPVhK(h4FTToZxlr3ghbtIl<@H6~^BYa)RHnD@>px<b;4@SD0W&$O%Emt}vmF
zkP||VU17o<At!_#yTU{|LQaS{c7=&{gq#p{><Sa>2st6<*cB$;5pqHtwCWCX*DG3h
zfKHr&-|+-lBm)a7&}J#bemgXM-Jtrg^Pq3%3GjG7C~CnNOZ@(GJl4h`z`?-ac&v>R
zN^?PJZYa$IrFo$=AC%^Y(gILg5K0R{X<;ZW0;NTvv>22Yhtd*IS`tc2L1}3yEd!-x
zp|l*7mWR>`P+Ad6D?w>xD6ImeRiU&Rlvan*8c<pjN^3!BZ78h+rFEgS9+cJx(Vo5F
z@bm11QJ~Op1YN6}=yCi21H&Jr`D({wEo`8f0tOI+k%0vi>Md+cFa|S>!2)Bj!We8Y
z20Mu1(R_fTbkl1c&)znWaXywG$`ts+5BPL`M7_TjzCQL~(HF;KV6_aMy=@K*EDS67
z`CA%6Ron3c4WD4=nS-2lfEVhlgD}P+7~?REaRkOV3S%6DF^<C+Ct!?|Fvcku<1~oj
z(R_fXwC}ZsM{h?1F9U;z<-s!09&D8LcKm|y?T24Hjvv_Z_xFDkd60XdiMNFfntEH<
zpvkv|4Vr#i*q{lxg$<g5TiBpUxP=XxhFjP`(FTqeXew@DgC^q^HgGzIxEFdEAE+p5
zJy6PvyfK5_v$G8pc%Hp&7kF71JUiP!L4ZA<gL5O=`T!5exdR@Z<s6_x`a1k2Tsqt(
zeOpg@^n!PQd-A&;?BW0o<{e>RVCe9d>hfR&@j!z}9sbf?9!wzKX0V)0mj^S5w+76U
z?ebs&@j&NbcKFM6d9Z?bpex8b{N=km*g(ALV3i789_%0<=&bn;f5k2juzjF&PCNXS
zx;!{Ra!p{B%3U5@EhkIrJN#9;Jh)p<meh3kt9E(tw45xd?C@9X^5AVbSyI;FuioXs
z*K)F?xWiwg%Yh$sU|WZ~<}T2l``6iqmtLoXTSTuDc7ZmUypG%j+LrJ-XcuU&!E5hb
zAb-Dh*#+94^4fM6J7`~y*)C8|^tJvjP7qIH7Z-?9+y%Na?6uS`9uQA>7ibg6Yo1-8
z8ya7;?&1d}^IjHlkLCkXJ3%%hoh(>V4c_4nI&xwkSRLZ-YirOB_vS+%kj}@X=l*ug
z$^n{a2ABfP926xcr!s(u_>%krB==Y;<fRsuq^2k&m8L6X<|&k9q$(6A=B6r?WE7<)
zrsyanCgm5EWag#oaWUkUmZVlNKqMH7Gt=`Da~P5nb8=Es;?s)qbK`R|lNeG`6H{{X
zle1w~V5z@AXVv(2yK{h=B%pofpe45L9jHx`iJ<Bbdy@oo6bs}uI*OYl2OqM6n<Stn
z1!QkAxJkmn1Zk3RFhiOo9MC2S2ee7T0d10SK$|2SApM*jAso;q2?w-E!U1iPa6p?R
z9MC2S2ee7T0d10SK$|2S&?X57v`NANZIW<6n<O02CJ6_$Nx~uS*cB$x5yBzi*cB$(
z5yBzq*cB$#5yBzm*cB$-5yBzu*cB$z5yBzk*cB$*5yBzs*cB$%5yBzo*cB$<5yByl
zy{JQLnt+-#;6@3WIOXjbl=XoI;43Nrd$gV`VLrylV0ge6bRbO}3j+h_(6KNU28Lc1
z@a_`Ro=xu49Xl^Nc3yC7e!%G2{FAYi)9|ft>w(g!*QGw4=X^Ae8NP+C&vwj|c{BCp
z#pura2j5E=-p~9G;$$8Gk%m7UGh^OxfS6ciJ(`a)fleyh<J)?mMAk9W1Y*#4kU`%w
zzk~Ea4f@b|?BF|I!(*BEK!Tk&4!+=b?7ZvP`1JpOeg;Rwqu$*%?>(BI|0{_E9Z7KT
zg@Q-t52*XP3wR9gHU0xBEH}0c5Gd7iv2+kA)qtI!=Fwg9Lc-J9<V~rlNApoeAIq~v
zZ(e#bGcZ6mBzbg$mLrw!0G&I;(HWz{;?wD)A^<wGRsytGQp45on|HU&`)`LCOU+*^
zpE>h+0w#29KE?=BB;?U~)1&z$qethB58nJ6dES>OIyV2~tUJD63%u(BoDh&Sl$?Kk
z-=p<5XfuWccn5j6j|xjkqK9>i3P(wlC-@`@1&_`fu=A3-19%KiHU5J7w*ukcOOXAW
z9^EAuK>ob~^6w!=56f3YZ(crwZ%01^^RG|m3y*^@c)%yOesJVJ*wfCy(7@o?+|Iz#
zz`)pikP&oAU;_hxGw6_{gAc?x5AwH6VPs(FJfR9YCm0kq9F`~eTW5nte)j$N|NlRz
zt^)Z$!n4=posZ%-kLF_vpq+XO9^K$$Gr&Fv&5kH|GWK(@G%$eJ9GxB<ARjkAWMKI4
zzte-KGef}R;9G^x3=z;&2B_BqT9d%w(fp64NXnx(0A%_X56e%*avr@Rpsh<1pm8ig
zSHo{F^+5-ebjrMcnFVrF^RXA6isw9g>mGP?{_{Baj<q+85p-8j^Z$fm0mE+|t(W*)
zLEBzmg61DQdaM3>Xnr^R20pLA1at_2i2%Q#i-82cppStD=zbm(&<-3Q6VQPL2B3A2
z1|DEh@PP#;paTmGB0y?0z@p&u3QP(>CRFeX_85T17d@KaHFz{1XDOWnvbzP;PVxAD
z%aLDz1;ajY&@~@oEPeR0m4Shw^CViyQ32ZSwF4AkkU&N4Csi>pfUXe*OLZPZ(^|~{
zYJ<5z?`?JN5;1Y=2r-aw?g}ws1hFJREG7_33dCXtv7|klkFoezek{G<(JA5G$?_f)
za~jZs2DA*;0C|)OeHH~)lR;?0^%)DeKI1^G&jfMTXTsF$Vjq0SGQjm2)?Ef@QAoS`
z1U~-J|Jb4rgfPZG*udi-paoh;;~!T*BiYy+8`nUaEvYsBaS|LkLwEcG+}Jn)ZET!?
zHa1Q`8yhE}jg1q~#>NR~W8(z0v2jA)u`5iWBjkjFV^^4BN5~09$F4A?j*t^dj$L8O
z9U&)_9lOF*IzmpUICh1pc7&Wzb?gdL>j*ia=GYac-Vt&_-LWf7qa);mhGSQlW=F^g
zO~<Y<t&WfrT8>>|+8rS$v>m&`bUH##=s0$T>2`#i&~@wz)9VO1q375Yrr!~ALf^3~
z%%CIWgn?sMm|;iA2}8%OFr$u;6Go0*Va6RHCyX7t!c00sPMA1$g_(AQoG^9l3Nz~n
zIbr756=vQMa>CrPD-3ktx`ks`m}N)E2}{SWFsqJ`6IPC0Vb&cXC#)U2!fZN1PS`kh
zh1qt5oUnE53bX47IbrA66=vTNa>CxRD-3jUyMtp_m}5uC2}j4SFsF`?6Hbm@Va^>P
zC!8I-!dyB+PPjOBg}HWwoN#sQ3UliSIpOBm73SU%a>AYH#v1L$pD@mgLtQVAr2~Xo
zUJi2o(EdE=z&1g534TF$4t_y*2Yx|!1AamG41PiP2!6qKP)D0zupM-&A-`ZdXyre@
zU^{646u)5m1JEh0g6$U|6sQj17i<UZA>kKn2W|Z37i<Sz_QEgN9s$~~DhM8l1sMk6
z6+oyJ5NZa5x&WaLKq$~^0Di%C(5hUJVW4x<1=|H6lm~>efKUYxDgi=)PB`WlZ0~^Z
z4nU|45b6blx&fg;t9$tc+ZmV{82AO-Eg+Nzgi3%=0T8MKLRCPh4G?Mpgt`HtPCzKo
z2pGR$`v(Y5g9U7~1cVBJP!15P0zzd#s09#e0)#pNp>{y14-o1Bgpyzdo5=y893Yed
zgvx+W5fEwugld3LJ0R2w2=xF$U4T#=Y+y5gKzIfao&to5fKVO~ssTb3K&TZEY6gV5
z0HF>*s2>pO1%y&y2iqV3p*$dz1%xVqPzexf288N>PzNB?1_<>6LfwE+pb<_`{BeMd
zwt!F?5Gnye1wg0{2vq^0HbAHa5b6emIsu^=IKhT}fbcXRJP8OD0HGWpR0V{}fKUq{
z)C3510z&P8P#+-F0|+I-1-5|$LODPv0|=D?p&}sE1PIjtp>{y16%gtHgt`EsIJm)P
z{($fdAUp*K6#=0<AXEc{Du7TcAk+*9bpb*hfKWdm)C&luzyr2H077{{C<_Qx0HG2f
z)C>sK0ig~+s0|S61%$c*p#*rrW->r13kanFp%Nfe0EFs*P!$kr1B6-tp>9B^6A+4l
z4{YWK2u}mTlYmeG5Xu2URY0f=2(<u0O@L4*Ak+>B^#MXXfKU?rU>i6flmmn^fKV9_
zDgr`HfKUw(Y6pZ`0ihm1s0$E^LjY{%4+zfy!c%}y5fI7)LN!3B0tmGNLd}3s7a-ID
z2=xO(y?{^(f?yj2Ae0A$vVc$p5Gnye&45rH5b6Mg+5n+mK&TrKN<au~CIf`BfKVC`
zDgi<TK&TD~RRN(kK&S-}>IQ^50ihU#!DfDd@H8Mi2?!Mcp&TGo1%%3gPzxZ`1PFBk
zLhXQ1A0X5N2qhr`wt)jeIY1}_2$cb$A|TWR2-N_gc0i~V5b6Phx&Wa#M8RhMfba|;
zJOv090iiq~R0D)6fKV$S)C>r90YV*sP(L8l3kank2DU)}LU}+a3kX#Jp%Ng}3<%W$
zp$<T(4G`)Dgt`Ht1jNB+GC(K`2&Dm`5+GCngzA7$6%c9zgjxWhZa}CL5Q;$pY~}|D
zPXoe}fKUMt$^k-EK&T7|wE#j*fKVqO)D8&s0YW{1P!f`08#o}81B5bwP#F*^0zyrI
zPz?}j2ZUMyp&me}3lNG!3T);N2+sh*Q-Dwr5Xu8WH9)8W2(<!2&45rBAk+Z}^#ek^
zfKUq3U>gJ=lm~>efKUYxDgi>xfKVL}>Hvh=0HIz$s2dPUKn83k1B9}GP#O>_0YU{p
zs168K0iiZPs09$}2822Rp%`SrW`2P1G$1?)2o(UK93WH$gvx+W3n0`42z3HN?SN1p
zAk+g0B_Rj4fdfK0KqvzUl>wn5Ak+j1)c~P(K&TZE>H&nh0HHYK!Djw|@C+b41qc-Z
zp*$c|1B5DoP%9wR3<z}rLLGomKOoc#2&JF^wm|?wc|a%&2vq=~5+KwJ2-N|h4nU|4
z5b6blx&fgC6v1XPKqw0cr2(N5AXET^>VQxc5NZR2S^%MLK&TTCia`l%<_8E*1HzMl
zPyrCi0YX(ks0;|T076ZGP$wYN4hZ!DLOp;`63Sp3I3Sb*gff6o84xN0LQQ~B4G?Mv
zgjxZi9zduI5Q;+uY~~LL&j7+xfKU+-$^$|*K&S!;wE{xTfKV48)By<f146xkPztJG
z8w4Pf2ZXYKPz4Yw0Yc4yP#qBJ0EF5Ap<Y0!8xTrB4QwU@gtCB88W1W0LIpsm4hU5N
zp*BFM1rX{6ggODC7}UXLet_^aAUp{O6#$_eAXEi}%79P{Ak+j1bpk@|fKVSG)B|;F
zx8Fbp`@mz3;Pup?K|#l0(D;&LNPtgwxrAfGzDfTW7#K<ne7e&WK!=FxfDQ@4c5H|O
zNW!D}0EcI%o5gERSHu6WO+iAQ-DMgcnjbt4zF_V=1RW!DHT-XQ5<K$h0lH||rMrRy
zWHu}KBoCL)A0Ev|a31CXb~8$U+oRiEqPwBzA08i~s0aHm6m*}&Iq<5X@1C7MJX#Nc
zCwx8lT`zcaUhrZ3P^^q`;)|={6VNp~klP?$LiXxh@NE9aStRM%>-XQM^&@{P=tN%+
z#*3i4_`cupP(0xYx|M*5p<KzsmVtqZp<K$t7NoJ<)}#3VKX|E9>w(g=m+YXy@ZKHZ
zY5K+kprr#ooyUBjw_}3VgEjx-<ZlM`#$SR*srmO_==J&s+Qf4C-G0!*rOVHopD{Nd
z|L+01CWd92NArOX9?kz5J(_R)2Q8^@0Uc}W(fq@VzZtYa60|(=;8QODUKM@sZXSKm
zAaNk*Y9G%|78TEKmooys-6>}z_$3&;yIu4JJQ>>sZZI%_eah?EeC)rk;xqo%NuYFt
z@3IT<Z5+>hKwC%;f+M@-Kna^?H;>BeDWI#=n*VVYZ+g8Knk2vqzywqPww?%d*cHz8
zM6<v{>}H^O^iGH!Xu3TiqwKJd1ScMlyCDZsK+-#6e$KP=oJZ$n$PArlZ{B~O*021n
z3qVl=TH)pK-=p;)f9qP%AUEhp;6onYZ+R%5ay5MGWBI|C-|3wv<55q>tDcs3i&Zhw
zj^S-k(s>1Q2=u5d&^iJJk8T4W=($edr~;kZ?%6Hw(dz}V&=+K3uL%=)_vU*~&3_)P
z|9$vfzI!r$^K5;`-wHYo&a?F#<n(jTULHBn=x<XV$l09-d>LPWN9wD<dkepMXkPW`
zj1}<cbY<}A%mtkk!rxNP2)eYwv8~;KiG`u%Knag$?|u*y92=h9{Q?Xu3?7X?L5Dl=
zH-pv?d-OUodUm#h#XEf^JVBR&bn2XNJk~A&8UpcbZdYJnVPN#+-+R=vyWfC;g~5mM
zrDrFY<=H*m0%V@$DGz@4Q=XmuAf9J)%W=@!A4Xrs92Ef&A>nuo>>LK4&d;xz3~zgM
z-oQ6|ffnmwpo3sf!tNe|N`k!uCZGba6qbrjHB1sT#g8-j<>1qq3trEA0Go|@45%kg
z!7NJzO+KQ#8zw0RPV1mp02>KQ%3vBt`E~|;I^9>#&i|gxwV=xf>_K}8dbcy&0G;aa
z9elUVL$GP!ga_Jb;M48E;oEwEzvU%JY4Z=3B3;j3Uj?sTkpqzHU{CS4fp!LY_3|85
z0Ocgcmma+V0v?tZ`P-I&g5#1)=P}J|p1mIbJv1+RG(Tf6Q3IV)!V8_rg-{;dH5UXt
zJ8P~gfN%b5KE_!3#-sTsJAYFoBLhR)1dnbXki5@T1rSTZv(x9Q28g8qVi|x~8X%Sh
zh-Cm`Ie=IeAeIM+<p5#@fLI<NR)k0MAr4Q=3#H3ng0>=nilpX8e>{4<{&;kr_c-{T
z33lGgPo81{@L@0ft)R6<FF|Mbd4O(U(EMrmA8EY}zktgR0e%6WAD~nGUH*bdpTD5v
zTz(jUL_w$cyZi-_K7T<6y8H+LiGt4Xcliq<ef}1JOeo+N==lLE(;fK*TmC{BJ%2$%
zub_kdJ(>@)luq?%{Z?Y<)64T0bo;e0D70;UfX{aMe$VhEY`&Raz=i(<zW@(E=n?@=
z@M->_OVboU_cN3}^0d6b-<k^A*wgL7;o0fS;Cb)~mv?uFx`g8vM$o-$eBh$`n+LQE
zb-`Dvd-iSz4QYBDKmPIm|No9VK<kzqcY;nge9i4@_~i8=&^^hob3K~>tCq6wWB}dc
zYvR%CF5uI7(4+Z>V3CqX=TDD=FPV0LszHy-4<L)1nL2+qKV<gcUw;a89ck;ylAYi)
z&kQep|JeM)VV47_gy(m<0CFs^NAoY+GM*iFpe0qT;8`n=UJ(Y5&ae+2oqj(&dRdNw
z+~i?-5HxDd;K}cF(4&*hv-yC4NAqz;kH%x5GRmX*zZ!olXvfw|$bk*u$!}Oz`v6MF
z@O%hL<+$pLGoGL$5ubV-e9GqAYohPjcnnmIfzIt~(Fd_w4wQ)abbj~jyz0^U8IsdF
z@A-7T^6k~p_iQ}s!N9`c+1;ZLqCHwqmP&&o;-haT<i?wp10|uJ-M$Q<`Z>U}yG1_$
zRCIO=cy>;KFk3H`@^~I^(T@Q62^2=n2mga27<AYlzVg!W!0S6`rJy6apTPwSlt3w8
z5cQ=;;~UU`y>I6caLp;Af_g0sC~kZ@AA!B?*?G{n^(24GLePG%=0B#TJdV3Si34=g
z?rR^<=05`E;=Y}aJP$r%0SWoGUMe+nHN0ea`*n(MZ-~kVpU#V@sRp$3gUPY^5wj2f
z`iq{7hoHJjPC*ln<M&Unb1$2JJM4g_pu?aBC$C5I58E=H-H;Rn-sHT4fkA-5@RH~E
zPafZI`S!{PdNv*g32k8XwY<sSyd5-m+L@yw0m?aky)5dU%?Bh5-x_{{u5a<_^m$_d
zTDjuU{MUfL6?AVEC@)0#bjGMCfX+A304-SI0G)Uu;L-UGbQg{UI9Nc(diQ}02OW6S
zZKJY*5p?#6fKRuN3J2&k6b+y57!`%rfskSoPJ#*rZolrFCk7tfejKmUz)a6>4xi3<
zptR!b(frelzZtX*40N>8!RK6Fy*l<@-6HnjMGa}7tskJ)MW-)ldB;@&kM5GI68sX3
zUfn+S0v?S0pw^xT=%yLaecB$!-9RfF84OQ?j)e5+4CC<W%sD6EVHw9!YUbHo#{s)5
zsYKKhbmeWQp=W2AglD%O2k0!=*Sug}XPE$a5sPQ1ABW*L&>4rG&3_E|n~eYe|8Mx#
zm+>Mfn47kO%Ba@2kgct*hHqb+Lqn`Yg#$IrqCjn;Zm_TzDCVKz_Syv!M9}a_c>@Wb
zM8EEoHwNJFc?Jp}J4pDLfSX9?J;C8)0t=s#Zg9)1lh32u=Nc$zu3-(D8=&llC1_G8
z4Vt5jo|bR<n=C<*)cUQ&-UAfG{4Jn0vgCv|{6zE~6;OUGHS=gZ0?M@biw87aC8waJ
z1vt?{*|5?Q(Fn&TTY}Q2!C#(uc3$)7{OsBJ7v6jp*bmBu`#=QPaL_UHpxgh}gF?U2
zSpp;hIyLe?KLda3e9*qk&Oe?9--v)t;y?I8pT89}W$DxT7qnW*v)kn@co~_aXYX9l
z@^nx!-3nr~94O)N=)4cH0j5d<dP?1X(9O~CLu*~$G8|)O0G+eR&%ofuzl}u!v?4Ff
zt;0mYr}GECKn3-P(F<MBWl%U<mx|yeGYkw296p`URvPLOB6o0+4R$p&TwxSSc@69D
z1_yX{p7ZRy=n1;x`aifd23;WQ2`(#&LHkcT&w9dpg+BTmpseER3A*~+@&tbiXlJiS
zuLq-NCy$D6XUP!-NZ(Ks+&2XE*x{bXoFMn_718$uwZVG#LmCgqz>SC9po)4oxb46O
zYc~8tZZ^0H_<$DbL7EMqlg}`k4Ie3PHiUoh==8^EHhAzm9royC_iR2a0BS^eG#&?4
zu^!F;pv?x)ZZ25Jw1O@;09V|g&aO`<WMl&*`|=E^Ktqi*P=dr6<txE$d{BQDW(*`o
zk*eJ0HxizmAAP$meY-O`JTJcWwfyVb`Nx;v>8WSuDbLQ|KAjgl4nE-W?Dk;>T|ds>
z0^Yj>j$?OF-P?K2^WZZs?_L>W?`{@jaJ&B|r~(2t*gLsBx=RiVcy#+5mf)9Q^X_&r
z7Vu<jhExY9A$<a$&P32)4S!25xP$PArO3|L^1V;z4^MvgqaMAL0^YqQKfz1mEdTMh
zX@HNKG<oRJd`!UO`vo7yAD+D|2R)h(Xn+p30-r=__}16*y)VDp`_32NFL-{x>Z19=
z<M=Vqtz;gW?|d}hc{D#@FERA)wbA$NwfX7Md|boh`wjH-+`DDodvwOU6oAyh2N+A=
zdNluI=Wn_JswX;Mdwjp_qxssS*W{%~^Dz(4gU^{gds*Il^|HM1VLai{d?3LPb^nG(
zcg~L!9-TS=PJmb!K&%TO)(sHr28i_l#CiZ?y#TRZfLI?utPdd84-o5zN4L%ok4~L`
z9?i!&JS=~gu6*eU?uGyG(R|?9?Q>88w8Xy^wB!FJ=vZ!#y?;P!*#G~p_fdT6(Odfm
zvLuqJ*Nw6H0kcQ*e^BS-8z{!W#}$H)G4bhq54vov^S8(M%N~~ZJ^0=4dmMbs?A2@Y
z+lTSIN8|Aspn|eD;=hOHXTxvs`%?G?T)u<Or~JNvU(n^F0KcHmM+J}==zz-apaUvD
z8i2$cKw_W+D!+pcsQefJ5=#Jyf%+QXL0Sv=1$#b%dM@Ay2Hi}y1k}Qc_UN_w2<oMH
z^~(GOC1Ialmd`$rc<B7+@%@^I<!29m_s^caCLeql&v`T-v+($S!|*mze?|^uhaA74
zi~I+EK^}RJ=EDl08<9$%cv`;UZ$0_<|9@XiMNlj42Ixq)>pq}n^(BwyBNFgpC>FdE
z*QfKo2T0CGMF7+g<M8MdQSs@#3obQ1J70Tri>QDaS{$GzmjJjT=w^QT4z!oO8#X!v
zt?!_xw}W*;g>Y1XXzPWb_uYV+Vx3n!JO6q%gKq+y3>qLf_=L^B*F?t?)^TudYf*)E
z95`U-7JK)y=y<S#`Uu|5dsIO*Ly3%ccaJKlJK)*L@87ux%=GAnG`VD;H-&=4K|KQy
z4N?kjfq8UtfO-eGFQ`HD8mJS6D6c?qiMu}px|zbK^C;M(*E~DFdUXB<ogUhf3(AGy
z8wmc_GcfpqD)4Gh+spD;xeREe6tq^nn+4o9=W*%$c<`l2gAE5msf0)GZqSIRPv<vC
zpo7LGCV~!W>%0#W^Xxq0YxxIqg)P7PbI`?DpsE~n^_PGT^gMLParK^^M}0wUOYjjB
zphfo+AqAL1k(75Yi<+n9QT}Got_x6T`&fS9Z)*d!Tn>O%(MtGO{`BZP<;m}U-J|mw
zDES^g4k@6HduV?5Xnw?8qUiDc7UKL@NB(U*Y>pj1te|aTjG!?N(D=rGX8tA_P+8k~
z(Bu0>&+pg4ZCa1-mpm=6gU!~w=+!Ht0lF;Fhw+0)^8wIhi7cQNE&sL{gTEayMt?z!
ze;qNP`x0Xe{&&QH?n{(0=#YWlm-w;t>Pyf#wg)JHAcw)f#Cl$pr{%G7BY4n@90ql)
zm0&^7#ZV&V0f`U(7G}_Tscj-0FaLld5fULDjfX)))E=GpUWa(V<JHsh7-%&(2eQG(
zuo-*|RED)|VPs(72N?_=Q0?6ZifNC=V<3ZlIwAKrxf;HG2^!t>>3rbP{NRB{Z@~kP
z&QBf(U$ORjF@h@o=6|4N;+MeXDCpd|m!NyyJbDZNduU!Wyo4Md0xV*V`~p5=pc@HX
zL>WNWDT)e!R)LFwSB#4pfJRP4!2>y>24HdUnsG7kwTz<Rp&ZcwusC?txL5&LJ$Nuj
zw7{eJRf9+KF_zNlpeB<sc%bb2O{DQ6utxCpc4A<Cpb;7$Q3j9ZLkgfyQt5rr{cWui
zL8pZv2WPn{Jc@ikJs^>Tpx{(MiYF0J65{aaW;p~Zc3nW>`Pu;-3m#ZQ6ttm$z!|NE
zmq6PbKph_y4%l$@>*I!(KvhlWz1Qqed6?A8aLhJNCb(e=8-GPFFFZOyvqAc$J`je2
zN4LmvkiTr8IiHK6#1JaR-vXMg0NsYl-vVy(ce5M^dDNAE8w-a=^AFQf=N+I?gx5+Q
z-R<B61Zu{#ek=|5Xgye(@1c3jgV|5O13VLh*(x<W;BoK)%j;)00_ALA)}3CD4+mc|
z?Sc$VJp!FleDEa`sPg4sf6#;R!t32=g(GOT2T?deCBbDCn1BkvY6;M#w+PkHq7+PF
zw%0-D=U;=)L_j7Vz|%{hqsu%skAZqF?VvGw%;9=J3D53uP>MJOD#TjvgZf0>;IVqp
zJU}z(OmNR$hyT#=d#`SnLq9w^Sx$im@w-`0cyxMz#@=BA`5NGX{BAc6PtA7FK)xrK
z>7pV4V}KNc9KzrWxk=2@x4R5<t#*k4xJ3*pxSN0c=WhYu*#xaqk?wFnT&Im^(hn^l
zu?9OVl)?6Z_LzUb76+gkF(Kkmr*s=Y4F}E7eDdl1=-c@Nq5!qs-lL6t1rj*c5Cr!4
z`|jEK$G3Nj3MhO)G1dZRf!Y|bn%%d%M+G#E0`81~;?}o2M1{k(^8|d$m$l(Z!~fs`
z`9+}SLO07VAIl&7?NdRSs`HnJ<{_WXe;%6Wz;~cKod6evb)YlKLGyjSng>C;Uo)QZ
z>=yauWBIF0+_O967YB%?=h1we$<y*@>66#aXU>2Pxd!SqYo741JXXXEIugC}B20Dp
zC9u>5u(ER=mLFgWV1~>Gxv(`3JY;dQMAxUA(Z}*&k-HDGBZrUW!QwC<%b(?$zLr1A
zgh1UQkKTa)9<8TJi#!-lfR3&QwMRf5NCLMK!Xg-SBp<dI0v&>gP5dM%3t*2_Q&1I;
zJkSe`Qq1@abqoRZpTB@E=>RnztU-;3Za)DZ%ZL2!pbM=$phLvn*1oO(O9hZOU?2DC
zwD#<E{|`E%trc{(nGfRw&+qp=K~uG+AR9r2E990zP$Q*V4SZubsIddS?zs7fLXn7P
zFAs~S<=NsopU#&aj0Zg}&lDGfM&ttiduW~l%>y?-V=j>a&9pF|IdjI5f13=CV@C`x
z1E_idbznj5k6)nn2Y7x3eBZ2NM+h$i<i=SLlM&2h0x_AuOlA<188i#wVR@qT%*%(M
zt^{Zl|KS6V-bz9nwm|2vz&C6m?VkeGf2QF2*A!g;!gg$d#liKjDY*VM0oT7K;QH4T
zT>qMa>t7Ra{c8fQe@(&luW12%)7ErQJz@;*i+sO@R{xrS>t7SFJ>dG+lmXmL1?}Lv
z4?0n-b=|-J|9!jFKuZxUJ-g#LJX&vqim~S&o%g`$3U@K)@%{D(4@U4B3g1pW-_AM?
zP<n><L@=u!Xqf{`(x97&5H$muBroX5E$EB@R0`}IFaaMaLlk46yM8-w!sZa5I$$<o
zFUBy_dq}V+XxieRZ)cr^V;8%PYKewV=TBJw3^Z)L7_|I<n<Mx_9~;%uH=weo1#~A2
z)^W2VyFkNe;5q?vr;lfM9fu?TwlD!7*d3hETd_dFuMfUA-UoWeD(Lzjj0;YAK6o^O
zJ7^3a{{M%}4rASxg=Eh^P=tULfqRA+K?io?PLMkd50DgmX#Ksg0MI~Yx4#55&<ziG
zfNt}F)P){1K=tyZ1E2)r7>AiMK;;3NdC>kNO8EooQhCD4pHfiMoXGMg1=R66_=K6L
zGU(s~W^h}*7GwcRIV6NAhu95IzSIOMAf{|+0aZ?FAl0zVoS^%o=vhASw}38qhm{em
zpzhTfQ2QKj`S7|7Egyk$>}wq~LA*H?k-r_gM0h}DD}!TK2oEEO#Ry_Si{7pf9@LWe
z0<=srg_TL5>zk3vq!K4sN`^P9NH32tTSEkkk(XNkVP`a9lpmg*|6C3KJ2wC4tT%qm
zea5l*I3t*&hPf~M^908RJBHFbpcWEa%Yo9%uSL(GY{Lf0?tA?J`^GSEb|E6afKo6#
zzqEqVACdV5G=JfF@CmbbFV7PX#uJ3=ZBU-+WjO%OH(-nK<r~lh0O&+4@I~(U>Qqp>
z^`#!j-SB+F1x~tPVl@ABh42ig`~$jf64Lwg?cL76z`+2@9qk|na`(ZpyPt)DgQ4{#
ze`_PCSnr<B!N9@b(fA8=mN0+I6;N`4WbAH+<{wN&3ZC8D1wbkwU7MXCWsW;Q6C2R6
zO{n~SkVUX5ukL=3p{|ApJX%jW@=rMcT0L{{5vOmj2jjtqTrQj^J9z|LI!}JT>Cya<
zxy0PDH;~b%^PI=QXPh34$2`8@1efpK`$2{re9pyqz0=OK`5<HSA@EWR&}dlmLB`U1
zj=Mn4@YOu!+8fE@(|OY4;6qLi#)BS>2N~EH7+iZZnH_rznH+m786oC@eR}W_7vrza
zi44E~|96D=9VGIpb0WhZWDys}SDh0X{-Fxp>J)TrKFk8L0CdP$^HG-OV=T?bSv;E$
z{VAP)yn*2#=%@q+22Y6pJ5L>a#O1<y$gy)eD9Axm;hvpfM|gI!oQFn);Q{D+fYy^G
zHlE!gDjvN>jGmn)Dvq5#Q#d+Lf_ha4UvYVMi(GGf2)>Zv;6u)C9xlgDa6E#>w>_GF
zI20WK^@wnf&_ZJgTKVh(#o|s-=s_b9+%ANai!c&P`TWhJyBt2k?6@6tC!+||M9}iw
z1F!*Bm(CyfN?wQ!sOCf4Kkgh277WlcqM-M9dholPAg57;V!lfkzu^Iw&XWxXXEpp3
zE)VD5b`ol)M>0>B2jj*64?#2C3{X2=I!{e#xy0Y{4%}W9VYd?D@aT15EP3tN@UxP?
z1r%D24L?ixTR^85I5zw=ERlQ(+QsVF@Y8_5Wg=)suHmO4f2%4Z0|T15@c9&w`Jh1~
z{%xq{m+-fMPWgt|1n!rEuCV}{;sZH6%cb+=YsNDzCrg6(xACw$S@AG{9rw=gfMdhY
z;(AB0gE|}=ex~uasQv%{|0U>jEU*Dk?}6|C0$l_w=mIjq#fk^wy*ID(j<GSkE&%zh
z#1iC!(llg!E}f?k<D)H?N<d?W@UVFg(&f0Zq*M!83qn1}K4CQbK#Bht8{-B>9Bo=i
zN}&#kk{*HsJUTzT764a-Py&>b__uNJ@4MI=^}YEwYtg&rUkW8J8-8k+2sZrGEtT-;
z4PbNx54FA)g|Hbx%gH#QM=o_9a^&B~)f;%h)$n%nFV6A+&z-Yof`Oz@=Y_NhzLuxG
zdqt!@dSxbg9zP74we#e6zU{%k@8m9hP%l~Yl!xWzat@zf8A;FP!x#AXc`$;U)Oo7;
z(1qq-Tt)k#*LD5>U+>y_ppFxC<21k1>DPjw3#Px{0(IJbTW@>td!F*>4(I6P>XK-=
zUBU;=o`#S$r7gGlr+|AA(U<{_5<ZUb{MgL_%_yYyNKnl40I&Boz!%Xd>Jj#XCa8Kv
zK}mo_2cVjVtv^JK_FW1I?K_9j_8s#0$!Pxw(xigsuYI6l7JU69Q2TDQKW|En@xIai
zd^~0a02>iNn%$tNKMzW;B=tu?LsFiQHaWaMa)ikKhyVivw2p(eboYarxcK`cERg;P
z4|;#Z1koR1!O|b$LGF)$)+m8GBM%+HBY`NL5f)Hqr1_u$N>79X+T1t;?|twv{^|_8
zfW-aO8TbIf1@%M%KOpmA-H_&k4vwgOkk!W<KKuvOl_-4>9wPc6jA!unKX{=14}Jy)
zkAn|csMP;JL>j0?4RJS|#H_zT^P68hJO2~ey^Y4wy#+1YhNg2;ySEKY4AA7{YIwl2
z8QeK#0CjG?dqo;N4nAV_U_9i}cnGu;!?Sk-s5c2ZEeCWw1p@=W2Dk+Sxrh|h^n1;C
z#^ZQX1#~csU(o4>$8o0v2SIy>1)@&y3nYEu54p)7c8gyy>IA<algDwV7huVdhx}oW
z_yv<bcpP^EEumuY=&b7SIPL_pmEpJ(Xyq2eai=+;Ky-w3LJvOV>gC~UJjlqxz|h%M
z0Ge)VJhTAR;A}p|$lqG_|NsBv4GEwNbHH<j;O=SXwS&*NTsV(8c5a7sT)h}QJHcIg
z&rX)>h>j}{EG>iR){`X;MD<^Lc{)7~K4is`hW3E^u;4-N80`H=Xx@f4YVr4CG1CwF
zd>p0Y;Y>u1hckiOeW2E+2flH=(eZEw28Mm3<KZ$Ykp0vi&2I!eJ3(gxLrW}=P8Ssp
zkKPg$cGy~gmIEcW{M%eq*gd=bIXW2~w==?&TDz!l@VA1B1<2lL0qhydv5U>ds6@ji
zwbTi+(ht(r0*#lo94JX}<ln}^XT>7u(d)@r^6s@9vYM6yB@U?a&}@k^6olfQ7I5(c
zY4w6je9#J#<DkVj4Cqd8asB`Q|Le=3f((jL^D~wEr^9|cz=QMw0cg0xC>-HW!~QuF
z@_Gp&(6BF&^Dm4bjR&8w5-y+p1VB|0e~U4wt<cND<7s)c*dMgujq!x1<&k0+!vpZ~
zI?(zD7RQbdR`B`<7SJ3VD|r0_3uqF76}<j|1vCrC%Iwj60Cb&5>6w?{9Y4(nA9#R9
zx8JeCmSz70EkQg9suo&7cPGBw2&#`kD_k@`8J>iW2ZQEkctGn9dBE!rLCY=#eR#p^
zA9%p)4|%}r4|&1;AztwM2OjYH2OjYH2VU^{2VU^{2OjYH2OjYH2VU^{2i^jY=9di~
z&4<A24-b?Wdo&*et$9OR|G)!Y|G)!U|G*1g{{UVb0$EgjA3DW2QkFd+rT<Wm&Zm$v
z8q~)LfUJ4|?OuZ{!Z}$g@LK&062C;!t5?L*!}3tMfJf(v51#xR!#GOszXUDj2F=m1
zA<xfvHvR|oTpag+NMC;U=RUo<pe*>>0My7r!k(~=WS4w8pZj#agA}NsB|n{h0-l|2
z97ql*<$rwviCc0Q=AK<}_soe1m|J=q+yLu50d0fDLMn||(3uCw*C&G9L&W?krR^&g
z!ui)t0JI2`zoh}xO~lu@0&TA(YSOfwfq?<CGyy(o3ZL(Xo#zb74>VnmG&(*(r}2r=
z@wCzLH1L|e!M8pJT*x93_Vx_A40`(M`6b1Pd3wnO1q>P*nR%HdsVSP83W~N08U~sS
z8X6^;Ag+yqhDNq;Vns-1if5iP=++TUkYrJ6X>n>wyr!mtt*wHFhK5F|nTaM;P{GDV
zA=^18+bOf8SX05y4#5HGOerqWwM)q?DyfW*Hi*@O*a9{r+cU2$F()%61Y|KoGRQ95
zXa?0{)tsDC1_m95ScQ_z6kF9&ebrKhoW$ai_{8KwTd<^tMsa3UD%>>&U?(Pl3@Anu
zEJ;klB9fU>fi9X~psA?<@;unjP9U?atg^uz=ls&V60j9uZ|K@V`~Xr6bq0fmMwzCj
zf}Mhf2FNY33XqVojb;Ebb5awFQ{#(E@{3aA!9GgSS4~j>n+4(*+p4BSgS-{14`VQ-
z<|QWOq{b)a<>i+omSpDV6*IVkg%naM^AdA2lNFGpbQJPSGE$4mGmAkt%%oN-Bo?JA
z<mKz;7ZmF;6qgnh6r~my$EOySCg#K!mn0@<7c&GyMHLbiK=;=u6r~pA7nLYvrYV%C
zs+XlIB<2*QCZ<#><d>Edl$IzY=7DWMQCpr_l7YC{25c^dZHXx<AiGnkVqtzB!aAtI
zdJGVU$0wDh7c+#E7UdNy<fo;9@7;mOWagzSq~?`m7NzD?Drl4zr>2$WD5T{VDI}%l
zC1>O&7G-DVrE9{?f!xCrpOc!HUCa;!2^5H!0$5BTu|y%YBD2IEW^qbtaY<2rWjrXo
zq^7{MfJIA_K@q2rpQezg0FhPzU-kpn3+6$b4z(&XFFC)cC^fl6p|m(LJr(2`h@RA9
zg~YrR2pc)-;buW@4vH_$D^5&Hg*l@vGd~BCdcdwIuFOkTfGE@jDJ!W|&`8xw*Hg$%
z%*n}5*3eV{T|A@!x^_q*5voujBQY-}C$$I>M2RK&xtYoFpkxCNA}~iGDYc|LH8oEG
zq5|yTf}F(6JcZoU-29?Sg~a6K)Z*gQVm*em{G#O4_~O*U_+(JF2Af#S;F+dSoLZuz
zkeHJLHKQ1ulvC5vQj<$E%Ro_BoLX24iqFKHoJxh{{Ji4K;*!+75(N#YVVXJ$MXBkD
zMJYL{#o*v8&qxG?W@?c_Vsc3-SX*&HYI0^;W@?HaLqSnyUP*jXYF=h~9zy_#qmY|e
zlAMv6qM!s3RRSmaVpzoMF=Qm>l*H%f#ite(<rguyR%DhaB&L<57Ad4<78RF3b5d%G
z0$5&;A+ZFMUgC>$Qd0}!bBh^*K@8BPP`RLxfu^mb)U^DfRB*}yC0J1UECIPYH!-hL
zA-5Qwa7*$Pl0nW>P=cmIsOvOAKFLqZ%t?)hgf%=Y3sQ?R^HVZG5nHKHUX)pq3X6?`
zBCrO9l6(cQT_D|h3~4!~#TigTK+bgo@fC_Q5>xWaVLDUGQj01TA{25#F$t27FRsi@
z%FoHHN-aXt0~b?BPE5{7EmlC*2XSV6PG)XqNqlY+Lr`jQW(p`GArcB;2~aTkI)Pl6
zn3=1PSfb~d1}*{$it<4z2^{~Wxv9kpxuDR4=+ptJ$WsUjPRvs%&&<hD0Q(5l2YL*}
zCHV!QNGvW%EGl6LF3B$_R>;p&0CN>e^GY&v6yoDSwPk!!YH?|9s)nXQW-&N>q^2ln
zfZ``5HK{Z`9a?yl=H+GPrGpGCOUy|x%FIh)aL&&wDay|&Rw&O%1(nVUK@dg$d0|i`
z8k!14sU_ettE8wjRUyAfAuTbdI8~1!BNJ3vRK|m97lwe;B3)=Qfr=}D#C1TvhuDw-
ziW*Q#DJV)U%giq=hD8)C!+~>AQEF~#Zc=JdYKlTZY7z7*GCc)_fc)a(%%q%Dg|ft)
zQcyWll&TPIpr>aZtET|95bO|J1BJv~P)%42iV$NXZ**Jq6ck(&lQR_ZQY%UzhAE`v
zmnP+;7K5S$su@%eK_UuX9Ox*N7J!UIvCJHjD3NS5@x@|cNJgqcN@`kSX%5WF%wh#2
z1r0+Z3k>&Z>M>;I$Abz%MC9b8mZj!^+yoNND9X>vtO6I93YobDIhmjv+$t43{T1>H
zQj5Ui#d-<`3c3n;`3mS73>9=0ic%Ac^C8tVPJ=bTnNZgbRKIE(Dd;Ms=j10P=3tly
zsy1?R&@5+2$xMw0mp1Wf`9;|bE}5y&!Y8*hrz8`aPEu1qHC#5RHV552mz<HAlcJDZ
zl$uzQTC9+lS`LkSq{acbfdOk1fH(@E(m)|EF*j9@Au~M>)N;wo&&$j!E-5O_P0cGw
zO^MIVPbtkwEoSh{D@iR%PAw?OFDh0j&d4v#Nm0np%c)dINi6}@WRSX{JR>y^mVdw%
z46<1YP_y(HiZc?6Qd8m!N{Zq$5#}<46eT8SL+b>EqSUn1qSU<PRE1<vas(BanRyC1
znMujo+Ms+6H2_@yl&2<UgG|$7C{9hz&r6AiU8M(U2*E1K@{Cka@e4}5;7S>k*`ZZ-
zW}X5}543DAW>8R2P*7IQQ&3G)Pz_d4^<@YF-|H8gn3q`sDg><*5EVH%SApUKB{L~#
z<dznfC?vtMnkE-<W<V1#s&=DTO)gOTy|N$`+6eUpT`Cw-S&#~CVS^j5B@lT~vlT9n
zXxc(5?f9Jh#1sv+;*!LY)Oa0ehKtWHN=Yq>FG|fxtN?WxpnZVs&^$;OflVh#Kd8?E
zZYe7$M5iTY=A@>83V@<iP_YMY!-7iU<m^~31_cGxVhv3$P>6$=R;noq+6EP>RTW$e
zwitkmA>1*@&(qJ{O2Nf3#8Dy0(b*MA$koxs$KTnTi@`m=D8IBMGcQ#^H3i%>gEp*G
zQxwWGGILTDGV*g$K<NsS7*tcNxEQz?z<~zRQJz?=04r*9D!~S%rYL}tkQEoC8v|;>
z<R>SV<QIWbbV`0XLvCtGA}Dc!*@*=OsVNFbLg4hFp<1A;TA&GPX+W8vSOv9oL9q(z
zb%C-$s&8tpQ);?~CM48TQi>F`!4(3i`+}^<H7^B85v=0|GEPBFp-w}?%mmbLGc?dt
z&{Z%5ndasg;^<?gfR>gOk`wb3^72a*a&r?4pe2Vw2`E!5Xs8zGs}^7;T?Ti5aL8+c
z0Ic3qD9uYrEy6Ip%t%3_ATvclHAPbaq+AQ+XGs4F+(!g;r_f!LS*%c8T3nEtmy((S
z3N3K0U0MJ)NKe5T)PzK<!1cHo-11BFKvpTFB$hxrJ{rZC&bLy?%`7fX1uIOgC`e5P
z-Q)@Ka530z8AZBwnZ@yGMX9Nv+8>%3z%@5GN=m>AAY~?~kS~r;%u9&}m-@w^h=leL
zH8hYFf@%{KNkxb(vOS<o1Ma97r6!}OEe6#l$)!cbnfZCJcm{==h6b7ptbd9lrky=p
zoxK$x`O!*2wHTDylvInA6g0p&PDcSufy<g8P)NGum*;7u7UU;q=qO}^(`G<oQAu!S
zRjMY;85t=>x^`eC5C?&Mm0Vg>l$uu(59y)7l;)M@<P?+?fx{3K9D1Nu4k!gfMjW8}
zK|=-bem0gd3$S)j`%u@eB%=tM*<dGtR2UK`3sQ>RRImjM8X9nyLtF~$acAb|#V40k
zfc0XC!G>M(^7B$Li+)%i1WB8Mx@xgHmRiCW)E|H(RwUKM;LKpFnxbjN#h{u3j!ba!
z1&^{|4O&oIjmIUOk(yYb03KjLF4{o-NpRN@T+)HZK4AXR&?qhfrBYC$)krCZ44)KN
zLC2fGWxs}oR!VV6Jg69i#RMdhGgB%Q)D*JaauU;nEAwEc7-%wpl9qE$VsWt}sJ{xf
z)F-hhJ=Hfiu>c{Yp^*(9zVS^=&je`(mm}Z-D=ke>@uwMW5UZ)l0L=ud#a5tp8`!|2
zqQpvtg2bZ4+|-iPqGE;ovecrqocwYtNJ~RO3tZ4DXsA}DC}=6DR;6fyN=H!Pn3M`?
z92BJ%gWE=+eha9!1uKs);X<|x)Dz23rim@kAV_7<(16BDYD#=+UP`=zE-cnkQ{rK{
zPr=SsL8BOy<3Je=8ZqGV#j`jdzdW_bKP{v@Un4OmGd&N~<OAhtP;44#GI)6Ug;;@_
zmzDXY3Mu({>Lm)vpfRV!r2NtnP-DM171I4JRsgBUO{@fU>|t)mFN)7itc))L_kH3)
zna9?Uiviwv3dzsUVQ>u!@(;37aD%rEK(!ASOjxxTT1tUh4XVYEatRzQnhHskpjK{v
znu2Pvf(Ez`u8^Fcl4=F2VL;`#fr6Tvf>J4@m0pq$uGW+gz7G!d^>qx21Q&k_s>KW%
z8sI`3RIyfpa&k$2Nn%bs$Tg`cprKA91JI~pa(-@ZeqMZ9PGWkohNi9^NFLF*RR!m~
z;QX|bpyFa5P><KOA~`iRB{c<9PbDQLXT#DzC@?@VqR9ZZ8Z#o0A_3kig|xHti{RHp
zLtEbYMG6`P8I{GL&Ofx`)?`oy4K!LQxVTtZf!i~ld6^{|;7VLWBQqsFJrz`gfSQP)
zF<`I?O-*bDLs~{9pixTDATPLBwgH6_vOXlsU<uMQMIo^mGzO&ruJpMu9OMKZ3h~KL
z&el*Z&`~G{H8DZum;$u1X{(xoPm@AXD!3*rO9e%CPKmA^R3EH)1ahBWYH<m;?#5#~
zbT|j>PrMc;rhu9uswuj5pvGioUN&CU(A<)dnv6xABWN56!|OT<B}J74g8;4<H3Y!n
zhe+NU8u{gUsqlIcRNf**5;(pQ1{J54D1eoNf-)CJBLiJKB>o^>1CnD9q7B&x_>5No
zmA9x)1gAq#DW#F^m+zUPiJ9PCAOp6LG_P8$2SQb)3{VPM?l>oc%C!7~)I4xU*h&Fb
z@&qK7WPmz{CHeUZIr(|%Rtl=gs8CN&kBgzWBqhJJ1Vp746)^;*CZ@P$=A?$?JC&xT
zr4})0Xn-r*9C&6+Dosn%wF8yIpau_vh6bvD0yt;oCRW6QwJ<oAC1&P;vYrCC!~ypn
zREw=Z(FD?%S`-a3DnAWuOllFhg&zwmW7J~|)HO936hewh^O6%wQd1Z>Rg1YeId#D$
zrZc2%rVs`i3<A}Ss-PA!hye{6P+^9|g*TAZZPh{59!MHljG+|NjnB=@1KFfdTvC*o
zm(BpH*+Dg6F{qCPX>aN=fD8rcwn@z`D5<n#K$QKUz*5LB0F9;>Lq?}TZ6Pa26{7$u
z4>UBOg)eAU2UdE4Y$?{%WJoM6$!E}GaB+2W4D|_NC{D~v&M#xo&;Zp{HlP^}P#p>B
z1i@M_nR&@Mr75WlV4J~%izwEEMpe=?%b=-)0jfGaGc7)~BD1)pm^gh38kuPdnc(?^
z;*w%b2KXQ<eDJmuGNA(+P62gR;R=c%p#Z6M6pCTP4hlt}k;~jvP^}0WS5zp=ECLOA
zD}Y)(;E{Kb3}|FWKL=!94ycO?8tu_zNUbPIEy@GU55Y%m;|mf?G8n)Kz9e4(ra%GV
z2t5VQGzD;EfyZ1GO7in_AVaRjsfk6&844-^jv*f4#0d&8B#jK9+Mqlh<SZkQOW+;`
zi-SgDL83@jf!tkGng{j>ScgJVW?o`ZB}g1@E@aFA(l;$u(14o`aT9n*Dk)U~G>xf{
znWm7FQ<kd>*INWLFtb>pG%pdBzd!@UMVSTQpolLhN=?hGU<fWL$}9j4X=Z{)0n#!n
zAh7`oR|Qa*6@&5tq~!tW;edw8LDQF|dF7dTDWFl}WKj7J@-^Hh9gxF7O(%u4#NrZ#
zw4%h^RNaDn@F19OQX;533elcg1RAIYi{~ZgC?NW5rA6SG6;zAT5=#<uD6t4^03@ej
zdLtJUU&)jh4>3U>)S1>}fJ`;TXXYoD<RFF>!Q*%kDFv{ULJ?>VsJNt9j{%}RJ~=<H
zB(<UhJWS2tn^>WcR|*>G29N84<~t$5S*(zqT2KN`kEx)MKCt7#qq_PjsR)i9Lr#7=
zIK~;m!Sf|K`RU*xZzY(xUO{GxlAZ!+>=`_jl$Zk<?uN`(DM1Q<C9u0eoYbNssA||q
zb!M>wTmo!cYDH>1Xt0&R7c{q(p9da!1vx*pA~m@b+{yyYBjkZP8Tmz^whJUmz;=K}
zlk!p&kd%Uq0%Z-b%QX_g2@>IYm}OvZXhOVO0vZ@E&dE=Q`WZBSf+$y@v%n>wQE!kU
zPy$a(Ny!A2$RK+llf${GiQws1g`9lw#E2e4S!z*IesN|=B|{jDr2rWi*8q*87iZ?A
z=9TCufQHT!6_PSbKt6`prK4b^t)L5;*MW#=!t!EjUKv9;bWWutU!f>9H@^%zW(Y3`
z!6VErkv=Z*o_@iuK_T%zo=!oIL7uL`Am=8Q<!7cS6oA^HdFh}M7&NU08YC}D&C^qG
zfleo67Auq#m8R-3K-$;PIbrB5Jah^JG$#ygZD;1^=`n!#@!-rIpI8E_3`!V0^UCtG
zQ^B*x3Sb#fotK%XkO-P51x*dYW?1zUJQ9mRGYgREPEZ+zY_lzRgh>Z9OO%<W5FejY
zoR}A%k`Hzk#7dMoD(H+NsNjX<og#&d#A1a+h2)Gx(9k(3<Vy4Oz$Gzwpc1`L2Fle?
zD?x@p^GALWq%=(~N-WM$0FB|NCZ>R*4bqzf`ON@SKINB|=;o*CLV^i2ISHC(EiTQ?
zO)RQJGC3u)7~G5jPs4&VLyAp^!pu}~!bMJK5NUX+3f2alh=|WkEMV{tR)_%AmX!(`
zpaceKY=c!nQW=;DQIHP`1!yRNhIl~J#h~aY)=>b>%0N_tr&<)ir3J)NO+5y1B*uf~
z(-@pV1-Sx*qmWpX4xSt-h8JbUsp(~i$)@De;*$Jaa6PGBtPt$!9_;EK28(`}i@{^9
zMXBkadF>)lHIoWc0r3J%3S3vfq879^02D*zpjxB|l*XZLcZg?TdQgl5mmQEHozh~^
z^mS2wE;x07CN&i@OEmQqU?p;KW_nU-F&>XNg$Bc1Ihg&Cn3P{sg2x+<PC+3<!5_t$
z>6tk>cs%0i<1<A3QBssxfX5>tL5=}K#3yM5sdzl%7T`Ll{Q)jL;z0#LJgCr$hn6f1
zE~y1Yso-v+9;n9%DvXdSDM+goqBb5<O4u5L`vuUd11hCuYY3?~Kn?JM^rA%2kV#2C
zG(_UHY>o67N<nMnGSd@tN{UMole0m!1b8)2X)$O~LJqipQj!X7<bzgVfJTuLb0B79
z=B2|cYS_RSVnGp11W{Fk`tXo7b}4!c$vLTsMe&d|F5scPc+h%_V$dWYgAZtY89H$X
zT3H0@E`gU*RHYW>>!xMqfaWes!5vx9pr3}He~@diYfzZ0CUWhVo0?mkTB4x|YBXjR
zgDeNtsc>7s<HVpw6?pJck0CifC%=fn8AN7Qr9vBh#a0R$i8<womBlrApp`T=pnff=
z`IefVm|PiO05UBx1=JQ!fvyz<O_LRX*Y$yd3$}1DCo`!iu?SST=49q&r=}=?7xLv~
zCP7V5Fw!&9Gu2}NcQHWo`tc<>#qsH>CE)%VQoB4JMM94uBQ>W0x`qnmJJ8UCLP~0J
za#1Fv>#oND3L(U>D0n0kT#Z3id4QS`AQigcxl!<nF^$v;P)8ipGJr%6C{z`EldQqD
zWFok>(@jfE1}Om92TqSE3c2~kIhEjsehFlx4{Qsle_G6tkyw-xUsPO-aEC`?QHnxP
za4^!Eqa<(|&dbl!1x2%tLZSj_ls3HxH0uQ&N(Dt?aY15v9_k!qc}8Y(255l|V$~IB
z5TO`s0l1n5)j^Po7}o5_Oar?Qy5y-CG#vq2fyPjrpH_nERL~eQ*d(ahJOy9cI2G)F
zP%J_%f;$Q{h_6swngm^k2VFX-4_Z}{oR|Yz?gU<Qm6(|WYN-~1$M_ZeLVbJ`G*VJQ
zQ?{U}g0AF*ERBFHbO8-TU``BZLf2w}Tmp)r^!(Ifg{0J+e9#(}R0U7~L1GP>u^_HZ
z0jUDb$|Qmp4nkKkfLso;1)PH+J(iM;#5^P)fclda@t~408Qd)d_a{M%(>&7@5NRP7
ztN_W!IiMl}w4f>xv_KU!IStCR;I(H^|3ioM6*TgT6re5VG?;TRJq>B;Yl1RVVnIA~
znI3~{1!yTBXd(tw=7FZ;pfW`|3W>#udAgth4y5LMQ7UBFaY=rBelcV*O&MtBqL{%S
zv^WP6G@uTFnTal_>jm}|Xi5zn_281X1YAmhdI}J;6iV~JqbHD7J*brliWmQ29fhRQ
z5^#=$43(voq=G^M798M$q%1K<K?AfDG&3hB6S5YkSW{2IFEu?8w6YV{fd=&<6;krS
zh9#DifJT=<_CP%Yi%Ia3#Z(3VU_CB|<itEswFL^NWKbWV7__pdBo|bDK<glE#wDgG
z=!3GKer{qxu|8<IORk=RZ+>w}P9>;Nfh`h-6(8`fa51QGE=w&+Oiu;b01l>P&@^FU
zda6QZURr)pE;#AHYrB-vT+mvN#1e&qqWtut#9W2qjM9>n{PH~T@E<4uk@UlsS3%84
zELMP4QlMoH$@#ejnK`KnC7HRYpneF{+W3^rB8Cu98Y}^=DNju<0j;$KmH2RjL5?Vf
z_iVv~8DNW{W4$Svpe4uoMU{FCX{9+i;Bp?cV!XH@F*y}JF{c2sKPR;$6+8+D>Mnuh
ztre0$OT8dV@Ul~j@=|j^^<yHa7ieq*PFe*yi6x+rDTag!C}$?6!iOzWpo?&kXRo2v
z2$pGZq=mT9&SQLXeo-pOhYT*z-Xuss0VD!y6(~5tou{LKuEo|6<V<J|D9KlVj0`}v
zDkLfxnuTa9fQ<u<?&&Fbf|qrG*0(A62ZPr&CYC@aKtY-yN|C|?RN#YR0+D_o%Nija
zQ_%E9QCX@&PJRh^sWNQ17LvapEu!4Sl(P7g{Jav7`S2tM>UbBGCYOMQw7?-=0?9In
z^-~%drRk}fu!c)!9>i&2UmymW<1_O>1Fi9CpwY%+XrM#HQeb0dnc!8i$=To~Kj?`F
zJU#*+M2#;4WxmRsRH#WH+d!+Mz^NJBmk-M<E=|l)2rem2$;?+ME~(5(1usFjQUK4h
zXc!vkm>6kVDd_2eT5~C-1@R^M*{OM;X^-@h43PH=K;uc7WvM#Qb&ue#H>gfYgtiR9
z?o>$3Db9y<%RwvIGeCPAAaf52U;`B(BdXwfD6<%8xDXN&kVpcT;KksDplP5qlu}xd
zlL@IAKur};4uT8{6zeItRwU*Y<fK|DsJpnjga*Wi_<OthSt+FD=j$dV7U_c4daJ`T
zAgJkJ02<CpOwNu6yBD;YGdHn>!3|t~K&MGS1rc;z9C+yzxLFL17CnXFR74gk0+o5t
zD1wYkq!#IAKpH?9sUSKRlui+CF+GLQ;#39bj0mWJO;0U>ucHNJ)x;7#hP?cEP$G&i
z0PREoxe(e!21NsCWDGLu4{4WyyadYEpjxCHvYHPxc>&U|0M@UkzyOMX<dS$0m6r|~
zvVt|yAtPguV28*f22((#38?TaNG-~#Q~*__x+SSa&>1D9R%&rcQE^ET$Z_CO8Qg7v
zj<}Q;fyPLSia{X(3f$t7BJk)(aY<2fVlik!P$8`}54>FiTsWp>g7#W~)|7(>oQjbf
z!ys!4@`$sh05r^(0<tl=xF8R12PnV^SW%LX-T_iT^$XZ5pd?saQdE+kO^VqCNkwRe
zqZ$nlCXhl>49-a<E?jazdqncU;gSbplM?oMDWwHO1wKe2-0{T3YH|i~i6=RuNCzCH
z8AW-eIXbX}RFs@iM7({uskzCyM0f<E4sI^?lmp5!$)JT)Ff$>!GqD)7a{-d6Am(Tk
z80sh#80jeFX(~XvlAyjuO0hy7blD7aJQP&ZCxT{b6$%W&{wpv-&H}lqxw)y}78W9>
zB`QEO88~4=RA^{ocQ3d>2<};C=9Ls>5|L;i{bzlUFA6F_6nM-ZqPsXVnTY63EFqj~
zv_S1ZcvurQG&L`Uu%X4Nc_~_i3{6Q*&MyKjxdydK!L3-h!7wR!d#OkvH?g1~GcO%n
zqe5D-#i==I;HE63GY=ZZ(FJuo!Gr6d*`Q(u(AYL;ArymuS!z*HW(s7=1lA}8$$~1-
zlG0+(!~>{c0d<!Z(!f35#5~A!69aev6*PefE*If$ge!-10l}(3vk`g4CD7>s@LY(7
zCVHg}(g-#RI>v#qfv_OCn876#R`aGR<bt+26y&5r)kBM_%)Im*P;aobC>hk6g4WTQ
zc?u|dwIKZ}&|ZU71r1P_2|N)1-Z}-Eok-420X2r8Z5PnoI;iyq5(2dmA>B3<Z5buG
zIq}K)Wzco34DP9Upj{%V3Lpsuc;g$=M$m(<JAh0q27}iifM){W4J17VP!lg6*0cky
z9t95vfkGLQp+WKrhGx*b3SRXLZux+h+<}LiKyAWIaH}Q}v?LGQTLVopK#Yb@1E3iR
z?uUb0pw0oI;6bip@bX9So(+(8g$z*rnOCf*0O>ozrpG}61D<jLwQ=+E%R!Ac(4G&-
zYUg;+j3mOUlA_G?bkM5G^28$0ZYjuwCTLwWD3$7h6hmh^!3_rZEHAkJPXevAR>)0E
zNo4@_$>Kqs-T2hp(i~8x$;*dsSOZM~g}4TXDERyNM1q$Hf(jr|Mu7Dk;aLZ?qyeHG
zp0QFClt7!Jl|ajH5{p4wDZnd74MB^fARCThYsd^i;~6$K3K}K`poR0GjWhX0pjG1F
z9fWD1A}}|xq}WP9RU_I!*D_X1(_W*hCMQSJzB)yxRHs5GqSjhLwZK|IHCi_op(I8x
zMoZJa*jhm~nG3W<64W9Dt>=L@e--Q$3>Y*t6g4zJL$aBm)!v{roCXRtH3~VYX(jPl
zrNt%SeT|x+HI7=zrA46iEb7JTNUH`lG!!!u%TnXZGgC@3u;_&E2M1XUT6YAZK?`IU
zG&FKj^U_N)U`uR3ON^kam5{n_@t}3D#qoKixnOm$6@j220__CO%+Cv{EJy_{%K@$T
z0Ywcc2_qR$4DJbl`n#aTKp;hs1w!zc#8eAf4Fp>I1R4q`NGvJ_Zwyz2Y->j~04%G3
zYywDMCMaGNG&GRK<Kb(hK}$eO5<vx{tu1W(0+<io&<6@cP{mPN3|jsT-Kzjr;Fg(}
zS)2jdF$0PR$R>O6n1m*D(?CjU320{|XqlRZ1`eIzGzc+YQxm#UJP15JSX9XX+Ld4h
z836<3Mb%P;;!IExnV6TFUkVxnP0YzGOI1jR?RNnWJ*Pq!pXw;2RA%O-gF>JLyiOhL
zO6byT$QBGxAZlcX=4I#Qm*+vY=_9YX2dzkh3_F9i-GjCuC6`p_+QD243J+9&c|tb)
zgBH?)78aMKf=AjDQ$X4wszFAA9gQRdG8nwD545r?4>ZCJTI~VS!=RyIpkR*@E6(73
zZYc`zjV$1(fW{Rp;6eUHxD&ke%mo}5ppG4As1Ll33$z^-;yo^~60iKsJe&$ZYpyd<
zJp|isp`lR(+53s)C*(a01Og4}BXFQ0Cla_gB;?Tiq@jT-08xaj-z7B>lJd|Lf+HPS
zA#$t{Qj2CNs3j5)jyrHVh7_fsy;BO>piM^#pcoAXP4~E@7UY-sffj08fmY~-7N;V%
zrh!TtP!<IjCScXz%_hEyki8Y4B$JX_P?7=K6a!LY1P&_j=0K1(P|gPLNrB|#qLTQG
z{QT^AP=J6JgM(JcBSa8uWg#tO`1n^5(psz36z~FZ@Wu)S4b_~S6deT+sma9v8m0#A
z5Ab!ef{wmefw-Vu4qygoPz1~XO?7}7;1K{Y3$)7u%m5EhgIVBCf3dA<RZ6sKRZ6Tv
zUP(p~h^MbwmBIxZ?oEX)PeoZ64`0-jie-U(VhMa0PqhG41RyPmFU`wMEKmZ~AqI%h
z(9l3xjSh(ucx?gd_k(5$6+l}>i&KlrK${TKQXnNtT1tG0rY>lY8JG{=V~_?h04$)P
zQ3_i04pPCOp#hVD<(_2lj#ALzLT+M#0<66NsU<X2p#iU>pjuU`X$9Jop#y5G=H-JH
z{Db@j^MXckYC352TrV{bl<Hkda|;3>+sJ(rLDN={9p#XrH&6>(AuT^AC%+uDs+JSH
zF%Ps#mcca-yxIlSOb3mCB9w!6mj$>oc>4G-fL0MOfSOGVPNBgJpc!n2P(N=!|8PIh
znh!rmA5bL@PR5}9ES|-odEjY_RPc5^aDaeA$PsdOMlfg)7N;U;D1x#PsMQ3Xu~5)b
zfVNo-O*El34Jg=BK}Qzk<%2T^Odlw_fY|Y1QP7e}#BM@xjx9<B_tpxEQcL2K6N^i1
zKv89<0UAGx*MzDCX@+mSMAX)x9m?P>7<u`S%@^T`nc$^s;09_cXiNvZiyx{3v{?h9
zQV$ewu0<%T)HO6ffd$Ip(EW3uMb)4P^i3=%)&OlmP;><y$N*}QAi_`)w9yaL5CN5G
z2AT{=y`^H%$UkTmFlaqIND0`xkOB&HmJ3LShHptlD183_g9a)eY>h@D`0xtIzS&%y
zJ7&QZ6=dTHXh1O)loC@@koKKGT&9|$Uy@jyt<Qk803AgJ)U*Wm*)#Lf!NCM-o~0Hc
zS}ULyp@xQufu)(ICe##ABMWI}AQjZ-PK7R{MloEE3mQN$XQ-xtr$$Oa+hB4NK?mf3
zLj^Pj2g<OZPzRTwN^Y5XDey(<zTne7f)evUQzD?n0woIYWv<9RPDw4(FD**UOUciL
zl+2*fQ1CH4AX~tB09^XTC*_xv<mVz6Md_&}Mc_=MVXUK|R+Iy3;3CBzq&!h8$^nH2
zEZ>9sOQ1pxA#0-mlLQwE;0OiV3!Msw467EWrpM<MXu!o%bJ8?4brjT!6H7qb6`?r{
zlyV@U3GR%8+CU(0fpZUJVRdnGNsdNQYN3vTk&c2|UUEUHj)GcFYMu^wP_v+<NJjzG
zodDHK;H`9!u}y^DB+$t}po4u%z^4;H(-1gC_!p$+IR(2gXlQ`u>A{P-G?Fq=LM6C7
zGYxb`LQy8DyTt(ECW2370iSTfpbDN^Q7r(?=Rj70f;TQO1i%iJ0GA;ME+|<sfCjb^
z%}XmT26$6b0laJ412j<yb`PlG1S)Aj1vR*JUjUl{g`Bd$;0`$lp)9cov=Jdc4YDXg
zwW<`VIwdtZ2Xr_9m|JY6T2+d+ky}HxSQC280ccyW6&C}v*~O3sZHO~~t6BxsQYa%M
zH4(HYS+$e_rEW_C4SFONRcbPT*ZP4wD3AkCKt1UEJOyxl0NR@lmxr#@R!}W~)%v!o
z1>hatwvg(zSV0%OXFMLXoeZ2*H430YnhIJ9*}-57d?CXdnV=my3>q35xlkqXxta?4
z3faD?C5aG)(83ViAQUyusW~~|V%@VCqRBTk7h2U8fRYA0mto3l6hMo1gwve!N<dD4
zm;^E!vSR{~EA{mBi%N3z!H1?mwvlEqXdoAlumc1%)F4M*fR6Jj%`5`-)-*vqP4F37
z3>q4#pu@Jnc@f+fK{gk>FBoKODWXm3o?7BloTO2jnWCcrs_;OilA=bjfu3ivBe-nV
z0C$Ir4Uq(pybo>Y!j=wOA$o^->CjOog~Vd$NhT=@8sH)c+oo}N?-9E`P~ED@#enRa
zqLLgvkY_SLX#%{(#~j|pgKvklQb;L<@4E*t)hPvS2FOf-H0nTAC8P`nZCVE<RnUwE
zQZWm!m_a>Z=ltBH%)HbT=uXl6B3K>-4H|*wlOelZ!TY?S!%Sc+Ap-ENps=x-)D*CX
z^z`)M6P)p&fwTNPBmrpCFuw>S1-2dRX&eoUqSRtd1vSu0C+N0QXfi{Tih6qb#99d2
z;F1#$K79ymXEJE-Fr+&IO8goIp+4XYf+P-VNoD($<~oCvg2yQ|G?H}fz?~6r+XB`s
zCFl%DK!EM7faVengHTOPP!b^40|iBypcT``Mqpz+iyc9maZ^(?ic*Vp6tY3X0Qq^4
zq5$3!C+IFje1L`*a}x`|W`kS?3FF+v0;6cq7Hn08Y>?STpv}@D<@r9KqjH=oOHx7Y
zWzY^baH<8J7U)-+3p+#z;v~@U4ncS1WEPiztyToB@~8v{E+|$E;9Il7C(D2~xqyd=
zK|L<@VpxI&AC?3=I0WjYRE0#)?w`EkwA3PnB+$NiJ(AKVWLZjLQKeo6;?xjOw($Y2
zu0Yvj4s!<i`3BUVf<<R;VnKXTYPt@1subLYk4Gw@kX3>s9-a^JDS~$gP>m`|Eru5D
zptdxq`46=moDooD!6gz%7Th>uKz2p}PNyPo9|mQkjMBVpP;x-pZ4YY_!NM@V2sC>P
z+Krc=1{<d>DFO{mfyVscaSJJfKxwuZROkgj_C|RY`)1~)YM@qV$zWUKL8%zN?J)!F
z!ORp;UIb<Gym+W8uy|f-BIxuPh!`wnGIZ@g-cL$R$EpTo3POp3wgQv`YUN<p01EB`
zuoNOILt3L5xC1n`JU%(GATc?!q!Q#XX!i#)APwrbfTJl7MHOU`W?o_rD9wg}R|F9*
zb-+8F!5I>{OGDgIK!%!{h#Ui%Gg3`aD9tNMP0mlx%d7&ONR^YAu2Bp+jskR+4`^%`
zv}v;xGPDTUIS=*?s6g>etbmR=!uD{2Xb;Fqgr3m7nV>ExsKhb^4}imYW(;s9SVA!m
zy2OkjF{wB|r?ezB9z5Rx8n#8q<!0t(<|gKV$E_j5+zK`dpn)i#)I0{q0?@)mKggak
zNQVo4Gz3FIeld7p-UiewvV$Hd#b9fzTFe01?F(Ah3p?HsG^dykIwY&8L=kj=k!p&q
zEn43PRKI}R81QZn19X%DX~+hg7a$soN(@1br_{U@(0L}%0#pOkOerccg31^{>mLJ6
zq=6ztA4(HERRTUk1o?=CVt6MDMFF^P0t$F=X9L;|1D8u`AP#6k1in=mW-w@J75IdW
z5<+89RTa=71JL-5CKp3-C8*n^;O!dZ7atJh?;P*v7~~!XH5Z$-s~;X&{CbhKYG}Y`
z1t2HQLWkaw+GVPU142M&Pn2qbhM@EmTtFq49+s0@(u?xTK@BuejRNY{KubK;DzHv?
z$U{e4AuA%my}KmP#@c-FB5Et>F)#)UdHD?BxdaA7hRW1p2G9&4EOIeT$jmE&ZlH!4
zpqc_oJ`k^gQi+BJtdId!#85dzvVjyg(9u*4`21HXsGk5D*aJ1XA>|%;U>mNY6jU%X
z7%_m?aTjNn!AB}F-H5!LAGFC8#lO%Lg{ccP9EI++0>XtIIESTx#+*T=1-R4$_b5PR
zIw;$Nj}8Exhye`(a8Crp2enN#G)j$)Km(ef13<EaQo-Y$Dd5wOHKC&cAj25ImMDO2
z0UfvuuX?gW5|cnJD@{!X=owX@{jV@~dOm2_p{NALPfRWZ^^%Z|a~@@mhQMeDjE2By
z2#kinXb6mkz-S1JhQMeDjE2By2#kinXb6mkz-S1JhQMeDjE2By2#kinXb6mkz-S1J
zhQMeDjE2By2#kinXb6mkz-S1JhQMeDjE2By2#kinXb6mkz-S1JhQMeDjE2By2#kin
zXb6mkz-S1JhQMeDjE2By2#kinXb6mkz-S1JhQMeDjE2By2#kinXb22~5MZK_8#vI+
zrIkHs){JsTLtr!nMnhmU1V%$(Gz3ONU^E0qLtr!nMnhmU1V%$(Gz3ONU^E0qLtr!n
zMnhmU1V%$(Gz3ONU=)moz-S1JhQMeDjE2By2#kinXb6mkz-S1JhQMeDjE2By2#kin
zXb6mkz-S1JhQMeDjE2By2#kinXb6mkz-S1JhQMeDjD`R>1mdIo%pf=K8X5;z<|gIm
zWLBj*=clB)=HixjNi0dkls62?C`wIC2`))2Ni``b%1?GJV_-ls-@r33vm`SSWPxjd
zUvRu3vIbYMZOG~^+%oeBC}u!bZ|<8~lIWXQU})e7x?kHVCqFqGi#@ry5RYNlXJ`a*
zzjIM)Vo54iok_^{AvwRO1dH;_N<Txx`1s;Pkguy!iwq4Q=7&@kq{4iQY@WFz<aT2$
zMj<&FDLgHMQgc!hi&KM3@{3Z5(u@*bhDONxaoLKn&m5{8mr6*0BGeliL*3+_lb@8B
zgH0RAJ@F;QiFxt4r6s8q@kyy^`9-PmpqPW0#sItd8Mizl{Tlg#3<)So^}!YMS;*mS
zXa-Xsl$w}=PY=v3AR5_!5dHbZCAc+bg7hF`B>m=a{UkU5Nxvaje`p>kxUhw8ZWbtf
z5#eJBRu8fZj~-;Vg4oFRLDH`?$UbxERooDJEnQOcic^Dg5|hAL&p9zU1CoI(gDdlr
z!5UyG9*22`mPNP{GYN*H`WITffUT#w`B*X&Q4Yry9+aDh2z&F;yyA?+B1n`NVs#cM
zs=*kCd(5HHL#_CxhIyul`ot|KF})b<Hd83mJ2}`m9+Do=N@0+KfW)HW)FLCpfTGO2
z5|DsPYH@N=W<g12eqJ%C+5(3Kh=`9uEyc~iTGCttypyZI@{sZ?JwHCNBtJJZ+1MyP
zCqFR-Bn8Hhx-}jyZ)SpD-q<L<7*w8vHG|xbX+B<gGZXy!3CSB9#iyl~Bxl4Yrhq+x
z#r=5Yjg8_{E0Qx3^U_nnUcjOsue`BQd~$wnL1IxVsySf8u!M)12?6!+^3NhS#WX%6
zu{gsuz`G3I20)~DA45w>)ekM^^7BekD@t5Jg(%E&ko{=s!O#?3+Bs$BB^FisCFZ80
zq#l&|238*Bm*!z>FF-6oxW~u@oYZ_1OOi8EQ-Vti3W`#Ti_sG(LcO7(iwn4f2W1Oz
zUO;N0l%%@mg4$f>paMB8u?SWiBe%~W^`}c}aY<2rB{l;<6$+AlM*gKG1*IiHsRj91
z8$dzcphliiaB_Y@Y6?^pvVA5HF_+ZD6i}6d&Bg%K%xB@^0?`9^J}u2NgtlKia|^Jx
zUO?fAC}g2dLJA)<XoCsdJ|or;B>jd^{lsboCm@7=BS?IL>U;m9@S@C;RAQ=qB>l!v
z`@!xfCoDh?LYQZ00W||^EJ@x183o4Z<*|idVqShoCOqFE*=GPrD?y3L(3%gL0l^&<
zXmlZ`A9HYib1p3^O3f<?E=k1ReE_=xK_J;@j8bq|_~&`$XXd4*xCWFVlq1`Rs@~E+
z4^sS~YQSl}p@Dy%OKJ(IsfDZqr+Q2Oyx@|=q7pO*;ZzSY-z_sQvp6F)1*uF!Qf~(L
zZ*ggEYDi`Zwj2yEXrW<%9)E@wNF|#yq|7xm2G`GSMftgInK`MTx)!P%xjcmxWhS`F
zyWC1hc@6E~BKn8!sU?nixLf>5NpRc1_Mx;N%pi#h<R(b{k6s^GKot}f<rf8)=H@0A
zRe}@;8-iLRnC2N7c;=O)7Ud=8K+4JBlA_GKbhE^Qg4DbekVddA2nS(=pLu9ON@7WB
zKv8~jYH=|}4TPcI1XLg(RaXJYC{cu=-WXhTgyaWT7U$%rgIt7g3?zI}!pF$P#n8aH
zGC3#JIU^O8gUno90x~L#Gm{f@AZZ4YQcPW3eDc%LM9rbK7&L=oxW_yb8eZ|mc?F>6
zTbgS?axSbn2FhP3?y>MMNX>(#B2ax~0^&F(g96JJG|Ulz+C{^#&&(||FC`$cBqJmr
z5^AVHfT7+1WWH-fW^qX|s!B+(VNsuxm<~?wMV4R+tUtgz8IlUo)f*WFmnIdLWR{ec
zq`Ku7f!eNNi8-a<Oah8ZboG{D!G7R!4HQh70p7_0hQ{&nWr^`QnZ+gXC5h<}XTeEy
z{XT|f!JxiF3d9ib$WRg<W6<?u%ipG8e?meBUA>V3xa4(7EyynkN-aw*Do*uHEO0i0
z6+uYlj|Dho`ljaQ7gYun<)?v*ie$|39hCH7Xy%?;f~Lo<EH^hPAUD@F*dQJyGhj*I
zK8D7=xrqgCnH8xi;2I31)jJty_!(LRr52|am8AxkB<7_g7NxkQ6uTlNIduOUn)-rF
z&q)o*hqw|HOaTa2VW>ys2T%YMXI7;m8;_A6jEo@027y}Wp2d!3iJ3WxNja&m&@m<q
z^G#eza|@uQi*I59EFNGU#!zqRo>~G*C149cDHI$n-pK*E!A9|z<)4pPacW6UX0B@{
zsI<nEho*<%%&Jt+;?TUD%-l>+6$Y<T(d{=f2~LGn-XJYLAmyHUPL(C8#gG9@4E4s2
zDJh_ab#OsqG8QW^)Pu}N)`I3H4E4sI#gNh_Gbtw(DeR#Ej;`L&5~9X8v7jI`FWo1x
zGQYIM&=TCqK#_rVQ!(_Lc@{%sE2uOtFEcM4B{^WE2Sbza#LN=6{356(RMnXA0U9+-
zOaUqOO)P+Pxed)g+~CxlG?0)}X<8bz>;|O~4EJI6pE)Rz`D7NC_^0{ir<CTTLQFO?
zfmM#6JQtRlT#{epm+xGXU*riY%8h*T6H`)CAUa%K!M0-9XM(6Na#B+Z2=?coqrf1?
zq!u|F5e^SXjRsL~?pf@ZlUat81u@)X395g6^7GO`fd;FwK_xdRv@pZl2vlA{tN<5`
zA^8Q4c_~i$B_;W}u1Nv8!3L0a1w=QdenVrB%izIkl9`uTf}DrZ-REOyk&+XiS&~|m
zSdtoFkdaappPb|xU}%(*1L0-nrRC=$nzZQp(d;ucN=wYiNlHx42Dj46Fw!5$dqKg$
za3^7yXX>6>;#ZoRlv?DU<{S_TP4+PFVwh)W?wg;NUy`4fnT*ymfM`KC-yGB!EJ`nf
zIRIVW$Iuv}qS!Gn#Wk<YH6S1$8C;TKH_y<(J+;I&uPn1DKM!Okx_L$hpmNDMC$YE~
zJXV@ml3!$O1WL{(jseC-uC9h=0r>@`If*5yZbhl7pvZ$XmQ3KvLH!p<{xHUBm`{Fk
zVh*^#@C-JJcLixTiZ?Wd+v}N^mJcZmvDR-!j^MT@B+Oj{0+Iu~lPfbak|51ubpQAm
znV`21{PIC%Kx&a|Qb01n76-a{hK8UfjYnc$N=_;ymzzO2!I|lKi8<gVn=4WSLIe^G
z42)Gl42%^5jM6;p91|EB7(n7OP&s)J?aL?7%>)rQ0r43a7|_LiaEOBk!my~X!J&Q%
z4)HZO#E;+*zXKIl1kp(D{{rGOFfbT^Xe4nSMvwrezf^FD+d##U%@<%`U<iSV^Fxed
zP+?$T$bgDvf@ohp0Vh5QCq4xyJ`G1cgC5pCmVV}LCXilG*n_mOg9ru&u-+vgJq!#C
zcA!Hvap(ob$r-4+FfIlL246k_N0=Q>d<IT@7LI%lE_@A)%^W@Ky=;A~{VZ+F-Atf3
zW&xSYz`zg$vJ-AT#7&@dpaPYD3Y7<?1CTx&sQ4q0y=eM$7#J90pz@9&&%ouK_%xjO
z3_vdFVe5tZ9Fnejpz0^1*|P*H4sL71%|W>D2vq(ol0FFr28KIO@lvR`3!ehW>EJN^
z0hRj$mBSVvpfFWn1}R`*2m&2wiX%)5P=k~K6ps;5eW37TaO4vJg+~rl>>NsX!NS7<
zIXJ*(%z>(Bg*bshgMooz15|7h7Bi3y0Hy6aP_-sF(*vr*LH-qBfmpUq9CsQDK-C6z
zmj_heF_3n696|hs>@HAVD1oY7fvy%QFM!-X2da*X6PH_19RhOy1*o1c!npLf@S(dO
z6ki<BKnBMb0|NudEE%X+5h&ns#Qg-c`~)&91gZ}dgdi`1v}ZuYhzXx5P__8N2bBNz
zK-Ga8^G@J0#gR{;kGY?T0URfHpz`4K50QtLIn8W6ti3D{wIIK8uz_64z%UD%uCSFI
z38=vhPNNP`eIS2>OaR4i2vlqqNB}u4xbQi^$~uspHBfb|pmd5Oe9_|yl#jMR^<_cb
z3eUUXawPycxiKg(FfcrUs$Y%b9v40bND;ySGLr*TMlmoj6k;{A0L4sD8nJ+?7Xz8;
z#3#_l1SzWnpyF;IbI`&Z7UH0|tAMII0n!f-BZz}Q@-v|Frx5bsxCIqpps?Nnm4`+#
zxJ)|(6T@RSD1N>`)qO{p4M`VB@dHvP11j?v7#Q%W1G&Wos*V?A9<*MKfQpra+yeI>
zq&#rsvjAm6cH}?>nbQN+gKW+Ms2C~cT!HFAHs=LYj1+TZK;;et0|P9KL21?iDz+L_
zf8a>7==lVczA~WtVzGpW3m<Cw0+oF;pz5b#Q4bEkf@YNP1L-*f)e}af9#EJwfa(SY
z1_mW)+=2Wk0u@^iYQW&|BYL?9(&q!!w-XfbIP@*RQeL(|^?}ko$QdBBW<bS$@!&4U
zvAN*_RNqZJ`q0}zp#03i4YHYm!2v`iBigzOIK(ZW;_e{zSqSw3Sj0hblK~Zf2~v-l
z9~}7{P~#Kira4eOV$k>m<$X{XZGnn=A<Tl84WO{Q0+k21n{dPfdKv}k;{k;k0|Uce
zJZT%ftpn2M0@b%3>P~ER2f98`nAAY^xq|9!%rJ4`OF#`1kX;*~dJcoibR2#|uQNdU
zUO@Hf;_=%Cw6qC|0|ii8W?*2L3Gy3rBO@rLLFQRN#ZB<kUFd!WnO6YSHwhYdpg0AU
zwH;9LWgvTy!vd*I1k%3&s_q4neo&e?0Tl<eH5lOaP7k<-2g$#H%4b3KIq^xr(+nss
zIQT#k3=G{M$`Ra_fYb?2d<Kr-z5^mI+MxYF8>k*<kRGIdR0t079H{s@B=sP-wLrze
zqqGpe!`%k*^Af0h7c^`@VFnW40~L=1nO6gf8Aw0k3RHX%NF2#sZ=m9hNaCQlWC4|P
z3=9mCc+v)XngZEx1J!p0$vlvF2vpn&O*{uG4lXmG?gGVE3sn3fR6TNg2Dy#|nY{t3
z7Cfy5H3KAm0xGTsH3Jq#51`@=NaCRQ{s9&D1C<q6^AT!e4-`&1;0l9*p$k+YV%6i$
z_kjsjAINPfP<;YO@dt844OHA3)PcrKb0}>DP?`hflMPTkx1s)lhZR!W1!U(9s5*0~
zI#76k^nZYgPlbxZ^&{mokY6PPK?)ccw4iRrEYsZiE})ecpgv~+R3EIIcjtS+2(lYw
zZ4OlKAjoJ(J^_$D4N$Q{P<&twQ&2I8(q#wtO?E)_6_cp%15{rTC@+v;pN0^~(F_d5
zB<f3m>Z=0LIP60&Cqdyd1EijTfuSBmlc4VcNIe4sLk)-~K_3UGzsSJA&`6>_2dKUj
zJn?|de-%)D9eDI%Yo~00>O)W0C!pfY(7cH&U4MY8n*nMMV+|iiJ`dC^4DL&6fHD;W
z1H*b~8HsE@s4ofWxiBz*%JUGYT39*n#3upDEPc$~OyF_F5~w`-_+bwY@g+FK_dvyA
zbs8w2frPGr2nJ|dE)`NQfb#wusQ6+~QijwskU9=2?}L<xh=LR_FsOqlXc-Igmkw0C
z7b*@31BlN-`h1}B$ofFyDNu3rwq*@eTnlO*%>7fK;uc8aAp6%q#Y3Rt$aOf#o-<JS
zD5yNlyeCj`JtT3Ed4Hhd)1czW=7H)Z8F1&8fgulC215J`8M8!=bCBI0P_<v7W`XPm
zmGKEs@pw=>3A2nxY4?K4c#v6Bpn5?4CeS!0$Sjcf8mKs^x<D2`0u@J2Payx@fr`h1
z?1slTB)&jp%pa(HCp1lCmhmop=zR>3J4~PhJ4MiN0l5#9zI>qKTcKfq9A2<-50JVN
zsJa<=)Pcf(4pf~k)E>BbPJ9N)?E;WrPe9dz$Gp+}3Uc!cs62A}08}S2fGRCm|Id+6
z0Hjs~Ds~3yK9K)F?$LpYgU8t5b~y2Axbq!gg?W$x(gurwszr_ykl6(|#5=HvgZ#As
zD&7Kh3nUC6aR@T+093vhDi3liNc;v=+!je3<lhfaaZoW2k^-q^kp!_A81{iErX_qJ
zbs%vWsJJdj99j;5#7%IB`#{Cf{hWeD9OR4|s5q?M3mcyX**^m+2Wp;ytOwb<1}cVZ
zK4^UF2vnREnvNl1gc#of#oY_28t_~Ka@?V%B~bblkpkJsz_1cTA*)3yCqZ#z163D@
zPzP_fgY1lf%G(o2zaYPLK-HQ-&4R__0;sqhk~k>u?tqH#gZdd;-o@5t{{YnoUR{k8
zrySBC3m6!zKonFQWRC(=ToDv0SnEsBOa^L&3DOq<)fa`Qen;<vgUZVZP<?Koh{tLl
zs$C#GN1%GXLCZPJu)x&w1FA<96gNba%OHDnK#|VCz_0`qMnvjKfa=*yq#jUOm;%+~
z0@9NXslP$uYoOw>AaN!Kumni_2vi(7?SS&d9jG{JU%`bh0aAQ`+tCcNAj23Ko`A*&
zu!c9N8-m*Y1|<axs6J3MflL6!xeruK6;B%(eT)HQRtr=g$S)wXK+c{474rkd4?GV-
z91hA`JD~EY<vnD46}fHzx$6m3Ev)T^nLe=hF=XUGu3=zc1&u4>2pjbJ5oBKoRNrY5
z@+L@M4^-cAoaxww4_jOM2vnZ}o-rZxa0jK2KTv(B^DHiW29RI|&mAa$3tI*T@Z2*z
z9#GY|5Ksg1TLx6kB0OmWJuE@#VF6ShZ0-|QF7AMegU3Fg<rOGhT!4zt14SL&y_o3&
z?0=|QTz&)91qvXA3=9lM(al5ZZ-e~j0adpYPn@HdcOd^YK=py00`&(-d<InfD%4(>
zzc)a|L2g5C1D=42qqhwoK*f>G2bE<%pyJ}t{Dqk(P|HkE*y?}{XJCke>Ved=m|+Xb
zzY$QiF;MqI)It&#D7-45@`ZTPI(q*Pq;CUMp9{2~hv{zYdHDrYpA;VZ(BlVWp8|AZ
zK!OB)p!kb`>H~!vay%74#laLbzCmSR2UviC0aOfw=F350I0q`0hb0U_akvL6e+o-{
zppRLC(hsQ3^#Q8q8PrS{J_C>xxR1-D3=(8u$j4$HdYNhgRjZ6AT+rJeAU_pA^<77?
z1ClO4ewqN4H$ahxq%mxM0>#l0sGhGN3$T{c?tBfbsOcFL7Js1n`as_H<r9E~1t|U`
zz!?m4EsOzFd?Qp3DDXh)J)q*?mAue+1&Jp>#ldxXCb-H5&sA1H#XZseiBztD!eaqc
z9V4_{f#f52cz`NrlzA|a@+%;Mfq?<M&Ih>+L~FnPfvS4|^@|gq1gKyK4O4*Ugk@Ag
z5)2GHSmq}{&O}<i0#@$>RWFUjt?24Oeyf41w?hvDEMxAVa0bQo2B@BUP&=^YfAn+*
z^5zSuJ`QxdkirCHz5uv`$iT1#s*V`*LH%?OsJ>ZHcfsSy5wzCF0eQFp+~ur*s-FuA
zVx+VOa>Ep;TsjGE0Hw7vP<`PbGnrh#i49b?Jb{X5fW)EWu0Nn+2~hVE<4=%T2H?RR
z1_qc}Aiujn#ZExo3->#CJp$&so)V~fWHUOTVo!)PV+T|{G+M#w?+jFIKh#h7+yP1x
zf1v6W(CtJ@6QFQa0T<#740WLJL(1DWP;un`F{lU%fr=xoCxiD3LGmR~dGHPmc>aWx
zfgt;)K;^;he5ie(bg>31ZiaL0(w%PtmidP#P<?J7_e0AdkUf8(;^1NsY7a<UL=&Wt
zfdQP3pyD9=b)e##@s#=4>d+LZJ|}266O-0J<-;7PKG>QZ<oLu^7l7P;0jg&q$O}-n
zgPJ-opyJF>H$con^o2lrdB6ja3=BO`HJ~yF6kjS(@xxFvk;e%^dBO!M4{DNtlz_r2
z0xEV3XPX=}B#c@of!r_ws;?Qz4IuFqQ1Jqg1>xYV4IXPg02S|q#tFn<khBDH+XJY)
zHb|c%p8zP`e}Rg@=BpukAmf^_VJwhd8L%b>27i#=96kY1ooN6Sdjk^l<r9F-?|{O|
z2P$U{bvtr6fs$GdRGu3l4;g<(8-oGG{S2sDCM;@k#r+wmo(PcJsv%(n3cDvzad43b
zO%ovTKTvUS(m)ay0TpTt3=HV%b)e$t>Rq7X$m&7i7XuXsb$LKe0*Mts#d1Ibj(h^3
zaA|>xVT{Y8g$pSBH$c^{0_lgeb(%pHHpo9`pmNA#ejxEDP;uC}IVfF&#Q#9Wk>_JU
zLL%S-je)@wYdM;L+!O?-K^Lg{1Vmi9^L=0h&v$_QoC1{x*$Hwsh^~N&odgLmtpi6E
zNPGfR9Jw6@3ZoTJ@xKT=u%;bQI=li^%Y{%2FMmOK^9xjdBh-Jylt&<aI^YQe1_sy~
zMq>1V{FDOKrw6qU7XCF*aqzlvr1UohDjp3E8!vd+tbvMKgT$fgLGg72D*hYcUwGI!
z@>w7jE<op>zChI@$2-WKJo+GmQPVvr>{X!R<>>7|v~h2c+5o89dmy9WbsOdwIVhfL
zplVy7;Q}d#AY~UwehyTAI*M5c`8`ni4um{Bo<aV(1C<AR7aCq5@h?#E3s8Nq_}~E*
zJPZsB-XQS;aIk~NKvbaOMkwxd;R}E`1w5zc0ab(C&j#6*02N0r8$d!8AcBE`;VsB6
zNIr(g8Dy<GYTW=Tx7R@RR73SZ!V9(B2HAN9st%N9VSP_fK70ceht*RcF$P1BVGIm5
z5DL7eRRk&qohk+AaSf;#tX@Sf+d*;Vfhq6ArvM2ckbDMI9^3|jqzialf!xsnm4`0V
z0oyqTDwYUx8=4-FKlec8k;gqj;#Z*J?NEK7_ywiSH&Ah6`nM8BAk7R6*Pv-0TV6*W
zuL6a4094;SXnjnqz7D9qv(P+@O&@x{2IQv$P<^IQeeg7aR(F7+{tZ;EEHoWs+JTzp
zKw+t13<-z%APOlDSwO{+%OX%b2SCNKjr)MyPym$&?{R^|DLma{tJgt(Tmse81a$*0
zKZ5ee1*qB<^zcAx(}U9652!j28)Ph~Zsh?*AOi!#b&vp3+XmEr)PTy>p_mKmE`ztO
zFo5Q&eV}TpQPiO3PiA*UJ_|oS2PZxcC%ynrK2Vr|v~_?81_p-1c+wmCco<0U0jNG=
z!xN<Z3y5G~V3>d>jbdxZ>zIN9hJis5G)RTD%yQ>jfY$#2rHK@%KBRdFcfJLX_5nz~
z1uE|WG9Hp9;AI0yehE~b37T#p@ee6mKxy;{RNfJ)AC%ug@p=a;4oVlGF*T6d4^T0C
zB()%M4sapDzyPjuq3IkHz6wzB={WmbsCfqD-VmrBaN7nFPL6yE;AR?l?56}OkF-7n
zk_V8|D5zea162p!*8~X{h&n9&YLHvcK-Kf0gcH(O5!#w*kiQwg3uzb_!0YLlV!)Li
z$PW@wad6uoVmCZaK>948@)MzH9TeuEWEB7v&&QLt(9<y}embD~Y@y~s;utmWfb87>
zRR`Xy28}0>_z9@E8B{;WJs|N1P;vA&)(@ySY^?%Jy#Od9gZ8i?r4Mlahl+0ig)P%t
z*aA^VB81NQ`#{y8ug6J&ii3CBLfs6C-x{bmwza&_b{lM)8n}(I2C5!5t^jf~$ebfk
z@my$M6CQSuaWu^KA5{HEBtL@UfX5Ofz`!60Y9K)39FpFU(j}-5VFFcW0@_CbN#784
zNc-&2$`9r>%zPP6d<C9-2}~bgEaqfJz6?jOAlQFBP;-&nN}xDg0u@JYTY<{!Jy3Dj
z`T=*o4WO<N*sL2+Iq?2ArhDLY4N9LMpyHeGl(Xn_Y#=vifG5To7{Es_K;saUPaL4)
z?4Wc34>L%z0O?DB%7fEiA=nw<HdX~x929@BvZ)6uW`vZ6LFL#Is5rP^mjGF#vI8oH
z-WR=qMI2<t3#d4F-rtc=03`MYDh6E|0d|)FxI$-OfG!gNi>W}xKy@)Fg@E*0K*gZb
z=-~F64^#}ce-XKj2nvfFs628$0F_%UQ1J~Q!{K2FFSk(ENP*Hk$gCYuJ>YdQOpr-(
zP*`4oiWi{72gEG&F=$Zy!5Y4u&@hMO9Yp*oKpV#3E+aJFLH1if#lho`Na6udaqtie
zl6VGG99+LtK+*xooCc^ka+(LF(-}~4Qqn0XUM@iO!Qu~;ub)80@U3S7xrGOuz!(@{
z`zl~ztpXKCb|Wa>Y@p&+Si%~-M<)QK=mDpZ0;ryL9N|3yDt`@{7GQ2z0To9cs|3a0
z0jT&vgn96K3KWhHpz^SNPnd09&=d;l`UX%~NPrjIFfdF9naf-Q-uD2q&j2c}2oi^<
zRYZCTfXc)6Ac5Qu(w6}h--FNxcPA(;JD~Dh*uxSd4}ju&4^$6`4GJ!hyDvb+z(d>6
zeR&}97f^B7dJ34k7{Co728OLz+yzQI3Q+k8APeCB#jKY-pz4t02V`#oR2<wNsE4F`
zP&rZo6+a1WCqVKYB%dM=FoDci0#ys9k|1V)!gLQ<fPtYI#chbVxC503cYBcX;ukF9
zAoF;@3se#5AG!Pj$?HJn!Q+eYut3=71C>WElR<5V6sY(vkUN>Ov9=vLplXooIFR2L
zU=atoWd~IJG{{VdTj1#llpbzC<v~?BNC`;n4O9%g>=U}ykpbLjW`GO>Acc_xR2<wU
zN7~<I02OZq846Voicb%y_!UrmGPT0|h!LS6Kb1h$B9|v1_w_)<LCqLYod^<J02PDz
z1EhZoR18@^Nc;>`ya&l`ptBdAK*iOeX&hS_fW9w}X+GZy#xTAOj4pgT7~S{|Fgo#_
zV07ZU!05<#gVB-i0izS&3q~it4~(9C3qZz#${HW=h8G5gX`nE`(Jn%7`-0rv0@a5e
z_j91);35nf)}S!i0u_gD^#j+@C$Na!fr`P#pF!#715^xF#zXQQA`J_GH#1?50ct?S
z*+8C!q&Ik*4>`Yr%CZos+I3je;_BmfK=u5D#vR067|93h*DX-Bpe7thImpfvP_ZWL
zc7hg8q0Ezm!toDO4=fx(aUlSnsApgRPYoc2xdv1mIUU+S#n8tWL!jd5@tFe^N1j&$
z+1UaW2c;p{cpWIN=0L?^;}OX7^B{eDpz`2hEvQ>TW%d=QIBd-nJS>sg@gQ}7h)@S=
zQ>lPYMq*%S#S*sed<Phj;~&&64}q$$2SpBe9AyD~4^RPA4i=7}vZDnm2HtyzCvAb;
zvH_|#6iYqn!iPFH0ScoBQ1#&Y5E@1x@gGoe@E$o(dDYDXJ`Y6zJV437po7JHaGM5g
zPbSDL7pNZCxGbn{1&PN%#nH>D5~w(Gx&fu(9;i6@%nh_~0NdTbh|-_}*>M1>2i=Yv
zP;pTB!qOB-{RgNxDE^VfIlz+v3=H7n0V$jmpyJ4B3}lW4R2<!$0H`=}+6U#e45&CP
z-a%&6K*f;Ng2bml#lcIqpl$)xqidkzuyalz=^C-l8<h4gK-Kg^(;jS14@m9}RBksG
zISz0|$H0KD50np8pmIB*`q1;C3sfH2y`XT3fr`W0f)MvQ@o9iMBG8jxK>lihs*^>@
zUkHDJ!fyps4J`aXVtb%s&}}T>vhe~`47%hMEcOH{1{==@>HPr}1F=Eg0{N526U1U*
zfbF-2xEE44fYj+g<za3Bl~)c>v7J!2W2;-y$E`tTRY3KDh7v)xg5tdgDh3{+gT^~Z
zd<j$>JiG-J2f23-RD3_k07!lT4amaB0PaBL!9zVr`o2KL*W%D80<Ihx7?AsRpm@@O
zilgo!K#ivWs2W%pf!v=06$^mc2P+?HpyIHxTbTG1s5rX%HBfP6^`JO70u^T@Ar3&{
z_XnyETYnuSF9V(kV_<-dXCb$TLH@FV$|ILOAblZFan$ohAn6F?-V&(1HmIS8wVec7
zRe(9Jx(2E*9NNA@PM;w6oPo-t$M+MccpNnR(e<%_2WJ=<z(WVnbOJI@1}YBjIw6Uh
zK*f>m0jc+aildv80u@JBUjr3KZr_2*sVPu#@QId4Yr{bKW&>0X)}{m5dju+mZvGvp
zIBd=Wl)gam^93r7v<Dd8cL3Qh;tL8W=$J6re#p5|AiE5pa_Dw>K*f>ANkHyRfQo~c
znnU{>B~UR?T0pLYdT@v@fr^8N?vUbP4^$kzyto1tN3LH%ZhwPC98^ED_(A*&Tk{7=
zAK-Gjff2SK26`rv0aWcDPzJ}Eb}{$Nf!Zw@P<=uuX&2JI1?fO;LxJLG22?$)u7bD;
zl7~Qk*#VVD?rVa?FJKV|`SAr*oY1^H$P5wipg#k{4p6W_!y6P=I#6-gm_IRPJ;=Ni
zs6OOzKahA0R2;e91c^_9iles+)<DJ4+agDx;^^t%4pbc7oG(yuaJLZZKajmV-~tzO
z&94d$aT_e+pfn!>6^EsHQ21v+#cn{u6cV41_(zU=kp3x9wV)&hQVvQ#E1+UdSkn*c
z`8goJ+<>Y__xlH^IC2>UYO8R7H?c7=AkEQ1`gcfe6;K*5fT{zZRfIMDW3FohnV$jG
zw+UKD!Ts;T7XZs*Ab(DPs$<5|{sx(h99E#R>Ht*za!^2l%PPovc97g1s9YhM94L%`
zK;=MT1sZDrspkPttS~UZ)*Hauj-dRg0hNQT$pyCo6TnNH!0UNEpz`Q?L3X7;<zVRn
zWM>6b3_X4(;1FMdL;L^^@f$eAKj0AO2nGcbX4+SPii?9P9B5tv#is>S9JP+e92ZQ0
zszWZPK>48pD$ao=o{{4i)Gt~BReKn!7PH(zZ7YDxzX8>Qy7w6~zk$qW0ZnQ#FfhR8
z!w8uV$_ExuJ)WRJ2psvKfd$oFAiD~n`U0W(fRJ4vJxic^h~4J_(sKi<XFaIAz}%|{
z8uW&bhk*8-gTjm_6p{vRf+$FP8d3(JttA2bAF5Utr~fhc;egV80aTv|)c>G12`D{v
zK*cvg#o^@x+L*-#sJdf#)PemERrdm#X5i*Q=0q{Z)4~1^19_Z*0crgz#Q%<b2FMHe
zLFIu3R4uq^2?;BB8wym8ML^~6LhXmgvm>8@JKqMTX7~xDkh2y$py~thgeUsEB*>o!
zp!!xp?IGk(klVjN^?>L6A#R7S)dHC*0v@1ZVAw^ZnV_)qfa(dtq6axYgX}MXss$%e
zH2XpFQ=sw*py+_e!^0MohPFWE_e0YFC=G%1oq>wO*7G}p&v=5Yy8y|*fy#rMfmqDt
z0T1j$&W?n&OF{ZnpyJ>r6q-Izc)393i48B1o(iZQV&e@I#%rK@oCt(5C_mkRs<l8@
zi<F;0?qC3Kpk!bm)*YaJunANTc<(eMJe>FxKwWRhS}0JMML^YH3u};k1ymk3kA@ys
zGobRg!h8o*9=4~KP`U@X`wdhNc>TE#pFkUvGcTJr>@?tRW>9ztfDaELK0H8Wp$mz6
zK*<`EbV2PqP!|})1}!fFZ8HY3L1QAIb&w!7X!|^<4FO_<&TIgU;egnnF(1%84u}nE
zyMX5KL2S@`JScoYY>=NpZEFx4G%p8A7a%sMzYZD?1+hW(GH9+E#0HgHp#B?(4O$`#
z3J(w)G=BzKE(c<R+Ss6R7!Vt@j0Dst1F=EvNzgPihz;s5gQnO(Y)~5;G^Pk*gNB<y
z!>%AUXebUe1O;M)h9N-ZD2NS8FQ7OFu|Z8$P%{n0236;v@&d#L6<?sN3}S<#6cqd*
zHfW9!v}Xpy2K6;S<p+oj+Ghh=PYz;()<2{%Fff4Fp#4Xn^&B8}HUk3#XiYwd4cc#+
z4^;zdI~GCNB@7G<ptEE_YRVZH7%HIRpmG#6_6riPWq|Ax0<l47j)Bfv1F=DKl%TZ=
zAa)xA0|RJnDu~_5z`)Q2H3u|r1v*;?v>y>P4hfQ<$iTn=Ix7#v295iG`s^S!XiYTe
z{1gxybk6K-s2QOBWT3szAn^qZ3=E+4x*#@aZvp7s0uXx{0|Nu7y$oW5)&zj|5`fsC
zebAsWF%Ww_=&WU^nVT3G7(nM2fW$%TrM5xELH$F}m?%gb)KA?56$hOo0veM8iG$Ai
zIs_F5o#hIeuLOyM#&FL;#X;+^L1({##4j^2Fo4dJ1F=DC06=peAU3E?ato>+wCDdW
zlzpFpfdRaK5tOO0V1Eq;1{Q{o|Iwv5H9%<qc5*rc1E`q<Qj>fMA`at&icgUE`I``N
zkpDq^n7Gv~i1>a``<Q`&0XnqE-~ly<1C)Uo7#N_(&oHb$4N)%-6$j5VF)%Ph9fgQ{
zLB&D&7G#gfK8ScWR2-CFLE=xhLByv(#bM*UJ{ut78=>N$vH+xBekDZwEL0p+rhvrL
z7DB}DLd9Y0Mi$P3h<}HQgUT0>`m+}y;@d$S2E;m{Bhc^xFD!zcJ;lJla0seC0BRwq
z%m8T>gN8!~R2)<ufyB2RftbG@Dh{)E+g^zH38*-fVvvD`1MIvzP?-oar+qy{{X3{a
zSop-OfQWNL&w&H?$ru<Ik`_S3HKF35auj6Fo0$-C7pOSQJ&I8GgVHTX9jIIe(Fblo
z)W<^AgUVfyI3F||VCUVz%%5}$qJ9BXJuE#;I}8y&4HXB~Gaz$>q2cf!Dh`{wjMxfM
z&k3p|kmBY1I*7P3R2<yjWME)0UJem=f{KIc6Oj2Y=R?H9q2kc!XE26_LmE^ZR6l{#
zKZM5D6A*`ifdOXD*Xs~-ilORZ;WPCDM7#|u4vij$2PYxo)1cz8{2~JlhqX{~Sh#&#
z3sL_LDh^9OGnYZcMWGgg%5;#^@}d4}go=ae0FZd+42XKzxp3gISOx}$i_mZe&qp&b
zFhH$g5Q6$k7t|1CU|@j7FAvmT0Z?&JT?H~<`w+zZO;B-|zmj%C#7{!SLG>g^J;xS^
zI2SY^Vda1x)W6zLaag#uErqDJhKj@Dt7jfW+zToWs<%PrKb;N{uZN0*x*H&Ib7(#S
zw~ZJW7-0D*{u)GmGgLjOO#o6~c^)FZ87dAdFBhDEh;M_6!_u3@L5TQOs5mS<=kJ1u
zKZlBg+9)9N-8VzTxuFh$l}j_%K*Uv{;;{6vX9+~y0V)n^`+&^ZF&82ZJBJO_RsxAD
zK*ON|svc(VB51h*ZkNLL05UKzEWHXbXAV?7EIjw0gNR>*ii6r#AoIT-hlqcNio?=L
z{sD-%6f_}#+VvpyS9e0houK02v1<kfhTKgM@dBtgO#S-R5b+sMaT|~!pmYiihbvHV
z@EjHc1A`zm9DYK@p~VM7`ZS0+T+o1lW)FsPXgTQ)s(cw37+~Qn4GjlbsCt<B>d<g-
zf{Mf9s}vdzF;H>vyaDKJg8dMCCqu<y{^Ed!!)~ZJsBH@J+LMhC^-rPVP;W4pLc`$?
zR2){$r!R)6mxLDBuyQhU4n$lTDh^u03^M=6REW41R2)h%)I#fpBxpE5t9gbwS0L)0
zp$cK~HTNt;ybvl5Gk^Cnh<F8>coZ}oCP2ku={9}`MEwRd@zzxk@e5FKD8;aM5k&kY
zQ~*|wY?uuZhn;B#JFm$e>R)+iL_v=QVfYR$=L?|zg{i-E8DfqjR6VSmd3pvS9sm`G
z<@d+X_Dnuh99CbPhqh;GpyJTtk6|~o-7*0x4lNEC?m*iuOQGVReiA6YM4<j%izaRW
z_3u`wIH*qpQonx+#GMbJ;;?jb4O)+b`eGn;Fn6AY*5ly4JPZu5Z4wOf(DvRxs5vlw
zy3qC>Gc=>X+J_5Z=0n9{?)Qg=4=+?4mQGGV%V80yILw_!(C{&Yio?tifrgJIR2)|R
z_(0or@lbJCd0P%`*A+s=Vda=4w0!~|pJ!lTfRzI?q3yb5Q1!5Uv>d8_15_N;M*@W(
zH`KpM(1s^8IWqJ>+X>cCaZn!)q<%HDo}CC4ht+G0&~R7?6$kZkK<aCt<+C+3U|{|-
zgqBynP;r>Q!lC)M2`UatR}Z1-d^%JdR$tGBw#SY_(?6`dS_(}Muc7K;<}gFUfdSf(
zgth<Mq2_o(#i7*zLp8KL6Au*!^?^bD;(&(3a;P{g9r{Asbz7j~u<~{(v|V=-Dh|s>
z63}+tTc|jw?+r5l9JKwT56z&Uu?CR11~eQjpyHtZF-UwP)SZ8z;Q(|0X=wXrE>u0t
zon6rO&nl=msILq%=PI;aCkHLqVC5$x)O;PNICM&yfol&WpH@J{Vd-rGv|ZE$6$gzY
zfXu%QZ5JJfio?|RLEC{Bq2k~@BA|Ue&~UJWHmqRouY<M&y`kdJ;A7B(#)}X%Lqmtv
z7`{W>MVV0bu>A57+AgYrii7t}GB7ZNL&HHDTF^p^4+cSK`_L3B4hx5HX#21cDh>;`
zx6pP`KU5r+-jt!?a04n1tKYMs?ZcN)anO2LP`DLB+lRi;h6yYjZb92cQBZMcwaQQo
zO@~>~aDe6O5NJ3QLDhrCu0ZC;LBpXADh?VS0Ew4E+lQ9W1{cg<a?tjnJ5(IJR+@o<
zp#|DLWP~Psm^*c#;lKwKhnZgoZ6BV5io?ub2yGW#hl<0@?}N6BCPE8NSiQyy4Tl9#
zahUn9p!u#D8V<1ZFbmo)iiUPXVD>JBwu>^M;xKz(LEA;j(1s5zoI{}PLu;rwc<l`X
z1H&$8yJ#s?99B*yLEDF0q2i#iI#4(-fwqgDL&ag~;XAZl^aCmmbr!>SXuC)rI=}!e
zb{TA;?L%v*IB5I}WWF7=oVg7R2UxrdK*M1JR6S^X6Qo`S8V=i_;xK!oq2X{BDh?~h
zUP9YNAEDx)u|tqK_n_?}Q)t5w)($)cZ6EqT#bNnN3mOh-P;pp&Z37L5Y^XT2SZA<<
zhC>Hb92Spvq3xw<P;u~`Q=oP%v^;qZ4F^~|ya?Jp<bgKCVD(fpw0$TC6`u+66axdp
zL}>ePJ5(H|-X0nbC!yltGd36)7*wI*pa~kVMH*kyhK7R!R2(!;39=#z+HTwq6^G@c
zP0)7K5vVvcxid_KwxeD_#i7}f!2}u(e9#6jXbcZzz8$n40iOp4-46*8KMrj--hrxz
zrSn_Rb|dU83eY$%Nc|0HyT}(b0L{R_0IR2tK--OBP;v0uVg?3=vh9%i;wn@e=C2LV
z_R=G$IINyM2yHKEK|8Xra{DK=y<`g&2aOqn+@lH&hxt%(nEEZy_T(n0I4pcpq3(yp
zAB+}&wja!)9c5U0V}Z6OuR+a$<x?SOd-6F{95hA>a?ey~`)WIQ5e#BnLKSN7NvJq<
znJ<GBG~D>11p_SnH$dB0>QHf5JBJ+_ZgEg?n14B;;Z_J0hvi2@Xt-^Kio?{$K--xo
zpyIG}vH;pn2!VzJtX)wDZD&pcO*A02Kj%Q(S1Y07pz(1~IDCY*ugstWW3c+D5!%l5
zhl<1eH4$2mw?V~W?YD2xdTlmT9J)n@p%B{6ybTqH#S0s>o%seT4r|BSLfe^6(1s^W
z{c&i%2!@J7mtQcvhPDT?py2?^ce9}BWGPfV%$y(4aN7nI2hEp&!l4El4ve5l8BqTp
zB*?(PPylUT2}8v}^DQ8$chL4#6jU5$z7sSYvZ3Oj`4*7+S<w1!A5<Kco_V3={{^Tx
zEPri=mWQzY<1q7Oq2ZtjjS$fM49I+Ss5`-D5g@sL0koY7+ZPTqCm$LPGoj|d()liE
zc;1JK!^-V%(Dv0^s5q>?{ts<mxk3k|Vdj@Y+nHfdanSr0$ekCU?W=yMI81#pw4J#C
zDh`^L0;#uzhQoKLIILY!3~gt!K@EnvUj-U3i=gQNx;2;KEVO;)162<*=NYtp6%7@K
znWGC0hlNmaSbqElZC`DHii76XK<>1Gh64-KLRfiw3EIBmg^I)KH3?`qctXWt?lFM2
zGb5nlu=EoKZD+2Aio@KqAKJd!2Negen_^&K*bNPT*xjA5d};{|2YJv$BLf2iEPkD#
z;h+l@hc*`&yrAvOFsL}Jz4RH{zDk3NL%S;smC$x(D^wiTo>7E`!$hb!th`EwwlkMQ
z#bND`a%ekqA5<JxP8LJknM}}tgoWEHX!}YKDh{g$1)=%wBQ!lgm$NW5K-*VYQ1!6<
zI1Ados)34w=1oEIdmh@pItvwt`PUN~4sW31(5+Am;n4P^K6D@)7GE==?I<UxIIR9U
z18qmeL&ah4d;@JqZGnoz#y6Cp{@o1~hsDbhXg+d-4oJh=f!CnzsMApOu=4p6v>n9_
znrvoZV1UKD1Ju7JP;pp3JqK+^xkANZ^~GUmJ1Pz;4lO1a)<fG-Q=#I}ZUcinG#qw8
z#i7kI2195#JcWwG(upxN9DYN^q1`ZsL(q1VENG&ffq?<qU1aEjmK#yfaDcfd9U2aH
zQ1!6#zXBQ#oltRDySEM6o?HwShqbp&py6-|Dh^ABT+nd12^EKxCkoJTkcS35EWP<d
z+mnV+ap*7*Lp!uR3EK+`6R(1{qtc=3VdHX=&~TUx6^AxA8KywX$%)W#fQ9E8XnXPi
zR6WeU=b`P%TTpSB`_Dq#MGDXf7HD^rVJEa*<O~&ug?}`(J(&U(hq-?#v|UsW6^Et&
zWzcrf9H=<VU+<vpq7!K1QqXYt0u_g)+m+Dvq%3s624;>u)Sa;QCCpw~X#Kbx8b09r
zKNuJoenQ((o=|gO=CecFlSNQ*n7_K9?a5xKIJCLRAO#J#y-;yjxxo*04{UEKtlVpZ
zwkJPB)x*l|H_&zz2eg2Jb^{phLEBMgP;prKAO;OLTc|j+`Oe@7ZBOPv#bM();?VYh
z6trUpYyTHR!{H`WJ*-}v2yIV3f{H_v3&S;NJ4y*!V8ilhIJ7<K0u_gi3$;PplSxo<
zSULF`+KwuPio^QRY0z+(2o;B=+uzW3)M}_WEPok6+mm~t;?UxcVGgt%^$RKvE5{n4
z^}aeZ9ANFqdT4u62|8c~OFwU+;bspNhmG?GLc_reDh_kM8MGbc3pF2B|4xOb!$zoj
zSb1^=s(u1g9G35%Lfadgq2jP|H49qr-++q4!g(3Az3~ky4huI+Xng_OuL&z3<e=rJ
z8ngg_g<A%+JV}O%!}3!u)IHHqf5FOuL(uj{J5)WaoIe9?Z)}2!!|E3yX!svS6Tbs(
zcU^&s!@|c9YVTvHIIO<g0c~%5hl<0}11~fjIH3)Bn7!W6_LUS=9A?fEX!}YJDh^90
z!q9N8f%+F#|H?uA>kd^9Z5A+CK>gbc6^9O|GT1}gSBs(IFn_&(wktM4#bNbM9<+UR
z6DkfXPsE`9{Q(t+b{82upzSLyXvYH9Z;gSrubiObu<|Do+P;c}io@K00NUP|3KfTy
z51!EQ?16?u1gNpZz`&3SZC@>ds)v<h1<>}@cBnYaJx8GJjq^}(n7{0x;qVSB4lV8(
z`k~`^`p|(}Xmgyw2ioq+fQrN7w-4IhsDz3`n-L5Lq3w<BP;pqeU4*tbUP8rT<@`iw
z`}_&izp(gv4sAcEf)?R1FfhQvM-=KWBd9oR9Pco+{a^tVhZ@JQ1KNJDg^I(>Ujl7E
z_&~*B<%S5<Ur|tTn19uv{>p}m!_3iu`l|{m4$F_*q3wsIP;qFtoMAdNUwno-5ZVo6
z@PW3YZbH?=;wu*#4nLscu=%xYXgdmWC@5k)N)j3loY00CtbTb9Z9fP>#bNo26&emo
zP;pqgb%C~{ETQ7Ca<2y3jtYm0Lx&w17@*~tHZ($D=5K=5*Nss1&|w0Gb<p~H8&n*c
z%@`b@?)(cChvn;8&~}b2bRq(pd>N{t?VMDoIINs`46Uy#q2kbC8ixPS`g#pi92UQI
z(00yVs5q?N`~Yn~!14*STgZ?FEtjmJ{)M^o9khPG05t~|kAI-``+KN3tUZ|zZRf~<
z7ML<HfX{0LXL)G2g+Rq&?QIrlxOGFtVdd~cXgxj`Dh><(BhdEDTBtaz9mNd|pSw_T
zm^;;=;qwP74qB@Ua!(7iyp4wX7Z%PLQ2)k&7RNF$FhGZ07|Nmkodgw!b~_nPL+kOg
zP;po}V+(E1utE30!OF25XnRHuDh_k!L1=r%7Ag))x6#mW2!V>j(&q(ed!`O54htW3
zXnUp)Dh><hiO}}UQK&eqzE};dU-F^h0IRQ4pzWDAQ1!5MZVvUYB6MH_R*$<v$CsR-
z;&Ass{S^cihqd?Wq5bX>s5o?*gy9mjy)g$W4vUu+(Dud#s5ms)F?@pN(?3vgn17w2
z?SaWqf5F_-1#L$eLp$!U@sJQ`J8cS792U;&q3w-*P;pp0Y7w;E^%yD+YX_c!wl_GT
z1CX$CCLY=zP)8HzgZkGMDh><(FVJ!|6DkgCkHtd$+YA+lMi0X(XuZD}>R-^hYEU}g
z4$aq>pz2}m%!APM{|+h+GoKymU)Vl1Si0Q^4NurUHJCfap#F7%4n#qR#Tn*7+Z&}&
zaajGx1Z@vYfQrMynH5@Z?t+TL+EE73aJUQ=hlOV)wB7X)Dh?~(f}r*aK|4CIdQcb|
z4zN9Fu>P7XG#qrH3lm`VmkBgqq(a4E>hD6^8+}l5SpDS;4gYCSaah0dH?+NR2r3S9
zr!KVJbrmWO^RFYc-SrMC4hw%jXuFFII`9LF$7RrVml9MQ*6+9iHD3W54zT{07qs1F
zkET8q+U|;hio^V64E1jcR2*s?LkqNhm5nCu2=#9fR2<qYU}%Q6L&~Azu=-^gv>h@X
zDh@M$IkX)z4=N5TXT+iY-47Lqh0k$lxFtXhfR!7kq3w|CQ1!5Meg@hO`G_X|3)&9h
zhE6!Z?A-xvhv=Y*uZ6b9e4*m7{#Pfo9Z~=lhgSa#+))4ShKj?=e_5!1Z$ZUj>3j{e
z-Sq=a{4z8>ltBFpYljO${VN6?Acv)gB&dIlq2jQ5HUa8iSEx9wKIMb@w-hQ4%hyk!
z?U`jzaacP41#Qn<f{H_@X&JPj?XD|Oap*8BLm{-?bsZ`WEw&i)q2o4pq2e%e-a*?l
z_o3p@;TQ&OXgRO}8V;~_^+M?Q)nll7SUOw+9lv@36^FHNmqXhp!q5&1%$?y-e}VR$
zfXY)?d36AqkM=_C^?|P6c?@koh(XPP<<p1I_Ja{r99AENK-)`BP;prO_!ZiINP&vO
z%*lqf-x{Feu<*GCZ6`EA#bN7nRzcfKJy3C2d*%bQop1;$4vR-=XnW}$R2&u#r=aBn
zC$s?$D<5p3{{0A5Zv+Y?1_p*$sDG8A1MRT<cmUddFo%l6!a*78Uw5cDEFA_x+e_t8
zaUQ7o+o0`=W~ex<y~F@5w*{f@1nrvvY3YKNW2d0vu>Q^iXgPKhDh?|rJD}y5Bs3sl
z>FO4=98-ge!^$67X!&CY6^G?(8E8I@g^EL)p$tXPa%>e;9Oiy4X#0OD$k7Z846txk
zgQmBGQ1#GZH3lPSys$tAmSE#E6QKP{DX2Is-ua>75C9d2^%sPp;gARwhYou&yoZ)!
zOQGV>VQYo}XgEB9io?qDB53)>0*xqGIaUHK-;|)@uyAIEhC>om99I7}LfiA8eNv#H
zfMzp><<RnN7F0dFe1?{9yP@K+_Qo-2`F0H|4oior(DLmSR2)_>XF<#Jzi8rS&~Old
zCIndjcLB6~bAgJ(^5YF?`Q`={hqVuPL(8`us5mVBdqK<j8mKtTzk8thaSJFApnI`E
z%)8L?tr@Bw>Rbi}XgKsk#bM>!J81c~3n~tamsimK*A1vRtbMx>TF(E4io@DJ$Drk*
z8nj^r>pwn+rrQLlILu%2&~PY#io^Wn4Go8Ks5q?MehOO7uY-!i(x(Y%!x{q@1NeMY
zPyj%22>9}FE(XvZJg5+ux_AjhaWR0;ItDSJ_&HP@w$1}8%&-h9j=sn3FI4;kOd*uk
zfZ7Y*;0P51Q5;Zr3P9@vkQfLXL)C-#OoIfVSQDxqd=Dd33`E_5+UtO3ju6zG05tL4
zQ1!5NOCU2qm>sGfw$2<R2Ez7GdmGTqiHEA6fF>>nRlfjD+!LyP1Dg0JsCy2eiOWLO
zUqBN-237w7O<WjiuL3M%fgI1kz+eY8#{f-yBh(zIGC1`Yv>}p#3w%x+ToAP96RI9o
ze!=8kLe<0SA(;3asCsC36DG{?8LA#Oz5tWxfT{=ICk7K_U|_fpRS(*`iX_b7R{&aP
z^$0EmtM?y+`=^h<_vC;iVdApj`t%V4tUQI)JJ#U-_#+0GdtmLBR`B|VNAP?E8wZdD
z*Qbvd4uA}2U|@jt_fw($^jXk)7FN!jfc9ILLB(PDeIB@<{s`m=ut~6ar5oUW>mvqO
zI){yS6+rvr+o0ya>SZsee_`npHa;*F+&_K9084K$cXopN<Bu3%=?6CdbpYHyeZ&Au
zKQMDb!Ts?^3<1#e15;lM?w>wlXn=~t`eiI&|2|?^fF}M5+&_K9Z~!U}^REfizaOCD
zu<^RJ;C|>M1_Nlr3f8XP4(^9OVkm%$!|Ip6;P%WTh7C}0m^-I~`{R!o9zexm=J3G$
z3vD1nhglg~!2RM!3<XeeX!Doh1-PI1h~Wa7_-}A~<`IJdwBZa(?_yB@HlT^egWKVc
z7%o7?VfFY+aJ%IZg8;OF4|5L-)V~R6;!-gGLd9YJT>@^mJYskN6^FHFw7~uDM+~rj
zF08-v5Zr!y#NYs}aA55;W~hH*{Y03!In=)mQ1!5QcLBHG9x*IH6Q2Waw>)AvfF|w$
z_3r~T@n~>6?Gd~|2Xp5xa69c0g95an2NTzX`qu#}4$JRZ;C9+0h6FTm4XA$`pyIIc
znM!aw?GeKUH1Rp$cG@F`2T*aCf9HbRX^$9S3qoQ2Szf4r4WR90nE406?XgD;2~crZ
zd*cwe9rB1_0#qDU&U^s3#~v{pfQrM$OXq>xV~-dZpzT{&K3WWJk3C{AfQrM)xq5JW
z>=8o&R2){G`~tVf9x)t16K90_R{+{xg^k}bL;VYD55vr#1a6N#VwixYo*nAn3s7-b
zI`@G3R{&Z-!p8s2q5e&PibJRE8CanH-2fGb#qTX}yXz6d1*kZz+<pLVcRhkn9Krfo
z3Q+$#K-+1sc4j)b-Svo}04fd(|4?wd>k-2Os5q=$_XOPTdc<%6Dh^ZM4sK^Yf-eMv
zm7lY~{pd#w2GDjI%sqABcIG1nSbGl^K2yQ%%ts6xpz2}yS`F&o2T*ZXzHWf}R{>ff
z!16^9xSjck!2v1`>$jc+_ZJ>96hOsc<?UB+`}q;W2B<hJd{UtPeE=1QwR>-Z`?HT2
zVEgM~>HIplKl_Nm0b0?4@0Va;VDJL>-ybn7fQrN1^BUZreZ+79Dh?~pe}Vh6j~E1?
z4O>_^2ZH<cj~E=F;;??r9&o?@5kmn~9A^GRaKHW$18hG#tevtQ+^>JcZ~>|w7B7O(
za1ekF{J`>^3e>*=P;pqkGlu%N0V)p5*V~}&jSWz7Sh#UQ{rdna4zt$->R$zD2Md;d
z)<D}E0Z?&RI5<N6+W-}Zsb2=3?|8(p0V)oQ$A8fF#sjE0EPOJ+^Bs>E1fU&0SUKhe
zp4WK9-~bhe`S%pGy-@%ahvi3MsDCFw#bNoy5Zb;v02PPLe`Q14S0A9_F!y|cwl@@@
z6WuWN-r)AtBZdGp@qN(tMgvsb7TlU*V3-2+?*XVdEd0;G+8a=Dn192-?W;!&3ebT8
zSU<}F>R;G?ZP+@WZfN`J0#rTBoO)>c3U<H-One!%y<q?yz<`C1H`KogP;po}Rt#-l
zO@NBS^2ICg`2Qn@3s7-bdbj{>Z-5W~V_;x_rCTYee;uF|I4u1yhPJN?pyIIc-g(gW
z#ssK1EMGr?wl@wy#bN0x7uvr102P;phW}@1dqV(PVZ!{I1#MqBK*eG0@O!ZK22>oj
zzw#rry#c!b2$mlHLfab#P=~|DVM3wps|Khzte%P#0X4OcFbG4}?Ldn&1~Wg1cs<l!
zXmP;s&K@HE9GYJ^q5e8n0}?;XP~iaSNyEBfyHgk#m>8HC4wyk2h~RV9K=<cmLd8uW
z;^6Zd85kIxq9NiNpbLw^_XL2>$LWEX-yj9)X+fJE47!aFaSy1yFmd4!h&cxHAq`wu
z`sC?_sOLaae}WmJet{aqJ>YXQ85kG>q2>pmsbA9oG3SF7s(aMRAmR#8^|10MtO6oF
zK?|ZD){%Tz3K36$s)r^QhNHz0aYv|sVd2>TGY2XTGlvoC&I{HM^I_q@TnI5I0ID8l
z&fH+Ae=Q;Y1)pcfz`#)00a4!ob&mr0AXEm1D^UM>K+S=f9|Dc{K&Uv({8*^H0#I{c
z;x{WH<}*MKGH?)pm?TsJ5wAp3UkUZs3$$=%28Y{Gh6rdvhM2;@5Cu&q4ruP#Y6bD{
z1ujT>fYnDDOc3#c_YiT=c}Jim%?*vm2~c}s{g>xZciw=8vj7XE2R^MDVvfLfNQVu4
z_d4iorap+jKxTq4%$=b7??Cw?0DSNp1H(6n^$a_@Am&WygP0=@4Y(IZ5b=OlAX69^
zmO!K#rb5Hh0m>I(hoqoMV0&fZXD&gT5e#Wye;tJw0wST|rw@&<08WU0m^%yFLGC}o
zFdJF`K)YuQTf0HxvJBumeHj=SVB$qQ5O;!%24Pq^)&n+QmH|BM!oa`)?S?U!fz$I*
z1_7u$VC}s$c8EC!4<H_c^*5Wq=}ndabj}pWd}ud`!4RCUWf{Q3B@7G<F!5ARh&dDZ
zA?9>KD2B2si2Gstlwjr9VyOAB@j96JW@tD!K*I+%9+M3fhmFg@#svelAohOv0*SyG
z&;ad)rcX#HgWLe}1p`AU)ErnmL6tN3!{Q4XK9JnXz>pUL(tDWU0W^I=Y++zntqu{7
zfaW8Z`s`qkxGa2}6V|R+sRj~1%us=rUpT`d;tbI6f|(DR=VN3z3?C<fiEj&osQ&>K
zfVm&!J7$<6APy2{hNl`NK?cwnU&y)<a?A|SP7Oi`%wlGM)mmUKoM48Z1_T!ZGnnD0
zAAz}Wf*ICGfQvvF%<xlHAbc3f%mC|Ez(gQ4GklZ{!iSN}@KcCjA`qGxa)UjDgG4ej
zz*+}Lg5dCh#U8pitTl=*4r@)Li^E30(8Xc75M3PB>qQrbt#(8ghpiGr7l*Y<(8XcB
zUUYHTs1Le0Y&HyC99CMRi$fQCpb9fEGe9TDF~p&RiWuUc6AaM=!SMpyEr%+{%mCY^
ziY^X2#Q|L$bmAeZ7>LKr06P5;#6rc)40)&mP#!Y_=u|`~2Z>^4fSvk)BnWmtY!@=R
zIOya=R51{bnE`Z)B8Y{GnHeB;BC04TUxQ9pL>C2#gHBq+CJs7v5t}&Z1V(J)pc5If
ziGxmO#3l|psS%qv=+s7R;;_~?svI)|=rl)EF%XX#UfP0q2+Yg?I^_|;hq0I$Kqo%J
zcnF%A0d)E!f)8UcGk{Klgz*qGGXv;UNCY3oVrBrH5DDWUXl4f3X^99i5Q`advjB*R
zf|(g$r!1fdGcYrNPLxCy1M!#{K&MNBSg4qp;V`NIl*i0~IPVcE1g4l7klHO^5eUJ|
za2&!wBJan5_FOYDC?rD~R^apULF>lNA>sik5OMHb)eH;_v*IA)4e1bZ@IBHD3=Fba
z5b+1Dkctgvj$SN8d_x*UJ*+>-02TiL9f$|t9nHYN@Fo+YUI8i&zH^#^fuSuMBHmC6
zF$b2@sw5%e3Q+gJ#*0=#{k5PFq8@zbG^n2<2vNTPdJvcv#JLQNeGCkOpm2t@SD|4v
zF%hEv0o47ldHKi55b=Uyi22|<su>s<&Zt1d8Ok8yuyup7irB?(h(N>*p#47BI!Q%n
zI2ZUp%z>TTqy%+;!YPP2bU6saJ8p<M1s)J_@O|+N3=BLL5b+1@5OMIG^9&3O^W`Ao
z0?_s|EM88zK*SlgLe#^?A2j+Q;q$^C(r<;eJp7>H{NV^hJ^21h1_p*F`4Dp^Km}km
z>pC3b50xS6FQBP6Qot@QDFhK0fQAFC=5ywSh$leZ19SgpX#D<wx*yhll!vCP2~hR0
z8tV*H{RgOeXfk0)od_|X0qRazNiBmzTtpM1KEMPLKA`h!K}l<U6GXgVA4D8{Pbvcg
z!yaLX_=Y_Yaq#`B3=9nMsu1yj-4Jo`9bBM(6Et0+i-YDDg&3F^Hh?cff}HaUvNxX}
zY7R7gg6}?IU|?v3#fvh;r?7c-?F0q}C8Y8bd`30{1H%eakT|0Jgtagtvq9pBdI8q2
zw*ae0)C<sM+zemiLFy6p8gw}(Lm^l_qF#f|ukHt{N7PfW{sbdfJ))k1xu+AX9#Njd
z&Otn70<srTp2OVJEDi}DhZ~S^hE8uVBtyj$R3SYDSbr@QnvWJJpo-7-gPH@)cQBVt
zhL)=hlOX1U?<QwpU<m2}<*%a*3DEwF1Y~%EA#D=GoCJt+20Lg!V{J6Z{jkw81_nK-
zcvdt-y#x5tJqCtjph#z6V6cVSTOb87=r1Ii8QP)cSc5D?d?VDHsnB#-AOjKSf~q&N
zftY{bD?}XDvS)^t0}X#6;xPXfL&M=f5UThmSo;4B5eMHv1{!zdf|xI$3lWF)n`iYy
z#2W-5;S9d72$U}Zq2l5YaqxXa3=9l9!4UBS{19>QT}TWJ46lQ*iyJ`8p9NA7^{|?|
zQ68cmUHo$ZM7-f0#GSBtVHp{S_yN#B83P0CI%0-xVi55SJP`AzLgOVIDjvWK5r@@l
z0nmEHfEywXzViw+z6UK2(Z$a|)8PTMbf^YRw+GHZ+zA_hSm6qB&jV<@W<qJT9EkV=
z8Hl~0GqFKV_2z?!8|XvCVdv_pK*bM0^98KlUj?n#0-)}J^>AjeLCt}R!}8HRPpEh=
zBmrIpS<1k`;L!~c4^V}OL$?7ioP@fQK?&lo-%$6LLF>&AdJu6Vh&G04J`i&RenP}y
zJvuRH_%lGo;XP+2i24bSA?jh_mgEZ&ci@1818kiCtOr#5K14liy#1sGM0^2s0Ri|9
zQw9cxgRBto2T*fhJ;s(YP&sgzK>*qgSpf})dBqU*4QC<dgYPS5U|>jrhI7Glh&cG3
zPf+<R0Z|{I0uhIex9^(_5&yso5eMH50%{jQ!!6(yL>xA6csUZHegSlx8RBaOhF3ih
zcSb<RLtyQJcBp$4pbJ4@@%z#gVh)2Q#C-6*U7+((v>@UIIuLPK&Cv?YUmKw2K&OEj
z7Nvs9Jy@;IzyQ8ao`HeE720k*a1RpUuyJxhXgD)Ggor0VD26rc5PJ{Ygb2XO2W_yw
zWEntb+k=80=HK-!5cL<XLexX8VQ_+)f8jAi`~)-|7I{I`H$V>*n+1_(P=|)kg_RKh
z!g|6lqaf-Hz!$tQFzkn_ztaj4f3Oy!z7uM`k}*VF;2A{W6R7w$XuD{`4Tv}gR9rF_
zqJF{^h`1e8d=1pzg4Gc73n0=AFEb$O4OT(KVe9)q>uf;niU&|}SU9yo)jM=R3;><k
z4+_5kXudFj`WM<9Vc^9fo&=5e3BMrr!q%nk@rStQ0<;{1PMa}YgZ3j9)IikpK>gJL
ztrrrY`3_b-mqOz!ffEw5u>7m%4KaTKA4D9Me`i6}D?ru5MsReY@teQ}QC|u2EU12g
zw)X@cLfiw(?;naG`Q-=NIAjYnpE^iD!VR`QXd|?od4N_<8bRA{AE51C*!g=>(0uv<
zS|7pk-CJmSU@(Tb6Le1k$f;ML?Ft5Nh&$Iq!z}>X-%)^;1F&+#99nNWK<jJReCQ5K
zNVqjX{o4vP2Xwz1D4iHwf|w60KW(Aqu)}wVIQX7bP`j50l&=xvB(Qq$W&*_g10oRh
zu=e3!XuCat9TIL|L7rk@V0dc<Q4gE%fo{8Em@NtspKt(T4s6~NG^7Y}X9H9m)-MQD
zf~ZFq=YY189iZt1w!ZgaIz)W{v>t)2uK=Ad3^IR#Jj9)_`N!qZ{QIE};vU#OJ40xA
zGBiNMVg5CRrmG8_kO1z2Pz>Qva}uBqe+mtUchGug1GF6ri${+<h&wMp+Z(X-{{dQ`
zDnQdSY#v+~nhqJD^$2X_u?(ty!#9Y(VDk<!(EJzxod<aYb>{}Ccmp&ZVdncn&AA{9
z@h|A^4v-f*p#D{WwkKif=Qq@x2hjWobH6&Y{rMpbVvZuTB5#9+r@<A7IQTAm(0P8)
z@?iorzCibTfb2c12MM2mdl2=o`LBbz5b+66aajH62yNef@P(*949R8;ub|=y!4PrS
zd0_U?@e0^NL)du5ODTx?3&0ngLGS7XogW45&t8Cv!{+x>q3Q*o=@6E#4#Vt)#yhNE
z90v{01ZcY20Esq+I%xWFsE4={)+3q^jTeDth&b%rPGM+2;sI3rFm!@yzZt~+0^Jbx
zxlr+!Q1K025OG+31fBB*$`=h#b71x0RH*ufi4gVRJM0)37`8#}O@NNWz}k~m(DbPw
z3Q-SBpLx)7CIDKGz|zSIEl@dw7*7V@_r}1$aDxpbju=k{-{;1_!0^f+Bo3Q}VqoZm
zSi|6G1QLgZE&~Jj-aiHghDcjTI2=%fD1^1^xS{cK09ro7##@Y`>Jy;qVd>$gJ;WRX
zeuz1+dkn%OAmR(4{V(V;6b8^a^`P+F04?WXBibd<cB8;Kh&j+~!0@mgR39B>;DGiw
zVePjM&~kDEbRjHkMD-3Q$iJ}K4|=a6Xy1%1NE|l0gAlKPwwE5PfY=Kg2Y3%_cR|IW
z%PbfcLHkV$pyJTw6b!D?5dShj#bGl&f>7}b%OU2&#Mz+rqX4wM0qY@4%7NU8m=A*0
zkE{4V;;>jkxPPxK#NG)|^I_%HN@#r)unc0a5wv`(0EZ7^UI}LYQx1^%h<PHIcoSG0
z)(b({E5-@2*8u8YSW0~bYj2!@WL(hwPoVPZ5DxJf(Eh9f)SWP&zl8Q@(Zx?g+aV3m
za=si|j@>H&rIW)9A<%X{RG7gMT7C*Z`$w?zOFN+bxCCgq1ZziiLfcmj(DD;jo@<&w
z{JQ{Jp2K1S6s(~1EZ_wRXVAS#ApdT4gQ#cN4iPU0DP&+^SO6WDXxIS}pAHr8c7&)`
z*aZ=XjsGy|K*SB8<D3Vf>ixmvMTmJHSpTRWJYIyD_kry*m4}YI8bHfi*m%(=R#3bn
z=App%Kr%2eq;rA95%W;sdmkAX7_{_2;;>OG1_tompbQKQMbLH~gD524b)oKTg0|Zi
z+=loIcCX73aR22nLjqcSaY5_-4W}XMVd?N9v>jCdEk8{m)-arbw!<5s{aIM}dqT^T
z4;LZkz}gj0p!qHVT5iC^_fCL>v%(*U!Ly+5{}0VaAKpU5&7cKPU^PVjg<lYHC#ZVS
zc!>Cd1rU2-{k~_=a()4H{n8&$B4J=)*oi}25IU}v0A1e#Tc5xPO@|H8{y6w<bp{58
zd}fHf3`&rc4@<Z0(0YdfI-Um0kI$g)PmqPEhmEgJf%Z=upzUht@EpSlXg*?)hp30u
zgKQlTdj<YO{L2Up2M%ca;Q#|fJ*-|{2OWPFV1kIl&QtM)w*L#hK+KVanqyiDG5^3b
zi1;FCxZQw`=NK?T%z?$@d}#Yt0ctO-A6JS)9CSWADE}rv%>m!5%fP^31ucKj#e<>c
z!vSdd085{9TtN8(HX6sk0ILW2pzVYM(hzsT#uFZtLHxBq1>#X_=mOuR(EiH>wDf-h
zTHhsXgoFdEMwf+^W6<$KSbJ|ev>oUGT?Yj<p2120Vs8S}J+S)75ZYg8fR2yB$~QOY
zILrnfh`q3RB2a%36mA>DA>y!oX8q9m+5@e=wt$Ai1L(L)3nbexXq7|VQw=f477`o`
z($I3F!4M+;78>s_q3wzX&~^oM*&;(S)cgV?h<e!m>=J#5`2x@dSz=K0=fcV>s5rD+
z!l32~ibuq{0$96lnKeipv3?*BYK}t_NF1>q0Je^)%N8V#Scd?<ub6>>!3H}1umKv6
zuyo4+tsfP(K->?ygAe3oS?GMq1E_i{Xt?D;=Tp$dE1~TThYt{QK=&Df%;ATQS5JWE
zUs$@8fVR&IpzU^8`+PREJb3`EA7SfkKSReuCZMIaThMY_0V)n_F)W3q^8;>>0E4w}
zL!t5e09qfhL8KY7q3tUJ==dRQAIA=8IDCNS3-ES1&^hJM{x7<C4zykI0Xhx?8&}y2
z&DZGS($M-M0Gi%l@sb4{&p7}c$AIORs#ZvQ13LY|@B<Xcp!?qnAn7du8qTnMw_Ot=
zZU9{$3tbM*U<u9F4$uh!nECgh{fGx{ka&d6_f3M<;|~NO;xP3MhEVgLK*U3#>4eJ&
zBAy@u5dhs?33BRoXg&=<%csks?iUb;sE36^2(;e$P!2I4RNsKic>--ee}MMKVez}V
z0unwupyR`^p2;F;`kVkgU>BA?6?h=-G?0bZ3rnACp#Bp046zqBp9tD73MzjVK-+cQ
zAjg2#8$<K;1ZepHs|Piq^G6$?;S9T<t_xc4FhJ+oVe=hn&~O%js)vO`6RckkE&pNT
z2{)ki?1oy1J3;F~!A^p<b26aq9BA`_p$M8^7!)D(0&ILH8CpJ1Kr5eJoI&LYVqFUO
z&SM4!hT~Zvaaiw)f#EtdAAJR@hs}yGFo5st1>Lup3sMhDwG0f<VJQX=aQ%f?=L0i;
zH&{I^l`$}cL%hcTI)_vVX?+Oz9%E3y66_vWXfZIfL){bN1hN-4TE+mm_ZT!!1a>E6
zt{xO#Fmq;t)x&y+3=GiWW(Gm9IIOpaFz1{j$b7`Q6qq^Zpy^HF6U5=L^B;<#?eGiG
zauQZ^S3>7;CP3SVuzsH{biB?0Ivxm1S68|r>AV0fe$$}+G6QIN0!z<_(;(@*04-fD
zgQf=oX#33x;#`JCXnp4ZO>eMvyJ{cAoCotD3Sl8GUjq@}04*P2;y0oBNCDa&fVpQc
zG@XCA4lxJTf7}AK_rpzy_&R7j+N(p%H!y~X!@@zU2qON$1|kl1F2k)xi1-3Ch<HBK
zoK~oM0jN0WUS3fAuPKD6f8Y#J4=oNDUZg<8FE~KN&qB>{fQF}l1w{NBBs($uOogal
z01Ze}sCrQI090-;m_pP;kNae>g2q<^)L*c6#nfJiIRQ}h(Cu&xK~V7pQ1!6&64B81
z8w0f5hTTKt<_R(90@NJXxa%rd_(0Xe+Ffs<;gA4T4_j|@8roiRfZ7W?=VuuXanLlb
z5(BLEU|=`}4F`J*P=0~6;u#pA)jz{tusCA9Wh^9^7(}fh?hk;bE7*FTC}=ud0G-E#
z^*2+X_1XexI)`rOV~~TUD+5W0!LW5xAEEvF1D+5E!gBH==(wT+bbKB<T*qJz8~^_Y
zF$d=2ztD8`0Gi)n^=}_^+_eB&uff)>UxW5j7QBR*18X<FgU(ZbFn}Z|W=OTfumsv(
zx_~xL-USsGfaWh)z5un;LFw&+2gF}5L5ZA!fuR*@{sQQFDp>gsYJY*$GeGA(-$2!a
z&b0)IKY-S=u<&GuhED*rT>(octkC&8fkO~~ZG~9R&<Jfu9e~aw_(8=lLEDq);u+9*
zF<1-<fM-zmm_ge`AG{#u!{+^;K-YB?K;s3rzT!A^-c|uRehynP$pLMT2|zPCtXx_R
z>u*BMhqcd3q3OH;svb74_XyfwzHk`g9@x1cS77M`TF*kazc7?Q#SNh2_OSFL2X%h{
zv|S1d=R?r;gM$FXd?skPm4WAZ5$jj?L&YBkL-Nal=@9iM&<zZKS|H*dpbJuhpbdf&
z==}17_Yeb^p$X_Cw0wKO4GDi(dTwlhnDc-YBAy4)#&8X~j-mis@PO|A21VJXW{7%$
zHxTu8AVJW&1vQBH1{R1o=uUT#)J|x-8eQBJy57S9YVS0VV$ixr=z0%yaW&|?@Q0NU
z^S?qjQf`9wqbET3gTO|#!=U3c2I>&?u#wyVs5u2taoBj{%UY=W%OL7u>kv4qAmSJ7
zA>y$09{1fL;v1kFY@R^pUsw$w;sxyx^`QPO$ZOJ2^&g-G#xJP)YtZsP06L%^4~b@m
zs}&G)0-#MAR%pDaL)|G*0Wlx8()T5_-75eMf7l4@6KFnt04;c6^C_VF>cHgynz&sT
z#9jvIej-r019Jb4I*51yv?J>ZDb5&z>LKC>-h)&zFu>+jLF17i^99%;4u_4~s6fqm
z0PU#3#>qLL<}g4z=zAgFW5|Q5Pk<hX16@|g5CZLAG(gRVwc9s9`;`w~K->fCr%%Qq
zt_e-g4$yTMu>F7<?GS%~?q3C&R0#0~gB!HGEr6y!*nMg(+7R^$(2E9(pz1?#h<|{V
zOCQuA9);E8HPC#$0lNOj9%@b-)SU*55cRO~?He?GDnK`W!P-SLpyCsjLe#_V_3BCi
z)z^r9F;P(F8|XOm249GJRcL|b2~D>K(1bP(>K+eh`5*vY2n=&id<i5R4&*@0ISx(F
zhoSj`0eS!#Y#h4~+8%xYU8uqe-B{J;05RtQ^k5Wdc45%KAubH-r$g1lMx0Zi^}+`<
z@qf^D#Rky%Tv+=pEeT>T!)#EjGcdr$@$Ny(nFQ#%7g#wH0FAEzXqO5)Ji)Nf4q}c1
zv>;gx2@VDx=s0ZxbSde2X!z$t$L$wD%j+;`1N}dAeX;|zA?XM$|5rfgO&ZQZ42GRA
zbrm}9QE&+&E)Ag=UPIfZ7ohVgu$?y5(DBcPGZ2MeAl_zhhnlZ&5+V+5PBCoefcUH6
z6hs`F92o+j;tA&<;-K~-$S6Ko{dF87z7ZtIz`$@8+P+<YCjJy!zr#9euyq&4Q1b(z
z=?NMP4Ev$;h6_|6=EHh)D>^~x9JX4SfguPY&2Ya1Bo1peFfcel#ht<G5&JBl+b<b@
zLB|0M#2^aqK;1tdn$9Oc7Z52x8<Z_=knk~pPQ<~=|4&fy0BHFPTj#I`hxl@6x;g+Y
zmtgtp2{iqK#w|cjfhHdYMX34@N)UI#)|c`@#|ataAQ`s{n!YAO>x&Q2J$Nwlv!MC(
z19SlLCN$$kL&MnsS`Ws8EN5U~I1imqU+@%SFDzexRz8Eue+Otg8Fv2Uf9QBJ?7S~n
zJ7iB0C|;n4JTNdYxIq`d*+SI^*g(vOt;aqBozJ=e9cY2I>()TaE6{ykASc4cd6J;@
zW<oi{9B6UIumn1;`ymq|ei}kCEQ79xOqdH1kbtH;E@-+<=z@qti&utf==?&#M2L7H
zRJ|j#9Cm;%h=Wd_Fw{ZK4~T`Rhovhn==_2~97G&8-ZBN+PHupfW3YO&722-*Fa@IC
z1scDx&~~N(bbTo-em6tY&xU@8`Y1@UU<kz_egImo3PAk@>j4Tv+iB?Hi=pGs3!v#A
zwr|=GHf{i2NC+)18G@nVzd#t`9@u&eQ2c|^&jsjs0?hqipzUpeOi=7HFcd)pq5>N4
z0?>smJE0xyH_&qU!!d~Yu$^EZpzZ$+LXZIPgQmCr(DMHQbm2LyoMeTrTTp<`-@!)e
z)1m!^2~crZzPJgk_Y)RE?1lB0)u8R<3DEX4sGkP%NjbEgj4mz=Z6_aqs)wy7Nr8qx
zy7<!?Ncl4Xx}h1iGwM6EAJ-rUaSv>K<^#07cVGoX9CnV{MQFS{fVN{{GZwEcLHQI~
zC@?TE?1N}y*aG!0!(~XqSBC^ELjg4Z7C`&mupZ7wXgN~=EsA07fo^Cyv*0->R2Udw
z>s!*H@yGz(r~y0g=o2))1fc4n!_W+_&~Y9G&_;gH{anxj!U<|l0Ms0q`G29~rLg%Y
zSbEz8Z6`c{h8t`rn-SFg2cYfnMbP$=542njfc7h4=5#^Js{&g{fGvS|k6{tCTzUXq
zM+z&K1flJL20=(b!bUt7L(_u*wBm)C{{@;J(8aIA+z+ispxrHoJ<$FUEWBXmyoa{y
zU?aOQ@hQ;u1MI*%n0PzXeAsz<FmX9pJVL|yBGkX%q2Zta&0m|L;=YBD@lR+s7JfeM
z9H=`Dp!pOwvTOle$6f&KzrfZvdPCbk3!vgK|J{YEXMk?(gC;wM2B`Q3s5s1=Sy1r@
zP;uCK0HLt@8XEqvevKLq@hi}LeE_N+<{njOyA)k~i4rJ(!B%@QFo;9bl^V4COn^>Y
ze}{%!2{b(zK-=N4akit-^nflN3Jre)=zt1reF8r;zkFbX<lkG+_KXo!{RIw)crzq9
zGN@HT%9#(ZAn6&lFX=OMJ>dhWIne5eVJbAAK8S{>hs|4QLd6$A`yJ3?m_Y@aPbWYJ
z&SCTK*P-L>0#Nf|J4IEX<y8Z8Ab}O)Tm}zl|F_{k#NHmL`)5MOsnEq|L-X|nXj2eY
zE`j!ofa;@ye-Lw+q2~OB_R|?+AmXrbu(!~7Iq(-E4jb16-CGYb2VMNPBq-itwGE=*
zaZ(B-4lAV)_at70w)YC41M}yg?ul;(sfXnv1_o&NgP{VtpJ)MeTnIM5mIQ5w!15I=
z|L%m=v(VuO2AKF|sCv+TJ5UmYi3daD1=bINiFZT80k)qFCVmH+KGDT}q3s_B=srzY
z`|vfi|H}X^hhg{SSwP3T9H8x3*uGlOy^l&r=SaZzg#|;yVFGkR7_5Eu99mBWK-&|O
zpy9~^O+NzAf)lnbA{3f_(8d2i=f@BH1BDI)!%V0-O3?9D1%8OY6^Jy$Jm|WY1n4?v
z*!Y7vwERB+UFZ#4cghB>uO~nk{^&xI7ehUCJcNN4V!k9)Tmm|No&en#;S9BRKFnWe
z;vZoCLK6>$wgWdn#bM#R1X_-vi!X-OBM+eCY_Rj3|3k<B1)%FcVe7!Tq4n>Aw~&kr
zP1X!wq2=%f=sY-V{{0kG{ROCcXtXg*fQo;Bs)wx~5QmOGGoY<UT?HMtH-L)6+7&5K
zcV1WuaSzO$ub}bR03A1g?aaxBuJ1~Ks)sgD87yG!L+H9ASpDJx9e4cz9oT~oS23)F
zj)OU{K;m&3gkoTXs$T#tcqT#Pu>$Iz4bXl8te=$%U57IP+Fyf>FL^@!1#9QQ&Ntfy
zjW6gh8~i@gL(uuA1JH#?(CUZbH*`KU0V)n_9|l0%{{_&EDUDEf>P`aPkqYbOFu+ej
zNt^%@hjum@5aKhz;^0G?!6v}kBidkb*s2zU`mg;UbMAxHf(V%Ut*sz&*yuF_18g10
zgf5Uc>{K3vIeJq-?U3Veb+GcusRSYpG8=?p=EyaH%z^cC5avwQV1RAO04axK(7lEN
z(7Xv3WME*ZzQn+w$n=n*13K;lE5VPQhKR#1c7ur*E`*4CK=&QM#MjJ%h{O0WT74Tt
zTmjk+hKZ-IfQV<Hi7z}15&r=lXo0Dh+Y1qg)fX^v#&r;J4rm1q6aO$BB7OndwTFox
zSpyNzfQAK3+;#&*JOY~TVd5LELc~8n2RvZnr&dG6Vdq%F#2b!7#804w&;R{Uap?Fp
zOno>sJYn-aF!2+MAnKvhZt!+#6EvJ*=RCvIgU0tk@t6T^Kf%PUXG6>hfHsI=;ug?&
zPk@f^!Ney*&4;a5fQfIp2{GpeT73CH<M9Nv-wRXU28~D9`MNOi{m}SoKy#<^a)|jm
zpzThW`kV71;tgo_PCo(>_dpYWdL1HOfaWhAsC!mGyO1#RXK#V1hvi$CI1|(y*m=S*
z@xqf3^*hkg$%GRS@egS3@81OxUw|gQW(h?62Xx#SW`6i$h`0orc;p<2xCdG~d@&Uw
zZh@AryrAh#0?ppiRS@+YXyMkl9U{I1O`HXq4i})sml8C;2%x1a8)$mwKy#-eG@W#y
zg}*yAJYnaP!@_~_5X3z%(ER1T8zO!H&7ILpA>y!ep<(7E&Vz_6pp|c_(D*umR&M0M
z$_KRcQ#Ti4&J472V*@ljTcDLQ&!O=MJJ%iN9?=~Ta~`0T4~wAT3_G_OroI)Le_`w1
zVB#v!cz=Kv{@X7@%>RH^er{X|5r<A2!poCu&~y$Ro`;M7gvJ-_9AKEeh0uIgfoA^p
znGo|~=l8<Y=bVCw&p^vBf0seTGoT8g6oV!-ze9&5;O-IK167Y!&S+kPh(nh-z}2Ti
z^Opx&JkHt)QD1=;{&%4HYXO@2vSSeS3TWv>U?W5vwyz)Neokn-z|I+liSIuHQ4c#;
z940;u8ZWRG0Ze@66o~o&wEXfKT28{wb%&`>g65+KXywL!Xt?b_^KTb4-F`sJM>5cS
zXMmQT<1awmGXX6hX+q->b`CkrJ&MqL3O!B}9xqd%^>PPV`JizgV*Uj*^DUtHaRHk8
zP-wj@ffg?tq4{nCTE1X~*2}Q=6U?1rQ1umP>TRw-+ygs@AEy4zMTqzfwD5_5){h_1
z%y~2eqP_wx9yJd_#DAcP_icuV!w!su*{cFAuU?>q!|P2D^$XD4BMS{TSo<DkP6;&q
zGoaNAD`52nT6sGYTJFL2Z@|n6It#J40L}gJ(DF(Gst`&sOoWz8uzOfw;?s{p%z<vp
zhNqKgXuI(STDkFH0Yv=@wDM=eIf(cUH23>L<BI_;{cnKgBiK0tF!vNe%P|AA`i^%i
z#QXzj{tboZqZMfJk^n7NAE2pMfu;uysD)69p#&Q55oqb>A~b$Cpr!MCX!!#>pC4w<
zD`@==yFU&l&IFCe47B{^F%9A`=x`}K{9E@y#3RtkhXQE5{{pQX-U+SuAE1d_LHiL7
zX!aVehnNqWPlUO18Z=%$pqY~f&A%FG;cN{Jf7pE%Fmu*H%O%)-Ixz8l(C`mHbI$=-
zI{_^py@b}+uycW6=3Iq_Kdk=`6YqhB=MS`a?1k1Z325>709wBoprvPjsQIw_IAG>~
zfyN7Lz5phE720n9f#&`YXg#8Vmi}v@<r@cDI`4z#YuNn)F!Sd?-T48neldrpa}6|q
zC9j3VZva|;JPmE9L8nLH>CFHZ&S>e)7g|ojj#P!Y=OVOz??ChKTWC6m^>Jb9xuE4I
zY=1aRe98fcI}6avDS^5t1I=H%p!w?pT6}Rp!v}U>7|i^S(E7atEu1Z&?LAnZ9Hzbt
z+D@=QGk-d?+~Ytiw;7@Fz5`ADmm3g&d7!1kQ_y}8>|P<5y%x~^^$oQ4Z7sCigN?7k
z)H6Zz?+2&=lwt^n=HDG??WlNYyCMQDU$2Iy2iQFnFmp<v?K%N8b4;P_2M?%1D8=vv
zTK>cCeS?WFf|j2VXyN7stp``2xrY;~egj&3J%`p`&}G{2blU|j_g0{#Ti08V@PB|-
z&ICjI-2rIj*hOf&dIOp{x1i;l23q_YK<mvLXz8;G+J4SJQ?CjwH=x6HaQ9n6^Qi<{
z`LG*W|HAGEgoWo8XuATsy#Q`b6*M0mfGUJi3=^UKO3=Q4P@aT|FM+m~c0dK76vHxT
zI3%FuM;mB=!~v~7{R8b^G@ym&259<+?f-<C9}f+m2Wa6u2b%t0KovqMhCk4DX#-k0
zRt8PCC(zPKCR9D_J|LJmozQUWKx@yefR$Hh?qPzKZxhh`6%MUmEYR}x4`_My0WBWg
zVeMPA^zR9+k6`!pz})EpEoV-kg|k1@d<L}qm<lZqE1(8IDTYhXcGL+p_kV@<Q(*VV
zz|`|Y^9yv_D?D8ZLE9S*X!$f9TJFK_wSk!<2u&vzXyLgJ8t<_CfMDu(L+dZtP9vCj
z6|}#z0WJU5LE9Cu`)FY5U7+SCprw<a(Eis9wD9zXrXSdSQZRG;py_7?Q~*jbghJ~t
z*whkCoDW(*!tURJiGPKrlNpd{1bBE}ho*-gP=!#6fdSf|3P7vhZ$kS82hh^_BxwBw
zTQ>+ZCk>k4(a&9904+~6(Bknsv>rKumOg!;@vDIr{tuz~Jp)aB7c{@WK#O-HX#M4Z
zX75{QJZ?bCN4(H<>wy*y&!F`e>>ewaf0Lo+d_b!=WufVO0h&1q(0GTP^93_!J+xk%
zf##lIXt@FP7CatrLE{&?d>bxq0Bt9Cpp^sR(Doke9ygf1deHRQf#%K|(E9fUnmJX_
z_Iw1Ie{Vy>`3KaYF!L>7;eeJe@}confu=qH+CDKrtJl^;-5G(F9{xhx^E=Soa}_rJ
zfR_Fxq46~X&A(@$`RE2(y%`4`zx{w#AF)CEYaD3iT!*%wFQB<c2O9n>(8A#-w0#b{
z{|gpwc~EiK#S}2{cxd=PKr{b0wA}7M3(o`4_89D*GMG8yQ1udM<#RtYoF|}#Lq4<}
z;(+GgDroun0xdr-godXDn)*-B^ellEkIc~YCV^JJoQ1Y4PN12?3pHl~TDjT;tv45-
ziSt71JJ|XGSU7Y+>z5s9@f!nex5Mt|f~mg@ZST!M3+HZV`FR5^er=)S4;5(PTnY{6
z2sHJ#p#4zLIXB4drFLj|CZOd<DQNo4Kx<d@LCftKX!Z&~>ucEkbTEH~L(B6YXy%tg
z+r0&7{>_87KVkQhz|46FP3H&D{Ph=_FQCU}!^<lXXgkmX&E7fC@`M2`|F%KXa|c>_
z+Xbz!VfP!t+;at5Zx*1XpU2Q}TY#1hA41d51gHT}ih&ENo&&8O*#zw`2%!1*Gjx7%
z0-E?LX!#s~=KfpIc=13>w~wLYX|Q`jVeTo0jx)oq6oH9<hsM_owDf!hTAsk}r-P|y
zfrkGLr~s5=5Q5gr7tr!!IyC$bpoN1Lv^<C1_XjiQDs+CW0nNYK(DLL3TKHQ-)pMZL
zgBzgv0(RaV%>2u+ctH!dU(o*D1hjTb4Yb~b-ERvsrw7_Dnt|r8I%qz+f##k^(EK8S
zrv3*sU%>8(hMAuZjh7#2?s0;aGqC-8F!i&b<;(>%^-rMT`~uCt%+PjG2U>dbhL$s+
z^MH}d6Lo00T>%mVoi7HZ{h{p~3AFrP4y{ie(Bd%|+JAh3mQT5$^>PN9cptQV`vJ{g
zccJ|t4zzOM3AA4?fR=w>LE{&8pDZlgCPDM#2DErlhvw@7w0QJ}nje7{p0l9&6n0-Z
z%={W?I?+H=p9LMasX)tjVbFf}3N(LhgVy5~XziSX(EcxIeGMo|VD=t__D>7Y!fg^X
zpDLh*PcF26-+*RsGPGQUt(%3J&j3wVE70=$YG{63ffjBPq3!t&r~y!lVF|QejzBZ#
zFf@J>(9EfT#+L_Lxb1?LpABgKa)63^ptXNiK<k$kX!YO(Xu0|V&751%cric=A1!D<
zbOF>uP>SIy)W05R`D+ujeuu4Rf~n_$s)yaH3lmR*#%~8&yg!5HqXTH+^8?z>gf26L
z*PAua@(^|pDa`x^Xnpqq&7I~@bD+zy;pPZH`yH_LS1@zpq3x~+G<P0_=DP=I=J!DB
zeb_zAFmqNz$3<tLl^gcZ@dOLBe6#>s-@(@P!pu1XEhl07(O}}T(DAeew0guIS`NeR
z?S-lDgw}VUeQe12Yc;ey1fAo8EPfQ)e}QgOfQMTHG+&%ROSk8t<*fr+K79^t-)f-6
z?_FrT!0zvcxzifjPlVn33==;EjjtbQ;pqZ3e+QcR|Df?$ftD{OLd!$gesY-kx1i<T
z4YYRSDrmg_Kr2^uq4g<je;mx5576}R11+8KK+9VNG;_S6_P#(%Z|9)tBmgZucR}Yz
zCZLrAXQAz)1T^zsLdS(9(9BVU*0UOD;j<h%4v>JBu416|tOlCD5@7vSwDf!rnjT>H
zO2fkEF0>zd0WBV{L+jrRH1iKY%ZC$a@f!>^#{o_J1GK*0fL88pgql-<77hi_{>u)u
zaO;A`7j(M`JpH>s?R|k}jsi3uVfS~#{Hp?OM_Hh${{<Z{Qa}rbz0mx70<9h54OKq@
zt=w*dmJbqW@yG=&Pdd=*qfS_R7|nb`=(y7gH1}MGwp%Qq9)eN~x1sIf1!(DZJ~ZBM
zpxOHz+K>Bz)-Kuujdu++d#6F;3wlixJpB2f<BibcWZ>d^pyr=I>%R*?%M;kW^Dy^Y
zL+g<lXz8s5TFyYXN5joO3@xu3(9*ddv>mR27M?!Pat5?M8o69O2<?y0K#RvI(0qLZ
z&3qPUy<dP9&N9$)MguLJ*F)Q5uzTuZ{xyK6p9VB@%AoZ%?7nrFdJkxQ0lNnrChiSw
zcLkt@vpTeV@IWg!=0ocd*!}e|b9|xgWZ3=nFmVNFyxc%DCleYkKhVnO&(Qp9ftG&u
zLd$>Hc{ecg=RnIz*cFyA@f2t~jRVbJ0nmE<09rV|f{vebpp_e^q4mN9wEFQFG~6=K
z;{5`&y;^|g-)d<2GXpKYgrV)I3uxgG0&T}0Koj2pEe{W%nezpjFEY^FSq{xd4QS=+
zO=vj7_P4;oEecvc!p{4KiEo6aPY<;4oD8kkI?&9Iho=7sH1~XlmSfQEQ1JX%3T?+i
zkHdkBKZTZK6=?ol4h?4kH1mJL>MykX8v(5cHPF;sLBkn(?E~E2RnT#m2DJEH2TkV@
zXyFhG4QJSXA6U4#Leu#QwEE%{v^~#(mQIqP>G=a%xnTk87oe55>d^Fj1I?Wmpy{~+
z&3s2_`4E5>4$9E>{|&Ty_7*feVfReH{N(`+&k8j6NI}CBwm$-<J{nq&B%p=EJXm<5
zxj!FTk9<Ij_i3>7kLLc}(DV<x{|RPq3$#5s11-J|L(6#sH1}sh%jXQV@V^XAw+3kC
z#%^di483*(o_?yJ<#qwoAyA4z466PITD;tb_KSa@wF4WW?L7;$a;Y7f{vFWjyQ9$d
zya!tODGeQ`nt|qiMQA$TffmlQq2UQSmjb!II|A*O!Okgw`RfX_d}BcKmjSe#$v`W|
zB%$T`0kn9xf|fs^^Wc%~{Ru5kB+%mV0yO=@0v_g`RnYvk1KnO|K7!pF4O71w8ZWSO
ze_-NlQ1J(7;gbN(Um0lm<tVhgdV$t{`w7i=FVNi24Q(GrpyiA6(0E^gW^WTTpF)pI
zgn66616q$Lp!v5Pnyw_!^2-_M_zCp*4Y)Z@(0acB&HZbk`B4DPo$b(e-2}As_8(gB
zN1%nzN?5xKEgi-{#do0PyN%HL_X3(Zo1pD31GIc$3XONrxzxz%XFjxkft{NHi{Bh*
zdwT;~KH3Tm{}X8L%z%c!0n`8}#h?cb{|L13kA;T609yEPK=UsLn)yx8a`gnr@kryD
zlcC}N0xcfxpyj6qTD<T<+xZ+&2SO=^b<lh_0nJ_$Xn81s7XC)iaV^-sYnVBX(0sQ7
z%{?8^^b9-C1*U#BG(2aZl@AA@;h=#Qzk1O2>IO9PuRzNy2Q=}2&~ont)Iuo5APX%|
zG|<ZV70~eUKnu5b(DKa!E&cz6hK~bUeq@KH^8~bbKLsuKJkZo1f`+F8T6@V9+Fp%-
zIvh$dv_RWe0%+!cf{xoepp_@h(DuU$v~WHREyo1V)H6c!O9RwGD8;Y}I-USKPZ=iu
z8k(L9(9C%SZ6`ptx5CR4C1^Vtdc7fByd2u!lt2rIr_gu|K+D(e&~Yv3bq#QHZbR#-
z2Wa6l1zPXJ&O3&=|0uK`-+`9iG@<o^0#qTCVvvBQbI?9iP?m&=dqBfK04<%QLCYEF
zwE%E;x<dQuuyb%==4ivl&(Y$m7g|1FKufoV(DV;GUkPSTJG5OCfu>#u8lDMIg;0uN
z3p70&poPCAG<_DJm4{K#cF_T}a?Al*FIS+ICz{akF+htKV`zB`+ZPIRj~8@a$pTIN
zRcL$i1)4jTL+hyyH2>~~r9-sx!2_D!KA?rO4YXZ)0qPJa#oz&r#}2e~?f@-^cc7Ug
z3k_%JbrbM-UkEK9cA%9rTcPDl2AaQ~K*N~<t=v$9mJbuq@`Vkw-6eqL9&Kp3r-0VJ
zs)N>>&}*IG?#zddYh6HdPYAR;Ie}(A7c{^8KyzmVG#;VHcEZhH5&}8zVgdA?R@gZJ
z_o3$)Ux13k_78o4p7SFBy{7|q?m=)E#GD4`xo0qO(D8|&b0Gwv=h?!}$8dq3x9|aU
z;4lLN1MGg8Y0&ff94<i;5NyBvd#L#g(0j~1K$)I_fx#bo4%-3f`3cbE#h|2teV?*I
zD8!u!(1R;r=Z#E(`j-KE9t+G~Z>V|!Xonmc4Ggu=bMpeA3Ss_ohr06t^!zT+d0`-@
z3c&7hgI;+IJGX%qYHtH{<2%$EhKEpl7eF^Kq(JkZBGmi|t04tk4b;Ok!Xf^e&;}8&
zf{LGoiF-lB3!&z)L(QK6IsgQ8KMl0}*b5aGfNng4?W1Ca+AFXRVooE}{A#HA0?-2?
z>Y?IWVdBt(xQe0nzJsPW0qBH5G1T5ZsQCua1GHfGLav2|+Xd*sy0G@n9H{yL==n&n
zlSEpf>2tzNP^dF7WI>$EAO;QR576^1p~p-x2*A!;o(xf62B8>0=gol9tpjue1}xtF
zq3P2Add?y2T!M6{_yy?2cd<}=O<>|@AO=INXUK!PvjBP?2rR!Gfrifl=*63`_NEde
zBz_&B0~s*)JcWky2j~&>CeZSL5#}#w##$#1v41r*em_7vim-HhA8PLh=mAd9;*3Eb
zsy<;cL_bWt87kfYJx>NEJ{9V(572mlo#&heRlk87(vgPUW0eyQI)C6W18iI!TD>tO
zLf!KKdSEsev|aEK=3nSRgI}Qa+YG4r6QKDE>RpC<HSFbp1&;DzHV$z?b?oMV_BBC=
zv>*WlC0~SLSFeM^99tafAL0-P?YqNf@AVMu_DVBi7q7wLUo#x;EXASTEfl-?4Q|-Q
zLvXk=3WxbhINY-shx&XR;&M3L<AcLJ;yBdj;V>UkYcYVQ)AzA4F#P!s0kHB6l=_jy
zVdt!X#FdfM!_GB97l)m50}_{EN0<-0Ne5jVcAphUyo>{(9#+nwi#J2lFGw6T#|(2n
z^!O>TzmUbD#R6D-Et31UA(?|L4m;NhWIkx@4`x2><P&u9$4KUY=Eh*^zu^#v9wP&G
zPb89mVdV?Rd}MKBXgLiMuSar!I1ce-Bymt*3+A3O9OAHZ#X#nNL5eTfdBf=9i;>J}
zM{+;xJP43_WbxZj^`LU|2s0vnA4A1K>U)s<r3?~afTYiCW(Ecu=)D~JXyUd|aoBxI
zAZd_#m^k$K9q@Jv(2@JFaBu}FL^9tRYK}je_#aM44=@rc4syRW3&Q>JP;n3ivKMAf
z8b|=ie3<+5(8OWp*FeQV=G!2dzZNPEqL9M}cCQOa9As}Pw8A|K5<s#SCJsF=7$Y2D
z>$5@HK<2>Qc?TqbWDYDmpW_gR9*>D({wFl`u<(Ii&j(KbAbVlqzy>XtK;eKK&d_Vi
z;Ob%KK(8Tyi^JS64K)X3J+k>qXyP@{aD#Rq!0ty5f9UlbaPv!`>Y>-{g4KhrGKZzB
zWF+&|k<#-vByo^?VD5xoYXvtS7GKa~S24uzK+OS#4{~~b1Qmz*7iK=#fmq^^8)N_$
zaoGA@kTkOSVjuw|^|0`V&0E0ig~g*5R6U47jz`$}6fpHLbId^sk<5p=-y2OFW_~T2
z_#Saci?sz!oCTV%Ve|SRY0#PySbQx22_V@EOXsU`h{MKtLDI<KvkfGGWDd+<u=U?C
z|H9mV3aTDNA%_oao(!fQX3lkxLL~EH;qw|z9A>^4wBZdi2NpiEXyUN&QH6?wj6)6|
zZKycR99a5yMiNI(=YdG#pmYv%4{V$QWd0wd@~sd}JuE-M&Y^(W3o{2c4~=e4Cz3g!
zGyGuj3p@V;WDe-=1(^6OsCtk&puJ%*@x@Sakb2Nq9!&folDIrlzP<t#2bqIhuffKf
zK;odQLty4eLC0}G;>hZCk;IYJXG6t7?g57<q?z`=A4wb}2Qz;UR2<!WP@4+W6alFP
z6%{b`o1g<$=;~)d`)BClYmvl}-MJq+jsr3u*`1G(#6fZ}d)c7#1nA};fp*Y9YLVUf
z3@VPUemAtg4pNUCFAtH#k>l|#l6VReq8|SQ6$hEW6sbMK4DGyt%m<x?0dv0`R2-xp
zIUWs>#F4|t6Dp2w4(OgZSiHm_r7IigxEn}4vUo6(IOt3nn0s2G;^^+tg!Vf@<{+zg
zMiOU2@^1{1IC6MCf_A_`<{-zfH1x_kP`4MfW*6q3BB(e>J+e77k;IYhT>}+IcmIAQ
zabZ?Oe7%N>gUknEn7yLV4h*_E&vA(VLJ~(d-woO^2bnV&$=*PyILJ<9e`Vtk-wtU$
zf~#TVbdm-=R~Ox!3MBDVr1V(}6$iNoIekusii6CNLTa~5LC=3j7dJ){2c4}03pYQg
zILLftcg7-#BZp5PR2*bJvN?;9#O;yXa~???lzy&2?~~MoRNLTo4zhYvByrHy4={Jy
zAc=$S)_{roK*d4sM=sAJpyD8RBAXMBBn~>O6=qH*R2<!$VyHOCoM5E<(t;$8oF4j-
z#6kXrW-ErdXyPz?S0ITan{xn39NFG;NaD!q?;weT`XDg#A40`J{z6VapP}L)e}VQ?
zz|`|X@3jJngWL}jmxhXi%t1~ko1o$__0Zy-VHZ>!q+SUrADxDZ!_>pV=P{BvvU@%w
ziEl+pSAx(B*FfeVhl31~IN1Hrex??h_;0AV5t6tgQogf<ii65G7o>KJGm>~6lE1v5
z;vn~c?Dc{67Xs15q1S0JL_)<u;d2hjoCK&i$X?`fH491n5>h(62o(pJ1G>T+7GIB`
z;vn~c?plF~zk-T`)K?<e`w=P*vUe+zf0>~JzaVo!cNN0S;fIQY%#lYjM-nOyGDjMz
zUJHhbgVf(bGCvzh964R7K@X$^nG=nq9$I{W%Z<5=h<d>tsvcxM50ZP9L&ed}IRzC5
z`D-4MIai_L=;jna55z_{XEIbA-JE$)addNZpab&g=6FHH(ani~ildto4;`2TnS&f(
z^+@8Ykj7hDpyD8NKy!Goc<hFXgX{&TTj;pQET}lheB^Yv94Zb{pUcd^zyqD|ScfDI
zGN%S=&K5NB2B`QUH1Qs&_(?SJ8Bp=dXyT8d;<wSnVfMa86JHEf{|QZe2~_+in)p(v
zID-nPm4+CPS_TzoM-yKT73V_}UjY>tMH62M6_-U5_koJ*K*d4vRf3fMjiKV8ctOq=
zE>Llh`e#VxgD+GZ6kpCr<y#n39HbsOzf43D2OXUaODBtv#NQ&Nt8GZ)$o3vZ5_dz&
zkB^bWk=4I}ii6w<>RQ3<{R$OFcjq6dI4B&>Ao-UAdT|xV9OQaI4@n%k9&tkwNA5rR
zB8e|VDj&k3;vn}Rw>R3L;vjpG&FMuF2dyE4`D;2<9NnDFP;qo~b|Hx)n{xyzj&9Cr
zs5r=+bfkE{02K$RM{W;Xhl+#LBfI||k~pZT3v>T#s5r<R<Z$=|6-PJcCz3d*=?yc7
z4LU!KZVoS09NiodBymvF5@wD9R2<zLEvPuUIfh8$pt*jSId)KSbaO(W;vjQC<r}P>
z6A2Xusego&&J&QtFC(STVyHOCoKB?ru?I;UIo-~Hii6TQayh&mDh{$2bc8<4{pXRy
zUn1Gd0X+a8q#ilnr67re#<*bSWI@G2?gaUl8`_>JLKA0ziqAz72MtBQ%vk~z2ic2U
z&g_PYgUkmlm4T^01QkbDe+DWJ3J2u+?lx2$q<$w-_&-4sS3wg01r-O`iyY2U(0O!_
zIC8w0B8h{}OozGC3Mvk=7dam}B8h{}LWQXhhKhsC&qInA&^#Teh5`8tG{y^4-w0I?
zGXFV}`lC>BkU5q}`T7)89Hc%QslMQa&bx!ugW~ZGwB0L#CjJE~Zi*ysjby$pR2<!W
zAE-FYe3&`GP;rpIkn5==s5nghYpA^iNaD!$RzStk?QMpNqnkewDh@Iq)YgWD=Q^l3
z$Q<N!co-@UQjZ)jXQARC^`N_aVdh+cii6b8L8=#SLd8Mq#gWq6JtT2tb3Q}GLFRzY
z?u41&qYX+8koE?$csg`J0?2%CB=f7F7juBbb&$l3q3bF@=7aVUz|8*&6$hyYjkUtW
z`JoHg(bb=`gt!N!9@*ZHIK+9N7mlE-H-%n|jxH_$oiGN8BfCG(6=5&3_+#jL3y?dJ
z$H%_=Le!&+yZS@KLFOa7{}A*-H;_28`JbWdHbCYqL+WpC2}PKL9B#bO3zyN=KZRb{
z2QnYoULoj3b?D-TIK(C55cVRQa{_u19>^SI_uHi))FX>CKrcoCsh^INPK2T2Aooin
zl`{vS7yW?LBb)Q17Q6Y9(2Kgz)dxY>yP%t&1QiFVNA}lZBynVSZib43%xOf57bobt
zG>|#S@sbP`M^|3}6$hzDwznB74pMK3R4<D{*Il8DD?!E4&2ff`gVck{Tj=m9Lj+VD
zR9+$1;{{N0kU8g(;-v>F4l)P1JvJFh9CRl(EdMToii6BSZjW7rii6AnxhDi#Uq66~
zgVaAoiuadLahQ78I0hT^-ZGGQFjBcE0~H6E!-wR4MI>?La?cnl4l-vGQaC3di6hs`
z*+}9b_ru1E>e0ku;V=g(4suUEl6yes(t}biNE|txSV7l8g4_c#A2vSe3>62de~8rI
zsfUV#)FZodA(A+<zYZdagRVM-x$_uQ9ArLn`{6NE9Av&TQoJxg7r21Lk?rMyile71
zNvJqTJ;-0MaMMH+hq=cFDh_fF=&T=@xHD87WDc^uiAdte?kq$S&q8WHltINo<|F&J
z87dAke+yE+&YKR3Ee7!T`CX)VoQx!nJP$hsdO-xpd}Q%>=sHVu^Rtn}k@FYm{Bw}a
zAoZXwCM+Bpq3S{ABj>NlP;rp@E+qGFMG{92w-ZotkU7ZXT@BEMxajdX2PzIykK7+$
zk0g%VAK!;0j@<7C?JtA*3)wxOeX=ldWcPoBngjAzHc~u(gNlRPgB*{{(0jW<>fa;f
zYY8NAWP2T;;^_X3gNlR9NA_<4k~p$|%c0^Rdy&nbh9r*co<&IFpsUhh@w*%<4zd^7
zUz?%gAoD?UuQ2tOki?Pgy$2OX_ZRydP$)yv^An`<BnU|yxnI@?6$jaioIa-_iG$X3
z!Q8V1Dh_f#a{4@lB#vzUMW{H)d}Q~3L=s2#?_VTwWcRQ@*F%HMDMhLm1fk;S?va3s
zgVg6Dr7KyeI7mHm_?sb#$0C&jPDtX&>u}1U;-K(H?oV|=#X;sH_ouEQiQhshZ@)st
z(aqt2u6sr|Cjdzt*_?Q&ILI92dcP4W4l)OHb{H%kJD}pA@Imfh^g_i!>XG{wlaR!b
z>)FLnagaHak;<igP;rns$mNg5d`S8Pxf8j6ZHgq0?0(QW(jXn^<`+ZNgTy0|%7HGZ
zIJ&(*pyKHEvO?F9gT#^THH3<zo9_q}2bph%luojt;^^jdL&ZVrk?RZ4Iietcfy6H%
znZpF#j{!0VIeg5Z;vn_N>ChG`4ss`QesMt(M;-?Ygo=aALC(L)P;rnsQ<1{60ZAM=
z|4xUBgWQQ6ZX2NDAoD?cbztf3B~%<_K5{$ZCz?1+y#VwgLXbJ2Gk0L(3Q%#7Imqs@
zLlQ@JzaNq~Xl*3SoM5Op$b95-AQ>tSGJh#@I3S55+dCa9ju8$}agg~a;Q$o}nU4|<
zXyPz;3P2YYgUmq*2dFs69Ax*{A&Dcq-w#PVAE`VHhKhsCM-GQfB=J>9>9ZIr4zf2F
zDSW0Oi6gsbJ5(G!d~QI+LG~htPbPHV1;~8l@To)-hlS4ss5r<RTO@ZbfQp06L3YnU
zBynW-pM#2n%t7w2-GhpQ%mM91huQlWDh^VQ9Bx06#6ytW!@Lxf+acpEr;x%;4M`l?
zo$gR^^l;07ii7M$4!56BagaNa!;KTVF9jwJbH4&q9Au6Sk~<Bc;vn_N?g>N^M|OW4
zR2*aua=7I|#X;s2BBi%ts5nSHa=3LOiQh(Y&t#}L$ecMy^~*LSab$O1hl-<z+YhKX
z$X?`d>s*eA7vyl8i6#yUH_&}XARQoc9Fg1!I{z6Y4ss{5dmbX0gY5oyP;rns$l>-6
zDh@KI2r1l{p&Q~r>XE|@bPhkrUXXYkl6#b)>OtllMM`guNaD!ujDU)xhubEoILLhD
zc3t>NkgbsPj2v!RIK=DF#9`t24@n%k{$hph9|O4`x&0{u6$iNox&E?35=VBYBUBt@
z4zhofk;IY1Cm%_C2~s<=3`u+`l6W&z9Nj%#P;rpG#Ypkk4;2TgM~=s7P;roY<Zzga
zB#zwf1)U!PiUE*0$l<UNNj<VTJCMXdTMl92e;g`~Zq8+>ILJMqvwdOeKOu=DhbQ-H
zkZU0Q4$vB1n0g_oILI7i^(si>B}n0;2^9yq2RVEUpyHtPiQF!7L=s1Chr~n0LFORm
z_cW+D$Q)Uue9;RP2e}iJo?-6)2o(pJQ-qYien7=R>XH2=u?7+jAaUeyQ$Z3hMfNXL
z9ArMSe~qEyAamv;m3xs$;>h;qL&ZV<LJprsByr^MnGY2Q*^3-L*P!Acdy&m&UJLOT
z$b95*Q-X?v)FX#mCsZ6{K61ECfQp0EBbyI8FA-z|NF3R}dy&+aA%)u^s5r=c<Z!zT
z6$hEK3n_koB8em0%MZQi9ON(La8pDQM-Df8s5r=8<Zw%aii6BS4xd)2ILJN7;qwwI
z4l)Nhd_F+MLF$p+DG1$X3lc~6mn@QaIa2t5&b0uAC&+x{@Nt8x2Z_fcrDs1RanRiu
zu=Jk{6$jZ{kJNANL=s1Kr_v^ntqkDfX_3Rt6)Fz07dhMnH$&8e%ttP-B#^{GTccs_
zQHP3y%t0>q{GsBY@JF_H1(G;&{BA=MM~<)CP;roZkmKt=R2<!W`7IFlgWQ80k7`hH
zkU7ZV<AWrQ9G*=`;vjor<EYcn#9`sE7Ag+17r9@sA1V%VC$fJpAc-UU_bXH!<W7*i
zF!Ob`Li`0X2RS^mafm;Hio?u-x&IrQILv%r=*CEN_lrQqLG~iM-vKHPQjgqT^2H&Z
zup8ojkb2~Kr5va@$ep0GR$=Zbgo=aIBj=Y2s5nSHa{8=C5(ll(fSJ<=6$hDvoIa;Q
z#nH`~gCq{xf&epTB~%>U9O3;Ce}T-2M=Ia!k;IYH+x&wN^`P)Xj>m&gagh1Q`7!qp
zcJ&*e;vjoL=>!(PN6^G!?!OHc2bqtYKHovbLGD40UvB7zSdch!`ZR!w!|a8b9}5)+
zsYmwLWT-euJ#siKMG~(>DkoP##X;^wj`zJ#adh)PA&DcqU;PLq+(7n%!UyI~Z>TuB
zIoVKgkiE#|MiEpTWDc_XXCR3q$NO@qILI92d~pbec<)JwJ3;D^^Th+`xeOq26Qp|K
z1(J9*lK5w+ILMtwNa;}aEW~_}II{cm&O^k}!(lp99AqzYIt1Md2GRjC2Na&L^wtMG
zfCVNF3+JU!agaI4{n<58age>p@pS-6967x`g^Ht_&v_B#8q9jl0ZAO$oK&bdx;dRt
zagckE)9p&AILQ6T>0tv@9Apl1c-}-3M-KmIP;rns$m!uT4)Jr)4d)>B$m!u0R2*b)
z6;gh=4;2TgN6s&wZ$iQcq+SWBy()1FA&%_+q&pCC^l)f_ii6BYP7j55A?iWqBd3Q}
zG;vsZm;)6DnS<O<Uknuo*^8VWb|8r($KxHSILuy{`Fi&t?g5#DtUd@Tj;_8RDh_fF
za{Nw%ii6Z6htD1)apdqk2^9yKgB-tiafq*l9vlEtj~u@{q2eHWtC8Y&A5<Kq9yxw5
zL(iQ7segzRzb|lze?t;St~dW8iG#NK!NQXVdQJ++UgUaH7%C33R|~0}(ZC^Yh9r(`
zuPu@|vb{b~addlwq2eHWosinS`8dRDk;IYhZ9x)8ws$gA9Npf<P;rpGXOO~qKMwJ;
zNaD!$UO^H^w)Zhq9Npf}P;rpGpgRCy@xlu_V1)s*-1C5ngUmr5Z@B;!M>pp&l6V?Y
zJZ^;^i~~}SEPfbC9NAx|ki<Qa#$j$j#X;^tPCpN!;vn;p&3S<&4!X+(=HE|HaddN-
zUqSLa$eg`M@#2U>JQztl9Lc|hP;pSXfn5H}zJ{0&vKM)ti2Dt8@pDjdkb98Lzl9`@
z?B9n-;*ku9{VX4#;vjpG!;SeZ#9om3_mSMMjwFs;UOk42qx;MI9mE`v`CpLQ4-;{S
zOMnha!;;?GpyD9+AlthFNgUaoTad&-XJ5eLcPCUF<R0Ym?J!gvWd0hY_<fEfj%=?2
z^g=d}Ip2`{rHv&19ZB36N&GXCco32}a`+s?A$}i89J!tI3@Q$CKe9W&Ac@x^mGeKL
z;vn}Uhl9mONPMB26NMy>96o7C;&n*oXG6u&%`b+EgUn|}Dp#i=i6gszFH{_44stka
zeuB6YB+iYLJ`JGaAoG#UaY7QWM{=h-R2*auayUdo#nIDq;Ae=v=;oI|#nIJofr^97
zM@|nHki?PWUG@vae2{u%aWkkm$le$v_uC?g$0CV$K*iDBa{?+3G6y+)-Xe)3$4kvu
zh<ni0_aTWlAlW+^Dh_f#a(K>yii6BSE|(S}iE|;Dvk@u|G6%U_It&#DnFG438<wx1
zLd8Mqk;B;udO#9-ID|mOLF)66@?$Sl99_L4^ngTkabu`Bx;g$(adh?fafn+$53)s9
z-~I~{{^;V*q2lQFUjGeI4+<aTaK48m-i=gmzJ`i}%s~!kZs@^)AajtzSsY0m*?c)9
zanKeVSiERM#nH_-f{KI8M>fY2NgQ+rC(Il-s5rVgzEE*=b3%~BK}*hI<|IPJ(ap(#
zildv8k0cISLJl*h9x9G*&Sa=K$eb*sdSnZdIC8#o`HP6JIHdINjU)~_0}5tuG*ld9
zFLHTUk0g#<Zp_9Z{tt(^%0GyEK;|QxlL-|E`3u?o-ALld{+*5_-iYL{IZ$zs`N-wN
zVyHOCeB|`73P~Kf-LexZ4l)Nh-5!RDgUkWl<p2ve?f(#eq35H!IK<7M7qy|A<ANlP
z>`reaaX+N?RVY*(-JQu$agh0XNa>^<NgO$xS3$)=<{-!WO(b#T_P_(EILLftb3P%7
zHzCE#cc?hXeB^lHVuWm*K@Yb`s5nSHa{XHi6-T$XA4$9!$=)eYagaI4_RdEVM=sAF
zL&eeE6VC*3C&(P+_EjB{IC6TvjYC`qdT<`P`KeHGbboati6h73VkGg?NbQr`P;qqg
zHCZ6;2bqto-Wf^U2q~Q`fQp0siyS_GpyD8NkkyN@Ld-|EHvxzEBd9pYeB|)_3>62N
zZ-(SAD>m%rpNER0tN#EM2bqsNKFq=nF$W}$oSucD;vjQ0klKxfIK(F+iK`%`w`EA;
zpfmko<-=Meagg0G@hwQ=ptAvC;vbR3K}Y+*#D$>;%!Ay?j^s`wByrGPUoiESNaBe|
z?({+uM>Z!JNn8^tJv1SSCn1^Bi6owkBt8pC9NC=BNa8g}?th6x{40_;a(Va%NgQ;9
z49vfroQU{EF1H1s;-GLtHb)#u9JyVg0u=|v6|y<nP;qo~jF7~U+ZFauaddOspyKG}
z_#%lTw=1Hc;^^iiL&ZVnyhO?`OOeDuXGOxoXAP3L8&Z57K@vwc=Q5IbB2s(>aznxy
zWG}LKGLpCwlKP1_#OEW4Bge}!Byr?=c`H;LJsb{0#X;`5juZ~!JP>!HmrIdQadh>?
zNaA;q(*H`RIJ!A6pyD8NkkvEuLhJ>J`y-j7f+UVyZrC7+BbOV_Na7$r!{X5kNgTP{
zm=6_4cjs5AILJMqvua`H@bV$tiEOV3k~p%x(n#XS_U1#y(e3>J6$jayhtzHn;78bt
z96riO;yaMSEf^|}ZvJbiILLft^~|6HqoL;wg6{T!`IjF_9CYr-AA3l<O%`1odQP1s
zk~p$C!ARn3kkVT`k~p&Yx#;3h^ZSs*k<D3*BwmRW4*QYB!RABFu@!`bCn&Cv_l3nl
z#X;eNY)&>*9Hbt3oWB_=4pM&y$=-e>aj?D6aGQ=M{u?SjA59z<{#((-q3W-qiNnnK
zh$N2e9%ktM0U&ouA(b-%NaD!pSr$ngS-mlm_;e(5Vvxj<%~_5lj;ww&l6V)AIai?K
zpmbY>v|r{PR2&rkpgYW9;qw$K4pJ|Ml&<)NA@K|HFX*m!n0i$tanPC4FmW%aILI7i
zdqbe&==N4Y#X;uxA?4EvNaCO^Uoi8xLdDU|-wzc>H~%SA9ArLd2{X)`-$>%1B|k86
z1rdmU(aqO_ildt!02K$BzYEFzX-MKnk;J>9;^^j2g^Ht_zZ)tJG9NUB3v=g1ByrHx
zB24@nR2<!W22qH=(9Ktaii6AtO_jjRu|X0C4H?436QSbh=4V62(aoO-6$hCQ>YBsM
zS&k$QYEr?(&p^e|&A$c}M>qcuR2*bJC`w`G2#G=b3lf(@8W%E$ildwF2o*;+KOHI#
zG6!_WGtB&2ByrFg<1q0>P;qqg*FeS5&A$W{2bph&<jxmJ;-ITNVCM6RL;QtqzBp7I
z-F#c9ILQ1^B=duj#1oLjE1=@&<~Kpb(am206$hE0f@ID<B=KA%@yAecbo1Xr#nH|G
z0u=|T7e^|W<e&$>gX}FwGT#JAya`D>5-JWd2f18IhKi%xn*|jIsTW1EcM4P-WN#0W
z`Kyq`L1(|i;_EzA9Apl%y*Hua==T1Hii6Cbk7T~6BqZKJ;wzEFt)SxQ=DR?}(aq0-
zii6DAjATv&k~ruJ7?}H)LdDU|Uk?>WH~%VB9Ay4+B=cV*iC;t#7m$MZ3*CGvs5rX$
z4p4EB`FD`a2}2TpjwD_U6-PI}6)KKy{%WW=$o!8;<{U&42c3Ng3!i6Dadh)PK*iC`
z7Xw|?0c{_$A@zfFki<b(sKCq*go>k^9}N{pH@^`o4syRJlKIn-#AT4g_dvzb%|8Ye
zM>qcsR2*c!ERs1)GLU!#iG!|cg1KKEDvoZxAygdQ{BWo^$Q*ej^K+5J6_CUyLB-L{
zp92*~H~$b+9Av&Ck~ue!#Fdc5|3byl&1aW|_!r%LU8p$7e9&DCuyAlj5?4hsKLsj|
zZhjtA9Nqj0P;rp?YDnfRLlRd<62Fclj@&+cj3kcS|9yodo`ckG`2`gRxd(Y%f*Dk~
zLeukpq;gUbNgR2c)&MFF@-Ol_B@d`L$Y03q-b5sE(2+2(@SKb!?vCW&gGl1}Nbcv5
zhr}1i`~oC#GbHgsB=MO@;zdZ}51`_paJY@s-eyrin6H849(|}dy7~oBaZorQ*9)tl
z;vn_N?eqOe;-E9wVc~EJNxT>7+^TFvh<iZh6e6|%&p^dN_9CAvbqh)SDw6uwP;pSW
z-A5`9KS9Mo<|Cg6#RR&@3Ys23SB$~jDGe1zS04%$2e}9NoY;7%ILO|3r0`FJilduT
z3l#^cPefARf+P+)@(1Rgy-4E7>FqvL9Nl~#Wk`5}%tuboCP?DQ>E8iK965ivBZ-6V
zVuZOT1S$@)7dd}LL&ZV%Y9ghpB&aw@J#zS`BZ(vLXU~I*gUr!FGN%+Oj&4pBk~p$C
zjZkrrIW0)$v_Zu|<{-~^Ooobs)N>;B>!+(A!V_71J5(H$9+30JL8v&$eB^v_0xAwt
zkKAwl1QiF_TZxn&I8+h#Rw0S&Ld8MmAlqvW6-T$%4k`{(kK8`YfQp0ctwu7x4oSQQ
zNqjL>9Apl%y=$T3==NTQii6At9VG=zKQEEQ>yXUnQ-k;y-FykCIJ)_EP;rp?^+@J~
zAc;31iC03!(amp$ildvq5-JWdzY)ot{Yc_XNa9bR;^^kTgNmb@FQN|dFUb5BBy+To
z#9NWX{h{LM=0`%s(ao=iii6B=Lo#P7l6X6k_%5h8y7@<-;^^kTf{KI8??5t#0o3_~
zmaCme;;K+_bo2G0;^^j^LB&Dpk^55#P;rpGT}bAaA&GY*iO+_LgUmrrw@abo==Pq5
zii6DWK{Dqdk~ruHG+26O(}ct$y7>Z7adh*|pyD9&`;pA|K@y*UBwh#=M>oG3Dvoac
zLZ~>%e9%#9Fn4Z85(gcD1{1#n6-PJ!8B`qId>$=`e?jJhju3;Hql6?5I+_b6?hX}4
zH$M<6j&6QAR2*bJ=!h(sIlV~YprfQ<;+vr2=;rT%ildwV2r3RTA9TbN%$y%c;-Dj@
zVB)gc5dWf^uMQPQH{Ta34l*Bfgc8i0WF&FW(Lpfr4yZV~`IDgH=;rT$ii6At9n}Lf
z=Nyta=tvuw_-Cj%y7_;h;^^ip>p=VqG9Pq=49px$ByrGDE->*ps5rX$8BlR_^Cv^a
zLFR*wW`UWr5=k6%BneFX98?_L{2Nelbn}^Y5$*>a=>aoG5=k6%^aV`Z4l0grz6Vqs
z-F$zjI7qz+Qa_>+Dh~1&=qL!7`Ta=Zpd%1q;#;8NAajt*rF~FwbbDVy#X;tSjwpbc
z^B+kZbW{LLTtyEO4(R6VLB-L{4}pq<%m*C_05c~GNgTBG946im6-PIJCR7~V{QXdI
zkolmk+c0ykB8h{xKEuR+LB-L{XVHiF3*CGzs5r=c&{kuZISxqTpsl?y@l>cdy7~D~
zadh*iLd8MmZ$K)aS0jmUL=wLM6-PJ!7E~PFd<FxEzd+`Lw(7#%DTX8t+5!s`w}y(N
zo9_x0M>jtkDh@IqwB;0LP9u^yXsakpd>K?6-TVzuadh*qLB&DlgSLdi%z1+(z8xui
z1PvknMK@m>DvoZx5>y<dUIHoK`9Q@%_U=G3KM6^ECz5zOR2*aua=x1g6-T#sJ5(HG
zK4?oQ%wK1b#P=YX{|PFNZvG#rIJ)^tMv!m-nZFmw91A4zeMsW5P;qqg)1l(%=J!Iy
zLFR+DsKVU87)ks9lKCf~;^^jIf{LS?{{t!xG9R?16=pskXtDv?4g_sEg^8O%#nH`o
zfQqA=p9U2NnGf3f2{We#NgTA*5+=R`DvoacI;c3h`B$LgAoD?Yp~K91g(Q9)DSU)X
zAn}E6z6?|x-FzpgILLg^9ojJSBap;FTS8&t4N!4(^Shwp=;m*Lii6BQh2+j-NaClF
z#NR>1(arw>6-PH;*%abmkoll3r!aR~B8h{xoWjHtq2lP~XG6u&&7TMr2bq5k$(_rQ
z#6eqBVdkHQildu<6Dp2w{(q=A$b8TiOqe;MW(a>>LbBHuDvoZxJ5(Iq{9LFw$o$Jl
z<}@RTUqKRI4HZW>e=AfR-Td27agg~}k<9ssBo5jV3iFqwImBP+<|{+R(araSii6C*
zj%0p3lK2fI@ph;<y7?2K;^^jYhl+#D2W?S>x$`WNIB1J1O#CZU9Nql?P;qqgRV^U?
z1(^@pDhe~l8c7_qH4`SD3>8N=KNl*FZvJGbILQ3_Na3&&N&Eql_(iBVy7{-E;^^ix
zS|Z&45Xl^IB=JW`;`UH+bn`u-;^^k*L&ZVv2W>5dg+nWn_!A`a*Fwe7&EF0cM>qd2
zR2*dfQzUafBZ-5yoWkstwu1N<-F#K3IJ)`XP;rp?pe>9ra}trnL0bl4;+;@&bn_=e
z#nH{*2^9yK584_CGv_>#IB07iO#C}k9Nm0IYly$l%~ywtgUknQ^@EvXizE)(x(5?a
zg^Ht_pAQvBH-9Qr9ArLdOCQXf)kxx?Ep#yP%TRH2^Y22%(amSJf%pq#K4{At%p6H1
zanKeqn7AWU9Nm0xs5rX$g-~&j`JgRXFmu|G#6er5VB+hc;^^k@go>k^e;+CiG9R=>
z31-e$ByrG|Bbd0XEyTa*=Bq=+(araTii6AtZ7qVClZ+$|+FAq??}mz_n?DsQj&A;L
zs5r>{pGf)ZB9b_0D-z87pHOjh^O-@5HW(o1gCUPgYeL0A=7Y8(!OXEo5(jOafr+O>
z#nH_#go>lPe>zkgWIkwX2+W+dNaCO^ATaT(P;qqg??c7W&1bcT#23hX&=v}qInqet
zpe+k9ac8JFy7|6Padh*Gq2eI(L0cAJ=5!*7gSHgF#5Y34(aqlt6-PJ!Aygb>K4|Lz
z%$)B?;-Dq}FmZVYh=0+|*My3ro9_=52bm9A@((j76-gYllpZGD3l&E<e>zkg-Tb{!
zagh0-rO+^QE+dI^A<f7AhKi$`&*}*A7rOb{P;rp?pe4*O^Bs}IK}(Eb;+ar!bn}a$
z;^^kjgo=aA2Q2}HnX?{A9JE9iCVm|%j&A-#s5rX$>`oAWfy@Uj#f6z8izE(OvI-M-
zg^Ht_?++D6H@_4r4l*CK6clDoH<CDL$s|mCGgKVi{Jl_dbn_oW#X;tSmh8dI`H3VB
zTG|E^S9FH>7u|eqs5rX$flzUf`Jkm_Fmuw8#6e4|VB-Byadh)%LdDU|-wzcBnGagB
z1T*I<k~nC|4@~?oR2<!Wb{B}h(9PF{ii6AtEv12(<BTK@T8aV_&xVSln_mhQM>l^q
zR2*bJXo&~RoQ+80pd}A5@taU_bn_oW#nH{@bcOf}WIkxg0L&bDByrHxJxtskDvoY`
zAXFUP{9>p$$b8ULJj|R<ByrGGHcWgcR2*c^45W1e2cY60bCBn$k0XgAuLHRb6$hJx
zv`*kLR2*cE2-3QUR5wUCfYc+eLuiGHgZzuU4rCKl9NnD5NaBx>#;NW@#X;sEuV;7%
z6$hDvte)8&;vSHA36eX-q2eHOkk>zGLd8Mqk=H*MK*d4+LY{wjgo=aIBd>pmf{LT7
z?}3Vg)FZoRF_Jh3k~<F~i6gH=xB(RhxgU8Q#UrRV$b95=6fdFT=<fLi6$hzDUKhdW
zfe1I`brjY};>hbRLZIU4<`+T5LFOa7e-@HBvVWH$i6f`awMgQ~>nL_X#X<HWucJ5!
z6$jbdinMOw7*rgj9(mouWvDnveIZi#TYwH{fsVf+yT1*G_!1;>WOFtkiMJuSXDd`3
z-91O3;vn~c&WUn?-a~W&P22`5eg{q51S<XlO<V^m{sm231uD(}T6_%kFUVdQs5lQ)
z9F*RW^REI_9OV9QNacejR2=4hm^;nU#9{7qMH7d)GZ;-A=FUVkahN;vq2lQ7tc8k$
z+{uD;PQqlUILMu|k>Y(9k~ng_U&A5(2T2^+oOW+WJ_6Z`ykBM^R2<|^<nwcOLB&Dp
zk<Sfd^nsWIawjNWVCTq*qKU)Ge;uee$Q<N-sjvMI<{<m)FOqmWQu<`_ho}dcgPdQu
zki?Pq^+@3mH^Cvk3$#d`0n(pBKG#b)3SuwFzr0BCVud7*?EY{Z;<ZTP$mVcFL(B*H
z3prktpyKH9Vht4ssYi~NCa5^boyhSr4NV*tFKeOVAaju8B{vS@9*{Z6{;Ee3??8%|
z7N|JL9OQWEK@vxfmpM4Zx8V@CNrkuvWIl4dOwNRegWOqxw7zQ>k~p&auj3GZi6q{M
z<ga&7age>p{wmCZ*b5Rzj<3Zz5OMVQIsz33sYi~l6wu}br1A}xk1Ei_Ve!=u6$hDv
zypLNX4`MGU9FYBMg(Qv~K8y1q>Otlp$IE6M;s<buU&0~&tOQ{`a(sP-ii6zQg%r-e
zpyD9+AcwOs=umZN_}C-oJ0x*r|3=^t&q5OKMzS{_DvoaNCnRy?_*Jcj_zOLL-Js$i
zbCBcr8B`qPU*!Dw3r!przk)Ro^Fihy$M1BgILI7i|L#Q+M-CsgI)pjM@oR=d+!=>>
z2oCY|W`z03@mmHJ2f4EcDV(dJ;vjz^$M57eh&dqjw~+HMk~p$|Z{rYWY{za+H&h&C
zFLFGd>4d09kH@c2agciCcwEv2Q4ew_ay;%p6Nkm)C8#*a9OQEK0g^a!{I-J*4}zw1
zWdF`Y67NL{&v{UBkom~rxu6%~PLMcqyl=oEz88o16&&JCQxN7O$Gh-Mh&U*Gek1jd
ztdPW!{S|{lya`Dh*&Lo(5c5I)LXJm2&?Q?~&b2Ftii6Z6$D`U@h&dp4BFCc@nm8;T
zL!jaybCBaP2}v9|9(m>=%t!XG9Flk+Qama{#X;sH$D=Cfl6Yu41UVi}afmzN5Rb$m
z&b}PtPLRFG@i=)kL>v@8)kx*-E+lbef8D_$&a?)*IXzHukiE$9cy=8`J$iop1{DXX
zM~=s(>mlkv?nI8qooM2)c)Sc12bqH$j}MW=k>jy*1Hyb{|IS7d??;Nq1yFI2`N;9O
zXcNR7kT`NYZo(nHABXrg9O5lI5#}SuqcCU_9ke`&Kq^<Qki?Pw6^lc>8A%-39Nzs1
zdy(VO{~$yhJsvBd;-GLqjz{%F5cTNsXpJTgi^ou?ILI92cuYnTM~+9n!wB<{{i}c^
zJ^?8nRiWY_^O56G{V2p7kT`NYn&S|6!66=vL!9#r!hGa-Tzml{4ho-cq;hp1k~p%z
zDnXkYq2&g0yp&yrn1dcK)1l%Ze<8<<%N2-vkiE$HD*{a%7B59magaI4@zQ`KjvO!Q
zR}tnTyWbZ{9NE8ru0hm;%tsD?p6l4fC2@%B;}D+&+RO<JH{|eN2o(o~!$hQXvJ5H?
zau0Gk5e5yqLGzs|Qu(QeB#!LgcTjPVImq$#{t?7q=<y}+7$Oc*j~rinq2eHSBFEQ7
zG;vsby@rZ|%t4N?pGe}!@wNB~#9om3$nHOhB#!Lgif0h@AoG#qs{@DlR2<@KaEQyk
zL70ymUpi26kUJ+K#g`#e9ONG4_*(oPVh%|CA*6D0ACkBSk~!y)#F5oMMiS3J%BQ!!
zAk0S=|BNK=fuz3vFG4-C_+%t;Eu?g1#sG3T<i0Ruac3m)=}7*HL=s1i$66$DPbB|N
zf{KH}O_`N}0hWFiA&I|765k0G2e}H_{F_MP$nJTHBt99*-d9j@kiE$9^%*J-GJhvh
zxUn&UL?GdSEG~>B?urx+YB<D=k;Ivi)Vtvj4@MF{hNQj%hj<H;IP!RMH<GwEQaH?j
zii5%dc|3VOR2<}MWOJ4wiR&PlvkfYaZq8w-ILMr4q;z!)hxiL5ab$bnBZ=!G+4~17
zj&3hA6UatLd>JFzYXKDpsYgEld=^w3qzhU7W+d@9Na^7m4)MoG;>Aeu<-rUx88YsN
zY;Ouw93+dZz8Fb763LuC9O8?S#2+B3-+@E?7?L=0IG;rl*Fy^DJ5X^@xFM&L$53&Q
z`&E$aWn=+~K*AqcTo_4QA4$DBR2*bJ^1Z|MP;roH$m)ZU#C?(CHybJrGDjGx+?Wj&
z2bqJcelwEzWTg0IWCf{&xF1<u7)jg@$^E7{#GR4E^^wd^f{KIOiF_|`5f1St9O9F3
zh%dq+z6*!=S*SS3*U0XCj3h3J6wW-L!yTagV&wS|VW>FB97Ck^!^aL1fuw)r`9wXa
zI7k-Rd@Cez10-|2pyHr#LpCQEDh@Ko87W?DI6xwhctjRYL=rbbGCu<<j&6Q4R2*cQ
zF_QW&s5rX%`A~6?`UyzuSe7A)Pec-5izE&j8iCb=Cy~U>knBAN6-T%C7E~N$Z$Fax
z50S+Cki;1|K`JrhMF=VmlAVO4UK}cpZm%*_9Hf3Sl6noOIJ$a6Bym-we3}Fm2bqKH
z-%KR&sYvD*Ac=#9j$q+74JwXq?+P5^JE7trdy)OS4=Rps&NUq3UvP;3g^GjBM-Cq*
z(BbLOegSfN=0*}n4j+4{ILI8(P!`O;Zb;%Ykiy3oNqjnzcs`OiayXYj#nJuSi$i=G
zk~p$E_d>-%?leJ4w@0Aj=;l9wii6Z6yXQHQxH*zJBA`QLp#30IBykz2IJ)_oNaD!u
zG)59f4*zHz;+aU|$mSFyi6fgc4Jr=u7jikX8Y+(N&dpG9korKR`r-go9MoSsgH#S*
zhKi%Be~ctP52-x-fkRxF2V?@IoZN||UJZx1F_JhtlKQ7e;z~&CPN(uB%vVMdKaC^~
z>Q{o+DuGUpyo5viF`78^7zBowXyVXq*9>3K#G%_&7=A*<LE(Q8X&(PSR2<}5kb62H
z-6aNIK9C3`d_dx$JBC5-6hRXQl|dkJDKv4IJ5`ayL0c1G`Bw)j4swq?Qh8_$6$jZ4
zvUdyAJ+^4#(BT3G7c_C`un&Vbn)n{5Ij;O5lOg`HK*~qOP;roZ&Lgd-YJrM_bRoz4
zWF+x4r1Y=>NgTPqb__`zH1rM&hdWSlki7{=_I`zmgVI0p`T-FEkV_!-S0PfksX@g-
zva^xOJqxHfy7?YR;>hL%Ac>zwGCv$Dj_#gbB=I{)>1qK~9Axivr2KmYN&Fs?_!Fo&
z$b97X)laB6$X}rJP$Q)PN^T77f*=t{I3Ty5`Jmz;b0m?<lQ1N486@!zs5r<pFQoL)
zk0kDmB)$Ym93_5{#F5j(B_#1FNakFJii5%jxj%jnDh_f#^181VP;rnu!;#|m2UHwn
z4j)o{{fCN!)FbzI*n~hLkn|scWR56Q9Apl1e@7WA4$|d|6mGu4AQ6Z;$l{Sm;>h+U
zAc=#PCc)BwF;pDg-YTd#$QERC8j-}2@5AbYildve7%C1jrwA#%?S+bi!WlW;UVw^&
z%t21KDk2~gAnENEk~!8;agZ#s`R+*Kps6#Me|@0hAoInM;wunI9Qk~nWT-gE{B$IH
zYoX%k?w<e^2bquT{^LmE$nL)f6-PJ!6_Plz``<&wLFOa7{|k~hviq4qht@&cE$flW
zNja!Ey88{G;vn;p-5-lXyaP%64pR6`g^GjBM=np+LB&D-MJ`W{B8i(J)z_z>;vn}R
z`}aJOII@4QAc@N%<(GR<agcjZ@-<W(<eu+H`SCYY9AqzYz7`e(sf6S^<nWY75=V|N
z6{tAK9Ax)vB8elr-xw+mvZV<rJZquiAak;j>ZwUkadh=7ki?Pm?|LM0Tcq-E4^$jv
zK63eU7%C1jAK9E!NaA)#=3Ie_qnmRZDvoZ>BP4NqBy-+F#nH|A1{DXH<A9`|SsWw+
zDIbvA!yHKB$l)vu6$k11gp^Jcki<dh(+9dfQx{1bS$z<axBybRjf9GW+>h*@I3#go
z_Y_0LLGC$;<emnoI4Ip-LP`%T5+Ie3bcn3p8A;p($(&duapZb48%Z4G-)=2P{oV%^
z2f6<$lD!*|#9ttZABBp8Tm>?x2Wrk4BylUG@VNmM2bquD?s|nJj%+WlB*<h){36?{
z2o(p(g6)O2Pc)Fkk?l2silf_W1r<j(#}$WoArA2dH1TSvd#-~H35Ax!$l?DRNgO%8
z*g=PZLe)=2O6NRKagh6w+bzOSagh6GBgMNK4sl~7@qVOw!3~FaFp~Hrq<BxmAzq9m
zUXNscJCe8!QhJyS6$kkXxj!-&Dh^8j(n$Wg4iyKfzlBsDzJ`i}!U5S{X3!z3(C}<P
zGRFjmxC4?na=GV@BrcBR{t&1*$UVsAXEanC<Q`;ml90s3kj%-4ildv;3>62N!-y3A
z6QJUt@IkI;w?M_w)gOb3gVe7=>Mxvwii7NJKoWlp6$hCE%3nU565#g#XC!gZJpw!q
zU}1(|Na7&%HBj{opu=aO;SUmTfQs{>iT6OoMbX4(K*i<J#2-V&)zQRZ_L`%KFNUhO
zLla*D6?a7wUkVlXK@(pF6%R%eUk(+ILK9yB6;DJHUkMe@L=%UFa{*Kw6ko{w(0Zsi
zD85RN(tkTt928&3>8%e*TpB68&4P-9%t21Ki=pBmbEJ{-?^dWdNImkr(h;aQy86pV
z;=D-aJcWv*oAU)K4l)N>Ju~Q#Vrcs5K{7`ShqyA5xG0i(GaTa1NaCB3)Q2F6BbVC=
zP;vBlDT9iG{PhkgA2mS5LH<HEX9kiuvb{@?#HS&Z|0|*5AoG#S|LsWPFOkZJ!%%UM
zy~mOKbq$C3V<hnzNap-N5=VBw2<XsfXuN>(H7wn#Ld8MuEJjM7JCVeZ)6XHOILMuH
zNa^z&R2*auay#lSR2-yU9!Wh1=&)%l<J*Qv;>hD3woq|UJR+B$K~Qm!`5=G6#yujD
z#F4|H6iFO8+!~R@k@I5*lDG_#`=>+2LH<R~kMp47Aoom1N)L;n;vn_N>0uRA9ON(L
z{>~PtILI92af~BSagaI4{hiZLagcgs_g_L1M;^y`2o(pJgY5p#P;rnsIY{YH9dxKS
zG`^6>k&-}{DnZ4O=PSFR;^^iqMiP%js^70e#X;^tUXR2HIy4+9-CnVVw0ni2;vn@8
zk@BwtR2*b4viZSC;+;tOB@;;;lzw35S3<?n&7T1k2bqs-&SoTW<n`ndpu@_c;e(uy
z%Aw+*ct@@;c0k2J_AW;n_jm>s2ic2k{%0idW~A_x1s#SC4L4+QV<ho)Na`J+;^^*4
zg^GjhMOI&oB)%2NoHIDYA0vsoAcg-2s5rX4f}q31q3%akuZ$$VA1QsRf)=kp!x?$q
zR~=}w87hvvUdsYBs0}qA*_>b`@o7l@dIl8-xf8kkxnc<l83qQBIP&<|GpINy9+Agq
zszIAeq3%I0-@2jVAajt-Uknuo*#b(Ru<~sKR2*bJ@;Ji*YmiDve-qjLXOP5^%ZJNI
z;){^RRUSdbLFOZu4=<tOAX|{l`G6$87|ERfP;qo~SZqKhK>CTu{cCQhI4B&D%R^D9
zI7k<Ad8i5%2bqst9_m2FLF$p+X^bR}Tpl_>#X;sE`*$&t_;jTF=mHv)fyN_pdh>;f
zquU#TB+h|Uk0e6H(e32}4c1^W|11vi$53&Qy?c=I#UC8vT%bW5X!=JEA3-E>P#nO<
zV-=v{=<YOzii7O6MatKKIK)$Nh!-P?BfF;xNgUZdoltRf_e_S0gWMy7<et4a#4jU>
z8zbfScSz#M?T24bagbYNk<?3p2DzZ&3CgFiaI=GogVZCJ^HorBkUNphpN1rk?4CtP
z;xmxi70aRGpm0ELS8RrggUoM7N)M&ZAQ4D;h3uYbP;rns$m@HLLd8M4kj<F}y5tf|
z`cwx^4nf6{%Ud(3ILI92__ak6=SIpGK2ULxdyw<va$k@Mka7drotvTJAXzJ<csYk8
zjvUTUq2lQA!srJw0n>bAs5nR#*_=ouab$Z_q2eI(k<0UHByr^QGaD)nG9NkpsQ80K
zAmuqo9JWu>0!<v2-dv&Lpm4j3R9-zo5=U-_Fb6=)2dSTcq@Dvwd;?OyKp0893rW2-
zk~ng^B?w8p8%ccwl6WYR_;e(3Wc7=X#9NWnuSF6MMiM`XB#xX;?n1>uzD5quk7(ks
z@caiA2ZaxEcuE9<On{^l<aVzdR2(D=GM^hdF0F<p&Hxp6gNlR9*G6)G5Ry2u`5S^j
zCPVB+j>ogX5OENRoIdX(iO)nTH=aPnLG~h-8@Zt%6Cmaz*K6^S2yx_moedQS$s*_L
zA|&xrr1n5PR2*b4a=vbZildv;izHr#WX>F@IJ!BDq2lP~tU?k;E@yT^#nH|A5DhW`
z5)R1ehdBl!4k9y=%GIez;yy^>JO@b}ROG<Y)lDREWc3e_#F5qW$AWBxlmp22N+XFQ
zhrbe%IH<=2vsWJ~j_zMGs5r<LWOHnh#1)asXD_HYx;ep6agaGBNa0fr6$h1v$o0+?
zs5r<R<ZwQZB;JXXFYY6Ww;_qY#39Zd2XYA{+>qTPjwBA+k_ZbQIVAB_Na;-jDh_fd
za=JB!ii2$NL8^BSLB&Dpk^9T>pv%Ic^&@h=z6KRXH|H^uxFAw{rUG=iIMf{Ea-at)
zjvmgopi9J|>XF@(nF6vAlFpIE<<b!1$nI=P$1Xk%NgUZ6y9|hW5D6N8hTZ?`h9(ZX
zf7TC892PH0=;F|OY@5);Vdflxii5%*+5OL<;vn}Rhv(T$kO(B5AgBK;NaBJ>>Hi^A
z9ArLndiV?#2bp#aDLqJMfkYtToQRZerz43YhnryzLOrtkH$lZgvdHEiMiQThlun)?
zi6hqwAE4ss>4Ya2WHKZikkuO@i6fi87b*@42jp~UmIpBhB<_pk-zFU5$8d<V<s;1T
zLo&w$NgUbU<4|#Qe_er!gWPigsXg-wN&GdE`Ah{6dqE^}I7mXpLFOQ<S49#xMKZ?+
zDvoYW9Fq7fr1~NmDh@Iqxn9nKii6BSPM?KH;zCI2vkoc_G6y+*HY156_q!)U#X;ut
zAeGx2k;IY1;TTjLJ)D&aK_)=bIdZ(XAc-TlGd+>Sk=vOCNaD!tOz9$o`N;X@WHCY<
zIlnlSK*T{Ls67T7-xDkai9p<m+|HDNilh506Dkf0PvmxHK2#iJ8pwQDd#@Z#9M;}z
zf{LS?KMyJnG9S4exC%)e*<UB1;vjpG<K-HX_#C8kbsH)UG9Niz{X-H*jxW|Skja?k
zfHsmiayl_b5(h2)fR)>JNaE5+?(u_)gWQ9hKEt8nAls46i9-?xP2I!H&wz@fo0AU}
z2bqJMU&@fgk=v!sP;qo~x}f6d=1fEqM{bucfQqA=vm7c8GG{hYIIMw+gVZC(%VwxJ
zNc~%+dgL^cIC8xIKoSR~Ls&nNtsG<mBpyNHuyB)sii7M$-iNCU6$j};Hs2me9N9ho
zNaAym{1pNf2bquTuVkn=$oxX2a;6$d9NFGANa7&(!~C@iO&sR03s7;8y~z8BuS3N_
z_9C1A8A%-3J<Js#m5^|ohvY8~s5r=cWPb@m#X-8BAjOw9k~p%xF-YRb{>nlVhxw}k
zDh{&O5vhJ@hl+#jMK*sik~p$^HY178NAlMWs5r=cWPcroii6CLL5i<uNaD!$I#h#H
zVvaARLd8MmBe(N&Y9Q)CByu=3pozo6VLDVCWDaut&V!1B%2nj?mfc9=$m1;!pyDul
zVdh`11&Ki1k8I9w9O5!{2=&P3J3_@lvLJuK%&&urgWO+)6pyV?agciC@LY`~jvW5?
zk;Fmf!}7&vG;x@{T=gK6A@v<{`VoPOqlcR|R2<|^<Z%EC9OAAx#AQL3WkUNM$m0f@
zP;ro}79gcVJ*YUyUgUIW3Ka*bM=sB8ki_|r+CSb<agaI4^-D46P(SE6?OCMs+zAy2
zg#&W`bQM$_WDat=JqHyBxd+*t$4KH;Nap{9ildt^1v<<Q8a~M88$iWD<|CWqj3l0q
zWd05u;zy9gk;CmYk~rwdF<3ge1r-PR7dhM>L&ZVvX+tXCej|w^r&}G+VRq1PMoynr
zXyPz?1EAs{du@^OML1L(WG}M$#Yp1F?rBC6Ux<{hI-uep^O4ilWT-gE{BKC%xfV$r
z+1`6d;>iAbhb9j57YFFDIcWSM*Rx_s;>hKgEL0ri9%Os1k;IYR>4PM`2+6;JP;qqs
zCPT$R=I0>w6L~?0(?Q*d+^${<I!p~Jj@<tI0~JR%M;LTi7&P8Zkjz)ZA#RK$-iVa0
zl99wg;S6iHA4C#IR(}>r9J$?i1xXya{rLnc4hkRSbp8P<4)PbWIp2}Qk=vh)phLBw
z;e%|BFjO35&K)FwY2y%gMiSRVN{10R#EX%{Hz1kchC_TZlK3$s_0OT=pm0b)%6BfH
zL#Ckq;zQ~$CnJd?r;|pgILN=q=Jz6rBbPr@ki?fEjk7I=ii6yP9G;t@;vn<0kkZvf
zs5pAL`UNTuG6&h66`(_xp#DPc?>vEuqnrN$NgUbz-;u<T%TG4YVLeduk=-v06$hEm
zg5-X6s5rX&9iieN_apZQy^+L`^J6kp9Nqk4B=NUM>1sJt9ArLn_;`U1uYtNBS^N>`
zkQAsmvb{Gzo3)_%9ohWPNaFlR{`Chfl7^atZ2mbM;&GrwR8aNE_KJWeL80Qv<}iZ>
zQ=sCLk<zm^R2&pO$nJ4Q65oInJ`14Y=;0#)>bybCN49qzsIv_fM|P(Xs8a+LM|Mvj
zR2<|UWP6j5#P1>H(*sa(boZEoIww%`k==71)VPO=BfBRb)YyW?7qa=yNaFcO@iiZZ
z_+}*WBqVp9#3B9&Dh_f#^7zjSByr^NpU+TnQ1}!fna>QW)S>PN)eErk7Ctm_*m#R1
zR2)5j8AHWE?m^C9wn*a0;T8%NM|V#$l6W6dxXp%&gUm-ZXCsn0a(pQ+2AK@$Zz7vx
zj3jP`ls;XM#F5(xXQARCdy&hxXHapFEy(H_mw-ed_9C0lizE)x3Tw{@LB&DlBe$cJ
zq2eIZ6p_Ng4oMsoU*6Dl)Zu92bD-jNNaA_S3=E(<TtO?==OBp-A+7iOh$L>z%)kJ;
z`y8ZRc`3*x5PyNhL3f9P#C?#&k=+@AB#vCp$0La&um8-0ii5%dxtuSBii2!NHm3$j
zd?QkQ*9{d%H)k?b9AwT4r1ZZ9NgNcOuywp=(8OWk`2$HD*&Oj@Ad?~CgB;GrNaD!h
z9D^hdvKO|VKLt&^1sabfXyUMS{zuWoVfzTAmqXkG3WqaD@v8+D2g!o$h55@0O&n&g
zCz?3Sol$7wF!wA(6Njn4iY5+or`8IPOCbGdWOtfE#X+*j?(~9+gUTP|dpcsE;vn_1
zNd4Ais5mGbkk?VyK*d4ok<(Q(k~nhuoCFmInS-1@XF|o%%~^mXj+{Q%L&ed}ISdsC
znKKV5eOjypi9o^!x%@c~6$i;8tG|sTz6&W|JVFu&9YF^xf8IdF(cSYIDh@LL1d@A1
zR)Ity=^VM-Q-+Fz;sv?CpRpRE9%MeU``e-7=;|ZZAk-tTdnrZ|Uy9TY=|mDoF8}W%
zi6gIv`Gq8oY)<xCguTe_+y@m0$%2*?!NTntR2<|l<n#2NA&DcOr+0T9$OK5ZA)E6T
zDvoXr?|O)OkT|kA3L7BeAQCzJuWtm2K*rgS!=G~#c5zW8apZht2o(qET8or^tfAr{
z_aNt^RwQxcaC-?AM~~m^%^;H@=@~h`WVb-XLF$p+V+0ik$%2j?hK0WkR2<zsKaj+c
z-4nbOWCCXRoPdgh%t3a~qiqoNAaP`Kn71Ruk=tDyNaD!tE@LF|4y1G&heJFADh>(<
z<apcx6$iPe7s(vn9SHXziz^|CBd_n$MG{AzcgsK$NA~Xts5rWN*mgqf1(C?<Sq>@=
zawl@W&_fbOPS4+=;^^jE?*f^OnO~xz;^^jQBZ(uMpSc@i4oE$6{2J{=h$FWrzwW~>
zo^t>qj_%H1P;qqga}Q!y-+Krm4pNV7ukT@qIEVz*cd&MND4IB|9bN$y2bqK1-flq>
zM>c;ER2*bJa(%ZFNgR3JZ3k2wWIl3zcMnM%Ih}k(5=XX|^9aaBNPb5acfcX;4iyLK
zLN4Emk;IYfBdwz#m6+x)IR+62k)S3mtlU@$6$kkXxxKvsDh^VQ96sBT#6d@-!^}Ab
z6$hDv96o2E;^^jFK@vxvCw&MNM>pp)R2*c^Mx^?e<v2(Lk}r_MM;R&(G6%Wdv_uj|
zK1a(7NgO#|0-@p{TaeAqL=s1KPbrc(sA&ufpDL(0$UVs6+zb^5ncsutuW2~M7bA(^
zL+Y<>fQp0iBl3AWUy#I+&)ZQu0kRPiZlI;RFn8)AiG!A=!o)q0#F6byMiM`S<o*Jv
zIJ$dwLB&C~BdfoRB(9C*uXi}a{~(DYr%&dSAd?~f0?k>$+%EtX2ZcX!`c#IBgLKIw
z*=vg|j^wXGBymu=1hNCv?`uU9huJ#^Dh{$2d3=5mR2*b4vN_w(#9`*JodT(Z_$v@;
z9G(|R9JF*7rd|d~968-uA&VpVHvvf;)P;hXlL{3FxgR;*7DL5BuChVukM|;pBioyF
z8l)0ZE+Ox~TLcvc$)bb<nmEioXQARC_aM(R{)39c%z=&PbDRN*K<q`{$EO7q2gxG4
z(;G<~*<Ybhage>p^OYG;agaHnE*;FBxlnPCdgO3xhKhsK$04Pw<xp`@enD>M97hsI
z-v4zADh@IqdH<KjS&+#P|016+WDgYw$s*h9jU<kokAjfIL1`T3uXw09$X?`plm-<C
znU8$#O*T{<q#pU)n*t<p<aJ`rP;rnsYDnQT6G<F7zLp?~Bd4DoXyP#UbDRU249Q2J
zCF(G7ekAb_r2Hj^B#vya1(G<jJHwI0L0wpw`7uy&P&go`hh(TY$W^9D`KSg-9NFH3
z=RqnV@r&Gk`wA5Yr61&V1xyzp>Otbj=}H@iIMYRldJu^mo+4=CFn?)5#X<f;F5e8G
z;^^i$p^3xHnTR9~+9CiGpMfMEh7>Pbk;IY1=O&Uka(F(5ii6yVoPT*Pfm{el56J0X
z7)c!YoHS*qILI92^sfaK2bqR!jv<mb@;PaCP;qo~T%qD1b3j+bz{0@?NgQ;w3rsu)
zDvoYWGE^L74ru5Cral8I4pNVt4vV4UAoXEL>97Y$966jfK*d4kAh(yAFM~{ggeP+P
znTjS3bI)q1ILI92^87GV9F%U6)AI!+apd&;1u71*9ob%{D<BbsdtmljB8emWD-uZ@
zIUMq#;vjb-r=KRMILH>zkPpoKcBnW=J#sithKhsKS0a^fOjki7kbI5Yj|hQ^gJhA@
zRWy<~az7;tDh{$2Iekt*5=S<F6;vE#KC*kZA&Dc~yBA3ux!ryWDvoaNWvDpF{5~ZA
zI$Z;aVET6<R2(FWZ0`yraVw;8nB7oubbB{n2blngcVu&RA&Dc0+exT6x;gKW#F4{|
z=LW)jWPeE@i6h%9k0g#9ZaPqLbbF1V;vid)&9Oofw?+yFcc?hJIet)abaO(H#BGqw
zNrH-_o0AC@2bp7mq`m+u4pNUi4pxdJj$FUjK*d4kAp5HsN!$|2{7F!8kom~zc_vgG
z-JAtT;<iZUtb&T8o3j}z4l<_#soWE~2@=6fpLS4jkSwzMU6I6*(^Uvm9Npe3Byr?)
zH3cdTG9TGJ3y{Q-?Ol!}j-0NxK*iDRJq#5GnLi6DKN{TviD3G7IaC}Zi)`;YBynW_
z?uCk@+xr+v9NEABpyD9&k=?^}8zh36e+7}mk^L(N6-T#M6)Fxg4cYxVNaFTL>BI~w
zj&6=ER2<zL7bJ1ybQ=s6M>i)5DvoYWB9b`higj2$QUDc4H>VjY4l>6dDcwGTii6Z6
zhx3&?AeE5#eT_8#^#dvnl0^=m|48D<@ymA?q!MBda(*;H5=XYz2PzKIh3w7<BynVW
z<B`OX<2MH?4)PbWy~R**kom~wR3V8wBgJngR2<!$2~cr#bEYGSBd3#vP;qo~RzStk
z%~_8mj+{>RLB-L{ISLg=H|GqJxGR#s?m)%S&3OzJM>ppck~rvWa#(u%2^B{-hv6Q`
z1kC)%jwJ4a<Q_4oIJ!B?P;roH*OA5_OpwHp+hcxEaZo!DxxJSO6$hFB2q`_+Ld8Mm
zBbzf7NgUbUWk}-4>bD??gQn(S;j<Ge4zd@yU3VBN4zjlv$zMkIK_Za+f}Af_LB&C`
z$mw<?k~ng{I{+02*^8Y1pCO4Oo6r0JWHKbakln+NB#vya7?L=0zEg&ZquXl?6$jaJ
z38@~*#35deBo4Y#5*D6yP;rp?$mgpxBZ(uoAC^JI(bL0js5r=+$4Ken5L6uGPGtX{
zL=qQ4njgOg6$hDv9L{&4;^^i)K@t~5GUp3a9Niq|haeLm@sfd5ZWlqtLF$p?@e7hT
za=Fd?2x1N>9FWhk;fIQYWSx-mqX<+SWIl2@7a@rw+uMOdd=69`WIl3uE=CeZPCpx<
z;vjpG!}By$9Apl1I9x{(M>hW+k~nfX{2D5bZvH2zILLftbABR;BbUP*k3lLS`4rim
z{7`X_EV4ObNaD!(R23?Y?j9YeIJ!B;NaChQ@nsJcM>od}DvoZBFOs+!k~uL@addOa
zpyHtPgIun5L&ZVrpCjd?Nl<ZgduJkvBj=-KP;rns$l<vbDvoZ>79?@xd~^gVj&9Cn
zs5r=+RHX99=?O>#5|7B~c_WfIaz5Gx6$ga_ay~i&6$hE-h!mcuq2eI-Am^i3P;roY
z<aF{8NgO$yFgyjRgt!wqeAJM{k=<_(6$j};_OCaRII_J#NaD!(F&-)oazC=YX;5*H
z`N-zvB8emCyK<;Fx;b@FaddN9k;IYn-4v)ex;fjR;-GjzPM@ct;vn^JkkaQRs5rX4
zH<84V)8{j&ILI92aCi$9M>ppSk~nhuWO)Wsi5ZW=P;rp#52W<j1QiF_iyXh7pyD9)
z$l?DJNgO%-a6AX8#I#orNgUaHcc?f>7qWYTk;IYhjY1MfPCw~Tagh6w!z~Xg4l*Cv
zoKhrl<n&Vy6-PIx4JwXqPA`%;a{8GA6-PH`F;pDgoK;BT-bnd+7gQYGoP$ttbaPH1
ziF+WKa}_F%Zq6O3IJ!BHk;HwF%=rKnM>mJ<1;_-<bvuesagh2~NcqATDh|@si_|V%
z1QiFVM@}ayuRtmx?Gxm9)J76VPKQ=dagaI4=^+709NGLzs5r<LWcRcpi6h(FgCvfe
z4rfBe(d}IT6$hD*Y|e5dapZKk5h{*u&JL(Jx;gui#F5kCIjA_gIai_L=;qu(5_dp~
z_t#KybaOsK#X;tTA;qKoYmf+}9N<FQN7IKxoc#?%J%~g$M;J-m9I0IzghM<INgO$x
zQ<20$CxpY=`9)B1bbnPs#X;^tHm3neToS2W-31j#H)k?b9AwTkr105-L;Nt3I2)4s
z`%rO^`N;DcoNqxUL-GZ(dSxW>V5D;187hu$P9%~z^88&TR2*arvN@BH#GfLW{{)Bl
zXC(2*Nb1GkflP+DAGx3F2^9yq^CnXIDa9ck_#R>os9r{%mst!I2bqJM-`^mKBbzVr
z0b&kFJ+k-*B=P@9<=9WCI7k<0eg}51gyJWV2&6njc8>#89ArN7IjBicagZ*MIk59i
z_k970V48CqNgR0{=5r)*<aXmns5r<pJ*0g78!8TR5Ary<^jDBdNd8qv3V#D6@iHWF
ze<X2ae`P|&L8c-5s{lzHIo@X=i6f_zB}n3+rNOZLyAmo6azFC8#|Ef4C_NyD!!D>e
z$UXW<;cx^h4l)Nh98MyMBlq_&K*iC`zXcTsnU8#4>uabuy85qBadh>p-#{Xe@JDXX
z^FYNxvdHC<Fp@a(`L0S(age`|>p^3vILMp?q;k~`NgNbkuzePONaD!qW01s=-II(Y
zj=Vm<2r7>5o@S^x$UVJC?wN%{d^3{x0;F>C9}aQh?;w*Q<xB#SdJ`mZkbhzOAneh^
zVd3D7CJx(wk$@%++h?&EO&qq5<2sr+Y@dbZ4~RQK;e))-!U8G|k_EXFW{wA%ILtjk
zXyPz`#iNPC+_?x%9HxFH4)N1S;>h9o97!D6o$NnBE{B9aNF3(hNT@ive>0%sAYCB!
zF#lGdiNpNcjwTLs{|q#7n14T`iNnkn{{^xU)1BE+addZ<LB&D3kli^2Dh|r;$mR1g
zs5nSH^8S~#P;rp?$mP#vs5nTyBT~J2@;68XQa&K3lfO`LkSwx#<v$=1h`(MVnX?}%
z4zl+KQhDzD7rT0YByr?@D`80Dpes*d<#Pg59ArLn`I8P62ibybP9Bmt=;~3JIkix6
zbaPsu;^^jdBZ-5q`h=M?8!C=&&LXHdx;ZP6#6eeX!pzwQ6-PJcFjO35&RL{zevTv_
zj<jCr50ZEUl6b^FkO`3ZLN=!uNt_F*9P36BN3KsdLd8Mp5V;+42uU3I{FX;haggnx
z^bGSa+kcP<q#c4h?%@O#2gxGa8;2y0?9MDCanKeVnECloaZq?7*W=Alagh0ok^F1I
zzzka6$^a5azE}4Nk~s3cy3C9S^~mN3BZ=!GnZF(?4sy>8q<tKxpyD8Vk<~whileLl
z3>62dcSA}K;!FtlActEJR2&pv$nnC&j8G4X7tq>APymRbiNnIv0V)o1PXUtq7ed8B
z<|C(vcTjPVJ3;2d%n@aQ*b7pR9Pj?D5OJ7#n0wOD#9`)?LB&DtK|W8o87dAl2c~`x
zR2-xpx&L^B4Pq}y9JxJj#|{w(nS&gj{z&4WEnG13L!jaybCA>93?y-6^VdSf(apbs
zB#s=v4jd5ofXqiWXAKVV%TRHU`N-!yT;qh80}@AWU)@C#*F@@vzJiK_>_skbzeB}A
z<{+ET%!S>2E+lacB=g0g;^^kfLB&DlBfC=-Nn8!d93!YWx;d6maddMWki^xI%<+ec
zqnncq6$hEqft0Uvk;Fmi+y;98T{W7xEmXV>hj=$s9AqzY`kV+A2iXfU-x_MpY&7vd
z(EY+oq2eHOtdZ*9)lhMCb2g!g!`#0IO&n(aaU^l%aJY;l4sxeA)SdUB;-LJF+;4gT
z6$iQJ0#d)}6I2}Je&l}2cO-G-eiJh{BE4B6#fuA69Apmi_(Ks?9Aq!ZoiP8_p^3xd
zs}qNKA5<J<K5~3bfr`V-hsD=CG;vsXu7HYz%t4N?bx?71bGD+1!`#0YO&n(aMW{H)
zd`qPC@D(Z!G9NkIn0OH32@0Q5==tirIK+jZ;vn;p!$ATn4l*BP4$Pe@XyUMN*2f`k
z0u@I$-wG-YGanYtE@<MgaPWhQgUmq==Mbnkx;fEk;xP9oqlv@J&q5QgfreW(R2*b4
za`-nw#bNfAK-JGe5=Sog79xpjA(dCFq2eI(k;~`nNa8F=@qQmFj-DT1Ld8Mu(MB@=
z8&n)*K5~BijU<keA9)e!M+_-HW*~_p*QYyih+jt%M>gj%k~nCqG_3x80Tl<i6S@BV
z3>63YiyO&327C~Ag483I55J+}=<3<|A?ne?O%N&$Qm=y)ZgNm@kom~rri>(x9B#%?
zagaG~NaGdWNaCP#zeAw+PF6$3LGD4`FVhDV2ic3fUuGRt9ArLdN(2^eJD}nq^~m>-
zo`H&k)PwS`3$#3E5rBjPNF3Rn0!ZS>`(i|);vn;p_r*vdi6e)DB2*k?K63ikKoZwQ
z3TJbuILLhD^zRH62bq(P)J{%@ilc{HDO4O}4sy7yMG{B8?|T<i9Apl1yY~WA9Aqyj
z++gFbzmUX{-NPn`2v6j2<A#cZ+=Co$0!ZS>;U<bCj(iWe5>y=Io-m|(Ru?J`GXFSI
z`CtMS2dPKCm)sI64pNWo9y=s)WcLI^#X;s+A*JVZByr^QT#7@y0ZAO$oIWIR<a9C>
zNn9T(oh*ThgWQjtPBufuLGBDeDjyCYiG$)1mj2Hoi6g6jj3l0gWX^jeagaH%b`b;U
zP#Ea>OUUYlk;L7Q%#lYDM>a<nNgP?dGm`j3By;?c#6jlxK=XA1k~p&ZVkB_|By$>&
z#6jlxLe1$#5=U0Q7)jg!DPC4V#X<3cTu$zUii6?>WPS<M{1a&6#Zd7JP;pRxL~du^
zg^GjBF+#HU6;vGE-j7gmkb2~F^#e)V7|9%VVMzW3nS-3J_@Lq-a}1Hx3q!?0>XGx2
z1d=#%K2nB?gUpdc3V(m7ILN=q_Zp`{#X;sHx5sjk#G8=jn<gTOBljz3BZ(uIC%d5H
z=<d0UB)$sCorNNh@Byhu7H>upKZ&G%3l8zaNa8z@)N_j>%tsbiMiMVaDu3c|h!-P?
zzeB1odXU7C+b#2;;-K(HF8_~1#X;eZJm2>bhxjoui2Fh2Ag9}FP;pSWnINT~XHapF
z`BRa~?T=7#ka}|@^*^BEAoa-Oz+&PMdqLvJ^J|7sagaHnd<Uz)ERe*J!yy7m968)l
zki<bp*TC8vnNV?%y~ypf5~w)HUgUYM7N|H#J#zWb4HXBeN6x2{ki?PatrkMXLFORm
z)6GzEkU2I;=}JNZ5<VbtWdGJd#X;sMB8`KshKi%BKaC`gZ2om5ab)-3LlW0Ps;^%_
z#X<HWyZ=2@9Aq!DIp2`Pk<DR{g!l{H9CoNU$Q;m-La_Mafr^9FBgdB*R2-xpIlU=B
z#X;(k)0;6=9Hd?XDL-DuA^s3a9NAwlki<=q()m}YILKb)@L`sM_!nevF;c#c!XaLa
zBt8WxJ@iAxLFR8jDnGX(i6i$TQe+VJBAZi;B)%QVJ)KZ-kom~#F|1`F=AergLd8M;
zLN=!vN!%65{Pj?AkU7ZizltP|?0yXeh`k{5k<D>N5;s7K$4aO;$b4jTrXq>2K?=9O
zP;rp?$mR$uBJ7=tWPUIX@nj@%E2Q|!gNlR7Rpj!y1u71*7rA_!k0g$4&RQgK<o56;
zs5r>K$o2SkByr?={4i7;WN!#kyj*~aqr3AdR2-xp*`1$|#F5QmRzifEAW}FyQN}LL
ztb!1qfu!CJhj=iO_<bbx2}t4~clJQrW4TD;$m*Ms#A}h_cP^4Ra(R0YDh>+gt4Qjf
zAc?;~68`}ehlLx=J^zu!t&qwMZdFJ)fXq)os!s)>;^^kc;1CbQA)bIHUJVVOay5v(
zAoG#^J0D3LIegw}Ak>47Sc8?%pP}L)_am3j%$f-GOOVo=GLks5z3xzPkU7ZVoQoum
z9L{}Eagh6w!*d2y9Apl1crJp9gVZD2dlE?;*_~IB#6d^L!Tfs*Dh@Iq*}spW;vn<i
zA*IhBP;roY<aJhzT8Qugr&}%1?S2dl(K-lmWOIs<#8)AOXBUz<*c>Z}IrGrO=Rn0b
zp^2}7iXTH0-vbrDg(iLmD*g{i9N9g>x(N5HBZY$+k~qknQ=sOUqlqtpihH1mZ-I(O
zqKO}Yif5sTUxAAEBZ(usXEBoaK_qu>L=p$N^A6OUqe$Y&>MtXS&qs=vFG%7bb9$iW
z{6-V+hKjT5A;Jx$el}E`A5DBUR9q5Gd^c2F6;1p!R9qiT92Sp$XyUMRl87b_OD830
z;;?iw9Z4KH92O&q|3(Vubx7hM|2~1ba~BTrqe$Y&=3GV+M{cLxLK3$`DsP`d#X<QI
zxt;bIDh|rOVo2pVw>~0Xkjo8Ss5r<R<bGB-4skUDggMCNl`&KtWDatFsvAihxqmbr
zDvn-XuYrn#+z$#*SifmAk~p&a&m)N=`}a1IIOs@ASh@EADh_fda=G^$Dh_fFa{uuo
zR2<|U<o*<+AtW3?<{<Z{IH2Mn^~mwak0g%VpOS-$gUmsWM`Nfs$ea~O>CFv?crcQ<
z0#g1>KoSRq=NoAH%taDMR^N;yUXEnWW~ewQe2~Y<??J^u?nfTi{evWqJPs^xga|ie
z_3lt{kbjZw4Mq}24$mkgaciV}kqH$Cxd%Bsi=pBm^J9?m#Q~@|NIkN99zn&?)qh43
z4@HWXe^7CdIn7AzA6C#|-_Y?%<nWh95=S=25Gsytjx$so6#mjk@lpX52dTe>WN$N6
z9OQmmr10s7ii6Z6&r>Xhii6Z|MDo``s5nSHa{fIF6$iNoxnFP}Dh@IS<lhQtJM9~i
zII{UnCXn<1G6y-|@j%5v<{;-g1*ka4J;?b^9V!k|kDN~Qki?Pmoh?)xWDasV35JS;
z%$bRlPAZ_{Aoa-M&;k_)xgR+kW<te5=77QhR*tPg5=S<F8&n)*4stjgfQp06K@Nut
zP;roZki+3RR2-xpIUMdGi6e)@Tc|k59OQ6dHig6s$ee1V^d<`x2dPKypV~sj(bY#n
z#X;(k`{T(_agh3(NamM8#X;eKygsuVDh^U_hm@YDLd8MmBaf5pfQp0EBb$F2Njw!P
zo&UulE^LMfhaRN#(1$~OF_O4ClKRU~agaNa$CKI2A?Bm|R~jk~a=#Oje^sI4AajuY
z>j)JGsYkZA2}v9|J#-?8J0h7s6DkfeA2~fNfQp062Th&A>eDq)agciC^5i2_9HbuE
z-XBQfpevJM=5Sj;!U1Fsvc1AkagaHak;2miDvlm*;ZSjqdKV;rB|^nP<|Bt&EmR!c
zoJmk|kU6eM=InxsgUoq@RNit~LfnsTjxtmnWR5$MIh&y3Aajt@Lyi@8b6Bh);vjQ8
zkj&wPii6BS_E#xX9Nj(qHrUM(fr_J>Q-~z~8p*#EP;qqgd!gbWcX}eZa|u)&-TeJf
zagciC_&tpzj+}ljA&I*ong0kX4l*A({d|UsgUr`JDrY2Z5#fN`o_qim2bqH$FW>DT
z>e0o2*+axZ<|CV<;D8WEws$j<II{YqNaCO))nWPK6jU5!FLHbJGE^L7Zv~RS{z1jj
z<3-sK;T|ufaMOi~gUm-xKYmbgkon$7>O-O8=;}M5;vn_@Nb38c;^^vcAc-UABV{Lq
zJCXgRk0g$q9?X!$eUR*Rg^GjhMNSVsP;rnuk<AH468A+iCjlysZcaK>9NnBeB=G<w
zbE=`@=;ky*#nH{_L=s0%=QE+==;kbjii6ClMM@9*pyKH1;XYIxq&^VIoiCx{AoG#a
z1D7)*UV@O+3qr-w)$2pWLFNY|sW*d)qpM#D6$hzDcK=o+apd^ggCrh;Wd22{ILLhD
zcz+BP2brIP6h6!@5PzYEk0ewaq&^hMd}XLO$b97RS%4&tTyC7kA+F;Ju@_`M@;(b=
zByr?@4GvIokiE$M@<tLzZvQWYii6BY_U~FGab$b9Ac-UI6WIq9N4NJVR2*bJvN>mv
z#F6)j+=hyyoAU@Nj&9CNByr?@B0r(x=;koHA;NP9Qv6QCA-)(%Tn(umcnOF2V<hob
zB=y4X5PL!HL7w-QMG{Az_cw-$gZztZjx&;Y3Q{|#0V<Aeeh-p3viY-dh@XavgX~2%
z|1pwy8j`*I9teLSr)O~_apd(6hDhSb;b4s<j_l4zs5r<y$o3W^iAN*F<9et#dN}Na
zii7g+8Km~fQ6%vPNaD|+;^^kQg^GjBLGH(~dP2eh<jydpa)1X(9Mr#q&5y`I#X;sH
zkK3z5#X;tTBbj3f6-QU^fg~=9G(VmX6$hDv96r@Z;t@#ZPlbwu%twxw`AFi(@p2YP
zd<D`x<0T|<<oURpP;roZ?jp^zKR^<{ha~<1Dh_fFayiE11qo-6II=s1q2eI(7b4}m
zY$S2ycGOy^ILI92bp>0X;vjR7)n7sqM>hW+k~rup8(4enF;pC6K5~2PGgKU8{(7Wz
z%i#_27f2l0UMZ+JdU|Vuii6BY4u=Cc#P8t{|As@H&j;cjbn``_;^^+wgNlRHBc~H9
zs5rX%NF;IOa7aZG2VKPj3(qX5ILLhD@GORkgUmmO6rLxc;vn_N<<d8(I7odoQu>$i
zh4>dF9)l$A1{DXHgB;HBP;roY<nir7s5nSHa=z|`ii6Z6yYn29codSo_n_h+bCAbv
zo+F7P=daIDagh1Xk<!1nAH-jv^n*Me8wV8!nU6f~x&%oadHiY%R2*aua=CXBDh{$2
zRKCH+uf8COgN~em#p6$?ILKb)aR4cQh&w^z$mLigk~nhs_aliTr?;6n#E&D1Bm3(*
zR2<!3Z=mAn{`w6S2e}j3JsSfM?nf5ik0g%l&X-8y$nN<G6-RduUm(PMboa<Y#nIif
z8i)8hBynVW|3Ssk?G+BfZm$87IC6Tkfr^97K^~uUgNlRPk32pZ1{DXnA32@JLd8Mq
zk=yerNaD!jlf_VRkU7ZpMHN&W-90T(agh1Q?wJ7<M_0cHDvqxHFp@YYQoD#D7!qzE
z_aLVS9wc$(^dOBx+#4zmvKQI>WF+xdNcnvpR2<}f<ov!7Dh_fFa(+LJB#xZ#d_xfK
zN1pFX2t|k^`zs4c9NAwBk;IYJA3zdEHa|EFVLq}s=}6+p=5#>CLE(cO4%?B$k<-sU
zB=K0J^7b55927pt>E|j`9ArMSId_o6<B-gG0~JR%=QC6sWX>$4_!10<_!lIOT<<GG
z#X<3iT;7&K#X;sHhr?DRapdv#><EbYAagDurBB~Th&ad`<nV9BA+8z)QIGCUD<pBy
z6?U+4-X1CrG9S6VHjKt@P6CoRa`?QCg{TL)A2}R4<FJdbiN`LkkN^<}xd%DiCLxI<
zmxo)R;voMb*K50x#F69c6I2{zK63asB|+>(cmEuyILLhDe(_=?ape0$H$cTf<|C)i
zeNb_9bB-d3Bb##`DvoZ>HK;hqoyg_(1E@I2eB^TS15_Mj4syBu9V!k|kDOorA&DcG
z+q}t;@Bx{F>@Q`gILMq}r2JxuB#s>Z-cWIn`;pU0BUBt@4zl{?P;rpG$m!uQR2*IX
zGbC|j_k2PU2VJoUOaI@Y;vn;p(?4?x#J?c({~-BG7%C2OKl1(pWvDpF9AtOeL&ed}
z2}TmXfn<I=R2*b}6;gk#2PzIS-vO!rdlxE>uKqbx99{h{s5rX%|4?ys^`2>na6oov
zGLpC*Qh7B4hxm4=ILKb)bbAmg4ho+Xr1JSRR2<|U<Z-zRNaD!t>c>!VkU6?Y?h#8z
zxF1<u8A<#<Qur6)5N}2j4@K&~C}u#+2l)#*zSN-NAonB3S0hv$U41uH99{has5rX%
zrBHEn_4~81yXOd099{i<P@%~HId25n{Y#+Y=<3;Xu$wOk6-QUE1{Ftlzcy4HUHxIG
zIJ)|?P;qqi51``c>YqZz(bdQ2Biw%#DSs`8ii6S*a{TT<5>G=)pL?O=AoGin%sB!T
z2e}71ou7k>gUnAwGUo<V9Apl1I=_n~j-1Y)K*d4kq$8R05-JWd2iZLzpyD9)8A$5C
zLdDV5|AC5w)Famm%mt8e1BpLG8vhZ7ii6BSsTZK)AoVkm@>eZX927pt;lCOxj;{V3
zk~p$^t|EyeyXPrX9Nj&iq2eI(?;_=2^+JfhK<YtESiMjP;z08Say>N_DvoZ>VkB`(
zr1IwwR2<}A<aV875yW1QIP$uPS{&j%P;rpGSxE6X9Z5VBNqiwx9ON(LboC5L9ON{Z
ze@#G%28(}_q2eHWk^NPSB)%IdetVI`k?ZkAP;rodk^4JapyD8RBKLP5BZ(uQi<njd
z2{({>WcN>jii6yljT{b8agciCa99Bq2dPJP=MJbi$eqaX{sbxxG6%W+`41`%G6z&-
z!p2otOCjzAi6fh@i6o93Zl*}$psSl<@nQuP2ic3<K5>MKgWQQ+&Uiz`LG~iI1EZnh
zAaju0fk{wtkb30&m5C&d+zzaOii6BS&hO1oagaH3Na_C~4)Oa);>h+sLlVzHipOtI
zaddl`%Mjr_3&~zJs5mHmkn1%As5r<R<a*f+Dh_f#vN^#>;$M-{c|MZ371DWP9Z2HH
z<CEKv#3PZ^KSUDGNAj;?Il^BBNa8+7;)O`!E0DyCki>5wi6guJGm>})lE3&W5cVRc
z+ZH5oP&$Xrk4#1r?}e@pyZ{vkg)?${n7bOg`MOBr$nLR35=Txa4oKp~NdEPQii7M$
zPM={=aZvn%u0V(7uV|<^NIi1?N`{Jq)Xzn#FRGy8=;^8jDh@ISIbC%_#X;(&kjz;K
z6$hD*oPLfViI*Vx>lTuDDU$eas5r=c<aEwj0|{qz_vk~#LH3p*nd6EiUXCPQh9r(0
z4oyhn$nnyNB#xYaXF|n6?m>>1#ZYmOdm@nX@8VjB`_aWWBZ;p@O1CGF#F5=|9!Xpo
zsoioPDvs`+yLAYAk<I^%B;JH%uW>y>J+innlDI#T`ZqYlnHv!197a;_jYB*cNqi}i
zdiG|7ImqI|NaD|t(qSPE@n$6PXe9Hm;Shg}BwmPQ{@G51dyvI9cOk?Zkj(#yLtMBU
zq5dV3`jUy*#ha1Dm66g_#w3J#WbtMs@m?hNdrn8FM;32H5=TyN9Z2FTNa<}VR2)6M
zEryDN(s>J#z59^Fk;`G9nF#lQmSDrmv179l;;)eGm7IqVM>fY1NgUZ;UnFr=By)nG
z;vn~nBh6ojBZ(vTQ{tfFAb%l;Pb!kQCX)FjP;rp?$mK&dR2<!$CM0n!By%Q0#nH`~
z0Tl<CqlTn@E>s+(9@$@uki?PwwGt{0GDjWBoOMufbaOT%i6fh{3n~sWM;pnU{ZMgq
zbB-X1Bb##?Dh@Jd4^q400#qDi4syNr7%C1@{|G4`eLxZi)$eDlA^Y|IB8elb7oLwu
zSN=%pRt<-^F_O3~lD)o2;>hVU3x{|Ik~p$CQ;@{>B89_Ds5p8!EQX4M!hr?JJ;e(U
z{z4XSL=s0%&mBnOx=8Uj11b)(7dbsIhKhsiwL`M^Ad)z8I501UxCdko@_6;SB?$3L
zNaKNzq2eI(k<DRU3Q-RdN48fGDh_HtAonArq2eI*hDiQWf{KIOgWR7|M-oR)pL$Sn
zkU7ZVW{M<kfMmWCR2*bJa=3Xy#X;umLyBKNs5nSHayn0jii6bKBc;y+IK(d_iF+W`
z7vFG*vn)e|C$hh|k;ILV{3QVu2e}j3Un)>>Q20wCxzh+L4st)T`IboHDoE`#52!f0
z`N2?ekU7ZrJ6A48xF1=3Gm<#6y}OXak?)H<2^B}T_cBx*WUn|<I{$z}oEfw@3A(T9
z8IpPh9O8*c;>hmIKoUp3Ppt$hj_%HCs5r=-$mTR5i6h^qHW4b0ZjSLvM0g_4vxh^)
zLFx}8jT6>E#X<I(Bc+p8s5nSH^16#%P;roYWb-d0i7O(dA2rbA1T;L6#f_1~!;!*y
z7Y^}bNaD!ha~4Uw0?GY%pyD9+Bd7DnP;rp^A0oNa2DFI?>P}>FFC=kfdjpZgk?l=@
zilf_G3>632i@a~>5mX$c9=U(&1UifZ>K<f!J(0wb?>~xwii6BS_HP}MII{WEq2lQ7
zIk6Uzevs`wk0g$K|Ir<&IJ&)$q2eI(bCKfLX+4tpNaB9T;z;F5D3Z84Qv9Yu#nJ68
zhKhsi-GyX+D^wh$9yuJQK*iD3FGdpQM>1y*4)M!K;$BGQ_D3Az%%DSFpz*7Tq+S<?
zxHXbEa=bVpiTfgjPdHQ@<X`0UkPH<E`S%=>zY37VLG7+9_6tDAjWg6Di6g6@i6jnI
z4{fI{gNlRfeTY=fY=(-1>^+Z^?~WshBby_;5t2?o<{-yc08|{^oMa^NeMtT)LJ~(d
ze<6}Mvii+P;^|24Jc~p8F_QRuBzylNi6ggvq&GqQ1#&;wJ<xF0go=awdlji2WegRE
ztA~bj5>y<d{u+|{Cz}!GBiqZm1tE^?PC+E`{YdQ@F{n7meB}0wGE^Moo<B(8vkQm#
zF(h&1bqi;a#F5t<+=7aO>_twu524~9dy&m~fh3M>&L^lix;e~S5#jIyDZZp|h#Mn`
zPeID3W!n(uAm_(gBym5a{5SzBj_#fpP;rpIkj-b_jxawP$(`m<aZo!AdH&)CR2*bJ
z^8AI!4(#SAAc-TpUmZ#OJ(By)q2eI(k>kY?Dh_f#vN;||;{HhHL_o#S&54JKqnne4
zB#!K!VyHN}In7XUkU1Za!i{4mA{>y#|09VbyPs_rLVW;|`-P$6==Lf@#X<JgAf*$F
z-3W7##e<Q=uOj86xqA@mk;OM7iPs_d>l9QR<Q`B{0yYkF6^Hl(9OB9Q5cVRQUyLMv
z8p+<RP;rpG$o;{>0|;}F)%QTfLFz$6N-%fMLK2^fR9`Gd66ZrI-!>zOBm4I-R2&rk
z|B=Fz^$@~6$l}6C;+K)sYeL0A?nE}<1c$gi4)HyQ5%waRe;G-f4=Fs~LdDVT6$b?_
z1LWQxWcMiJ5ZA{c9u5@;g%7g5$w=ahk;0)0hxlY9@kL1LkKho$gd~ofziuLl2O{OK
z7f^9fI3SlZpP}L)_b)@Tck59|ID^!Kl)%!}hT{-%kb30$Vmp#J@;<mDP;rns$o5`B
z62Fd=4joP)%tv;Q50W^te}j?4k^2itP;qp7Goj+>?k_+RN8V3Y1r<j(rx7ZSZcYc1
zIP!kF=}>WWbLK(C(al+kB#ykFZYxwA-JHWvagaINk<$Nl9O6%r#F4}E4U#x=c>acp
zqua}T5)ofrNa;rpDh^VQ9KWte;>i8wDyTTf{mAA_MiM`cWd2SZ;+K)c1Ci>BpE$&Y
zPa)jziDZ5t4)J6p@e4@d+yWH``4@SgOAnGb^8UN2Na8n<+_@eq4hjck^A975-$t_c
z98?@+FS0ogpyD8Nkkx-i64yhr_a9Uo)c!$U7a@8Y5k5gk<%u<tIP$!95>y;y4roXK
zR&JC*#X;^w4xc(Capdr6M-oT&*FvZ`$Y03r-;5-F1Sx!u;Sj%!B>ovm{WBcmpOM7N
zk<>GSE{%iMBM*_nlOHM$awn)i!UDbLLK01!2P&?CL);W9jvj6vNaD!-xL~L_y1j`|
zaZtP<j|100#X;upL@I}yq2eHOK=V*@z`a%mhF+*Ry80<lagh1Q>1RGv9HjmmQafZ5
zR2*bJa(Etuii6Z6hv!`+ab*8KLJ~(Fm;MYD2bq5bDPR9b5(mW#H#Gd&&mz(}NSpyG
zE`cPDY>qLK_+cdT?U2Ml=D_0DA4wcpeJqkV@_x(|Byr^Zm?cngQ1~F%r_E4tkbi}c
z(&q#uagckYq5hhMCaw$>UxFsC4HaL9CT<KB-+?A>4HZ9zCN2XNKaVD^0u{f3Cawb&
ze~2b-0u_ISCT;^2|AQos91g<g5b?VbDSYIR#6jT$bEhf}aXmC~nETDq#9{7tKof_#
z-xEz7=KcgUahUmeXyP#QYtY1D=69iq!_2>lCJys2^La%0Acw;=9OCmXVpo3vP22(+
zFSn7zk;DHplK2;-e8g}G)qEGIIlM^X$m*4#;-GwS0jV4|L=u0BB<>6q2jv%6B=G<w
zaZotG?2SbdM^;~qBz^}eU46zO&U_i+uO&$8b&<r8$Cm=2;-GSMCDOcnJX9RyUuC3n
zdmU69<S&r>??A`F_9BUgAl2j7ki<diVdIleq2eI(k@wGjfQp06M|P*s73}_!LlQrL
zG!CW=6$hD*JPu|I6$hE`f|MToki?PgtwRzoLGssZs5r=c<n^VR*CFl%i6gJ`G=++T
z!Wp^#@`8$k+ye?9*!s^vBynW-6eEcvyT2Yu{2)>|v_Qo{?m-TRZm2lOJ;?R-RH!(}
zJ;>`nmqNus<{+>CTmuycsYh<-Z$=VFUjKOrDh@ISxqi6}6$hDf1}WV>!y*0|Nn8~v
ze=*#Egg?k%$l<I46$hD*tlkVN4ss9j_?sIJ@hBv5<ntkuq2eI(Taet-0Tl<CkG#)u
zAygb){bnR_0i<x)2NegIgPg9;Ld8MmAgh0jBz_dhoPSVpQ1~E^Lkix6gd50w<Z$pq
z5=ZuLG*ld94stjbLd8MuK~B%pki?PQvj8d%vKKjgHbKQf<{;nSv>hrAQjfgeW)G4$
zay#uXR2*au@;UP-pyKG}oJA5xHs=ad9ApmieNT^|;vjR7?|b?T6$h#JMoJGxw-DjH
z7O7lKMiNJk-(sjZdN_AL#X;sHhw}=kILJN7=InrqqnmRUDvoZ>FC=kf_jBKdxF4h*
zIll`biAN%plZsGrkb98xy9QJo-5h-+aebuuL_4TBx;d^;age`|%Q1hbILLhDax57t
zj;=lzDvqwc7Ag+17rESPfr^9FBZosbk~ng?Hw!8bG6y*v7DL5B=6E6H(|u5JkUNp{
z=|!kG$Q<N+$^}vc?I$AVQ*o#`$Q<N+stXkd*^8Whf{?_K-4ll-j+`Hpq2eI-Am_&n
zByr??l#3*eoZri!;vn}#A*G)ds5r=c<owkQ6$hzD&es#5;vn_N?wN`tj_jVzP;rns
z7D(ZL7D*hr{(S@$2Zbky2^)X-0^&f!A30v+??Unm$UVs7o=D=z@f8LY2bqr?UpY{5
zkUNp%s~Jfg*_}&}#F72A4k`|E4|4b)g^GjBM>gj&lK3H{cEt^-ILI92cEx?DILI92
zbn*l$4pNUCFE5eAk>lk9R2*aua{PXUildwJ3rQT=9L9T)@CTXm0V!RHLB&DlAh$nd
zq2eI*$mP5qR2-xpIUNQ=#X;&fA*G)Ls5nUdU8M5A2r7=Qz7Z;pu6{C99Hbt3ym~QI
z99{iZs5rX%!${(ONbTNhIK&?#iDx3Y{{vJUJ$>rkM}#x7dS@hYQ>5^Tfr^9Nk38Oz
z4HXBuA6b1flDGqsduAeuBd6O7P;qqg-{BBvdjN4ix_UVr;;K+_kUNp>bwUzHcBdbb
z_+g}c6buyy*^8WylA+=t^OqyVS0z*&q#ilkI-ug{>K7x4w;_ewMW{HsIk%C-k;{jF
zP;rp?$mR%x7K=dF!*n2-?+6t~H{Tmc9NGLls5r=cWOJI4#0`+r&mtso<nZ4N6$jai
ze9p-gByr?$`w0~XrDsqP4lB=j9wE{La=Gn>B#vBeheE|c?nib{J(4)G`@50Ek=qZG
zki?^r%BzJ?age`|+Yc+C;vjpG%~_8m9*bnoKBzdlIY*)5=;oY35|2SL=Lu9C-JI7@
zagaI4<^Kn$I7mHm`TrG39J$>70~H6Ea|9{BFg`}a3vzxDhKhsKyCdZnO(b#TcyWP>
zgWQ9h9>SpFAajt_S0RZbo8N{ceiX@_-B59m`N-~^h$N1jeilQ;LG}h9<)a%=agaI4
z>YpKrBj=+JP;rnsaY*sS^#l=a$m_0^pyD9)$o3i|iKimDCkRO#IecQE;vjb--*=FL
zBo12I1Iu3}P;rpGp!N*xp6+@a;w?~dkom~-JKa!mm^snValEN$;yF<9g=pe2Q1R7h
z;>A#LrKgZ^1DTJUzci7=i;%+E0xAx2CvrY@f{KI80r?kZZyZz{q#n7ymIW0Dl}pI&
zz<Q`S%pBNwQ5%vta=ffW5=V~5n@Hlvkkaivs5r<y$m#YeR2<|U<bKwBs5r<y$o;JU
zP;rns$o(d^XV}A&7fBqs-y{PS2bqH$o*GbbkiE$9qK_mVj}$L<P;qo~{Gj6K=7b`N
ze?l@R1uBkiPBv5=-JBvM@y|%+G(yGE&6x}p2bp7tl<(Hz5I>A0{u-%%w0e#RXJl~?
zByr?$^G6a#PS0^raddYUL&ZVvbV0JW7fBpB9ZrXegUmrLALb*8BbN{Bq2eI(LHPw%
zKJ3CFz8@+MG9S5oI0hAmnFA{yE})6S%7;5>;;?-B3{4zXK72<Ke}<Hgm|sA`ALJh7
zb@;qcagciwk<x<*R2-xpIlpK?#X;(mkktD@#X;(k%kyZcI7mHm{3aoZBgbzcR2*au
za{j7-ii6BaMzXgaDh^VQ?9Pcu;>hLLLZ~>X+(0hJHbcch=7ZuFb}!5!G;vt?--C*S
z>_s;J6;vGE{QppKnE9}BlI<lVUO?i==~Ep^963E3BZ(hJieC$;ILJN7<)l4S9ONG4
za?%qj4zd@yoJ@p@qpQz`ileKqhKhsiMGpTas5nSHa=dpUi6fV*Goa!ibCBbGF;pC6
z&I_b=)CQ<H$eqaNkZ`_2geS6kWhC(`By((WhzBEye?(GWibK2^N!$~u{8@%1jvT*R
zq2eI_B9}9Fki?PC$76d9@fS!vvbe_^h&U*Gki*#@NgO$U#X-eE<{*c2Ba%3BdY%Xs
z2Zb|oepv<;2iXhCFR=8y2~8Z9U(P|rLG~h>e-A2-ZvJPeIJ)`2ki?P0Q|>Jy9FW7`
z8cF;FQhsrOii6yPoL}6b;vn}R=a)dJILJN7`6U%9j;=l*Dvqwc9x4v97dgMQLB&Dp
zk>jx!NgO%9%z=u7%t4OF#ZYmOIW<V>b}tU`%ShrAk<`D(A<p~`5zaG^)Jx+KH%1cQ
zhNRvfNj#64fdO=PHE79A43c;%QaPWAB#vxOGm^L&Qu|~kR2&pO$o;7mP;pTBAge!&
zB>oR6|K7$S{uxR9Cz8L|-Xp>XSzHh*4sy>8BzG!9#X;`bhGef94smBB@lqsnB5;To
zBZ;>oxw8*R962A&g^GjRc@4?@%}C;pk;L~w#X;^zHs=<SII_LZpyKHH<sDQUWG{06
z@jFx;Wd0YV^uYK563!s?$oYs3NgTQV&I=Vsw^tM@4l)PXUOA{Z$lk9=_G&=ILF$q1
z)kP9Vw$}tI4l?H?Qu$*E6$hDvT>dyi#X;(Ikm4%@NgO$xGoa!ibCBb!6)Fxg2U-1G
zBynW(*C2@_mp_}4#J?eh!+xkZ$X?{~=NMERWbY{?|DJ}5gVZDY_cBx*r2Z39`hSij
zj_iJpkBE3j_OA+59Apl%dK)BhWb?g|#F70Qgd~pa-#Dl^$o<IvO@)es>_s*w2T42)
zDcq`|;^^iyLB&DloJI<_cBnW=J#x5BhKhsKe?UqnOOV8o!(j(h9Apl1xLt*cgUmrz
z{}xFc+5A69;>iAG{sf5^kU7ZV#t#(-*^3-*Vo-6A`ZGxWm4=Fg)Fb;>87dA^?}g-F
zGbC|j_s2uULFOR)w*V>*G6z|G7m_%#`7@Ekk^Q>>NgUa~YoOvFdy)OS87dC47ulR$
zNaE>8>Et9-9NnA?P;rnsXOY6~DpVY#9y#0|L&ZVr|00Fk4;<pcpAqp`hLj(*ki?P0
z%?2tCDp!%mtNo$kAon1TSLY&$-$$xPs-fZ_cOsj=07)F#JqMxUAoG#y_tQw?$mRJ}
z9O8eF#F5S6`2q<Cbn}Iw;^^*FMG`-U6fas(agaI4@nQ%S2bqJM9xRZ=Gmz4QD^wh0
z4syEkfr_J>6O1IDiDXU^R2<!$VyHOC92KN=(t#w794}L$;vjR7`!7qO;vjQC{Q}rH
z$p#$aTcP40bCAbL_CUp9=A=N!KTn{E!}=FDpyD8Nkoy-;pyHtPiQIqr2^EK#59`0M
zeucz4OdK{2BY-9jvsVmF95xOkha`?1ZdOR*$l>gUBz_(#{dhygLH<HcKS5A&kiU@o
zDKSuSko%GQDLGJakU7ZhmSU(lNIh~otU?k;?ss%T#X;sEr^AUz;@L>+h&CdLBhMGy
z#33#WS~L%xzq3V3hviUlkiE$9+YA*4g#&W@&VY)8`~^yfu=rhxB#vzURwQxcaM*(+
zo`sZ;PC~^&?m-TR3s7;8y~yTVM-tCQGUo|Y9NnDPP;rpIkmL6&R2*bJa{RJ>hooDO
zImq$L0~H6UM|O`ek~nhwDnZ3T<{<ma5J~(2Qn~F66$hEW5GlUOpyD8NkjvHCIK)@u
z5Z{SI{5%fvM>xbk;1Fm3fe1HbcS_?B*TNxgf+UVy-^C({Bb#4@Brb%MUuuxVK~W8x
zpK3=EN3Pc<K*d4fpM#XHrbER+;g6giRw0QayJs&B@k=<wKS0Gn_9DkS$4~6xDGU_{
zsaHixC%RB^kUNpxV*?dOS09Wd?t|1m$%Bfcn^OxF2bqJceln7{Dv~)Xki?P8?PE}J
zbn|aO#X;sHtN)55j%@yas5r<R<ap%x1qnA$en&n(Sp+H$GCvO~e&wLzAaju8R~0G_
zQjhE&V<hnlNcD>aR2*aua{b~26-PHG7)jg)DIW8o;vjR7<FO7Z4l)N>{bVF@W90Bh
z5=VCbVW>E|`B$LgAoG#cKZ1&b)FX%UYp6JSIRAx;gUmq=XO`cPcmbJ%9M0TOagcgs
zdo_^6k^N<YBz_So{4Js4AoG#K-x(?nGXDuu_{884FGdn~LQ>y>B#!LPB~WpYy;qUS
z^HWITFObBaBZ(uIZ)|@c;RAAKAyWF}g^GjBN1ksgKoUnbzY8i3G6&h6%aFv8{k0WI
z9JyZGgCw4h<ermIagckE>$M9|age>p=3GY-FF-Qq8B`qIoDWcObaTEVi6gs*<u4@M
z(9Pk7ii6C#gp^JMpyD9)$mv88NgO#mjiKTob8aBz({dc*%}C<6k<@elgSZo94zjp1
zlDIdL`g9!P#Yo~oNa}y%5EuTBuoropDh(<Q3J2tU`i)59pd+bZ_2z4+ILQ6T=6pvI
zM~?S@NaDpv@y^QtvJrBA0&@CMhKhsCzlfCYETG~bUC8sx4oKq2{U(2?ILI7OdllAi
ziozit4;2TQkKAucgNnn<fz2-$pozo!HPvY1uzpP|nmDXqGXW|NvKQI?tDxc_dy&K8
zFp~H$q<FuMB#!LgM>xcvL&ZV%BK!9pR2*b4$Q+n|f1ruO{L9P;GJ$~srXJ>BUNmu-
ze-)9$k=<{MByNu6FJBzu$w=a_kkpqWiG$n^bI&BGILNig{hfJGaZvq*+~3&@6^Ho?
z*55gTB#vzF1*ka49OVAREvPui9OVARE2ucgJ;?RoN2oYRJ#s$!fh3OHzhGwqnShy(
zgrVXfbA*xdks*>ea=nlV6$hDyJRdq0hj=p!NF~Hx&{1Kq@?klWIC6P1g$<z|S$q?c
zIC44T&W=!j1*tus3>63Y3psqUki?PaXDgxNAk&b`nHfmp$mwATR2&qK$mwAxR2*b4
zC|$wQ!vQ35<nVlfB#s>ZUy#HvBh^Pgq2eHSBG*R@93T<M{X59%iVG?Zau0I4l7fnZ
zbRnlJMW{GPJ#x5dAc;pHmCxo-agaI4;pPk#2bqI>E@(Vd9Hbt(y_yFVM_1pBB(98<
zKG#9T(aqU`B#zwvyb2WunU8GFV<hn@NaX`FC&*+-x<z)U5L6sw4zhY>B=Kq_ce+8v
zL8c*_6ABdvnS-o88A+T2$((wqIJ!A~P;rns$m$m(i9bN{*I}qQx;dAi;vjR7)jviO
zpN7;f{SOsKH-`^YNkGSukku<AiElx2k1JFh-JB4pILJN7>XVVgry_+<36eN+{+bIF
zM>l^BR2*bJvic)P;>hM-KoY-#lpn7`#X;sH=f_t_;>hv-87dC4HyO$O{M;ZDFw>hH
zR2*HsF_QQMr0`tI12G4r9$9=dlDHC*dL~|odJu{1PDQ9V$Q)$#x=7;4<%0>5IP&?T
zj!<!s`7@Bt<p_p~gUnAy3Wsteab)xBki?PCP3?t>qnp10NgUZ<2chEV_FhI3mqkkF
z@1f!#^O4Q@2NegIgREW{bl4d*{ktRiOBE`PZjK359Apl%dKV;d<Z$pt60bxmhohk4
zAoG#KIT<PrGG7-d-fN)ZAoa-p>V}G=t6z*Ho`q!29;i6FIj5oGAajt_KSmPgLked`
zevk>6>0baU4l)N>y)u%x98x&jLd8L*A^Xb*Dh@ISS$#5+_$4HBT5*U^MiPIDq<$+7
z@xw^s$oc&Nk~nhtBPalJIV2pA+gFx2#J@wuLH?>jN)J4O2y>A4wJ9KpBZrRxR2*bZ
zHIg}2P;roH$n6A2s5nSHviswa#F71*jU;{*sr)Q}ii6BYE<c;0;vn;rk<!~fs5nSH
zvimQ926LhNE|JBbihxu?!t*v#`*4LQLL51q3&jxPpd&e9?bZEIagcjzk;3OBR2-xW
zIeeZ&#X;(k-TxU$9Qj<kUr6G}=fbgwgG`3FA30xhL&ZVnBby_HB#wM8oFY^lWE!$L
z8c=a`bM%qKk<W#*hl-<{;|3K+H^&!AoF6IPqoCsG<|IPJLFOQrdl^XLHAvxK0To9#
zrx_{^GN%P8pDscYM^3jJk;Lne%s&Pd2bqtYkM1CeYapd7O9_xlNIw@jUL26bk;B0k
zDh|?x953Neagh6w-C2huj_j|AP;rns$mv;L5+nj~53)IiNaEL!;>8Rq4$_63AGM`G
zBADhlA&DdV*Aqz`IXwqM#X+Va`!@<I4)QOuIf+Q($mzKNDvoYWIaD0ooH`_N<n-JJ
z6-PH`F;pC6PA5|OISLgAsYfnn9wCV%_Y>bi#nJnT%+eqeAmNGJPZU8CN48f1Dh@IS
zxqqhx6$iN!xqoK`6$jaZTrN36#X;(k^OpybICB3k94Zbn2RXiyq2eHON|4Iu1{~s(
zk;ILV>irEk#1A8hXCbM7j3kbnp4nwUE`*em$m8m|NaD!jw0=-=ko&EW&X<UQii1o;
z&hJT3agcgsdpnWDk=;2JN&Gre{+b092bqtYzZOHqLFVfrg{QwPNF^klAd4p>i8CRk
z&%aP{P&z?g7vv=eF$Y8<&m*Mb5Z?tA2e}8?{9{Ps$oo1^L&ZVnBk$|HfFzE*KJz+M
z9ArLnI=qJ@UXN4`zlDl}%tua#%<>=+Nce~%r4w}|anL$v&>SsjowFrW927pt<2GSX
zagckE%}GWQk3x!<3LN5-k;L<m+_Maa_+}(=MWlGVfkXT=lK5vN_sA$9!U0*_7)jh4
z$$U2);=xGbu}JDWaELEP67NRx?=~Fbhmpj&kkntpA^sRi+!0CrHyq+DiimJPPFLJW
z;tfdYN(w3t(uJI^l%e9F^uU8;ZyZz{r2Yz$cs`Oi^0-qqR2*bZBa*#6P;rns$o0rZ
z9OAo?#F5Rvf+UV?&U>gh$X;akGb({>gp`v{klZf}6$h!0KuT9eNaD!lUJ6tkWE%21
z&q5?|<oTCMByr^Vi>pv^kiE$9bq7ftd7Sn&R2*b4a(sP25=TDI^EZ<CBP9RIfDW^R
z_S2F5Re&T8s+VE&0yCiEAbXMP_Z3ia^z!5&R2<|lkU6k%;1fvV$o4)!5(lY=%|pG$
zA^rg>4ss7@ND0<Y`3@C_*$bPOVN?OBgp`vY^I`KcylCPu|B9oD!{%k|(ZpfueUQYF
z{gs0xj-0M4ki?PWy&g%t87aT?LB&D7K#upRP;rodk<FQdB;JB#&T6PQx;dMm;vjQw
zAl28~q2eI*$o2I;s5nSHvb{%<#M_YUy#f^nnS<>9dr)z7bDkoJw<4MI2`Y|m&L5~a
zx;f0MAeE4KZ$~mm04ffWMRt!kR2-C^k=vPyP;rp?$n8u+s5r<R<aVY7R2-xpIehGq
z#F5*Xeo%3cImqrwhKhsCiAT!6WjMr}k;Eq;)nA)%h#y807e_MxE|NHMdKOUwxe!u*
zBF|^JAc<c_>JKI&iC;uAKLaWb@)xrCZAjwC?wN!neiJEuPKSzvT!oxI7emEC=CdK$
zdmKp|+1~e1agaI4{YPogp_b5b6=ZRKP^T9v4w|}$l|K?tage>Ba;8TMa{r@)Cdgz+
zIz(=7`#{A(vQv@5EgmWkG6%Uon1&>dd|yl{R2*aua{4LP28m$C*HR>L<ax$xx(M~i
z;$M)&k>?*X^bqQi=O5dV#F6WZ$xv}n{z7hlu7HYz{0j;<Sbeb`NgO%8ZX$^z$L~`l
z@momg<P}sL<XYr(@)0Tyau0HT{|yxfxd%DFbL)dlfP^P<eiwp@gVZDEcS$61<ovDy
z6$hDy9ACyzagaIBklG=>NaD!h&;k_)nS-1kw;+il=f{0W;>hijV@Tr2?UQRzagcjJ
z@dB%tAL0;y1{DXn2f1E;3l)c%1FM(6qlv@nWo84A36T5(vKLm*@}h~u>SZOUI7n9$
zQa;j!io@)Mnd1o+2dPI+pP^83P<lX4pIK0Gm^rZYS%@T#954My;>hth8%g{&Qu<r~
z6$iNoIejjNii6yPoIW=~#X;^tPM-&%;vjR7)8`4OI7mHm`aF*$j+{R4LB&DlAg9mI
zP;rns3`pfFzadB^B)*WtK@KVoazAo->OsXp=5!#{%jQsVkZH*0RwW~eBe(NQk;IYv
z1wBaO$m%CU#X<HWyK_BM9AxixB!3-+ileLlgd~m}4xC0H6CmXSvc0WPaZorQk4wye
zildvq7D@aLQaafL6$jaZoKE&Y#nH__2NegYM;`aM4;4qZm)RJk5)zLGkjftsByr?$
z^M#6obRmx~#X!Z;%`ZU`M>fA1NgO$Sb|Hy(BBhh*P;rpG$mw$)R2*dQU8HbZ3>62d
zM-I2mP;rp@1f+OBf+UXY-}_K;kU7Zl`vocvG6z{bj|oU6Bs`JLmp~G~hvZIKs5nR$
zvO7(n;vn<8kix+lDh^VQeEx|8k~s3XQ!rE<WKJ_u`!EGb9NGOXIK<~5i6fh{0!jQn
zlE2nM#X;^w_Sa#kILJMDNa^hwk~p$^enQ1T<{*!A@|%K0Ao&hi+#E?9IekXq5U;}_
zz5s{#8mKtP{mAY-h9r*cuS-bcKak?_CR7~c3*>mbha`?1k58fEAbWoznezrJj&9CJ
zBynVOen7=R=KMl3=RZ^&-5eG(kO(B4k<H<Tii6DggJg~nR2-xW*<a#F;>hO6LB&Dl
zJU~i6%208TImqe97%C1@zZWU}xFCrm$4d$h@fsv?WOF)@#2+HLrxz-Y?w%!3agckE
z%dyo+;>hb3c0t8K<{+12hoRyib1IR_r58xz$o}Fo2blmVXPzL1KR;9)B#S&QErKMD
z9R56(Ae9hvkj*zn5=VBAJ(BnfBzs+;;vmzI?e#<wN47TrDh~4RV<dAzq2lP~L?MYI
zo0A9?2buE>$(%H(IJ!C6NaD!m6hXy7<~&A<_j0H>$Q<N!SO*mcseg)OZ!=UJq#ijO
zI*`PX?d^w(gUoq}WX=?*IJ!AAk;IYBSqv2inX??JoZp8ejvT+gpyD9&k?S>1E073e
zT_tk+O#&(oGXD*dJLQqYLGAV)DM<g<04feL4S8NE5h@Nc=N*zcSx|9w^;40=6_M`g
zIEX|1BUBt@{%a)j|3k$=<|FSD;j;#bK*~4da8QMcgUmtpuMUzpvVX0i;vmzI{hJOI
z2bqKH-vX#Oy7~o3;>i9z4;2TQgY2(|P;rns$o~3{B#vy3ybVYtBz}?a5i@~`gJhBW
zaW+We$oGgPAc-S~TNaWya{HXi7GyG{oB@T~8R)&h+E8(jEONih94ZcK-y)|&AE-De
z96;v4`engL;>hW|6iFO8Uo;|#BbVD9NaChQ^Q4oY;vjb-m)kR;;vo0DMM`h;pyD9)
z$mPIdByr^Yy9z1}GUo|W`LiA>4l)P1{MiN-2ZaxEKk)!m9Apl1Kk))o9Apl1Kk+(L
z9HbsO9PS~BBli>ELd8MmAcq5F7Y!tS7a-NklR%S@&~dX0r2M-XDh{$2S^WX1ILLf&
zB=yMVUq&k5rb5+&%t01k1Qo|;jv<mcrAX?L?=9^{5=R~%Gh&2Dfb7i$t@E^p@U76q
ze?!Hc(8OWmhoR`=Q1zfSr63bw=EKZ6grpwX{m9`Hjnsa~2N?jJ_dyn)3<?-%yda0O
zFE_|mNO`D(Bm6^=%m<y32+{$v23h<sJ4h72Ig^mmNeM(bc)twt_-8eeIPyB84yZWD
z8_4N!8j|>Vq;Vn8otq#jkUNp>1<jSf#F6doMha)-^*l46;^_9yhl+#DM>b~}k~s2u
zo~=-EbaVDV#nH_<j3kb{p64=D9Niq`^bm^_U#?IIP`QCTE)fnD2bqIBZqNV~2e}8?
z9H=ljzJ!p>*8~M7G`(3Nm1C+P1EAu_>Y>WP=4df9FeJ`|m<)0UNDib8B<?p4BF+I4
zgqi~q4}yyGpoxb;#RbsBqoCp<XyS2DaS1f>B&fIyns^#i9Mal>lzSleWI@GM(A4Ka
z#Wm2xi=g5<XyONELHuigCO!u$Zh|IW2Q|k6O}q&zZi6P?1{HTe6YqkGyP%2pLB&1L
z#3w<;ebB_GLB#{m#AiXpL(s(MLB%7`#1}!uW6;ExLB$i$#QmV*lY%C`4yrx_O?(qn
zJO@pD3e=neH1S<f^~mKFDBiC^(`^Ns`a@9lHE80;pyCZ^;t!$bKw=+~uD&9blj%t6
zk;|DpByr?&5>|eK@)L47*$Gt-62FL4POgTQC!l<XZ0~j?ab$b<A&DcGlP93!AoG#!
zJr5NJnU8GFH6(H5auU?H0y!1k98jAaB#v$l=&Wg&IC4433{nWK?~vVt9L^$0?SX?(
z_kiq0Zr^T$ngc374<d!zZm2j&eK(Rg^cV(k`6h-`9zwT`g2ly=#G%XE!P3a?gf71Y
zt4B5mx=ai#E`ekYbh;129O!TwSUs{i(Cz|QToTC~FOY|@gxgA}ILO<`;f5TZZAjrs
zi*$PxDV(*T@da`Zvc2X=;>hXE4oMt2-FiU9LEb|Se}AYr$b4jTKzHT9(i?KR1)V7h
z5=S=&wk{9d9MB$ckb00fa=Hbr2?2?tn}ZzArAXxia=C=;PFOhrG9S5oAf_FKJfHXj
zWB|1OMYfj(>L8Fbvc23$;>h7F0ToC0mpoJ)-5fO}apZ6|g^Ht_V*?dOH^&)C966kW
zq2lP~K!w5iA`U4%i-95q8V<<f$m%<g;ssefvN*E(D5Q22vU+53Wc4p`xCdDrS^X9q
z>XF5f)yLs*53)G2`rSDEi!6?;-T}!ye0-1q1;rP#II?<qB==ZCl!MDR<bGu~R2*au
zXnf!bbesXXe+Rny2G;+A^%Ftrk<CZ8cP)}Tk=uL7;>hYXk-`Di9s|`E$o+IDBzJB?
z8aMEVii6T2azA|+l6V$UxrbbyAlusnEw4c4{6kVd4=N7wFY<ck#ZYmOdgSqn6-eU9
z;}z?n;vjRjA-NyK200ZZ4r(*N!ucpvJ;;3Ia`g;U9Hbtk7p5N8uK|hgKr$aR#tSkZ
z-5k)^3rHNKehZR%&{@7PaZsNNW<Co@A(na#IUbvk;t|%KM2|=0b{DA412exCWGU2q
z<amU&yFljbMT(axNa~UA$5exc56HjB<8sHL;vjDzyAwIwjv<A^EhP2G_e+AtoIzHD
z%twwF(4BE0agh1Q>EtWa9FThCbOM@70;vayBc~HakO9zg64^Z*Na81v+zDz6!OTH+
zj~tSEWOI=Fm8X!*F@dTFxd+)CYp6JgLN><<Bmi~iX(V$3q2lP~L_ozs6tX$-AOWa3
zptKE34>?eAbaRTK;vfpyoGOq2)SR<O?rDLFqnpzW6$eqs_3tE*0Mwk_Naierildve
z0xAxoklnK$BmgxB)P{%oYd=&R-5lh6^aiQ?v;{>jG+)d^O8;I+=KMhtPlAerC}eYx
z>v80A!wYILNc~PE|3*T^@wsyrQvKqN<WA&#SBxaS5Xqg#q2eHWk<Gb|Bn}$GfrZ;W
zB=I9i?tBXs$LCH3BzNjT)r0Is9{09`ii6CVkK|6+cq2$0xnAf5832tJWbu8_a05vr
zn-9Hy2iz_~cFz|a>RCY+LetM9r2YjcY(Y*1Nh6PML$|$x%}0)3=(azwIC8xJU4{v6
z4<P4v=yEf#deGP!Ec~I<s$g;Cbm9tf2s9j!&4GFgtUd{;UQh-(o&hqSG7Tx5L30Nn
zDUfk5k;JEi1fk}G{0?)^3aB_JoI!n0nD`c`ILI92`JLBLagcgs_xwQ;NA@o>wA==%
z-;0#qgrMRe^O5~42^9yaM>a<RNgOm54Rfb4R2<zL<ni$RNcK8H)q~7GfF$k<6-PG*
zIs8MA(tkUWf04yOd#ONDAanjAg?~TPe2~4!>1rC1IC8sXDO4O}4s!Ucfr_J>vl&So
zIemi4QkZ*?%`u013}pTSBzGeBN09SlIaEEU{eaw_Y=nw~+yiQB!Q!O@Dh@IqxgFAr
zB#vBPPl1Yq%s~#H*+}BZ{sPUFVDlGLIXIj*Bjpz_kYX(9A9+3qS^a*fdXRgN)8R2B
zape4a6)Fz$FLF2|yXQNSdy0_MXCj4v8<IF^>KGQD8<507Q=KqzP@V!wf$T*VPX;+0
z>fa0`^S44B1X7PIei<qb(uV9#=yf#U@(sCugdUHCAubFu7+T&Uw}+wIbHVX)2`S$}
zmy?6d!4+;nNcpZ8<XNcs$l_;^#6f8u7Cx7e#Lpqw`v@uyaxSvHFQMX~a6oQ<zJrQ`
z)FZb)KO>1Fr{`Z#agaI4>4y<1pCX5Y08|`gKC*kD(E<*)i%99m6>2_6J#u+|8%Z2_
zUK>_!gYqx(yfy>WUXVLM{Z`n#wm6bFvc1Yk;>h8wg(Qv~&X!PdkUNq6<p322*^6wB
zJCZo4PXUWZ(3~>JYv|^H?%V{4qniU82Lp*;L5g?K8I>UQ=;naVx&euU!Uws01MOi1
ziG$1mxdG;$2~c-}%t0>SrbER+>XGNQk^8^M^V(~n>OtlphYxbRTO+k&Ve>B_^~muK
zYhQuvMOF{G^A6^I<ZuR^y$=(=iWEMeJ%Au_kom~&0j(tiiG$2XHU~L;Kx65!@BytI
z1*u0jXCl<U=;pxYH$mdpk=#Q}J&5cc<a+Q1k~yF@12*>{hx1&da0cCh4pI+F56JVC
zuz4tuzmVrEk;i{-BiV~Q{)60(5(0S?T0SG^QzfW4$X?`pY7P|#QONlexj%^P{uGcx
zXgP`8FUv*}zlr2dSicYCFXVV{L{g7zP6v`WsE-ee_o+~EbaUoF#X%Huxr*E$L@rmC
zffPc+2f18b3l#^24{|=;4iyJc$oUj>hae~(LGD4$r=UA5K;j_v$oUj>W)4goIiG^o
z#(=~@<{*a;a{76Jlzx!sA0HuwGi*K)WDatA$Ojn?_3wV9`WiM*2U1@HTJP~60%jqp
zM@~P>pyHtLK~6tApyD9^g3=G{{>Mv5;>hm*2o*=S_XkuQWIl5EGa=<`<nR}Rii6BS
z4u4swILJN7;je-ujvW5D+WE-guY%N0kb=4sWIpmfICZEv$UVsG<&eikk<CFiKNG3`
zCAEBj#V^P`$mK&Nl6#QT19HCrIp57i3LoVBi#&gdtR6JR3$g-aFLFKw^@%{@pm0D=
z&!DmtBo0!KoKHbxQy_7WdgOe10qP!*IC4G(*#%RNY`z-EU}!o=PPax-aZtKKPPgt*
zaS#Pcx3Km}21o!}z9Gj;2~-?p4s!aegNlPF<n-AG5`ek~Ieo&)F_1KJ`a~|rkkcn}
zI*CUr2Vm<8K;eTtpIZnD9H{$|)gznpg@W`38!rO6A341tj}IfKH{|s~$ms{xJ^`77
zoZdiVdLS==#F5p*>RFIDC=I~s1<=?XNIfVVkkbRG%>WVysYgz4AUA`=LF$py+XEcw
z?G=(ZviW8pgQ4+@oZevLuAp>+oZiBr>OmB8daD2lK;sKJUSQ**Aajt@8!TOcv>~Ur
zc_0C(dyv!HQm8nHLQZdMKmt&Eaiurpdl-#Dfd(}nxqTQ56$iN!`Thl1KNMumf24Y<
z1*#qt{>b|&kjIgb(+~1^II?>zKn6qI{}0K0PpCM$`F=>^$mI!gzUV{BU$FI2AafLu
z)(vVw-48YnY242oDh^VQ>@RPqI7mIR`N;N~BIQR}B=w**9<X$dy#9(E$zIUh2S^LZ
zeB}BFwmu5v9_0Ec9HbZ;Zpii`yQdy09AM*tAoD?E&M^1D<^e(C$nKngWIkw43a0)V
zk~kBR`;q&Dpt%*8dgS#9tVrr%^MD|Gk;4Hrwga*PB#!KUkQfMq#3Ps)7+~wqK;eQc
zz7d+wk=Nsa)Pv^OK<bd!<AKCMV>BRf<n?$UaoD&C@_IawIA{zMq#k)a9!MNCwgnQ0
zr8k&6L32nTapd_~kb2m70djf(iC=`eA9+0<NF3A$1DS)o9uFiADsw^Nu<(G{dlzaB
ztUm}7e+U&vj(3nbuyz0}y}{JO=HZan<AKz}<~5Pm<AKCKLd}QugJ9;s=I4;t<AKyq
zhN?$Sx08|b(NB=)py?bmHwQ~suyF}c{3GX6<aCH^4zl@SNaiEQ7bjBsgsm3^nU9?B
zko}8n4zl@nNao8UxgS{^S-luiyA-+HKrRPh<rTVnVB<WXa7H!<+5A={^GR)&j<ypZ
z{V7_s6OiL&FtiigDM%-y{TE0&p+)}%IbH@s|K$o&yJDc)lcJyk4_YrEyGH{_9JxJd
z2^9yGpUCxv9g;Y%_GCCxzA%E8=OA;C+t09Z8}#-waz75a{oIUX4zhcY_lY34pHD#5
zgPa?MR8O5p5|2g_=LRW+h7Yp)k=LsrhmSr~J;-0k?m=F!f-8J<kiv)5`en4-pk29v
z94~{R+{i|17s(-|Tjcc{uy!mc9U}MFJaMQ;-XDQ%K5YFkC|L_4<%=~)<_I8(A4L)e
zjlIL#nXvIskb98x#Z4sj$nJ;Dqk-&wie&x=sCtk&$m>a1pzU9fdSr8u+i%@S<t-)c
zRb+FJ&38mHA9-F<7|H#xc}bA_k;6d($^FRYAe(;<Dc+IWw<1X96Vtv$HV4`K??~>a
zb@>D9Z-K%AdAtbLPXd+y$m2zzG8Po|p!h`|FOmldK+9)j_iH1GBafTG#y>&QAUD9$
zrz1!JI-Y|(uH^w02T{o8_=5zX_9BnJ#X!YD{z5hfwoU*fjXeGa8(#&fM;?F61u2BO
z2f4l&sPbnul6#Q-g`9r;km|2wP-H>fk6gba?^BRMO1BG<)Fao|$nzb@<|EsiNXK+L
zI$r>(XNj3FK#rGzO1H@A<mPBP0k8i-E@uYAyb^M}3{*OSja!1M;T&cL1{UZ-HrV(i
zOk5Z$&H)|BgNZMJ4sZ$}i5oLBFu>YR5@_PE^;HUJ;;{8q8ffCM_LBjcIIR6-fhPU{
zTAn(fiNo4Y9!TOK|DF(nXb3<PzYP^nKoW;uwF=gN9BwJBU?DJp9Byey;;`{sP`D){
ziNnTeLE;%m;;?osNIV@$95(I>5>G`EhdL8HteJ!)4x1kYss9YBY{9N%V1Vr}28n+~
z5{K<028n+{5{K;<28n+`5{K;z28sVf5{IoT0EvG<5{IP=kobEfaoBtTNc<y`_zb9f
zLE`U_#1|lm|3DIltz!hKM^1;Z^$F<WuyZ-k#bNzrbny#F_9B~q15F&3Zei&WW)3W!
zzd%zD6NjZ!boH=x5$NLJ2xnjbQy}-i%;5kj#3Bw`2MCe|sfXnwSUVhD9JVeRCJu9-
z0Z0I9J}4h$K?jm8(8Oz?;;{92AZd{LJg7KqUn)$z5h@-45<oIP4Jr<rqXY#VNE&1g
zOnm}K07-oXR6T4R8b}(Xz8ESFx|14a4ye5i+qVxpPXnYLBo50zuytrKaoGAB(3zje
z=D@^Z>-S*lVdFcnb!aegnEC}E0jT>y_QK{lVEfcS(jalzya;mn<A;>~k;|VTByr^O
z#~n!=x%>%15=Sn7f|10L%O8IvapdyH4M`l?oez-8C1iI#L=s0<pNeD-vidY6ab)%L
zVT~RJ1_osH3y{Q-)h|R6M^?WGNgP@ITqJR1_0S^^K*@jsSv_oRIY<Io{Tw87kkv0n
z5=U0Q1W6ngkDzV|=zIo{*&qyy7nnFq9V~sp#9{FSE9YV2u=)U2Zo|Z3d{{XQ6Ni<*
zu<{lr4l7S#<tI!WRt~~wm^irLVqjo^m2WU{Sos1guVCV^e69h?5YT=oC>&t<6IRZ^
z)Wh->tlWT!!`gqy`%FRRz}A0EK{G!98V9ia2s0-EDh@LbCcXfgra^O#p!k7_!x9Mc
zI5WuJ1ZYBV04YTBSAZZ$Hv>Zgnz(~7M0^68_yp*}H01qmAoC5RA?i<{sb2sU2c1y~
zQUQ_%sV{&I6#W4SAi3uQR9pq>Z;&)d{Rim4ObnWMfEvhD28IGO@dBtgEN{Zhaex*`
zptHL{I$`1gQ1J(7=6rxov_h{31g~QUxyJxHaqR;wD?sLGL-m5ptw0jjK@tb;RRPI^
z)Pu}<0A08NIujmQ`~$SY0F7m#h(j|LXzUSLTp$y~V_=AYrVE()6DC5$bI`;$K*eXE
zi8nwG9y@?0ZZH{Q4y=rYnZE%l&cg<ghlv|NH|DyaiC=&oJO;Ys1Ed3{{sC0H0Zn}a
zbi!c=n)rm7Al(cMFVMspW<$hzpyz18%-;YNw?Pv(m<v%Kf+ijS6|X@PUoa1%eh!*=
z!F-7L9yD<WXhC)XO*{Z9{sT=s0Xkp<+8YQm5$65`=!Sa_=)w`W_+pSM28I|k@dBv$
z1T^svOCai(poudqg^1rk6K{Yn$bEw*J^?DO02)w4%D)284S6PL;tEjl95nF@t04By
zK@&HC4uoGo6Th$)qMn5dLc_wrU_FE{fhL{+6%RlY7l3Y%>Od2}0BzvTK@<M~6~BTm
z4sGD_K+k`Jx#z+&h<jAf#08#1#BI>T1EAs|XyOZ?;yGyIAE4q3(8M1=8~!`c#2H>e
z?7e{|9sm^=fG#|Oxt{^Lq1FRU{J?vNISpvy1<(c8ThPQ0e1)iggC;%!y5UlV7a|X{
z_rO00-v&)Q0a}rlpouSlZqV#O6L)}4Tx>xT|G)~Vc+a4TKVXB1zd;ihV26nFAf2-T
zDz_V;;tpuy0?>|81e$mPRJ;I9d;?Ux15G@E6JqZQH1P{i@dIe$3EU9%H_*fnK*c|x
zi5Kud)N}Ad!W$O;47?C=2Q+a7eu#Jknm7Zr0abt|9sm{ZKoeg872kp;-XI7u{|uTq
z19YS96EtxHsQ4c=@eNRM1892(?k_or`59>96QCQy8qmZSKo|0FK@)%A3Nhynn)m@X
zi1-&YaR%syFd1k&3+A2$Q1K8n@e9xnYXO@00Z)keEokBsyddIx(8L9zAmU%p#3y7z
z#C4$KPcZigKs%->XyOw<ms2q?Fw8*{7nlh#=L(wm1n5G39%%a!Za(zDGZ!@R1<;0V
z4Vt(Bw4uBOO?<(7h`ndf#2-M#zo3bKfF5L`106?%xn~0CQXmEfh6prq2XG6IfuRCT
z`~y^c0-Cr0XfY`R1H%e5aRaFM0W|RdsQ3*u@dHrt4`|{Hphc{p{-!8uKHUHnH$W4A
z02L2F6E6TQo@HQQ$UqZc02OaQ6Mp~|pMfSW09tIzz`(EpO*{Z9egRE<162G4nz#UH
zu`S3;&;y%b@!|j#S3nbg02TK^6Au6_&ShX=NI@5ec8q4AiEn@|JlTLI{s1a|0!>^1
zbodqn1H%I}aRaD0gE+_&kn;vX^}+<uAz=&*3>IkO3ZO}Q1_p)zH1P$XNo)oNh6*(C
z1kmI&0|UbXG;s##!lE;1;s&5Y=@=Lo-k^yKKo5ptfp+-e;S3d*Koc*3iW{JbJAe+!
zV_;y2K@%5{1)0deP=Y3I02S{+6AyrjFF_M8fQlbM6K8-f2)ctN-T)Q<f+l_dD$XH^
z8ZQr^;tFWu3!oF-7HHxZpyB~&;tUE9|7M_xD?r5?(8L{};&af%H$cTVpot%Vil0Ce
ze*hJKgC_m~y5Uj++AjyW4wMcTsDM}u3=U}G0nm*O325RQpyEAf;vb+32A80T8>mCf
z--9Hsi`38kf+P-dPXSat4|F^Lq#Gpu04lD6CawS-z=%N-*F!RY3X-@!lK2TEagg}|
z&<z}a(8X;)E?{6VfQ~nScp&u!wjdS*LkgO>0(2qX3^efvQ1K0D;s*8*b55X%Pk@R)
zKoh?J6=#8tbAWV%+_M2XU}J+OzQ7lxf`K6bO?(4XyaP@A0ci0Zs2)cXXMirO*n=h>
z5DPK?1)8`)97J3Jx<CrV1G)17bO0#=P5eV9NCgAK1T^sj(1V>$povc?fT(AHE=&jU
zK;~~K1F;wwRM5l|$|2$&XyO9U4No~};s>DOOVGp%+9BrbK@)!f6~BTe?f~0B3>^ps
z=?1y;0aRQCO?(3MpdcSK@q{jrP6mb+G;x7mi1-{daRaFM7Bq1I=!UH`XyOh~@h52F
z1yJ!nXyOx~;s%PS<>!Weh<jqt#04fo#B0#R3!vg#(8NDXfvA6jChjl`BCeu@YHz|^
zh<FT|c*6pScnO;L2B>%sn)m~#_yRQX4^Z&~XyOUbjon|+#0?fh>=l4+SOW1t@vg80
z#A0BuK@*<<-56JbByNCIUQIy~2bpsKI<R^IP5i@3i1`fA4LKklNd1RnAQl6I44QZY
zbmO=Qn)m{!xDT3m0(9Uu1x@?{RJ;aFT;U|d-X&<_1*ah5H_*fz&OpQ&R8ix%;VeX4
z0Zlvsy1_jFO}yX|M12FA_=GDE@hxcL7oZ#B-=K+a0A1e8z`!5^9VZ6q28HJV(50yi
z3=BSK;tiln2pJd{YS6?LK$ns+FfhzO6F&eIzknug038T_fhIlyD*gveoB?#15(5K+
z33TH(%$*6K%XSzT7(CF#FF?gB(8L#j7JD)<F!Z2_3p@jv$iT1%O`PEcMEnApxB*n0
z0Xkj|QUwaP53fKh1_li@ae+4waoD&!hzC+X0V*DWrv3m_yaG*J;Vnof1H%k7@d;4z
z4QS#YpyDsk#0|bd%wd3z>w|b8_cTDoCD6n-K*bHv#09>CbTTkxpow4j1rc9>CawUT
z=(vI=e&8=e{Tnp#f`1Tk0qDY05D)Cm{~#6vg9e(o03)PO@jw%Q02Plx6aN4epMoZS
zfdgXB8Z_|)E{OOMBymHC5I93WK@tbK^8!@;4>WNG=)uMc+F)(qUNuPl1|EoECTQXe
zyb$pKH1Q8m@d7k)1Ad75IcVYz0ub>FXyO5a5b+mi;v1mi4A2dYpil?7^8r*`0!>^%
z2x5)_nz#d0+yhO#04kn<CcXeFUV<jR0V>{sCaxe1v3Coa_ywr=1vK#n5s3O1XyON;
z;taZ|@uDCKQ7?feUH}#MKoj2}4pE<hCN3Ze5wAfLH-L&yK@(??f~a4ECSCv)zkx0;
z15y72O}s%CB5nXZ@DUb|4hj(Q3?y+Qh!8jc8j!?6@h+eUk(_}ho&Xi!fF^zbDt-b@
zoIwd<&JT2P=!B;LbfY!QodHmB4K(ovsCWpPID;m{{021f2T<_^XyOIX$;ks~;sVgl
z+ygZ61yJ!HXyO;3;sVfx9WeJVfOgt6(8NDL#eLAk4WNZe3YvHTRJ;aFya6h{0ZqIB
z8kslH#6LjAKcI;lfEFu()>RvVqaR)_IY7lF(8L>{;yP&J3!vgYXyO4Tka)>K6K8-P
z#NLA@9sm_zfF_;*6+eI`egP_e15I4O3}WvGH1P#caT(}_F<5*FSU}W=poxEg9t_`u
zCVs&IqW%b)_yQ-0_y;uc2ham(RiGR5VD>V&LDbuzi7$YPhoFf+fQpx(i95JM%vpgZ
z{s1a|1x>ub1ET&9nmB_OL|gzm&ku8_090HDP5c8?JOE9+zz1SZ51RM~Ux@e-H1PvL
z5b+;q;t9}$Ee)Utq{7_uAq=8E15I2Z86w_+CeDxo5nq8O9sm_TfhL}i22uY2O?(4X
z{0o}+1E@F;bfXK*oeJp?b5zj88=&G5XyOXc1sxS=;vb;m3(&+D6hh3ufF@p03=wC6
z9-IMlPeUn0Tn0^?p$sB!gC-sT6%RoZ{{TH$v<FQ*p&DY&7Buk%phK`27#Pl=iEpTd
zsDFYc{-F*c{s&Fmp&lYG0$rE|^A`j3;wc?8@dT)N0GhZ!GsK(>H1P(gcmtaF1E}~0
zH1Q2x5OYqTi3@Z?#DAcPH%x?x3qUU<fVsb65=7hrO?<(0i1-9F@dwbwaVyZo1)z)d
z4xot}K*jH%i7$YPe?b?AE+EnY9d>}U&LLqb#62!Z;?N=<T!Ew@iG$h?7oh5E(8Lv%
zLCl$eCLRD4Ux6k*VL3$o9yIX_Q1L5h;tVSw>ffM=8$iVwtijHO*LMq`;v#6`2cY5_
zXyOl`;x=gF0xKc*2B3)>K*bBt#4kX_JJ7@pK$mSYFfi;v6Mp~|zk()S06kcj1$s~j
zEL}ZV3vrJMns~u_h`0@!_yVYS2%7i>sCW*VIKu{rIW1`72~hDlNaE0{8XWLfki<dh
zWCB$E3pDW!P;mk1LGUntC2WM)tAQrI0V?i*CjI~_UV<bJZ3=+hGX+T;<Q@g+Lb)|)
z;tbG(c#oio8$iXMpoueVhqzM)dcZo&{S7-H;wEU~3cDcUA!y<OyCLE^XyP08K*W2{
z#0#JYu^&JaZ#V!^e+5l^0#y7Bn)m^zI1BWiNtpWu4nfROK@-1l7$WY2CY}Jg3==e8
zi6%Y)Dqe#o{sAh!0!{qD35fXz(8L)|Lc|}SiBEuv|3DMJ02PPruYvpP6vQ0Zz8IKz
z0#qEfp9Lm<04kmVT>uOd{{R*5K@;C_8e;wuH1P{i@jYnbAE4rQ(8Ld%ftd3FP5c5>
zoW&8Gtl{O`2dKCVnz+GPh&d)`;tf!7A2e}+a}f0vXyP9(Lc}Mai7Q-!h%Z4CH-L)o
zKofU>ieEqzFMx`_Koe(x9)KMHJqQvO{svbd_I99&U$_ntUw|h50V=)&P2AuHMEw~w
zaR;dQ12pjfsQ4E&@dT*2h%;)uY=DaEpou?#ibtS{f4B*8PY;^-g4+=B9q8hqLvTUu
zE;R8CP;mz6!AY=ibGQdFM+8kg04lD7Cf)!QcR&-L02Plw6F&eIFF+H202S{*6L+`|
zanAxY@dl{)0W|Rh=tAZjXyOZ?;tbGzDlq>FfG&4pU|`Td6K{ZuN1%xdJchWZ1WkMb
zRJ;RCd;wH^3!1pW6Noua(8MP|FUt6XCVl`aF5-roehQvL%<(`IU+@wlo`5E<@CqVc
zfhHaR6`z16-T)Opf+oJ;EySEVXyO;3;$P6j8QwwE^FS|3frY;TR9pp3ya6h1gC>3e
zDjtF+{sAhUgC;KU9%63;nz#Z~d<L4h15|tins@<J{0f@5!v~1@AJD`vK*f2W8;fB6
zo$wK&UIR^B;S)sM15Nw^R6GGqT;MZAeFvI&0rWzZHE7}!zCzR=Koeg86~BTeegG=|
z0!{n@RQwN`IKwxH`2x@bL16wBfQlQSi5q-}sCPjVcYuo5poud;FUFjJCN2OKUx6kb
z02M!gCO!cw{s2up;1|R_KhVS{K*c4X`*dOca`+8VZ-6FV02L2G6Ib{PQJ;Y(ZU7Z;
zKof6(iqAk3SAcGo-GC-u02M!hCNA(FVlM-9zXi<w3gDgF3=9fr;s>DO4rt;AjF62T
z5oqEGQ1J>haRDZX`VC0pu)9k@CD;WdaZr2Pfdiuc1)6vRRGb64aS!JH2T*YZG;sw^
zh&dK$;t5dk05tIhQ1J{j@dr@x1~hR6(BTuHc~3O)1gQ8HH1P*e@e^p`AE4q7(8LY6
zA@2WyCcc3OA}-+z3O&TSy8vE@xCxs01*o_Wnz#TTM12aHxC2zY0!=&tDn0>Cd;wH^
z1)BH+sQ3XiaRq*ey*JRr6QJTB(8MP|#X0;?{d)i^Zh|J>0KEVz2VER`5$+r`@deO}
zP4=LPCrCrwc?C^;0#y7Bn)m^zxCHbfMp*h>AOkVS08KnW79yU3Ce9!a5pO^fPk@Tg
zKog$;72kj+z5yzJ0!{n_RQv&&xPb!1-XCb<0Z?%P=tf7lzo6n8XyON;;tpuy51`@^
zXyOct5PNgb#1)|8Gtk5tlpyNYpot4W#qXerC#XWye?b#(fQs`3qNOXSxCxs00yT&^
zIcVYr(2K&RpoxDlfT%x$CeC0C5r2Rtz5y!!2Tj}ndhxPA5UM)^pyE1c;s>DOK4{_w
z(2L75(8L!&#cPnnp;I7W3#TB7TSBW4ki;4!aVsS8BS_-bNaA;p#Gz9uAY&N5Ac@-|
zspkm>ON0BZc1YqXNaFTL;x<U)&?y<P0Vzo0j!5cjki?-=HDL8Cki?-=HDK{ONa8L?
z=5RpwDT4BaE0VYkk~nm#25e3Vk~nlq1}we;NgO&Q0~Wu7B<_i1zCb8g8XP{*sTZ(-
z4U)JwlKK)Pap;r`SbYzYICM$|EWQOv+z-i|J4oXGNa6xvU~ORc!1nTjL~M}61Ci9n
zAc=$O{R7Z+*n=j%z!H*Qjv$Fcr-(qtGyFgjhfWcJ#U-EzaD(C{1j$|>B=Jxr@d_ky
z=#&!JoEb>s;YjLtAc=#{Nd_xsU|_g_Bp!vN{sWSDG?KUg^Z*2qJ7bW<HIT$(k;FZa
z#N&{}Ymmg_k;FG3iNp3%gWP%tNjworJxe4=7SgUrLK3$?5{FK$ffdFei9@H*z~VJX
z;;BgH%s~=|PL+Yx??DoWPKklVKOl)`Aekc)1(pV<w@f5)4<zv{ByooLC_h8P`1s<)
zyv&l!s?;Jw^US=G)S|q^ocQ9rf}+g4k~G(V<lF%7<SGocW<jY1`9&qJ*d+s?nz89L
zGVp}j5}cf0keU))Qk0pOZkAY3keZhQH_t3SzN9!Y&(JiaI5E#TBQ-hOEip4E6|5jL
z*f74b62nP`hS=3*7AKaJR5BoWG`<Mz`1sVKqWq%x;?msQ#G*=u^wg5nypp2)f=Y(m
z)ZF9(kQR^|;tPuMljBoTi%W{~!L~x(=3{8$o0^+nR2h_*m!2A&TH+eu7aVVB7?M$x
znwSz?l30@Jnwy)8ti?RIGA}tSvB<<TFB7|RWYsXEoOAM%vyF>k7FfEZ<`t&~=OiXM
z=H%ojJ0~V*q`GE-HKIhPk+E-LL3mMSNn%n?s#|7GYDhlBy{-XextW;i4UOT^pPQRl
z09KWWMV*gXacW6UX09tp4v~65tdykuiunAz_`Lj*%rvkK(6F-bEiFl{2u>|Ac1%fe
ztxQ6eGc<!F1W1Z<N-R#ba7;-7YjDM{&d|s)CB-E*5sPBDg=Rsix%p+O5R*{C$It{4
zQ$eZenZ+eVl}46snRzJ?G3WfelGKV4r%L}~PZyv3<m}WGEG8JaxENYG7o{ear26Ei
zXC^1+Ky-tYf|GB2Zel@vaYkZFemQ1xwSWhAab|jAa!F=>o@-`+cUeFghFT*76ty`e
z#U+W!*{;|X`xsiJ<iux|q!uNXq{bIyq!h&`C%Fa~8l~hwc$s-=`MCjQ40=VWIf;58
zf9jzZ1;z%!nN_LIIf=!^;6#>Kl3!$O<ddJAm;+94o_@jcMp)H=WK0|bjE!7fU0n?g
zTv8K3i4>F<0)ma>LDr(%WoQlwHCUJ@7N;5-1gDlj0yf1pw=yXUOPHWXpP>;%1H>@b
zT&$XmjNk#849ZpU>8T|pnYpR1MA=~Am7kdhHJ>OAMlPu(iOCswwZI*eR$P);;+l!o
zt8hg*U_}Am$=H-3GBA=VJh5zO;geXDp6Z*MSOAY@Q2ZGg_~rW-_$C&F=H(_9I49=h
zB!QBfUvRv!5vGoSk|M{VqQpv2iI<t|3Q8G<;FRK+l2VjfTpV1Gn4B7xnOcsX9zdm~
z3EX0k_F`A8-U`l4&r8gKrVm3im(pC2dm;HYwFs;UpD)dw^K+9j^HNjbc0oLeEs29<
zV9A#_|GFBPxTlslCYO{Z=HygDtw>D)84mRgv<&nyv~bSPD=y7Vg`@|k%FxUd*8uc7
z7$OPvET}Yunu53NGBgY>Nh~UX=ylDi1O=@Dgcnj-kc!m^9N7+R5U9ArZU)pdNR>re
zQ7X&=xFp1Cs3$D_^I(SJFLkh#1gLuBqx^7M0m=O-Ag|(03@A<mg|DT59+F-nN+-+U
z)Dloh0BVhZ%WCXyvhdGCs3OftC|YrP+R(s14^qHDTtb>1=(^E8j#TGl<!9!_mw=l!
zpx{MUX=oHwn&(!On(C3CpIr>9mGD(9^e=Rb-BU}PK&8D?YI<fK*nNmFwFEWEz%498
z1Gk*g;tZF}qLNBiaJ-^sIScpH5>Qd;UX++unv+<R2~!4(esi$?U~qL0ZE0Z|V`Lnh
zS^_O4@{9aSOZ?Mtt2OdORKEn2TDW8ugBp6y`9-Oq0y4G8GtDnGIkmVru?VYo3?S_-
zP{YvBJSa84AT<xa4kKewt2Hw*C$lOwASbaTEx#z&HL)nC5)xR@P#{i~kD+-|X=YAJ
zd~$wXab|HzYF;v`F@~lH%OFibyzLc3Q&9DhnH*e@nFm&G0cx}b=j4~8IL^=z;^|;e
z^U2sR6)KAo&*q@gyePd4MI$1Wn0S_?7Mb{^R+K;#py)L;2(HXc$_Ir|5vZS2mY9>7
zl30@Jo1apelj@UM4AtZf4J^#2ucdox3B-+9j5l>m0`<8t6P2ME*hem@1^Fc&iFqkG
zsg|Y1sqxAArFk$LQQc_~Tv|{7s+=?P^Pr`)p&5!8TqmkVV~{8O(;yxyHpv9_W3adf
zRhgkt8ng`oid2ZlU?E_PQXZT8=LMyLdOG-H8?)*{(uh$!Swb?HZ(>0~W?s5aVr715
zi7Ct)4Aq!s<5p|xoS&0llv$MuiLzo;uNj0CB_^i^Bo>uGB~XLX&^bRhH$TrUCo#R)
z&@ec)#3eN?u`~y!7#cvP1mulOF)~toUOuS(ht*OGL_%>-Edga3s4{O<#~GuxxeP#=
z0@9p=_z^|55lGrMu_7$92-FIKw)?Ot1T~d>6DvZCQ;V=E#_I?pL(k%nqS911P#|UI
zrK4DbSEr$gXE7uVI3|NiM2O3v0c>OhN|cad4LmZDoLW$lUjz*n6n`2bmzgG@?2=zp
zQVdQ5*p-9gE+Da}IJL;g5IiOV5^zZ^PA<wU0QL8vx?nD`K)A%EGA}VVGubgOFTW%a
zi&7*<gWLhl%4p`9fbH~6EJ@BtO~I+m&<Ils&D)4l&Ct>(u_P7Y&XD~49H_0Rdaz|W
zLrZYy5fT;9?1)XXkufAch2|BdCg-Q;Wmcu8fI<$NT8wTWxSCF^aLmapgEq9WYBP0D
zE%7VOO-e2DPje0k#i|C;Lx*-^^NS!!2Q9T>^Q);VXmAOl92&od=3$9Npnd^34}uE^
zL!+S7vecsDRR5xsRH)&o;b`QOpO})G0x57!lXFrNu_`l!<_6Eaw0u)%9I7nciV|~E
z@hY)!Ni0dks{$jyjRQ*)ixTrnGV@Xc@(Wzc81#JN<I_s>lH=ns#uW@rKy8zNqI^&`
z^i2e*#wdWHsTN#i;!uKKI)Tz-Kyq+_6IKI3rITx3S!Pjw9%_6b<u`bP23(mzBMedN
zTY{?#&)k9>hzTfhWMl+y&-o@+2Bnsi7UlVs=3rB54Dp;tW*(vq=$r`3<ao6in!<A+
zXkalp+X5WLj#%w5v;?OwaAP1e57h3(q0Stk4%Ax0p$ajmkd|MR4e>rSd`!VjEl{bL
zm;$j0B8?I{hQ{EwcV=EXShX3lLKJgw%UA@ZCZ>R#NZ5E2gfbMvk;Kt5FIrkMa!)M*
z4VtEc3LLEVxu-(=*}<tfX%H1qs|=0&^FT=vQkg)cP{YCyBps4d3@Qb%%DbnQ1SF=X
zBIKb)TY`%VgfOfH2_NS)LC8V17#e``8Ki3qu?s4Jt;tZ7nv<GXoC;BgH-td#WAK;)
zIH#a`&)hdZFTW%|FEiOMF)u#^G_Z!L$^ws^p((hAaLUX}EUNTN%!N7#)fP}A0_3&S
z;$mD%%tH%6?QZ<4j9oIZnvbnGH#7#7!)`_SxnKuE!U@$`7;SJ+4>~y>-Vl#3%_~k!
z!)l`eD6v5r3Wlb|*_j3L<r$eJsl}j?Gl*4qqr?Kzq)5VMwizfzm8XD;Wt8DwXj-s<
zjqaI+=9OpWfz+WF$RKaPriDNaiTKLQ)EsOI4Nc+0l<BD@1({gYn4ze_t_b92(AXGe
z+5yRgfDJ|+>_GR8WoTYzVQDHvDY}O+drL-OBQexrb_EQL!0mMKR8T5b|6$YP4r<%u
z)?;J<E{H)H*t0k^FDElMvjnT*MxfafP*V>)q)I@o322-F(qsoKM>7~!fFSBP3(w-<
zjKm_WHlr2d(5W_1SqoDRjR9zt0GWzImPg4eMuw0nA8;E9($)j1#bPXqHZ0?V;Et19
zW?p7-2AWF@QG1r4;VvX~sL6+*Ee8I1NSe_Tijj+pkpZNj4alf0Mw$r1Ou<H`zKNAd
zso()or^Mv!^rHMy=%f=Qr$YnM$PA*cAhA3TrVchc1yM-I(dOW!ng~s$P-D?T#SAop
z2v$N`fFSfCM$%x@m7q>#stIV)6q`E@!QKi=O|3{x#v*SPl<JCI#t@QA!1bUZsFrpv
zEh<XQD+$16jG-}jF4#99$Unr@IRu+Upn;a)U@S70V6Be9K0y#kXvjfQwu=!&5H;|z
z)fh09Q0<0BkR%UD?J!AHV~ikUA)q0a)FPM?sD4B~g-M|3#gU`1s>PCxVCtZjVUA0|
z6rfm&JluuUL@fgQ6s7}aBxdIaT?Mpv4XVswQmEFUwj`aQQ318U96FALCJb*Np@|!r
zfIItni8-JNWKb*FCAB0qxg@^`rV!O`q$(Pw0A?|01UW1bt`90~35jXn`~sMI6a%4!
zKDd<*?F0HI!j(eJF!xO@NkkGxF~JbI&xh3xcxMhK3pEyzmS7Sn2IELeFtt!aP{vYW
zawz5?B?(Bc1*QsS0%no`t3WM^po&ew86PZ<ROBEf88j(qb~PkAyFyh$twYPMP)Stp
zp=MX85~zMe5W7GnQ1s#mVytShWml+~P|L7nSEvFMOYvt{s1BHsm~jJh983jL*u$hy
ztusdH_&K9m0MD+d!iemODvl?+LKULgjhtPf3ZU+Wt-(Qa4^no8sz)&pM|OoOg&7UY
zu25kV6Hv1&HWi5M3YCQ#i%3f_H=`JgBQ3$yLJdL9u22h5%)!jAP*pG!Fp~tj9Y{$6
zEQQF)43PC)pv6Iu#a9f8pt%f~aC&}xF=zrC#)qhZOkgm?N1-iLgN+Y@X5&E1!b*!$
z9rIE^y*bcgwP3^e%p_Ms)1uVm(xT$b{5+U3pcP7xm2MzsfET#I>;n&1rB-B?zyv@O
z8w|y%B}L%YIB0Dcl$Bdhln<&WFxTi<z{ZdQic$*_i&EY4i-HsLKue-B^U_@dj4Y8?
zpcO-8;uDL~OLJ56N{Siul8TFAwx>X50^;)_qr{jY0BtFQJP(@t^-hMYiF38gE6t5h
zPRz*x83kY17oV9|T#}fR6Q2tn$Ba+RONj@~+Q(;rCTtn>eDsP-iePp_f&#Qe542<s
zG*K2`oSRsj5uX8`SSn&bTU^AT2Wr9=Fr?>$7R%`+7ZflQK<0`;QJS1xoSGh=SHMtO
zoRgYbz>r%CT2jIQT3`m9Bu+^zNd%=6y`p@Ec+ir(ynKdK$Y>n{d|?#Kaq0Q-ndy1?
zMXB+{m3hhWNuUW`jF>=Ln*dsg2U=2-i>V0FS%tU>wB8L<l>vAOjDHa*aRrp&HwL_D
z&^4eez#E%FM8`KbH5a@j4VOxU%Ze+DlS^`31H3b{0?Gn%u^Mb-2=7rtlqZ3v4pKoY
zDRJsCG=b|WFUl-Q1+P29;yII`(mY>qnt@O4gH=IG1dH4h)A)?U;tbH7I<kb1Nm71F
zC3rogxvz_9ymLqdx)MVJkOX9y28%*aiomfp&5*|HdBEeD@I`B&ML<{=x`CHCfd_*;
zgN@@|LCFU>2vB-M&PEU~LYt_rnVFSYxw*Nx)f*C4Zvh^qgv_M`6y>L7=A?pF>!KQp
zS!6?(o_a%VN38)YoJ!NuQj0)~aubuY!7VN{_0X7yHB1c+eDljvA&vkob_Hc13?<;v
zad2Az>?@RzLDOVp3^5D5q}DSx6SRmH>`#I^4b7lBLDR=z?F6+Ln?kjK*6$))=3fLJ
z?kCO^xWyn-K&xOtYr3$k14arOLrb^JoE&JR!3N-5b90jdAhCxMDMkh^`FSOvX_H{&
zl_gkI8k+e+D<{x+xqn_xr7J`gG)63a6AK__po$xsc^11?6r?7Xq^3YREg*S(IgsA#
z1}(rz2)u|Cv?>jK(ICW^D4~W33%`8mq%TAjG%OGa7%i$Tp<~ARMW8@HbTwcaEJ0C>
zNEx`48=8Y+%`Y`I1rp+JaPv@{X=DJhzNjoU1v-BRHrW(h>7d$=*~SMqC_$wVXnGh;
zF{ByonFn5g0`)(()#=EI(hxj96O>wzm|281?;t5QGJ+~jOz|%QXV6gaOcNn}hLCO<
zD18#A!8`~$F+s@nMo@*pCHY0E1f5}ttlBZTur!mfCUYXy8Ja<cabSx*!HYaG3j|PT
zqNW8S<l?B<u`Dq&2ehIK8nviujXjGY(VCf*11*2SNe8Q9&`2O88G_c#=I42orl*2t
znSAq8KwA{BxC9zJ5C?&j7Kh~f2ZId9S1i!DVn!_m2rf|v*UBiF-p9}sw4@*nyxb3|
zLc+eI0$e+zggVC5w`nkJE)cY$#WTe<3yUU1b1pYE7qqr1pez%MGL-gVQF2BRsKta$
zA&Pk@>Y!ztp(!K*`sKryse(#P)Qu_FOh&ACNGmBS%}WLqxY*Po_6dR7*EyMapsfhW
z0m+!YGBOG-O)4(QEGaDk^@l*yTw#ehrI6NXaxSzBfOQLkp#?}aWHnonXI^qnX-cY@
zTYgb)VhO07gIB8|vesNzvb1HAr!BxcnLLe2<Y@!NtQjPfAWOEunHt3`^yvyi6Hxh!
zG{=f9<_s-CihT0((xDY1c&ZhfN>Ck^n1V14+$K%|#}T^CAf?5r=+zyhi3#euV<sR&
zM7Ag{DauPOsB{fT4)Dg3)KFFC5UmoF%!xG<ob<5Uj<QY%vRMnOE0G4K3=MK};z7Pj
zDJ=kX*Rc5BFgG<fKC?K!DzzvdhZ58P%1H$+aK;imMn=wwC5fO($byW_WbnirxZcKL
zDs&_Vv^v-nNgbZjpI~_m+8BbhCxyJ{!qwEJC=s+s+b`H8-Xb8i2)qZ$6})!{UzVqm
z?Pfu#X_+}Wp!Nf%_2{V?X}%k@VK5gIiDkit@mS&!HIkCSN|SLY1uZiN?<<6M5L^S?
z${>9M*I)x|hMW2(7JwoOvA@qdIRL$Eh1Crf{z)Z?nR(F3Gw{SSDEzUkO>=d1EyL34
z3J8f0!1SS!Np594Y}_ZYq@)P6vkJOPtt=qe0ICP(3ZtOZVo*a3Y`<$}CD<O!&MGJ#
z;vsEW@cv3ndwq;eAYB&NY!0-ifV#9EQy<1)CwMhDraEKL!d##Ha-Y<))EubUslJ(c
zjyaj>d7yziSFj$~Y&zVnpgjjrDbyweww2e$NDD9>OI*>T4#fb1yY38Oy`xk}V-FmL
zaKZc{(DZCER;Qs9VTPv3`FWs}QVi{xK(wH^#n1>e0*mNiff|y~7={OgC1n3)Kt9w?
z6a$Pvixj|V0JQkQ2ek0PGta5ABo&)tLoA~ch9&{|1z-cfOB<oupl(3vvLTv#$Xzxh
z7h}l*pw*ehnN_KfQ4wqbVD6chTm)J;6_Q_)m;(w8tg2j6F;(FyN(slYSwMb4X-;BE
zDyTOKnlHv4%b;vUuw)E20*zkz1sla18iS$%T;hV3fI_^27MP&rwUDp`Cw!=^5okgl
zk`X;p6H`))Kr5v}64OzP0522wPs&P7E&(kdLnuKF3aF8mZl!t2u6ZRzka0w`Q6uDt
zGlq7|+;j4i62WCR`Yvo_)#l(u(a7Z=B<xU|$4EMiEIjjyQ;SL<Jt#zCbIUIR`4AMw
zcpL|9i+h4ctzAJo+(9iioR%3{LfY;S^`Mz$BJ`Lb`^FRN_!Hhmx#nmETz(OvtA!lP
zsFR}3Mxec(pwUv$NdTZ2MTu?90SiJJP*zAd8<J`|0S$;DZ}5ON#B^V9QpRw*k#R_3
zIw*aj$2p1*5%Y3pL8+i}0+Nuh_9jt+(HOp(*BRUc2PHO?auI7$X9^zcNexK$%ma_i
z5~wHO>l;9&QW$t;gI~ULNq&)MrK@=mWLq}bMr2WL1gN7#u{)9}cL$_d3YzCaTZ>_6
z;F$tiixL1D52J!T&~nYt%q<f%!j9O0<x08XkU|Kl89@az!Q~Y7jYMf>5bI1s%Yf7(
z$VNfL!g*6jMh0gs)a-+_R193{fVS&-<`tI|m4c612uMcB$A*af2-^KXAX5<P!WbIE
znu$)JjW>`o0oEpiHNQadMO?*<#dpRiZC%$~q6~v1b1a8CfLi~s9q+ELxeSm=L@<?@
zlfw`npI(|+loFo<I{N`O4Vw!(%_BZ3H4QWqTM8ceMU_fSD@iQ^>B&YFhiU;Ww}Q_S
zqx2R)bI!2yXyS`gOX5>f6H79{Q`(?22#6~w4Ipco-4csSK=VtvSs-n&><1aSc7Yt{
z0*M{e+89+iWK<l_U^N!Q1By~X%UKB<ZVnzr56CYrfef~Q&h!9hJ4hn{)Kmuz(4tsj
z2GLWLO1u_`A0P`<aXSh%3!xp30-C{e10^&ptC3u@T(h#kZp3edp=$tPBVf@4jT7)t
zt+SCU#C)uhhEPdV%MsgFKs%d3qa2x-PDEbXo|&GSTToI79-zfkX=n+bF)z+c2aOTn
zP-x`hVv(L&0*)kCusKji`@oKhfy6CrDj2K;)#-@g)%4Vo6wu-j*GzEG8|7r?l~%;3
zWP;YcLJWs>JP~aX<Mh-Lh#ab^#^9DKxQ=tjssj5GCvZm=iz5-uDe%G$h>e)8u}n`b
zi3jak%Y&#ubrV`5Gc<xMvWA2ZL<2PR49(zeCa^z1W9^_^jcOj|;(JiiAxfPg#5xr7
z%tF$=L8C#Lm6@1kAOaw#I5jof6{{jk*o-V>6-88jUTU#xKv^cNR7}gv!(ucd0l-!p
zfmRoQ6~cl8dbkJZfC+3l8bvL1og(C@2!g7O!ATcXCgCo_z{aBl6?g-FQAu!V5@_Lf
zYBA^-h~xn8V8i%e<M_->EE*6)V&#dM;N2pb0oc?bGIC03fsrdVC0NE(K;>0{cQO`x
zu_-om4ZyA#G1pRD0-ck=W+uWf#U({})FJ!=FO)D77Gf3#VrO0{Xax{9YfZr`)&25a
zQd0|@K$~~4dcp`{YjI|7K~5@Y%()~VG|K6n8~|D^hv^2;CNI!{e+qP$t{eE^wcLPA
zy!}WsP?ZE3iG&WBfDS4ONDjyiHi-vm#u!000_!Ns&jslMFVqUas?HER1|5<QRpwom
zi(MTeA~K7?r@OggH4e$4ke(5!egGA*M!0)T$*x$<vhXiR%>z3tz&jaKcbkAXkhxj#
zR7?P78Z<HlHLKx!$5T`MOG^q$OI*P!VL2T0R5Z|;Sl|;K!0J%5AEGph2Q6cC&BQlY
zPU{s^kO>`Zt_)AiEOE;(f=($xJdEa%V9+{2xBMdC%$%IeVr)uGVM>Bilk@XZu&S|u
zuB!+xNz6-0EJ|_1t_*P;7-$X#i;K-Xi=mDUD$UCSE#$<a2vJ^xR$+lh0<frp7Q>*?
zy3`_b(8(^DWvSTwhltDMocv;JN-Uj05}<^JO+V-i5fAWUO{5t?u!CS}3);AX3?rb(
zV5B<m8GDG`bYR7(F=pyn3~s1G>X+0MEKV|Vae*Hg3Cbg8E-q*rr9hd_(A32R^&CAc
zw!zkE=R(dlgzOdqtAlwCb>Ek>5f=9tqQnJE2@V4c2^#=bg0#FC)Nz3>VJ=84$-rE{
zi)YQYt8s2|I!1}?V`Ku^oChAgOaqM@`Q<|k*`$EvOi)2<XdEA3mKdLtSzHodl89-B
zWmvEuM7t}II(!Vx&~0^1!e$ky)0m%^2Jh1qr{<)=+Bo19rl24&Mm}sbJ`u9&CO)|c
zw73{_U`eVgXk99@07`EViw2k#pf*Q5Xo$Tel_57Vr7W{J6($AU*bL*Q=f@|O<mYB4
zo0-IeXP_`7jEztwpw`0FLCu3XpP?YL0B%=WW*+!-q@wur{G$9)(1{2LZJ>kSpoMa3
zMtmCRBnE^ec=L69Zfa3F+%Ryk#TS8A6(ZCnrl5)-dnY+R7qsj=KD8n_16dbbjj>TY
zK{aM3c=f~0PERc<DlJY#I2W{@93{HI>+2y)z~f6m2jMX2ff_wY#VLA4iFqmcxzL5*
zCE)P|m>1LY<5Tleka)<;y}>e3@H600)-$>qn&yJekWGotO)W_T8<L({Qkt0pTDxD6
z2{IC~9v&%wrlo+ACj3}A1JDM2=>C0hnFK8=!6lq4D1jEogZ2hMl%VKEbB-a%f1m?E
z3sOOrgBHif7o~zy0h|ku88egkwA7O1jQGS9Oi5!SJd$Q6@j3a4ST!MwgVyQ50u_?5
z3X)-bkX$^13)v%pQ2-g6LMHMY{enGRi<1)zQiD?qOH=cbQ;Wd^<=|6%T?3LaG#Z+N
z2B6(CD^gPsGlihV9vCW(%-|})3-0~%+!9L?bHHmATywE&u>ffSPsXOE5UmO8qD#<e
zxj1YwG<8W$&IcW*3T+PKP-kQeat+w4!KDSMMSl6vRtOIDhG5r&)e};RedUaWZ(;%1
z*SIV&fjbCI8LX}|@l7m%bhjam0UW`MHN*_Tr&&M)ABPK!3_&gcTaFr?0p3`W3OGFA
zK>^m~iZ$NRSK=9grs*O60CiiODxvG~h|+8bI+72e*)<EB+blu;0GSOsVKO%pRN-PI
zU>`$70sx;C16sC$&7UY^;D)A&DJaW-K`X&QwJfx@z`i;T)d<i*$e@D(z-vIAjo>Dr
zcepIThfH{+R)9Oa7#=V*0?WIkCTHe?W>T>Q1Ze&uFC`$cBqJmrvgixcdBQXb=_ouy
zQ^@f}py2Z_&r2-=@81ToQk?TaE4r|R5$L1`*Ss<uW`oxEft^}p2=Nl+6md{Vghvx-
zi$q0caS3>E0*i~0Of@V39orS320EOLup121Km`?O^HM%&*(R2hjWUn`>T6&NS|j7&
zjQrA^6yJQvap$E)sUi8G{v~!7pqL3=_=V{!L~kMy*6GJogfOZ!54N5YQx(#pFmRrM
zO!$M60(J+QcosV*73b%amZaiVWDM=v2Uiy7<fmgd2xZY6B4)5Ewg^fr2O9~Kg%x$s
zenD_*2`C+683)4_C5Bjri%h{O4{SW@$_3PZ5tj9<MCwFazDka+OjmMrC6T2I+@r(j
za3UKOALWO3fDM*lHMH<ZECvmXfC{qA{5<fiJk~hD9OebBaEHVymZAhSHd&NefGC5&
zQHNeMVvA`*V{lZ1iWP8Y8=GrPJ&Qr*DYiWCSqw_{!Jyrsi6!|(u9#{pJ&R$5Ev6*s
zK-$D~unUSTGK=Gj!N&oC)j`uVe3g~4OKOg5WfDe~1q}rRfm_?45oEADRI8ymWN|-a
zqzYVbV964>xw*)iU@NK&L92lLiy$*fj(L!?xiFi{sG4D&Zip_dmf^I^GtCuTaKr3E
zaTRPz3bJMfddM#*QKGcnQM4FAr65{B%WUv#L&@1hY(EA?1T3I2hEyyaQ(z~)WP*K+
zV!9zp%?@8l4DyeGFZfVA$D-s6*MJO6t>88aqSb_{069fjf)f@jS%cL=T?~(9(7}1I
z5XTz3$hwRSLqWaY^t{v*<dlUqo->n@&>A;Ts|}%hU?8ayr(X2D>tkr-2);iAa-ySa
z0C<gfWkyC)64;3-0Svme!2~?X;Ru?gM$B>;xVXSK<AJ<u?&1Pg<_dCcaY<20ViJR1
zab+%;MmbCi#e7J>I_2kshwTGkJ}t@zbqFy|M8u&Qd!x?;Jog2j!vmdM4w||*L=y7@
zttRrxG<5aJG%|2?H4Z2(fh=<ZYlAfK1F#1OWG31PJfn|1*^N6)KuH|M-=J`XZ0~{?
zLrlPe41q;GzI+nk4NCve8XPutip3|O4LQ)|7x_h~hcSXx!|Z~b=L8<CaYd29a0KWs
z5^(Ujq8-$aw8jL*2n+u_NV~`t;%I223AB<3q7Eg{46z*@<ZMK=N<&xF^aagUpri&0
zTU5Ictvt}_OJ$H<INkxt!6xw_#jwCZI(i$_A}$7JL&!PApqew-7_1t_XzX*x$SbG}
zjXYDF!6Q`QsxSyTH3+g7#U%8eov}esX&x+Ff_72D@6!OKFVNu!Zje>#n2iG0fHGHX
zjzzb^$Qa||7r5C;pn?Ea!9WupDC-exwxI#SY}Wucl8pmZ;Gn@?a0Ts_Uj!?!19F3n
zFr&f85HwxySd?Dun3n?X2n7TrV^fG+5f~a4mFC4mPj>)EFcy<hHGr!QNS6zy0Z&U9
z&!ie;RT9C)ca{aE#ToIS1wgJr-XQ;wX&WqsV_AZSVFh{}gM4}ps8E2Oh~QRM=1Rat
zhA8cM(7H!x+Z?11(;85o0|#)Cp($tye{o4_5u|ku?puNrBse!h1;NP?t5Fuvf(UdH
zaWLeTD{yofVx}Bu8yVDI4Jb-Y%dEhu(AXz4sR(*Hrzf~49gNjH#Cn;MqT&*;(+Mj?
z?2N%I7!Y&2pn37)0`NvBtVSA#q~;cYR>y;nzQ*YjL~&S@ng=>-G{76QCkNAJ^kpib
z)-R-`;hzQ>H!5}w$OWx+FpP&5z*y^V{29RzJSz<C{J6TJCP<15Mrl!EF&QHb;z&5q
z3JqKxLRu48gC7yD1>k{y*UZd-vS0(uL}z3IDjeY(ogvLea7hPRwil3#RS#%j2omTJ
zcjOm1=A}60mz3n^x+dY!gK~WqXtF3bu{hf`Gaw6_4M^L%QgT3dWq}s#U{eTQT8iWp
z$Gnt~oMNaWf(_!KdSHv9KqsMiBo=3+7J>>fEWu%jd?SDbXk-l3@x-MVWqb|3I0|z1
z9%%K8H`IF6+7+)ZL)QSTx{!~U0iDtWzYE3<9Iv2lX$*Qk!NDG&tOF}!p*<|{0zONZ
z)TGjM&>0r40dAn7(<)aarHHj_IMktd!3cB&D|q1x<n$w0+W@pp4z&ISd^sT4coc1h
z=E;!rBIC<ai<0t-LASSn+<>CU$H*AGrWn*jiO(-BiO)}q&js(r0~-kSnvbDraVh-z
zjQHe|3S?Ph7$41KGstxh!LZe>kg^%l!2me~Zn$|i(jW*z9>q9NTN}$lR-CPMkOk-l
zSc1(4&3Aztc!nftHZ*XqOwLIK#{)z=v2*&M`U~E(!saeR1K9dW=vEd;r@|GjWQB$o
z?D!Q(j}biT4zdAlM^0u^QUK^uEYNgzN`5&wzEHx$%&`Q#ZYBU!pJTcTG`$cEIkGD=
zFC96_m0_A?Xc3%R0-Atu$xJ1r)EqLaMubWe&|QZF4fH{};SQXX!Lya|xusZ~X#!oM
z09v$yRfUfcVr2{1FmS#|23<G_RUZ-tpE*VAoPoj+7DYyo^-Yiz4@oW1(g8B98U*g$
zp=|#FI~S%Oy2TTAP$w1>a?!3)vv6^N+6Hn5N=*A$lw_oWyU<`eQ00s)bMnjMb3mIt
z<H0_T&&|w>PlRvw#4rtO{|$0I5I7kkb?;JBf>YDMTSh^q!2E{M;WRV_-F^u!bRcQk
zH8<BUI3AXA@$^E$)iZoZ5S#A|!Eu)YxzQA~MgufIU5rJgxvv|feG76bS`fkSZ$(P9
z5Hp~D@&R2wlmc3Uf+`F;k`Hv%Cg^}Ege;2bhQ_6N*?IZpdC-{`4C{@+bB>VNcSwN>
zYA!>%s3`R(rl&wB8bGYa(1<j@08L!TN-!N^0Be^+&!s?e1Bpgiy1<T|HG_?df--}-
ziwnd|OuJoNz_q(ya6EoRpvoLw5j27f&0+2b-L4C<2rUC4_xHd-0`763#V1Nl1sbl0
z$fLxlkC9;#_%#1`P!l^IoB%-!P%-1j$H)lOG)pZmCaBcNs3ap5%Z?zhp)gMxf)?%}
z@AE*~_zMbFs5;nrpwL^MK)Du&Lf=&IVZ5M|#6d=Trhrad^9zp0uH45WHxY7e9<r-^
zjLe~jBNjogosBQZNlZ@7$j<>?0E6T%A4AjRk_w!%M#ji(5Og!pq5#o#f)r}#%ArAF
zXb2tgL^KLe%4zUUBUpGL`wDZfC#Z)EZeKt~!LVuaF|<T(=>#Pvr-tMgpcrf937-&3
zO@Rz$LW*@zVuP3rI?M#L{}jAA5_E-b0D4MB=~f{Hupu#~BVQQjO4w+WaK|>IWQypL
z8pQ{I5*uo_56OK#XbueUP7d-$EB=v>fCf1aw22$Tzo?F~gbt#Cma>4(drJogngwXq
z7gQSrxPi~F1V;mkMkCN18`?%;l;%xtE~X|QBgiH_aKj-tu`<30d^=8j9_V@;6u(*^
zrv=EmRj_f;r0HX1fUE%C6abll;!Gby14tPI+GB=nf}sU;n>h4rD_l)QP@EuoBq$~r
zlCRYasug@Z8R=GorkucQ1i|{D9wFTrLqiI*LVCL3{+xMYa$$T?Ds-<s)(y}2f)Uvy
z=z2<U9b-s|Nua|T5J5z_c_2R`j)kMhWtLD+B1ax+4up*%z`8ZySTMAN9G?o^{SOIM
zDwu0z?2%XuO(-egIWlPCg_O8xnFG7i!0X#VD+?=O24U3<&E24@iZb&+*AaqtK!O@T
zD92TUGa*_ow}hUcoSByn-yMoYoskK8gC2A`GI%5zv*<7~hAfYE%!8hT3GcmOsx>r4
z@8Mxl1G!29ZJYvAosmUwep*RTaWVJ=6xWL6)YO#J6x@~@xwwGl1t3)+B*Kw9?-&+<
zMhgtUH9zR?KIr)nC^{hH>7ZF75KFHpUoSoi(YJ$N5`^9dM~M@{r<Rx^ZiC0OHyYH+
z0G&k=Qk0lioR(SyQHtRy@bQ<R(NfS+C5E6~H#v~$aS$Ig<_qdIfzGD|UA+pPGRHIm
zy!{B&mh(+4fc7EGKwQwxULYaR0()?xf~8YvbI2LI4F^=j!7?PIBa3~A!UBAfNkwJ}
zB&wihKy@Ha7&SBkkEZzLgC?J#uED7me76^9n=|y>N~AU@7H1(Wu>g559Cq3zvAPUR
z-HY<ekq*Nk<P%6)1li3=K&>HoBssV|vjnuN0W{5v)6>v#csJ-Wd;A7l5U0!#|B7!=
znt??=bS4+nP{nVxA>`)Qko<xGXB;X~bB<v$_$pXPr#C(&Kd%IIZ5S-KVPs1b&DbU<
zL9Rws1PwY!zptp$&;;qy#!}D$-k^ZTGKC5<3F?2yFdXC%7s%KlxE1af91prw7JQ@+
za$bQd2cOD9gmUzDJor2=kfWe;5wP|>*iIx@q3eUV&yZAIU}qB4g-Dr2*fMiwC0g?w
zx=R<`%|3=^$c<UQ{Jd0f$e~1;kwHLFW^Q6pC44;tc!3+p>!|9CAlu*wt28u+4?csg
zZN+XJ@_-h6#LCdj5p{_&w0J_DSi*3cp&`-;Bc>01jF8r*LJnNdFM^B^fE7d29iqK~
z)J4bMRK#BX8k)GI<`t&~=OiY9!xFS?#td@ukE>6vnW?F<nX6B(iGih=t1Hq0fbo>t
z0q^u8EHN}NGNG;|h6doaAov_3B;OEi5u$29gtK{QUNPt<I7r!rwdo6rYiRtysz9(i
zK<&2T)DqYkpr8zlT|cOuk*G(YXv4CE7CB}37@EK*zQB`#_}1tkyV%0B7~>EgP_+rW
zlm=s{0X<)XZ39<aVE3S8NJFHP7O<_r0yzXlgAvjau7J{#`0&h<49MI*#2sjsL4zHw
z5CPXpSd1<%$uB6$NG;DV%1MFj!zzj|D9B8~bhnW)R<+oaqOYJaG|Uc#jN5{4T*PpN
zk1=8b7TOHWF9J_YKn8Llj)D2h479&06(WWbPCkYv>G36?gZAP<_lICpVrT)Imj~VH
z3{8a??lCk09cc|d>kc%Rfz>KANYMrAUO)!yzyStxqan(01*EkDR)FGQ(7k|$&=E*%
z`&}`o%rKk^GQt3A1nS;cP<qAOF$*#P>PSP#mE*8p0=QQNZNh*Tqk)v7I2U=$*A!e*
zV)2q$aB2yzUJ`ihC>c`|_z+FJU7P^7vLvuRsM~!EO_6IzpG-7a<MjOaqSCyQ%-q!Y
zWQZJ^SKtLhkp(C{#pjmBgDt?R%*e2~GB+tdC$lQGC?1hY@oO?f)&y1x^?)Vlb`x+5
z)HNUj6jh+vfABphpkRk8vH&T9kF}zxKy@a{c4b3D&=zt?nuFHE7O)ecK%0~xCmMKG
zx)RxbL|L7bOO~!ovUGt~LXqRfBv)`qqXrSS4F#a}%i!@=&@w?#RfH{^K#_ww28+#j
zq;(U}7AEKvuA<W7%(7Habb#6vNVQQBsDb55$RJ3glT3q<W)?H^(tQ#u^Giz%%|UA{
zK<@ERgLH-=353AHBh+RbS#b#pT`b3tV~HpuSXu=gT?)D_iI^L9AnODPo?ZsZTd2vx
z6lNRj#KV9x(D*_;!Nb?cwb2MZJqoqav8X7q614k*w)PsrPc8wC8|5d1_G3~vWJAJG
zTR}!HF0Ksmpb>rW4(@n!OG{*~A&3uN6{Kf|Dr00~X$ie_Ob^6FGQ-#yRjDC}54oRA
z4~c1nFu)MOMAd3!ZUM3-IM_qa49o&ua;9f$f#OIb6I8yTF+wSbiR3gxBZL$Z(-0ww
zYLulpicQAmsC*+dzL`1PwWtb>O~En{*CUuF2&OTb1|x(Nh>7e6LxdC(6D$Z0C^L{F
zAXXum#%8EKF+xazn8@a%sx&f0s6=9-DY7s{G2YPJ6yyl7bHFT!b5IqTAY?#HBqtc7
zDl`J|VF?IL$_QZyh>2{7Awmj?iK^ew(gelf#^xq4ha*^KXlhKsY9L-hlQKc&8-n;y
zmxGu{&NDJbm;z!VNf{d<q>z|~Xl5HARH4ckSsKGVVT|HELo>Jxh=pXQDXKza5FhGr
zB&G>iJJ{#O2&NH&X^3E=8E9dI;u2$XRK6jI4=HI7EHgAUrbZxtfvpEIk(_U2f~wTW
z7@-u2X@n3pL@-gc8e15mxzrG3D=00SqskbXq4G_^3L(xzFilVu85^VW4MBWpNQ0Qj
zo<bO6gkTyXF;N_9XlVd<D3}Fyi5Y@vYJj5N*aRU3Vj|mYjF18`k)@0fQXnRhlp(75
zh9ExFXCNkuN`xV(ZnCtrK&yaI_{L_I7LaACdJq=ak0z*^jE%vHz*0y|BZR0Sss=*?
zgcO(sifl6r6q^lAEkHJd4Mk!aqp31Nr~)yO{A_H9kV0aj>NiKR)7S!)Z)A?jH#Rc|
zxe4rAR2d^vunfet2&M^wX^dbRq3Jb5<r{+duy{o1LRDmGhT?KVb2GThz$}PMP!*Y=
za*aWJs68MiQrH<9BMd=e8lf6sh){&YL{(#HisDW)Q@At1EQm7^OcPY)#t0b@6WN7E
z2q_Q~Sqjw*BSVBr5EDtIu>nE~O_QYwin|RhOkfT-N0l*yOMqC&hMR(AAU;IZV{C$u
zLSh=DsxmY}r~)yO%{D|xAu&<)TN<Ny!N>xYZ)k1|_Y$g%kr`YD!h-k#RgnoQ*BHcy
zB_>oULu0UUU_(GmB!3tgA*4V|WGO?06o`o|Wq^<Zvp^Zr+z93yGcXHmohgE8Y=jyb
zMhGbo6Ulf(LxdC(6D$a}$q>aPQ&g@Ihz|`2B&LZW$a!E#8KY@H$QU7*hNy~+4UnWz
ztT(naK;avr@r}(5KsJLNj;hiOm1~T~Hw5va9sx0tLdeJzY$n(@NK6wn1C0@?Kujb9
z42=*{ASSXDLdFo)JVOJ76q=VU&5<iHBMVf%87kKh#D_F}KrAG?jZ7`g5uGeJ(-<LY
zgl3c>LJEnAs>s3u#dU^gd~;N3BQpz-#i00tupprf76da*5KLn<twyMPLl7StgGfw6
zG*t!&15ss+EX+|{Ze|X58JGojjwz}dLlcA)64MwVYJ{r6$Pkrp2;xH>jl@J%WMpZE
z;xZ!(Gq}^hEQr%k6&ac!q>z}#sH%*NQ2B-+KGZ!RCUSByL>P#~MAdI(X$p55m<4f~
zDT@1zO%PHbCXywF#t1186G_Sl%@7bD=2BECLqmiiNK7<E7A7c;GBP)Txg5bV1B*fY
zfU4Zs1eI@Oj8F<<B01dH2u&#(-w?!y`2<a=A;MH7CaNN1OJfwD7^3lwEzsoA_~yoN
zkE1FyHiOGRSdf4~Rb*s>$~Oe@p}qkzkplu%rLi$8-w4Eq>I5;7bQ&3fT>`criD`%s
zMK#LM+z9R`ILi#o0-IrKgc4%L#;ANFG`=B-4|5s96eCn!hK2|!BqpjNOG6Z!4bk{U
z7O3*(s9Ym7z9EPYDcnIUq!2SSL(^$$2nrF1?@^_UO;GuUAU@Q$NK9i?RYpdrd_xc)
zstd$Ka*L56no<xSsuaXTQfg>`a3-oIV@m^&2S7E2xdBQTnt>(2J_9k4OfyBufS5=!
zCI}f26G_I{7}az`5FhGTB&HF<07C>5#a$MbW@z=a8N73eDr1VO(!>&^5bPlk6UA|;
zDh-VhN<mB{rG`cbDG(D$%GeMgg~UWN+QI_Gk!Gk|BM={w@*pg*b4^hdnOGn^f?ygW
zm`14TjSNxwh9EvP>_JRqKNuiPLDghzX^!G>Lkm>Cu{kQ=2#s%OW)5;SD4~H^$ab25
zWxzf~Vj3evjSx&jR9lP<5K^cz7G@~UH3spa0c!?w2-rGP1k(h;G)6Fu5KKcf0}W95
zh9EvPP*G(pO;KE8WNr$w9~=;9GN!0}Ll7ToB#4O=W`-tUL%^N@F_EN<j1f{GCX$q)
z5kd;YM3OQxL`Z>{NK(cIsLnD%;~RqbFlWNNW^MvwnVFz^-xMqZb~zH$1R-jSU>YHq
zhG@nZAf(V_ER9htG_){=ImH~#GDB5kg32`p@u5BfF_8lUO{Fo|NU(2^m_}%-3=yh8
zOeFIR4G>ajnk<b_{9$B)$~QDOg8K_i#tbe4Vj<aPWD1r6I~T-6k}@<wNEsuTMrcN(
zaSahFK};m`j0_M`AQto#rsU!hLlkcrTB7oeEKvF8s9Zx3ACiwjEF=q!O$|Ze0r4Ax
zX@X!HBbY`ArXi{Y#s)}IW(;~zcNdow8R~&$KpEHE0L2f+W(IJpk(j0kQ4>@RM#cy!
z5EIE8Mn<Sg4MBWpS_CnXlo}!oL1Lo1%+k^nxwbSkvowX*mMAhtreGOx@R=Z(#t5bn
zf@z3gqMC1PZUHyn0>yk|Q?Lx!d?cm`swzWcgeoMa5keGIy@ff7C5Gmxd}A|Iz9EPY
zNj(r2#5t&nj7`izegI1$F^$nw86i}Gn8@*hkTFCs(X?Bdp}HK6Z(#;<11PPTp(->5
zOMo4R#56&O8Y7rS2&N&bDaHl}DO4FFOH(w5q4JH)QTb-5Ttg5a8p3EYrlue-L0pb1
zWn_YoLSh;tM2%227#kv_keH~7OhDFwLeSg<)kkJ<84wFO;!MFZ5GSH)GC|0Im`Iw8
z5i%eqvWyWz3dBT~GDJurF;VTbG)8f^1uEAF#D|2mxiQSEW?&Y?0|=%Gf@zFuh_Mku
z3dBTmqM;$0QUioiG#N`H6o(pFpz_U)V9o=vkgPC6Rc8p|Lwp2bLHvQL$jBIM8dwU6
zX@n3pMAcwyfRI9!F|;&9akm93*T~!u?rty(Y^NE5X^N`e1eI$9;zJ8=B&IP!zY(ei
zV?%@#h=~+Xh6YGdC~h{kFn~MK07b^o3@ih2G^&)bDMHEwO$wE3WQ<S=Vj{W82q6Pv
zBFPvVBBYR*D6TU>u9b`}Em8RvmL~983RT7gECcowh>2{gF+vK&M3OQxLP&v_NK%G|
zs8$;pAe5rY7+YGPI>iE&Z)O2^GnfT-qbY)Ef~wru7$F5>BD={5Aq8S0OQ9KJh{`tt
z@u6uBiHWMn(83(WBW9>vV-O#j3(Y}Zf_MbMG(j+p(X<*Nq(Dq$hoh=AGDN6EVxlTC
zLvf}hD%Ti|Z-~Y>HZub`9#sB=SjbK>1<OFZg<zVXnr~=~$~QJbC<QT*3^X=GNFgy%
z^&455qIk#10*!Bu#y2yCyB}4?6f6O8KB|nd2`b+R#D^vaB&IRK03%clhK2|!BqpjN
z3lkKN7^Crx(D~*jFpq#(Na1D%mw>P!UP3k9&;+aqEQQ20MpI>kP=&-aM2MoQH?lNF
z@q+~_*BHcyWC3$D88c&;XCN%F!%R^X8JU0;fu%r9Brh8yWRRFfsQL|&6rniN2!&^f
z$~8jc8(SE`oNA7y(hM#GVj(%t$P`tju?Z^Q2#s%u#y3V)ZVci>(;tY5Y!lcC;2<(W
zFbz@lgZ9$Erqa-4EDhnF1GB&;nHi!4kSRh2#6+^)1R;aOG)C2KgiwUUG(=ToY=BUO
zCSz%U;u>=UxQoFou!~I*OcMmt7*(ecLdFomL^0gb7`Z+*vP9*ZqjHVSQ2B-+J|ww=
zSjgdIX$%X069m&3!8AfJ4N(m>Hb6+B${3nkfJ_CK%wQHIBoIs!3l!fN8zZEUm`13o
z3=I*gkeH~7EX`3&HnKqDo0-F1hALxd3YLMm6u~q>FpW_)7#Sg?keG(3stgSfs!(N&
zEzRIg0ka@hBbX)#rZIwPWQO8FV?%@#h=~-nMg|BeR858!rf{oGQH(Q1<r<^$jX->8
zc1L2GfQ<vY-x$pRBUHW-hz~UY#6)tgA;J(OCaQKr3lkLQ8k?KIJOW}NnPzN;s?rF=
zhvon@8B?$sVAq3~$cC7pDFyMNt_Lwul!6=rHpCcJlc5p9d=L{!lOaL|iHWM+(ip|Z
zMreFPG`_KgF~}jHtY;2qnW36t3YGx76~shxkO`_nV-O$aUo<IHu8}dqOeCfeswzW6
zgeoK^SP<-DBbeLGz$}OpjZg!?1eI@Wj8KZiG(uHnXoye+Vj}t3&;TKYs>#w2#b!e^
zzOe<Wyg4e@7{rI9I1mfTMq@KWkUzn`12K`LOc635CX$Q^LI%V{k}*cL*AT>qMj8^+
z2u&3#*T@iIJcx;GyaAe05FctjSQ9wr3=lp-Fij0m0?-5@gTypORb+(9H3spawjnVM
z5k{d{VPs}$1n*ZGA=j9umMC095FctT64L}#m9a6{IB-lMF^v$Sh6pCARwD}wR14Ag
z=BU!fAU-6un4!v;qH>Kve3-*6K%ND=&IDDJp)o=ViD`tU3YBYYh|q+@L{nsGj_NOS
zbC4rIiNFlZ0z1bPO_2#g3dBTCUdE_OjX->;|3FM+rA7!-KujblLxc>7i7aD)kV3P`
z(hS8XM&@R4pMY6lpO_$+#;EFzjSx~uOhbeys(M2UQ@Hu2C^j3Kf@Q$=Au&x5qQ<Bi
zjEqqEh9EvP&_GNi{~H^kDFyMNN|BhTiY!e~+-Ho&H!?SY`2@s5vds)G0bxPB1QrA{
zO;8OsGDb*&m`ElWp{g_l@uAKJF_BanqNxP&p(??qgOaAXG0eec#;9I11<QaPhr~2S
zQ)Prug~T*Oh@z@DLb1ch(g<d|Ih<vNs>aw9ECX=|s+0*r2E;`2xv?>-N<$DI>UAWh
z5yAjN1QS)Or6JsjU>4XRW(cM!f@xxi>N{hE6o`rBJ|lz-64MYNifWRD0gAzf<_2&#
zfmskYp(-*mMM!~|$hMmxq>z}#2vH*h(-75IV*^yaA&3tRS&*Zg13WD);|&?~e4GP3
zE#NFm3%Hm$jAdks#5946S{lKahGuZ4ks+LEW^M>mU}Oeo8XCZvMrH=_hR8LXk)<UH
z-`E0`ZwTT;s~Ag=)4}0simJ%i1eI@Sj8KZiG(w0PqG>QdNTJGDTA(@)jc<-74dO#x
ziz;JiYJqS)f@y+a8Y7rSXnGMchNv>e1_&uI3sh{FnImj6M{&K82|@~qX^f@{m1}H-
z(1gS^M2MoQw=_ew6U2uGi5bFS2&M_DdSf&$h!0J}NK7MCRfY)TkeH}yj4e&k9EQp_
z1j$1kiYjAjif}iojG+la3W;fqs>;X+p$f!A&hCZ?DI_MEeoGUO13+<WZi3<mGq?nV
z1<4#>K`_$<Rk<-j28n5es>sL?p$dtKs>s;V7{wtL#&8$HS!Q4s*d3;*strvLQpTuK
zMn(uJB&H!k6ji;kxe<y(j6i%yEP_}_L2YIPb0UNVc9;oR5X>}2FpUsQLj)7mB4Z0f
zn0e-gs7^3L<r{+d&?F3EBDu*FYzEkR5EDtp1R;aOG)9OTp;}^Wh>${ILOT}b1|Zjh
zZ89@Jaju~$LJEm#f)F)E)nIIdkODE0Ty1EGkODE0q>K!Zq|nx{AXf+mkm||OG9JpZ
zfU_(uU}A>GaHfShOb}FOLG>70n!-d44dF~9QxmwTF`Q{+X#^KFgEK*u8q_dQr3Ph!
zDm56>)DW)C0L}!}ZwAQTu|(yea*Zs|_-2+M(?J;>#6k)^LsPH}IR22B#;E!YjS#Ak
zn1%>ZH1(DiD9$r7w}9IZW<l&jRb*^}$~Qve8-n=I<PKsY`NGH;VJZ^S2-QGCRIV|I
z4>b>oiKfWR9PV;33*vGF)7Tu%rzl)wBQ$9cA8IEO(-2`Es(NEfGr09&7Q}ip6iW<E
z5K<r}QotA+Bcwn~Bq<|=3=-22&1eIJDpVOWQxrECgZPl*5yV2W$Ji8Ar4fh^4FV*l
z392eXV^fgF!QKTikqtCLNFgx|5u#{DS(>0a)dH1oZUV9ils6D8Gq4!gc2fk?1i>^$
zHNyy%YYgH;{Rm<rx!%waVF(fvRlkv?F^ZE7El~O9#&9R2N*J2KWk4(>dyP!NG7v8z
zm?j9OF{)9<MyPxv5Fh3zR4GF=E{G3R31T9-!q@=GJ`^t+TNt76jnMeU=0<QoqpCDE
z1Is{shAL%bf{+3+kz8VAjF3WN8lf3rh){*ZL{(&Ii0X1Qz9Aal$O28hxgp$Vs4`|?
z39!dNOeEJEo1&^T1o5Fkj>I%U7+{R5!Pp2P1!5wZZDfe5)DXmnnvKkaJK6xmg18dF
zG(|8?5KLnO)Sxm#NP(D0t}r%4NP(D0Qbq;_1`JdHx~U8d%vj9Xk;e%Z4ZQ`X-~=O_
z1z}{UF))C{*dSau=>TPYv}J*^Ad~=vf|JQ=3=F6$AW|n@Lrm=W1u~t1;VA<H0}}%S
z0|!K!K>|v9XfQAcLfObvhY&<R4^$AO{~asBE|{JDc2M_&42P-(Q4V$x6~{mvB#iF<
zE<321X!--5L0p;u)eEwpl?3-s!Q%eMSll1kjNSbL_7L~4fZ7kE(A^)>jNSbkpzim8
zY6Q6-<RcIU3Bkhu%Q}etLLfmTd;n^{16sJi?1#~~;%@;K|1Zbl|EHD^``OU!VQ_-@
ze;=AS%wCvNA6R1d{|~7DZ$K4-{0~Y?=>Es${xw+K?~ld(Eh*UDf4~Le{wRK^1E3VT
z`|DG%yZ^#-h)a>vAIK<(C<DR#vjdC!8?d;4TM>5mD}+GY@5T*vIFv$n|HdNh?l*V=
zaVc{81En#DC}H;>!Q%c4EKs``5cI(;?Cvj!hq(Vbr1*ilo`C_~{d=;YW}&6C3aI-t
zp!z}SN0fy8e*ug8t+BZOi9dGt2P8t=--%YZqr3mUKX&&&cnJw<<n#l|^AJ(O;eQ8<
z``0i-?LrFw<<Z#P{~!h8em%5sMR)(AXsDTJ>KtA{T#B52q_KqmxpavAXxbSB(joT$
zgvUIDfo}iFbg2ChX*k&dwO;}n{-F4m#bQ6M^5X@T@VkU1{$p|>?nf{G1TrA*XGilG
zy8FX(q3%ahx8N-#{E*YH0txQ_g2nw0vBdwJRP63o$bz_k6NG|?E4urqr($<M$9stT
z1Ca8cG70Wy5XNjjT*DIn!8po~2YC>Ow?plRc>vx0emKgHhz}6=BZt2l3GU~?;{GdG
z+`kn^`Y9-YxIY}4esQ^f1CI1_;3KB{HA!&41Qz%EVR65(9QO2cp%~(Rd6>hYG<x{+
z$ze}F8lNHVhc&W6`B#So_p4xWe-IY;7ja^D{|6%7pUa8e{SjE)uTO&e4Y0W19gF*!
zWU;$npoF;a|0{#t{T*1`Z$yIoZLqi>)Fgqp3Th_<149i5cJ~_)>HcyKs99*`=MF6H
zHzmRS9$4HTj3xZ<<8Xffk?y~R!~HL?xZi>V_lIC{zdsiDFX6);{slz3e?A}f@R#_4
znSZTGaDM_8_q$<n|1})>cLI^_zlbCMdSG$C9SQEw!Q%eYSlaLNl(2{Y2B`bR`Je?S
zltM2*XDVS2{|YSbcO=366<FN=0E_#-N@92ag(gT&Uk!CPj6!$+2TAPiUjcQ01ym!b
z{C6S2{ViDB{}7A&4@+Tpe?v3G{h&G%>I5)_?*4sJ*xj%26*K+2li>adSln-eCH-3)
zVR!!qsQWq4%0+bdn;Btue*o0|C!p;oQ22Y1;Ql#S+z)C}LP8a4Cj$e6iXL|NA83WB
zJWRm-@_JCS(9}tMhlIZewEYBfzb^^yUxCH_|FDGrb_?w8pU?que=O8~aN=RW?7wcZ
z!0!HpUl8}h#*aYm4<Nz)Td=r)9v1g2xMFwzhi-`bKf)XirP0%mv@3S^bNt41e=rH|
zKY+#k3$eJr#TJMAdm!%jgiuh|V}^gdEq3>BfV#f{DgB3$;QljM+&>?S`xjVacfZ3#
zh{FS+_QO1Y9{#hfvAf^kFC_et-5*JU`)^=z{~s*wXJf(c{sogD?mtDq{fsa((em$x
ze-QU0kN?Gx;Ql9A-2WG57t;8LC64@CFa_fN^#t;-36A{R@gLLu@g%ta0~Yr$z~X+Z
zChXy_FazTLo3MlfrP0%mX%qJJlfVF(f0zK(2P%J(NO1ojEbh0&;{HWi*xk=C6XJed
z2nBToX8xV4h28xhpzgPTrazGTQ%P_?hY05QgB2F{Ut+`VeuKFXhl@b%hj{=!{Livs
zcfSS`B>Xv``a$l`Ai@12Slka9l7hGjY9|8&!y8uY?hgP}77Ppw8=>~&a{qH!n+h%e
z8ZblL{{yNY<o;|D+^>Me{h3(8KamT&`vpLmg@J+L7}S1T?vLSuh6S4YHCQ3;M;`yl
zBf<STSloXTi~A=#VR!!nP-Vx!!0-aiUFhkj&k4KxC$K@>51ao1g?}Ll?zh0={!}dP
z_l(Ex{tHVWDb1Wf_`AeocmD+ri2IT2uM!g6?}EksX;|FfX@cGT0?Q!o_l6}LD2*Qe
zEhgCAAHW51Kl1o}ISK9$z~cVvSlsW2BmE>m-M@-J`tih(el|eeuL0E$N<UR3xIYGq
z`?;{Ve;W^u@LvfDe~_Kfpa)av;lGgwd-&hrfrLNu{6j4X?$5yD{>xb0@8p8r{S%<>
z-vtdnu;a0`|7~5cyI+A9;(p}tZy>?_C0N{_2P><Q+CPgrvAaKD4J7=72)KW4CwBLH
z@I&1H0qSv3`e`P?{S8>$KOf8d#d{p(&xUmn_lH33hf(P1=M|3f$3g(&e&q3oHWJ+5
zgT?&|u(&_l6npp!tcSQCR({}ef0`-w@ZSJ+KXUu6lLYtAfVy7<YB4DO6tJWpCmi!f
z1yJ|zCs6*|;+Q{j5QKz3a{Ipri~IAS_A{ZSQ-h6=@B{Ukp<Vz}5K%A_Ol0D)UqT3C
z{{yJ|LH_T<Vn43=!!^+G1FcyASp?F*5KH{;#F2g*pzc?I+7B`VgwfOQ798pKhcLwb
zu=E46e<BI)-+{&bi?F!=H;(#q0d(RJH0A<wHw>e@{~M0_GeQK@{ZmMA{}C+ipNqx)
z!P(gJ-v_AsHDC^h(&+B@%f_Dnc0k>aJbyKv1ovOS;{JJ9+;4=V{7~2oN$Gx2cf%-j
z_v_*)KVCrHkDPvHk>LJ2SloXeOZ{o*j6M7dpzbGBe_A?Y4}T9)NcuspKj)I*{ufx>
ze*=sAXX9|c!8S<v6Ka1=!{Pn{aZL9wAi@1#u(&@TOZk1X1AF*C*a30B6I!{7o_?-$
zU=RNpk`VVJ*Z+%2a6f}6X8*eYi~DVHv|kK%L)>pc!2K3D+Akea5ck8%Ur_nEj0E@d
zU~&H~Ea`_ENBg~CFU0+X(hnPs_WKHHi2IS#|4I_vFM-AVv$2#vstMTBkHP_n`$Y-V
zUkVA>)6WH2i2ISpZ`P3Deibb4pM%Byi*S^m4hJFbCscpU#Zi88$V1$ZTz;-6!TknU
z+`kx$`<rpJA0|NEuSg*L>u|ImGO)OR6AA9O!Q%cUSloXENBiNxAxQWWs=xN*Xg{35
z;{L59xZeYd`!8b2zwdFB{{n|0?q5%!{CS0={MS%`q#xw*n;j&$KLm^WK~p*qS3&a}
z0|Ub}9R1e=M<FV?38bHiIQp*{N)Y!W_n&r?;Qj<G?!Ss9{IB6CKQA1ExSvq@c@anX
z`2gyE<nnVL3GUCq;{MxM+<(Fmd->ULk~sGtc7(<yS~}xUg@iw{`wwDqf4@3pO+VT+
z2ZO^Ii2VyB7Q&j2U>dfs0L)=vV92=yaX)Bn5KIh2!}K2oO*(-Dpcs~%VDxS1`cHKG
z1=K*R^%)o{U<D{tKYIJ)8jkg!2I>(1BiA2CvG~7D1LA&k`zN$P?B4)$C=UA@HK5@S
zm4{Io8W8&%Ai)UUKXDw3{kZy%6<E@bBy6q#Y5ZnIE7bjH@$b+9aX)PQ3+67!tQ3sL
zz_7R#>V7o+FLWU8N1lH^MS}ZVu()3qi~9wk^H<Dh_IE(t4_fnza4jUQBJ+80%wJ8=
zg}5KN|8<rG_fNp$ekm;OZ|=e#{ws)de_a>$@IQdX{TE1Z{~Rpt7sKNIo(b69e}YK&
zw@<+C{tsB(f0+dLufXDdaV+ka!{PoHM7m!Rhx--uFw@U965PK9i~B)B(Bc5T=PCq;
z`#Cxx`Ik`o_s8M>04(kY%>~2qKWHxjC?DY}e-3~g%fP^ZJbnf0Qlh(GVG{QAqd}zm
zr6*xeKMh#ie}{zdKZC{n5?IpDi+=3x_aM^!kNdH^e*+fx-^b$q!Z4`)pvXYN8BqHl
z2qOt1>4%A~Sr5^VUjGKng`}SYQZSVe8diV8s<p~cu>JzH;+H{S2Sk5G6ht44gry%C
zza$juf0zK2egO6V4SR?HsQ>&J$^EeOXPOGxR|rvsAa6k9@55Dy7|6Z(%!u+IrXK*t
Cry3Rj

literal 0
HcmV?d00001

-- 
GitLab


From e5159b2a2f0fdd47c644d1655f5a7b57ec7dd509 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Wed, 6 Jan 2021 13:27:17 -0500
Subject: [PATCH 0780/2400] cmd/internal/dwarf: minor cleanups

Remove a stale comment, demote PutInlinedFunc from public to private,
and remove an unused interface originally used for sorting vars.
No change in functionality.

Change-Id: I5ee1ad2b10b78b158e2223c6979bab830202db95
Reviewed-on: https://go-review.googlesource.com/c/go/+/295009
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/internal/dwarf/dwarf.go | 20 +++++---------------
 1 file changed, 5 insertions(+), 15 deletions(-)

diff --git a/src/cmd/internal/dwarf/dwarf.go b/src/cmd/internal/dwarf/dwarf.go
index 8de4096f06..70d792fec6 100644
--- a/src/cmd/internal/dwarf/dwarf.go
+++ b/src/cmd/internal/dwarf/dwarf.go
@@ -318,8 +318,6 @@ const (
 )
 
 // Index into the abbrevs table below.
-// Keep in sync with ispubname() and ispubtype() in ld/dwarf.go.
-// ispubtype considers >= NULLTYPE public
 const (
 	DW_ABRV_NULL = iota
 	DW_ABRV_COMPUNIT
@@ -1257,7 +1255,7 @@ func PutAbstractFunc(ctxt Context, s *FnState) error {
 // its corresponding 'abstract' DIE (containing location-independent
 // attributes such as name, type, etc). Inlined subroutine DIEs can
 // have other inlined subroutine DIEs as children.
-func PutInlinedFunc(ctxt Context, s *FnState, callersym Sym, callIdx int) error {
+func putInlinedFunc(ctxt Context, s *FnState, callersym Sym, callIdx int) error {
 	ic := s.InlCalls.Calls[callIdx]
 	callee := ic.AbsFunSym
 
@@ -1268,7 +1266,7 @@ func PutInlinedFunc(ctxt Context, s *FnState, callersym Sym, callIdx int) error
 	Uleb128put(ctxt, s.Info, int64(abbrev))
 
 	if logDwarf {
-		ctxt.Logf("PutInlinedFunc(caller=%v,callee=%v,abbrev=%d)\n", callersym, callee, abbrev)
+		ctxt.Logf("putInlinedFunc(caller=%v,callee=%v,abbrev=%d)\n", callersym, callee, abbrev)
 	}
 
 	// Abstract origin.
@@ -1304,7 +1302,7 @@ func PutInlinedFunc(ctxt Context, s *FnState, callersym Sym, callIdx int) error
 	// Children of this inline.
 	for _, sib := range inlChildren(callIdx, &s.InlCalls) {
 		absfn := s.InlCalls.Calls[sib].AbsFunSym
-		err := PutInlinedFunc(ctxt, s, absfn, sib)
+		err := putInlinedFunc(ctxt, s, absfn, sib)
 		if err != nil {
 			return err
 		}
@@ -1346,7 +1344,7 @@ func PutConcreteFunc(ctxt Context, s *FnState) error {
 	// Inlined subroutines.
 	for _, sib := range inlChildren(-1, &s.InlCalls) {
 		absfn := s.InlCalls.Calls[sib].AbsFunSym
-		err := PutInlinedFunc(ctxt, s, absfn, sib)
+		err := putInlinedFunc(ctxt, s, absfn, sib)
 		if err != nil {
 			return err
 		}
@@ -1394,7 +1392,7 @@ func PutDefaultFunc(ctxt Context, s *FnState) error {
 	// Inlined subroutines.
 	for _, sib := range inlChildren(-1, &s.InlCalls) {
 		absfn := s.InlCalls.Calls[sib].AbsFunSym
-		err := PutInlinedFunc(ctxt, s, absfn, sib)
+		err := putInlinedFunc(ctxt, s, absfn, sib)
 		if err != nil {
 			return err
 		}
@@ -1600,14 +1598,6 @@ func putvar(ctxt Context, s *FnState, v *Var, absfn Sym, fnabbrev, inlIndex int,
 	// Var has no children => no terminator
 }
 
-// VarsByOffset attaches the methods of sort.Interface to []*Var,
-// sorting in increasing StackOffset.
-type VarsByOffset []*Var
-
-func (s VarsByOffset) Len() int           { return len(s) }
-func (s VarsByOffset) Less(i, j int) bool { return s[i].StackOffset < s[j].StackOffset }
-func (s VarsByOffset) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
-
 // byChildIndex implements sort.Interface for []*dwarf.Var by child index.
 type byChildIndex []*Var
 
-- 
GitLab


From a51daac840482d71d89742871b860a023dbdba0e Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Sun, 14 Feb 2021 00:04:48 +0100
Subject: [PATCH 0781/2400] cmd/link: set SizeOfRawData rather than VirtualSize
 in COFF files for .bss section

GCC and Clang both set the SizeOfRawData field rather than the
VirtualSize field for communicating the size of the .bss section. As a
consequence, LLD does not look at VirtualSize and collapses the .bss
section into whatever is around it, resulting in runtime crashes. This
commit changes the logic so that if the requested "file size" is 0, then
the SizeOfRawData field is set rather than the VirtualSize field as the
sole length marker.

Fixes #44250.
Fixes #39326.
Updates #38755.
Updates #36439.
Updates #43800.

Change-Id: Ied89ddaa0a717fed840238244c6e4848845aeeb6
Reviewed-on: https://go-review.googlesource.com/c/go/+/291630
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/ld/pe.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/cmd/link/internal/ld/pe.go b/src/cmd/link/internal/ld/pe.go
index 36c8e0da9a..46e3df5df1 100644
--- a/src/cmd/link/internal/ld/pe.go
+++ b/src/cmd/link/internal/ld/pe.go
@@ -418,14 +418,16 @@ func (f *peFile) addSection(name string, sectsize int, filesize int) *peSection
 		name:             name,
 		shortName:        name,
 		index:            len(f.sections) + 1,
-		virtualSize:      uint32(sectsize),
 		virtualAddress:   f.nextSectOffset,
 		pointerToRawData: f.nextFileOffset,
 	}
 	f.nextSectOffset = uint32(Rnd(int64(f.nextSectOffset)+int64(sectsize), PESECTALIGN))
 	if filesize > 0 {
+		sect.virtualSize = uint32(sectsize)
 		sect.sizeOfRawData = uint32(Rnd(int64(filesize), PEFILEALIGN))
 		f.nextFileOffset += sect.sizeOfRawData
+	} else {
+		sect.sizeOfRawData = uint32(sectsize)
 	}
 	f.sections = append(f.sections, sect)
 	return sect
-- 
GitLab


From 811167e2c94e1480328513575cdddbc9ad9a7447 Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Sun, 14 Feb 2021 14:44:14 +0100
Subject: [PATCH 0782/2400] cmd/link: do not pass -Bsymbolic for PE DLLs

This is only a valid option on ELF. Binutils accepts it, but LLVM
rejects it, so for Windows, it's best to just omit it.

Updates #44250.
Updates #39326.
Updates #38755.
Updates #36439.
Updates #43800.

Change-Id: Iffd2345d757f23dd737e63bd464cd412527077c4
Reviewed-on: https://go-review.googlesource.com/c/go/+/291632
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/ld/lib.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index 314896824a..28713456c4 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -1343,8 +1343,6 @@ func (ctxt *Link) hostlink() {
 		if ctxt.HeadType == objabi.Hdarwin {
 			argv = append(argv, "-dynamiclib")
 		} else {
-			// ELF.
-			argv = append(argv, "-Wl,-Bsymbolic")
 			if ctxt.UseRelro() {
 				argv = append(argv, "-Wl,-z,relro")
 			}
@@ -1357,6 +1355,8 @@ func (ctxt *Link) hostlink() {
 				// Pass -z nodelete to mark the shared library as
 				// non-closeable: a dlclose will do nothing.
 				argv = append(argv, "-Wl,-z,nodelete")
+				// Only pass Bsymbolic on non-Windows.
+				argv = append(argv, "-Wl,-Bsymbolic")
 			}
 		}
 	case BuildModeShared:
-- 
GitLab


From 91cfbf39e45b130562bbc5b353aa041cfe315faa Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Sun, 14 Feb 2021 19:01:39 +0100
Subject: [PATCH 0783/2400] cmd/link: set .ctors COFF section to writable and
 aligned

Without setting these flags, LLVM's LLD ignores the .ctors section when
merging objects.

Updates #44250.
Updates #39326.
Updates #38755.
Updates #36439.
Updates #43800.

Change-Id: I8766104508f7acd832088a590ee7d68afa0d6065
Reviewed-on: https://go-review.googlesource.com/c/go/+/291633
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/ld/pe.go | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/src/cmd/link/internal/ld/pe.go b/src/cmd/link/internal/ld/pe.go
index 46e3df5df1..a0aba866dc 100644
--- a/src/cmd/link/internal/ld/pe.go
+++ b/src/cmd/link/internal/ld/pe.go
@@ -66,6 +66,8 @@ const (
 	IMAGE_SCN_MEM_WRITE              = 0x80000000
 	IMAGE_SCN_MEM_DISCARDABLE        = 0x2000000
 	IMAGE_SCN_LNK_NRELOC_OVFL        = 0x1000000
+	IMAGE_SCN_ALIGN_4BYTES           = 0x300000
+	IMAGE_SCN_ALIGN_8BYTES           = 0x400000
 	IMAGE_SCN_ALIGN_32BYTES          = 0x600000
 )
 
@@ -478,20 +480,19 @@ func (f *peFile) addInitArray(ctxt *Link) *peSection {
 	// However, the entire Go runtime is initialized from just one function, so it is unlikely
 	// that this will need to grow in the future.
 	var size int
+	var alignment uint32
 	switch objabi.GOARCH {
 	default:
 		Exitf("peFile.addInitArray: unsupported GOARCH=%q\n", objabi.GOARCH)
-	case "386":
-		size = 4
-	case "amd64":
-		size = 8
-	case "arm":
+	case "386", "arm":
 		size = 4
-	case "arm64":
+		alignment = IMAGE_SCN_ALIGN_4BYTES
+	case "amd64", "arm64":
 		size = 8
+		alignment = IMAGE_SCN_ALIGN_8BYTES
 	}
 	sect := f.addSection(".ctors", size, size)
-	sect.characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ
+	sect.characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE | alignment
 	sect.sizeOfRawData = uint32(size)
 	ctxt.Out.SeekSet(int64(sect.pointerToRawData))
 	sect.checkOffset(ctxt.Out.Offset())
-- 
GitLab


From ab331c0254d4462dde6640ec9b00fecc828f4162 Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Sun, 14 Feb 2021 19:43:31 +0100
Subject: [PATCH 0784/2400] runtime/cgo: use correct lean and mean macro

WIN64_LEAN_AND_MEAN is not the correct macro to use and doesn't ever
exist.

Change-Id: I32a5523cc0f7cc3f3a4d022071cf81f88db39aa9
Reviewed-on: https://go-review.googlesource.com/c/go/+/291634
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Trust: Alex Brainman <alex.brainman@gmail.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
---
 src/runtime/cgo/gcc_libinit_windows.c | 2 +-
 src/runtime/cgo/gcc_windows_amd64.c   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/runtime/cgo/gcc_libinit_windows.c b/src/runtime/cgo/gcc_libinit_windows.c
index 2732248bdc..ad5038667a 100644
--- a/src/runtime/cgo/gcc_libinit_windows.c
+++ b/src/runtime/cgo/gcc_libinit_windows.c
@@ -4,7 +4,7 @@
 
 // +build cgo
 
-#define WIN64_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #include <process.h>
 
diff --git a/src/runtime/cgo/gcc_windows_amd64.c b/src/runtime/cgo/gcc_windows_amd64.c
index 25cfd086dd..9df9b9b1e4 100644
--- a/src/runtime/cgo/gcc_windows_amd64.c
+++ b/src/runtime/cgo/gcc_windows_amd64.c
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#define WIN64_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #include <process.h>
 #include <stdlib.h>
-- 
GitLab


From 55d7dcc3cd4b3ee6bca0ab7101866d785776ff51 Mon Sep 17 00:00:00 2001
From: Andy Pan <panjf2000@gmail.com>
Date: Tue, 10 Nov 2020 21:02:18 +0800
Subject: [PATCH 0785/2400] runtime: optimize the memory padding in p struct

Since allocation for p struct will be rounded up to the next size class,
the two relevant adjacent classes for this case are 9728 bytes and 10240 bytes.

A p is currently 10072 bytes, so it gets rounded up to 10240 bytes when we allocate one,
So the pad in p struct is unnecessary, eliminate it and add comments for
warning the false sharing.

Change-Id: Iae8b32931d1beddbfff1f58044d8401703da6407
Reviewed-on: https://go-review.googlesource.com/c/go/+/268759
Reviewed-by: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Ian Lance Taylor <iant@golang.org>
---
 src/runtime/runtime2.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index 5bd283d12f..f5318e6f11 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -5,7 +5,6 @@
 package runtime
 
 import (
-	"internal/cpu"
 	"runtime/internal/atomic"
 	"runtime/internal/sys"
 	"unsafe"
@@ -713,7 +712,8 @@ type p struct {
 	// scheduler ASAP (regardless of what G is running on it).
 	preempt bool
 
-	pad cpu.CacheLinePad
+	// Padding is no longer needed. False sharing is now not a worry because p is large enough
+	// that its size class is an integer multiple of the cache line size (for any of our architectures).
 }
 
 type schedt struct {
-- 
GitLab


From 5e94fe931613111c170e4798131790b3db2bbe90 Mon Sep 17 00:00:00 2001
From: Alberto Donizetti <alb.donizetti@gmail.com>
Date: Tue, 23 Feb 2021 15:05:33 +0100
Subject: [PATCH 0786/2400] go/build/constraint: fix splitPlusBuild func doc
 comment

Noticed while reading the code of the new package; likely a copy-paste
from the splitGoBuild function, which is almost identical.

Change-Id: I869272123708d25d237a4f0445f8e853865747f0
Reviewed-on: https://go-review.googlesource.com/c/go/+/295469
Trust: Alberto Donizetti <alb.donizetti@gmail.com>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/go/build/constraint/expr.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/go/build/constraint/expr.go b/src/go/build/constraint/expr.go
index 3b278702f8..1ef707ceac 100644
--- a/src/go/build/constraint/expr.go
+++ b/src/go/build/constraint/expr.go
@@ -355,8 +355,8 @@ func IsPlusBuild(line string) bool {
 	return ok
 }
 
-// splitGoBuild splits apart the leading //go:build prefix in line from the build expression itself.
-// It returns "", false if the input is not a //go:build line or if the input contains multiple lines.
+// splitPlusBuild splits apart the leading // +build prefix in line from the build expression itself.
+// It returns "", false if the input is not a // +build line or if the input contains multiple lines.
 func splitPlusBuild(line string) (expr string, ok bool) {
 	// A single trailing newline is OK; otherwise multiple lines are not.
 	if len(line) > 0 && line[len(line)-1] == '\n' {
-- 
GitLab


From c7f596f919d779dc01a60f876cbd9d8cc2cd70b2 Mon Sep 17 00:00:00 2001
From: Andy Pan <panjf2000@gmail.com>
Date: Sat, 21 Nov 2020 15:27:00 +0800
Subject: [PATCH 0787/2400] cmd/go: resolve TODO by replacing InDir() function

Change-Id: Idf886bbc4e66c9ee2a41c90034075301e0a21a58
Reviewed-on: https://go-review.googlesource.com/c/go/+/271909
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/search/search.go |  1 -
 src/cmd/go/internal/test/test.go     | 17 +++--------------
 2 files changed, 3 insertions(+), 15 deletions(-)

diff --git a/src/cmd/go/internal/search/search.go b/src/cmd/go/internal/search/search.go
index 18738cf59e..faf3a321dd 100644
--- a/src/cmd/go/internal/search/search.go
+++ b/src/cmd/go/internal/search/search.go
@@ -571,7 +571,6 @@ func IsRelativePath(pattern string) bool {
 // If so, InDir returns an equivalent path relative to dir.
 // If not, InDir returns an empty string.
 // InDir makes some effort to succeed even in the presence of symbolic links.
-// TODO(rsc): Replace internal/test.inDir with a call to this function for Go 1.12.
 func InDir(path, dir string) string {
 	if rel := inDirLex(path, dir); rel != "" {
 		return rel
diff --git a/src/cmd/go/internal/test/test.go b/src/cmd/go/internal/test/test.go
index 7fc9e8fbdc..ea9dfbe4e8 100644
--- a/src/cmd/go/internal/test/test.go
+++ b/src/cmd/go/internal/test/test.go
@@ -29,6 +29,7 @@ import (
 	"cmd/go/internal/cfg"
 	"cmd/go/internal/load"
 	"cmd/go/internal/lockedfile"
+	"cmd/go/internal/search"
 	"cmd/go/internal/str"
 	"cmd/go/internal/trace"
 	"cmd/go/internal/work"
@@ -1499,7 +1500,7 @@ func computeTestInputsID(a *work.Action, testlog []byte) (cache.ActionID, error)
 			if !filepath.IsAbs(name) {
 				name = filepath.Join(pwd, name)
 			}
-			if a.Package.Root == "" || !inDir(name, a.Package.Root) {
+			if a.Package.Root == "" || search.InDir(name, a.Package.Root) == "" {
 				// Do not recheck files outside the module, GOPATH, or GOROOT root.
 				break
 			}
@@ -1508,7 +1509,7 @@ func computeTestInputsID(a *work.Action, testlog []byte) (cache.ActionID, error)
 			if !filepath.IsAbs(name) {
 				name = filepath.Join(pwd, name)
 			}
-			if a.Package.Root == "" || !inDir(name, a.Package.Root) {
+			if a.Package.Root == "" || search.InDir(name, a.Package.Root) == "" {
 				// Do not recheck files outside the module, GOPATH, or GOROOT root.
 				break
 			}
@@ -1526,18 +1527,6 @@ func computeTestInputsID(a *work.Action, testlog []byte) (cache.ActionID, error)
 	return sum, nil
 }
 
-func inDir(path, dir string) bool {
-	if str.HasFilePathPrefix(path, dir) {
-		return true
-	}
-	xpath, err1 := filepath.EvalSymlinks(path)
-	xdir, err2 := filepath.EvalSymlinks(dir)
-	if err1 == nil && err2 == nil && str.HasFilePathPrefix(xpath, xdir) {
-		return true
-	}
-	return false
-}
-
 func hashGetenv(name string) cache.ActionID {
 	h := cache.NewHash("getenv")
 	v, ok := os.LookupEnv(name)
-- 
GitLab


From bf5fa2d19887bd86891447761b45041e500c2a07 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Mon, 22 Feb 2021 19:45:21 -0500
Subject: [PATCH 0788/2400] cmd/compile: guard special register usage with
 GOEXPERIMENT=regabi

Previously, some special register uses are only guarded with ABI
wrapper generation (-abiwrap). This CL makes it also guarded with
the GOEXPERIMENT. This way we can enable only the wrapper
generation without fully the new ABI, for benchmarking purposes.

Change-Id: I90fc34afa1dc17c9c73e7b06e940e79e4c4bf7f6
Reviewed-on: https://go-review.googlesource.com/c/go/+/295289
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/amd64/ssa.go        | 13 +++++++------
 src/cmd/compile/internal/ssa/gen/AMD64.rules |  2 +-
 src/cmd/compile/internal/ssa/rewriteAMD64.go |  5 +++--
 3 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index 4938e4b0e3..6944ba7ce7 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -16,6 +16,7 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/x86"
+	"cmd/internal/objabi"
 )
 
 // markMoves marks any MOVXconst ops that need to avoid clobbering flags.
@@ -845,7 +846,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		if s.ABI != obj.ABIInternal {
 			v.Fatalf("MOVOstorezero can be only used in ABIInternal functions")
 		}
-		if !base.Flag.ABIWrap {
+		if !(objabi.Regabi_enabled == 1 && base.Flag.ABIWrap) {
 			// zeroing X15 manually if wrappers are not used
 			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
 		}
@@ -945,7 +946,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		if s.ABI != obj.ABIInternal {
 			v.Fatalf("MOVOconst can be only used in ABIInternal functions")
 		}
-		if !base.Flag.ABIWrap {
+		if !(objabi.Regabi_enabled == 1 && base.Flag.ABIWrap) {
 			// zeroing X15 manually if wrappers are not used
 			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
 		}
@@ -1017,20 +1018,20 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		// Closure pointer is DX.
 		ssagen.CheckLoweredGetClosurePtr(v)
 	case ssa.OpAMD64LoweredGetG:
-		if base.Flag.ABIWrap {
+		if objabi.Regabi_enabled == 1 && base.Flag.ABIWrap {
 			v.Fatalf("LoweredGetG should not appear in new ABI")
 		}
 		r := v.Reg()
 		getgFromTLS(s, r)
 	case ssa.OpAMD64CALLstatic:
-		if s.ABI == obj.ABI0 && v.Aux.(*ssa.AuxCall).Fn.ABI() == obj.ABIInternal {
+		if objabi.Regabi_enabled == 1 && s.ABI == obj.ABI0 && v.Aux.(*ssa.AuxCall).Fn.ABI() == obj.ABIInternal {
 			// zeroing X15 when entering ABIInternal from ABI0
 			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
 			// set G register from TLS
 			getgFromTLS(s, x86.REG_R14)
 		}
 		s.Call(v)
-		if s.ABI == obj.ABIInternal && v.Aux.(*ssa.AuxCall).Fn.ABI() == obj.ABI0 {
+		if objabi.Regabi_enabled == 1 && s.ABI == obj.ABIInternal && v.Aux.(*ssa.AuxCall).Fn.ABI() == obj.ABI0 {
 			// zeroing X15 when entering ABIInternal from ABI0
 			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
 			// set G register from TLS
@@ -1333,7 +1334,7 @@ func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
 	case ssa.BlockRet:
 		s.Prog(obj.ARET)
 	case ssa.BlockRetJmp:
-		if s.ABI == obj.ABI0 && b.Aux.(*obj.LSym).ABI() == obj.ABIInternal {
+		if objabi.Regabi_enabled == 1 && s.ABI == obj.ABI0 && b.Aux.(*obj.LSym).ABI() == obj.ABIInternal {
 			// zeroing X15 when entering ABIInternal from ABI0
 			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
 			// set G register from TLS
diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules
index 3c75bcfa05..acd2170ea7 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64.rules
+++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules
@@ -459,7 +459,7 @@
 (IsInBounds idx len) => (SETB (CMPQ idx len))
 (IsSliceInBounds idx len) => (SETBE (CMPQ idx len))
 (NilCheck ...) => (LoweredNilCheck ...)
-(GetG mem) && !base.Flag.ABIWrap => (LoweredGetG mem) // only lower in old ABI. in new ABI we have a G register.
+(GetG mem) && !(objabi.Regabi_enabled == 1 && base.Flag.ABIWrap) => (LoweredGetG mem) // only lower in old ABI. in new ABI we have a G register.
 (GetClosurePtr ...) => (LoweredGetClosurePtr ...)
 (GetCallerPC ...) => (LoweredGetCallerPC ...)
 (GetCallerSP ...) => (LoweredGetCallerSP ...)
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index 03498c719c..4074d37d35 100644
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -4,6 +4,7 @@
 package ssa
 
 import "math"
+import "cmd/internal/objabi"
 import "cmd/compile/internal/base"
 import "cmd/compile/internal/types"
 
@@ -30129,11 +30130,11 @@ func rewriteValueAMD64_OpFloor(v *Value) bool {
 func rewriteValueAMD64_OpGetG(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (GetG mem)
-	// cond: !base.Flag.ABIWrap
+	// cond: !(objabi.Regabi_enabled == 1 && base.Flag.ABIWrap)
 	// result: (LoweredGetG mem)
 	for {
 		mem := v_0
-		if !(!base.Flag.ABIWrap) {
+		if !(!(objabi.Regabi_enabled == 1 && base.Flag.ABIWrap)) {
 			break
 		}
 		v.reset(OpAMD64LoweredGetG)
-- 
GitLab


From f1562c761014111ce359b14016718ddabd24c2f2 Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Mon, 15 Feb 2021 20:20:15 +0100
Subject: [PATCH 0789/2400] cmd/go: recognize DLL magic from llvm binaries

When using LLD with c-shared, the magic in the output DLL is slightly
different than for EXEs.

Change-Id: Icc5f34f7bb61f11a9d75494236b7797cc1988b40
Reviewed-on: https://go-review.googlesource.com/c/go/+/291638
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/go/internal/work/exec.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/cmd/go/internal/work/exec.go b/src/cmd/go/internal/work/exec.go
index 422e83c224..d957fa1fcd 100644
--- a/src/cmd/go/internal/work/exec.go
+++ b/src/cmd/go/internal/work/exec.go
@@ -1841,6 +1841,7 @@ var objectMagic = [][]byte{
 	{0xCE, 0xFA, 0xED, 0xFE},                  // Mach-O little-endian 32-bit
 	{0xCF, 0xFA, 0xED, 0xFE},                  // Mach-O little-endian 64-bit
 	{0x4d, 0x5a, 0x90, 0x00, 0x03, 0x00},      // PE (Windows) as generated by 6l/8l and gcc
+	{0x4d, 0x5a, 0x78, 0x00, 0x01, 0x00},      // PE (Windows) as generated by llvm for dll
 	{0x00, 0x00, 0x01, 0xEB},                  // Plan 9 i386
 	{0x00, 0x00, 0x8a, 0x97},                  // Plan 9 amd64
 	{0x00, 0x00, 0x06, 0x47},                  // Plan 9 arm
-- 
GitLab


From 42cd40ee74050391e4714eefa8aeb0242b93b0f5 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Fri, 12 Feb 2021 15:55:25 -0800
Subject: [PATCH 0790/2400] cmd/compile: improve bit test code

Some bit test instruction generation stopped triggering after
the change to addressing modes. I suspect this was just because
ANDQload was being generated before the rewrite rules could discover
the BTQ. Fix that by decomposing the ANDQload when it is surrounded
by a TESTQ (thus re-enabling the BTQ rules).

Fixes #44228

Change-Id: I489b4a5a7eb01c65fc8db0753f8cec54097cadb2
Reviewed-on: https://go-review.googlesource.com/c/go/+/291749
Trust: Keith Randall <khr@golang.org>
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Keith Randall <khr@golang.org>
Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>
---
 src/cmd/compile/internal/ssa/gen/AMD64.rules |  5 ++
 src/cmd/compile/internal/ssa/rewriteAMD64.go | 54 ++++++++++++++++++++
 test/codegen/bits.go                         |  9 ++++
 3 files changed, 68 insertions(+)

diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules
index acd2170ea7..01a8a16456 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64.rules
+++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules
@@ -2191,6 +2191,11 @@
 	&& clobber(l) =>
   @l.Block (CMP(Q|L|W|B)constload {sym} [makeValAndOff64(0, int64(off))] ptr mem)
 
+// Convert ANDload to MOVload when we can do the AND in a containing TEST op.
+// Only do when it's within the same block, so we don't have flags live across basic block boundaries.
+// See issue 44228.
+(TEST(Q|L) a:(AND(Q|L)load [off] {sym} x ptr mem) a) && a.Uses == 2 && a.Block == v.Block && clobber(a) => (TEST(Q|L) (MOV(Q|L)load <a.Type> [off] {sym} ptr mem) x)
+
 (MOVBload [off] {sym} (SB) _) && symIsRO(sym) => (MOVLconst [int32(read8(sym, int64(off)))])
 (MOVWload [off] {sym} (SB) _) && symIsRO(sym) => (MOVLconst [int32(read16(sym, int64(off), config.ctxt.Arch.ByteOrder))])
 (MOVLload [off] {sym} (SB) _) && symIsRO(sym) => (MOVQconst [int64(read32(sym, int64(off), config.ctxt.Arch.ByteOrder))])
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index 4074d37d35..5fb6c303fd 100644
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -27141,6 +27141,33 @@ func rewriteValueAMD64_OpAMD64TESTL(v *Value) bool {
 		}
 		break
 	}
+	// match: (TESTL a:(ANDLload [off] {sym} x ptr mem) a)
+	// cond: a.Uses == 2 && a.Block == v.Block && clobber(a)
+	// result: (TESTL (MOVLload <a.Type> [off] {sym} ptr mem) x)
+	for {
+		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
+			a := v_0
+			if a.Op != OpAMD64ANDLload {
+				continue
+			}
+			off := auxIntToInt32(a.AuxInt)
+			sym := auxToSym(a.Aux)
+			mem := a.Args[2]
+			x := a.Args[0]
+			ptr := a.Args[1]
+			if a != v_1 || !(a.Uses == 2 && a.Block == v.Block && clobber(a)) {
+				continue
+			}
+			v.reset(OpAMD64TESTL)
+			v0 := b.NewValue0(a.Pos, OpAMD64MOVLload, a.Type)
+			v0.AuxInt = int32ToAuxInt(off)
+			v0.Aux = symToAux(sym)
+			v0.AddArg2(ptr, mem)
+			v.AddArg2(v0, x)
+			return true
+		}
+		break
+	}
 	return false
 }
 func rewriteValueAMD64_OpAMD64TESTLconst(v *Value) bool {
@@ -27246,6 +27273,33 @@ func rewriteValueAMD64_OpAMD64TESTQ(v *Value) bool {
 		}
 		break
 	}
+	// match: (TESTQ a:(ANDQload [off] {sym} x ptr mem) a)
+	// cond: a.Uses == 2 && a.Block == v.Block && clobber(a)
+	// result: (TESTQ (MOVQload <a.Type> [off] {sym} ptr mem) x)
+	for {
+		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
+			a := v_0
+			if a.Op != OpAMD64ANDQload {
+				continue
+			}
+			off := auxIntToInt32(a.AuxInt)
+			sym := auxToSym(a.Aux)
+			mem := a.Args[2]
+			x := a.Args[0]
+			ptr := a.Args[1]
+			if a != v_1 || !(a.Uses == 2 && a.Block == v.Block && clobber(a)) {
+				continue
+			}
+			v.reset(OpAMD64TESTQ)
+			v0 := b.NewValue0(a.Pos, OpAMD64MOVQload, a.Type)
+			v0.AuxInt = int32ToAuxInt(off)
+			v0.Aux = symToAux(sym)
+			v0.AddArg2(ptr, mem)
+			v.AddArg2(v0, x)
+			return true
+		}
+		break
+	}
 	return false
 }
 func rewriteValueAMD64_OpAMD64TESTQconst(v *Value) bool {
diff --git a/test/codegen/bits.go b/test/codegen/bits.go
index 4508eba487..806dad13c8 100644
--- a/test/codegen/bits.go
+++ b/test/codegen/bits.go
@@ -352,3 +352,12 @@ func cont0Mask64U(x uint64) uint64 {
 	// s390x:"RISBGZ\t[$]48, [$]15, [$]0,"
 	return x & 0xffff00000000ffff
 }
+
+func issue44228a(a []int64, i int) bool {
+	// amd64: "BTQ", -"SHL"
+	return a[i>>6]&(1<<(i&63)) != 0
+}
+func issue44228b(a []int32, i int) bool {
+	// amd64: "BTL", -"SHL"
+	return a[i>>5]&(1<<(i&31)) != 0
+}
-- 
GitLab


From 74cac8d47937af01bd9653df8d601b08843d3808 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Wed, 7 Oct 2020 09:44:16 -0400
Subject: [PATCH 0791/2400] cmd/compile: add AMD64 parameter register defs, Arg
 ops, plumb to ssa.Config

This is partial plumbing recycled from the original register abi test work;
these are the parts that translate easily.  Some other bits are deferred till
later when they are ready to be used.

For #40724.

Change-Id: Ica8c55a4526793446189725a2bc3839124feb38f
Reviewed-on: https://go-review.googlesource.com/c/go/+/260539
Trust: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/config.go        | 56 ++++++++++-------
 src/cmd/compile/internal/ssa/gen/AMD64Ops.go  | 25 ++++----
 .../compile/internal/ssa/gen/genericOps.go    |  6 ++
 src/cmd/compile/internal/ssa/gen/main.go      | 62 ++++++++++++++-----
 src/cmd/compile/internal/ssa/op.go            |  4 ++
 src/cmd/compile/internal/ssa/opGen.go         | 36 +++++++++++
 src/runtime/stack.go                          |  2 +-
 7 files changed, 141 insertions(+), 50 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go
index f3a3a88a66..07508d6e83 100644
--- a/src/cmd/compile/internal/ssa/config.go
+++ b/src/cmd/compile/internal/ssa/config.go
@@ -5,6 +5,7 @@
 package ssa
 
 import (
+	"cmd/compile/internal/abi"
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
@@ -21,29 +22,33 @@ type Config struct {
 	PtrSize        int64  // 4 or 8; copy of cmd/internal/sys.Arch.PtrSize
 	RegSize        int64  // 4 or 8; copy of cmd/internal/sys.Arch.RegSize
 	Types          Types
-	lowerBlock     blockRewriter // lowering function
-	lowerValue     valueRewriter // lowering function
-	splitLoad      valueRewriter // function for splitting merged load ops; only used on some architectures
-	registers      []Register    // machine registers
-	gpRegMask      regMask       // general purpose integer register mask
-	fpRegMask      regMask       // floating point register mask
-	fp32RegMask    regMask       // floating point register mask
-	fp64RegMask    regMask       // floating point register mask
-	specialRegMask regMask       // special register mask
-	GCRegMap       []*Register   // garbage collector register map, by GC register index
-	FPReg          int8          // register number of frame pointer, -1 if not used
-	LinkReg        int8          // register number of link register if it is a general purpose register, -1 if not used
-	hasGReg        bool          // has hardware g register
-	ctxt           *obj.Link     // Generic arch information
-	optimize       bool          // Do optimization
-	noDuffDevice   bool          // Don't use Duff's device
-	useSSE         bool          // Use SSE for non-float operations
-	useAvg         bool          // Use optimizations that need Avg* operations
-	useHmul        bool          // Use optimizations that need Hmul* operations
-	SoftFloat      bool          //
-	Race           bool          // race detector enabled
-	BigEndian      bool          //
-	UseFMA         bool          // Use hardware FMA operation
+	lowerBlock     blockRewriter  // lowering function
+	lowerValue     valueRewriter  // lowering function
+	splitLoad      valueRewriter  // function for splitting merged load ops; only used on some architectures
+	registers      []Register     // machine registers
+	gpRegMask      regMask        // general purpose integer register mask
+	fpRegMask      regMask        // floating point register mask
+	fp32RegMask    regMask        // floating point register mask
+	fp64RegMask    regMask        // floating point register mask
+	specialRegMask regMask        // special register mask
+	intParamRegs   []int8         // register numbers of integer param (in/out) registers
+	floatParamRegs []int8         // register numbers of floating param (in/out) registers
+	ABI1           *abi.ABIConfig // "ABIInternal" under development // TODO change comment when this becomes current
+	ABI0           *abi.ABIConfig
+	GCRegMap       []*Register // garbage collector register map, by GC register index
+	FPReg          int8        // register number of frame pointer, -1 if not used
+	LinkReg        int8        // register number of link register if it is a general purpose register, -1 if not used
+	hasGReg        bool        // has hardware g register
+	ctxt           *obj.Link   // Generic arch information
+	optimize       bool        // Do optimization
+	noDuffDevice   bool        // Don't use Duff's device
+	useSSE         bool        // Use SSE for non-float operations
+	useAvg         bool        // Use optimizations that need Avg* operations
+	useHmul        bool        // Use optimizations that need Hmul* operations
+	SoftFloat      bool        //
+	Race           bool        // race detector enabled
+	BigEndian      bool        //
+	UseFMA         bool        // Use hardware FMA operation
 }
 
 type (
@@ -195,6 +200,8 @@ func NewConfig(arch string, types Types, ctxt *obj.Link, optimize bool) *Config
 		c.gpRegMask = gpRegMaskAMD64
 		c.fpRegMask = fpRegMaskAMD64
 		c.specialRegMask = specialRegMaskAMD64
+		c.intParamRegs = paramIntRegAMD64
+		c.floatParamRegs = paramFloatRegAMD64
 		c.FPReg = framepointerRegAMD64
 		c.LinkReg = linkRegAMD64
 		c.hasGReg = base.Flag.ABIWrap
@@ -326,6 +333,9 @@ func NewConfig(arch string, types Types, ctxt *obj.Link, optimize bool) *Config
 	c.useSSE = true
 	c.UseFMA = true
 
+	c.ABI0 = abi.NewABIConfig(0, 0)
+	c.ABI1 = abi.NewABIConfig(len(c.intParamRegs), len(c.floatParamRegs))
+
 	// On Plan 9, floating point operations are not allowed in note handler.
 	if objabi.GOOS == "plan9" {
 		// Don't use FMA on Plan 9
diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
index 043162e544..96475672a8 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
+++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 package main
@@ -929,16 +930,18 @@ func init() {
 	}
 
 	archs = append(archs, arch{
-		name:            "AMD64",
-		pkg:             "cmd/internal/obj/x86",
-		genfile:         "../../amd64/ssa.go",
-		ops:             AMD64ops,
-		blocks:          AMD64blocks,
-		regnames:        regNamesAMD64,
-		gpregmask:       gp,
-		fpregmask:       fp,
-		specialregmask:  x15,
-		framepointerreg: int8(num["BP"]),
-		linkreg:         -1, // not used
+		name:               "AMD64",
+		pkg:                "cmd/internal/obj/x86",
+		genfile:            "../../amd64/ssa.go",
+		ops:                AMD64ops,
+		blocks:             AMD64blocks,
+		regnames:           regNamesAMD64,
+		ParamIntRegNames:   "AX BX CX DI SI R8 R9 R10 R11",
+		ParamFloatRegNames: "X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14",
+		gpregmask:          gp,
+		fpregmask:          fp,
+		specialregmask:     x15,
+		framepointerreg:    int8(num["BP"]),
+		linkreg:            -1, // not used
 	})
 }
diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go
index 8cfda35c22..23a2d74b14 100644
--- a/src/cmd/compile/internal/ssa/gen/genericOps.go
+++ b/src/cmd/compile/internal/ssa/gen/genericOps.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 package main
@@ -332,6 +333,11 @@ var genericOps = []opData{
 	{name: "InitMem", zeroWidth: true},                               // memory input to the function.
 	{name: "Arg", aux: "SymOff", symEffect: "Read", zeroWidth: true}, // argument to the function.  aux=GCNode of arg, off = offset in that arg.
 
+	// Like Arg, these are generic ops that survive lowering. AuxInt is a register index, and the actual output register for each index is defined by the architecture.
+	// AuxInt = integer argument index (not a register number). ABI-specified spill loc obtained from function
+	{name: "ArgIntReg", aux: "Int8", zeroWidth: true},   // argument to the function in an int reg.
+	{name: "ArgFloatReg", aux: "Int8", zeroWidth: true}, // argument to the function in a float reg.
+
 	// The address of a variable.  arg0 is the base pointer.
 	// If the variable is a global, the base pointer will be SB and
 	// the Aux field will be a *obj.LSym.
diff --git a/src/cmd/compile/internal/ssa/gen/main.go b/src/cmd/compile/internal/ssa/gen/main.go
index e7a4ef0629..f5385389c3 100644
--- a/src/cmd/compile/internal/ssa/gen/main.go
+++ b/src/cmd/compile/internal/ssa/gen/main.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 // The gen command generates Go code (in the parent directory) for all
@@ -30,21 +31,23 @@ import (
 // apart from type names, and avoid awkward func parameters like "arch arch".
 
 type arch struct {
-	name            string
-	pkg             string // obj package to import for this arch.
-	genfile         string // source file containing opcode code generation.
-	ops             []opData
-	blocks          []blockData
-	regnames        []string
-	gpregmask       regMask
-	fpregmask       regMask
-	fp32regmask     regMask
-	fp64regmask     regMask
-	specialregmask  regMask
-	framepointerreg int8
-	linkreg         int8
-	generic         bool
-	imports         []string
+	name               string
+	pkg                string // obj package to import for this arch.
+	genfile            string // source file containing opcode code generation.
+	ops                []opData
+	blocks             []blockData
+	regnames           []string
+	ParamIntRegNames   string
+	ParamFloatRegNames string
+	gpregmask          regMask
+	fpregmask          regMask
+	fp32regmask        regMask
+	fp64regmask        regMask
+	specialregmask     regMask
+	framepointerreg    int8
+	linkreg            int8
+	generic            bool
+	imports            []string
 }
 
 type opData struct {
@@ -412,7 +415,9 @@ func genOp() {
 		}
 		fmt.Fprintf(w, "var registers%s = [...]Register {\n", a.name)
 		var gcRegN int
+		num := map[string]int8{}
 		for i, r := range a.regnames {
+			num[r] = int8(i)
 			pkg := a.pkg[len("cmd/internal/obj/"):]
 			var objname string // name in cmd/internal/obj/$ARCH
 			switch r {
@@ -435,11 +440,38 @@ func genOp() {
 			}
 			fmt.Fprintf(w, "  {%d, %s, %d, \"%s\"},\n", i, objname, gcRegIdx, r)
 		}
+		parameterRegisterList := func(paramNamesString string) []int8 {
+			paramNamesString = strings.TrimSpace(paramNamesString)
+			if paramNamesString == "" {
+				return nil
+			}
+			paramNames := strings.Split(paramNamesString, " ")
+			var paramRegs []int8
+			for _, regName := range paramNames {
+				if regName == "" {
+					// forgive extra spaces
+					continue
+				}
+				if regNum, ok := num[regName]; ok {
+					paramRegs = append(paramRegs, regNum)
+					delete(num, regName)
+				} else {
+					log.Fatalf("parameter register %s for architecture %s not a register name (or repeated in parameter list)", regName, a.name)
+				}
+			}
+			return paramRegs
+		}
+
+		paramIntRegs := parameterRegisterList(a.ParamIntRegNames)
+		paramFloatRegs := parameterRegisterList(a.ParamFloatRegNames)
+
 		if gcRegN > 32 {
 			// Won't fit in a uint32 mask.
 			log.Fatalf("too many GC registers (%d > 32) on %s", gcRegN, a.name)
 		}
 		fmt.Fprintln(w, "}")
+		fmt.Fprintf(w, "var paramIntReg%s = %#v\n", a.name, paramIntRegs)
+		fmt.Fprintf(w, "var paramFloatReg%s = %#v\n", a.name, paramFloatRegs)
 		fmt.Fprintf(w, "var gpRegMask%s = regMask(%d)\n", a.name, a.gpregmask)
 		fmt.Fprintf(w, "var fpRegMask%s = regMask(%d)\n", a.name, a.fpregmask)
 		if a.fp32regmask != 0 {
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index f41d014d41..cf0d2affc7 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -79,6 +79,7 @@ type AuxCall struct {
 	Fn      *obj.LSym
 	args    []Param // Includes receiver for method calls.  Does NOT include hidden closure pointer.
 	results []Param
+	reg     *regInfo // regInfo for this call // TODO for now nil means ignore
 }
 
 // ResultForOffset returns the index of the result at a particular offset among the results
@@ -186,16 +187,19 @@ func (a *AuxCall) String() string {
 
 // StaticAuxCall returns an AuxCall for a static call.
 func StaticAuxCall(sym *obj.LSym, args []Param, results []Param) *AuxCall {
+	// TODO Create regInfo for AuxCall
 	return &AuxCall{Fn: sym, args: args, results: results}
 }
 
 // InterfaceAuxCall returns an AuxCall for an interface call.
 func InterfaceAuxCall(args []Param, results []Param) *AuxCall {
+	// TODO Create regInfo for AuxCall
 	return &AuxCall{Fn: nil, args: args, results: results}
 }
 
 // ClosureAuxCall returns an AuxCall for a closure call.
 func ClosureAuxCall(args []Param, results []Param) *AuxCall {
+	// TODO Create regInfo for AuxCall
 	return &AuxCall{Fn: nil, args: args, results: results}
 }
 
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index e4087bd021..ba170968ae 100644
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -2747,6 +2747,8 @@ const (
 	OpConstSlice
 	OpInitMem
 	OpArg
+	OpArgIntReg
+	OpArgFloatReg
 	OpAddr
 	OpLocalAddr
 	OpSP
@@ -35253,6 +35255,20 @@ var opcodeTable = [...]opInfo{
 		symEffect: SymRead,
 		generic:   true,
 	},
+	{
+		name:      "ArgIntReg",
+		auxType:   auxInt8,
+		argLen:    0,
+		zeroWidth: true,
+		generic:   true,
+	},
+	{
+		name:      "ArgFloatReg",
+		auxType:   auxInt8,
+		argLen:    0,
+		zeroWidth: true,
+		generic:   true,
+	},
 	{
 		name:      "Addr",
 		auxType:   auxSym,
@@ -36141,6 +36157,8 @@ var registers386 = [...]Register{
 	{15, x86.REG_X7, -1, "X7"},
 	{16, 0, -1, "SB"},
 }
+var paramIntReg386 = []int8(nil)
+var paramFloatReg386 = []int8(nil)
 var gpRegMask386 = regMask(239)
 var fpRegMask386 = regMask(65280)
 var specialRegMask386 = regMask(0)
@@ -36181,6 +36199,8 @@ var registersAMD64 = [...]Register{
 	{31, x86.REG_X15, -1, "X15"},
 	{32, 0, -1, "SB"},
 }
+var paramIntRegAMD64 = []int8{0, 3, 1, 7, 6, 8, 9, 10, 11}
+var paramFloatRegAMD64 = []int8{16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30}
 var gpRegMaskAMD64 = regMask(49135)
 var fpRegMaskAMD64 = regMask(2147418112)
 var specialRegMaskAMD64 = regMask(2147483648)
@@ -36221,6 +36241,8 @@ var registersARM = [...]Register{
 	{31, arm.REG_F15, -1, "F15"},
 	{32, 0, -1, "SB"},
 }
+var paramIntRegARM = []int8(nil)
+var paramFloatRegARM = []int8(nil)
 var gpRegMaskARM = regMask(21503)
 var fpRegMaskARM = regMask(4294901760)
 var specialRegMaskARM = regMask(0)
@@ -36292,6 +36314,8 @@ var registersARM64 = [...]Register{
 	{62, arm64.REG_F31, -1, "F31"},
 	{63, 0, -1, "SB"},
 }
+var paramIntRegARM64 = []int8(nil)
+var paramFloatRegARM64 = []int8(nil)
 var gpRegMaskARM64 = regMask(670826495)
 var fpRegMaskARM64 = regMask(9223372034707292160)
 var specialRegMaskARM64 = regMask(0)
@@ -36347,6 +36371,8 @@ var registersMIPS = [...]Register{
 	{46, mips.REG_LO, -1, "LO"},
 	{47, 0, -1, "SB"},
 }
+var paramIntRegMIPS = []int8(nil)
+var paramFloatRegMIPS = []int8(nil)
 var gpRegMaskMIPS = regMask(335544318)
 var fpRegMaskMIPS = regMask(35183835217920)
 var specialRegMaskMIPS = regMask(105553116266496)
@@ -36417,6 +36443,8 @@ var registersMIPS64 = [...]Register{
 	{61, mips.REG_LO, -1, "LO"},
 	{62, 0, -1, "SB"},
 }
+var paramIntRegMIPS64 = []int8(nil)
+var paramFloatRegMIPS64 = []int8(nil)
 var gpRegMaskMIPS64 = regMask(167772158)
 var fpRegMaskMIPS64 = regMask(1152921504338411520)
 var specialRegMaskMIPS64 = regMask(3458764513820540928)
@@ -36488,6 +36516,8 @@ var registersPPC64 = [...]Register{
 	{62, ppc64.REG_F30, -1, "F30"},
 	{63, ppc64.REG_F31, -1, "F31"},
 }
+var paramIntRegPPC64 = []int8(nil)
+var paramFloatRegPPC64 = []int8(nil)
 var gpRegMaskPPC64 = regMask(1073733624)
 var fpRegMaskPPC64 = regMask(576460743713488896)
 var specialRegMaskPPC64 = regMask(0)
@@ -36559,6 +36589,8 @@ var registersRISCV64 = [...]Register{
 	{62, riscv.REG_F31, -1, "F31"},
 	{63, 0, -1, "SB"},
 }
+var paramIntRegRISCV64 = []int8(nil)
+var paramFloatRegRISCV64 = []int8(nil)
 var gpRegMaskRISCV64 = regMask(1006632948)
 var fpRegMaskRISCV64 = regMask(9223372034707292160)
 var specialRegMaskRISCV64 = regMask(0)
@@ -36599,6 +36631,8 @@ var registersS390X = [...]Register{
 	{31, s390x.REG_F15, -1, "F15"},
 	{32, 0, -1, "SB"},
 }
+var paramIntRegS390X = []int8(nil)
+var paramFloatRegS390X = []int8(nil)
 var gpRegMaskS390X = regMask(23551)
 var fpRegMaskS390X = regMask(4294901760)
 var specialRegMaskS390X = regMask(0)
@@ -36657,6 +36691,8 @@ var registersWasm = [...]Register{
 	{49, wasm.REGG, -1, "g"},
 	{50, 0, -1, "SB"},
 }
+var paramIntRegWasm = []int8(nil)
+var paramFloatRegWasm = []int8(nil)
 var gpRegMaskWasm = regMask(65535)
 var fpRegMaskWasm = regMask(281474976645120)
 var fp32RegMaskWasm = regMask(4294901760)
diff --git a/src/runtime/stack.go b/src/runtime/stack.go
index d971e5e26f..c572f7296f 100644
--- a/src/runtime/stack.go
+++ b/src/runtime/stack.go
@@ -112,7 +112,7 @@ const (
 	stackDebug       = 0
 	stackFromSystem  = 0 // allocate stacks from system memory instead of the heap
 	stackFaultOnFree = 0 // old stacks are mapped noaccess to detect use after free
-	stackPoisonCopy  = 0 // fill stack that should not be accessed with garbage, to detect bad dereferences during copy
+	stackPoisonCopy  = 1 // fill stack that should not be accessed with garbage, to detect bad dereferences during copy
 	stackNoCache     = 0 // disable per-P small stack caches
 
 	// check the BP links during traceback.
-- 
GitLab


From 080119799bb9cbace0d20bcc671497a53e3ec14e Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 23 Feb 2021 11:38:24 -0500
Subject: [PATCH 0792/2400] runtime: fix usleep on windows/arm

Changed calling convention to pre-multiply the argument by -100,
and then deleted the * 100 but not the negation in the windows/arm assembly.
Delete the negation.

Fixes the current all.bash breakage on windows/arm builder.
(Maybe that will uncover more.)

Change-Id: I13006a44866ecc007586deb180a49c038d70aa99
Reviewed-on: https://go-review.googlesource.com/c/go/+/295529
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/sys_windows_arm.s | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/runtime/sys_windows_arm.s b/src/runtime/sys_windows_arm.s
index 4be5ce7da0..9a5d9b1dd4 100644
--- a/src/runtime/sys_windows_arm.s
+++ b/src/runtime/sys_windows_arm.s
@@ -375,12 +375,11 @@ TEXT runtime·tstart_stdcall(SB),NOSPLIT|NOFRAME,$0
 // duration (in -100ns units) is in dt+0(FP).
 // g may be nil.
 TEXT runtime·usleep2(SB),NOSPLIT|NOFRAME,$0-4
-	MOVW	dt+0(FP), R0
+	MOVW	dt+0(FP), R3
 	MOVM.DB.W [R4, R14], (R13)	// push {r4, lr}
 	MOVW	R13, R4			// Save SP
 	SUB	$8, R13			// R13 = R13 - 8
 	BIC	$0x7, R13		// Align SP for ABI
-	RSB	$0, R0, R3		// R3 = -R0
 	MOVW	$0, R1			// R1 = FALSE (alertable)
 	MOVW	$-1, R0			// R0 = handle
 	MOVW	R13, R2			// R2 = pTime
-- 
GitLab


From c584f42dcf43351e4cd1e5df22a063f020c00777 Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Mon, 30 Nov 2020 23:47:27 +1100
Subject: [PATCH 0793/2400] cmd/compile: change riscv64 Eq32/Neq32 to zero
 extend before subtraction

As done with other equality tests, zero extend before subtraction rather than
after (or in this case, at the same time). While at face value this appears to
require more instructions, in reality it allows for most sign extensions to
be completely eliminated due to correctly typed loads. Existing optimisations
(such as subtraction of zero) then become more effective.

This removes more than 10,000 instructions from the Go binary and in particular,
a writeBarrier check only requires three instructions (AUIPC, LWU, BNEZ) instead
of the current four (AUIPC, LWU, NEGW, BNEZ).

Change-Id: I7afdc1921c4916ddbd414c3b3f5c2089107ec016
Reviewed-on: https://go-review.googlesource.com/c/go/+/274066
Trust: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
---
 .../compile/internal/ssa/gen/RISCV64.rules    |  4 ++--
 .../compile/internal/ssa/rewriteRISCV64.go    | 22 ++++++++++++++-----
 2 files changed, 18 insertions(+), 8 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/gen/RISCV64.rules b/src/cmd/compile/internal/ssa/gen/RISCV64.rules
index 4380a5efef..15361fd37a 100644
--- a/src/cmd/compile/internal/ssa/gen/RISCV64.rules
+++ b/src/cmd/compile/internal/ssa/gen/RISCV64.rules
@@ -251,7 +251,7 @@
 
 (EqPtr x y) => (SEQZ (SUB <x.Type> x y))
 (Eq64  x y) => (SEQZ (SUB <x.Type> x y))
-(Eq32  x y) => (SEQZ (SUBW <x.Type> x y))
+(Eq32  x y) => (SEQZ (SUB <x.Type> (ZeroExt32to64 x) (ZeroExt32to64 y)))
 (Eq16  x y) => (SEQZ (SUB <x.Type> (ZeroExt16to64 x) (ZeroExt16to64 y)))
 (Eq8   x y) => (SEQZ (SUB <x.Type> (ZeroExt8to64  x) (ZeroExt8to64  y)))
 (Eq64F ...) => (FEQD ...)
@@ -259,7 +259,7 @@
 
 (NeqPtr x y) => (SNEZ (SUB <x.Type> x y))
 (Neq64  x y) => (SNEZ (SUB <x.Type> x y))
-(Neq32  x y) => (SNEZ (SUBW <x.Type> x y))
+(Neq32  x y) => (SNEZ (SUB <x.Type> (ZeroExt32to64 x) (ZeroExt32to64 y)))
 (Neq16  x y) => (SNEZ (SUB <x.Type> (ZeroExt16to64 x) (ZeroExt16to64 y)))
 (Neq8   x y) => (SNEZ (SUB <x.Type> (ZeroExt8to64  x) (ZeroExt8to64  y)))
 (Neq64F ...) => (FNED ...)
diff --git a/src/cmd/compile/internal/ssa/rewriteRISCV64.go b/src/cmd/compile/internal/ssa/rewriteRISCV64.go
index fb507b65c4..1abdf1aa06 100644
--- a/src/cmd/compile/internal/ssa/rewriteRISCV64.go
+++ b/src/cmd/compile/internal/ssa/rewriteRISCV64.go
@@ -890,14 +890,19 @@ func rewriteValueRISCV64_OpEq32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
+	typ := &b.Func.Config.Types
 	// match: (Eq32 x y)
-	// result: (SEQZ (SUBW <x.Type> x y))
+	// result: (SEQZ (SUB <x.Type> (ZeroExt32to64 x) (ZeroExt32to64 y)))
 	for {
 		x := v_0
 		y := v_1
 		v.reset(OpRISCV64SEQZ)
-		v0 := b.NewValue0(v.Pos, OpRISCV64SUBW, x.Type)
-		v0.AddArg2(x, y)
+		v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
+		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
+		v1.AddArg(x)
+		v2 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
+		v2.AddArg(y)
+		v0.AddArg2(v1, v2)
 		v.AddArg(v0)
 		return true
 	}
@@ -2466,14 +2471,19 @@ func rewriteValueRISCV64_OpNeq32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
+	typ := &b.Func.Config.Types
 	// match: (Neq32 x y)
-	// result: (SNEZ (SUBW <x.Type> x y))
+	// result: (SNEZ (SUB <x.Type> (ZeroExt32to64 x) (ZeroExt32to64 y)))
 	for {
 		x := v_0
 		y := v_1
 		v.reset(OpRISCV64SNEZ)
-		v0 := b.NewValue0(v.Pos, OpRISCV64SUBW, x.Type)
-		v0.AddArg2(x, y)
+		v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
+		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
+		v1.AddArg(x)
+		v2 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
+		v2.AddArg(y)
+		v0.AddArg2(v1, v2)
 		v.AddArg(v0)
 		return true
 	}
-- 
GitLab


From a671e33c6daded6639e0cd97b4791c4468475e71 Mon Sep 17 00:00:00 2001
From: Tamir Duberstein <tamird@google.com>
Date: Thu, 12 Nov 2020 17:42:58 -0500
Subject: [PATCH 0794/2400] all: use more precise build tags

s/!gccgo/gc/ in files which use gc-syntax assembly.

Change-Id: Ifdadb62edd1210ebc70e7cd415648b752afaf067
Reviewed-on: https://go-review.googlesource.com/c/go/+/269957
Reviewed-by: Than McIntosh <thanm@google.com>
Trust: David Chase <drchase@google.com>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 misc/cgo/test/testdata/issue9400/asm_386.s     | 2 +-
 misc/cgo/test/testdata/issue9400/asm_amd64x.s  | 2 +-
 misc/cgo/test/testdata/issue9400/asm_arm.s     | 2 +-
 misc/cgo/test/testdata/issue9400/asm_arm64.s   | 2 +-
 misc/cgo/test/testdata/issue9400/asm_mips64x.s | 2 +-
 misc/cgo/test/testdata/issue9400/asm_mipsx.s   | 2 +-
 misc/cgo/test/testdata/issue9400/asm_ppc64x.s  | 2 +-
 misc/cgo/test/testdata/issue9400/asm_riscv64.s | 2 +-
 misc/cgo/test/testdata/issue9400/asm_s390x.s   | 2 +-
 misc/cgo/testshared/testdata/depBase/asm.s     | 2 +-
 misc/cgo/testshared/testdata/depBase/stubs.go  | 2 +-
 src/cmd/dist/util_gc.go                        | 4 ++--
 src/cmd/go/testdata/script/build_overlay.txt   | 2 +-
 13 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/misc/cgo/test/testdata/issue9400/asm_386.s b/misc/cgo/test/testdata/issue9400/asm_386.s
index 7f158b5c39..96b8b60c10 100644
--- a/misc/cgo/test/testdata/issue9400/asm_386.s
+++ b/misc/cgo/test/testdata/issue9400/asm_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !gccgo
+// +build gc
 
 #include "textflag.h"
 
diff --git a/misc/cgo/test/testdata/issue9400/asm_amd64x.s b/misc/cgo/test/testdata/issue9400/asm_amd64x.s
index 48b86190a5..99509bce5e 100644
--- a/misc/cgo/test/testdata/issue9400/asm_amd64x.s
+++ b/misc/cgo/test/testdata/issue9400/asm_amd64x.s
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.
 
 // +build amd64 amd64p32
-// +build !gccgo
+// +build gc
 
 #include "textflag.h"
 
diff --git a/misc/cgo/test/testdata/issue9400/asm_arm.s b/misc/cgo/test/testdata/issue9400/asm_arm.s
index 96c278520f..cc92856c2f 100644
--- a/misc/cgo/test/testdata/issue9400/asm_arm.s
+++ b/misc/cgo/test/testdata/issue9400/asm_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !gccgo
+// +build gc
 
 #include "textflag.h"
 
diff --git a/misc/cgo/test/testdata/issue9400/asm_arm64.s b/misc/cgo/test/testdata/issue9400/asm_arm64.s
index 2ebbfcca3b..2565793f9a 100644
--- a/misc/cgo/test/testdata/issue9400/asm_arm64.s
+++ b/misc/cgo/test/testdata/issue9400/asm_arm64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !gccgo
+// +build gc
 
 #include "textflag.h"
 
diff --git a/misc/cgo/test/testdata/issue9400/asm_mips64x.s b/misc/cgo/test/testdata/issue9400/asm_mips64x.s
index 63dc90605e..693231ddfe 100644
--- a/misc/cgo/test/testdata/issue9400/asm_mips64x.s
+++ b/misc/cgo/test/testdata/issue9400/asm_mips64x.s
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.
 
 // +build mips64 mips64le
-// +build !gccgo
+// +build gc
 
 #include "textflag.h"
 
diff --git a/misc/cgo/test/testdata/issue9400/asm_mipsx.s b/misc/cgo/test/testdata/issue9400/asm_mipsx.s
index 7a92735194..63261bbf9d 100644
--- a/misc/cgo/test/testdata/issue9400/asm_mipsx.s
+++ b/misc/cgo/test/testdata/issue9400/asm_mipsx.s
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.
 
 // +build mips mipsle
-// +build !gccgo
+// +build gc
 
 #include "textflag.h"
 
diff --git a/misc/cgo/test/testdata/issue9400/asm_ppc64x.s b/misc/cgo/test/testdata/issue9400/asm_ppc64x.s
index c88ec3b21e..b5613fb6ec 100644
--- a/misc/cgo/test/testdata/issue9400/asm_ppc64x.s
+++ b/misc/cgo/test/testdata/issue9400/asm_ppc64x.s
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.
 
 // +build ppc64 ppc64le
-// +build !gccgo
+// +build gc
 
 #include "textflag.h"
 
diff --git a/misc/cgo/test/testdata/issue9400/asm_riscv64.s b/misc/cgo/test/testdata/issue9400/asm_riscv64.s
index 20fcc0066d..244dadac35 100644
--- a/misc/cgo/test/testdata/issue9400/asm_riscv64.s
+++ b/misc/cgo/test/testdata/issue9400/asm_riscv64.s
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.
 
 // +build riscv64
-// +build !gccgo
+// +build gc
 
 #include "textflag.h"
 
diff --git a/misc/cgo/test/testdata/issue9400/asm_s390x.s b/misc/cgo/test/testdata/issue9400/asm_s390x.s
index fc9ad724c1..4856492958 100644
--- a/misc/cgo/test/testdata/issue9400/asm_s390x.s
+++ b/misc/cgo/test/testdata/issue9400/asm_s390x.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !gccgo
+// +build gc
 
 #include "textflag.h"
 
diff --git a/misc/cgo/testshared/testdata/depBase/asm.s b/misc/cgo/testshared/testdata/depBase/asm.s
index a8acf77f0b..0f1111f392 100644
--- a/misc/cgo/testshared/testdata/depBase/asm.s
+++ b/misc/cgo/testshared/testdata/depBase/asm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !gccgo
+// +build gc
 
 #include "textflag.h"
 
diff --git a/misc/cgo/testshared/testdata/depBase/stubs.go b/misc/cgo/testshared/testdata/depBase/stubs.go
index 04534f38dd..c77953803b 100644
--- a/misc/cgo/testshared/testdata/depBase/stubs.go
+++ b/misc/cgo/testshared/testdata/depBase/stubs.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !gccgo
+// +build gc
 
 package depBase
 
diff --git a/src/cmd/dist/util_gc.go b/src/cmd/dist/util_gc.go
index 2db6d3a25e..875784d383 100644
--- a/src/cmd/dist/util_gc.go
+++ b/src/cmd/dist/util_gc.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build !gccgo
-// +build !gccgo
+//go:build gc
+// +build gc
 
 package main
 
diff --git a/src/cmd/go/testdata/script/build_overlay.txt b/src/cmd/go/testdata/script/build_overlay.txt
index b11cd96014..2932b94e6c 100644
--- a/src/cmd/go/testdata/script/build_overlay.txt
+++ b/src/cmd/go/testdata/script/build_overlay.txt
@@ -238,7 +238,7 @@ void say_hello();
 
 void say_hello() { puts("hello cgo\n"); fflush(stdout); }
 -- m/overlay/asm_gc.s --
-// +build !gccgo
+// +build gc
 
 TEXT ·foo(SB),0,$0
 	RET
-- 
GitLab


From d434c2338b11b9ecf19865e8ec3f2721706f29cf Mon Sep 17 00:00:00 2001
From: zhengjianxun <zhuimengshaonian04@gmail.com>
Date: Tue, 23 Feb 2021 03:12:56 +0000
Subject: [PATCH 0795/2400] runtime: clarify GC fractional mode description

nowdays, in runtime/mgc.go,we can see the comment descrition : The fractional worker is necessary when GOMAXPROCS*gcBackgroundUtilization is not an integer.
but it not true such as GOMAXPROCS=5.
in the implemet of startCycle() , Fractional Mode happend only when
GOMAXPROCS<=3 or GOMAXPROCS=6. so utilization can closest to 25%.
Fixes #44380

Change-Id: Id0dd6d9f37759c2c9231f164a013a014216dd442
GitHub-Last-Rev: 5910e76324b2fa908235c325c8b1edafca496256
GitHub-Pull-Request: golang/go#44381
Reviewed-on: https://go-review.googlesource.com/c/go/+/293630
Reviewed-by: Austin Clements <austin@google.com>
Trust: Michael Pratt <mpratt@google.com>
---
 src/runtime/mgc.go | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index 185d3201ca..7c7239beb8 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -302,9 +302,11 @@ const (
 	// gcMarkWorkerFractionalMode indicates that a P is currently
 	// running the "fractional" mark worker. The fractional worker
 	// is necessary when GOMAXPROCS*gcBackgroundUtilization is not
-	// an integer. The fractional worker should run until it is
-	// preempted and will be scheduled to pick up the fractional
-	// part of GOMAXPROCS*gcBackgroundUtilization.
+	// an integer and using only dedicated workers would result in
+	// utilization too far from the target of gcBackgroundUtilization.
+	// The fractional worker should run until it is preempted and
+	// will be scheduled to pick up the fractional part of
+	// GOMAXPROCS*gcBackgroundUtilization.
 	gcMarkWorkerFractionalMode
 
 	// gcMarkWorkerIdleMode indicates that a P is running the mark
-- 
GitLab


From d2911d76127deaa08644979cec7d990559f0aa54 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Wed, 9 Dec 2020 14:59:40 -0800
Subject: [PATCH 0796/2400] cmd/compile: fold MOV*nop and MOV*const

MOV*nop and MOV*reg seem superfluous. They are there to keep type
information around that would otherwise get thrown away. Not sure
what we need it for. I think our compiler needs a normalization of
how types are represented in SSA, especially after lowering.

MOV*nop gets in the way of some optimization rules firing, like for
load combining.

For now, just fold MOV*nop and MOV*const. It's certainly safe to
do that, as the type info on the MOV*const isn't ever useful.

R=go1.17

Change-Id: I3630a80afc2455a8e9cd9fde10c7abe05ddc3767
Reviewed-on: https://go-review.googlesource.com/c/go/+/276792
Trust: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/ssa/gen/ARM.rules     |  4 ++++
 src/cmd/compile/internal/ssa/gen/ARM64.rules   |  4 ++++
 src/cmd/compile/internal/ssa/gen/MIPS.rules    |  4 ++++
 src/cmd/compile/internal/ssa/gen/MIPS64.rules  |  4 ++++
 src/cmd/compile/internal/ssa/gen/RISCV64.rules |  4 ++++
 src/cmd/compile/internal/ssa/rewriteARM.go     | 17 +++++++++++++++++
 src/cmd/compile/internal/ssa/rewriteARM64.go   | 17 +++++++++++++++++
 src/cmd/compile/internal/ssa/rewriteMIPS.go    | 17 +++++++++++++++++
 src/cmd/compile/internal/ssa/rewriteMIPS64.go  | 17 +++++++++++++++++
 src/cmd/compile/internal/ssa/rewriteRISCV64.go | 17 +++++++++++++++++
 10 files changed, 105 insertions(+)

diff --git a/src/cmd/compile/internal/ssa/gen/ARM.rules b/src/cmd/compile/internal/ssa/gen/ARM.rules
index de0df363e4..cbafd12a4f 100644
--- a/src/cmd/compile/internal/ssa/gen/ARM.rules
+++ b/src/cmd/compile/internal/ssa/gen/ARM.rules
@@ -546,6 +546,10 @@
 // MOVWnop doesn't emit instruction, only for ensuring the type.
 (MOVWreg x) && x.Uses == 1 => (MOVWnop x)
 
+// TODO: we should be able to get rid of MOVWnop all together.
+// But for now, this is enough to get rid of lots of them.
+(MOVWnop (MOVWconst [c])) => (MOVWconst [c])
+
 // mul by constant
 (MUL x (MOVWconst [c])) && int32(c) == -1 => (RSBconst [0] x)
 (MUL _ (MOVWconst [0])) => (MOVWconst [0])
diff --git a/src/cmd/compile/internal/ssa/gen/ARM64.rules b/src/cmd/compile/internal/ssa/gen/ARM64.rules
index a0e2a0d5e2..4531c38a7a 100644
--- a/src/cmd/compile/internal/ssa/gen/ARM64.rules
+++ b/src/cmd/compile/internal/ssa/gen/ARM64.rules
@@ -1127,6 +1127,10 @@
 // MOVDnop doesn't emit instruction, only for ensuring the type.
 (MOVDreg x) && x.Uses == 1 => (MOVDnop x)
 
+// TODO: we should be able to get rid of MOVDnop all together.
+// But for now, this is enough to get rid of lots of them.
+(MOVDnop (MOVDconst [c])) => (MOVDconst [c])
+
 // fold constant into arithmatic ops
 (ADD x (MOVDconst [c])) => (ADDconst [c] x)
 (SUB x (MOVDconst [c])) => (SUBconst [c] x)
diff --git a/src/cmd/compile/internal/ssa/gen/MIPS.rules b/src/cmd/compile/internal/ssa/gen/MIPS.rules
index 8ad2c90ac3..bc1ce82940 100644
--- a/src/cmd/compile/internal/ssa/gen/MIPS.rules
+++ b/src/cmd/compile/internal/ssa/gen/MIPS.rules
@@ -559,6 +559,10 @@
 // MOVWnop doesn't emit instruction, only for ensuring the type.
 (MOVWreg x) && x.Uses == 1 => (MOVWnop x)
 
+// TODO: we should be able to get rid of MOVWnop all together.
+// But for now, this is enough to get rid of lots of them.
+(MOVWnop (MOVWconst [c])) => (MOVWconst [c])
+
 // fold constant into arithmatic ops
 (ADD x (MOVWconst [c])) => (ADDconst [c] x)
 (SUB x (MOVWconst [c])) => (SUBconst [c] x)
diff --git a/src/cmd/compile/internal/ssa/gen/MIPS64.rules b/src/cmd/compile/internal/ssa/gen/MIPS64.rules
index 088c9b1ac4..e3f7633274 100644
--- a/src/cmd/compile/internal/ssa/gen/MIPS64.rules
+++ b/src/cmd/compile/internal/ssa/gen/MIPS64.rules
@@ -558,6 +558,10 @@
 // MOVVnop doesn't emit instruction, only for ensuring the type.
 (MOVVreg x) && x.Uses == 1 => (MOVVnop x)
 
+// TODO: we should be able to get rid of MOVVnop all together.
+// But for now, this is enough to get rid of lots of them.
+(MOVVnop (MOVVconst [c])) => (MOVVconst [c])
+
 // fold constant into arithmatic ops
 (ADDV x (MOVVconst [c])) && is32Bit(c) => (ADDVconst [c] x)
 (SUBV x (MOVVconst [c])) && is32Bit(c) => (SUBVconst [c] x)
diff --git a/src/cmd/compile/internal/ssa/gen/RISCV64.rules b/src/cmd/compile/internal/ssa/gen/RISCV64.rules
index 15361fd37a..9119ebc0e8 100644
--- a/src/cmd/compile/internal/ssa/gen/RISCV64.rules
+++ b/src/cmd/compile/internal/ssa/gen/RISCV64.rules
@@ -673,6 +673,10 @@
 // MOVnop does not emit an instruction, only for ensuring the type.
 (MOVDreg x) && x.Uses == 1 => (MOVDnop x)
 
+// TODO: we should be able to get rid of MOVDnop all together.
+// But for now, this is enough to get rid of lots of them.
+(MOVDnop (MOVDconst [c])) => (MOVDconst [c])
+
 // Fold constant into immediate instructions where possible.
 (ADD (MOVBconst [val]) x) => (ADDI [int64(val)] x)
 (ADD (MOVHconst [val]) x) => (ADDI [int64(val)] x)
diff --git a/src/cmd/compile/internal/ssa/rewriteARM.go b/src/cmd/compile/internal/ssa/rewriteARM.go
index c958aae2c4..1adbceb0ad 100644
--- a/src/cmd/compile/internal/ssa/rewriteARM.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM.go
@@ -202,6 +202,8 @@ func rewriteValueARM(v *Value) bool {
 		return rewriteValueARM_OpARMMOVWloadshiftRA(v)
 	case OpARMMOVWloadshiftRL:
 		return rewriteValueARM_OpARMMOVWloadshiftRL(v)
+	case OpARMMOVWnop:
+		return rewriteValueARM_OpARMMOVWnop(v)
 	case OpARMMOVWreg:
 		return rewriteValueARM_OpARMMOVWreg(v)
 	case OpARMMOVWstore:
@@ -6501,6 +6503,21 @@ func rewriteValueARM_OpARMMOVWloadshiftRL(v *Value) bool {
 	}
 	return false
 }
+func rewriteValueARM_OpARMMOVWnop(v *Value) bool {
+	v_0 := v.Args[0]
+	// match: (MOVWnop (MOVWconst [c]))
+	// result: (MOVWconst [c])
+	for {
+		if v_0.Op != OpARMMOVWconst {
+			break
+		}
+		c := auxIntToInt32(v_0.AuxInt)
+		v.reset(OpARMMOVWconst)
+		v.AuxInt = int32ToAuxInt(c)
+		return true
+	}
+	return false
+}
 func rewriteValueARM_OpARMMOVWreg(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (MOVWreg x)
diff --git a/src/cmd/compile/internal/ssa/rewriteARM64.go b/src/cmd/compile/internal/ssa/rewriteARM64.go
index ff1156d901..ba146c7043 100644
--- a/src/cmd/compile/internal/ssa/rewriteARM64.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM64.go
@@ -189,6 +189,8 @@ func rewriteValueARM64(v *Value) bool {
 		return rewriteValueARM64_OpARM64MOVDloadidx(v)
 	case OpARM64MOVDloadidx8:
 		return rewriteValueARM64_OpARM64MOVDloadidx8(v)
+	case OpARM64MOVDnop:
+		return rewriteValueARM64_OpARM64MOVDnop(v)
 	case OpARM64MOVDreg:
 		return rewriteValueARM64_OpARM64MOVDreg(v)
 	case OpARM64MOVDstore:
@@ -9011,6 +9013,21 @@ func rewriteValueARM64_OpARM64MOVDloadidx8(v *Value) bool {
 	}
 	return false
 }
+func rewriteValueARM64_OpARM64MOVDnop(v *Value) bool {
+	v_0 := v.Args[0]
+	// match: (MOVDnop (MOVDconst [c]))
+	// result: (MOVDconst [c])
+	for {
+		if v_0.Op != OpARM64MOVDconst {
+			break
+		}
+		c := auxIntToInt64(v_0.AuxInt)
+		v.reset(OpARM64MOVDconst)
+		v.AuxInt = int64ToAuxInt(c)
+		return true
+	}
+	return false
+}
 func rewriteValueARM64_OpARM64MOVDreg(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (MOVDreg x)
diff --git a/src/cmd/compile/internal/ssa/rewriteMIPS.go b/src/cmd/compile/internal/ssa/rewriteMIPS.go
index 3fc5527955..0c074364df 100644
--- a/src/cmd/compile/internal/ssa/rewriteMIPS.go
+++ b/src/cmd/compile/internal/ssa/rewriteMIPS.go
@@ -297,6 +297,8 @@ func rewriteValueMIPS(v *Value) bool {
 		return rewriteValueMIPS_OpMIPSMOVHstorezero(v)
 	case OpMIPSMOVWload:
 		return rewriteValueMIPS_OpMIPSMOVWload(v)
+	case OpMIPSMOVWnop:
+		return rewriteValueMIPS_OpMIPSMOVWnop(v)
 	case OpMIPSMOVWreg:
 		return rewriteValueMIPS_OpMIPSMOVWreg(v)
 	case OpMIPSMOVWstore:
@@ -3647,6 +3649,21 @@ func rewriteValueMIPS_OpMIPSMOVWload(v *Value) bool {
 	}
 	return false
 }
+func rewriteValueMIPS_OpMIPSMOVWnop(v *Value) bool {
+	v_0 := v.Args[0]
+	// match: (MOVWnop (MOVWconst [c]))
+	// result: (MOVWconst [c])
+	for {
+		if v_0.Op != OpMIPSMOVWconst {
+			break
+		}
+		c := auxIntToInt32(v_0.AuxInt)
+		v.reset(OpMIPSMOVWconst)
+		v.AuxInt = int32ToAuxInt(c)
+		return true
+	}
+	return false
+}
 func rewriteValueMIPS_OpMIPSMOVWreg(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (MOVWreg x)
diff --git a/src/cmd/compile/internal/ssa/rewriteMIPS64.go b/src/cmd/compile/internal/ssa/rewriteMIPS64.go
index d78f6089af..073cf8726c 100644
--- a/src/cmd/compile/internal/ssa/rewriteMIPS64.go
+++ b/src/cmd/compile/internal/ssa/rewriteMIPS64.go
@@ -339,6 +339,8 @@ func rewriteValueMIPS64(v *Value) bool {
 		return rewriteValueMIPS64_OpMIPS64MOVHstorezero(v)
 	case OpMIPS64MOVVload:
 		return rewriteValueMIPS64_OpMIPS64MOVVload(v)
+	case OpMIPS64MOVVnop:
+		return rewriteValueMIPS64_OpMIPS64MOVVnop(v)
 	case OpMIPS64MOVVreg:
 		return rewriteValueMIPS64_OpMIPS64MOVVreg(v)
 	case OpMIPS64MOVVstore:
@@ -3584,6 +3586,21 @@ func rewriteValueMIPS64_OpMIPS64MOVVload(v *Value) bool {
 	}
 	return false
 }
+func rewriteValueMIPS64_OpMIPS64MOVVnop(v *Value) bool {
+	v_0 := v.Args[0]
+	// match: (MOVVnop (MOVVconst [c]))
+	// result: (MOVVconst [c])
+	for {
+		if v_0.Op != OpMIPS64MOVVconst {
+			break
+		}
+		c := auxIntToInt64(v_0.AuxInt)
+		v.reset(OpMIPS64MOVVconst)
+		v.AuxInt = int64ToAuxInt(c)
+		return true
+	}
+	return false
+}
 func rewriteValueMIPS64_OpMIPS64MOVVreg(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (MOVVreg x)
diff --git a/src/cmd/compile/internal/ssa/rewriteRISCV64.go b/src/cmd/compile/internal/ssa/rewriteRISCV64.go
index 1abdf1aa06..bc47d76e87 100644
--- a/src/cmd/compile/internal/ssa/rewriteRISCV64.go
+++ b/src/cmd/compile/internal/ssa/rewriteRISCV64.go
@@ -435,6 +435,8 @@ func rewriteValueRISCV64(v *Value) bool {
 		return rewriteValueRISCV64_OpRISCV64MOVDconst(v)
 	case OpRISCV64MOVDload:
 		return rewriteValueRISCV64_OpRISCV64MOVDload(v)
+	case OpRISCV64MOVDnop:
+		return rewriteValueRISCV64_OpRISCV64MOVDnop(v)
 	case OpRISCV64MOVDreg:
 		return rewriteValueRISCV64_OpRISCV64MOVDreg(v)
 	case OpRISCV64MOVDstore:
@@ -3349,6 +3351,21 @@ func rewriteValueRISCV64_OpRISCV64MOVDload(v *Value) bool {
 	}
 	return false
 }
+func rewriteValueRISCV64_OpRISCV64MOVDnop(v *Value) bool {
+	v_0 := v.Args[0]
+	// match: (MOVDnop (MOVDconst [c]))
+	// result: (MOVDconst [c])
+	for {
+		if v_0.Op != OpRISCV64MOVDconst {
+			break
+		}
+		c := auxIntToInt64(v_0.AuxInt)
+		v.reset(OpRISCV64MOVDconst)
+		v.AuxInt = int64ToAuxInt(c)
+		return true
+	}
+	return false
+}
 func rewriteValueRISCV64_OpRISCV64MOVDreg(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (MOVDreg x)
-- 
GitLab


From c49c7a675a2c8ee7591a2d6243255813856b65ce Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Mon, 1 Feb 2021 00:45:41 -0800
Subject: [PATCH 0797/2400] runtime: save R15 before checking AVX state

When in dynlink mode, reading a global can clobber R15.
Just to be safe, save R15 before checking the AVX state to see
if we need to VZEROUPPER or not.

This could cause a problem in buildmodes that aren't supported yet.

Change-Id: I8fda62d3fbe808584774fa5e8d9810a4612a84e5
Reviewed-on: https://go-review.googlesource.com/c/go/+/288452
Trust: Keith Randall <khr@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/mkpreempt.go    | 19 +++++++++++++------
 src/runtime/preempt_amd64.s | 10 +++++-----
 2 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/src/runtime/mkpreempt.go b/src/runtime/mkpreempt.go
index 3069d6ed04..3a9e6cc478 100644
--- a/src/runtime/mkpreempt.go
+++ b/src/runtime/mkpreempt.go
@@ -230,12 +230,16 @@ func genAMD64() {
 		if reg == "SP" || reg == "BP" {
 			continue
 		}
-		if strings.HasPrefix(reg, "X") {
-			l.add("MOVUPS", reg, 16)
-		} else {
+		if !strings.HasPrefix(reg, "X") {
 			l.add("MOVQ", reg, 8)
 		}
 	}
+	lSSE := layout{stack: l.stack, sp: "SP"}
+	for _, reg := range regNamesAMD64 {
+		if strings.HasPrefix(reg, "X") {
+			lSSE.add("MOVUPS", reg, 16)
+		}
+	}
 
 	// TODO: MXCSR register?
 
@@ -244,10 +248,12 @@ func genAMD64() {
 	p("// Save flags before clobbering them")
 	p("PUSHFQ")
 	p("// obj doesn't understand ADD/SUB on SP, but does understand ADJSP")
-	p("ADJSP $%d", l.stack)
+	p("ADJSP $%d", lSSE.stack)
 	p("// But vet doesn't know ADJSP, so suppress vet stack checking")
 	p("NOP SP")
 
+	l.save()
+
 	// Apparently, the signal handling code path in darwin kernel leaves
 	// the upper bits of Y registers in a dirty state, which causes
 	// many SSE operations (128-bit and narrower) become much slower.
@@ -259,10 +265,11 @@ func genAMD64() {
 	p("VZEROUPPER")
 	p("#endif")
 
-	l.save()
+	lSSE.save()
 	p("CALL ·asyncPreempt2(SB)")
+	lSSE.restore()
 	l.restore()
-	p("ADJSP $%d", -l.stack)
+	p("ADJSP $%d", -lSSE.stack)
 	p("POPFQ")
 	p("POPQ BP")
 	p("RET")
diff --git a/src/runtime/preempt_amd64.s b/src/runtime/preempt_amd64.s
index 92c664d79a..dc7af806d3 100644
--- a/src/runtime/preempt_amd64.s
+++ b/src/runtime/preempt_amd64.s
@@ -13,11 +13,6 @@ TEXT ·asyncPreempt<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-0
 	ADJSP $368
 	// But vet doesn't know ADJSP, so suppress vet stack checking
 	NOP SP
-	#ifdef GOOS_darwin
-	CMPB internal∕cpu·X86+const_offsetX86HasAVX(SB), $0
-	JE 2(PC)
-	VZEROUPPER
-	#endif
 	MOVQ AX, 0(SP)
 	MOVQ CX, 8(SP)
 	MOVQ DX, 16(SP)
@@ -32,6 +27,11 @@ TEXT ·asyncPreempt<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-0
 	MOVQ R13, 88(SP)
 	MOVQ R14, 96(SP)
 	MOVQ R15, 104(SP)
+	#ifdef GOOS_darwin
+	CMPB internal∕cpu·X86+const_offsetX86HasAVX(SB), $0
+	JE 2(PC)
+	VZEROUPPER
+	#endif
 	MOVUPS X0, 112(SP)
 	MOVUPS X1, 128(SP)
 	MOVUPS X2, 144(SP)
-- 
GitLab


From a4dac8bd220ff893d7df9cb6fbaf56ecfdd66ad4 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Wed, 3 Feb 2021 12:25:46 -0800
Subject: [PATCH 0798/2400] runtime: use BX instead of R15 in race detector

If the race detector were runnable in dynamic linking mode,
then R15 would get clobbered. I don't think it is, so maybe
not a problem, but can't hurt to clean it up.

It also lets CL 283474 pass cleanly when checking the whole stdlib
(together with CL 288452).

Change-Id: I5a5021ecc7e7b8bed1cd3a7067c39b24c09e0783
Reviewed-on: https://go-review.googlesource.com/c/go/+/289270
Trust: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/race_amd64.s | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/runtime/race_amd64.s b/src/runtime/race_amd64.s
index c3b7bbfbfe..e10c21c7f3 100644
--- a/src/runtime/race_amd64.s
+++ b/src/runtime/race_amd64.s
@@ -184,7 +184,7 @@ TEXT	runtime·racefuncenter(SB), NOSPLIT, $0-8
 // Common code for racefuncenter/racefuncenterfp
 // R11 = caller's return address
 TEXT	racefuncenter<>(SB), NOSPLIT, $0-0
-	MOVQ	DX, R15		// save function entry context (for closures)
+	MOVQ	DX, BX		// save function entry context (for closures)
 #ifndef GOEXPERIMENT_REGABI
 	get_tls(R12)
 	MOVQ	g(R12), R14
@@ -193,9 +193,9 @@ TEXT	racefuncenter<>(SB), NOSPLIT, $0-0
 	MOVQ	R11, RARG1
 	// void __tsan_func_enter(ThreadState *thr, void *pc);
 	MOVQ	$__tsan_func_enter(SB), AX
-	// racecall<> preserves R15
+	// racecall<> preserves BX
 	CALL	racecall<>(SB)
-	MOVQ	R15, DX	// restore function entry context
+	MOVQ	BX, DX	// restore function entry context
 	RET
 
 // func runtime·racefuncexit()
@@ -376,7 +376,7 @@ racecallatomic_ignore:
 	// Addr is outside the good range.
 	// Call __tsan_go_ignore_sync_begin to ignore synchronization during the atomic op.
 	// An attempt to synchronize on the address would cause crash.
-	MOVQ	AX, R15	// remember the original function
+	MOVQ	AX, BX	// remember the original function
 	MOVQ	$__tsan_go_ignore_sync_begin(SB), AX
 #ifndef GOEXPERIMENT_REGABI
 	get_tls(R12)
@@ -384,7 +384,7 @@ racecallatomic_ignore:
 #endif
 	MOVQ	g_racectx(R14), RARG0	// goroutine context
 	CALL	racecall<>(SB)
-	MOVQ	R15, AX	// restore the original function
+	MOVQ	BX, AX	// restore the original function
 	// Call the atomic function.
 	MOVQ	g_racectx(R14), RARG0	// goroutine context
 	MOVQ	8(SP), RARG1	// caller pc
-- 
GitLab


From fa40c0232c79f1e8eb6bda6c63604958bdf1102f Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Mon, 22 Feb 2021 15:04:25 -0500
Subject: [PATCH 0799/2400] cmd/go: reproduce issue #44497 in
 TestScript/mod_edit

For #44497

Change-Id: Ie5285b9c526506b6b1280a590a5dcbee4074f57b
Reviewed-on: https://go-review.googlesource.com/c/go/+/295149
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/testdata/script/mod_edit.txt | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/src/cmd/go/testdata/script/mod_edit.txt b/src/cmd/go/testdata/script/mod_edit.txt
index d7e681e831..02d2d40bbb 100644
--- a/src/cmd/go/testdata/script/mod_edit.txt
+++ b/src/cmd/go/testdata/script/mod_edit.txt
@@ -26,6 +26,25 @@ cmpenv go.mod $WORK/go.mod.edit2
 stderr '^go mod: -exclude=example.com/m@bad: version "bad" invalid: must be of the form v1.2.3$'
 ! go mod edit -retract=bad
 stderr '^go mod: -retract=bad: version "bad" invalid: must be of the form v1.2.3$'
+cmpenv go.mod $WORK/go.mod.edit2
+
+cp go.mod go.mod.beforebugs
+
+# BUG(#44497): -exclude accepts a mismatched major version without +incompatible, but should not.
+go mod edit -exclude=example.com/m@v2.0.0
+! go mod edit -json
+stderr '^go: errors parsing go.mod:\n.*[/\\]go.mod:16: exclude example\.com/m: version "v2\.0\.0" invalid: should be v0 or v1, not v2$'
+cp go.mod.beforebugs go.mod
+
+# BUG(#44497): -exclude accepts a v1 version for a v2 module, but should not.
+go mod edit -exclude=example.com/m/v2@v1.0.0
+! go mod edit -json
+stderr '^go: errors parsing go.mod:\n.*[/\\]go.mod:16: exclude example\.com/m/v2: version "v1\.0\.0" invalid: should be v2, not v1$'
+cp go.mod.beforebugs go.mod
+
+# BUG(#44497): -exclude rejects a +incompatible version for an unversioned
+# module path, but should not.
+! go mod edit -exclude=example.com/m@v2.0.0+incompatible
 
 # go mod edit -json
 go mod edit -json
-- 
GitLab


From 74903553bc91cef8f31067ad69ef2aa7d60ceb00 Mon Sep 17 00:00:00 2001
From: Dmitri Shuralyov <dmitshur@golang.org>
Date: Mon, 22 Feb 2021 17:21:10 -0500
Subject: [PATCH 0800/2400] doc: start draft go1.17 release notes, move go1.16
 to x/website

This template is based on CL 248198 and previous ones like it.
Continue to eagerly include often-used sections, and clarify that
the TODO is about completing the section, or removing if it turns
out not to be needed.

Move the Go 1.16 release notes to x/website, since that's the new
home for past Go release notes as of CL 291711. They're added to
x/website in CL 295249.

'relnote -html' does not report any CLs with RELNOTE annotations
since 2021/02/01.

For #44513.
Updates #40700.

Change-Id: Idd389335500ec4dec2764cbbaa385918cc8a79ad
Reviewed-on: https://go-review.googlesource.com/c/go/+/295209
Trust: Dmitri Shuralyov <dmitshur@golang.org>
Run-TryBot: Dmitri Shuralyov <dmitshur@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Alexander Rakoczy <alex@golang.org>
Reviewed-by: Carlos Amedee <carlos@golang.org>
---
 doc/go1.16.html | 1220 -----------------------------------------------
 doc/go1.17.html |   84 ++++
 2 files changed, 84 insertions(+), 1220 deletions(-)
 delete mode 100644 doc/go1.16.html
 create mode 100644 doc/go1.17.html

diff --git a/doc/go1.16.html b/doc/go1.16.html
deleted file mode 100644
index f2370e8363..0000000000
--- a/doc/go1.16.html
+++ /dev/null
@@ -1,1220 +0,0 @@
-<!--{
-	"Title": "Go 1.16 Release Notes",
-	"Path":  "/doc/go1.16"
-}-->
-
-<!--
-NOTE: In this document and others in this directory, the convention is to
-set fixed-width phrases with non-fixed-width spaces, as in
-<code>hello</code> <code>world</code>.
-Do not send CLs removing the interior tags from such phrases.
--->
-
-<style>
-  main ul li { margin: 0.5em 0; }
-</style>
-
-<h2 id="introduction">Introduction to Go 1.16</h2>
-
-<p>
-  The latest Go release, version 1.16, arrives six months after <a href="/doc/go1.15">Go 1.15</a>.
-  Most of its changes are in the implementation of the toolchain, runtime, and libraries.
-  As always, the release maintains the Go 1 <a href="/doc/go1compat.html">promise of compatibility</a>.
-  We expect almost all Go programs to continue to compile and run as before.
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<p>
-  There are no changes to the language.
-</p>
-
-<h2 id="ports">Ports</h2>
-
-<h3 id="darwin">Darwin and iOS</h3>
-
-<p><!-- golang.org/issue/38485, golang.org/issue/41385, CL 266373, more CLs -->
-  Go 1.16 adds support of 64-bit ARM architecture on macOS (also known as
-  Apple Silicon) with <code>GOOS=darwin</code>, <code>GOARCH=arm64</code>.
-  Like the <code>darwin/amd64</code> port, the <code>darwin/arm64</code>
-  port supports cgo, internal and external linking, <code>c-archive</code>,
-  <code>c-shared</code>, and <code>pie</code> build modes, and the race
-  detector.
-</p>
-
-<p><!-- CL 254740 -->
-  The iOS port, which was previously <code>darwin/arm64</code>, has
-  been renamed to <code>ios/arm64</code>. <code>GOOS=ios</code>
-  implies the
-  <code>darwin</code> build tag, just as <code>GOOS=android</code>
-  implies the <code>linux</code> build tag. This change should be
-  transparent to anyone using gomobile to build iOS apps.
-</p>
-
-<p><!-- golang.org/issue/42100, CL 263798 -->
-  Go 1.16 adds an <code>ios/amd64</code> port, which targets the iOS
-  simulator running on AMD64-based macOS. Previously this was
-  unofficially supported through <code>darwin/amd64</code> with
-  the <code>ios</code> build tag set. See also
-  <a href="/misc/ios/README"><code>misc/ios/README</code></a> for
-  details about how to build programs for iOS and iOS simulator.
-</p>
-
-<p><!-- golang.org/issue/23011 -->
-  Go 1.16 is the last release that will run on macOS 10.12 Sierra.
-  Go 1.17 will require macOS 10.13 High Sierra or later.
-</p>
-
-<h3 id="netbsd">NetBSD</h3>
-
-<p><!-- golang.org/issue/30824 -->
-  Go now supports the 64-bit ARM architecture on NetBSD (the
-  <code>netbsd/arm64</code> port).
-</p>
-
-<h3 id="openbsd">OpenBSD</h3>
-
-<p><!-- golang.org/issue/40995 -->
-  Go now supports the MIPS64 architecture on OpenBSD
-  (the <code>openbsd/mips64</code> port). This port does not yet
-  support cgo.
-</p>
-
-<p><!-- golang.org/issue/36435, many CLs -->
-  On the 64-bit x86 and 64-bit ARM architectures on OpenBSD (the
-  <code>openbsd/amd64</code> and <code>openbsd/arm64</code> ports), system
-  calls are now made through <code>libc</code>, instead of directly using
-  the <code>SYSCALL</code>/<code>SVC</code> instruction. This ensures
-  forward-compatibility with future versions of OpenBSD. In particular,
-  OpenBSD 6.9 onwards will require system calls to be made through
-  <code>libc</code> for non-static Go binaries.
-</p>
-
-<h3 id="386">386</h3>
-
-<p><!-- golang.org/issue/40255, golang.org/issue/41848, CL 258957, and CL 260017 -->
-  As <a href="go1.15#386">announced</a> in the Go 1.15 release notes,
-  Go 1.16 drops support for x87 mode compilation (<code>GO386=387</code>).
-  Support for non-SSE2 processors is now available using soft float
-  mode (<code>GO386=softfloat</code>).
-  Users running on non-SSE2 processors should replace <code>GO386=387</code>
-  with <code>GO386=softfloat</code>.
-</p>
-
-<h3 id="riscv">RISC-V</h3>
-
-<p><!-- golang.org/issue/36641, CL 267317 -->
-  The <code>linux/riscv64</code> port now supports cgo and
-  <code>-buildmode=pie</code>. This release also includes performance
-  optimizations and code generation improvements for RISC-V.
-</p>
-
-<h2 id="tools">Tools</h2>
-
-<h3 id="go-command">Go command</h3>
-
-<h4 id="modules">Modules</h4>
-
-<p><!-- golang.org/issue/41330 -->
-  Module-aware mode is enabled by default, regardless of whether a
-  <code>go.mod</code> file is present in the current working directory or a
-  parent directory. More precisely, the <code>GO111MODULE</code> environment
-  variable now defaults to <code>on</code>. To switch to the previous behavior,
-  set <code>GO111MODULE</code> to <code>auto</code>.
-</p>
-
-<p><!-- golang.org/issue/40728 -->
-  Build commands like <code>go</code> <code>build</code> and <code>go</code>
-  <code>test</code> no longer modify <code>go.mod</code> and <code>go.sum</code>
-  by default. Instead, they report an error if a module requirement or checksum
-  needs to be added or updated (as if the <code>-mod=readonly</code> flag were
-  used). Module requirements and sums may be adjusted with <code>go</code>
-  <code>mod</code> <code>tidy</code> or <code>go</code> <code>get</code>.
-</p>
-
-<p><!-- golang.org/issue/40276 -->
-  <code>go</code> <code>install</code> now accepts arguments with
-  version suffixes (for example, <code>go</code> <code>install</code>
-  <code>example.com/cmd@v1.0.0</code>). This causes <code>go</code>
-  <code>install</code> to build and install packages in module-aware mode,
-  ignoring the <code>go.mod</code> file in the current directory or any parent
-  directory, if there is one. This is useful for installing executables without
-  affecting the dependencies of the main module.
-</p>
-
-<p><!-- golang.org/issue/40276 -->
-  <code>go</code> <code>install</code>, with or without a version suffix (as
-  described above), is now the recommended way to build and install packages in
-  module mode. <code>go</code> <code>get</code> should be used with the
-  <code>-d</code> flag to adjust the current module's dependencies without
-  building packages, and use of <code>go</code> <code>get</code> to build and
-  install packages is deprecated. In a future release, the <code>-d</code> flag
-  will always be enabled.
-</p>
-
-<p><!-- golang.org/issue/24031 -->
-  <code>retract</code> directives may now be used in a <code>go.mod</code> file
-  to indicate that certain published versions of the module should not be used
-  by other modules. A module author may retract a version after a severe problem
-  is discovered or if the version was published unintentionally.
-</p>
-
-<p><!-- golang.org/issue/26603 -->
-  The <code>go</code> <code>mod</code> <code>vendor</code>
-  and <code>go</code> <code>mod</code> <code>tidy</code> subcommands now accept
-  the <code>-e</code> flag, which instructs them to proceed despite errors in
-  resolving missing packages.
-</p>
-
-<p><!-- golang.org/issue/36465 -->
-  The <code>go</code> command now ignores requirements on module versions
-  excluded by <code>exclude</code> directives in the main module. Previously,
-  the <code>go</code> command used the next version higher than an excluded
-  version, but that version could change over time, resulting in
-  non-reproducible builds.
-</p>
-
-<p><!-- golang.org/issue/43052, golang.org/issue/43985 -->
-  In module mode, the <code>go</code> command now disallows import paths that
-  include non-ASCII characters or path elements with a leading dot character
-  (<code>.</code>). Module paths with these characters were already disallowed
-  (see <a href="/ref/mod#go-mod-file-ident">Module paths and versions</a>),
-  so this change affects only paths within module subdirectories.
-</p>
-
-<h4 id="embed">Embedding Files</h4>
-
-<p>
-  The <code>go</code> command now supports including
-  static files and file trees as part of the final executable,
-  using the new <code>//go:embed</code> directive.
-  See the documentation for the new
-  <a href="/pkg/embed/"><code>embed</code></a>
-  package for details.
-</p>
-
-<h4 id="go-test"><code>go</code> <code>test</code></h4>
-
-<p><!-- golang.org/issue/29062 -->
-  When using <code>go</code> <code>test</code>, a test that
-  calls <code>os.Exit(0)</code> during execution of a test function
-  will now be considered to fail.
-  This will help catch cases in which a test calls code that calls
-  <code>os.Exit(0)</code> and thereby stops running all future tests.
-  If a <code>TestMain</code> function calls <code>os.Exit(0)</code>
-  that is still considered to be a passing test.
-</p>
-
-<p><!-- golang.org/issue/39484 -->
-  <code>go</code> <code>test</code> reports an error when the <code>-c</code>
-  or <code>-i</code> flags are used together with unknown flags. Normally,
-  unknown flags are passed to tests, but when <code>-c</code> or <code>-i</code>
-  are used, tests are not run.
-</p>
-
-<h4 id="go-get"><code>go</code> <code>get</code></h4>
-
-<p><!-- golang.org/issue/37519 -->
-  The <code>go</code> <code>get</code> <code>-insecure</code> flag is
-  deprecated and will be removed in a future version. This flag permits
-  fetching from repositories and resolving custom domains using insecure
-  schemes such as HTTP, and also bypasses module sum validation using the
-  checksum database. To permit the use of insecure schemes, use the
-  <code>GOINSECURE</code> environment variable instead. To bypass module
-  sum validation, use <code>GOPRIVATE</code> or <code>GONOSUMDB</code>.
-  See <code>go</code> <code>help</code> <code>environment</code> for details.
-</p>
-
-<p><!-- golang.org/cl/263267 -->
-  <code>go</code> <code>get</code> <code>example.com/mod@patch</code> now
-  requires that some version of <code>example.com/mod</code> already be
-  required by the main module.
-  (However, <code>go</code> <code>get</code> <code>-u=patch</code> continues
-  to patch even newly-added dependencies.)
-</p>
-
-<h4 id="govcs"><code>GOVCS</code> environment variable</h4>
-
-<p><!-- golang.org/issue/266420 -->
-  <code>GOVCS</code> is a new environment variable that limits which version
-  control tools the <code>go</code> command may use to download source code.
-  This mitigates security issues with tools that are typically used in trusted,
-  authenticated environments. By default, <code>git</code> and <code>hg</code>
-  may be used to download code from any repository. <code>svn</code>,
-  <code>bzr</code>, and <code>fossil</code> may only be used to download code
-  from repositories with module paths or package paths matching patterns in
-  the <code>GOPRIVATE</code> environment variable. See
-  <a href="/cmd/go/#hdr-Controlling_version_control_with_GOVCS"><code>go</code>
-  <code>help</code> <code>vcs</code></a> for details.
-</p>
-
-<h4 id="all-pattern">The <code>all</code> pattern</h4>
-
-<p><!-- golang.org/cl/240623 -->
-  When the main module's <code>go.mod</code> file
-  declares <code>go</code> <code>1.16</code> or higher, the <code>all</code>
-  package pattern now matches only those packages that are transitively imported
-  by a package or test found in the main module. (Packages imported by <em>tests
-  of</em> packages imported by the main module are no longer included.) This is
-  the same set of packages retained
-  by <code>go</code> <code>mod</code> <code>vendor</code> since Go 1.11.
-</p>
-
-<h4 id="toolexec">The <code>-toolexec</code> build flag</h4>
-
-<p><!-- golang.org/cl/263357 -->
-  When the <code>-toolexec</code> build flag is specified to use a program when
-  invoking toolchain programs like compile or asm, the environment variable
-  <code>TOOLEXEC_IMPORTPATH</code> is now set to the import path of the package
-  being built.
-</p>
-
-<h4 id="i-flag">The <code>-i</code> build flag</h4>
-
-<p><!-- golang.org/issue/41696 -->
-  The <code>-i</code> flag accepted by <code>go</code> <code>build</code>,
-  <code>go</code> <code>install</code>, and <code>go</code> <code>test</code> is
-  now deprecated. The <code>-i</code> flag instructs the <code>go</code> command
-  to install packages imported by packages named on the command line. Since
-  the build cache was introduced in Go 1.10, the <code>-i</code> flag no longer
-  has a significant effect on build times, and it causes errors when the install
-  directory is not writable.
-</p>
-
-<h4 id="list-buildid">The <code>list</code> command</h4>
-
-<p><!-- golang.org/cl/263542 -->
-  When the <code>-export</code> flag is specified, the <code>BuildID</code>
-  field is now set to the build ID of the compiled package. This is equivalent
-  to running <code>go</code> <code>tool</code> <code>buildid</code> on
-  <code>go</code> <code>list</code> <code>-exported</code> <code>-f</code> <code>{{.Export}}</code>,
-  but without the extra step.
-</p>
-
-<h4 id="overlay-flag">The <code>-overlay</code> flag</h4>
-
-<p><!-- golang.org/issue/39958 -->
-  The <code>-overlay</code> flag specifies a JSON configuration file containing
-  a set of file path replacements. The <code>-overlay</code> flag may be used
-  with all build commands and <code>go</code> <code>mod</code> subcommands.
-  It is primarily intended to be used by editor tooling such as gopls to
-  understand the effects of unsaved changes to source files.  The config file
-  maps actual file paths to replacement file paths and the <code>go</code>
-  command and its builds will run as if the actual file paths exist with the
-  contents given by the replacement file paths, or don't exist if the replacement
-  file paths are empty.
-</p>
-
-<h3 id="cgo">Cgo</h3>
-
-<p><!-- CL 252378 -->
-  The <a href="/cmd/cgo">cgo</a> tool will no longer try to translate
-  C struct bitfields into Go struct fields, even if their size can be
-  represented in Go. The order in which C bitfields appear in memory
-  is implementation dependent, so in some cases the cgo tool produced
-  results that were silently incorrect.
-</p>
-
-<h3 id="vet">Vet</h3>
-
-<h4 id="vet-testing-T">New warning for invalid testing.T use in
-goroutines</h4>
-
-<p><!-- CL 235677 -->
-  The vet tool now warns about invalid calls to the <code>testing.T</code>
-  method <code>Fatal</code> from within a goroutine created during the test.
-  This also warns on calls to <code>Fatalf</code>, <code>FailNow</code>, and
-  <code>Skip{,f,Now}</code> methods on <code>testing.T</code> tests or
-  <code>testing.B</code> benchmarks.
-</p>
-
-<p>
-  Calls to these methods stop the execution of the created goroutine and not
-  the <code>Test*</code> or <code>Benchmark*</code> function. So these are
-  <a href="/pkg/testing/#T.FailNow">required</a> to be called by the goroutine
-  running the test or benchmark function. For example:
-</p>
-
-<pre>
-func TestFoo(t *testing.T) {
-    go func() {
-        if condition() {
-            t.Fatal("oops") // This exits the inner func instead of TestFoo.
-        }
-        ...
-    }()
-}
-</pre>
-
-<p>
-  Code calling <code>t.Fatal</code> (or a similar method) from a created
-  goroutine should be rewritten to signal the test failure using
-  <code>t.Error</code> and exit the goroutine early using an alternative
-  method, such as using a <code>return</code> statement. The previous example
-  could be rewritten as:
-</p>
-
-<pre>
-func TestFoo(t *testing.T) {
-    go func() {
-        if condition() {
-            t.Error("oops")
-            return
-        }
-        ...
-    }()
-}
-</pre>
-
-<h4 id="vet-frame-pointer">New warning for frame pointer</h4>
-
-<p><!-- CL 248686, CL 276372 -->
-  The vet tool now warns about amd64 assembly that clobbers the BP
-  register (the frame pointer) without saving and restoring it,
-  contrary to the calling convention. Code that doesn't preserve the
-  BP register must be modified to either not use BP at all or preserve
-  BP by saving and restoring it. An easy way to preserve BP is to set
-  the frame size to a nonzero value, which causes the generated
-  prologue and epilogue to preserve the BP register for you.
-  See <a href="https://golang.org/cl/248260">CL 248260</a> for example
-  fixes.
-</p>
-
-<h4 id="vet-asn1-unmarshal">New warning for asn1.Unmarshal</h4>
-
-<p><!-- CL 243397 -->
-  The vet tool now warns about incorrectly passing a non-pointer or nil argument to
-  <a href="/pkg/encoding/asn1/#Unmarshal"><code>asn1.Unmarshal</code></a>.
-  This is like the existing checks for
-  <a href="/pkg/encoding/json/#Unmarshal"><code>encoding/json.Unmarshal</code></a>
-  and <a href="/pkg/encoding/xml/#Unmarshal"><code>encoding/xml.Unmarshal</code></a>.
-</p>
-
-<h2 id="runtime">Runtime</h2>
-
-<p>
-  The new <a href="/pkg/runtime/metrics/"><code>runtime/metrics</code></a> package
-  introduces a stable interface for reading
-  implementation-defined metrics from the Go runtime.
-  It supersedes existing functions like
-  <a href="/pkg/runtime/#ReadMemStats"><code>runtime.ReadMemStats</code></a>
-  and
-  <a href="/pkg/runtime/debug/#GCStats"><code>debug.GCStats</code></a>
-  and is significantly more general and efficient.
-  See the package documentation for more details.
-</p>
-
-<p><!-- CL 254659 -->
-  Setting the <code>GODEBUG</code> environment variable
-  to <code>inittrace=1</code> now causes the runtime to emit a single
-  line to standard error for each package <code>init</code>,
-  summarizing its execution time and memory allocation. This trace can
-  be used to find bottlenecks or regressions in Go startup
-  performance.
-  The <a href="/pkg/runtime/#hdr-Environment_Variables"><code>GODEBUG</code>
-  documentation</a> describes the format.
-</p>
-
-<p><!-- CL 267100 -->
-  On Linux, the runtime now defaults to releasing memory to the
-  operating system promptly (using <code>MADV_DONTNEED</code>), rather
-  than lazily when the operating system is under memory pressure
-  (using <code>MADV_FREE</code>). This means process-level memory
-  statistics like RSS will more accurately reflect the amount of
-  physical memory being used by Go processes. Systems that are
-  currently using <code>GODEBUG=madvdontneed=1</code> to improve
-  memory monitoring behavior no longer need to set this environment
-  variable.
-</p>
-
-<p><!-- CL 220419, CL 271987 -->
-  Go 1.16 fixes a discrepancy between the race detector and
-  the <a href="/ref/mem">Go memory model</a>. The race detector now
-  more precisely follows the channel synchronization rules of the
-  memory model. As a result, the detector may now report races it
-  previously missed.
-</p>
-
-<h2 id="compiler">Compiler</h2>
-
-<p><!-- CL 256459, CL 264837, CL 266203, CL 256460 -->
-  The compiler can now inline functions with
-  non-labeled <code>for</code> loops, method values, and type
-  switches. The inliner can also detect more indirect calls where
-  inlining is possible.
-</p>
-
-<h2 id="linker">Linker</h2>
-
-<p><!-- CL 248197 -->
-  This release includes additional improvements to the Go linker,
-  reducing linker resource usage (both time and memory) and improving
-  code robustness/maintainability. These changes form the second half
-  of a two-release project to
-  <a href="https://golang.org/s/better-linker">modernize the Go
-  linker</a>.
-</p>
-
-<p>
-  The linker changes in 1.16 extend the 1.15 improvements to all
-  supported architecture/OS combinations (the 1.15 performance improvements
-  were primarily focused on <code>ELF</code>-based OSes and
-  <code>amd64</code> architectures).  For a representative set of
-  large Go programs, linking is 20-25% faster than 1.15 and requires
-  5-15% less memory on average for <code>linux/amd64</code>, with larger
-  improvements for other architectures and OSes. Most binaries are
-  also smaller as a result of more aggressive symbol pruning.
-</p>
-
-<p><!-- CL 255259 -->
-  On Windows, <code>go build -buildmode=c-shared</code> now generates Windows
-  ASLR DLLs by default. ASLR can be disabled with <code>--ldflags=-aslr=false</code>.
-</p>
-
-<h2 id="library">Core library</h2>
-
-<h3 id="library-embed">Embedded Files</h3>
-
-<p>
-  The new <a href="/pkg/embed/"><code>embed</code></a> package
-  provides access to files embedded in the program during compilation
-  using the new <a href="#embed"><code>//go:embed</code> directive</a>.
-</p>
-
-<h3 id="fs">File Systems</h3>
-
-<p>
-  The new <a href="/pkg/io/fs/"><code>io/fs</code></a> package
-  defines the <a href="/pkg/io/fs/#FS"><code>fs.FS</code></a> interface,
-  an abstraction for read-only trees of files.
-  The standard library packages have been adapted to make use
-  of the interface as appropriate.
-</p>
-
-<p>
-  On the producer side of the interface,
-  the new <a href="/pkg/embed/#FS"><code>embed.FS</code></a> type
-  implements <code>fs.FS</code>, as does
-  <a href="/pkg/archive/zip/#Reader"><code>zip.Reader</code></a>.
-  The new <a href="/pkg/os/#DirFS"><code>os.DirFS</code></a> function
-  provides an implementation of <code>fs.FS</code> backed by a tree
-  of operating system files.
-</p>
-
-<p>
-  On the consumer side,
-  the new <a href="/pkg/net/http/#FS"><code>http.FS</code></a>
-  function converts an <code>fs.FS</code> to an
-  <a href="/pkg/net/http/#FileSystem"><code>http.FileSystem</code></a>.
-  Also, the <a href="/pkg/html/template/"><code>html/template</code></a>
-  and <a href="/pkg/text/template/"><code>text/template</code></a>
-  packages’ <a href="/pkg/html/template/#ParseFS"><code>ParseFS</code></a>
-  functions and methods read templates from an <code>fs.FS</code>.
-</p>
-
-<p>
-  For testing code that implements <code>fs.FS</code>,
-  the new <a href="/pkg/testing/fstest/"><code>testing/fstest</code></a>
-  package provides a <a href="/pkg/testing/fstest/#TestFS"><code>TestFS</code></a>
-  function that checks for and reports common mistakes.
-  It also provides a simple in-memory file system implementation,
-  <a href="/pkg/testing/fstest/#MapFS"><code>MapFS</code></a>,
-  which can be useful for testing code that accepts <code>fs.FS</code>
-  implementations.
-</p>
-
-<h3 id="ioutil">Deprecation of io/ioutil</h3>
-
-<p>
-  The <a href="/pkg/io/ioutil/"><code>io/ioutil</code></a> package has
-  turned out to be a poorly defined and hard to understand collection
-  of things. All functionality provided by the package has been moved
-  to other packages. The <code>io/ioutil</code> package remains and
-  will continue to work as before, but we encourage new code to use
-  the new definitions in the <a href="/pkg/io/"><code>io</code></a> and
-  <a href="/pkg/os/"><code>os</code></a> packages.
-
-  Here is a list of the new locations of the names exported
-  by <code>io/ioutil</code>:
-  <ul>
-    <li><a href="/pkg/io/ioutil/#Discard"><code>Discard</code></a>
-      => <a href="/pkg/io/#Discard"><code>io.Discard</code></a></li>
-    <li><a href="/pkg/io/ioutil/#NopCloser"><code>NopCloser</code></a>
-      => <a href="/pkg/io/#NopCloser"><code>io.NopCloser</code></a></li>
-    <li><a href="/pkg/io/ioutil/#ReadAll"><code>ReadAll</code></a>
-      => <a href="/pkg/io/#ReadAll"><code>io.ReadAll</code></a></li>
-    <li><a href="/pkg/io/ioutil/#ReadDir"><code>ReadDir</code></a>
-      => <a href="/pkg/os/#ReadDir"><code>os.ReadDir</code></a>
-      (note: returns a slice of
-      <a href="/pkg/os/#DirEntry"><code>os.DirEntry</code></a>
-      rather than a slice of
-      <a href="/pkg/io/fs/#FileInfo"><code>fs.FileInfo</code></a>)
-    </li>
-    <li><a href="/pkg/io/ioutil/#ReadFile"><code>ReadFile</code></a>
-      => <a href="/pkg/os/#ReadFile"><code>os.ReadFile</code></a></li>
-    <li><a href="/pkg/io/ioutil/#TempDir"><code>TempDir</code></a>
-      => <a href="/pkg/os/#MkdirTemp"><code>os.MkdirTemp</code></a></li>
-    <li><a href="/pkg/io/ioutil/#TempFile"><code>TempFile</code></a>
-      => <a href="/pkg/os/#CreateTemp"><code>os.CreateTemp</code></a></li>
-    <li><a href="/pkg/io/ioutil/#WriteFile"><code>WriteFile</code></a>
-      => <a href="/pkg/os/#WriteFile"><code>os.WriteFile</code></a></li>
-  </ul>
-</p>
-
-<!-- okay-after-beta1
-  TODO: decide if any additional changes are worth factoring out from
-  "Minor changes to the library" and highlighting in "Core library"
--->
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<p>
-  As always, there are various minor changes and updates to the library,
-  made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
-  in mind.
-</p>
-
-<dl id="archive/zip"><dt><a href="/pkg/archive/zip/">archive/zip</a></dt>
-  <dd>
-    <p><!-- CL 243937 -->
-      The new <a href="/pkg/archive/zip/#Reader.Open"><code>Reader.Open</code></a>
-      method implements the <a href="/pkg/io/fs/#FS"><code>fs.FS</code></a>
-      interface.
-    </p>
-  </dd>
-</dl>
-
-<dl id="crypto/dsa"><dt><a href="/pkg/crypto/dsa/">crypto/dsa</a></dt>
-  <dd>
-    <p><!-- CL 257939 -->
-      The <a href="/pkg/crypto/dsa/"><code>crypto/dsa</code></a> package is now deprecated.
-      See <a href="https://golang.org/issue/40337">issue #40337</a>.
-    </p>
-  </dd>
-</dl><!-- crypto/dsa -->
-
-<dl id="crypto/hmac"><dt><a href="/pkg/crypto/hmac/">crypto/hmac</a></dt>
-  <dd>
-    <p><!-- CL 261960 -->
-      <a href="/pkg/crypto/hmac/#New"><code>New</code></a> will now panic if
-      separate calls to the hash generation function fail to return new values.
-      Previously, the behavior was undefined and invalid outputs were sometimes
-      generated.
-    </p>
-  </dd>
-</dl><!-- crypto/hmac -->
-
-<dl id="crypto/tls"><dt><a href="/pkg/crypto/tls/">crypto/tls</a></dt>
-  <dd>
-    <p><!-- CL 256897 -->
-      I/O operations on closing or closed TLS connections can now be detected
-      using the new <a href="/pkg/net/#ErrClosed"><code>net.ErrClosed</code></a>
-      error. A typical use would be <code>errors.Is(err, net.ErrClosed)</code>.
-    </p>
-
-    <p><!-- CL 266037 -->
-      A default write deadline is now set in
-      <a href="/pkg/crypto/tls/#Conn.Close"><code>Conn.Close</code></a>
-      before sending the "close notify" alert, in order to prevent blocking
-      indefinitely.
-    </p>
-
-    <p><!-- CL 239748 -->
-      Clients now return a handshake error if the server selects
-      <a href="/pkg/crypto/tls/#ConnectionState.NegotiatedProtocol">
-      an ALPN protocol</a> that was not in
-      <a href="/pkg/crypto/tls/#Config.NextProtos">
-      the list advertised by the client</a>.
-    </p>
-
-    <p><!-- CL 262857 -->
-      Servers will now prefer other available AEAD cipher suites (such as ChaCha20Poly1305)
-      over AES-GCM cipher suites if either the client or server doesn't have AES hardware
-      support, unless both <a href="/pkg/crypto/tls/#Config.PreferServerCipherSuites">
-      <code>Config.PreferServerCipherSuites</code></a>
-      and <a href="/pkg/crypto/tls/#Config.CipherSuites"><code>Config.CipherSuites</code></a>
-      are set. The client is assumed not to have AES hardware support if it does
-      not signal a preference for AES-GCM cipher suites.
-    </p>
-
-    <p><!-- CL 246637 -->
-      <a href="/pkg/crypto/tls/#Config.Clone"><code>Config.Clone</code></a> now
-      returns nil if the receiver is nil, rather than panicking.
-    </p>
-  </dd>
-</dl><!-- crypto/tls -->
-
-<dl id="crypto/x509"><dt><a href="/pkg/crypto/x509/">crypto/x509</a></dt>
-  <dd>
-    <p>
-      The <code>GODEBUG=x509ignoreCN=0</code> flag will be removed in Go 1.17.
-      It enables the legacy behavior of treating the <code>CommonName</code>
-      field on X.509 certificates as a host name when no Subject Alternative
-      Names are present.
-    </p>
-
-    <p><!-- CL 235078 -->
-      <a href="/pkg/crypto/x509/#ParseCertificate"><code>ParseCertificate</code></a> and
-      <a href="/pkg/crypto/x509/#CreateCertificate"><code>CreateCertificate</code></a>
-      now enforce string encoding restrictions for the <code>DNSNames</code>,
-      <code>EmailAddresses</code>, and <code>URIs</code> fields. These fields
-      can only contain strings with characters within the ASCII range.
-    </p>
-
-    <p><!-- CL 259697 -->
-      <a href="/pkg/crypto/x509/#CreateCertificate"><code>CreateCertificate</code></a>
-      now verifies the generated certificate's signature using the signer's
-      public key. If the signature is invalid, an error is returned, instead of
-      a malformed certificate.
-    </p>
-
-    <p><!-- CL 257939 -->
-      DSA signature verification is no longer supported. Note that DSA signature
-      generation was never supported.
-      See <a href="https://golang.org/issue/40337">issue #40337</a>.
-    </p>
-
-    <p><!-- CL 257257 -->
-      On Windows, <a href="/pkg/crypto/x509/#Certificate.Verify"><code>Certificate.Verify</code></a>
-      will now return all certificate chains that are built by the platform
-      certificate verifier, instead of just the highest ranked chain.
-    </p>
-
-    <p><!-- CL 262343 -->
-      The new <a href="/pkg/crypto/x509/#SystemRootsError.Unwrap"><code>SystemRootsError.Unwrap</code></a>
-      method allows accessing the <a href="/pkg/crypto/x509/#SystemRootsError.Err"><code>Err</code></a>
-      field through the <a href="/pkg/errors"><code>errors</code></a> package functions.
-    </p>
-
-    <p><!-- CL 230025 -->
-      On Unix systems, the <code>crypto/x509</code> package is now more
-      efficient in how it stores its copy of the system cert pool.
-      Programs that use only a small number of roots will use around a
-      half megabyte less memory.
-    </p>
-
-  </dd>
-</dl><!-- crypto/x509 -->
-
-<dl id="debug/elf"><dt><a href="/pkg/debug/elf/">debug/elf</a></dt>
-  <dd>
-    <p><!-- CL 255138 -->
-      More <a href="/pkg/debug/elf/#DT_NULL"><code>DT</code></a>
-      and <a href="/pkg/debug/elf/#PT_NULL"><code>PT</code></a>
-      constants have been added.
-    </p>
-  </dd>
-</dl><!-- debug/elf -->
-
-<dl id="encoding/asn1"><dt><a href="/pkg/encoding/asn1">encoding/asn1</a></dt>
-  <dd>
-    <p><!-- CL 255881 -->
-      <a href="/pkg/encoding/asn1/#Unmarshal"><code>Unmarshal</code></a> and
-      <a href="/pkg/encoding/asn1/#UnmarshalWithParams"><code>UnmarshalWithParams</code></a>
-      now return an error instead of panicking when the argument is not
-      a pointer or is nil. This change matches the behavior of other
-      encoding packages such as <a href="/pkg/encoding/json"><code>encoding/json</code></a>.
-    </p>
-  </dd>
-</dl>
-
-<dl id="encoding/json"><dt><a href="/pkg/encoding/json/">encoding/json</a></dt>
-  <dd>
-    <p><!-- CL 234818 -->
-      The <code>json</code> struct field tags understood by
-      <a href="/pkg/encoding/json/#Marshal"><code>Marshal</code></a>,
-      <a href="/pkg/encoding/json/#Unmarshal"><code>Unmarshal</code></a>,
-      and related functionality now permit semicolon characters within
-      a JSON object name for a Go struct field.
-    </p>
-  </dd>
-</dl><!-- encoding/json -->
-
-<dl id="encoding/xml"><dt><a href="/pkg/encoding/xml/">encoding/xml</a></dt>
-  <dd>
-    <p><!-- CL 264024 -->
-      The encoder has always taken care to avoid using namespace prefixes
-      beginning with <code>xml</code>, which are reserved by the XML
-      specification.
-      Now, following the specification more closely, that check is
-      case-insensitive, so that prefixes beginning
-      with <code>XML</code>, <code>XmL</code>, and so on are also
-      avoided.
-    </p>
-  </dd>
-</dl><!-- encoding/xml -->
-
-<dl id="flag"><dt><a href="/pkg/flag/">flag</a></dt>
-  <dd>
-    <p><!-- CL 240014 -->
-      The new <a href="/pkg/flag/#Func"><code>Func</code></a> function
-      allows registering a flag implemented by calling a function,
-      as a lighter-weight alternative to implementing the
-      <a href="/pkg/flag/#Value"><code>Value</code></a> interface.
-    </p>
-  </dd>
-</dl><!-- flag -->
-
-<dl id="go/build"><dt><a href="/pkg/go/build/">go/build</a></dt>
-  <dd>
-    <p><!-- CL 243941, CL 283636 -->
-      The <a href="/pkg/go/build/#Package"><code>Package</code></a>
-      struct has new fields that report information
-      about <code>//go:embed</code> directives in the package:
-      <a href="/pkg/go/build/#Package.EmbedPatterns"><code>EmbedPatterns</code></a>,
-      <a href="/pkg/go/build/#Package.EmbedPatternPos"><code>EmbedPatternPos</code></a>,
-      <a href="/pkg/go/build/#Package.TestEmbedPatterns"><code>TestEmbedPatterns</code></a>,
-      <a href="/pkg/go/build/#Package.TestEmbedPatternPos"><code>TestEmbedPatternPos</code></a>,
-      <a href="/pkg/go/build/#Package.XTestEmbedPatterns"><code>XTestEmbedPatterns</code></a>,
-      <a href="/pkg/go/build/#Package.XTestEmbedPatternPos"><code>XTestEmbedPatternPos</code></a>.
-    </p>
-
-    <p><!-- CL 240551 -->
-      The <a href="/pkg/go/build/#Package"><code>Package</code></a> field
-      <a href="/pkg/go/build/#Package.IgnoredGoFiles"><code>IgnoredGoFiles</code></a>
-      will no longer include files that start with "_" or ".",
-      as those files are always ignored.
-      <code>IgnoredGoFiles</code> is for files ignored because of
-      build constraints.
-    </p>
-
-    <p><!-- CL 240551 -->
-      The new <a href="/pkg/go/build/#Package"><code>Package</code></a>
-      field <a href="/pkg/go/build/#Package.IgnoredOtherFiles"><code>IgnoredOtherFiles</code></a>
-      has a list of non-Go files ignored because of build constraints.
-    </p>
-  </dd>
-</dl><!-- go/build -->
-
-<dl id="go/build/constraint"><dt><a href="/pkg/go/build/constraint/">go/build/constraint</a></dt>
-  <dd>
-    <p><!-- CL 240604 -->
-      The new
-      <a href="/pkg/go/build/constraint/"><code>go/build/constraint</code></a>
-      package parses build constraint lines, both the original
-      <code>// +build</code> syntax and the <code>//go:build</code>
-      syntax that will be introduced in Go 1.17.
-      This package exists so that tools built with Go 1.16 will be able
-      to process Go 1.17 source code.
-      See <a href="https://golang.org/design/draft-gobuild">https://golang.org/design/draft-gobuild</a>
-      for details about the build constraint syntaxes and the planned
-      transition to the <code>//go:build</code> syntax.
-      Note that <code>//go:build</code> lines are <b>not</b> supported
-      in Go 1.16 and should not be introduced into Go programs yet.
-    </p>
-  </dd>
-</dl><!-- go/build/constraint -->
-
-<dl id="html/template"><dt><a href="/pkg/html/template/">html/template</a></dt>
-  <dd>
-    <p><!-- CL 243938 -->
-      The new <a href="/pkg/html/template/#ParseFS"><code>template.ParseFS</code></a>
-      function and <a href="/pkg/html/template/#Template.ParseFS"><code>template.Template.ParseFS</code></a>
-      method are like <a href="/pkg/html/template/#ParseGlob"><code>template.ParseGlob</code></a>
-      and <a href="/pkg/html/template/#Template.ParseGlob"><code>template.Template.ParseGlob</code></a>,
-      but read the templates from an <a href="/pkg/io/fs/#FS"><code>fs.FS</code></a>.
-    </p>
-  </dd>
-</dl><!-- html/template -->
-
-<dl id="io"><dt><a href="/pkg/io/">io</a></dt>
-  <dd>
-    <p><!-- CL 261577 -->
-      The package now defines a
-      <a href="/pkg/io/#ReadSeekCloser"><code>ReadSeekCloser</code></a> interface.
-    </p>
-
-    <p><!-- CL 263141 -->
-      The package now defines
-      <a href="/pkg/io/#Discard"><code>Discard</code></a>,
-      <a href="/pkg/io/#NopCloser"><code>NopCloser</code></a>, and
-      <a href="/pkg/io/#ReadAll"><code>ReadAll</code></a>,
-      to be used instead of the same names in the
-      <a href="/pkg/io/ioutil/"><code>io/ioutil</code></a> package.
-    </p>
-  </dd>
-</dl><!-- io -->
-
-<dl id="log"><dt><a href="/pkg/log/">log</a></dt>
-  <dd>
-    <p><!-- CL 264460 -->
-      The new <a href="/pkg/log/#Default"><code>Default</code></a> function
-      provides access to the default <a href="/pkg/log/#Logger"><code>Logger</code></a>.
-    </p>
-  </dd>
-</dl><!-- log -->
-
-<dl id="log/syslog"><dt><a href="/pkg/log/syslog/">log/syslog</a></dt>
-  <dd>
-    <p><!-- CL 264297 -->
-      The <a href="/pkg/log/syslog/#Writer"><code>Writer</code></a>
-      now uses the local message format
-      (omitting the host name and using a shorter time stamp)
-      when logging to custom Unix domain sockets,
-      matching the format already used for the default log socket.
-    </p>
-  </dd>
-</dl><!-- log/syslog -->
-
-<dl id="mime/multipart"><dt><a href="/pkg/mime/multipart/">mime/multipart</a></dt>
-  <dd>
-    <p><!-- CL 247477 -->
-      The <a href="/pkg/mime/multipart/#Reader"><code>Reader</code></a>'s
-      <a href="/pkg/mime/multipart/#Reader.ReadForm"><code>ReadForm</code></a>
-      method no longer rejects form data
-      when passed the maximum int64 value as a limit.
-    </p>
-  </dd>
-</dl><!-- mime/multipart -->
-
-<dl id="net"><dt><a href="/pkg/net/">net</a></dt>
-  <dd>
-    <p><!-- CL 250357 -->
-      The case of I/O on a closed network connection, or I/O on a network
-      connection that is closed before any of the I/O completes, can now
-      be detected using the new <a href="/pkg/net/#ErrClosed"><code>ErrClosed</code></a>
-      error. A typical use would be <code>errors.Is(err, net.ErrClosed)</code>.
-      In earlier releases the only way to reliably detect this case was to
-      match the string returned by the <code>Error</code> method
-      with <code>"use of closed network connection"</code>.
-    </p>
-
-    <p><!-- CL 255898 -->
-      In previous Go releases the default TCP listener backlog size on Linux systems,
-      set by <code>/proc/sys/net/core/somaxconn</code>, was limited to a maximum of <code>65535</code>.
-      On Linux kernel version 4.1 and above, the maximum is now <code>4294967295</code>.
-    </p>
-
-    <p><!-- CL 238629 -->
-      On Linux, host name lookups no longer use DNS before checking
-      <code>/etc/hosts</code> when <code>/etc/nsswitch.conf</code>
-      is missing; this is common on musl-based systems and makes
-      Go programs match the behavior of C programs on those systems.
-    </p>
-  </dd>
-</dl><!-- net -->
-
-<dl id="net/http"><dt><a href="/pkg/net/http/">net/http</a></dt>
-  <dd>
-    <p><!-- CL 233637 -->
-      In the <a href="/pkg/net/http/"><code>net/http</code></a> package, the
-      behavior of <a href="/pkg/net/http/#StripPrefix"><code>StripPrefix</code></a>
-      has been changed to strip the prefix from the request URL's
-      <code>RawPath</code> field in addition to its <code>Path</code> field.
-      In past releases, only the <code>Path</code> field was trimmed, and so if the
-      request URL contained any escaped characters the URL would be modified to
-      have mismatched <code>Path</code> and <code>RawPath</code> fields.
-      In Go 1.16, <code>StripPrefix</code> trims both fields.
-      If there are escaped characters in the prefix part of the request URL the
-      handler serves a 404 instead of its previous behavior of invoking the
-      underlying handler with a mismatched <code>Path</code>/<code>RawPath</code> pair.
-    </p>
-
-    <p><!-- CL 252497 -->
-      The <a href="/pkg/net/http/"><code>net/http</code></a> package now rejects HTTP range requests
-      of the form <code>"Range": "bytes=--N"</code> where <code>"-N"</code> is a negative suffix length, for
-      example <code>"Range": "bytes=--2"</code>. It now replies with a <code>416 "Range Not Satisfiable"</code> response.
-    </p>
-
-    <p><!-- CL 256498, golang.org/issue/36990 -->
-      Cookies set with <a href="/pkg/net/http/#SameSiteDefaultMode"><code>SameSiteDefaultMode</code></a>
-      now behave according to the current spec (no attribute is set) instead of
-      generating a SameSite key without a value.
-    </p>
-
-    <p><!-- CL 250039 -->
-      The <a href="/pkg/net/http/#Client"><code>Client</code></a> now sends
-      an explicit <code>Content-Length:</code> <code>0</code>
-      header in <code>PATCH</code> requests with empty bodies,
-      matching the existing behavior of <code>POST</code> and <code>PUT</code>.
-    </p>
-
-    <p><!-- CL 249440 -->
-      The <a href="/pkg/net/http/#ProxyFromEnvironment"><code>ProxyFromEnvironment</code></a>
-      function no longer returns the setting of the <code>HTTP_PROXY</code>
-      environment variable for <code>https://</code> URLs when
-      <code>HTTPS_PROXY</code> is unset.
-    </p>
-
-    <p><!-- 259917 -->
-      The <a href="/pkg/net/http/#Transport"><code>Transport</code></a>
-      type has a new field
-      <a href="/pkg/net/http/#Transport.GetProxyConnectHeader"><code>GetProxyConnectHeader</code></a>
-      which may be set to a function that returns headers to send to a
-      proxy during a <code>CONNECT</code> request.
-      In effect <code>GetProxyConnectHeader</code> is a dynamic
-      version of the existing field
-      <a href="/pkg/net/http/#Transport.ProxyConnectHeader"><code>ProxyConnectHeader</code></a>;
-      if <code>GetProxyConnectHeader</code> is not <code>nil</code>,
-      then <code>ProxyConnectHeader</code> is ignored.
-    </p>
-
-    <p><!-- CL 243939 -->
-      The new <a href="/pkg/net/http/#FS"><code>http.FS</code></a>
-      function converts an <a href="/pkg/io/fs/#FS"><code>fs.FS</code></a>
-      to an <a href="/pkg/net/http/#FileSystem"><code>http.FileSystem</code></a>.
-    </p>
-  </dd>
-</dl><!-- net/http -->
-
-<dl id="net/http/httputil"><dt><a href="/pkg/net/http/httputil/">net/http/httputil</a></dt>
-  <dd>
-    <p><!-- CL 260637 -->
-      <a href="/pkg/net/http/httputil/#ReverseProxy"><code>ReverseProxy</code></a>
-      now flushes buffered data more aggressively when proxying
-      streamed responses with unknown body lengths.
-    </p>
-  </dd>
-</dl><!-- net/http/httputil -->
-
-<dl id="net/smtp"><dt><a href="/pkg/net/smtp/">net/smtp</a></dt>
-  <dd>
-    <p><!-- CL 247257 -->
-      The <a href="/pkg/net/smtp/#Client"><code>Client</code></a>'s
-      <a href="/pkg/net/smtp/#Client.Mail"><code>Mail</code></a>
-      method now sends the <code>SMTPUTF8</code> directive to
-      servers that support it, signaling that addresses are encoded in UTF-8.
-    </p>
-  </dd>
-</dl><!-- net/smtp -->
-
-<dl id="os"><dt><a href="/pkg/os/">os</a></dt>
-  <dd>
-    <p><!-- CL 242998 -->
-      <a href="/pkg/os/#Process.Signal"><code>Process.Signal</code></a> now
-      returns <a href="/pkg/os/#ErrProcessDone"><code>ErrProcessDone</code></a>
-      instead of the unexported <code>errFinished</code> when the process has
-      already finished.
-    </p>
-
-    <p><!-- CL 261540 -->
-      The package defines a new type
-      <a href="/pkg/os/#DirEntry"><code>DirEntry</code></a>
-      as an alias for <a href="/pkg/io/fs/#DirEntry"><code>fs.DirEntry</code></a>.
-      The new <a href="/pkg/os/#ReadDir"><code>ReadDir</code></a>
-      function and the new
-      <a href="/pkg/os/#File.ReadDir"><code>File.ReadDir</code></a>
-      method can be used to read the contents of a directory into a
-      slice of <a href="/pkg/os/#DirEntry"><code>DirEntry</code></a>.
-      The <a href="/pkg/os/#File.Readdir"><code>File.Readdir</code></a>
-      method (note the lower case <code>d</code> in <code>dir</code>)
-      still exists, returning a slice of
-      <a href="/pkg/os/#FileInfo"><code>FileInfo</code></a>, but for
-      most programs it will be more efficient to switch to
-      <a href="/pkg/os/#File.ReadDir"><code>File.ReadDir</code></a>.
-    </p>
-
-    <p><!-- CL 263141 -->
-      The package now defines
-      <a href="/pkg/os/#CreateTemp"><code>CreateTemp</code></a>,
-      <a href="/pkg/os/#MkdirTemp"><code>MkdirTemp</code></a>,
-      <a href="/pkg/os/#ReadFile"><code>ReadFile</code></a>, and
-      <a href="/pkg/os/#WriteFile"><code>WriteFile</code></a>,
-      to be used instead of functions defined in the
-      <a href="/pkg/io/ioutil/"><code>io/ioutil</code></a> package.
-    </p>
-
-    <p><!-- CL 243906 -->
-      The types <a href="/pkg/os/#FileInfo"><code>FileInfo</code></a>,
-      <a href="/pkg/os/#FileMode"><code>FileMode</code></a>, and
-      <a href="/pkg/os/#PathError"><code>PathError</code></a>
-      are now aliases for types of the same name in the
-      <a href="/pkg/io/fs/"><code>io/fs</code></a> package.
-      Function signatures in the <a href="/pkg/os/"><code>os</code></a>
-      package have been updated to refer to the names in the
-      <a href="/pkg/io/fs/"><code>io/fs</code></a> package.
-      This should not affect any existing code.
-    </p>
-
-    <p><!-- CL 243911 -->
-      The new <a href="/pkg/os/#DirFS"><code>DirFS</code></a> function
-      provides an implementation of
-      <a href="/pkg/io/fs/#FS"><code>fs.FS</code></a> backed by a tree
-      of operating system files.
-    </p>
-  </dd>
-</dl><!-- os -->
-
-<dl id="os/signal"><dt><a href="/pkg/os/signal/">os/signal</a></dt>
-  <dd>
-    <p><!-- CL 219640 -->
-      The new
-      <a href="/pkg/os/signal/#NotifyContext"><code>NotifyContext</code></a>
-      function allows creating contexts that are canceled upon arrival of
-      specific signals.
-    </p>
-  </dd>
-</dl><!-- os/signal -->
-
-<dl id="path"><dt><a href="/pkg/path/">path</a></dt>
-  <dd>
-    <p><!-- CL 264397, golang.org/issues/28614 -->
-      The <a href="/pkg/path/#Match"><code>Match</code></a> function now
-      returns an error if the unmatched part of the pattern has a
-      syntax error. Previously, the function returned early on a failed
-      match, and thus did not report any later syntax error in the
-      pattern.
-    </p>
-  </dd>
-</dl><!-- path -->
-
-<dl id="path/filepath"><dt><a href="/pkg/path/filepath/">path/filepath</a></dt>
-  <dd>
-    <p><!-- CL 267887 -->
-      The new function
-      <a href="/pkg/path/filepath/#WalkDir"><code>WalkDir</code></a>
-      is similar to
-      <a href="/pkg/path/filepath/#Walk"><code>Walk</code></a>,
-      but is typically more efficient.
-      The function passed to <code>WalkDir</code> receives a
-      <a href="/pkg/io/fs/#DirEntry"><code>fs.DirEntry</code></a>
-      instead of a
-      <a href="/pkg/io/fs/#FileInfo"><code>fs.FileInfo</code></a>.
-      (To clarify for those who recall the <code>Walk</code> function
-      as taking an <a href="/pkg/os/#FileInfo"><code>os.FileInfo</code></a>,
-      <code>os.FileInfo</code> is now an alias for <code>fs.FileInfo</code>.)
-    </p>
-
-    <p><!-- CL 264397, golang.org/issues/28614 -->
-      The <a href="/pkg/path/filepath#Match"><code>Match</code></a> and
-      <a href="/pkg/path/filepath#Glob"><code>Glob</code></a> functions now
-      return an error if the unmatched part of the pattern has a
-      syntax error. Previously, the functions returned early on a failed
-      match, and thus did not report any later syntax error in the
-      pattern.
-    </p>
-  </dd>
-</dl><!-- path/filepath -->
-
-<dl id="runtime/debug"><dt><a href="/pkg/runtime/debug/">runtime/debug</a></dt>
-  <dd>
-    <p><!-- CL 249677 -->
-      The <a href="/pkg/runtime#Error"><code>runtime.Error</code></a> values
-      used when <code>SetPanicOnFault</code> is enabled may now have an
-      <code>Addr</code> method. If that method exists, it returns the memory
-      address that triggered the fault.
-    </p>
-  </dd>
-</dl><!-- runtime/debug -->
-
-<dl id="strconv"><dt><a href="/pkg/strconv/">strconv</a></dt>
-  <dd>
-    <p><!-- CL 260858 -->
-      <a href="/pkg/strconv/#ParseFloat"><code>ParseFloat</code></a> now uses
-      the <a
-      href="https://nigeltao.github.io/blog/2020/eisel-lemire.html">Eisel-Lemire
-      algorithm</a>, improving performance by up to a factor of 2. This can
-      also speed up decoding textual formats like <a
-      href="/pkg/encoding/json/"><code>encoding/json</code></a>.
-    </p>
-  </dd>
-</dl><!-- strconv -->
-
-<dl id="syscall"><dt><a href="/pkg/syscall/">syscall</a></dt>
-  <dd>
-    <p><!-- CL 263271 -->
-      <a href="/pkg/syscall/?GOOS=windows#NewCallback"><code>NewCallback</code></a>
-      and
-      <a href="/pkg/syscall/?GOOS=windows#NewCallbackCDecl"><code>NewCallbackCDecl</code></a>
-      now correctly support callback functions with multiple
-      sub-<code>uintptr</code>-sized arguments in a row. This may
-      require changing uses of these functions to eliminate manual
-      padding between small arguments.
-    </p>
-
-    <p><!-- CL 261917 -->
-      <a href="/pkg/syscall/?GOOS=windows#SysProcAttr"><code>SysProcAttr</code></a> on Windows has a new <code>NoInheritHandles</code> field that disables inheriting handles when creating a new process.
-    </p>
-
-    <p><!-- CL 269761, golang.org/issue/42584 -->
-      <a href="/pkg/syscall/?GOOS=windows#DLLError"><code>DLLError</code></a> on Windows now has an <code>Unwrap</code> method for unwrapping its underlying error.
-    </p>
-
-    <p><!-- CL 210639 -->
-      On Linux,
-      <a href="/pkg/syscall/#Setgid"><code>Setgid</code></a>,
-      <a href="/pkg/syscall/#Setuid"><code>Setuid</code></a>,
-      and related calls are now implemented.
-      Previously, they returned an <code>syscall.EOPNOTSUPP</code> error.
-    </p>
-
-    <p><!-- CL 210639 -->
-      On Linux, the new functions
-      <a href="/pkg/syscall/#AllThreadsSyscall"><code>AllThreadsSyscall</code></a>
-      and <a href="/pkg/syscall/#AllThreadsSyscall6"><code>AllThreadsSyscall6</code></a>
-      may be used to make a system call on all Go threads in the process.
-      These functions may only be used by programs that do not use cgo;
-      if a program uses cgo, they will always return
-      <a href="/pkg/syscall/#ENOTSUP"><code>syscall.ENOTSUP</code></a>.
-    </p>
-  </dd>
-</dl><!-- syscall -->
-
-<dl id="testing/iotest"><dt><a href="/pkg/testing/iotest/">testing/iotest</a></dt>
-  <dd>
-    <p><!-- CL 199501 -->
-      The new
-      <a href="/pkg/testing/iotest/#ErrReader"><code>ErrReader</code></a>
-      function returns an
-      <a href="/pkg/io/#Reader"><code>io.Reader</code></a> that always
-      returns an error.
-    </p>
-
-    <p><!-- CL 243909 -->
-      The new
-      <a href="/pkg/testing/iotest/#TestReader"><code>TestReader</code></a>
-      function tests that an <a href="/pkg/io/#Reader"><code>io.Reader</code></a>
-      behaves correctly.
-    </p>
-  </dd>
-</dl><!-- testing/iotest -->
-
-<dl id="text/template"><dt><a href="/pkg/text/template/">text/template</a></dt>
-  <dd>
-    <p><!-- CL 254257, golang.org/issue/29770 -->
-      Newlines characters are now allowed inside action delimiters,
-      permitting actions to span multiple lines.
-    </p>
-
-    <p><!-- CL 243938 -->
-      The new <a href="/pkg/text/template/#ParseFS"><code>template.ParseFS</code></a>
-      function and <a href="/pkg/text/template/#Template.ParseFS"><code>template.Template.ParseFS</code></a>
-      method are like <a href="/pkg/text/template/#ParseGlob"><code>template.ParseGlob</code></a>
-      and <a href="/pkg/text/template/#Template.ParseGlob"><code>template.Template.ParseGlob</code></a>,
-      but read the templates from an <a href="/pkg/io/fs/#FS"><code>fs.FS</code></a>.
-    </p>
-  </dd>
-</dl><!-- text/template -->
-
-<dl id="text/template/parse"><dt><a href="/pkg/text/template/parse/">text/template/parse</a></dt>
-  <dd>
-    <p><!-- CL 229398, golang.org/issue/34652 -->
-      A new <a href="/pkg/text/template/parse/#CommentNode"><code>CommentNode</code></a>
-      was added to the parse tree. The <a href="/pkg/text/template/parse/#Mode"><code>Mode</code></a>
-      field in the <code>parse.Tree</code> enables access to it.
-    </p>
-  </dd>
-</dl><!-- text/template/parse -->
-
-<dl id="time/tzdata"><dt><a href="/pkg/time/tzdata/">time/tzdata</a></dt>
-  <dd>
-    <p><!-- CL 261877 -->
-      The slim timezone data format is now used for the timezone database in
-      <code>$GOROOT/lib/time/zoneinfo.zip</code> and the embedded copy in this
-      package. This reduces the size of the timezone database by about 350 KB.
-    </p>
-  </dd>
-</dl><!-- time/tzdata -->
-
-<dl id="unicode"><dt><a href="/pkg/unicode/">unicode</a></dt>
-  <dd>
-    <p><!-- CL 248765 -->
-      The <a href="/pkg/unicode/"><code>unicode</code></a> package and associated
-      support throughout the system has been upgraded from Unicode 12.0.0 to
-      <a href="https://www.unicode.org/versions/Unicode13.0.0/">Unicode 13.0.0</a>,
-      which adds 5,930 new characters, including four new scripts, and 55 new emoji.
-      Unicode 13.0.0 also designates plane 3 (U+30000-U+3FFFF) as the tertiary
-      ideographic plane.
-    </p>
-  </dd>
-</dl><!-- unicode -->
diff --git a/doc/go1.17.html b/doc/go1.17.html
new file mode 100644
index 0000000000..79cd4f7b61
--- /dev/null
+++ b/doc/go1.17.html
@@ -0,0 +1,84 @@
+<!--{
+	"Title": "Go 1.17 Release Notes",
+	"Path":  "/doc/go1.17"
+}-->
+
+<!--
+NOTE: In this document and others in this directory, the convention is to
+set fixed-width phrases with non-fixed-width spaces, as in
+<code>hello</code> <code>world</code>.
+Do not send CLs removing the interior tags from such phrases.
+-->
+
+<style>
+  main ul li { margin: 0.5em 0; }
+</style>
+
+<h2 id="introduction">DRAFT RELEASE NOTES — Introduction to Go 1.17</h2>
+
+<p>
+  <strong>
+    Go 1.17 is not yet released. These are work-in-progress
+    release notes. Go 1.17 is expected to be released in August 2021.
+  </strong>
+</p>
+
+<h2 id="language">Changes to the language</h2>
+
+<p>
+  TODO: complete this section
+</p>
+
+<h2 id="ports">Ports</h2>
+
+<p>
+  TODO: complete this section, or delete if not needed
+</p>
+
+<h2 id="tools">Tools</h2>
+
+<p>
+  TODO: complete this section, or delete if not needed
+</p>
+
+<h3 id="go-command">Go command</h3>
+
+<p>
+  TODO: complete this section, or delete if not needed
+</p>
+
+<h2 id="runtime">Runtime</h2>
+
+<p>
+  TODO: complete this section, or delete if not needed
+</p>
+
+<h2 id="compiler">Compiler</h2>
+
+<p>
+  TODO: complete this section, or delete if not needed
+</p>
+
+<h2 id="linker">Linker</h2>
+
+<p>
+  TODO: complete this section, or delete if not needed
+</p>
+
+<h2 id="library">Core library</h2>
+
+<p>
+  TODO: complete this section
+</p>
+
+<h3 id="minor_library_changes">Minor changes to the library</h3>
+
+<p>
+  As always, there are various minor changes and updates to the library,
+  made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
+  in mind.
+</p>
+
+<p>
+  TODO: complete this section
+</p>
-- 
GitLab


From 0458d8c9830f80e8063c384bf4282843ed36a946 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 23 Feb 2021 12:47:08 -0800
Subject: [PATCH 0801/2400] go/types, types2: constraints may be parenthesized
 and that includes "any"

Change-Id: I9a234cc1f04ca762375b51ec8ef009fb264c7ed1
Reviewed-on: https://go-review.googlesource.com/c/go/+/295689
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/decl.go                 | 2 +-
 src/cmd/compile/internal/types2/testdata/typeparams.go2 | 4 ++++
 src/go/types/decl.go                                    | 2 +-
 src/go/types/testdata/typeparams.go2                    | 4 ++++
 4 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index 677172d40f..f0a037adb0 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -707,7 +707,7 @@ func (check *Checker) collectTypeParams(list []*syntax.Field) (tparams []*TypeNa
 		// The predeclared identifier "any" is visible only as a constraint
 		// in a type parameter list. Look for it before general constraint
 		// resolution.
-		if tident, _ := f.Type.(*syntax.Name); tident != nil && tident.Value == "any" && check.lookup("any") == nil {
+		if tident, _ := unparen(f.Type).(*syntax.Name); tident != nil && tident.Value == "any" && check.lookup("any") == nil {
 			bound = universeAny
 		} else {
 			bound = check.typ(f.Type)
diff --git a/src/cmd/compile/internal/types2/testdata/typeparams.go2 b/src/cmd/compile/internal/types2/testdata/typeparams.go2
index 04f563029f..41306b6e23 100644
--- a/src/cmd/compile/internal/types2/testdata/typeparams.go2
+++ b/src/cmd/compile/internal/types2/testdata/typeparams.go2
@@ -19,6 +19,10 @@ func _[_ any](x int) int
 func _[T any](T /* ERROR redeclared */ T)()
 func _[T, T /* ERROR redeclared */ any]()
 
+// Constraints (incl. any) may be parenthesized.
+func _[_ (any)]() {}
+func _[_ (interface{})]() {}
+
 func reverse[T any](list []T) []T {
         rlist := make([]T, len(list))
         i := len(list)
diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index c97b1a66bb..1134607e92 100644
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -726,7 +726,7 @@ func (check *Checker) collectTypeParams(list *ast.FieldList) (tparams []*TypeNam
 		// The predeclared identifier "any" is visible only as a constraint
 		// in a type parameter list. Look for it before general constraint
 		// resolution.
-		if tident, _ := f.Type.(*ast.Ident); tident != nil && tident.Name == "any" && check.lookup("any") == nil {
+		if tident, _ := unparen(f.Type).(*ast.Ident); tident != nil && tident.Name == "any" && check.lookup("any") == nil {
 			bound = universeAny
 		} else {
 			bound = check.typ(f.Type)
diff --git a/src/go/types/testdata/typeparams.go2 b/src/go/types/testdata/typeparams.go2
index 2dd8f64dc0..bb7f016a83 100644
--- a/src/go/types/testdata/typeparams.go2
+++ b/src/go/types/testdata/typeparams.go2
@@ -19,6 +19,10 @@ func _[_ any](x int) int
 func _[T any](T /* ERROR redeclared */ T)()
 func _[T, T /* ERROR redeclared */ any]()
 
+// Constraints (incl. any) may be parenthesized.
+func _[_ (any)]() {}
+func _[_ (interface{})]() {}
+
 func reverse[T any](list []T) []T {
         rlist := make([]T, len(list))
         i := len(list)
-- 
GitLab


From fbed561f8a596ddbd2bb599a17ea3c6e0b223602 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Tue, 23 Feb 2021 14:02:33 -0500
Subject: [PATCH 0802/2400] runtime: reset stack poison flag accidentally set

See if this clears failure on openbsd-amd64-68 (ahem).

Change-Id: Ifa60ef711a95e5de8ad91433ffa425f75b36c76f
Reviewed-on: https://go-review.googlesource.com/c/go/+/295629
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/stack.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/stack.go b/src/runtime/stack.go
index c572f7296f..d971e5e26f 100644
--- a/src/runtime/stack.go
+++ b/src/runtime/stack.go
@@ -112,7 +112,7 @@ const (
 	stackDebug       = 0
 	stackFromSystem  = 0 // allocate stacks from system memory instead of the heap
 	stackFaultOnFree = 0 // old stacks are mapped noaccess to detect use after free
-	stackPoisonCopy  = 1 // fill stack that should not be accessed with garbage, to detect bad dereferences during copy
+	stackPoisonCopy  = 0 // fill stack that should not be accessed with garbage, to detect bad dereferences during copy
 	stackNoCache     = 0 // disable per-P small stack caches
 
 	// check the BP links during traceback.
-- 
GitLab


From aaed6cbced238030053df4e54f676a1d59df89d7 Mon Sep 17 00:00:00 2001
From: "Daniel S. Fava" <danielsfava@gmail.com>
Date: Fri, 12 Feb 2021 09:54:50 +0100
Subject: [PATCH 0803/2400] testing/race: fixing intermittent test failure

Test NoRaceMutexPureHappensBefore in runtime/race/testdata/mutex_test.go
expects the second spawned goroutine to run after the first.  The test
attempts to force this scheduling with a 10 millisecond wait.  Following
a suggestion by Bryan Mills, we force this scheduling using a shared
variable whose access take place within the existing mutex.

Fixes #35745.

Change-Id: Ib23ec51492ecfeed4752e020401dd25755a669ed
Reviewed-on: https://go-review.googlesource.com/c/go/+/291292
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Dmitry Vyukov <dvyukov@google.com>
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/race/testdata/mutex_test.go | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/runtime/race/testdata/mutex_test.go b/src/runtime/race/testdata/mutex_test.go
index cbed2d370c..9dbed9a2c9 100644
--- a/src/runtime/race/testdata/mutex_test.go
+++ b/src/runtime/race/testdata/mutex_test.go
@@ -78,16 +78,23 @@ func TestNoRaceMutexPureHappensBefore(t *testing.T) {
 	var mu sync.Mutex
 	var x int16 = 0
 	_ = x
+	written := false
 	ch := make(chan bool, 2)
 	go func() {
 		x = 1
 		mu.Lock()
+		written = true
 		mu.Unlock()
 		ch <- true
 	}()
 	go func() {
-		<-time.After(1e5)
+		time.Sleep(100 * time.Microsecond)
 		mu.Lock()
+		for !written {
+			mu.Unlock()
+			time.Sleep(100 * time.Microsecond)
+			mu.Lock()
+		}
 		mu.Unlock()
 		x = 1
 		ch <- true
-- 
GitLab


From 42b9e3a8dfb31f18829c45f0995cbf3c78fc90fb Mon Sep 17 00:00:00 2001
From: Keiichi Hirobe <chalenge.akane@gmail.com>
Date: Sun, 21 Feb 2021 12:22:13 +0900
Subject: [PATCH 0804/2400] context: fix XTestInterlockedCancels

The test does not use Done channel, so fix that.

Change-Id: I795feab2e95de815b8b6ee7a7fd90f19f7af7db1
Reviewed-on: https://go-review.googlesource.com/c/go/+/294749
Reviewed-by: Sameer Ajmani <sameer@golang.org>
Trust: Sameer Ajmani <sameer@golang.org>
Trust: Cody Oss <codyoss@google.com>
Run-TryBot: Sameer Ajmani <sameer@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/context/context_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/context/context_test.go b/src/context/context_test.go
index 6b392a29da..84eef01da1 100644
--- a/src/context/context_test.go
+++ b/src/context/context_test.go
@@ -525,7 +525,7 @@ func XTestInterlockedCancels(t testingT) {
 	parent, cancelParent := WithCancel(Background())
 	child, cancelChild := WithCancel(parent)
 	go func() {
-		parent.Done()
+		<-parent.Done()
 		cancelChild()
 	}()
 	cancelParent()
-- 
GitLab


From 6cc8aa7ece96aca282db19f08aa5c98ed13695d9 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 23 Feb 2021 11:48:15 -0500
Subject: [PATCH 0805/2400] go/types: minor updates to comments to align with
 types2

Change-Id: Ic4fcd67cd9222eae6b72d9e91e37f3b0293b0b8d
Reviewed-on: https://go-review.googlesource.com/c/go/+/295530
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/go/types/conversions.go | 2 +-
 src/go/types/issues_test.go | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/go/types/conversions.go b/src/go/types/conversions.go
index 69463f0ca6..d93ff465bb 100644
--- a/src/go/types/conversions.go
+++ b/src/go/types/conversions.go
@@ -142,7 +142,7 @@ func isUintptr(typ Type) bool {
 }
 
 func isUnsafePointer(typ Type) bool {
-	// TODO(gri): Is this asBasic() instead of typ.(*Basic) correct?
+	// TODO(gri): Is this asBasic(typ) instead of typ.(*Basic) correct?
 	//            (The former calls under(), while the latter doesn't.)
 	//            The spec does not say so, but gc claims it is. See also
 	//            issue 6326.
diff --git a/src/go/types/issues_test.go b/src/go/types/issues_test.go
index 9ed2934c74..a773a362c7 100644
--- a/src/go/types/issues_test.go
+++ b/src/go/types/issues_test.go
@@ -385,9 +385,9 @@ func TestIssue28005(t *testing.T) {
 			}
 		}
 		if obj == nil {
-			t.Fatal("interface not found")
+			t.Fatal("object X not found")
 		}
-		iface := obj.Type().Underlying().(*Interface) // I must be an interface
+		iface := obj.Type().Underlying().(*Interface) // object X must be an interface
 
 		// Each iface method m is embedded; and m's receiver base type name
 		// must match the method's name per the choice in the source file.
-- 
GitLab


From 0694fb3d78f9ce2add154203dbd42a7a5a07c2da Mon Sep 17 00:00:00 2001
From: Andy Pan <panjf2000@gmail.com>
Date: Tue, 10 Nov 2020 17:56:33 +0800
Subject: [PATCH 0806/2400] image: resolve the TODO of doc comment style

Change-Id: Ic7701a9e4635fe1a331c9a1df776ed580759eb9d
Reviewed-on: https://go-review.googlesource.com/c/go/+/268758
Reviewed-by: Nigel Tao <nigeltao@golang.org>
Reviewed-by: Rob Pike <r@golang.org>
Trust: Nigel Tao <nigeltao@golang.org>
Trust: Alberto Donizetti <alb.donizetti@gmail.com>
Trust: Rob Pike <r@golang.org>
---
 src/image/jpeg/reader.go | 3 ---
 src/image/png/writer.go  | 1 +
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/image/jpeg/reader.go b/src/image/jpeg/reader.go
index 4a4706ffe7..b34072396c 100644
--- a/src/image/jpeg/reader.go
+++ b/src/image/jpeg/reader.go
@@ -14,9 +14,6 @@ import (
 	"io"
 )
 
-// TODO(nigeltao): fix up the doc comment style so that sentences start with
-// the name of the type or function that they annotate.
-
 // A FormatError reports that the input is not a valid JPEG.
 type FormatError string
 
diff --git a/src/image/png/writer.go b/src/image/png/writer.go
index 53adc1633c..cbcdb9e798 100644
--- a/src/image/png/writer.go
+++ b/src/image/png/writer.go
@@ -51,6 +51,7 @@ type encoder struct {
 	bw      *bufio.Writer
 }
 
+// CompressionLevel indicates the compression level.
 type CompressionLevel int
 
 const (
-- 
GitLab


From 37805292550e7144200b09320ffb61f21d421f8d Mon Sep 17 00:00:00 2001
From: David Benjamin <davidben@google.com>
Date: Fri, 25 Dec 2020 12:02:55 -0500
Subject: [PATCH 0807/2400] unicode: correctly handle negative runes

Is and isExcludingLatin did not handle negative runes when dispatching
to is16. TestNegativeRune covers this along with the existing uint32
casts in IsGraphic, etc. (For tests, I picked the smallest non-Latin-1
code point in each range.)

Updates #43254

Change-Id: I17261b91f0d2b5b5125d19219411b45c480df74f
Reviewed-on: https://go-review.googlesource.com/c/go/+/280493
Run-TryBot: Rob Pike <r@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Rob Pike <r@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/unicode/letter.go      |  6 ++-
 src/unicode/letter_test.go | 79 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 83 insertions(+), 2 deletions(-)

diff --git a/src/unicode/letter.go b/src/unicode/letter.go
index a57566f0a5..268e457a87 100644
--- a/src/unicode/letter.go
+++ b/src/unicode/letter.go
@@ -154,7 +154,8 @@ func is32(ranges []Range32, r uint32) bool {
 // Is reports whether the rune is in the specified table of ranges.
 func Is(rangeTab *RangeTable, r rune) bool {
 	r16 := rangeTab.R16
-	if len(r16) > 0 && r <= rune(r16[len(r16)-1].Hi) {
+	// Compare as uint32 to correctly handle negative runes.
+	if len(r16) > 0 && uint32(r) <= uint32(r16[len(r16)-1].Hi) {
 		return is16(r16, uint16(r))
 	}
 	r32 := rangeTab.R32
@@ -166,7 +167,8 @@ func Is(rangeTab *RangeTable, r rune) bool {
 
 func isExcludingLatin(rangeTab *RangeTable, r rune) bool {
 	r16 := rangeTab.R16
-	if off := rangeTab.LatinOffset; len(r16) > off && r <= rune(r16[len(r16)-1].Hi) {
+	// Compare as uint32 to correctly handle negative runes.
+	if off := rangeTab.LatinOffset; len(r16) > off && uint32(r) <= uint32(r16[len(r16)-1].Hi) {
 		return is16(r16[off:], uint16(r))
 	}
 	r32 := rangeTab.R32
diff --git a/src/unicode/letter_test.go b/src/unicode/letter_test.go
index 19ee535d57..a91e3a326f 100644
--- a/src/unicode/letter_test.go
+++ b/src/unicode/letter_test.go
@@ -563,3 +563,82 @@ func TestSpecialCaseNoMapping(t *testing.T) {
 		t.Errorf("got %q; want %q", got, want)
 	}
 }
+
+func TestNegativeRune(t *testing.T) {
+	// Issue 43254
+	// These tests cover negative rune handling by testing values which,
+	// when cast to uint8 or uint16, look like a particular valid rune.
+	// This package has Latin-1-specific optimizations, so we test all of
+	// Latin-1 and representative non-Latin-1 values in the character
+	// categories covered by IsGraphic, etc.
+	nonLatin1 := []uint32{
+		// Lu: LATIN CAPITAL LETTER A WITH MACRON
+		0x0100,
+		// Ll: LATIN SMALL LETTER A WITH MACRON
+		0x0101,
+		// Lt: LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON
+		0x01C5,
+		// M: COMBINING GRAVE ACCENT
+		0x0300,
+		// Nd: ARABIC-INDIC DIGIT ZERO
+		0x0660,
+		// P: GREEK QUESTION MARK
+		0x037E,
+		// S: MODIFIER LETTER LEFT ARROWHEAD
+		0x02C2,
+		// Z: OGHAM SPACE MARK
+		0x1680,
+	}
+	for i := 0; i < MaxLatin1+len(nonLatin1); i++ {
+		base := uint32(i)
+		if i >= MaxLatin1 {
+			base = nonLatin1[i-MaxLatin1]
+		}
+
+		// Note r is negative, but uint8(r) == uint8(base) and
+		// uint16(r) == uint16(base).
+		r := rune(base - 1<<31)
+		if Is(Letter, r) {
+			t.Errorf("Is(Letter, 0x%x - 1<<31) = true, want false", base)
+		}
+		if IsControl(r) {
+			t.Errorf("IsControl(0x%x - 1<<31) = true, want false", base)
+		}
+		if IsDigit(r) {
+			t.Errorf("IsDigit(0x%x - 1<<31) = true, want false", base)
+		}
+		if IsGraphic(r) {
+			t.Errorf("IsGraphic(0x%x - 1<<31) = true, want false", base)
+		}
+		if IsLetter(r) {
+			t.Errorf("IsLetter(0x%x - 1<<31) = true, want false", base)
+		}
+		if IsLower(r) {
+			t.Errorf("IsLower(0x%x - 1<<31) = true, want false", base)
+		}
+		if IsMark(r) {
+			t.Errorf("IsMark(0x%x - 1<<31) = true, want false", base)
+		}
+		if IsNumber(r) {
+			t.Errorf("IsNumber(0x%x - 1<<31) = true, want false", base)
+		}
+		if IsPrint(r) {
+			t.Errorf("IsPrint(0x%x - 1<<31) = true, want false", base)
+		}
+		if IsPunct(r) {
+			t.Errorf("IsPunct(0x%x - 1<<31) = true, want false", base)
+		}
+		if IsSpace(r) {
+			t.Errorf("IsSpace(0x%x - 1<<31) = true, want false", base)
+		}
+		if IsSymbol(r) {
+			t.Errorf("IsSymbol(0x%x - 1<<31) = true, want false", base)
+		}
+		if IsTitle(r) {
+			t.Errorf("IsTitle(0x%x - 1<<31) = true, want false", base)
+		}
+		if IsUpper(r) {
+			t.Errorf("IsUpper(0x%x - 1<<31) = true, want false", base)
+		}
+	}
+}
-- 
GitLab


From 43652dc46f770253b3603f47165b1568b439b0b5 Mon Sep 17 00:00:00 2001
From: David Benjamin <davidben@google.com>
Date: Fri, 25 Dec 2020 12:02:04 -0500
Subject: [PATCH 0808/2400] bufio, bytes, strings: handle negative runes in
 WriteRune

Updates #43254

Change-Id: I7d4bf3b99cc36ca2156af5bb01a1c595419d1d3c
Reviewed-on: https://go-review.googlesource.com/c/go/+/280492
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Rob Pike <r@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/bufio/bufio.go          |  3 ++-
 src/bufio/bufio_test.go     | 14 ++++++++++++++
 src/bytes/buffer.go         |  3 ++-
 src/bytes/buffer_test.go    | 11 +++++++++++
 src/strings/builder.go      |  3 ++-
 src/strings/builder_test.go | 11 +++++++++++
 6 files changed, 42 insertions(+), 3 deletions(-)

diff --git a/src/bufio/bufio.go b/src/bufio/bufio.go
index 6baf9b9e40..ec928e7ad6 100644
--- a/src/bufio/bufio.go
+++ b/src/bufio/bufio.go
@@ -670,7 +670,8 @@ func (b *Writer) WriteByte(c byte) error {
 // WriteRune writes a single Unicode code point, returning
 // the number of bytes written and any error.
 func (b *Writer) WriteRune(r rune) (size int, err error) {
-	if r < utf8.RuneSelf {
+	// Compare as uint32 to correctly handle negative runes.
+	if uint32(r) < utf8.RuneSelf {
 		err = b.WriteByte(byte(r))
 		if err != nil {
 			return 0, err
diff --git a/src/bufio/bufio_test.go b/src/bufio/bufio_test.go
index d7b34bd0d8..ebcc711db9 100644
--- a/src/bufio/bufio_test.go
+++ b/src/bufio/bufio_test.go
@@ -534,6 +534,20 @@ func TestReadWriteRune(t *testing.T) {
 	}
 }
 
+func TestWriteInvalidRune(t *testing.T) {
+	// Invalid runes, including negative ones, should be written as the
+	// replacement character.
+	for _, r := range []rune{-1, utf8.MaxRune + 1} {
+		var buf bytes.Buffer
+		w := NewWriter(&buf)
+		w.WriteRune(r)
+		w.Flush()
+		if s := buf.String(); s != "\uFFFD" {
+			t.Errorf("WriteRune(%d) wrote %q, not replacement character", r, s)
+		}
+	}
+}
+
 func TestReadStringAllocs(t *testing.T) {
 	r := strings.NewReader("       foo       foo        42        42        42        42        42        42        42        42       4.2       4.2       4.2       4.2\n")
 	buf := NewReader(r)
diff --git a/src/bytes/buffer.go b/src/bytes/buffer.go
index f19a4cfff0..549b077708 100644
--- a/src/bytes/buffer.go
+++ b/src/bytes/buffer.go
@@ -275,7 +275,8 @@ func (b *Buffer) WriteByte(c byte) error {
 // included to match bufio.Writer's WriteRune. The buffer is grown as needed;
 // if it becomes too large, WriteRune will panic with ErrTooLarge.
 func (b *Buffer) WriteRune(r rune) (n int, err error) {
-	if r < utf8.RuneSelf {
+	// Compare as uint32 to correctly handle negative runes.
+	if uint32(r) < utf8.RuneSelf {
 		b.WriteByte(byte(r))
 		return 1, nil
 	}
diff --git a/src/bytes/buffer_test.go b/src/bytes/buffer_test.go
index fec5ef8a35..9c9b7440ff 100644
--- a/src/bytes/buffer_test.go
+++ b/src/bytes/buffer_test.go
@@ -6,6 +6,7 @@ package bytes_test
 
 import (
 	. "bytes"
+	"fmt"
 	"io"
 	"math/rand"
 	"testing"
@@ -387,6 +388,16 @@ func TestRuneIO(t *testing.T) {
 	}
 }
 
+func TestWriteInvalidRune(t *testing.T) {
+	// Invalid runes, including negative ones, should be written as
+	// utf8.RuneError.
+	for _, r := range []rune{-1, utf8.MaxRune + 1} {
+		var buf Buffer
+		buf.WriteRune(r)
+		check(t, fmt.Sprintf("TestWriteInvalidRune (%d)", r), &buf, "\uFFFD")
+	}
+}
+
 func TestNext(t *testing.T) {
 	b := []byte{0, 1, 2, 3, 4}
 	tmp := make([]byte, 5)
diff --git a/src/strings/builder.go b/src/strings/builder.go
index 6ff151d74b..547e52e84d 100644
--- a/src/strings/builder.go
+++ b/src/strings/builder.go
@@ -103,7 +103,8 @@ func (b *Builder) WriteByte(c byte) error {
 // It returns the length of r and a nil error.
 func (b *Builder) WriteRune(r rune) (int, error) {
 	b.copyCheck()
-	if r < utf8.RuneSelf {
+	// Compare as uint32 to correctly handle negative runes.
+	if uint32(r) < utf8.RuneSelf {
 		b.buf = append(b.buf, byte(r))
 		return 1, nil
 	}
diff --git a/src/strings/builder_test.go b/src/strings/builder_test.go
index b662efe7a5..e3d239266f 100644
--- a/src/strings/builder_test.go
+++ b/src/strings/builder_test.go
@@ -8,6 +8,7 @@ import (
 	"bytes"
 	. "strings"
 	"testing"
+	"unicode/utf8"
 )
 
 func check(t *testing.T, b *Builder, want string) {
@@ -301,6 +302,16 @@ func TestBuilderCopyPanic(t *testing.T) {
 	}
 }
 
+func TestBuilderWriteInvalidRune(t *testing.T) {
+	// Invalid runes, including negative ones, should be written as
+	// utf8.RuneError.
+	for _, r := range []rune{-1, utf8.MaxRune + 1} {
+		var b Builder
+		b.WriteRune(r)
+		check(t, &b, "\uFFFD")
+	}
+}
+
 var someBytes = []byte("some bytes sdljlk jsklj3lkjlk djlkjw")
 
 var sinkS string
-- 
GitLab


From 6ba4a300d894b33fd8bf076dec08a5e3245d3a2c Mon Sep 17 00:00:00 2001
From: John Bampton <jbampton@gmail.com>
Date: Wed, 17 Feb 2021 01:48:21 +0000
Subject: [PATCH 0809/2400] docs: fix spelling

Change-Id: Ib689e5793d9cb372e759c4f34af71f004010c822
GitHub-Last-Rev: d63798388e5dcccb984689b0ae39b87453b97393
GitHub-Pull-Request: golang/go#44259
Reviewed-on: https://go-review.googlesource.com/c/go/+/291949
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/ssa/value.go                       | 2 +-
 .../mod/example.com_split-incompatible_subpkg_v0.1.0.txt    | 2 +-
 src/cmd/go/testdata/script/mod_empty_err.txt                | 2 +-
 src/cmd/go/testdata/script/mod_outside.txt                  | 2 +-
 src/cmd/go/testdata/script/test_chatty_parallel_fail.txt    | 2 +-
 src/cmd/go/testdata/script/test_chatty_parallel_success.txt | 2 +-
 .../testdata/script/test_chatty_parallel_success_sleepy.txt | 2 +-
 src/cmd/internal/archive/archive_test.go                    | 4 ++--
 src/cmd/internal/goobj/objfile.go                           | 2 +-
 src/cmd/internal/obj/objfile.go                             | 4 ++--
 src/cmd/internal/obj/pcln.go                                | 2 +-
 src/cmd/internal/obj/x86/asm6.go                            | 2 +-
 src/cmd/link/internal/ld/pcln.go                            | 4 ++--
 src/cmd/link/internal/loader/loader.go                      | 2 +-
 src/crypto/tls/handshake_client_test.go                     | 6 +++---
 src/internal/poll/copy_file_range_linux.go                  | 6 +++---
 src/os/readfrom_linux_test.go                               | 6 +++---
 src/runtime/chan_test.go                                    | 4 ++--
 src/runtime/lockrank_on.go                                  | 2 +-
 src/runtime/metrics.go                                      | 2 +-
 src/runtime/mgcscavenge.go                                  | 2 +-
 test/prove.go                                               | 2 +-
 22 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go
index d000b7cce0..6539631b9c 100644
--- a/src/cmd/compile/internal/ssa/value.go
+++ b/src/cmd/compile/internal/ssa/value.go
@@ -484,7 +484,7 @@ func (v *Value) removeable() bool {
 	if v.Type.IsMemory() {
 		// All memory ops aren't needed here, but we do need
 		// to keep calls at least (because they might have
-		// syncronization operations we can't see).
+		// synchronization operations we can't see).
 		return false
 	}
 	if v.Op.HasSideEffects() {
diff --git a/src/cmd/go/testdata/mod/example.com_split-incompatible_subpkg_v0.1.0.txt b/src/cmd/go/testdata/mod/example.com_split-incompatible_subpkg_v0.1.0.txt
index 8f9e49176c..edf5d48788 100644
--- a/src/cmd/go/testdata/mod/example.com_split-incompatible_subpkg_v0.1.0.txt
+++ b/src/cmd/go/testdata/mod/example.com_split-incompatible_subpkg_v0.1.0.txt
@@ -1,6 +1,6 @@
 Written by hand.
 Test case for getting a package that has been moved to a nested module,
-with a +incompatible verison (and thus no go.mod file) at the root module.
+with a +incompatible version (and thus no go.mod file) at the root module.
 
 -- .mod --
 module example.com/split-incompatible/subpkg
diff --git a/src/cmd/go/testdata/script/mod_empty_err.txt b/src/cmd/go/testdata/script/mod_empty_err.txt
index 982e6b2e51..c4359bcccc 100644
--- a/src/cmd/go/testdata/script/mod_empty_err.txt
+++ b/src/cmd/go/testdata/script/mod_empty_err.txt
@@ -1,4 +1,4 @@
-# This test checks error messages for non-existant packages in module mode.
+# This test checks error messages for non-existent packages in module mode.
 # Veries golang.org/issue/35414
 env GO111MODULE=on
 cd $WORK
diff --git a/src/cmd/go/testdata/script/mod_outside.txt b/src/cmd/go/testdata/script/mod_outside.txt
index 8f01b5d242..7b45f1a209 100644
--- a/src/cmd/go/testdata/script/mod_outside.txt
+++ b/src/cmd/go/testdata/script/mod_outside.txt
@@ -200,7 +200,7 @@ stderr 'needmod[/\\]needmod.go:10:2: no required module provides package example
 go install cmd/addr2line
 ! stderr .
 
-# 'go run' with a verison should fail due to syntax.
+# 'go run' with a version should fail due to syntax.
 ! go run example.com/printversion@v1.0.0
 stderr 'can only use path@version syntax with'
 
diff --git a/src/cmd/go/testdata/script/test_chatty_parallel_fail.txt b/src/cmd/go/testdata/script/test_chatty_parallel_fail.txt
index 3f7360b659..3b2791cb89 100644
--- a/src/cmd/go/testdata/script/test_chatty_parallel_fail.txt
+++ b/src/cmd/go/testdata/script/test_chatty_parallel_fail.txt
@@ -14,7 +14,7 @@ stdout -count=1 '{"Time":"[0-9TZ:.+-]{20,40}","Action":"output","Package":"comma
 stdout -count=1 '{"Time":"[0-9TZ:.+-]{20,40}","Action":"output","Package":"command-line-arguments","Test":"TestChattyParallel/sub-2","Output":"=== CONT  TestChattyParallel/sub-2\\n"}\n{"Time":"[0-9TZ:.+-]{20,40}","Action":"output","Package":"command-line-arguments","Test":"TestChattyParallel/sub-2","Output":"    chatty_parallel_test.go:38: error from sub-2\\n"}'
 
 -- chatty_parallel_test.go --
-package chatty_paralell_test
+package chatty_parallel_test
 
 import (
 	"testing"
diff --git a/src/cmd/go/testdata/script/test_chatty_parallel_success.txt b/src/cmd/go/testdata/script/test_chatty_parallel_success.txt
index 4a86d74f19..58b5ab7267 100644
--- a/src/cmd/go/testdata/script/test_chatty_parallel_success.txt
+++ b/src/cmd/go/testdata/script/test_chatty_parallel_success.txt
@@ -13,7 +13,7 @@ stdout -count=2 '{"Time":"[0-9TZ:.+-]{20,40}","Action":"output","Package":"comma
 stdout -count=2 '{"Time":"[0-9TZ:.+-]{20,40}","Action":"output","Package":"command-line-arguments","Test":"TestChattyParallel/sub-2","Output":"=== CONT  TestChattyParallel/sub-2\\n"}\n{"Time":"[0-9TZ:.+-]{20,40}","Action":"output","Package":"command-line-arguments","Test":"TestChattyParallel/sub-2","Output":"    chatty_parallel_test.go:32: this is sub-2\\n"}'
 
 -- chatty_parallel_test.go --
-package chatty_paralell_test
+package chatty_parallel_test
 
 import (
 	"testing"
diff --git a/src/cmd/go/testdata/script/test_chatty_parallel_success_sleepy.txt b/src/cmd/go/testdata/script/test_chatty_parallel_success_sleepy.txt
index 5952a87bea..e651a7ed24 100644
--- a/src/cmd/go/testdata/script/test_chatty_parallel_success_sleepy.txt
+++ b/src/cmd/go/testdata/script/test_chatty_parallel_success_sleepy.txt
@@ -5,7 +5,7 @@ go test -parallel 3 chatty_parallel_test.go -v
 stdout '--- PASS: TestFast \([0-9.]{4}s\)\n=== CONT  TestSlow\n    chatty_parallel_test.go:31: this is the second TestSlow log\n--- PASS: TestSlow \([0-9.]{4}s\)'
 
 -- chatty_parallel_test.go --
-package chatty_paralell_test
+package chatty_parallel_test
 
 import (
 	"testing"
diff --git a/src/cmd/internal/archive/archive_test.go b/src/cmd/internal/archive/archive_test.go
index cb4eb842b4..c284a9cf0d 100644
--- a/src/cmd/internal/archive/archive_test.go
+++ b/src/cmd/internal/archive/archive_test.go
@@ -173,7 +173,7 @@ func TestParseGoobj(t *testing.T) {
 			continue
 		}
 		if e.Type != EntryGoObj {
-			t.Errorf("wrong type of object: wnat EntryGoObj, got %v", e.Type)
+			t.Errorf("wrong type of object: want EntryGoObj, got %v", e.Type)
 		}
 		if !bytes.Contains(e.Obj.TextHeader, []byte(runtime.GOARCH)) {
 			t.Errorf("text header does not contain GOARCH %s: %q", runtime.GOARCH, e.Obj.TextHeader)
@@ -204,7 +204,7 @@ func TestParseArchive(t *testing.T) {
 			continue
 		}
 		if e.Type != EntryGoObj {
-			t.Errorf("wrong type of object: wnat EntryGoObj, got %v", e.Type)
+			t.Errorf("wrong type of object: want EntryGoObj, got %v", e.Type)
 		}
 		if !bytes.Contains(e.Obj.TextHeader, []byte(runtime.GOARCH)) {
 			t.Errorf("text header does not contain GOARCH %s: %q", runtime.GOARCH, e.Obj.TextHeader)
diff --git a/src/cmd/internal/goobj/objfile.go b/src/cmd/internal/goobj/objfile.go
index d1b838f676..247cc695f0 100644
--- a/src/cmd/internal/goobj/objfile.go
+++ b/src/cmd/internal/goobj/objfile.go
@@ -481,7 +481,7 @@ func (r *RefFlags) SetFlag2(x uint8) { r[9] = x }
 
 func (r *RefFlags) Write(w *Writer) { w.Bytes(r[:]) }
 
-// Used to construct an artifically large array type when reading an
+// Used to construct an artificially large array type when reading an
 // item from the object file relocs section or aux sym section (needs
 // to work on 32-bit as well as 64-bit). See issue 41621.
 const huge = (1<<31 - 1) / RelocSize
diff --git a/src/cmd/internal/obj/objfile.go b/src/cmd/internal/obj/objfile.go
index 85f0570e5d..b031afbc36 100644
--- a/src/cmd/internal/obj/objfile.go
+++ b/src/cmd/internal/obj/objfile.go
@@ -383,7 +383,7 @@ func (w *writer) Sym(s *LSym) {
 
 func (w *writer) Hash64(s *LSym) {
 	if !s.ContentAddressable() || len(s.R) != 0 {
-		panic("Hash of non-content-addresable symbol")
+		panic("Hash of non-content-addressable symbol")
 	}
 	b := contentHash64(s)
 	w.Bytes(b[:])
@@ -391,7 +391,7 @@ func (w *writer) Hash64(s *LSym) {
 
 func (w *writer) Hash(s *LSym) {
 	if !s.ContentAddressable() {
-		panic("Hash of non-content-addresable symbol")
+		panic("Hash of non-content-addressable symbol")
 	}
 	b := w.contentHash(s)
 	w.Bytes(b[:])
diff --git a/src/cmd/internal/obj/pcln.go b/src/cmd/internal/obj/pcln.go
index 67c4f9a62b..7af81335fb 100644
--- a/src/cmd/internal/obj/pcln.go
+++ b/src/cmd/internal/obj/pcln.go
@@ -37,7 +37,7 @@ func funcpctab(ctxt *Link, func_ *LSym, desc string, valfunc func(*Link, *LSym,
 	oldval := val
 	fn := func_.Func()
 	if fn.Text == nil {
-		// Return the emtpy symbol we've built so far.
+		// Return the empty symbol we've built so far.
 		return sym
 	}
 
diff --git a/src/cmd/internal/obj/x86/asm6.go b/src/cmd/internal/obj/x86/asm6.go
index a6b85ac4a0..fa670d5c18 100644
--- a/src/cmd/internal/obj/x86/asm6.go
+++ b/src/cmd/internal/obj/x86/asm6.go
@@ -1887,7 +1887,7 @@ func lookForJCC(p *obj.Prog) *obj.Prog {
 func fusedJump(p *obj.Prog) (bool, uint8) {
 	var fusedSize uint8
 
-	// The first instruction in a macro fused pair may be preceeded by the LOCK prefix,
+	// The first instruction in a macro fused pair may be preceded by the LOCK prefix,
 	// or possibly an XACQUIRE/XRELEASE prefix followed by a LOCK prefix. If it is, we
 	// need to be careful to insert any padding before the locks rather than directly after them.
 
diff --git a/src/cmd/link/internal/ld/pcln.go b/src/cmd/link/internal/ld/pcln.go
index fb733117be..61b64f4f5a 100644
--- a/src/cmd/link/internal/ld/pcln.go
+++ b/src/cmd/link/internal/ld/pcln.go
@@ -50,7 +50,7 @@ type pclntab struct {
 }
 
 // addGeneratedSym adds a generator symbol to pclntab, returning the new Sym.
-// It is the caller's responsibilty to save they symbol in state.
+// It is the caller's responsibility to save they symbol in state.
 func (state *pclntab) addGeneratedSym(ctxt *Link, name string, size int64, f generatorFunc) loader.Sym {
 	size = Rnd(size, int64(ctxt.Arch.PtrSize))
 	state.size += size
@@ -360,7 +360,7 @@ func (state *pclntab) generateFilenameTabs(ctxt *Link, compUnits []*sym.Compilat
 	// then not loading extra filenames), and just use the hash value of the
 	// symbol name to do this cataloging.
 	//
-	// TOOD: Store filenames as symbols. (Note this would be easiest if you
+	// TODO: Store filenames as symbols. (Note this would be easiest if you
 	// also move strings to ALWAYS using the larger content addressable hash
 	// function, and use that hash value for uniqueness testing.)
 	cuEntries := make([]goobj.CUFileIndex, len(compUnits))
diff --git a/src/cmd/link/internal/loader/loader.go b/src/cmd/link/internal/loader/loader.go
index 68dc3de273..c05309a141 100644
--- a/src/cmd/link/internal/loader/loader.go
+++ b/src/cmd/link/internal/loader/loader.go
@@ -1547,7 +1547,7 @@ func (l *Loader) SymUnit(i Sym) *sym.CompilationUnit {
 // regular compiler-generated Go symbols), but in the case of
 // building with "-linkshared" (when a symbol is read from a
 // shared library), will hold the library name.
-// NOTE: this correspondes to sym.Symbol.File field.
+// NOTE: this corresponds to sym.Symbol.File field.
 func (l *Loader) SymPkg(i Sym) string {
 	if f, ok := l.symPkg[i]; ok {
 		return f
diff --git a/src/crypto/tls/handshake_client_test.go b/src/crypto/tls/handshake_client_test.go
index 12b0254123..0e6c5a6370 100644
--- a/src/crypto/tls/handshake_client_test.go
+++ b/src/crypto/tls/handshake_client_test.go
@@ -1528,7 +1528,7 @@ func testVerifyConnection(t *testing.T, version uint16) {
 					}
 					if c.DidResume {
 						return nil
-						// The SCTs and OCSP Responce are dropped on resumption.
+						// The SCTs and OCSP Response are dropped on resumption.
 						// See http://golang.org/issue/39075.
 					}
 					if len(c.OCSPResponse) == 0 {
@@ -1569,7 +1569,7 @@ func testVerifyConnection(t *testing.T, version uint16) {
 					}
 					if c.DidResume {
 						return nil
-						// The SCTs and OCSP Responce are dropped on resumption.
+						// The SCTs and OCSP Response are dropped on resumption.
 						// See http://golang.org/issue/39075.
 					}
 					if len(c.OCSPResponse) == 0 {
@@ -1619,7 +1619,7 @@ func testVerifyConnection(t *testing.T, version uint16) {
 					}
 					if c.DidResume {
 						return nil
-						// The SCTs and OCSP Responce are dropped on resumption.
+						// The SCTs and OCSP Response are dropped on resumption.
 						// See http://golang.org/issue/39075.
 					}
 					if len(c.OCSPResponse) == 0 {
diff --git a/src/internal/poll/copy_file_range_linux.go b/src/internal/poll/copy_file_range_linux.go
index 01b242a4ea..5b9e5d4020 100644
--- a/src/internal/poll/copy_file_range_linux.go
+++ b/src/internal/poll/copy_file_range_linux.go
@@ -78,7 +78,7 @@ func CopyFileRange(dst, src *FD, remain int64) (written int64, handled bool, err
 			// Go supports Linux >= 2.6.33, so the system call
 			// may not be present.
 			//
-			// If we see ENOSYS, we have certainly not transfered
+			// If we see ENOSYS, we have certainly not transferred
 			// any data, so we can tell the caller that we
 			// couldn't handle the transfer and let them fall
 			// back to more generic code.
@@ -91,13 +91,13 @@ func CopyFileRange(dst, src *FD, remain int64) (written int64, handled bool, err
 			// Prior to Linux 5.3, it was not possible to
 			// copy_file_range across file systems. Similarly to
 			// the ENOSYS case above, if we see EXDEV, we have
-			// not transfered any data, and we can let the caller
+			// not transferred any data, and we can let the caller
 			// fall back to generic code.
 			//
 			// As for EINVAL, that is what we see if, for example,
 			// dst or src refer to a pipe rather than a regular
 			// file. This is another case where no data has been
-			// transfered, so we consider it unhandled.
+			// transferred, so we consider it unhandled.
 			//
 			// If src and dst are on CIFS, we can see EIO.
 			// See issue #42334.
diff --git a/src/os/readfrom_linux_test.go b/src/os/readfrom_linux_test.go
index 1d145dadb0..cb6a59abdb 100644
--- a/src/os/readfrom_linux_test.go
+++ b/src/os/readfrom_linux_test.go
@@ -106,7 +106,7 @@ func TestCopyFileRange(t *testing.T) {
 				t.Fatal(err)
 			}
 			if n != int64(len(data)) {
-				t.Fatalf("transfered %d, want %d", n, len(data))
+				t.Fatalf("transferred %d, want %d", n, len(data))
 			}
 			if !hook.called {
 				t.Fatalf("should have called poll.CopyFileRange")
@@ -130,7 +130,7 @@ func TestCopyFileRange(t *testing.T) {
 				t.Fatal(err)
 			}
 			if n != int64(len(data)) {
-				t.Fatalf("transfered %d, want %d", n, len(data))
+				t.Fatalf("transferred %d, want %d", n, len(data))
 			}
 			if !hook.called {
 				t.Fatalf("should have called poll.CopyFileRange")
@@ -162,7 +162,7 @@ func TestCopyFileRange(t *testing.T) {
 				t.Fatal(err)
 			}
 			if n != int64(len(data)) {
-				t.Fatalf("transfered %d, want %d", n, len(data))
+				t.Fatalf("transferred %d, want %d", n, len(data))
 			}
 			if !hook.called {
 				t.Fatalf("should have called poll.CopyFileRange")
diff --git a/src/runtime/chan_test.go b/src/runtime/chan_test.go
index 756bbbeccf..003d6a9fb3 100644
--- a/src/runtime/chan_test.go
+++ b/src/runtime/chan_test.go
@@ -631,7 +631,7 @@ func TestNoShrinkStackWhileParking(t *testing.T) {
 	// channel. See issue 40641 for more details on the problem.
 	//
 	// The way we try to induce this failure is to set up two
-	// goroutines: a sender and a reciever that communicate across
+	// goroutines: a sender and a receiver that communicate across
 	// a channel. We try to set up a situation where the sender
 	// grows its stack temporarily then *fully* blocks on a channel
 	// often. Meanwhile a GC is triggered so that we try to get a
@@ -671,7 +671,7 @@ func TestNoShrinkStackWhileParking(t *testing.T) {
 		go send(c, done)
 		// Wait a little bit before triggering
 		// the GC to make sure the sender and
-		// reciever have gotten into their groove.
+		// receiver have gotten into their groove.
 		time.Sleep(50 * time.Microsecond)
 		runtime.GC()
 		<-done
diff --git a/src/runtime/lockrank_on.go b/src/runtime/lockrank_on.go
index 702bf5f24c..7d45debaca 100644
--- a/src/runtime/lockrank_on.go
+++ b/src/runtime/lockrank_on.go
@@ -220,7 +220,7 @@ func releaseLockRank(rank lockRank) {
 func lockWithRankMayAcquire(l *mutex, rank lockRank) {
 	gp := getg()
 	if gp.m.locksHeldLen == 0 {
-		// No possibilty of lock ordering problem if no other locks held
+		// No possibility of lock ordering problem if no other locks held
 		return
 	}
 
diff --git a/src/runtime/metrics.go b/src/runtime/metrics.go
index 3e8dbda0ca..ce3bac9d8f 100644
--- a/src/runtime/metrics.go
+++ b/src/runtime/metrics.go
@@ -481,7 +481,7 @@ func readMetrics(samplesp unsafe.Pointer, len int, cap int) {
 
 	// Acquire the metricsSema but with handoff. This operation
 	// is expensive enough that queueing up goroutines and handing
-	// off between them will be noticably better-behaved.
+	// off between them will be noticeably better-behaved.
 	semacquire1(&metricsSema, true, 0, 0)
 
 	// Ensure the map is initialized.
diff --git a/src/runtime/mgcscavenge.go b/src/runtime/mgcscavenge.go
index a7c5bc49b8..46a40632bf 100644
--- a/src/runtime/mgcscavenge.go
+++ b/src/runtime/mgcscavenge.go
@@ -207,7 +207,7 @@ func wakeScavenger() {
 		// Ready the goroutine by injecting it. We use injectglist instead
 		// of ready or goready in order to allow us to run this function
 		// without a P. injectglist also avoids placing the goroutine in
-		// the current P's runnext slot, which is desireable to prevent
+		// the current P's runnext slot, which is desirable to prevent
 		// the scavenger from interfering with user goroutine scheduling
 		// too much.
 		var list gList
diff --git a/test/prove.go b/test/prove.go
index af9c06a6f7..83b0380838 100644
--- a/test/prove.go
+++ b/test/prove.go
@@ -1013,7 +1013,7 @@ func sh64noopt(n int64) int64 {
 // opt, an earlier pass, has already replaced it.
 // The fix for this issue allows prove to zero a right shift that was added as
 // part of the less-than-optimal reqwrite. That change by prove then allows
-// lateopt to clean up all the unneccesary parts of the original division
+// lateopt to clean up all the unnecessary parts of the original division
 // replacement. See issue #36159.
 func divShiftClean(n int) int {
 	if n < 0 {
-- 
GitLab


From 084b07d6f6104bf9585ffe71fc2477046102c1da Mon Sep 17 00:00:00 2001
From: DQNEO <dqneoo@gmail.com>
Date: Wed, 10 Feb 2021 22:34:09 +0900
Subject: [PATCH 0810/2400] spec: improve sentence structure for passing a
 slice

Change-Id: I453d06da2f596eb0b99905aec46a05547d73c62c
Reviewed-on: https://go-review.googlesource.com/c/go/+/290872
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Trust: Robert Griesemer <gri@golang.org>
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Reviewed-by: Rob Pike <r@golang.org>
---
 doc/go_spec.html | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index e22fabd699..2a1322fb0f 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1,6 +1,6 @@
 <!--{
 	"Title": "The Go Programming Language Specification",
-	"Subtitle": "Version of Feb 19, 2021",
+	"Subtitle": "Version of Feb 24, 2021",
 	"Path": "/ref/spec"
 }-->
 
@@ -3532,9 +3532,9 @@ within <code>Greeting</code>, <code>who</code> will have the value
 </p>
 
 <p>
-If the final argument is assignable to a slice type <code>[]T</code>, it is
-passed unchanged as the value for a <code>...T</code> parameter if the argument
-is followed by <code>...</code>. In this case no new slice is created.
+If the final argument is assignable to a slice type <code>[]T</code> and
+is followed by <code>...</code>, it is passed unchanged as the value
+for a <code>...T</code> parameter. In this case no new slice is created.
 </p>
 
 <p>
-- 
GitLab


From eb863240dcc857b4207b06eb33385446696b7b1c Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Tue, 23 Feb 2021 15:35:43 +0100
Subject: [PATCH 0811/2400] runtime: remove unused const stackSystem on
 dragonfly

Change-Id: I778c2bd7cf0b12275bae344cb2130a7959500481
Reviewed-on: https://go-review.googlesource.com/c/go/+/295470
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/runtime/os_dragonfly.go | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/runtime/os_dragonfly.go b/src/runtime/os_dragonfly.go
index b786c8ab5f..2e930b6e94 100644
--- a/src/runtime/os_dragonfly.go
+++ b/src/runtime/os_dragonfly.go
@@ -65,8 +65,6 @@ func setNonblock(fd int32)
 
 func pipe() (r, w int32, errno int32)
 
-const stackSystem = 0
-
 // From DragonFly's <sys/sysctl.h>
 const (
 	_CTL_HW      = 6
-- 
GitLab


From 35b80eac7d2ba6cd632b3dc195f8588d95212fbf Mon Sep 17 00:00:00 2001
From: Alberto Donizetti <alb.donizetti@gmail.com>
Date: Sun, 14 Feb 2021 11:19:39 +0100
Subject: [PATCH 0812/2400] hash/maphash: remove duplicate from Hash
 documentation

Fixes #44255

Change-Id: I14d2edbee0a0c39e04111414a57d70ee2fdfb6af
Reviewed-on: https://go-review.googlesource.com/c/go/+/291631
Trust: Alberto Donizetti <alb.donizetti@gmail.com>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/hash/maphash/maphash.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/hash/maphash/maphash.go b/src/hash/maphash/maphash.go
index ecc147d599..f7ef1b41e8 100644
--- a/src/hash/maphash/maphash.go
+++ b/src/hash/maphash/maphash.go
@@ -34,7 +34,7 @@ type Seed struct {
 //
 // The zero Hash is a valid Hash ready to use.
 // A zero Hash chooses a random seed for itself during
-// the first call to a Reset, Write, Seed, Sum64, or Seed method.
+// the first call to a Reset, Write, Seed, or Sum64 method.
 // For control over the seed, use SetSeed.
 //
 // The computed hash values depend only on the initial seed and
-- 
GitLab


From 26001d109ed3da33c728b96e547fa380c7e2a300 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 23 Feb 2021 12:01:26 -0500
Subject: [PATCH 0813/2400] go/types: review of call.go

The changes from the (reviewed) dev.regabi copy of call.go can be seen
by comparing patchset 1 and 4. The actual changes are removing the
"// REVIEW INCOMPLETE" marker, deleting some leftover handling of type
instantiation in Checker.call, and adding a comment that exprOrTypeList
should be refactored.

I started to refactor exprOrTypeList, but thought it best to mark this
code as reviewed before diverging from types2.

Change-Id: Icf7fbff5a8def49c5f1781472fd7ba7b73dd9a9c
Reviewed-on: https://go-review.googlesource.com/c/go/+/295531
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/call.go | 16 ++--------------
 1 file changed, 2 insertions(+), 14 deletions(-)

diff --git a/src/go/types/call.go b/src/go/types/call.go
index b502122a26..e56f741370 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -1,4 +1,3 @@
-// REVIEW INCOMPLETE
 // Copyright 2013 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.
@@ -114,19 +113,9 @@ func (check *Checker) call(x *operand, call *ast.CallExpr) exprKind {
 		return statement
 
 	case typexpr:
-		// conversion or type instantiation
+		// conversion
 		T := x.typ
 		x.mode = invalid
-		if isGeneric(T) {
-			// type instantiation
-			x.typ = check.typ(call)
-			if x.typ != Typ[Invalid] {
-				x.mode = typexpr
-			}
-			return expression
-		}
-
-		// conversion
 		switch n := len(call.Args); n {
 		case 0:
 			check.errorf(inNode(call, call.Rparen), _WrongArgCount, "missing argument in conversion to %s", T)
@@ -217,6 +206,7 @@ func (check *Checker) call(x *operand, call *ast.CallExpr) exprKind {
 
 // exprOrTypeList returns a list of operands and reports an error if the
 // list contains a mix of values and types (ignoring invalid operands).
+// TODO(rFindley) Now we can split this into exprList and typeList.
 func (check *Checker) exprOrTypeList(elist []ast.Expr) (xlist []*operand, ok bool) {
 	ok = true
 
@@ -437,8 +427,6 @@ func (check *Checker) arguments(call *ast.CallExpr, sig *Signature, args []*oper
 	}
 
 	// check arguments
-	// TODO(gri) Possible optimization (may be tricky): We could avoid
-	//           checking arguments from which we inferred type arguments.
 	for i, a := range args {
 		check.assignment(a, sigParams.vars[i].typ, check.sprintf("argument to %s", call.Fun))
 	}
-- 
GitLab


From e49612089196be102b4b7f86c417b8cfba2521aa Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Mon, 1 Feb 2021 08:35:36 -0800
Subject: [PATCH 0814/2400] database: remove race in TestTxContextWait

This test contained a data race.
On line 437, db.BeginTx starts a goroutine that runs tx.awaitDone,
which reads tx.keepConnOnRollback.
On line 445, the test writes to tx.keepConnOnRollback.
tx.awaitDone waits on ctx, but because ctx is timeout-based,
there's no ordering guarantee between the write and the read.

The race detector never caught this before
because the context package implementation of Done
contained enough synchronization to make it safe.
That synchronization is not package of the context API or guarantees,
and the first several releases it was not present.
Another commit soon will remove that synchronization,
exposing the latent data race.

To fix the race, emulate a time-based context
using an explicit cancellation-based context.
This gives us enough control to avoid the race.

Change-Id: I103fe9b987b1d4c02e7a20ac3c22a682652128b6
Reviewed-on: https://go-review.googlesource.com/c/go/+/288493
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Daniel Theophanes <kardianos@gmail.com>
---
 src/database/sql/sql_test.go | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/src/database/sql/sql_test.go b/src/database/sql/sql_test.go
index c968852ade..99bfd62491 100644
--- a/src/database/sql/sql_test.go
+++ b/src/database/sql/sql_test.go
@@ -431,25 +431,24 @@ func TestTxContextWait(t *testing.T) {
 	db := newTestDB(t, "people")
 	defer closeDB(t, db)
 
-	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Millisecond)
-	defer cancel()
+	ctx, cancel := context.WithCancel(context.Background())
 
 	tx, err := db.BeginTx(ctx, nil)
 	if err != nil {
-		// Guard against the context being canceled before BeginTx completes.
-		if err == context.DeadlineExceeded {
-			t.Skip("tx context canceled prior to first use")
-		}
 		t.Fatal(err)
 	}
 	tx.keepConnOnRollback = false
 
+	go func() {
+		time.Sleep(15 * time.Millisecond)
+		cancel()
+	}()
 	// This will trigger the *fakeConn.Prepare method which will take time
 	// performing the query. The ctxDriverPrepare func will check the context
 	// after this and close the rows and return an error.
 	_, err = tx.QueryContext(ctx, "WAIT|1s|SELECT|people|age,name|")
-	if err != context.DeadlineExceeded {
-		t.Fatalf("expected QueryContext to error with context deadline exceeded but returned %v", err)
+	if err != context.Canceled {
+		t.Fatalf("expected QueryContext to error with context canceled but returned %v", err)
 	}
 
 	waitForFree(t, db, 5*time.Second, 0)
-- 
GitLab


From 04edf418d285df410745118aae756f9e0a9a00f5 Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Wed, 18 Nov 2020 12:50:29 -0800
Subject: [PATCH 0815/2400] encoding/json: reduce allocated space in Unmarshal
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The decodeState type is a large part of the allocated space during Unmarshal.
The errorContext field is infrequently used, and only on error.
Extract it into a pointer and allocate it separate when necessary.

name                old time/op    new time/op    delta
UnmarshalString-8      115ns ± 5%     114ns ± 3%     ~     (p=0.170 n=15+15)
UnmarshalFloat64-8     113ns ± 2%     106ns ± 1%   -6.42%  (p=0.000 n=15+14)
UnmarshalInt64-8      93.3ns ± 1%    86.9ns ± 4%   -6.89%  (p=0.000 n=14+15)

name                old alloc/op   new alloc/op   delta
UnmarshalString-8       192B ± 0%      160B ± 0%  -16.67%  (p=0.000 n=15+15)
UnmarshalFloat64-8      180B ± 0%      148B ± 0%  -17.78%  (p=0.000 n=15+15)
UnmarshalInt64-8        176B ± 0%      144B ± 0%  -18.18%  (p=0.000 n=15+15)

name                old allocs/op  new allocs/op  delta
UnmarshalString-8       2.00 ± 0%      2.00 ± 0%     ~     (all equal)
UnmarshalFloat64-8      2.00 ± 0%      2.00 ± 0%     ~     (all equal)
UnmarshalInt64-8        1.00 ± 0%      1.00 ± 0%     ~     (all equal)

Change-Id: I53f3f468e6c65f77a12e5138a2626455b197012d
Reviewed-on: https://go-review.googlesource.com/c/go/+/271338
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Trust: Daniel Martí <mvdan@mvdan.cc>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Daniel Martí <mvdan@mvdan.cc>
---
 src/encoding/json/decode.go | 51 ++++++++++++++++++++++---------------
 1 file changed, 31 insertions(+), 20 deletions(-)

diff --git a/src/encoding/json/decode.go b/src/encoding/json/decode.go
index 86d8a69db7..a9917e72c7 100644
--- a/src/encoding/json/decode.go
+++ b/src/encoding/json/decode.go
@@ -200,16 +200,19 @@ func (n Number) Int64() (int64, error) {
 	return strconv.ParseInt(string(n), 10, 64)
 }
 
+// An errorContext provides context for type errors during decoding.
+type errorContext struct {
+	Struct     reflect.Type
+	FieldStack []string
+}
+
 // decodeState represents the state while decoding a JSON value.
 type decodeState struct {
-	data         []byte
-	off          int // next read offset in data
-	opcode       int // last read result
-	scan         scanner
-	errorContext struct { // provides context for type errors
-		Struct     reflect.Type
-		FieldStack []string
-	}
+	data                  []byte
+	off                   int // next read offset in data
+	opcode                int // last read result
+	scan                  scanner
+	errorContext          *errorContext
 	savedError            error
 	useNumber             bool
 	disallowUnknownFields bool
@@ -229,10 +232,11 @@ func (d *decodeState) init(data []byte) *decodeState {
 	d.data = data
 	d.off = 0
 	d.savedError = nil
-	d.errorContext.Struct = nil
-
-	// Reuse the allocated space for the FieldStack slice.
-	d.errorContext.FieldStack = d.errorContext.FieldStack[:0]
+	if d.errorContext != nil {
+		d.errorContext.Struct = nil
+		// Reuse the allocated space for the FieldStack slice.
+		d.errorContext.FieldStack = d.errorContext.FieldStack[:0]
+	}
 	return d
 }
 
@@ -246,12 +250,11 @@ func (d *decodeState) saveError(err error) {
 
 // addErrorContext returns a new error enhanced with information from d.errorContext
 func (d *decodeState) addErrorContext(err error) error {
-	if d.errorContext.Struct != nil || len(d.errorContext.FieldStack) > 0 {
+	if d.errorContext != nil && (d.errorContext.Struct != nil || len(d.errorContext.FieldStack) > 0) {
 		switch err := err.(type) {
 		case *UnmarshalTypeError:
 			err.Struct = d.errorContext.Struct.Name()
 			err.Field = strings.Join(d.errorContext.FieldStack, ".")
-			return err
 		}
 	}
 	return err
@@ -657,7 +660,10 @@ func (d *decodeState) object(v reflect.Value) error {
 	}
 
 	var mapElem reflect.Value
-	origErrorContext := d.errorContext
+	var origErrorContext errorContext
+	if d.errorContext != nil {
+		origErrorContext = *d.errorContext
+	}
 
 	for {
 		// Read opening " of string key or closing }.
@@ -732,6 +738,9 @@ func (d *decodeState) object(v reflect.Value) error {
 					}
 					subv = subv.Field(i)
 				}
+				if d.errorContext == nil {
+					d.errorContext = new(errorContext)
+				}
 				d.errorContext.FieldStack = append(d.errorContext.FieldStack, f.name)
 				d.errorContext.Struct = t
 			} else if d.disallowUnknownFields {
@@ -812,11 +821,13 @@ func (d *decodeState) object(v reflect.Value) error {
 		if d.opcode == scanSkipSpace {
 			d.scanWhile(scanSkipSpace)
 		}
-		// Reset errorContext to its original state.
-		// Keep the same underlying array for FieldStack, to reuse the
-		// space and avoid unnecessary allocs.
-		d.errorContext.FieldStack = d.errorContext.FieldStack[:len(origErrorContext.FieldStack)]
-		d.errorContext.Struct = origErrorContext.Struct
+		if d.errorContext != nil {
+			// Reset errorContext to its original state.
+			// Keep the same underlying array for FieldStack, to reuse the
+			// space and avoid unnecessary allocs.
+			d.errorContext.FieldStack = d.errorContext.FieldStack[:len(origErrorContext.FieldStack)]
+			d.errorContext.Struct = origErrorContext.Struct
+		}
 		if d.opcode == scanEndObject {
 			break
 		}
-- 
GitLab


From 07c658316b411a4b0e71a3a7e78b970b091795ab Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Thu, 21 Jan 2021 16:59:29 -0800
Subject: [PATCH 0816/2400] io/ioutil: forward TempFile and TempDir to os
 package

For #42026
Fixes #44311

Change-Id: I3dabcf902d155f95800b4adf1d7578906a194ce6
Reviewed-on: https://go-review.googlesource.com/c/go/+/285378
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/io/ioutil/export_test.go   |   7 ---
 src/io/ioutil/tempfile.go      | 108 ++-------------------------------
 src/io/ioutil/tempfile_test.go |  13 ++--
 3 files changed, 13 insertions(+), 115 deletions(-)
 delete mode 100644 src/io/ioutil/export_test.go

diff --git a/src/io/ioutil/export_test.go b/src/io/ioutil/export_test.go
deleted file mode 100644
index dff55f07e2..0000000000
--- a/src/io/ioutil/export_test.go
+++ /dev/null
@@ -1,7 +0,0 @@
-// Copyright 2020 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 ioutil
-
-var ErrPatternHasSeparator = errPatternHasSeparator
diff --git a/src/io/ioutil/tempfile.go b/src/io/ioutil/tempfile.go
index af7c6fd7c1..4b272e5a5d 100644
--- a/src/io/ioutil/tempfile.go
+++ b/src/io/ioutil/tempfile.go
@@ -5,38 +5,9 @@
 package ioutil
 
 import (
-	"errors"
 	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
 )
 
-// Random number state.
-// We generate random temporary file names so that there's a good
-// chance the file doesn't exist yet - keeps the number of tries in
-// TempFile to a minimum.
-var rand uint32
-var randmu sync.Mutex
-
-func reseed() uint32 {
-	return uint32(time.Now().UnixNano() + int64(os.Getpid()))
-}
-
-func nextRandom() string {
-	randmu.Lock()
-	r := rand
-	if r == 0 {
-		r = reseed()
-	}
-	r = r*1664525 + 1013904223 // constants from Numerical Recipes
-	rand = r
-	randmu.Unlock()
-	return strconv.Itoa(int(1e9 + r%1e9))[1:]
-}
-
 // TempFile creates a new temporary file in the directory dir,
 // opens the file for reading and writing, and returns the resulting *os.File.
 // The filename is generated by taking pattern and adding a random
@@ -48,48 +19,10 @@ func nextRandom() string {
 // will not choose the same file. The caller can use f.Name()
 // to find the pathname of the file. It is the caller's responsibility
 // to remove the file when no longer needed.
+//
+// As of Go 1.16, this function simply calls os.CreateTemp.
 func TempFile(dir, pattern string) (f *os.File, err error) {
-	if dir == "" {
-		dir = os.TempDir()
-	}
-
-	prefix, suffix, err := prefixAndSuffix(pattern)
-	if err != nil {
-		return
-	}
-
-	nconflict := 0
-	for i := 0; i < 10000; i++ {
-		name := filepath.Join(dir, prefix+nextRandom()+suffix)
-		f, err = os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0600)
-		if os.IsExist(err) {
-			if nconflict++; nconflict > 10 {
-				randmu.Lock()
-				rand = reseed()
-				randmu.Unlock()
-			}
-			continue
-		}
-		break
-	}
-	return
-}
-
-var errPatternHasSeparator = errors.New("pattern contains path separator")
-
-// prefixAndSuffix splits pattern by the last wildcard "*", if applicable,
-// returning prefix as the part before "*" and suffix as the part after "*".
-func prefixAndSuffix(pattern string) (prefix, suffix string, err error) {
-	if strings.ContainsRune(pattern, os.PathSeparator) {
-		err = errPatternHasSeparator
-		return
-	}
-	if pos := strings.LastIndex(pattern, "*"); pos != -1 {
-		prefix, suffix = pattern[:pos], pattern[pos+1:]
-	} else {
-		prefix = pattern
-	}
-	return
+	return os.CreateTemp(dir, pattern)
 }
 
 // TempDir creates a new temporary directory in the directory dir.
@@ -101,37 +34,8 @@ func prefixAndSuffix(pattern string) (prefix, suffix string, err error) {
 // Multiple programs calling TempDir simultaneously
 // will not choose the same directory. It is the caller's responsibility
 // to remove the directory when no longer needed.
+//
+// As of Go 1.16, this function simply calls os.MkdirTemp.
 func TempDir(dir, pattern string) (name string, err error) {
-	if dir == "" {
-		dir = os.TempDir()
-	}
-
-	prefix, suffix, err := prefixAndSuffix(pattern)
-	if err != nil {
-		return
-	}
-
-	nconflict := 0
-	for i := 0; i < 10000; i++ {
-		try := filepath.Join(dir, prefix+nextRandom()+suffix)
-		err = os.Mkdir(try, 0700)
-		if os.IsExist(err) {
-			if nconflict++; nconflict > 10 {
-				randmu.Lock()
-				rand = reseed()
-				randmu.Unlock()
-			}
-			continue
-		}
-		if os.IsNotExist(err) {
-			if _, err := os.Stat(dir); os.IsNotExist(err) {
-				return "", err
-			}
-		}
-		if err == nil {
-			name = try
-		}
-		break
-	}
-	return
+	return os.MkdirTemp(dir, pattern)
 }
diff --git a/src/io/ioutil/tempfile_test.go b/src/io/ioutil/tempfile_test.go
index 440c7cffc6..5cef18c33b 100644
--- a/src/io/ioutil/tempfile_test.go
+++ b/src/io/ioutil/tempfile_test.go
@@ -50,6 +50,9 @@ func TestTempFile_pattern(t *testing.T) {
 	}
 }
 
+// This string is from os.errPatternHasSeparator.
+const patternHasSeparator = "pattern contains path separator"
+
 func TestTempFile_BadPattern(t *testing.T) {
 	tmpDir, err := TempDir("", t.Name())
 	if err != nil {
@@ -81,9 +84,8 @@ func TestTempFile_BadPattern(t *testing.T) {
 			if tt.wantErr {
 				if err == nil {
 					t.Errorf("Expected an error for pattern %q", tt.pattern)
-				}
-				if g, w := err, ErrPatternHasSeparator; g != w {
-					t.Errorf("Error mismatch: got %#v, want %#v for pattern %q", g, w, tt.pattern)
+				} else if !strings.Contains(err.Error(), patternHasSeparator) {
+					t.Errorf("Error mismatch: got %#v, want %q for pattern %q", err, patternHasSeparator, tt.pattern)
 				}
 			} else if err != nil {
 				t.Errorf("Unexpected error %v for pattern %q", err, tt.pattern)
@@ -183,9 +185,8 @@ func TestTempDir_BadPattern(t *testing.T) {
 			if tt.wantErr {
 				if err == nil {
 					t.Errorf("Expected an error for pattern %q", tt.pattern)
-				}
-				if g, w := err, ErrPatternHasSeparator; g != w {
-					t.Errorf("Error mismatch: got %#v, want %#v for pattern %q", g, w, tt.pattern)
+				} else if !strings.Contains(err.Error(), patternHasSeparator) {
+					t.Errorf("Error mismatch: got %#v, want %q for pattern %q", err, patternHasSeparator, tt.pattern)
 				}
 			} else if err != nil {
 				t.Errorf("Unexpected error %v for pattern %q", err, tt.pattern)
-- 
GitLab


From b97b1456aed5915f7633f16e573b4912140ee8e9 Mon Sep 17 00:00:00 2001
From: YunQiang Su <wzssyqa@gmail.com>
Date: Tue, 9 Jun 2020 04:09:58 +0000
Subject: [PATCH 0817/2400] cmd/go, cmd/cgo: pass -mfp32 and -mhard/soft-float
 to MIPS GCC

For mips32 currently, we are using FP32, while the gcc may be FPXX,
which may generate .MIPS.abiflags and .gnu.attributes section with
value as FPXX. So the kernel will treat the exe as FPXX, and may
choose to use FR=1 FPU mode for it.
Currently, in Go, we use 2 lwc1 to load both half of a double value
to a pair of even-odd FPR. This behavior can only work with FR=0 mode.

In FR=1 mode, all of 32 FPR are 64bit. If we lwc1 the high-half of a double
value to an odd FPR, and try to use the previous even FPR to compute, the
real high-half of even FPR will be unpredicatable.
We set -mfp32 to force the gcc generate FP32 code and section value.

More details about FP32/FPXX/FP64 are explained in:
https://web.archive.org/web/20180828210612/https://dmz-portal.mips.com/wiki/MIPS_O32_ABI_-_FR0_and_FR1_Interlinking

When GOMIPS/GOMIPS64 is set as softfloat, we should also pass
 -msoft-float to gcc.

Here we also add -mno-odd-spreg option, since Loongson's CPU cannot use
odd-number FR in FR=0 mode.

Fixes #39435

Change-Id: I54026ad416a815fe43a9261ebf6d02e5519c3930
Reviewed-on: https://go-review.googlesource.com/c/go/+/237058
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Meng Zhuo <mzh@golangcn.org>
---
 src/cmd/cgo/gcc.go               | 12 ++++++++++--
 src/cmd/cgo/main.go              |  4 +++-
 src/cmd/go/internal/work/exec.go | 14 ++++++++++++--
 3 files changed, 25 insertions(+), 5 deletions(-)

diff --git a/src/cmd/cgo/gcc.go b/src/cmd/cgo/gcc.go
index b5e28e3254..775f20b09f 100644
--- a/src/cmd/cgo/gcc.go
+++ b/src/cmd/cgo/gcc.go
@@ -1566,9 +1566,17 @@ func (p *Package) gccMachine() []string {
 	case "s390x":
 		return []string{"-m64"}
 	case "mips64", "mips64le":
-		return []string{"-mabi=64"}
+		if gomips64 == "hardfloat" {
+			return []string{"-mabi=64", "-mhard-float"}
+		} else if gomips64 == "softfloat" {
+			return []string{"-mabi=64", "-msoft-float"}
+		}
 	case "mips", "mipsle":
-		return []string{"-mabi=32"}
+		if gomips == "hardfloat" {
+			return []string{"-mabi=32", "-mfp32", "-mhard-float", "-mno-odd-spreg"}
+		} else if gomips == "softfloat" {
+			return []string{"-mabi=32", "-msoft-float"}
+		}
 	}
 	return nil
 }
diff --git a/src/cmd/cgo/main.go b/src/cmd/cgo/main.go
index c1116e28ec..5767c54307 100644
--- a/src/cmd/cgo/main.go
+++ b/src/cmd/cgo/main.go
@@ -245,7 +245,7 @@ var importRuntimeCgo = flag.Bool("import_runtime_cgo", true, "import runtime/cgo
 var importSyscall = flag.Bool("import_syscall", true, "import syscall in generated code")
 var trimpath = flag.String("trimpath", "", "applies supplied rewrites or trims prefixes to recorded source file paths")
 
-var goarch, goos string
+var goarch, goos, gomips, gomips64 string
 
 func main() {
 	objabi.AddVersionFlag() // -V
@@ -405,6 +405,8 @@ func newPackage(args []string) *Package {
 	if s := os.Getenv("GOOS"); s != "" {
 		goos = s
 	}
+	gomips = objabi.GOMIPS
+	gomips64 = objabi.GOMIPS64
 	ptrSize := ptrSizeMap[goarch]
 	if ptrSize == 0 {
 		fatalf("unknown ptrSize for $GOARCH %q", goarch)
diff --git a/src/cmd/go/internal/work/exec.go b/src/cmd/go/internal/work/exec.go
index d957fa1fcd..3980c5f898 100644
--- a/src/cmd/go/internal/work/exec.go
+++ b/src/cmd/go/internal/work/exec.go
@@ -2599,9 +2599,19 @@ func (b *Builder) gccArchArgs() []string {
 	case "s390x":
 		return []string{"-m64", "-march=z196"}
 	case "mips64", "mips64le":
-		return []string{"-mabi=64"}
+		args := []string{"-mabi=64"}
+		if cfg.GOMIPS64 == "hardfloat" {
+			return append(args, "-mhard-float")
+		} else if cfg.GOMIPS64 == "softfloat" {
+			return append(args, "-msoft-float")
+		}
 	case "mips", "mipsle":
-		return []string{"-mabi=32", "-march=mips32"}
+		args := []string{"-mabi=32", "-march=mips32"}
+		if cfg.GOMIPS == "hardfloat" {
+			return append(args, "-mhard-float", "-mfp32", "-mno-odd-spreg")
+		} else if cfg.GOMIPS == "softfloat" {
+			return append(args, "-msoft-float")
+		}
 	case "ppc64":
 		if cfg.Goos == "aix" {
 			return []string{"-maix64"}
-- 
GitLab


From 691ac806d20616fab66bb50752edfa9e4e9f8151 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Mon, 22 Feb 2021 15:05:20 -0500
Subject: [PATCH 0818/2400] cmd/go: fix version validation in 'go mod edit
 -exclude'

The fix is to pull in CL 295089 from the x/mod repo.

Fixes #44497

Change-Id: I008b58d0f4bb48c09d4f1e6ed31d11a714f87dc0
Reviewed-on: https://go-review.googlesource.com/c/go/+/295150
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go.mod                                |  2 +-
 src/cmd/go.sum                                |  3 +-
 src/cmd/go/testdata/script/mod_edit.txt       | 27 +++-----
 .../vendor/golang.org/x/mod/modfile/rule.go   | 65 +++++++++++++------
 src/cmd/vendor/modules.txt                    |  2 +-
 5 files changed, 60 insertions(+), 39 deletions(-)

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index 24ad6c2432..3c90dca491 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -6,7 +6,7 @@ require (
 	github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2
 	golang.org/x/arch v0.0.0-20201008161808-52c3e6f60cff
 	golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897
-	golang.org/x/mod v0.4.1
+	golang.org/x/mod v0.4.2-0.20210223202949-66f6d92cabd5
 	golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e // indirect
 	golang.org/x/tools v0.1.1-0.20210220032852-2363391a5b2f
 )
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index e9b62f46e1..498b92207f 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -13,8 +13,9 @@ golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897 h1:pLI5jrR7OSLijeIDcmRxNmw2api+jEfxLoykJVice/E=
 golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/mod v0.4.1 h1:Kvvh58BN8Y9/lBi7hTekvtMpm07eUZ0ck5pRHpsMWrY=
 golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.2-0.20210223202949-66f6d92cabd5 h1:ETedWdSKv0zHgSxvhXszxH25fCWwA6olYCPu9ehlVKs=
+golang.org/x/mod v0.4.2-0.20210223202949-66f6d92cabd5/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
diff --git a/src/cmd/go/testdata/script/mod_edit.txt b/src/cmd/go/testdata/script/mod_edit.txt
index 02d2d40bbb..9da69306da 100644
--- a/src/cmd/go/testdata/script/mod_edit.txt
+++ b/src/cmd/go/testdata/script/mod_edit.txt
@@ -16,9 +16,9 @@ cmpenv go.mod $WORK/go.mod.init
 cmpenv go.mod $WORK/go.mod.init
 
 # go mod edits
-go mod edit -droprequire=x.1 -require=x.1@v1.0.0 -require=x.2@v1.1.0 -droprequire=x.2 -exclude='x.1 @ v1.2.0' -exclude=x.1@v1.2.1 -replace=x.1@v1.3.0=y.1@v1.4.0 -replace='x.1@v1.4.0 = ../z' -retract=v1.6.0 -retract=[v1.1.0,v1.2.0] -retract=[v1.3.0,v1.4.0] -retract=v1.0.0
+go mod edit -droprequire=x.1 -require=x.1@v1.0.0 -require=x.2@v1.1.0 -droprequire=x.2 -exclude='x.1 @ v1.2.0' -exclude=x.1@v1.2.1 -exclude=x.1@v2.0.0+incompatible -replace=x.1@v1.3.0=y.1@v1.4.0 -replace='x.1@v1.4.0 = ../z' -retract=v1.6.0 -retract=[v1.1.0,v1.2.0] -retract=[v1.3.0,v1.4.0] -retract=v1.0.0
 cmpenv go.mod $WORK/go.mod.edit1
-go mod edit -droprequire=x.1 -dropexclude=x.1@v1.2.1 -dropreplace=x.1@v1.3.0 -require=x.3@v1.99.0 -dropretract=v1.0.0 -dropretract=[v1.1.0,v1.2.0]
+go mod edit -droprequire=x.1 -dropexclude=x.1@v1.2.1 -dropexclude=x.1@v2.0.0+incompatible -dropreplace=x.1@v1.3.0 -require=x.3@v1.99.0 -dropretract=v1.0.0 -dropretract=[v1.1.0,v1.2.0]
 cmpenv go.mod $WORK/go.mod.edit2
 
 # -exclude and -retract reject invalid versions.
@@ -26,25 +26,17 @@ cmpenv go.mod $WORK/go.mod.edit2
 stderr '^go mod: -exclude=example.com/m@bad: version "bad" invalid: must be of the form v1.2.3$'
 ! go mod edit -retract=bad
 stderr '^go mod: -retract=bad: version "bad" invalid: must be of the form v1.2.3$'
-cmpenv go.mod $WORK/go.mod.edit2
 
-cp go.mod go.mod.beforebugs
+! go mod edit -exclude=example.com/m@v2.0.0
+stderr '^go mod: -exclude=example.com/m@v2\.0\.0: version "v2\.0\.0" invalid: should be v2\.0\.0\+incompatible \(or module example\.com/m/v2\)$'
 
-# BUG(#44497): -exclude accepts a mismatched major version without +incompatible, but should not.
-go mod edit -exclude=example.com/m@v2.0.0
-! go mod edit -json
-stderr '^go: errors parsing go.mod:\n.*[/\\]go.mod:16: exclude example\.com/m: version "v2\.0\.0" invalid: should be v0 or v1, not v2$'
-cp go.mod.beforebugs go.mod
+! go mod edit -exclude=example.com/m/v2@v1.0.0
+stderr '^go mod: -exclude=example.com/m/v2@v1\.0\.0: version "v1\.0\.0" invalid: should be v2, not v1$'
 
-# BUG(#44497): -exclude accepts a v1 version for a v2 module, but should not.
-go mod edit -exclude=example.com/m/v2@v1.0.0
-! go mod edit -json
-stderr '^go: errors parsing go.mod:\n.*[/\\]go.mod:16: exclude example\.com/m/v2: version "v1\.0\.0" invalid: should be v2, not v1$'
-cp go.mod.beforebugs go.mod
+! go mod edit -exclude=gopkg.in/example.v1@v2.0.0
+stderr '^go mod: -exclude=gopkg\.in/example\.v1@v2\.0\.0: version "v2\.0\.0" invalid: should be v1, not v2$'
 
-# BUG(#44497): -exclude rejects a +incompatible version for an unversioned
-# module path, but should not.
-! go mod edit -exclude=example.com/m@v2.0.0+incompatible
+cmpenv go.mod $WORK/go.mod.edit2
 
 # go mod edit -json
 go mod edit -json
@@ -107,6 +99,7 @@ require x.1 v1.0.0
 exclude (
 	x.1 v1.2.0
 	x.1 v1.2.1
+	x.1 v2.0.0+incompatible
 )
 
 replace (
diff --git a/src/cmd/vendor/golang.org/x/mod/modfile/rule.go b/src/cmd/vendor/golang.org/x/mod/modfile/rule.go
index c6a189dbe0..8fcf96b713 100644
--- a/src/cmd/vendor/golang.org/x/mod/modfile/rule.go
+++ b/src/cmd/vendor/golang.org/x/mod/modfile/rule.go
@@ -835,11 +835,8 @@ func (f *File) DropRequire(path string) error {
 // AddExclude adds a exclude statement to the mod file. Errors if the provided
 // version is not a canonical version string
 func (f *File) AddExclude(path, vers string) error {
-	if !isCanonicalVersion(vers) {
-		return &module.InvalidVersionError{
-			Version: vers,
-			Err:     errors.New("must be of the form v1.2.3"),
-		}
+	if err := checkCanonicalVersion(path, vers); err != nil {
+		return err
 	}
 
 	var hint *Line
@@ -916,17 +913,15 @@ func (f *File) DropReplace(oldPath, oldVers string) error {
 // AddRetract adds a retract statement to the mod file. Errors if the provided
 // version interval does not consist of canonical version strings
 func (f *File) AddRetract(vi VersionInterval, rationale string) error {
-	if !isCanonicalVersion(vi.High) {
-		return &module.InvalidVersionError{
-			Version: vi.High,
-			Err:     errors.New("must be of the form v1.2.3"),
-		}
+	var path string
+	if f.Module != nil {
+		path = f.Module.Mod.Path
 	}
-	if !isCanonicalVersion(vi.Low) {
-		return &module.InvalidVersionError{
-			Version: vi.Low,
-			Err:     errors.New("must be of the form v1.2.3"),
-		}
+	if err := checkCanonicalVersion(path, vi.High); err != nil {
+		return err
+	}
+	if err := checkCanonicalVersion(path, vi.Low); err != nil {
+		return err
 	}
 
 	r := &Retract{
@@ -1086,8 +1081,40 @@ func lineRetractLess(li, lj *Line) bool {
 	return semver.Compare(vii.High, vij.High) > 0
 }
 
-// isCanonicalVersion tests if the provided version string represents a valid
-// canonical version.
-func isCanonicalVersion(vers string) bool {
-	return vers != "" && semver.Canonical(vers) == vers
+// checkCanonicalVersion returns a non-nil error if vers is not a canonical
+// version string or does not match the major version of path.
+//
+// If path is non-empty, the error text suggests a format with a major version
+// corresponding to the path.
+func checkCanonicalVersion(path, vers string) error {
+	_, pathMajor, pathMajorOk := module.SplitPathVersion(path)
+
+	if vers == "" || vers != module.CanonicalVersion(vers) {
+		if pathMajor == "" {
+			return &module.InvalidVersionError{
+				Version: vers,
+				Err:     fmt.Errorf("must be of the form v1.2.3"),
+			}
+		}
+		return &module.InvalidVersionError{
+			Version: vers,
+			Err:     fmt.Errorf("must be of the form %s.2.3", module.PathMajorPrefix(pathMajor)),
+		}
+	}
+
+	if pathMajorOk {
+		if err := module.CheckPathMajor(vers, pathMajor); err != nil {
+			if pathMajor == "" {
+				// In this context, the user probably wrote "v2.3.4" when they meant
+				// "v2.3.4+incompatible". Suggest that instead of "v0 or v1".
+				return &module.InvalidVersionError{
+					Version: vers,
+					Err:     fmt.Errorf("should be %s+incompatible (or module %s/%v)", vers, path, semver.Major(vers)),
+				}
+			}
+			return err
+		}
+	}
+
+	return nil
 }
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index abe70ae87e..254cff70dd 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -28,7 +28,7 @@ golang.org/x/arch/x86/x86asm
 golang.org/x/crypto/ed25519
 golang.org/x/crypto/ed25519/internal/edwards25519
 golang.org/x/crypto/ssh/terminal
-# golang.org/x/mod v0.4.1
+# golang.org/x/mod v0.4.2-0.20210223202949-66f6d92cabd5
 ## explicit
 golang.org/x/mod/internal/lazyregexp
 golang.org/x/mod/modfile
-- 
GitLab


From ae1fa08e4138c49c8e7fa10c3eadbfca0233842b Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Fri, 29 Jan 2021 15:41:18 -0800
Subject: [PATCH 0819/2400] context: reduce contention in cancelCtx.Done
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Use an atomic.Value to hold the done channel.
Conveniently, we have a mutex handy to coordinate writes to it.

name                 old time/op  new time/op  delta
ContextCancelDone-8  67.5ns ±10%   2.2ns ±11%  -96.74%  (p=0.000 n=30+28)

Fixes #42564

Change-Id: I5d72e0e87fb221d4e230209e5fb4698bea4053c6
Reviewed-on: https://go-review.googlesource.com/c/go/+/288193
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Trust: Sameer Ajmani <sameer@golang.org>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/context/benchmark_test.go | 15 +++++++++++++++
 src/context/context.go        | 30 +++++++++++++++++-------------
 2 files changed, 32 insertions(+), 13 deletions(-)

diff --git a/src/context/benchmark_test.go b/src/context/benchmark_test.go
index 5d56863050..c4c72f00f8 100644
--- a/src/context/benchmark_test.go
+++ b/src/context/benchmark_test.go
@@ -5,6 +5,7 @@
 package context_test
 
 import (
+	"context"
 	. "context"
 	"fmt"
 	"runtime"
@@ -138,3 +139,17 @@ func BenchmarkCheckCanceled(b *testing.B) {
 		}
 	})
 }
+
+func BenchmarkContextCancelDone(b *testing.B) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			select {
+			case <-ctx.Done():
+			default:
+			}
+		}
+	})
+}
diff --git a/src/context/context.go b/src/context/context.go
index b3fdb8277a..733c5f56d9 100644
--- a/src/context/context.go
+++ b/src/context/context.go
@@ -303,10 +303,8 @@ func parentCancelCtx(parent Context) (*cancelCtx, bool) {
 	if !ok {
 		return nil, false
 	}
-	p.mu.Lock()
-	ok = p.done == done
-	p.mu.Unlock()
-	if !ok {
+	pdone, _ := p.done.Load().(chan struct{})
+	if pdone != done {
 		return nil, false
 	}
 	return p, true
@@ -345,7 +343,7 @@ type cancelCtx struct {
 	Context
 
 	mu       sync.Mutex            // protects following fields
-	done     chan struct{}         // created lazily, closed by first cancel call
+	done     atomic.Value          // of chan struct{}, created lazily, closed by first cancel call
 	children map[canceler]struct{} // set to nil by the first cancel call
 	err      error                 // set to non-nil by the first cancel call
 }
@@ -358,13 +356,18 @@ func (c *cancelCtx) Value(key interface{}) interface{} {
 }
 
 func (c *cancelCtx) Done() <-chan struct{} {
+	d := c.done.Load()
+	if d != nil {
+		return d.(chan struct{})
+	}
 	c.mu.Lock()
-	if c.done == nil {
-		c.done = make(chan struct{})
+	defer c.mu.Unlock()
+	d = c.done.Load()
+	if d == nil {
+		d = make(chan struct{})
+		c.done.Store(d)
 	}
-	d := c.done
-	c.mu.Unlock()
-	return d
+	return d.(chan struct{})
 }
 
 func (c *cancelCtx) Err() error {
@@ -401,10 +404,11 @@ func (c *cancelCtx) cancel(removeFromParent bool, err error) {
 		return // already canceled
 	}
 	c.err = err
-	if c.done == nil {
-		c.done = closedchan
+	d, _ := c.done.Load().(chan struct{})
+	if d == nil {
+		c.done.Store(closedchan)
 	} else {
-		close(c.done)
+		close(d)
 	}
 	for child := range c.children {
 		// NOTE: acquiring the child's lock while holding parent's lock.
-- 
GitLab


From 27684ea195641ead8a8f08cb345925da889a12ed Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Thu, 14 Jan 2021 14:38:55 -0800
Subject: [PATCH 0820/2400] testing: print late arriving log line in panic

When you log after a test has completed,
the testing package panics.

Print the logged line as part of that panic,
to aid in debugging.

Change-Id: I3d6689d1eed57c03e300afe37db0c15b2f4acda4
Reviewed-on: https://go-review.googlesource.com/c/go/+/283972
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/testing/sub_test.go | 2 +-
 src/testing/testing.go  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/testing/sub_test.go b/src/testing/sub_test.go
index 5b226f85ad..6c7d83aac2 100644
--- a/src/testing/sub_test.go
+++ b/src/testing/sub_test.go
@@ -822,7 +822,7 @@ func TestLogAfterComplete(t *T) {
 						c2 <- fmt.Sprintf("subtest panic with unexpected value %v", p)
 						return
 					}
-					const want = "Log in goroutine after TestLateLog has completed"
+					const want = "Log in goroutine after TestLateLog has completed: log after test"
 					if !strings.Contains(s, want) {
 						c2 <- fmt.Sprintf("subtest panic %q does not contain %q", s, want)
 					}
diff --git a/src/testing/testing.go b/src/testing/testing.go
index 80354d5ce8..466dd96981 100644
--- a/src/testing/testing.go
+++ b/src/testing/testing.go
@@ -762,7 +762,7 @@ func (c *common) logDepth(s string, depth int) {
 				return
 			}
 		}
-		panic("Log in goroutine after " + c.name + " has completed")
+		panic("Log in goroutine after " + c.name + " has completed: " + s)
 	} else {
 		if c.chatty != nil {
 			if c.bench {
-- 
GitLab


From adb467ffd2d82b796de12bdd8effa2cfefe01f29 Mon Sep 17 00:00:00 2001
From: Egon Elbre <egonelbre@gmail.com>
Date: Sat, 2 Jan 2021 16:28:11 +0200
Subject: [PATCH 0821/2400] cmd/compile: reduce inline cost of OCONVOP

OCONVOP doesn't have effect in the compiled code so, it can be safely
excluded from inline cost calculation.

Also make sequence ODEREF OCONVNOP* OADDR cost 1. This is rather common
conversion, such as *(*uint32)(unsafe.Pointer(&x)).

Fixes #42788

Change-Id: I5001f7e89d985c198b6405694cdd5b819cf3f47a
Reviewed-on: https://go-review.googlesource.com/c/go/+/281232
Reviewed-by: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Elias Naur <mail@eliasnaur.com>
---
 src/cmd/compile/internal/inline/inl.go | 16 ++++++++++++++++
 test/inline.go                         | 23 +++++++++++++++++++++++
 2 files changed, 39 insertions(+)

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 7d70fca6c9..0e57c17667 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -384,6 +384,22 @@ func (v *hairyVisitor) doNode(n ir.Node) bool {
 	case ir.OAPPEND:
 		v.budget -= inlineExtraAppendCost
 
+	case ir.ODEREF:
+		// *(*X)(unsafe.Pointer(&x)) is low-cost
+		n := n.(*ir.StarExpr)
+
+		ptr := n.X
+		for ptr.Op() == ir.OCONVNOP {
+			ptr = ptr.(*ir.ConvExpr).X
+		}
+		if ptr.Op() == ir.OADDR {
+			v.budget += 1 // undo half of default cost of ir.ODEREF+ir.OADDR
+		}
+
+	case ir.OCONVNOP:
+		// This doesn't produce code, but the children might.
+		v.budget++ // undo default cost
+
 	case ir.ODCLCONST, ir.OFALL:
 		// These nodes don't produce code; omit from inlining budget.
 		return false
diff --git a/test/inline.go b/test/inline.go
index 37965c0d9d..a79f5589fb 100644
--- a/test/inline.go
+++ b/test/inline.go
@@ -10,6 +10,7 @@
 package foo
 
 import (
+	"math"
 	"runtime"
 	"unsafe"
 )
@@ -262,3 +263,25 @@ func gd2() int { // ERROR "can inline gd2"
 func gd3() func() { // ERROR "can inline gd3"
 	return ii
 }
+
+// Issue #42788 - ensure ODEREF OCONVNOP* OADDR is low cost.
+func EncodeQuad(d []uint32, x [6]float32) { // ERROR "can inline EncodeQuad" "d does not escape"
+	_ = d[:6]
+	d[0] = math.Float32bits(x[0]) // ERROR "inlining call to math.Float32bits"
+	d[1] = math.Float32bits(x[1]) // ERROR "inlining call to math.Float32bits"
+	d[2] = math.Float32bits(x[2]) // ERROR "inlining call to math.Float32bits"
+	d[3] = math.Float32bits(x[3]) // ERROR "inlining call to math.Float32bits"
+	d[4] = math.Float32bits(x[4]) // ERROR "inlining call to math.Float32bits"
+	d[5] = math.Float32bits(x[5]) // ERROR "inlining call to math.Float32bits"
+}
+
+// Ensure OCONVNOP is zero cost.
+func Conv(v uint64) uint64 { // ERROR "can inline Conv"
+	return conv2(conv2(conv2(v))) // ERROR "inlining call to (conv1|conv2)"
+}
+func conv2(v uint64) uint64 { // ERROR "can inline conv2"
+	return conv1(conv1(conv1(conv1(v)))) // ERROR "inlining call to conv1"
+}
+func conv1(v uint64) uint64 { // ERROR "can inline conv1"
+	return uint64(uint64(uint64(uint64(uint64(uint64(uint64(uint64(uint64(uint64(uint64(v)))))))))))
+}
-- 
GitLab


From 7a2f3273c5598bf53e37d0c8a4cb8a8caf7c4ca4 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Thu, 21 Jan 2021 12:04:46 -0500
Subject: [PATCH 0822/2400] cmd/compile: plumb abi info into ssagen/ssa

Plumb abi information into ssa/ssagen for plain calls
and plain functions (not methods).  Does not extend all the
way through the compiler (yet).

One test disabled because it extends far enough to break the test.

Normalized all the compiler's register args TODOs to
// TODO(register args) ...

For #40724.

Change-Id: I0173a4579f032ac3c9db3aef1749d40da5ea01ff
Reviewed-on: https://go-review.googlesource.com/c/go/+/293389
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/abi/abiutils.go      |  11 +-
 src/cmd/compile/internal/ir/node.go           |   2 +-
 src/cmd/compile/internal/noder/lex.go         |   4 +-
 src/cmd/compile/internal/ssa/func.go          |   5 +
 .../compile/internal/ssa/loopreschedchecks.go |   3 +-
 src/cmd/compile/internal/ssa/op.go            |  17 ++-
 src/cmd/compile/internal/ssa/rewrite.go       |   2 +-
 src/cmd/compile/internal/ssa/writebarrier.go  |   3 +-
 src/cmd/compile/internal/ssagen/ssa.go        | 134 +++++++++++++-----
 src/cmd/compile/internal/typecheck/iexport.go |   2 +-
 src/cmd/compile/internal/typecheck/iimport.go |   2 +-
 test/abi/regabipragma.go                      |   4 +-
 12 files changed, 137 insertions(+), 52 deletions(-)

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index e935821802..7b388ec3dc 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -116,6 +116,13 @@ func NewABIConfig(iRegsCount, fRegsCount int) *ABIConfig {
 	return &ABIConfig{regAmounts: RegAmounts{iRegsCount, fRegsCount}, regsForTypeCache: make(map[*types.Type]int)}
 }
 
+// Copy returns a copy of an ABIConfig for use in a function's compilation so that access to the cache does not need to be protected with a mutex.
+func (a *ABIConfig) Copy() *ABIConfig {
+	b := *a
+	b.regsForTypeCache = make(map[*types.Type]int)
+	return &b
+}
+
 // NumParamRegs returns the number of parameter registers used for a given type,
 // without regard for the number available.
 func (a *ABIConfig) NumParamRegs(t *types.Type) int {
@@ -157,12 +164,12 @@ func (a *ABIConfig) NumParamRegs(t *types.Type) int {
 // 'config' and analyzes the function to determine how its parameters
 // and results will be passed (in registers or on the stack), returning
 // an ABIParamResultInfo object that holds the results of the analysis.
-func (config *ABIConfig) ABIAnalyze(t *types.Type) ABIParamResultInfo {
+func (config *ABIConfig) ABIAnalyze(t *types.Type) *ABIParamResultInfo {
 	setup()
 	s := assignState{
 		rTotal: config.regAmounts,
 	}
-	result := ABIParamResultInfo{config: config}
+	result := &ABIParamResultInfo{config: config}
 
 	// Receiver
 	ft := t.FuncType()
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 59643713fa..38f9123582 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -456,7 +456,7 @@ const (
 	// Go command pragmas
 	GoBuildPragma
 
-	RegisterParams // TODO remove after register abi is working
+	RegisterParams // TODO(register args) remove after register abi is working
 
 )
 
diff --git a/src/cmd/compile/internal/noder/lex.go b/src/cmd/compile/internal/noder/lex.go
index cdca9e55f3..36cfb9bc23 100644
--- a/src/cmd/compile/internal/noder/lex.go
+++ b/src/cmd/compile/internal/noder/lex.go
@@ -28,7 +28,7 @@ const (
 		ir.Nosplit |
 		ir.Noinline |
 		ir.NoCheckPtr |
-		ir.RegisterParams | // TODO remove after register abi is working
+		ir.RegisterParams | // TODO(register args) remove after register abi is working
 		ir.CgoUnsafeArgs |
 		ir.UintptrEscapes |
 		ir.Systemstack |
@@ -80,7 +80,7 @@ func pragmaFlag(verb string) ir.PragmaFlag {
 		// in the argument list.
 		// Used in syscall/dll_windows.go.
 		return ir.UintptrEscapes
-	case "go:registerparams": // TODO remove after register abi is working
+	case "go:registerparams": // TODO(register args) remove after register abi is working
 		return ir.RegisterParams
 	case "go:notinheap":
 		return ir.NotInHeap
diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go
index de99a8d4af..a36529af03 100644
--- a/src/cmd/compile/internal/ssa/func.go
+++ b/src/cmd/compile/internal/ssa/func.go
@@ -5,6 +5,7 @@
 package ssa
 
 import (
+	"cmd/compile/internal/abi"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"crypto/sha1"
@@ -43,6 +44,10 @@ type Func struct {
 	DebugTest      bool           // default true unless $GOSSAHASH != ""; as a debugging aid, make new code conditional on this and use GOSSAHASH to binary search for failing cases
 	PrintOrHtmlSSA bool           // true if GOSSAFUNC matches, true even if fe.Log() (spew phase results to stdout) is false.
 	ruleMatches    map[string]int // number of times countRule was called during compilation for any given string
+	ABI0           *abi.ABIConfig // A copy, for no-sync access
+	ABI1           *abi.ABIConfig // A copy, for no-sync access
+	ABISelf        *abi.ABIConfig // ABI for function being compiled
+	ABIDefault     *abi.ABIConfig // ABI for rtcall and other no-parsed-signature/pragma functions.
 
 	scheduled   bool  // Values in Blocks are in final order
 	laidout     bool  // Blocks are ordered
diff --git a/src/cmd/compile/internal/ssa/loopreschedchecks.go b/src/cmd/compile/internal/ssa/loopreschedchecks.go
index 9c73bcff26..5308d1ac48 100644
--- a/src/cmd/compile/internal/ssa/loopreschedchecks.go
+++ b/src/cmd/compile/internal/ssa/loopreschedchecks.go
@@ -246,7 +246,8 @@ func insertLoopReschedChecks(f *Func) {
 		//    mem1 := call resched (mem0)
 		//    goto header
 		resched := f.fe.Syslook("goschedguarded")
-		mem1 := sched.NewValue1A(bb.Pos, OpStaticCall, types.TypeMem, StaticAuxCall(resched, nil, nil), mem0)
+		// TODO(register args) -- will need more details
+		mem1 := sched.NewValue1A(bb.Pos, OpStaticCall, types.TypeMem, StaticAuxCall(resched, nil, nil, nil), mem0)
 		sched.AddEdgeTo(h)
 		headerMemPhi.AddArg(mem1)
 
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index cf0d2affc7..4bda7369bb 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -5,6 +5,7 @@
 package ssa
 
 import (
+	"cmd/compile/internal/abi"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -71,15 +72,18 @@ type auxType int8
 
 type Param struct {
 	Type   *types.Type
-	Offset int32    // Offset of Param if not in a register.
+	Offset int32 // Offset of Param if not in a register, spill offset if it is in a register input, types.BADWIDTH if it is a register output.
+	Reg    []abi.RegIndex
 	Name   *ir.Name // For OwnAux, need to prepend stores with Vardefs
 }
 
 type AuxCall struct {
+	// TODO(register args) this information is largely redundant with ../abi information, needs cleanup once new ABI is in place.
 	Fn      *obj.LSym
 	args    []Param // Includes receiver for method calls.  Does NOT include hidden closure pointer.
 	results []Param
-	reg     *regInfo // regInfo for this call // TODO for now nil means ignore
+	reg     *regInfo                // regInfo for this call // TODO for now nil means ignore
+	abiInfo *abi.ABIParamResultInfo // TODO remove fields above redundant with this information.
 }
 
 // ResultForOffset returns the index of the result at a particular offset among the results
@@ -186,9 +190,9 @@ func (a *AuxCall) String() string {
 }
 
 // StaticAuxCall returns an AuxCall for a static call.
-func StaticAuxCall(sym *obj.LSym, args []Param, results []Param) *AuxCall {
+func StaticAuxCall(sym *obj.LSym, args []Param, results []Param, paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
 	// TODO Create regInfo for AuxCall
-	return &AuxCall{Fn: sym, args: args, results: results}
+	return &AuxCall{Fn: sym, args: args, results: results, abiInfo: paramResultInfo}
 }
 
 // InterfaceAuxCall returns an AuxCall for an interface call.
@@ -206,9 +210,10 @@ func ClosureAuxCall(args []Param, results []Param) *AuxCall {
 func (*AuxCall) CanBeAnSSAAux() {}
 
 // OwnAuxCall returns a function's own AuxCall
-func OwnAuxCall(fn *obj.LSym, args []Param, results []Param) *AuxCall {
+
+func OwnAuxCall(fn *obj.LSym, args []Param, results []Param, paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
 	// TODO if this remains identical to ClosureAuxCall above after new ABI is done, should deduplicate.
-	return &AuxCall{Fn: fn, args: args, results: results}
+	return &AuxCall{Fn: fn, args: args, results: results, abiInfo: paramResultInfo}
 }
 
 const (
diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go
index e82aa84cdf..ac6278ab9d 100644
--- a/src/cmd/compile/internal/ssa/rewrite.go
+++ b/src/cmd/compile/internal/ssa/rewrite.go
@@ -765,7 +765,7 @@ func devirt(v *Value, aux Aux, sym Sym, offset int64) *AuxCall {
 		return nil
 	}
 	va := aux.(*AuxCall)
-	return StaticAuxCall(lsym, va.args, va.results)
+	return StaticAuxCall(lsym, va.args, va.results, va.abiInfo)
 }
 
 // de-virtualize an InterLECall
diff --git a/src/cmd/compile/internal/ssa/writebarrier.go b/src/cmd/compile/internal/ssa/writebarrier.go
index 4378f2d627..7d375da128 100644
--- a/src/cmd/compile/internal/ssa/writebarrier.go
+++ b/src/cmd/compile/internal/ssa/writebarrier.go
@@ -512,7 +512,8 @@ func wbcall(pos src.XPos, b *Block, fn, typ *obj.LSym, ptr, val, mem, sp, sb *Va
 	off = round(off, config.PtrSize)
 
 	// issue call
-	mem = b.NewValue1A(pos, OpStaticCall, types.TypeMem, StaticAuxCall(fn, ACArgs, nil), mem)
+	// TODO(register args) -- will need more details
+	mem = b.NewValue1A(pos, OpStaticCall, types.TypeMem, StaticAuxCall(fn, ACArgs, nil, nil), mem)
 	mem.AuxInt = off - config.ctxt.FixedFrameSize()
 	return mem
 }
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index cfc54ae0ab..d69eb17ca9 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -357,7 +357,20 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 	if fn.Pragma&ir.Nosplit != 0 {
 		s.f.NoSplit = true
 	}
-	if fn.Pragma&ir.RegisterParams != 0 { // TODO remove after register abi is working
+	s.f.ABI0 = ssaConfig.ABI0.Copy() // Make a copy to avoid racy map operations in type-width cache.
+	s.f.ABI1 = ssaConfig.ABI1.Copy()
+
+	s.f.ABIDefault = s.f.ABI1 // Default ABI for function calls with no parsed signature for a pragma, e.g. rtcall
+	// TODO(register args) -- remove "true ||"; in the short run, turning on the register ABI experiment still leaves the compiler defaulting to ABI0.
+	// TODO(register args) -- remove this conditional entirely when register ABI is not an experiment.
+	if true || objabi.Regabi_enabled == 0 {
+		s.f.ABIDefault = s.f.ABI0 // reset
+	}
+
+	s.f.ABISelf = s.f.ABIDefault
+
+	if fn.Pragma&ir.RegisterParams != 0 { // TODO(register args) remove after register abi is working
+		s.f.ABISelf = s.f.ABI1
 		if strings.Contains(name, ".") {
 			base.ErrorfAt(fn.Pos(), "Calls to //go:registerparams method %s won't work, remove the pragma from the declaration.", name)
 		}
@@ -449,18 +462,19 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 		s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, deferBitsTemp, s.mem(), false)
 	}
 
+	params := s.f.ABISelf.ABIAnalyze(fn.Type())
+
 	// Generate addresses of local declarations
 	s.decladdrs = map[*ir.Name]*ssa.Value{}
-	var args []ssa.Param
 	var results []ssa.Param
 	for _, n := range fn.Dcl {
 		switch n.Class {
 		case ir.PPARAM:
+			// Be aware that blank and unnamed input parameters will not appear here, but do appear in the type
 			s.decladdrs[n] = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(n.Type()), n, s.sp, s.startmem)
-			args = append(args, ssa.Param{Type: n.Type(), Offset: int32(n.FrameOffset())})
 		case ir.PPARAMOUT:
 			s.decladdrs[n] = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(n.Type()), n, s.sp, s.startmem)
-			results = append(results, ssa.Param{Type: n.Type(), Offset: int32(n.FrameOffset()), Name: n})
+			results = append(results, ssa.Param{Name: n})
 		case ir.PAUTO:
 			// processed at each use, to prevent Addr coming
 			// before the decl.
@@ -468,7 +482,36 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 			s.Fatalf("local variable with class %v unimplemented", n.Class)
 		}
 	}
-	s.f.OwnAux = ssa.OwnAuxCall(fn.LSym, args, results)
+
+	// TODO: figure out why base.Ctxt.FixedFrameSize() is not added to these offsets here (compare to calls).
+	// The input half is ignored unless a register ABI is used.
+	var args []ssa.Param
+	for _, p := range params.InParams() {
+		r := p.Registers
+		var o int32
+		if len(r) == 0 {
+			o = p.Offset()
+		} else {
+			o = p.SpillOffset() + int32(params.SpillAreaOffset())
+		}
+		args = append(args, ssa.Param{Type: p.Type, Offset: o, Reg: r})
+	}
+
+	// For now, need the ir.Name attached to these, so update those already created.
+	for i, p := range params.OutParams() {
+		r := p.Registers
+		var o int32
+		if len(r) == 0 {
+			o = p.Offset()
+		} else {
+			o = types.BADWIDTH
+		}
+		results[i].Type = p.Type
+		results[i].Offset = o
+		results[i].Reg = r
+	}
+
+	s.f.OwnAux = ssa.OwnAuxCall(fn.LSym, args, results, params)
 
 	// Populate SSAable arguments.
 	for _, n := range fn.Dcl {
@@ -1846,7 +1889,7 @@ func (s *state) exit() *ssa.Block {
 		}
 
 		// Run exit code. Today, this is just racefuncexit, in -race mode.
-		// TODO this seems risky here with a register-ABI, but not clear it is right to do it earlier either.
+		// TODO(register args) this seems risky here with a register-ABI, but not clear it is right to do it earlier either.
 		// Spills in register allocation might just fix it.
 		s.stmtList(s.curfn.Exit)
 
@@ -4691,7 +4734,7 @@ func (s *state) openDeferExit() {
 			aux := ssa.ClosureAuxCall(ACArgs, ACResults)
 			call = s.newValue2A(ssa.OpClosureLECall, aux.LateExpansionResultType(), aux, codeptr, v)
 		} else {
-			aux := ssa.StaticAuxCall(fn.(*ir.Name).Linksym(), ACArgs, ACResults)
+			aux := ssa.StaticAuxCall(fn.(*ir.Name).Linksym(), ACArgs, ACResults, nil) // TODO will need types for this.
 			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 		}
 		callArgs = append(callArgs, s.mem())
@@ -4738,18 +4781,9 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 	var codeptr *ssa.Value // ptr to target code (if dynamic)
 	var rcvr *ssa.Value    // receiver to set
 	fn := n.X
-	var ACArgs []ssa.Param
-	var ACResults []ssa.Param
-	var callArgs []*ssa.Value
-	res := n.X.Type().Results()
-	if k == callNormal {
-		nf := res.NumFields()
-		for i := 0; i < nf; i++ {
-			fp := res.Field(i)
-			ACResults = append(ACResults, ssa.Param{Type: fp.Type, Offset: int32(fp.Offset + base.Ctxt.FixedFrameSize())})
-		}
-	}
-
+	var ACArgs []ssa.Param    // AuxCall args
+	var ACResults []ssa.Param // AuxCall results
+	var callArgs []*ssa.Value // For late-expansion, the args themselves (not stored, args to the call instead).
 	inRegisters := false
 
 	switch n.Op() {
@@ -4757,7 +4791,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		if k == callNormal && fn.Op() == ir.ONAME && fn.(*ir.Name).Class == ir.PFUNC {
 			fn := fn.(*ir.Name)
 			callee = fn
-			// TODO remove after register abi is working
+			// TODO(register args) remove after register abi is working
 			inRegistersImported := fn.Pragma()&ir.RegisterParams != 0
 			inRegistersSamePackage := fn.Func != nil && fn.Func.Pragma&ir.RegisterParams != 0
 			inRegisters = inRegistersImported || inRegistersSamePackage
@@ -4790,6 +4824,27 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 	types.CalcSize(fn.Type())
 	stksize := fn.Type().ArgWidth() // includes receiver, args, and results
 
+	abi := s.f.ABI1
+	if !inRegisters {
+		abi = s.f.ABI0
+	}
+
+	params := abi.ABIAnalyze(n.X.Type())
+
+	res := n.X.Type().Results()
+	if k == callNormal {
+		for _, p := range params.OutParams() {
+			r := p.Registers
+			var o int32
+			if len(r) == 0 {
+				o = p.Offset()
+			} else {
+				o = p.SpillOffset() + int32(params.SpillAreaOffset())
+			}
+			ACResults = append(ACResults, ssa.Param{Type: p.Type, Offset: o + int32(base.Ctxt.FixedFrameSize()), Reg: r})
+		}
+	}
+
 	var call *ssa.Value
 	if k == callDeferStack {
 		// Make a defer struct d on the stack.
@@ -4841,14 +4896,14 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 
 		// Call runtime.deferprocStack with pointer to _defer record.
 		ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(base.Ctxt.FixedFrameSize())})
-		aux := ssa.StaticAuxCall(ir.Syms.DeferprocStack, ACArgs, ACResults)
+		aux := ssa.StaticAuxCall(ir.Syms.DeferprocStack, ACArgs, ACResults, nil)
 		callArgs = append(callArgs, addr, s.mem())
 		call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 		call.AddArgs(callArgs...)
 		if stksize < int64(types.PtrSize) {
 			// We need room for both the call to deferprocStack and the call to
 			// the deferred function.
-			// TODO Revisit this if/when we pass args in registers.
+			// TODO(register args) Revisit this if/when we pass args in registers.
 			stksize = int64(types.PtrSize)
 		}
 		call.AuxInt = stksize
@@ -4870,7 +4925,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 
 		// Set receiver (for interface calls).
 		if rcvr != nil {
-			ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(argStart)})
+			// ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(argStart)})
 			callArgs = append(callArgs, rcvr)
 		}
 
@@ -4880,11 +4935,20 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		if n.Op() == ir.OCALLMETH {
 			base.Fatalf("OCALLMETH missed by walkCall")
 		}
-		for i, n := range args {
-			f := t.Params().Field(i)
-			ACArg, arg := s.putArg(n, f.Type, argStart+f.Offset)
+
+		for _, p := range params.InParams() {
+			r := p.Registers
+			var o int32
+			if len(r) == 0 {
+				o = p.Offset()
+			} else {
+				o = p.SpillOffset() + int32(params.SpillAreaOffset())
+			}
+			ACArg := ssa.Param{Type: p.Type, Offset: int32(argStart) + o, Reg: r}
 			ACArgs = append(ACArgs, ACArg)
-			callArgs = append(callArgs, arg)
+		}
+		for i, n := range args {
+			callArgs = append(callArgs, s.putArg(n, t.Params().Field(i).Type))
 		}
 
 		callArgs = append(callArgs, s.mem())
@@ -4892,11 +4956,11 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		// call target
 		switch {
 		case k == callDefer:
-			aux := ssa.StaticAuxCall(ir.Syms.Deferproc, ACArgs, ACResults)
+			aux := ssa.StaticAuxCall(ir.Syms.Deferproc, ACArgs, ACResults, nil) // TODO paramResultInfo for DeferProc
 			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 		case k == callGo:
-			aux := ssa.StaticAuxCall(ir.Syms.Newproc, ACArgs, ACResults)
-			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
+			aux := ssa.StaticAuxCall(ir.Syms.Newproc, ACArgs, ACResults, nil)
+			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux) // TODO paramResultInfo for NewProc
 		case closure != nil:
 			// rawLoad because loading the code pointer from a
 			// closure is always safe, but IsSanitizerSafeAddr
@@ -4910,7 +4974,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			aux := ssa.InterfaceAuxCall(ACArgs, ACResults)
 			call = s.newValue1A(ssa.OpInterLECall, aux.LateExpansionResultType(), aux, codeptr)
 		case callee != nil:
-			aux := ssa.StaticAuxCall(callTargetLSym(callee, s.curfn.LSym), ACArgs, ACResults)
+			aux := ssa.StaticAuxCall(callTargetLSym(callee, s.curfn.LSym), ACArgs, ACResults, params)
 			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 		default:
 			s.Fatalf("bad call type %v %v", n.Op(), n)
@@ -5391,7 +5455,7 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
 
 	// Issue call
 	var call *ssa.Value
-	aux := ssa.StaticAuxCall(fn, ACArgs, ACResults)
+	aux := ssa.StaticAuxCall(fn, ACArgs, ACResults, nil) // WILL NEED A TYPE FOR THIS.)
 	callArgs = append(callArgs, s.mem())
 	call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 	call.AddArgs(callArgs...)
@@ -5539,15 +5603,15 @@ func (s *state) storeTypePtrs(t *types.Type, left, right *ssa.Value) {
 	}
 }
 
-// putArg evaluates n for the purpose of passing it as an argument to a function and returns the corresponding Param and value for the call.
-func (s *state) putArg(n ir.Node, t *types.Type, off int64) (ssa.Param, *ssa.Value) {
+// putArg evaluates n for the purpose of passing it as an argument to a function and returns the value for the call.
+func (s *state) putArg(n ir.Node, t *types.Type) *ssa.Value {
 	var a *ssa.Value
 	if !TypeOK(t) {
 		a = s.newValue2(ssa.OpDereference, t, s.addr(n), s.mem())
 	} else {
 		a = s.expr(n)
 	}
-	return ssa.Param{Type: t, Offset: int32(off)}, a
+	return a
 }
 
 func (s *state) storeArgWithBase(n ir.Node, t *types.Type, base *ssa.Value, off int64) {
diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index 6fab74e61f..38ac753201 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -1025,7 +1025,7 @@ func (w *exportWriter) funcExt(n *ir.Name) {
 	w.linkname(n.Sym())
 	w.symIdx(n.Sym())
 
-	// TODO remove after register abi is working.
+	// TODO(register args) remove after register abi is working.
 	w.uint64(uint64(n.Func.Pragma))
 
 	// Escape analysis.
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 29090a9178..17aa35549d 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -673,7 +673,7 @@ func (r *importReader) funcExt(n *ir.Name) {
 	r.linkname(n.Sym())
 	r.symIdx(n.Sym())
 
-	// TODO remove after register abi is working
+	// TODO(register args) remove after register abi is working
 	n.SetPragma(ir.PragmaFlag(r.uint64()))
 
 	// Escape analysis.
diff --git a/test/abi/regabipragma.go b/test/abi/regabipragma.go
index e7ecd58fc8..86f42f9779 100644
--- a/test/abi/regabipragma.go
+++ b/test/abi/regabipragma.go
@@ -1,3 +1,4 @@
+// skip
 // runindir -gcflags=-c=1
 // +build !windows
 
@@ -5,6 +6,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// TODO May delete or adapt this test once regabi is the default
+// TODO(register args) Temporarily disabled now that register abi info is flowing halfway through the compiler.
+// TODO(register args) May delete or adapt this test once regabi is the default
 
 package ignore
-- 
GitLab


From dc4698f52b5ad3f0251e0cc25bc7ffbd10e23f2c Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Tue, 23 Feb 2021 13:29:40 +0100
Subject: [PATCH 0823/2400] syscall: do not overflow key memory in
 GetQueuedCompletionStatus

The third argument to GetQueuedCompletionStatus is a pointer to a
uintptr, not a uint32. Users of this functions have therefore been
corrupting their memory every time they used it. Either that memory
corruption was silent (dangerous), or their programs didn't work so they
chose a different API to use.

Fixes #44538.

RELNOTES=yes

Change-Id: Idf48d4c712d13da29791e9a460159255f963105b
Reviewed-on: https://go-review.googlesource.com/c/go/+/295371
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 api/except.txt                  | 6 ++++++
 src/syscall/syscall_windows.go  | 6 +++---
 src/syscall/zsyscall_windows.go | 6 +++---
 3 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/api/except.txt b/api/except.txt
index 6f6f839ba6..1ddc397d11 100644
--- a/api/except.txt
+++ b/api/except.txt
@@ -471,6 +471,9 @@ pkg syscall (openbsd-amd64-cgo), type Statfs_t struct, Pad_cgo_1 [4]uint8
 pkg syscall (openbsd-amd64-cgo), type Timespec struct, Pad_cgo_0 [4]uint8
 pkg syscall (openbsd-amd64-cgo), type Timespec struct, Sec int32
 pkg syscall (windows-386), const TOKEN_ALL_ACCESS = 983295
+pkg syscall (windows-386), func CreateIoCompletionPort(Handle, Handle, uint32, uint32) (Handle, error)
+pkg syscall (windows-386), func GetQueuedCompletionStatus(Handle, *uint32, *uint32, **Overlapped, uint32) error
+pkg syscall (windows-386), func PostQueuedCompletionStatus(Handle, uint32, uint32, *Overlapped) error
 pkg syscall (windows-386), type AddrinfoW struct, Addr uintptr
 pkg syscall (windows-386), type CertChainPolicyPara struct, ExtraPolicyPara uintptr
 pkg syscall (windows-386), type CertChainPolicyStatus struct, ExtraPolicyStatus uintptr
@@ -480,6 +483,9 @@ pkg syscall (windows-386), type CertRevocationInfo struct, OidSpecificInfo uintp
 pkg syscall (windows-386), type CertSimpleChain struct, TrustListInfo uintptr
 pkg syscall (windows-386), type RawSockaddrAny struct, Pad [96]int8
 pkg syscall (windows-amd64), const TOKEN_ALL_ACCESS = 983295
+pkg syscall (windows-amd64), func CreateIoCompletionPort(Handle, Handle, uint32, uint32) (Handle, error)
+pkg syscall (windows-amd64), func GetQueuedCompletionStatus(Handle, *uint32, *uint32, **Overlapped, uint32) error
+pkg syscall (windows-amd64), func PostQueuedCompletionStatus(Handle, uint32, uint32, *Overlapped) error
 pkg syscall (windows-amd64), type AddrinfoW struct, Addr uintptr
 pkg syscall (windows-amd64), type CertChainPolicyPara struct, ExtraPolicyPara uintptr
 pkg syscall (windows-amd64), type CertChainPolicyStatus struct, ExtraPolicyStatus uintptr
diff --git a/src/syscall/syscall_windows.go b/src/syscall/syscall_windows.go
index 4a576486d1..a958f7aa84 100644
--- a/src/syscall/syscall_windows.go
+++ b/src/syscall/syscall_windows.go
@@ -213,9 +213,9 @@ func NewCallbackCDecl(fn interface{}) uintptr {
 //sys	SetEndOfFile(handle Handle) (err error)
 //sys	GetSystemTimeAsFileTime(time *Filetime)
 //sys	GetTimeZoneInformation(tzi *Timezoneinformation) (rc uint32, err error) [failretval==0xffffffff]
-//sys	CreateIoCompletionPort(filehandle Handle, cphandle Handle, key uint32, threadcnt uint32) (handle Handle, err error)
-//sys	GetQueuedCompletionStatus(cphandle Handle, qty *uint32, key *uint32, overlapped **Overlapped, timeout uint32) (err error)
-//sys	PostQueuedCompletionStatus(cphandle Handle, qty uint32, key uint32, overlapped *Overlapped) (err error)
+//sys	CreateIoCompletionPort(filehandle Handle, cphandle Handle, key uintptr, threadcnt uint32) (handle Handle, err error)
+//sys	GetQueuedCompletionStatus(cphandle Handle, qty *uint32, key *uintptr, overlapped **Overlapped, timeout uint32) (err error)
+//sys	PostQueuedCompletionStatus(cphandle Handle, qty uint32, key uintptr, overlapped *Overlapped) (err error)
 //sys	CancelIo(s Handle) (err error)
 //sys	CancelIoEx(s Handle, o *Overlapped) (err error)
 //sys	CreateProcess(appName *uint16, commandLine *uint16, procSecurity *SecurityAttributes, threadSecurity *SecurityAttributes, inheritHandles bool, creationFlags uint32, env *uint16, currentDir *uint16, startupInfo *StartupInfo, outProcInfo *ProcessInformation) (err error) = CreateProcessW
diff --git a/src/syscall/zsyscall_windows.go b/src/syscall/zsyscall_windows.go
index 2166be595b..cc44e31a85 100644
--- a/src/syscall/zsyscall_windows.go
+++ b/src/syscall/zsyscall_windows.go
@@ -515,7 +515,7 @@ func CreateHardLink(filename *uint16, existingfilename *uint16, reserved uintptr
 	return
 }
 
-func CreateIoCompletionPort(filehandle Handle, cphandle Handle, key uint32, threadcnt uint32) (handle Handle, err error) {
+func CreateIoCompletionPort(filehandle Handle, cphandle Handle, key uintptr, threadcnt uint32) (handle Handle, err error) {
 	r0, _, e1 := Syscall6(procCreateIoCompletionPort.Addr(), 4, uintptr(filehandle), uintptr(cphandle), uintptr(key), uintptr(threadcnt), 0, 0)
 	handle = Handle(r0)
 	if handle == 0 {
@@ -822,7 +822,7 @@ func GetProcessTimes(handle Handle, creationTime *Filetime, exitTime *Filetime,
 	return
 }
 
-func GetQueuedCompletionStatus(cphandle Handle, qty *uint32, key *uint32, overlapped **Overlapped, timeout uint32) (err error) {
+func GetQueuedCompletionStatus(cphandle Handle, qty *uint32, key *uintptr, overlapped **Overlapped, timeout uint32) (err error) {
 	r1, _, e1 := Syscall6(procGetQueuedCompletionStatus.Addr(), 5, uintptr(cphandle), uintptr(unsafe.Pointer(qty)), uintptr(unsafe.Pointer(key)), uintptr(unsafe.Pointer(overlapped)), uintptr(timeout), 0)
 	if r1 == 0 {
 		err = errnoErr(e1)
@@ -954,7 +954,7 @@ func OpenProcess(da uint32, inheritHandle bool, pid uint32) (handle Handle, err
 	return
 }
 
-func PostQueuedCompletionStatus(cphandle Handle, qty uint32, key uint32, overlapped *Overlapped) (err error) {
+func PostQueuedCompletionStatus(cphandle Handle, qty uint32, key uintptr, overlapped *Overlapped) (err error) {
 	r1, _, e1 := Syscall6(procPostQueuedCompletionStatus.Addr(), 4, uintptr(cphandle), uintptr(qty), uintptr(key), uintptr(unsafe.Pointer(overlapped)), 0, 0)
 	if r1 == 0 {
 		err = errnoErr(e1)
-- 
GitLab


From c9d9b40b1355a8e6674aaaf6abaf362e66abae47 Mon Sep 17 00:00:00 2001
From: Kevin Burke <kev@inburke.com>
Date: Wed, 24 Feb 2021 09:12:34 -0800
Subject: [PATCH 0824/2400] context: avoid importing context package twice

Change-Id: Id0a127e080dda8ee62738922c6de8caf3719dd68
Reviewed-on: https://go-review.googlesource.com/c/go/+/295949
Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Trust: Kevin Burke <kev@inburke.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/context/benchmark_test.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/context/benchmark_test.go b/src/context/benchmark_test.go
index c4c72f00f8..69d75fff18 100644
--- a/src/context/benchmark_test.go
+++ b/src/context/benchmark_test.go
@@ -5,7 +5,6 @@
 package context_test
 
 import (
-	"context"
 	. "context"
 	"fmt"
 	"runtime"
@@ -141,7 +140,7 @@ func BenchmarkCheckCanceled(b *testing.B) {
 }
 
 func BenchmarkContextCancelDone(b *testing.B) {
-	ctx, cancel := context.WithCancel(context.Background())
+	ctx, cancel := WithCancel(Background())
 	defer cancel()
 
 	b.RunParallel(func(pb *testing.PB) {
-- 
GitLab


From b7f62daa59ea5983d5825e166abc527d4ea69777 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Tue, 15 Dec 2020 16:01:34 -0500
Subject: [PATCH 0825/2400] cmd/internal/goobj: add test case for object file
 reader

Add test in which a input Go object file contains a very large number
of relocations (more than 1<<20).

Updates #41621.

Change-Id: If1ebf3c4fefbf55ddec4e05c5299e7c48fc697d8
Reviewed-on: https://go-review.googlesource.com/c/go/+/278493
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: Than McIntosh <thanm@google.com>
---
 src/cmd/internal/goobj/objfile_test.go | 62 ++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)

diff --git a/src/cmd/internal/goobj/objfile_test.go b/src/cmd/internal/goobj/objfile_test.go
index c6fd427c15..99d02a1bf1 100644
--- a/src/cmd/internal/goobj/objfile_test.go
+++ b/src/cmd/internal/goobj/objfile_test.go
@@ -9,6 +9,11 @@ import (
 	"bytes"
 	"cmd/internal/bio"
 	"cmd/internal/objabi"
+	"fmt"
+	"internal/testenv"
+	"io/ioutil"
+	"os"
+	"os/exec"
 	"testing"
 )
 
@@ -69,3 +74,60 @@ func TestReadWrite(t *testing.T) {
 		t.Errorf("read Aux2 mismatch: got %v %v", a2.Type(), a2.Sym())
 	}
 }
+
+var issue41621prolog = `
+package main
+var lines = []string{
+`
+
+var issue41621epilog = `
+}
+func getLines() []string {
+	return lines
+}
+func main() {
+	println(getLines())
+}
+`
+
+func TestIssue41621LargeNumberOfRelocations(t *testing.T) {
+	if testing.Short() || (objabi.GOARCH != "amd64") {
+		t.Skipf("Skipping large number of relocations test in short mode or on %s", objabi.GOARCH)
+	}
+	testenv.MustHaveGoBuild(t)
+
+	tmpdir, err := ioutil.TempDir("", "lotsofrelocs")
+	if err != nil {
+		t.Fatalf("can't create temp directory: %v\n", err)
+	}
+	defer os.RemoveAll(tmpdir)
+
+	// Emit testcase.
+	var w bytes.Buffer
+	fmt.Fprintf(&w, issue41621prolog)
+	for i := 0; i < 1048576+13; i++ {
+		fmt.Fprintf(&w, "\t\"%d\",\n", i)
+	}
+	fmt.Fprintf(&w, issue41621epilog)
+	err = ioutil.WriteFile(tmpdir+"/large.go", w.Bytes(), 0666)
+	if err != nil {
+		t.Fatalf("can't write output: %v\n", err)
+	}
+
+	// Emit go.mod
+	w.Reset()
+	fmt.Fprintf(&w, "module issue41621\n\ngo 1.12\n")
+	err = ioutil.WriteFile(tmpdir+"/go.mod", w.Bytes(), 0666)
+	if err != nil {
+		t.Fatalf("can't write output: %v\n", err)
+	}
+	w.Reset()
+
+	// Build.
+	cmd := exec.Command(testenv.GoToolPath(t), "build", "-o", "large")
+	cmd.Dir = tmpdir
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("Build failed: %v, output: %s", err, out)
+	}
+}
-- 
GitLab


From bf48163e8f2b604f3b9e83951e331cd11edd8495 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alejandro=20Garc=C3=ADa=20Montoro?=
 <alejandro.garciamontoro@gmail.com>
Date: Wed, 30 Dec 2020 18:41:36 +0100
Subject: [PATCH 0826/2400] cmd/compile: add rule to coalesce writes

The code generated when storing eight bytes loaded from memory created a
series of small writes instead of a single, large one. The specific
pattern of instructions generated stored 1 byte, then 2 bytes, then 4
bytes, and finally 1 byte.

The new rules match this specific pattern both for amd64 and for s390x,
and convert it into a single instruction to store the 8 bytes. arm64 and
ppc64le already generated the right code, but the new codegen test
covers also those architectures.

Fixes #41663

Change-Id: Ifb9b464be2d59c2ed5034acf7b9c3e473f344030
Reviewed-on: https://go-review.googlesource.com/c/go/+/280456
Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ssa/gen/AMD64.rules | 10 ++++
 src/cmd/compile/internal/ssa/gen/S390X.rules | 10 ++++
 src/cmd/compile/internal/ssa/rewriteAMD64.go | 48 ++++++++++++++++++++
 src/cmd/compile/internal/ssa/rewriteS390X.go | 48 ++++++++++++++++++++
 test/codegen/memcombine.go                   |  9 ++++
 5 files changed, 125 insertions(+)

diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules
index 01a8a16456..f2bcbd2dfc 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64.rules
+++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules
@@ -1969,6 +1969,16 @@
   && clobber(x)
   => (MOVQstore [i] {s} p0 w0 mem)
 
+(MOVBstore [7] p1 (SHRQconst [56] w)
+  x1:(MOVWstore [5] p1 (SHRQconst [40] w)
+  x2:(MOVLstore [1] p1 (SHRQconst [8] w)
+  x3:(MOVBstore p1 w mem))))
+  && x1.Uses == 1
+  && x2.Uses == 1
+  && x3.Uses == 1
+  && clobber(x1, x2, x3)
+  => (MOVQstore p1 w mem)
+
 (MOVBstore [i] {s} p
   x1:(MOVBload [j] {s2} p2 mem)
     mem2:(MOVBstore [i-1] {s} p
diff --git a/src/cmd/compile/internal/ssa/gen/S390X.rules b/src/cmd/compile/internal/ssa/gen/S390X.rules
index c3421da0a2..7111d5e11a 100644
--- a/src/cmd/compile/internal/ssa/gen/S390X.rules
+++ b/src/cmd/compile/internal/ssa/gen/S390X.rules
@@ -1420,6 +1420,16 @@
   && clobber(x)
   => (MOVDBRstore [i-4] {s} p w0 mem)
 
+(MOVBstore [7] p1 (SRDconst w)
+  x1:(MOVHBRstore [5] p1 (SRDconst w)
+  x2:(MOVWBRstore [1] p1 (SRDconst w)
+  x3:(MOVBstore p1 w mem))))
+  && x1.Uses == 1
+  && x2.Uses == 1
+  && x3.Uses == 1
+  && clobber(x1, x2, x3)
+  => (MOVDBRstore p1 w mem)
+
 // Combining byte loads into larger (unaligned) loads.
 
 // Big-endian loads
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index 5fb6c303fd..599137c806 100644
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -11412,6 +11412,54 @@ func rewriteValueAMD64_OpAMD64MOVBstore(v *Value) bool {
 		v.AddArg3(p0, w0, mem)
 		return true
 	}
+	// match: (MOVBstore [7] p1 (SHRQconst [56] w) x1:(MOVWstore [5] p1 (SHRQconst [40] w) x2:(MOVLstore [1] p1 (SHRQconst [8] w) x3:(MOVBstore p1 w mem))))
+	// cond: x1.Uses == 1 && x2.Uses == 1 && x3.Uses == 1 && clobber(x1, x2, x3)
+	// result: (MOVQstore p1 w mem)
+	for {
+		if auxIntToInt32(v.AuxInt) != 7 {
+			break
+		}
+		p1 := v_0
+		if v_1.Op != OpAMD64SHRQconst || auxIntToInt8(v_1.AuxInt) != 56 {
+			break
+		}
+		w := v_1.Args[0]
+		x1 := v_2
+		if x1.Op != OpAMD64MOVWstore || auxIntToInt32(x1.AuxInt) != 5 {
+			break
+		}
+		_ = x1.Args[2]
+		if p1 != x1.Args[0] {
+			break
+		}
+		x1_1 := x1.Args[1]
+		if x1_1.Op != OpAMD64SHRQconst || auxIntToInt8(x1_1.AuxInt) != 40 || w != x1_1.Args[0] {
+			break
+		}
+		x2 := x1.Args[2]
+		if x2.Op != OpAMD64MOVLstore || auxIntToInt32(x2.AuxInt) != 1 {
+			break
+		}
+		_ = x2.Args[2]
+		if p1 != x2.Args[0] {
+			break
+		}
+		x2_1 := x2.Args[1]
+		if x2_1.Op != OpAMD64SHRQconst || auxIntToInt8(x2_1.AuxInt) != 8 || w != x2_1.Args[0] {
+			break
+		}
+		x3 := x2.Args[2]
+		if x3.Op != OpAMD64MOVBstore {
+			break
+		}
+		mem := x3.Args[2]
+		if p1 != x3.Args[0] || w != x3.Args[1] || !(x1.Uses == 1 && x2.Uses == 1 && x3.Uses == 1 && clobber(x1, x2, x3)) {
+			break
+		}
+		v.reset(OpAMD64MOVQstore)
+		v.AddArg3(p1, w, mem)
+		return true
+	}
 	// match: (MOVBstore [i] {s} p x1:(MOVBload [j] {s2} p2 mem) mem2:(MOVBstore [i-1] {s} p x2:(MOVBload [j-1] {s2} p2 mem) mem))
 	// cond: x1.Uses == 1 && x2.Uses == 1 && mem2.Uses == 1 && clobber(x1, x2, mem2)
 	// result: (MOVWstore [i-1] {s} p (MOVWload [j-1] {s2} p2 mem) mem)
diff --git a/src/cmd/compile/internal/ssa/rewriteS390X.go b/src/cmd/compile/internal/ssa/rewriteS390X.go
index b52a1b6745..6adae3ff35 100644
--- a/src/cmd/compile/internal/ssa/rewriteS390X.go
+++ b/src/cmd/compile/internal/ssa/rewriteS390X.go
@@ -8880,6 +8880,54 @@ func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool {
 		v.AddArg3(p, w0, mem)
 		return true
 	}
+	// match: (MOVBstore [7] p1 (SRDconst w) x1:(MOVHBRstore [5] p1 (SRDconst w) x2:(MOVWBRstore [1] p1 (SRDconst w) x3:(MOVBstore p1 w mem))))
+	// cond: x1.Uses == 1 && x2.Uses == 1 && x3.Uses == 1 && clobber(x1, x2, x3)
+	// result: (MOVDBRstore p1 w mem)
+	for {
+		if auxIntToInt32(v.AuxInt) != 7 {
+			break
+		}
+		p1 := v_0
+		if v_1.Op != OpS390XSRDconst {
+			break
+		}
+		w := v_1.Args[0]
+		x1 := v_2
+		if x1.Op != OpS390XMOVHBRstore || auxIntToInt32(x1.AuxInt) != 5 {
+			break
+		}
+		_ = x1.Args[2]
+		if p1 != x1.Args[0] {
+			break
+		}
+		x1_1 := x1.Args[1]
+		if x1_1.Op != OpS390XSRDconst || w != x1_1.Args[0] {
+			break
+		}
+		x2 := x1.Args[2]
+		if x2.Op != OpS390XMOVWBRstore || auxIntToInt32(x2.AuxInt) != 1 {
+			break
+		}
+		_ = x2.Args[2]
+		if p1 != x2.Args[0] {
+			break
+		}
+		x2_1 := x2.Args[1]
+		if x2_1.Op != OpS390XSRDconst || w != x2_1.Args[0] {
+			break
+		}
+		x3 := x2.Args[2]
+		if x3.Op != OpS390XMOVBstore {
+			break
+		}
+		mem := x3.Args[2]
+		if p1 != x3.Args[0] || w != x3.Args[1] || !(x1.Uses == 1 && x2.Uses == 1 && x3.Uses == 1 && clobber(x1, x2, x3)) {
+			break
+		}
+		v.reset(OpS390XMOVDBRstore)
+		v.AddArg3(p1, w, mem)
+		return true
+	}
 	return false
 }
 func rewriteValueS390X_OpS390XMOVBstoreconst(v *Value) bool {
diff --git a/test/codegen/memcombine.go b/test/codegen/memcombine.go
index 6ad9514557..121f394f29 100644
--- a/test/codegen/memcombine.go
+++ b/test/codegen/memcombine.go
@@ -367,6 +367,15 @@ func store_le64_idx(b []byte, idx int) {
 	binary.LittleEndian.PutUint64(b[idx:], sink64)
 }
 
+func store_le64_load(b []byte, x *[8]byte) {
+	_ = b[8]
+	// amd64:-`MOV[BWL]`
+	// arm64:-`MOV[BWH]`
+	// ppc64le:-`MOV[BWH]`
+	// s390x:-`MOVB`,-`MOV[WH]BR`
+	binary.LittleEndian.PutUint64(b, binary.LittleEndian.Uint64(x[:]))
+}
+
 func store_le32(b []byte) {
 	// amd64:`MOVL\s`
 	// arm64:`MOVW`,-`MOV[BH]`
-- 
GitLab


From 478277f81283b9e941c4fdadc253797e6d035971 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Tue, 23 Feb 2021 22:03:29 -0500
Subject: [PATCH 0827/2400] cmd/compile/internal-abi: use x87 mode, not MMX
 mode

Florian Weimer pointed out that my justification for using MMX mode
was nonsense and that staying in x87 mode simplifies transitions to
and from C. Hence, switch the spec to say we're always in x87 mode.

For #40724.

Change-Id: Iad916b2c376db41f95614aa6897f6b1184576bb7
Reviewed-on: https://go-review.googlesource.com/c/go/+/295789
Trust: Austin Clements <austin@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal-abi.md | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/src/cmd/compile/internal-abi.md b/src/cmd/compile/internal-abi.md
index f4ef2cc869..3a3509d8c2 100644
--- a/src/cmd/compile/internal-abi.md
+++ b/src/cmd/compile/internal-abi.md
@@ -455,13 +455,12 @@ The arithmetic status flags are treated like scratch registers and not
 preserved across calls.
 All other bits in RFLAGS are system flags.
 
-The CPU is always in MMX technology state (not x87 mode).
+At function calls and returns, the CPU is in x87 mode (not MMX
+technology mode).
 
-*Rationale*: Go on amd64 uses the XMM registers and never uses the x87
-registers, so it makes sense to assume the CPU is in MMX mode.
-Otherwise, any function that used the XMM registers would have to
-execute an EMMS instruction before calling another function or
-returning (this is the case in the SysV ABI).
+*Rationale*: Go on amd64 does not use either the x87 registers or MMX
+registers. Hence, we follow the SysV platform conventions in order to
+simplify transitions to and from the C ABI.
 
 At calls, the MXCSR control bits are always set as follows:
 
-- 
GitLab


From 3deb528199383b39425fc99f3741a6ade6ab5a6b Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Tue, 23 Feb 2021 21:22:20 -0500
Subject: [PATCH 0828/2400] cmd/compile/internal-abi: update internal ABI spec
 for g register

We've already implemented dedicating R14 as the G register on amd64,
so remove the TODO saying we might want to hold off on this.

For #40724.

Change-Id: I45b24ced03cac862127b53f5e9a4b4bcf6b1f86c
Reviewed-on: https://go-review.googlesource.com/c/go/+/295790
Trust: Austin Clements <austin@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal-abi.md | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/cmd/compile/internal-abi.md b/src/cmd/compile/internal-abi.md
index 3a3509d8c2..0e5d8ce260 100644
--- a/src/cmd/compile/internal-abi.md
+++ b/src/cmd/compile/internal-abi.md
@@ -402,9 +402,6 @@ Special-purpose registers are as follows:
 | R15 | GOT reference temporary | Fixed if dynlink |
 | X15 | Zero value | Fixed |
 
-TODO: We may start with the existing TLS-based g and move to R14
-later.
-
 *Rationale*: These register meanings are compatible with Go’s
 stack-based calling convention except for R14 and X15, which will have
 to be restored on transitions from ABI0 code to ABIInternal code.
-- 
GitLab


From 80ddc17ae1b3ffacc42c19b999956f9ccef3ddd1 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Tue, 23 Feb 2021 20:48:22 -0500
Subject: [PATCH 0829/2400] cmd/compile/internal-abi: fix ABI0-equivalence for
 zero-sized values

This fixes a bug in the internal ABI specification that made it not
equivalent to ABI0 even with zero architectural argument registers in
the case of a zero-sized argument with alignment > 1.

In ABI0, even zero-sized arguments cause alignment padding in the
stack frame.

Currently, in the internal ABI, zero-sized arguments get
register-assigned even if there are no registers because they don't
consume any registers. Hence, they don't create alignment padding in
the stack frame.

Fix this by stack-assigning zero-sized arguments.

For #40724.

Change-Id: I1f5a95a94fed8b5313a360e5e76875701ba5f562
Reviewed-on: https://go-review.googlesource.com/c/go/+/295791
Trust: Austin Clements <austin@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal-abi.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/cmd/compile/internal-abi.md b/src/cmd/compile/internal-abi.md
index 0e5d8ce260..b457f6ee74 100644
--- a/src/cmd/compile/internal-abi.md
+++ b/src/cmd/compile/internal-abi.md
@@ -153,6 +153,7 @@ Assigning a receiver, argument, or result V of underlying type T works
 as follows:
 
 1. Remember I and FP.
+1. If T has zero size, add T to the stack sequence S and return.
 1. Try to register-assign V.
 1. If step 2 failed, reset I and FP to the values from step 1, add T
    to the stack sequence S, and assign V to this field in S.
@@ -295,6 +296,15 @@ An architecture may still define register meanings that aren’t
 compatible with ABI0, but these differences should be easy to account
 for in the compiler.
 
+The assignment algorithm assigns zero-sized values to the stack
+(assignment step 2) in order to support ABI0-equivalence.
+While these values take no space themselves, they do result in
+alignment padding on the stack in ABI0.
+Without this step, the internal ABI would register-assign zero-sized
+values even on architectures that provide no argument registers
+because they don't consume any registers, and hence not add alignment
+padding to the stack.
+
 The algorithm reserves spill space for arguments in the caller’s frame
 so that the compiler can generate a stack growth path that spills into
 this reserved space.
-- 
GitLab


From 3ee32439b5114c1fe5f04891b678613aa72e13c2 Mon Sep 17 00:00:00 2001
From: Egon Elbre <egonelbre@gmail.com>
Date: Fri, 27 Nov 2020 17:10:33 +0200
Subject: [PATCH 0830/2400] cmd/compile: ARM64 optimize []float64 and []float32
 access

Optimize load and store to []float64 and []float32.
Previously it used LSL instead of shifted register indexed load/store.

Before:

    LSL   $3, R0, R0
    FMOVD F0, (R1)(R0)

After:

    FMOVD F0, (R1)(R0<<3)

Fixes #42798

Change-Id: I0c0912140c3dce5aa6abc27097c0eb93833cc589
Reviewed-on: https://go-review.googlesource.com/c/go/+/273706
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Giovanni Bajo <rasky@develer.com>
---
 src/cmd/compile/internal/arm64/ssa.go        |  14 +-
 src/cmd/compile/internal/ssa/gen/ARM64.rules |  18 ++
 src/cmd/compile/internal/ssa/gen/ARM64Ops.go |  20 +-
 src/cmd/compile/internal/ssa/opGen.go        |  56 ++++
 src/cmd/compile/internal/ssa/rewriteARM64.go | 294 +++++++++++++++++++
 test/codegen/floats.go                       |   4 +-
 test/codegen/memops.go                       |   4 +
 7 files changed, 396 insertions(+), 14 deletions(-)

diff --git a/src/cmd/compile/internal/arm64/ssa.go b/src/cmd/compile/internal/arm64/ssa.go
index 73e74e1219..ca5eac72bf 100644
--- a/src/cmd/compile/internal/arm64/ssa.go
+++ b/src/cmd/compile/internal/arm64/ssa.go
@@ -100,9 +100,11 @@ func genIndexedOperand(v *ssa.Value) obj.Addr {
 	// Reg: base register, Index: (shifted) index register
 	mop := obj.Addr{Type: obj.TYPE_MEM, Reg: v.Args[0].Reg()}
 	switch v.Op {
-	case ssa.OpARM64MOVDloadidx8, ssa.OpARM64MOVDstoreidx8, ssa.OpARM64MOVDstorezeroidx8:
+	case ssa.OpARM64MOVDloadidx8, ssa.OpARM64MOVDstoreidx8, ssa.OpARM64MOVDstorezeroidx8,
+		ssa.OpARM64FMOVDloadidx8, ssa.OpARM64FMOVDstoreidx8:
 		mop.Index = arm64.REG_LSL | 3<<5 | v.Args[1].Reg()&31
-	case ssa.OpARM64MOVWloadidx4, ssa.OpARM64MOVWUloadidx4, ssa.OpARM64MOVWstoreidx4, ssa.OpARM64MOVWstorezeroidx4:
+	case ssa.OpARM64MOVWloadidx4, ssa.OpARM64MOVWUloadidx4, ssa.OpARM64MOVWstoreidx4, ssa.OpARM64MOVWstorezeroidx4,
+		ssa.OpARM64FMOVSloadidx4, ssa.OpARM64FMOVSstoreidx4:
 		mop.Index = arm64.REG_LSL | 2<<5 | v.Args[1].Reg()&31
 	case ssa.OpARM64MOVHloadidx2, ssa.OpARM64MOVHUloadidx2, ssa.OpARM64MOVHstoreidx2, ssa.OpARM64MOVHstorezeroidx2:
 		mop.Index = arm64.REG_LSL | 1<<5 | v.Args[1].Reg()&31
@@ -435,7 +437,9 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssa.OpARM64MOVHUloadidx2,
 		ssa.OpARM64MOVWloadidx4,
 		ssa.OpARM64MOVWUloadidx4,
-		ssa.OpARM64MOVDloadidx8:
+		ssa.OpARM64MOVDloadidx8,
+		ssa.OpARM64FMOVDloadidx8,
+		ssa.OpARM64FMOVSloadidx4:
 		p := s.Prog(v.Op.Asm())
 		p.From = genIndexedOperand(v)
 		p.To.Type = obj.TYPE_REG
@@ -472,7 +476,9 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssa.OpARM64FMOVDstoreidx,
 		ssa.OpARM64MOVHstoreidx2,
 		ssa.OpARM64MOVWstoreidx4,
-		ssa.OpARM64MOVDstoreidx8:
+		ssa.OpARM64FMOVSstoreidx4,
+		ssa.OpARM64MOVDstoreidx8,
+		ssa.OpARM64FMOVDstoreidx8:
 		p := s.Prog(v.Op.Asm())
 		p.To = genIndexedOperand(v)
 		p.From.Type = obj.TYPE_REG
diff --git a/src/cmd/compile/internal/ssa/gen/ARM64.rules b/src/cmd/compile/internal/ssa/gen/ARM64.rules
index 4531c38a7a..98503748db 100644
--- a/src/cmd/compile/internal/ssa/gen/ARM64.rules
+++ b/src/cmd/compile/internal/ssa/gen/ARM64.rules
@@ -792,6 +792,15 @@
 (MOVHUloadidx2 ptr (MOVDconst [c]) mem) && is32Bit(c<<1) => (MOVHUload [int32(c)<<1] ptr mem)
 (MOVHloadidx2  ptr (MOVDconst [c]) mem) && is32Bit(c<<1) => (MOVHload  [int32(c)<<1] ptr mem)
 
+(FMOVDload [off] {sym} (ADDshiftLL [3] ptr idx) mem) && off == 0 && sym == nil => (FMOVDloadidx8 ptr idx mem)
+(FMOVSload [off] {sym} (ADDshiftLL [2] ptr idx) mem) && off == 0 && sym == nil => (FMOVSloadidx4 ptr idx mem)
+(FMOVDloadidx ptr (SLLconst [3] idx) mem) => (FMOVDloadidx8 ptr idx mem)
+(FMOVSloadidx ptr (SLLconst [2] idx) mem) => (FMOVSloadidx4 ptr idx mem)
+(FMOVDloadidx (SLLconst [3] idx) ptr mem) => (FMOVDloadidx8 ptr idx mem)
+(FMOVSloadidx (SLLconst [2] idx) ptr mem) => (FMOVSloadidx4 ptr idx mem)
+(FMOVDloadidx8 ptr (MOVDconst [c]) mem) && is32Bit(c<<3) => (FMOVDload ptr [int32(c)<<3] mem)
+(FMOVSloadidx4 ptr (MOVDconst [c]) mem) && is32Bit(c<<2) => (FMOVSload ptr [int32(c)<<2] mem)
+
 (MOVBstore [off1] {sym} (ADDconst [off2] ptr) val mem) && is32Bit(int64(off1)+off2)
 	&& (ptr.Op != OpSB || !config.ctxt.Flag_shared) =>
 	(MOVBstore [off1+int32(off2)] {sym} ptr val mem)
@@ -865,6 +874,15 @@
 (MOVWstoreidx4 ptr (MOVDconst [c]) val mem) && is32Bit(c<<2) => (MOVWstore [int32(c)<<2] ptr val mem)
 (MOVHstoreidx2 ptr (MOVDconst [c]) val mem) && is32Bit(c<<1) => (MOVHstore [int32(c)<<1] ptr val mem)
 
+(FMOVDstore [off] {sym} (ADDshiftLL [3] ptr idx) val mem) && off == 0 && sym == nil => (FMOVDstoreidx8 ptr idx val mem)
+(FMOVSstore [off] {sym} (ADDshiftLL [2] ptr idx) val mem) && off == 0 && sym == nil => (FMOVSstoreidx4 ptr idx val mem)
+(FMOVDstoreidx ptr (SLLconst [3] idx) val mem) => (FMOVDstoreidx8 ptr idx val mem)
+(FMOVSstoreidx ptr (SLLconst [2] idx) val mem) => (FMOVSstoreidx4 ptr idx val mem)
+(FMOVDstoreidx (SLLconst [3] idx) ptr val mem) => (FMOVDstoreidx8 ptr idx val mem)
+(FMOVSstoreidx (SLLconst [2] idx) ptr val mem) => (FMOVSstoreidx4 ptr idx val mem)
+(FMOVDstoreidx8 ptr (MOVDconst [c]) val mem) && is32Bit(c<<3) => (FMOVDstore [int32(c)<<3] ptr val mem)
+(FMOVSstoreidx4 ptr (MOVDconst [c]) val mem) && is32Bit(c<<2) => (FMOVSstore [int32(c)<<2] ptr val mem)
+
 (MOVBload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
 	&& canMergeSym(sym1,sym2) && is32Bit(int64(off1)+int64(off2))
 	&& (ptr.Op != OpSB || !config.ctxt.Flag_shared) =>
diff --git a/src/cmd/compile/internal/ssa/gen/ARM64Ops.go b/src/cmd/compile/internal/ssa/gen/ARM64Ops.go
index b0bc9c78ff..e826e75252 100644
--- a/src/cmd/compile/internal/ssa/gen/ARM64Ops.go
+++ b/src/cmd/compile/internal/ssa/gen/ARM64Ops.go
@@ -379,11 +379,13 @@ func init() {
 		{name: "FMOVDloadidx", argLength: 3, reg: fp2load, asm: "FMOVD", typ: "Float64"}, // load 64-bit float from arg0 + arg1, arg2=mem.
 
 		// shifted register indexed load
-		{name: "MOVHloadidx2", argLength: 3, reg: gp2load, asm: "MOVH", typ: "Int16"},    // load 16-bit half-word from arg0 + arg1*2, sign-extended to 64-bit, arg2=mem.
-		{name: "MOVHUloadidx2", argLength: 3, reg: gp2load, asm: "MOVHU", typ: "UInt16"}, // load 16-bit half-word from arg0 + arg1*2, zero-extended to 64-bit, arg2=mem.
-		{name: "MOVWloadidx4", argLength: 3, reg: gp2load, asm: "MOVW", typ: "Int32"},    // load 32-bit word from arg0 + arg1*4, sign-extended to 64-bit, arg2=mem.
-		{name: "MOVWUloadidx4", argLength: 3, reg: gp2load, asm: "MOVWU", typ: "UInt32"}, // load 32-bit word from arg0 + arg1*4, zero-extended to 64-bit, arg2=mem.
-		{name: "MOVDloadidx8", argLength: 3, reg: gp2load, asm: "MOVD", typ: "UInt64"},   // load 64-bit double-word from arg0 + arg1*8, arg2 = mem.
+		{name: "MOVHloadidx2", argLength: 3, reg: gp2load, asm: "MOVH", typ: "Int16"},     // load 16-bit half-word from arg0 + arg1*2, sign-extended to 64-bit, arg2=mem.
+		{name: "MOVHUloadidx2", argLength: 3, reg: gp2load, asm: "MOVHU", typ: "UInt16"},  // load 16-bit half-word from arg0 + arg1*2, zero-extended to 64-bit, arg2=mem.
+		{name: "MOVWloadidx4", argLength: 3, reg: gp2load, asm: "MOVW", typ: "Int32"},     // load 32-bit word from arg0 + arg1*4, sign-extended to 64-bit, arg2=mem.
+		{name: "MOVWUloadidx4", argLength: 3, reg: gp2load, asm: "MOVWU", typ: "UInt32"},  // load 32-bit word from arg0 + arg1*4, zero-extended to 64-bit, arg2=mem.
+		{name: "MOVDloadidx8", argLength: 3, reg: gp2load, asm: "MOVD", typ: "UInt64"},    // load 64-bit double-word from arg0 + arg1*8, arg2 = mem.
+		{name: "FMOVSloadidx4", argLength: 3, reg: fp2load, asm: "FMOVS", typ: "Float32"}, // load 32-bit float from arg0 + arg1*4, arg2 = mem.
+		{name: "FMOVDloadidx8", argLength: 3, reg: fp2load, asm: "FMOVD", typ: "Float64"}, // load 64-bit float from arg0 + arg1*8, arg2 = mem.
 
 		{name: "MOVBstore", argLength: 3, reg: gpstore, aux: "SymOff", asm: "MOVB", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"},   // store 1 byte of arg1 to arg0 + auxInt + aux.  arg2=mem.
 		{name: "MOVHstore", argLength: 3, reg: gpstore, aux: "SymOff", asm: "MOVH", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"},   // store 2 bytes of arg1 to arg0 + auxInt + aux.  arg2=mem.
@@ -402,9 +404,11 @@ func init() {
 		{name: "FMOVDstoreidx", argLength: 4, reg: fpstore2, asm: "FMOVD", typ: "Mem"}, // store 64-bit float of arg2 to arg0 + arg1, arg3=mem.
 
 		// shifted register indexed store
-		{name: "MOVHstoreidx2", argLength: 4, reg: gpstore2, asm: "MOVH", typ: "Mem"}, // store 2 bytes of arg2 to arg0 + arg1*2, arg3 = mem.
-		{name: "MOVWstoreidx4", argLength: 4, reg: gpstore2, asm: "MOVW", typ: "Mem"}, // store 4 bytes of arg2 to arg0 + arg1*4, arg3 = mem.
-		{name: "MOVDstoreidx8", argLength: 4, reg: gpstore2, asm: "MOVD", typ: "Mem"}, // store 8 bytes of arg2 to arg0 + arg1*8, arg3 = mem.
+		{name: "MOVHstoreidx2", argLength: 4, reg: gpstore2, asm: "MOVH", typ: "Mem"},   // store 2 bytes of arg2 to arg0 + arg1*2, arg3 = mem.
+		{name: "MOVWstoreidx4", argLength: 4, reg: gpstore2, asm: "MOVW", typ: "Mem"},   // store 4 bytes of arg2 to arg0 + arg1*4, arg3 = mem.
+		{name: "MOVDstoreidx8", argLength: 4, reg: gpstore2, asm: "MOVD", typ: "Mem"},   // store 8 bytes of arg2 to arg0 + arg1*8, arg3 = mem.
+		{name: "FMOVSstoreidx4", argLength: 4, reg: fpstore2, asm: "FMOVS", typ: "Mem"}, // store 32-bit float of arg2 to arg0 + arg1*4, arg3=mem.
+		{name: "FMOVDstoreidx8", argLength: 4, reg: fpstore2, asm: "FMOVD", typ: "Mem"}, // store 64-bit float of arg2 to arg0 + arg1*8, arg3=mem.
 
 		{name: "MOVBstorezero", argLength: 2, reg: gpstore0, aux: "SymOff", asm: "MOVB", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"}, // store 1 byte of zero to arg0 + auxInt + aux.  arg1=mem.
 		{name: "MOVHstorezero", argLength: 2, reg: gpstore0, aux: "SymOff", asm: "MOVH", typ: "Mem", faultOnNilArg0: true, symEffect: "Write"}, // store 2 bytes of zero to arg0 + auxInt + aux.  arg1=mem.
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index ba170968ae..551aa725b6 100644
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -1481,6 +1481,8 @@ const (
 	OpARM64MOVWloadidx4
 	OpARM64MOVWUloadidx4
 	OpARM64MOVDloadidx8
+	OpARM64FMOVSloadidx4
+	OpARM64FMOVDloadidx8
 	OpARM64MOVBstore
 	OpARM64MOVHstore
 	OpARM64MOVWstore
@@ -1497,6 +1499,8 @@ const (
 	OpARM64MOVHstoreidx2
 	OpARM64MOVWstoreidx4
 	OpARM64MOVDstoreidx8
+	OpARM64FMOVSstoreidx4
+	OpARM64FMOVDstoreidx8
 	OpARM64MOVBstorezero
 	OpARM64MOVHstorezero
 	OpARM64MOVWstorezero
@@ -19787,6 +19791,34 @@ var opcodeTable = [...]opInfo{
 			},
 		},
 	},
+	{
+		name:   "FMOVSloadidx4",
+		argLen: 3,
+		asm:    arm64.AFMOVS,
+		reg: regInfo{
+			inputs: []inputInfo{
+				{1, 805044223},           // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R19 R20 R21 R22 R23 R24 R25 R26 g R30
+				{0, 9223372038733561855}, // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R19 R20 R21 R22 R23 R24 R25 R26 g R30 SP SB
+			},
+			outputs: []outputInfo{
+				{0, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
+			},
+		},
+	},
+	{
+		name:   "FMOVDloadidx8",
+		argLen: 3,
+		asm:    arm64.AFMOVD,
+		reg: regInfo{
+			inputs: []inputInfo{
+				{1, 805044223},           // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R19 R20 R21 R22 R23 R24 R25 R26 g R30
+				{0, 9223372038733561855}, // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R19 R20 R21 R22 R23 R24 R25 R26 g R30 SP SB
+			},
+			outputs: []outputInfo{
+				{0, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
+			},
+		},
+	},
 	{
 		name:           "MOVBstore",
 		auxType:        auxSymOff,
@@ -19994,6 +20026,30 @@ var opcodeTable = [...]opInfo{
 			},
 		},
 	},
+	{
+		name:   "FMOVSstoreidx4",
+		argLen: 4,
+		asm:    arm64.AFMOVS,
+		reg: regInfo{
+			inputs: []inputInfo{
+				{1, 805044223},           // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R19 R20 R21 R22 R23 R24 R25 R26 g R30
+				{0, 9223372038733561855}, // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R19 R20 R21 R22 R23 R24 R25 R26 g R30 SP SB
+				{2, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
+			},
+		},
+	},
+	{
+		name:   "FMOVDstoreidx8",
+		argLen: 4,
+		asm:    arm64.AFMOVD,
+		reg: regInfo{
+			inputs: []inputInfo{
+				{1, 805044223},           // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R19 R20 R21 R22 R23 R24 R25 R26 g R30
+				{0, 9223372038733561855}, // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R19 R20 R21 R22 R23 R24 R25 R26 g R30 SP SB
+				{2, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
+			},
+		},
+	},
 	{
 		name:           "MOVBstorezero",
 		auxType:        auxSymOff,
diff --git a/src/cmd/compile/internal/ssa/rewriteARM64.go b/src/cmd/compile/internal/ssa/rewriteARM64.go
index ba146c7043..ece834f996 100644
--- a/src/cmd/compile/internal/ssa/rewriteARM64.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM64.go
@@ -99,18 +99,26 @@ func rewriteValueARM64(v *Value) bool {
 		return rewriteValueARM64_OpARM64FMOVDload(v)
 	case OpARM64FMOVDloadidx:
 		return rewriteValueARM64_OpARM64FMOVDloadidx(v)
+	case OpARM64FMOVDloadidx8:
+		return rewriteValueARM64_OpARM64FMOVDloadidx8(v)
 	case OpARM64FMOVDstore:
 		return rewriteValueARM64_OpARM64FMOVDstore(v)
 	case OpARM64FMOVDstoreidx:
 		return rewriteValueARM64_OpARM64FMOVDstoreidx(v)
+	case OpARM64FMOVDstoreidx8:
+		return rewriteValueARM64_OpARM64FMOVDstoreidx8(v)
 	case OpARM64FMOVSload:
 		return rewriteValueARM64_OpARM64FMOVSload(v)
 	case OpARM64FMOVSloadidx:
 		return rewriteValueARM64_OpARM64FMOVSloadidx(v)
+	case OpARM64FMOVSloadidx4:
+		return rewriteValueARM64_OpARM64FMOVSloadidx4(v)
 	case OpARM64FMOVSstore:
 		return rewriteValueARM64_OpARM64FMOVSstore(v)
 	case OpARM64FMOVSstoreidx:
 		return rewriteValueARM64_OpARM64FMOVSstoreidx(v)
+	case OpARM64FMOVSstoreidx4:
+		return rewriteValueARM64_OpARM64FMOVSstoreidx4(v)
 	case OpARM64FMULD:
 		return rewriteValueARM64_OpARM64FMULD(v)
 	case OpARM64FMULS:
@@ -3900,6 +3908,25 @@ func rewriteValueARM64_OpARM64FMOVDload(v *Value) bool {
 		v.AddArg3(ptr, idx, mem)
 		return true
 	}
+	// match: (FMOVDload [off] {sym} (ADDshiftLL [3] ptr idx) mem)
+	// cond: off == 0 && sym == nil
+	// result: (FMOVDloadidx8 ptr idx mem)
+	for {
+		off := auxIntToInt32(v.AuxInt)
+		sym := auxToSym(v.Aux)
+		if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 3 {
+			break
+		}
+		idx := v_0.Args[1]
+		ptr := v_0.Args[0]
+		mem := v_1
+		if !(off == 0 && sym == nil) {
+			break
+		}
+		v.reset(OpARM64FMOVDloadidx8)
+		v.AddArg3(ptr, idx, mem)
+		return true
+	}
 	// match: (FMOVDload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
 	// cond: canMergeSym(sym1,sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_shared)
 	// result: (FMOVDload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
@@ -3964,6 +3991,56 @@ func rewriteValueARM64_OpARM64FMOVDloadidx(v *Value) bool {
 		v.AddArg2(ptr, mem)
 		return true
 	}
+	// match: (FMOVDloadidx ptr (SLLconst [3] idx) mem)
+	// result: (FMOVDloadidx8 ptr idx mem)
+	for {
+		ptr := v_0
+		if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 3 {
+			break
+		}
+		idx := v_1.Args[0]
+		mem := v_2
+		v.reset(OpARM64FMOVDloadidx8)
+		v.AddArg3(ptr, idx, mem)
+		return true
+	}
+	// match: (FMOVDloadidx (SLLconst [3] idx) ptr mem)
+	// result: (FMOVDloadidx8 ptr idx mem)
+	for {
+		if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 3 {
+			break
+		}
+		idx := v_0.Args[0]
+		ptr := v_1
+		mem := v_2
+		v.reset(OpARM64FMOVDloadidx8)
+		v.AddArg3(ptr, idx, mem)
+		return true
+	}
+	return false
+}
+func rewriteValueARM64_OpARM64FMOVDloadidx8(v *Value) bool {
+	v_2 := v.Args[2]
+	v_1 := v.Args[1]
+	v_0 := v.Args[0]
+	// match: (FMOVDloadidx8 ptr (MOVDconst [c]) mem)
+	// cond: is32Bit(c<<3)
+	// result: (FMOVDload ptr [int32(c)<<3] mem)
+	for {
+		ptr := v_0
+		if v_1.Op != OpARM64MOVDconst {
+			break
+		}
+		c := auxIntToInt64(v_1.AuxInt)
+		mem := v_2
+		if !(is32Bit(c << 3)) {
+			break
+		}
+		v.reset(OpARM64FMOVDload)
+		v.AuxInt = int32ToAuxInt(int32(c) << 3)
+		v.AddArg2(ptr, mem)
+		return true
+	}
 	return false
 }
 func rewriteValueARM64_OpARM64FMOVDstore(v *Value) bool {
@@ -4031,6 +4108,26 @@ func rewriteValueARM64_OpARM64FMOVDstore(v *Value) bool {
 		v.AddArg4(ptr, idx, val, mem)
 		return true
 	}
+	// match: (FMOVDstore [off] {sym} (ADDshiftLL [3] ptr idx) val mem)
+	// cond: off == 0 && sym == nil
+	// result: (FMOVDstoreidx8 ptr idx val mem)
+	for {
+		off := auxIntToInt32(v.AuxInt)
+		sym := auxToSym(v.Aux)
+		if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 3 {
+			break
+		}
+		idx := v_0.Args[1]
+		ptr := v_0.Args[0]
+		val := v_1
+		mem := v_2
+		if !(off == 0 && sym == nil) {
+			break
+		}
+		v.reset(OpARM64FMOVDstoreidx8)
+		v.AddArg4(ptr, idx, val, mem)
+		return true
+	}
 	// match: (FMOVDstore [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) val mem)
 	// cond: canMergeSym(sym1,sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_shared)
 	// result: (FMOVDstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem)
@@ -4099,6 +4196,60 @@ func rewriteValueARM64_OpARM64FMOVDstoreidx(v *Value) bool {
 		v.AddArg3(idx, val, mem)
 		return true
 	}
+	// match: (FMOVDstoreidx ptr (SLLconst [3] idx) val mem)
+	// result: (FMOVDstoreidx8 ptr idx val mem)
+	for {
+		ptr := v_0
+		if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 3 {
+			break
+		}
+		idx := v_1.Args[0]
+		val := v_2
+		mem := v_3
+		v.reset(OpARM64FMOVDstoreidx8)
+		v.AddArg4(ptr, idx, val, mem)
+		return true
+	}
+	// match: (FMOVDstoreidx (SLLconst [3] idx) ptr val mem)
+	// result: (FMOVDstoreidx8 ptr idx val mem)
+	for {
+		if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 3 {
+			break
+		}
+		idx := v_0.Args[0]
+		ptr := v_1
+		val := v_2
+		mem := v_3
+		v.reset(OpARM64FMOVDstoreidx8)
+		v.AddArg4(ptr, idx, val, mem)
+		return true
+	}
+	return false
+}
+func rewriteValueARM64_OpARM64FMOVDstoreidx8(v *Value) bool {
+	v_3 := v.Args[3]
+	v_2 := v.Args[2]
+	v_1 := v.Args[1]
+	v_0 := v.Args[0]
+	// match: (FMOVDstoreidx8 ptr (MOVDconst [c]) val mem)
+	// cond: is32Bit(c<<3)
+	// result: (FMOVDstore [int32(c)<<3] ptr val mem)
+	for {
+		ptr := v_0
+		if v_1.Op != OpARM64MOVDconst {
+			break
+		}
+		c := auxIntToInt64(v_1.AuxInt)
+		val := v_2
+		mem := v_3
+		if !(is32Bit(c << 3)) {
+			break
+		}
+		v.reset(OpARM64FMOVDstore)
+		v.AuxInt = int32ToAuxInt(int32(c) << 3)
+		v.AddArg3(ptr, val, mem)
+		return true
+	}
 	return false
 }
 func rewriteValueARM64_OpARM64FMOVSload(v *Value) bool {
@@ -4163,6 +4314,25 @@ func rewriteValueARM64_OpARM64FMOVSload(v *Value) bool {
 		v.AddArg3(ptr, idx, mem)
 		return true
 	}
+	// match: (FMOVSload [off] {sym} (ADDshiftLL [2] ptr idx) mem)
+	// cond: off == 0 && sym == nil
+	// result: (FMOVSloadidx4 ptr idx mem)
+	for {
+		off := auxIntToInt32(v.AuxInt)
+		sym := auxToSym(v.Aux)
+		if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 2 {
+			break
+		}
+		idx := v_0.Args[1]
+		ptr := v_0.Args[0]
+		mem := v_1
+		if !(off == 0 && sym == nil) {
+			break
+		}
+		v.reset(OpARM64FMOVSloadidx4)
+		v.AddArg3(ptr, idx, mem)
+		return true
+	}
 	// match: (FMOVSload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
 	// cond: canMergeSym(sym1,sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_shared)
 	// result: (FMOVSload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
@@ -4227,6 +4397,56 @@ func rewriteValueARM64_OpARM64FMOVSloadidx(v *Value) bool {
 		v.AddArg2(ptr, mem)
 		return true
 	}
+	// match: (FMOVSloadidx ptr (SLLconst [2] idx) mem)
+	// result: (FMOVSloadidx4 ptr idx mem)
+	for {
+		ptr := v_0
+		if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 2 {
+			break
+		}
+		idx := v_1.Args[0]
+		mem := v_2
+		v.reset(OpARM64FMOVSloadidx4)
+		v.AddArg3(ptr, idx, mem)
+		return true
+	}
+	// match: (FMOVSloadidx (SLLconst [2] idx) ptr mem)
+	// result: (FMOVSloadidx4 ptr idx mem)
+	for {
+		if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 2 {
+			break
+		}
+		idx := v_0.Args[0]
+		ptr := v_1
+		mem := v_2
+		v.reset(OpARM64FMOVSloadidx4)
+		v.AddArg3(ptr, idx, mem)
+		return true
+	}
+	return false
+}
+func rewriteValueARM64_OpARM64FMOVSloadidx4(v *Value) bool {
+	v_2 := v.Args[2]
+	v_1 := v.Args[1]
+	v_0 := v.Args[0]
+	// match: (FMOVSloadidx4 ptr (MOVDconst [c]) mem)
+	// cond: is32Bit(c<<2)
+	// result: (FMOVSload ptr [int32(c)<<2] mem)
+	for {
+		ptr := v_0
+		if v_1.Op != OpARM64MOVDconst {
+			break
+		}
+		c := auxIntToInt64(v_1.AuxInt)
+		mem := v_2
+		if !(is32Bit(c << 2)) {
+			break
+		}
+		v.reset(OpARM64FMOVSload)
+		v.AuxInt = int32ToAuxInt(int32(c) << 2)
+		v.AddArg2(ptr, mem)
+		return true
+	}
 	return false
 }
 func rewriteValueARM64_OpARM64FMOVSstore(v *Value) bool {
@@ -4294,6 +4514,26 @@ func rewriteValueARM64_OpARM64FMOVSstore(v *Value) bool {
 		v.AddArg4(ptr, idx, val, mem)
 		return true
 	}
+	// match: (FMOVSstore [off] {sym} (ADDshiftLL [2] ptr idx) val mem)
+	// cond: off == 0 && sym == nil
+	// result: (FMOVSstoreidx4 ptr idx val mem)
+	for {
+		off := auxIntToInt32(v.AuxInt)
+		sym := auxToSym(v.Aux)
+		if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 2 {
+			break
+		}
+		idx := v_0.Args[1]
+		ptr := v_0.Args[0]
+		val := v_1
+		mem := v_2
+		if !(off == 0 && sym == nil) {
+			break
+		}
+		v.reset(OpARM64FMOVSstoreidx4)
+		v.AddArg4(ptr, idx, val, mem)
+		return true
+	}
 	// match: (FMOVSstore [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) val mem)
 	// cond: canMergeSym(sym1,sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_shared)
 	// result: (FMOVSstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem)
@@ -4362,6 +4602,60 @@ func rewriteValueARM64_OpARM64FMOVSstoreidx(v *Value) bool {
 		v.AddArg3(idx, val, mem)
 		return true
 	}
+	// match: (FMOVSstoreidx ptr (SLLconst [2] idx) val mem)
+	// result: (FMOVSstoreidx4 ptr idx val mem)
+	for {
+		ptr := v_0
+		if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 2 {
+			break
+		}
+		idx := v_1.Args[0]
+		val := v_2
+		mem := v_3
+		v.reset(OpARM64FMOVSstoreidx4)
+		v.AddArg4(ptr, idx, val, mem)
+		return true
+	}
+	// match: (FMOVSstoreidx (SLLconst [2] idx) ptr val mem)
+	// result: (FMOVSstoreidx4 ptr idx val mem)
+	for {
+		if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 2 {
+			break
+		}
+		idx := v_0.Args[0]
+		ptr := v_1
+		val := v_2
+		mem := v_3
+		v.reset(OpARM64FMOVSstoreidx4)
+		v.AddArg4(ptr, idx, val, mem)
+		return true
+	}
+	return false
+}
+func rewriteValueARM64_OpARM64FMOVSstoreidx4(v *Value) bool {
+	v_3 := v.Args[3]
+	v_2 := v.Args[2]
+	v_1 := v.Args[1]
+	v_0 := v.Args[0]
+	// match: (FMOVSstoreidx4 ptr (MOVDconst [c]) val mem)
+	// cond: is32Bit(c<<2)
+	// result: (FMOVSstore [int32(c)<<2] ptr val mem)
+	for {
+		ptr := v_0
+		if v_1.Op != OpARM64MOVDconst {
+			break
+		}
+		c := auxIntToInt64(v_1.AuxInt)
+		val := v_2
+		mem := v_3
+		if !(is32Bit(c << 2)) {
+			break
+		}
+		v.reset(OpARM64FMOVSstore)
+		v.AuxInt = int32ToAuxInt(int32(c) << 2)
+		v.AddArg3(ptr, val, mem)
+		return true
+	}
 	return false
 }
 func rewriteValueARM64_OpARM64FMULD(v *Value) bool {
diff --git a/test/codegen/floats.go b/test/codegen/floats.go
index 83b4a358a5..397cbb82f7 100644
--- a/test/codegen/floats.go
+++ b/test/codegen/floats.go
@@ -53,12 +53,12 @@ func DivPow2(f1, f2, f3 float64) (float64, float64, float64) {
 }
 
 func indexLoad(b0 []float32, b1 float32, idx int) float32 {
-	// arm64:`FMOVS\s\(R[0-9]+\)\(R[0-9]+\),\sF[0-9]+`
+	// arm64:`FMOVS\s\(R[0-9]+\)\(R[0-9]+<<2\),\sF[0-9]+`
 	return b0[idx] * b1
 }
 
 func indexStore(b0 []float64, b1 float64, idx int) {
-	// arm64:`FMOVD\sF[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`
+	// arm64:`FMOVD\sF[0-9]+,\s\(R[0-9]+\)\(R[0-9]+<<3\)`
 	b0[idx] = b1
 }
 
diff --git a/test/codegen/memops.go b/test/codegen/memops.go
index a234283146..7f06a574fe 100644
--- a/test/codegen/memops.go
+++ b/test/codegen/memops.go
@@ -177,9 +177,11 @@ func idxFloat32(x, y []float32, i int) {
 	var t float32
 	//    amd64: `MOVSS\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
 	// 386/sse2: `MOVSS\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
+	//    arm64: `FMOVS\t\(R[0-9]*\)\(R[0-9]*<<2\), F[0-9]+`
 	t = x[i+1]
 	//    amd64: `MOVSS\tX[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
 	// 386/sse2: `MOVSS\tX[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
+	//    arm64: `FMOVS\tF[0-9]+, \(R[0-9]*\)\(R[0-9]*<<2\)`
 	y[i+1] = t
 	//    amd64: `MOVSS\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), X[0-9]+`
 	// 386/sse2: `MOVSS\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), X[0-9]+`
@@ -193,9 +195,11 @@ func idxFloat64(x, y []float64, i int) {
 	var t float64
 	//    amd64: `MOVSD\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
 	// 386/sse2: `MOVSD\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
+	//    arm64: `FMOVD\t\(R[0-9]*\)\(R[0-9]*<<3\), F[0-9]+`
 	t = x[i+1]
 	//    amd64: `MOVSD\tX[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
 	// 386/sse2: `MOVSD\tX[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
+	//    arm64: `FMOVD\tF[0-9]+, \(R[0-9]*\)\(R[0-9]*<<3\)`
 	y[i+1] = t
 	//    amd64: `MOVSD\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), X[0-9]+`
 	// 386/sse2: `MOVSD\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), X[0-9]+`
-- 
GitLab


From 6c3f8a2f4730f005850be7fde3a3dac6dc5323a6 Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Wed, 24 Feb 2021 11:48:09 -0800
Subject: [PATCH 0831/2400] cmd/link: use ctxt.Logf instead of package log

Fixes #43601

Change-Id: I28b745cb92932d875a66f64c63355650a092f096
Reviewed-on: https://go-review.googlesource.com/c/go/+/296029
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/link/internal/ld/config.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/cmd/link/internal/ld/config.go b/src/cmd/link/internal/ld/config.go
index 481dc67475..291b28e11c 100644
--- a/src/cmd/link/internal/ld/config.go
+++ b/src/cmd/link/internal/ld/config.go
@@ -8,7 +8,6 @@ import (
 	"cmd/internal/objabi"
 	"cmd/internal/sys"
 	"fmt"
-	"log"
 )
 
 // A BuildMode indicates the sort of object we are building.
@@ -181,7 +180,7 @@ func mustLinkExternal(ctxt *Link) (res bool, reason string) {
 	if ctxt.Debugvlog > 1 {
 		defer func() {
 			if res {
-				log.Printf("external linking is forced by: %s\n", reason)
+				ctxt.Logf("external linking is forced by: %s\n", reason)
 			}
 		}()
 	}
-- 
GitLab


From 8027343b6395536aa8bef8158bad8f4c290dd650 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Wed, 24 Feb 2021 13:03:17 -0800
Subject: [PATCH 0832/2400] cmd/compile: disable inlining functions with
 closures for now

Added a flag '-d=inlfuncswithclosures=1' to allow inlining functions with
closures, and change the default to off for now, until #44370 is fixed.

Updates #44370.

Change-Id: Ic17723aa5c091d91f5f5004d8b63ec7125257acf
Reviewed-on: https://go-review.googlesource.com/c/go/+/296049
Run-TryBot: Dan Scales <danscales@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/base/debug.go | 45 +++++++++++++-------------
 src/cmd/compile/internal/inline/inl.go | 12 +++----
 test/closure3.go                       |  2 +-
 test/inline.go                         |  2 +-
 4 files changed, 31 insertions(+), 30 deletions(-)

diff --git a/src/cmd/compile/internal/base/debug.go b/src/cmd/compile/internal/base/debug.go
index 164941bb26..b9fa3d882e 100644
--- a/src/cmd/compile/internal/base/debug.go
+++ b/src/cmd/compile/internal/base/debug.go
@@ -29,28 +29,29 @@ var Debug = DebugFlags{
 // The -d option takes a comma-separated list of settings.
 // Each setting is name=value; for ints, name is short for name=1.
 type DebugFlags struct {
-	Append        int    `help:"print information about append compilation"`
-	Checkptr      int    `help:"instrument unsafe pointer conversions"`
-	Closure       int    `help:"print information about closure compilation"`
-	DclStack      int    `help:"run internal dclstack check"`
-	Defer         int    `help:"print information about defer compilation"`
-	DisableNil    int    `help:"disable nil checks"`
-	DumpPtrs      int    `help:"show Node pointers values in dump output"`
-	DwarfInl      int    `help:"print information about DWARF inlined function creation"`
-	Export        int    `help:"print export data"`
-	Fieldtrack    *int   `help:"enable field tracking"`
-	GCProg        int    `help:"print dump of GC programs"`
-	Libfuzzer     int    `help:"enable coverage instrumentation for libfuzzer"`
-	LocationLists int    `help:"print information about DWARF location list creation"`
-	Nil           int    `help:"print information about nil checks"`
-	PCTab         string `help:"print named pc-value table"`
-	Panic         int    `help:"show all compiler panics"`
-	Slice         int    `help:"print information about slice compilation"`
-	SoftFloat     int    `help:"force compiler to emit soft-float code"`
-	TypeAssert    int    `help:"print information about type assertion inlining"`
-	TypecheckInl  int    `help:"eager typechecking of inline function bodies"`
-	WB            int    `help:"print information about write barriers"`
-	ABIWrap       int    `help:"print information about ABI wrapper generation"`
+	Append               int    `help:"print information about append compilation"`
+	Checkptr             int    `help:"instrument unsafe pointer conversions"`
+	Closure              int    `help:"print information about closure compilation"`
+	DclStack             int    `help:"run internal dclstack check"`
+	Defer                int    `help:"print information about defer compilation"`
+	DisableNil           int    `help:"disable nil checks"`
+	DumpPtrs             int    `help:"show Node pointers values in dump output"`
+	DwarfInl             int    `help:"print information about DWARF inlined function creation"`
+	Export               int    `help:"print export data"`
+	Fieldtrack           *int   `help:"enable field tracking"`
+	GCProg               int    `help:"print dump of GC programs"`
+	InlFuncsWithClosures int    `help:"allow functions with closures to be inlined"`
+	Libfuzzer            int    `help:"enable coverage instrumentation for libfuzzer"`
+	LocationLists        int    `help:"print information about DWARF location list creation"`
+	Nil                  int    `help:"print information about nil checks"`
+	PCTab                string `help:"print named pc-value table"`
+	Panic                int    `help:"show all compiler panics"`
+	Slice                int    `help:"print information about slice compilation"`
+	SoftFloat            int    `help:"force compiler to emit soft-float code"`
+	TypeAssert           int    `help:"print information about type assertion inlining"`
+	TypecheckInl         int    `help:"eager typechecking of inline function bodies"`
+	WB                   int    `help:"print information about write barriers"`
+	ABIWrap              int    `help:"print information about ABI wrapper generation"`
 
 	any bool // set when any of the values have been set
 }
diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 0e57c17667..fe6509e4c9 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -354,15 +354,15 @@ func (v *hairyVisitor) doNode(n ir.Node) bool {
 		return true
 
 	case ir.OCLOSURE:
-		// TODO(danscales,mdempsky): Get working with -G.
-		// Probably after #43818 is fixed.
-		if base.Flag.G > 0 {
-			v.reason = "inlining closures not yet working with -G"
+		if base.Debug.InlFuncsWithClosures == 0 {
+			// TODO(danscales): change default of InlFuncsWithClosures
+			// to 1 when #44370 is fixed
+			v.reason = "not inlining functions with closures"
 			return true
 		}
 
-		// TODO(danscales) - fix some bugs when budget is lowered below 15
-		// Maybe make budget proportional to number of closure variables, e.g.:
+		// TODO(danscales): Maybe make budget proportional to number of closure
+		// variables, e.g.:
 		//v.budget -= int32(len(n.(*ir.ClosureExpr).Func.ClosureVars) * 3)
 		v.budget -= 15
 		// Scan body of closure (which DoChildren doesn't automatically
diff --git a/test/closure3.go b/test/closure3.go
index 37b548d6dc..452a52720a 100644
--- a/test/closure3.go
+++ b/test/closure3.go
@@ -1,4 +1,4 @@
-// errorcheckandrundir -0 -m
+// errorcheckandrundir -0 -m -d=inlfuncswithclosures=1
 
 // Copyright 2017 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/inline.go b/test/inline.go
index a79f5589fb..44c746b282 100644
--- a/test/inline.go
+++ b/test/inline.go
@@ -1,4 +1,4 @@
-// errorcheck -0 -m
+// errorcheck -0 -m -d=inlfuncswithclosures=1
 
 // Copyright 2015 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
-- 
GitLab


From d0d21b7c4c92df8bf60059cbea4c20cfe4ae5fee Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Mon, 1 Feb 2021 13:26:47 -0500
Subject: [PATCH 0833/2400] cmd/compile: plumb abi info into expandCalls

Work in progress.

TODO:
- insert debugging output for all the steps listed below
- emit modified call instructions w/ multiple register inputs
  and Result-typed outputs (next CL)
  - initially just change output from "mem" to "Result{mem}"
  = most places this hits will be future work.
- change OpArg to use registerized variants
  - (done) match abi paramresultinfo with particular arg, use Name
  - (this CL) push register offsets for "loads" and "stores" into
    recursive decomposition.
- hand registerized Result to exit block

For #40724.

Change-Id: Ie5de9d71f8fd4e092f5ee9260b54de35abf91016
Reviewed-on: https://go-review.googlesource.com/c/go/+/293390
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
---
 src/cmd/compile/internal/abi/abiutils.go     |  68 ++--
 src/cmd/compile/internal/ssa/expand_calls.go | 345 ++++++++++++++-----
 src/cmd/compile/internal/ssa/op.go           |  16 +-
 3 files changed, 312 insertions(+), 117 deletions(-)

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index 7b388ec3dc..4bd27efb59 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -30,6 +30,10 @@ type ABIParamResultInfo struct {
 	config            *ABIConfig // to enable String() method
 }
 
+func (a *ABIParamResultInfo) Config() *ABIConfig {
+	return a.config
+}
+
 func (a *ABIParamResultInfo) InParams() []ABIParamAssignment {
 	return a.inparams
 }
@@ -68,10 +72,11 @@ type RegIndex uint8
 // ABIParamAssignment holds information about how a specific param or
 // result will be passed: in registers (in which case 'Registers' is
 // populated) or on the stack (in which case 'Offset' is set to a
-// non-negative stack offset. The values in 'Registers' are indices (as
-// described above), not architected registers.
+// non-negative stack offset. The values in 'Registers' are indices
+// (as described above), not architected registers.
 type ABIParamAssignment struct {
 	Type      *types.Type
+	Name      types.Object // should always be *ir.Name, used to match with a particular ssa.OpArg.
 	Registers []RegIndex
 	offset    int32
 }
@@ -126,37 +131,36 @@ func (a *ABIConfig) Copy() *ABIConfig {
 // NumParamRegs returns the number of parameter registers used for a given type,
 // without regard for the number available.
 func (a *ABIConfig) NumParamRegs(t *types.Type) int {
+	var n int
 	if n, ok := a.regsForTypeCache[t]; ok {
 		return n
 	}
 
 	if t.IsScalar() || t.IsPtrShaped() {
-		var n int
 		if t.IsComplex() {
 			n = 2
 		} else {
 			n = (int(t.Size()) + types.RegSize - 1) / types.RegSize
 		}
-		a.regsForTypeCache[t] = n
-		return n
-	}
-	typ := t.Kind()
-	n := 0
-	switch typ {
-	case types.TARRAY:
-		n = a.NumParamRegs(t.Elem()) * int(t.NumElem())
-	case types.TSTRUCT:
-		for _, f := range t.FieldSlice() {
-			n += a.NumParamRegs(f.Type)
+	} else {
+		typ := t.Kind()
+		switch typ {
+		case types.TARRAY:
+			n = a.NumParamRegs(t.Elem()) * int(t.NumElem())
+		case types.TSTRUCT:
+			for _, f := range t.FieldSlice() {
+				n += a.NumParamRegs(f.Type)
+			}
+		case types.TSLICE:
+			n = a.NumParamRegs(synthSlice)
+		case types.TSTRING:
+			n = a.NumParamRegs(synthString)
+		case types.TINTER:
+			n = a.NumParamRegs(synthIface)
 		}
-	case types.TSLICE:
-		n = a.NumParamRegs(synthSlice)
-	case types.TSTRING:
-		n = a.NumParamRegs(synthString)
-	case types.TINTER:
-		n = a.NumParamRegs(synthIface)
 	}
 	a.regsForTypeCache[t] = n
+
 	return n
 }
 
@@ -176,14 +180,14 @@ func (config *ABIConfig) ABIAnalyze(t *types.Type) *ABIParamResultInfo {
 	if t.NumRecvs() != 0 {
 		rfsl := ft.Receiver.FieldSlice()
 		result.inparams = append(result.inparams,
-			s.assignParamOrReturn(rfsl[0].Type, false))
+			s.assignParamOrReturn(rfsl[0], false))
 	}
 
 	// Inputs
 	ifsl := ft.Params.FieldSlice()
 	for _, f := range ifsl {
 		result.inparams = append(result.inparams,
-			s.assignParamOrReturn(f.Type, false))
+			s.assignParamOrReturn(f, false))
 	}
 	s.stackOffset = types.Rnd(s.stackOffset, int64(types.RegSize))
 
@@ -191,7 +195,7 @@ func (config *ABIConfig) ABIAnalyze(t *types.Type) *ABIParamResultInfo {
 	s.rUsed = RegAmounts{}
 	ofsl := ft.Results.FieldSlice()
 	for _, f := range ofsl {
-		result.outparams = append(result.outparams, s.assignParamOrReturn(f.Type, true))
+		result.outparams = append(result.outparams, s.assignParamOrReturn(f, true))
 	}
 	// The spill area is at a register-aligned offset and its size is rounded up to a register alignment.
 	// TODO in theory could align offset only to minimum required by spilled data types.
@@ -299,7 +303,7 @@ func (state *assignState) allocateRegs() []RegIndex {
 // regAllocate creates a register ABIParamAssignment object for a param
 // or result with the specified type, as a final step (this assumes
 // that all of the safety/suitability analysis is complete).
-func (state *assignState) regAllocate(t *types.Type, isReturn bool) ABIParamAssignment {
+func (state *assignState) regAllocate(t *types.Type, name types.Object, isReturn bool) ABIParamAssignment {
 	spillLoc := int64(-1)
 	if !isReturn {
 		// Spill for register-resident t must be aligned for storage of a t.
@@ -308,6 +312,7 @@ func (state *assignState) regAllocate(t *types.Type, isReturn bool) ABIParamAssi
 	}
 	return ABIParamAssignment{
 		Type:      t,
+		Name:      name,
 		Registers: state.allocateRegs(),
 		offset:    int32(spillLoc),
 	}
@@ -316,9 +321,10 @@ func (state *assignState) regAllocate(t *types.Type, isReturn bool) ABIParamAssi
 // stackAllocate creates a stack memory ABIParamAssignment object for
 // a param or result with the specified type, as a final step (this
 // assumes that all of the safety/suitability analysis is complete).
-func (state *assignState) stackAllocate(t *types.Type) ABIParamAssignment {
+func (state *assignState) stackAllocate(t *types.Type, name types.Object) ABIParamAssignment {
 	return ABIParamAssignment{
 		Type:   t,
+		Name:   name,
 		offset: int32(state.stackSlot(t)),
 	}
 }
@@ -451,18 +457,20 @@ func (state *assignState) regassign(pt *types.Type) bool {
 }
 
 // assignParamOrReturn processes a given receiver, param, or result
-// of type 'pt' to determine whether it can be register assigned.
+// of field f to determine whether it can be register assigned.
 // The result of the analysis is recorded in the result
 // ABIParamResultInfo held in 'state'.
-func (state *assignState) assignParamOrReturn(pt *types.Type, isReturn bool) ABIParamAssignment {
+func (state *assignState) assignParamOrReturn(f *types.Field, isReturn bool) ABIParamAssignment {
+	// TODO(register args) ? seems like "struct" and "fields" is not right anymore for describing function parameters
+	pt := f.Type
 	state.pUsed = RegAmounts{}
 	if pt.Width == types.BADWIDTH {
 		panic("should never happen")
 	} else if pt.Width == 0 {
-		return state.stackAllocate(pt)
+		return state.stackAllocate(pt, f.Nname)
 	} else if state.regassign(pt) {
-		return state.regAllocate(pt, isReturn)
+		return state.regAllocate(pt, f.Nname, isReturn)
 	} else {
-		return state.stackAllocate(pt)
+		return state.stackAllocate(pt, f.Nname)
 	}
 }
diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index 579818e4f3..85d6fda427 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -5,6 +5,8 @@
 package ssa
 
 import (
+	"cmd/compile/internal/abi"
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"fmt"
@@ -24,6 +26,8 @@ type offsetKey struct {
 	pt     *types.Type
 }
 
+type Abi1RO uint8 // An offset within a parameter's slice of register indices, for abi1.
+
 func isBlockMultiValueExit(b *Block) bool {
 	return (b.Kind == BlockRet || b.Kind == BlockRetJmp) && len(b.Controls) > 0 && b.Controls[0].Op == OpMakeResult
 }
@@ -51,8 +55,107 @@ func removeTrivialWrapperTypes(t *types.Type) *types.Type {
 	return t
 }
 
+// A registerCursor tracks which register is used for an Arg or regValues, or a piece of such.
+type registerCursor struct {
+	// TODO(register args) convert this to a generalized target cursor.
+	regsLen   int    // the number of registers available for this Arg/result (which is all in registers or not at all)
+	nextSlice Abi1RO // the next register/register-slice offset
+	config    *abi.ABIConfig
+	regValues *[]*Value // values assigned to registers accumulate here
+}
+
+// next effectively post-increments the register cursor; the receiver is advanced,
+// the old value is returned.
+func (c *registerCursor) next(t *types.Type) registerCursor {
+	rc := *c
+	if int(c.nextSlice) < c.regsLen {
+		w := c.config.NumParamRegs(t)
+		c.nextSlice += Abi1RO(w)
+	}
+	return rc
+}
+
+// plus returns a register cursor offset from the original, without modifying the original.
+func (c *registerCursor) plus(regWidth Abi1RO) registerCursor {
+	rc := *c
+	rc.nextSlice += regWidth
+	return rc
+}
+
+const (
+	// Register offsets for fields of built-in aggregate types; the ones not listed are zero.
+	RO_complex_imag = 1
+	RO_string_len   = 1
+	RO_slice_len    = 1
+	RO_slice_cap    = 2
+	RO_iface_data   = 1
+)
+
+func (x *expandState) regWidth(t *types.Type) Abi1RO {
+	return Abi1RO(x.abi1.NumParamRegs(t))
+}
+
+// regOffset returns the register offset of the i'th element of type t
+func (x *expandState) regOffset(t *types.Type, i int) Abi1RO {
+	// TODO maybe cache this in a map if profiling recommends.
+	if i == 0 {
+		return 0
+	}
+	if t.IsArray() {
+		return Abi1RO(i) * x.regWidth(t.Elem())
+	}
+	if t.IsStruct() {
+		k := Abi1RO(0)
+		for j := 0; j < i; j++ {
+			k += x.regWidth(t.FieldType(j))
+		}
+		return k
+	}
+	panic("Haven't implemented this case yet, do I need to?")
+}
+
+// at returns the register cursor for component i of t, where the first
+// component is numbered 0.
+func (c *registerCursor) at(t *types.Type, i int) registerCursor {
+	rc := *c
+	if i == 0 || c.regsLen == 0 {
+		return rc
+	}
+	if t.IsArray() {
+		w := c.config.NumParamRegs(t.Elem())
+		rc.nextSlice += Abi1RO(i * w)
+		return rc
+	}
+	if t.IsStruct() {
+		for j := 0; j < i; j++ {
+			rc.next(t.FieldType(j))
+		}
+		return rc
+	}
+	panic("Haven't implemented this case yet, do I need to?")
+}
+
+func (c *registerCursor) init(regs []abi.RegIndex, info *abi.ABIParamResultInfo, result *[]*Value) {
+	c.regsLen = len(regs)
+	c.nextSlice = 0
+	if len(regs) == 0 {
+		return
+	}
+	c.config = info.Config()
+	c.regValues = result
+}
+
+func (c *registerCursor) addArg(v *Value) {
+	*c.regValues = append(*c.regValues, v)
+}
+
+func (c *registerCursor) hasRegs() bool {
+	return c.regsLen > 0
+}
+
 type expandState struct {
 	f            *Func
+	abi1         *abi.ABIConfig
 	debug        bool
 	canSSAType   func(*types.Type) bool
 	regSize      int64
@@ -61,6 +164,8 @@ type expandState struct {
 	ptrSize      int64
 	hiOffset     int64
 	lowOffset    int64
+	hiRo         Abi1RO
+	loRo         Abi1RO
 	namedSelects map[*Value][]namedVal
 	sdom         SparseTree
 	common       map[selKey]*Value
@@ -123,6 +228,18 @@ func (x *expandState) splitSlots(ls []LocalSlot, sfx string, offset int64, ty *t
 	return locs
 }
 
+// prAssignForArg returns the ABIParamAssignment for v, assumed to be an OpArg.
+func (x *expandState) prAssignForArg(v *Value) abi.ABIParamAssignment {
+	name := v.Aux.(*ir.Name)
+	fPri := x.f.OwnAux.abiInfo
+	for _, a := range fPri.InParams() {
+		if a.Name == name {
+			return a
+		}
+	}
+	panic(fmt.Errorf("Did not match param %v in prInfo %+v", name, fPri.InParams()))
+}
+
 // Calls that need lowering have some number of inputs, including a memory input,
 // and produce a tuple of (value1, value2, ..., mem) where valueK may or may not be SSA-able.
 
@@ -140,7 +257,7 @@ func (x *expandState) splitSlots(ls []LocalSlot, sfx string, offset int64, ty *t
 // It emits the code necessary to implement the leaf select operation that leads to the root.
 //
 // TODO when registers really arrive, must also decompose anything split across two registers or registers and memory.
-func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64) []LocalSlot {
+func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64, regOffset Abi1RO) []LocalSlot {
 	if x.debug {
 		fmt.Printf("rewriteSelect(%s, %s, %d)\n", leaf.LongString(), selector.LongString(), offset)
 	}
@@ -157,9 +274,13 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64)
 	}
 	switch selector.Op {
 	case OpArg:
+		paramAssignment := x.prAssignForArg(selector)
+		_ = paramAssignment
+		// TODO(register args)
 		if !x.isAlreadyExpandedAggregateType(selector.Type) {
 			if leafType == selector.Type { // OpIData leads us here, sometimes.
 				leaf.copyOf(selector)
+
 			} else {
 				x.f.Fatalf("Unexpected OpArg type, selector=%s, leaf=%s\n", selector.LongString(), leaf.LongString())
 			}
@@ -228,6 +349,8 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64)
 		}
 
 	case OpSelectN:
+		// TODO(register args) result case
+		// if applied to Op-mumble-call, the Aux tells us which result, regOffset specifies offset within result.  If a register, should rewrite to OpSelectN for new call.
 		// TODO these may be duplicated. Should memoize. Intermediate selectors will go dead, no worries there.
 		call := selector.Args[0]
 		aux := call.Aux.(*AuxCall)
@@ -264,9 +387,10 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64)
 		w := selector.Args[0]
 		var ls []LocalSlot
 		if w.Type.Kind() != types.TSTRUCT { // IData artifact
-			ls = x.rewriteSelect(leaf, w, offset)
+			ls = x.rewriteSelect(leaf, w, offset, regOffset)
 		} else {
-			ls = x.rewriteSelect(leaf, w, offset+w.Type.FieldOff(int(selector.AuxInt)))
+			fldi := int(selector.AuxInt)
+			ls = x.rewriteSelect(leaf, w, offset+w.Type.FieldOff(fldi), regOffset+x.regOffset(w.Type, fldi))
 			if w.Op != OpIData {
 				for _, l := range ls {
 					locs = append(locs, x.f.fe.SplitStruct(l, int(selector.AuxInt)))
@@ -276,30 +400,31 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64)
 
 	case OpArraySelect:
 		w := selector.Args[0]
-		x.rewriteSelect(leaf, w, offset+selector.Type.Size()*selector.AuxInt)
+		index := selector.AuxInt
+		x.rewriteSelect(leaf, w, offset+selector.Type.Size()*index, regOffset+x.regOffset(w.Type, int(index)))
 
 	case OpInt64Hi:
 		w := selector.Args[0]
-		ls := x.rewriteSelect(leaf, w, offset+x.hiOffset)
+		ls := x.rewriteSelect(leaf, w, offset+x.hiOffset, regOffset+x.hiRo)
 		locs = x.splitSlots(ls, ".hi", x.hiOffset, leafType)
 
 	case OpInt64Lo:
 		w := selector.Args[0]
-		ls := x.rewriteSelect(leaf, w, offset+x.lowOffset)
+		ls := x.rewriteSelect(leaf, w, offset+x.lowOffset, regOffset+x.loRo)
 		locs = x.splitSlots(ls, ".lo", x.lowOffset, leafType)
 
 	case OpStringPtr:
-		ls := x.rewriteSelect(leaf, selector.Args[0], offset)
+		ls := x.rewriteSelect(leaf, selector.Args[0], offset, regOffset)
 		locs = x.splitSlots(ls, ".ptr", 0, x.typs.BytePtr)
 
 	case OpSlicePtr:
 		w := selector.Args[0]
-		ls := x.rewriteSelect(leaf, w, offset)
+		ls := x.rewriteSelect(leaf, w, offset, regOffset)
 		locs = x.splitSlots(ls, ".ptr", 0, types.NewPtr(w.Type.Elem()))
 
 	case OpITab:
 		w := selector.Args[0]
-		ls := x.rewriteSelect(leaf, w, offset)
+		ls := x.rewriteSelect(leaf, w, offset, regOffset)
 		sfx := ".itab"
 		if w.Type.IsEmptyInterface() {
 			sfx = ".type"
@@ -307,27 +432,27 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64)
 		locs = x.splitSlots(ls, sfx, 0, x.typs.Uintptr)
 
 	case OpComplexReal:
-		ls := x.rewriteSelect(leaf, selector.Args[0], offset)
+		ls := x.rewriteSelect(leaf, selector.Args[0], offset, regOffset)
 		locs = x.splitSlots(ls, ".real", 0, leafType)
 
 	case OpComplexImag:
-		ls := x.rewriteSelect(leaf, selector.Args[0], offset+leafType.Width) // result is FloatNN, width of result is offset of imaginary part.
+		ls := x.rewriteSelect(leaf, selector.Args[0], offset+leafType.Width, regOffset+RO_complex_imag) // result is FloatNN, width of result is offset of imaginary part.
 		locs = x.splitSlots(ls, ".imag", leafType.Width, leafType)
 
 	case OpStringLen, OpSliceLen:
-		ls := x.rewriteSelect(leaf, selector.Args[0], offset+x.ptrSize)
+		ls := x.rewriteSelect(leaf, selector.Args[0], offset+x.ptrSize, regOffset+RO_slice_len)
 		locs = x.splitSlots(ls, ".len", x.ptrSize, leafType)
 
 	case OpIData:
-		ls := x.rewriteSelect(leaf, selector.Args[0], offset+x.ptrSize)
+		ls := x.rewriteSelect(leaf, selector.Args[0], offset+x.ptrSize, regOffset+RO_iface_data)
 		locs = x.splitSlots(ls, ".data", x.ptrSize, leafType)
 
 	case OpSliceCap:
-		ls := x.rewriteSelect(leaf, selector.Args[0], offset+2*x.ptrSize)
+		ls := x.rewriteSelect(leaf, selector.Args[0], offset+2*x.ptrSize, regOffset+RO_slice_cap)
 		locs = x.splitSlots(ls, ".cap", 2*x.ptrSize, leafType)
 
 	case OpCopy: // If it's an intermediate result, recurse
-		locs = x.rewriteSelect(leaf, selector.Args[0], offset)
+		locs = x.rewriteSelect(leaf, selector.Args[0], offset, regOffset)
 		for _, s := range x.namedSelects[selector] {
 			// this copy may have had its own name, preserve that, too.
 			locs = append(locs, x.f.Names[s.locIndex])
@@ -361,23 +486,26 @@ func (x *expandState) rewriteDereference(b *Block, base, a, mem *Value, offset,
 // decomposeArgOrLoad is a helper for storeArgOrLoad.
 // It decomposes a Load or an Arg into smaller parts, parameterized by the decomposeOne and decomposeTwo functions
 // passed to it, and returns the new mem. If the type does not match one of the expected aggregate types, it returns nil instead.
-func (x *expandState) decomposeArgOrLoad(pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offset int64,
-	decomposeOne func(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t1 *types.Type, offArg, offStore int64) *Value,
-	decomposeTwo func(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64) *Value) *Value {
+func (x *expandState) decomposeArgOrLoad(pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offset int64, loadRegOffset Abi1RO, storeRc registerCursor,
+	decomposeOne func(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t1 *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value,
+	decomposeTwo func(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value) *Value {
 	u := source.Type
 	switch u.Kind() {
 	case types.TARRAY:
 		elem := u.Elem()
+		elemRO := x.regWidth(elem)
 		for i := int64(0); i < u.NumElem(); i++ {
 			elemOff := i * elem.Size()
-			mem = decomposeOne(x, pos, b, base, source, mem, elem, source.AuxInt+elemOff, offset+elemOff)
+			mem = decomposeOne(x, pos, b, base, source, mem, elem, source.AuxInt+elemOff, offset+elemOff, loadRegOffset, storeRc.next(elem))
+			loadRegOffset += elemRO
 			pos = pos.WithNotStmt()
 		}
 		return mem
 	case types.TSTRUCT:
 		for i := 0; i < u.NumFields(); i++ {
 			fld := u.Field(i)
-			mem = decomposeOne(x, pos, b, base, source, mem, fld.Type, source.AuxInt+fld.Offset, offset+fld.Offset)
+			mem = decomposeOne(x, pos, b, base, source, mem, fld.Type, source.AuxInt+fld.Offset, offset+fld.Offset, loadRegOffset, storeRc.next(fld.Type))
+			loadRegOffset += x.regWidth(fld.Type)
 			pos = pos.WithNotStmt()
 		}
 		return mem
@@ -386,20 +514,20 @@ func (x *expandState) decomposeArgOrLoad(pos src.XPos, b *Block, base, source, m
 			break
 		}
 		tHi, tLo := x.intPairTypes(t.Kind())
-		mem = decomposeOne(x, pos, b, base, source, mem, tHi, source.AuxInt+x.hiOffset, offset+x.hiOffset)
+		mem = decomposeOne(x, pos, b, base, source, mem, tHi, source.AuxInt+x.hiOffset, offset+x.hiOffset, loadRegOffset+x.hiRo, storeRc.plus(x.hiRo))
 		pos = pos.WithNotStmt()
-		return decomposeOne(x, pos, b, base, source, mem, tLo, source.AuxInt+x.lowOffset, offset+x.lowOffset)
+		return decomposeOne(x, pos, b, base, source, mem, tLo, source.AuxInt+x.lowOffset, offset+x.lowOffset, loadRegOffset+x.loRo, storeRc.plus(x.loRo))
 	case types.TINTER:
-		return decomposeTwo(x, pos, b, base, source, mem, x.typs.Uintptr, x.typs.BytePtr, source.AuxInt, offset)
+		return decomposeTwo(x, pos, b, base, source, mem, x.typs.Uintptr, x.typs.BytePtr, source.AuxInt, offset, loadRegOffset, storeRc)
 	case types.TSTRING:
-		return decomposeTwo(x, pos, b, base, source, mem, x.typs.BytePtr, x.typs.Int, source.AuxInt, offset)
+		return decomposeTwo(x, pos, b, base, source, mem, x.typs.BytePtr, x.typs.Int, source.AuxInt, offset, loadRegOffset, storeRc)
 	case types.TCOMPLEX64:
-		return decomposeTwo(x, pos, b, base, source, mem, x.typs.Float32, x.typs.Float32, source.AuxInt, offset)
+		return decomposeTwo(x, pos, b, base, source, mem, x.typs.Float32, x.typs.Float32, source.AuxInt, offset, loadRegOffset, storeRc)
 	case types.TCOMPLEX128:
-		return decomposeTwo(x, pos, b, base, source, mem, x.typs.Float64, x.typs.Float64, source.AuxInt, offset)
+		return decomposeTwo(x, pos, b, base, source, mem, x.typs.Float64, x.typs.Float64, source.AuxInt, offset, loadRegOffset, storeRc)
 	case types.TSLICE:
-		mem = decomposeTwo(x, pos, b, base, source, mem, x.typs.BytePtr, x.typs.Int, source.AuxInt, offset)
-		return decomposeOne(x, pos, b, base, source, mem, x.typs.Int, source.AuxInt+2*x.ptrSize, offset+2*x.ptrSize)
+		mem = decomposeOne(x, pos, b, base, source, mem, x.typs.BytePtr, source.AuxInt, offset, loadRegOffset, storeRc.next(x.typs.BytePtr))
+		return decomposeTwo(x, pos, b, base, source, mem, x.typs.Int, x.typs.Int, source.AuxInt+x.ptrSize, offset+x.ptrSize, loadRegOffset+RO_slice_len, storeRc)
 	}
 	return nil
 }
@@ -407,79 +535,85 @@ func (x *expandState) decomposeArgOrLoad(pos src.XPos, b *Block, base, source, m
 // storeOneArg creates a decomposed (one step) arg that is then stored.
 // pos and b locate the store instruction, base is the base of the store target, source is the "base" of the value input,
 // mem is the input mem, t is the type in question, and offArg and offStore are the offsets from the respective bases.
-func storeOneArg(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offArg, offStore int64) *Value {
+func storeOneArg(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
+	paramAssignment := x.prAssignForArg(source)
+	_ = paramAssignment
+	// TODO(register args)
 	w := x.common[selKey{source, offArg, t.Width, t}]
 	if w == nil {
 		w = source.Block.NewValue0IA(source.Pos, OpArg, t, offArg, source.Aux)
 		x.common[selKey{source, offArg, t.Width, t}] = w
 	}
-	return x.storeArgOrLoad(pos, b, base, w, mem, t, offStore)
+	return x.storeArgOrLoad(pos, b, base, w, mem, t, offStore, loadRegOffset, storeRc)
 }
 
 // storeOneLoad creates a decomposed (one step) load that is then stored.
-func storeOneLoad(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offArg, offStore int64) *Value {
+func storeOneLoad(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
 	from := x.offsetFrom(source.Args[0], offArg, types.NewPtr(t))
 	w := source.Block.NewValue2(source.Pos, OpLoad, t, from, mem)
-	return x.storeArgOrLoad(pos, b, base, w, mem, t, offStore)
+	return x.storeArgOrLoad(pos, b, base, w, mem, t, offStore, loadRegOffset, storeRc)
 }
 
-func storeTwoArg(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64) *Value {
-	mem = storeOneArg(x, pos, b, base, source, mem, t1, offArg, offStore)
+func storeTwoArg(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
+	mem = storeOneArg(x, pos, b, base, source, mem, t1, offArg, offStore, loadRegOffset, storeRc.next(t1))
 	pos = pos.WithNotStmt()
 	t1Size := t1.Size()
-	return storeOneArg(x, pos, b, base, source, mem, t2, offArg+t1Size, offStore+t1Size)
+	return storeOneArg(x, pos, b, base, source, mem, t2, offArg+t1Size, offStore+t1Size, loadRegOffset+1, storeRc)
 }
 
-func storeTwoLoad(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64) *Value {
-	mem = storeOneLoad(x, pos, b, base, source, mem, t1, offArg, offStore)
+// storeTwoLoad creates a pair of decomposed (one step) loads that are then stored.
+// the elements of the pair must not require any additional alignment.
+func storeTwoLoad(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
+	mem = storeOneLoad(x, pos, b, base, source, mem, t1, offArg, offStore, loadRegOffset, storeRc.next(t1))
 	pos = pos.WithNotStmt()
 	t1Size := t1.Size()
-	return storeOneLoad(x, pos, b, base, source, mem, t2, offArg+t1Size, offStore+t1Size)
+	return storeOneLoad(x, pos, b, base, source, mem, t2, offArg+t1Size, offStore+t1Size, loadRegOffset+1, storeRc)
 }
 
-// storeArgOrLoad converts stores of SSA-able aggregate arguments (passed to a call) into a series of primitive-typed
+// storeArgOrLoad converts stores of SSA-able potentially aggregatable arguments (passed to a call) into a series of primitive-typed
 // stores of non-aggregate types.  It recursively walks up a chain of selectors until it reaches a Load or an Arg.
 // If it does not reach a Load or an Arg, nothing happens; this allows a little freedom in phase ordering.
-func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offset int64) *Value {
+func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offset int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
 	if x.debug {
 		fmt.Printf("\tstoreArgOrLoad(%s;  %s;  %s;  %s; %d)\n", base.LongString(), source.LongString(), mem.String(), t.String(), offset)
 	}
 
 	switch source.Op {
 	case OpCopy:
-		return x.storeArgOrLoad(pos, b, base, source.Args[0], mem, t, offset)
+		return x.storeArgOrLoad(pos, b, base, source.Args[0], mem, t, offset, loadRegOffset, storeRc)
 
 	case OpLoad:
-		ret := x.decomposeArgOrLoad(pos, b, base, source, mem, t, offset, storeOneLoad, storeTwoLoad)
+		ret := x.decomposeArgOrLoad(pos, b, base, source, mem, t, offset, loadRegOffset, storeRc, storeOneLoad, storeTwoLoad)
 		if ret != nil {
 			return ret
 		}
 
 	case OpArg:
-		ret := x.decomposeArgOrLoad(pos, b, base, source, mem, t, offset, storeOneArg, storeTwoArg)
+		ret := x.decomposeArgOrLoad(pos, b, base, source, mem, t, offset, loadRegOffset, storeRc, storeOneArg, storeTwoArg)
 		if ret != nil {
 			return ret
 		}
 
 	case OpArrayMake0, OpStructMake0:
+		// TODO(register args) is this correct for registers?
 		return mem
 
 	case OpStructMake1, OpStructMake2, OpStructMake3, OpStructMake4:
 		for i := 0; i < t.NumFields(); i++ {
 			fld := t.Field(i)
-			mem = x.storeArgOrLoad(pos, b, base, source.Args[i], mem, fld.Type, offset+fld.Offset)
+			mem = x.storeArgOrLoad(pos, b, base, source.Args[i], mem, fld.Type, offset+fld.Offset, 0, storeRc.next(fld.Type))
 			pos = pos.WithNotStmt()
 		}
 		return mem
 
 	case OpArrayMake1:
-		return x.storeArgOrLoad(pos, b, base, source.Args[0], mem, t.Elem(), offset)
+		return x.storeArgOrLoad(pos, b, base, source.Args[0], mem, t.Elem(), offset, 0, storeRc.at(t, 0))
 
 	case OpInt64Make:
 		tHi, tLo := x.intPairTypes(t.Kind())
-		mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, tHi, offset+x.hiOffset)
+		mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, tHi, offset+x.hiOffset, 0, storeRc.next(tHi))
 		pos = pos.WithNotStmt()
-		return x.storeArgOrLoad(pos, b, base, source.Args[1], mem, tLo, offset+x.lowOffset)
+		return x.storeArgOrLoad(pos, b, base, source.Args[1], mem, tLo, offset+x.lowOffset, 0, storeRc)
 
 	case OpComplexMake:
 		tPart := x.typs.Float32
@@ -487,25 +621,25 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, base, source, mem *
 		if wPart == 8 {
 			tPart = x.typs.Float64
 		}
-		mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, tPart, offset)
+		mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, tPart, offset, 0, storeRc.next(tPart))
 		pos = pos.WithNotStmt()
-		return x.storeArgOrLoad(pos, b, base, source.Args[1], mem, tPart, offset+wPart)
+		return x.storeArgOrLoad(pos, b, base, source.Args[1], mem, tPart, offset+wPart, 0, storeRc)
 
 	case OpIMake:
-		mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, x.typs.Uintptr, offset)
+		mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, x.typs.Uintptr, offset, 0, storeRc.next(x.typs.Uintptr))
 		pos = pos.WithNotStmt()
-		return x.storeArgOrLoad(pos, b, base, source.Args[1], mem, x.typs.BytePtr, offset+x.ptrSize)
+		return x.storeArgOrLoad(pos, b, base, source.Args[1], mem, x.typs.BytePtr, offset+x.ptrSize, 0, storeRc)
 
 	case OpStringMake:
-		mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, x.typs.BytePtr, offset)
+		mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, x.typs.BytePtr, offset, 0, storeRc.next(x.typs.BytePtr))
 		pos = pos.WithNotStmt()
-		return x.storeArgOrLoad(pos, b, base, source.Args[1], mem, x.typs.Int, offset+x.ptrSize)
+		return x.storeArgOrLoad(pos, b, base, source.Args[1], mem, x.typs.Int, offset+x.ptrSize, 0, storeRc)
 
 	case OpSliceMake:
-		mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, x.typs.BytePtr, offset)
+		mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, x.typs.BytePtr, offset, 0, storeRc.next(x.typs.BytePtr))
 		pos = pos.WithNotStmt()
-		mem = x.storeArgOrLoad(pos, b, base, source.Args[1], mem, x.typs.Int, offset+x.ptrSize)
-		return x.storeArgOrLoad(pos, b, base, source.Args[2], mem, x.typs.Int, offset+2*x.ptrSize)
+		mem = x.storeArgOrLoad(pos, b, base, source.Args[1], mem, x.typs.Int, offset+x.ptrSize, 0, storeRc.next(x.typs.Int))
+		return x.storeArgOrLoad(pos, b, base, source.Args[2], mem, x.typs.Int, offset+2*x.ptrSize, 0, storeRc)
 	}
 
 	// For nodes that cannot be taken apart -- OpSelectN, other structure selectors.
@@ -515,11 +649,13 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, base, source, mem *
 		if source.Type != t && t.NumElem() == 1 && elt.Width == t.Width && t.Width == x.regSize {
 			t = removeTrivialWrapperTypes(t)
 			// it could be a leaf type, but the "leaf" could be complex64 (for example)
-			return x.storeArgOrLoad(pos, b, base, source, mem, t, offset)
+			return x.storeArgOrLoad(pos, b, base, source, mem, t, offset, loadRegOffset, storeRc)
 		}
+		eltRO := x.regWidth(elt)
 		for i := int64(0); i < t.NumElem(); i++ {
 			sel := source.Block.NewValue1I(pos, OpArraySelect, elt, i, source)
-			mem = x.storeArgOrLoad(pos, b, base, sel, mem, elt, offset+i*elt.Width)
+			mem = x.storeArgOrLoad(pos, b, base, sel, mem, elt, offset+i*elt.Width, loadRegOffset, storeRc.at(t, 0))
+			loadRegOffset += eltRO
 			pos = pos.WithNotStmt()
 		}
 		return mem
@@ -546,13 +682,14 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, base, source, mem *
 			// of a *uint8, which does not succeed.
 			t = removeTrivialWrapperTypes(t)
 			// it could be a leaf type, but the "leaf" could be complex64 (for example)
-			return x.storeArgOrLoad(pos, b, base, source, mem, t, offset)
+			return x.storeArgOrLoad(pos, b, base, source, mem, t, offset, loadRegOffset, storeRc)
 		}
 
 		for i := 0; i < t.NumFields(); i++ {
 			fld := t.Field(i)
 			sel := source.Block.NewValue1I(pos, OpStructSelect, fld.Type, int64(i), source)
-			mem = x.storeArgOrLoad(pos, b, base, sel, mem, fld.Type, offset+fld.Offset)
+			mem = x.storeArgOrLoad(pos, b, base, sel, mem, fld.Type, offset+fld.Offset, loadRegOffset, storeRc.next(fld.Type))
+			loadRegOffset += x.regWidth(fld.Type)
 			pos = pos.WithNotStmt()
 		}
 		return mem
@@ -563,52 +700,58 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, base, source, mem *
 		}
 		tHi, tLo := x.intPairTypes(t.Kind())
 		sel := source.Block.NewValue1(pos, OpInt64Hi, tHi, source)
-		mem = x.storeArgOrLoad(pos, b, base, sel, mem, tHi, offset+x.hiOffset)
+		mem = x.storeArgOrLoad(pos, b, base, sel, mem, tHi, offset+x.hiOffset, loadRegOffset+x.hiRo, storeRc.plus(x.hiRo))
 		pos = pos.WithNotStmt()
 		sel = source.Block.NewValue1(pos, OpInt64Lo, tLo, source)
-		return x.storeArgOrLoad(pos, b, base, sel, mem, tLo, offset+x.lowOffset)
+		return x.storeArgOrLoad(pos, b, base, sel, mem, tLo, offset+x.lowOffset, loadRegOffset+x.loRo, storeRc.plus(x.hiRo))
 
 	case types.TINTER:
 		sel := source.Block.NewValue1(pos, OpITab, x.typs.BytePtr, source)
-		mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.BytePtr, offset)
+		mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.BytePtr, offset, loadRegOffset, storeRc.next(x.typs.BytePtr))
 		pos = pos.WithNotStmt()
 		sel = source.Block.NewValue1(pos, OpIData, x.typs.BytePtr, source)
-		return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.BytePtr, offset+x.ptrSize)
+		return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.BytePtr, offset+x.ptrSize, loadRegOffset+RO_iface_data, storeRc)
 
 	case types.TSTRING:
 		sel := source.Block.NewValue1(pos, OpStringPtr, x.typs.BytePtr, source)
-		mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.BytePtr, offset)
+		mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.BytePtr, offset, loadRegOffset, storeRc.next(x.typs.BytePtr))
 		pos = pos.WithNotStmt()
 		sel = source.Block.NewValue1(pos, OpStringLen, x.typs.Int, source)
-		return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Int, offset+x.ptrSize)
+		return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Int, offset+x.ptrSize, loadRegOffset+RO_string_len, storeRc)
 
 	case types.TSLICE:
 		et := types.NewPtr(t.Elem())
 		sel := source.Block.NewValue1(pos, OpSlicePtr, et, source)
-		mem = x.storeArgOrLoad(pos, b, base, sel, mem, et, offset)
+		mem = x.storeArgOrLoad(pos, b, base, sel, mem, et, offset, loadRegOffset, storeRc.next(et))
 		pos = pos.WithNotStmt()
 		sel = source.Block.NewValue1(pos, OpSliceLen, x.typs.Int, source)
-		mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Int, offset+x.ptrSize)
+		mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Int, offset+x.ptrSize, loadRegOffset+RO_slice_len, storeRc.next(x.typs.Int))
 		sel = source.Block.NewValue1(pos, OpSliceCap, x.typs.Int, source)
-		return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Int, offset+2*x.ptrSize)
+		return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Int, offset+2*x.ptrSize, loadRegOffset+RO_slice_cap, storeRc)
 
 	case types.TCOMPLEX64:
 		sel := source.Block.NewValue1(pos, OpComplexReal, x.typs.Float32, source)
-		mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Float32, offset)
+		mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Float32, offset, loadRegOffset, storeRc.next(x.typs.Float32))
 		pos = pos.WithNotStmt()
 		sel = source.Block.NewValue1(pos, OpComplexImag, x.typs.Float32, source)
-		return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Float32, offset+4)
+		return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Float32, offset+4, loadRegOffset+RO_complex_imag, storeRc)
 
 	case types.TCOMPLEX128:
 		sel := source.Block.NewValue1(pos, OpComplexReal, x.typs.Float64, source)
-		mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Float64, offset)
+		mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Float64, offset, loadRegOffset, storeRc.next(x.typs.Float64))
 		pos = pos.WithNotStmt()
 		sel = source.Block.NewValue1(pos, OpComplexImag, x.typs.Float64, source)
-		return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Float64, offset+8)
+		return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Float64, offset+8, loadRegOffset+RO_complex_imag, storeRc)
 	}
 
-	dst := x.offsetFrom(base, offset, types.NewPtr(t))
-	s := b.NewValue3A(pos, OpStore, types.TypeMem, t, dst, source, mem)
+	s := mem
+	if storeRc.hasRegs() {
+		// TODO(register args)
+		storeRc.addArg(source)
+	} else {
+		dst := x.offsetFrom(base, offset, types.NewPtr(t))
+		s = b.NewValue3A(pos, OpStore, types.TypeMem, t, dst, source, mem)
+	}
 	if x.debug {
 		fmt.Printf("\t\tstoreArg returns %s\n", s.LongString())
 	}
@@ -624,6 +767,7 @@ func (x *expandState) rewriteArgs(v *Value, firstArg int) *Value {
 	pos := v.Pos.WithNotStmt()
 	m0 := v.MemoryArg()
 	mem := m0
+	allResults := []*Value{}
 	for i, a := range v.Args {
 		if i < firstArg {
 			continue
@@ -632,18 +776,31 @@ func (x *expandState) rewriteArgs(v *Value, firstArg int) *Value {
 			break
 		}
 		auxI := int64(i - firstArg)
+		aRegs := aux.RegsOfArg(auxI)
+		aOffset := aux.OffsetOfArg(auxI)
+		aType := aux.TypeOfArg(auxI)
 		if a.Op == OpDereference {
 			if a.MemoryArg() != m0 {
 				x.f.Fatalf("Op...LECall and OpDereference have mismatched mem, %s and %s", v.LongString(), a.LongString())
 			}
+			if len(aRegs) > 0 {
+				x.f.Fatalf("Not implemented yet, not-SSA-type %v passed in registers", aType)
+			}
 			// "Dereference" of addressed (probably not-SSA-eligible) value becomes Move
-			// TODO this will be more complicated with registers in the picture.
-			mem = x.rewriteDereference(v.Block, x.sp, a, mem, aux.OffsetOfArg(auxI), aux.SizeOfArg(auxI), aux.TypeOfArg(auxI), pos)
+			// TODO(register args) this will be more complicated with registers in the picture.
+			mem = x.rewriteDereference(v.Block, x.sp, a, mem, aOffset, aux.SizeOfArg(auxI), aType, pos)
 		} else {
 			if x.debug {
-				fmt.Printf("storeArg %s, %v, %d\n", a.LongString(), aux.TypeOfArg(auxI), aux.OffsetOfArg(auxI))
+				fmt.Printf("storeArg %s, %v, %d\n", a.LongString(), aType, aOffset)
+			}
+			var rc registerCursor
+			var result *[]*Value
+			if len(aRegs) > 0 {
+				result = &allResults
 			}
-			mem = x.storeArgOrLoad(pos, v.Block, x.sp, a, mem, aux.TypeOfArg(auxI), aux.OffsetOfArg(auxI))
+			rc.init(aRegs, aux.abiInfo, result)
+			mem = x.storeArgOrLoad(pos, v.Block, x.sp, a, mem, aType, aOffset, 0, rc)
+			// TODO append mem to Result, update type
 		}
 	}
 	v.resetArgs()
@@ -667,6 +824,7 @@ func expandCalls(f *Func) {
 	sp, _ := f.spSb()
 	x := &expandState{
 		f:            f,
+		abi1:         f.ABI1,
 		debug:        f.pass.debug > 0,
 		canSSAType:   f.fe.CanSSA,
 		regSize:      f.Config.RegSize,
@@ -681,9 +839,11 @@ func expandCalls(f *Func) {
 
 	// For 32-bit, need to deal with decomposition of 64-bit integers, which depends on endianness.
 	if f.Config.BigEndian {
-		x.lowOffset = 4
+		x.lowOffset, x.hiOffset = 4, 0
+		x.loRo, x.hiRo = 1, 0
 	} else {
-		x.hiOffset = 4
+		x.lowOffset, x.hiOffset = 0, 4
+		x.loRo, x.hiRo = 0, 1
 	}
 
 	if x.debug {
@@ -692,7 +852,7 @@ func expandCalls(f *Func) {
 
 	// TODO if too slow, whole program iteration can be replaced w/ slices of appropriate values, accumulated in first loop here.
 
-	// Step 0: rewrite the calls to convert incoming args to stores.
+	// Step 0: rewrite the calls to convert args to calls into stores/register movement.
 	for _, b := range f.Blocks {
 		for _, v := range b.Values {
 			switch v.Op {
@@ -717,6 +877,7 @@ func expandCalls(f *Func) {
 			mem := m0
 			aux := f.OwnAux
 			pos := v.Pos.WithNotStmt()
+			allResults := []*Value{}
 			for j, a := range v.Args {
 				i := int64(j)
 				if a == m0 {
@@ -726,7 +887,11 @@ func expandCalls(f *Func) {
 				auxBase := b.NewValue2A(v.Pos, OpLocalAddr, types.NewPtr(auxType), aux.results[i].Name, x.sp, mem)
 				auxOffset := int64(0)
 				auxSize := aux.SizeOfResult(i)
+				aRegs := aux.RegsOfResult(int64(j))
 				if a.Op == OpDereference {
+					if len(aRegs) > 0 {
+						x.f.Fatalf("Not implemented yet, not-SSA-type %v returned in register", auxType)
+					}
 					// Avoid a self-move, and if one is detected try to remove the already-inserted VarDef for the assignment that won't happen.
 					if dAddr, dMem := a.Args[0], a.Args[1]; dAddr.Op == OpLocalAddr && dAddr.Args[0].Op == OpSP &&
 						dAddr.Args[1] == dMem && dAddr.Aux == aux.results[i].Name {
@@ -738,12 +903,20 @@ func expandCalls(f *Func) {
 					mem = x.rewriteDereference(v.Block, auxBase, a, mem, auxOffset, auxSize, auxType, pos)
 				} else {
 					if a.Op == OpLoad && a.Args[0].Op == OpLocalAddr {
-						addr := a.Args[0]
+						addr := a.Args[0] // This is a self-move. // TODO(register args) do what here for registers?
 						if addr.MemoryArg() == a.MemoryArg() && addr.Aux == aux.results[i].Name {
 							continue
 						}
 					}
-					mem = x.storeArgOrLoad(v.Pos, b, auxBase, a, mem, aux.TypeOfResult(i), auxOffset)
+					var rc registerCursor
+					var result *[]*Value
+					if len(aRegs) > 0 {
+						result = &allResults
+					}
+					rc.init(aRegs, aux.abiInfo, result)
+					// TODO(register args)
+					mem = x.storeArgOrLoad(v.Pos, b, auxBase, a, mem, aux.TypeOfResult(i), auxOffset, 0, rc)
+					// TODO append mem to Result, update type
 				}
 			}
 			b.SetControl(mem)
@@ -786,7 +959,7 @@ func expandCalls(f *Func) {
 						fmt.Printf("Splitting store %s\n", v.LongString())
 					}
 					dst, mem := v.Args[0], v.Args[2]
-					mem = x.storeArgOrLoad(v.Pos, b, dst, source, mem, t, 0)
+					mem = x.storeArgOrLoad(v.Pos, b, dst, source, mem, t, 0, 0, registerCursor{})
 					v.copyOf(mem)
 				}
 			}
@@ -973,7 +1146,7 @@ func expandCalls(f *Func) {
 		if v.Op == OpCopy {
 			continue
 		}
-		locs := x.rewriteSelect(v, v, 0)
+		locs := x.rewriteSelect(v, v, 0, 0)
 		// Install new names.
 		if v.Type.IsMemory() {
 			continue
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index 4bda7369bb..55e0602f2f 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -105,16 +105,29 @@ func (a *AuxCall) OffsetOfResult(which int64) int64 {
 }
 
 // OffsetOfArg returns the SP offset of argument which (indexed 0, 1, etc).
+// If the call is to a method, the receiver is the first argument (i.e., index 0)
 func (a *AuxCall) OffsetOfArg(which int64) int64 {
 	return int64(a.args[which].Offset)
 }
 
+// RegsOfResult returns the register(s) used for result which (indexed 0, 1, etc).
+func (a *AuxCall) RegsOfResult(which int64) []abi.RegIndex {
+	return a.results[which].Reg
+}
+
+// RegsOfArg returns the register(s) used for argument which (indexed 0, 1, etc).
+// If the call is to a method, the receiver is the first argument (i.e., index 0)
+func (a *AuxCall) RegsOfArg(which int64) []abi.RegIndex {
+	return a.args[which].Reg
+}
+
 // TypeOfResult returns the type of result which (indexed 0, 1, etc).
 func (a *AuxCall) TypeOfResult(which int64) *types.Type {
 	return a.results[which].Type
 }
 
 // TypeOfArg returns the type of argument which (indexed 0, 1, etc).
+// If the call is to a method, the receiver is the first argument (i.e., index 0)
 func (a *AuxCall) TypeOfArg(which int64) *types.Type {
 	return a.args[which].Type
 }
@@ -125,6 +138,7 @@ func (a *AuxCall) SizeOfResult(which int64) int64 {
 }
 
 // SizeOfArg returns the size of argument which (indexed 0, 1, etc).
+// If the call is to a method, the receiver is the first argument (i.e., index 0)
 func (a *AuxCall) SizeOfArg(which int64) int64 {
 	return a.TypeOfArg(which).Width
 }
@@ -145,7 +159,7 @@ func (a *AuxCall) LateExpansionResultType() *types.Type {
 	return types.NewResults(tys)
 }
 
-// NArgs returns the number of arguments
+// NArgs returns the number of arguments (including receiver, if there is one).
 func (a *AuxCall) NArgs() int64 {
 	return int64(len(a.args))
 }
-- 
GitLab


From dbbc5ec7e87f1976188c57ce4fb0d41e324df687 Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Wed, 24 Feb 2021 22:59:59 +0100
Subject: [PATCH 0834/2400] syscall: restore broken GetQueuedCompletionStatus
 signature but make it not crash

This reverts commit dc4698f52b5ad3f0251e0cc25bc7ffbd10e23f2c, and then
fixes the memory corruption issue. It also suggests users switch to
x/sys/windows for the proper function.

This requires CL 295174 to be submitted first.

Updates #44538.

Change-Id: I0ee602f1c1d6a89cc585aff426833a4cb3f2be50
Reviewed-on: https://go-review.googlesource.com/c/go/+/296149
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 api/except.txt                  |  6 ------
 src/syscall/syscall_windows.go  | 31 ++++++++++++++++++++++++++++---
 src/syscall/zsyscall_windows.go |  6 +++---
 3 files changed, 31 insertions(+), 12 deletions(-)

diff --git a/api/except.txt b/api/except.txt
index 1ddc397d11..6f6f839ba6 100644
--- a/api/except.txt
+++ b/api/except.txt
@@ -471,9 +471,6 @@ pkg syscall (openbsd-amd64-cgo), type Statfs_t struct, Pad_cgo_1 [4]uint8
 pkg syscall (openbsd-amd64-cgo), type Timespec struct, Pad_cgo_0 [4]uint8
 pkg syscall (openbsd-amd64-cgo), type Timespec struct, Sec int32
 pkg syscall (windows-386), const TOKEN_ALL_ACCESS = 983295
-pkg syscall (windows-386), func CreateIoCompletionPort(Handle, Handle, uint32, uint32) (Handle, error)
-pkg syscall (windows-386), func GetQueuedCompletionStatus(Handle, *uint32, *uint32, **Overlapped, uint32) error
-pkg syscall (windows-386), func PostQueuedCompletionStatus(Handle, uint32, uint32, *Overlapped) error
 pkg syscall (windows-386), type AddrinfoW struct, Addr uintptr
 pkg syscall (windows-386), type CertChainPolicyPara struct, ExtraPolicyPara uintptr
 pkg syscall (windows-386), type CertChainPolicyStatus struct, ExtraPolicyStatus uintptr
@@ -483,9 +480,6 @@ pkg syscall (windows-386), type CertRevocationInfo struct, OidSpecificInfo uintp
 pkg syscall (windows-386), type CertSimpleChain struct, TrustListInfo uintptr
 pkg syscall (windows-386), type RawSockaddrAny struct, Pad [96]int8
 pkg syscall (windows-amd64), const TOKEN_ALL_ACCESS = 983295
-pkg syscall (windows-amd64), func CreateIoCompletionPort(Handle, Handle, uint32, uint32) (Handle, error)
-pkg syscall (windows-amd64), func GetQueuedCompletionStatus(Handle, *uint32, *uint32, **Overlapped, uint32) error
-pkg syscall (windows-amd64), func PostQueuedCompletionStatus(Handle, uint32, uint32, *Overlapped) error
 pkg syscall (windows-amd64), type AddrinfoW struct, Addr uintptr
 pkg syscall (windows-amd64), type CertChainPolicyPara struct, ExtraPolicyPara uintptr
 pkg syscall (windows-amd64), type CertChainPolicyStatus struct, ExtraPolicyStatus uintptr
diff --git a/src/syscall/syscall_windows.go b/src/syscall/syscall_windows.go
index a958f7aa84..5310f2da80 100644
--- a/src/syscall/syscall_windows.go
+++ b/src/syscall/syscall_windows.go
@@ -213,9 +213,9 @@ func NewCallbackCDecl(fn interface{}) uintptr {
 //sys	SetEndOfFile(handle Handle) (err error)
 //sys	GetSystemTimeAsFileTime(time *Filetime)
 //sys	GetTimeZoneInformation(tzi *Timezoneinformation) (rc uint32, err error) [failretval==0xffffffff]
-//sys	CreateIoCompletionPort(filehandle Handle, cphandle Handle, key uintptr, threadcnt uint32) (handle Handle, err error)
-//sys	GetQueuedCompletionStatus(cphandle Handle, qty *uint32, key *uintptr, overlapped **Overlapped, timeout uint32) (err error)
-//sys	PostQueuedCompletionStatus(cphandle Handle, qty uint32, key uintptr, overlapped *Overlapped) (err error)
+//sys	createIoCompletionPort(filehandle Handle, cphandle Handle, key uintptr, threadcnt uint32) (handle Handle, err error) = CreateIoCompletionPort
+//sys	getQueuedCompletionStatus(cphandle Handle, qty *uint32, key *uintptr, overlapped **Overlapped, timeout uint32) (err error) = GetQueuedCompletionStatus
+//sys	postQueuedCompletionStatus(cphandle Handle, qty uint32, key uintptr, overlapped *Overlapped) (err error) = PostQueuedCompletionStatus
 //sys	CancelIo(s Handle) (err error)
 //sys	CancelIoEx(s Handle, o *Overlapped) (err error)
 //sys	CreateProcess(appName *uint16, commandLine *uint16, procSecurity *SecurityAttributes, threadSecurity *SecurityAttributes, inheritHandles bool, creationFlags uint32, env *uint16, currentDir *uint16, startupInfo *StartupInfo, outProcInfo *ProcessInformation) (err error) = CreateProcessW
@@ -1212,3 +1212,28 @@ func Readlink(path string, buf []byte) (n int, err error) {
 
 	return n, nil
 }
+
+// Deprecated: CreateIoCompletionPort has the wrong function signature. Use x/sys/windows.CreateIoCompletionPort.
+func CreateIoCompletionPort(filehandle Handle, cphandle Handle, key uint32, threadcnt uint32) (Handle, error) {
+	return createIoCompletionPort(filehandle, cphandle, uintptr(key), threadcnt)
+}
+
+// Deprecated: GetQueuedCompletionStatus has the wrong function signature. Use x/sys/windows.GetQueuedCompletionStatus.
+func GetQueuedCompletionStatus(cphandle Handle, qty *uint32, key *uint32, overlapped **Overlapped, timeout uint32) error {
+	var ukey uintptr
+	var pukey *uintptr
+	if key != nil {
+		ukey = uintptr(*key)
+		pukey = &ukey
+	}
+	err := getQueuedCompletionStatus(cphandle, qty, pukey, overlapped, timeout)
+	if key != nil {
+		*key = uint32(ukey)
+	}
+	return err
+}
+
+// Deprecated: PostQueuedCompletionStatus has the wrong function signature. Use x/sys/windows.PostQueuedCompletionStatus.
+func PostQueuedCompletionStatus(cphandle Handle, qty uint32, key uint32, overlapped *Overlapped) error {
+	return postQueuedCompletionStatus(cphandle, qty, uintptr(key), overlapped)
+}
diff --git a/src/syscall/zsyscall_windows.go b/src/syscall/zsyscall_windows.go
index cc44e31a85..b1480ba7df 100644
--- a/src/syscall/zsyscall_windows.go
+++ b/src/syscall/zsyscall_windows.go
@@ -515,7 +515,7 @@ func CreateHardLink(filename *uint16, existingfilename *uint16, reserved uintptr
 	return
 }
 
-func CreateIoCompletionPort(filehandle Handle, cphandle Handle, key uintptr, threadcnt uint32) (handle Handle, err error) {
+func createIoCompletionPort(filehandle Handle, cphandle Handle, key uintptr, threadcnt uint32) (handle Handle, err error) {
 	r0, _, e1 := Syscall6(procCreateIoCompletionPort.Addr(), 4, uintptr(filehandle), uintptr(cphandle), uintptr(key), uintptr(threadcnt), 0, 0)
 	handle = Handle(r0)
 	if handle == 0 {
@@ -822,7 +822,7 @@ func GetProcessTimes(handle Handle, creationTime *Filetime, exitTime *Filetime,
 	return
 }
 
-func GetQueuedCompletionStatus(cphandle Handle, qty *uint32, key *uintptr, overlapped **Overlapped, timeout uint32) (err error) {
+func getQueuedCompletionStatus(cphandle Handle, qty *uint32, key *uintptr, overlapped **Overlapped, timeout uint32) (err error) {
 	r1, _, e1 := Syscall6(procGetQueuedCompletionStatus.Addr(), 5, uintptr(cphandle), uintptr(unsafe.Pointer(qty)), uintptr(unsafe.Pointer(key)), uintptr(unsafe.Pointer(overlapped)), uintptr(timeout), 0)
 	if r1 == 0 {
 		err = errnoErr(e1)
@@ -954,7 +954,7 @@ func OpenProcess(da uint32, inheritHandle bool, pid uint32) (handle Handle, err
 	return
 }
 
-func PostQueuedCompletionStatus(cphandle Handle, qty uint32, key uintptr, overlapped *Overlapped) (err error) {
+func postQueuedCompletionStatus(cphandle Handle, qty uint32, key uintptr, overlapped *Overlapped) (err error) {
 	r1, _, e1 := Syscall6(procPostQueuedCompletionStatus.Addr(), 4, uintptr(cphandle), uintptr(qty), uintptr(key), uintptr(unsafe.Pointer(overlapped)), 0, 0)
 	if r1 == 0 {
 		err = errnoErr(e1)
-- 
GitLab


From ff614b13d90961f55b1058bd798c6d4e92d3939c Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Thu, 25 Feb 2021 01:29:58 +0100
Subject: [PATCH 0835/2400] runtime: subtract one from ip when determining
 abort

On windows/arm, the abort is given from one byte off of the function
address, perhaps because Windows wants to simulate x86/amd64 modes, or
because it's jumping from thumb mode. This is not the case with
windows/arm64, though.

This prevents a failure in the builders with the TestAbort test:

    crash_test.go:727: output contains BAD:
        panic: runtime error: invalid memory address or nil pointer dereference [recovered]
                panic: BAD: recovered from abort
        [signal 0xc0000005 code=0x0 addr=0x0 pc=0x6a5721]

Change-Id: I8939c60611863cc0c325e179a772601acea9fd4a
Reviewed-on: https://go-review.googlesource.com/c/go/+/296153
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/signal_windows.go | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/runtime/signal_windows.go b/src/runtime/signal_windows.go
index 6215d0ba2d..63158f0bc4 100644
--- a/src/runtime/signal_windows.go
+++ b/src/runtime/signal_windows.go
@@ -45,9 +45,10 @@ func initExceptionHandler() {
 //go:nosplit
 func isAbort(r *context) bool {
 	pc := r.ip()
-	if GOARCH == "386" || GOARCH == "amd64" {
+	if GOARCH == "386" || GOARCH == "amd64" || GOARCH == "arm" {
 		// In the case of an abort, the exception IP is one byte after
-		// the INT3 (this differs from UNIX OSes).
+		// the INT3 (this differs from UNIX OSes). Note that on ARM,
+		// this means that the exception IP is no longer aligned.
 		pc--
 	}
 	return isAbortPC(pc)
-- 
GitLab


From d822ffebc59d27190ac145a71c726dad35769225 Mon Sep 17 00:00:00 2001
From: Egon Elbre <egonelbre@gmail.com>
Date: Wed, 24 Feb 2021 21:08:52 +0200
Subject: [PATCH 0836/2400] test: fix inline.go test for linux-amd64-noopt

math.Float32bits was not being inlined across package boundaries.
Create a private func that can be inlined with -l.

Change-Id: Ic50bf4727dd8ade09d011eb204006b7ee88db34a
Reviewed-on: https://go-review.googlesource.com/c/go/+/295989
Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Keith Randall <khr@golang.org>
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 test/inline.go | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/test/inline.go b/test/inline.go
index 44c746b282..bc23768d01 100644
--- a/test/inline.go
+++ b/test/inline.go
@@ -10,7 +10,6 @@
 package foo
 
 import (
-	"math"
 	"runtime"
 	"unsafe"
 )
@@ -267,12 +266,18 @@ func gd3() func() { // ERROR "can inline gd3"
 // Issue #42788 - ensure ODEREF OCONVNOP* OADDR is low cost.
 func EncodeQuad(d []uint32, x [6]float32) { // ERROR "can inline EncodeQuad" "d does not escape"
 	_ = d[:6]
-	d[0] = math.Float32bits(x[0]) // ERROR "inlining call to math.Float32bits"
-	d[1] = math.Float32bits(x[1]) // ERROR "inlining call to math.Float32bits"
-	d[2] = math.Float32bits(x[2]) // ERROR "inlining call to math.Float32bits"
-	d[3] = math.Float32bits(x[3]) // ERROR "inlining call to math.Float32bits"
-	d[4] = math.Float32bits(x[4]) // ERROR "inlining call to math.Float32bits"
-	d[5] = math.Float32bits(x[5]) // ERROR "inlining call to math.Float32bits"
+	d[0] = float32bits(x[0]) // ERROR "inlining call to float32bits"
+	d[1] = float32bits(x[1]) // ERROR "inlining call to float32bits"
+	d[2] = float32bits(x[2]) // ERROR "inlining call to float32bits"
+	d[3] = float32bits(x[3]) // ERROR "inlining call to float32bits"
+	d[4] = float32bits(x[4]) // ERROR "inlining call to float32bits"
+	d[5] = float32bits(x[5]) // ERROR "inlining call to float32bits"
+}
+
+// float32bits is a copy of math.Float32bits to ensure that
+// these tests pass with `-gcflags=-l`.
+func float32bits(f float32) uint32 { // ERROR "can inline float32bits"
+	return *(*uint32)(unsafe.Pointer(&f))
 }
 
 // Ensure OCONVNOP is zero cost.
-- 
GitLab


From 666ad85df450e3a54a77954f97423980b6ac064f Mon Sep 17 00:00:00 2001
From: Ikko Ashimine <eltociear@gmail.com>
Date: Thu, 25 Feb 2021 03:03:45 +0000
Subject: [PATCH 0837/2400] cmd/compile: fix typo in rewrite_test.go

insted -> instead

Change-Id: Ib8a0423cf99f615976f058468873fb576dd96db6
GitHub-Last-Rev: 8e1a1d08807a35c55d65a2e3f8bb28418a43b3a8
GitHub-Pull-Request: golang/go#44598
Reviewed-on: https://go-review.googlesource.com/c/go/+/296309
Reviewed-by: Keith Randall <khr@golang.org>
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ssa/rewrite_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ssa/rewrite_test.go b/src/cmd/compile/internal/ssa/rewrite_test.go
index 6fe429e85a..272b080d88 100644
--- a/src/cmd/compile/internal/ssa/rewrite_test.go
+++ b/src/cmd/compile/internal/ssa/rewrite_test.go
@@ -13,7 +13,7 @@ func TestMove(t *testing.T) {
 	copy(x[1:], x[:])
 	for i := 1; i < len(x); i++ {
 		if int(x[i]) != i {
-			t.Errorf("Memmove got converted to OpMove in alias-unsafe way. Got %d insted of %d in position %d", int(x[i]), i, i+1)
+			t.Errorf("Memmove got converted to OpMove in alias-unsafe way. Got %d instead of %d in position %d", int(x[i]), i, i+1)
 		}
 	}
 }
-- 
GitLab


From 76c0003cd5645078e342c1d24c98b3ce5ae42eb4 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Tue, 23 Feb 2021 14:58:32 +0100
Subject: [PATCH 0838/2400] syscall, os: use pipe2 syscall on DragonflyBSD
 instead of pipe

Follow the implementation used by the other BSDs and account for the
intricacy of having to pass the fds array even though the file
descriptors are returned.

Re-submit of CL 130996 with corrected pipe2 wrapper.

Change-Id: Ie36d8214cba60c4fdb579f18bfc1c1ab3ead3ddc
Reviewed-on: https://go-review.googlesource.com/c/go/+/295372
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/os/pipe2_bsd.go                     |  4 ++--
 src/os/pipe_bsd.go                      |  4 ++--
 src/syscall/forkpipe.go                 |  4 ++--
 src/syscall/forkpipe2.go                |  4 ++--
 src/syscall/syscall_dragonfly.go        | 13 +++++++++++++
 src/syscall/zsyscall_dragonfly_amd64.go | 12 ++++++++++++
 src/syscall/zsysnum_dragonfly_amd64.go  |  1 +
 7 files changed, 34 insertions(+), 8 deletions(-)

diff --git a/src/os/pipe2_bsd.go b/src/os/pipe2_bsd.go
index 0af8019525..bf6d081db5 100644
--- a/src/os/pipe2_bsd.go
+++ b/src/os/pipe2_bsd.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build freebsd || netbsd || openbsd
-// +build freebsd netbsd openbsd
+//go:build dragonfly || freebsd || netbsd || openbsd
+// +build dragonfly freebsd netbsd openbsd
 
 package os
 
diff --git a/src/os/pipe_bsd.go b/src/os/pipe_bsd.go
index 57959a2ea4..097b32e7eb 100644
--- a/src/os/pipe_bsd.go
+++ b/src/os/pipe_bsd.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build aix || darwin || dragonfly || (js && wasm) || (solaris && !illumos)
-// +build aix darwin dragonfly js,wasm solaris,!illumos
+//go:build aix || darwin || (js && wasm) || (solaris && !illumos)
+// +build aix darwin js,wasm solaris,!illumos
 
 package os
 
diff --git a/src/syscall/forkpipe.go b/src/syscall/forkpipe.go
index c7ddcf26ab..79cbdf4150 100644
--- a/src/syscall/forkpipe.go
+++ b/src/syscall/forkpipe.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build aix || darwin || dragonfly || solaris
-// +build aix darwin dragonfly solaris
+//go:build aix || darwin || solaris
+// +build aix darwin solaris
 
 package syscall
 
diff --git a/src/syscall/forkpipe2.go b/src/syscall/forkpipe2.go
index cd98779ac9..e57240c156 100644
--- a/src/syscall/forkpipe2.go
+++ b/src/syscall/forkpipe2.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build freebsd || netbsd || openbsd
-// +build freebsd netbsd openbsd
+//go:build dragonfly || freebsd || netbsd || openbsd
+// +build dragonfly freebsd netbsd openbsd
 
 package syscall
 
diff --git a/src/syscall/syscall_dragonfly.go b/src/syscall/syscall_dragonfly.go
index 0988fe4608..b01a4ada67 100644
--- a/src/syscall/syscall_dragonfly.go
+++ b/src/syscall/syscall_dragonfly.go
@@ -100,6 +100,19 @@ func Pipe(p []int) (err error) {
 	return
 }
 
+//sysnb	pipe2(p *[2]_C_int, flags int) (r int, w int, err error)
+
+func Pipe2(p []int, flags int) (err error) {
+	if len(p) != 2 {
+		return EINVAL
+	}
+	var pp [2]_C_int
+	// pipe2 on dragonfly takes an fds array as an argument, but still
+	// returns the file descriptors.
+	p[0], p[1], err = pipe2(&pp, flags)
+	return err
+}
+
 //sys	extpread(fd int, p []byte, flags int, offset int64) (n int, err error)
 func Pread(fd int, p []byte, offset int64) (n int, err error) {
 	return extpread(fd, p, 0, offset)
diff --git a/src/syscall/zsyscall_dragonfly_amd64.go b/src/syscall/zsyscall_dragonfly_amd64.go
index 4799d1dcb0..aa327c0010 100644
--- a/src/syscall/zsyscall_dragonfly_amd64.go
+++ b/src/syscall/zsyscall_dragonfly_amd64.go
@@ -274,6 +274,18 @@ func pipe() (r int, w int, err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func pipe2(p *[2]_C_int, flags int) (r int, w int, err error) {
+	r0, r1, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
+	r = int(r0)
+	w = int(r1)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func extpread(fd int, p []byte, flags int, offset int64) (n int, err error) {
 	var _p0 unsafe.Pointer
 	if len(p) > 0 {
diff --git a/src/syscall/zsysnum_dragonfly_amd64.go b/src/syscall/zsysnum_dragonfly_amd64.go
index 855188f045..ae504a5f0c 100644
--- a/src/syscall/zsysnum_dragonfly_amd64.go
+++ b/src/syscall/zsysnum_dragonfly_amd64.go
@@ -302,6 +302,7 @@ const (
 	SYS_LPATHCONF              = 533 // { int lpathconf(char *path, int name); }
 	SYS_VMM_GUEST_CTL          = 534 // { int vmm_guest_ctl(int op, struct vmm_guest_options *options); }
 	SYS_VMM_GUEST_SYNC_ADDR    = 535 // { int vmm_guest_sync_addr(long *dstaddr, long *srcaddr); }
+	SYS_PIPE2                  = 538 // { int pipe2(int *fildes, int flags); }
 	SYS_UTIMENSAT              = 539 // { int utimensat(int fd, const char *path, const struct timespec *ts, int flags); }
 	SYS_ACCEPT4                = 541 // { int accept4(int s, caddr_t name, int *anamelen, int flags); }
 )
-- 
GitLab


From 37ca84a9cd6a8a76dfe91263a17d2b92b17a24b3 Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Thu, 25 Feb 2021 02:58:04 +0100
Subject: [PATCH 0839/2400] syscall: return error if GetQueuedCompletionStatus
 truncates key

This function has the wrong signature, so return an error when that
actually might lead to unexpected results. Users should switch to
x/sys/windows for the real version of this function.

Updates #44538.

Change-Id: I4d1f3d1e380815733ecfea683f939b1d25dcc32a
Reviewed-on: https://go-review.googlesource.com/c/go/+/296154
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/syscall/syscall_windows.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/syscall/syscall_windows.go b/src/syscall/syscall_windows.go
index 5310f2da80..ee5311b176 100644
--- a/src/syscall/syscall_windows.go
+++ b/src/syscall/syscall_windows.go
@@ -1229,6 +1229,9 @@ func GetQueuedCompletionStatus(cphandle Handle, qty *uint32, key *uint32, overla
 	err := getQueuedCompletionStatus(cphandle, qty, pukey, overlapped, timeout)
 	if key != nil {
 		*key = uint32(ukey)
+		if uintptr(*key) != ukey && err == nil {
+			err = errorspkg.New("GetQueuedCompletionStatus returned key overflow")
+		}
 	}
 	return err
 }
-- 
GitLab


From ad17b65b340d5a40d0da1b4cbcdc239061e97c65 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Sun, 21 Feb 2021 15:28:41 -0800
Subject: [PATCH 0840/2400] testing/fstest: treat dash specially when building
 glob

"[-]" is not a valid path.Match pattern.

Fixes #44474

Change-Id: I0932bbf08ffb8ad0c5337d69d0893f53c1ba89ad
Reviewed-on: https://go-review.googlesource.com/c/go/+/294869
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/testing/fstest/testfs.go      | 2 +-
 src/testing/fstest/testfs_test.go | 9 +++++++++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/testing/fstest/testfs.go b/src/testing/fstest/testfs.go
index 8fc8acaaf3..736bbf0590 100644
--- a/src/testing/fstest/testfs.go
+++ b/src/testing/fstest/testfs.go
@@ -303,7 +303,7 @@ func (t *fsTester) checkGlob(dir string, list []fs.DirEntry) {
 		for i, e := range elem {
 			var pattern []rune
 			for j, r := range e {
-				if r == '*' || r == '?' || r == '\\' || r == '[' {
+				if r == '*' || r == '?' || r == '\\' || r == '[' || r == '-' {
 					pattern = append(pattern, '\\', r)
 					continue
 				}
diff --git a/src/testing/fstest/testfs_test.go b/src/testing/fstest/testfs_test.go
index 5b8813c343..aefb4b3361 100644
--- a/src/testing/fstest/testfs_test.go
+++ b/src/testing/fstest/testfs_test.go
@@ -29,3 +29,12 @@ func TestSymlink(t *testing.T) {
 		t.Fatal(err)
 	}
 }
+
+func TestDash(t *testing.T) {
+	m := MapFS{
+		"a-b/a": {Data: []byte("a-b/a")},
+	}
+	if err := TestFS(m, "a-b/a"); err != nil {
+		t.Error(err)
+	}
+}
-- 
GitLab


From 9fe8ebf9b49e632db54aa60809e2019a2a87e28b Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Sun, 14 Feb 2021 17:59:48 -0800
Subject: [PATCH 0841/2400] test: add test case that failed with gccgo

bug511.dir/b.go:10:14: error: reference to undefined field or method 'M'

Change-Id: I9f96dc5c7254b310bc3e15b0bc588d62718cb4b2
Reviewed-on: https://go-review.googlesource.com/c/go/+/292009
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 test/fixedbugs/bug511.dir/a.go | 11 +++++++++++
 test/fixedbugs/bug511.dir/b.go | 11 +++++++++++
 test/fixedbugs/bug511.go       |  9 +++++++++
 3 files changed, 31 insertions(+)
 create mode 100644 test/fixedbugs/bug511.dir/a.go
 create mode 100644 test/fixedbugs/bug511.dir/b.go
 create mode 100644 test/fixedbugs/bug511.go

diff --git a/test/fixedbugs/bug511.dir/a.go b/test/fixedbugs/bug511.dir/a.go
new file mode 100644
index 0000000000..33931a07a8
--- /dev/null
+++ b/test/fixedbugs/bug511.dir/a.go
@@ -0,0 +1,11 @@
+// Copyright 2021 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 a
+
+type S struct{}
+
+type A = S
+
+func (A) M() {}
diff --git a/test/fixedbugs/bug511.dir/b.go b/test/fixedbugs/bug511.dir/b.go
new file mode 100644
index 0000000000..f8877d6afd
--- /dev/null
+++ b/test/fixedbugs/bug511.dir/b.go
@@ -0,0 +1,11 @@
+// Copyright 2021 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 b
+
+import "./a"
+
+func F() {
+	a.S{}.M()
+}
diff --git a/test/fixedbugs/bug511.go b/test/fixedbugs/bug511.go
new file mode 100644
index 0000000000..edd3a23521
--- /dev/null
+++ b/test/fixedbugs/bug511.go
@@ -0,0 +1,9 @@
+// compiledir
+
+// Copyright 2021 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.
+
+// Gccgo mishandled type aliases as receiver types.
+
+package ignored
-- 
GitLab


From 2c4c189bba57a4a72c371afa7e544c16abd76ffa Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Thu, 18 Feb 2021 20:20:12 -0500
Subject: [PATCH 0842/2400] cmd/go/internal/mvs: add test cases for downgrade
 interaction with hidden versions

For #36460

Change-Id: I889c4ece0d2caff7528cf437f89f7446dbd83955
Reviewed-on: https://go-review.googlesource.com/c/go/+/294292
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/mvs/mvs_test.go | 53 +++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)

diff --git a/src/cmd/go/internal/mvs/mvs_test.go b/src/cmd/go/internal/mvs/mvs_test.go
index 742e396e0d..661f68be08 100644
--- a/src/cmd/go/internal/mvs/mvs_test.go
+++ b/src/cmd/go/internal/mvs/mvs_test.go
@@ -275,6 +275,59 @@ B1:
 build A:        A B2
 downgrade A B1: A B1
 
+# Both B3 and C2 require D2.
+# If we downgrade D to D1, then in isolation B3 would downgrade to B1,
+# because B2 is hidden — B1 is the next-highest version that is not hidden.
+# However, if we downgrade D, we will also downgrade C to C1.
+# And C1 requires B2.hidden, and B2.hidden also meets our requirements:
+# it is compatible with D1 and a strict downgrade from B3.
+#
+# BUG(?): B2.hidden does not require E1, so there is no need for E1
+# to appear in the final build list. Nonetheless, there it is.
+#
+name: downhiddenartifact
+A: B3 C2
+A1: B3
+B1: E1
+B2.hidden:
+B3: D2
+C1: B2.hidden
+C2: D2
+D1:
+D2:
+build A1: A1 B3 D2
+downgrade A1 D1: A1 B1 D1 E1
+build A: A B3 C2 D2
+downgrade A D1: A B2.hidden C1 D1 E1
+
+# Both B3 and C3 require D2.
+# If we downgrade D to D1, then in isolation B3 would downgrade to B1,
+# and C3 would downgrade to C1.
+# But C1 requires B2.hidden, and B1 requires C2.hidden, so we can't
+# downgrade to either of those without pulling the other back up a little.
+#
+# B2.hidden and C2.hidden are both compatible with D1, so that still
+# meets our requirements — but then we're in an odd state in which
+# B and C have both been downgraded to hidden versions, without any
+# remaining requirements to explain how those hidden versions got there.
+#
+# TODO(bcmills): Would it be better to force downgrades to land on non-hidden
+# versions?
+# In this case, that would remove the dependencies on B and C entirely.
+#
+name: downhiddencross
+A: B3 C3
+B1: C2.hidden
+B2.hidden:
+B3: D2
+C1: B2.hidden
+C2.hidden:
+C3: D2
+D1:
+D2:
+build A: A B3 C3 D2
+downgrade A D1: A B2.hidden C2.hidden D1
+
 # golang.org/issue/25542.
 name: noprev1
 A: B4 C2
-- 
GitLab


From 3137da82fd74d534fff59092329c0ca820ff6589 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 19 Feb 2021 14:41:02 -0500
Subject: [PATCH 0843/2400] cmd/go: add a script test corresponding to the
 downhiddenartifact MVS test

For #36460

Change-Id: I95abff45bb325732a19eb8b9c0d3fc34df08b4d4
Reviewed-on: https://go-review.googlesource.com/c/go/+/294293
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 .../script/mod_get_downup_pseudo_artifact.txt | 132 ++++++++++++++++++
 1 file changed, 132 insertions(+)
 create mode 100644 src/cmd/go/testdata/script/mod_get_downup_pseudo_artifact.txt

diff --git a/src/cmd/go/testdata/script/mod_get_downup_pseudo_artifact.txt b/src/cmd/go/testdata/script/mod_get_downup_pseudo_artifact.txt
new file mode 100644
index 0000000000..d773f6bd4d
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_get_downup_pseudo_artifact.txt
@@ -0,0 +1,132 @@
+# This test illustrates a case where an upgrade–downgrade–upgrade cycle could
+# add extraneous dependencies due to another module depending on an
+# otherwise-unlisted version (such as a pseudo-version).
+#
+# This case corresponds to the "downhiddenartifact" test in the mvs package.
+
+# The initial package import graph used in the test looks like:
+#
+# a --- b
+#  \     \
+#   \     \
+#    c --- d
+#
+# The module dependency graph initially looks like:
+#
+# a --- b.3
+#  \      \
+#   \      \
+#   c.2 --- d.2
+#
+# c.1 --- b.2 (pseudo)
+#
+# b.1 --- e.1
+
+cp go.mod go.mod.orig
+go mod tidy
+cmp go.mod.orig go.mod
+
+go get -d example.net/d@v0.1.0
+
+go list -m all
+stdout '^example.net/b v0.2.1-0.20210219000000-000000000000 '
+stdout '^example.net/c v0.1.0 '
+stdout '^example.net/d v0.1.0 '
+
+	# BUG: A dependency on e is added even though nothing requires it.
+stdout '^example.net/e '
+
+go mod why -m example.net/e
+stdout '^\(main module does not need module example.net/e\)'
+
+-- go.mod --
+module example.net/a
+
+go 1.16
+
+require (
+	example.net/b v0.3.0
+	example.net/c v0.2.0
+)
+
+replace (
+	example.net/b v0.1.0 => ./b1
+	example.net/b v0.2.1-0.20210219000000-000000000000 => ./b2
+	example.net/b v0.3.0 => ./b3
+	example.net/c v0.1.0 => ./c1
+	example.net/c v0.2.0 => ./c2
+	example.net/d v0.1.0 => ./d
+	example.net/d v0.2.0 => ./d
+	example.net/e v0.1.0 => ./e
+)
+-- a.go --
+package a
+
+import (
+	_ "example.net/b"
+	_ "example.net/c"
+)
+
+-- b1/go.mod --
+module example.net/b
+
+go 1.16
+
+require example.net/e v0.1.0
+-- b1/b.go --
+package b
+
+import _ "example.net/e"
+
+-- b2/go.mod --
+module example.net/b
+
+go 1.16
+-- b2/b.go --
+package b
+
+-- b3/go.mod --
+module example.net/b
+
+go 1.16
+
+require example.net/d v0.2.0
+-- b3/b.go --
+package b
+
+import _ "example.net/d"
+-- c1/go.mod --
+module example.net/c
+
+go 1.16
+
+require example.net/b v0.2.1-0.20210219000000-000000000000
+-- c1/c.go --
+package c
+
+import _ "example.net/b"
+
+-- c2/go.mod --
+module example.net/c
+
+go 1.16
+
+require example.net/d v0.2.0
+-- c2/c.go --
+package c
+
+import _ "example.net/d"
+
+-- d/go.mod --
+module example.net/d
+
+go 1.16
+-- d/d.go --
+package d
+
+-- e/go.mod --
+module example.net/e
+
+go 1.16
+-- e/e.go --
+package e
-- 
GitLab


From bcac57f89c0ec609e6fbebcbcd42bb73fdaef2f0 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Wed, 24 Feb 2021 18:24:45 -0500
Subject: [PATCH 0844/2400] cmd: upgrade golang.org/x/mod to fix go.mod parser

modfile.Parse passed an empty string to the VersionFixer for the
module path. This caused errors for v2+ versions.

Fixes #44494

Change-Id: I13b86b6ecf6815c4bc9a96ec0668284c9228c205
Reviewed-on: https://go-review.googlesource.com/c/go/+/296131
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go.mod                                |   2 +-
 src/cmd/go.sum                                |   4 +-
 .../script/mod_retract_fix_version.txt        |  24 +++++
 .../vendor/golang.org/x/mod/modfile/rule.go   | 102 ++++++++++++++----
 src/cmd/vendor/modules.txt                    |   2 +-
 5 files changed, 109 insertions(+), 25 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/mod_retract_fix_version.txt

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index 3c90dca491..8ca3b982ee 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -6,7 +6,7 @@ require (
 	github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2
 	golang.org/x/arch v0.0.0-20201008161808-52c3e6f60cff
 	golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897
-	golang.org/x/mod v0.4.2-0.20210223202949-66f6d92cabd5
+	golang.org/x/mod v0.4.2-0.20210225160341-66bf157bf5bc
 	golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e // indirect
 	golang.org/x/tools v0.1.1-0.20210220032852-2363391a5b2f
 )
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 498b92207f..7de27879f6 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -14,8 +14,8 @@ golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPh
 golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897 h1:pLI5jrR7OSLijeIDcmRxNmw2api+jEfxLoykJVice/E=
 golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.4.2-0.20210223202949-66f6d92cabd5 h1:ETedWdSKv0zHgSxvhXszxH25fCWwA6olYCPu9ehlVKs=
-golang.org/x/mod v0.4.2-0.20210223202949-66f6d92cabd5/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.2-0.20210225160341-66bf157bf5bc h1:xQukuh0OD2SNSUK1CCBFATgHYx5ye75S/bAWEU/PT0E=
+golang.org/x/mod v0.4.2-0.20210225160341-66bf157bf5bc/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
diff --git a/src/cmd/go/testdata/script/mod_retract_fix_version.txt b/src/cmd/go/testdata/script/mod_retract_fix_version.txt
new file mode 100644
index 0000000000..f8099ec93e
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_retract_fix_version.txt
@@ -0,0 +1,24 @@
+# retract must not be used without a module directive.
+! go list -m all
+stderr 'go.mod:3: no module directive found, so retract cannot be used$'
+
+# Commands that update go.mod should fix non-canonical versions in
+# retract directives.
+# Verifies #44494.
+go mod edit -module=rsc.io/quote/v2
+! go list -m all
+stderr '^go: updates to go.mod needed; to update it:\n\tgo mod tidy$'
+go mod tidy
+go list -m all
+cmp go.mod go.mod.want
+
+-- go.mod --
+go 1.16
+
+retract latest
+-- go.mod.want --
+go 1.16
+
+retract v2.0.1
+
+module rsc.io/quote/v2
diff --git a/src/cmd/vendor/golang.org/x/mod/modfile/rule.go b/src/cmd/vendor/golang.org/x/mod/modfile/rule.go
index 8fcf96b713..f8c9384985 100644
--- a/src/cmd/vendor/golang.org/x/mod/modfile/rule.go
+++ b/src/cmd/vendor/golang.org/x/mod/modfile/rule.go
@@ -125,6 +125,12 @@ func (f *File) AddComment(text string) {
 
 type VersionFixer func(path, version string) (string, error)
 
+// errDontFix is returned by a VersionFixer to indicate the version should be
+// left alone, even if it's not canonical.
+var dontFixRetract VersionFixer = func(_, vers string) (string, error) {
+	return vers, nil
+}
+
 // Parse parses the data, reported in errors as being from file,
 // into a File struct. It applies fix, if non-nil, to canonicalize all module versions found.
 func Parse(file string, data []byte, fix VersionFixer) (*File, error) {
@@ -142,7 +148,7 @@ func ParseLax(file string, data []byte, fix VersionFixer) (*File, error) {
 	return parseToFile(file, data, fix, false)
 }
 
-func parseToFile(file string, data []byte, fix VersionFixer, strict bool) (*File, error) {
+func parseToFile(file string, data []byte, fix VersionFixer, strict bool) (parsed *File, err error) {
 	fs, err := parse(file, data)
 	if err != nil {
 		return nil, err
@@ -150,8 +156,18 @@ func parseToFile(file string, data []byte, fix VersionFixer, strict bool) (*File
 	f := &File{
 		Syntax: fs,
 	}
-
 	var errs ErrorList
+
+	// fix versions in retract directives after the file is parsed.
+	// We need the module path to fix versions, and it might be at the end.
+	defer func() {
+		oldLen := len(errs)
+		f.fixRetract(fix, &errs)
+		if len(errs) > oldLen {
+			parsed, err = nil, errs
+		}
+	}()
+
 	for _, x := range fs.Stmt {
 		switch x := x.(type) {
 		case *Line:
@@ -370,7 +386,7 @@ func (f *File) add(errs *ErrorList, block *LineBlock, line *Line, verb string, a
 
 	case "retract":
 		rationale := parseRetractRationale(block, line)
-		vi, err := parseVersionInterval(verb, &args, fix)
+		vi, err := parseVersionInterval(verb, "", &args, dontFixRetract)
 		if err != nil {
 			if strict {
 				wrapError(err)
@@ -397,6 +413,47 @@ func (f *File) add(errs *ErrorList, block *LineBlock, line *Line, verb string, a
 	}
 }
 
+// fixRetract applies fix to each retract directive in f, appending any errors
+// to errs.
+//
+// Most versions are fixed as we parse the file, but for retract directives,
+// the relevant module path is the one specified with the module directive,
+// and that might appear at the end of the file (or not at all).
+func (f *File) fixRetract(fix VersionFixer, errs *ErrorList) {
+	if fix == nil {
+		return
+	}
+	path := ""
+	if f.Module != nil {
+		path = f.Module.Mod.Path
+	}
+	var r *Retract
+	wrapError := func(err error) {
+		*errs = append(*errs, Error{
+			Filename: f.Syntax.Name,
+			Pos:      r.Syntax.Start,
+			Err:      err,
+		})
+	}
+
+	for _, r = range f.Retract {
+		if path == "" {
+			wrapError(errors.New("no module directive found, so retract cannot be used"))
+			return // only print the first one of these
+		}
+
+		args := r.Syntax.Token
+		if args[0] == "retract" {
+			args = args[1:]
+		}
+		vi, err := parseVersionInterval("retract", path, &args, fix)
+		if err != nil {
+			wrapError(err)
+		}
+		r.VersionInterval = vi
+	}
+}
+
 // isIndirect reports whether line has a "// indirect" comment,
 // meaning it is in go.mod only for its effect on indirect dependencies,
 // so that it can be dropped entirely once the effective version of the
@@ -491,13 +548,13 @@ func AutoQuote(s string) string {
 	return s
 }
 
-func parseVersionInterval(verb string, args *[]string, fix VersionFixer) (VersionInterval, error) {
+func parseVersionInterval(verb string, path string, args *[]string, fix VersionFixer) (VersionInterval, error) {
 	toks := *args
 	if len(toks) == 0 || toks[0] == "(" {
 		return VersionInterval{}, fmt.Errorf("expected '[' or version")
 	}
 	if toks[0] != "[" {
-		v, err := parseVersion(verb, "", &toks[0], fix)
+		v, err := parseVersion(verb, path, &toks[0], fix)
 		if err != nil {
 			return VersionInterval{}, err
 		}
@@ -509,7 +566,7 @@ func parseVersionInterval(verb string, args *[]string, fix VersionFixer) (Versio
 	if len(toks) == 0 {
 		return VersionInterval{}, fmt.Errorf("expected version after '['")
 	}
-	low, err := parseVersion(verb, "", &toks[0], fix)
+	low, err := parseVersion(verb, path, &toks[0], fix)
 	if err != nil {
 		return VersionInterval{}, err
 	}
@@ -523,7 +580,7 @@ func parseVersionInterval(verb string, args *[]string, fix VersionFixer) (Versio
 	if len(toks) == 0 {
 		return VersionInterval{}, fmt.Errorf("expected version after ','")
 	}
-	high, err := parseVersion(verb, "", &toks[0], fix)
+	high, err := parseVersion(verb, path, &toks[0], fix)
 	if err != nil {
 		return VersionInterval{}, err
 	}
@@ -631,8 +688,7 @@ func parseVersion(verb string, path string, s *string, fix VersionFixer) (string
 		}
 	}
 	if fix != nil {
-		var err error
-		t, err = fix(path, t)
+		fixed, err := fix(path, t)
 		if err != nil {
 			if err, ok := err.(*module.ModuleError); ok {
 				return "", &Error{
@@ -643,19 +699,23 @@ func parseVersion(verb string, path string, s *string, fix VersionFixer) (string
 			}
 			return "", err
 		}
+		t = fixed
+	} else {
+		cv := module.CanonicalVersion(t)
+		if cv == "" {
+			return "", &Error{
+				Verb:    verb,
+				ModPath: path,
+				Err: &module.InvalidVersionError{
+					Version: t,
+					Err:     errors.New("must be of the form v1.2.3"),
+				},
+			}
+		}
+		t = cv
 	}
-	if v := module.CanonicalVersion(t); v != "" {
-		*s = v
-		return *s, nil
-	}
-	return "", &Error{
-		Verb:    verb,
-		ModPath: path,
-		Err: &module.InvalidVersionError{
-			Version: t,
-			Err:     errors.New("must be of the form v1.2.3"),
-		},
-	}
+	*s = t
+	return *s, nil
 }
 
 func modulePathMajor(path string) (string, error) {
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 254cff70dd..03853007e0 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -28,7 +28,7 @@ golang.org/x/arch/x86/x86asm
 golang.org/x/crypto/ed25519
 golang.org/x/crypto/ed25519/internal/edwards25519
 golang.org/x/crypto/ssh/terminal
-# golang.org/x/mod v0.4.2-0.20210223202949-66f6d92cabd5
+# golang.org/x/mod v0.4.2-0.20210225160341-66bf157bf5bc
 ## explicit
 golang.org/x/mod/internal/lazyregexp
 golang.org/x/mod/modfile
-- 
GitLab


From 1f7a01459b1172fdc571a81ffd369dbf32b6c8b2 Mon Sep 17 00:00:00 2001
From: Andy Pan <panjf2000@gmail.com>
Date: Mon, 23 Nov 2020 15:42:48 +0800
Subject: [PATCH 0845/2400] runtime: batch moving gFree list between local p
 and global schedt

Change-Id: I0ca1fcee6d3f08bdfcfa51f0dc774118d7355636
Reviewed-on: https://go-review.googlesource.com/c/go/+/271914
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Austin Clements <austin@google.com>
---
 src/runtime/proc.go | 34 +++++++++++++++++++++++++---------
 1 file changed, 25 insertions(+), 9 deletions(-)

diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index dbb430fd25..19049d21f3 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -4170,17 +4170,25 @@ func gfput(_p_ *p, gp *g) {
 	_p_.gFree.push(gp)
 	_p_.gFree.n++
 	if _p_.gFree.n >= 64 {
-		lock(&sched.gFree.lock)
+		var (
+			inc      int32
+			stackQ   gQueue
+			noStackQ gQueue
+		)
 		for _p_.gFree.n >= 32 {
-			_p_.gFree.n--
 			gp = _p_.gFree.pop()
+			_p_.gFree.n--
 			if gp.stack.lo == 0 {
-				sched.gFree.noStack.push(gp)
+				noStackQ.push(gp)
 			} else {
-				sched.gFree.stack.push(gp)
+				stackQ.push(gp)
 			}
-			sched.gFree.n++
+			inc++
 		}
+		lock(&sched.gFree.lock)
+		sched.gFree.noStack.pushAll(noStackQ)
+		sched.gFree.stack.pushAll(stackQ)
+		sched.gFree.n += inc
 		unlock(&sched.gFree.lock)
 	}
 }
@@ -4232,17 +4240,25 @@ retry:
 
 // Purge all cached G's from gfree list to the global list.
 func gfpurge(_p_ *p) {
-	lock(&sched.gFree.lock)
+	var (
+		inc      int32
+		stackQ   gQueue
+		noStackQ gQueue
+	)
 	for !_p_.gFree.empty() {
 		gp := _p_.gFree.pop()
 		_p_.gFree.n--
 		if gp.stack.lo == 0 {
-			sched.gFree.noStack.push(gp)
+			noStackQ.push(gp)
 		} else {
-			sched.gFree.stack.push(gp)
+			stackQ.push(gp)
 		}
-		sched.gFree.n++
+		inc++
 	}
+	lock(&sched.gFree.lock)
+	sched.gFree.noStack.pushAll(noStackQ)
+	sched.gFree.stack.pushAll(stackQ)
+	sched.gFree.n += inc
 	unlock(&sched.gFree.lock)
 }
 
-- 
GitLab


From ee2a45e5fbee473b81c8ab81da8d83699d64e01f Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Wed, 24 Feb 2021 09:43:59 +0100
Subject: [PATCH 0846/2400] runtime: use pipe2 for nonblockingPipe on dragonfly

The pipe2 syscall is available since DragonflyBSD 4.2, see
https://www.dragonflybsd.org/release42/

Change-Id: Ifc67c4935cc59bae29be459167e2fa765843ac03
Reviewed-on: https://go-review.googlesource.com/c/go/+/295471
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/runtime/defs_dragonfly.go       |  4 ++++
 src/runtime/defs_dragonfly_amd64.go |  4 ++++
 src/runtime/export_pipe2_test.go    |  4 ++--
 src/runtime/export_pipe_test.go     |  4 ++--
 src/runtime/nbpipe_pipe.go          |  4 ++--
 src/runtime/nbpipe_pipe2.go         |  4 ++--
 src/runtime/os_dragonfly.go         |  5 +++--
 src/runtime/sys_dragonfly_amd64.s   | 18 ++++++++++++++++++
 8 files changed, 37 insertions(+), 10 deletions(-)

diff --git a/src/runtime/defs_dragonfly.go b/src/runtime/defs_dragonfly.go
index 225258901f..aca2bf9001 100644
--- a/src/runtime/defs_dragonfly.go
+++ b/src/runtime/defs_dragonfly.go
@@ -32,6 +32,10 @@ const (
 	EFAULT = C.EFAULT
 	EBUSY  = C.EBUSY
 	EAGAIN = C.EAGAIN
+	ENOSYS = C.ENOSYS
+
+	O_NONBLOCK = C.O_NONBLOCK
+	O_CLOEXEC  = C.O_CLOEXEC
 
 	PROT_NONE  = C.PROT_NONE
 	PROT_READ  = C.PROT_READ
diff --git a/src/runtime/defs_dragonfly_amd64.go b/src/runtime/defs_dragonfly_amd64.go
index 30f1b33845..f3c6ecd04b 100644
--- a/src/runtime/defs_dragonfly_amd64.go
+++ b/src/runtime/defs_dragonfly_amd64.go
@@ -10,6 +10,10 @@ const (
 	_EFAULT = 0xe
 	_EBUSY  = 0x10
 	_EAGAIN = 0x23
+	_ENOSYS = 0x4e
+
+	_O_NONBLOCK = 0x4
+	_O_CLOEXEC  = 0x20000
 
 	_PROT_NONE  = 0x0
 	_PROT_READ  = 0x1
diff --git a/src/runtime/export_pipe2_test.go b/src/runtime/export_pipe2_test.go
index 31c8e43b3f..26d8b7d185 100644
--- a/src/runtime/export_pipe2_test.go
+++ b/src/runtime/export_pipe2_test.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build freebsd || linux || netbsd || openbsd || solaris
-// +build freebsd linux netbsd openbsd solaris
+//go:build dragonfly || freebsd || linux || netbsd || openbsd || solaris
+// +build dragonfly freebsd linux netbsd openbsd solaris
 
 package runtime
 
diff --git a/src/runtime/export_pipe_test.go b/src/runtime/export_pipe_test.go
index 82032e6bfb..a0c6c0440d 100644
--- a/src/runtime/export_pipe_test.go
+++ b/src/runtime/export_pipe_test.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build aix || darwin || dragonfly
-// +build aix darwin dragonfly
+//go:build aix || darwin
+// +build aix darwin
 
 package runtime
 
diff --git a/src/runtime/nbpipe_pipe.go b/src/runtime/nbpipe_pipe.go
index d92cf97217..b17257e9ec 100644
--- a/src/runtime/nbpipe_pipe.go
+++ b/src/runtime/nbpipe_pipe.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build aix || darwin || dragonfly
-// +build aix darwin dragonfly
+//go:build aix || darwin
+// +build aix darwin
 
 package runtime
 
diff --git a/src/runtime/nbpipe_pipe2.go b/src/runtime/nbpipe_pipe2.go
index f138d1f956..f22b2b591f 100644
--- a/src/runtime/nbpipe_pipe2.go
+++ b/src/runtime/nbpipe_pipe2.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build freebsd || linux || netbsd || openbsd || solaris
-// +build freebsd linux netbsd openbsd solaris
+//go:build dragonfly || freebsd || linux || netbsd || openbsd || solaris
+// +build dragonfly freebsd linux netbsd openbsd solaris
 
 package runtime
 
diff --git a/src/runtime/os_dragonfly.go b/src/runtime/os_dragonfly.go
index 2e930b6e94..5c688a3109 100644
--- a/src/runtime/os_dragonfly.go
+++ b/src/runtime/os_dragonfly.go
@@ -60,10 +60,11 @@ func kqueue() int32
 
 //go:noescape
 func kevent(kq int32, ch *keventt, nch int32, ev *keventt, nev int32, ts *timespec) int32
-func closeonexec(fd int32)
-func setNonblock(fd int32)
 
 func pipe() (r, w int32, errno int32)
+func pipe2(flags int32) (r, w int32, errno int32)
+func closeonexec(fd int32)
+func setNonblock(fd int32)
 
 // From DragonFly's <sys/sysctl.h>
 const (
diff --git a/src/runtime/sys_dragonfly_amd64.s b/src/runtime/sys_dragonfly_amd64.s
index 580633af55..9cb268d740 100644
--- a/src/runtime/sys_dragonfly_amd64.s
+++ b/src/runtime/sys_dragonfly_amd64.s
@@ -123,6 +123,24 @@ pipeok:
 	MOVL	$0, errno+8(FP)
 	RET
 
+// func pipe2(flags int32) (r, w int32, errno int32)
+TEXT runtime·pipe2(SB),NOSPLIT,$0-20
+	MOVL	$0, DI
+	// dragonfly expects flags as the 2nd argument
+	MOVL	flags+0(FP), SI
+	MOVL	$538, AX
+	SYSCALL
+	JCC	pipe2ok
+	MOVL	$-1,r+8(FP)
+	MOVL	$-1,w+12(FP)
+	MOVL	AX, errno+16(FP)
+	RET
+pipe2ok:
+	MOVL	AX, r+8(FP)
+	MOVL	DX, w+12(FP)
+	MOVL	$0, errno+16(FP)
+	RET
+
 TEXT runtime·write1(SB),NOSPLIT,$-8
 	MOVQ	fd+0(FP), DI		// arg 1 fd
 	MOVQ	p+8(FP), SI		// arg 2 buf
-- 
GitLab


From 1a3e968b1fcb2082b1d99be563a7c9f8c61c66ba Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Sun, 21 Feb 2021 22:09:03 +0700
Subject: [PATCH 0847/2400] cmd/compile: fix mishandling of unsafe-uintptr
 arguments with call method in go/defer

In CL 253457, we did the same fix for direct function calls. But for
method calls, the receiver argument also need to be passed through the
wrapper function, which we are not doing so the compiler crashes with
the code in #44415.

As we already rewrite t.M(...) into T.M(t, ...) during walkCall1, to fix
this, we can do the same trick in wrapCall, so the receiver argument
will be treated as others.

Fixes #44415

Change-Id: I396182983c85d9c5e4494657da79d25636e8a079
Reviewed-on: https://go-review.googlesource.com/c/go/+/294849
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/walk/expr.go | 32 +++++++++++++++------------
 src/cmd/compile/internal/walk/stmt.go |  3 +++
 test/fixedbugs/issue24491a.go         | 30 +++++++++++++++++++++++++
 test/fixedbugs/issue44415.go          | 21 ++++++++++++++++++
 4 files changed, 72 insertions(+), 14 deletions(-)
 create mode 100644 test/fixedbugs/issue44415.go

diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 7b65db5100..ce95fbc2b4 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -503,21 +503,8 @@ func walkCall1(n *ir.CallExpr, init *ir.Nodes) {
 	}
 	n.SetWalked(true)
 
-	// If this is a method call t.M(...),
-	// rewrite into a function call T.M(t, ...).
 	// TODO(mdempsky): Do this right after type checking.
-	if n.Op() == ir.OCALLMETH {
-		withRecv := make([]ir.Node, len(n.Args)+1)
-		dot := n.X.(*ir.SelectorExpr)
-		withRecv[0] = dot.X
-		copy(withRecv[1:], n.Args)
-		n.Args = withRecv
-
-		dot = ir.NewSelectorExpr(dot.Pos(), ir.OXDOT, ir.TypeNode(dot.X.Type()), dot.Selection.Sym)
-
-		n.SetOp(ir.OCALLFUNC)
-		n.X = typecheck.Expr(dot)
-	}
+	rewriteMethodCall(n)
 
 	args := n.Args
 	params := n.X.Type().Params()
@@ -547,6 +534,23 @@ func walkCall1(n *ir.CallExpr, init *ir.Nodes) {
 	n.Args = args
 }
 
+// rewriteMethodCall rewrites a method call t.M(...) into a function call T.M(t, ...).
+func rewriteMethodCall(n *ir.CallExpr) {
+	if n.Op() != ir.OCALLMETH {
+		return
+	}
+	withRecv := make([]ir.Node, len(n.Args)+1)
+	dot := n.X.(*ir.SelectorExpr)
+	withRecv[0] = dot.X
+	copy(withRecv[1:], n.Args)
+	n.Args = withRecv
+
+	dot = ir.NewSelectorExpr(dot.Pos(), ir.OXDOT, ir.TypeNode(dot.X.Type()), dot.Selection.Sym)
+
+	n.SetOp(ir.OCALLFUNC)
+	n.X = typecheck.Expr(dot)
+}
+
 // walkDivMod walks an ODIV or OMOD node.
 func walkDivMod(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 	n.X = walkExpr(n.X, init)
diff --git a/src/cmd/compile/internal/walk/stmt.go b/src/cmd/compile/internal/walk/stmt.go
index 46a621c2ba..86f8819ec3 100644
--- a/src/cmd/compile/internal/walk/stmt.go
+++ b/src/cmd/compile/internal/walk/stmt.go
@@ -241,6 +241,9 @@ func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 		init.Append(ir.TakeInit(n)...)
 	}
 
+	// TODO(mdempsky): Do this right after type checking.
+	rewriteMethodCall(n)
+
 	isBuiltinCall := n.Op() != ir.OCALLFUNC && n.Op() != ir.OCALLMETH && n.Op() != ir.OCALLINTER
 
 	// Turn f(a, b, []T{c, d, e}...) back into f(a, b, c, d, e).
diff --git a/test/fixedbugs/issue24491a.go b/test/fixedbugs/issue24491a.go
index 8accf8c0a3..da734531a5 100644
--- a/test/fixedbugs/issue24491a.go
+++ b/test/fixedbugs/issue24491a.go
@@ -48,6 +48,30 @@ func f() int {
 	return test("return", uintptr(setup()), uintptr(setup()), uintptr(setup()), uintptr(setup()))
 }
 
+type S struct{}
+
+//go:noinline
+//go:uintptrescapes
+func (S) test(s string, p, q uintptr, rest ...uintptr) int {
+	runtime.GC()
+	runtime.GC()
+
+	if *(*string)(unsafe.Pointer(p)) != "ok" {
+		panic(s + ": p failed")
+	}
+	if *(*string)(unsafe.Pointer(q)) != "ok" {
+		panic(s + ": q failed")
+	}
+	for _, r := range rest {
+		if *(*string)(unsafe.Pointer(r)) != "ok" {
+			panic(s + ": r[i] failed")
+		}
+	}
+
+	done <- true
+	return 0
+}
+
 func main() {
 	test("normal", uintptr(setup()), uintptr(setup()), uintptr(setup()), uintptr(setup()))
 	<-done
@@ -60,6 +84,12 @@ func main() {
 	}()
 	<-done
 
+	func() {
+		s := &S{}
+		defer s.test("method call", uintptr(setup()), uintptr(setup()))
+	}()
+	<-done
+
 	f()
 	<-done
 }
diff --git a/test/fixedbugs/issue44415.go b/test/fixedbugs/issue44415.go
new file mode 100644
index 0000000000..26820a9f09
--- /dev/null
+++ b/test/fixedbugs/issue44415.go
@@ -0,0 +1,21 @@
+// compile
+
+// Copyright 2021 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.
+
+// +build windows
+
+package p
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+var dllKernel = syscall.NewLazyDLL("Kernel32.dll")
+
+func Call() {
+	procLocalFree := dllKernel.NewProc("LocalFree")
+	defer procLocalFree.Call(uintptr(unsafe.Pointer(nil)))
+}
-- 
GitLab


From 4ebb6f5110af3e60455d8751b996b958afb25a36 Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Thu, 7 Jan 2021 19:08:37 -0800
Subject: [PATCH 0848/2400] cmd/compile: automate resultInArg0 register checks

No functional changes; passes toolstash-check.
No measureable performance changes.

Change-Id: I2629f73d4a3cc56d80f512f33cf57cf41d8f15d3
Reviewed-on: https://go-review.googlesource.com/c/go/+/296010
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/amd64/ssa.go    | 76 ++++--------------------
 src/cmd/compile/internal/arm/ssa.go      |  3 -
 src/cmd/compile/internal/arm64/ssa.go    |  9 +--
 src/cmd/compile/internal/mips/ssa.go     |  9 ---
 src/cmd/compile/internal/mips64/ssa.go   |  3 -
 src/cmd/compile/internal/riscv64/ssa.go  |  3 -
 src/cmd/compile/internal/s390x/ssa.go    | 48 +++------------
 src/cmd/compile/internal/ssa/gen/main.go |  1 +
 src/cmd/compile/internal/ssa/opGen.go    |  1 +
 src/cmd/compile/internal/ssa/value.go    | 17 ++++++
 src/cmd/compile/internal/ssagen/ssa.go   |  4 ++
 src/cmd/compile/internal/x86/ssa.go      | 44 +++-----------
 12 files changed, 52 insertions(+), 166 deletions(-)

diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index 6944ba7ce7..230219a383 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -202,9 +202,6 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.From = obj.Addr{Type: obj.TYPE_REG, Reg: v.Args[2].Reg()}
 		p.To = obj.Addr{Type: obj.TYPE_REG, Reg: v.Reg()}
 		p.SetFrom3(obj.Addr{Type: obj.TYPE_REG, Reg: v.Args[1].Reg()})
-		if v.Reg() != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 	case ssa.OpAMD64ADDQ, ssa.OpAMD64ADDL:
 		r := v.Reg()
 		r1 := v.Args[0].Reg()
@@ -254,11 +251,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssa.OpAMD64BTSL, ssa.OpAMD64BTSQ,
 		ssa.OpAMD64BTCL, ssa.OpAMD64BTCQ,
 		ssa.OpAMD64BTRL, ssa.OpAMD64BTRQ:
-		r := v.Reg()
-		if r != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
-		opregreg(s, v.Op.Asm(), r, v.Args[1].Reg())
+		opregreg(s, v.Op.Asm(), v.Reg(), v.Args[1].Reg())
 
 	case ssa.OpAMD64DIVQU, ssa.OpAMD64DIVLU, ssa.OpAMD64DIVWU:
 		// Arg[0] (the dividend) is in AX.
@@ -401,20 +394,16 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		// compute (x+y)/2 unsigned.
 		// Do a 64-bit add, the overflow goes into the carry.
 		// Shift right once and pull the carry back into the 63rd bit.
-		r := v.Reg()
-		if r != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 		p := s.Prog(x86.AADDQ)
 		p.From.Type = obj.TYPE_REG
 		p.To.Type = obj.TYPE_REG
-		p.To.Reg = r
+		p.To.Reg = v.Reg()
 		p.From.Reg = v.Args[1].Reg()
 		p = s.Prog(x86.ARCRQ)
 		p.From.Type = obj.TYPE_CONST
 		p.From.Offset = 1
 		p.To.Type = obj.TYPE_REG
-		p.To.Reg = r
+		p.To.Reg = v.Reg()
 
 	case ssa.OpAMD64ADDQcarry, ssa.OpAMD64ADCQ:
 		r := v.Reg0()
@@ -530,21 +519,13 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssa.OpAMD64CMOVQCS, ssa.OpAMD64CMOVLCS, ssa.OpAMD64CMOVWCS,
 		ssa.OpAMD64CMOVQGTF, ssa.OpAMD64CMOVLGTF, ssa.OpAMD64CMOVWGTF,
 		ssa.OpAMD64CMOVQGEF, ssa.OpAMD64CMOVLGEF, ssa.OpAMD64CMOVWGEF:
-		r := v.Reg()
-		if r != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = v.Args[1].Reg()
 		p.To.Type = obj.TYPE_REG
-		p.To.Reg = r
+		p.To.Reg = v.Reg()
 
 	case ssa.OpAMD64CMOVQNEF, ssa.OpAMD64CMOVLNEF, ssa.OpAMD64CMOVWNEF:
-		r := v.Reg()
-		if r != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 		// Flag condition: ^ZERO || PARITY
 		// Generate:
 		//   CMOV*NE  SRC,DST
@@ -553,7 +534,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = v.Args[1].Reg()
 		p.To.Type = obj.TYPE_REG
-		p.To.Reg = r
+		p.To.Reg = v.Reg()
 		var q *obj.Prog
 		if v.Op == ssa.OpAMD64CMOVQNEF {
 			q = s.Prog(x86.ACMOVQPS)
@@ -565,14 +546,9 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		q.From.Type = obj.TYPE_REG
 		q.From.Reg = v.Args[1].Reg()
 		q.To.Type = obj.TYPE_REG
-		q.To.Reg = r
+		q.To.Reg = v.Reg()
 
 	case ssa.OpAMD64CMOVQEQF, ssa.OpAMD64CMOVLEQF, ssa.OpAMD64CMOVWEQF:
-		r := v.Reg()
-		if r != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
-
 		// Flag condition: ZERO && !PARITY
 		// Generate:
 		//   MOV      SRC,AX
@@ -589,7 +565,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		}
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_REG
-		p.From.Reg = r
+		p.From.Reg = v.Reg()
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = x86.REG_AX
 		var q *obj.Prog
@@ -603,7 +579,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		q.From.Type = obj.TYPE_REG
 		q.From.Reg = x86.REG_AX
 		q.To.Type = obj.TYPE_REG
-		q.To.Reg = r
+		q.To.Reg = v.Reg()
 
 	case ssa.OpAMD64MULQconst, ssa.OpAMD64MULLconst:
 		r := v.Reg()
@@ -622,15 +598,11 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssa.OpAMD64SHRQconst, ssa.OpAMD64SHRLconst, ssa.OpAMD64SHRWconst, ssa.OpAMD64SHRBconst,
 		ssa.OpAMD64SARQconst, ssa.OpAMD64SARLconst, ssa.OpAMD64SARWconst, ssa.OpAMD64SARBconst,
 		ssa.OpAMD64ROLQconst, ssa.OpAMD64ROLLconst, ssa.OpAMD64ROLWconst, ssa.OpAMD64ROLBconst:
-		r := v.Reg()
-		if r != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 		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 = r
+		p.To.Reg = v.Reg()
 	case ssa.OpAMD64SBBQcarrymask, ssa.OpAMD64SBBLcarrymask:
 		r := v.Reg()
 		p := s.Prog(v.Op.Asm())
@@ -913,9 +885,6 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
-		if v.Reg() != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 	case ssa.OpAMD64ADDLloadidx1, ssa.OpAMD64ADDLloadidx4, ssa.OpAMD64ADDLloadidx8, ssa.OpAMD64ADDQloadidx1, ssa.OpAMD64ADDQloadidx8,
 		ssa.OpAMD64SUBLloadidx1, ssa.OpAMD64SUBLloadidx4, ssa.OpAMD64SUBLloadidx8, ssa.OpAMD64SUBQloadidx1, ssa.OpAMD64SUBQloadidx8,
 		ssa.OpAMD64ANDLloadidx1, ssa.OpAMD64ANDLloadidx4, ssa.OpAMD64ANDLloadidx8, ssa.OpAMD64ANDQloadidx1, ssa.OpAMD64ANDQloadidx8,
@@ -939,9 +908,6 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
-		if v.Reg() != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 	case ssa.OpAMD64DUFFZERO:
 		if s.ABI != obj.ABIInternal {
 			v.Fatalf("MOVOconst can be only used in ABIInternal functions")
@@ -1078,22 +1044,14 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 	case ssa.OpAMD64NEGQ, ssa.OpAMD64NEGL,
 		ssa.OpAMD64BSWAPQ, ssa.OpAMD64BSWAPL,
 		ssa.OpAMD64NOTQ, ssa.OpAMD64NOTL:
-		r := v.Reg()
-		if r != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 		p := s.Prog(v.Op.Asm())
 		p.To.Type = obj.TYPE_REG
-		p.To.Reg = r
+		p.To.Reg = v.Reg()
 
 	case ssa.OpAMD64NEGLflags:
-		r := v.Reg0()
-		if r != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 		p := s.Prog(v.Op.Asm())
 		p.To.Type = obj.TYPE_REG
-		p.To.Reg = r
+		p.To.Reg = v.Reg0()
 
 	case ssa.OpAMD64BSFQ, ssa.OpAMD64BSRQ, ssa.OpAMD64BSFL, ssa.OpAMD64BSRL, ssa.OpAMD64SQRTSD:
 		p := s.Prog(v.Op.Asm())
@@ -1214,25 +1172,17 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg0()
 	case ssa.OpAMD64XCHGB, ssa.OpAMD64XCHGL, ssa.OpAMD64XCHGQ:
-		r := v.Reg0()
-		if r != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output[0] not in same register %s", v.LongString())
-		}
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_REG
-		p.From.Reg = r
+		p.From.Reg = v.Reg0()
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[1].Reg()
 		ssagen.AddAux(&p.To, v)
 	case ssa.OpAMD64XADDLlock, ssa.OpAMD64XADDQlock:
-		r := v.Reg0()
-		if r != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output[0] not in same register %s", v.LongString())
-		}
 		s.Prog(x86.ALOCK)
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_REG
-		p.From.Reg = r
+		p.From.Reg = v.Reg0()
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[1].Reg()
 		ssagen.AddAux(&p.To, v)
diff --git a/src/cmd/compile/internal/arm/ssa.go b/src/cmd/compile/internal/arm/ssa.go
index 729d2dab2d..6cbdf4377d 100644
--- a/src/cmd/compile/internal/arm/ssa.go
+++ b/src/cmd/compile/internal/arm/ssa.go
@@ -173,9 +173,6 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = y
 	case ssa.OpARMMOVWnop:
-		if v.Reg() != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 		// nothing to do
 	case ssa.OpLoadReg:
 		if v.Type.IsFlags() {
diff --git a/src/cmd/compile/internal/arm64/ssa.go b/src/cmd/compile/internal/arm64/ssa.go
index ca5eac72bf..2576aeb600 100644
--- a/src/cmd/compile/internal/arm64/ssa.go
+++ b/src/cmd/compile/internal/arm64/ssa.go
@@ -142,9 +142,6 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = y
 	case ssa.OpARM64MOVDnop:
-		if v.Reg() != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 		// nothing to do
 	case ssa.OpLoadReg:
 		if v.Type.IsFlags() {
@@ -522,17 +519,13 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssagen.AddAux(&p.To, v)
 	case ssa.OpARM64BFI,
 		ssa.OpARM64BFXIL:
-		r := v.Reg()
-		if r != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_CONST
 		p.From.Offset = v.AuxInt >> 8
 		p.SetFrom3(obj.Addr{Type: obj.TYPE_CONST, Offset: v.AuxInt & 0xff})
 		p.Reg = v.Args[1].Reg()
 		p.To.Type = obj.TYPE_REG
-		p.To.Reg = r
+		p.To.Reg = v.Reg()
 	case ssa.OpARM64SBFIZ,
 		ssa.OpARM64SBFX,
 		ssa.OpARM64UBFIZ,
diff --git a/src/cmd/compile/internal/mips/ssa.go b/src/cmd/compile/internal/mips/ssa.go
index f1cdbd3241..115e3cb8e2 100644
--- a/src/cmd/compile/internal/mips/ssa.go
+++ b/src/cmd/compile/internal/mips/ssa.go
@@ -112,9 +112,6 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 			p.To.Reg = y
 		}
 	case ssa.OpMIPSMOVWnop:
-		if v.Reg() != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 		// nothing to do
 	case ssa.OpLoadReg:
 		if v.Type.IsFlags() {
@@ -244,9 +241,6 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.OpMIPSCMOVZ:
-		if v.Reg() != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = v.Args[2].Reg()
@@ -254,9 +248,6 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.OpMIPSCMOVZzero:
-		if v.Reg() != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = v.Args[1].Reg()
diff --git a/src/cmd/compile/internal/mips64/ssa.go b/src/cmd/compile/internal/mips64/ssa.go
index 14cf7af143..d9c47751e1 100644
--- a/src/cmd/compile/internal/mips64/ssa.go
+++ b/src/cmd/compile/internal/mips64/ssa.go
@@ -115,9 +115,6 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 			p.To.Reg = y
 		}
 	case ssa.OpMIPS64MOVVnop:
-		if v.Reg() != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 		// nothing to do
 	case ssa.OpLoadReg:
 		if v.Type.IsFlags() {
diff --git a/src/cmd/compile/internal/riscv64/ssa.go b/src/cmd/compile/internal/riscv64/ssa.go
index 70c29a4b7b..0a3064323a 100644
--- a/src/cmd/compile/internal/riscv64/ssa.go
+++ b/src/cmd/compile/internal/riscv64/ssa.go
@@ -211,9 +211,6 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = rd
 	case ssa.OpRISCV64MOVDnop:
-		if v.Reg() != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 		// nothing to do
 	case ssa.OpLoadReg:
 		if v.Type.IsFlags() {
diff --git a/src/cmd/compile/internal/s390x/ssa.go b/src/cmd/compile/internal/s390x/ssa.go
index d4c7a286e2..0c65f7a238 100644
--- a/src/cmd/compile/internal/s390x/ssa.go
+++ b/src/cmd/compile/internal/s390x/ssa.go
@@ -175,10 +175,6 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 			p.Reg = r1
 		}
 	case ssa.OpS390XRXSBG:
-		r1 := v.Reg()
-		if r1 != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 		r2 := v.Args[1].Reg()
 		i := v.Aux.(s390x.RotateParams)
 		p := s.Prog(v.Op.Asm())
@@ -188,7 +184,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 			{Type: obj.TYPE_CONST, Offset: int64(i.Amount)},
 			{Type: obj.TYPE_REG, Reg: r2},
 		})
-		p.To = obj.Addr{Type: obj.TYPE_REG, Reg: r1}
+		p.To = obj.Addr{Type: obj.TYPE_REG, Reg: v.Reg()}
 	case ssa.OpS390XRISBGZ:
 		r1 := v.Reg()
 		r2 := v.Args[0].Reg()
@@ -233,12 +229,8 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 			p.Reg = r2
 		}
 	case ssa.OpS390XADDE, ssa.OpS390XSUBE:
-		r1 := v.Reg0()
-		if r1 != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 		r2 := v.Args[1].Reg()
-		opregreg(s, v.Op.Asm(), r1, r2)
+		opregreg(s, v.Op.Asm(), v.Reg0(), r2)
 	case ssa.OpS390XADDCconst:
 		r1 := v.Reg0()
 		r3 := v.Args[0].Reg()
@@ -248,18 +240,10 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 	case ssa.OpS390XMULLD, ssa.OpS390XMULLW,
 		ssa.OpS390XMULHD, ssa.OpS390XMULHDU,
 		ssa.OpS390XFMULS, ssa.OpS390XFMUL, ssa.OpS390XFDIVS, ssa.OpS390XFDIV:
-		r := v.Reg()
-		if r != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
-		opregreg(s, v.Op.Asm(), r, v.Args[1].Reg())
+		opregreg(s, v.Op.Asm(), v.Reg(), v.Args[1].Reg())
 	case ssa.OpS390XFSUBS, ssa.OpS390XFSUB,
 		ssa.OpS390XFADDS, ssa.OpS390XFADD:
-		r := v.Reg0()
-		if r != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
-		opregreg(s, v.Op.Asm(), r, v.Args[1].Reg())
+		opregreg(s, v.Op.Asm(), v.Reg0(), v.Args[1].Reg())
 	case ssa.OpS390XMLGR:
 		// MLGR Rx R3 -> R2:R3
 		r0 := v.Args[0].Reg()
@@ -274,10 +258,6 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Type = obj.TYPE_REG
 	case ssa.OpS390XFMADD, ssa.OpS390XFMADDS,
 		ssa.OpS390XFMSUB, ssa.OpS390XFMSUBS:
-		r := v.Reg()
-		if r != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 		r1 := v.Args[1].Reg()
 		r2 := v.Args[2].Reg()
 		p := s.Prog(v.Op.Asm())
@@ -285,7 +265,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.From.Reg = r1
 		p.Reg = r2
 		p.To.Type = obj.TYPE_REG
-		p.To.Reg = r
+		p.To.Reg = v.Reg()
 	case ssa.OpS390XFIDBR:
 		switch v.AuxInt {
 		case 0, 1, 3, 4, 5, 6, 7:
@@ -361,15 +341,11 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssa.OpS390XANDconst, ssa.OpS390XANDWconst,
 		ssa.OpS390XORconst, ssa.OpS390XORWconst,
 		ssa.OpS390XXORconst, ssa.OpS390XXORWconst:
-		r := v.Reg()
-		if r != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 		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 = r
+		p.To.Reg = v.Reg()
 	case ssa.OpS390XSLDconst, ssa.OpS390XSLWconst,
 		ssa.OpS390XSRDconst, ssa.OpS390XSRWconst,
 		ssa.OpS390XSRADconst, ssa.OpS390XSRAWconst,
@@ -441,16 +417,12 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssa.OpS390XANDWload, ssa.OpS390XANDload,
 		ssa.OpS390XORWload, ssa.OpS390XORload,
 		ssa.OpS390XXORWload, ssa.OpS390XXORload:
-		r := v.Reg()
-		if r != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[1].Reg()
 		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
-		p.To.Reg = r
+		p.To.Reg = v.Reg()
 	case ssa.OpS390XMOVDload,
 		ssa.OpS390XMOVWZload, ssa.OpS390XMOVHZload, ssa.OpS390XMOVBZload,
 		ssa.OpS390XMOVDBRload, ssa.OpS390XMOVWBRload, ssa.OpS390XMOVHBRload,
@@ -608,16 +580,12 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 	case ssa.OpS390XSumBytes2, ssa.OpS390XSumBytes4, ssa.OpS390XSumBytes8:
 		v.Fatalf("SumBytes generated %s", v.LongString())
 	case ssa.OpS390XLOCGR:
-		r := v.Reg()
-		if r != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_CONST
 		p.From.Offset = int64(v.Aux.(s390x.CCMask))
 		p.Reg = v.Args[1].Reg()
 		p.To.Type = obj.TYPE_REG
-		p.To.Reg = r
+		p.To.Reg = v.Reg()
 	case ssa.OpS390XFSQRT:
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_REG
diff --git a/src/cmd/compile/internal/ssa/gen/main.go b/src/cmd/compile/internal/ssa/gen/main.go
index f5385389c3..8e5997b25a 100644
--- a/src/cmd/compile/internal/ssa/gen/main.go
+++ b/src/cmd/compile/internal/ssa/gen/main.go
@@ -407,6 +407,7 @@ func genOp() {
 	fmt.Fprintln(w, "func (o Op) IsCall() bool { return opcodeTable[o].call }")
 	fmt.Fprintln(w, "func (o Op) HasSideEffects() bool { return opcodeTable[o].hasSideEffects }")
 	fmt.Fprintln(w, "func (o Op) UnsafePoint() bool { return opcodeTable[o].unsafePoint }")
+	fmt.Fprintln(w, "func (o Op) ResultInArg0() bool { return opcodeTable[o].resultInArg0 }")
 
 	// generate registers
 	for _, a := range archs {
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index 551aa725b6..10ea57b36b 100644
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -36193,6 +36193,7 @@ func (o Op) SymEffect() SymEffect { return opcodeTable[o].symEffect }
 func (o Op) IsCall() bool         { return opcodeTable[o].call }
 func (o Op) HasSideEffects() bool { return opcodeTable[o].hasSideEffects }
 func (o Op) UnsafePoint() bool    { return opcodeTable[o].unsafePoint }
+func (o Op) ResultInArg0() bool   { return opcodeTable[o].resultInArg0 }
 
 var registers386 = [...]Register{
 	{0, x86.REG_AX, 0, "AX"},
diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go
index 6539631b9c..55e4b684c1 100644
--- a/src/cmd/compile/internal/ssa/value.go
+++ b/src/cmd/compile/internal/ssa/value.go
@@ -411,6 +411,23 @@ func (v *Value) isGenericIntConst() bool {
 	return v != nil && (v.Op == OpConst64 || v.Op == OpConst32 || v.Op == OpConst16 || v.Op == OpConst8)
 }
 
+// ResultReg returns the result register assigned to v, in cmd/internal/obj/$ARCH numbering.
+// It is similar to Reg and Reg0, except that it is usable interchangeably for all Value Ops.
+// If you know v.Op, using Reg or Reg0 (as appropriate) will be more efficient.
+func (v *Value) ResultReg() int16 {
+	reg := v.Block.Func.RegAlloc[v.ID]
+	if reg == nil {
+		v.Fatalf("nil reg for value: %s\n%s\n", v.LongString(), v.Block.Func)
+	}
+	if pair, ok := reg.(LocPair); ok {
+		reg = pair[0]
+	}
+	if reg == nil {
+		v.Fatalf("nil reg0 for value: %s\n%s\n", v.LongString(), v.Block.Func)
+	}
+	return reg.(*Register).objNum
+}
+
 // Reg returns the register assigned to v, in cmd/internal/obj/$ARCH numbering.
 func (v *Value) Reg() int16 {
 	reg := v.Block.Func.RegAlloc[v.ID]
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index d69eb17ca9..20acdbdc66 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -6509,6 +6509,10 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 			x := s.pp.Next
 			s.DebugFriendlySetPosFrom(v)
 
+			if v.Op.ResultInArg0() && v.ResultReg() != v.Args[0].Reg() {
+				v.Fatalf("input[0] and output not in same register %s", v.LongString())
+			}
+
 			switch v.Op {
 			case ssa.OpInitMem:
 				// memory arg needs no code
diff --git a/src/cmd/compile/internal/x86/ssa.go b/src/cmd/compile/internal/x86/ssa.go
index 00dfa07bf7..c5fe3ae2e2 100644
--- a/src/cmd/compile/internal/x86/ssa.go
+++ b/src/cmd/compile/internal/x86/ssa.go
@@ -161,31 +161,19 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssa.Op386PXOR,
 		ssa.Op386ADCL,
 		ssa.Op386SBBL:
-		r := v.Reg()
-		if r != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
-		opregreg(s, v.Op.Asm(), r, v.Args[1].Reg())
+		opregreg(s, v.Op.Asm(), v.Reg(), v.Args[1].Reg())
 
 	case ssa.Op386ADDLcarry, ssa.Op386SUBLcarry:
 		// output 0 is carry/borrow, output 1 is the low 32 bits.
-		r := v.Reg0()
-		if r != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output[0] not in same register %s", v.LongString())
-		}
-		opregreg(s, v.Op.Asm(), r, v.Args[1].Reg())
+		opregreg(s, v.Op.Asm(), v.Reg0(), v.Args[1].Reg())
 
 	case ssa.Op386ADDLconstcarry, ssa.Op386SUBLconstcarry:
 		// output 0 is carry/borrow, output 1 is the low 32 bits.
-		r := v.Reg0()
-		if r != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output[0] not in same register %s", v.LongString())
-		}
 		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 = r
+		p.To.Reg = v.Reg0()
 
 	case ssa.Op386DIVL, ssa.Op386DIVW,
 		ssa.Op386DIVLU, ssa.Op386DIVWU,
@@ -306,20 +294,16 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		// compute (x+y)/2 unsigned.
 		// Do a 32-bit add, the overflow goes into the carry.
 		// Shift right once and pull the carry back into the 31st bit.
-		r := v.Reg()
-		if r != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 		p := s.Prog(x86.AADDL)
 		p.From.Type = obj.TYPE_REG
 		p.To.Type = obj.TYPE_REG
-		p.To.Reg = r
+		p.To.Reg = v.Reg()
 		p.From.Reg = v.Args[1].Reg()
 		p = s.Prog(x86.ARCRL)
 		p.From.Type = obj.TYPE_CONST
 		p.From.Offset = 1
 		p.To.Type = obj.TYPE_REG
-		p.To.Reg = r
+		p.To.Reg = v.Reg()
 
 	case ssa.Op386ADDLconst:
 		r := v.Reg()
@@ -370,15 +354,11 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssa.Op386SHRLconst, ssa.Op386SHRWconst, ssa.Op386SHRBconst,
 		ssa.Op386SARLconst, ssa.Op386SARWconst, ssa.Op386SARBconst,
 		ssa.Op386ROLLconst, ssa.Op386ROLWconst, ssa.Op386ROLBconst:
-		r := v.Reg()
-		if r != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 		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 = r
+		p.To.Reg = v.Reg()
 	case ssa.Op386SBBLcarrymask:
 		r := v.Reg()
 		p := s.Prog(v.Op.Asm())
@@ -536,9 +516,6 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
-		if v.Reg() != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 	case ssa.Op386ADDLload, ssa.Op386SUBLload, ssa.Op386MULLload,
 		ssa.Op386ANDLload, ssa.Op386ORLload, ssa.Op386XORLload,
 		ssa.Op386ADDSDload, ssa.Op386ADDSSload, ssa.Op386SUBSDload, ssa.Op386SUBSSload,
@@ -549,9 +526,6 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
-		if v.Reg() != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 	case ssa.Op386MOVSSstore, ssa.Op386MOVSDstore, ssa.Op386MOVLstore, ssa.Op386MOVWstore, ssa.Op386MOVBstore,
 		ssa.Op386ADDLmodify, ssa.Op386SUBLmodify, ssa.Op386ANDLmodify, ssa.Op386ORLmodify, ssa.Op386XORLmodify:
 		p := s.Prog(v.Op.Asm())
@@ -781,13 +755,9 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 	case ssa.Op386NEGL,
 		ssa.Op386BSWAPL,
 		ssa.Op386NOTL:
-		r := v.Reg()
-		if r != v.Args[0].Reg() {
-			v.Fatalf("input[0] and output not in same register %s", v.LongString())
-		}
 		p := s.Prog(v.Op.Asm())
 		p.To.Type = obj.TYPE_REG
-		p.To.Reg = r
+		p.To.Reg = v.Reg()
 	case ssa.Op386BSFL, ssa.Op386BSFW,
 		ssa.Op386BSRL, ssa.Op386BSRW,
 		ssa.Op386SQRTSD:
-- 
GitLab


From 194b636f8f1ff7d6b709b5b9010d1d14b3919e66 Mon Sep 17 00:00:00 2001
From: Ivan Trubach <mr.trubach@icloud.com>
Date: Thu, 25 Feb 2021 19:15:04 +0000
Subject: [PATCH 0849/2400] database/sql: close driver.Connector if it
 implements io.Closer

This change allows driver implementations to manage resources in
driver.Connector, e.g. to share the same underlying database handle
between multiple connections. That is, it allows embedded databases
with in-memory backends like SQLite and Genji to safely release the
resources once the sql.DB is closed.

This makes it possible to address oddities with in-memory stores in
SQLite and Genji drivers without introducing too much complexity in
the driver implementations.

See also:
- https://github.com/mattn/go-sqlite3/issues/204
- https://github.com/mattn/go-sqlite3/issues/511
- https://github.com/genjidb/genji/issues/210

Fixes #41790

Change-Id: Idbd19763134438ed38288b9d44f16608e4e97fd7
GitHub-Last-Rev: 962c785dfb3bb6ad98b2216bcedd84ba383fe872
GitHub-Pull-Request: golang/go#41710
Reviewed-on: https://go-review.googlesource.com/c/go/+/258360
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Daniel Theophanes <kardianos@gmail.com>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/database/sql/driver/driver.go |  3 +++
 src/database/sql/fakedb_test.go   |  9 +++++++++
 src/database/sql/sql.go           |  6 ++++++
 src/database/sql/sql_test.go      | 11 ++++++++++-
 4 files changed, 28 insertions(+), 1 deletion(-)

diff --git a/src/database/sql/driver/driver.go b/src/database/sql/driver/driver.go
index 5bbcf20db2..f09396175a 100644
--- a/src/database/sql/driver/driver.go
+++ b/src/database/sql/driver/driver.go
@@ -115,6 +115,9 @@ type DriverContext interface {
 // DriverContext's OpenConnector method, to allow drivers
 // access to context and to avoid repeated parsing of driver
 // configuration.
+//
+// If a Connector implements io.Closer, the sql package's DB.Close
+// method will call Close and return error (if any).
 type Connector interface {
 	// Connect returns a connection to the database.
 	// Connect may return a cached connection (one previously
diff --git a/src/database/sql/fakedb_test.go b/src/database/sql/fakedb_test.go
index 7605a2a6d2..1bfd1118aa 100644
--- a/src/database/sql/fakedb_test.go
+++ b/src/database/sql/fakedb_test.go
@@ -56,6 +56,7 @@ type fakeConnector struct {
 	name string
 
 	waiter func(context.Context)
+	closed bool
 }
 
 func (c *fakeConnector) Connect(context.Context) (driver.Conn, error) {
@@ -68,6 +69,14 @@ func (c *fakeConnector) Driver() driver.Driver {
 	return fdriver
 }
 
+func (c *fakeConnector) Close() error {
+	if c.closed {
+		return errors.New("fakedb: connector is closed")
+	}
+	c.closed = true
+	return nil
+}
+
 type fakeDriverCtx struct {
 	fakeDriver
 }
diff --git a/src/database/sql/sql.go b/src/database/sql/sql.go
index 726aadb899..37bcb0d091 100644
--- a/src/database/sql/sql.go
+++ b/src/database/sql/sql.go
@@ -850,6 +850,12 @@ func (db *DB) Close() error {
 		}
 	}
 	db.stop()
+	if c, ok := db.connector.(io.Closer); ok {
+		err1 := c.Close()
+		if err1 != nil {
+			err = err1
+		}
+	}
 	return err
 }
 
diff --git a/src/database/sql/sql_test.go b/src/database/sql/sql_test.go
index 99bfd62491..c06e565ea9 100644
--- a/src/database/sql/sql_test.go
+++ b/src/database/sql/sql_test.go
@@ -4059,9 +4059,18 @@ func TestOpenConnector(t *testing.T) {
 	}
 	defer db.Close()
 
-	if _, is := db.connector.(*fakeConnector); !is {
+	c, ok := db.connector.(*fakeConnector)
+	if !ok {
 		t.Fatal("not using *fakeConnector")
 	}
+
+	if err := db.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	if !c.closed {
+		t.Fatal("connector is not closed")
+	}
 }
 
 type ctxOnlyDriver struct {
-- 
GitLab


From 526ee96f4992ff3a1e1c219fe8dc9870098bacba Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Fri, 6 Nov 2020 17:37:03 -0800
Subject: [PATCH 0850/2400] os: avoid allocation in File.WriteString

Instead of alloc+copy to convert the string
to a byte slice, do an unsafe conversion.

Rely on the kernel not to scribble on the
buffer during the write.

Fixes #42406

Change-Id: I66f4838b43a11bcc3d67bbfa1706726318d55343
Reviewed-on: https://go-review.googlesource.com/c/go/+/268020
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/os/file.go    |  9 ++++++++-
 src/os/os_test.go | 18 ++++++++++++++++++
 2 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/src/os/file.go b/src/os/file.go
index 52dd94339b..ebeb0d0ac9 100644
--- a/src/os/file.go
+++ b/src/os/file.go
@@ -44,11 +44,13 @@ import (
 	"errors"
 	"internal/poll"
 	"internal/testlog"
+	"internal/unsafeheader"
 	"io"
 	"io/fs"
 	"runtime"
 	"syscall"
 	"time"
+	"unsafe"
 )
 
 // Name returns the name of the file as presented to Open.
@@ -246,7 +248,12 @@ func (f *File) Seek(offset int64, whence int) (ret int64, err error) {
 // WriteString is like Write, but writes the contents of string s rather than
 // a slice of bytes.
 func (f *File) WriteString(s string) (n int, err error) {
-	return f.Write([]byte(s))
+	var b []byte
+	hdr := (*unsafeheader.Slice)(unsafe.Pointer(&b))
+	hdr.Data = (*unsafeheader.String)(unsafe.Pointer(&s)).Data
+	hdr.Cap = len(s)
+	hdr.Len = len(s)
+	return f.Write(b)
 }
 
 // Mkdir creates a new directory with the specified name and permission
diff --git a/src/os/os_test.go b/src/os/os_test.go
index a32e5fc11e..f27c796c05 100644
--- a/src/os/os_test.go
+++ b/src/os/os_test.go
@@ -2773,3 +2773,21 @@ func TestReadFileProc(t *testing.T) {
 		t.Fatalf("read %s: not newline-terminated: %q", name, data)
 	}
 }
+
+func TestWriteStringAlloc(t *testing.T) {
+	if runtime.GOOS == "js" {
+		t.Skip("js allocates a lot during File.WriteString")
+	}
+	d := t.TempDir()
+	f, err := Create(filepath.Join(d, "whiteboard.txt"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f.Close()
+	allocs := testing.AllocsPerRun(100, func() {
+		f.WriteString("I will not allocate when passed a string longer than 32 bytes.\n")
+	})
+	if allocs != 0 {
+		t.Errorf("expected 0 allocs for File.WriteString, got %v", allocs)
+	}
+}
-- 
GitLab


From 6c3bcda866582b51842d71576a11c0fe1b647a22 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 17 Feb 2021 17:49:40 -0800
Subject: [PATCH 0851/2400] cmd/compile: declare inlined result params early
 for empty returns

The code for delayed declaration of inlined result parameters only
handles non-empty return statements. This is generally okay, because
we already early declare if there are any (non-blank) named result
parameters.

But if a user writes a function with only blank result parameters and
with exactly one return statement, which is empty, then they could end
up hitting the dreaded "Value live at entry" ICE.

This CL fixes the issue by ensuring we always early declare inlined
result parameters if there are any empty return statements.

Fixes #44355.

Change-Id: I315f3853be436452883b1ce31da1bdffdf24d506
Reviewed-on: https://go-review.googlesource.com/c/go/+/293293
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/inline/inl.go | 20 ++++++++++++++------
 test/fixedbugs/issue44355.dir/a.go     |  7 +++++++
 test/fixedbugs/issue44355.dir/b.go     |  9 +++++++++
 test/fixedbugs/issue44355.go           |  7 +++++++
 4 files changed, 37 insertions(+), 6 deletions(-)
 create mode 100644 test/fixedbugs/issue44355.dir/a.go
 create mode 100644 test/fixedbugs/issue44355.dir/b.go
 create mode 100644 test/fixedbugs/issue44355.go

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index fe6509e4c9..1703be74e9 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -852,17 +852,25 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 		}
 	}
 
+	// We can delay declaring+initializing result parameters if:
+	// (1) there's exactly one "return" statement in the inlined function;
+	// (2) it's not an empty return statement (#44355); and
+	// (3) the result parameters aren't named.
+	delayretvars := true
+
 	nreturns := 0
 	ir.VisitList(ir.Nodes(fn.Inl.Body), func(n ir.Node) {
-		if n != nil && n.Op() == ir.ORETURN {
+		if n, ok := n.(*ir.ReturnStmt); ok {
 			nreturns++
+			if len(n.Results) == 0 {
+				delayretvars = false // empty return statement (case 2)
+			}
 		}
 	})
 
-	// We can delay declaring+initializing result parameters if:
-	// (1) there's only one "return" statement in the inlined
-	// function, and (2) the result parameters aren't named.
-	delayretvars := nreturns == 1
+	if nreturns != 1 {
+		delayretvars = false // not exactly one return statement (case 1)
+	}
 
 	// temporaries for return values.
 	var retvars []ir.Node
@@ -873,7 +881,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 			m = inlvar(n)
 			m = typecheck.Expr(m).(*ir.Name)
 			inlvars[n] = m
-			delayretvars = false // found a named result parameter
+			delayretvars = false // found a named result parameter (case 3)
 		} else {
 			// anonymous return values, synthesize names for use in assignment that replaces return
 			m = retvar(t, i)
diff --git a/test/fixedbugs/issue44355.dir/a.go b/test/fixedbugs/issue44355.dir/a.go
new file mode 100644
index 0000000000..0f63c6fd98
--- /dev/null
+++ b/test/fixedbugs/issue44355.dir/a.go
@@ -0,0 +1,7 @@
+// Copyright 2021 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 a
+
+func F() (_ *int) { return nil }
diff --git a/test/fixedbugs/issue44355.dir/b.go b/test/fixedbugs/issue44355.dir/b.go
new file mode 100644
index 0000000000..09d5bde887
--- /dev/null
+++ b/test/fixedbugs/issue44355.dir/b.go
@@ -0,0 +1,9 @@
+// Copyright 2021 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 b
+
+import "./a"
+
+var _ = a.F()
diff --git a/test/fixedbugs/issue44355.go b/test/fixedbugs/issue44355.go
new file mode 100644
index 0000000000..d406838588
--- /dev/null
+++ b/test/fixedbugs/issue44355.go
@@ -0,0 +1,7 @@
+// compiledir
+
+// Copyright 2021 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 ignored
-- 
GitLab


From 7fcf9893f71c75f6b2fd53bea326d5061f705208 Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Thu, 25 Feb 2021 09:58:05 -0800
Subject: [PATCH 0852/2400] cmd/internal/obj: fix typo in docs

Change-Id: I5a3d26a4cc59b327d46ca24bcb01ef594758c230
Reviewed-on: https://go-review.googlesource.com/c/go/+/296531
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/cmd/internal/obj/link.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/internal/obj/link.go b/src/cmd/internal/obj/link.go
index a48db3bdc8..a24461cef2 100644
--- a/src/cmd/internal/obj/link.go
+++ b/src/cmd/internal/obj/link.go
@@ -360,7 +360,7 @@ func (p *Prog) SetFrom3(a Addr) {
 	p.RestArgs = []AddrPos{{a, Source}}
 }
 
-// SetTo2 assings []Args{{a, 1}} to p.RestArgs when the second destination
+// SetTo2 assigns []Args{{a, 1}} to p.RestArgs when the second destination
 // operand does not fit into prog.RegTo2.
 func (p *Prog) SetTo2(a Addr) {
 	p.RestArgs = []AddrPos{{a, Destination}}
-- 
GitLab


From b83d073e9eb4cbd0cd5ca530f576668c49f6d0f1 Mon Sep 17 00:00:00 2001
From: Joe Tsai <joetsai@digital-static.net>
Date: Wed, 14 Oct 2020 18:41:16 -0700
Subject: [PATCH 0853/2400] reflect: add Method.IsExported and
 StructField.IsExported methods

The IsExported method is a more intuitive helper for checking whether
the method or field is exported than checking whether PkgPath is empty.

In the same CL, modify the standard library to make use of this helper.

Fixes #41563

Change-Id: Iaacfb3b74449501f98e2707aa32095a32bd3c3c1
Reviewed-on: https://go-review.googlesource.com/c/go/+/266197
Trust: Joe Tsai <joetsai@digital-static.net>
Run-TryBot: Joe Tsai <thebrokentoaster@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/encoding/asn1/asn1.go    |  2 +-
 src/encoding/asn1/marshal.go |  2 +-
 src/encoding/json/encode.go  |  5 ++--
 src/encoding/xml/typeinfo.go |  2 +-
 src/net/rpc/server.go        |  2 +-
 src/reflect/all_test.go      | 55 ++++++++++++++++++++++++++++++------
 src/reflect/type.go          | 19 ++++++++++---
 src/text/template/exec.go    |  2 +-
 8 files changed, 68 insertions(+), 21 deletions(-)

diff --git a/src/encoding/asn1/asn1.go b/src/encoding/asn1/asn1.go
index f9b9cb4930..cffc06dc9c 100644
--- a/src/encoding/asn1/asn1.go
+++ b/src/encoding/asn1/asn1.go
@@ -914,7 +914,7 @@ func parseField(v reflect.Value, bytes []byte, initOffset int, params fieldParam
 		structType := fieldType
 
 		for i := 0; i < structType.NumField(); i++ {
-			if structType.Field(i).PkgPath != "" {
+			if !structType.Field(i).IsExported() {
 				err = StructuralError{"struct contains unexported fields"}
 				return
 			}
diff --git a/src/encoding/asn1/marshal.go b/src/encoding/asn1/marshal.go
index 0d34d5aa1e..5b4d786d49 100644
--- a/src/encoding/asn1/marshal.go
+++ b/src/encoding/asn1/marshal.go
@@ -488,7 +488,7 @@ func makeBody(value reflect.Value, params fieldParameters) (e encoder, err error
 		t := v.Type()
 
 		for i := 0; i < t.NumField(); i++ {
-			if t.Field(i).PkgPath != "" {
+			if !t.Field(i).IsExported() {
 				return nil, StructuralError{"struct contains unexported fields"}
 			}
 		}
diff --git a/src/encoding/json/encode.go b/src/encoding/json/encode.go
index 483b9d8f2d..751f03d33d 100644
--- a/src/encoding/json/encode.go
+++ b/src/encoding/json/encode.go
@@ -1239,19 +1239,18 @@ func typeFields(t reflect.Type) structFields {
 			// Scan f.typ for fields to include.
 			for i := 0; i < f.typ.NumField(); i++ {
 				sf := f.typ.Field(i)
-				isUnexported := sf.PkgPath != ""
 				if sf.Anonymous {
 					t := sf.Type
 					if t.Kind() == reflect.Ptr {
 						t = t.Elem()
 					}
-					if isUnexported && t.Kind() != reflect.Struct {
+					if !sf.IsExported() && t.Kind() != reflect.Struct {
 						// Ignore embedded fields of unexported non-struct types.
 						continue
 					}
 					// Do not ignore embedded fields of unexported struct types
 					// since they may have exported fields.
-				} else if isUnexported {
+				} else if !sf.IsExported() {
 					// Ignore unexported non-embedded fields.
 					continue
 				}
diff --git a/src/encoding/xml/typeinfo.go b/src/encoding/xml/typeinfo.go
index f30fe58590..162724ef1a 100644
--- a/src/encoding/xml/typeinfo.go
+++ b/src/encoding/xml/typeinfo.go
@@ -60,7 +60,7 @@ func getTypeInfo(typ reflect.Type) (*typeInfo, error) {
 		n := typ.NumField()
 		for i := 0; i < n; i++ {
 			f := typ.Field(i)
-			if (f.PkgPath != "" && !f.Anonymous) || f.Tag.Get("xml") == "-" {
+			if (!f.IsExported() && !f.Anonymous) || f.Tag.Get("xml") == "-" {
 				continue // Private field
 			}
 
diff --git a/src/net/rpc/server.go b/src/net/rpc/server.go
index 9cb928240f..074c5b9b0d 100644
--- a/src/net/rpc/server.go
+++ b/src/net/rpc/server.go
@@ -283,7 +283,7 @@ func suitableMethods(typ reflect.Type, reportErr bool) map[string]*methodType {
 		mtype := method.Type
 		mname := method.Name
 		// Method must be exported.
-		if method.PkgPath != "" {
+		if !method.IsExported() {
 			continue
 		}
 		// Method needs three ins: receiver, *args, *reply.
diff --git a/src/reflect/all_test.go b/src/reflect/all_test.go
index 1225d6177d..35cc469d74 100644
--- a/src/reflect/all_test.go
+++ b/src/reflect/all_test.go
@@ -2900,6 +2900,7 @@ func TestFieldPkgPath(t *testing.T) {
 		index    []int
 		pkgPath  string
 		embedded bool
+		exported bool
 	}
 
 	checkPkgPath := func(name string, s []pkgpathTest) {
@@ -2911,27 +2912,63 @@ func TestFieldPkgPath(t *testing.T) {
 			if got, want := f.Anonymous, test.embedded; got != want {
 				t.Errorf("%s: Field(%d).Anonymous = %v, want %v", name, test.index, got, want)
 			}
+			if got, want := f.IsExported(), test.exported; got != want {
+				t.Errorf("%s: Field(%d).IsExported = %v, want %v", name, test.index, got, want)
+			}
 		}
 	}
 
 	checkPkgPath("testStruct", []pkgpathTest{
-		{[]int{0}, "", false},             // Exported
-		{[]int{1}, "reflect_test", false}, // unexported
-		{[]int{2}, "", true},              // OtherPkgFields
-		{[]int{2, 0}, "", false},          // OtherExported
-		{[]int{2, 1}, "reflect", false},   // otherUnexported
-		{[]int{3}, "reflect_test", true},  // int
-		{[]int{4}, "reflect_test", true},  // *x
+		{[]int{0}, "", false, true},              // Exported
+		{[]int{1}, "reflect_test", false, false}, // unexported
+		{[]int{2}, "", true, true},               // OtherPkgFields
+		{[]int{2, 0}, "", false, true},           // OtherExported
+		{[]int{2, 1}, "reflect", false, false},   // otherUnexported
+		{[]int{3}, "reflect_test", true, false},  // int
+		{[]int{4}, "reflect_test", true, false},  // *x
 	})
 
 	type localOtherPkgFields OtherPkgFields
 	typ = TypeOf(localOtherPkgFields{})
 	checkPkgPath("localOtherPkgFields", []pkgpathTest{
-		{[]int{0}, "", false},        // OtherExported
-		{[]int{1}, "reflect", false}, // otherUnexported
+		{[]int{0}, "", false, true},         // OtherExported
+		{[]int{1}, "reflect", false, false}, // otherUnexported
 	})
 }
 
+func TestMethodPkgPath(t *testing.T) {
+	type I interface {
+		x()
+		X()
+	}
+	typ := TypeOf((*interface {
+		I
+		y()
+		Y()
+	})(nil)).Elem()
+
+	tests := []struct {
+		name     string
+		pkgPath  string
+		exported bool
+	}{
+		{"X", "", true},
+		{"Y", "", true},
+		{"x", "reflect_test", false},
+		{"y", "reflect_test", false},
+	}
+
+	for _, test := range tests {
+		m, _ := typ.MethodByName(test.name)
+		if got, want := m.PkgPath, test.pkgPath; got != want {
+			t.Errorf("MethodByName(%q).PkgPath = %q, want %q", test.name, got, want)
+		}
+		if got, want := m.IsExported(), test.exported; got != want {
+			t.Errorf("MethodByName(%q).IsExported = %v, want %v", test.name, got, want)
+		}
+	}
+}
+
 func TestVariadicType(t *testing.T) {
 	// Test example from Type documentation.
 	var f func(x int, y ...float64)
diff --git a/src/reflect/type.go b/src/reflect/type.go
index eb2030063a..dc235ea8f7 100644
--- a/src/reflect/type.go
+++ b/src/reflect/type.go
@@ -568,12 +568,13 @@ func newName(n, tag string, exported bool) name {
 // Method represents a single method.
 type Method struct {
 	// Name is the method name.
+	Name string
+
 	// PkgPath is the package path that qualifies a lower case (unexported)
 	// method name. It is empty for upper case (exported) method names.
 	// The combination of PkgPath and Name uniquely identifies a method
 	// in a method set.
 	// See https://golang.org/ref/spec#Uniqueness_of_identifiers
-	Name    string
 	PkgPath string
 
 	Type  Type  // method type
@@ -581,6 +582,11 @@ type Method struct {
 	Index int   // index for Type.Method
 }
 
+// IsExported reports whether the method is exported.
+func (m Method) IsExported() bool {
+	return m.PkgPath == ""
+}
+
 const (
 	kindDirectIface = 1 << 5
 	kindGCProg      = 1 << 6 // Type.gc points to GC program
@@ -1090,6 +1096,7 @@ func (t *interfaceType) MethodByName(name string) (m Method, ok bool) {
 type StructField struct {
 	// Name is the field name.
 	Name string
+
 	// PkgPath is the package path that qualifies a lower case (unexported)
 	// field name. It is empty for upper case (exported) field names.
 	// See https://golang.org/ref/spec#Uniqueness_of_identifiers
@@ -1102,6 +1109,11 @@ type StructField struct {
 	Anonymous bool      // is an embedded field
 }
 
+// IsExported reports whether the field is exported.
+func (f StructField) IsExported() bool {
+	return f.PkgPath == ""
+}
+
 // A StructTag is the tag string in a struct field.
 //
 // By convention, tag strings are a concatenation of
@@ -2771,8 +2783,7 @@ func runtimeStructField(field StructField) (structField, string) {
 		panic("reflect.StructOf: field \"" + field.Name + "\" is anonymous but has PkgPath set")
 	}
 
-	exported := field.PkgPath == ""
-	if exported {
+	if field.IsExported() {
 		// Best-effort check for misuse.
 		// Since this field will be treated as exported, not much harm done if Unicode lowercase slips through.
 		c := field.Name[0]
@@ -2788,7 +2799,7 @@ func runtimeStructField(field StructField) (structField, string) {
 
 	resolveReflectType(field.Type.common()) // install in runtime
 	f := structField{
-		name:        newName(field.Name, string(field.Tag), exported),
+		name:        newName(field.Name, string(field.Tag), field.IsExported()),
 		typ:         field.Type.common(),
 		offsetEmbed: offsetEmbed,
 	}
diff --git a/src/text/template/exec.go b/src/text/template/exec.go
index 19154fc640..4637b2035f 100644
--- a/src/text/template/exec.go
+++ b/src/text/template/exec.go
@@ -615,7 +615,7 @@ func (s *state) evalField(dot reflect.Value, fieldName string, node parse.Node,
 		tField, ok := receiver.Type().FieldByName(fieldName)
 		if ok {
 			field := receiver.FieldByIndex(tField.Index)
-			if tField.PkgPath != "" { // field is unexported
+			if !tField.IsExported() {
 				s.errorf("%s is an unexported field of struct type %s", fieldName, typ)
 			}
 			// If it's a function, we must call it.
-- 
GitLab


From 9a7fe196e468c687ad7239b9447c584826331771 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 25 Feb 2021 21:32:29 +0000
Subject: [PATCH 0854/2400] Revert "cmd/compile: fix mishandling of
 unsafe-uintptr arguments with call method in go/defer"

This reverts commit CL 294849.

Reason for revert: this doesn't actually fix the issue, as revealed
by the noopt builder's failures.

Change-Id: Ib4ea9ceb4d75e46b3b91ec348b365fd8c83316ad
Reviewed-on: https://go-review.googlesource.com/c/go/+/296629
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/compile/internal/walk/expr.go | 32 ++++++++++++---------------
 src/cmd/compile/internal/walk/stmt.go |  3 ---
 test/fixedbugs/issue24491a.go         | 30 -------------------------
 test/fixedbugs/issue44415.go          | 21 ------------------
 4 files changed, 14 insertions(+), 72 deletions(-)
 delete mode 100644 test/fixedbugs/issue44415.go

diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index ce95fbc2b4..7b65db5100 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -503,8 +503,21 @@ func walkCall1(n *ir.CallExpr, init *ir.Nodes) {
 	}
 	n.SetWalked(true)
 
+	// If this is a method call t.M(...),
+	// rewrite into a function call T.M(t, ...).
 	// TODO(mdempsky): Do this right after type checking.
-	rewriteMethodCall(n)
+	if n.Op() == ir.OCALLMETH {
+		withRecv := make([]ir.Node, len(n.Args)+1)
+		dot := n.X.(*ir.SelectorExpr)
+		withRecv[0] = dot.X
+		copy(withRecv[1:], n.Args)
+		n.Args = withRecv
+
+		dot = ir.NewSelectorExpr(dot.Pos(), ir.OXDOT, ir.TypeNode(dot.X.Type()), dot.Selection.Sym)
+
+		n.SetOp(ir.OCALLFUNC)
+		n.X = typecheck.Expr(dot)
+	}
 
 	args := n.Args
 	params := n.X.Type().Params()
@@ -534,23 +547,6 @@ func walkCall1(n *ir.CallExpr, init *ir.Nodes) {
 	n.Args = args
 }
 
-// rewriteMethodCall rewrites a method call t.M(...) into a function call T.M(t, ...).
-func rewriteMethodCall(n *ir.CallExpr) {
-	if n.Op() != ir.OCALLMETH {
-		return
-	}
-	withRecv := make([]ir.Node, len(n.Args)+1)
-	dot := n.X.(*ir.SelectorExpr)
-	withRecv[0] = dot.X
-	copy(withRecv[1:], n.Args)
-	n.Args = withRecv
-
-	dot = ir.NewSelectorExpr(dot.Pos(), ir.OXDOT, ir.TypeNode(dot.X.Type()), dot.Selection.Sym)
-
-	n.SetOp(ir.OCALLFUNC)
-	n.X = typecheck.Expr(dot)
-}
-
 // walkDivMod walks an ODIV or OMOD node.
 func walkDivMod(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 	n.X = walkExpr(n.X, init)
diff --git a/src/cmd/compile/internal/walk/stmt.go b/src/cmd/compile/internal/walk/stmt.go
index 86f8819ec3..46a621c2ba 100644
--- a/src/cmd/compile/internal/walk/stmt.go
+++ b/src/cmd/compile/internal/walk/stmt.go
@@ -241,9 +241,6 @@ func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 		init.Append(ir.TakeInit(n)...)
 	}
 
-	// TODO(mdempsky): Do this right after type checking.
-	rewriteMethodCall(n)
-
 	isBuiltinCall := n.Op() != ir.OCALLFUNC && n.Op() != ir.OCALLMETH && n.Op() != ir.OCALLINTER
 
 	// Turn f(a, b, []T{c, d, e}...) back into f(a, b, c, d, e).
diff --git a/test/fixedbugs/issue24491a.go b/test/fixedbugs/issue24491a.go
index da734531a5..8accf8c0a3 100644
--- a/test/fixedbugs/issue24491a.go
+++ b/test/fixedbugs/issue24491a.go
@@ -48,30 +48,6 @@ func f() int {
 	return test("return", uintptr(setup()), uintptr(setup()), uintptr(setup()), uintptr(setup()))
 }
 
-type S struct{}
-
-//go:noinline
-//go:uintptrescapes
-func (S) test(s string, p, q uintptr, rest ...uintptr) int {
-	runtime.GC()
-	runtime.GC()
-
-	if *(*string)(unsafe.Pointer(p)) != "ok" {
-		panic(s + ": p failed")
-	}
-	if *(*string)(unsafe.Pointer(q)) != "ok" {
-		panic(s + ": q failed")
-	}
-	for _, r := range rest {
-		if *(*string)(unsafe.Pointer(r)) != "ok" {
-			panic(s + ": r[i] failed")
-		}
-	}
-
-	done <- true
-	return 0
-}
-
 func main() {
 	test("normal", uintptr(setup()), uintptr(setup()), uintptr(setup()), uintptr(setup()))
 	<-done
@@ -84,12 +60,6 @@ func main() {
 	}()
 	<-done
 
-	func() {
-		s := &S{}
-		defer s.test("method call", uintptr(setup()), uintptr(setup()))
-	}()
-	<-done
-
 	f()
 	<-done
 }
diff --git a/test/fixedbugs/issue44415.go b/test/fixedbugs/issue44415.go
deleted file mode 100644
index 26820a9f09..0000000000
--- a/test/fixedbugs/issue44415.go
+++ /dev/null
@@ -1,21 +0,0 @@
-// compile
-
-// Copyright 2021 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.
-
-// +build windows
-
-package p
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-var dllKernel = syscall.NewLazyDLL("Kernel32.dll")
-
-func Call() {
-	procLocalFree := dllKernel.NewProc("LocalFree")
-	defer procLocalFree.Call(uintptr(unsafe.Pointer(nil)))
-}
-- 
GitLab


From 5f15af111cb40c3ac154be88288abd381e6f61e2 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 15 Jan 2021 09:48:39 -0500
Subject: [PATCH 0855/2400] syscall: comment on fields omitted from the
 win32finddata1 struct

Updates #42637

Change-Id: I4c7d38034b60c2c04efdeb530a97d96deddfd6fe
Reviewed-on: https://go-review.googlesource.com/c/go/+/284152
Trust: Bryan C. Mills <bcmills@google.com>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Trust: Alex Brainman <alex.brainman@gmail.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
---
 src/syscall/types_windows.go | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/syscall/types_windows.go b/src/syscall/types_windows.go
index 0349f3b180..5fef5c9477 100644
--- a/src/syscall/types_windows.go
+++ b/src/syscall/types_windows.go
@@ -398,6 +398,14 @@ type win32finddata1 struct {
 	Reserved1         uint32
 	FileName          [MAX_PATH]uint16
 	AlternateFileName [14]uint16
+
+	// The Microsoft documentation for this struct¹ describes three additional
+	// fields: dwFileType, dwCreatorType, and wFinderFlags. However, those fields
+	// are empirically only present in the macOS port of the Win32 API,² and thus
+	// not needed for binaries built for Windows.
+	//
+	// ¹ https://docs.microsoft.com/en-us/windows/win32/api/minwinbase/ns-minwinbase-win32_find_dataw
+	// ² https://golang.org/issue/42637#issuecomment-760715755
 }
 
 func copyFindData(dst *Win32finddata, src *win32finddata1) {
-- 
GitLab


From a61524d1033632f733f69bf6635e767d70d95cdd Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Thu, 7 Jan 2021 14:01:29 -0800
Subject: [PATCH 0856/2400] cmd/internal/obj: add Prog.SetFrom3{Reg,Const}

These are the the most common uses, and they reduce line noise.

I don't love adding new deprecated APIs,
but since they're trivial wrappers,
it'll be very easy to update them along with the rest.
No functional changes; passes toolstash-check.

Change-Id: I691a8175cfef9081180e463c63f326376af3f3a6
Reviewed-on: https://go-review.googlesource.com/c/go/+/296009
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/asm/internal/asm/asm.go       |  5 +----
 src/cmd/compile/internal/amd64/ssa.go |  6 +++---
 src/cmd/compile/internal/arm/ssa.go   |  4 ++--
 src/cmd/compile/internal/arm64/ssa.go | 10 +++++-----
 src/cmd/compile/internal/ppc64/ssa.go | 22 +++++++++++-----------
 src/cmd/compile/internal/s390x/ssa.go |  8 ++++----
 src/cmd/compile/internal/x86/ssa.go   |  2 +-
 src/cmd/internal/obj/link.go          | 14 ++++++++++++++
 8 files changed, 41 insertions(+), 30 deletions(-)

diff --git a/src/cmd/asm/internal/asm/asm.go b/src/cmd/asm/internal/asm/asm.go
index c4032759bb..06867cd507 100644
--- a/src/cmd/asm/internal/asm/asm.go
+++ b/src/cmd/asm/internal/asm/asm.go
@@ -811,10 +811,7 @@ func (p *Parser) asmInstruction(op obj.As, cond string, a []obj.Addr) {
 			} else {
 				mask = (^uint32(0) >> uint(mask2+1)) & (^uint32(0) << uint(31-(mask1-1)))
 			}
-			prog.SetFrom3(obj.Addr{
-				Type:   obj.TYPE_CONST,
-				Offset: int64(mask),
-			})
+			prog.SetFrom3Const(int64(mask))
 			prog.To = a[4]
 			break
 		}
diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index 230219a383..32cb0a9368 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -201,7 +201,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From = obj.Addr{Type: obj.TYPE_REG, Reg: v.Args[2].Reg()}
 		p.To = obj.Addr{Type: obj.TYPE_REG, Reg: v.Reg()}
-		p.SetFrom3(obj.Addr{Type: obj.TYPE_REG, Reg: v.Args[1].Reg()})
+		p.SetFrom3Reg(v.Args[1].Reg())
 	case ssa.OpAMD64ADDQ, ssa.OpAMD64ADDL:
 		r := v.Reg()
 		r1 := v.Args[0].Reg()
@@ -588,7 +588,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.From.Offset = v.AuxInt
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = r
-		p.SetFrom3(obj.Addr{Type: obj.TYPE_REG, Reg: v.Args[0].Reg()})
+		p.SetFrom3Reg(v.Args[0].Reg())
 
 	case ssa.OpAMD64SUBQconst, ssa.OpAMD64SUBLconst,
 		ssa.OpAMD64ANDQconst, ssa.OpAMD64ANDLconst,
@@ -1073,7 +1073,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		}
 		p.From.Offset = val
 		p.From.Type = obj.TYPE_CONST
-		p.SetFrom3(obj.Addr{Type: obj.TYPE_REG, Reg: v.Args[0].Reg()})
+		p.SetFrom3Reg(v.Args[0].Reg())
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.OpAMD64POPCNTQ, ssa.OpAMD64POPCNTL:
diff --git a/src/cmd/compile/internal/arm/ssa.go b/src/cmd/compile/internal/arm/ssa.go
index 6cbdf4377d..c4d8cbf149 100644
--- a/src/cmd/compile/internal/arm/ssa.go
+++ b/src/cmd/compile/internal/arm/ssa.go
@@ -279,7 +279,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_CONST
 		p.From.Offset = v.AuxInt >> 8
-		p.SetFrom3(obj.Addr{Type: obj.TYPE_CONST, Offset: v.AuxInt & 0xff})
+		p.SetFrom3Const(v.AuxInt & 0xff)
 		p.Reg = v.Args[0].Reg()
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
@@ -299,7 +299,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 				p := s.Prog(arm.ABFC)
 				p.From.Type = obj.TYPE_CONST
 				p.From.Offset = int64(width)
-				p.SetFrom3(obj.Addr{Type: obj.TYPE_CONST, Offset: int64(lsb)})
+				p.SetFrom3Const(int64(lsb))
 				p.To.Type = obj.TYPE_REG
 				p.To.Reg = v.Reg()
 				break
diff --git a/src/cmd/compile/internal/arm64/ssa.go b/src/cmd/compile/internal/arm64/ssa.go
index 2576aeb600..5067d92dfe 100644
--- a/src/cmd/compile/internal/arm64/ssa.go
+++ b/src/cmd/compile/internal/arm64/ssa.go
@@ -229,7 +229,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.Reg = ra
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = rm
-		p.SetFrom3(obj.Addr{Type: obj.TYPE_REG, Reg: rn})
+		p.SetFrom3Reg(rn)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = rt
 	case ssa.OpARM64ADDconst,
@@ -292,7 +292,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_CONST
 		p.From.Offset = v.AuxInt
-		p.SetFrom3(obj.Addr{Type: obj.TYPE_REG, Reg: v.Args[0].Reg()})
+		p.SetFrom3Reg(v.Args[0].Reg())
 		p.Reg = v.Args[1].Reg()
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
@@ -522,7 +522,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_CONST
 		p.From.Offset = v.AuxInt >> 8
-		p.SetFrom3(obj.Addr{Type: obj.TYPE_CONST, Offset: v.AuxInt & 0xff})
+		p.SetFrom3Const(v.AuxInt & 0xff)
 		p.Reg = v.Args[1].Reg()
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
@@ -533,7 +533,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_CONST
 		p.From.Offset = v.AuxInt >> 8
-		p.SetFrom3(obj.Addr{Type: obj.TYPE_CONST, Offset: v.AuxInt & 0xff})
+		p.SetFrom3Const(v.AuxInt & 0xff)
 		p.Reg = v.Args[0].Reg()
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
@@ -952,7 +952,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.From.Type = obj.TYPE_REG // assembler encodes conditional bits in Reg
 		p.From.Reg = condBits[ssa.Op(v.AuxInt)]
 		p.Reg = v.Args[0].Reg()
-		p.SetFrom3(obj.Addr{Type: obj.TYPE_REG, Reg: r1})
+		p.SetFrom3Reg(r1)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.OpARM64DUFFZERO:
diff --git a/src/cmd/compile/internal/ppc64/ssa.go b/src/cmd/compile/internal/ppc64/ssa.go
index c85e110ed3..f984079c4b 100644
--- a/src/cmd/compile/internal/ppc64/ssa.go
+++ b/src/cmd/compile/internal/ppc64/ssa.go
@@ -419,7 +419,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		// If it is a Compare-and-Swap-Release operation, set the EH field with
 		// the release hint.
 		if v.AuxInt == 0 {
-			p.SetFrom3(obj.Addr{Type: obj.TYPE_CONST, Offset: 0})
+			p.SetFrom3Const(0)
 		}
 		// CMP reg1,reg2
 		p1 := s.Prog(cmp)
@@ -586,7 +586,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		// clrlslwi ra,rs,mb,sh will become rlwinm ra,rs,sh,mb-sh,31-sh as described in ISA
 		p.From = obj.Addr{Type: obj.TYPE_CONST, Offset: ssa.GetPPC64Shiftmb(shifts)}
-		p.SetFrom3(obj.Addr{Type: obj.TYPE_CONST, Offset: ssa.GetPPC64Shiftsh(shifts)})
+		p.SetFrom3Const(ssa.GetPPC64Shiftsh(shifts))
 		p.Reg = r1
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = r
@@ -598,7 +598,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		// clrlsldi ra,rs,mb,sh will become rldic ra,rs,sh,mb-sh
 		p.From = obj.Addr{Type: obj.TYPE_CONST, Offset: ssa.GetPPC64Shiftmb(shifts)}
-		p.SetFrom3(obj.Addr{Type: obj.TYPE_CONST, Offset: ssa.GetPPC64Shiftsh(shifts)})
+		p.SetFrom3Const(ssa.GetPPC64Shiftsh(shifts))
 		p.Reg = r1
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = r
@@ -610,7 +610,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		shifts := v.AuxInt
 		p := s.Prog(v.Op.Asm())
 		p.From = obj.Addr{Type: obj.TYPE_CONST, Offset: ssa.GetPPC64Shiftsh(shifts)}
-		p.SetFrom3(obj.Addr{Type: obj.TYPE_CONST, Offset: ssa.GetPPC64Shiftmb(shifts)})
+		p.SetFrom3Const(ssa.GetPPC64Shiftmb(shifts))
 		p.Reg = r1
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = r
@@ -658,7 +658,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To = obj.Addr{Type: obj.TYPE_REG, Reg: v.Reg()}
 		p.Reg = v.Args[0].Reg()
 		p.From = obj.Addr{Type: obj.TYPE_CONST, Offset: int64(rot)}
-		p.SetFrom3(obj.Addr{Type: obj.TYPE_CONST, Offset: int64(mask)})
+		p.SetFrom3Const(int64(mask))
 
 		// Auxint holds mask
 	case ssa.OpPPC64RLWNM:
@@ -667,7 +667,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To = obj.Addr{Type: obj.TYPE_REG, Reg: v.Reg()}
 		p.Reg = v.Args[0].Reg()
 		p.From = obj.Addr{Type: obj.TYPE_REG, Reg: v.Args[1].Reg()}
-		p.SetFrom3(obj.Addr{Type: obj.TYPE_CONST, Offset: int64(mask)})
+		p.SetFrom3Const(int64(mask))
 
 	case ssa.OpPPC64MADDLD:
 		r := v.Reg()
@@ -679,7 +679,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = r1
 		p.Reg = r2
-		p.SetFrom3(obj.Addr{Type: obj.TYPE_REG, Reg: r3})
+		p.SetFrom3Reg(r3)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = r
 
@@ -693,7 +693,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = r1
 		p.Reg = r3
-		p.SetFrom3(obj.Addr{Type: obj.TYPE_REG, Reg: r2})
+		p.SetFrom3Reg(r2)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = r
 
@@ -720,7 +720,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 
 	case ssa.OpPPC64SUBFCconst:
 		p := s.Prog(v.Op.Asm())
-		p.SetFrom3(obj.Addr{Type: obj.TYPE_CONST, Offset: v.AuxInt})
+		p.SetFrom3Const(v.AuxInt)
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = v.Args[0].Reg()
 		p.To.Type = obj.TYPE_REG
@@ -910,7 +910,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		// AuxInt values 4,5,6 implemented with reverse operand order from 0,1,2
 		if v.AuxInt > 3 {
 			p.Reg = r.Reg
-			p.SetFrom3(obj.Addr{Type: obj.TYPE_REG, Reg: v.Args[0].Reg()})
+			p.SetFrom3Reg(v.Args[0].Reg())
 		} else {
 			p.Reg = v.Args[0].Reg()
 			p.SetFrom3(r)
@@ -1784,7 +1784,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		pp.To.Reg = ppc64.REG_LR
 
 		// Insert a hint this is not a subroutine return.
-		pp.SetFrom3(obj.Addr{Type: obj.TYPE_CONST, Offset: 1})
+		pp.SetFrom3Const(1)
 
 		if base.Ctxt.Flag_shared {
 			// When compiling Go into PIC, the function we just
diff --git a/src/cmd/compile/internal/s390x/ssa.go b/src/cmd/compile/internal/s390x/ssa.go
index 0c65f7a238..4830d902c2 100644
--- a/src/cmd/compile/internal/s390x/ssa.go
+++ b/src/cmd/compile/internal/s390x/ssa.go
@@ -894,7 +894,7 @@ func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
 		p.From.Type = obj.TYPE_CONST
 		p.From.Offset = int64(s390x.NotEqual & s390x.NotUnordered) // unordered is not possible
 		p.Reg = s390x.REG_R3
-		p.SetFrom3(obj.Addr{Type: obj.TYPE_CONST, Offset: 0})
+		p.SetFrom3Const(0)
 		if b.Succs[0].Block() != next {
 			s.Br(s390x.ABR, b.Succs[0].Block())
 		}
@@ -937,17 +937,17 @@ func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
 		p.From.Type = obj.TYPE_CONST
 		p.From.Offset = int64(mask & s390x.NotUnordered) // unordered is not possible
 		p.Reg = b.Controls[0].Reg()
-		p.SetFrom3(obj.Addr{Type: obj.TYPE_REG, Reg: b.Controls[1].Reg()})
+		p.SetFrom3Reg(b.Controls[1].Reg())
 	case ssa.BlockS390XCGIJ, ssa.BlockS390XCIJ:
 		p.From.Type = obj.TYPE_CONST
 		p.From.Offset = int64(mask & s390x.NotUnordered) // unordered is not possible
 		p.Reg = b.Controls[0].Reg()
-		p.SetFrom3(obj.Addr{Type: obj.TYPE_CONST, Offset: int64(int8(b.AuxInt))})
+		p.SetFrom3Const(int64(int8(b.AuxInt)))
 	case ssa.BlockS390XCLGIJ, ssa.BlockS390XCLIJ:
 		p.From.Type = obj.TYPE_CONST
 		p.From.Offset = int64(mask & s390x.NotUnordered) // unordered is not possible
 		p.Reg = b.Controls[0].Reg()
-		p.SetFrom3(obj.Addr{Type: obj.TYPE_CONST, Offset: int64(uint8(b.AuxInt))})
+		p.SetFrom3Const(int64(uint8(b.AuxInt)))
 	default:
 		b.Fatalf("branch not implemented: %s", b.LongString())
 	}
diff --git a/src/cmd/compile/internal/x86/ssa.go b/src/cmd/compile/internal/x86/ssa.go
index c5fe3ae2e2..4d134c6926 100644
--- a/src/cmd/compile/internal/x86/ssa.go
+++ b/src/cmd/compile/internal/x86/ssa.go
@@ -342,7 +342,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.From.Offset = v.AuxInt
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = r
-		p.SetFrom3(obj.Addr{Type: obj.TYPE_REG, Reg: v.Args[0].Reg()})
+		p.SetFrom3Reg(v.Args[0].Reg())
 
 	case ssa.Op386SUBLconst,
 		ssa.Op386ADCLconst,
diff --git a/src/cmd/internal/obj/link.go b/src/cmd/internal/obj/link.go
index a24461cef2..c74de779d2 100644
--- a/src/cmd/internal/obj/link.go
+++ b/src/cmd/internal/obj/link.go
@@ -360,6 +360,20 @@ func (p *Prog) SetFrom3(a Addr) {
 	p.RestArgs = []AddrPos{{a, Source}}
 }
 
+// SetFrom3Reg calls p.SetFrom3 with a register Addr containing reg.
+//
+// Deprecated: for the same reasons as Prog.GetFrom3.
+func (p *Prog) SetFrom3Reg(reg int16) {
+	p.SetFrom3(Addr{Type: TYPE_REG, Reg: reg})
+}
+
+// SetFrom3Const calls p.SetFrom3 with a const Addr containing x.
+//
+// Deprecated: for the same reasons as Prog.GetFrom3.
+func (p *Prog) SetFrom3Const(off int64) {
+	p.SetFrom3(Addr{Type: TYPE_CONST, Offset: off})
+}
+
 // SetTo2 assigns []Args{{a, 1}} to p.RestArgs when the second destination
 // operand does not fit into prog.RegTo2.
 func (p *Prog) SetTo2(a Addr) {
-- 
GitLab


From 9a555fc24c318bf1b07bdc07d5c02e372681e401 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Thu, 25 Feb 2021 12:13:23 -0800
Subject: [PATCH 0857/2400] cmd/compile:  fix missing descend in Addrtaken for
 closures.

ComputeAddrtaken needs to descend into closures, now that imported
bodies can include closures. The bug was that we weren't properly
setting Addrtaken for a variable inside a closure inside a function that
we were importing.

For now, still disable inlining of functions with closures for -G mode.
I'll enable it in a later change -- there are just a few fixes related
to the fact that we don't need to set Ntype for closure functions.

Added a test derived from the cilium repro in the issue.

Fixes #44370

Change-Id: Ida2a403636bf8740b471b3ad68b5474951811e19
Reviewed-on: https://go-review.googlesource.com/c/go/+/296649
Run-TryBot: Dan Scales <danscales@google.com>
Trust: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/base/flag.go      |  1 +
 src/cmd/compile/internal/inline/inl.go     |  4 +---
 src/cmd/compile/internal/typecheck/subr.go |  9 +++++++--
 test/fixedbugs/issue44370.dir/a.go         | 20 ++++++++++++++++++++
 test/fixedbugs/issue44370.dir/b.go         | 11 +++++++++++
 test/fixedbugs/issue44370.go               |  7 +++++++
 6 files changed, 47 insertions(+), 5 deletions(-)
 create mode 100644 test/fixedbugs/issue44370.dir/a.go
 create mode 100644 test/fixedbugs/issue44370.dir/b.go
 create mode 100644 test/fixedbugs/issue44370.go

diff --git a/src/cmd/compile/internal/base/flag.go b/src/cmd/compile/internal/base/flag.go
index d8ca9885cb..ade17fc0cd 100644
--- a/src/cmd/compile/internal/base/flag.go
+++ b/src/cmd/compile/internal/base/flag.go
@@ -159,6 +159,7 @@ func ParseFlags() {
 	Flag.LinkShared = &Ctxt.Flag_linkshared
 	Flag.Shared = &Ctxt.Flag_shared
 	Flag.WB = true
+	Debug.InlFuncsWithClosures = 1
 
 	Flag.Cfg.ImportMap = make(map[string]string)
 
diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 1703be74e9..e961b10844 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -354,9 +354,7 @@ func (v *hairyVisitor) doNode(n ir.Node) bool {
 		return true
 
 	case ir.OCLOSURE:
-		if base.Debug.InlFuncsWithClosures == 0 {
-			// TODO(danscales): change default of InlFuncsWithClosures
-			// to 1 when #44370 is fixed
+		if base.Debug.InlFuncsWithClosures == 0 || base.Flag.G > 0 {
 			v.reason = "not inlining functions with closures"
 			return true
 		}
diff --git a/src/cmd/compile/internal/typecheck/subr.go b/src/cmd/compile/internal/typecheck/subr.go
index b88a9f2283..c40cfa2288 100644
--- a/src/cmd/compile/internal/typecheck/subr.go
+++ b/src/cmd/compile/internal/typecheck/subr.go
@@ -106,7 +106,8 @@ var DirtyAddrtaken = false
 
 func ComputeAddrtaken(top []ir.Node) {
 	for _, n := range top {
-		ir.Visit(n, func(n ir.Node) {
+		var doVisit func(n ir.Node)
+		doVisit = func(n ir.Node) {
 			if n.Op() == ir.OADDR {
 				if x := ir.OuterValue(n.(*ir.AddrExpr).X); x.Op() == ir.ONAME {
 					x.Name().SetAddrtaken(true)
@@ -117,7 +118,11 @@ func ComputeAddrtaken(top []ir.Node) {
 					}
 				}
 			}
-		})
+			if n.Op() == ir.OCLOSURE {
+				ir.VisitList(n.(*ir.ClosureExpr).Func.Body, doVisit)
+			}
+		}
+		ir.Visit(n, doVisit)
 	}
 }
 
diff --git a/test/fixedbugs/issue44370.dir/a.go b/test/fixedbugs/issue44370.dir/a.go
new file mode 100644
index 0000000000..c5bf1bcbc7
--- /dev/null
+++ b/test/fixedbugs/issue44370.dir/a.go
@@ -0,0 +1,20 @@
+// Copyright 2021 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 a
+
+// A StoppableWaitGroup waits for a collection of goroutines to finish.
+type StoppableWaitGroup struct {
+	// i is the internal counter which can store tolerate negative values
+	// as opposed the golang's library WaitGroup.
+	i *int64
+}
+
+// NewStoppableWaitGroup returns a new StoppableWaitGroup. When the 'Stop' is
+// executed, following 'Add()' calls won't have any effect.
+func NewStoppableWaitGroup() *StoppableWaitGroup {
+	return &StoppableWaitGroup{
+		i: func() *int64 { i := int64(0); return &i }(),
+	}
+}
diff --git a/test/fixedbugs/issue44370.dir/b.go b/test/fixedbugs/issue44370.dir/b.go
new file mode 100644
index 0000000000..f0e0b4e55f
--- /dev/null
+++ b/test/fixedbugs/issue44370.dir/b.go
@@ -0,0 +1,11 @@
+// Copyright 2021 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 b
+
+import "./a"
+
+func JoinClusterServices() {
+	_ = a.NewStoppableWaitGroup()
+}
diff --git a/test/fixedbugs/issue44370.go b/test/fixedbugs/issue44370.go
new file mode 100644
index 0000000000..d406838588
--- /dev/null
+++ b/test/fixedbugs/issue44370.go
@@ -0,0 +1,7 @@
+// compiledir
+
+// Copyright 2021 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 ignored
-- 
GitLab


From e25040d16288563c89cead5e8da8d3b9c74ab655 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Thu, 4 Feb 2021 16:42:35 -0500
Subject: [PATCH 0858/2400] cmd/compile: change StaticCall to return a
 "Results"

StaticLECall (multiple value in +mem, multiple value result +mem) ->
StaticCall (multiple ergister value in +mem,
   multiple register-sized-value result +mem) ->
ARCH CallStatic (multiple ergister value in +mem,
   multiple register-sized-value result +mem)

But the architecture-dependent stuff is indifferent to whether
it is mem->mem or (mem)->(mem) until Prog generation.

Deal with OpSelectN -> Prog in ssagen/ssa.go, others, as they
appear.

For #40724.

Change-Id: I1d0436f6371054f1881862641d8e7e418e4a6a16
Reviewed-on: https://go-review.googlesource.com/c/go/+/293391
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/abi/abiutils.go      |  83 +++-
 src/cmd/compile/internal/ssa/cse.go           |   2 +-
 src/cmd/compile/internal/ssa/expand_calls.go  |  38 +-
 .../compile/internal/ssa/gen/generic.rules    |  54 +--
 .../compile/internal/ssa/gen/genericOps.go    |   2 +-
 src/cmd/compile/internal/ssa/location.go      |  14 +
 src/cmd/compile/internal/ssa/lower.go         |   2 +-
 src/cmd/compile/internal/ssa/op.go            |  10 +
 src/cmd/compile/internal/ssa/opGen.go         |   2 +-
 src/cmd/compile/internal/ssa/regalloc.go      |  20 +-
 src/cmd/compile/internal/ssa/rewrite.go       |  14 +-
 .../compile/internal/ssa/rewritegeneric.go    | 411 ++++++------------
 src/cmd/compile/internal/ssa/schedule.go      |  16 +-
 src/cmd/compile/internal/ssa/tighten.go       |   3 +-
 src/cmd/compile/internal/ssa/tuple.go         |  40 +-
 src/cmd/compile/internal/ssa/writebarrier.go  |  17 +-
 src/cmd/compile/internal/ssagen/ssa.go        |  18 +-
 src/cmd/compile/internal/types/type.go        |  23 +-
 18 files changed, 387 insertions(+), 382 deletions(-)

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index 4bd27efb59..b43d95e976 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -27,6 +27,8 @@ type ABIParamResultInfo struct {
 	outparams         []ABIParamAssignment
 	offsetToSpillArea int64
 	spillAreaSize     int64
+	inRegistersUsed   int
+	outRegistersUsed  int
 	config            *ABIConfig // to enable String() method
 }
 
@@ -42,6 +44,14 @@ func (a *ABIParamResultInfo) OutParams() []ABIParamAssignment {
 	return a.outparams
 }
 
+func (a *ABIParamResultInfo) InRegistersUsed() int {
+	return a.inRegistersUsed
+}
+
+func (a *ABIParamResultInfo) OutRegistersUsed() int {
+	return a.outRegistersUsed
+}
+
 func (a *ABIParamResultInfo) InParam(i int) ABIParamAssignment {
 	return a.inparams[i]
 }
@@ -164,6 +174,55 @@ func (a *ABIConfig) NumParamRegs(t *types.Type) int {
 	return n
 }
 
+// preAllocateParams gets the slice sizes right for inputs and outputs.
+func (a *ABIParamResultInfo) preAllocateParams(hasRcvr bool, nIns, nOuts int) {
+	if hasRcvr {
+		nIns++
+	}
+	a.inparams = make([]ABIParamAssignment, 0, nIns)
+	a.outparams = make([]ABIParamAssignment, 0, nOuts)
+}
+
+// ABIAnalyzeTypes takes an optional receiver type, arrays of ins and outs, and returns an ABIParamResultInfo,
+// based on the given configuration.  This is the same result computed by config.ABIAnalyze applied to the
+// corresponding method/function type, except that all the embedded parameter names are nil.
+// This is intended for use by ssagen/ssa.go:(*state).rtcall, for runtime functions that lack a parsed function type.
+func (config *ABIConfig) ABIAnalyzeTypes(rcvr *types.Type, ins, outs []*types.Type) *ABIParamResultInfo {
+	setup()
+	s := assignState{
+		rTotal: config.regAmounts,
+	}
+	result := &ABIParamResultInfo{config: config}
+	result.preAllocateParams(rcvr != nil, len(ins), len(outs))
+
+	// Receiver
+	if rcvr != nil {
+		result.inparams = append(result.inparams,
+			s.assignParamOrReturn(rcvr, nil, false))
+	}
+
+	// Inputs
+	for _, t := range ins {
+		result.inparams = append(result.inparams,
+			s.assignParamOrReturn(t, nil, false))
+	}
+	s.stackOffset = types.Rnd(s.stackOffset, int64(types.RegSize))
+	result.inRegistersUsed = s.rUsed.intRegs + s.rUsed.floatRegs
+
+	// Outputs
+	s.rUsed = RegAmounts{}
+	for _, t := range outs {
+		result.outparams = append(result.outparams, s.assignParamOrReturn(t, nil, true))
+	}
+	// The spill area is at a register-aligned offset and its size is rounded up to a register alignment.
+	// TODO in theory could align offset only to minimum required by spilled data types.
+	result.offsetToSpillArea = alignTo(s.stackOffset, types.RegSize)
+	result.spillAreaSize = alignTo(s.spillOffset, types.RegSize)
+	result.outRegistersUsed = s.rUsed.intRegs + s.rUsed.floatRegs
+
+	return result
+}
+
 // ABIAnalyze takes a function type 't' and an ABI rules description
 // 'config' and analyzes the function to determine how its parameters
 // and results will be passed (in registers or on the stack), returning
@@ -174,33 +233,37 @@ func (config *ABIConfig) ABIAnalyze(t *types.Type) *ABIParamResultInfo {
 		rTotal: config.regAmounts,
 	}
 	result := &ABIParamResultInfo{config: config}
+	ft := t.FuncType()
+	result.preAllocateParams(t.NumRecvs() != 0, ft.Params.NumFields(), ft.Results.NumFields())
 
 	// Receiver
-	ft := t.FuncType()
+	// TODO(register args) ? seems like "struct" and "fields" is not right anymore for describing function parameters
 	if t.NumRecvs() != 0 {
-		rfsl := ft.Receiver.FieldSlice()
+		r := ft.Receiver.FieldSlice()[0]
 		result.inparams = append(result.inparams,
-			s.assignParamOrReturn(rfsl[0], false))
+			s.assignParamOrReturn(r.Type, r.Nname, false))
 	}
 
 	// Inputs
 	ifsl := ft.Params.FieldSlice()
 	for _, f := range ifsl {
 		result.inparams = append(result.inparams,
-			s.assignParamOrReturn(f, false))
+			s.assignParamOrReturn(f.Type, f.Nname, false))
 	}
 	s.stackOffset = types.Rnd(s.stackOffset, int64(types.RegSize))
+	result.inRegistersUsed = s.rUsed.intRegs + s.rUsed.floatRegs
 
 	// Outputs
 	s.rUsed = RegAmounts{}
 	ofsl := ft.Results.FieldSlice()
 	for _, f := range ofsl {
-		result.outparams = append(result.outparams, s.assignParamOrReturn(f, true))
+		result.outparams = append(result.outparams, s.assignParamOrReturn(f.Type, f.Nname, true))
 	}
 	// The spill area is at a register-aligned offset and its size is rounded up to a register alignment.
 	// TODO in theory could align offset only to minimum required by spilled data types.
 	result.offsetToSpillArea = alignTo(s.stackOffset, types.RegSize)
 	result.spillAreaSize = alignTo(s.spillOffset, types.RegSize)
+	result.outRegistersUsed = s.rUsed.intRegs + s.rUsed.floatRegs
 
 	return result
 }
@@ -460,17 +523,15 @@ func (state *assignState) regassign(pt *types.Type) bool {
 // of field f to determine whether it can be register assigned.
 // The result of the analysis is recorded in the result
 // ABIParamResultInfo held in 'state'.
-func (state *assignState) assignParamOrReturn(f *types.Field, isReturn bool) ABIParamAssignment {
-	// TODO(register args) ? seems like "struct" and "fields" is not right anymore for describing function parameters
-	pt := f.Type
+func (state *assignState) assignParamOrReturn(pt *types.Type, n types.Object, isReturn bool) ABIParamAssignment {
 	state.pUsed = RegAmounts{}
 	if pt.Width == types.BADWIDTH {
 		panic("should never happen")
 	} else if pt.Width == 0 {
-		return state.stackAllocate(pt, f.Nname)
+		return state.stackAllocate(pt, n)
 	} else if state.regassign(pt) {
-		return state.regAllocate(pt, f.Nname, isReturn)
+		return state.regAllocate(pt, n, isReturn)
 	} else {
-		return state.stackAllocate(pt, f.Nname)
+		return state.stackAllocate(pt, n)
 	}
 }
diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go
index f78527410c..ade5e0648e 100644
--- a/src/cmd/compile/internal/ssa/cse.go
+++ b/src/cmd/compile/internal/ssa/cse.go
@@ -299,7 +299,7 @@ func cmpVal(v, w *Value, auxIDs auxmap) types.Cmp {
 	// OpSelect is a pseudo-op. We need to be more aggressive
 	// regarding CSE to keep multiple OpSelect's of the same
 	// argument from existing.
-	if v.Op != OpSelect0 && v.Op != OpSelect1 {
+	if v.Op != OpSelect0 && v.Op != OpSelect1 && v.Op != OpSelectN {
 		if tc := v.Type.Compare(w.Type); tc != types.CMPeq {
 			return tc
 		}
diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index 85d6fda427..292b0b41ce 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -170,6 +170,7 @@ type expandState struct {
 	sdom         SparseTree
 	common       map[selKey]*Value
 	offsets      map[offsetKey]*Value
+	memForCall   map[ID]*Value // For a call, need to know the unique selector that gets the mem.
 }
 
 // intPairTypes returns the pair of 32-bit int types needed to encode a 64-bit integer type on a target
@@ -280,7 +281,6 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64,
 		if !x.isAlreadyExpandedAggregateType(selector.Type) {
 			if leafType == selector.Type { // OpIData leads us here, sometimes.
 				leaf.copyOf(selector)
-
 			} else {
 				x.f.Fatalf("Unexpected OpArg type, selector=%s, leaf=%s\n", selector.LongString(), leaf.LongString())
 			}
@@ -357,13 +357,43 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64,
 		which := selector.AuxInt
 		if which == aux.NResults() { // mem is after the results.
 			// rewrite v as a Copy of call -- the replacement call will produce a mem.
-			leaf.copyOf(call)
+			if call.Op == OpStaticLECall {
+				if leaf != selector {
+					panic("Unexpected selector of memory")
+				}
+				// StaticCall selector will address last element of Result.
+				// TODO do this for all the other call types eventually.
+				if aux.abiInfo == nil {
+					panic(fmt.Errorf("aux.abiInfo nil for call %s", call.LongString()))
+				}
+				if existing := x.memForCall[call.ID]; existing == nil {
+					selector.AuxInt = int64(aux.abiInfo.OutRegistersUsed())
+					x.memForCall[call.ID] = selector
+				} else {
+					selector.copyOf(existing)
+				}
+			} else {
+				leaf.copyOf(call)
+			}
 		} else {
 			leafType := removeTrivialWrapperTypes(leaf.Type)
 			if x.canSSAType(leafType) {
 				pt := types.NewPtr(leafType)
 				off := x.offsetFrom(x.sp, offset+aux.OffsetOfResult(which), pt)
 				// Any selection right out of the arg area/registers has to be same Block as call, use call as mem input.
+				if call.Op == OpStaticLECall { // TODO this is temporary until all calls are register-able
+					// Create a "mem" for any loads that need to occur.
+					if mem := x.memForCall[call.ID]; mem != nil {
+						if mem.Block != call.Block {
+							panic(fmt.Errorf("selector and call need to be in same block, selector=%s; call=%s", selector.LongString(), call.LongString()))
+						}
+						call = mem
+					} else {
+						mem = call.Block.NewValue1I(call.Pos.WithNotStmt(), OpSelectN, types.TypeMem, int64(aux.abiInfo.OutRegistersUsed()), call)
+						x.memForCall[call.ID] = mem
+						call = mem
+					}
+				}
 				if leaf.Block == call.Block {
 					leaf.reset(OpLoad)
 					leaf.SetArgs2(off, call)
@@ -835,6 +865,7 @@ func expandCalls(f *Func) {
 		sdom:         f.Sdom(),
 		common:       make(map[selKey]*Value),
 		offsets:      make(map[offsetKey]*Value),
+		memForCall:   make(map[ID]*Value),
 	}
 
 	// For 32-bit, need to deal with decomposition of 64-bit integers, which depends on endianness.
@@ -1173,7 +1204,8 @@ func expandCalls(f *Func) {
 			switch v.Op {
 			case OpStaticLECall:
 				v.Op = OpStaticCall
-				v.Type = types.TypeMem
+				// TODO need to insert all the register types.
+				v.Type = types.NewResults([]*types.Type{types.TypeMem})
 			case OpClosureLECall:
 				v.Op = OpClosureCall
 				v.Type = types.TypeMem
diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules
index 1784923224..fab45243ed 100644
--- a/src/cmd/compile/internal/ssa/gen/generic.rules
+++ b/src/cmd/compile/internal/ssa/gen/generic.rules
@@ -1970,37 +1970,6 @@
 
 (Sqrt (Const64F [c])) && !math.IsNaN(math.Sqrt(c)) => (Const64F [math.Sqrt(c)])
 
-// recognize runtime.newobject and don't Zero/Nilcheck it
-(Zero (Load (OffPtr [c] (SP)) mem) mem)
-	&& mem.Op == OpStaticCall
-	&& isSameCall(mem.Aux, "runtime.newobject")
-	&& c == config.ctxt.FixedFrameSize() + config.RegSize // offset of return value
-	=> mem
-(Store (Load (OffPtr [c] (SP)) mem) x mem)
-	&& isConstZero(x)
-	&& mem.Op == OpStaticCall
-	&& isSameCall(mem.Aux, "runtime.newobject")
-	&& c == config.ctxt.FixedFrameSize() + config.RegSize // offset of return value
-	=> mem
-(Store (OffPtr (Load (OffPtr [c] (SP)) mem)) x mem)
-	&& isConstZero(x)
-	&& mem.Op == OpStaticCall
-	&& isSameCall(mem.Aux, "runtime.newobject")
-	&& c == config.ctxt.FixedFrameSize() + config.RegSize // offset of return value
-	=> mem
-// nil checks just need to rewrite to something useless.
-// they will be deadcode eliminated soon afterwards.
-(NilCheck (Load (OffPtr [c] (SP)) (StaticCall {sym} _)) _)
-	&& isSameCall(sym, "runtime.newobject")
-	&& c == config.ctxt.FixedFrameSize() + config.RegSize // offset of return value
-	&& warnRule(fe.Debug_checknil(), v, "removed nil check")
-	=> (Invalid)
-(NilCheck (OffPtr (Load (OffPtr [c] (SP)) (StaticCall {sym} _))) _)
-	&& isSameCall(sym, "runtime.newobject")
-	&& c == config.ctxt.FixedFrameSize() + config.RegSize // offset of return value
-	&& warnRule(fe.Debug_checknil(), v, "removed nil check")
-	=> (Invalid)
-
 // for rewriting results of some late-expanded rewrites (below)
 (SelectN [0] (MakeResult a ___)) => a
 (SelectN [1] (MakeResult a b ___)) => b
@@ -2021,12 +1990,12 @@
 	&& isSameCall(call.Aux, "runtime.newobject")
 	=> mem
 
-(NilCheck (SelectN [0] call:(StaticLECall _ _)) (SelectN [1] call))
+(NilCheck (SelectN [0] call:(StaticLECall _ _)) _)
 	&& isSameCall(call.Aux, "runtime.newobject")
 	&& warnRule(fe.Debug_checknil(), v, "removed nil check")
 	=> (Invalid)
 
-(NilCheck (OffPtr (SelectN [0] call:(StaticLECall _ _))) (SelectN [1] call))
+(NilCheck (OffPtr (SelectN [0] call:(StaticLECall _ _))) _)
 	&& isSameCall(call.Aux, "runtime.newobject")
 	&& warnRule(fe.Debug_checknil(), v, "removed nil check")
 	=> (Invalid)
@@ -2083,15 +2052,19 @@
 (IsNonNil (Addr _)) => (ConstBool [true])
 (IsNonNil (LocalAddr _ _)) => (ConstBool [true])
 
+// TODO REGISTER ARGS this will need revision.
+// Because expand calls runs after prove, constants useful to this pattern may not appear
+// In the future both versions need to exist; the memory and register variants.
+
 // Inline small or disjoint runtime.memmove calls with constant length.
 // See the comment in op Move in genericOps.go for discussion of the type.
-(StaticCall {sym} s1:(Store _ (Const(64|32) [sz]) s2:(Store  _ src s3:(Store {t} _ dst mem))))
+(SelectN [0] call:(StaticCall {sym} s1:(Store _ (Const(64|32) [sz]) s2:(Store  _ src s3:(Store {t} _ dst mem)))))
 	&& sz >= 0
 	&& isSameCall(sym, "runtime.memmove")
 	&& t.IsPtr() // avoids TUINTPTR, see issue 30061
 	&& s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1
 	&& isInlinableMemmove(dst, src, int64(sz), config)
-	&& clobber(s1, s2, s3)
+	&& clobber(s1, s2, s3, call)
 	=> (Move {t.Elem()} [int64(sz)] dst src mem)
 
 // Inline small or disjoint runtime.memmove calls with constant length.
@@ -2105,13 +2078,6 @@
 	&& clobber(call)
 	=> (Move {dst.Type.Elem()} [int64(sz)] dst src mem)
 
-// De-virtualize interface calls into static calls.
-// Note that (ITab (IMake)) doesn't get
-// rewritten until after the first opt pass,
-// so this rule should trigger reliably.
-(InterCall [argsize] {auxCall} (Load (OffPtr [off] (ITab (IMake (Addr {itab} (SB)) _))) _) mem) && devirt(v, auxCall, itab, off) != nil =>
-	(StaticCall [int32(argsize)] {devirt(v, auxCall, itab, off)} mem)
-
 // De-virtualize late-expanded interface calls into late-expanded static calls.
 // Note that (ITab (IMake)) doesn't get rewritten until after the first opt pass,
 // so this rule should trigger reliably.
@@ -2499,8 +2465,8 @@
 				(Store {t5} (OffPtr <tt5> [o5] dst) d4
 					(Zero {t1} [n] dst mem)))))
 
-// TODO this does not fire before call expansion; is that acceptable?
-(StaticCall {sym} x) && needRaceCleanup(sym, v) => x
+(SelectN [0] call:(StaticLECall {sym} a x)) && needRaceCleanup(sym, call) && clobber(call) => x
+(SelectN [0] call:(StaticLECall {sym} x)) && needRaceCleanup(sym, call) && clobber(call) => x
 
 // Collapse moving A -> B -> C into just A -> C.
 // Later passes (deadstore, elim unread auto) will remove the A -> B move, if possible.
diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go
index 23a2d74b14..043f445c16 100644
--- a/src/cmd/compile/internal/ssa/gen/genericOps.go
+++ b/src/cmd/compile/internal/ssa/gen/genericOps.go
@@ -396,7 +396,7 @@ var genericOps = []opData{
 	// to match StaticCall's 32 bit arg size limit.
 	// TODO(drchase,josharian): could the arg size limit be bundled into the rules for CallOff?
 	{name: "ClosureCall", argLength: 3, aux: "CallOff", call: true},    // arg0=code pointer, arg1=context ptr, arg2=memory.  auxint=arg size.  Returns memory.
-	{name: "StaticCall", argLength: 1, aux: "CallOff", call: true},     // call function aux.(*obj.LSym), arg0=memory.  auxint=arg size.  Returns memory.
+	{name: "StaticCall", argLength: -1, aux: "CallOff", call: true},    // call function aux.(*obj.LSym), arg0..argN-1 are register inputs, argN=memory.  auxint=arg size.  Returns Result of register results, plus memory.
 	{name: "InterCall", argLength: 2, aux: "CallOff", call: true},      // interface call.  arg0=code pointer, arg1=memory, auxint=arg size.  Returns memory.
 	{name: "ClosureLECall", argLength: -1, aux: "CallOff", call: true}, // late-expanded closure call. arg0=code pointer, arg1=context ptr,  arg2..argN-1 are inputs, argN is mem. auxint = arg size. Result is tuple of result(s), plus mem.
 	{name: "StaticLECall", argLength: -1, aux: "CallOff", call: true},  // late-expanded static call function aux.(*ssa.AuxCall.Fn). arg0..argN-1 are inputs, argN is mem. auxint = arg size. Result is tuple of result(s), plus mem.
diff --git a/src/cmd/compile/internal/ssa/location.go b/src/cmd/compile/internal/ssa/location.go
index 4cd0ac8d77..af0a913d17 100644
--- a/src/cmd/compile/internal/ssa/location.go
+++ b/src/cmd/compile/internal/ssa/location.go
@@ -88,6 +88,20 @@ func (t LocPair) String() string {
 	return fmt.Sprintf("<%s,%s>", n0, n1)
 }
 
+type LocResults []Location
+
+func (t LocResults) String() string {
+	s := "<"
+	a := ""
+	for _, r := range t {
+		a += s
+		s = ","
+		a += r.String()
+	}
+	a += ">"
+	return a
+}
+
 type ArgPair struct {
 	reg *Register
 	mem LocalSlot
diff --git a/src/cmd/compile/internal/ssa/lower.go b/src/cmd/compile/internal/ssa/lower.go
index f332b2e028..f6b2bf86a9 100644
--- a/src/cmd/compile/internal/ssa/lower.go
+++ b/src/cmd/compile/internal/ssa/lower.go
@@ -21,7 +21,7 @@ func checkLower(f *Func) {
 				continue // lowered
 			}
 			switch v.Op {
-			case OpSP, OpSB, OpInitMem, OpArg, OpPhi, OpVarDef, OpVarKill, OpVarLive, OpKeepAlive, OpSelect0, OpSelect1, OpConvert, OpInlMark:
+			case OpSP, OpSB, OpInitMem, OpArg, OpPhi, OpVarDef, OpVarKill, OpVarLive, OpKeepAlive, OpSelect0, OpSelect1, OpSelectN, OpConvert, OpInlMark:
 				continue // ok not to lower
 			case OpGetG:
 				if f.Config.hasGReg {
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index 55e0602f2f..6949bdca31 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -203,9 +203,19 @@ func (a *AuxCall) String() string {
 	return fn + "}"
 }
 
+func ACParamsToTypes(ps []Param) (ts []*types.Type) {
+	for _, p := range ps {
+		ts = append(ts, p.Type)
+	}
+	return
+}
+
 // StaticAuxCall returns an AuxCall for a static call.
 func StaticAuxCall(sym *obj.LSym, args []Param, results []Param, paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
 	// TODO Create regInfo for AuxCall
+	if paramResultInfo == nil {
+		panic(fmt.Errorf("Nil paramResultInfo, sym=%v", sym))
+	}
 	return &AuxCall{Fn: sym, args: args, results: results, abiInfo: paramResultInfo}
 }
 
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index 10ea57b36b..2d37ae4357 100644
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -35435,7 +35435,7 @@ var opcodeTable = [...]opInfo{
 	{
 		name:    "StaticCall",
 		auxType: auxCallOff,
-		argLen:  1,
+		argLen:  -1,
 		call:    true,
 		generic: true,
 	},
diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go
index 8c25b1c81d..99e101281b 100644
--- a/src/cmd/compile/internal/ssa/regalloc.go
+++ b/src/cmd/compile/internal/ssa/regalloc.go
@@ -761,6 +761,9 @@ func (s *regAllocState) advanceUses(v *Value) {
 // current instruction.
 func (s *regAllocState) liveAfterCurrentInstruction(v *Value) bool {
 	u := s.values[v.ID].uses
+	if u == nil {
+		panic(fmt.Errorf("u is nil, v = %s, s.values[v.ID] = %v", v.LongString(), s.values[v.ID]))
+	}
 	d := u.dist
 	for u != nil && u.dist == d {
 		u = u.next
@@ -1208,13 +1211,17 @@ func (s *regAllocState) regalloc(f *Func) {
 				s.sb = v.ID
 				continue
 			}
-			if v.Op == OpSelect0 || v.Op == OpSelect1 {
+			if v.Op == OpSelect0 || v.Op == OpSelect1 || v.Op == OpSelectN {
 				if s.values[v.ID].needReg {
-					var i = 0
-					if v.Op == OpSelect1 {
-						i = 1
+					if v.Op == OpSelectN {
+						s.assignReg(register(s.f.getHome(v.Args[0].ID).(LocResults)[int(v.AuxInt)].(*Register).num), v, v)
+					} else {
+						var i = 0
+						if v.Op == OpSelect1 {
+							i = 1
+						}
+						s.assignReg(register(s.f.getHome(v.Args[0].ID).(LocPair)[i].(*Register).num), v, v)
 					}
-					s.assignReg(register(s.f.getHome(v.Args[0].ID).(LocPair)[i].(*Register).num), v, v)
 				}
 				b.Values = append(b.Values, v)
 				s.advanceUses(v)
@@ -1767,6 +1774,9 @@ func (s *regAllocState) placeSpills() {
 		// put the spill of v.  At the start "best" is the best place
 		// we have found so far.
 		// TODO: find a way to make this O(1) without arbitrary cutoffs.
+		if v == nil {
+			panic(fmt.Errorf("nil v, s.orig[%d], vi = %v, spill = %s", i, vi, spill.LongString()))
+		}
 		best := v.Block
 		bestArg := v
 		var bestDepth int16
diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go
index ac6278ab9d..19b97a3ed1 100644
--- a/src/cmd/compile/internal/ssa/rewrite.go
+++ b/src/cmd/compile/internal/ssa/rewrite.go
@@ -793,7 +793,10 @@ func devirtLESym(v *Value, aux Aux, sym Sym, offset int64) *obj.LSym {
 
 func devirtLECall(v *Value, sym *obj.LSym) *Value {
 	v.Op = OpStaticLECall
-	v.Aux.(*AuxCall).Fn = sym
+	auxcall := v.Aux.(*AuxCall)
+	auxcall.Fn = sym
+	// TODO(register args) this should not be necessary when fully transition to the new register ABI.
+	auxcall.abiInfo = v.Block.Func.ABIDefault.ABIAnalyzeTypes(nil, ACParamsToTypes(auxcall.args), ACParamsToTypes(auxcall.results))
 	v.RemoveArg(0)
 	return v
 }
@@ -1617,7 +1620,7 @@ func needRaceCleanup(sym *AuxCall, v *Value) bool {
 	for _, b := range f.Blocks {
 		for _, v := range b.Values {
 			switch v.Op {
-			case OpStaticCall:
+			case OpStaticCall, OpStaticLECall:
 				// Check for racefuncenter/racefuncenterfp will encounter racefuncexit and vice versa.
 				// Allow calls to panic*
 				s := v.Aux.(*AuxCall).Fn.String()
@@ -1632,15 +1635,20 @@ func needRaceCleanup(sym *AuxCall, v *Value) bool {
 				return false
 			case OpPanicBounds, OpPanicExtend:
 				// Note: these are panic generators that are ok (like the static calls above).
-			case OpClosureCall, OpInterCall:
+			case OpClosureCall, OpInterCall, OpClosureLECall, OpInterLECall:
 				// We must keep the race functions if there are any other call types.
 				return false
 			}
 		}
 	}
 	if isSameCall(sym, "runtime.racefuncenter") {
+		// TODO REGISTER ABI this needs to be cleaned up.
 		// If we're removing racefuncenter, remove its argument as well.
 		if v.Args[0].Op != OpStore {
+			if v.Op == OpStaticLECall {
+				// there is no store, yet.
+				return true
+			}
 			return false
 		}
 		mem := v.Args[0].Args[2]
diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go
index 958e24d29f..e5a27199a7 100644
--- a/src/cmd/compile/internal/ssa/rewritegeneric.go
+++ b/src/cmd/compile/internal/ssa/rewritegeneric.go
@@ -122,8 +122,6 @@ func rewriteValuegeneric(v *Value) bool {
 		return rewriteValuegeneric_OpEqSlice(v)
 	case OpIMake:
 		return rewriteValuegeneric_OpIMake(v)
-	case OpInterCall:
-		return rewriteValuegeneric_OpInterCall(v)
 	case OpInterLECall:
 		return rewriteValuegeneric_OpInterLECall(v)
 	case OpIsInBounds:
@@ -392,8 +390,6 @@ func rewriteValuegeneric(v *Value) bool {
 		return rewriteValuegeneric_OpSlicemask(v)
 	case OpSqrt:
 		return rewriteValuegeneric_OpSqrt(v)
-	case OpStaticCall:
-		return rewriteValuegeneric_OpStaticCall(v)
 	case OpStaticLECall:
 		return rewriteValuegeneric_OpStaticLECall(v)
 	case OpStore:
@@ -8542,52 +8538,6 @@ func rewriteValuegeneric_OpIMake(v *Value) bool {
 	}
 	return false
 }
-func rewriteValuegeneric_OpInterCall(v *Value) bool {
-	v_1 := v.Args[1]
-	v_0 := v.Args[0]
-	// match: (InterCall [argsize] {auxCall} (Load (OffPtr [off] (ITab (IMake (Addr {itab} (SB)) _))) _) mem)
-	// cond: devirt(v, auxCall, itab, off) != nil
-	// result: (StaticCall [int32(argsize)] {devirt(v, auxCall, itab, off)} mem)
-	for {
-		argsize := auxIntToInt32(v.AuxInt)
-		auxCall := auxToCall(v.Aux)
-		if v_0.Op != OpLoad {
-			break
-		}
-		v_0_0 := v_0.Args[0]
-		if v_0_0.Op != OpOffPtr {
-			break
-		}
-		off := auxIntToInt64(v_0_0.AuxInt)
-		v_0_0_0 := v_0_0.Args[0]
-		if v_0_0_0.Op != OpITab {
-			break
-		}
-		v_0_0_0_0 := v_0_0_0.Args[0]
-		if v_0_0_0_0.Op != OpIMake {
-			break
-		}
-		v_0_0_0_0_0 := v_0_0_0_0.Args[0]
-		if v_0_0_0_0_0.Op != OpAddr {
-			break
-		}
-		itab := auxToSym(v_0_0_0_0_0.Aux)
-		v_0_0_0_0_0_0 := v_0_0_0_0_0.Args[0]
-		if v_0_0_0_0_0_0.Op != OpSB {
-			break
-		}
-		mem := v_1
-		if !(devirt(v, auxCall, itab, off) != nil) {
-			break
-		}
-		v.reset(OpStaticCall)
-		v.AuxInt = int32ToAuxInt(int32(argsize))
-		v.Aux = callToAux(devirt(v, auxCall, itab, off))
-		v.AddArg(mem)
-		return true
-	}
-	return false
-}
 func rewriteValuegeneric_OpInterLECall(v *Value) bool {
 	// match: (InterLECall [argsize] {auxCall} (Load (OffPtr [off] (ITab (IMake (Addr {itab} (SB)) _))) _) ___)
 	// cond: devirtLESym(v, auxCall, itab, off) != nil
@@ -16113,7 +16063,6 @@ func rewriteValuegeneric_OpNilCheck(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
-	config := b.Func.Config
 	fe := b.Func.fe
 	// match: (NilCheck (GetG mem) mem)
 	// result: mem
@@ -16128,67 +16077,7 @@ func rewriteValuegeneric_OpNilCheck(v *Value) bool {
 		v.copyOf(mem)
 		return true
 	}
-	// match: (NilCheck (Load (OffPtr [c] (SP)) (StaticCall {sym} _)) _)
-	// cond: isSameCall(sym, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize && warnRule(fe.Debug_checknil(), v, "removed nil check")
-	// result: (Invalid)
-	for {
-		if v_0.Op != OpLoad {
-			break
-		}
-		_ = v_0.Args[1]
-		v_0_0 := v_0.Args[0]
-		if v_0_0.Op != OpOffPtr {
-			break
-		}
-		c := auxIntToInt64(v_0_0.AuxInt)
-		v_0_0_0 := v_0_0.Args[0]
-		if v_0_0_0.Op != OpSP {
-			break
-		}
-		v_0_1 := v_0.Args[1]
-		if v_0_1.Op != OpStaticCall {
-			break
-		}
-		sym := auxToCall(v_0_1.Aux)
-		if !(isSameCall(sym, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize && warnRule(fe.Debug_checknil(), v, "removed nil check")) {
-			break
-		}
-		v.reset(OpInvalid)
-		return true
-	}
-	// match: (NilCheck (OffPtr (Load (OffPtr [c] (SP)) (StaticCall {sym} _))) _)
-	// cond: isSameCall(sym, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize && warnRule(fe.Debug_checknil(), v, "removed nil check")
-	// result: (Invalid)
-	for {
-		if v_0.Op != OpOffPtr {
-			break
-		}
-		v_0_0 := v_0.Args[0]
-		if v_0_0.Op != OpLoad {
-			break
-		}
-		_ = v_0_0.Args[1]
-		v_0_0_0 := v_0_0.Args[0]
-		if v_0_0_0.Op != OpOffPtr {
-			break
-		}
-		c := auxIntToInt64(v_0_0_0.AuxInt)
-		v_0_0_0_0 := v_0_0_0.Args[0]
-		if v_0_0_0_0.Op != OpSP {
-			break
-		}
-		v_0_0_1 := v_0_0.Args[1]
-		if v_0_0_1.Op != OpStaticCall {
-			break
-		}
-		sym := auxToCall(v_0_0_1.Aux)
-		if !(isSameCall(sym, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize && warnRule(fe.Debug_checknil(), v, "removed nil check")) {
-			break
-		}
-		v.reset(OpInvalid)
-		return true
-	}
-	// match: (NilCheck (SelectN [0] call:(StaticLECall _ _)) (SelectN [1] call))
+	// match: (NilCheck (SelectN [0] call:(StaticLECall _ _)) _)
 	// cond: isSameCall(call.Aux, "runtime.newobject") && warnRule(fe.Debug_checknil(), v, "removed nil check")
 	// result: (Invalid)
 	for {
@@ -16196,13 +16085,13 @@ func rewriteValuegeneric_OpNilCheck(v *Value) bool {
 			break
 		}
 		call := v_0.Args[0]
-		if call.Op != OpStaticLECall || len(call.Args) != 2 || v_1.Op != OpSelectN || auxIntToInt64(v_1.AuxInt) != 1 || call != v_1.Args[0] || !(isSameCall(call.Aux, "runtime.newobject") && warnRule(fe.Debug_checknil(), v, "removed nil check")) {
+		if call.Op != OpStaticLECall || len(call.Args) != 2 || !(isSameCall(call.Aux, "runtime.newobject") && warnRule(fe.Debug_checknil(), v, "removed nil check")) {
 			break
 		}
 		v.reset(OpInvalid)
 		return true
 	}
-	// match: (NilCheck (OffPtr (SelectN [0] call:(StaticLECall _ _))) (SelectN [1] call))
+	// match: (NilCheck (OffPtr (SelectN [0] call:(StaticLECall _ _))) _)
 	// cond: isSameCall(call.Aux, "runtime.newobject") && warnRule(fe.Debug_checknil(), v, "removed nil check")
 	// result: (Invalid)
 	for {
@@ -16214,7 +16103,7 @@ func rewriteValuegeneric_OpNilCheck(v *Value) bool {
 			break
 		}
 		call := v_0_0.Args[0]
-		if call.Op != OpStaticLECall || len(call.Args) != 2 || v_1.Op != OpSelectN || auxIntToInt64(v_1.AuxInt) != 1 || call != v_1.Args[0] || !(isSameCall(call.Aux, "runtime.newobject") && warnRule(fe.Debug_checknil(), v, "removed nil check")) {
+		if call.Op != OpStaticLECall || len(call.Args) != 2 || !(isSameCall(call.Aux, "runtime.newobject") && warnRule(fe.Debug_checknil(), v, "removed nil check")) {
 			break
 		}
 		v.reset(OpInvalid)
@@ -20799,6 +20688,94 @@ func rewriteValuegeneric_OpSelectN(v *Value) bool {
 		v.copyOf(c)
 		return true
 	}
+	// match: (SelectN [0] call:(StaticCall {sym} s1:(Store _ (Const64 [sz]) s2:(Store _ src s3:(Store {t} _ dst mem)))))
+	// cond: sz >= 0 && isSameCall(sym, "runtime.memmove") && t.IsPtr() && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst, src, int64(sz), config) && clobber(s1, s2, s3, call)
+	// result: (Move {t.Elem()} [int64(sz)] dst src mem)
+	for {
+		if auxIntToInt64(v.AuxInt) != 0 {
+			break
+		}
+		call := v_0
+		if call.Op != OpStaticCall || len(call.Args) != 1 {
+			break
+		}
+		sym := auxToCall(call.Aux)
+		s1 := call.Args[0]
+		if s1.Op != OpStore {
+			break
+		}
+		_ = s1.Args[2]
+		s1_1 := s1.Args[1]
+		if s1_1.Op != OpConst64 {
+			break
+		}
+		sz := auxIntToInt64(s1_1.AuxInt)
+		s2 := s1.Args[2]
+		if s2.Op != OpStore {
+			break
+		}
+		_ = s2.Args[2]
+		src := s2.Args[1]
+		s3 := s2.Args[2]
+		if s3.Op != OpStore {
+			break
+		}
+		t := auxToType(s3.Aux)
+		mem := s3.Args[2]
+		dst := s3.Args[1]
+		if !(sz >= 0 && isSameCall(sym, "runtime.memmove") && t.IsPtr() && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst, src, int64(sz), config) && clobber(s1, s2, s3, call)) {
+			break
+		}
+		v.reset(OpMove)
+		v.AuxInt = int64ToAuxInt(int64(sz))
+		v.Aux = typeToAux(t.Elem())
+		v.AddArg3(dst, src, mem)
+		return true
+	}
+	// match: (SelectN [0] call:(StaticCall {sym} s1:(Store _ (Const32 [sz]) s2:(Store _ src s3:(Store {t} _ dst mem)))))
+	// cond: sz >= 0 && isSameCall(sym, "runtime.memmove") && t.IsPtr() && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst, src, int64(sz), config) && clobber(s1, s2, s3, call)
+	// result: (Move {t.Elem()} [int64(sz)] dst src mem)
+	for {
+		if auxIntToInt64(v.AuxInt) != 0 {
+			break
+		}
+		call := v_0
+		if call.Op != OpStaticCall || len(call.Args) != 1 {
+			break
+		}
+		sym := auxToCall(call.Aux)
+		s1 := call.Args[0]
+		if s1.Op != OpStore {
+			break
+		}
+		_ = s1.Args[2]
+		s1_1 := s1.Args[1]
+		if s1_1.Op != OpConst32 {
+			break
+		}
+		sz := auxIntToInt32(s1_1.AuxInt)
+		s2 := s1.Args[2]
+		if s2.Op != OpStore {
+			break
+		}
+		_ = s2.Args[2]
+		src := s2.Args[1]
+		s3 := s2.Args[2]
+		if s3.Op != OpStore {
+			break
+		}
+		t := auxToType(s3.Aux)
+		mem := s3.Args[2]
+		dst := s3.Args[1]
+		if !(sz >= 0 && isSameCall(sym, "runtime.memmove") && t.IsPtr() && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst, src, int64(sz), config) && clobber(s1, s2, s3, call)) {
+			break
+		}
+		v.reset(OpMove)
+		v.AuxInt = int64ToAuxInt(int64(sz))
+		v.Aux = typeToAux(t.Elem())
+		v.AddArg3(dst, src, mem)
+		return true
+	}
 	// match: (SelectN [0] call:(StaticLECall {sym} dst src (Const64 [sz]) mem))
 	// cond: sz >= 0 && call.Uses == 1 && isSameCall(sym, "runtime.memmove") && dst.Type.IsPtr() && isInlinableMemmove(dst, src, int64(sz), config) && clobber(call)
 	// result: (Move {dst.Type.Elem()} [int64(sz)] dst src mem)
@@ -20857,6 +20834,44 @@ func rewriteValuegeneric_OpSelectN(v *Value) bool {
 		v.AddArg3(dst, src, mem)
 		return true
 	}
+	// match: (SelectN [0] call:(StaticLECall {sym} a x))
+	// cond: needRaceCleanup(sym, call) && clobber(call)
+	// result: x
+	for {
+		if auxIntToInt64(v.AuxInt) != 0 {
+			break
+		}
+		call := v_0
+		if call.Op != OpStaticLECall || len(call.Args) != 2 {
+			break
+		}
+		sym := auxToCall(call.Aux)
+		x := call.Args[1]
+		if !(needRaceCleanup(sym, call) && clobber(call)) {
+			break
+		}
+		v.copyOf(x)
+		return true
+	}
+	// match: (SelectN [0] call:(StaticLECall {sym} x))
+	// cond: needRaceCleanup(sym, call) && clobber(call)
+	// result: x
+	for {
+		if auxIntToInt64(v.AuxInt) != 0 {
+			break
+		}
+		call := v_0
+		if call.Op != OpStaticLECall || len(call.Args) != 1 {
+			break
+		}
+		sym := auxToCall(call.Aux)
+		x := call.Args[0]
+		if !(needRaceCleanup(sym, call) && clobber(call)) {
+			break
+		}
+		v.copyOf(x)
+		return true
+	}
 	return false
 }
 func rewriteValuegeneric_OpSignExt16to32(v *Value) bool {
@@ -21307,98 +21322,6 @@ func rewriteValuegeneric_OpSqrt(v *Value) bool {
 	}
 	return false
 }
-func rewriteValuegeneric_OpStaticCall(v *Value) bool {
-	v_0 := v.Args[0]
-	b := v.Block
-	config := b.Func.Config
-	// match: (StaticCall {sym} s1:(Store _ (Const64 [sz]) s2:(Store _ src s3:(Store {t} _ dst mem))))
-	// cond: sz >= 0 && isSameCall(sym, "runtime.memmove") && t.IsPtr() && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst, src, int64(sz), config) && clobber(s1, s2, s3)
-	// result: (Move {t.Elem()} [int64(sz)] dst src mem)
-	for {
-		sym := auxToCall(v.Aux)
-		s1 := v_0
-		if s1.Op != OpStore {
-			break
-		}
-		_ = s1.Args[2]
-		s1_1 := s1.Args[1]
-		if s1_1.Op != OpConst64 {
-			break
-		}
-		sz := auxIntToInt64(s1_1.AuxInt)
-		s2 := s1.Args[2]
-		if s2.Op != OpStore {
-			break
-		}
-		_ = s2.Args[2]
-		src := s2.Args[1]
-		s3 := s2.Args[2]
-		if s3.Op != OpStore {
-			break
-		}
-		t := auxToType(s3.Aux)
-		mem := s3.Args[2]
-		dst := s3.Args[1]
-		if !(sz >= 0 && isSameCall(sym, "runtime.memmove") && t.IsPtr() && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst, src, int64(sz), config) && clobber(s1, s2, s3)) {
-			break
-		}
-		v.reset(OpMove)
-		v.AuxInt = int64ToAuxInt(int64(sz))
-		v.Aux = typeToAux(t.Elem())
-		v.AddArg3(dst, src, mem)
-		return true
-	}
-	// match: (StaticCall {sym} s1:(Store _ (Const32 [sz]) s2:(Store _ src s3:(Store {t} _ dst mem))))
-	// cond: sz >= 0 && isSameCall(sym, "runtime.memmove") && t.IsPtr() && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst, src, int64(sz), config) && clobber(s1, s2, s3)
-	// result: (Move {t.Elem()} [int64(sz)] dst src mem)
-	for {
-		sym := auxToCall(v.Aux)
-		s1 := v_0
-		if s1.Op != OpStore {
-			break
-		}
-		_ = s1.Args[2]
-		s1_1 := s1.Args[1]
-		if s1_1.Op != OpConst32 {
-			break
-		}
-		sz := auxIntToInt32(s1_1.AuxInt)
-		s2 := s1.Args[2]
-		if s2.Op != OpStore {
-			break
-		}
-		_ = s2.Args[2]
-		src := s2.Args[1]
-		s3 := s2.Args[2]
-		if s3.Op != OpStore {
-			break
-		}
-		t := auxToType(s3.Aux)
-		mem := s3.Args[2]
-		dst := s3.Args[1]
-		if !(sz >= 0 && isSameCall(sym, "runtime.memmove") && t.IsPtr() && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst, src, int64(sz), config) && clobber(s1, s2, s3)) {
-			break
-		}
-		v.reset(OpMove)
-		v.AuxInt = int64ToAuxInt(int64(sz))
-		v.Aux = typeToAux(t.Elem())
-		v.AddArg3(dst, src, mem)
-		return true
-	}
-	// match: (StaticCall {sym} x)
-	// cond: needRaceCleanup(sym, v)
-	// result: x
-	for {
-		sym := auxToCall(v.Aux)
-		x := v_0
-		if !(needRaceCleanup(sym, v)) {
-			break
-		}
-		v.copyOf(x)
-		return true
-	}
-	return false
-}
 func rewriteValuegeneric_OpStaticLECall(v *Value) bool {
 	b := v.Block
 	typ := &b.Func.Config.Types
@@ -21442,7 +21365,6 @@ func rewriteValuegeneric_OpStore(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
-	config := b.Func.Config
 	fe := b.Func.fe
 	// match: (Store {t1} p1 (Load <t2> p2 mem) mem)
 	// cond: isSamePtr(p1, p2) && t2.Size() == t1.Size()
@@ -21890,58 +21812,6 @@ func rewriteValuegeneric_OpStore(v *Value) bool {
 		v.AddArg3(dst, e, mem)
 		return true
 	}
-	// match: (Store (Load (OffPtr [c] (SP)) mem) x mem)
-	// cond: isConstZero(x) && mem.Op == OpStaticCall && isSameCall(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize
-	// result: mem
-	for {
-		if v_0.Op != OpLoad {
-			break
-		}
-		mem := v_0.Args[1]
-		v_0_0 := v_0.Args[0]
-		if v_0_0.Op != OpOffPtr {
-			break
-		}
-		c := auxIntToInt64(v_0_0.AuxInt)
-		v_0_0_0 := v_0_0.Args[0]
-		if v_0_0_0.Op != OpSP {
-			break
-		}
-		x := v_1
-		if mem != v_2 || !(isConstZero(x) && mem.Op == OpStaticCall && isSameCall(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize) {
-			break
-		}
-		v.copyOf(mem)
-		return true
-	}
-	// match: (Store (OffPtr (Load (OffPtr [c] (SP)) mem)) x mem)
-	// cond: isConstZero(x) && mem.Op == OpStaticCall && isSameCall(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize
-	// result: mem
-	for {
-		if v_0.Op != OpOffPtr {
-			break
-		}
-		v_0_0 := v_0.Args[0]
-		if v_0_0.Op != OpLoad {
-			break
-		}
-		mem := v_0_0.Args[1]
-		v_0_0_0 := v_0_0.Args[0]
-		if v_0_0_0.Op != OpOffPtr {
-			break
-		}
-		c := auxIntToInt64(v_0_0_0.AuxInt)
-		v_0_0_0_0 := v_0_0_0.Args[0]
-		if v_0_0_0_0.Op != OpSP {
-			break
-		}
-		x := v_1
-		if mem != v_2 || !(isConstZero(x) && mem.Op == OpStaticCall && isSameCall(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize) {
-			break
-		}
-		v.copyOf(mem)
-		return true
-	}
 	// match: (Store (SelectN [0] call:(StaticLECall _ _)) x mem:(SelectN [1] call))
 	// cond: isConstZero(x) && isSameCall(call.Aux, "runtime.newobject")
 	// result: mem
@@ -24660,27 +24530,6 @@ func rewriteValuegeneric_OpZero(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
-	config := b.Func.Config
-	// match: (Zero (Load (OffPtr [c] (SP)) mem) mem)
-	// cond: mem.Op == OpStaticCall && isSameCall(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize
-	// result: mem
-	for {
-		if v_0.Op != OpLoad {
-			break
-		}
-		mem := v_0.Args[1]
-		v_0_0 := v_0.Args[0]
-		if v_0_0.Op != OpOffPtr {
-			break
-		}
-		c := auxIntToInt64(v_0_0.AuxInt)
-		v_0_0_0 := v_0_0.Args[0]
-		if v_0_0_0.Op != OpSP || mem != v_1 || !(mem.Op == OpStaticCall && isSameCall(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize) {
-			break
-		}
-		v.copyOf(mem)
-		return true
-	}
 	// match: (Zero (SelectN [0] call:(StaticLECall _ _)) mem:(SelectN [1] call))
 	// cond: isSameCall(call.Aux, "runtime.newobject")
 	// result: mem
diff --git a/src/cmd/compile/internal/ssa/schedule.go b/src/cmd/compile/internal/ssa/schedule.go
index 8facb91100..6b34310db7 100644
--- a/src/cmd/compile/internal/ssa/schedule.go
+++ b/src/cmd/compile/internal/ssa/schedule.go
@@ -145,7 +145,7 @@ func schedule(f *Func) {
 				// reduce register pressure. It also helps make sure
 				// VARDEF ops are scheduled before the corresponding LEA.
 				score[v.ID] = ScoreMemory
-			case v.Op == OpSelect0 || v.Op == OpSelect1:
+			case v.Op == OpSelect0 || v.Op == OpSelect1 || v.Op == OpSelectN:
 				// Schedule the pseudo-op of reading part of a tuple
 				// immediately after the tuple-generating op, since
 				// this value is already live. This also removes its
@@ -270,6 +270,20 @@ func schedule(f *Func) {
 					tuples[v.Args[0].ID] = make([]*Value, 2)
 				}
 				tuples[v.Args[0].ID][1] = v
+			case v.Op == OpSelectN:
+				if tuples[v.Args[0].ID] == nil {
+					tuples[v.Args[0].ID] = make([]*Value, v.Args[0].Type.NumFields())
+				}
+				tuples[v.Args[0].ID][v.AuxInt] = v
+			case v.Type.IsResults() && tuples[v.ID] != nil:
+				tup := tuples[v.ID]
+				for i := len(tup) - 1; i >= 0; i-- {
+					if tup[i] != nil {
+						order = append(order, tup[i])
+					}
+				}
+				delete(tuples, v.ID)
+				order = append(order, v)
 			case v.Type.IsTuple() && tuples[v.ID] != nil:
 				if tuples[v.ID][1] != nil {
 					order = append(order, tuples[v.ID][1])
diff --git a/src/cmd/compile/internal/ssa/tighten.go b/src/cmd/compile/internal/ssa/tighten.go
index 5dfc453649..bd08334a5f 100644
--- a/src/cmd/compile/internal/ssa/tighten.go
+++ b/src/cmd/compile/internal/ssa/tighten.go
@@ -18,10 +18,11 @@ func tighten(f *Func) {
 				continue
 			}
 			switch v.Op {
-			case OpPhi, OpArg, OpSelect0, OpSelect1:
+			case OpPhi, OpArg, OpSelect0, OpSelect1, OpSelectN:
 				// Phis need to stay in their block.
 				// Arg must stay in the entry block.
 				// Tuple selectors must stay with the tuple generator.
+				// SelectN is typically, ultimately, a register.
 				continue
 			}
 			if v.MemoryArg() != nil {
diff --git a/src/cmd/compile/internal/ssa/tuple.go b/src/cmd/compile/internal/ssa/tuple.go
index 38deabf83d..289df40431 100644
--- a/src/cmd/compile/internal/ssa/tuple.go
+++ b/src/cmd/compile/internal/ssa/tuple.go
@@ -4,8 +4,8 @@
 
 package ssa
 
-// tightenTupleSelectors ensures that tuple selectors (Select0 and
-// Select1 ops) are in the same block as their tuple generator. The
+// tightenTupleSelectors ensures that tuple selectors (Select0, Select1,
+// and SelectN ops) are in the same block as their tuple generator. The
 // function also ensures that there are no duplicate tuple selectors.
 // These properties are expected by the scheduler but may not have
 // been maintained by the optimization pipeline up to this point.
@@ -13,28 +13,40 @@ package ssa
 // See issues 16741 and 39472.
 func tightenTupleSelectors(f *Func) {
 	selectors := make(map[struct {
-		id ID
-		op Op
+		id    ID
+		which int
 	}]*Value)
 	for _, b := range f.Blocks {
 		for _, selector := range b.Values {
-			if selector.Op != OpSelect0 && selector.Op != OpSelect1 {
+			// Key fields for de-duplication
+			var tuple *Value
+			idx := 0
+			switch selector.Op {
+			default:
 				continue
-			}
-
-			// Get the tuple generator to use as a key for de-duplication.
-			tuple := selector.Args[0]
-			if !tuple.Type.IsTuple() {
-				f.Fatalf("arg of tuple selector %s is not a tuple: %s", selector.String(), tuple.LongString())
+			case OpSelect1:
+				idx = 1
+				fallthrough
+			case OpSelect0:
+				tuple = selector.Args[0]
+				if !tuple.Type.IsTuple() {
+					f.Fatalf("arg of tuple selector %s is not a tuple: %s", selector.String(), tuple.LongString())
+				}
+			case OpSelectN:
+				tuple = selector.Args[0]
+				idx = int(selector.AuxInt)
+				if !tuple.Type.IsResults() {
+					f.Fatalf("arg of result selector %s is not a results: %s", selector.String(), tuple.LongString())
+				}
 			}
 
 			// If there is a pre-existing selector in the target block then
 			// use that. Do this even if the selector is already in the
 			// target block to avoid duplicate tuple selectors.
 			key := struct {
-				id ID
-				op Op
-			}{tuple.ID, selector.Op}
+				id    ID
+				which int
+			}{tuple.ID, idx}
 			if t := selectors[key]; t != nil {
 				if selector != t {
 					selector.copyOf(t)
diff --git a/src/cmd/compile/internal/ssa/writebarrier.go b/src/cmd/compile/internal/ssa/writebarrier.go
index 7d375da128..0af039577f 100644
--- a/src/cmd/compile/internal/ssa/writebarrier.go
+++ b/src/cmd/compile/internal/ssa/writebarrier.go
@@ -487,12 +487,14 @@ func wbcall(pos src.XPos, b *Block, fn, typ *obj.LSym, ptr, val, mem, sp, sb *Va
 	off := config.ctxt.FixedFrameSize()
 
 	var ACArgs []Param
+	var argTypes []*types.Type
 	if typ != nil { // for typedmemmove
 		taddr := b.NewValue1A(pos, OpAddr, b.Func.Config.Types.Uintptr, typ, sb)
 		off = round(off, taddr.Type.Alignment())
 		arg := b.NewValue1I(pos, OpOffPtr, taddr.Type.PtrTo(), off, sp)
 		mem = b.NewValue3A(pos, OpStore, types.TypeMem, ptr.Type, arg, taddr, mem)
 		ACArgs = append(ACArgs, Param{Type: b.Func.Config.Types.Uintptr, Offset: int32(off)})
+		argTypes = append(argTypes, b.Func.Config.Types.Uintptr)
 		off += taddr.Type.Size()
 	}
 
@@ -500,6 +502,7 @@ func wbcall(pos src.XPos, b *Block, fn, typ *obj.LSym, ptr, val, mem, sp, sb *Va
 	arg := b.NewValue1I(pos, OpOffPtr, ptr.Type.PtrTo(), off, sp)
 	mem = b.NewValue3A(pos, OpStore, types.TypeMem, ptr.Type, arg, ptr, mem)
 	ACArgs = append(ACArgs, Param{Type: ptr.Type, Offset: int32(off)})
+	argTypes = append(argTypes, ptr.Type)
 	off += ptr.Type.Size()
 
 	if val != nil {
@@ -507,15 +510,15 @@ func wbcall(pos src.XPos, b *Block, fn, typ *obj.LSym, ptr, val, mem, sp, sb *Va
 		arg = b.NewValue1I(pos, OpOffPtr, val.Type.PtrTo(), off, sp)
 		mem = b.NewValue3A(pos, OpStore, types.TypeMem, val.Type, arg, val, mem)
 		ACArgs = append(ACArgs, Param{Type: val.Type, Offset: int32(off)})
+		argTypes = append(argTypes, val.Type)
 		off += val.Type.Size()
 	}
 	off = round(off, config.PtrSize)
 
 	// issue call
-	// TODO(register args) -- will need more details
-	mem = b.NewValue1A(pos, OpStaticCall, types.TypeMem, StaticAuxCall(fn, ACArgs, nil, nil), mem)
+	mem = b.NewValue1A(pos, OpStaticCall, types.TypeResultMem, StaticAuxCall(fn, ACArgs, nil, b.Func.ABIDefault.ABIAnalyzeTypes(nil, argTypes, nil)), mem)
 	mem.AuxInt = off - config.ctxt.FixedFrameSize()
-	return mem
+	return b.NewValue1I(pos, OpSelectN, types.TypeMem, 0, mem)
 }
 
 // round to a multiple of r, r is a power of 2
@@ -563,12 +566,20 @@ func IsReadOnlyGlobalAddr(v *Value) bool {
 
 // IsNewObject reports whether v is a pointer to a freshly allocated & zeroed object at memory state mem.
 func IsNewObject(v *Value, mem *Value) bool {
+	// TODO this will need updating for register args; the OpLoad is wrong.
 	if v.Op != OpLoad {
 		return false
 	}
 	if v.MemoryArg() != mem {
 		return false
 	}
+	if mem.Op != OpSelectN {
+		return false
+	}
+	if mem.Type != types.TypeMem {
+		return false
+	} // assume it is the right selection if true
+	mem = mem.Args[0]
 	if mem.Op != OpStaticCall {
 		return false
 	}
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 20acdbdc66..ba00b9c7f6 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -4734,7 +4734,8 @@ func (s *state) openDeferExit() {
 			aux := ssa.ClosureAuxCall(ACArgs, ACResults)
 			call = s.newValue2A(ssa.OpClosureLECall, aux.LateExpansionResultType(), aux, codeptr, v)
 		} else {
-			aux := ssa.StaticAuxCall(fn.(*ir.Name).Linksym(), ACArgs, ACResults, nil) // TODO will need types for this.
+			aux := ssa.StaticAuxCall(fn.(*ir.Name).Linksym(), ACArgs, ACResults,
+				s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
 			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 		}
 		callArgs = append(callArgs, s.mem())
@@ -4896,7 +4897,8 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 
 		// Call runtime.deferprocStack with pointer to _defer record.
 		ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(base.Ctxt.FixedFrameSize())})
-		aux := ssa.StaticAuxCall(ir.Syms.DeferprocStack, ACArgs, ACResults, nil)
+		aux := ssa.StaticAuxCall(ir.Syms.DeferprocStack, ACArgs, ACResults,
+			s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
 		callArgs = append(callArgs, addr, s.mem())
 		call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 		call.AddArgs(callArgs...)
@@ -4956,10 +4958,12 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		// call target
 		switch {
 		case k == callDefer:
-			aux := ssa.StaticAuxCall(ir.Syms.Deferproc, ACArgs, ACResults, nil) // TODO paramResultInfo for DeferProc
+			aux := ssa.StaticAuxCall(ir.Syms.Deferproc, ACArgs, ACResults,
+				s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults))) // TODO paramResultInfo for DeferProc
 			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 		case k == callGo:
-			aux := ssa.StaticAuxCall(ir.Syms.Newproc, ACArgs, ACResults, nil)
+			aux := ssa.StaticAuxCall(ir.Syms.Newproc, ACArgs, ACResults,
+				s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
 			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux) // TODO paramResultInfo for NewProc
 		case closure != nil:
 			// rawLoad because loading the code pointer from a
@@ -5434,6 +5438,7 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
 	var ACArgs []ssa.Param
 	var ACResults []ssa.Param
 	var callArgs []*ssa.Value
+	var callArgTypes []*types.Type
 
 	for _, arg := range args {
 		t := arg.Type
@@ -5441,6 +5446,7 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
 		size := t.Size()
 		ACArgs = append(ACArgs, ssa.Param{Type: t, Offset: int32(off)})
 		callArgs = append(callArgs, arg)
+		callArgTypes = append(callArgTypes, t)
 		off += size
 	}
 	off = types.Rnd(off, int64(types.RegSize))
@@ -5455,7 +5461,7 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
 
 	// Issue call
 	var call *ssa.Value
-	aux := ssa.StaticAuxCall(fn, ACArgs, ACResults, nil) // WILL NEED A TYPE FOR THIS.)
+	aux := ssa.StaticAuxCall(fn, ACArgs, ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, callArgTypes, results))
 	callArgs = append(callArgs, s.mem())
 	call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 	call.AddArgs(callArgs...)
@@ -6520,7 +6526,7 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 				// input args need no code
 			case ssa.OpSP, ssa.OpSB:
 				// nothing to do
-			case ssa.OpSelect0, ssa.OpSelect1:
+			case ssa.OpSelect0, ssa.OpSelect1, ssa.OpSelectN:
 				// nothing to do
 			case ssa.OpGetG:
 				// nothing to do when there's a g register,
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index b6374e49a5..9fb6d68994 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -581,12 +581,19 @@ func NewTuple(t1, t2 *Type) *Type {
 	return t
 }
 
-func NewResults(types []*Type) *Type {
+func newResults(types []*Type) *Type {
 	t := New(TRESULTS)
 	t.Extra.(*Results).Types = types
 	return t
 }
 
+func NewResults(types []*Type) *Type {
+	if len(types) == 1 && types[0] == TypeMem {
+		return TypeResultMem
+	}
+	return newResults(types)
+}
+
 func newSSA(name string) *Type {
 	t := New(TSSA)
 	t.Extra = name
@@ -1407,6 +1414,9 @@ func (t *Type) PtrTo() *Type {
 }
 
 func (t *Type) NumFields() int {
+	if t.kind == TRESULTS {
+		return len(t.Extra.(*Results).Types)
+	}
 	return t.Fields().Len()
 }
 func (t *Type) FieldType(i int) *Type {
@@ -1597,11 +1607,12 @@ func FakeRecvType() *Type {
 
 var (
 	// TSSA types. HasPointers assumes these are pointer-free.
-	TypeInvalid = newSSA("invalid")
-	TypeMem     = newSSA("mem")
-	TypeFlags   = newSSA("flags")
-	TypeVoid    = newSSA("void")
-	TypeInt128  = newSSA("int128")
+	TypeInvalid   = newSSA("invalid")
+	TypeMem       = newSSA("mem")
+	TypeFlags     = newSSA("flags")
+	TypeVoid      = newSSA("void")
+	TypeInt128    = newSSA("int128")
+	TypeResultMem = newResults([]*Type{TypeMem})
 )
 
 // NewNamed returns a new named type for the given type name.
-- 
GitLab


From 23943a67378040340d835734a55dee7cb639e586 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Fri, 26 Feb 2021 10:17:09 +0700
Subject: [PATCH 0859/2400] cmd/compile: fix mishandling of unsafe-uintptr
 arguments with call method in go/defer

In CL 253457, we did the same fix for direct function calls. But for
method calls, the receiver argument also need to be passed through the
wrapper function, which we are not doing so the compiler crashes with
the code in #44415.

It will be nicer if we can rewrite OCALLMETHOD to normal OCALLFUNC, but
that will be for future CL. The passing receiver argument to wrapper
function is easier for backporting to go1.16 branch.

Fixes #44415

Change-Id: I03607a64429042c6066ce673931db9769deb3124
Reviewed-on: https://go-review.googlesource.com/c/go/+/296490
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/walk/stmt.go | 21 ++++++++++++++----
 test/fixedbugs/issue24491a.go         | 31 +++++++++++++++++++++++++++
 2 files changed, 48 insertions(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/walk/stmt.go b/src/cmd/compile/internal/walk/stmt.go
index 46a621c2ba..0c851506cb 100644
--- a/src/cmd/compile/internal/walk/stmt.go
+++ b/src/cmd/compile/internal/walk/stmt.go
@@ -253,15 +253,22 @@ func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 		}
 	}
 
+	wrapArgs := n.Args
+	// If there's a receiver argument, it needs to be passed through the wrapper too.
+	if n.Op() == ir.OCALLMETH || n.Op() == ir.OCALLINTER {
+		recv := n.X.(*ir.SelectorExpr).X
+		wrapArgs = append([]ir.Node{recv}, wrapArgs...)
+	}
+
 	// origArgs keeps track of what argument is uintptr-unsafe/unsafe-uintptr conversion.
-	origArgs := make([]ir.Node, len(n.Args))
+	origArgs := make([]ir.Node, len(wrapArgs))
 	var funcArgs []*ir.Field
-	for i, arg := range n.Args {
+	for i, arg := range wrapArgs {
 		s := typecheck.LookupNum("a", i)
 		if !isBuiltinCall && arg.Op() == ir.OCONVNOP && arg.Type().IsUintptr() && arg.(*ir.ConvExpr).X.Type().IsUnsafePtr() {
 			origArgs[i] = arg
 			arg = arg.(*ir.ConvExpr).X
-			n.Args[i] = arg
+			wrapArgs[i] = arg
 		}
 		funcArgs = append(funcArgs, ir.NewField(base.Pos, s, nil, arg.Type()))
 	}
@@ -278,6 +285,12 @@ func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 		}
 		args[i] = ir.NewConvExpr(base.Pos, origArg.Op(), origArg.Type(), args[i])
 	}
+	if n.Op() == ir.OCALLMETH || n.Op() == ir.OCALLINTER {
+		// Move wrapped receiver argument back to its appropriate place.
+		recv := typecheck.Expr(args[0])
+		n.X.(*ir.SelectorExpr).X = recv
+		args = args[1:]
+	}
 	call := ir.NewCallExpr(base.Pos, n.Op(), n.X, args)
 	if !isBuiltinCall {
 		call.SetOp(ir.OCALL)
@@ -291,6 +304,6 @@ func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	typecheck.Stmts(fn.Body)
 	typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
 
-	call = ir.NewCallExpr(base.Pos, ir.OCALL, fn.Nname, n.Args)
+	call = ir.NewCallExpr(base.Pos, ir.OCALL, fn.Nname, wrapArgs)
 	return walkExpr(typecheck.Stmt(call), init)
 }
diff --git a/test/fixedbugs/issue24491a.go b/test/fixedbugs/issue24491a.go
index 8accf8c0a3..d30b65b233 100644
--- a/test/fixedbugs/issue24491a.go
+++ b/test/fixedbugs/issue24491a.go
@@ -48,6 +48,14 @@ func f() int {
 	return test("return", uintptr(setup()), uintptr(setup()), uintptr(setup()), uintptr(setup()))
 }
 
+type S struct{}
+
+//go:noinline
+//go:uintptrescapes
+func (S) test(s string, p, q uintptr, rest ...uintptr) int {
+	return test(s, p, q, rest...)
+}
+
 func main() {
 	test("normal", uintptr(setup()), uintptr(setup()), uintptr(setup()), uintptr(setup()))
 	<-done
@@ -60,6 +68,29 @@ func main() {
 	}()
 	<-done
 
+	func() {
+		for {
+			defer test("defer in for loop", uintptr(setup()), uintptr(setup()), uintptr(setup()), uintptr(setup()))
+			break
+		}
+	}()
+
+	<-done
+	func() {
+		s := &S{}
+		defer s.test("method call", uintptr(setup()), uintptr(setup()), uintptr(setup()), uintptr(setup()))
+	}()
+	<-done
+
+	func() {
+		s := &S{}
+		for {
+			defer s.test("defer method loop", uintptr(setup()), uintptr(setup()), uintptr(setup()), uintptr(setup()))
+			break
+		}
+	}()
+	<-done
+
 	f()
 	<-done
 }
-- 
GitLab


From a655208c9ecd2fee4de6deff35a863b1c28a091c Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 25 Feb 2021 20:01:53 -0500
Subject: [PATCH 0860/2400] cmd/link: handle types as converted to interface
 when dynlink

When using plugins, a type (whose value) may be pass to a plugin
and get converted to interface there, or vice versa. We need to
treat the type as potentially converted to interface, and retain
its methods.

Should fix #44586.

Change-Id: I80dd35e68baedaa852a317543ccd78d94628d13b
Reviewed-on: https://go-review.googlesource.com/c/go/+/296709
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 misc/cgo/testplugin/plugin_test.go            | 13 ++++----
 misc/cgo/testplugin/testdata/method2/main.go  | 32 +++++++++++++++++++
 misc/cgo/testplugin/testdata/method2/p/p.go   |  9 ++++++
 .../cgo/testplugin/testdata/method2/plugin.go | 11 +++++++
 src/cmd/link/internal/ld/deadcode.go          |  7 ++++
 5 files changed, 65 insertions(+), 7 deletions(-)
 create mode 100644 misc/cgo/testplugin/testdata/method2/main.go
 create mode 100644 misc/cgo/testplugin/testdata/method2/p/p.go
 create mode 100644 misc/cgo/testplugin/testdata/method2/plugin.go

diff --git a/misc/cgo/testplugin/plugin_test.go b/misc/cgo/testplugin/plugin_test.go
index 9055dbda04..2d991012c8 100644
--- a/misc/cgo/testplugin/plugin_test.go
+++ b/misc/cgo/testplugin/plugin_test.go
@@ -201,12 +201,11 @@ func TestMethod(t *testing.T) {
 	// Exported symbol's method must be live.
 	goCmd(t, "build", "-buildmode=plugin", "-o", "plugin.so", "./method/plugin.go")
 	goCmd(t, "build", "-o", "method.exe", "./method/main.go")
+	run(t, "./method.exe")
+}
 
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer cancel()
-	cmd := exec.CommandContext(ctx, "./method.exe")
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, out)
-	}
+func TestMethod2(t *testing.T) {
+	goCmd(t, "build", "-buildmode=plugin", "-o", "method2.so", "./method2/plugin.go")
+	goCmd(t, "build", "-o", "method2.exe", "./method2/main.go")
+	run(t, "./method2.exe")
 }
diff --git a/misc/cgo/testplugin/testdata/method2/main.go b/misc/cgo/testplugin/testdata/method2/main.go
new file mode 100644
index 0000000000..6a87e7b6a0
--- /dev/null
+++ b/misc/cgo/testplugin/testdata/method2/main.go
@@ -0,0 +1,32 @@
+// Copyright 2021 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.
+
+// A type can be passed to a plugin and converted to interface
+// there. So its methods need to be live.
+
+package main
+
+import (
+	"plugin"
+
+	"testplugin/method2/p"
+)
+
+var t p.T
+
+type I interface { M() }
+
+func main() {
+	pl, err := plugin.Open("method2.so")
+	if err != nil {
+		panic(err)
+	}
+
+	f, err := pl.Lookup("F")
+	if err != nil {
+		panic(err)
+	}
+
+	f.(func(p.T) interface{})(t).(I).M()
+}
diff --git a/misc/cgo/testplugin/testdata/method2/p/p.go b/misc/cgo/testplugin/testdata/method2/p/p.go
new file mode 100644
index 0000000000..acb526acec
--- /dev/null
+++ b/misc/cgo/testplugin/testdata/method2/p/p.go
@@ -0,0 +1,9 @@
+// Copyright 2021 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 p
+
+type T int
+
+func (T) M() { println("M") }
diff --git a/misc/cgo/testplugin/testdata/method2/plugin.go b/misc/cgo/testplugin/testdata/method2/plugin.go
new file mode 100644
index 0000000000..6198e7648e
--- /dev/null
+++ b/misc/cgo/testplugin/testdata/method2/plugin.go
@@ -0,0 +1,11 @@
+// Copyright 2021 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 "testplugin/method2/p"
+
+func main() {}
+
+func F(t p.T) interface{} { return t }
diff --git a/src/cmd/link/internal/ld/deadcode.go b/src/cmd/link/internal/ld/deadcode.go
index 1874103b93..ebde41499e 100644
--- a/src/cmd/link/internal/ld/deadcode.go
+++ b/src/cmd/link/internal/ld/deadcode.go
@@ -24,6 +24,7 @@ type deadcodePass struct {
 	ifaceMethod     map[methodsig]bool // methods declared in reached interfaces
 	markableMethods []methodref        // methods of reached types
 	reflectSeen     bool               // whether we have seen a reflect method call
+	dynlink         bool
 
 	methodsigstmp []methodsig // scratch buffer for decoding method signatures
 }
@@ -34,6 +35,7 @@ func (d *deadcodePass) init() {
 	if objabi.Fieldtrack_enabled != 0 {
 		d.ldr.Reachparent = make([]loader.Sym, d.ldr.NSym())
 	}
+	d.dynlink = d.ctxt.DynlinkingGo()
 
 	if d.ctxt.BuildMode == BuildModeShared {
 		// Mark all symbols defined in this library as reachable when
@@ -115,6 +117,11 @@ func (d *deadcodePass) flood() {
 		var usedInIface bool
 
 		if isgotype {
+			if d.dynlink {
+				// When dynaamic linking, a type may be passed across DSO
+				// boundary and get converted to interface at the other side.
+				d.ldr.SetAttrUsedInIface(symIdx, true)
+			}
 			usedInIface = d.ldr.AttrUsedInIface(symIdx)
 		}
 
-- 
GitLab


From f41460145ef6b75303e5f766a676274f456387d3 Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Thu, 4 Feb 2021 00:11:12 +0100
Subject: [PATCH 0861/2400] cmd/link: recognize ARM64 PE files and relocations

For now, this only add a single relocation type, which is sufficient for
Windows resources. Later we'll see if we need more for cgo.

In order to ensure these code paths are actually tested, this expands
the rsrc tests to include all the architectures of PE objects that we
need to be recognizing, and splits things more clearly between binutils
and llvm objects, which have a slightly different layout, so that we
test both.

This CL is part of a stack adding windows/arm64
support (#36439), intended to land in the Go 1.17 cycle.

Change-Id: Ia1ee840265e9d12c0b12dd1c5d0810f8b300e557
Reviewed-on: https://go-review.googlesource.com/c/go/+/289429
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/ld/lib.go               |   6 ++-
 src/cmd/link/internal/loadpe/ldpe.go          |  29 +++++++++++++
 src/cmd/link/link_test.go                     |  38 +++++++++++++-----
 .../{testPErsrc => pe-binutils}/main.go       |   7 ++--
 .../link/testdata/pe-binutils/rsrc_386.syso   | Bin 0 -> 228 bytes
 .../rsrc.syso => pe-binutils/rsrc_amd64.syso} | Bin
 .../{testPErsrc-complex => pe-llvm}/main.go   |   4 +-
 src/cmd/link/testdata/pe-llvm/rsrc_386.syso   | Bin 0 -> 352 bytes
 .../rsrc.syso => pe-llvm/rsrc_amd64.syso}     | Bin 352 -> 352 bytes
 src/cmd/link/testdata/pe-llvm/rsrc_arm.syso   | Bin 0 -> 352 bytes
 src/cmd/link/testdata/pe-llvm/rsrc_arm64.syso | Bin 0 -> 352 bytes
 11 files changed, 67 insertions(+), 17 deletions(-)
 rename src/cmd/link/testdata/{testPErsrc => pe-binutils}/main.go (65%)
 create mode 100644 src/cmd/link/testdata/pe-binutils/rsrc_386.syso
 rename src/cmd/link/testdata/{testPErsrc/rsrc.syso => pe-binutils/rsrc_amd64.syso} (100%)
 rename src/cmd/link/testdata/{testPErsrc-complex => pe-llvm}/main.go (92%)
 create mode 100644 src/cmd/link/testdata/pe-llvm/rsrc_386.syso
 rename src/cmd/link/testdata/{testPErsrc-complex/rsrc.syso => pe-llvm/rsrc_amd64.syso} (81%)
 create mode 100644 src/cmd/link/testdata/pe-llvm/rsrc_arm.syso
 create mode 100644 src/cmd/link/testdata/pe-llvm/rsrc_arm64.syso

diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index 28713456c4..517b0f6930 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -1827,7 +1827,11 @@ func ldobj(ctxt *Link, f *bio.Reader, lib *sym.Library, length int64, pn string,
 		return ldhostobj(ldmacho, ctxt.HeadType, f, pkg, length, pn, file)
 	}
 
-	if /* x86 */ c1 == 0x4c && c2 == 0x01 || /* x86_64 */ c1 == 0x64 && c2 == 0x86 || /* armv7 */ c1 == 0xc4 && c2 == 0x01 {
+	switch c1<<8 | c2 {
+	case 0x4c01, // 386
+		0x6486, // amd64
+		0xc401, // arm
+		0x64aa: // arm64
 		ldpe := func(ctxt *Link, f *bio.Reader, pkg string, length int64, pn string) {
 			textp, rsrc, err := loadpe.Load(ctxt.loader, ctxt.Arch, ctxt.IncVersion(), f, pkg, length, pn)
 			if err != nil {
diff --git a/src/cmd/link/internal/loadpe/ldpe.go b/src/cmd/link/internal/loadpe/ldpe.go
index a5c025de8f..f474dfb276 100644
--- a/src/cmd/link/internal/loadpe/ldpe.go
+++ b/src/cmd/link/internal/loadpe/ldpe.go
@@ -115,6 +115,24 @@ const (
 	IMAGE_REL_THUMB_BRANCH24         = 0x0014
 	IMAGE_REL_THUMB_BLX23            = 0x0015
 	IMAGE_REL_ARM_PAIR               = 0x0016
+	IMAGE_REL_ARM64_ABSOLUTE         = 0x0000
+	IMAGE_REL_ARM64_ADDR32           = 0x0001
+	IMAGE_REL_ARM64_ADDR32NB         = 0x0002
+	IMAGE_REL_ARM64_BRANCH26         = 0x0003
+	IMAGE_REL_ARM64_PAGEBASE_REL21   = 0x0004
+	IMAGE_REL_ARM64_REL21            = 0x0005
+	IMAGE_REL_ARM64_PAGEOFFSET_12A   = 0x0006
+	IMAGE_REL_ARM64_PAGEOFFSET_12L   = 0x0007
+	IMAGE_REL_ARM64_SECREL           = 0x0008
+	IMAGE_REL_ARM64_SECREL_LOW12A    = 0x0009
+	IMAGE_REL_ARM64_SECREL_HIGH12A   = 0x000A
+	IMAGE_REL_ARM64_SECREL_LOW12L    = 0x000B
+	IMAGE_REL_ARM64_TOKEN            = 0x000C
+	IMAGE_REL_ARM64_SECTION          = 0x000D
+	IMAGE_REL_ARM64_ADDR64           = 0x000E
+	IMAGE_REL_ARM64_BRANCH19         = 0x000F
+	IMAGE_REL_ARM64_BRANCH14         = 0x0010
+	IMAGE_REL_ARM64_REL32            = 0x0011
 )
 
 // TODO(crawshaw): de-duplicate these symbols with cmd/internal/ld, ideally in debug/pe.
@@ -319,6 +337,17 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, input *bio.Read
 				case IMAGE_REL_ARM_BRANCH24:
 					rType = objabi.R_CALLARM
 
+					rAdd = int64(int32(binary.LittleEndian.Uint32(sectdata[rsect][rOff:])))
+				}
+
+			case sys.ARM64:
+				switch r.Type {
+				default:
+					return nil, nil, fmt.Errorf("%s: %v: unknown ARM64 relocation type %v", pn, sectsyms[rsect], r.Type)
+
+				case IMAGE_REL_ARM64_ADDR32, IMAGE_REL_ARM64_ADDR32NB:
+					rType = objabi.R_ADDR
+
 					rAdd = int64(int32(binary.LittleEndian.Uint32(sectdata[rsect][rOff:])))
 				}
 			}
diff --git a/src/cmd/link/link_test.go b/src/cmd/link/link_test.go
index 08ddd00a0c..9c69ccca43 100644
--- a/src/cmd/link/link_test.go
+++ b/src/cmd/link/link_test.go
@@ -753,23 +753,24 @@ func TestIndexMismatch(t *testing.T) {
 	}
 }
 
-func TestPErsrc(t *testing.T) {
+func TestPErsrcBinutils(t *testing.T) {
 	// Test that PE rsrc section is handled correctly (issue 39658).
 	testenv.MustHaveGoBuild(t)
 
-	if runtime.GOARCH != "amd64" || runtime.GOOS != "windows" {
-		t.Skipf("this is a windows/amd64-only test")
+	if (runtime.GOARCH != "386" && runtime.GOARCH != "amd64") || runtime.GOOS != "windows" {
+		// This test is limited to amd64 and 386, because binutils is limited as such
+		t.Skipf("this is only for windows/amd64 and windows/386")
 	}
 
 	t.Parallel()
 
-	tmpdir, err := ioutil.TempDir("", "TestPErsrc")
+	tmpdir, err := ioutil.TempDir("", "TestPErsrcBinutils")
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer os.RemoveAll(tmpdir)
 
-	pkgdir := filepath.Join("testdata", "testPErsrc")
+	pkgdir := filepath.Join("testdata", "pe-binutils")
 	exe := filepath.Join(tmpdir, "a.exe")
 	cmd := exec.Command(testenv.GoToolPath(t), "build", "-o", exe)
 	cmd.Dir = pkgdir
@@ -787,19 +788,36 @@ func TestPErsrc(t *testing.T) {
 	if !bytes.Contains(b, []byte("Hello Gophers!")) {
 		t.Fatalf("binary does not contain expected content")
 	}
+}
+
+func TestPErsrcLLVM(t *testing.T) {
+	// Test that PE rsrc section is handled correctly (issue 39658).
+	testenv.MustHaveGoBuild(t)
+
+	if runtime.GOOS != "windows" {
+		t.Skipf("this is a windows-only test")
+	}
+
+	t.Parallel()
+
+	tmpdir, err := ioutil.TempDir("", "TestPErsrcLLVM")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmpdir)
 
-	pkgdir = filepath.Join("testdata", "testPErsrc-complex")
-	exe = filepath.Join(tmpdir, "a.exe")
-	cmd = exec.Command(testenv.GoToolPath(t), "build", "-o", exe)
+	pkgdir := filepath.Join("testdata", "pe-llvm")
+	exe := filepath.Join(tmpdir, "a.exe")
+	cmd := exec.Command(testenv.GoToolPath(t), "build", "-o", exe)
 	cmd.Dir = pkgdir
 	// cmd.Env = append(os.Environ(), "GOOS=windows", "GOARCH=amd64") // uncomment if debugging in a cross-compiling environment
-	out, err = cmd.CombinedOutput()
+	out, err := cmd.CombinedOutput()
 	if err != nil {
 		t.Fatalf("building failed: %v, output:\n%s", err, out)
 	}
 
 	// Check that the binary contains the rsrc data
-	b, err = ioutil.ReadFile(exe)
+	b, err := ioutil.ReadFile(exe)
 	if err != nil {
 		t.Fatalf("reading output failed: %v", err)
 	}
diff --git a/src/cmd/link/testdata/testPErsrc/main.go b/src/cmd/link/testdata/pe-binutils/main.go
similarity index 65%
rename from src/cmd/link/testdata/testPErsrc/main.go
rename to src/cmd/link/testdata/pe-binutils/main.go
index 5eb66fb9cc..14ea6f9e0f 100644
--- a/src/cmd/link/testdata/testPErsrc/main.go
+++ b/src/cmd/link/testdata/pe-binutils/main.go
@@ -4,10 +4,9 @@
 
 // Test that a PE rsrc section is handled correctly (issue 39658).
 //
-// rsrc.syso is created with:
-//	windres -i a.rc -o rsrc.syso -O coff
-// on windows-amd64-2016 builder, where a.rc is a text file with
-// the following content:
+// rsrc.syso is created using binutils with:
+//	{x86_64,i686}-w64-mingw32-windres -i a.rc -o rsrc_$GOARCH.syso -O coff
+// where a.rc is a text file with the following content:
 //
 // resname RCDATA {
 //   "Hello Gophers!\0",
diff --git a/src/cmd/link/testdata/pe-binutils/rsrc_386.syso b/src/cmd/link/testdata/pe-binutils/rsrc_386.syso
new file mode 100644
index 0000000000000000000000000000000000000000..b4abc58abee609976b890aa7dafe197431d7e011
GIT binary patch
literal 228
zcmeZaWMlw=a|{d&5EcugUQuyTGDr}LI~W)kY#10AjzIY!bq)*$2cTRi#mK<Lz`!8E
zz|a5{08=2f9t;c(2590S+c;Sm7$O)L7}yzt7+e{G8T=R=8GIRB88R3c805jaA%sV2
xPENjpdwxMiYEiKwLr6wuu|j6CLZU)RYH^7k#0-#1b_QgZgKTDIU}0cj006ep7hV7W

literal 0
HcmV?d00001

diff --git a/src/cmd/link/testdata/testPErsrc/rsrc.syso b/src/cmd/link/testdata/pe-binutils/rsrc_amd64.syso
similarity index 100%
rename from src/cmd/link/testdata/testPErsrc/rsrc.syso
rename to src/cmd/link/testdata/pe-binutils/rsrc_amd64.syso
diff --git a/src/cmd/link/testdata/testPErsrc-complex/main.go b/src/cmd/link/testdata/pe-llvm/main.go
similarity index 92%
rename from src/cmd/link/testdata/testPErsrc-complex/main.go
rename to src/cmd/link/testdata/pe-llvm/main.go
index affd6eada2..099a71a3ff 100644
--- a/src/cmd/link/testdata/testPErsrc-complex/main.go
+++ b/src/cmd/link/testdata/pe-llvm/main.go
@@ -6,8 +6,8 @@
 // have been created by llvm-rc or msvc's rc.exe, which means there's the
 // @feat.00 symbol as well as split .rsrc$00 and .rsrc$01 section to deal with.
 //
-// rsrc.syso is created with:
-//    windres -i a.rc -o rsrc.syso -O coff
+// rsrc.syso is created using llvm with:
+//    {i686,x86_64,armv7,arm64}-w64-mingw32-windres -i a.rc -o rsrc_$GOARCH.syso -O coff
 // where this windres calls into llvm-rc and llvm-cvtres. The source file,
 // a.rc, simply contains a reference to its own bytes:
 //
diff --git a/src/cmd/link/testdata/pe-llvm/rsrc_386.syso b/src/cmd/link/testdata/pe-llvm/rsrc_386.syso
new file mode 100644
index 0000000000000000000000000000000000000000..21126c9954fd595269f7e68ffaca4dc32ee3e25d
GIT binary patch
literal 352
zcmeZaWMVitQ7z#E0|Nsa0~j#s6%`jHs~8x9c?=8;84L^zDGUq@XP^R%3=9ko3=9rX
zbw*HO1_=fRh8r*rlm@ATGNBYB0~Z4WNNodD08D|*j9_4BFkoOn5ocgvWZ-0BVDJE|
zVqg$~(jbbRA&9}1A(+9B!I8n2!4<5Am4ShQoq>U&D782*F*j8q$l1j)#8DwpuP7O0
zErUZ^YGR3=fq@_c1H=FS3=GT+P+x$33vvZBBgnrX7RU|=hN=Pkl!<|XfteBHSBM;p
QR0%Qw0}vmq2E<?h07&s7NdN!<

literal 0
HcmV?d00001

diff --git a/src/cmd/link/testdata/testPErsrc-complex/rsrc.syso b/src/cmd/link/testdata/pe-llvm/rsrc_amd64.syso
similarity index 81%
rename from src/cmd/link/testdata/testPErsrc-complex/rsrc.syso
rename to src/cmd/link/testdata/pe-llvm/rsrc_amd64.syso
index eff630b8a23de71fa27da5bf0b49965bf4cea69a..56f9260b0a3b76ad84ac48b2c5f0a41bb538dee5 100644
GIT binary patch
delta 17
YcmaFB^ni&YrHzSU{Y15djT{k-05<ytkpKVy

delta 17
YcmaFB^ni&YrHzTfX4$&<jT{k-05>58x&QzG

diff --git a/src/cmd/link/testdata/pe-llvm/rsrc_arm.syso b/src/cmd/link/testdata/pe-llvm/rsrc_arm.syso
new file mode 100644
index 0000000000000000000000000000000000000000..c93a1e9ba0ffa390e122f211ca55ace3355ce27b
GIT binary patch
literal 352
zcmX@Y$iy&xqFTZS1_lN;1~6dMD=IEZRxvOH^B5QyG8h;bQWzK*&Oiki85kHG7#JL&
z>WrYm3=#|s3^!mLC=F5vWkM-N1}+8$klF^Q0GI-q8NtBNV8FnDBF@0T$iT_Mz~BK^
z#lRo}r9l)sLlA>2LokCMgCm14gDY4KD+2=q69WT7QEG8sVs5HJkh6<ph@(QHUQsg0
zS_X%-)Wi}!0|P+@28RFt85o!upuPb67UT+MMv#9&ERY=#3{?a6DadqYMvz}2axhXQ
O$N&sLe6Si2g8=}t9U_td

literal 0
HcmV?d00001

diff --git a/src/cmd/link/testdata/pe-llvm/rsrc_arm64.syso b/src/cmd/link/testdata/pe-llvm/rsrc_arm64.syso
new file mode 100644
index 0000000000000000000000000000000000000000..7849638ddd42e7e24efcc18665e265ac01f8edcd
GIT binary patch
literal 352
zcmYdU#l*01qFTZS1_lN;1~6dMD=IEZRxvOH^B5QyG8h;bQWzK*&Oiki85kHG7#JL&
z>WrYm3=#|s3^!mLC=F5vWkM-N1}+8$klF^Q0GI-q8NtBNV8FnDBF@0T$iT_Mz~BK^
z#lRo}r9l)sLlA>2LokCMgCm14gDY4KD+2=q69WT7QEG8sVs5HJkh6<ph@(QHUQsg0
zS_X%-)Wi}!0|P+@28RFt85o!upuPb67UT+MMv#9&ERY=#3{?a6DadqYMvz}2axhXQ
O$N&sLe6Si2g8={|dm`lk

literal 0
HcmV?d00001

-- 
GitLab


From ba9168bd07bfed6071e3eadcaae40b5481c52c24 Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Sun, 31 Jan 2021 17:37:20 +0100
Subject: [PATCH 0862/2400] syscall: add support for proc thread attribute
 lists

This will allow us to pass additional attributes when starting
processes.

Updates #44011.

Change-Id: I4af365c5544a6d421830f247593ec970200e5e03
Reviewed-on: https://go-review.googlesource.com/c/go/+/288296
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Trust: Alex Brainman <alex.brainman@gmail.com>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
---
 src/syscall/syscall_windows.go  | 23 +++++++++++++++++++++++
 src/syscall/types_windows.go    | 16 ++++++++++++++++
 src/syscall/zsyscall_windows.go | 24 ++++++++++++++++++++++++
 3 files changed, 63 insertions(+)

diff --git a/src/syscall/syscall_windows.go b/src/syscall/syscall_windows.go
index ee5311b176..cc8dc487d3 100644
--- a/src/syscall/syscall_windows.go
+++ b/src/syscall/syscall_windows.go
@@ -284,6 +284,9 @@ func NewCallbackCDecl(fn interface{}) uintptr {
 // This function returns 1 byte BOOLEAN rather than the 4 byte BOOL.
 //sys	CreateSymbolicLink(symlinkfilename *uint16, targetfilename *uint16, flags uint32) (err error) [failretval&0xff==0] = CreateSymbolicLinkW
 //sys	CreateHardLink(filename *uint16, existingfilename *uint16, reserved uintptr) (err error) [failretval&0xff==0] = CreateHardLinkW
+//sys	initializeProcThreadAttributeList(attrlist *_PROC_THREAD_ATTRIBUTE_LIST, attrcount uint32, flags uint32, size *uintptr) (err error) = InitializeProcThreadAttributeList
+//sys	deleteProcThreadAttributeList(attrlist *_PROC_THREAD_ATTRIBUTE_LIST) = DeleteProcThreadAttributeList
+//sys	updateProcThreadAttribute(attrlist *_PROC_THREAD_ATTRIBUTE_LIST, flags uint32, attr uintptr, value uintptr, size uintptr, prevvalue uintptr, returnedsize *uintptr) (err error) = UpdateProcThreadAttribute
 
 // syscall interface implementation for other packages
 
@@ -1240,3 +1243,23 @@ func GetQueuedCompletionStatus(cphandle Handle, qty *uint32, key *uint32, overla
 func PostQueuedCompletionStatus(cphandle Handle, qty uint32, key uint32, overlapped *Overlapped) error {
 	return postQueuedCompletionStatus(cphandle, qty, uintptr(key), overlapped)
 }
+
+// newProcThreadAttributeList allocates new PROC_THREAD_ATTRIBUTE_LIST, with
+// the requested maximum number of attributes, which must be cleaned up by
+// deleteProcThreadAttributeList.
+func newProcThreadAttributeList(maxAttrCount uint32) (*_PROC_THREAD_ATTRIBUTE_LIST, error) {
+	var size uintptr
+	err := initializeProcThreadAttributeList(nil, maxAttrCount, 0, &size)
+	if err != ERROR_INSUFFICIENT_BUFFER {
+		if err == nil {
+			return nil, errorspkg.New("unable to query buffer size from InitializeProcThreadAttributeList")
+		}
+		return nil, err
+	}
+	al := (*_PROC_THREAD_ATTRIBUTE_LIST)(unsafe.Pointer(&make([]byte, size)[0]))
+	err = initializeProcThreadAttributeList(al, maxAttrCount, 0, &size)
+	if err != nil {
+		return nil, err
+	}
+	return al, nil
+}
diff --git a/src/syscall/types_windows.go b/src/syscall/types_windows.go
index 5fef5c9477..384b5b4f2c 100644
--- a/src/syscall/types_windows.go
+++ b/src/syscall/types_windows.go
@@ -490,6 +490,22 @@ type StartupInfo struct {
 	StdErr        Handle
 }
 
+type _PROC_THREAD_ATTRIBUTE_LIST struct {
+	_ [1]byte
+}
+
+const (
+	_PROC_THREAD_ATTRIBUTE_PARENT_PROCESS = 0x00020000
+	_PROC_THREAD_ATTRIBUTE_HANDLE_LIST    = 0x00020002
+)
+
+type _STARTUPINFOEXW struct {
+	StartupInfo
+	ProcThreadAttributeList *_PROC_THREAD_ATTRIBUTE_LIST
+}
+
+const _EXTENDED_STARTUPINFO_PRESENT = 0x00080000
+
 type ProcessInformation struct {
 	Process   Handle
 	Thread    Handle
diff --git a/src/syscall/zsyscall_windows.go b/src/syscall/zsyscall_windows.go
index b1480ba7df..b08e6ac5c2 100644
--- a/src/syscall/zsyscall_windows.go
+++ b/src/syscall/zsyscall_windows.go
@@ -93,6 +93,7 @@ var (
 	procCreateSymbolicLinkW                = modkernel32.NewProc("CreateSymbolicLinkW")
 	procCreateToolhelp32Snapshot           = modkernel32.NewProc("CreateToolhelp32Snapshot")
 	procDeleteFileW                        = modkernel32.NewProc("DeleteFileW")
+	procDeleteProcThreadAttributeList      = modkernel32.NewProc("DeleteProcThreadAttributeList")
 	procDeviceIoControl                    = modkernel32.NewProc("DeviceIoControl")
 	procDuplicateHandle                    = modkernel32.NewProc("DuplicateHandle")
 	procExitProcess                        = modkernel32.NewProc("ExitProcess")
@@ -131,6 +132,7 @@ var (
 	procGetTempPathW                       = modkernel32.NewProc("GetTempPathW")
 	procGetTimeZoneInformation             = modkernel32.NewProc("GetTimeZoneInformation")
 	procGetVersion                         = modkernel32.NewProc("GetVersion")
+	procInitializeProcThreadAttributeList  = modkernel32.NewProc("InitializeProcThreadAttributeList")
 	procLoadLibraryW                       = modkernel32.NewProc("LoadLibraryW")
 	procLocalFree                          = modkernel32.NewProc("LocalFree")
 	procMapViewOfFile                      = modkernel32.NewProc("MapViewOfFile")
@@ -153,6 +155,7 @@ var (
 	procSetHandleInformation               = modkernel32.NewProc("SetHandleInformation")
 	procTerminateProcess                   = modkernel32.NewProc("TerminateProcess")
 	procUnmapViewOfFile                    = modkernel32.NewProc("UnmapViewOfFile")
+	procUpdateProcThreadAttribute          = modkernel32.NewProc("UpdateProcThreadAttribute")
 	procVirtualLock                        = modkernel32.NewProc("VirtualLock")
 	procVirtualUnlock                      = modkernel32.NewProc("VirtualUnlock")
 	procWaitForSingleObject                = modkernel32.NewProc("WaitForSingleObject")
@@ -569,6 +572,11 @@ func DeleteFile(path *uint16) (err error) {
 	return
 }
 
+func deleteProcThreadAttributeList(attrlist *_PROC_THREAD_ATTRIBUTE_LIST) {
+	Syscall(procDeleteProcThreadAttributeList.Addr(), 1, uintptr(unsafe.Pointer(attrlist)), 0, 0)
+	return
+}
+
 func DeviceIoControl(handle Handle, ioControlCode uint32, inBuffer *byte, inBufferSize uint32, outBuffer *byte, outBufferSize uint32, bytesReturned *uint32, overlapped *Overlapped) (err error) {
 	r1, _, e1 := Syscall9(procDeviceIoControl.Addr(), 8, uintptr(handle), uintptr(ioControlCode), uintptr(unsafe.Pointer(inBuffer)), uintptr(inBufferSize), uintptr(unsafe.Pointer(outBuffer)), uintptr(outBufferSize), uintptr(unsafe.Pointer(bytesReturned)), uintptr(unsafe.Pointer(overlapped)), 0)
 	if r1 == 0 {
@@ -897,6 +905,14 @@ func GetVersion() (ver uint32, err error) {
 	return
 }
 
+func initializeProcThreadAttributeList(attrlist *_PROC_THREAD_ATTRIBUTE_LIST, attrcount uint32, flags uint32, size *uintptr) (err error) {
+	r1, _, e1 := Syscall6(procInitializeProcThreadAttributeList.Addr(), 4, uintptr(unsafe.Pointer(attrlist)), uintptr(attrcount), uintptr(flags), uintptr(unsafe.Pointer(size)), 0, 0)
+	if r1 == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
 func LoadLibrary(libname string) (handle Handle, err error) {
 	var _p0 *uint16
 	_p0, err = UTF16PtrFromString(libname)
@@ -1099,6 +1115,14 @@ func UnmapViewOfFile(addr uintptr) (err error) {
 	return
 }
 
+func updateProcThreadAttribute(attrlist *_PROC_THREAD_ATTRIBUTE_LIST, flags uint32, attr uintptr, value uintptr, size uintptr, prevvalue uintptr, returnedsize *uintptr) (err error) {
+	r1, _, e1 := Syscall9(procUpdateProcThreadAttribute.Addr(), 7, uintptr(unsafe.Pointer(attrlist)), uintptr(flags), uintptr(attr), uintptr(value), uintptr(size), uintptr(prevvalue), uintptr(unsafe.Pointer(returnedsize)), 0, 0)
+	if r1 == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
 func VirtualLock(addr uintptr, length uintptr) (err error) {
 	r1, _, e1 := Syscall(procVirtualLock.Addr(), 2, uintptr(addr), uintptr(length), 0)
 	if r1 == 0 {
-- 
GitLab


From 2d760816ff30bea82f54682f3049cfb6c6027da7 Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Sun, 31 Jan 2021 17:54:27 +0100
Subject: [PATCH 0863/2400] syscall: restrict inherited handles on Windows

Windows does not have CLOEXEC, but rather handles are marked explicitly
for being inherited by new processes. This can cause problems when
different Windows functions create new processes from different threads.
syscall.StartProcess has traditionally used a mutex to prevent races
with itself, but this doesn't handle races with other win32 functions.

Fortunately there's a solution: PROC_THREAD_ATTRIBUTE_HANDLE_LIST allows
us to pass the entire list of handles that we want to be inherited. This
lets us get rid of the mutex and also makes process creation safe across
the Go runtime, no matter the context.

Updates #44011.

Change-Id: Ia3424cd2ec64868849cbd6cbb5b0d765224bf4ab
Reviewed-on: https://go-review.googlesource.com/c/go/+/288297
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Trust: Alex Brainman <alex.brainman@gmail.com>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
---
 src/syscall/exec_windows.go | 25 +++++++++++++++----------
 1 file changed, 15 insertions(+), 10 deletions(-)

diff --git a/src/syscall/exec_windows.go b/src/syscall/exec_windows.go
index 46cbd7567d..ff9f7a3913 100644
--- a/src/syscall/exec_windows.go
+++ b/src/syscall/exec_windows.go
@@ -310,12 +310,6 @@ func StartProcess(argv0 string, argv []string, attr *ProcAttr) (pid int, handle
 		}
 	}
 
-	// Acquire the fork lock so that no other threads
-	// create new fds that are not yet close-on-exec
-	// before we fork.
-	ForkLock.Lock()
-	defer ForkLock.Unlock()
-
 	p, _ := GetCurrentProcess()
 	fd := make([]Handle, len(attr.Files))
 	for i := range attr.Files {
@@ -327,7 +321,12 @@ func StartProcess(argv0 string, argv []string, attr *ProcAttr) (pid int, handle
 			defer CloseHandle(Handle(fd[i]))
 		}
 	}
-	si := new(StartupInfo)
+	si := new(_STARTUPINFOEXW)
+	si.ProcThreadAttributeList, err = newProcThreadAttributeList(1)
+	if err != nil {
+		return 0, 0, err
+	}
+	defer deleteProcThreadAttributeList(si.ProcThreadAttributeList)
 	si.Cb = uint32(unsafe.Sizeof(*si))
 	si.Flags = STARTF_USESTDHANDLES
 	if sys.HideWindow {
@@ -338,13 +337,19 @@ func StartProcess(argv0 string, argv []string, attr *ProcAttr) (pid int, handle
 	si.StdOutput = fd[1]
 	si.StdErr = fd[2]
 
+	// Do not accidentally inherit more than these handles.
+	err = updateProcThreadAttribute(si.ProcThreadAttributeList, 0, _PROC_THREAD_ATTRIBUTE_HANDLE_LIST, uintptr(unsafe.Pointer(&fd[0])), uintptr(len(fd))*unsafe.Sizeof(fd[0]), 0, nil)
+	if err != nil {
+		return 0, 0, err
+	}
+
 	pi := new(ProcessInformation)
 
-	flags := sys.CreationFlags | CREATE_UNICODE_ENVIRONMENT
+	flags := sys.CreationFlags | CREATE_UNICODE_ENVIRONMENT | _EXTENDED_STARTUPINFO_PRESENT
 	if sys.Token != 0 {
-		err = CreateProcessAsUser(sys.Token, argv0p, argvp, sys.ProcessAttributes, sys.ThreadAttributes, !sys.NoInheritHandles, flags, createEnvBlock(attr.Env), dirp, si, pi)
+		err = CreateProcessAsUser(sys.Token, argv0p, argvp, sys.ProcessAttributes, sys.ThreadAttributes, !sys.NoInheritHandles, flags, createEnvBlock(attr.Env), dirp, &si.StartupInfo, pi)
 	} else {
-		err = CreateProcess(argv0p, argvp, sys.ProcessAttributes, sys.ThreadAttributes, !sys.NoInheritHandles, flags, createEnvBlock(attr.Env), dirp, si, pi)
+		err = CreateProcess(argv0p, argvp, sys.ProcessAttributes, sys.ThreadAttributes, !sys.NoInheritHandles, flags, createEnvBlock(attr.Env), dirp, &si.StartupInfo, pi)
 	}
 	if err != nil {
 		return 0, 0, err
-- 
GitLab


From 3146166baa8c420dfe20619e4aa9978b87927268 Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Sun, 31 Jan 2021 18:07:43 +0100
Subject: [PATCH 0864/2400] syscall: introduce
 SysProcAttr.AdditionalInheritedHandles on Windows

This allows users to specify handles that they explicitly want to be
inherited by the new process. These handles must already be marked as
inheritable.

Updates #44011.
Updates #21085.

Change-Id: Ib18322e7dc2909e68c4209e80385492804fa15d3
Reviewed-on: https://go-review.googlesource.com/c/go/+/288298
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
---
 src/syscall/exec_windows.go | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/src/syscall/exec_windows.go b/src/syscall/exec_windows.go
index ff9f7a3913..0ddc240a56 100644
--- a/src/syscall/exec_windows.go
+++ b/src/syscall/exec_windows.go
@@ -235,13 +235,14 @@ type ProcAttr struct {
 }
 
 type SysProcAttr struct {
-	HideWindow        bool
-	CmdLine           string // used if non-empty, else the windows command line is built by escaping the arguments passed to StartProcess
-	CreationFlags     uint32
-	Token             Token               // if set, runs new process in the security context represented by the token
-	ProcessAttributes *SecurityAttributes // if set, applies these security attributes as the descriptor for the new process
-	ThreadAttributes  *SecurityAttributes // if set, applies these security attributes as the descriptor for the main thread of the new process
-	NoInheritHandles  bool                // if set, each inheritable handle in the calling process is not inherited by the new process
+	HideWindow                 bool
+	CmdLine                    string // used if non-empty, else the windows command line is built by escaping the arguments passed to StartProcess
+	CreationFlags              uint32
+	Token                      Token               // if set, runs new process in the security context represented by the token
+	ProcessAttributes          *SecurityAttributes // if set, applies these security attributes as the descriptor for the new process
+	ThreadAttributes           *SecurityAttributes // if set, applies these security attributes as the descriptor for the main thread of the new process
+	NoInheritHandles           bool                // if set, each inheritable handle in the calling process is not inherited by the new process
+	AdditionalInheritedHandles []Handle            // a list of additional handles, already marked as inheritable, that will be inherited by the new process
 }
 
 var zeroProcAttr ProcAttr
@@ -337,6 +338,7 @@ func StartProcess(argv0 string, argv []string, attr *ProcAttr) (pid int, handle
 	si.StdOutput = fd[1]
 	si.StdErr = fd[2]
 
+	fd = append(fd, sys.AdditionalInheritedHandles...)
 	// Do not accidentally inherit more than these handles.
 	err = updateProcThreadAttribute(si.ProcThreadAttributeList, 0, _PROC_THREAD_ATTRIBUTE_HANDLE_LIST, uintptr(unsafe.Pointer(&fd[0])), uintptr(len(fd))*unsafe.Sizeof(fd[0]), 0, nil)
 	if err != nil {
-- 
GitLab


From 19f96e73bf655764b57424cc9e00657f364ffb89 Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Sun, 31 Jan 2021 18:14:56 +0100
Subject: [PATCH 0865/2400] syscall: introduce SysProcAttr.ParentProcess on
 Windows

This allows users to specify which process should be used as the parent
process when creating a new process.

Note that this doesn't just trivially pass the handle onward to
PROC_THREAD_ATTRIBUTE_PARENT_PROCESS, because inherited handles must be
valid in the parent process, so if we're changing the destination
process, then we must also change the origin of the parent handles. And,
the StartProcess function must clean up these handles successfully when
exiting, regardless of where the duplication happened. So, we take care
in this commit to use DuplicateHandle for both duplicating and for
closing the inherited handles.

The test was taken originally from CL 288272 and adjusted for use here.

Fixes #44011.

Change-Id: Ib3b132028dcab1aded3dc0e65126c8abebfa35eb
Reviewed-on: https://go-review.googlesource.com/c/go/+/288300
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Trust: Alex Brainman <alex.brainman@gmail.com>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
---
 src/syscall/exec_windows.go      | 17 ++++++--
 src/syscall/exec_windows_test.go | 73 ++++++++++++++++++++++++++++++++
 2 files changed, 87 insertions(+), 3 deletions(-)

diff --git a/src/syscall/exec_windows.go b/src/syscall/exec_windows.go
index 0ddc240a56..7b73cf1f6f 100644
--- a/src/syscall/exec_windows.go
+++ b/src/syscall/exec_windows.go
@@ -243,6 +243,7 @@ type SysProcAttr struct {
 	ThreadAttributes           *SecurityAttributes // if set, applies these security attributes as the descriptor for the main thread of the new process
 	NoInheritHandles           bool                // if set, each inheritable handle in the calling process is not inherited by the new process
 	AdditionalInheritedHandles []Handle            // a list of additional handles, already marked as inheritable, that will be inherited by the new process
+	ParentProcess              Handle              // if non-zero, the new process regards the process given by this handle as its parent process, and AdditionalInheritedHandles, if set, should exist in this parent process
 }
 
 var zeroProcAttr ProcAttr
@@ -312,18 +313,22 @@ func StartProcess(argv0 string, argv []string, attr *ProcAttr) (pid int, handle
 	}
 
 	p, _ := GetCurrentProcess()
+	parentProcess := p
+	if sys.ParentProcess != 0 {
+		parentProcess = sys.ParentProcess
+	}
 	fd := make([]Handle, len(attr.Files))
 	for i := range attr.Files {
 		if attr.Files[i] > 0 {
-			err := DuplicateHandle(p, Handle(attr.Files[i]), p, &fd[i], 0, true, DUPLICATE_SAME_ACCESS)
+			err := DuplicateHandle(p, Handle(attr.Files[i]), parentProcess, &fd[i], 0, true, DUPLICATE_SAME_ACCESS)
 			if err != nil {
 				return 0, 0, err
 			}
-			defer CloseHandle(Handle(fd[i]))
+			defer DuplicateHandle(parentProcess, fd[i], 0, nil, 0, false, DUPLICATE_CLOSE_SOURCE)
 		}
 	}
 	si := new(_STARTUPINFOEXW)
-	si.ProcThreadAttributeList, err = newProcThreadAttributeList(1)
+	si.ProcThreadAttributeList, err = newProcThreadAttributeList(2)
 	if err != nil {
 		return 0, 0, err
 	}
@@ -334,6 +339,12 @@ func StartProcess(argv0 string, argv []string, attr *ProcAttr) (pid int, handle
 		si.Flags |= STARTF_USESHOWWINDOW
 		si.ShowWindow = SW_HIDE
 	}
+	if sys.ParentProcess != 0 {
+		err = updateProcThreadAttribute(si.ProcThreadAttributeList, 0, _PROC_THREAD_ATTRIBUTE_PARENT_PROCESS, uintptr(unsafe.Pointer(&sys.ParentProcess)), unsafe.Sizeof(sys.ParentProcess), 0, nil)
+		if err != nil {
+			return 0, 0, err
+		}
+	}
 	si.StdInput = fd[0]
 	si.StdOutput = fd[1]
 	si.StdErr = fd[2]
diff --git a/src/syscall/exec_windows_test.go b/src/syscall/exec_windows_test.go
index eda1d36877..8a1c2ceaae 100644
--- a/src/syscall/exec_windows_test.go
+++ b/src/syscall/exec_windows_test.go
@@ -5,8 +5,14 @@
 package syscall_test
 
 import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
 	"syscall"
 	"testing"
+	"time"
 )
 
 func TestEscapeArg(t *testing.T) {
@@ -41,3 +47,70 @@ func TestEscapeArg(t *testing.T) {
 		}
 	}
 }
+
+func TestChangingProcessParent(t *testing.T) {
+	if os.Getenv("GO_WANT_HELPER_PROCESS") == "parent" {
+		// in parent process
+
+		// Parent does nothign. It is just used as a parent of a child process.
+		time.Sleep(time.Minute)
+		os.Exit(0)
+	}
+
+	if os.Getenv("GO_WANT_HELPER_PROCESS") == "child" {
+		// in child process
+		dumpPath := os.Getenv("GO_WANT_HELPER_PROCESS_FILE")
+		if dumpPath == "" {
+			fmt.Fprintf(os.Stderr, "Dump file path cannot be blank.")
+			os.Exit(1)
+		}
+		err := os.WriteFile(dumpPath, []byte(fmt.Sprintf("%d", os.Getppid())), 0644)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error writing dump file: %v", err)
+			os.Exit(2)
+		}
+		os.Exit(0)
+	}
+
+	// run parent process
+
+	parent := exec.Command(os.Args[0], "-test.run=TestChangingProcessParent")
+	parent.Env = append(os.Environ(), "GO_WANT_HELPER_PROCESS=parent")
+	err := parent.Start()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		parent.Process.Kill()
+		parent.Wait()
+	}()
+
+	// run child process
+
+	const _PROCESS_CREATE_PROCESS = 0x0080
+	const _PROCESS_DUP_HANDLE = 0x0040
+	childDumpPath := filepath.Join(t.TempDir(), "ppid.txt")
+	ph, err := syscall.OpenProcess(_PROCESS_CREATE_PROCESS|_PROCESS_DUP_HANDLE|syscall.PROCESS_QUERY_INFORMATION,
+		false, uint32(parent.Process.Pid))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer syscall.CloseHandle(ph)
+
+	child := exec.Command(os.Args[0], "-test.run=TestChangingProcessParent")
+	child.Env = append(os.Environ(),
+		"GO_WANT_HELPER_PROCESS=child",
+		"GO_WANT_HELPER_PROCESS_FILE="+childDumpPath)
+	child.SysProcAttr = &syscall.SysProcAttr{ParentProcess: ph}
+	childOutput, err := child.CombinedOutput()
+	if err != nil {
+		t.Errorf("child failed: %v: %v", err, string(childOutput))
+	}
+	childOutput, err = ioutil.ReadFile(childDumpPath)
+	if err != nil {
+		t.Fatalf("reading child ouput failed: %v", err)
+	}
+	if got, want := string(childOutput), fmt.Sprintf("%d", parent.Process.Pid); got != want {
+		t.Fatalf("child output: want %q, got %q", want, got)
+	}
+}
-- 
GitLab


From d8e33d558e2c5fcd7f9092790780e68adbac0f1b Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Sun, 21 Feb 2021 10:54:38 -0800
Subject: [PATCH 0866/2400] cmd/compile: deal with closures in generic
 functions and instantiated function values

 - Deal with closures in generic functions by fixing the stenciling code

 - Deal with instantiated function values (instantiated generic
   functions that are not immediately called) during stenciling. This
   requires changing the OFUNCINST node to an ONAME node for the
   appropriately instantiated function. We do this in a second pass,
   since this is uncommon, but requires editing the tree at multiple
   levels.

 - Check global assignments (as well as functions) for generic function
   instantiations.

 - Fix a bug in (*subst).typ where a generic type in a generic function
   may definitely not use all the type args of the function, so we need
   to translate the rparams of the type based on the tparams/targs of
   the function.

 - Added new test combine.go that tests out closures in generic
   functions and instantiated function values.

 - Added one new variant to the settable test.

 - Enabling inlining functions with closures for -G=3. (For now, set
   Ntype on closures in -G=3 mode to keep compatibility with later parts
   of compiler, and allow inlining of functions with closures.)

Change-Id: Iea63d5704c322e42e2f750a83adc8b44f911d4ec
Reviewed-on: https://go-review.googlesource.com/c/go/+/296269
Reviewed-by: Robert Griesemer <gri@golang.org>
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/inline/inl.go    |   2 +-
 src/cmd/compile/internal/noder/expr.go    |  11 +-
 src/cmd/compile/internal/noder/stencil.go | 182 +++++++++++++++++-----
 test/typeparam/combine.go                 |  65 ++++++++
 test/typeparam/settable.go                |  27 +++-
 5 files changed, 236 insertions(+), 51 deletions(-)
 create mode 100644 test/typeparam/combine.go

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index e961b10844..1d049298d7 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -354,7 +354,7 @@ func (v *hairyVisitor) doNode(n ir.Node) bool {
 		return true
 
 	case ir.OCLOSURE:
-		if base.Debug.InlFuncsWithClosures == 0 || base.Flag.G > 0 {
+		if base.Debug.InlFuncsWithClosures == 0 {
 			v.reason = "not inlining functions with closures"
 			return true
 		}
diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index b166d34ead..3fded144dc 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -325,19 +325,22 @@ func (g *irgen) compLit(typ types2.Type, lit *syntax.CompositeLit) ir.Node {
 	return typecheck.Expr(ir.NewCompLitExpr(g.pos(lit), ir.OCOMPLIT, ir.TypeNode(g.typ(typ)), exprs))
 }
 
-func (g *irgen) funcLit(typ types2.Type, expr *syntax.FuncLit) ir.Node {
+func (g *irgen) funcLit(typ2 types2.Type, expr *syntax.FuncLit) ir.Node {
 	fn := ir.NewFunc(g.pos(expr))
 	fn.SetIsHiddenClosure(ir.CurFunc != nil)
 
 	fn.Nname = ir.NewNameAt(g.pos(expr), typecheck.ClosureName(ir.CurFunc))
 	ir.MarkFunc(fn.Nname)
-	fn.Nname.SetType(g.typ(typ))
+	typ := g.typ(typ2)
 	fn.Nname.Func = fn
 	fn.Nname.Defn = fn
+	// Set Ntype for now to be compatible with later parts of compile, remove later.
+	fn.Nname.Ntype = ir.TypeNode(typ)
+	typed(typ, fn.Nname)
+	fn.SetTypecheck(1)
 
 	fn.OClosure = ir.NewClosureExpr(g.pos(expr), fn)
-	fn.OClosure.SetType(fn.Nname.Type())
-	fn.OClosure.SetTypecheck(1)
+	typed(typ, fn.OClosure)
 
 	g.funcBody(fn, nil, expr.Type, expr.Body)
 
diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 69461a8190..fb1bbfedc8 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -27,19 +27,37 @@ func (g *irgen) stencil() {
 	// functions calling other generic functions.
 	for i := 0; i < len(g.target.Decls); i++ {
 		decl := g.target.Decls[i]
-		if decl.Op() != ir.ODCLFUNC || decl.Type().NumTParams() > 0 {
-			// Skip any non-function declarations and skip generic functions
+
+		// Look for function instantiations in bodies of non-generic
+		// functions or in global assignments (ignore global type and
+		// constant declarations).
+		switch decl.Op() {
+		case ir.ODCLFUNC:
+			if decl.Type().HasTParam() {
+				// Skip any generic functions
+				continue
+			}
+
+		case ir.OAS:
+
+		case ir.OAS2:
+
+		default:
 			continue
 		}
 
-		// For each non-generic function, search for any function calls using
-		// generic function instantiations. (We don't yet handle generic
-		// function instantiations that are not immediately called.)
-		// Then create the needed instantiated function if it hasn't been
-		// created yet, and change to calling that function directly.
-		f := decl.(*ir.Func)
+		// For all non-generic code, search for any function calls using
+		// generic function instantiations. Then create the needed
+		// instantiated function if it hasn't been created yet, and change
+		// to calling that function directly.
 		modified := false
-		ir.VisitList(f.Body, func(n ir.Node) {
+		foundFuncInst := false
+		ir.Visit(decl, func(n ir.Node) {
+			if n.Op() == ir.OFUNCINST {
+				// We found a function instantiation that is not
+				// immediately called.
+				foundFuncInst = true
+			}
 			if n.Op() != ir.OCALLFUNC || n.(*ir.CallExpr).X.Op() != ir.OFUNCINST {
 				return
 			}
@@ -47,19 +65,7 @@ func (g *irgen) stencil() {
 			// instantiation.
 			call := n.(*ir.CallExpr)
 			inst := call.X.(*ir.InstExpr)
-			sym := makeInstName(inst)
-			//fmt.Printf("Found generic func call in %v to %v\n", f, s)
-			st := g.target.Stencils[sym]
-			if st == nil {
-				// If instantiation doesn't exist yet, create it and add
-				// to the list of decls.
-				st = genericSubst(sym, inst)
-				g.target.Stencils[sym] = st
-				g.target.Decls = append(g.target.Decls, st)
-				if base.Flag.W > 1 {
-					ir.Dump(fmt.Sprintf("\nstenciled %v", st), st)
-				}
-			}
+			st := g.getInstantiation(inst)
 			// Replace the OFUNCINST with a direct reference to the
 			// new stenciled function
 			call.X = st.Nname
@@ -76,6 +82,26 @@ func (g *irgen) stencil() {
 			}
 			modified = true
 		})
+
+		// If we found an OFUNCINST without a corresponding call in the
+		// above decl, then traverse the nodes of decl again (with
+		// EditChildren rather than Visit), where we actually change the
+		// OFUNCINST node to an ONAME for the instantiated function.
+		// EditChildren is more expensive than Visit, so we only do this
+		// in the infrequent case of an OFUNCINSt without a corresponding
+		// call.
+		if foundFuncInst {
+			var edit func(ir.Node) ir.Node
+			edit = func(x ir.Node) ir.Node {
+				if x.Op() == ir.OFUNCINST {
+					st := g.getInstantiation(x.(*ir.InstExpr))
+					return st.Nname
+				}
+				ir.EditChildren(x, edit)
+				return x
+			}
+			edit(decl)
+		}
 		if base.Flag.W > 1 && modified {
 			ir.Dump(fmt.Sprintf("\nmodified %v", decl), decl)
 		}
@@ -83,18 +109,39 @@ func (g *irgen) stencil() {
 
 }
 
-// makeInstName makes the unique name for a stenciled generic function, based on
-// the name of the function and the types of the type params.
-func makeInstName(inst *ir.InstExpr) *types.Sym {
-	b := bytes.NewBufferString("#")
+// getInstantiation gets the instantiated function corresponding to inst. If the
+// instantiated function is not already cached, then it calls genericStub to
+// create the new instantiation.
+func (g *irgen) getInstantiation(inst *ir.InstExpr) *ir.Func {
+	var sym *types.Sym
 	if meth, ok := inst.X.(*ir.SelectorExpr); ok {
 		// Write the name of the generic method, including receiver type
-		b.WriteString(meth.Selection.Nname.Sym().Name)
+		sym = makeInstName(meth.Selection.Nname.Sym(), inst.Targs)
 	} else {
-		b.WriteString(inst.X.(*ir.Name).Name().Sym().Name)
+		sym = makeInstName(inst.X.(*ir.Name).Name().Sym(), inst.Targs)
 	}
+	//fmt.Printf("Found generic func call in %v to %v\n", f, s)
+	st := g.target.Stencils[sym]
+	if st == nil {
+		// If instantiation doesn't exist yet, create it and add
+		// to the list of decls.
+		st = g.genericSubst(sym, inst)
+		g.target.Stencils[sym] = st
+		g.target.Decls = append(g.target.Decls, st)
+		if base.Flag.W > 1 {
+			ir.Dump(fmt.Sprintf("\nstenciled %v", st), st)
+		}
+	}
+	return st
+}
+
+// makeInstName makes the unique name for a stenciled generic function, based on
+// the name of the function and the targs.
+func makeInstName(fnsym *types.Sym, targs []ir.Node) *types.Sym {
+	b := bytes.NewBufferString("#")
+	b.WriteString(fnsym.Name)
 	b.WriteString("[")
-	for i, targ := range inst.Targs {
+	for i, targ := range targs {
 		if i > 0 {
 			b.WriteString(",")
 		}
@@ -107,6 +154,7 @@ func makeInstName(inst *ir.InstExpr) *types.Sym {
 // Struct containing info needed for doing the substitution as we create the
 // instantiation of a generic function with specified type arguments.
 type subster struct {
+	g       *irgen
 	newf    *ir.Func // Func node for the new stenciled function
 	tparams []*types.Field
 	targs   []ir.Node
@@ -121,7 +169,7 @@ type subster struct {
 // inst. For a method with a generic receiver, it returns an instantiated function
 // type where the receiver becomes the first parameter. Otherwise the instantiated
 // method would still need to be transformed by later compiler phases.
-func genericSubst(name *types.Sym, inst *ir.InstExpr) *ir.Func {
+func (g *irgen) genericSubst(name *types.Sym, inst *ir.InstExpr) *ir.Func {
 	var nameNode *ir.Name
 	var tparams []*types.Field
 	if selExpr, ok := inst.X.(*ir.SelectorExpr); ok {
@@ -148,6 +196,7 @@ func genericSubst(name *types.Sym, inst *ir.InstExpr) *ir.Func {
 	name.Def = newf.Nname
 
 	subst := &subster{
+		g:       g,
 		newf:    newf,
 		tparams: tparams,
 		targs:   inst.Targs,
@@ -198,6 +247,9 @@ func (subst *subster) node(n ir.Node) ir.Node {
 				return v
 			}
 			m := ir.NewNameAt(name.Pos(), name.Sym())
+			if name.IsClosureVar() {
+				m.SetIsClosureVar(true)
+			}
 			t := x.Type()
 			newt := subst.typ(t)
 			m.SetType(newt)
@@ -219,10 +271,12 @@ func (subst *subster) node(n ir.Node) ir.Node {
 				// t can be nil only if this is a call that has no
 				// return values, so allow that and otherwise give
 				// an error.
-				if _, isCallExpr := m.(*ir.CallExpr); !isCallExpr {
+				_, isCallExpr := m.(*ir.CallExpr)
+				_, isStructKeyExpr := m.(*ir.StructKeyExpr)
+				if !isCallExpr && !isStructKeyExpr {
 					base.Fatalf(fmt.Sprintf("Nil type for %v", x))
 				}
-			} else {
+			} else if x.Op() != ir.OCLOSURE {
 				m.SetType(subst.typ(x.Type()))
 			}
 		}
@@ -270,14 +324,27 @@ func (subst *subster) node(n ir.Node) ir.Node {
 			if oldfn.ClosureCalled() {
 				newfn.SetClosureCalled(true)
 			}
+			newfn.SetIsHiddenClosure(true)
 			m.(*ir.ClosureExpr).Func = newfn
-			newfn.Nname = ir.NewNameAt(oldfn.Nname.Pos(), oldfn.Nname.Sym())
-			newfn.Nname.SetType(oldfn.Nname.Type())
-			newfn.Nname.Ntype = subst.node(oldfn.Nname.Ntype).(ir.Ntype)
+			newsym := makeInstName(oldfn.Nname.Sym(), subst.targs)
+			newfn.Nname = ir.NewNameAt(oldfn.Nname.Pos(), newsym)
+			newfn.Nname.Func = newfn
+			newfn.Nname.Defn = newfn
+			ir.MarkFunc(newfn.Nname)
+			newfn.OClosure = m.(*ir.ClosureExpr)
+
+			saveNewf := subst.newf
+			subst.newf = newfn
+			newfn.Dcl = subst.namelist(oldfn.Dcl)
+			newfn.ClosureVars = subst.namelist(oldfn.ClosureVars)
 			newfn.Body = subst.list(oldfn.Body)
-			// Make shallow copy of the Dcl and ClosureVar slices
-			newfn.Dcl = append([]*ir.Name(nil), oldfn.Dcl...)
-			newfn.ClosureVars = append([]*ir.Name(nil), oldfn.ClosureVars...)
+			subst.newf = saveNewf
+
+			// Set Ntype for now to be compatible with later parts of compiler
+			newfn.Nname.Ntype = subst.node(oldfn.Nname.Ntype).(ir.Ntype)
+			typed(subst.typ(oldfn.Nname.Type()), newfn.Nname)
+			newfn.SetTypecheck(1)
+			subst.g.target.Decls = append(subst.g.target.Decls, newfn)
 		}
 		return m
 	}
@@ -285,6 +352,20 @@ func (subst *subster) node(n ir.Node) ir.Node {
 	return edit(n)
 }
 
+func (subst *subster) namelist(l []*ir.Name) []*ir.Name {
+	s := make([]*ir.Name, len(l))
+	for i, n := range l {
+		s[i] = subst.node(n).(*ir.Name)
+		if n.Defn != nil {
+			s[i].Defn = subst.node(n.Defn)
+		}
+		if n.Outer != nil {
+			s[i].Outer = subst.node(n.Outer).(*ir.Name)
+		}
+	}
+	return s
+}
+
 func (subst *subster) list(l []ir.Node) []ir.Node {
 	s := make([]ir.Node, len(l))
 	for i, n := range l {
@@ -293,7 +374,9 @@ func (subst *subster) list(l []ir.Node) []ir.Node {
 	return s
 }
 
-// tstruct substitutes type params in a structure type
+// tstruct substitutes type params in types of the fields of a structure type. For
+// each field, if Nname is set, tstruct also translates the Nname using subst.vars, if
+// Nname is in subst.vars.
 func (subst *subster) tstruct(t *types.Type) *types.Type {
 	if t.NumFields() == 0 {
 		return t
@@ -301,7 +384,7 @@ func (subst *subster) tstruct(t *types.Type) *types.Type {
 	var newfields []*types.Field
 	for i, f := range t.Fields().Slice() {
 		t2 := subst.typ(f.Type)
-		if t2 != f.Type && newfields == nil {
+		if (t2 != f.Type || f.Nname != nil) && newfields == nil {
 			newfields = make([]*types.Field, t.NumFields())
 			for j := 0; j < i; j++ {
 				newfields[j] = t.Field(j)
@@ -309,6 +392,12 @@ func (subst *subster) tstruct(t *types.Type) *types.Type {
 		}
 		if newfields != nil {
 			newfields[i] = types.NewField(f.Pos, f.Sym, t2)
+			if f.Nname != nil {
+				// f.Nname may not be in subst.vars[] if this is
+				// a function name or a function instantiation type
+				// that we are translating
+				newfields[i].Nname = subst.vars[f.Nname.(*ir.Name)]
+			}
 		}
 	}
 	if newfields != nil {
@@ -319,14 +408,14 @@ func (subst *subster) tstruct(t *types.Type) *types.Type {
 }
 
 // instTypeName creates a name for an instantiated type, based on the type args
-func instTypeName(name string, targs []ir.Node) string {
+func instTypeName(name string, targs []*types.Type) string {
 	b := bytes.NewBufferString(name)
 	b.WriteByte('[')
 	for i, targ := range targs {
 		if i > 0 {
 			b.WriteByte(',')
 		}
-		b.WriteString(targ.Type().String())
+		b.WriteString(targ.String())
 	}
 	b.WriteByte(']')
 	return b.String()
@@ -415,10 +504,17 @@ func (subst *subster) typ(t *types.Type) *types.Type {
 			// Since we've substituted types, we also need to change
 			// the defined name of the type, by removing the old types
 			// (in brackets) from the name, and adding the new types.
+
+			// Translate the type params for this type according to
+			// the tparam/targs mapping of the function.
+			neededTargs := make([]*types.Type, len(t.RParams))
+			for i, rparam := range t.RParams {
+				neededTargs[i] = subst.typ(rparam)
+			}
 			oldname := t.Sym().Name
 			i := strings.Index(oldname, "[")
 			oldname = oldname[:i]
-			sym := t.Sym().Pkg.Lookup(instTypeName(oldname, subst.targs))
+			sym := t.Sym().Pkg.Lookup(instTypeName(oldname, neededTargs))
 			if sym.Def != nil {
 				// We've already created this instantiated defined type.
 				return sym.Def.Type()
diff --git a/test/typeparam/combine.go b/test/typeparam/combine.go
new file mode 100644
index 0000000000..d4a2988a7b
--- /dev/null
+++ b/test/typeparam/combine.go
@@ -0,0 +1,65 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 (
+	"fmt"
+)
+
+type _Gen[A any] func() (A, bool)
+
+func combine[T1, T2, T any](g1 _Gen[T1], g2 _Gen[T2], join func(T1, T2) T) _Gen[T] {
+    return func() (T, bool) {
+        var t T
+        t1, ok := g1()
+        if !ok {
+            return t, false
+        }
+        t2, ok := g2()
+        if !ok {
+            return t, false
+        }
+        return join(t1, t2), true
+    }
+}
+
+type _Pair[A, B any] struct {
+	A A
+	B B
+}
+
+func _NewPair[A, B any](a A, b B) _Pair[A, B] {
+	return _Pair[A, B]{a, b}
+}
+
+func _Combine2[A, B any](ga _Gen[A], gb _Gen[B]) _Gen[_Pair[A, B]] {
+    return combine(ga, gb, _NewPair[A, B])
+}
+
+func main() {
+	var g1 _Gen[int] = func() (int, bool) { return 3, true }
+	var g2 _Gen[string] = func() (string, bool) { return "x", false }
+	var g3 _Gen[string] = func() (string, bool) { return "y", true }
+
+	gc := combine(g1, g2, _NewPair[int, string])
+	if got, ok := gc(); ok {
+		panic(fmt.Sprintf("got %v, %v, wanted -/false", got, ok))
+	}
+	gc2 := _Combine2(g1, g2)
+	if got, ok := gc2(); ok {
+		panic(fmt.Sprintf("got %v, %v, wanted -/false", got, ok))
+	}
+
+	gc3 := combine(g1, g3, _NewPair[int, string])
+	if got, ok := gc3(); !ok || got.A != 3 || got.B != "y" {
+		panic(fmt.Sprintf("got %v, %v, wanted {3, y}, true", got, ok))
+	}
+	gc4 := _Combine2(g1, g3)
+	if got, ok := gc4(); !ok || got.A != 3 || got.B != "y" {
+		panic (fmt.Sprintf("got %v, %v, wanted {3, y}, true", got, ok))
+	}
+}
diff --git a/test/typeparam/settable.go b/test/typeparam/settable.go
index 3bd141f784..7532953a77 100644
--- a/test/typeparam/settable.go
+++ b/test/typeparam/settable.go
@@ -11,7 +11,24 @@ import (
 	"strconv"
 )
 
-func fromStrings3[T any](s []string, set func(*T, string)) []T {
+type Setter[B any] interface {
+        Set(string)
+	type *B
+}
+
+func fromStrings1[T any, PT Setter[T]](s []string) []T {
+        result := make([]T, len(s))
+        for i, v := range s {
+                // The type of &result[i] is *T which is in the type list
+                // of Setter, so we can convert it to PT.
+                p := PT(&result[i])
+                // PT has a Set method.
+                p.Set(v)
+        }
+        return result
+}
+
+func fromStrings2[T any](s []string, set func(*T, string)) []T {
         results := make([]T, len(s))
         for i, v := range s {
                 set(&results[i], v)
@@ -30,8 +47,12 @@ func (p *Settable) Set(s string) {
 }
 
 func main() {
-        s := fromStrings3([]string{"1"},
-                func(p *Settable, s string) { p.Set(s) })
+        s := fromStrings1[Settable, *Settable]([]string{"1"})
+        if len(s) != 1 || s[0] != 1 {
+                panic(fmt.Sprintf("got %v, want %v", s, []int{1}))
+        }
+
+        s = fromStrings2([]string{"1"}, func(p *Settable, s string) { p.Set(s) })
         if len(s) != 1 || s[0] != 1 {
                 panic(fmt.Sprintf("got %v, want %v", s, []int{1}))
         }
-- 
GitLab


From cda8ee095e487951eab5a53a097e2b8f400f237d Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Wed, 17 Feb 2021 19:14:03 +0000
Subject: [PATCH 0867/2400] reflect: fix register ABI spill space calculation

Currently this does things the old way by computing the number of
registers, but we're going to be using their ABI0 layout for the spill
space for now.

Change-Id: Ibcef1ee48fd834af7cbdaabe704bcabe066ed358
Reviewed-on: https://go-review.googlesource.com/c/go/+/293011
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: Michael Knyszek <mknyszek@google.com>
---
 src/reflect/abi.go | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/src/reflect/abi.go b/src/reflect/abi.go
index 88af212717..20f41d96b5 100644
--- a/src/reflect/abi.go
+++ b/src/reflect/abi.go
@@ -334,8 +334,7 @@ func newAbiDesc(t *funcType, rcvr *rtype) abiDesc {
 	//
 	// TODO(mknyszek): Remove this when we no longer have
 	// caller reserved spill space.
-	spillInt := uintptr(0)
-	spillFloat := uintptr(0)
+	spill := uintptr(0)
 
 	// Compute gc program & stack bitmap for stack arguments
 	stackPtrs := new(bitVector)
@@ -351,21 +350,19 @@ func newAbiDesc(t *funcType, rcvr *rtype) abiDesc {
 				stackPtrs.append(0)
 			}
 		} else {
-			spillInt += ptrSize
+			spill += ptrSize
 		}
 	}
 	for _, arg := range t.in() {
-		i, f := in.iregs, in.fregs
 		stkStep := in.addArg(arg)
 		if stkStep != nil {
 			addTypeBits(stackPtrs, stkStep.stkOff, arg)
 		} else {
-			i, f = in.iregs-i, in.fregs-f
-			spillInt += uintptr(i) * ptrSize
-			spillFloat += uintptr(f) * abi.EffectiveFloatRegSize
+			spill = align(spill, uintptr(arg.align))
+			spill += arg.size
 		}
 	}
-	spill := align(spillInt+spillFloat, ptrSize)
+	spill = align(spill, ptrSize)
 
 	// From the input parameters alone, we now know
 	// the stackCallArgsSize and retOffset.
-- 
GitLab


From d9fd38e68ba00a51c2c7363150688d0e7687ef84 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Thu, 25 Feb 2021 10:01:56 -0800
Subject: [PATCH 0868/2400] time: correct unusual extension string cases

This fixes two uncommon cases.

First, the tzdata code permits timezone offsets up to 24 * 7, although
the POSIX TZ parsing does not. The tzdata code uses this to specify a
day of week in some cases.

Second, we incorrectly rejected a negative time offset for when a time
zone change comes into effect.

Fixes #44385

Change-Id: I5f2efc1d385e9bfa974a0de3fa81e7a94b827602
Reviewed-on: https://go-review.googlesource.com/c/go/+/296392
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/time/zoneinfo.go      |  6 ++--
 src/time/zoneinfo_test.go | 60 +++++++++++++++++++++++++++++----------
 2 files changed, 49 insertions(+), 17 deletions(-)

diff --git a/src/time/zoneinfo.go b/src/time/zoneinfo.go
index c3662297c7..6db9443474 100644
--- a/src/time/zoneinfo.go
+++ b/src/time/zoneinfo.go
@@ -377,8 +377,10 @@ func tzsetOffset(s string) (offset int, rest string, ok bool) {
 		neg = true
 	}
 
+	// The tzdata code permits values up to 24 * 7 here,
+	// although POSIX does not.
 	var hours int
-	hours, s, ok = tzsetNum(s, 0, 24)
+	hours, s, ok = tzsetNum(s, 0, 24*7)
 	if !ok {
 		return 0, "", false
 	}
@@ -487,7 +489,7 @@ func tzsetRule(s string) (rule, string, bool) {
 	}
 
 	offset, s, ok := tzsetOffset(s[1:])
-	if !ok || offset < 0 {
+	if !ok {
 		return rule{}, "", false
 	}
 	r.time = offset
diff --git a/src/time/zoneinfo_test.go b/src/time/zoneinfo_test.go
index 277b68f798..d043e1e9f1 100644
--- a/src/time/zoneinfo_test.go
+++ b/src/time/zoneinfo_test.go
@@ -183,22 +183,50 @@ func TestMalformedTZData(t *testing.T) {
 	}
 }
 
-func TestLoadLocationFromTZDataSlim(t *testing.T) {
-	// A 2020b slim tzdata for Europe/Berlin
-	tzData := "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00<\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xffo\xa2a\xf8\xff\xff\xff\xff\x9b\f\x17`\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9cٮ\x90\xff\xff\xff\xff\x9d\xa4\xb5\x90\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\xc8\tq\x90\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xffѶ\x96\x00\xff\xff\xff\xff\xd2X\xbe\x80\xff\xff\xff\xffҡO\x10\xff\xff\xff\xff\xd3c\x1b\x90\xff\xff\xff\xff\xd4K#\x90\xff\xff\xff\xff\xd59\xd1 \xff\xff\xff\xff\xd5g\xe7\x90\xff\xff\xff\xffըs\x00\xff\xff\xff\xff\xd6)\xb4\x10\xff\xff\xff\xff\xd7,\x1a\x10\xff\xff\xff\xff\xd8\t\x96\x10\xff\xff\xff\xff\xd9\x02\xc1\x90\xff\xff\xff\xff\xd9\xe9x\x10\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x01\x02\x01\x02\x01\x03\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00\f\x88\x00\x00\x00\x00\x1c \x01\x04\x00\x00\x0e\x10\x00\t\x00\x00*0\x01\rLMT\x00CEST\x00CET\x00CEMT\x00\nCET-1CEST,M3.5.0,M10.5.0/3\n"
+var slimTests = []struct {
+	zoneName   string
+	tzData     string
+	wantName   string
+	wantOffset int
+}{
+	{
+		// 2020b slim tzdata for Europe/Berlin.
+		zoneName:   "Europe/Berlin",
+		tzData:     "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00<\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xffo\xa2a\xf8\xff\xff\xff\xff\x9b\f\x17`\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9cٮ\x90\xff\xff\xff\xff\x9d\xa4\xb5\x90\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\xc8\tq\x90\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xffѶ\x96\x00\xff\xff\xff\xff\xd2X\xbe\x80\xff\xff\xff\xffҡO\x10\xff\xff\xff\xff\xd3c\x1b\x90\xff\xff\xff\xff\xd4K#\x90\xff\xff\xff\xff\xd59\xd1 \xff\xff\xff\xff\xd5g\xe7\x90\xff\xff\xff\xffըs\x00\xff\xff\xff\xff\xd6)\xb4\x10\xff\xff\xff\xff\xd7,\x1a\x10\xff\xff\xff\xff\xd8\t\x96\x10\xff\xff\xff\xff\xd9\x02\xc1\x90\xff\xff\xff\xff\xd9\xe9x\x10\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x01\x02\x01\x02\x01\x03\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00\f\x88\x00\x00\x00\x00\x1c \x01\x04\x00\x00\x0e\x10\x00\t\x00\x00*0\x01\rLMT\x00CEST\x00CET\x00CEMT\x00\nCET-1CEST,M3.5.0,M10.5.0/3\n",
+		wantName:   "CET",
+		wantOffset: 3600,
+	},
+	{
+		// 2021a slim tzdata for America/Nuuk.
+		zoneName:   "America/Nuuk",
+		tzData:     "TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\"\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x9b\x80h\x00\x00\x00\x00\x00\x13M|P\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xffπ\x00\x00\xff\xff\xd5\xd0\x00\x04\xff\xff\xe3\xe0\x01\bLMT\x00-03\x00-02\x00\n<-03>3<-02>,M3.5.0/-2,M10.5.0/-1\n",
+		wantName:   "-03",
+		wantOffset: -10800,
+	},
+	{
+		// 2021a slim tzdata for Asia/Gaza.
+		zoneName:   "Asia/Gaza",
+		tzData:     "TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00s\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xff}\xbdJ\xb0\xff\xff\xff\xff\xc8Y\xcf\x00\xff\xff\xff\xff\xc8\xfa\xa6\x00\xff\xff\xff\xff\xc98\x9c\x80\xff\xff\xff\xff\xcc\xe5\xeb\x80\xff\xff\xff\xffͬ\xfe\x00\xff\xff\xff\xff\xce\xc7\x1f\x00\xff\xff\xff\xffϏ\x83\x00\xff\xff\xff\xffЩ\xa4\x00\xff\xff\xff\xffф}\x00\xff\xff\xff\xffҊ׀\xff\xff\xff\xff\xd3e\xb0\x80\xff\xff\xff\xff\xd4l\v\x00\xff\xff\xff\xff\xe86c`\xff\xff\xff\xff\xe8\xf4-P\xff\xff\xff\xff\xea\v\xb9`\xff\xff\xff\xff\xea\xd5`\xd0\xff\xff\xff\xff\xeb\xec\xfa\xf0\xff\xff\xff\xff\xec\xb5m\x00\xff\xff\xff\xff\xed\xcf\u007f\xf0\xff\xff\xff\xff\xee\x97\xf2\x00\xff\xff\xff\xffﰳp\xff\xff\xff\xff\xf0y%\x80\xff\xff\xff\xff\xf1\x91\xe6\xf0\xff\xff\xff\xff\xf2ZY\x00\xff\xff\xff\xff\xf3s\x1ap\xff\xff\xff\xff\xf4;\x8c\x80\xff\xff\xff\xff\xf5U\x9fp\xff\xff\xff\xff\xf6\x1e\x11\x80\xff\xff\xff\xff\xf76\xd2\xf0\xff\xff\xff\xff\xf7\xffE\x00\xff\xff\xff\xff\xf9\x18\x06p\xff\xff\xff\xff\xf9\xe1\xca\x00\xff\xff\xff\xff\xfa\xf99\xf0\xff\xff\xff\xff\xfb'BP\x00\x00\x00\x00\b|\x8b\xe0\x00\x00\x00\x00\b\xfd\xb0\xd0\x00\x00\x00\x00\t\xf6\xea`\x00\x00\x00\x00\n\xa63\xd0\x00\x00\x00\x00\x13\xe9\xfc`\x00\x00\x00\x00\x14![`\x00\x00\x00\x00\x1a\xfa\xc6`\x00\x00\x00\x00\x1b\x8en`\x00\x00\x00\x00\x1c\xbe\xf8\xe0\x00\x00\x00\x00\x1dw|\xd0\x00\x00\x00\x00\x1e\xcc\xff`\x00\x00\x00\x00\x1f`\x99P\x00\x00\x00\x00 \x82\xb1`\x00\x00\x00\x00!I\xb5\xd0\x00\x00\x00\x00\"^\x9e\xe0\x00\x00\x00\x00# ]P\x00\x00\x00\x00$Z0`\x00\x00\x00\x00%\x00?P\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00&\xd6\xe6\xd0\x00\x00\x00\x00'\xeb\xcf\xe0\x00\x00\x00\x00(\xc0\x03P\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xa9\x1f\xd0\x00\x00\x00\x00+\xbbe\xe0\x00\x00\x00\x00,\x89\x01\xd0\x00\x00\x00\x00-\x9bG\xe0\x00\x00\x00\x00._\xa9P\x00\x00\x00\x00/{)\xe0\x00\x00\x00\x000H\xc5\xd0\x00\x00\x00\x000\xe7\a\xe0\x00\x00\x00\x001dF`\x00\x00\x00\x002A\xc2`\x00\x00\x00\x003D(`\x00\x00\x00\x004!\xa4`\x00\x00\x00\x005$\n`\x00\x00\x00\x006\x01\x86`\x00\x00\x00\x007\x16a`\x00\x00\x00\x008\x06DP\x00\x00\x00\x008\xff}\xe0\x00\x00\x00\x009\xef`\xd0\x00\x00\x00\x00:\xdf_\xe0\x00\x00\x00\x00;\xcfB\xd0\x00\x00\x00\x00<\xbfA\xe0\x00\x00\x00\x00=\xaf$\xd0\x00\x00\x00\x00>\x9f#\xe0\x00\x00\x00\x00?\x8f\x06\xd0\x00\x00\x00\x00@\u007f\x05\xe0\x00\x00\x00\x00A\\\x81\xe0\x00\x00\x00\x00B^\xe7\xe0\x00\x00\x00\x00CA\xb7\xf0\x00\x00\x00\x00D-\xa6`\x00\x00\x00\x00E\x12\xfdP\x00\x00\x00\x00F\x0e\xd9\xe0\x00\x00\x00\x00F\xe8op\x00\x00\x00\x00G\xec\x18\xe0\x00\x00\x00\x00H\xb7\x11\xd0\x00\x00\x00\x00I\xcb\xfa\xe0\x00\x00\x00\x00J\xa0<`\x00\x00\x00\x00K\xad.\x9c\x00\x00\x00\x00La\xbd\xd0\x00\x00\x00\x00M\x94\xf9\x9c\x00\x00\x00\x00N5\xc2P\x00\x00\x00\x00Ot\xdb`\x00\x00\x00\x00P[\x91\xe0\x00\x00\x00\x00QT\xbd`\x00\x00\x00\x00RD\xa0P\x00\x00\x00\x00S4\x9f`\x00\x00\x00\x00TIlP\x00\x00\x00\x00U\x15\xd2\xe0\x00\x00\x00\x00V)\\`\x00\x00\x00\x00V\xf5\xc2\xf0\x00\x00\x00\x00X\x13\xca`\x00\x00\x00\x00Xդ\xf0\x00\x00\x00\x00Y\xf3\xac`\x00\x00\x00\x00Z\xb5\x86\xf0\x00\x00\x00\x00[ӎ`\x00\x00\x00\x00\\\x9dC\xe0\x00\x00\x00\x00]\xb3bP\x00\x00\x00\x00^~w`\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00 P\x00\x00\x00\x00*0\x01\x04\x00\x00\x1c \x00\t\x00\x00*0\x01\r\x00\x00\x1c \x00\x11LMT\x00EEST\x00EET\x00IDT\x00IST\x00\nEET-2EEST,M3.4.4/48,M10.4.4/49\n",
+		wantName:   "EET",
+		wantOffset: 7200,
+	},
+}
 
-	reference, err := time.LoadLocationFromTZData("Europe/Berlin", []byte(tzData))
-	if err != nil {
-		t.Fatal(err)
-	}
+func TestLoadLocationFromTZDataSlim(t *testing.T) {
+	for _, test := range slimTests {
+		reference, err := time.LoadLocationFromTZData(test.zoneName, []byte(test.tzData))
+		if err != nil {
+			t.Fatal(err)
+		}
 
-	d := time.Date(2020, time.October, 29, 15, 30, 0, 0, reference)
-	tzName, tzOffset := d.Zone()
-	if want := "CET"; tzName != want {
-		t.Errorf("Zone name == %s, want %s", tzName, want)
-	}
-	if want := 3600; tzOffset != want {
-		t.Errorf("Zone offset == %d, want %d", tzOffset, want)
+		d := time.Date(2020, time.October, 29, 15, 30, 0, 0, reference)
+		tzName, tzOffset := d.Zone()
+		if tzName != test.wantName {
+			t.Errorf("Zone name == %s, want %s", tzName, test.wantName)
+		}
+		if tzOffset != test.wantOffset {
+			t.Errorf("Zone offset == %d, want %d", tzOffset, test.wantOffset)
+		}
 	}
 }
 
@@ -263,7 +291,8 @@ func TestTzsetOffset(t *testing.T) {
 		{"+08", 8 * 60 * 60, "", true},
 		{"-01:02:03", -1*60*60 - 2*60 - 3, "", true},
 		{"01", 1 * 60 * 60, "", true},
-		{"100", 0, "", false},
+		{"100", 100 * 60 * 60, "", true},
+		{"1000", 0, "", false},
 		{"8PDT", 8 * 60 * 60, "PDT", true},
 	} {
 		off, out, ok := time.TzsetOffset(test.in)
@@ -288,6 +317,7 @@ func TestTzsetRule(t *testing.T) {
 		{"30/03:00:00", time.Rule{Kind: time.RuleDOY, Day: 30, Time: 3 * 60 * 60}, "", true},
 		{"M4.5.6/03:00:00", time.Rule{Kind: time.RuleMonthWeekDay, Mon: 4, Week: 5, Day: 6, Time: 3 * 60 * 60}, "", true},
 		{"M4.5.7/03:00:00", time.Rule{}, "", false},
+		{"M4.5.6/-04", time.Rule{Kind: time.RuleMonthWeekDay, Mon: 4, Week: 5, Day: 6, Time: -4 * 60 * 60}, "", true},
 	} {
 		r, out, ok := time.TzsetRule(test.in)
 		if r != test.r || out != test.out || ok != test.ok {
-- 
GitLab


From 998fe70b683ed64d0bc67d9e0a35f8a7bcbe161d Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Fri, 26 Feb 2021 17:37:26 -0500
Subject: [PATCH 0869/2400] cmd/compile: fixed which-result confusion in
 presence of 0-width types

A function returning multiple results, some of them zero-width,
will have more than one result present at an offset.  Be sure
that offset AND type match.

Includes test.

Change-Id: I3eb1f56116d989b4e73f533fefabb1bf554c901b
Reviewed-on: https://go-review.googlesource.com/c/go/+/297169
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
---
 src/cmd/compile/internal/ssa/op.go     |  9 ++++---
 src/cmd/compile/internal/ssagen/ssa.go |  4 ++--
 test/abi/f_ret_z_not.go                | 33 ++++++++++++++++++++++++++
 test/abi/f_ret_z_not.out               |  1 +
 4 files changed, 42 insertions(+), 5 deletions(-)
 create mode 100644 test/abi/f_ret_z_not.go
 create mode 100644 test/abi/f_ret_z_not.out

diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index 6949bdca31..ece274b083 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -86,12 +86,15 @@ type AuxCall struct {
 	abiInfo *abi.ABIParamResultInfo // TODO remove fields above redundant with this information.
 }
 
-// ResultForOffset returns the index of the result at a particular offset among the results
+// ResultForOffsetAndType returns the index of a t-typed result at *A* particular offset among the results.
+// An arbitrary number of zero-width-typed results may reside at the same offset with a single not-zero-width
+// typed result, but the ones with the same type are all indistinguishable so it doesn't matter "which one"
+// is obtained.
 // This does not include the mem result for the call opcode.
-func (a *AuxCall) ResultForOffset(offset int64) int64 {
+func (a *AuxCall) ResultForOffsetAndType(offset int64, t *types.Type) int64 {
 	which := int64(-1)
 	for i := int64(0); i < a.NResults(); i++ { // note aux NResults does not include mem result.
-		if a.OffsetOfResult(i) == offset {
+		if a.OffsetOfResult(i) == offset && a.TypeOfResult(i) == t {
 			which = i
 			break
 		}
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index ba00b9c7f6..865630dd3e 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -2909,7 +2909,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 			addr := s.constOffPtrSP(types.NewPtr(n.Type()), n.Offset)
 			return s.rawLoad(n.Type(), addr)
 		}
-		which := s.prevCall.Aux.(*ssa.AuxCall).ResultForOffset(n.Offset)
+		which := s.prevCall.Aux.(*ssa.AuxCall).ResultForOffsetAndType(n.Offset, n.Type())
 		if which == -1 {
 			// Do the old thing // TODO: Panic instead.
 			addr := s.constOffPtrSP(types.NewPtr(n.Type()), n.Offset)
@@ -5119,7 +5119,7 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 		if s.prevCall == nil || s.prevCall.Op != ssa.OpStaticLECall && s.prevCall.Op != ssa.OpInterLECall && s.prevCall.Op != ssa.OpClosureLECall {
 			return s.constOffPtrSP(t, n.Offset)
 		}
-		which := s.prevCall.Aux.(*ssa.AuxCall).ResultForOffset(n.Offset)
+		which := s.prevCall.Aux.(*ssa.AuxCall).ResultForOffsetAndType(n.Offset, n.Type())
 		if which == -1 {
 			// Do the old thing // TODO: Panic instead.
 			return s.constOffPtrSP(t, n.Offset)
diff --git a/test/abi/f_ret_z_not.go b/test/abi/f_ret_z_not.go
new file mode 100644
index 0000000000..b072aea75e
--- /dev/null
+++ b/test/abi/f_ret_z_not.go
@@ -0,0 +1,33 @@
+// run
+
+// Copyright 2021 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 "fmt"
+
+type Z struct {
+}
+
+type NZ struct {
+	x, y int
+}
+
+//go:noinline
+func f(x,y int) (Z,NZ,Z) {
+	var z Z
+	return z,NZ{x,y},z
+}
+
+//go:noinline
+func g() (Z,NZ,Z) {
+	a,b,c := f(3,4)
+	return c,b,a
+}
+
+func main() {
+	_,b,_ := g()
+	fmt.Println(b.x+b.y)
+}
diff --git a/test/abi/f_ret_z_not.out b/test/abi/f_ret_z_not.out
new file mode 100644
index 0000000000..7f8f011eb7
--- /dev/null
+++ b/test/abi/f_ret_z_not.out
@@ -0,0 +1 @@
+7
-- 
GitLab


From a429926159232f2e127d46698633ffce5896ae30 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 27 Feb 2021 09:41:19 -0800
Subject: [PATCH 0870/2400] cmd/compile: fix escape analysis of heap-allocated
 results

One of escape analysis's responsibilities is to summarize whether/how
each function parameter flows to the heap so we can correctly
incorporate those flows into callers' escape analysis data flow
graphs.

As an optimization, we separately record when parameters flow to
result parameters, so that we can more precisely analyze parameter
flows based on how the results are used at the call site. However, if
a named result parameter itself needs to be heap allocated, this
optimization isn't safe and the parameter needs to be recorded as
flowing to heap rather than flowing to result.

Escape analysis used to get this correct because it conservatively
rewalked the data-flow graph multiple times. So even though it would
incorrectly record the result parameter flow, it would separately find
a flow to the heap. However, CL 196811 (specifically, case 3)
optimized the walking logic to reduce unnecessary rewalks causing us
to stop finding the extra heap flow.

This CL fixes the issue by correcting location.leakTo to be sensitive
to sink.escapes and not record result-flows when the result parameter
escapes to the heap.

Fixes #44614.

Change-Id: I48742ed35a6cab591094e2d23a439e205bd65c50
Reviewed-on: https://go-review.googlesource.com/c/go/+/297289
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/escape/escape.go |  7 ++++---
 test/escape5.go                           | 11 +++++++++++
 2 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index 58cad73c76..213ef7832d 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -1625,9 +1625,10 @@ func containsClosure(f, c *ir.Func) bool {
 
 // leak records that parameter l leaks to sink.
 func (l *location) leakTo(sink *location, derefs int) {
-	// If sink is a result parameter and we can fit return bits
-	// into the escape analysis tag, then record a return leak.
-	if sink.isName(ir.PPARAMOUT) && sink.curfn == l.curfn {
+	// If sink is a result parameter that doesn't escape (#44614)
+	// and we can fit return bits into the escape analysis tag,
+	// then record as a result leak.
+	if !sink.escapes && sink.isName(ir.PPARAMOUT) && sink.curfn == l.curfn {
 		ri := sink.resultIndex - 1
 		if ri < numEscResults {
 			// Leak to result parameter.
diff --git a/test/escape5.go b/test/escape5.go
index 2ed2023cd2..82be2c38e7 100644
--- a/test/escape5.go
+++ b/test/escape5.go
@@ -269,3 +269,14 @@ func f28369(n int) int {
 
 	return 1 + f28369(n-1)
 }
+
+// Issue 44614: parameters that flow to a heap-allocated result
+// parameter must be recorded as a heap-flow rather than a
+// result-flow.
+
+// N.B., must match "leaking param: p",
+// but *not* "leaking param: p to result r level=0".
+func f(p *int) (r *int) { // ERROR "leaking param: p$" "moved to heap: r"
+	sink4 = &r
+	return p
+}
-- 
GitLab


From 5ff7ec98b7727b3641df25200345b1aa50b6ff35 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Tue, 9 Feb 2021 18:09:47 -0500
Subject: [PATCH 0871/2400] cmd/compile: check frame offsets against abi

this is in preparation for turning off calculation of frame offsets
in types.CalcSize

For #40724.

Change-Id: I2c29fd289c014674076e5ec5170055dbca5ea64b
Reviewed-on: https://go-review.googlesource.com/c/go/+/293392
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
---
 src/cmd/compile/internal/abi/abiutils.go      | 43 +++++++++++++--
 src/cmd/compile/internal/gc/compile.go        |  3 +
 src/cmd/compile/internal/ssa/op.go            | 18 +++---
 src/cmd/compile/internal/ssagen/ssa.go        | 55 ++++++++++++-------
 .../compile/internal/test/abiutilsaux_test.go | 32 -----------
 5 files changed, 85 insertions(+), 66 deletions(-)

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index b43d95e976..f5f3b25726 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -52,12 +52,12 @@ func (a *ABIParamResultInfo) OutRegistersUsed() int {
 	return a.outRegistersUsed
 }
 
-func (a *ABIParamResultInfo) InParam(i int) ABIParamAssignment {
-	return a.inparams[i]
+func (a *ABIParamResultInfo) InParam(i int) *ABIParamAssignment {
+	return &a.inparams[i]
 }
 
-func (a *ABIParamResultInfo) OutParam(i int) ABIParamAssignment {
-	return a.outparams[i]
+func (a *ABIParamResultInfo) OutParam(i int) *ABIParamAssignment {
+	return &a.outparams[i]
 }
 
 func (a *ABIParamResultInfo) SpillAreaOffset() int64 {
@@ -111,6 +111,18 @@ func (a *ABIParamAssignment) SpillOffset() int32 {
 	return a.offset
 }
 
+// FrameOffset returns the location that a value would spill to, if any exists.
+// For register-allocated inputs, that is their spill offset reserved for morestack
+// (might as well use it, it is there); for stack-allocated inputs and outputs,
+// that is their location on the stack.  For register-allocated outputs, there is
+// no defined spill area, so return -1.
+func (a *ABIParamAssignment) FrameOffset(i *ABIParamResultInfo) int64 {
+	if len(a.Registers) == 0 || a.offset == -1 {
+		return int64(a.offset)
+	}
+	return int64(a.offset) + i.SpillAreaOffset()
+}
+
 // RegAmounts holds a specified number of integer/float registers.
 type RegAmounts struct {
 	intRegs   int
@@ -265,9 +277,32 @@ func (config *ABIConfig) ABIAnalyze(t *types.Type) *ABIParamResultInfo {
 	result.spillAreaSize = alignTo(s.spillOffset, types.RegSize)
 	result.outRegistersUsed = s.rUsed.intRegs + s.rUsed.floatRegs
 
+	// Fill in the frame offsets for receiver, inputs, results
+	k := 0
+	if t.NumRecvs() != 0 {
+		config.updateOffset(result, ft.Receiver.FieldSlice()[0], result.inparams[0], false)
+		k++
+	}
+	for i, f := range ft.Params.FieldSlice() {
+		config.updateOffset(result, f, result.inparams[k+i], false)
+	}
+	for i, f := range ft.Results.FieldSlice() {
+		config.updateOffset(result, f, result.outparams[i], true)
+	}
 	return result
 }
 
+func (config *ABIConfig) updateOffset(result *ABIParamResultInfo, f *types.Field, a ABIParamAssignment, isReturn bool) {
+	if !isReturn || len(a.Registers) == 0 {
+		// TODO in next CL, assign
+		if f.Offset != a.FrameOffset(result) {
+			if config.regAmounts.intRegs == 0 && config.regAmounts.floatRegs == 0 {
+				panic(fmt.Errorf("Expected node offset %d != abi offset %d", f.Offset, a.FrameOffset(result)))
+			}
+		}
+	}
+}
+
 //......................................................................
 //
 // Non-public portions.
diff --git a/src/cmd/compile/internal/gc/compile.go b/src/cmd/compile/internal/gc/compile.go
index ba67c58c45..9a4c00a341 100644
--- a/src/cmd/compile/internal/gc/compile.go
+++ b/src/cmd/compile/internal/gc/compile.go
@@ -43,6 +43,9 @@ func enqueueFunc(fn *ir.Func) {
 	if len(fn.Body) == 0 {
 		// Initialize ABI wrappers if necessary.
 		ssagen.InitLSym(fn, false)
+		types.CalcSize(fn.Type()) // TODO register args; remove this once all is done by abiutils
+		a := ssagen.AbiForFunc(fn)
+		a.ABIAnalyze(fn.Type())   // will set parameter spill/home locations correctly
 		liveness.WriteFuncMap(fn)
 		return
 	}
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index ece274b083..e5778cb31a 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -104,13 +104,13 @@ func (a *AuxCall) ResultForOffsetAndType(offset int64, t *types.Type) int64 {
 
 // OffsetOfResult returns the SP offset of result which (indexed 0, 1, etc).
 func (a *AuxCall) OffsetOfResult(which int64) int64 {
-	return int64(a.results[which].Offset)
+	return int64(a.abiInfo.OutParam(int(which)).Offset())
 }
 
 // OffsetOfArg returns the SP offset of argument which (indexed 0, 1, etc).
 // If the call is to a method, the receiver is the first argument (i.e., index 0)
 func (a *AuxCall) OffsetOfArg(which int64) int64 {
-	return int64(a.args[which].Offset)
+	return int64(a.abiInfo.InParam(int(which)).Offset())
 }
 
 // RegsOfResult returns the register(s) used for result which (indexed 0, 1, etc).
@@ -206,6 +206,9 @@ func (a *AuxCall) String() string {
 	return fn + "}"
 }
 
+// ACParamsToTypes translates a slice of Param into a slice of *types.Type
+// This is a helper call for ssagen/ssa.go.
+// TODO remove this, as part of replacing fields of AuxCall with abi.ABIParamResultInfo.
 func ACParamsToTypes(ps []Param) (ts []*types.Type) {
 	for _, p := range ps {
 		ts = append(ts, p.Type)
@@ -215,7 +218,6 @@ func ACParamsToTypes(ps []Param) (ts []*types.Type) {
 
 // StaticAuxCall returns an AuxCall for a static call.
 func StaticAuxCall(sym *obj.LSym, args []Param, results []Param, paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
-	// TODO Create regInfo for AuxCall
 	if paramResultInfo == nil {
 		panic(fmt.Errorf("Nil paramResultInfo, sym=%v", sym))
 	}
@@ -223,15 +225,13 @@ func StaticAuxCall(sym *obj.LSym, args []Param, results []Param, paramResultInfo
 }
 
 // InterfaceAuxCall returns an AuxCall for an interface call.
-func InterfaceAuxCall(args []Param, results []Param) *AuxCall {
-	// TODO Create regInfo for AuxCall
-	return &AuxCall{Fn: nil, args: args, results: results}
+func InterfaceAuxCall(args []Param, results []Param, paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
+	return &AuxCall{Fn: nil, args: args, results: results, abiInfo: paramResultInfo}
 }
 
 // ClosureAuxCall returns an AuxCall for a closure call.
-func ClosureAuxCall(args []Param, results []Param) *AuxCall {
-	// TODO Create regInfo for AuxCall
-	return &AuxCall{Fn: nil, args: args, results: results}
+func ClosureAuxCall(args []Param, results []Param, paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
+	return &AuxCall{Fn: nil, args: args, results: results, abiInfo: paramResultInfo}
 }
 
 func (*AuxCall) CanBeAnSSAAux() {}
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 865630dd3e..81e8eccf32 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -7,6 +7,7 @@ package ssagen
 import (
 	"bufio"
 	"bytes"
+	"cmd/compile/internal/abi"
 	"encoding/binary"
 	"fmt"
 	"go/constant"
@@ -208,6 +209,32 @@ func InitConfig() {
 	ir.Syms.SigPanic = typecheck.LookupRuntimeFunc("sigpanic")
 }
 
+// AbiForFunc returns the ABI for a function, used to figure out arg/result mapping for rtcall and bodyless functions.
+// This follows policy for GOEXPERIMENT=regabi, //go:registerparams, and currently defined ABIInternal.
+// Policy is subject to change....
+// This always returns a freshly copied ABI.
+func AbiForFunc(fn *ir.Func) *abi.ABIConfig {
+	return abiForFunc(fn, ssaConfig.ABI0, ssaConfig.ABI1).Copy() // No idea what races will result, be safe
+}
+
+// abiForFunc implements ABI policy for a function, but does not return a copy of the ABI.
+// Passing a nil function returns ABIInternal.
+func abiForFunc(fn *ir.Func, abi0, abi1 *abi.ABIConfig) *abi.ABIConfig {
+	a := abi1
+	if true || objabi.Regabi_enabled == 0 {
+		a = abi0
+	}
+	if fn != nil && fn.Pragma&ir.RegisterParams != 0 { // TODO(register args) remove after register abi is working
+		name := ir.FuncName(fn)
+		if strings.Contains(name, ".") {
+			base.ErrorfAt(fn.Pos(), "Calls to //go:registerparams method %s won't work, remove the pragma from the declaration.", name)
+		}
+		a = abi1
+		base.WarnfAt(fn.Pos(), "declared function %v has register params", fn)
+	}
+	return a
+}
+
 // getParam returns the Field of ith param of node n (which is a
 // function/method/interface call), where the receiver of a method call is
 // considered as the 0th parameter. This does not include the receiver of an
@@ -357,25 +384,10 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 	if fn.Pragma&ir.Nosplit != 0 {
 		s.f.NoSplit = true
 	}
-	s.f.ABI0 = ssaConfig.ABI0.Copy() // Make a copy to avoid racy map operations in type-width cache.
+	s.f.ABI0 = ssaConfig.ABI0.Copy() // Make a copy to avoid racy map operations in type-register-width cache.
 	s.f.ABI1 = ssaConfig.ABI1.Copy()
-
-	s.f.ABIDefault = s.f.ABI1 // Default ABI for function calls with no parsed signature for a pragma, e.g. rtcall
-	// TODO(register args) -- remove "true ||"; in the short run, turning on the register ABI experiment still leaves the compiler defaulting to ABI0.
-	// TODO(register args) -- remove this conditional entirely when register ABI is not an experiment.
-	if true || objabi.Regabi_enabled == 0 {
-		s.f.ABIDefault = s.f.ABI0 // reset
-	}
-
-	s.f.ABISelf = s.f.ABIDefault
-
-	if fn.Pragma&ir.RegisterParams != 0 { // TODO(register args) remove after register abi is working
-		s.f.ABISelf = s.f.ABI1
-		if strings.Contains(name, ".") {
-			base.ErrorfAt(fn.Pos(), "Calls to //go:registerparams method %s won't work, remove the pragma from the declaration.", name)
-		}
-		s.f.Warnl(fn.Pos(), "declared function %v has register params", fn)
-	}
+	s.f.ABIDefault = abiForFunc(nil, s.f.ABI0, s.f.ABI1)
+	s.f.ABISelf = abiForFunc(fn, s.f.ABI0, s.f.ABI1)
 
 	s.panics = map[funcLine]*ssa.Block{}
 	s.softFloat = s.config.SoftFloat
@@ -4731,7 +4743,7 @@ func (s *state) openDeferExit() {
 			v := s.load(r.closure.Type.Elem(), r.closure)
 			s.maybeNilCheckClosure(v, callDefer)
 			codeptr := s.rawLoad(types.Types[types.TUINTPTR], v)
-			aux := ssa.ClosureAuxCall(ACArgs, ACResults)
+			aux := ssa.ClosureAuxCall(ACArgs, ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
 			call = s.newValue2A(ssa.OpClosureLECall, aux.LateExpansionResultType(), aux, codeptr, v)
 		} else {
 			aux := ssa.StaticAuxCall(fn.(*ir.Name).Linksym(), ACArgs, ACResults,
@@ -4972,10 +4984,11 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			// critical that we not clobber any arguments already
 			// stored onto the stack.
 			codeptr = s.rawLoad(types.Types[types.TUINTPTR], closure)
-			aux := ssa.ClosureAuxCall(ACArgs, ACResults)
+			aux := ssa.ClosureAuxCall(ACArgs, ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
 			call = s.newValue2A(ssa.OpClosureLECall, aux.LateExpansionResultType(), aux, codeptr, closure)
 		case codeptr != nil:
-			aux := ssa.InterfaceAuxCall(ACArgs, ACResults)
+			// Note that the "receiver" parameter is nil because the actual receiver is the first input parameter.
+			aux := ssa.InterfaceAuxCall(ACArgs, ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
 			call = s.newValue1A(ssa.OpInterLECall, aux.LateExpansionResultType(), aux, codeptr)
 		case callee != nil:
 			aux := ssa.StaticAuxCall(callTargetLSym(callee, s.curfn.LSym), ACArgs, ACResults, params)
diff --git a/src/cmd/compile/internal/test/abiutilsaux_test.go b/src/cmd/compile/internal/test/abiutilsaux_test.go
index bac0c7639d..7eb273273d 100644
--- a/src/cmd/compile/internal/test/abiutilsaux_test.go
+++ b/src/cmd/compile/internal/test/abiutilsaux_test.go
@@ -129,36 +129,4 @@ func abitest(t *testing.T, ft *types.Type, exp expectedDump) {
 			strings.TrimSpace(exp.dump), regResString, reason)
 	}
 
-	// Analyze again with empty register set.
-	empty := abi.NewABIConfig(0, 0)
-	emptyRes := empty.ABIAnalyze(ft)
-	emptyResString := emptyRes.String()
-
-	// Walk the results and make sure the offsets assigned match
-	// up with those assiged by CalcSize. This checks to make sure that
-	// when we have no available registers the ABI assignment degenerates
-	// back to the original ABI0.
-
-	// receiver
-	failed := 0
-	rfsl := ft.Recvs().Fields().Slice()
-	poff := 0
-	if len(rfsl) != 0 {
-		failed |= verifyParamResultOffset(t, rfsl[0], emptyRes.InParams()[0], "receiver", 0)
-		poff = 1
-	}
-	// params
-	pfsl := ft.Params().Fields().Slice()
-	for k, f := range pfsl {
-		verifyParamResultOffset(t, f, emptyRes.InParams()[k+poff], "param", k)
-	}
-	// results
-	ofsl := ft.Results().Fields().Slice()
-	for k, f := range ofsl {
-		failed |= verifyParamResultOffset(t, f, emptyRes.OutParams()[k], "result", k)
-	}
-
-	if failed != 0 {
-		t.Logf("emptyres:\n%s\n", emptyResString)
-	}
 }
-- 
GitLab


From 2a8df4488ee893353b1200794bde758e9726e7c7 Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Sun, 31 Jan 2021 19:51:45 +0100
Subject: [PATCH 0872/2400] os: mark pipes returned by os.Pipe() as inheritable
 by default

Now that we don't automatically pass all inheritable handles to new
processes, we can make pipes returned by os.Pipe() inheritable, just
like they are on Unix. This then allows them to be passed through the
SysProcAttr.AdditionalInheritedHandles parameter simply.

Updates #44011.
Fixes #21085.

Change-Id: I8eae329fbc74f9dc7962136fa9aae8fb66879751
Reviewed-on: https://go-review.googlesource.com/c/go/+/288299
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Trust: Alex Brainman <alex.brainman@gmail.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
---
 src/os/exec/exec_test.go         | 10 ++++++++
 src/os/exec/exec_windows_test.go | 43 ++++++++++++++++++++++++++++++++
 src/os/file_windows.go           |  5 ++--
 3 files changed, 56 insertions(+), 2 deletions(-)
 create mode 100644 src/os/exec/exec_windows_test.go

diff --git a/src/os/exec/exec_test.go b/src/os/exec/exec_test.go
index 8b0c93f382..57591a38ab 100644
--- a/src/os/exec/exec_test.go
+++ b/src/os/exec/exec_test.go
@@ -915,6 +915,16 @@ func TestHelperProcess(*testing.T) {
 	case "sleep":
 		time.Sleep(3 * time.Second)
 		os.Exit(0)
+	case "pipehandle":
+		handle, _ := strconv.ParseUint(args[0], 16, 64)
+		pipe := os.NewFile(uintptr(handle), "")
+		_, err := fmt.Fprint(pipe, args[1])
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "writing to pipe failed: %v\n", err)
+			os.Exit(1)
+		}
+		pipe.Close()
+		os.Exit(0)
 	default:
 		fmt.Fprintf(os.Stderr, "Unknown command %q\n", cmd)
 		os.Exit(2)
diff --git a/src/os/exec/exec_windows_test.go b/src/os/exec/exec_windows_test.go
new file mode 100644
index 0000000000..fbccffec0e
--- /dev/null
+++ b/src/os/exec/exec_windows_test.go
@@ -0,0 +1,43 @@
+// Copyright 2021 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.
+
+//go:build windows
+// +build windows
+
+package exec_test
+
+import (
+	"io"
+	"os"
+	"strconv"
+	"syscall"
+	"testing"
+)
+
+func TestPipePassing(t *testing.T) {
+	r, w, err := os.Pipe()
+	if err != nil {
+		t.Error(err)
+	}
+	const marker = "arrakis, dune, desert planet"
+	childProc := helperCommand(t, "pipehandle", strconv.FormatUint(uint64(w.Fd()), 16), marker)
+	childProc.SysProcAttr = &syscall.SysProcAttr{AdditionalInheritedHandles: []syscall.Handle{syscall.Handle(w.Fd())}}
+	err = childProc.Start()
+	if err != nil {
+		t.Error(err)
+	}
+	w.Close()
+	response, err := io.ReadAll(r)
+	if err != nil {
+		t.Error(err)
+	}
+	r.Close()
+	if string(response) != marker {
+		t.Errorf("got %q; want %q", string(response), marker)
+	}
+	err = childProc.Wait()
+	if err != nil {
+		t.Error(err)
+	}
+}
diff --git a/src/os/file_windows.go b/src/os/file_windows.go
index dfc5fc6ce6..0d3c048a75 100644
--- a/src/os/file_windows.go
+++ b/src/os/file_windows.go
@@ -279,10 +279,11 @@ func rename(oldname, newname string) error {
 }
 
 // Pipe returns a connected pair of Files; reads from r return bytes written to w.
-// It returns the files and an error, if any.
+// It returns the files and an error, if any. The Windows handles underlying
+// the returned files are marked as inheritable by child processes.
 func Pipe() (r *File, w *File, err error) {
 	var p [2]syscall.Handle
-	e := syscall.CreatePipe(&p[0], &p[1], nil, 0)
+	e := syscall.Pipe(p[:])
 	if e != nil {
 		return nil, nil, NewSyscallError("pipe", e)
 	}
-- 
GitLab


From 5fafc0bbd4819578e58e5b9163981b0074ab0b01 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Thu, 25 Feb 2021 18:38:43 -0500
Subject: [PATCH 0873/2400] cmd/go/internal/modload: don't query when fixing
 canonical versions

If a canonical version is passed to fixVersion when loading the main
go.mod and that version don't match the module path's major version
suffix, don't call Query.

Query doesn't return a useful error in this case when the path is
malformed, for example, when it doens't have a dot in the first path
element. It's better to report the major version mismatch error.

Fixes #44494

Change-Id: I97b1f64aee894fa0db6fb637aa03a51357ee782c
Reviewed-on: https://go-review.googlesource.com/c/go/+/296590
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go/internal/modload/init.go           |  5 ++--
 .../script/mod_retract_fix_version.txt        | 24 +++++++++++++++++++
 2 files changed, 27 insertions(+), 2 deletions(-)

diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index bc8d17e0a5..4de5ac9303 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -539,9 +539,10 @@ func fixVersion(ctx context.Context, fixed *bool) modfile.VersionFixer {
 			}
 		}
 		if vers != "" && module.CanonicalVersion(vers) == vers {
-			if err := module.CheckPathMajor(vers, pathMajor); err == nil {
-				return vers, nil
+			if err := module.CheckPathMajor(vers, pathMajor); err != nil {
+				return "", module.VersionError(module.Version{Path: path, Version: vers}, err)
 			}
+			return vers, nil
 		}
 
 		info, err := Query(ctx, path, vers, "", nil)
diff --git a/src/cmd/go/testdata/script/mod_retract_fix_version.txt b/src/cmd/go/testdata/script/mod_retract_fix_version.txt
index f8099ec93e..e45758b627 100644
--- a/src/cmd/go/testdata/script/mod_retract_fix_version.txt
+++ b/src/cmd/go/testdata/script/mod_retract_fix_version.txt
@@ -12,6 +12,18 @@ go mod tidy
 go list -m all
 cmp go.mod go.mod.want
 
+# If a retracted version doesn't match the module's major version suffx,
+# an error should be reported.
+! go mod edit -retract=v3.0.1
+stderr '^go mod: -retract=v3.0.1: version "v3.0.1" invalid: should be v2, not v3$'
+cp go.mod.mismatch-v2 go.mod
+! go list -m all
+stderr 'go.mod:3: retract rsc.io/quote/v2: version "v3.0.1" invalid: should be v2, not v3$'
+
+cp go.mod.mismatch-v1 go.mod
+! go list -m all
+stderr 'go.mod:3: retract rsc.io/quote: version "v3.0.1" invalid: should be v0 or v1, not v3$'
+
 -- go.mod --
 go 1.16
 
@@ -22,3 +34,15 @@ go 1.16
 retract v2.0.1
 
 module rsc.io/quote/v2
+-- go.mod.mismatch-v2 --
+go 1.16
+
+retract v3.0.1
+
+module rsc.io/quote/v2
+-- go.mod.mismatch-v1 --
+go 1.16
+
+retract v3.0.1
+
+module rsc.io/quote
-- 
GitLab


From a400eb3261ee3798e0715d2ba6a4083abe59150a Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Mon, 1 Mar 2021 14:43:24 +0000
Subject: [PATCH 0874/2400] Revert "cmd/compile: check frame offsets against
 abi"

This reverts CL 293392.

Reason for revert: broke most non-x86 builders

Fixes #44675

Change-Id: I1e815c3ab27a02e83a2f0d221a617909dd021403
Reviewed-on: https://go-review.googlesource.com/c/go/+/297549
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
---
 src/cmd/compile/internal/abi/abiutils.go      | 43 ++-------------
 src/cmd/compile/internal/gc/compile.go        |  3 -
 src/cmd/compile/internal/ssa/op.go            | 18 +++---
 src/cmd/compile/internal/ssagen/ssa.go        | 55 +++++++------------
 .../compile/internal/test/abiutilsaux_test.go | 32 +++++++++++
 5 files changed, 66 insertions(+), 85 deletions(-)

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index f5f3b25726..b43d95e976 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -52,12 +52,12 @@ func (a *ABIParamResultInfo) OutRegistersUsed() int {
 	return a.outRegistersUsed
 }
 
-func (a *ABIParamResultInfo) InParam(i int) *ABIParamAssignment {
-	return &a.inparams[i]
+func (a *ABIParamResultInfo) InParam(i int) ABIParamAssignment {
+	return a.inparams[i]
 }
 
-func (a *ABIParamResultInfo) OutParam(i int) *ABIParamAssignment {
-	return &a.outparams[i]
+func (a *ABIParamResultInfo) OutParam(i int) ABIParamAssignment {
+	return a.outparams[i]
 }
 
 func (a *ABIParamResultInfo) SpillAreaOffset() int64 {
@@ -111,18 +111,6 @@ func (a *ABIParamAssignment) SpillOffset() int32 {
 	return a.offset
 }
 
-// FrameOffset returns the location that a value would spill to, if any exists.
-// For register-allocated inputs, that is their spill offset reserved for morestack
-// (might as well use it, it is there); for stack-allocated inputs and outputs,
-// that is their location on the stack.  For register-allocated outputs, there is
-// no defined spill area, so return -1.
-func (a *ABIParamAssignment) FrameOffset(i *ABIParamResultInfo) int64 {
-	if len(a.Registers) == 0 || a.offset == -1 {
-		return int64(a.offset)
-	}
-	return int64(a.offset) + i.SpillAreaOffset()
-}
-
 // RegAmounts holds a specified number of integer/float registers.
 type RegAmounts struct {
 	intRegs   int
@@ -277,32 +265,9 @@ func (config *ABIConfig) ABIAnalyze(t *types.Type) *ABIParamResultInfo {
 	result.spillAreaSize = alignTo(s.spillOffset, types.RegSize)
 	result.outRegistersUsed = s.rUsed.intRegs + s.rUsed.floatRegs
 
-	// Fill in the frame offsets for receiver, inputs, results
-	k := 0
-	if t.NumRecvs() != 0 {
-		config.updateOffset(result, ft.Receiver.FieldSlice()[0], result.inparams[0], false)
-		k++
-	}
-	for i, f := range ft.Params.FieldSlice() {
-		config.updateOffset(result, f, result.inparams[k+i], false)
-	}
-	for i, f := range ft.Results.FieldSlice() {
-		config.updateOffset(result, f, result.outparams[i], true)
-	}
 	return result
 }
 
-func (config *ABIConfig) updateOffset(result *ABIParamResultInfo, f *types.Field, a ABIParamAssignment, isReturn bool) {
-	if !isReturn || len(a.Registers) == 0 {
-		// TODO in next CL, assign
-		if f.Offset != a.FrameOffset(result) {
-			if config.regAmounts.intRegs == 0 && config.regAmounts.floatRegs == 0 {
-				panic(fmt.Errorf("Expected node offset %d != abi offset %d", f.Offset, a.FrameOffset(result)))
-			}
-		}
-	}
-}
-
 //......................................................................
 //
 // Non-public portions.
diff --git a/src/cmd/compile/internal/gc/compile.go b/src/cmd/compile/internal/gc/compile.go
index 9a4c00a341..ba67c58c45 100644
--- a/src/cmd/compile/internal/gc/compile.go
+++ b/src/cmd/compile/internal/gc/compile.go
@@ -43,9 +43,6 @@ func enqueueFunc(fn *ir.Func) {
 	if len(fn.Body) == 0 {
 		// Initialize ABI wrappers if necessary.
 		ssagen.InitLSym(fn, false)
-		types.CalcSize(fn.Type()) // TODO register args; remove this once all is done by abiutils
-		a := ssagen.AbiForFunc(fn)
-		a.ABIAnalyze(fn.Type())   // will set parameter spill/home locations correctly
 		liveness.WriteFuncMap(fn)
 		return
 	}
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index e5778cb31a..ece274b083 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -104,13 +104,13 @@ func (a *AuxCall) ResultForOffsetAndType(offset int64, t *types.Type) int64 {
 
 // OffsetOfResult returns the SP offset of result which (indexed 0, 1, etc).
 func (a *AuxCall) OffsetOfResult(which int64) int64 {
-	return int64(a.abiInfo.OutParam(int(which)).Offset())
+	return int64(a.results[which].Offset)
 }
 
 // OffsetOfArg returns the SP offset of argument which (indexed 0, 1, etc).
 // If the call is to a method, the receiver is the first argument (i.e., index 0)
 func (a *AuxCall) OffsetOfArg(which int64) int64 {
-	return int64(a.abiInfo.InParam(int(which)).Offset())
+	return int64(a.args[which].Offset)
 }
 
 // RegsOfResult returns the register(s) used for result which (indexed 0, 1, etc).
@@ -206,9 +206,6 @@ func (a *AuxCall) String() string {
 	return fn + "}"
 }
 
-// ACParamsToTypes translates a slice of Param into a slice of *types.Type
-// This is a helper call for ssagen/ssa.go.
-// TODO remove this, as part of replacing fields of AuxCall with abi.ABIParamResultInfo.
 func ACParamsToTypes(ps []Param) (ts []*types.Type) {
 	for _, p := range ps {
 		ts = append(ts, p.Type)
@@ -218,6 +215,7 @@ func ACParamsToTypes(ps []Param) (ts []*types.Type) {
 
 // StaticAuxCall returns an AuxCall for a static call.
 func StaticAuxCall(sym *obj.LSym, args []Param, results []Param, paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
+	// TODO Create regInfo for AuxCall
 	if paramResultInfo == nil {
 		panic(fmt.Errorf("Nil paramResultInfo, sym=%v", sym))
 	}
@@ -225,13 +223,15 @@ func StaticAuxCall(sym *obj.LSym, args []Param, results []Param, paramResultInfo
 }
 
 // InterfaceAuxCall returns an AuxCall for an interface call.
-func InterfaceAuxCall(args []Param, results []Param, paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
-	return &AuxCall{Fn: nil, args: args, results: results, abiInfo: paramResultInfo}
+func InterfaceAuxCall(args []Param, results []Param) *AuxCall {
+	// TODO Create regInfo for AuxCall
+	return &AuxCall{Fn: nil, args: args, results: results}
 }
 
 // ClosureAuxCall returns an AuxCall for a closure call.
-func ClosureAuxCall(args []Param, results []Param, paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
-	return &AuxCall{Fn: nil, args: args, results: results, abiInfo: paramResultInfo}
+func ClosureAuxCall(args []Param, results []Param) *AuxCall {
+	// TODO Create regInfo for AuxCall
+	return &AuxCall{Fn: nil, args: args, results: results}
 }
 
 func (*AuxCall) CanBeAnSSAAux() {}
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 81e8eccf32..865630dd3e 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -7,7 +7,6 @@ package ssagen
 import (
 	"bufio"
 	"bytes"
-	"cmd/compile/internal/abi"
 	"encoding/binary"
 	"fmt"
 	"go/constant"
@@ -209,32 +208,6 @@ func InitConfig() {
 	ir.Syms.SigPanic = typecheck.LookupRuntimeFunc("sigpanic")
 }
 
-// AbiForFunc returns the ABI for a function, used to figure out arg/result mapping for rtcall and bodyless functions.
-// This follows policy for GOEXPERIMENT=regabi, //go:registerparams, and currently defined ABIInternal.
-// Policy is subject to change....
-// This always returns a freshly copied ABI.
-func AbiForFunc(fn *ir.Func) *abi.ABIConfig {
-	return abiForFunc(fn, ssaConfig.ABI0, ssaConfig.ABI1).Copy() // No idea what races will result, be safe
-}
-
-// abiForFunc implements ABI policy for a function, but does not return a copy of the ABI.
-// Passing a nil function returns ABIInternal.
-func abiForFunc(fn *ir.Func, abi0, abi1 *abi.ABIConfig) *abi.ABIConfig {
-	a := abi1
-	if true || objabi.Regabi_enabled == 0 {
-		a = abi0
-	}
-	if fn != nil && fn.Pragma&ir.RegisterParams != 0 { // TODO(register args) remove after register abi is working
-		name := ir.FuncName(fn)
-		if strings.Contains(name, ".") {
-			base.ErrorfAt(fn.Pos(), "Calls to //go:registerparams method %s won't work, remove the pragma from the declaration.", name)
-		}
-		a = abi1
-		base.WarnfAt(fn.Pos(), "declared function %v has register params", fn)
-	}
-	return a
-}
-
 // getParam returns the Field of ith param of node n (which is a
 // function/method/interface call), where the receiver of a method call is
 // considered as the 0th parameter. This does not include the receiver of an
@@ -384,10 +357,25 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 	if fn.Pragma&ir.Nosplit != 0 {
 		s.f.NoSplit = true
 	}
-	s.f.ABI0 = ssaConfig.ABI0.Copy() // Make a copy to avoid racy map operations in type-register-width cache.
+	s.f.ABI0 = ssaConfig.ABI0.Copy() // Make a copy to avoid racy map operations in type-width cache.
 	s.f.ABI1 = ssaConfig.ABI1.Copy()
-	s.f.ABIDefault = abiForFunc(nil, s.f.ABI0, s.f.ABI1)
-	s.f.ABISelf = abiForFunc(fn, s.f.ABI0, s.f.ABI1)
+
+	s.f.ABIDefault = s.f.ABI1 // Default ABI for function calls with no parsed signature for a pragma, e.g. rtcall
+	// TODO(register args) -- remove "true ||"; in the short run, turning on the register ABI experiment still leaves the compiler defaulting to ABI0.
+	// TODO(register args) -- remove this conditional entirely when register ABI is not an experiment.
+	if true || objabi.Regabi_enabled == 0 {
+		s.f.ABIDefault = s.f.ABI0 // reset
+	}
+
+	s.f.ABISelf = s.f.ABIDefault
+
+	if fn.Pragma&ir.RegisterParams != 0 { // TODO(register args) remove after register abi is working
+		s.f.ABISelf = s.f.ABI1
+		if strings.Contains(name, ".") {
+			base.ErrorfAt(fn.Pos(), "Calls to //go:registerparams method %s won't work, remove the pragma from the declaration.", name)
+		}
+		s.f.Warnl(fn.Pos(), "declared function %v has register params", fn)
+	}
 
 	s.panics = map[funcLine]*ssa.Block{}
 	s.softFloat = s.config.SoftFloat
@@ -4743,7 +4731,7 @@ func (s *state) openDeferExit() {
 			v := s.load(r.closure.Type.Elem(), r.closure)
 			s.maybeNilCheckClosure(v, callDefer)
 			codeptr := s.rawLoad(types.Types[types.TUINTPTR], v)
-			aux := ssa.ClosureAuxCall(ACArgs, ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
+			aux := ssa.ClosureAuxCall(ACArgs, ACResults)
 			call = s.newValue2A(ssa.OpClosureLECall, aux.LateExpansionResultType(), aux, codeptr, v)
 		} else {
 			aux := ssa.StaticAuxCall(fn.(*ir.Name).Linksym(), ACArgs, ACResults,
@@ -4984,11 +4972,10 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			// critical that we not clobber any arguments already
 			// stored onto the stack.
 			codeptr = s.rawLoad(types.Types[types.TUINTPTR], closure)
-			aux := ssa.ClosureAuxCall(ACArgs, ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
+			aux := ssa.ClosureAuxCall(ACArgs, ACResults)
 			call = s.newValue2A(ssa.OpClosureLECall, aux.LateExpansionResultType(), aux, codeptr, closure)
 		case codeptr != nil:
-			// Note that the "receiver" parameter is nil because the actual receiver is the first input parameter.
-			aux := ssa.InterfaceAuxCall(ACArgs, ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
+			aux := ssa.InterfaceAuxCall(ACArgs, ACResults)
 			call = s.newValue1A(ssa.OpInterLECall, aux.LateExpansionResultType(), aux, codeptr)
 		case callee != nil:
 			aux := ssa.StaticAuxCall(callTargetLSym(callee, s.curfn.LSym), ACArgs, ACResults, params)
diff --git a/src/cmd/compile/internal/test/abiutilsaux_test.go b/src/cmd/compile/internal/test/abiutilsaux_test.go
index 7eb273273d..bac0c7639d 100644
--- a/src/cmd/compile/internal/test/abiutilsaux_test.go
+++ b/src/cmd/compile/internal/test/abiutilsaux_test.go
@@ -129,4 +129,36 @@ func abitest(t *testing.T, ft *types.Type, exp expectedDump) {
 			strings.TrimSpace(exp.dump), regResString, reason)
 	}
 
+	// Analyze again with empty register set.
+	empty := abi.NewABIConfig(0, 0)
+	emptyRes := empty.ABIAnalyze(ft)
+	emptyResString := emptyRes.String()
+
+	// Walk the results and make sure the offsets assigned match
+	// up with those assiged by CalcSize. This checks to make sure that
+	// when we have no available registers the ABI assignment degenerates
+	// back to the original ABI0.
+
+	// receiver
+	failed := 0
+	rfsl := ft.Recvs().Fields().Slice()
+	poff := 0
+	if len(rfsl) != 0 {
+		failed |= verifyParamResultOffset(t, rfsl[0], emptyRes.InParams()[0], "receiver", 0)
+		poff = 1
+	}
+	// params
+	pfsl := ft.Params().Fields().Slice()
+	for k, f := range pfsl {
+		verifyParamResultOffset(t, f, emptyRes.InParams()[k+poff], "param", k)
+	}
+	// results
+	ofsl := ft.Results().Fields().Slice()
+	for k, f := range ofsl {
+		failed |= verifyParamResultOffset(t, f, emptyRes.OutParams()[k], "result", k)
+	}
+
+	if failed != 0 {
+		t.Logf("emptyres:\n%s\n", emptyResString)
+	}
 }
-- 
GitLab


From 87beecd6dfd3b12ed30785ec502f7380dc79ec29 Mon Sep 17 00:00:00 2001
From: Jordan Liggitt <liggitt@google.com>
Date: Sat, 27 Feb 2021 23:06:23 -0500
Subject: [PATCH 0875/2400] cmd/go: add missing newline to retraction warning
 message

Fixes #44674

Change-Id: Icbdb79084bf7bd2f52cc0a53abcc1ec6f0c4a1bf
Reviewed-on: https://go-review.googlesource.com/c/go/+/297350
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modget/get.go              | 2 +-
 src/cmd/go/testdata/script/mod_get_retract.txt | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/go/internal/modget/get.go b/src/cmd/go/internal/modget/get.go
index 6b328d8bc8..971c5a8d8a 100644
--- a/src/cmd/go/internal/modget/get.go
+++ b/src/cmd/go/internal/modget/get.go
@@ -1530,7 +1530,7 @@ func (r *resolver) checkPackagesAndRetractions(ctx context.Context, pkgPatterns
 		}
 	}
 	if retractPath != "" {
-		fmt.Fprintf(os.Stderr, "go: to switch to the latest unretracted version, run:\n\tgo get %s@latest", retractPath)
+		fmt.Fprintf(os.Stderr, "go: to switch to the latest unretracted version, run:\n\tgo get %s@latest\n", retractPath)
 	}
 }
 
diff --git a/src/cmd/go/testdata/script/mod_get_retract.txt b/src/cmd/go/testdata/script/mod_get_retract.txt
index fe0ac88629..560fa7bfb2 100644
--- a/src/cmd/go/testdata/script/mod_get_retract.txt
+++ b/src/cmd/go/testdata/script/mod_get_retract.txt
@@ -11,7 +11,7 @@ cp go.mod.orig go.mod
 go mod edit -require example.com/retract/self/prev@v1.9.0
 go get -d example.com/retract/self/prev
 stderr '^go: warning: example.com/retract/self/prev@v1.9.0: retracted by module author: self$'
-stderr '^go: to switch to the latest unretracted version, run:\n\tgo get example.com/retract/self/prev@latest$'
+stderr '^go: to switch to the latest unretracted version, run:\n\tgo get example.com/retract/self/prev@latest\n$'
 go list -m example.com/retract/self/prev
 stdout '^example.com/retract/self/prev v1.9.0$'
 
-- 
GitLab


From f6a74c656837fcb0ea04e7b605ccdce7d10c45db Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Fri, 26 Feb 2021 09:25:22 -0500
Subject: [PATCH 0876/2400] cmd/compile/internal/ir: fix up stale comment

Fix a small stale comment in FinishCaptureNames (refers to old code
structure before the big refactoring).

Change-Id: I2dfb84ce238f919f6e17061439a8bd9b09459dae
Reviewed-on: https://go-review.googlesource.com/c/go/+/296829
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/name.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 6240852aaf..035c9cd3d0 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -398,7 +398,7 @@ func FinishCaptureNames(pos src.XPos, outerfn, fn *Func) {
 	// unhook them.
 	// make the list of pointers for the closure call.
 	for _, cv := range fn.ClosureVars {
-		// Unlink from n; see comment in syntax.go type Param for these fields.
+		// Unlink from n; see comment above on type Name for these fields.
 		n := cv.Defn.(*Name)
 		n.Innermost = cv.Outer
 
-- 
GitLab


From 97bdac03aee805cfa54e7762037a568d85339970 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Mon, 1 Mar 2021 10:00:09 -0500
Subject: [PATCH 0877/2400] cmd: upgrade golang.org/x/mod to relax import path
 check

This incorporates CL 297089, which allows leading dots in import path
elements but not module path elements. Also added a test.

Fixes #43985
Updates #34992

Change-Id: I2d5faabd8f7b23a7943d3f3ccb6707ab5dc2ce3c
Reviewed-on: https://go-review.googlesource.com/c/go/+/297530
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go.mod                                |  2 +-
 src/cmd/go.sum                                |  4 +-
 src/cmd/go/internal/get/get.go                | 30 +++++++++++++-
 .../go/testdata/script/mod_invalid_path.txt   | 24 +++++++++++
 .../vendor/golang.org/x/mod/module/module.go  | 40 ++++++++++++-------
 src/cmd/vendor/modules.txt                    |  2 +-
 6 files changed, 82 insertions(+), 20 deletions(-)

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index 8ca3b982ee..ef05ca1ad1 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -6,7 +6,7 @@ require (
 	github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2
 	golang.org/x/arch v0.0.0-20201008161808-52c3e6f60cff
 	golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897
-	golang.org/x/mod v0.4.2-0.20210225160341-66bf157bf5bc
+	golang.org/x/mod v0.4.2-0.20210301144719-c8bb1bd8a2aa
 	golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e // indirect
 	golang.org/x/tools v0.1.1-0.20210220032852-2363391a5b2f
 )
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 7de27879f6..77063f76af 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -14,8 +14,8 @@ golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPh
 golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897 h1:pLI5jrR7OSLijeIDcmRxNmw2api+jEfxLoykJVice/E=
 golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.4.2-0.20210225160341-66bf157bf5bc h1:xQukuh0OD2SNSUK1CCBFATgHYx5ye75S/bAWEU/PT0E=
-golang.org/x/mod v0.4.2-0.20210225160341-66bf157bf5bc/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.2-0.20210301144719-c8bb1bd8a2aa h1:Ci2bbuyE4ah9djFByg+fdNQcqc8DVSdcXbrWy6MBoEs=
+golang.org/x/mod v0.4.2-0.20210301144719-c8bb1bd8a2aa/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
diff --git a/src/cmd/go/internal/get/get.go b/src/cmd/go/internal/get/get.go
index 38ff3823f2..329a2f5eda 100644
--- a/src/cmd/go/internal/get/get.go
+++ b/src/cmd/go/internal/get/get.go
@@ -431,7 +431,7 @@ func downloadPackage(p *load.Package) error {
 		}
 		importPrefix = importPrefix[:slash]
 	}
-	if err := module.CheckImportPath(importPrefix); err != nil {
+	if err := checkImportPath(importPrefix); err != nil {
 		return fmt.Errorf("%s: invalid import path: %v", p.ImportPath, err)
 	}
 	security := web.SecureOnly
@@ -591,3 +591,31 @@ func selectTag(goVersion string, tags []string) (match string) {
 	}
 	return ""
 }
+
+// checkImportPath is like module.CheckImportPath, but it forbids leading dots
+// in path elements. This can lead to 'go get' creating .git and other VCS
+// directories in places we might run VCS tools later.
+func checkImportPath(path string) error {
+	if err := module.CheckImportPath(path); err != nil {
+		return err
+	}
+	checkElem := func(elem string) error {
+		if elem[0] == '.' {
+			return fmt.Errorf("malformed import path %q: leading dot in path element", path)
+		}
+		return nil
+	}
+	elemStart := 0
+	for i, r := range path {
+		if r == '/' {
+			if err := checkElem(path[elemStart:]); err != nil {
+				return err
+			}
+			elemStart = i + 1
+		}
+	}
+	if err := checkElem(path[elemStart:]); err != nil {
+		return err
+	}
+	return nil
+}
diff --git a/src/cmd/go/testdata/script/mod_invalid_path.txt b/src/cmd/go/testdata/script/mod_invalid_path.txt
index 667828839f..c8c075daae 100644
--- a/src/cmd/go/testdata/script/mod_invalid_path.txt
+++ b/src/cmd/go/testdata/script/mod_invalid_path.txt
@@ -23,6 +23,20 @@ cd $WORK/gopath/src/badname
 ! go list .
 stderr 'invalid module path'
 
+# Test that an import path containing an element with a leading dot is valid,
+# but such a module path is not.
+# Verifies #43985.
+cd $WORK/gopath/src/dotname
+go list ./.dot
+stdout '^example.com/dotname/.dot$'
+go list ./use
+stdout '^example.com/dotname/use$'
+! go list -m example.com/dotname/.dot@latest
+stderr '^go list -m: example.com/dotname/.dot@latest: malformed module path "example.com/dotname/.dot": leading dot in path element$'
+go get -d example.com/dotname/.dot
+go get -d example.com/dotname/use
+go mod tidy
+
 -- mod/go.mod --
 
 -- mod/foo.go --
@@ -38,3 +52,13 @@ module .\.
 -- badname/foo.go --
 package badname
 
+-- dotname/go.mod --
+module example.com/dotname
+
+go 1.16
+-- dotname/.dot/dot.go --
+package dot
+-- dotname/use/use.go --
+package use
+
+import _ "example.com/dotname/.dot"
diff --git a/src/cmd/vendor/golang.org/x/mod/module/module.go b/src/cmd/vendor/golang.org/x/mod/module/module.go
index c1c5263c42..272baeef17 100644
--- a/src/cmd/vendor/golang.org/x/mod/module/module.go
+++ b/src/cmd/vendor/golang.org/x/mod/module/module.go
@@ -270,7 +270,7 @@ func fileNameOK(r rune) bool {
 
 // CheckPath checks that a module path is valid.
 // A valid module path is a valid import path, as checked by CheckImportPath,
-// with two additional constraints.
+// with three additional constraints.
 // First, the leading path element (up to the first slash, if any),
 // by convention a domain name, must contain only lower-case ASCII letters,
 // ASCII digits, dots (U+002E), and dashes (U+002D);
@@ -280,8 +280,9 @@ func fileNameOK(r rune) bool {
 // and must not contain any dots. For paths beginning with "gopkg.in/",
 // this second requirement is replaced by a requirement that the path
 // follow the gopkg.in server's conventions.
+// Third, no path element may begin with a dot.
 func CheckPath(path string) error {
-	if err := checkPath(path, false); err != nil {
+	if err := checkPath(path, modulePath); err != nil {
 		return fmt.Errorf("malformed module path %q: %v", path, err)
 	}
 	i := strings.Index(path, "/")
@@ -315,7 +316,7 @@ func CheckPath(path string) error {
 //
 // A valid path element is a non-empty string made up of
 // ASCII letters, ASCII digits, and limited ASCII punctuation: - . _ and ~.
-// It must not begin or end with a dot (U+002E), nor contain two dots in a row.
+// It must not end with a dot (U+002E), nor contain two dots in a row.
 //
 // The element prefix up to the first dot must not be a reserved file name
 // on Windows, regardless of case (CON, com1, NuL, and so on). The element
@@ -326,19 +327,29 @@ func CheckPath(path string) error {
 // top-level package documentation for additional information about
 // subtleties of Unicode.
 func CheckImportPath(path string) error {
-	if err := checkPath(path, false); err != nil {
+	if err := checkPath(path, importPath); err != nil {
 		return fmt.Errorf("malformed import path %q: %v", path, err)
 	}
 	return nil
 }
 
+// pathKind indicates what kind of path we're checking. Module paths,
+// import paths, and file paths have different restrictions.
+type pathKind int
+
+const (
+	modulePath pathKind = iota
+	importPath
+	filePath
+)
+
 // checkPath checks that a general path is valid.
 // It returns an error describing why but not mentioning path.
 // Because these checks apply to both module paths and import paths,
 // the caller is expected to add the "malformed ___ path %q: " prefix.
 // fileName indicates whether the final element of the path is a file name
 // (as opposed to a directory name).
-func checkPath(path string, fileName bool) error {
+func checkPath(path string, kind pathKind) error {
 	if !utf8.ValidString(path) {
 		return fmt.Errorf("invalid UTF-8")
 	}
@@ -357,35 +368,34 @@ func checkPath(path string, fileName bool) error {
 	elemStart := 0
 	for i, r := range path {
 		if r == '/' {
-			if err := checkElem(path[elemStart:i], fileName); err != nil {
+			if err := checkElem(path[elemStart:i], kind); err != nil {
 				return err
 			}
 			elemStart = i + 1
 		}
 	}
-	if err := checkElem(path[elemStart:], fileName); err != nil {
+	if err := checkElem(path[elemStart:], kind); err != nil {
 		return err
 	}
 	return nil
 }
 
 // checkElem checks whether an individual path element is valid.
-// fileName indicates whether the element is a file name (not a directory name).
-func checkElem(elem string, fileName bool) error {
+func checkElem(elem string, kind pathKind) error {
 	if elem == "" {
 		return fmt.Errorf("empty path element")
 	}
 	if strings.Count(elem, ".") == len(elem) {
 		return fmt.Errorf("invalid path element %q", elem)
 	}
-	if elem[0] == '.' && !fileName {
+	if elem[0] == '.' && kind == modulePath {
 		return fmt.Errorf("leading dot in path element")
 	}
 	if elem[len(elem)-1] == '.' {
 		return fmt.Errorf("trailing dot in path element")
 	}
 	charOK := pathOK
-	if fileName {
+	if kind == filePath {
 		charOK = fileNameOK
 	}
 	for _, r := range elem {
@@ -406,7 +416,7 @@ func checkElem(elem string, fileName bool) error {
 		}
 	}
 
-	if fileName {
+	if kind == filePath {
 		// don't check for Windows short-names in file names. They're
 		// only an issue for import paths.
 		return nil
@@ -444,7 +454,7 @@ func checkElem(elem string, fileName bool) error {
 // top-level package documentation for additional information about
 // subtleties of Unicode.
 func CheckFilePath(path string) error {
-	if err := checkPath(path, true); err != nil {
+	if err := checkPath(path, filePath); err != nil {
 		return fmt.Errorf("malformed file path %q: %v", path, err)
 	}
 	return nil
@@ -647,7 +657,7 @@ func EscapePath(path string) (escaped string, err error) {
 // Versions are allowed to be in non-semver form but must be valid file names
 // and not contain exclamation marks.
 func EscapeVersion(v string) (escaped string, err error) {
-	if err := checkElem(v, true); err != nil || strings.Contains(v, "!") {
+	if err := checkElem(v, filePath); err != nil || strings.Contains(v, "!") {
 		return "", &InvalidVersionError{
 			Version: v,
 			Err:     fmt.Errorf("disallowed version string"),
@@ -706,7 +716,7 @@ func UnescapeVersion(escaped string) (v string, err error) {
 	if !ok {
 		return "", fmt.Errorf("invalid escaped version %q", escaped)
 	}
-	if err := checkElem(v, true); err != nil {
+	if err := checkElem(v, filePath); err != nil {
 		return "", fmt.Errorf("invalid escaped version %q: %v", v, err)
 	}
 	return v, nil
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 03853007e0..e4dfd32315 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -28,7 +28,7 @@ golang.org/x/arch/x86/x86asm
 golang.org/x/crypto/ed25519
 golang.org/x/crypto/ed25519/internal/edwards25519
 golang.org/x/crypto/ssh/terminal
-# golang.org/x/mod v0.4.2-0.20210225160341-66bf157bf5bc
+# golang.org/x/mod v0.4.2-0.20210301144719-c8bb1bd8a2aa
 ## explicit
 golang.org/x/mod/internal/lazyregexp
 golang.org/x/mod/modfile
-- 
GitLab


From b98ce3b606b2bb620c9c62482cd73f068157a32c Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Mon, 1 Mar 2021 09:05:58 -0800
Subject: [PATCH 0878/2400] cmd/compile:  import empty closure function
 correctly

On import, make sure that an empty closure is represented as a single
empty block statement. Otherwise, the closure is dropped. Block
statements are not exported explicitly, so must recreate on import.

Fixes #44330

Change-Id: I061598f0f859dd71d2d0cbd10c77cdd81525d1f2
Reviewed-on: https://go-review.googlesource.com/c/go/+/297569
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Trust: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/typecheck/iimport.go |  5 ++++
 test/fixedbugs/issue44330.dir/a.go            | 21 +++++++++++++++++
 test/fixedbugs/issue44330.dir/b.go            | 23 +++++++++++++++++++
 test/fixedbugs/issue44330.go                  |  7 ++++++
 4 files changed, 56 insertions(+)
 create mode 100644 test/fixedbugs/issue44330.dir/a.go
 create mode 100644 test/fixedbugs/issue44330.dir/b.go
 create mode 100644 test/fixedbugs/issue44330.go

diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 17aa35549d..9355174da8 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -992,6 +992,11 @@ func (r *importReader) node() ir.Node {
 		r.funcBody(fn)
 		fn.Dcl = fn.Inl.Dcl
 		fn.Body = fn.Inl.Body
+		if len(fn.Body) == 0 {
+			// An empty closure must be represented as a single empty
+			// block statement, else it will be dropped.
+			fn.Body = []ir.Node{ir.NewBlockStmt(src.NoXPos, nil)}
+		}
 		fn.Inl = nil
 
 		ir.FinishCaptureNames(pos, r.curfn, fn)
diff --git a/test/fixedbugs/issue44330.dir/a.go b/test/fixedbugs/issue44330.dir/a.go
new file mode 100644
index 0000000000..9d3ab9fe80
--- /dev/null
+++ b/test/fixedbugs/issue44330.dir/a.go
@@ -0,0 +1,21 @@
+// Copyright 2021 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 a
+
+type Table struct {
+	ColumnSeparator bool
+	RowSeparator    bool
+
+	// ColumnResizer is called on each Draw. Can be used for custom column sizing.
+	ColumnResizer func()
+}
+
+func NewTable() *Table {
+	return &Table{
+		ColumnSeparator: true,
+		RowSeparator:    true,
+		ColumnResizer:   func() {},
+	}
+}
diff --git a/test/fixedbugs/issue44330.dir/b.go b/test/fixedbugs/issue44330.dir/b.go
new file mode 100644
index 0000000000..1d5742421b
--- /dev/null
+++ b/test/fixedbugs/issue44330.dir/b.go
@@ -0,0 +1,23 @@
+// Copyright 2021 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 (
+	"./a"
+)
+
+type Term struct {
+	top *a.Table
+}
+
+//go:noinline
+func NewFred() *Term {
+	table := a.NewTable()
+	return &Term{top: table}
+}
+
+func main() {
+	NewFred()
+}
diff --git a/test/fixedbugs/issue44330.go b/test/fixedbugs/issue44330.go
new file mode 100644
index 0000000000..682d9c5bf3
--- /dev/null
+++ b/test/fixedbugs/issue44330.go
@@ -0,0 +1,7 @@
+// rundir
+
+// Copyright 2021 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 ignored
-- 
GitLab


From a69c45213d7fa18a09e59274e0e18db7766bf5c8 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 23 Feb 2021 16:29:33 -0500
Subject: [PATCH 0879/2400] go/types: review of expr.go

The changes from the (reviewed) dev.regabi copy of expr.go can be seen
by comparing patchset 2 and 7. The actual change is some small
improvements to readability and consistency in untyped conversion,
adding some missing documentation, and removing the "// REVIEW
INCOMPLETE" marker.

Note that expr.go diverges from types2 in its handling of untyped
conversion.

Change-Id: I13a85f6e08f43343e249818245aa857b1f4bf29c
Reviewed-on: https://go-review.googlesource.com/c/go/+/295729
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/expr.go | 30 ++++++++++++++++++------------
 1 file changed, 18 insertions(+), 12 deletions(-)

diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 77807e3b5b..9b51ce94b7 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -1,4 +1,3 @@
-// REVIEW INCOMPLETE
 // Copyright 2012 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.
@@ -100,8 +99,8 @@ func (check *Checker) overflow(x *operand, op token.Token, opPos token.Pos) {
 
 	// Typed constants must be representable in
 	// their type after each constant operation.
-	if typ := asBasic(x.typ); typ != nil && isTyped(typ) {
-		check.representable(x, typ)
+	if isTyped(x.typ) {
+		check.representable(x, asBasic(x.typ))
 		return
 	}
 
@@ -191,10 +190,9 @@ func (check *Checker) unary(x *operand, e *ast.UnaryExpr) {
 			// nothing to do (and don't cause an error below in the overflow check)
 			return
 		}
-		typ := asBasic(x.typ)
 		var prec uint
-		if isUnsigned(typ) {
-			prec = uint(check.conf.sizeof(typ) * 8)
+		if isUnsigned(x.typ) {
+			prec = uint(check.conf.sizeof(x.typ) * 8)
 		}
 		x.val = constant.UnaryOp(e.Op, x.val, prec)
 		x.expr = e
@@ -400,14 +398,20 @@ func representableConst(x constant.Value, check *Checker, typ *Basic, rounded *c
 // representable checks that a constant operand is representable in the given
 // basic type.
 func (check *Checker) representable(x *operand, typ *Basic) {
-	if v, code := check.representation(x, typ); code != 0 {
+	v, code := check.representation(x, typ)
+	if code != 0 {
 		check.invalidConversion(code, x, typ)
 		x.mode = invalid
-	} else if v != nil {
-		x.val = v
+		return
 	}
+	assert(v != nil)
+	x.val = v
 }
 
+// representation returns the representation of the constant operand x as the
+// basic type typ.
+//
+// If no such representation is possible, it returns a non-zero error code.
 func (check *Checker) representation(x *operand, typ *Basic) (constant.Value, errorCode) {
 	assert(x.mode == constant_)
 	v := x.val
@@ -593,7 +597,10 @@ func (check *Checker) convertUntyped(x *operand, target Type) {
 
 // implicitTypeAndValue returns the implicit type of x when used in a context
 // where the target type is expected. If no such implicit conversion is
-// possible, it returns a nil Type.
+// possible, it returns a nil Type and non-zero error code.
+//
+// If x is a constant operand, the returned constant.Value will be the
+// representation of x in this context.
 func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, constant.Value, errorCode) {
 	target = expand(target)
 	if x.mode == invalid || isTyped(x.typ) || target == Typ[Invalid] {
@@ -994,9 +1001,8 @@ func (check *Checker) binary(x *operand, e ast.Expr, lhs, rhs ast.Expr, op token
 			// x.typ is unchanged
 			return
 		}
-		typ := asBasic(x.typ)
 		// force integer division of integer operands
-		if op == token.QUO && isInteger(typ) {
+		if op == token.QUO && isInteger(x.typ) {
 			op = token.QUO_ASSIGN
 		}
 		x.val = constant.BinaryOp(x.val, op, y.val)
-- 
GitLab


From 700b73975e9a925584773e6df85b175371cf9d95 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Mon, 25 Jan 2021 17:13:51 -0500
Subject: [PATCH 0880/2400] runtime: use entersyscall in syscall_syscallX on
 Darwin

CL 197938 changed syscall* functions to call entersyscall, instead
of entersyscallblock. It missed syscall_syscallX, probably because
it was in sys_darwin_64.go, not sys_darwin.go like others. Change
that one as well.

Found during the review of CL 270380 (thanks Joel).

Change-Id: I0884fc766703f555a3895be332dccfa7d2431374
Reviewed-on: https://go-review.googlesource.com/c/go/+/286435
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/runtime/sys_darwin.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/sys_darwin.go b/src/runtime/sys_darwin.go
index dacce2ee1a..4ae259ac63 100644
--- a/src/runtime/sys_darwin.go
+++ b/src/runtime/sys_darwin.go
@@ -27,7 +27,7 @@ func syscall()
 //go:nosplit
 //go:cgo_unsafe_args
 func syscall_syscallX(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
-	entersyscallblock()
+	entersyscall()
 	libcCall(unsafe.Pointer(funcPC(syscallX)), unsafe.Pointer(&fn))
 	exitsyscall()
 	return
-- 
GitLab


From ff5cf4ced3f1681ec972cd954d4b476f87616fe3 Mon Sep 17 00:00:00 2001
From: YunQiang Su <syq@debian.org>
Date: Sat, 20 Jun 2020 14:04:54 +0000
Subject: [PATCH 0881/2400] cmd/link,debug/elf: mips32, add .gnu.attributes and
 .MIPS.abiflags sections

MIPS32 uses .gnu.attributes and .MIPS.abiflags sections to mark FP ABI
the object is using, and the kernel will set the correct FP mode for it.

Currrently Go doesn't generate these 2 sections. If we link object
without these 2 sections togather FPXX objects, the result will be FPXX,
which is wrong:
   FP32 + FPXX -> FP32
   FPXX + FP64 -> FP64
   FP32 + FP64 -> reject

These 2 sections is also needed to support FPXX and FP64 in future.

More details about FP32/FPXX/FP64 are explained in:
    https://web.archive.org/web/20180828210612/https://dmz-portal.mips.com/wiki/MIPS_O32_ABI_-_FR0_and_FR1_Interlinking

Fixes #39677

Change-Id: Ia34e7461dee38a4f575dd8ace609988744512ac1
Reviewed-on: https://go-review.googlesource.com/c/go/+/239217
Run-TryBot: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Meng Zhuo <mzh@golangcn.org>
---
 src/cmd/link/internal/ld/elf.go | 145 ++++++++++++++++++++++++++++++++
 src/debug/elf/elf.go            |   2 +
 2 files changed, 147 insertions(+)

diff --git a/src/cmd/link/internal/ld/elf.go b/src/cmd/link/internal/ld/elf.go
index 37b2dc640d..d3e598b312 100644
--- a/src/cmd/link/internal/ld/elf.go
+++ b/src/cmd/link/internal/ld/elf.go
@@ -519,6 +519,90 @@ func elfwriteinterp(out *OutBuf) int {
 	return int(sh.Size)
 }
 
+// member of .gnu.attributes of MIPS for fpAbi
+const (
+	// No floating point is present in the module (default)
+	MIPS_FPABI_NONE    = 0
+	// FP code in the module uses the FP32 ABI for a 32-bit ABI
+	MIPS_FPABI_ANY     = 1
+	// FP code in the module only uses single precision ABI
+	MIPS_FPABI_SINGLE  = 2
+	// FP code in the module uses soft-float ABI
+	MIPS_FPABI_SOFT    = 3
+	// FP code in the module assumes an FPU with FR=1 and has 12
+	// callee-saved doubles. Historic, no longer supported.
+	MIPS_FPABI_HIST    = 4
+	// FP code in the module uses the FPXX  ABI
+	MIPS_FPABI_FPXX    = 5
+	// FP code in the module uses the FP64  ABI
+	MIPS_FPABI_FP64    = 6
+	// FP code in the module uses the FP64A ABI
+	MIPS_FPABI_FP64A   = 7
+)
+
+func elfMipsAbiFlags(sh *ElfShdr, startva uint64, resoff uint64) int {
+	n := 24
+	sh.Addr = startva + resoff - uint64(n)
+	sh.Off = resoff - uint64(n)
+	sh.Size = uint64(n)
+	sh.Type = uint32(elf.SHT_MIPS_ABIFLAGS)
+	sh.Flags = uint64(elf.SHF_ALLOC)
+
+	return n
+}
+
+//typedef struct
+//{
+//  /* Version of flags structure.  */
+//  uint16_t version;
+//  /* The level of the ISA: 1-5, 32, 64.  */
+//  uint8_t isa_level;
+//  /* The revision of ISA: 0 for MIPS V and below, 1-n otherwise.  */
+//  uint8_t isa_rev;
+//  /* The size of general purpose registers.  */
+//  uint8_t gpr_size;
+//  /* The size of co-processor 1 registers.  */
+//  uint8_t cpr1_size;
+//  /* The size of co-processor 2 registers.  */
+//  uint8_t cpr2_size;
+//  /* The floating-point ABI.  */
+//  uint8_t fp_abi;
+//  /* Processor-specific extension.  */
+//  uint32_t isa_ext;
+//  /* Mask of ASEs used.  */
+//  uint32_t ases;
+//  /* Mask of general flags.  */
+//  uint32_t flags1;
+//  uint32_t flags2;
+//} Elf_Internal_ABIFlags_v0;
+func elfWriteMipsAbiFlags(ctxt *Link) int {
+	sh := elfshname(".MIPS.abiflags")
+	ctxt.Out.SeekSet(int64(sh.Off))
+	ctxt.Out.Write16(0) // version
+	ctxt.Out.Write8(32) // isaLevel
+	ctxt.Out.Write8(1)  // isaRev
+	ctxt.Out.Write8(1)  // gprSize
+	ctxt.Out.Write8(1)  // cpr1Size
+	ctxt.Out.Write8(0)  // cpr2Size
+	if objabi.GOMIPS == "softfloat" {
+		ctxt.Out.Write8(MIPS_FPABI_SOFT)  // fpAbi
+	} else {
+		// Go cannot make sure non odd-number-fpr is used (ie, in load a double from memory).
+		// So, we mark the object is MIPS I style paired float/double register scheme,
+		// aka MIPS_FPABI_ANY. If we mark the object as FPXX, the kernel may use FR=1 mode,
+		// then we meet some problem.
+		// Note: MIPS_FPABI_ANY is bad naming: in fact it is MIPS I style FPR usage.
+		//       It is not for 'ANY'.
+		// TODO: switch to FPXX after be sure that no odd-number-fpr is used.
+		ctxt.Out.Write8(MIPS_FPABI_ANY)   // fpAbi
+	}
+	ctxt.Out.Write32(0)  // isaExt
+	ctxt.Out.Write32(0)  // ases
+	ctxt.Out.Write32(0)  // flags1
+	ctxt.Out.Write32(0)  // flags2
+	return int(sh.Size)
+}
+
 func elfnote(sh *ElfShdr, startva uint64, resoff uint64, sz int) int {
 	n := 3*4 + uint64(sz) + resoff%4
 
@@ -1204,6 +1288,10 @@ func (ctxt *Link) doelf() {
 	shstrtab.Addstring(".noptrbss")
 	shstrtab.Addstring("__libfuzzer_extra_counters")
 	shstrtab.Addstring(".go.buildinfo")
+	if ctxt.IsMIPS() {
+		shstrtab.Addstring(".MIPS.abiflags")
+		shstrtab.Addstring(".gnu.attributes")
+	}
 
 	// generate .tbss section for dynamic internal linker or external
 	// linking, so that various binutils could correctly calculate
@@ -1254,6 +1342,10 @@ func (ctxt *Link) doelf() {
 			shstrtab.Addstring(elfRelType + ".data.rel.ro")
 		}
 		shstrtab.Addstring(elfRelType + ".go.buildinfo")
+		if ctxt.IsMIPS() {
+			shstrtab.Addstring(elfRelType + ".MIPS.abiflags")
+			shstrtab.Addstring(elfRelType + ".gnu.attributes")
+		}
 
 		// add a .note.GNU-stack section to mark the stack as non-executable
 		shstrtab.Addstring(".note.GNU-stack")
@@ -1445,6 +1537,36 @@ func (ctxt *Link) doelf() {
 	if ctxt.LinkMode == LinkExternal && *flagBuildid != "" {
 		addgonote(ctxt, ".note.go.buildid", ELF_NOTE_GOBUILDID_TAG, []byte(*flagBuildid))
 	}
+
+
+	//type mipsGnuAttributes struct {
+	//	version uint8   // 'A'
+	//	length  uint32  // 15 including itself
+	//	gnu     [4]byte // "gnu\0"
+	//	tag     uint8   // 1:file, 2: section, 3: symbol, 1 here
+	//	taglen  uint32  // tag length, including tag, 7 here
+	//	tagfp   uint8   // 4
+	//	fpAbi  uint8    // see .MIPS.abiflags
+	//}
+	if ctxt.IsMIPS() {
+		gnuattributes := ldr.CreateSymForUpdate(".gnu.attributes", 0)
+		gnuattributes.SetType(sym.SELFROSECT)
+		gnuattributes.SetReachable(true)
+		gnuattributes.AddUint8('A')  // version 'A'
+		gnuattributes.AddUint32(ctxt.Arch, 15) // length 15 including itself
+		gnuattributes.AddBytes([]byte("gnu\x00")) // "gnu\0"
+		gnuattributes.AddUint8(1) // 1:file, 2: section, 3: symbol, 1 here
+		gnuattributes.AddUint32(ctxt.Arch, 7) // tag length, including tag, 7 here
+		gnuattributes.AddUint8(4) // 4 for FP, 8 for MSA
+		if objabi.GOMIPS == "softfloat" {
+			gnuattributes.AddUint8(MIPS_FPABI_SOFT)
+		} else {
+			// Note: MIPS_FPABI_ANY is bad naming: in fact it is MIPS I style FPR usage.
+			//       It is not for 'ANY'.
+			// TODO: switch to FPXX after be sure that no odd-number-fpr is used.
+			gnuattributes.AddUint8(MIPS_FPABI_ANY)
+		}
+	}
 }
 
 // Do not write DT_NULL.  elfdynhash will finish it.
@@ -1910,6 +2032,25 @@ elfobj:
 	shsym(sh, ldr, ldr.Lookup(".shstrtab", 0))
 	eh.Shstrndx = uint16(sh.shnum)
 
+	if ctxt.IsMIPS() {
+		sh = elfshname(".MIPS.abiflags")
+		sh.Type = uint32(elf.SHT_MIPS_ABIFLAGS)
+		sh.Flags = uint64(elf.SHF_ALLOC)
+		sh.Addralign = 8
+		resoff -= int64(elfMipsAbiFlags(sh, uint64(startva), uint64(resoff)))
+
+		ph := newElfPhdr()
+		ph.Type = elf.PT_MIPS_ABIFLAGS
+		ph.Flags = elf.PF_R
+		phsh(ph, sh)
+
+		sh = elfshname(".gnu.attributes")
+		sh.Type = uint32(elf.SHT_GNU_ATTRIBUTES)
+		sh.Addralign = 1
+		ldr := ctxt.loader
+		shsym(sh, ldr, ldr.Lookup(".gnu.attributes", 0))
+	}
+
 	// put these sections early in the list
 	if !*FlagS {
 		elfshname(".symtab")
@@ -2029,6 +2170,10 @@ elfobj:
 	if !*FlagD {
 		a += int64(elfwriteinterp(ctxt.Out))
 	}
+	if ctxt.IsMIPS() {
+		a += int64(elfWriteMipsAbiFlags(ctxt))
+	}
+
 	if ctxt.LinkMode != LinkExternal {
 		if ctxt.HeadType == objabi.Hnetbsd {
 			a += int64(elfwritenetbsdsig(ctxt.Out))
diff --git a/src/debug/elf/elf.go b/src/debug/elf/elf.go
index 2b777eabac..b04d874019 100644
--- a/src/debug/elf/elf.go
+++ b/src/debug/elf/elf.go
@@ -644,6 +644,7 @@ const (
 	SHT_GNU_VERSYM     SectionType = 0x6fffffff /* GNU version symbol table */
 	SHT_HIOS           SectionType = 0x6fffffff /* Last of OS specific semantics */
 	SHT_LOPROC         SectionType = 0x70000000 /* reserved range for processor */
+	SHT_MIPS_ABIFLAGS  SectionType = 0x7000002a /* .MIPS.abiflags */
 	SHT_HIPROC         SectionType = 0x7fffffff /* specific section header types */
 	SHT_LOUSER         SectionType = 0x80000000 /* reserved range for application */
 	SHT_HIUSER         SectionType = 0xffffffff /* specific indexes */
@@ -675,6 +676,7 @@ var shtStrings = []intName{
 	{0x6ffffffe, "SHT_GNU_VERNEED"},
 	{0x6fffffff, "SHT_GNU_VERSYM"},
 	{0x70000000, "SHT_LOPROC"},
+	{0x7000002a, "SHT_MIPS_ABIFLAGS"},
 	{0x7fffffff, "SHT_HIPROC"},
 	{0x80000000, "SHT_LOUSER"},
 	{0xffffffff, "SHT_HIUSER"},
-- 
GitLab


From a6eeb4add46eddb19ceba36bdd448738808e5ce2 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 24 Feb 2021 10:31:11 -0500
Subject: [PATCH 0882/2400] go/parser,go/types: hide API changes related to
 type parameters

While the dev.typeparams branch was merged, the type parameter API is
slated for go1.18. Hide these changes to the go/parser and go/types API.

This was done as follows:
 + For APIs that will probably not be needed for go1.18, simply unexport
   them.
 + For APIs that we expect to export in go1.18, prefix symbols with '_',
   so that the planned (upper-cased) symbol name is apparent.
 + For APIs that must be exported for testing, move both API and tests
   to files guarded by the go1.18 build constraint.
 + parser.ParseTypeParams is unexported and copied wherever it is
   needed.
 + The -G flag is removed from gofmt, replaced by enabling type
   parameters if built with the go1.18 build constraint.

Notably, changes related to type parameters in go/ast are currently left
exported. We're looking at the AST API separately.

The new API diff from 1.16 is:
+pkg go/ast, method (*FuncDecl) IsMethod() bool
+pkg go/ast, method (*ListExpr) End() token.Pos
+pkg go/ast, method (*ListExpr) Pos() token.Pos
+pkg go/ast, type FuncType struct, TParams *FieldList
+pkg go/ast, type ListExpr struct
+pkg go/ast, type ListExpr struct, ElemList []Expr
+pkg go/ast, type TypeSpec struct, TParams *FieldList
+pkg go/types, type Config struct, GoVersion string

Change-Id: I1baf67e26279b49092e774309a836c460979774a
Reviewed-on: https://go-review.googlesource.com/c/go/+/295929
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/gofmt/gofmt.go          |  25 ++++--
 src/cmd/gofmt/gofmt_go1.18.go   |  12 +++
 src/cmd/gofmt/gofmt_test.go     |   3 +-
 src/go/parser/error_test.go     |   2 +-
 src/go/parser/interface.go      |   8 +-
 src/go/parser/parser.go         |  22 ++---
 src/go/parser/short_test.go     |  14 ++--
 src/go/printer/printer_test.go  |  17 +++-
 src/go/types/api.go             |  10 +--
 src/go/types/api_go1.18.go      |  22 +++++
 src/go/types/api_go1.18_test.go | 138 ++++++++++++++++++++++++++++++
 src/go/types/api_test.go        | 124 +--------------------------
 src/go/types/builtins.go        |   8 +-
 src/go/types/call.go            |   2 +-
 src/go/types/check.go           |   4 +-
 src/go/types/check_test.go      |   6 +-
 src/go/types/decl.go            |   4 +-
 src/go/types/expr.go            |   8 +-
 src/go/types/infer.go           |   8 +-
 src/go/types/lookup.go          |   4 +-
 src/go/types/operand.go         |   2 +-
 src/go/types/predicates.go      |  22 ++---
 src/go/types/sanitize.go        |   8 +-
 src/go/types/scope.go           |   4 +-
 src/go/types/sizes.go           |   2 +-
 src/go/types/stmt.go            |   2 +-
 src/go/types/subst.go           |  20 ++---
 src/go/types/type.go            | 143 +++++++++++++++-----------------
 src/go/types/typestring.go      |   8 +-
 src/go/types/typexpr.go         |  14 ++--
 src/go/types/unify.go           |   8 +-
 31 files changed, 370 insertions(+), 304 deletions(-)
 create mode 100644 src/cmd/gofmt/gofmt_go1.18.go
 create mode 100644 src/go/types/api_go1.18.go
 create mode 100644 src/go/types/api_go1.18_test.go

diff --git a/src/cmd/gofmt/gofmt.go b/src/cmd/gofmt/gofmt.go
index b82aa7e7a9..95f537d91e 100644
--- a/src/cmd/gofmt/gofmt.go
+++ b/src/cmd/gofmt/gofmt.go
@@ -26,13 +26,16 @@ import (
 
 var (
 	// main operation modes
-	list            = flag.Bool("l", false, "list files whose formatting differs from gofmt's")
-	write           = flag.Bool("w", false, "write result to (source) file instead of stdout")
-	rewriteRule     = flag.String("r", "", "rewrite rule (e.g., 'a[b:len(a)] -> a[b:]')")
-	simplifyAST     = flag.Bool("s", false, "simplify code")
-	doDiff          = flag.Bool("d", false, "display diffs instead of rewriting files")
-	allErrors       = flag.Bool("e", false, "report all errors (not just the first 10 on different lines)")
-	allowTypeParams = flag.Bool("G", false, "allow generic code")
+	list        = flag.Bool("l", false, "list files whose formatting differs from gofmt's")
+	write       = flag.Bool("w", false, "write result to (source) file instead of stdout")
+	rewriteRule = flag.String("r", "", "rewrite rule (e.g., 'a[b:len(a)] -> a[b:]')")
+	simplifyAST = flag.Bool("s", false, "simplify code")
+	doDiff      = flag.Bool("d", false, "display diffs instead of rewriting files")
+	allErrors   = flag.Bool("e", false, "report all errors (not just the first 10 on different lines)")
+
+	// allowTypeParams controls whether type parameters are allowed in the code
+	// being formatted. It is enabled for go1.18 in gofmt_go1.18.go.
+	allowTypeParams = false
 
 	// debugging
 	cpuprofile = flag.String("cpuprofile", "", "write cpu profile to this file")
@@ -48,6 +51,10 @@ const (
 	//
 	// This value is defined in go/printer specifically for go/format and cmd/gofmt.
 	printerNormalizeNumbers = 1 << 30
+
+	// parseTypeParams tells go/parser to parse type parameters. Must be kept in
+	// sync with go/parser/interface.go.
+	parseTypeParams parser.Mode = 1 << 30
 )
 
 var (
@@ -72,8 +79,8 @@ func initParserMode() {
 	if *allErrors {
 		parserMode |= parser.AllErrors
 	}
-	if *allowTypeParams {
-		parserMode |= parser.ParseTypeParams
+	if allowTypeParams {
+		parserMode |= parseTypeParams
 	}
 }
 
diff --git a/src/cmd/gofmt/gofmt_go1.18.go b/src/cmd/gofmt/gofmt_go1.18.go
new file mode 100644
index 0000000000..be7b46b5ed
--- /dev/null
+++ b/src/cmd/gofmt/gofmt_go1.18.go
@@ -0,0 +1,12 @@
+// Copyright 2021 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.
+
+//go:build go1.18
+// +build go1.18
+
+package main
+
+func init() {
+	allowTypeParams = true
+}
diff --git a/src/cmd/gofmt/gofmt_test.go b/src/cmd/gofmt/gofmt_test.go
index 60e4f2e03d..9e2239a692 100644
--- a/src/cmd/gofmt/gofmt_test.go
+++ b/src/cmd/gofmt/gofmt_test.go
@@ -78,7 +78,8 @@ func runTest(t *testing.T, in, out string) {
 			// fake flag - pretend input is from stdin
 			stdin = true
 		case "-G":
-			*allowTypeParams = true
+			// fake flag - allow parsing type parameters
+			allowTypeParams = true
 		default:
 			t.Errorf("unrecognized flag name: %s", name)
 		}
diff --git a/src/go/parser/error_test.go b/src/go/parser/error_test.go
index 8e20b7b468..3caa3571e6 100644
--- a/src/go/parser/error_test.go
+++ b/src/go/parser/error_test.go
@@ -188,7 +188,7 @@ func TestErrors(t *testing.T) {
 		if !d.IsDir() && !strings.HasPrefix(name, ".") && (strings.HasSuffix(name, ".src") || strings.HasSuffix(name, ".go2")) {
 			mode := DeclarationErrors | AllErrors
 			if strings.HasSuffix(name, ".go2") {
-				mode |= ParseTypeParams
+				mode |= parseTypeParams
 			}
 			checkErrors(t, filepath.Join(testdata, name), nil, mode, true)
 		}
diff --git a/src/go/parser/interface.go b/src/go/parser/interface.go
index b8b312463f..123faaee77 100644
--- a/src/go/parser/interface.go
+++ b/src/go/parser/interface.go
@@ -55,8 +55,14 @@ const (
 	Trace                                          // print a trace of parsed productions
 	DeclarationErrors                              // report declaration errors
 	SpuriousErrors                                 // same as AllErrors, for backward-compatibility
-	ParseTypeParams                                // Placeholder. Will control the parsing of type parameters.
 	AllErrors         = SpuriousErrors             // report all errors (not just the first 10 on different lines)
+
+	// parseTypeParams controls the parsing of type parameters. Must be
+	// kept in sync with:
+	//  go/printer/printer_test.go
+	//  go/types/check_test.go
+	//  cmd/gofmt/gofmt.go
+	parseTypeParams = 1 << 30
 )
 
 // ParseFile parses the source code of a single Go source file and returns
diff --git a/src/go/parser/parser.go b/src/go/parser/parser.go
index 5c4cea8638..ed1867b3b3 100644
--- a/src/go/parser/parser.go
+++ b/src/go/parser/parser.go
@@ -651,7 +651,7 @@ func (p *parser) parseQualifiedIdent(ident *ast.Ident) ast.Expr {
 	}
 
 	typ := p.parseTypeName(ident)
-	if p.tok == token.LBRACK && p.mode&ParseTypeParams != 0 {
+	if p.tok == token.LBRACK && p.mode&parseTypeParams != 0 {
 		typ = p.parseTypeInstance(typ)
 	}
 
@@ -712,7 +712,7 @@ func (p *parser) parseArrayFieldOrTypeInstance(x *ast.Ident) (*ast.Ident, ast.Ex
 	// TODO(rfindley): consider changing parseRhsOrType so that this function variable
 	// is not needed.
 	argparser := p.parseRhsOrType
-	if p.mode&ParseTypeParams == 0 {
+	if p.mode&parseTypeParams == 0 {
 		argparser = p.parseRhs
 	}
 	if p.tok != token.RBRACK {
@@ -742,13 +742,13 @@ func (p *parser) parseArrayFieldOrTypeInstance(x *ast.Ident) (*ast.Ident, ast.Ex
 			// x [P]E
 			return x, &ast.ArrayType{Lbrack: lbrack, Len: args[0], Elt: elt}
 		}
-		if p.mode&ParseTypeParams == 0 {
+		if p.mode&parseTypeParams == 0 {
 			p.error(rbrack, "missing element type in array type expression")
 			return nil, &ast.BadExpr{From: args[0].Pos(), To: args[0].End()}
 		}
 	}
 
-	if p.mode&ParseTypeParams == 0 {
+	if p.mode&parseTypeParams == 0 {
 		p.error(firstComma, "expected ']', found ','")
 		return x, &ast.BadExpr{From: args[0].Pos(), To: args[len(args)-1].End()}
 	}
@@ -1045,7 +1045,7 @@ func (p *parser) parseParameters(scope *ast.Scope, acceptTParams bool) (tparams,
 		defer un(trace(p, "Parameters"))
 	}
 
-	if p.mode&ParseTypeParams != 0 && acceptTParams && p.tok == token.LBRACK {
+	if p.mode&parseTypeParams != 0 && acceptTParams && p.tok == token.LBRACK {
 		opening := p.pos
 		p.next()
 		// [T any](params) syntax
@@ -1119,7 +1119,7 @@ func (p *parser) parseMethodSpec(scope *ast.Scope) *ast.Field {
 	x := p.parseTypeName(nil)
 	if ident, _ := x.(*ast.Ident); ident != nil {
 		switch {
-		case p.tok == token.LBRACK && p.mode&ParseTypeParams != 0:
+		case p.tok == token.LBRACK && p.mode&parseTypeParams != 0:
 			// generic method or embedded instantiated type
 			lbrack := p.pos
 			p.next()
@@ -1171,7 +1171,7 @@ func (p *parser) parseMethodSpec(scope *ast.Scope) *ast.Field {
 	} else {
 		// embedded, possibly instantiated type
 		typ = x
-		if p.tok == token.LBRACK && p.mode&ParseTypeParams != 0 {
+		if p.tok == token.LBRACK && p.mode&parseTypeParams != 0 {
 			// embedded instantiated interface
 			typ = p.parseTypeInstance(typ)
 		}
@@ -1193,7 +1193,7 @@ func (p *parser) parseInterfaceType() *ast.InterfaceType {
 	lbrace := p.expect(token.LBRACE)
 	scope := ast.NewScope(nil) // interface scope
 	var list []*ast.Field
-	for p.tok == token.IDENT || p.mode&ParseTypeParams != 0 && p.tok == token.TYPE {
+	for p.tok == token.IDENT || p.mode&parseTypeParams != 0 && p.tok == token.TYPE {
 		if p.tok == token.IDENT {
 			list = append(list, p.parseMethodSpec(scope))
 		} else {
@@ -1289,7 +1289,7 @@ func (p *parser) tryIdentOrType() ast.Expr {
 	switch p.tok {
 	case token.IDENT:
 		typ := p.parseTypeName(nil)
-		if p.tok == token.LBRACK && p.mode&ParseTypeParams != 0 {
+		if p.tok == token.LBRACK && p.mode&parseTypeParams != 0 {
 			typ = p.parseTypeInstance(typ)
 		}
 		return typ
@@ -1552,7 +1552,7 @@ func (p *parser) parseIndexOrSliceOrInstance(x ast.Expr) ast.Expr {
 		return &ast.IndexExpr{X: x, Lbrack: lbrack, Index: index[0], Rbrack: rbrack}
 	}
 
-	if p.mode&ParseTypeParams == 0 {
+	if p.mode&parseTypeParams == 0 {
 		p.error(firstComma, "expected ']' or ':', found ','")
 		return &ast.BadExpr{From: args[0].Pos(), To: args[len(args)-1].End()}
 	}
@@ -2696,7 +2696,7 @@ func (p *parser) parseTypeSpec(doc *ast.CommentGroup, _ token.Pos, _ token.Token
 			p.exprLev++
 			x := p.parseExpr(true) // we don't know yet if we're a lhs or rhs expr
 			p.exprLev--
-			if name0, _ := x.(*ast.Ident); p.mode&ParseTypeParams != 0 && name0 != nil && p.tok != token.RBRACK {
+			if name0, _ := x.(*ast.Ident); p.mode&parseTypeParams != 0 && name0 != nil && p.tok != token.RBRACK {
 				// generic type [T any];
 				p.parseGenericType(spec, lbrack, name0, token.RBRACK)
 			} else {
diff --git a/src/go/parser/short_test.go b/src/go/parser/short_test.go
index 3676c27559..b21dd0aa60 100644
--- a/src/go/parser/short_test.go
+++ b/src/go/parser/short_test.go
@@ -64,8 +64,8 @@ var valids = []string{
 }
 
 // validWithTParamsOnly holds source code examples that are valid if
-// ParseTypeParams is set, but invalid if not. When checking with the
-// ParseTypeParams set, errors are ignored.
+// parseTypeParams is set, but invalid if not. When checking with the
+// parseTypeParams set, errors are ignored.
 var validWithTParamsOnly = []string{
 	`package p; type _ []T[ /* ERROR "expected ';', found '\['" */ int]`,
 	`package p; type T[P any /* ERROR "expected ']', found any" */ ] struct { P }`,
@@ -131,10 +131,10 @@ func TestValid(t *testing.T) {
 	})
 	t.Run("tparams", func(t *testing.T) {
 		for _, src := range valids {
-			checkErrors(t, src, src, DeclarationErrors|AllErrors|ParseTypeParams, false)
+			checkErrors(t, src, src, DeclarationErrors|AllErrors|parseTypeParams, false)
 		}
 		for _, src := range validWithTParamsOnly {
-			checkErrors(t, src, src, DeclarationErrors|AllErrors|ParseTypeParams, false)
+			checkErrors(t, src, src, DeclarationErrors|AllErrors|parseTypeParams, false)
 		}
 	})
 }
@@ -142,7 +142,7 @@ func TestValid(t *testing.T) {
 // TestSingle is useful to track down a problem with a single short test program.
 func TestSingle(t *testing.T) {
 	const src = `package p; var _ = T[P]{}`
-	checkErrors(t, src, src, DeclarationErrors|AllErrors|ParseTypeParams, true)
+	checkErrors(t, src, src, DeclarationErrors|AllErrors|parseTypeParams, true)
 }
 
 var invalids = []string{
@@ -261,10 +261,10 @@ func TestInvalid(t *testing.T) {
 	})
 	t.Run("tparams", func(t *testing.T) {
 		for _, src := range invalids {
-			checkErrors(t, src, src, DeclarationErrors|AllErrors|ParseTypeParams, true)
+			checkErrors(t, src, src, DeclarationErrors|AllErrors|parseTypeParams, true)
 		}
 		for _, src := range invalidTParamErrs {
-			checkErrors(t, src, src, DeclarationErrors|AllErrors|ParseTypeParams, true)
+			checkErrors(t, src, src, DeclarationErrors|AllErrors|parseTypeParams, true)
 		}
 	})
 }
diff --git a/src/go/printer/printer_test.go b/src/go/printer/printer_test.go
index 03c4badb04..e03c2df063 100644
--- a/src/go/printer/printer_test.go
+++ b/src/go/printer/printer_test.go
@@ -19,6 +19,10 @@ import (
 	"time"
 )
 
+// parseTypeParams tells go/parser to parse type parameters. Must be kept in
+// sync with go/parser/interface.go.
+const parseTypeParams parser.Mode = 1 << 30
+
 const (
 	dataDir  = "testdata"
 	tabwidth = 8
@@ -35,6 +39,7 @@ const (
 	rawFormat
 	normNumber
 	idempotent
+	allowTypeParams
 )
 
 // format parses src, prints the corresponding AST, verifies the resulting
@@ -42,7 +47,11 @@ const (
 // if any.
 func format(src []byte, mode checkMode) ([]byte, error) {
 	// parse src
-	f, err := parser.ParseFile(fset, "", src, parser.ParseComments|parser.ParseTypeParams)
+	parseMode := parser.ParseComments
+	if mode&allowTypeParams != 0 {
+		parseMode |= parseTypeParams
+	}
+	f, err := parser.ParseFile(fset, "", src, parseMode)
 	if err != nil {
 		return nil, fmt.Errorf("parse: %s\n%s", err, src)
 	}
@@ -70,7 +79,7 @@ func format(src []byte, mode checkMode) ([]byte, error) {
 
 	// make sure formatted output is syntactically correct
 	res := buf.Bytes()
-	if _, err := parser.ParseFile(fset, "", res, parser.ParseTypeParams); err != nil {
+	if _, err := parser.ParseFile(fset, "", res, parseTypeParams); err != nil {
 		return nil, fmt.Errorf("re-parse: %s\n%s", err, buf.Bytes())
 	}
 
@@ -201,13 +210,13 @@ var data = []entry{
 	{"linebreaks.input", "linebreaks.golden", idempotent},
 	{"expressions.input", "expressions.golden", idempotent},
 	{"expressions.input", "expressions.raw", rawFormat | idempotent},
-	{"declarations.input", "declarations.golden", 0},
+	{"declarations.input", "declarations.golden", allowTypeParams},
 	{"statements.input", "statements.golden", 0},
 	{"slow.input", "slow.golden", idempotent},
 	{"complit.input", "complit.x", export},
 	{"go2numbers.input", "go2numbers.golden", idempotent},
 	{"go2numbers.input", "go2numbers.norm", normNumber | idempotent},
-	{"generics.input", "generics.golden", idempotent},
+	{"generics.input", "generics.golden", idempotent | allowTypeParams},
 	{"gobuild1.input", "gobuild1.golden", idempotent},
 	{"gobuild2.input", "gobuild2.golden", idempotent},
 	{"gobuild3.input", "gobuild3.golden", idempotent},
diff --git a/src/go/types/api.go b/src/go/types/api.go
index 09ac65b81f..436c23099b 100644
--- a/src/go/types/api.go
+++ b/src/go/types/api.go
@@ -184,11 +184,11 @@ type Info struct {
 	// qualified identifiers are collected in the Uses map.
 	Types map[ast.Expr]TypeAndValue
 
-	// Inferred maps calls of parameterized functions that use
-	// type inference to the inferred type arguments and signature
+	// _Inferred maps calls of parameterized functions that use
+	// type inference to the _Inferred type arguments and signature
 	// of the function called. The recorded "call" expression may be
 	// an *ast.CallExpr (as in f(x)), or an *ast.IndexExpr (s in f[T]).
-	Inferred map[ast.Expr]Inferred
+	_Inferred map[ast.Expr]_Inferred
 
 	// Defs maps identifiers to the objects they define (including
 	// package names, dots "." of dot-imports, and blank "_" identifiers).
@@ -346,9 +346,9 @@ func (tv TypeAndValue) HasOk() bool {
 	return tv.mode == commaok || tv.mode == mapindex
 }
 
-// Inferred reports the inferred type arguments and signature
+// _Inferred reports the _Inferred type arguments and signature
 // for a parameterized function call that uses type inference.
-type Inferred struct {
+type _Inferred struct {
 	Targs []Type
 	Sig   *Signature
 }
diff --git a/src/go/types/api_go1.18.go b/src/go/types/api_go1.18.go
new file mode 100644
index 0000000000..d98f4ef0dc
--- /dev/null
+++ b/src/go/types/api_go1.18.go
@@ -0,0 +1,22 @@
+// Copyright 2021 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.
+
+//go:build go1.18
+// +build go1.18
+
+package types
+
+import (
+	"go/ast"
+)
+
+type Inferred = _Inferred
+
+func GetInferred(info *Info) map[ast.Expr]Inferred {
+	return info._Inferred
+}
+
+func SetInferred(info *Info, inferred map[ast.Expr]Inferred) {
+	info._Inferred = inferred
+}
diff --git a/src/go/types/api_go1.18_test.go b/src/go/types/api_go1.18_test.go
new file mode 100644
index 0000000000..bbbf70581d
--- /dev/null
+++ b/src/go/types/api_go1.18_test.go
@@ -0,0 +1,138 @@
+// Copyright 2021 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.
+
+//go:build go1.18
+
+package types_test
+
+import (
+	"fmt"
+	"go/ast"
+	"testing"
+
+	. "go/types"
+)
+
+func TestInferredInfo(t *testing.T) {
+	var tests = []struct {
+		src   string
+		fun   string
+		targs []string
+		sig   string
+	}{
+		{genericPkg + `p0; func f[T any](T); func _() { f(42) }`,
+			`f`,
+			[]string{`int`},
+			`func(int)`,
+		},
+		{genericPkg + `p1; func f[T any](T) T; func _() { f('@') }`,
+			`f`,
+			[]string{`rune`},
+			`func(rune) rune`,
+		},
+		{genericPkg + `p2; func f[T any](...T) T; func _() { f(0i) }`,
+			`f`,
+			[]string{`complex128`},
+			`func(...complex128) complex128`,
+		},
+		{genericPkg + `p3; func f[A, B, C any](A, *B, []C); func _() { f(1.2, new(string), []byte{}) }`,
+			`f`,
+			[]string{`float64`, `string`, `byte`},
+			`func(float64, *string, []byte)`,
+		},
+		{genericPkg + `p4; func f[A, B any](A, *B, ...[]B); func _() { f(1.2, new(byte)) }`,
+			`f`,
+			[]string{`float64`, `byte`},
+			`func(float64, *byte, ...[]byte)`,
+		},
+
+		{genericPkg + `s1; func f[T any, P interface{type *T}](x T); func _(x string) { f(x) }`,
+			`f`,
+			[]string{`string`, `*string`},
+			`func(x string)`,
+		},
+		{genericPkg + `s2; func f[T any, P interface{type *T}](x []T); func _(x []int) { f(x) }`,
+			`f`,
+			[]string{`int`, `*int`},
+			`func(x []int)`,
+		},
+		{genericPkg + `s3; type C[T any] interface{type chan<- T}; func f[T any, P C[T]](x []T); func _(x []int) { f(x) }`,
+			`f`,
+			[]string{`int`, `chan<- int`},
+			`func(x []int)`,
+		},
+		{genericPkg + `s4; type C[T any] interface{type chan<- T}; func f[T any, P C[T], Q C[[]*P]](x []T); func _(x []int) { f(x) }`,
+			`f`,
+			[]string{`int`, `chan<- int`, `chan<- []*chan<- int`},
+			`func(x []int)`,
+		},
+
+		{genericPkg + `t1; func f[T any, P interface{type *T}]() T; func _() { _ = f[string] }`,
+			`f`,
+			[]string{`string`, `*string`},
+			`func() string`,
+		},
+		{genericPkg + `t2; type C[T any] interface{type chan<- T}; func f[T any, P C[T]]() []T; func _() { _ = f[int] }`,
+			`f`,
+			[]string{`int`, `chan<- int`},
+			`func() []int`,
+		},
+		{genericPkg + `t3; type C[T any] interface{type chan<- T}; func f[T any, P C[T], Q C[[]*P]]() []T; func _() { _ = f[int] }`,
+			`f`,
+			[]string{`int`, `chan<- int`, `chan<- []*chan<- int`},
+			`func() []int`,
+		},
+	}
+
+	for _, test := range tests {
+		info := Info{}
+		SetInferred(&info, make(map[ast.Expr]Inferred))
+		name, err := mayTypecheck(t, "InferredInfo", test.src, &info)
+		if err != nil {
+			t.Errorf("package %s: %v", name, err)
+			continue
+		}
+
+		// look for inferred type arguments and signature
+		var targs []Type
+		var sig *Signature
+		for call, inf := range GetInferred(&info) {
+			var fun ast.Expr
+			switch x := call.(type) {
+			case *ast.CallExpr:
+				fun = x.Fun
+			case *ast.IndexExpr:
+				fun = x.X
+			default:
+				panic(fmt.Sprintf("unexpected call expression type %T", call))
+			}
+			if ExprString(fun) == test.fun {
+				targs = inf.Targs
+				sig = inf.Sig
+				break
+			}
+		}
+		if targs == nil {
+			t.Errorf("package %s: no inferred information found for %s", name, test.fun)
+			continue
+		}
+
+		// check that type arguments are correct
+		if len(targs) != len(test.targs) {
+			t.Errorf("package %s: got %d type arguments; want %d", name, len(targs), len(test.targs))
+			continue
+		}
+		for i, targ := range targs {
+			if got := targ.String(); got != test.targs[i] {
+				t.Errorf("package %s, %d. type argument: got %s; want %s", name, i, got, test.targs[i])
+				continue
+			}
+		}
+
+		// check that signature is correct
+		if got := sig.String(); got != test.sig {
+			t.Errorf("package %s: got %s; want %s", name, got, test.sig)
+		}
+	}
+}
diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go
index 20648f1cf6..0226a857bd 100644
--- a/src/go/types/api_test.go
+++ b/src/go/types/api_test.go
@@ -49,7 +49,7 @@ const genericPkg = "package generic_"
 
 func modeForSource(src string) parser.Mode {
 	if strings.HasPrefix(src, genericPkg) {
-		return parser.ParseTypeParams
+		return parseTypeParams
 	}
 	return 0
 }
@@ -377,128 +377,6 @@ func TestTypesInfo(t *testing.T) {
 	}
 }
 
-func TestInferredInfo(t *testing.T) {
-	var tests = []struct {
-		src   string
-		fun   string
-		targs []string
-		sig   string
-	}{
-		{genericPkg + `p0; func f[T any](T); func _() { f(42) }`,
-			`f`,
-			[]string{`int`},
-			`func(int)`,
-		},
-		{genericPkg + `p1; func f[T any](T) T; func _() { f('@') }`,
-			`f`,
-			[]string{`rune`},
-			`func(rune) rune`,
-		},
-		{genericPkg + `p2; func f[T any](...T) T; func _() { f(0i) }`,
-			`f`,
-			[]string{`complex128`},
-			`func(...complex128) complex128`,
-		},
-		{genericPkg + `p3; func f[A, B, C any](A, *B, []C); func _() { f(1.2, new(string), []byte{}) }`,
-			`f`,
-			[]string{`float64`, `string`, `byte`},
-			`func(float64, *string, []byte)`,
-		},
-		{genericPkg + `p4; func f[A, B any](A, *B, ...[]B); func _() { f(1.2, new(byte)) }`,
-			`f`,
-			[]string{`float64`, `byte`},
-			`func(float64, *byte, ...[]byte)`,
-		},
-
-		{genericPkg + `s1; func f[T any, P interface{type *T}](x T); func _(x string) { f(x) }`,
-			`f`,
-			[]string{`string`, `*string`},
-			`func(x string)`,
-		},
-		{genericPkg + `s2; func f[T any, P interface{type *T}](x []T); func _(x []int) { f(x) }`,
-			`f`,
-			[]string{`int`, `*int`},
-			`func(x []int)`,
-		},
-		{genericPkg + `s3; type C[T any] interface{type chan<- T}; func f[T any, P C[T]](x []T); func _(x []int) { f(x) }`,
-			`f`,
-			[]string{`int`, `chan<- int`},
-			`func(x []int)`,
-		},
-		{genericPkg + `s4; type C[T any] interface{type chan<- T}; func f[T any, P C[T], Q C[[]*P]](x []T); func _(x []int) { f(x) }`,
-			`f`,
-			[]string{`int`, `chan<- int`, `chan<- []*chan<- int`},
-			`func(x []int)`,
-		},
-
-		{genericPkg + `t1; func f[T any, P interface{type *T}]() T; func _() { _ = f[string] }`,
-			`f`,
-			[]string{`string`, `*string`},
-			`func() string`,
-		},
-		{genericPkg + `t2; type C[T any] interface{type chan<- T}; func f[T any, P C[T]]() []T; func _() { _ = f[int] }`,
-			`f`,
-			[]string{`int`, `chan<- int`},
-			`func() []int`,
-		},
-		{genericPkg + `t3; type C[T any] interface{type chan<- T}; func f[T any, P C[T], Q C[[]*P]]() []T; func _() { _ = f[int] }`,
-			`f`,
-			[]string{`int`, `chan<- int`, `chan<- []*chan<- int`},
-			`func() []int`,
-		},
-	}
-
-	for _, test := range tests {
-		info := Info{Inferred: make(map[ast.Expr]Inferred)}
-		name, err := mayTypecheck(t, "InferredInfo", test.src, &info)
-		if err != nil {
-			t.Errorf("package %s: %v", name, err)
-			continue
-		}
-
-		// look for inferred type arguments and signature
-		var targs []Type
-		var sig *Signature
-		for call, inf := range info.Inferred {
-			var fun ast.Expr
-			switch x := call.(type) {
-			case *ast.CallExpr:
-				fun = x.Fun
-			case *ast.IndexExpr:
-				fun = x.X
-			default:
-				panic(fmt.Sprintf("unexpected call expression type %T", call))
-			}
-			if ExprString(fun) == test.fun {
-				targs = inf.Targs
-				sig = inf.Sig
-				break
-			}
-		}
-		if targs == nil {
-			t.Errorf("package %s: no inferred information found for %s", name, test.fun)
-			continue
-		}
-
-		// check that type arguments are correct
-		if len(targs) != len(test.targs) {
-			t.Errorf("package %s: got %d type arguments; want %d", name, len(targs), len(test.targs))
-			continue
-		}
-		for i, targ := range targs {
-			if got := targ.String(); got != test.targs[i] {
-				t.Errorf("package %s, %d. type argument: got %s; want %s", name, i, got, test.targs[i])
-				continue
-			}
-		}
-
-		// check that signature is correct
-		if got := sig.String(); got != test.sig {
-			t.Errorf("package %s: got %s; want %s", name, got, test.sig)
-		}
-	}
-}
-
 func TestDefsInfo(t *testing.T) {
 	var tests = []struct {
 		src  string
diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go
index d45cd9b278..3df82fffda 100644
--- a/src/go/types/builtins.go
+++ b/src/go/types/builtins.go
@@ -179,7 +179,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 				mode = value
 			}
 
-		case *Sum:
+		case *_Sum:
 			if t.is(func(t Type) bool {
 				switch t := under(t).(type) {
 				case *Basic:
@@ -469,7 +469,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 				m = 2
 			case *Map, *Chan:
 				m = 1
-			case *Sum:
+			case *_Sum:
 				return t.is(valid)
 			default:
 				return false
@@ -732,8 +732,8 @@ func (check *Checker) applyTypeFunc(f func(Type) Type, x Type) Type {
 
 		// construct a suitable new type parameter
 		tpar := NewTypeName(token.NoPos, nil /* = Universe pkg */, "<type parameter>", nil)
-		ptyp := check.NewTypeParam(tpar, 0, &emptyInterface) // assigns type to tpar as a side-effect
-		tsum := NewSum(rtypes)
+		ptyp := check.newTypeParam(tpar, 0, &emptyInterface) // assigns type to tpar as a side-effect
+		tsum := _NewSum(rtypes)
 		ptyp.bound = &Interface{types: tsum, allMethods: markComplete, allTypes: tsum}
 
 		return ptyp
diff --git a/src/go/types/call.go b/src/go/types/call.go
index e56f741370..bd10f6fbc3 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -128,7 +128,7 @@ func (check *Checker) call(x *operand, call *ast.CallExpr) exprKind {
 				}
 				if t := asInterface(T); t != nil {
 					check.completeInterface(token.NoPos, t)
-					if t.IsConstraint() {
+					if t._IsConstraint() {
 						check.errorf(call, _Todo, "cannot use interface %s in conversion (contains type list or is comparable)", T)
 						break
 					}
diff --git a/src/go/types/check.go b/src/go/types/check.go
index 4cc3024de9..69e9466a8b 100644
--- a/src/go/types/check.go
+++ b/src/go/types/check.go
@@ -396,8 +396,8 @@ func (check *Checker) recordCommaOkTypes(x ast.Expr, a [2]Type) {
 func (check *Checker) recordInferred(call ast.Expr, targs []Type, sig *Signature) {
 	assert(call != nil)
 	assert(sig != nil)
-	if m := check.Inferred; m != nil {
-		m[call] = Inferred{targs, sig}
+	if m := check._Inferred; m != nil {
+		m[call] = _Inferred{targs, sig}
 	}
 }
 
diff --git a/src/go/types/check_test.go b/src/go/types/check_test.go
index c92855b3d8..9812b3808b 100644
--- a/src/go/types/check_test.go
+++ b/src/go/types/check_test.go
@@ -44,6 +44,10 @@ import (
 	. "go/types"
 )
 
+// parseTypeParams tells go/parser to parse type parameters. Must be kept in
+// sync with go/parser/interface.go.
+const parseTypeParams parser.Mode = 1 << 30
+
 var (
 	haltOnError = flag.Bool("halt", false, "halt on error")
 	listErrors  = flag.Bool("errlist", false, "list errors")
@@ -210,7 +214,7 @@ func checkFiles(t *testing.T, goVersion string, filenames []string, srcs [][]byt
 
 	mode := parser.AllErrors
 	if strings.HasSuffix(filenames[0], ".go2") {
-		mode |= parser.ParseTypeParams
+		mode |= parseTypeParams
 	}
 
 	// parse files and collect parser errors
diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index 1134607e92..2eb2c39745 100644
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -713,7 +713,7 @@ func (check *Checker) collectTypeParams(list *ast.FieldList) (tparams []*TypeNam
 
 	setBoundAt := func(at int, bound Type) {
 		assert(IsInterface(bound))
-		tparams[at].typ.(*TypeParam).bound = bound
+		tparams[at].typ.(*_TypeParam).bound = bound
 	}
 
 	index := 0
@@ -756,7 +756,7 @@ func (check *Checker) collectTypeParams(list *ast.FieldList) (tparams []*TypeNam
 func (check *Checker) declareTypeParams(tparams []*TypeName, names []*ast.Ident) []*TypeName {
 	for _, name := range names {
 		tpar := NewTypeName(name.Pos(), check.pkg, name.Name, nil)
-		check.NewTypeParam(tpar, len(tparams), &emptyInterface) // assigns type to tpar as a side-effect
+		check.newTypeParam(tpar, len(tparams), &emptyInterface) // assigns type to tpar as a side-effect
 		check.declare(check.scope, name, tpar, check.scope.pos) // TODO(gri) check scope position
 		tparams = append(tparams, tpar)
 	}
diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 9b51ce94b7..e1b484c410 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -660,7 +660,7 @@ func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, const
 		default:
 			return nil, nil, _InvalidUntypedConversion
 		}
-	case *Sum:
+	case *_Sum:
 		ok := t.is(func(t Type) bool {
 			target, _, _ := check.implicitTypeAndValue(x, t)
 			return target != nil
@@ -1517,7 +1517,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 			x.expr = e
 			return expression
 
-		case *Sum:
+		case *_Sum:
 			// A sum type can be indexed if all of the sum's types
 			// support indexing and have the same index and element
 			// type. Special rules apply for maps in the sum type.
@@ -1549,7 +1549,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 					tkey = t.key
 					e = t.elem
 					nmaps++
-				case *TypeParam:
+				case *_TypeParam:
 					check.errorf(x, 0, "type of %s contains a type parameter - cannot index (implementation restriction)", x)
 				case *instance:
 					panic("unimplemented")
@@ -1661,7 +1661,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 			valid = true
 			// x.typ doesn't change
 
-		case *Sum, *TypeParam:
+		case *_Sum, *_TypeParam:
 			check.errorf(x, 0, "generic slice expressions not yet implemented")
 			goto Error
 		}
diff --git a/src/go/types/infer.go b/src/go/types/infer.go
index 95bd3cb378..4b20836f88 100644
--- a/src/go/types/infer.go
+++ b/src/go/types/infer.go
@@ -98,7 +98,7 @@ func (check *Checker) infer(tparams []*TypeName, params *Tuple, args []*operand)
 		// only parameter type it can possibly match against is a *TypeParam.
 		// Thus, only keep the indices of generic parameters that are not of
 		// composite types and which don't have a type inferred yet.
-		if tpar, _ := par.typ.(*TypeParam); tpar != nil && u.x.at(tpar.index) == nil {
+		if tpar, _ := par.typ.(*_TypeParam); tpar != nil && u.x.at(tpar.index) == nil {
 			indices[j] = i
 			j++
 		}
@@ -201,7 +201,7 @@ func (w *tpWalker) isParameterized(typ Type) (res bool) {
 			}
 		}
 
-	case *Sum:
+	case *_Sum:
 		return w.isParameterizedList(t.types)
 
 	case *Signature:
@@ -243,7 +243,7 @@ func (w *tpWalker) isParameterized(typ Type) (res bool) {
 	case *Named:
 		return w.isParameterizedList(t.targs)
 
-	case *TypeParam:
+	case *_TypeParam:
 		// t must be one of w.tparams
 		return t.index < len(w.tparams) && w.tparams[t.index].typ == t
 
@@ -291,7 +291,7 @@ func (check *Checker) inferB(tparams []*TypeName, targs []Type) (types []Type, i
 
 	// Unify type parameters with their structural constraints, if any.
 	for _, tpar := range tparams {
-		typ := tpar.typ.(*TypeParam)
+		typ := tpar.typ.(*_TypeParam)
 		sbound := check.structuralType(typ.bound)
 		if sbound != nil {
 			if !u.unify(typ, sbound) {
diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go
index a0e7f3cc0d..3691b1ecaa 100644
--- a/src/go/types/lookup.go
+++ b/src/go/types/lookup.go
@@ -107,7 +107,7 @@ func (check *Checker) rawLookupFieldOrMethod(T Type, addressable bool, pkg *Pack
 		var next []embeddedType // embedded types found at current depth
 
 		// look for (pkg, name) in all types at current depth
-		var tpar *TypeParam // set if obj receiver is a type parameter
+		var tpar *_TypeParam // set if obj receiver is a type parameter
 		for _, e := range current {
 			typ := e.typ
 
@@ -195,7 +195,7 @@ func (check *Checker) rawLookupFieldOrMethod(T Type, addressable bool, pkg *Pack
 					indirect = e.indirect
 				}
 
-			case *TypeParam:
+			case *_TypeParam:
 				// only consider explicit methods in the type parameter bound, not
 				// methods that may be common to all types in the type list.
 				if i, m := lookupMethod(t.Bound().allMethods, pkg, name); m != nil {
diff --git a/src/go/types/operand.go b/src/go/types/operand.go
index 8f9c9d09bf..8344c059c4 100644
--- a/src/go/types/operand.go
+++ b/src/go/types/operand.go
@@ -242,7 +242,7 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er
 
 	// x is an untyped value representable by a value of type T.
 	if isUntyped(Vu) {
-		if t, ok := Tu.(*Sum); ok {
+		if t, ok := Tu.(*_Sum); ok {
 			return t.is(func(t Type) bool {
 				// TODO(gri) this could probably be more efficient
 				ok, _ := x.assignableTo(check, t, reason)
diff --git a/src/go/types/predicates.go b/src/go/types/predicates.go
index 0ff8fcbbf7..7bb026414f 100644
--- a/src/go/types/predicates.go
+++ b/src/go/types/predicates.go
@@ -14,7 +14,7 @@ import (
 // isNamed may be called with types that are not fully set up.
 func isNamed(typ Type) bool {
 	switch typ.(type) {
-	case *Basic, *Named, *TypeParam, *instance:
+	case *Basic, *Named, *_TypeParam, *instance:
 		return true
 	}
 	return false
@@ -32,7 +32,7 @@ func is(typ Type, what BasicInfo) bool {
 	switch t := optype(typ).(type) {
 	case *Basic:
 		return t.info&what != 0
-	case *Sum:
+	case *_Sum:
 		return t.is(func(typ Type) bool { return is(typ, what) })
 	}
 	return false
@@ -109,7 +109,7 @@ func comparable(T Type, seen map[Type]bool) bool {
 	//
 	// is not comparable because []byte is not comparable.
 	if t := asTypeParam(T); t != nil && optype(t) == theTop {
-		return t.Bound().IsComparable()
+		return t.Bound()._IsComparable()
 	}
 
 	switch t := optype(T).(type) {
@@ -128,13 +128,13 @@ func comparable(T Type, seen map[Type]bool) bool {
 		return true
 	case *Array:
 		return comparable(t.elem, seen)
-	case *Sum:
+	case *_Sum:
 		pred := func(t Type) bool {
 			return comparable(t, seen)
 		}
 		return t.is(pred)
-	case *TypeParam:
-		return t.Bound().IsComparable()
+	case *_TypeParam:
+		return t.Bound()._IsComparable()
 	}
 	return false
 }
@@ -146,7 +146,7 @@ func hasNil(typ Type) bool {
 		return t.kind == UnsafePointer
 	case *Slice, *Pointer, *Signature, *Interface, *Map, *Chan:
 		return true
-	case *Sum:
+	case *_Sum:
 		return t.is(hasNil)
 	}
 	return false
@@ -265,14 +265,14 @@ func (check *Checker) identical0(x, y Type, cmpTags bool, p *ifacePair) bool {
 				check.identical0(x.results, y.results, cmpTags, p)
 		}
 
-	case *Sum:
+	case *_Sum:
 		// Two sum types are identical if they contain the same types.
 		// (Sum types always consist of at least two types. Also, the
 		// the set (list) of types in a sum type consists of unique
 		// types - each type appears exactly once. Thus, two sum types
 		// must contain the same number of types to have chance of
 		// being equal.
-		if y, ok := y.(*Sum); ok && len(x.types) == len(y.types) {
+		if y, ok := y.(*_Sum); ok && len(x.types) == len(y.types) {
 			// Every type in x.types must be in y.types.
 			// Quadratic algorithm, but probably good enough for now.
 			// TODO(gri) we need a fast quick type ID/hash for all types.
@@ -370,7 +370,7 @@ func (check *Checker) identical0(x, y Type, cmpTags bool, p *ifacePair) bool {
 			return x.obj == y.obj
 		}
 
-	case *TypeParam:
+	case *_TypeParam:
 		// nothing to do (x and y being equal is caught in the very beginning of this function)
 
 	// case *instance:
@@ -397,7 +397,7 @@ func (check *Checker) identicalTParams(x, y []*TypeName, cmpTags bool, p *ifaceP
 	}
 	for i, x := range x {
 		y := y[i]
-		if !check.identical0(x.typ.(*TypeParam).bound, y.typ.(*TypeParam).bound, cmpTags, p) {
+		if !check.identical0(x.typ.(*_TypeParam).bound, y.typ.(*_TypeParam).bound, cmpTags, p) {
 			return false
 		}
 	}
diff --git a/src/go/types/sanitize.go b/src/go/types/sanitize.go
index 3a6896c5c2..3429867321 100644
--- a/src/go/types/sanitize.go
+++ b/src/go/types/sanitize.go
@@ -24,7 +24,7 @@ func sanitizeInfo(info *Info) {
 		}
 	}
 
-	for e, inf := range info.Inferred {
+	for e, inf := range info._Inferred {
 		changed := false
 		for i, targ := range inf.Targs {
 			if typ := s.typ(targ); typ != targ {
@@ -37,7 +37,7 @@ func sanitizeInfo(info *Info) {
 			changed = true
 		}
 		if changed {
-			info.Inferred[e] = inf
+			info._Inferred[e] = inf
 		}
 	}
 
@@ -102,7 +102,7 @@ func (s sanitizer) typ(typ Type) Type {
 		s.tuple(t.params)
 		s.tuple(t.results)
 
-	case *Sum:
+	case *_Sum:
 		s.typeList(t.types)
 
 	case *Interface:
@@ -135,7 +135,7 @@ func (s sanitizer) typ(typ Type) Type {
 		s.typeList(t.targs)
 		s.funcList(t.methods)
 
-	case *TypeParam:
+	case *_TypeParam:
 		if bound := s.typ(t.bound); bound != t.bound {
 			t.bound = bound
 		}
diff --git a/src/go/types/scope.go b/src/go/types/scope.go
index 157b1b7066..26c28d1c4e 100644
--- a/src/go/types/scope.go
+++ b/src/go/types/scope.go
@@ -108,13 +108,13 @@ func (s *Scope) Insert(obj Object) Object {
 	return nil
 }
 
-// Squash merges s with its parent scope p by adding all
+// squash merges s with its parent scope p by adding all
 // objects of s to p, adding all children of s to the
 // children of p, and removing s from p's children.
 // The function f is called for each object obj in s which
 // has an object alt in p. s should be discarded after
 // having been squashed.
-func (s *Scope) Squash(err func(obj, alt Object)) {
+func (s *Scope) squash(err func(obj, alt Object)) {
 	p := s.parent
 	assert(p != nil)
 	for _, obj := range s.elems {
diff --git a/src/go/types/sizes.go b/src/go/types/sizes.go
index e8377a4f92..67052bb816 100644
--- a/src/go/types/sizes.go
+++ b/src/go/types/sizes.go
@@ -148,7 +148,7 @@ func (s *StdSizes) Sizeof(T Type) int64 {
 		}
 		offsets := s.Offsetsof(t.fields)
 		return offsets[n-1] + s.Sizeof(t.fields[n-1].typ)
-	case *Sum:
+	case *_Sum:
 		panic("Sizeof unimplemented for type sum")
 	case *Interface:
 		return s.WordSize * 2
diff --git a/src/go/types/stmt.go b/src/go/types/stmt.go
index 82c21c2a7a..27da198a85 100644
--- a/src/go/types/stmt.go
+++ b/src/go/types/stmt.go
@@ -907,7 +907,7 @@ func rangeKeyVal(typ Type, wantKey, wantVal bool) (Type, Type, string) {
 			msg = "send-only channel"
 		}
 		return typ.elem, Typ[Invalid], msg
-	case *Sum:
+	case *_Sum:
 		first := true
 		var key, val Type
 		var msg string
diff --git a/src/go/types/subst.go b/src/go/types/subst.go
index ed27488503..931375f1f2 100644
--- a/src/go/types/subst.go
+++ b/src/go/types/subst.go
@@ -22,21 +22,21 @@ type substMap struct {
 	// TODO(gri) rewrite that code, get rid of this field, and make this
 	//           struct just the map (proj)
 	targs []Type
-	proj  map[*TypeParam]Type
+	proj  map[*_TypeParam]Type
 }
 
 // makeSubstMap creates a new substitution map mapping tpars[i] to targs[i].
 // If targs[i] is nil, tpars[i] is not substituted.
 func makeSubstMap(tpars []*TypeName, targs []Type) *substMap {
 	assert(len(tpars) == len(targs))
-	proj := make(map[*TypeParam]Type, len(tpars))
+	proj := make(map[*_TypeParam]Type, len(tpars))
 	for i, tpar := range tpars {
 		// We must expand type arguments otherwise *instance
 		// types end up as components in composite types.
 		// TODO(gri) explain why this causes problems, if it does
 		targ := expand(targs[i]) // possibly nil
 		targs[i] = targ
-		proj[tpar.typ.(*TypeParam)] = targ
+		proj[tpar.typ.(*_TypeParam)] = targ
 	}
 	return &substMap{targs, proj}
 }
@@ -49,7 +49,7 @@ func (m *substMap) empty() bool {
 	return len(m.proj) == 0
 }
 
-func (m *substMap) lookup(tpar *TypeParam) Type {
+func (m *substMap) lookup(tpar *_TypeParam) Type {
 	if t := m.proj[tpar]; t != nil {
 		return t
 	}
@@ -121,7 +121,7 @@ func (check *Checker) instantiate(pos token.Pos, typ Type, targs []Type, poslist
 
 	// check bounds
 	for i, tname := range tparams {
-		tpar := tname.typ.(*TypeParam)
+		tpar := tname.typ.(*_TypeParam)
 		iface := tpar.Bound()
 		if iface.Empty() {
 			continue // no type bound
@@ -222,7 +222,7 @@ func (check *Checker) subst(pos token.Pos, typ Type, smap *substMap) Type {
 	switch t := typ.(type) {
 	case *Basic:
 		return typ // nothing to do
-	case *TypeParam:
+	case *_TypeParam:
 		return smap.lookup(t)
 	}
 
@@ -293,13 +293,13 @@ func (subst *subster) typ(typ Type) Type {
 			}
 		}
 
-	case *Sum:
+	case *_Sum:
 		types, copied := subst.typeList(t.types)
 		if copied {
 			// Don't do it manually, with a Sum literal: the new
 			// types list may not be unique and NewSum may remove
 			// duplicates.
-			return NewSum(types)
+			return _NewSum(types)
 		}
 
 	case *Interface:
@@ -389,7 +389,7 @@ func (subst *subster) typ(typ Type) Type {
 
 		// create a new named type and populate caches to avoid endless recursion
 		tname := NewTypeName(subst.pos, t.obj.pkg, t.obj.name, nil)
-		named := subst.check.NewNamed(tname, t.underlying, t.methods) // method signatures are updated lazily
+		named := subst.check.newNamed(tname, t.underlying, t.methods) // method signatures are updated lazily
 		named.tparams = t.tparams                                     // new type is still parameterized
 		named.targs = newTargs
 		subst.check.typMap[h] = named
@@ -402,7 +402,7 @@ func (subst *subster) typ(typ Type) Type {
 
 		return named
 
-	case *TypeParam:
+	case *_TypeParam:
 		return subst.smap.lookup(t)
 
 	case *instance:
diff --git a/src/go/types/type.go b/src/go/types/type.go
index 21892c9270..201da95a58 100644
--- a/src/go/types/type.go
+++ b/src/go/types/type.go
@@ -240,11 +240,11 @@ func NewSignature(recv *Var, params, results *Tuple, variadic bool) *Signature {
 // contain methods whose receiver type is a different interface.
 func (s *Signature) Recv() *Var { return s.recv }
 
-// TParams returns the type parameters of signature s, or nil.
-func (s *Signature) TParams() []*TypeName { return s.tparams }
+// _TParams returns the type parameters of signature s, or nil.
+func (s *Signature) _TParams() []*TypeName { return s.tparams }
 
-// SetTParams sets the type parameters of signature s.
-func (s *Signature) SetTParams(tparams []*TypeName) { s.tparams = tparams }
+// _SetTParams sets the type parameters of signature s.
+func (s *Signature) _SetTParams(tparams []*TypeName) { s.tparams = tparams }
 
 // Params returns the parameters of signature s, or nil.
 func (s *Signature) Params() *Tuple { return s.params }
@@ -255,19 +255,19 @@ func (s *Signature) Results() *Tuple { return s.results }
 // Variadic reports whether the signature s is variadic.
 func (s *Signature) Variadic() bool { return s.variadic }
 
-// A Sum represents a set of possible types.
+// A _Sum represents a set of possible types.
 // Sums are currently used to represent type lists of interfaces
 // and thus the underlying types of type parameters; they are not
 // first class types of Go.
-type Sum struct {
+type _Sum struct {
 	types []Type // types are unique
 }
 
-// NewSum returns a new Sum type consisting of the provided
+// _NewSum returns a new Sum type consisting of the provided
 // types if there are more than one. If there is exactly one
 // type, it returns that type. If the list of types is empty
 // the result is nil.
-func NewSum(types []Type) Type {
+func _NewSum(types []Type) Type {
 	if len(types) == 0 {
 		return nil
 	}
@@ -278,7 +278,7 @@ func NewSum(types []Type) Type {
 	// current use case of type lists.
 	// TODO(gri) Come up with the rules for sum types.
 	for _, t := range types {
-		if _, ok := t.(*Sum); ok {
+		if _, ok := t.(*_Sum); ok {
 			panic("sum type contains sum type - unimplemented")
 		}
 	}
@@ -286,11 +286,11 @@ func NewSum(types []Type) Type {
 	if len(types) == 1 {
 		return types[0]
 	}
-	return &Sum{types: types}
+	return &_Sum{types: types}
 }
 
 // is reports whether all types in t satisfy pred.
-func (s *Sum) is(pred func(Type) bool) bool {
+func (s *_Sum) is(pred func(Type) bool) bool {
 	if s == nil {
 		return false
 	}
@@ -446,8 +446,8 @@ func (t *Interface) Empty() bool {
 	}, nil)
 }
 
-// HasTypeList reports whether interface t has a type list, possibly from an embedded type.
-func (t *Interface) HasTypeList() bool {
+// _HasTypeList reports whether interface t has a type list, possibly from an embedded type.
+func (t *Interface) _HasTypeList() bool {
 	if t.allMethods != nil {
 		// interface is complete - quick test
 		return t.allTypes != nil
@@ -458,8 +458,8 @@ func (t *Interface) HasTypeList() bool {
 	}, nil)
 }
 
-// IsComparable reports whether interface t is or embeds the predeclared interface "comparable".
-func (t *Interface) IsComparable() bool {
+// _IsComparable reports whether interface t is or embeds the predeclared interface "comparable".
+func (t *Interface) _IsComparable() bool {
 	if t.allMethods != nil {
 		// interface is complete - quick test
 		_, m := lookupMethod(t.allMethods, nil, "==")
@@ -472,8 +472,8 @@ func (t *Interface) IsComparable() bool {
 	}, nil)
 }
 
-// IsConstraint reports t.HasTypeList() || t.IsComparable().
-func (t *Interface) IsConstraint() bool {
+// _IsConstraint reports t.HasTypeList() || t.IsComparable().
+func (t *Interface) _IsConstraint() bool {
 	if t.allMethods != nil {
 		// interface is complete - quick test
 		if t.allTypes != nil {
@@ -667,7 +667,7 @@ func NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named {
 	return typ
 }
 
-func (check *Checker) NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named {
+func (check *Checker) newNamed(obj *TypeName, underlying Type, methods []*Func) *Named {
 	typ := &Named{check: check, obj: obj, orig: underlying, underlying: underlying, methods: methods}
 	if obj.typ == nil {
 		obj.typ = typ
@@ -681,15 +681,15 @@ func (t *Named) Obj() *TypeName { return t.obj }
 // TODO(gri) Come up with a better representation and API to distinguish
 //           between parameterized instantiated and non-instantiated types.
 
-// TParams returns the type parameters of the named type t, or nil.
+// _TParams returns the type parameters of the named type t, or nil.
 // The result is non-nil for an (originally) parameterized type even if it is instantiated.
-func (t *Named) TParams() []*TypeName { return t.tparams }
+func (t *Named) _TParams() []*TypeName { return t.tparams }
 
-// TArgs returns the type arguments after instantiation of the named type t, or nil if not instantiated.
-func (t *Named) TArgs() []Type { return t.targs }
+// _TArgs returns the type arguments after instantiation of the named type t, or nil if not instantiated.
+func (t *Named) _TArgs() []Type { return t.targs }
 
-// SetTArgs sets the type arguments of Named.
-func (t *Named) SetTArgs(args []Type) { t.targs = args }
+// _SetTArgs sets the type arguments of Named.
+func (t *Named) _SetTArgs(args []Type) { t.targs = args }
 
 // NumMethods returns the number of explicit methods whose receiver is named type t.
 func (t *Named) NumMethods() int { return len(t.methods) }
@@ -715,8 +715,8 @@ func (t *Named) AddMethod(m *Func) {
 	}
 }
 
-// A TypeParam represents a type parameter type.
-type TypeParam struct {
+// A _TypeParam represents a type parameter type.
+type _TypeParam struct {
 	check *Checker  // for lazy type bound completion
 	id    uint64    // unique id
 	obj   *TypeName // corresponding type name
@@ -724,10 +724,10 @@ type TypeParam struct {
 	bound Type      // *Named or *Interface; underlying type is always *Interface
 }
 
-// NewTypeParam returns a new TypeParam.
-func (check *Checker) NewTypeParam(obj *TypeName, index int, bound Type) *TypeParam {
+// newTypeParam returns a new TypeParam.
+func (check *Checker) newTypeParam(obj *TypeName, index int, bound Type) *_TypeParam {
 	assert(bound != nil)
-	typ := &TypeParam{check: check, id: check.nextId, obj: obj, index: index, bound: bound}
+	typ := &_TypeParam{check: check, id: check.nextId, obj: obj, index: index, bound: bound}
 	check.nextId++
 	if obj.typ == nil {
 		obj.typ = typ
@@ -735,7 +735,7 @@ func (check *Checker) NewTypeParam(obj *TypeName, index int, bound Type) *TypePa
 	return typ
 }
 
-func (t *TypeParam) Bound() *Interface {
+func (t *_TypeParam) Bound() *Interface {
 	iface := asInterface(t.bound)
 	// use the type bound position if we have one
 	pos := token.NoPos
@@ -839,40 +839,40 @@ type top struct{}
 var theTop = &top{}
 
 // Type-specific implementations of Underlying.
-func (t *Basic) Underlying() Type     { return t }
-func (t *Array) Underlying() Type     { return t }
-func (t *Slice) Underlying() Type     { return t }
-func (t *Struct) Underlying() Type    { return t }
-func (t *Pointer) Underlying() Type   { return t }
-func (t *Tuple) Underlying() Type     { return t }
-func (t *Signature) Underlying() Type { return t }
-func (t *Sum) Underlying() Type       { return t }
-func (t *Interface) Underlying() Type { return t }
-func (t *Map) Underlying() Type       { return t }
-func (t *Chan) Underlying() Type      { return t }
-func (t *Named) Underlying() Type     { return t.underlying }
-func (t *TypeParam) Underlying() Type { return t }
-func (t *instance) Underlying() Type  { return t }
-func (t *bottom) Underlying() Type    { return t }
-func (t *top) Underlying() Type       { return t }
+func (t *Basic) Underlying() Type      { return t }
+func (t *Array) Underlying() Type      { return t }
+func (t *Slice) Underlying() Type      { return t }
+func (t *Struct) Underlying() Type     { return t }
+func (t *Pointer) Underlying() Type    { return t }
+func (t *Tuple) Underlying() Type      { return t }
+func (t *Signature) Underlying() Type  { return t }
+func (t *_Sum) Underlying() Type       { return t }
+func (t *Interface) Underlying() Type  { return t }
+func (t *Map) Underlying() Type        { return t }
+func (t *Chan) Underlying() Type       { return t }
+func (t *Named) Underlying() Type      { return t.underlying }
+func (t *_TypeParam) Underlying() Type { return t }
+func (t *instance) Underlying() Type   { return t }
+func (t *bottom) Underlying() Type     { return t }
+func (t *top) Underlying() Type        { return t }
 
 // Type-specific implementations of String.
-func (t *Basic) String() string     { return TypeString(t, nil) }
-func (t *Array) String() string     { return TypeString(t, nil) }
-func (t *Slice) String() string     { return TypeString(t, nil) }
-func (t *Struct) String() string    { return TypeString(t, nil) }
-func (t *Pointer) String() string   { return TypeString(t, nil) }
-func (t *Tuple) String() string     { return TypeString(t, nil) }
-func (t *Signature) String() string { return TypeString(t, nil) }
-func (t *Sum) String() string       { return TypeString(t, nil) }
-func (t *Interface) String() string { return TypeString(t, nil) }
-func (t *Map) String() string       { return TypeString(t, nil) }
-func (t *Chan) String() string      { return TypeString(t, nil) }
-func (t *Named) String() string     { return TypeString(t, nil) }
-func (t *TypeParam) String() string { return TypeString(t, nil) }
-func (t *instance) String() string  { return TypeString(t, nil) }
-func (t *bottom) String() string    { return TypeString(t, nil) }
-func (t *top) String() string       { return TypeString(t, nil) }
+func (t *Basic) String() string      { return TypeString(t, nil) }
+func (t *Array) String() string      { return TypeString(t, nil) }
+func (t *Slice) String() string      { return TypeString(t, nil) }
+func (t *Struct) String() string     { return TypeString(t, nil) }
+func (t *Pointer) String() string    { return TypeString(t, nil) }
+func (t *Tuple) String() string      { return TypeString(t, nil) }
+func (t *Signature) String() string  { return TypeString(t, nil) }
+func (t *_Sum) String() string       { return TypeString(t, nil) }
+func (t *Interface) String() string  { return TypeString(t, nil) }
+func (t *Map) String() string        { return TypeString(t, nil) }
+func (t *Chan) String() string       { return TypeString(t, nil) }
+func (t *Named) String() string      { return TypeString(t, nil) }
+func (t *_TypeParam) String() string { return TypeString(t, nil) }
+func (t *instance) String() string   { return TypeString(t, nil) }
+func (t *bottom) String() string     { return TypeString(t, nil) }
+func (t *top) String() string        { return TypeString(t, nil) }
 
 // under returns the true expanded underlying type.
 // If it doesn't exist, the result is Typ[Invalid].
@@ -909,22 +909,11 @@ func asSlice(t Type) *Slice {
 	return op
 }
 
-// TODO (rFindley) delete this on the dev.typeparams branch. This is only
-// exported in the prototype for legacy compatibility.
-func AsStruct(t Type) *Struct {
-	return asStruct(t)
-}
-
 func asStruct(t Type) *Struct {
 	op, _ := optype(t).(*Struct)
 	return op
 }
 
-// TODO(rFindley) delete this on the dev.typeparams branch (see ToStruct).
-func AsPointer(t Type) *Pointer {
-	return asPointer(t)
-}
-
 func asPointer(t Type) *Pointer {
 	op, _ := optype(t).(*Pointer)
 	return op
@@ -940,8 +929,8 @@ func asSignature(t Type) *Signature {
 	return op
 }
 
-func asSum(t Type) *Sum {
-	op, _ := optype(t).(*Sum)
+func asSum(t Type) *_Sum {
+	op, _ := optype(t).(*_Sum)
 	return op
 }
 
@@ -969,7 +958,7 @@ func asNamed(t Type) *Named {
 	return e
 }
 
-func asTypeParam(t Type) *TypeParam {
-	u, _ := under(t).(*TypeParam)
+func asTypeParam(t Type) *_TypeParam {
+	u, _ := under(t).(*_TypeParam)
 	return u
 }
diff --git a/src/go/types/typestring.go b/src/go/types/typestring.go
index a0caded160..fe27f0f276 100644
--- a/src/go/types/typestring.go
+++ b/src/go/types/typestring.go
@@ -158,7 +158,7 @@ func writeType(buf *bytes.Buffer, typ Type, qf Qualifier, visited []Type) {
 		buf.WriteString("func")
 		writeSignature(buf, t, qf, visited)
 
-	case *Sum:
+	case *_Sum:
 		for i, t := range t.types {
 			if i > 0 {
 				buf.WriteString(", ")
@@ -279,7 +279,7 @@ func writeType(buf *bytes.Buffer, typ Type, qf Qualifier, visited []Type) {
 			writeTParamList(buf, t.tparams, qf, visited)
 		}
 
-	case *TypeParam:
+	case *_TypeParam:
 		s := "?"
 		if t.obj != nil {
 			s = t.obj.name
@@ -321,7 +321,7 @@ func writeTParamList(buf *bytes.Buffer, list []*TypeName, qf Qualifier, visited
 	for i, p := range list {
 		// TODO(rFindley) support 'any' sugar here.
 		var b Type = &emptyInterface
-		if t, _ := p.typ.(*TypeParam); t != nil && t.bound != nil {
+		if t, _ := p.typ.(*_TypeParam); t != nil && t.bound != nil {
 			b = t.bound
 		}
 		if i > 0 {
@@ -334,7 +334,7 @@ func writeTParamList(buf *bytes.Buffer, list []*TypeName, qf Qualifier, visited
 		}
 		prev = b
 
-		if t, _ := p.typ.(*TypeParam); t != nil {
+		if t, _ := p.typ.(*_TypeParam); t != nil {
 			writeType(buf, t, qf, visited)
 		} else {
 			buf.WriteString(p.name)
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index 53c87f20d5..8f30a67a2f 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -146,7 +146,7 @@ func (check *Checker) ordinaryType(pos positioner, typ Type) {
 				check.softErrorf(pos, _Todo, "interface contains type constraints (%s)", t.allTypes)
 				return
 			}
-			if t.IsComparable() {
+			if t._IsComparable() {
 				check.softErrorf(pos, _Todo, "interface is (or embeds) comparable")
 			}
 		}
@@ -301,7 +301,7 @@ func (check *Checker) funcType(sig *Signature, recvPar *ast.FieldList, ftyp *ast
 				}
 				smap := makeSubstMap(recvTParams, list)
 				for i, tname := range sig.rparams {
-					bound := recvTParams[i].typ.(*TypeParam).bound
+					bound := recvTParams[i].typ.(*_TypeParam).bound
 					// bound is (possibly) parameterized in the context of the
 					// receiver type declaration. Substitute parameters for the
 					// current context.
@@ -309,7 +309,7 @@ func (check *Checker) funcType(sig *Signature, recvPar *ast.FieldList, ftyp *ast
 					//           (no bound == empty interface)
 					if bound != nil {
 						bound = check.subst(tname.pos, bound, smap)
-						tname.typ.(*TypeParam).bound = bound
+						tname.typ.(*_TypeParam).bound = bound
 					}
 				}
 			}
@@ -333,7 +333,7 @@ func (check *Checker) funcType(sig *Signature, recvPar *ast.FieldList, ftyp *ast
 	recvList, _ := check.collectParams(scope, recvPar, recvTyp, false) // use rewritten receiver type, if any
 	params, variadic := check.collectParams(scope, ftyp.Params, nil, true)
 	results, _ := check.collectParams(scope, ftyp.Results, nil, false)
-	scope.Squash(func(obj, alt Object) {
+	scope.squash(func(obj, alt Object) {
 		check.errorf(obj, _DuplicateDecl, "%s redeclared in this block", obj.Name())
 		check.reportAltDecl(alt)
 	})
@@ -823,7 +823,7 @@ func (check *Checker) interfaceType(ityp *Interface, iface *ast.InterfaceType, d
 	}
 
 	// type constraints
-	ityp.types = NewSum(check.collectTypeConstraints(iface.Pos(), types))
+	ityp.types = _NewSum(check.collectTypeConstraints(iface.Pos(), types))
 
 	if len(ityp.methods) == 0 && ityp.types == nil && len(ityp.embeddeds) == 0 {
 		// empty interface
@@ -928,7 +928,7 @@ func (check *Checker) completeInterface(pos token.Pos, ityp *Interface) {
 		if etyp == nil {
 			if utyp != Typ[Invalid] {
 				var format string
-				if _, ok := utyp.(*TypeParam); ok {
+				if _, ok := utyp.(*_TypeParam); ok {
 					format = "%s is a type parameter, not an interface"
 				} else {
 					format = "%s is not an interface"
@@ -987,7 +987,7 @@ func intersect(x, y Type) (r Type) {
 	if rtypes == nil {
 		return theBottom
 	}
-	return NewSum(rtypes)
+	return _NewSum(rtypes)
 }
 
 func sortTypes(list []Type) {
diff --git a/src/go/types/unify.go b/src/go/types/unify.go
index ab18febbdf..fbcd64c442 100644
--- a/src/go/types/unify.go
+++ b/src/go/types/unify.go
@@ -83,7 +83,7 @@ func (d *tparamsList) init(tparams []*TypeName) {
 	}
 	if debug {
 		for i, tpar := range tparams {
-			assert(i == tpar.typ.(*TypeParam).index)
+			assert(i == tpar.typ.(*_TypeParam).index)
 		}
 	}
 	d.tparams = tparams
@@ -131,7 +131,7 @@ func (u *unifier) join(i, j int) bool {
 // If typ is a type parameter of d, index returns the type parameter index.
 // Otherwise, the result is < 0.
 func (d *tparamsList) index(typ Type) int {
-	if t, ok := typ.(*TypeParam); ok {
+	if t, ok := typ.(*_TypeParam); ok {
 		if i := t.index; i < len(d.tparams) && d.tparams[i].typ == t {
 			return i
 		}
@@ -335,7 +335,7 @@ func (u *unifier) nify(x, y Type, p *ifacePair) bool {
 				u.nify(x.results, y.results, p)
 		}
 
-	case *Sum:
+	case *_Sum:
 		// This should not happen with the current internal use of sum types.
 		panic("type inference across sum types not implemented")
 
@@ -431,7 +431,7 @@ func (u *unifier) nify(x, y Type, p *ifacePair) bool {
 			}
 		}
 
-	case *TypeParam:
+	case *_TypeParam:
 		// Two type parameters (which are not part of the type parameters of the
 		// enclosing type as those are handled in the beginning of this function)
 		// are identical if they originate in the same declaration.
-- 
GitLab


From 580636a78a8e2462f4c5cbbac04c6403c81401ff Mon Sep 17 00:00:00 2001
From: John Bampton <jbampton@gmail.com>
Date: Mon, 1 Mar 2021 09:47:09 +0000
Subject: [PATCH 0883/2400] all: fix spelling

Change-Id: Iad14571c3e19b01740cd744f0b3025b3e2f1cb72
GitHub-Last-Rev: e8064019299f4e593116060ce2bbd14d62830af7
GitHub-Pull-Request: golang/go#44685
Reviewed-on: https://go-review.googlesource.com/c/go/+/297409
Trust: Alberto Donizetti <alb.donizetti@gmail.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/cmd/compile/internal/ir/visit.go       | 8 ++++----
 src/cmd/compile/internal/types2/call.go    | 4 ++--
 src/cmd/compile/internal/types2/typexpr.go | 4 ++--
 src/go/types/call.go                       | 4 ++--
 src/go/types/examples/types.go2            | 2 +-
 src/go/types/typexpr.go                    | 4 ++--
 src/reflect/abi.go                         | 2 +-
 src/syscall/exec_windows_test.go           | 2 +-
 test/run.go                                | 2 +-
 9 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/cmd/compile/internal/ir/visit.go b/src/cmd/compile/internal/ir/visit.go
index c1b3d4ed95..e4aeae3522 100644
--- a/src/cmd/compile/internal/ir/visit.go
+++ b/src/cmd/compile/internal/ir/visit.go
@@ -25,10 +25,10 @@ package ir
 //
 //	var do func(ir.Node) bool
 //	do = func(x ir.Node) bool {
-//		... processing BEFORE visting children ...
+//		... processing BEFORE visiting children ...
 //		if ... should visit children ... {
 //			ir.DoChildren(x, do)
-//			... processing AFTER visting children ...
+//			... processing AFTER visiting children ...
 //		}
 //		if ... should stop parent DoChildren call from visiting siblings ... {
 //			return true
@@ -43,11 +43,11 @@ package ir
 //
 //	var do func(ir.Node) bool
 //	do = func(x ir.Node) bool {
-//		... processing BEFORE visting children ...
+//		... processing BEFORE visiting children ...
 //		if ... should visit children ... {
 //			ir.DoChildren(x, do)
 //		}
-//		... processing AFTER visting children ...
+//		... processing AFTER visiting children ...
 //		return false
 //	}
 //	do(root)
diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index 72805c453b..3f40a99b07 100644
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -71,7 +71,7 @@ func (check *Checker) funcInst(x *operand, inst *syntax.IndexExpr) {
 			x.expr = inst
 			return
 		}
-		// all type arguments were inferred sucessfully
+		// all type arguments were inferred successfully
 		if debug {
 			for _, targ := range targs {
 				assert(targ != nil)
@@ -402,7 +402,7 @@ func (check *Checker) arguments(call *syntax.CallExpr, sig *Signature, args []*o
 				return
 			}
 		}
-		// all type arguments were inferred sucessfully
+		// all type arguments were inferred successfully
 		if debug {
 			for _, targ := range targs {
 				assert(targ != nil)
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 7190cb446a..02f9b2804d 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -426,7 +426,7 @@ func (check *Checker) funcType(sig *Signature, recvPar *syntax.Field, tparams []
 }
 
 // goTypeName returns the Go type name for typ and
-// removes any occurences of "types." from that name.
+// removes any occurrences of "types." from that name.
 func goTypeName(typ Type) string {
 	return strings.Replace(fmt.Sprintf("%T", typ), "types.", "", -1) // strings.ReplaceAll is not available in Go 1.4
 }
@@ -710,7 +710,7 @@ func (check *Checker) arrayLength(e syntax.Expr) int64 {
 }
 
 // typeList provides the list of types corresponding to the incoming expression list.
-// If an error occured, the result is nil, but all list elements were type-checked.
+// If an error occurred, the result is nil, but all list elements were type-checked.
 func (check *Checker) typeList(list []syntax.Expr) []Type {
 	res := make([]Type, len(list)) // res != nil even if len(list) == 0
 	for i, x := range list {
diff --git a/src/go/types/call.go b/src/go/types/call.go
index bd10f6fbc3..f23ca02e1d 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -73,7 +73,7 @@ func (check *Checker) funcInst(x *operand, inst *ast.IndexExpr) {
 			x.expr = inst
 			return
 		}
-		// all type arguments were inferred sucessfully
+		// all type arguments were inferred successfully
 		if debug {
 			for _, targ := range targs {
 				assert(targ != nil)
@@ -404,7 +404,7 @@ func (check *Checker) arguments(call *ast.CallExpr, sig *Signature, args []*oper
 				return
 			}
 		}
-		// all type arguments were inferred sucessfully
+		// all type arguments were inferred successfully
 		if debug {
 			for _, targ := range targs {
 				assert(targ != nil)
diff --git a/src/go/types/examples/types.go2 b/src/go/types/examples/types.go2
index 20abefbe05..59c8804ad2 100644
--- a/src/go/types/examples/types.go2
+++ b/src/go/types/examples/types.go2
@@ -146,7 +146,7 @@ func _() {
 
 // We accept parenthesized embedded struct fields so we can distinguish between
 // a named field with a parenthesized type foo (T) and an embedded parameterized
-// type (foo(T)), similarly to interace embedding.
+// type (foo(T)), similarly to interface embedding.
 // They still need to be valid embedded types after the parentheses are stripped
 // (i.e., in contrast to interfaces, we cannot embed a struct literal). The name
 // of the embedded field is derived as before, after stripping parentheses.
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index 8f30a67a2f..63e37de4b7 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -398,7 +398,7 @@ func (check *Checker) funcType(sig *Signature, recvPar *ast.FieldList, ftyp *ast
 }
 
 // goTypeName returns the Go type name for typ and
-// removes any occurences of "types." from that name.
+// removes any occurrences of "types." from that name.
 func goTypeName(typ Type) string {
 	return strings.ReplaceAll(fmt.Sprintf("%T", typ), "types.", "")
 }
@@ -674,7 +674,7 @@ func (check *Checker) arrayLength(e ast.Expr) int64 {
 }
 
 // typeList provides the list of types corresponding to the incoming expression list.
-// If an error occured, the result is nil, but all list elements were type-checked.
+// If an error occurred, the result is nil, but all list elements were type-checked.
 func (check *Checker) typeList(list []ast.Expr) []Type {
 	res := make([]Type, len(list)) // res != nil even if len(list) == 0
 	for i, x := range list {
diff --git a/src/reflect/abi.go b/src/reflect/abi.go
index 20f41d96b5..36d6b3095b 100644
--- a/src/reflect/abi.go
+++ b/src/reflect/abi.go
@@ -378,7 +378,7 @@ func newAbiDesc(t *funcType, rcvr *rtype) abiDesc {
 	// Stack-assigned return values do not share
 	// space with arguments like they do with registers,
 	// so we need to inject a stack offset here.
-	// Fake it by artifically extending stackBytes by
+	// Fake it by artificially extending stackBytes by
 	// the return offset.
 	out.stackBytes = retOffset
 	for i, res := range t.out() {
diff --git a/src/syscall/exec_windows_test.go b/src/syscall/exec_windows_test.go
index 8a1c2ceaae..fb2c767c35 100644
--- a/src/syscall/exec_windows_test.go
+++ b/src/syscall/exec_windows_test.go
@@ -108,7 +108,7 @@ func TestChangingProcessParent(t *testing.T) {
 	}
 	childOutput, err = ioutil.ReadFile(childDumpPath)
 	if err != nil {
-		t.Fatalf("reading child ouput failed: %v", err)
+		t.Fatalf("reading child output failed: %v", err)
 	}
 	if got, want := string(childOutput), fmt.Sprintf("%d", parent.Process.Pid); got != want {
 		t.Fatalf("child output: want %q, got %q", want, got)
diff --git a/test/run.go b/test/run.go
index 657632643e..570768e680 100644
--- a/test/run.go
+++ b/test/run.go
@@ -757,7 +757,7 @@ func (t *test) run() {
 		// up and running against the existing test cases. The explicitly
 		// listed files don't pass yet, usually because the error messages
 		// are slightly different (this list is not complete). Any errorcheck
-		// tests that require output from analysis phases past intial type-
+		// tests that require output from analysis phases past initial type-
 		// checking are also excluded since these phases are not running yet.
 		// We can get rid of this code once types2 is fully plugged in.
 
-- 
GitLab


From 4c1a7ab49c4c68907bc7f7f7f776edd9116584a5 Mon Sep 17 00:00:00 2001
From: Baokun Lee <bk@golangcn.org>
Date: Mon, 18 Jan 2021 14:41:20 +0800
Subject: [PATCH 0884/2400] cmd/go: reject relative paths in GOMODCACHE
 environment

Go already rejects relative paths in a couple environment variables,
It should reject relative paths in GOMODCACHE.

Fixes #43715

Change-Id: Id1ceff839c7ab21c00cf4ace45ce48324733a526
Reviewed-on: https://go-review.googlesource.com/c/go/+/284432
Run-TryBot: Baokun Lee <bk@golangcn.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Trust: Jay Conrod <jayconrod@google.com>
Trust: Baokun Lee <bk@golangcn.org>
---
 src/cmd/go/internal/envcmd/env.go            |  2 +-
 src/cmd/go/internal/modfetch/cache.go        | 31 ++++++++++++--------
 src/cmd/go/internal/modfetch/fetch.go        |  6 ++--
 src/cmd/go/testdata/script/env_write.txt     |  6 ++++
 src/cmd/go/testdata/script/mod_cache_dir.txt | 11 +++++++
 5 files changed, 39 insertions(+), 17 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/mod_cache_dir.txt

diff --git a/src/cmd/go/internal/envcmd/env.go b/src/cmd/go/internal/envcmd/env.go
index 6937187522..aad5d704e5 100644
--- a/src/cmd/go/internal/envcmd/env.go
+++ b/src/cmd/go/internal/envcmd/env.go
@@ -428,7 +428,7 @@ func checkEnvWrite(key, val string) error {
 			return fmt.Errorf("GOPATH entry is relative; must be absolute path: %q", val)
 		}
 	// Make sure CC and CXX are absolute paths
-	case "CC", "CXX":
+	case "CC", "CXX", "GOMODCACHE":
 		if !filepath.IsAbs(val) && val != "" && val != filepath.Base(val) {
 			return fmt.Errorf("%s entry is relative; must be absolute path: %q", key, val)
 		}
diff --git a/src/cmd/go/internal/modfetch/cache.go b/src/cmd/go/internal/modfetch/cache.go
index 3a2ff63721..9e751931a0 100644
--- a/src/cmd/go/internal/modfetch/cache.go
+++ b/src/cmd/go/internal/modfetch/cache.go
@@ -28,10 +28,8 @@ import (
 )
 
 func cacheDir(path string) (string, error) {
-	if cfg.GOMODCACHE == "" {
-		// modload.Init exits if GOPATH[0] is empty, and cfg.GOMODCACHE
-		// is set to GOPATH[0]/pkg/mod if GOMODCACHE is empty, so this should never happen.
-		return "", fmt.Errorf("internal error: cfg.GOMODCACHE not set")
+	if err := checkCacheDir(); err != nil {
+		return "", err
 	}
 	enc, err := module.EscapePath(path)
 	if err != nil {
@@ -64,10 +62,8 @@ func CachePath(m module.Version, suffix string) (string, error) {
 // along with the directory if the directory does not exist or if the directory
 // is not completely populated.
 func DownloadDir(m module.Version) (string, error) {
-	if cfg.GOMODCACHE == "" {
-		// modload.Init exits if GOPATH[0] is empty, and cfg.GOMODCACHE
-		// is set to GOPATH[0]/pkg/mod if GOMODCACHE is empty, so this should never happen.
-		return "", fmt.Errorf("internal error: cfg.GOMODCACHE not set")
+	if err := checkCacheDir(); err != nil {
+		return "", err
 	}
 	enc, err := module.EscapePath(m.Path)
 	if err != nil {
@@ -134,10 +130,8 @@ func lockVersion(mod module.Version) (unlock func(), err error) {
 // user's working directory.
 // If err is nil, the caller MUST eventually call the unlock function.
 func SideLock() (unlock func(), err error) {
-	if cfg.GOMODCACHE == "" {
-		// modload.Init exits if GOPATH[0] is empty, and cfg.GOMODCACHE
-		// is set to GOPATH[0]/pkg/mod if GOMODCACHE is empty, so this should never happen.
-		base.Fatalf("go: internal error: cfg.GOMODCACHE not set")
+	if err := checkCacheDir(); err != nil {
+		base.Fatalf("go: %v", err)
 	}
 
 	path := filepath.Join(cfg.GOMODCACHE, "cache", "lock")
@@ -633,3 +627,16 @@ func rewriteVersionList(dir string) {
 		base.Fatalf("go: failed to write version list: %v", err)
 	}
 }
+
+func checkCacheDir() error {
+	if cfg.GOMODCACHE == "" {
+		// modload.Init exits if GOPATH[0] is empty, and cfg.GOMODCACHE
+		// is set to GOPATH[0]/pkg/mod if GOMODCACHE is empty, so this should never happen.
+		return fmt.Errorf("internal error: cfg.GOMODCACHE not set")
+	}
+
+	if !filepath.IsAbs(cfg.GOMODCACHE) {
+		return fmt.Errorf("GOMODCACHE entry is relative; must be absolute path: %q.\n", cfg.GOMODCACHE)
+	}
+	return nil
+}
diff --git a/src/cmd/go/internal/modfetch/fetch.go b/src/cmd/go/internal/modfetch/fetch.go
index c55c3cf253..d5ad277dd0 100644
--- a/src/cmd/go/internal/modfetch/fetch.go
+++ b/src/cmd/go/internal/modfetch/fetch.go
@@ -37,10 +37,8 @@ var downloadCache par.Cache
 // local download cache and returns the name of the directory
 // corresponding to the root of the module's file tree.
 func Download(ctx context.Context, mod module.Version) (dir string, err error) {
-	if cfg.GOMODCACHE == "" {
-		// modload.Init exits if GOPATH[0] is empty, and cfg.GOMODCACHE
-		// is set to GOPATH[0]/pkg/mod if GOMODCACHE is empty, so this should never happen.
-		base.Fatalf("go: internal error: cfg.GOMODCACHE not set")
+	if err := checkCacheDir(); err != nil {
+		base.Fatalf("go: %v", err)
 	}
 
 	// The par.Cache here avoids duplicate work.
diff --git a/src/cmd/go/testdata/script/env_write.txt b/src/cmd/go/testdata/script/env_write.txt
index bda1e57826..4fa39df104 100644
--- a/src/cmd/go/testdata/script/env_write.txt
+++ b/src/cmd/go/testdata/script/env_write.txt
@@ -173,3 +173,9 @@ go env -w GOOS=linux GOARCH=mips
 env GOOS=windows
 ! go env -u GOOS
 stderr 'unsupported GOOS/GOARCH.*windows/mips$'
+
+# go env -w should reject relative paths in GOMODCACHE environment.
+! go env -w GOMODCACHE=~/test
+stderr 'go env -w: GOMODCACHE entry is relative; must be absolute path: "~/test"'
+! go env -w GOMODCACHE=./test
+stderr 'go env -w: GOMODCACHE entry is relative; must be absolute path: "./test"'
diff --git a/src/cmd/go/testdata/script/mod_cache_dir.txt b/src/cmd/go/testdata/script/mod_cache_dir.txt
new file mode 100644
index 0000000000..7284ccf8ba
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_cache_dir.txt
@@ -0,0 +1,11 @@
+env GO111MODULE=on
+
+# Go should reject relative paths in GOMODCACHE environment.
+
+env GOMODCACHE="~/test"
+! go get example.com/tools/cmd/hello
+stderr 'must be absolute path'
+
+env GOMODCACHE="./test"
+! go get example.com/tools/cmd/hello
+stderr 'must be absolute path'
-- 
GitLab


From ebb92dfed96fadb3c563ff11cead85bbb7536793 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Mon, 1 Mar 2021 19:55:22 +0100
Subject: [PATCH 0885/2400] internal/poll, runtime: handle netpollopen error in
 poll_runtime_pollOpen

When netpollopen in poll_runtime_pollOpen returns an error, the work in
runtime_pollUnblock and runtime_pollClose can be avoided since the
underlying system call to set up the poller failed.

E.g. on linux, this avoids calling netpollclose and thus epoll_ctl(fd,
EPOLL_CTL_DEL, ...) in case the file does not support epoll, i.e.
epoll_ctl(fd, EPOLL_CTL_ADD, ...) in netpollopen failed.

Fixes #44552

Change-Id: I564d90340fd1ab3a6490526353616a447ae0cfb8
Reviewed-on: https://go-review.googlesource.com/c/go/+/297392
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/internal/poll/fd_poll_runtime.go | 4 ----
 src/runtime/netpoll.go               | 9 ++++++---
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/internal/poll/fd_poll_runtime.go b/src/internal/poll/fd_poll_runtime.go
index beb0f7d6a6..b072af00ea 100644
--- a/src/internal/poll/fd_poll_runtime.go
+++ b/src/internal/poll/fd_poll_runtime.go
@@ -39,10 +39,6 @@ func (pd *pollDesc) init(fd *FD) error {
 	serverInit.Do(runtime_pollServerInit)
 	ctx, errno := runtime_pollOpen(uintptr(fd.Sysfd))
 	if errno != 0 {
-		if ctx != 0 {
-			runtime_pollUnblock(ctx)
-			runtime_pollClose(ctx)
-		}
 		return errnoErr(syscall.Errno(errno))
 	}
 	pd.runtimeCtx = ctx
diff --git a/src/runtime/netpoll.go b/src/runtime/netpoll.go
index afb208a455..202aef593f 100644
--- a/src/runtime/netpoll.go
+++ b/src/runtime/netpoll.go
@@ -162,9 +162,12 @@ func poll_runtime_pollOpen(fd uintptr) (*pollDesc, int) {
 	pd.self = pd
 	unlock(&pd.lock)
 
-	var errno int32
-	errno = netpollopen(fd, pd)
-	return pd, int(errno)
+	errno := netpollopen(fd, pd)
+	if errno != 0 {
+		pollcache.free(pd)
+		return nil, int(errno)
+	}
+	return pd, 0
 }
 
 //go:linkname poll_runtime_pollClose internal/poll.runtime_pollClose
-- 
GitLab


From 2b50ab2aee75d3c361fcd1eb39e830e2e73056b6 Mon Sep 17 00:00:00 2001
From: fanzha02 <fannie.zhang@arm.com>
Date: Mon, 7 Dec 2020 19:15:15 +0800
Subject: [PATCH 0886/2400] cmd/compile: optimize single-precision floating
 point square root

Add generic rule to rewrite the single-precision square root expression
with one single-precision instruction. The optimization will reduce two
times of precision converting between double-precision and single-precision.

On arm64 flatform.

previous:
  FCVTSD F0, F0
  FSQRTD F0, F0
  FCVTDS F0, F0

optimized:
  FSQRTS S0, S0

And this patch adds the test case to check the correctness.

This patch refers to CL 241877, contributed by Alice Xu
(dianhong.xu@arm.com)

Change-Id: I6de5d02281c693017ac4bd4c10963dd55989bd7e
Reviewed-on: https://go-review.googlesource.com/c/go/+/276873
Trust: fannie zhang <Fannie.Zhang@arm.com>
Run-TryBot: fannie zhang <Fannie.Zhang@arm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/amd64/ssa.go         |   4 +-
 src/cmd/compile/internal/arm/ssa.go           |   1 +
 src/cmd/compile/internal/arm64/ssa.go         |   1 +
 src/cmd/compile/internal/mips/ssa.go          |   1 +
 src/cmd/compile/internal/mips64/ssa.go        |   1 +
 src/cmd/compile/internal/s390x/ssa.go         |   2 +-
 src/cmd/compile/internal/ssa/gen/386.rules    |   1 +
 src/cmd/compile/internal/ssa/gen/386Ops.go    |   1 +
 src/cmd/compile/internal/ssa/gen/AMD64.rules  |   1 +
 src/cmd/compile/internal/ssa/gen/AMD64Ops.go  |   1 +
 src/cmd/compile/internal/ssa/gen/ARM.rules    |   1 +
 src/cmd/compile/internal/ssa/gen/ARM64.rules  |   2 +
 src/cmd/compile/internal/ssa/gen/ARM64Ops.go  |   1 +
 src/cmd/compile/internal/ssa/gen/ARMOps.go    |   1 +
 src/cmd/compile/internal/ssa/gen/MIPS.rules   |   1 +
 src/cmd/compile/internal/ssa/gen/MIPS64.rules |   1 +
 src/cmd/compile/internal/ssa/gen/MIPS64Ops.go |   1 +
 src/cmd/compile/internal/ssa/gen/MIPSOps.go   |   1 +
 src/cmd/compile/internal/ssa/gen/PPC64.rules  |   1 +
 .../compile/internal/ssa/gen/RISCV64.rules    |   1 +
 src/cmd/compile/internal/ssa/gen/S390X.rules  |   2 +
 src/cmd/compile/internal/ssa/gen/S390XOps.go  |   1 +
 src/cmd/compile/internal/ssa/gen/Wasm.rules   |   2 +
 src/cmd/compile/internal/ssa/gen/WasmOps.go   |  14 +-
 .../compile/internal/ssa/gen/generic.rules    |   3 +
 .../compile/internal/ssa/gen/genericOps.go    |   5 +-
 src/cmd/compile/internal/ssa/opGen.go         | 134 ++++++++++++++++--
 src/cmd/compile/internal/ssa/rewrite386.go    |   3 +
 src/cmd/compile/internal/ssa/rewriteAMD64.go  |   3 +
 src/cmd/compile/internal/ssa/rewriteARM.go    |   3 +
 src/cmd/compile/internal/ssa/rewriteARM64.go  |   3 +
 src/cmd/compile/internal/ssa/rewriteMIPS.go   |   3 +
 src/cmd/compile/internal/ssa/rewriteMIPS64.go |   3 +
 src/cmd/compile/internal/ssa/rewritePPC64.go  |   3 +
 .../compile/internal/ssa/rewriteRISCV64.go    |   3 +
 src/cmd/compile/internal/ssa/rewriteS390X.go  |   3 +
 src/cmd/compile/internal/ssa/rewriteWasm.go   |   3 +
 .../compile/internal/ssa/rewritegeneric.go    |  20 +++
 src/cmd/compile/internal/x86/ssa.go           |   2 +-
 src/math/all_test.go                          |  34 +++++
 test/codegen/math.go                          |  11 ++
 41 files changed, 255 insertions(+), 28 deletions(-)

diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index 32cb0a9368..d83d78f080 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -1053,7 +1053,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg0()
 
-	case ssa.OpAMD64BSFQ, ssa.OpAMD64BSRQ, ssa.OpAMD64BSFL, ssa.OpAMD64BSRL, ssa.OpAMD64SQRTSD:
+	case ssa.OpAMD64BSFQ, ssa.OpAMD64BSRQ, ssa.OpAMD64BSFL, ssa.OpAMD64BSRL, ssa.OpAMD64SQRTSD, ssa.OpAMD64SQRTSS:
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = v.Args[0].Reg()
@@ -1061,7 +1061,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		switch v.Op {
 		case ssa.OpAMD64BSFQ, ssa.OpAMD64BSRQ:
 			p.To.Reg = v.Reg0()
-		case ssa.OpAMD64BSFL, ssa.OpAMD64BSRL, ssa.OpAMD64SQRTSD:
+		case ssa.OpAMD64BSFL, ssa.OpAMD64BSRL, ssa.OpAMD64SQRTSD, ssa.OpAMD64SQRTSS:
 			p.To.Reg = v.Reg()
 		}
 	case ssa.OpAMD64ROUNDSD:
diff --git a/src/cmd/compile/internal/arm/ssa.go b/src/cmd/compile/internal/arm/ssa.go
index c4d8cbf149..7b2fec3765 100644
--- a/src/cmd/compile/internal/arm/ssa.go
+++ b/src/cmd/compile/internal/arm/ssa.go
@@ -654,6 +654,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssa.OpARMREV,
 		ssa.OpARMREV16,
 		ssa.OpARMRBIT,
+		ssa.OpARMSQRTF,
 		ssa.OpARMSQRTD,
 		ssa.OpARMNEGF,
 		ssa.OpARMNEGD,
diff --git a/src/cmd/compile/internal/arm64/ssa.go b/src/cmd/compile/internal/arm64/ssa.go
index 5067d92dfe..056a6eb62d 100644
--- a/src/cmd/compile/internal/arm64/ssa.go
+++ b/src/cmd/compile/internal/arm64/ssa.go
@@ -893,6 +893,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssa.OpARM64FMOVSgpfp,
 		ssa.OpARM64FNEGS,
 		ssa.OpARM64FNEGD,
+		ssa.OpARM64FSQRTS,
 		ssa.OpARM64FSQRTD,
 		ssa.OpARM64FCVTZSSW,
 		ssa.OpARM64FCVTZSDW,
diff --git a/src/cmd/compile/internal/mips/ssa.go b/src/cmd/compile/internal/mips/ssa.go
index 115e3cb8e2..13736d12b4 100644
--- a/src/cmd/compile/internal/mips/ssa.go
+++ b/src/cmd/compile/internal/mips/ssa.go
@@ -363,6 +363,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssa.OpMIPSMOVDF,
 		ssa.OpMIPSNEGF,
 		ssa.OpMIPSNEGD,
+		ssa.OpMIPSSQRTF,
 		ssa.OpMIPSSQRTD,
 		ssa.OpMIPSCLZ:
 		p := s.Prog(v.Op.Asm())
diff --git a/src/cmd/compile/internal/mips64/ssa.go b/src/cmd/compile/internal/mips64/ssa.go
index d9c47751e1..c5a3ca305a 100644
--- a/src/cmd/compile/internal/mips64/ssa.go
+++ b/src/cmd/compile/internal/mips64/ssa.go
@@ -355,6 +355,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssa.OpMIPS64MOVDF,
 		ssa.OpMIPS64NEGF,
 		ssa.OpMIPS64NEGD,
+		ssa.OpMIPS64SQRTF,
 		ssa.OpMIPS64SQRTD:
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_REG
diff --git a/src/cmd/compile/internal/s390x/ssa.go b/src/cmd/compile/internal/s390x/ssa.go
index 4830d902c2..ca6720bb33 100644
--- a/src/cmd/compile/internal/s390x/ssa.go
+++ b/src/cmd/compile/internal/s390x/ssa.go
@@ -586,7 +586,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.Reg = v.Args[1].Reg()
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
-	case ssa.OpS390XFSQRT:
+	case ssa.OpS390XFSQRTS, ssa.OpS390XFSQRT:
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = v.Args[0].Reg()
diff --git a/src/cmd/compile/internal/ssa/gen/386.rules b/src/cmd/compile/internal/ssa/gen/386.rules
index df03cb71a6..d6d122dc78 100644
--- a/src/cmd/compile/internal/ssa/gen/386.rules
+++ b/src/cmd/compile/internal/ssa/gen/386.rules
@@ -54,6 +54,7 @@
 (Bswap32 ...) => (BSWAPL ...)
 
 (Sqrt ...) => (SQRTSD ...)
+(Sqrt32 ...) => (SQRTSS ...)
 
 (Ctz16 x) => (BSFL (ORLconst <typ.UInt32> [0x10000] x))
 (Ctz16NonZero ...) => (BSFL ...)
diff --git a/src/cmd/compile/internal/ssa/gen/386Ops.go b/src/cmd/compile/internal/ssa/gen/386Ops.go
index 2b7185e537..c4b49fbb23 100644
--- a/src/cmd/compile/internal/ssa/gen/386Ops.go
+++ b/src/cmd/compile/internal/ssa/gen/386Ops.go
@@ -308,6 +308,7 @@ func init() {
 		{name: "BSWAPL", argLength: 1, reg: gp11, asm: "BSWAPL", resultInArg0: true, clobberFlags: true}, // arg0 swap bytes
 
 		{name: "SQRTSD", argLength: 1, reg: fp11, asm: "SQRTSD"}, // sqrt(arg0)
+		{name: "SQRTSS", argLength: 1, reg: fp11, asm: "SQRTSS"}, // sqrt(arg0), float32
 
 		{name: "SBBLcarrymask", argLength: 1, reg: flagsgp, asm: "SBBL"}, // (int32)(-1) if carry is set, 0 if carry is clear.
 		// Note: SBBW and SBBB are subsumed by SBBL
diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules
index f2bcbd2dfc..bab9cee88c 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64.rules
+++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules
@@ -104,6 +104,7 @@
 (PopCount8 x) => (POPCNTL (MOVBQZX <typ.UInt32> x))
 
 (Sqrt ...) => (SQRTSD ...)
+(Sqrt32 ...) => (SQRTSS ...)
 
 (RoundToEven x) => (ROUNDSD [0] x)
 (Floor x)       => (ROUNDSD [1] x)
diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
index 96475672a8..fd2c2023e6 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
+++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
@@ -594,6 +594,7 @@ func init() {
 		{name: "POPCNTL", argLength: 1, reg: gp11, asm: "POPCNTL", clobberFlags: true}, // count number of set bits in arg0
 
 		{name: "SQRTSD", argLength: 1, reg: fp11, asm: "SQRTSD"}, // sqrt(arg0)
+		{name: "SQRTSS", argLength: 1, reg: fp11, asm: "SQRTSS"}, // sqrt(arg0), float32
 
 		// ROUNDSD instruction isn't guaranteed to be on the target platform (it is SSE4.1)
 		// Any use must be preceded by a successful check of runtime.x86HasSSE41.
diff --git a/src/cmd/compile/internal/ssa/gen/ARM.rules b/src/cmd/compile/internal/ssa/gen/ARM.rules
index cbafd12a4f..f46f4238f7 100644
--- a/src/cmd/compile/internal/ssa/gen/ARM.rules
+++ b/src/cmd/compile/internal/ssa/gen/ARM.rules
@@ -56,6 +56,7 @@
 (Com(32|16|8) ...) => (MVN ...)
 
 (Sqrt ...) => (SQRTD ...)
+(Sqrt32 ...) => (SQRTF ...)
 (Abs ...) => (ABSD ...)
 
 // TODO: optimize this for ARMv5 and ARMv6
diff --git a/src/cmd/compile/internal/ssa/gen/ARM64.rules b/src/cmd/compile/internal/ssa/gen/ARM64.rules
index 98503748db..ea912f9f97 100644
--- a/src/cmd/compile/internal/ssa/gen/ARM64.rules
+++ b/src/cmd/compile/internal/ssa/gen/ARM64.rules
@@ -60,6 +60,8 @@
 (Trunc ...) => (FRINTZD ...)
 (FMA x y z) => (FMADDD z x y)
 
+(Sqrt32 ...) => (FSQRTS ...)
+
 // lowering rotates
 (RotateLeft8 <t> x (MOVDconst [c])) => (Or8 (Lsh8x64 <t> x (MOVDconst [c&7])) (Rsh8Ux64 <t> x (MOVDconst [-c&7])))
 (RotateLeft16 <t> x (MOVDconst [c])) => (Or16 (Lsh16x64 <t> x (MOVDconst [c&15])) (Rsh16Ux64 <t> x (MOVDconst [-c&15])))
diff --git a/src/cmd/compile/internal/ssa/gen/ARM64Ops.go b/src/cmd/compile/internal/ssa/gen/ARM64Ops.go
index e826e75252..0a4fd14b2b 100644
--- a/src/cmd/compile/internal/ssa/gen/ARM64Ops.go
+++ b/src/cmd/compile/internal/ssa/gen/ARM64Ops.go
@@ -236,6 +236,7 @@ func init() {
 		{name: "FNEGS", argLength: 1, reg: fp11, asm: "FNEGS"},                                // -arg0, float32
 		{name: "FNEGD", argLength: 1, reg: fp11, asm: "FNEGD"},                                // -arg0, float64
 		{name: "FSQRTD", argLength: 1, reg: fp11, asm: "FSQRTD"},                              // sqrt(arg0), float64
+		{name: "FSQRTS", argLength: 1, reg: fp11, asm: "FSQRTS"},                              // sqrt(arg0), float32
 		{name: "REV", argLength: 1, reg: gp11, asm: "REV"},                                    // byte reverse, 64-bit
 		{name: "REVW", argLength: 1, reg: gp11, asm: "REVW"},                                  // byte reverse, 32-bit
 		{name: "REV16W", argLength: 1, reg: gp11, asm: "REV16W"},                              // byte reverse in each 16-bit halfword, 32-bit
diff --git a/src/cmd/compile/internal/ssa/gen/ARMOps.go b/src/cmd/compile/internal/ssa/gen/ARMOps.go
index 70c789937a..253ff573ec 100644
--- a/src/cmd/compile/internal/ssa/gen/ARMOps.go
+++ b/src/cmd/compile/internal/ssa/gen/ARMOps.go
@@ -217,6 +217,7 @@ func init() {
 		{name: "NEGF", argLength: 1, reg: fp11, asm: "NEGF"},   // -arg0, float32
 		{name: "NEGD", argLength: 1, reg: fp11, asm: "NEGD"},   // -arg0, float64
 		{name: "SQRTD", argLength: 1, reg: fp11, asm: "SQRTD"}, // sqrt(arg0), float64
+		{name: "SQRTF", argLength: 1, reg: fp11, asm: "SQRTF"}, // sqrt(arg0), float32
 		{name: "ABSD", argLength: 1, reg: fp11, asm: "ABSD"},   // abs(arg0), float64
 
 		{name: "CLZ", argLength: 1, reg: gp11, asm: "CLZ"},     // count leading zero
diff --git a/src/cmd/compile/internal/ssa/gen/MIPS.rules b/src/cmd/compile/internal/ssa/gen/MIPS.rules
index bc1ce82940..6b59555cbe 100644
--- a/src/cmd/compile/internal/ssa/gen/MIPS.rules
+++ b/src/cmd/compile/internal/ssa/gen/MIPS.rules
@@ -121,6 +121,7 @@
 (Com(32|16|8) x) => (NORconst [0] x)
 
 (Sqrt ...) => (SQRTD ...)
+(Sqrt32 ...) => (SQRTF ...)
 
 // TODO: optimize this case?
 (Ctz32NonZero ...) => (Ctz32 ...)
diff --git a/src/cmd/compile/internal/ssa/gen/MIPS64.rules b/src/cmd/compile/internal/ssa/gen/MIPS64.rules
index e3f7633274..bc51a0d53d 100644
--- a/src/cmd/compile/internal/ssa/gen/MIPS64.rules
+++ b/src/cmd/compile/internal/ssa/gen/MIPS64.rules
@@ -121,6 +121,7 @@
 (Com(64|32|16|8) x) => (NOR (MOVVconst [0]) x)
 
 (Sqrt ...) => (SQRTD ...)
+(Sqrt32 ...) => (SQRTF ...)
 
 // boolean ops -- booleans are represented with 0=false, 1=true
 (AndB ...) => (AND ...)
diff --git a/src/cmd/compile/internal/ssa/gen/MIPS64Ops.go b/src/cmd/compile/internal/ssa/gen/MIPS64Ops.go
index e1e3933502..77f251c0d3 100644
--- a/src/cmd/compile/internal/ssa/gen/MIPS64Ops.go
+++ b/src/cmd/compile/internal/ssa/gen/MIPS64Ops.go
@@ -199,6 +199,7 @@ func init() {
 		{name: "NEGF", argLength: 1, reg: fp11, asm: "NEGF"},   // -arg0, float32
 		{name: "NEGD", argLength: 1, reg: fp11, asm: "NEGD"},   // -arg0, float64
 		{name: "SQRTD", argLength: 1, reg: fp11, asm: "SQRTD"}, // sqrt(arg0), float64
+		{name: "SQRTF", argLength: 1, reg: fp11, asm: "SQRTF"}, // sqrt(arg0), float32
 
 		// shifts
 		{name: "SLLV", argLength: 2, reg: gp21, asm: "SLLV"},                    // arg0 << arg1, shift amount is mod 64
diff --git a/src/cmd/compile/internal/ssa/gen/MIPSOps.go b/src/cmd/compile/internal/ssa/gen/MIPSOps.go
index 75ab99ea26..b92e8cb9f1 100644
--- a/src/cmd/compile/internal/ssa/gen/MIPSOps.go
+++ b/src/cmd/compile/internal/ssa/gen/MIPSOps.go
@@ -182,6 +182,7 @@ func init() {
 		{name: "NEGF", argLength: 1, reg: fp11, asm: "NEGF"},   // -arg0, float32
 		{name: "NEGD", argLength: 1, reg: fp11, asm: "NEGD"},   // -arg0, float64
 		{name: "SQRTD", argLength: 1, reg: fp11, asm: "SQRTD"}, // sqrt(arg0), float64
+		{name: "SQRTF", argLength: 1, reg: fp11, asm: "SQRTF"}, // sqrt(arg0), float32
 
 		// shifts
 		{name: "SLL", argLength: 2, reg: gp21, asm: "SLL"},                    // arg0 << arg1, shift amount is mod 32
diff --git a/src/cmd/compile/internal/ssa/gen/PPC64.rules b/src/cmd/compile/internal/ssa/gen/PPC64.rules
index a762be65d4..85ce9a5b54 100644
--- a/src/cmd/compile/internal/ssa/gen/PPC64.rules
+++ b/src/cmd/compile/internal/ssa/gen/PPC64.rules
@@ -71,6 +71,7 @@
 (Round(32|64)F ...) => (LoweredRound(32|64)F ...)
 
 (Sqrt ...) => (FSQRT ...)
+(Sqrt32 ...) => (FSQRTS ...)
 (Floor ...) => (FFLOOR ...)
 (Ceil ...) => (FCEIL ...)
 (Trunc ...) => (FTRUNC ...)
diff --git a/src/cmd/compile/internal/ssa/gen/RISCV64.rules b/src/cmd/compile/internal/ssa/gen/RISCV64.rules
index 9119ebc0e8..a11d1e6624 100644
--- a/src/cmd/compile/internal/ssa/gen/RISCV64.rules
+++ b/src/cmd/compile/internal/ssa/gen/RISCV64.rules
@@ -92,6 +92,7 @@
 (Com8  ...) => (NOT ...)
 
 (Sqrt ...) => (FSQRTD ...)
+(Sqrt32 ...) => (FSQRTS ...)
 
 // Sign and zero extension.
 
diff --git a/src/cmd/compile/internal/ssa/gen/S390X.rules b/src/cmd/compile/internal/ssa/gen/S390X.rules
index 7111d5e11a..e4a1cd6981 100644
--- a/src/cmd/compile/internal/ssa/gen/S390X.rules
+++ b/src/cmd/compile/internal/ssa/gen/S390X.rules
@@ -142,6 +142,8 @@
 (Round       x) => (FIDBR [1] x)
 (FMA     x y z) => (FMADD z x y)
 
+(Sqrt32    ...) => (FSQRTS ...)
+
 // Atomic loads and stores.
 // The SYNC instruction (fast-BCR-serialization) prevents store-load
 // reordering. Other sequences of memory operations (load-load,
diff --git a/src/cmd/compile/internal/ssa/gen/S390XOps.go b/src/cmd/compile/internal/ssa/gen/S390XOps.go
index b24fd61942..1ddad1febd 100644
--- a/src/cmd/compile/internal/ssa/gen/S390XOps.go
+++ b/src/cmd/compile/internal/ssa/gen/S390XOps.go
@@ -382,6 +382,7 @@ func init() {
 		{name: "NOTW", argLength: 1, reg: gp11, resultInArg0: true, clobberFlags: true}, // ^arg0
 
 		{name: "FSQRT", argLength: 1, reg: fp11, asm: "FSQRT"}, // sqrt(arg0)
+		{name: "FSQRTS", argLength: 1, reg: fp11, asm: "FSQRTS"}, // sqrt(arg0), float32
 
 		// Conditional register-register moves.
 		// The aux for these values is an s390x.CCMask value representing the condition code mask.
diff --git a/src/cmd/compile/internal/ssa/gen/Wasm.rules b/src/cmd/compile/internal/ssa/gen/Wasm.rules
index fc45cd3ed5..7cda16b4b5 100644
--- a/src/cmd/compile/internal/ssa/gen/Wasm.rules
+++ b/src/cmd/compile/internal/ssa/gen/Wasm.rules
@@ -332,6 +332,8 @@
 (Abs ...) => (F64Abs ...)
 (Copysign ...) => (F64Copysign ...)
 
+(Sqrt32 ...) => (F32Sqrt ...)
+
 (Ctz64 ...) => (I64Ctz ...)
 (Ctz32 x) => (I64Ctz (I64Or x (I64Const [0x100000000])))
 (Ctz16 x) => (I64Ctz (I64Or x (I64Const [0x10000])))
diff --git a/src/cmd/compile/internal/ssa/gen/WasmOps.go b/src/cmd/compile/internal/ssa/gen/WasmOps.go
index 36c53bc78c..c92878ca73 100644
--- a/src/cmd/compile/internal/ssa/gen/WasmOps.go
+++ b/src/cmd/compile/internal/ssa/gen/WasmOps.go
@@ -238,13 +238,13 @@ func init() {
 		{name: "I64Extend16S", asm: "I64Extend16S", argLength: 1, reg: gp11, typ: "Int64"}, // sign-extend arg0 from 16 to 64 bit
 		{name: "I64Extend32S", asm: "I64Extend32S", argLength: 1, reg: gp11, typ: "Int64"}, // sign-extend arg0 from 32 to 64 bit
 
-		{name: "F32Sqrt", asm: "F32Sqrt", argLength: 1, reg: fp64_11, typ: "Float32"},         // sqrt(arg0)
-		{name: "F32Trunc", asm: "F32Trunc", argLength: 1, reg: fp64_11, typ: "Float32"},       // trunc(arg0)
-		{name: "F32Ceil", asm: "F32Ceil", argLength: 1, reg: fp64_11, typ: "Float32"},         // ceil(arg0)
-		{name: "F32Floor", asm: "F32Floor", argLength: 1, reg: fp64_11, typ: "Float32"},       // floor(arg0)
-		{name: "F32Nearest", asm: "F32Nearest", argLength: 1, reg: fp64_11, typ: "Float32"},   // round(arg0)
-		{name: "F32Abs", asm: "F32Abs", argLength: 1, reg: fp64_11, typ: "Float32"},           // abs(arg0)
-		{name: "F32Copysign", asm: "F32Copysign", argLength: 2, reg: fp64_21, typ: "Float32"}, // copysign(arg0, arg1)
+		{name: "F32Sqrt", asm: "F32Sqrt", argLength: 1, reg: fp32_11, typ: "Float32"},         // sqrt(arg0)
+		{name: "F32Trunc", asm: "F32Trunc", argLength: 1, reg: fp32_11, typ: "Float32"},       // trunc(arg0)
+		{name: "F32Ceil", asm: "F32Ceil", argLength: 1, reg: fp32_11, typ: "Float32"},         // ceil(arg0)
+		{name: "F32Floor", asm: "F32Floor", argLength: 1, reg: fp32_11, typ: "Float32"},       // floor(arg0)
+		{name: "F32Nearest", asm: "F32Nearest", argLength: 1, reg: fp32_11, typ: "Float32"},   // round(arg0)
+		{name: "F32Abs", asm: "F32Abs", argLength: 1, reg: fp32_11, typ: "Float32"},           // abs(arg0)
+		{name: "F32Copysign", asm: "F32Copysign", argLength: 2, reg: fp32_21, typ: "Float32"}, // copysign(arg0, arg1)
 
 		{name: "F64Sqrt", asm: "F64Sqrt", argLength: 1, reg: fp64_11, typ: "Float64"},         // sqrt(arg0)
 		{name: "F64Trunc", asm: "F64Trunc", argLength: 1, reg: fp64_11, typ: "Float64"},       // trunc(arg0)
diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules
index fab45243ed..9dd20a7cfa 100644
--- a/src/cmd/compile/internal/ssa/gen/generic.rules
+++ b/src/cmd/compile/internal/ssa/gen/generic.rules
@@ -1968,6 +1968,9 @@
 (Div32F x (Const32F <t> [c])) && reciprocalExact32(c) => (Mul32F x (Const32F <t> [1/c]))
 (Div64F x (Const64F <t> [c])) && reciprocalExact64(c) => (Mul64F x (Const64F <t> [1/c]))
 
+// rewrite single-precision sqrt expression "float32(math.Sqrt(float64(x)))"
+(Cvt64Fto32F sqrt0:(Sqrt (Cvt32Fto64F x))) && sqrt0.Uses==1 => (Sqrt32 x)
+
 (Sqrt (Const64F [c])) && !math.IsNaN(math.Sqrt(c)) => (Const64F [math.Sqrt(c)])
 
 // for rewriting results of some late-expanded rewrites (below)
diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go
index 043f445c16..b730c436cf 100644
--- a/src/cmd/compile/internal/ssa/gen/genericOps.go
+++ b/src/cmd/compile/internal/ssa/gen/genericOps.go
@@ -258,13 +258,14 @@ var genericOps = []opData{
 	{name: "RotateLeft32", argLength: 2}, // Rotate bits in arg[0] left by arg[1]
 	{name: "RotateLeft64", argLength: 2}, // Rotate bits in arg[0] left by arg[1]
 
-	// Square root, float64 only.
+	// Square root.
 	// Special cases:
 	//   +∞  → +∞
 	//   ±0  → ±0 (sign preserved)
 	//   x<0 → NaN
 	//   NaN → NaN
-	{name: "Sqrt", argLength: 1}, // √arg0
+	{name: "Sqrt", argLength: 1}, // √arg0   (floating point, double precision)
+	{name: "Sqrt32", argLength: 1}, // √arg0 (floating point, single precision)
 
 	// Round to integer, float64 only.
 	// Special cases:
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index 2d37ae4357..bd9741fe3e 100644
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -432,6 +432,7 @@ const (
 	Op386BSRW
 	Op386BSWAPL
 	Op386SQRTSD
+	Op386SQRTSS
 	Op386SBBLcarrymask
 	Op386SETEQ
 	Op386SETNE
@@ -888,6 +889,7 @@ const (
 	OpAMD64POPCNTQ
 	OpAMD64POPCNTL
 	OpAMD64SQRTSD
+	OpAMD64SQRTSS
 	OpAMD64ROUNDSD
 	OpAMD64VFMADD231SD
 	OpAMD64SBBQcarrymask
@@ -1090,6 +1092,7 @@ const (
 	OpARMNEGF
 	OpARMNEGD
 	OpARMSQRTD
+	OpARMSQRTF
 	OpARMABSD
 	OpARMCLZ
 	OpARMREV
@@ -1358,6 +1361,7 @@ const (
 	OpARM64FNEGS
 	OpARM64FNEGD
 	OpARM64FSQRTD
+	OpARM64FSQRTS
 	OpARM64REV
 	OpARM64REVW
 	OpARM64REV16W
@@ -1641,6 +1645,7 @@ const (
 	OpMIPSNEGF
 	OpMIPSNEGD
 	OpMIPSSQRTD
+	OpMIPSSQRTF
 	OpMIPSSLL
 	OpMIPSSLLconst
 	OpMIPSSRL
@@ -1751,6 +1756,7 @@ const (
 	OpMIPS64NEGF
 	OpMIPS64NEGD
 	OpMIPS64SQRTD
+	OpMIPS64SQRTF
 	OpMIPS64SLLV
 	OpMIPS64SLLVconst
 	OpMIPS64SRLV
@@ -2301,6 +2307,7 @@ const (
 	OpS390XNOT
 	OpS390XNOTW
 	OpS390XFSQRT
+	OpS390XFSQRTS
 	OpS390XLOCGR
 	OpS390XMOVBreg
 	OpS390XMOVBZreg
@@ -2727,6 +2734,7 @@ const (
 	OpRotateLeft32
 	OpRotateLeft64
 	OpSqrt
+	OpSqrt32
 	OpFloor
 	OpCeil
 	OpTrunc
@@ -4778,6 +4786,19 @@ var opcodeTable = [...]opInfo{
 			},
 		},
 	},
+	{
+		name:   "SQRTSS",
+		argLen: 1,
+		asm:    x86.ASQRTSS,
+		reg: regInfo{
+			inputs: []inputInfo{
+				{0, 65280}, // X0 X1 X2 X3 X4 X5 X6 X7
+			},
+			outputs: []outputInfo{
+				{0, 65280}, // X0 X1 X2 X3 X4 X5 X6 X7
+			},
+		},
+	},
 	{
 		name:   "SBBLcarrymask",
 		argLen: 1,
@@ -11630,6 +11651,19 @@ var opcodeTable = [...]opInfo{
 			},
 		},
 	},
+	{
+		name:   "SQRTSS",
+		argLen: 1,
+		asm:    x86.ASQRTSS,
+		reg: regInfo{
+			inputs: []inputInfo{
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+			},
+			outputs: []outputInfo{
+				{0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+			},
+		},
+	},
 	{
 		name:    "ROUNDSD",
 		auxType: auxInt8,
@@ -14424,6 +14458,19 @@ var opcodeTable = [...]opInfo{
 			},
 		},
 	},
+	{
+		name:   "SQRTF",
+		argLen: 1,
+		asm:    arm.ASQRTF,
+		reg: regInfo{
+			inputs: []inputInfo{
+				{0, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
+			},
+			outputs: []outputInfo{
+				{0, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
+			},
+		},
+	},
 	{
 		name:   "ABSD",
 		argLen: 1,
@@ -18086,6 +18133,19 @@ var opcodeTable = [...]opInfo{
 			},
 		},
 	},
+	{
+		name:   "FSQRTS",
+		argLen: 1,
+		asm:    arm64.AFSQRTS,
+		reg: regInfo{
+			inputs: []inputInfo{
+				{0, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
+			},
+			outputs: []outputInfo{
+				{0, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
+			},
+		},
+	},
 	{
 		name:   "REV",
 		argLen: 1,
@@ -21879,6 +21939,19 @@ var opcodeTable = [...]opInfo{
 			},
 		},
 	},
+	{
+		name:   "SQRTF",
+		argLen: 1,
+		asm:    mips.ASQRTF,
+		reg: regInfo{
+			inputs: []inputInfo{
+				{0, 35183835217920}, // F0 F2 F4 F6 F8 F10 F12 F14 F16 F18 F20 F22 F24 F26 F28 F30
+			},
+			outputs: []outputInfo{
+				{0, 35183835217920}, // F0 F2 F4 F6 F8 F10 F12 F14 F16 F18 F20 F22 F24 F26 F28 F30
+			},
+		},
+	},
 	{
 		name:   "SLL",
 		argLen: 2,
@@ -23358,6 +23431,19 @@ var opcodeTable = [...]opInfo{
 			},
 		},
 	},
+	{
+		name:   "SQRTF",
+		argLen: 1,
+		asm:    mips.ASQRTF,
+		reg: regInfo{
+			inputs: []inputInfo{
+				{0, 1152921504338411520}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
+			},
+			outputs: []outputInfo{
+				{0, 1152921504338411520}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
+			},
+		},
+	},
 	{
 		name:   "SLLV",
 		argLen: 2,
@@ -30942,6 +31028,19 @@ var opcodeTable = [...]opInfo{
 			},
 		},
 	},
+	{
+		name:   "FSQRTS",
+		argLen: 1,
+		asm:    s390x.AFSQRTS,
+		reg: regInfo{
+			inputs: []inputInfo{
+				{0, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
+			},
+			outputs: []outputInfo{
+				{0, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
+			},
+		},
+	},
 	{
 		name:         "LOCGR",
 		auxType:      auxS390XCCMask,
@@ -33876,10 +33975,10 @@ var opcodeTable = [...]opInfo{
 		asm:    wasm.AF32Sqrt,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 281470681743360}, // F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
+				{0, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
 			},
 			outputs: []outputInfo{
-				{0, 281470681743360}, // F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
+				{0, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
 			},
 		},
 	},
@@ -33889,10 +33988,10 @@ var opcodeTable = [...]opInfo{
 		asm:    wasm.AF32Trunc,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 281470681743360}, // F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
+				{0, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
 			},
 			outputs: []outputInfo{
-				{0, 281470681743360}, // F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
+				{0, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
 			},
 		},
 	},
@@ -33902,10 +34001,10 @@ var opcodeTable = [...]opInfo{
 		asm:    wasm.AF32Ceil,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 281470681743360}, // F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
+				{0, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
 			},
 			outputs: []outputInfo{
-				{0, 281470681743360}, // F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
+				{0, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
 			},
 		},
 	},
@@ -33915,10 +34014,10 @@ var opcodeTable = [...]opInfo{
 		asm:    wasm.AF32Floor,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 281470681743360}, // F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
+				{0, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
 			},
 			outputs: []outputInfo{
-				{0, 281470681743360}, // F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
+				{0, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
 			},
 		},
 	},
@@ -33928,10 +34027,10 @@ var opcodeTable = [...]opInfo{
 		asm:    wasm.AF32Nearest,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 281470681743360}, // F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
+				{0, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
 			},
 			outputs: []outputInfo{
-				{0, 281470681743360}, // F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
+				{0, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
 			},
 		},
 	},
@@ -33941,10 +34040,10 @@ var opcodeTable = [...]opInfo{
 		asm:    wasm.AF32Abs,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 281470681743360}, // F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
+				{0, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
 			},
 			outputs: []outputInfo{
-				{0, 281470681743360}, // F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
+				{0, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
 			},
 		},
 	},
@@ -33954,11 +34053,11 @@ var opcodeTable = [...]opInfo{
 		asm:    wasm.AF32Copysign,
 		reg: regInfo{
 			inputs: []inputInfo{
-				{0, 281470681743360}, // F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
-				{1, 281470681743360}, // F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
+				{0, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
+				{1, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
 			},
 			outputs: []outputInfo{
-				{0, 281470681743360}, // F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
+				{0, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
 			},
 		},
 	},
@@ -35176,6 +35275,11 @@ var opcodeTable = [...]opInfo{
 		argLen:  1,
 		generic: true,
 	},
+	{
+		name:    "Sqrt32",
+		argLen:  1,
+		generic: true,
+	},
 	{
 		name:    "Floor",
 		argLen:  1,
diff --git a/src/cmd/compile/internal/ssa/rewrite386.go b/src/cmd/compile/internal/ssa/rewrite386.go
index 4e7fdb9e63..726d68e243 100644
--- a/src/cmd/compile/internal/ssa/rewrite386.go
+++ b/src/cmd/compile/internal/ssa/rewrite386.go
@@ -620,6 +620,9 @@ func rewriteValue386(v *Value) bool {
 	case OpSqrt:
 		v.Op = Op386SQRTSD
 		return true
+	case OpSqrt32:
+		v.Op = Op386SQRTSS
+		return true
 	case OpStaticCall:
 		v.Op = Op386CALLstatic
 		return true
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index 599137c806..52d0fd095d 100644
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -1089,6 +1089,9 @@ func rewriteValueAMD64(v *Value) bool {
 	case OpSqrt:
 		v.Op = OpAMD64SQRTSD
 		return true
+	case OpSqrt32:
+		v.Op = OpAMD64SQRTSS
+		return true
 	case OpStaticCall:
 		v.Op = OpAMD64CALLstatic
 		return true
diff --git a/src/cmd/compile/internal/ssa/rewriteARM.go b/src/cmd/compile/internal/ssa/rewriteARM.go
index 1adbceb0ad..ed1f85e340 100644
--- a/src/cmd/compile/internal/ssa/rewriteARM.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM.go
@@ -823,6 +823,9 @@ func rewriteValueARM(v *Value) bool {
 	case OpSqrt:
 		v.Op = OpARMSQRTD
 		return true
+	case OpSqrt32:
+		v.Op = OpARMSQRTF
+		return true
 	case OpStaticCall:
 		v.Op = OpARMCALLstatic
 		return true
diff --git a/src/cmd/compile/internal/ssa/rewriteARM64.go b/src/cmd/compile/internal/ssa/rewriteARM64.go
index ece834f996..55bb486600 100644
--- a/src/cmd/compile/internal/ssa/rewriteARM64.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM64.go
@@ -999,6 +999,9 @@ func rewriteValueARM64(v *Value) bool {
 	case OpSqrt:
 		v.Op = OpARM64FSQRTD
 		return true
+	case OpSqrt32:
+		v.Op = OpARM64FSQRTS
+		return true
 	case OpStaticCall:
 		v.Op = OpARM64CALLstatic
 		return true
diff --git a/src/cmd/compile/internal/ssa/rewriteMIPS.go b/src/cmd/compile/internal/ssa/rewriteMIPS.go
index 0c074364df..fdf329cbd0 100644
--- a/src/cmd/compile/internal/ssa/rewriteMIPS.go
+++ b/src/cmd/compile/internal/ssa/rewriteMIPS.go
@@ -516,6 +516,9 @@ func rewriteValueMIPS(v *Value) bool {
 	case OpSqrt:
 		v.Op = OpMIPSSQRTD
 		return true
+	case OpSqrt32:
+		v.Op = OpMIPSSQRTF
+		return true
 	case OpStaticCall:
 		v.Op = OpMIPSCALLstatic
 		return true
diff --git a/src/cmd/compile/internal/ssa/rewriteMIPS64.go b/src/cmd/compile/internal/ssa/rewriteMIPS64.go
index 073cf8726c..541bdd694a 100644
--- a/src/cmd/compile/internal/ssa/rewriteMIPS64.go
+++ b/src/cmd/compile/internal/ssa/rewriteMIPS64.go
@@ -596,6 +596,9 @@ func rewriteValueMIPS64(v *Value) bool {
 	case OpSqrt:
 		v.Op = OpMIPS64SQRTD
 		return true
+	case OpSqrt32:
+		v.Op = OpMIPS64SQRTF
+		return true
 	case OpStaticCall:
 		v.Op = OpMIPS64CALLstatic
 		return true
diff --git a/src/cmd/compile/internal/ssa/rewritePPC64.go b/src/cmd/compile/internal/ssa/rewritePPC64.go
index 98f748e5fa..3357864291 100644
--- a/src/cmd/compile/internal/ssa/rewritePPC64.go
+++ b/src/cmd/compile/internal/ssa/rewritePPC64.go
@@ -743,6 +743,9 @@ func rewriteValuePPC64(v *Value) bool {
 	case OpSqrt:
 		v.Op = OpPPC64FSQRT
 		return true
+	case OpSqrt32:
+		v.Op = OpPPC64FSQRTS
+		return true
 	case OpStaticCall:
 		v.Op = OpPPC64CALLstatic
 		return true
diff --git a/src/cmd/compile/internal/ssa/rewriteRISCV64.go b/src/cmd/compile/internal/ssa/rewriteRISCV64.go
index bc47d76e87..36e152bd99 100644
--- a/src/cmd/compile/internal/ssa/rewriteRISCV64.go
+++ b/src/cmd/compile/internal/ssa/rewriteRISCV64.go
@@ -582,6 +582,9 @@ func rewriteValueRISCV64(v *Value) bool {
 	case OpSqrt:
 		v.Op = OpRISCV64FSQRTD
 		return true
+	case OpSqrt32:
+		v.Op = OpRISCV64FSQRTS
+		return true
 	case OpStaticCall:
 		v.Op = OpRISCV64CALLstatic
 		return true
diff --git a/src/cmd/compile/internal/ssa/rewriteS390X.go b/src/cmd/compile/internal/ssa/rewriteS390X.go
index 6adae3ff35..e0a5ff4cbb 100644
--- a/src/cmd/compile/internal/ssa/rewriteS390X.go
+++ b/src/cmd/compile/internal/ssa/rewriteS390X.go
@@ -792,6 +792,9 @@ func rewriteValueS390X(v *Value) bool {
 	case OpSqrt:
 		v.Op = OpS390XFSQRT
 		return true
+	case OpSqrt32:
+		v.Op = OpS390XFSQRTS
+		return true
 	case OpStaticCall:
 		v.Op = OpS390XCALLstatic
 		return true
diff --git a/src/cmd/compile/internal/ssa/rewriteWasm.go b/src/cmd/compile/internal/ssa/rewriteWasm.go
index c8ecefc736..7258bc4f8e 100644
--- a/src/cmd/compile/internal/ssa/rewriteWasm.go
+++ b/src/cmd/compile/internal/ssa/rewriteWasm.go
@@ -527,6 +527,9 @@ func rewriteValueWasm(v *Value) bool {
 	case OpSqrt:
 		v.Op = OpWasmF64Sqrt
 		return true
+	case OpSqrt32:
+		v.Op = OpWasmF32Sqrt
+		return true
 	case OpStaticCall:
 		v.Op = OpWasmLoweredStaticCall
 		return true
diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go
index e5a27199a7..7e7cf458ff 100644
--- a/src/cmd/compile/internal/ssa/rewritegeneric.go
+++ b/src/cmd/compile/internal/ssa/rewritegeneric.go
@@ -4085,6 +4085,26 @@ func rewriteValuegeneric_OpCvt64Fto32F(v *Value) bool {
 		v.AuxInt = float32ToAuxInt(float32(c))
 		return true
 	}
+	// match: (Cvt64Fto32F sqrt0:(Sqrt (Cvt32Fto64F x)))
+	// cond: sqrt0.Uses==1
+	// result: (Sqrt32 x)
+	for {
+		sqrt0 := v_0
+		if sqrt0.Op != OpSqrt {
+			break
+		}
+		sqrt0_0 := sqrt0.Args[0]
+		if sqrt0_0.Op != OpCvt32Fto64F {
+			break
+		}
+		x := sqrt0_0.Args[0]
+		if !(sqrt0.Uses == 1) {
+			break
+		}
+		v.reset(OpSqrt32)
+		v.AddArg(x)
+		return true
+	}
 	return false
 }
 func rewriteValuegeneric_OpCvt64Fto64(v *Value) bool {
diff --git a/src/cmd/compile/internal/x86/ssa.go b/src/cmd/compile/internal/x86/ssa.go
index 4d134c6926..62982f4c6d 100644
--- a/src/cmd/compile/internal/x86/ssa.go
+++ b/src/cmd/compile/internal/x86/ssa.go
@@ -760,7 +760,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Reg = v.Reg()
 	case ssa.Op386BSFL, ssa.Op386BSFW,
 		ssa.Op386BSRL, ssa.Op386BSRW,
-		ssa.Op386SQRTSD:
+		ssa.Op386SQRTSS, ssa.Op386SQRTSD:
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = v.Args[0].Reg()
diff --git a/src/math/all_test.go b/src/math/all_test.go
index 3aae0373c7..d154457999 100644
--- a/src/math/all_test.go
+++ b/src/math/all_test.go
@@ -2067,6 +2067,21 @@ var fmaC = []struct{ x, y, z, want float64 }{
 	{-7.751454006381804e-05, 5.588653777189071e-308, -2.2207280111272877e-308, -2.2211612130544025e-308},
 }
 
+var sqrt32 = []float32{
+	0,
+	float32(Copysign(0, -1)),
+	float32(NaN()),
+	float32(Inf(1)),
+	float32(Inf(-1)),
+	1,
+	2,
+	-2,
+	4.9790119248836735e+00,
+	7.7388724745781045e+00,
+	-2.7688005719200159e-01,
+	-5.0106036182710749e+00,
+}
+
 func tolerance(a, b, e float64) bool {
 	// Multiplying by e here can underflow denormal values to zero.
 	// Check a==b so that at least if a and b are small and identical
@@ -3181,6 +3196,25 @@ func TestFloatMinMax(t *testing.T) {
 	}
 }
 
+var indirectSqrt = Sqrt
+
+// TestFloat32Sqrt checks the correctness of the float32 square root optimization result.
+func TestFloat32Sqrt(t *testing.T) {
+	for _, v := range sqrt32 {
+		want := float32(indirectSqrt(float64(v)))
+		got := float32(Sqrt(float64(v)))
+		if IsNaN(float64(want)) {
+			if !IsNaN(float64(got)) {
+				t.Errorf("got=%#v want=NaN, v=%#v", got, v)
+			}
+			continue
+		}
+		if got != want {
+			t.Errorf("got=%#v want=%#v, v=%#v", got, want, v)
+		}
+	}
+}
+
 // Benchmarks
 
 // Global exported variables are used to store the
diff --git a/test/codegen/math.go b/test/codegen/math.go
index ac8071400e..243ddb0494 100644
--- a/test/codegen/math.go
+++ b/test/codegen/math.go
@@ -55,6 +55,17 @@ func sqrt(x float64) float64 {
 	return math.Sqrt(x)
 }
 
+func sqrt32(x float32) float32 {
+	// amd64:"SQRTSS"
+	// 386/sse2:"SQRTSS" 386/softfloat:-"SQRTS"
+	// arm64:"FSQRTS"
+	// arm/7:"SQRTF"
+	// mips/hardfloat:"SQRTF" mips/softfloat:-"SQRTF"
+	// mips64/hardfloat:"SQRTF" mips64/softfloat:-"SQRTF"
+	// wasm:"F32Sqrt"
+	return float32(math.Sqrt(float64(x)))
+}
+
 // Check that it's using integer registers
 func abs(x, y float64) {
 	// amd64:"BTRQ\t[$]63"
-- 
GitLab


From 97b32a6724ebc3a6029e06b6c4b3acb9c980b15a Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Mon, 1 Mar 2021 17:31:20 -0500
Subject: [PATCH 0887/2400] cmd/compile: better version of check frame offsets
 against abi

improved to run on more architectures.

this is in preparation for turning off calculation of frame offsets
in types.CalcSize.

Replaces https://go-review.googlesource.com/c/go/+/293392 .
Updates #44675.
For #40724.

Change-Id: I40ba496172447cf09b86bc646148859363c11ad9
Reviewed-on: https://go-review.googlesource.com/c/go/+/297637
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/abi/abiutils.go      | 54 ++++++++++++---
 src/cmd/compile/internal/gc/compile.go        |  3 +
 src/cmd/compile/internal/ssa/config.go        |  4 +-
 src/cmd/compile/internal/ssa/op.go            | 28 +++++---
 src/cmd/compile/internal/ssagen/ssa.go        | 67 ++++++++++++-------
 .../compile/internal/test/abiutils_test.go    |  2 +-
 .../compile/internal/test/abiutilsaux_test.go | 32 ---------
 7 files changed, 112 insertions(+), 78 deletions(-)

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index b43d95e976..a5c85a89fb 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -52,12 +52,12 @@ func (a *ABIParamResultInfo) OutRegistersUsed() int {
 	return a.outRegistersUsed
 }
 
-func (a *ABIParamResultInfo) InParam(i int) ABIParamAssignment {
-	return a.inparams[i]
+func (a *ABIParamResultInfo) InParam(i int) *ABIParamAssignment {
+	return &a.inparams[i]
 }
 
-func (a *ABIParamResultInfo) OutParam(i int) ABIParamAssignment {
-	return a.outparams[i]
+func (a *ABIParamResultInfo) OutParam(i int) *ABIParamAssignment {
+	return &a.outparams[i]
 }
 
 func (a *ABIParamResultInfo) SpillAreaOffset() int64 {
@@ -111,6 +111,18 @@ func (a *ABIParamAssignment) SpillOffset() int32 {
 	return a.offset
 }
 
+// FrameOffset returns the location that a value would spill to, if any exists.
+// For register-allocated inputs, that is their spill offset reserved for morestack
+// (might as well use it, it is there); for stack-allocated inputs and outputs,
+// that is their location on the stack.  For register-allocated outputs, there is
+// no defined spill area, so return -1.
+func (a *ABIParamAssignment) FrameOffset(i *ABIParamResultInfo) int64 {
+	if len(a.Registers) == 0 || a.offset == -1 {
+		return int64(a.offset)
+	}
+	return int64(a.offset) + i.SpillAreaOffset()
+}
+
 // RegAmounts holds a specified number of integer/float registers.
 type RegAmounts struct {
 	intRegs   int
@@ -121,14 +133,15 @@ type RegAmounts struct {
 // by the ABI rules for parameter passing and result returning.
 type ABIConfig struct {
 	// Do we need anything more than this?
+	offsetForLocals  int64 // e.g., obj.(*Link).FixedFrameSize() -- extra linkage information on some architectures.
 	regAmounts       RegAmounts
 	regsForTypeCache map[*types.Type]int
 }
 
 // NewABIConfig returns a new ABI configuration for an architecture with
 // iRegsCount integer/pointer registers and fRegsCount floating point registers.
-func NewABIConfig(iRegsCount, fRegsCount int) *ABIConfig {
-	return &ABIConfig{regAmounts: RegAmounts{iRegsCount, fRegsCount}, regsForTypeCache: make(map[*types.Type]int)}
+func NewABIConfig(iRegsCount, fRegsCount int, offsetForLocals int64) *ABIConfig {
+	return &ABIConfig{offsetForLocals: offsetForLocals, regAmounts: RegAmounts{iRegsCount, fRegsCount}, regsForTypeCache: make(map[*types.Type]int)}
 }
 
 // Copy returns a copy of an ABIConfig for use in a function's compilation so that access to the cache does not need to be protected with a mutex.
@@ -190,7 +203,8 @@ func (a *ABIParamResultInfo) preAllocateParams(hasRcvr bool, nIns, nOuts int) {
 func (config *ABIConfig) ABIAnalyzeTypes(rcvr *types.Type, ins, outs []*types.Type) *ABIParamResultInfo {
 	setup()
 	s := assignState{
-		rTotal: config.regAmounts,
+		stackOffset: config.offsetForLocals,
+		rTotal:      config.regAmounts,
 	}
 	result := &ABIParamResultInfo{config: config}
 	result.preAllocateParams(rcvr != nil, len(ins), len(outs))
@@ -230,7 +244,8 @@ func (config *ABIConfig) ABIAnalyzeTypes(rcvr *types.Type, ins, outs []*types.Ty
 func (config *ABIConfig) ABIAnalyze(t *types.Type) *ABIParamResultInfo {
 	setup()
 	s := assignState{
-		rTotal: config.regAmounts,
+		stackOffset: config.offsetForLocals,
+		rTotal:      config.regAmounts,
 	}
 	result := &ABIParamResultInfo{config: config}
 	ft := t.FuncType()
@@ -265,9 +280,32 @@ func (config *ABIConfig) ABIAnalyze(t *types.Type) *ABIParamResultInfo {
 	result.spillAreaSize = alignTo(s.spillOffset, types.RegSize)
 	result.outRegistersUsed = s.rUsed.intRegs + s.rUsed.floatRegs
 
+	// Fill in the frame offsets for receiver, inputs, results
+	k := 0
+	if t.NumRecvs() != 0 {
+		config.updateOffset(result, ft.Receiver.FieldSlice()[0], result.inparams[0], false)
+		k++
+	}
+	for i, f := range ft.Params.FieldSlice() {
+		config.updateOffset(result, f, result.inparams[k+i], false)
+	}
+	for i, f := range ft.Results.FieldSlice() {
+		config.updateOffset(result, f, result.outparams[i], true)
+	}
 	return result
 }
 
+func (config *ABIConfig) updateOffset(result *ABIParamResultInfo, f *types.Field, a ABIParamAssignment, isReturn bool) {
+	if !isReturn || len(a.Registers) == 0 {
+		// TODO in next CL, assign
+		if f.Offset+config.offsetForLocals != a.FrameOffset(result) {
+			if config.regAmounts.intRegs == 0 && config.regAmounts.floatRegs == 0 {
+				panic(fmt.Errorf("Expected node offset %d != abi offset %d", f.Offset, a.FrameOffset(result)))
+			}
+		}
+	}
+}
+
 //......................................................................
 //
 // Non-public portions.
diff --git a/src/cmd/compile/internal/gc/compile.go b/src/cmd/compile/internal/gc/compile.go
index ba67c58c45..2d7a74a403 100644
--- a/src/cmd/compile/internal/gc/compile.go
+++ b/src/cmd/compile/internal/gc/compile.go
@@ -43,6 +43,9 @@ func enqueueFunc(fn *ir.Func) {
 	if len(fn.Body) == 0 {
 		// Initialize ABI wrappers if necessary.
 		ssagen.InitLSym(fn, false)
+		types.CalcSize(fn.Type()) // TODO register args; remove this once all is done by abiutils
+		a := ssagen.AbiForFunc(fn)
+		a.ABIAnalyze(fn.Type()) // will set parameter spill/home locations correctly
 		liveness.WriteFuncMap(fn)
 		return
 	}
diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go
index 07508d6e83..9921b51cc7 100644
--- a/src/cmd/compile/internal/ssa/config.go
+++ b/src/cmd/compile/internal/ssa/config.go
@@ -333,8 +333,8 @@ func NewConfig(arch string, types Types, ctxt *obj.Link, optimize bool) *Config
 	c.useSSE = true
 	c.UseFMA = true
 
-	c.ABI0 = abi.NewABIConfig(0, 0)
-	c.ABI1 = abi.NewABIConfig(len(c.intParamRegs), len(c.floatParamRegs))
+	c.ABI0 = abi.NewABIConfig(0, 0, ctxt.FixedFrameSize())
+	c.ABI1 = abi.NewABIConfig(len(c.intParamRegs), len(c.floatParamRegs), ctxt.FixedFrameSize())
 
 	// On Plan 9, floating point operations are not allowed in note handler.
 	if objabi.GOOS == "plan9" {
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index ece274b083..6d2ca96293 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -104,13 +104,23 @@ func (a *AuxCall) ResultForOffsetAndType(offset int64, t *types.Type) int64 {
 
 // OffsetOfResult returns the SP offset of result which (indexed 0, 1, etc).
 func (a *AuxCall) OffsetOfResult(which int64) int64 {
-	return int64(a.results[which].Offset)
+	o := int64(a.results[which].Offset)
+	n := int64(a.abiInfo.OutParam(int(which)).Offset())
+	if o != n {
+		panic(fmt.Errorf("Result old=%d, new=%d, auxcall=%s, oparams=%v", o, n, a, a.abiInfo.OutParams()))
+	}
+	return int64(a.abiInfo.OutParam(int(which)).Offset())
 }
 
 // OffsetOfArg returns the SP offset of argument which (indexed 0, 1, etc).
 // If the call is to a method, the receiver is the first argument (i.e., index 0)
 func (a *AuxCall) OffsetOfArg(which int64) int64 {
-	return int64(a.args[which].Offset)
+	o := int64(a.args[which].Offset)
+	n := int64(a.abiInfo.InParam(int(which)).Offset())
+	if o != n {
+		panic(fmt.Errorf("Arg old=%d, new=%d, auxcall=%s, iparams=%v", o, n, a, a.abiInfo.InParams()))
+	}
+	return int64(a.abiInfo.InParam(int(which)).Offset())
 }
 
 // RegsOfResult returns the register(s) used for result which (indexed 0, 1, etc).
@@ -206,6 +216,9 @@ func (a *AuxCall) String() string {
 	return fn + "}"
 }
 
+// ACParamsToTypes translates a slice of Param into a slice of *types.Type
+// This is a helper call for ssagen/ssa.go.
+// TODO remove this, as part of replacing fields of AuxCall with abi.ABIParamResultInfo.
 func ACParamsToTypes(ps []Param) (ts []*types.Type) {
 	for _, p := range ps {
 		ts = append(ts, p.Type)
@@ -215,7 +228,6 @@ func ACParamsToTypes(ps []Param) (ts []*types.Type) {
 
 // StaticAuxCall returns an AuxCall for a static call.
 func StaticAuxCall(sym *obj.LSym, args []Param, results []Param, paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
-	// TODO Create regInfo for AuxCall
 	if paramResultInfo == nil {
 		panic(fmt.Errorf("Nil paramResultInfo, sym=%v", sym))
 	}
@@ -223,15 +235,13 @@ func StaticAuxCall(sym *obj.LSym, args []Param, results []Param, paramResultInfo
 }
 
 // InterfaceAuxCall returns an AuxCall for an interface call.
-func InterfaceAuxCall(args []Param, results []Param) *AuxCall {
-	// TODO Create regInfo for AuxCall
-	return &AuxCall{Fn: nil, args: args, results: results}
+func InterfaceAuxCall(args []Param, results []Param, paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
+	return &AuxCall{Fn: nil, args: args, results: results, abiInfo: paramResultInfo}
 }
 
 // ClosureAuxCall returns an AuxCall for a closure call.
-func ClosureAuxCall(args []Param, results []Param) *AuxCall {
-	// TODO Create regInfo for AuxCall
-	return &AuxCall{Fn: nil, args: args, results: results}
+func ClosureAuxCall(args []Param, results []Param, paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
+	return &AuxCall{Fn: nil, args: args, results: results, abiInfo: paramResultInfo}
 }
 
 func (*AuxCall) CanBeAnSSAAux() {}
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 865630dd3e..938c1e8b62 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -7,6 +7,7 @@ package ssagen
 import (
 	"bufio"
 	"bytes"
+	"cmd/compile/internal/abi"
 	"encoding/binary"
 	"fmt"
 	"go/constant"
@@ -208,6 +209,32 @@ func InitConfig() {
 	ir.Syms.SigPanic = typecheck.LookupRuntimeFunc("sigpanic")
 }
 
+// AbiForFunc returns the ABI for a function, used to figure out arg/result mapping for rtcall and bodyless functions.
+// This follows policy for GOEXPERIMENT=regabi, //go:registerparams, and currently defined ABIInternal.
+// Policy is subject to change....
+// This always returns a freshly copied ABI.
+func AbiForFunc(fn *ir.Func) *abi.ABIConfig {
+	return abiForFunc(fn, ssaConfig.ABI0, ssaConfig.ABI1).Copy() // No idea what races will result, be safe
+}
+
+// abiForFunc implements ABI policy for a function, but does not return a copy of the ABI.
+// Passing a nil function returns ABIInternal.
+func abiForFunc(fn *ir.Func, abi0, abi1 *abi.ABIConfig) *abi.ABIConfig {
+	a := abi1
+	if true || objabi.Regabi_enabled == 0 {
+		a = abi0
+	}
+	if fn != nil && fn.Pragma&ir.RegisterParams != 0 { // TODO(register args) remove after register abi is working
+		name := ir.FuncName(fn)
+		if strings.Contains(name, ".") {
+			base.ErrorfAt(fn.Pos(), "Calls to //go:registerparams method %s won't work, remove the pragma from the declaration.", name)
+		}
+		a = abi1
+		base.WarnfAt(fn.Pos(), "declared function %v has register params", fn)
+	}
+	return a
+}
+
 // getParam returns the Field of ith param of node n (which is a
 // function/method/interface call), where the receiver of a method call is
 // considered as the 0th parameter. This does not include the receiver of an
@@ -357,25 +384,10 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 	if fn.Pragma&ir.Nosplit != 0 {
 		s.f.NoSplit = true
 	}
-	s.f.ABI0 = ssaConfig.ABI0.Copy() // Make a copy to avoid racy map operations in type-width cache.
+	s.f.ABI0 = ssaConfig.ABI0.Copy() // Make a copy to avoid racy map operations in type-register-width cache.
 	s.f.ABI1 = ssaConfig.ABI1.Copy()
-
-	s.f.ABIDefault = s.f.ABI1 // Default ABI for function calls with no parsed signature for a pragma, e.g. rtcall
-	// TODO(register args) -- remove "true ||"; in the short run, turning on the register ABI experiment still leaves the compiler defaulting to ABI0.
-	// TODO(register args) -- remove this conditional entirely when register ABI is not an experiment.
-	if true || objabi.Regabi_enabled == 0 {
-		s.f.ABIDefault = s.f.ABI0 // reset
-	}
-
-	s.f.ABISelf = s.f.ABIDefault
-
-	if fn.Pragma&ir.RegisterParams != 0 { // TODO(register args) remove after register abi is working
-		s.f.ABISelf = s.f.ABI1
-		if strings.Contains(name, ".") {
-			base.ErrorfAt(fn.Pos(), "Calls to //go:registerparams method %s won't work, remove the pragma from the declaration.", name)
-		}
-		s.f.Warnl(fn.Pos(), "declared function %v has register params", fn)
-	}
+	s.f.ABIDefault = abiForFunc(nil, s.f.ABI0, s.f.ABI1)
+	s.f.ABISelf = abiForFunc(fn, s.f.ABI0, s.f.ABI1)
 
 	s.panics = map[funcLine]*ssa.Block{}
 	s.softFloat = s.config.SoftFloat
@@ -4731,7 +4743,7 @@ func (s *state) openDeferExit() {
 			v := s.load(r.closure.Type.Elem(), r.closure)
 			s.maybeNilCheckClosure(v, callDefer)
 			codeptr := s.rawLoad(types.Types[types.TUINTPTR], v)
-			aux := ssa.ClosureAuxCall(ACArgs, ACResults)
+			aux := ssa.ClosureAuxCall(ACArgs, ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
 			call = s.newValue2A(ssa.OpClosureLECall, aux.LateExpansionResultType(), aux, codeptr, v)
 		} else {
 			aux := ssa.StaticAuxCall(fn.(*ir.Name).Linksym(), ACArgs, ACResults,
@@ -4842,7 +4854,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			} else {
 				o = p.SpillOffset() + int32(params.SpillAreaOffset())
 			}
-			ACResults = append(ACResults, ssa.Param{Type: p.Type, Offset: o + int32(base.Ctxt.FixedFrameSize()), Reg: r})
+			ACResults = append(ACResults, ssa.Param{Type: p.Type, Offset: o, Reg: r})
 		}
 	}
 
@@ -4913,21 +4925,23 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		// Store arguments to stack, including defer/go arguments and receiver for method calls.
 		// These are written in SP-offset order.
 		argStart := base.Ctxt.FixedFrameSize()
+		// argExtra is for combining with ABI-derived offsets; argStart is for old ABI0 code (defer, go).
+		argExtra := int32(0) // TODO(register args) untangle this mess when fully transition to abiutils, defer/go sanitized.
 		// Defer/go args.
 		if k != callNormal {
 			// Write argsize and closure (args to newproc/deferproc).
 			argsize := s.constInt32(types.Types[types.TUINT32], int32(stksize))
-			ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINT32], Offset: int32(argStart)})
+			ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINT32], Offset: int32(argStart)}) // not argExtra
 			callArgs = append(callArgs, argsize)
 			ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(argStart) + int32(types.PtrSize)})
 			callArgs = append(callArgs, closure)
 			stksize += 2 * int64(types.PtrSize)
 			argStart += 2 * int64(types.PtrSize)
+			argExtra = 2 * int32(types.PtrSize)
 		}
 
 		// Set receiver (for interface calls).
 		if rcvr != nil {
-			// ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(argStart)})
 			callArgs = append(callArgs, rcvr)
 		}
 
@@ -4938,7 +4952,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			base.Fatalf("OCALLMETH missed by walkCall")
 		}
 
-		for _, p := range params.InParams() {
+		for _, p := range params.InParams() { // includes receiver for interface calls
 			r := p.Registers
 			var o int32
 			if len(r) == 0 {
@@ -4946,7 +4960,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			} else {
 				o = p.SpillOffset() + int32(params.SpillAreaOffset())
 			}
-			ACArg := ssa.Param{Type: p.Type, Offset: int32(argStart) + o, Reg: r}
+			ACArg := ssa.Param{Type: p.Type, Offset: argExtra + o, Reg: r} // o from ABI includes any architecture-dependent offsets.
 			ACArgs = append(ACArgs, ACArg)
 		}
 		for i, n := range args {
@@ -4972,10 +4986,11 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			// critical that we not clobber any arguments already
 			// stored onto the stack.
 			codeptr = s.rawLoad(types.Types[types.TUINTPTR], closure)
-			aux := ssa.ClosureAuxCall(ACArgs, ACResults)
+			aux := ssa.ClosureAuxCall(ACArgs, ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
 			call = s.newValue2A(ssa.OpClosureLECall, aux.LateExpansionResultType(), aux, codeptr, closure)
 		case codeptr != nil:
-			aux := ssa.InterfaceAuxCall(ACArgs, ACResults)
+			// Note that the "receiver" parameter is nil because the actual receiver is the first input parameter.
+			aux := ssa.InterfaceAuxCall(ACArgs, ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
 			call = s.newValue1A(ssa.OpInterLECall, aux.LateExpansionResultType(), aux, codeptr)
 		case callee != nil:
 			aux := ssa.StaticAuxCall(callTargetLSym(callee, s.curfn.LSym), ACArgs, ACResults, params)
diff --git a/src/cmd/compile/internal/test/abiutils_test.go b/src/cmd/compile/internal/test/abiutils_test.go
index a0a11671e1..9a7d6d138c 100644
--- a/src/cmd/compile/internal/test/abiutils_test.go
+++ b/src/cmd/compile/internal/test/abiutils_test.go
@@ -21,7 +21,7 @@ import (
 // AMD64 registers available:
 // - integer: RAX, RBX, RCX, RDI, RSI, R8, R9, r10, R11
 // - floating point: X0 - X14
-var configAMD64 = abi.NewABIConfig(9, 15)
+var configAMD64 = abi.NewABIConfig(9, 15, 0)
 
 func TestMain(m *testing.M) {
 	ssagen.Arch.LinkArch = &x86.Linkamd64
diff --git a/src/cmd/compile/internal/test/abiutilsaux_test.go b/src/cmd/compile/internal/test/abiutilsaux_test.go
index bac0c7639d..7eb273273d 100644
--- a/src/cmd/compile/internal/test/abiutilsaux_test.go
+++ b/src/cmd/compile/internal/test/abiutilsaux_test.go
@@ -129,36 +129,4 @@ func abitest(t *testing.T, ft *types.Type, exp expectedDump) {
 			strings.TrimSpace(exp.dump), regResString, reason)
 	}
 
-	// Analyze again with empty register set.
-	empty := abi.NewABIConfig(0, 0)
-	emptyRes := empty.ABIAnalyze(ft)
-	emptyResString := emptyRes.String()
-
-	// Walk the results and make sure the offsets assigned match
-	// up with those assiged by CalcSize. This checks to make sure that
-	// when we have no available registers the ABI assignment degenerates
-	// back to the original ABI0.
-
-	// receiver
-	failed := 0
-	rfsl := ft.Recvs().Fields().Slice()
-	poff := 0
-	if len(rfsl) != 0 {
-		failed |= verifyParamResultOffset(t, rfsl[0], emptyRes.InParams()[0], "receiver", 0)
-		poff = 1
-	}
-	// params
-	pfsl := ft.Params().Fields().Slice()
-	for k, f := range pfsl {
-		verifyParamResultOffset(t, f, emptyRes.InParams()[k+poff], "param", k)
-	}
-	// results
-	ofsl := ft.Results().Fields().Slice()
-	for k, f := range ofsl {
-		failed |= verifyParamResultOffset(t, f, emptyRes.OutParams()[k], "result", k)
-	}
-
-	if failed != 0 {
-		t.Logf("emptyres:\n%s\n", emptyResString)
-	}
 }
-- 
GitLab


From c6374f516206c02b905d0d76ee1a66dab6fcd212 Mon Sep 17 00:00:00 2001
From: Tamir Duberstein <tamird@google.com>
Date: Thu, 25 Feb 2021 16:44:46 -0500
Subject: [PATCH 0888/2400] dist: generate stub go.mod in workdir

...and run commands from there.

This removes the requirement that bootstrap must not run inside a module
by ensuring that enclosing modules do not interfere with bootstrap.

Fixes #44209.

Change-Id: I700a81829226770b8160c8ff04127b855b6e26bf
Reviewed-on: https://go-review.googlesource.com/c/go/+/296610
Trust: Jay Conrod <jayconrod@google.com>
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/dist/build.go | 26 ++++++--------------------
 1 file changed, 6 insertions(+), 20 deletions(-)

diff --git a/src/cmd/dist/build.go b/src/cmd/dist/build.go
index 07ede42574..158cedbadc 100644
--- a/src/cmd/dist/build.go
+++ b/src/cmd/dist/build.go
@@ -111,9 +111,6 @@ func xinit() {
 		fatalf("$GOROOT must be set")
 	}
 	goroot = filepath.Clean(b)
-	if modRoot := findModuleRoot(goroot); modRoot != "" {
-		fatalf("found go.mod file in %s: $GOROOT must not be inside a module", modRoot)
-	}
 
 	b = os.Getenv("GOROOT_FINAL")
 	if b == "" {
@@ -241,6 +238,9 @@ func xinit() {
 	os.Setenv("LANGUAGE", "en_US.UTF8")
 
 	workdir = xworkdir()
+	if err := ioutil.WriteFile(pathf("%s/go.mod", workdir), []byte("module bootstrap"), 0666); err != nil {
+		fatalf("cannot write stub go.mod: %s", err)
+	}
 	xatexit(rmworkdir)
 
 	tooldir = pathf("%s/pkg/tool/%s_%s", goroot, gohostos, gohostarch)
@@ -1505,11 +1505,11 @@ func goCmd(goBinary string, cmd string, args ...string) {
 		goCmd = append(goCmd, "-p=1")
 	}
 
-	run(goroot, ShowOutput|CheckExit, append(goCmd, args...)...)
+	run(workdir, ShowOutput|CheckExit, append(goCmd, args...)...)
 }
 
 func checkNotStale(goBinary string, targets ...string) {
-	out := run(goroot, CheckExit,
+	out := run(workdir, CheckExit,
 		append([]string{
 			goBinary,
 			"list", "-gcflags=all=" + gogcflags, "-ldflags=all=" + goldflags,
@@ -1519,7 +1519,7 @@ func checkNotStale(goBinary string, targets ...string) {
 		os.Setenv("GODEBUG", "gocachehash=1")
 		for _, target := range []string{"runtime/internal/sys", "cmd/dist", "cmd/link"} {
 			if strings.Contains(out, "STALE "+target) {
-				run(goroot, ShowOutput|CheckExit, goBinary, "list", "-f={{.ImportPath}} {{.Stale}}", target)
+				run(workdir, ShowOutput|CheckExit, goBinary, "list", "-f={{.ImportPath}} {{.Stale}}", target)
 				break
 			}
 		}
@@ -1615,20 +1615,6 @@ func checkCC() {
 	}
 }
 
-func findModuleRoot(dir string) (root string) {
-	for {
-		if fi, err := os.Stat(filepath.Join(dir, "go.mod")); err == nil && !fi.IsDir() {
-			return dir
-		}
-		d := filepath.Dir(dir)
-		if d == dir {
-			break
-		}
-		dir = d
-	}
-	return ""
-}
-
 func defaulttarg() string {
 	// xgetwd might return a path with symlinks fully resolved, and if
 	// there happens to be symlinks in goroot, then the hasprefix test
-- 
GitLab


From 09f4ef4fa73a110eefd2cb9d78439f51d9294f65 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 19 Feb 2021 14:03:45 -0500
Subject: [PATCH 0889/2400] cmd/go/internal/mvs: prune spurious dependencies in
 Downgrade
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Previously, mvs.Downgrade could introduce spurious dependencies if the
downgrade computed for one module lands on a “hidden” version (such as
a pseudo-version) due to a requirement introduced by the downgrade for
another module.

To eliminate those spurious dependencies, we can add one more call to
BuildList to recompute the “actual” downgraded versions, and then
including only those actual versions in the final call to BuildList.

For #36460

Change-Id: Icc6b54aa004907221b2bcbbae74598b0e4100776
Reviewed-on: https://go-review.googlesource.com/c/go/+/294294
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/mvs/mvs.go                | 35 +++++++++++++++++++
 src/cmd/go/internal/mvs/mvs_test.go           |  7 ++--
 .../script/mod_get_downup_pseudo_artifact.txt |  9 ++---
 3 files changed, 42 insertions(+), 9 deletions(-)

diff --git a/src/cmd/go/internal/mvs/mvs.go b/src/cmd/go/internal/mvs/mvs.go
index ff2c5f963c..e30a40c97e 100644
--- a/src/cmd/go/internal/mvs/mvs.go
+++ b/src/cmd/go/internal/mvs/mvs.go
@@ -492,6 +492,41 @@ List:
 		downgraded = append(downgraded, r)
 	}
 
+	// The downgrades we computed above only downgrade to versions enumerated by
+	// reqs.Previous. However, reqs.Previous omits some versions — such as
+	// pseudo-versions and retracted versions — that may be selected as transitive
+	// requirements of other modules.
+	//
+	// If one of those requirements pulls the version back up above the version
+	// identified by reqs.Previous, then the transitive dependencies of that that
+	// initially-downgraded version should no longer matter — in particular, we
+	// should not add new dependencies on module paths that nothing else in the
+	// updated module graph even requires.
+	//
+	// In order to eliminate those spurious dependencies, we recompute the build
+	// list with the actual versions of the downgraded modules as selected by MVS,
+	// instead of our initial downgrades.
+	// (See the downhiddenartifact and downhiddencross test cases).
+	actual, err := BuildList(target, &override{
+		target: target,
+		list:   downgraded,
+		Reqs:   reqs,
+	})
+	if err != nil {
+		return nil, err
+	}
+	actualVersion := make(map[string]string, len(actual))
+	for _, m := range actual {
+		actualVersion[m.Path] = m.Version
+	}
+
+	downgraded = downgraded[:0]
+	for _, m := range list {
+		if v, ok := actualVersion[m.Path]; ok {
+			downgraded = append(downgraded, module.Version{Path: m.Path, Version: v})
+		}
+	}
+
 	return BuildList(target, &override{
 		target: target,
 		list:   downgraded,
diff --git a/src/cmd/go/internal/mvs/mvs_test.go b/src/cmd/go/internal/mvs/mvs_test.go
index 661f68be08..598ed66688 100644
--- a/src/cmd/go/internal/mvs/mvs_test.go
+++ b/src/cmd/go/internal/mvs/mvs_test.go
@@ -282,8 +282,9 @@ downgrade A B1: A B1
 # And C1 requires B2.hidden, and B2.hidden also meets our requirements:
 # it is compatible with D1 and a strict downgrade from B3.
 #
-# BUG(?): B2.hidden does not require E1, so there is no need for E1
-# to appear in the final build list. Nonetheless, there it is.
+# Since neither the initial nor the final build list includes B1,
+# and the nothing in the final downgraded build list requires E at all,
+# no dependency on E1 (required by only B1) should be introduced.
 #
 name: downhiddenartifact
 A: B3 C2
@@ -298,7 +299,7 @@ D2:
 build A1: A1 B3 D2
 downgrade A1 D1: A1 B1 D1 E1
 build A: A B3 C2 D2
-downgrade A D1: A B2.hidden C1 D1 E1
+downgrade A D1: A B2.hidden C1 D1
 
 # Both B3 and C3 require D2.
 # If we downgrade D to D1, then in isolation B3 would downgrade to B1,
diff --git a/src/cmd/go/testdata/script/mod_get_downup_pseudo_artifact.txt b/src/cmd/go/testdata/script/mod_get_downup_pseudo_artifact.txt
index d773f6bd4d..c49615cecb 100644
--- a/src/cmd/go/testdata/script/mod_get_downup_pseudo_artifact.txt
+++ b/src/cmd/go/testdata/script/mod_get_downup_pseudo_artifact.txt
@@ -26,18 +26,15 @@ cp go.mod go.mod.orig
 go mod tidy
 cmp go.mod.orig go.mod
 
+# When we downgrade d.2 to d.1, no dependency on e should be added
+# because nothing else in the module or import graph requires it.
 go get -d example.net/d@v0.1.0
 
 go list -m all
 stdout '^example.net/b v0.2.1-0.20210219000000-000000000000 '
 stdout '^example.net/c v0.1.0 '
 stdout '^example.net/d v0.1.0 '
-
-	# BUG: A dependency on e is added even though nothing requires it.
-stdout '^example.net/e '
-
-go mod why -m example.net/e
-stdout '^\(main module does not need module example.net/e\)'
+! stdout '^example.net/e '
 
 -- go.mod --
 module example.net/a
-- 
GitLab


From e9eed78dc3f4ab9a87f43c7d902025329f622783 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Tue, 2 Mar 2021 09:52:55 -0500
Subject: [PATCH 0890/2400] cmd/go: resolve std-vendored dependencies as std
 packages except in 'go get' and 'go mod'

In CL 251159, I removed a hard-coded special case changing the
rewriting behavior for std dependencies in GOROOT/src/vendor and
GOROOT/src/cmd/vendor. Unfortunately, that caused packages in 'std' to
be reported as stale when run within GOROOT/src.

This change restores the special-case behavior, but plumbs it through
the PackageOpts explicitly instead of comparing strings stored in
global variables.

Fixes #44725

Change-Id: If084fe74972ce1704715ca79b0b7e092dd90c88b
Reviewed-on: https://go-review.googlesource.com/c/go/+/297869
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modcmd/tidy.go            |  9 +++---
 src/cmd/go/internal/modcmd/vendor.go          |  9 +++---
 src/cmd/go/internal/modcmd/why.go             |  9 +++---
 src/cmd/go/internal/modget/get.go             | 14 +++++----
 src/cmd/go/internal/modload/load.go           |  9 ++++--
 src/cmd/go/testdata/script/list_std_stale.txt | 31 +++++++++++++++++++
 src/cmd/go/testdata/script/mod_list_std.txt   | 14 +++++----
 src/cmd/go/testdata/script/mod_std_vendor.txt |  6 ++--
 8 files changed, 72 insertions(+), 29 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/list_std_stale.txt

diff --git a/src/cmd/go/internal/modcmd/tidy.go b/src/cmd/go/internal/modcmd/tidy.go
index 3b83d87a8e..e7e63e6533 100644
--- a/src/cmd/go/internal/modcmd/tidy.go
+++ b/src/cmd/go/internal/modcmd/tidy.go
@@ -62,10 +62,11 @@ func runTidy(ctx context.Context, cmd *base.Command, args []string) {
 	modload.RootMode = modload.NeedRoot
 
 	modload.LoadPackages(ctx, modload.PackageOpts{
-		Tags:                  imports.AnyTags(),
-		ResolveMissingImports: true,
-		LoadTests:             true,
-		AllowErrors:           tidyE,
+		Tags:                     imports.AnyTags(),
+		VendorModulesInGOROOTSrc: true,
+		ResolveMissingImports:    true,
+		LoadTests:                true,
+		AllowErrors:              tidyE,
 	}, "all")
 
 	modload.TidyBuildList()
diff --git a/src/cmd/go/internal/modcmd/vendor.go b/src/cmd/go/internal/modcmd/vendor.go
index d3ed9e00e2..2cd683b75c 100644
--- a/src/cmd/go/internal/modcmd/vendor.go
+++ b/src/cmd/go/internal/modcmd/vendor.go
@@ -64,10 +64,11 @@ func runVendor(ctx context.Context, cmd *base.Command, args []string) {
 	modload.RootMode = modload.NeedRoot
 
 	loadOpts := modload.PackageOpts{
-		Tags:                  imports.AnyTags(),
-		ResolveMissingImports: true,
-		UseVendorAll:          true,
-		AllowErrors:           vendorE,
+		Tags:                     imports.AnyTags(),
+		VendorModulesInGOROOTSrc: true,
+		ResolveMissingImports:    true,
+		UseVendorAll:             true,
+		AllowErrors:              vendorE,
 	}
 	_, pkgs := modload.LoadPackages(ctx, loadOpts, "all")
 
diff --git a/src/cmd/go/internal/modcmd/why.go b/src/cmd/go/internal/modcmd/why.go
index a5f3e8afcb..79d257d198 100644
--- a/src/cmd/go/internal/modcmd/why.go
+++ b/src/cmd/go/internal/modcmd/why.go
@@ -68,10 +68,11 @@ func runWhy(ctx context.Context, cmd *base.Command, args []string) {
 	modload.RootMode = modload.NeedRoot
 
 	loadOpts := modload.PackageOpts{
-		Tags:          imports.AnyTags(),
-		LoadTests:     !*whyVendor,
-		SilenceErrors: true,
-		UseVendorAll:  *whyVendor,
+		Tags:                     imports.AnyTags(),
+		VendorModulesInGOROOTSrc: true,
+		LoadTests:                !*whyVendor,
+		SilenceErrors:            true,
+		UseVendorAll:             *whyVendor,
 	}
 
 	if *whyM {
diff --git a/src/cmd/go/internal/modget/get.go b/src/cmd/go/internal/modget/get.go
index 971c5a8d8a..b875a46d81 100644
--- a/src/cmd/go/internal/modget/get.go
+++ b/src/cmd/go/internal/modget/get.go
@@ -1120,9 +1120,10 @@ func (r *resolver) findAndUpgradeImports(ctx context.Context, queries []*query)
 // build list.
 func (r *resolver) loadPackages(ctx context.Context, patterns []string, findPackage func(ctx context.Context, path string, m module.Version) (versionOk bool)) {
 	opts := modload.PackageOpts{
-		Tags:          imports.AnyTags(),
-		LoadTests:     *getT,
-		SilenceErrors: true, // May be fixed by subsequent upgrades or downgrades.
+		Tags:                     imports.AnyTags(),
+		VendorModulesInGOROOTSrc: true,
+		LoadTests:                *getT,
+		SilenceErrors:            true, // May be fixed by subsequent upgrades or downgrades.
 	}
 
 	opts.AllowPackage = func(ctx context.Context, path string, m module.Version) error {
@@ -1459,9 +1460,10 @@ func (r *resolver) checkPackagesAndRetractions(ctx context.Context, pkgPatterns
 		// LoadPackages will print errors (since it has more context) but will not
 		// exit, since we need to load retractions later.
 		pkgOpts := modload.PackageOpts{
-			LoadTests:             *getT,
-			ResolveMissingImports: false,
-			AllowErrors:           true,
+			VendorModulesInGOROOTSrc: true,
+			LoadTests:                *getT,
+			ResolveMissingImports:    false,
+			AllowErrors:              true,
 		}
 		matches, pkgs := modload.LoadPackages(ctx, pkgOpts, pkgPatterns...)
 		for _, m := range matches {
diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index 6d87acc6d3..0dba49e40e 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -134,6 +134,11 @@ type PackageOpts struct {
 	// If nil, treated as equivalent to imports.Tags().
 	Tags map[string]bool
 
+	// VendorModulesInGOROOTSrc indicates that if we are within a module in
+	// GOROOT/src, packages in the module's vendor directory should be resolved as
+	// actual module dependencies (instead of standard-library packages).
+	VendorModulesInGOROOTSrc bool
+
 	// ResolveMissingImports indicates that we should attempt to add module
 	// dependencies as needed to resolve imports of packages that are not found.
 	//
@@ -1170,13 +1175,13 @@ func (ld *loader) stdVendor(parentPath, path string) string {
 	}
 
 	if str.HasPathPrefix(parentPath, "cmd") {
-		if Target.Path != "cmd" {
+		if !ld.VendorModulesInGOROOTSrc || Target.Path != "cmd" {
 			vendorPath := pathpkg.Join("cmd", "vendor", path)
 			if _, err := os.Stat(filepath.Join(cfg.GOROOTsrc, filepath.FromSlash(vendorPath))); err == nil {
 				return vendorPath
 			}
 		}
-	} else if Target.Path != "std" || str.HasPathPrefix(parentPath, "vendor") {
+	} else if !ld.VendorModulesInGOROOTSrc || Target.Path != "std" || str.HasPathPrefix(parentPath, "vendor") {
 		// If we are outside of the 'std' module, resolve imports from within 'std'
 		// to the vendor directory.
 		//
diff --git a/src/cmd/go/testdata/script/list_std_stale.txt b/src/cmd/go/testdata/script/list_std_stale.txt
new file mode 100644
index 0000000000..e5c1f334fd
--- /dev/null
+++ b/src/cmd/go/testdata/script/list_std_stale.txt
@@ -0,0 +1,31 @@
+# https://golang.org/issue/44725: packages in std should not be reported as stale,
+# regardless of whether they are listed from within or outside GOROOT/src.
+
+# Control case: net should not be stale at the start of the test,
+# and should depend on vendor/golang.org/… instead of golang.org/….
+
+! stale net
+
+go list -deps net
+stdout '^vendor/golang.org/x/net'
+! stdout '^golang.org/x/net'
+
+# Net should also not be stale when viewed from within GOROOT/src,
+# and should still report the same package dependencies.
+
+cd $GOROOT/src
+! stale net
+
+go list -deps net
+stdout '^vendor/golang.org/x/net'
+! stdout '^golang.org/x/net'
+
+
+# However, 'go mod' and 'go get' subcommands should report the original module
+# dependencies, not the vendored packages.
+
+[!net] stop
+
+env GOPROXY=
+go mod why -m golang.org/x/net
+stdout '^# golang.org/x/net\nnet\ngolang.org/x/net'
diff --git a/src/cmd/go/testdata/script/mod_list_std.txt b/src/cmd/go/testdata/script/mod_list_std.txt
index baf7908ab9..f4e0433d8a 100644
--- a/src/cmd/go/testdata/script/mod_list_std.txt
+++ b/src/cmd/go/testdata/script/mod_list_std.txt
@@ -48,18 +48,20 @@ stdout ^vendor/golang.org/x/crypto/internal/subtle
 ! stdout ^golang\.org/x
 
 # Within the std module, the dependencies of the non-vendored packages within
-# std should appear to come from modules, but they should be loaded from the
-# vendor directory (just like ordinary vendored module dependencies).
+# std should appear to be packages beginning with 'vendor/', not 'golang.org/…'
+# module dependencies.
 
 go list all
-stdout ^golang.org/x/
+! stdout ^golang.org/x/
 ! stdout ^std/
 ! stdout ^cmd/
-! stdout ^vendor/
+stdout ^vendor/
 
 go list -deps -f '{{if not .Standard}}{{.ImportPath}}{{end}}' std
-! stdout ^vendor/golang.org/x/net/http2/hpack
-stdout ^golang.org/x/net/http2/hpack
+! stdout .
+
+# However, the 'golang.org/…' module dependencies should resolve to those same
+# directories.
 
 go list -f '{{.Dir}}' golang.org/x/net/http2/hpack
 stdout $GOROOT[/\\]src[/\\]vendor
diff --git a/src/cmd/go/testdata/script/mod_std_vendor.txt b/src/cmd/go/testdata/script/mod_std_vendor.txt
index fb954d74ed..c3cde52953 100644
--- a/src/cmd/go/testdata/script/mod_std_vendor.txt
+++ b/src/cmd/go/testdata/script/mod_std_vendor.txt
@@ -36,11 +36,11 @@ stderr 'use of vendored package'
 
 
 # When run within the 'std' module, 'go list -test' should report vendored
-# transitive dependencies at their original module paths.
+# transitive dependencies at their vendored paths.
 cd $GOROOT/src
 go list -test -f '{{range .Deps}}{{.}}{{"\n"}}{{end}}' net/http
-stdout ^golang.org/x/net/http2/hpack
-! stdout ^vendor/golang.org/x/net/http2/hpack
+! stdout ^golang.org/x/net/http2/hpack
+stdout ^vendor/golang.org/x/net/http2/hpack
 
 -- go.mod --
 module m
-- 
GitLab


From b65091c11d711ff3b01cd25393305410e1b0b377 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 26 Feb 2021 17:21:21 -0500
Subject: [PATCH 0891/2400] cmd/go: add a test case that reproduces #44296

For #44296

Change-Id: I310f99ccd406622e39f3fbfa12f7a3bee39602db
Reviewed-on: https://go-review.googlesource.com/c/go/+/297149
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 .../testdata/script/mod_retract_versions.txt   | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 src/cmd/go/testdata/script/mod_retract_versions.txt

diff --git a/src/cmd/go/testdata/script/mod_retract_versions.txt b/src/cmd/go/testdata/script/mod_retract_versions.txt
new file mode 100644
index 0000000000..93ce5926e3
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_retract_versions.txt
@@ -0,0 +1,18 @@
+# https://golang.org/issue/44296: the --versions flag should not affect
+# the version reported by 'go list' in case of retractions.
+
+env FMT='{{.Path}}{{with .Error}}: {{printf "%q" .Err}}{{end}} {{printf "%q" .Version}}{{with .Versions}} {{.}}{{end}}'
+
+go list -m -e -f $FMT example.com/retract/self/pseudo
+stdout '^example.com/retract/self/pseudo: "module example.com/retract/self/pseudo: not a known dependency" ""$'
+
+go list -m -e -f $FMT example.com/retract/self/pseudo@latest
+stdout '^example.com/retract/self/pseudo: "module example.com/retract/self/pseudo: no matching versions for query \\"latest\\"" "latest"$'
+
+
+	# BUG(#44296): Adding --versions should not cause a retracted version to be reported.
+go list -m -e -f $FMT --versions example.com/retract/self/pseudo
+stdout '^example.com/retract/self/pseudo "v1.9.0"$'
+
+go list -m -e -f $FMT --versions example.com/retract/self/pseudo@latest
+stdout '^example.com/retract/self/pseudo: "module example.com/retract/self/pseudo: no matching versions for query \\"latest\\"" "latest"$'
-- 
GitLab


From 2a2f99eefb70a66ecb9560a61b5cf23a5ca02ecb Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 26 Feb 2021 17:40:18 -0500
Subject: [PATCH 0892/2400] cmd/go/internal/modload: do not resolve an
 arbitrary version for 'go list --versions'
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

If we don't actually require the listed module, we previously
implicitly resolved "latest", but also (erroneously) forgot to apply
exclusions and retractions for it. But there is really no need to
resolve "latest" in this case at all — now we omit the version from
the reported module info entirely.

Fixes #44296

Change-Id: Id595f52f597c7213bd65b73bf066a678d9e1d694
Reviewed-on: https://go-review.googlesource.com/c/go/+/297150
Trust: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modload/build.go               |  6 +++++-
 src/cmd/go/internal/modload/list.go                | 14 +++-----------
 src/cmd/go/testdata/script/mod_proxy_https.txt     |  1 +
 .../go/testdata/script/mod_retract_versions.txt    |  3 +--
 4 files changed, 10 insertions(+), 14 deletions(-)

diff --git a/src/cmd/go/internal/modload/build.go b/src/cmd/go/internal/modload/build.go
index 8ad5f834de..5a151b4802 100644
--- a/src/cmd/go/internal/modload/build.go
+++ b/src/cmd/go/internal/modload/build.go
@@ -113,7 +113,11 @@ func addVersions(ctx context.Context, m *modinfo.ModulePublic, listRetracted boo
 	if listRetracted {
 		allowed = CheckExclusions
 	}
-	m.Versions, _ = versions(ctx, m.Path, allowed)
+	var err error
+	m.Versions, err = versions(ctx, m.Path, allowed)
+	if err != nil && m.Error == nil {
+		m.Error = &modinfo.ModuleError{Err: err.Error()}
+	}
 }
 
 // addRetraction fills in m.Retracted if the module was retracted by its author.
diff --git a/src/cmd/go/internal/modload/list.go b/src/cmd/go/internal/modload/list.go
index 3491f941cd..de16c2f786 100644
--- a/src/cmd/go/internal/modload/list.go
+++ b/src/cmd/go/internal/modload/list.go
@@ -136,17 +136,9 @@ func listModules(ctx context.Context, args []string, listVersions, listRetracted
 				if listVersions {
 					// Don't make the user provide an explicit '@latest' when they're
 					// explicitly asking what the available versions are.
-					// Instead, resolve the module, even if it isn't an existing dependency.
-					info, err := Query(ctx, arg, "latest", "", nil)
-					if err == nil {
-						mod := moduleInfo(ctx, module.Version{Path: arg, Version: info.Version}, false, listRetracted)
-						mods = append(mods, mod)
-					} else {
-						mods = append(mods, &modinfo.ModulePublic{
-							Path:  arg,
-							Error: modinfoError(arg, "", err),
-						})
-					}
+					// Instead, return a modinfo without a version,
+					// to which we can attach the requested version list.
+					mods = append(mods, &modinfo.ModulePublic{Path: arg})
 					continue
 				}
 				if cfg.BuildMod == "vendor" {
diff --git a/src/cmd/go/testdata/script/mod_proxy_https.txt b/src/cmd/go/testdata/script/mod_proxy_https.txt
index a23090cd0a..a5e28dd0b9 100644
--- a/src/cmd/go/testdata/script/mod_proxy_https.txt
+++ b/src/cmd/go/testdata/script/mod_proxy_https.txt
@@ -10,6 +10,7 @@ stderr 'invalid proxy URL.*proxydir'
 # GOPROXY HTTPS paths may elide the "https://" prefix.
 # (See golang.org/issue/32191.)
 env GOPROXY=proxy.golang.org
+env GOSUMDB=
 go list -versions -m golang.org/x/text
 
 -- go.mod --
diff --git a/src/cmd/go/testdata/script/mod_retract_versions.txt b/src/cmd/go/testdata/script/mod_retract_versions.txt
index 93ce5926e3..961a0a1fa3 100644
--- a/src/cmd/go/testdata/script/mod_retract_versions.txt
+++ b/src/cmd/go/testdata/script/mod_retract_versions.txt
@@ -10,9 +10,8 @@ go list -m -e -f $FMT example.com/retract/self/pseudo@latest
 stdout '^example.com/retract/self/pseudo: "module example.com/retract/self/pseudo: no matching versions for query \\"latest\\"" "latest"$'
 
 
-	# BUG(#44296): Adding --versions should not cause a retracted version to be reported.
 go list -m -e -f $FMT --versions example.com/retract/self/pseudo
-stdout '^example.com/retract/self/pseudo "v1.9.0"$'
+stdout '^example.com/retract/self/pseudo ""$'
 
 go list -m -e -f $FMT --versions example.com/retract/self/pseudo@latest
 stdout '^example.com/retract/self/pseudo: "module example.com/retract/self/pseudo: no matching versions for query \\"latest\\"" "latest"$'
-- 
GitLab


From 312fd9937d6e8675a166fe60df77c1c24015a369 Mon Sep 17 00:00:00 2001
From: witchard <witchard@hotmail.co.uk>
Date: Tue, 2 Mar 2021 21:16:24 +0000
Subject: [PATCH 0893/2400] cmd/go: remove -insecure flag on go get

Resolves #37519

Change-Id: Iba675a180b0e61b12835cdb6ecd4c6dc61e0605c
GitHub-Last-Rev: aa018af6f8fc7f0b829820e831ad96734adcb8d0
GitHub-Pull-Request: golang/go#44724
Reviewed-on: https://go-review.googlesource.com/c/go/+/297709
Trust: Jay Conrod <jayconrod@google.com>
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 doc/go1.17.html                               | 12 ++++++--
 src/cmd/go/alldocs.go                         | 26 ++++------------
 src/cmd/go/internal/cfg/cfg.go                |  2 --
 src/cmd/go/internal/get/get.go                | 27 +++++++----------
 src/cmd/go/internal/help/helpdoc.go           |  7 ++---
 src/cmd/go/internal/modfetch/insecure.go      | 16 ----------
 src/cmd/go/internal/modfetch/repo.go          |  4 +--
 src/cmd/go/internal/modfetch/sumdb.go         |  2 +-
 src/cmd/go/internal/modget/get.go             | 30 +++++++------------
 src/cmd/go/internal/web/http.go               |  2 +-
 src/cmd/go/testdata/script/get_404_meta.txt   |  5 ++--
 src/cmd/go/testdata/script/get_insecure.txt   | 20 ++++++++-----
 .../script/get_insecure_custom_domain.txt     |  4 ++-
 .../script/get_insecure_deprecated.txt        | 21 -------------
 .../get_insecure_no_longer_supported.txt      | 13 ++++++++
 .../testdata/script/get_insecure_redirect.txt |  5 ++--
 .../testdata/script/get_insecure_update.txt   |  8 +++--
 .../script/mod_get_insecure_redirect.txt      |  4 +--
 .../go/testdata/script/mod_sumdb_cache.txt    |  7 -----
 19 files changed, 83 insertions(+), 132 deletions(-)
 delete mode 100644 src/cmd/go/internal/modfetch/insecure.go
 delete mode 100644 src/cmd/go/testdata/script/get_insecure_deprecated.txt
 create mode 100644 src/cmd/go/testdata/script/get_insecure_no_longer_supported.txt

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 79cd4f7b61..a07290714f 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -43,8 +43,16 @@ Do not send CLs removing the interior tags from such phrases.
 
 <h3 id="go-command">Go command</h3>
 
-<p>
-  TODO: complete this section, or delete if not needed
+<h4 id="go-get"><code>go</code> <code>get</code></h4>
+
+<p><!-- golang.org/issue/37519 -->
+  The <code>go</code> <code>get</code> <code>-insecure</code> flag is
+  deprecated and has been removed. To permit the use of insecure schemes
+  when fetching dependencies, please use the <code>GOINSECURE</code>
+  environment variable. The <code>-insecure</code> flag also bypassed module
+  sum validation, use <code>GOPRIVATE</code> or <code>GONOSUMDB</code> if
+  you need that functionality. See <code>go</code> <code>help</code>
+  <code>environment</code> for details.
 </p>
 
 <h2 id="runtime">Runtime</h2>
diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index db3f281ef3..a125e94cea 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -596,7 +596,7 @@
 //
 // Usage:
 //
-// 	go get [-d] [-t] [-u] [-v] [-insecure] [build flags] [packages]
+// 	go get [-d] [-t] [-u] [-v] [build flags] [packages]
 //
 // Get resolves its command-line arguments to packages at specific module versions,
 // updates go.mod to require those versions, downloads source code into the
@@ -641,14 +641,6 @@
 // When the -t and -u flags are used together, get will update
 // test dependencies as well.
 //
-// The -insecure flag permits fetching from repositories and resolving
-// custom domains using insecure schemes such as HTTP, and also bypassess
-// module sum validation using the checksum database. Use with caution.
-// This flag is deprecated and will be removed in a future version of go.
-// To permit the use of insecure schemes, use the GOINSECURE environment
-// variable instead. To bypass module sum validation, use GOPRIVATE or
-// GONOSUMDB. See 'go help environment' for details.
-//
 // The -d flag instructs get not to build or install packages. get will only
 // update go.mod and download source code needed to build packages.
 //
@@ -1783,9 +1775,8 @@
 // 		Comma-separated list of glob patterns (in the syntax of Go's path.Match)
 // 		of module path prefixes that should always be fetched in an insecure
 // 		manner. Only applies to dependencies that are being fetched directly.
-// 		Unlike the -insecure flag on 'go get', GOINSECURE does not disable
-// 		checksum database validation. GOPRIVATE or GONOSUMDB may be used
-// 		to achieve that.
+// 		GOINSECURE does not disable checksum database validation. GOPRIVATE or
+// 		GONOSUMDB may be used to achieve that.
 // 	GOOS
 // 		The operating system for which to compile code.
 // 		Examples are linux, darwin, windows, netbsd.
@@ -2135,7 +2126,7 @@
 // This help text, accessible as 'go help gopath-get' even in module-aware mode,
 // describes 'go get' as it operates in legacy GOPATH mode.
 //
-// Usage: go get [-d] [-f] [-t] [-u] [-v] [-fix] [-insecure] [build flags] [packages]
+// Usage: go get [-d] [-f] [-t] [-u] [-v] [-fix] [build flags] [packages]
 //
 // Get downloads the packages named by the import paths, along with their
 // dependencies. It then installs the named packages, like 'go install'.
@@ -2151,13 +2142,6 @@
 // The -fix flag instructs get to run the fix tool on the downloaded packages
 // before resolving dependencies or building the code.
 //
-// The -insecure flag permits fetching from repositories and resolving
-// custom domains using insecure schemes such as HTTP. Use with caution.
-// This flag is deprecated and will be removed in a future version of go.
-// The GOINSECURE environment variable should be used instead, since it
-// provides control over which packages may be retrieved using an insecure
-// scheme. See 'go help environment' for details.
-//
 // The -t flag instructs get to also download the packages required to build
 // the tests for the specified packages.
 //
@@ -2342,7 +2326,7 @@
 // will result in the following requests:
 //
 // 	https://example.org/pkg/foo?go-get=1 (preferred)
-// 	http://example.org/pkg/foo?go-get=1  (fallback, only with -insecure)
+// 	http://example.org/pkg/foo?go-get=1  (fallback, only with use of correctly set GOINSECURE)
 //
 // If that page contains the meta tag
 //
diff --git a/src/cmd/go/internal/cfg/cfg.go b/src/cmd/go/internal/cfg/cfg.go
index 322247962f..810189c15d 100644
--- a/src/cmd/go/internal/cfg/cfg.go
+++ b/src/cmd/go/internal/cfg/cfg.go
@@ -51,8 +51,6 @@ var (
 	ModCacheRW bool   // -modcacherw flag
 	ModFile    string // -modfile flag
 
-	Insecure bool // -insecure flag
-
 	CmdName string // "build", "install", "list", "mod tidy", etc.
 
 	DebugActiongraph string // -debug-actiongraph flag (undocumented, unstable)
diff --git a/src/cmd/go/internal/get/get.go b/src/cmd/go/internal/get/get.go
index 329a2f5eda..10eda1275e 100644
--- a/src/cmd/go/internal/get/get.go
+++ b/src/cmd/go/internal/get/get.go
@@ -26,7 +26,7 @@ import (
 )
 
 var CmdGet = &base.Command{
-	UsageLine: "go get [-d] [-f] [-t] [-u] [-v] [-fix] [-insecure] [build flags] [packages]",
+	UsageLine: "go get [-d] [-f] [-t] [-u] [-v] [-fix] [build flags] [packages]",
 	Short:     "download and install packages and dependencies",
 	Long: `
 Get downloads the packages named by the import paths, along with their
@@ -43,13 +43,6 @@ of the original.
 The -fix flag instructs get to run the fix tool on the downloaded packages
 before resolving dependencies or building the code.
 
-The -insecure flag permits fetching from repositories and resolving
-custom domains using insecure schemes such as HTTP. Use with caution.
-This flag is deprecated and will be removed in a future version of go.
-The GOINSECURE environment variable should be used instead, since it
-provides control over which packages may be retrieved using an insecure
-scheme. See 'go help environment' for details.
-
 The -t flag instructs get to also download the packages required to build
 the tests for the specified packages.
 
@@ -105,17 +98,17 @@ Usage: ` + CmdGet.UsageLine + `
 }
 
 var (
-	getD   = CmdGet.Flag.Bool("d", false, "")
-	getF   = CmdGet.Flag.Bool("f", false, "")
-	getT   = CmdGet.Flag.Bool("t", false, "")
-	getU   = CmdGet.Flag.Bool("u", false, "")
-	getFix = CmdGet.Flag.Bool("fix", false, "")
+	getD        = CmdGet.Flag.Bool("d", false, "")
+	getF        = CmdGet.Flag.Bool("f", false, "")
+	getT        = CmdGet.Flag.Bool("t", false, "")
+	getU        = CmdGet.Flag.Bool("u", false, "")
+	getFix      = CmdGet.Flag.Bool("fix", false, "")
+	getInsecure = CmdGet.Flag.Bool("insecure", false, "")
 )
 
 func init() {
 	work.AddBuildFlags(CmdGet, work.OmitModFlag|work.OmitModCommonFlags)
 	CmdGet.Run = runGet // break init loop
-	CmdGet.Flag.BoolVar(&cfg.Insecure, "insecure", cfg.Insecure, "")
 }
 
 func runGet(ctx context.Context, cmd *base.Command, args []string) {
@@ -129,8 +122,8 @@ func runGet(ctx context.Context, cmd *base.Command, args []string) {
 	if *getF && !*getU {
 		base.Fatalf("go get: cannot use -f flag without -u")
 	}
-	if cfg.Insecure {
-		fmt.Fprintf(os.Stderr, "go get: -insecure flag is deprecated; see 'go help get' for details\n")
+	if *getInsecure {
+		base.Fatalf("go get: -insecure flag is no longer supported; use GOINSECURE instead")
 	}
 
 	// Disable any prompting for passwords by Git.
@@ -435,7 +428,7 @@ func downloadPackage(p *load.Package) error {
 		return fmt.Errorf("%s: invalid import path: %v", p.ImportPath, err)
 	}
 	security := web.SecureOnly
-	if cfg.Insecure || module.MatchPrefixPatterns(cfg.GOINSECURE, importPrefix) {
+	if module.MatchPrefixPatterns(cfg.GOINSECURE, importPrefix) {
 		security = web.Insecure
 	}
 
diff --git a/src/cmd/go/internal/help/helpdoc.go b/src/cmd/go/internal/help/helpdoc.go
index 57cee4ff96..2f86e4195d 100644
--- a/src/cmd/go/internal/help/helpdoc.go
+++ b/src/cmd/go/internal/help/helpdoc.go
@@ -251,7 +251,7 @@ For example,
 will result in the following requests:
 
 	https://example.org/pkg/foo?go-get=1 (preferred)
-	http://example.org/pkg/foo?go-get=1  (fallback, only with -insecure)
+	http://example.org/pkg/foo?go-get=1  (fallback, only with use of correctly set GOINSECURE)
 
 If that page contains the meta tag
 
@@ -517,9 +517,8 @@ General-purpose environment variables:
 		Comma-separated list of glob patterns (in the syntax of Go's path.Match)
 		of module path prefixes that should always be fetched in an insecure
 		manner. Only applies to dependencies that are being fetched directly.
-		Unlike the -insecure flag on 'go get', GOINSECURE does not disable
-		checksum database validation. GOPRIVATE or GONOSUMDB may be used
-		to achieve that.
+		GOINSECURE does not disable checksum database validation. GOPRIVATE or
+		GONOSUMDB may be used to achieve that.
 	GOOS
 		The operating system for which to compile code.
 		Examples are linux, darwin, windows, netbsd.
diff --git a/src/cmd/go/internal/modfetch/insecure.go b/src/cmd/go/internal/modfetch/insecure.go
deleted file mode 100644
index 012d05f29d..0000000000
--- a/src/cmd/go/internal/modfetch/insecure.go
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright 2018 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 modfetch
-
-import (
-	"cmd/go/internal/cfg"
-
-	"golang.org/x/mod/module"
-)
-
-// allowInsecure reports whether we are allowed to fetch this path in an insecure manner.
-func allowInsecure(path string) bool {
-	return cfg.Insecure || module.MatchPrefixPatterns(cfg.GOINSECURE, path)
-}
diff --git a/src/cmd/go/internal/modfetch/repo.go b/src/cmd/go/internal/modfetch/repo.go
index af9e24cefd..ed9a52267a 100644
--- a/src/cmd/go/internal/modfetch/repo.go
+++ b/src/cmd/go/internal/modfetch/repo.go
@@ -267,7 +267,7 @@ var (
 func lookupDirect(path string) (Repo, error) {
 	security := web.SecureOnly
 
-	if allowInsecure(path) {
+	if module.MatchPrefixPatterns(cfg.GOINSECURE, path) {
 		security = web.Insecure
 	}
 	rr, err := vcs.RepoRootForImportPath(path, vcs.PreferMod, security)
@@ -312,7 +312,7 @@ func ImportRepoRev(path, rev string) (Repo, *RevInfo, error) {
 	// version control system, we ignore meta tags about modules
 	// and use only direct source control entries (get.IgnoreMod).
 	security := web.SecureOnly
-	if allowInsecure(path) {
+	if module.MatchPrefixPatterns(cfg.GOINSECURE, path) {
 		security = web.Insecure
 	}
 	rr, err := vcs.RepoRootForImportPath(path, vcs.IgnoreMod, security)
diff --git a/src/cmd/go/internal/modfetch/sumdb.go b/src/cmd/go/internal/modfetch/sumdb.go
index fbe2bda2e5..118bb3d2d0 100644
--- a/src/cmd/go/internal/modfetch/sumdb.go
+++ b/src/cmd/go/internal/modfetch/sumdb.go
@@ -34,7 +34,7 @@ import (
 
 // useSumDB reports whether to use the Go checksum database for the given module.
 func useSumDB(mod module.Version) bool {
-	return cfg.GOSUMDB != "off" && !cfg.Insecure && !module.MatchPrefixPatterns(cfg.GONOSUMDB, mod.Path)
+	return cfg.GOSUMDB != "off" && !module.MatchPrefixPatterns(cfg.GONOSUMDB, mod.Path)
 }
 
 // lookupSumDB returns the Go checksum database's go.sum lines for the given module,
diff --git a/src/cmd/go/internal/modget/get.go b/src/cmd/go/internal/modget/get.go
index b875a46d81..9340a582e5 100644
--- a/src/cmd/go/internal/modget/get.go
+++ b/src/cmd/go/internal/modget/get.go
@@ -37,7 +37,6 @@ import (
 	"sync"
 
 	"cmd/go/internal/base"
-	"cmd/go/internal/cfg"
 	"cmd/go/internal/imports"
 	"cmd/go/internal/load"
 	"cmd/go/internal/modload"
@@ -53,7 +52,7 @@ import (
 var CmdGet = &base.Command{
 	// Note: -d -u are listed explicitly because they are the most common get flags.
 	// Do not send CLs removing them because they're covered by [get flags].
-	UsageLine: "go get [-d] [-t] [-u] [-v] [-insecure] [build flags] [packages]",
+	UsageLine: "go get [-d] [-t] [-u] [-v] [build flags] [packages]",
 	Short:     "add dependencies to current module and install them",
 	Long: `
 Get resolves its command-line arguments to packages at specific module versions,
@@ -99,14 +98,6 @@ but changes the default to select patch releases.
 When the -t and -u flags are used together, get will update
 test dependencies as well.
 
-The -insecure flag permits fetching from repositories and resolving
-custom domains using insecure schemes such as HTTP, and also bypassess
-module sum validation using the checksum database. Use with caution.
-This flag is deprecated and will be removed in a future version of go.
-To permit the use of insecure schemes, use the GOINSECURE environment
-variable instead. To bypass module sum validation, use GOPRIVATE or
-GONOSUMDB. See 'go help environment' for details.
-
 The -d flag instructs get not to build or install packages. get will only
 update go.mod and download source code needed to build packages.
 
@@ -227,13 +218,13 @@ variable for future go command invocations.
 }
 
 var (
-	getD   = CmdGet.Flag.Bool("d", false, "")
-	getF   = CmdGet.Flag.Bool("f", false, "")
-	getFix = CmdGet.Flag.Bool("fix", false, "")
-	getM   = CmdGet.Flag.Bool("m", false, "")
-	getT   = CmdGet.Flag.Bool("t", false, "")
-	getU   upgradeFlag
-	// -insecure is cfg.Insecure
+	getD        = CmdGet.Flag.Bool("d", false, "")
+	getF        = CmdGet.Flag.Bool("f", false, "")
+	getFix      = CmdGet.Flag.Bool("fix", false, "")
+	getM        = CmdGet.Flag.Bool("m", false, "")
+	getT        = CmdGet.Flag.Bool("t", false, "")
+	getU        upgradeFlag
+	getInsecure = CmdGet.Flag.Bool("insecure", false, "")
 	// -v is cfg.BuildV
 )
 
@@ -264,7 +255,6 @@ func (v *upgradeFlag) String() string { return "" }
 func init() {
 	work.AddBuildFlags(CmdGet, work.OmitModFlag)
 	CmdGet.Run = runGet // break init loop
-	CmdGet.Flag.BoolVar(&cfg.Insecure, "insecure", cfg.Insecure, "")
 	CmdGet.Flag.Var(&getU, "u", "")
 }
 
@@ -284,8 +274,8 @@ func runGet(ctx context.Context, cmd *base.Command, args []string) {
 	if *getM {
 		base.Fatalf("go get: -m flag is no longer supported; consider -d to skip building packages")
 	}
-	if cfg.Insecure {
-		fmt.Fprintf(os.Stderr, "go get: -insecure flag is deprecated; see 'go help get' for details\n")
+	if *getInsecure {
+		base.Fatalf("go get: -insecure flag is no longer supported; use GOINSECURE instead")
 	}
 	load.ModResolveTests = *getT
 
diff --git a/src/cmd/go/internal/web/http.go b/src/cmd/go/internal/web/http.go
index a77e0f9317..f177278eba 100644
--- a/src/cmd/go/internal/web/http.go
+++ b/src/cmd/go/internal/web/http.go
@@ -28,7 +28,7 @@ import (
 	"cmd/internal/browser"
 )
 
-// impatientInsecureHTTPClient is used in -insecure mode,
+// impatientInsecureHTTPClient is used with GOINSECURE,
 // when we're connecting to https servers that might not be there
 // or might be using self-signed certificates.
 var impatientInsecureHTTPClient = &http.Client{
diff --git a/src/cmd/go/testdata/script/get_404_meta.txt b/src/cmd/go/testdata/script/get_404_meta.txt
index b71cc7fe01..ec4f8d3243 100644
--- a/src/cmd/go/testdata/script/get_404_meta.txt
+++ b/src/cmd/go/testdata/script/get_404_meta.txt
@@ -3,9 +3,10 @@
 [!net] skip
 [!exec:git] skip
 
+env GONOSUMDB=bazil.org,github.com,golang.org
 env GO111MODULE=off
-go get -d -insecure bazil.org/fuse/fs/fstestutil
+go get -d bazil.org/fuse/fs/fstestutil
 
 env GO111MODULE=on
 env GOPROXY=direct
-go get -d -insecure bazil.org/fuse/fs/fstestutil
+go get -d bazil.org/fuse/fs/fstestutil
diff --git a/src/cmd/go/testdata/script/get_insecure.txt b/src/cmd/go/testdata/script/get_insecure.txt
index 36ad2c05b7..69930f7107 100644
--- a/src/cmd/go/testdata/script/get_insecure.txt
+++ b/src/cmd/go/testdata/script/get_insecure.txt
@@ -12,10 +12,12 @@ env GO111MODULE=off
 # GOPATH: Try go get -d of HTTP-only repo (should fail).
 ! go get -d insecure.go-get-issue-15410.appspot.com/pkg/p
 
-# GOPATH: Try again with -insecure (should succeed).
-go get -d -insecure insecure.go-get-issue-15410.appspot.com/pkg/p
+# GOPATH: Try again with GOINSECURE (should succeed).
+env GOINSECURE=insecure.go-get-issue-15410.appspot.com
+go get -d insecure.go-get-issue-15410.appspot.com/pkg/p
 
-# GOPATH: Try updating without -insecure (should fail).
+# GOPATH: Try updating without GOINSECURE (should fail).
+env GOINSECURE=''
 ! go get -d -u -f insecure.go-get-issue-15410.appspot.com/pkg/p
 
 # Modules: Set up
@@ -29,10 +31,14 @@ env GOPROXY=''
 # Modules: Try go get -d of HTTP-only repo (should fail).
 ! go get -d insecure.go-get-issue-15410.appspot.com/pkg/p
 
-# Modules: Try again with -insecure (should succeed).
-go get -d -insecure insecure.go-get-issue-15410.appspot.com/pkg/p
+# Modules: Try again with GOINSECURE (should succeed).
+env GOINSECURE=insecure.go-get-issue-15410.appspot.com
+env GONOSUMDB=insecure.go-get-issue-15410.appspot.com
+go get -d insecure.go-get-issue-15410.appspot.com/pkg/p
 
-# Modules: Try updating without -insecure (should fail).
+# Modules: Try updating without GOINSECURE (should fail).
+env GOINSECURE=''
+env GONOSUMDB=''
 ! go get -d -u -f insecure.go-get-issue-15410.appspot.com/pkg/p
 
 go list -m ...
@@ -48,4 +54,4 @@ func main() {
 	os.Exit(1)
 }
 -- module_file --
-module m
\ No newline at end of file
+module m
diff --git a/src/cmd/go/testdata/script/get_insecure_custom_domain.txt b/src/cmd/go/testdata/script/get_insecure_custom_domain.txt
index a4a6fd428f..7eba42e873 100644
--- a/src/cmd/go/testdata/script/get_insecure_custom_domain.txt
+++ b/src/cmd/go/testdata/script/get_insecure_custom_domain.txt
@@ -3,4 +3,6 @@
 env GO111MODULE=off
 
 ! go get -d insecure.go-get-issue-15410.appspot.com/pkg/p
-go get -d -insecure insecure.go-get-issue-15410.appspot.com/pkg/p
+
+env GOINSECURE=insecure.go-get-issue-15410.appspot.com
+go get -d insecure.go-get-issue-15410.appspot.com/pkg/p
diff --git a/src/cmd/go/testdata/script/get_insecure_deprecated.txt b/src/cmd/go/testdata/script/get_insecure_deprecated.txt
deleted file mode 100644
index 7f5f5c7877..0000000000
--- a/src/cmd/go/testdata/script/get_insecure_deprecated.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-# GOPATH: Set up
-env GO111MODULE=off
-
-# GOPATH: Fetch without insecure, no warning
-! go get test
-! stderr 'go get: -insecure flag is deprecated; see ''go help get'' for details'
-
-# GOPATH: Fetch with insecure, should warn
-! go get -insecure test
-stderr 'go get: -insecure flag is deprecated; see ''go help get'' for details'
-
-# Modules: Set up
-env GO111MODULE=on
-
-# Modules: Fetch without insecure, no warning
-! go get test
-! stderr 'go get: -insecure flag is deprecated; see ''go help get'' for details'
-
-# Modules: Fetch with insecure, should warn
-! go get -insecure test
-stderr 'go get: -insecure flag is deprecated; see ''go help get'' for details'
diff --git a/src/cmd/go/testdata/script/get_insecure_no_longer_supported.txt b/src/cmd/go/testdata/script/get_insecure_no_longer_supported.txt
new file mode 100644
index 0000000000..2517664dd0
--- /dev/null
+++ b/src/cmd/go/testdata/script/get_insecure_no_longer_supported.txt
@@ -0,0 +1,13 @@
+# GOPATH: Set up
+env GO111MODULE=off
+
+# GOPATH: Fetch with insecure, should error
+! go get -insecure test
+stderr 'go get: -insecure flag is no longer supported; use GOINSECURE instead'
+
+# Modules: Set up
+env GO111MODULE=on
+
+# Modules: Fetch with insecure, should error
+! go get -insecure test
+stderr 'go get: -insecure flag is no longer supported; use GOINSECURE instead'
diff --git a/src/cmd/go/testdata/script/get_insecure_redirect.txt b/src/cmd/go/testdata/script/get_insecure_redirect.txt
index 0478d1f75d..fb5f26951c 100644
--- a/src/cmd/go/testdata/script/get_insecure_redirect.txt
+++ b/src/cmd/go/testdata/script/get_insecure_redirect.txt
@@ -1,4 +1,4 @@
-# golang.org/issue/29591: 'go get' was following plain-HTTP redirects even without -insecure.
+# golang.org/issue/29591: 'go get' was following plain-HTTP redirects even without -insecure (now replaced by GOINSECURE).
 # golang.org/issue/34049: 'go get' would panic in case of an insecure redirect in GOPATH mode
 
 [!net] skip
@@ -9,4 +9,5 @@ env GO111MODULE=off
 ! go get -d vcs-test.golang.org/insecure/go/insecure
 stderr 'redirected .* to insecure URL'
 
-go get -d -insecure vcs-test.golang.org/insecure/go/insecure
+env GOINSECURE=vcs-test.golang.org/insecure/go/insecure
+go get -d vcs-test.golang.org/insecure/go/insecure
diff --git a/src/cmd/go/testdata/script/get_insecure_update.txt b/src/cmd/go/testdata/script/get_insecure_update.txt
index 4511c98c56..e1a1a23d47 100644
--- a/src/cmd/go/testdata/script/get_insecure_update.txt
+++ b/src/cmd/go/testdata/script/get_insecure_update.txt
@@ -5,8 +5,10 @@ env GO111MODULE=off
 # Clone the repo via HTTP manually.
 exec git clone -q http://github.com/golang/example github.com/golang/example
 
-# Update without -insecure should fail.
-# Update with -insecure should succeed.
+# Update without GOINSECURE should fail.
 # We need -f to ignore import comments.
 ! go get -d -u -f github.com/golang/example/hello
-go get -d -u -f -insecure github.com/golang/example/hello
+
+# Update with GOINSECURE should succeed.
+env GOINSECURE=github.com/golang/example/hello
+go get -d -u -f github.com/golang/example/hello
diff --git a/src/cmd/go/testdata/script/mod_get_insecure_redirect.txt b/src/cmd/go/testdata/script/mod_get_insecure_redirect.txt
index 3755f17633..2e12834495 100644
--- a/src/cmd/go/testdata/script/mod_get_insecure_redirect.txt
+++ b/src/cmd/go/testdata/script/mod_get_insecure_redirect.txt
@@ -1,4 +1,4 @@
-# golang.org/issue/29591: 'go get' was following plain-HTTP redirects even without -insecure.
+# golang.org/issue/29591: 'go get' was following plain-HTTP redirects even without -insecure (now replaced by GOINSECURE).
 
 [!net] skip
 [!exec:git] skip
@@ -10,8 +10,6 @@ env GOSUMDB=off
 ! go get -d vcs-test.golang.org/insecure/go/insecure
 stderr 'redirected .* to insecure URL'
 
-go get -d -insecure vcs-test.golang.org/insecure/go/insecure
-
 # insecure host
 env GOINSECURE=vcs-test.golang.org
 go clean -modcache
diff --git a/src/cmd/go/testdata/script/mod_sumdb_cache.txt b/src/cmd/go/testdata/script/mod_sumdb_cache.txt
index 2937b2e4dc..1b38475fb5 100644
--- a/src/cmd/go/testdata/script/mod_sumdb_cache.txt
+++ b/src/cmd/go/testdata/script/mod_sumdb_cache.txt
@@ -43,12 +43,5 @@ env GOPROXY=$proxy/sumdb-504
 ! go get -d rsc.io/quote@v1.5.2
 stderr 504
 
-# but -insecure bypasses the checksum lookup entirely
-env GOINSECURE=
-go get -d -insecure rsc.io/quote@v1.5.2
-
-# and then it is in go.sum again
-go get -d rsc.io/quote@v1.5.2
-
 -- go.mod.orig --
 module m
-- 
GitLab


From aea1259a7288d71736273b494e60bd424ea1946c Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Sun, 28 Feb 2021 21:48:20 -0500
Subject: [PATCH 0894/2400] cmd/link: disable flaky Darwin "symbols" test

About one run out of 3 it fails on my laptop, and
I am tired of having to be a nanny for my tests just
because of this one flaky test.  This has been a problem
for months.

Updates #32218.

Change-Id: I2871d4c6f47e9432d189ed7bdcda8f9c0871cfc5
Reviewed-on: https://go-review.googlesource.com/c/go/+/297469
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/link/dwarf_test.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/cmd/link/dwarf_test.go b/src/cmd/link/dwarf_test.go
index db710bed6a..d0284ad4f5 100644
--- a/src/cmd/link/dwarf_test.go
+++ b/src/cmd/link/dwarf_test.go
@@ -91,7 +91,8 @@ func testDWARF(t *testing.T, buildmode string, expectDWARF bool, env ...string)
 				exe = filepath.Join(tmpDir, "go.o")
 			}
 
-			if runtime.GOOS == "darwin" {
+			darwinSymbolTestIsTooFlaky := true // Turn this off, it is too flaky -- See #32218
+			if runtime.GOOS == "darwin" && !darwinSymbolTestIsTooFlaky {
 				if _, err = exec.LookPath("symbols"); err == nil {
 					// Ensure Apple's tooling can parse our object for symbols.
 					out, err = exec.Command("symbols", exe).CombinedOutput()
-- 
GitLab


From 77973863c351b162d68723439fc56fb054e917b2 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Tue, 9 Feb 2021 15:14:43 -0500
Subject: [PATCH 0895/2400] cmd/compile: use abiutils for all rcvr/in/out frame
 offsets.

types thought it knew how to do this, but that's a lie, because types
doesn't know what the ABI is.

includes extra checking to help prevent things from accidentally working
if they need to be changed but aren't.

For #40724.

Change-Id: I166cd948f262344b7bebde6a2c25e7a7f878bbfb
Reviewed-on: https://go-review.googlesource.com/c/go/+/293393
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/abi/abiutils.go      | 33 ++++++++----
 src/cmd/compile/internal/ir/expr.go           |  8 +--
 src/cmd/compile/internal/ssa/expand_calls.go  | 31 ++++++++---
 src/cmd/compile/internal/ssa/op.go            | 40 +++------------
 src/cmd/compile/internal/ssagen/ssa.go        | 51 ++++++++++---------
 .../compile/internal/typecheck/typecheck.go   |  2 +-
 src/cmd/compile/internal/types/size.go        |  6 ++-
 src/cmd/compile/internal/types/type.go        | 16 +++++-
 src/cmd/compile/internal/walk/assign.go       |  2 +-
 9 files changed, 107 insertions(+), 82 deletions(-)

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index a5c85a89fb..8549c0325d 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -151,6 +151,13 @@ func (a *ABIConfig) Copy() *ABIConfig {
 	return &b
 }
 
+// LocalsOffset returns the architecture-dependent offset from SP for args and results.
+// In theory this is only used for debugging; it ought to already be incorporated into
+// results from the ABI-related methods
+func (a *ABIConfig) LocalsOffset() int64 {
+	return a.offsetForLocals
+}
+
 // NumParamRegs returns the number of parameter registers used for a given type,
 // without regard for the number available.
 func (a *ABIConfig) NumParamRegs(t *types.Type) int {
@@ -237,23 +244,22 @@ func (config *ABIConfig) ABIAnalyzeTypes(rcvr *types.Type, ins, outs []*types.Ty
 	return result
 }
 
-// ABIAnalyze takes a function type 't' and an ABI rules description
+// ABIAnalyzeFuncType takes a function type 'ft' and an ABI rules description
 // 'config' and analyzes the function to determine how its parameters
 // and results will be passed (in registers or on the stack), returning
 // an ABIParamResultInfo object that holds the results of the analysis.
-func (config *ABIConfig) ABIAnalyze(t *types.Type) *ABIParamResultInfo {
+func (config *ABIConfig) ABIAnalyzeFuncType(ft *types.Func) *ABIParamResultInfo {
 	setup()
 	s := assignState{
 		stackOffset: config.offsetForLocals,
 		rTotal:      config.regAmounts,
 	}
 	result := &ABIParamResultInfo{config: config}
-	ft := t.FuncType()
-	result.preAllocateParams(t.NumRecvs() != 0, ft.Params.NumFields(), ft.Results.NumFields())
+	result.preAllocateParams(ft.Receiver != nil, ft.Params.NumFields(), ft.Results.NumFields())
 
 	// Receiver
 	// TODO(register args) ? seems like "struct" and "fields" is not right anymore for describing function parameters
-	if t.NumRecvs() != 0 {
+	if ft.Receiver != nil && ft.Receiver.NumFields() != 0 {
 		r := ft.Receiver.FieldSlice()[0]
 		result.inparams = append(result.inparams,
 			s.assignParamOrReturn(r.Type, r.Nname, false))
@@ -279,7 +285,14 @@ func (config *ABIConfig) ABIAnalyze(t *types.Type) *ABIParamResultInfo {
 	result.offsetToSpillArea = alignTo(s.stackOffset, types.RegSize)
 	result.spillAreaSize = alignTo(s.spillOffset, types.RegSize)
 	result.outRegistersUsed = s.rUsed.intRegs + s.rUsed.floatRegs
+	return result
+}
 
+// ABIAnalyze returns the same result as ABIAnalyzeFuncType, but also
+// updates the offsets of all the receiver, input, and output fields.
+func (config *ABIConfig) ABIAnalyze(t *types.Type) *ABIParamResultInfo {
+	ft := t.FuncType()
+	result := config.ABIAnalyzeFuncType(ft)
 	// Fill in the frame offsets for receiver, inputs, results
 	k := 0
 	if t.NumRecvs() != 0 {
@@ -296,13 +309,11 @@ func (config *ABIConfig) ABIAnalyze(t *types.Type) *ABIParamResultInfo {
 }
 
 func (config *ABIConfig) updateOffset(result *ABIParamResultInfo, f *types.Field, a ABIParamAssignment, isReturn bool) {
+	// Everything except return values in registers has either a frame home (if not in a register) or a frame spill location.
 	if !isReturn || len(a.Registers) == 0 {
-		// TODO in next CL, assign
-		if f.Offset+config.offsetForLocals != a.FrameOffset(result) {
-			if config.regAmounts.intRegs == 0 && config.regAmounts.floatRegs == 0 {
-				panic(fmt.Errorf("Expected node offset %d != abi offset %d", f.Offset, a.FrameOffset(result)))
-			}
-		}
+		// The type frame offset DOES NOT show effects of minimum frame size.
+		// Getting this wrong breaks stackmaps, see liveness/plive.go:WriteFuncMap and typebits/typebits.go:Set
+		f.Offset = a.FrameOffset(result)-config.LocalsOffset()
 	}
 }
 
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index d68bcfe60c..65ed3cff66 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -447,14 +447,14 @@ func (n *ParenExpr) SetOTYPE(t *types.Type) {
 	t.SetNod(n)
 }
 
-// A ResultExpr represents a direct access to a result slot on the stack frame.
+// A ResultExpr represents a direct access to a result.
 type ResultExpr struct {
 	miniExpr
-	Offset int64
+	Index int64 // index of the result expr.
 }
 
-func NewResultExpr(pos src.XPos, typ *types.Type, offset int64) *ResultExpr {
-	n := &ResultExpr{Offset: offset}
+func NewResultExpr(pos src.XPos, typ *types.Type, index int64) *ResultExpr {
+	n := &ResultExpr{Index: index}
 	n.pos = pos
 	n.op = ORESULT
 	n.typ = typ
diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index 292b0b41ce..741d59258b 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -32,6 +32,10 @@ func isBlockMultiValueExit(b *Block) bool {
 	return (b.Kind == BlockRet || b.Kind == BlockRetJmp) && len(b.Controls) > 0 && b.Controls[0].Op == OpMakeResult
 }
 
+func badVal(s string, v *Value) error {
+	return fmt.Errorf("%s %s", s, v.LongString())
+}
+
 // removeTrivialWrapperTypes unwraps layers of
 // struct { singleField SomeType } and [1]SomeType
 // until a non-wrapper type is reached.  This is useful
@@ -231,6 +235,9 @@ func (x *expandState) splitSlots(ls []LocalSlot, sfx string, offset int64, ty *t
 
 // prAssignForArg returns the ABIParamAssignment for v, assumed to be an OpArg.
 func (x *expandState) prAssignForArg(v *Value) abi.ABIParamAssignment {
+	if v.Op != OpArg {
+		panic(badVal("Wanted OpArg, instead saw", v))
+	}
 	name := v.Aux.(*ir.Name)
 	fPri := x.f.OwnAux.abiInfo
 	for _, a := range fPri.InParams() {
@@ -275,9 +282,6 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64,
 	}
 	switch selector.Op {
 	case OpArg:
-		paramAssignment := x.prAssignForArg(selector)
-		_ = paramAssignment
-		// TODO(register args)
 		if !x.isAlreadyExpandedAggregateType(selector.Type) {
 			if leafType == selector.Type { // OpIData leads us here, sometimes.
 				leaf.copyOf(selector)
@@ -364,7 +368,7 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64,
 				// StaticCall selector will address last element of Result.
 				// TODO do this for all the other call types eventually.
 				if aux.abiInfo == nil {
-					panic(fmt.Errorf("aux.abiInfo nil for call %s", call.LongString()))
+					panic(badVal("aux.abiInfo nil for call", call))
 				}
 				if existing := x.memForCall[call.ID]; existing == nil {
 					selector.AuxInt = int64(aux.abiInfo.OutRegistersUsed())
@@ -566,9 +570,6 @@ func (x *expandState) decomposeArgOrLoad(pos src.XPos, b *Block, base, source, m
 // pos and b locate the store instruction, base is the base of the store target, source is the "base" of the value input,
 // mem is the input mem, t is the type in question, and offArg and offStore are the offsets from the respective bases.
 func storeOneArg(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
-	paramAssignment := x.prAssignForArg(source)
-	_ = paramAssignment
-	// TODO(register args)
 	w := x.common[selKey{source, offArg, t.Width, t}]
 	if w == nil {
 		w = source.Block.NewValue0IA(source.Pos, OpArg, t, offArg, source.Aux)
@@ -1198,10 +1199,24 @@ func expandCalls(f *Func) {
 
 	deleteNamedVals(f, toDelete)
 
-	// Step 4: rewrite the calls themselves, correcting the type
+	// Step 4: rewrite the calls themselves, correcting the type.
 	for _, b := range f.Blocks {
 		for _, v := range b.Values {
 			switch v.Op {
+			case OpArg:
+				pa := x.prAssignForArg(v)
+				switch len(pa.Registers) {
+				case 0:
+					frameOff := v.Aux.(*ir.Name).FrameOffset()
+					if pa.Offset() != int32(frameOff+x.f.ABISelf.LocalsOffset()) {
+						panic(fmt.Errorf("Parameter assignment %d and OpArg.Aux frameOffset %d disagree, op=%s\n",
+							pa.Offset(), frameOff, v.LongString()))
+					}
+				case 1:
+				default:
+					panic(badVal("Saw unexpeanded OpArg", v))
+				}
+
 			case OpStaticLECall:
 				v.Op = OpStaticCall
 				// TODO need to insert all the register types.
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index 6d2ca96293..506c745f7c 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -86,63 +86,39 @@ type AuxCall struct {
 	abiInfo *abi.ABIParamResultInfo // TODO remove fields above redundant with this information.
 }
 
-// ResultForOffsetAndType returns the index of a t-typed result at *A* particular offset among the results.
-// An arbitrary number of zero-width-typed results may reside at the same offset with a single not-zero-width
-// typed result, but the ones with the same type are all indistinguishable so it doesn't matter "which one"
-// is obtained.
-// This does not include the mem result for the call opcode.
-func (a *AuxCall) ResultForOffsetAndType(offset int64, t *types.Type) int64 {
-	which := int64(-1)
-	for i := int64(0); i < a.NResults(); i++ { // note aux NResults does not include mem result.
-		if a.OffsetOfResult(i) == offset && a.TypeOfResult(i) == t {
-			which = i
-			break
-		}
-	}
-	return which
-}
-
 // OffsetOfResult returns the SP offset of result which (indexed 0, 1, etc).
 func (a *AuxCall) OffsetOfResult(which int64) int64 {
-	o := int64(a.results[which].Offset)
 	n := int64(a.abiInfo.OutParam(int(which)).Offset())
-	if o != n {
-		panic(fmt.Errorf("Result old=%d, new=%d, auxcall=%s, oparams=%v", o, n, a, a.abiInfo.OutParams()))
-	}
-	return int64(a.abiInfo.OutParam(int(which)).Offset())
+	return n
 }
 
 // OffsetOfArg returns the SP offset of argument which (indexed 0, 1, etc).
 // If the call is to a method, the receiver is the first argument (i.e., index 0)
 func (a *AuxCall) OffsetOfArg(which int64) int64 {
-	o := int64(a.args[which].Offset)
 	n := int64(a.abiInfo.InParam(int(which)).Offset())
-	if o != n {
-		panic(fmt.Errorf("Arg old=%d, new=%d, auxcall=%s, iparams=%v", o, n, a, a.abiInfo.InParams()))
-	}
-	return int64(a.abiInfo.InParam(int(which)).Offset())
+	return n
 }
 
 // RegsOfResult returns the register(s) used for result which (indexed 0, 1, etc).
 func (a *AuxCall) RegsOfResult(which int64) []abi.RegIndex {
-	return a.results[which].Reg
+	return a.abiInfo.OutParam(int(which)).Registers
 }
 
 // RegsOfArg returns the register(s) used for argument which (indexed 0, 1, etc).
 // If the call is to a method, the receiver is the first argument (i.e., index 0)
 func (a *AuxCall) RegsOfArg(which int64) []abi.RegIndex {
-	return a.args[which].Reg
+	return a.abiInfo.InParam(int(which)).Registers
 }
 
 // TypeOfResult returns the type of result which (indexed 0, 1, etc).
 func (a *AuxCall) TypeOfResult(which int64) *types.Type {
-	return a.results[which].Type
+	return a.abiInfo.OutParam(int(which)).Type
 }
 
 // TypeOfArg returns the type of argument which (indexed 0, 1, etc).
 // If the call is to a method, the receiver is the first argument (i.e., index 0)
 func (a *AuxCall) TypeOfArg(which int64) *types.Type {
-	return a.args[which].Type
+	return a.abiInfo.InParam(int(which)).Type
 }
 
 // SizeOfResult returns the size of result which (indexed 0, 1, etc).
@@ -158,7 +134,7 @@ func (a *AuxCall) SizeOfArg(which int64) int64 {
 
 // NResults returns the number of results
 func (a *AuxCall) NResults() int64 {
-	return int64(len(a.results))
+	return int64(len(a.abiInfo.OutParams()))
 }
 
 // LateExpansionResultType returns the result type (including trailing mem)
@@ -174,7 +150,7 @@ func (a *AuxCall) LateExpansionResultType() *types.Type {
 
 // NArgs returns the number of arguments (including receiver, if there is one).
 func (a *AuxCall) NArgs() int64 {
-	return int64(len(a.args))
+	return int64(len(a.abiInfo.InParams()))
 }
 
 // String returns
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 938c1e8b62..210150d872 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -301,7 +301,7 @@ func (s *state) emitOpenDeferInfo() {
 	var maxargsize int64
 	for i := len(s.openDefers) - 1; i >= 0; i-- {
 		r := s.openDefers[i]
-		argsize := r.n.X.Type().ArgWidth()
+		argsize := r.n.X.Type().ArgWidth() // TODO register args: but maybe use of abi0 will make this easy
 		if argsize > maxargsize {
 			maxargsize = argsize
 		}
@@ -324,19 +324,30 @@ func (s *state) emitOpenDeferInfo() {
 		}
 		off = dvarint(x, off, int64(numArgs))
 		if r.rcvrNode != nil {
-			off = dvarint(x, off, -r.rcvrNode.FrameOffset())
+			off = dvarint(x, off, -okOffset(r.rcvrNode.FrameOffset()))
 			off = dvarint(x, off, s.config.PtrSize)
-			off = dvarint(x, off, 0)
+			off = dvarint(x, off, 0) // This is okay because defer records use ABI0 (for now)
 		}
+
+		// TODO(register args) assume abi0 for this?
+		ab := s.f.ABI0
+		pri := ab.ABIAnalyzeFuncType(r.n.X.Type().FuncType())
 		for j, arg := range r.argNodes {
 			f := getParam(r.n, j)
-			off = dvarint(x, off, -arg.FrameOffset())
+			off = dvarint(x, off, -okOffset(arg.FrameOffset()))
 			off = dvarint(x, off, f.Type.Size())
-			off = dvarint(x, off, f.Offset)
+			off = dvarint(x, off, okOffset(pri.InParam(j).FrameOffset(pri))-ab.LocalsOffset()) // defer does not want the fixed frame adjustment
 		}
 	}
 }
 
+func okOffset(offset int64) int64 {
+	if offset >= types.BOGUS_FUNARG_OFFSET {
+		panic(fmt.Errorf("Bogus offset %d", offset))
+	}
+	return offset
+}
+
 // buildssa builds an SSA function for fn.
 // worker indicates which of the backend workers is doing the processing.
 func buildssa(fn *ir.Func, worker int) *ssa.Func {
@@ -528,7 +539,13 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 	// Populate SSAable arguments.
 	for _, n := range fn.Dcl {
 		if n.Class == ir.PPARAM && s.canSSA(n) {
-			v := s.newValue0A(ssa.OpArg, n.Type(), n)
+			var v *ssa.Value
+			if n.Sym().Name == ".fp" {
+				// Race-detector's get-caller-pc incantation is NOT a real Arg.
+				v = s.newValue0(ssa.OpGetCallerPC, n.Type())
+			} else {
+				v = s.newValue0A(ssa.OpArg, n.Type(), n)
+			}
 			s.vars[n] = v
 			s.addNamedValue(n, v) // This helps with debugging information, not needed for compilation itself.
 		}
@@ -2917,15 +2934,11 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 	case ir.ORESULT:
 		n := n.(*ir.ResultExpr)
 		if s.prevCall == nil || s.prevCall.Op != ssa.OpStaticLECall && s.prevCall.Op != ssa.OpInterLECall && s.prevCall.Op != ssa.OpClosureLECall {
-			// Do the old thing
-			addr := s.constOffPtrSP(types.NewPtr(n.Type()), n.Offset)
-			return s.rawLoad(n.Type(), addr)
+			panic("Expected to see a previous call")
 		}
-		which := s.prevCall.Aux.(*ssa.AuxCall).ResultForOffsetAndType(n.Offset, n.Type())
+		which := n.Index
 		if which == -1 {
-			// Do the old thing // TODO: Panic instead.
-			addr := s.constOffPtrSP(types.NewPtr(n.Type()), n.Offset)
-			return s.rawLoad(n.Type(), addr)
+			panic(fmt.Errorf("ORESULT %v does not match call %s", n, s.prevCall))
 		}
 		if TypeOK(n.Type()) {
 			return s.newValue1I(ssa.OpSelectN, n.Type(), which, s.prevCall)
@@ -4889,7 +4902,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 
 		// Then, store all the arguments of the defer call.
 		ft := fn.Type()
-		off := t.FieldOff(12)
+		off := t.FieldOff(12) // TODO register args: be sure this isn't a hardcoded param stack offset.
 		args := n.Args
 
 		// Set receiver (for interface calls). Always a pointer.
@@ -5131,15 +5144,7 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 	case ir.ORESULT:
 		// load return from callee
 		n := n.(*ir.ResultExpr)
-		if s.prevCall == nil || s.prevCall.Op != ssa.OpStaticLECall && s.prevCall.Op != ssa.OpInterLECall && s.prevCall.Op != ssa.OpClosureLECall {
-			return s.constOffPtrSP(t, n.Offset)
-		}
-		which := s.prevCall.Aux.(*ssa.AuxCall).ResultForOffsetAndType(n.Offset, n.Type())
-		if which == -1 {
-			// Do the old thing // TODO: Panic instead.
-			return s.constOffPtrSP(t, n.Offset)
-		}
-		x := s.newValue1I(ssa.OpSelectNAddr, t, which, s.prevCall)
+		x := s.newValue1I(ssa.OpSelectNAddr, t, n.Index, s.prevCall)
 		return x
 
 	case ir.OINDEX:
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index cb434578dd..5a3446b358 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -1175,7 +1175,7 @@ func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 			base.Errorf("%v is both field and method", n.Sel)
 		}
 		if f1.Offset == types.BADWIDTH {
-			base.Fatalf("lookdot badwidth %v %p", f1, f1)
+			base.Fatalf("lookdot badwidth t=%v, f1=%v@%p", t, f1, f1)
 		}
 		n.Selection = f1
 		n.SetType(f1.Type)
diff --git a/src/cmd/compile/internal/types/size.go b/src/cmd/compile/internal/types/size.go
index 799cf3a1f6..4c7378560c 100644
--- a/src/cmd/compile/internal/types/size.go
+++ b/src/cmd/compile/internal/types/size.go
@@ -141,6 +141,8 @@ func expandiface(t *Type) {
 }
 
 func calcStructOffset(errtype *Type, t *Type, o int64, flag int) int64 {
+	// flag is 0 (receiver), 1 (actual struct), or RegSize (in/out parameters)
+	isStruct := flag == 1
 	starto := o
 	maxalign := int32(flag)
 	if maxalign < 1 {
@@ -161,7 +163,9 @@ func calcStructOffset(errtype *Type, t *Type, o int64, flag int) int64 {
 		if f.Type.Align > 0 {
 			o = Rnd(o, int64(f.Type.Align))
 		}
-		f.Offset = o
+		if isStruct { // For receiver/args/results, depends on ABI
+			f.Offset = o
+		}
 		if f.Nname != nil {
 			// addrescapes has similar code to update these offsets.
 			// Usually addrescapes runs after calcStructOffset,
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 9fb6d68994..b0516a8259 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -411,7 +411,8 @@ type Field struct {
 	Nname Object
 
 	// Offset in bytes of this field or method within its enclosing struct
-	// or interface Type.
+	// or interface Type.  Exception: if field is function receiver, arg or
+	// result, then this is BOGUS_FUNARG_OFFSET; types does not know the Abi.
 	Offset int64
 }
 
@@ -1719,6 +1720,14 @@ func NewTypeParam(pkg *Pkg, constraint *Type) *Type {
 	return t
 }
 
+const BOGUS_FUNARG_OFFSET = 1000000000
+
+func unzeroFieldOffsets(f []*Field) {
+	for i := range f {
+		f[i].Offset = BOGUS_FUNARG_OFFSET // This will cause an explosion if it is not corrected
+	}
+}
+
 // NewSignature returns a new function type for the given receiver,
 // parametes, results, and type parameters, any of which may be nil.
 func NewSignature(pkg *Pkg, recv *Field, tparams, params, results []*Field) *Type {
@@ -1739,6 +1748,11 @@ func NewSignature(pkg *Pkg, recv *Field, tparams, params, results []*Field) *Typ
 		return s
 	}
 
+	if recv != nil {
+		recv.Offset = BOGUS_FUNARG_OFFSET
+	}
+	unzeroFieldOffsets(params)
+	unzeroFieldOffsets(results)
 	ft.Receiver = funargs(recvs, FunargRcvr)
 	ft.TParams = funargs(tparams, FunargTparams)
 	ft.Params = funargs(params, FunargParams)
diff --git a/src/cmd/compile/internal/walk/assign.go b/src/cmd/compile/internal/walk/assign.go
index 230b544148..44622c741d 100644
--- a/src/cmd/compile/internal/walk/assign.go
+++ b/src/cmd/compile/internal/walk/assign.go
@@ -270,7 +270,7 @@ func ascompatet(nl ir.Nodes, nr *types.Type) []ir.Node {
 		}
 
 		res := ir.NewResultExpr(base.Pos, nil, types.BADWIDTH)
-		res.Offset = base.Ctxt.FixedFrameSize() + r.Offset
+		res.Index = int64(i)
 		res.SetType(r.Type)
 		res.SetTypecheck(1)
 
-- 
GitLab


From 84ca4949a71554265b3c8a99359a5fad6ca0cab1 Mon Sep 17 00:00:00 2001
From: eric fang <eric.fang@arm.com>
Date: Tue, 2 Mar 2021 06:08:51 +0000
Subject: [PATCH 0896/2400] cmd/compile: remove 8-byte alignment requirement of
 stack slot on mips64

This CL applies CL 267999 to mips64.

Updates #42385

Change-Id: Ideab21be0d8c1a36b3be7411b24adac70a3d16e0
Reviewed-on: https://go-review.googlesource.com/c/go/+/297771
Reviewed-by: eric fang <eric.fang@arm.com>
Reviewed-by: Keith Randall <khr@golang.org>
Trust: eric fang <eric.fang@arm.com>
Run-TryBot: eric fang <eric.fang@arm.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ssagen/pgen.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ssagen/pgen.go b/src/cmd/compile/internal/ssagen/pgen.go
index 25b09e1f5d..717f1118f6 100644
--- a/src/cmd/compile/internal/ssagen/pgen.go
+++ b/src/cmd/compile/internal/ssagen/pgen.go
@@ -138,7 +138,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 		} else {
 			lastHasPtr = false
 		}
-		if Arch.LinkArch.InFamily(sys.MIPS, sys.MIPS64, sys.ARM, sys.ARM64, sys.PPC64, sys.S390X) {
+		if Arch.LinkArch.InFamily(sys.MIPS, sys.ARM, sys.ARM64, sys.PPC64, sys.S390X) {
 			s.stksize = types.Rnd(s.stksize, int64(types.PtrSize))
 		}
 		n.SetFrameOffset(-s.stksize)
-- 
GitLab


From 06c72f3627ea749d8579d0d590fd715b2d5e512f Mon Sep 17 00:00:00 2001
From: Baokun Lee <bk@golangcn.org>
Date: Mon, 14 Dec 2020 19:39:02 +0800
Subject: [PATCH 0897/2400] A+C: change email address for Baokun Lee

Change-Id: Ib82e1c8c549c91e20c5aff5e50736617c6831f8c
Reviewed-on: https://go-review.googlesource.com/c/go/+/277792
Run-TryBot: Baokun Lee <bk@golangcn.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Alberto Donizetti <alb.donizetti@gmail.com>
---
 AUTHORS      | 2 +-
 CONTRIBUTORS | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/AUTHORS b/AUTHORS
index 4828ba36cc..eb05706811 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -195,7 +195,7 @@ Ayanamist Yang <ayanamist@gmail.com>
 Aymerick Jéhanne <aymerick@jehanne.org>
 Azat Kaumov <kaumov.a.r@gmail.com>
 Baiju Muthukadan <baiju.m.mail@gmail.com>
-Baokun Lee <nototon@gmail.com>
+Baokun Lee <nototon@gmail.com> <bk@golangcn.org>
 Bartosz Grzybowski <melkorm@gmail.com>
 Bastian Ike <bastian.ike@gmail.com>
 Ben Burkert <ben@benburkert.com>
diff --git a/CONTRIBUTORS b/CONTRIBUTORS
index ccbe4627f3..b176a03328 100644
--- a/CONTRIBUTORS
+++ b/CONTRIBUTORS
@@ -321,7 +321,7 @@ Azat Kaumov <kaumov.a.r@gmail.com>
 Baiju Muthukadan <baiju.m.mail@gmail.com>
 Balaram Makam <bmakam.qdt@qualcommdatacenter.com>
 Balazs Lecz <leczb@google.com>
-Baokun Lee <nototon@gmail.com>
+Baokun Lee <nototon@gmail.com> <bk@golangcn.org>
 Barnaby Keene <accounts@southcla.ws>
 Bartosz Grzybowski <melkorm@gmail.com>
 Bartosz Oler <brtsz@google.com>
-- 
GitLab


From f2df1e3c34ceb2225d0df5c9ec92d5dc9e9ba919 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Sat, 13 Feb 2021 10:49:37 -0500
Subject: [PATCH 0898/2400] cmd/compile: retrieve Args from registers

in progress; doesn't fully work until they are also passed on
register on the caller side.

For #40724.

Change-Id: I29a6680e60bdbe9d132782530214f2a2b51fb8f6
Reviewed-on: https://go-review.googlesource.com/c/go/+/293394
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/abi/abiutils.go     |  7 ++++++
 src/cmd/compile/internal/amd64/ssa.go        |  2 ++
 src/cmd/compile/internal/ssa/expand_calls.go | 24 ++++++++++++++++----
 src/cmd/compile/internal/ssa/lower.go        |  6 ++++-
 src/cmd/compile/internal/ssa/regalloc.go     | 23 +++++++++++++++----
 src/cmd/compile/internal/ssa/rewrite.go      |  2 --
 src/cmd/compile/internal/ssa/schedule.go     |  2 +-
 src/cmd/compile/internal/ssagen/ssa.go       | 12 +++++++++-
 8 files changed, 64 insertions(+), 14 deletions(-)

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index 8549c0325d..903cc5205d 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -158,6 +158,13 @@ func (a *ABIConfig) LocalsOffset() int64 {
 	return a.offsetForLocals
 }
 
+// FloatIndexFor translates r into an index in the floating point parameter
+// registers.  If the result is negative, the input index was actually for the
+// integer parameter registers.
+func (a *ABIConfig) FloatIndexFor(r RegIndex) int64 {
+	return int64(r) - int64(a.regAmounts.intRegs)
+}
+
 // NumParamRegs returns the number of parameter registers used for a given type,
 // without regard for the number available.
 func (a *ABIConfig) NumParamRegs(t *types.Type) int {
diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index d83d78f080..3c43a1d41b 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -980,6 +980,8 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
+	case ssa.OpArgIntReg, ssa.OpArgFloatReg:
+		ssagen.CheckArgReg(v)
 	case ssa.OpAMD64LoweredGetClosurePtr:
 		// Closure pointer is DX.
 		ssagen.CheckLoweredGetClosurePtr(v)
diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index 741d59258b..68fb0581f6 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -808,9 +808,9 @@ func (x *expandState) rewriteArgs(v *Value, firstArg int) *Value {
 		}
 		auxI := int64(i - firstArg)
 		aRegs := aux.RegsOfArg(auxI)
-		aOffset := aux.OffsetOfArg(auxI)
 		aType := aux.TypeOfArg(auxI)
 		if a.Op == OpDereference {
+			aOffset := aux.OffsetOfArg(auxI)
 			if a.MemoryArg() != m0 {
 				x.f.Fatalf("Op...LECall and OpDereference have mismatched mem, %s and %s", v.LongString(), a.LongString())
 			}
@@ -821,13 +821,16 @@ func (x *expandState) rewriteArgs(v *Value, firstArg int) *Value {
 			// TODO(register args) this will be more complicated with registers in the picture.
 			mem = x.rewriteDereference(v.Block, x.sp, a, mem, aOffset, aux.SizeOfArg(auxI), aType, pos)
 		} else {
-			if x.debug {
-				fmt.Printf("storeArg %s, %v, %d\n", a.LongString(), aType, aOffset)
-			}
 			var rc registerCursor
 			var result *[]*Value
+			var aOffset int64
 			if len(aRegs) > 0 {
 				result = &allResults
+			} else {
+				aOffset = aux.OffsetOfArg(auxI)
+			}
+			if x.debug {
+				fmt.Printf("storeArg %s, %v, %d\n", a.LongString(), aType, aOffset)
 			}
 			rc.init(aRegs, aux.abiInfo, result)
 			mem = x.storeArgOrLoad(pos, v.Block, x.sp, a, mem, aType, aOffset, 0, rc)
@@ -1213,8 +1216,19 @@ func expandCalls(f *Func) {
 							pa.Offset(), frameOff, v.LongString()))
 					}
 				case 1:
+					r := pa.Registers[0]
+					i := f.ABISelf.FloatIndexFor(r)
+					// TODO seems like this has implications for debugging. How does this affect the location?
+					if i >= 0 { // float PR
+						v.Op = OpArgFloatReg
+					} else {
+						v.Op = OpArgIntReg
+						i = int64(r)
+					}
+					v.AuxInt = i
+
 				default:
-					panic(badVal("Saw unexpeanded OpArg", v))
+					panic(badVal("Saw unexpanded OpArg", v))
 				}
 
 			case OpStaticLECall:
diff --git a/src/cmd/compile/internal/ssa/lower.go b/src/cmd/compile/internal/ssa/lower.go
index f6b2bf86a9..bbb80a7a30 100644
--- a/src/cmd/compile/internal/ssa/lower.go
+++ b/src/cmd/compile/internal/ssa/lower.go
@@ -21,8 +21,12 @@ func checkLower(f *Func) {
 				continue // lowered
 			}
 			switch v.Op {
-			case OpSP, OpSB, OpInitMem, OpArg, OpPhi, OpVarDef, OpVarKill, OpVarLive, OpKeepAlive, OpSelect0, OpSelect1, OpSelectN, OpConvert, OpInlMark:
+			case OpSP, OpSB, OpInitMem, OpArg, OpArgIntReg, OpArgFloatReg, OpPhi, OpVarDef, OpVarKill, OpVarLive, OpKeepAlive, OpSelect0, OpSelect1, OpSelectN, OpConvert, OpInlMark:
 				continue // ok not to lower
+			case OpMakeResult:
+				if len(b.Controls) == 1 && b.Controls[0] == v {
+					continue
+				}
 			case OpGetG:
 				if f.Config.hasGReg {
 					// has hardware g register, regalloc takes care of it
diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go
index 99e101281b..74dd70c3d9 100644
--- a/src/cmd/compile/internal/ssa/regalloc.go
+++ b/src/cmd/compile/internal/ssa/regalloc.go
@@ -800,7 +800,8 @@ func (s *regAllocState) compatRegs(t *types.Type) regMask {
 }
 
 // regspec returns the regInfo for operation op.
-func (s *regAllocState) regspec(op Op) regInfo {
+func (s *regAllocState) regspec(v *Value) regInfo {
+	op := v.Op
 	if op == OpConvert {
 		// OpConvert is a generic op, so it doesn't have a
 		// register set in the static table. It can use any
@@ -808,6 +809,20 @@ func (s *regAllocState) regspec(op Op) regInfo {
 		m := s.allocatable & s.f.Config.gpRegMask
 		return regInfo{inputs: []inputInfo{{regs: m}}, outputs: []outputInfo{{regs: m}}}
 	}
+	if op == OpArgIntReg {
+		reg := v.Block.Func.Config.intParamRegs[v.AuxInt8()]
+		return regInfo{outputs: []outputInfo{{regs: 1 << uint(reg)}}}
+	}
+	if op == OpArgFloatReg {
+		reg := v.Block.Func.Config.floatParamRegs[v.AuxInt8()]
+		return regInfo{outputs: []outputInfo{{regs: 1 << uint(reg)}}}
+	}
+	if op.IsCall() {
+		// TODO Panic if not okay
+		if ac, ok := v.Aux.(*AuxCall); ok && ac.reg != nil {
+			return *ac.reg
+		}
+	}
 	return opcodeTable[op].reg
 }
 
@@ -1163,7 +1178,7 @@ func (s *regAllocState) regalloc(f *Func) {
 		for i := len(oldSched) - 1; i >= 0; i-- {
 			v := oldSched[i]
 			prefs := desired.remove(v.ID)
-			regspec := s.regspec(v.Op)
+			regspec := s.regspec(v)
 			desired.clobber(regspec.clobbers)
 			for _, j := range regspec.inputs {
 				if countRegs(j.regs) != 1 {
@@ -1193,7 +1208,7 @@ func (s *regAllocState) regalloc(f *Func) {
 			if s.f.pass.debug > regDebug {
 				fmt.Printf("  processing %s\n", v.LongString())
 			}
-			regspec := s.regspec(v.Op)
+			regspec := s.regspec(v)
 			if v.Op == OpPhi {
 				f.Fatalf("phi %s not at start of block", v)
 			}
@@ -2447,7 +2462,7 @@ func (s *regAllocState) computeLive() {
 					// desired registers back though phi nodes.
 					continue
 				}
-				regspec := s.regspec(v.Op)
+				regspec := s.regspec(v)
 				// Cancel desired registers if they get clobbered.
 				desired.clobber(regspec.clobbers)
 				// Update desired registers if there are any fixed register inputs.
diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go
index 19b97a3ed1..9243000cef 100644
--- a/src/cmd/compile/internal/ssa/rewrite.go
+++ b/src/cmd/compile/internal/ssa/rewrite.go
@@ -795,8 +795,6 @@ func devirtLECall(v *Value, sym *obj.LSym) *Value {
 	v.Op = OpStaticLECall
 	auxcall := v.Aux.(*AuxCall)
 	auxcall.Fn = sym
-	// TODO(register args) this should not be necessary when fully transition to the new register ABI.
-	auxcall.abiInfo = v.Block.Func.ABIDefault.ABIAnalyzeTypes(nil, ACParamsToTypes(auxcall.args), ACParamsToTypes(auxcall.results))
 	v.RemoveArg(0)
 	return v
 }
diff --git a/src/cmd/compile/internal/ssa/schedule.go b/src/cmd/compile/internal/ssa/schedule.go
index 6b34310db7..c987647131 100644
--- a/src/cmd/compile/internal/ssa/schedule.go
+++ b/src/cmd/compile/internal/ssa/schedule.go
@@ -137,7 +137,7 @@ func schedule(f *Func) {
 			case v.Op == OpVarDef:
 				// We want all the vardefs next.
 				score[v.ID] = ScoreVarDef
-			case v.Op == OpArg:
+			case v.Op == OpArg || v.Op == OpArgIntReg || v.Op == OpArgFloatReg:
 				// We want all the args as early as possible, for better debugging.
 				score[v.ID] = ScoreArg
 			case v.Type.IsMemory():
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 210150d872..9088ce333b 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -485,7 +485,8 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 		s.vars[memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, deferBitsTemp, s.mem(), false)
 	}
 
-	params := s.f.ABISelf.ABIAnalyze(fn.Type())
+	var params *abi.ABIParamResultInfo
+	params = s.f.ABISelf.ABIAnalyze(fn.Type())
 
 	// Generate addresses of local declarations
 	s.decladdrs = map[*ir.Name]*ssa.Value{}
@@ -7019,11 +7020,20 @@ func CheckLoweredPhi(v *ssa.Value) {
 // That register contains the closure pointer on closure entry.
 func CheckLoweredGetClosurePtr(v *ssa.Value) {
 	entry := v.Block.Func.Entry
+	// TODO register args: not all the register-producing ops can come first.
 	if entry != v.Block || entry.Values[0] != v {
 		base.Fatalf("in %s, badly placed LoweredGetClosurePtr: %v %v", v.Block.Func.Name, v.Block, v)
 	}
 }
 
+// CheckArgReg ensures that v is in the function's entry block.
+func CheckArgReg(v *ssa.Value) {
+	entry := v.Block.Func.Entry
+	if entry != v.Block {
+		base.Fatalf("in %s, badly placed ArgIReg or ArgFReg: %v %v", v.Block.Func.Name, v.Block, v)
+	}
+}
+
 func AddrAuto(a *obj.Addr, v *ssa.Value) {
 	n, off := ssa.AutoVar(v)
 	a.Type = obj.TYPE_MEM
-- 
GitLab


From 00cb841b83ad157bc21d36daf0626bbcd4af0d57 Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Tue, 7 May 2019 17:56:49 +1000
Subject: [PATCH 0899/2400] syscall: implement rawVforkSyscall for remaining
 linux platforms

This allows the use of CLONE_VFORK and CLONE_VM for fork/exec, preventing
'fork/exec ...: cannot allocate memory' failures from occuring when attempting
to execute commands from a Go process that has a large memory footprint.
Additionally, this should reduce the latency of fork/exec on these platforms.

Fixes #31936

Change-Id: I4e28cf0763173145cacaa5340680dca9ff449305
Reviewed-on: https://go-review.googlesource.com/c/go/+/295849
Trust: Joel Sing <joel@sing.id.au>
Run-TryBot: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/syscall/asm_linux_386.s          | 20 ++++++++++++++++++++
 src/syscall/asm_linux_amd64.s        |  2 +-
 src/syscall/asm_linux_arm.s          | 21 +++++++++++++++++++++
 src/syscall/asm_linux_arm64.s        |  1 -
 src/syscall/asm_linux_mips64x.s      | 20 ++++++++++++++++++++
 src/syscall/asm_linux_mipsx.s        | 17 +++++++++++++++++
 src/syscall/exec_linux.go            |  8 +-------
 src/syscall/syscall_linux_386.go     |  4 +---
 src/syscall/syscall_linux_arm.go     |  4 +---
 src/syscall/syscall_linux_mips64x.go |  4 +---
 src/syscall/syscall_linux_mipsx.go   |  4 +---
 11 files changed, 84 insertions(+), 21 deletions(-)

diff --git a/src/syscall/asm_linux_386.s b/src/syscall/asm_linux_386.s
index 4201f367ba..1c69083118 100644
--- a/src/syscall/asm_linux_386.s
+++ b/src/syscall/asm_linux_386.s
@@ -110,6 +110,26 @@ ok2:
 	MOVL	$0, err+36(FP)
 	RET
 
+// func rawVforkSyscall(trap, a1 uintptr) (r1, err uintptr)
+TEXT ·rawVforkSyscall(SB),NOSPLIT|NOFRAME,$0-16
+	MOVL	trap+0(FP), AX	// syscall entry
+	MOVL	a1+4(FP), BX
+	MOVL	$0, CX
+	MOVL	$0, DX
+	POPL	SI // preserve return address
+	INVOKE_SYSCALL
+	PUSHL	SI
+	CMPL	AX, $0xfffff001
+	JLS	ok
+	MOVL	$-1, r1+8(FP)
+	NEGL	AX
+	MOVL	AX, err+12(FP)
+	RET
+ok:
+	MOVL	AX, r1+8(FP)
+	MOVL	$0, err+12(FP)
+	RET
+
 // func rawSyscallNoError(trap uintptr, a1, a2, a3 uintptr) (r1, r2 uintptr);
 TEXT ·rawSyscallNoError(SB),NOSPLIT,$0-24
 	MOVL	trap+0(FP), AX	// syscall entry
diff --git a/src/syscall/asm_linux_amd64.s b/src/syscall/asm_linux_amd64.s
index ba22179dc2..a9af68d51d 100644
--- a/src/syscall/asm_linux_amd64.s
+++ b/src/syscall/asm_linux_amd64.s
@@ -108,7 +108,7 @@ ok2:
 	RET
 
 // func rawVforkSyscall(trap, a1 uintptr) (r1, err uintptr)
-TEXT ·rawVforkSyscall(SB),NOSPLIT,$0-32
+TEXT ·rawVforkSyscall(SB),NOSPLIT|NOFRAME,$0-32
 	MOVQ	a1+8(FP), DI
 	MOVQ	$0, SI
 	MOVQ	$0, DX
diff --git a/src/syscall/asm_linux_arm.s b/src/syscall/asm_linux_arm.s
index 458e9cce79..6bb4df81a0 100644
--- a/src/syscall/asm_linux_arm.s
+++ b/src/syscall/asm_linux_arm.s
@@ -154,6 +154,27 @@ ok1:
 	MOVW	R0, err+24(FP)
 	RET
 
+// func rawVforkSyscall(trap, a1 uintptr) (r1, err uintptr)
+TEXT ·rawVforkSyscall(SB),NOSPLIT|NOFRAME,$0-16
+	MOVW	trap+0(FP), R7	// syscall entry
+	MOVW	a1+4(FP), R0
+	MOVW	$0, R1
+	MOVW	$0, R2
+	SWI	$0
+	MOVW	$0xfffff001, R1
+	CMP	R1, R0
+	BLS	ok
+	MOVW	$-1, R1
+	MOVW	R1, r1+8(FP)
+	RSB	$0, R0, R0
+	MOVW	R0, err+12(FP)
+	RET
+ok:
+	MOVW	R0, r1+8(FP)
+	MOVW	$0, R0
+	MOVW	R0, err+12(FP)
+	RET
+
 // func rawSyscallNoError(trap uintptr, a1, a2, a3 uintptr) (r1, r2 uintptr);
 TEXT ·rawSyscallNoError(SB),NOSPLIT,$0-24
 	MOVW	trap+0(FP), R7	// syscall entry
diff --git a/src/syscall/asm_linux_arm64.s b/src/syscall/asm_linux_arm64.s
index fb22f8d547..a30e4d87d4 100644
--- a/src/syscall/asm_linux_arm64.s
+++ b/src/syscall/asm_linux_arm64.s
@@ -125,7 +125,6 @@ ok:
 	MOVD	ZR, err+24(FP)	// errno
 	RET
 
-
 // func rawSyscallNoError(trap uintptr, a1, a2, a3 uintptr) (r1, r2 uintptr);
 TEXT ·rawSyscallNoError(SB),NOSPLIT,$0-48
 	MOVD	a1+8(FP), R0
diff --git a/src/syscall/asm_linux_mips64x.s b/src/syscall/asm_linux_mips64x.s
index d0b0e5a0a8..b3ae59023d 100644
--- a/src/syscall/asm_linux_mips64x.s
+++ b/src/syscall/asm_linux_mips64x.s
@@ -102,6 +102,26 @@ ok2:
 	MOVV	R0, err+72(FP)	// errno
 	RET
 
+// func rawVforkSyscall(trap, a1 uintptr) (r1, err uintptr)
+TEXT ·rawVforkSyscall(SB),NOSPLIT|NOFRAME,$0-32
+	MOVV	a1+8(FP), R4
+	MOVV	R0, R5
+	MOVV	R0, R6
+	MOVV	R0, R7
+	MOVV	R0, R8
+	MOVV	R0, R9
+	MOVV	trap+0(FP), R2	// syscall entry
+	SYSCALL
+	BEQ	R7, ok
+	MOVV	$-1, R1
+	MOVV	R1, r1+16(FP)	// r1
+	MOVV	R2, err+24(FP)	// errno
+	RET
+ok:
+	MOVV	R2, r1+16(FP)	// r1
+	MOVV	R0, err+24(FP)	// errno
+	RET
+
 TEXT ·rawSyscallNoError(SB),NOSPLIT,$0-48
 	MOVV	a1+8(FP), R4
 	MOVV	a2+16(FP), R5
diff --git a/src/syscall/asm_linux_mipsx.s b/src/syscall/asm_linux_mipsx.s
index 5727e4d41d..ee436490b2 100644
--- a/src/syscall/asm_linux_mipsx.s
+++ b/src/syscall/asm_linux_mipsx.s
@@ -139,6 +139,23 @@ ok2:
 	MOVW	R0, err+36(FP)	// errno
 	RET
 
+// func rawVforkSyscall(trap, a1 uintptr) (r1, err uintptr)
+TEXT ·rawVforkSyscall(SB),NOSPLIT|NOFRAME,$0-16
+	MOVW	a1+4(FP), R4
+	MOVW	R0, R5
+	MOVW	R0, R6
+	MOVW	trap+0(FP), R2	// syscall entry
+	SYSCALL
+	BEQ	R7, ok
+	MOVW	$-1, R1
+	MOVW	R1, r1+8(FP)	// r1
+	MOVW	R2, err+12(FP)	// errno
+	RET
+ok:
+	MOVW	R2, r1+8(FP)	// r1
+	MOVW	R0, err+12(FP)	// errno
+	RET
+
 TEXT ·rawSyscallNoError(SB),NOSPLIT,$20-24
 	MOVW	a1+4(FP), R4
 	MOVW	a2+8(FP), R5
diff --git a/src/syscall/exec_linux.go b/src/syscall/exec_linux.go
index b0099cb4b0..6353da4048 100644
--- a/src/syscall/exec_linux.go
+++ b/src/syscall/exec_linux.go
@@ -208,18 +208,12 @@ func forkAndExecInChild1(argv0 *byte, argv, envv []*byte, chroot, dir *byte, att
 		}
 	}
 
-	var hasRawVforkSyscall bool
-	switch runtime.GOARCH {
-	case "amd64", "arm64", "ppc64", "riscv64", "s390x":
-		hasRawVforkSyscall = true
-	}
-
 	// About to call fork.
 	// No more allocation or calls of non-assembly functions.
 	runtime_BeforeFork()
 	locked = true
 	switch {
-	case hasRawVforkSyscall && (sys.Cloneflags&CLONE_NEWUSER == 0 && sys.Unshareflags&CLONE_NEWUSER == 0):
+	case sys.Cloneflags&CLONE_NEWUSER == 0 && sys.Unshareflags&CLONE_NEWUSER == 0:
 		r1, err1 = rawVforkSyscall(SYS_CLONE, uintptr(SIGCHLD|CLONE_VFORK|CLONE_VM)|sys.Cloneflags)
 	case runtime.GOARCH == "s390x":
 		r1, _, err1 = RawSyscall6(SYS_CLONE, 0, uintptr(SIGCHLD)|sys.Cloneflags, 0, 0, 0, 0)
diff --git a/src/syscall/syscall_linux_386.go b/src/syscall/syscall_linux_386.go
index ed52647403..0db037470d 100644
--- a/src/syscall/syscall_linux_386.go
+++ b/src/syscall/syscall_linux_386.go
@@ -387,6 +387,4 @@ func (cmsg *Cmsghdr) SetLen(length int) {
 	cmsg.Len = uint32(length)
 }
 
-func rawVforkSyscall(trap, a1 uintptr) (r1 uintptr, err Errno) {
-	panic("not implemented")
-}
+func rawVforkSyscall(trap, a1 uintptr) (r1 uintptr, err Errno)
diff --git a/src/syscall/syscall_linux_arm.go b/src/syscall/syscall_linux_arm.go
index 4a3729f898..e887cf788f 100644
--- a/src/syscall/syscall_linux_arm.go
+++ b/src/syscall/syscall_linux_arm.go
@@ -236,6 +236,4 @@ func (cmsg *Cmsghdr) SetLen(length int) {
 	cmsg.Len = uint32(length)
 }
 
-func rawVforkSyscall(trap, a1 uintptr) (r1 uintptr, err Errno) {
-	panic("not implemented")
-}
+func rawVforkSyscall(trap, a1 uintptr) (r1 uintptr, err Errno)
diff --git a/src/syscall/syscall_linux_mips64x.go b/src/syscall/syscall_linux_mips64x.go
index dd51f3d00a..5feb03e915 100644
--- a/src/syscall/syscall_linux_mips64x.go
+++ b/src/syscall/syscall_linux_mips64x.go
@@ -214,6 +214,4 @@ func (cmsg *Cmsghdr) SetLen(length int) {
 	cmsg.Len = uint64(length)
 }
 
-func rawVforkSyscall(trap, a1 uintptr) (r1 uintptr, err Errno) {
-	panic("not implemented")
-}
+func rawVforkSyscall(trap, a1 uintptr) (r1 uintptr, err Errno)
diff --git a/src/syscall/syscall_linux_mipsx.go b/src/syscall/syscall_linux_mipsx.go
index 7894bdd465..39104d71d8 100644
--- a/src/syscall/syscall_linux_mipsx.go
+++ b/src/syscall/syscall_linux_mipsx.go
@@ -224,6 +224,4 @@ func (cmsg *Cmsghdr) SetLen(length int) {
 	cmsg.Len = uint32(length)
 }
 
-func rawVforkSyscall(trap, a1 uintptr) (r1 uintptr, err Errno) {
-	panic("not implemented")
-}
+func rawVforkSyscall(trap, a1 uintptr) (r1 uintptr, err Errno)
-- 
GitLab


From 497feff168b44bdcb645ab0c2a956b0033d6100d Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Sat, 27 Feb 2021 19:07:32 +1100
Subject: [PATCH 0900/2400] cmd/compile: intrinsify
 runtime/internal/atomic.{And,Or}{8,} on RISCV64

The 32 bit versions are easily implement with a single instruction, while the
8 bit versions require a bit more effort but use the same atomic instructions
via rewrite rules.

Change-Id: I42e8d457b239c8f75e39a8e282fc88c1bb292a99
Reviewed-on: https://go-review.googlesource.com/c/go/+/268098
Trust: Joel Sing <joel@sing.id.au>
Run-TryBot: Joel Sing <joel@sing.id.au>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/riscv64/ssa.go       |  8 ++
 .../compile/internal/ssa/gen/RISCV64.rules    | 16 ++++
 .../compile/internal/ssa/gen/RISCV64Ops.go    |  8 +-
 src/cmd/compile/internal/ssa/opGen.go         | 28 +++++++
 .../compile/internal/ssa/rewriteRISCV64.go    | 75 +++++++++++++++++++
 5 files changed, 134 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/riscv64/ssa.go b/src/cmd/compile/internal/riscv64/ssa.go
index 0a3064323a..5576dd4e48 100644
--- a/src/cmd/compile/internal/riscv64/ssa.go
+++ b/src/cmd/compile/internal/riscv64/ssa.go
@@ -510,6 +510,14 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p6 := s.Prog(obj.ANOP)
 		p2.To.SetTarget(p6)
 
+	case ssa.OpRISCV64LoweredAtomicAnd32, ssa.OpRISCV64LoweredAtomicOr32:
+		p := s.Prog(v.Op.Asm())
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = v.Args[1].Reg()
+		p.To.Type = obj.TYPE_MEM
+		p.To.Reg = v.Args[0].Reg()
+		p.RegTo2 = riscv.REG_ZERO
+
 	case ssa.OpRISCV64LoweredZero:
 		mov, sz := largestMove(v.AuxInt)
 
diff --git a/src/cmd/compile/internal/ssa/gen/RISCV64.rules b/src/cmd/compile/internal/ssa/gen/RISCV64.rules
index a11d1e6624..d7efef039e 100644
--- a/src/cmd/compile/internal/ssa/gen/RISCV64.rules
+++ b/src/cmd/compile/internal/ssa/gen/RISCV64.rules
@@ -564,12 +564,28 @@
 (AtomicAdd32 ...) => (LoweredAtomicAdd32 ...)
 (AtomicAdd64 ...) => (LoweredAtomicAdd64 ...)
 
+// AtomicAnd8(ptr,val) => LoweredAtomicAnd32(ptr&^3, ^((uint8(val) ^ 0xff) << ((ptr & 3) * 8)))
+(AtomicAnd8 ptr val mem) =>
+	(LoweredAtomicAnd32 (ANDI <typ.Uintptr> [^3] ptr)
+		(NOT <typ.UInt32> (SLL <typ.UInt32> (XORI <typ.UInt32> [0xff] (ZeroExt8to32 val))
+			(SLLI <typ.UInt64> [3] (ANDI <typ.UInt64> [3] ptr)))) mem)
+
+(AtomicAnd32 ...) => (LoweredAtomicAnd32 ...)
+
 (AtomicCompareAndSwap32 ...) => (LoweredAtomicCas32 ...)
 (AtomicCompareAndSwap64 ...) => (LoweredAtomicCas64 ...)
 
 (AtomicExchange32 ...) => (LoweredAtomicExchange32 ...)
 (AtomicExchange64 ...) => (LoweredAtomicExchange64 ...)
 
+// AtomicOr8(ptr,val)  => LoweredAtomicOr32(ptr&^3, uint32(val)<<((ptr&3)*8))
+(AtomicOr8 ptr val mem) =>
+	(LoweredAtomicOr32 (ANDI <typ.Uintptr> [^3] ptr)
+		(SLL <typ.UInt32> (ZeroExt8to32 val)
+			(SLLI <typ.UInt64> [3] (ANDI <typ.UInt64> [3] ptr))) mem)
+
+(AtomicOr32  ...) => (LoweredAtomicOr32  ...)
+
 // Conditional branches
 (If cond yes no) => (BNEZ cond yes no)
 
diff --git a/src/cmd/compile/internal/ssa/gen/RISCV64Ops.go b/src/cmd/compile/internal/ssa/gen/RISCV64Ops.go
index f64319230b..92a0c3c84c 100644
--- a/src/cmd/compile/internal/ssa/gen/RISCV64Ops.go
+++ b/src/cmd/compile/internal/ssa/gen/RISCV64Ops.go
@@ -126,6 +126,7 @@ func init() {
 		gp11sb   = regInfo{inputs: []regMask{gpspsbMask}, outputs: []regMask{gpMask}}
 		gpxchg   = regInfo{inputs: []regMask{gpspsbgMask, gpgMask}, outputs: []regMask{gpMask}}
 		gpcas    = regInfo{inputs: []regMask{gpspsbgMask, gpgMask, gpgMask}, outputs: []regMask{gpMask}}
+		gpatomic = regInfo{inputs: []regMask{gpspsbgMask, gpgMask}}
 
 		fp11    = regInfo{inputs: []regMask{fpMask}, outputs: []regMask{fpMask}}
 		fp21    = regInfo{inputs: []regMask{fpMask, fpMask}, outputs: []regMask{fpMask}}
@@ -335,7 +336,7 @@ func init() {
 		{name: "LoweredAtomicLoad64", argLength: 2, reg: gpload, faultOnNilArg0: true},
 
 		// Atomic stores.
-		// store arg1 to arg0. arg2=mem. returns memory.
+		// store arg1 to *arg0. arg2=mem. returns memory.
 		{name: "LoweredAtomicStore8", argLength: 3, reg: gpstore, faultOnNilArg0: true, hasSideEffects: true},
 		{name: "LoweredAtomicStore32", argLength: 3, reg: gpstore, faultOnNilArg0: true, hasSideEffects: true},
 		{name: "LoweredAtomicStore64", argLength: 3, reg: gpstore, faultOnNilArg0: true, hasSideEffects: true},
@@ -367,6 +368,11 @@ func init() {
 		{name: "LoweredAtomicCas32", argLength: 4, reg: gpcas, resultNotInArgs: true, faultOnNilArg0: true, hasSideEffects: true, unsafePoint: true},
 		{name: "LoweredAtomicCas64", argLength: 4, reg: gpcas, resultNotInArgs: true, faultOnNilArg0: true, hasSideEffects: true, unsafePoint: true},
 
+		// Atomic 32 bit AND/OR.
+		// *arg0 &= (|=) arg1. arg2=mem. returns nil.
+		{name: "LoweredAtomicAnd32", argLength: 3, reg: gpatomic, asm: "AMOANDW", faultOnNilArg0: true, hasSideEffects: true},
+		{name: "LoweredAtomicOr32", argLength: 3, reg: gpatomic, asm: "AMOORW", faultOnNilArg0: true, hasSideEffects: true},
+
 		// Lowering pass-throughs
 		{name: "LoweredNilCheck", argLength: 2, faultOnNilArg0: true, nilCheck: true, reg: regInfo{inputs: []regMask{gpspMask}}}, // arg0=ptr,arg1=mem, returns void.  Faults if ptr is nil.
 		{name: "LoweredGetClosurePtr", reg: regInfo{outputs: []regMask{regCtxt}}},                                                // scheduler ensures only at beginning of entry block
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index bd9741fe3e..a26eec680f 100644
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -2149,6 +2149,8 @@ const (
 	OpRISCV64LoweredAtomicAdd64
 	OpRISCV64LoweredAtomicCas32
 	OpRISCV64LoweredAtomicCas64
+	OpRISCV64LoweredAtomicAnd32
+	OpRISCV64LoweredAtomicOr32
 	OpRISCV64LoweredNilCheck
 	OpRISCV64LoweredGetClosurePtr
 	OpRISCV64LoweredGetCallerSP
@@ -28722,6 +28724,32 @@ var opcodeTable = [...]opInfo{
 			},
 		},
 	},
+	{
+		name:           "LoweredAtomicAnd32",
+		argLen:         3,
+		faultOnNilArg0: true,
+		hasSideEffects: true,
+		asm:            riscv.AAMOANDW,
+		reg: regInfo{
+			inputs: []inputInfo{
+				{1, 1073741812},          // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 g X28 X29 X30
+				{0, 9223372037928517622}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 g X28 X29 X30 SB
+			},
+		},
+	},
+	{
+		name:           "LoweredAtomicOr32",
+		argLen:         3,
+		faultOnNilArg0: true,
+		hasSideEffects: true,
+		asm:            riscv.AAMOORW,
+		reg: regInfo{
+			inputs: []inputInfo{
+				{1, 1073741812},          // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 g X28 X29 X30
+				{0, 9223372037928517622}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 g X28 X29 X30 SB
+			},
+		},
+	},
 	{
 		name:           "LoweredNilCheck",
 		argLen:         2,
diff --git a/src/cmd/compile/internal/ssa/rewriteRISCV64.go b/src/cmd/compile/internal/ssa/rewriteRISCV64.go
index 36e152bd99..7f77477da7 100644
--- a/src/cmd/compile/internal/ssa/rewriteRISCV64.go
+++ b/src/cmd/compile/internal/ssa/rewriteRISCV64.go
@@ -52,6 +52,11 @@ func rewriteValueRISCV64(v *Value) bool {
 	case OpAtomicAdd64:
 		v.Op = OpRISCV64LoweredAtomicAdd64
 		return true
+	case OpAtomicAnd32:
+		v.Op = OpRISCV64LoweredAtomicAnd32
+		return true
+	case OpAtomicAnd8:
+		return rewriteValueRISCV64_OpAtomicAnd8(v)
 	case OpAtomicCompareAndSwap32:
 		v.Op = OpRISCV64LoweredAtomicCas32
 		return true
@@ -76,6 +81,11 @@ func rewriteValueRISCV64(v *Value) bool {
 	case OpAtomicLoadPtr:
 		v.Op = OpRISCV64LoweredAtomicLoad64
 		return true
+	case OpAtomicOr32:
+		v.Op = OpRISCV64LoweredAtomicOr32
+		return true
+	case OpAtomicOr8:
+		return rewriteValueRISCV64_OpAtomicOr8(v)
 	case OpAtomicStore32:
 		v.Op = OpRISCV64LoweredAtomicStore32
 		return true
@@ -681,6 +691,71 @@ func rewriteValueRISCV64_OpAddr(v *Value) bool {
 		return true
 	}
 }
+func rewriteValueRISCV64_OpAtomicAnd8(v *Value) bool {
+	v_2 := v.Args[2]
+	v_1 := v.Args[1]
+	v_0 := v.Args[0]
+	b := v.Block
+	typ := &b.Func.Config.Types
+	// match: (AtomicAnd8 ptr val mem)
+	// result: (LoweredAtomicAnd32 (ANDI <typ.Uintptr> [^3] ptr) (NOT <typ.UInt32> (SLL <typ.UInt32> (XORI <typ.UInt32> [0xff] (ZeroExt8to32 val)) (SLLI <typ.UInt64> [3] (ANDI <typ.UInt64> [3] ptr)))) mem)
+	for {
+		ptr := v_0
+		val := v_1
+		mem := v_2
+		v.reset(OpRISCV64LoweredAtomicAnd32)
+		v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Uintptr)
+		v0.AuxInt = int64ToAuxInt(^3)
+		v0.AddArg(ptr)
+		v1 := b.NewValue0(v.Pos, OpRISCV64NOT, typ.UInt32)
+		v2 := b.NewValue0(v.Pos, OpRISCV64SLL, typ.UInt32)
+		v3 := b.NewValue0(v.Pos, OpRISCV64XORI, typ.UInt32)
+		v3.AuxInt = int64ToAuxInt(0xff)
+		v4 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
+		v4.AddArg(val)
+		v3.AddArg(v4)
+		v5 := b.NewValue0(v.Pos, OpRISCV64SLLI, typ.UInt64)
+		v5.AuxInt = int64ToAuxInt(3)
+		v6 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.UInt64)
+		v6.AuxInt = int64ToAuxInt(3)
+		v6.AddArg(ptr)
+		v5.AddArg(v6)
+		v2.AddArg2(v3, v5)
+		v1.AddArg(v2)
+		v.AddArg3(v0, v1, mem)
+		return true
+	}
+}
+func rewriteValueRISCV64_OpAtomicOr8(v *Value) bool {
+	v_2 := v.Args[2]
+	v_1 := v.Args[1]
+	v_0 := v.Args[0]
+	b := v.Block
+	typ := &b.Func.Config.Types
+	// match: (AtomicOr8 ptr val mem)
+	// result: (LoweredAtomicOr32 (ANDI <typ.Uintptr> [^3] ptr) (SLL <typ.UInt32> (ZeroExt8to32 val) (SLLI <typ.UInt64> [3] (ANDI <typ.UInt64> [3] ptr))) mem)
+	for {
+		ptr := v_0
+		val := v_1
+		mem := v_2
+		v.reset(OpRISCV64LoweredAtomicOr32)
+		v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Uintptr)
+		v0.AuxInt = int64ToAuxInt(^3)
+		v0.AddArg(ptr)
+		v1 := b.NewValue0(v.Pos, OpRISCV64SLL, typ.UInt32)
+		v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
+		v2.AddArg(val)
+		v3 := b.NewValue0(v.Pos, OpRISCV64SLLI, typ.UInt64)
+		v3.AuxInt = int64ToAuxInt(3)
+		v4 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.UInt64)
+		v4.AuxInt = int64ToAuxInt(3)
+		v4.AddArg(ptr)
+		v3.AddArg(v4)
+		v1.AddArg2(v2, v3)
+		v.AddArg3(v0, v1, mem)
+		return true
+	}
+}
 func rewriteValueRISCV64_OpAvg64u(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
-- 
GitLab


From 85f62b09413ea043623f7f6905a4d1426908e6a2 Mon Sep 17 00:00:00 2001
From: eric fang <eric.fang@arm.com>
Date: Tue, 2 Mar 2021 05:53:49 +0000
Subject: [PATCH 0901/2400] cmd/compile: remove 8-byte alignment requirement of
 stack slot on mips

This CL applies CL 267999 to mips.

Updates #42385

Change-Id: I8096e16c1b4def767b0c20c16add36fa2406bcab
Reviewed-on: https://go-review.googlesource.com/c/go/+/297772
Reviewed-by: Keith Randall <khr@golang.org>
Trust: eric fang <eric.fang@arm.com>
---
 src/cmd/compile/internal/ssagen/pgen.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ssagen/pgen.go b/src/cmd/compile/internal/ssagen/pgen.go
index 717f1118f6..9b81d14f7e 100644
--- a/src/cmd/compile/internal/ssagen/pgen.go
+++ b/src/cmd/compile/internal/ssagen/pgen.go
@@ -138,7 +138,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 		} else {
 			lastHasPtr = false
 		}
-		if Arch.LinkArch.InFamily(sys.MIPS, sys.ARM, sys.ARM64, sys.PPC64, sys.S390X) {
+		if Arch.LinkArch.InFamily(sys.ARM, sys.ARM64, sys.PPC64, sys.S390X) {
 			s.stksize = types.Rnd(s.stksize, int64(types.PtrSize))
 		}
 		n.SetFrameOffset(-s.stksize)
-- 
GitLab


From c4e3f6c4c78f52060d409a549b83b72644069137 Mon Sep 17 00:00:00 2001
From: eric fang <eric.fang@arm.com>
Date: Tue, 2 Mar 2021 06:10:58 +0000
Subject: [PATCH 0902/2400] cmd/compile: remove 8-byte alignment requirement of
 stack slot on s390x

This CL applies CL 267999 to s390x.

Updates #42385

Change-Id: Ie8e69ad1b3f7ddc2c8f05125f4af617aeac035ec
Reviewed-on: https://go-review.googlesource.com/c/go/+/297769
Reviewed-by: Keith Randall <khr@golang.org>
Trust: eric fang <eric.fang@arm.com>
---
 src/cmd/compile/internal/ssagen/pgen.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ssagen/pgen.go b/src/cmd/compile/internal/ssagen/pgen.go
index 9b81d14f7e..b675d1c876 100644
--- a/src/cmd/compile/internal/ssagen/pgen.go
+++ b/src/cmd/compile/internal/ssagen/pgen.go
@@ -138,7 +138,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 		} else {
 			lastHasPtr = false
 		}
-		if Arch.LinkArch.InFamily(sys.ARM, sys.ARM64, sys.PPC64, sys.S390X) {
+		if Arch.LinkArch.InFamily(sys.ARM, sys.ARM64, sys.PPC64) {
 			s.stksize = types.Rnd(s.stksize, int64(types.PtrSize))
 		}
 		n.SetFrameOffset(-s.stksize)
-- 
GitLab


From 9f33dc3ca1b7b6bdb1a8e83c24d490f579bbbdc8 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Wed, 17 Feb 2021 10:38:03 -0500
Subject: [PATCH 0903/2400] cmd/compile: handle aggregate OpArg in registers

Also handles case where OpArg does not escape but has its address
taken.

May have exposed a lurking bug in 1.16 expandCalls,
if e.g., loading len(someArrayOfstructThing[0].secondStringField)
from a local.  Maybe.

For #40724.

Change-Id: I0298c4ad5d652b5e3d7ed6a62095d59e2d8819c7
Reviewed-on: https://go-review.googlesource.com/c/go/+/293396
Trust: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/amd64/ssa.go        |   2 -
 src/cmd/compile/internal/ssa/expand_calls.go | 250 +++++++++++++------
 src/cmd/compile/internal/ssa/op.go           |  10 +
 src/cmd/compile/internal/ssa/regalloc.go     |   3 +
 src/cmd/compile/internal/ssa/stackalloc.go   |  15 +-
 src/cmd/compile/internal/ssa/tighten.go      |   2 +-
 src/cmd/compile/internal/ssagen/ssa.go       |  36 ++-
 7 files changed, 225 insertions(+), 93 deletions(-)

diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index 3c43a1d41b..d83d78f080 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -980,8 +980,6 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
-	case ssa.OpArgIntReg, ssa.OpArgFloatReg:
-		ssagen.CheckArgReg(v)
 	case ssa.OpAMD64LoweredGetClosurePtr:
 		// Closure pointer is DX.
 		ssagen.CheckLoweredGetClosurePtr(v)
diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index 68fb0581f6..87b8a02b25 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -158,23 +158,24 @@ func (c *registerCursor) hasRegs() bool {
 }
 
 type expandState struct {
-	f            *Func
-	abi1         *abi.ABIConfig
-	debug        bool
-	canSSAType   func(*types.Type) bool
-	regSize      int64
-	sp           *Value
-	typs         *Types
-	ptrSize      int64
-	hiOffset     int64
-	lowOffset    int64
-	hiRo         Abi1RO
-	loRo         Abi1RO
-	namedSelects map[*Value][]namedVal
-	sdom         SparseTree
-	common       map[selKey]*Value
-	offsets      map[offsetKey]*Value
-	memForCall   map[ID]*Value // For a call, need to know the unique selector that gets the mem.
+	f               *Func
+	abi1            *abi.ABIConfig
+	debug           bool
+	canSSAType      func(*types.Type) bool
+	regSize         int64
+	sp              *Value
+	typs            *Types
+	ptrSize         int64
+	hiOffset        int64
+	lowOffset       int64
+	hiRo            Abi1RO
+	loRo            Abi1RO
+	namedSelects    map[*Value][]namedVal
+	sdom            SparseTree
+	commonSelectors map[selKey]*Value // used to de-dupe selectors
+	commonArgs      map[selKey]*Value // used to de-dupe OpArg/OpArgIntReg/OpArgFloatReg
+	offsets         map[offsetKey]*Value
+	memForCall      map[ID]*Value // For a call, need to know the unique selector that gets the mem.
 }
 
 // intPairTypes returns the pair of 32-bit int types needed to encode a 64-bit integer type on a target
@@ -238,14 +239,20 @@ func (x *expandState) prAssignForArg(v *Value) abi.ABIParamAssignment {
 	if v.Op != OpArg {
 		panic(badVal("Wanted OpArg, instead saw", v))
 	}
-	name := v.Aux.(*ir.Name)
-	fPri := x.f.OwnAux.abiInfo
-	for _, a := range fPri.InParams() {
+	return ParamAssignmentForArgName(x.f, v.Aux.(*ir.Name))
+}
+
+// ParamAssignmentForArgName returns the ABIParamAssignment for f's arg with matching name.
+func ParamAssignmentForArgName(f *Func, name *ir.Name) abi.ABIParamAssignment {
+	abiInfo := f.OwnAux.abiInfo
+	// This is unfortunate, but apparently the only way.
+	// TODO after register args stabilize, find a better way
+	for _, a := range abiInfo.InParams() {
 		if a.Name == name {
 			return a
 		}
 	}
-	panic(fmt.Errorf("Did not match param %v in prInfo %+v", name, fPri.InParams()))
+	panic(fmt.Errorf("Did not match param %v in prInfo %+v", name, abiInfo.InParams()))
 }
 
 // Calls that need lowering have some number of inputs, including a memory input,
@@ -284,7 +291,7 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64,
 	case OpArg:
 		if !x.isAlreadyExpandedAggregateType(selector.Type) {
 			if leafType == selector.Type { // OpIData leads us here, sometimes.
-				leaf.copyOf(selector)
+				x.newArgToMemOrRegs(selector, leaf, offset, regOffset, leafType, leaf.Pos)
 			} else {
 				x.f.Fatalf("Unexpected OpArg type, selector=%s, leaf=%s\n", selector.LongString(), leaf.LongString())
 			}
@@ -297,20 +304,8 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64,
 		case OpIData, OpStructSelect, OpArraySelect:
 			leafType = removeTrivialWrapperTypes(leaf.Type)
 		}
-		aux := selector.Aux
-		auxInt := selector.AuxInt + offset
-		if leaf.Block == selector.Block {
-			leaf.reset(OpArg)
-			leaf.Aux = aux
-			leaf.AuxInt = auxInt
-			leaf.Type = leafType
-		} else {
-			w := selector.Block.NewValue0IA(leaf.Pos, OpArg, leafType, auxInt, aux)
-			leaf.copyOf(w)
-			if x.debug {
-				fmt.Printf("\tnew %s\n", w.LongString())
-			}
-		}
+		x.newArgToMemOrRegs(selector, leaf, offset, regOffset, leafType, leaf.Pos)
+
 		for _, s := range x.namedSelects[selector] {
 			locs = append(locs, x.f.Names[s.locIndex])
 		}
@@ -519,8 +514,23 @@ func (x *expandState) rewriteDereference(b *Block, base, a, mem *Value, offset,
 
 // decomposeArgOrLoad is a helper for storeArgOrLoad.
 // It decomposes a Load or an Arg into smaller parts, parameterized by the decomposeOne and decomposeTwo functions
-// passed to it, and returns the new mem. If the type does not match one of the expected aggregate types, it returns nil instead.
+// passed to it, and returns the new mem.
+// If the type does not match one of the expected aggregate types, it returns nil instead.
+// Parameters:
+//  pos           -- the location of any generated code.
+//  b             -- the block into which any generated code should normally be placed
+//  base          -- for the stores that will ultimately be generated, the base to which the offset is applied. (Note this disappears in a future CL, folded into storeRc)
+//  source        -- the value, possibly an aggregate, to be stored.
+//  mem           -- the mem flowing into this decomposition (loads depend on it, stores updated it)
+//  t             -- the type of the value to be stored
+//  offset        -- if the value is stored in memory, it is stored at base + offset
+//  loadRegOffset -- regarding source as a value in registers, the register offset in ABI1.  Meaningful only if source is OpArg.
+//  storeRc       -- storeRC; if the value is stored in registers, this specifies the registers.  StoreRc also identifies whether the target is registers or memory.
+//
+// TODO -- this needs cleanup; it just works for SSA-able aggregates, and won't fully generalize to register-args aggregates.
 func (x *expandState) decomposeArgOrLoad(pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offset int64, loadRegOffset Abi1RO, storeRc registerCursor,
+	// For decompose One and Two, the additional offArg provides the offset from the beginning of "source", if it is in memory.
+	// offStore is combined to base to obtain a store destionation, like "offset" of decomposeArgOrLoad
 	decomposeOne func(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t1 *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value,
 	decomposeTwo func(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value) *Value {
 	u := source.Type
@@ -530,7 +540,7 @@ func (x *expandState) decomposeArgOrLoad(pos src.XPos, b *Block, base, source, m
 		elemRO := x.regWidth(elem)
 		for i := int64(0); i < u.NumElem(); i++ {
 			elemOff := i * elem.Size()
-			mem = decomposeOne(x, pos, b, base, source, mem, elem, source.AuxInt+elemOff, offset+elemOff, loadRegOffset, storeRc.next(elem))
+			mem = decomposeOne(x, pos, b, base, source, mem, elem, elemOff, offset+elemOff, loadRegOffset, storeRc.next(elem))
 			loadRegOffset += elemRO
 			pos = pos.WithNotStmt()
 		}
@@ -538,7 +548,7 @@ func (x *expandState) decomposeArgOrLoad(pos src.XPos, b *Block, base, source, m
 	case types.TSTRUCT:
 		for i := 0; i < u.NumFields(); i++ {
 			fld := u.Field(i)
-			mem = decomposeOne(x, pos, b, base, source, mem, fld.Type, source.AuxInt+fld.Offset, offset+fld.Offset, loadRegOffset, storeRc.next(fld.Type))
+			mem = decomposeOne(x, pos, b, base, source, mem, fld.Type, fld.Offset, offset+fld.Offset, loadRegOffset, storeRc.next(fld.Type))
 			loadRegOffset += x.regWidth(fld.Type)
 			pos = pos.WithNotStmt()
 		}
@@ -548,20 +558,20 @@ func (x *expandState) decomposeArgOrLoad(pos src.XPos, b *Block, base, source, m
 			break
 		}
 		tHi, tLo := x.intPairTypes(t.Kind())
-		mem = decomposeOne(x, pos, b, base, source, mem, tHi, source.AuxInt+x.hiOffset, offset+x.hiOffset, loadRegOffset+x.hiRo, storeRc.plus(x.hiRo))
+		mem = decomposeOne(x, pos, b, base, source, mem, tHi, x.hiOffset, offset+x.hiOffset, loadRegOffset+x.hiRo, storeRc.plus(x.hiRo))
 		pos = pos.WithNotStmt()
-		return decomposeOne(x, pos, b, base, source, mem, tLo, source.AuxInt+x.lowOffset, offset+x.lowOffset, loadRegOffset+x.loRo, storeRc.plus(x.loRo))
+		return decomposeOne(x, pos, b, base, source, mem, tLo, x.lowOffset, offset+x.lowOffset, loadRegOffset+x.loRo, storeRc.plus(x.loRo))
 	case types.TINTER:
-		return decomposeTwo(x, pos, b, base, source, mem, x.typs.Uintptr, x.typs.BytePtr, source.AuxInt, offset, loadRegOffset, storeRc)
+		return decomposeTwo(x, pos, b, base, source, mem, x.typs.Uintptr, x.typs.BytePtr, 0, offset, loadRegOffset, storeRc)
 	case types.TSTRING:
-		return decomposeTwo(x, pos, b, base, source, mem, x.typs.BytePtr, x.typs.Int, source.AuxInt, offset, loadRegOffset, storeRc)
+		return decomposeTwo(x, pos, b, base, source, mem, x.typs.BytePtr, x.typs.Int, 0, offset, loadRegOffset, storeRc)
 	case types.TCOMPLEX64:
-		return decomposeTwo(x, pos, b, base, source, mem, x.typs.Float32, x.typs.Float32, source.AuxInt, offset, loadRegOffset, storeRc)
+		return decomposeTwo(x, pos, b, base, source, mem, x.typs.Float32, x.typs.Float32, 0, offset, loadRegOffset, storeRc)
 	case types.TCOMPLEX128:
-		return decomposeTwo(x, pos, b, base, source, mem, x.typs.Float64, x.typs.Float64, source.AuxInt, offset, loadRegOffset, storeRc)
+		return decomposeTwo(x, pos, b, base, source, mem, x.typs.Float64, x.typs.Float64, 0, offset, loadRegOffset, storeRc)
 	case types.TSLICE:
-		mem = decomposeOne(x, pos, b, base, source, mem, x.typs.BytePtr, source.AuxInt, offset, loadRegOffset, storeRc.next(x.typs.BytePtr))
-		return decomposeTwo(x, pos, b, base, source, mem, x.typs.Int, x.typs.Int, source.AuxInt+x.ptrSize, offset+x.ptrSize, loadRegOffset+RO_slice_len, storeRc)
+		mem = decomposeOne(x, pos, b, base, source, mem, x.typs.BytePtr, 0, offset, loadRegOffset, storeRc.next(x.typs.BytePtr))
+		return decomposeTwo(x, pos, b, base, source, mem, x.typs.Int, x.typs.Int, x.ptrSize, offset+x.ptrSize, loadRegOffset+RO_slice_len, storeRc)
 	}
 	return nil
 }
@@ -570,10 +580,11 @@ func (x *expandState) decomposeArgOrLoad(pos src.XPos, b *Block, base, source, m
 // pos and b locate the store instruction, base is the base of the store target, source is the "base" of the value input,
 // mem is the input mem, t is the type in question, and offArg and offStore are the offsets from the respective bases.
 func storeOneArg(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
-	w := x.common[selKey{source, offArg, t.Width, t}]
+	w := x.commonArgs[selKey{source, offArg, t.Width, t}]
 	if w == nil {
-		w = source.Block.NewValue0IA(source.Pos, OpArg, t, offArg, source.Aux)
-		x.common[selKey{source, offArg, t.Width, t}] = w
+		// w = source.Block.NewValue0IA(source.Pos, OpArg, t, offArg, source.Aux)
+		w = x.newArgToMemOrRegs(source, w, offArg, loadRegOffset, t, pos)
+		// x.commonArgs[selKey{source, offArg, t.Width, t}] = w
 	}
 	return x.storeArgOrLoad(pos, b, base, w, mem, t, offStore, loadRegOffset, storeRc)
 }
@@ -867,7 +878,7 @@ func expandCalls(f *Func) {
 		ptrSize:      f.Config.PtrSize,
 		namedSelects: make(map[*Value][]namedVal),
 		sdom:         f.Sdom(),
-		common:       make(map[selKey]*Value),
+		commonArgs:   make(map[selKey]*Value),
 		offsets:      make(map[offsetKey]*Value),
 		memForCall:   make(map[ID]*Value),
 	}
@@ -1110,7 +1121,7 @@ func expandCalls(f *Func) {
 		}
 	}
 
-	x.common = make(map[selKey]*Value)
+	x.commonSelectors = make(map[selKey]*Value)
 	// Rewrite duplicate selectors as copies where possible.
 	for i := len(allOrdered) - 1; i >= 0; i-- {
 		v := allOrdered[i]
@@ -1153,15 +1164,15 @@ func expandCalls(f *Func) {
 			offset = size
 		}
 		sk := selKey{from: w, size: size, offset: offset, typ: typ}
-		dupe := x.common[sk]
+		dupe := x.commonSelectors[sk]
 		if dupe == nil {
-			x.common[sk] = v
+			x.commonSelectors[sk] = v
 		} else if x.sdom.IsAncestorEq(dupe.Block, v.Block) {
 			v.copyOf(dupe)
 		} else {
 			// Because values are processed in dominator order, the old common[s] will never dominate after a miss is seen.
 			// Installing the new value might match some future values.
-			x.common[sk] = v
+			x.commonSelectors[sk] = v
 		}
 	}
 
@@ -1207,30 +1218,7 @@ func expandCalls(f *Func) {
 		for _, v := range b.Values {
 			switch v.Op {
 			case OpArg:
-				pa := x.prAssignForArg(v)
-				switch len(pa.Registers) {
-				case 0:
-					frameOff := v.Aux.(*ir.Name).FrameOffset()
-					if pa.Offset() != int32(frameOff+x.f.ABISelf.LocalsOffset()) {
-						panic(fmt.Errorf("Parameter assignment %d and OpArg.Aux frameOffset %d disagree, op=%s\n",
-							pa.Offset(), frameOff, v.LongString()))
-					}
-				case 1:
-					r := pa.Registers[0]
-					i := f.ABISelf.FloatIndexFor(r)
-					// TODO seems like this has implications for debugging. How does this affect the location?
-					if i >= 0 { // float PR
-						v.Op = OpArgFloatReg
-					} else {
-						v.Op = OpArgIntReg
-						i = int64(r)
-					}
-					v.AuxInt = i
-
-				default:
-					panic(badVal("Saw unexpanded OpArg", v))
-				}
-
+				x.rewriteArgToMemOrRegs(v)
 			case OpStaticLECall:
 				v.Op = OpStaticCall
 				// TODO need to insert all the register types.
@@ -1263,3 +1251,107 @@ func expandCalls(f *Func) {
 		}
 	}
 }
+
+// rewriteArgToMemOrRegs converts OpArg v in-place into the register version of v,
+// if that is appropriate.
+func (x *expandState) rewriteArgToMemOrRegs(v *Value) *Value {
+	pa := x.prAssignForArg(v)
+	switch len(pa.Registers) {
+	case 0:
+		frameOff := v.Aux.(*ir.Name).FrameOffset()
+		if pa.Offset() != int32(frameOff+x.f.ABISelf.LocalsOffset()) {
+			panic(fmt.Errorf("Parameter assignment %d and OpArg.Aux frameOffset %d disagree, op=%s",
+				pa.Offset(), frameOff, v.LongString()))
+		}
+	case 1:
+		r := pa.Registers[0]
+		i := x.f.ABISelf.FloatIndexFor(r)
+		// TODO seems like this has implications for debugging. How does this affect the location?
+		if i >= 0 { // float PR
+			v.Op = OpArgFloatReg
+		} else {
+			v.Op = OpArgIntReg
+			i = int64(r)
+		}
+		v.Aux = &AuxNameOffset{v.Aux.(*ir.Name), 0}
+		v.AuxInt = i
+
+	default:
+		panic(badVal("Saw unexpanded OpArg", v))
+	}
+	return v
+}
+
+// newArgToMemOrRegs either rewrites toReplace into an OpArg referencing memory or into an OpArgXXXReg to a register,
+// or rewrites it into a copy of the appropriate OpArgXXX.  The actual OpArgXXX is determined by combining baseArg (an OpArg)
+// with offset, regOffset, and t to determine which portion of it reference (either all or a part, in memory or in registers).
+func (x *expandState) newArgToMemOrRegs(baseArg, toReplace *Value, offset int64, regOffset Abi1RO, t *types.Type, pos src.XPos) *Value {
+	key := selKey{baseArg, offset, t.Width, t}
+	w := x.commonArgs[key]
+	if w != nil {
+		if toReplace != nil {
+			toReplace.copyOf(w)
+		}
+		return w
+	}
+
+	pa := x.prAssignForArg(baseArg)
+	switch len(pa.Registers) {
+	case 0:
+		frameOff := baseArg.Aux.(*ir.Name).FrameOffset()
+		if pa.Offset() != int32(frameOff+x.f.ABISelf.LocalsOffset()) {
+			panic(fmt.Errorf("Parameter assignment %d and OpArg.Aux frameOffset %d disagree, op=%s",
+				pa.Offset(), frameOff, baseArg.LongString()))
+		}
+
+		aux := baseArg.Aux
+		auxInt := baseArg.AuxInt + offset
+		if toReplace != nil && toReplace.Block == baseArg.Block {
+			toReplace.reset(OpArg)
+			toReplace.Aux = aux
+			toReplace.AuxInt = auxInt
+			toReplace.Type = t
+			x.commonArgs[key] = toReplace
+			return toReplace
+		} else {
+			w := baseArg.Block.NewValue0IA(pos, OpArg, t, auxInt, aux)
+			x.commonArgs[key] = w
+			if x.debug {
+				fmt.Printf("\tnew %s\n", w.LongString())
+			}
+			if toReplace != nil {
+				toReplace.copyOf(w)
+			}
+			return w
+		}
+
+	default:
+		r := pa.Registers[regOffset]
+		auxInt := x.f.ABISelf.FloatIndexFor(r)
+		op := OpArgFloatReg
+		// TODO seems like this has implications for debugging. How does this affect the location?
+		if auxInt < 0 { // int (not float) parameter register
+			op = OpArgIntReg
+			auxInt = int64(r)
+		}
+		aux := &AuxNameOffset{baseArg.Aux.(*ir.Name), baseArg.AuxInt + offset}
+		if toReplace != nil && toReplace.Block == baseArg.Block {
+			toReplace.reset(op)
+			toReplace.Aux = aux
+			toReplace.AuxInt = auxInt
+			toReplace.Type = t
+			x.commonArgs[key] = toReplace
+			return toReplace
+		} else {
+			w := baseArg.Block.NewValue0IA(pos, op, t, auxInt, aux)
+			if x.debug {
+				fmt.Printf("\tnew %s\n", w.LongString())
+			}
+			x.commonArgs[key] = w
+			if toReplace != nil {
+				toReplace.copyOf(w)
+			}
+			return w
+		}
+	}
+}
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index 506c745f7c..f704848425 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -77,6 +77,16 @@ type Param struct {
 	Name   *ir.Name // For OwnAux, need to prepend stores with Vardefs
 }
 
+type AuxNameOffset struct {
+	Name   *ir.Name
+	Offset int64
+}
+
+func (a *AuxNameOffset) CanBeAnSSAAux() {}
+func (a *AuxNameOffset) String() string {
+	return fmt.Sprintf("%s+%d", a.Name.Sym().Name, a.Offset)
+}
+
 type AuxCall struct {
 	// TODO(register args) this information is largely redundant with ../abi information, needs cleanup once new ABI is in place.
 	Fn      *obj.LSym
diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go
index 74dd70c3d9..c11138bf4e 100644
--- a/src/cmd/compile/internal/ssa/regalloc.go
+++ b/src/cmd/compile/internal/ssa/regalloc.go
@@ -1517,6 +1517,9 @@ func (s *regAllocState) regalloc(f *Func) {
 					}
 					s.f.setHome(v, outLocs)
 					// Note that subsequent SelectX instructions will do the assignReg calls.
+				} else if v.Type.IsResults() {
+					// TODO register arguments need to make this work
+					panic("Oops, implement this.")
 				} else {
 					if r := outRegs[0]; r != noRegister {
 						s.assignReg(r, v, v)
diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go
index 68a6f08a2a..041e7855f6 100644
--- a/src/cmd/compile/internal/ssa/stackalloc.go
+++ b/src/cmd/compile/internal/ssa/stackalloc.go
@@ -151,13 +151,24 @@ func (s *stackAllocState) stackalloc() {
 
 	// Allocate args to their assigned locations.
 	for _, v := range f.Entry.Values {
-		if v.Op != OpArg {
+		if v.Op != OpArg { // && v.Op != OpArgFReg && v.Op != OpArgIReg  {
 			continue
 		}
 		if v.Aux == nil {
 			f.Fatalf("%s has nil Aux\n", v.LongString())
 		}
-		loc := LocalSlot{N: v.Aux.(*ir.Name), Type: v.Type, Off: v.AuxInt}
+		var loc LocalSlot
+		var name *ir.Name
+		var offset int64
+		if v.Op == OpArg {
+			name = v.Aux.(*ir.Name)
+			offset = v.AuxInt
+		} else {
+			nameOff := v.Aux.(*AuxNameOffset)
+			name = nameOff.Name
+			offset = nameOff.Offset
+		}
+		loc = LocalSlot{N: name, Type: v.Type, Off: offset}
 		if f.pass.debug > stackDebug {
 			fmt.Printf("stackalloc %s to %s\n", v, loc)
 		}
diff --git a/src/cmd/compile/internal/ssa/tighten.go b/src/cmd/compile/internal/ssa/tighten.go
index bd08334a5f..214bf628bd 100644
--- a/src/cmd/compile/internal/ssa/tighten.go
+++ b/src/cmd/compile/internal/ssa/tighten.go
@@ -18,7 +18,7 @@ func tighten(f *Func) {
 				continue
 			}
 			switch v.Op {
-			case OpPhi, OpArg, OpSelect0, OpSelect1, OpSelectN:
+			case OpPhi, OpArg, OpArgIntReg, OpArgFloatReg, OpSelect0, OpSelect1, OpSelectN:
 				// Phis need to stay in their block.
 				// Arg must stay in the entry block.
 				// Tuple selectors must stay with the tuple generator.
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 9088ce333b..f4da71fef4 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -539,16 +539,32 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 
 	// Populate SSAable arguments.
 	for _, n := range fn.Dcl {
-		if n.Class == ir.PPARAM && s.canSSA(n) {
-			var v *ssa.Value
-			if n.Sym().Name == ".fp" {
-				// Race-detector's get-caller-pc incantation is NOT a real Arg.
-				v = s.newValue0(ssa.OpGetCallerPC, n.Type())
-			} else {
-				v = s.newValue0A(ssa.OpArg, n.Type(), n)
+		if n.Class == ir.PPARAM {
+			if s.canSSA(n) {
+				var v *ssa.Value
+				if n.Sym().Name == ".fp" {
+					// Race-detector's get-caller-pc incantation is NOT a real Arg.
+					v = s.newValue0(ssa.OpGetCallerPC, n.Type())
+				} else {
+					v = s.newValue0A(ssa.OpArg, n.Type(), n)
+				}
+				s.vars[n] = v
+				s.addNamedValue(n, v) // This helps with debugging information, not needed for compilation itself.
+			} else if !s.canSSAName(n) { // I.e., the address was taken.  The type may or may not be okay.
+				// If the value will arrive in registers,
+				// AND if it can be SSA'd (if it cannot, panic for now),
+				// THEN
+				// (1) receive it as an OpArg (but do not store its name in the var table)
+				// (2) store it to its spill location, which is its address as well.
+				paramAssignment := ssa.ParamAssignmentForArgName(s.f, n)
+				if len(paramAssignment.Registers) > 0 {
+					if !TypeOK(n.Type()) { // TODO register args -- if v is not an SSA-able type, must decompose, here.
+						panic(fmt.Errorf("Arg in registers is too big to be SSA'd, need to implement decomposition, type=%v, n=%v", n.Type(), n))
+					}
+					v := s.newValue0A(ssa.OpArg, n.Type(), n)
+					s.store(n.Type(), s.decladdrs[n], v)
+				}
 			}
-			s.vars[n] = v
-			s.addNamedValue(n, v) // This helps with debugging information, not needed for compilation itself.
 		}
 	}
 
@@ -6545,6 +6561,8 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 				// memory arg needs no code
 			case ssa.OpArg:
 				// input args need no code
+			case ssa.OpArgIntReg, ssa.OpArgFloatReg:
+				CheckArgReg(v)
 			case ssa.OpSP, ssa.OpSB:
 				// nothing to do
 			case ssa.OpSelect0, ssa.OpSelect1, ssa.OpSelectN:
-- 
GitLab


From 3e524ee65addd8a30bbfb4fd69508d429fda6d4f Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Mon, 1 Mar 2021 11:02:48 -0500
Subject: [PATCH 0904/2400] cmd/compile: make modified Aux type for OpArgXXXX
 pass ssa/check

For #40724.

Change-Id: I7d1e76139d187cd15a6e0df9d19542b7200589f6
Reviewed-on: https://go-review.googlesource.com/c/go/+/297911
Trust: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/check.go         |  6 +++
 .../compile/internal/ssa/gen/genericOps.go    |  4 +-
 src/cmd/compile/internal/ssa/op.go            | 41 ++++++++++---------
 src/cmd/compile/internal/ssa/opGen.go         |  4 +-
 src/cmd/compile/internal/ssa/value.go         |  2 +-
 5 files changed, 32 insertions(+), 25 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go
index 9e4aa6cd79..969fd96dbf 100644
--- a/src/cmd/compile/internal/ssa/check.go
+++ b/src/cmd/compile/internal/ssa/check.go
@@ -182,6 +182,12 @@ func checkFunc(f *Func) {
 					f.Fatalf("value %v has Aux type %T, want *AuxCall", v, v.Aux)
 				}
 				canHaveAux = true
+			case auxNameOffsetInt8:
+				if _, ok := v.Aux.(*AuxNameOffset); !ok {
+					f.Fatalf("value %v has Aux type %T, want *AuxNameOffset", v, v.Aux)
+				}
+				canHaveAux = true
+				canHaveAuxInt = true
 			case auxSym, auxTyp:
 				canHaveAux = true
 			case auxSymOff, auxSymValAndOff, auxTypSize:
diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go
index b730c436cf..ee85156a42 100644
--- a/src/cmd/compile/internal/ssa/gen/genericOps.go
+++ b/src/cmd/compile/internal/ssa/gen/genericOps.go
@@ -336,8 +336,8 @@ var genericOps = []opData{
 
 	// Like Arg, these are generic ops that survive lowering. AuxInt is a register index, and the actual output register for each index is defined by the architecture.
 	// AuxInt = integer argument index (not a register number). ABI-specified spill loc obtained from function
-	{name: "ArgIntReg", aux: "Int8", zeroWidth: true},   // argument to the function in an int reg.
-	{name: "ArgFloatReg", aux: "Int8", zeroWidth: true}, // argument to the function in a float reg.
+	{name: "ArgIntReg", aux: "NameOffsetInt8", zeroWidth: true},   // argument to the function in an int reg.
+	{name: "ArgFloatReg", aux: "NameOffsetInt8", zeroWidth: true}, // argument to the function in a float reg.
 
 	// The address of a variable.  arg0 is the base pointer.
 	// If the variable is a global, the base pointer will be SB and
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index f704848425..0bc7b0ca0d 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -240,26 +240,27 @@ func OwnAuxCall(fn *obj.LSym, args []Param, results []Param, paramResultInfo *ab
 }
 
 const (
-	auxNone         auxType = iota
-	auxBool                 // auxInt is 0/1 for false/true
-	auxInt8                 // auxInt is an 8-bit integer
-	auxInt16                // auxInt is a 16-bit integer
-	auxInt32                // auxInt is a 32-bit integer
-	auxInt64                // auxInt is a 64-bit integer
-	auxInt128               // auxInt represents a 128-bit integer.  Always 0.
-	auxUInt8                // auxInt is an 8-bit unsigned integer
-	auxFloat32              // auxInt is a float32 (encoded with math.Float64bits)
-	auxFloat64              // auxInt is a float64 (encoded with math.Float64bits)
-	auxFlagConstant         // auxInt is a flagConstant
-	auxString               // aux is a string
-	auxSym                  // aux is a symbol (a *gc.Node for locals, an *obj.LSym for globals, or nil for none)
-	auxSymOff               // aux is a symbol, auxInt is an offset
-	auxSymValAndOff         // aux is a symbol, auxInt is a ValAndOff
-	auxTyp                  // aux is a type
-	auxTypSize              // aux is a type, auxInt is a size, must have Aux.(Type).Size() == AuxInt
-	auxCCop                 // aux is a ssa.Op that represents a flags-to-bool conversion (e.g. LessThan)
-	auxCall                 // aux is a *ssa.AuxCall
-	auxCallOff              // aux is a *ssa.AuxCall, AuxInt is int64 param (in+out) size
+	auxNone           auxType = iota
+	auxBool                   // auxInt is 0/1 for false/true
+	auxInt8                   // auxInt is an 8-bit integer
+	auxInt16                  // auxInt is a 16-bit integer
+	auxInt32                  // auxInt is a 32-bit integer
+	auxInt64                  // auxInt is a 64-bit integer
+	auxInt128                 // auxInt represents a 128-bit integer.  Always 0.
+	auxUInt8                  // auxInt is an 8-bit unsigned integer
+	auxFloat32                // auxInt is a float32 (encoded with math.Float64bits)
+	auxFloat64                // auxInt is a float64 (encoded with math.Float64bits)
+	auxFlagConstant           // auxInt is a flagConstant
+	auxNameOffsetInt8         // aux is a &struct{Name ir.Name, Offset int64}; auxInt is index in parameter registers array
+	auxString                 // aux is a string
+	auxSym                    // aux is a symbol (a *gc.Node for locals, an *obj.LSym for globals, or nil for none)
+	auxSymOff                 // aux is a symbol, auxInt is an offset
+	auxSymValAndOff           // aux is a symbol, auxInt is a ValAndOff
+	auxTyp                    // aux is a type
+	auxTypSize                // aux is a type, auxInt is a size, must have Aux.(Type).Size() == AuxInt
+	auxCCop                   // aux is a ssa.Op that represents a flags-to-bool conversion (e.g. LessThan)
+	auxCall                   // aux is a *ssa.AuxCall
+	auxCallOff                // aux is a *ssa.AuxCall, AuxInt is int64 param (in+out) size
 
 	// architecture specific aux types
 	auxARM64BitField     // aux is an arm64 bitfield lsb and width packed into auxInt
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index a26eec680f..a9565ffe4b 100644
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -35445,14 +35445,14 @@ var opcodeTable = [...]opInfo{
 	},
 	{
 		name:      "ArgIntReg",
-		auxType:   auxInt8,
+		auxType:   auxNameOffsetInt8,
 		argLen:    0,
 		zeroWidth: true,
 		generic:   true,
 	},
 	{
 		name:      "ArgFloatReg",
-		auxType:   auxInt8,
+		auxType:   auxNameOffsetInt8,
 		argLen:    0,
 		zeroWidth: true,
 		generic:   true,
diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go
index 55e4b684c1..127e4ce641 100644
--- a/src/cmd/compile/internal/ssa/value.go
+++ b/src/cmd/compile/internal/ssa/value.go
@@ -78,7 +78,7 @@ func (v *Value) String() string {
 }
 
 func (v *Value) AuxInt8() int8 {
-	if opcodeTable[v.Op].auxType != auxInt8 {
+	if opcodeTable[v.Op].auxType != auxInt8 && opcodeTable[v.Op].auxType != auxNameOffsetInt8 {
 		v.Fatalf("op %s doesn't have an int8 aux field", v.Op)
 	}
 	return int8(v.AuxInt)
-- 
GitLab


From d6f6ef6358f15d6e49d949749869f199d99d5047 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Tue, 2 Mar 2021 23:39:12 -0500
Subject: [PATCH 0905/2400] cmd/compile: remove races introduced in abiutils
 field update

This fix uses mutex around the problematic store and subsequent access;
if this causes performance problems later a better fix is to do all the
ABI binding in gc/walk where it is single-threaded.

Change-Id: I488f28ab75beb8351c856fd50b0095cab463642e
Reviewed-on: https://go-review.googlesource.com/c/go/+/298109
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Austin Clements <austin@google.com>
---
 src/cmd/compile/internal/abi/abiutils.go | 21 ++++++++++++++++++++-
 src/cmd/compile/internal/ssagen/ssa.go   | 12 ++++++------
 2 files changed, 26 insertions(+), 7 deletions(-)

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index 903cc5205d..3eab4b8d8b 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -315,12 +315,31 @@ func (config *ABIConfig) ABIAnalyze(t *types.Type) *ABIParamResultInfo {
 	return result
 }
 
+// parameterUpdateMu protects the Offset field of function/method parameters (a subset of structure Fields)
+var parameterUpdateMu sync.Mutex
+
+// FieldOffsetOf returns a concurency-safe version of f.Offset
+func FieldOffsetOf(f *types.Field) int64 {
+	parameterUpdateMu.Lock()
+	defer parameterUpdateMu.Unlock()
+	return f.Offset
+}
+
 func (config *ABIConfig) updateOffset(result *ABIParamResultInfo, f *types.Field, a ABIParamAssignment, isReturn bool) {
 	// Everything except return values in registers has either a frame home (if not in a register) or a frame spill location.
 	if !isReturn || len(a.Registers) == 0 {
 		// The type frame offset DOES NOT show effects of minimum frame size.
 		// Getting this wrong breaks stackmaps, see liveness/plive.go:WriteFuncMap and typebits/typebits.go:Set
-		f.Offset = a.FrameOffset(result)-config.LocalsOffset()
+		parameterUpdateMu.Lock()
+		defer parameterUpdateMu.Unlock()
+		off := a.FrameOffset(result) - config.LocalsOffset()
+		fOffset := f.Offset
+		if fOffset == types.BOGUS_FUNARG_OFFSET {
+			// Set the Offset the first time. After that, we may recompute it, but it should never change.
+			f.Offset = off
+		} else if fOffset != off {
+			panic(fmt.Errorf("Offset changed from %d to %d", fOffset, off))
+		}
 	}
 }
 
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index f4da71fef4..05dd0c62a9 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -1240,7 +1240,7 @@ func (s *state) instrumentFields(t *types.Type, addr *ssa.Value, kind instrument
 		if f.Sym.IsBlank() {
 			continue
 		}
-		offptr := s.newValue1I(ssa.OpOffPtr, types.NewPtr(f.Type), f.Offset, addr)
+		offptr := s.newValue1I(ssa.OpOffPtr, types.NewPtr(f.Type), abi.FieldOffsetOf(f), addr)
 		s.instrumentFields(f.Type, offptr, kind)
 	}
 }
@@ -4759,7 +4759,7 @@ func (s *state) openDeferExit() {
 		}
 		for j, argAddrVal := range r.argVals {
 			f := getParam(r.n, j)
-			ACArgs = append(ACArgs, ssa.Param{Type: f.Type, Offset: int32(argStart + f.Offset)})
+			ACArgs = append(ACArgs, ssa.Param{Type: f.Type, Offset: int32(argStart + abi.FieldOffsetOf(f))})
 			var a *ssa.Value
 			if !TypeOK(f.Type) {
 				a = s.newValue2(ssa.OpDereference, f.Type, argAddrVal, s.mem())
@@ -4867,12 +4867,12 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 	types.CalcSize(fn.Type())
 	stksize := fn.Type().ArgWidth() // includes receiver, args, and results
 
-	abi := s.f.ABI1
+	callABI := s.f.ABI1
 	if !inRegisters {
-		abi = s.f.ABI0
+		callABI = s.f.ABI0
 	}
 
-	params := abi.ABIAnalyze(n.X.Type())
+	params := callABI.ABIAnalyze(n.X.Type())
 
 	res := n.X.Type().Results()
 	if k == callNormal {
@@ -4933,7 +4933,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		}
 		// Set other args.
 		for _, f := range ft.Params().Fields().Slice() {
-			s.storeArgWithBase(args[0], f.Type, addr, off+f.Offset)
+			s.storeArgWithBase(args[0], f.Type, addr, off+abi.FieldOffsetOf(f))
 			args = args[1:]
 		}
 
-- 
GitLab


From 6db80d74200675e20c562684c0bcc6d12a5631eb Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 2 Mar 2021 21:52:09 -0800
Subject: [PATCH 0906/2400] cmd/compile/internal/types2: use correct recv for
 parameterized embedded methods

Methods of generic types are instantiated lazily (upon use). Thus,
when we encounter a method of such a type, we need to instantiate
the method signature with the receiver type arguments. We infer
those type arguments from the method receiver. If the method is
embedded, we must use the actual embedded receiver type, otherwise
the receiver type declared with the method doesn't match up and
inference will fail.

(Note that there's no type inference in the source code here, it's
only the implementation which uses the existing inference mechanism
to easily identify the actual type arguments. If the implementation
is correct, the inference will always succeed.)

Updates #44688.

Change-Id: Ie35b62bebaeaf42037f2ca00cf8bd34fec2ddd9c
Reviewed-on: https://go-review.googlesource.com/c/go/+/298129
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/call.go       | 33 +++++---
 .../internal/types2/fixedbugs/issue44688.go2  | 83 +++++++++++++++++++
 src/cmd/compile/internal/types2/selection.go  |  4 +-
 3 files changed, 106 insertions(+), 14 deletions(-)
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue44688.go2

diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index 3f40a99b07..320e12d4d6 100644
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -597,34 +597,43 @@ func (check *Checker) selector(x *operand, e *syntax.SelectorExpr) {
 	if m, _ := obj.(*Func); m != nil {
 		// check.dump("### found method %s", m)
 		check.objDecl(m, nil)
-		// If m has a parameterized receiver type, infer the type parameter
-		// values from the actual receiver provided and then substitute the
-		// type parameters in the signature accordingly.
+		// If m has a parameterized receiver type, infer the type arguments
+		// from the actual receiver provided and then substitute the type
+		// parameters accordingly.
 		// TODO(gri) factor this code out
 		sig := m.typ.(*Signature)
 		if len(sig.rparams) > 0 {
-			//check.dump("### recv typ = %s", x.typ)
+			// For inference to work, we must use the receiver type
+			// matching the receiver in the actual method declaration.
+			// If the method is embedded, the matching receiver is the
+			// embedded struct or interface that declared the method.
+			// Traverse the embedding to find that type (issue #44688).
+			recv := x.typ
+			for i := 0; i < len(index)-1; i++ {
+				// The embedded type is always a struct or a pointer to
+				// a struct except for the last one (which we don't need).
+				recv = asStruct(derefStructPtr(recv)).Field(index[i]).typ
+			}
+			//check.dump("### recv = %s", recv)
 			//check.dump("### method = %s rparams = %s tparams = %s", m, sig.rparams, sig.tparams)
 			// The method may have a pointer receiver, but the actually provided receiver
 			// may be a (hopefully addressable) non-pointer value, or vice versa. Here we
 			// only care about inferring receiver type parameters; to make the inference
 			// work, match up pointer-ness of receiver and argument.
-			arg := x
-			if ptrRecv := isPointer(sig.recv.typ); ptrRecv != isPointer(arg.typ) {
-				copy := *arg
+			if ptrRecv := isPointer(sig.recv.typ); ptrRecv != isPointer(recv) {
 				if ptrRecv {
-					copy.typ = NewPointer(arg.typ)
+					recv = NewPointer(recv)
 				} else {
-					copy.typ = arg.typ.(*Pointer).base
+					recv = recv.(*Pointer).base
 				}
-				arg = &copy
 			}
-			targs, failed := check.infer(sig.rparams, NewTuple(sig.recv), []*operand{arg})
+			arg := operand{mode: variable, expr: x.expr, typ: recv}
+			targs, failed := check.infer(sig.rparams, NewTuple(sig.recv), []*operand{&arg})
 			//check.dump("### inferred targs = %s", targs)
 			if failed >= 0 {
 				// We may reach here if there were other errors (see issue #40056).
 				// check.infer will report a follow-up error.
-				// TODO(gri) avoid the follow-up error or provide better explanation.
+				// TODO(gri) avoid the follow-up error as it is confusing (there's no inference in the source code)
 				goto Error
 			}
 			// Don't modify m. Instead - for now - make a copy of m and use that instead.
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue44688.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue44688.go2
new file mode 100644
index 0000000000..512bfcc922
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue44688.go2
@@ -0,0 +1,83 @@
+// Copyright 2021 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 P
+
+type A1[T any] struct{}
+
+func (*A1[T]) m1(T) {}
+
+type A2[T any] interface {
+	m2(T)
+}
+
+type B1[T any] struct {
+	filler int
+	*A1[T]
+	A2[T]
+}
+
+type B2[T any] interface {
+	A2[T]
+}
+
+type C[T any] struct {
+	filler1 int
+	filler2 int
+	B1[T]
+}
+
+type D[T any] struct {
+	filler1 int
+	filler2 int
+	filler3 int
+	C[T]
+}
+
+func _() {
+	// calling embedded methods
+	var b1 B1[string]
+
+	b1.A1.m1("")
+	b1.m1("")
+
+	b1.A2.m2("")
+	b1.m2("")
+
+	var b2 B2[string]
+	b2.m2("")
+
+	// a deeper nesting
+	var d D[string]
+	d.m1("")
+	d.m2("")
+
+	// calling method expressions
+	m1x := B1[string].m1
+	m1x(b1, "")
+	m2x := B2[string].m2
+	m2x(b2, "")
+
+	// calling method values
+	m1v := b1.m1
+	m1v("")
+	m2v := b1.m2
+	m2v("")
+	b2v := b2.m2
+	b2v("")
+}
+
+// actual test case from issue
+
+type A[T any] struct{}
+
+func (*A[T]) f(T) {}
+
+type B[T any] struct{ A[T] }
+
+func _() {
+	var b B[string]
+	b.A.f("")
+	b.f("")
+}
diff --git a/src/cmd/compile/internal/types2/selection.go b/src/cmd/compile/internal/types2/selection.go
index 67d1aa7e1d..02c0fc6902 100644
--- a/src/cmd/compile/internal/types2/selection.go
+++ b/src/cmd/compile/internal/types2/selection.go
@@ -51,8 +51,8 @@ func (s *Selection) Kind() SelectionKind { return s.kind }
 // Recv returns the type of x in x.f.
 func (s *Selection) Recv() Type { return s.recv }
 
-// Work-around for bug where a (*instance) shows up in a final type.
-// TODO(gri):  fix this bug.
+// Work-around for a compiler issue where an (*instance) escapes.
+// TODO(gri): Is this still needed?
 func (s *Selection) TArgs() []Type {
 	r := s.recv
 	if p := asPointer(r); p != nil {
-- 
GitLab


From 12bb256cb30a76b540dbbc1cac38d7044facfa29 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 3 Mar 2021 13:33:24 -0500
Subject: [PATCH 0907/2400] go/types: use correct recv for parameterized
 embedded methods

This is a direct port of CL 298129 to go/types.

Fixes #44688

Change-Id: I950992ea7beea5b9c8bea0c296b5ce03b2aa9b12
Reviewed-on: https://go-review.googlesource.com/c/go/+/298349
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/call.go                  | 33 +++++++----
 src/go/types/fixedbugs/issue44688.go2 | 83 +++++++++++++++++++++++++++
 2 files changed, 105 insertions(+), 11 deletions(-)
 create mode 100644 src/go/types/fixedbugs/issue44688.go2

diff --git a/src/go/types/call.go b/src/go/types/call.go
index f23ca02e1d..ae0a245b2b 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -592,31 +592,42 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr) {
 	// methods may not have a fully set up signature yet
 	if m, _ := obj.(*Func); m != nil {
 		check.objDecl(m, nil)
-		// If m has a parameterized receiver type, infer the type parameter
-		// values from the actual receiver provided and then substitute the
-		// type parameters in the signature accordingly.
+		// If m has a parameterized receiver type, infer the type arguments from
+		// the actual receiver provided and then substitute the type parameters in
+		// the signature accordingly.
 		// TODO(gri) factor this code out
 		sig := m.typ.(*Signature)
 		if len(sig.rparams) > 0 {
+			// For inference to work, we must use the receiver type
+			// matching the receiver in the actual method declaration.
+			// If the method is embedded, the matching receiver is the
+			// embedded struct or interface that declared the method.
+			// Traverse the embedding to find that type (issue #44688).
+			recv := x.typ
+			for i := 0; i < len(index)-1; i++ {
+				// The embedded type is either a struct or a pointer to
+				// a struct except for the last one (which we don't need).
+				recv = asStruct(derefStructPtr(recv)).Field(index[i]).typ
+			}
+
 			// The method may have a pointer receiver, but the actually provided receiver
 			// may be a (hopefully addressable) non-pointer value, or vice versa. Here we
 			// only care about inferring receiver type parameters; to make the inference
 			// work, match up pointer-ness of receiver and argument.
-			arg := x
-			if ptrRecv := isPointer(sig.recv.typ); ptrRecv != isPointer(arg.typ) {
-				copy := *arg
+			if ptrRecv := isPointer(sig.recv.typ); ptrRecv != isPointer(recv) {
 				if ptrRecv {
-					copy.typ = NewPointer(arg.typ)
+					recv = NewPointer(recv)
 				} else {
-					copy.typ = arg.typ.(*Pointer).base
+					recv = recv.(*Pointer).base
 				}
-				arg = &copy
 			}
-			targs, failed := check.infer(sig.rparams, NewTuple(sig.recv), []*operand{arg})
+			arg := operand{mode: variable, expr: x.expr, typ: recv}
+			targs, failed := check.infer(sig.rparams, NewTuple(sig.recv), []*operand{&arg})
 			if failed >= 0 {
 				// We may reach here if there were other errors (see issue #40056).
 				// check.infer will report a follow-up error.
-				// TODO(gri) avoid the follow-up error or provide better explanation.
+				// TODO(gri) avoid the follow-up error as it is confusing
+				//           (there's no inference in the source code)
 				goto Error
 			}
 			// Don't modify m. Instead - for now - make a copy of m and use that instead.
diff --git a/src/go/types/fixedbugs/issue44688.go2 b/src/go/types/fixedbugs/issue44688.go2
new file mode 100644
index 0000000000..512bfcc922
--- /dev/null
+++ b/src/go/types/fixedbugs/issue44688.go2
@@ -0,0 +1,83 @@
+// Copyright 2021 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 P
+
+type A1[T any] struct{}
+
+func (*A1[T]) m1(T) {}
+
+type A2[T any] interface {
+	m2(T)
+}
+
+type B1[T any] struct {
+	filler int
+	*A1[T]
+	A2[T]
+}
+
+type B2[T any] interface {
+	A2[T]
+}
+
+type C[T any] struct {
+	filler1 int
+	filler2 int
+	B1[T]
+}
+
+type D[T any] struct {
+	filler1 int
+	filler2 int
+	filler3 int
+	C[T]
+}
+
+func _() {
+	// calling embedded methods
+	var b1 B1[string]
+
+	b1.A1.m1("")
+	b1.m1("")
+
+	b1.A2.m2("")
+	b1.m2("")
+
+	var b2 B2[string]
+	b2.m2("")
+
+	// a deeper nesting
+	var d D[string]
+	d.m1("")
+	d.m2("")
+
+	// calling method expressions
+	m1x := B1[string].m1
+	m1x(b1, "")
+	m2x := B2[string].m2
+	m2x(b2, "")
+
+	// calling method values
+	m1v := b1.m1
+	m1v("")
+	m2v := b1.m2
+	m2v("")
+	b2v := b2.m2
+	b2v("")
+}
+
+// actual test case from issue
+
+type A[T any] struct{}
+
+func (*A[T]) f(T) {}
+
+type B[T any] struct{ A[T] }
+
+func _() {
+	var b B[string]
+	b.A.f("")
+	b.f("")
+}
-- 
GitLab


From 79beddc773ecca50c283dde6aad7c80929da0554 Mon Sep 17 00:00:00 2001
From: eric fang <eric.fang@arm.com>
Date: Mon, 23 Nov 2020 10:59:33 +0000
Subject: [PATCH 0908/2400] cmd/asm: add 128-bit FLDPQ and FSTPQ instructions
 for arm64

This CL adds assembly support for 128-bit FLDPQ and FSTPQ instructions.

This CL also deletes some wrong pre/post-indexed LDP and STP instructions,
such as {ALDP, C_UAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, C_XPRE},
because when the offset type is C_UAUTO4K, pre and post don't work.

Change-Id: Ifd901d4440eb06eb9e86c9dd17518749fdf32848
Reviewed-on: https://go-review.googlesource.com/c/go/+/273668
Trust: eric fang <eric.fang@arm.com>
Run-TryBot: eric fang <eric.fang@arm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: eric fang <eric.fang@arm.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/asm/internal/asm/testdata/arm64.s     |  48 +++
 .../asm/internal/asm/testdata/arm64error.s    |   3 +
 src/cmd/internal/obj/arm64/a.out.go           |  16 +-
 src/cmd/internal/obj/arm64/anames.go          |   2 +
 src/cmd/internal/obj/arm64/anames7.go         |  12 +
 src/cmd/internal/obj/arm64/asm7.go            | 335 ++++++++++++------
 6 files changed, 297 insertions(+), 119 deletions(-)

diff --git a/src/cmd/asm/internal/asm/testdata/arm64.s b/src/cmd/asm/internal/asm/testdata/arm64.s
index 91e3a0ca0a..1e6cde7a46 100644
--- a/src/cmd/asm/internal/asm/testdata/arm64.s
+++ b/src/cmd/asm/internal/asm/testdata/arm64.s
@@ -982,6 +982,54 @@ again:
 	FSTPS	(F3, F4), x(SB)
 	FSTPS	(F3, F4), x+8(SB)
 
+// FLDPQ/FSTPQ
+	FLDPQ   -4000(R0), (F1, F2)  // 1b803ed1610b40ad
+	FLDPQ	-1024(R0), (F1, F2)  // 010860ad
+	FLDPQ	(R0), (F1, F2)       // 010840ad
+	FLDPQ	16(R0), (F1, F2)     // 018840ad
+	FLDPQ	-16(R0), (F1, F2)    // 01887fad
+	FLDPQ.W	32(R0), (F1, F2)     // 0108c1ad
+	FLDPQ.P	32(R0), (F1, F2)     // 0108c1ac
+	FLDPQ	11(R0), (F1, F2)     // 1b2c0091610b40ad
+	FLDPQ	1024(R0), (F1, F2)   // 1b001091610b40ad
+	FLDPQ   4104(R0), (F1, F2)
+	FLDPQ   -4000(RSP), (F1, F2) // fb833ed1610b40ad
+	FLDPQ	-1024(RSP), (F1, F2) // e10b60ad
+	FLDPQ	(RSP), (F1, F2)      // e10b40ad
+	FLDPQ	16(RSP), (F1, F2)    // e18b40ad
+	FLDPQ	-16(RSP), (F1, F2)   // e18b7fad
+	FLDPQ.W	32(RSP), (F1, F2)    // e10bc1ad
+	FLDPQ.P	32(RSP), (F1, F2)    // e10bc1ac
+	FLDPQ	11(RSP), (F1, F2)    // fb2f0091610b40ad
+	FLDPQ	1024(RSP), (F1, F2)  // fb031091610b40ad
+	FLDPQ   4104(RSP), (F1, F2)
+	FLDPQ	-31(R0), (F1, F2)    // 1b7c00d1610b40ad
+	FLDPQ	-4(R0), (F1, F2)     // 1b1000d1610b40ad
+	FLDPQ	x(SB), (F1, F2)
+	FLDPQ	x+8(SB), (F1, F2)
+	FSTPQ	(F3, F4), -4000(R5)  // bb803ed1631300ad
+	FSTPQ	(F3, F4), -1024(R5)  // a31020ad
+	FSTPQ	(F3, F4), (R5)       // a31000ad
+	FSTPQ	(F3, F4), 16(R5)     // a39000ad
+	FSTPQ	(F3, F4), -16(R5)    // a3903fad
+	FSTPQ.W	(F3, F4), 32(R5)     // a31081ad
+	FSTPQ.P	(F3, F4), 32(R5)     // a31081ac
+	FSTPQ	(F3, F4), 11(R5)     // bb2c0091631300ad
+	FSTPQ	(F3, F4), 1024(R5)   // bb001091631300ad
+	FSTPQ	(F3, F4), 4104(R5)
+	FSTPQ	(F3, F4), -4000(RSP) // fb833ed1631300ad
+	FSTPQ	(F3, F4), -1024(RSP) // e31320ad
+	FSTPQ	(F3, F4), (RSP)      // e31300ad
+	FSTPQ	(F3, F4), 16(RSP)    // e39300ad
+	FSTPQ	(F3, F4), -16(RSP)   // e3933fad
+	FSTPQ.W	(F3, F4), 32(RSP)    // e31381ad
+	FSTPQ.P	(F3, F4), 32(RSP)    // e31381ac
+	FSTPQ	(F3, F4), 11(RSP)    // fb2f0091631300ad
+	FSTPQ	(F3, F4), 1024(RSP)  // fb031091631300ad
+	FSTPQ	(F3, F4), 4104(RSP)
+	FSTPQ	(F3, F4), x(SB)
+	FSTPQ	(F3, F4), x+8(SB)
+
 // System Register
 	MSR	$1, SPSel                          // bf4100d5
 	MSR	$9, DAIFSet                        // df4903d5
diff --git a/src/cmd/asm/internal/asm/testdata/arm64error.s b/src/cmd/asm/internal/asm/testdata/arm64error.s
index e579f20836..9b4f42a8ff 100644
--- a/src/cmd/asm/internal/asm/testdata/arm64error.s
+++ b/src/cmd/asm/internal/asm/testdata/arm64error.s
@@ -109,6 +109,9 @@ TEXT errors(SB),$0
 	VREV16	V1.D1, V2.D1                                     // ERROR "invalid arrangement"
 	VREV16	V1.B8, V2.B16                                    // ERROR "invalid arrangement"
 	VREV16	V1.H4, V2.H4                                     // ERROR "invalid arrangement"
+	FLDPQ	(R0), (R1, R2)                                   // ERROR "invalid register pair"
+	FLDPQ	(R1), (F2, F2)                                   // ERROR "constrained unpredictable behavior"
+	FSTPQ	(R1, R2), (R0)                                   // ERROR "invalid register pair"
 	FLDPD	(R0), (R1, R2)                                   // ERROR "invalid register pair"
 	FLDPD	(R1), (F2, F2)                                   // ERROR "constrained unpredictable behavior"
 	FLDPS	(R2), (F3, F3)                                   // ERROR "constrained unpredictable behavior"
diff --git a/src/cmd/internal/obj/arm64/a.out.go b/src/cmd/internal/obj/arm64/a.out.go
index 7ab9c1475f..ed07f18691 100644
--- a/src/cmd/internal/obj/arm64/a.out.go
+++ b/src/cmd/internal/obj/arm64/a.out.go
@@ -420,16 +420,21 @@ const (
 	C_LBRA
 
 	C_ZAUTO       // 0(RSP)
+	C_NSAUTO_16   // -256 <= x < 0, 0 mod 16
 	C_NSAUTO_8    // -256 <= x < 0, 0 mod 8
 	C_NSAUTO_4    // -256 <= x < 0, 0 mod 4
 	C_NSAUTO      // -256 <= x < 0
+	C_NPAUTO_16   // -512 <= x < 0, 0 mod 16
 	C_NPAUTO      // -512 <= x < 0, 0 mod 8
+	C_NQAUTO_16   // -1024 <= x < 0, 0 mod 16
 	C_NAUTO4K     // -4095 <= x < 0
+	C_PSAUTO_16   // 0 to 255, 0 mod 16
 	C_PSAUTO_8    // 0 to 255, 0 mod 8
 	C_PSAUTO_4    // 0 to 255, 0 mod 4
 	C_PSAUTO      // 0 to 255
 	C_PPAUTO_16   // 0 to 504, 0 mod 16
 	C_PPAUTO      // 0 to 504, 0 mod 8
+	C_PQAUTO_16   // 0 to 1008, 0 mod 16
 	C_UAUTO4K_16  // 0 to 4095, 0 mod 16
 	C_UAUTO4K_8   // 0 to 4095, 0 mod 8
 	C_UAUTO4K_4   // 0 to 4095, 0 mod 4
@@ -454,17 +459,22 @@ const (
 	C_SEXT16 // 0 to 65520
 	C_LEXT
 
-	C_ZOREG    // 0(R)
-	C_NSOREG_8 // must mirror C_NSAUTO_8, etc
+	C_ZOREG     // 0(R)
+	C_NSOREG_16 // must mirror C_NSAUTO_16, etc
+	C_NSOREG_8
 	C_NSOREG_4
 	C_NSOREG
+	C_NPOREG_16
 	C_NPOREG
+	C_NQOREG_16
 	C_NOREG4K
+	C_PSOREG_16
 	C_PSOREG_8
 	C_PSOREG_4
 	C_PSOREG
 	C_PPOREG_16
 	C_PPOREG
+	C_PQOREG_16
 	C_UOREG4K_16
 	C_UOREG4K_8
 	C_UOREG4K_4
@@ -898,6 +908,7 @@ const (
 	AFDIVD
 	AFDIVS
 	AFLDPD
+	AFLDPQ
 	AFLDPS
 	AFMOVQ
 	AFMOVD
@@ -912,6 +923,7 @@ const (
 	AFSQRTD
 	AFSQRTS
 	AFSTPD
+	AFSTPQ
 	AFSTPS
 	AFSUBD
 	AFSUBS
diff --git a/src/cmd/internal/obj/arm64/anames.go b/src/cmd/internal/obj/arm64/anames.go
index a98f8c7ed5..0fb28536c4 100644
--- a/src/cmd/internal/obj/arm64/anames.go
+++ b/src/cmd/internal/obj/arm64/anames.go
@@ -392,6 +392,7 @@ var Anames = []string{
 	"FDIVD",
 	"FDIVS",
 	"FLDPD",
+	"FLDPQ",
 	"FLDPS",
 	"FMOVQ",
 	"FMOVD",
@@ -406,6 +407,7 @@ var Anames = []string{
 	"FSQRTD",
 	"FSQRTS",
 	"FSTPD",
+	"FSTPQ",
 	"FSTPS",
 	"FSUBD",
 	"FSUBS",
diff --git a/src/cmd/internal/obj/arm64/anames7.go b/src/cmd/internal/obj/arm64/anames7.go
index f7e99517ce..2ecd8164b6 100644
--- a/src/cmd/internal/obj/arm64/anames7.go
+++ b/src/cmd/internal/obj/arm64/anames7.go
@@ -42,15 +42,21 @@ var cnames7 = []string{
 	"SBRA",
 	"LBRA",
 	"ZAUTO",
+	"NSAUTO_16",
 	"NSAUTO_8",
 	"NSAUTO_4",
 	"NSAUTO",
+	"NPAUTO_16",
 	"NPAUTO",
+	"NQAUTO_16",
 	"NAUTO4K",
+	"PSAUTO_16",
 	"PSAUTO_8",
 	"PSAUTO_4",
 	"PSAUTO",
+	"PPAUTO_16",
 	"PPAUTO",
+	"PQAUTO_16",
 	"UAUTO4K_16",
 	"UAUTO4K_8",
 	"UAUTO4K_4",
@@ -74,15 +80,21 @@ var cnames7 = []string{
 	"SEXT16",
 	"LEXT",
 	"ZOREG",
+	"NSOREG_16",
 	"NSOREG_8",
 	"NSOREG_4",
 	"NSOREG",
+	"NPOREG_16",
 	"NPOREG",
+	"NQOREG_16",
 	"NOREG4K",
+	"PSOREG_16",
 	"PSOREG_8",
 	"PSOREG_4",
 	"PSOREG",
+	"PPOREG_16",
 	"PPOREG",
+	"PQOREG_16",
 	"UOREG4K_16",
 	"UOREG4K_8",
 	"UOREG4K_4",
diff --git a/src/cmd/internal/obj/arm64/asm7.go b/src/cmd/internal/obj/arm64/asm7.go
index 70072cfba4..5937ebd732 100644
--- a/src/cmd/internal/obj/arm64/asm7.go
+++ b/src/cmd/internal/obj/arm64/asm7.go
@@ -689,6 +689,46 @@ var optab = []Optab{
 
 	/* pre/post-indexed/signed-offset load/store register pair
 	   (unscaled, signed 10-bit quad-aligned and long offset) */
+	{AFLDPQ, C_NQAUTO_16, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, 0},
+	{AFLDPQ, C_NQAUTO_16, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, C_XPRE},
+	{AFLDPQ, C_NQAUTO_16, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, C_XPOST},
+	{AFLDPQ, C_PQAUTO_16, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, 0},
+	{AFLDPQ, C_PQAUTO_16, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, C_XPRE},
+	{AFLDPQ, C_PQAUTO_16, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, C_XPOST},
+	{AFLDPQ, C_UAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, 0},
+	{AFLDPQ, C_NAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, 0},
+	{AFLDPQ, C_LAUTO, C_NONE, C_NONE, C_PAIR, 75, 12, REGSP, LFROM, 0},
+	{AFLDPQ, C_NQOREG_16, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, 0},
+	{AFLDPQ, C_NQOREG_16, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, C_XPRE},
+	{AFLDPQ, C_NQOREG_16, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, C_XPOST},
+	{AFLDPQ, C_PQOREG_16, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, 0},
+	{AFLDPQ, C_PQOREG_16, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, C_XPRE},
+	{AFLDPQ, C_PQOREG_16, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, C_XPOST},
+	{AFLDPQ, C_UOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, 0},
+	{AFLDPQ, C_NOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, 0},
+	{AFLDPQ, C_LOREG, C_NONE, C_NONE, C_PAIR, 75, 12, 0, LFROM, 0},
+	{AFLDPQ, C_ADDR, C_NONE, C_NONE, C_PAIR, 88, 12, 0, 0, 0},
+
+	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_NQAUTO_16, 67, 4, REGSP, 0, 0},
+	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_NQAUTO_16, 67, 4, REGSP, 0, C_XPRE},
+	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_NQAUTO_16, 67, 4, REGSP, 0, C_XPOST},
+	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_PQAUTO_16, 67, 4, REGSP, 0, 0},
+	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_PQAUTO_16, 67, 4, REGSP, 0, C_XPRE},
+	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_PQAUTO_16, 67, 4, REGSP, 0, C_XPOST},
+	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_UAUTO4K, 76, 8, REGSP, 0, 0},
+	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_NAUTO4K, 76, 12, REGSP, 0, 0},
+	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_LAUTO, 77, 12, REGSP, LTO, 0},
+	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_NQOREG_16, 67, 4, 0, 0, 0},
+	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_NQOREG_16, 67, 4, 0, 0, C_XPRE},
+	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_NQOREG_16, 67, 4, 0, 0, C_XPOST},
+	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_PQOREG_16, 67, 4, 0, 0, 0},
+	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_PQOREG_16, 67, 4, 0, 0, C_XPRE},
+	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_PQOREG_16, 67, 4, 0, 0, C_XPOST},
+	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_UOREG4K, 76, 8, 0, 0, 0},
+	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_NOREG4K, 76, 8, 0, 0, 0},
+	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_LOREG, 77, 12, 0, LTO, 0},
+	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_ADDR, 87, 12, 0, 0, 0},
+
 	{ALDP, C_NPAUTO, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, 0},
 	{ALDP, C_NPAUTO, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, C_XPRE},
 	{ALDP, C_NPAUTO, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, C_XPOST},
@@ -696,14 +736,8 @@ var optab = []Optab{
 	{ALDP, C_PPAUTO, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, C_XPRE},
 	{ALDP, C_PPAUTO, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, C_XPOST},
 	{ALDP, C_UAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, 0},
-	{ALDP, C_UAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, C_XPRE},
-	{ALDP, C_UAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, C_XPOST},
 	{ALDP, C_NAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, 0},
-	{ALDP, C_NAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, C_XPRE},
-	{ALDP, C_NAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, C_XPOST},
 	{ALDP, C_LAUTO, C_NONE, C_NONE, C_PAIR, 75, 12, REGSP, LFROM, 0},
-	{ALDP, C_LAUTO, C_NONE, C_NONE, C_PAIR, 75, 12, REGSP, LFROM, C_XPRE},
-	{ALDP, C_LAUTO, C_NONE, C_NONE, C_PAIR, 75, 12, REGSP, LFROM, C_XPOST},
 	{ALDP, C_NPOREG, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, 0},
 	{ALDP, C_NPOREG, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, C_XPRE},
 	{ALDP, C_NPOREG, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, C_XPOST},
@@ -711,14 +745,8 @@ var optab = []Optab{
 	{ALDP, C_PPOREG, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, C_XPRE},
 	{ALDP, C_PPOREG, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, C_XPOST},
 	{ALDP, C_UOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, 0},
-	{ALDP, C_UOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, C_XPRE},
-	{ALDP, C_UOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, C_XPOST},
 	{ALDP, C_NOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, 0},
-	{ALDP, C_NOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, C_XPRE},
-	{ALDP, C_NOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, C_XPOST},
 	{ALDP, C_LOREG, C_NONE, C_NONE, C_PAIR, 75, 12, 0, LFROM, 0},
-	{ALDP, C_LOREG, C_NONE, C_NONE, C_PAIR, 75, 12, 0, LFROM, C_XPRE},
-	{ALDP, C_LOREG, C_NONE, C_NONE, C_PAIR, 75, 12, 0, LFROM, C_XPOST},
 	{ALDP, C_ADDR, C_NONE, C_NONE, C_PAIR, 88, 12, 0, 0, 0},
 
 	{ASTP, C_PAIR, C_NONE, C_NONE, C_NPAUTO, 67, 4, REGSP, 0, 0},
@@ -728,14 +756,8 @@ var optab = []Optab{
 	{ASTP, C_PAIR, C_NONE, C_NONE, C_PPAUTO, 67, 4, REGSP, 0, C_XPRE},
 	{ASTP, C_PAIR, C_NONE, C_NONE, C_PPAUTO, 67, 4, REGSP, 0, C_XPOST},
 	{ASTP, C_PAIR, C_NONE, C_NONE, C_UAUTO4K, 76, 8, REGSP, 0, 0},
-	{ASTP, C_PAIR, C_NONE, C_NONE, C_UAUTO4K, 76, 8, REGSP, 0, C_XPRE},
-	{ASTP, C_PAIR, C_NONE, C_NONE, C_UAUTO4K, 76, 8, REGSP, 0, C_XPOST},
 	{ASTP, C_PAIR, C_NONE, C_NONE, C_NAUTO4K, 76, 12, REGSP, 0, 0},
-	{ASTP, C_PAIR, C_NONE, C_NONE, C_NAUTO4K, 76, 12, REGSP, 0, C_XPRE},
-	{ASTP, C_PAIR, C_NONE, C_NONE, C_NAUTO4K, 76, 12, REGSP, 0, C_XPOST},
 	{ASTP, C_PAIR, C_NONE, C_NONE, C_LAUTO, 77, 12, REGSP, LTO, 0},
-	{ASTP, C_PAIR, C_NONE, C_NONE, C_LAUTO, 77, 12, REGSP, LTO, C_XPRE},
-	{ASTP, C_PAIR, C_NONE, C_NONE, C_LAUTO, 77, 12, REGSP, LTO, C_XPOST},
 	{ASTP, C_PAIR, C_NONE, C_NONE, C_NPOREG, 67, 4, 0, 0, 0},
 	{ASTP, C_PAIR, C_NONE, C_NONE, C_NPOREG, 67, 4, 0, 0, C_XPRE},
 	{ASTP, C_PAIR, C_NONE, C_NONE, C_NPOREG, 67, 4, 0, 0, C_XPOST},
@@ -743,14 +765,8 @@ var optab = []Optab{
 	{ASTP, C_PAIR, C_NONE, C_NONE, C_PPOREG, 67, 4, 0, 0, C_XPRE},
 	{ASTP, C_PAIR, C_NONE, C_NONE, C_PPOREG, 67, 4, 0, 0, C_XPOST},
 	{ASTP, C_PAIR, C_NONE, C_NONE, C_UOREG4K, 76, 8, 0, 0, 0},
-	{ASTP, C_PAIR, C_NONE, C_NONE, C_UOREG4K, 76, 8, 0, 0, C_XPRE},
-	{ASTP, C_PAIR, C_NONE, C_NONE, C_UOREG4K, 76, 8, 0, 0, C_XPOST},
 	{ASTP, C_PAIR, C_NONE, C_NONE, C_NOREG4K, 76, 8, 0, 0, 0},
-	{ASTP, C_PAIR, C_NONE, C_NONE, C_NOREG4K, 76, 8, 0, 0, C_XPRE},
-	{ASTP, C_PAIR, C_NONE, C_NONE, C_NOREG4K, 76, 8, 0, 0, C_XPOST},
 	{ASTP, C_PAIR, C_NONE, C_NONE, C_LOREG, 77, 12, 0, LTO, 0},
-	{ASTP, C_PAIR, C_NONE, C_NONE, C_LOREG, 77, 12, 0, LTO, C_XPRE},
-	{ASTP, C_PAIR, C_NONE, C_NONE, C_LOREG, 77, 12, 0, LTO, C_XPOST},
 	{ASTP, C_PAIR, C_NONE, C_NONE, C_ADDR, 87, 12, 0, 0, 0},
 
 	// differ from LDP/STP for C_NSAUTO_4/C_PSAUTO_4/C_NSOREG_4/C_PSOREG_4
@@ -761,14 +777,8 @@ var optab = []Optab{
 	{ALDPW, C_PSAUTO_4, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, C_XPRE},
 	{ALDPW, C_PSAUTO_4, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, C_XPOST},
 	{ALDPW, C_UAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, 0},
-	{ALDPW, C_UAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, C_XPRE},
-	{ALDPW, C_UAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, C_XPOST},
 	{ALDPW, C_NAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, 0},
-	{ALDPW, C_NAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, C_XPRE},
-	{ALDPW, C_NAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, C_XPOST},
 	{ALDPW, C_LAUTO, C_NONE, C_NONE, C_PAIR, 75, 12, REGSP, LFROM, 0},
-	{ALDPW, C_LAUTO, C_NONE, C_NONE, C_PAIR, 75, 12, REGSP, LFROM, C_XPRE},
-	{ALDPW, C_LAUTO, C_NONE, C_NONE, C_PAIR, 75, 12, REGSP, LFROM, C_XPOST},
 	{ALDPW, C_NSOREG_4, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, 0},
 	{ALDPW, C_NSOREG_4, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, C_XPRE},
 	{ALDPW, C_NSOREG_4, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, C_XPOST},
@@ -776,14 +786,8 @@ var optab = []Optab{
 	{ALDPW, C_PSOREG_4, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, C_XPRE},
 	{ALDPW, C_PSOREG_4, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, C_XPOST},
 	{ALDPW, C_UOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, 0},
-	{ALDPW, C_UOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, C_XPRE},
-	{ALDPW, C_UOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, C_XPOST},
 	{ALDPW, C_NOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, 0},
-	{ALDPW, C_NOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, C_XPRE},
-	{ALDPW, C_NOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, C_XPOST},
 	{ALDPW, C_LOREG, C_NONE, C_NONE, C_PAIR, 75, 12, 0, LFROM, 0},
-	{ALDPW, C_LOREG, C_NONE, C_NONE, C_PAIR, 75, 12, 0, LFROM, C_XPRE},
-	{ALDPW, C_LOREG, C_NONE, C_NONE, C_PAIR, 75, 12, 0, LFROM, C_XPOST},
 	{ALDPW, C_ADDR, C_NONE, C_NONE, C_PAIR, 88, 12, 0, 0, 0},
 
 	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NSAUTO_4, 67, 4, REGSP, 0, 0},
@@ -793,14 +797,8 @@ var optab = []Optab{
 	{ASTPW, C_PAIR, C_NONE, C_NONE, C_PSAUTO_4, 67, 4, REGSP, 0, C_XPRE},
 	{ASTPW, C_PAIR, C_NONE, C_NONE, C_PSAUTO_4, 67, 4, REGSP, 0, C_XPOST},
 	{ASTPW, C_PAIR, C_NONE, C_NONE, C_UAUTO4K, 76, 8, REGSP, 0, 0},
-	{ASTPW, C_PAIR, C_NONE, C_NONE, C_UAUTO4K, 76, 8, REGSP, 0, C_XPRE},
-	{ASTPW, C_PAIR, C_NONE, C_NONE, C_UAUTO4K, 76, 8, REGSP, 0, C_XPOST},
 	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NAUTO4K, 76, 12, REGSP, 0, 0},
-	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NAUTO4K, 76, 12, REGSP, 0, C_XPRE},
-	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NAUTO4K, 76, 12, REGSP, 0, C_XPOST},
 	{ASTPW, C_PAIR, C_NONE, C_NONE, C_LAUTO, 77, 12, REGSP, LTO, 0},
-	{ASTPW, C_PAIR, C_NONE, C_NONE, C_LAUTO, 77, 12, REGSP, LTO, C_XPRE},
-	{ASTPW, C_PAIR, C_NONE, C_NONE, C_LAUTO, 77, 12, REGSP, LTO, C_XPOST},
 	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NSOREG_4, 67, 4, 0, 0, 0},
 	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NSOREG_4, 67, 4, 0, 0, C_XPRE},
 	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NSOREG_4, 67, 4, 0, 0, C_XPOST},
@@ -808,14 +806,8 @@ var optab = []Optab{
 	{ASTPW, C_PAIR, C_NONE, C_NONE, C_PSOREG_4, 67, 4, 0, 0, C_XPRE},
 	{ASTPW, C_PAIR, C_NONE, C_NONE, C_PSOREG_4, 67, 4, 0, 0, C_XPOST},
 	{ASTPW, C_PAIR, C_NONE, C_NONE, C_UOREG4K, 76, 8, 0, 0, 0},
-	{ASTPW, C_PAIR, C_NONE, C_NONE, C_UOREG4K, 76, 8, 0, 0, C_XPRE},
-	{ASTPW, C_PAIR, C_NONE, C_NONE, C_UOREG4K, 76, 8, 0, 0, C_XPOST},
 	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NOREG4K, 76, 8, 0, 0, 0},
-	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NOREG4K, 76, 8, 0, 0, C_XPRE},
-	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NOREG4K, 76, 8, 0, 0, C_XPOST},
 	{ASTPW, C_PAIR, C_NONE, C_NONE, C_LOREG, 77, 12, 0, LTO, 0},
-	{ASTPW, C_PAIR, C_NONE, C_NONE, C_LOREG, 77, 12, 0, LTO, C_XPRE},
-	{ASTPW, C_PAIR, C_NONE, C_NONE, C_LOREG, 77, 12, 0, LTO, C_XPOST},
 	{ASTPW, C_PAIR, C_NONE, C_NONE, C_ADDR, 87, 12, 0, 0, 0},
 
 	{ASWPD, C_REG, C_NONE, C_NONE, C_ZOREG, 47, 4, 0, 0, 0},        // RegTo2=C_REG
@@ -1276,12 +1268,27 @@ func (c *ctxt7) addpool(p *obj.Prog, a *obj.Addr) {
 	case C_ADDCON:
 		fallthrough
 
-	case C_ZAUTO,
-		C_PSAUTO,
+	case C_ADDCON2,
+		C_LCON,
+		C_VCON,
+		C_LACON,
+
+		C_ZAUTO,
+		C_NSAUTO_16,
+		C_NSAUTO_8,
+		C_NSAUTO_4,
+		C_NSAUTO,
+		C_NPAUTO_16,
+		C_NPAUTO,
+		C_NQAUTO_16,
+		C_NAUTO4K,
+		C_PSAUTO_16,
 		C_PSAUTO_8,
 		C_PSAUTO_4,
+		C_PSAUTO,
 		C_PPAUTO_16,
 		C_PPAUTO,
+		C_PQAUTO_16,
 		C_UAUTO4K_16,
 		C_UAUTO4K_8,
 		C_UAUTO4K_4,
@@ -1297,17 +1304,24 @@ func (c *ctxt7) addpool(p *obj.Prog, a *obj.Addr) {
 		C_UAUTO32K_16,
 		C_UAUTO32K,
 		C_UAUTO64K,
-		C_NSAUTO_8,
-		C_NSAUTO_4,
-		C_NSAUTO,
-		C_NPAUTO,
-		C_NAUTO4K,
 		C_LAUTO,
-		C_PSOREG,
+
+		C_ZOREG,
+		C_NSOREG_16,
+		C_NSOREG_8,
+		C_NSOREG_4,
+		C_NSOREG,
+		C_NPOREG_16,
+		C_NPOREG,
+		C_NQOREG_16,
+		C_NOREG4K,
+		C_PSOREG_16,
 		C_PSOREG_8,
 		C_PSOREG_4,
+		C_PSOREG,
 		C_PPOREG_16,
 		C_PPOREG,
+		C_PQOREG_16,
 		C_UOREG4K_16,
 		C_UOREG4K_8,
 		C_UOREG4K_4,
@@ -1323,16 +1337,7 @@ func (c *ctxt7) addpool(p *obj.Prog, a *obj.Addr) {
 		C_UOREG32K_16,
 		C_UOREG32K,
 		C_UOREG64K,
-		C_NSOREG_8,
-		C_NSOREG_4,
-		C_NSOREG,
-		C_NPOREG,
-		C_NOREG4K,
-		C_LOREG,
-		C_LACON,
-		C_ADDCON2,
-		C_LCON,
-		C_VCON:
+		C_LOREG:
 		if a.Name == obj.NAME_EXTERN {
 			fmt.Printf("addpool: %v in %v needs reloc\n", DRconv(cls), p)
 		}
@@ -1590,6 +1595,9 @@ func autoclass(l int64) int {
 	}
 
 	if l < 0 {
+		if l >= -256 && (l&15) == 0 {
+			return C_NSAUTO_16
+		}
 		if l >= -256 && (l&7) == 0 {
 			return C_NSAUTO_8
 		}
@@ -1599,9 +1607,15 @@ func autoclass(l int64) int {
 		if l >= -256 {
 			return C_NSAUTO
 		}
+		if l >= -512 && (l&15) == 0 {
+			return C_NPAUTO_16
+		}
 		if l >= -512 && (l&7) == 0 {
 			return C_NPAUTO
 		}
+		if l >= -1024 && (l&15) == 0 {
+			return C_NQAUTO_16
+		}
 		if l >= -4095 {
 			return C_NAUTO4K
 		}
@@ -1609,6 +1623,9 @@ func autoclass(l int64) int {
 	}
 
 	if l <= 255 {
+		if (l & 15) == 0 {
+			return C_PSAUTO_16
+		}
 		if (l & 7) == 0 {
 			return C_PSAUTO_8
 		}
@@ -1625,6 +1642,11 @@ func autoclass(l int64) int {
 			return C_PPAUTO
 		}
 	}
+	if l <= 1008 {
+		if l&15 == 0 {
+			return C_PQAUTO_16
+		}
+	}
 	if l <= 4095 {
 		if l&15 == 0 {
 			return C_UAUTO4K_16
@@ -2193,64 +2215,99 @@ func cmp(a int, b int) bool {
 			return true
 		}
 
+	case C_NSAUTO_8:
+		if b == C_NSAUTO_16 {
+			return true
+		}
+
 	case C_NSAUTO_4:
-		if b == C_NSAUTO_8 {
+		if b == C_NSAUTO_16 || b == C_NSAUTO_8 {
 			return true
 		}
 
 	case C_NSAUTO:
 		switch b {
-		case C_NSAUTO_4, C_NSAUTO_8:
+		case C_NSAUTO_4, C_NSAUTO_8, C_NSAUTO_16:
+			return true
+		}
+
+	case C_NPAUTO_16:
+		switch b {
+		case C_NSAUTO_16:
 			return true
 		}
 
 	case C_NPAUTO:
 		switch b {
-		case C_NSAUTO_8:
+		case C_NSAUTO_16, C_NSAUTO_8, C_NPAUTO_16:
+			return true
+		}
+
+	case C_NQAUTO_16:
+		switch b {
+		case C_NSAUTO_16, C_NPAUTO_16:
 			return true
 		}
 
 	case C_NAUTO4K:
 		switch b {
-		case C_NSAUTO_8, C_NSAUTO_4, C_NSAUTO, C_NPAUTO:
+		case C_NSAUTO_16, C_NSAUTO_8, C_NSAUTO_4, C_NSAUTO, C_NPAUTO_16,
+			C_NPAUTO, C_NQAUTO_16:
 			return true
 		}
 
-	case C_PSAUTO_8:
+	case C_PSAUTO_16:
 		if b == C_ZAUTO {
 			return true
 		}
 
+	case C_PSAUTO_8:
+		if b == C_ZAUTO || b == C_PSAUTO_16 {
+			return true
+		}
+
 	case C_PSAUTO_4:
 		switch b {
-		case C_ZAUTO, C_PSAUTO_8:
+		case C_ZAUTO, C_PSAUTO_16, C_PSAUTO_8:
 			return true
 		}
 
 	case C_PSAUTO:
 		switch b {
-		case C_ZAUTO, C_PSAUTO_8, C_PSAUTO_4:
+		case C_ZAUTO, C_PSAUTO_16, C_PSAUTO_8, C_PSAUTO_4:
+			return true
+		}
+
+	case C_PPAUTO_16:
+		switch b {
+		case C_ZAUTO, C_PSAUTO_16:
 			return true
 		}
 
 	case C_PPAUTO:
 		switch b {
-		case C_ZAUTO, C_PSAUTO_8, C_PPAUTO_16:
+		case C_ZAUTO, C_PSAUTO_16, C_PSAUTO_8, C_PPAUTO_16:
+			return true
+		}
+
+	case C_PQAUTO_16:
+		switch b {
+		case C_ZAUTO, C_PSAUTO_16, C_PPAUTO_16:
 			return true
 		}
 
 	case C_UAUTO4K:
 		switch b {
-		case C_ZAUTO, C_PSAUTO, C_PSAUTO_4, C_PSAUTO_8,
-			C_PPAUTO, C_PPAUTO_16,
+		case C_ZAUTO, C_PSAUTO, C_PSAUTO_4, C_PSAUTO_8, C_PSAUTO_16,
+			C_PPAUTO, C_PPAUTO_16, C_PQAUTO_16,
 			C_UAUTO4K_2, C_UAUTO4K_4, C_UAUTO4K_8, C_UAUTO4K_16:
 			return true
 		}
 
 	case C_UAUTO8K:
 		switch b {
-		case C_ZAUTO, C_PSAUTO, C_PSAUTO_4, C_PSAUTO_8,
-			C_PPAUTO, C_PPAUTO_16,
+		case C_ZAUTO, C_PSAUTO, C_PSAUTO_4, C_PSAUTO_8, C_PSAUTO_16,
+			C_PPAUTO, C_PPAUTO_16, C_PQAUTO_16,
 			C_UAUTO4K_2, C_UAUTO4K_4, C_UAUTO4K_8, C_UAUTO4K_16,
 			C_UAUTO8K_4, C_UAUTO8K_8, C_UAUTO8K_16:
 			return true
@@ -2258,8 +2315,8 @@ func cmp(a int, b int) bool {
 
 	case C_UAUTO16K:
 		switch b {
-		case C_ZAUTO, C_PSAUTO, C_PSAUTO_4, C_PSAUTO_8,
-			C_PPAUTO, C_PPAUTO_16,
+		case C_ZAUTO, C_PSAUTO, C_PSAUTO_4, C_PSAUTO_8, C_PSAUTO_16,
+			C_PPAUTO, C_PPAUTO_16, C_PQAUTO_16,
 			C_UAUTO4K_4, C_UAUTO4K_8, C_UAUTO4K_16,
 			C_UAUTO8K_4, C_UAUTO8K_8, C_UAUTO8K_16,
 			C_UAUTO16K_8, C_UAUTO16K_16:
@@ -2268,8 +2325,8 @@ func cmp(a int, b int) bool {
 
 	case C_UAUTO32K:
 		switch b {
-		case C_ZAUTO, C_PSAUTO, C_PSAUTO_4, C_PSAUTO_8,
-			C_PPAUTO, C_PPAUTO_16,
+		case C_ZAUTO, C_PSAUTO, C_PSAUTO_4, C_PSAUTO_8, C_PSAUTO_16,
+			C_PPAUTO, C_PPAUTO_16, C_PQAUTO_16,
 			C_UAUTO4K_8, C_UAUTO4K_16,
 			C_UAUTO8K_8, C_UAUTO8K_16,
 			C_UAUTO16K_8, C_UAUTO16K_16,
@@ -2279,17 +2336,17 @@ func cmp(a int, b int) bool {
 
 	case C_UAUTO64K:
 		switch b {
-		case C_ZAUTO, C_PSAUTO, C_PSAUTO_4, C_PSAUTO_8,
-			C_PPAUTO_16, C_UAUTO4K_16, C_UAUTO8K_16, C_UAUTO16K_16,
+		case C_ZAUTO, C_PSAUTO, C_PSAUTO_4, C_PSAUTO_8, C_PSAUTO_16,
+			C_PPAUTO_16, C_PQAUTO_16, C_UAUTO4K_16, C_UAUTO8K_16, C_UAUTO16K_16,
 			C_UAUTO32K_16:
 			return true
 		}
 
 	case C_LAUTO:
 		switch b {
-		case C_ZAUTO, C_NSAUTO, C_NSAUTO_4, C_NSAUTO_8, C_NPAUTO, C_NAUTO4K,
-			C_PSAUTO, C_PSAUTO_4, C_PSAUTO_8,
-			C_PPAUTO, C_PPAUTO_16,
+		case C_ZAUTO, C_NSAUTO, C_NSAUTO_4, C_NSAUTO_8, C_NSAUTO_16, C_NPAUTO_16, C_NPAUTO, C_NQAUTO_16, C_NAUTO4K,
+			C_PSAUTO, C_PSAUTO_4, C_PSAUTO_8, C_PSAUTO_16,
+			C_PPAUTO, C_PPAUTO_16, C_PQAUTO_16,
 			C_UAUTO4K, C_UAUTO4K_2, C_UAUTO4K_4, C_UAUTO4K_8, C_UAUTO4K_16,
 			C_UAUTO8K, C_UAUTO8K_4, C_UAUTO8K_8, C_UAUTO8K_16,
 			C_UAUTO16K, C_UAUTO16K_8, C_UAUTO16K_16,
@@ -2298,64 +2355,98 @@ func cmp(a int, b int) bool {
 			return true
 		}
 
+	case C_NSOREG_8:
+		if b == C_NSOREG_16 {
+			return true
+		}
+
 	case C_NSOREG_4:
-		if b == C_NSOREG_8 {
+		if b == C_NSOREG_8 || b == C_NSOREG_16 {
 			return true
 		}
 
 	case C_NSOREG:
 		switch b {
-		case C_NSOREG_4, C_NSOREG_8:
+		case C_NSOREG_4, C_NSOREG_8, C_NSOREG_16:
+			return true
+		}
+
+	case C_NPOREG_16:
+		switch b {
+		case C_NSOREG_16:
 			return true
 		}
 
 	case C_NPOREG:
 		switch b {
-		case C_NSOREG_8:
+		case C_NSOREG_16, C_NSOREG_8, C_NPOREG_16:
+			return true
+		}
+
+	case C_NQOREG_16:
+		switch b {
+		case C_NSOREG_16, C_NPOREG_16:
 			return true
 		}
 
 	case C_NOREG4K:
 		switch b {
-		case C_NSOREG_8, C_NSOREG_4, C_NSOREG, C_NPOREG:
+		case C_NSOREG_16, C_NSOREG_8, C_NSOREG_4, C_NSOREG, C_NPOREG_16, C_NPOREG, C_NQOREG_16:
 			return true
 		}
 
-	case C_PSOREG_8:
+	case C_PSOREG_16:
 		if b == C_ZOREG {
 			return true
 		}
 
+	case C_PSOREG_8:
+		if b == C_ZOREG || b == C_PSOREG_16 {
+			return true
+		}
+
 	case C_PSOREG_4:
 		switch b {
-		case C_ZOREG, C_PSOREG_8:
+		case C_ZOREG, C_PSOREG_16, C_PSOREG_8:
 			return true
 		}
 
 	case C_PSOREG:
 		switch b {
-		case C_ZOREG, C_PSOREG_8, C_PSOREG_4:
+		case C_ZOREG, C_PSOREG_16, C_PSOREG_8, C_PSOREG_4:
+			return true
+		}
+
+	case C_PPOREG_16:
+		switch b {
+		case C_ZOREG, C_PSOREG_16:
 			return true
 		}
 
 	case C_PPOREG:
 		switch b {
-		case C_ZOREG, C_PSOREG_8, C_PPOREG_16:
+		case C_ZOREG, C_PSOREG_16, C_PSOREG_8, C_PPOREG_16:
+			return true
+		}
+
+	case C_PQOREG_16:
+		switch b {
+		case C_ZOREG, C_PSOREG_16, C_PPOREG_16:
 			return true
 		}
 
 	case C_UOREG4K:
 		switch b {
-		case C_ZOREG, C_PSOREG, C_PSOREG_4, C_PSOREG_8,
-			C_PPOREG, C_PPOREG_16,
+		case C_ZOREG, C_PSOREG, C_PSOREG_4, C_PSOREG_8, C_PSOREG_16,
+			C_PPOREG, C_PPOREG_16, C_PQOREG_16,
 			C_UOREG4K_2, C_UOREG4K_4, C_UOREG4K_8, C_UOREG4K_16:
 			return true
 		}
 
 	case C_UOREG8K:
 		switch b {
-		case C_ZOREG, C_PSOREG, C_PSOREG_4, C_PSOREG_8,
-			C_PPOREG, C_PPOREG_16,
+		case C_ZOREG, C_PSOREG, C_PSOREG_4, C_PSOREG_8, C_PSOREG_16,
+			C_PPOREG, C_PPOREG_16, C_PQOREG_16,
 			C_UOREG4K_2, C_UOREG4K_4, C_UOREG4K_8, C_UOREG4K_16,
 			C_UOREG8K_4, C_UOREG8K_8, C_UOREG8K_16:
 			return true
@@ -2363,8 +2454,8 @@ func cmp(a int, b int) bool {
 
 	case C_UOREG16K:
 		switch b {
-		case C_ZOREG, C_PSOREG, C_PSOREG_4, C_PSOREG_8,
-			C_PPOREG, C_PPOREG_16,
+		case C_ZOREG, C_PSOREG, C_PSOREG_4, C_PSOREG_8, C_PSOREG_16,
+			C_PPOREG, C_PPOREG_16, C_PQOREG_16,
 			C_UOREG4K_4, C_UOREG4K_8, C_UOREG4K_16,
 			C_UOREG8K_4, C_UOREG8K_8, C_UOREG8K_16,
 			C_UOREG16K_8, C_UOREG16K_16:
@@ -2373,8 +2464,8 @@ func cmp(a int, b int) bool {
 
 	case C_UOREG32K:
 		switch b {
-		case C_ZOREG, C_PSOREG, C_PSOREG_4, C_PSOREG_8,
-			C_PPOREG, C_PPOREG_16,
+		case C_ZOREG, C_PSOREG, C_PSOREG_4, C_PSOREG_8, C_PSOREG_16,
+			C_PPOREG, C_PPOREG_16, C_PQOREG_16,
 			C_UOREG4K_8, C_UOREG4K_16,
 			C_UOREG8K_8, C_UOREG8K_16,
 			C_UOREG16K_8, C_UOREG16K_16,
@@ -2384,17 +2475,17 @@ func cmp(a int, b int) bool {
 
 	case C_UOREG64K:
 		switch b {
-		case C_ZOREG, C_PSOREG, C_PSOREG_4, C_PSOREG_8,
-			C_PPOREG_16, C_UOREG4K_16, C_UOREG8K_16, C_UOREG16K_16,
+		case C_ZOREG, C_PSOREG, C_PSOREG_4, C_PSOREG_8, C_PSOREG_16,
+			C_PPOREG_16, C_PQOREG_16, C_UOREG4K_16, C_UOREG8K_16, C_UOREG16K_16,
 			C_UOREG32K_16:
 			return true
 		}
 
 	case C_LOREG:
 		switch b {
-		case C_ZOREG, C_NSOREG, C_NSOREG_4, C_NSOREG_8, C_NPOREG, C_NOREG4K,
-			C_PSOREG, C_PSOREG_4, C_PSOREG_8,
-			C_PPOREG, C_PPOREG_16,
+		case C_ZOREG, C_NSOREG, C_NSOREG_4, C_NSOREG_8, C_NSOREG_16, C_NPOREG, C_NPOREG_16, C_NQOREG_16, C_NOREG4K,
+			C_PSOREG, C_PSOREG_4, C_PSOREG_8, C_PSOREG_16,
+			C_PPOREG, C_PPOREG_16, C_PQOREG_16,
 			C_UOREG4K, C_UOREG4K_2, C_UOREG4K_4, C_UOREG4K_8, C_UOREG4K_16,
 			C_UOREG8K, C_UOREG8K_4, C_UOREG8K_8, C_UOREG8K_16,
 			C_UOREG16K, C_UOREG16K_8, C_UOREG16K_16,
@@ -2722,6 +2813,10 @@ func buildop(ctxt *obj.Link) {
 			obj.ATEXT:
 			break
 
+		case AFLDPQ:
+			break
+		case AFSTPQ:
+			break
 		case ALDP:
 			oprangeset(AFLDPD, t)
 
@@ -7192,7 +7287,7 @@ func (c *ctxt7) opextr(p *obj.Prog, a obj.As, v int32, rn int, rm int, rt int) u
 	return o
 }
 
-/* genrate instruction encoding for LDP/LDPW/LDPSW/STP/STPW */
+/* genrate instruction encoding for ldp and stp series */
 func (c *ctxt7) opldpstp(p *obj.Prog, o *Optab, vo int32, rbase, rl, rh, ldp uint32) uint32 {
 	wback := false
 	if o.scond == C_XPOST || o.scond == C_XPRE {
@@ -7205,30 +7300,36 @@ func (c *ctxt7) opldpstp(p *obj.Prog, o *Optab, vo int32, rbase, rl, rh, ldp uin
 		if wback == true {
 			c.checkUnpredictable(p, false, true, p.To.Reg, p.From.Reg, int16(p.From.Offset))
 		}
-	case AFLDPD, AFLDPS:
+	case AFLDPD, AFLDPQ, AFLDPS:
 		c.checkUnpredictable(p, true, false, p.From.Reg, p.To.Reg, int16(p.To.Offset))
 	}
 	var ret uint32
 	// check offset
 	switch p.As {
-	case AFLDPD, AFSTPD:
-		if vo < -512 || vo > 504 || vo%8 != 0 {
+	case AFLDPQ, AFSTPQ:
+		if vo < -1024 || vo > 1008 || vo%16 != 0 {
 			c.ctxt.Diag("invalid offset %v\n", p)
 		}
-		vo /= 8
-		ret = 1<<30 | 1<<26
-	case ALDP, ASTP:
+		vo /= 16
+		ret = 2<<30 | 1<<26
+	case AFLDPD, AFSTPD:
 		if vo < -512 || vo > 504 || vo%8 != 0 {
 			c.ctxt.Diag("invalid offset %v\n", p)
 		}
 		vo /= 8
-		ret = 2 << 30
+		ret = 1<<30 | 1<<26
 	case AFLDPS, AFSTPS:
 		if vo < -256 || vo > 252 || vo%4 != 0 {
 			c.ctxt.Diag("invalid offset %v\n", p)
 		}
 		vo /= 4
 		ret = 1 << 26
+	case ALDP, ASTP:
+		if vo < -512 || vo > 504 || vo%8 != 0 {
+			c.ctxt.Diag("invalid offset %v\n", p)
+		}
+		vo /= 8
+		ret = 2 << 30
 	case ALDPW, ASTPW:
 		if vo < -256 || vo > 252 || vo%4 != 0 {
 			c.ctxt.Diag("invalid offset %v\n", p)
@@ -7246,7 +7347,7 @@ func (c *ctxt7) opldpstp(p *obj.Prog, o *Optab, vo int32, rbase, rl, rh, ldp uin
 	}
 	// check register pair
 	switch p.As {
-	case AFLDPD, AFLDPS, AFSTPD, AFSTPS:
+	case AFLDPQ, AFLDPD, AFLDPS, AFSTPQ, AFSTPD, AFSTPS:
 		if rl < REG_F0 || REG_F31 < rl || rh < REG_F0 || REG_F31 < rh {
 			c.ctxt.Diag("invalid register pair %v\n", p)
 		}
-- 
GitLab


From 726d704c32acf99a9ed44d81c99adb22d4759241 Mon Sep 17 00:00:00 2001
From: eric fang <eric.fang@arm.com>
Date: Thu, 19 Nov 2020 07:18:41 +0000
Subject: [PATCH 0909/2400] cmd/asm: add arm64 instructions VUMAX and VUMIN

This CL adds support for arm64 fp&simd instructions VUMAX and VUMIN.
Fixes #42326

Change-Id: I3757ba165dc31ce1ce70f3b06a9e5b94c14d2ab9
Reviewed-on: https://go-review.googlesource.com/c/go/+/271497
Trust: eric fang <eric.fang@arm.com>
Run-TryBot: eric fang <eric.fang@arm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: fannie zhang <Fannie.Zhang@arm.com>
Reviewed-by: eric fang <eric.fang@arm.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/asm/internal/asm/testdata/arm64.s      | 12 ++++++++++++
 src/cmd/asm/internal/asm/testdata/arm64error.s |  4 ++++
 src/cmd/internal/obj/arm64/a.out.go            |  2 ++
 src/cmd/internal/obj/arm64/anames.go           |  2 ++
 src/cmd/internal/obj/arm64/asm7.go             | 12 ++++++++++++
 5 files changed, 32 insertions(+)

diff --git a/src/cmd/asm/internal/asm/testdata/arm64.s b/src/cmd/asm/internal/asm/testdata/arm64.s
index 1e6cde7a46..c1385a13ab 100644
--- a/src/cmd/asm/internal/asm/testdata/arm64.s
+++ b/src/cmd/asm/internal/asm/testdata/arm64.s
@@ -207,6 +207,18 @@ TEXT	foo(SB), DUPOK|NOSPLIT, $-8
 	VUADDW2	V9.B16, V12.H8, V14.H8          // 8e11296e
 	VUADDW2	V13.H8, V20.S4, V30.S4          // 9e126d6e
 	VUADDW2	V21.S4, V24.D2, V29.D2          // 1d13b56e
+	VUMAX	V3.B8, V2.B8, V1.B8             // 4164232e
+	VUMAX	V3.B16, V2.B16, V1.B16          // 4164236e
+	VUMAX	V3.H4, V2.H4, V1.H4             // 4164632e
+	VUMAX	V3.H8, V2.H8, V1.H8             // 4164636e
+	VUMAX	V3.S2, V2.S2, V1.S2             // 4164a32e
+	VUMAX	V3.S4, V2.S4, V1.S4             // 4164a36e
+	VUMIN	V3.B8, V2.B8, V1.B8             // 416c232e
+	VUMIN	V3.B16, V2.B16, V1.B16          // 416c236e
+	VUMIN	V3.H4, V2.H4, V1.H4             // 416c632e
+	VUMIN	V3.H8, V2.H8, V1.H8             // 416c636e
+	VUMIN	V3.S2, V2.S2, V1.S2             // 416ca32e
+	VUMIN	V3.S4, V2.S4, V1.S4             // 416ca36e
 	FCCMPS	LT, F1, F2, $1	                // 41b4211e
 	FMADDS	F1, F3, F2, F4                  // 440c011f
 	FMADDD	F4, F5, F4, F4                  // 8414441f
diff --git a/src/cmd/asm/internal/asm/testdata/arm64error.s b/src/cmd/asm/internal/asm/testdata/arm64error.s
index 9b4f42a8ff..1c8eaa1752 100644
--- a/src/cmd/asm/internal/asm/testdata/arm64error.s
+++ b/src/cmd/asm/internal/asm/testdata/arm64error.s
@@ -358,6 +358,10 @@ TEXT errors(SB),$0
 	VBIF	V0.D2, V1.D2, V2.D2                              // ERROR "invalid arrangement"
 	VUADDW	V9.B8, V12.H8, V14.B8                            // ERROR "invalid arrangement"
 	VUADDW2	V9.B8, V12.S4, V14.S4                            // ERROR "operand mismatch"
+	VUMAX   V1.D2, V2.D2, V3.D2                              // ERROR "invalid arrangement"
+	VUMIN   V1.D2, V2.D2, V3.D2                              // ERROR "invalid arrangement"
+	VUMAX	V1.B8, V2.B8, V3.B16                             // ERROR "operand mismatch"
+	VUMIN	V1.H4, V2.S4, V3.H4                              // ERROR "operand mismatch"
 	VSLI	$64, V7.D2, V8.D2                                // ERROR "shift out of range"
 	VUSRA   $0, V7.D2, V8.D2                                 // ERROR "shift out of range"
 	CASPD	(R3, R4), (R2), (R8, R9)                         // ERROR "source register pair must start from even register"
diff --git a/src/cmd/internal/obj/arm64/a.out.go b/src/cmd/internal/obj/arm64/a.out.go
index ed07f18691..bf75bb4a89 100644
--- a/src/cmd/internal/obj/arm64/a.out.go
+++ b/src/cmd/internal/obj/arm64/a.out.go
@@ -1031,6 +1031,8 @@ const (
 	AVEXT
 	AVRBIT
 	AVRAX1
+	AVUMAX
+	AVUMIN
 	AVUSHR
 	AVUSHLL
 	AVUSHLL2
diff --git a/src/cmd/internal/obj/arm64/anames.go b/src/cmd/internal/obj/arm64/anames.go
index 0fb28536c4..9cc5871648 100644
--- a/src/cmd/internal/obj/arm64/anames.go
+++ b/src/cmd/internal/obj/arm64/anames.go
@@ -515,6 +515,8 @@ var Anames = []string{
 	"VEXT",
 	"VRBIT",
 	"VRAX1",
+	"VUMAX",
+	"VUMIN",
 	"VUSHR",
 	"VUSHLL",
 	"VUSHLL2",
diff --git a/src/cmd/internal/obj/arm64/asm7.go b/src/cmd/internal/obj/arm64/asm7.go
index 5937ebd732..f7c0a48214 100644
--- a/src/cmd/internal/obj/arm64/asm7.go
+++ b/src/cmd/internal/obj/arm64/asm7.go
@@ -3017,6 +3017,8 @@ func buildop(ctxt *obj.Link) {
 			oprangeset(AVBSL, t)
 			oprangeset(AVBIT, t)
 			oprangeset(AVCMTST, t)
+			oprangeset(AVUMAX, t)
+			oprangeset(AVUMIN, t)
 			oprangeset(AVUZP1, t)
 			oprangeset(AVUZP2, t)
 			oprangeset(AVBIF, t)
@@ -4529,6 +4531,10 @@ func (c *ctxt7) asmout(p *obj.Prog, o *Optab, out []uint32) {
 			if af != ARNG_2D && af != ARNG_2S && af != ARNG_4S {
 				c.ctxt.Diag("invalid arrangement: %v", p)
 			}
+		case AVUMAX, AVUMIN:
+			if af == ARNG_2D {
+				c.ctxt.Diag("invalid arrangement: %v", p)
+			}
 		}
 		switch p.As {
 		case AVAND, AVEOR:
@@ -6205,6 +6211,12 @@ func (c *ctxt7) oprrr(p *obj.Prog, a obj.As) uint32 {
 	case AVCMTST:
 		return 0xE<<24 | 1<<21 | 0x23<<10
 
+	case AVUMAX:
+		return 1<<29 | 7<<25 | 1<<21 | 0x19<<10
+
+	case AVUMIN:
+		return 1<<29 | 7<<25 | 1<<21 | 0x1b<<10
+
 	case AVUZP1:
 		return 7<<25 | 3<<11
 
-- 
GitLab


From 355c3a037edd8107bc4f1918d7a84764039ac6d1 Mon Sep 17 00:00:00 2001
From: eric fang <eric.fang@arm.com>
Date: Mon, 1 Feb 2021 07:47:06 +0000
Subject: [PATCH 0910/2400] cmd/internal/obj/asm64: add support for moving
 BITCON to RSP

Constant of BITCON type can be moved into RSP by MOVD or MOVW instructions
directly, this CL enables this format of these two instructions.

For 32-bit ADDWop instructions with constant, rewrite the high 32-bit
to be a repetition of the low 32-bit, just as ANDWop instructions do,
so that we can optimize ADDW $bitcon, Rn, Rt as:
MOVW $bitcon, Rtmp
ADDW Rtmp, Rn, Rt
The original code is:
MOVZ $bitcon_low, Rtmp
MOVK $bitcon_high,Rtmp
ADDW Rtmp, Rn, Rt

Change-Id: I30e71972bcfd6470a8b6e6ffbacaee79d523805a
Reviewed-on: https://go-review.googlesource.com/c/go/+/289649
Trust: eric fang <eric.fang@arm.com>
Run-TryBot: eric fang <eric.fang@arm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: eric fang <eric.fang@arm.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/asm/internal/asm/testdata/arm64.s |  3 +++
 src/cmd/internal/obj/arm64/asm7.go        | 19 ++++++-------------
 src/cmd/internal/obj/arm64/obj7.go        | 14 +++++++-------
 3 files changed, 16 insertions(+), 20 deletions(-)

diff --git a/src/cmd/asm/internal/asm/testdata/arm64.s b/src/cmd/asm/internal/asm/testdata/arm64.s
index c1385a13ab..17ecd9b2b8 100644
--- a/src/cmd/asm/internal/asm/testdata/arm64.s
+++ b/src/cmd/asm/internal/asm/testdata/arm64.s
@@ -364,6 +364,9 @@ TEXT	foo(SB), DUPOK|NOSPLIT, $-8
 	MOVD	$1, ZR
 	MOVD	$1, R1
 	MOVK	$1, R1
+	MOVD	$0x1000100010001000, RSP      // MOVD	$1152939097061330944, RSP   // ff8304b2
+	MOVW	$0x10001000, RSP              // MOVW	$268439552, RSP             // ff830432
+	ADDW	$0x10001000, R1               // ADDW	$268439552, R1              // fb83043221001b0b
 
 // move a large constant to a Vd.
 	VMOVS	$0x80402010, V11                                      // VMOVS	$2151686160, V11
diff --git a/src/cmd/internal/obj/arm64/asm7.go b/src/cmd/internal/obj/arm64/asm7.go
index f7c0a48214..3b0fa6fb53 100644
--- a/src/cmd/internal/obj/arm64/asm7.go
+++ b/src/cmd/internal/obj/arm64/asm7.go
@@ -404,8 +404,8 @@ var optab = []Optab{
 	/* MOVs that become MOVK/MOVN/MOVZ/ADD/SUB/OR */
 	{AMOVW, C_MOVCON, C_NONE, C_NONE, C_REG, 32, 4, 0, 0, 0},
 	{AMOVD, C_MOVCON, C_NONE, C_NONE, C_REG, 32, 4, 0, 0, 0},
-	{AMOVW, C_BITCON, C_NONE, C_NONE, C_REG, 32, 4, 0, 0, 0},
-	{AMOVD, C_BITCON, C_NONE, C_NONE, C_REG, 32, 4, 0, 0, 0},
+	{AMOVW, C_BITCON, C_NONE, C_NONE, C_RSP, 32, 4, 0, 0, 0},
+	{AMOVD, C_BITCON, C_NONE, C_NONE, C_RSP, 32, 4, 0, 0, 0},
 	{AMOVW, C_MOVCON2, C_NONE, C_NONE, C_REG, 12, 8, 0, NOTUSETMP, 0},
 	{AMOVD, C_MOVCON2, C_NONE, C_NONE, C_REG, 12, 8, 0, NOTUSETMP, 0},
 	{AMOVD, C_MOVCON3, C_NONE, C_NONE, C_REG, 12, 12, 0, NOTUSETMP, 0},
@@ -2060,9 +2060,10 @@ func (c *ctxt7) oplook(p *obj.Prog) *Optab {
 		}
 		a1 = a0 + 1
 		p.From.Class = int8(a1)
-		// more specific classification of 32-bit integers
 		if p.From.Type == obj.TYPE_CONST && p.From.Name == obj.NAME_NONE {
-			if p.As == AMOVW || isADDWop(p.As) {
+			if p.As == AMOVW || isADDWop(p.As) || isANDWop(p.As) {
+				// For 32-bit instruction with constant, we need to
+				// treat its offset value as 32 bits to classify it.
 				ra0 := c.con32class(&p.From)
 				// do not break C_ADDCON2 when S bit is set
 				if (p.As == AADDSW || p.As == ASUBSW) && ra0 == C_ADDCON2 {
@@ -2071,16 +2072,8 @@ func (c *ctxt7) oplook(p *obj.Prog) *Optab {
 				a1 = ra0 + 1
 				p.From.Class = int8(a1)
 			}
-			if isANDWop(p.As) && a0 != C_BITCON {
-				// For 32-bit logical instruction with constant,
-				// the BITCON test is special in that it looks at
-				// the 64-bit which has the high 32-bit as a copy
-				// of the low 32-bit. We have handled that and
-				// don't pass it to con32class.
-				a1 = c.con32class(&p.From) + 1
-				p.From.Class = int8(a1)
-			}
 			if ((p.As == AMOVD) || isANDop(p.As) || isADDop(p.As)) && (a0 == C_LCON || a0 == C_VCON) {
+				// more specific classification of 64-bit integers
 				a1 = c.con64class(&p.From) + 1
 				p.From.Class = int8(a1)
 			}
diff --git a/src/cmd/internal/obj/arm64/obj7.go b/src/cmd/internal/obj/arm64/obj7.go
index 8f7648e5d5..425cb88f7e 100644
--- a/src/cmd/internal/obj/arm64/obj7.go
+++ b/src/cmd/internal/obj/arm64/obj7.go
@@ -314,13 +314,13 @@ func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
 		}
 	}
 
-	// For 32-bit logical instruction with constant,
-	// rewrite the high 32-bit to be a repetition of
-	// the low 32-bit, so that the BITCON test can be
-	// shared for both 32-bit and 64-bit. 32-bit ops
-	// will zero the high 32-bit of the destination
-	// register anyway.
-	if isANDWop(p.As) && p.From.Type == obj.TYPE_CONST {
+	// For 32-bit instruction with constant, rewrite
+	// the high 32-bit to be a repetition of the low
+	// 32-bit, so that the BITCON test can be shared
+	// for both 32-bit and 64-bit. 32-bit ops will
+	// zero the high 32-bit of the destination register
+	// anyway.
+	if (isANDWop(p.As) || isADDWop(p.As) || p.As == AMOVW) && p.From.Type == obj.TYPE_CONST {
 		v := p.From.Offset & 0xffffffff
 		p.From.Offset = v | v<<32
 	}
-- 
GitLab


From 593f5bbad7727f57ce452c4aa93604e8dabbba7d Mon Sep 17 00:00:00 2001
From: eric fang <eric.fang@arm.com>
Date: Wed, 4 Nov 2020 09:26:28 +0000
Subject: [PATCH 0911/2400] cmd/compile: adjust stack slot alignment
 requirements on arm64

Currently any variable that is spilled onto the stack will occupy at least 8 bytes,
because the stack offset is required to be aligned with 8 bytes on linux/arm64.
This CL removes this constraint by aligning the stack slot with its actual size.

Updates #42385

Change-Id: Icbd63dc70cd19852802e43f134355f19ba7e1e29
Reviewed-on: https://go-review.googlesource.com/c/go/+/267999
Trust: eric fang <eric.fang@arm.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssagen/pgen.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ssagen/pgen.go b/src/cmd/compile/internal/ssagen/pgen.go
index b675d1c876..7e15f54299 100644
--- a/src/cmd/compile/internal/ssagen/pgen.go
+++ b/src/cmd/compile/internal/ssagen/pgen.go
@@ -138,7 +138,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 		} else {
 			lastHasPtr = false
 		}
-		if Arch.LinkArch.InFamily(sys.ARM, sys.ARM64, sys.PPC64) {
+		if Arch.LinkArch.InFamily(sys.ARM, sys.PPC64) {
 			s.stksize = types.Rnd(s.stksize, int64(types.PtrSize))
 		}
 		n.SetFrameOffset(-s.stksize)
-- 
GitLab


From 27dbc4551a37a48cf7c020db0aeac6f2841883dc Mon Sep 17 00:00:00 2001
From: eric fang <eric.fang@arm.com>
Date: Thu, 4 Feb 2021 03:08:20 +0000
Subject: [PATCH 0912/2400] cmd/asm: disable scaled register format for arm64

Arm64 doesn't have scaled register format, such as (R1*2), (R1)(R2*3),
but currently the assembler doesn't report an error for such kind of
instruction operand format. This CL disables the scaled register
operand format for arm64 and reports an error if this kind of instruction
format is seen.
With this CL, the assembler won't print (R1)(R2) as (R1)(R2*1), so that
we can make the assembly test simpler.

Change-Id: I6d7569065597215be4c767032a63648d2ad16fed
Reviewed-on: https://go-review.googlesource.com/c/go/+/289589
Trust: eric fang <eric.fang@arm.com>
Run-TryBot: eric fang <eric.fang@arm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: eric fang <eric.fang@arm.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/asm/internal/asm/parse.go            |  8 ++--
 src/cmd/asm/internal/asm/testdata/arm64.s    | 48 ++++++++++----------
 src/cmd/asm/internal/asm/testdata/arm64enc.s | 44 +++++++++---------
 3 files changed, 51 insertions(+), 49 deletions(-)

diff --git a/src/cmd/asm/internal/asm/parse.go b/src/cmd/asm/internal/asm/parse.go
index f1d37bc2c8..2c7332877f 100644
--- a/src/cmd/asm/internal/asm/parse.go
+++ b/src/cmd/asm/internal/asm/parse.go
@@ -999,15 +999,17 @@ func (p *Parser) registerIndirect(a *obj.Addr, prefix rune) {
 				p.errorf("unimplemented two-register form")
 			}
 			a.Index = r1
-			if scale == 0 && p.arch.Family == sys.ARM64 {
-				// scale is 1 by default for ARM64
-				a.Scale = 1
+			if scale != 0 && p.arch.Family == sys.ARM64 {
+				p.errorf("arm64 doesn't support scaled register format")
 			} else {
 				a.Scale = int16(scale)
 			}
 		}
 		p.get(')')
 	} else if scale != 0 {
+		if p.arch.Family == sys.ARM64 {
+			p.errorf("arm64 doesn't support scaled register format")
+		}
 		// First (R) was missing, all we have is (R*scale).
 		a.Reg = 0
 		a.Index = r1
diff --git a/src/cmd/asm/internal/asm/testdata/arm64.s b/src/cmd/asm/internal/asm/testdata/arm64.s
index 17ecd9b2b8..8635708320 100644
--- a/src/cmd/asm/internal/asm/testdata/arm64.s
+++ b/src/cmd/asm/internal/asm/testdata/arm64.s
@@ -395,13 +395,13 @@ TEXT	foo(SB), DUPOK|NOSPLIT, $-8
 // LD1/ST1
 	VLD1	(R8), [V1.B16, V2.B16]                          // 01a1404c
 	VLD1.P	(R3), [V31.H8, V0.H8]                           // 7fa4df4c
-	VLD1.P	(R8)(R20), [V21.B16, V22.B16]                   // VLD1.P	(R8)(R20*1), [V21.B16,V22.B16] // 15a1d44c
+	VLD1.P	(R8)(R20), [V21.B16, V22.B16]                   // 15a1d44c
 	VLD1.P	64(R1), [V5.B16, V6.B16, V7.B16, V8.B16]        // 2520df4c
 	VLD1.P	1(R0), V4.B[15]                                 // 041cdf4d
 	VLD1.P	2(R0), V4.H[7]                                  // 0458df4d
 	VLD1.P	4(R0), V4.S[3]                                  // 0490df4d
 	VLD1.P	8(R0), V4.D[1]                                  // 0484df4d
-	VLD1.P	(R0)(R1), V4.D[1]                               // VLD1.P	(R0)(R1*1), V4.D[1] // 0484c14d
+	VLD1.P	(R0)(R1), V4.D[1]                               // 0484c14d
 	VLD1	(R0), V4.D[1]                                   // 0484404d
 	VST1.P	[V4.S4, V5.S4], 32(R1)                          // 24a89f4c
 	VST1	[V0.S4, V1.S4], (R0)                            // 00a8004c
@@ -409,29 +409,29 @@ TEXT	foo(SB), DUPOK|NOSPLIT, $-8
 	VLD1.P	24(R30), [V3.S2,V4.S2,V5.S2]                    // c36bdf0c
 	VLD2	(R29), [V23.H8, V24.H8]                         // b787404c
 	VLD2.P	16(R0), [V18.B8, V19.B8]                        // 1280df0c
-	VLD2.P	(R1)(R2), [V15.S2, V16.S2]                      // VLD2.P	(R1)(R2*1), [V15.S2,V16.S2] // 2f88c20c
+	VLD2.P	(R1)(R2), [V15.S2, V16.S2]                      // 2f88c20c
 	VLD3	(R27), [V11.S4, V12.S4, V13.S4]                 // 6b4b404c
 	VLD3.P	48(RSP), [V11.S4, V12.S4, V13.S4]               // eb4bdf4c
-	VLD3.P	(R30)(R2), [V14.D2, V15.D2, V16.D2]             // VLD3.P	(R30)(R2*1), [V14.D2,V15.D2,V16.D2] // ce4fc24c
+	VLD3.P	(R30)(R2), [V14.D2, V15.D2, V16.D2]             // ce4fc24c
 	VLD4	(R15), [V10.H4, V11.H4, V12.H4, V13.H4]         // ea05400c
 	VLD4.P	32(R24), [V31.B8, V0.B8, V1.B8, V2.B8]          // 1f03df0c
-	VLD4.P	(R13)(R9), [V14.S2, V15.S2, V16.S2, V17.S2]     // VLD4.P	(R13)(R9*1), [V14.S2,V15.S2,V16.S2,V17.S2] // ae09c90c
+	VLD4.P	(R13)(R9), [V14.S2, V15.S2, V16.S2, V17.S2]     // ae09c90c
 	VLD1R	(R1), [V9.B8]                                   // 29c0400d
 	VLD1R.P	(R1), [V9.B8]                                   // 29c0df0d
 	VLD1R.P	1(R1), [V2.B8]                                  // 22c0df0d
 	VLD1R.P	2(R1), [V2.H4]                                  // 22c4df0d
 	VLD1R	(R0), [V0.B16]                                  // 00c0404d
 	VLD1R.P	(R0), [V0.B16]                                  // 00c0df4d
-	VLD1R.P	(R15)(R1), [V15.H4]                             // VLD1R.P	(R15)(R1*1), [V15.H4] // efc5c10d
+	VLD1R.P	(R15)(R1), [V15.H4]                             // efc5c10d
 	VLD2R	(R15), [V15.H4, V16.H4]                         // efc5600d
 	VLD2R.P	16(R0), [V0.D2, V1.D2]                          // 00ccff4d
-	VLD2R.P	(R0)(R5), [V31.D1, V0.D1]                       // VLD2R.P	(R0)(R5*1), [V31.D1, V0.D1] // 1fcce50d
+	VLD2R.P	(R0)(R5), [V31.D1, V0.D1]                       // 1fcce50d
 	VLD3R	(RSP), [V31.S2, V0.S2, V1.S2]                   // ffeb400d
 	VLD3R.P	6(R15), [V15.H4, V16.H4, V17.H4]                // efe5df0d
-	VLD3R.P	(R15)(R6), [V15.H8, V16.H8, V17.H8]             // VLD3R.P	(R15)(R6*1), [V15.H8, V16.H8, V17.H8] // efe5c64d
+	VLD3R.P	(R15)(R6), [V15.H8, V16.H8, V17.H8]             // efe5c64d
 	VLD4R	(R0), [V0.B8, V1.B8, V2.B8, V3.B8]              // 00e0600d
 	VLD4R.P	16(RSP), [V31.S4, V0.S4, V1.S4, V2.S4]          // ffebff4d
-	VLD4R.P	(R15)(R9), [V15.H4, V16.H4, V17.H4, V18.H4]     // VLD4R.P	(R15)(R9*1), [V15.H4, V16.H4, V17.H4, V18.H4] // efe5e90d
+	VLD4R.P	(R15)(R9), [V15.H4, V16.H4, V17.H4, V18.H4]     // efe5e90d
 	VST1.P	[V24.S2], 8(R2)                                 // 58789f0c
 	VST1	[V29.S2, V30.S2], (R29)                         // bdab000c
 	VST1	[V14.H4, V15.H4, V16.H4], (R27)                 // 6e67000c
@@ -439,17 +439,17 @@ TEXT	foo(SB), DUPOK|NOSPLIT, $-8
 	VST1.P	V4.H[7], 2(R0)                                  // 04589f4d
 	VST1.P	V4.S[3], 4(R0)                                  // 04909f4d
 	VST1.P	V4.D[1], 8(R0)                                  // 04849f4d
-	VST1.P	V4.D[1], (R0)(R1)                               // VST1.P	V4.D[1], (R0)(R1*1) // 0484814d
+	VST1.P	V4.D[1], (R0)(R1)                               // 0484814d
 	VST1	V4.D[1], (R0)                                   // 0484004d
 	VST2	[V22.H8, V23.H8], (R23)                         // f686004c
 	VST2.P	[V14.H4, V15.H4], 16(R17)                       // 2e869f0c
-	VST2.P	[V14.H4, V15.H4], (R3)(R17)                     // VST2.P	[V14.H4,V15.H4], (R3)(R17*1) // 6e84910c
+	VST2.P	[V14.H4, V15.H4], (R3)(R17)                     // 6e84910c
 	VST3	[V1.D2, V2.D2, V3.D2], (R11)                    // 614d004c
 	VST3.P	[V18.S4, V19.S4, V20.S4], 48(R25)               // 324b9f4c
-	VST3.P	[V19.B8, V20.B8, V21.B8], (R3)(R7)              // VST3.P	[V19.B8, V20.B8, V21.B8], (R3)(R7*1) // 7340870c
+	VST3.P	[V19.B8, V20.B8, V21.B8], (R3)(R7)              // 7340870c
 	VST4	[V22.D2, V23.D2, V24.D2, V25.D2], (R3)          // 760c004c
 	VST4.P	[V14.D2, V15.D2, V16.D2, V17.D2], 64(R15)       // ee0d9f4c
-	VST4.P	[V24.B8, V25.B8, V26.B8, V27.B8], (R3)(R23)     // VST4.P	[V24.B8, V25.B8, V26.B8, V27.B8], (R3)(R23*1) // 7800970c
+	VST4.P	[V24.B8, V25.B8, V26.B8, V27.B8], (R3)(R23)     // 7800970c
 
 // pre/post-indexed
 	FMOVS.P	F20, 4(R0)                                      // 144400bc
@@ -536,29 +536,29 @@ TEXT	foo(SB), DUPOK|NOSPLIT, $-8
 
 // shifted or extended register offset.
 	MOVD	(R2)(R6.SXTW), R4               // 44c866f8
-	MOVD	(R3)(R6), R5                    // MOVD	(R3)(R6*1), R5               // 656866f8
-	MOVD	(R2)(R6), R4                    // MOVD	(R2)(R6*1), R4               // 446866f8
+	MOVD	(R3)(R6), R5                    // 656866f8
+	MOVD	(R2)(R6), R4                    // 446866f8
 	MOVWU	(R19)(R20<<2), R20              // 747a74b8
 	MOVD	(R2)(R6<<3), R4                 // 447866f8
 	MOVD	(R3)(R7.SXTX<<3), R8            // 68f867f8
 	MOVWU	(R5)(R4.UXTW), R10              // aa4864b8
 	MOVBU	(R3)(R9.UXTW), R8               // 68486938
-	MOVBU	(R5)(R8), R10                   // MOVBU	(R5)(R8*1), R10      // aa686838
+	MOVBU	(R5)(R8), R10                   // aa686838
 	MOVHU	(R2)(R7.SXTW<<1), R11           // 4bd86778
 	MOVHU	(R1)(R2<<1), R5                 // 25786278
 	MOVB	(R9)(R3.UXTW), R6               // 2649a338
-	MOVB	(R10)(R6), R15                  // MOVB	(R10)(R6*1), R15             // 4f69a638
+	MOVB	(R10)(R6), R15                  // 4f69a638
 	MOVB	(R29)(R30<<0), R14              // ae7bbe38
-	MOVB	(R29)(R30), R14                 // MOVB	(R29)(R30*1), R14            // ae6bbe38
+	MOVB	(R29)(R30), R14                 // ae6bbe38
 	MOVH	(R5)(R7.SXTX<<1), R19           // b3f8a778
 	MOVH	(R8)(R4<<1), R10                // 0a79a478
 	MOVW	(R9)(R8.SXTW<<2), R19           // 33d9a8b8
 	MOVW	(R1)(R4.SXTX), R11              // 2be8a4b8
 	MOVW	(R1)(R4.SXTX), ZR               // 3fe8a4b8
-	MOVW	(R2)(R5), R12                   // MOVW	(R2)(R5*1), R12               // 4c68a5b8
-	FMOVS	(R2)(R6), F4                    // FMOVS	(R2)(R6*1), F4        // 446866bc
+	MOVW	(R2)(R5), R12                   // 4c68a5b8
+	FMOVS	(R2)(R6), F4                    // 446866bc
 	FMOVS	(R2)(R6<<2), F4                 // 447866bc
-	FMOVD	(R2)(R6), F4                    // FMOVD	(R2)(R6*1), F4        // 446866fc
+	FMOVD	(R2)(R6), F4                    // 446866fc
 	FMOVD	(R2)(R6<<3), F4                 // 447866fc
 
 	MOVD	R5, (R2)(R6<<3)                 // 457826f8
@@ -568,15 +568,15 @@ TEXT	foo(SB), DUPOK|NOSPLIT, $-8
 	MOVW	R7, (R3)(R4.SXTW)               // 67c824b8
 	MOVB	R4, (R2)(R6.SXTX)               // 44e82638
 	MOVB	R8, (R3)(R9.UXTW)               // 68482938
-	MOVB	R10, (R5)(R8)                   // MOVB	R10, (R5)(R8*1)               // aa682838
+	MOVB	R10, (R5)(R8)                   // aa682838
 	MOVH	R11, (R2)(R7.SXTW<<1)           // 4bd82778
 	MOVH	R5, (R1)(R2<<1)                 // 25782278
 	MOVH	R7, (R2)(R5.SXTX<<1)            // 47f82578
 	MOVH	R8, (R3)(R6.UXTW)               // 68482678
 	MOVB	R4, (R2)(R6.SXTX)               // 44e82638
-	FMOVS	F4, (R2)(R6)                    // FMOVS	F4, (R2)(R6*1)        // 446826bc
+	FMOVS	F4, (R2)(R6)                    // 446826bc
 	FMOVS	F4, (R2)(R6<<2)                 // 447826bc
-	FMOVD	F4, (R2)(R6)                    // FMOVD	F4, (R2)(R6*1)        // 446826fc
+	FMOVD	F4, (R2)(R6)                    // 446826fc
 	FMOVD	F4, (R2)(R6<<3)                 // 447826fc
 
 // vmov
diff --git a/src/cmd/asm/internal/asm/testdata/arm64enc.s b/src/cmd/asm/internal/asm/testdata/arm64enc.s
index e802ee76f5..f71f7b0484 100644
--- a/src/cmd/asm/internal/asm/testdata/arm64enc.s
+++ b/src/cmd/asm/internal/asm/testdata/arm64enc.s
@@ -188,7 +188,7 @@ TEXT asmtest(SB),DUPOK|NOSPLIT,$-8
    MOVBU 2916(R24), R3                        // 03936d39
    MOVBU (R19)(R14<<0), R23                   // 777a6e38
    MOVBU (R2)(R8.SXTX), R19                   // 53e86838
-   MOVBU (R27)(R23), R14                      // MOVBU (R27)(R23*1), R14     // 6e6b7738
+   MOVBU (R27)(R23), R14                      // 6e6b7738
    MOVHU.P 107(R14), R13                      // cdb54678
    MOVHU.W 192(R3), R2                        // 620c4c78
    MOVHU 6844(R4), R19                        // 93787579
@@ -201,9 +201,9 @@ TEXT asmtest(SB),DUPOK|NOSPLIT,$-8
    MOVB 997(R9), R23                          // 37958f39
    //TODO MOVBW (R2<<1)(R21), R15             // af7ae238
    //TODO MOVBW (R26)(R0), R21                // 1568fa38
-   MOVB (R5)(R15), R16                        // MOVB (R5)(R15*1), R16         // b068af38
+   MOVB (R5)(R15), R16                        // b068af38
    MOVB (R19)(R26.SXTW), R19                  // 73caba38
-   MOVB (R29)(R30), R14                       // MOVB (R29)(R30*1), R14        // ae6bbe38
+   MOVB (R29)(R30), R14                       // ae6bbe38
    //TODO MOVHW.P 218(R22), R25               // d9a6cd78
    MOVH.P 179(R23), R5                        // e5368b78
    //TODO MOVHW.W 136(R2), R27                // 5b8cc878
@@ -357,12 +357,12 @@ TEXT asmtest(SB),DUPOK|NOSPLIT,$-8
    MOVD R25, -137(R17)                        // 397217f8
    MOVW R4, (R12)(R22.UXTW<<2)                // 845936b8
    MOVD R27, (R5)(R15.UXTW<<3)                // bb582ff8
-   MOVB R2, (R10)(R16)                        // MOVB R2, (R10)(R16*1)         // 42693038
-   MOVB R2, (R29)(R26)                        // MOVB R2, (R29)(R26*1)         // a26b3a38
+   MOVB R2, (R10)(R16)                        // 42693038
+   MOVB R2, (R29)(R26)                        // a26b3a38
    MOVH R11, -80(R23)                         // eb021b78
    MOVH R11, (R27)(R14.SXTW<<1)               // 6bdb2e78
-   MOVB R19, (R0)(R4)                         // MOVB R19, (R0)(R4*1)          // 13682438
-   MOVB R1, (R6)(R4)                          // MOVB R1, (R6)(R4*1)           // c1682438
+   MOVB R19, (R0)(R4)                         // 13682438
+   MOVB R1, (R6)(R4)                          // c1682438
    MOVH R3, (R11)(R13<<1)                     // 63792d78
    //TODO STTR 55(R4), R29                    // 9d7803b8
    //TODO STTR 124(R5), R25                   // b9c807f8
@@ -679,23 +679,23 @@ TEXT asmtest(SB),DUPOK|NOSPLIT,$-8
    VLD1 (R24), [V18.D1, V19.D1, V20.D1]                        // 126f400c
    VLD1 (R29), [V14.D1, V15.D1, V16.D1, V17.D1]                // ae2f400c
    VLD1.P 16(R23), [V1.B16]                                    // e172df4c
-   VLD1.P (R6)(R11), [V31.D1]                                  // VLD1.P (R6)(R11*1), [V31.D1]                 // df7ccb0c
+   VLD1.P (R6)(R11), [V31.D1]                                  // df7ccb0c
    VLD1.P 16(R7), [V31.D1, V0.D1]                              // ffacdf0c
-   VLD1.P (R19)(R4), [V24.B8, V25.B8]                          // VLD1.P (R19)(R4*1), [V24.B8, V25.B8]         // 78a2c40c
-   VLD1.P (R20)(R8), [V7.H8, V8.H8, V9.H8]                     // VLD1.P (R20)(R8*1), [V7.H8, V8.H8, V9.H8]    // 8766c84c
+   VLD1.P (R19)(R4), [V24.B8, V25.B8]                          // 78a2c40c
+   VLD1.P (R20)(R8), [V7.H8, V8.H8, V9.H8]                     // 8766c84c
    VLD1.P 32(R30), [V5.B8, V6.B8, V7.B8, V8.B8]                // c523df0c
    VLD1 (R19), V14.B[15]                                       // 6e1e404d
    VLD1 (R29), V0.H[1]                                         // a04b400d
    VLD1 (R27), V2.S[0]                                         // 6283400d
    VLD1 (R21), V5.D[1]                                         // a586404d
    VLD1.P 1(R19), V10.B[14]                                    // 6a1adf4d
-   VLD1.P (R3)(R14), V16.B[11]                                 // VLD1.P (R3)(R14*1), V16.B[11]                // 700cce4d
+   VLD1.P (R3)(R14), V16.B[11]                                 // 700cce4d
    VLD1.P 2(R1), V28.H[2]                                      // 3c50df0d
-   VLD1.P (R13)(R20), V9.H[2]                                  // VLD1.P (R13)(R20*1), V9.H[2]                 // a951d40d
+   VLD1.P (R13)(R20), V9.H[2]                                  // a951d40d
    VLD1.P 4(R17), V1.S[3]                                      // 2192df4d
-   VLD1.P (R14)(R2), V17.S[2]                                  // VLD1.P (R14)(R2*1), V17.S[2]                 // d181c24d
+   VLD1.P (R14)(R2), V17.S[2]                                  // d181c24d
    VLD1.P 8(R5), V30.D[1]                                      // be84df4d
-   VLD1.P (R27)(R13), V27.D[0]                                 // VLD1.P (R27)(R13*1), V27.D[0]                // 7b87cd0d
+   VLD1.P (R27)(R13), V27.D[0]                                 // 7b87cd0d
    //TODO FMOVS.P -29(RSP), F8                                 // e8375ebc
    //TODO FMOVS.W 71(R29), F28                                 // bc7f44bc
    FMOVS 6160(R4), F23                                         // 971058bd
@@ -732,25 +732,25 @@ TEXT asmtest(SB),DUPOK|NOSPLIT,$-8
    VSHL $7, V22.D2, V25.D2                                     // d956474f
    VST1 [V14.H4, V15.H4, V16.H4], (R27)                        // 6e67000c
    VST1 [V2.S4, V3.S4, V4.S4, V5.S4], (R14)                    // c229004c
-   VST1.P [V25.S4], (R7)(R29)                                  // VST1.P [V25.S4], (R7)(R29*1)                          // f9789d4c
+   VST1.P [V25.S4], (R7)(R29)                                  // f9789d4c
    VST1.P [V25.D2, V26.D2], 32(R7)                             // f9ac9f4c
-   VST1.P [V14.D1, V15.D1], (R7)(R23)                          // VST1.P [V14.D1, V15.D1], (R7)(R23*1)                  // eeac970c
+   VST1.P [V14.D1, V15.D1], (R7)(R23)                          // eeac970c
    VST1.P [V25.D2, V26.D2, V27.D2], 48(R27)                    // 796f9f4c
-   VST1.P [V13.H8, V14.H8, V15.H8], (R3)(R14)                  // VST1.P [V13.H8, V14.H8, V15.H8], (R3)(R14*1)          // 6d648e4c
+   VST1.P [V13.H8, V14.H8, V15.H8], (R3)(R14)                  // 6d648e4c
    VST1.P [V16.S4, V17.S4, V18.S4, V19.S4], 64(R6)             // d0289f4c
-   VST1.P [V19.H4, V20.H4, V21.H4, V22.H4], (R4)(R16)          // VST1.P [V19.H4, V20.H4, V21.H4, V22.H4], (R4)(R16*1)  // 9324900c
+   VST1.P [V19.H4, V20.H4, V21.H4, V22.H4], (R4)(R16)          // 9324900c
    VST1 V12.B[3], (R1)                                         // 2c0c000d
    VST1 V12.B[3], (R1)                                         // 2c0c000d
    VST1 V25.S[2], (R20)                                        // 9982004d
    VST1 V9.D[1], (RSP)                                         // e987004d
    VST1.P V30.B[6], 1(R3)                                      // 7e189f0d
-   VST1.P V8.B[0], (R3)(R21)                                   // VST1.P V8.B[0], (R3)(R21*1)                          // 6800950d
+   VST1.P V8.B[0], (R3)(R21)                                   // 6800950d
    VST1.P V15.H[5], 2(R10)                                     // 4f499f4d
-   VST1.P V1.H[7], (R23)(R11)                                  // VST1.P V1.H[7], (R23)(R11*1)                         // e15a8b4d
+   VST1.P V1.H[7], (R23)(R11)                                  // e15a8b4d
    VST1.P V26.S[0], 4(R11)                                     // 7a819f0d
-   VST1.P V9.S[1], (R16)(R21)                                  // VST1.P V9.S[1], (R16)(R21*1)                         // 0992950d
+   VST1.P V9.S[1], (R16)(R21)                                  // 0992950d
    VST1.P V16.D[0], 8(R9)                                      // 30859f0d
-   VST1.P V23.D[1], (R21)(R16)                                 // VST1.P V23.D[1], (R21)(R16*1)                        // b786904d
+   VST1.P V23.D[1], (R21)(R16)                                 // b786904d
    VSUB V1, V12, V23                                           // 9785e17e
    VUADDLV V31.S4, V11                                         // eb3bb06e
    UCVTFWS R11, F19                                            // 7301231e
-- 
GitLab


From 775f11cda1d30f3f9778e737c2280cfe28ead1b4 Mon Sep 17 00:00:00 2001
From: eric fang <eric.fang@arm.com>
Date: Tue, 12 Jan 2021 02:45:46 +0000
Subject: [PATCH 0913/2400] cmd/internal/obj/arm64: remove unncessary class
 check in addpool

The argument class check in addpool is unnecessary, remove it so that we don't
need to list all the compatiable classes.

Change-Id: I36f6594db35e25db22fe898273e024c2db4cb771
Reviewed-on: https://go-review.googlesource.com/c/go/+/283492
Trust: eric fang <eric.fang@arm.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/internal/obj/arm64/asm7.go | 97 +-----------------------------
 1 file changed, 2 insertions(+), 95 deletions(-)

diff --git a/src/cmd/internal/obj/arm64/asm7.go b/src/cmd/internal/obj/arm64/asm7.go
index 3b0fa6fb53..e9f18e1bf0 100644
--- a/src/cmd/internal/obj/arm64/asm7.go
+++ b/src/cmd/internal/obj/arm64/asm7.go
@@ -1251,101 +1251,8 @@ func (c *ctxt7) addpool(p *obj.Prog, a *obj.Addr) {
 		sz = 8
 	}
 
-	switch cls {
-	// TODO(aram): remove.
-	default:
-		if a.Name != obj.NAME_EXTERN {
-			fmt.Printf("addpool: %v in %v shouldn't go to default case\n", DRconv(cls), p)
-		}
-
-		t.To.Offset = a.Offset
-		t.To.Sym = a.Sym
-		t.To.Type = a.Type
-		t.To.Name = a.Name
-
-	/* This is here because MOV uint12<<12, R is disabled in optab.
-	Because of this, we need to load the constant from memory. */
-	case C_ADDCON:
-		fallthrough
-
-	case C_ADDCON2,
-		C_LCON,
-		C_VCON,
-		C_LACON,
-
-		C_ZAUTO,
-		C_NSAUTO_16,
-		C_NSAUTO_8,
-		C_NSAUTO_4,
-		C_NSAUTO,
-		C_NPAUTO_16,
-		C_NPAUTO,
-		C_NQAUTO_16,
-		C_NAUTO4K,
-		C_PSAUTO_16,
-		C_PSAUTO_8,
-		C_PSAUTO_4,
-		C_PSAUTO,
-		C_PPAUTO_16,
-		C_PPAUTO,
-		C_PQAUTO_16,
-		C_UAUTO4K_16,
-		C_UAUTO4K_8,
-		C_UAUTO4K_4,
-		C_UAUTO4K_2,
-		C_UAUTO4K,
-		C_UAUTO8K_16,
-		C_UAUTO8K_8,
-		C_UAUTO8K_4,
-		C_UAUTO8K,
-		C_UAUTO16K_16,
-		C_UAUTO16K_8,
-		C_UAUTO16K,
-		C_UAUTO32K_16,
-		C_UAUTO32K,
-		C_UAUTO64K,
-		C_LAUTO,
-
-		C_ZOREG,
-		C_NSOREG_16,
-		C_NSOREG_8,
-		C_NSOREG_4,
-		C_NSOREG,
-		C_NPOREG_16,
-		C_NPOREG,
-		C_NQOREG_16,
-		C_NOREG4K,
-		C_PSOREG_16,
-		C_PSOREG_8,
-		C_PSOREG_4,
-		C_PSOREG,
-		C_PPOREG_16,
-		C_PPOREG,
-		C_PQOREG_16,
-		C_UOREG4K_16,
-		C_UOREG4K_8,
-		C_UOREG4K_4,
-		C_UOREG4K_2,
-		C_UOREG4K,
-		C_UOREG8K_16,
-		C_UOREG8K_8,
-		C_UOREG8K_4,
-		C_UOREG8K,
-		C_UOREG16K_16,
-		C_UOREG16K_8,
-		C_UOREG16K,
-		C_UOREG32K_16,
-		C_UOREG32K,
-		C_UOREG64K,
-		C_LOREG:
-		if a.Name == obj.NAME_EXTERN {
-			fmt.Printf("addpool: %v in %v needs reloc\n", DRconv(cls), p)
-		}
-
-		t.To.Type = obj.TYPE_CONST
-		t.To.Offset = lit
-		break
-	}
+	t.To.Type = obj.TYPE_CONST
+	t.To.Offset = lit
 
 	for q := c.blitrl; q != nil; q = q.Link { /* could hash on t.t0.offset */
 		if q.To == t.To {
-- 
GitLab


From 04a4dca2ac3d4f963e3c740045ce7a2959bf0319 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Wed, 17 Feb 2021 12:17:25 -0500
Subject: [PATCH 0914/2400] cmd/compile: refactor out an almost-superfluous arg

Moved all "target" information into "storeRC"; it was a register
cursor, now it is a register cursor that also carries the store
target with it if there are no registers.  Also allows booby-trapping
to ensure that the target is unambiguously one or the other.

For #40724.

Change-Id: I53ba4b91679e5fcc89c63b7d31225135299c6ec6
Reviewed-on: https://go-review.googlesource.com/c/go/+/293397
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/expand_calls.go | 162 ++++++++++---------
 1 file changed, 90 insertions(+), 72 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index 87b8a02b25..1868e3f073 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -62,12 +62,31 @@ func removeTrivialWrapperTypes(t *types.Type) *types.Type {
 // A registerCursor tracks which register is used for an Arg or regValues, or a piece of such.
 type registerCursor struct {
 	// TODO(register args) convert this to a generalized target cursor.
+	storeDest *Value // if there are no register targets, then this is the base of the store.
 	regsLen   int    // the number of registers available for this Arg/result (which is all in registers or not at all)
 	nextSlice Abi1RO // the next register/register-slice offset
 	config    *abi.ABIConfig
 	regValues *[]*Value // values assigned to registers accumulate here
 }
 
+func (rc *registerCursor) String() string {
+	dest := "<none>"
+	if rc.storeDest != nil {
+		dest = rc.storeDest.String()
+	}
+	regs := "<none>"
+	if rc.regValues != nil {
+		regs = ""
+		for i, x := range *rc.regValues {
+			if i > 0 {
+				regs = regs + "; "
+			}
+			regs = regs + x.LongString()
+		}
+	}
+	return fmt.Sprintf("RCSR{storeDest=%v, regsLen=%d, nextSlice=%d, regValues=[%s], config=%v", dest, rc.regsLen, rc.nextSlice, regs, rc.config)
+}
+
 // next effectively post-increments the register cursor; the receiver is advanced,
 // the old value is returned.
 func (c *registerCursor) next(t *types.Type) registerCursor {
@@ -139,10 +158,11 @@ func (c *registerCursor) at(t *types.Type, i int) registerCursor {
 	panic("Haven't implemented this case yet, do I need to?")
 }
 
-func (c *registerCursor) init(regs []abi.RegIndex, info *abi.ABIParamResultInfo, result *[]*Value) {
+func (c *registerCursor) init(regs []abi.RegIndex, info *abi.ABIParamResultInfo, result *[]*Value, storeDest *Value) {
 	c.regsLen = len(regs)
 	c.nextSlice = 0
 	if len(regs) == 0 {
+		c.storeDest = storeDest // only save this if there are no registers, will explode if misused.
 		return
 	}
 	c.config = info.Config()
@@ -519,20 +539,20 @@ func (x *expandState) rewriteDereference(b *Block, base, a, mem *Value, offset,
 // Parameters:
 //  pos           -- the location of any generated code.
 //  b             -- the block into which any generated code should normally be placed
-//  base          -- for the stores that will ultimately be generated, the base to which the offset is applied. (Note this disappears in a future CL, folded into storeRc)
 //  source        -- the value, possibly an aggregate, to be stored.
 //  mem           -- the mem flowing into this decomposition (loads depend on it, stores updated it)
 //  t             -- the type of the value to be stored
-//  offset        -- if the value is stored in memory, it is stored at base + offset
+//  offset        -- if the value is stored in memory, it is stored at base (see storeRc) + offset
 //  loadRegOffset -- regarding source as a value in registers, the register offset in ABI1.  Meaningful only if source is OpArg.
-//  storeRc       -- storeRC; if the value is stored in registers, this specifies the registers.  StoreRc also identifies whether the target is registers or memory.
+//  storeRc       -- storeRC; if the value is stored in registers, this specifies the registers.
+//                   StoreRc also identifies whether the target is registers or memory, and has the base for the store operation.
 //
 // TODO -- this needs cleanup; it just works for SSA-able aggregates, and won't fully generalize to register-args aggregates.
-func (x *expandState) decomposeArgOrLoad(pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offset int64, loadRegOffset Abi1RO, storeRc registerCursor,
+func (x *expandState) decomposeArgOrLoad(pos src.XPos, b *Block, source, mem *Value, t *types.Type, offset int64, loadRegOffset Abi1RO, storeRc registerCursor,
 	// For decompose One and Two, the additional offArg provides the offset from the beginning of "source", if it is in memory.
 	// offStore is combined to base to obtain a store destionation, like "offset" of decomposeArgOrLoad
-	decomposeOne func(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t1 *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value,
-	decomposeTwo func(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value) *Value {
+	decomposeOne func(x *expandState, pos src.XPos, b *Block, source, mem *Value, t1 *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value,
+	decomposeTwo func(x *expandState, pos src.XPos, b *Block, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value) *Value {
 	u := source.Type
 	switch u.Kind() {
 	case types.TARRAY:
@@ -540,7 +560,7 @@ func (x *expandState) decomposeArgOrLoad(pos src.XPos, b *Block, base, source, m
 		elemRO := x.regWidth(elem)
 		for i := int64(0); i < u.NumElem(); i++ {
 			elemOff := i * elem.Size()
-			mem = decomposeOne(x, pos, b, base, source, mem, elem, elemOff, offset+elemOff, loadRegOffset, storeRc.next(elem))
+			mem = decomposeOne(x, pos, b, source, mem, elem, elemOff, offset+elemOff, loadRegOffset, storeRc.next(elem))
 			loadRegOffset += elemRO
 			pos = pos.WithNotStmt()
 		}
@@ -548,7 +568,7 @@ func (x *expandState) decomposeArgOrLoad(pos src.XPos, b *Block, base, source, m
 	case types.TSTRUCT:
 		for i := 0; i < u.NumFields(); i++ {
 			fld := u.Field(i)
-			mem = decomposeOne(x, pos, b, base, source, mem, fld.Type, fld.Offset, offset+fld.Offset, loadRegOffset, storeRc.next(fld.Type))
+			mem = decomposeOne(x, pos, b, source, mem, fld.Type, fld.Offset, offset+fld.Offset, loadRegOffset, storeRc.next(fld.Type))
 			loadRegOffset += x.regWidth(fld.Type)
 			pos = pos.WithNotStmt()
 		}
@@ -558,80 +578,78 @@ func (x *expandState) decomposeArgOrLoad(pos src.XPos, b *Block, base, source, m
 			break
 		}
 		tHi, tLo := x.intPairTypes(t.Kind())
-		mem = decomposeOne(x, pos, b, base, source, mem, tHi, x.hiOffset, offset+x.hiOffset, loadRegOffset+x.hiRo, storeRc.plus(x.hiRo))
+		mem = decomposeOne(x, pos, b, source, mem, tHi, x.hiOffset, offset+x.hiOffset, loadRegOffset+x.hiRo, storeRc.plus(x.hiRo))
 		pos = pos.WithNotStmt()
-		return decomposeOne(x, pos, b, base, source, mem, tLo, x.lowOffset, offset+x.lowOffset, loadRegOffset+x.loRo, storeRc.plus(x.loRo))
+		return decomposeOne(x, pos, b, source, mem, tLo, x.lowOffset, offset+x.lowOffset, loadRegOffset+x.loRo, storeRc.plus(x.loRo))
 	case types.TINTER:
-		return decomposeTwo(x, pos, b, base, source, mem, x.typs.Uintptr, x.typs.BytePtr, 0, offset, loadRegOffset, storeRc)
+		return decomposeTwo(x, pos, b, source, mem, x.typs.Uintptr, x.typs.BytePtr, 0, offset, loadRegOffset, storeRc)
 	case types.TSTRING:
-		return decomposeTwo(x, pos, b, base, source, mem, x.typs.BytePtr, x.typs.Int, 0, offset, loadRegOffset, storeRc)
+		return decomposeTwo(x, pos, b, source, mem, x.typs.BytePtr, x.typs.Int, 0, offset, loadRegOffset, storeRc)
 	case types.TCOMPLEX64:
-		return decomposeTwo(x, pos, b, base, source, mem, x.typs.Float32, x.typs.Float32, 0, offset, loadRegOffset, storeRc)
+		return decomposeTwo(x, pos, b, source, mem, x.typs.Float32, x.typs.Float32, 0, offset, loadRegOffset, storeRc)
 	case types.TCOMPLEX128:
-		return decomposeTwo(x, pos, b, base, source, mem, x.typs.Float64, x.typs.Float64, 0, offset, loadRegOffset, storeRc)
+		return decomposeTwo(x, pos, b, source, mem, x.typs.Float64, x.typs.Float64, 0, offset, loadRegOffset, storeRc)
 	case types.TSLICE:
-		mem = decomposeOne(x, pos, b, base, source, mem, x.typs.BytePtr, 0, offset, loadRegOffset, storeRc.next(x.typs.BytePtr))
-		return decomposeTwo(x, pos, b, base, source, mem, x.typs.Int, x.typs.Int, x.ptrSize, offset+x.ptrSize, loadRegOffset+RO_slice_len, storeRc)
+		mem = decomposeOne(x, pos, b, source, mem, x.typs.BytePtr, 0, offset, loadRegOffset, storeRc.next(x.typs.BytePtr))
+		return decomposeTwo(x, pos, b, source, mem, x.typs.Int, x.typs.Int, x.ptrSize, offset+x.ptrSize, loadRegOffset+RO_slice_len, storeRc)
 	}
 	return nil
 }
 
 // storeOneArg creates a decomposed (one step) arg that is then stored.
-// pos and b locate the store instruction, base is the base of the store target, source is the "base" of the value input,
+// pos and b locate the store instruction, source is the "base" of the value input,
 // mem is the input mem, t is the type in question, and offArg and offStore are the offsets from the respective bases.
-func storeOneArg(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
+func storeOneArg(x *expandState, pos src.XPos, b *Block, source, mem *Value, t *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
 	w := x.commonArgs[selKey{source, offArg, t.Width, t}]
 	if w == nil {
-		// w = source.Block.NewValue0IA(source.Pos, OpArg, t, offArg, source.Aux)
 		w = x.newArgToMemOrRegs(source, w, offArg, loadRegOffset, t, pos)
-		// x.commonArgs[selKey{source, offArg, t.Width, t}] = w
 	}
-	return x.storeArgOrLoad(pos, b, base, w, mem, t, offStore, loadRegOffset, storeRc)
+	return x.storeArgOrLoad(pos, b, w, mem, t, offStore, loadRegOffset, storeRc)
 }
 
 // storeOneLoad creates a decomposed (one step) load that is then stored.
-func storeOneLoad(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
+func storeOneLoad(x *expandState, pos src.XPos, b *Block, source, mem *Value, t *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
 	from := x.offsetFrom(source.Args[0], offArg, types.NewPtr(t))
 	w := source.Block.NewValue2(source.Pos, OpLoad, t, from, mem)
-	return x.storeArgOrLoad(pos, b, base, w, mem, t, offStore, loadRegOffset, storeRc)
+	return x.storeArgOrLoad(pos, b, w, mem, t, offStore, loadRegOffset, storeRc)
 }
 
-func storeTwoArg(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
-	mem = storeOneArg(x, pos, b, base, source, mem, t1, offArg, offStore, loadRegOffset, storeRc.next(t1))
+func storeTwoArg(x *expandState, pos src.XPos, b *Block, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
+	mem = storeOneArg(x, pos, b, source, mem, t1, offArg, offStore, loadRegOffset, storeRc.next(t1))
 	pos = pos.WithNotStmt()
 	t1Size := t1.Size()
-	return storeOneArg(x, pos, b, base, source, mem, t2, offArg+t1Size, offStore+t1Size, loadRegOffset+1, storeRc)
+	return storeOneArg(x, pos, b, source, mem, t2, offArg+t1Size, offStore+t1Size, loadRegOffset+1, storeRc)
 }
 
 // storeTwoLoad creates a pair of decomposed (one step) loads that are then stored.
 // the elements of the pair must not require any additional alignment.
-func storeTwoLoad(x *expandState, pos src.XPos, b *Block, base, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
-	mem = storeOneLoad(x, pos, b, base, source, mem, t1, offArg, offStore, loadRegOffset, storeRc.next(t1))
+func storeTwoLoad(x *expandState, pos src.XPos, b *Block, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
+	mem = storeOneLoad(x, pos, b, source, mem, t1, offArg, offStore, loadRegOffset, storeRc.next(t1))
 	pos = pos.WithNotStmt()
 	t1Size := t1.Size()
-	return storeOneLoad(x, pos, b, base, source, mem, t2, offArg+t1Size, offStore+t1Size, loadRegOffset+1, storeRc)
+	return storeOneLoad(x, pos, b, source, mem, t2, offArg+t1Size, offStore+t1Size, loadRegOffset+1, storeRc)
 }
 
 // storeArgOrLoad converts stores of SSA-able potentially aggregatable arguments (passed to a call) into a series of primitive-typed
 // stores of non-aggregate types.  It recursively walks up a chain of selectors until it reaches a Load or an Arg.
 // If it does not reach a Load or an Arg, nothing happens; this allows a little freedom in phase ordering.
-func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, base, source, mem *Value, t *types.Type, offset int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
+func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, source, mem *Value, t *types.Type, offset int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
 	if x.debug {
-		fmt.Printf("\tstoreArgOrLoad(%s;  %s;  %s;  %s; %d)\n", base.LongString(), source.LongString(), mem.String(), t.String(), offset)
+		fmt.Printf("\tstoreArgOrLoad(%s;  %s;  %s; %d; %s)\n", source.LongString(), mem.String(), t.String(), offset, storeRc.String())
 	}
 
 	switch source.Op {
 	case OpCopy:
-		return x.storeArgOrLoad(pos, b, base, source.Args[0], mem, t, offset, loadRegOffset, storeRc)
+		return x.storeArgOrLoad(pos, b, source.Args[0], mem, t, offset, loadRegOffset, storeRc)
 
 	case OpLoad:
-		ret := x.decomposeArgOrLoad(pos, b, base, source, mem, t, offset, loadRegOffset, storeRc, storeOneLoad, storeTwoLoad)
+		ret := x.decomposeArgOrLoad(pos, b, source, mem, t, offset, loadRegOffset, storeRc, storeOneLoad, storeTwoLoad)
 		if ret != nil {
 			return ret
 		}
 
 	case OpArg:
-		ret := x.decomposeArgOrLoad(pos, b, base, source, mem, t, offset, loadRegOffset, storeRc, storeOneArg, storeTwoArg)
+		ret := x.decomposeArgOrLoad(pos, b, source, mem, t, offset, loadRegOffset, storeRc, storeOneArg, storeTwoArg)
 		if ret != nil {
 			return ret
 		}
@@ -643,19 +661,19 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, base, source, mem *
 	case OpStructMake1, OpStructMake2, OpStructMake3, OpStructMake4:
 		for i := 0; i < t.NumFields(); i++ {
 			fld := t.Field(i)
-			mem = x.storeArgOrLoad(pos, b, base, source.Args[i], mem, fld.Type, offset+fld.Offset, 0, storeRc.next(fld.Type))
+			mem = x.storeArgOrLoad(pos, b, source.Args[i], mem, fld.Type, offset+fld.Offset, 0, storeRc.next(fld.Type))
 			pos = pos.WithNotStmt()
 		}
 		return mem
 
 	case OpArrayMake1:
-		return x.storeArgOrLoad(pos, b, base, source.Args[0], mem, t.Elem(), offset, 0, storeRc.at(t, 0))
+		return x.storeArgOrLoad(pos, b, source.Args[0], mem, t.Elem(), offset, 0, storeRc.at(t, 0))
 
 	case OpInt64Make:
 		tHi, tLo := x.intPairTypes(t.Kind())
-		mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, tHi, offset+x.hiOffset, 0, storeRc.next(tHi))
+		mem = x.storeArgOrLoad(pos, b, source.Args[0], mem, tHi, offset+x.hiOffset, 0, storeRc.next(tHi))
 		pos = pos.WithNotStmt()
-		return x.storeArgOrLoad(pos, b, base, source.Args[1], mem, tLo, offset+x.lowOffset, 0, storeRc)
+		return x.storeArgOrLoad(pos, b, source.Args[1], mem, tLo, offset+x.lowOffset, 0, storeRc)
 
 	case OpComplexMake:
 		tPart := x.typs.Float32
@@ -663,25 +681,25 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, base, source, mem *
 		if wPart == 8 {
 			tPart = x.typs.Float64
 		}
-		mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, tPart, offset, 0, storeRc.next(tPart))
+		mem = x.storeArgOrLoad(pos, b, source.Args[0], mem, tPart, offset, 0, storeRc.next(tPart))
 		pos = pos.WithNotStmt()
-		return x.storeArgOrLoad(pos, b, base, source.Args[1], mem, tPart, offset+wPart, 0, storeRc)
+		return x.storeArgOrLoad(pos, b, source.Args[1], mem, tPart, offset+wPart, 0, storeRc)
 
 	case OpIMake:
-		mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, x.typs.Uintptr, offset, 0, storeRc.next(x.typs.Uintptr))
+		mem = x.storeArgOrLoad(pos, b, source.Args[0], mem, x.typs.Uintptr, offset, 0, storeRc.next(x.typs.Uintptr))
 		pos = pos.WithNotStmt()
-		return x.storeArgOrLoad(pos, b, base, source.Args[1], mem, x.typs.BytePtr, offset+x.ptrSize, 0, storeRc)
+		return x.storeArgOrLoad(pos, b, source.Args[1], mem, x.typs.BytePtr, offset+x.ptrSize, 0, storeRc)
 
 	case OpStringMake:
-		mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, x.typs.BytePtr, offset, 0, storeRc.next(x.typs.BytePtr))
+		mem = x.storeArgOrLoad(pos, b, source.Args[0], mem, x.typs.BytePtr, offset, 0, storeRc.next(x.typs.BytePtr))
 		pos = pos.WithNotStmt()
-		return x.storeArgOrLoad(pos, b, base, source.Args[1], mem, x.typs.Int, offset+x.ptrSize, 0, storeRc)
+		return x.storeArgOrLoad(pos, b, source.Args[1], mem, x.typs.Int, offset+x.ptrSize, 0, storeRc)
 
 	case OpSliceMake:
-		mem = x.storeArgOrLoad(pos, b, base, source.Args[0], mem, x.typs.BytePtr, offset, 0, storeRc.next(x.typs.BytePtr))
+		mem = x.storeArgOrLoad(pos, b, source.Args[0], mem, x.typs.BytePtr, offset, 0, storeRc.next(x.typs.BytePtr))
 		pos = pos.WithNotStmt()
-		mem = x.storeArgOrLoad(pos, b, base, source.Args[1], mem, x.typs.Int, offset+x.ptrSize, 0, storeRc.next(x.typs.Int))
-		return x.storeArgOrLoad(pos, b, base, source.Args[2], mem, x.typs.Int, offset+2*x.ptrSize, 0, storeRc)
+		mem = x.storeArgOrLoad(pos, b, source.Args[1], mem, x.typs.Int, offset+x.ptrSize, 0, storeRc.next(x.typs.Int))
+		return x.storeArgOrLoad(pos, b, source.Args[2], mem, x.typs.Int, offset+2*x.ptrSize, 0, storeRc)
 	}
 
 	// For nodes that cannot be taken apart -- OpSelectN, other structure selectors.
@@ -691,12 +709,12 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, base, source, mem *
 		if source.Type != t && t.NumElem() == 1 && elt.Width == t.Width && t.Width == x.regSize {
 			t = removeTrivialWrapperTypes(t)
 			// it could be a leaf type, but the "leaf" could be complex64 (for example)
-			return x.storeArgOrLoad(pos, b, base, source, mem, t, offset, loadRegOffset, storeRc)
+			return x.storeArgOrLoad(pos, b, source, mem, t, offset, loadRegOffset, storeRc)
 		}
 		eltRO := x.regWidth(elt)
 		for i := int64(0); i < t.NumElem(); i++ {
 			sel := source.Block.NewValue1I(pos, OpArraySelect, elt, i, source)
-			mem = x.storeArgOrLoad(pos, b, base, sel, mem, elt, offset+i*elt.Width, loadRegOffset, storeRc.at(t, 0))
+			mem = x.storeArgOrLoad(pos, b, sel, mem, elt, offset+i*elt.Width, loadRegOffset, storeRc.at(t, 0))
 			loadRegOffset += eltRO
 			pos = pos.WithNotStmt()
 		}
@@ -724,13 +742,13 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, base, source, mem *
 			// of a *uint8, which does not succeed.
 			t = removeTrivialWrapperTypes(t)
 			// it could be a leaf type, but the "leaf" could be complex64 (for example)
-			return x.storeArgOrLoad(pos, b, base, source, mem, t, offset, loadRegOffset, storeRc)
+			return x.storeArgOrLoad(pos, b, source, mem, t, offset, loadRegOffset, storeRc)
 		}
 
 		for i := 0; i < t.NumFields(); i++ {
 			fld := t.Field(i)
 			sel := source.Block.NewValue1I(pos, OpStructSelect, fld.Type, int64(i), source)
-			mem = x.storeArgOrLoad(pos, b, base, sel, mem, fld.Type, offset+fld.Offset, loadRegOffset, storeRc.next(fld.Type))
+			mem = x.storeArgOrLoad(pos, b, sel, mem, fld.Type, offset+fld.Offset, loadRegOffset, storeRc.next(fld.Type))
 			loadRegOffset += x.regWidth(fld.Type)
 			pos = pos.WithNotStmt()
 		}
@@ -742,48 +760,48 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, base, source, mem *
 		}
 		tHi, tLo := x.intPairTypes(t.Kind())
 		sel := source.Block.NewValue1(pos, OpInt64Hi, tHi, source)
-		mem = x.storeArgOrLoad(pos, b, base, sel, mem, tHi, offset+x.hiOffset, loadRegOffset+x.hiRo, storeRc.plus(x.hiRo))
+		mem = x.storeArgOrLoad(pos, b, sel, mem, tHi, offset+x.hiOffset, loadRegOffset+x.hiRo, storeRc.plus(x.hiRo))
 		pos = pos.WithNotStmt()
 		sel = source.Block.NewValue1(pos, OpInt64Lo, tLo, source)
-		return x.storeArgOrLoad(pos, b, base, sel, mem, tLo, offset+x.lowOffset, loadRegOffset+x.loRo, storeRc.plus(x.hiRo))
+		return x.storeArgOrLoad(pos, b, sel, mem, tLo, offset+x.lowOffset, loadRegOffset+x.loRo, storeRc.plus(x.hiRo))
 
 	case types.TINTER:
 		sel := source.Block.NewValue1(pos, OpITab, x.typs.BytePtr, source)
-		mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.BytePtr, offset, loadRegOffset, storeRc.next(x.typs.BytePtr))
+		mem = x.storeArgOrLoad(pos, b, sel, mem, x.typs.BytePtr, offset, loadRegOffset, storeRc.next(x.typs.BytePtr))
 		pos = pos.WithNotStmt()
 		sel = source.Block.NewValue1(pos, OpIData, x.typs.BytePtr, source)
-		return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.BytePtr, offset+x.ptrSize, loadRegOffset+RO_iface_data, storeRc)
+		return x.storeArgOrLoad(pos, b, sel, mem, x.typs.BytePtr, offset+x.ptrSize, loadRegOffset+RO_iface_data, storeRc)
 
 	case types.TSTRING:
 		sel := source.Block.NewValue1(pos, OpStringPtr, x.typs.BytePtr, source)
-		mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.BytePtr, offset, loadRegOffset, storeRc.next(x.typs.BytePtr))
+		mem = x.storeArgOrLoad(pos, b, sel, mem, x.typs.BytePtr, offset, loadRegOffset, storeRc.next(x.typs.BytePtr))
 		pos = pos.WithNotStmt()
 		sel = source.Block.NewValue1(pos, OpStringLen, x.typs.Int, source)
-		return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Int, offset+x.ptrSize, loadRegOffset+RO_string_len, storeRc)
+		return x.storeArgOrLoad(pos, b, sel, mem, x.typs.Int, offset+x.ptrSize, loadRegOffset+RO_string_len, storeRc)
 
 	case types.TSLICE:
 		et := types.NewPtr(t.Elem())
 		sel := source.Block.NewValue1(pos, OpSlicePtr, et, source)
-		mem = x.storeArgOrLoad(pos, b, base, sel, mem, et, offset, loadRegOffset, storeRc.next(et))
+		mem = x.storeArgOrLoad(pos, b, sel, mem, et, offset, loadRegOffset, storeRc.next(et))
 		pos = pos.WithNotStmt()
 		sel = source.Block.NewValue1(pos, OpSliceLen, x.typs.Int, source)
-		mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Int, offset+x.ptrSize, loadRegOffset+RO_slice_len, storeRc.next(x.typs.Int))
+		mem = x.storeArgOrLoad(pos, b, sel, mem, x.typs.Int, offset+x.ptrSize, loadRegOffset+RO_slice_len, storeRc.next(x.typs.Int))
 		sel = source.Block.NewValue1(pos, OpSliceCap, x.typs.Int, source)
-		return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Int, offset+2*x.ptrSize, loadRegOffset+RO_slice_cap, storeRc)
+		return x.storeArgOrLoad(pos, b, sel, mem, x.typs.Int, offset+2*x.ptrSize, loadRegOffset+RO_slice_cap, storeRc)
 
 	case types.TCOMPLEX64:
 		sel := source.Block.NewValue1(pos, OpComplexReal, x.typs.Float32, source)
-		mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Float32, offset, loadRegOffset, storeRc.next(x.typs.Float32))
+		mem = x.storeArgOrLoad(pos, b, sel, mem, x.typs.Float32, offset, loadRegOffset, storeRc.next(x.typs.Float32))
 		pos = pos.WithNotStmt()
 		sel = source.Block.NewValue1(pos, OpComplexImag, x.typs.Float32, source)
-		return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Float32, offset+4, loadRegOffset+RO_complex_imag, storeRc)
+		return x.storeArgOrLoad(pos, b, sel, mem, x.typs.Float32, offset+4, loadRegOffset+RO_complex_imag, storeRc)
 
 	case types.TCOMPLEX128:
 		sel := source.Block.NewValue1(pos, OpComplexReal, x.typs.Float64, source)
-		mem = x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Float64, offset, loadRegOffset, storeRc.next(x.typs.Float64))
+		mem = x.storeArgOrLoad(pos, b, sel, mem, x.typs.Float64, offset, loadRegOffset, storeRc.next(x.typs.Float64))
 		pos = pos.WithNotStmt()
 		sel = source.Block.NewValue1(pos, OpComplexImag, x.typs.Float64, source)
-		return x.storeArgOrLoad(pos, b, base, sel, mem, x.typs.Float64, offset+8, loadRegOffset+RO_complex_imag, storeRc)
+		return x.storeArgOrLoad(pos, b, sel, mem, x.typs.Float64, offset+8, loadRegOffset+RO_complex_imag, storeRc)
 	}
 
 	s := mem
@@ -791,7 +809,7 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, base, source, mem *
 		// TODO(register args)
 		storeRc.addArg(source)
 	} else {
-		dst := x.offsetFrom(base, offset, types.NewPtr(t))
+		dst := x.offsetFrom(storeRc.storeDest, offset, types.NewPtr(t))
 		s = b.NewValue3A(pos, OpStore, types.TypeMem, t, dst, source, mem)
 	}
 	if x.debug {
@@ -843,8 +861,8 @@ func (x *expandState) rewriteArgs(v *Value, firstArg int) *Value {
 			if x.debug {
 				fmt.Printf("storeArg %s, %v, %d\n", a.LongString(), aType, aOffset)
 			}
-			rc.init(aRegs, aux.abiInfo, result)
-			mem = x.storeArgOrLoad(pos, v.Block, x.sp, a, mem, aType, aOffset, 0, rc)
+			rc.init(aRegs, aux.abiInfo, result, x.sp)
+			mem = x.storeArgOrLoad(pos, v.Block, a, mem, aType, aOffset, 0, rc)
 			// TODO append mem to Result, update type
 		}
 	}
@@ -959,9 +977,9 @@ func expandCalls(f *Func) {
 					if len(aRegs) > 0 {
 						result = &allResults
 					}
-					rc.init(aRegs, aux.abiInfo, result)
-					// TODO(register args)
-					mem = x.storeArgOrLoad(v.Pos, b, auxBase, a, mem, aux.TypeOfResult(i), auxOffset, 0, rc)
+					rc.init(aRegs, aux.abiInfo, result, auxBase)
+					// TODO REGISTER
+					mem = x.storeArgOrLoad(v.Pos, b, a, mem, aux.TypeOfResult(i), auxOffset, 0, rc)
 					// TODO append mem to Result, update type
 				}
 			}
@@ -1005,7 +1023,7 @@ func expandCalls(f *Func) {
 						fmt.Printf("Splitting store %s\n", v.LongString())
 					}
 					dst, mem := v.Args[0], v.Args[2]
-					mem = x.storeArgOrLoad(v.Pos, b, dst, source, mem, t, 0, 0, registerCursor{})
+					mem = x.storeArgOrLoad(v.Pos, b, source, mem, t, 0, 0, registerCursor{storeDest: dst})
 					v.copyOf(mem)
 				}
 			}
-- 
GitLab


From 95ff296a11606cec32fb697c74aee520f23498b0 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Wed, 17 Feb 2021 18:01:52 -0500
Subject: [PATCH 0915/2400] cmd/compile: pass arguments as register parameters
 to StaticCall.

Additional register-parameter plumbing, not all the way to the end;
if you test register parameter-passing, it fails mid-compilation.

For #40724.

Change-Id: Ibb675022c9156779a451726329890e52fca1cb33
Reviewed-on: https://go-review.googlesource.com/c/go/+/293398
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
---
 src/cmd/compile/internal/ssa/expand_calls.go | 49 ++++++++++----------
 1 file changed, 25 insertions(+), 24 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index 1868e3f073..ff16eac90f 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -806,7 +806,6 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, source, mem *Value,
 
 	s := mem
 	if storeRc.hasRegs() {
-		// TODO(register args)
 		storeRc.addArg(source)
 	} else {
 		dst := x.offsetFrom(storeRc.storeDest, offset, types.NewPtr(t))
@@ -821,21 +820,15 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, source, mem *Value,
 // rewriteArgs removes all the Args from a call and converts the call args into appropriate
 // stores (or later, register movement).  Extra args for interface and closure calls are ignored,
 // but removed.
-func (x *expandState) rewriteArgs(v *Value, firstArg int) *Value {
+func (x *expandState) rewriteArgs(v *Value, firstArg int) (*Value, []*Value) {
 	// Thread the stores on the memory arg
 	aux := v.Aux.(*AuxCall)
 	pos := v.Pos.WithNotStmt()
 	m0 := v.MemoryArg()
 	mem := m0
 	allResults := []*Value{}
-	for i, a := range v.Args {
-		if i < firstArg {
-			continue
-		}
-		if a == m0 { // mem is last.
-			break
-		}
-		auxI := int64(i - firstArg)
+	for i, a := range v.Args[firstArg : len(v.Args)-1] { // skip leading non-parameter SSA Args and trailing mem SSA Arg.
+		auxI := int64(i)
 		aRegs := aux.RegsOfArg(auxI)
 		aType := aux.TypeOfArg(auxI)
 		if a.Op == OpDereference {
@@ -863,11 +856,10 @@ func (x *expandState) rewriteArgs(v *Value, firstArg int) *Value {
 			}
 			rc.init(aRegs, aux.abiInfo, result, x.sp)
 			mem = x.storeArgOrLoad(pos, v.Block, a, mem, aType, aOffset, 0, rc)
-			// TODO append mem to Result, update type
 		}
 	}
 	v.resetArgs()
-	return mem
+	return mem, allResults
 }
 
 // expandCalls converts LE (Late Expansion) calls that act like they receive value args into a lower-level form
@@ -921,17 +913,30 @@ func expandCalls(f *Func) {
 		for _, v := range b.Values {
 			switch v.Op {
 			case OpStaticLECall:
-				mem := x.rewriteArgs(v, 0)
-				v.SetArgs1(mem)
+				mem, results := x.rewriteArgs(v, 0)
+				v.AddArgs(results...)
+				v.AddArg(mem)
 			case OpClosureLECall:
 				code := v.Args[0]
 				context := v.Args[1]
-				mem := x.rewriteArgs(v, 2)
-				v.SetArgs3(code, context, mem)
+				mem, results := x.rewriteArgs(v, 2)
+				if len(results) == 0 {
+					v.SetArgs3(code, context, mem)
+				} else {
+					v.SetArgs2(code, context)
+					v.AddArgs(results...)
+					v.AddArg(mem)
+				}
 			case OpInterLECall:
 				code := v.Args[0]
-				mem := x.rewriteArgs(v, 1)
-				v.SetArgs2(code, mem)
+				mem, results := x.rewriteArgs(v, 1)
+				if len(results) == 0 {
+					v.SetArgs2(code, mem)
+				} else {
+					v.SetArgs1(code)
+					v.AddArgs(results...)
+					v.AddArg(mem)
+				}
 			}
 		}
 		if isBlockMultiValueExit(b) {
@@ -942,11 +947,8 @@ func expandCalls(f *Func) {
 			aux := f.OwnAux
 			pos := v.Pos.WithNotStmt()
 			allResults := []*Value{}
-			for j, a := range v.Args {
+			for j, a := range v.Args[:len(v.Args)-1] {
 				i := int64(j)
-				if a == m0 {
-					break
-				}
 				auxType := aux.TypeOfResult(i)
 				auxBase := b.NewValue2A(v.Pos, OpLocalAddr, types.NewPtr(auxType), aux.results[i].Name, x.sp, mem)
 				auxOffset := int64(0)
@@ -978,11 +980,10 @@ func expandCalls(f *Func) {
 						result = &allResults
 					}
 					rc.init(aRegs, aux.abiInfo, result, auxBase)
-					// TODO REGISTER
 					mem = x.storeArgOrLoad(v.Pos, b, a, mem, aux.TypeOfResult(i), auxOffset, 0, rc)
-					// TODO append mem to Result, update type
 				}
 			}
+			// TODO REGISTER -- keep the Result for block control, splice in contents of AllResults
 			b.SetControl(mem)
 			v.reset(OpInvalid) // otherwise it can have a mem operand which will fail check(), even though it is dead.
 		}
-- 
GitLab


From 4532467c1854fa16378063bd99defadc4a1e5fb1 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Thu, 18 Feb 2021 15:50:37 -0500
Subject: [PATCH 0916/2400] cmd/compile: pass register parameters to called
 function

still needs morestack
still needs results
lots of corner cases also not dealt with.

For #40724.

Change-Id: I03abdf1e8363d75c52969560b427e488a48cd37a
Reviewed-on: https://go-review.googlesource.com/c/go/+/293889
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
---
 src/cmd/compile/internal/ssa/gen/AMD64Ops.go |  3 +-
 src/cmd/compile/internal/ssa/op.go           | 54 +++++++++++++++++++-
 src/cmd/compile/internal/ssa/opGen.go        |  2 +-
 src/cmd/compile/internal/ssa/regalloc.go     | 27 ++++++++--
 4 files changed, 78 insertions(+), 8 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
index fd2c2023e6..5f5ebaaa35 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
+++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
@@ -771,7 +771,8 @@ func init() {
 			faultOnNilArg0: true,
 		},
 
-		{name: "CALLstatic", argLength: 1, reg: regInfo{clobbers: callerSave}, aux: "CallOff", clobberFlags: true, call: true},                                              // call static function aux.(*obj.LSym).  arg0=mem, auxint=argsize, returns mem
+		// With a register ABI, the actual register info for these instructions (i.e., what is used in regalloc) is augmented with per-call-site bindings of additional arguments to specific registers.
+		{name: "CALLstatic", argLength: -1, reg: regInfo{clobbers: callerSave}, aux: "CallOff", clobberFlags: true, call: true},                                             // call static function aux.(*obj.LSym).  arg0=mem, auxint=argsize, returns mem
 		{name: "CALLclosure", argLength: 3, reg: regInfo{inputs: []regMask{gpsp, buildReg("DX"), 0}, clobbers: callerSave}, aux: "CallOff", clobberFlags: true, call: true}, // call function via closure.  arg0=codeptr, arg1=closure, arg2=mem, auxint=argsize, returns mem
 		{name: "CALLinter", argLength: 2, reg: regInfo{inputs: []regMask{gp}, clobbers: callerSave}, aux: "CallOff", clobberFlags: true, call: true},                        // call fn by pointer.  arg0=codeptr, arg1=mem, auxint=argsize, returns mem
 
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index 0bc7b0ca0d..4082e84c6a 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -96,6 +96,54 @@ type AuxCall struct {
 	abiInfo *abi.ABIParamResultInfo // TODO remove fields above redundant with this information.
 }
 
+// Reg returns the regInfo for a given call, combining the derived in/out register masks
+// with the machine-specific register information in the input i.  (The machine-specific
+// regInfo is much handier at the call site than it is when the AuxCall is being constructed,
+// therefore do this lazily).
+//
+// TODO: there is a Clever Hack that allows pre-generation of a small-ish number of the slices
+// of inputInfo and outputInfo used here, provided that we are willing to reorder the inputs
+// and outputs from calls, so that all integer registers come first, then all floating registers.
+// At this point (active development of register ABI) that is very premature,
+// but if this turns out to be a cost, we could do it.
+func (a *AuxCall) Reg(i *regInfo, c *Config) *regInfo {
+	if a.reg.clobbers != 0 {
+		// Already updated
+		return a.reg
+	}
+	if a.abiInfo.InRegistersUsed()+a.abiInfo.OutRegistersUsed() == 0 {
+		// Shortcut for zero case, also handles old ABI.
+		a.reg = i
+		return a.reg
+	}
+	a.reg.inputs = append(a.reg.inputs, i.inputs...)
+	for _, p := range a.abiInfo.InParams() {
+		for _, r := range p.Registers {
+			m := archRegForAbiReg(r, c)
+			a.reg.inputs = append(a.reg.inputs, inputInfo{idx: len(a.reg.inputs), regs: (1 << m)})
+		}
+	}
+	a.reg.outputs = append(a.reg.outputs, i.outputs...)
+	for _, p := range a.abiInfo.OutParams() {
+		for _, r := range p.Registers {
+			m := archRegForAbiReg(r, c)
+			a.reg.outputs = append(a.reg.outputs, outputInfo{idx: len(a.reg.outputs), regs: (1 << m)})
+		}
+	}
+	a.reg.clobbers = i.clobbers
+	return a.reg
+}
+
+func archRegForAbiReg(r abi.RegIndex, c *Config) uint8 {
+	var m int8
+	if int(r) < len(c.intParamRegs) {
+		m = c.intParamRegs[r]
+	} else {
+		m = c.floatParamRegs[int(r)-len(c.intParamRegs)]
+	}
+	return uint8(m)
+}
+
 // OffsetOfResult returns the SP offset of result which (indexed 0, 1, etc).
 func (a *AuxCall) OffsetOfResult(which int64) int64 {
 	n := int64(a.abiInfo.OutParam(int(which)).Offset())
@@ -217,7 +265,11 @@ func StaticAuxCall(sym *obj.LSym, args []Param, results []Param, paramResultInfo
 	if paramResultInfo == nil {
 		panic(fmt.Errorf("Nil paramResultInfo, sym=%v", sym))
 	}
-	return &AuxCall{Fn: sym, args: args, results: results, abiInfo: paramResultInfo}
+	var reg *regInfo
+	if paramResultInfo.InRegistersUsed()+paramResultInfo.OutRegistersUsed() > 0 {
+		reg = &regInfo{}
+	}
+	return &AuxCall{Fn: sym, args: args, results: results, abiInfo: paramResultInfo, reg: reg}
 }
 
 // InterfaceAuxCall returns an AuxCall for an interface call.
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index a9565ffe4b..34445cfbf1 100644
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -13229,7 +13229,7 @@ var opcodeTable = [...]opInfo{
 	{
 		name:         "CALLstatic",
 		auxType:      auxCallOff,
-		argLen:       1,
+		argLen:       -1,
 		clobberFlags: true,
 		call:         true,
 		reg: regInfo{
diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go
index c11138bf4e..c2d0478e82 100644
--- a/src/cmd/compile/internal/ssa/regalloc.go
+++ b/src/cmd/compile/internal/ssa/regalloc.go
@@ -151,6 +151,14 @@ type register uint8
 
 const noRegister register = 255
 
+// For bulk initializing
+var noRegisters [32]register = [32]register{
+	noRegister, noRegister, noRegister, noRegister, noRegister, noRegister, noRegister, noRegister,
+	noRegister, noRegister, noRegister, noRegister, noRegister, noRegister, noRegister, noRegister,
+	noRegister, noRegister, noRegister, noRegister, noRegister, noRegister, noRegister, noRegister,
+	noRegister, noRegister, noRegister, noRegister, noRegister, noRegister, noRegister, noRegister,
+}
+
 // A regMask encodes a set of machine registers.
 // TODO: regMask -> regSet?
 type regMask uint64
@@ -818,9 +826,8 @@ func (s *regAllocState) regspec(v *Value) regInfo {
 		return regInfo{outputs: []outputInfo{{regs: 1 << uint(reg)}}}
 	}
 	if op.IsCall() {
-		// TODO Panic if not okay
 		if ac, ok := v.Aux.(*AuxCall); ok && ac.reg != nil {
-			return *ac.reg
+			return *ac.Reg(&opcodeTable[op].reg, s.f.Config)
 		}
 	}
 	return opcodeTable[op].reg
@@ -1456,7 +1463,8 @@ func (s *regAllocState) regalloc(f *Func) {
 
 			// Pick registers for outputs.
 			{
-				outRegs := [2]register{noRegister, noRegister}
+				outRegs := noRegisters // TODO if this is costly, hoist and clear incrementally below.
+				maxOutIdx := -1
 				var used regMask
 				for _, out := range regspec.outputs {
 					mask := out.regs & s.allocatable &^ used
@@ -1502,6 +1510,9 @@ func (s *regAllocState) regalloc(f *Func) {
 						mask &^= desired.avoid
 					}
 					r := s.allocReg(mask, v)
+					if out.idx > maxOutIdx {
+						maxOutIdx = out.idx
+					}
 					outRegs[out.idx] = r
 					used |= regMask(1) << r
 					s.tmpused |= regMask(1) << r
@@ -1518,8 +1529,14 @@ func (s *regAllocState) regalloc(f *Func) {
 					s.f.setHome(v, outLocs)
 					// Note that subsequent SelectX instructions will do the assignReg calls.
 				} else if v.Type.IsResults() {
-					// TODO register arguments need to make this work
-					panic("Oops, implement this.")
+					// preallocate outLocs to the right size, which is maxOutIdx+1
+					outLocs := make(LocResults, maxOutIdx+1, maxOutIdx+1)
+					for i := 0; i <= maxOutIdx; i++ {
+						if r := outRegs[i]; r != noRegister {
+							outLocs[i] = &s.registers[r]
+						}
+					}
+					s.f.setHome(v, outLocs)
 				} else {
 					if r := outRegs[0]; r != noRegister {
 						s.assignReg(r, v, v)
-- 
GitLab


From b7f4307761c61d2d3f563c37b0c9ad0e64899d9f Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Fri, 19 Feb 2021 12:42:57 +0700
Subject: [PATCH 0917/2400] cmd/compile: graceful handle error in noder
 LoadPackage

When syntax.Parse returns error, noder.file will be nil. Currently, we
continue accessing it regardlessly and depend on gc.hidePanic to hide
the panic from user.

Instead, we should gracefully handle the error in LoadPackage, then exit
earlier if any error occurred.

Updates #43311

Change-Id: I0a108ef360bd4f0cc9f481071b8967355e1513af
Reviewed-on: https://go-review.googlesource.com/c/go/+/294030
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/noder/noder.go | 3 +++
 test/fixedbugs/bug050.go                | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index d692bf97aa..8c456e4561 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -68,6 +68,9 @@ func LoadPackage(filenames []string) {
 		for e := range p.err {
 			p.errorAt(e.Pos, "%s", e.Msg)
 		}
+		if p.file == nil {
+			base.ErrorExit()
+		}
 		lines += p.file.EOF.Line()
 	}
 	base.Timer.AddEvent(int64(lines), "lines")
diff --git a/test/fixedbugs/bug050.go b/test/fixedbugs/bug050.go
index aba68b1dcb..1e299ed99a 100644
--- a/test/fixedbugs/bug050.go
+++ b/test/fixedbugs/bug050.go
@@ -1,4 +1,4 @@
-// errorcheck
+// errorcheck -d=panic
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
-- 
GitLab


From 12a405b96aadc0174d3b63e61f593bcc28465af0 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Fri, 19 Feb 2021 13:54:28 +0700
Subject: [PATCH 0918/2400] cmd/compile: do not set type for OPACK

That's an invalid operation and depend on gc.hidePanic to report error.

Updates #43311

Change-Id: I78d615c40ab1e7887f612491e215c1c2bb758ef6
Reviewed-on: https://go-review.googlesource.com/c/go/+/294031
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/typecheck/typecheck.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 5a3446b358..278e64fc61 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -528,7 +528,7 @@ func typecheck1(n ir.Node, top int) ir.Node {
 	case ir.OPACK:
 		n := n.(*ir.PkgName)
 		base.Errorf("use of package %v without selector", n.Sym())
-		n.SetType(nil)
+		n.SetDiag(true)
 		return n
 
 	// types (ODEREF is with exprs)
-- 
GitLab


From 8c22874e4e804e29ca040599ec63bb9e35233acd Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Fri, 19 Feb 2021 13:47:14 +0700
Subject: [PATCH 0919/2400] cmd/compile: skip diag error in checkassign if one
 was emitted

While at it, also remove checkassignlist, which is not used.

For #43311

Change-Id: Ie7ed81f68080d8881fca6035da64a9755f2cb555
Reviewed-on: https://go-review.googlesource.com/c/go/+/294032
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/typecheck/typecheck.go | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 278e64fc61..e7d4e81672 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -1612,6 +1612,10 @@ func checkassign(stmt ir.Node, n ir.Node) {
 		return
 	}
 
+	defer n.SetType(nil)
+	if n.Diag() {
+		return
+	}
 	switch {
 	case n.Op() == ir.ODOT && n.(*ir.SelectorExpr).X.Op() == ir.OINDEXMAP:
 		base.Errorf("cannot assign to struct field %v in map", n)
@@ -1622,13 +1626,6 @@ func checkassign(stmt ir.Node, n ir.Node) {
 	default:
 		base.Errorf("cannot assign to %v", n)
 	}
-	n.SetType(nil)
-}
-
-func checkassignlist(stmt ir.Node, l ir.Nodes) {
-	for _, n := range l {
-		checkassign(stmt, n)
-	}
 }
 
 func checkassignto(src *types.Type, dst ir.Node) {
-- 
GitLab


From 4b8b2c58647af6f1979d8c53d886c8cd71c99e4b Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Fri, 19 Feb 2021 13:50:42 +0700
Subject: [PATCH 0920/2400] cmd/compile: do not set type for OTYPE

That's an invalid operation and depend on gc.hidePanic to report error.

Updates #43311

Change-Id: Ib0761dcf4d9d2a23c41de7eff0376677a90b942e
Reviewed-on: https://go-review.googlesource.com/c/go/+/294033
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/typecheck/typecheck.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index e7d4e81672..240f0409e7 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -433,8 +433,8 @@ func typecheck(n ir.Node, top int) (res ir.Node) {
 	case top&ctxType == 0 && n.Op() == ir.OTYPE && t != nil:
 		if !n.Type().Broke() {
 			base.Errorf("type %v is not an expression", n.Type())
+			n.SetDiag(true)
 		}
-		n.SetType(nil)
 
 	case top&(ctxStmt|ctxExpr) == ctxStmt && !isStmt && t != nil:
 		if !n.Diag() {
-- 
GitLab


From 1d0256a9890b9179746551910a20cee97e653101 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Sat, 20 Feb 2021 02:40:35 +0700
Subject: [PATCH 0921/2400] cmd/compile: do not add invalid key to constSet

After CL 272654, the compiler now use go/constant.Value to represent
constant nodes. That makes ir.ConstantValue requires node type to
correctly return value for untyped int node. But untyped int node can
have nil type after typechecked, e.g: using int value as key for
map[string]int, that makes the compiler crashes.

To fix it, just don't add the invalid key to constSet, since when
it's not important to report duplicated keys when they aren't valid.

For #43311
Fixes #44432

Change-Id: I44d8f2b95f5cb339e77e8a705a94bcb16e62beb9
Reviewed-on: https://go-review.googlesource.com/c/go/+/294034
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/typecheck/const.go |  2 +-
 test/fixedbugs/issue44432.go                | 13 +++++++++++++
 2 files changed, 14 insertions(+), 1 deletion(-)
 create mode 100644 test/fixedbugs/issue44432.go

diff --git a/src/cmd/compile/internal/typecheck/const.go b/src/cmd/compile/internal/typecheck/const.go
index c60d36ba62..9b3a27b2d8 100644
--- a/src/cmd/compile/internal/typecheck/const.go
+++ b/src/cmd/compile/internal/typecheck/const.go
@@ -794,7 +794,7 @@ func (s *constSet) add(pos src.XPos, n ir.Node, what, where string) {
 		}
 	}
 
-	if !ir.IsConstNode(n) {
+	if !ir.IsConstNode(n) || n.Type() == nil {
 		return
 	}
 	if n.Type().IsUntyped() {
diff --git a/test/fixedbugs/issue44432.go b/test/fixedbugs/issue44432.go
new file mode 100644
index 0000000000..c5fb67e0d7
--- /dev/null
+++ b/test/fixedbugs/issue44432.go
@@ -0,0 +1,13 @@
+// errorcheck -G=0 -d=panic
+
+// Copyright 2021 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 p
+
+var m = map[string]int{
+	"a": 1,
+	1:   1, // ERROR "cannot use 1.*as type string in map key"
+	2:   2, // ERROR "cannot use 2.*as type string in map key"
+}
-- 
GitLab


From 868a110c568591d9085996ba05c94593809a437a Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Sun, 21 Feb 2021 22:27:19 +0700
Subject: [PATCH 0922/2400] cmd/compile: make check2 gracefully exit if it
 reported errors

Otherwise, if -d=panic was set, check2 will treat already reported
error as internal compiler error.

For #43311
Fixes #44445

Change-Id: I5dbe06334666df21d9107396b9dcfdd905aa1e44
Reviewed-on: https://go-review.googlesource.com/c/go/+/294850
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/noder/irgen.go | 2 +-
 test/fixedbugs/bug188.go                | 8 ++++----
 test/fixedbugs/bug358.go                | 2 +-
 test/fixedbugs/bug397.go                | 8 ++++----
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/cmd/compile/internal/noder/irgen.go b/src/cmd/compile/internal/noder/irgen.go
index 28536cc1f7..da5b024b1a 100644
--- a/src/cmd/compile/internal/noder/irgen.go
+++ b/src/cmd/compile/internal/noder/irgen.go
@@ -68,10 +68,10 @@ func check2(noders []*noder) {
 	}
 	pkg, err := conf.Check(base.Ctxt.Pkgpath, files, &info)
 	files = nil
+	base.ExitIfErrors()
 	if err != nil {
 		base.FatalfAt(src.NoXPos, "conf.Check error: %v", err)
 	}
-	base.ExitIfErrors()
 	if base.Flag.G < 2 {
 		os.Exit(0)
 	}
diff --git a/test/fixedbugs/bug188.go b/test/fixedbugs/bug188.go
index 5506147894..8195e3666d 100644
--- a/test/fixedbugs/bug188.go
+++ b/test/fixedbugs/bug188.go
@@ -1,4 +1,4 @@
-// errorcheck
+// errorcheck -d=panic
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -9,7 +9,7 @@ package main
 import "sort"
 
 func main() {
-	sort.Sort(nil);
-	var x int;
-	sort(x);	// ERROR "package"
+	sort.Sort(nil)
+	var x int
+	sort(x) // ERROR "package"
 }
diff --git a/test/fixedbugs/bug358.go b/test/fixedbugs/bug358.go
index 5ca0be1f6e..541051cdd3 100644
--- a/test/fixedbugs/bug358.go
+++ b/test/fixedbugs/bug358.go
@@ -1,4 +1,4 @@
-// errorcheck
+// errorcheck -d=panic
 
 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug397.go b/test/fixedbugs/bug397.go
index db8d652814..bf3a5fffc8 100644
--- a/test/fixedbugs/bug397.go
+++ b/test/fixedbugs/bug397.go
@@ -1,4 +1,4 @@
-// errorcheck
+// errorcheck -d=panic
 
 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -7,7 +7,7 @@
 package main
 
 // Issue 2623
-var m = map[string]int {
-	"abc":1,
-	1:2, // ERROR "cannot use 1.*as type string in map key|incompatible type|cannot convert"
+var m = map[string]int{
+	"abc": 1,
+	1:     2, // ERROR "cannot use 1.*as type string in map key|incompatible type|cannot convert"
 }
-- 
GitLab


From a2d92b5143ad6ed1b55b71032c5c1f468ba76fd4 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Fri, 19 Feb 2021 17:11:40 -0500
Subject: [PATCH 0923/2400] cmd/compile: register abi, morestack work and mole
 whacking

Morestack works for non-pointer register parameters

Within a function body, pointer-typed parameters are correctly
tracked.

Results still not hooked up.

For #40724.

Change-Id: Icaee0b51d0da54af983662d945d939b756088746
Reviewed-on: https://go-review.googlesource.com/c/go/+/294410
Trust: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/abi/abiutils.go   |  4 ++
 src/cmd/compile/internal/amd64/ssa.go      | 11 +++++
 src/cmd/compile/internal/ssa/debug.go      |  4 +-
 src/cmd/compile/internal/ssa/stackalloc.go | 41 +++++++++-------
 src/cmd/compile/internal/ssagen/ssa.go     | 48 +++++++++++++++++--
 src/cmd/internal/obj/link.go               | 23 ++++++---
 src/cmd/internal/obj/x86/obj6.go           | 55 ++++++++++++++--------
 test/abi/f_ret_z_not.go                    | 14 +++---
 test/abi/many_int_input.go                 | 30 ++++++++++++
 test/abi/many_int_input.out                |  1 +
 test/abi/regabipragma.go                   |  1 +
 11 files changed, 175 insertions(+), 57 deletions(-)
 create mode 100644 test/abi/many_int_input.go
 create mode 100644 test/abi/many_int_input.out

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index 3eab4b8d8b..f84f8f8e01 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -5,6 +5,7 @@
 package abi
 
 import (
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"fmt"
@@ -337,6 +338,9 @@ func (config *ABIConfig) updateOffset(result *ABIParamResultInfo, f *types.Field
 		if fOffset == types.BOGUS_FUNARG_OFFSET {
 			// Set the Offset the first time. After that, we may recompute it, but it should never change.
 			f.Offset = off
+			if f.Nname != nil {
+				f.Nname.(*ir.Name).SetFrameOffset(off)
+			}
 		} else if fOffset != off {
 			panic(fmt.Errorf("Offset changed from %d to %d", fOffset, off))
 		}
diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index d83d78f080..60baa4270f 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -980,6 +980,17 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssagen.AddAux(&p.From, v)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
+	case ssa.OpArgIntReg, ssa.OpArgFloatReg:
+		// The assembler needs to wrap the entry safepoint/stack growth code with spill/unspill
+		// The loop only runs once.
+		for _, ap := range v.Block.Func.RegArgs {
+			// Pass the spill/unspill information along to the assembler, offset by size of return PC pushed on stack.
+			addr := ssagen.SpillSlotAddr(ap.Mem(), x86.REG_SP, v.Block.Func.Config.PtrSize)
+			s.FuncInfo().AddSpill(
+				obj.RegSpill{Reg: ap.Reg(), Addr: addr, Unspill: loadByType(ap.Type()), Spill: storeByType(ap.Type())})
+		}
+		v.Block.Func.RegArgs = nil
+		ssagen.CheckArgReg(v)
 	case ssa.OpAMD64LoweredGetClosurePtr:
 		// Closure pointer is DX.
 		ssagen.CheckLoweredGetClosurePtr(v)
diff --git a/src/cmd/compile/internal/ssa/debug.go b/src/cmd/compile/internal/ssa/debug.go
index 68b6ab5fe9..d725fc526e 100644
--- a/src/cmd/compile/internal/ssa/debug.go
+++ b/src/cmd/compile/internal/ssa/debug.go
@@ -901,10 +901,10 @@ func (state *debugState) buildLocationLists(blockLocs []*BlockDebug) {
 
 			if opcodeTable[v.Op].zeroWidth {
 				if changed {
-					if v.Op == OpArg || v.Op == OpPhi || v.Op.isLoweredGetClosurePtr() {
+					if hasAnyArgOp(v) || v.Op == OpPhi || v.Op.isLoweredGetClosurePtr() {
 						// These ranges begin at true beginning of block, not after first instruction
 						if zeroWidthPending {
-							b.Func.Fatalf("Unexpected op mixed with OpArg/OpPhi/OpLoweredGetClosurePtr at beginning of block %s in %s\n%s", b, b.Func.Name, b.Func)
+							panic(fmt.Errorf("Unexpected op '%s' mixed with OpArg/OpPhi/OpLoweredGetClosurePtr at beginning of block %s in %s\n%s", v.LongString(), b, b.Func.Name, b.Func))
 						}
 						apcChangedSize = len(state.changedVars.contents())
 						continue
diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go
index 041e7855f6..45058d4e72 100644
--- a/src/cmd/compile/internal/ssa/stackalloc.go
+++ b/src/cmd/compile/internal/ssa/stackalloc.go
@@ -112,7 +112,7 @@ func (s *stackAllocState) init(f *Func, spillLive [][]ID) {
 		for _, v := range b.Values {
 			s.values[v.ID].typ = v.Type
 			s.values[v.ID].needSlot = !v.Type.IsMemory() && !v.Type.IsVoid() && !v.Type.IsFlags() && f.getHome(v.ID) == nil && !v.rematerializeable() && !v.OnWasmStack
-			s.values[v.ID].isArg = v.Op == OpArg
+			s.values[v.ID].isArg = hasAnyArgOp(v)
 			if f.pass.debug > stackDebug && s.values[v.ID].needSlot {
 				fmt.Printf("%s needs a stack slot\n", v)
 			}
@@ -151,28 +151,29 @@ func (s *stackAllocState) stackalloc() {
 
 	// Allocate args to their assigned locations.
 	for _, v := range f.Entry.Values {
-		if v.Op != OpArg { // && v.Op != OpArgFReg && v.Op != OpArgIReg  {
+		if !hasAnyArgOp(v) {
 			continue
 		}
 		if v.Aux == nil {
 			f.Fatalf("%s has nil Aux\n", v.LongString())
 		}
-		var loc LocalSlot
-		var name *ir.Name
-		var offset int64
 		if v.Op == OpArg {
-			name = v.Aux.(*ir.Name)
-			offset = v.AuxInt
-		} else {
-			nameOff := v.Aux.(*AuxNameOffset)
-			name = nameOff.Name
-			offset = nameOff.Offset
+			loc := LocalSlot{N: v.Aux.(*ir.Name), Type: v.Type, Off: v.AuxInt}
+			if f.pass.debug > stackDebug {
+				fmt.Printf("stackalloc OpArg %s to %s\n", v, loc)
+			}
+			f.setHome(v, loc)
+			continue
 		}
-		loc = LocalSlot{N: name, Type: v.Type, Off: offset}
+
+		nameOff := v.Aux.(*AuxNameOffset)
+		loc := LocalSlot{N: nameOff.Name, Type: v.Type, Off: nameOff.Offset}
 		if f.pass.debug > stackDebug {
-			fmt.Printf("stackalloc %s to %s\n", v, loc)
+			fmt.Printf("stackalloc Op%s %s to %s\n", v.Op, v, loc)
 		}
-		f.setHome(v, loc)
+		// register args already allocated to registers, but need to know the stack allocation for later
+		reg := f.getHome(v.ID).(*Register)
+		f.RegArgs = append(f.RegArgs, ArgPair{reg: reg, mem: loc})
 	}
 
 	// For each type, we keep track of all the stack slots we
@@ -209,7 +210,7 @@ func (s *stackAllocState) stackalloc() {
 				s.nNotNeed++
 				continue
 			}
-			if v.Op == OpArg {
+			if hasAnyArgOp(v) {
 				s.nArgSlot++
 				continue // already picked
 			}
@@ -396,7 +397,7 @@ func (s *stackAllocState) buildInterferenceGraph() {
 				for _, id := range live.contents() {
 					// Note: args can have different types and still interfere
 					// (with each other or with other values). See issue 23522.
-					if s.values[v.ID].typ.Compare(s.values[id].typ) == types.CMPeq || v.Op == OpArg || s.values[id].isArg {
+					if s.values[v.ID].typ.Compare(s.values[id].typ) == types.CMPeq || hasAnyArgOp(v) || s.values[id].isArg {
 						s.interfere[v.ID] = append(s.interfere[v.ID], id)
 						s.interfere[id] = append(s.interfere[id], v.ID)
 					}
@@ -407,13 +408,15 @@ func (s *stackAllocState) buildInterferenceGraph() {
 					live.add(a.ID)
 				}
 			}
-			if v.Op == OpArg && s.values[v.ID].needSlot {
+			if hasAnyArgOp(v) && s.values[v.ID].needSlot {
 				// OpArg is an input argument which is pre-spilled.
 				// We add back v.ID here because we want this value
 				// to appear live even before this point. Being live
 				// all the way to the start of the entry block prevents other
 				// values from being allocated to the same slot and clobbering
 				// the input value before we have a chance to load it.
+
+				// TODO(register args) this is apparently not wrong for register args -- is it necessary?
 				live.add(v.ID)
 			}
 		}
@@ -430,3 +433,7 @@ func (s *stackAllocState) buildInterferenceGraph() {
 		}
 	}
 }
+
+func hasAnyArgOp(v *Value) bool {
+	return v.Op == OpArg || v.Op == OpArgIntReg || v.Op == OpArgFloatReg
+}
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 05dd0c62a9..9ee855343f 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -221,7 +221,7 @@ func AbiForFunc(fn *ir.Func) *abi.ABIConfig {
 // Passing a nil function returns ABIInternal.
 func abiForFunc(fn *ir.Func, abi0, abi1 *abi.ABIConfig) *abi.ABIConfig {
 	a := abi1
-	if true || objabi.Regabi_enabled == 0 {
+	if !regabiEnabledForAllCompilation() {
 		a = abi0
 	}
 	if fn != nil && fn.Pragma&ir.RegisterParams != 0 { // TODO(register args) remove after register abi is working
@@ -235,6 +235,11 @@ func abiForFunc(fn *ir.Func, abi0, abi1 *abi.ABIConfig) *abi.ABIConfig {
 	return a
 }
 
+func regabiEnabledForAllCompilation() bool {
+	// TODO compiler does not yet change behavior for GOEXPERIMENT=regabi
+	return false && objabi.Regabi_enabled != 0
+}
+
 // getParam returns the Field of ith param of node n (which is a
 // function/method/interface call), where the receiver of a method call is
 // considered as the 0th parameter. This does not include the receiver of an
@@ -6404,6 +6409,10 @@ type State struct {
 	OnWasmStackSkipped int
 }
 
+func (s *State) FuncInfo() *obj.FuncInfo {
+	return s.pp.CurFunc.LSym.Func()
+}
+
 // Prog appends a new Prog.
 func (s *State) Prog(as obj.As) *obj.Prog {
 	p := s.pp.Prog(as)
@@ -6561,11 +6570,9 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 				// memory arg needs no code
 			case ssa.OpArg:
 				// input args need no code
-			case ssa.OpArgIntReg, ssa.OpArgFloatReg:
-				CheckArgReg(v)
 			case ssa.OpSP, ssa.OpSB:
 				// nothing to do
-			case ssa.OpSelect0, ssa.OpSelect1, ssa.OpSelectN:
+			case ssa.OpSelect0, ssa.OpSelect1, ssa.OpSelectN, ssa.OpMakeResult:
 				// nothing to do
 			case ssa.OpGetG:
 				// nothing to do when there's a g register,
@@ -7470,6 +7477,39 @@ func deferstruct(stksize int64) *types.Type {
 	return s
 }
 
+// SlotAddr uses LocalSlot information to initialize an obj.Addr
+// The resulting addr is used in a non-standard context -- in the prologue
+// of a function, before the frame has been constructed, so the standard
+// addressing for the parameters will be wrong.
+func SpillSlotAddr(slot *ssa.LocalSlot, baseReg int16, extraOffset int64) obj.Addr {
+	n, off := slot.N, slot.Off
+	if n.Class != ir.PPARAM && n.Class != ir.PPARAMOUT {
+		panic("Only expected to see param and returns here")
+	}
+	return obj.Addr{
+		Name:   obj.NAME_NONE,
+		Type:   obj.TYPE_MEM,
+		Reg:    baseReg,
+		Offset: off + extraOffset + n.FrameOffset(),
+	}
+}
+
+// AddrForParamSlot fills in an Addr appropriately for a Spill,
+// Restore, or VARLIVE.
+func AddrForParamSlot(slot *ssa.LocalSlot, addr *obj.Addr) {
+	// TODO replace this boilerplate in a couple of places.
+	n, off := slot.N, slot.Off
+	addr.Type = obj.TYPE_MEM
+	addr.Sym = n.Linksym()
+	addr.Offset = off
+	if n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT {
+		addr.Name = obj.NAME_PARAM
+		addr.Offset += n.FrameOffset()
+	} else {
+		addr.Name = obj.NAME_AUTO
+	}
+}
+
 var (
 	BoundsCheckFunc [ssa.BoundsKindCount]*obj.LSym
 	ExtendCheckFunc [ssa.BoundsKindCount]*obj.LSym
diff --git a/src/cmd/internal/obj/link.go b/src/cmd/internal/obj/link.go
index c74de779d2..448f45b47b 100644
--- a/src/cmd/internal/obj/link.go
+++ b/src/cmd/internal/obj/link.go
@@ -473,6 +473,7 @@ type FuncInfo struct {
 	Autot    map[*LSym]struct{}
 	Pcln     Pcln
 	InlMarks []InlMark
+	spills   []RegSpill
 
 	dwarfInfoSym       *LSym
 	dwarfLocSym        *LSym
@@ -552,6 +553,11 @@ func (fi *FuncInfo) AddInlMark(p *Prog, id int32) {
 	fi.InlMarks = append(fi.InlMarks, InlMark{p: p, id: id})
 }
 
+// AddSpill appends a spill record to the list for FuncInfo fi
+func (fi *FuncInfo) AddSpill(s RegSpill) {
+	fi.spills = append(fi.spills, s)
+}
+
 // Record the type symbol for an auto variable so that the linker
 // an emit DWARF type information for the type.
 func (fi *FuncInfo) RecordAutoType(gotype *LSym) {
@@ -803,12 +809,12 @@ type Auto struct {
 	Gotype  *LSym
 }
 
-// RegArg provides spill/fill information for a register-resident argument
+// RegSpill provides spill/fill information for a register-resident argument
 // to a function.  These need spilling/filling in the safepoint/stackgrowth case.
 // At the time of fill/spill, the offset must be adjusted by the architecture-dependent
 // adjustment to hardware SP that occurs in a call instruction.  E.g., for AMD64,
 // at Offset+8 because the return address was pushed.
-type RegArg struct {
+type RegSpill struct {
 	Addr           Addr
 	Reg            int16
 	Spill, Unspill As
@@ -844,7 +850,6 @@ type Link struct {
 	DebugInfo          func(fn *LSym, info *LSym, curfn interface{}) ([]dwarf.Scope, dwarf.InlCalls) // if non-nil, curfn is a *gc.Node
 	GenAbstractFunc    func(fn *LSym)
 	Errors             int
-	RegArgs            []RegArg
 
 	InParallel    bool // parallel backend phase in effect
 	UseBASEntries bool // use Base Address Selection Entries in location lists and PC ranges
@@ -893,9 +898,11 @@ func (ctxt *Link) Logf(format string, args ...interface{}) {
 	ctxt.Bso.Flush()
 }
 
-func (ctxt *Link) SpillRegisterArgs(last *Prog, pa ProgAlloc) *Prog {
+// SpillRegisterArgs emits the code to spill register args into whatever
+// locations the spill records specify.
+func (fi *FuncInfo) SpillRegisterArgs(last *Prog, pa ProgAlloc) *Prog {
 	// Spill register args.
-	for _, ra := range ctxt.RegArgs {
+	for _, ra := range fi.spills {
 		spill := Appendp(last, pa)
 		spill.As = ra.Spill
 		spill.From.Type = TYPE_REG
@@ -906,9 +913,11 @@ func (ctxt *Link) SpillRegisterArgs(last *Prog, pa ProgAlloc) *Prog {
 	return last
 }
 
-func (ctxt *Link) UnspillRegisterArgs(last *Prog, pa ProgAlloc) *Prog {
+// UnspillRegisterArgs emits the code to restore register args from whatever
+// locations the spill records specify.
+func (fi *FuncInfo) UnspillRegisterArgs(last *Prog, pa ProgAlloc) *Prog {
 	// Unspill any spilled register args
-	for _, ra := range ctxt.RegArgs {
+	for _, ra := range fi.spills {
 		unspill := Appendp(last, pa)
 		unspill.As = ra.Unspill
 		unspill.From = ra.Addr
diff --git a/src/cmd/internal/obj/x86/obj6.go b/src/cmd/internal/obj/x86/obj6.go
index bc3a3b4bbe..d70cbebc5e 100644
--- a/src/cmd/internal/obj/x86/obj6.go
+++ b/src/cmd/internal/obj/x86/obj6.go
@@ -135,7 +135,7 @@ func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
 			p.To.Index = REG_NONE
 		}
 	} else {
-		// load_g_cx, below, always inserts the 1-instruction sequence. Rewrite it
+		// load_g, below, always inserts the 1-instruction sequence. Rewrite it
 		// as the 2-instruction sequence if necessary.
 		//	MOVQ 0(TLS), BX
 		// becomes
@@ -644,8 +644,12 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 			regg = REGG // use the g register directly in ABIInternal
 		} else {
 			p = obj.Appendp(p, newprog)
-			p = load_g_cx(ctxt, p, newprog) // load g into CX
 			regg = REG_CX
+			if ctxt.Arch.Family == sys.AMD64 {
+				// Using this register means that stacksplit works w/ //go:registerparams even when objabi.Regabi_enabled == 0
+				regg = REGG // == REG_R14
+			}
+			p = load_g(ctxt, p, newprog, regg) // load g into regg
 		}
 	}
 
@@ -963,7 +967,7 @@ func indir_cx(ctxt *obj.Link, a *obj.Addr) {
 // Overwriting p is unusual but it lets use this in both the
 // prologue (caller must call appendp first) and in the epilogue.
 // Returns last new instruction.
-func load_g_cx(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) *obj.Prog {
+func load_g(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc, rg int16) *obj.Prog {
 	p.As = AMOVQ
 	if ctxt.Arch.PtrSize == 4 {
 		p.As = AMOVL
@@ -972,7 +976,7 @@ func load_g_cx(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) *obj.Prog {
 	p.From.Reg = REG_TLS
 	p.From.Offset = 0
 	p.To.Type = obj.TYPE_REG
-	p.To.Reg = REG_CX
+	p.To.Reg = rg
 
 	next := p.Link
 	progedit(ctxt, p, newprog)
@@ -1027,9 +1031,14 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
 		// unnecessarily. See issue #35470.
 		p = ctxt.StartUnsafePoint(p, newprog)
 	} else if framesize <= objabi.StackBig {
+		tmp := int16(REG_AX) // use AX for 32-bit
+		if ctxt.Arch.Family == sys.AMD64 {
+			// for 64-bit, stay away from register ABI parameter registers, even w/o GOEXPERIMENT=regabi
+			tmp = int16(REG_R13)
+		}
 		// large stack: SP-framesize <= stackguard-StackSmall
-		//	LEAQ -xxx(SP), AX
-		//	CMPQ AX, stackguard
+		//	LEAQ -xxx(SP), tmp
+		//	CMPQ tmp, stackguard
 		p = obj.Appendp(p, newprog)
 
 		p.As = lea
@@ -1037,12 +1046,12 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
 		p.From.Reg = REG_SP
 		p.From.Offset = -(int64(framesize) - objabi.StackSmall)
 		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_AX
+		p.To.Reg = tmp
 
 		p = obj.Appendp(p, newprog)
 		p.As = cmp
 		p.From.Type = obj.TYPE_REG
-		p.From.Reg = REG_AX
+		p.From.Reg = tmp
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = rg
 		p.To.Offset = 2 * int64(ctxt.Arch.PtrSize) // G.stackguard0
@@ -1052,6 +1061,12 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
 
 		p = ctxt.StartUnsafePoint(p, newprog) // see the comment above
 	} else {
+		tmp1 := int16(REG_SI)
+		tmp2 := int16(REG_AX)
+		if ctxt.Arch.Family == sys.AMD64 {
+			tmp1 = int16(REG_R13) // register ABI uses REG_SI and REG_AX for parameters.
+			tmp2 = int16(REG_R12)
+		}
 		// Such a large stack we need to protect against wraparound.
 		// If SP is close to zero:
 		//	SP-stackguard+StackGuard <= framesize + (StackGuard-StackSmall)
@@ -1060,12 +1075,12 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
 		//
 		// Preemption sets stackguard to StackPreempt, a very large value.
 		// That breaks the math above, so we have to check for that explicitly.
-		//	MOVQ	stackguard, SI
+		//	MOVQ	stackguard, tmp1
 		//	CMPQ	SI, $StackPreempt
 		//	JEQ	label-of-call-to-morestack
-		//	LEAQ	StackGuard(SP), AX
-		//	SUBQ	SI, AX
-		//	CMPQ	AX, $(framesize+(StackGuard-StackSmall))
+		//	LEAQ	StackGuard(SP), tmp2
+		//	SUBQ	tmp1, tmp2
+		//	CMPQ	tmp2, $(framesize+(StackGuard-StackSmall))
 
 		p = obj.Appendp(p, newprog)
 
@@ -1077,14 +1092,14 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
 			p.From.Offset = 3 * int64(ctxt.Arch.PtrSize) // G.stackguard1
 		}
 		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_SI
+		p.To.Reg = tmp1
 
 		p = ctxt.StartUnsafePoint(p, newprog) // see the comment above
 
 		p = obj.Appendp(p, newprog)
 		p.As = cmp
 		p.From.Type = obj.TYPE_REG
-		p.From.Reg = REG_SI
+		p.From.Reg = tmp1
 		p.To.Type = obj.TYPE_CONST
 		p.To.Offset = objabi.StackPreempt
 		if ctxt.Arch.Family == sys.I386 {
@@ -1102,19 +1117,19 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
 		p.From.Reg = REG_SP
 		p.From.Offset = int64(objabi.StackGuard)
 		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_AX
+		p.To.Reg = tmp2
 
 		p = obj.Appendp(p, newprog)
 		p.As = sub
 		p.From.Type = obj.TYPE_REG
-		p.From.Reg = REG_SI
+		p.From.Reg = tmp1
 		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_AX
+		p.To.Reg = tmp2
 
 		p = obj.Appendp(p, newprog)
 		p.As = cmp
 		p.From.Type = obj.TYPE_REG
-		p.From.Reg = REG_AX
+		p.From.Reg = tmp2
 		p.To.Type = obj.TYPE_CONST
 		p.To.Offset = int64(framesize) + (int64(objabi.StackGuard) - objabi.StackSmall)
 	}
@@ -1139,7 +1154,7 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
 
 	pcdata := ctxt.EmitEntryStackMap(cursym, spfix, newprog)
 	spill := ctxt.StartUnsafePoint(pcdata, newprog)
-	pcdata = ctxt.SpillRegisterArgs(spill, newprog)
+	pcdata = cursym.Func().SpillRegisterArgs(spill, newprog)
 
 	call := obj.Appendp(pcdata, newprog)
 	call.Pos = cursym.Func().Text.Pos
@@ -1164,7 +1179,7 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
 		progedit(ctxt, callend.Link, newprog)
 	}
 
-	pcdata = ctxt.UnspillRegisterArgs(callend, newprog)
+	pcdata = cursym.Func().UnspillRegisterArgs(callend, newprog)
 	pcdata = ctxt.EndUnsafePoint(pcdata, newprog, -1)
 
 	jmp := obj.Appendp(pcdata, newprog)
diff --git a/test/abi/f_ret_z_not.go b/test/abi/f_ret_z_not.go
index b072aea75e..d890223ff7 100644
--- a/test/abi/f_ret_z_not.go
+++ b/test/abi/f_ret_z_not.go
@@ -16,18 +16,18 @@ type NZ struct {
 }
 
 //go:noinline
-func f(x,y int) (Z,NZ,Z) {
+func f(x, y int) (Z, NZ, Z) {
 	var z Z
-	return z,NZ{x,y},z
+	return z, NZ{x, y}, z
 }
 
 //go:noinline
-func g() (Z,NZ,Z) {
-	a,b,c := f(3,4)
-	return c,b,a
+func g() (Z, NZ, Z) {
+	a, b, c := f(3, 4)
+	return c, b, a
 }
 
 func main() {
-	_,b,_ := g()
-	fmt.Println(b.x+b.y)
+	_, b, _ := g()
+	fmt.Println(b.x + b.y)
 }
diff --git a/test/abi/many_int_input.go b/test/abi/many_int_input.go
new file mode 100644
index 0000000000..6c3332f842
--- /dev/null
+++ b/test/abi/many_int_input.go
@@ -0,0 +1,30 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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 (
+	"fmt"
+)
+
+//go:registerparams
+//go:noinline
+func F(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z int64) {
+	G(z, y, x, w, v, u, t, s, r, q, p, o, n, m, l, k, j, i, h, g, f, e, d, c, b, a)
+}
+
+//go:registerparams
+//go:noinline
+func G(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z int64) {
+	fmt.Println(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z)
+}
+
+func main() {
+	F(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26)
+}
diff --git a/test/abi/many_int_input.out b/test/abi/many_int_input.out
new file mode 100644
index 0000000000..fecfa82581
--- /dev/null
+++ b/test/abi/many_int_input.out
@@ -0,0 +1 @@
+26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
diff --git a/test/abi/regabipragma.go b/test/abi/regabipragma.go
index 86f42f9779..070b3110d6 100644
--- a/test/abi/regabipragma.go
+++ b/test/abi/regabipragma.go
@@ -1,5 +1,6 @@
 // skip
 // runindir -gcflags=-c=1
+//go:build !windows
 // +build !windows
 
 // Copyright 2021 The Go Authors. All rights reserved.
-- 
GitLab


From 3778f8e07d06cabfccd1508295ad67270af078cd Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Fri, 19 Feb 2021 18:00:48 -0500
Subject: [PATCH 0924/2400] cmd/compile: fix pointer maps for morestack

Verified with test and with single step watching changes to register
values across morestack calls, after reload.

Also added stack-growth test with pointer parameters of varying lifetime.

For #40724.

Change-Id: Idb5fe27786ac5c6665a734d41e68d3d39de2f4da
Reviewed-on: https://go-review.googlesource.com/c/go/+/294429
Trust: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
---
 src/cmd/compile/internal/liveness/plive.go | 16 +++++
 src/cmd/compile/internal/ssa/value.go      | 12 ++--
 test/abi/uglyfib.go                        | 79 ++++++++++++++++++++++
 test/abi/uglyfib.out                       |  1 +
 4 files changed, 104 insertions(+), 4 deletions(-)
 create mode 100644 test/abi/uglyfib.go
 create mode 100644 test/abi/uglyfib.out

diff --git a/src/cmd/compile/internal/liveness/plive.go b/src/cmd/compile/internal/liveness/plive.go
index 53ae797fce..48a26cf66a 100644
--- a/src/cmd/compile/internal/liveness/plive.go
+++ b/src/cmd/compile/internal/liveness/plive.go
@@ -297,6 +297,22 @@ func affectedVar(v *ssa.Value) (*ir.Name, ssa.SymEffect) {
 		n, _ := ssa.AutoVar(v)
 		return n, ssa.SymWrite
 
+	case ssa.OpArgIntReg:
+		// This forces the spill slot for the register to be live at function entry.
+		// one of the following holds for a function F with pointer-valued register arg X:
+		//  0. No GC (so an uninitialized spill slot is okay)
+		//  1. GC at entry of F.  GC is precise, but the spills around morestack initialize X's spill slot
+		//  2. Stack growth at entry of F.  Same as GC.
+		//  3. GC occurs within F itself.  This has to be from preemption, and thus GC is conservative.
+		//     a. X is in a register -- then X is seen, and the spill slot is also scanned conservatively.
+		//     b. X is spilled -- the spill slot is initialized, and scanned conservatively
+		//     c. X is not live -- the spill slot is scanned conservatively, and it may contain X from an earlier spill.
+		//  4. GC within G, transitively called from F
+		//    a. X is live at call site, therefore is spilled, to its spill slot (which is live because of subsequent LoadReg).
+		//    b. X is not live at call site -- but neither is its spill slot.
+		n, _ := ssa.AutoVar(v)
+		return n, ssa.SymRead
+
 	case ssa.OpVarLive:
 		return v.Aux.(*ir.Name), ssa.SymRead
 	case ssa.OpVarDef, ssa.OpVarKill:
diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go
index 127e4ce641..c20fc87e90 100644
--- a/src/cmd/compile/internal/ssa/value.go
+++ b/src/cmd/compile/internal/ssa/value.go
@@ -517,9 +517,13 @@ func (*Value) CanBeAnSSAAux() {}
 // AutoVar returns a *Name and int64 representing the auto variable and offset within it
 // where v should be spilled.
 func AutoVar(v *Value) (*ir.Name, int64) {
-	loc := v.Block.Func.RegAlloc[v.ID].(LocalSlot)
-	if v.Type.Size() > loc.Type.Size() {
-		v.Fatalf("spill/restore type %s doesn't fit in slot type %s", v.Type, loc.Type)
+	if loc, ok := v.Block.Func.RegAlloc[v.ID].(LocalSlot); ok {
+		if v.Type.Size() > loc.Type.Size() {
+			v.Fatalf("spill/restore type %s doesn't fit in slot type %s", v.Type, loc.Type)
+		}
+		return loc.N, loc.Off
 	}
-	return loc.N, loc.Off
+	// Assume it is a register, return its spill slot, which needs to be live
+	nameOff := v.Aux.(*AuxNameOffset)
+	return nameOff.Name, nameOff.Offset
 }
diff --git a/test/abi/uglyfib.go b/test/abi/uglyfib.go
new file mode 100644
index 0000000000..bde3548bee
--- /dev/null
+++ b/test/abi/uglyfib.go
@@ -0,0 +1,79 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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 "fmt"
+
+// This test is designed to provoke a stack growth
+// in a way that very likely leaves junk in the
+// parameter save area if they aren't saved or spilled
+// there, as appropriate.
+
+//go:registerparams
+//go:noinline
+func f(x int, xm1, xm2, p *int) {
+	var y = [2]int{x - 4, 0}
+	if x < 2 {
+		*p += x
+		return
+	}
+	x -= 3
+	g(*xm1, xm2, &x, p)   // xm1 is no longer live.
+	h(*xm2, &x, &y[0], p) // xm2 is no longer live, but was spilled.
+}
+
+//go:registerparams
+//go:noinline
+func g(x int, xm1, xm2, p *int) {
+	var y = [3]int{x - 4, 0, 0}
+	if x < 2 {
+		*p += x
+		return
+	}
+	x -= 3
+	k(*xm2, &x, &y[0], p)
+	h(*xm1, xm2, &x, p)
+}
+
+//go:registerparams
+//go:noinline
+func h(x int, xm1, xm2, p *int) {
+	var y = [4]int{x - 4, 0, 0, 0}
+	if x < 2 {
+		*p += x
+		return
+	}
+	x -= 3
+	k(*xm1, xm2, &x, p)
+	f(*xm2, &x, &y[0], p)
+}
+
+//go:registerparams
+//go:noinline
+func k(x int, xm1, xm2, p *int) {
+	var y = [5]int{x - 4, 0, 0, 0, 0}
+	if x < 2 {
+		*p += x
+		return
+	}
+	x -= 3
+	f(*xm2, &x, &y[0], p)
+	g(*xm1, xm2, &x, p)
+}
+
+func main() {
+	x := 40
+	var y int
+	xm1 := x - 1
+	xm2 := x - 2
+	f(x, &xm1, &xm2, &y)
+
+	fmt.Printf("Fib(%d)=%d\n", x, y)
+}
diff --git a/test/abi/uglyfib.out b/test/abi/uglyfib.out
new file mode 100644
index 0000000000..d892270e20
--- /dev/null
+++ b/test/abi/uglyfib.out
@@ -0,0 +1 @@
+Fib(40)=102334155
-- 
GitLab


From a416efef5a278c9c8c5e133bbec5c2c1d0df9491 Mon Sep 17 00:00:00 2001
From: Tao Qingyun <qingyunha@gmail.com>
Date: Sat, 7 Nov 2020 02:43:27 +0000
Subject: [PATCH 0925/2400] =?UTF-8?q?runtime:=20remove=20a=20duplicated=20?=
 =?UTF-8?q?testcase=20of=20TestPallocDataFindScavengeCa=E2=80=A6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Change-Id: Ib44729ffb5d4d7b84114dcf028b7e0418c9d5035
GitHub-Last-Rev: 13f59a650aa424b4852ee4a803eebc793dbbfc15
GitHub-Pull-Request: golang/go#42434
Reviewed-on: https://go-review.googlesource.com/c/go/+/268021
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
Trust: Martin Möhrmann <moehrmann@google.com>
---
 src/runtime/mgcscavenge_test.go | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/src/runtime/mgcscavenge_test.go b/src/runtime/mgcscavenge_test.go
index 250343077f..3b12a2e1e6 100644
--- a/src/runtime/mgcscavenge_test.go
+++ b/src/runtime/mgcscavenge_test.go
@@ -152,12 +152,6 @@ func TestPallocDataFindScavengeCandidate(t *testing.T) {
 			max:   PallocChunkPages,
 			want:  BitRange{0, uint(m)},
 		}
-		tests["StartFree"+suffix] = test{
-			alloc: []BitRange{{uint(m), PallocChunkPages - uint(m)}},
-			min:   m,
-			max:   PallocChunkPages,
-			want:  BitRange{0, uint(m)},
-		}
 		tests["EndFree"+suffix] = test{
 			alloc: []BitRange{{0, PallocChunkPages - uint(m)}},
 			min:   m,
-- 
GitLab


From 9a40dee3ee9c69e8bb4952f9e14b1817195d1f3d Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Thu, 4 Mar 2021 10:39:32 -0500
Subject: [PATCH 0926/2400] cmd/go: reject 'go list -m MOD@patch' when no
 existing version of MOD is required

Noticed while debugging failing tests for #36460.

Fixes #44788

Change-Id: Ic2cf511d871b29284f7372920f6f7d452825dd63
Reviewed-on: https://go-review.googlesource.com/c/go/+/298651
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/internal/modload/list.go                  | 2 +-
 src/cmd/go/internal/modload/query.go                 | 2 +-
 src/cmd/go/internal/modload/query_test.go            | 2 +-
 src/cmd/go/testdata/script/mod_prefer_compatible.txt | 4 ++--
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/cmd/go/internal/modload/list.go b/src/cmd/go/internal/modload/list.go
index de16c2f786..6dba6bea22 100644
--- a/src/cmd/go/internal/modload/list.go
+++ b/src/cmd/go/internal/modload/list.go
@@ -78,7 +78,7 @@ func listModules(ctx context.Context, args []string, listVersions, listRetracted
 		if i := strings.Index(arg, "@"); i >= 0 {
 			path := arg[:i]
 			vers := arg[i+1:]
-			var current string
+			current := "none"
 			for _, m := range buildList {
 				if m.Path == path {
 					current = m.Version
diff --git a/src/cmd/go/internal/modload/query.go b/src/cmd/go/internal/modload/query.go
index 8affd179bb..a8012c792a 100644
--- a/src/cmd/go/internal/modload/query.go
+++ b/src/cmd/go/internal/modload/query.go
@@ -330,7 +330,7 @@ func newQueryMatcher(path string, query, current string, allowed AllowedFunc) (*
 		}
 
 	case query == "patch":
-		if current == "none" {
+		if current == "" || current == "none" {
 			return nil, &NoPatchBaseError{path}
 		}
 		if current == "" {
diff --git a/src/cmd/go/internal/modload/query_test.go b/src/cmd/go/internal/modload/query_test.go
index e225a0e71e..6e39df45a7 100644
--- a/src/cmd/go/internal/modload/query_test.go
+++ b/src/cmd/go/internal/modload/query_test.go
@@ -122,7 +122,7 @@ var queryTests = []struct {
 	{path: queryRepo, query: "upgrade", allow: "NOMATCH", err: `no matching versions for query "upgrade"`},
 	{path: queryRepo, query: "upgrade", current: "v1.9.9", allow: "NOMATCH", err: `vcs-test.golang.org/git/querytest.git@v1.9.9: disallowed module version`},
 	{path: queryRepo, query: "upgrade", current: "v1.99.99", err: `vcs-test.golang.org/git/querytest.git@v1.99.99: invalid version: unknown revision v1.99.99`},
-	{path: queryRepo, query: "patch", current: "", vers: "v1.9.9"},
+	{path: queryRepo, query: "patch", current: "", err: `can't query version "patch" of module vcs-test.golang.org/git/querytest.git: no existing version is required`},
 	{path: queryRepo, query: "patch", current: "v0.1.0", vers: "v0.1.2"},
 	{path: queryRepo, query: "patch", current: "v1.9.0", vers: "v1.9.9"},
 	{path: queryRepo, query: "patch", current: "v1.9.10-pre1", vers: "v1.9.10-pre1"},
diff --git a/src/cmd/go/testdata/script/mod_prefer_compatible.txt b/src/cmd/go/testdata/script/mod_prefer_compatible.txt
index aa6260f63c..1b408c3e9e 100644
--- a/src/cmd/go/testdata/script/mod_prefer_compatible.txt
+++ b/src/cmd/go/testdata/script/mod_prefer_compatible.txt
@@ -23,8 +23,8 @@ stdout '^github.com/russross/blackfriday v1\.'
 go list -m github.com/russross/blackfriday@upgrade
 stdout '^github.com/russross/blackfriday v1\.'
 
-go list -m github.com/russross/blackfriday@patch
-stdout '^github.com/russross/blackfriday v1\.'
+! go list -m github.com/russross/blackfriday@patch
+stderr '^go list -m: github.com/russross/blackfriday@patch: can''t query version "patch" of module github.com/russross/blackfriday: no existing version is required$'
 
 # If we're fetching directly from version control, ignored +incompatible
 # versions should also be omitted by 'go list'.
-- 
GitLab


From 9c54f878d26e106f8e375c31aabceb1e36ff4050 Mon Sep 17 00:00:00 2001
From: LeonardWang <wangdeyu0907@gmail.com>
Date: Thu, 7 Jan 2021 00:36:34 +0800
Subject: [PATCH 0927/2400] runtime: remove GODEBUG=scavenge mode

Change-Id: Ic4c7b5086303c7faa49f4cbf6738e66d5de35c7e
Reviewed-on: https://go-review.googlesource.com/c/go/+/282012
Trust: Michael Pratt <mpratt@google.com>
Run-TryBot: Michael Pratt <mpratt@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Austin Clements <austin@google.com>
---
 src/runtime/extern.go   | 2 --
 src/runtime/runtime1.go | 2 --
 2 files changed, 4 deletions(-)

diff --git a/src/runtime/extern.go b/src/runtime/extern.go
index bbe41dd0d4..b73d68428f 100644
--- a/src/runtime/extern.go
+++ b/src/runtime/extern.go
@@ -110,8 +110,6 @@ It is a comma-separated list of name=val pairs setting these named variables:
 	with a trivial allocator that obtains memory from the operating system and
 	never reclaims any memory.
 
-	scavenge: scavenge=1 enables debugging mode of heap scavenger.
-
 	scavtrace: setting scavtrace=1 causes the runtime to emit a single line to standard
 	error, roughly once per GC cycle, summarizing the amount of work done by the
 	scavenger as well as the total amount of memory returned to the operating system
diff --git a/src/runtime/runtime1.go b/src/runtime/runtime1.go
index 30b7044bff..b238da8f51 100644
--- a/src/runtime/runtime1.go
+++ b/src/runtime/runtime1.go
@@ -310,7 +310,6 @@ var debug struct {
 	gctrace            int32
 	invalidptr         int32
 	madvdontneed       int32 // for Linux; issue 28466
-	scavenge           int32
 	scavtrace          int32
 	scheddetail        int32
 	schedtrace         int32
@@ -339,7 +338,6 @@ var dbgvars = []dbgVar{
 	{"invalidptr", &debug.invalidptr},
 	{"madvdontneed", &debug.madvdontneed},
 	{"sbrk", &debug.sbrk},
-	{"scavenge", &debug.scavenge},
 	{"scavtrace", &debug.scavtrace},
 	{"scheddetail", &debug.scheddetail},
 	{"schedtrace", &debug.schedtrace},
-- 
GitLab


From cfb609bfb70027e60d71a5ac7e9202144246b98a Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Thu, 4 Feb 2021 22:46:23 -0500
Subject: [PATCH 0928/2400] cmd/go: ensure that the test subprocess always
 times out in TestScript/test_write_profiles_on_timeout

This test verifies the behavior of a test that fails due to timing
out. However, the test to be timed out was only sleeping for 1s before
returning successfully. That is empirically not always long enough for
the test process itself to detect the timeout and terminate.

We could replace the sleep with a select{}, but that would assume that
the deadlock detector does not terminate a test that reaches that
state (true today, but not necessarily so).

We could replace the arbitrarily sleep with an arbitrarily longer
sleep, but that's, well, arbitrary.

Instead, have the test sleep in an unbounded loop to ensure that it
always continues to run until the timeout is detected, and check the
test output to ensure that it actually reached the timeout path.

Fixes #32983

Change-Id: Ie7f210b36ef0cc0a4db473f780e15a3d6def8bda
Reviewed-on: https://go-review.googlesource.com/c/go/+/289889
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 .../script/test_write_profiles_on_timeout.txt     | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/src/cmd/go/testdata/script/test_write_profiles_on_timeout.txt b/src/cmd/go/testdata/script/test_write_profiles_on_timeout.txt
index 08e67a429e..0db183f8f0 100644
--- a/src/cmd/go/testdata/script/test_write_profiles_on_timeout.txt
+++ b/src/cmd/go/testdata/script/test_write_profiles_on_timeout.txt
@@ -3,6 +3,7 @@
 [short] skip
 
 ! go test -cpuprofile cpu.pprof -memprofile mem.pprof -timeout 1ms
+stdout '^panic: test timed out'
 grep . cpu.pprof
 grep . mem.pprof
 
@@ -12,6 +13,14 @@ module profiling
 go 1.16
 -- timeout_test.go --
 package timeouttest_test
-import "testing"
-import "time"
-func TestSleep(t *testing.T) { time.Sleep(time.Second) }
+
+import (
+	"testing"
+	"time"
+)
+
+func TestSleep(t *testing.T) {
+	for {
+		time.Sleep(1 * time.Second)
+	}
+}
-- 
GitLab


From 2d30c94874c127d9028e29b77fadeb284c23e89a Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Tue, 3 Nov 2020 10:35:34 -0600
Subject: [PATCH 0929/2400] cmd/internal: Add 6 args to ppc64 optab

This is a preparatory patch to support 6 arg opcodes on POWER10,
and simplify 5 arg opcode processing (e.g RLWNM and similar).

This expands the optab structure, and renames a4 arguments to a6.
No actual change in functionality is made.

Change-Id: I785e4177778e4bf1326cf8e46e8aeaaa0e4d406b
Reviewed-on: https://go-review.googlesource.com/c/go/+/295031
Run-TryBot: Lynn Boger <laboger@linux.vnet.ibm.com>
Run-TryBot: Carlos Eduardo Seo <carlos.seo@linaro.org>
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: Keith Randall <khr@golang.org>
---
 src/cmd/internal/obj/ppc64/asm9.go | 915 +++++++++++++++--------------
 1 file changed, 465 insertions(+), 450 deletions(-)

diff --git a/src/cmd/internal/obj/ppc64/asm9.go b/src/cmd/internal/obj/ppc64/asm9.go
index 97b4cb2317..7985f050de 100644
--- a/src/cmd/internal/obj/ppc64/asm9.go
+++ b/src/cmd/internal/obj/ppc64/asm9.go
@@ -64,13 +64,15 @@ const (
 
 type Optab struct {
 	as    obj.As // Opcode
-	a1    uint8
-	a2    uint8
-	a3    uint8
-	a4    uint8
-	type_ int8 // cases in asmout below. E.g., 44 = st r,(ra+rb); 45 = ld (ra+rb), r
-	size  int8
-	param int16
+	a1    uint8  // p.From argument (obj.Addr). p is of type obj.Prog.
+	a2    uint8  // p.Reg argument (int16 Register)
+	a3    uint8  // p.RestArgs[0]  (obj.AddrPos)
+	a4    uint8  // p.RestArgs[1]
+	a5    uint8  // p.RestARgs[2]
+	a6    uint8  // p.To (obj.Addr)
+	type_ int8   // cases in asmout below. E.g., 44 = st r,(ra+rb); 45 = ld (ra+rb), r
+	size  int8   // Text space in bytes to lay operation
+	param int16  // Implied base register for pseudo-registers
 }
 
 // optab contains an array to be sliced of accepted operand combinations for an
@@ -88,546 +90,546 @@ type Optab struct {
 // Likewise, each slice of optab is dynamically sorted using the ocmp Sort interface
 // to arrange entries to minimize text size of each opcode.
 var optab = []Optab{
-	{as: obj.ATEXT, a1: C_LEXT, a4: C_TEXTSIZE, type_: 0, size: 0},
-	{as: obj.ATEXT, a1: C_LEXT, a3: C_LCON, a4: C_TEXTSIZE, type_: 0, size: 0},
-	{as: obj.ATEXT, a1: C_ADDR, a4: C_TEXTSIZE, type_: 0, size: 0},
-	{as: obj.ATEXT, a1: C_ADDR, a3: C_LCON, a4: C_TEXTSIZE, type_: 0, size: 0},
+	{as: obj.ATEXT, a1: C_LEXT, a6: C_TEXTSIZE, type_: 0, size: 0},
+	{as: obj.ATEXT, a1: C_LEXT, a3: C_LCON, a6: C_TEXTSIZE, type_: 0, size: 0},
+	{as: obj.ATEXT, a1: C_ADDR, a6: C_TEXTSIZE, type_: 0, size: 0},
+	{as: obj.ATEXT, a1: C_ADDR, a3: C_LCON, a6: C_TEXTSIZE, type_: 0, size: 0},
 	/* move register */
-	{as: AMOVD, a1: C_REG, a4: C_REG, type_: 1, size: 4},
-	{as: AMOVB, a1: C_REG, a4: C_REG, type_: 12, size: 4},
-	{as: AMOVBZ, a1: C_REG, a4: C_REG, type_: 13, size: 4},
-	{as: AMOVW, a1: C_REG, a4: C_REG, type_: 12, size: 4},
-	{as: AMOVWZ, a1: C_REG, a4: C_REG, type_: 13, size: 4},
-	{as: AADD, a1: C_REG, a2: C_REG, a4: C_REG, type_: 2, size: 4},
-	{as: AADD, a1: C_REG, a4: C_REG, type_: 2, size: 4},
-	{as: AADD, a1: C_SCON, a2: C_REG, a4: C_REG, type_: 4, size: 4},
-	{as: AADD, a1: C_SCON, a4: C_REG, type_: 4, size: 4},
-	{as: AADD, a1: C_ADDCON, a2: C_REG, a4: C_REG, type_: 4, size: 4},
-	{as: AADD, a1: C_ADDCON, a4: C_REG, type_: 4, size: 4},
-	{as: AADD, a1: C_UCON, a2: C_REG, a4: C_REG, type_: 20, size: 4},
-	{as: AADD, a1: C_UCON, a4: C_REG, type_: 20, size: 4},
-	{as: AADD, a1: C_ANDCON, a2: C_REG, a4: C_REG, type_: 22, size: 8},
-	{as: AADD, a1: C_ANDCON, a4: C_REG, type_: 22, size: 8},
-	{as: AADD, a1: C_LCON, a2: C_REG, a4: C_REG, type_: 22, size: 12},
-	{as: AADD, a1: C_LCON, a4: C_REG, type_: 22, size: 12},
-	{as: AADDIS, a1: C_ADDCON, a2: C_REG, a4: C_REG, type_: 20, size: 4},
-	{as: AADDIS, a1: C_ADDCON, a4: C_REG, type_: 20, size: 4},
-	{as: AADDC, a1: C_REG, a2: C_REG, a4: C_REG, type_: 2, size: 4},
-	{as: AADDC, a1: C_REG, a4: C_REG, type_: 2, size: 4},
-	{as: AADDC, a1: C_ADDCON, a2: C_REG, a4: C_REG, type_: 4, size: 4},
-	{as: AADDC, a1: C_ADDCON, a4: C_REG, type_: 4, size: 4},
-	{as: AADDC, a1: C_LCON, a2: C_REG, a4: C_REG, type_: 22, size: 12},
-	{as: AADDC, a1: C_LCON, a4: C_REG, type_: 22, size: 12},
-	{as: AAND, a1: C_REG, a2: C_REG, a4: C_REG, type_: 6, size: 4}, /* logical, no literal */
-	{as: AAND, a1: C_REG, a4: C_REG, type_: 6, size: 4},
-	{as: AANDCC, a1: C_REG, a2: C_REG, a4: C_REG, type_: 6, size: 4},
-	{as: AANDCC, a1: C_REG, a4: C_REG, type_: 6, size: 4},
-	{as: AANDCC, a1: C_ANDCON, a4: C_REG, type_: 58, size: 4},
-	{as: AANDCC, a1: C_ANDCON, a2: C_REG, a4: C_REG, type_: 58, size: 4},
-	{as: AANDCC, a1: C_UCON, a4: C_REG, type_: 59, size: 4},
-	{as: AANDCC, a1: C_UCON, a2: C_REG, a4: C_REG, type_: 59, size: 4},
-	{as: AANDCC, a1: C_ADDCON, a4: C_REG, type_: 23, size: 8},
-	{as: AANDCC, a1: C_ADDCON, a2: C_REG, a4: C_REG, type_: 23, size: 8},
-	{as: AANDCC, a1: C_LCON, a4: C_REG, type_: 23, size: 12},
-	{as: AANDCC, a1: C_LCON, a2: C_REG, a4: C_REG, type_: 23, size: 12},
-	{as: AANDISCC, a1: C_ANDCON, a4: C_REG, type_: 59, size: 4},
-	{as: AANDISCC, a1: C_ANDCON, a2: C_REG, a4: C_REG, type_: 59, size: 4},
-	{as: AMULLW, a1: C_REG, a2: C_REG, a4: C_REG, type_: 2, size: 4},
-	{as: AMULLW, a1: C_REG, a4: C_REG, type_: 2, size: 4},
-	{as: AMULLW, a1: C_ADDCON, a2: C_REG, a4: C_REG, type_: 4, size: 4},
-	{as: AMULLW, a1: C_ADDCON, a4: C_REG, type_: 4, size: 4},
-	{as: AMULLW, a1: C_ANDCON, a2: C_REG, a4: C_REG, type_: 4, size: 4},
-	{as: AMULLW, a1: C_ANDCON, a4: C_REG, type_: 4, size: 4},
-	{as: AMULLW, a1: C_LCON, a2: C_REG, a4: C_REG, type_: 22, size: 12},
-	{as: AMULLW, a1: C_LCON, a4: C_REG, type_: 22, size: 12},
-	{as: ASUBC, a1: C_REG, a2: C_REG, a4: C_REG, type_: 10, size: 4},
-	{as: ASUBC, a1: C_REG, a4: C_REG, type_: 10, size: 4},
-	{as: ASUBC, a1: C_REG, a3: C_ADDCON, a4: C_REG, type_: 27, size: 4},
-	{as: ASUBC, a1: C_REG, a3: C_LCON, a4: C_REG, type_: 28, size: 12},
-	{as: AOR, a1: C_REG, a2: C_REG, a4: C_REG, type_: 6, size: 4}, /* logical, literal not cc (or/xor) */
-	{as: AOR, a1: C_REG, a4: C_REG, type_: 6, size: 4},
-	{as: AOR, a1: C_ANDCON, a4: C_REG, type_: 58, size: 4},
-	{as: AOR, a1: C_ANDCON, a2: C_REG, a4: C_REG, type_: 58, size: 4},
-	{as: AOR, a1: C_UCON, a4: C_REG, type_: 59, size: 4},
-	{as: AOR, a1: C_UCON, a2: C_REG, a4: C_REG, type_: 59, size: 4},
-	{as: AOR, a1: C_ADDCON, a4: C_REG, type_: 23, size: 8},
-	{as: AOR, a1: C_ADDCON, a2: C_REG, a4: C_REG, type_: 23, size: 8},
-	{as: AOR, a1: C_LCON, a4: C_REG, type_: 23, size: 12},
-	{as: AOR, a1: C_LCON, a2: C_REG, a4: C_REG, type_: 23, size: 12},
-	{as: AORIS, a1: C_ANDCON, a4: C_REG, type_: 59, size: 4},
-	{as: AORIS, a1: C_ANDCON, a2: C_REG, a4: C_REG, type_: 59, size: 4},
-	{as: ADIVW, a1: C_REG, a2: C_REG, a4: C_REG, type_: 2, size: 4}, /* op r1[,r2],r3 */
-	{as: ADIVW, a1: C_REG, a4: C_REG, type_: 2, size: 4},
-	{as: ASUB, a1: C_REG, a2: C_REG, a4: C_REG, type_: 10, size: 4}, /* op r2[,r1],r3 */
-	{as: ASUB, a1: C_REG, a4: C_REG, type_: 10, size: 4},
-	{as: ASLW, a1: C_REG, a4: C_REG, type_: 6, size: 4},
-	{as: ASLW, a1: C_REG, a2: C_REG, a4: C_REG, type_: 6, size: 4},
-	{as: ASLD, a1: C_REG, a4: C_REG, type_: 6, size: 4},
-	{as: ASLD, a1: C_REG, a2: C_REG, a4: C_REG, type_: 6, size: 4},
-	{as: ASLD, a1: C_SCON, a2: C_REG, a4: C_REG, type_: 25, size: 4},
-	{as: ASLD, a1: C_SCON, a4: C_REG, type_: 25, size: 4},
-	{as: AEXTSWSLI, a1: C_SCON, a4: C_REG, type_: 25, size: 4},
-	{as: AEXTSWSLI, a1: C_SCON, a2: C_REG, a4: C_REG, type_: 25, size: 4},
-	{as: ASLW, a1: C_SCON, a2: C_REG, a4: C_REG, type_: 57, size: 4},
-	{as: ASLW, a1: C_SCON, a4: C_REG, type_: 57, size: 4},
-	{as: ASRAW, a1: C_REG, a4: C_REG, type_: 6, size: 4},
-	{as: ASRAW, a1: C_REG, a2: C_REG, a4: C_REG, type_: 6, size: 4},
-	{as: ASRAW, a1: C_SCON, a2: C_REG, a4: C_REG, type_: 56, size: 4},
-	{as: ASRAW, a1: C_SCON, a4: C_REG, type_: 56, size: 4},
-	{as: ASRAD, a1: C_REG, a4: C_REG, type_: 6, size: 4},
-	{as: ASRAD, a1: C_REG, a2: C_REG, a4: C_REG, type_: 6, size: 4},
-	{as: ASRAD, a1: C_SCON, a2: C_REG, a4: C_REG, type_: 56, size: 4},
-	{as: ASRAD, a1: C_SCON, a4: C_REG, type_: 56, size: 4},
-	{as: ARLWMI, a1: C_SCON, a2: C_REG, a3: C_LCON, a4: C_REG, type_: 62, size: 4},
-	{as: ARLWMI, a1: C_REG, a2: C_REG, a3: C_LCON, a4: C_REG, type_: 63, size: 4},
-	{as: ACLRLSLWI, a1: C_SCON, a2: C_REG, a3: C_LCON, a4: C_REG, type_: 62, size: 4},
-	{as: ARLDMI, a1: C_SCON, a2: C_REG, a3: C_LCON, a4: C_REG, type_: 30, size: 4},
-	{as: ARLDC, a1: C_SCON, a2: C_REG, a3: C_LCON, a4: C_REG, type_: 29, size: 4},
-	{as: ARLDCL, a1: C_SCON, a2: C_REG, a3: C_LCON, a4: C_REG, type_: 29, size: 4},
-	{as: ARLDCL, a1: C_REG, a2: C_REG, a3: C_LCON, a4: C_REG, type_: 14, size: 4},
-	{as: ARLDICL, a1: C_REG, a2: C_REG, a3: C_LCON, a4: C_REG, type_: 14, size: 4},
-	{as: ARLDICL, a1: C_SCON, a2: C_REG, a3: C_LCON, a4: C_REG, type_: 14, size: 4},
-	{as: ARLDCL, a1: C_REG, a3: C_LCON, a4: C_REG, type_: 14, size: 4},
-	{as: AFADD, a1: C_FREG, a4: C_FREG, type_: 2, size: 4},
-	{as: AFADD, a1: C_FREG, a2: C_FREG, a4: C_FREG, type_: 2, size: 4},
-	{as: AFABS, a1: C_FREG, a4: C_FREG, type_: 33, size: 4},
-	{as: AFABS, a4: C_FREG, type_: 33, size: 4},
-	{as: AFMOVD, a1: C_FREG, a4: C_FREG, type_: 33, size: 4},
-	{as: AFMADD, a1: C_FREG, a2: C_FREG, a3: C_FREG, a4: C_FREG, type_: 34, size: 4},
-	{as: AFMUL, a1: C_FREG, a4: C_FREG, type_: 32, size: 4},
-	{as: AFMUL, a1: C_FREG, a2: C_FREG, a4: C_FREG, type_: 32, size: 4},
+	{as: AMOVD, a1: C_REG, a6: C_REG, type_: 1, size: 4},
+	{as: AMOVB, a1: C_REG, a6: C_REG, type_: 12, size: 4},
+	{as: AMOVBZ, a1: C_REG, a6: C_REG, type_: 13, size: 4},
+	{as: AMOVW, a1: C_REG, a6: C_REG, type_: 12, size: 4},
+	{as: AMOVWZ, a1: C_REG, a6: C_REG, type_: 13, size: 4},
+	{as: AADD, a1: C_REG, a2: C_REG, a6: C_REG, type_: 2, size: 4},
+	{as: AADD, a1: C_REG, a6: C_REG, type_: 2, size: 4},
+	{as: AADD, a1: C_SCON, a2: C_REG, a6: C_REG, type_: 4, size: 4},
+	{as: AADD, a1: C_SCON, a6: C_REG, type_: 4, size: 4},
+	{as: AADD, a1: C_ADDCON, a2: C_REG, a6: C_REG, type_: 4, size: 4},
+	{as: AADD, a1: C_ADDCON, a6: C_REG, type_: 4, size: 4},
+	{as: AADD, a1: C_UCON, a2: C_REG, a6: C_REG, type_: 20, size: 4},
+	{as: AADD, a1: C_UCON, a6: C_REG, type_: 20, size: 4},
+	{as: AADD, a1: C_ANDCON, a2: C_REG, a6: C_REG, type_: 22, size: 8},
+	{as: AADD, a1: C_ANDCON, a6: C_REG, type_: 22, size: 8},
+	{as: AADD, a1: C_LCON, a2: C_REG, a6: C_REG, type_: 22, size: 12},
+	{as: AADD, a1: C_LCON, a6: C_REG, type_: 22, size: 12},
+	{as: AADDIS, a1: C_ADDCON, a2: C_REG, a6: C_REG, type_: 20, size: 4},
+	{as: AADDIS, a1: C_ADDCON, a6: C_REG, type_: 20, size: 4},
+	{as: AADDC, a1: C_REG, a2: C_REG, a6: C_REG, type_: 2, size: 4},
+	{as: AADDC, a1: C_REG, a6: C_REG, type_: 2, size: 4},
+	{as: AADDC, a1: C_ADDCON, a2: C_REG, a6: C_REG, type_: 4, size: 4},
+	{as: AADDC, a1: C_ADDCON, a6: C_REG, type_: 4, size: 4},
+	{as: AADDC, a1: C_LCON, a2: C_REG, a6: C_REG, type_: 22, size: 12},
+	{as: AADDC, a1: C_LCON, a6: C_REG, type_: 22, size: 12},
+	{as: AAND, a1: C_REG, a2: C_REG, a6: C_REG, type_: 6, size: 4}, /* logical, no literal */
+	{as: AAND, a1: C_REG, a6: C_REG, type_: 6, size: 4},
+	{as: AANDCC, a1: C_REG, a2: C_REG, a6: C_REG, type_: 6, size: 4},
+	{as: AANDCC, a1: C_REG, a6: C_REG, type_: 6, size: 4},
+	{as: AANDCC, a1: C_ANDCON, a6: C_REG, type_: 58, size: 4},
+	{as: AANDCC, a1: C_ANDCON, a2: C_REG, a6: C_REG, type_: 58, size: 4},
+	{as: AANDCC, a1: C_UCON, a6: C_REG, type_: 59, size: 4},
+	{as: AANDCC, a1: C_UCON, a2: C_REG, a6: C_REG, type_: 59, size: 4},
+	{as: AANDCC, a1: C_ADDCON, a6: C_REG, type_: 23, size: 8},
+	{as: AANDCC, a1: C_ADDCON, a2: C_REG, a6: C_REG, type_: 23, size: 8},
+	{as: AANDCC, a1: C_LCON, a6: C_REG, type_: 23, size: 12},
+	{as: AANDCC, a1: C_LCON, a2: C_REG, a6: C_REG, type_: 23, size: 12},
+	{as: AANDISCC, a1: C_ANDCON, a6: C_REG, type_: 59, size: 4},
+	{as: AANDISCC, a1: C_ANDCON, a2: C_REG, a6: C_REG, type_: 59, size: 4},
+	{as: AMULLW, a1: C_REG, a2: C_REG, a6: C_REG, type_: 2, size: 4},
+	{as: AMULLW, a1: C_REG, a6: C_REG, type_: 2, size: 4},
+	{as: AMULLW, a1: C_ADDCON, a2: C_REG, a6: C_REG, type_: 4, size: 4},
+	{as: AMULLW, a1: C_ADDCON, a6: C_REG, type_: 4, size: 4},
+	{as: AMULLW, a1: C_ANDCON, a2: C_REG, a6: C_REG, type_: 4, size: 4},
+	{as: AMULLW, a1: C_ANDCON, a6: C_REG, type_: 4, size: 4},
+	{as: AMULLW, a1: C_LCON, a2: C_REG, a6: C_REG, type_: 22, size: 12},
+	{as: AMULLW, a1: C_LCON, a6: C_REG, type_: 22, size: 12},
+	{as: ASUBC, a1: C_REG, a2: C_REG, a6: C_REG, type_: 10, size: 4},
+	{as: ASUBC, a1: C_REG, a6: C_REG, type_: 10, size: 4},
+	{as: ASUBC, a1: C_REG, a3: C_ADDCON, a6: C_REG, type_: 27, size: 4},
+	{as: ASUBC, a1: C_REG, a3: C_LCON, a6: C_REG, type_: 28, size: 12},
+	{as: AOR, a1: C_REG, a2: C_REG, a6: C_REG, type_: 6, size: 4}, /* logical, literal not cc (or/xor) */
+	{as: AOR, a1: C_REG, a6: C_REG, type_: 6, size: 4},
+	{as: AOR, a1: C_ANDCON, a6: C_REG, type_: 58, size: 4},
+	{as: AOR, a1: C_ANDCON, a2: C_REG, a6: C_REG, type_: 58, size: 4},
+	{as: AOR, a1: C_UCON, a6: C_REG, type_: 59, size: 4},
+	{as: AOR, a1: C_UCON, a2: C_REG, a6: C_REG, type_: 59, size: 4},
+	{as: AOR, a1: C_ADDCON, a6: C_REG, type_: 23, size: 8},
+	{as: AOR, a1: C_ADDCON, a2: C_REG, a6: C_REG, type_: 23, size: 8},
+	{as: AOR, a1: C_LCON, a6: C_REG, type_: 23, size: 12},
+	{as: AOR, a1: C_LCON, a2: C_REG, a6: C_REG, type_: 23, size: 12},
+	{as: AORIS, a1: C_ANDCON, a6: C_REG, type_: 59, size: 4},
+	{as: AORIS, a1: C_ANDCON, a2: C_REG, a6: C_REG, type_: 59, size: 4},
+	{as: ADIVW, a1: C_REG, a2: C_REG, a6: C_REG, type_: 2, size: 4}, /* op r1[,r2],r3 */
+	{as: ADIVW, a1: C_REG, a6: C_REG, type_: 2, size: 4},
+	{as: ASUB, a1: C_REG, a2: C_REG, a6: C_REG, type_: 10, size: 4}, /* op r2[,r1],r3 */
+	{as: ASUB, a1: C_REG, a6: C_REG, type_: 10, size: 4},
+	{as: ASLW, a1: C_REG, a6: C_REG, type_: 6, size: 4},
+	{as: ASLW, a1: C_REG, a2: C_REG, a6: C_REG, type_: 6, size: 4},
+	{as: ASLD, a1: C_REG, a6: C_REG, type_: 6, size: 4},
+	{as: ASLD, a1: C_REG, a2: C_REG, a6: C_REG, type_: 6, size: 4},
+	{as: ASLD, a1: C_SCON, a2: C_REG, a6: C_REG, type_: 25, size: 4},
+	{as: ASLD, a1: C_SCON, a6: C_REG, type_: 25, size: 4},
+	{as: AEXTSWSLI, a1: C_SCON, a6: C_REG, type_: 25, size: 4},
+	{as: AEXTSWSLI, a1: C_SCON, a2: C_REG, a6: C_REG, type_: 25, size: 4},
+	{as: ASLW, a1: C_SCON, a2: C_REG, a6: C_REG, type_: 57, size: 4},
+	{as: ASLW, a1: C_SCON, a6: C_REG, type_: 57, size: 4},
+	{as: ASRAW, a1: C_REG, a6: C_REG, type_: 6, size: 4},
+	{as: ASRAW, a1: C_REG, a2: C_REG, a6: C_REG, type_: 6, size: 4},
+	{as: ASRAW, a1: C_SCON, a2: C_REG, a6: C_REG, type_: 56, size: 4},
+	{as: ASRAW, a1: C_SCON, a6: C_REG, type_: 56, size: 4},
+	{as: ASRAD, a1: C_REG, a6: C_REG, type_: 6, size: 4},
+	{as: ASRAD, a1: C_REG, a2: C_REG, a6: C_REG, type_: 6, size: 4},
+	{as: ASRAD, a1: C_SCON, a2: C_REG, a6: C_REG, type_: 56, size: 4},
+	{as: ASRAD, a1: C_SCON, a6: C_REG, type_: 56, size: 4},
+	{as: ARLWMI, a1: C_SCON, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 62, size: 4},
+	{as: ARLWMI, a1: C_REG, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 63, size: 4},
+	{as: ACLRLSLWI, a1: C_SCON, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 62, size: 4},
+	{as: ARLDMI, a1: C_SCON, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 30, size: 4},
+	{as: ARLDC, a1: C_SCON, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 29, size: 4},
+	{as: ARLDCL, a1: C_SCON, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 29, size: 4},
+	{as: ARLDCL, a1: C_REG, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 14, size: 4},
+	{as: ARLDICL, a1: C_REG, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 14, size: 4},
+	{as: ARLDICL, a1: C_SCON, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 14, size: 4},
+	{as: ARLDCL, a1: C_REG, a3: C_LCON, a6: C_REG, type_: 14, size: 4},
+	{as: AFADD, a1: C_FREG, a6: C_FREG, type_: 2, size: 4},
+	{as: AFADD, a1: C_FREG, a2: C_FREG, a6: C_FREG, type_: 2, size: 4},
+	{as: AFABS, a1: C_FREG, a6: C_FREG, type_: 33, size: 4},
+	{as: AFABS, a6: C_FREG, type_: 33, size: 4},
+	{as: AFMOVD, a1: C_FREG, a6: C_FREG, type_: 33, size: 4},
+	{as: AFMADD, a1: C_FREG, a2: C_FREG, a3: C_FREG, a6: C_FREG, type_: 34, size: 4},
+	{as: AFMUL, a1: C_FREG, a6: C_FREG, type_: 32, size: 4},
+	{as: AFMUL, a1: C_FREG, a2: C_FREG, a6: C_FREG, type_: 32, size: 4},
 
 	/* store, short offset */
-	{as: AMOVD, a1: C_REG, a2: C_REG, a4: C_ZOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVW, a1: C_REG, a2: C_REG, a4: C_ZOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVWZ, a1: C_REG, a2: C_REG, a4: C_ZOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVBZ, a1: C_REG, a2: C_REG, a4: C_ZOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVBZU, a1: C_REG, a2: C_REG, a4: C_ZOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVB, a1: C_REG, a2: C_REG, a4: C_ZOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVBU, a1: C_REG, a2: C_REG, a4: C_ZOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVD, a1: C_REG, a4: C_SEXT, type_: 7, size: 4, param: REGSB},
-	{as: AMOVW, a1: C_REG, a4: C_SEXT, type_: 7, size: 4, param: REGSB},
-	{as: AMOVWZ, a1: C_REG, a4: C_SEXT, type_: 7, size: 4, param: REGSB},
-	{as: AMOVBZ, a1: C_REG, a4: C_SEXT, type_: 7, size: 4, param: REGSB},
-	{as: AMOVB, a1: C_REG, a4: C_SEXT, type_: 7, size: 4, param: REGSB},
-	{as: AMOVD, a1: C_REG, a4: C_SAUTO, type_: 7, size: 4, param: REGSP},
-	{as: AMOVW, a1: C_REG, a4: C_SAUTO, type_: 7, size: 4, param: REGSP},
-	{as: AMOVWZ, a1: C_REG, a4: C_SAUTO, type_: 7, size: 4, param: REGSP},
-	{as: AMOVBZ, a1: C_REG, a4: C_SAUTO, type_: 7, size: 4, param: REGSP},
-	{as: AMOVB, a1: C_REG, a4: C_SAUTO, type_: 7, size: 4, param: REGSP},
-	{as: AMOVD, a1: C_REG, a4: C_SOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVW, a1: C_REG, a4: C_SOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVWZ, a1: C_REG, a4: C_SOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVBZ, a1: C_REG, a4: C_SOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVBZU, a1: C_REG, a4: C_SOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVB, a1: C_REG, a4: C_SOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVBU, a1: C_REG, a4: C_SOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVD, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVW, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVWZ, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVBZ, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVBZU, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVB, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVBU, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVD, a1: C_REG, a6: C_SEXT, type_: 7, size: 4, param: REGSB},
+	{as: AMOVW, a1: C_REG, a6: C_SEXT, type_: 7, size: 4, param: REGSB},
+	{as: AMOVWZ, a1: C_REG, a6: C_SEXT, type_: 7, size: 4, param: REGSB},
+	{as: AMOVBZ, a1: C_REG, a6: C_SEXT, type_: 7, size: 4, param: REGSB},
+	{as: AMOVB, a1: C_REG, a6: C_SEXT, type_: 7, size: 4, param: REGSB},
+	{as: AMOVD, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4, param: REGSP},
+	{as: AMOVW, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4, param: REGSP},
+	{as: AMOVWZ, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4, param: REGSP},
+	{as: AMOVBZ, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4, param: REGSP},
+	{as: AMOVB, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4, param: REGSP},
+	{as: AMOVD, a1: C_REG, a6: C_SOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVW, a1: C_REG, a6: C_SOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVWZ, a1: C_REG, a6: C_SOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVBZ, a1: C_REG, a6: C_SOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVBZU, a1: C_REG, a6: C_SOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVB, a1: C_REG, a6: C_SOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVBU, a1: C_REG, a6: C_SOREG, type_: 7, size: 4, param: REGZERO},
 
 	/* load, short offset */
-	{as: AMOVD, a1: C_ZOREG, a2: C_REG, a4: C_REG, type_: 8, size: 4, param: REGZERO},
-	{as: AMOVW, a1: C_ZOREG, a2: C_REG, a4: C_REG, type_: 8, size: 4, param: REGZERO},
-	{as: AMOVWZ, a1: C_ZOREG, a2: C_REG, a4: C_REG, type_: 8, size: 4, param: REGZERO},
-	{as: AMOVBZ, a1: C_ZOREG, a2: C_REG, a4: C_REG, type_: 8, size: 4, param: REGZERO},
-	{as: AMOVBZU, a1: C_ZOREG, a2: C_REG, a4: C_REG, type_: 8, size: 4, param: REGZERO},
-	{as: AMOVB, a1: C_ZOREG, a2: C_REG, a4: C_REG, type_: 9, size: 8, param: REGZERO},
-	{as: AMOVBU, a1: C_ZOREG, a2: C_REG, a4: C_REG, type_: 9, size: 8, param: REGZERO},
-	{as: AMOVD, a1: C_SEXT, a4: C_REG, type_: 8, size: 4, param: REGSB},
-	{as: AMOVW, a1: C_SEXT, a4: C_REG, type_: 8, size: 4, param: REGSB},
-	{as: AMOVWZ, a1: C_SEXT, a4: C_REG, type_: 8, size: 4, param: REGSB},
-	{as: AMOVBZ, a1: C_SEXT, a4: C_REG, type_: 8, size: 4, param: REGSB},
-	{as: AMOVB, a1: C_SEXT, a4: C_REG, type_: 9, size: 8, param: REGSB},
-	{as: AMOVD, a1: C_SAUTO, a4: C_REG, type_: 8, size: 4, param: REGSP},
-	{as: AMOVW, a1: C_SAUTO, a4: C_REG, type_: 8, size: 4, param: REGSP},
-	{as: AMOVWZ, a1: C_SAUTO, a4: C_REG, type_: 8, size: 4, param: REGSP},
-	{as: AMOVBZ, a1: C_SAUTO, a4: C_REG, type_: 8, size: 4, param: REGSP},
-	{as: AMOVB, a1: C_SAUTO, a4: C_REG, type_: 9, size: 8, param: REGSP},
-	{as: AMOVD, a1: C_SOREG, a4: C_REG, type_: 8, size: 4, param: REGZERO},
-	{as: AMOVW, a1: C_SOREG, a4: C_REG, type_: 8, size: 4, param: REGZERO},
-	{as: AMOVWZ, a1: C_SOREG, a4: C_REG, type_: 8, size: 4, param: REGZERO},
-	{as: AMOVBZ, a1: C_SOREG, a4: C_REG, type_: 8, size: 4, param: REGZERO},
-	{as: AMOVBZU, a1: C_SOREG, a4: C_REG, type_: 8, size: 4, param: REGZERO},
-	{as: AMOVB, a1: C_SOREG, a4: C_REG, type_: 9, size: 8, param: REGZERO},
-	{as: AMOVBU, a1: C_SOREG, a4: C_REG, type_: 9, size: 8, param: REGZERO},
+	{as: AMOVD, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4, param: REGZERO},
+	{as: AMOVW, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4, param: REGZERO},
+	{as: AMOVWZ, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4, param: REGZERO},
+	{as: AMOVBZ, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4, param: REGZERO},
+	{as: AMOVBZU, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4, param: REGZERO},
+	{as: AMOVB, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 9, size: 8, param: REGZERO},
+	{as: AMOVBU, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 9, size: 8, param: REGZERO},
+	{as: AMOVD, a1: C_SEXT, a6: C_REG, type_: 8, size: 4, param: REGSB},
+	{as: AMOVW, a1: C_SEXT, a6: C_REG, type_: 8, size: 4, param: REGSB},
+	{as: AMOVWZ, a1: C_SEXT, a6: C_REG, type_: 8, size: 4, param: REGSB},
+	{as: AMOVBZ, a1: C_SEXT, a6: C_REG, type_: 8, size: 4, param: REGSB},
+	{as: AMOVB, a1: C_SEXT, a6: C_REG, type_: 9, size: 8, param: REGSB},
+	{as: AMOVD, a1: C_SAUTO, a6: C_REG, type_: 8, size: 4, param: REGSP},
+	{as: AMOVW, a1: C_SAUTO, a6: C_REG, type_: 8, size: 4, param: REGSP},
+	{as: AMOVWZ, a1: C_SAUTO, a6: C_REG, type_: 8, size: 4, param: REGSP},
+	{as: AMOVBZ, a1: C_SAUTO, a6: C_REG, type_: 8, size: 4, param: REGSP},
+	{as: AMOVB, a1: C_SAUTO, a6: C_REG, type_: 9, size: 8, param: REGSP},
+	{as: AMOVD, a1: C_SOREG, a6: C_REG, type_: 8, size: 4, param: REGZERO},
+	{as: AMOVW, a1: C_SOREG, a6: C_REG, type_: 8, size: 4, param: REGZERO},
+	{as: AMOVWZ, a1: C_SOREG, a6: C_REG, type_: 8, size: 4, param: REGZERO},
+	{as: AMOVBZ, a1: C_SOREG, a6: C_REG, type_: 8, size: 4, param: REGZERO},
+	{as: AMOVBZU, a1: C_SOREG, a6: C_REG, type_: 8, size: 4, param: REGZERO},
+	{as: AMOVB, a1: C_SOREG, a6: C_REG, type_: 9, size: 8, param: REGZERO},
+	{as: AMOVBU, a1: C_SOREG, a6: C_REG, type_: 9, size: 8, param: REGZERO},
 
 	/* store, long offset */
-	{as: AMOVD, a1: C_REG, a4: C_LEXT, type_: 35, size: 8, param: REGSB},
-	{as: AMOVW, a1: C_REG, a4: C_LEXT, type_: 35, size: 8, param: REGSB},
-	{as: AMOVWZ, a1: C_REG, a4: C_LEXT, type_: 35, size: 8, param: REGSB},
-	{as: AMOVBZ, a1: C_REG, a4: C_LEXT, type_: 35, size: 8, param: REGSB},
-	{as: AMOVB, a1: C_REG, a4: C_LEXT, type_: 35, size: 8, param: REGSB},
-	{as: AMOVD, a1: C_REG, a4: C_LAUTO, type_: 35, size: 8, param: REGSP},
-	{as: AMOVW, a1: C_REG, a4: C_LAUTO, type_: 35, size: 8, param: REGSP},
-	{as: AMOVWZ, a1: C_REG, a4: C_LAUTO, type_: 35, size: 8, param: REGSP},
-	{as: AMOVBZ, a1: C_REG, a4: C_LAUTO, type_: 35, size: 8, param: REGSP},
-	{as: AMOVB, a1: C_REG, a4: C_LAUTO, type_: 35, size: 8, param: REGSP},
-	{as: AMOVD, a1: C_REG, a4: C_LOREG, type_: 35, size: 8, param: REGZERO},
-	{as: AMOVW, a1: C_REG, a4: C_LOREG, type_: 35, size: 8, param: REGZERO},
-	{as: AMOVWZ, a1: C_REG, a4: C_LOREG, type_: 35, size: 8, param: REGZERO},
-	{as: AMOVBZ, a1: C_REG, a4: C_LOREG, type_: 35, size: 8, param: REGZERO},
-	{as: AMOVB, a1: C_REG, a4: C_LOREG, type_: 35, size: 8, param: REGZERO},
-	{as: AMOVD, a1: C_REG, a4: C_ADDR, type_: 74, size: 8},
-	{as: AMOVW, a1: C_REG, a4: C_ADDR, type_: 74, size: 8},
-	{as: AMOVWZ, a1: C_REG, a4: C_ADDR, type_: 74, size: 8},
-	{as: AMOVBZ, a1: C_REG, a4: C_ADDR, type_: 74, size: 8},
-	{as: AMOVB, a1: C_REG, a4: C_ADDR, type_: 74, size: 8},
+	{as: AMOVD, a1: C_REG, a6: C_LEXT, type_: 35, size: 8, param: REGSB},
+	{as: AMOVW, a1: C_REG, a6: C_LEXT, type_: 35, size: 8, param: REGSB},
+	{as: AMOVWZ, a1: C_REG, a6: C_LEXT, type_: 35, size: 8, param: REGSB},
+	{as: AMOVBZ, a1: C_REG, a6: C_LEXT, type_: 35, size: 8, param: REGSB},
+	{as: AMOVB, a1: C_REG, a6: C_LEXT, type_: 35, size: 8, param: REGSB},
+	{as: AMOVD, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8, param: REGSP},
+	{as: AMOVW, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8, param: REGSP},
+	{as: AMOVWZ, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8, param: REGSP},
+	{as: AMOVBZ, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8, param: REGSP},
+	{as: AMOVB, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8, param: REGSP},
+	{as: AMOVD, a1: C_REG, a6: C_LOREG, type_: 35, size: 8, param: REGZERO},
+	{as: AMOVW, a1: C_REG, a6: C_LOREG, type_: 35, size: 8, param: REGZERO},
+	{as: AMOVWZ, a1: C_REG, a6: C_LOREG, type_: 35, size: 8, param: REGZERO},
+	{as: AMOVBZ, a1: C_REG, a6: C_LOREG, type_: 35, size: 8, param: REGZERO},
+	{as: AMOVB, a1: C_REG, a6: C_LOREG, type_: 35, size: 8, param: REGZERO},
+	{as: AMOVD, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
+	{as: AMOVW, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
+	{as: AMOVWZ, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
+	{as: AMOVBZ, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
+	{as: AMOVB, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 
 	/* load, long offset */
-	{as: AMOVD, a1: C_LEXT, a4: C_REG, type_: 36, size: 8, param: REGSB},
-	{as: AMOVW, a1: C_LEXT, a4: C_REG, type_: 36, size: 8, param: REGSB},
-	{as: AMOVWZ, a1: C_LEXT, a4: C_REG, type_: 36, size: 8, param: REGSB},
-	{as: AMOVBZ, a1: C_LEXT, a4: C_REG, type_: 36, size: 8, param: REGSB},
-	{as: AMOVB, a1: C_LEXT, a4: C_REG, type_: 37, size: 12, param: REGSB},
-	{as: AMOVD, a1: C_LAUTO, a4: C_REG, type_: 36, size: 8, param: REGSP},
-	{as: AMOVW, a1: C_LAUTO, a4: C_REG, type_: 36, size: 8, param: REGSP},
-	{as: AMOVWZ, a1: C_LAUTO, a4: C_REG, type_: 36, size: 8, param: REGSP},
-	{as: AMOVBZ, a1: C_LAUTO, a4: C_REG, type_: 36, size: 8, param: REGSP},
-	{as: AMOVB, a1: C_LAUTO, a4: C_REG, type_: 37, size: 12, param: REGSP},
-	{as: AMOVD, a1: C_LOREG, a4: C_REG, type_: 36, size: 8, param: REGZERO},
-	{as: AMOVW, a1: C_LOREG, a4: C_REG, type_: 36, size: 8, param: REGZERO},
-	{as: AMOVWZ, a1: C_LOREG, a4: C_REG, type_: 36, size: 8, param: REGZERO},
-	{as: AMOVBZ, a1: C_LOREG, a4: C_REG, type_: 36, size: 8, param: REGZERO},
-	{as: AMOVB, a1: C_LOREG, a4: C_REG, type_: 37, size: 12, param: REGZERO},
-	{as: AMOVD, a1: C_ADDR, a4: C_REG, type_: 75, size: 8},
-	{as: AMOVW, a1: C_ADDR, a4: C_REG, type_: 75, size: 8},
-	{as: AMOVWZ, a1: C_ADDR, a4: C_REG, type_: 75, size: 8},
-	{as: AMOVBZ, a1: C_ADDR, a4: C_REG, type_: 75, size: 8},
-	{as: AMOVB, a1: C_ADDR, a4: C_REG, type_: 76, size: 12},
-
-	{as: AMOVD, a1: C_TLS_LE, a4: C_REG, type_: 79, size: 4},
-	{as: AMOVD, a1: C_TLS_IE, a4: C_REG, type_: 80, size: 8},
-
-	{as: AMOVD, a1: C_GOTADDR, a4: C_REG, type_: 81, size: 8},
-	{as: AMOVD, a1: C_TOCADDR, a4: C_REG, type_: 95, size: 8},
+	{as: AMOVD, a1: C_LEXT, a6: C_REG, type_: 36, size: 8, param: REGSB},
+	{as: AMOVW, a1: C_LEXT, a6: C_REG, type_: 36, size: 8, param: REGSB},
+	{as: AMOVWZ, a1: C_LEXT, a6: C_REG, type_: 36, size: 8, param: REGSB},
+	{as: AMOVBZ, a1: C_LEXT, a6: C_REG, type_: 36, size: 8, param: REGSB},
+	{as: AMOVB, a1: C_LEXT, a6: C_REG, type_: 37, size: 12, param: REGSB},
+	{as: AMOVD, a1: C_LAUTO, a6: C_REG, type_: 36, size: 8, param: REGSP},
+	{as: AMOVW, a1: C_LAUTO, a6: C_REG, type_: 36, size: 8, param: REGSP},
+	{as: AMOVWZ, a1: C_LAUTO, a6: C_REG, type_: 36, size: 8, param: REGSP},
+	{as: AMOVBZ, a1: C_LAUTO, a6: C_REG, type_: 36, size: 8, param: REGSP},
+	{as: AMOVB, a1: C_LAUTO, a6: C_REG, type_: 37, size: 12, param: REGSP},
+	{as: AMOVD, a1: C_LOREG, a6: C_REG, type_: 36, size: 8, param: REGZERO},
+	{as: AMOVW, a1: C_LOREG, a6: C_REG, type_: 36, size: 8, param: REGZERO},
+	{as: AMOVWZ, a1: C_LOREG, a6: C_REG, type_: 36, size: 8, param: REGZERO},
+	{as: AMOVBZ, a1: C_LOREG, a6: C_REG, type_: 36, size: 8, param: REGZERO},
+	{as: AMOVB, a1: C_LOREG, a6: C_REG, type_: 37, size: 12, param: REGZERO},
+	{as: AMOVD, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
+	{as: AMOVW, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
+	{as: AMOVWZ, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
+	{as: AMOVBZ, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
+	{as: AMOVB, a1: C_ADDR, a6: C_REG, type_: 76, size: 12},
+
+	{as: AMOVD, a1: C_TLS_LE, a6: C_REG, type_: 79, size: 4},
+	{as: AMOVD, a1: C_TLS_IE, a6: C_REG, type_: 80, size: 8},
+
+	{as: AMOVD, a1: C_GOTADDR, a6: C_REG, type_: 81, size: 8},
+	{as: AMOVD, a1: C_TOCADDR, a6: C_REG, type_: 95, size: 8},
 
 	/* load constant */
-	{as: AMOVD, a1: C_SECON, a4: C_REG, type_: 3, size: 4, param: REGSB},
-	{as: AMOVD, a1: C_SACON, a4: C_REG, type_: 3, size: 4, param: REGSP},
-	{as: AMOVD, a1: C_LECON, a4: C_REG, type_: 26, size: 8, param: REGSB},
-	{as: AMOVD, a1: C_LACON, a4: C_REG, type_: 26, size: 8, param: REGSP},
-	{as: AMOVD, a1: C_ADDCON, a4: C_REG, type_: 3, size: 4, param: REGZERO},
-	{as: AMOVD, a1: C_ANDCON, a4: C_REG, type_: 3, size: 4, param: REGZERO},
-	{as: AMOVW, a1: C_SECON, a4: C_REG, type_: 3, size: 4, param: REGSB}, /* TO DO: check */
-	{as: AMOVW, a1: C_SACON, a4: C_REG, type_: 3, size: 4, param: REGSP},
-	{as: AMOVW, a1: C_LECON, a4: C_REG, type_: 26, size: 8, param: REGSB},
-	{as: AMOVW, a1: C_LACON, a4: C_REG, type_: 26, size: 8, param: REGSP},
-	{as: AMOVW, a1: C_ADDCON, a4: C_REG, type_: 3, size: 4, param: REGZERO},
-	{as: AMOVW, a1: C_ANDCON, a4: C_REG, type_: 3, size: 4, param: REGZERO},
-	{as: AMOVWZ, a1: C_SECON, a4: C_REG, type_: 3, size: 4, param: REGSB}, /* TO DO: check */
-	{as: AMOVWZ, a1: C_SACON, a4: C_REG, type_: 3, size: 4, param: REGSP},
-	{as: AMOVWZ, a1: C_LECON, a4: C_REG, type_: 26, size: 8, param: REGSB},
-	{as: AMOVWZ, a1: C_LACON, a4: C_REG, type_: 26, size: 8, param: REGSP},
-	{as: AMOVWZ, a1: C_ADDCON, a4: C_REG, type_: 3, size: 4, param: REGZERO},
-	{as: AMOVWZ, a1: C_ANDCON, a4: C_REG, type_: 3, size: 4, param: REGZERO},
+	{as: AMOVD, a1: C_SECON, a6: C_REG, type_: 3, size: 4, param: REGSB},
+	{as: AMOVD, a1: C_SACON, a6: C_REG, type_: 3, size: 4, param: REGSP},
+	{as: AMOVD, a1: C_LECON, a6: C_REG, type_: 26, size: 8, param: REGSB},
+	{as: AMOVD, a1: C_LACON, a6: C_REG, type_: 26, size: 8, param: REGSP},
+	{as: AMOVD, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4, param: REGZERO},
+	{as: AMOVD, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4, param: REGZERO},
+	{as: AMOVW, a1: C_SECON, a6: C_REG, type_: 3, size: 4, param: REGSB}, /* TO DO: check */
+	{as: AMOVW, a1: C_SACON, a6: C_REG, type_: 3, size: 4, param: REGSP},
+	{as: AMOVW, a1: C_LECON, a6: C_REG, type_: 26, size: 8, param: REGSB},
+	{as: AMOVW, a1: C_LACON, a6: C_REG, type_: 26, size: 8, param: REGSP},
+	{as: AMOVW, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4, param: REGZERO},
+	{as: AMOVW, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4, param: REGZERO},
+	{as: AMOVWZ, a1: C_SECON, a6: C_REG, type_: 3, size: 4, param: REGSB}, /* TO DO: check */
+	{as: AMOVWZ, a1: C_SACON, a6: C_REG, type_: 3, size: 4, param: REGSP},
+	{as: AMOVWZ, a1: C_LECON, a6: C_REG, type_: 26, size: 8, param: REGSB},
+	{as: AMOVWZ, a1: C_LACON, a6: C_REG, type_: 26, size: 8, param: REGSP},
+	{as: AMOVWZ, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4, param: REGZERO},
+	{as: AMOVWZ, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4, param: REGZERO},
 
 	/* load unsigned/long constants (TO DO: check) */
-	{as: AMOVD, a1: C_UCON, a4: C_REG, type_: 3, size: 4, param: REGZERO},
-	{as: AMOVD, a1: C_LCON, a4: C_REG, type_: 19, size: 8},
-	{as: AMOVW, a1: C_UCON, a4: C_REG, type_: 3, size: 4, param: REGZERO},
-	{as: AMOVW, a1: C_LCON, a4: C_REG, type_: 19, size: 8},
-	{as: AMOVWZ, a1: C_UCON, a4: C_REG, type_: 3, size: 4, param: REGZERO},
-	{as: AMOVWZ, a1: C_LCON, a4: C_REG, type_: 19, size: 8},
-	{as: AMOVHBR, a1: C_ZOREG, a2: C_REG, a4: C_REG, type_: 45, size: 4},
-	{as: AMOVHBR, a1: C_ZOREG, a4: C_REG, type_: 45, size: 4},
-	{as: AMOVHBR, a1: C_REG, a2: C_REG, a4: C_ZOREG, type_: 44, size: 4},
-	{as: AMOVHBR, a1: C_REG, a4: C_ZOREG, type_: 44, size: 4},
+	{as: AMOVD, a1: C_UCON, a6: C_REG, type_: 3, size: 4, param: REGZERO},
+	{as: AMOVD, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
+	{as: AMOVW, a1: C_UCON, a6: C_REG, type_: 3, size: 4, param: REGZERO},
+	{as: AMOVW, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
+	{as: AMOVWZ, a1: C_UCON, a6: C_REG, type_: 3, size: 4, param: REGZERO},
+	{as: AMOVWZ, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
+	{as: AMOVHBR, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 45, size: 4},
+	{as: AMOVHBR, a1: C_ZOREG, a6: C_REG, type_: 45, size: 4},
+	{as: AMOVHBR, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 44, size: 4},
+	{as: AMOVHBR, a1: C_REG, a6: C_ZOREG, type_: 44, size: 4},
 	{as: ASYSCALL, type_: 5, size: 4},
 	{as: ASYSCALL, a1: C_REG, type_: 77, size: 12},
 	{as: ASYSCALL, a1: C_SCON, type_: 77, size: 12},
-	{as: ABEQ, a4: C_SBRA, type_: 16, size: 4},
-	{as: ABEQ, a1: C_CREG, a4: C_SBRA, type_: 16, size: 4},
-	{as: ABR, a4: C_LBRA, type_: 11, size: 4},
-	{as: ABR, a4: C_LBRAPIC, type_: 11, size: 8},
-	{as: ABC, a1: C_SCON, a2: C_REG, a4: C_SBRA, type_: 16, size: 4},
-	{as: ABC, a1: C_SCON, a2: C_REG, a4: C_LBRA, type_: 17, size: 4},
-	{as: ABR, a4: C_LR, type_: 18, size: 4},
-	{as: ABR, a3: C_SCON, a4: C_LR, type_: 18, size: 4},
-	{as: ABR, a4: C_CTR, type_: 18, size: 4},
-	{as: ABR, a1: C_REG, a4: C_CTR, type_: 18, size: 4},
-	{as: ABR, a4: C_ZOREG, type_: 15, size: 8},
-	{as: ABC, a2: C_REG, a4: C_LR, type_: 18, size: 4},
-	{as: ABC, a2: C_REG, a4: C_CTR, type_: 18, size: 4},
-	{as: ABC, a1: C_SCON, a2: C_REG, a4: C_LR, type_: 18, size: 4},
-	{as: ABC, a1: C_SCON, a2: C_REG, a4: C_CTR, type_: 18, size: 4},
-	{as: ABC, a4: C_ZOREG, type_: 15, size: 8},
-	{as: AFMOVD, a1: C_SEXT, a4: C_FREG, type_: 8, size: 4, param: REGSB},
-	{as: AFMOVD, a1: C_SAUTO, a4: C_FREG, type_: 8, size: 4, param: REGSP},
-	{as: AFMOVD, a1: C_SOREG, a4: C_FREG, type_: 8, size: 4, param: REGZERO},
-	{as: AFMOVD, a1: C_LEXT, a4: C_FREG, type_: 36, size: 8, param: REGSB},
-	{as: AFMOVD, a1: C_LAUTO, a4: C_FREG, type_: 36, size: 8, param: REGSP},
-	{as: AFMOVD, a1: C_LOREG, a4: C_FREG, type_: 36, size: 8, param: REGZERO},
-	{as: AFMOVD, a1: C_ZCON, a4: C_FREG, type_: 24, size: 4},
-	{as: AFMOVD, a1: C_ADDCON, a4: C_FREG, type_: 24, size: 8},
-	{as: AFMOVD, a1: C_ADDR, a4: C_FREG, type_: 75, size: 8},
-	{as: AFMOVD, a1: C_FREG, a4: C_SEXT, type_: 7, size: 4, param: REGSB},
-	{as: AFMOVD, a1: C_FREG, a4: C_SAUTO, type_: 7, size: 4, param: REGSP},
-	{as: AFMOVD, a1: C_FREG, a4: C_SOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AFMOVD, a1: C_FREG, a4: C_LEXT, type_: 35, size: 8, param: REGSB},
-	{as: AFMOVD, a1: C_FREG, a4: C_LAUTO, type_: 35, size: 8, param: REGSP},
-	{as: AFMOVD, a1: C_FREG, a4: C_LOREG, type_: 35, size: 8, param: REGZERO},
-	{as: AFMOVD, a1: C_FREG, a4: C_ADDR, type_: 74, size: 8},
-	{as: AFMOVSX, a1: C_ZOREG, a2: C_REG, a4: C_FREG, type_: 45, size: 4},
-	{as: AFMOVSX, a1: C_ZOREG, a4: C_FREG, type_: 45, size: 4},
-	{as: AFMOVSX, a1: C_FREG, a2: C_REG, a4: C_ZOREG, type_: 44, size: 4},
-	{as: AFMOVSX, a1: C_FREG, a4: C_ZOREG, type_: 44, size: 4},
-	{as: AFMOVSZ, a1: C_ZOREG, a2: C_REG, a4: C_FREG, type_: 45, size: 4},
-	{as: AFMOVSZ, a1: C_ZOREG, a4: C_FREG, type_: 45, size: 4},
+	{as: ABEQ, a6: C_SBRA, type_: 16, size: 4},
+	{as: ABEQ, a1: C_CREG, a6: C_SBRA, type_: 16, size: 4},
+	{as: ABR, a6: C_LBRA, type_: 11, size: 4},
+	{as: ABR, a6: C_LBRAPIC, type_: 11, size: 8},
+	{as: ABC, a1: C_SCON, a2: C_REG, a6: C_SBRA, type_: 16, size: 4},
+	{as: ABC, a1: C_SCON, a2: C_REG, a6: C_LBRA, type_: 17, size: 4},
+	{as: ABR, a6: C_LR, type_: 18, size: 4},
+	{as: ABR, a3: C_SCON, a6: C_LR, type_: 18, size: 4},
+	{as: ABR, a6: C_CTR, type_: 18, size: 4},
+	{as: ABR, a1: C_REG, a6: C_CTR, type_: 18, size: 4},
+	{as: ABR, a6: C_ZOREG, type_: 15, size: 8},
+	{as: ABC, a2: C_REG, a6: C_LR, type_: 18, size: 4},
+	{as: ABC, a2: C_REG, a6: C_CTR, type_: 18, size: 4},
+	{as: ABC, a1: C_SCON, a2: C_REG, a6: C_LR, type_: 18, size: 4},
+	{as: ABC, a1: C_SCON, a2: C_REG, a6: C_CTR, type_: 18, size: 4},
+	{as: ABC, a6: C_ZOREG, type_: 15, size: 8},
+	{as: AFMOVD, a1: C_SEXT, a6: C_FREG, type_: 8, size: 4, param: REGSB},
+	{as: AFMOVD, a1: C_SAUTO, a6: C_FREG, type_: 8, size: 4, param: REGSP},
+	{as: AFMOVD, a1: C_SOREG, a6: C_FREG, type_: 8, size: 4, param: REGZERO},
+	{as: AFMOVD, a1: C_LEXT, a6: C_FREG, type_: 36, size: 8, param: REGSB},
+	{as: AFMOVD, a1: C_LAUTO, a6: C_FREG, type_: 36, size: 8, param: REGSP},
+	{as: AFMOVD, a1: C_LOREG, a6: C_FREG, type_: 36, size: 8, param: REGZERO},
+	{as: AFMOVD, a1: C_ZCON, a6: C_FREG, type_: 24, size: 4},
+	{as: AFMOVD, a1: C_ADDCON, a6: C_FREG, type_: 24, size: 8},
+	{as: AFMOVD, a1: C_ADDR, a6: C_FREG, type_: 75, size: 8},
+	{as: AFMOVD, a1: C_FREG, a6: C_SEXT, type_: 7, size: 4, param: REGSB},
+	{as: AFMOVD, a1: C_FREG, a6: C_SAUTO, type_: 7, size: 4, param: REGSP},
+	{as: AFMOVD, a1: C_FREG, a6: C_SOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AFMOVD, a1: C_FREG, a6: C_LEXT, type_: 35, size: 8, param: REGSB},
+	{as: AFMOVD, a1: C_FREG, a6: C_LAUTO, type_: 35, size: 8, param: REGSP},
+	{as: AFMOVD, a1: C_FREG, a6: C_LOREG, type_: 35, size: 8, param: REGZERO},
+	{as: AFMOVD, a1: C_FREG, a6: C_ADDR, type_: 74, size: 8},
+	{as: AFMOVSX, a1: C_ZOREG, a2: C_REG, a6: C_FREG, type_: 45, size: 4},
+	{as: AFMOVSX, a1: C_ZOREG, a6: C_FREG, type_: 45, size: 4},
+	{as: AFMOVSX, a1: C_FREG, a2: C_REG, a6: C_ZOREG, type_: 44, size: 4},
+	{as: AFMOVSX, a1: C_FREG, a6: C_ZOREG, type_: 44, size: 4},
+	{as: AFMOVSZ, a1: C_ZOREG, a2: C_REG, a6: C_FREG, type_: 45, size: 4},
+	{as: AFMOVSZ, a1: C_ZOREG, a6: C_FREG, type_: 45, size: 4},
 	{as: ASYNC, type_: 46, size: 4},
 	{as: AWORD, a1: C_LCON, type_: 40, size: 4},
 	{as: ADWORD, a1: C_LCON, type_: 31, size: 8},
 	{as: ADWORD, a1: C_DCON, type_: 31, size: 8},
-	{as: AADDME, a1: C_REG, a4: C_REG, type_: 47, size: 4},
-	{as: AEXTSB, a1: C_REG, a4: C_REG, type_: 48, size: 4},
-	{as: AEXTSB, a4: C_REG, type_: 48, size: 4},
-	{as: AISEL, a1: C_LCON, a2: C_REG, a3: C_REG, a4: C_REG, type_: 84, size: 4},
-	{as: AISEL, a1: C_ZCON, a2: C_REG, a3: C_REG, a4: C_REG, type_: 84, size: 4},
-	{as: ANEG, a1: C_REG, a4: C_REG, type_: 47, size: 4},
-	{as: ANEG, a4: C_REG, type_: 47, size: 4},
-	{as: AREM, a1: C_REG, a4: C_REG, type_: 50, size: 12},
-	{as: AREM, a1: C_REG, a2: C_REG, a4: C_REG, type_: 50, size: 12},
-	{as: AREMU, a1: C_REG, a4: C_REG, type_: 50, size: 16},
-	{as: AREMU, a1: C_REG, a2: C_REG, a4: C_REG, type_: 50, size: 16},
-	{as: AREMD, a1: C_REG, a4: C_REG, type_: 51, size: 12},
-	{as: AREMD, a1: C_REG, a2: C_REG, a4: C_REG, type_: 51, size: 12},
+	{as: AADDME, a1: C_REG, a6: C_REG, type_: 47, size: 4},
+	{as: AEXTSB, a1: C_REG, a6: C_REG, type_: 48, size: 4},
+	{as: AEXTSB, a6: C_REG, type_: 48, size: 4},
+	{as: AISEL, a1: C_LCON, a2: C_REG, a3: C_REG, a6: C_REG, type_: 84, size: 4},
+	{as: AISEL, a1: C_ZCON, a2: C_REG, a3: C_REG, a6: C_REG, type_: 84, size: 4},
+	{as: ANEG, a1: C_REG, a6: C_REG, type_: 47, size: 4},
+	{as: ANEG, a6: C_REG, type_: 47, size: 4},
+	{as: AREM, a1: C_REG, a6: C_REG, type_: 50, size: 12},
+	{as: AREM, a1: C_REG, a2: C_REG, a6: C_REG, type_: 50, size: 12},
+	{as: AREMU, a1: C_REG, a6: C_REG, type_: 50, size: 16},
+	{as: AREMU, a1: C_REG, a2: C_REG, a6: C_REG, type_: 50, size: 16},
+	{as: AREMD, a1: C_REG, a6: C_REG, type_: 51, size: 12},
+	{as: AREMD, a1: C_REG, a2: C_REG, a6: C_REG, type_: 51, size: 12},
 	{as: AMTFSB0, a1: C_SCON, type_: 52, size: 4},
-	{as: AMOVFL, a1: C_FPSCR, a4: C_FREG, type_: 53, size: 4},
-	{as: AMOVFL, a1: C_FREG, a4: C_FPSCR, type_: 64, size: 4},
-	{as: AMOVFL, a1: C_FREG, a3: C_LCON, a4: C_FPSCR, type_: 64, size: 4},
-	{as: AMOVFL, a1: C_LCON, a4: C_FPSCR, type_: 65, size: 4},
-	{as: AMOVD, a1: C_MSR, a4: C_REG, type_: 54, size: 4},  /* mfmsr */
-	{as: AMOVD, a1: C_REG, a4: C_MSR, type_: 54, size: 4},  /* mtmsrd */
-	{as: AMOVWZ, a1: C_REG, a4: C_MSR, type_: 54, size: 4}, /* mtmsr */
+	{as: AMOVFL, a1: C_FPSCR, a6: C_FREG, type_: 53, size: 4},
+	{as: AMOVFL, a1: C_FREG, a6: C_FPSCR, type_: 64, size: 4},
+	{as: AMOVFL, a1: C_FREG, a3: C_LCON, a6: C_FPSCR, type_: 64, size: 4},
+	{as: AMOVFL, a1: C_LCON, a6: C_FPSCR, type_: 65, size: 4},
+	{as: AMOVD, a1: C_MSR, a6: C_REG, type_: 54, size: 4},  /* mfmsr */
+	{as: AMOVD, a1: C_REG, a6: C_MSR, type_: 54, size: 4},  /* mtmsrd */
+	{as: AMOVWZ, a1: C_REG, a6: C_MSR, type_: 54, size: 4}, /* mtmsr */
 
 	/* Other ISA 2.05+ instructions */
-	{as: APOPCNTD, a1: C_REG, a4: C_REG, type_: 93, size: 4},            /* population count, x-form */
-	{as: ACMPB, a1: C_REG, a2: C_REG, a4: C_REG, type_: 92, size: 4},    /* compare byte, x-form */
-	{as: ACMPEQB, a1: C_REG, a2: C_REG, a4: C_CREG, type_: 92, size: 4}, /* compare equal byte, x-form, ISA 3.0 */
-	{as: ACMPEQB, a1: C_REG, a4: C_REG, type_: 70, size: 4},
-	{as: AFTDIV, a1: C_FREG, a2: C_FREG, a4: C_SCON, type_: 92, size: 4},          /* floating test for sw divide, x-form */
-	{as: AFTSQRT, a1: C_FREG, a4: C_SCON, type_: 93, size: 4},                     /* floating test for sw square root, x-form */
-	{as: ACOPY, a1: C_REG, a4: C_REG, type_: 92, size: 4},                         /* copy/paste facility, x-form */
-	{as: ADARN, a1: C_SCON, a4: C_REG, type_: 92, size: 4},                        /* deliver random number, x-form */
-	{as: ALDMX, a1: C_SOREG, a4: C_REG, type_: 45, size: 4},                       /* load doubleword monitored, x-form */
-	{as: AMADDHD, a1: C_REG, a2: C_REG, a3: C_REG, a4: C_REG, type_: 83, size: 4}, /* multiply-add high/low doubleword, va-form */
-	{as: AADDEX, a1: C_REG, a2: C_REG, a3: C_SCON, a4: C_REG, type_: 94, size: 4}, /* add extended using alternate carry, z23-form */
-	{as: ACRAND, a1: C_CREG, a4: C_CREG, type_: 2, size: 4},                       /* logical ops for condition registers xl-form */
+	{as: APOPCNTD, a1: C_REG, a6: C_REG, type_: 93, size: 4},            /* population count, x-form */
+	{as: ACMPB, a1: C_REG, a2: C_REG, a6: C_REG, type_: 92, size: 4},    /* compare byte, x-form */
+	{as: ACMPEQB, a1: C_REG, a2: C_REG, a6: C_CREG, type_: 92, size: 4}, /* compare equal byte, x-form, ISA 3.0 */
+	{as: ACMPEQB, a1: C_REG, a6: C_REG, type_: 70, size: 4},
+	{as: AFTDIV, a1: C_FREG, a2: C_FREG, a6: C_SCON, type_: 92, size: 4},          /* floating test for sw divide, x-form */
+	{as: AFTSQRT, a1: C_FREG, a6: C_SCON, type_: 93, size: 4},                     /* floating test for sw square root, x-form */
+	{as: ACOPY, a1: C_REG, a6: C_REG, type_: 92, size: 4},                         /* copy/paste facility, x-form */
+	{as: ADARN, a1: C_SCON, a6: C_REG, type_: 92, size: 4},                        /* deliver random number, x-form */
+	{as: ALDMX, a1: C_SOREG, a6: C_REG, type_: 45, size: 4},                       /* load doubleword monitored, x-form */
+	{as: AMADDHD, a1: C_REG, a2: C_REG, a3: C_REG, a6: C_REG, type_: 83, size: 4}, /* multiply-add high/low doubleword, va-form */
+	{as: AADDEX, a1: C_REG, a2: C_REG, a3: C_SCON, a6: C_REG, type_: 94, size: 4}, /* add extended using alternate carry, z23-form */
+	{as: ACRAND, a1: C_CREG, a6: C_CREG, type_: 2, size: 4},                       /* logical ops for condition registers xl-form */
 
 	/* Vector instructions */
 
 	/* Vector load */
-	{as: ALV, a1: C_SOREG, a4: C_VREG, type_: 45, size: 4}, /* vector load, x-form */
+	{as: ALV, a1: C_SOREG, a6: C_VREG, type_: 45, size: 4}, /* vector load, x-form */
 
 	/* Vector store */
-	{as: ASTV, a1: C_VREG, a4: C_SOREG, type_: 44, size: 4}, /* vector store, x-form */
+	{as: ASTV, a1: C_VREG, a6: C_SOREG, type_: 44, size: 4}, /* vector store, x-form */
 
 	/* Vector logical */
-	{as: AVAND, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4}, /* vector and, vx-form */
-	{as: AVOR, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},  /* vector or, vx-form */
+	{as: AVAND, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4}, /* vector and, vx-form */
+	{as: AVOR, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},  /* vector or, vx-form */
 
 	/* Vector add */
-	{as: AVADDUM, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},            /* vector add unsigned modulo, vx-form */
-	{as: AVADDCU, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},            /* vector add & write carry unsigned, vx-form */
-	{as: AVADDUS, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},            /* vector add unsigned saturate, vx-form */
-	{as: AVADDSS, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},            /* vector add signed saturate, vx-form */
-	{as: AVADDE, a1: C_VREG, a2: C_VREG, a3: C_VREG, a4: C_VREG, type_: 83, size: 4}, /* vector add extended, va-form */
+	{as: AVADDUM, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},            /* vector add unsigned modulo, vx-form */
+	{as: AVADDCU, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},            /* vector add & write carry unsigned, vx-form */
+	{as: AVADDUS, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},            /* vector add unsigned saturate, vx-form */
+	{as: AVADDSS, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},            /* vector add signed saturate, vx-form */
+	{as: AVADDE, a1: C_VREG, a2: C_VREG, a3: C_VREG, a6: C_VREG, type_: 83, size: 4}, /* vector add extended, va-form */
 
 	/* Vector subtract */
-	{as: AVSUBUM, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},            /* vector subtract unsigned modulo, vx-form */
-	{as: AVSUBCU, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},            /* vector subtract & write carry unsigned, vx-form */
-	{as: AVSUBUS, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},            /* vector subtract unsigned saturate, vx-form */
-	{as: AVSUBSS, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},            /* vector subtract signed saturate, vx-form */
-	{as: AVSUBE, a1: C_VREG, a2: C_VREG, a3: C_VREG, a4: C_VREG, type_: 83, size: 4}, /* vector subtract extended, va-form */
+	{as: AVSUBUM, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},            /* vector subtract unsigned modulo, vx-form */
+	{as: AVSUBCU, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},            /* vector subtract & write carry unsigned, vx-form */
+	{as: AVSUBUS, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},            /* vector subtract unsigned saturate, vx-form */
+	{as: AVSUBSS, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},            /* vector subtract signed saturate, vx-form */
+	{as: AVSUBE, a1: C_VREG, a2: C_VREG, a3: C_VREG, a6: C_VREG, type_: 83, size: 4}, /* vector subtract extended, va-form */
 
 	/* Vector multiply */
-	{as: AVMULESB, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4, param: 9},    /* vector multiply, vx-form */
-	{as: AVPMSUM, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},               /* vector polynomial multiply & sum, vx-form */
-	{as: AVMSUMUDM, a1: C_VREG, a2: C_VREG, a3: C_VREG, a4: C_VREG, type_: 83, size: 4}, /* vector multiply-sum, va-form */
+	{as: AVMULESB, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4, param: 9},    /* vector multiply, vx-form */
+	{as: AVPMSUM, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},               /* vector polynomial multiply & sum, vx-form */
+	{as: AVMSUMUDM, a1: C_VREG, a2: C_VREG, a3: C_VREG, a6: C_VREG, type_: 83, size: 4}, /* vector multiply-sum, va-form */
 
 	/* Vector rotate */
-	{as: AVR, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4}, /* vector rotate, vx-form */
+	{as: AVR, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4}, /* vector rotate, vx-form */
 
 	/* Vector shift */
-	{as: AVS, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},                 /* vector shift, vx-form */
-	{as: AVSA, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},                /* vector shift algebraic, vx-form */
-	{as: AVSOI, a1: C_ANDCON, a2: C_VREG, a3: C_VREG, a4: C_VREG, type_: 83, size: 4}, /* vector shift by octet immediate, va-form */
+	{as: AVS, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},                 /* vector shift, vx-form */
+	{as: AVSA, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},                /* vector shift algebraic, vx-form */
+	{as: AVSOI, a1: C_ANDCON, a2: C_VREG, a3: C_VREG, a6: C_VREG, type_: 83, size: 4}, /* vector shift by octet immediate, va-form */
 
 	/* Vector count */
-	{as: AVCLZ, a1: C_VREG, a4: C_VREG, type_: 85, size: 4},    /* vector count leading zeros, vx-form */
-	{as: AVPOPCNT, a1: C_VREG, a4: C_VREG, type_: 85, size: 4}, /* vector population count, vx-form */
+	{as: AVCLZ, a1: C_VREG, a6: C_VREG, type_: 85, size: 4},    /* vector count leading zeros, vx-form */
+	{as: AVPOPCNT, a1: C_VREG, a6: C_VREG, type_: 85, size: 4}, /* vector population count, vx-form */
 
 	/* Vector compare */
-	{as: AVCMPEQ, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},   /* vector compare equal, vc-form */
-	{as: AVCMPGT, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},   /* vector compare greater than, vc-form */
-	{as: AVCMPNEZB, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4}, /* vector compare not equal, vx-form */
+	{as: AVCMPEQ, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},   /* vector compare equal, vc-form */
+	{as: AVCMPGT, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},   /* vector compare greater than, vc-form */
+	{as: AVCMPNEZB, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4}, /* vector compare not equal, vx-form */
 
 	/* Vector merge */
-	{as: AVMRGOW, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4}, /* vector merge odd word, vx-form */
+	{as: AVMRGOW, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4}, /* vector merge odd word, vx-form */
 
 	/* Vector permute */
-	{as: AVPERM, a1: C_VREG, a2: C_VREG, a3: C_VREG, a4: C_VREG, type_: 83, size: 4}, /* vector permute, va-form */
+	{as: AVPERM, a1: C_VREG, a2: C_VREG, a3: C_VREG, a6: C_VREG, type_: 83, size: 4}, /* vector permute, va-form */
 
 	/* Vector bit permute */
-	{as: AVBPERMQ, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4}, /* vector bit permute, vx-form */
+	{as: AVBPERMQ, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4}, /* vector bit permute, vx-form */
 
 	/* Vector select */
-	{as: AVSEL, a1: C_VREG, a2: C_VREG, a3: C_VREG, a4: C_VREG, type_: 83, size: 4}, /* vector select, va-form */
+	{as: AVSEL, a1: C_VREG, a2: C_VREG, a3: C_VREG, a6: C_VREG, type_: 83, size: 4}, /* vector select, va-form */
 
 	/* Vector splat */
-	{as: AVSPLTB, a1: C_SCON, a2: C_VREG, a4: C_VREG, type_: 82, size: 4}, /* vector splat, vx-form */
-	{as: AVSPLTB, a1: C_ADDCON, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},
-	{as: AVSPLTISB, a1: C_SCON, a4: C_VREG, type_: 82, size: 4}, /* vector splat immediate, vx-form */
-	{as: AVSPLTISB, a1: C_ADDCON, a4: C_VREG, type_: 82, size: 4},
+	{as: AVSPLTB, a1: C_SCON, a2: C_VREG, a6: C_VREG, type_: 82, size: 4}, /* vector splat, vx-form */
+	{as: AVSPLTB, a1: C_ADDCON, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},
+	{as: AVSPLTISB, a1: C_SCON, a6: C_VREG, type_: 82, size: 4}, /* vector splat immediate, vx-form */
+	{as: AVSPLTISB, a1: C_ADDCON, a6: C_VREG, type_: 82, size: 4},
 
 	/* Vector AES */
-	{as: AVCIPH, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4},  /* vector AES cipher, vx-form */
-	{as: AVNCIPH, a1: C_VREG, a2: C_VREG, a4: C_VREG, type_: 82, size: 4}, /* vector AES inverse cipher, vx-form */
-	{as: AVSBOX, a1: C_VREG, a4: C_VREG, type_: 82, size: 4},              /* vector AES subbytes, vx-form */
+	{as: AVCIPH, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},  /* vector AES cipher, vx-form */
+	{as: AVNCIPH, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4}, /* vector AES inverse cipher, vx-form */
+	{as: AVSBOX, a1: C_VREG, a6: C_VREG, type_: 82, size: 4},              /* vector AES subbytes, vx-form */
 
 	/* Vector SHA */
-	{as: AVSHASIGMA, a1: C_ANDCON, a2: C_VREG, a3: C_ANDCON, a4: C_VREG, type_: 82, size: 4}, /* vector SHA sigma, vx-form */
+	{as: AVSHASIGMA, a1: C_ANDCON, a2: C_VREG, a3: C_ANDCON, a6: C_VREG, type_: 82, size: 4}, /* vector SHA sigma, vx-form */
 
 	/* VSX vector load */
-	{as: ALXVD2X, a1: C_SOREG, a4: C_VSREG, type_: 87, size: 4},        /* vsx vector load, xx1-form */
-	{as: ALXV, a1: C_SOREG, a4: C_VSREG, type_: 96, size: 4},           /* vsx vector load, dq-form */
-	{as: ALXVL, a1: C_REG, a2: C_REG, a4: C_VSREG, type_: 98, size: 4}, /* vsx vector load length */
+	{as: ALXVD2X, a1: C_SOREG, a6: C_VSREG, type_: 87, size: 4},        /* vsx vector load, xx1-form */
+	{as: ALXV, a1: C_SOREG, a6: C_VSREG, type_: 96, size: 4},           /* vsx vector load, dq-form */
+	{as: ALXVL, a1: C_REG, a2: C_REG, a6: C_VSREG, type_: 98, size: 4}, /* vsx vector load length */
 
 	/* VSX vector store */
-	{as: ASTXVD2X, a1: C_VSREG, a4: C_SOREG, type_: 86, size: 4},        /* vsx vector store, xx1-form */
-	{as: ASTXV, a1: C_VSREG, a4: C_SOREG, type_: 97, size: 4},           /* vsx vector store, dq-form */
-	{as: ASTXVL, a1: C_VSREG, a2: C_REG, a4: C_REG, type_: 99, size: 4}, /* vsx vector store with length x-form */
+	{as: ASTXVD2X, a1: C_VSREG, a6: C_SOREG, type_: 86, size: 4},        /* vsx vector store, xx1-form */
+	{as: ASTXV, a1: C_VSREG, a6: C_SOREG, type_: 97, size: 4},           /* vsx vector store, dq-form */
+	{as: ASTXVL, a1: C_VSREG, a2: C_REG, a6: C_REG, type_: 99, size: 4}, /* vsx vector store with length x-form */
 
 	/* VSX scalar load */
-	{as: ALXSDX, a1: C_SOREG, a4: C_VSREG, type_: 87, size: 4}, /* vsx scalar load, xx1-form */
+	{as: ALXSDX, a1: C_SOREG, a6: C_VSREG, type_: 87, size: 4}, /* vsx scalar load, xx1-form */
 
 	/* VSX scalar store */
-	{as: ASTXSDX, a1: C_VSREG, a4: C_SOREG, type_: 86, size: 4}, /* vsx scalar store, xx1-form */
+	{as: ASTXSDX, a1: C_VSREG, a6: C_SOREG, type_: 86, size: 4}, /* vsx scalar store, xx1-form */
 
 	/* VSX scalar as integer load */
-	{as: ALXSIWAX, a1: C_SOREG, a4: C_VSREG, type_: 87, size: 4}, /* vsx scalar as integer load, xx1-form */
+	{as: ALXSIWAX, a1: C_SOREG, a6: C_VSREG, type_: 87, size: 4}, /* vsx scalar as integer load, xx1-form */
 
 	/* VSX scalar store as integer */
-	{as: ASTXSIWX, a1: C_VSREG, a4: C_SOREG, type_: 86, size: 4}, /* vsx scalar as integer store, xx1-form */
+	{as: ASTXSIWX, a1: C_VSREG, a6: C_SOREG, type_: 86, size: 4}, /* vsx scalar as integer store, xx1-form */
 
 	/* VSX move from VSR */
-	{as: AMFVSRD, a1: C_VSREG, a4: C_REG, type_: 88, size: 4}, /* vsx move from vsr, xx1-form */
-	{as: AMFVSRD, a1: C_FREG, a4: C_REG, type_: 88, size: 4},
-	{as: AMFVSRD, a1: C_VREG, a4: C_REG, type_: 88, size: 4},
+	{as: AMFVSRD, a1: C_VSREG, a6: C_REG, type_: 88, size: 4}, /* vsx move from vsr, xx1-form */
+	{as: AMFVSRD, a1: C_FREG, a6: C_REG, type_: 88, size: 4},
+	{as: AMFVSRD, a1: C_VREG, a6: C_REG, type_: 88, size: 4},
 
 	/* VSX move to VSR */
-	{as: AMTVSRD, a1: C_REG, a4: C_VSREG, type_: 88, size: 4}, /* vsx move to vsr, xx1-form */
-	{as: AMTVSRD, a1: C_REG, a2: C_REG, a4: C_VSREG, type_: 88, size: 4},
-	{as: AMTVSRD, a1: C_REG, a4: C_FREG, type_: 88, size: 4},
-	{as: AMTVSRD, a1: C_REG, a4: C_VREG, type_: 88, size: 4},
+	{as: AMTVSRD, a1: C_REG, a6: C_VSREG, type_: 88, size: 4}, /* vsx move to vsr, xx1-form */
+	{as: AMTVSRD, a1: C_REG, a2: C_REG, a6: C_VSREG, type_: 88, size: 4},
+	{as: AMTVSRD, a1: C_REG, a6: C_FREG, type_: 88, size: 4},
+	{as: AMTVSRD, a1: C_REG, a6: C_VREG, type_: 88, size: 4},
 
 	/* VSX logical */
-	{as: AXXLAND, a1: C_VSREG, a2: C_VSREG, a4: C_VSREG, type_: 90, size: 4}, /* vsx and, xx3-form */
-	{as: AXXLOR, a1: C_VSREG, a2: C_VSREG, a4: C_VSREG, type_: 90, size: 4},  /* vsx or, xx3-form */
+	{as: AXXLAND, a1: C_VSREG, a2: C_VSREG, a6: C_VSREG, type_: 90, size: 4}, /* vsx and, xx3-form */
+	{as: AXXLOR, a1: C_VSREG, a2: C_VSREG, a6: C_VSREG, type_: 90, size: 4},  /* vsx or, xx3-form */
 
 	/* VSX select */
-	{as: AXXSEL, a1: C_VSREG, a2: C_VSREG, a3: C_VSREG, a4: C_VSREG, type_: 91, size: 4}, /* vsx select, xx4-form */
+	{as: AXXSEL, a1: C_VSREG, a2: C_VSREG, a3: C_VSREG, a6: C_VSREG, type_: 91, size: 4}, /* vsx select, xx4-form */
 
 	/* VSX merge */
-	{as: AXXMRGHW, a1: C_VSREG, a2: C_VSREG, a4: C_VSREG, type_: 90, size: 4}, /* vsx merge, xx3-form */
+	{as: AXXMRGHW, a1: C_VSREG, a2: C_VSREG, a6: C_VSREG, type_: 90, size: 4}, /* vsx merge, xx3-form */
 
 	/* VSX splat */
-	{as: AXXSPLTW, a1: C_VSREG, a3: C_SCON, a4: C_VSREG, type_: 89, size: 4}, /* vsx splat, xx2-form */
-	{as: AXXSPLTIB, a1: C_SCON, a4: C_VSREG, type_: 100, size: 4},            /* vsx splat, xx2-form */
+	{as: AXXSPLTW, a1: C_VSREG, a3: C_SCON, a6: C_VSREG, type_: 89, size: 4}, /* vsx splat, xx2-form */
+	{as: AXXSPLTIB, a1: C_SCON, a6: C_VSREG, type_: 100, size: 4},            /* vsx splat, xx2-form */
 
 	/* VSX permute */
-	{as: AXXPERM, a1: C_VSREG, a2: C_VSREG, a4: C_VSREG, type_: 90, size: 4}, /* vsx permute, xx3-form */
+	{as: AXXPERM, a1: C_VSREG, a2: C_VSREG, a6: C_VSREG, type_: 90, size: 4}, /* vsx permute, xx3-form */
 
 	/* VSX shift */
-	{as: AXXSLDWI, a1: C_VSREG, a2: C_VSREG, a3: C_SCON, a4: C_VSREG, type_: 90, size: 4}, /* vsx shift immediate, xx3-form */
+	{as: AXXSLDWI, a1: C_VSREG, a2: C_VSREG, a3: C_SCON, a6: C_VSREG, type_: 90, size: 4}, /* vsx shift immediate, xx3-form */
 
 	/* VSX reverse bytes */
-	{as: AXXBRQ, a1: C_VSREG, a4: C_VSREG, type_: 101, size: 4}, /* vsx reverse bytes */
+	{as: AXXBRQ, a1: C_VSREG, a6: C_VSREG, type_: 101, size: 4}, /* vsx reverse bytes */
 
 	/* VSX scalar FP-FP conversion */
-	{as: AXSCVDPSP, a1: C_VSREG, a4: C_VSREG, type_: 89, size: 4}, /* vsx scalar fp-fp conversion, xx2-form */
+	{as: AXSCVDPSP, a1: C_VSREG, a6: C_VSREG, type_: 89, size: 4}, /* vsx scalar fp-fp conversion, xx2-form */
 
 	/* VSX vector FP-FP conversion */
-	{as: AXVCVDPSP, a1: C_VSREG, a4: C_VSREG, type_: 89, size: 4}, /* vsx vector fp-fp conversion, xx2-form */
+	{as: AXVCVDPSP, a1: C_VSREG, a6: C_VSREG, type_: 89, size: 4}, /* vsx vector fp-fp conversion, xx2-form */
 
 	/* VSX scalar FP-integer conversion */
-	{as: AXSCVDPSXDS, a1: C_VSREG, a4: C_VSREG, type_: 89, size: 4}, /* vsx scalar fp-integer conversion, xx2-form */
+	{as: AXSCVDPSXDS, a1: C_VSREG, a6: C_VSREG, type_: 89, size: 4}, /* vsx scalar fp-integer conversion, xx2-form */
 
 	/* VSX scalar integer-FP conversion */
-	{as: AXSCVSXDDP, a1: C_VSREG, a4: C_VSREG, type_: 89, size: 4}, /* vsx scalar integer-fp conversion, xx2-form */
+	{as: AXSCVSXDDP, a1: C_VSREG, a6: C_VSREG, type_: 89, size: 4}, /* vsx scalar integer-fp conversion, xx2-form */
 
 	/* VSX vector FP-integer conversion */
-	{as: AXVCVDPSXDS, a1: C_VSREG, a4: C_VSREG, type_: 89, size: 4}, /* vsx vector fp-integer conversion, xx2-form */
+	{as: AXVCVDPSXDS, a1: C_VSREG, a6: C_VSREG, type_: 89, size: 4}, /* vsx vector fp-integer conversion, xx2-form */
 
 	/* VSX vector integer-FP conversion */
-	{as: AXVCVSXDDP, a1: C_VSREG, a4: C_VSREG, type_: 89, size: 4}, /* vsx vector integer-fp conversion, xx2-form */
+	{as: AXVCVSXDDP, a1: C_VSREG, a6: C_VSREG, type_: 89, size: 4}, /* vsx vector integer-fp conversion, xx2-form */
 
 	/* 64-bit special registers */
-	{as: AMOVD, a1: C_REG, a4: C_SPR, type_: 66, size: 4},
-	{as: AMOVD, a1: C_REG, a4: C_LR, type_: 66, size: 4},
-	{as: AMOVD, a1: C_REG, a4: C_CTR, type_: 66, size: 4},
-	{as: AMOVD, a1: C_REG, a4: C_XER, type_: 66, size: 4},
-	{as: AMOVD, a1: C_SPR, a4: C_REG, type_: 66, size: 4},
-	{as: AMOVD, a1: C_LR, a4: C_REG, type_: 66, size: 4},
-	{as: AMOVD, a1: C_CTR, a4: C_REG, type_: 66, size: 4},
-	{as: AMOVD, a1: C_XER, a4: C_REG, type_: 66, size: 4},
+	{as: AMOVD, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
+	{as: AMOVD, a1: C_REG, a6: C_LR, type_: 66, size: 4},
+	{as: AMOVD, a1: C_REG, a6: C_CTR, type_: 66, size: 4},
+	{as: AMOVD, a1: C_REG, a6: C_XER, type_: 66, size: 4},
+	{as: AMOVD, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
+	{as: AMOVD, a1: C_LR, a6: C_REG, type_: 66, size: 4},
+	{as: AMOVD, a1: C_CTR, a6: C_REG, type_: 66, size: 4},
+	{as: AMOVD, a1: C_XER, a6: C_REG, type_: 66, size: 4},
 
 	/* 32-bit special registers (gloss over sign-extension or not?) */
-	{as: AMOVW, a1: C_REG, a4: C_SPR, type_: 66, size: 4},
-	{as: AMOVW, a1: C_REG, a4: C_CTR, type_: 66, size: 4},
-	{as: AMOVW, a1: C_REG, a4: C_XER, type_: 66, size: 4},
-	{as: AMOVW, a1: C_SPR, a4: C_REG, type_: 66, size: 4},
-	{as: AMOVW, a1: C_XER, a4: C_REG, type_: 66, size: 4},
-	{as: AMOVWZ, a1: C_REG, a4: C_SPR, type_: 66, size: 4},
-	{as: AMOVWZ, a1: C_REG, a4: C_CTR, type_: 66, size: 4},
-	{as: AMOVWZ, a1: C_REG, a4: C_XER, type_: 66, size: 4},
-	{as: AMOVWZ, a1: C_SPR, a4: C_REG, type_: 66, size: 4},
-	{as: AMOVWZ, a1: C_XER, a4: C_REG, type_: 66, size: 4},
-	{as: AMOVFL, a1: C_FPSCR, a4: C_CREG, type_: 73, size: 4},
-	{as: AMOVFL, a1: C_CREG, a4: C_CREG, type_: 67, size: 4},
-	{as: AMOVW, a1: C_CREG, a4: C_REG, type_: 68, size: 4},
-	{as: AMOVWZ, a1: C_CREG, a4: C_REG, type_: 68, size: 4},
-	{as: AMOVFL, a1: C_REG, a4: C_LCON, type_: 69, size: 4},
-	{as: AMOVFL, a1: C_REG, a4: C_CREG, type_: 69, size: 4},
-	{as: AMOVW, a1: C_REG, a4: C_CREG, type_: 69, size: 4},
-	{as: AMOVWZ, a1: C_REG, a4: C_CREG, type_: 69, size: 4},
-	{as: ACMP, a1: C_REG, a4: C_REG, type_: 70, size: 4},
-	{as: ACMP, a1: C_REG, a2: C_REG, a4: C_REG, type_: 70, size: 4},
-	{as: ACMP, a1: C_REG, a4: C_ADDCON, type_: 71, size: 4},
-	{as: ACMP, a1: C_REG, a2: C_REG, a4: C_ADDCON, type_: 71, size: 4},
-	{as: ACMPU, a1: C_REG, a4: C_REG, type_: 70, size: 4},
-	{as: ACMPU, a1: C_REG, a2: C_REG, a4: C_REG, type_: 70, size: 4},
-	{as: ACMPU, a1: C_REG, a4: C_ANDCON, type_: 71, size: 4},
-	{as: ACMPU, a1: C_REG, a2: C_REG, a4: C_ANDCON, type_: 71, size: 4},
-	{as: AFCMPO, a1: C_FREG, a4: C_FREG, type_: 70, size: 4},
-	{as: AFCMPO, a1: C_FREG, a2: C_REG, a4: C_FREG, type_: 70, size: 4},
-	{as: ATW, a1: C_LCON, a2: C_REG, a4: C_REG, type_: 60, size: 4},
-	{as: ATW, a1: C_LCON, a2: C_REG, a4: C_ADDCON, type_: 61, size: 4},
+	{as: AMOVW, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
+	{as: AMOVW, a1: C_REG, a6: C_CTR, type_: 66, size: 4},
+	{as: AMOVW, a1: C_REG, a6: C_XER, type_: 66, size: 4},
+	{as: AMOVW, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
+	{as: AMOVW, a1: C_XER, a6: C_REG, type_: 66, size: 4},
+	{as: AMOVWZ, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
+	{as: AMOVWZ, a1: C_REG, a6: C_CTR, type_: 66, size: 4},
+	{as: AMOVWZ, a1: C_REG, a6: C_XER, type_: 66, size: 4},
+	{as: AMOVWZ, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
+	{as: AMOVWZ, a1: C_XER, a6: C_REG, type_: 66, size: 4},
+	{as: AMOVFL, a1: C_FPSCR, a6: C_CREG, type_: 73, size: 4},
+	{as: AMOVFL, a1: C_CREG, a6: C_CREG, type_: 67, size: 4},
+	{as: AMOVW, a1: C_CREG, a6: C_REG, type_: 68, size: 4},
+	{as: AMOVWZ, a1: C_CREG, a6: C_REG, type_: 68, size: 4},
+	{as: AMOVFL, a1: C_REG, a6: C_LCON, type_: 69, size: 4},
+	{as: AMOVFL, a1: C_REG, a6: C_CREG, type_: 69, size: 4},
+	{as: AMOVW, a1: C_REG, a6: C_CREG, type_: 69, size: 4},
+	{as: AMOVWZ, a1: C_REG, a6: C_CREG, type_: 69, size: 4},
+	{as: ACMP, a1: C_REG, a6: C_REG, type_: 70, size: 4},
+	{as: ACMP, a1: C_REG, a2: C_REG, a6: C_REG, type_: 70, size: 4},
+	{as: ACMP, a1: C_REG, a6: C_ADDCON, type_: 71, size: 4},
+	{as: ACMP, a1: C_REG, a2: C_REG, a6: C_ADDCON, type_: 71, size: 4},
+	{as: ACMPU, a1: C_REG, a6: C_REG, type_: 70, size: 4},
+	{as: ACMPU, a1: C_REG, a2: C_REG, a6: C_REG, type_: 70, size: 4},
+	{as: ACMPU, a1: C_REG, a6: C_ANDCON, type_: 71, size: 4},
+	{as: ACMPU, a1: C_REG, a2: C_REG, a6: C_ANDCON, type_: 71, size: 4},
+	{as: AFCMPO, a1: C_FREG, a6: C_FREG, type_: 70, size: 4},
+	{as: AFCMPO, a1: C_FREG, a2: C_REG, a6: C_FREG, type_: 70, size: 4},
+	{as: ATW, a1: C_LCON, a2: C_REG, a6: C_REG, type_: 60, size: 4},
+	{as: ATW, a1: C_LCON, a2: C_REG, a6: C_ADDCON, type_: 61, size: 4},
 	{as: ADCBF, a1: C_ZOREG, type_: 43, size: 4},
 	{as: ADCBF, a1: C_SOREG, type_: 43, size: 4},
-	{as: ADCBF, a1: C_ZOREG, a2: C_REG, a4: C_SCON, type_: 43, size: 4},
-	{as: ADCBF, a1: C_SOREG, a4: C_SCON, type_: 43, size: 4},
-	{as: AECOWX, a1: C_REG, a2: C_REG, a4: C_ZOREG, type_: 44, size: 4},
-	{as: AECIWX, a1: C_ZOREG, a2: C_REG, a4: C_REG, type_: 45, size: 4},
-	{as: AECOWX, a1: C_REG, a4: C_ZOREG, type_: 44, size: 4},
-	{as: AECIWX, a1: C_ZOREG, a4: C_REG, type_: 45, size: 4},
-	{as: ALDAR, a1: C_ZOREG, a4: C_REG, type_: 45, size: 4},
-	{as: ALDAR, a1: C_ZOREG, a3: C_ANDCON, a4: C_REG, type_: 45, size: 4},
+	{as: ADCBF, a1: C_ZOREG, a2: C_REG, a6: C_SCON, type_: 43, size: 4},
+	{as: ADCBF, a1: C_SOREG, a6: C_SCON, type_: 43, size: 4},
+	{as: AECOWX, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 44, size: 4},
+	{as: AECIWX, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 45, size: 4},
+	{as: AECOWX, a1: C_REG, a6: C_ZOREG, type_: 44, size: 4},
+	{as: AECIWX, a1: C_ZOREG, a6: C_REG, type_: 45, size: 4},
+	{as: ALDAR, a1: C_ZOREG, a6: C_REG, type_: 45, size: 4},
+	{as: ALDAR, a1: C_ZOREG, a3: C_ANDCON, a6: C_REG, type_: 45, size: 4},
 	{as: AEIEIO, type_: 46, size: 4},
 	{as: ATLBIE, a1: C_REG, type_: 49, size: 4},
-	{as: ATLBIE, a1: C_SCON, a4: C_REG, type_: 49, size: 4},
-	{as: ASLBMFEE, a1: C_REG, a4: C_REG, type_: 55, size: 4},
-	{as: ASLBMTE, a1: C_REG, a4: C_REG, type_: 55, size: 4},
-	{as: ASTSW, a1: C_REG, a4: C_ZOREG, type_: 44, size: 4},
-	{as: ASTSW, a1: C_REG, a3: C_LCON, a4: C_ZOREG, type_: 41, size: 4},
-	{as: ALSW, a1: C_ZOREG, a4: C_REG, type_: 45, size: 4},
-	{as: ALSW, a1: C_ZOREG, a3: C_LCON, a4: C_REG, type_: 42, size: 4},
+	{as: ATLBIE, a1: C_SCON, a6: C_REG, type_: 49, size: 4},
+	{as: ASLBMFEE, a1: C_REG, a6: C_REG, type_: 55, size: 4},
+	{as: ASLBMTE, a1: C_REG, a6: C_REG, type_: 55, size: 4},
+	{as: ASTSW, a1: C_REG, a6: C_ZOREG, type_: 44, size: 4},
+	{as: ASTSW, a1: C_REG, a3: C_LCON, a6: C_ZOREG, type_: 41, size: 4},
+	{as: ALSW, a1: C_ZOREG, a6: C_REG, type_: 45, size: 4},
+	{as: ALSW, a1: C_ZOREG, a3: C_LCON, a6: C_REG, type_: 42, size: 4},
 	{as: obj.AUNDEF, type_: 78, size: 4},
-	{as: obj.APCDATA, a1: C_LCON, a4: C_LCON, type_: 0, size: 0},
-	{as: obj.AFUNCDATA, a1: C_SCON, a4: C_ADDR, type_: 0, size: 0},
+	{as: obj.APCDATA, a1: C_LCON, a6: C_LCON, type_: 0, size: 0},
+	{as: obj.AFUNCDATA, a1: C_SCON, a6: C_ADDR, type_: 0, size: 0},
 	{as: obj.ANOP, type_: 0, size: 0},
 	{as: obj.ANOP, a1: C_LCON, type_: 0, size: 0}, // NOP operand variations added for #40689
 	{as: obj.ANOP, a1: C_REG, type_: 0, size: 0},  // to preserve previous behavior
 	{as: obj.ANOP, a1: C_FREG, type_: 0, size: 0},
-	{as: obj.ADUFFZERO, a4: C_LBRA, type_: 11, size: 4}, // same as ABR/ABL
-	{as: obj.ADUFFCOPY, a4: C_LBRA, type_: 11, size: 4}, // same as ABR/ABL
+	{as: obj.ADUFFZERO, a6: C_LBRA, type_: 11, size: 4}, // same as ABR/ABL
+	{as: obj.ADUFFCOPY, a6: C_LBRA, type_: 11, size: 4}, // same as ABR/ABL
 	{as: obj.APCALIGN, a1: C_LCON, type_: 0, size: 0},   // align code
 
 	{as: obj.AXXX, type_: 0, size: 4},
@@ -1042,25 +1044,28 @@ func (c *ctxt9) oplook(p *obj.Prog) *Optab {
 		a1 = c.aclass(&p.From) + 1
 		p.From.Class = int8(a1)
 	}
-
 	a1--
-	a3 := C_NONE + 1
-	if p.GetFrom3() != nil {
-		a3 = int(p.GetFrom3().Class)
-		if a3 == 0 {
-			a3 = c.aclass(p.GetFrom3()) + 1
-			p.GetFrom3().Class = int8(a3)
+
+	argsv := [3]int{C_NONE + 1, C_NONE + 1, C_NONE + 1}
+	for i, ap := range p.RestArgs {
+		argsv[i] = int(ap.Addr.Class)
+		if argsv[i] == 0 {
+			argsv[i] = c.aclass(&ap.Addr) + 1
+			ap.Addr.Class = int8(argsv[i])
 		}
-	}
 
-	a3--
-	a4 := int(p.To.Class)
-	if a4 == 0 {
-		a4 = c.aclass(&p.To) + 1
-		p.To.Class = int8(a4)
 	}
+	a3 := argsv[0] - 1
+	a4 := argsv[1] - 1
+	a5 := argsv[2] - 1
+
+	a6 := int(p.To.Class)
+	if a6 == 0 {
+		a6 = c.aclass(&p.To) + 1
+		p.To.Class = int8(a6)
+	}
+	a6--
 
-	a4--
 	a2 := C_NONE
 	if p.Reg != 0 {
 		if REG_R0 <= p.Reg && p.Reg <= REG_R31 {
@@ -1074,20 +1079,22 @@ func (c *ctxt9) oplook(p *obj.Prog) *Optab {
 		}
 	}
 
-	// c.ctxt.Logf("oplook %v %d %d %d %d\n", p, a1, a2, a3, a4)
+	// c.ctxt.Logf("oplook %v %d %d %d %d\n", p, a1, a2, a3, a4, a5, a6)
 	ops := oprange[p.As&obj.AMask]
 	c1 := &xcmp[a1]
 	c3 := &xcmp[a3]
 	c4 := &xcmp[a4]
+	c5 := &xcmp[a5]
+	c6 := &xcmp[a6]
 	for i := range ops {
 		op := &ops[i]
-		if int(op.a2) == a2 && c1[op.a1] && c3[op.a3] && c4[op.a4] {
+		if int(op.a2) == a2 && c1[op.a1] && c3[op.a3] && c4[op.a4] && c5[op.a5] && c6[op.a6] {
 			p.Optab = uint16(cap(optab) - cap(ops) + i + 1)
 			return op
 		}
 	}
 
-	c.ctxt.Diag("illegal combination %v %v %v %v %v", p.As, DRconv(a1), DRconv(a2), DRconv(a3), DRconv(a4))
+	c.ctxt.Diag("illegal combination %v %v %v %v %v %v %v", p.As, DRconv(a1), DRconv(a2), DRconv(a3), DRconv(a4), DRconv(a5), DRconv(a6))
 	prasm(p)
 	if ops == nil {
 		ops = optab
@@ -1217,6 +1224,14 @@ func (x ocmp) Less(i, j int) bool {
 	if n != 0 {
 		return n < 0
 	}
+	n = int(p1.a5) - int(p2.a5)
+	if n != 0 {
+		return n < 0
+	}
+	n = int(p1.a6) - int(p2.a6)
+	if n != 0 {
+		return n < 0
+	}
 	return false
 }
 
-- 
GitLab


From 9d88a9e2bf89068238ed02a0c960e58f547bb102 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Mon, 22 Feb 2021 21:51:35 -0500
Subject: [PATCH 0930/2400] cmd/compile: implement simple register results

at least for ints and strings

includes simple test

For #40724.

Change-Id: Ib8484e5b957b08f961574a67cfd93d3d26551558
Reviewed-on: https://go-review.googlesource.com/c/go/+/295309
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/abi/abiutils.go     | 64 ++++++++++++++++++++
 src/cmd/compile/internal/ssa/expand_calls.go | 58 ++++++++++++------
 src/cmd/compile/internal/ssa/lower.go        |  3 +-
 src/cmd/compile/internal/ssa/op.go           | 25 +++++++-
 src/cmd/compile/internal/ssa/regalloc.go     |  3 +
 test/abi/fibish.go                           | 33 ++++++++++
 test/abi/fibish.out                          |  1 +
 7 files changed, 164 insertions(+), 23 deletions(-)
 create mode 100644 test/abi/fibish.go
 create mode 100644 test/abi/fibish.out

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index f84f8f8e01..ffa709965c 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -101,6 +101,70 @@ func (a *ABIParamAssignment) Offset() int32 {
 	return a.offset
 }
 
+// RegisterTypes returns a slice of the types of the registers
+// corresponding to a slice of parameters.  The returned slice
+// has capacity for one more, likely a memory type.
+func RegisterTypes(apa []ABIParamAssignment) []*types.Type {
+	rcount := 0
+	for _, pa := range apa {
+		rcount += len(pa.Registers)
+	}
+	if rcount == 0 {
+		// Note that this catches top-level struct{} and [0]Foo, which are stack allocated.
+		return make([]*types.Type, 0, 1)
+	}
+	rts := make([]*types.Type, 0, rcount+1)
+	for _, pa := range apa {
+		if len(pa.Registers) == 0 {
+			continue
+		}
+		rts = appendParamRegs(rts, pa.Type)
+	}
+	return rts
+}
+
+func appendParamRegs(rts []*types.Type, t *types.Type) []*types.Type {
+	if t.IsScalar() || t.IsPtrShaped() {
+		if t.IsComplex() {
+			c := types.FloatForComplex(t)
+			return append(rts, c, c)
+		} else {
+			if int(t.Size()) <= types.RegSize {
+				return append(rts, t)
+			}
+			// assume 64bit int on 32-bit machine
+			// TODO endianness? Should high-order (sign bits) word come first?
+			if t.IsSigned() {
+				rts = append(rts, types.Types[types.TINT32])
+			} else {
+				rts = append(rts, types.Types[types.TUINT32])
+			}
+			return append(rts, types.Types[types.TUINT32])
+		}
+	} else {
+		typ := t.Kind()
+		switch typ {
+		case types.TARRAY:
+			for i := int64(0); i < t.Size(); i++ { // 0 gets no registers, plus future-proofing.
+				rts = appendParamRegs(rts, t.Elem())
+			}
+		case types.TSTRUCT:
+			for _, f := range t.FieldSlice() {
+				if f.Type.Size() > 0 { // embedded zero-width types receive no registers
+					rts = appendParamRegs(rts, f.Type)
+				}
+			}
+		case types.TSLICE:
+			return appendParamRegs(rts, synthSlice)
+		case types.TSTRING:
+			return appendParamRegs(rts, synthString)
+		case types.TINTER:
+			return appendParamRegs(rts, synthIface)
+		}
+	}
+	return rts
+}
+
 // SpillOffset returns the offset *within the spill area* for the parameter that "a" describes.
 // Registers will be spilled here; if a memory home is needed (for a pointer method e.g.)
 // then that will be the address.
diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index ff16eac90f..6e14a90e79 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -14,10 +14,10 @@ import (
 )
 
 type selKey struct {
-	from   *Value
-	offset int64
-	size   int64
-	typ    *types.Type
+	from          *Value // what is selected from
+	offsetOrIndex int64  // whatever is appropriate for the selector
+	size          int64
+	typ           *types.Type
 }
 
 type offsetKey struct {
@@ -372,6 +372,7 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64,
 		// if applied to Op-mumble-call, the Aux tells us which result, regOffset specifies offset within result.  If a register, should rewrite to OpSelectN for new call.
 		// TODO these may be duplicated. Should memoize. Intermediate selectors will go dead, no worries there.
 		call := selector.Args[0]
+		call0 := call
 		aux := call.Aux.(*AuxCall)
 		which := selector.AuxInt
 		if which == aux.NResults() { // mem is after the results.
@@ -398,7 +399,6 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64,
 			leafType := removeTrivialWrapperTypes(leaf.Type)
 			if x.canSSAType(leafType) {
 				pt := types.NewPtr(leafType)
-				off := x.offsetFrom(x.sp, offset+aux.OffsetOfResult(which), pt)
 				// Any selection right out of the arg area/registers has to be same Block as call, use call as mem input.
 				if call.Op == OpStaticLECall { // TODO this is temporary until all calls are register-able
 					// Create a "mem" for any loads that need to occur.
@@ -413,15 +413,30 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64,
 						call = mem
 					}
 				}
-				if leaf.Block == call.Block {
-					leaf.reset(OpLoad)
-					leaf.SetArgs2(off, call)
-					leaf.Type = leafType
+				outParam := aux.abiInfo.OutParam(int(which))
+				if len(outParam.Registers) > 0 {
+					reg := int64(outParam.Registers[regOffset])
+					if leaf.Block == call.Block {
+						leaf.reset(OpSelectN)
+						leaf.SetArgs1(call0)
+						leaf.Type = leafType
+						leaf.AuxInt = reg
+					} else {
+						w := call.Block.NewValue1I(leaf.Pos, OpSelectN, leafType, reg, call0)
+						leaf.copyOf(w)
+					}
 				} else {
-					w := call.Block.NewValue2(leaf.Pos, OpLoad, leafType, off, call)
-					leaf.copyOf(w)
-					if x.debug {
-						fmt.Printf("\tnew %s\n", w.LongString())
+					off := x.offsetFrom(x.sp, offset+aux.OffsetOfResult(which), pt)
+					if leaf.Block == call.Block {
+						leaf.reset(OpLoad)
+						leaf.SetArgs2(off, call)
+						leaf.Type = leafType
+					} else {
+						w := call.Block.NewValue2(leaf.Pos, OpLoad, leafType, off, call)
+						leaf.copyOf(w)
+						if x.debug {
+							fmt.Printf("\tnew %s\n", w.LongString())
+						}
 					}
 				}
 				for _, s := range x.namedSelects[selector] {
@@ -812,7 +827,7 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, source, mem *Value,
 		s = b.NewValue3A(pos, OpStore, types.TypeMem, t, dst, source, mem)
 	}
 	if x.debug {
-		fmt.Printf("\t\tstoreArg returns %s\n", s.LongString())
+		fmt.Printf("\t\tstoreArg returns %s, storeRc=%s\n", s.LongString(), storeRc.String())
 	}
 	return s
 }
@@ -983,9 +998,11 @@ func expandCalls(f *Func) {
 					mem = x.storeArgOrLoad(v.Pos, b, a, mem, aux.TypeOfResult(i), auxOffset, 0, rc)
 				}
 			}
-			// TODO REGISTER -- keep the Result for block control, splice in contents of AllResults
-			b.SetControl(mem)
-			v.reset(OpInvalid) // otherwise it can have a mem operand which will fail check(), even though it is dead.
+			v.resetArgs()
+			v.AddArgs(allResults...)
+			v.AddArg(mem)
+			v.Type = types.NewResults(append(abi.RegisterTypes(aux.abiInfo.OutParams()), types.TypeMem))
+			b.SetControl(v)
 		}
 	}
 
@@ -1170,7 +1187,7 @@ func expandCalls(f *Func) {
 		case OpArraySelect:
 			offset = size * v.AuxInt
 		case OpSelectN:
-			offset = w.Aux.(*AuxCall).OffsetOfResult(v.AuxInt)
+			offset = v.AuxInt // offset is just a key, really.
 		case OpInt64Hi:
 			offset = x.hiOffset
 		case OpInt64Lo:
@@ -1182,7 +1199,7 @@ func expandCalls(f *Func) {
 		case OpComplexImag:
 			offset = size
 		}
-		sk := selKey{from: w, size: size, offset: offset, typ: typ}
+		sk := selKey{from: w, size: size, offsetOrIndex: offset, typ: typ}
 		dupe := x.commonSelectors[sk]
 		if dupe == nil {
 			x.commonSelectors[sk] = v
@@ -1240,8 +1257,9 @@ func expandCalls(f *Func) {
 				x.rewriteArgToMemOrRegs(v)
 			case OpStaticLECall:
 				v.Op = OpStaticCall
+				rts := abi.RegisterTypes(v.Aux.(*AuxCall).abiInfo.OutParams())
 				// TODO need to insert all the register types.
-				v.Type = types.NewResults([]*types.Type{types.TypeMem})
+				v.Type = types.NewResults(append(rts, types.TypeMem))
 			case OpClosureLECall:
 				v.Op = OpClosureCall
 				v.Type = types.TypeMem
diff --git a/src/cmd/compile/internal/ssa/lower.go b/src/cmd/compile/internal/ssa/lower.go
index bbb80a7a30..5760c35601 100644
--- a/src/cmd/compile/internal/ssa/lower.go
+++ b/src/cmd/compile/internal/ssa/lower.go
@@ -24,7 +24,7 @@ func checkLower(f *Func) {
 			case OpSP, OpSB, OpInitMem, OpArg, OpArgIntReg, OpArgFloatReg, OpPhi, OpVarDef, OpVarKill, OpVarLive, OpKeepAlive, OpSelect0, OpSelect1, OpSelectN, OpConvert, OpInlMark:
 				continue // ok not to lower
 			case OpMakeResult:
-				if len(b.Controls) == 1 && b.Controls[0] == v {
+				if b.Controls[0] == v {
 					continue
 				}
 			case OpGetG:
@@ -34,6 +34,7 @@ func checkLower(f *Func) {
 				}
 			}
 			s := "not lowered: " + v.String() + ", " + v.Op.String() + " " + v.Type.SimpleString()
+
 			for _, a := range v.Args {
 				s += " " + a.Type.SimpleString()
 			}
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index 4082e84c6a..0577ec7bed 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -134,6 +134,24 @@ func (a *AuxCall) Reg(i *regInfo, c *Config) *regInfo {
 	return a.reg
 }
 
+func (a *AuxCall) ResultReg(c *Config) *regInfo {
+	if a.abiInfo.OutRegistersUsed() == 0 {
+		return a.reg
+	}
+	if len(a.reg.inputs) > 0 {
+		return a.reg
+	}
+	k := 0
+	for _, p := range a.abiInfo.OutParams() {
+		for _, r := range p.Registers {
+			m := archRegForAbiReg(r, c)
+			a.reg.inputs = append(a.reg.inputs, inputInfo{idx: k, regs: (1 << m)})
+			k++
+		}
+	}
+	return a.reg
+}
+
 func archRegForAbiReg(r abi.RegIndex, c *Config) uint8 {
 	var m int8
 	if int(r) < len(c.intParamRegs) {
@@ -285,10 +303,13 @@ func ClosureAuxCall(args []Param, results []Param, paramResultInfo *abi.ABIParam
 func (*AuxCall) CanBeAnSSAAux() {}
 
 // OwnAuxCall returns a function's own AuxCall
-
 func OwnAuxCall(fn *obj.LSym, args []Param, results []Param, paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
 	// TODO if this remains identical to ClosureAuxCall above after new ABI is done, should deduplicate.
-	return &AuxCall{Fn: fn, args: args, results: results, abiInfo: paramResultInfo}
+	var reg *regInfo
+	if paramResultInfo.InRegistersUsed()+paramResultInfo.OutRegistersUsed() > 0 {
+		reg = &regInfo{}
+	}
+	return &AuxCall{Fn: fn, args: args, results: results, abiInfo: paramResultInfo, reg: reg}
 }
 
 const (
diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go
index c2d0478e82..15f6412a85 100644
--- a/src/cmd/compile/internal/ssa/regalloc.go
+++ b/src/cmd/compile/internal/ssa/regalloc.go
@@ -830,6 +830,9 @@ func (s *regAllocState) regspec(v *Value) regInfo {
 			return *ac.Reg(&opcodeTable[op].reg, s.f.Config)
 		}
 	}
+	if op == OpMakeResult && s.f.OwnAux.reg != nil {
+		return *s.f.OwnAux.ResultReg(s.f.Config)
+	}
 	return opcodeTable[op].reg
 }
 
diff --git a/test/abi/fibish.go b/test/abi/fibish.go
new file mode 100644
index 0000000000..b72f1322de
--- /dev/null
+++ b/test/abi/fibish.go
@@ -0,0 +1,33 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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 "fmt"
+
+// Test that register results are correctly returned (and passed)
+
+//go:registerparams
+//go:noinline
+func f(x int) (int, int) {
+
+	if x < 3 {
+		return 0, x
+	}
+
+	a, b := f(x - 2)
+	c, d := f(x - 1)
+	return a + d, b + c
+}
+
+func main() {
+	x := 40
+	a, b := f(x)
+	fmt.Printf("f(%d)=%d,%d\n", x, a, b)
+}
diff --git a/test/abi/fibish.out b/test/abi/fibish.out
new file mode 100644
index 0000000000..9bd80c32c9
--- /dev/null
+++ b/test/abi/fibish.out
@@ -0,0 +1 @@
+f(40)=39088169,126491972
-- 
GitLab


From 77505c25d83a2130011736d6a2a915eaa3ae230a Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Sun, 28 Feb 2021 12:18:18 +0100
Subject: [PATCH 0931/2400] syscall: treat proc thread attribute lists as
 unsafe.Pointers

It turns out that the proc thread update function doesn't actually
allocate new memory for its arguments and instead just copies the
pointer values into the preallocated memory. Since we were allocating
that memory as []byte, the garbage collector didn't scan it for pointers
to Go allocations and freed them. We _could_ fix this by requiring that
all users of this use runtime.KeepAlive for everything they pass to the
update function, but that seems harder than necessary. Instead, we can
just do the allocation as []unsafe.Pointer, which means the GC can
operate as intended and not free these from beneath our feet. In order
to ensure this remains true, we also add a test for this.

Fixes #44662.

Change-Id: Ib392ba8ceacacec94b11379919c8179841cba29f
Reviewed-on: https://go-review.googlesource.com/c/go/+/297389
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Trust: Alex Brainman <alex.brainman@gmail.com>
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/syscall/exec_windows.go         |  4 ++--
 src/syscall/export_windows_test.go  | 11 +++++++++
 src/syscall/syscall_windows.go      |  5 ++--
 src/syscall/syscall_windows_test.go | 36 +++++++++++++++++++++++++++++
 src/syscall/types_windows.go        |  8 ++++++-
 src/syscall/zsyscall_windows.go     |  2 +-
 6 files changed, 60 insertions(+), 6 deletions(-)
 create mode 100644 src/syscall/export_windows_test.go

diff --git a/src/syscall/exec_windows.go b/src/syscall/exec_windows.go
index 7b73cf1f6f..b20a27d28b 100644
--- a/src/syscall/exec_windows.go
+++ b/src/syscall/exec_windows.go
@@ -340,7 +340,7 @@ func StartProcess(argv0 string, argv []string, attr *ProcAttr) (pid int, handle
 		si.ShowWindow = SW_HIDE
 	}
 	if sys.ParentProcess != 0 {
-		err = updateProcThreadAttribute(si.ProcThreadAttributeList, 0, _PROC_THREAD_ATTRIBUTE_PARENT_PROCESS, uintptr(unsafe.Pointer(&sys.ParentProcess)), unsafe.Sizeof(sys.ParentProcess), 0, nil)
+		err = updateProcThreadAttribute(si.ProcThreadAttributeList, 0, _PROC_THREAD_ATTRIBUTE_PARENT_PROCESS, unsafe.Pointer(&sys.ParentProcess), unsafe.Sizeof(sys.ParentProcess), nil, nil)
 		if err != nil {
 			return 0, 0, err
 		}
@@ -351,7 +351,7 @@ func StartProcess(argv0 string, argv []string, attr *ProcAttr) (pid int, handle
 
 	fd = append(fd, sys.AdditionalInheritedHandles...)
 	// Do not accidentally inherit more than these handles.
-	err = updateProcThreadAttribute(si.ProcThreadAttributeList, 0, _PROC_THREAD_ATTRIBUTE_HANDLE_LIST, uintptr(unsafe.Pointer(&fd[0])), uintptr(len(fd))*unsafe.Sizeof(fd[0]), 0, nil)
+	err = updateProcThreadAttribute(si.ProcThreadAttributeList, 0, _PROC_THREAD_ATTRIBUTE_HANDLE_LIST, unsafe.Pointer(&fd[0]), uintptr(len(fd))*unsafe.Sizeof(fd[0]), nil, nil)
 	if err != nil {
 		return 0, 0, err
 	}
diff --git a/src/syscall/export_windows_test.go b/src/syscall/export_windows_test.go
new file mode 100644
index 0000000000..a72a1ee391
--- /dev/null
+++ b/src/syscall/export_windows_test.go
@@ -0,0 +1,11 @@
+// Copyright 2021 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 syscall
+
+var NewProcThreadAttributeList = newProcThreadAttributeList
+var UpdateProcThreadAttribute = updateProcThreadAttribute
+var DeleteProcThreadAttributeList = deleteProcThreadAttributeList
+
+const PROC_THREAD_ATTRIBUTE_HANDLE_LIST = _PROC_THREAD_ATTRIBUTE_HANDLE_LIST
diff --git a/src/syscall/syscall_windows.go b/src/syscall/syscall_windows.go
index cc8dc487d3..05a7d3027d 100644
--- a/src/syscall/syscall_windows.go
+++ b/src/syscall/syscall_windows.go
@@ -286,7 +286,7 @@ func NewCallbackCDecl(fn interface{}) uintptr {
 //sys	CreateHardLink(filename *uint16, existingfilename *uint16, reserved uintptr) (err error) [failretval&0xff==0] = CreateHardLinkW
 //sys	initializeProcThreadAttributeList(attrlist *_PROC_THREAD_ATTRIBUTE_LIST, attrcount uint32, flags uint32, size *uintptr) (err error) = InitializeProcThreadAttributeList
 //sys	deleteProcThreadAttributeList(attrlist *_PROC_THREAD_ATTRIBUTE_LIST) = DeleteProcThreadAttributeList
-//sys	updateProcThreadAttribute(attrlist *_PROC_THREAD_ATTRIBUTE_LIST, flags uint32, attr uintptr, value uintptr, size uintptr, prevvalue uintptr, returnedsize *uintptr) (err error) = UpdateProcThreadAttribute
+//sys	updateProcThreadAttribute(attrlist *_PROC_THREAD_ATTRIBUTE_LIST, flags uint32, attr uintptr, value unsafe.Pointer, size uintptr, prevvalue unsafe.Pointer, returnedsize *uintptr) (err error) = UpdateProcThreadAttribute
 
 // syscall interface implementation for other packages
 
@@ -1256,7 +1256,8 @@ func newProcThreadAttributeList(maxAttrCount uint32) (*_PROC_THREAD_ATTRIBUTE_LI
 		}
 		return nil, err
 	}
-	al := (*_PROC_THREAD_ATTRIBUTE_LIST)(unsafe.Pointer(&make([]byte, size)[0]))
+	// size is guaranteed to be ≥1 by initializeProcThreadAttributeList.
+	al := (*_PROC_THREAD_ATTRIBUTE_LIST)(unsafe.Pointer(&make([]unsafe.Pointer, (size+ptrSize-1)/ptrSize)[0]))
 	err = initializeProcThreadAttributeList(al, maxAttrCount, 0, &size)
 	if err != nil {
 		return nil, err
diff --git a/src/syscall/syscall_windows_test.go b/src/syscall/syscall_windows_test.go
index a9ae54752b..d5e8d58b5a 100644
--- a/src/syscall/syscall_windows_test.go
+++ b/src/syscall/syscall_windows_test.go
@@ -7,8 +7,11 @@ package syscall_test
 import (
 	"os"
 	"path/filepath"
+	"runtime"
 	"syscall"
 	"testing"
+	"time"
+	"unsafe"
 )
 
 func TestWin32finddata(t *testing.T) {
@@ -75,3 +78,36 @@ func TestTOKEN_ALL_ACCESS(t *testing.T) {
 		t.Errorf("TOKEN_ALL_ACCESS = %x, want 0xF01FF", syscall.TOKEN_ALL_ACCESS)
 	}
 }
+
+func TestProcThreadAttributeListPointers(t *testing.T) {
+	list, err := syscall.NewProcThreadAttributeList(1)
+	if err != nil {
+		t.Errorf("unable to create ProcThreadAttributeList: %v", err)
+	}
+	done := make(chan struct{})
+	fds := make([]syscall.Handle, 20)
+	runtime.SetFinalizer(&fds[0], func(*syscall.Handle) {
+		close(done)
+	})
+	err = syscall.UpdateProcThreadAttribute(list, 0, syscall.PROC_THREAD_ATTRIBUTE_HANDLE_LIST, unsafe.Pointer(&fds[0]), uintptr(len(fds))*unsafe.Sizeof(fds[0]), nil, nil)
+	if err != nil {
+		syscall.DeleteProcThreadAttributeList(list)
+		t.Errorf("unable to update ProcThreadAttributeList: %v", err)
+		return
+	}
+	runtime.GC()
+	runtime.GC()
+	select {
+	case <-done:
+		t.Error("ProcThreadAttributeList was garbage collected unexpectedly")
+	default:
+	}
+	syscall.DeleteProcThreadAttributeList(list)
+	runtime.GC()
+	runtime.GC()
+	select {
+	case <-done:
+	case <-time.After(time.Second):
+		t.Error("ProcThreadAttributeList was not garbage collected after a second")
+	}
+}
diff --git a/src/syscall/types_windows.go b/src/syscall/types_windows.go
index 384b5b4f2c..31fe7664c9 100644
--- a/src/syscall/types_windows.go
+++ b/src/syscall/types_windows.go
@@ -4,6 +4,8 @@
 
 package syscall
 
+import "unsafe"
+
 const (
 	// Windows errors.
 	ERROR_FILE_NOT_FOUND      Errno = 2
@@ -491,7 +493,11 @@ type StartupInfo struct {
 }
 
 type _PROC_THREAD_ATTRIBUTE_LIST struct {
-	_ [1]byte
+	// This is of type unsafe.Pointer, not of type byte or uintptr, because
+	// the contents of it is mostly a list of pointers, and in most cases,
+	// that's a list of pointers to Go-allocated objects. In order to keep
+	// the GC from collecting these objects, we declare this as unsafe.Pointer.
+	_ [1]unsafe.Pointer
 }
 
 const (
diff --git a/src/syscall/zsyscall_windows.go b/src/syscall/zsyscall_windows.go
index b08e6ac5c2..10d0f54e8c 100644
--- a/src/syscall/zsyscall_windows.go
+++ b/src/syscall/zsyscall_windows.go
@@ -1115,7 +1115,7 @@ func UnmapViewOfFile(addr uintptr) (err error) {
 	return
 }
 
-func updateProcThreadAttribute(attrlist *_PROC_THREAD_ATTRIBUTE_LIST, flags uint32, attr uintptr, value uintptr, size uintptr, prevvalue uintptr, returnedsize *uintptr) (err error) {
+func updateProcThreadAttribute(attrlist *_PROC_THREAD_ATTRIBUTE_LIST, flags uint32, attr uintptr, value unsafe.Pointer, size uintptr, prevvalue unsafe.Pointer, returnedsize *uintptr) (err error) {
 	r1, _, e1 := Syscall9(procUpdateProcThreadAttribute.Addr(), 7, uintptr(unsafe.Pointer(attrlist)), uintptr(flags), uintptr(attr), uintptr(value), uintptr(size), uintptr(prevvalue), uintptr(unsafe.Pointer(returnedsize)), 0, 0)
 	if r1 == 0 {
 		err = errnoErr(e1)
-- 
GitLab


From c015f76acb73990d4cb7fb056165b64d79b1b037 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Tue, 23 Feb 2021 20:00:31 -0500
Subject: [PATCH 0932/2400] cmd/compile: implement too-big-to-SSA struct
 passing in registers

Added a test that exercises named results

Change-Id: Ie228b68f4f846266595a95e0f65a6e4b8bf79635
Reviewed-on: https://go-review.googlesource.com/c/go/+/297029
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/abi/abiutils.go     | 59 +++++++++++--
 src/cmd/compile/internal/ssa/expand_calls.go | 26 ++++--
 src/cmd/compile/internal/ssagen/ssa.go       | 27 +++---
 test/abi/named_results.go                    | 91 ++++++++++++++++++++
 test/abi/named_results.out                   | 13 +++
 5 files changed, 190 insertions(+), 26 deletions(-)
 create mode 100644 test/abi/named_results.go
 create mode 100644 test/abi/named_results.out

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index ffa709965c..3c07be62e0 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -118,12 +118,22 @@ func RegisterTypes(apa []ABIParamAssignment) []*types.Type {
 		if len(pa.Registers) == 0 {
 			continue
 		}
-		rts = appendParamRegs(rts, pa.Type)
+		rts = appendParamTypes(rts, pa.Type)
 	}
 	return rts
 }
 
-func appendParamRegs(rts []*types.Type, t *types.Type) []*types.Type {
+func (pa *ABIParamAssignment) RegisterTypesAndOffsets() ([]*types.Type, []int64) {
+	l := len(pa.Registers)
+	if l == 0 {
+		return nil, nil
+	}
+	typs := make([]*types.Type, 0, l)
+	offs := make([]int64, 0, l)
+	return appendParamTypes(typs, pa.Type), appendParamOffsets(offs, 0, pa.Type)
+}
+
+func appendParamTypes(rts []*types.Type, t *types.Type) []*types.Type {
 	if t.IsScalar() || t.IsPtrShaped() {
 		if t.IsComplex() {
 			c := types.FloatForComplex(t)
@@ -146,25 +156,60 @@ func appendParamRegs(rts []*types.Type, t *types.Type) []*types.Type {
 		switch typ {
 		case types.TARRAY:
 			for i := int64(0); i < t.Size(); i++ { // 0 gets no registers, plus future-proofing.
-				rts = appendParamRegs(rts, t.Elem())
+				rts = appendParamTypes(rts, t.Elem())
 			}
 		case types.TSTRUCT:
 			for _, f := range t.FieldSlice() {
 				if f.Type.Size() > 0 { // embedded zero-width types receive no registers
-					rts = appendParamRegs(rts, f.Type)
+					rts = appendParamTypes(rts, f.Type)
 				}
 			}
 		case types.TSLICE:
-			return appendParamRegs(rts, synthSlice)
+			return appendParamTypes(rts, synthSlice)
 		case types.TSTRING:
-			return appendParamRegs(rts, synthString)
+			return appendParamTypes(rts, synthString)
 		case types.TINTER:
-			return appendParamRegs(rts, synthIface)
+			return appendParamTypes(rts, synthIface)
 		}
 	}
 	return rts
 }
 
+// appendParamOffsets appends the offset(s) of type t, starting from "at",
+// to input offsets, and returns the longer slice.
+func appendParamOffsets(offsets []int64, at int64, t *types.Type) []int64 {
+	at = align(at, t)
+	if t.IsScalar() || t.IsPtrShaped() {
+		if t.IsComplex() || int(t.Width) > types.RegSize { // complex and *int64 on 32-bit
+			s := t.Width / 2
+			return append(offsets, at, at+s)
+		} else {
+			return append(offsets, at)
+		}
+	} else {
+		typ := t.Kind()
+		switch typ {
+		case types.TARRAY:
+			for i := int64(0); i < t.NumElem(); i++ {
+				offsets = appendParamOffsets(offsets, at, t.Elem())
+			}
+			return offsets
+		case types.TSTRUCT:
+			for _, f := range t.FieldSlice() {
+				offsets = appendParamOffsets(offsets, at, f.Type)
+				at += f.Type.Width
+			}
+		case types.TSLICE:
+			return appendParamOffsets(offsets, at, synthSlice)
+		case types.TSTRING:
+			return appendParamOffsets(offsets, at, synthString)
+		case types.TINTER:
+			return appendParamOffsets(offsets, at, synthIface)
+		}
+	}
+	return offsets
+}
+
 // SpillOffset returns the offset *within the spill area* for the parameter that "a" describes.
 // Registers will be spilled here; if a memory home is needed (for a pointer method e.g.)
 // then that will be the address.
diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index 6e14a90e79..fd8ae30caf 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -657,7 +657,7 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, source, mem *Value,
 	case OpCopy:
 		return x.storeArgOrLoad(pos, b, source.Args[0], mem, t, offset, loadRegOffset, storeRc)
 
-	case OpLoad:
+	case OpLoad, OpDereference:
 		ret := x.decomposeArgOrLoad(pos, b, source, mem, t, offset, loadRegOffset, storeRc, storeOneLoad, storeTwoLoad)
 		if ret != nil {
 			return ret
@@ -820,6 +820,9 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, source, mem *Value,
 	}
 
 	s := mem
+	if source.Op == OpDereference {
+		source.Op = OpLoad // For purposes of parameter passing expansion, a Dereference is a Load.
+	}
 	if storeRc.hasRegs() {
 		storeRc.addArg(source)
 	} else {
@@ -846,14 +849,11 @@ func (x *expandState) rewriteArgs(v *Value, firstArg int) (*Value, []*Value) {
 		auxI := int64(i)
 		aRegs := aux.RegsOfArg(auxI)
 		aType := aux.TypeOfArg(auxI)
-		if a.Op == OpDereference {
+		if len(aRegs) == 0 && a.Op == OpDereference {
 			aOffset := aux.OffsetOfArg(auxI)
 			if a.MemoryArg() != m0 {
 				x.f.Fatalf("Op...LECall and OpDereference have mismatched mem, %s and %s", v.LongString(), a.LongString())
 			}
-			if len(aRegs) > 0 {
-				x.f.Fatalf("Not implemented yet, not-SSA-type %v passed in registers", aType)
-			}
 			// "Dereference" of addressed (probably not-SSA-eligible) value becomes Move
 			// TODO(register args) this will be more complicated with registers in the picture.
 			mem = x.rewriteDereference(v.Block, x.sp, a, mem, aOffset, aux.SizeOfArg(auxI), aType, pos)
@@ -969,10 +969,7 @@ func expandCalls(f *Func) {
 				auxOffset := int64(0)
 				auxSize := aux.SizeOfResult(i)
 				aRegs := aux.RegsOfResult(int64(j))
-				if a.Op == OpDereference {
-					if len(aRegs) > 0 {
-						x.f.Fatalf("Not implemented yet, not-SSA-type %v returned in register", auxType)
-					}
+				if len(aRegs) == 0 && a.Op == OpDereference {
 					// Avoid a self-move, and if one is detected try to remove the already-inserted VarDef for the assignment that won't happen.
 					if dAddr, dMem := a.Args[0], a.Args[1]; dAddr.Op == OpLocalAddr && dAddr.Args[0].Op == OpSP &&
 						dAddr.Args[1] == dMem && dAddr.Aux == aux.results[i].Name {
@@ -1392,3 +1389,14 @@ func (x *expandState) newArgToMemOrRegs(baseArg, toReplace *Value, offset int64,
 		}
 	}
 }
+
+// argOpAndRegisterFor converts an abi register index into an ssa Op and corresponding
+// arg register index.
+// TODO could call this in at least two places earlier in this file.
+func ArgOpAndRegisterFor(r abi.RegIndex, abiConfig *abi.ABIConfig) (Op, int64) {
+	i := abiConfig.FloatIndexFor(r)
+	if i >= 0 { // float PR
+		return OpArgFloatReg, i
+	}
+	return OpArgIntReg, int64(r)
+}
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 9ee855343f..2a281860af 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -555,19 +555,26 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 				}
 				s.vars[n] = v
 				s.addNamedValue(n, v) // This helps with debugging information, not needed for compilation itself.
-			} else if !s.canSSAName(n) { // I.e., the address was taken.  The type may or may not be okay.
-				// If the value will arrive in registers,
-				// AND if it can be SSA'd (if it cannot, panic for now),
-				// THEN
-				// (1) receive it as an OpArg (but do not store its name in the var table)
-				// (2) store it to its spill location, which is its address as well.
+			} else { // address was taken AND/OR too large for SSA
 				paramAssignment := ssa.ParamAssignmentForArgName(s.f, n)
 				if len(paramAssignment.Registers) > 0 {
-					if !TypeOK(n.Type()) { // TODO register args -- if v is not an SSA-able type, must decompose, here.
-						panic(fmt.Errorf("Arg in registers is too big to be SSA'd, need to implement decomposition, type=%v, n=%v", n.Type(), n))
+					if TypeOK(n.Type()) { // SSA-able type, so address was taken -- receive value in OpArg, DO NOT bind to var, store immediately to memory.
+						v := s.newValue0A(ssa.OpArg, n.Type(), n)
+						s.store(n.Type(), s.decladdrs[n], v)
+					} else { // Too big for SSA.
+						// Brute force, and early, do a bunch of stores from registers
+						// TODO fix the nasty storeArgOrLoad recursion in ssa/expand_calls.go so this Just Works with store of a big Arg.
+						typs, offs := paramAssignment.RegisterTypesAndOffsets()
+						for i, t := range typs {
+							o := offs[i]
+							r := paramAssignment.Registers[i]
+							op, reg := ssa.ArgOpAndRegisterFor(r, s.f.ABISelf)
+							v := s.newValue0I(op, t, reg)
+							v.Aux = &ssa.AuxNameOffset{Name: n, Offset: o}
+							p := s.newValue1I(ssa.OpOffPtr, types.NewPtr(n.Type()), o, s.decladdrs[n])
+							s.store(t, p, v)
+						}
 					}
-					v := s.newValue0A(ssa.OpArg, n.Type(), n)
-					s.store(n.Type(), s.decladdrs[n], v)
 				}
 			}
 		}
diff --git a/test/abi/named_results.go b/test/abi/named_results.go
new file mode 100644
index 0000000000..eaaadb184f
--- /dev/null
+++ b/test/abi/named_results.go
@@ -0,0 +1,91 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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 (
+	"fmt"
+)
+
+var sink *string
+
+var y int
+
+//go:registerparams
+//go:noinline
+func F(a, b, c *int) (x int) {
+	x = *a
+	G(&x)
+	x += *b
+	G(&x)
+	x += *c
+	G(&x)
+	return
+}
+
+//go:registerparams
+//go:noinline
+func G(x *int) {
+	y += *x
+	fmt.Println("y = ", y)
+}
+
+//go:registerparams
+//go:noinline
+func X() {
+	*sink += " !!!!!!!!!!!!!!!"
+}
+
+//go:registerparams
+//go:noinline
+func H(s, t string) (result string) { // result leaks to heap
+	result = "Aloha! " + s + " " + t
+	sink = &result
+	r := ""
+	if len(s) <= len(t) {
+		r = "OKAY! "
+		X()
+	}
+	return r + result
+}
+
+//go:registerparams
+//go:noinline
+func K(s, t string) (result string) { // result spills
+	result = "Aloha! " + s + " " + t
+	r := ""
+	if len(s) <= len(t) {
+		r = "OKAY! "
+		X()
+	}
+	return r + result
+}
+
+func main() {
+	a, b, c := 1, 4, 16
+	x := F(&a, &b, &c)
+	fmt.Printf("x = %d\n", x)
+
+	y := H("Hello", "World!")
+	fmt.Println("len(y) =", len(y))
+	fmt.Println("y =", y)
+	z := H("Hello", "Pal!")
+	fmt.Println("len(z) =", len(z))
+	fmt.Println("z =", z)
+
+	fmt.Println()
+
+	y = K("Hello", "World!")
+	fmt.Println("len(y) =", len(y))
+	fmt.Println("y =", y)
+	z = K("Hello", "Pal!")
+	fmt.Println("len(z) =", len(z))
+	fmt.Println("z =", z)
+
+}
diff --git a/test/abi/named_results.out b/test/abi/named_results.out
new file mode 100644
index 0000000000..02f12e806d
--- /dev/null
+++ b/test/abi/named_results.out
@@ -0,0 +1,13 @@
+y =  1
+y =  6
+y =  27
+x = 21
+len(y) = 41
+y = OKAY! Aloha! Hello World! !!!!!!!!!!!!!!!
+len(z) = 17
+z = Aloha! Hello Pal!
+
+len(y) = 25
+y = OKAY! Aloha! Hello World!
+len(z) = 17
+z = Aloha! Hello Pal!
-- 
GitLab


From 9d3718e834fcf5b602b84539364606445cfc8a1a Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Thu, 4 Mar 2021 16:38:20 -0500
Subject: [PATCH 0933/2400] cmd/compile: remove I-saw-a-register-pragma chatter

It is not multithreaded-compilation-safe, and also seems
to cause problems on the noopt-builder.

Change-Id: I52dbcd507d256990f1ec7c8040ec7b76595aae4f
Reviewed-on: https://go-review.googlesource.com/c/go/+/298850
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssagen/ssa.go |  4 ---
 test/abi/regabipragma.dir/main.go      | 36 --------------------------
 test/abi/regabipragma.dir/tmp/foo.go   | 19 --------------
 test/abi/regabipragma.go               | 13 ----------
 test/abi/regabipragma.out              |  6 -----
 5 files changed, 78 deletions(-)
 delete mode 100644 test/abi/regabipragma.dir/main.go
 delete mode 100644 test/abi/regabipragma.dir/tmp/foo.go
 delete mode 100644 test/abi/regabipragma.go
 delete mode 100644 test/abi/regabipragma.out

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 2a281860af..881fdcc8f4 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -230,7 +230,6 @@ func abiForFunc(fn *ir.Func, abi0, abi1 *abi.ABIConfig) *abi.ABIConfig {
 			base.ErrorfAt(fn.Pos(), "Calls to //go:registerparams method %s won't work, remove the pragma from the declaration.", name)
 		}
 		a = abi1
-		base.WarnfAt(fn.Pos(), "declared function %v has register params", fn)
 	}
 	return a
 }
@@ -4850,9 +4849,6 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			inRegistersImported := fn.Pragma()&ir.RegisterParams != 0
 			inRegistersSamePackage := fn.Func != nil && fn.Func.Pragma&ir.RegisterParams != 0
 			inRegisters = inRegistersImported || inRegistersSamePackage
-			if inRegisters {
-				s.f.Warnl(n.Pos(), "called function %v has register params", callee)
-			}
 			break
 		}
 		closure = s.expr(fn)
diff --git a/test/abi/regabipragma.dir/main.go b/test/abi/regabipragma.dir/main.go
deleted file mode 100644
index d663337a10..0000000000
--- a/test/abi/regabipragma.dir/main.go
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright 2021 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 (
-	"fmt"
-	"regabipragma.dir/tmp"
-)
-
-type S string
-
-//go:noinline
-func (s S) ff(t string) string {
-	return string(s) + " " + t
-}
-
-//go:noinline
-//go:registerparams
-func f(s,t string) string { // ERROR "Declared function f has register params"
-	return s + " " + t
-}
-
-func check(s string) {
-	if s != "Hello world!" {
-		fmt.Printf("FAIL, wanted 'Hello world!' but got '%s'\n", s)
-	}
-}
-
-func main() {
-	check(f("Hello", "world!"))   // ERROR "Called function ...f has register params"
-	check(tmp.F("Hello", "world!"))  // ERROR "Called function regabipragma.dir/tmp.F has register params"
-	check(S("Hello").ff("world!"))
-	check(tmp.S("Hello").FF("world!"))
-}
diff --git a/test/abi/regabipragma.dir/tmp/foo.go b/test/abi/regabipragma.dir/tmp/foo.go
deleted file mode 100644
index cff989bbcd..0000000000
--- a/test/abi/regabipragma.dir/tmp/foo.go
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright 2021 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 tmp
-
-
-type S string
-
-//go:noinline
-func (s S) FF(t string) string {
-        return string(s) + " " + t
-}
-
-//go:noinline
-//go:registerparams
-func F(s,t string) string {
-        return s + " " + t
-}
diff --git a/test/abi/regabipragma.go b/test/abi/regabipragma.go
deleted file mode 100644
index 070b3110d6..0000000000
--- a/test/abi/regabipragma.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// skip
-// runindir -gcflags=-c=1
-//go:build !windows
-// +build !windows
-
-// Copyright 2021 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.
-
-// TODO(register args) Temporarily disabled now that register abi info is flowing halfway through the compiler.
-// TODO(register args) May delete or adapt this test once regabi is the default
-
-package ignore
diff --git a/test/abi/regabipragma.out b/test/abi/regabipragma.out
deleted file mode 100644
index 321b1adfcc..0000000000
--- a/test/abi/regabipragma.out
+++ /dev/null
@@ -1,6 +0,0 @@
-# regabipragma.dir/tmp
-tmp/foo.go:17:6: declared function F has register params
-# regabipragma.dir
-./main.go:21:6: declared function f has register params
-./main.go:32:9: called function f has register params
-./main.go:33:13: called function tmp.F has register params
-- 
GitLab


From a99ff24a26939f30440dd0f06dce426ed5e638ee Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 3 Mar 2021 18:33:45 -0800
Subject: [PATCH 0934/2400] cmd/compile/internal/syntax: print type parameters
 and type lists

types2 uses the syntax printer to print expressions (for tracing
or error messages), so we need to (at least) print type lists in
interfaces.

While at it, also implement the printing of type parameter lists.

Fixes #44766.

Change-Id: I36a4a7152d9bef7251af264b5c7890aca88d8dc3
Reviewed-on: https://go-review.googlesource.com/c/go/+/298549
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/syntax/printer.go    | 57 ++++++++++++++-----
 .../compile/internal/syntax/printer_test.go   | 37 +++++++++++-
 2 files changed, 79 insertions(+), 15 deletions(-)

diff --git a/src/cmd/compile/internal/syntax/printer.go b/src/cmd/compile/internal/syntax/printer.go
index 9109ce2363..e557f5d924 100644
--- a/src/cmd/compile/internal/syntax/printer.go
+++ b/src/cmd/compile/internal/syntax/printer.go
@@ -481,10 +481,10 @@ func (p *printer) printRawNode(n Node) {
 		if len(n.FieldList) > 0 {
 			if p.linebreaks {
 				p.print(newline, indent)
-				p.printFieldList(n.FieldList, n.TagList)
+				p.printFieldList(n.FieldList, n.TagList, _Semi)
 				p.print(outdent, newline)
 			} else {
-				p.printFieldList(n.FieldList, n.TagList)
+				p.printFieldList(n.FieldList, n.TagList, _Semi)
 			}
 		}
 		p.print(_Rbrace)
@@ -494,20 +494,40 @@ func (p *printer) printRawNode(n Node) {
 		p.printSignature(n)
 
 	case *InterfaceType:
+		// separate type list and method list
+		var types []Expr
+		var methods []*Field
+		for _, f := range n.MethodList {
+			if f.Name != nil && f.Name.Value == "type" {
+				types = append(types, f.Type)
+			} else {
+				// method or embedded interface
+				methods = append(methods, f)
+			}
+		}
+
+		multiLine := len(n.MethodList) > 0 && p.linebreaks
 		p.print(_Interface)
-		if len(n.MethodList) > 0 && p.linebreaks {
+		if multiLine {
 			p.print(blank)
 		}
 		p.print(_Lbrace)
-		if len(n.MethodList) > 0 {
-			if p.linebreaks {
-				p.print(newline, indent)
-				p.printMethodList(n.MethodList)
-				p.print(outdent, newline)
-			} else {
-				p.printMethodList(n.MethodList)
+		if multiLine {
+			p.print(newline, indent)
+		}
+		if len(types) > 0 {
+			p.print(_Type, blank)
+			p.printExprList(types)
+			if len(methods) > 0 {
+				p.print(_Semi, blank)
 			}
 		}
+		if len(methods) > 0 {
+			p.printMethodList(methods)
+		}
+		if multiLine {
+			p.print(outdent, newline)
+		}
 		p.print(_Rbrace)
 
 	case *MapType:
@@ -667,7 +687,13 @@ func (p *printer) printRawNode(n Node) {
 		if n.Group == nil {
 			p.print(_Type, blank)
 		}
-		p.print(n.Name, blank)
+		p.print(n.Name)
+		if n.TParamList != nil {
+			p.print(_Lbrack)
+			p.printFieldList(n.TParamList, nil, _Comma)
+			p.print(_Rbrack)
+		}
+		p.print(blank)
 		if n.Alias {
 			p.print(_Assign, blank)
 		}
@@ -696,6 +722,11 @@ func (p *printer) printRawNode(n Node) {
 			p.print(_Rparen, blank)
 		}
 		p.print(n.Name)
+		if n.TParamList != nil {
+			p.print(_Lbrack)
+			p.printFieldList(n.TParamList, nil, _Comma)
+			p.print(_Rbrack)
+		}
 		p.printSignature(n.Type)
 		if n.Body != nil {
 			p.print(blank, n.Body)
@@ -746,14 +777,14 @@ func (p *printer) printFields(fields []*Field, tags []*BasicLit, i, j int) {
 	}
 }
 
-func (p *printer) printFieldList(fields []*Field, tags []*BasicLit) {
+func (p *printer) printFieldList(fields []*Field, tags []*BasicLit, sep token) {
 	i0 := 0
 	var typ Expr
 	for i, f := range fields {
 		if f.Name == nil || f.Type != typ {
 			if i0 < i {
 				p.printFields(fields, tags, i0, i)
-				p.print(_Semi, newline)
+				p.print(sep, newline)
 				i0 = i
 			}
 			typ = f.Type
diff --git a/src/cmd/compile/internal/syntax/printer_test.go b/src/cmd/compile/internal/syntax/printer_test.go
index bcae815a46..4890327595 100644
--- a/src/cmd/compile/internal/syntax/printer_test.go
+++ b/src/cmd/compile/internal/syntax/printer_test.go
@@ -61,6 +61,21 @@ var stringTests = []string{
 	"package p",
 	"package p; type _ int; type T1 = struct{}; type ( _ *struct{}; T2 = float32 )",
 
+	// generic type declarations
+	"package p; type _[T any] struct{}",
+	"package p; type _[A, B, C interface{m()}] struct{}",
+	"package p; type _[T any, A, B, C interface{m()}, X, Y, Z interface{type int}] struct{}",
+
+	// generic function declarations
+	"package p; func _[T any]()",
+	"package p; func _[A, B, C interface{m()}]()",
+	"package p; func _[T any, A, B, C interface{m()}, X, Y, Z interface{type int}]()",
+
+	// methods with generic receiver types
+	"package p; func (R[T]) _()",
+	"package p; func (*R[A, B, C]) _()",
+	"package p; func (_ *R[A, B, C]) _()",
+
 	// channels
 	"package p; type _ chan chan int",
 	"package p; type _ chan (<-chan int)",
@@ -79,7 +94,7 @@ var stringTests = []string{
 
 func TestPrintString(t *testing.T) {
 	for _, want := range stringTests {
-		ast, err := Parse(nil, strings.NewReader(want), nil, nil, 0)
+		ast, err := Parse(nil, strings.NewReader(want), nil, nil, AllowGenerics)
 		if err != nil {
 			t.Error(err)
 			continue
@@ -116,6 +131,24 @@ var exprTests = [][2]string{
 	{"func(x int) complex128 { return 0 }", "func(x int) complex128 {…}"},
 	{"[]int{1, 2, 3}", "[]int{…}"},
 
+	// type expressions
+	dup("[1 << 10]byte"),
+	dup("[]int"),
+	dup("*int"),
+	dup("struct{x int}"),
+	dup("func()"),
+	dup("func(int, float32) string"),
+	dup("interface{m()}"),
+	dup("interface{m() string; n(x int)}"),
+	dup("interface{type int}"),
+	dup("interface{type int, float64, string}"),
+	dup("interface{type int; m()}"),
+	dup("interface{type int, float64, string; m() string; n(x int)}"),
+	dup("map[string]int"),
+	dup("chan E"),
+	dup("<-chan E"),
+	dup("chan<- E"),
+
 	// non-type expressions
 	dup("(x)"),
 	dup("x.f"),
@@ -172,7 +205,7 @@ var exprTests = [][2]string{
 func TestShortString(t *testing.T) {
 	for _, test := range exprTests {
 		src := "package p; var _ = " + test[0]
-		ast, err := Parse(nil, strings.NewReader(src), nil, nil, 0)
+		ast, err := Parse(nil, strings.NewReader(src), nil, nil, AllowGenerics)
 		if err != nil {
 			t.Errorf("%s: %s", test[0], err)
 			continue
-- 
GitLab


From b87e9b9f68f1eb0d685fd250b3b47495710e0059 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Thu, 4 Mar 2021 10:35:17 -0500
Subject: [PATCH 0935/2400] cmd/go: clarify errors for commands run outside a
 module

The new error message tells the user what was wrong (no go.mod found)
and directs them to 'go help modules', which links to tutorials.

Fixes #44745

Change-Id: I98f31fec4a8757eb1792b45491519da4c552cb0f
Reviewed-on: https://go-review.googlesource.com/c/go/+/298650
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go/internal/modget/query.go           |  2 +-
 src/cmd/go/internal/modload/import.go         | 18 ++++---
 src/cmd/go/internal/modload/init.go           |  6 ++-
 src/cmd/go/internal/modload/list.go           |  2 +-
 src/cmd/go/internal/run/run.go                | 20 +------
 .../go/testdata/script/mod_convert_dep.txt    |  2 +-
 src/cmd/go/testdata/script/mod_find.txt       |  2 +-
 src/cmd/go/testdata/script/mod_outside.txt    | 52 +++++++++----------
 src/go/build/build_test.go                    |  2 +-
 9 files changed, 47 insertions(+), 59 deletions(-)

diff --git a/src/cmd/go/internal/modget/query.go b/src/cmd/go/internal/modget/query.go
index d8364c8c0d..1a5a60f7eb 100644
--- a/src/cmd/go/internal/modget/query.go
+++ b/src/cmd/go/internal/modget/query.go
@@ -186,7 +186,7 @@ func (q *query) validate() error {
 	if q.pattern == "all" {
 		// If there is no main module, "all" is not meaningful.
 		if !modload.HasModRoot() {
-			return fmt.Errorf(`cannot match "all": working directory is not part of a module`)
+			return fmt.Errorf(`cannot match "all": %v`, modload.ErrNoModRoot)
 		}
 		if !versionOkForMainModule(q.version) {
 			// TODO(bcmills): "all@none" seems like a totally reasonable way to
diff --git a/src/cmd/go/internal/modload/import.go b/src/cmd/go/internal/modload/import.go
index 182429aee4..995641c9f1 100644
--- a/src/cmd/go/internal/modload/import.go
+++ b/src/cmd/go/internal/modload/import.go
@@ -51,7 +51,7 @@ func (e *ImportMissingError) Error() string {
 		if e.isStd {
 			return fmt.Sprintf("package %s is not in GOROOT (%s)", e.Path, filepath.Join(cfg.GOROOT, "src", e.Path))
 		}
-		if e.QueryErr != nil {
+		if e.QueryErr != nil && e.QueryErr != ErrNoModRoot {
 			return fmt.Sprintf("cannot find module providing package %s: %v", e.Path, e.QueryErr)
 		}
 		if cfg.BuildMod == "mod" || (cfg.BuildMod == "readonly" && allowMissingModuleImports) {
@@ -66,13 +66,11 @@ func (e *ImportMissingError) Error() string {
 			return fmt.Sprintf("module %s provides package %s and is replaced but not required; to add it:\n\tgo get %s", e.replaced.Path, e.Path, suggestArg)
 		}
 
-		suggestion := ""
-		if !HasModRoot() {
-			suggestion = ": working directory is not part of a module"
-		} else {
-			suggestion = fmt.Sprintf("; to add it:\n\tgo get %s", e.Path)
+		message := fmt.Sprintf("no required module provides package %s", e.Path)
+		if e.QueryErr != nil {
+			return fmt.Sprintf("%s: %v", message, e.QueryErr)
 		}
-		return fmt.Sprintf("no required module provides package %s%s", e.Path, suggestion)
+		return fmt.Sprintf("%s; to add it:\n\tgo get %s", message, e.Path)
 	}
 
 	if e.newMissingVersion != "" {
@@ -318,7 +316,11 @@ func importFromBuildList(ctx context.Context, path string, buildList []module.Ve
 		return mods[0], dirs[0], nil
 	}
 
-	return module.Version{}, "", &ImportMissingError{Path: path, isStd: pathIsStd}
+	var queryErr error
+	if !HasModRoot() {
+		queryErr = ErrNoModRoot
+	}
+	return module.Version{}, "", &ImportMissingError{Path: path, QueryErr: queryErr, isStd: pathIsStd}
 }
 
 // queryImport attempts to locate a module that can be added to the current
diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index 4de5ac9303..8ec1c8681a 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -177,7 +177,7 @@ func Init() {
 				base.Fatalf("go: cannot find main module, but -modfile was set.\n\t-modfile cannot be used to set the module root directory.")
 			}
 			if RootMode == NeedRoot {
-				base.Fatalf("go: cannot find main module; see 'go help modules'")
+				base.Fatalf("go: %v", ErrNoModRoot)
 			}
 			if !mustUseModules {
 				// GO111MODULE is 'auto', and we can't find a module root.
@@ -338,9 +338,11 @@ func die() {
 		}
 		base.Fatalf("go: cannot find main module, but found %s in %s\n\tto create a module there, run:\n\t%sgo mod init", name, dir, cdCmd)
 	}
-	base.Fatalf("go: cannot find main module; see 'go help modules'")
+	base.Fatalf("go: %v", ErrNoModRoot)
 }
 
+var ErrNoModRoot = errors.New("go.mod file not found in current directory or any parent directory; see 'go help modules'")
+
 // LoadModFile sets Target and, if there is a main module, parses the initial
 // build list from its go.mod file.
 //
diff --git a/src/cmd/go/internal/modload/list.go b/src/cmd/go/internal/modload/list.go
index 6dba6bea22..c7ef8c9fb7 100644
--- a/src/cmd/go/internal/modload/list.go
+++ b/src/cmd/go/internal/modload/list.go
@@ -73,7 +73,7 @@ func listModules(ctx context.Context, args []string, listVersions, listRetracted
 			base.Fatalf("go: cannot use relative path %s to specify module", arg)
 		}
 		if !HasModRoot() && (arg == "all" || strings.Contains(arg, "...")) {
-			base.Fatalf("go: cannot match %q: working directory is not part of a module", arg)
+			base.Fatalf("go: cannot match %q: %v", arg, ErrNoModRoot)
 		}
 		if i := strings.Index(arg, "@"); i >= 0 {
 			path := arg[:i]
diff --git a/src/cmd/go/internal/run/run.go b/src/cmd/go/internal/run/run.go
index 99578b244c..666b1a0e56 100644
--- a/src/cmd/go/internal/run/run.go
+++ b/src/cmd/go/internal/run/run.go
@@ -96,28 +96,12 @@ func runRun(ctx context.Context, cmd *base.Command, args []string) {
 		base.Fatalf("go run: no go files listed")
 	}
 	cmdArgs := args[i:]
-	if p.Error != nil {
-		base.Fatalf("%s", p.Error)
-	}
+	load.CheckPackageErrors([]*load.Package{p})
 
-	p.Internal.OmitDebug = true
-	if len(p.DepsErrors) > 0 {
-		// Since these are errors in dependencies,
-		// the same error might show up multiple times,
-		// once in each package that depends on it.
-		// Only print each once.
-		printed := map[*load.PackageError]bool{}
-		for _, err := range p.DepsErrors {
-			if !printed[err] {
-				printed[err] = true
-				base.Errorf("%s", err)
-			}
-		}
-	}
-	base.ExitIfErrors()
 	if p.Name != "main" {
 		base.Fatalf("go run: cannot run non-main package")
 	}
+	p.Internal.OmitDebug = true
 	p.Target = "" // must build - not up to date
 	if p.Internal.CmdlineFiles {
 		//set executable name if go file is given as cmd-argument
diff --git a/src/cmd/go/testdata/script/mod_convert_dep.txt b/src/cmd/go/testdata/script/mod_convert_dep.txt
index ad22aca5be..875a836fd2 100644
--- a/src/cmd/go/testdata/script/mod_convert_dep.txt
+++ b/src/cmd/go/testdata/script/mod_convert_dep.txt
@@ -18,7 +18,7 @@ stdout '^m$'
 # Test that we ignore directories when trying to find alternate config files.
 cd $WORK/gopkgdir/x
 ! go list .
-stderr 'cannot find main module'
+stderr '^go: go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 ! stderr 'Gopkg.lock'
 
 -- $WORK/test/Gopkg.lock --
diff --git a/src/cmd/go/testdata/script/mod_find.txt b/src/cmd/go/testdata/script/mod_find.txt
index 9468acfd33..1e01973ff4 100644
--- a/src/cmd/go/testdata/script/mod_find.txt
+++ b/src/cmd/go/testdata/script/mod_find.txt
@@ -49,7 +49,7 @@ rm go.mod
 # Test that we ignore directories when trying to find go.mod.
 cd $WORK/gomoddir
 ! go list .
-stderr 'cannot find main module'
+stderr '^go: go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 
 [!symlink] stop
 
diff --git a/src/cmd/go/testdata/script/mod_outside.txt b/src/cmd/go/testdata/script/mod_outside.txt
index 7b45f1a209..9d4c22c77b 100644
--- a/src/cmd/go/testdata/script/mod_outside.txt
+++ b/src/cmd/go/testdata/script/mod_outside.txt
@@ -12,13 +12,13 @@ stdout 'NUL|/dev/null'
 # 'go list' without arguments implicitly operates on the current directory,
 # which is not in a module.
 ! go list
-stderr 'cannot find main module'
+stderr '^go: go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 go list -m
 stdout '^command-line-arguments$'
 # 'go list' in the working directory should fail even if there is a a 'package
 # main' present: without a main module, we do not know its package path.
 ! go list ./needmod
-stderr 'cannot find main module'
+stderr '^go: go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 
 # 'go list all' lists the transitive import graph of the main module,
 # which is empty if there is no main module.
@@ -41,7 +41,7 @@ stdout 'command-line-arguments'
 
 # 'go list' on a package from a module should fail.
 ! go list example.com/printversion
-stderr '^no required module provides package example.com/printversion: working directory is not part of a module$'
+stderr '^no required module provides package example.com/printversion: go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 
 
 # 'go list -m' with an explicit version should resolve that version.
@@ -54,19 +54,19 @@ stdout 'v1.0.0\s+v1.0.1\s+v1.1.0'
 
 # 'go list -m all' should fail. "all" is not meaningful outside of a module.
 ! go list -m all
-stderr 'go: cannot match "all": working directory is not part of a module'
+stderr 'go: cannot match "all": go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 
 # 'go list -m <mods> all' should also fail.
 ! go list -m example.com/printversion@v1.0.0 all
-stderr 'go: cannot match "all": working directory is not part of a module'
+stderr 'go: cannot match "all": go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 ! stdout 'example.com/version'
 
 # 'go list -m' with wildcards should fail. Wildcards match modules in the
 # build list, so they aren't meaningful outside a module.
 ! go list -m ...
-stderr 'go: cannot match "...": working directory is not part of a module'
+stderr 'go: cannot match "...": go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 ! go list -m rsc.io/quote/...
-stderr 'go: cannot match "rsc.io/quote/...": working directory is not part of a module'
+stderr 'go: cannot match "rsc.io/quote/...": go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 
 
 # 'go clean' should skip the current directory if it isn't in a module.
@@ -76,20 +76,20 @@ go clean -n
 
 # 'go mod graph' should fail, since there's no module graph.
 ! go mod graph
-stderr 'cannot find main module'
+stderr '^go: go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 
 # 'go mod why' should fail, since there is no main module to depend on anything.
 ! go mod why -m example.com/version
-stderr 'cannot find main module'
+stderr '^go: go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 
 # 'go mod edit', 'go mod tidy', and 'go mod fmt' should fail:
 # there is no go.mod file to edit.
 ! go mod tidy
-stderr 'cannot find main module'
+stderr '^go: go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 ! go mod edit -fmt
-stderr 'cannot find main module'
+stderr '^go: go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 ! go mod edit -require example.com/version@v1.0.0
-stderr 'cannot find main module'
+stderr '^go: go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 
 
 # 'go mod download' without arguments should report an error.
@@ -104,33 +104,33 @@ exists $GOPATH/pkg/mod/cache/download/example.com/printversion/@v/v1.0.0.zip
 
 # 'go mod download all' should fail. "all" is not meaningful outside of a module.
 ! go mod download all
-stderr 'go: cannot match "all": working directory is not part of a module'
+stderr 'go: cannot match "all": go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 
 
 # 'go mod vendor' should fail: it starts by clearing the existing vendor
 # directory, and we don't know where that is.
 ! go mod vendor
-stderr 'cannot find main module'
+stderr '^go: go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 
 
 # 'go mod verify' should fail: we have no modules to verify.
 ! go mod verify
-stderr 'cannot find main module'
+stderr '^go: go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 
 
 # 'go get' without arguments implicitly operates on the main module, and thus
 # should fail.
 ! go get
-stderr 'cannot find main module'
+stderr '^go: go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 ! go get -u
-stderr 'cannot find main module'
+stderr '^go: go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 ! go get -u ./needmod
-stderr 'cannot find main module'
+stderr '^go: go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 
 # 'go get -u all' upgrades the transitive import graph of the main module,
 # which is empty.
 ! go get -u all
-stderr 'go get: cannot match "all": working directory is not part of a module'
+stderr '^go get: cannot match "all": go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 
 # 'go get' should check the proposed module graph for consistency,
 # even though we won't write it anywhere.
@@ -147,16 +147,16 @@ exists $GOPATH/pkg/mod/example.com/version@v1.0.0
 # 'go build' without arguments implicitly operates on the current directory, and should fail.
 cd needmod
 ! go build
-stderr 'cannot find main module'
+stderr '^go: go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 cd ..
 
 # 'go build' of a non-module directory should fail too.
 ! go build ./needmod
-stderr 'cannot find main module'
+stderr '^go: go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 
 # 'go build' of source files should fail if they import anything outside std.
 ! go build -n ./needmod/needmod.go
-stderr '^needmod[/\\]needmod.go:10:2: no required module provides package example.com/version: working directory is not part of a module$'
+stderr '^needmod[/\\]needmod.go:10:2: no required module provides package example.com/version: go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 
 # 'go build' of source files should succeed if they do not import anything outside std.
 go build -n -o ignore ./stdonly/stdonly.go
@@ -179,7 +179,7 @@ go doc fmt
 
 # 'go doc' should fail for a package path outside a module.
 ! go doc example.com/version
-stderr 'doc: no required module provides package example.com/version: working directory is not part of a module'
+stderr 'doc: no required module provides package example.com/version: go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 
 # 'go install' with a version should succeed if all constraints are met.
 # See mod_install_pkg_version.
@@ -194,7 +194,7 @@ stderr '^go install: version is required when current directory is not in a modu
 # 'go install' should fail if a source file imports a package that must be
 # resolved to a module.
 ! go install ./needmod/needmod.go
-stderr 'needmod[/\\]needmod.go:10:2: no required module provides package example.com/version: working directory is not part of a module'
+stderr 'needmod[/\\]needmod.go:10:2: no required module provides package example.com/version: go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 
 # 'go install' should succeed with a package in GOROOT.
 go install cmd/addr2line
@@ -206,12 +206,12 @@ stderr 'can only use path@version syntax with'
 
 # 'go run' should fail if a package argument must be resolved to a module.
 ! go run example.com/printversion
-stderr '^no required module provides package example.com/printversion: working directory is not part of a module$'
+stderr '^no required module provides package example.com/printversion: go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 
 # 'go run' should fail if a source file imports a package that must be
 # resolved to a module.
 ! go run ./needmod/needmod.go
-stderr '^needmod[/\\]needmod.go:10:2: no required module provides package example.com/version: working directory is not part of a module$'
+stderr '^needmod[/\\]needmod.go:10:2: no required module provides package example.com/version: go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 
 
 # 'go fmt' should be able to format files outside of a module.
diff --git a/src/go/build/build_test.go b/src/go/build/build_test.go
index 0762a150eb..6529b6e47e 100644
--- a/src/go/build/build_test.go
+++ b/src/go/build/build_test.go
@@ -644,7 +644,7 @@ func TestImportPackageOutsideModule(t *testing.T) {
 	ctxt.GOPATH = gopath
 	ctxt.Dir = filepath.Join(gopath, "src/example.com/p")
 
-	want := "working directory is not part of a module"
+	want := "go.mod file not found in current directory or any parent directory"
 	if _, err := ctxt.Import("example.com/p", gopath, FindOnly); err == nil {
 		t.Fatal("importing package when no go.mod is present succeeded unexpectedly")
 	} else if errStr := err.Error(); !strings.Contains(errStr, want) {
-- 
GitLab


From 56d52e661114be60fb1893b034ac0c5976b622af Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Thu, 4 Mar 2021 11:50:31 -0500
Subject: [PATCH 0936/2400] cmd/go: don't report missing std import errors for
 tidy and vendor

'go mod tidy' and 'go mod vendor' normally report errors when a
package can't be imported, even if the import appears in a file that
wouldn't be compiled by the current version of Go. These errors are
common for packages introduced in higher versions of Go, like "embed"
in 1.16.

This change causes 'go mod tidy' and 'go mod vendor' to ignore
missing package errors if the import path appears to come from the
standard library because it lacks a dot in the first path element.

Fixes #44557
Updates #27063

Change-Id: I61d6443e77ab95fd8c0d1514f57ef4c8885a77cc
Reviewed-on: https://go-review.googlesource.com/c/go/+/298749
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/internal/modcmd/tidy.go            |  1 +
 src/cmd/go/internal/modcmd/vendor.go          |  1 +
 src/cmd/go/internal/modload/load.go           | 13 ++++++++++++-
 src/cmd/go/testdata/script/mod_tidy_error.txt |  4 ++--
 4 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/src/cmd/go/internal/modcmd/tidy.go b/src/cmd/go/internal/modcmd/tidy.go
index e7e63e6533..34ff86ff18 100644
--- a/src/cmd/go/internal/modcmd/tidy.go
+++ b/src/cmd/go/internal/modcmd/tidy.go
@@ -67,6 +67,7 @@ func runTidy(ctx context.Context, cmd *base.Command, args []string) {
 		ResolveMissingImports:    true,
 		LoadTests:                true,
 		AllowErrors:              tidyE,
+		SilenceMissingStdImports: true,
 	}, "all")
 
 	modload.TidyBuildList()
diff --git a/src/cmd/go/internal/modcmd/vendor.go b/src/cmd/go/internal/modcmd/vendor.go
index 2cd683b75c..6ebc18dcd8 100644
--- a/src/cmd/go/internal/modcmd/vendor.go
+++ b/src/cmd/go/internal/modcmd/vendor.go
@@ -69,6 +69,7 @@ func runVendor(ctx context.Context, cmd *base.Command, args []string) {
 		ResolveMissingImports:    true,
 		UseVendorAll:             true,
 		AllowErrors:              vendorE,
+		SilenceMissingStdImports: true,
 	}
 	_, pkgs := modload.LoadPackages(ctx, loadOpts, "all")
 
diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index 0dba49e40e..2e62a7659f 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -175,6 +175,12 @@ type PackageOpts struct {
 	// that occur while loading packages. SilenceErrors implies AllowErrors.
 	SilenceErrors bool
 
+	// SilenceMissingStdImports indicates that LoadPackages should not print
+	// errors or terminate the process if an imported package is missing, and the
+	// import path looks like it might be in the standard library (perhaps in a
+	// future version).
+	SilenceMissingStdImports bool
+
 	// SilenceUnmatchedWarnings suppresses the warnings normally emitted for
 	// patterns that did not match any packages.
 	SilenceUnmatchedWarnings bool
@@ -292,8 +298,13 @@ func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (ma
 					sumErr.importerIsTest = importer.testOf != nil
 				}
 			}
+			silence := opts.SilenceErrors
+			if stdErr := (*ImportMissingError)(nil); errors.As(pkg.err, &stdErr) &&
+				stdErr.isStd && opts.SilenceMissingStdImports {
+				silence = true
+			}
 
-			if !opts.SilenceErrors {
+			if !silence {
 				if opts.AllowErrors {
 					fmt.Fprintf(os.Stderr, "%s: %v\n", pkg.stackText(), pkg.err)
 				} else {
diff --git a/src/cmd/go/testdata/script/mod_tidy_error.txt b/src/cmd/go/testdata/script/mod_tidy_error.txt
index b6c24ceaf7..395537b1a7 100644
--- a/src/cmd/go/testdata/script/mod_tidy_error.txt
+++ b/src/cmd/go/testdata/script/mod_tidy_error.txt
@@ -4,12 +4,12 @@ env GO111MODULE=on
 # 'go mod tidy' and 'go mod vendor' should not hide loading errors.
 
 ! go mod tidy
-stderr '^issue27063 imports\n\tnonexist: package nonexist is not in GOROOT \(.*\)'
+! stderr 'package nonexist is not in GOROOT'
 stderr '^issue27063 imports\n\tnonexist.example.com: cannot find module providing package nonexist.example.com'
 stderr '^issue27063 imports\n\tissue27063/other imports\n\tother.example.com/nonexist: cannot find module providing package other.example.com/nonexist'
 
 ! go mod vendor
-stderr '^issue27063 imports\n\tnonexist: package nonexist is not in GOROOT \(.*\)'
+! stderr 'package nonexist is not in GOROOT'
 stderr '^issue27063 imports\n\tnonexist.example.com: cannot find module providing package nonexist.example.com'
 stderr '^issue27063 imports\n\tissue27063/other imports\n\tother.example.com/nonexist: cannot find module providing package other.example.com/nonexist'
 
-- 
GitLab


From 5c5552c5bab55c7233cc0cc105876a982ec25b74 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Wed, 24 Feb 2021 12:58:01 -0500
Subject: [PATCH 0937/2400] cmd/compile: add register abi tests

Change-Id: I4b2b62a8eb1c4bf47f552214127d4ed5710af196
Reviewed-on: https://go-review.googlesource.com/c/go/+/297030
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 test/abi/f_ret_z_not.go            |  6 ++
 test/abi/many_int_input.go         |  3 +
 test/abi/many_intstar_input.go     | 45 ++++++++++++++
 test/abi/many_intstar_input.out    |  3 +
 test/abi/more_intstar_input.go     | 44 ++++++++++++++
 test/abi/more_intstar_input.out    |  2 +
 test/abi/named_return_stuff.go     | 94 ++++++++++++++++++++++++++++++
 test/abi/named_return_stuff.out    | 13 +++++
 test/abi/return_stuff.go           | 38 ++++++++++++
 test/abi/return_stuff.out          |  3 +
 test/abi/struct_3_string_input.go  | 40 +++++++++++++
 test/abi/struct_3_string_input.out |  0
 test/abi/uglyfib.go                |  3 +
 13 files changed, 294 insertions(+)
 create mode 100644 test/abi/many_intstar_input.go
 create mode 100644 test/abi/many_intstar_input.out
 create mode 100644 test/abi/more_intstar_input.go
 create mode 100644 test/abi/more_intstar_input.out
 create mode 100644 test/abi/named_return_stuff.go
 create mode 100644 test/abi/named_return_stuff.out
 create mode 100644 test/abi/return_stuff.go
 create mode 100644 test/abi/return_stuff.out
 create mode 100644 test/abi/struct_3_string_input.go
 create mode 100644 test/abi/struct_3_string_input.out

diff --git a/test/abi/f_ret_z_not.go b/test/abi/f_ret_z_not.go
index d890223ff7..63d6c7918f 100644
--- a/test/abi/f_ret_z_not.go
+++ b/test/abi/f_ret_z_not.go
@@ -1,9 +1,15 @@
 // run
 
+//go:build !wasm
+// +build !wasm
+
 // Copyright 2021 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.
 
+// wasm is excluded because the compiler chatter about register abi pragma ends up
+// on stdout, and causes the expected output to not match.
+
 package main
 
 import "fmt"
diff --git a/test/abi/many_int_input.go b/test/abi/many_int_input.go
index 6c3332f842..8fda937932 100644
--- a/test/abi/many_int_input.go
+++ b/test/abi/many_int_input.go
@@ -7,6 +7,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// wasm is excluded because the compiler chatter about register abi pragma ends up
+// on stdout, and causes the expected output to not match.
+
 package main
 
 import (
diff --git a/test/abi/many_intstar_input.go b/test/abi/many_intstar_input.go
new file mode 100644
index 0000000000..b209c801ba
--- /dev/null
+++ b/test/abi/many_intstar_input.go
@@ -0,0 +1,45 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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.
+
+// wasm is excluded because the compiler chatter about register abi pragma ends up
+// on stdout, and causes the expected output to not match.
+
+package main
+
+import (
+	"fmt"
+)
+
+var sink int = 3
+
+//go:registerparams
+//go:noinline
+func F(a, b, c, d, e, f *int) {
+	G(f, e, d, c, b, a)
+	sink += *a // *a == 6 after swapping in G
+}
+
+//go:registerparams
+//go:noinline
+func G(a, b, c, d, e, f *int) {
+	var scratch [1000 * 100]int
+	scratch[*a] = *f                    // scratch[6] = 1
+	fmt.Println(*a, *b, *c, *d, *e, *f) // Forces it to spill b
+	sink = scratch[*b+1]                // scratch[5+1] == 1
+	*f, *a = *a, *f
+	*e, *b = *b, *e
+	*d, *c = *c, *d
+}
+
+func main() {
+	a, b, c, d, e, f := 1, 2, 3, 4, 5, 6
+	F(&a, &b, &c, &d, &e, &f)
+	fmt.Println(a, b, c, d, e, f)
+	fmt.Println(sink)
+}
diff --git a/test/abi/many_intstar_input.out b/test/abi/many_intstar_input.out
new file mode 100644
index 0000000000..0a37ccbec7
--- /dev/null
+++ b/test/abi/many_intstar_input.out
@@ -0,0 +1,3 @@
+6 5 4 3 2 1
+6 5 4 3 2 1
+7
diff --git a/test/abi/more_intstar_input.go b/test/abi/more_intstar_input.go
new file mode 100644
index 0000000000..f0a48fbdc2
--- /dev/null
+++ b/test/abi/more_intstar_input.go
@@ -0,0 +1,44 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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.
+
+// wasm is excluded because the compiler chatter about register abi pragma ends up
+// on stdout, and causes the expected output to not match.
+
+package main
+
+import (
+	"fmt"
+)
+
+var sink int
+
+//go:registerparams
+//go:noinline
+func F(a, b, c, d, e, f, g, h, i, j, k, l, m *int) {
+	G(m, l, k, j, i, h, g, f, e, d, c, b, a)
+	// did the pointers get properly updated?
+	sink = *a + *m
+}
+
+//go:registerparams
+//go:noinline
+func G(a, b, c, d, e, f, g, h, i, j, k, l, m *int) {
+	// Do not reference the parameters
+	var scratch [1000 * 100]int
+	I := *c - *e - *l // zero.
+	scratch[I] = *d
+	fmt.Println("Got this far!")
+	sink += scratch[0]
+}
+
+func main() {
+	a, b, c, d, e, f, g, h, i, j, k, l, m := 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13
+	F(&a, &b, &c, &d, &e, &f, &g, &h, &i, &j, &k, &l, &m)
+	fmt.Printf("Sink = %d\n", sink-7)
+}
diff --git a/test/abi/more_intstar_input.out b/test/abi/more_intstar_input.out
new file mode 100644
index 0000000000..2ab84bfa8c
--- /dev/null
+++ b/test/abi/more_intstar_input.out
@@ -0,0 +1,2 @@
+Got this far!
+Sink = 7
diff --git a/test/abi/named_return_stuff.go b/test/abi/named_return_stuff.go
new file mode 100644
index 0000000000..faa0221a3c
--- /dev/null
+++ b/test/abi/named_return_stuff.go
@@ -0,0 +1,94 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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.
+
+// wasm is excluded because the compiler chatter about register abi pragma ends up
+// on stdout, and causes the expected output to not match.
+
+package main
+
+import (
+	"fmt"
+)
+
+var sink *string
+
+var y int
+
+//go:registerparams
+//go:noinline
+func F(a, b, c *int) (x int) {
+	x = *a
+	G(&x)
+	x += *b
+	G(&x)
+	x += *c
+	G(&x)
+	return
+}
+
+//go:registerparams
+//go:noinline
+func G(x *int) {
+	y += *x
+	fmt.Println("y = ", y)
+}
+
+//go:registerparams
+//go:noinline
+func X() {
+	*sink += " !!!!!!!!!!!!!!!"
+}
+
+//go:registerparams
+//go:noinline
+func H(s, t string) (result string) { // result leaks to heap
+	result = "Aloha! " + s + " " + t
+	sink = &result
+	r := ""
+	if len(s) <= len(t) {
+		r = "OKAY! "
+		X()
+	}
+	return r + result
+}
+
+//go:registerparams
+//go:noinline
+func K(s, t string) (result string) { // result spills
+	result = "Aloha! " + s + " " + t
+	r := ""
+	if len(s) <= len(t) {
+		r = "OKAY! "
+		X()
+	}
+	return r + result
+}
+
+func main() {
+	a, b, c := 1, 4, 16
+	x := F(&a, &b, &c)
+	fmt.Printf("x = %d\n", x)
+
+	y := H("Hello", "World!")
+	fmt.Println("len(y) =", len(y))
+	fmt.Println("y =", y)
+	z := H("Hello", "Pal!")
+	fmt.Println("len(z) =", len(z))
+	fmt.Println("z =", z)
+
+	fmt.Println()
+
+	y = K("Hello", "World!")
+	fmt.Println("len(y) =", len(y))
+	fmt.Println("y =", y)
+	z = K("Hello", "Pal!")
+	fmt.Println("len(z) =", len(z))
+	fmt.Println("z =", z)
+
+}
diff --git a/test/abi/named_return_stuff.out b/test/abi/named_return_stuff.out
new file mode 100644
index 0000000000..02f12e806d
--- /dev/null
+++ b/test/abi/named_return_stuff.out
@@ -0,0 +1,13 @@
+y =  1
+y =  6
+y =  27
+x = 21
+len(y) = 41
+y = OKAY! Aloha! Hello World! !!!!!!!!!!!!!!!
+len(z) = 17
+z = Aloha! Hello Pal!
+
+len(y) = 25
+y = OKAY! Aloha! Hello World!
+len(z) = 17
+z = Aloha! Hello Pal!
diff --git a/test/abi/return_stuff.go b/test/abi/return_stuff.go
new file mode 100644
index 0000000000..130d8be5c5
--- /dev/null
+++ b/test/abi/return_stuff.go
@@ -0,0 +1,38 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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.
+
+// wasm is excluded because the compiler chatter about register abi pragma ends up
+// on stdout, and causes the expected output to not match.
+
+package main
+
+import (
+	"fmt"
+)
+
+//go:registerparams
+//go:noinline
+func F(a, b, c *int) int {
+	return *a + *b + *c
+}
+
+//go:registerparams
+//go:noinline
+func H(s, t string) string {
+	return s + " " + t
+}
+
+func main() {
+	a, b, c := 1, 4, 16
+	x := F(&a, &b, &c)
+	fmt.Printf("x = %d\n", x)
+	y := H("Hello", "World!")
+	fmt.Println("len(y) =", len(y))
+	fmt.Println("y =", y)
+}
diff --git a/test/abi/return_stuff.out b/test/abi/return_stuff.out
new file mode 100644
index 0000000000..5f519d7b99
--- /dev/null
+++ b/test/abi/return_stuff.out
@@ -0,0 +1,3 @@
+x = 21
+len(y) = 12
+y = Hello World!
diff --git a/test/abi/struct_3_string_input.go b/test/abi/struct_3_string_input.go
new file mode 100644
index 0000000000..54a8b38af9
--- /dev/null
+++ b/test/abi/struct_3_string_input.go
@@ -0,0 +1,40 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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.
+
+// wasm is excluded because the compiler chatter about register abi pragma ends up
+// on stdout, and causes the expected output to not match.
+
+package main
+
+import (
+	"fmt"
+)
+
+var sink *string
+
+type toobig struct {
+	a, b, c string
+}
+
+//go:registerparams
+//go:noinline
+func H(x toobig) string {
+	return x.a + " " + x.b + " " + x.c
+}
+
+func main() {
+	s := H(toobig{"Hello", "there,", "World"})
+	gotVsWant(s, "Hello there, World")
+}
+
+func gotVsWant(got, want string) {
+	if got != want {
+		fmt.Printf("FAIL, got %s, wanted %s\n", got, want)
+	}
+}
diff --git a/test/abi/struct_3_string_input.out b/test/abi/struct_3_string_input.out
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/test/abi/uglyfib.go b/test/abi/uglyfib.go
index bde3548bee..b8e8739f30 100644
--- a/test/abi/uglyfib.go
+++ b/test/abi/uglyfib.go
@@ -7,6 +7,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// wasm is excluded because the compiler chatter about register abi pragma ends up
+// on stdout, and causes the expected output to not match.
+
 package main
 
 import "fmt"
-- 
GitLab


From d6504b80973a22edbb5045e98c53901776101d18 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Sat, 27 Feb 2021 17:11:36 -0500
Subject: [PATCH 0938/2400] cmd/compile: tweak offset-generator to elide more
 +0 offsets

this caused a problem in write barrier code when a spurious
zero-offset prevented a write barrier elision.

removed cache after instrumenting it and discovering
zero safe hits (one value must dominate the other, else
unsafe).

Change-Id: I42dfdb4d38ebfe158b13e766a7fabfc514d773f7
Reviewed-on: https://go-review.googlesource.com/c/go/+/297349
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/expand_calls.go | 42 ++++++++------------
 1 file changed, 17 insertions(+), 25 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index fd8ae30caf..03b2a98fce 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -20,12 +20,6 @@ type selKey struct {
 	typ           *types.Type
 }
 
-type offsetKey struct {
-	from   *Value
-	offset int64
-	pt     *types.Type
-}
-
 type Abi1RO uint8 // An offset within a parameter's slice of register indices, for abi1.
 
 func isBlockMultiValueExit(b *Block) bool {
@@ -194,8 +188,7 @@ type expandState struct {
 	sdom            SparseTree
 	commonSelectors map[selKey]*Value // used to de-dupe selectors
 	commonArgs      map[selKey]*Value // used to de-dupe OpArg/OpArgIntReg/OpArgFloatReg
-	offsets         map[offsetKey]*Value
-	memForCall      map[ID]*Value // For a call, need to know the unique selector that gets the mem.
+	memForCall      map[ID]*Value     // For a call, need to know the unique selector that gets the mem.
 }
 
 // intPairTypes returns the pair of 32-bit int types needed to encode a 64-bit integer type on a target
@@ -223,9 +216,16 @@ func (x *expandState) isAlreadyExpandedAggregateType(t *types.Type) bool {
 
 // offsetFrom creates an offset from a pointer, simplifying chained offsets and offsets from SP
 // TODO should also optimize offsets from SB?
-func (x *expandState) offsetFrom(from *Value, offset int64, pt *types.Type) *Value {
-	if offset == 0 && from.Type == pt { // this is not actually likely
-		return from
+func (x *expandState) offsetFrom(b *Block, from *Value, offset int64, pt *types.Type) *Value {
+	ft := from.Type
+	if offset == 0 {
+		if ft == pt {
+			return from
+		}
+		// This captures common, (apparently) safe cases.  The unsafe cases involve ft == uintptr
+		if (ft.IsPtr() || ft.IsUnsafePtr()) && pt.IsPtr() {
+			return from
+		}
 	}
 	// Simplify, canonicalize
 	for from.Op == OpOffPtr {
@@ -235,14 +235,7 @@ func (x *expandState) offsetFrom(from *Value, offset int64, pt *types.Type) *Val
 	if from == x.sp {
 		return x.f.ConstOffPtrSP(pt, offset, x.sp)
 	}
-	key := offsetKey{from, offset, pt}
-	v := x.offsets[key]
-	if v != nil {
-		return v
-	}
-	v = from.Block.NewValue1I(from.Pos.WithNotStmt(), OpOffPtr, pt, offset, from)
-	x.offsets[key] = v
-	return v
+	return b.NewValue1I(from.Pos.WithNotStmt(), OpOffPtr, pt, offset, from)
 }
 
 // splitSlots splits one "field" (specified by sfx, offset, and ty) out of the LocalSlots in ls and returns the new LocalSlots this generates.
@@ -426,7 +419,7 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64,
 						leaf.copyOf(w)
 					}
 				} else {
-					off := x.offsetFrom(x.sp, offset+aux.OffsetOfResult(which), pt)
+					off := x.offsetFrom(x.f.Entry, x.sp, offset+aux.OffsetOfResult(which), pt)
 					if leaf.Block == call.Block {
 						leaf.reset(OpLoad)
 						leaf.SetArgs2(off, call)
@@ -531,7 +524,7 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64,
 
 func (x *expandState) rewriteDereference(b *Block, base, a, mem *Value, offset, size int64, typ *types.Type, pos src.XPos) *Value {
 	source := a.Args[0]
-	dst := x.offsetFrom(base, offset, source.Type)
+	dst := x.offsetFrom(b, base, offset, source.Type)
 	if a.Uses == 1 && a.Block == b {
 		a.reset(OpMove)
 		a.Pos = pos
@@ -624,7 +617,7 @@ func storeOneArg(x *expandState, pos src.XPos, b *Block, source, mem *Value, t *
 
 // storeOneLoad creates a decomposed (one step) load that is then stored.
 func storeOneLoad(x *expandState, pos src.XPos, b *Block, source, mem *Value, t *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
-	from := x.offsetFrom(source.Args[0], offArg, types.NewPtr(t))
+	from := x.offsetFrom(b, source.Args[0], offArg, types.NewPtr(t))
 	w := source.Block.NewValue2(source.Pos, OpLoad, t, from, mem)
 	return x.storeArgOrLoad(pos, b, w, mem, t, offStore, loadRegOffset, storeRc)
 }
@@ -826,7 +819,7 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, source, mem *Value,
 	if storeRc.hasRegs() {
 		storeRc.addArg(source)
 	} else {
-		dst := x.offsetFrom(storeRc.storeDest, offset, types.NewPtr(t))
+		dst := x.offsetFrom(b, storeRc.storeDest, offset, types.NewPtr(t))
 		s = b.NewValue3A(pos, OpStore, types.TypeMem, t, dst, source, mem)
 	}
 	if x.debug {
@@ -904,7 +897,6 @@ func expandCalls(f *Func) {
 		namedSelects: make(map[*Value][]namedVal),
 		sdom:         f.Sdom(),
 		commonArgs:   make(map[selKey]*Value),
-		offsets:      make(map[offsetKey]*Value),
 		memForCall:   make(map[ID]*Value),
 	}
 
@@ -1098,7 +1090,7 @@ func expandCalls(f *Func) {
 				which := v.AuxInt
 				aux := call.Aux.(*AuxCall)
 				pt := v.Type
-				off := x.offsetFrom(x.sp, aux.OffsetOfResult(which), pt)
+				off := x.offsetFrom(x.f.Entry, x.sp, aux.OffsetOfResult(which), pt)
 				v.copyOf(off)
 			}
 		}
-- 
GitLab


From d891ebdce1ac2c72e1d923c24f5a65ec14ba7cf8 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Fri, 26 Feb 2021 14:27:59 -0500
Subject: [PATCH 0939/2400] cmd/compile: return (and receive) medium-large
 results

includes three tests

Change-Id: I33ac0cfe35085d4b6ad2775abcaa3d7d6527b49f
Reviewed-on: https://go-review.googlesource.com/c/go/+/297031
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/expand_calls.go | 80 +++++++++---------
 src/cmd/compile/internal/ssa/op.go           |  9 ++-
 src/cmd/compile/internal/ssagen/ssa.go       | 85 +++++++++++++-------
 test/abi/double_nested_addressed_struct.go   | 62 ++++++++++++++
 test/abi/double_nested_struct.go             | 55 +++++++++++++
 test/abi/too_big_to_ssa.go                   | 47 +++++++++++
 test/abi/too_big_to_ssa.out                  |  2 +
 7 files changed, 264 insertions(+), 76 deletions(-)
 create mode 100644 test/abi/double_nested_addressed_struct.go
 create mode 100644 test/abi/double_nested_struct.go
 create mode 100644 test/abi/too_big_to_ssa.go
 create mode 100644 test/abi/too_big_to_ssa.out

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index 03b2a98fce..df135853fe 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -248,7 +248,7 @@ func (x *expandState) splitSlots(ls []LocalSlot, sfx string, offset int64, ty *t
 }
 
 // prAssignForArg returns the ABIParamAssignment for v, assumed to be an OpArg.
-func (x *expandState) prAssignForArg(v *Value) abi.ABIParamAssignment {
+func (x *expandState) prAssignForArg(v *Value) *abi.ABIParamAssignment {
 	if v.Op != OpArg {
 		panic(badVal("Wanted OpArg, instead saw", v))
 	}
@@ -256,13 +256,12 @@ func (x *expandState) prAssignForArg(v *Value) abi.ABIParamAssignment {
 }
 
 // ParamAssignmentForArgName returns the ABIParamAssignment for f's arg with matching name.
-func ParamAssignmentForArgName(f *Func, name *ir.Name) abi.ABIParamAssignment {
+func ParamAssignmentForArgName(f *Func, name *ir.Name) *abi.ABIParamAssignment {
 	abiInfo := f.OwnAux.abiInfo
-	// This is unfortunate, but apparently the only way.
-	// TODO after register args stabilize, find a better way
-	for _, a := range abiInfo.InParams() {
+	ip := abiInfo.InParams()
+	for i, a := range ip {
 		if a.Name == name {
-			return a
+			return &ip[i]
 		}
 	}
 	panic(fmt.Errorf("Did not match param %v in prInfo %+v", name, abiInfo.InParams()))
@@ -646,6 +645,7 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, source, mem *Value,
 		fmt.Printf("\tstoreArgOrLoad(%s;  %s;  %s; %d; %s)\n", source.LongString(), mem.String(), t.String(), offset, storeRc.String())
 	}
 
+	// Start with Opcodes that can be disassembled
 	switch source.Op {
 	case OpCopy:
 		return x.storeArgOrLoad(pos, b, source.Args[0], mem, t, offset, loadRegOffset, storeRc)
@@ -1025,14 +1025,9 @@ func expandCalls(f *Func) {
 						t = tSrc
 					}
 				}
-				if iAEATt {
-					if x.debug {
-						fmt.Printf("Splitting store %s\n", v.LongString())
-					}
-					dst, mem := v.Args[0], v.Args[2]
-					mem = x.storeArgOrLoad(v.Pos, b, source, mem, t, 0, 0, registerCursor{storeDest: dst})
-					v.copyOf(mem)
-				}
+				dst, mem := v.Args[0], v.Args[2]
+				mem = x.storeArgOrLoad(v.Pos, b, source, mem, t, 0, 0, registerCursor{storeDest: dst})
+				v.copyOf(mem)
 			}
 		}
 	}
@@ -1322,14 +1317,12 @@ func (x *expandState) newArgToMemOrRegs(baseArg, toReplace *Value, offset int64,
 	}
 
 	pa := x.prAssignForArg(baseArg)
-	switch len(pa.Registers) {
-	case 0:
+	if len(pa.Registers) == 0 { // Arg is on stack
 		frameOff := baseArg.Aux.(*ir.Name).FrameOffset()
 		if pa.Offset() != int32(frameOff+x.f.ABISelf.LocalsOffset()) {
 			panic(fmt.Errorf("Parameter assignment %d and OpArg.Aux frameOffset %d disagree, op=%s",
 				pa.Offset(), frameOff, baseArg.LongString()))
 		}
-
 		aux := baseArg.Aux
 		auxInt := baseArg.AuxInt + offset
 		if toReplace != nil && toReplace.Block == baseArg.Block {
@@ -1350,35 +1343,34 @@ func (x *expandState) newArgToMemOrRegs(baseArg, toReplace *Value, offset int64,
 			}
 			return w
 		}
-
-	default:
-		r := pa.Registers[regOffset]
-		auxInt := x.f.ABISelf.FloatIndexFor(r)
-		op := OpArgFloatReg
-		// TODO seems like this has implications for debugging. How does this affect the location?
-		if auxInt < 0 { // int (not float) parameter register
-			op = OpArgIntReg
-			auxInt = int64(r)
+	}
+	// Arg is in registers
+	r := pa.Registers[regOffset]
+	auxInt := x.f.ABISelf.FloatIndexFor(r)
+	op := OpArgFloatReg
+	// TODO seems like this has implications for debugging. How does this affect the location?
+	if auxInt < 0 { // int (not float) parameter register
+		op = OpArgIntReg
+		auxInt = int64(r)
+	}
+	aux := &AuxNameOffset{baseArg.Aux.(*ir.Name), baseArg.AuxInt + offset}
+	if toReplace != nil && toReplace.Block == baseArg.Block {
+		toReplace.reset(op)
+		toReplace.Aux = aux
+		toReplace.AuxInt = auxInt
+		toReplace.Type = t
+		x.commonArgs[key] = toReplace
+		return toReplace
+	} else {
+		w := baseArg.Block.NewValue0IA(pos, op, t, auxInt, aux)
+		if x.debug {
+			fmt.Printf("\tnew %s\n", w.LongString())
 		}
-		aux := &AuxNameOffset{baseArg.Aux.(*ir.Name), baseArg.AuxInt + offset}
-		if toReplace != nil && toReplace.Block == baseArg.Block {
-			toReplace.reset(op)
-			toReplace.Aux = aux
-			toReplace.AuxInt = auxInt
-			toReplace.Type = t
-			x.commonArgs[key] = toReplace
-			return toReplace
-		} else {
-			w := baseArg.Block.NewValue0IA(pos, op, t, auxInt, aux)
-			if x.debug {
-				fmt.Printf("\tnew %s\n", w.LongString())
-			}
-			x.commonArgs[key] = w
-			if toReplace != nil {
-				toReplace.copyOf(w)
-			}
-			return w
+		x.commonArgs[key] = w
+		if toReplace != nil {
+			toReplace.copyOf(w)
 		}
+		return w
 	}
 }
 
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index 0577ec7bed..574377a33d 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -133,7 +133,9 @@ func (a *AuxCall) Reg(i *regInfo, c *Config) *regInfo {
 	a.reg.clobbers = i.clobbers
 	return a.reg
 }
-
+func (a *AuxCall) ABI() *abi.ABIConfig {
+	return a.abiInfo.Config()
+}
 func (a *AuxCall) ResultReg(c *Config) *regInfo {
 	if a.abiInfo.OutRegistersUsed() == 0 {
 		return a.reg
@@ -162,6 +164,11 @@ func archRegForAbiReg(r abi.RegIndex, c *Config) uint8 {
 	return uint8(m)
 }
 
+// OffsetOfResult returns the SP offset of result which (indexed 0, 1, etc).
+func (a *AuxCall) ParamAssignmentForResult(which int64) *abi.ABIParamAssignment {
+	return a.abiInfo.OutParam(int(which))
+}
+
 // OffsetOfResult returns the SP offset of result which (indexed 0, 1, etc).
 func (a *AuxCall) OffsetOfResult(which int64) int64 {
 	n := int64(a.abiInfo.OutParam(int(which)).Offset())
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 881fdcc8f4..b590bd4f2f 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -563,16 +563,9 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 					} else { // Too big for SSA.
 						// Brute force, and early, do a bunch of stores from registers
 						// TODO fix the nasty storeArgOrLoad recursion in ssa/expand_calls.go so this Just Works with store of a big Arg.
-						typs, offs := paramAssignment.RegisterTypesAndOffsets()
-						for i, t := range typs {
-							o := offs[i]
-							r := paramAssignment.Registers[i]
-							op, reg := ssa.ArgOpAndRegisterFor(r, s.f.ABISelf)
-							v := s.newValue0I(op, t, reg)
-							v.Aux = &ssa.AuxNameOffset{Name: n, Offset: o}
-							p := s.newValue1I(ssa.OpOffPtr, types.NewPtr(n.Type()), o, s.decladdrs[n])
-							s.store(t, p, v)
-						}
+						abi := s.f.ABISelf
+						addr := s.decladdrs[n]
+						s.storeParameterRegsToStack(abi, paramAssignment, n, addr)
 					}
 				}
 			}
@@ -648,6 +641,20 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 	return s.f
 }
 
+func (s *state) storeParameterRegsToStack(abi *abi.ABIConfig, paramAssignment *abi.ABIParamAssignment, n *ir.Name, addr *ssa.Value) {
+	typs, offs := paramAssignment.RegisterTypesAndOffsets()
+	for i, t := range typs {
+		r := paramAssignment.Registers[i]
+		o := offs[i]
+		op, reg := ssa.ArgOpAndRegisterFor(r, abi)
+		aux := &ssa.AuxNameOffset{Name: n, Offset: o}
+		v := s.newValue0I(op, t, reg)
+		v.Aux = aux
+		p := s.newValue1I(ssa.OpOffPtr, types.NewPtr(t), o, addr)
+		s.store(t, p, v)
+	}
+}
+
 // zeroResults zeros the return values at the start of the function.
 // We need to do this very early in the function.  Defer might stop a
 // panic and show the return values as they exist at the time of
@@ -2968,12 +2975,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		if which == -1 {
 			panic(fmt.Errorf("ORESULT %v does not match call %s", n, s.prevCall))
 		}
-		if TypeOK(n.Type()) {
-			return s.newValue1I(ssa.OpSelectN, n.Type(), which, s.prevCall)
-		} else {
-			addr := s.newValue1I(ssa.OpSelectNAddr, types.NewPtr(n.Type()), which, s.prevCall)
-			return s.rawLoad(n.Type(), addr)
-		}
+		return s.resultOfCall(s.prevCall, which, n.Type())
 
 	case ir.ODEREF:
 		n := n.(*ir.StarExpr)
@@ -3174,6 +3176,30 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 	}
 }
 
+func (s *state) resultOfCall(c *ssa.Value, which int64, t *types.Type) *ssa.Value {
+	aux := c.Aux.(*ssa.AuxCall)
+	pa := aux.ParamAssignmentForResult(which)
+	// TODO(register args) determine if in-memory TypeOK is better loaded early from SelectNAddr or later when SelectN is expanded.
+	// SelectN is better for pattern-matching and possible call-aware analysis we might want to do in the future.
+	if len(pa.Registers) == 0 && !TypeOK(t) {
+		addr := s.newValue1I(ssa.OpSelectNAddr, types.NewPtr(t), which, c)
+		return s.rawLoad(t, addr)
+	}
+	return s.newValue1I(ssa.OpSelectN, t, which, c)
+}
+
+func (s *state) resultAddrOfCall(c *ssa.Value, which int64, t *types.Type) *ssa.Value {
+	aux := c.Aux.(*ssa.AuxCall)
+	pa := aux.ParamAssignmentForResult(which)
+	if len(pa.Registers) == 0 {
+		return s.newValue1I(ssa.OpSelectNAddr, types.NewPtr(t), which, c)
+	}
+	_, addr := s.temp(c.Pos, t)
+	rval := s.newValue1I(ssa.OpSelectN, t, which, c)
+	s.vars[memVar] = s.newValue3Apos(ssa.OpStore, types.TypeMem, t, addr, rval, s.mem(), false)
+	return addr
+}
+
 // append converts an OAPPEND node to SSA.
 // If inplace is false, it converts the OAPPEND expression n to an ssa.Value,
 // adds it to s, and returns the Value.
@@ -5068,10 +5094,8 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 	}
 	fp := res.Field(0)
 	if returnResultAddr {
-		pt := types.NewPtr(fp.Type)
-		return s.newValue1I(ssa.OpSelectNAddr, pt, 0, call)
+		return s.resultAddrOfCall(call, 0, fp.Type)
 	}
-
 	return s.newValue1I(ssa.OpSelectN, fp.Type, 0, call)
 }
 
@@ -5169,9 +5193,7 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 	case ir.ORESULT:
 		// load return from callee
 		n := n.(*ir.ResultExpr)
-		x := s.newValue1I(ssa.OpSelectNAddr, t, n.Index, s.prevCall)
-		return x
-
+		return s.resultAddrOfCall(s.prevCall, n.Index, n.Type())
 	case ir.OINDEX:
 		n := n.(*ir.IndexExpr)
 		if n.X.Type().IsSlice() {
@@ -5528,12 +5550,7 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
 	res := make([]*ssa.Value, len(results))
 	for i, t := range results {
 		off = types.Rnd(off, t.Alignment())
-		if TypeOK(t) {
-			res[i] = s.newValue1I(ssa.OpSelectN, t, int64(i), call)
-		} else {
-			addr := s.newValue1I(ssa.OpSelectNAddr, types.NewPtr(t), int64(i), call)
-			res[i] = s.rawLoad(t, addr)
-		}
+		res[i] = s.resultOfCall(call, int64(i), t)
 		off += t.Size()
 	}
 	off = types.Rnd(off, int64(types.PtrSize))
@@ -6233,9 +6250,7 @@ func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Val
 	if commaok && !TypeOK(n.Type()) {
 		// unSSAable type, use temporary.
 		// TODO: get rid of some of these temporaries.
-		tmp = typecheck.TempAt(n.Pos(), s.curfn, n.Type())
-		s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, tmp.(*ir.Name), s.mem())
-		addr = s.addr(tmp)
+		tmp, addr = s.temp(n.Pos(), n.Type())
 	}
 
 	cond := s.newValue2(ssa.OpEqPtr, types.Types[types.TBOOL], itab, targetITab)
@@ -6317,6 +6332,14 @@ func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Val
 	return res, resok
 }
 
+// temp allocates a temp of type t at position pos
+func (s *state) temp(pos src.XPos, t *types.Type) (*ir.Name, *ssa.Value) {
+	tmp := typecheck.TempAt(pos, s.curfn, t)
+	s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, tmp, s.mem())
+	addr := s.addr(tmp)
+	return tmp, addr
+}
+
 // variable returns the value of a variable at the current location.
 func (s *state) variable(n ir.Node, t *types.Type) *ssa.Value {
 	v := s.vars[n]
diff --git a/test/abi/double_nested_addressed_struct.go b/test/abi/double_nested_addressed_struct.go
new file mode 100644
index 0000000000..be7c88aaaf
--- /dev/null
+++ b/test/abi/double_nested_addressed_struct.go
@@ -0,0 +1,62 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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.
+
+// wasm is excluded because the compiler chatter about register abi pragma ends up
+// on stdout, and causes the expected output to not match.
+
+package main
+
+import (
+	"fmt"
+)
+
+var sink *string
+
+type stringPair struct {
+	a, b string
+}
+
+type stringPairPair struct {
+	x, y stringPair
+}
+
+// The goal of this test is to be sure that the call arg/result expander works correctly
+// for a corner case of passing a 2-nested struct that fits in registers to/from calls.
+// AND, the struct has its address taken.
+
+//go:registerparams
+//go:noinline
+func H(spp stringPairPair) string {
+	F(&spp)
+	return spp.x.a + " " + spp.x.b + " " + spp.y.a + " " + spp.y.b
+}
+
+//go:registerparams
+//go:noinline
+func G(d, c, b, a string) stringPairPair {
+	return stringPairPair{stringPair{a, b}, stringPair{c, d}}
+}
+
+//go:registerparams
+//go:noinline
+func F(spp *stringPairPair) {
+	spp.x.a, spp.x.b, spp.y.a, spp.y.b = spp.y.b, spp.y.a, spp.x.b, spp.x.a
+}
+
+func main() {
+	spp := G("this", "is", "a", "test")
+	s := H(spp)
+	gotVsWant(s, "this is a test")
+}
+
+func gotVsWant(got, want string) {
+	if got != want {
+		fmt.Printf("FAIL, got %s, wanted %s\n", got, want)
+	}
+}
diff --git a/test/abi/double_nested_struct.go b/test/abi/double_nested_struct.go
new file mode 100644
index 0000000000..70d8ea4bce
--- /dev/null
+++ b/test/abi/double_nested_struct.go
@@ -0,0 +1,55 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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.
+
+// wasm is excluded because the compiler chatter about register abi pragma ends up
+// on stdout, and causes the expected output to not match. 
+
+package main
+
+import (
+	"fmt"
+)
+
+var sink *string
+
+type stringPair struct {
+	a, b string
+}
+
+type stringPairPair struct {
+	x, y stringPair
+}
+
+// The goal of this test is to be sure that the call arg/result expander works correctly
+// for a corner case of passing a 2-nested struct that fits in registers to/from calls.
+
+//go:registerparams
+//go:noinline
+func H(spp stringPairPair) string {
+	return spp.x.a + " " + spp.x.b + " " + spp.y.a + " " + spp.y.b
+}
+
+//go:registerparams
+//go:noinline
+func G(a,b,c,d string) stringPairPair {
+	return stringPairPair{stringPair{a,b},stringPair{c,d}}
+}
+
+
+func main() {
+	spp := G("this","is","a","test")
+	s := H(spp)
+	gotVsWant(s, "this is a test")
+}
+
+func gotVsWant(got, want string) {
+	if got != want {
+		fmt.Printf("FAIL, got %s, wanted %s\n", got, want)
+	}
+}
diff --git a/test/abi/too_big_to_ssa.go b/test/abi/too_big_to_ssa.go
new file mode 100644
index 0000000000..a5c6abb0e4
--- /dev/null
+++ b/test/abi/too_big_to_ssa.go
@@ -0,0 +1,47 @@
+// run
+
+// +build !wasm
+
+// Copyright 2021 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 (
+	"fmt"
+)
+
+var sink *string
+
+type toobig struct {
+	// 6 words will not SSA but will fit in registers
+	a,b,c string
+}
+
+//go:registerparams
+//go:noinline
+func H(x toobig) string {
+	return x.a + " " + x.b + " " + x.c
+}
+
+//go:registerparams
+//go:noinline
+func I(a,b,c string) toobig {
+	return toobig{a,b,c}
+}
+
+func main() {
+	s := H(toobig{"Hello", "there,", "World"})
+	gotVsWant(s, "Hello there, World")
+	fmt.Println(s)
+	t := H(I("Ahoy", "there,", "Matey"))
+	gotVsWant(t, "Ahoy there, Matey")
+	fmt.Println(t)
+}
+
+func gotVsWant(got, want string) {
+	if got != want {
+		fmt.Printf("FAIL, got %s, wanted %s\n", got, want)
+	}
+}
diff --git a/test/abi/too_big_to_ssa.out b/test/abi/too_big_to_ssa.out
new file mode 100644
index 0000000000..eeece34d47
--- /dev/null
+++ b/test/abi/too_big_to_ssa.out
@@ -0,0 +1,2 @@
+Hello there, World
+Ahoy there, Matey
-- 
GitLab


From 96a96a9058004af531db56dee26d82af08321cdb Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Thu, 4 Mar 2021 12:09:04 -0800
Subject: [PATCH 0940/2400] cmd/compile: remove types2.(*Selection).TArgs(),
 now that instance bug seems fixed

Previously, we would sometimes see an internal (*instance) type for a
receiver of a types2 method, which was a bug. To deal with that, we put
in an extra (*Selection).TArgs() method. However, that (*instance) type
is no longer showing up for receivers, so we can remove the types2
method we added and do the work with existing types2 API methods.

Change-Id: I03e68f5bbaaf82fe706b6efecbb02e951bbd3cd4
Reviewed-on: https://go-review.googlesource.com/c/go/+/298869
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/noder/expr.go       | 15 ++++++++++++++-
 src/cmd/compile/internal/types2/selection.go | 16 ----------------
 2 files changed, 14 insertions(+), 17 deletions(-)

diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index 3fded144dc..b99f5a4cdd 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -253,7 +253,7 @@ func (g *irgen) selectorExpr(pos src.XPos, typ types2.Type, expr *syntax.Selecto
 
 				// selinfo.Targs() are the types used to
 				// instantiate the type of receiver
-				targs2 := selinfo.TArgs()
+				targs2 := getTargs(selinfo)
 				targs := make([]ir.Node, len(targs2))
 				for i, targ2 := range targs2 {
 					targs[i] = ir.TypeNode(g.typ(targ2))
@@ -279,6 +279,19 @@ func (g *irgen) selectorExpr(pos src.XPos, typ types2.Type, expr *syntax.Selecto
 	return n
 }
 
+// getTargs gets the targs associated with the receiver of a selected method
+func getTargs(selinfo *types2.Selection) []types2.Type {
+	r := selinfo.Recv()
+	if p := types2.AsPointer(r); p != nil {
+		r = p.Elem()
+	}
+	n := types2.AsNamed(r)
+	if n == nil {
+		base.Fatalf("Incorrect type for selinfo %v", selinfo)
+	}
+	return n.TArgs()
+}
+
 func (g *irgen) exprList(expr syntax.Expr) []ir.Node {
 	switch expr := expr.(type) {
 	case nil:
diff --git a/src/cmd/compile/internal/types2/selection.go b/src/cmd/compile/internal/types2/selection.go
index 02c0fc6902..8128aeee2e 100644
--- a/src/cmd/compile/internal/types2/selection.go
+++ b/src/cmd/compile/internal/types2/selection.go
@@ -51,22 +51,6 @@ func (s *Selection) Kind() SelectionKind { return s.kind }
 // Recv returns the type of x in x.f.
 func (s *Selection) Recv() Type { return s.recv }
 
-// Work-around for a compiler issue where an (*instance) escapes.
-// TODO(gri): Is this still needed?
-func (s *Selection) TArgs() []Type {
-	r := s.recv
-	if p := asPointer(r); p != nil {
-		r = p.Elem()
-	}
-	if n := asNamed(r); n != nil {
-		return n.TArgs()
-	}
-	// The base type (after skipping any pointer) must be a Named type. The
-	// bug is that sometimes it can be an instance type (which is supposed to
-	// be an internal type only).
-	return r.(*instance).targs
-}
-
 // Obj returns the object denoted by x.f; a *Var for
 // a field selection, and a *Func in all other cases.
 func (s *Selection) Obj() Object { return s.obj }
-- 
GitLab


From a7526bbf72dfe0fde00d88f85fd6cddccdb3a345 Mon Sep 17 00:00:00 2001
From: Meng Zhuo <mzh@golangcn.org>
Date: Thu, 21 Jan 2021 22:53:30 +0800
Subject: [PATCH 0941/2400] encoding/json: marshal maps using
 reflect.Value.MapRange
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Map serialization using reflect.Value.MapIndex cannot retrieve
map keys that contain a NaN, resulting in a panic.
Switch the implementation to use the reflect.Value.MapRange method
instead, which iterates over all map entries regardless of whether
they are directly retrievable.

Note that according to RFC 8259, section 4, a JSON object should
have unique names, but does not forbid the occurrence of duplicate names.

Fixes #43207

Change-Id: If4bc55229b1f64b8ca4b0fed37549725efdace39
Reviewed-on: https://go-review.googlesource.com/c/go/+/278632
Trust: Meng Zhuo <mzh@golangcn.org>
Trust: Joe Tsai <thebrokentoaster@gmail.com>
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Meng Zhuo <mzh@golangcn.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
Reviewed-by: Daniel Martí <mvdan@mvdan.cc>
---
 src/encoding/json/encode.go      | 36 +++++++++++++++++---------------
 src/encoding/json/encode_test.go | 21 +++++++++++++++++++
 2 files changed, 40 insertions(+), 17 deletions(-)

diff --git a/src/encoding/json/encode.go b/src/encoding/json/encode.go
index 751f03d33d..e473e615a9 100644
--- a/src/encoding/json/encode.go
+++ b/src/encoding/json/encode.go
@@ -794,23 +794,24 @@ func (me mapEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
 	e.WriteByte('{')
 
 	// Extract and sort the keys.
-	keys := v.MapKeys()
-	sv := make([]reflectWithString, len(keys))
-	for i, v := range keys {
-		sv[i].v = v
+	sv := make([]reflectWithString, v.Len())
+	mi := v.MapRange()
+	for i := 0; mi.Next(); i++ {
+		sv[i].k = mi.Key()
+		sv[i].v = mi.Value()
 		if err := sv[i].resolve(); err != nil {
 			e.error(fmt.Errorf("json: encoding error for type %q: %q", v.Type().String(), err.Error()))
 		}
 	}
-	sort.Slice(sv, func(i, j int) bool { return sv[i].s < sv[j].s })
+	sort.Slice(sv, func(i, j int) bool { return sv[i].ks < sv[j].ks })
 
 	for i, kv := range sv {
 		if i > 0 {
 			e.WriteByte(',')
 		}
-		e.string(kv.s, opts.escapeHTML)
+		e.string(kv.ks, opts.escapeHTML)
 		e.WriteByte(':')
-		me.elemEnc(e, v.MapIndex(kv.v), opts)
+		me.elemEnc(e, kv.v, opts)
 	}
 	e.WriteByte('}')
 	e.ptrLevel--
@@ -997,29 +998,30 @@ func typeByIndex(t reflect.Type, index []int) reflect.Type {
 }
 
 type reflectWithString struct {
-	v reflect.Value
-	s string
+	k  reflect.Value
+	v  reflect.Value
+	ks string
 }
 
 func (w *reflectWithString) resolve() error {
-	if w.v.Kind() == reflect.String {
-		w.s = w.v.String()
+	if w.k.Kind() == reflect.String {
+		w.ks = w.k.String()
 		return nil
 	}
-	if tm, ok := w.v.Interface().(encoding.TextMarshaler); ok {
-		if w.v.Kind() == reflect.Ptr && w.v.IsNil() {
+	if tm, ok := w.k.Interface().(encoding.TextMarshaler); ok {
+		if w.k.Kind() == reflect.Ptr && w.k.IsNil() {
 			return nil
 		}
 		buf, err := tm.MarshalText()
-		w.s = string(buf)
+		w.ks = string(buf)
 		return err
 	}
-	switch w.v.Kind() {
+	switch w.k.Kind() {
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		w.s = strconv.FormatInt(w.v.Int(), 10)
+		w.ks = strconv.FormatInt(w.k.Int(), 10)
 		return nil
 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-		w.s = strconv.FormatUint(w.v.Uint(), 10)
+		w.ks = strconv.FormatUint(w.k.Uint(), 10)
 		return nil
 	}
 	panic("unexpected map key type")
diff --git a/src/encoding/json/encode_test.go b/src/encoding/json/encode_test.go
index 42bb09d5cd..0dad951095 100644
--- a/src/encoding/json/encode_test.go
+++ b/src/encoding/json/encode_test.go
@@ -245,6 +245,22 @@ func TestUnsupportedValues(t *testing.T) {
 	}
 }
 
+// Issue 43207
+func TestMarshalTextFloatMap(t *testing.T) {
+	m := map[textfloat]string{
+		textfloat(math.NaN()): "1",
+		textfloat(math.NaN()): "1",
+	}
+	got, err := Marshal(m)
+	if err != nil {
+		t.Errorf("Marshal() error: %v", err)
+	}
+	want := `{"TF:NaN":"1","TF:NaN":"1"}`
+	if string(got) != want {
+		t.Errorf("Marshal() = %s, want %s", got, want)
+	}
+}
+
 // Ref has Marshaler and Unmarshaler methods with pointer receiver.
 type Ref int
 
@@ -854,6 +870,10 @@ func tenc(format string, a ...interface{}) ([]byte, error) {
 	return buf.Bytes(), nil
 }
 
+type textfloat float64
+
+func (f textfloat) MarshalText() ([]byte, error) { return tenc(`TF:%0.2f`, f) }
+
 // Issue 13783
 func TestEncodeBytekind(t *testing.T) {
 	testdata := []struct {
@@ -872,6 +892,7 @@ func TestEncodeBytekind(t *testing.T) {
 		{[]jsonint{5, 4}, `[{"JI":5},{"JI":4}]`},
 		{[]textint{9, 3}, `["TI:9","TI:3"]`},
 		{[]int{9, 3}, `[9,3]`},
+		{[]textfloat{12, 3}, `["TF:12.00","TF:3.00"]`},
 	}
 	for _, d := range testdata {
 		js, err := Marshal(d.data)
-- 
GitLab


From b62da089091e305b6231082d8a69b27c56603b51 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Thu, 4 Mar 2021 21:09:17 -0500
Subject: [PATCH 0942/2400] cmd/go: update error expectations in
 TestScript/mod_install_pkg_version

This test was missed in CL 298650, and not caught by TryBots because
it is skipped it short mode (and we forgot to add longtest TryBots on
that CL).

Updates #44745

Change-Id: I696d01307dabf351b0e4735db0644f4e09c8e369
Reviewed-on: https://go-review.googlesource.com/c/go/+/298794
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/testdata/script/mod_install_pkg_version.txt | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/go/testdata/script/mod_install_pkg_version.txt b/src/cmd/go/testdata/script/mod_install_pkg_version.txt
index e27ebc5cc5..6ed600ff71 100644
--- a/src/cmd/go/testdata/script/mod_install_pkg_version.txt
+++ b/src/cmd/go/testdata/script/mod_install_pkg_version.txt
@@ -59,9 +59,9 @@ rm $GOPATH/bin
 env GO111MODULE=on
 go mod download rsc.io/fortune@v1.0.0
 ! go install $GOPATH/pkg/mod/rsc.io/fortune@v1.0.0
-stderr '^go: cannot find main module; see ''go help modules''$'
+stderr '^go: go\.mod file not found in current directory or any parent directory; see ''go help modules''$'
 ! go install ../pkg/mod/rsc.io/fortune@v1.0.0
-stderr '^go: cannot find main module; see ''go help modules''$'
+stderr '^go: go\.mod file not found in current directory or any parent directory; see ''go help modules''$'
 mkdir tmp
 cd tmp
 go mod init tmp
-- 
GitLab


From 2b0e29f51669063002cbcceca4f4a43e00144876 Mon Sep 17 00:00:00 2001
From: John Bampton <jbampton@gmail.com>
Date: Sun, 14 Feb 2021 17:27:56 +0000
Subject: [PATCH 0943/2400] docs: fix case of GitHub

Change `Github` to `GitHub`

Change-Id: I514e8dc9a19182fcf9fcf5bc1b5fbff253c1a947
GitHub-Last-Rev: 7124c7058e0c7ff19dc8440fa79271eb6cfdaea9
GitHub-Pull-Request: golang/go#44260
Reviewed-on: https://go-review.googlesource.com/c/go/+/291950
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 misc/chrome/gophertool/popup.html | 2 +-
 src/cmd/go/internal/vcs/vcs.go    | 2 +-
 src/crypto/md5/md5_test.go        | 2 +-
 src/crypto/sha1/sha1_test.go      | 2 +-
 src/crypto/sha256/sha256_test.go  | 2 +-
 src/crypto/sha512/sha512_test.go  | 2 +-
 6 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/misc/chrome/gophertool/popup.html b/misc/chrome/gophertool/popup.html
index 9740406276..ad42a3847c 100644
--- a/misc/chrome/gophertool/popup.html
+++ b/misc/chrome/gophertool/popup.html
@@ -15,7 +15,7 @@
 <a href="#" url="https://golang.org/pkg/">pkg</a> id/name:</small>
 <form style='margin: 0' id='navform'><nobr><input id="inputbox" size=10 tabindex=1 /><input type="submit" value="go" /></nobr></form>
 <small>Also: <a href="#" url="https://build.golang.org">buildbots</a>
-<a href="#" url="https://github.com/golang/go">Github</a>
+<a href="#" url="https://github.com/golang/go">GitHub</a>
 </small>
 </body>
 </html>
diff --git a/src/cmd/go/internal/vcs/vcs.go b/src/cmd/go/internal/vcs/vcs.go
index 9feffe0765..91485f6f74 100644
--- a/src/cmd/go/internal/vcs/vcs.go
+++ b/src/cmd/go/internal/vcs/vcs.go
@@ -1176,7 +1176,7 @@ func expand(match map[string]string, s string) string {
 // and import paths referring to a fully-qualified importPath
 // containing a VCS type (foo.com/repo.git/dir)
 var vcsPaths = []*vcsPath{
-	// Github
+	// GitHub
 	{
 		pathPrefix: "github.com",
 		regexp:     lazyregexp.New(`^(?P<root>github\.com/[A-Za-z0-9_.\-]+/[A-Za-z0-9_.\-]+)(/[A-Za-z0-9_.\-]+)*$`),
diff --git a/src/crypto/md5/md5_test.go b/src/crypto/md5/md5_test.go
index 282ba1b859..c0ac0971c4 100644
--- a/src/crypto/md5/md5_test.go
+++ b/src/crypto/md5/md5_test.go
@@ -157,7 +157,7 @@ func TestBlockGeneric(t *testing.T) {
 // Tests for unmarshaling hashes that have hashed a large amount of data
 // The initial hash generation is omitted from the test, because it takes a long time.
 // The test contains some already-generated states, and their expected sums
-// Tests a problem that is outlined in Github issue #29541
+// Tests a problem that is outlined in GitHub issue #29541
 // The problem is triggered when an amount of data has been hashed for which
 // the data length has a 1 in the 32nd bit. When casted to int, this changes
 // the sign of the value, and causes the modulus operation to return a
diff --git a/src/crypto/sha1/sha1_test.go b/src/crypto/sha1/sha1_test.go
index 681e928de2..c3e6010af1 100644
--- a/src/crypto/sha1/sha1_test.go
+++ b/src/crypto/sha1/sha1_test.go
@@ -156,7 +156,7 @@ func TestBlockGeneric(t *testing.T) {
 // Tests for unmarshaling hashes that have hashed a large amount of data
 // The initial hash generation is omitted from the test, because it takes a long time.
 // The test contains some already-generated states, and their expected sums
-// Tests a problem that is outlined in Github issue #29543
+// Tests a problem that is outlined in GitHub issue #29543
 // The problem is triggered when an amount of data has been hashed for which
 // the data length has a 1 in the 32nd bit. When casted to int, this changes
 // the sign of the value, and causes the modulus operation to return a
diff --git a/src/crypto/sha256/sha256_test.go b/src/crypto/sha256/sha256_test.go
index 433c5a4c5e..a2794b015d 100644
--- a/src/crypto/sha256/sha256_test.go
+++ b/src/crypto/sha256/sha256_test.go
@@ -229,7 +229,7 @@ func TestBlockGeneric(t *testing.T) {
 // Tests for unmarshaling hashes that have hashed a large amount of data
 // The initial hash generation is omitted from the test, because it takes a long time.
 // The test contains some already-generated states, and their expected sums
-// Tests a problem that is outlined in Github issue #29517
+// Tests a problem that is outlined in GitHub issue #29517
 // The problem is triggered when an amount of data has been hashed for which
 // the data length has a 1 in the 32nd bit. When casted to int, this changes
 // the sign of the value, and causes the modulus operation to return a
diff --git a/src/crypto/sha512/sha512_test.go b/src/crypto/sha512/sha512_test.go
index 59998b1d38..74a13331af 100644
--- a/src/crypto/sha512/sha512_test.go
+++ b/src/crypto/sha512/sha512_test.go
@@ -835,7 +835,7 @@ func TestBlockGeneric(t *testing.T) {
 // Tests for unmarshaling hashes that have hashed a large amount of data
 // The initial hash generation is omitted from the test, because it takes a long time.
 // The test contains some already-generated states, and their expected sums
-// Tests a problem that is outlined in Github issue #29541
+// Tests a problem that is outlined in GitHub issue #29541
 // The problem is triggered when an amount of data has been hashed for which
 // the data length has a 1 in the 32nd bit. When casted to int, this changes
 // the sign of the value, and causes the modulus operation to return a
-- 
GitLab


From f0b6d3753f57bf37487b127f968920743c401ed9 Mon Sep 17 00:00:00 2001
From: Tao Qingyun <qingyunha@gmail.com>
Date: Fri, 5 Mar 2021 04:01:00 +0000
Subject: [PATCH 0944/2400] cmd/go: update PWD variable for 'go generate'

Most subprocess invocations in the go command use base.AppendPWD to
append an accurate value of PWD to the command's environment, which can
speed up calls like os.Getwd and also help to provide less-confusing
output from scripts. Update `go generate` to do so.

Fixes #43862

Change-Id: I3b756f1532b2d922f7d74fd86414d5567a0122c0
GitHub-Last-Rev: 3ec8da265a2777d1dcbcea00f107b8f5905f3640
GitHub-Pull-Request: golang/go#43940
Reviewed-on: https://go-review.googlesource.com/c/go/+/287152
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Baokun Lee <bk@golangcn.org>
---
 src/cmd/go/internal/generate/generate.go |  1 +
 src/cmd/go/testdata/script/generate.txt  | 10 +++++++++-
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/cmd/go/internal/generate/generate.go b/src/cmd/go/internal/generate/generate.go
index a48311d51b..97df229b31 100644
--- a/src/cmd/go/internal/generate/generate.go
+++ b/src/cmd/go/internal/generate/generate.go
@@ -334,6 +334,7 @@ func (g *Generator) setEnv() {
 		"GOPACKAGE=" + g.pkg,
 		"DOLLAR=" + "$",
 	}
+	g.env = base.AppendPWD(g.env, g.dir)
 }
 
 // split breaks the line into words, evaluating quoted
diff --git a/src/cmd/go/testdata/script/generate.txt b/src/cmd/go/testdata/script/generate.txt
index c3c563e5f4..73f5bbd57a 100644
--- a/src/cmd/go/testdata/script/generate.txt
+++ b/src/cmd/go/testdata/script/generate.txt
@@ -26,6 +26,10 @@ stdout 'yes' # flag.go should select yes
 go generate './generate/env_test.go'
 stdout 'main_test'
 
+# Test go generate provides the right "$PWD"
+go generate './generate/env_pwd.go'
+stdout $WORK'[/\\]gopath[/\\]src[/\\]generate'
+
 -- echo.go --
 package main
 
@@ -88,4 +92,8 @@ package p
 -- generate/env_test.go --
 package main_test
 
-//go:generate echo $GOPACKAGE
\ No newline at end of file
+//go:generate echo $GOPACKAGE
+-- generate/env_pwd.go --
+package p
+
+//go:generate echo $PWD
-- 
GitLab


From 60b500dc6c78a793775a7dff4eb8c656734a54c8 Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Fri, 26 Feb 2021 09:16:56 -0800
Subject: [PATCH 0945/2400] math/big: remove bounds checks for shrVU_g inner
 loop
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Make explicit a shrVU_g precondition.
Replace i with i+1 throughout the loop.
The resulting loop is functionally identical,
but the compiler can do better BCE without the i-1 slice offset.

Benchmarks results on amd64 with -tags=math_big_pure_go.

name                          old time/op  new time/op  delta
NonZeroShifts/1/shrVU-8       4.55ns ± 2%  4.45ns ± 3%   -2.27%  (p=0.000 n=28+30)
NonZeroShifts/1/shlVU-8       4.07ns ± 1%  4.13ns ± 4%   +1.55%  (p=0.000 n=26+29)
NonZeroShifts/2/shrVU-8       6.12ns ± 1%  5.55ns ± 1%   -9.30%  (p=0.000 n=28+28)
NonZeroShifts/2/shlVU-8       5.65ns ± 3%  5.70ns ± 2%   +0.92%  (p=0.008 n=30+29)
NonZeroShifts/3/shrVU-8       7.58ns ± 2%  6.79ns ± 2%  -10.46%  (p=0.000 n=28+28)
NonZeroShifts/3/shlVU-8       6.62ns ± 2%  6.69ns ± 1%   +1.07%  (p=0.000 n=29+28)
NonZeroShifts/4/shrVU-8       9.02ns ± 1%  7.79ns ± 2%  -13.59%  (p=0.000 n=27+30)
NonZeroShifts/4/shlVU-8       7.74ns ± 1%  7.82ns ± 1%   +0.92%  (p=0.000 n=26+28)
NonZeroShifts/5/shrVU-8       10.6ns ± 1%   8.9ns ± 3%  -16.31%  (p=0.000 n=25+29)
NonZeroShifts/5/shlVU-8       8.59ns ± 1%  8.68ns ± 1%   +1.13%  (p=0.000 n=27+29)
NonZeroShifts/10/shrVU-8      18.2ns ± 2%  14.4ns ± 1%  -20.96%  (p=0.000 n=27+28)
NonZeroShifts/10/shlVU-8      14.1ns ± 1%  14.1ns ± 1%   +0.46%  (p=0.001 n=26+28)
NonZeroShifts/100/shrVU-8      161ns ± 2%   118ns ± 1%  -26.83%  (p=0.000 n=29+30)
NonZeroShifts/100/shlVU-8      119ns ± 2%   120ns ± 2%   +0.92%  (p=0.000 n=29+29)
NonZeroShifts/1000/shrVU-8    1.54µs ± 1%  1.10µs ± 1%  -28.63%  (p=0.000 n=29+29)
NonZeroShifts/1000/shlVU-8    1.10µs ± 1%  1.10µs ± 2%     ~     (p=0.701 n=28+29)
NonZeroShifts/10000/shrVU-8   15.3µs ± 2%  10.9µs ± 1%  -28.68%  (p=0.000 n=28+28)
NonZeroShifts/10000/shlVU-8   10.9µs ± 2%  10.9µs ± 2%   -0.57%  (p=0.003 n=26+29)
NonZeroShifts/100000/shrVU-8   154µs ± 1%   111µs ± 2%  -28.04%  (p=0.000 n=27+28)
NonZeroShifts/100000/shlVU-8   113µs ± 2%   113µs ± 2%     ~     (p=0.790 n=30+30)

Change-Id: Ib6a621ee7c88b27f0f18121fb2cba3606c40c9b0
Reviewed-on: https://go-review.googlesource.com/c/go/+/297049
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/math/big/arith.go | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/math/big/arith.go b/src/math/big/arith.go
index 750ce8aa39..e1947936d4 100644
--- a/src/math/big/arith.go
+++ b/src/math/big/arith.go
@@ -170,12 +170,16 @@ func shrVU_g(z, x []Word, s uint) (c Word) {
 	if len(z) == 0 {
 		return
 	}
+	if len(x) != len(z) {
+		// This is an invariant guaranteed by the caller.
+		panic("len(x) != len(z)")
+	}
 	s &= _W - 1 // hint to the compiler that shifts by s don't need guard code
 	ŝ := _W - s
 	ŝ &= _W - 1 // ditto
 	c = x[0] << ŝ
-	for i := 0; i < len(z)-1; i++ {
-		z[i] = x[i]>>s | x[i+1]<<ŝ
+	for i := 1; i < len(z); i++ {
+		z[i-1] = x[i-1]>>s | x[i]<<ŝ
 	}
 	z[len(z)-1] = x[len(z)-1] >> s
 	return
-- 
GitLab


From 31df4e3fcd0c961684a027188a391f6db1ab3439 Mon Sep 17 00:00:00 2001
From: Meng Zhuo <mzh@golangcn.org>
Date: Mon, 16 Nov 2020 17:50:01 +0800
Subject: [PATCH 0946/2400] cmd/link: add relocs type for mips64x

The race detector of llvm adds four reloc types even with -fPIC

elf.R_MIPS_CALL16
elf.R_MIPS_GPREL32
elf.R_MIPS_64
elf.R_MIPS_GOT_DISP

Change-Id: If73119dcba14ef74395273eb680f52a0aa853217
Reviewed-on: https://go-review.googlesource.com/c/go/+/270297
Trust: Meng Zhuo <mzh@golangcn.org>
Run-TryBot: Meng Zhuo <mzh@golangcn.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/link/internal/loadelf/ldelf.go | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/cmd/link/internal/loadelf/ldelf.go b/src/cmd/link/internal/loadelf/ldelf.go
index c698874b32..6e3b2c077d 100644
--- a/src/cmd/link/internal/loadelf/ldelf.go
+++ b/src/cmd/link/internal/loadelf/ldelf.go
@@ -983,7 +983,11 @@ func relSize(arch *sys.Arch, pn string, elftype uint32) (uint8, error) {
 		MIPS64 | uint32(elf.R_MIPS_GPREL16)<<16,
 		MIPS64 | uint32(elf.R_MIPS_GOT_PAGE)<<16,
 		MIPS64 | uint32(elf.R_MIPS_JALR)<<16,
-		MIPS64 | uint32(elf.R_MIPS_GOT_OFST)<<16:
+		MIPS64 | uint32(elf.R_MIPS_GOT_OFST)<<16,
+		MIPS64 | uint32(elf.R_MIPS_CALL16)<<16,
+		MIPS64 | uint32(elf.R_MIPS_GPREL32)<<16,
+		MIPS64 | uint32(elf.R_MIPS_64)<<16,
+		MIPS64 | uint32(elf.R_MIPS_GOT_DISP)<<16:
 		return 4, nil
 
 	case S390X | uint32(elf.R_390_8)<<16:
-- 
GitLab


From 2217e89ba326875470a856cd0da79f3ec9a896b8 Mon Sep 17 00:00:00 2001
From: Rodolfo Carvalho <rhcarvalho@gmail.com>
Date: Mon, 18 Jan 2021 19:56:26 +0100
Subject: [PATCH 0947/2400] net/http/httptrace: fix doc typo
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Change-Id: I919d9c3968c0fcd33774e714f22182504790bd01
Reviewed-on: https://go-review.googlesource.com/c/go/+/284143
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Daniel Martí <mvdan@mvdan.cc>
Trust: Daniel Martí <mvdan@mvdan.cc>
---
 src/net/http/httptrace/trace.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/net/http/httptrace/trace.go b/src/net/http/httptrace/trace.go
index 6a5cbac9d8..5777c91747 100644
--- a/src/net/http/httptrace/trace.go
+++ b/src/net/http/httptrace/trace.go
@@ -127,7 +127,7 @@ type ClientTrace struct {
 
 	// ConnectDone is called when a new connection's Dial
 	// completes. The provided err indicates whether the
-	// connection completedly successfully.
+	// connection completed successfully.
 	// If net.Dialer.DualStack ("Happy Eyeballs") support is
 	// enabled, this may be called multiple times.
 	ConnectDone func(network, addr string, err error)
-- 
GitLab


From 2e794c2bb1302af764670dba894bbfe537bd63f0 Mon Sep 17 00:00:00 2001
From: Alexey Vilenski <bynovhack@gmail.com>
Date: Fri, 5 Mar 2021 11:37:54 +0000
Subject: [PATCH 0948/2400] testing: add TB.Setenv
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add a new method TB.Setenv that'll set environment variables
only for the isolated lifetime of the test, and will clean up
and unset these variables when the test ends.
This method disables the test or benchmark from running in
parallel.

Fixes #41260

Change-Id: I0a18f094ec1c6ec3157b4b12993ea3075e2e9867
GitHub-Last-Rev: 0ca12fa565318f350b927e2ef94f3b4f792c75c2
GitHub-Pull-Request: golang/go#41857
Reviewed-on: https://go-review.googlesource.com/c/go/+/260577
Trust: Daniel Martí <mvdan@mvdan.cc>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: roger peppe <rogpeppe@gmail.com>
---
 src/testing/testing.go      | 42 +++++++++++++++++++
 src/testing/testing_test.go | 83 +++++++++++++++++++++++++++++++++++++
 2 files changed, 125 insertions(+)

diff --git a/src/testing/testing.go b/src/testing/testing.go
index 466dd96981..fc52f3c547 100644
--- a/src/testing/testing.go
+++ b/src/testing/testing.go
@@ -667,6 +667,7 @@ var _ TB = (*B)(nil)
 type T struct {
 	common
 	isParallel bool
+	isEnvSet   bool
 	context    *testContext // For running tests and subtests.
 }
 
@@ -964,6 +965,29 @@ func (c *common) TempDir() string {
 	return dir
 }
 
+// Setenv calls os.Setenv(key, value) and uses Cleanup to
+// restore the environment variable to its original value
+// after the test.
+//
+// This cannot be used in parallel tests.
+func (c *common) Setenv(key, value string) {
+	prevValue, ok := os.LookupEnv(key)
+
+	if err := os.Setenv(key, value); err != nil {
+		c.Fatalf("cannot set environment variable: %v", err)
+	}
+
+	if ok {
+		c.Cleanup(func() {
+			os.Setenv(key, prevValue)
+		})
+	} else {
+		c.Cleanup(func() {
+			os.Unsetenv(key)
+		})
+	}
+}
+
 // panicHanding is an argument to runCleanup.
 type panicHandling int
 
@@ -1035,6 +1059,9 @@ func (t *T) Parallel() {
 	if t.isParallel {
 		panic("testing: t.Parallel called multiple times")
 	}
+	if t.isEnvSet {
+		panic("testing: t.Parallel called after t.Setenv; cannot set environment variables in parallel tests")
+	}
 	t.isParallel = true
 
 	// We don't want to include the time we spend waiting for serial tests
@@ -1068,6 +1095,21 @@ func (t *T) Parallel() {
 	t.raceErrors += -race.Errors()
 }
 
+// Setenv calls os.Setenv(key, value) and uses Cleanup to
+// restore the environment variable to its original value
+// after the test.
+//
+// This cannot be used in parallel tests.
+func (t *T) Setenv(key, value string) {
+	if t.isParallel {
+		panic("testing: t.Setenv called after t.Parallel; cannot set environment variables in parallel tests")
+	}
+
+	t.isEnvSet = true
+
+	t.common.Setenv(key, value)
+}
+
 // InternalTest is an internal type but exported because it is cross-package;
 // it is part of the implementation of the "go test" command.
 type InternalTest struct {
diff --git a/src/testing/testing_test.go b/src/testing/testing_test.go
index 0f096980ca..55a4df4739 100644
--- a/src/testing/testing_test.go
+++ b/src/testing/testing_test.go
@@ -109,3 +109,86 @@ func testTempDir(t *testing.T) {
 		t.Errorf("unexpected %d files in TempDir: %v", len(files), files)
 	}
 }
+
+func TestSetenv(t *testing.T) {
+	tests := []struct {
+		name               string
+		key                string
+		initialValueExists bool
+		initialValue       string
+		newValue           string
+	}{
+		{
+			name:               "initial value exists",
+			key:                "GO_TEST_KEY_1",
+			initialValueExists: true,
+			initialValue:       "111",
+			newValue:           "222",
+		},
+		{
+			name:               "initial value exists but empty",
+			key:                "GO_TEST_KEY_2",
+			initialValueExists: true,
+			initialValue:       "",
+			newValue:           "222",
+		},
+		{
+			name:               "initial value is not exists",
+			key:                "GO_TEST_KEY_3",
+			initialValueExists: false,
+			initialValue:       "",
+			newValue:           "222",
+		},
+	}
+
+	for _, test := range tests {
+		if test.initialValueExists {
+			if err := os.Setenv(test.key, test.initialValue); err != nil {
+				t.Fatalf("unable to set env: got %v", err)
+			}
+		} else {
+			os.Unsetenv(test.key)
+		}
+
+		t.Run(test.name, func(t *testing.T) {
+			t.Setenv(test.key, test.newValue)
+			if os.Getenv(test.key) != test.newValue {
+				t.Fatalf("unexpected value after t.Setenv: got %s, want %s", os.Getenv(test.key), test.newValue)
+			}
+		})
+
+		got, exists := os.LookupEnv(test.key)
+		if got != test.initialValue {
+			t.Fatalf("unexpected value after t.Setenv cleanup: got %s, want %s", got, test.initialValue)
+		}
+		if exists != test.initialValueExists {
+			t.Fatalf("unexpected value after t.Setenv cleanup: got %t, want %t", exists, test.initialValueExists)
+		}
+	}
+}
+
+func TestSetenvWithParallelAfterSetenv(t *testing.T) {
+	defer func() {
+		want := "testing: t.Parallel called after t.Setenv; cannot set environment variables in parallel tests"
+		if got := recover(); got != want {
+			t.Fatalf("expected panic; got %#v want %q", got, want)
+		}
+	}()
+
+	t.Setenv("GO_TEST_KEY_1", "value")
+
+	t.Parallel()
+}
+
+func TestSetenvWithParallelBeforeSetenv(t *testing.T) {
+	defer func() {
+		want := "testing: t.Setenv called after t.Parallel; cannot set environment variables in parallel tests"
+		if got := recover(); got != want {
+			t.Fatalf("expected panic; got %#v want %q", got, want)
+		}
+	}()
+
+	t.Parallel()
+
+	t.Setenv("GO_TEST_KEY_1", "value")
+}
-- 
GitLab


From 302a400316319501748c0f034464fa70e7815272 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Wed, 3 Mar 2021 16:30:22 -0500
Subject: [PATCH 0949/2400] cmd/go/internal/modfetch: detect and recover from
 missing ziphash file

Previously, if an extracted module directory existed in the module
cache, but the corresponding ziphash file did not, if the sum was
missing from go.sum, we would not verify the sum. This caused 'go get'
not to write missing sums. 'go build' in readonly mode (now the
default) checks for missing sums and doesn't attempt to fetch modules
that can't be verified against go.sum.

With this change, when requesting the module directory with
modfetch.DownloadDir, if the ziphash file is missing, the go command
will re-hash the zip without downloading or re-extracting it again.

Note that the go command creates the ziphash file before the module
directory, but another program could remove it separately, and it
might not be present after a crash.

Fixes #44749

Change-Id: I64551e048a3ba17d069de1ec123d5b8b2757543c
Reviewed-on: https://go-review.googlesource.com/c/go/+/298352
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go/internal/modfetch/cache.go         | 17 ++++
 src/cmd/go/internal/modfetch/fetch.go         | 77 ++++++++++++-------
 .../script/mod_get_missing_ziphash.txt        | 55 +++++++++++++
 src/cmd/go/testdata/script/mod_verify.txt     |  7 +-
 4 files changed, 125 insertions(+), 31 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/mod_get_missing_ziphash.txt

diff --git a/src/cmd/go/internal/modfetch/cache.go b/src/cmd/go/internal/modfetch/cache.go
index 9e751931a0..10f774568d 100644
--- a/src/cmd/go/internal/modfetch/cache.go
+++ b/src/cmd/go/internal/modfetch/cache.go
@@ -80,6 +80,7 @@ func DownloadDir(m module.Version) (string, error) {
 		return "", err
 	}
 
+	// Check whether the directory itself exists.
 	dir := filepath.Join(cfg.GOMODCACHE, enc+"@"+encVer)
 	if fi, err := os.Stat(dir); os.IsNotExist(err) {
 		return dir, err
@@ -88,6 +89,9 @@ func DownloadDir(m module.Version) (string, error) {
 	} else if !fi.IsDir() {
 		return dir, &DownloadDirPartialError{dir, errors.New("not a directory")}
 	}
+
+	// Check if a .partial file exists. This is created at the beginning of
+	// a download and removed after the zip is extracted.
 	partialPath, err := CachePath(m, "partial")
 	if err != nil {
 		return dir, err
@@ -97,6 +101,19 @@ func DownloadDir(m module.Version) (string, error) {
 	} else if !os.IsNotExist(err) {
 		return dir, err
 	}
+
+	// Check if a .ziphash file exists. It should be created before the
+	// zip is extracted, but if it was deleted (by another program?), we need
+	// to re-calculate it.
+	ziphashPath, err := CachePath(m, "ziphash")
+	if err != nil {
+		return dir, err
+	}
+	if _, err := os.Stat(ziphashPath); os.IsNotExist(err) {
+		return dir, &DownloadDirPartialError{dir, errors.New("ziphash file is missing")}
+	} else if err != nil {
+		return dir, err
+	}
 	return dir, nil
 }
 
diff --git a/src/cmd/go/internal/modfetch/fetch.go b/src/cmd/go/internal/modfetch/fetch.go
index d5ad277dd0..7b4ce2154c 100644
--- a/src/cmd/go/internal/modfetch/fetch.go
+++ b/src/cmd/go/internal/modfetch/fetch.go
@@ -168,13 +168,16 @@ func DownloadZip(ctx context.Context, mod module.Version) (zipfile string, err e
 		if err != nil {
 			return cached{"", err}
 		}
+		ziphashfile := zipfile + "hash"
 
-		// Skip locking if the zipfile already exists.
+		// Return without locking if the zip and ziphash files exist.
 		if _, err := os.Stat(zipfile); err == nil {
-			return cached{zipfile, nil}
+			if _, err := os.Stat(ziphashfile); err == nil {
+				return cached{zipfile, nil}
+			}
 		}
 
-		// The zip file does not exist. Acquire the lock and create it.
+		// The zip or ziphash file does not exist. Acquire the lock and create them.
 		if cfg.CmdName != "mod download" {
 			fmt.Fprintf(os.Stderr, "go: downloading %s %s\n", mod.Path, mod.Version)
 		}
@@ -184,14 +187,6 @@ func DownloadZip(ctx context.Context, mod module.Version) (zipfile string, err e
 		}
 		defer unlock()
 
-		// Double-check that the zipfile was not created while we were waiting for
-		// the lock.
-		if _, err := os.Stat(zipfile); err == nil {
-			return cached{zipfile, nil}
-		}
-		if err := os.MkdirAll(filepath.Dir(zipfile), 0777); err != nil {
-			return cached{"", err}
-		}
 		if err := downloadZip(ctx, mod, zipfile); err != nil {
 			return cached{"", err}
 		}
@@ -204,6 +199,25 @@ func downloadZip(ctx context.Context, mod module.Version, zipfile string) (err e
 	ctx, span := trace.StartSpan(ctx, "modfetch.downloadZip "+zipfile)
 	defer span.Done()
 
+	// Double-check that the zipfile was not created while we were waiting for
+	// the lock in DownloadZip.
+	ziphashfile := zipfile + "hash"
+	var zipExists, ziphashExists bool
+	if _, err := os.Stat(zipfile); err == nil {
+		zipExists = true
+	}
+	if _, err := os.Stat(ziphashfile); err == nil {
+		ziphashExists = true
+	}
+	if zipExists && ziphashExists {
+		return nil
+	}
+
+	// Create parent directories.
+	if err := os.MkdirAll(filepath.Dir(zipfile), 0777); err != nil {
+		return err
+	}
+
 	// Clean up any remaining tempfiles from previous runs.
 	// This is only safe to do because the lock file ensures that their
 	// writers are no longer active.
@@ -215,6 +229,12 @@ func downloadZip(ctx context.Context, mod module.Version, zipfile string) (err e
 		}
 	}
 
+	// If the zip file exists, the ziphash file must have been deleted
+	// or lost after a file system crash. Re-hash the zip without downloading.
+	if zipExists {
+		return hashZip(mod, zipfile, ziphashfile)
+	}
+
 	// From here to the os.Rename call below is functionally almost equivalent to
 	// renameio.WriteToFile, with one key difference: we want to validate the
 	// contents of the file (by hashing it) before we commit it. Because the file
@@ -287,15 +307,7 @@ func downloadZip(ctx context.Context, mod module.Version, zipfile string) (err e
 	}
 
 	// Hash the zip file and check the sum before renaming to the final location.
-	hash, err := dirhash.HashZip(f.Name(), dirhash.DefaultHash)
-	if err != nil {
-		return err
-	}
-	if err := checkModSum(mod, hash); err != nil {
-		return err
-	}
-
-	if err := renameio.WriteFile(zipfile+"hash", []byte(hash), 0666); err != nil {
+	if err := hashZip(mod, f.Name(), ziphashfile); err != nil {
 		return err
 	}
 	if err := os.Rename(f.Name(), zipfile); err != nil {
@@ -307,6 +319,22 @@ func downloadZip(ctx context.Context, mod module.Version, zipfile string) (err e
 	return nil
 }
 
+// hashZip reads the zip file opened in f, then writes the hash to ziphashfile,
+// overwriting that file if it exists.
+//
+// If the hash does not match go.sum (or the sumdb if enabled), hashZip returns
+// an error and does not write ziphashfile.
+func hashZip(mod module.Version, zipfile, ziphashfile string) error {
+	hash, err := dirhash.HashZip(zipfile, dirhash.DefaultHash)
+	if err != nil {
+		return err
+	}
+	if err := checkModSum(mod, hash); err != nil {
+		return err
+	}
+	return renameio.WriteFile(ziphashfile, []byte(hash), 0666)
+}
+
 // makeDirsReadOnly makes a best-effort attempt to remove write permissions for dir
 // and its transitive contents.
 func makeDirsReadOnly(dir string) {
@@ -450,11 +478,6 @@ func HaveSum(mod module.Version) bool {
 
 // checkMod checks the given module's checksum.
 func checkMod(mod module.Version) {
-	if cfg.GOMODCACHE == "" {
-		// Do not use current directory.
-		return
-	}
-
 	// Do the file I/O before acquiring the go.sum lock.
 	ziphash, err := CachePath(mod, "ziphash")
 	if err != nil {
@@ -462,10 +485,6 @@ func checkMod(mod module.Version) {
 	}
 	data, err := renameio.ReadFile(ziphash)
 	if err != nil {
-		if errors.Is(err, fs.ErrNotExist) {
-			// This can happen if someone does rm -rf GOPATH/src/cache/download. So it goes.
-			return
-		}
 		base.Fatalf("verifying %v", module.VersionError(mod, err))
 	}
 	h := strings.TrimSpace(string(data))
diff --git a/src/cmd/go/testdata/script/mod_get_missing_ziphash.txt b/src/cmd/go/testdata/script/mod_get_missing_ziphash.txt
new file mode 100644
index 0000000000..8f6793edf5
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_get_missing_ziphash.txt
@@ -0,0 +1,55 @@
+# Test that if the module cache contains an extracted source directory but not
+# a ziphash, 'go build' complains about a missing sum, and 'go get' adds
+# the sum. Verifies #44749.
+
+# With a tidy go.sum, go build succeeds. This also populates the module cache.
+cp go.sum.tidy go.sum
+go build -n use
+env GOPROXY=off
+env GOSUMDB=off
+
+# Control case: if we delete the hash for rsc.io/quote v1.5.2,
+# 'go build' reports an error. 'go get' adds the sum.
+cp go.sum.bug go.sum
+! go build -n use
+stderr '^use.go:3:8: missing go.sum entry for module providing package rsc.io/quote \(imported by use\); to add:\n\tgo get use$'
+go get -d use
+cmp go.sum go.sum.tidy
+go build -n use
+
+# If we delete the hash *and* the ziphash file, we should see the same behavior.
+cp go.sum.bug go.sum
+rm $WORK/gopath/pkg/mod/cache/download/rsc.io/quote/@v/v1.5.2.ziphash
+! go build -n use
+stderr '^use.go:3:8: missing go.sum entry for module providing package rsc.io/quote \(imported by use\); to add:\n\tgo get use$'
+go get -d use
+cmp go.sum go.sum.tidy
+go build -n use
+
+-- go.mod --
+module use
+
+go 1.17
+
+require rsc.io/quote v1.5.2
+-- go.sum.tidy --
+golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c h1:pvCbr/wm8HzDD3fVywevekufpn6tCGPY3spdHeZJEsw=
+golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+rsc.io/quote v1.5.2 h1:3fEykkD9k7lYzXqCYrwGAf7iNhbk4yCjHmKBN9td4L0=
+rsc.io/quote v1.5.2/go.mod h1:LzX7hefJvL54yjefDEDHNONDjII0t9xZLPXsUe+TKr0=
+rsc.io/sampler v1.3.0 h1:HLGR/BgEtI3r0uymSP/nl2uPLsUnNJX8toRyhfpBTII=
+rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
+rsc.io/testonly v1.0.0 h1:K/VWHdO+Jv7woUXG0GzVNx1czBXUt3Ib1deaMn+xk64=
+rsc.io/testonly v1.0.0/go.mod h1:OqmGbIFOcF+XrFReLOGZ6BhMM7uMBiQwZsyNmh74SzY=
+-- go.sum.bug --
+golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c h1:pvCbr/wm8HzDD3fVywevekufpn6tCGPY3spdHeZJEsw=
+golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+rsc.io/quote v1.5.2/go.mod h1:LzX7hefJvL54yjefDEDHNONDjII0t9xZLPXsUe+TKr0=
+rsc.io/sampler v1.3.0 h1:HLGR/BgEtI3r0uymSP/nl2uPLsUnNJX8toRyhfpBTII=
+rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
+rsc.io/testonly v1.0.0 h1:K/VWHdO+Jv7woUXG0GzVNx1czBXUt3Ib1deaMn+xk64=
+rsc.io/testonly v1.0.0/go.mod h1:OqmGbIFOcF+XrFReLOGZ6BhMM7uMBiQwZsyNmh74SzY=
+-- use.go --
+package use
+
+import _ "rsc.io/quote"
diff --git a/src/cmd/go/testdata/script/mod_verify.txt b/src/cmd/go/testdata/script/mod_verify.txt
index 43812d069f..b5106659a9 100644
--- a/src/cmd/go/testdata/script/mod_verify.txt
+++ b/src/cmd/go/testdata/script/mod_verify.txt
@@ -48,10 +48,13 @@ go mod tidy
 grep '^rsc.io/quote v1.1.0/go.mod ' go.sum
 grep '^rsc.io/quote v1.1.0 ' go.sum
 
-# sync should ignore missing ziphash; verify should not
+# verify should fail on a missing ziphash. tidy should restore it.
 rm $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.1.0.ziphash
-go mod tidy
 ! go mod verify
+stderr '^rsc.io/quote v1.1.0: missing ziphash: open '$GOPATH'[/\\]pkg[/\\]mod[/\\]cache[/\\]download[/\\]rsc.io[/\\]quote[/\\]@v[/\\]v1.1.0.ziphash'
+go mod tidy
+exists $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.1.0.ziphash
+go mod verify
 
 # Packages below module root should not be mentioned in go.sum.
 rm go.sum
-- 
GitLab


From c5a1c2276ee41a65cce93b7e443d333dfa29aba7 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Wed, 17 Feb 2021 19:28:33 +0000
Subject: [PATCH 0950/2400] reflect: use global variables for register count

This change switches reflect to use global variables for ABI-related
register counts instead of internal/abi constants. The advantage of
doing so is that we can make the internal/abi constants non-zero and
enable the runtime register argument spiller/unspiller even if they're
not used. It's basically turning two things we need to flip when we
switch to the register ABI into one.

It also paves the way for testing the reflect register ABI path
independently, because now we can switch the global variables at will
and run the register-assignment algorithm in tests without having the
rest of the runtime be broken.

Change-Id: Ie23629a37a5c80aeb24909d4bd9eacbd3f0c06d9
Reviewed-on: https://go-review.googlesource.com/c/go/+/293149
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/internal/abi/abi_amd64.go | 10 +++-------
 src/reflect/abi.go            | 28 ++++++++++++++++++++++++++--
 src/runtime/asm_amd64.s       |  5 +----
 3 files changed, 30 insertions(+), 13 deletions(-)

diff --git a/src/internal/abi/abi_amd64.go b/src/internal/abi/abi_amd64.go
index 77589d4c34..07c3ec1aab 100644
--- a/src/internal/abi/abi_amd64.go
+++ b/src/internal/abi/abi_amd64.go
@@ -10,16 +10,12 @@ package abi
 const (
 	// See abi_generic.go.
 
-	// Currently these values are zero because whatever uses
-	// them will expect the register ABI, which isn't ready
-	// yet.
-
 	// RAX, RBX, RCX, RDI, RSI, R8, R9, R10, R11.
-	IntArgRegs = 0 // 9
+	IntArgRegs = 9
 
 	// X0 -> X14.
-	FloatArgRegs = 0 // 15
+	FloatArgRegs = 15
 
 	// We use SSE2 registers which support 64-bit float operations.
-	EffectiveFloatRegSize = 0 // 8
+	EffectiveFloatRegSize = 8
 )
diff --git a/src/reflect/abi.go b/src/reflect/abi.go
index 36d6b3095b..618efd0980 100644
--- a/src/reflect/abi.go
+++ b/src/reflect/abi.go
@@ -9,6 +9,30 @@ import (
 	"unsafe"
 )
 
+// These variables are used by the register assignment
+// algorithm in this file.
+//
+// They should be modified with care (no other reflect code
+// may be executing) and are generally only modified
+// when testing this package.
+//
+// They should never be set higher than their internal/abi
+// constant counterparts, because the system relies on a
+// structure that is at least large enough to hold the
+// registers the system supports.
+//
+// Currently they're set to zero because using the actual
+// constants will break every part of the toolchain that
+// uses reflect to call functions (e.g. go test, or anything
+// that uses text/template). The values that are currently
+// commented out there should be the actual values once
+// we're ready to use the register ABI everywhere.
+var (
+	intArgRegs   = 0          // abi.IntArgRegs
+	floatArgRegs = 0          // abi.FloatArgRegs
+	floatRegSize = uintptr(0) // uintptr(abi.EffectiveFloatRegSize)
+)
+
 // abiStep represents an ABI "instruction." Each instruction
 // describes one part of how to translate between a Go value
 // in memory and a call frame.
@@ -226,7 +250,7 @@ func (a *abiSeq) assignIntN(offset, size uintptr, n int, ptrMap uint8) bool {
 	if ptrMap != 0 && size != ptrSize {
 		panic("non-empty pointer map passed for non-pointer-size values")
 	}
-	if a.iregs+n > abi.IntArgRegs {
+	if a.iregs+n > intArgRegs {
 		return false
 	}
 	for i := 0; i < n; i++ {
@@ -255,7 +279,7 @@ func (a *abiSeq) assignFloatN(offset, size uintptr, n int) bool {
 	if n < 0 {
 		panic("invalid n")
 	}
-	if a.fregs+n > abi.FloatArgRegs || abi.EffectiveFloatRegSize < size {
+	if a.fregs+n > floatArgRegs || floatRegSize < size {
 		return false
 	}
 	for i := 0; i < n; i++ {
diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index 517c5a9d3e..ddd6a5bd5b 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -442,10 +442,7 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0
 	MOVL	$0, DX
 	JMP	runtime·morestack(SB)
 
-// REFLECTCALL_USE_REGABI is not defined. It must be defined in conjunction with the
-// register constants in the internal/abi package.
-
-#ifdef REFLECTCALL_USE_REGABI
+#ifdef GOEXPERIMENT_REGABI
 // spillArgs stores return values from registers to a *internal/abi.RegArgs in R12.
 TEXT spillArgs<>(SB),NOSPLIT,$0-0
 	MOVQ AX, 0(R12)
-- 
GitLab


From a2f70672334ecc71c81bd1f424e1734485d8cb83 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Thu, 18 Feb 2021 17:33:01 +0000
Subject: [PATCH 0951/2400] reflect: include the alignment of zero-sized types
 in stack offsets

This change modifies the reflect ABI assignment algorithm to catch
zero-sized types at the top level of each argument and faux-stack-assign
them. It doesn't actually generate an ABI step, which is unnecessary,
but it ensures that the offsets of further stack-assigned arguments are
aligned to the alignment of that zero-sized argument.

This change is necessary to have the register ABI assignment algorithm
gracefully degrade to ABI0 when no registers are present in the ABI.

Fixes #44377.

Change-Id: Ia95571688a61259302bb3c6d5fb33fbb6b5e8db8
Reviewed-on: https://go-review.googlesource.com/c/go/+/293789
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: Than McIntosh <thanm@google.com>
---
 src/reflect/abi.go | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/src/reflect/abi.go b/src/reflect/abi.go
index 618efd0980..50e6312172 100644
--- a/src/reflect/abi.go
+++ b/src/reflect/abi.go
@@ -123,6 +123,24 @@ func (a *abiSeq) stepsForValue(i int) []abiStep {
 func (a *abiSeq) addArg(t *rtype) *abiStep {
 	pStart := len(a.steps)
 	a.valueStart = append(a.valueStart, pStart)
+	if t.size == 0 {
+		// If the size of the argument type is zero, then
+		// in order to degrade gracefully into ABI0, we need
+		// to stack-assign this type. The reason is that
+		// although zero-sized types take up no space on the
+		// stack, they do cause the next argument to be aligned.
+		// So just do that here, but don't bother actually
+		// generating a new ABI step for it (there's nothing to
+		// actually copy).
+		//
+		// We cannot handle this in the recursive case of
+		// regAssign because zero-sized *fields* of a
+		// non-zero-sized struct do not cause it to be
+		// stack-assigned. So we need a special case here
+		// at the top.
+		a.stackBytes = align(a.stackBytes, uintptr(t.align))
+		return nil
+	}
 	if !a.regAssign(t, 0) {
 		a.steps = a.steps[:pStart]
 		a.stackAssign(t.size, uintptr(t.align))
-- 
GitLab


From 280c735b07af9ea313d73049b0031f466e8d1000 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Thu, 4 Mar 2021 23:12:22 -0500
Subject: [PATCH 0952/2400] cmd/go: require a module root in 'go list -m' with
 an unversioned path

Fixes #44803

Change-Id: Ie6ee2e3bca1809c91ecedec75d2c6620da914b29
Reviewed-on: https://go-review.googlesource.com/c/go/+/298752
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modload/list.go                 | 9 +++++++--
 src/cmd/go/testdata/script/mod_outside.txt          | 5 +++++
 src/cmd/go/testdata/script/mod_retract_versions.txt | 5 +++++
 3 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/src/cmd/go/internal/modload/list.go b/src/cmd/go/internal/modload/list.go
index c7ef8c9fb7..44803e960b 100644
--- a/src/cmd/go/internal/modload/list.go
+++ b/src/cmd/go/internal/modload/list.go
@@ -72,8 +72,13 @@ func listModules(ctx context.Context, args []string, listVersions, listRetracted
 		if search.IsRelativePath(arg) {
 			base.Fatalf("go: cannot use relative path %s to specify module", arg)
 		}
-		if !HasModRoot() && (arg == "all" || strings.Contains(arg, "...")) {
-			base.Fatalf("go: cannot match %q: %v", arg, ErrNoModRoot)
+		if !HasModRoot() {
+			if arg == "all" || strings.Contains(arg, "...") {
+				base.Fatalf("go: cannot match %q: %v", arg, ErrNoModRoot)
+			}
+			if !listVersions && !strings.Contains(arg, "@") {
+				base.Fatalf("go: cannot match %q without -versions or an explicit version: %v", arg, ErrNoModRoot)
+			}
 		}
 		if i := strings.Index(arg, "@"); i >= 0 {
 			path := arg[:i]
diff --git a/src/cmd/go/testdata/script/mod_outside.txt b/src/cmd/go/testdata/script/mod_outside.txt
index 9d4c22c77b..7c57db9f7c 100644
--- a/src/cmd/go/testdata/script/mod_outside.txt
+++ b/src/cmd/go/testdata/script/mod_outside.txt
@@ -61,6 +61,11 @@ stderr 'go: cannot match "all": go.mod file not found in current directory or an
 stderr 'go: cannot match "all": go.mod file not found in current directory or any parent directory; see ''go help modules''$'
 ! stdout 'example.com/version'
 
+# 'go list -m <mods>' should fail if any of the mods lacks an explicit version.
+! go list -m example.com/printversion
+stderr 'go: cannot match "example.com/printversion" without -versions or an explicit version: go.mod file not found in current directory or any parent directory; see ''go help modules''$'
+! stdout 'example.com/version'
+
 # 'go list -m' with wildcards should fail. Wildcards match modules in the
 # build list, so they aren't meaningful outside a module.
 ! go list -m ...
diff --git a/src/cmd/go/testdata/script/mod_retract_versions.txt b/src/cmd/go/testdata/script/mod_retract_versions.txt
index 961a0a1fa3..012fa15f42 100644
--- a/src/cmd/go/testdata/script/mod_retract_versions.txt
+++ b/src/cmd/go/testdata/script/mod_retract_versions.txt
@@ -15,3 +15,8 @@ stdout '^example.com/retract/self/pseudo ""$'
 
 go list -m -e -f $FMT --versions example.com/retract/self/pseudo@latest
 stdout '^example.com/retract/self/pseudo: "module example.com/retract/self/pseudo: no matching versions for query \\"latest\\"" "latest"$'
+
+-- go.mod --
+module test
+
+go 1.17
-- 
GitLab


From 67b9ecb23b16ed63f974e6741e1f229eab023ff5 Mon Sep 17 00:00:00 2001
From: Michael Pratt <mpratt@google.com>
Date: Tue, 17 Nov 2020 12:28:40 -0500
Subject: [PATCH 0953/2400] runtime: update paniclk ordering

Now that allglock is no longer taken in throw, paniclk can move to the
bottom of the lock order where it belongs.

There is no fundamental reason that we really need to skip checks on
paniclk in lockWithRank (despite the recursive throws that could be
caused by lock rank checking, startpanic_m would still allow the crash
to complete). However, the partial order of lockRankPanic should be
every single lock that may be held before a throw, nil dereference,
out-of-bounds access, which our partial order doesn't cover.

Updates #42669

Change-Id: Ic3efaea873dc2dd9fd5b0d6ccdd5319730b29a22
Reviewed-on: https://go-review.googlesource.com/c/go/+/270862
Trust: Michael Pratt <mpratt@google.com>
Run-TryBot: Michael Pratt <mpratt@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/lockrank.go    |  8 ++++----
 src/runtime/lockrank_on.go | 11 +++++------
 2 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/src/runtime/lockrank.go b/src/runtime/lockrank.go
index b3c01ba104..23b727f4d8 100644
--- a/src/runtime/lockrank.go
+++ b/src/runtime/lockrank.go
@@ -44,7 +44,6 @@ const (
 	lockRankPollDesc
 	lockRankSched
 	lockRankDeadlock
-	lockRankPanic
 	lockRankAllg
 	lockRankAllp
 
@@ -92,6 +91,7 @@ const (
 	// rank, we don't allow any further locks to be acquired other than more
 	// hchan locks.
 	lockRankHchanLeaf
+	lockRankPanic
 
 	// Leaf locks with no dependencies, so these constants are not actually used anywhere.
 	// There are other architecture-dependent leaf locks as well.
@@ -123,7 +123,6 @@ var lockNames = []string{
 	lockRankPollDesc: "pollDesc",
 	lockRankSched:    "sched",
 	lockRankDeadlock: "deadlock",
-	lockRankPanic:    "panic",
 	lockRankAllg:     "allg",
 	lockRankAllp:     "allp",
 
@@ -162,6 +161,7 @@ var lockNames = []string{
 
 	lockRankGFree:     "gFree",
 	lockRankHchanLeaf: "hchanLeaf",
+	lockRankPanic:     "panic",
 
 	lockRankNewmHandoff:   "newmHandoff.lock",
 	lockRankDebugPtrmask:  "debugPtrmask.lock",
@@ -202,8 +202,7 @@ var lockPartialOrder [][]lockRank = [][]lockRank{
 	lockRankPollDesc:      {},
 	lockRankSched:         {lockRankSysmon, lockRankScavenge, lockRankForcegc, lockRankSweepWaiters, lockRankAssistQueue, lockRankCpuprof, lockRankSweep, lockRankPollDesc},
 	lockRankDeadlock:      {lockRankDeadlock},
-	lockRankPanic:         {lockRankDeadlock},
-	lockRankAllg:          {lockRankSysmon, lockRankSched, lockRankPanic},
+	lockRankAllg:          {lockRankSysmon, lockRankSched},
 	lockRankAllp:          {lockRankSysmon, lockRankSched},
 	lockRankTimers:        {lockRankSysmon, lockRankScavenge, lockRankSched, lockRankAllp, lockRankPollDesc, lockRankTimers},
 	lockRankItab:          {},
@@ -237,6 +236,7 @@ var lockPartialOrder [][]lockRank = [][]lockRank{
 
 	lockRankGFree:     {lockRankSched},
 	lockRankHchanLeaf: {lockRankGscan, lockRankHchanLeaf},
+	lockRankPanic:     {lockRankDeadlock}, // plus any other lock held on throw.
 
 	lockRankNewmHandoff:   {},
 	lockRankDebugPtrmask:  {},
diff --git a/src/runtime/lockrank_on.go b/src/runtime/lockrank_on.go
index 7d45debaca..3958d9eeaa 100644
--- a/src/runtime/lockrank_on.go
+++ b/src/runtime/lockrank_on.go
@@ -65,12 +65,11 @@ func lockWithRank(l *mutex, rank lockRank) {
 		// rank recording for it, since print/println are used when
 		// printing out a lock ordering problem below.
 		//
-		// paniclk has an ordering problem, since it can be acquired
-		// during a panic with any other locks held (especially if the
-		// panic is because of a directed segv), and yet also allg is
-		// acquired after paniclk in tracebackothers()). This is a genuine
-		// problem, so for now we don't do lock rank recording for paniclk
-		// either.
+		// paniclk is only used for fatal throw/panic. Don't do lock
+		// ranking recording for it, since we throw after reporting a
+		// lock ordering problem. Additionally, paniclk may be taken
+		// after effectively any lock (anywhere we might panic), which
+		// the partial order doesn't cover.
 		lock2(l)
 		return
 	}
-- 
GitLab


From d4247f516724cae2e84a4d1bef71bd47aa2fd1d8 Mon Sep 17 00:00:00 2001
From: Adrien Delorme <azr@users.noreply.github.com>
Date: Fri, 5 Mar 2021 15:59:12 +0000
Subject: [PATCH 0954/2400] text/template: wrap errors returned by template
 functions instead of stringifying them
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fixes #34201

Change-Id: Ic2e2967e4b01167345cf38bd006cabb206a64377
GitHub-Last-Rev: 5d0c4856550614484a8dbfb68c37aa1abcfcc529
GitHub-Pull-Request: golang/go#42398
Reviewed-on: https://go-review.googlesource.com/c/go/+/267838
Reviewed-by: Daniel Martí <mvdan@mvdan.cc>
Trust: Daniel Martí <mvdan@mvdan.cc>
Trust: Pontus Leitzler <leitzler@gmail.com>
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/text/template/exec.go      |  2 +-
 src/text/template/exec_test.go | 22 ++++++++++++++++++++++
 src/text/template/funcs.go     |  5 ++++-
 3 files changed, 27 insertions(+), 2 deletions(-)

diff --git a/src/text/template/exec.go b/src/text/template/exec.go
index 4637b2035f..f1305a29a0 100644
--- a/src/text/template/exec.go
+++ b/src/text/template/exec.go
@@ -727,7 +727,7 @@ func (s *state) evalCall(dot, fun reflect.Value, node parse.Node, name string, a
 	// error to the caller.
 	if err != nil {
 		s.at(node)
-		s.errorf("error calling %s: %v", name, err)
+		s.errorf("error calling %s: %w", name, err)
 	}
 	if v.Type() == reflectValueType {
 		v = v.Interface().(reflect.Value)
diff --git a/src/text/template/exec_test.go b/src/text/template/exec_test.go
index 1a129ed5af..255b111b34 100644
--- a/src/text/template/exec_test.go
+++ b/src/text/template/exec_test.go
@@ -902,6 +902,28 @@ func TestExecError(t *testing.T) {
 	}
 }
 
+type CustomError struct{}
+
+func (*CustomError) Error() string { return "heyo !" }
+
+// Check that a custom error can be returned.
+func TestExecError_CustomError(t *testing.T) {
+	failingFunc := func() (string, error) {
+		return "", &CustomError{}
+	}
+	tmpl := Must(New("top").Funcs(FuncMap{
+		"err": failingFunc,
+	}).Parse("{{ err }}"))
+
+	var b bytes.Buffer
+	err := tmpl.Execute(&b, nil)
+
+	var e *CustomError
+	if !errors.As(err, &e) {
+		t.Fatalf("expected custom error; got %s", err)
+	}
+}
+
 func TestJSEscaping(t *testing.T) {
 	testCases := []struct {
 		in, exp string
diff --git a/src/text/template/funcs.go b/src/text/template/funcs.go
index 1b6940a84a..9dd332c068 100644
--- a/src/text/template/funcs.go
+++ b/src/text/template/funcs.go
@@ -23,6 +23,9 @@ import (
 // return value evaluates to non-nil during execution, execution terminates and
 // Execute returns that error.
 //
+// Errors returned by Execute wrap the underlying error; call errors.As to
+// uncover them.
+//
 // When template execution invokes a function with an argument list, that list
 // must be assignable to the function's parameter types. Functions meant to
 // apply to arguments of arbitrary type can use parameters of type interface{} or
@@ -344,7 +347,7 @@ func call(fn reflect.Value, args ...reflect.Value) (reflect.Value, error) {
 
 		var err error
 		if argv[i], err = prepareArg(arg, argType); err != nil {
-			return reflect.Value{}, fmt.Errorf("arg %d: %s", i, err)
+			return reflect.Value{}, fmt.Errorf("arg %d: %w", i, err)
 		}
 	}
 	return safeCall(fn, argv)
-- 
GitLab


From 70b277cf2e953bb9994b00898280f4659a47471e Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Thu, 4 Mar 2021 14:27:36 +0700
Subject: [PATCH 0955/2400] cmd/compile: only check return for valid functions

CheckReturn uses fn.Type() unconditionally, so for invalid function,
fn.Type() will be nil, causes the compiler crashes.

Updates #43311

Change-Id: I4420dd296c72ea83986b38fbf2c7f51fa59757c8
Reviewed-on: https://go-review.googlesource.com/c/go/+/298709
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/typecheck/typecheck.go |  2 +-
 test/fixedbugs/issue17588.go                    | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 240f0409e7..030158b1a1 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -2104,7 +2104,7 @@ func CheckUnused(fn *ir.Func) {
 
 // CheckReturn makes sure that fn terminates appropriately.
 func CheckReturn(fn *ir.Func) {
-	if fn.Type().NumResults() != 0 && len(fn.Body) != 0 {
+	if fn.Type() != nil && fn.Type().NumResults() != 0 && len(fn.Body) != 0 {
 		markBreak(fn)
 		if !isTermNodes(fn.Body) {
 			base.ErrorfAt(fn.Endlineno, "missing return at end of function")
diff --git a/test/fixedbugs/issue17588.go b/test/fixedbugs/issue17588.go
index ed5312fa21..5c0787bf1d 100644
--- a/test/fixedbugs/issue17588.go
+++ b/test/fixedbugs/issue17588.go
@@ -1,4 +1,4 @@
-// errorcheck
+// errorcheck -d=panic
 
 // Copyright 2016 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -11,10 +11,10 @@
 
 package p
 
-type F func(b T)  // ERROR "T .*is not a type|expected type"
+type F func(b T) // ERROR "T .*is not a type|expected type"
 
 func T(fn F) {
-    func() {
-        fn(nil)  // If Decldepth is not initialized properly, typecheckclosure() Fatals here.
-    }()
+	func() {
+		fn(nil) // If Decldepth is not initialized properly, typecheckclosure() Fatals here.
+	}()
 }
-- 
GitLab


From 80098ef00c1c8a832b2d67d7cbd4dea5f8eff6e9 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Thu, 4 Mar 2021 14:40:50 +0700
Subject: [PATCH 0956/2400] cmd/compile: don't expand invalid embedded
 interface

The invalid interface type will be reported already, so don't expand
that invalid one, which causes the compiler crashes.

Updates #43311

Change-Id: Ic335cfa74f0b9fcfd0929dc5fd31d9156a8f5f5c
Reviewed-on: https://go-review.googlesource.com/c/go/+/298710
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/types/size.go | 2 +-
 test/fixedbugs/issue20245.go           | 2 +-
 test/fixedbugs/issue22921.go           | 2 +-
 test/fixedbugs/issue27938.go           | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/types/size.go b/src/cmd/compile/internal/types/size.go
index 4c7378560c..ef23cdf5fe 100644
--- a/src/cmd/compile/internal/types/size.go
+++ b/src/cmd/compile/internal/types/size.go
@@ -100,7 +100,7 @@ func expandiface(t *Type) {
 	}
 
 	for _, m := range t.Methods().Slice() {
-		if m.Sym != nil {
+		if m.Sym != nil || m.Type == nil {
 			continue
 		}
 
diff --git a/test/fixedbugs/issue20245.go b/test/fixedbugs/issue20245.go
index b07dbe20de..20258231d1 100644
--- a/test/fixedbugs/issue20245.go
+++ b/test/fixedbugs/issue20245.go
@@ -1,4 +1,4 @@
-// errorcheck
+// errorcheck -d=panic
 
 // Copyright 2017 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/issue22921.go b/test/fixedbugs/issue22921.go
index 5336ba3410..cdd77fb24f 100644
--- a/test/fixedbugs/issue22921.go
+++ b/test/fixedbugs/issue22921.go
@@ -1,4 +1,4 @@
-// errorcheck
+// errorcheck -d=panic
 
 // Copyright 2020 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/issue27938.go b/test/fixedbugs/issue27938.go
index ed974e642d..2589e1eff8 100644
--- a/test/fixedbugs/issue27938.go
+++ b/test/fixedbugs/issue27938.go
@@ -1,4 +1,4 @@
-// errorcheck
+// errorcheck -d=panic
 
 // Copyright 2018 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
-- 
GitLab


From 51d8d351c1bb2cac74e1bbf8545245cdbc8914c3 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Thu, 4 Mar 2021 20:56:01 +0700
Subject: [PATCH 0957/2400] cmd/compile: do not set type for OTYPESW

Same as CL 294031, but for OTYPESW.

Updates #43311

Change-Id: I996f5938835baff1d830c17ed75652315106bdfd
Reviewed-on: https://go-review.googlesource.com/c/go/+/298712
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/typecheck/typecheck.go | 2 +-
 test/fixedbugs/issue24470.go                    | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 030158b1a1..647465af4f 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -876,7 +876,7 @@ func typecheck1(n ir.Node, top int) ir.Node {
 	case ir.OTYPESW:
 		n := n.(*ir.TypeSwitchGuard)
 		base.Errorf("use of .(type) outside type switch")
-		n.SetType(nil)
+		n.SetDiag(true)
 		return n
 
 	case ir.ODCLFUNC:
diff --git a/test/fixedbugs/issue24470.go b/test/fixedbugs/issue24470.go
index 2805998cca..5b7b2b5adf 100644
--- a/test/fixedbugs/issue24470.go
+++ b/test/fixedbugs/issue24470.go
@@ -1,4 +1,4 @@
-// errorcheck
+// errorcheck -d=panic
 
 // Copyright 2018 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -10,7 +10,7 @@
 package p
 
 func f(i interface{}) {
-	if x, ok := i.(type); ok { // ERROR "outside type switch"
+	if x, ok := i.(type); ok { // ERROR "assignment mismatch|outside type switch"
 		_ = x
 	}
 }
-- 
GitLab


From 9e6b1fcd0a42db0f4699ff17e3b248e563f7eee4 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Thu, 4 Mar 2021 22:24:58 +0700
Subject: [PATCH 0958/2400] cmd/compile: do not report error for invalid
 constant

Invalid constant was already reported by noder, so don't re-check in
typecheck, which lead to compiler crashing.

Updates #43311

Change-Id: I48e2f540601cef725c1ff628c066ed15d848e771
Reviewed-on: https://go-review.googlesource.com/c/go/+/298713
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/noder/noder.go         | 2 +-
 src/cmd/compile/internal/typecheck/typecheck.go | 4 +++-
 test/char_lit1.go                               | 2 +-
 test/fixedbugs/issue20232.go                    | 2 +-
 4 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 8c456e4561..4c7c9fc322 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -689,7 +689,7 @@ func (p *noder) expr(expr syntax.Expr) ir.Node {
 		if expr.Kind == syntax.RuneLit {
 			n.SetType(types.UntypedRune)
 		}
-		n.SetDiag(expr.Bad) // avoid follow-on errors if there was a syntax error
+		n.SetDiag(expr.Bad || n.Val().Kind() == constant.Unknown) // avoid follow-on errors if there was a syntax error
 		return n
 	case *syntax.CompositeLit:
 		n := ir.NewCompLitExpr(p.pos(expr), ir.OCOMPLIT, p.typeExpr(expr.Type), nil)
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 647465af4f..548c1af85c 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -482,7 +482,9 @@ func typecheck1(n ir.Node, top int) ir.Node {
 
 	case ir.OLITERAL:
 		if n.Sym() == nil && n.Type() == nil {
-			base.Fatalf("literal missing type: %v", n)
+			if !n.Diag() {
+				base.Fatalf("literal missing type: %v", n)
+			}
 		}
 		return n
 
diff --git a/test/char_lit1.go b/test/char_lit1.go
index 489744b6e9..8899aff83a 100644
--- a/test/char_lit1.go
+++ b/test/char_lit1.go
@@ -1,4 +1,4 @@
-// errorcheck
+// errorcheck -d=panic
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/issue20232.go b/test/fixedbugs/issue20232.go
index 7a0300a4c4..846843dccb 100644
--- a/test/fixedbugs/issue20232.go
+++ b/test/fixedbugs/issue20232.go
@@ -1,4 +1,4 @@
-// errorcheck
+// errorcheck -d=panic
 
 // Copyright 2017 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
-- 
GitLab


From fbee173545da4ecbdd80a59edcb93e6c4605241f Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Thu, 4 Mar 2021 22:27:41 +0700
Subject: [PATCH 0959/2400] cmd/compile: fix wrong condition in tcShift

CL 279442 refactored typecheck arithmetic operators, but using wrong
condition for checking invalid rhs.

Updates #43311

Change-Id: I7a03a5535b82ac4ea4806725776b0a4f7af1b79a
Reviewed-on: https://go-review.googlesource.com/c/go/+/298714
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/typecheck/expr.go | 2 +-
 test/fixedbugs/bug297.go                   | 7 ++++---
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/expr.go b/src/cmd/compile/internal/typecheck/expr.go
index 339fb00aa4..10a4c1b1dc 100644
--- a/src/cmd/compile/internal/typecheck/expr.go
+++ b/src/cmd/compile/internal/typecheck/expr.go
@@ -48,7 +48,7 @@ func tcAddr(n *ir.AddrExpr) ir.Node {
 }
 
 func tcShift(n, l, r ir.Node) (ir.Node, ir.Node, *types.Type) {
-	if l.Type() == nil || l.Type() == nil {
+	if l.Type() == nil || r.Type() == nil {
 		return l, r, nil
 	}
 
diff --git a/test/fixedbugs/bug297.go b/test/fixedbugs/bug297.go
index c2bd253d05..70eb4ca9b2 100644
--- a/test/fixedbugs/bug297.go
+++ b/test/fixedbugs/bug297.go
@@ -1,4 +1,4 @@
-// errorcheck
+// errorcheck -d=panic
 
 // Copyright 2010 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -9,7 +9,8 @@
 package main
 
 type ByteSize float64
+
 const (
-	_ = iota;   // ignore first value by assigning to blank identifier
-	KB ByteSize = 1<<(10*X) // ERROR "undefined"
+	_           = iota          // ignore first value by assigning to blank identifier
+	KB ByteSize = 1 << (10 * X) // ERROR "undefined"
 )
-- 
GitLab


From c082f9fee0e08ac5ea6498ade1153fb6e68f7c72 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Thu, 4 Mar 2021 15:06:38 +0700
Subject: [PATCH 0960/2400] cmd/compile: do not set ONAME type when evaluated
 in type context

Updates #43311

Change-Id: I26e397d071b434256dab0cc7fff9d134b80bd6e3
Reviewed-on: https://go-review.googlesource.com/c/go/+/298711
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/typecheck/typecheck.go | 6 +++++-
 test/fixedbugs/issue22389.go                    | 2 +-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 548c1af85c..30632ac18b 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -446,7 +446,11 @@ func typecheck(n ir.Node, top int) (res ir.Node) {
 	case top&(ctxType|ctxExpr) == ctxType && n.Op() != ir.OTYPE && n.Op() != ir.ONONAME && (t != nil || n.Op() == ir.ONAME):
 		base.Errorf("%v is not a type", n)
 		if t != nil {
-			n.SetType(nil)
+			if n.Op() == ir.ONAME {
+				t.SetBroke(true)
+			} else {
+				n.SetType(nil)
+			}
 		}
 
 	}
diff --git a/test/fixedbugs/issue22389.go b/test/fixedbugs/issue22389.go
index 75dc285403..81e6d94e65 100644
--- a/test/fixedbugs/issue22389.go
+++ b/test/fixedbugs/issue22389.go
@@ -1,4 +1,4 @@
-// errorcheck
+// errorcheck -d=panic
 
 // Copyright 2017 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
-- 
GitLab


From 44721f4565858526545c69b4846daeea40843a98 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Thu, 4 Mar 2021 22:31:43 +0700
Subject: [PATCH 0961/2400] test: enable "-d=panic" by default for errorcheck*

Fixes #43311

Change-Id: I134d6c0524c198998a3c093dd3a8144052e8f7a9
Reviewed-on: https://go-review.googlesource.com/c/go/+/298715
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 test/run.go | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/test/run.go b/test/run.go
index 570768e680..4c01886560 100644
--- a/test/run.go
+++ b/test/run.go
@@ -725,7 +725,7 @@ func (t *test) run() {
 		// Fail if wantError is true and compilation was successful and vice versa.
 		// Match errors produced by gc against errors in comments.
 		// TODO(gri) remove need for -C (disable printing of columns in error messages)
-		cmdline := []string{goTool(), "tool", "compile", "-C", "-e", "-o", "a.o"}
+		cmdline := []string{goTool(), "tool", "compile", "-d=panic", "-C", "-e", "-o", "a.o"}
 		// No need to add -dynlink even if linkshared if we're just checking for errors...
 		cmdline = append(cmdline, flags...)
 		cmdline = append(cmdline, long)
@@ -830,6 +830,7 @@ func (t *test) run() {
 		}
 
 	case "errorcheckdir", "errorcheckandrundir":
+		flags = append(flags, "-d=panic")
 		// Compile and errorCheck all files in the directory as packages in lexicographic order.
 		// If errorcheckdir and wantError, compilation of the last package must fail.
 		// If errorcheckandrundir and wantError, compilation of the package prior the last must fail.
@@ -1179,7 +1180,7 @@ func (t *test) run() {
 			t.err = fmt.Errorf("write tempfile:%s", err)
 			return
 		}
-		cmdline := []string{goTool(), "tool", "compile", "-e", "-o", "a.o"}
+		cmdline := []string{goTool(), "tool", "compile", "-d=panic", "-e", "-o", "a.o"}
 		cmdline = append(cmdline, flags...)
 		cmdline = append(cmdline, tfile)
 		out, err = runcmd(cmdline...)
-- 
GitLab


From 39bdd41d03725878f1fd6f8b500ba6700f03bdad Mon Sep 17 00:00:00 2001
From: Kevin Burke <kevin@burke.dev>
Date: Tue, 2 Mar 2021 11:54:36 -0800
Subject: [PATCH 0962/2400] cmd/go/internal/modfetch/codehost: report git
 errors more accurately

Previously, if you attempted to fetch a private repository, or your
Git/curl client failed for an unknown reason, codehost would return an
UnknownRevisionError, which reported that a given revision in go.mod
was "unknown". This is confusing to many users who can go look in
their browser for example and see that the commit-ish exists.

Instead check whether "git ls-remote" exited with an error, and if so,
return that instead of the UnknownRevision message.

Fixes #42751.

Change-Id: I0dbded878b2818280e61126a4493767d719ad577
Reviewed-on: https://go-review.googlesource.com/c/go/+/297950
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Trust: Bryan C. Mills <bcmills@google.com>
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/internal/modfetch/codehost/git.go  |  6 ++++
 .../testdata/script/mod_get_private_vcs.txt   | 30 +++++++++++++++++++
 2 files changed, 36 insertions(+)

diff --git a/src/cmd/go/internal/modfetch/codehost/git.go b/src/cmd/go/internal/modfetch/codehost/git.go
index 72005e27d5..4d4964edf4 100644
--- a/src/cmd/go/internal/modfetch/codehost/git.go
+++ b/src/cmd/go/internal/modfetch/codehost/git.go
@@ -296,6 +296,9 @@ func (r *gitRepo) stat(rev string) (*RevInfo, error) {
 	// Or maybe it's the prefix of a hash of a named ref.
 	// Try to resolve to both a ref (git name) and full (40-hex-digit) commit hash.
 	r.refsOnce.Do(r.loadRefs)
+	// loadRefs may return an error if git fails, for example segfaults, or
+	// could not load a private repo, but defer checking to the else block
+	// below, in case we already have the rev in question in the local cache.
 	var ref, hash string
 	if r.refs["refs/tags/"+rev] != "" {
 		ref = "refs/tags/" + rev
@@ -332,6 +335,9 @@ func (r *gitRepo) stat(rev string) (*RevInfo, error) {
 			hash = rev
 		}
 	} else {
+		if r.refsErr != nil {
+			return nil, r.refsErr
+		}
 		return nil, &UnknownRevisionError{Rev: rev}
 	}
 
diff --git a/src/cmd/go/testdata/script/mod_get_private_vcs.txt b/src/cmd/go/testdata/script/mod_get_private_vcs.txt
index 514b0a7a53..8b01eac62c 100644
--- a/src/cmd/go/testdata/script/mod_get_private_vcs.txt
+++ b/src/cmd/go/testdata/script/mod_get_private_vcs.txt
@@ -9,3 +9,33 @@ env GOPROXY=direct
 stderr 'Confirm the import path was entered correctly.'
 stderr 'If this is a private repository, see https://golang.org/doc/faq#git_https for additional information.'
 ! stdout .
+
+# Fetching a nonexistent commit should return an "unknown revision"
+# error message.
+! go get github.com/golang/term@86186f3aba07ed0212cfb944f3398997d2d07c6b
+stderr '^go get: github.com/golang/term@86186f3aba07ed0212cfb944f3398997d2d07c6b: invalid version: unknown revision 86186f3aba07ed0212cfb944f3398997d2d07c6b$'
+! stdout .
+
+! go get github.com/golang/nonexist@master
+stderr '^Confirm the import path was entered correctly.$'
+stderr '^If this is a private repository, see https://golang.org/doc/faq#git_https for additional information.$'
+! stderr 'unknown revision'
+! stdout .
+
+[!linux] stop
+
+# Test that Git clone errors will be shown to the user instead of a generic
+# "unknown revision" error. To do this we want to force git ls-remote to return
+# an error we don't already have special handling for. See golang/go#42751.
+#
+# Set XDG_CONFIG_HOME to tell Git where to look for the git config file listed
+# below, which turns on ssh.
+env XDG_CONFIG_HOME=$TMPDIR
+! go install github.com/golang/nonexist@master
+stderr 'fatal: Could not read from remote repository.'
+! stderr 'unknown revision'
+! stdout .
+
+-- $TMPDIR/git/config --
+[url "git@github.com:"]
+    insteadOf = https://github.com/
-- 
GitLab


From d85083911d6ea742901933a544467dad55bb381f Mon Sep 17 00:00:00 2001
From: Michael Pratt <mpratt@google.com>
Date: Wed, 23 Dec 2020 15:05:37 -0500
Subject: [PATCH 0963/2400] runtime: encapsulate access to allgs

Correctly accessing allgs is a bit hairy. Some paths need to lock
allglock, some don't. Those that don't are safest using atomicAllG, but
usage is not consistent.

Rather than doing this ad-hoc, move all access* through forEachG /
forEachGRace, the locking and atomic versions, respectively. This will
make it easier to ensure safe access.

* markroot is the only exception, as it has a far-removed guarantee of
safe access via an atomic load of allglen far before actual use.

Change-Id: Ie1c7a8243e155ae2b4bc3143577380c695680e89
Reviewed-on: https://go-review.googlesource.com/c/go/+/279994
Trust: Michael Pratt <mpratt@google.com>
Run-TryBot: Michael Pratt <mpratt@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/heapdump.go  |  7 ++++---
 src/runtime/mgc.go       |  8 +++-----
 src/runtime/mgcmark.go   | 32 +++++++++++++++++++-------------
 src/runtime/mprof.go     | 35 +++++++++++++++++++----------------
 src/runtime/proc.go      | 40 +++++++++++++++++++++++++++++-----------
 src/runtime/trace.go     |  5 +++--
 src/runtime/traceback.go | 21 +++++++++------------
 7 files changed, 86 insertions(+), 62 deletions(-)

diff --git a/src/runtime/heapdump.go b/src/runtime/heapdump.go
index 2d531571aa..1b8c19b476 100644
--- a/src/runtime/heapdump.go
+++ b/src/runtime/heapdump.go
@@ -403,9 +403,10 @@ func dumpgoroutine(gp *g) {
 }
 
 func dumpgs() {
+	assertWorldStopped()
+
 	// goroutines & stacks
-	for i := 0; uintptr(i) < allglen; i++ {
-		gp := allgs[i]
+	forEachG(func(gp *g) {
 		status := readgstatus(gp) // The world is stopped so gp will not be in a scan state.
 		switch status {
 		default:
@@ -418,7 +419,7 @@ func dumpgs() {
 			_Gwaiting:
 			dumpgoroutine(gp)
 		}
-	}
+	})
 }
 
 func finq_callback(fn *funcval, obj unsafe.Pointer, nret uintptr, fint *_type, ot *ptrtype) {
diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index 7c7239beb8..6927e90daa 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -2229,14 +2229,12 @@ func gcSweep(mode gcMode) {
 //
 //go:systemstack
 func gcResetMarkState() {
-	// This may be called during a concurrent phase, so make sure
+	// This may be called during a concurrent phase, so lock to make sure
 	// allgs doesn't change.
-	lock(&allglock)
-	for _, gp := range allgs {
+	forEachG(func(gp *g) {
 		gp.gcscandone = false // set to true in gcphasework
 		gp.gcAssistBytes = 0
-	}
-	unlock(&allglock)
+	})
 
 	// Clear page marks. This is just 1MB per 64GB of heap, so the
 	// time here is pretty trivial.
diff --git a/src/runtime/mgcmark.go b/src/runtime/mgcmark.go
index 46fae5de72..b3c1e00ca5 100644
--- a/src/runtime/mgcmark.go
+++ b/src/runtime/mgcmark.go
@@ -116,23 +116,26 @@ func gcMarkRootCheck() {
 		throw("left over markroot jobs")
 	}
 
-	lock(&allglock)
 	// Check that stacks have been scanned.
-	var gp *g
-	for i := 0; i < work.nStackRoots; i++ {
-		gp = allgs[i]
+	//
+	// We only check the first nStackRoots Gs that we should have scanned.
+	// Since we don't care about newer Gs (see comment in
+	// gcMarkRootPrepare), no locking is required.
+	i := 0
+	forEachGRace(func(gp *g) {
+		if i >= work.nStackRoots {
+			return
+		}
+
 		if !gp.gcscandone {
-			goto fail
+			println("gp", gp, "goid", gp.goid,
+				"status", readgstatus(gp),
+				"gcscandone", gp.gcscandone)
+			throw("scan missed a g")
 		}
-	}
-	unlock(&allglock)
-	return
 
-fail:
-	println("gp", gp, "goid", gp.goid,
-		"status", readgstatus(gp),
-		"gcscandone", gp.gcscandone)
-	throw("scan missed a g")
+		i++
+	})
 }
 
 // ptrmask for an allocation containing a single pointer.
@@ -189,6 +192,9 @@ func markroot(gcw *gcWork, i uint32) {
 		// the rest is scanning goroutine stacks
 		var gp *g
 		if baseStacks <= i && i < end {
+			// N.B. Atomic read of allglen in gcMarkRootPrepare
+			// acts as a barrier to ensure that allgs must be large
+			// enough to contain all relevant Gs.
 			gp = allgs[i-baseStacks]
 		} else {
 			throw("markroot: bad index")
diff --git a/src/runtime/mprof.go b/src/runtime/mprof.go
index 128498d69b..c94b8f7cae 100644
--- a/src/runtime/mprof.go
+++ b/src/runtime/mprof.go
@@ -731,12 +731,13 @@ func goroutineProfileWithLabels(p []StackRecord, labels []unsafe.Pointer) (n int
 
 	stopTheWorld("profile")
 
+	// World is stopped, no locking required.
 	n = 1
-	for _, gp1 := range allgs {
+	forEachGRace(func(gp1 *g) {
 		if isOK(gp1) {
 			n++
 		}
-	}
+	})
 
 	if n <= len(p) {
 		ok = true
@@ -757,21 +758,23 @@ func goroutineProfileWithLabels(p []StackRecord, labels []unsafe.Pointer) (n int
 		}
 
 		// Save other goroutines.
-		for _, gp1 := range allgs {
-			if isOK(gp1) {
-				if len(r) == 0 {
-					// Should be impossible, but better to return a
-					// truncated profile than to crash the entire process.
-					break
-				}
-				saveg(^uintptr(0), ^uintptr(0), gp1, &r[0])
-				if labels != nil {
-					lbl[0] = gp1.labels
-					lbl = lbl[1:]
-				}
-				r = r[1:]
+		forEachGRace(func(gp1 *g) {
+			if !isOK(gp1) {
+				return
 			}
-		}
+
+			if len(r) == 0 {
+				// Should be impossible, but better to return a
+				// truncated profile than to crash the entire process.
+				return
+			}
+			saveg(^uintptr(0), ^uintptr(0), gp1, &r[0])
+			if labels != nil {
+				lbl[0] = gp1.labels
+				lbl = lbl[1:]
+			}
+			r = r[1:]
+		})
 	}
 
 	startTheWorld()
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 19049d21f3..5f372bb063 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -541,6 +541,30 @@ func atomicAllGIndex(ptr **g, i uintptr) *g {
 	return *(**g)(add(unsafe.Pointer(ptr), i*sys.PtrSize))
 }
 
+// forEachG calls fn on every G from allgs.
+//
+// forEachG takes a lock to exclude concurrent addition of new Gs.
+func forEachG(fn func(gp *g)) {
+	lock(&allglock)
+	for _, gp := range allgs {
+		fn(gp)
+	}
+	unlock(&allglock)
+}
+
+// forEachGRace calls fn on every G from allgs.
+//
+// forEachGRace avoids locking, but does not exclude addition of new Gs during
+// execution, which may be missed.
+func forEachGRace(fn func(gp *g)) {
+	ptr, length := atomicAllG()
+	for i := uintptr(0); i < length; i++ {
+		gp := atomicAllGIndex(ptr, i)
+		fn(gp)
+	}
+	return
+}
+
 const (
 	// Number of goroutine ids to grab from sched.goidgen to local per-P cache at once.
 	// 16 seems to provide enough amortization, but other than that it's mostly arbitrary number.
@@ -4969,11 +4993,9 @@ func checkdead() {
 	}
 
 	grunning := 0
-	lock(&allglock)
-	for i := 0; i < len(allgs); i++ {
-		gp := allgs[i]
+	forEachG(func(gp *g) {
 		if isSystemGoroutine(gp, false) {
-			continue
+			return
 		}
 		s := readgstatus(gp)
 		switch s &^ _Gscan {
@@ -4986,8 +5008,7 @@ func checkdead() {
 			print("runtime: checkdead: find g ", gp.goid, " in status ", s, "\n")
 			throw("checkdead: runnable g")
 		}
-	}
-	unlock(&allglock)
+	})
 	if grunning == 0 { // possible if main goroutine calls runtime·Goexit()
 		unlock(&sched.lock) // unlock so that GODEBUG=scheddetail=1 doesn't hang
 		throw("no goroutines (main called runtime.Goexit) - deadlock!")
@@ -5390,9 +5411,7 @@ func schedtrace(detailed bool) {
 		print("  M", mp.id, ": p=", id1, " curg=", id2, " mallocing=", mp.mallocing, " throwing=", mp.throwing, " preemptoff=", mp.preemptoff, ""+" locks=", mp.locks, " dying=", mp.dying, " spinning=", mp.spinning, " blocked=", mp.blocked, " lockedg=", id3, "\n")
 	}
 
-	lock(&allglock)
-	for gi := 0; gi < len(allgs); gi++ {
-		gp := allgs[gi]
+	forEachG(func(gp *g) {
 		mp := gp.m
 		lockedm := gp.lockedm.ptr()
 		id1 := int64(-1)
@@ -5404,8 +5423,7 @@ func schedtrace(detailed bool) {
 			id2 = lockedm.id
 		}
 		print("  G", gp.goid, ": status=", readgstatus(gp), "(", gp.waitreason.String(), ") m=", id1, " lockedm=", id2, "\n")
-	}
-	unlock(&allglock)
+	})
 	unlock(&sched.lock)
 }
 
diff --git a/src/runtime/trace.go b/src/runtime/trace.go
index bcd0b9d56c..bfaa00ee58 100644
--- a/src/runtime/trace.go
+++ b/src/runtime/trace.go
@@ -221,7 +221,8 @@ func StartTrace() error {
 	stackID := traceStackID(mp, stkBuf, 2)
 	releasem(mp)
 
-	for _, gp := range allgs {
+	// World is stopped, no need to lock.
+	forEachGRace(func(gp *g) {
 		status := readgstatus(gp)
 		if status != _Gdead {
 			gp.traceseq = 0
@@ -241,7 +242,7 @@ func StartTrace() error {
 		} else {
 			gp.sysblocktraced = false
 		}
-	}
+	})
 	traceProcStart()
 	traceGoStart()
 	// Note: ticksStart needs to be set after we emit traceEvGoInSyscall events.
diff --git a/src/runtime/traceback.go b/src/runtime/traceback.go
index 53eb689848..f8cda83098 100644
--- a/src/runtime/traceback.go
+++ b/src/runtime/traceback.go
@@ -945,19 +945,16 @@ func tracebackothers(me *g) {
 		traceback(^uintptr(0), ^uintptr(0), 0, curgp)
 	}
 
-	// We can't take allglock here because this may be during fatal
-	// throw/panic, where locking allglock could be out-of-order or a
-	// direct deadlock.
+	// We can't call locking forEachG here because this may be during fatal
+	// throw/panic, where locking could be out-of-order or a direct
+	// deadlock.
 	//
-	// Instead, use atomic access to allgs which requires no locking. We
-	// don't lock against concurrent creation of new Gs, but even with
-	// allglock we may miss Gs created after this loop.
-	ptr, length := atomicAllG()
-	for i := uintptr(0); i < length; i++ {
-		gp := atomicAllGIndex(ptr, i)
-
+	// Instead, use forEachGRace, which requires no locking. We don't lock
+	// against concurrent creation of new Gs, but even with allglock we may
+	// miss Gs created after this loop.
+	forEachGRace(func(gp *g) {
 		if gp == me || gp == curgp || readgstatus(gp) == _Gdead || isSystemGoroutine(gp, false) && level < 2 {
-			continue
+			return
 		}
 		print("\n")
 		goroutineheader(gp)
@@ -971,7 +968,7 @@ func tracebackothers(me *g) {
 		} else {
 			traceback(^uintptr(0), ^uintptr(0), 0, gp)
 		}
-	}
+	})
 }
 
 // tracebackHexdump hexdumps part of stk around frame.sp and frame.fp
-- 
GitLab


From a829114b21b5a4238dea13dc97b030d650935ed8 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Fri, 5 Mar 2021 15:12:37 -0500
Subject: [PATCH 0964/2400] cmd/compile: match Aux and AuxInt explicitly in
 store combining rule

CL 280456 introduced a new store combining rule. On the LHS some
of the Aux and AuxInt of the stores are not specified, therefore
ignored during the matching. The rule is only correct if they
match. This CL adds explict match.

TODO: maybe we want the rule matcher require Aux/AuxInt to be
always specified on the LHS (using _ to explicitly ignore)? Or
maybe we want it to match the zero value if not specified? The
current approach is error-prone.

Fixes #44823.

Change-Id: Ic12b4a0de63117f2f070039737f0c905f28561bc
Reviewed-on: https://go-review.googlesource.com/c/go/+/299289
Trust: Cherry Zhang <cherryyz@google.com>
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>
---
 src/cmd/compile/internal/ssa/gen/AMD64.rules | 10 ++++----
 src/cmd/compile/internal/ssa/gen/S390X.rules | 10 ++++----
 src/cmd/compile/internal/ssa/rewriteAMD64.go | 12 +++++----
 src/cmd/compile/internal/ssa/rewriteS390X.go | 12 +++++----
 test/fixedbugs/issue44823.go                 | 26 ++++++++++++++++++++
 5 files changed, 50 insertions(+), 20 deletions(-)
 create mode 100644 test/fixedbugs/issue44823.go

diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules
index bab9cee88c..7b03034bb7 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64.rules
+++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules
@@ -1970,15 +1970,15 @@
   && clobber(x)
   => (MOVQstore [i] {s} p0 w0 mem)
 
-(MOVBstore [7] p1 (SHRQconst [56] w)
-  x1:(MOVWstore [5] p1 (SHRQconst [40] w)
-  x2:(MOVLstore [1] p1 (SHRQconst [8] w)
-  x3:(MOVBstore p1 w mem))))
+(MOVBstore [7] {s} p1 (SHRQconst [56] w)
+  x1:(MOVWstore [5] {s} p1 (SHRQconst [40] w)
+  x2:(MOVLstore [1] {s} p1 (SHRQconst [8] w)
+  x3:(MOVBstore [0] {s} p1 w mem))))
   && x1.Uses == 1
   && x2.Uses == 1
   && x3.Uses == 1
   && clobber(x1, x2, x3)
-  => (MOVQstore p1 w mem)
+  => (MOVQstore {s} p1 w mem)
 
 (MOVBstore [i] {s} p
   x1:(MOVBload [j] {s2} p2 mem)
diff --git a/src/cmd/compile/internal/ssa/gen/S390X.rules b/src/cmd/compile/internal/ssa/gen/S390X.rules
index e4a1cd6981..1f75f78a71 100644
--- a/src/cmd/compile/internal/ssa/gen/S390X.rules
+++ b/src/cmd/compile/internal/ssa/gen/S390X.rules
@@ -1422,15 +1422,15 @@
   && clobber(x)
   => (MOVDBRstore [i-4] {s} p w0 mem)
 
-(MOVBstore [7] p1 (SRDconst w)
-  x1:(MOVHBRstore [5] p1 (SRDconst w)
-  x2:(MOVWBRstore [1] p1 (SRDconst w)
-  x3:(MOVBstore p1 w mem))))
+(MOVBstore [7] {s} p1 (SRDconst w)
+  x1:(MOVHBRstore [5] {s} p1 (SRDconst w)
+  x2:(MOVWBRstore [1] {s} p1 (SRDconst w)
+  x3:(MOVBstore [0] {s} p1 w mem))))
   && x1.Uses == 1
   && x2.Uses == 1
   && x3.Uses == 1
   && clobber(x1, x2, x3)
-  => (MOVDBRstore p1 w mem)
+  => (MOVDBRstore {s} p1 w mem)
 
 // Combining byte loads into larger (unaligned) loads.
 
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index 52d0fd095d..8da3b28b5c 100644
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -11415,20 +11415,21 @@ func rewriteValueAMD64_OpAMD64MOVBstore(v *Value) bool {
 		v.AddArg3(p0, w0, mem)
 		return true
 	}
-	// match: (MOVBstore [7] p1 (SHRQconst [56] w) x1:(MOVWstore [5] p1 (SHRQconst [40] w) x2:(MOVLstore [1] p1 (SHRQconst [8] w) x3:(MOVBstore p1 w mem))))
+	// match: (MOVBstore [7] {s} p1 (SHRQconst [56] w) x1:(MOVWstore [5] {s} p1 (SHRQconst [40] w) x2:(MOVLstore [1] {s} p1 (SHRQconst [8] w) x3:(MOVBstore [0] {s} p1 w mem))))
 	// cond: x1.Uses == 1 && x2.Uses == 1 && x3.Uses == 1 && clobber(x1, x2, x3)
-	// result: (MOVQstore p1 w mem)
+	// result: (MOVQstore {s} p1 w mem)
 	for {
 		if auxIntToInt32(v.AuxInt) != 7 {
 			break
 		}
+		s := auxToSym(v.Aux)
 		p1 := v_0
 		if v_1.Op != OpAMD64SHRQconst || auxIntToInt8(v_1.AuxInt) != 56 {
 			break
 		}
 		w := v_1.Args[0]
 		x1 := v_2
-		if x1.Op != OpAMD64MOVWstore || auxIntToInt32(x1.AuxInt) != 5 {
+		if x1.Op != OpAMD64MOVWstore || auxIntToInt32(x1.AuxInt) != 5 || auxToSym(x1.Aux) != s {
 			break
 		}
 		_ = x1.Args[2]
@@ -11440,7 +11441,7 @@ func rewriteValueAMD64_OpAMD64MOVBstore(v *Value) bool {
 			break
 		}
 		x2 := x1.Args[2]
-		if x2.Op != OpAMD64MOVLstore || auxIntToInt32(x2.AuxInt) != 1 {
+		if x2.Op != OpAMD64MOVLstore || auxIntToInt32(x2.AuxInt) != 1 || auxToSym(x2.Aux) != s {
 			break
 		}
 		_ = x2.Args[2]
@@ -11452,7 +11453,7 @@ func rewriteValueAMD64_OpAMD64MOVBstore(v *Value) bool {
 			break
 		}
 		x3 := x2.Args[2]
-		if x3.Op != OpAMD64MOVBstore {
+		if x3.Op != OpAMD64MOVBstore || auxIntToInt32(x3.AuxInt) != 0 || auxToSym(x3.Aux) != s {
 			break
 		}
 		mem := x3.Args[2]
@@ -11460,6 +11461,7 @@ func rewriteValueAMD64_OpAMD64MOVBstore(v *Value) bool {
 			break
 		}
 		v.reset(OpAMD64MOVQstore)
+		v.Aux = symToAux(s)
 		v.AddArg3(p1, w, mem)
 		return true
 	}
diff --git a/src/cmd/compile/internal/ssa/rewriteS390X.go b/src/cmd/compile/internal/ssa/rewriteS390X.go
index e0a5ff4cbb..85260dace8 100644
--- a/src/cmd/compile/internal/ssa/rewriteS390X.go
+++ b/src/cmd/compile/internal/ssa/rewriteS390X.go
@@ -8883,20 +8883,21 @@ func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool {
 		v.AddArg3(p, w0, mem)
 		return true
 	}
-	// match: (MOVBstore [7] p1 (SRDconst w) x1:(MOVHBRstore [5] p1 (SRDconst w) x2:(MOVWBRstore [1] p1 (SRDconst w) x3:(MOVBstore p1 w mem))))
+	// match: (MOVBstore [7] {s} p1 (SRDconst w) x1:(MOVHBRstore [5] {s} p1 (SRDconst w) x2:(MOVWBRstore [1] {s} p1 (SRDconst w) x3:(MOVBstore [0] {s} p1 w mem))))
 	// cond: x1.Uses == 1 && x2.Uses == 1 && x3.Uses == 1 && clobber(x1, x2, x3)
-	// result: (MOVDBRstore p1 w mem)
+	// result: (MOVDBRstore {s} p1 w mem)
 	for {
 		if auxIntToInt32(v.AuxInt) != 7 {
 			break
 		}
+		s := auxToSym(v.Aux)
 		p1 := v_0
 		if v_1.Op != OpS390XSRDconst {
 			break
 		}
 		w := v_1.Args[0]
 		x1 := v_2
-		if x1.Op != OpS390XMOVHBRstore || auxIntToInt32(x1.AuxInt) != 5 {
+		if x1.Op != OpS390XMOVHBRstore || auxIntToInt32(x1.AuxInt) != 5 || auxToSym(x1.Aux) != s {
 			break
 		}
 		_ = x1.Args[2]
@@ -8908,7 +8909,7 @@ func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool {
 			break
 		}
 		x2 := x1.Args[2]
-		if x2.Op != OpS390XMOVWBRstore || auxIntToInt32(x2.AuxInt) != 1 {
+		if x2.Op != OpS390XMOVWBRstore || auxIntToInt32(x2.AuxInt) != 1 || auxToSym(x2.Aux) != s {
 			break
 		}
 		_ = x2.Args[2]
@@ -8920,7 +8921,7 @@ func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool {
 			break
 		}
 		x3 := x2.Args[2]
-		if x3.Op != OpS390XMOVBstore {
+		if x3.Op != OpS390XMOVBstore || auxIntToInt32(x3.AuxInt) != 0 || auxToSym(x3.Aux) != s {
 			break
 		}
 		mem := x3.Args[2]
@@ -8928,6 +8929,7 @@ func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool {
 			break
 		}
 		v.reset(OpS390XMOVDBRstore)
+		v.Aux = symToAux(s)
 		v.AddArg3(p1, w, mem)
 		return true
 	}
diff --git a/test/fixedbugs/issue44823.go b/test/fixedbugs/issue44823.go
new file mode 100644
index 0000000000..85811df67d
--- /dev/null
+++ b/test/fixedbugs/issue44823.go
@@ -0,0 +1,26 @@
+// run
+
+// Copyright 2021 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.
+
+// Issue 44823: miscompilation with store combining.
+
+package main
+
+import "encoding/binary"
+
+//go:noinline
+func Id(a [8]byte) (x [8]byte) {
+	binary.LittleEndian.PutUint64(x[:], binary.LittleEndian.Uint64(a[:]))
+	return
+}
+
+var a = [8]byte{1, 2, 3, 4, 5, 6, 7, 8}
+
+func main() {
+	x := Id(a)
+	if x != a {
+		panic("FAIL")
+	}
+}
-- 
GitLab


From a22bd3dc73bfcc9bf37cbd651933c54c82799c2a Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Mon, 1 Mar 2021 19:23:42 -0500
Subject: [PATCH 0965/2400] cmd/compile: use getcallerpc for racefuncentry

Currently, when instrumenting for the race detector, the compiler
inserts racefuncentry/racefuncentryfp at the entry of instrumented
functions. racefuncentry takes the caller's PC. On AMD64, we synthesize
a node which points to -8(FP) which is where the return address is
stored. Later this node turns to a special Arg in SSA that is not
really an argument. This causes problems in the new ABI work so that
special node has to be special-cased.

This CL changes the special node to a call to getcallerpc, which lowers
to an intrinsic in SSA. This also unifies AMD64 code path and LR machine
code path, as getcallerpc works on all platforms.

Change-Id: I1377e140b91e0473cfcadfda221f26870c1b124d
Reviewed-on: https://go-review.googlesource.com/c/go/+/297929
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/base/base.go         |  2 +-
 src/cmd/compile/internal/ssa/rewrite.go       |  6 +-
 src/cmd/compile/internal/ssagen/ssa.go        |  3 +
 src/cmd/compile/internal/typecheck/builtin.go | 57 ++++++++++---------
 .../internal/typecheck/builtin/runtime.go     |  4 +-
 src/cmd/compile/internal/walk/race.go         | 27 ++-------
 6 files changed, 44 insertions(+), 55 deletions(-)

diff --git a/src/cmd/compile/internal/base/base.go b/src/cmd/compile/internal/base/base.go
index 3b9bc3a8af..4c2516f60e 100644
--- a/src/cmd/compile/internal/base/base.go
+++ b/src/cmd/compile/internal/base/base.go
@@ -70,6 +70,6 @@ var NoInstrumentPkgs = []string{
 	"internal/cpu",
 }
 
-// Don't insert racefuncenterfp/racefuncexit into the following packages.
+// Don't insert racefuncenter/racefuncexit into the following packages.
 // Memory accesses in the packages are either uninteresting or will cause false positives.
 var NoRacePkgs = []string{"sync", "sync/atomic"}
diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go
index 9243000cef..07bbdb8813 100644
--- a/src/cmd/compile/internal/ssa/rewrite.go
+++ b/src/cmd/compile/internal/ssa/rewrite.go
@@ -1612,18 +1612,18 @@ func needRaceCleanup(sym *AuxCall, v *Value) bool {
 	if !f.Config.Race {
 		return false
 	}
-	if !isSameCall(sym, "runtime.racefuncenter") && !isSameCall(sym, "runtime.racefuncenterfp") && !isSameCall(sym, "runtime.racefuncexit") {
+	if !isSameCall(sym, "runtime.racefuncenter") && !isSameCall(sym, "runtime.racefuncexit") {
 		return false
 	}
 	for _, b := range f.Blocks {
 		for _, v := range b.Values {
 			switch v.Op {
 			case OpStaticCall, OpStaticLECall:
-				// Check for racefuncenter/racefuncenterfp will encounter racefuncexit and vice versa.
+				// Check for racefuncenter will encounter racefuncexit and vice versa.
 				// Allow calls to panic*
 				s := v.Aux.(*AuxCall).Fn.String()
 				switch s {
-				case "runtime.racefuncenter", "runtime.racefuncenterfp", "runtime.racefuncexit",
+				case "runtime.racefuncenter", "runtime.racefuncexit",
 					"runtime.panicdivide", "runtime.panicwrap",
 					"runtime.panicshift":
 					continue
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index b590bd4f2f..961cae419a 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -4564,6 +4564,9 @@ func findIntrinsic(sym *types.Sym) intrinsicBuilder {
 	if sym.Pkg == types.LocalPkg {
 		pkg = base.Ctxt.Pkgpath
 	}
+	if sym.Pkg == ir.Pkgs.Runtime {
+		pkg = "runtime"
+	}
 	if base.Flag.Race && pkg == "sync/atomic" {
 		// The race detector needs to be able to intercept these calls.
 		// We can't intrinsify them.
diff --git a/src/cmd/compile/internal/typecheck/builtin.go b/src/cmd/compile/internal/typecheck/builtin.go
index 3c7776d9ae..ddec26df59 100644
--- a/src/cmd/compile/internal/typecheck/builtin.go
+++ b/src/cmd/compile/internal/typecheck/builtin.go
@@ -177,26 +177,26 @@ var runtimeDecls = [...]struct {
 	{"uint64tofloat64", funcTag, 116},
 	{"uint32tofloat64", funcTag, 117},
 	{"complex128div", funcTag, 118},
+	{"getcallerpc", funcTag, 119},
 	{"racefuncenter", funcTag, 31},
-	{"racefuncenterfp", funcTag, 9},
 	{"racefuncexit", funcTag, 9},
 	{"raceread", funcTag, 31},
 	{"racewrite", funcTag, 31},
-	{"racereadrange", funcTag, 119},
-	{"racewriterange", funcTag, 119},
-	{"msanread", funcTag, 119},
-	{"msanwrite", funcTag, 119},
-	{"msanmove", funcTag, 120},
-	{"checkptrAlignment", funcTag, 121},
-	{"checkptrArithmetic", funcTag, 123},
-	{"libfuzzerTraceCmp1", funcTag, 125},
-	{"libfuzzerTraceCmp2", funcTag, 127},
-	{"libfuzzerTraceCmp4", funcTag, 128},
-	{"libfuzzerTraceCmp8", funcTag, 129},
-	{"libfuzzerTraceConstCmp1", funcTag, 125},
-	{"libfuzzerTraceConstCmp2", funcTag, 127},
-	{"libfuzzerTraceConstCmp4", funcTag, 128},
-	{"libfuzzerTraceConstCmp8", funcTag, 129},
+	{"racereadrange", funcTag, 120},
+	{"racewriterange", funcTag, 120},
+	{"msanread", funcTag, 120},
+	{"msanwrite", funcTag, 120},
+	{"msanmove", funcTag, 121},
+	{"checkptrAlignment", funcTag, 122},
+	{"checkptrArithmetic", funcTag, 124},
+	{"libfuzzerTraceCmp1", funcTag, 126},
+	{"libfuzzerTraceCmp2", funcTag, 128},
+	{"libfuzzerTraceCmp4", funcTag, 129},
+	{"libfuzzerTraceCmp8", funcTag, 130},
+	{"libfuzzerTraceConstCmp1", funcTag, 126},
+	{"libfuzzerTraceConstCmp2", funcTag, 128},
+	{"libfuzzerTraceConstCmp4", funcTag, 129},
+	{"libfuzzerTraceConstCmp8", funcTag, 130},
 	{"x86HasPOPCNT", varTag, 6},
 	{"x86HasSSE41", varTag, 6},
 	{"x86HasFMA", varTag, 6},
@@ -219,7 +219,7 @@ func params(tlist ...*types.Type) []*types.Field {
 }
 
 func runtimeTypes() []*types.Type {
-	var typs [130]*types.Type
+	var typs [131]*types.Type
 	typs[0] = types.ByteType
 	typs[1] = types.NewPtr(typs[0])
 	typs[2] = types.Types[types.TANY]
@@ -339,16 +339,17 @@ func runtimeTypes() []*types.Type {
 	typs[116] = newSig(params(typs[24]), params(typs[20]))
 	typs[117] = newSig(params(typs[65]), params(typs[20]))
 	typs[118] = newSig(params(typs[26], typs[26]), params(typs[26]))
-	typs[119] = newSig(params(typs[5], typs[5]), nil)
-	typs[120] = newSig(params(typs[5], typs[5], typs[5]), nil)
-	typs[121] = newSig(params(typs[7], typs[1], typs[5]), nil)
-	typs[122] = types.NewSlice(typs[7])
-	typs[123] = newSig(params(typs[7], typs[122]), nil)
-	typs[124] = types.Types[types.TUINT8]
-	typs[125] = newSig(params(typs[124], typs[124]), nil)
-	typs[126] = types.Types[types.TUINT16]
-	typs[127] = newSig(params(typs[126], typs[126]), nil)
-	typs[128] = newSig(params(typs[65], typs[65]), nil)
-	typs[129] = newSig(params(typs[24], typs[24]), nil)
+	typs[119] = newSig(nil, params(typs[5]))
+	typs[120] = newSig(params(typs[5], typs[5]), nil)
+	typs[121] = newSig(params(typs[5], typs[5], typs[5]), nil)
+	typs[122] = newSig(params(typs[7], typs[1], typs[5]), nil)
+	typs[123] = types.NewSlice(typs[7])
+	typs[124] = newSig(params(typs[7], typs[123]), nil)
+	typs[125] = types.Types[types.TUINT8]
+	typs[126] = newSig(params(typs[125], typs[125]), nil)
+	typs[127] = types.Types[types.TUINT16]
+	typs[128] = newSig(params(typs[127], typs[127]), nil)
+	typs[129] = newSig(params(typs[65], typs[65]), nil)
+	typs[130] = newSig(params(typs[24], typs[24]), nil)
 	return typs[:]
 }
diff --git a/src/cmd/compile/internal/typecheck/builtin/runtime.go b/src/cmd/compile/internal/typecheck/builtin/runtime.go
index d5e00afcf8..8575148b5b 100644
--- a/src/cmd/compile/internal/typecheck/builtin/runtime.go
+++ b/src/cmd/compile/internal/typecheck/builtin/runtime.go
@@ -6,6 +6,7 @@
 // to update builtin.go. This is not done automatically
 // to avoid depending on having a working compiler binary.
 
+//go:build ignore
 // +build ignore
 
 package runtime
@@ -224,9 +225,10 @@ func uint32tofloat64(uint32) float64
 
 func complex128div(num complex128, den complex128) (quo complex128)
 
+func getcallerpc() uintptr
+
 // race detection
 func racefuncenter(uintptr)
-func racefuncenterfp()
 func racefuncexit()
 func raceread(uintptr)
 func racewrite(uintptr)
diff --git a/src/cmd/compile/internal/walk/race.go b/src/cmd/compile/internal/walk/race.go
index 47cd2fdc22..859e5c57f0 100644
--- a/src/cmd/compile/internal/walk/race.go
+++ b/src/cmd/compile/internal/walk/race.go
@@ -7,11 +7,8 @@ package walk
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
-	"cmd/compile/internal/ssagen"
-	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
-	"cmd/internal/sys"
 )
 
 func instrument(fn *ir.Func) {
@@ -26,26 +23,12 @@ func instrument(fn *ir.Func) {
 	if base.Flag.Race {
 		lno := base.Pos
 		base.Pos = src.NoXPos
-		if ssagen.Arch.LinkArch.Arch.Family != sys.AMD64 {
-			fn.Enter.Prepend(mkcallstmt("racefuncenterfp"))
-			fn.Exit.Append(mkcallstmt("racefuncexit"))
-		} else {
-
-			// nodpc is the PC of the caller as extracted by
-			// getcallerpc. We use -widthptr(FP) for x86.
-			// This only works for amd64. This will not
-			// work on arm or others that might support
-			// race in the future.
-
-			nodpc := ir.NewNameAt(src.NoXPos, typecheck.Lookup(".fp"))
-			nodpc.Class = ir.PPARAM
-			nodpc.SetUsed(true)
-			nodpc.SetType(types.Types[types.TUINTPTR])
-			nodpc.SetFrameOffset(int64(-types.PtrSize))
-			fn.Dcl = append(fn.Dcl, nodpc)
-			fn.Enter.Prepend(mkcallstmt("racefuncenter", nodpc))
-			fn.Exit.Append(mkcallstmt("racefuncexit"))
+		var init ir.Nodes
+		fn.Enter.Prepend(mkcallstmt("racefuncenter", mkcall("getcallerpc", types.Types[types.TUINTPTR], &init)))
+		if len(init) != 0 {
+			base.Fatalf("race walk: unexpected init for getcallerpc")
 		}
+		fn.Exit.Append(mkcallstmt("racefuncexit"))
 		base.Pos = lno
 	}
 }
-- 
GitLab


From fb03be9d5577a3d22834a25b3b62916aee30db2a Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 2 Mar 2021 10:27:18 -0500
Subject: [PATCH 0966/2400] cmd/compile: use getcallersp for gorecover "fp" arg

Currently, the compiler synthesize a special ".fp" node, which
points to the FP of the current frame, be to used to call
gorecover. Later that node turns to an Arg in SSA that is not
really an arg, causing problems for the new ABI work which changes
the handling of Args, so we have to special-case that node.

This CL changes the compiler to get the FP by using getcallersp,
which is an intrinsic in SSA and works on all platforms. As we
need the FP, not the caller SP, one drawback is that we have to
add FixedFrameSize for LR machines. But it does allow us to remove
that special node.

Change-Id: Ie721d51efca8116c9d23cc4f79738fffcf847df8
Reviewed-on: https://go-review.googlesource.com/c/go/+/297930
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/ir/name.go                   | 2 --
 src/cmd/compile/internal/ssagen/pgen.go               | 7 +------
 src/cmd/compile/internal/ssagen/ssa.go                | 4 ----
 src/cmd/compile/internal/typecheck/builtin.go         | 1 +
 src/cmd/compile/internal/typecheck/builtin/runtime.go | 1 +
 src/cmd/compile/internal/typecheck/universe.go        | 5 -----
 src/cmd/compile/internal/walk/expr.go                 | 9 ++++++++-
 7 files changed, 11 insertions(+), 18 deletions(-)

diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 035c9cd3d0..16c30324e5 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -509,5 +509,3 @@ func NewPkgName(pos src.XPos, sym *types.Sym, pkg *types.Pkg) *PkgName {
 	p.pos = pos
 	return p
 }
-
-var RegFP *Name
diff --git a/src/cmd/compile/internal/ssagen/pgen.go b/src/cmd/compile/internal/ssagen/pgen.go
index 7e15f54299..d12e12947e 100644
--- a/src/cmd/compile/internal/ssagen/pgen.go
+++ b/src/cmd/compile/internal/ssagen/pgen.go
@@ -93,12 +93,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 		for _, v := range b.Values {
 			if n, ok := v.Aux.(*ir.Name); ok {
 				switch n.Class {
-				case ir.PPARAM, ir.PPARAMOUT:
-					// Don't modify RegFP; it is a global.
-					if n != ir.RegFP {
-						n.SetUsed(true)
-					}
-				case ir.PAUTO:
+				case ir.PPARAM, ir.PPARAMOUT, ir.PAUTO:
 					n.SetUsed(true)
 				}
 			}
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 961cae419a..cc79c07af7 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -5176,10 +5176,6 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 			if v != nil {
 				return v
 			}
-			if n == ir.RegFP {
-				// Special arg that points to the frame pointer (Used by ORECOVER).
-				return s.entryNewValue2A(ssa.OpLocalAddr, t, n, s.sp, s.startmem)
-			}
 			s.Fatalf("addr of undeclared ONAME %v. declared: %v", n, s.decladdrs)
 			return nil
 		case ir.PAUTO:
diff --git a/src/cmd/compile/internal/typecheck/builtin.go b/src/cmd/compile/internal/typecheck/builtin.go
index ddec26df59..3421c44588 100644
--- a/src/cmd/compile/internal/typecheck/builtin.go
+++ b/src/cmd/compile/internal/typecheck/builtin.go
@@ -178,6 +178,7 @@ var runtimeDecls = [...]struct {
 	{"uint32tofloat64", funcTag, 117},
 	{"complex128div", funcTag, 118},
 	{"getcallerpc", funcTag, 119},
+	{"getcallersp", funcTag, 119},
 	{"racefuncenter", funcTag, 31},
 	{"racefuncexit", funcTag, 9},
 	{"raceread", funcTag, 31},
diff --git a/src/cmd/compile/internal/typecheck/builtin/runtime.go b/src/cmd/compile/internal/typecheck/builtin/runtime.go
index 8575148b5b..614bd46177 100644
--- a/src/cmd/compile/internal/typecheck/builtin/runtime.go
+++ b/src/cmd/compile/internal/typecheck/builtin/runtime.go
@@ -226,6 +226,7 @@ func uint32tofloat64(uint32) float64
 func complex128div(num complex128, den complex128) (quo complex128)
 
 func getcallerpc() uintptr
+func getcallersp() uintptr
 
 // race detection
 func racefuncenter(uintptr)
diff --git a/src/cmd/compile/internal/typecheck/universe.go b/src/cmd/compile/internal/typecheck/universe.go
index c4c034184b..f04dcb671c 100644
--- a/src/cmd/compile/internal/typecheck/universe.go
+++ b/src/cmd/compile/internal/typecheck/universe.go
@@ -354,9 +354,4 @@ func DeclareUniverse() {
 		s1.Def = s.Def
 		s1.Block = s.Block
 	}
-
-	ir.RegFP = NewName(Lookup(".fp"))
-	ir.RegFP.SetType(types.Types[types.TINT32])
-	ir.RegFP.Class = ir.PPARAM
-	ir.RegFP.SetUsed(true)
 }
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 7b65db5100..1d90029298 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -158,7 +158,14 @@ func walkExpr1(n ir.Node, init *ir.Nodes) ir.Node {
 
 	case ir.ORECOVER:
 		n := n.(*ir.CallExpr)
-		return mkcall("gorecover", n.Type(), init, typecheck.NodAddr(ir.RegFP))
+		// Call gorecover with the FP of this frame.
+		// FP is equal to caller's SP plus FixedFrameSize().
+		var fp ir.Node = mkcall("getcallersp", types.Types[types.TUINTPTR], init)
+		if off := base.Ctxt.FixedFrameSize(); off != 0 {
+			fp = ir.NewBinaryExpr(fp.Pos(), ir.OADD, fp, ir.NewInt(off))
+		}
+		fp = ir.NewConvExpr(fp.Pos(), ir.OCONVNOP, types.NewPtr(types.Types[types.TINT32]), fp)
+		return mkcall("gorecover", n.Type(), init, fp)
 
 	case ir.OCFUNC:
 		return n
-- 
GitLab


From 7205a4fbdc98f22fc2f0df7d12a242f9096bebbf Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 2 Mar 2021 13:21:53 -0500
Subject: [PATCH 0967/2400] cmd/internal/goobj: regenerate builtin list

Change-Id: Ib8cb5f90e084838f00ecba78641bbb5d48ecac32
Reviewed-on: https://go-review.googlesource.com/c/go/+/297931
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/internal/goobj/builtinlist.go | 7 ++++---
 src/cmd/internal/goobj/mkbuiltin.go   | 4 ++--
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/cmd/internal/goobj/builtinlist.go b/src/cmd/internal/goobj/builtinlist.go
index 0cca752332..9f248137da 100644
--- a/src/cmd/internal/goobj/builtinlist.go
+++ b/src/cmd/internal/goobj/builtinlist.go
@@ -41,6 +41,7 @@ var builtins = [...]struct {
 	{"runtime.printcomplex", 1},
 	{"runtime.printstring", 1},
 	{"runtime.printpointer", 1},
+	{"runtime.printuintptr", 1},
 	{"runtime.printiface", 1},
 	{"runtime.printeface", 1},
 	{"runtime.printslice", 1},
@@ -61,7 +62,6 @@ var builtins = [...]struct {
 	{"runtime.stringtoslicebyte", 1},
 	{"runtime.stringtoslicerune", 1},
 	{"runtime.slicecopy", 1},
-	{"runtime.slicestringcopy", 1},
 	{"runtime.decoderune", 1},
 	{"runtime.countrunes", 1},
 	{"runtime.convI2I", 1},
@@ -122,7 +122,6 @@ var builtins = [...]struct {
 	{"runtime.typedslicecopy", 1},
 	{"runtime.selectnbsend", 1},
 	{"runtime.selectnbrecv", 1},
-	{"runtime.selectnbrecv2", 1},
 	{"runtime.selectsetpc", 1},
 	{"runtime.selectgo", 1},
 	{"runtime.block", 1},
@@ -172,8 +171,9 @@ var builtins = [...]struct {
 	{"runtime.uint64tofloat64", 1},
 	{"runtime.uint32tofloat64", 1},
 	{"runtime.complex128div", 1},
+	{"runtime.getcallerpc", 1},
+	{"runtime.getcallersp", 1},
 	{"runtime.racefuncenter", 1},
-	{"runtime.racefuncenterfp", 1},
 	{"runtime.racefuncexit", 1},
 	{"runtime.raceread", 1},
 	{"runtime.racewrite", 1},
@@ -181,6 +181,7 @@ var builtins = [...]struct {
 	{"runtime.racewriterange", 1},
 	{"runtime.msanread", 1},
 	{"runtime.msanwrite", 1},
+	{"runtime.msanmove", 1},
 	{"runtime.checkptrAlignment", 1},
 	{"runtime.checkptrArithmetic", 1},
 	{"runtime.libfuzzerTraceCmp1", 1},
diff --git a/src/cmd/internal/goobj/mkbuiltin.go b/src/cmd/internal/goobj/mkbuiltin.go
index 4e46970648..18b969586c 100644
--- a/src/cmd/internal/goobj/mkbuiltin.go
+++ b/src/cmd/internal/goobj/mkbuiltin.go
@@ -5,7 +5,7 @@
 //go:build ignore
 // +build ignore
 
-// Generate builtinlist.go from cmd/compile/internal/gc/builtin/runtime.go.
+// Generate builtinlist.go from cmd/compile/internal/typecheck/builtin/runtime.go.
 
 package main
 
@@ -54,7 +54,7 @@ func main() {
 func mkbuiltin(w io.Writer) {
 	pkg := "runtime"
 	fset := token.NewFileSet()
-	path := filepath.Join("..", "..", "compile", "internal", "gc", "builtin", "runtime.go")
+	path := filepath.Join("..", "..", "compile", "internal", "typecheck", "builtin", "runtime.go")
 	f, err := parser.ParseFile(fset, path, nil, 0)
 	if err != nil {
 		log.Fatal(err)
-- 
GitLab


From 87d29939c8f93799ce889d98e0e5579d1eb2ffe5 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 2 Mar 2021 13:22:21 -0500
Subject: [PATCH 0968/2400] runtime: remove racefuncenterfp

No longer needed with previous CL.

Change-Id: I7c01f9e0e34ecb9553ef1b3d662f33419fd3a244
Reviewed-on: https://go-review.googlesource.com/c/go/+/297932
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: David Chase <drchase@google.com>
---
 src/runtime/race_amd64.s   | 10 +---------
 src/runtime/race_arm64.s   | 10 +---------
 src/runtime/race_ppc64le.s | 12 +-----------
 3 files changed, 3 insertions(+), 29 deletions(-)

diff --git a/src/runtime/race_amd64.s b/src/runtime/race_amd64.s
index e10c21c7f3..287bb9fc0a 100644
--- a/src/runtime/race_amd64.s
+++ b/src/runtime/race_amd64.s
@@ -167,21 +167,13 @@ call:
 ret:
 	RET
 
-// func runtime·racefuncenterfp(fp uintptr)
-// Called from instrumented code.
-// Like racefuncenter but passes FP, not PC
-TEXT	runtime·racefuncenterfp(SB), NOSPLIT, $0-8
-	MOVQ	fp+0(FP), R11
-	MOVQ	-8(R11), R11
-	JMP	racefuncenter<>(SB)
-
 // func runtime·racefuncenter(pc uintptr)
 // Called from instrumented code.
 TEXT	runtime·racefuncenter(SB), NOSPLIT, $0-8
 	MOVQ	callpc+0(FP), R11
 	JMP	racefuncenter<>(SB)
 
-// Common code for racefuncenter/racefuncenterfp
+// Common code for racefuncenter
 // R11 = caller's return address
 TEXT	racefuncenter<>(SB), NOSPLIT, $0-0
 	MOVQ	DX, BX		// save function entry context (for closures)
diff --git a/src/runtime/race_arm64.s b/src/runtime/race_arm64.s
index 8aa17742b8..82e3caadc8 100644
--- a/src/runtime/race_arm64.s
+++ b/src/runtime/race_arm64.s
@@ -160,21 +160,13 @@ call:
 ret:
 	RET
 
-// func runtime·racefuncenterfp(fp uintptr)
-// Called from instrumented code.
-// Like racefuncenter but doesn't passes an arg, uses the caller pc
-// from the first slot on the stack
-TEXT	runtime·racefuncenterfp(SB), NOSPLIT, $0-0
-	MOVD	0(RSP), R9
-	JMP	racefuncenter<>(SB)
-
 // func runtime·racefuncenter(pc uintptr)
 // Called from instrumented code.
 TEXT	runtime·racefuncenter(SB), NOSPLIT, $0-8
 	MOVD	callpc+0(FP), R9
 	JMP	racefuncenter<>(SB)
 
-// Common code for racefuncenter/racefuncenterfp
+// Common code for racefuncenter
 // R9 = caller's return address
 TEXT	racefuncenter<>(SB), NOSPLIT, $0-0
 	load_g
diff --git a/src/runtime/race_ppc64le.s b/src/runtime/race_ppc64le.s
index 8961254ea6..b09f37031c 100644
--- a/src/runtime/race_ppc64le.s
+++ b/src/runtime/race_ppc64le.s
@@ -163,23 +163,13 @@ call:
 ret:
 	RET
 
-// func runtime·racefuncenterfp()
-// Called from instrumented Go code.
-// Like racefuncenter but doesn't pass an arg, uses the caller pc
-// from the first slot on the stack.
-TEXT	runtime·racefuncenterfp(SB), NOSPLIT, $0-0
-	MOVD	0(R1), R8
-	BR	racefuncenter<>(SB)
-
 // func runtime·racefuncenter(pc uintptr)
 // Called from instrumented Go code.
-// Not used now since gc/racewalk.go doesn't pass the
-// correct caller pc and racefuncenterfp can do it.
 TEXT	runtime·racefuncenter(SB), NOSPLIT, $0-8
 	MOVD	callpc+0(FP), R8
 	BR	racefuncenter<>(SB)
 
-// Common code for racefuncenter/racefuncenterfp
+// Common code for racefuncenter
 // R11 = caller's return address
 TEXT	racefuncenter<>(SB), NOSPLIT, $0-0
 	MOVD    runtime·tls_g(SB), R10
-- 
GitLab


From f901ea701ddac5a4d600d49007e54caa32b4c9b5 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Sun, 8 Nov 2020 11:27:53 -0500
Subject: [PATCH 0969/2400] cmd/internal/goobj: store relocation type as uint16

Currently, relocation type is stored as uint8 in object files, as
Go relocations do not exceed 255. In the linker, however, it is
used as a 16-bit type, because external relocations can exceed
255. The linker has to store the extra byte in a side table. This
complicates many things.

Just store it as uint16 in object files. This simplifies things,
with a small cost of increasing the object file sizes.

               before      after
hello.o         1672        1678
runtime.a    7927784     8056194

Change-Id: I313cf44ad0b8b3b76e35055ae55d911ff35e3158
Reviewed-on: https://go-review.googlesource.com/c/go/+/268477
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/internal/goobj/objfile.go             | 34 ++++++------
 src/cmd/internal/goobj/objfile_test.go        |  4 +-
 src/cmd/internal/obj/objfile.go               |  2 +-
 src/cmd/link/internal/loader/loader.go        | 53 ++++++-------------
 src/cmd/link/internal/loader/loader_test.go   |  3 +-
 src/cmd/link/internal/loader/symbolbuilder.go |  8 +--
 6 files changed, 40 insertions(+), 64 deletions(-)

diff --git a/src/cmd/internal/goobj/objfile.go b/src/cmd/internal/goobj/objfile.go
index 247cc695f0..e2858bd57d 100644
--- a/src/cmd/internal/goobj/objfile.go
+++ b/src/cmd/internal/goobj/objfile.go
@@ -33,7 +33,7 @@ import (
 // New object file format.
 //
 //    Header struct {
-//       Magic       [...]byte   // "\x00go116ld"
+//       Magic       [...]byte   // "\x00go117ld"
 //       Fingerprint [8]byte
 //       Flags       uint32
 //       Offsets     [...]uint32 // byte offset of each block below
@@ -89,7 +89,7 @@ import (
 //    Relocs [...]struct {
 //       Off  int32
 //       Size uint8
-//       Type uint8
+//       Type uint16
 //       Add  int64
 //       Sym  symRef
 //    }
@@ -219,7 +219,7 @@ type Header struct {
 	Offsets     [NBlk]uint32
 }
 
-const Magic = "\x00go116ld"
+const Magic = "\x00go117ld"
 
 func (h *Header) Write(w *Writer) {
 	w.RawString(h.Magic)
@@ -373,32 +373,32 @@ const HashSize = sha1.Size
 // Reloc struct {
 //    Off  int32
 //    Siz  uint8
-//    Type uint8
+//    Type uint16
 //    Add  int64
 //    Sym  SymRef
 // }
 type Reloc [RelocSize]byte
 
-const RelocSize = 4 + 1 + 1 + 8 + 8
+const RelocSize = 4 + 1 + 2 + 8 + 8
 
-func (r *Reloc) Off() int32  { return int32(binary.LittleEndian.Uint32(r[:])) }
-func (r *Reloc) Siz() uint8  { return r[4] }
-func (r *Reloc) Type() uint8 { return r[5] }
-func (r *Reloc) Add() int64  { return int64(binary.LittleEndian.Uint64(r[6:])) }
+func (r *Reloc) Off() int32   { return int32(binary.LittleEndian.Uint32(r[:])) }
+func (r *Reloc) Siz() uint8   { return r[4] }
+func (r *Reloc) Type() uint16 { return binary.LittleEndian.Uint16(r[5:]) }
+func (r *Reloc) Add() int64   { return int64(binary.LittleEndian.Uint64(r[7:])) }
 func (r *Reloc) Sym() SymRef {
-	return SymRef{binary.LittleEndian.Uint32(r[14:]), binary.LittleEndian.Uint32(r[18:])}
+	return SymRef{binary.LittleEndian.Uint32(r[15:]), binary.LittleEndian.Uint32(r[19:])}
 }
 
-func (r *Reloc) SetOff(x int32)  { binary.LittleEndian.PutUint32(r[:], uint32(x)) }
-func (r *Reloc) SetSiz(x uint8)  { r[4] = x }
-func (r *Reloc) SetType(x uint8) { r[5] = x }
-func (r *Reloc) SetAdd(x int64)  { binary.LittleEndian.PutUint64(r[6:], uint64(x)) }
+func (r *Reloc) SetOff(x int32)   { binary.LittleEndian.PutUint32(r[:], uint32(x)) }
+func (r *Reloc) SetSiz(x uint8)   { r[4] = x }
+func (r *Reloc) SetType(x uint16) { binary.LittleEndian.PutUint16(r[5:], x) }
+func (r *Reloc) SetAdd(x int64)   { binary.LittleEndian.PutUint64(r[7:], uint64(x)) }
 func (r *Reloc) SetSym(x SymRef) {
-	binary.LittleEndian.PutUint32(r[14:], x.PkgIdx)
-	binary.LittleEndian.PutUint32(r[18:], x.SymIdx)
+	binary.LittleEndian.PutUint32(r[15:], x.PkgIdx)
+	binary.LittleEndian.PutUint32(r[19:], x.SymIdx)
 }
 
-func (r *Reloc) Set(off int32, size uint8, typ uint8, add int64, sym SymRef) {
+func (r *Reloc) Set(off int32, size uint8, typ uint16, add int64, sym SymRef) {
 	r.SetOff(off)
 	r.SetSiz(size)
 	r.SetType(typ)
diff --git a/src/cmd/internal/goobj/objfile_test.go b/src/cmd/internal/goobj/objfile_test.go
index 99d02a1bf1..ad80ede0f3 100644
--- a/src/cmd/internal/goobj/objfile_test.go
+++ b/src/cmd/internal/goobj/objfile_test.go
@@ -40,7 +40,7 @@ func TestReadWrite(t *testing.T) {
 	var r Reloc
 	r.SetOff(12)
 	r.SetSiz(4)
-	r.SetType(uint8(objabi.R_ADDR))
+	r.SetType(uint16(objabi.R_ADDR))
 	r.SetAdd(54321)
 	r.SetSym(SymRef{11, 22})
 	r.Write(w)
@@ -63,7 +63,7 @@ func TestReadWrite(t *testing.T) {
 	b = b[SymSize:]
 	var r2 Reloc
 	r2.fromBytes(b)
-	if r2.Off() != 12 || r2.Siz() != 4 || r2.Type() != uint8(objabi.R_ADDR) || r2.Add() != 54321 || r2.Sym() != (SymRef{11, 22}) {
+	if r2.Off() != 12 || r2.Siz() != 4 || r2.Type() != uint16(objabi.R_ADDR) || r2.Add() != 54321 || r2.Sym() != (SymRef{11, 22}) {
 		t.Errorf("read Reloc2 mismatch: got %v %v %v %v %v", r2.Off(), r2.Siz(), r2.Type(), r2.Add(), r2.Sym())
 	}
 
diff --git a/src/cmd/internal/obj/objfile.go b/src/cmd/internal/obj/objfile.go
index b031afbc36..24fb5a19de 100644
--- a/src/cmd/internal/obj/objfile.go
+++ b/src/cmd/internal/obj/objfile.go
@@ -498,7 +498,7 @@ func (w *writer) Reloc(r *Reloc) {
 	var o goobj.Reloc
 	o.SetOff(r.Off)
 	o.SetSiz(r.Siz)
-	o.SetType(uint8(r.Type))
+	o.SetType(uint16(r.Type))
 	o.SetAdd(r.Add)
 	o.SetSym(makeSymRef(r.Sym))
 	o.Write(w.Writer)
diff --git a/src/cmd/link/internal/loader/loader.go b/src/cmd/link/internal/loader/loader.go
index c05309a141..6d2e7dcabc 100644
--- a/src/cmd/link/internal/loader/loader.go
+++ b/src/cmd/link/internal/loader/loader.go
@@ -51,30 +51,13 @@ type Reloc struct {
 	*goobj.Reloc
 	r *oReader
 	l *Loader
-
-	// External reloc types may not fit into a uint8 which the Go object file uses.
-	// Store it here, instead of in the byte of goobj.Reloc.
-	// For Go symbols this will always be zero.
-	// goobj.Reloc.Type() + typ is always the right type, for both Go and external
-	// symbols.
-	typ objabi.RelocType
 }
 
-func (rel Reloc) Type() objabi.RelocType { return objabi.RelocType(rel.Reloc.Type()) + rel.typ }
-func (rel Reloc) Sym() Sym               { return rel.l.resolve(rel.r, rel.Reloc.Sym()) }
-func (rel Reloc) SetSym(s Sym)           { rel.Reloc.SetSym(goobj.SymRef{PkgIdx: 0, SymIdx: uint32(s)}) }
-func (rel Reloc) IsMarker() bool         { return rel.Siz() == 0 }
-
-func (rel Reloc) SetType(t objabi.RelocType) {
-	if t != objabi.RelocType(uint8(t)) {
-		panic("SetType: type doesn't fit into Reloc")
-	}
-	rel.Reloc.SetType(uint8(t))
-	if rel.typ != 0 {
-		// should use SymbolBuilder.SetRelocType
-		panic("wrong method to set reloc type")
-	}
-}
+func (rel Reloc) Type() objabi.RelocType     { return objabi.RelocType(rel.Reloc.Type()) }
+func (rel Reloc) SetType(t objabi.RelocType) { rel.Reloc.SetType(uint16(t)) }
+func (rel Reloc) Sym() Sym                   { return rel.l.resolve(rel.r, rel.Reloc.Sym()) }
+func (rel Reloc) SetSym(s Sym)               { rel.Reloc.SetSym(goobj.SymRef{PkgIdx: 0, SymIdx: uint32(s)}) }
+func (rel Reloc) IsMarker() bool             { return rel.Siz() == 0 }
 
 // Aux holds a "handle" to access an aux symbol record from an
 // object file.
@@ -307,15 +290,14 @@ type elfsetstringFunc func(str string, off int)
 // extSymPayload holds the payload (data + relocations) for linker-synthesized
 // external symbols (note that symbol value is stored in a separate slice).
 type extSymPayload struct {
-	name     string // TODO: would this be better as offset into str table?
-	size     int64
-	ver      int
-	kind     sym.SymKind
-	objidx   uint32 // index of original object if sym made by cloneToExternal
-	relocs   []goobj.Reloc
-	reltypes []objabi.RelocType // relocation types
-	data     []byte
-	auxs     []goobj.Aux
+	name   string // TODO: would this be better as offset into str table?
+	size   int64
+	ver    int
+	kind   sym.SymKind
+	objidx uint32 // index of original object if sym made by cloneToExternal
+	relocs []goobj.Reloc
+	data   []byte
+	auxs   []goobj.Aux
 }
 
 const (
@@ -1833,10 +1815,9 @@ func (relocs *Relocs) Count() int { return len(relocs.rs) }
 // At returns the j-th reloc for a global symbol.
 func (relocs *Relocs) At(j int) Reloc {
 	if relocs.l.isExtReader(relocs.r) {
-		pp := relocs.l.payloads[relocs.li]
-		return Reloc{&relocs.rs[j], relocs.r, relocs.l, pp.reltypes[j]}
+		return Reloc{&relocs.rs[j], relocs.r, relocs.l}
 	}
-	return Reloc{&relocs.rs[j], relocs.r, relocs.l, 0}
+	return Reloc{&relocs.rs[j], relocs.r, relocs.l}
 }
 
 // Relocs returns a Relocs object for the given global sym.
@@ -2337,13 +2318,11 @@ func (l *Loader) cloneToExternal(symIdx Sym) {
 		// Copy relocations
 		relocs := l.Relocs(symIdx)
 		pp.relocs = make([]goobj.Reloc, relocs.Count())
-		pp.reltypes = make([]objabi.RelocType, relocs.Count())
 		for i := range pp.relocs {
 			// Copy the relocs slice.
 			// Convert local reference to global reference.
 			rel := relocs.At(i)
-			pp.relocs[i].Set(rel.Off(), rel.Siz(), 0, rel.Add(), goobj.SymRef{PkgIdx: 0, SymIdx: uint32(rel.Sym())})
-			pp.reltypes[i] = rel.Type()
+			pp.relocs[i].Set(rel.Off(), rel.Siz(), uint16(rel.Type()), rel.Add(), goobj.SymRef{PkgIdx: 0, SymIdx: uint32(rel.Sym())})
 		}
 
 		// Copy data
diff --git a/src/cmd/link/internal/loader/loader_test.go b/src/cmd/link/internal/loader/loader_test.go
index 1371c2a541..15ae830dc9 100644
--- a/src/cmd/link/internal/loader/loader_test.go
+++ b/src/cmd/link/internal/loader/loader_test.go
@@ -237,7 +237,8 @@ func sameRelocSlice(s1 *Relocs, s2 []Reloc) bool {
 type addFunc func(l *Loader, s Sym, s2 Sym) Sym
 
 func mkReloc(l *Loader, typ objabi.RelocType, off int32, siz uint8, add int64, sym Sym) Reloc {
-	r := Reloc{&goobj.Reloc{}, l.extReader, l, typ}
+	r := Reloc{&goobj.Reloc{}, l.extReader, l}
+	r.SetType(typ)
 	r.SetOff(off)
 	r.SetSiz(siz)
 	r.SetAdd(add)
diff --git a/src/cmd/link/internal/loader/symbolbuilder.go b/src/cmd/link/internal/loader/symbolbuilder.go
index 5d37da8ac6..204d04412d 100644
--- a/src/cmd/link/internal/loader/symbolbuilder.go
+++ b/src/cmd/link/internal/loader/symbolbuilder.go
@@ -121,13 +121,11 @@ func (sb *SymbolBuilder) Relocs() Relocs {
 // ResetRelocs removes all relocations on this symbol.
 func (sb *SymbolBuilder) ResetRelocs() {
 	sb.relocs = sb.relocs[:0]
-	sb.reltypes = sb.reltypes[:0]
 }
 
 // SetRelocType sets the type of the 'i'-th relocation on this sym to 't'
 func (sb *SymbolBuilder) SetRelocType(i int, t objabi.RelocType) {
-	sb.relocs[i].SetType(0)
-	sb.reltypes[i] = t
+	sb.relocs[i].SetType(uint16(t))
 }
 
 // SetRelocSym sets the target sym of the 'i'-th relocation on this sym to 's'
@@ -143,7 +141,6 @@ func (sb *SymbolBuilder) SetRelocAdd(i int, a int64) {
 // Add n relocations, return a handle to the relocations.
 func (sb *SymbolBuilder) AddRelocs(n int) Relocs {
 	sb.relocs = append(sb.relocs, make([]goobj.Reloc, n)...)
-	sb.reltypes = append(sb.reltypes, make([]objabi.RelocType, n)...)
 	return sb.l.Relocs(sb.symIdx)
 }
 
@@ -152,7 +149,7 @@ func (sb *SymbolBuilder) AddRelocs(n int) Relocs {
 func (sb *SymbolBuilder) AddRel(typ objabi.RelocType) (Reloc, int) {
 	j := len(sb.relocs)
 	sb.relocs = append(sb.relocs, goobj.Reloc{})
-	sb.reltypes = append(sb.reltypes, typ)
+	sb.relocs[j].SetType(uint16(typ))
 	relocs := sb.Relocs()
 	return relocs.At(j), j
 }
@@ -169,7 +166,6 @@ func (p *relocsByOff) Len() int           { return len(p.relocs) }
 func (p *relocsByOff) Less(i, j int) bool { return p.relocs[i].Off() < p.relocs[j].Off() }
 func (p *relocsByOff) Swap(i, j int) {
 	p.relocs[i], p.relocs[j] = p.relocs[j], p.relocs[i]
-	p.reltypes[i], p.reltypes[j] = p.reltypes[j], p.reltypes[i]
 }
 
 func (sb *SymbolBuilder) Reachable() bool {
-- 
GitLab


From 009bfeae866f45549865e554420a05c10e9578ca Mon Sep 17 00:00:00 2001
From: Roger Peppe <rogpeppe@gmail.com>
Date: Fri, 1 Jan 2021 12:14:34 +0000
Subject: [PATCH 0970/2400] reflect: add VisibleFields function
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When writing code that reflects over a struct type, it's a common requirement to know the full set of struct fields, including fields available due to embedding of anonymous members while excluding fields that are erased because they're at the same level as another field with the same name.

The logic to do this is not that complex, but it's a little subtle and easy to get wrong.

This CL adds a new `VisibleFields` function to the reflect package that returns the full set of effective fields that apply in a given struct type.

Performance isn't a prime consideration, as it's common to cache results by type.

Fixes #42782

Change-Id: I7f1af76cecff9b8a2490f17eec058826e396f660
Reviewed-on: https://go-review.googlesource.com/c/go/+/281233
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Daniel Martí <mvdan@mvdan.cc>
---
 src/reflect/visiblefields.go      | 101 +++++++++
 src/reflect/visiblefields_test.go | 326 ++++++++++++++++++++++++++++++
 2 files changed, 427 insertions(+)
 create mode 100644 src/reflect/visiblefields.go
 create mode 100644 src/reflect/visiblefields_test.go

diff --git a/src/reflect/visiblefields.go b/src/reflect/visiblefields.go
new file mode 100644
index 0000000000..c068979dcc
--- /dev/null
+++ b/src/reflect/visiblefields.go
@@ -0,0 +1,101 @@
+package reflect
+
+// VisibleFields returns all the visible fields in t, which must be a
+// struct type. A field is defined as visible if it's accessible
+// directly with a FieldByName call. The returned fields include fields
+// inside anonymous struct members and unexported fields. They follow
+// the same order found in the struct, with anonymous fields followed
+// immediately by their promoted fields.
+//
+// For each element e of the returned slice, the corresponding field
+// can be retrieved from a value v of type t by calling v.FieldByIndex(e.Index).
+func VisibleFields(t Type) []StructField {
+	if t == nil {
+		panic("reflect: VisibleFields(nil)")
+	}
+	if t.Kind() != Struct {
+		panic("reflect.VisibleFields of non-struct type")
+	}
+	w := &visibleFieldsWalker{
+		byName:   make(map[string]int),
+		visiting: make(map[Type]bool),
+		fields:   make([]StructField, 0, t.NumField()),
+		index:    make([]int, 0, 2),
+	}
+	w.walk(t)
+	// Remove all the fields that have been hidden.
+	// Use an in-place removal that avoids copying in
+	// the common case that there are no hidden fields.
+	j := 0
+	for i := range w.fields {
+		f := &w.fields[i]
+		if f.Name == "" {
+			continue
+		}
+		if i != j {
+			// A field has been removed. We need to shuffle
+			// all the subsequent elements up.
+			w.fields[j] = *f
+		}
+		j++
+	}
+	return w.fields[:j]
+}
+
+type visibleFieldsWalker struct {
+	byName   map[string]int
+	visiting map[Type]bool
+	fields   []StructField
+	index    []int
+}
+
+// walk walks all the fields in the struct type t, visiting
+// fields in index preorder and appending them to w.fields
+// (this maintains the required ordering).
+// Fields that have been overridden have their
+// Name field cleared.
+func (w *visibleFieldsWalker) walk(t Type) {
+	if w.visiting[t] {
+		return
+	}
+	w.visiting[t] = true
+	for i := 0; i < t.NumField(); i++ {
+		f := t.Field(i)
+		w.index = append(w.index, i)
+		add := true
+		if oldIndex, ok := w.byName[f.Name]; ok {
+			old := &w.fields[oldIndex]
+			if len(w.index) == len(old.Index) {
+				// Fields with the same name at the same depth
+				// cancel one another out. Set the field name
+				// to empty to signify that has happened, and
+				// there's no need to add this field.
+				old.Name = ""
+				add = false
+			} else if len(w.index) < len(old.Index) {
+				// The old field loses because it's deeper than the new one.
+				old.Name = ""
+			} else {
+				// The old field wins because it's shallower than the new one.
+				add = false
+			}
+		}
+		if add {
+			// Copy the index so that it's not overwritten
+			// by the other appends.
+			f.Index = append([]int(nil), w.index...)
+			w.byName[f.Name] = len(w.fields)
+			w.fields = append(w.fields, f)
+		}
+		if f.Anonymous {
+			if f.Type.Kind() == Ptr {
+				f.Type = f.Type.Elem()
+			}
+			if f.Type.Kind() == Struct {
+				w.walk(f.Type)
+			}
+		}
+		w.index = w.index[:len(w.index)-1]
+	}
+	delete(w.visiting, t)
+}
diff --git a/src/reflect/visiblefields_test.go b/src/reflect/visiblefields_test.go
new file mode 100644
index 0000000000..2688b63091
--- /dev/null
+++ b/src/reflect/visiblefields_test.go
@@ -0,0 +1,326 @@
+package reflect_test
+
+import (
+	. "reflect"
+	"testing"
+)
+
+type structField struct {
+	name  string
+	index []int
+}
+
+var fieldsTests = []struct {
+	testName string
+	val      interface{}
+	expect   []structField
+}{{
+	testName: "SimpleStruct",
+	val: struct {
+		A int
+		B string
+		C bool
+	}{},
+	expect: []structField{{
+		name:  "A",
+		index: []int{0},
+	}, {
+		name:  "B",
+		index: []int{1},
+	}, {
+		name:  "C",
+		index: []int{2},
+	}},
+}, {
+	testName: "NonEmbeddedStructMember",
+	val: struct {
+		A struct {
+			X int
+		}
+	}{},
+	expect: []structField{{
+		name:  "A",
+		index: []int{0},
+	}},
+}, {
+	testName: "EmbeddedExportedStruct",
+	val: struct {
+		SFG
+	}{},
+	expect: []structField{{
+		name:  "SFG",
+		index: []int{0},
+	}, {
+		name:  "F",
+		index: []int{0, 0},
+	}, {
+		name:  "G",
+		index: []int{0, 1},
+	}},
+}, {
+	testName: "EmbeddedUnexportedStruct",
+	val: struct {
+		sFG
+	}{},
+	expect: []structField{{
+		name:  "sFG",
+		index: []int{0},
+	}, {
+		name:  "F",
+		index: []int{0, 0},
+	}, {
+		name:  "G",
+		index: []int{0, 1},
+	}},
+}, {
+	testName: "TwoEmbeddedStructsWithCancellingMembers",
+	val: struct {
+		SFG
+		SF
+	}{},
+	expect: []structField{{
+		name:  "SFG",
+		index: []int{0},
+	}, {
+		name:  "G",
+		index: []int{0, 1},
+	}, {
+		name:  "SF",
+		index: []int{1},
+	}},
+}, {
+	testName: "EmbeddedStructsWithSameFieldsAtDifferentDepths",
+	val: struct {
+		SFGH3
+		SG1
+		SFG2
+		SF2
+		L int
+	}{},
+	expect: []structField{{
+		name:  "SFGH3",
+		index: []int{0},
+	}, {
+		name:  "SFGH2",
+		index: []int{0, 0},
+	}, {
+		name:  "SFGH1",
+		index: []int{0, 0, 0},
+	}, {
+		name:  "SFGH",
+		index: []int{0, 0, 0, 0},
+	}, {
+		name:  "H",
+		index: []int{0, 0, 0, 0, 2},
+	}, {
+		name:  "SG1",
+		index: []int{1},
+	}, {
+		name:  "SG",
+		index: []int{1, 0},
+	}, {
+		name:  "G",
+		index: []int{1, 0, 0},
+	}, {
+		name:  "SFG2",
+		index: []int{2},
+	}, {
+		name:  "SFG1",
+		index: []int{2, 0},
+	}, {
+		name:  "SFG",
+		index: []int{2, 0, 0},
+	}, {
+		name:  "SF2",
+		index: []int{3},
+	}, {
+		name:  "SF1",
+		index: []int{3, 0},
+	}, {
+		name:  "SF",
+		index: []int{3, 0, 0},
+	}, {
+		name:  "L",
+		index: []int{4},
+	}},
+}, {
+	testName: "EmbeddedPointerStruct",
+	val: struct {
+		*SF
+	}{},
+	expect: []structField{{
+		name:  "SF",
+		index: []int{0},
+	}, {
+		name:  "F",
+		index: []int{0, 0},
+	}},
+}, {
+	testName: "EmbeddedNotAPointer",
+	val: struct {
+		M
+	}{},
+	expect: []structField{{
+		name:  "M",
+		index: []int{0},
+	}},
+}, {
+	testName: "RecursiveEmbedding",
+	val:      Rec1{},
+	expect: []structField{{
+		name:  "Rec2",
+		index: []int{0},
+	}, {
+		name:  "F",
+		index: []int{0, 0},
+	}, {
+		name:  "Rec1",
+		index: []int{0, 1},
+	}},
+}, {
+	testName: "RecursiveEmbedding2",
+	val:      Rec2{},
+	expect: []structField{{
+		name:  "F",
+		index: []int{0},
+	}, {
+		name:  "Rec1",
+		index: []int{1},
+	}, {
+		name:  "Rec2",
+		index: []int{1, 0},
+	}},
+}, {
+	testName: "RecursiveEmbedding3",
+	val:      RS3{},
+	expect: []structField{{
+		name:  "RS2",
+		index: []int{0},
+	}, {
+		name:  "RS1",
+		index: []int{1},
+	}, {
+		name:  "i",
+		index: []int{1, 0},
+	}},
+}}
+
+type SFG struct {
+	F int
+	G int
+}
+
+type SFG1 struct {
+	SFG
+}
+
+type SFG2 struct {
+	SFG1
+}
+
+type SFGH struct {
+	F int
+	G int
+	H int
+}
+
+type SFGH1 struct {
+	SFGH
+}
+
+type SFGH2 struct {
+	SFGH1
+}
+
+type SFGH3 struct {
+	SFGH2
+}
+
+type SF struct {
+	F int
+}
+
+type SF1 struct {
+	SF
+}
+
+type SF2 struct {
+	SF1
+}
+
+type SG struct {
+	G int
+}
+
+type SG1 struct {
+	SG
+}
+
+type sFG struct {
+	F int
+	G int
+}
+
+type RS1 struct {
+	i int
+}
+
+type RS2 struct {
+	RS1
+}
+
+type RS3 struct {
+	RS2
+	RS1
+}
+
+type M map[string]interface{}
+
+type Rec1 struct {
+	*Rec2
+}
+
+type Rec2 struct {
+	F string
+	*Rec1
+}
+
+func TestFields(t *testing.T) {
+	for _, test := range fieldsTests {
+		test := test
+		t.Run(test.testName, func(t *testing.T) {
+			typ := TypeOf(test.val)
+			fields := VisibleFields(typ)
+			if got, want := len(fields), len(test.expect); got != want {
+				t.Fatalf("unexpected field count; got %d want %d", got, want)
+			}
+
+			for j, field := range fields {
+				expect := test.expect[j]
+				t.Logf("field %d: %s", j, expect.name)
+				gotField := typ.FieldByIndex(field.Index)
+				// Unfortunately, FieldByIndex does not return
+				// a field with the same index that we passed in,
+				// so we set it to the expected value so that
+				// it can be compared later with the result of FieldByName.
+				gotField.Index = field.Index
+				expectField := typ.FieldByIndex(expect.index)
+				// ditto.
+				expectField.Index = expect.index
+				if !DeepEqual(gotField, expectField) {
+					t.Fatalf("unexpected field result\ngot %#v\nwant %#v", gotField, expectField)
+				}
+
+				// Sanity check that we can actually access the field by the
+				// expected name.
+				gotField1, ok := typ.FieldByName(expect.name)
+				if !ok {
+					t.Fatalf("field %q not accessible by name", expect.name)
+				}
+				if !DeepEqual(gotField1, expectField) {
+					t.Fatalf("unexpected FieldByName result; got %#v want %#v", gotField1, expectField)
+				}
+			}
+		})
+	}
+}
-- 
GitLab


From 414fa8c35e7c2f65e2c767d6db2f25791e53b5c1 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Sun, 8 Nov 2020 11:50:10 -0500
Subject: [PATCH 0971/2400] cmd/internal/objabi: use a separate bit to mark
 weak relocation

Instead of using two relocation types R_XXX and R_WEAKXXX, use a
separate bit, R_WEAK, to mark weak relocations. This makes it
easier to add more weak relocation types.

Change-Id: Iec4195c2aefa65f59e464c83018246e17cd08173
Reviewed-on: https://go-review.googlesource.com/c/go/+/268478
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/internal/objabi/reloctype.go        |  13 ++-
 src/cmd/internal/objabi/reloctype_string.go | 113 ++++++++++----------
 src/cmd/link/internal/ld/data.go            |  29 ++---
 src/cmd/link/internal/ld/deadcode.go        |   5 +-
 src/cmd/link/internal/loader/loader.go      |   3 +-
 5 files changed, 85 insertions(+), 78 deletions(-)

diff --git a/src/cmd/internal/objabi/reloctype.go b/src/cmd/internal/objabi/reloctype.go
index 649f690194..217d8565f2 100644
--- a/src/cmd/internal/objabi/reloctype.go
+++ b/src/cmd/internal/objabi/reloctype.go
@@ -50,11 +50,6 @@ const (
 	// R_ADDROFF resolves to a 32-bit offset from the beginning of the section
 	// holding the data being relocated to the referenced symbol.
 	R_ADDROFF
-	// R_WEAKADDROFF resolves just like R_ADDROFF but is a weak relocation.
-	// A weak relocation does not make the symbol it refers to reachable,
-	// and is only honored by the linker if the symbol is in some other way
-	// reachable.
-	R_WEAKADDROFF
 	R_SIZE
 	R_CALL
 	R_CALLARM
@@ -256,6 +251,14 @@ const (
 	// of a symbol. This isn't a real relocation, it can be placed in anywhere
 	// in a symbol and target any symbols.
 	R_XCOFFREF
+
+	// R_WEAK marks the relocation as a weak reference.
+	// A weak relocation does not make the symbol it refers to reachable,
+	// and is only honored by the linker if the symbol is in some other way
+	// reachable.
+	R_WEAK = -1 << 15
+
+	R_WEAKADDROFF = R_WEAK | R_ADDROFF
 )
 
 // IsDirectCall reports whether r is a relocation for a direct call.
diff --git a/src/cmd/internal/objabi/reloctype_string.go b/src/cmd/internal/objabi/reloctype_string.go
index 658a44f8b8..8882d19f88 100644
--- a/src/cmd/internal/objabi/reloctype_string.go
+++ b/src/cmd/internal/objabi/reloctype_string.go
@@ -13,66 +13,65 @@ func _() {
 	_ = x[R_ADDRARM64-3]
 	_ = x[R_ADDRMIPS-4]
 	_ = x[R_ADDROFF-5]
-	_ = x[R_WEAKADDROFF-6]
-	_ = x[R_SIZE-7]
-	_ = x[R_CALL-8]
-	_ = x[R_CALLARM-9]
-	_ = x[R_CALLARM64-10]
-	_ = x[R_CALLIND-11]
-	_ = x[R_CALLPOWER-12]
-	_ = x[R_CALLMIPS-13]
-	_ = x[R_CALLRISCV-14]
-	_ = x[R_CONST-15]
-	_ = x[R_PCREL-16]
-	_ = x[R_TLS_LE-17]
-	_ = x[R_TLS_IE-18]
-	_ = x[R_GOTOFF-19]
-	_ = x[R_PLT0-20]
-	_ = x[R_PLT1-21]
-	_ = x[R_PLT2-22]
-	_ = x[R_USEFIELD-23]
-	_ = x[R_USETYPE-24]
-	_ = x[R_USEIFACE-25]
-	_ = x[R_USEIFACEMETHOD-26]
-	_ = x[R_METHODOFF-27]
-	_ = x[R_POWER_TOC-28]
-	_ = x[R_GOTPCREL-29]
-	_ = x[R_JMPMIPS-30]
-	_ = x[R_DWARFSECREF-31]
-	_ = x[R_DWARFFILEREF-32]
-	_ = x[R_ARM64_TLS_LE-33]
-	_ = x[R_ARM64_TLS_IE-34]
-	_ = x[R_ARM64_GOTPCREL-35]
-	_ = x[R_ARM64_GOT-36]
-	_ = x[R_ARM64_PCREL-37]
-	_ = x[R_ARM64_LDST8-38]
-	_ = x[R_ARM64_LDST16-39]
-	_ = x[R_ARM64_LDST32-40]
-	_ = x[R_ARM64_LDST64-41]
-	_ = x[R_ARM64_LDST128-42]
-	_ = x[R_POWER_TLS_LE-43]
-	_ = x[R_POWER_TLS_IE-44]
-	_ = x[R_POWER_TLS-45]
-	_ = x[R_ADDRPOWER_DS-46]
-	_ = x[R_ADDRPOWER_GOT-47]
-	_ = x[R_ADDRPOWER_PCREL-48]
-	_ = x[R_ADDRPOWER_TOCREL-49]
-	_ = x[R_ADDRPOWER_TOCREL_DS-50]
-	_ = x[R_RISCV_PCREL_ITYPE-51]
-	_ = x[R_RISCV_PCREL_STYPE-52]
-	_ = x[R_RISCV_TLS_IE_ITYPE-53]
-	_ = x[R_RISCV_TLS_IE_STYPE-54]
-	_ = x[R_PCRELDBL-55]
-	_ = x[R_ADDRMIPSU-56]
-	_ = x[R_ADDRMIPSTLS-57]
-	_ = x[R_ADDRCUOFF-58]
-	_ = x[R_WASMIMPORT-59]
-	_ = x[R_XCOFFREF-60]
+	_ = x[R_SIZE-6]
+	_ = x[R_CALL-7]
+	_ = x[R_CALLARM-8]
+	_ = x[R_CALLARM64-9]
+	_ = x[R_CALLIND-10]
+	_ = x[R_CALLPOWER-11]
+	_ = x[R_CALLMIPS-12]
+	_ = x[R_CALLRISCV-13]
+	_ = x[R_CONST-14]
+	_ = x[R_PCREL-15]
+	_ = x[R_TLS_LE-16]
+	_ = x[R_TLS_IE-17]
+	_ = x[R_GOTOFF-18]
+	_ = x[R_PLT0-19]
+	_ = x[R_PLT1-20]
+	_ = x[R_PLT2-21]
+	_ = x[R_USEFIELD-22]
+	_ = x[R_USETYPE-23]
+	_ = x[R_USEIFACE-24]
+	_ = x[R_USEIFACEMETHOD-25]
+	_ = x[R_METHODOFF-26]
+	_ = x[R_POWER_TOC-27]
+	_ = x[R_GOTPCREL-28]
+	_ = x[R_JMPMIPS-29]
+	_ = x[R_DWARFSECREF-30]
+	_ = x[R_DWARFFILEREF-31]
+	_ = x[R_ARM64_TLS_LE-32]
+	_ = x[R_ARM64_TLS_IE-33]
+	_ = x[R_ARM64_GOTPCREL-34]
+	_ = x[R_ARM64_GOT-35]
+	_ = x[R_ARM64_PCREL-36]
+	_ = x[R_ARM64_LDST8-37]
+	_ = x[R_ARM64_LDST16-38]
+	_ = x[R_ARM64_LDST32-39]
+	_ = x[R_ARM64_LDST64-40]
+	_ = x[R_ARM64_LDST128-41]
+	_ = x[R_POWER_TLS_LE-42]
+	_ = x[R_POWER_TLS_IE-43]
+	_ = x[R_POWER_TLS-44]
+	_ = x[R_ADDRPOWER_DS-45]
+	_ = x[R_ADDRPOWER_GOT-46]
+	_ = x[R_ADDRPOWER_PCREL-47]
+	_ = x[R_ADDRPOWER_TOCREL-48]
+	_ = x[R_ADDRPOWER_TOCREL_DS-49]
+	_ = x[R_RISCV_PCREL_ITYPE-50]
+	_ = x[R_RISCV_PCREL_STYPE-51]
+	_ = x[R_RISCV_TLS_IE_ITYPE-52]
+	_ = x[R_RISCV_TLS_IE_STYPE-53]
+	_ = x[R_PCRELDBL-54]
+	_ = x[R_ADDRMIPSU-55]
+	_ = x[R_ADDRMIPSTLS-56]
+	_ = x[R_ADDRCUOFF-57]
+	_ = x[R_WASMIMPORT-58]
+	_ = x[R_XCOFFREF-59]
 }
 
-const _RelocType_name = "R_ADDRR_ADDRPOWERR_ADDRARM64R_ADDRMIPSR_ADDROFFR_WEAKADDROFFR_SIZER_CALLR_CALLARMR_CALLARM64R_CALLINDR_CALLPOWERR_CALLMIPSR_CALLRISCVR_CONSTR_PCRELR_TLS_LER_TLS_IER_GOTOFFR_PLT0R_PLT1R_PLT2R_USEFIELDR_USETYPER_USEIFACER_USEIFACEMETHODR_METHODOFFR_POWER_TOCR_GOTPCRELR_JMPMIPSR_DWARFSECREFR_DWARFFILEREFR_ARM64_TLS_LER_ARM64_TLS_IER_ARM64_GOTPCRELR_ARM64_GOTR_ARM64_PCRELR_ARM64_LDST8R_ARM64_LDST16R_ARM64_LDST32R_ARM64_LDST64R_ARM64_LDST128R_POWER_TLS_LER_POWER_TLS_IER_POWER_TLSR_ADDRPOWER_DSR_ADDRPOWER_GOTR_ADDRPOWER_PCRELR_ADDRPOWER_TOCRELR_ADDRPOWER_TOCREL_DSR_RISCV_PCREL_ITYPER_RISCV_PCREL_STYPER_RISCV_TLS_IE_ITYPER_RISCV_TLS_IE_STYPER_PCRELDBLR_ADDRMIPSUR_ADDRMIPSTLSR_ADDRCUOFFR_WASMIMPORTR_XCOFFREF"
+const _RelocType_name = "R_ADDRR_ADDRPOWERR_ADDRARM64R_ADDRMIPSR_ADDROFFR_SIZER_CALLR_CALLARMR_CALLARM64R_CALLINDR_CALLPOWERR_CALLMIPSR_CALLRISCVR_CONSTR_PCRELR_TLS_LER_TLS_IER_GOTOFFR_PLT0R_PLT1R_PLT2R_USEFIELDR_USETYPER_USEIFACER_USEIFACEMETHODR_METHODOFFR_POWER_TOCR_GOTPCRELR_JMPMIPSR_DWARFSECREFR_DWARFFILEREFR_ARM64_TLS_LER_ARM64_TLS_IER_ARM64_GOTPCRELR_ARM64_GOTR_ARM64_PCRELR_ARM64_LDST8R_ARM64_LDST16R_ARM64_LDST32R_ARM64_LDST64R_ARM64_LDST128R_POWER_TLS_LER_POWER_TLS_IER_POWER_TLSR_ADDRPOWER_DSR_ADDRPOWER_GOTR_ADDRPOWER_PCRELR_ADDRPOWER_TOCRELR_ADDRPOWER_TOCREL_DSR_RISCV_PCREL_ITYPER_RISCV_PCREL_STYPER_RISCV_TLS_IE_ITYPER_RISCV_TLS_IE_STYPER_PCRELDBLR_ADDRMIPSUR_ADDRMIPSTLSR_ADDRCUOFFR_WASMIMPORTR_XCOFFREF"
 
-var _RelocType_index = [...]uint16{0, 6, 17, 28, 38, 47, 60, 66, 72, 81, 92, 101, 112, 122, 133, 140, 147, 155, 163, 171, 177, 183, 189, 199, 208, 218, 234, 245, 256, 266, 275, 288, 302, 316, 330, 346, 357, 370, 383, 397, 411, 425, 440, 454, 468, 479, 493, 508, 525, 543, 564, 583, 602, 622, 642, 652, 663, 676, 687, 699, 709}
+var _RelocType_index = [...]uint16{0, 6, 17, 28, 38, 47, 53, 59, 68, 79, 88, 99, 109, 120, 127, 134, 142, 150, 158, 164, 170, 176, 186, 195, 205, 221, 232, 243, 253, 262, 275, 289, 303, 317, 333, 344, 357, 370, 384, 398, 412, 427, 441, 455, 466, 480, 495, 512, 530, 551, 570, 589, 609, 629, 639, 650, 663, 674, 686, 696}
 
 func (i RelocType) String() string {
 	i -= 1
diff --git a/src/cmd/link/internal/ld/data.go b/src/cmd/link/internal/ld/data.go
index 92d38bb63e..a9d17c806e 100644
--- a/src/cmd/link/internal/ld/data.go
+++ b/src/cmd/link/internal/ld/data.go
@@ -165,6 +165,7 @@ func (st *relocSymState) relocsym(s loader.Sym, P []byte) {
 		rs := r.Sym()
 		rs = ldr.ResolveABIAlias(rs)
 		rt := r.Type()
+		weak := r.Weak()
 		if off < 0 || off+siz > int32(len(P)) {
 			rname := ""
 			if rs != 0 {
@@ -211,7 +212,7 @@ func (st *relocSymState) relocsym(s loader.Sym, P []byte) {
 				st.err.Errorf(s, "unhandled relocation for %s (type %d (%s) rtype %d (%s))", ldr.SymName(rs), rst, rst, rt, sym.RelocName(target.Arch, rt))
 			}
 		}
-		if rs != 0 && rst != sym.STLSBSS && rt != objabi.R_WEAKADDROFF && rt != objabi.R_METHODOFF && !ldr.AttrReachable(rs) {
+		if rs != 0 && rst != sym.STLSBSS && !weak && rt != objabi.R_METHODOFF && !ldr.AttrReachable(rs) {
 			st.err.Errorf(s, "unreachable sym in relocation: %s", ldr.SymName(rs))
 		}
 
@@ -387,18 +388,18 @@ func (st *relocSymState) relocsym(s loader.Sym, P []byte) {
 				break
 			}
 			o = ldr.SymValue(rs) + r.Add() - int64(ldr.SymSect(rs).Vaddr)
-		case objabi.R_WEAKADDROFF, objabi.R_METHODOFF:
+		case objabi.R_METHODOFF:
 			if !ldr.AttrReachable(rs) {
-				if rt == objabi.R_METHODOFF {
-					// Set it to a sentinel value. The runtime knows this is not pointing to
-					// anything valid.
-					o = -1
-					break
-				}
-				continue
+				// Set it to a sentinel value. The runtime knows this is not pointing to
+				// anything valid.
+				o = -1
+				break
 			}
 			fallthrough
 		case objabi.R_ADDROFF:
+			if weak && !ldr.AttrReachable(rs) {
+				continue
+			}
 			// The method offset tables using this relocation expect the offset to be relative
 			// to the start of the first text section, even if there are multiple.
 			if ldr.SymSect(rs).Name == ".text" {
@@ -635,7 +636,7 @@ func extreloc(ctxt *Link, ldr *loader.Loader, s loader.Sym, r loader.Reloc) (loa
 		return ExtrelocSimple(ldr, r), true
 
 	// These reloc types don't need external relocations.
-	case objabi.R_ADDROFF, objabi.R_WEAKADDROFF, objabi.R_METHODOFF, objabi.R_ADDRCUOFF,
+	case objabi.R_ADDROFF, objabi.R_METHODOFF, objabi.R_ADDRCUOFF,
 		objabi.R_SIZE, objabi.R_CONST, objabi.R_GOTOFF:
 		return rr, false
 	}
@@ -710,9 +711,8 @@ func windynrelocsym(ctxt *Link, rel *loader.SymbolBuilder, s loader.Sym) {
 		if targ == 0 {
 			continue
 		}
-		rt := r.Type()
 		if !ctxt.loader.AttrReachable(targ) {
-			if rt == objabi.R_WEAKADDROFF {
+			if r.Weak() {
 				continue
 			}
 			ctxt.Errorf(s, "dynamic relocation to unreachable symbol %s",
@@ -786,6 +786,10 @@ func dynrelocsym(ctxt *Link, s loader.Sym) {
 		if r.IsMarker() {
 			continue // skip marker relocations
 		}
+		rSym := r.Sym()
+		if r.Weak() && !ldr.AttrReachable(rSym) {
+			continue
+		}
 		if ctxt.BuildMode == BuildModePIE && ctxt.LinkMode == LinkInternal {
 			// It's expected that some relocations will be done
 			// later by relocsym (R_TLS_LE, R_ADDROFF), so
@@ -794,7 +798,6 @@ func dynrelocsym(ctxt *Link, s loader.Sym) {
 			continue
 		}
 
-		rSym := r.Sym()
 		if rSym != 0 && ldr.SymType(rSym) == sym.SDYNIMPORT || r.Type() >= objabi.ElfRelocOffset {
 			if rSym != 0 && !ldr.AttrReachable(rSym) {
 				ctxt.Errorf(s, "dynamic relocation to unreachable symbol %s", ldr.SymName(rSym))
diff --git a/src/cmd/link/internal/ld/deadcode.go b/src/cmd/link/internal/ld/deadcode.go
index ebde41499e..ed276b5a99 100644
--- a/src/cmd/link/internal/ld/deadcode.go
+++ b/src/cmd/link/internal/ld/deadcode.go
@@ -128,10 +128,11 @@ func (d *deadcodePass) flood() {
 		methods = methods[:0]
 		for i := 0; i < relocs.Count(); i++ {
 			r := relocs.At(i)
+			if r.Weak() {
+				continue
+			}
 			t := r.Type()
 			switch t {
-			case objabi.R_WEAKADDROFF:
-				continue
 			case objabi.R_METHODOFF:
 				if i+2 >= relocs.Count() {
 					panic("expect three consecutive R_METHODOFF relocs")
diff --git a/src/cmd/link/internal/loader/loader.go b/src/cmd/link/internal/loader/loader.go
index 6d2e7dcabc..5df4348a36 100644
--- a/src/cmd/link/internal/loader/loader.go
+++ b/src/cmd/link/internal/loader/loader.go
@@ -53,7 +53,8 @@ type Reloc struct {
 	l *Loader
 }
 
-func (rel Reloc) Type() objabi.RelocType     { return objabi.RelocType(rel.Reloc.Type()) }
+func (rel Reloc) Type() objabi.RelocType     { return objabi.RelocType(rel.Reloc.Type()) &^ objabi.R_WEAK }
+func (rel Reloc) Weak() bool                 { return objabi.RelocType(rel.Reloc.Type())&objabi.R_WEAK != 0 }
 func (rel Reloc) SetType(t objabi.RelocType) { rel.Reloc.SetType(uint16(t)) }
 func (rel Reloc) Sym() Sym                   { return rel.l.resolve(rel.r, rel.Reloc.Sym()) }
 func (rel Reloc) SetSym(s Sym)               { rel.Reloc.SetSym(goobj.SymRef{PkgIdx: 0, SymIdx: uint32(s)}) }
-- 
GitLab


From b0df92703c89e42592659ae99cded0d5b68382b7 Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Mon, 4 Jan 2021 13:34:29 -0800
Subject: [PATCH 0972/2400] math/big: add shrVU and shlVU benchmarks

Change-Id: Id67d6ac856bd9271de99c3381bde910aa0c166e0
Reviewed-on: https://go-review.googlesource.com/c/go/+/296011
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/math/big/arith_test.go | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/src/math/big/arith_test.go b/src/math/big/arith_test.go
index 2aca0effde..7b3427f834 100644
--- a/src/math/big/arith_test.go
+++ b/src/math/big/arith_test.go
@@ -671,3 +671,27 @@ func BenchmarkDivWVW(b *testing.B) {
 		})
 	}
 }
+
+func BenchmarkNonZeroShifts(b *testing.B) {
+	for _, n := range benchSizes {
+		if isRaceBuilder && n > 1e3 {
+			continue
+		}
+		x := rndV(n)
+		s := uint(rand.Int63n(_W-2)) + 1 // avoid 0 and over-large shifts
+		z := make([]Word, n)
+		b.Run(fmt.Sprint(n), func(b *testing.B) {
+			b.SetBytes(int64(n * _W))
+			b.Run("shrVU", func(b *testing.B) {
+				for i := 0; i < b.N; i++ {
+					_ = shrVU(z, x, s)
+				}
+			})
+			b.Run("shlVU", func(b *testing.B) {
+				for i := 0; i < b.N; i++ {
+					_ = shlVU(z, x, s)
+				}
+			})
+		})
+	}
+}
-- 
GitLab


From 597b5d192e39d7bba38dd461b96effe6e524984b Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 6 Mar 2021 23:25:25 -0800
Subject: [PATCH 0973/2400] cmd/compile: rename internal-abi.md to
 abi-internal.md

Allows muscle-memoried tab completion of cmd/compile/internal/...
paths to work again.

Change-Id: Ib54a5f2cc9fabcb876c2e62635828ab28b565501
Reviewed-on: https://go-review.googlesource.com/c/go/+/299530
Reviewed-by: Austin Clements <austin@google.com>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/{internal-abi.md => abi-internal.md} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename src/cmd/compile/{internal-abi.md => abi-internal.md} (100%)

diff --git a/src/cmd/compile/internal-abi.md b/src/cmd/compile/abi-internal.md
similarity index 100%
rename from src/cmd/compile/internal-abi.md
rename to src/cmd/compile/abi-internal.md
-- 
GitLab


From 125eca0f7210da1bbf1a4a1460a87d1c33366b99 Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Sat, 6 Mar 2021 04:46:07 +1100
Subject: [PATCH 0974/2400] cmd/compile: improve IsNonNil rule on riscv64

IsNonNil is readily implemented using SNEZ on riscv64, removing over 8,000
instructions from the go binary. Other rules will improve on this sequence,
however in this case it makes sense to use a direct simplification.

Change-Id: Ib4068599532398afcd05f51d160673ef5fb5e5a0
Reviewed-on: https://go-review.googlesource.com/c/go/+/299230
Trust: Joel Sing <joel@sing.id.au>
Reviewed-by: Michael Munday <mike.munday@lowrisc.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ssa/gen/RISCV64.rules |  2 +-
 src/cmd/compile/internal/ssa/rewriteRISCV64.go | 18 ++----------------
 2 files changed, 3 insertions(+), 17 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/gen/RISCV64.rules b/src/cmd/compile/internal/ssa/gen/RISCV64.rules
index d7efef039e..dbe04f1d58 100644
--- a/src/cmd/compile/internal/ssa/gen/RISCV64.rules
+++ b/src/cmd/compile/internal/ssa/gen/RISCV64.rules
@@ -423,7 +423,7 @@
 (Convert ...) => (MOVconvert ...)
 
 // Checks
-(IsNonNil p) => (NeqPtr (MOVDconst [0]) p)
+(IsNonNil ...) => (SNEZ ...)
 (IsInBounds ...) => (Less64U ...)
 (IsSliceInBounds ...) => (Leq64U ...)
 
diff --git a/src/cmd/compile/internal/ssa/rewriteRISCV64.go b/src/cmd/compile/internal/ssa/rewriteRISCV64.go
index 7f77477da7..895f380d33 100644
--- a/src/cmd/compile/internal/ssa/rewriteRISCV64.go
+++ b/src/cmd/compile/internal/ssa/rewriteRISCV64.go
@@ -239,7 +239,8 @@ func rewriteValueRISCV64(v *Value) bool {
 		v.Op = OpLess64U
 		return true
 	case OpIsNonNil:
-		return rewriteValueRISCV64_OpIsNonNil(v)
+		v.Op = OpRISCV64SNEZ
+		return true
 	case OpIsSliceInBounds:
 		v.Op = OpLeq64U
 		return true
@@ -1101,21 +1102,6 @@ func rewriteValueRISCV64_OpHmul32u(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueRISCV64_OpIsNonNil(v *Value) bool {
-	v_0 := v.Args[0]
-	b := v.Block
-	typ := &b.Func.Config.Types
-	// match: (IsNonNil p)
-	// result: (NeqPtr (MOVDconst [0]) p)
-	for {
-		p := v_0
-		v.reset(OpNeqPtr)
-		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
-		v0.AuxInt = int64ToAuxInt(0)
-		v.AddArg2(v0, p)
-		return true
-	}
-}
 func rewriteValueRISCV64_OpLeq16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
-- 
GitLab


From aafad20b617ee63d58fcd4f6e0d98fe27760678c Mon Sep 17 00:00:00 2001
From: Emmanuel T Odeke <emmanuel@orijtech.com>
Date: Sat, 6 Mar 2021 23:14:21 -0800
Subject: [PATCH 0975/2400] encoding/binary: limit bytes read by Uvarint to <=
 10

Limits the number of bytes that can be consumed by Uvarint
to MaxVarintLen64 (10) to avoid wasted computations.
With this change, if Uvarint reads more than MaxVarintLen64
bytes, it'll return the erroring byte count of n=-(MaxVarintLen64+1)
which is -11, as per the function signature.

Updated some tests to reflect the new change in expectations of n
when the number of bytes to be read exceeds the limits..

Fixes #41185

Change-Id: Ie346457b1ddb0214b60c72e81128e24d604d083d
Reviewed-on: https://go-review.googlesource.com/c/go/+/299531
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/encoding/binary/varint.go      |  7 +++-
 src/encoding/binary/varint_test.go | 63 ++++++++++++++++++++++++++++--
 2 files changed, 66 insertions(+), 4 deletions(-)

diff --git a/src/encoding/binary/varint.go b/src/encoding/binary/varint.go
index 1fa325dec7..8fe20b5c45 100644
--- a/src/encoding/binary/varint.go
+++ b/src/encoding/binary/varint.go
@@ -61,8 +61,13 @@ func Uvarint(buf []byte) (uint64, int) {
 	var x uint64
 	var s uint
 	for i, b := range buf {
+		if i == MaxVarintLen64 {
+			// Catch byte reads past MaxVarintLen64.
+			// See issue https://golang.org/issues/41185
+			return 0, -(i + 1) // overflow
+		}
 		if b < 0x80 {
-			if i >= MaxVarintLen64 || i == MaxVarintLen64-1 && b > 1 {
+			if i == MaxVarintLen64-1 && b > 1 {
 				return 0, -(i + 1) // overflow
 			}
 			return x | uint64(b)<<s, i + 1
diff --git a/src/encoding/binary/varint_test.go b/src/encoding/binary/varint_test.go
index 6ef4c99505..d025a67538 100644
--- a/src/encoding/binary/varint_test.go
+++ b/src/encoding/binary/varint_test.go
@@ -7,6 +7,7 @@ package binary
 import (
 	"bytes"
 	"io"
+	"math"
 	"testing"
 )
 
@@ -121,10 +122,66 @@ func TestBufferTooSmall(t *testing.T) {
 	}
 }
 
+// Ensure that we catch overflows of bytes going past MaxVarintLen64.
+// See issue https://golang.org/issues/41185
+func TestBufferTooBigWithOverflow(t *testing.T) {
+	tests := []struct {
+		in        []byte
+		name      string
+		wantN     int
+		wantValue uint64
+	}{
+		{
+			name: "invalid: 1000 bytes",
+			in: func() []byte {
+				b := make([]byte, 1000)
+				for i := range b {
+					b[i] = 0xff
+				}
+				b[999] = 0
+				return b
+			}(),
+			wantN:     -11,
+			wantValue: 0,
+		},
+		{
+			name:      "valid: math.MaxUint64-40",
+			in:        []byte{0xd7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01},
+			wantValue: math.MaxUint64 - 40,
+			wantN:     10,
+		},
+		{
+			name:      "invalid: with more than MaxVarintLen64 bytes",
+			in:        []byte{0xd7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01},
+			wantN:     -11,
+			wantValue: 0,
+		},
+		{
+			name:      "invalid: 10th byte",
+			in:        []byte{0xd7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f},
+			wantN:     -10,
+			wantValue: 0,
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			value, n := Uvarint(tt.in)
+			if g, w := n, tt.wantN; g != w {
+				t.Errorf("bytes returned=%d, want=%d", g, w)
+			}
+			if g, w := value, tt.wantValue; g != w {
+				t.Errorf("value=%d, want=%d", g, w)
+			}
+		})
+	}
+}
+
 func testOverflow(t *testing.T, buf []byte, x0 uint64, n0 int, err0 error) {
 	x, n := Uvarint(buf)
 	if x != 0 || n != n0 {
-		t.Errorf("Uvarint(%v): got x = %d, n = %d; want 0, %d", buf, x, n, n0)
+		t.Errorf("Uvarint(% X): got x = %d, n = %d; want 0, %d", buf, x, n, n0)
 	}
 
 	r := bytes.NewReader(buf)
@@ -140,8 +197,8 @@ func testOverflow(t *testing.T, buf []byte, x0 uint64, n0 int, err0 error) {
 
 func TestOverflow(t *testing.T) {
 	testOverflow(t, []byte{0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x2}, 0, -10, overflow)
-	testOverflow(t, []byte{0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x1, 0, 0}, 0, -13, overflow)
-	testOverflow(t, []byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 1<<64-1, 0, overflow) // 11 bytes, should overflow
+	testOverflow(t, []byte{0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x1, 0, 0}, 0, -11, overflow)
+	testOverflow(t, []byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 1<<64-1, -11, overflow) // 11 bytes, should overflow
 }
 
 func TestNonCanonicalZero(t *testing.T) {
-- 
GitLab


From b4787201c9872fbbe8e1ebb2e2113b31ec2105a6 Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Sun, 7 Mar 2021 14:48:08 -0800
Subject: [PATCH 0976/2400] cmd/compile: minor doc improvements

These are left over from comments I failed to leave on CL 249463;
apparently I never hit "Reply".

Change-Id: Ia3f8a900703c347f8f98581ec1ac172c0f72cd9e
Reviewed-on: https://go-review.googlesource.com/c/go/+/299589
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/ssa/decompose.go | 2 +-
 src/cmd/compile/internal/ssa/rewrite.go   | 2 +-
 src/cmd/compile/internal/ssa/value.go     | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/decompose.go b/src/cmd/compile/internal/ssa/decompose.go
index ea988e44f6..ba48b6b3b9 100644
--- a/src/cmd/compile/internal/ssa/decompose.go
+++ b/src/cmd/compile/internal/ssa/decompose.go
@@ -24,7 +24,7 @@ func decomposeBuiltIn(f *Func) {
 	}
 
 	// Decompose other values
-	// Note: deadcode is false because we need to keep the original
+	// Note: Leave dead values because we need to keep the original
 	// values around so the name component resolution below can still work.
 	applyRewrite(f, rewriteBlockdec, rewriteValuedec, leaveDeadValues)
 	if f.Config.RegSize == 4 {
diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go
index 07bbdb8813..5c56b2b346 100644
--- a/src/cmd/compile/internal/ssa/rewrite.go
+++ b/src/cmd/compile/internal/ssa/rewrite.go
@@ -27,7 +27,7 @@ const (
 	removeDeadValues                 = true
 )
 
-// deadcode indicates that rewrite should try to remove any values that become dead.
+// deadcode indicates whether rewrite should try to remove any values that become dead.
 func applyRewrite(f *Func, rb blockRewriter, rv valueRewriter, deadcode deadValueChoice) {
 	// repeat rewrites until we find no more rewrites
 	pendingLines := f.cachedLineStarts // Holds statement boundaries that need to be moved to a new value/block
diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go
index c20fc87e90..6cc2b2ab8b 100644
--- a/src/cmd/compile/internal/ssa/value.go
+++ b/src/cmd/compile/internal/ssa/value.go
@@ -499,7 +499,7 @@ func (v *Value) removeable() bool {
 		return false
 	}
 	if v.Type.IsMemory() {
-		// All memory ops aren't needed here, but we do need
+		// We don't need to preserve all memory ops, but we do need
 		// to keep calls at least (because they might have
 		// synchronization operations we can't see).
 		return false
-- 
GitLab


From 7419a86c824efc6e2696f29e4dc1ac81756f1dfb Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Sun, 7 Mar 2021 20:32:38 -0800
Subject: [PATCH 0977/2400] cmd/link/internal/ld: fix typo in a comment

Change-Id: I6d0fafd38f0ad9392f163a9d8cd94d103bf2a059
Reviewed-on: https://go-review.googlesource.com/c/go/+/299669
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/link/internal/ld/deadcode.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/link/internal/ld/deadcode.go b/src/cmd/link/internal/ld/deadcode.go
index ed276b5a99..ea98fea4e5 100644
--- a/src/cmd/link/internal/ld/deadcode.go
+++ b/src/cmd/link/internal/ld/deadcode.go
@@ -19,7 +19,7 @@ var _ = fmt.Print
 type deadcodePass struct {
 	ctxt *Link
 	ldr  *loader.Loader
-	wq   heap // work queue, using min-heap for beter locality
+	wq   heap // work queue, using min-heap for better locality
 
 	ifaceMethod     map[methodsig]bool // methods declared in reached interfaces
 	markableMethods []methodref        // methods of reached types
-- 
GitLab


From fee3cd4250843a0a7c056fed3d3e6e1a423f3120 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong@orijtech.com>
Date: Tue, 9 Mar 2021 01:52:10 +0700
Subject: [PATCH 0978/2400] cmd/compile: fix width not calculated for imported
 type

The compiler currently has problem that some imported type is missing
size calculation. The problem is not triggered until CL 283313 merged,
due to the compiler can compile the functions immediately when it sees
them, so during SSA generation, size calculation is still ok.

CL 283313 makes the compiler always push functions to compile queue,
then drain from it for compiling function. During this process, the
types calculation size is disabled, so calculating size during SSA now
make the compiler crashes.

To fix this, we can just always calculate type size during typechecking,
when importing type from other packages.

Fixes #44732

Change-Id: I8d00ea0b5aadd432154908280e55d85c75f3ce92
Reviewed-on: https://go-review.googlesource.com/c/go/+/299689
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/typecheck/iimport.go |  6 ++++++
 test/fixedbugs/issue44732.dir/bar/bar.go      | 11 +++++++++++
 test/fixedbugs/issue44732.dir/foo/foo.go      | 13 +++++++++++++
 test/fixedbugs/issue44732.dir/main.go         | 15 +++++++++++++++
 test/fixedbugs/issue44732.go                  |  7 +++++++
 5 files changed, 52 insertions(+)
 create mode 100644 test/fixedbugs/issue44732.dir/bar/bar.go
 create mode 100644 test/fixedbugs/issue44732.dir/foo/foo.go
 create mode 100644 test/fixedbugs/issue44732.dir/main.go
 create mode 100644 test/fixedbugs/issue44732.go

diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 9355174da8..8df75b2285 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -508,6 +508,12 @@ func (p *iimporter) typAt(off uint64) *types.Type {
 			base.Fatalf("predeclared type missing from cache: %d", off)
 		}
 		t = p.newReader(off-predeclReserved, nil).typ1()
+		// Ensure size is calculated for imported types. Since CL 283313, the compiler
+		// does not compile the function immediately when it sees them. Instead, funtions
+		// are pushed to compile queue, then draining from the queue for compiling.
+		// During this process, the size calculation is disabled, so it is not safe for
+		// calculating size during SSA generation anymore. See issue #44732.
+		types.CheckSize(t)
 		p.typCache[off] = t
 	}
 	return t
diff --git a/test/fixedbugs/issue44732.dir/bar/bar.go b/test/fixedbugs/issue44732.dir/bar/bar.go
new file mode 100644
index 0000000000..fc14161610
--- /dev/null
+++ b/test/fixedbugs/issue44732.dir/bar/bar.go
@@ -0,0 +1,11 @@
+// Copyright 2021 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 bar
+
+import "issue44732.dir/foo"
+
+type Bar struct {
+	Foo *foo.Foo
+}
diff --git a/test/fixedbugs/issue44732.dir/foo/foo.go b/test/fixedbugs/issue44732.dir/foo/foo.go
new file mode 100644
index 0000000000..c8afb0e880
--- /dev/null
+++ b/test/fixedbugs/issue44732.dir/foo/foo.go
@@ -0,0 +1,13 @@
+// Copyright 2021 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 foo
+
+type Foo struct {
+	updatecb func()
+}
+
+func NewFoo() *Foo {
+	return &Foo{updatecb: nil}
+}
diff --git a/test/fixedbugs/issue44732.dir/main.go b/test/fixedbugs/issue44732.dir/main.go
new file mode 100644
index 0000000000..21208ecdd9
--- /dev/null
+++ b/test/fixedbugs/issue44732.dir/main.go
@@ -0,0 +1,15 @@
+// Copyright 2021 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 (
+	"issue44732.dir/bar"
+	"issue44732.dir/foo"
+)
+
+func main() {
+	_ = bar.Bar{}
+	_ = foo.NewFoo()
+}
diff --git a/test/fixedbugs/issue44732.go b/test/fixedbugs/issue44732.go
new file mode 100644
index 0000000000..4210671205
--- /dev/null
+++ b/test/fixedbugs/issue44732.go
@@ -0,0 +1,7 @@
+// runindir
+
+// Copyright 2021 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 ignored
-- 
GitLab


From bd372847849c9187fd6112bd3cc0203c15c3ac72 Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Sun, 7 Mar 2021 20:52:39 -0800
Subject: [PATCH 0979/2400] cmd/link: use testing.T.TempDir in tests

Change-Id: I6fc8c9ee6d2246bfd874eb58b411e34ddbeaf723
Reviewed-on: https://go-review.googlesource.com/c/go/+/299670
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/link/dwarf_test.go                    |   7 +-
 src/cmd/link/elf_test.go                      |  18 +--
 src/cmd/link/internal/ld/deadcode_test.go     |   8 +-
 src/cmd/link/internal/ld/dwarf_test.go        | 104 ++++----------
 src/cmd/link/internal/ld/elf_test.go          |  13 +-
 src/cmd/link/internal/ld/fallocate_test.go    |   9 +-
 src/cmd/link/internal/ld/go_test.go           |   7 +-
 src/cmd/link/internal/ld/issue33808_test.go   |   8 +-
 src/cmd/link/internal/ld/ld_test.go           |  26 +---
 src/cmd/link/internal/ld/nooptcgolink_test.go |   8 +-
 src/cmd/link/internal/ld/outbuf_test.go       |   8 +-
 src/cmd/link/link_test.go                     | 129 ++++--------------
 src/cmd/link/linkbig_test.go                  |   9 +-
 13 files changed, 75 insertions(+), 279 deletions(-)

diff --git a/src/cmd/link/dwarf_test.go b/src/cmd/link/dwarf_test.go
index d0284ad4f5..0419613cbe 100644
--- a/src/cmd/link/dwarf_test.go
+++ b/src/cmd/link/dwarf_test.go
@@ -10,7 +10,6 @@ import (
 	"cmd/internal/objfile"
 	"debug/dwarf"
 	"internal/testenv"
-	"io/ioutil"
 	"os"
 	"os/exec"
 	"path"
@@ -59,11 +58,7 @@ func testDWARF(t *testing.T, buildmode string, expectDWARF bool, env ...string)
 		t.Run(prog, func(t *testing.T) {
 			t.Parallel()
 
-			tmpDir, err := ioutil.TempDir("", "go-link-TestDWARF")
-			if err != nil {
-				t.Fatal(err)
-			}
-			defer os.RemoveAll(tmpDir)
+			tmpDir := t.TempDir()
 
 			exe := filepath.Join(tmpDir, prog+".exe")
 			dir := "../../runtime/testdata/" + prog
diff --git a/src/cmd/link/elf_test.go b/src/cmd/link/elf_test.go
index b4441297e6..012c0b5169 100644
--- a/src/cmd/link/elf_test.go
+++ b/src/cmd/link/elf_test.go
@@ -70,11 +70,7 @@ func TestSectionsWithSameName(t *testing.T) {
 		t.Skipf("can't find objcopy: %v", err)
 	}
 
-	dir, err := ioutil.TempDir("", "go-link-TestSectionsWithSameName")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	gopath := filepath.Join(dir, "GOPATH")
 	env := append(os.Environ(), "GOPATH="+gopath)
@@ -144,11 +140,7 @@ func TestMinusRSymsWithSameName(t *testing.T) {
 	testenv.MustHaveCGO(t)
 	t.Parallel()
 
-	dir, err := ioutil.TempDir("", "go-link-TestMinusRSymsWithSameName")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	gopath := filepath.Join(dir, "GOPATH")
 	env := append(os.Environ(), "GOPATH="+gopath)
@@ -271,11 +263,7 @@ func TestPIESize(t *testing.T) {
 		t.Run(name, func(t *testing.T) {
 			t.Parallel()
 
-			dir, err := ioutil.TempDir("", "go-link-"+name)
-			if err != nil {
-				t.Fatal(err)
-			}
-			defer os.RemoveAll(dir)
+			dir := t.TempDir()
 
 			writeGo(t, dir)
 
diff --git a/src/cmd/link/internal/ld/deadcode_test.go b/src/cmd/link/internal/ld/deadcode_test.go
index b756091613..bd74205a1a 100644
--- a/src/cmd/link/internal/ld/deadcode_test.go
+++ b/src/cmd/link/internal/ld/deadcode_test.go
@@ -7,8 +7,6 @@ package ld
 import (
 	"bytes"
 	"internal/testenv"
-	"io/ioutil"
-	"os"
 	"os/exec"
 	"path/filepath"
 	"testing"
@@ -18,11 +16,7 @@ func TestDeadcode(t *testing.T) {
 	testenv.MustHaveGoBuild(t)
 	t.Parallel()
 
-	tmpdir, err := ioutil.TempDir("", "TestDeadcode")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	tests := []struct {
 		src      string
diff --git a/src/cmd/link/internal/ld/dwarf_test.go b/src/cmd/link/internal/ld/dwarf_test.go
index a66506d392..d16cff911b 100644
--- a/src/cmd/link/internal/ld/dwarf_test.go
+++ b/src/cmd/link/internal/ld/dwarf_test.go
@@ -39,11 +39,7 @@ func TestRuntimeTypesPresent(t *testing.T) {
 		t.Skip("skipping on plan9; no DWARF symbol table in executables")
 	}
 
-	dir, err := ioutil.TempDir("", "TestRuntimeTypesPresent")
-	if err != nil {
-		t.Fatalf("could not create directory: %v", err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	f := gobuild(t, dir, `package main; func main() { }`, NoOpt)
 	defer f.Close()
@@ -171,11 +167,7 @@ func main() {
 		"main.Baz": {"Foo": true, "name": false},
 	}
 
-	dir, err := ioutil.TempDir("", "TestEmbeddedStructMarker")
-	if err != nil {
-		t.Fatalf("could not create directory: %v", err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	f := gobuild(t, dir, prog, NoOpt)
 
@@ -255,11 +247,8 @@ func main() {
 	y[0] = nil
 }
 `
-	dir, err := ioutil.TempDir("", "TestSizes")
-	if err != nil {
-		t.Fatalf("could not create directory: %v", err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
+
 	f := gobuild(t, dir, prog, NoOpt)
 	defer f.Close()
 	d, err := f.DWARF()
@@ -303,11 +292,7 @@ func main() {
 	c <- "foo"
 }
 `
-	dir, err := ioutil.TempDir("", "TestFieldOverlap")
-	if err != nil {
-		t.Fatalf("could not create directory: %v", err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	f := gobuild(t, dir, prog, NoOpt)
 	defer f.Close()
@@ -351,13 +336,10 @@ func varDeclCoordsAndSubrogramDeclFile(t *testing.T, testpoint string, expectFil
 
 	prog := fmt.Sprintf("package main\n%s\nfunc main() {\n\nvar i int\ni = i\n}\n", directive)
 
-	dir, err := ioutil.TempDir("", testpoint)
-	if err != nil {
-		t.Fatalf("could not create directory: %v", err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	f := gobuild(t, dir, prog, NoOpt)
+	defer f.Close()
 
 	d, err := f.DWARF()
 	if err != nil {
@@ -653,11 +635,7 @@ func main() {
     G = x
 }
 `
-	dir, err := ioutil.TempDir("", "TestInlinedRoutineRecords")
-	if err != nil {
-		t.Fatalf("could not create directory: %v", err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	// Note: this is a build with "-l=4", as opposed to "-l -N". The
 	// test is intended to verify DWARF that is only generated when
@@ -665,6 +643,7 @@ func main() {
 	// main.main, however, hence we build with "-gcflags=-l=4" as opposed
 	// to "-gcflags=all=-l=4".
 	f := gobuild(t, dir, prog, OptInl4)
+	defer f.Close()
 
 	d, err := f.DWARF()
 	if err != nil {
@@ -788,14 +767,11 @@ func main() {
 func abstractOriginSanity(t *testing.T, pkgDir string, flags string) {
 	t.Parallel()
 
-	dir, err := ioutil.TempDir("", "TestAbstractOriginSanity")
-	if err != nil {
-		t.Fatalf("could not create directory: %v", err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	// Build with inlining, to exercise DWARF inlining support.
 	f := gobuildTestdata(t, dir, filepath.Join(pkgDir, "main"), flags)
+	defer f.Close()
 
 	d, err := f.DWARF()
 	if err != nil {
@@ -973,13 +949,11 @@ func main() {
 	print(p)
 }
 `
-	dir, err := ioutil.TempDir("", "TestRuntimeType")
-	if err != nil {
-		t.Fatalf("could not create directory: %v", err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	f := gobuild(t, dir, prog, flags)
+	defer f.Close()
+
 	out, err := exec.Command(f.path).CombinedOutput()
 	if err != nil {
 		t.Fatalf("could not run test program: %v", err)
@@ -1043,11 +1017,7 @@ func TestIssue27614(t *testing.T) {
 
 	t.Parallel()
 
-	dir, err := ioutil.TempDir("", "go-build")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	const prog = `package main
 
@@ -1161,11 +1131,7 @@ func TestStaticTmp(t *testing.T) {
 
 	t.Parallel()
 
-	dir, err := ioutil.TempDir("", "go-build")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	const prog = `package main
 
@@ -1243,11 +1209,7 @@ func TestPackageNameAttr(t *testing.T) {
 
 	t.Parallel()
 
-	dir, err := ioutil.TempDir("", "go-build")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	const prog = "package main\nfunc main() {\nprintln(\"hello world\")\n}\n"
 
@@ -1307,14 +1269,10 @@ func TestMachoIssue32233(t *testing.T) {
 		t.Skip("skipping; test only interesting on darwin")
 	}
 
-	tmpdir, err := ioutil.TempDir("", "TestMachoIssue32233")
-	if err != nil {
-		t.Fatalf("could not create directory: %v", err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
-	wd, err2 := os.Getwd()
-	if err2 != nil {
+	wd, err := os.Getwd()
+	if err != nil {
 		t.Fatalf("where am I? %v", err)
 	}
 	pdir := filepath.Join(wd, "testdata", "issue32233", "main")
@@ -1328,11 +1286,7 @@ func TestWindowsIssue36495(t *testing.T) {
 		t.Skip("skipping: test only on windows")
 	}
 
-	dir, err := ioutil.TempDir("", "TestEmbeddedStructMarker")
-	if err != nil {
-		t.Fatalf("could not create directory: %v", err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	prog := `
 package main
@@ -1347,6 +1301,7 @@ func main() {
 	if err != nil {
 		t.Fatalf("error opening pe file: %v", err)
 	}
+	defer exe.Close()
 	dw, err := exe.DWARF()
 	if err != nil {
 		t.Fatalf("error parsing DWARF: %v", err)
@@ -1397,17 +1352,14 @@ func TestIssue38192(t *testing.T) {
 
 	// Build a test program that contains a translation unit whose
 	// text (from am assembly source) contains only a single instruction.
-	tmpdir, err := ioutil.TempDir("", "TestIssue38192")
-	if err != nil {
-		t.Fatalf("could not create directory: %v", err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 	wd, err := os.Getwd()
 	if err != nil {
 		t.Fatalf("where am I? %v", err)
 	}
 	pdir := filepath.Join(wd, "testdata", "issue38192")
 	f := gobuildTestdata(t, tmpdir, pdir, DefaultOpt)
+	defer f.Close()
 
 	// Open the resulting binary and examine the DWARF it contains.
 	// Look for the function of interest ("main.singleInstruction")
@@ -1520,17 +1472,15 @@ func TestIssue39757(t *testing.T) {
 	// compiler/runtime in ways that aren't happening now, so this
 	// might be something to check for if it does start failing.
 
-	tmpdir, err := ioutil.TempDir("", "TestIssue38192")
-	if err != nil {
-		t.Fatalf("could not create directory: %v", err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
+
 	wd, err := os.Getwd()
 	if err != nil {
 		t.Fatalf("where am I? %v", err)
 	}
 	pdir := filepath.Join(wd, "testdata", "issue39757")
 	f := gobuildTestdata(t, tmpdir, pdir, DefaultOpt)
+	defer f.Close()
 
 	syms, err := f.Symbols()
 	if err != nil {
diff --git a/src/cmd/link/internal/ld/elf_test.go b/src/cmd/link/internal/ld/elf_test.go
index 70e743fa65..d86ebb89e0 100644
--- a/src/cmd/link/internal/ld/elf_test.go
+++ b/src/cmd/link/internal/ld/elf_test.go
@@ -22,11 +22,7 @@ import (
 func TestDynSymShInfo(t *testing.T) {
 	t.Parallel()
 	testenv.MustHaveGoBuild(t)
-	dir, err := ioutil.TempDir("", "go-build-issue33358")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	const prog = `
 package main
@@ -52,6 +48,7 @@ func main() {
 	if err != nil {
 		t.Fatalf("failed to open built file: %v", err)
 	}
+	defer fi.Close()
 
 	elfFile, err := elf.NewFile(fi)
 	if err != nil {
@@ -96,11 +93,7 @@ func TestNoDuplicateNeededEntries(t *testing.T) {
 
 	t.Parallel()
 
-	dir, err := ioutil.TempDir("", "no-dup-needed")
-	if err != nil {
-		t.Fatalf("Failed to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	wd, err := os.Getwd()
 	if err != nil {
diff --git a/src/cmd/link/internal/ld/fallocate_test.go b/src/cmd/link/internal/ld/fallocate_test.go
index 56d2321826..1ed0eb2ca7 100644
--- a/src/cmd/link/internal/ld/fallocate_test.go
+++ b/src/cmd/link/internal/ld/fallocate_test.go
@@ -8,7 +8,6 @@
 package ld
 
 import (
-	"io/ioutil"
 	"os"
 	"path/filepath"
 	"syscall"
@@ -16,14 +15,10 @@ import (
 )
 
 func TestFallocate(t *testing.T) {
-	dir, err := ioutil.TempDir("", "TestFallocate")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 	filename := filepath.Join(dir, "a.out")
 	out := NewOutBuf(nil)
-	err = out.Open(filename)
+	err := out.Open(filename)
 	if err != nil {
 		t.Fatalf("Open file failed: %v", err)
 	}
diff --git a/src/cmd/link/internal/ld/go_test.go b/src/cmd/link/internal/ld/go_test.go
index 0197196023..230f85a0e5 100644
--- a/src/cmd/link/internal/ld/go_test.go
+++ b/src/cmd/link/internal/ld/go_test.go
@@ -8,7 +8,6 @@ import (
 	"cmd/internal/objabi"
 	"internal/testenv"
 	"io/ioutil"
-	"os"
 	"os/exec"
 	"path/filepath"
 	"reflect"
@@ -86,11 +85,7 @@ func TestDedupLibrariesOpenBSDLink(t *testing.T) {
 	testenv.MustHaveCGO(t)
 	t.Parallel()
 
-	dir, err := ioutil.TempDir("", "dedup-build")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	// cgo_import_dynamic both the unversioned libraries and pull in the
 	// net package to get a cgo package with a versioned library.
diff --git a/src/cmd/link/internal/ld/issue33808_test.go b/src/cmd/link/internal/ld/issue33808_test.go
index 92a47faa4a..43f4540a02 100644
--- a/src/cmd/link/internal/ld/issue33808_test.go
+++ b/src/cmd/link/internal/ld/issue33808_test.go
@@ -6,8 +6,6 @@ package ld
 
 import (
 	"internal/testenv"
-	"io/ioutil"
-	"os"
 	"runtime"
 	"strings"
 	"testing"
@@ -31,11 +29,7 @@ func TestIssue33808(t *testing.T) {
 	testenv.MustHaveCGO(t)
 	t.Parallel()
 
-	dir, err := ioutil.TempDir("", "TestIssue33808")
-	if err != nil {
-		t.Fatalf("could not create directory: %v", err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	f := gobuild(t, dir, prog, "-ldflags=-linkmode=external")
 	f.Close()
diff --git a/src/cmd/link/internal/ld/ld_test.go b/src/cmd/link/internal/ld/ld_test.go
index cdfaadb17d..836d9bff3d 100644
--- a/src/cmd/link/internal/ld/ld_test.go
+++ b/src/cmd/link/internal/ld/ld_test.go
@@ -9,7 +9,6 @@ import (
 	"fmt"
 	"internal/testenv"
 	"io/ioutil"
-	"os"
 	"os/exec"
 	"path/filepath"
 	"runtime"
@@ -25,11 +24,6 @@ func TestUndefinedRelocErrors(t *testing.T) {
 	testenv.MustInternalLink(t)
 
 	t.Parallel()
-	dir, err := ioutil.TempDir("", "go-build")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
 
 	out, err := exec.Command(testenv.GoToolPath(t), "build", "./testdata/issue10978").CombinedOutput()
 	if err == nil {
@@ -108,11 +102,7 @@ func TestArchiveBuildInvokeWithExec(t *testing.T) {
 	case "openbsd", "windows":
 		t.Skip("c-archive unsupported")
 	}
-	dir, err := ioutil.TempDir("", "go-build")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	srcfile := filepath.Join(dir, "test.go")
 	arfile := filepath.Join(dir, "test.a")
@@ -150,11 +140,7 @@ func TestPPC64LargeTextSectionSplitting(t *testing.T) {
 	testenv.MustHaveGoBuild(t)
 	testenv.MustHaveCGO(t)
 	t.Parallel()
-	dir, err := ioutil.TempDir("", "go-build")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	// NB: the use of -ldflags=-debugppc64textsize=1048576 tells the linker to
 	// split text sections at a size threshold of 1M instead of the
@@ -168,7 +154,7 @@ func TestPPC64LargeTextSectionSplitting(t *testing.T) {
 	}
 
 	// Result should be runnable.
-	_, err = exec.Command(exe, "version").CombinedOutput()
+	_, err := exec.Command(exe, "version").CombinedOutput()
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -194,11 +180,7 @@ func testWindowsBuildmodeCSharedASLR(t *testing.T, useASLR bool) {
 	t.Parallel()
 	testenv.MustHaveGoBuild(t)
 
-	dir, err := ioutil.TempDir("", "go-build")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	srcfile := filepath.Join(dir, "test.go")
 	objfile := filepath.Join(dir, "test.dll")
diff --git a/src/cmd/link/internal/ld/nooptcgolink_test.go b/src/cmd/link/internal/ld/nooptcgolink_test.go
index 4d2ff1acf2..73548dabd4 100644
--- a/src/cmd/link/internal/ld/nooptcgolink_test.go
+++ b/src/cmd/link/internal/ld/nooptcgolink_test.go
@@ -6,8 +6,6 @@ package ld
 
 import (
 	"internal/testenv"
-	"io/ioutil"
-	"os"
 	"os/exec"
 	"path/filepath"
 	"runtime"
@@ -22,11 +20,7 @@ func TestNooptCgoBuild(t *testing.T) {
 
 	testenv.MustHaveGoBuild(t)
 	testenv.MustHaveCGO(t)
-	dir, err := ioutil.TempDir("", "go-build")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 	cmd := exec.Command(testenv.GoToolPath(t), "build", "-gcflags=-N -l", "-o", filepath.Join(dir, "a.out"))
 	cmd.Dir = filepath.Join(runtime.GOROOT(), "src", "runtime", "testdata", "testprogcgo")
 	out, err := cmd.CombinedOutput()
diff --git a/src/cmd/link/internal/ld/outbuf_test.go b/src/cmd/link/internal/ld/outbuf_test.go
index e6643da396..a7b105f887 100644
--- a/src/cmd/link/internal/ld/outbuf_test.go
+++ b/src/cmd/link/internal/ld/outbuf_test.go
@@ -5,8 +5,6 @@
 package ld
 
 import (
-	"io/ioutil"
-	"os"
 	"path/filepath"
 	"runtime"
 	"testing"
@@ -19,11 +17,7 @@ func TestMMap(t *testing.T) {
 		t.Skip("unsupported OS")
 	case "aix", "darwin", "ios", "dragonfly", "freebsd", "linux", "netbsd", "openbsd", "windows":
 	}
-	dir, err := ioutil.TempDir("", "TestMMap")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 	filename := filepath.Join(dir, "foo.out")
 	ob := NewOutBuf(nil)
 	if err := ob.Open(filename); err != nil {
diff --git a/src/cmd/link/link_test.go b/src/cmd/link/link_test.go
index 9c69ccca43..9369e550f4 100644
--- a/src/cmd/link/link_test.go
+++ b/src/cmd/link/link_test.go
@@ -48,13 +48,9 @@ const X = "\n!\n"
 func main() {}
 `
 
-	tmpdir, err := ioutil.TempDir("", "issue21703")
-	if err != nil {
-		t.Fatalf("failed to create temp dir: %v\n", err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
-	err = ioutil.WriteFile(filepath.Join(tmpdir, "main.go"), []byte(source), 0666)
+	err := ioutil.WriteFile(filepath.Join(tmpdir, "main.go"), []byte(source), 0666)
 	if err != nil {
 		t.Fatalf("failed to write main.go: %v\n", err)
 	}
@@ -83,11 +79,7 @@ func TestIssue28429(t *testing.T) {
 
 	testenv.MustHaveGoBuild(t)
 
-	tmpdir, err := ioutil.TempDir("", "issue28429-")
-	if err != nil {
-		t.Fatalf("failed to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	write := func(name, content string) {
 		err := ioutil.WriteFile(filepath.Join(tmpdir, name), []byte(content), 0666)
@@ -126,11 +118,7 @@ func TestUnresolved(t *testing.T) {
 
 	t.Parallel()
 
-	tmpdir, err := ioutil.TempDir("", "unresolved-")
-	if err != nil {
-		t.Fatalf("failed to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	write := func(name, content string) {
 		err := ioutil.WriteFile(filepath.Join(tmpdir, name), []byte(content), 0666)
@@ -195,11 +183,7 @@ func TestIssue33979(t *testing.T) {
 
 	t.Parallel()
 
-	tmpdir, err := ioutil.TempDir("", "unresolved-")
-	if err != nil {
-		t.Fatalf("failed to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	write := func(name, content string) {
 		err := ioutil.WriteFile(filepath.Join(tmpdir, name), []byte(content), 0666)
@@ -300,11 +284,7 @@ func TestBuildForTvOS(t *testing.T) {
 		"-framework", "CoreFoundation",
 	}
 	lib := filepath.Join("testdata", "testBuildFortvOS", "lib.go")
-	tmpDir, err := ioutil.TempDir("", "go-link-TestBuildFortvOS")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpDir)
+	tmpDir := t.TempDir()
 
 	ar := filepath.Join(tmpDir, "lib.a")
 	cmd := exec.Command(testenv.GoToolPath(t), "build", "-buildmode=c-archive", "-o", ar, lib)
@@ -339,14 +319,10 @@ func TestXFlag(t *testing.T) {
 
 	t.Parallel()
 
-	tmpdir, err := ioutil.TempDir("", "TestXFlag")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	src := filepath.Join(tmpdir, "main.go")
-	err = ioutil.WriteFile(src, []byte(testXFlagSrc), 0666)
+	err := ioutil.WriteFile(src, []byte(testXFlagSrc), 0666)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -367,14 +343,10 @@ func TestMacOSVersion(t *testing.T) {
 
 	t.Parallel()
 
-	tmpdir, err := ioutil.TempDir("", "TestMacOSVersion")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	src := filepath.Join(tmpdir, "main.go")
-	err = ioutil.WriteFile(src, []byte(testMacOSVersionSrc), 0666)
+	err := ioutil.WriteFile(src, []byte(testMacOSVersionSrc), 0666)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -393,6 +365,7 @@ func TestMacOSVersion(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+	defer exef.Close()
 	exem, err := macho.NewFile(exef)
 	if err != nil {
 		t.Fatal(err)
@@ -446,14 +419,10 @@ func TestIssue34788Android386TLSSequence(t *testing.T) {
 
 	t.Parallel()
 
-	tmpdir, err := ioutil.TempDir("", "TestIssue34788Android386TLSSequence")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	src := filepath.Join(tmpdir, "blah.go")
-	err = ioutil.WriteFile(src, []byte(Issue34788src), 0666)
+	err := ioutil.WriteFile(src, []byte(Issue34788src), 0666)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -506,14 +475,10 @@ func TestStrictDup(t *testing.T) {
 
 	t.Parallel()
 
-	tmpdir, err := ioutil.TempDir("", "TestStrictDup")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	src := filepath.Join(tmpdir, "x.go")
-	err = ioutil.WriteFile(src, []byte(testStrictDupGoSrc), 0666)
+	err := ioutil.WriteFile(src, []byte(testStrictDupGoSrc), 0666)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -592,14 +557,10 @@ func TestFuncAlign(t *testing.T) {
 
 	t.Parallel()
 
-	tmpdir, err := ioutil.TempDir("", "TestFuncAlign")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	src := filepath.Join(tmpdir, "go.mod")
-	err = ioutil.WriteFile(src, []byte("module cmd/link/TestFuncAlign/falign"), 0666)
+	err := ioutil.WriteFile(src, []byte("module cmd/link/TestFuncAlign/falign"), 0666)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -665,14 +626,10 @@ func TestTrampoline(t *testing.T) {
 
 	t.Parallel()
 
-	tmpdir, err := ioutil.TempDir("", "TestTrampoline")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	src := filepath.Join(tmpdir, "hello.go")
-	err = ioutil.WriteFile(src, []byte(testTrampSrc), 0666)
+	err := ioutil.WriteFile(src, []byte(testTrampSrc), 0666)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -701,11 +658,7 @@ func TestIndexMismatch(t *testing.T) {
 
 	t.Parallel()
 
-	tmpdir, err := ioutil.TempDir("", "TestIndexMismatch")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	aSrc := filepath.Join("testdata", "testIndexMismatch", "a.go")
 	bSrc := filepath.Join("testdata", "testIndexMismatch", "b.go")
@@ -764,11 +717,7 @@ func TestPErsrcBinutils(t *testing.T) {
 
 	t.Parallel()
 
-	tmpdir, err := ioutil.TempDir("", "TestPErsrcBinutils")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	pkgdir := filepath.Join("testdata", "pe-binutils")
 	exe := filepath.Join(tmpdir, "a.exe")
@@ -800,11 +749,7 @@ func TestPErsrcLLVM(t *testing.T) {
 
 	t.Parallel()
 
-	tmpdir, err := ioutil.TempDir("", "TestPErsrcLLVM")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	pkgdir := filepath.Join("testdata", "pe-llvm")
 	exe := filepath.Join(tmpdir, "a.exe")
@@ -832,12 +777,6 @@ func TestContentAddressableSymbols(t *testing.T) {
 
 	t.Parallel()
 
-	tmpdir, err := ioutil.TempDir("", "TestContentAddressableSymbols")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
-
 	src := filepath.Join("testdata", "testHashedSyms", "p.go")
 	cmd := exec.Command(testenv.GoToolPath(t), "run", src)
 	out, err := cmd.CombinedOutput()
@@ -881,14 +820,10 @@ func TestIssue38554(t *testing.T) {
 
 	t.Parallel()
 
-	tmpdir, err := ioutil.TempDir("", "TestIssue38554")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	src := filepath.Join(tmpdir, "x.go")
-	err = ioutil.WriteFile(src, []byte(testIssue38554Src), 0666)
+	err := ioutil.WriteFile(src, []byte(testIssue38554Src), 0666)
 	if err != nil {
 		t.Fatalf("failed to write source file: %v", err)
 	}
@@ -935,14 +870,10 @@ func TestIssue42396(t *testing.T) {
 
 	t.Parallel()
 
-	tmpdir, err := ioutil.TempDir("", "TestIssue42396")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	src := filepath.Join(tmpdir, "main.go")
-	err = ioutil.WriteFile(src, []byte(testIssue42396src), 0666)
+	err := ioutil.WriteFile(src, []byte(testIssue42396src), 0666)
 	if err != nil {
 		t.Fatalf("failed to write source file: %v", err)
 	}
@@ -992,14 +923,10 @@ func TestLargeReloc(t *testing.T) {
 	testenv.MustHaveGoBuild(t)
 	t.Parallel()
 
-	tmpdir, err := ioutil.TempDir("", "TestIssue42396")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	src := filepath.Join(tmpdir, "x.go")
-	err = ioutil.WriteFile(src, []byte(testLargeRelocSrc), 0666)
+	err := ioutil.WriteFile(src, []byte(testLargeRelocSrc), 0666)
 	if err != nil {
 		t.Fatalf("failed to write source file: %v", err)
 	}
diff --git a/src/cmd/link/linkbig_test.go b/src/cmd/link/linkbig_test.go
index 78d2bc1afe..d5d77d6c72 100644
--- a/src/cmd/link/linkbig_test.go
+++ b/src/cmd/link/linkbig_test.go
@@ -27,12 +27,7 @@ func TestLargeText(t *testing.T) {
 
 	var w bytes.Buffer
 	const FN = 4
-	tmpdir, err := ioutil.TempDir("", "bigtext")
-	if err != nil {
-		t.Fatalf("can't create temp directory: %v\n", err)
-	}
-
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	// Generate the scenario where the total amount of text exceeds the
 	// limit for the jmp/call instruction, on RISC architectures like ppc64le,
@@ -79,7 +74,7 @@ func TestLargeText(t *testing.T) {
 	fmt.Fprintf(&w, "\t}\n")
 	fmt.Fprintf(&w, "\tfmt.Printf(\"PASS\\n\")\n")
 	fmt.Fprintf(&w, "}")
-	err = ioutil.WriteFile(tmpdir+"/bigfn.go", w.Bytes(), 0666)
+	err := ioutil.WriteFile(tmpdir+"/bigfn.go", w.Bytes(), 0666)
 	if err != nil {
 		t.Fatalf("can't write output: %v\n", err)
 	}
-- 
GitLab


From a08adda12c2af7f597dad9d280282c7e70d4a2dc Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Wed, 3 Mar 2021 08:04:40 -0800
Subject: [PATCH 0980/2400] os/signal: remove comments about SA_RESTART

It's no longer necessary for non-Go signal handlers to use SA_RESTART.

For #20400
Fixes #44761

Change-Id: Ie3c7fecc631a4a2822331754296ea09b308e1391
Reviewed-on: https://go-review.googlesource.com/c/go/+/298269
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/os/signal/doc.go | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/os/signal/doc.go b/src/os/signal/doc.go
index 2229d36954..a210795849 100644
--- a/src/os/signal/doc.go
+++ b/src/os/signal/doc.go
@@ -129,9 +129,7 @@ If the non-Go code installs any signal handlers, it must use the
 SA_ONSTACK flag with sigaction. Failing to do so is likely to cause
 the program to crash if the signal is received. Go programs routinely
 run with a limited stack, and therefore set up an alternate signal
-stack. Also, the Go standard library expects that any signal handlers
-will use the SA_RESTART flag. Failing to do so may cause some library
-calls to return "interrupted system call" errors.
+stack.
 
 If the non-Go code installs a signal handler for any of the
 synchronous signals (SIGBUS, SIGFPE, SIGSEGV), then it should record
-- 
GitLab


From b6def6a34e049d5d2cc9225d991c4b84427467ec Mon Sep 17 00:00:00 2001
From: Emmanuel T Odeke <emmanuel@orijtech.com>
Date: Sat, 6 Mar 2021 23:57:33 -0800
Subject: [PATCH 0981/2400] cmd/vet: bring in sigchanyzer to report unbuffered
 channels to signal.Notify

Brings in the static analyzer "sigchanyzer", that we created at
Orijtech, Inc, and already submitted in CL 274352, as

    golang.org/x/tools/go/analysis/passes/sigchanyzer

and add it to cmd/vet as one of the passes.

Fixes #9399

Change-Id: I83708b8ea5ca8ede5ee31efab55cbce7419434ab
Reviewed-on: https://go-review.googlesource.com/c/go/+/299532
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Trust: Bryan C. Mills <bcmills@google.com>
---
 .../passes/sigchanyzer/sigchanyzer.go         | 129 ++++++++++++++++++
 src/cmd/vendor/modules.txt                    |   1 +
 src/cmd/vet/main.go                           |   2 +
 3 files changed, 132 insertions(+)
 create mode 100644 src/cmd/vendor/golang.org/x/tools/go/analysis/passes/sigchanyzer/sigchanyzer.go

diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/sigchanyzer/sigchanyzer.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/sigchanyzer/sigchanyzer.go
new file mode 100644
index 0000000000..3d89061d17
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/sigchanyzer/sigchanyzer.go
@@ -0,0 +1,129 @@
+// Copyright 2020 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 sigchanyzer defines an Analyzer that detects
+// misuse of unbuffered signal as argument to signal.Notify.
+package sigchanyzer
+
+import (
+	"bytes"
+	"go/ast"
+	"go/format"
+	"go/token"
+	"go/types"
+
+	"golang.org/x/tools/go/analysis"
+	"golang.org/x/tools/go/analysis/passes/inspect"
+	"golang.org/x/tools/go/ast/inspector"
+)
+
+const Doc = `check for unbuffered channel of os.Signal
+
+This checker reports call expression of the form signal.Notify(c <-chan os.Signal, sig ...os.Signal),
+where c is an unbuffered channel, which can be at risk of missing the signal.`
+
+// Analyzer describes sigchanyzer analysis function detector.
+var Analyzer = &analysis.Analyzer{
+	Name:     "sigchanyzer",
+	Doc:      Doc,
+	Requires: []*analysis.Analyzer{inspect.Analyzer},
+	Run:      run,
+}
+
+func run(pass *analysis.Pass) (interface{}, error) {
+	inspect := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector)
+
+	nodeFilter := []ast.Node{
+		(*ast.CallExpr)(nil),
+	}
+	inspect.Preorder(nodeFilter, func(n ast.Node) {
+		call := n.(*ast.CallExpr)
+		if !isSignalNotify(pass.TypesInfo, call) {
+			return
+		}
+		var chanDecl *ast.CallExpr
+		switch arg := call.Args[0].(type) {
+		case *ast.Ident:
+			if decl, ok := findDecl(arg).(*ast.CallExpr); ok {
+				chanDecl = decl
+			}
+		case *ast.CallExpr:
+			chanDecl = arg
+		}
+		if chanDecl == nil || len(chanDecl.Args) != 1 {
+			return
+		}
+		chanDecl.Args = append(chanDecl.Args, &ast.BasicLit{
+			Kind:  token.INT,
+			Value: "1",
+		})
+		var buf bytes.Buffer
+		if err := format.Node(&buf, token.NewFileSet(), chanDecl); err != nil {
+			return
+		}
+		pass.Report(analysis.Diagnostic{
+			Pos:     call.Pos(),
+			End:     call.End(),
+			Message: "misuse of unbuffered os.Signal channel as argument to signal.Notify",
+			SuggestedFixes: []analysis.SuggestedFix{{
+				Message: "Change to buffer channel",
+				TextEdits: []analysis.TextEdit{{
+					Pos:     chanDecl.Pos(),
+					End:     chanDecl.End(),
+					NewText: buf.Bytes(),
+				}},
+			}},
+		})
+	})
+	return nil, nil
+}
+
+func isSignalNotify(info *types.Info, call *ast.CallExpr) bool {
+	check := func(id *ast.Ident) bool {
+		obj := info.ObjectOf(id)
+		return obj.Name() == "Notify" && obj.Pkg().Path() == "os/signal"
+	}
+	switch fun := call.Fun.(type) {
+	case *ast.SelectorExpr:
+		return check(fun.Sel)
+	case *ast.Ident:
+		if fun, ok := findDecl(fun).(*ast.SelectorExpr); ok {
+			return check(fun.Sel)
+		}
+		return false
+	default:
+		return false
+	}
+}
+
+func findDecl(arg *ast.Ident) ast.Node {
+	if arg.Obj == nil {
+		return nil
+	}
+	switch as := arg.Obj.Decl.(type) {
+	case *ast.AssignStmt:
+		if len(as.Lhs) != len(as.Rhs) {
+			return nil
+		}
+		for i, lhs := range as.Lhs {
+			lid, ok := lhs.(*ast.Ident)
+			if !ok {
+				continue
+			}
+			if lid.Obj == arg.Obj {
+				return as.Rhs[i]
+			}
+		}
+	case *ast.ValueSpec:
+		if len(as.Names) != len(as.Values) {
+			return nil
+		}
+		for i, name := range as.Names {
+			if name.Obj == arg.Obj {
+				return as.Values[i]
+			}
+		}
+	}
+	return nil
+}
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index e4dfd32315..b1a2c67581 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -69,6 +69,7 @@ golang.org/x/tools/go/analysis/passes/lostcancel
 golang.org/x/tools/go/analysis/passes/nilfunc
 golang.org/x/tools/go/analysis/passes/printf
 golang.org/x/tools/go/analysis/passes/shift
+golang.org/x/tools/go/analysis/passes/sigchanyzer
 golang.org/x/tools/go/analysis/passes/stdmethods
 golang.org/x/tools/go/analysis/passes/stringintconv
 golang.org/x/tools/go/analysis/passes/structtag
diff --git a/src/cmd/vet/main.go b/src/cmd/vet/main.go
index d50c45d691..a33bba2466 100644
--- a/src/cmd/vet/main.go
+++ b/src/cmd/vet/main.go
@@ -22,6 +22,7 @@ import (
 	"golang.org/x/tools/go/analysis/passes/nilfunc"
 	"golang.org/x/tools/go/analysis/passes/printf"
 	"golang.org/x/tools/go/analysis/passes/shift"
+	"golang.org/x/tools/go/analysis/passes/sigchanyzer"
 	"golang.org/x/tools/go/analysis/passes/stdmethods"
 	"golang.org/x/tools/go/analysis/passes/stringintconv"
 	"golang.org/x/tools/go/analysis/passes/structtag"
@@ -54,6 +55,7 @@ func main() {
 		nilfunc.Analyzer,
 		printf.Analyzer,
 		shift.Analyzer,
+		sigchanyzer.Analyzer,
 		stdmethods.Analyzer,
 		stringintconv.Analyzer,
 		structtag.Analyzer,
-- 
GitLab


From 618b66e16d5adedbeccb7e7ed35b26e439a9f86f Mon Sep 17 00:00:00 2001
From: eric fang <eric.fang@arm.com>
Date: Tue, 2 Mar 2021 06:02:55 +0000
Subject: [PATCH 0982/2400] cmd/compile: remove 4-byte alignment requirement of
 stack slot on arm

This CL applies CL 267999 to arm.

Updates #42385

Change-Id: Iad82aafcb7b0a5a77a4bea32f648320f57a17cdd
Reviewed-on: https://go-review.googlesource.com/c/go/+/297773
Reviewed-by: eric fang <eric.fang@arm.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: eric fang <eric.fang@arm.com>
Run-TryBot: eric fang <eric.fang@arm.com>
---
 src/cmd/compile/internal/ssagen/pgen.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ssagen/pgen.go b/src/cmd/compile/internal/ssagen/pgen.go
index d12e12947e..c2225ce950 100644
--- a/src/cmd/compile/internal/ssagen/pgen.go
+++ b/src/cmd/compile/internal/ssagen/pgen.go
@@ -133,7 +133,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 		} else {
 			lastHasPtr = false
 		}
-		if Arch.LinkArch.InFamily(sys.ARM, sys.PPC64) {
+		if Arch.LinkArch.InFamily(sys.PPC64) {
 			s.stksize = types.Rnd(s.stksize, int64(types.PtrSize))
 		}
 		n.SetFrameOffset(-s.stksize)
-- 
GitLab


From 437d229e2ac4cda4265090375b94d74ca218a846 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Tue, 2 Mar 2021 09:10:49 +0100
Subject: [PATCH 0983/2400] runtime: document netpollclose

Document that network poller implementations need to define
netpollclose.

Change-Id: Idc73dea7cfd503d4de7e1d95902f0f102cf5ed8f
Reviewed-on: https://go-review.googlesource.com/c/go/+/297809
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/runtime/netpoll.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/runtime/netpoll.go b/src/runtime/netpoll.go
index 202aef593f..6c26fdbbeb 100644
--- a/src/runtime/netpoll.go
+++ b/src/runtime/netpoll.go
@@ -23,6 +23,9 @@ import (
 //     Arm edge-triggered notifications for fd. The pd argument is to pass
 //     back to netpollready when fd is ready. Return an errno value.
 //
+// func netpollclose(fd uintptr) int32
+//     Disable notifications for fd. Return an errno value.
+//
 // func netpoll(delta int64) gList
 //     Poll the network. If delta < 0, block indefinitely. If delta == 0,
 //     poll without blocking. If delta > 0, block for up to delta nanoseconds.
-- 
GitLab


From b70a2bc9c612de35b765712bd689865f6a1716b6 Mon Sep 17 00:00:00 2001
From: Alberto Donizetti <alb.donizetti@gmail.com>
Date: Fri, 5 Mar 2021 11:22:13 +0100
Subject: [PATCH 0984/2400] cmd/compile: make ValAndOff.{Val,Off} return an
 int32

The ValAndOff type is a 64bit integer holding a 32bit value and a
32bit offset in each half, but for historical reasons its Val and Off
methods returned an int64. This was convenient when AuxInt was always
an int64, but now that AuxInts are typed we can return int32 from Val
and Off and get rid of a several casts and now unnecessary range
checks.

This change:

- changes the Val and Off methods to return an int32 (from int64);
- adds Val64 and Off64 methods for convenience in the few remaining
  places (in the ssa.go files) where Val and Off are stored in int64
  fields;
- deletes makeValAndOff64, renames makeValAndOff32 to makeValAndOff
- deletes a few ValAndOff methods that are now unused;
- removes several validOff/validValAndOff check that will always
  return true.

Passes:

  GOARCH=amd64 gotip build -toolexec 'toolstash -cmp' -a std
  GOARCH=386 gotip build -toolexec 'toolstash -cmp' -a std
  GOARCH=s390x gotip build -toolexec 'toolstash -cmp' -a std

(the three GOARCHs with SSA rules files impacted by the change).

Change-Id: I2abbbf42188c798631b94d3a55ca44256f140be7
Reviewed-on: https://go-review.googlesource.com/c/go/+/299149
Trust: Alberto Donizetti <alb.donizetti@gmail.com>
Trust: Keith Randall <khr@golang.org>
Run-TryBot: Alberto Donizetti <alb.donizetti@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/amd64/ssa.go         |  22 +-
 src/cmd/compile/internal/s390x/ssa.go         |  14 +-
 src/cmd/compile/internal/ssa/gen/386.rules    |  75 ++--
 .../internal/ssa/gen/386splitload.rules       |   6 +-
 src/cmd/compile/internal/ssa/gen/AMD64.rules  |  95 +++--
 .../internal/ssa/gen/AMD64splitload.rules     |  32 +-
 src/cmd/compile/internal/ssa/gen/S390X.rules  |  40 +--
 src/cmd/compile/internal/ssa/op.go            |  42 +--
 src/cmd/compile/internal/ssa/rewrite386.go    | 184 +++++-----
 .../internal/ssa/rewrite386splitload.go       |  14 +-
 src/cmd/compile/internal/ssa/rewriteAMD64.go  | 330 +++++++++---------
 .../internal/ssa/rewriteAMD64splitload.go     | 100 +++---
 src/cmd/compile/internal/ssa/rewriteS390X.go  |  96 ++---
 src/cmd/compile/internal/x86/ssa.go           |  20 +-
 14 files changed, 504 insertions(+), 566 deletions(-)

diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index 60baa4270f..af398c814a 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -682,9 +682,9 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		ssagen.AddAux2(&p.From, v, sc.Off())
+		ssagen.AddAux2(&p.From, v, sc.Off64())
 		p.To.Type = obj.TYPE_CONST
-		p.To.Offset = sc.Val()
+		p.To.Offset = sc.Val64()
 	case ssa.OpAMD64CMPQloadidx8, ssa.OpAMD64CMPQloadidx1, ssa.OpAMD64CMPLloadidx4, ssa.OpAMD64CMPLloadidx1, ssa.OpAMD64CMPWloadidx2, ssa.OpAMD64CMPWloadidx1, ssa.OpAMD64CMPBloadidx1:
 		p := s.Prog(v.Op.Asm())
 		memIdx(&p.From, v)
@@ -695,9 +695,9 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		sc := v.AuxValAndOff()
 		p := s.Prog(v.Op.Asm())
 		memIdx(&p.From, v)
-		ssagen.AddAux2(&p.From, v, sc.Off())
+		ssagen.AddAux2(&p.From, v, sc.Off64())
 		p.To.Type = obj.TYPE_CONST
-		p.To.Offset = sc.Val()
+		p.To.Offset = sc.Val64()
 	case ssa.OpAMD64MOVLconst, ssa.OpAMD64MOVQconst:
 		x := v.Reg()
 
@@ -769,7 +769,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssagen.AddAux(&p.To, v)
 	case ssa.OpAMD64ADDQconstmodify, ssa.OpAMD64ADDLconstmodify:
 		sc := v.AuxValAndOff()
-		off := sc.Off()
+		off := sc.Off64()
 		val := sc.Val()
 		if val == 1 || val == -1 {
 			var asm obj.As
@@ -797,8 +797,8 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssa.OpAMD64BTCQconstmodify, ssa.OpAMD64BTCLconstmodify, ssa.OpAMD64BTSQconstmodify, ssa.OpAMD64BTSLconstmodify,
 		ssa.OpAMD64BTRQconstmodify, ssa.OpAMD64BTRLconstmodify, ssa.OpAMD64XORQconstmodify, ssa.OpAMD64XORLconstmodify:
 		sc := v.AuxValAndOff()
-		off := sc.Off()
-		val := sc.Val()
+		off := sc.Off64()
+		val := sc.Val64()
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_CONST
 		p.From.Offset = val
@@ -810,10 +810,10 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_CONST
 		sc := v.AuxValAndOff()
-		p.From.Offset = sc.Val()
+		p.From.Offset = sc.Val64()
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		ssagen.AddAux2(&p.To, v, sc.Off())
+		ssagen.AddAux2(&p.To, v, sc.Off64())
 	case ssa.OpAMD64MOVOstorezero:
 		if s.ABI != obj.ABIInternal {
 			v.Fatalf("MOVOstorezero can be only used in ABIInternal functions")
@@ -836,7 +836,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_CONST
 		sc := v.AuxValAndOff()
-		p.From.Offset = sc.Val()
+		p.From.Offset = sc.Val64()
 		switch {
 		case p.As == x86.AADDQ && p.From.Offset == 1:
 			p.As = x86.AINCQ
@@ -852,7 +852,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 			p.From.Type = obj.TYPE_NONE
 		}
 		memIdx(&p.To, v)
-		ssagen.AddAux2(&p.To, v, sc.Off())
+		ssagen.AddAux2(&p.To, v, sc.Off64())
 	case ssa.OpAMD64MOVLQSX, ssa.OpAMD64MOVWQSX, ssa.OpAMD64MOVBQSX, ssa.OpAMD64MOVLQZX, ssa.OpAMD64MOVWQZX, ssa.OpAMD64MOVBQZX,
 		ssa.OpAMD64CVTTSS2SL, ssa.OpAMD64CVTTSD2SL, ssa.OpAMD64CVTTSS2SQ, ssa.OpAMD64CVTTSD2SQ,
 		ssa.OpAMD64CVTSS2SD, ssa.OpAMD64CVTSD2SS:
diff --git a/src/cmd/compile/internal/s390x/ssa.go b/src/cmd/compile/internal/s390x/ssa.go
index ca6720bb33..7646be6147 100644
--- a/src/cmd/compile/internal/s390x/ssa.go
+++ b/src/cmd/compile/internal/s390x/ssa.go
@@ -480,10 +480,10 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_CONST
 		sc := v.AuxValAndOff()
-		p.From.Offset = sc.Val()
+		p.From.Offset = sc.Val64()
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		ssagen.AddAux2(&p.To, v, sc.Off())
+		ssagen.AddAux2(&p.To, v, sc.Off64())
 	case ssa.OpS390XMOVBreg, ssa.OpS390XMOVHreg, ssa.OpS390XMOVWreg,
 		ssa.OpS390XMOVBZreg, ssa.OpS390XMOVHZreg, ssa.OpS390XMOVWZreg,
 		ssa.OpS390XLDGR, ssa.OpS390XLGDR,
@@ -499,10 +499,10 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_CONST
 		sc := v.AuxValAndOff()
-		p.From.Offset = sc.Val()
+		p.From.Offset = sc.Val64()
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		ssagen.AddAux2(&p.To, v, sc.Off())
+		ssagen.AddAux2(&p.To, v, sc.Off64())
 	case ssa.OpCopy:
 		if v.Type.IsMemory() {
 			return
@@ -618,15 +618,15 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		vo := v.AuxValAndOff()
 		p := s.Prog(s390x.AMVC)
 		p.From.Type = obj.TYPE_CONST
-		p.From.Offset = vo.Val()
+		p.From.Offset = vo.Val64()
 		p.SetFrom3(obj.Addr{
 			Type:   obj.TYPE_MEM,
 			Reg:    v.Args[1].Reg(),
-			Offset: vo.Off(),
+			Offset: vo.Off64(),
 		})
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		p.To.Offset = vo.Off()
+		p.To.Offset = vo.Off64()
 	case ssa.OpS390XSTMG2, ssa.OpS390XSTMG3, ssa.OpS390XSTMG4,
 		ssa.OpS390XSTM2, ssa.OpS390XSTM3, ssa.OpS390XSTM4:
 		for i := 2; i < len(v.Args)-1; i++ {
diff --git a/src/cmd/compile/internal/ssa/gen/386.rules b/src/cmd/compile/internal/ssa/gen/386.rules
index d6d122dc78..199b73c42f 100644
--- a/src/cmd/compile/internal/ssa/gen/386.rules
+++ b/src/cmd/compile/internal/ssa/gen/386.rules
@@ -258,17 +258,17 @@
 (Zero [4] destptr mem) => (MOVLstoreconst [0] destptr mem)
 
 (Zero [3] destptr mem) =>
-	(MOVBstoreconst [makeValAndOff32(0,2)] destptr
-		(MOVWstoreconst [makeValAndOff32(0,0)] destptr mem))
+	(MOVBstoreconst [makeValAndOff(0,2)] destptr
+		(MOVWstoreconst [makeValAndOff(0,0)] destptr mem))
 (Zero [5] destptr mem) =>
-	(MOVBstoreconst [makeValAndOff32(0,4)] destptr
-		(MOVLstoreconst [makeValAndOff32(0,0)] destptr mem))
+	(MOVBstoreconst [makeValAndOff(0,4)] destptr
+		(MOVLstoreconst [makeValAndOff(0,0)] destptr mem))
 (Zero [6] destptr mem) =>
-	(MOVWstoreconst [makeValAndOff32(0,4)] destptr
-		(MOVLstoreconst [makeValAndOff32(0,0)] destptr mem))
+	(MOVWstoreconst [makeValAndOff(0,4)] destptr
+		(MOVLstoreconst [makeValAndOff(0,0)] destptr mem))
 (Zero [7] destptr mem) =>
-	(MOVLstoreconst [makeValAndOff32(0,3)] destptr
-		(MOVLstoreconst [makeValAndOff32(0,0)] destptr mem))
+	(MOVLstoreconst [makeValAndOff(0,3)] destptr
+		(MOVLstoreconst [makeValAndOff(0,0)] destptr mem))
 
 // Strip off any fractional word zeroing.
 (Zero [s] destptr mem) && s%4 != 0 && s > 4 =>
@@ -277,17 +277,17 @@
 
 // Zero small numbers of words directly.
 (Zero [8] destptr mem) =>
-	(MOVLstoreconst [makeValAndOff32(0,4)] destptr
-		(MOVLstoreconst [makeValAndOff32(0,0)] destptr mem))
+	(MOVLstoreconst [makeValAndOff(0,4)] destptr
+		(MOVLstoreconst [makeValAndOff(0,0)] destptr mem))
 (Zero [12] destptr mem) =>
-	(MOVLstoreconst [makeValAndOff32(0,8)] destptr
-		(MOVLstoreconst [makeValAndOff32(0,4)] destptr
-			(MOVLstoreconst [makeValAndOff32(0,0)] destptr mem)))
+	(MOVLstoreconst [makeValAndOff(0,8)] destptr
+		(MOVLstoreconst [makeValAndOff(0,4)] destptr
+			(MOVLstoreconst [makeValAndOff(0,0)] destptr mem)))
 (Zero [16] destptr mem) =>
-	(MOVLstoreconst [makeValAndOff32(0,12)] destptr
-		(MOVLstoreconst [makeValAndOff32(0,8)] destptr
-			(MOVLstoreconst [makeValAndOff32(0,4)] destptr
-				(MOVLstoreconst [makeValAndOff32(0,0)] destptr mem))))
+	(MOVLstoreconst [makeValAndOff(0,12)] destptr
+		(MOVLstoreconst [makeValAndOff(0,8)] destptr
+			(MOVLstoreconst [makeValAndOff(0,4)] destptr
+				(MOVLstoreconst [makeValAndOff(0,0)] destptr mem))))
 
 // Medium zeroing uses a duff device.
 (Zero [s] destptr mem)
@@ -621,12 +621,12 @@
 	((ADD|AND|OR|XOR)Lconstmodify [valoff1.addOffset32(off2)] {sym} base mem)
 
 // Fold constants into stores.
-(MOVLstore [off] {sym} ptr (MOVLconst [c]) mem) && validOff(int64(off)) =>
-	(MOVLstoreconst [makeValAndOff32(c,off)] {sym} ptr mem)
-(MOVWstore [off] {sym} ptr (MOVLconst [c]) mem) && validOff(int64(off)) =>
-	(MOVWstoreconst [makeValAndOff32(c,off)] {sym} ptr mem)
-(MOVBstore [off] {sym} ptr (MOVLconst [c]) mem) && validOff(int64(off)) =>
-	(MOVBstoreconst [makeValAndOff32(c,off)] {sym} ptr mem)
+(MOVLstore [off] {sym} ptr (MOVLconst [c]) mem) =>
+	(MOVLstoreconst [makeValAndOff(c,off)] {sym} ptr mem)
+(MOVWstore [off] {sym} ptr (MOVLconst [c]) mem) =>
+	(MOVWstoreconst [makeValAndOff(c,off)] {sym} ptr mem)
+(MOVBstore [off] {sym} ptr (MOVLconst [c]) mem) =>
+	(MOVBstoreconst [makeValAndOff(c,off)] {sym} ptr mem)
 
 // Fold address offsets into constant stores.
 (MOV(L|W|B)storeconst [sc] {s} (ADDLconst [off] ptr) mem) && sc.canAdd32(off) =>
@@ -676,8 +676,8 @@
 (MOVLstore {sym} [off] ptr y:((ADD|SUB|AND|OR|XOR)L l:(MOVLload [off] {sym} ptr mem) x) mem) && y.Uses==1 && l.Uses==1 && clobber(y, l) =>
 	((ADD|SUB|AND|OR|XOR)Lmodify [off] {sym} ptr x mem)
 (MOVLstore {sym} [off] ptr y:((ADD|AND|OR|XOR)Lconst [c] l:(MOVLload [off] {sym} ptr mem)) mem)
-	&& y.Uses==1 && l.Uses==1 && clobber(y, l) && validValAndOff(int64(c),int64(off)) =>
-	((ADD|AND|OR|XOR)Lconstmodify [makeValAndOff32(c,off)] {sym} ptr mem)
+	&& y.Uses==1 && l.Uses==1 && clobber(y, l) =>
+	((ADD|AND|OR|XOR)Lconstmodify [makeValAndOff(c,off)] {sym} ptr mem)
 
 // fold LEALs together
 (LEAL [off1] {sym1} (LEAL [off2] {sym2} x)) && is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) =>
@@ -995,49 +995,49 @@
   && x.Uses == 1
   && a.Off() + 1 == c.Off()
   && clobber(x)
-  => (MOVWstoreconst [makeValAndOff32(int32(a.Val()&0xff | c.Val()<<8), a.Off32())] {s} p mem)
+  => (MOVWstoreconst [makeValAndOff(a.Val()&0xff | c.Val()<<8, a.Off())] {s} p mem)
 (MOVBstoreconst [a] {s} p x:(MOVBstoreconst [c] {s} p mem))
   && x.Uses == 1
   && a.Off() + 1 == c.Off()
   && clobber(x)
-  => (MOVWstoreconst [makeValAndOff32(int32(a.Val()&0xff | c.Val()<<8), a.Off32())] {s} p mem)
+  => (MOVWstoreconst [makeValAndOff(a.Val()&0xff | c.Val()<<8, a.Off())] {s} p mem)
 
 (MOVBstoreconst [c] {s} p1 x:(MOVBstoreconst [a] {s} p0 mem))
   && x.Uses == 1
   && a.Off() == c.Off()
   && sequentialAddresses(p0, p1, 1)
   && clobber(x)
-  => (MOVWstoreconst [makeValAndOff32(int32(a.Val()&0xff | c.Val()<<8), a.Off32())] {s} p0 mem)
+  => (MOVWstoreconst [makeValAndOff(a.Val()&0xff | c.Val()<<8, a.Off())] {s} p0 mem)
 (MOVBstoreconst [a] {s} p0 x:(MOVBstoreconst [c] {s} p1 mem))
   && x.Uses == 1
   && a.Off() == c.Off()
   && sequentialAddresses(p0, p1, 1)
   && clobber(x)
-  => (MOVWstoreconst [makeValAndOff32(int32(a.Val()&0xff | c.Val()<<8), a.Off32())] {s} p0 mem)
+  => (MOVWstoreconst [makeValAndOff(a.Val()&0xff | c.Val()<<8, a.Off())] {s} p0 mem)
 
 (MOVWstoreconst [c] {s} p x:(MOVWstoreconst [a] {s} p mem))
   && x.Uses == 1
   && a.Off() + 2 == c.Off()
   && clobber(x)
-  => (MOVLstoreconst [makeValAndOff32(int32(a.Val()&0xffff | c.Val()<<16), a.Off32())] {s} p mem)
+  => (MOVLstoreconst [makeValAndOff(a.Val()&0xffff | c.Val()<<16, a.Off())] {s} p mem)
 (MOVWstoreconst [a] {s} p x:(MOVWstoreconst [c] {s} p mem))
   && x.Uses == 1
   && ValAndOff(a).Off() + 2 == ValAndOff(c).Off()
   && clobber(x)
-  => (MOVLstoreconst [makeValAndOff32(int32(a.Val()&0xffff | c.Val()<<16), a.Off32())] {s} p mem)
+  => (MOVLstoreconst [makeValAndOff(a.Val()&0xffff | c.Val()<<16, a.Off())] {s} p mem)
 
 (MOVWstoreconst [c] {s} p1 x:(MOVWstoreconst [a] {s} p0 mem))
   && x.Uses == 1
   && a.Off() == c.Off()
   && sequentialAddresses(p0, p1, 2)
   && clobber(x)
-  => (MOVLstoreconst [makeValAndOff32(int32(a.Val()&0xffff | c.Val()<<16), a.Off32())] {s} p0 mem)
+  => (MOVLstoreconst [makeValAndOff(a.Val()&0xffff | c.Val()<<16, a.Off())] {s} p0 mem)
 (MOVWstoreconst [a] {s} p0 x:(MOVWstoreconst [c] {s} p1 mem))
   && x.Uses == 1
   && a.Off() == c.Off()
   && sequentialAddresses(p0, p1, 2)
   && clobber(x)
-  => (MOVLstoreconst [makeValAndOff32(int32(a.Val()&0xffff | c.Val()<<16), a.Off32())] {s} p0 mem)
+  => (MOVLstoreconst [makeValAndOff(a.Val()&0xffff | c.Val()<<16, a.Off())] {s} p0 mem)
 
 // Combine stores into larger (unaligned) stores.
 (MOVBstore [i] {s} p (SHR(W|L)const [8] w) x:(MOVBstore [i-1] {s} p w mem))
@@ -1099,13 +1099,12 @@
 
 (CMP(L|W|B)const l:(MOV(L|W|B)load {sym} [off] ptr mem) [c])
 	&& l.Uses == 1
-	&& validValAndOff(int64(c), int64(off))
 	&& clobber(l) =>
-  @l.Block (CMP(L|W|B)constload {sym} [makeValAndOff32(int32(c),int32(off))] ptr mem)
+  @l.Block (CMP(L|W|B)constload {sym} [makeValAndOff(int32(c),off)] ptr mem)
 
-(CMPLload {sym} [off] ptr (MOVLconst [c]) mem) && validValAndOff(int64(c),int64(off)) => (CMPLconstload {sym} [makeValAndOff32(c,off)] ptr mem)
-(CMPWload {sym} [off] ptr (MOVLconst [c]) mem) && validValAndOff(int64(int16(c)),int64(off)) => (CMPWconstload {sym} [makeValAndOff32(int32(int16(c)),off)] ptr mem)
-(CMPBload {sym} [off] ptr (MOVLconst [c]) mem) && validValAndOff(int64(int8(c)),int64(off)) => (CMPBconstload {sym} [makeValAndOff32(int32(int8(c)),off)] ptr mem)
+(CMPLload {sym} [off] ptr (MOVLconst [c]) mem) => (CMPLconstload {sym} [makeValAndOff(c,off)] ptr mem)
+(CMPWload {sym} [off] ptr (MOVLconst [c]) mem) => (CMPWconstload {sym} [makeValAndOff(int32(int16(c)),off)] ptr mem)
+(CMPBload {sym} [off] ptr (MOVLconst [c]) mem) => (CMPBconstload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
 
 (MOVBload [off] {sym} (SB) _) && symIsRO(sym) => (MOVLconst [int32(read8(sym, int64(off)))])
 (MOVWload [off] {sym} (SB) _) && symIsRO(sym) => (MOVLconst [int32(read16(sym, int64(off), config.ctxt.Arch.ByteOrder))])
diff --git a/src/cmd/compile/internal/ssa/gen/386splitload.rules b/src/cmd/compile/internal/ssa/gen/386splitload.rules
index ed93b90b73..29d4f8c227 100644
--- a/src/cmd/compile/internal/ssa/gen/386splitload.rules
+++ b/src/cmd/compile/internal/ssa/gen/386splitload.rules
@@ -6,6 +6,6 @@
 
 (CMP(L|W|B)load {sym} [off] ptr x mem) => (CMP(L|W|B) (MOV(L|W|B)load {sym} [off] ptr mem) x)
 
-(CMPLconstload {sym} [vo] ptr mem) => (CMPLconst (MOVLload {sym} [vo.Off32()] ptr mem) [vo.Val32()])
-(CMPWconstload {sym} [vo] ptr mem) => (CMPWconst (MOVWload {sym} [vo.Off32()] ptr mem) [vo.Val16()])
-(CMPBconstload {sym} [vo] ptr mem) => (CMPBconst (MOVBload {sym} [vo.Off32()] ptr mem) [vo.Val8()])
+(CMPLconstload {sym} [vo] ptr mem) => (CMPLconst (MOVLload {sym} [vo.Off()] ptr mem) [vo.Val()])
+(CMPWconstload {sym} [vo] ptr mem) => (CMPWconst (MOVWload {sym} [vo.Off()] ptr mem) [vo.Val16()])
+(CMPBconstload {sym} [vo] ptr mem) => (CMPBconst (MOVBload {sym} [vo.Off()] ptr mem) [vo.Val8()])
diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules
index 7b03034bb7..c61b460a56 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64.rules
+++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules
@@ -318,46 +318,46 @@
 
 // Lowering Zero instructions
 (Zero [0] _ mem) => mem
-(Zero [1] destptr mem) => (MOVBstoreconst [makeValAndOff32(0,0)] destptr mem)
-(Zero [2] destptr mem) => (MOVWstoreconst [makeValAndOff32(0,0)] destptr mem)
-(Zero [4] destptr mem) => (MOVLstoreconst [makeValAndOff32(0,0)] destptr mem)
-(Zero [8] destptr mem) => (MOVQstoreconst [makeValAndOff32(0,0)] destptr mem)
+(Zero [1] destptr mem) => (MOVBstoreconst [makeValAndOff(0,0)] destptr mem)
+(Zero [2] destptr mem) => (MOVWstoreconst [makeValAndOff(0,0)] destptr mem)
+(Zero [4] destptr mem) => (MOVLstoreconst [makeValAndOff(0,0)] destptr mem)
+(Zero [8] destptr mem) => (MOVQstoreconst [makeValAndOff(0,0)] destptr mem)
 
 (Zero [3] destptr mem) =>
-	(MOVBstoreconst [makeValAndOff32(0,2)] destptr
-		(MOVWstoreconst [makeValAndOff32(0,0)] destptr mem))
+	(MOVBstoreconst [makeValAndOff(0,2)] destptr
+		(MOVWstoreconst [makeValAndOff(0,0)] destptr mem))
 (Zero [5] destptr mem) =>
-	(MOVBstoreconst [makeValAndOff32(0,4)] destptr
-		(MOVLstoreconst [makeValAndOff32(0,0)] destptr mem))
+	(MOVBstoreconst [makeValAndOff(0,4)] destptr
+		(MOVLstoreconst [makeValAndOff(0,0)] destptr mem))
 (Zero [6] destptr mem) =>
-	(MOVWstoreconst [makeValAndOff32(0,4)] destptr
-		(MOVLstoreconst [makeValAndOff32(0,0)] destptr mem))
+	(MOVWstoreconst [makeValAndOff(0,4)] destptr
+		(MOVLstoreconst [makeValAndOff(0,0)] destptr mem))
 (Zero [7] destptr mem) =>
-	(MOVLstoreconst [makeValAndOff32(0,3)] destptr
-		(MOVLstoreconst [makeValAndOff32(0,0)] destptr mem))
+	(MOVLstoreconst [makeValAndOff(0,3)] destptr
+		(MOVLstoreconst [makeValAndOff(0,0)] destptr mem))
 
 // Strip off any fractional word zeroing.
 (Zero [s] destptr mem) && s%8 != 0 && s > 8 && !config.useSSE =>
 	(Zero [s-s%8] (OffPtr <destptr.Type> destptr [s%8])
-		(MOVQstoreconst [makeValAndOff32(0,0)] destptr mem))
+		(MOVQstoreconst [makeValAndOff(0,0)] destptr mem))
 
 // Zero small numbers of words directly.
 (Zero [16] destptr mem) && !config.useSSE =>
-	(MOVQstoreconst [makeValAndOff32(0,8)] destptr
-		(MOVQstoreconst [makeValAndOff32(0,0)] destptr mem))
+	(MOVQstoreconst [makeValAndOff(0,8)] destptr
+		(MOVQstoreconst [makeValAndOff(0,0)] destptr mem))
 (Zero [24] destptr mem) && !config.useSSE =>
-	(MOVQstoreconst [makeValAndOff32(0,16)] destptr
-		(MOVQstoreconst [makeValAndOff32(0,8)] destptr
-			(MOVQstoreconst [makeValAndOff32(0,0)] destptr mem)))
+	(MOVQstoreconst [makeValAndOff(0,16)] destptr
+		(MOVQstoreconst [makeValAndOff(0,8)] destptr
+			(MOVQstoreconst [makeValAndOff(0,0)] destptr mem)))
 (Zero [32] destptr mem) && !config.useSSE =>
-	(MOVQstoreconst [makeValAndOff32(0,24)] destptr
-		(MOVQstoreconst [makeValAndOff32(0,16)] destptr
-			(MOVQstoreconst [makeValAndOff32(0,8)] destptr
-				(MOVQstoreconst [makeValAndOff32(0,0)] destptr mem))))
+	(MOVQstoreconst [makeValAndOff(0,24)] destptr
+		(MOVQstoreconst [makeValAndOff(0,16)] destptr
+			(MOVQstoreconst [makeValAndOff(0,8)] destptr
+				(MOVQstoreconst [makeValAndOff(0,0)] destptr mem))))
 
 (Zero [s] destptr mem) && s > 8 && s < 16 && config.useSSE =>
-	(MOVQstoreconst [makeValAndOff32(0,int32(s-8))] destptr
-		(MOVQstoreconst [makeValAndOff32(0,0)] destptr mem))
+	(MOVQstoreconst [makeValAndOff(0,int32(s-8))] destptr
+		(MOVQstoreconst [makeValAndOff(0,0)] destptr mem))
 
 // Adjust zeros to be a multiple of 16 bytes.
 (Zero [s] destptr mem) && s%16 != 0 && s > 16 && s%16 > 8 && config.useSSE =>
@@ -366,7 +366,7 @@
 
 (Zero [s] destptr mem) && s%16 != 0 && s > 16 && s%16 <= 8 && config.useSSE =>
 	(Zero [s-s%16] (OffPtr <destptr.Type> destptr [s%16])
-		(MOVQstoreconst [makeValAndOff32(0,0)] destptr mem))
+		(MOVQstoreconst [makeValAndOff(0,0)] destptr mem))
 
 (Zero [16] destptr mem) && config.useSSE =>
 	(MOVOstorezero destptr mem)
@@ -1122,13 +1122,13 @@
 
 // Fold constants into stores.
 (MOVQstore [off] {sym} ptr (MOVQconst [c]) mem) && validVal(c) =>
-	(MOVQstoreconst [makeValAndOff32(int32(c),off)] {sym} ptr mem)
+	(MOVQstoreconst [makeValAndOff(int32(c),off)] {sym} ptr mem)
 (MOVLstore [off] {sym} ptr (MOV(L|Q)const [c]) mem) =>
-	(MOVLstoreconst [makeValAndOff32(int32(c),off)] {sym} ptr mem)
+	(MOVLstoreconst [makeValAndOff(int32(c),off)] {sym} ptr mem)
 (MOVWstore [off] {sym} ptr (MOV(L|Q)const [c]) mem) =>
-	(MOVWstoreconst [makeValAndOff32(int32(int16(c)),off)] {sym} ptr mem)
+	(MOVWstoreconst [makeValAndOff(int32(int16(c)),off)] {sym} ptr mem)
 (MOVBstore [off] {sym} ptr (MOV(L|Q)const [c]) mem) =>
-	(MOVBstoreconst [makeValAndOff32(int32(int8(c)),off)] {sym} ptr mem)
+	(MOVBstoreconst [makeValAndOff(int32(int8(c)),off)] {sym} ptr mem)
 
 // Fold address offsets into constant stores.
 (MOV(Q|L|W|B)storeconst [sc] {s} (ADDQconst [off] ptr) mem) && ValAndOff(sc).canAdd32(off) =>
@@ -1868,32 +1868,32 @@
   && x.Uses == 1
   && a.Off() + 1 == c.Off()
   && clobber(x)
-  => (MOVWstoreconst [makeValAndOff64(a.Val()&0xff | c.Val()<<8, a.Off())] {s} p mem)
+  => (MOVWstoreconst [makeValAndOff(a.Val()&0xff | c.Val()<<8, a.Off())] {s} p mem)
 (MOVBstoreconst [a] {s} p x:(MOVBstoreconst [c] {s} p mem))
   && x.Uses == 1
   && a.Off() + 1 == c.Off()
   && clobber(x)
-  => (MOVWstoreconst [makeValAndOff64(a.Val()&0xff | c.Val()<<8, a.Off())] {s} p mem)
+  => (MOVWstoreconst [makeValAndOff(a.Val()&0xff | c.Val()<<8, a.Off())] {s} p mem)
 (MOVWstoreconst [c] {s} p x:(MOVWstoreconst [a] {s} p mem))
   && x.Uses == 1
   && a.Off() + 2 == c.Off()
   && clobber(x)
-  => (MOVLstoreconst [makeValAndOff64(a.Val()&0xffff | c.Val()<<16, a.Off())] {s} p mem)
+  => (MOVLstoreconst [makeValAndOff(a.Val()&0xffff | c.Val()<<16, a.Off())] {s} p mem)
 (MOVWstoreconst [a] {s} p x:(MOVWstoreconst [c] {s} p mem))
   && x.Uses == 1
   && a.Off() + 2 == c.Off()
   && clobber(x)
-  => (MOVLstoreconst [makeValAndOff64(a.Val()&0xffff | c.Val()<<16, a.Off())] {s} p mem)
+  => (MOVLstoreconst [makeValAndOff(a.Val()&0xffff | c.Val()<<16, a.Off())] {s} p mem)
 (MOVLstoreconst [c] {s} p x:(MOVLstoreconst [a] {s} p mem))
   && x.Uses == 1
   && a.Off() + 4 == c.Off()
   && clobber(x)
-  => (MOVQstore [a.Off32()] {s} p (MOVQconst [a.Val()&0xffffffff | c.Val()<<32]) mem)
+  => (MOVQstore [a.Off()] {s} p (MOVQconst [a.Val64()&0xffffffff | c.Val64()<<32]) mem)
 (MOVLstoreconst [a] {s} p x:(MOVLstoreconst [c] {s} p mem))
   && x.Uses == 1
   && a.Off() + 4 == c.Off()
   && clobber(x)
-  => (MOVQstore [a.Off32()] {s} p (MOVQconst [a.Val()&0xffffffff | c.Val()<<32]) mem)
+  => (MOVQstore [a.Off()] {s} p (MOVQconst [a.Val64()&0xffffffff | c.Val64()<<32]) mem)
 (MOVQstoreconst [c] {s} p x:(MOVQstoreconst [c2] {s} p mem))
   && config.useSSE
   && x.Uses == 1
@@ -1901,7 +1901,7 @@
   && c.Val() == 0
   && c2.Val() == 0
   && clobber(x)
-  => (MOVOstorezero [c2.Off32()] {s} p mem)
+  => (MOVOstorezero [c2.Off()] {s} p mem)
 
 // Combine stores into larger (unaligned) stores. Little endian.
 (MOVBstore [i] {s} p (SHR(W|L|Q)const [8] w) x:(MOVBstore [i-1] {s} p w mem))
@@ -2120,11 +2120,11 @@
 (MOVBQZX (MOVBQZX x)) => (MOVBQZX x)
 
 (MOVQstore [off] {sym} ptr a:((ADD|AND|OR|XOR|BTC|BTR|BTS)Qconst [c] l:(MOVQload [off] {sym} ptr2 mem)) mem)
-	&& isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c),int64(off)) && clobber(l, a) =>
-	((ADD|AND|OR|XOR|BTC|BTR|BTS)Qconstmodify {sym} [makeValAndOff32(int32(c),off)] ptr mem)
+	&& isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a) =>
+	((ADD|AND|OR|XOR|BTC|BTR|BTS)Qconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
 (MOVLstore [off] {sym} ptr a:((ADD|AND|OR|XOR|BTC|BTR|BTS)Lconst [c] l:(MOVLload [off] {sym} ptr2 mem)) mem)
-	&& isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c),int64(off)) && clobber(l, a) =>
-	((ADD|AND|OR|XOR|BTC|BTR|BTS)Lconstmodify {sym} [makeValAndOff32(int32(c),off)] ptr mem)
+	&& isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a) =>
+	((ADD|AND|OR|XOR|BTC|BTR|BTS)Lconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
 
 // float <-> int register moves, with no conversion.
 // These come up when compiling math.{Float{32,64}bits,Float{32,64}frombits}.
@@ -2184,23 +2184,22 @@
 (CMP(Q|L)const l:(MOV(Q|L)load {sym} [off] ptr mem) [c])
 	&& l.Uses == 1
 	&& clobber(l) =>
-@l.Block (CMP(Q|L)constload {sym} [makeValAndOff32(c,off)] ptr mem)
+@l.Block (CMP(Q|L)constload {sym} [makeValAndOff(c,off)] ptr mem)
 (CMP(W|B)const l:(MOV(W|B)load {sym} [off] ptr mem) [c])
 	&& l.Uses == 1
 	&& clobber(l) =>
-@l.Block (CMP(W|B)constload {sym} [makeValAndOff32(int32(c),off)] ptr mem)
+@l.Block (CMP(W|B)constload {sym} [makeValAndOff(int32(c),off)] ptr mem)
 
-(CMPQload {sym} [off] ptr (MOVQconst [c]) mem) && validValAndOff(c,int64(off)) => (CMPQconstload {sym} [makeValAndOff64(c,int64(off))] ptr mem)
-(CMPLload {sym} [off] ptr (MOVLconst [c]) mem) && validValAndOff(int64(c),int64(off)) => (CMPLconstload {sym} [makeValAndOff32(c,off)] ptr mem)
-(CMPWload {sym} [off] ptr (MOVLconst [c]) mem) && validValAndOff(int64(int16(c)),int64(off)) => (CMPWconstload {sym} [makeValAndOff32(int32(int16(c)),off)] ptr mem)
-(CMPBload {sym} [off] ptr (MOVLconst [c]) mem) && validValAndOff(int64(int8(c)),int64(off)) => (CMPBconstload {sym} [makeValAndOff32(int32(int8(c)),off)] ptr mem)
+(CMPQload {sym} [off] ptr (MOVQconst [c]) mem) && validVal(c) => (CMPQconstload {sym} [makeValAndOff(int32(c),off)] ptr mem)
+(CMPLload {sym} [off] ptr (MOVLconst [c]) mem) => (CMPLconstload {sym} [makeValAndOff(c,off)] ptr mem)
+(CMPWload {sym} [off] ptr (MOVLconst [c]) mem) => (CMPWconstload {sym} [makeValAndOff(int32(int16(c)),off)] ptr mem)
+(CMPBload {sym} [off] ptr (MOVLconst [c]) mem) => (CMPBconstload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
 
 (TEST(Q|L|W|B)  l:(MOV(Q|L|W|B)load {sym} [off] ptr mem) l2)
         && l == l2
 	&& l.Uses == 2
-	&& validValAndOff(0, int64(off))
 	&& clobber(l) =>
-  @l.Block (CMP(Q|L|W|B)constload {sym} [makeValAndOff64(0, int64(off))] ptr mem)
+  @l.Block (CMP(Q|L|W|B)constload {sym} [makeValAndOff(0, off)] ptr mem)
 
 // Convert ANDload to MOVload when we can do the AND in a containing TEST op.
 // Only do when it's within the same block, so we don't have flags live across basic block boundaries.
diff --git a/src/cmd/compile/internal/ssa/gen/AMD64splitload.rules b/src/cmd/compile/internal/ssa/gen/AMD64splitload.rules
index a50d509d0d..dd8f8ac4a1 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64splitload.rules
+++ b/src/cmd/compile/internal/ssa/gen/AMD64splitload.rules
@@ -18,28 +18,28 @@
 
 (CMP(Q|L|W|B)load {sym} [off] ptr x mem) => (CMP(Q|L|W|B) (MOV(Q|L|W|B)load {sym} [off] ptr mem) x)
 
-(CMP(Q|L|W|B)constload {sym} [vo] ptr mem) && vo.Val() == 0 => (TEST(Q|L|W|B) x:(MOV(Q|L|W|B)load {sym} [vo.Off32()] ptr mem) x)
+(CMP(Q|L|W|B)constload {sym} [vo] ptr mem) && vo.Val() == 0 => (TEST(Q|L|W|B) x:(MOV(Q|L|W|B)load {sym} [vo.Off()] ptr mem) x)
 
-(CMPQconstload {sym} [vo] ptr mem) && vo.Val() != 0 => (CMPQconst (MOVQload {sym} [vo.Off32()] ptr mem) [vo.Val32()])
-(CMPLconstload {sym} [vo] ptr mem) && vo.Val() != 0 => (CMPLconst (MOVLload {sym} [vo.Off32()] ptr mem) [vo.Val32()])
-(CMPWconstload {sym} [vo] ptr mem) && vo.Val() != 0 => (CMPWconst (MOVWload {sym} [vo.Off32()] ptr mem) [vo.Val16()])
-(CMPBconstload {sym} [vo] ptr mem) && vo.Val() != 0 => (CMPBconst (MOVBload {sym} [vo.Off32()] ptr mem) [vo.Val8()])
+(CMPQconstload {sym} [vo] ptr mem) && vo.Val() != 0 => (CMPQconst (MOVQload {sym} [vo.Off()] ptr mem) [vo.Val()])
+(CMPLconstload {sym} [vo] ptr mem) && vo.Val() != 0 => (CMPLconst (MOVLload {sym} [vo.Off()] ptr mem) [vo.Val()])
+(CMPWconstload {sym} [vo] ptr mem) && vo.Val() != 0 => (CMPWconst (MOVWload {sym} [vo.Off()] ptr mem) [vo.Val16()])
+(CMPBconstload {sym} [vo] ptr mem) && vo.Val() != 0 => (CMPBconst (MOVBload {sym} [vo.Off()] ptr mem) [vo.Val8()])
 
 (CMP(Q|L|W|B)loadidx1 {sym} [off] ptr idx x mem) => (CMP(Q|L|W|B) (MOV(Q|L|W|B)loadidx1 {sym} [off] ptr idx mem) x)
 (CMPQloadidx8 {sym} [off] ptr idx x mem) => (CMPQ (MOVQloadidx8 {sym} [off] ptr idx mem) x)
 (CMPLloadidx4 {sym} [off] ptr idx x mem) => (CMPL (MOVLloadidx4 {sym} [off] ptr idx mem) x)
 (CMPWloadidx2 {sym} [off] ptr idx x mem) => (CMPW (MOVWloadidx2 {sym} [off] ptr idx mem) x)
 
-(CMP(Q|L|W|B)constloadidx1 {sym} [vo] ptr idx mem) && vo.Val() == 0 => (TEST(Q|L|W|B) x:(MOV(Q|L|W|B)loadidx1 {sym} [vo.Off32()] ptr idx mem) x)
-(CMPQconstloadidx8         {sym} [vo] ptr idx mem) && vo.Val() == 0 => (TESTQ         x:(MOVQloadidx8         {sym} [vo.Off32()] ptr idx mem) x)
-(CMPLconstloadidx4         {sym} [vo] ptr idx mem) && vo.Val() == 0 => (TESTL         x:(MOVLloadidx4         {sym} [vo.Off32()] ptr idx mem) x)
-(CMPWconstloadidx2         {sym} [vo] ptr idx mem) && vo.Val() == 0 => (TESTW         x:(MOVWloadidx2         {sym} [vo.Off32()] ptr idx mem) x)
+(CMP(Q|L|W|B)constloadidx1 {sym} [vo] ptr idx mem) && vo.Val() == 0 => (TEST(Q|L|W|B) x:(MOV(Q|L|W|B)loadidx1 {sym} [vo.Off()] ptr idx mem) x)
+(CMPQconstloadidx8         {sym} [vo] ptr idx mem) && vo.Val() == 0 => (TESTQ         x:(MOVQloadidx8         {sym} [vo.Off()] ptr idx mem) x)
+(CMPLconstloadidx4         {sym} [vo] ptr idx mem) && vo.Val() == 0 => (TESTL         x:(MOVLloadidx4         {sym} [vo.Off()] ptr idx mem) x)
+(CMPWconstloadidx2         {sym} [vo] ptr idx mem) && vo.Val() == 0 => (TESTW         x:(MOVWloadidx2         {sym} [vo.Off()] ptr idx mem) x)
 
-(CMPQconstloadidx1 {sym} [vo] ptr idx mem) && vo.Val() != 0 => (CMPQconst (MOVQloadidx1 {sym} [vo.Off32()] ptr idx mem) [vo.Val32()])
-(CMPLconstloadidx1 {sym} [vo] ptr idx mem) && vo.Val() != 0 => (CMPLconst (MOVLloadidx1 {sym} [vo.Off32()] ptr idx mem) [vo.Val32()])
-(CMPWconstloadidx1 {sym} [vo] ptr idx mem) && vo.Val() != 0 => (CMPWconst (MOVWloadidx1 {sym} [vo.Off32()] ptr idx mem) [vo.Val16()])
-(CMPBconstloadidx1 {sym} [vo] ptr idx mem) && vo.Val() != 0 => (CMPBconst (MOVBloadidx1 {sym} [vo.Off32()] ptr idx mem) [vo.Val8()])
+(CMPQconstloadidx1 {sym} [vo] ptr idx mem) && vo.Val() != 0 => (CMPQconst (MOVQloadidx1 {sym} [vo.Off()] ptr idx mem) [vo.Val()])
+(CMPLconstloadidx1 {sym} [vo] ptr idx mem) && vo.Val() != 0 => (CMPLconst (MOVLloadidx1 {sym} [vo.Off()] ptr idx mem) [vo.Val()])
+(CMPWconstloadidx1 {sym} [vo] ptr idx mem) && vo.Val() != 0 => (CMPWconst (MOVWloadidx1 {sym} [vo.Off()] ptr idx mem) [vo.Val16()])
+(CMPBconstloadidx1 {sym} [vo] ptr idx mem) && vo.Val() != 0 => (CMPBconst (MOVBloadidx1 {sym} [vo.Off()] ptr idx mem) [vo.Val8()])
 
-(CMPQconstloadidx8 {sym} [vo] ptr idx mem) && vo.Val() != 0 => (CMPQconst (MOVQloadidx8 {sym} [vo.Off32()] ptr idx mem) [vo.Val32()])
-(CMPLconstloadidx4 {sym} [vo] ptr idx mem) && vo.Val() != 0 => (CMPLconst (MOVLloadidx4 {sym} [vo.Off32()] ptr idx mem) [vo.Val32()])
-(CMPWconstloadidx2 {sym} [vo] ptr idx mem) && vo.Val() != 0 => (CMPWconst (MOVWloadidx2 {sym} [vo.Off32()] ptr idx mem) [vo.Val16()])
+(CMPQconstloadidx8 {sym} [vo] ptr idx mem) && vo.Val() != 0 => (CMPQconst (MOVQloadidx8 {sym} [vo.Off()] ptr idx mem) [vo.Val()])
+(CMPLconstloadidx4 {sym} [vo] ptr idx mem) && vo.Val() != 0 => (CMPLconst (MOVLloadidx4 {sym} [vo.Off()] ptr idx mem) [vo.Val()])
+(CMPWconstloadidx2 {sym} [vo] ptr idx mem) && vo.Val() != 0 => (CMPWconst (MOVWloadidx2 {sym} [vo.Off()] ptr idx mem) [vo.Val16()])
diff --git a/src/cmd/compile/internal/ssa/gen/S390X.rules b/src/cmd/compile/internal/ssa/gen/S390X.rules
index 1f75f78a71..0fdd231d71 100644
--- a/src/cmd/compile/internal/ssa/gen/S390X.rules
+++ b/src/cmd/compile/internal/ssa/gen/S390X.rules
@@ -386,13 +386,13 @@
 
 // MVC for other moves. Use up to 4 instructions (sizes up to 1024 bytes).
 (Move [s] dst src mem) && s > 0 && s <= 256 && logLargeCopy(v, s) =>
-	(MVC [makeValAndOff32(int32(s), 0)] dst src mem)
+	(MVC [makeValAndOff(int32(s), 0)] dst src mem)
 (Move [s] dst src mem) && s > 256 && s <= 512 && logLargeCopy(v, s) =>
-	(MVC [makeValAndOff32(int32(s)-256, 256)] dst src (MVC [makeValAndOff32(256, 0)] dst src mem))
+	(MVC [makeValAndOff(int32(s)-256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem))
 (Move [s] dst src mem) && s > 512 && s <= 768 && logLargeCopy(v, s) =>
-	(MVC [makeValAndOff32(int32(s)-512, 512)] dst src (MVC [makeValAndOff32(256, 256)] dst src (MVC [makeValAndOff32(256, 0)] dst src mem)))
+	(MVC [makeValAndOff(int32(s)-512, 512)] dst src (MVC [makeValAndOff(256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem)))
 (Move [s] dst src mem) && s > 768 && s <= 1024 && logLargeCopy(v, s) =>
-	(MVC [makeValAndOff32(int32(s)-768, 768)] dst src (MVC [makeValAndOff32(256, 512)] dst src (MVC [makeValAndOff32(256, 256)] dst src (MVC [makeValAndOff32(256, 0)] dst src mem))))
+	(MVC [makeValAndOff(int32(s)-768, 768)] dst src (MVC [makeValAndOff(256, 512)] dst src (MVC [makeValAndOff(256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem))))
 
 // Move more than 1024 bytes using a loop.
 (Move [s] dst src mem) && s > 1024 && logLargeCopy(v, s) =>
@@ -405,20 +405,20 @@
 (Zero [4] destptr mem) => (MOVWstoreconst [0] destptr mem)
 (Zero [8] destptr mem) => (MOVDstoreconst [0] destptr mem)
 (Zero [3] destptr mem) =>
-	(MOVBstoreconst [makeValAndOff32(0,2)] destptr
+	(MOVBstoreconst [makeValAndOff(0,2)] destptr
 		(MOVHstoreconst [0] destptr mem))
 (Zero [5] destptr mem) =>
-	(MOVBstoreconst [makeValAndOff32(0,4)] destptr
+	(MOVBstoreconst [makeValAndOff(0,4)] destptr
 		(MOVWstoreconst [0] destptr mem))
 (Zero [6] destptr mem) =>
-	(MOVHstoreconst [makeValAndOff32(0,4)] destptr
+	(MOVHstoreconst [makeValAndOff(0,4)] destptr
 		(MOVWstoreconst [0] destptr mem))
 (Zero [7] destptr mem) =>
-	(MOVWstoreconst [makeValAndOff32(0,3)] destptr
+	(MOVWstoreconst [makeValAndOff(0,3)] destptr
 		(MOVWstoreconst [0] destptr mem))
 
 (Zero [s] destptr mem) && s > 0 && s <= 1024 =>
-	(CLEAR [makeValAndOff32(int32(s), 0)] destptr mem)
+	(CLEAR [makeValAndOff(int32(s), 0)] destptr mem)
 
 // Zero more than 1024 bytes using a loop.
 (Zero [s] destptr mem) && s > 1024 =>
@@ -948,22 +948,22 @@
 
 // Fold constants into stores.
 (MOVDstore [off] {sym} ptr (MOVDconst [c]) mem) && is16Bit(c) && isU12Bit(int64(off)) && ptr.Op != OpSB =>
-	(MOVDstoreconst [makeValAndOff32(int32(c),off)] {sym} ptr mem)
+	(MOVDstoreconst [makeValAndOff(int32(c),off)] {sym} ptr mem)
 (MOVWstore [off] {sym} ptr (MOVDconst [c]) mem) && is16Bit(c) && isU12Bit(int64(off)) && ptr.Op != OpSB =>
-	(MOVWstoreconst [makeValAndOff32(int32(c),off)] {sym} ptr mem)
+	(MOVWstoreconst [makeValAndOff(int32(c),off)] {sym} ptr mem)
 (MOVHstore [off] {sym} ptr (MOVDconst [c]) mem) && isU12Bit(int64(off)) && ptr.Op != OpSB =>
-	(MOVHstoreconst [makeValAndOff32(int32(int16(c)),off)] {sym} ptr mem)
+	(MOVHstoreconst [makeValAndOff(int32(int16(c)),off)] {sym} ptr mem)
 (MOVBstore [off] {sym} ptr (MOVDconst [c]) mem) && is20Bit(int64(off)) && ptr.Op != OpSB =>
-	(MOVBstoreconst [makeValAndOff32(int32(int8(c)),off)] {sym} ptr mem)
+	(MOVBstoreconst [makeValAndOff(int32(int8(c)),off)] {sym} ptr mem)
 
 // Fold address offsets into constant stores.
-(MOVDstoreconst [sc] {s} (ADDconst [off] ptr) mem) && isU12Bit(sc.Off()+int64(off)) =>
+(MOVDstoreconst [sc] {s} (ADDconst [off] ptr) mem) && isU12Bit(sc.Off64()+int64(off)) =>
 	(MOVDstoreconst [sc.addOffset32(off)] {s} ptr mem)
-(MOVWstoreconst [sc] {s} (ADDconst [off] ptr) mem) && isU12Bit(sc.Off()+int64(off)) =>
+(MOVWstoreconst [sc] {s} (ADDconst [off] ptr) mem) && isU12Bit(sc.Off64()+int64(off)) =>
 	(MOVWstoreconst [sc.addOffset32(off)] {s} ptr mem)
-(MOVHstoreconst [sc] {s} (ADDconst [off] ptr) mem) && isU12Bit(sc.Off()+int64(off)) =>
+(MOVHstoreconst [sc] {s} (ADDconst [off] ptr) mem) && isU12Bit(sc.Off64()+int64(off)) =>
 	(MOVHstoreconst [sc.addOffset32(off)] {s} ptr mem)
-(MOVBstoreconst [sc] {s} (ADDconst [off] ptr) mem) && is20Bit(sc.Off()+int64(off)) =>
+(MOVBstoreconst [sc] {s} (ADDconst [off] ptr) mem) && is20Bit(sc.Off64()+int64(off)) =>
 	(MOVBstoreconst [sc.addOffset32(off)] {s} ptr mem)
 
 // Merge address calculations into loads and stores.
@@ -1306,19 +1306,19 @@
   && x.Uses == 1
   && a.Off() + 1 == c.Off()
   && clobber(x)
-  => (MOVHstoreconst [makeValAndOff32(c.Val32()&0xff | a.Val32()<<8, a.Off32())] {s} p mem)
+  => (MOVHstoreconst [makeValAndOff(c.Val()&0xff | a.Val()<<8, a.Off())] {s} p mem)
 (MOVHstoreconst [c] {s} p x:(MOVHstoreconst [a] {s} p mem))
   && p.Op != OpSB
   && x.Uses == 1
   && a.Off() + 2 == c.Off()
   && clobber(x)
-  => (MOVWstore [a.Off32()] {s} p (MOVDconst [int64(c.Val32()&0xffff | a.Val32()<<16)]) mem)
+  => (MOVWstore [a.Off()] {s} p (MOVDconst [int64(c.Val()&0xffff | a.Val()<<16)]) mem)
 (MOVWstoreconst [c] {s} p x:(MOVWstoreconst [a] {s} p mem))
   && p.Op != OpSB
   && x.Uses == 1
   && a.Off() + 4 == c.Off()
   && clobber(x)
-  => (MOVDstore [a.Off32()] {s} p (MOVDconst [c.Val()&0xffffffff | a.Val()<<32]) mem)
+  => (MOVDstore [a.Off()] {s} p (MOVDconst [c.Val64()&0xffffffff | a.Val64()<<32]) mem)
 
 // Combine stores into larger (unaligned) stores.
 // It doesn't work on global data (based on SB) because stores with relative addressing
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index 574377a33d..342df73d02 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -382,13 +382,13 @@ type Sym interface {
 // The low 32 bits hold a pointer offset.
 type ValAndOff int64
 
-func (x ValAndOff) Val() int64   { return int64(x) >> 32 }
-func (x ValAndOff) Val32() int32 { return int32(int64(x) >> 32) }
+func (x ValAndOff) Val() int32   { return int32(int64(x) >> 32) }
+func (x ValAndOff) Val64() int64 { return int64(x) >> 32 }
 func (x ValAndOff) Val16() int16 { return int16(int64(x) >> 32) }
 func (x ValAndOff) Val8() int8   { return int8(int64(x) >> 32) }
 
-func (x ValAndOff) Off() int64   { return int64(int32(x)) }
-func (x ValAndOff) Off32() int32 { return int32(x) }
+func (x ValAndOff) Off64() int64 { return int64(int32(x)) }
+func (x ValAndOff) Off() int32   { return int32(x) }
 
 func (x ValAndOff) String() string {
 	return fmt.Sprintf("val=%d,off=%d", x.Val(), x.Off())
@@ -400,40 +400,16 @@ func validVal(val int64) bool {
 	return val == int64(int32(val))
 }
 
-// validOff reports whether the offset can be used
-// as an argument to makeValAndOff.
-func validOff(off int64) bool {
-	return off == int64(int32(off))
-}
-
-// validValAndOff reports whether we can fit the value and offset into
-// a ValAndOff value.
-func validValAndOff(val, off int64) bool {
-	if !validVal(val) {
-		return false
-	}
-	if !validOff(off) {
-		return false
-	}
-	return true
-}
-
-func makeValAndOff32(val, off int32) ValAndOff {
+func makeValAndOff(val, off int32) ValAndOff {
 	return ValAndOff(int64(val)<<32 + int64(uint32(off)))
 }
-func makeValAndOff64(val, off int64) ValAndOff {
-	if !validValAndOff(val, off) {
-		panic("invalid makeValAndOff64")
-	}
-	return ValAndOff(val<<32 + int64(uint32(off)))
-}
 
 func (x ValAndOff) canAdd32(off int32) bool {
-	newoff := x.Off() + int64(off)
+	newoff := x.Off64() + int64(off)
 	return newoff == int64(int32(newoff))
 }
 func (x ValAndOff) canAdd64(off int64) bool {
-	newoff := x.Off() + off
+	newoff := x.Off64() + off
 	return newoff == int64(int32(newoff))
 }
 
@@ -441,13 +417,13 @@ func (x ValAndOff) addOffset32(off int32) ValAndOff {
 	if !x.canAdd32(off) {
 		panic("invalid ValAndOff.addOffset32")
 	}
-	return makeValAndOff64(x.Val(), x.Off()+int64(off))
+	return makeValAndOff(x.Val(), x.Off()+off)
 }
 func (x ValAndOff) addOffset64(off int64) ValAndOff {
 	if !x.canAdd64(off) {
 		panic("invalid ValAndOff.addOffset64")
 	}
-	return makeValAndOff64(x.Val(), x.Off()+off)
+	return makeValAndOff(x.Val(), x.Off()+int32(off))
 }
 
 // int128 is a type that stores a 128-bit constant.
diff --git a/src/cmd/compile/internal/ssa/rewrite386.go b/src/cmd/compile/internal/ssa/rewrite386.go
index 726d68e243..1ec2d26f75 100644
--- a/src/cmd/compile/internal/ssa/rewrite386.go
+++ b/src/cmd/compile/internal/ssa/rewrite386.go
@@ -1996,8 +1996,8 @@ func rewriteValue386_Op386CMPBconst(v *Value) bool {
 		return true
 	}
 	// match: (CMPBconst l:(MOVBload {sym} [off] ptr mem) [c])
-	// cond: l.Uses == 1 && validValAndOff(int64(c), int64(off)) && clobber(l)
-	// result: @l.Block (CMPBconstload {sym} [makeValAndOff32(int32(c),int32(off))] ptr mem)
+	// cond: l.Uses == 1 && clobber(l)
+	// result: @l.Block (CMPBconstload {sym} [makeValAndOff(int32(c),off)] ptr mem)
 	for {
 		c := auxIntToInt8(v.AuxInt)
 		l := v_0
@@ -2008,13 +2008,13 @@ func rewriteValue386_Op386CMPBconst(v *Value) bool {
 		sym := auxToSym(l.Aux)
 		mem := l.Args[1]
 		ptr := l.Args[0]
-		if !(l.Uses == 1 && validValAndOff(int64(c), int64(off)) && clobber(l)) {
+		if !(l.Uses == 1 && clobber(l)) {
 			break
 		}
 		b = l.Block
 		v0 := b.NewValue0(l.Pos, Op386CMPBconstload, types.TypeFlags)
 		v.copyOf(v0)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), int32(off)))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v0.Aux = symToAux(sym)
 		v0.AddArg2(ptr, mem)
 		return true
@@ -2026,8 +2026,7 @@ func rewriteValue386_Op386CMPBload(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (CMPBload {sym} [off] ptr (MOVLconst [c]) mem)
-	// cond: validValAndOff(int64(int8(c)),int64(off))
-	// result: (CMPBconstload {sym} [makeValAndOff32(int32(int8(c)),off)] ptr mem)
+	// result: (CMPBconstload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -2037,11 +2036,8 @@ func rewriteValue386_Op386CMPBload(v *Value) bool {
 		}
 		c := auxIntToInt32(v_1.AuxInt)
 		mem := v_2
-		if !(validValAndOff(int64(int8(c)), int64(off))) {
-			break
-		}
 		v.reset(Op386CMPBconstload)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(int8(c)), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
@@ -2304,8 +2300,8 @@ func rewriteValue386_Op386CMPLconst(v *Value) bool {
 		return true
 	}
 	// match: (CMPLconst l:(MOVLload {sym} [off] ptr mem) [c])
-	// cond: l.Uses == 1 && validValAndOff(int64(c), int64(off)) && clobber(l)
-	// result: @l.Block (CMPLconstload {sym} [makeValAndOff32(int32(c),int32(off))] ptr mem)
+	// cond: l.Uses == 1 && clobber(l)
+	// result: @l.Block (CMPLconstload {sym} [makeValAndOff(int32(c),off)] ptr mem)
 	for {
 		c := auxIntToInt32(v.AuxInt)
 		l := v_0
@@ -2316,13 +2312,13 @@ func rewriteValue386_Op386CMPLconst(v *Value) bool {
 		sym := auxToSym(l.Aux)
 		mem := l.Args[1]
 		ptr := l.Args[0]
-		if !(l.Uses == 1 && validValAndOff(int64(c), int64(off)) && clobber(l)) {
+		if !(l.Uses == 1 && clobber(l)) {
 			break
 		}
 		b = l.Block
 		v0 := b.NewValue0(l.Pos, Op386CMPLconstload, types.TypeFlags)
 		v.copyOf(v0)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), int32(off)))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v0.Aux = symToAux(sym)
 		v0.AddArg2(ptr, mem)
 		return true
@@ -2334,8 +2330,7 @@ func rewriteValue386_Op386CMPLload(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (CMPLload {sym} [off] ptr (MOVLconst [c]) mem)
-	// cond: validValAndOff(int64(c),int64(off))
-	// result: (CMPLconstload {sym} [makeValAndOff32(c,off)] ptr mem)
+	// result: (CMPLconstload {sym} [makeValAndOff(c,off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -2345,11 +2340,8 @@ func rewriteValue386_Op386CMPLload(v *Value) bool {
 		}
 		c := auxIntToInt32(v_1.AuxInt)
 		mem := v_2
-		if !(validValAndOff(int64(c), int64(off))) {
-			break
-		}
 		v.reset(Op386CMPLconstload)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(c, off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(c, off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
@@ -2597,8 +2589,8 @@ func rewriteValue386_Op386CMPWconst(v *Value) bool {
 		return true
 	}
 	// match: (CMPWconst l:(MOVWload {sym} [off] ptr mem) [c])
-	// cond: l.Uses == 1 && validValAndOff(int64(c), int64(off)) && clobber(l)
-	// result: @l.Block (CMPWconstload {sym} [makeValAndOff32(int32(c),int32(off))] ptr mem)
+	// cond: l.Uses == 1 && clobber(l)
+	// result: @l.Block (CMPWconstload {sym} [makeValAndOff(int32(c),off)] ptr mem)
 	for {
 		c := auxIntToInt16(v.AuxInt)
 		l := v_0
@@ -2609,13 +2601,13 @@ func rewriteValue386_Op386CMPWconst(v *Value) bool {
 		sym := auxToSym(l.Aux)
 		mem := l.Args[1]
 		ptr := l.Args[0]
-		if !(l.Uses == 1 && validValAndOff(int64(c), int64(off)) && clobber(l)) {
+		if !(l.Uses == 1 && clobber(l)) {
 			break
 		}
 		b = l.Block
 		v0 := b.NewValue0(l.Pos, Op386CMPWconstload, types.TypeFlags)
 		v.copyOf(v0)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), int32(off)))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v0.Aux = symToAux(sym)
 		v0.AddArg2(ptr, mem)
 		return true
@@ -2627,8 +2619,7 @@ func rewriteValue386_Op386CMPWload(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (CMPWload {sym} [off] ptr (MOVLconst [c]) mem)
-	// cond: validValAndOff(int64(int16(c)),int64(off))
-	// result: (CMPWconstload {sym} [makeValAndOff32(int32(int16(c)),off)] ptr mem)
+	// result: (CMPWconstload {sym} [makeValAndOff(int32(int16(c)),off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -2638,11 +2629,8 @@ func rewriteValue386_Op386CMPWload(v *Value) bool {
 		}
 		c := auxIntToInt32(v_1.AuxInt)
 		mem := v_2
-		if !(validValAndOff(int64(int16(c)), int64(off))) {
-			break
-		}
 		v.reset(Op386CMPWconstload)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(int16(c)), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int16(c)), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
@@ -3735,8 +3723,7 @@ func rewriteValue386_Op386MOVBstore(v *Value) bool {
 		return true
 	}
 	// match: (MOVBstore [off] {sym} ptr (MOVLconst [c]) mem)
-	// cond: validOff(int64(off))
-	// result: (MOVBstoreconst [makeValAndOff32(c,off)] {sym} ptr mem)
+	// result: (MOVBstoreconst [makeValAndOff(c,off)] {sym} ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -3746,11 +3733,8 @@ func rewriteValue386_Op386MOVBstore(v *Value) bool {
 		}
 		c := auxIntToInt32(v_1.AuxInt)
 		mem := v_2
-		if !(validOff(int64(off))) {
-			break
-		}
 		v.reset(Op386MOVBstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(c, off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(c, off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
@@ -4090,7 +4074,7 @@ func rewriteValue386_Op386MOVBstoreconst(v *Value) bool {
 	}
 	// match: (MOVBstoreconst [c] {s} p x:(MOVBstoreconst [a] {s} p mem))
 	// cond: x.Uses == 1 && a.Off() + 1 == c.Off() && clobber(x)
-	// result: (MOVWstoreconst [makeValAndOff32(int32(a.Val()&0xff | c.Val()<<8), a.Off32())] {s} p mem)
+	// result: (MOVWstoreconst [makeValAndOff(a.Val()&0xff | c.Val()<<8, a.Off())] {s} p mem)
 	for {
 		c := auxIntToValAndOff(v.AuxInt)
 		s := auxToSym(v.Aux)
@@ -4108,14 +4092,14 @@ func rewriteValue386_Op386MOVBstoreconst(v *Value) bool {
 			break
 		}
 		v.reset(Op386MOVWstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(a.Val()&0xff|c.Val()<<8), a.Off32()))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(a.Val()&0xff|c.Val()<<8, a.Off()))
 		v.Aux = symToAux(s)
 		v.AddArg2(p, mem)
 		return true
 	}
 	// match: (MOVBstoreconst [a] {s} p x:(MOVBstoreconst [c] {s} p mem))
 	// cond: x.Uses == 1 && a.Off() + 1 == c.Off() && clobber(x)
-	// result: (MOVWstoreconst [makeValAndOff32(int32(a.Val()&0xff | c.Val()<<8), a.Off32())] {s} p mem)
+	// result: (MOVWstoreconst [makeValAndOff(a.Val()&0xff | c.Val()<<8, a.Off())] {s} p mem)
 	for {
 		a := auxIntToValAndOff(v.AuxInt)
 		s := auxToSym(v.Aux)
@@ -4133,14 +4117,14 @@ func rewriteValue386_Op386MOVBstoreconst(v *Value) bool {
 			break
 		}
 		v.reset(Op386MOVWstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(a.Val()&0xff|c.Val()<<8), a.Off32()))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(a.Val()&0xff|c.Val()<<8, a.Off()))
 		v.Aux = symToAux(s)
 		v.AddArg2(p, mem)
 		return true
 	}
 	// match: (MOVBstoreconst [c] {s} p1 x:(MOVBstoreconst [a] {s} p0 mem))
 	// cond: x.Uses == 1 && a.Off() == c.Off() && sequentialAddresses(p0, p1, 1) && clobber(x)
-	// result: (MOVWstoreconst [makeValAndOff32(int32(a.Val()&0xff | c.Val()<<8), a.Off32())] {s} p0 mem)
+	// result: (MOVWstoreconst [makeValAndOff(a.Val()&0xff | c.Val()<<8, a.Off())] {s} p0 mem)
 	for {
 		c := auxIntToValAndOff(v.AuxInt)
 		s := auxToSym(v.Aux)
@@ -4159,14 +4143,14 @@ func rewriteValue386_Op386MOVBstoreconst(v *Value) bool {
 			break
 		}
 		v.reset(Op386MOVWstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(a.Val()&0xff|c.Val()<<8), a.Off32()))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(a.Val()&0xff|c.Val()<<8, a.Off()))
 		v.Aux = symToAux(s)
 		v.AddArg2(p0, mem)
 		return true
 	}
 	// match: (MOVBstoreconst [a] {s} p0 x:(MOVBstoreconst [c] {s} p1 mem))
 	// cond: x.Uses == 1 && a.Off() == c.Off() && sequentialAddresses(p0, p1, 1) && clobber(x)
-	// result: (MOVWstoreconst [makeValAndOff32(int32(a.Val()&0xff | c.Val()<<8), a.Off32())] {s} p0 mem)
+	// result: (MOVWstoreconst [makeValAndOff(a.Val()&0xff | c.Val()<<8, a.Off())] {s} p0 mem)
 	for {
 		a := auxIntToValAndOff(v.AuxInt)
 		s := auxToSym(v.Aux)
@@ -4185,7 +4169,7 @@ func rewriteValue386_Op386MOVBstoreconst(v *Value) bool {
 			break
 		}
 		v.reset(Op386MOVWstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(a.Val()&0xff|c.Val()<<8), a.Off32()))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(a.Val()&0xff|c.Val()<<8, a.Off()))
 		v.Aux = symToAux(s)
 		v.AddArg2(p0, mem)
 		return true
@@ -4304,8 +4288,7 @@ func rewriteValue386_Op386MOVLstore(v *Value) bool {
 		return true
 	}
 	// match: (MOVLstore [off] {sym} ptr (MOVLconst [c]) mem)
-	// cond: validOff(int64(off))
-	// result: (MOVLstoreconst [makeValAndOff32(c,off)] {sym} ptr mem)
+	// result: (MOVLstoreconst [makeValAndOff(c,off)] {sym} ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -4315,11 +4298,8 @@ func rewriteValue386_Op386MOVLstore(v *Value) bool {
 		}
 		c := auxIntToInt32(v_1.AuxInt)
 		mem := v_2
-		if !(validOff(int64(off))) {
-			break
-		}
 		v.reset(Op386MOVLstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(c, off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(c, off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
@@ -4602,8 +4582,8 @@ func rewriteValue386_Op386MOVLstore(v *Value) bool {
 		break
 	}
 	// match: (MOVLstore {sym} [off] ptr y:(ADDLconst [c] l:(MOVLload [off] {sym} ptr mem)) mem)
-	// cond: y.Uses==1 && l.Uses==1 && clobber(y, l) && validValAndOff(int64(c),int64(off))
-	// result: (ADDLconstmodify [makeValAndOff32(c,off)] {sym} ptr mem)
+	// cond: y.Uses==1 && l.Uses==1 && clobber(y, l)
+	// result: (ADDLconstmodify [makeValAndOff(c,off)] {sym} ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -4618,18 +4598,18 @@ func rewriteValue386_Op386MOVLstore(v *Value) bool {
 			break
 		}
 		mem := l.Args[1]
-		if ptr != l.Args[0] || mem != v_2 || !(y.Uses == 1 && l.Uses == 1 && clobber(y, l) && validValAndOff(int64(c), int64(off))) {
+		if ptr != l.Args[0] || mem != v_2 || !(y.Uses == 1 && l.Uses == 1 && clobber(y, l)) {
 			break
 		}
 		v.reset(Op386ADDLconstmodify)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(c, off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(c, off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
 	}
 	// match: (MOVLstore {sym} [off] ptr y:(ANDLconst [c] l:(MOVLload [off] {sym} ptr mem)) mem)
-	// cond: y.Uses==1 && l.Uses==1 && clobber(y, l) && validValAndOff(int64(c),int64(off))
-	// result: (ANDLconstmodify [makeValAndOff32(c,off)] {sym} ptr mem)
+	// cond: y.Uses==1 && l.Uses==1 && clobber(y, l)
+	// result: (ANDLconstmodify [makeValAndOff(c,off)] {sym} ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -4644,18 +4624,18 @@ func rewriteValue386_Op386MOVLstore(v *Value) bool {
 			break
 		}
 		mem := l.Args[1]
-		if ptr != l.Args[0] || mem != v_2 || !(y.Uses == 1 && l.Uses == 1 && clobber(y, l) && validValAndOff(int64(c), int64(off))) {
+		if ptr != l.Args[0] || mem != v_2 || !(y.Uses == 1 && l.Uses == 1 && clobber(y, l)) {
 			break
 		}
 		v.reset(Op386ANDLconstmodify)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(c, off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(c, off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
 	}
 	// match: (MOVLstore {sym} [off] ptr y:(ORLconst [c] l:(MOVLload [off] {sym} ptr mem)) mem)
-	// cond: y.Uses==1 && l.Uses==1 && clobber(y, l) && validValAndOff(int64(c),int64(off))
-	// result: (ORLconstmodify [makeValAndOff32(c,off)] {sym} ptr mem)
+	// cond: y.Uses==1 && l.Uses==1 && clobber(y, l)
+	// result: (ORLconstmodify [makeValAndOff(c,off)] {sym} ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -4670,18 +4650,18 @@ func rewriteValue386_Op386MOVLstore(v *Value) bool {
 			break
 		}
 		mem := l.Args[1]
-		if ptr != l.Args[0] || mem != v_2 || !(y.Uses == 1 && l.Uses == 1 && clobber(y, l) && validValAndOff(int64(c), int64(off))) {
+		if ptr != l.Args[0] || mem != v_2 || !(y.Uses == 1 && l.Uses == 1 && clobber(y, l)) {
 			break
 		}
 		v.reset(Op386ORLconstmodify)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(c, off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(c, off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
 	}
 	// match: (MOVLstore {sym} [off] ptr y:(XORLconst [c] l:(MOVLload [off] {sym} ptr mem)) mem)
-	// cond: y.Uses==1 && l.Uses==1 && clobber(y, l) && validValAndOff(int64(c),int64(off))
-	// result: (XORLconstmodify [makeValAndOff32(c,off)] {sym} ptr mem)
+	// cond: y.Uses==1 && l.Uses==1 && clobber(y, l)
+	// result: (XORLconstmodify [makeValAndOff(c,off)] {sym} ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -4696,11 +4676,11 @@ func rewriteValue386_Op386MOVLstore(v *Value) bool {
 			break
 		}
 		mem := l.Args[1]
-		if ptr != l.Args[0] || mem != v_2 || !(y.Uses == 1 && l.Uses == 1 && clobber(y, l) && validValAndOff(int64(c), int64(off))) {
+		if ptr != l.Args[0] || mem != v_2 || !(y.Uses == 1 && l.Uses == 1 && clobber(y, l)) {
 			break
 		}
 		v.reset(Op386XORLconstmodify)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(c, off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(c, off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
@@ -5286,8 +5266,7 @@ func rewriteValue386_Op386MOVWstore(v *Value) bool {
 		return true
 	}
 	// match: (MOVWstore [off] {sym} ptr (MOVLconst [c]) mem)
-	// cond: validOff(int64(off))
-	// result: (MOVWstoreconst [makeValAndOff32(c,off)] {sym} ptr mem)
+	// result: (MOVWstoreconst [makeValAndOff(c,off)] {sym} ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -5297,11 +5276,8 @@ func rewriteValue386_Op386MOVWstore(v *Value) bool {
 		}
 		c := auxIntToInt32(v_1.AuxInt)
 		mem := v_2
-		if !(validOff(int64(off))) {
-			break
-		}
 		v.reset(Op386MOVWstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(c, off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(c, off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
@@ -5490,7 +5466,7 @@ func rewriteValue386_Op386MOVWstoreconst(v *Value) bool {
 	}
 	// match: (MOVWstoreconst [c] {s} p x:(MOVWstoreconst [a] {s} p mem))
 	// cond: x.Uses == 1 && a.Off() + 2 == c.Off() && clobber(x)
-	// result: (MOVLstoreconst [makeValAndOff32(int32(a.Val()&0xffff | c.Val()<<16), a.Off32())] {s} p mem)
+	// result: (MOVLstoreconst [makeValAndOff(a.Val()&0xffff | c.Val()<<16, a.Off())] {s} p mem)
 	for {
 		c := auxIntToValAndOff(v.AuxInt)
 		s := auxToSym(v.Aux)
@@ -5508,14 +5484,14 @@ func rewriteValue386_Op386MOVWstoreconst(v *Value) bool {
 			break
 		}
 		v.reset(Op386MOVLstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(a.Val()&0xffff|c.Val()<<16), a.Off32()))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(a.Val()&0xffff|c.Val()<<16, a.Off()))
 		v.Aux = symToAux(s)
 		v.AddArg2(p, mem)
 		return true
 	}
 	// match: (MOVWstoreconst [a] {s} p x:(MOVWstoreconst [c] {s} p mem))
 	// cond: x.Uses == 1 && ValAndOff(a).Off() + 2 == ValAndOff(c).Off() && clobber(x)
-	// result: (MOVLstoreconst [makeValAndOff32(int32(a.Val()&0xffff | c.Val()<<16), a.Off32())] {s} p mem)
+	// result: (MOVLstoreconst [makeValAndOff(a.Val()&0xffff | c.Val()<<16, a.Off())] {s} p mem)
 	for {
 		a := auxIntToValAndOff(v.AuxInt)
 		s := auxToSym(v.Aux)
@@ -5533,14 +5509,14 @@ func rewriteValue386_Op386MOVWstoreconst(v *Value) bool {
 			break
 		}
 		v.reset(Op386MOVLstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(a.Val()&0xffff|c.Val()<<16), a.Off32()))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(a.Val()&0xffff|c.Val()<<16, a.Off()))
 		v.Aux = symToAux(s)
 		v.AddArg2(p, mem)
 		return true
 	}
 	// match: (MOVWstoreconst [c] {s} p1 x:(MOVWstoreconst [a] {s} p0 mem))
 	// cond: x.Uses == 1 && a.Off() == c.Off() && sequentialAddresses(p0, p1, 2) && clobber(x)
-	// result: (MOVLstoreconst [makeValAndOff32(int32(a.Val()&0xffff | c.Val()<<16), a.Off32())] {s} p0 mem)
+	// result: (MOVLstoreconst [makeValAndOff(a.Val()&0xffff | c.Val()<<16, a.Off())] {s} p0 mem)
 	for {
 		c := auxIntToValAndOff(v.AuxInt)
 		s := auxToSym(v.Aux)
@@ -5559,14 +5535,14 @@ func rewriteValue386_Op386MOVWstoreconst(v *Value) bool {
 			break
 		}
 		v.reset(Op386MOVLstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(a.Val()&0xffff|c.Val()<<16), a.Off32()))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(a.Val()&0xffff|c.Val()<<16, a.Off()))
 		v.Aux = symToAux(s)
 		v.AddArg2(p0, mem)
 		return true
 	}
 	// match: (MOVWstoreconst [a] {s} p0 x:(MOVWstoreconst [c] {s} p1 mem))
 	// cond: x.Uses == 1 && a.Off() == c.Off() && sequentialAddresses(p0, p1, 2) && clobber(x)
-	// result: (MOVLstoreconst [makeValAndOff32(int32(a.Val()&0xffff | c.Val()<<16), a.Off32())] {s} p0 mem)
+	// result: (MOVLstoreconst [makeValAndOff(a.Val()&0xffff | c.Val()<<16, a.Off())] {s} p0 mem)
 	for {
 		a := auxIntToValAndOff(v.AuxInt)
 		s := auxToSym(v.Aux)
@@ -5585,7 +5561,7 @@ func rewriteValue386_Op386MOVWstoreconst(v *Value) bool {
 			break
 		}
 		v.reset(Op386MOVLstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(a.Val()&0xffff|c.Val()<<16), a.Off32()))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(a.Val()&0xffff|c.Val()<<16, a.Off()))
 		v.Aux = symToAux(s)
 		v.AddArg2(p0, mem)
 		return true
@@ -11574,7 +11550,7 @@ func rewriteValue386_OpZero(v *Value) bool {
 		return true
 	}
 	// match: (Zero [3] destptr mem)
-	// result: (MOVBstoreconst [makeValAndOff32(0,2)] destptr (MOVWstoreconst [makeValAndOff32(0,0)] destptr mem))
+	// result: (MOVBstoreconst [makeValAndOff(0,2)] destptr (MOVWstoreconst [makeValAndOff(0,0)] destptr mem))
 	for {
 		if auxIntToInt64(v.AuxInt) != 3 {
 			break
@@ -11582,15 +11558,15 @@ func rewriteValue386_OpZero(v *Value) bool {
 		destptr := v_0
 		mem := v_1
 		v.reset(Op386MOVBstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 2))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 2))
 		v0 := b.NewValue0(v.Pos, Op386MOVWstoreconst, types.TypeMem)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 0))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 0))
 		v0.AddArg2(destptr, mem)
 		v.AddArg2(destptr, v0)
 		return true
 	}
 	// match: (Zero [5] destptr mem)
-	// result: (MOVBstoreconst [makeValAndOff32(0,4)] destptr (MOVLstoreconst [makeValAndOff32(0,0)] destptr mem))
+	// result: (MOVBstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [makeValAndOff(0,0)] destptr mem))
 	for {
 		if auxIntToInt64(v.AuxInt) != 5 {
 			break
@@ -11598,15 +11574,15 @@ func rewriteValue386_OpZero(v *Value) bool {
 		destptr := v_0
 		mem := v_1
 		v.reset(Op386MOVBstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 4))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 4))
 		v0 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 0))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 0))
 		v0.AddArg2(destptr, mem)
 		v.AddArg2(destptr, v0)
 		return true
 	}
 	// match: (Zero [6] destptr mem)
-	// result: (MOVWstoreconst [makeValAndOff32(0,4)] destptr (MOVLstoreconst [makeValAndOff32(0,0)] destptr mem))
+	// result: (MOVWstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [makeValAndOff(0,0)] destptr mem))
 	for {
 		if auxIntToInt64(v.AuxInt) != 6 {
 			break
@@ -11614,15 +11590,15 @@ func rewriteValue386_OpZero(v *Value) bool {
 		destptr := v_0
 		mem := v_1
 		v.reset(Op386MOVWstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 4))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 4))
 		v0 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 0))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 0))
 		v0.AddArg2(destptr, mem)
 		v.AddArg2(destptr, v0)
 		return true
 	}
 	// match: (Zero [7] destptr mem)
-	// result: (MOVLstoreconst [makeValAndOff32(0,3)] destptr (MOVLstoreconst [makeValAndOff32(0,0)] destptr mem))
+	// result: (MOVLstoreconst [makeValAndOff(0,3)] destptr (MOVLstoreconst [makeValAndOff(0,0)] destptr mem))
 	for {
 		if auxIntToInt64(v.AuxInt) != 7 {
 			break
@@ -11630,9 +11606,9 @@ func rewriteValue386_OpZero(v *Value) bool {
 		destptr := v_0
 		mem := v_1
 		v.reset(Op386MOVLstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 3))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 3))
 		v0 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 0))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 0))
 		v0.AddArg2(destptr, mem)
 		v.AddArg2(destptr, v0)
 		return true
@@ -11659,7 +11635,7 @@ func rewriteValue386_OpZero(v *Value) bool {
 		return true
 	}
 	// match: (Zero [8] destptr mem)
-	// result: (MOVLstoreconst [makeValAndOff32(0,4)] destptr (MOVLstoreconst [makeValAndOff32(0,0)] destptr mem))
+	// result: (MOVLstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [makeValAndOff(0,0)] destptr mem))
 	for {
 		if auxIntToInt64(v.AuxInt) != 8 {
 			break
@@ -11667,15 +11643,15 @@ func rewriteValue386_OpZero(v *Value) bool {
 		destptr := v_0
 		mem := v_1
 		v.reset(Op386MOVLstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 4))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 4))
 		v0 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 0))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 0))
 		v0.AddArg2(destptr, mem)
 		v.AddArg2(destptr, v0)
 		return true
 	}
 	// match: (Zero [12] destptr mem)
-	// result: (MOVLstoreconst [makeValAndOff32(0,8)] destptr (MOVLstoreconst [makeValAndOff32(0,4)] destptr (MOVLstoreconst [makeValAndOff32(0,0)] destptr mem)))
+	// result: (MOVLstoreconst [makeValAndOff(0,8)] destptr (MOVLstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [makeValAndOff(0,0)] destptr mem)))
 	for {
 		if auxIntToInt64(v.AuxInt) != 12 {
 			break
@@ -11683,18 +11659,18 @@ func rewriteValue386_OpZero(v *Value) bool {
 		destptr := v_0
 		mem := v_1
 		v.reset(Op386MOVLstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 8))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 8))
 		v0 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 4))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 4))
 		v1 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
-		v1.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 0))
+		v1.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 0))
 		v1.AddArg2(destptr, mem)
 		v0.AddArg2(destptr, v1)
 		v.AddArg2(destptr, v0)
 		return true
 	}
 	// match: (Zero [16] destptr mem)
-	// result: (MOVLstoreconst [makeValAndOff32(0,12)] destptr (MOVLstoreconst [makeValAndOff32(0,8)] destptr (MOVLstoreconst [makeValAndOff32(0,4)] destptr (MOVLstoreconst [makeValAndOff32(0,0)] destptr mem))))
+	// result: (MOVLstoreconst [makeValAndOff(0,12)] destptr (MOVLstoreconst [makeValAndOff(0,8)] destptr (MOVLstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [makeValAndOff(0,0)] destptr mem))))
 	for {
 		if auxIntToInt64(v.AuxInt) != 16 {
 			break
@@ -11702,13 +11678,13 @@ func rewriteValue386_OpZero(v *Value) bool {
 		destptr := v_0
 		mem := v_1
 		v.reset(Op386MOVLstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 12))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 12))
 		v0 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 8))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 8))
 		v1 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
-		v1.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 4))
+		v1.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 4))
 		v2 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
-		v2.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 0))
+		v2.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 0))
 		v2.AddArg2(destptr, mem)
 		v1.AddArg2(destptr, v2)
 		v0.AddArg2(destptr, v1)
diff --git a/src/cmd/compile/internal/ssa/rewrite386splitload.go b/src/cmd/compile/internal/ssa/rewrite386splitload.go
index fff26fa77e..90b5df8ae0 100644
--- a/src/cmd/compile/internal/ssa/rewrite386splitload.go
+++ b/src/cmd/compile/internal/ssa/rewrite386splitload.go
@@ -26,7 +26,7 @@ func rewriteValue386splitload_Op386CMPBconstload(v *Value) bool {
 	b := v.Block
 	typ := &b.Func.Config.Types
 	// match: (CMPBconstload {sym} [vo] ptr mem)
-	// result: (CMPBconst (MOVBload {sym} [vo.Off32()] ptr mem) [vo.Val8()])
+	// result: (CMPBconst (MOVBload {sym} [vo.Off()] ptr mem) [vo.Val8()])
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -35,7 +35,7 @@ func rewriteValue386splitload_Op386CMPBconstload(v *Value) bool {
 		v.reset(Op386CMPBconst)
 		v.AuxInt = int8ToAuxInt(vo.Val8())
 		v0 := b.NewValue0(v.Pos, Op386MOVBload, typ.UInt8)
-		v0.AuxInt = int32ToAuxInt(vo.Off32())
+		v0.AuxInt = int32ToAuxInt(vo.Off())
 		v0.Aux = symToAux(sym)
 		v0.AddArg2(ptr, mem)
 		v.AddArg(v0)
@@ -71,16 +71,16 @@ func rewriteValue386splitload_Op386CMPLconstload(v *Value) bool {
 	b := v.Block
 	typ := &b.Func.Config.Types
 	// match: (CMPLconstload {sym} [vo] ptr mem)
-	// result: (CMPLconst (MOVLload {sym} [vo.Off32()] ptr mem) [vo.Val32()])
+	// result: (CMPLconst (MOVLload {sym} [vo.Off()] ptr mem) [vo.Val()])
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
 		ptr := v_0
 		mem := v_1
 		v.reset(Op386CMPLconst)
-		v.AuxInt = int32ToAuxInt(vo.Val32())
+		v.AuxInt = int32ToAuxInt(vo.Val())
 		v0 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32)
-		v0.AuxInt = int32ToAuxInt(vo.Off32())
+		v0.AuxInt = int32ToAuxInt(vo.Off())
 		v0.Aux = symToAux(sym)
 		v0.AddArg2(ptr, mem)
 		v.AddArg(v0)
@@ -116,7 +116,7 @@ func rewriteValue386splitload_Op386CMPWconstload(v *Value) bool {
 	b := v.Block
 	typ := &b.Func.Config.Types
 	// match: (CMPWconstload {sym} [vo] ptr mem)
-	// result: (CMPWconst (MOVWload {sym} [vo.Off32()] ptr mem) [vo.Val16()])
+	// result: (CMPWconst (MOVWload {sym} [vo.Off()] ptr mem) [vo.Val16()])
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -125,7 +125,7 @@ func rewriteValue386splitload_Op386CMPWconstload(v *Value) bool {
 		v.reset(Op386CMPWconst)
 		v.AuxInt = int16ToAuxInt(vo.Val16())
 		v0 := b.NewValue0(v.Pos, Op386MOVWload, typ.UInt16)
-		v0.AuxInt = int32ToAuxInt(vo.Off32())
+		v0.AuxInt = int32ToAuxInt(vo.Off())
 		v0.Aux = symToAux(sym)
 		v0.AddArg2(ptr, mem)
 		v.AddArg(v0)
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index 8da3b28b5c..d208624d0e 100644
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -6962,7 +6962,7 @@ func rewriteValueAMD64_OpAMD64CMPBconst(v *Value) bool {
 	}
 	// match: (CMPBconst l:(MOVBload {sym} [off] ptr mem) [c])
 	// cond: l.Uses == 1 && clobber(l)
-	// result: @l.Block (CMPBconstload {sym} [makeValAndOff32(int32(c),off)] ptr mem)
+	// result: @l.Block (CMPBconstload {sym} [makeValAndOff(int32(c),off)] ptr mem)
 	for {
 		c := auxIntToInt8(v.AuxInt)
 		l := v_0
@@ -6979,7 +6979,7 @@ func rewriteValueAMD64_OpAMD64CMPBconst(v *Value) bool {
 		b = l.Block
 		v0 := b.NewValue0(l.Pos, OpAMD64CMPBconstload, types.TypeFlags)
 		v.copyOf(v0)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), off))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v0.Aux = symToAux(sym)
 		v0.AddArg2(ptr, mem)
 		return true
@@ -7084,8 +7084,7 @@ func rewriteValueAMD64_OpAMD64CMPBload(v *Value) bool {
 		return true
 	}
 	// match: (CMPBload {sym} [off] ptr (MOVLconst [c]) mem)
-	// cond: validValAndOff(int64(int8(c)),int64(off))
-	// result: (CMPBconstload {sym} [makeValAndOff32(int32(int8(c)),off)] ptr mem)
+	// result: (CMPBconstload {sym} [makeValAndOff(int32(int8(c)),off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -7095,11 +7094,8 @@ func rewriteValueAMD64_OpAMD64CMPBload(v *Value) bool {
 		}
 		c := auxIntToInt32(v_1.AuxInt)
 		mem := v_2
-		if !(validValAndOff(int64(int8(c)), int64(off))) {
-			break
-		}
 		v.reset(OpAMD64CMPBconstload)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(int8(c)), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
@@ -7363,7 +7359,7 @@ func rewriteValueAMD64_OpAMD64CMPLconst(v *Value) bool {
 	}
 	// match: (CMPLconst l:(MOVLload {sym} [off] ptr mem) [c])
 	// cond: l.Uses == 1 && clobber(l)
-	// result: @l.Block (CMPLconstload {sym} [makeValAndOff32(c,off)] ptr mem)
+	// result: @l.Block (CMPLconstload {sym} [makeValAndOff(c,off)] ptr mem)
 	for {
 		c := auxIntToInt32(v.AuxInt)
 		l := v_0
@@ -7380,7 +7376,7 @@ func rewriteValueAMD64_OpAMD64CMPLconst(v *Value) bool {
 		b = l.Block
 		v0 := b.NewValue0(l.Pos, OpAMD64CMPLconstload, types.TypeFlags)
 		v.copyOf(v0)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(c, off))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(c, off))
 		v0.Aux = symToAux(sym)
 		v0.AddArg2(ptr, mem)
 		return true
@@ -7485,8 +7481,7 @@ func rewriteValueAMD64_OpAMD64CMPLload(v *Value) bool {
 		return true
 	}
 	// match: (CMPLload {sym} [off] ptr (MOVLconst [c]) mem)
-	// cond: validValAndOff(int64(c),int64(off))
-	// result: (CMPLconstload {sym} [makeValAndOff32(c,off)] ptr mem)
+	// result: (CMPLconstload {sym} [makeValAndOff(c,off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -7496,11 +7491,8 @@ func rewriteValueAMD64_OpAMD64CMPLload(v *Value) bool {
 		}
 		c := auxIntToInt32(v_1.AuxInt)
 		mem := v_2
-		if !(validValAndOff(int64(c), int64(off))) {
-			break
-		}
 		v.reset(OpAMD64CMPLconstload)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(c, off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(c, off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
@@ -7933,7 +7925,7 @@ func rewriteValueAMD64_OpAMD64CMPQconst(v *Value) bool {
 	}
 	// match: (CMPQconst l:(MOVQload {sym} [off] ptr mem) [c])
 	// cond: l.Uses == 1 && clobber(l)
-	// result: @l.Block (CMPQconstload {sym} [makeValAndOff32(c,off)] ptr mem)
+	// result: @l.Block (CMPQconstload {sym} [makeValAndOff(c,off)] ptr mem)
 	for {
 		c := auxIntToInt32(v.AuxInt)
 		l := v_0
@@ -7950,7 +7942,7 @@ func rewriteValueAMD64_OpAMD64CMPQconst(v *Value) bool {
 		b = l.Block
 		v0 := b.NewValue0(l.Pos, OpAMD64CMPQconstload, types.TypeFlags)
 		v.copyOf(v0)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(c, off))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(c, off))
 		v0.Aux = symToAux(sym)
 		v0.AddArg2(ptr, mem)
 		return true
@@ -8055,8 +8047,8 @@ func rewriteValueAMD64_OpAMD64CMPQload(v *Value) bool {
 		return true
 	}
 	// match: (CMPQload {sym} [off] ptr (MOVQconst [c]) mem)
-	// cond: validValAndOff(c,int64(off))
-	// result: (CMPQconstload {sym} [makeValAndOff64(c,int64(off))] ptr mem)
+	// cond: validVal(c)
+	// result: (CMPQconstload {sym} [makeValAndOff(int32(c),off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -8066,11 +8058,11 @@ func rewriteValueAMD64_OpAMD64CMPQload(v *Value) bool {
 		}
 		c := auxIntToInt64(v_1.AuxInt)
 		mem := v_2
-		if !(validValAndOff(c, int64(off))) {
+		if !(validVal(c)) {
 			break
 		}
 		v.reset(OpAMD64CMPQconstload)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff64(c, int64(off)))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
@@ -8319,7 +8311,7 @@ func rewriteValueAMD64_OpAMD64CMPWconst(v *Value) bool {
 	}
 	// match: (CMPWconst l:(MOVWload {sym} [off] ptr mem) [c])
 	// cond: l.Uses == 1 && clobber(l)
-	// result: @l.Block (CMPWconstload {sym} [makeValAndOff32(int32(c),off)] ptr mem)
+	// result: @l.Block (CMPWconstload {sym} [makeValAndOff(int32(c),off)] ptr mem)
 	for {
 		c := auxIntToInt16(v.AuxInt)
 		l := v_0
@@ -8336,7 +8328,7 @@ func rewriteValueAMD64_OpAMD64CMPWconst(v *Value) bool {
 		b = l.Block
 		v0 := b.NewValue0(l.Pos, OpAMD64CMPWconstload, types.TypeFlags)
 		v.copyOf(v0)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), off))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v0.Aux = symToAux(sym)
 		v0.AddArg2(ptr, mem)
 		return true
@@ -8441,8 +8433,7 @@ func rewriteValueAMD64_OpAMD64CMPWload(v *Value) bool {
 		return true
 	}
 	// match: (CMPWload {sym} [off] ptr (MOVLconst [c]) mem)
-	// cond: validValAndOff(int64(int16(c)),int64(off))
-	// result: (CMPWconstload {sym} [makeValAndOff32(int32(int16(c)),off)] ptr mem)
+	// result: (CMPWconstload {sym} [makeValAndOff(int32(int16(c)),off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -8452,11 +8443,8 @@ func rewriteValueAMD64_OpAMD64CMPWload(v *Value) bool {
 		}
 		c := auxIntToInt32(v_1.AuxInt)
 		mem := v_2
-		if !(validValAndOff(int64(int16(c)), int64(off))) {
-			break
-		}
 		v.reset(OpAMD64CMPWconstload)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(int16(c)), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int16(c)), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
@@ -10600,7 +10588,7 @@ func rewriteValueAMD64_OpAMD64MOVBstore(v *Value) bool {
 		return true
 	}
 	// match: (MOVBstore [off] {sym} ptr (MOVLconst [c]) mem)
-	// result: (MOVBstoreconst [makeValAndOff32(int32(int8(c)),off)] {sym} ptr mem)
+	// result: (MOVBstoreconst [makeValAndOff(int32(int8(c)),off)] {sym} ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -10611,13 +10599,13 @@ func rewriteValueAMD64_OpAMD64MOVBstore(v *Value) bool {
 		c := auxIntToInt32(v_1.AuxInt)
 		mem := v_2
 		v.reset(OpAMD64MOVBstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(int8(c)), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
 	}
 	// match: (MOVBstore [off] {sym} ptr (MOVQconst [c]) mem)
-	// result: (MOVBstoreconst [makeValAndOff32(int32(int8(c)),off)] {sym} ptr mem)
+	// result: (MOVBstoreconst [makeValAndOff(int32(int8(c)),off)] {sym} ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -10628,7 +10616,7 @@ func rewriteValueAMD64_OpAMD64MOVBstore(v *Value) bool {
 		c := auxIntToInt64(v_1.AuxInt)
 		mem := v_2
 		v.reset(OpAMD64MOVBstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(int8(c)), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
@@ -11601,7 +11589,7 @@ func rewriteValueAMD64_OpAMD64MOVBstoreconst(v *Value) bool {
 	}
 	// match: (MOVBstoreconst [c] {s} p x:(MOVBstoreconst [a] {s} p mem))
 	// cond: x.Uses == 1 && a.Off() + 1 == c.Off() && clobber(x)
-	// result: (MOVWstoreconst [makeValAndOff64(a.Val()&0xff | c.Val()<<8, a.Off())] {s} p mem)
+	// result: (MOVWstoreconst [makeValAndOff(a.Val()&0xff | c.Val()<<8, a.Off())] {s} p mem)
 	for {
 		c := auxIntToValAndOff(v.AuxInt)
 		s := auxToSym(v.Aux)
@@ -11619,14 +11607,14 @@ func rewriteValueAMD64_OpAMD64MOVBstoreconst(v *Value) bool {
 			break
 		}
 		v.reset(OpAMD64MOVWstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff64(a.Val()&0xff|c.Val()<<8, a.Off()))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(a.Val()&0xff|c.Val()<<8, a.Off()))
 		v.Aux = symToAux(s)
 		v.AddArg2(p, mem)
 		return true
 	}
 	// match: (MOVBstoreconst [a] {s} p x:(MOVBstoreconst [c] {s} p mem))
 	// cond: x.Uses == 1 && a.Off() + 1 == c.Off() && clobber(x)
-	// result: (MOVWstoreconst [makeValAndOff64(a.Val()&0xff | c.Val()<<8, a.Off())] {s} p mem)
+	// result: (MOVWstoreconst [makeValAndOff(a.Val()&0xff | c.Val()<<8, a.Off())] {s} p mem)
 	for {
 		a := auxIntToValAndOff(v.AuxInt)
 		s := auxToSym(v.Aux)
@@ -11644,7 +11632,7 @@ func rewriteValueAMD64_OpAMD64MOVBstoreconst(v *Value) bool {
 			break
 		}
 		v.reset(OpAMD64MOVWstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff64(a.Val()&0xff|c.Val()<<8, a.Off()))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(a.Val()&0xff|c.Val()<<8, a.Off()))
 		v.Aux = symToAux(s)
 		v.AddArg2(p, mem)
 		return true
@@ -12258,7 +12246,7 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
 		return true
 	}
 	// match: (MOVLstore [off] {sym} ptr (MOVLconst [c]) mem)
-	// result: (MOVLstoreconst [makeValAndOff32(int32(c),off)] {sym} ptr mem)
+	// result: (MOVLstoreconst [makeValAndOff(int32(c),off)] {sym} ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -12269,13 +12257,13 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
 		c := auxIntToInt32(v_1.AuxInt)
 		mem := v_2
 		v.reset(OpAMD64MOVLstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
 	}
 	// match: (MOVLstore [off] {sym} ptr (MOVQconst [c]) mem)
-	// result: (MOVLstoreconst [makeValAndOff32(int32(c),off)] {sym} ptr mem)
+	// result: (MOVLstoreconst [makeValAndOff(int32(c),off)] {sym} ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -12286,7 +12274,7 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
 		c := auxIntToInt64(v_1.AuxInt)
 		mem := v_2
 		v.reset(OpAMD64MOVLstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
@@ -12842,8 +12830,8 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
 		return true
 	}
 	// match: (MOVLstore [off] {sym} ptr a:(ADDLconst [c] l:(MOVLload [off] {sym} ptr2 mem)) mem)
-	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c),int64(off)) && clobber(l, a)
-	// result: (ADDLconstmodify {sym} [makeValAndOff32(int32(c),off)] ptr mem)
+	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
+	// result: (ADDLconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -12859,18 +12847,18 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
 		}
 		mem := l.Args[1]
 		ptr2 := l.Args[0]
-		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c), int64(off)) && clobber(l, a)) {
+		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)) {
 			break
 		}
 		v.reset(OpAMD64ADDLconstmodify)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
 	}
 	// match: (MOVLstore [off] {sym} ptr a:(ANDLconst [c] l:(MOVLload [off] {sym} ptr2 mem)) mem)
-	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c),int64(off)) && clobber(l, a)
-	// result: (ANDLconstmodify {sym} [makeValAndOff32(int32(c),off)] ptr mem)
+	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
+	// result: (ANDLconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -12886,18 +12874,18 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
 		}
 		mem := l.Args[1]
 		ptr2 := l.Args[0]
-		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c), int64(off)) && clobber(l, a)) {
+		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)) {
 			break
 		}
 		v.reset(OpAMD64ANDLconstmodify)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
 	}
 	// match: (MOVLstore [off] {sym} ptr a:(ORLconst [c] l:(MOVLload [off] {sym} ptr2 mem)) mem)
-	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c),int64(off)) && clobber(l, a)
-	// result: (ORLconstmodify {sym} [makeValAndOff32(int32(c),off)] ptr mem)
+	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
+	// result: (ORLconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -12913,18 +12901,18 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
 		}
 		mem := l.Args[1]
 		ptr2 := l.Args[0]
-		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c), int64(off)) && clobber(l, a)) {
+		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)) {
 			break
 		}
 		v.reset(OpAMD64ORLconstmodify)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
 	}
 	// match: (MOVLstore [off] {sym} ptr a:(XORLconst [c] l:(MOVLload [off] {sym} ptr2 mem)) mem)
-	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c),int64(off)) && clobber(l, a)
-	// result: (XORLconstmodify {sym} [makeValAndOff32(int32(c),off)] ptr mem)
+	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
+	// result: (XORLconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -12940,18 +12928,18 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
 		}
 		mem := l.Args[1]
 		ptr2 := l.Args[0]
-		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c), int64(off)) && clobber(l, a)) {
+		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)) {
 			break
 		}
 		v.reset(OpAMD64XORLconstmodify)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
 	}
 	// match: (MOVLstore [off] {sym} ptr a:(BTCLconst [c] l:(MOVLload [off] {sym} ptr2 mem)) mem)
-	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c),int64(off)) && clobber(l, a)
-	// result: (BTCLconstmodify {sym} [makeValAndOff32(int32(c),off)] ptr mem)
+	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
+	// result: (BTCLconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -12967,18 +12955,18 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
 		}
 		mem := l.Args[1]
 		ptr2 := l.Args[0]
-		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c), int64(off)) && clobber(l, a)) {
+		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)) {
 			break
 		}
 		v.reset(OpAMD64BTCLconstmodify)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
 	}
 	// match: (MOVLstore [off] {sym} ptr a:(BTRLconst [c] l:(MOVLload [off] {sym} ptr2 mem)) mem)
-	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c),int64(off)) && clobber(l, a)
-	// result: (BTRLconstmodify {sym} [makeValAndOff32(int32(c),off)] ptr mem)
+	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
+	// result: (BTRLconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -12994,18 +12982,18 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
 		}
 		mem := l.Args[1]
 		ptr2 := l.Args[0]
-		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c), int64(off)) && clobber(l, a)) {
+		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)) {
 			break
 		}
 		v.reset(OpAMD64BTRLconstmodify)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
 	}
 	// match: (MOVLstore [off] {sym} ptr a:(BTSLconst [c] l:(MOVLload [off] {sym} ptr2 mem)) mem)
-	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c),int64(off)) && clobber(l, a)
-	// result: (BTSLconstmodify {sym} [makeValAndOff32(int32(c),off)] ptr mem)
+	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
+	// result: (BTSLconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -13021,11 +13009,11 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
 		}
 		mem := l.Args[1]
 		ptr2 := l.Args[0]
-		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c), int64(off)) && clobber(l, a)) {
+		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)) {
 			break
 		}
 		v.reset(OpAMD64BTSLconstmodify)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
@@ -13099,7 +13087,7 @@ func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value) bool {
 	}
 	// match: (MOVLstoreconst [c] {s} p x:(MOVLstoreconst [a] {s} p mem))
 	// cond: x.Uses == 1 && a.Off() + 4 == c.Off() && clobber(x)
-	// result: (MOVQstore [a.Off32()] {s} p (MOVQconst [a.Val()&0xffffffff | c.Val()<<32]) mem)
+	// result: (MOVQstore [a.Off()] {s} p (MOVQconst [a.Val64()&0xffffffff | c.Val64()<<32]) mem)
 	for {
 		c := auxIntToValAndOff(v.AuxInt)
 		s := auxToSym(v.Aux)
@@ -13117,16 +13105,16 @@ func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value) bool {
 			break
 		}
 		v.reset(OpAMD64MOVQstore)
-		v.AuxInt = int32ToAuxInt(a.Off32())
+		v.AuxInt = int32ToAuxInt(a.Off())
 		v.Aux = symToAux(s)
 		v0 := b.NewValue0(x.Pos, OpAMD64MOVQconst, typ.UInt64)
-		v0.AuxInt = int64ToAuxInt(a.Val()&0xffffffff | c.Val()<<32)
+		v0.AuxInt = int64ToAuxInt(a.Val64()&0xffffffff | c.Val64()<<32)
 		v.AddArg3(p, v0, mem)
 		return true
 	}
 	// match: (MOVLstoreconst [a] {s} p x:(MOVLstoreconst [c] {s} p mem))
 	// cond: x.Uses == 1 && a.Off() + 4 == c.Off() && clobber(x)
-	// result: (MOVQstore [a.Off32()] {s} p (MOVQconst [a.Val()&0xffffffff | c.Val()<<32]) mem)
+	// result: (MOVQstore [a.Off()] {s} p (MOVQconst [a.Val64()&0xffffffff | c.Val64()<<32]) mem)
 	for {
 		a := auxIntToValAndOff(v.AuxInt)
 		s := auxToSym(v.Aux)
@@ -13144,10 +13132,10 @@ func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value) bool {
 			break
 		}
 		v.reset(OpAMD64MOVQstore)
-		v.AuxInt = int32ToAuxInt(a.Off32())
+		v.AuxInt = int32ToAuxInt(a.Off())
 		v.Aux = symToAux(s)
 		v0 := b.NewValue0(x.Pos, OpAMD64MOVQconst, typ.UInt64)
-		v0.AuxInt = int64ToAuxInt(a.Val()&0xffffffff | c.Val()<<32)
+		v0.AuxInt = int64ToAuxInt(a.Val64()&0xffffffff | c.Val64()<<32)
 		v.AddArg3(p, v0, mem)
 		return true
 	}
@@ -13603,7 +13591,7 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
 	}
 	// match: (MOVQstore [off] {sym} ptr (MOVQconst [c]) mem)
 	// cond: validVal(c)
-	// result: (MOVQstoreconst [makeValAndOff32(int32(c),off)] {sym} ptr mem)
+	// result: (MOVQstoreconst [makeValAndOff(int32(c),off)] {sym} ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -13617,7 +13605,7 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
 			break
 		}
 		v.reset(OpAMD64MOVQstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
@@ -14023,8 +14011,8 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
 		return true
 	}
 	// match: (MOVQstore [off] {sym} ptr a:(ADDQconst [c] l:(MOVQload [off] {sym} ptr2 mem)) mem)
-	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c),int64(off)) && clobber(l, a)
-	// result: (ADDQconstmodify {sym} [makeValAndOff32(int32(c),off)] ptr mem)
+	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
+	// result: (ADDQconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -14040,18 +14028,18 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
 		}
 		mem := l.Args[1]
 		ptr2 := l.Args[0]
-		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c), int64(off)) && clobber(l, a)) {
+		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)) {
 			break
 		}
 		v.reset(OpAMD64ADDQconstmodify)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
 	}
 	// match: (MOVQstore [off] {sym} ptr a:(ANDQconst [c] l:(MOVQload [off] {sym} ptr2 mem)) mem)
-	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c),int64(off)) && clobber(l, a)
-	// result: (ANDQconstmodify {sym} [makeValAndOff32(int32(c),off)] ptr mem)
+	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
+	// result: (ANDQconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -14067,18 +14055,18 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
 		}
 		mem := l.Args[1]
 		ptr2 := l.Args[0]
-		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c), int64(off)) && clobber(l, a)) {
+		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)) {
 			break
 		}
 		v.reset(OpAMD64ANDQconstmodify)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
 	}
 	// match: (MOVQstore [off] {sym} ptr a:(ORQconst [c] l:(MOVQload [off] {sym} ptr2 mem)) mem)
-	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c),int64(off)) && clobber(l, a)
-	// result: (ORQconstmodify {sym} [makeValAndOff32(int32(c),off)] ptr mem)
+	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
+	// result: (ORQconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -14094,18 +14082,18 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
 		}
 		mem := l.Args[1]
 		ptr2 := l.Args[0]
-		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c), int64(off)) && clobber(l, a)) {
+		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)) {
 			break
 		}
 		v.reset(OpAMD64ORQconstmodify)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
 	}
 	// match: (MOVQstore [off] {sym} ptr a:(XORQconst [c] l:(MOVQload [off] {sym} ptr2 mem)) mem)
-	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c),int64(off)) && clobber(l, a)
-	// result: (XORQconstmodify {sym} [makeValAndOff32(int32(c),off)] ptr mem)
+	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
+	// result: (XORQconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -14121,18 +14109,18 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
 		}
 		mem := l.Args[1]
 		ptr2 := l.Args[0]
-		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c), int64(off)) && clobber(l, a)) {
+		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)) {
 			break
 		}
 		v.reset(OpAMD64XORQconstmodify)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
 	}
 	// match: (MOVQstore [off] {sym} ptr a:(BTCQconst [c] l:(MOVQload [off] {sym} ptr2 mem)) mem)
-	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c),int64(off)) && clobber(l, a)
-	// result: (BTCQconstmodify {sym} [makeValAndOff32(int32(c),off)] ptr mem)
+	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
+	// result: (BTCQconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -14148,18 +14136,18 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
 		}
 		mem := l.Args[1]
 		ptr2 := l.Args[0]
-		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c), int64(off)) && clobber(l, a)) {
+		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)) {
 			break
 		}
 		v.reset(OpAMD64BTCQconstmodify)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
 	}
 	// match: (MOVQstore [off] {sym} ptr a:(BTRQconst [c] l:(MOVQload [off] {sym} ptr2 mem)) mem)
-	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c),int64(off)) && clobber(l, a)
-	// result: (BTRQconstmodify {sym} [makeValAndOff32(int32(c),off)] ptr mem)
+	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
+	// result: (BTRQconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -14175,18 +14163,18 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
 		}
 		mem := l.Args[1]
 		ptr2 := l.Args[0]
-		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c), int64(off)) && clobber(l, a)) {
+		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)) {
 			break
 		}
 		v.reset(OpAMD64BTRQconstmodify)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
 	}
 	// match: (MOVQstore [off] {sym} ptr a:(BTSQconst [c] l:(MOVQload [off] {sym} ptr2 mem)) mem)
-	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c),int64(off)) && clobber(l, a)
-	// result: (BTSQconstmodify {sym} [makeValAndOff32(int32(c),off)] ptr mem)
+	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
+	// result: (BTSQconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -14202,11 +14190,11 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
 		}
 		mem := l.Args[1]
 		ptr2 := l.Args[0]
-		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(int64(c), int64(off)) && clobber(l, a)) {
+		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)) {
 			break
 		}
 		v.reset(OpAMD64BTSQconstmodify)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
@@ -14280,7 +14268,7 @@ func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *Value) bool {
 	}
 	// match: (MOVQstoreconst [c] {s} p x:(MOVQstoreconst [c2] {s} p mem))
 	// cond: config.useSSE && x.Uses == 1 && c2.Off() + 8 == c.Off() && c.Val() == 0 && c2.Val() == 0 && clobber(x)
-	// result: (MOVOstorezero [c2.Off32()] {s} p mem)
+	// result: (MOVOstorezero [c2.Off()] {s} p mem)
 	for {
 		c := auxIntToValAndOff(v.AuxInt)
 		s := auxToSym(v.Aux)
@@ -14298,7 +14286,7 @@ func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *Value) bool {
 			break
 		}
 		v.reset(OpAMD64MOVOstorezero)
-		v.AuxInt = int32ToAuxInt(c2.Off32())
+		v.AuxInt = int32ToAuxInt(c2.Off())
 		v.Aux = symToAux(s)
 		v.AddArg2(p, mem)
 		return true
@@ -15085,7 +15073,7 @@ func rewriteValueAMD64_OpAMD64MOVWstore(v *Value) bool {
 		return true
 	}
 	// match: (MOVWstore [off] {sym} ptr (MOVLconst [c]) mem)
-	// result: (MOVWstoreconst [makeValAndOff32(int32(int16(c)),off)] {sym} ptr mem)
+	// result: (MOVWstoreconst [makeValAndOff(int32(int16(c)),off)] {sym} ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -15096,13 +15084,13 @@ func rewriteValueAMD64_OpAMD64MOVWstore(v *Value) bool {
 		c := auxIntToInt32(v_1.AuxInt)
 		mem := v_2
 		v.reset(OpAMD64MOVWstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(int16(c)), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int16(c)), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
 	}
 	// match: (MOVWstore [off] {sym} ptr (MOVQconst [c]) mem)
-	// result: (MOVWstoreconst [makeValAndOff32(int32(int16(c)),off)] {sym} ptr mem)
+	// result: (MOVWstoreconst [makeValAndOff(int32(int16(c)),off)] {sym} ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -15113,7 +15101,7 @@ func rewriteValueAMD64_OpAMD64MOVWstore(v *Value) bool {
 		c := auxIntToInt64(v_1.AuxInt)
 		mem := v_2
 		v.reset(OpAMD64MOVWstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(int16(c)), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int16(c)), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
@@ -15495,7 +15483,7 @@ func rewriteValueAMD64_OpAMD64MOVWstoreconst(v *Value) bool {
 	}
 	// match: (MOVWstoreconst [c] {s} p x:(MOVWstoreconst [a] {s} p mem))
 	// cond: x.Uses == 1 && a.Off() + 2 == c.Off() && clobber(x)
-	// result: (MOVLstoreconst [makeValAndOff64(a.Val()&0xffff | c.Val()<<16, a.Off())] {s} p mem)
+	// result: (MOVLstoreconst [makeValAndOff(a.Val()&0xffff | c.Val()<<16, a.Off())] {s} p mem)
 	for {
 		c := auxIntToValAndOff(v.AuxInt)
 		s := auxToSym(v.Aux)
@@ -15513,14 +15501,14 @@ func rewriteValueAMD64_OpAMD64MOVWstoreconst(v *Value) bool {
 			break
 		}
 		v.reset(OpAMD64MOVLstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff64(a.Val()&0xffff|c.Val()<<16, a.Off()))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(a.Val()&0xffff|c.Val()<<16, a.Off()))
 		v.Aux = symToAux(s)
 		v.AddArg2(p, mem)
 		return true
 	}
 	// match: (MOVWstoreconst [a] {s} p x:(MOVWstoreconst [c] {s} p mem))
 	// cond: x.Uses == 1 && a.Off() + 2 == c.Off() && clobber(x)
-	// result: (MOVLstoreconst [makeValAndOff64(a.Val()&0xffff | c.Val()<<16, a.Off())] {s} p mem)
+	// result: (MOVLstoreconst [makeValAndOff(a.Val()&0xffff | c.Val()<<16, a.Off())] {s} p mem)
 	for {
 		a := auxIntToValAndOff(v.AuxInt)
 		s := auxToSym(v.Aux)
@@ -15538,7 +15526,7 @@ func rewriteValueAMD64_OpAMD64MOVWstoreconst(v *Value) bool {
 			break
 		}
 		v.reset(OpAMD64MOVLstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff64(a.Val()&0xffff|c.Val()<<16, a.Off()))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(a.Val()&0xffff|c.Val()<<16, a.Off()))
 		v.Aux = symToAux(s)
 		v.AddArg2(p, mem)
 		return true
@@ -27100,8 +27088,8 @@ func rewriteValueAMD64_OpAMD64TESTB(v *Value) bool {
 		break
 	}
 	// match: (TESTB l:(MOVBload {sym} [off] ptr mem) l2)
-	// cond: l == l2 && l.Uses == 2 && validValAndOff(0, int64(off)) && clobber(l)
-	// result: @l.Block (CMPBconstload {sym} [makeValAndOff64(0, int64(off))] ptr mem)
+	// cond: l == l2 && l.Uses == 2 && clobber(l)
+	// result: @l.Block (CMPBconstload {sym} [makeValAndOff(0, off)] ptr mem)
 	for {
 		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 			l := v_0
@@ -27113,13 +27101,13 @@ func rewriteValueAMD64_OpAMD64TESTB(v *Value) bool {
 			mem := l.Args[1]
 			ptr := l.Args[0]
 			l2 := v_1
-			if !(l == l2 && l.Uses == 2 && validValAndOff(0, int64(off)) && clobber(l)) {
+			if !(l == l2 && l.Uses == 2 && clobber(l)) {
 				continue
 			}
 			b = l.Block
 			v0 := b.NewValue0(l.Pos, OpAMD64CMPBconstload, types.TypeFlags)
 			v.copyOf(v0)
-			v0.AuxInt = valAndOffToAuxInt(makeValAndOff64(0, int64(off)))
+			v0.AuxInt = valAndOffToAuxInt(makeValAndOff(0, off))
 			v0.Aux = symToAux(sym)
 			v0.AddArg2(ptr, mem)
 			return true
@@ -27168,8 +27156,8 @@ func rewriteValueAMD64_OpAMD64TESTL(v *Value) bool {
 		break
 	}
 	// match: (TESTL l:(MOVLload {sym} [off] ptr mem) l2)
-	// cond: l == l2 && l.Uses == 2 && validValAndOff(0, int64(off)) && clobber(l)
-	// result: @l.Block (CMPLconstload {sym} [makeValAndOff64(0, int64(off))] ptr mem)
+	// cond: l == l2 && l.Uses == 2 && clobber(l)
+	// result: @l.Block (CMPLconstload {sym} [makeValAndOff(0, off)] ptr mem)
 	for {
 		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 			l := v_0
@@ -27181,13 +27169,13 @@ func rewriteValueAMD64_OpAMD64TESTL(v *Value) bool {
 			mem := l.Args[1]
 			ptr := l.Args[0]
 			l2 := v_1
-			if !(l == l2 && l.Uses == 2 && validValAndOff(0, int64(off)) && clobber(l)) {
+			if !(l == l2 && l.Uses == 2 && clobber(l)) {
 				continue
 			}
 			b = l.Block
 			v0 := b.NewValue0(l.Pos, OpAMD64CMPLconstload, types.TypeFlags)
 			v.copyOf(v0)
-			v0.AuxInt = valAndOffToAuxInt(makeValAndOff64(0, int64(off)))
+			v0.AuxInt = valAndOffToAuxInt(makeValAndOff(0, off))
 			v0.Aux = symToAux(sym)
 			v0.AddArg2(ptr, mem)
 			return true
@@ -27300,8 +27288,8 @@ func rewriteValueAMD64_OpAMD64TESTQ(v *Value) bool {
 		break
 	}
 	// match: (TESTQ l:(MOVQload {sym} [off] ptr mem) l2)
-	// cond: l == l2 && l.Uses == 2 && validValAndOff(0, int64(off)) && clobber(l)
-	// result: @l.Block (CMPQconstload {sym} [makeValAndOff64(0, int64(off))] ptr mem)
+	// cond: l == l2 && l.Uses == 2 && clobber(l)
+	// result: @l.Block (CMPQconstload {sym} [makeValAndOff(0, off)] ptr mem)
 	for {
 		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 			l := v_0
@@ -27313,13 +27301,13 @@ func rewriteValueAMD64_OpAMD64TESTQ(v *Value) bool {
 			mem := l.Args[1]
 			ptr := l.Args[0]
 			l2 := v_1
-			if !(l == l2 && l.Uses == 2 && validValAndOff(0, int64(off)) && clobber(l)) {
+			if !(l == l2 && l.Uses == 2 && clobber(l)) {
 				continue
 			}
 			b = l.Block
 			v0 := b.NewValue0(l.Pos, OpAMD64CMPQconstload, types.TypeFlags)
 			v.copyOf(v0)
-			v0.AuxInt = valAndOffToAuxInt(makeValAndOff64(0, int64(off)))
+			v0.AuxInt = valAndOffToAuxInt(makeValAndOff(0, off))
 			v0.Aux = symToAux(sym)
 			v0.AddArg2(ptr, mem)
 			return true
@@ -27440,8 +27428,8 @@ func rewriteValueAMD64_OpAMD64TESTW(v *Value) bool {
 		break
 	}
 	// match: (TESTW l:(MOVWload {sym} [off] ptr mem) l2)
-	// cond: l == l2 && l.Uses == 2 && validValAndOff(0, int64(off)) && clobber(l)
-	// result: @l.Block (CMPWconstload {sym} [makeValAndOff64(0, int64(off))] ptr mem)
+	// cond: l == l2 && l.Uses == 2 && clobber(l)
+	// result: @l.Block (CMPWconstload {sym} [makeValAndOff(0, off)] ptr mem)
 	for {
 		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 			l := v_0
@@ -27453,13 +27441,13 @@ func rewriteValueAMD64_OpAMD64TESTW(v *Value) bool {
 			mem := l.Args[1]
 			ptr := l.Args[0]
 			l2 := v_1
-			if !(l == l2 && l.Uses == 2 && validValAndOff(0, int64(off)) && clobber(l)) {
+			if !(l == l2 && l.Uses == 2 && clobber(l)) {
 				continue
 			}
 			b = l.Block
 			v0 := b.NewValue0(l.Pos, OpAMD64CMPWconstload, types.TypeFlags)
 			v.copyOf(v0)
-			v0.AuxInt = valAndOffToAuxInt(makeValAndOff64(0, int64(off)))
+			v0.AuxInt = valAndOffToAuxInt(makeValAndOff(0, off))
 			v0.Aux = symToAux(sym)
 			v0.AddArg2(ptr, mem)
 			return true
@@ -34060,7 +34048,7 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 		return true
 	}
 	// match: (Zero [1] destptr mem)
-	// result: (MOVBstoreconst [makeValAndOff32(0,0)] destptr mem)
+	// result: (MOVBstoreconst [makeValAndOff(0,0)] destptr mem)
 	for {
 		if auxIntToInt64(v.AuxInt) != 1 {
 			break
@@ -34068,12 +34056,12 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 		destptr := v_0
 		mem := v_1
 		v.reset(OpAMD64MOVBstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 0))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 0))
 		v.AddArg2(destptr, mem)
 		return true
 	}
 	// match: (Zero [2] destptr mem)
-	// result: (MOVWstoreconst [makeValAndOff32(0,0)] destptr mem)
+	// result: (MOVWstoreconst [makeValAndOff(0,0)] destptr mem)
 	for {
 		if auxIntToInt64(v.AuxInt) != 2 {
 			break
@@ -34081,12 +34069,12 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 		destptr := v_0
 		mem := v_1
 		v.reset(OpAMD64MOVWstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 0))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 0))
 		v.AddArg2(destptr, mem)
 		return true
 	}
 	// match: (Zero [4] destptr mem)
-	// result: (MOVLstoreconst [makeValAndOff32(0,0)] destptr mem)
+	// result: (MOVLstoreconst [makeValAndOff(0,0)] destptr mem)
 	for {
 		if auxIntToInt64(v.AuxInt) != 4 {
 			break
@@ -34094,12 +34082,12 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 		destptr := v_0
 		mem := v_1
 		v.reset(OpAMD64MOVLstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 0))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 0))
 		v.AddArg2(destptr, mem)
 		return true
 	}
 	// match: (Zero [8] destptr mem)
-	// result: (MOVQstoreconst [makeValAndOff32(0,0)] destptr mem)
+	// result: (MOVQstoreconst [makeValAndOff(0,0)] destptr mem)
 	for {
 		if auxIntToInt64(v.AuxInt) != 8 {
 			break
@@ -34107,12 +34095,12 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 		destptr := v_0
 		mem := v_1
 		v.reset(OpAMD64MOVQstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 0))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 0))
 		v.AddArg2(destptr, mem)
 		return true
 	}
 	// match: (Zero [3] destptr mem)
-	// result: (MOVBstoreconst [makeValAndOff32(0,2)] destptr (MOVWstoreconst [makeValAndOff32(0,0)] destptr mem))
+	// result: (MOVBstoreconst [makeValAndOff(0,2)] destptr (MOVWstoreconst [makeValAndOff(0,0)] destptr mem))
 	for {
 		if auxIntToInt64(v.AuxInt) != 3 {
 			break
@@ -34120,15 +34108,15 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 		destptr := v_0
 		mem := v_1
 		v.reset(OpAMD64MOVBstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 2))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 2))
 		v0 := b.NewValue0(v.Pos, OpAMD64MOVWstoreconst, types.TypeMem)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 0))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 0))
 		v0.AddArg2(destptr, mem)
 		v.AddArg2(destptr, v0)
 		return true
 	}
 	// match: (Zero [5] destptr mem)
-	// result: (MOVBstoreconst [makeValAndOff32(0,4)] destptr (MOVLstoreconst [makeValAndOff32(0,0)] destptr mem))
+	// result: (MOVBstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [makeValAndOff(0,0)] destptr mem))
 	for {
 		if auxIntToInt64(v.AuxInt) != 5 {
 			break
@@ -34136,15 +34124,15 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 		destptr := v_0
 		mem := v_1
 		v.reset(OpAMD64MOVBstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 4))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 4))
 		v0 := b.NewValue0(v.Pos, OpAMD64MOVLstoreconst, types.TypeMem)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 0))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 0))
 		v0.AddArg2(destptr, mem)
 		v.AddArg2(destptr, v0)
 		return true
 	}
 	// match: (Zero [6] destptr mem)
-	// result: (MOVWstoreconst [makeValAndOff32(0,4)] destptr (MOVLstoreconst [makeValAndOff32(0,0)] destptr mem))
+	// result: (MOVWstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [makeValAndOff(0,0)] destptr mem))
 	for {
 		if auxIntToInt64(v.AuxInt) != 6 {
 			break
@@ -34152,15 +34140,15 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 		destptr := v_0
 		mem := v_1
 		v.reset(OpAMD64MOVWstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 4))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 4))
 		v0 := b.NewValue0(v.Pos, OpAMD64MOVLstoreconst, types.TypeMem)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 0))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 0))
 		v0.AddArg2(destptr, mem)
 		v.AddArg2(destptr, v0)
 		return true
 	}
 	// match: (Zero [7] destptr mem)
-	// result: (MOVLstoreconst [makeValAndOff32(0,3)] destptr (MOVLstoreconst [makeValAndOff32(0,0)] destptr mem))
+	// result: (MOVLstoreconst [makeValAndOff(0,3)] destptr (MOVLstoreconst [makeValAndOff(0,0)] destptr mem))
 	for {
 		if auxIntToInt64(v.AuxInt) != 7 {
 			break
@@ -34168,16 +34156,16 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 		destptr := v_0
 		mem := v_1
 		v.reset(OpAMD64MOVLstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 3))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 3))
 		v0 := b.NewValue0(v.Pos, OpAMD64MOVLstoreconst, types.TypeMem)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 0))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 0))
 		v0.AddArg2(destptr, mem)
 		v.AddArg2(destptr, v0)
 		return true
 	}
 	// match: (Zero [s] destptr mem)
 	// cond: s%8 != 0 && s > 8 && !config.useSSE
-	// result: (Zero [s-s%8] (OffPtr <destptr.Type> destptr [s%8]) (MOVQstoreconst [makeValAndOff32(0,0)] destptr mem))
+	// result: (Zero [s-s%8] (OffPtr <destptr.Type> destptr [s%8]) (MOVQstoreconst [makeValAndOff(0,0)] destptr mem))
 	for {
 		s := auxIntToInt64(v.AuxInt)
 		destptr := v_0
@@ -34191,14 +34179,14 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 		v0.AuxInt = int64ToAuxInt(s % 8)
 		v0.AddArg(destptr)
 		v1 := b.NewValue0(v.Pos, OpAMD64MOVQstoreconst, types.TypeMem)
-		v1.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 0))
+		v1.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 0))
 		v1.AddArg2(destptr, mem)
 		v.AddArg2(v0, v1)
 		return true
 	}
 	// match: (Zero [16] destptr mem)
 	// cond: !config.useSSE
-	// result: (MOVQstoreconst [makeValAndOff32(0,8)] destptr (MOVQstoreconst [makeValAndOff32(0,0)] destptr mem))
+	// result: (MOVQstoreconst [makeValAndOff(0,8)] destptr (MOVQstoreconst [makeValAndOff(0,0)] destptr mem))
 	for {
 		if auxIntToInt64(v.AuxInt) != 16 {
 			break
@@ -34209,16 +34197,16 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 			break
 		}
 		v.reset(OpAMD64MOVQstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 8))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 8))
 		v0 := b.NewValue0(v.Pos, OpAMD64MOVQstoreconst, types.TypeMem)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 0))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 0))
 		v0.AddArg2(destptr, mem)
 		v.AddArg2(destptr, v0)
 		return true
 	}
 	// match: (Zero [24] destptr mem)
 	// cond: !config.useSSE
-	// result: (MOVQstoreconst [makeValAndOff32(0,16)] destptr (MOVQstoreconst [makeValAndOff32(0,8)] destptr (MOVQstoreconst [makeValAndOff32(0,0)] destptr mem)))
+	// result: (MOVQstoreconst [makeValAndOff(0,16)] destptr (MOVQstoreconst [makeValAndOff(0,8)] destptr (MOVQstoreconst [makeValAndOff(0,0)] destptr mem)))
 	for {
 		if auxIntToInt64(v.AuxInt) != 24 {
 			break
@@ -34229,11 +34217,11 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 			break
 		}
 		v.reset(OpAMD64MOVQstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 16))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 16))
 		v0 := b.NewValue0(v.Pos, OpAMD64MOVQstoreconst, types.TypeMem)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 8))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 8))
 		v1 := b.NewValue0(v.Pos, OpAMD64MOVQstoreconst, types.TypeMem)
-		v1.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 0))
+		v1.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 0))
 		v1.AddArg2(destptr, mem)
 		v0.AddArg2(destptr, v1)
 		v.AddArg2(destptr, v0)
@@ -34241,7 +34229,7 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 	}
 	// match: (Zero [32] destptr mem)
 	// cond: !config.useSSE
-	// result: (MOVQstoreconst [makeValAndOff32(0,24)] destptr (MOVQstoreconst [makeValAndOff32(0,16)] destptr (MOVQstoreconst [makeValAndOff32(0,8)] destptr (MOVQstoreconst [makeValAndOff32(0,0)] destptr mem))))
+	// result: (MOVQstoreconst [makeValAndOff(0,24)] destptr (MOVQstoreconst [makeValAndOff(0,16)] destptr (MOVQstoreconst [makeValAndOff(0,8)] destptr (MOVQstoreconst [makeValAndOff(0,0)] destptr mem))))
 	for {
 		if auxIntToInt64(v.AuxInt) != 32 {
 			break
@@ -34252,13 +34240,13 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 			break
 		}
 		v.reset(OpAMD64MOVQstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 24))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 24))
 		v0 := b.NewValue0(v.Pos, OpAMD64MOVQstoreconst, types.TypeMem)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 16))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 16))
 		v1 := b.NewValue0(v.Pos, OpAMD64MOVQstoreconst, types.TypeMem)
-		v1.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 8))
+		v1.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 8))
 		v2 := b.NewValue0(v.Pos, OpAMD64MOVQstoreconst, types.TypeMem)
-		v2.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 0))
+		v2.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 0))
 		v2.AddArg2(destptr, mem)
 		v1.AddArg2(destptr, v2)
 		v0.AddArg2(destptr, v1)
@@ -34267,7 +34255,7 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 	}
 	// match: (Zero [s] destptr mem)
 	// cond: s > 8 && s < 16 && config.useSSE
-	// result: (MOVQstoreconst [makeValAndOff32(0,int32(s-8))] destptr (MOVQstoreconst [makeValAndOff32(0,0)] destptr mem))
+	// result: (MOVQstoreconst [makeValAndOff(0,int32(s-8))] destptr (MOVQstoreconst [makeValAndOff(0,0)] destptr mem))
 	for {
 		s := auxIntToInt64(v.AuxInt)
 		destptr := v_0
@@ -34276,9 +34264,9 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 			break
 		}
 		v.reset(OpAMD64MOVQstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, int32(s-8)))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(0, int32(s-8)))
 		v0 := b.NewValue0(v.Pos, OpAMD64MOVQstoreconst, types.TypeMem)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 0))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 0))
 		v0.AddArg2(destptr, mem)
 		v.AddArg2(destptr, v0)
 		return true
@@ -34305,7 +34293,7 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 	}
 	// match: (Zero [s] destptr mem)
 	// cond: s%16 != 0 && s > 16 && s%16 <= 8 && config.useSSE
-	// result: (Zero [s-s%16] (OffPtr <destptr.Type> destptr [s%16]) (MOVQstoreconst [makeValAndOff32(0,0)] destptr mem))
+	// result: (Zero [s-s%16] (OffPtr <destptr.Type> destptr [s%16]) (MOVQstoreconst [makeValAndOff(0,0)] destptr mem))
 	for {
 		s := auxIntToInt64(v.AuxInt)
 		destptr := v_0
@@ -34319,7 +34307,7 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
 		v0.AuxInt = int64ToAuxInt(s % 16)
 		v0.AddArg(destptr)
 		v1 := b.NewValue0(v.Pos, OpAMD64MOVQstoreconst, types.TypeMem)
-		v1.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 0))
+		v1.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 0))
 		v1.AddArg2(destptr, mem)
 		v.AddArg2(v0, v1)
 		return true
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64splitload.go b/src/cmd/compile/internal/ssa/rewriteAMD64splitload.go
index 65bfec0f68..1b8680c052 100644
--- a/src/cmd/compile/internal/ssa/rewriteAMD64splitload.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64splitload.go
@@ -59,7 +59,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPBconstload(v *Value) bool {
 	typ := &b.Func.Config.Types
 	// match: (CMPBconstload {sym} [vo] ptr mem)
 	// cond: vo.Val() == 0
-	// result: (TESTB x:(MOVBload {sym} [vo.Off32()] ptr mem) x)
+	// result: (TESTB x:(MOVBload {sym} [vo.Off()] ptr mem) x)
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -70,7 +70,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPBconstload(v *Value) bool {
 		}
 		v.reset(OpAMD64TESTB)
 		x := b.NewValue0(v.Pos, OpAMD64MOVBload, typ.UInt8)
-		x.AuxInt = int32ToAuxInt(vo.Off32())
+		x.AuxInt = int32ToAuxInt(vo.Off())
 		x.Aux = symToAux(sym)
 		x.AddArg2(ptr, mem)
 		v.AddArg2(x, x)
@@ -78,7 +78,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPBconstload(v *Value) bool {
 	}
 	// match: (CMPBconstload {sym} [vo] ptr mem)
 	// cond: vo.Val() != 0
-	// result: (CMPBconst (MOVBload {sym} [vo.Off32()] ptr mem) [vo.Val8()])
+	// result: (CMPBconst (MOVBload {sym} [vo.Off()] ptr mem) [vo.Val8()])
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -90,7 +90,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPBconstload(v *Value) bool {
 		v.reset(OpAMD64CMPBconst)
 		v.AuxInt = int8ToAuxInt(vo.Val8())
 		v0 := b.NewValue0(v.Pos, OpAMD64MOVBload, typ.UInt8)
-		v0.AuxInt = int32ToAuxInt(vo.Off32())
+		v0.AuxInt = int32ToAuxInt(vo.Off())
 		v0.Aux = symToAux(sym)
 		v0.AddArg2(ptr, mem)
 		v.AddArg(v0)
@@ -106,7 +106,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPBconstloadidx1(v *Value) bool {
 	typ := &b.Func.Config.Types
 	// match: (CMPBconstloadidx1 {sym} [vo] ptr idx mem)
 	// cond: vo.Val() == 0
-	// result: (TESTB x:(MOVBloadidx1 {sym} [vo.Off32()] ptr idx mem) x)
+	// result: (TESTB x:(MOVBloadidx1 {sym} [vo.Off()] ptr idx mem) x)
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -118,7 +118,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPBconstloadidx1(v *Value) bool {
 		}
 		v.reset(OpAMD64TESTB)
 		x := b.NewValue0(v.Pos, OpAMD64MOVBloadidx1, typ.UInt8)
-		x.AuxInt = int32ToAuxInt(vo.Off32())
+		x.AuxInt = int32ToAuxInt(vo.Off())
 		x.Aux = symToAux(sym)
 		x.AddArg3(ptr, idx, mem)
 		v.AddArg2(x, x)
@@ -126,7 +126,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPBconstloadidx1(v *Value) bool {
 	}
 	// match: (CMPBconstloadidx1 {sym} [vo] ptr idx mem)
 	// cond: vo.Val() != 0
-	// result: (CMPBconst (MOVBloadidx1 {sym} [vo.Off32()] ptr idx mem) [vo.Val8()])
+	// result: (CMPBconst (MOVBloadidx1 {sym} [vo.Off()] ptr idx mem) [vo.Val8()])
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -139,7 +139,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPBconstloadidx1(v *Value) bool {
 		v.reset(OpAMD64CMPBconst)
 		v.AuxInt = int8ToAuxInt(vo.Val8())
 		v0 := b.NewValue0(v.Pos, OpAMD64MOVBloadidx1, typ.UInt8)
-		v0.AuxInt = int32ToAuxInt(vo.Off32())
+		v0.AuxInt = int32ToAuxInt(vo.Off())
 		v0.Aux = symToAux(sym)
 		v0.AddArg3(ptr, idx, mem)
 		v.AddArg(v0)
@@ -202,7 +202,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPLconstload(v *Value) bool {
 	typ := &b.Func.Config.Types
 	// match: (CMPLconstload {sym} [vo] ptr mem)
 	// cond: vo.Val() == 0
-	// result: (TESTL x:(MOVLload {sym} [vo.Off32()] ptr mem) x)
+	// result: (TESTL x:(MOVLload {sym} [vo.Off()] ptr mem) x)
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -213,7 +213,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPLconstload(v *Value) bool {
 		}
 		v.reset(OpAMD64TESTL)
 		x := b.NewValue0(v.Pos, OpAMD64MOVLload, typ.UInt32)
-		x.AuxInt = int32ToAuxInt(vo.Off32())
+		x.AuxInt = int32ToAuxInt(vo.Off())
 		x.Aux = symToAux(sym)
 		x.AddArg2(ptr, mem)
 		v.AddArg2(x, x)
@@ -221,7 +221,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPLconstload(v *Value) bool {
 	}
 	// match: (CMPLconstload {sym} [vo] ptr mem)
 	// cond: vo.Val() != 0
-	// result: (CMPLconst (MOVLload {sym} [vo.Off32()] ptr mem) [vo.Val32()])
+	// result: (CMPLconst (MOVLload {sym} [vo.Off()] ptr mem) [vo.Val()])
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -231,9 +231,9 @@ func rewriteValueAMD64splitload_OpAMD64CMPLconstload(v *Value) bool {
 			break
 		}
 		v.reset(OpAMD64CMPLconst)
-		v.AuxInt = int32ToAuxInt(vo.Val32())
+		v.AuxInt = int32ToAuxInt(vo.Val())
 		v0 := b.NewValue0(v.Pos, OpAMD64MOVLload, typ.UInt32)
-		v0.AuxInt = int32ToAuxInt(vo.Off32())
+		v0.AuxInt = int32ToAuxInt(vo.Off())
 		v0.Aux = symToAux(sym)
 		v0.AddArg2(ptr, mem)
 		v.AddArg(v0)
@@ -249,7 +249,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPLconstloadidx1(v *Value) bool {
 	typ := &b.Func.Config.Types
 	// match: (CMPLconstloadidx1 {sym} [vo] ptr idx mem)
 	// cond: vo.Val() == 0
-	// result: (TESTL x:(MOVLloadidx1 {sym} [vo.Off32()] ptr idx mem) x)
+	// result: (TESTL x:(MOVLloadidx1 {sym} [vo.Off()] ptr idx mem) x)
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -261,7 +261,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPLconstloadidx1(v *Value) bool {
 		}
 		v.reset(OpAMD64TESTL)
 		x := b.NewValue0(v.Pos, OpAMD64MOVLloadidx1, typ.UInt32)
-		x.AuxInt = int32ToAuxInt(vo.Off32())
+		x.AuxInt = int32ToAuxInt(vo.Off())
 		x.Aux = symToAux(sym)
 		x.AddArg3(ptr, idx, mem)
 		v.AddArg2(x, x)
@@ -269,7 +269,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPLconstloadidx1(v *Value) bool {
 	}
 	// match: (CMPLconstloadidx1 {sym} [vo] ptr idx mem)
 	// cond: vo.Val() != 0
-	// result: (CMPLconst (MOVLloadidx1 {sym} [vo.Off32()] ptr idx mem) [vo.Val32()])
+	// result: (CMPLconst (MOVLloadidx1 {sym} [vo.Off()] ptr idx mem) [vo.Val()])
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -280,9 +280,9 @@ func rewriteValueAMD64splitload_OpAMD64CMPLconstloadidx1(v *Value) bool {
 			break
 		}
 		v.reset(OpAMD64CMPLconst)
-		v.AuxInt = int32ToAuxInt(vo.Val32())
+		v.AuxInt = int32ToAuxInt(vo.Val())
 		v0 := b.NewValue0(v.Pos, OpAMD64MOVLloadidx1, typ.UInt32)
-		v0.AuxInt = int32ToAuxInt(vo.Off32())
+		v0.AuxInt = int32ToAuxInt(vo.Off())
 		v0.Aux = symToAux(sym)
 		v0.AddArg3(ptr, idx, mem)
 		v.AddArg(v0)
@@ -298,7 +298,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPLconstloadidx4(v *Value) bool {
 	typ := &b.Func.Config.Types
 	// match: (CMPLconstloadidx4 {sym} [vo] ptr idx mem)
 	// cond: vo.Val() == 0
-	// result: (TESTL x:(MOVLloadidx4 {sym} [vo.Off32()] ptr idx mem) x)
+	// result: (TESTL x:(MOVLloadidx4 {sym} [vo.Off()] ptr idx mem) x)
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -310,7 +310,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPLconstloadidx4(v *Value) bool {
 		}
 		v.reset(OpAMD64TESTL)
 		x := b.NewValue0(v.Pos, OpAMD64MOVLloadidx4, typ.UInt32)
-		x.AuxInt = int32ToAuxInt(vo.Off32())
+		x.AuxInt = int32ToAuxInt(vo.Off())
 		x.Aux = symToAux(sym)
 		x.AddArg3(ptr, idx, mem)
 		v.AddArg2(x, x)
@@ -318,7 +318,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPLconstloadidx4(v *Value) bool {
 	}
 	// match: (CMPLconstloadidx4 {sym} [vo] ptr idx mem)
 	// cond: vo.Val() != 0
-	// result: (CMPLconst (MOVLloadidx4 {sym} [vo.Off32()] ptr idx mem) [vo.Val32()])
+	// result: (CMPLconst (MOVLloadidx4 {sym} [vo.Off()] ptr idx mem) [vo.Val()])
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -329,9 +329,9 @@ func rewriteValueAMD64splitload_OpAMD64CMPLconstloadidx4(v *Value) bool {
 			break
 		}
 		v.reset(OpAMD64CMPLconst)
-		v.AuxInt = int32ToAuxInt(vo.Val32())
+		v.AuxInt = int32ToAuxInt(vo.Val())
 		v0 := b.NewValue0(v.Pos, OpAMD64MOVLloadidx4, typ.UInt32)
-		v0.AuxInt = int32ToAuxInt(vo.Off32())
+		v0.AuxInt = int32ToAuxInt(vo.Off())
 		v0.Aux = symToAux(sym)
 		v0.AddArg3(ptr, idx, mem)
 		v.AddArg(v0)
@@ -419,7 +419,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPQconstload(v *Value) bool {
 	typ := &b.Func.Config.Types
 	// match: (CMPQconstload {sym} [vo] ptr mem)
 	// cond: vo.Val() == 0
-	// result: (TESTQ x:(MOVQload {sym} [vo.Off32()] ptr mem) x)
+	// result: (TESTQ x:(MOVQload {sym} [vo.Off()] ptr mem) x)
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -430,7 +430,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPQconstload(v *Value) bool {
 		}
 		v.reset(OpAMD64TESTQ)
 		x := b.NewValue0(v.Pos, OpAMD64MOVQload, typ.UInt64)
-		x.AuxInt = int32ToAuxInt(vo.Off32())
+		x.AuxInt = int32ToAuxInt(vo.Off())
 		x.Aux = symToAux(sym)
 		x.AddArg2(ptr, mem)
 		v.AddArg2(x, x)
@@ -438,7 +438,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPQconstload(v *Value) bool {
 	}
 	// match: (CMPQconstload {sym} [vo] ptr mem)
 	// cond: vo.Val() != 0
-	// result: (CMPQconst (MOVQload {sym} [vo.Off32()] ptr mem) [vo.Val32()])
+	// result: (CMPQconst (MOVQload {sym} [vo.Off()] ptr mem) [vo.Val()])
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -448,9 +448,9 @@ func rewriteValueAMD64splitload_OpAMD64CMPQconstload(v *Value) bool {
 			break
 		}
 		v.reset(OpAMD64CMPQconst)
-		v.AuxInt = int32ToAuxInt(vo.Val32())
+		v.AuxInt = int32ToAuxInt(vo.Val())
 		v0 := b.NewValue0(v.Pos, OpAMD64MOVQload, typ.UInt64)
-		v0.AuxInt = int32ToAuxInt(vo.Off32())
+		v0.AuxInt = int32ToAuxInt(vo.Off())
 		v0.Aux = symToAux(sym)
 		v0.AddArg2(ptr, mem)
 		v.AddArg(v0)
@@ -466,7 +466,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPQconstloadidx1(v *Value) bool {
 	typ := &b.Func.Config.Types
 	// match: (CMPQconstloadidx1 {sym} [vo] ptr idx mem)
 	// cond: vo.Val() == 0
-	// result: (TESTQ x:(MOVQloadidx1 {sym} [vo.Off32()] ptr idx mem) x)
+	// result: (TESTQ x:(MOVQloadidx1 {sym} [vo.Off()] ptr idx mem) x)
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -478,7 +478,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPQconstloadidx1(v *Value) bool {
 		}
 		v.reset(OpAMD64TESTQ)
 		x := b.NewValue0(v.Pos, OpAMD64MOVQloadidx1, typ.UInt64)
-		x.AuxInt = int32ToAuxInt(vo.Off32())
+		x.AuxInt = int32ToAuxInt(vo.Off())
 		x.Aux = symToAux(sym)
 		x.AddArg3(ptr, idx, mem)
 		v.AddArg2(x, x)
@@ -486,7 +486,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPQconstloadidx1(v *Value) bool {
 	}
 	// match: (CMPQconstloadidx1 {sym} [vo] ptr idx mem)
 	// cond: vo.Val() != 0
-	// result: (CMPQconst (MOVQloadidx1 {sym} [vo.Off32()] ptr idx mem) [vo.Val32()])
+	// result: (CMPQconst (MOVQloadidx1 {sym} [vo.Off()] ptr idx mem) [vo.Val()])
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -497,9 +497,9 @@ func rewriteValueAMD64splitload_OpAMD64CMPQconstloadidx1(v *Value) bool {
 			break
 		}
 		v.reset(OpAMD64CMPQconst)
-		v.AuxInt = int32ToAuxInt(vo.Val32())
+		v.AuxInt = int32ToAuxInt(vo.Val())
 		v0 := b.NewValue0(v.Pos, OpAMD64MOVQloadidx1, typ.UInt64)
-		v0.AuxInt = int32ToAuxInt(vo.Off32())
+		v0.AuxInt = int32ToAuxInt(vo.Off())
 		v0.Aux = symToAux(sym)
 		v0.AddArg3(ptr, idx, mem)
 		v.AddArg(v0)
@@ -515,7 +515,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPQconstloadidx8(v *Value) bool {
 	typ := &b.Func.Config.Types
 	// match: (CMPQconstloadidx8 {sym} [vo] ptr idx mem)
 	// cond: vo.Val() == 0
-	// result: (TESTQ x:(MOVQloadidx8 {sym} [vo.Off32()] ptr idx mem) x)
+	// result: (TESTQ x:(MOVQloadidx8 {sym} [vo.Off()] ptr idx mem) x)
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -527,7 +527,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPQconstloadidx8(v *Value) bool {
 		}
 		v.reset(OpAMD64TESTQ)
 		x := b.NewValue0(v.Pos, OpAMD64MOVQloadidx8, typ.UInt64)
-		x.AuxInt = int32ToAuxInt(vo.Off32())
+		x.AuxInt = int32ToAuxInt(vo.Off())
 		x.Aux = symToAux(sym)
 		x.AddArg3(ptr, idx, mem)
 		v.AddArg2(x, x)
@@ -535,7 +535,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPQconstloadidx8(v *Value) bool {
 	}
 	// match: (CMPQconstloadidx8 {sym} [vo] ptr idx mem)
 	// cond: vo.Val() != 0
-	// result: (CMPQconst (MOVQloadidx8 {sym} [vo.Off32()] ptr idx mem) [vo.Val32()])
+	// result: (CMPQconst (MOVQloadidx8 {sym} [vo.Off()] ptr idx mem) [vo.Val()])
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -546,9 +546,9 @@ func rewriteValueAMD64splitload_OpAMD64CMPQconstloadidx8(v *Value) bool {
 			break
 		}
 		v.reset(OpAMD64CMPQconst)
-		v.AuxInt = int32ToAuxInt(vo.Val32())
+		v.AuxInt = int32ToAuxInt(vo.Val())
 		v0 := b.NewValue0(v.Pos, OpAMD64MOVQloadidx8, typ.UInt64)
-		v0.AuxInt = int32ToAuxInt(vo.Off32())
+		v0.AuxInt = int32ToAuxInt(vo.Off())
 		v0.Aux = symToAux(sym)
 		v0.AddArg3(ptr, idx, mem)
 		v.AddArg(v0)
@@ -636,7 +636,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPWconstload(v *Value) bool {
 	typ := &b.Func.Config.Types
 	// match: (CMPWconstload {sym} [vo] ptr mem)
 	// cond: vo.Val() == 0
-	// result: (TESTW x:(MOVWload {sym} [vo.Off32()] ptr mem) x)
+	// result: (TESTW x:(MOVWload {sym} [vo.Off()] ptr mem) x)
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -647,7 +647,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPWconstload(v *Value) bool {
 		}
 		v.reset(OpAMD64TESTW)
 		x := b.NewValue0(v.Pos, OpAMD64MOVWload, typ.UInt16)
-		x.AuxInt = int32ToAuxInt(vo.Off32())
+		x.AuxInt = int32ToAuxInt(vo.Off())
 		x.Aux = symToAux(sym)
 		x.AddArg2(ptr, mem)
 		v.AddArg2(x, x)
@@ -655,7 +655,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPWconstload(v *Value) bool {
 	}
 	// match: (CMPWconstload {sym} [vo] ptr mem)
 	// cond: vo.Val() != 0
-	// result: (CMPWconst (MOVWload {sym} [vo.Off32()] ptr mem) [vo.Val16()])
+	// result: (CMPWconst (MOVWload {sym} [vo.Off()] ptr mem) [vo.Val16()])
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -667,7 +667,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPWconstload(v *Value) bool {
 		v.reset(OpAMD64CMPWconst)
 		v.AuxInt = int16ToAuxInt(vo.Val16())
 		v0 := b.NewValue0(v.Pos, OpAMD64MOVWload, typ.UInt16)
-		v0.AuxInt = int32ToAuxInt(vo.Off32())
+		v0.AuxInt = int32ToAuxInt(vo.Off())
 		v0.Aux = symToAux(sym)
 		v0.AddArg2(ptr, mem)
 		v.AddArg(v0)
@@ -683,7 +683,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPWconstloadidx1(v *Value) bool {
 	typ := &b.Func.Config.Types
 	// match: (CMPWconstloadidx1 {sym} [vo] ptr idx mem)
 	// cond: vo.Val() == 0
-	// result: (TESTW x:(MOVWloadidx1 {sym} [vo.Off32()] ptr idx mem) x)
+	// result: (TESTW x:(MOVWloadidx1 {sym} [vo.Off()] ptr idx mem) x)
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -695,7 +695,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPWconstloadidx1(v *Value) bool {
 		}
 		v.reset(OpAMD64TESTW)
 		x := b.NewValue0(v.Pos, OpAMD64MOVWloadidx1, typ.UInt16)
-		x.AuxInt = int32ToAuxInt(vo.Off32())
+		x.AuxInt = int32ToAuxInt(vo.Off())
 		x.Aux = symToAux(sym)
 		x.AddArg3(ptr, idx, mem)
 		v.AddArg2(x, x)
@@ -703,7 +703,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPWconstloadidx1(v *Value) bool {
 	}
 	// match: (CMPWconstloadidx1 {sym} [vo] ptr idx mem)
 	// cond: vo.Val() != 0
-	// result: (CMPWconst (MOVWloadidx1 {sym} [vo.Off32()] ptr idx mem) [vo.Val16()])
+	// result: (CMPWconst (MOVWloadidx1 {sym} [vo.Off()] ptr idx mem) [vo.Val16()])
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -716,7 +716,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPWconstloadidx1(v *Value) bool {
 		v.reset(OpAMD64CMPWconst)
 		v.AuxInt = int16ToAuxInt(vo.Val16())
 		v0 := b.NewValue0(v.Pos, OpAMD64MOVWloadidx1, typ.UInt16)
-		v0.AuxInt = int32ToAuxInt(vo.Off32())
+		v0.AuxInt = int32ToAuxInt(vo.Off())
 		v0.Aux = symToAux(sym)
 		v0.AddArg3(ptr, idx, mem)
 		v.AddArg(v0)
@@ -732,7 +732,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPWconstloadidx2(v *Value) bool {
 	typ := &b.Func.Config.Types
 	// match: (CMPWconstloadidx2 {sym} [vo] ptr idx mem)
 	// cond: vo.Val() == 0
-	// result: (TESTW x:(MOVWloadidx2 {sym} [vo.Off32()] ptr idx mem) x)
+	// result: (TESTW x:(MOVWloadidx2 {sym} [vo.Off()] ptr idx mem) x)
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -744,7 +744,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPWconstloadidx2(v *Value) bool {
 		}
 		v.reset(OpAMD64TESTW)
 		x := b.NewValue0(v.Pos, OpAMD64MOVWloadidx2, typ.UInt16)
-		x.AuxInt = int32ToAuxInt(vo.Off32())
+		x.AuxInt = int32ToAuxInt(vo.Off())
 		x.Aux = symToAux(sym)
 		x.AddArg3(ptr, idx, mem)
 		v.AddArg2(x, x)
@@ -752,7 +752,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPWconstloadidx2(v *Value) bool {
 	}
 	// match: (CMPWconstloadidx2 {sym} [vo] ptr idx mem)
 	// cond: vo.Val() != 0
-	// result: (CMPWconst (MOVWloadidx2 {sym} [vo.Off32()] ptr idx mem) [vo.Val16()])
+	// result: (CMPWconst (MOVWloadidx2 {sym} [vo.Off()] ptr idx mem) [vo.Val16()])
 	for {
 		vo := auxIntToValAndOff(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -765,7 +765,7 @@ func rewriteValueAMD64splitload_OpAMD64CMPWconstloadidx2(v *Value) bool {
 		v.reset(OpAMD64CMPWconst)
 		v.AuxInt = int16ToAuxInt(vo.Val16())
 		v0 := b.NewValue0(v.Pos, OpAMD64MOVWloadidx2, typ.UInt16)
-		v0.AuxInt = int32ToAuxInt(vo.Off32())
+		v0.AuxInt = int32ToAuxInt(vo.Off())
 		v0.Aux = symToAux(sym)
 		v0.AddArg3(ptr, idx, mem)
 		v.AddArg(v0)
diff --git a/src/cmd/compile/internal/ssa/rewriteS390X.go b/src/cmd/compile/internal/ssa/rewriteS390X.go
index 85260dace8..f02362a0d4 100644
--- a/src/cmd/compile/internal/ssa/rewriteS390X.go
+++ b/src/cmd/compile/internal/ssa/rewriteS390X.go
@@ -3433,7 +3433,7 @@ func rewriteValueS390X_OpMove(v *Value) bool {
 	}
 	// match: (Move [s] dst src mem)
 	// cond: s > 0 && s <= 256 && logLargeCopy(v, s)
-	// result: (MVC [makeValAndOff32(int32(s), 0)] dst src mem)
+	// result: (MVC [makeValAndOff(int32(s), 0)] dst src mem)
 	for {
 		s := auxIntToInt64(v.AuxInt)
 		dst := v_0
@@ -3443,13 +3443,13 @@ func rewriteValueS390X_OpMove(v *Value) bool {
 			break
 		}
 		v.reset(OpS390XMVC)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(s), 0))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(s), 0))
 		v.AddArg3(dst, src, mem)
 		return true
 	}
 	// match: (Move [s] dst src mem)
 	// cond: s > 256 && s <= 512 && logLargeCopy(v, s)
-	// result: (MVC [makeValAndOff32(int32(s)-256, 256)] dst src (MVC [makeValAndOff32(256, 0)] dst src mem))
+	// result: (MVC [makeValAndOff(int32(s)-256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem))
 	for {
 		s := auxIntToInt64(v.AuxInt)
 		dst := v_0
@@ -3459,16 +3459,16 @@ func rewriteValueS390X_OpMove(v *Value) bool {
 			break
 		}
 		v.reset(OpS390XMVC)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(s)-256, 256))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(s)-256, 256))
 		v0 := b.NewValue0(v.Pos, OpS390XMVC, types.TypeMem)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(256, 0))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(256, 0))
 		v0.AddArg3(dst, src, mem)
 		v.AddArg3(dst, src, v0)
 		return true
 	}
 	// match: (Move [s] dst src mem)
 	// cond: s > 512 && s <= 768 && logLargeCopy(v, s)
-	// result: (MVC [makeValAndOff32(int32(s)-512, 512)] dst src (MVC [makeValAndOff32(256, 256)] dst src (MVC [makeValAndOff32(256, 0)] dst src mem)))
+	// result: (MVC [makeValAndOff(int32(s)-512, 512)] dst src (MVC [makeValAndOff(256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem)))
 	for {
 		s := auxIntToInt64(v.AuxInt)
 		dst := v_0
@@ -3478,11 +3478,11 @@ func rewriteValueS390X_OpMove(v *Value) bool {
 			break
 		}
 		v.reset(OpS390XMVC)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(s)-512, 512))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(s)-512, 512))
 		v0 := b.NewValue0(v.Pos, OpS390XMVC, types.TypeMem)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(256, 256))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(256, 256))
 		v1 := b.NewValue0(v.Pos, OpS390XMVC, types.TypeMem)
-		v1.AuxInt = valAndOffToAuxInt(makeValAndOff32(256, 0))
+		v1.AuxInt = valAndOffToAuxInt(makeValAndOff(256, 0))
 		v1.AddArg3(dst, src, mem)
 		v0.AddArg3(dst, src, v1)
 		v.AddArg3(dst, src, v0)
@@ -3490,7 +3490,7 @@ func rewriteValueS390X_OpMove(v *Value) bool {
 	}
 	// match: (Move [s] dst src mem)
 	// cond: s > 768 && s <= 1024 && logLargeCopy(v, s)
-	// result: (MVC [makeValAndOff32(int32(s)-768, 768)] dst src (MVC [makeValAndOff32(256, 512)] dst src (MVC [makeValAndOff32(256, 256)] dst src (MVC [makeValAndOff32(256, 0)] dst src mem))))
+	// result: (MVC [makeValAndOff(int32(s)-768, 768)] dst src (MVC [makeValAndOff(256, 512)] dst src (MVC [makeValAndOff(256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem))))
 	for {
 		s := auxIntToInt64(v.AuxInt)
 		dst := v_0
@@ -3500,13 +3500,13 @@ func rewriteValueS390X_OpMove(v *Value) bool {
 			break
 		}
 		v.reset(OpS390XMVC)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(s)-768, 768))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(s)-768, 768))
 		v0 := b.NewValue0(v.Pos, OpS390XMVC, types.TypeMem)
-		v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(256, 512))
+		v0.AuxInt = valAndOffToAuxInt(makeValAndOff(256, 512))
 		v1 := b.NewValue0(v.Pos, OpS390XMVC, types.TypeMem)
-		v1.AuxInt = valAndOffToAuxInt(makeValAndOff32(256, 256))
+		v1.AuxInt = valAndOffToAuxInt(makeValAndOff(256, 256))
 		v2 := b.NewValue0(v.Pos, OpS390XMVC, types.TypeMem)
-		v2.AuxInt = valAndOffToAuxInt(makeValAndOff32(256, 0))
+		v2.AuxInt = valAndOffToAuxInt(makeValAndOff(256, 0))
 		v2.AddArg3(dst, src, mem)
 		v1.AddArg3(dst, src, v2)
 		v0.AddArg3(dst, src, v1)
@@ -8617,7 +8617,7 @@ func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool {
 	}
 	// match: (MOVBstore [off] {sym} ptr (MOVDconst [c]) mem)
 	// cond: is20Bit(int64(off)) && ptr.Op != OpSB
-	// result: (MOVBstoreconst [makeValAndOff32(int32(int8(c)),off)] {sym} ptr mem)
+	// result: (MOVBstoreconst [makeValAndOff(int32(int8(c)),off)] {sym} ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -8631,7 +8631,7 @@ func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool {
 			break
 		}
 		v.reset(OpS390XMOVBstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(int8(c)), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int8(c)), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
@@ -8939,7 +8939,7 @@ func rewriteValueS390X_OpS390XMOVBstoreconst(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (MOVBstoreconst [sc] {s} (ADDconst [off] ptr) mem)
-	// cond: is20Bit(sc.Off()+int64(off))
+	// cond: is20Bit(sc.Off64()+int64(off))
 	// result: (MOVBstoreconst [sc.addOffset32(off)] {s} ptr mem)
 	for {
 		sc := auxIntToValAndOff(v.AuxInt)
@@ -8950,7 +8950,7 @@ func rewriteValueS390X_OpS390XMOVBstoreconst(v *Value) bool {
 		off := auxIntToInt32(v_0.AuxInt)
 		ptr := v_0.Args[0]
 		mem := v_1
-		if !(is20Bit(sc.Off() + int64(off))) {
+		if !(is20Bit(sc.Off64() + int64(off))) {
 			break
 		}
 		v.reset(OpS390XMOVBstoreconst)
@@ -8983,7 +8983,7 @@ func rewriteValueS390X_OpS390XMOVBstoreconst(v *Value) bool {
 	}
 	// match: (MOVBstoreconst [c] {s} p x:(MOVBstoreconst [a] {s} p mem))
 	// cond: p.Op != OpSB && x.Uses == 1 && a.Off() + 1 == c.Off() && clobber(x)
-	// result: (MOVHstoreconst [makeValAndOff32(c.Val32()&0xff | a.Val32()<<8, a.Off32())] {s} p mem)
+	// result: (MOVHstoreconst [makeValAndOff(c.Val()&0xff | a.Val()<<8, a.Off())] {s} p mem)
 	for {
 		c := auxIntToValAndOff(v.AuxInt)
 		s := auxToSym(v.Aux)
@@ -9001,7 +9001,7 @@ func rewriteValueS390X_OpS390XMOVBstoreconst(v *Value) bool {
 			break
 		}
 		v.reset(OpS390XMOVHstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(c.Val32()&0xff|a.Val32()<<8, a.Off32()))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(c.Val()&0xff|a.Val()<<8, a.Off()))
 		v.Aux = symToAux(s)
 		v.AddArg2(p, mem)
 		return true
@@ -9213,7 +9213,7 @@ func rewriteValueS390X_OpS390XMOVDstore(v *Value) bool {
 	}
 	// match: (MOVDstore [off] {sym} ptr (MOVDconst [c]) mem)
 	// cond: is16Bit(c) && isU12Bit(int64(off)) && ptr.Op != OpSB
-	// result: (MOVDstoreconst [makeValAndOff32(int32(c),off)] {sym} ptr mem)
+	// result: (MOVDstoreconst [makeValAndOff(int32(c),off)] {sym} ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -9227,7 +9227,7 @@ func rewriteValueS390X_OpS390XMOVDstore(v *Value) bool {
 			break
 		}
 		v.reset(OpS390XMOVDstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
@@ -9343,7 +9343,7 @@ func rewriteValueS390X_OpS390XMOVDstoreconst(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (MOVDstoreconst [sc] {s} (ADDconst [off] ptr) mem)
-	// cond: isU12Bit(sc.Off()+int64(off))
+	// cond: isU12Bit(sc.Off64()+int64(off))
 	// result: (MOVDstoreconst [sc.addOffset32(off)] {s} ptr mem)
 	for {
 		sc := auxIntToValAndOff(v.AuxInt)
@@ -9354,7 +9354,7 @@ func rewriteValueS390X_OpS390XMOVDstoreconst(v *Value) bool {
 		off := auxIntToInt32(v_0.AuxInt)
 		ptr := v_0.Args[0]
 		mem := v_1
-		if !(isU12Bit(sc.Off() + int64(off))) {
+		if !(isU12Bit(sc.Off64() + int64(off))) {
 			break
 		}
 		v.reset(OpS390XMOVDstoreconst)
@@ -10079,7 +10079,7 @@ func rewriteValueS390X_OpS390XMOVHstore(v *Value) bool {
 	}
 	// match: (MOVHstore [off] {sym} ptr (MOVDconst [c]) mem)
 	// cond: isU12Bit(int64(off)) && ptr.Op != OpSB
-	// result: (MOVHstoreconst [makeValAndOff32(int32(int16(c)),off)] {sym} ptr mem)
+	// result: (MOVHstoreconst [makeValAndOff(int32(int16(c)),off)] {sym} ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -10093,7 +10093,7 @@ func rewriteValueS390X_OpS390XMOVHstore(v *Value) bool {
 			break
 		}
 		v.reset(OpS390XMOVHstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(int16(c)), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(int16(c)), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
@@ -10244,7 +10244,7 @@ func rewriteValueS390X_OpS390XMOVHstoreconst(v *Value) bool {
 	b := v.Block
 	typ := &b.Func.Config.Types
 	// match: (MOVHstoreconst [sc] {s} (ADDconst [off] ptr) mem)
-	// cond: isU12Bit(sc.Off()+int64(off))
+	// cond: isU12Bit(sc.Off64()+int64(off))
 	// result: (MOVHstoreconst [sc.addOffset32(off)] {s} ptr mem)
 	for {
 		sc := auxIntToValAndOff(v.AuxInt)
@@ -10255,7 +10255,7 @@ func rewriteValueS390X_OpS390XMOVHstoreconst(v *Value) bool {
 		off := auxIntToInt32(v_0.AuxInt)
 		ptr := v_0.Args[0]
 		mem := v_1
-		if !(isU12Bit(sc.Off() + int64(off))) {
+		if !(isU12Bit(sc.Off64() + int64(off))) {
 			break
 		}
 		v.reset(OpS390XMOVHstoreconst)
@@ -10288,7 +10288,7 @@ func rewriteValueS390X_OpS390XMOVHstoreconst(v *Value) bool {
 	}
 	// match: (MOVHstoreconst [c] {s} p x:(MOVHstoreconst [a] {s} p mem))
 	// cond: p.Op != OpSB && x.Uses == 1 && a.Off() + 2 == c.Off() && clobber(x)
-	// result: (MOVWstore [a.Off32()] {s} p (MOVDconst [int64(c.Val32()&0xffff | a.Val32()<<16)]) mem)
+	// result: (MOVWstore [a.Off()] {s} p (MOVDconst [int64(c.Val()&0xffff | a.Val()<<16)]) mem)
 	for {
 		c := auxIntToValAndOff(v.AuxInt)
 		s := auxToSym(v.Aux)
@@ -10306,10 +10306,10 @@ func rewriteValueS390X_OpS390XMOVHstoreconst(v *Value) bool {
 			break
 		}
 		v.reset(OpS390XMOVWstore)
-		v.AuxInt = int32ToAuxInt(a.Off32())
+		v.AuxInt = int32ToAuxInt(a.Off())
 		v.Aux = symToAux(s)
 		v0 := b.NewValue0(x.Pos, OpS390XMOVDconst, typ.UInt64)
-		v0.AuxInt = int64ToAuxInt(int64(c.Val32()&0xffff | a.Val32()<<16))
+		v0.AuxInt = int64ToAuxInt(int64(c.Val()&0xffff | a.Val()<<16))
 		v.AddArg3(p, v0, mem)
 		return true
 	}
@@ -10917,7 +10917,7 @@ func rewriteValueS390X_OpS390XMOVWstore(v *Value) bool {
 	}
 	// match: (MOVWstore [off] {sym} ptr (MOVDconst [c]) mem)
 	// cond: is16Bit(c) && isU12Bit(int64(off)) && ptr.Op != OpSB
-	// result: (MOVWstoreconst [makeValAndOff32(int32(c),off)] {sym} ptr mem)
+	// result: (MOVWstoreconst [makeValAndOff(int32(c),off)] {sym} ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -10931,7 +10931,7 @@ func rewriteValueS390X_OpS390XMOVWstore(v *Value) bool {
 			break
 		}
 		v.reset(OpS390XMOVWstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), off))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
@@ -11105,7 +11105,7 @@ func rewriteValueS390X_OpS390XMOVWstoreconst(v *Value) bool {
 	b := v.Block
 	typ := &b.Func.Config.Types
 	// match: (MOVWstoreconst [sc] {s} (ADDconst [off] ptr) mem)
-	// cond: isU12Bit(sc.Off()+int64(off))
+	// cond: isU12Bit(sc.Off64()+int64(off))
 	// result: (MOVWstoreconst [sc.addOffset32(off)] {s} ptr mem)
 	for {
 		sc := auxIntToValAndOff(v.AuxInt)
@@ -11116,7 +11116,7 @@ func rewriteValueS390X_OpS390XMOVWstoreconst(v *Value) bool {
 		off := auxIntToInt32(v_0.AuxInt)
 		ptr := v_0.Args[0]
 		mem := v_1
-		if !(isU12Bit(sc.Off() + int64(off))) {
+		if !(isU12Bit(sc.Off64() + int64(off))) {
 			break
 		}
 		v.reset(OpS390XMOVWstoreconst)
@@ -11149,7 +11149,7 @@ func rewriteValueS390X_OpS390XMOVWstoreconst(v *Value) bool {
 	}
 	// match: (MOVWstoreconst [c] {s} p x:(MOVWstoreconst [a] {s} p mem))
 	// cond: p.Op != OpSB && x.Uses == 1 && a.Off() + 4 == c.Off() && clobber(x)
-	// result: (MOVDstore [a.Off32()] {s} p (MOVDconst [c.Val()&0xffffffff | a.Val()<<32]) mem)
+	// result: (MOVDstore [a.Off()] {s} p (MOVDconst [c.Val64()&0xffffffff | a.Val64()<<32]) mem)
 	for {
 		c := auxIntToValAndOff(v.AuxInt)
 		s := auxToSym(v.Aux)
@@ -11167,10 +11167,10 @@ func rewriteValueS390X_OpS390XMOVWstoreconst(v *Value) bool {
 			break
 		}
 		v.reset(OpS390XMOVDstore)
-		v.AuxInt = int32ToAuxInt(a.Off32())
+		v.AuxInt = int32ToAuxInt(a.Off())
 		v.Aux = symToAux(s)
 		v0 := b.NewValue0(x.Pos, OpS390XMOVDconst, typ.UInt64)
-		v0.AuxInt = int64ToAuxInt(c.Val()&0xffffffff | a.Val()<<32)
+		v0.AuxInt = int64ToAuxInt(c.Val64()&0xffffffff | a.Val64()<<32)
 		v.AddArg3(p, v0, mem)
 		return true
 	}
@@ -15918,7 +15918,7 @@ func rewriteValueS390X_OpZero(v *Value) bool {
 		return true
 	}
 	// match: (Zero [3] destptr mem)
-	// result: (MOVBstoreconst [makeValAndOff32(0,2)] destptr (MOVHstoreconst [0] destptr mem))
+	// result: (MOVBstoreconst [makeValAndOff(0,2)] destptr (MOVHstoreconst [0] destptr mem))
 	for {
 		if auxIntToInt64(v.AuxInt) != 3 {
 			break
@@ -15926,7 +15926,7 @@ func rewriteValueS390X_OpZero(v *Value) bool {
 		destptr := v_0
 		mem := v_1
 		v.reset(OpS390XMOVBstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 2))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 2))
 		v0 := b.NewValue0(v.Pos, OpS390XMOVHstoreconst, types.TypeMem)
 		v0.AuxInt = valAndOffToAuxInt(0)
 		v0.AddArg2(destptr, mem)
@@ -15934,7 +15934,7 @@ func rewriteValueS390X_OpZero(v *Value) bool {
 		return true
 	}
 	// match: (Zero [5] destptr mem)
-	// result: (MOVBstoreconst [makeValAndOff32(0,4)] destptr (MOVWstoreconst [0] destptr mem))
+	// result: (MOVBstoreconst [makeValAndOff(0,4)] destptr (MOVWstoreconst [0] destptr mem))
 	for {
 		if auxIntToInt64(v.AuxInt) != 5 {
 			break
@@ -15942,7 +15942,7 @@ func rewriteValueS390X_OpZero(v *Value) bool {
 		destptr := v_0
 		mem := v_1
 		v.reset(OpS390XMOVBstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 4))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 4))
 		v0 := b.NewValue0(v.Pos, OpS390XMOVWstoreconst, types.TypeMem)
 		v0.AuxInt = valAndOffToAuxInt(0)
 		v0.AddArg2(destptr, mem)
@@ -15950,7 +15950,7 @@ func rewriteValueS390X_OpZero(v *Value) bool {
 		return true
 	}
 	// match: (Zero [6] destptr mem)
-	// result: (MOVHstoreconst [makeValAndOff32(0,4)] destptr (MOVWstoreconst [0] destptr mem))
+	// result: (MOVHstoreconst [makeValAndOff(0,4)] destptr (MOVWstoreconst [0] destptr mem))
 	for {
 		if auxIntToInt64(v.AuxInt) != 6 {
 			break
@@ -15958,7 +15958,7 @@ func rewriteValueS390X_OpZero(v *Value) bool {
 		destptr := v_0
 		mem := v_1
 		v.reset(OpS390XMOVHstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 4))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 4))
 		v0 := b.NewValue0(v.Pos, OpS390XMOVWstoreconst, types.TypeMem)
 		v0.AuxInt = valAndOffToAuxInt(0)
 		v0.AddArg2(destptr, mem)
@@ -15966,7 +15966,7 @@ func rewriteValueS390X_OpZero(v *Value) bool {
 		return true
 	}
 	// match: (Zero [7] destptr mem)
-	// result: (MOVWstoreconst [makeValAndOff32(0,3)] destptr (MOVWstoreconst [0] destptr mem))
+	// result: (MOVWstoreconst [makeValAndOff(0,3)] destptr (MOVWstoreconst [0] destptr mem))
 	for {
 		if auxIntToInt64(v.AuxInt) != 7 {
 			break
@@ -15974,7 +15974,7 @@ func rewriteValueS390X_OpZero(v *Value) bool {
 		destptr := v_0
 		mem := v_1
 		v.reset(OpS390XMOVWstoreconst)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(0, 3))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(0, 3))
 		v0 := b.NewValue0(v.Pos, OpS390XMOVWstoreconst, types.TypeMem)
 		v0.AuxInt = valAndOffToAuxInt(0)
 		v0.AddArg2(destptr, mem)
@@ -15983,7 +15983,7 @@ func rewriteValueS390X_OpZero(v *Value) bool {
 	}
 	// match: (Zero [s] destptr mem)
 	// cond: s > 0 && s <= 1024
-	// result: (CLEAR [makeValAndOff32(int32(s), 0)] destptr mem)
+	// result: (CLEAR [makeValAndOff(int32(s), 0)] destptr mem)
 	for {
 		s := auxIntToInt64(v.AuxInt)
 		destptr := v_0
@@ -15992,7 +15992,7 @@ func rewriteValueS390X_OpZero(v *Value) bool {
 			break
 		}
 		v.reset(OpS390XCLEAR)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(s), 0))
+		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(s), 0))
 		v.AddArg2(destptr, mem)
 		return true
 	}
diff --git a/src/cmd/compile/internal/x86/ssa.go b/src/cmd/compile/internal/x86/ssa.go
index 62982f4c6d..e8c92c0f00 100644
--- a/src/cmd/compile/internal/x86/ssa.go
+++ b/src/cmd/compile/internal/x86/ssa.go
@@ -427,9 +427,9 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
-		ssagen.AddAux2(&p.From, v, sc.Off())
+		ssagen.AddAux2(&p.From, v, sc.Off64())
 		p.To.Type = obj.TYPE_CONST
-		p.To.Offset = sc.Val()
+		p.To.Offset = sc.Val64()
 	case ssa.Op386MOVLconst:
 		x := v.Reg()
 
@@ -544,7 +544,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 			} else {
 				p = s.Prog(x86.ADECL)
 			}
-			off := sc.Off()
+			off := sc.Off64()
 			p.To.Type = obj.TYPE_MEM
 			p.To.Reg = v.Args[0].Reg()
 			ssagen.AddAux2(&p.To, v, off)
@@ -553,8 +553,8 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		fallthrough
 	case ssa.Op386ANDLconstmodify, ssa.Op386ORLconstmodify, ssa.Op386XORLconstmodify:
 		sc := v.AuxValAndOff()
-		off := sc.Off()
-		val := sc.Val()
+		off := sc.Off64()
+		val := sc.Val64()
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_CONST
 		p.From.Offset = val
@@ -591,10 +591,10 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_CONST
 		sc := v.AuxValAndOff()
-		p.From.Offset = sc.Val()
+		p.From.Offset = sc.Val64()
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = v.Args[0].Reg()
-		ssagen.AddAux2(&p.To, v, sc.Off())
+		ssagen.AddAux2(&p.To, v, sc.Off64())
 	case ssa.Op386ADDLconstmodifyidx4:
 		sc := v.AuxValAndOff()
 		val := sc.Val()
@@ -605,7 +605,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 			} else {
 				p = s.Prog(x86.ADECL)
 			}
-			off := sc.Off()
+			off := sc.Off64()
 			p.To.Type = obj.TYPE_MEM
 			p.To.Reg = v.Args[0].Reg()
 			p.To.Scale = 4
@@ -619,7 +619,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_CONST
 		sc := v.AuxValAndOff()
-		p.From.Offset = sc.Val()
+		p.From.Offset = sc.Val64()
 		r := v.Args[0].Reg()
 		i := v.Args[1].Reg()
 		switch v.Op {
@@ -637,7 +637,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = r
 		p.To.Index = i
-		ssagen.AddAux2(&p.To, v, sc.Off())
+		ssagen.AddAux2(&p.To, v, sc.Off64())
 	case ssa.Op386MOVWLSX, ssa.Op386MOVBLSX, ssa.Op386MOVWLZX, ssa.Op386MOVBLZX,
 		ssa.Op386CVTSL2SS, ssa.Op386CVTSL2SD,
 		ssa.Op386CVTTSS2SL, ssa.Op386CVTTSD2SL,
-- 
GitLab


From 762ef81a5670da99a4b060fd3afe4134c9e82017 Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Mon, 8 Mar 2021 18:44:27 -0800
Subject: [PATCH 0985/2400] cmd/link/internal/ld: deflake TestWindowsIssue36495

Over a dozen of the ld tests were missing closes. That was less
obvious before CL 299670 started using T.TempDir instead, which fails
a test when the tempdir can't be cleaned up (as it can't on Windows
when things are still open), insteading of leaving tempdirs around on
disk after the test.

Most of the missing closes were fixed in CL 299670, but the builders
helpfully pointed out that I missed at least this one.

Change-Id: I35f695bb7cbfba31e16311c5af965c148f9d7943
Reviewed-on: https://go-review.googlesource.com/c/go/+/299929
Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
Trust: Dan Scales <danscales@google.com>
Trust: Alex Brainman <alex.brainman@gmail.com>
---
 src/cmd/link/internal/ld/dwarf_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/cmd/link/internal/ld/dwarf_test.go b/src/cmd/link/internal/ld/dwarf_test.go
index d16cff911b..f5f2258451 100644
--- a/src/cmd/link/internal/ld/dwarf_test.go
+++ b/src/cmd/link/internal/ld/dwarf_test.go
@@ -1297,6 +1297,7 @@ func main() {
   fmt.Println("Hello World")
 }`
 	f := gobuild(t, dir, prog, NoOpt)
+	defer f.Close()
 	exe, err := pe.Open(f.path)
 	if err != nil {
 		t.Fatalf("error opening pe file: %v", err)
-- 
GitLab


From 034fffdb490ade3cbccd79eacdb9370850ef51d1 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Tue, 9 Mar 2021 10:38:30 +0100
Subject: [PATCH 0986/2400] net: use io.Discard in
 TestSendfileOnWriteTimeoutExceeded

Replace ioutil.Discard which is deprecated as of Go 1.16.

This was already done in CL 263142 but accidentially re-introduced in
CL 285914.

Change-Id: Ife0944d416294b1ba7c8f6b602aa68a3b9213c50
Reviewed-on: https://go-review.googlesource.com/c/go/+/299989
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/net/sendfile_test.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/net/sendfile_test.go b/src/net/sendfile_test.go
index db72daa328..54e51fa0ab 100644
--- a/src/net/sendfile_test.go
+++ b/src/net/sendfile_test.go
@@ -14,7 +14,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"os"
 	"runtime"
 	"sync"
@@ -367,7 +366,7 @@ func TestSendfileOnWriteTimeoutExceeded(t *testing.T) {
 	}
 	defer conn.Close()
 
-	n, err := io.Copy(ioutil.Discard, conn)
+	n, err := io.Copy(io.Discard, conn)
 	if err != nil {
 		t.Fatalf("expected nil error, but got %v", err)
 	}
-- 
GitLab


From a70eb2c9f2e3d52116b90a21ce10718356197ee5 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Wed, 3 Mar 2021 13:33:27 -0800
Subject: [PATCH 0987/2400] cmd/compile:  get instantiated generic types
 working with interfaces

Get instantiatiated generic types working with interfaces, including
typechecking assignments to interfaces and instantiating all the methods
properly. To get it all working, this change includes:

 - Add support for substituting in interfaces in subster.typ()

 - Fill in the info for the methods for all instantiated generic types,
   so those methods will be available for later typechecking (by the old
   typechecker) when assigning an instantiated generic type to an
   interface. We also want those methods available so we have the list
   when we want to instantiate all methods of an instantiated type. We
   have both for instantiated types encountered during the initial noder
   phase, and for instantiated types created during stenciling of a
   function/method.

 - When we first create a fully-instantiated generic type (whether
   during initial noder2 pass or while instantiating a method/function),
   add it to a list so that all of its methods will also be
   instantiated. This is needed so that an instantiated type can be
   assigned to an interface.

 - Properly substitute type names in the names of instantiated methods.

 - New accessor methods for types.Type.RParam.

 - To deal with generic types which are empty structs (or just don't use
   their type params anywhere), we want to set HasTParam if a named type
   has any type params that are not fully instantiated, even if the
   type param is not used in the type.

 - In subst.typ() and elsewhere, always set sym.Def for a new forwarding
   type we are creating, so we always create a single unique type for
   each generic type instantiation. This handles recursion within a
   type, and also recursive relationships across many types or methods.
   We remove the seen[] hashtable, which was serving the same purpose,
   but for subst.typ() only. We now handle all kinds of recursive types.

 - We don't seem to need to force types.CheckSize() on
   created/substituted generic types anymore, so commented out for now.

 - Add an RParams accessor to types2.Signature, and also a new
   exported types2.AsSignature() function.

Change-Id: If6c5dd98427b20bfe9de3379cc16f83df9c9b632
Reviewed-on: https://go-review.googlesource.com/c/go/+/298449
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/decl.go     |  10 +-
 src/cmd/compile/internal/noder/irgen.go    |   3 +
 src/cmd/compile/internal/noder/stencil.go  | 371 +++++++++++++++------
 src/cmd/compile/internal/noder/types.go    | 125 +++++--
 src/cmd/compile/internal/noder/validate.go |   4 +-
 src/cmd/compile/internal/types/type.go     |  38 ++-
 src/cmd/compile/internal/types2/type.go    |   8 +-
 test/typeparam/cons.go                     | 101 ++++++
 test/typeparam/ordered.go                  |  95 ++++++
 test/typeparam/settable.go                 |   4 +-
 10 files changed, 620 insertions(+), 139 deletions(-)
 create mode 100644 test/typeparam/cons.go
 create mode 100644 test/typeparam/ordered.go

diff --git a/src/cmd/compile/internal/noder/decl.go b/src/cmd/compile/internal/noder/decl.go
index a1596be4a4..f0cdcbfc2e 100644
--- a/src/cmd/compile/internal/noder/decl.go
+++ b/src/cmd/compile/internal/noder/decl.go
@@ -134,14 +134,14 @@ func (g *irgen) typeDecl(out *ir.Nodes, decl *syntax.TypeDecl) {
 	}
 
 	// We need to use g.typeExpr(decl.Type) here to ensure that for
-	// chained, defined-type declarations like
+	// chained, defined-type declarations like:
 	//
 	//	type T U
 	//
 	//	//go:notinheap
 	//	type U struct { … }
 	//
-	// that we mark both T and U as NotInHeap. If we instead used just
+	// we mark both T and U as NotInHeap. If we instead used just
 	// g.typ(otyp.Underlying()), then we'd instead set T's underlying
 	// type directly to the struct type (which is not marked NotInHeap)
 	// and fail to mark T as NotInHeap.
@@ -154,6 +154,12 @@ func (g *irgen) typeDecl(out *ir.Nodes, decl *syntax.TypeDecl) {
 	// [mdempsky: Subtleties like these are why I always vehemently
 	// object to new type pragmas.]
 	ntyp.SetUnderlying(g.typeExpr(decl.Type))
+	if len(decl.TParamList) > 0 {
+		// Set HasTParam if there are any tparams, even if no tparams are
+		// used in the type itself (e.g., if it is an empty struct, or no
+		// fields in the struct use the tparam).
+		ntyp.SetHasTParam(true)
+	}
 	types.ResumeCheckSize()
 
 	if otyp, ok := otyp.(*types2.Named); ok && otyp.NumMethods() != 0 {
diff --git a/src/cmd/compile/internal/noder/irgen.go b/src/cmd/compile/internal/noder/irgen.go
index da5b024b1a..06b234c31d 100644
--- a/src/cmd/compile/internal/noder/irgen.go
+++ b/src/cmd/compile/internal/noder/irgen.go
@@ -100,6 +100,9 @@ type irgen struct {
 	objs   map[types2.Object]*ir.Name
 	typs   map[types2.Type]*types.Type
 	marker dwarfgen.ScopeMarker
+
+	// Fully-instantiated generic types whose methods should be instantiated
+	instTypeList []*types.Type
 }
 
 func (g *irgen) generate(noders []*noder) {
diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index fb1bbfedc8..8001d6d398 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -18,10 +18,25 @@ import (
 	"strings"
 )
 
-// stencil scans functions for instantiated generic function calls and
-// creates the required stencils for simple generic functions.
+// For catching problems as we add more features
+// TODO(danscales): remove assertions or replace with base.FatalfAt()
+func assert(p bool) {
+	if !p {
+		panic("assertion failed")
+	}
+}
+
+// stencil scans functions for instantiated generic function calls and creates the
+// required instantiations for simple generic functions. It also creates
+// instantiated methods for all fully-instantiated generic types that have been
+// encountered already or new ones that are encountered during the stenciling
+// process.
 func (g *irgen) stencil() {
 	g.target.Stencils = make(map[*types.Sym]*ir.Func)
+
+	// Instantiate the methods of instantiated generic types that we have seen so far.
+	g.instantiateMethods()
+
 	// Don't use range(g.target.Decls) - we also want to process any new instantiated
 	// functions that are created during this loop, in order to handle generic
 	// functions calling other generic functions.
@@ -65,7 +80,7 @@ func (g *irgen) stencil() {
 			// instantiation.
 			call := n.(*ir.CallExpr)
 			inst := call.X.(*ir.InstExpr)
-			st := g.getInstantiation(inst)
+			st := g.getInstantiationForNode(inst)
 			// Replace the OFUNCINST with a direct reference to the
 			// new stenciled function
 			call.X = st.Nname
@@ -94,7 +109,7 @@ func (g *irgen) stencil() {
 			var edit func(ir.Node) ir.Node
 			edit = func(x ir.Node) ir.Node {
 				if x.Op() == ir.OFUNCINST {
-					st := g.getInstantiation(x.(*ir.InstExpr))
+					st := g.getInstantiationForNode(x.(*ir.InstExpr))
 					return st.Nname
 				}
 				ir.EditChildren(x, edit)
@@ -105,27 +120,65 @@ func (g *irgen) stencil() {
 		if base.Flag.W > 1 && modified {
 			ir.Dump(fmt.Sprintf("\nmodified %v", decl), decl)
 		}
+		// We may have seen new fully-instantiated generic types while
+		// instantiating any needed functions/methods in the above
+		// function. If so, instantiate all the methods of those types
+		// (which will then lead to more function/methods to scan in the loop).
+		g.instantiateMethods()
 	}
 
 }
 
-// getInstantiation gets the instantiated function corresponding to inst. If the
-// instantiated function is not already cached, then it calls genericStub to
-// create the new instantiation.
-func (g *irgen) getInstantiation(inst *ir.InstExpr) *ir.Func {
-	var sym *types.Sym
+// instantiateMethods instantiates all the methods of all fully-instantiated
+// generic types that have been added to g.instTypeList.
+func (g *irgen) instantiateMethods() {
+	for i := 0; i < len(g.instTypeList); i++ {
+		typ := g.instTypeList[i]
+		// Get the base generic type by looking up the symbol of the
+		// generic (uninstantiated) name.
+		baseSym := typ.Sym().Pkg.Lookup(genericTypeName(typ.Sym()))
+		baseType := baseSym.Def.(*ir.Name).Type()
+		for j, m := range typ.Methods().Slice() {
+			name := m.Nname.(*ir.Name)
+			targs := make([]ir.Node, len(typ.RParams()))
+			for k, targ := range typ.RParams() {
+				targs[k] = ir.TypeNode(targ)
+			}
+			baseNname := baseType.Methods().Slice()[j].Nname.(*ir.Name)
+			name.Func = g.getInstantiation(baseNname, targs, true)
+		}
+	}
+	g.instTypeList = nil
+
+}
+
+// genericSym returns the name of the base generic type for the type named by
+// sym. It simply returns the name obtained by removing everything after the
+// first bracket ("[").
+func genericTypeName(sym *types.Sym) string {
+	return sym.Name[0:strings.Index(sym.Name, "[")]
+}
+
+// getInstantiationForNode returns the function/method instantiation for a
+// InstExpr node inst.
+func (g *irgen) getInstantiationForNode(inst *ir.InstExpr) *ir.Func {
 	if meth, ok := inst.X.(*ir.SelectorExpr); ok {
-		// Write the name of the generic method, including receiver type
-		sym = makeInstName(meth.Selection.Nname.Sym(), inst.Targs)
+		return g.getInstantiation(meth.Selection.Nname.(*ir.Name), inst.Targs, true)
 	} else {
-		sym = makeInstName(inst.X.(*ir.Name).Name().Sym(), inst.Targs)
+		return g.getInstantiation(inst.X.(*ir.Name), inst.Targs, false)
 	}
-	//fmt.Printf("Found generic func call in %v to %v\n", f, s)
+}
+
+// getInstantiation gets the instantiantion of the function or method nameNode
+// with the type arguments targs. If the instantiated function is not already
+// cached, then it calls genericSubst to create the new instantiation.
+func (g *irgen) getInstantiation(nameNode *ir.Name, targs []ir.Node, isMeth bool) *ir.Func {
+	sym := makeInstName(nameNode.Sym(), targs, isMeth)
 	st := g.target.Stencils[sym]
 	if st == nil {
 		// If instantiation doesn't exist yet, create it and add
 		// to the list of decls.
-		st = g.genericSubst(sym, inst)
+		st = g.genericSubst(sym, nameNode, targs, isMeth)
 		g.target.Stencils[sym] = st
 		g.target.Decls = append(g.target.Decls, st)
 		if base.Flag.W > 1 {
@@ -135,11 +188,29 @@ func (g *irgen) getInstantiation(inst *ir.InstExpr) *ir.Func {
 	return st
 }
 
-// makeInstName makes the unique name for a stenciled generic function, based on
-// the name of the function and the targs.
-func makeInstName(fnsym *types.Sym, targs []ir.Node) *types.Sym {
-	b := bytes.NewBufferString("#")
-	b.WriteString(fnsym.Name)
+// makeInstName makes the unique name for a stenciled generic function or method,
+// based on the name of the function fy=nsym and the targs. It replaces any
+// existing bracket type list in the name. makeInstName asserts that fnsym has
+// brackets in its name if and only if hasBrackets is true.
+// TODO(danscales): remove the assertions and the hasBrackets argument later.
+//
+// Names of declared generic functions have no brackets originally, so hasBrackets
+// should be false. Names of generic methods already have brackets, since the new
+// type parameter is specified in the generic type of the receiver (e.g. func
+// (func (v *value[T]).set(...) { ... } has the original name (*value[T]).set.
+//
+// The standard naming is something like: 'genFn[int,bool]' for functions and
+// '(*genType[int,bool]).methodName' for methods
+func makeInstName(fnsym *types.Sym, targs []ir.Node, hasBrackets bool) *types.Sym {
+	b := bytes.NewBufferString("")
+	name := fnsym.Name
+	i := strings.Index(name, "[")
+	assert(hasBrackets == (i >= 0))
+	if i >= 0 {
+		b.WriteString(name[0:i])
+	} else {
+		b.WriteString(name)
+	}
 	b.WriteString("[")
 	for i, targ := range targs {
 		if i > 0 {
@@ -148,60 +219,64 @@ func makeInstName(fnsym *types.Sym, targs []ir.Node) *types.Sym {
 		b.WriteString(targ.Type().String())
 	}
 	b.WriteString("]")
+	if i >= 0 {
+		i2 := strings.Index(name[i:], "]")
+		assert(i2 >= 0)
+		b.WriteString(name[i+i2+1:])
+	}
 	return typecheck.Lookup(b.String())
 }
 
 // Struct containing info needed for doing the substitution as we create the
 // instantiation of a generic function with specified type arguments.
 type subster struct {
-	g       *irgen
-	newf    *ir.Func // Func node for the new stenciled function
-	tparams []*types.Field
-	targs   []ir.Node
+	g        *irgen
+	isMethod bool     // If a method is being instantiated
+	newf     *ir.Func // Func node for the new stenciled function
+	tparams  []*types.Field
+	targs    []ir.Node
 	// The substitution map from name nodes in the generic function to the
 	// name nodes in the new stenciled function.
 	vars map[*ir.Name]*ir.Name
-	seen map[*types.Type]*types.Type
 }
 
-// genericSubst returns a new function with the specified name. The function is an
-// instantiation of a generic function or method with type params, as specified by
-// inst. For a method with a generic receiver, it returns an instantiated function
-// type where the receiver becomes the first parameter. Otherwise the instantiated
-// method would still need to be transformed by later compiler phases.
-func (g *irgen) genericSubst(name *types.Sym, inst *ir.InstExpr) *ir.Func {
-	var nameNode *ir.Name
+// genericSubst returns a new function with name newsym. The function is an
+// instantiation of a generic function or method specified by namedNode with type
+// args targs. For a method with a generic receiver, it returns an instantiated
+// function type where the receiver becomes the first parameter. Otherwise the
+// instantiated method would still need to be transformed by later compiler
+// phases.
+func (g *irgen) genericSubst(newsym *types.Sym, nameNode *ir.Name, targs []ir.Node, isMethod bool) *ir.Func {
 	var tparams []*types.Field
-	if selExpr, ok := inst.X.(*ir.SelectorExpr); ok {
+	if isMethod {
 		// Get the type params from the method receiver (after skipping
 		// over any pointer)
-		nameNode = ir.AsNode(selExpr.Selection.Nname).(*ir.Name)
-		recvType := selExpr.Type().Recv().Type
-		if recvType.IsPtr() {
-			recvType = recvType.Elem()
-		}
-		tparams = make([]*types.Field, len(recvType.RParams))
-		for i, rparam := range recvType.RParams {
+		recvType := nameNode.Type().Recv().Type
+		recvType = deref(recvType)
+		tparams = make([]*types.Field, len(recvType.RParams()))
+		for i, rparam := range recvType.RParams() {
 			tparams[i] = types.NewField(src.NoXPos, nil, rparam)
 		}
 	} else {
-		nameNode = inst.X.(*ir.Name)
 		tparams = nameNode.Type().TParams().Fields().Slice()
 	}
 	gf := nameNode.Func
-	newf := ir.NewFunc(inst.Pos())
-	newf.Nname = ir.NewNameAt(inst.Pos(), name)
+	// Pos of the instantiated function is same as the generic function
+	newf := ir.NewFunc(gf.Pos())
+	newf.Nname = ir.NewNameAt(gf.Pos(), newsym)
 	newf.Nname.Func = newf
 	newf.Nname.Defn = newf
-	name.Def = newf.Nname
+	newsym.Def = newf.Nname
+
+	assert(len(tparams) == len(targs))
 
 	subst := &subster{
-		g:       g,
-		newf:    newf,
-		tparams: tparams,
-		targs:   inst.Targs,
-		vars:    make(map[*ir.Name]*ir.Name),
-		seen:    make(map[*types.Type]*types.Type),
+		g:        g,
+		isMethod: isMethod,
+		newf:     newf,
+		tparams:  tparams,
+		targs:    targs,
+		vars:     make(map[*ir.Name]*ir.Name),
 	}
 
 	newf.Dcl = make([]*ir.Name, len(gf.Dcl))
@@ -213,7 +288,7 @@ func (g *irgen) genericSubst(name *types.Sym, inst *ir.InstExpr) *ir.Func {
 	// Ugly: we have to insert the Name nodes of the parameters/results into
 	// the function type. The current function type has no Nname fields set,
 	// because it came via conversion from the types2 type.
-	oldt := inst.X.Type()
+	oldt := nameNode.Type()
 	// We also transform a generic method type to the corresponding
 	// instantiated function type where the receiver is the first parameter.
 	newt := types.NewSignature(oldt.Pkg(), nil, nil,
@@ -326,7 +401,9 @@ func (subst *subster) node(n ir.Node) ir.Node {
 			}
 			newfn.SetIsHiddenClosure(true)
 			m.(*ir.ClosureExpr).Func = newfn
-			newsym := makeInstName(oldfn.Nname.Sym(), subst.targs)
+			// Closure name can already have brackets, if it derives
+			// from a generic method
+			newsym := makeInstName(oldfn.Nname.Sym(), subst.targs, subst.isMethod)
 			newfn.Nname = ir.NewNameAt(oldfn.Nname.Pos(), newsym)
 			newfn.Nname.Func = newfn
 			newfn.Nname.Defn = newfn
@@ -379,6 +456,12 @@ func (subst *subster) list(l []ir.Node) []ir.Node {
 // Nname is in subst.vars.
 func (subst *subster) tstruct(t *types.Type) *types.Type {
 	if t.NumFields() == 0 {
+		if t.HasTParam() {
+			// For an empty struct, we need to return a new type,
+			// since it may now be fully instantiated (HasTParam
+			// becomes false).
+			return types.NewStruct(t.Pkg(), nil)
+		}
 		return t
 	}
 	var newfields []*types.Field
@@ -391,12 +474,21 @@ func (subst *subster) tstruct(t *types.Type) *types.Type {
 			}
 		}
 		if newfields != nil {
+			// TODO(danscales): make sure this works for the field
+			// names of embedded types (which should keep the name of
+			// the type param, not the instantiated type).
 			newfields[i] = types.NewField(f.Pos, f.Sym, t2)
 			if f.Nname != nil {
 				// f.Nname may not be in subst.vars[] if this is
 				// a function name or a function instantiation type
 				// that we are translating
-				newfields[i].Nname = subst.vars[f.Nname.(*ir.Name)]
+				v := subst.vars[f.Nname.(*ir.Name)]
+				// Be careful not to put a nil var into Nname,
+				// since Nname is an interface, so it would be a
+				// non-nil interface.
+				if v != nil {
+					newfields[i].Nname = v
+				}
 			}
 		}
 	}
@@ -407,7 +499,32 @@ func (subst *subster) tstruct(t *types.Type) *types.Type {
 
 }
 
-// instTypeName creates a name for an instantiated type, based on the type args
+// tinter substitutes type params in types of the methods of an interface type.
+func (subst *subster) tinter(t *types.Type) *types.Type {
+	if t.Methods().Len() == 0 {
+		return t
+	}
+	var newfields []*types.Field
+	for i, f := range t.Methods().Slice() {
+		t2 := subst.typ(f.Type)
+		if (t2 != f.Type || f.Nname != nil) && newfields == nil {
+			newfields = make([]*types.Field, t.NumFields())
+			for j := 0; j < i; j++ {
+				newfields[j] = t.Methods().Slice()[j]
+			}
+		}
+		if newfields != nil {
+			newfields[i] = types.NewField(f.Pos, f.Sym, t2)
+		}
+	}
+	if newfields != nil {
+		return types.NewInterface(t.Pkg(), newfields)
+	}
+	return t
+}
+
+// instTypeName creates a name for an instantiated type, based on the name of the
+// generic type and the type args
 func instTypeName(name string, targs []*types.Type) string {
 	b := bytes.NewBufferString(name)
 	b.WriteByte('[')
@@ -423,27 +540,57 @@ func instTypeName(name string, targs []*types.Type) string {
 
 // typ computes the type obtained by substituting any type parameter in t with the
 // corresponding type argument in subst. If t contains no type parameters, the
-// result is t; otherwise the result is a new type.
-// It deals with recursive types by using a map and TFORW types.
-// TODO(danscales) deal with recursion besides ptr/struct cases.
+// result is t; otherwise the result is a new type. It deals with recursive types
+// by using TFORW types and finding partially or fully created types via sym.Def.
 func (subst *subster) typ(t *types.Type) *types.Type {
 	if !t.HasTParam() {
 		return t
 	}
-	if subst.seen[t] != nil {
-		// We've hit a recursive type
-		return subst.seen[t]
-	}
 
-	var newt *types.Type
-	switch t.Kind() {
-	case types.TTYPEPARAM:
+	if t.Kind() == types.TTYPEPARAM {
 		for i, tp := range subst.tparams {
 			if tp.Type == t {
 				return subst.targs[i].Type()
 			}
 		}
 		return t
+	}
+
+	var newsym *types.Sym
+	var neededTargs []*types.Type
+	var forw *types.Type
+
+	if t.Sym() != nil {
+		// Translate the type params for this type according to
+		// the tparam/targs mapping from subst.
+		neededTargs = make([]*types.Type, len(t.RParams()))
+		for i, rparam := range t.RParams() {
+			neededTargs[i] = subst.typ(rparam)
+		}
+		// For a named (defined) type, we have to change the name of the
+		// type as well. We do this first, so we can look up if we've
+		// already seen this type during this substitution or other
+		// definitions/substitutions.
+		genName := genericTypeName(t.Sym())
+		newsym = t.Sym().Pkg.Lookup(instTypeName(genName, neededTargs))
+		if newsym.Def != nil {
+			// We've already created this instantiated defined type.
+			return newsym.Def.Type()
+		}
+
+		// In order to deal with recursive generic types, create a TFORW type
+		// initially and set its Def field, so it can be found if this type
+		// appears recursively within the type.
+		forw = types.New(types.TFORW)
+		forw.SetSym(newsym)
+		newsym.Def = ir.TypeNode(forw)
+		//println("Creating new type by sub", newsym.Name, forw.HasTParam())
+		forw.SetRParams(neededTargs)
+	}
+
+	var newt *types.Type
+
+	switch t.Kind() {
 
 	case types.TARRAY:
 		elem := t.Elem()
@@ -454,17 +601,10 @@ func (subst *subster) typ(t *types.Type) *types.Type {
 
 	case types.TPTR:
 		elem := t.Elem()
-		// In order to deal with recursive generic types, create a TFORW
-		// type initially and store it in the seen map, so it can be
-		// accessed if this type appears recursively within the type.
-		forw := types.New(types.TFORW)
-		subst.seen[t] = forw
 		newelem := subst.typ(elem)
 		if newelem != elem {
-			forw.SetUnderlying(types.NewPtr(newelem))
-			newt = forw
+			newt = types.NewPtr(newelem)
 		}
-		delete(subst.seen, t)
 
 	case types.TSLICE:
 		elem := t.Elem()
@@ -474,14 +614,10 @@ func (subst *subster) typ(t *types.Type) *types.Type {
 		}
 
 	case types.TSTRUCT:
-		forw := types.New(types.TFORW)
-		subst.seen[t] = forw
 		newt = subst.tstruct(t)
-		if newt != t {
-			forw.SetUnderlying(newt)
-			newt = forw
+		if newt == t {
+			newt = nil
 		}
-		delete(subst.seen, t)
 
 	case types.TFUNC:
 		newrecvs := subst.tstruct(t.Recvs())
@@ -492,40 +628,61 @@ func (subst *subster) typ(t *types.Type) *types.Type {
 			if newrecvs.NumFields() > 0 {
 				newrecv = newrecvs.Field(0)
 			}
-			newt = types.NewSignature(t.Pkg(), newrecv, nil, newparams.FieldSlice(), newresults.FieldSlice())
+			newt = types.NewSignature(t.Pkg(), newrecv, t.TParams().FieldSlice(), newparams.FieldSlice(), newresults.FieldSlice())
+		}
+
+	case types.TINTER:
+		newt = subst.tinter(t)
+		if newt == t {
+			newt = nil
 		}
 
 		// TODO: case TCHAN
 		// TODO: case TMAP
-		// TODO: case TINTER
 	}
-	if newt != nil {
-		if t.Sym() != nil {
-			// Since we've substituted types, we also need to change
-			// the defined name of the type, by removing the old types
-			// (in brackets) from the name, and adding the new types.
-
-			// Translate the type params for this type according to
-			// the tparam/targs mapping of the function.
-			neededTargs := make([]*types.Type, len(t.RParams))
-			for i, rparam := range t.RParams {
-				neededTargs[i] = subst.typ(rparam)
-			}
-			oldname := t.Sym().Name
-			i := strings.Index(oldname, "[")
-			oldname = oldname[:i]
-			sym := t.Sym().Pkg.Lookup(instTypeName(oldname, neededTargs))
-			if sym.Def != nil {
-				// We've already created this instantiated defined type.
-				return sym.Def.Type()
-			}
-			newt.SetSym(sym)
-			sym.Def = ir.TypeNode(newt)
-		}
+	if newt == nil {
+		// Even though there were typeparams in the type, there may be no
+		// change if this is a function type for a function call (which will
+		// have its own tparams/targs in the function instantiation).
+		return t
+	}
+
+	if t.Sym() == nil {
+		// Not a named type, so there was no forwarding type and there are
+		// no methods to substitute.
+		assert(t.Methods().Len() == 0)
 		return newt
 	}
 
-	return t
+	forw.SetUnderlying(newt)
+	newt = forw
+
+	if t.Kind() != types.TINTER && t.Methods().Len() > 0 {
+		// Fill in the method info for the new type.
+		var newfields []*types.Field
+		newfields = make([]*types.Field, t.Methods().Len())
+		for i, f := range t.Methods().Slice() {
+			t2 := subst.typ(f.Type)
+			oldsym := f.Nname.Sym()
+			newsym := makeInstName(oldsym, subst.targs, true)
+			var nname *ir.Name
+			if newsym.Def != nil {
+				nname = newsym.Def.(*ir.Name)
+			} else {
+				nname = ir.NewNameAt(f.Pos, newsym)
+				nname.SetType(t2)
+				newsym.Def = nname
+			}
+			newfields[i] = types.NewField(f.Pos, f.Sym, t2)
+			newfields[i].Nname = nname
+		}
+		newt.Methods().Set(newfields)
+		if !newt.HasTParam() {
+			// Generate all the methods for a new fully-instantiated type.
+			subst.g.instTypeList = append(subst.g.instTypeList, newt)
+		}
+	}
+	return newt
 }
 
 // fields sets the Nname field for the Field nodes inside a type signature, based
@@ -554,3 +711,11 @@ func (subst *subster) fields(class ir.Class, oldfields []*types.Field, dcl []*ir
 	}
 	return newfields
 }
+
+// defer does a single defer of type t, if it is a pointer type.
+func deref(t *types.Type) *types.Type {
+	if t.IsPtr() {
+		return t.Elem()
+	}
+	return t
+}
diff --git a/src/cmd/compile/internal/noder/types.go b/src/cmd/compile/internal/noder/types.go
index c23295c3a1..dfcf55d9c8 100644
--- a/src/cmd/compile/internal/noder/types.go
+++ b/src/cmd/compile/internal/noder/types.go
@@ -12,6 +12,7 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/compile/internal/types2"
 	"cmd/internal/src"
+	"strings"
 )
 
 func (g *irgen) pkg(pkg *types2.Package) *types.Pkg {
@@ -29,11 +30,10 @@ func (g *irgen) pkg(pkg *types2.Package) *types.Pkg {
 // typ converts a types2.Type to a types.Type, including caching of previously
 // translated types.
 func (g *irgen) typ(typ types2.Type) *types.Type {
-	// Caching type mappings isn't strictly needed, because typ0 preserves
-	// type identity; but caching minimizes memory blow-up from mapping the
-	// same composite type multiple times, and also plays better with the
-	// current state of cmd/compile (e.g., haphazard calculation of type
-	// sizes).
+	// Cache type2-to-type mappings. Important so that each defined generic
+	// type (instantiated or not) has a single types.Type representation.
+	// Also saves a lot of computation and memory by avoiding re-translating
+	// types2 types repeatedly.
 	res, ok := g.typs[typ]
 	if !ok {
 		res = g.typ0(typ)
@@ -42,9 +42,9 @@ func (g *irgen) typ(typ types2.Type) *types.Type {
 		// Ensure we calculate the size for all concrete types seen by
 		// the frontend. This is another heavy hammer for something that
 		// should really be the backend's responsibility instead.
-		if res != nil && !res.IsUntyped() && !res.IsFuncArgStruct() {
-			types.CheckSize(res)
-		}
+		//if res != nil && !res.IsUntyped() && !res.IsFuncArgStruct() {
+		//	types.CheckSize(res)
+		//}
 	}
 	return res
 }
@@ -99,27 +99,35 @@ func (g *irgen) typ0(typ types2.Type) *types.Type {
 
 			// Create a forwarding type first and put it in the g.typs
 			// map, in order to deal with recursive generic types.
+			// Fully set up the extra ntyp information (Def, RParams,
+			// which may set HasTParam) before translating the
+			// underlying type itself, so we handle recursion
+			// correctly, including via method signatures.
 			ntyp := types.New(types.TFORW)
 			g.typs[typ] = ntyp
-			ntyp.SetUnderlying(g.typ(typ.Underlying()))
 			ntyp.SetSym(s)
+			s.Def = ir.TypeNode(ntyp)
 
-			if ntyp.HasTParam() {
-				// If ntyp still has type params, then we must be
-				// referencing something like 'value[T2]', as when
-				// specifying the generic receiver of a method,
-				// where value was defined as "type value[T any]
-				// ...". Save the type args, which will now be the
-				// new type params of the current type.
-				ntyp.RParams = make([]*types.Type, len(typ.TArgs()))
-				for i, targ := range typ.TArgs() {
-					ntyp.RParams[i] = g.typ(targ)
-				}
+			// If ntyp still has type params, then we must be
+			// referencing something like 'value[T2]', as when
+			// specifying the generic receiver of a method,
+			// where value was defined as "type value[T any]
+			// ...". Save the type args, which will now be the
+			// new type  of the current type.
+			//
+			// If ntyp does not have type params, we are saving the
+			// concrete types used to instantiate this type. We'll use
+			// these when instantiating the methods of the
+			// instantiated type.
+			rparams := make([]*types.Type, len(typ.TArgs()))
+			for i, targ := range typ.TArgs() {
+				rparams[i] = g.typ(targ)
 			}
+			ntyp.SetRParams(rparams)
+			//fmt.Printf("Saw new type %v %v\n", instName, ntyp.HasTParam())
 
-			// Make sure instantiated type can be uniquely found from
-			// the sym
-			s.Def = ir.TypeNode(ntyp)
+			ntyp.SetUnderlying(g.typ(typ.Underlying()))
+			g.fillinMethods(typ, ntyp)
 			return ntyp
 		}
 		obj := g.obj(typ.Obj())
@@ -174,7 +182,9 @@ func (g *irgen) typ0(typ types2.Type) *types.Type {
 	case *types2.TypeParam:
 		tp := types.NewTypeParam(g.tpkg(typ), g.typ(typ.Bound()))
 		// Save the name of the type parameter in the sym of the type.
-		tp.SetSym(g.sym(typ.Obj()))
+		// Include the types2 subscript in the sym name
+		sym := g.pkg(typ.Obj().Pkg()).Lookup(types2.TypeString(typ, func(*types2.Package) string { return "" }))
+		tp.SetSym(sym)
 		return tp
 
 	case *types2.Tuple:
@@ -188,7 +198,7 @@ func (g *irgen) typ0(typ types2.Type) *types.Type {
 			fields[i] = g.param(typ.At(i))
 		}
 		t := types.NewStruct(types.LocalPkg, fields)
-		types.CheckSize(t)
+		//types.CheckSize(t)
 		// Can only set after doing the types.CheckSize()
 		t.StructType().Funarg = types.FunargResults
 		return t
@@ -199,6 +209,71 @@ func (g *irgen) typ0(typ types2.Type) *types.Type {
 	}
 }
 
+// fillinMethods fills in the method name nodes and types for a defined type. This
+// is needed for later typechecking when looking up methods of instantiated types,
+// and for actually generating the methods for instantiated types.
+func (g *irgen) fillinMethods(typ *types2.Named, ntyp *types.Type) {
+	if typ.NumMethods() != 0 {
+		targs := make([]ir.Node, len(typ.TArgs()))
+		for i, targ := range typ.TArgs() {
+			targs[i] = ir.TypeNode(g.typ(targ))
+		}
+
+		methods := make([]*types.Field, typ.NumMethods())
+		for i := range methods {
+			m := typ.Method(i)
+			meth := g.obj(m)
+			recvType := types2.AsSignature(m.Type()).Recv().Type()
+			ptr := types2.AsPointer(recvType)
+			if ptr != nil {
+				recvType = ptr.Elem()
+			}
+			if recvType != types2.Type(typ) {
+				// Unfortunately, meth is the type of the method of the
+				// generic type, so we have to do a substitution to get
+				// the name/type of the method of the instantiated type,
+				// using m.Type().RParams() and typ.TArgs()
+				inst2 := instTypeName2("", typ.TArgs())
+				name := meth.Sym().Name
+				i1 := strings.Index(name, "[")
+				i2 := strings.Index(name[i1:], "]")
+				assert(i1 >= 0 && i2 >= 0)
+				// Generate the name of the instantiated method.
+				name = name[0:i1] + inst2 + name[i1+i2+1:]
+				newsym := meth.Sym().Pkg.Lookup(name)
+				var meth2 *ir.Name
+				if newsym.Def != nil {
+					meth2 = newsym.Def.(*ir.Name)
+				} else {
+					meth2 = ir.NewNameAt(meth.Pos(), newsym)
+					rparams := types2.AsSignature(m.Type()).RParams()
+					tparams := make([]*types.Field, len(rparams))
+					for i, rparam := range rparams {
+						tparams[i] = types.NewField(src.NoXPos, nil, g.typ(rparam.Type()))
+					}
+					assert(len(tparams) == len(targs))
+					subst := &subster{
+						g:       g,
+						tparams: tparams,
+						targs:   targs,
+					}
+					// Do the substitution of the type
+					meth2.SetType(subst.typ(meth.Type()))
+					newsym.Def = meth2
+				}
+				meth = meth2
+			}
+			methods[i] = types.NewField(meth.Pos(), g.selector(m), meth.Type())
+			methods[i].Nname = meth
+		}
+		ntyp.Methods().Set(methods)
+		if !ntyp.HasTParam() {
+			// Generate all the methods for a new fully-instantiated type.
+			g.instTypeList = append(g.instTypeList, ntyp)
+		}
+	}
+}
+
 func (g *irgen) signature(recv *types.Field, sig *types2.Signature) *types.Type {
 	tparams2 := sig.TParams()
 	tparams := make([]*types.Field, len(tparams2))
diff --git a/src/cmd/compile/internal/noder/validate.go b/src/cmd/compile/internal/noder/validate.go
index f97f81d5ad..3341de8e04 100644
--- a/src/cmd/compile/internal/noder/validate.go
+++ b/src/cmd/compile/internal/noder/validate.go
@@ -96,9 +96,7 @@ func (g *irgen) unsafeExpr(name string, arg syntax.Expr) int64 {
 	selection := g.info.Selections[sel]
 
 	typ := g.typ(g.info.Types[sel.X].Type)
-	if typ.IsPtr() {
-		typ = typ.Elem()
-	}
+	typ = deref(typ)
 
 	var offset int64
 	for _, i := range selection.Index() {
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index b0516a8259..d76d9b409f 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -177,10 +177,16 @@ type Type struct {
 
 	flags bitset8
 
-	// Type params (in order) of this named type that need to be instantiated.
+	// For defined (named) generic types, the list of type params (in order)
+	// of this type that need to be instantiated. For fully-instantiated
+	// generic types, this is the targs used to instantiate them (which are
+	// used when generating the corresponding instantiated methods). rparams
+	// is only set for named types that are generic or are fully-instantiated
+	// from a generic type.
+
 	// TODO(danscales): for space reasons, should probably be a pointer to a
 	// slice, possibly change the name of this field.
-	RParams []*Type
+	rparams []*Type
 }
 
 func (*Type) CanBeAnSSAAux() {}
@@ -236,6 +242,26 @@ func (t *Type) Pos() src.XPos {
 	return src.NoXPos
 }
 
+func (t *Type) RParams() []*Type {
+	return t.rparams
+}
+
+func (t *Type) SetRParams(rparams []*Type) {
+	t.rparams = rparams
+	if t.HasTParam() {
+		return
+	}
+	// HasTParam should be set if any rparam is or has a type param. This is
+	// to handle the case of a generic type which doesn't reference any of its
+	// type params (e.g. most commonly, an empty struct).
+	for _, rparam := range rparams {
+		if rparam.HasTParam() {
+			t.SetHasTParam(true)
+			break
+		}
+	}
+}
+
 // NoPkg is a nil *Pkg value for clarity.
 // It's intended for use when constructing types that aren't exported
 // and thus don't need to be associated with any package.
@@ -1702,6 +1728,13 @@ func NewBasic(kind Kind, obj Object) *Type {
 func NewInterface(pkg *Pkg, methods []*Field) *Type {
 	t := New(TINTER)
 	t.SetInterface(methods)
+	for _, f := range methods {
+		// f.Type could be nil for a broken interface declaration
+		if f.Type != nil && f.Type.HasTParam() {
+			t.SetHasTParam(true)
+			break
+		}
+	}
 	if anyBroke(methods) {
 		t.SetBroke(true)
 	}
@@ -1754,6 +1787,7 @@ func NewSignature(pkg *Pkg, recv *Field, tparams, params, results []*Field) *Typ
 	unzeroFieldOffsets(params)
 	unzeroFieldOffsets(results)
 	ft.Receiver = funargs(recvs, FunargRcvr)
+	// TODO(danscales): just use nil here (save memory) if no tparams
 	ft.TParams = funargs(tparams, FunargTparams)
 	ft.Params = funargs(params, FunargParams)
 	ft.Results = funargs(results, FunargResults)
diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
index 52bd99deab..ae6642a059 100644
--- a/src/cmd/compile/internal/types2/type.go
+++ b/src/cmd/compile/internal/types2/type.go
@@ -243,6 +243,9 @@ func (s *Signature) Recv() *Var { return s.recv }
 // TParams returns the type parameters of signature s, or nil.
 func (s *Signature) TParams() []*TypeName { return s.tparams }
 
+// RParams returns the receiver type params of signature s, or nil.
+func (s *Signature) RParams() []*TypeName { return s.rparams }
+
 // SetTParams sets the type parameters of signature s.
 func (s *Signature) SetTParams(tparams []*TypeName) { s.tparams = tparams }
 
@@ -965,5 +968,6 @@ func asTypeParam(t Type) *TypeParam {
 
 // Exported for the compiler.
 
-func AsPointer(t Type) *Pointer { return asPointer(t) }
-func AsNamed(t Type) *Named     { return asNamed(t) }
+func AsPointer(t Type) *Pointer     { return asPointer(t) }
+func AsNamed(t Type) *Named         { return asNamed(t) }
+func AsSignature(t Type) *Signature { return asSignature(t) }
diff --git a/test/typeparam/cons.go b/test/typeparam/cons.go
new file mode 100644
index 0000000000..08a825f59f
--- /dev/null
+++ b/test/typeparam/cons.go
@@ -0,0 +1,101 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// lice
+
+package main
+
+import "fmt"
+
+// Overriding the predeclare "any", so it can be used as a type constraint or a type
+// argument
+type any interface{}
+
+type _Function[a, b any] interface {
+	Apply(x a) b
+}
+
+type incr struct{ n int }
+
+func (this incr) Apply(x int) int {
+	return x + this.n
+}
+
+type pos struct{}
+
+func (this pos) Apply(x int) bool {
+	return x > 0
+}
+
+type compose[a, b, c any] struct {
+	f _Function[a, b]
+	g _Function[b, c]
+}
+
+func (this compose[a, b, c]) Apply(x a) c {
+	return this.g.Apply(this.f.Apply(x))
+}
+
+type _Eq[a any] interface {
+	Equal(a) bool
+}
+
+type Int int
+
+func (this Int) Equal(that int) bool {
+	return int(this) == that
+}
+
+type _List[a any] interface {
+	Match(casenil _Function[_Nil[a], any], casecons _Function[_Cons[a], any]) any
+}
+
+type _Nil[a any] struct{
+}
+
+func (xs _Nil[a]) Match(casenil _Function[_Nil[a], any], casecons _Function[_Cons[a], any]) any {
+	return casenil.Apply(xs)
+}
+
+type _Cons[a any] struct {
+	Head a
+	Tail _List[a]
+}
+
+func (xs _Cons[a]) Match(casenil _Function[_Nil[a], any], casecons _Function[_Cons[a], any]) any {
+	return casecons.Apply(xs)
+}
+
+type mapNil[a, b any] struct{
+}
+
+func (m mapNil[a, b]) Apply(_ _Nil[a]) any {
+	return _Nil[b]{}
+}
+
+type mapCons[a, b any] struct {
+	f _Function[a, b]
+}
+
+func (m mapCons[a, b]) Apply(xs _Cons[a]) any {
+	return _Cons[b]{m.f.Apply(xs.Head), _Map[a, b](m.f, xs.Tail)}
+}
+
+func _Map[a, b any](f _Function[a, b], xs _List[a]) _List[b] {
+	return xs.Match(mapNil[a, b]{}, mapCons[a, b]{f}).(_List[b])
+}
+
+func main() {
+	var xs _List[int] = _Cons[int]{3, _Cons[int]{6, _Nil[int]{}}}
+	// TODO(danscales): Remove conversion calls in next two, needed for now.
+	var ys _List[int] = _Map[int, int](_Function[int, int](incr{-5}), xs)
+	var xz _List[bool] = _Map[int, bool](_Function[int, bool](pos{}), ys)
+	cs1 := xz.(_Cons[bool])
+	cs2 := cs1.Tail.(_Cons[bool])
+	_, ok := cs2.Tail.(_Nil[bool])
+	if cs1.Head != false || cs2.Head != true || !ok {
+		panic(fmt.Sprintf("got %v, %v, %v, expected false, true, true",
+			cs1.Head, cs2.Head, ok))
+	}
+}
diff --git a/test/typeparam/ordered.go b/test/typeparam/ordered.go
new file mode 100644
index 0000000000..448db68bb5
--- /dev/null
+++ b/test/typeparam/ordered.go
@@ -0,0 +1,95 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 (
+	"fmt"
+	"math"
+	"sort"
+)
+
+type Ordered interface {
+	type int, int8, int16, int32, int64,
+		uint, uint8, uint16, uint32, uint64, uintptr,
+		float32, float64,
+		string
+}
+
+type orderedSlice[Elem Ordered] []Elem
+
+func (s orderedSlice[Elem]) Len() int           { return len(s) }
+func (s orderedSlice[Elem]) Less(i, j int) bool {
+	if s[i] < s[j] {
+		return true
+	}
+	isNaN := func(f Elem) bool { return f != f }
+	if isNaN(s[i]) && !isNaN(s[j]) {
+		return true
+	}
+	return false
+}
+func (s orderedSlice[Elem]) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
+func _OrderedSlice[Elem Ordered](s []Elem) {
+	sort.Sort(orderedSlice[Elem](s))
+}
+
+var ints = []int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586}
+var float64s = []float64{74.3, 59.0, math.Inf(1), 238.2, -784.0, 2.3, math.NaN(), math.NaN(), math.Inf(-1), 9845.768, -959.7485, 905, 7.8, 7.8}
+var strings = []string{"", "Hello", "foo", "bar", "foo", "f00", "%*&^*&^&", "***"}
+
+func TestSortOrderedInts() bool {
+	return testOrdered("ints", ints, sort.Ints)
+}
+
+func TestSortOrderedFloat64s() bool {
+	return testOrdered("float64s", float64s, sort.Float64s)
+}
+
+func TestSortOrderedStrings() bool {
+	return testOrdered("strings", strings, sort.Strings)
+}
+
+func testOrdered[Elem Ordered](name string, s []Elem, sorter func([]Elem)) bool {
+	s1 := make([]Elem, len(s))
+	copy(s1, s)
+	s2 := make([]Elem, len(s))
+	copy(s2, s)
+	_OrderedSlice(s1)
+	sorter(s2)
+	ok := true
+	if !sliceEq(s1, s2) {
+		fmt.Printf("%s: got %v, want %v", name, s1, s2)
+		ok = false
+	}
+	for i := len(s1) - 1; i > 0; i-- {
+		if s1[i] < s1[i-1] {
+			fmt.Printf("%s: element %d (%v) < element %d (%v)", name, i, s1[i], i - 1, s1[i - 1])
+			ok = false
+		}
+	}
+	return ok
+}
+
+func sliceEq[Elem Ordered](s1, s2 []Elem) bool {
+	for i, v1 := range s1 {
+		v2 := s2[i]
+		if v1 != v2 {
+			isNaN := func(f Elem) bool { return f != f }
+			if !isNaN(v1) || !isNaN(v2) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func main() {
+	if !TestSortOrderedInts() || !TestSortOrderedFloat64s() || !TestSortOrderedStrings() {
+		panic("failure")
+	}
+}
diff --git a/test/typeparam/settable.go b/test/typeparam/settable.go
index 7532953a77..f42c6574fe 100644
--- a/test/typeparam/settable.go
+++ b/test/typeparam/settable.go
@@ -11,12 +11,12 @@ import (
 	"strconv"
 )
 
-type Setter[B any] interface {
+type _Setter[B any] interface {
         Set(string)
 	type *B
 }
 
-func fromStrings1[T any, PT Setter[T]](s []string) []T {
+func fromStrings1[T any, PT _Setter[T]](s []string) []T {
         result := make([]T, len(s))
         for i, v := range s {
                 // The type of &result[i] is *T which is in the type list
-- 
GitLab


From b60a3a8cfbc6096babe72ebcee0733bba496cf9a Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Fri, 5 Mar 2021 09:49:28 -0800
Subject: [PATCH 0988/2400] cmd/compile: add debugging mode for import/export

Just add a simple magic number with each op, to detect when
the reader gets desynchronized from the writer.

Change-Id: Iac7dab7f465b0021b1d7ae31c8f8a353ac3663a2
Reviewed-on: https://go-review.googlesource.com/c/go/+/299769
Trust: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/typecheck/iexport.go | 8 ++++++++
 src/cmd/compile/internal/typecheck/iimport.go | 3 +++
 2 files changed, 11 insertions(+)

diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index 38ac753201..6f33ca1597 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -246,6 +246,11 @@ const (
 	interfaceType
 )
 
+const (
+	debug = false
+	magic = 0x6742937dc293105
+)
+
 func WriteExports(out *bufio.Writer) {
 	p := iexporter{
 		allPkgs:     map[*types.Pkg]bool{},
@@ -1584,6 +1589,9 @@ func (w *exportWriter) expr(n ir.Node) {
 }
 
 func (w *exportWriter) op(op ir.Op) {
+	if debug {
+		w.uint64(magic)
+	}
 	w.uint64(uint64(op))
 }
 
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 8df75b2285..d7c118b631 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -1228,6 +1228,9 @@ func (r *importReader) node() ir.Node {
 }
 
 func (r *importReader) op() ir.Op {
+	if debug && r.uint64() != magic {
+		base.Fatalf("import stream has desynchronized")
+	}
 	return ir.Op(r.uint64())
 }
 
-- 
GitLab


From e8e425cb231863c1ed1bcf00dd5a517ceeaf6b9c Mon Sep 17 00:00:00 2001
From: Michael Pratt <mpratt@google.com>
Date: Tue, 9 Mar 2021 10:41:16 -0500
Subject: [PATCH 0989/2400] runtime: add pollDesc partial edges

gscan is taken during stack growth, which may occur while pollDesc is
held.

mallocgc may also be called while pollDesc is held. mallocgc may take
mheap or mheapSpecial. The former exists, but is out of order; the
latter is missing.

Fixes #44881

Change-Id: Ie25935d9d433e813c11a528ee47255b317a09f41
Reviewed-on: https://go-review.googlesource.com/c/go/+/300009
Trust: Michael Pratt <mpratt@google.com>
Trust: Dan Scales <danscales@google.com>
Reviewed-by: Dan Scales <danscales@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Pratt <mpratt@google.com>
---
 src/runtime/lockrank.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/runtime/lockrank.go b/src/runtime/lockrank.go
index 23b727f4d8..5a908b470f 100644
--- a/src/runtime/lockrank.go
+++ b/src/runtime/lockrank.go
@@ -224,14 +224,14 @@ var lockPartialOrder [][]lockRank = [][]lockRank{
 	lockRankRwmutexR: {lockRankSysmon, lockRankRwmutexW},
 
 	lockRankSpanSetSpine: {lockRankSysmon, lockRankScavenge, lockRankForcegc, lockRankAssistQueue, lockRankCpuprof, lockRankSweep, lockRankPollDesc, lockRankSched, lockRankAllg, lockRankAllp, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankNotifyList, lockRankTraceBuf, lockRankTraceStrings, lockRankHchan},
-	lockRankGscan:        {lockRankSysmon, lockRankScavenge, lockRankForcegc, lockRankSweepWaiters, lockRankAssistQueue, lockRankCpuprof, lockRankSweep, lockRankSched, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankHchan, lockRankFin, lockRankTraceBuf, lockRankTraceStrings, lockRankRoot, lockRankNotifyList, lockRankProf, lockRankGcBitsArenas, lockRankTrace, lockRankTraceStackTab, lockRankNetpollInit, lockRankSpanSetSpine},
+	lockRankGscan:        {lockRankSysmon, lockRankScavenge, lockRankForcegc, lockRankSweepWaiters, lockRankAssistQueue, lockRankCpuprof, lockRankSweep, lockRankPollDesc, lockRankSched, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankHchan, lockRankFin, lockRankTraceBuf, lockRankTraceStrings, lockRankRoot, lockRankNotifyList, lockRankProf, lockRankGcBitsArenas, lockRankTrace, lockRankTraceStackTab, lockRankNetpollInit, lockRankSpanSetSpine},
 	lockRankStackpool:    {lockRankSysmon, lockRankScavenge, lockRankSweepWaiters, lockRankAssistQueue, lockRankCpuprof, lockRankSweep, lockRankSched, lockRankPollDesc, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankHchan, lockRankFin, lockRankNotifyList, lockRankTraceBuf, lockRankTraceStrings, lockRankProf, lockRankGcBitsArenas, lockRankRoot, lockRankTrace, lockRankTraceStackTab, lockRankNetpollInit, lockRankRwmutexR, lockRankSpanSetSpine, lockRankGscan},
 	lockRankStackLarge:   {lockRankSysmon, lockRankAssistQueue, lockRankSched, lockRankItab, lockRankHchan, lockRankProf, lockRankGcBitsArenas, lockRankRoot, lockRankSpanSetSpine, lockRankGscan},
 	lockRankDefer:        {},
 	lockRankSudog:        {lockRankNotifyList, lockRankHchan},
 	lockRankWbufSpans:    {lockRankSysmon, lockRankScavenge, lockRankSweepWaiters, lockRankAssistQueue, lockRankSweep, lockRankSched, lockRankAllg, lockRankPollDesc, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankHchan, lockRankFin, lockRankNotifyList, lockRankTraceStrings, lockRankMspanSpecial, lockRankProf, lockRankRoot, lockRankGscan, lockRankDefer, lockRankSudog},
-	lockRankMheap:        {lockRankSysmon, lockRankScavenge, lockRankSweepWaiters, lockRankAssistQueue, lockRankCpuprof, lockRankSweep, lockRankSched, lockRankAllg, lockRankAllp, lockRankFin, lockRankPollDesc, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankNotifyList, lockRankTraceBuf, lockRankTraceStrings, lockRankHchan, lockRankMspanSpecial, lockRankProf, lockRankGcBitsArenas, lockRankRoot, lockRankGscan, lockRankStackpool, lockRankStackLarge, lockRankDefer, lockRankSudog, lockRankWbufSpans, lockRankSpanSetSpine},
-	lockRankMheapSpecial: {lockRankSysmon, lockRankScavenge, lockRankAssistQueue, lockRankCpuprof, lockRankSweep, lockRankSched, lockRankAllg, lockRankAllp, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankNotifyList, lockRankTraceBuf, lockRankTraceStrings, lockRankHchan},
+	lockRankMheap:        {lockRankSysmon, lockRankScavenge, lockRankSweepWaiters, lockRankAssistQueue, lockRankCpuprof, lockRankSweep, lockRankPollDesc, lockRankSched, lockRankAllg, lockRankAllp, lockRankFin, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankNotifyList, lockRankTraceBuf, lockRankTraceStrings, lockRankHchan, lockRankMspanSpecial, lockRankProf, lockRankGcBitsArenas, lockRankRoot, lockRankGscan, lockRankStackpool, lockRankStackLarge, lockRankDefer, lockRankSudog, lockRankWbufSpans, lockRankSpanSetSpine},
+	lockRankMheapSpecial: {lockRankSysmon, lockRankScavenge, lockRankAssistQueue, lockRankCpuprof, lockRankSweep, lockRankPollDesc, lockRankSched, lockRankAllg, lockRankAllp, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankNotifyList, lockRankTraceBuf, lockRankTraceStrings, lockRankHchan},
 	lockRankGlobalAlloc:  {lockRankProf, lockRankSpanSetSpine, lockRankMheap, lockRankMheapSpecial},
 
 	lockRankGFree:     {lockRankSched},
-- 
GitLab


From b6df58bd1f3b2a05787f62bbec4267f7867d4bbd Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Fri, 5 Mar 2021 09:50:28 -0800
Subject: [PATCH 0990/2400] cmd/compile: detect duplicate importing earlier

Change-Id: I05ba944e189a884b727e40a9526d212612c3e923
Reviewed-on: https://go-review.googlesource.com/c/go/+/299770
Trust: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/typecheck/func.go    | 11 +++--------
 src/cmd/compile/internal/typecheck/iimport.go |  2 +-
 2 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index 6e2354c281..367df8e9f4 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -108,6 +108,9 @@ var inTypeCheckInl bool
 // Lazy typechecking of imported bodies. For local functions, CanInline will set ->typecheck
 // because they're a copy of an already checked body.
 func ImportedBody(fn *ir.Func) {
+	if fn.Inl.Body != nil {
+		return
+	}
 	lno := ir.SetPos(fn.Nname)
 
 	// When we load an inlined body, we need to allow OADDR
@@ -151,14 +154,6 @@ func ImportedBody(fn *ir.Func) {
 	inTypeCheckInl = false
 	ir.CurFunc = savefn
 
-	// During ImportBody (which imports fn.Func.Inl.Body),
-	// declarations are added to fn.Func.Dcl by funcBody(). Move them
-	// to fn.Func.Inl.Dcl for consistency with how local functions
-	// behave. (Append because ImportedBody may be called multiple
-	// times on same fn.)
-	fn.Inl.Dcl = append(fn.Inl.Dcl, fn.Dcl...)
-	fn.Dcl = nil
-
 	base.Pos = lno
 }
 
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index d7c118b631..5c57373b66 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -63,7 +63,7 @@ func expandDecl(n ir.Node) ir.Node {
 
 func ImportBody(fn *ir.Func) {
 	if fn.Inl.Body != nil {
-		return
+		base.Fatalf("%v already has inline body", fn)
 	}
 
 	r := importReaderFor(fn.Nname.Sym(), inlineImporter)
-- 
GitLab


From 48895d021bf631f15d68ecc10cab89ebd9cb28f6 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Sun, 7 Mar 2021 23:48:02 -0800
Subject: [PATCH 0991/2400] cmd/compile: remove skipping of implicit operations
 during export

We'll need to attach types to these operations, so we need to
represent them in the import/export data.

Some of the operations use a selector indicating a different package,
so we need to provide an option to encode the package of a selector.
The default selector() function can't encode that extra information,
as selector's exact encoding is used by go/types.

Change-Id: I4c110fe347b3d915f88a722834bc4058baea7854
Reviewed-on: https://go-review.googlesource.com/c/go/+/299771
Trust: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/typecheck/iexport.go | 42 ++++++++++++-------
 src/cmd/compile/internal/typecheck/iimport.go | 19 ++++++++-
 2 files changed, 43 insertions(+), 18 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index 6f33ca1597..fa16357066 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -617,6 +617,11 @@ func (w *exportWriter) selector(s *types.Sym) {
 		base.Fatalf("missing currPkg")
 	}
 
+	// If the selector being written is unexported, it comes with a package qualifier.
+	// If the selector being written is exported, it is not package-qualified.
+	// See the spec: https://golang.org/ref/spec#Uniqueness_of_identifiers
+	// As an optimization, we don't actually write the package every time - instead we
+	// call setPkg before a group of selectors (all of which must have the same package qualifier).
 	pkg := w.currPkg
 	if types.IsExported(s.Name) {
 		pkg = types.LocalPkg
@@ -628,6 +633,26 @@ func (w *exportWriter) selector(s *types.Sym) {
 	w.string(s.Name)
 }
 
+// Export a selector, but one whose package may not match
+// the package being compiled. This is a separate function
+// because the standard selector() serialization format is fixed
+// by the go/types reader. This one can only be used during
+// inline/generic body exporting.
+func (w *exportWriter) exoticSelector(s *types.Sym) {
+	pkg := w.currPkg
+	if types.IsExported(s.Name) {
+		pkg = types.LocalPkg
+	}
+
+	w.string(s.Name)
+	if s.Pkg == pkg {
+		w.uint64(0)
+	} else {
+		w.uint64(1)
+		w.pkg(s.Pkg)
+	}
+}
+
 func (w *exportWriter) typ(t *types.Type) {
 	w.data.uint64(w.p.typOff(t))
 }
@@ -1299,21 +1324,6 @@ func simplifyForExport(n ir.Node) ir.Node {
 	case ir.OPAREN:
 		n := n.(*ir.ParenExpr)
 		return simplifyForExport(n.X)
-	case ir.ODEREF:
-		n := n.(*ir.StarExpr)
-		if n.Implicit() {
-			return simplifyForExport(n.X)
-		}
-	case ir.OADDR:
-		n := n.(*ir.AddrExpr)
-		if n.Implicit() {
-			return simplifyForExport(n.X)
-		}
-	case ir.ODOT, ir.ODOTPTR:
-		n := n.(*ir.SelectorExpr)
-		if n.Implicit() {
-			return simplifyForExport(n.X)
-		}
 	}
 	return n
 }
@@ -1437,7 +1447,7 @@ func (w *exportWriter) expr(n ir.Node) {
 		w.op(ir.OXDOT)
 		w.pos(n.Pos())
 		w.expr(n.X)
-		w.selector(n.Sel)
+		w.exoticSelector(n.Sel)
 
 	case ir.ODOTTYPE, ir.ODOTTYPE2:
 		n := n.(*ir.TypeAssertExpr)
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 5c57373b66..91bb215a29 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -466,6 +466,21 @@ func (r *importReader) ident(selector bool) *types.Sym {
 func (r *importReader) localIdent() *types.Sym { return r.ident(false) }
 func (r *importReader) selector() *types.Sym   { return r.ident(true) }
 
+func (r *importReader) exoticSelector() *types.Sym {
+	name := r.string()
+	if name == "" {
+		return nil
+	}
+	pkg := r.currPkg
+	if types.IsExported(name) {
+		pkg = types.LocalPkg
+	}
+	if r.uint64() != 0 {
+		pkg = r.pkg()
+	}
+	return pkg.Lookup(name)
+}
+
 func (r *importReader) qualifiedIdent() *ir.Ident {
 	name := r.string()
 	pkg := r.pkg()
@@ -753,7 +768,7 @@ func (r *importReader) doInline(fn *ir.Func) {
 		base.Fatalf("%v already has inline body", fn)
 	}
 
-	//fmt.Printf("Importing %v\n", n)
+	//fmt.Printf("Importing %s\n", fn.Nname.Sym().Name)
 	r.funcBody(fn)
 
 	importlist = append(importlist, fn)
@@ -1038,7 +1053,7 @@ func (r *importReader) node() ir.Node {
 
 	case ir.OXDOT:
 		// see parser.new_dotname
-		return ir.NewSelectorExpr(r.pos(), ir.OXDOT, r.expr(), r.selector())
+		return ir.NewSelectorExpr(r.pos(), ir.OXDOT, r.expr(), r.exoticSelector())
 
 	// case ODOTTYPE, ODOTTYPE2:
 	// 	unreachable - mapped to case ODOTTYPE below by exporter
-- 
GitLab


From 5eb99120844c0494d655678262e1fb41949a2b99 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Fri, 5 Mar 2021 19:56:13 -0500
Subject: [PATCH 0992/2400] cmd/compile: fix OpArg decomposer for registers in
 expandCalls

Includes test taken from
https://github.com/golang/go/issues/44816#issuecomment-791618179
and improved debugging output.

Updates #44816

Change-Id: I94aeb9c5255f175fe80727be29d218bad54bf7ea
Reviewed-on: https://go-review.googlesource.com/c/go/+/299389
Trust: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/expand_calls.go | 162 +++++++++++++++----
 test/abi/double_nested_struct.go             |   9 +-
 test/abi/struct_lower_1.go                   |  30 ++++
 test/abi/struct_lower_1.out                  |   1 +
 test/abi/too_big_to_ssa.go                   |   7 +-
 5 files changed, 166 insertions(+), 43 deletions(-)
 create mode 100644 test/abi/struct_lower_1.go
 create mode 100644 test/abi/struct_lower_1.out

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index df135853fe..516ea42db9 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -78,7 +78,8 @@ func (rc *registerCursor) String() string {
 			regs = regs + x.LongString()
 		}
 	}
-	return fmt.Sprintf("RCSR{storeDest=%v, regsLen=%d, nextSlice=%d, regValues=[%s], config=%v", dest, rc.regsLen, rc.nextSlice, regs, rc.config)
+	// not printing the config because that has not been useful
+	return fmt.Sprintf("RCSR{storeDest=%v, regsLen=%d, nextSlice=%d, regValues=[%s]}", dest, rc.regsLen, rc.nextSlice, regs)
 }
 
 // next effectively post-increments the register cursor; the receiver is advanced,
@@ -189,6 +190,7 @@ type expandState struct {
 	commonSelectors map[selKey]*Value // used to de-dupe selectors
 	commonArgs      map[selKey]*Value // used to de-dupe OpArg/OpArgIntReg/OpArgFloatReg
 	memForCall      map[ID]*Value     // For a call, need to know the unique selector that gets the mem.
+	indentLevel     int               // Indentation for debugging recursion
 }
 
 // intPairTypes returns the pair of 32-bit int types needed to encode a 64-bit integer type on a target
@@ -267,6 +269,19 @@ func ParamAssignmentForArgName(f *Func, name *ir.Name) *abi.ABIParamAssignment {
 	panic(fmt.Errorf("Did not match param %v in prInfo %+v", name, abiInfo.InParams()))
 }
 
+// indent increments (or decrements) the indentation.
+func (x *expandState) indent(n int) {
+	x.indentLevel += n
+}
+
+// Printf does an indented fmt.Printf on te format and args.
+func (x *expandState) Printf(format string, a ...interface{}) (n int, err error) {
+	if x.indentLevel > 0 {
+		fmt.Printf("%[1]*s", x.indentLevel, "")
+	}
+	return fmt.Printf(format, a...)
+}
+
 // Calls that need lowering have some number of inputs, including a memory input,
 // and produce a tuple of (value1, value2, ..., mem) where valueK may or may not be SSA-able.
 
@@ -286,7 +301,9 @@ func ParamAssignmentForArgName(f *Func, name *ir.Name) *abi.ABIParamAssignment {
 // TODO when registers really arrive, must also decompose anything split across two registers or registers and memory.
 func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64, regOffset Abi1RO) []LocalSlot {
 	if x.debug {
-		fmt.Printf("rewriteSelect(%s, %s, %d)\n", leaf.LongString(), selector.LongString(), offset)
+		x.indent(3)
+		defer x.indent(-3)
+		x.Printf("rewriteSelect(%s, %s, %d)\n", leaf.LongString(), selector.LongString(), offset)
 	}
 	var locs []LocalSlot
 	leafType := leaf.Type
@@ -308,7 +325,7 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64,
 				x.f.Fatalf("Unexpected OpArg type, selector=%s, leaf=%s\n", selector.LongString(), leaf.LongString())
 			}
 			if x.debug {
-				fmt.Printf("\tOpArg, break\n")
+				x.Printf("---OpArg, break\n")
 			}
 			break
 		}
@@ -427,7 +444,7 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64,
 						w := call.Block.NewValue2(leaf.Pos, OpLoad, leafType, off, call)
 						leaf.copyOf(w)
 						if x.debug {
-							fmt.Printf("\tnew %s\n", w.LongString())
+							x.Printf("---new %s\n", w.LongString())
 						}
 					}
 				}
@@ -539,9 +556,86 @@ func (x *expandState) rewriteDereference(b *Block, base, a, mem *Value, offset,
 	return mem
 }
 
-// decomposeArgOrLoad is a helper for storeArgOrLoad.
-// It decomposes a Load or an Arg into smaller parts, parameterized by the decomposeOne and decomposeTwo functions
-// passed to it, and returns the new mem.
+// decomposeArg is a helper for storeArgOrLoad.
+// It decomposes a Load or an Arg into smaller parts and returns the new mem.
+// If the type does not match one of the expected aggregate types, it returns nil instead.
+// Parameters:
+//  pos           -- the location of any generated code.
+//  b             -- the block into which any generated code should normally be placed
+//  source        -- the value, possibly an aggregate, to be stored.
+//  mem           -- the mem flowing into this decomposition (loads depend on it, stores updated it)
+//  t             -- the type of the value to be stored
+//  storeOffset   -- if the value is stored in memory, it is stored at base (see storeRc) + storeOffset
+//  loadRegOffset -- regarding source as a value in registers, the register offset in ABI1.  Meaningful only if source is OpArg.
+//  storeRc       -- storeRC; if the value is stored in registers, this specifies the registers.
+//                   StoreRc also identifies whether the target is registers or memory, and has the base for the store operation.
+func (x *expandState) decomposeArg(pos src.XPos, b *Block, source, mem *Value, t *types.Type, storeOffset int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
+
+	pa := x.prAssignForArg(source)
+	if len(pa.Registers) > 0 {
+		// Handle the in-registers case directly
+		rts, offs := pa.RegisterTypesAndOffsets()
+		last := loadRegOffset + x.regWidth(t)
+		if offs[loadRegOffset] != 0 {
+			panic(fmt.Errorf("offset %d of requested register %d should be zero", offs[loadRegOffset], loadRegOffset))
+		}
+		for i := loadRegOffset; i < last; i++ {
+			rt := rts[i]
+			off := offs[i]
+			w := x.commonArgs[selKey{source, off, rt.Width, rt}]
+			if w == nil {
+				w = x.newArgToMemOrRegs(source, w, off, i, rt, pos)
+			}
+			mem = x.storeArgOrLoad(pos, b, w, mem, rt, storeOffset+off, i, storeRc.next(rt))
+		}
+		return mem
+	}
+
+	u := source.Type
+	switch u.Kind() {
+	case types.TARRAY:
+		elem := u.Elem()
+		elemRO := x.regWidth(elem)
+		for i := int64(0); i < u.NumElem(); i++ {
+			elemOff := i * elem.Size()
+			mem = storeOneArg(x, pos, b, source, mem, elem, elemOff, storeOffset+elemOff, loadRegOffset, storeRc.next(elem))
+			loadRegOffset += elemRO
+			pos = pos.WithNotStmt()
+		}
+		return mem
+	case types.TSTRUCT:
+		for i := 0; i < u.NumFields(); i++ {
+			fld := u.Field(i)
+			mem = storeOneArg(x, pos, b, source, mem, fld.Type, fld.Offset, storeOffset+fld.Offset, loadRegOffset, storeRc.next(fld.Type))
+			loadRegOffset += x.regWidth(fld.Type)
+			pos = pos.WithNotStmt()
+		}
+		return mem
+	case types.TINT64, types.TUINT64:
+		if t.Width == x.regSize {
+			break
+		}
+		tHi, tLo := x.intPairTypes(t.Kind())
+		mem = storeOneArg(x, pos, b, source, mem, tHi, x.hiOffset, storeOffset+x.hiOffset, loadRegOffset+x.hiRo, storeRc.plus(x.hiRo))
+		pos = pos.WithNotStmt()
+		return storeOneArg(x, pos, b, source, mem, tLo, x.lowOffset, storeOffset+x.lowOffset, loadRegOffset+x.loRo, storeRc.plus(x.loRo))
+	case types.TINTER:
+		return storeTwoArg(x, pos, b, source, mem, x.typs.Uintptr, x.typs.BytePtr, 0, storeOffset, loadRegOffset, storeRc)
+	case types.TSTRING:
+		return storeTwoArg(x, pos, b, source, mem, x.typs.BytePtr, x.typs.Int, 0, storeOffset, loadRegOffset, storeRc)
+	case types.TCOMPLEX64:
+		return storeTwoArg(x, pos, b, source, mem, x.typs.Float32, x.typs.Float32, 0, storeOffset, loadRegOffset, storeRc)
+	case types.TCOMPLEX128:
+		return storeTwoArg(x, pos, b, source, mem, x.typs.Float64, x.typs.Float64, 0, storeOffset, loadRegOffset, storeRc)
+	case types.TSLICE:
+		mem = storeOneArg(x, pos, b, source, mem, x.typs.BytePtr, 0, storeOffset, loadRegOffset, storeRc.next(x.typs.BytePtr))
+		return storeTwoArg(x, pos, b, source, mem, x.typs.Int, x.typs.Int, x.ptrSize, storeOffset+x.ptrSize, loadRegOffset+RO_slice_len, storeRc)
+	}
+	return nil
+}
+
+// decomposeLoad is a helper for storeArgOrLoad.
+// It decomposes a Load  into smaller parts and returns the new mem.
 // If the type does not match one of the expected aggregate types, it returns nil instead.
 // Parameters:
 //  pos           -- the location of any generated code.
@@ -555,11 +649,7 @@ func (x *expandState) rewriteDereference(b *Block, base, a, mem *Value, offset,
 //                   StoreRc also identifies whether the target is registers or memory, and has the base for the store operation.
 //
 // TODO -- this needs cleanup; it just works for SSA-able aggregates, and won't fully generalize to register-args aggregates.
-func (x *expandState) decomposeArgOrLoad(pos src.XPos, b *Block, source, mem *Value, t *types.Type, offset int64, loadRegOffset Abi1RO, storeRc registerCursor,
-	// For decompose One and Two, the additional offArg provides the offset from the beginning of "source", if it is in memory.
-	// offStore is combined to base to obtain a store destionation, like "offset" of decomposeArgOrLoad
-	decomposeOne func(x *expandState, pos src.XPos, b *Block, source, mem *Value, t1 *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value,
-	decomposeTwo func(x *expandState, pos src.XPos, b *Block, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value) *Value {
+func (x *expandState) decomposeLoad(pos src.XPos, b *Block, source, mem *Value, t *types.Type, offset int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
 	u := source.Type
 	switch u.Kind() {
 	case types.TARRAY:
@@ -567,7 +657,7 @@ func (x *expandState) decomposeArgOrLoad(pos src.XPos, b *Block, source, mem *Va
 		elemRO := x.regWidth(elem)
 		for i := int64(0); i < u.NumElem(); i++ {
 			elemOff := i * elem.Size()
-			mem = decomposeOne(x, pos, b, source, mem, elem, elemOff, offset+elemOff, loadRegOffset, storeRc.next(elem))
+			mem = storeOneLoad(x, pos, b, source, mem, elem, elemOff, offset+elemOff, loadRegOffset, storeRc.next(elem))
 			loadRegOffset += elemRO
 			pos = pos.WithNotStmt()
 		}
@@ -575,7 +665,7 @@ func (x *expandState) decomposeArgOrLoad(pos src.XPos, b *Block, source, mem *Va
 	case types.TSTRUCT:
 		for i := 0; i < u.NumFields(); i++ {
 			fld := u.Field(i)
-			mem = decomposeOne(x, pos, b, source, mem, fld.Type, fld.Offset, offset+fld.Offset, loadRegOffset, storeRc.next(fld.Type))
+			mem = storeOneLoad(x, pos, b, source, mem, fld.Type, fld.Offset, offset+fld.Offset, loadRegOffset, storeRc.next(fld.Type))
 			loadRegOffset += x.regWidth(fld.Type)
 			pos = pos.WithNotStmt()
 		}
@@ -585,20 +675,20 @@ func (x *expandState) decomposeArgOrLoad(pos src.XPos, b *Block, source, mem *Va
 			break
 		}
 		tHi, tLo := x.intPairTypes(t.Kind())
-		mem = decomposeOne(x, pos, b, source, mem, tHi, x.hiOffset, offset+x.hiOffset, loadRegOffset+x.hiRo, storeRc.plus(x.hiRo))
+		mem = storeOneLoad(x, pos, b, source, mem, tHi, x.hiOffset, offset+x.hiOffset, loadRegOffset+x.hiRo, storeRc.plus(x.hiRo))
 		pos = pos.WithNotStmt()
-		return decomposeOne(x, pos, b, source, mem, tLo, x.lowOffset, offset+x.lowOffset, loadRegOffset+x.loRo, storeRc.plus(x.loRo))
+		return storeOneLoad(x, pos, b, source, mem, tLo, x.lowOffset, offset+x.lowOffset, loadRegOffset+x.loRo, storeRc.plus(x.loRo))
 	case types.TINTER:
-		return decomposeTwo(x, pos, b, source, mem, x.typs.Uintptr, x.typs.BytePtr, 0, offset, loadRegOffset, storeRc)
+		return storeTwoLoad(x, pos, b, source, mem, x.typs.Uintptr, x.typs.BytePtr, 0, offset, loadRegOffset, storeRc)
 	case types.TSTRING:
-		return decomposeTwo(x, pos, b, source, mem, x.typs.BytePtr, x.typs.Int, 0, offset, loadRegOffset, storeRc)
+		return storeTwoLoad(x, pos, b, source, mem, x.typs.BytePtr, x.typs.Int, 0, offset, loadRegOffset, storeRc)
 	case types.TCOMPLEX64:
-		return decomposeTwo(x, pos, b, source, mem, x.typs.Float32, x.typs.Float32, 0, offset, loadRegOffset, storeRc)
+		return storeTwoLoad(x, pos, b, source, mem, x.typs.Float32, x.typs.Float32, 0, offset, loadRegOffset, storeRc)
 	case types.TCOMPLEX128:
-		return decomposeTwo(x, pos, b, source, mem, x.typs.Float64, x.typs.Float64, 0, offset, loadRegOffset, storeRc)
+		return storeTwoLoad(x, pos, b, source, mem, x.typs.Float64, x.typs.Float64, 0, offset, loadRegOffset, storeRc)
 	case types.TSLICE:
-		mem = decomposeOne(x, pos, b, source, mem, x.typs.BytePtr, 0, offset, loadRegOffset, storeRc.next(x.typs.BytePtr))
-		return decomposeTwo(x, pos, b, source, mem, x.typs.Int, x.typs.Int, x.ptrSize, offset+x.ptrSize, loadRegOffset+RO_slice_len, storeRc)
+		mem = storeOneLoad(x, pos, b, source, mem, x.typs.BytePtr, 0, offset, loadRegOffset, storeRc.next(x.typs.BytePtr))
+		return storeTwoLoad(x, pos, b, source, mem, x.typs.Int, x.typs.Int, x.ptrSize, offset+x.ptrSize, loadRegOffset+RO_slice_len, storeRc)
 	}
 	return nil
 }
@@ -642,7 +732,9 @@ func storeTwoLoad(x *expandState, pos src.XPos, b *Block, source, mem *Value, t1
 // If it does not reach a Load or an Arg, nothing happens; this allows a little freedom in phase ordering.
 func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, source, mem *Value, t *types.Type, offset int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
 	if x.debug {
-		fmt.Printf("\tstoreArgOrLoad(%s;  %s;  %s; %d; %s)\n", source.LongString(), mem.String(), t.String(), offset, storeRc.String())
+		x.indent(3)
+		defer x.indent(-3)
+		x.Printf("storeArgOrLoad(%s;  %s;  %s; %d; %s)\n", source.LongString(), mem.String(), t.String(), offset, storeRc.String())
 	}
 
 	// Start with Opcodes that can be disassembled
@@ -651,13 +743,13 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, source, mem *Value,
 		return x.storeArgOrLoad(pos, b, source.Args[0], mem, t, offset, loadRegOffset, storeRc)
 
 	case OpLoad, OpDereference:
-		ret := x.decomposeArgOrLoad(pos, b, source, mem, t, offset, loadRegOffset, storeRc, storeOneLoad, storeTwoLoad)
+		ret := x.decomposeLoad(pos, b, source, mem, t, offset, loadRegOffset, storeRc)
 		if ret != nil {
 			return ret
 		}
 
 	case OpArg:
-		ret := x.decomposeArgOrLoad(pos, b, source, mem, t, offset, loadRegOffset, storeRc, storeOneArg, storeTwoArg)
+		ret := x.decomposeArg(pos, b, source, mem, t, offset, loadRegOffset, storeRc)
 		if ret != nil {
 			return ret
 		}
@@ -823,7 +915,7 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, source, mem *Value,
 		s = b.NewValue3A(pos, OpStore, types.TypeMem, t, dst, source, mem)
 	}
 	if x.debug {
-		fmt.Printf("\t\tstoreArg returns %s, storeRc=%s\n", s.LongString(), storeRc.String())
+		x.Printf("-->storeArg returns %s, storeRc=%s\n", s.LongString(), storeRc.String())
 	}
 	return s
 }
@@ -860,7 +952,7 @@ func (x *expandState) rewriteArgs(v *Value, firstArg int) (*Value, []*Value) {
 				aOffset = aux.OffsetOfArg(auxI)
 			}
 			if x.debug {
-				fmt.Printf("storeArg %s, %v, %d\n", a.LongString(), aType, aOffset)
+				x.Printf("storeArg %s, %v, %d\n", a.LongString(), aType, aOffset)
 			}
 			rc.init(aRegs, aux.abiInfo, result, x.sp)
 			mem = x.storeArgOrLoad(pos, v.Block, a, mem, aType, aOffset, 0, rc)
@@ -910,7 +1002,7 @@ func expandCalls(f *Func) {
 	}
 
 	if x.debug {
-		fmt.Printf("\nexpandsCalls(%s)\n", f.Name)
+		x.Printf("\nexpandsCalls(%s)\n", f.Name)
 	}
 
 	// TODO if too slow, whole program iteration can be replaced w/ slices of appropriate values, accumulated in first loop here.
@@ -1055,7 +1147,7 @@ func expandCalls(f *Func) {
 				case OpStructSelect, OpArraySelect, OpSelectN, OpArg:
 					val2Preds[w] += 1
 					if x.debug {
-						fmt.Printf("v2p[%s] = %d\n", w.LongString(), val2Preds[w])
+						x.Printf("v2p[%s] = %d\n", w.LongString(), val2Preds[w])
 					}
 				}
 				fallthrough
@@ -1064,7 +1156,7 @@ func expandCalls(f *Func) {
 				if _, ok := val2Preds[v]; !ok {
 					val2Preds[v] = 0
 					if x.debug {
-						fmt.Printf("v2p[%s] = %d\n", v.LongString(), val2Preds[v])
+						x.Printf("v2p[%s] = %d\n", v.LongString(), val2Preds[v])
 					}
 				}
 
@@ -1075,7 +1167,7 @@ func expandCalls(f *Func) {
 				if _, ok := val2Preds[v]; !ok {
 					val2Preds[v] = 0
 					if x.debug {
-						fmt.Printf("v2p[%s] = %d\n", v.LongString(), val2Preds[v])
+						x.Printf("v2p[%s] = %d\n", v.LongString(), val2Preds[v])
 					}
 				}
 
@@ -1203,7 +1295,7 @@ func expandCalls(f *Func) {
 	for i, v := range allOrdered {
 		if x.debug {
 			b := v.Block
-			fmt.Printf("allOrdered[%d] = b%d, %s, uses=%d\n", i, b.ID, v.LongString(), v.Uses)
+			x.Printf("allOrdered[%d] = b%d, %s, uses=%d\n", i, b.ID, v.LongString(), v.Uses)
 		}
 		if v.Uses == 0 {
 			v.reset(OpInvalid)
@@ -1305,7 +1397,7 @@ func (x *expandState) rewriteArgToMemOrRegs(v *Value) *Value {
 
 // newArgToMemOrRegs either rewrites toReplace into an OpArg referencing memory or into an OpArgXXXReg to a register,
 // or rewrites it into a copy of the appropriate OpArgXXX.  The actual OpArgXXX is determined by combining baseArg (an OpArg)
-// with offset, regOffset, and t to determine which portion of it reference (either all or a part, in memory or in registers).
+// with offset, regOffset, and t to determine which portion of it to reference (either all or a part, in memory or in registers).
 func (x *expandState) newArgToMemOrRegs(baseArg, toReplace *Value, offset int64, regOffset Abi1RO, t *types.Type, pos src.XPos) *Value {
 	key := selKey{baseArg, offset, t.Width, t}
 	w := x.commonArgs[key]
@@ -1336,7 +1428,7 @@ func (x *expandState) newArgToMemOrRegs(baseArg, toReplace *Value, offset int64,
 			w := baseArg.Block.NewValue0IA(pos, OpArg, t, auxInt, aux)
 			x.commonArgs[key] = w
 			if x.debug {
-				fmt.Printf("\tnew %s\n", w.LongString())
+				x.Printf("---new %s\n", w.LongString())
 			}
 			if toReplace != nil {
 				toReplace.copyOf(w)
@@ -1364,7 +1456,7 @@ func (x *expandState) newArgToMemOrRegs(baseArg, toReplace *Value, offset int64,
 	} else {
 		w := baseArg.Block.NewValue0IA(pos, op, t, auxInt, aux)
 		if x.debug {
-			fmt.Printf("\tnew %s\n", w.LongString())
+			x.Printf("---new %s\n", w.LongString())
 		}
 		x.commonArgs[key] = w
 		if toReplace != nil {
diff --git a/test/abi/double_nested_struct.go b/test/abi/double_nested_struct.go
index 70d8ea4bce..814341e701 100644
--- a/test/abi/double_nested_struct.go
+++ b/test/abi/double_nested_struct.go
@@ -8,7 +8,7 @@
 // license that can be found in the LICENSE file.
 
 // wasm is excluded because the compiler chatter about register abi pragma ends up
-// on stdout, and causes the expected output to not match. 
+// on stdout, and causes the expected output to not match.
 
 package main
 
@@ -37,13 +37,12 @@ func H(spp stringPairPair) string {
 
 //go:registerparams
 //go:noinline
-func G(a,b,c,d string) stringPairPair {
-	return stringPairPair{stringPair{a,b},stringPair{c,d}}
+func G(a, b, c, d string) stringPairPair {
+	return stringPairPair{stringPair{a, b}, stringPair{c, d}}
 }
 
-
 func main() {
-	spp := G("this","is","a","test")
+	spp := G("this", "is", "a", "test")
 	s := H(spp)
 	gotVsWant(s, "this is a test")
 }
diff --git a/test/abi/struct_lower_1.go b/test/abi/struct_lower_1.go
new file mode 100644
index 0000000000..b20de9be4b
--- /dev/null
+++ b/test/abi/struct_lower_1.go
@@ -0,0 +1,30 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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 "fmt"
+
+//go:registerparams
+//go:noinline
+func passStruct6(a Struct6) Struct6 {
+	return a
+}
+
+type Struct6 struct {
+	Struct1
+}
+
+type Struct1 struct {
+	A, B, C uint
+}
+
+func main() {
+	fmt.Println(passStruct6(Struct6{Struct1{1, 2, 3}}))
+}
diff --git a/test/abi/struct_lower_1.out b/test/abi/struct_lower_1.out
new file mode 100644
index 0000000000..d326cb6119
--- /dev/null
+++ b/test/abi/struct_lower_1.out
@@ -0,0 +1 @@
+{{1 2 3}}
diff --git a/test/abi/too_big_to_ssa.go b/test/abi/too_big_to_ssa.go
index a5c6abb0e4..6c55d31419 100644
--- a/test/abi/too_big_to_ssa.go
+++ b/test/abi/too_big_to_ssa.go
@@ -1,5 +1,6 @@
 // run
 
+//go:build !wasm
 // +build !wasm
 
 // Copyright 2021 The Go Authors. All rights reserved.
@@ -16,7 +17,7 @@ var sink *string
 
 type toobig struct {
 	// 6 words will not SSA but will fit in registers
-	a,b,c string
+	a, b, c string
 }
 
 //go:registerparams
@@ -27,8 +28,8 @@ func H(x toobig) string {
 
 //go:registerparams
 //go:noinline
-func I(a,b,c string) toobig {
-	return toobig{a,b,c}
+func I(a, b, c string) toobig {
+	return toobig{a, b, c}
 }
 
 func main() {
-- 
GitLab


From 98dfdc82c85c238a5ab6131d6f1e86e0da259851 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Fri, 5 Mar 2021 21:09:40 -0500
Subject: [PATCH 0993/2400] cmd/compile: fix broken type+offset calc for
 register args

Includes more enhancements to debugging output.

Updates #44816.

Change-Id: I5b21815cf37ed21e7dec6c06f538090f32260203
Reviewed-on: https://go-review.googlesource.com/c/go/+/299409
Trust: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/abi/abiutils.go     |  29 +++--
 src/cmd/compile/internal/ssa/expand_calls.go | 110 ++++++++++---------
 test/abi/bad_internal_offsets.go             |  74 +++++++++++++
 3 files changed, 150 insertions(+), 63 deletions(-)
 create mode 100644 test/abi/bad_internal_offsets.go

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index 3c07be62e0..7d5de1d528 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -130,10 +130,15 @@ func (pa *ABIParamAssignment) RegisterTypesAndOffsets() ([]*types.Type, []int64)
 	}
 	typs := make([]*types.Type, 0, l)
 	offs := make([]int64, 0, l)
-	return appendParamTypes(typs, pa.Type), appendParamOffsets(offs, 0, pa.Type)
+	offs, _ = appendParamOffsets(offs, 0, pa.Type)
+	return appendParamTypes(typs, pa.Type), offs
 }
 
 func appendParamTypes(rts []*types.Type, t *types.Type) []*types.Type {
+	w := t.Width
+	if w == 0 {
+		return rts
+	}
 	if t.IsScalar() || t.IsPtrShaped() {
 		if t.IsComplex() {
 			c := types.FloatForComplex(t)
@@ -176,28 +181,30 @@ func appendParamTypes(rts []*types.Type, t *types.Type) []*types.Type {
 }
 
 // appendParamOffsets appends the offset(s) of type t, starting from "at",
-// to input offsets, and returns the longer slice.
-func appendParamOffsets(offsets []int64, at int64, t *types.Type) []int64 {
+// to input offsets, and returns the longer slice and the next unused offset.
+func appendParamOffsets(offsets []int64, at int64, t *types.Type) ([]int64, int64) {
 	at = align(at, t)
+	w := t.Width
+	if w == 0 {
+		return offsets, at
+	}
 	if t.IsScalar() || t.IsPtrShaped() {
 		if t.IsComplex() || int(t.Width) > types.RegSize { // complex and *int64 on 32-bit
-			s := t.Width / 2
-			return append(offsets, at, at+s)
+			s := w / 2
+			return append(offsets, at, at+s), at + w
 		} else {
-			return append(offsets, at)
+			return append(offsets, at), at + w
 		}
 	} else {
 		typ := t.Kind()
 		switch typ {
 		case types.TARRAY:
 			for i := int64(0); i < t.NumElem(); i++ {
-				offsets = appendParamOffsets(offsets, at, t.Elem())
+				offsets, at = appendParamOffsets(offsets, at, t.Elem())
 			}
-			return offsets
 		case types.TSTRUCT:
 			for _, f := range t.FieldSlice() {
-				offsets = appendParamOffsets(offsets, at, f.Type)
-				at += f.Type.Width
+				offsets, at = appendParamOffsets(offsets, at, f.Type)
 			}
 		case types.TSLICE:
 			return appendParamOffsets(offsets, at, synthSlice)
@@ -207,7 +214,7 @@ func appendParamOffsets(offsets []int64, at int64, t *types.Type) []int64 {
 			return appendParamOffsets(offsets, at, synthIface)
 		}
 	}
-	return offsets
+	return offsets, at
 }
 
 // SpillOffset returns the offset *within the spill area* for the parameter that "a" describes.
diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index 516ea42db9..d4fa7f2b14 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -643,13 +643,13 @@ func (x *expandState) decomposeArg(pos src.XPos, b *Block, source, mem *Value, t
 //  source        -- the value, possibly an aggregate, to be stored.
 //  mem           -- the mem flowing into this decomposition (loads depend on it, stores updated it)
 //  t             -- the type of the value to be stored
-//  offset        -- if the value is stored in memory, it is stored at base (see storeRc) + offset
+//  storeOffset   -- if the value is stored in memory, it is stored at base (see storeRc) + offset
 //  loadRegOffset -- regarding source as a value in registers, the register offset in ABI1.  Meaningful only if source is OpArg.
 //  storeRc       -- storeRC; if the value is stored in registers, this specifies the registers.
 //                   StoreRc also identifies whether the target is registers or memory, and has the base for the store operation.
 //
 // TODO -- this needs cleanup; it just works for SSA-able aggregates, and won't fully generalize to register-args aggregates.
-func (x *expandState) decomposeLoad(pos src.XPos, b *Block, source, mem *Value, t *types.Type, offset int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
+func (x *expandState) decomposeLoad(pos src.XPos, b *Block, source, mem *Value, t *types.Type, storeOffset int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
 	u := source.Type
 	switch u.Kind() {
 	case types.TARRAY:
@@ -657,7 +657,7 @@ func (x *expandState) decomposeLoad(pos src.XPos, b *Block, source, mem *Value,
 		elemRO := x.regWidth(elem)
 		for i := int64(0); i < u.NumElem(); i++ {
 			elemOff := i * elem.Size()
-			mem = storeOneLoad(x, pos, b, source, mem, elem, elemOff, offset+elemOff, loadRegOffset, storeRc.next(elem))
+			mem = storeOneLoad(x, pos, b, source, mem, elem, elemOff, storeOffset+elemOff, loadRegOffset, storeRc.next(elem))
 			loadRegOffset += elemRO
 			pos = pos.WithNotStmt()
 		}
@@ -665,7 +665,7 @@ func (x *expandState) decomposeLoad(pos src.XPos, b *Block, source, mem *Value,
 	case types.TSTRUCT:
 		for i := 0; i < u.NumFields(); i++ {
 			fld := u.Field(i)
-			mem = storeOneLoad(x, pos, b, source, mem, fld.Type, fld.Offset, offset+fld.Offset, loadRegOffset, storeRc.next(fld.Type))
+			mem = storeOneLoad(x, pos, b, source, mem, fld.Type, fld.Offset, storeOffset+fld.Offset, loadRegOffset, storeRc.next(fld.Type))
 			loadRegOffset += x.regWidth(fld.Type)
 			pos = pos.WithNotStmt()
 		}
@@ -675,20 +675,20 @@ func (x *expandState) decomposeLoad(pos src.XPos, b *Block, source, mem *Value,
 			break
 		}
 		tHi, tLo := x.intPairTypes(t.Kind())
-		mem = storeOneLoad(x, pos, b, source, mem, tHi, x.hiOffset, offset+x.hiOffset, loadRegOffset+x.hiRo, storeRc.plus(x.hiRo))
+		mem = storeOneLoad(x, pos, b, source, mem, tHi, x.hiOffset, storeOffset+x.hiOffset, loadRegOffset+x.hiRo, storeRc.plus(x.hiRo))
 		pos = pos.WithNotStmt()
-		return storeOneLoad(x, pos, b, source, mem, tLo, x.lowOffset, offset+x.lowOffset, loadRegOffset+x.loRo, storeRc.plus(x.loRo))
+		return storeOneLoad(x, pos, b, source, mem, tLo, x.lowOffset, storeOffset+x.lowOffset, loadRegOffset+x.loRo, storeRc.plus(x.loRo))
 	case types.TINTER:
-		return storeTwoLoad(x, pos, b, source, mem, x.typs.Uintptr, x.typs.BytePtr, 0, offset, loadRegOffset, storeRc)
+		return storeTwoLoad(x, pos, b, source, mem, x.typs.Uintptr, x.typs.BytePtr, 0, storeOffset, loadRegOffset, storeRc)
 	case types.TSTRING:
-		return storeTwoLoad(x, pos, b, source, mem, x.typs.BytePtr, x.typs.Int, 0, offset, loadRegOffset, storeRc)
+		return storeTwoLoad(x, pos, b, source, mem, x.typs.BytePtr, x.typs.Int, 0, storeOffset, loadRegOffset, storeRc)
 	case types.TCOMPLEX64:
-		return storeTwoLoad(x, pos, b, source, mem, x.typs.Float32, x.typs.Float32, 0, offset, loadRegOffset, storeRc)
+		return storeTwoLoad(x, pos, b, source, mem, x.typs.Float32, x.typs.Float32, 0, storeOffset, loadRegOffset, storeRc)
 	case types.TCOMPLEX128:
-		return storeTwoLoad(x, pos, b, source, mem, x.typs.Float64, x.typs.Float64, 0, offset, loadRegOffset, storeRc)
+		return storeTwoLoad(x, pos, b, source, mem, x.typs.Float64, x.typs.Float64, 0, storeOffset, loadRegOffset, storeRc)
 	case types.TSLICE:
-		mem = storeOneLoad(x, pos, b, source, mem, x.typs.BytePtr, 0, offset, loadRegOffset, storeRc.next(x.typs.BytePtr))
-		return storeTwoLoad(x, pos, b, source, mem, x.typs.Int, x.typs.Int, x.ptrSize, offset+x.ptrSize, loadRegOffset+RO_slice_len, storeRc)
+		mem = storeOneLoad(x, pos, b, source, mem, x.typs.BytePtr, 0, storeOffset, loadRegOffset, storeRc.next(x.typs.BytePtr))
+		return storeTwoLoad(x, pos, b, source, mem, x.typs.Int, x.typs.Int, x.ptrSize, storeOffset+x.ptrSize, loadRegOffset+RO_slice_len, storeRc)
 	}
 	return nil
 }
@@ -696,12 +696,18 @@ func (x *expandState) decomposeLoad(pos src.XPos, b *Block, source, mem *Value,
 // storeOneArg creates a decomposed (one step) arg that is then stored.
 // pos and b locate the store instruction, source is the "base" of the value input,
 // mem is the input mem, t is the type in question, and offArg and offStore are the offsets from the respective bases.
-func storeOneArg(x *expandState, pos src.XPos, b *Block, source, mem *Value, t *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
-	w := x.commonArgs[selKey{source, offArg, t.Width, t}]
+func storeOneArg(x *expandState, pos src.XPos, b *Block, source, mem *Value, t *types.Type, argOffset, storeOffset int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
+	if x.debug {
+		x.indent(3)
+		defer x.indent(-3)
+		fmt.Printf("storeOneArg(%s;  %s;  %s; aO=%d; sO=%d; lrO=%d; %s)\n", source.LongString(), mem.String(), t.String(), argOffset, storeOffset, loadRegOffset, storeRc.String())
+	}
+
+	w := x.commonArgs[selKey{source, argOffset, t.Width, t}]
 	if w == nil {
-		w = x.newArgToMemOrRegs(source, w, offArg, loadRegOffset, t, pos)
+		w = x.newArgToMemOrRegs(source, w, argOffset, loadRegOffset, t, pos)
 	}
-	return x.storeArgOrLoad(pos, b, w, mem, t, offStore, loadRegOffset, storeRc)
+	return x.storeArgOrLoad(pos, b, w, mem, t, storeOffset, loadRegOffset, storeRc)
 }
 
 // storeOneLoad creates a decomposed (one step) load that is then stored.
@@ -730,26 +736,26 @@ func storeTwoLoad(x *expandState, pos src.XPos, b *Block, source, mem *Value, t1
 // storeArgOrLoad converts stores of SSA-able potentially aggregatable arguments (passed to a call) into a series of primitive-typed
 // stores of non-aggregate types.  It recursively walks up a chain of selectors until it reaches a Load or an Arg.
 // If it does not reach a Load or an Arg, nothing happens; this allows a little freedom in phase ordering.
-func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, source, mem *Value, t *types.Type, offset int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
+func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, source, mem *Value, t *types.Type, storeOffset int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
 	if x.debug {
 		x.indent(3)
 		defer x.indent(-3)
-		x.Printf("storeArgOrLoad(%s;  %s;  %s; %d; %s)\n", source.LongString(), mem.String(), t.String(), offset, storeRc.String())
+		x.Printf("storeArgOrLoad(%s;  %s;  %s; %d; %s)\n", source.LongString(), mem.String(), t.String(), storeOffset, storeRc.String())
 	}
 
 	// Start with Opcodes that can be disassembled
 	switch source.Op {
 	case OpCopy:
-		return x.storeArgOrLoad(pos, b, source.Args[0], mem, t, offset, loadRegOffset, storeRc)
+		return x.storeArgOrLoad(pos, b, source.Args[0], mem, t, storeOffset, loadRegOffset, storeRc)
 
 	case OpLoad, OpDereference:
-		ret := x.decomposeLoad(pos, b, source, mem, t, offset, loadRegOffset, storeRc)
+		ret := x.decomposeLoad(pos, b, source, mem, t, storeOffset, loadRegOffset, storeRc)
 		if ret != nil {
 			return ret
 		}
 
 	case OpArg:
-		ret := x.decomposeArg(pos, b, source, mem, t, offset, loadRegOffset, storeRc)
+		ret := x.decomposeArg(pos, b, source, mem, t, storeOffset, loadRegOffset, storeRc)
 		if ret != nil {
 			return ret
 		}
@@ -761,19 +767,19 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, source, mem *Value,
 	case OpStructMake1, OpStructMake2, OpStructMake3, OpStructMake4:
 		for i := 0; i < t.NumFields(); i++ {
 			fld := t.Field(i)
-			mem = x.storeArgOrLoad(pos, b, source.Args[i], mem, fld.Type, offset+fld.Offset, 0, storeRc.next(fld.Type))
+			mem = x.storeArgOrLoad(pos, b, source.Args[i], mem, fld.Type, storeOffset+fld.Offset, 0, storeRc.next(fld.Type))
 			pos = pos.WithNotStmt()
 		}
 		return mem
 
 	case OpArrayMake1:
-		return x.storeArgOrLoad(pos, b, source.Args[0], mem, t.Elem(), offset, 0, storeRc.at(t, 0))
+		return x.storeArgOrLoad(pos, b, source.Args[0], mem, t.Elem(), storeOffset, 0, storeRc.at(t, 0))
 
 	case OpInt64Make:
 		tHi, tLo := x.intPairTypes(t.Kind())
-		mem = x.storeArgOrLoad(pos, b, source.Args[0], mem, tHi, offset+x.hiOffset, 0, storeRc.next(tHi))
+		mem = x.storeArgOrLoad(pos, b, source.Args[0], mem, tHi, storeOffset+x.hiOffset, 0, storeRc.next(tHi))
 		pos = pos.WithNotStmt()
-		return x.storeArgOrLoad(pos, b, source.Args[1], mem, tLo, offset+x.lowOffset, 0, storeRc)
+		return x.storeArgOrLoad(pos, b, source.Args[1], mem, tLo, storeOffset+x.lowOffset, 0, storeRc)
 
 	case OpComplexMake:
 		tPart := x.typs.Float32
@@ -781,25 +787,25 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, source, mem *Value,
 		if wPart == 8 {
 			tPart = x.typs.Float64
 		}
-		mem = x.storeArgOrLoad(pos, b, source.Args[0], mem, tPart, offset, 0, storeRc.next(tPart))
+		mem = x.storeArgOrLoad(pos, b, source.Args[0], mem, tPart, storeOffset, 0, storeRc.next(tPart))
 		pos = pos.WithNotStmt()
-		return x.storeArgOrLoad(pos, b, source.Args[1], mem, tPart, offset+wPart, 0, storeRc)
+		return x.storeArgOrLoad(pos, b, source.Args[1], mem, tPart, storeOffset+wPart, 0, storeRc)
 
 	case OpIMake:
-		mem = x.storeArgOrLoad(pos, b, source.Args[0], mem, x.typs.Uintptr, offset, 0, storeRc.next(x.typs.Uintptr))
+		mem = x.storeArgOrLoad(pos, b, source.Args[0], mem, x.typs.Uintptr, storeOffset, 0, storeRc.next(x.typs.Uintptr))
 		pos = pos.WithNotStmt()
-		return x.storeArgOrLoad(pos, b, source.Args[1], mem, x.typs.BytePtr, offset+x.ptrSize, 0, storeRc)
+		return x.storeArgOrLoad(pos, b, source.Args[1], mem, x.typs.BytePtr, storeOffset+x.ptrSize, 0, storeRc)
 
 	case OpStringMake:
-		mem = x.storeArgOrLoad(pos, b, source.Args[0], mem, x.typs.BytePtr, offset, 0, storeRc.next(x.typs.BytePtr))
+		mem = x.storeArgOrLoad(pos, b, source.Args[0], mem, x.typs.BytePtr, storeOffset, 0, storeRc.next(x.typs.BytePtr))
 		pos = pos.WithNotStmt()
-		return x.storeArgOrLoad(pos, b, source.Args[1], mem, x.typs.Int, offset+x.ptrSize, 0, storeRc)
+		return x.storeArgOrLoad(pos, b, source.Args[1], mem, x.typs.Int, storeOffset+x.ptrSize, 0, storeRc)
 
 	case OpSliceMake:
-		mem = x.storeArgOrLoad(pos, b, source.Args[0], mem, x.typs.BytePtr, offset, 0, storeRc.next(x.typs.BytePtr))
+		mem = x.storeArgOrLoad(pos, b, source.Args[0], mem, x.typs.BytePtr, storeOffset, 0, storeRc.next(x.typs.BytePtr))
 		pos = pos.WithNotStmt()
-		mem = x.storeArgOrLoad(pos, b, source.Args[1], mem, x.typs.Int, offset+x.ptrSize, 0, storeRc.next(x.typs.Int))
-		return x.storeArgOrLoad(pos, b, source.Args[2], mem, x.typs.Int, offset+2*x.ptrSize, 0, storeRc)
+		mem = x.storeArgOrLoad(pos, b, source.Args[1], mem, x.typs.Int, storeOffset+x.ptrSize, 0, storeRc.next(x.typs.Int))
+		return x.storeArgOrLoad(pos, b, source.Args[2], mem, x.typs.Int, storeOffset+2*x.ptrSize, 0, storeRc)
 	}
 
 	// For nodes that cannot be taken apart -- OpSelectN, other structure selectors.
@@ -809,12 +815,12 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, source, mem *Value,
 		if source.Type != t && t.NumElem() == 1 && elt.Width == t.Width && t.Width == x.regSize {
 			t = removeTrivialWrapperTypes(t)
 			// it could be a leaf type, but the "leaf" could be complex64 (for example)
-			return x.storeArgOrLoad(pos, b, source, mem, t, offset, loadRegOffset, storeRc)
+			return x.storeArgOrLoad(pos, b, source, mem, t, storeOffset, loadRegOffset, storeRc)
 		}
 		eltRO := x.regWidth(elt)
 		for i := int64(0); i < t.NumElem(); i++ {
 			sel := source.Block.NewValue1I(pos, OpArraySelect, elt, i, source)
-			mem = x.storeArgOrLoad(pos, b, sel, mem, elt, offset+i*elt.Width, loadRegOffset, storeRc.at(t, 0))
+			mem = x.storeArgOrLoad(pos, b, sel, mem, elt, storeOffset+i*elt.Width, loadRegOffset, storeRc.at(t, 0))
 			loadRegOffset += eltRO
 			pos = pos.WithNotStmt()
 		}
@@ -842,13 +848,13 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, source, mem *Value,
 			// of a *uint8, which does not succeed.
 			t = removeTrivialWrapperTypes(t)
 			// it could be a leaf type, but the "leaf" could be complex64 (for example)
-			return x.storeArgOrLoad(pos, b, source, mem, t, offset, loadRegOffset, storeRc)
+			return x.storeArgOrLoad(pos, b, source, mem, t, storeOffset, loadRegOffset, storeRc)
 		}
 
 		for i := 0; i < t.NumFields(); i++ {
 			fld := t.Field(i)
 			sel := source.Block.NewValue1I(pos, OpStructSelect, fld.Type, int64(i), source)
-			mem = x.storeArgOrLoad(pos, b, sel, mem, fld.Type, offset+fld.Offset, loadRegOffset, storeRc.next(fld.Type))
+			mem = x.storeArgOrLoad(pos, b, sel, mem, fld.Type, storeOffset+fld.Offset, loadRegOffset, storeRc.next(fld.Type))
 			loadRegOffset += x.regWidth(fld.Type)
 			pos = pos.WithNotStmt()
 		}
@@ -860,48 +866,48 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, source, mem *Value,
 		}
 		tHi, tLo := x.intPairTypes(t.Kind())
 		sel := source.Block.NewValue1(pos, OpInt64Hi, tHi, source)
-		mem = x.storeArgOrLoad(pos, b, sel, mem, tHi, offset+x.hiOffset, loadRegOffset+x.hiRo, storeRc.plus(x.hiRo))
+		mem = x.storeArgOrLoad(pos, b, sel, mem, tHi, storeOffset+x.hiOffset, loadRegOffset+x.hiRo, storeRc.plus(x.hiRo))
 		pos = pos.WithNotStmt()
 		sel = source.Block.NewValue1(pos, OpInt64Lo, tLo, source)
-		return x.storeArgOrLoad(pos, b, sel, mem, tLo, offset+x.lowOffset, loadRegOffset+x.loRo, storeRc.plus(x.hiRo))
+		return x.storeArgOrLoad(pos, b, sel, mem, tLo, storeOffset+x.lowOffset, loadRegOffset+x.loRo, storeRc.plus(x.hiRo))
 
 	case types.TINTER:
 		sel := source.Block.NewValue1(pos, OpITab, x.typs.BytePtr, source)
-		mem = x.storeArgOrLoad(pos, b, sel, mem, x.typs.BytePtr, offset, loadRegOffset, storeRc.next(x.typs.BytePtr))
+		mem = x.storeArgOrLoad(pos, b, sel, mem, x.typs.BytePtr, storeOffset, loadRegOffset, storeRc.next(x.typs.BytePtr))
 		pos = pos.WithNotStmt()
 		sel = source.Block.NewValue1(pos, OpIData, x.typs.BytePtr, source)
-		return x.storeArgOrLoad(pos, b, sel, mem, x.typs.BytePtr, offset+x.ptrSize, loadRegOffset+RO_iface_data, storeRc)
+		return x.storeArgOrLoad(pos, b, sel, mem, x.typs.BytePtr, storeOffset+x.ptrSize, loadRegOffset+RO_iface_data, storeRc)
 
 	case types.TSTRING:
 		sel := source.Block.NewValue1(pos, OpStringPtr, x.typs.BytePtr, source)
-		mem = x.storeArgOrLoad(pos, b, sel, mem, x.typs.BytePtr, offset, loadRegOffset, storeRc.next(x.typs.BytePtr))
+		mem = x.storeArgOrLoad(pos, b, sel, mem, x.typs.BytePtr, storeOffset, loadRegOffset, storeRc.next(x.typs.BytePtr))
 		pos = pos.WithNotStmt()
 		sel = source.Block.NewValue1(pos, OpStringLen, x.typs.Int, source)
-		return x.storeArgOrLoad(pos, b, sel, mem, x.typs.Int, offset+x.ptrSize, loadRegOffset+RO_string_len, storeRc)
+		return x.storeArgOrLoad(pos, b, sel, mem, x.typs.Int, storeOffset+x.ptrSize, loadRegOffset+RO_string_len, storeRc)
 
 	case types.TSLICE:
 		et := types.NewPtr(t.Elem())
 		sel := source.Block.NewValue1(pos, OpSlicePtr, et, source)
-		mem = x.storeArgOrLoad(pos, b, sel, mem, et, offset, loadRegOffset, storeRc.next(et))
+		mem = x.storeArgOrLoad(pos, b, sel, mem, et, storeOffset, loadRegOffset, storeRc.next(et))
 		pos = pos.WithNotStmt()
 		sel = source.Block.NewValue1(pos, OpSliceLen, x.typs.Int, source)
-		mem = x.storeArgOrLoad(pos, b, sel, mem, x.typs.Int, offset+x.ptrSize, loadRegOffset+RO_slice_len, storeRc.next(x.typs.Int))
+		mem = x.storeArgOrLoad(pos, b, sel, mem, x.typs.Int, storeOffset+x.ptrSize, loadRegOffset+RO_slice_len, storeRc.next(x.typs.Int))
 		sel = source.Block.NewValue1(pos, OpSliceCap, x.typs.Int, source)
-		return x.storeArgOrLoad(pos, b, sel, mem, x.typs.Int, offset+2*x.ptrSize, loadRegOffset+RO_slice_cap, storeRc)
+		return x.storeArgOrLoad(pos, b, sel, mem, x.typs.Int, storeOffset+2*x.ptrSize, loadRegOffset+RO_slice_cap, storeRc)
 
 	case types.TCOMPLEX64:
 		sel := source.Block.NewValue1(pos, OpComplexReal, x.typs.Float32, source)
-		mem = x.storeArgOrLoad(pos, b, sel, mem, x.typs.Float32, offset, loadRegOffset, storeRc.next(x.typs.Float32))
+		mem = x.storeArgOrLoad(pos, b, sel, mem, x.typs.Float32, storeOffset, loadRegOffset, storeRc.next(x.typs.Float32))
 		pos = pos.WithNotStmt()
 		sel = source.Block.NewValue1(pos, OpComplexImag, x.typs.Float32, source)
-		return x.storeArgOrLoad(pos, b, sel, mem, x.typs.Float32, offset+4, loadRegOffset+RO_complex_imag, storeRc)
+		return x.storeArgOrLoad(pos, b, sel, mem, x.typs.Float32, storeOffset+4, loadRegOffset+RO_complex_imag, storeRc)
 
 	case types.TCOMPLEX128:
 		sel := source.Block.NewValue1(pos, OpComplexReal, x.typs.Float64, source)
-		mem = x.storeArgOrLoad(pos, b, sel, mem, x.typs.Float64, offset, loadRegOffset, storeRc.next(x.typs.Float64))
+		mem = x.storeArgOrLoad(pos, b, sel, mem, x.typs.Float64, storeOffset, loadRegOffset, storeRc.next(x.typs.Float64))
 		pos = pos.WithNotStmt()
 		sel = source.Block.NewValue1(pos, OpComplexImag, x.typs.Float64, source)
-		return x.storeArgOrLoad(pos, b, sel, mem, x.typs.Float64, offset+8, loadRegOffset+RO_complex_imag, storeRc)
+		return x.storeArgOrLoad(pos, b, sel, mem, x.typs.Float64, storeOffset+8, loadRegOffset+RO_complex_imag, storeRc)
 	}
 
 	s := mem
@@ -911,7 +917,7 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, source, mem *Value,
 	if storeRc.hasRegs() {
 		storeRc.addArg(source)
 	} else {
-		dst := x.offsetFrom(b, storeRc.storeDest, offset, types.NewPtr(t))
+		dst := x.offsetFrom(b, storeRc.storeDest, storeOffset, types.NewPtr(t))
 		s = b.NewValue3A(pos, OpStore, types.TypeMem, t, dst, source, mem)
 	}
 	if x.debug {
diff --git a/test/abi/bad_internal_offsets.go b/test/abi/bad_internal_offsets.go
new file mode 100644
index 0000000000..d396c1a60f
--- /dev/null
+++ b/test/abi/bad_internal_offsets.go
@@ -0,0 +1,74 @@
+// compile
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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 genChecker0
+
+var FailCount int
+
+//go:noinline
+func NoteFailure(fidx int, pkg string, pref string, parmNo int, _ uint64) {
+	FailCount += 1
+	if FailCount > 10 {
+		panic("bad")
+	}
+}
+
+//go:noinline
+func NoteFailureElem(fidx int, pkg string, pref string, parmNo int, elem int, _ uint64) {
+	FailCount += 1
+	if FailCount > 10 {
+		panic("bad")
+	}
+}
+
+type StructF0S0 struct {
+	F0 int16
+	F1 string
+	F2 StructF0S1
+}
+
+type StructF0S1 struct {
+	_ uint16
+}
+
+// 0 returns 3 params
+//go:registerparams
+//go:noinline
+func Test0(p0 uint32, p1 StructF0S0, p2 int32) {
+	// consume some stack space, so as to trigger morestack
+	var pad [256]uint64
+	pad[FailCount]++
+	if p0 == 0 {
+		return
+	}
+	p1f0c := int16(-3096)
+	if p1.F0 != p1f0c {
+		NoteFailureElem(0, "genChecker0", "parm", 1, 0, pad[0])
+		return
+	}
+	p1f1c := "f6ꂅ8ˋ<"
+	if p1.F1 != p1f1c {
+		NoteFailureElem(0, "genChecker0", "parm", 1, 1, pad[0])
+		return
+	}
+	p1f2c := StructF0S1{}
+	if p1.F2 != p1f2c {
+		NoteFailureElem(0, "genChecker0", "parm", 1, 2, pad[0])
+		return
+	}
+	p2f0c := int32(496713155)
+	if p2 != p2f0c {
+		NoteFailureElem(0, "genChecker0", "parm", 2, 0, pad[0])
+		return
+	}
+	// recursive call
+	Test0(p0-1, p1, p2)
+	return
+	// 0 addr-taken params, 0 addr-taken returns
+}
-- 
GitLab


From 9f5298ca6e7fc9c46c0a82bd7be39450ec48dcb5 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Sat, 6 Mar 2021 20:59:40 -0500
Subject: [PATCH 0994/2400] cmd/compile: fix confusion in generating SelectN
 index

Old: return the ABI register index of the result (wrong!)
New: return the index w/in sequence of result registers (right!)

Fixed bug:
genCaller0/genCaller0.go:43:9: internal compiler error: 'Caller0':
   panic during schedule while compiling Caller0:
runtime error: index out of range [10] with length 9

Updates #44816.

Change-Id: I1111e283658a2d6422986ae3d61bd95d1b9bde5e
Reviewed-on: https://go-review.googlesource.com/c/go/+/299549
Trust: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/expand_calls.go | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index d4fa7f2b14..d7d7d3bc45 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -424,7 +424,11 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64,
 				}
 				outParam := aux.abiInfo.OutParam(int(which))
 				if len(outParam.Registers) > 0 {
-					reg := int64(outParam.Registers[regOffset])
+					firstReg := uint32(0)
+					for i := 0; i < int(which); i++ {
+						firstReg += uint32(len(aux.abiInfo.OutParam(i).Registers))
+					}
+					reg := int64(regOffset + Abi1RO(firstReg))
 					if leaf.Block == call.Block {
 						leaf.reset(OpSelectN)
 						leaf.SetArgs1(call0)
-- 
GitLab


From 382851c1fd135a99efbe128a3be0ce466d42506f Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Sun, 7 Mar 2021 14:00:10 -0500
Subject: [PATCH 0995/2400] cmd/compile: fix failure to communicate between
 ABIinfo producer&consumer

ABI info producer and consumer had different ideas for register
order for parameters.

Includes a test, includes improvements to debugging output.

Updates #44816.

Change-Id: I4812976f7a6c08d6fc02aac1ec0544b1f141cca6
Reviewed-on: https://go-review.googlesource.com/c/go/+/299570
Trust: David Chase <drchase@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/abi/abiutils.go      | 77 ++++++++++++-----
 src/cmd/compile/internal/ssa/expand_calls.go  | 83 ++++++++++---------
 src/cmd/compile/internal/ssa/value.go         |  4 +-
 .../compile/internal/test/abiutils_test.go    |  6 +-
 src/cmd/internal/obj/x86/asm6.go              |  2 +-
 test/abi/s_sif_sif.go                         | 37 +++++++++
 6 files changed, 142 insertions(+), 67 deletions(-)
 create mode 100644 test/abi/s_sif_sif.go

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index 7d5de1d528..ecde34313a 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -477,9 +477,9 @@ func (c *RegAmounts) regString(r RegIndex) string {
 	return fmt.Sprintf("<?>%d", r)
 }
 
-// toString method renders an ABIParamAssignment in human-readable
+// ToString method renders an ABIParamAssignment in human-readable
 // form, suitable for debugging or unit testing.
-func (ri *ABIParamAssignment) toString(config *ABIConfig) string {
+func (ri *ABIParamAssignment) ToString(config *ABIConfig, extra bool) string {
 	regs := "R{"
 	offname := "spilloffset" // offset is for spill for register(s)
 	if len(ri.Registers) == 0 {
@@ -487,19 +487,25 @@ func (ri *ABIParamAssignment) toString(config *ABIConfig) string {
 	}
 	for _, r := range ri.Registers {
 		regs += " " + config.regAmounts.regString(r)
+		if extra {
+			regs += fmt.Sprintf("(%d)", r)
+		}
+	}
+	if extra {
+		regs += fmt.Sprintf(" | #I=%d, #F=%d", config.regAmounts.intRegs, config.regAmounts.floatRegs)
 	}
 	return fmt.Sprintf("%s } %s: %d typ: %v", regs, offname, ri.offset, ri.Type)
 }
 
-// toString method renders an ABIParamResultInfo in human-readable
+// String method renders an ABIParamResultInfo in human-readable
 // form, suitable for debugging or unit testing.
 func (ri *ABIParamResultInfo) String() string {
 	res := ""
 	for k, p := range ri.inparams {
-		res += fmt.Sprintf("IN %d: %s\n", k, p.toString(ri.config))
+		res += fmt.Sprintf("IN %d: %s\n", k, p.ToString(ri.config, false))
 	}
 	for k, r := range ri.outparams {
-		res += fmt.Sprintf("OUT %d: %s\n", k, r.toString(ri.config))
+		res += fmt.Sprintf("OUT %d: %s\n", k, r.ToString(ri.config, false))
 	}
 	res += fmt.Sprintf("offsetToSpillArea: %d spillAreaSize: %d",
 		ri.offsetToSpillArea, ri.spillAreaSize)
@@ -537,25 +543,54 @@ func (state *assignState) stackSlot(t *types.Type) int64 {
 	return rv
 }
 
-// allocateRegs returns a set of register indices for a parameter or result
+// allocateRegs returns an ordered list of register indices for a parameter or result
 // that we've just determined to be register-assignable. The number of registers
 // needed is assumed to be stored in state.pUsed.
-func (state *assignState) allocateRegs() []RegIndex {
-	regs := []RegIndex{}
-
-	// integer
-	for r := state.rUsed.intRegs; r < state.rUsed.intRegs+state.pUsed.intRegs; r++ {
-		regs = append(regs, RegIndex(r))
+func (state *assignState) allocateRegs(regs []RegIndex, t *types.Type) []RegIndex {
+	if t.Width == 0 {
+		return regs
 	}
-	state.rUsed.intRegs += state.pUsed.intRegs
-
-	// floating
-	for r := state.rUsed.floatRegs; r < state.rUsed.floatRegs+state.pUsed.floatRegs; r++ {
-		regs = append(regs, RegIndex(r+state.rTotal.intRegs))
+	ri := state.rUsed.intRegs
+	rf := state.rUsed.floatRegs
+	if t.IsScalar() || t.IsPtrShaped() {
+		if t.IsComplex() {
+			regs = append(regs, RegIndex(rf+state.rTotal.intRegs), RegIndex(rf+1+state.rTotal.intRegs))
+			rf += 2
+		} else if t.IsFloat() {
+			regs = append(regs, RegIndex(rf+state.rTotal.intRegs))
+			rf += 1
+		} else {
+			n := (int(t.Size()) + types.RegSize - 1) / types.RegSize
+			for i := 0; i < n; i++ { // looking ahead to really big integers
+				regs = append(regs, RegIndex(ri))
+				ri += 1
+			}
+		}
+		state.rUsed.intRegs = ri
+		state.rUsed.floatRegs = rf
+		return regs
+	} else {
+		typ := t.Kind()
+		switch typ {
+		case types.TARRAY:
+			for i := int64(0); i < t.NumElem(); i++ {
+				regs = state.allocateRegs(regs, t.Elem())
+			}
+			return regs
+		case types.TSTRUCT:
+			for _, f := range t.FieldSlice() {
+				regs = state.allocateRegs(regs, f.Type)
+			}
+			return regs
+		case types.TSLICE:
+			return state.allocateRegs(regs, synthSlice)
+		case types.TSTRING:
+			return state.allocateRegs(regs, synthString)
+		case types.TINTER:
+			return state.allocateRegs(regs, synthIface)
+		}
 	}
-	state.rUsed.floatRegs += state.pUsed.floatRegs
-
-	return regs
+	panic(fmt.Errorf("Was not expecting type %s", t))
 }
 
 // regAllocate creates a register ABIParamAssignment object for a param
@@ -571,7 +606,7 @@ func (state *assignState) regAllocate(t *types.Type, name types.Object, isReturn
 	return ABIParamAssignment{
 		Type:      t,
 		Name:      name,
-		Registers: state.allocateRegs(),
+		Registers: state.allocateRegs([]RegIndex{}, t),
 		offset:    int32(spillLoc),
 	}
 }
diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index d7d7d3bc45..6e2004224f 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -303,7 +303,7 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64,
 	if x.debug {
 		x.indent(3)
 		defer x.indent(-3)
-		x.Printf("rewriteSelect(%s, %s, %d)\n", leaf.LongString(), selector.LongString(), offset)
+		x.Printf("rewriteSelect(%s; %s; memOff=%d; regOff=%d)\n", leaf.LongString(), selector.LongString(), offset, regOffset)
 	}
 	var locs []LocalSlot
 	leafType := leaf.Type
@@ -581,7 +581,13 @@ func (x *expandState) decomposeArg(pos src.XPos, b *Block, source, mem *Value, t
 		rts, offs := pa.RegisterTypesAndOffsets()
 		last := loadRegOffset + x.regWidth(t)
 		if offs[loadRegOffset] != 0 {
-			panic(fmt.Errorf("offset %d of requested register %d should be zero", offs[loadRegOffset], loadRegOffset))
+			// Document the problem before panicking.
+			for i := 0; i < len(rts); i++ {
+				rt := rts[i]
+				off := offs[i]
+				fmt.Printf("rt=%s, off=%d, rt.Width=%d, rt.Align=%d\n", rt.String(), off, rt.Width, rt.Align)
+			}
+			panic(fmt.Errorf("offset %d of requested register %d should be zero, source=%s", offs[loadRegOffset], loadRegOffset, source.LongString()))
 		}
 		for i := loadRegOffset; i < last; i++ {
 			rt := rts[i]
@@ -704,7 +710,7 @@ func storeOneArg(x *expandState, pos src.XPos, b *Block, source, mem *Value, t *
 	if x.debug {
 		x.indent(3)
 		defer x.indent(-3)
-		fmt.Printf("storeOneArg(%s;  %s;  %s; aO=%d; sO=%d; lrO=%d; %s)\n", source.LongString(), mem.String(), t.String(), argOffset, storeOffset, loadRegOffset, storeRc.String())
+		x.Printf("storeOneArg(%s;  %s;  %s; aO=%d; sO=%d; lrO=%d; %s)\n", source.LongString(), mem.String(), t.String(), argOffset, storeOffset, loadRegOffset, storeRc.String())
 	}
 
 	w := x.commonArgs[selKey{source, argOffset, t.Width, t}]
@@ -1388,14 +1394,8 @@ func (x *expandState) rewriteArgToMemOrRegs(v *Value) *Value {
 		}
 	case 1:
 		r := pa.Registers[0]
-		i := x.f.ABISelf.FloatIndexFor(r)
-		// TODO seems like this has implications for debugging. How does this affect the location?
-		if i >= 0 { // float PR
-			v.Op = OpArgFloatReg
-		} else {
-			v.Op = OpArgIntReg
-			i = int64(r)
-		}
+		var i int64
+		v.Op, i = ArgOpAndRegisterFor(r, x.f.ABISelf)
 		v.Aux = &AuxNameOffset{v.Aux.(*ir.Name), 0}
 		v.AuxInt = i
 
@@ -1409,6 +1409,11 @@ func (x *expandState) rewriteArgToMemOrRegs(v *Value) *Value {
 // or rewrites it into a copy of the appropriate OpArgXXX.  The actual OpArgXXX is determined by combining baseArg (an OpArg)
 // with offset, regOffset, and t to determine which portion of it to reference (either all or a part, in memory or in registers).
 func (x *expandState) newArgToMemOrRegs(baseArg, toReplace *Value, offset int64, regOffset Abi1RO, t *types.Type, pos src.XPos) *Value {
+	if x.debug {
+		x.indent(3)
+		defer x.indent(-3)
+		x.Printf("newArgToMemOrRegs(base=%s; toReplace=%s; t=%s; memOff=%d; regOff=%d)\n", baseArg.String(), toReplace.LongString(), t, offset, regOffset)
+	}
 	key := selKey{baseArg, offset, t.Width, t}
 	w := x.commonArgs[key]
 	if w != nil {
@@ -1432,28 +1437,27 @@ func (x *expandState) newArgToMemOrRegs(baseArg, toReplace *Value, offset int64,
 			toReplace.Aux = aux
 			toReplace.AuxInt = auxInt
 			toReplace.Type = t
-			x.commonArgs[key] = toReplace
-			return toReplace
+			w = toReplace
 		} else {
-			w := baseArg.Block.NewValue0IA(pos, OpArg, t, auxInt, aux)
-			x.commonArgs[key] = w
-			if x.debug {
-				x.Printf("---new %s\n", w.LongString())
-			}
-			if toReplace != nil {
-				toReplace.copyOf(w)
-			}
-			return w
+			w = baseArg.Block.NewValue0IA(pos, OpArg, t, auxInt, aux)
+		}
+		x.commonArgs[key] = w
+		if toReplace != nil {
+			toReplace.copyOf(w)
 		}
+		if x.debug {
+			x.Printf("-->%s\n", w.LongString())
+		}
+		return w
 	}
 	// Arg is in registers
 	r := pa.Registers[regOffset]
-	auxInt := x.f.ABISelf.FloatIndexFor(r)
-	op := OpArgFloatReg
-	// TODO seems like this has implications for debugging. How does this affect the location?
-	if auxInt < 0 { // int (not float) parameter register
-		op = OpArgIntReg
-		auxInt = int64(r)
+	op, auxInt := ArgOpAndRegisterFor(r, x.f.ABISelf)
+	if op == OpArgIntReg && t.IsFloat() || op == OpArgFloatReg && t.IsInteger() {
+		fmt.Printf("pa=%v\nx.f.OwnAux.abiInfo=%s\n",
+			pa.ToString(x.f.ABISelf, true),
+			x.f.OwnAux.abiInfo.String())
+		panic(fmt.Errorf("Op/Type mismatch, op=%s, type=%s", op.String(), t.String()))
 	}
 	aux := &AuxNameOffset{baseArg.Aux.(*ir.Name), baseArg.AuxInt + offset}
 	if toReplace != nil && toReplace.Block == baseArg.Block {
@@ -1461,24 +1465,23 @@ func (x *expandState) newArgToMemOrRegs(baseArg, toReplace *Value, offset int64,
 		toReplace.Aux = aux
 		toReplace.AuxInt = auxInt
 		toReplace.Type = t
-		x.commonArgs[key] = toReplace
-		return toReplace
+		w = toReplace
 	} else {
-		w := baseArg.Block.NewValue0IA(pos, op, t, auxInt, aux)
-		if x.debug {
-			x.Printf("---new %s\n", w.LongString())
-		}
-		x.commonArgs[key] = w
-		if toReplace != nil {
-			toReplace.copyOf(w)
-		}
-		return w
+		w = baseArg.Block.NewValue0IA(pos, op, t, auxInt, aux)
+	}
+	x.commonArgs[key] = w
+	if toReplace != nil {
+		toReplace.copyOf(w)
 	}
+	if x.debug {
+		x.Printf("-->%s\n", w.LongString())
+	}
+	return w
+
 }
 
 // argOpAndRegisterFor converts an abi register index into an ssa Op and corresponding
 // arg register index.
-// TODO could call this in at least two places earlier in this file.
 func ArgOpAndRegisterFor(r abi.RegIndex, abiConfig *abi.ABIConfig) (Op, int64) {
 	i := abiConfig.FloatIndexFor(r)
 	if i >= 0 { // float PR
diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go
index 6cc2b2ab8b..5a9779dd1e 100644
--- a/src/cmd/compile/internal/ssa/value.go
+++ b/src/cmd/compile/internal/ssa/value.go
@@ -198,12 +198,12 @@ func (v *Value) auxString() string {
 		if v.Aux != nil {
 			return fmt.Sprintf(" {%v}", v.Aux)
 		}
-	case auxSymOff, auxCallOff, auxTypSize:
+	case auxSymOff, auxCallOff, auxTypSize, auxNameOffsetInt8:
 		s := ""
 		if v.Aux != nil {
 			s = fmt.Sprintf(" {%v}", v.Aux)
 		}
-		if v.AuxInt != 0 {
+		if v.AuxInt != 0 || opcodeTable[v.Op].auxType == auxNameOffsetInt8 {
 			s += fmt.Sprintf(" [%v]", v.AuxInt)
 		}
 		return s
diff --git a/src/cmd/compile/internal/test/abiutils_test.go b/src/cmd/compile/internal/test/abiutils_test.go
index 9a7d6d138c..f8d0af8d7a 100644
--- a/src/cmd/compile/internal/test/abiutils_test.go
+++ b/src/cmd/compile/internal/test/abiutils_test.go
@@ -170,9 +170,9 @@ func TestABIUtilsStruct2(t *testing.T) {
 	exp := makeExpectedDump(`
         IN 0: R{ I0 } spilloffset: 0 typ: struct { int64; struct {} }
         IN 1: R{ I1 } spilloffset: 16 typ: struct { int64; struct {} }
-        IN 2: R{ I2 F0 } spilloffset: 32 typ: struct { float64; struct { int64; struct {} }; struct {} }
-        OUT 0: R{ I0 F0 } spilloffset: -1 typ: struct { float64; struct { int64; struct {} }; struct {} }
-        OUT 1: R{ I1 F1 } spilloffset: -1 typ: struct { float64; struct { int64; struct {} }; struct {} }
+        IN 2: R{ F0 I2 } spilloffset: 32 typ: struct { float64; struct { int64; struct {} }; struct {} }
+        OUT 0: R{ F0 I0 } spilloffset: -1 typ: struct { float64; struct { int64; struct {} }; struct {} }
+        OUT 1: R{ F1 I1 } spilloffset: -1 typ: struct { float64; struct { int64; struct {} }; struct {} }
         offsetToSpillArea: 0 spillAreaSize: 64
 `)
 
diff --git a/src/cmd/internal/obj/x86/asm6.go b/src/cmd/internal/obj/x86/asm6.go
index fa670d5c18..52ac567a36 100644
--- a/src/cmd/internal/obj/x86/asm6.go
+++ b/src/cmd/internal/obj/x86/asm6.go
@@ -5306,7 +5306,7 @@ bad:
 		}
 	}
 
-	ctxt.Diag("invalid instruction: %v", p)
+	ctxt.Diag("%s: invalid instruction: %v", cursym.Name, p)
 }
 
 // byteswapreg returns a byte-addressable register (AX, BX, CX, DX)
diff --git a/test/abi/s_sif_sif.go b/test/abi/s_sif_sif.go
new file mode 100644
index 0000000000..f05f26f29f
--- /dev/null
+++ b/test/abi/s_sif_sif.go
@@ -0,0 +1,37 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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
+
+// Test ensures that abi information producer and consumer agree about the
+// order of registers for inputs.  T's registers should be I0, F0, I1, F1.
+
+import "fmt"
+
+type P struct {
+	a int8
+	x float64
+}
+
+type T struct {
+	d, e P
+}
+
+//go:registerparams
+//go:noinline
+func G(t T) float64 {
+	return float64(t.d.a+t.e.a) + t.d.x + t.e.x
+}
+
+func main() {
+	x := G(T{P{10, 20}, P{30, 40}})
+	if x != 100.0 {
+		fmt.Printf("FAIL, Expected 100, got %f\n", x)
+	}
+}
-- 
GitLab


From e4f3cfadf618df5135bf0952507ab491975cceb5 Mon Sep 17 00:00:00 2001
From: Fazlul Shahriar <fshahriar@gmail.com>
Date: Thu, 25 Feb 2021 15:16:25 -0500
Subject: [PATCH 0996/2400] net: don't append a dot to TXT records on Plan 9

TXT records are not domain names, so no need to call absDomainName.
The output now matches the pure Go resolver.

Fixes #44619

Change-Id: I1ebf09152ff5c0446d2e2b4c26671358892d9dc9
Reviewed-on: https://go-review.googlesource.com/c/go/+/296589
Reviewed-by: David du Colombier <0intro@gmail.com>
Run-TryBot: David du Colombier <0intro@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: David du Colombier <0intro@gmail.com>
Trust: Ian Lance Taylor <iant@golang.org>
---
 src/net/lookup_plan9.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/net/lookup_plan9.go b/src/net/lookup_plan9.go
index 6a2d48eeda..5fc23f098b 100644
--- a/src/net/lookup_plan9.go
+++ b/src/net/lookup_plan9.go
@@ -308,7 +308,7 @@ func (*Resolver) lookupTXT(ctx context.Context, name string) (txt []string, err
 	}
 	for _, line := range lines {
 		if i := bytealg.IndexByteString(line, '\t'); i >= 0 {
-			txt = append(txt, absDomainName([]byte(line[i+1:])))
+			txt = append(txt, line[i+1:])
 		}
 	}
 	return
-- 
GitLab


From 18510ae88ffcb9c4a914805fde3e613539f9b6dc Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Sun, 7 Mar 2021 20:52:48 -0800
Subject: [PATCH 0997/2400] runtime, cmd/link/internal/ld: disable memory
 profiling when data unreachable

If runtime.MemProfile is unreachable, default to not collecting any
memory profiling samples, to save memory on the hash table.

Fixes #42347

Change-Id: I9a4894a5fc77035fe59b1842e1ec77a1182e70c1
Reviewed-on: https://go-review.googlesource.com/c/go/+/299671
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: Keith Randall <khr@golang.org>
---
 src/cmd/link/internal/ld/ld_test.go | 100 ++++++++++++++++++++++++++++
 src/cmd/link/internal/ld/lib.go     |  12 ++++
 src/runtime/mprof.go                |  17 ++++-
 3 files changed, 128 insertions(+), 1 deletion(-)

diff --git a/src/cmd/link/internal/ld/ld_test.go b/src/cmd/link/internal/ld/ld_test.go
index 836d9bff3d..f3725cbc6a 100644
--- a/src/cmd/link/internal/ld/ld_test.go
+++ b/src/cmd/link/internal/ld/ld_test.go
@@ -224,3 +224,103 @@ func testWindowsBuildmodeCSharedASLR(t *testing.T, useASLR bool) {
 		t.Error("IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE flag should not be set")
 	}
 }
+
+// TestMemProfileCheck tests that cmd/link sets
+// runtime.disableMemoryProfiling if the runtime.MemProfile
+// symbol is unreachable after deadcode (and not dynlinking).
+// The runtime then uses that to set the default value of
+// runtime.MemProfileRate, which this test checks.
+func TestMemProfileCheck(t *testing.T) {
+	testenv.MustHaveGoBuild(t)
+	t.Parallel()
+
+	tests := []struct {
+		name    string
+		prog    string
+		wantOut string
+	}{
+		{
+			"no_memprofile",
+			`
+package main
+import "runtime"
+func main() {
+	println(runtime.MemProfileRate)
+}
+`,
+			"0",
+		},
+		{
+			"with_memprofile",
+			`
+package main
+import "runtime"
+func main() {
+	runtime.MemProfile(nil, false)
+	println(runtime.MemProfileRate)
+}
+`,
+			"524288",
+		},
+		{
+			"with_memprofile_indirect",
+			`
+package main
+import "runtime"
+var f = runtime.MemProfile
+func main() {
+	if f == nil {
+		panic("no f")
+	}
+	println(runtime.MemProfileRate)
+}
+`,
+			"524288",
+		},
+		{
+			"with_memprofile_runtime_pprof",
+			`
+package main
+import "runtime"
+import "runtime/pprof"
+func main() {
+        _ = pprof.Profiles()
+	println(runtime.MemProfileRate)
+}
+`,
+			"524288",
+		},
+		{
+			"with_memprofile_http_pprof",
+			`
+package main
+import "runtime"
+import _ "net/http/pprof"
+func main() {
+	println(runtime.MemProfileRate)
+}
+`,
+			"524288",
+		},
+	}
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			tempDir := t.TempDir()
+			src := filepath.Join(tempDir, "x.go")
+			if err := ioutil.WriteFile(src, []byte(tt.prog), 0644); err != nil {
+				t.Fatal(err)
+			}
+			cmd := exec.Command(testenv.GoToolPath(t), "run", src)
+			out, err := cmd.CombinedOutput()
+			if err != nil {
+				t.Fatal(err)
+			}
+			got := strings.TrimSpace(string(out))
+			if got != tt.wantOut {
+				t.Errorf("got %q; want %q", got, tt.wantOut)
+			}
+		})
+	}
+}
diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index 517b0f6930..4c69d24354 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -790,6 +790,18 @@ func (ctxt *Link) linksetup() {
 			sb.SetSize(0)
 			sb.AddUint8(uint8(objabi.GOARM))
 		}
+
+		// Set runtime.disableMemoryProfiling bool if
+		// runtime.MemProfile is not retained in the binary after
+		// deadcode (and we're not dynamically linking).
+		memProfile := ctxt.loader.Lookup("runtime.MemProfile", sym.SymVerABIInternal)
+		if memProfile != 0 && !ctxt.loader.AttrReachable(memProfile) && !ctxt.DynlinkingGo() {
+			memProfSym := ctxt.loader.LookupOrCreateSym("runtime.disableMemoryProfiling", 0)
+			sb := ctxt.loader.MakeSymbolUpdater(memProfSym)
+			sb.SetType(sym.SDATA)
+			sb.SetSize(0)
+			sb.AddUint8(1) // true bool
+		}
 	} else {
 		// If OTOH the module does not contain the runtime package,
 		// create a local symbol for the moduledata.
diff --git a/src/runtime/mprof.go b/src/runtime/mprof.go
index c94b8f7cae..1156329615 100644
--- a/src/runtime/mprof.go
+++ b/src/runtime/mprof.go
@@ -490,7 +490,22 @@ func (r *StackRecord) Stack() []uintptr {
 // memory profiling rate should do so just once, as early as
 // possible in the execution of the program (for example,
 // at the beginning of main).
-var MemProfileRate int = 512 * 1024
+var MemProfileRate int = defaultMemProfileRate(512 * 1024)
+
+// defaultMemProfileRate returns 0 if disableMemoryProfiling is set.
+// It exists primarily for the godoc rendering of MemProfileRate
+// above.
+func defaultMemProfileRate(v int) int {
+	if disableMemoryProfiling {
+		return 0
+	}
+	return v
+}
+
+// disableMemoryProfiling is set by the linker if runtime.MemProfile
+// is not used and the link type guarantees nobody else could use it
+// elsewhere.
+var disableMemoryProfiling bool
 
 // A MemProfileRecord describes the live objects allocated
 // by a particular call sequence (stack trace).
-- 
GitLab


From 48ddf7012875014d3cab4a02002799a520b087a1 Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Tue, 5 Jan 2021 16:44:43 -0600
Subject: [PATCH 0998/2400] cmd/asm,cmd/compile: support 5 operand RLWNM/RLWMI
 on ppc64

These instructions are actually 5 argument opcodes as specified
by the ISA.  Prior to this patch, the MB and ME arguments were
merged into a single bitmask operand to workaround the limitations
of the ppc64 assembler backend.

This limitation no longer exists. Thus, we can pass operands for
these opcodes without having to merge the MB and ME arguments in
the assembler frontend or compiler backend.

Likewise, support for 4 operand variants is unchanged.

Change-Id: Ib086774f3581edeaadfd2190d652aaaa8a90daeb
Reviewed-on: https://go-review.googlesource.com/c/go/+/298750
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
Reviewed-by: Carlos Eduardo Seo <carlos.seo@linaro.org>
Trust: Carlos Eduardo Seo <carlos.seo@linaro.org>
---
 src/cmd/asm/internal/asm/asm.go           | 14 +++-------
 src/cmd/asm/internal/asm/testdata/ppc64.s |  6 +++++
 src/cmd/compile/internal/ppc64/ssa.go     |  8 +++---
 src/cmd/internal/obj/ppc64/asm9.go        | 13 +++++++++
 test/codegen/rotate.go                    | 32 +++++++++++------------
 test/codegen/shift.go                     | 32 +++++++++++------------
 6 files changed, 58 insertions(+), 47 deletions(-)

diff --git a/src/cmd/asm/internal/asm/asm.go b/src/cmd/asm/internal/asm/asm.go
index 06867cd507..340f188924 100644
--- a/src/cmd/asm/internal/asm/asm.go
+++ b/src/cmd/asm/internal/asm/asm.go
@@ -799,19 +799,11 @@ func (p *Parser) asmInstruction(op obj.As, cond string, a []obj.Addr) {
 		p.errorf("can't handle %s instruction with 4 operands", op)
 		return
 	case 5:
-		if p.arch.Family == sys.PPC64 && arch.IsPPC64RLD(op) {
-			// Always reg, reg, con, con, reg.  (con, con is a 'mask').
+		if p.arch.Family == sys.PPC64 {
 			prog.From = a[0]
+			// Second arg is always a register type on ppc64.
 			prog.Reg = p.getRegister(prog, op, &a[1])
-			mask1 := p.getConstant(prog, op, &a[2])
-			mask2 := p.getConstant(prog, op, &a[3])
-			var mask uint32
-			if mask1 < mask2 {
-				mask = (^uint32(0) >> uint(mask1)) & (^uint32(0) << uint(31-mask2))
-			} else {
-				mask = (^uint32(0) >> uint(mask2+1)) & (^uint32(0) << uint(31-(mask1-1)))
-			}
-			prog.SetFrom3Const(int64(mask))
+			prog.SetRestArgs([]obj.Addr{a[2], a[3]})
 			prog.To = a[4]
 			break
 		}
diff --git a/src/cmd/asm/internal/asm/testdata/ppc64.s b/src/cmd/asm/internal/asm/testdata/ppc64.s
index 8f6eb14f73..a818c0e789 100644
--- a/src/cmd/asm/internal/asm/testdata/ppc64.s
+++ b/src/cmd/asm/internal/asm/testdata/ppc64.s
@@ -280,11 +280,17 @@ TEXT asmtest(SB),DUPOK|NOSPLIT,$0
 	ROTLW R3, R4, R5                // 5c85183e
 	EXTSWSLI $3, R4, R5             // 7c851ef4
 	RLWMI $7, R3, $65535, R6        // 50663c3e
+	RLWMI $7, R3, $16, $31, R6      // 50663c3e
 	RLWMICC $7, R3, $65535, R6      // 50663c3f
+	RLWMICC $7, R3, $16, $31, R6    // 50663c3f
 	RLWNM $3, R4, $7, R6            // 54861f7e
+	RLWNM $3, R4, $29, $31, R6      // 54861f7e
 	RLWNM R3, R4, $7, R6            // 5c861f7e
+	RLWNM R3, R4, $29, $31, R6      // 5c861f7e
 	RLWNMCC $3, R4, $7, R6          // 54861f7f
+	RLWNMCC $3, R4, $29, $31, R6    // 54861f7f
 	RLWNMCC R3, R4, $7, R6          // 5c861f7f
+	RLWNMCC R3, R4, $29, $31, R6    // 5c861f7f
 	RLDMI $0, R4, $7, R6            // 7886076c
 	RLDMICC $0, R4, $7, R6          // 7886076d
 	RLDIMI $0, R4, $7, R6           // 788601cc
diff --git a/src/cmd/compile/internal/ppc64/ssa.go b/src/cmd/compile/internal/ppc64/ssa.go
index f984079c4b..2bae35bf44 100644
--- a/src/cmd/compile/internal/ppc64/ssa.go
+++ b/src/cmd/compile/internal/ppc64/ssa.go
@@ -653,21 +653,21 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 
 		// Auxint holds encoded rotate + mask
 	case ssa.OpPPC64RLWINM, ssa.OpPPC64RLWMI:
-		rot, _, _, mask := ssa.DecodePPC64RotateMask(v.AuxInt)
+		rot, mb, me, _ := ssa.DecodePPC64RotateMask(v.AuxInt)
 		p := s.Prog(v.Op.Asm())
 		p.To = obj.Addr{Type: obj.TYPE_REG, Reg: v.Reg()}
 		p.Reg = v.Args[0].Reg()
 		p.From = obj.Addr{Type: obj.TYPE_CONST, Offset: int64(rot)}
-		p.SetFrom3Const(int64(mask))
+		p.SetRestArgs([]obj.Addr{{Type: obj.TYPE_CONST, Offset: mb}, {Type: obj.TYPE_CONST, Offset: me}})
 
 		// Auxint holds mask
 	case ssa.OpPPC64RLWNM:
-		_, _, _, mask := ssa.DecodePPC64RotateMask(v.AuxInt)
+		_, mb, me, _ := ssa.DecodePPC64RotateMask(v.AuxInt)
 		p := s.Prog(v.Op.Asm())
 		p.To = obj.Addr{Type: obj.TYPE_REG, Reg: v.Reg()}
 		p.Reg = v.Args[0].Reg()
 		p.From = obj.Addr{Type: obj.TYPE_REG, Reg: v.Args[1].Reg()}
-		p.SetFrom3Const(int64(mask))
+		p.SetRestArgs([]obj.Addr{{Type: obj.TYPE_CONST, Offset: mb}, {Type: obj.TYPE_CONST, Offset: me}})
 
 	case ssa.OpPPC64MADDLD:
 		r := v.Reg()
diff --git a/src/cmd/internal/obj/ppc64/asm9.go b/src/cmd/internal/obj/ppc64/asm9.go
index 7985f050de..648a41b5c7 100644
--- a/src/cmd/internal/obj/ppc64/asm9.go
+++ b/src/cmd/internal/obj/ppc64/asm9.go
@@ -181,7 +181,9 @@ var optab = []Optab{
 	{as: ASRAD, a1: C_SCON, a2: C_REG, a6: C_REG, type_: 56, size: 4},
 	{as: ASRAD, a1: C_SCON, a6: C_REG, type_: 56, size: 4},
 	{as: ARLWMI, a1: C_SCON, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 62, size: 4},
+	{as: ARLWMI, a1: C_SCON, a2: C_REG, a3: C_SCON, a4: C_SCON, a6: C_REG, type_: 102, size: 4},
 	{as: ARLWMI, a1: C_REG, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 63, size: 4},
+	{as: ARLWMI, a1: C_REG, a2: C_REG, a3: C_SCON, a4: C_SCON, a6: C_REG, type_: 103, size: 4},
 	{as: ACLRLSLWI, a1: C_SCON, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 62, size: 4},
 	{as: ARLDMI, a1: C_SCON, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 30, size: 4},
 	{as: ARLDC, a1: C_SCON, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 29, size: 4},
@@ -3861,6 +3863,17 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		}
 	case 101:
 		o1 = AOP_XX2(c.oprrr(p.As), uint32(p.To.Reg), uint32(0), uint32(p.From.Reg))
+
+	case 102: /* RLWMI $sh,rs,$mb,$me,rt (M-form opcode)*/
+		mb := uint32(c.regoff(&p.RestArgs[0].Addr))
+		me := uint32(c.regoff(&p.RestArgs[1].Addr))
+		sh := uint32(c.regoff(&p.From))
+		o1 = OP_RLW(c.opirr(p.As), uint32(p.To.Reg), uint32(p.Reg), sh, mb, me)
+
+	case 103: /* RLWMI rb,rs,$mb,$me,rt (M-form opcode)*/
+		mb := uint32(c.regoff(&p.RestArgs[0].Addr))
+		me := uint32(c.regoff(&p.RestArgs[1].Addr))
+		o1 = OP_RLW(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.Reg), uint32(p.From.Reg), mb, me)
 	}
 
 	out[0] = o1
diff --git a/test/codegen/rotate.go b/test/codegen/rotate.go
index e0bcd0abbc..bf4bcc4fc3 100644
--- a/test/codegen/rotate.go
+++ b/test/codegen/rotate.go
@@ -176,38 +176,38 @@ func f32(x uint32) uint32 {
 func checkMaskedRotate32(a []uint32, r int) {
 	i := 0
 
-	// ppc64le: "RLWNM\t[$]16, R[0-9]+, [$]16711680, R[0-9]+"
-	// ppc64: "RLWNM\t[$]16, R[0-9]+, [$]16711680, R[0-9]+"
+	// ppc64le: "RLWNM\t[$]16, R[0-9]+, [$]8, [$]15, R[0-9]+"
+	// ppc64: "RLWNM\t[$]16, R[0-9]+, [$]8, [$]15, R[0-9]+"
 	a[i] = bits.RotateLeft32(a[i], 16) & 0xFF0000
 	i++
-	// ppc64le: "RLWNM\t[$]16, R[0-9]+, [$]16711680, R[0-9]+"
-	// ppc64: "RLWNM\t[$]16, R[0-9]+, [$]16711680, R[0-9]+"
+	// ppc64le: "RLWNM\t[$]16, R[0-9]+, [$]8, [$]15, R[0-9]+"
+	// ppc64: "RLWNM\t[$]16, R[0-9]+, [$]8, [$]15, R[0-9]+"
 	a[i] = bits.RotateLeft32(a[i]&0xFF, 16)
 	i++
-	// ppc64le: "RLWNM\t[$]4, R[0-9]+, [$]4080, R[0-9]+"
-	// ppc64: "RLWNM\t[$]4, R[0-9]+, [$]4080, R[0-9]+"
+	// ppc64le: "RLWNM\t[$]4, R[0-9]+, [$]20, [$]27, R[0-9]+"
+	// ppc64: "RLWNM\t[$]4, R[0-9]+, [$]20, [$]27, R[0-9]+"
 	a[i] = bits.RotateLeft32(a[i], 4) & 0xFF0
 	i++
-	// ppc64le: "RLWNM\t[$]16, R[0-9]+, [$]255, R[0-9]+"
-	// ppc64: "RLWNM\t[$]16, R[0-9]+, [$]255, R[0-9]+"
+	// ppc64le: "RLWNM\t[$]16, R[0-9]+, [$]24, [$]31, R[0-9]+"
+	// ppc64: "RLWNM\t[$]16, R[0-9]+, [$]24, [$]31, R[0-9]+"
 	a[i] = bits.RotateLeft32(a[i]&0xFF0000, 16)
 	i++
 
-	// ppc64le: "RLWNM\tR[0-9]+, R[0-9]+, [$]16711680, R[0-9]+"
-	// ppc64: "RLWNM\tR[0-9]+, R[0-9]+, [$]16711680, R[0-9]+"
+	// ppc64le: "RLWNM\tR[0-9]+, R[0-9]+, [$]8, [$]15, R[0-9]+"
+	// ppc64: "RLWNM\tR[0-9]+, R[0-9]+, [$]8, [$]15, R[0-9]+"
 	a[i] = bits.RotateLeft32(a[i], r) & 0xFF0000
 	i++
-	// ppc64le: "RLWNM\tR[0-9]+, R[0-9]+, [$]65280, R[0-9]+"
-	// ppc64: "RLWNM\tR[0-9]+, R[0-9]+, [$]65280, R[0-9]+"
+	// ppc64le: "RLWNM\tR[0-9]+, R[0-9]+, [$]16, [$]23, R[0-9]+"
+	// ppc64: "RLWNM\tR[0-9]+, R[0-9]+, [$]16, [$]23, R[0-9]+"
 	a[i] = bits.RotateLeft32(a[3], r) & 0xFF00
 	i++
 
-	// ppc64le: "RLWNM\tR[0-9]+, R[0-9]+, [$]4293922815, R[0-9]+"
-	// ppc64: "RLWNM\tR[0-9]+, R[0-9]+, [$]4293922815, R[0-9]+"
+	// ppc64le: "RLWNM\tR[0-9]+, R[0-9]+, [$]20, [$]11, R[0-9]+"
+	// ppc64: "RLWNM\tR[0-9]+, R[0-9]+, [$]20, [$]11, R[0-9]+"
 	a[i] = bits.RotateLeft32(a[3], r) & 0xFFF00FFF
 	i++
-	// ppc64le: "RLWNM\t[$]4, R[0-9]+, [$]4293922815, R[0-9]+"
-	// ppc64: "RLWNM\t[$]4, R[0-9]+, [$]4293922815, R[0-9]+"
+	// ppc64le: "RLWNM\t[$]4, R[0-9]+, [$]20, [$]11, R[0-9]+"
+	// ppc64: "RLWNM\t[$]4, R[0-9]+, [$]20, [$]11, R[0-9]+"
 	a[i] = bits.RotateLeft32(a[3], 4) & 0xFFF00FFF
 	i++
 }
diff --git a/test/codegen/shift.go b/test/codegen/shift.go
index d19a1984c1..ab0ffc2e13 100644
--- a/test/codegen/shift.go
+++ b/test/codegen/shift.go
@@ -240,12 +240,12 @@ func checkWidenAfterShift(v int64, u uint64) (int64, uint64) {
 func checkShiftAndMask32(v []uint32) {
 	i := 0
 
-	// ppc64le: "RLWNM\t[$]24, R[0-9]+, [$]1044480, R[0-9]+"
-	// ppc64: "RLWNM\t[$]24, R[0-9]+, [$]1044480, R[0-9]+"
+	// ppc64le: "RLWNM\t[$]24, R[0-9]+, [$]12, [$]19, R[0-9]+"
+	// ppc64: "RLWNM\t[$]24, R[0-9]+, [$]12, [$]19, R[0-9]+"
 	v[i] = (v[i] & 0xFF00000) >> 8
 	i++
-	// ppc64le: "RLWNM\t[$]26, R[0-9]+, [$]1020, R[0-9]+"
-	// ppc64: "RLWNM\t[$]26, R[0-9]+, [$]1020, R[0-9]+"
+	// ppc64le: "RLWNM\t[$]26, R[0-9]+, [$]22, [$]29, R[0-9]+"
+	// ppc64: "RLWNM\t[$]26, R[0-9]+, [$]22, [$]29, R[0-9]+"
 	v[i] = (v[i] & 0xFF00) >> 6
 	i++
 	// ppc64le: "MOVW\tR0"
@@ -256,12 +256,12 @@ func checkShiftAndMask32(v []uint32) {
 	// ppc64: "MOVW\tR0"
 	v[i] = (v[i] & 0xF000000) >> 28
 	i++
-	// ppc64le: "RLWNM\t[$]26, R[0-9]+, [$]255, R[0-9]+"
-	// ppc64: "RLWNM\t[$]26, R[0-9]+, [$]255, R[0-9]+"
+	// ppc64le: "RLWNM\t[$]26, R[0-9]+, [$]24, [$]31, R[0-9]+"
+	// ppc64: "RLWNM\t[$]26, R[0-9]+, [$]24, [$]31, R[0-9]+"
 	v[i] = (v[i] >> 6) & 0xFF
 	i++
-	// ppc64le: "RLWNM\t[$]26, R[0-9]+, [$]1044480, R[0-9]+"
-	// ppc64: "RLWNM\t[$]26, R[0-9]+, [$]1044480, R[0-9]+"
+	// ppc64le: "RLWNM\t[$]26, R[0-9]+, [$]12, [$]19, R[0-9]+"
+	// ppc64: "RLWNM\t[$]26, R[0-9]+, [$]12, [$]19, R[0-9]+"
 	v[i] = (v[i] >> 6) & 0xFF000
 	i++
 	// ppc64le: "MOVW\tR0"
@@ -275,16 +275,16 @@ func checkShiftAndMask32(v []uint32) {
 }
 
 func checkMergedShifts32(a [256]uint32, b [256]uint64, u uint32, v uint32) {
-	//ppc64le: -"CLRLSLDI", "RLWNM\t[$]10, R[0-9]+, [$]1020, R[0-9]+"
-	//ppc64: -"CLRLSLDI", "RLWNM\t[$]10, R[0-9]+, [$]1020, R[0-9]+"
+	//ppc64le: -"CLRLSLDI", "RLWNM\t[$]10, R[0-9]+, [$]22, [$]29, R[0-9]+"
+	//ppc64: -"CLRLSLDI", "RLWNM\t[$]10, R[0-9]+, [$]22, [$]29, R[0-9]+"
 	a[0] = a[uint8(v>>24)]
-	//ppc64le: -"CLRLSLDI", "RLWNM\t[$]11, R[0-9]+, [$]2040, R[0-9]+"
-	//ppc64: -"CLRLSLDI", "RLWNM\t[$]11, R[0-9]+, [$]2040, R[0-9]+"
+	//ppc64le: -"CLRLSLDI", "RLWNM\t[$]11, R[0-9]+, [$]21, [$]28, R[0-9]+"
+	//ppc64: -"CLRLSLDI", "RLWNM\t[$]11, R[0-9]+, [$]21, [$]28, R[0-9]+"
 	b[0] = b[uint8(v>>24)]
-	//ppc64le: -"CLRLSLDI", "RLWNM\t[$]15, R[0-9]+, [$]2040, R[0-9]+"
-	//ppc64: -"CLRLSLDI", "RLWNM\t[$]15, R[0-9]+, [$]2040, R[0-9]+"
+	//ppc64le: -"CLRLSLDI", "RLWNM\t[$]15, R[0-9]+, [$]21, [$]28, R[0-9]+"
+	//ppc64: -"CLRLSLDI", "RLWNM\t[$]15, R[0-9]+, [$]21, [$]28, R[0-9]+"
 	b[1] = b[(v>>20)&0xFF]
-	//ppc64le: -"SLD", "RLWNM\t[$]10, R[0-9]+, [$]1016, R[0-9]+"
-	//ppc64: -"SLD", "RLWNM\t[$]10, R[0-9]+, [$]1016, R[0-9]+"
+	//ppc64le: -"SLD", "RLWNM\t[$]10, R[0-9]+, [$]22, [$]28, R[0-9]+"
+	//ppc64: -"SLD", "RLWNM\t[$]10, R[0-9]+, [$]22, [$]28, R[0-9]+"
 	b[2] = b[v>>25]
 }
-- 
GitLab


From 142a76530cf610fe02d151727fa0d8038c552127 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 9 Mar 2021 14:22:38 -0500
Subject: [PATCH 0999/2400] go/types: improve the positioning of broken import
 errors

The heuristic gopls uses to guess error spans can get tripped-up on
certain valid characters in an import path (for example '-').

Update the error for broken imports to capture the full import path
span, so that gopls doesn't need to rely on heuristics.

Change-Id: Ieb8e0dce11933643f701b32271ff5f3477fecaaa
Reviewed-on: https://go-review.googlesource.com/c/go/+/300169
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/resolver.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/go/types/resolver.go b/src/go/types/resolver.go
index 763ea48d38..8e67237446 100644
--- a/src/go/types/resolver.go
+++ b/src/go/types/resolver.go
@@ -130,7 +130,7 @@ func (check *Checker) filename(fileNo int) string {
 	return fmt.Sprintf("file[%d]", fileNo)
 }
 
-func (check *Checker) importPackage(pos token.Pos, path, dir string) *Package {
+func (check *Checker) importPackage(at positioner, path, dir string) *Package {
 	// If we already have a package for the given (path, dir)
 	// pair, use it instead of doing a full import.
 	// Checker.impMap only caches packages that are marked Complete
@@ -170,7 +170,7 @@ func (check *Checker) importPackage(pos token.Pos, path, dir string) *Package {
 			imp = nil // create fake package below
 		}
 		if err != nil {
-			check.errorf(atPos(pos), _BrokenImport, "could not import %s (%s)", path, err)
+			check.errorf(at, _BrokenImport, "could not import %s (%s)", path, err)
 			if imp == nil {
 				// create a new fake package
 				// come up with a sensible package name (heuristic)
@@ -254,7 +254,7 @@ func (check *Checker) collectObjects() {
 					return
 				}
 
-				imp := check.importPackage(d.spec.Path.Pos(), path, fileDir)
+				imp := check.importPackage(d.spec.Path, path, fileDir)
 				if imp == nil {
 					return
 				}
-- 
GitLab


From acd7cb5887f486558fbcd517ed636a96447d695d Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 25 Feb 2021 14:54:04 -0800
Subject: [PATCH 1000/2400] cmd/compile/internal/types2: better error reporting
 framework (starting point)

Until now, errors which came with additional details (e.g., a declaration
cycle error followed by the list of objects involved in the cycle, one per
line) were reported as an ordinary error followed by "secondary" errors,
with the secondary errors marked as such by having a tab-indented error
message.

This approach often required clients to filter these secondary errors
(as they are not new errors, they are just clarifying a previously
reported error).

This CL introduces a new internal error_ type which permits accumulating
various error information that may then be reported as a single error.

Change-Id: I25b2f094facd37e12737e517f7ef8853d465ff77
Reviewed-on: https://go-review.googlesource.com/c/go/+/296689
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/noder/irgen.go       |  8 --
 src/cmd/compile/internal/types2/check_test.go |  6 +-
 src/cmd/compile/internal/types2/decl.go       | 30 ++++---
 src/cmd/compile/internal/types2/errors.go     | 89 ++++++++++++++++---
 .../compile/internal/types2/errors_test.go    | 20 +++++
 src/cmd/compile/internal/types2/initorder.go  | 10 ++-
 src/cmd/compile/internal/types2/labels.go     |  7 +-
 src/cmd/compile/internal/types2/resolver.go   | 18 ++--
 src/cmd/compile/internal/types2/stmt.go       | 18 ++--
 src/cmd/compile/internal/types2/typexpr.go    | 24 +++--
 10 files changed, 166 insertions(+), 64 deletions(-)

diff --git a/src/cmd/compile/internal/noder/irgen.go b/src/cmd/compile/internal/noder/irgen.go
index 06b234c31d..2de8c3fa60 100644
--- a/src/cmd/compile/internal/noder/irgen.go
+++ b/src/cmd/compile/internal/noder/irgen.go
@@ -41,14 +41,6 @@ func check2(noders []*noder) {
 		CompilerErrorMessages: true, // use error strings matching existing compiler errors
 		Error: func(err error) {
 			terr := err.(types2.Error)
-			if len(terr.Msg) > 0 && terr.Msg[0] == '\t' {
-				// types2 reports error clarifications via separate
-				// error messages which are indented with a tab.
-				// Ignore them to satisfy tools and tests that expect
-				// only one error in such cases.
-				// TODO(gri) Need to adjust error reporting in types2.
-				return
-			}
 			base.ErrorfAt(m.makeXPos(terr.Pos), "%s", terr.Msg)
 		},
 		Importer: &gcimports{
diff --git a/src/cmd/compile/internal/types2/check_test.go b/src/cmd/compile/internal/types2/check_test.go
index 9c1d278520..fc6f46b4b8 100644
--- a/src/cmd/compile/internal/types2/check_test.go
+++ b/src/cmd/compile/internal/types2/check_test.go
@@ -146,11 +146,7 @@ func checkFiles(t *testing.T, sources []string, goVersion string, colDelta uint,
 			t.Error(err)
 			return
 		}
-		// Ignore secondary error messages starting with "\t";
-		// they are clarifying messages for a primary error.
-		if !strings.Contains(err.Error(), ": \t") {
-			errlist = append(errlist, err)
-		}
+		errlist = append(errlist, err)
 	}
 	conf.Check(pkgName, files, nil)
 
diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index f0a037adb0..3528669bf9 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -11,12 +11,12 @@ import (
 	"go/constant"
 )
 
-func (check *Checker) reportAltDecl(obj Object) {
+func (err *error_) recordAltDecl(obj Object) {
 	if pos := obj.Pos(); pos.IsKnown() {
 		// We use "other" rather than "previous" here because
 		// the first declaration seen may not be textually
 		// earlier in the source.
-		check.errorf(pos, "\tother declaration of %s", obj.Name()) // secondary error, \t indented
+		err.errorf(pos, "other declaration of %s", obj.Name())
 	}
 }
 
@@ -27,8 +27,10 @@ func (check *Checker) declare(scope *Scope, id *syntax.Name, obj Object, pos syn
 	// binding."
 	if obj.Name() != "_" {
 		if alt := scope.Insert(obj); alt != nil {
-			check.errorf(obj.Pos(), "%s redeclared in this block", obj.Name())
-			check.reportAltDecl(alt)
+			var err error_
+			err.errorf(obj, "%s redeclared in this block", obj.Name())
+			err.recordAltDecl(alt)
+			check.report(&err)
 			return
 		}
 		obj.setScopePos(pos)
@@ -364,20 +366,22 @@ func (check *Checker) cycleError(cycle []Object) {
 	//           cycle? That would be more consistent with other error messages.
 	i := firstInSrc(cycle)
 	obj := cycle[i]
+	var err error_
 	if check.conf.CompilerErrorMessages {
-		check.errorf(obj.Pos(), "invalid recursive type %s", obj.Name())
+		err.errorf(obj, "invalid recursive type %s", obj.Name())
 	} else {
-		check.errorf(obj.Pos(), "illegal cycle in declaration of %s", obj.Name())
+		err.errorf(obj, "illegal cycle in declaration of %s", obj.Name())
 	}
 	for range cycle {
-		check.errorf(obj.Pos(), "\t%s refers to", obj.Name()) // secondary error, \t indented
+		err.errorf(obj, "%s refers to", obj.Name())
 		i++
 		if i >= len(cycle) {
 			i = 0
 		}
 		obj = cycle[i]
 	}
-	check.errorf(obj.Pos(), "\t%s", obj.Name())
+	err.errorf(obj, "%s", obj.Name())
+	check.report(&err)
 }
 
 // TODO(gri) This functionality should probably be with the Pos implementation.
@@ -787,19 +791,21 @@ func (check *Checker) collectMethods(obj *TypeName) {
 		// to it must be unique."
 		assert(m.name != "_")
 		if alt := mset.insert(m); alt != nil {
+			var err error_
 			switch alt.(type) {
 			case *Var:
-				check.errorf(m.pos, "field and method with the same name %s", m.name)
+				err.errorf(m.pos, "field and method with the same name %s", m.name)
 			case *Func:
 				if check.conf.CompilerErrorMessages {
-					check.errorf(m.pos, "%s.%s redeclared in this block", obj.Name(), m.name)
+					err.errorf(m.pos, "%s.%s redeclared in this block", obj.Name(), m.name)
 				} else {
-					check.errorf(m.pos, "method %s already declared for %s", m.name, obj)
+					err.errorf(m.pos, "method %s already declared for %s", m.name, obj)
 				}
 			default:
 				unreachable()
 			}
-			check.reportAltDecl(alt)
+			err.recordAltDecl(alt)
+			check.report(&err)
 			continue
 		}
 
diff --git a/src/cmd/compile/internal/types2/errors.go b/src/cmd/compile/internal/types2/errors.go
index 62b1d39d83..01df50c8e3 100644
--- a/src/cmd/compile/internal/types2/errors.go
+++ b/src/cmd/compile/internal/types2/errors.go
@@ -29,19 +29,61 @@ func unreachable() {
 	panic("unreachable")
 }
 
-func (check *Checker) qualifier(pkg *Package) string {
-	// Qualify the package unless it's the package being type-checked.
-	if pkg != check.pkg {
-		// If the same package name was used by multiple packages, display the full path.
-		if check.pkgCnt[pkg.name] > 1 {
-			return strconv.Quote(pkg.path)
+// An error_ represents a type-checking error.
+// To report an error_, call Checker.report.
+type error_ struct {
+	desc []errorDesc
+	soft bool // TODO(gri) eventually determine this from an error code
+}
+
+// An errorDesc describes part of a type-checking error.
+type errorDesc struct {
+	pos    syntax.Pos
+	format string
+	args   []interface{}
+}
+
+func (err *error_) empty() bool {
+	return err.desc == nil
+}
+
+func (err *error_) pos() syntax.Pos {
+	if err.empty() {
+		return nopos
+	}
+	return err.desc[0].pos
+}
+
+func (err *error_) msg(qf Qualifier) string {
+	if err.empty() {
+		return "no error"
+	}
+	var buf bytes.Buffer
+	for i := range err.desc {
+		p := &err.desc[i]
+		if i > 0 {
+			fmt.Fprintf(&buf, "\n\t%s: ", p.pos)
 		}
-		return pkg.name
+		buf.WriteString(sprintf(qf, p.format, p.args...))
 	}
-	return ""
+	return buf.String()
 }
 
-func (check *Checker) sprintf(format string, args ...interface{}) string {
+// String is for testing.
+func (err *error_) String() string {
+	if err.empty() {
+		return "no error"
+	}
+	return fmt.Sprintf("%s: %s", err.pos(), err.msg(nil))
+}
+
+// errorf adds formatted error information to err.
+// It may be called multiple times to provide additional information.
+func (err *error_) errorf(at poser, format string, args ...interface{}) {
+	err.desc = append(err.desc, errorDesc{posFor(at), format, args})
+}
+
+func sprintf(qf Qualifier, format string, args ...interface{}) string {
 	for i, arg := range args {
 		switch a := arg.(type) {
 		case nil:
@@ -49,21 +91,44 @@ func (check *Checker) sprintf(format string, args ...interface{}) string {
 		case operand:
 			panic("internal error: should always pass *operand")
 		case *operand:
-			arg = operandString(a, check.qualifier)
+			arg = operandString(a, qf)
 		case syntax.Pos:
 			arg = a.String()
 		case syntax.Expr:
 			arg = syntax.String(a)
 		case Object:
-			arg = ObjectString(a, check.qualifier)
+			arg = ObjectString(a, qf)
 		case Type:
-			arg = TypeString(a, check.qualifier)
+			arg = TypeString(a, qf)
 		}
 		args[i] = arg
 	}
 	return fmt.Sprintf(format, args...)
 }
 
+func (check *Checker) qualifier(pkg *Package) string {
+	// Qualify the package unless it's the package being type-checked.
+	if pkg != check.pkg {
+		// If the same package name was used by multiple packages, display the full path.
+		if check.pkgCnt[pkg.name] > 1 {
+			return strconv.Quote(pkg.path)
+		}
+		return pkg.name
+	}
+	return ""
+}
+
+func (check *Checker) sprintf(format string, args ...interface{}) string {
+	return sprintf(check.qualifier, format, args...)
+}
+
+func (check *Checker) report(err *error_) {
+	if err.empty() {
+		panic("internal error: reporting no error")
+	}
+	check.err(err.pos(), err.msg(check.qualifier), err.soft)
+}
+
 func (check *Checker) trace(pos syntax.Pos, format string, args ...interface{}) {
 	fmt.Printf("%s:\t%s%s\n",
 		pos,
diff --git a/src/cmd/compile/internal/types2/errors_test.go b/src/cmd/compile/internal/types2/errors_test.go
index cb21ff1ad3..e1f0e83fc9 100644
--- a/src/cmd/compile/internal/types2/errors_test.go
+++ b/src/cmd/compile/internal/types2/errors_test.go
@@ -6,6 +6,26 @@ package types2
 
 import "testing"
 
+func TestError(t *testing.T) {
+	var err error_
+	want := "no error"
+	if got := err.String(); got != want {
+		t.Errorf("empty error: got %q, want %q", got, want)
+	}
+
+	want = "<unknown position>: foo 42"
+	err.errorf(nopos, "foo %d", 42)
+	if got := err.String(); got != want {
+		t.Errorf("simple error: got %q, want %q", got, want)
+	}
+
+	want = "<unknown position>: foo 42\n\t<unknown position>: bar 43"
+	err.errorf(nopos, "bar %d", 43)
+	if got := err.String(); got != want {
+		t.Errorf("simple error: got %q, want %q", got, want)
+	}
+}
+
 func TestStripAnnotations(t *testing.T) {
 	for _, test := range []struct {
 		in, want string
diff --git a/src/cmd/compile/internal/types2/initorder.go b/src/cmd/compile/internal/types2/initorder.go
index a9cabecdf2..4081627666 100644
--- a/src/cmd/compile/internal/types2/initorder.go
+++ b/src/cmd/compile/internal/types2/initorder.go
@@ -151,18 +151,20 @@ func findPath(objMap map[Object]*declInfo, from, to Object, seen map[Object]bool
 // reportCycle reports an error for the given cycle.
 func (check *Checker) reportCycle(cycle []Object) {
 	obj := cycle[0]
+	var err error_
 	if check.conf.CompilerErrorMessages {
-		check.errorf(obj, "initialization loop for %s", obj.Name())
+		err.errorf(obj, "initialization loop for %s", obj.Name())
 	} else {
-		check.errorf(obj, "initialization cycle for %s", obj.Name())
+		err.errorf(obj, "initialization cycle for %s", obj.Name())
 	}
 	// subtle loop: print cycle[i] for i = 0, n-1, n-2, ... 1 for len(cycle) = n
 	for i := len(cycle) - 1; i >= 0; i-- {
-		check.errorf(obj, "\t%s refers to", obj.Name()) // secondary error, \t indented
+		err.errorf(obj, "%s refers to", obj.Name())
 		obj = cycle[i]
 	}
 	// print cycle[0] again to close the cycle
-	check.errorf(obj, "\t%s", obj.Name())
+	err.errorf(obj, "%s", obj.Name())
+	check.report(&err)
 }
 
 // ----------------------------------------------------------------------------
diff --git a/src/cmd/compile/internal/types2/labels.go b/src/cmd/compile/internal/types2/labels.go
index b20b454dea..cbbd65aa9a 100644
--- a/src/cmd/compile/internal/types2/labels.go
+++ b/src/cmd/compile/internal/types2/labels.go
@@ -128,8 +128,11 @@ func (check *Checker) blockBranches(all *Scope, parent *block, lstmt *syntax.Lab
 			if name := s.Label.Value; name != "_" {
 				lbl := NewLabel(s.Label.Pos(), check.pkg, name)
 				if alt := all.Insert(lbl); alt != nil {
-					check.softErrorf(lbl.pos, "label %s already declared", name)
-					check.reportAltDecl(alt)
+					var err error_
+					err.soft = true
+					err.errorf(lbl.pos, "label %s already declared", name)
+					err.recordAltDecl(alt)
+					check.report(&err)
 					// ok to continue
 				} else {
 					b.insert(s)
diff --git a/src/cmd/compile/internal/types2/resolver.go b/src/cmd/compile/internal/types2/resolver.go
index 44fa51a8e5..fe551525c6 100644
--- a/src/cmd/compile/internal/types2/resolver.go
+++ b/src/cmd/compile/internal/types2/resolver.go
@@ -305,8 +305,10 @@ func (check *Checker) collectObjects() {
 							// the object may be imported into more than one file scope
 							// concurrently. See issue #32154.)
 							if alt := fileScope.Insert(obj); alt != nil {
-								check.errorf(s.LocalPkgName, "%s redeclared in this block", obj.Name())
-								check.reportAltDecl(alt)
+								var err error_
+								err.errorf(s.LocalPkgName, "%s redeclared in this block", obj.Name())
+								err.recordAltDecl(alt)
+								check.report(&err)
 							} else {
 								check.dotImportMap[dotImportKey{fileScope, obj}] = pkgName
 							}
@@ -456,14 +458,16 @@ func (check *Checker) collectObjects() {
 	for _, scope := range fileScopes {
 		for _, obj := range scope.elems {
 			if alt := pkg.scope.Lookup(obj.Name()); alt != nil {
+				var err error_
 				if pkg, ok := obj.(*PkgName); ok {
-					check.errorf(alt, "%s already declared through import of %s", alt.Name(), pkg.Imported())
-					check.reportAltDecl(pkg)
+					err.errorf(alt, "%s already declared through import of %s", alt.Name(), pkg.Imported())
+					err.recordAltDecl(pkg)
 				} else {
-					check.errorf(alt, "%s already declared through dot-import of %s", alt.Name(), obj.Pkg())
-					// TODO(gri) dot-imported objects don't have a position; reportAltDecl won't print anything
-					check.reportAltDecl(obj)
+					err.errorf(alt, "%s already declared through dot-import of %s", alt.Name(), obj.Pkg())
+					// TODO(gri) dot-imported objects don't have a position; recordAltDecl won't print anything
+					err.recordAltDecl(obj)
 				}
+				check.report(&err)
 			}
 		}
 	}
diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go
index 490cd0fc19..21244f6065 100644
--- a/src/cmd/compile/internal/types2/stmt.go
+++ b/src/cmd/compile/internal/types2/stmt.go
@@ -253,8 +253,10 @@ L:
 			// (quadratic algorithm, but these lists tend to be very short)
 			for _, vt := range seen[val] {
 				if check.identical(v.typ, vt.typ) {
-					check.errorf(&v, "duplicate case %s in expression switch", &v)
-					check.error(vt.pos, "\tprevious case") // secondary error, \t indented
+					var err error_
+					err.errorf(&v, "duplicate case %s in expression switch", &v)
+					err.errorf(vt.pos, "previous case")
+					check.report(&err)
 					continue L
 				}
 			}
@@ -282,8 +284,10 @@ L:
 				if T != nil {
 					Ts = T.String()
 				}
-				check.errorf(e, "duplicate case %s in type switch", Ts)
-				check.error(pos, "\tprevious case") // secondary error, \t indented
+				var err error_
+				err.errorf(e, "duplicate case %s in type switch", Ts)
+				err.errorf(pos, "previous case")
+				check.report(&err)
 				continue L
 			}
 		}
@@ -430,8 +434,10 @@ func (check *Checker) stmt(ctxt stmtContext, s syntax.Stmt) {
 				// with the same name as a result parameter is in scope at the place of the return."
 				for _, obj := range res.vars {
 					if alt := check.lookup(obj.name); alt != nil && alt != obj {
-						check.errorf(s, "result parameter %s not in scope at return", obj.name)
-						check.errorf(alt, "\tinner declaration of %s", obj)
+						var err error_
+						err.errorf(s, "result parameter %s not in scope at return", obj.name)
+						err.errorf(alt, "inner declaration of %s", obj)
+						check.report(&err)
 						// ok to continue
 					}
 				}
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 02f9b2804d..177fcf4215 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -352,8 +352,10 @@ func (check *Checker) funcType(sig *Signature, recvPar *syntax.Field, tparams []
 	params, variadic := check.collectParams(scope, ftyp.ParamList, nil, true)
 	results, _ := check.collectParams(scope, ftyp.ResultList, nil, false)
 	scope.Squash(func(obj, alt Object) {
-		check.errorf(obj, "%s redeclared in this block", obj.Name())
-		check.reportAltDecl(alt)
+		var err error_
+		err.errorf(obj, "%s redeclared in this block", obj.Name())
+		err.recordAltDecl(alt)
+		check.report(&err)
 	})
 
 	if recvPar != nil {
@@ -796,8 +798,10 @@ func (check *Checker) collectParams(scope *Scope, list []*syntax.Field, type0 sy
 
 func (check *Checker) declareInSet(oset *objset, pos syntax.Pos, obj Object) bool {
 	if alt := oset.insert(obj); alt != nil {
-		check.errorf(pos, "%s redeclared", obj.Name())
-		check.reportAltDecl(alt)
+		var err error_
+		err.errorf(pos, "%s redeclared", obj.Name())
+		err.recordAltDecl(alt)
+		check.report(&err)
 		return false
 	}
 	return true
@@ -940,8 +944,10 @@ func (check *Checker) completeInterface(pos syntax.Pos, ityp *Interface) {
 			methods = append(methods, m)
 			mpos[m] = pos
 		case explicit:
-			check.errorf(pos, "duplicate method %s", m.name)
-			check.errorf(mpos[other.(*Func)], "\tother declaration of %s", m.name) // secondary error, \t indented
+			var err error_
+			err.errorf(pos, "duplicate method %s", m.name)
+			err.errorf(mpos[other.(*Func)], "other declaration of %s", m.name)
+			check.report(&err)
 		default:
 			// We have a duplicate method name in an embedded (not explicitly declared) method.
 			// Check method signatures after all types are computed (issue #33656).
@@ -950,8 +956,10 @@ func (check *Checker) completeInterface(pos syntax.Pos, ityp *Interface) {
 			// error message.
 			check.atEnd(func() {
 				if !check.allowVersion(m.pkg, 1, 14) || !check.identical(m.typ, other.Type()) {
-					check.errorf(pos, "duplicate method %s", m.name)
-					check.errorf(mpos[other.(*Func)], "\tother declaration of %s", m.name) // secondary error, \t indented
+					var err error_
+					err.errorf(pos, "duplicate method %s", m.name)
+					err.errorf(mpos[other.(*Func)], "other declaration of %s", m.name)
+					check.report(&err)
 				}
 			})
 		}
-- 
GitLab


From 41245ab28390fed22ba03ee87c0e3db97b16c73b Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 9 Mar 2021 17:14:15 -0800
Subject: [PATCH 1001/2400] cmd/compile/internal/types2: remove concept of
 finals

This is a 1:1 port of the respective change in go/types
in https://golang.org/cl/299590.

Change-Id: I65ad723f2e21e3d95fc0b94665e0121e31871a48
Reviewed-on: https://go-review.googlesource.com/c/go/+/300250
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/check.go   | 21 ---------------------
 src/cmd/compile/internal/types2/typexpr.go | 12 ++++++------
 2 files changed, 6 insertions(+), 27 deletions(-)

diff --git a/src/cmd/compile/internal/types2/check.go b/src/cmd/compile/internal/types2/check.go
index 95fb4e1076..c853925a2a 100644
--- a/src/cmd/compile/internal/types2/check.go
+++ b/src/cmd/compile/internal/types2/check.go
@@ -107,7 +107,6 @@ type Checker struct {
 	methods  map[*TypeName][]*Func    // maps package scope type names to associated non-blank (non-interface) methods
 	untyped  map[syntax.Expr]exprInfo // map of expressions without final type
 	delayed  []func()                 // stack of delayed action segments; segments are processed in FIFO order
-	finals   []func()                 // list of final actions; processed at the end of type-checking the current set of files
 	objPath  []Object                 // path of object dependencies during type inference (for cycle reporting)
 
 	// context within which the current object is type-checked
@@ -147,14 +146,6 @@ func (check *Checker) later(f func()) {
 	check.delayed = append(check.delayed, f)
 }
 
-// atEnd adds f to the list of actions processed at the end
-// of type-checking, before initialization order computation.
-// Actions added by atEnd are processed after any actions
-// added by later.
-func (check *Checker) atEnd(f func()) {
-	check.finals = append(check.finals, f)
-}
-
 // push pushes obj onto the object path and returns its index in the path.
 func (check *Checker) push(obj Object) int {
 	check.objPath = append(check.objPath, obj)
@@ -214,7 +205,6 @@ func (check *Checker) initFiles(files []*syntax.File) {
 	check.methods = nil
 	check.untyped = nil
 	check.delayed = nil
-	check.finals = nil
 
 	// determine package name and collect valid files
 	pkg := check.pkg
@@ -281,7 +271,6 @@ func (check *Checker) checkFiles(files []*syntax.File) (err error) {
 
 	print("== processDelayed ==")
 	check.processDelayed(0) // incl. all functions
-	check.processFinals()
 
 	print("== initOrder ==")
 	check.initOrder()
@@ -324,16 +313,6 @@ func (check *Checker) processDelayed(top int) {
 	check.delayed = check.delayed[:top]
 }
 
-func (check *Checker) processFinals() {
-	n := len(check.finals)
-	for _, f := range check.finals {
-		f() // must not append to check.finals
-	}
-	if len(check.finals) != n {
-		panic("internal error: final action list grew")
-	}
-}
-
 func (check *Checker) recordUntyped() {
 	if !debug && check.Types == nil {
 		return // nothing to do
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 177fcf4215..14bc91785e 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -141,7 +141,7 @@ func (check *Checker) ordinaryType(pos syntax.Pos, typ Type) {
 	// We don't want to call under() (via Interface) or complete interfaces while we
 	// are in the middle of type-checking parameter declarations that might belong to
 	// interface methods. Delay this check to the end of type-checking.
-	check.atEnd(func() {
+	check.later(func() {
 		if t := asInterface(typ); t != nil {
 			check.completeInterface(pos, t) // TODO(gri) is this the correct position?
 			if t.allTypes != nil {
@@ -574,7 +574,7 @@ func (check *Checker) typInternal(e0 syntax.Expr, def *Named) (T Type) {
 		//
 		// Delay this check because it requires fully setup types;
 		// it is safe to continue in any case (was issue 6667).
-		check.atEnd(func() {
+		check.later(func() {
 			if !Comparable(typ.key) {
 				var why string
 				if asTypeParam(typ.key) != nil {
@@ -676,7 +676,7 @@ func (check *Checker) instantiatedType(x syntax.Expr, targs []syntax.Expr, def *
 
 	// make sure we check instantiation works at least once
 	// and that the resulting type is valid
-	check.atEnd(func() {
+	check.later(func() {
 		t := typ.expand()
 		check.validType(t, nil)
 	})
@@ -954,7 +954,7 @@ func (check *Checker) completeInterface(pos syntax.Pos, ityp *Interface) {
 			// If we're pre-go1.14 (overlapping embeddings are not permitted), report that
 			// error here as well (even though we could do it eagerly) because it's the same
 			// error message.
-			check.atEnd(func() {
+			check.later(func() {
 				if !check.allowVersion(m.pkg, 1, 14) || !check.identical(m.typ, other.Type()) {
 					var err error_
 					err.errorf(pos, "duplicate method %s", m.name)
@@ -1170,7 +1170,7 @@ func (check *Checker) structType(styp *Struct, e *syntax.StructType) {
 			// (via under(t)) a possibly incomplete type.
 			embeddedTyp := typ // for closure below
 			embeddedPos := pos
-			check.atEnd(func() {
+			check.later(func() {
 				t, isPtr := deref(embeddedTyp)
 				switch t := optype(t).(type) {
 				case *Basic:
@@ -1230,7 +1230,7 @@ func (check *Checker) collectTypeConstraints(pos syntax.Pos, types []syntax.Expr
 	// interfaces, which may not be complete yet. It's ok to do this check at the
 	// end because it's not a requirement for correctness of the code.
 	// Note: This is a quadratic algorithm, but type lists tend to be short.
-	check.atEnd(func() {
+	check.later(func() {
 		for i, t := range list {
 			if t := asInterface(t); t != nil {
 				check.completeInterface(types[i].Pos(), t)
-- 
GitLab


From d33e2192a71c33a604af247161ba1d2c1969e4c7 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Tue, 9 Mar 2021 17:23:04 -0500
Subject: [PATCH 1002/2400] cmd/go: allow '+' in package import paths in module
 mode

This change upgrades x/mod to pull in the fix from CL 300149.

Fixes #44776.

Change-Id: I273f41df2abfff76d91315b7f19fce851c8770d8
Reviewed-on: https://go-review.googlesource.com/c/go/+/300176
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go.mod                                |  2 +-
 src/cmd/go.sum                                |  4 +-
 .../testdata/script/mod_invalid_path_plus.txt | 32 ++++++++++++++++
 .../vendor/golang.org/x/mod/module/module.go  | 38 +++++++++++++++----
 src/cmd/vendor/modules.txt                    |  2 +-
 5 files changed, 66 insertions(+), 12 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/mod_invalid_path_plus.txt

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index ef05ca1ad1..05076792c8 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -6,7 +6,7 @@ require (
 	github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2
 	golang.org/x/arch v0.0.0-20201008161808-52c3e6f60cff
 	golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897
-	golang.org/x/mod v0.4.2-0.20210301144719-c8bb1bd8a2aa
+	golang.org/x/mod v0.4.2-0.20210309222212-d6ab96f2441f
 	golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e // indirect
 	golang.org/x/tools v0.1.1-0.20210220032852-2363391a5b2f
 )
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 77063f76af..3827248879 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -14,8 +14,8 @@ golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPh
 golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897 h1:pLI5jrR7OSLijeIDcmRxNmw2api+jEfxLoykJVice/E=
 golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.4.2-0.20210301144719-c8bb1bd8a2aa h1:Ci2bbuyE4ah9djFByg+fdNQcqc8DVSdcXbrWy6MBoEs=
-golang.org/x/mod v0.4.2-0.20210301144719-c8bb1bd8a2aa/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.2-0.20210309222212-d6ab96f2441f h1:mQozKYYFIVK0MXcDB8Dvw0dR3rxKLnkSCJHWznfaodQ=
+golang.org/x/mod v0.4.2-0.20210309222212-d6ab96f2441f/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
diff --git a/src/cmd/go/testdata/script/mod_invalid_path_plus.txt b/src/cmd/go/testdata/script/mod_invalid_path_plus.txt
new file mode 100644
index 0000000000..636769eb4d
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_invalid_path_plus.txt
@@ -0,0 +1,32 @@
+# https://golang.org/issue/44776
+# The '+' character should be disallowed in module paths, but allowed in package
+# paths within valid modules.
+
+go get -d example.net/cmd
+go list example.net/cmd/x++
+
+! go list -versions -m 'example.net/bad++'
+stderr '^go list -m: malformed module path "example.net/bad\+\+": invalid char ''\+''$'
+
+# TODO(bcmills): 'go get -d example.net/cmd/x++' should also work, but currently
+# it does not. This might be fixed by https://golang.org/cl/297891.
+! go get -d example.net/cmd/x++
+stderr '^go get: malformed module path "example.net/cmd/x\+\+": invalid char ''\+''$'
+
+-- go.mod --
+module example.com/m
+
+go 1.16
+
+replace (
+	example.net/cmd => ./cmd
+)
+
+-- cmd/go.mod --
+module example.net/cmd
+
+go 1.16
+-- cmd/x++/main.go --
+package main
+
+func main() {}
diff --git a/src/cmd/vendor/golang.org/x/mod/module/module.go b/src/cmd/vendor/golang.org/x/mod/module/module.go
index 272baeef17..0e03014837 100644
--- a/src/cmd/vendor/golang.org/x/mod/module/module.go
+++ b/src/cmd/vendor/golang.org/x/mod/module/module.go
@@ -224,12 +224,16 @@ func firstPathOK(r rune) bool {
 		'a' <= r && r <= 'z'
 }
 
-// pathOK reports whether r can appear in an import path element.
+// modPathOK reports whether r can appear in a module path element.
 // Paths can be ASCII letters, ASCII digits, and limited ASCII punctuation: - . _ and ~.
-// This matches what "go get" has historically recognized in import paths.
+//
+// This matches what "go get" has historically recognized in import paths,
+// and avoids confusing sequences like '%20' or '+' that would change meaning
+// if used in a URL.
+//
 // TODO(rsc): We would like to allow Unicode letters, but that requires additional
 // care in the safe encoding (see "escaped paths" above).
-func pathOK(r rune) bool {
+func modPathOK(r rune) bool {
 	if r < utf8.RuneSelf {
 		return r == '-' || r == '.' || r == '_' || r == '~' ||
 			'0' <= r && r <= '9' ||
@@ -239,6 +243,17 @@ func pathOK(r rune) bool {
 	return false
 }
 
+// modPathOK reports whether r can appear in a package import path element.
+//
+// Import paths are intermediate between module paths and file paths: we allow
+// disallow characters that would be confusing or ambiguous as arguments to
+// 'go get' (such as '@' and ' ' ), but allow certain characters that are
+// otherwise-unambiguous on the command line and historically used for some
+// binary names (such as '++' as a suffix for compiler binaries and wrappers).
+func importPathOK(r rune) bool {
+	return modPathOK(r) || r == '+'
+}
+
 // fileNameOK reports whether r can appear in a file name.
 // For now we allow all Unicode letters but otherwise limit to pathOK plus a few more punctuation characters.
 // If we expand the set of allowed characters here, we have to
@@ -394,12 +409,19 @@ func checkElem(elem string, kind pathKind) error {
 	if elem[len(elem)-1] == '.' {
 		return fmt.Errorf("trailing dot in path element")
 	}
-	charOK := pathOK
-	if kind == filePath {
-		charOK = fileNameOK
-	}
 	for _, r := range elem {
-		if !charOK(r) {
+		ok := false
+		switch kind {
+		case modulePath:
+			ok = modPathOK(r)
+		case importPath:
+			ok = importPathOK(r)
+		case filePath:
+			ok = fileNameOK(r)
+		default:
+			panic(fmt.Sprintf("internal error: invalid kind %v", kind))
+		}
+		if !ok {
 			return fmt.Errorf("invalid char %q", r)
 		}
 	}
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index b1a2c67581..b84ee5a7b1 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -28,7 +28,7 @@ golang.org/x/arch/x86/x86asm
 golang.org/x/crypto/ed25519
 golang.org/x/crypto/ed25519/internal/edwards25519
 golang.org/x/crypto/ssh/terminal
-# golang.org/x/mod v0.4.2-0.20210301144719-c8bb1bd8a2aa
+# golang.org/x/mod v0.4.2-0.20210309222212-d6ab96f2441f
 ## explicit
 golang.org/x/mod/internal/lazyregexp
 golang.org/x/mod/modfile
-- 
GitLab


From 643d240a11b2d00e1718b02719707af0708e7519 Mon Sep 17 00:00:00 2001
From: Andy Pan <panjf2000@gmail.com>
Date: Thu, 19 Nov 2020 19:09:14 +0800
Subject: [PATCH 1003/2400] internal/poll: implement a pipe pool for splice()
 call
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

In scenarios where splice() is called, splice() is usually called not just once, but many times,
which means that a lot of pipes will be created and destroyed frequently, costing an amount of system resources
and slowing down performance, thus I suggest that we add a pipe pool for reusing pipes.

Benchmark tests:

goos: linux
goarch: amd64
pkg: internal/poll
cpu: AMD EPYC 7K62 48-Core Processor

name                  old time/op    new time/op    delta
SplicePipe-8            1.36µs ± 1%    0.02µs ± 0%   -98.57%  (p=0.001 n=7+7)
SplicePipeParallel-8     747ns ± 4%       4ns ± 0%   -99.41%  (p=0.001 n=7+7)

name                  old alloc/op   new alloc/op   delta
SplicePipe-8             24.0B ± 0%      0.0B       -100.00%  (p=0.001 n=7+7)
SplicePipeParallel-8     24.0B ± 0%      0.0B       -100.00%  (p=0.001 n=7+7)

name                  old allocs/op  new allocs/op  delta
SplicePipe-8              1.00 ± 0%      0.00       -100.00%  (p=0.001 n=7+7)
SplicePipeParallel-8      1.00 ± 0%      0.00       -100.00%  (p=0.001 n=7+7)

Fixes #42740

Change-Id: Idff654b7264342084e089b5ba796c87c380c471b
Reviewed-on: https://go-review.googlesource.com/c/go/+/271537
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Brad Fitzpatrick <bradfitz@golang.org>
---
 src/internal/poll/export_linux_test.go | 22 ++++++
 src/internal/poll/splice_linux.go      | 87 +++++++++++++++++------
 src/internal/poll/splice_linux_test.go | 96 ++++++++++++++++++++++++++
 3 files changed, 185 insertions(+), 20 deletions(-)
 create mode 100644 src/internal/poll/export_linux_test.go
 create mode 100644 src/internal/poll/splice_linux_test.go

diff --git a/src/internal/poll/export_linux_test.go b/src/internal/poll/export_linux_test.go
new file mode 100644
index 0000000000..7fba793697
--- /dev/null
+++ b/src/internal/poll/export_linux_test.go
@@ -0,0 +1,22 @@
+// Copyright 2021 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.
+
+// Export guts for testing on linux.
+// Since testing imports os and os imports internal/poll,
+// the internal/poll tests can not be in package poll.
+
+package poll
+
+var (
+	GetPipe     = getPipe
+	PutPipe     = putPipe
+	NewPipe     = newPipe
+	DestroyPipe = destroyPipe
+)
+
+func GetPipeFds(p *SplicePipe) (int, int) {
+	return p.rfd, p.wfd
+}
+
+type SplicePipe = splicePipe
diff --git a/src/internal/poll/splice_linux.go b/src/internal/poll/splice_linux.go
index 968bc44a5f..971f754f43 100644
--- a/src/internal/poll/splice_linux.go
+++ b/src/internal/poll/splice_linux.go
@@ -6,6 +6,8 @@ package poll
 
 import (
 	"internal/syscall/unix"
+	"runtime"
+	"sync"
 	"sync/atomic"
 	"syscall"
 	"unsafe"
@@ -23,23 +25,23 @@ const (
 // Splice transfers at most remain bytes of data from src to dst, using the
 // splice system call to minimize copies of data from and to userspace.
 //
-// Splice creates a temporary pipe, to serve as a buffer for the data transfer.
+// Splice gets a pipe buffer from the pool or creates a new one if needed, to serve as a buffer for the data transfer.
 // src and dst must both be stream-oriented sockets.
 //
 // If err != nil, sc is the system call which caused the error.
 func Splice(dst, src *FD, remain int64) (written int64, handled bool, sc string, err error) {
-	prfd, pwfd, sc, err := newTempPipe()
+	p, sc, err := getPipe()
 	if err != nil {
 		return 0, false, sc, err
 	}
-	defer destroyTempPipe(prfd, pwfd)
+	defer putPipe(p)
 	var inPipe, n int
 	for err == nil && remain > 0 {
 		max := maxSpliceSize
 		if int64(max) > remain {
 			max = int(remain)
 		}
-		inPipe, err = spliceDrain(pwfd, src, max)
+		inPipe, err = spliceDrain(p.wfd, src, max)
 		// The operation is considered handled if splice returns no
 		// error, or an error other than EINVAL. An EINVAL means the
 		// kernel does not support splice for the socket type of src.
@@ -55,10 +57,13 @@ func Splice(dst, src *FD, remain int64) (written int64, handled bool, sc string,
 		if err != nil || inPipe == 0 {
 			break
 		}
-		n, err = splicePump(dst, prfd, inPipe)
+		p.data += inPipe
+
+		n, err = splicePump(dst, p.rfd, inPipe)
 		if n > 0 {
 			written += int64(n)
 			remain -= int64(n)
+			p.data -= n
 		}
 	}
 	if err != nil {
@@ -149,13 +154,57 @@ func splice(out int, in int, max int, flags int) (int, error) {
 	return int(n), err
 }
 
+type splicePipe struct {
+	rfd  int
+	wfd  int
+	data int
+}
+
+// splicePipePool caches pipes to avoid high frequency construction and destruction of pipe buffers.
+// The garbage collector will free all pipes in the sync.Pool in periodically, thus we need to set up
+// a finalizer for each pipe to close the its file descriptors before the actual GC.
+var splicePipePool = sync.Pool{New: newPoolPipe}
+
+func newPoolPipe() interface{} {
+	// Discard the error which occurred during the creation of pipe buffer,
+	// redirecting the data transmission to the conventional way utilizing read() + write() as a fallback.
+	p := newPipe()
+	if p != nil {
+		runtime.SetFinalizer(p, destroyPipe)
+	}
+	return p
+}
+
+// getPipe tries to acquire a pipe buffer from the pool or create a new one with newPipe() if it gets nil from cache.
+//
+// Note that it may fail to create a new pipe buffer by newPipe(), in which case getPipe() will return a generic error
+// and system call name splice in string as the indication.
+func getPipe() (*splicePipe, string, error) {
+	v := splicePipePool.Get()
+	if v == nil {
+		return nil, "splice", syscall.EINVAL
+	}
+	return v.(*splicePipe), "", nil
+}
+
+func putPipe(p *splicePipe) {
+	// If there is still data left in the pipe,
+	// then close and discard it instead of putting it back into the pool.
+	if p.data != 0 {
+		runtime.SetFinalizer(p, nil)
+		destroyPipe(p)
+		return
+	}
+	splicePipePool.Put(p)
+}
+
 var disableSplice unsafe.Pointer
 
-// newTempPipe sets up a temporary pipe for a splice operation.
-func newTempPipe() (prfd, pwfd int, sc string, err error) {
+// newPipe sets up a pipe for a splice operation.
+func newPipe() (sp *splicePipe) {
 	p := (*bool)(atomic.LoadPointer(&disableSplice))
 	if p != nil && *p {
-		return -1, -1, "splice", syscall.EINVAL
+		return nil
 	}
 
 	var fds [2]int
@@ -165,9 +214,11 @@ func newTempPipe() (prfd, pwfd int, sc string, err error) {
 	// closed.
 	const flags = syscall.O_CLOEXEC | syscall.O_NONBLOCK
 	if err := syscall.Pipe2(fds[:], flags); err != nil {
-		return -1, -1, "pipe2", err
+		return nil
 	}
 
+	sp = &splicePipe{rfd: fds[0], wfd: fds[1]}
+
 	if p == nil {
 		p = new(bool)
 		defer atomic.StorePointer(&disableSplice, unsafe.Pointer(p))
@@ -175,20 +226,16 @@ func newTempPipe() (prfd, pwfd int, sc string, err error) {
 		// F_GETPIPE_SZ was added in 2.6.35, which does not have the -EAGAIN bug.
 		if _, _, errno := syscall.Syscall(unix.FcntlSyscall, uintptr(fds[0]), syscall.F_GETPIPE_SZ, 0); errno != 0 {
 			*p = true
-			destroyTempPipe(fds[0], fds[1])
-			return -1, -1, "fcntl", errno
+			destroyPipe(sp)
+			return nil
 		}
 	}
 
-	return fds[0], fds[1], "", nil
+	return
 }
 
-// destroyTempPipe destroys a temporary pipe.
-func destroyTempPipe(prfd, pwfd int) error {
-	err := CloseFunc(prfd)
-	err1 := CloseFunc(pwfd)
-	if err == nil {
-		return err1
-	}
-	return err
+// destroyPipe destroys a pipe.
+func destroyPipe(p *splicePipe) {
+	CloseFunc(p.rfd)
+	CloseFunc(p.wfd)
 }
diff --git a/src/internal/poll/splice_linux_test.go b/src/internal/poll/splice_linux_test.go
new file mode 100644
index 0000000000..9ea5197242
--- /dev/null
+++ b/src/internal/poll/splice_linux_test.go
@@ -0,0 +1,96 @@
+// Copyright 2021 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 poll_test
+
+import (
+	"internal/poll"
+	"runtime"
+	"syscall"
+	"testing"
+	"time"
+)
+
+// checkPipes returns true if all pipes are closed properly, false otherwise.
+func checkPipes(fds []int) bool {
+	for _, fd := range fds {
+		// Check if each pipe fd has been closed.
+		err := syscall.FcntlFlock(uintptr(fd), syscall.F_GETFD, nil)
+		if err == nil {
+			return false
+		}
+	}
+	return true
+}
+
+func TestSplicePipePool(t *testing.T) {
+	const N = 64
+	var (
+		p   *poll.SplicePipe
+		ps  []*poll.SplicePipe
+		fds []int
+		err error
+	)
+	for i := 0; i < N; i++ {
+		p, _, err = poll.GetPipe()
+		if err != nil {
+			t.Skip("failed to create pipe, skip this test")
+		}
+		prfd, pwfd := poll.GetPipeFds(p)
+		fds = append(fds, prfd, pwfd)
+		ps = append(ps, p)
+	}
+	for _, p = range ps {
+		poll.PutPipe(p)
+	}
+	ps = nil
+
+	var ok bool
+	// Trigger garbage collection to free the pipes in sync.Pool and check whether or not
+	// those pipe buffers have been closed as we expected.
+	for i := 0; i < 5; i++ {
+		runtime.GC()
+		time.Sleep(time.Duration(i*100+10) * time.Millisecond)
+		if ok = checkPipes(fds); ok {
+			break
+		}
+	}
+
+	if !ok {
+		t.Fatal("at least one pipe is still open")
+	}
+}
+
+func BenchmarkSplicePipe(b *testing.B) {
+	b.Run("SplicePipeWithPool", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			p, _, _ := poll.GetPipe()
+			poll.PutPipe(p)
+		}
+	})
+	b.Run("SplicePipeWithoutPool", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			p := poll.NewPipe()
+			poll.DestroyPipe(p)
+		}
+	})
+}
+
+func BenchmarkSplicePipePoolParallel(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			p, _, _ := poll.GetPipe()
+			poll.PutPipe(p)
+		}
+	})
+}
+
+func BenchmarkSplicePipeNativeParallel(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			p := poll.NewPipe()
+			poll.DestroyPipe(p)
+		}
+	})
+}
-- 
GitLab


From 4d608eb224fe1ba8e8532fcc44f91702a5b17f9f Mon Sep 17 00:00:00 2001
From: fanzha02 <fannie.zhang@arm.com>
Date: Wed, 10 Mar 2021 10:09:39 +0800
Subject: [PATCH 1004/2400] testing: fix typo in a comment

Change-Id: I781808327be84113cd55c52bc214b821cd166114
Reviewed-on: https://go-review.googlesource.com/c/go/+/300269
Trust: fannie zhang <Fannie.Zhang@arm.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/testing/testing.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/testing/testing.go b/src/testing/testing.go
index fc52f3c547..fafc67c5b7 100644
--- a/src/testing/testing.go
+++ b/src/testing/testing.go
@@ -388,7 +388,7 @@ type common struct {
 	w           io.Writer            // For flushToParent.
 	ran         bool                 // Test or benchmark (or one of its subtests) was executed.
 	failed      bool                 // Test or benchmark has failed.
-	skipped     bool                 // Test of benchmark has been skipped.
+	skipped     bool                 // Test or benchmark has been skipped.
 	done        bool                 // Test is finished and all subtests have completed.
 	helperPCs   map[uintptr]struct{} // functions to be skipped when writing file/line info
 	helperNames map[string]struct{}  // helperPCs converted to function names
-- 
GitLab


From cf598504669524a9f7002f6b6c1cb4e567ea4e9e Mon Sep 17 00:00:00 2001
From: David Carlier <devnexen@gmail.com>
Date: Tue, 9 Mar 2021 19:13:37 +0000
Subject: [PATCH 1005/2400] crypto/rand: supports for getrandom syscall in
 DragonFlyBSD

Since the 5.7 release, DragonFlyBSD supports as well
the getrandom function, the actual stable is 5.8.

Change-Id: I2b8fc468771b10ac12b38ea7e8e5314342de6375
GitHub-Last-Rev: c5c496f41898d58f2c6f3ccc81f754792f49edbe
GitHub-Pull-Request: golang/go#42617
Reviewed-on: https://go-review.googlesource.com/c/go/+/269999
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Trust: Ian Lance Taylor <iant@golang.org>
Trust: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/crypto/rand/rand_batched.go               |  4 +-
 src/crypto/rand/rand_batched_test.go          |  4 +-
 src/crypto/rand/rand_dragonfly.go             |  9 ++++
 .../syscall/unix/getrandom_dragonfly.go       | 51 +++++++++++++++++++
 4 files changed, 64 insertions(+), 4 deletions(-)
 create mode 100644 src/crypto/rand/rand_dragonfly.go
 create mode 100644 src/internal/syscall/unix/getrandom_dragonfly.go

diff --git a/src/crypto/rand/rand_batched.go b/src/crypto/rand/rand_batched.go
index 45e9351a31..538769a868 100644
--- a/src/crypto/rand/rand_batched.go
+++ b/src/crypto/rand/rand_batched.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build linux || freebsd
-// +build linux freebsd
+//go:build linux || freebsd || dragonfly
+// +build linux freebsd dragonfly
 
 package rand
 
diff --git a/src/crypto/rand/rand_batched_test.go b/src/crypto/rand/rand_batched_test.go
index fd50735c7d..814f15201a 100644
--- a/src/crypto/rand/rand_batched_test.go
+++ b/src/crypto/rand/rand_batched_test.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build linux || freebsd
-// +build linux freebsd
+//go:build linux || freebsd || dragonfly
+// +build linux freebsd dragonfly
 
 package rand
 
diff --git a/src/crypto/rand/rand_dragonfly.go b/src/crypto/rand/rand_dragonfly.go
new file mode 100644
index 0000000000..8a36fea6cd
--- /dev/null
+++ b/src/crypto/rand/rand_dragonfly.go
@@ -0,0 +1,9 @@
+// Copyright 2021 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 rand
+
+// maxGetRandomRead is the maximum number of bytes to ask for in one call to the
+// getrandom() syscall. In DragonFlyBSD at most 256 bytes will be returned per call.
+const maxGetRandomRead = 1 << 8
diff --git a/src/internal/syscall/unix/getrandom_dragonfly.go b/src/internal/syscall/unix/getrandom_dragonfly.go
new file mode 100644
index 0000000000..b345b4c00c
--- /dev/null
+++ b/src/internal/syscall/unix/getrandom_dragonfly.go
@@ -0,0 +1,51 @@
+// Copyright 2021 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 unix
+
+import (
+	"sync/atomic"
+	"syscall"
+	"unsafe"
+)
+
+var randomUnsupported int32 // atomic
+
+// DragonFlyBSD getrandom system call number.
+const randomTrap uintptr = 550
+
+// GetRandomFlag is a flag supported by the getrandom system call.
+type GetRandomFlag uintptr
+
+const (
+	// GRND_RANDOM is only set for portability purpose, no-op on DragonFlyBSD.
+	GRND_RANDOM GetRandomFlag = 0x0001
+
+	// GRND_NONBLOCK means return EAGAIN rather than blocking.
+	GRND_NONBLOCK GetRandomFlag = 0x0002
+
+	// GRND_INSECURE is an GRND_NONBLOCK alias
+	GRND_INSECURE GetRandomFlag = 0x0004
+)
+
+// GetRandom calls the DragonFlyBSD getrandom system call.
+func GetRandom(p []byte, flags GetRandomFlag) (n int, err error) {
+	if len(p) == 0 {
+		return 0, nil
+	}
+	if atomic.LoadInt32(&randomUnsupported) != 0 {
+		return 0, syscall.ENOSYS
+	}
+	r1, _, errno := syscall.Syscall(randomTrap,
+		uintptr(unsafe.Pointer(&p[0])),
+		uintptr(len(p)),
+		uintptr(flags))
+	if errno != 0 {
+		if errno == syscall.ENOSYS {
+			atomic.StoreInt32(&randomUnsupported, 1)
+		}
+		return 0, errno
+	}
+	return int(r1), nil
+}
-- 
GitLab


From 30c28bbf0507cba9219633192e02b68719ab8280 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Tue, 9 Mar 2021 23:31:41 -0500
Subject: [PATCH 1006/2400] cmd/go: avoid password prompts in
 TestScript/mod_get_private_vcs

In some cases, this test would prompt for interactive SSH passwords in
order to authenticate to github.com over SSH. Setting GIT_SSH_COMMAND
to /bin/false prevents that, while still provoking the desired Git
failure mode.

Updates #44904.

Change-Id: Idc9fe9f47d2ccb6c8a4ea988b73d9c8c774e4079
Reviewed-on: https://go-review.googlesource.com/c/go/+/300156
Trust: Bryan C. Mills <bcmills@google.com>
Trust: Kevin Burke <kev@inburke.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Kevin Burke <kev@inburke.com>
---
 src/cmd/go/testdata/script/mod_get_private_vcs.txt | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/cmd/go/testdata/script/mod_get_private_vcs.txt b/src/cmd/go/testdata/script/mod_get_private_vcs.txt
index 8b01eac62c..75c776a7fa 100644
--- a/src/cmd/go/testdata/script/mod_get_private_vcs.txt
+++ b/src/cmd/go/testdata/script/mod_get_private_vcs.txt
@@ -22,7 +22,8 @@ stderr '^If this is a private repository, see https://golang.org/doc/faq#git_htt
 ! stderr 'unknown revision'
 ! stdout .
 
-[!linux] stop
+[!linux] stop  # Needs XDG_CONFIG_HOME.
+[!exec:false] stop
 
 # Test that Git clone errors will be shown to the user instead of a generic
 # "unknown revision" error. To do this we want to force git ls-remote to return
@@ -31,6 +32,7 @@ stderr '^If this is a private repository, see https://golang.org/doc/faq#git_htt
 # Set XDG_CONFIG_HOME to tell Git where to look for the git config file listed
 # below, which turns on ssh.
 env XDG_CONFIG_HOME=$TMPDIR
+env GIT_SSH_COMMAND=false
 ! go install github.com/golang/nonexist@master
 stderr 'fatal: Could not read from remote repository.'
 ! stderr 'unknown revision'
-- 
GitLab


From bc489dd6d5e8fdb6089b41b21e2cca1151a8a691 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 9 Mar 2021 22:58:55 -0500
Subject: [PATCH 1007/2400] runtime: update signature of reflectcall functions

reflectcall tail calls runtime.call{16,32,...} functions, so they
have the same signature as reflectcall. It is important for them
to have the correct arg map, because those functions, as well as
the function being reflectcall'd, could move the stack. When that
happens, its pointer arguments, in particular regArgs, need to be
adjusted. Otherwise it will still point to the old stack, causing
memory corruption.

This only caused failures on the regabi builder because it is the
only place where internal/abi.RegArgs is not a zero-sized type.

May fix #44821.

Change-Id: Iab400ea6b60c52360d0b43a793f6bfe50ca9989b
Reviewed-on: https://go-review.googlesource.com/c/go/+/300154
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/stubs.go | 55 ++++++++++++++++++++++----------------------
 1 file changed, 28 insertions(+), 27 deletions(-)

diff --git a/src/runtime/stubs.go b/src/runtime/stubs.go
index b9b313a711..5011d7199e 100644
--- a/src/runtime/stubs.go
+++ b/src/runtime/stubs.go
@@ -318,33 +318,34 @@ func return0()
 
 // in asm_*.s
 // not called directly; definitions here supply type information for traceback.
-func call16(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call32(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call64(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call128(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call256(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call512(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call1024(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call2048(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call4096(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call8192(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call16384(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call32768(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call65536(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call131072(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call262144(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call524288(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call1048576(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call2097152(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call4194304(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call8388608(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call16777216(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call33554432(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call67108864(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call134217728(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call268435456(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call536870912(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
-func call1073741824(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
+// These must have the same signature (arg pointer map) as reflectcall.
+func call16(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call32(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call64(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call128(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call256(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call512(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call1024(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call2048(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call4096(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call8192(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call16384(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call32768(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call65536(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call131072(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call262144(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call524288(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call1048576(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call2097152(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call4194304(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call8388608(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call16777216(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call33554432(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call67108864(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call134217728(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call268435456(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call536870912(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
+func call1073741824(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
 
 func systemstack_switch()
 
-- 
GitLab


From 818f6b14b496d718c0f8e49c9ef4c06cc45cc0d4 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Mon, 8 Mar 2021 15:19:47 -0500
Subject: [PATCH 1008/2400] cmd/compile: remove ".fp" fake arg

No longer needed with previous CLs.

Change-Id: I9a1c11092a2736c190fa8e8ddfbb913b708957eb
Reviewed-on: https://go-review.googlesource.com/c/go/+/300155
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/ssagen/ssa.go | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index cc79c07af7..f1f244cce6 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -545,13 +545,7 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 	for _, n := range fn.Dcl {
 		if n.Class == ir.PPARAM {
 			if s.canSSA(n) {
-				var v *ssa.Value
-				if n.Sym().Name == ".fp" {
-					// Race-detector's get-caller-pc incantation is NOT a real Arg.
-					v = s.newValue0(ssa.OpGetCallerPC, n.Type())
-				} else {
-					v = s.newValue0A(ssa.OpArg, n.Type(), n)
-				}
+				v := s.newValue0A(ssa.OpArg, n.Type(), n)
 				s.vars[n] = v
 				s.addNamedValue(n, v) // This helps with debugging information, not needed for compilation itself.
 			} else { // address was taken AND/OR too large for SSA
-- 
GitLab


From 74574623039f2369b3e4b3d717285a48c47b73c4 Mon Sep 17 00:00:00 2001
From: Michael Pratt <mpratt@google.com>
Date: Wed, 10 Mar 2021 11:41:04 -0500
Subject: [PATCH 1009/2400] runtime/race: update dead link

LLVM changed their main branch name, so this link didn't work anymore.

Change-Id: I4c3a67b26e2bda012071281e29ea3c932c185130
Reviewed-on: https://go-review.googlesource.com/c/go/+/300469
Trust: Michael Pratt <mpratt@google.com>
Run-TryBot: Michael Pratt <mpratt@google.com>
Reviewed-by: Dmitry Vyukov <dvyukov@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/race/README | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/race/README b/src/runtime/race/README
index dbff42dc8a..3b188a0361 100644
--- a/src/runtime/race/README
+++ b/src/runtime/race/README
@@ -1,6 +1,6 @@
 runtime/race package contains the data race detector runtime library.
 It is based on ThreadSanitizer race detector, that is currently a part of
-the LLVM project (https://github.com/llvm/llvm-project/tree/master/compiler-rt).
+the LLVM project (https://github.com/llvm/llvm-project/tree/main/compiler-rt).
 
 To update the .syso files use golang.org/x/build/cmd/racebuild.
 
-- 
GitLab


From 489231111f2ef097e99b150232cc0c5323c9729e Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 10 Mar 2021 11:30:24 -0500
Subject: [PATCH 1010/2400] go/types: add missing build tag to
 api_go1.18_test.go

This file has a go:build comment without a corresponding +build comment.

Change-Id: Id01604242a14d8ead16ffb9aa1b45eef7706956a
Reviewed-on: https://go-review.googlesource.com/c/go/+/300450
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/api_go1.18_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/go/types/api_go1.18_test.go b/src/go/types/api_go1.18_test.go
index bbbf70581d..e60fe23201 100644
--- a/src/go/types/api_go1.18_test.go
+++ b/src/go/types/api_go1.18_test.go
@@ -3,6 +3,7 @@
 // license that can be found in the LICENSE file.
 
 //go:build go1.18
+// +build go1.18
 
 package types_test
 
-- 
GitLab


From 5edab39f490dd3cff7bf02101b2d37a90827fa6d Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 10 Mar 2021 11:33:23 -0500
Subject: [PATCH 1011/2400] cmd/gofmt: fix const association to avoid
 inaccurate comment

The const parseTypeParams was grouped with printer-related consts in
gofmt.go, implicitly suggesting that it must be kept in sync with
go/format/format.go.

Change-Id: Ia65dc15c27fef2c389f963071252adee32ec6bd6
Reviewed-on: https://go-review.googlesource.com/c/go/+/300451
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/gofmt/gofmt.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/cmd/gofmt/gofmt.go b/src/cmd/gofmt/gofmt.go
index 95f537d91e..cd867bba15 100644
--- a/src/cmd/gofmt/gofmt.go
+++ b/src/cmd/gofmt/gofmt.go
@@ -51,12 +51,12 @@ const (
 	//
 	// This value is defined in go/printer specifically for go/format and cmd/gofmt.
 	printerNormalizeNumbers = 1 << 30
-
-	// parseTypeParams tells go/parser to parse type parameters. Must be kept in
-	// sync with go/parser/interface.go.
-	parseTypeParams parser.Mode = 1 << 30
 )
 
+// parseTypeParams tells go/parser to parse type parameters. Must be kept in
+// sync with go/parser/interface.go.
+const parseTypeParams parser.Mode = 1 << 30
+
 var (
 	fileSet    = token.NewFileSet() // per process FileSet
 	exitCode   = 0
-- 
GitLab


From 1811aeae66bee899317403c92c83b56673919775 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Fri, 5 Mar 2021 22:07:56 -0800
Subject: [PATCH 1012/2400] cmd/compile:  deal with helper generic types that
 add methods to T

Deal with cases like: 'type P[T any] T' (used to add methods to an
arbitrary type T), In this case, P[T] has kind types.TTYPEPARAM (as does
T itself), but requires more code to substitute than a simple TTYPEPARAM
T. See the comment near the beginning of subster.typ() in stencil.go.

Add new test absdiff.go. This test has a case for complex types (which
I've commented out) that will only work when we deal better with Go
builtins in generic functions (like real and imag).

Remove change in fmt.go for TTYPEPARAMS that is no longer needed (since
all TTYPEPARAMS have a sym) and was sometimes causing an extra prefix
when formatting method names.

Separate out the setting of a TTYPEPARAM bound, since it can reference
the TTYPEPARAM being defined, so must be done separately. Also, we don't
currently (and may not ever) need bounds after types2 typechecking.

Change-Id: Id173057e0c4563b309b95e665e9c1151ead4ba77
Reviewed-on: https://go-review.googlesource.com/c/go/+/300049
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/stencil.go | 29 ++++++-
 src/cmd/compile/internal/noder/types.go   |  9 ++-
 src/cmd/compile/internal/types/fmt.go     |  2 +-
 src/cmd/compile/internal/types/type.go    |  7 +-
 test/typeparam/absdiff.go                 | 99 +++++++++++++++++++++++
 5 files changed, 138 insertions(+), 8 deletions(-)
 create mode 100644 test/typeparam/absdiff.go

diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 8001d6d398..071a2f44c2 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -553,7 +553,25 @@ func (subst *subster) typ(t *types.Type) *types.Type {
 				return subst.targs[i].Type()
 			}
 		}
-		return t
+		// If t is a simple typeparam T, then t has the name/symbol 'T'
+		// and t.Underlying() == t.
+		//
+		// However, consider the type definition: 'type P[T any] T'. We
+		// might use this definition so we can have a variant of type T
+		// that we can add new methods to. Suppose t is a reference to
+		// P[T]. t has the name 'P[T]', but its kind is TTYPEPARAM,
+		// because P[T] is defined as T. If we look at t.Underlying(), it
+		// is different, because the name of t.Underlying() is 'T' rather
+		// than 'P[T]'. But the kind of t.Underlying() is also TTYPEPARAM.
+		// In this case, we do the needed recursive substitution in the
+		// case statement below.
+		if t.Underlying() == t {
+			// t is a simple typeparam that didn't match anything in tparam
+			return t
+		}
+		// t is a more complex typeparam (e.g. P[T], as above, whose
+		// definition is just T).
+		assert(t.Sym() != nil)
 	}
 
 	var newsym *types.Sym
@@ -591,6 +609,15 @@ func (subst *subster) typ(t *types.Type) *types.Type {
 	var newt *types.Type
 
 	switch t.Kind() {
+	case types.TTYPEPARAM:
+		if t.Sym() == newsym {
+			// The substitution did not change the type.
+			return t
+		}
+		// Substitute the underlying typeparam (e.g. T in P[T], see
+		// the example describing type P[T] above).
+		newt = subst.typ(t.Underlying())
+		assert(newt != t)
 
 	case types.TARRAY:
 		elem := t.Elem()
diff --git a/src/cmd/compile/internal/noder/types.go b/src/cmd/compile/internal/noder/types.go
index dfcf55d9c8..96bf75d594 100644
--- a/src/cmd/compile/internal/noder/types.go
+++ b/src/cmd/compile/internal/noder/types.go
@@ -180,11 +180,18 @@ func (g *irgen) typ0(typ types2.Type) *types.Type {
 		return types.NewInterface(g.tpkg(typ), append(embeddeds, methods...))
 
 	case *types2.TypeParam:
-		tp := types.NewTypeParam(g.tpkg(typ), g.typ(typ.Bound()))
+		tp := types.NewTypeParam(g.tpkg(typ))
 		// Save the name of the type parameter in the sym of the type.
 		// Include the types2 subscript in the sym name
 		sym := g.pkg(typ.Obj().Pkg()).Lookup(types2.TypeString(typ, func(*types2.Package) string { return "" }))
 		tp.SetSym(sym)
+		// Set g.typs[typ] in case the bound methods reference typ.
+		g.typs[typ] = tp
+
+		// TODO(danscales): we don't currently need to use the bounds
+		// anywhere, so eventually we can probably remove.
+		bound := g.typ(typ.Bound())
+		*tp.Methods() = *bound.Methods()
 		return tp
 
 	case *types2.Tuple:
diff --git a/src/cmd/compile/internal/types/fmt.go b/src/cmd/compile/internal/types/fmt.go
index c59f62e302..e29c826bb7 100644
--- a/src/cmd/compile/internal/types/fmt.go
+++ b/src/cmd/compile/internal/types/fmt.go
@@ -318,7 +318,7 @@ func tconv2(b *bytes.Buffer, t *Type, verb rune, mode fmtMode, visited map[*Type
 	}
 
 	// Unless the 'L' flag was specified, if the type has a name, just print that name.
-	if verb != 'L' && t.Sym() != nil && t != Types[t.Kind()] && t.Kind() != TTYPEPARAM {
+	if verb != 'L' && t.Sym() != nil && t != Types[t.Kind()] {
 		switch mode {
 		case fmtTypeID, fmtTypeIDName:
 			if verb == 'S' {
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index d76d9b409f..ffaf755345 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -1742,12 +1742,9 @@ func NewInterface(pkg *Pkg, methods []*Field) *Type {
 	return t
 }
 
-// NewTypeParam returns a new type param with the given constraint (which may
-// not really be needed except for the type checker).
-func NewTypeParam(pkg *Pkg, constraint *Type) *Type {
+// NewTypeParam returns a new type param.
+func NewTypeParam(pkg *Pkg) *Type {
 	t := New(TTYPEPARAM)
-	constraint.wantEtype(TINTER)
-	t.methods = constraint.methods
 	t.Extra.(*Interface).pkg = pkg
 	t.SetHasTParam(true)
 	return t
diff --git a/test/typeparam/absdiff.go b/test/typeparam/absdiff.go
new file mode 100644
index 0000000000..5dd58f14f7
--- /dev/null
+++ b/test/typeparam/absdiff.go
@@ -0,0 +1,99 @@
+// run -gcflags=-G=3
+
+// Copyright 2020 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 (
+	"fmt"
+	//"math"
+)
+
+type Numeric interface {
+	type int, int8, int16, int32, int64,
+		uint, uint8, uint16, uint32, uint64, uintptr,
+		float32, float64,
+		complex64, complex128
+}
+
+// numericAbs matches numeric types with an Abs method.
+type numericAbs[T any] interface {
+	Numeric
+	Abs() T
+}
+
+// AbsDifference computes the absolute value of the difference of
+// a and b, where the absolute value is determined by the Abs method.
+func absDifference[T numericAbs[T]](a, b T) T {
+	d := a - b
+	return d.Abs()
+}
+
+// orderedNumeric matches numeric types that support the < operator.
+type orderedNumeric interface {
+	type int, int8, int16, int32, int64,
+		uint, uint8, uint16, uint32, uint64, uintptr,
+		float32, float64
+}
+
+// Complex matches the two complex types, which do not have a < operator.
+type Complex interface {
+	type complex64, complex128
+}
+
+// orderedAbs is a helper type that defines an Abs method for
+// ordered numeric types.
+type orderedAbs[T orderedNumeric] T
+
+func (a orderedAbs[T]) Abs() orderedAbs[T] {
+	// TODO(danscales): orderedAbs[T] conversion shouldn't be needed
+	if a < orderedAbs[T](0) {
+		return -a
+	}
+	return a
+}
+
+// complexAbs is a helper type that defines an Abs method for
+// complex types.
+// type complexAbs[T Complex] T
+
+// func (a complexAbs[T]) Abs() complexAbs[T] {
+// 	r := float64(real(a))
+// 	i := float64(imag(a))
+// 	d := math.Sqrt(r * r + i * i)
+// 	return complexAbs[T](complex(d, 0))
+// }
+
+// OrderedAbsDifference returns the absolute value of the difference
+// between a and b, where a and b are of an ordered type.
+func orderedAbsDifference[T orderedNumeric](a, b T) T {
+	return T(absDifference(orderedAbs[T](a), orderedAbs[T](b)))
+}
+
+// ComplexAbsDifference returns the absolute value of the difference
+// between a and b, where a and b are of a complex type.
+// func complexAbsDifference[T Complex](a, b T) T {
+// 	return T(absDifference(complexAbs[T](a), complexAbs[T](b)))
+// }
+
+func main() {
+	if got, want := orderedAbsDifference(1.0, -2.0), 3.0; got != want {
+		panic(fmt.Sprintf("got = %v, want = %v", got, want))
+	}
+	if got, want := orderedAbsDifference(-1.0, 2.0), 3.0; got != want {
+		panic(fmt.Sprintf("got = %v, want = %v", got, want))
+	}
+	if got, want := orderedAbsDifference(-20, 15), 35; got != want {
+		panic(fmt.Sprintf("got = %v, want = %v", got, want))
+	}
+
+	// Still have to handle built-ins real/abs to make this work
+	// if got, want := complexAbsDifference(5.0 + 2.0i, 2.0 - 2.0i), 5; got != want {
+	//	panic(fmt.Sprintf("got = %v, want = %v", got, want)
+	// }
+	// if got, want := complexAbsDifference(2.0 - 2.0i, 5.0 + 2.0i), 5; got != want {
+	//	panic(fmt.Sprintf("got = %v, want = %v", got, want)
+	// }
+}
-- 
GitLab


From cd3b4ca9f20fd14187ed4cdfdee1a02ea87e5cd8 Mon Sep 17 00:00:00 2001
From: Roland Shoemaker <roland@golang.org>
Date: Tue, 2 Mar 2021 10:00:53 -0800
Subject: [PATCH 1013/2400] archive/zip: fix panic in Reader.Open

When operating on a Zip file that contains a file prefixed with "../",
Open(...) would cause a panic in toValidName when attempting to strip
the prefixed path components.

Fixes CVE-2021-27919
Fixes #44916

Change-Id: Ic755d8126cb0897e2cbbdacf572439c38dde7b35
Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1004761
Reviewed-by: Filippo Valsorda <valsorda@google.com>
Reviewed-by: Russ Cox <rsc@google.com>
Reviewed-by: Katie Hockman <katiehockman@google.com>
Reviewed-on: https://go-review.googlesource.com/c/go/+/300489
Trust: Katie Hockman <katie@golang.org>
Run-TryBot: Katie Hockman <katie@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Alexander Rakoczy <alex@golang.org>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
---
 src/archive/zip/reader.go      |  2 +-
 src/archive/zip/reader_test.go | 35 ++++++++++++++++++++++++++++++++++
 2 files changed, 36 insertions(+), 1 deletion(-)

diff --git a/src/archive/zip/reader.go b/src/archive/zip/reader.go
index 8b4e77875f..c288ad965b 100644
--- a/src/archive/zip/reader.go
+++ b/src/archive/zip/reader.go
@@ -664,7 +664,7 @@ func toValidName(name string) string {
 	if strings.HasPrefix(p, "/") {
 		p = p[len("/"):]
 	}
-	for strings.HasPrefix(name, "../") {
+	for strings.HasPrefix(p, "../") {
 		p = p[len("../"):]
 	}
 	return p
diff --git a/src/archive/zip/reader_test.go b/src/archive/zip/reader_test.go
index 34e96f7da4..5faf1f49b5 100644
--- a/src/archive/zip/reader_test.go
+++ b/src/archive/zip/reader_test.go
@@ -1081,3 +1081,38 @@ func TestFS(t *testing.T) {
 		t.Fatal(err)
 	}
 }
+
+func TestCVE202127919(t *testing.T) {
+	// Archive containing only the file "../test.txt"
+	data := []byte{
+		0x50, 0x4b, 0x03, 0x04, 0x14, 0x00, 0x08, 0x00,
+		0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x2e, 0x2e,
+		0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x74, 0x78,
+		0x74, 0x0a, 0xc9, 0xc8, 0x2c, 0x56, 0xc8, 0x2c,
+		0x56, 0x48, 0x54, 0x28, 0x49, 0x2d, 0x2e, 0x51,
+		0x28, 0x49, 0xad, 0x28, 0x51, 0x48, 0xcb, 0xcc,
+		0x49, 0xd5, 0xe3, 0x02, 0x04, 0x00, 0x00, 0xff,
+		0xff, 0x50, 0x4b, 0x07, 0x08, 0xc0, 0xd7, 0xed,
+		0xc3, 0x20, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00,
+		0x00, 0x50, 0x4b, 0x01, 0x02, 0x14, 0x00, 0x14,
+		0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0xc0, 0xd7, 0xed, 0xc3, 0x20, 0x00, 0x00,
+		0x00, 0x1a, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e,
+		0x2e, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x74,
+		0x78, 0x74, 0x50, 0x4b, 0x05, 0x06, 0x00, 0x00,
+		0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x39, 0x00,
+		0x00, 0x00, 0x59, 0x00, 0x00, 0x00, 0x00, 0x00,
+	}
+	r, err := NewReader(bytes.NewReader([]byte(data)), int64(len(data)))
+	if err != nil {
+		t.Fatalf("Error reading the archive: %v", err)
+	}
+	_, err = r.Open("test.txt")
+	if err != nil {
+		t.Errorf("Error reading file: %v", err)
+	}
+}
-- 
GitLab


From d0b79e3513a29628f3599dc8860666b6eed75372 Mon Sep 17 00:00:00 2001
From: Katie Hockman <katie@golang.org>
Date: Mon, 1 Mar 2021 09:54:00 -0500
Subject: [PATCH 1014/2400] encoding/xml: prevent infinite loop while decoding

This change properly handles a TokenReader which
returns an EOF in the middle of an open XML
element.

Thanks to Sam Whited for reporting this.

Fixes CVE-2021-27918
Fixes #44913

Change-Id: Id02a3f3def4a1b415fa2d9a8e3b373eb6cb0f433
Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1004594
Reviewed-by: Russ Cox <rsc@google.com>
Reviewed-by: Roland Shoemaker <bracewell@google.com>
Reviewed-by: Filippo Valsorda <valsorda@google.com>
Reviewed-on: https://go-review.googlesource.com/c/go/+/300391
Trust: Katie Hockman <katie@golang.org>
Run-TryBot: Katie Hockman <katie@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Alexander Rakoczy <alex@golang.org>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
---
 src/encoding/xml/xml.go      |  19 ++++---
 src/encoding/xml/xml_test.go | 104 +++++++++++++++++++++++++++--------
 2 files changed, 92 insertions(+), 31 deletions(-)

diff --git a/src/encoding/xml/xml.go b/src/encoding/xml/xml.go
index adaf4daf19..6f9594d7ba 100644
--- a/src/encoding/xml/xml.go
+++ b/src/encoding/xml/xml.go
@@ -271,7 +271,7 @@ func NewTokenDecoder(t TokenReader) *Decoder {
 // it will return an error.
 //
 // Token implements XML name spaces as described by
-// https://www.w3.org/TR/REC-xml-names/.  Each of the
+// https://www.w3.org/TR/REC-xml-names/. Each of the
 // Name structures contained in the Token has the Space
 // set to the URL identifying its name space when known.
 // If Token encounters an unrecognized name space prefix,
@@ -285,16 +285,17 @@ func (d *Decoder) Token() (Token, error) {
 	if d.nextToken != nil {
 		t = d.nextToken
 		d.nextToken = nil
-	} else if t, err = d.rawToken(); err != nil {
-		switch {
-		case err == io.EOF && d.t != nil:
-			err = nil
-		case err == io.EOF && d.stk != nil && d.stk.kind != stkEOF:
-			err = d.syntaxError("unexpected EOF")
+	} else {
+		if t, err = d.rawToken(); t == nil && err != nil {
+			if err == io.EOF && d.stk != nil && d.stk.kind != stkEOF {
+				err = d.syntaxError("unexpected EOF")
+			}
+			return nil, err
 		}
-		return t, err
+		// We still have a token to process, so clear any
+		// errors (e.g. EOF) and proceed.
+		err = nil
 	}
-
 	if !d.Strict {
 		if t1, ok := d.autoClose(t); ok {
 			d.nextToken = t
diff --git a/src/encoding/xml/xml_test.go b/src/encoding/xml/xml_test.go
index efddca43e9..5672ebb375 100644
--- a/src/encoding/xml/xml_test.go
+++ b/src/encoding/xml/xml_test.go
@@ -33,30 +33,90 @@ func (t *toks) Token() (Token, error) {
 
 func TestDecodeEOF(t *testing.T) {
 	start := StartElement{Name: Name{Local: "test"}}
-	t.Run("EarlyEOF", func(t *testing.T) {
-		d := NewTokenDecoder(&toks{earlyEOF: true, t: []Token{
-			start,
-			start.End(),
-		}})
-		err := d.Decode(&struct {
-			XMLName Name `xml:"test"`
-		}{})
-		if err != nil {
-			t.Error(err)
+	tests := []struct {
+		name   string
+		tokens []Token
+		ok     bool
+	}{
+		{
+			name: "OK",
+			tokens: []Token{
+				start,
+				start.End(),
+			},
+			ok: true,
+		},
+		{
+			name: "Malformed",
+			tokens: []Token{
+				start,
+				StartElement{Name: Name{Local: "bad"}},
+				start.End(),
+			},
+			ok: false,
+		},
+	}
+	for _, tc := range tests {
+		for _, eof := range []bool{true, false} {
+			name := fmt.Sprintf("%s/earlyEOF=%v", tc.name, eof)
+			t.Run(name, func(t *testing.T) {
+				d := NewTokenDecoder(&toks{
+					earlyEOF: eof,
+					t:        tc.tokens,
+				})
+				err := d.Decode(&struct {
+					XMLName Name `xml:"test"`
+				}{})
+				if tc.ok && err != nil {
+					t.Fatalf("d.Decode: expected nil error, got %v", err)
+				}
+				if _, ok := err.(*SyntaxError); !tc.ok && !ok {
+					t.Errorf("d.Decode: expected syntax error, got %v", err)
+				}
+			})
 		}
-	})
-	t.Run("LateEOF", func(t *testing.T) {
-		d := NewTokenDecoder(&toks{t: []Token{
-			start,
-			start.End(),
-		}})
-		err := d.Decode(&struct {
-			XMLName Name `xml:"test"`
-		}{})
-		if err != nil {
-			t.Error(err)
+	}
+}
+
+type toksNil struct {
+	returnEOF bool
+	t         []Token
+}
+
+func (t *toksNil) Token() (Token, error) {
+	if len(t.t) == 0 {
+		if !t.returnEOF {
+			// Return nil, nil before returning an EOF. It's legal, but
+			// discouraged.
+			t.returnEOF = true
+			return nil, nil
 		}
-	})
+		return nil, io.EOF
+	}
+	var tok Token
+	tok, t.t = t.t[0], t.t[1:]
+	return tok, nil
+}
+
+func TestDecodeNilToken(t *testing.T) {
+	for _, strict := range []bool{true, false} {
+		name := fmt.Sprintf("Strict=%v", strict)
+		t.Run(name, func(t *testing.T) {
+			start := StartElement{Name: Name{Local: "test"}}
+			bad := StartElement{Name: Name{Local: "bad"}}
+			d := NewTokenDecoder(&toksNil{
+				// Malformed
+				t: []Token{start, bad, start.End()},
+			})
+			d.Strict = strict
+			err := d.Decode(&struct {
+				XMLName Name `xml:"test"`
+			}{})
+			if _, ok := err.(*SyntaxError); !ok {
+				t.Errorf("d.Decode: expected syntax error, got %v", err)
+			}
+		})
+	}
 }
 
 const testInput = `
-- 
GitLab


From 5ce51ea74177513b473e2da05d0e4e9b7affb3c4 Mon Sep 17 00:00:00 2001
From: KimMachineGun <geon0250@gmail.com>
Date: Wed, 10 Mar 2021 12:55:56 +0000
Subject: [PATCH 1015/2400] flag: panic if flag name begins with - or contains
 =

Fixes #41792

Change-Id: I9b4aae8a899e3c3ac9532d27932d275cfb1fab48
GitHub-Last-Rev: f06b1e17674bf77bdc2d3e798df4c4379748c8d2
GitHub-Pull-Request: golang/go#42737
Reviewed-on: https://go-review.googlesource.com/c/go/+/271788
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Rob Pike <r@golang.org>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Rob Pike <r@golang.org>
---
 src/flag/flag.go      | 24 +++++++++----
 src/flag/flag_test.go | 83 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 101 insertions(+), 6 deletions(-)

diff --git a/src/flag/flag.go b/src/flag/flag.go
index a8485f034f..f7598a6758 100644
--- a/src/flag/flag.go
+++ b/src/flag/flag.go
@@ -857,17 +857,23 @@ func Func(name, usage string, fn func(string) error) {
 // of strings by giving the slice the methods of Value; in particular, Set would
 // decompose the comma-separated string into the slice.
 func (f *FlagSet) Var(value Value, name string, usage string) {
+	// Flag must not begin "-" or contain "=".
+	if strings.HasPrefix(name, "-") {
+		panic(f.sprintf("flag %q begins with -", name))
+	} else if strings.Contains(name, "=") {
+		panic(f.sprintf("flag %q contains =", name))
+	}
+
 	// Remember the default value as a string; it won't change.
 	flag := &Flag{name, usage, value, value.String()}
 	_, alreadythere := f.formal[name]
 	if alreadythere {
 		var msg string
 		if f.name == "" {
-			msg = fmt.Sprintf("flag redefined: %s", name)
+			msg = f.sprintf("flag redefined: %s", name)
 		} else {
-			msg = fmt.Sprintf("%s flag redefined: %s", f.name, name)
+			msg = f.sprintf("%s flag redefined: %s", f.name, name)
 		}
-		fmt.Fprintln(f.Output(), msg)
 		panic(msg) // Happens only if flags are declared with identical names
 	}
 	if f.formal == nil {
@@ -886,13 +892,19 @@ func Var(value Value, name string, usage string) {
 	CommandLine.Var(value, name, usage)
 }
 
+// sprintf formats the message, prints it to output, and returns it.
+func (f *FlagSet) sprintf(format string, a ...interface{}) string {
+	msg := fmt.Sprintf(format, a...)
+	fmt.Fprintln(f.Output(), msg)
+	return msg
+}
+
 // failf prints to standard error a formatted error and usage message and
 // returns the error.
 func (f *FlagSet) failf(format string, a ...interface{}) error {
-	err := fmt.Errorf(format, a...)
-	fmt.Fprintln(f.Output(), err)
+	msg := f.sprintf(format, a...)
 	f.usage()
-	return err
+	return errors.New(msg)
 }
 
 // usage calls the Usage method for the flag set if one is specified,
diff --git a/src/flag/flag_test.go b/src/flag/flag_test.go
index 06cab79405..5835fcf22c 100644
--- a/src/flag/flag_test.go
+++ b/src/flag/flag_test.go
@@ -655,3 +655,86 @@ func TestExitCode(t *testing.T) {
 		}
 	}
 }
+
+func mustPanic(t *testing.T, testName string, expected string, f func()) {
+	t.Helper()
+	defer func() {
+		switch msg := recover().(type) {
+		case nil:
+			t.Errorf("%s\n: expected panic(%q), but did not panic", testName, expected)
+		case string:
+			if msg != expected {
+				t.Errorf("%s\n: expected panic(%q), but got panic(%q)", testName, expected, msg)
+			}
+		default:
+			t.Errorf("%s\n: expected panic(%q), but got panic(%T%v)", testName, expected, msg, msg)
+		}
+	}()
+	f()
+}
+
+func TestInvalidFlags(t *testing.T) {
+	tests := []struct {
+		flag     string
+		errorMsg string
+	}{
+		{
+			flag:     "-foo",
+			errorMsg: "flag \"-foo\" begins with -",
+		},
+		{
+			flag:     "foo=bar",
+			errorMsg: "flag \"foo=bar\" contains =",
+		},
+	}
+
+	for _, test := range tests {
+		testName := fmt.Sprintf("FlagSet.Var(&v, %q, \"\")", test.flag)
+
+		fs := NewFlagSet("", ContinueOnError)
+		buf := bytes.NewBuffer(nil)
+		fs.SetOutput(buf)
+
+		mustPanic(t, testName, test.errorMsg, func() {
+			var v flagVar
+			fs.Var(&v, test.flag, "")
+		})
+		if msg := test.errorMsg + "\n"; msg != buf.String() {
+			t.Errorf("%s\n: unexpected output: expected %q, bug got %q", testName, msg, buf)
+		}
+	}
+}
+
+func TestRedefinedFlags(t *testing.T) {
+	tests := []struct {
+		flagSetName string
+		errorMsg    string
+	}{
+		{
+			flagSetName: "",
+			errorMsg:    "flag redefined: foo",
+		},
+		{
+			flagSetName: "fs",
+			errorMsg:    "fs flag redefined: foo",
+		},
+	}
+
+	for _, test := range tests {
+		testName := fmt.Sprintf("flag redefined in FlagSet(%q)", test.flagSetName)
+
+		fs := NewFlagSet(test.flagSetName, ContinueOnError)
+		buf := bytes.NewBuffer(nil)
+		fs.SetOutput(buf)
+
+		var v flagVar
+		fs.Var(&v, "foo", "")
+
+		mustPanic(t, testName, test.errorMsg, func() {
+			fs.Var(&v, "foo", "")
+		})
+		if msg := test.errorMsg + "\n"; msg != buf.String() {
+			t.Errorf("%s\n: unexpected output: expected %q, bug got %q", testName, msg, buf)
+		}
+	}
+}
-- 
GitLab


From c41bf9ee81e26d0fc0aca858a3d96d96be29ccba Mon Sep 17 00:00:00 2001
From: Michael Pratt <mpratt@google.com>
Date: Tue, 9 Mar 2021 16:13:23 -0500
Subject: [PATCH 1016/2400] runtime: check partial lock ranking order

To ease readability we typically keep the partial order lists sorted by
rank. This isn't required for correctness, it just makes it (slightly)
easier to read the lists.

Currently we must notice out-of-order entries during code review, which
is an error-prone process.

Add a test to enforce ordering, and fix the errors that have crept in.
Most of the existing errors were misordered lockRankHchan or
lockRankPollDesc.

While we're here, I've moved the correctness check that the partial
ordering satisfies the total ordering from init to a test case. This
will allow us to catch these errors without even running
staticlockranking.

Change-Id: I9c11abe49ea26c556439822bb6a3183129600c3b
Reviewed-on: https://go-review.googlesource.com/c/go/+/300171
Trust: Michael Pratt <mpratt@google.com>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Michael Pratt <mpratt@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/runtime/export_test.go   |  8 +++++++
 src/runtime/lockrank.go      | 22 +++++++++----------
 src/runtime/lockrank_on.go   | 13 ------------
 src/runtime/lockrank_test.go | 41 ++++++++++++++++++++++++++++++++++++
 4 files changed, 60 insertions(+), 24 deletions(-)
 create mode 100644 src/runtime/lockrank_test.go

diff --git a/src/runtime/export_test.go b/src/runtime/export_test.go
index a48bb2636f..5a87024b8a 100644
--- a/src/runtime/export_test.go
+++ b/src/runtime/export_test.go
@@ -46,6 +46,14 @@ var NetpollGenericInit = netpollGenericInit
 var Memmove = memmove
 var MemclrNoHeapPointers = memclrNoHeapPointers
 
+var LockPartialOrder = lockPartialOrder
+
+type LockRank lockRank
+
+func (l LockRank) String() string {
+	return lockRank(l).String()
+}
+
 const PreemptMSupported = preemptMSupported
 
 type LFNode struct {
diff --git a/src/runtime/lockrank.go b/src/runtime/lockrank.go
index 5a908b470f..b600c2132b 100644
--- a/src/runtime/lockrank.go
+++ b/src/runtime/lockrank.go
@@ -204,7 +204,7 @@ var lockPartialOrder [][]lockRank = [][]lockRank{
 	lockRankDeadlock:      {lockRankDeadlock},
 	lockRankAllg:          {lockRankSysmon, lockRankSched},
 	lockRankAllp:          {lockRankSysmon, lockRankSched},
-	lockRankTimers:        {lockRankSysmon, lockRankScavenge, lockRankSched, lockRankAllp, lockRankPollDesc, lockRankTimers},
+	lockRankTimers:        {lockRankSysmon, lockRankScavenge, lockRankPollDesc, lockRankSched, lockRankAllp, lockRankTimers},
 	lockRankItab:          {},
 	lockRankReflectOffs:   {lockRankItab},
 	lockRankHchan:         {lockRankScavenge, lockRankSweep, lockRankHchan},
@@ -213,25 +213,25 @@ var lockPartialOrder [][]lockRank = [][]lockRank{
 	lockRankTraceBuf:      {lockRankSysmon, lockRankScavenge},
 	lockRankTraceStrings:  {lockRankTraceBuf},
 	lockRankMspanSpecial:  {lockRankSysmon, lockRankScavenge, lockRankAssistQueue, lockRankCpuprof, lockRankSweep, lockRankSched, lockRankAllg, lockRankAllp, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankHchan, lockRankNotifyList, lockRankTraceBuf, lockRankTraceStrings},
-	lockRankProf:          {lockRankSysmon, lockRankScavenge, lockRankAssistQueue, lockRankCpuprof, lockRankSweep, lockRankSched, lockRankAllg, lockRankAllp, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankNotifyList, lockRankTraceBuf, lockRankTraceStrings, lockRankHchan},
-	lockRankGcBitsArenas:  {lockRankSysmon, lockRankScavenge, lockRankAssistQueue, lockRankCpuprof, lockRankSched, lockRankAllg, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankNotifyList, lockRankTraceBuf, lockRankTraceStrings, lockRankHchan},
+	lockRankProf:          {lockRankSysmon, lockRankScavenge, lockRankAssistQueue, lockRankCpuprof, lockRankSweep, lockRankSched, lockRankAllg, lockRankAllp, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankHchan, lockRankNotifyList, lockRankTraceBuf, lockRankTraceStrings},
+	lockRankGcBitsArenas:  {lockRankSysmon, lockRankScavenge, lockRankAssistQueue, lockRankCpuprof, lockRankSched, lockRankAllg, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankHchan, lockRankNotifyList, lockRankTraceBuf, lockRankTraceStrings},
 	lockRankRoot:          {},
-	lockRankTrace:         {lockRankSysmon, lockRankScavenge, lockRankForcegc, lockRankAssistQueue, lockRankSched, lockRankHchan, lockRankTraceBuf, lockRankTraceStrings, lockRankRoot, lockRankSweep},
+	lockRankTrace:         {lockRankSysmon, lockRankScavenge, lockRankForcegc, lockRankAssistQueue, lockRankSweep, lockRankSched, lockRankHchan, lockRankTraceBuf, lockRankTraceStrings, lockRankRoot},
 	lockRankTraceStackTab: {lockRankScavenge, lockRankSweepWaiters, lockRankAssistQueue, lockRankSweep, lockRankSched, lockRankAllg, lockRankTimers, lockRankHchan, lockRankFin, lockRankNotifyList, lockRankTraceBuf, lockRankTraceStrings, lockRankRoot, lockRankTrace},
 	lockRankNetpollInit:   {lockRankTimers},
 
 	lockRankRwmutexW: {},
 	lockRankRwmutexR: {lockRankSysmon, lockRankRwmutexW},
 
-	lockRankSpanSetSpine: {lockRankSysmon, lockRankScavenge, lockRankForcegc, lockRankAssistQueue, lockRankCpuprof, lockRankSweep, lockRankPollDesc, lockRankSched, lockRankAllg, lockRankAllp, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankNotifyList, lockRankTraceBuf, lockRankTraceStrings, lockRankHchan},
-	lockRankGscan:        {lockRankSysmon, lockRankScavenge, lockRankForcegc, lockRankSweepWaiters, lockRankAssistQueue, lockRankCpuprof, lockRankSweep, lockRankPollDesc, lockRankSched, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankHchan, lockRankFin, lockRankTraceBuf, lockRankTraceStrings, lockRankRoot, lockRankNotifyList, lockRankProf, lockRankGcBitsArenas, lockRankTrace, lockRankTraceStackTab, lockRankNetpollInit, lockRankSpanSetSpine},
-	lockRankStackpool:    {lockRankSysmon, lockRankScavenge, lockRankSweepWaiters, lockRankAssistQueue, lockRankCpuprof, lockRankSweep, lockRankSched, lockRankPollDesc, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankHchan, lockRankFin, lockRankNotifyList, lockRankTraceBuf, lockRankTraceStrings, lockRankProf, lockRankGcBitsArenas, lockRankRoot, lockRankTrace, lockRankTraceStackTab, lockRankNetpollInit, lockRankRwmutexR, lockRankSpanSetSpine, lockRankGscan},
+	lockRankSpanSetSpine: {lockRankSysmon, lockRankScavenge, lockRankForcegc, lockRankAssistQueue, lockRankCpuprof, lockRankSweep, lockRankPollDesc, lockRankSched, lockRankAllg, lockRankAllp, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankHchan, lockRankNotifyList, lockRankTraceBuf, lockRankTraceStrings},
+	lockRankGscan:        {lockRankSysmon, lockRankScavenge, lockRankForcegc, lockRankSweepWaiters, lockRankAssistQueue, lockRankCpuprof, lockRankSweep, lockRankPollDesc, lockRankSched, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankHchan, lockRankFin, lockRankNotifyList, lockRankTraceBuf, lockRankTraceStrings, lockRankProf, lockRankGcBitsArenas, lockRankRoot, lockRankTrace, lockRankTraceStackTab, lockRankNetpollInit, lockRankSpanSetSpine},
+	lockRankStackpool:    {lockRankSysmon, lockRankScavenge, lockRankSweepWaiters, lockRankAssistQueue, lockRankCpuprof, lockRankSweep, lockRankPollDesc, lockRankSched, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankHchan, lockRankFin, lockRankNotifyList, lockRankTraceBuf, lockRankTraceStrings, lockRankProf, lockRankGcBitsArenas, lockRankRoot, lockRankTrace, lockRankTraceStackTab, lockRankNetpollInit, lockRankRwmutexR, lockRankSpanSetSpine, lockRankGscan},
 	lockRankStackLarge:   {lockRankSysmon, lockRankAssistQueue, lockRankSched, lockRankItab, lockRankHchan, lockRankProf, lockRankGcBitsArenas, lockRankRoot, lockRankSpanSetSpine, lockRankGscan},
 	lockRankDefer:        {},
-	lockRankSudog:        {lockRankNotifyList, lockRankHchan},
-	lockRankWbufSpans:    {lockRankSysmon, lockRankScavenge, lockRankSweepWaiters, lockRankAssistQueue, lockRankSweep, lockRankSched, lockRankAllg, lockRankPollDesc, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankHchan, lockRankFin, lockRankNotifyList, lockRankTraceStrings, lockRankMspanSpecial, lockRankProf, lockRankRoot, lockRankGscan, lockRankDefer, lockRankSudog},
-	lockRankMheap:        {lockRankSysmon, lockRankScavenge, lockRankSweepWaiters, lockRankAssistQueue, lockRankCpuprof, lockRankSweep, lockRankPollDesc, lockRankSched, lockRankAllg, lockRankAllp, lockRankFin, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankNotifyList, lockRankTraceBuf, lockRankTraceStrings, lockRankHchan, lockRankMspanSpecial, lockRankProf, lockRankGcBitsArenas, lockRankRoot, lockRankGscan, lockRankStackpool, lockRankStackLarge, lockRankDefer, lockRankSudog, lockRankWbufSpans, lockRankSpanSetSpine},
-	lockRankMheapSpecial: {lockRankSysmon, lockRankScavenge, lockRankAssistQueue, lockRankCpuprof, lockRankSweep, lockRankPollDesc, lockRankSched, lockRankAllg, lockRankAllp, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankNotifyList, lockRankTraceBuf, lockRankTraceStrings, lockRankHchan},
+	lockRankSudog:        {lockRankHchan, lockRankNotifyList},
+	lockRankWbufSpans:    {lockRankSysmon, lockRankScavenge, lockRankSweepWaiters, lockRankAssistQueue, lockRankSweep, lockRankPollDesc, lockRankSched, lockRankAllg, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankHchan, lockRankFin, lockRankNotifyList, lockRankTraceStrings, lockRankMspanSpecial, lockRankProf, lockRankRoot, lockRankGscan, lockRankDefer, lockRankSudog},
+	lockRankMheap:        {lockRankSysmon, lockRankScavenge, lockRankSweepWaiters, lockRankAssistQueue, lockRankCpuprof, lockRankSweep, lockRankPollDesc, lockRankSched, lockRankAllg, lockRankAllp, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankHchan, lockRankFin, lockRankNotifyList, lockRankTraceBuf, lockRankTraceStrings, lockRankMspanSpecial, lockRankProf, lockRankGcBitsArenas, lockRankRoot, lockRankSpanSetSpine, lockRankGscan, lockRankStackpool, lockRankStackLarge, lockRankDefer, lockRankSudog, lockRankWbufSpans},
+	lockRankMheapSpecial: {lockRankSysmon, lockRankScavenge, lockRankAssistQueue, lockRankCpuprof, lockRankSweep, lockRankPollDesc, lockRankSched, lockRankAllg, lockRankAllp, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankHchan, lockRankNotifyList, lockRankTraceBuf, lockRankTraceStrings},
 	lockRankGlobalAlloc:  {lockRankProf, lockRankSpanSetSpine, lockRankMheap, lockRankMheapSpecial},
 
 	lockRankGFree:     {lockRankSched},
diff --git a/src/runtime/lockrank_on.go b/src/runtime/lockrank_on.go
index 3958d9eeaa..fc8d2dc8d1 100644
--- a/src/runtime/lockrank_on.go
+++ b/src/runtime/lockrank_on.go
@@ -25,19 +25,6 @@ type lockRankStruct struct {
 	pad int
 }
 
-// init checks that the partial order in lockPartialOrder fits within the total
-// order determined by the order of the lockRank constants.
-func init() {
-	for rank, list := range lockPartialOrder {
-		for _, entry := range list {
-			if entry > lockRank(rank) {
-				println("lockPartial order row", lockRank(rank).String(), "entry", entry.String())
-				throw("lockPartialOrder table is inconsistent with total lock ranking order")
-			}
-		}
-	}
-}
-
 func lockInit(l *mutex, rank lockRank) {
 	l.rank = rank
 }
diff --git a/src/runtime/lockrank_test.go b/src/runtime/lockrank_test.go
new file mode 100644
index 0000000000..4b2fc0eaee
--- /dev/null
+++ b/src/runtime/lockrank_test.go
@@ -0,0 +1,41 @@
+// Copyright 2021 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 runtime_test
+
+import (
+	. "runtime"
+	"testing"
+)
+
+// Check that the partial order in lockPartialOrder fits within the total order
+// determined by the order of the lockRank constants.
+func TestLockRankPartialOrder(t *testing.T) {
+	for r, list := range LockPartialOrder {
+		rank := LockRank(r)
+		for _, e := range list {
+			entry := LockRank(e)
+			if entry > rank {
+				t.Errorf("lockPartialOrder row %v entry %v is inconsistent with total lock ranking order", rank, entry)
+			}
+		}
+	}
+}
+
+// Verify that partial order lists are kept sorted. This is a purely cosemetic
+// check to make manual reviews simpler. It does not affect correctness, unlike
+// the above test.
+func TestLockRankPartialOrderSortedEntries(t *testing.T) {
+	for r, list := range LockPartialOrder {
+		rank := LockRank(r)
+		var prev LockRank
+		for _, e := range list {
+			entry := LockRank(e)
+			if entry <= prev {
+				t.Errorf("Partial order for rank %v out of order: %v <= %v in %v", rank, entry, prev, list)
+			}
+			prev = entry
+		}
+	}
+}
-- 
GitLab


From ccf9acefa8b61fb58daad233a6e0478d092d55ef Mon Sep 17 00:00:00 2001
From: Lynn Boger <laboger@linux.vnet.ibm.com>
Date: Mon, 8 Mar 2021 10:07:17 -0600
Subject: [PATCH 1017/2400] cmd/compile/internal: improve handling of DS form
 offsets on ppc64x

In the ppc64 ISA DS form loads and stores are restricted to offset
fields that are a multiple of 4. This is currently handled with checks
in the rules that generate MOVDload, MOVWload, MOVDstore and
MOVDstorezero to prevent invalid instructions from getting to the
assembler.

An unhandled case was discovered which led to the search for a better
solution to this problem. Now, instead of checking the offset in the
rules, this will be detected when processing these Ops in
ssaGenValues in ppc64/ssa.go. If the offset is not valid, the address
of the symbol to be loaded or stored will be computed using the base
register + offset, and that value used in the new base register.
With the full address in the base register, the offset field can be
zero in the instruction.

Updates #44739

Change-Id: I4f3c0c469ae70a63e3add295c9b55ea0e30ef9b3
Reviewed-on: https://go-review.googlesource.com/c/go/+/299789
Trust: Lynn Boger <laboger@linux.vnet.ibm.com>
Run-TryBot: Lynn Boger <laboger@linux.vnet.ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ppc64/ssa.go        | 124 ++++++++++++++-----
 src/cmd/compile/internal/ssa/gen/PPC64.rules |  48 +++----
 src/cmd/compile/internal/ssa/rewritePPC64.go | 107 +++-------------
 test/fixedbugs/issue44739.go                 |  61 +++++++++
 4 files changed, 192 insertions(+), 148 deletions(-)
 create mode 100644 test/fixedbugs/issue44739.go

diff --git a/src/cmd/compile/internal/ppc64/ssa.go b/src/cmd/compile/internal/ppc64/ssa.go
index 2bae35bf44..899f5ee6af 100644
--- a/src/cmd/compile/internal/ppc64/ssa.go
+++ b/src/cmd/compile/internal/ppc64/ssa.go
@@ -798,42 +798,63 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Reg = v.Reg()
 		p.To.Type = obj.TYPE_REG
 
-	case ssa.OpPPC64MOVDload:
-
-		// MOVDload uses a DS instruction which requires the offset value of the data to be a multiple of 4.
-		// For offsets known at compile time, a MOVDload won't be selected, but in the case of a go.string,
-		// the offset is not known until link time. If the load of a go.string uses relocation for the
-		// offset field of the instruction, and if the offset is not aligned to 4, then a link error will occur.
-		// To avoid this problem, the full address of the go.string is computed and loaded into the base register,
-		// and that base register is used for the MOVDload using a 0 offset. This problem can only occur with
-		// go.string types because other types will have proper alignment.
-
-		gostring := false
-		switch n := v.Aux.(type) {
-		case *obj.LSym:
-			gostring = strings.HasPrefix(n.Name, "go.string.")
+	case ssa.OpPPC64MOVDload, ssa.OpPPC64MOVWload:
+
+		// MOVDload and MOVWload are DS form instructions that are restricted to
+		// offsets that are a multiple of 4. If the offset is not a multple of 4,
+		// then the address of the symbol to be loaded is computed (base + offset)
+		// and used as the new base register and the offset field in the instruction
+		// can be set to zero.
+
+		// This same problem can happen with gostrings since the final offset is not
+		// known yet, but could be unaligned after the relocation is resolved.
+		// So gostrings are handled the same way.
+
+		// This allows the MOVDload and MOVWload to be generated in more cases and
+		// eliminates some offset and alignment checking in the rules file.
+
+		fromAddr := obj.Addr{Type: obj.TYPE_MEM, Reg: v.Args[0].Reg()}
+		ssagen.AddAux(&fromAddr, v)
+
+		genAddr := false
+
+		switch fromAddr.Name {
+		case obj.NAME_EXTERN, obj.NAME_STATIC:
+			// Special case for a rule combines the bytes of gostring.
+			// The v alignment might seem OK, but we don't want to load it
+			// using an offset because relocation comes later.
+			genAddr = strings.HasPrefix(fromAddr.Sym.Name, "go.string") || v.Type.Alignment()%4 != 0 || fromAddr.Offset%4 != 0
+		default:
+			genAddr = fromAddr.Offset%4 != 0
 		}
-		if gostring {
-			// Generate full addr of the go.string const
-			// including AuxInt
+		if genAddr {
+			// Load full address into the temp register.
 			p := s.Prog(ppc64.AMOVD)
 			p.From.Type = obj.TYPE_ADDR
 			p.From.Reg = v.Args[0].Reg()
 			ssagen.AddAux(&p.From, v)
+			// Load target using temp as base register
+			// and offset zero. Setting NAME_NONE
+			// prevents any extra offsets from being
+			// added.
 			p.To.Type = obj.TYPE_REG
-			p.To.Reg = v.Reg()
-			// Load go.string using 0 offset
-			p = s.Prog(v.Op.Asm())
-			p.From.Type = obj.TYPE_MEM
-			p.From.Reg = v.Reg()
-			p.To.Type = obj.TYPE_REG
-			p.To.Reg = v.Reg()
-			break
+			p.To.Reg = ppc64.REGTMP
+			fromAddr.Reg = ppc64.REGTMP
+			// Clear the offset field and other
+			// information that might be used
+			// by the assembler to add to the
+			// final offset value.
+			fromAddr.Offset = 0
+			fromAddr.Name = obj.NAME_NONE
+			fromAddr.Sym = nil
 		}
-		// Not a go.string, generate a normal load
-		fallthrough
+		p := s.Prog(v.Op.Asm())
+		p.From = fromAddr
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = v.Reg()
+		break
 
-	case ssa.OpPPC64MOVWload, ssa.OpPPC64MOVHload, ssa.OpPPC64MOVWZload, ssa.OpPPC64MOVBZload, ssa.OpPPC64MOVHZload, ssa.OpPPC64FMOVDload, ssa.OpPPC64FMOVSload:
+	case ssa.OpPPC64MOVHload, ssa.OpPPC64MOVWZload, ssa.OpPPC64MOVBZload, ssa.OpPPC64MOVHZload, ssa.OpPPC64FMOVDload, ssa.OpPPC64FMOVSload:
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = v.Args[0].Reg()
@@ -865,7 +886,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 
-	case ssa.OpPPC64MOVDstorezero, ssa.OpPPC64MOVWstorezero, ssa.OpPPC64MOVHstorezero, ssa.OpPPC64MOVBstorezero:
+	case ssa.OpPPC64MOVWstorezero, ssa.OpPPC64MOVHstorezero, ssa.OpPPC64MOVBstorezero:
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = ppc64.REGZERO
@@ -873,7 +894,46 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Reg = v.Args[0].Reg()
 		ssagen.AddAux(&p.To, v)
 
-	case ssa.OpPPC64MOVDstore, ssa.OpPPC64MOVWstore, ssa.OpPPC64MOVHstore, ssa.OpPPC64MOVBstore, ssa.OpPPC64FMOVDstore, ssa.OpPPC64FMOVSstore:
+	case ssa.OpPPC64MOVDstore, ssa.OpPPC64MOVDstorezero:
+
+		// MOVDstore and MOVDstorezero become DS form instructions that are restricted
+		// to offset values that are a multple of 4. If the offset field is not a
+		// multiple of 4, then the full address of the store target is computed (base +
+		// offset) and used as the new base register and the offset in the instruction
+		// is set to 0.
+
+		// This allows the MOVDstore and MOVDstorezero to be generated in more cases,
+		// and prevents checking of the offset value and alignment in the rules.
+
+		toAddr := obj.Addr{Type: obj.TYPE_MEM, Reg: v.Args[0].Reg()}
+		ssagen.AddAux(&toAddr, v)
+
+		if toAddr.Offset%4 != 0 {
+			p := s.Prog(ppc64.AMOVD)
+			p.From.Type = obj.TYPE_ADDR
+			p.From.Reg = v.Args[0].Reg()
+			ssagen.AddAux(&p.From, v)
+			p.To.Type = obj.TYPE_REG
+			p.To.Reg = ppc64.REGTMP
+			toAddr.Reg = ppc64.REGTMP
+			// Clear the offset field and other
+			// information that might be used
+			// by the assembler to add to the
+			// final offset value.
+			toAddr.Offset = 0
+			toAddr.Name = obj.NAME_NONE
+			toAddr.Sym = nil
+		}
+		p := s.Prog(v.Op.Asm())
+		p.To = toAddr
+		p.From.Type = obj.TYPE_REG
+		if v.Op == ssa.OpPPC64MOVDstorezero {
+			p.From.Reg = ppc64.REGZERO
+		} else {
+			p.From.Reg = v.Args[1].Reg()
+		}
+
+	case ssa.OpPPC64MOVWstore, ssa.OpPPC64MOVHstore, ssa.OpPPC64MOVBstore, ssa.OpPPC64FMOVDstore, ssa.OpPPC64FMOVSstore:
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = v.Args[1].Reg()
@@ -1476,7 +1536,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 			case rem >= 8:
 				op, size = ppc64.AMOVD, 8
 			case rem >= 4:
-				op, size = ppc64.AMOVW, 4
+				op, size = ppc64.AMOVWZ, 4
 			case rem >= 2:
 				op, size = ppc64.AMOVH, 2
 			}
@@ -1743,7 +1803,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 			case rem >= 8:
 				op, size = ppc64.AMOVD, 8
 			case rem >= 4:
-				op, size = ppc64.AMOVW, 4
+				op, size = ppc64.AMOVWZ, 4
 			case rem >= 2:
 				op, size = ppc64.AMOVH, 2
 			}
diff --git a/src/cmd/compile/internal/ssa/gen/PPC64.rules b/src/cmd/compile/internal/ssa/gen/PPC64.rules
index 85ce9a5b54..b618cde529 100644
--- a/src/cmd/compile/internal/ssa/gen/PPC64.rules
+++ b/src/cmd/compile/internal/ssa/gen/PPC64.rules
@@ -607,24 +607,18 @@
 		(MOVHstorezero [4] destptr
 			(MOVWstorezero destptr mem)))
 
-// MOVD for store with DS must have offsets that are multiple of 4
-(Zero [8] {t} destptr mem) && t.Alignment()%4 == 0 =>
-        (MOVDstorezero destptr mem)
-(Zero [8] destptr mem) =>
-        (MOVWstorezero [4] destptr
-                (MOVWstorezero [0] destptr mem))
-// Handle these cases only if aligned properly, otherwise use general case below
-(Zero [12] {t} destptr mem) && t.Alignment()%4 == 0 =>
+(Zero [8] {t} destptr mem) => (MOVDstorezero destptr mem)
+(Zero [12] {t} destptr mem) =>
         (MOVWstorezero [8] destptr
                 (MOVDstorezero [0] destptr mem))
-(Zero [16] {t} destptr mem) && t.Alignment()%4 == 0 =>
+(Zero [16] {t} destptr mem) =>
        (MOVDstorezero [8] destptr
                 (MOVDstorezero [0] destptr mem))
-(Zero [24] {t} destptr mem) && t.Alignment()%4 == 0 =>
+(Zero [24] {t} destptr mem) =>
        (MOVDstorezero [16] destptr
                (MOVDstorezero [8] destptr
                        (MOVDstorezero [0] destptr mem)))
-(Zero [32] {t} destptr mem) && t.Alignment()%4 == 0 =>
+(Zero [32] {t} destptr mem) =>
        (MOVDstorezero [24] destptr
                (MOVDstorezero [16] destptr
                        (MOVDstorezero [8] destptr
@@ -639,9 +633,6 @@
 (Zero [s] ptr mem) && objabi.GOPPC64 >= 9 => (LoweredQuadZero [s] ptr mem)
 
 // moves
-// Only the MOVD and MOVW instructions require 4 byte
-// alignment in the offset field.  The other MOVx instructions
-// allow any alignment.
 (Move [0] _ _ mem) => mem
 (Move [1] dst src mem) => (MOVBstore dst (MOVBZload src mem) mem)
 (Move [2] dst src mem) =>
@@ -649,11 +640,8 @@
 (Move [4] dst src mem) =>
 	(MOVWstore dst (MOVWZload src mem) mem)
 // MOVD for load and store must have offsets that are multiple of 4
-(Move [8] {t} dst src mem) && t.Alignment()%4 == 0 =>
+(Move [8] {t} dst src mem) =>
 	(MOVDstore dst (MOVDload src mem) mem)
-(Move [8] dst src mem) =>
-	(MOVWstore [4] dst (MOVWZload [4] src mem)
-		(MOVWstore dst (MOVWZload src mem) mem))
 (Move [3] dst src mem) =>
         (MOVBstore [2] dst (MOVBZload [2] src mem)
                 (MOVHstore dst (MOVHload src mem) mem))
@@ -875,7 +863,7 @@
 (MFVSRD x:(FMOVDload [off] {sym} ptr mem)) && x.Uses == 1 && clobber(x) => @x.Block (MOVDload [off] {sym} ptr mem)
 
 // Fold offsets for stores.
-(MOVDstore [off1] {sym} (ADDconst [off2] x) val mem) && is16Bit(int64(off1)+off2) && (int64(off1)+off2)%4 == 0 => (MOVDstore [off1+int32(off2)] {sym} x val mem)
+(MOVDstore [off1] {sym} (ADDconst [off2] x) val mem) && is16Bit(int64(off1)+off2) => (MOVDstore [off1+int32(off2)] {sym} x val mem)
 (MOVWstore [off1] {sym} (ADDconst [off2] x) val mem) && is16Bit(int64(off1)+off2) => (MOVWstore [off1+int32(off2)] {sym} x val mem)
 (MOVHstore [off1] {sym} (ADDconst [off2] x) val mem) && is16Bit(int64(off1)+off2) => (MOVHstore [off1+int32(off2)] {sym} x val mem)
 (MOVBstore [off1] {sym} (ADDconst [off2] x) val mem) && is16Bit(int64(off1)+off2) => (MOVBstore [off1+int32(off2)] {sym} x val mem)
@@ -898,7 +886,7 @@
 	&& is16Bit(int64(off1+off2)) && (ptr.Op != OpSB || p.Uses == 1) =>
         (MOVWstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem)
 (MOVDstore [off1] {sym1} p:(MOVDaddr [off2] {sym2} ptr) val mem) && canMergeSym(sym1,sym2)
-	&& is16Bit(int64(off1+off2)) && (ptr.Op != OpSB || p.Uses == 1) && (off1+off2)%4 == 0 =>
+	&& is16Bit(int64(off1+off2)) && (ptr.Op != OpSB || p.Uses == 1) =>
         (MOVDstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem)
 
 (FMOVSstore [off1] {sym1} p:(MOVDaddr [off2] {sym2} ptr) val mem) && canMergeSym(sym1,sym2)
@@ -918,13 +906,13 @@
 	&& is16Bit(int64(off1+off2)) && (ptr.Op != OpSB || p.Uses == 1) =>
         (MOVHZload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
 (MOVWload [off1] {sym1} p:(MOVDaddr [off2] {sym2} ptr) mem) && canMergeSym(sym1,sym2)
-	&& is16Bit(int64(off1+off2)) && (ptr.Op != OpSB || p.Uses == 1) && (off1+off2)%4 == 0 =>
+	&& is16Bit(int64(off1+off2)) && (ptr.Op != OpSB || p.Uses == 1) =>
         (MOVWload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
 (MOVWZload [off1] {sym1} p:(MOVDaddr [off2] {sym2} ptr) mem) && canMergeSym(sym1,sym2)
 	&& is16Bit(int64(off1+off2)) && (ptr.Op != OpSB || p.Uses == 1) =>
         (MOVWZload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
 (MOVDload [off1] {sym1} p:(MOVDaddr [off2] {sym2} ptr) mem) && canMergeSym(sym1,sym2)
-	&& is16Bit(int64(off1+off2)) && (ptr.Op != OpSB || p.Uses == 1) && (off1+off2)%4 == 0 =>
+	&& is16Bit(int64(off1+off2)) && (ptr.Op != OpSB || p.Uses == 1) =>
         (MOVDload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
 (FMOVSload [off1] {sym1} p:(MOVDaddr [off2] {sym2} ptr) mem) && canMergeSym(sym1,sym2)
 	&& is16Bit(int64(off1+off2)) && (ptr.Op != OpSB || p.Uses == 1) =>
@@ -937,8 +925,8 @@
 (FMOVSload [off1] {sym} (ADDconst [off2] ptr) mem) && is16Bit(int64(off1)+off2) => (FMOVSload [off1+int32(off2)] {sym} ptr mem)
 (FMOVDload [off1] {sym} (ADDconst [off2] ptr) mem) && is16Bit(int64(off1)+off2) => (FMOVDload [off1+int32(off2)] {sym} ptr mem)
 
-(MOVDload [off1] {sym} (ADDconst [off2] x) mem) && is16Bit(int64(off1)+off2) && (int64(off1)+off2)%4 == 0 => (MOVDload [off1+int32(off2)] {sym} x mem)
-(MOVWload [off1] {sym} (ADDconst [off2] x) mem) && is16Bit(int64(off1)+off2) && (int64(off1)+off2)%4 == 0 => (MOVWload [off1+int32(off2)] {sym} x mem)
+(MOVDload [off1] {sym} (ADDconst [off2] x) mem) && is16Bit(int64(off1)+off2) => (MOVDload [off1+int32(off2)] {sym} x mem)
+(MOVWload [off1] {sym} (ADDconst [off2] x) mem) && is16Bit(int64(off1)+off2) => (MOVWload [off1+int32(off2)] {sym} x mem)
 (MOVWZload [off1] {sym} (ADDconst [off2] x) mem) && is16Bit(int64(off1)+off2) => (MOVWZload [off1+int32(off2)] {sym} x mem)
 (MOVHload [off1] {sym} (ADDconst [off2] x) mem) && is16Bit(int64(off1)+off2) => (MOVHload [off1+int32(off2)] {sym} x mem)
 (MOVHZload [off1] {sym} (ADDconst [off2] x) mem) && is16Bit(int64(off1)+off2) => (MOVHZload [off1+int32(off2)] {sym} x mem)
@@ -947,7 +935,10 @@
 // Determine load + addressing that can be done as a register indexed load
 (MOV(D|W|WZ|H|HZ|BZ)load [0] {sym} p:(ADD ptr idx) mem) && sym == nil && p.Uses == 1 => (MOV(D|W|WZ|H|HZ|BZ)loadidx ptr idx mem)
 
-// Determine indexed loads with constant values that can be done without index
+// Determine if there is benefit to using a non-indexed load, since that saves the load
+// of the index register. With MOVDload and MOVWload, there is no benefit if the offset
+// value is not a multiple of 4, since that results in an extra instruction in the base
+// register address computation.
 (MOV(D|W)loadidx ptr (MOVDconst [c]) mem) && is16Bit(c) && c%4 == 0 => (MOV(D|W)load [int32(c)] ptr mem)
 (MOV(WZ|H|HZ|BZ)loadidx ptr (MOVDconst [c]) mem) && is16Bit(c) => (MOV(WZ|H|HZ|BZ)load [int32(c)] ptr mem)
 (MOV(D|W)loadidx (MOVDconst [c]) ptr mem) && is16Bit(c) && c%4 == 0 => (MOV(D|W)load [int32(c)] ptr mem)
@@ -960,7 +951,7 @@
 (MOVBstore [off] {sym} ptr (MOVDconst [0]) mem) => (MOVBstorezero [off] {sym} ptr mem)
 
 // Fold offsets for storezero
-(MOVDstorezero [off1] {sym} (ADDconst [off2] x) mem) && is16Bit(int64(off1)+off2) && (int64(off1)+off2)%4 == 0 =>
+(MOVDstorezero [off1] {sym} (ADDconst [off2] x) mem) && is16Bit(int64(off1)+off2) =>
     (MOVDstorezero [off1+int32(off2)] {sym} x mem)
 (MOVWstorezero [off1] {sym} (ADDconst [off2] x) mem) && is16Bit(int64(off1)+off2) =>
     (MOVWstorezero [off1+int32(off2)] {sym} x mem)
@@ -973,6 +964,7 @@
 (MOV(D|W|H|B)store [0] {sym} p:(ADD ptr idx) val mem) && sym == nil && p.Uses == 1 => (MOV(D|W|H|B)storeidx ptr idx val mem)
 
 // Stores with constant index values can be done without indexed instructions
+// No need to lower the idx cases if c%4 is not 0
 (MOVDstoreidx ptr (MOVDconst [c]) val mem) && is16Bit(c) && c%4 == 0 => (MOVDstore [int32(c)] ptr val mem)
 (MOV(W|H|B)storeidx ptr (MOVDconst [c]) val mem) && is16Bit(c) => (MOV(W|H|B)store [int32(c)] ptr val mem)
 (MOVDstoreidx (MOVDconst [c]) ptr val mem) && is16Bit(c) && c%4 == 0 => (MOVDstore [int32(c)] ptr val mem)
@@ -980,7 +972,7 @@
 
 // Fold symbols into storezero
 (MOVDstorezero [off1] {sym1} p:(MOVDaddr [off2] {sym2} x) mem) && canMergeSym(sym1,sym2)
-	&& (x.Op != OpSB || p.Uses == 1) && (off1+off2)%4 == 0 =>
+	&& (x.Op != OpSB || p.Uses == 1) =>
     (MOVDstorezero [off1+off2] {mergeSym(sym1,sym2)} x mem)
 (MOVWstorezero [off1] {sym1} p:(MOVDaddr [off2] {sym2} x) mem) && canMergeSym(sym1,sym2)
 	&& (x.Op != OpSB || p.Uses == 1) =>
@@ -1294,7 +1286,6 @@
 	o3:(OR <t> s3:(SLDconst x4:(MOVBZload [i4] {s} p mem) [32])
 	x0:(MOVWZload {s} [i0] p mem)))))
 	&& !config.BigEndian
-	&& i0%4 == 0
 	&& i4 == i0+4
 	&& i5 == i0+5
 	&& i6 == i0+6
@@ -1431,7 +1422,6 @@
 	x2:(MOVBstore [i4] {s} p (SRDconst w [32])
 	x3:(MOVWstore [i0] {s} p w mem)))))
 	&& !config.BigEndian
-	&& i0%4 == 0
 	&& x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && x3.Uses == 1
 	&& i4 == i0+4 && i5 == i0+5 && i6 == i0+6 && i7 == i0+7
 	&& clobber(x0, x1, x2, x3)
diff --git a/src/cmd/compile/internal/ssa/rewritePPC64.go b/src/cmd/compile/internal/ssa/rewritePPC64.go
index 3357864291..a5bbc836cc 100644
--- a/src/cmd/compile/internal/ssa/rewritePPC64.go
+++ b/src/cmd/compile/internal/ssa/rewritePPC64.go
@@ -3528,46 +3528,20 @@ func rewriteValuePPC64_OpMove(v *Value) bool {
 		return true
 	}
 	// match: (Move [8] {t} dst src mem)
-	// cond: t.Alignment()%4 == 0
 	// result: (MOVDstore dst (MOVDload src mem) mem)
 	for {
 		if auxIntToInt64(v.AuxInt) != 8 {
 			break
 		}
-		t := auxToType(v.Aux)
 		dst := v_0
 		src := v_1
 		mem := v_2
-		if !(t.Alignment()%4 == 0) {
-			break
-		}
 		v.reset(OpPPC64MOVDstore)
 		v0 := b.NewValue0(v.Pos, OpPPC64MOVDload, typ.Int64)
 		v0.AddArg2(src, mem)
 		v.AddArg3(dst, v0, mem)
 		return true
 	}
-	// match: (Move [8] dst src mem)
-	// result: (MOVWstore [4] dst (MOVWZload [4] src mem) (MOVWstore dst (MOVWZload src mem) mem))
-	for {
-		if auxIntToInt64(v.AuxInt) != 8 {
-			break
-		}
-		dst := v_0
-		src := v_1
-		mem := v_2
-		v.reset(OpPPC64MOVWstore)
-		v.AuxInt = int32ToAuxInt(4)
-		v0 := b.NewValue0(v.Pos, OpPPC64MOVWZload, typ.UInt32)
-		v0.AuxInt = int32ToAuxInt(4)
-		v0.AddArg2(src, mem)
-		v1 := b.NewValue0(v.Pos, OpPPC64MOVWstore, types.TypeMem)
-		v2 := b.NewValue0(v.Pos, OpPPC64MOVWZload, typ.UInt32)
-		v2.AddArg2(src, mem)
-		v1.AddArg3(dst, v2, mem)
-		v.AddArg3(dst, v0, v1)
-		return true
-	}
 	// match: (Move [3] dst src mem)
 	// result: (MOVBstore [2] dst (MOVBZload [2] src mem) (MOVHstore dst (MOVHload src mem) mem))
 	for {
@@ -7881,7 +7855,7 @@ func rewriteValuePPC64_OpPPC64MOVBstore(v *Value) bool {
 		return true
 	}
 	// match: (MOVBstore [i7] {s} p (SRDconst w [56]) x0:(MOVBstore [i6] {s} p (SRDconst w [48]) x1:(MOVBstore [i5] {s} p (SRDconst w [40]) x2:(MOVBstore [i4] {s} p (SRDconst w [32]) x3:(MOVWstore [i0] {s} p w mem)))))
-	// cond: !config.BigEndian && i0%4 == 0 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && x3.Uses == 1 && i4 == i0+4 && i5 == i0+5 && i6 == i0+6 && i7 == i0+7 && clobber(x0, x1, x2, x3)
+	// cond: !config.BigEndian && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && x3.Uses == 1 && i4 == i0+4 && i5 == i0+5 && i6 == i0+6 && i7 == i0+7 && clobber(x0, x1, x2, x3)
 	// result: (MOVDstore [i0] {s} p w mem)
 	for {
 		i7 := auxIntToInt32(v.AuxInt)
@@ -7948,7 +7922,7 @@ func rewriteValuePPC64_OpPPC64MOVBstore(v *Value) bool {
 			break
 		}
 		mem := x3.Args[2]
-		if p != x3.Args[0] || w != x3.Args[1] || !(!config.BigEndian && i0%4 == 0 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && x3.Uses == 1 && i4 == i0+4 && i5 == i0+5 && i6 == i0+6 && i7 == i0+7 && clobber(x0, x1, x2, x3)) {
+		if p != x3.Args[0] || w != x3.Args[1] || !(!config.BigEndian && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && x3.Uses == 1 && i4 == i0+4 && i5 == i0+5 && i6 == i0+6 && i7 == i0+7 && clobber(x0, x1, x2, x3)) {
 			break
 		}
 		v.reset(OpPPC64MOVDstore)
@@ -8392,7 +8366,7 @@ func rewriteValuePPC64_OpPPC64MOVDload(v *Value) bool {
 		return true
 	}
 	// match: (MOVDload [off1] {sym1} p:(MOVDaddr [off2] {sym2} ptr) mem)
-	// cond: canMergeSym(sym1,sym2) && is16Bit(int64(off1+off2)) && (ptr.Op != OpSB || p.Uses == 1) && (off1+off2)%4 == 0
+	// cond: canMergeSym(sym1,sym2) && is16Bit(int64(off1+off2)) && (ptr.Op != OpSB || p.Uses == 1)
 	// result: (MOVDload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
 	for {
 		off1 := auxIntToInt32(v.AuxInt)
@@ -8405,7 +8379,7 @@ func rewriteValuePPC64_OpPPC64MOVDload(v *Value) bool {
 		sym2 := auxToSym(p.Aux)
 		ptr := p.Args[0]
 		mem := v_1
-		if !(canMergeSym(sym1, sym2) && is16Bit(int64(off1+off2)) && (ptr.Op != OpSB || p.Uses == 1) && (off1+off2)%4 == 0) {
+		if !(canMergeSym(sym1, sym2) && is16Bit(int64(off1+off2)) && (ptr.Op != OpSB || p.Uses == 1)) {
 			break
 		}
 		v.reset(OpPPC64MOVDload)
@@ -8415,7 +8389,7 @@ func rewriteValuePPC64_OpPPC64MOVDload(v *Value) bool {
 		return true
 	}
 	// match: (MOVDload [off1] {sym} (ADDconst [off2] x) mem)
-	// cond: is16Bit(int64(off1)+off2) && (int64(off1)+off2)%4 == 0
+	// cond: is16Bit(int64(off1)+off2)
 	// result: (MOVDload [off1+int32(off2)] {sym} x mem)
 	for {
 		off1 := auxIntToInt32(v.AuxInt)
@@ -8426,7 +8400,7 @@ func rewriteValuePPC64_OpPPC64MOVDload(v *Value) bool {
 		off2 := auxIntToInt64(v_0.AuxInt)
 		x := v_0.Args[0]
 		mem := v_1
-		if !(is16Bit(int64(off1)+off2) && (int64(off1)+off2)%4 == 0) {
+		if !(is16Bit(int64(off1) + off2)) {
 			break
 		}
 		v.reset(OpPPC64MOVDload)
@@ -8523,7 +8497,7 @@ func rewriteValuePPC64_OpPPC64MOVDstore(v *Value) bool {
 		return true
 	}
 	// match: (MOVDstore [off1] {sym} (ADDconst [off2] x) val mem)
-	// cond: is16Bit(int64(off1)+off2) && (int64(off1)+off2)%4 == 0
+	// cond: is16Bit(int64(off1)+off2)
 	// result: (MOVDstore [off1+int32(off2)] {sym} x val mem)
 	for {
 		off1 := auxIntToInt32(v.AuxInt)
@@ -8535,7 +8509,7 @@ func rewriteValuePPC64_OpPPC64MOVDstore(v *Value) bool {
 		x := v_0.Args[0]
 		val := v_1
 		mem := v_2
-		if !(is16Bit(int64(off1)+off2) && (int64(off1)+off2)%4 == 0) {
+		if !(is16Bit(int64(off1) + off2)) {
 			break
 		}
 		v.reset(OpPPC64MOVDstore)
@@ -8545,7 +8519,7 @@ func rewriteValuePPC64_OpPPC64MOVDstore(v *Value) bool {
 		return true
 	}
 	// match: (MOVDstore [off1] {sym1} p:(MOVDaddr [off2] {sym2} ptr) val mem)
-	// cond: canMergeSym(sym1,sym2) && is16Bit(int64(off1+off2)) && (ptr.Op != OpSB || p.Uses == 1) && (off1+off2)%4 == 0
+	// cond: canMergeSym(sym1,sym2) && is16Bit(int64(off1+off2)) && (ptr.Op != OpSB || p.Uses == 1)
 	// result: (MOVDstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem)
 	for {
 		off1 := auxIntToInt32(v.AuxInt)
@@ -8559,7 +8533,7 @@ func rewriteValuePPC64_OpPPC64MOVDstore(v *Value) bool {
 		ptr := p.Args[0]
 		val := v_1
 		mem := v_2
-		if !(canMergeSym(sym1, sym2) && is16Bit(int64(off1+off2)) && (ptr.Op != OpSB || p.Uses == 1) && (off1+off2)%4 == 0) {
+		if !(canMergeSym(sym1, sym2) && is16Bit(int64(off1+off2)) && (ptr.Op != OpSB || p.Uses == 1)) {
 			break
 		}
 		v.reset(OpPPC64MOVDstore)
@@ -8658,7 +8632,7 @@ func rewriteValuePPC64_OpPPC64MOVDstorezero(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (MOVDstorezero [off1] {sym} (ADDconst [off2] x) mem)
-	// cond: is16Bit(int64(off1)+off2) && (int64(off1)+off2)%4 == 0
+	// cond: is16Bit(int64(off1)+off2)
 	// result: (MOVDstorezero [off1+int32(off2)] {sym} x mem)
 	for {
 		off1 := auxIntToInt32(v.AuxInt)
@@ -8669,7 +8643,7 @@ func rewriteValuePPC64_OpPPC64MOVDstorezero(v *Value) bool {
 		off2 := auxIntToInt64(v_0.AuxInt)
 		x := v_0.Args[0]
 		mem := v_1
-		if !(is16Bit(int64(off1)+off2) && (int64(off1)+off2)%4 == 0) {
+		if !(is16Bit(int64(off1) + off2)) {
 			break
 		}
 		v.reset(OpPPC64MOVDstorezero)
@@ -8679,7 +8653,7 @@ func rewriteValuePPC64_OpPPC64MOVDstorezero(v *Value) bool {
 		return true
 	}
 	// match: (MOVDstorezero [off1] {sym1} p:(MOVDaddr [off2] {sym2} x) mem)
-	// cond: canMergeSym(sym1,sym2) && (x.Op != OpSB || p.Uses == 1) && (off1+off2)%4 == 0
+	// cond: canMergeSym(sym1,sym2) && (x.Op != OpSB || p.Uses == 1)
 	// result: (MOVDstorezero [off1+off2] {mergeSym(sym1,sym2)} x mem)
 	for {
 		off1 := auxIntToInt32(v.AuxInt)
@@ -8692,7 +8666,7 @@ func rewriteValuePPC64_OpPPC64MOVDstorezero(v *Value) bool {
 		sym2 := auxToSym(p.Aux)
 		x := p.Args[0]
 		mem := v_1
-		if !(canMergeSym(sym1, sym2) && (x.Op != OpSB || p.Uses == 1) && (off1+off2)%4 == 0) {
+		if !(canMergeSym(sym1, sym2) && (x.Op != OpSB || p.Uses == 1)) {
 			break
 		}
 		v.reset(OpPPC64MOVDstorezero)
@@ -10598,7 +10572,7 @@ func rewriteValuePPC64_OpPPC64MOVWload(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (MOVWload [off1] {sym1} p:(MOVDaddr [off2] {sym2} ptr) mem)
-	// cond: canMergeSym(sym1,sym2) && is16Bit(int64(off1+off2)) && (ptr.Op != OpSB || p.Uses == 1) && (off1+off2)%4 == 0
+	// cond: canMergeSym(sym1,sym2) && is16Bit(int64(off1+off2)) && (ptr.Op != OpSB || p.Uses == 1)
 	// result: (MOVWload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
 	for {
 		off1 := auxIntToInt32(v.AuxInt)
@@ -10611,7 +10585,7 @@ func rewriteValuePPC64_OpPPC64MOVWload(v *Value) bool {
 		sym2 := auxToSym(p.Aux)
 		ptr := p.Args[0]
 		mem := v_1
-		if !(canMergeSym(sym1, sym2) && is16Bit(int64(off1+off2)) && (ptr.Op != OpSB || p.Uses == 1) && (off1+off2)%4 == 0) {
+		if !(canMergeSym(sym1, sym2) && is16Bit(int64(off1+off2)) && (ptr.Op != OpSB || p.Uses == 1)) {
 			break
 		}
 		v.reset(OpPPC64MOVWload)
@@ -10621,7 +10595,7 @@ func rewriteValuePPC64_OpPPC64MOVWload(v *Value) bool {
 		return true
 	}
 	// match: (MOVWload [off1] {sym} (ADDconst [off2] x) mem)
-	// cond: is16Bit(int64(off1)+off2) && (int64(off1)+off2)%4 == 0
+	// cond: is16Bit(int64(off1)+off2)
 	// result: (MOVWload [off1+int32(off2)] {sym} x mem)
 	for {
 		off1 := auxIntToInt32(v.AuxInt)
@@ -10632,7 +10606,7 @@ func rewriteValuePPC64_OpPPC64MOVWload(v *Value) bool {
 		off2 := auxIntToInt64(v_0.AuxInt)
 		x := v_0.Args[0]
 		mem := v_1
-		if !(is16Bit(int64(off1)+off2) && (int64(off1)+off2)%4 == 0) {
+		if !(is16Bit(int64(off1) + off2)) {
 			break
 		}
 		v.reset(OpPPC64MOVWload)
@@ -12504,7 +12478,7 @@ func rewriteValuePPC64_OpPPC64OR(v *Value) bool {
 		break
 	}
 	// match: (OR <t> s6:(SLDconst x7:(MOVBZload [i7] {s} p mem) [56]) o5:(OR <t> s5:(SLDconst x6:(MOVBZload [i6] {s} p mem) [48]) o4:(OR <t> s4:(SLDconst x5:(MOVBZload [i5] {s} p mem) [40]) o3:(OR <t> s3:(SLDconst x4:(MOVBZload [i4] {s} p mem) [32]) x0:(MOVWZload {s} [i0] p mem)))))
-	// cond: !config.BigEndian && i0%4 == 0 && i4 == i0+4 && i5 == i0+5 && i6 == i0+6 && i7 == i0+7 && x0.Uses == 1 && x4.Uses == 1 && x5.Uses == 1 && x6.Uses ==1 && x7.Uses == 1 && o3.Uses == 1 && o4.Uses == 1 && o5.Uses == 1 && s3.Uses == 1 && s4.Uses == 1 && s5.Uses == 1 && s6.Uses == 1 && mergePoint(b, x0, x4, x5, x6, x7) != nil && clobber(x0, x4, x5, x6, x7, s3, s4, s5, s6, o3, o4, o5)
+	// cond: !config.BigEndian && i4 == i0+4 && i5 == i0+5 && i6 == i0+6 && i7 == i0+7 && x0.Uses == 1 && x4.Uses == 1 && x5.Uses == 1 && x6.Uses ==1 && x7.Uses == 1 && o3.Uses == 1 && o4.Uses == 1 && o5.Uses == 1 && s3.Uses == 1 && s4.Uses == 1 && s5.Uses == 1 && s6.Uses == 1 && mergePoint(b, x0, x4, x5, x6, x7) != nil && clobber(x0, x4, x5, x6, x7, s3, s4, s5, s6, o3, o4, o5)
 	// result: @mergePoint(b,x0,x4,x5,x6,x7) (MOVDload <t> {s} [i0] p mem)
 	for {
 		t := v.Type
@@ -12602,7 +12576,7 @@ func rewriteValuePPC64_OpPPC64OR(v *Value) bool {
 							continue
 						}
 						_ = x0.Args[1]
-						if p != x0.Args[0] || mem != x0.Args[1] || !(!config.BigEndian && i0%4 == 0 && i4 == i0+4 && i5 == i0+5 && i6 == i0+6 && i7 == i0+7 && x0.Uses == 1 && x4.Uses == 1 && x5.Uses == 1 && x6.Uses == 1 && x7.Uses == 1 && o3.Uses == 1 && o4.Uses == 1 && o5.Uses == 1 && s3.Uses == 1 && s4.Uses == 1 && s5.Uses == 1 && s6.Uses == 1 && mergePoint(b, x0, x4, x5, x6, x7) != nil && clobber(x0, x4, x5, x6, x7, s3, s4, s5, s6, o3, o4, o5)) {
+						if p != x0.Args[0] || mem != x0.Args[1] || !(!config.BigEndian && i4 == i0+4 && i5 == i0+5 && i6 == i0+6 && i7 == i0+7 && x0.Uses == 1 && x4.Uses == 1 && x5.Uses == 1 && x6.Uses == 1 && x7.Uses == 1 && o3.Uses == 1 && o4.Uses == 1 && o5.Uses == 1 && s3.Uses == 1 && s4.Uses == 1 && s5.Uses == 1 && s6.Uses == 1 && mergePoint(b, x0, x4, x5, x6, x7) != nil && clobber(x0, x4, x5, x6, x7, s3, s4, s5, s6, o3, o4, o5)) {
 							continue
 						}
 						b = mergePoint(b, x0, x4, x5, x6, x7)
@@ -16847,51 +16821,25 @@ func rewriteValuePPC64_OpZero(v *Value) bool {
 		return true
 	}
 	// match: (Zero [8] {t} destptr mem)
-	// cond: t.Alignment()%4 == 0
 	// result: (MOVDstorezero destptr mem)
 	for {
 		if auxIntToInt64(v.AuxInt) != 8 {
 			break
 		}
-		t := auxToType(v.Aux)
 		destptr := v_0
 		mem := v_1
-		if !(t.Alignment()%4 == 0) {
-			break
-		}
 		v.reset(OpPPC64MOVDstorezero)
 		v.AddArg2(destptr, mem)
 		return true
 	}
-	// match: (Zero [8] destptr mem)
-	// result: (MOVWstorezero [4] destptr (MOVWstorezero [0] destptr mem))
-	for {
-		if auxIntToInt64(v.AuxInt) != 8 {
-			break
-		}
-		destptr := v_0
-		mem := v_1
-		v.reset(OpPPC64MOVWstorezero)
-		v.AuxInt = int32ToAuxInt(4)
-		v0 := b.NewValue0(v.Pos, OpPPC64MOVWstorezero, types.TypeMem)
-		v0.AuxInt = int32ToAuxInt(0)
-		v0.AddArg2(destptr, mem)
-		v.AddArg2(destptr, v0)
-		return true
-	}
 	// match: (Zero [12] {t} destptr mem)
-	// cond: t.Alignment()%4 == 0
 	// result: (MOVWstorezero [8] destptr (MOVDstorezero [0] destptr mem))
 	for {
 		if auxIntToInt64(v.AuxInt) != 12 {
 			break
 		}
-		t := auxToType(v.Aux)
 		destptr := v_0
 		mem := v_1
-		if !(t.Alignment()%4 == 0) {
-			break
-		}
 		v.reset(OpPPC64MOVWstorezero)
 		v.AuxInt = int32ToAuxInt(8)
 		v0 := b.NewValue0(v.Pos, OpPPC64MOVDstorezero, types.TypeMem)
@@ -16901,18 +16849,13 @@ func rewriteValuePPC64_OpZero(v *Value) bool {
 		return true
 	}
 	// match: (Zero [16] {t} destptr mem)
-	// cond: t.Alignment()%4 == 0
 	// result: (MOVDstorezero [8] destptr (MOVDstorezero [0] destptr mem))
 	for {
 		if auxIntToInt64(v.AuxInt) != 16 {
 			break
 		}
-		t := auxToType(v.Aux)
 		destptr := v_0
 		mem := v_1
-		if !(t.Alignment()%4 == 0) {
-			break
-		}
 		v.reset(OpPPC64MOVDstorezero)
 		v.AuxInt = int32ToAuxInt(8)
 		v0 := b.NewValue0(v.Pos, OpPPC64MOVDstorezero, types.TypeMem)
@@ -16922,18 +16865,13 @@ func rewriteValuePPC64_OpZero(v *Value) bool {
 		return true
 	}
 	// match: (Zero [24] {t} destptr mem)
-	// cond: t.Alignment()%4 == 0
 	// result: (MOVDstorezero [16] destptr (MOVDstorezero [8] destptr (MOVDstorezero [0] destptr mem)))
 	for {
 		if auxIntToInt64(v.AuxInt) != 24 {
 			break
 		}
-		t := auxToType(v.Aux)
 		destptr := v_0
 		mem := v_1
-		if !(t.Alignment()%4 == 0) {
-			break
-		}
 		v.reset(OpPPC64MOVDstorezero)
 		v.AuxInt = int32ToAuxInt(16)
 		v0 := b.NewValue0(v.Pos, OpPPC64MOVDstorezero, types.TypeMem)
@@ -16946,18 +16884,13 @@ func rewriteValuePPC64_OpZero(v *Value) bool {
 		return true
 	}
 	// match: (Zero [32] {t} destptr mem)
-	// cond: t.Alignment()%4 == 0
 	// result: (MOVDstorezero [24] destptr (MOVDstorezero [16] destptr (MOVDstorezero [8] destptr (MOVDstorezero [0] destptr mem))))
 	for {
 		if auxIntToInt64(v.AuxInt) != 32 {
 			break
 		}
-		t := auxToType(v.Aux)
 		destptr := v_0
 		mem := v_1
-		if !(t.Alignment()%4 == 0) {
-			break
-		}
 		v.reset(OpPPC64MOVDstorezero)
 		v.AuxInt = int32ToAuxInt(24)
 		v0 := b.NewValue0(v.Pos, OpPPC64MOVDstorezero, types.TypeMem)
diff --git a/test/fixedbugs/issue44739.go b/test/fixedbugs/issue44739.go
new file mode 100644
index 0000000000..3441a90343
--- /dev/null
+++ b/test/fixedbugs/issue44739.go
@@ -0,0 +1,61 @@
+// compile
+
+// Copyright 2021 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.
+
+// issue 44739: cmd/compile: incorrect offset in MOVD
+// load/store on ppc64/ppc64le causes assembler error.
+
+// Test other 8 byte loads and stores where the
+// compile time offset is not aligned to 8, as
+// well as cases where the offset is not known
+// until link time (e.g. gostrings).
+
+package main
+
+import (
+	"fmt"
+)
+
+type T struct {
+	x [4]byte
+	y [8]byte
+}
+
+var st T
+
+const (
+	gostring1 = "abc"
+	gostring2 = "defghijk"
+	gostring3 = "lmnopqrs"
+)
+
+func f(a T, _ byte, b T) bool {
+	// initialization of a,b
+	// tests unaligned store
+	return a.y == b.y
+}
+
+func g(a T) {
+	// test load of unaligned
+	// 8 byte gostring, store
+	// to unaligned static
+	copy(a.y[:], gostring2)
+}
+
+func main() {
+	var t1, t2 T
+
+	// test copy to automatic storage,
+	// load of unaligned gostring.
+	copy(st.y[:], gostring2)
+	copy(t1.y[:], st.y[:])
+	copy(t2.y[:], gostring3)
+	// test initialization of params
+	if !f(t1, 'a', t2) {
+		// gostring1 added so it has a use
+		fmt.Printf("FAIL: %s\n", gostring1)
+	}
+}
+
-- 
GitLab


From a1a3d33b0dbd42ab91b04ba19bbee48b55427d58 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Mon, 1 Mar 2021 15:18:12 -0500
Subject: [PATCH 1018/2400] cmd/go: test remote lookup of packages with leading
 dots in path elements

Follow-up to CL 297530.

For #43985
For #34992

Change-Id: I2cfa6c41c013e627c3464c383ca42f5c9ebe521a
Reviewed-on: https://go-review.googlesource.com/c/go/+/297634
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go.mod                                |  2 +-
 src/cmd/go.sum                                |  4 +-
 src/cmd/go/internal/modload/query.go          | 18 ++++++-
 src/cmd/go/proxy_test.go                      |  2 +-
 .../mod/example.com_dotname_v1.0.0.txt        | 12 +++++
 .../script/mod_invalid_path_dotname.txt       | 46 ++++++++++++++++
 .../testdata/script/mod_invalid_path_plus.txt | 14 +++--
 .../vendor/golang.org/x/mod/module/module.go  | 52 +++++++++++++------
 src/cmd/vendor/modules.txt                    |  2 +-
 9 files changed, 126 insertions(+), 26 deletions(-)
 create mode 100644 src/cmd/go/testdata/mod/example.com_dotname_v1.0.0.txt
 create mode 100644 src/cmd/go/testdata/script/mod_invalid_path_dotname.txt

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index 05076792c8..306143f088 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -6,7 +6,7 @@ require (
 	github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2
 	golang.org/x/arch v0.0.0-20201008161808-52c3e6f60cff
 	golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897
-	golang.org/x/mod v0.4.2-0.20210309222212-d6ab96f2441f
+	golang.org/x/mod v0.4.3-0.20210310185834-19d50cac98aa
 	golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e // indirect
 	golang.org/x/tools v0.1.1-0.20210220032852-2363391a5b2f
 )
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 3827248879..97fbd5c0a9 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -14,8 +14,8 @@ golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPh
 golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897 h1:pLI5jrR7OSLijeIDcmRxNmw2api+jEfxLoykJVice/E=
 golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.4.2-0.20210309222212-d6ab96f2441f h1:mQozKYYFIVK0MXcDB8Dvw0dR3rxKLnkSCJHWznfaodQ=
-golang.org/x/mod v0.4.2-0.20210309222212-d6ab96f2441f/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.3-0.20210310185834-19d50cac98aa h1:++oSKjoJSsXNHyhUdK1BtBKMAaMHER+GWyKN3319OZA=
+golang.org/x/mod v0.4.3-0.20210310185834-19d50cac98aa/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
diff --git a/src/cmd/go/internal/modload/query.go b/src/cmd/go/internal/modload/query.go
index a8012c792a..1707bd88ed 100644
--- a/src/cmd/go/internal/modload/query.go
+++ b/src/cmd/go/internal/modload/query.go
@@ -695,7 +695,9 @@ func QueryPattern(ctx context.Context, pattern, query string, current func(strin
 
 // modulePrefixesExcludingTarget returns all prefixes of path that may plausibly
 // exist as a module, excluding targetPrefix but otherwise including path
-// itself, sorted by descending length.
+// itself, sorted by descending length. Prefixes that are not valid module paths
+// but are valid package paths (like "m" or "example.com/.gen") are included,
+// since they might be replaced.
 func modulePrefixesExcludingTarget(path string) []string {
 	prefixes := make([]string, 0, strings.Count(path, "/")+1)
 
@@ -747,6 +749,7 @@ func queryPrefixModules(ctx context.Context, candidateModules []string, queryMod
 		noPackage   *PackageNotInModuleError
 		noVersion   *NoMatchingVersionError
 		noPatchBase *NoPatchBaseError
+		invalidPath *module.InvalidPathError // see comment in case below
 		notExistErr error
 	)
 	for _, r := range results {
@@ -767,6 +770,17 @@ func queryPrefixModules(ctx context.Context, candidateModules []string, queryMod
 			if noPatchBase == nil {
 				noPatchBase = rErr
 			}
+		case *module.InvalidPathError:
+			// The prefix was not a valid module path, and there was no replacement.
+			// Prefixes like this may appear in candidateModules, since we handle
+			// replaced modules that weren't required in the repo lookup process
+			// (see lookupRepo).
+			//
+			// A shorter prefix may be a valid module path and may contain a valid
+			// import path, so this is a low-priority error.
+			if invalidPath == nil {
+				invalidPath = rErr
+			}
 		default:
 			if errors.Is(rErr, fs.ErrNotExist) {
 				if notExistErr == nil {
@@ -800,6 +814,8 @@ func queryPrefixModules(ctx context.Context, candidateModules []string, queryMod
 			err = noVersion
 		case noPatchBase != nil:
 			err = noPatchBase
+		case invalidPath != nil:
+			err = invalidPath
 		case notExistErr != nil:
 			err = notExistErr
 		default:
diff --git a/src/cmd/go/proxy_test.go b/src/cmd/go/proxy_test.go
index e390c73a9c..7d8a97dd99 100644
--- a/src/cmd/go/proxy_test.go
+++ b/src/cmd/go/proxy_test.go
@@ -362,7 +362,7 @@ func proxyHandler(w http.ResponseWriter, r *http.Request) {
 			var buf bytes.Buffer
 			z := zip.NewWriter(&buf)
 			for _, f := range a.Files {
-				if strings.HasPrefix(f.Name, ".") {
+				if f.Name == ".info" || f.Name == ".mod" || f.Name == ".zip" {
 					continue
 				}
 				var zipName string
diff --git a/src/cmd/go/testdata/mod/example.com_dotname_v1.0.0.txt b/src/cmd/go/testdata/mod/example.com_dotname_v1.0.0.txt
new file mode 100644
index 0000000000..2ada3a3f81
--- /dev/null
+++ b/src/cmd/go/testdata/mod/example.com_dotname_v1.0.0.txt
@@ -0,0 +1,12 @@
+-- .info --
+{"Version":"v1.0.0"}
+-- .mod --
+module example.com/dotname
+
+go 1.16
+-- go.mod --
+module example.com/dotname
+
+go 1.16
+-- .dot/dot.go --
+package dot
diff --git a/src/cmd/go/testdata/script/mod_invalid_path_dotname.txt b/src/cmd/go/testdata/script/mod_invalid_path_dotname.txt
new file mode 100644
index 0000000000..85934332d1
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_invalid_path_dotname.txt
@@ -0,0 +1,46 @@
+# Test that an import path containing an element with a leading dot
+# in another module is valid.
+
+# 'go get' works with no version query.
+cp go.mod.empty go.mod
+go get -d example.com/dotname/.dot
+go list -m example.com/dotname
+stdout '^example.com/dotname v1.0.0$'
+
+# 'go get' works with a version query.
+cp go.mod.empty go.mod
+go get -d example.com/dotname/.dot@latest
+go list -m example.com/dotname
+stdout '^example.com/dotname v1.0.0$'
+
+# 'go get' works on an importing package.
+cp go.mod.empty go.mod
+go get -d .
+go list -m example.com/dotname
+stdout '^example.com/dotname v1.0.0$'
+
+# 'go list' works on the dotted package.
+go list example.com/dotname/.dot
+stdout '^example.com/dotname/.dot$'
+
+# 'go list' works on an importing package.
+go list .
+stdout '^m$'
+
+# 'go mod tidy' works.
+cp go.mod.empty go.mod
+go mod tidy
+go list -m example.com/dotname
+stdout '^example.com/dotname v1.0.0$'
+
+-- go.mod.empty --
+module m
+
+go 1.16
+-- go.sum --
+example.com/dotname v1.0.0 h1:Q0JMAn464CnwFVCshs1n4+f5EFiW/eRhnx/fTWjw2Ag=
+example.com/dotname v1.0.0/go.mod h1:7K4VLT7QylRI8H7yZwUkeDH2s19wQnyfp/3oBlItWJ0=
+-- use.go --
+package use
+
+import _ "example.com/dotname/.dot"
diff --git a/src/cmd/go/testdata/script/mod_invalid_path_plus.txt b/src/cmd/go/testdata/script/mod_invalid_path_plus.txt
index 636769eb4d..51dbf93688 100644
--- a/src/cmd/go/testdata/script/mod_invalid_path_plus.txt
+++ b/src/cmd/go/testdata/script/mod_invalid_path_plus.txt
@@ -2,18 +2,22 @@
 # The '+' character should be disallowed in module paths, but allowed in package
 # paths within valid modules.
 
+# 'go list' accepts package paths with pluses.
+cp go.mod.orig go.mod
 go get -d example.net/cmd
 go list example.net/cmd/x++
 
+# 'go list -m' rejects module paths with pluses.
 ! go list -versions -m 'example.net/bad++'
 stderr '^go list -m: malformed module path "example.net/bad\+\+": invalid char ''\+''$'
 
-# TODO(bcmills): 'go get -d example.net/cmd/x++' should also work, but currently
-# it does not. This might be fixed by https://golang.org/cl/297891.
-! go get -d example.net/cmd/x++
-stderr '^go get: malformed module path "example.net/cmd/x\+\+": invalid char ''\+''$'
+# 'go get' accepts package paths with pluses.
+cp go.mod.orig go.mod
+go get -d example.net/cmd/x++
+go list -m example.net/cmd
+stdout '^example.net/cmd v0.0.0-00010101000000-000000000000 => ./cmd$'
 
--- go.mod --
+-- go.mod.orig --
 module example.com/m
 
 go 1.16
diff --git a/src/cmd/vendor/golang.org/x/mod/module/module.go b/src/cmd/vendor/golang.org/x/mod/module/module.go
index 0e03014837..cf69ff657a 100644
--- a/src/cmd/vendor/golang.org/x/mod/module/module.go
+++ b/src/cmd/vendor/golang.org/x/mod/module/module.go
@@ -192,6 +192,21 @@ func (e *InvalidVersionError) Error() string {
 
 func (e *InvalidVersionError) Unwrap() error { return e.Err }
 
+// An InvalidPathError indicates a module, import, or file path doesn't
+// satisfy all naming constraints. See CheckPath, CheckImportPath,
+// and CheckFilePath for specific restrictions.
+type InvalidPathError struct {
+	Kind string // "module", "import", or "file"
+	Path string
+	Err  error
+}
+
+func (e *InvalidPathError) Error() string {
+	return fmt.Sprintf("malformed %s path %q: %v", e.Kind, e.Path, e.Err)
+}
+
+func (e *InvalidPathError) Unwrap() error { return e.Err }
+
 // Check checks that a given module path, version pair is valid.
 // In addition to the path being a valid module path
 // and the version being a valid semantic version,
@@ -296,30 +311,36 @@ func fileNameOK(r rune) bool {
 // this second requirement is replaced by a requirement that the path
 // follow the gopkg.in server's conventions.
 // Third, no path element may begin with a dot.
-func CheckPath(path string) error {
+func CheckPath(path string) (err error) {
+	defer func() {
+		if err != nil {
+			err = &InvalidPathError{Kind: "module", Path: path, Err: err}
+		}
+	}()
+
 	if err := checkPath(path, modulePath); err != nil {
-		return fmt.Errorf("malformed module path %q: %v", path, err)
+		return err
 	}
 	i := strings.Index(path, "/")
 	if i < 0 {
 		i = len(path)
 	}
 	if i == 0 {
-		return fmt.Errorf("malformed module path %q: leading slash", path)
+		return fmt.Errorf("leading slash")
 	}
 	if !strings.Contains(path[:i], ".") {
-		return fmt.Errorf("malformed module path %q: missing dot in first path element", path)
+		return fmt.Errorf("missing dot in first path element")
 	}
 	if path[0] == '-' {
-		return fmt.Errorf("malformed module path %q: leading dash in first path element", path)
+		return fmt.Errorf("leading dash in first path element")
 	}
 	for _, r := range path[:i] {
 		if !firstPathOK(r) {
-			return fmt.Errorf("malformed module path %q: invalid char %q in first path element", path, r)
+			return fmt.Errorf("invalid char %q in first path element", r)
 		}
 	}
 	if _, _, ok := SplitPathVersion(path); !ok {
-		return fmt.Errorf("malformed module path %q: invalid version", path)
+		return fmt.Errorf("invalid version")
 	}
 	return nil
 }
@@ -343,7 +364,7 @@ func CheckPath(path string) error {
 // subtleties of Unicode.
 func CheckImportPath(path string) error {
 	if err := checkPath(path, importPath); err != nil {
-		return fmt.Errorf("malformed import path %q: %v", path, err)
+		return &InvalidPathError{Kind: "import", Path: path, Err: err}
 	}
 	return nil
 }
@@ -358,12 +379,13 @@ const (
 	filePath
 )
 
-// checkPath checks that a general path is valid.
-// It returns an error describing why but not mentioning path.
-// Because these checks apply to both module paths and import paths,
-// the caller is expected to add the "malformed ___ path %q: " prefix.
-// fileName indicates whether the final element of the path is a file name
-// (as opposed to a directory name).
+// checkPath checks that a general path is valid. kind indicates what
+// specific constraints should be applied.
+//
+// checkPath returns an error describing why the path is not valid.
+// Because these checks apply to module, import, and file paths,
+// and because other checks may be applied, the caller is expected to wrap
+// this error with InvalidPathError.
 func checkPath(path string, kind pathKind) error {
 	if !utf8.ValidString(path) {
 		return fmt.Errorf("invalid UTF-8")
@@ -477,7 +499,7 @@ func checkElem(elem string, kind pathKind) error {
 // subtleties of Unicode.
 func CheckFilePath(path string) error {
 	if err := checkPath(path, filePath); err != nil {
-		return fmt.Errorf("malformed file path %q: %v", path, err)
+		return &InvalidPathError{Kind: "file", Path: path, Err: err}
 	}
 	return nil
 }
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index b84ee5a7b1..af92df8721 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -28,7 +28,7 @@ golang.org/x/arch/x86/x86asm
 golang.org/x/crypto/ed25519
 golang.org/x/crypto/ed25519/internal/edwards25519
 golang.org/x/crypto/ssh/terminal
-# golang.org/x/mod v0.4.2-0.20210309222212-d6ab96f2441f
+# golang.org/x/mod v0.4.3-0.20210310185834-19d50cac98aa
 ## explicit
 golang.org/x/mod/internal/lazyregexp
 golang.org/x/mod/modfile
-- 
GitLab


From b7f0fb6d9eb9a2c1b2beb9ecd58bdbf3571dd5cd Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Sat, 6 Feb 2021 00:50:55 -0500
Subject: [PATCH 1019/2400] cmd/go/internal/modload: fuse upgrading with
 downgrading in EditBuildList

Previosly, EditBuildList performed an mvs.Upgrade followed by an
mvs.Downgrade, with the Downgrade building on the result of the
Upgrade. Unfortunately, that approach potentially folds in irrelevant
dependencies from the first Upgrade, which are then preserved
unnecessarily by the Downgrade (see mod_get_downup_artifact.txt).

Now, we use the initial Upgrade only to compute the maximum allowed
versions of transitive dependencies, and apply the module upgrades and
downgrades together in a single operation.

For #36460

Change-Id: I7590c137111fed4a3b06531c88d90efd49e6943a
Reviewed-on: https://go-review.googlesource.com/c/go/+/290770
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modload/buildlist.go      |  29 +-
 src/cmd/go/internal/modload/edit.go           | 281 ++++++++++++++++++
 src/cmd/go/internal/modload/mvs.go            |  29 +-
 .../script/mod_get_downup_artifact.txt        |  10 +-
 4 files changed, 314 insertions(+), 35 deletions(-)
 create mode 100644 src/cmd/go/internal/modload/edit.go

diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index 45f220a6ee..5de26357e1 100644
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -82,25 +82,9 @@ func Selected(path string) (version string) {
 // the listed modules requiring a higher version of another), EditBuildList
 // returns a *ConstraintError and leaves the build list in its previous state.
 func EditBuildList(ctx context.Context, add, mustSelect []module.Version) error {
-	var upgraded = capVersionSlice(buildList)
-	if len(add) > 0 {
-		// First, upgrade the build list with any additions.
-		// In theory we could just append the additions to the build list and let
-		// mvs.Downgrade take care of resolving the upgrades too, but the
-		// diagnostics from Upgrade are currently much better in case of errors.
-		var err error
-		upgraded, err = mvs.Upgrade(Target, &mvsReqs{buildList: upgraded}, add...)
-		if err != nil {
-			return err
-		}
-	}
-
-	downgraded, err := mvs.Downgrade(Target, &mvsReqs{buildList: append(upgraded, mustSelect...)}, mustSelect...)
-	if err != nil {
-		return err
-	}
+	LoadModFile(ctx)
 
-	final, err := mvs.Upgrade(Target, &mvsReqs{buildList: downgraded}, mustSelect...)
+	final, err := editBuildList(ctx, buildList, add, mustSelect)
 	if err != nil {
 		return err
 	}
@@ -112,10 +96,7 @@ func EditBuildList(ctx context.Context, add, mustSelect []module.Version) error
 	inconsistent := false
 	for _, m := range mustSelect {
 		s, ok := selected[m.Path]
-		if !ok {
-			if m.Version != "none" {
-				panic(fmt.Sprintf("internal error: mvs.BuildList lost %v", m))
-			}
+		if !ok && m.Version == "none" {
 			continue
 		}
 		if s.Version != m.Version {
@@ -135,7 +116,7 @@ func EditBuildList(ctx context.Context, add, mustSelect []module.Version) error
 		return nil
 	}
 
-	// We overshot one or more of the modules in mustSelected, which means that
+	// We overshot one or more of the modules in mustSelect, which means that
 	// Downgrade removed something in mustSelect because it conflicted with
 	// something else in mustSelect.
 	//
@@ -170,7 +151,7 @@ func EditBuildList(ctx context.Context, add, mustSelect []module.Version) error
 		s, ok := selected[m.Path]
 		if !ok {
 			if m.Version != "none" {
-				panic(fmt.Sprintf("internal error: mvs.BuildList lost %v", m))
+				panic(fmt.Sprintf("internal error: editBuildList lost %v", m))
 			}
 			continue
 		}
diff --git a/src/cmd/go/internal/modload/edit.go b/src/cmd/go/internal/modload/edit.go
new file mode 100644
index 0000000000..4d1f3c7826
--- /dev/null
+++ b/src/cmd/go/internal/modload/edit.go
@@ -0,0 +1,281 @@
+// Copyright 2021 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 modload
+
+import (
+	"context"
+	"sort"
+
+	"cmd/go/internal/mvs"
+
+	"golang.org/x/mod/module"
+	"golang.org/x/mod/semver"
+)
+
+// editBuildList returns an edited version of initial such that:
+//
+// 	1. Each module version in mustSelect is selected, unless it is upgraded
+// 	   by the transitive requirements of another version in mustSelect.
+//
+// 	2. Each module version in tryUpgrade is upgraded toward the indicated
+// 	   version as far as can be done without violating (1).
+//
+// 	3. Each module version in initial is downgraded from its original version
+// 	   only to the extent needed to satisfy (1), or upgraded only to the extent
+// 	   needed to satisfy (1) and (2).
+//
+// 	4. No module is upgraded above the maximum version of its path found in the
+// 	   combined dependency graph of list, tryUpgrade, and mustSelect.
+func editBuildList(ctx context.Context, initial, tryUpgrade, mustSelect []module.Version) ([]module.Version, error) {
+	// Per https://research.swtch.com/vgo-mvs#algorithm_4:
+	// “To avoid an unnecessary downgrade to E 1.1, we must also add a new
+	// requirement on E 1.2. We can apply Algorithm R to find the minimal set of
+	// new requirements to write to go.mod.”
+	//
+	// In order to generate those new requirements, we need consider versions for
+	// every module in the existing build list, plus every module being directly
+	// added by the edit. However, modules added only as dependencies of tentative
+	// versions should not be retained if they end up being upgraded or downgraded
+	// away due to versions in mustSelect.
+
+	// When we downgrade modules in order to reach mustSelect, we don't want to
+	// upgrade any existing module above the version that would be selected if we
+	// just added all of the new requirements and *didn't* downgrade.
+	//
+	// So we'll do exactly that: just add all of the new requirements and not
+	// downgrade, and return the resulting versions as an upper bound. This
+	// intentionally limits our solution space so that edits that the user
+	// percieves as “downgrades” will not also result in upgrades.
+	max := make(map[string]string)
+	maxes, err := mvs.Upgrade(Target, &mvsReqs{
+		buildList: append(capVersionSlice(initial), mustSelect...),
+	}, tryUpgrade...)
+	if err != nil {
+		return nil, err
+	}
+	for _, m := range maxes {
+		max[m.Path] = m.Version
+	}
+	// The versions in mustSelect override whatever we would naively select —
+	// we will downgrade other modules as needed in order to meet them.
+	for _, m := range mustSelect {
+		max[m.Path] = m.Version
+	}
+
+	limiter := newVersionLimiter(max)
+
+	// Force the selected versions in mustSelect, even if they conflict.
+	//
+	// TODO(bcmills): Instead of forcing these versions, record conflicts
+	// so that the caller doesn't have to recompute them.
+	for _, m := range mustSelect {
+		limiter.selected[m.Path] = m.Version
+	}
+
+	// For each module, we want to get as close as we can to either the upgrade
+	// version or the previously-selected version in the build list, whichever is
+	// higher. We can compute those in either order, but the upgrades will tend to
+	// be higher than the build list, so we arbitrarily start with those.
+	for _, m := range tryUpgrade {
+		if err := limiter.upgradeToward(ctx, m); err != nil {
+			return nil, err
+		}
+	}
+	for _, m := range initial {
+		if err := limiter.upgradeToward(ctx, m); err != nil {
+			return nil, err
+		}
+	}
+
+	// We've identified acceptable versions for each of the modules, but those
+	// versions are not necessarily consistent with each other: one upgraded or
+	// downgraded module may require a higher (but still allowed) version of
+	// another. The lower version may require extraneous dependencies that aren't
+	// actually relevant, so we need to compute the actual selected versions.
+	adjusted := make([]module.Version, 0, len(maxes))
+	for _, m := range maxes {
+		if v, ok := limiter.selected[m.Path]; ok {
+			adjusted = append(adjusted, module.Version{Path: m.Path, Version: v})
+		}
+	}
+	consistent, err := mvs.BuildList(Target, &mvsReqs{buildList: adjusted})
+	if err != nil {
+		return nil, err
+	}
+
+	// We have the correct selected versions. Now we need to re-run MVS with only
+	// the actually-selected versions in order to eliminate extraneous
+	// dependencies from lower-than-selected ones.
+	compacted := consistent[:0]
+	for _, m := range consistent {
+		if _, ok := limiter.selected[m.Path]; ok {
+			// The fact that the limiter has a version for m.Path indicates that we
+			// care about retaining that path, even if the version was upgraded for
+			// consistency.
+			compacted = append(compacted, m)
+		}
+	}
+
+	return mvs.BuildList(Target, &mvsReqs{buildList: compacted})
+}
+
+// A versionLimiter tracks the versions that may be selected for each module
+// subject to constraints on the maximum versions of transitive dependencies.
+type versionLimiter struct {
+	// max maps each module path to the maximum version that may be selected for
+	// that path. Paths with no entry are unrestricted.
+	max map[string]string
+
+	// selected maps each module path to a version of that path (if known) whose
+	// transitive dependencies do not violate any max version. The version kept
+	// is the highest one found during any call to upgradeToward for the given
+	// module path.
+	//
+	// If a higher acceptable version is found during a call to upgradeToward for
+	// some *other* module path, that does not update the selected version.
+	// Ignoring those versions keeps the downgrades computed for two modules
+	// together close to the individual downgrades that would be computed for each
+	// module in isolation. (The only way one module can affect another is if the
+	// final downgraded version of the one module explicitly requires a higher
+	// version of the other.)
+	//
+	// Version "none" of every module is always known not to violate any max
+	// version, so paths at version "none" are omitted.
+	selected map[string]string
+
+	// disqualified maps each encountered version to either true (if that version
+	// is known to be disqualified due to a conflict with a max version) or false
+	// (if that version is not known to be disqualified, either because it is ok
+	// or because we are currently traversing a cycle that includes it).
+	disqualified map[module.Version]bool
+
+	// requiredBy maps each not-yet-disqualified module version to the versions
+	// that directly require it. If that version becomes disqualified, the
+	// disqualification will be propagated to all of the versions in the list.
+	requiredBy map[module.Version][]module.Version
+}
+
+func newVersionLimiter(max map[string]string) *versionLimiter {
+	return &versionLimiter{
+		selected:     map[string]string{Target.Path: Target.Version},
+		max:          max,
+		disqualified: map[module.Version]bool{Target: false},
+		requiredBy:   map[module.Version][]module.Version{},
+	}
+}
+
+// upgradeToward attempts to upgrade the selected version of m.Path as close as
+// possible to m.Version without violating l's maximum version limits.
+func (l *versionLimiter) upgradeToward(ctx context.Context, m module.Version) error {
+	selected, ok := l.selected[m.Path]
+	if ok {
+		if cmpVersion(selected, m.Version) >= 0 {
+			// The selected version is already at least m, so no upgrade is needed.
+			return nil
+		}
+	} else {
+		selected = "none"
+	}
+
+	if l.isDisqualified(m) {
+		candidates, err := versions(ctx, m.Path, CheckAllowed)
+		if err != nil {
+			// This is likely a transient error reaching the repository,
+			// rather than a permanent error with the retrieved version.
+			//
+			// TODO(golang.org/issue/31730, golang.org/issue/30134):
+			// decode what to do based on the actual error.
+			return err
+		}
+
+		// Skip to candidates < m.Version.
+		i := sort.Search(len(candidates), func(i int) bool {
+			return semver.Compare(candidates[i], m.Version) >= 0
+		})
+		candidates = candidates[:i]
+
+		for l.isDisqualified(m) {
+			n := len(candidates)
+			if n == 0 || cmpVersion(selected, candidates[n-1]) >= 0 {
+				// We couldn't find a suitable candidate above the already-selected version.
+				// Retain that version unmodified.
+				return nil
+			}
+			m.Version, candidates = candidates[n-1], candidates[:n-1]
+		}
+	}
+
+	l.selected[m.Path] = m.Version
+	return nil
+}
+
+// isDisqualified reports whether m (or its transitive dependencies) would
+// violate l's maximum version limits if added to the module requirement graph.
+func (l *versionLimiter) isDisqualified(m module.Version) bool {
+	if m.Version == "none" || m == Target {
+		// version "none" has no requirements, and the dependencies of Target are
+		// tautological.
+		return false
+	}
+
+	if dq, seen := l.disqualified[m]; seen {
+		return dq
+	}
+	l.disqualified[m] = false
+
+	if max, ok := l.max[m.Path]; ok && cmpVersion(m.Version, max) > 0 {
+		l.disqualify(m)
+		return true
+	}
+
+	summary, err := goModSummary(m)
+	if err != nil {
+		// If we can't load the requirements, we couldn't load the go.mod file.
+		// There are a number of reasons this can happen, but this usually
+		// means an older version of the module had a missing or invalid
+		// go.mod file. For example, if example.com/mod released v2.0.0 before
+		// migrating to modules (v2.0.0+incompatible), then added a valid go.mod
+		// in v2.0.1, downgrading from v2.0.1 would cause this error.
+		//
+		// TODO(golang.org/issue/31730, golang.org/issue/30134): if the error
+		// is transient (we couldn't download go.mod), return the error from
+		// Downgrade. Currently, we can't tell what kind of error it is.
+		l.disqualify(m)
+		return true
+	}
+
+	for _, r := range summary.require {
+		if l.isDisqualified(r) {
+			l.disqualify(m)
+			return true
+		}
+
+		// r and its dependencies are (perhaps provisionally) ok.
+		//
+		// However, if there are cycles in the requirement graph, we may have only
+		// checked a portion of the requirement graph so far, and r (and thus m) may
+		// yet be disqualified by some path we have not yet visited. Remember this edge
+		// so that we can disqualify m and its dependents if that occurs.
+		l.requiredBy[r] = append(l.requiredBy[r], m)
+	}
+
+	return false
+}
+
+// disqualify records that m (or one of its transitive dependencies)
+// violates l's maximum version limits.
+func (l *versionLimiter) disqualify(m module.Version) {
+	if l.disqualified[m] {
+		return
+	}
+	l.disqualified[m] = true
+
+	for _, p := range l.requiredBy[m] {
+		l.disqualify(p)
+	}
+	// Now that we have disqualified the modules that depend on m, we can forget
+	// about them — we won't need to disqualify them again.
+	delete(l.requiredBy, m)
+}
diff --git a/src/cmd/go/internal/modload/mvs.go b/src/cmd/go/internal/modload/mvs.go
index 31015194f9..5f52017a74 100644
--- a/src/cmd/go/internal/modload/mvs.go
+++ b/src/cmd/go/internal/modload/mvs.go
@@ -16,6 +16,25 @@ import (
 	"golang.org/x/mod/semver"
 )
 
+// cmpVersion implements the comparison for versions in the module loader.
+//
+// It is consistent with semver.Compare except that as a special case,
+// the version "" is considered higher than all other versions.
+// The main module (also known as the target) has no version and must be chosen
+// over other versions of the same module in the module dependency graph.
+func cmpVersion(v1, v2 string) int {
+	if v2 == "" {
+		if v1 == "" {
+			return 0
+		}
+		return -1
+	}
+	if v1 == "" {
+		return 1
+	}
+	return semver.Compare(v1, v2)
+}
+
 // mvsReqs implements mvs.Reqs for module semantic versions,
 // with any exclusions or replacements applied internally.
 type mvsReqs struct {
@@ -47,7 +66,7 @@ func (r *mvsReqs) Required(mod module.Version) ([]module.Version, error) {
 // be chosen over other versions of the same module in the module dependency
 // graph.
 func (*mvsReqs) Max(v1, v2 string) string {
-	if v1 != "" && (v2 == "" || semver.Compare(v1, v2) == -1) {
+	if cmpVersion(v1, v2) < 0 {
 		return v2
 	}
 	return v1
@@ -86,12 +105,12 @@ func versions(ctx context.Context, path string, allowed AllowedFunc) ([]string,
 	return versions, err
 }
 
-// Previous returns the tagged version of m.Path immediately prior to
+// previousVersion returns the tagged version of m.Path immediately prior to
 // m.Version, or version "none" if no prior version is tagged.
 //
 // Since the version of Target is not found in the version list,
 // it has no previous version.
-func (*mvsReqs) Previous(m module.Version) (module.Version, error) {
+func previousVersion(m module.Version) (module.Version, error) {
 	// TODO(golang.org/issue/38714): thread tracing context through MVS.
 
 	if m == Target {
@@ -111,3 +130,7 @@ func (*mvsReqs) Previous(m module.Version) (module.Version, error) {
 	}
 	return module.Version{Path: m.Path, Version: "none"}, nil
 }
+
+func (*mvsReqs) Previous(m module.Version) (module.Version, error) {
+	return previousVersion(m)
+}
diff --git a/src/cmd/go/testdata/script/mod_get_downup_artifact.txt b/src/cmd/go/testdata/script/mod_get_downup_artifact.txt
index b35d4c4fd0..c20583b22a 100644
--- a/src/cmd/go/testdata/script/mod_get_downup_artifact.txt
+++ b/src/cmd/go/testdata/script/mod_get_downup_artifact.txt
@@ -61,14 +61,8 @@ go list -m all
 stdout '^example.com/a v0.1.0 '
 stdout '^example.com/b v0.1.0 '
 stdout '^example.com/c v0.1.0 '
-
-	# BUG: d should remain at v0.1.0, because it is not transitively imported by a
-	# with b@v0.1.0. Today, it is spuriously upgraded to v0.2.0.
-stdout '^example.com/d v0.2.0 '
-
-	# BUG: e should not be added, because it is not transitively imported by a
-	# with b@v0.1.0. Today, it is spuriously added.
-stdout '^example.com/e v0.1.0 '
+stdout '^example.com/d v0.1.0 '
+! stdout '^example.com/e '
 
 -- go.mod --
 module example.com/m
-- 
GitLab


From 2ceb79db526eabff880a8a03caab07258883b216 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Mon, 22 Feb 2021 17:05:32 -0500
Subject: [PATCH 1020/2400] cmd/go/internal/modload: make EditBuildList report
 whether the build list was changed

For #36460

Change-Id: I8dd6e6f998a217a4287212815ce61209df6f007f
Reviewed-on: https://go-review.googlesource.com/c/go/+/296609
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modget/get.go        | 11 +++++------
 src/cmd/go/internal/modload/buildlist.go | 17 +++++++++++------
 src/cmd/go/internal/work/build.go        |  2 +-
 3 files changed, 17 insertions(+), 13 deletions(-)

diff --git a/src/cmd/go/internal/modget/get.go b/src/cmd/go/internal/modget/get.go
index 9340a582e5..6b416d3622 100644
--- a/src/cmd/go/internal/modget/get.go
+++ b/src/cmd/go/internal/modget/get.go
@@ -30,7 +30,6 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"reflect"
 	"runtime"
 	"sort"
 	"strings"
@@ -1635,7 +1634,8 @@ func (r *resolver) updateBuildList(ctx context.Context, additions []module.Versi
 		}
 	}
 
-	if err := modload.EditBuildList(ctx, additions, resolved); err != nil {
+	changed, err := modload.EditBuildList(ctx, additions, resolved)
+	if err != nil {
 		var constraint *modload.ConstraintError
 		if !errors.As(err, &constraint) {
 			base.Errorf("go get: %v", err)
@@ -1654,12 +1654,11 @@ func (r *resolver) updateBuildList(ctx context.Context, additions []module.Versi
 		}
 		return false
 	}
-
-	buildList := modload.LoadAllModules(ctx)
-	if reflect.DeepEqual(r.buildList, buildList) {
+	if !changed {
 		return false
 	}
-	r.buildList = buildList
+
+	r.buildList = modload.LoadAllModules(ctx)
 	r.buildListVersion = make(map[string]string, len(r.buildList))
 	for _, m := range r.buildList {
 		r.buildListVersion[m.Path] = m.Version
diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index 5de26357e1..3412548efc 100644
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -12,6 +12,7 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"reflect"
 	"strings"
 
 	"golang.org/x/mod/module"
@@ -81,12 +82,12 @@ func Selected(path string) (version string) {
 // If the versions listed in mustSelect are mutually incompatible (due to one of
 // the listed modules requiring a higher version of another), EditBuildList
 // returns a *ConstraintError and leaves the build list in its previous state.
-func EditBuildList(ctx context.Context, add, mustSelect []module.Version) error {
+func EditBuildList(ctx context.Context, add, mustSelect []module.Version) (changed bool, err error) {
 	LoadModFile(ctx)
 
 	final, err := editBuildList(ctx, buildList, add, mustSelect)
 	if err != nil {
-		return err
+		return false, err
 	}
 
 	selected := make(map[string]module.Version, len(final))
@@ -106,14 +107,18 @@ func EditBuildList(ctx context.Context, add, mustSelect []module.Version) error
 	}
 
 	if !inconsistent {
-		buildList = final
 		additionalExplicitRequirements = make([]string, 0, len(mustSelect))
 		for _, m := range mustSelect {
 			if m.Version != "none" {
 				additionalExplicitRequirements = append(additionalExplicitRequirements, m.Path)
 			}
 		}
-		return nil
+		changed := false
+		if !reflect.DeepEqual(buildList, final) {
+			buildList = final
+			changed = true
+		}
+		return changed, nil
 	}
 
 	// We overshot one or more of the modules in mustSelect, which means that
@@ -136,7 +141,7 @@ func EditBuildList(ctx context.Context, add, mustSelect []module.Version) error
 		m, queue = queue[0], queue[1:]
 		required, err := reqs.Required(m)
 		if err != nil {
-			return err
+			return false, err
 		}
 		for _, r := range required {
 			if _, ok := reason[r]; !ok {
@@ -164,7 +169,7 @@ func EditBuildList(ctx context.Context, add, mustSelect []module.Version) error
 		}
 	}
 
-	return &ConstraintError{
+	return false, &ConstraintError{
 		Conflicts: conflicts,
 	}
 }
diff --git a/src/cmd/go/internal/work/build.go b/src/cmd/go/internal/work/build.go
index 0e7af6d33f..a80eb27798 100644
--- a/src/cmd/go/internal/work/build.go
+++ b/src/cmd/go/internal/work/build.go
@@ -836,7 +836,7 @@ func installOutsideModule(ctx context.Context, args []string) {
 	// Since we are in NoRoot mode, the build list initially contains only
 	// the dummy command-line-arguments module. Add a requirement on the
 	// module that provides the packages named on the command line.
-	if err := modload.EditBuildList(ctx, nil, []module.Version{installMod}); err != nil {
+	if _, err := modload.EditBuildList(ctx, nil, []module.Version{installMod}); err != nil {
 		base.Fatalf("go install %s: %v", args[0], err)
 	}
 
-- 
GitLab


From f9ed8b3f1e180d3cd8534897103683e8165df5f0 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Wed, 28 Oct 2020 21:47:32 -0400
Subject: [PATCH 1021/2400] cmd/go/internal/mvs: factor out an incremental
 implementation

The new Graph type implements an incremental version of the MVS
algorithm, with requirements pushed in by the caller instead of pulled
by an internal MVS traversal.

To avoid redundancy going forward (and to ensure adequate test
coverage of the incremental implementation), the existing buildList
function is reimplemented in terms of Graph.

For #36460

Change-Id: Idd0b6ab8f17cc41d83a2a4c25a95f82e9ce1eab0
Reviewed-on: https://go-review.googlesource.com/c/go/+/244760
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/mvs/errors.go |  10 +-
 src/cmd/go/internal/mvs/graph.go  | 223 ++++++++++++++++++++++++++++++
 src/cmd/go/internal/mvs/mvs.go    | 167 +++++++---------------
 3 files changed, 282 insertions(+), 118 deletions(-)
 create mode 100644 src/cmd/go/internal/mvs/graph.go

diff --git a/src/cmd/go/internal/mvs/errors.go b/src/cmd/go/internal/mvs/errors.go
index 5564965fb5..bf183cea9e 100644
--- a/src/cmd/go/internal/mvs/errors.go
+++ b/src/cmd/go/internal/mvs/errors.go
@@ -31,13 +31,15 @@ type buildListErrorElem struct {
 // occurred at a module found along the given path of requirements and/or
 // upgrades, which must be non-empty.
 //
-// The isUpgrade function reports whether a path step is due to an upgrade.
-// A nil isUpgrade function indicates that none of the path steps are due to upgrades.
-func NewBuildListError(err error, path []module.Version, isUpgrade func(from, to module.Version) bool) *BuildListError {
+// The isVersionChange function reports whether a path step is due to an
+// explicit upgrade or downgrade (as opposed to an existing requirement in a
+// go.mod file). A nil isVersionChange function indicates that none of the path
+// steps are due to explicit version changes.
+func NewBuildListError(err error, path []module.Version, isVersionChange func(from, to module.Version) bool) *BuildListError {
 	stack := make([]buildListErrorElem, 0, len(path))
 	for len(path) > 1 {
 		reason := "requires"
-		if isUpgrade != nil && isUpgrade(path[0], path[1]) {
+		if isVersionChange != nil && isVersionChange(path[0], path[1]) {
 			reason = "updating to"
 		}
 		stack = append(stack, buildListErrorElem{
diff --git a/src/cmd/go/internal/mvs/graph.go b/src/cmd/go/internal/mvs/graph.go
new file mode 100644
index 0000000000..c5de4866bf
--- /dev/null
+++ b/src/cmd/go/internal/mvs/graph.go
@@ -0,0 +1,223 @@
+// Copyright 2020 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 mvs
+
+import (
+	"fmt"
+
+	"golang.org/x/mod/module"
+)
+
+// Graph implements an incremental version of the MVS algorithm, with the
+// requirements pushed by the caller instead of pulled by the MVS traversal.
+type Graph struct {
+	cmp   func(v1, v2 string) int
+	roots []module.Version
+
+	required map[module.Version][]module.Version
+
+	isRoot   map[module.Version]bool // contains true for roots and false for reachable non-roots
+	selected map[string]string       // path → version
+}
+
+// NewGraph returns an incremental MVS graph containing only a set of root
+// dependencies and using the given max function for version strings.
+//
+// The caller must ensure that the root slice is not modified while the Graph
+// may be in use.
+func NewGraph(cmp func(v1, v2 string) int, roots []module.Version) *Graph {
+	g := &Graph{
+		cmp:      cmp,
+		roots:    roots[:len(roots):len(roots)],
+		required: make(map[module.Version][]module.Version),
+		isRoot:   make(map[module.Version]bool),
+		selected: make(map[string]string),
+	}
+
+	for _, m := range roots {
+		g.isRoot[m] = true
+		if g.cmp(g.Selected(m.Path), m.Version) < 0 {
+			g.selected[m.Path] = m.Version
+		}
+	}
+
+	return g
+}
+
+// Require adds the information that module m requires all modules in reqs.
+// The reqs slice must not be modified after it is passed to Require.
+//
+// m must be reachable by some existing chain of requirements from g's target,
+// and Require must not have been called for it already.
+//
+// If any of the modules in reqs has the same path as g's target,
+// the target must have higher precedence than the version in req.
+func (g *Graph) Require(m module.Version, reqs []module.Version) {
+	// To help catch disconnected-graph bugs, enforce that all required versions
+	// are actually reachable from the roots (and therefore should affect the
+	// selected versions of the modules they name).
+	if _, reachable := g.isRoot[m]; !reachable {
+		panic(fmt.Sprintf("%v is not reachable from any root", m))
+	}
+
+	// Truncate reqs to its capacity to avoid aliasing bugs if it is later
+	// returned from RequiredBy and appended to.
+	reqs = reqs[:len(reqs):len(reqs)]
+
+	if _, dup := g.required[m]; dup {
+		panic(fmt.Sprintf("requirements of %v have already been set", m))
+	}
+	g.required[m] = reqs
+
+	for _, dep := range reqs {
+		// Mark dep reachable, regardless of whether it is selected.
+		if _, ok := g.isRoot[dep]; !ok {
+			g.isRoot[dep] = false
+		}
+
+		if g.cmp(g.Selected(dep.Path), dep.Version) < 0 {
+			g.selected[dep.Path] = dep.Version
+		}
+	}
+}
+
+// RequiredBy returns the slice of requirements passed to Require for m, if any,
+// with its capacity reduced to its length.
+// If Require has not been called for m, RequiredBy(m) returns ok=false.
+//
+// The caller must not modify the returned slice, but may safely append to it
+// and may rely on it not to be modified.
+func (g *Graph) RequiredBy(m module.Version) (reqs []module.Version, ok bool) {
+	reqs, ok = g.required[m]
+	return reqs, ok
+}
+
+// Selected returns the selected version of the given module path.
+//
+// If no version is selected, Selected returns version "none".
+func (g *Graph) Selected(path string) (version string) {
+	v, ok := g.selected[path]
+	if !ok {
+		return "none"
+	}
+	return v
+}
+
+// BuildList returns the selected versions of all modules present in the Graph,
+// beginning with the selected versions of each module path in the roots of g.
+//
+// The order of the remaining elements in the list is deterministic
+// but arbitrary.
+func (g *Graph) BuildList() []module.Version {
+	seenRoot := make(map[string]bool, len(g.roots))
+
+	var list []module.Version
+	for _, r := range g.roots {
+		if seenRoot[r.Path] {
+			// Multiple copies of the same root, with the same or different versions,
+			// are a bit of a degenerate case: we will take the transitive
+			// requirements of both roots into account, but only the higher one can
+			// possibly be selected. However — especially given that we need the
+			// seenRoot map for later anyway — it is simpler to support this
+			// degenerate case than to forbid it.
+			continue
+		}
+
+		if v := g.Selected(r.Path); v != "none" {
+			list = append(list, module.Version{Path: r.Path, Version: v})
+		}
+		seenRoot[r.Path] = true
+	}
+	uniqueRoots := list
+
+	for path, version := range g.selected {
+		if !seenRoot[path] {
+			list = append(list, module.Version{Path: path, Version: version})
+		}
+	}
+	module.Sort(list[len(uniqueRoots):])
+
+	return list
+}
+
+// WalkBreadthFirst invokes f once, in breadth-first order, for each module
+// version other than "none" that appears in the graph, regardless of whether
+// that version is selected.
+func (g *Graph) WalkBreadthFirst(f func(m module.Version)) {
+	var queue []module.Version
+	enqueued := make(map[module.Version]bool)
+	for _, m := range g.roots {
+		if m.Version != "none" {
+			queue = append(queue, m)
+			enqueued[m] = true
+		}
+	}
+
+	for len(queue) > 0 {
+		m := queue[0]
+		queue = queue[1:]
+
+		f(m)
+
+		reqs, _ := g.RequiredBy(m)
+		for _, r := range reqs {
+			if !enqueued[r] && r.Version != "none" {
+				queue = append(queue, r)
+				enqueued[r] = true
+			}
+		}
+	}
+}
+
+// FindPath reports a shortest requirement path starting at one of the roots of
+// the graph and ending at a module version m for which f(m) returns true, or
+// nil if no such path exists.
+func (g *Graph) FindPath(f func(module.Version) bool) []module.Version {
+	// firstRequires[a] = b means that in a breadth-first traversal of the
+	// requirement graph, the module version a was first required by b.
+	firstRequires := make(map[module.Version]module.Version)
+
+	queue := g.roots
+	for _, m := range g.roots {
+		firstRequires[m] = module.Version{}
+	}
+
+	for len(queue) > 0 {
+		m := queue[0]
+		queue = queue[1:]
+
+		if f(m) {
+			// Construct the path reversed (because we're starting from the far
+			// endpoint), then reverse it.
+			path := []module.Version{m}
+			for {
+				m = firstRequires[m]
+				if m.Path == "" {
+					break
+				}
+				path = append(path, m)
+			}
+
+			i, j := 0, len(path)-1
+			for i < j {
+				path[i], path[j] = path[j], path[i]
+				i++
+				j--
+			}
+
+			return path
+		}
+
+		reqs, _ := g.RequiredBy(m)
+		for _, r := range reqs {
+			if _, seen := firstRequires[r]; !seen {
+				queue = append(queue, r)
+				firstRequires[r] = m
+			}
+		}
+	}
+
+	return nil
+}
diff --git a/src/cmd/go/internal/mvs/mvs.go b/src/cmd/go/internal/mvs/mvs.go
index e30a40c97e..6969f90f2e 100644
--- a/src/cmd/go/internal/mvs/mvs.go
+++ b/src/cmd/go/internal/mvs/mvs.go
@@ -10,7 +10,6 @@ import (
 	"fmt"
 	"sort"
 	"sync"
-	"sync/atomic"
 
 	"cmd/go/internal/par"
 
@@ -91,151 +90,91 @@ func BuildList(target module.Version, reqs Reqs) ([]module.Version, error) {
 }
 
 func buildList(target module.Version, reqs Reqs, upgrade func(module.Version) (module.Version, error)) ([]module.Version, error) {
-	// Explore work graph in parallel in case reqs.Required
-	// does high-latency network operations.
-	type modGraphNode struct {
-		m        module.Version
-		required []module.Version
-		upgrade  module.Version
-		err      error
+	cmp := func(v1, v2 string) int {
+		if reqs.Max(v1, v2) != v1 {
+			return -1
+		}
+		if reqs.Max(v2, v1) != v2 {
+			return 1
+		}
+		return 0
 	}
+
 	var (
 		mu       sync.Mutex
-		modGraph = map[module.Version]*modGraphNode{}
-		min      = map[string]string{} // maps module path to minimum required version
-		haveErr  int32
+		g        = NewGraph(cmp, []module.Version{target})
+		upgrades = map[module.Version]module.Version{}
+		errs     = map[module.Version]error{} // (non-nil errors only)
 	)
-	setErr := func(n *modGraphNode, err error) {
-		n.err = err
-		atomic.StoreInt32(&haveErr, 1)
-	}
 
+	// Explore work graph in parallel in case reqs.Required
+	// does high-latency network operations.
 	var work par.Work
 	work.Add(target)
 	work.Do(10, func(item interface{}) {
 		m := item.(module.Version)
 
-		node := &modGraphNode{m: m}
-		mu.Lock()
-		modGraph[m] = node
+		var required []module.Version
+		var err error
 		if m.Version != "none" {
-			if v, ok := min[m.Path]; !ok || reqs.Max(v, m.Version) != v {
-				min[m.Path] = m.Version
-			}
+			required, err = reqs.Required(m)
 		}
-		mu.Unlock()
 
-		if m.Version != "none" {
-			required, err := reqs.Required(m)
-			if err != nil {
-				setErr(node, err)
-				return
-			}
-			node.required = required
-			for _, r := range node.required {
-				work.Add(r)
+		u := m
+		if upgrade != nil {
+			upgradeTo, upErr := upgrade(m)
+			if upErr == nil {
+				u = upgradeTo
+			} else if err == nil {
+				err = upErr
 			}
 		}
 
-		if upgrade != nil {
-			u, err := upgrade(m)
-			if err != nil {
-				setErr(node, err)
-				return
-			}
-			if u != m {
-				node.upgrade = u
-				work.Add(u)
-			}
+		mu.Lock()
+		if err != nil {
+			errs[m] = err
+		}
+		if u != m {
+			upgrades[m] = u
+			required = append([]module.Version{u}, required...)
+		}
+		g.Require(m, required)
+		mu.Unlock()
+
+		for _, r := range required {
+			work.Add(r)
 		}
 	})
 
 	// If there was an error, find the shortest path from the target to the
 	// node where the error occurred so we can report a useful error message.
-	if haveErr != 0 {
-		// neededBy[a] = b means a was added to the module graph by b.
-		neededBy := make(map[*modGraphNode]*modGraphNode)
-		q := make([]*modGraphNode, 0, len(modGraph))
-		q = append(q, modGraph[target])
-		for len(q) > 0 {
-			node := q[0]
-			q = q[1:]
-
-			if node.err != nil {
-				pathUpgrade := map[module.Version]module.Version{}
-
-				// Construct the error path reversed (from the error to the main module),
-				// then reverse it to obtain the usual order (from the main module to
-				// the error).
-				errPath := []module.Version{node.m}
-				for n, prev := neededBy[node], node; n != nil; n, prev = neededBy[n], n {
-					if n.upgrade == prev.m {
-						pathUpgrade[n.m] = prev.m
-					}
-					errPath = append(errPath, n.m)
-				}
-				i, j := 0, len(errPath)-1
-				for i < j {
-					errPath[i], errPath[j] = errPath[j], errPath[i]
-					i++
-					j--
-				}
-
-				isUpgrade := func(from, to module.Version) bool {
-					return pathUpgrade[from] == to
-				}
-
-				return nil, NewBuildListError(node.err, errPath, isUpgrade)
-			}
+	if len(errs) > 0 {
+		errPath := g.FindPath(func(m module.Version) bool {
+			return errs[m] != nil
+		})
+		if len(errPath) == 0 {
+			panic("internal error: could not reconstruct path to module with error")
+		}
 
-			neighbors := node.required
-			if node.upgrade.Path != "" {
-				neighbors = append(neighbors, node.upgrade)
-			}
-			for _, neighbor := range neighbors {
-				nn := modGraph[neighbor]
-				if neededBy[nn] != nil {
-					continue
-				}
-				neededBy[nn] = node
-				q = append(q, nn)
+		err := errs[errPath[len(errPath)-1]]
+		isUpgrade := func(from, to module.Version) bool {
+			if u, ok := upgrades[from]; ok {
+				return u == to
 			}
+			return false
 		}
+		return nil, NewBuildListError(err.(error), errPath, isUpgrade)
 	}
 
 	// The final list is the minimum version of each module found in the graph.
-
-	if v := min[target.Path]; v != target.Version {
+	list := g.BuildList()
+	if v := list[0]; v != target {
 		// target.Version will be "" for modload, the main client of MVS.
 		// "" denotes the main module, which has no version. However, MVS treats
 		// version strings as opaque, so "" is not a special value here.
 		// See golang.org/issue/31491, golang.org/issue/29773.
-		panic(fmt.Sprintf("mistake: chose version %q instead of target %+v", v, target)) // TODO: Don't panic.
+		panic(fmt.Sprintf("mistake: chose version %q instead of target %+v", v, target))
 	}
-
-	list := []module.Version{target}
-	for path, vers := range min {
-		if path != target.Path {
-			list = append(list, module.Version{Path: path, Version: vers})
-		}
-
-		n := modGraph[module.Version{Path: path, Version: vers}]
-		required := n.required
-		for _, r := range required {
-			if r.Version == "none" {
-				continue
-			}
-			v := min[r.Path]
-			if r.Path != target.Path && reqs.Max(v, r.Version) != v {
-				panic(fmt.Sprintf("mistake: version %q does not satisfy requirement %+v", v, r)) // TODO: Don't panic.
-			}
-		}
-	}
-
-	tail := list[1:]
-	sort.Slice(tail, func(i, j int) bool {
-		return tail[i].Path < tail[j].Path
-	})
 	return list, nil
 }
 
-- 
GitLab


From aa26687e457d825fc9c580e8c029b768e0e70d38 Mon Sep 17 00:00:00 2001
From: Michael Pratt <mpratt@google.com>
Date: Wed, 10 Mar 2021 16:06:47 -0500
Subject: [PATCH 1022/2400] runtime, time: disable preemption in addtimer

The timerpMask optimization updates a mask of Ps (potentially)
containing timers in pidleget / pidleput. For correctness, it depends on
the assumption that new timers can only be added to a P's own heap.

addtimer violates this assumption if it is preempted after computing pp.
That G may then run on a different P, but adding a timer to the original
P's heap.

Avoid this by disabling preemption while pp is in use.

Other uses of doaddtimer should be OK:

* moveTimers: always moves to the current P's heap
* modtimer, cleantimers, addAdjustedTimers, runtimer: does not add net
  new timers to the heap while locked

Fixes #44868

Change-Id: I4a5d080865e854931d0a3a09a51ca36879101d72
Reviewed-on: https://go-review.googlesource.com/c/go/+/300610
Trust: Michael Pratt <mpratt@google.com>
Run-TryBot: Michael Pratt <mpratt@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/time.go    |  5 +++++
 src/time/sleep_test.go | 16 ++++++++++++++++
 2 files changed, 21 insertions(+)

diff --git a/src/runtime/time.go b/src/runtime/time.go
index 8ab2a03430..dee6a674e4 100644
--- a/src/runtime/time.go
+++ b/src/runtime/time.go
@@ -263,6 +263,9 @@ func addtimer(t *timer) {
 
 	when := t.when
 
+	// Disable preemption while using pp to avoid changing another P's heap.
+	mp := acquirem()
+
 	pp := getg().m.p.ptr()
 	lock(&pp.timersLock)
 	cleantimers(pp)
@@ -270,6 +273,8 @@ func addtimer(t *timer) {
 	unlock(&pp.timersLock)
 
 	wakeNetPoller(when)
+
+	releasem(mp)
 }
 
 // doaddtimer adds t to the current P's heap.
diff --git a/src/time/sleep_test.go b/src/time/sleep_test.go
index 084ac33f51..6ee0631a85 100644
--- a/src/time/sleep_test.go
+++ b/src/time/sleep_test.go
@@ -511,6 +511,22 @@ func TestZeroTimerStopPanics(t *testing.T) {
 	tr.Stop()
 }
 
+// Test that zero duration timers aren't missed by the scheduler. Regression test for issue 44868.
+func TestZeroTimer(t *testing.T) {
+	if testing.Short() {
+		t.Skip("-short")
+	}
+
+	for i := 0; i < 1000000; i++ {
+		s := Now()
+		ti := NewTimer(0)
+		<-ti.C
+		if diff := Since(s); diff > 2*Second {
+			t.Errorf("Expected time to get value from Timer channel in less than 2 sec, took %v", diff)
+		}
+	}
+}
+
 // Benchmark timer latency when the thread that creates the timer is busy with
 // other work and the timers must be serviced by other threads.
 // https://golang.org/issue/38860
-- 
GitLab


From 1bad3831a0afe76d3403f564e89be6b76f8c6d98 Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Tue, 9 Mar 2021 16:54:56 -0600
Subject: [PATCH 1023/2400] cmd/internal/obj: remove param element from ppc64
 optab

This is rarely used, and is implied based on the
memory type of the operand.  This is a step towards
simplifying the MOV* pseudo opcodes on ppc64.

Similarly, remove the bogus param value from AVMULESB.

Change-Id: Ibad4d045ec6d8c5163a468b2db1dfb762ef674ee
Reviewed-on: https://go-review.googlesource.com/c/go/+/300177
Run-TryBot: Paul Murphy <murp@ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
Trust: Ian Lance Taylor <iant@golang.org>
---
 src/cmd/internal/obj/ppc64/asm9.go | 257 +++++++++++++++--------------
 1 file changed, 136 insertions(+), 121 deletions(-)

diff --git a/src/cmd/internal/obj/ppc64/asm9.go b/src/cmd/internal/obj/ppc64/asm9.go
index 648a41b5c7..e979cabddf 100644
--- a/src/cmd/internal/obj/ppc64/asm9.go
+++ b/src/cmd/internal/obj/ppc64/asm9.go
@@ -72,7 +72,6 @@ type Optab struct {
 	a6    uint8  // p.To (obj.Addr)
 	type_ int8   // cases in asmout below. E.g., 44 = st r,(ra+rb); 45 = ld (ra+rb), r
 	size  int8   // Text space in bytes to lay operation
-	param int16  // Implied base register for pseudo-registers
 }
 
 // optab contains an array to be sliced of accepted operand combinations for an
@@ -202,73 +201,73 @@ var optab = []Optab{
 	{as: AFMUL, a1: C_FREG, a2: C_FREG, a6: C_FREG, type_: 32, size: 4},
 
 	/* store, short offset */
-	{as: AMOVD, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVW, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVWZ, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVBZ, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVBZU, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVB, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVBU, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVD, a1: C_REG, a6: C_SEXT, type_: 7, size: 4, param: REGSB},
-	{as: AMOVW, a1: C_REG, a6: C_SEXT, type_: 7, size: 4, param: REGSB},
-	{as: AMOVWZ, a1: C_REG, a6: C_SEXT, type_: 7, size: 4, param: REGSB},
-	{as: AMOVBZ, a1: C_REG, a6: C_SEXT, type_: 7, size: 4, param: REGSB},
-	{as: AMOVB, a1: C_REG, a6: C_SEXT, type_: 7, size: 4, param: REGSB},
-	{as: AMOVD, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4, param: REGSP},
-	{as: AMOVW, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4, param: REGSP},
-	{as: AMOVWZ, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4, param: REGSP},
-	{as: AMOVBZ, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4, param: REGSP},
-	{as: AMOVB, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4, param: REGSP},
-	{as: AMOVD, a1: C_REG, a6: C_SOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVW, a1: C_REG, a6: C_SOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVWZ, a1: C_REG, a6: C_SOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVBZ, a1: C_REG, a6: C_SOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVBZU, a1: C_REG, a6: C_SOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVB, a1: C_REG, a6: C_SOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AMOVBU, a1: C_REG, a6: C_SOREG, type_: 7, size: 4, param: REGZERO},
+	{as: AMOVD, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
+	{as: AMOVW, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
+	{as: AMOVWZ, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
+	{as: AMOVBZ, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
+	{as: AMOVBZU, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
+	{as: AMOVB, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
+	{as: AMOVBU, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
+	{as: AMOVD, a1: C_REG, a6: C_SEXT, type_: 7, size: 4},
+	{as: AMOVW, a1: C_REG, a6: C_SEXT, type_: 7, size: 4},
+	{as: AMOVWZ, a1: C_REG, a6: C_SEXT, type_: 7, size: 4},
+	{as: AMOVBZ, a1: C_REG, a6: C_SEXT, type_: 7, size: 4},
+	{as: AMOVB, a1: C_REG, a6: C_SEXT, type_: 7, size: 4},
+	{as: AMOVD, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4},
+	{as: AMOVW, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4},
+	{as: AMOVWZ, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4},
+	{as: AMOVBZ, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4},
+	{as: AMOVB, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4},
+	{as: AMOVD, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
+	{as: AMOVW, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
+	{as: AMOVWZ, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
+	{as: AMOVBZ, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
+	{as: AMOVBZU, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
+	{as: AMOVB, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
+	{as: AMOVBU, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 
 	/* load, short offset */
-	{as: AMOVD, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4, param: REGZERO},
-	{as: AMOVW, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4, param: REGZERO},
-	{as: AMOVWZ, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4, param: REGZERO},
-	{as: AMOVBZ, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4, param: REGZERO},
-	{as: AMOVBZU, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4, param: REGZERO},
-	{as: AMOVB, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 9, size: 8, param: REGZERO},
-	{as: AMOVBU, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 9, size: 8, param: REGZERO},
-	{as: AMOVD, a1: C_SEXT, a6: C_REG, type_: 8, size: 4, param: REGSB},
-	{as: AMOVW, a1: C_SEXT, a6: C_REG, type_: 8, size: 4, param: REGSB},
-	{as: AMOVWZ, a1: C_SEXT, a6: C_REG, type_: 8, size: 4, param: REGSB},
-	{as: AMOVBZ, a1: C_SEXT, a6: C_REG, type_: 8, size: 4, param: REGSB},
-	{as: AMOVB, a1: C_SEXT, a6: C_REG, type_: 9, size: 8, param: REGSB},
-	{as: AMOVD, a1: C_SAUTO, a6: C_REG, type_: 8, size: 4, param: REGSP},
-	{as: AMOVW, a1: C_SAUTO, a6: C_REG, type_: 8, size: 4, param: REGSP},
-	{as: AMOVWZ, a1: C_SAUTO, a6: C_REG, type_: 8, size: 4, param: REGSP},
-	{as: AMOVBZ, a1: C_SAUTO, a6: C_REG, type_: 8, size: 4, param: REGSP},
-	{as: AMOVB, a1: C_SAUTO, a6: C_REG, type_: 9, size: 8, param: REGSP},
-	{as: AMOVD, a1: C_SOREG, a6: C_REG, type_: 8, size: 4, param: REGZERO},
-	{as: AMOVW, a1: C_SOREG, a6: C_REG, type_: 8, size: 4, param: REGZERO},
-	{as: AMOVWZ, a1: C_SOREG, a6: C_REG, type_: 8, size: 4, param: REGZERO},
-	{as: AMOVBZ, a1: C_SOREG, a6: C_REG, type_: 8, size: 4, param: REGZERO},
-	{as: AMOVBZU, a1: C_SOREG, a6: C_REG, type_: 8, size: 4, param: REGZERO},
-	{as: AMOVB, a1: C_SOREG, a6: C_REG, type_: 9, size: 8, param: REGZERO},
-	{as: AMOVBU, a1: C_SOREG, a6: C_REG, type_: 9, size: 8, param: REGZERO},
+	{as: AMOVD, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVW, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVWZ, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVBZ, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVBZU, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVB, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 9, size: 8},
+	{as: AMOVBU, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 9, size: 8},
+	{as: AMOVD, a1: C_SEXT, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVW, a1: C_SEXT, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVWZ, a1: C_SEXT, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVBZ, a1: C_SEXT, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVB, a1: C_SEXT, a6: C_REG, type_: 9, size: 8},
+	{as: AMOVD, a1: C_SAUTO, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVW, a1: C_SAUTO, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVWZ, a1: C_SAUTO, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVBZ, a1: C_SAUTO, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVB, a1: C_SAUTO, a6: C_REG, type_: 9, size: 8},
+	{as: AMOVD, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVW, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVWZ, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVBZ, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVBZU, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVB, a1: C_SOREG, a6: C_REG, type_: 9, size: 8},
+	{as: AMOVBU, a1: C_SOREG, a6: C_REG, type_: 9, size: 8},
 
 	/* store, long offset */
-	{as: AMOVD, a1: C_REG, a6: C_LEXT, type_: 35, size: 8, param: REGSB},
-	{as: AMOVW, a1: C_REG, a6: C_LEXT, type_: 35, size: 8, param: REGSB},
-	{as: AMOVWZ, a1: C_REG, a6: C_LEXT, type_: 35, size: 8, param: REGSB},
-	{as: AMOVBZ, a1: C_REG, a6: C_LEXT, type_: 35, size: 8, param: REGSB},
-	{as: AMOVB, a1: C_REG, a6: C_LEXT, type_: 35, size: 8, param: REGSB},
-	{as: AMOVD, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8, param: REGSP},
-	{as: AMOVW, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8, param: REGSP},
-	{as: AMOVWZ, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8, param: REGSP},
-	{as: AMOVBZ, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8, param: REGSP},
-	{as: AMOVB, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8, param: REGSP},
-	{as: AMOVD, a1: C_REG, a6: C_LOREG, type_: 35, size: 8, param: REGZERO},
-	{as: AMOVW, a1: C_REG, a6: C_LOREG, type_: 35, size: 8, param: REGZERO},
-	{as: AMOVWZ, a1: C_REG, a6: C_LOREG, type_: 35, size: 8, param: REGZERO},
-	{as: AMOVBZ, a1: C_REG, a6: C_LOREG, type_: 35, size: 8, param: REGZERO},
-	{as: AMOVB, a1: C_REG, a6: C_LOREG, type_: 35, size: 8, param: REGZERO},
+	{as: AMOVD, a1: C_REG, a6: C_LEXT, type_: 35, size: 8},
+	{as: AMOVW, a1: C_REG, a6: C_LEXT, type_: 35, size: 8},
+	{as: AMOVWZ, a1: C_REG, a6: C_LEXT, type_: 35, size: 8},
+	{as: AMOVBZ, a1: C_REG, a6: C_LEXT, type_: 35, size: 8},
+	{as: AMOVB, a1: C_REG, a6: C_LEXT, type_: 35, size: 8},
+	{as: AMOVD, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8},
+	{as: AMOVW, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8},
+	{as: AMOVWZ, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8},
+	{as: AMOVBZ, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8},
+	{as: AMOVB, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8},
+	{as: AMOVD, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
+	{as: AMOVW, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
+	{as: AMOVWZ, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
+	{as: AMOVBZ, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
+	{as: AMOVB, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
 	{as: AMOVD, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 	{as: AMOVW, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 	{as: AMOVWZ, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
@@ -276,21 +275,21 @@ var optab = []Optab{
 	{as: AMOVB, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 
 	/* load, long offset */
-	{as: AMOVD, a1: C_LEXT, a6: C_REG, type_: 36, size: 8, param: REGSB},
-	{as: AMOVW, a1: C_LEXT, a6: C_REG, type_: 36, size: 8, param: REGSB},
-	{as: AMOVWZ, a1: C_LEXT, a6: C_REG, type_: 36, size: 8, param: REGSB},
-	{as: AMOVBZ, a1: C_LEXT, a6: C_REG, type_: 36, size: 8, param: REGSB},
-	{as: AMOVB, a1: C_LEXT, a6: C_REG, type_: 37, size: 12, param: REGSB},
-	{as: AMOVD, a1: C_LAUTO, a6: C_REG, type_: 36, size: 8, param: REGSP},
-	{as: AMOVW, a1: C_LAUTO, a6: C_REG, type_: 36, size: 8, param: REGSP},
-	{as: AMOVWZ, a1: C_LAUTO, a6: C_REG, type_: 36, size: 8, param: REGSP},
-	{as: AMOVBZ, a1: C_LAUTO, a6: C_REG, type_: 36, size: 8, param: REGSP},
-	{as: AMOVB, a1: C_LAUTO, a6: C_REG, type_: 37, size: 12, param: REGSP},
-	{as: AMOVD, a1: C_LOREG, a6: C_REG, type_: 36, size: 8, param: REGZERO},
-	{as: AMOVW, a1: C_LOREG, a6: C_REG, type_: 36, size: 8, param: REGZERO},
-	{as: AMOVWZ, a1: C_LOREG, a6: C_REG, type_: 36, size: 8, param: REGZERO},
-	{as: AMOVBZ, a1: C_LOREG, a6: C_REG, type_: 36, size: 8, param: REGZERO},
-	{as: AMOVB, a1: C_LOREG, a6: C_REG, type_: 37, size: 12, param: REGZERO},
+	{as: AMOVD, a1: C_LEXT, a6: C_REG, type_: 36, size: 8},
+	{as: AMOVW, a1: C_LEXT, a6: C_REG, type_: 36, size: 8},
+	{as: AMOVWZ, a1: C_LEXT, a6: C_REG, type_: 36, size: 8},
+	{as: AMOVBZ, a1: C_LEXT, a6: C_REG, type_: 36, size: 8},
+	{as: AMOVB, a1: C_LEXT, a6: C_REG, type_: 37, size: 12},
+	{as: AMOVD, a1: C_LAUTO, a6: C_REG, type_: 36, size: 8},
+	{as: AMOVW, a1: C_LAUTO, a6: C_REG, type_: 36, size: 8},
+	{as: AMOVWZ, a1: C_LAUTO, a6: C_REG, type_: 36, size: 8},
+	{as: AMOVBZ, a1: C_LAUTO, a6: C_REG, type_: 36, size: 8},
+	{as: AMOVB, a1: C_LAUTO, a6: C_REG, type_: 37, size: 12},
+	{as: AMOVD, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
+	{as: AMOVW, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
+	{as: AMOVWZ, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
+	{as: AMOVBZ, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
+	{as: AMOVB, a1: C_LOREG, a6: C_REG, type_: 37, size: 12},
 	{as: AMOVD, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
 	{as: AMOVW, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
 	{as: AMOVWZ, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
@@ -304,31 +303,31 @@ var optab = []Optab{
 	{as: AMOVD, a1: C_TOCADDR, a6: C_REG, type_: 95, size: 8},
 
 	/* load constant */
-	{as: AMOVD, a1: C_SECON, a6: C_REG, type_: 3, size: 4, param: REGSB},
-	{as: AMOVD, a1: C_SACON, a6: C_REG, type_: 3, size: 4, param: REGSP},
-	{as: AMOVD, a1: C_LECON, a6: C_REG, type_: 26, size: 8, param: REGSB},
-	{as: AMOVD, a1: C_LACON, a6: C_REG, type_: 26, size: 8, param: REGSP},
-	{as: AMOVD, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4, param: REGZERO},
-	{as: AMOVD, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4, param: REGZERO},
-	{as: AMOVW, a1: C_SECON, a6: C_REG, type_: 3, size: 4, param: REGSB}, /* TO DO: check */
-	{as: AMOVW, a1: C_SACON, a6: C_REG, type_: 3, size: 4, param: REGSP},
-	{as: AMOVW, a1: C_LECON, a6: C_REG, type_: 26, size: 8, param: REGSB},
-	{as: AMOVW, a1: C_LACON, a6: C_REG, type_: 26, size: 8, param: REGSP},
-	{as: AMOVW, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4, param: REGZERO},
-	{as: AMOVW, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4, param: REGZERO},
-	{as: AMOVWZ, a1: C_SECON, a6: C_REG, type_: 3, size: 4, param: REGSB}, /* TO DO: check */
-	{as: AMOVWZ, a1: C_SACON, a6: C_REG, type_: 3, size: 4, param: REGSP},
-	{as: AMOVWZ, a1: C_LECON, a6: C_REG, type_: 26, size: 8, param: REGSB},
-	{as: AMOVWZ, a1: C_LACON, a6: C_REG, type_: 26, size: 8, param: REGSP},
-	{as: AMOVWZ, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4, param: REGZERO},
-	{as: AMOVWZ, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4, param: REGZERO},
+	{as: AMOVD, a1: C_SECON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVD, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVD, a1: C_LECON, a6: C_REG, type_: 26, size: 8},
+	{as: AMOVD, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
+	{as: AMOVD, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVD, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVW, a1: C_SECON, a6: C_REG, type_: 3, size: 4}, /* TO DO: check */
+	{as: AMOVW, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVW, a1: C_LECON, a6: C_REG, type_: 26, size: 8},
+	{as: AMOVW, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
+	{as: AMOVW, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVW, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVWZ, a1: C_SECON, a6: C_REG, type_: 3, size: 4}, /* TO DO: check */
+	{as: AMOVWZ, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVWZ, a1: C_LECON, a6: C_REG, type_: 26, size: 8},
+	{as: AMOVWZ, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
+	{as: AMOVWZ, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVWZ, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4},
 
 	/* load unsigned/long constants (TO DO: check) */
-	{as: AMOVD, a1: C_UCON, a6: C_REG, type_: 3, size: 4, param: REGZERO},
+	{as: AMOVD, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
 	{as: AMOVD, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
-	{as: AMOVW, a1: C_UCON, a6: C_REG, type_: 3, size: 4, param: REGZERO},
+	{as: AMOVW, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
 	{as: AMOVW, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
-	{as: AMOVWZ, a1: C_UCON, a6: C_REG, type_: 3, size: 4, param: REGZERO},
+	{as: AMOVWZ, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
 	{as: AMOVWZ, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
 	{as: AMOVHBR, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 45, size: 4},
 	{as: AMOVHBR, a1: C_ZOREG, a6: C_REG, type_: 45, size: 4},
@@ -353,21 +352,21 @@ var optab = []Optab{
 	{as: ABC, a1: C_SCON, a2: C_REG, a6: C_LR, type_: 18, size: 4},
 	{as: ABC, a1: C_SCON, a2: C_REG, a6: C_CTR, type_: 18, size: 4},
 	{as: ABC, a6: C_ZOREG, type_: 15, size: 8},
-	{as: AFMOVD, a1: C_SEXT, a6: C_FREG, type_: 8, size: 4, param: REGSB},
-	{as: AFMOVD, a1: C_SAUTO, a6: C_FREG, type_: 8, size: 4, param: REGSP},
-	{as: AFMOVD, a1: C_SOREG, a6: C_FREG, type_: 8, size: 4, param: REGZERO},
-	{as: AFMOVD, a1: C_LEXT, a6: C_FREG, type_: 36, size: 8, param: REGSB},
-	{as: AFMOVD, a1: C_LAUTO, a6: C_FREG, type_: 36, size: 8, param: REGSP},
-	{as: AFMOVD, a1: C_LOREG, a6: C_FREG, type_: 36, size: 8, param: REGZERO},
+	{as: AFMOVD, a1: C_SEXT, a6: C_FREG, type_: 8, size: 4},
+	{as: AFMOVD, a1: C_SAUTO, a6: C_FREG, type_: 8, size: 4},
+	{as: AFMOVD, a1: C_SOREG, a6: C_FREG, type_: 8, size: 4},
+	{as: AFMOVD, a1: C_LEXT, a6: C_FREG, type_: 36, size: 8},
+	{as: AFMOVD, a1: C_LAUTO, a6: C_FREG, type_: 36, size: 8},
+	{as: AFMOVD, a1: C_LOREG, a6: C_FREG, type_: 36, size: 8},
 	{as: AFMOVD, a1: C_ZCON, a6: C_FREG, type_: 24, size: 4},
 	{as: AFMOVD, a1: C_ADDCON, a6: C_FREG, type_: 24, size: 8},
 	{as: AFMOVD, a1: C_ADDR, a6: C_FREG, type_: 75, size: 8},
-	{as: AFMOVD, a1: C_FREG, a6: C_SEXT, type_: 7, size: 4, param: REGSB},
-	{as: AFMOVD, a1: C_FREG, a6: C_SAUTO, type_: 7, size: 4, param: REGSP},
-	{as: AFMOVD, a1: C_FREG, a6: C_SOREG, type_: 7, size: 4, param: REGZERO},
-	{as: AFMOVD, a1: C_FREG, a6: C_LEXT, type_: 35, size: 8, param: REGSB},
-	{as: AFMOVD, a1: C_FREG, a6: C_LAUTO, type_: 35, size: 8, param: REGSP},
-	{as: AFMOVD, a1: C_FREG, a6: C_LOREG, type_: 35, size: 8, param: REGZERO},
+	{as: AFMOVD, a1: C_FREG, a6: C_SEXT, type_: 7, size: 4},
+	{as: AFMOVD, a1: C_FREG, a6: C_SAUTO, type_: 7, size: 4},
+	{as: AFMOVD, a1: C_FREG, a6: C_SOREG, type_: 7, size: 4},
+	{as: AFMOVD, a1: C_FREG, a6: C_LEXT, type_: 35, size: 8},
+	{as: AFMOVD, a1: C_FREG, a6: C_LAUTO, type_: 35, size: 8},
+	{as: AFMOVD, a1: C_FREG, a6: C_LOREG, type_: 35, size: 8},
 	{as: AFMOVD, a1: C_FREG, a6: C_ADDR, type_: 74, size: 8},
 	{as: AFMOVSX, a1: C_ZOREG, a2: C_REG, a6: C_FREG, type_: 45, size: 4},
 	{as: AFMOVSX, a1: C_ZOREG, a6: C_FREG, type_: 45, size: 4},
@@ -442,7 +441,7 @@ var optab = []Optab{
 	{as: AVSUBE, a1: C_VREG, a2: C_VREG, a3: C_VREG, a6: C_VREG, type_: 83, size: 4}, /* vector subtract extended, va-form */
 
 	/* Vector multiply */
-	{as: AVMULESB, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4, param: 9},    /* vector multiply, vx-form */
+	{as: AVMULESB, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},              /* vector multiply, vx-form */
 	{as: AVPMSUM, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},               /* vector polynomial multiply & sum, vx-form */
 	{as: AVMSUMUDM, a1: C_VREG, a2: C_VREG, a3: C_VREG, a6: C_VREG, type_: 83, size: 4}, /* vector multiply-sum, va-form */
 
@@ -684,6 +683,22 @@ func addpad(pc, a int64, ctxt *obj.Link, cursym *obj.LSym) int {
 	return 0
 }
 
+// Get the implied register of a operand which doesn't specify one.  These show up
+// in handwritten asm like "MOVD R5, foosymbol" where a base register is not supplied,
+// or "MOVD R5, foo+10(SP) or pseudo-register is used.  The other common case is when
+// generating constants in register like "MOVD $constant, Rx".
+func getimpliedreg(a *obj.Addr) int {
+	switch oclass(a) {
+	case C_ZOREG, C_SOREG, C_LOREG, C_ADDCON, C_ANDCON, C_UCON, C_SCON, C_LCON:
+		return REGZERO
+	case C_SEXT, C_LEXT, C_SECON, C_LECON:
+		return REGSB
+	case C_SAUTO, C_LAUTO, C_SACON, C_LACON:
+		return REGSP
+	}
+	return 0
+}
+
 func span9(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 	p := cursym.Func().Text
 	if p == nil || p.Link == nil { // handle external functions and ELF section symbols
@@ -2506,7 +2521,7 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		v := int32(d)
 		r := int(p.From.Reg)
 		if r == 0 {
-			r = int(o.param)
+			r = getimpliedreg(&p.From)
 		}
 		if r0iszero != 0 /*TypeKind(100016)*/ && p.To.Reg == 0 && (r != 0 || v != 0) {
 			c.ctxt.Diag("literal operation on R0\n%v", p)
@@ -2579,7 +2594,7 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		r := int(p.To.Reg)
 
 		if r == 0 {
-			r = int(o.param)
+			r = getimpliedreg(&p.To)
 		}
 		v := c.regoff(&p.To)
 		if p.To.Type == obj.TYPE_MEM && p.To.Index != 0 {
@@ -2615,7 +2630,7 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		r := int(p.From.Reg)
 
 		if r == 0 {
-			r = int(o.param)
+			r = getimpliedreg(&p.From)
 		}
 		v := c.regoff(&p.From)
 		if p.From.Type == obj.TYPE_MEM && p.From.Index != 0 {
@@ -2646,7 +2661,7 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		r := int(p.From.Reg)
 
 		if r == 0 {
-			r = int(o.param)
+			r = getimpliedreg(&p.From)
 		}
 		v := c.regoff(&p.From)
 		if p.From.Type == obj.TYPE_MEM && p.From.Index != 0 {
@@ -3036,7 +3051,7 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		v := c.regoff(&p.From)
 		r := int(p.From.Reg)
 		if r == 0 {
-			r = int(o.param)
+			r = getimpliedreg(&p.From)
 		}
 		o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(v)))
 		o2 = AOP_IRR(OP_ADDI, uint32(p.To.Reg), REGTMP, uint32(v))
@@ -3180,7 +3195,7 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 
 		r := int(p.To.Reg)
 		if r == 0 {
-			r = int(o.param)
+			r = getimpliedreg(&p.To)
 		}
 		// Offsets in DS form stores must be a multiple of 4
 		inst := c.opstore(p.As)
@@ -3195,7 +3210,7 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 
 		r := int(p.From.Reg)
 		if r == 0 {
-			r = int(o.param)
+			r = getimpliedreg(&p.From)
 		}
 		o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(v)))
 		o2 = AOP_IRR(c.opload(p.As), uint32(p.To.Reg), REGTMP, uint32(v))
@@ -3205,7 +3220,7 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 
 		r := int(p.From.Reg)
 		if r == 0 {
-			r = int(o.param)
+			r = getimpliedreg(&p.From)
 		}
 		o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(v)))
 		o2 = AOP_IRR(c.opload(p.As), uint32(p.To.Reg), REGTMP, uint32(v))
-- 
GitLab


From fdded79e6e3256118af182b42714d4d56f2000b0 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Tue, 9 Mar 2021 18:24:51 -0800
Subject: [PATCH 1024/2400] cmd/compile: fix handling of partially inferred
 type arguments

In the case of partially inferred type arguments, we need to use the
IndexExpr as the key in g.info.Inferred[] rather than the CallExpr.

Added an extra fromStrings1 call in the settable.go test that tests
partially inferred type arguments. This new call uses a new concrete
type SettableString as well.

I also added another implementation fromStrings3 (derived from a go2go
tests) that typechecks but intentionally causes a panic.

Change-Id: I74d35c5a741f72f37160a96fbec939451157f392
Reviewed-on: https://go-review.googlesource.com/c/go/+/300309
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/expr.go | 12 +++++-
 test/typeparam/settable.go             | 55 +++++++++++++++++++++++---
 2 files changed, 61 insertions(+), 6 deletions(-)

diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index b99f5a4cdd..06aa91199c 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -96,7 +96,17 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 
 	case *syntax.CallExpr:
 		fun := g.expr(expr.Fun)
-		if inferred, ok := g.info.Inferred[expr]; ok && len(inferred.Targs) > 0 {
+
+		// The key for the Inferred map is usually the expr.
+		key := syntax.Expr(expr)
+		if _, ok := expr.Fun.(*syntax.IndexExpr); ok {
+			// If the Fun is an IndexExpr, then this may be a
+			// partial type inference case. In this case, we look up
+			// the IndexExpr in the Inferred map.
+			// TODO(gri): should types2 always record the callExpr as the key?
+			key = syntax.Expr(expr.Fun)
+		}
+		if inferred, ok := g.info.Inferred[key]; ok && len(inferred.Targs) > 0 {
 			targs := make([]ir.Node, len(inferred.Targs))
 			for i, targ := range inferred.Targs {
 				targs[i] = ir.TypeNode(g.typ(targ))
diff --git a/test/typeparam/settable.go b/test/typeparam/settable.go
index f42c6574fe..29874fb189 100644
--- a/test/typeparam/settable.go
+++ b/test/typeparam/settable.go
@@ -11,11 +11,14 @@ import (
 	"strconv"
 )
 
+// Various implementations of fromStrings().
+
 type _Setter[B any] interface {
         Set(string)
 	type *B
 }
 
+// Takes two type parameters where PT = *T
 func fromStrings1[T any, PT _Setter[T]](s []string) []T {
         result := make([]T, len(s))
         for i, v := range s {
@@ -28,6 +31,7 @@ func fromStrings1[T any, PT _Setter[T]](s []string) []T {
         return result
 }
 
+// Takes one type parameter and a set function
 func fromStrings2[T any](s []string, set func(*T, string)) []T {
         results := make([]T, len(s))
         for i, v := range s {
@@ -36,24 +40,65 @@ func fromStrings2[T any](s []string, set func(*T, string)) []T {
         return results
 }
 
-type Settable int
+type _Setter2 interface {
+        Set(string)
+}
+
+// Takes only one type parameter, but causes a panic (see below)
+func fromStrings3[T _Setter2](s []string) []T {
+        results := make([]T, len(s))
+        for i, v := range s {
+		// Panics if T is a pointer type because receiver is T(nil).
+		results[i].Set(v)
+        }
+        return results
+}
+
+// Two concrete types with the appropriate Set method.
+
+type SettableInt int
 
-func (p *Settable) Set(s string) {
+func (p *SettableInt) Set(s string) {
         i, err := strconv.Atoi(s)
         if err != nil {
                 panic(err)
         }
-        *p = Settable(i)
+        *p = SettableInt(i)
+}
+
+type SettableString struct {
+	s string
+}
+
+func (x *SettableString) Set(s string) {
+        x.s = s
 }
 
 func main() {
-        s := fromStrings1[Settable, *Settable]([]string{"1"})
+        s := fromStrings1[SettableInt, *SettableInt]([]string{"1"})
         if len(s) != 1 || s[0] != 1 {
                 panic(fmt.Sprintf("got %v, want %v", s, []int{1}))
         }
 
-        s = fromStrings2([]string{"1"}, func(p *Settable, s string) { p.Set(s) })
+	// Test out constraint type inference, which should determine that the second
+	// type param is *SettableString.
+	ps := fromStrings1[SettableString]([]string{"x", "y"})
+        if len(ps) != 2 || ps[0] != (SettableString{"x"}) || ps[1] != (SettableString{"y"}) {
+                panic(s)
+        }
+
+        s = fromStrings2([]string{"1"}, func(p *SettableInt, s string) { p.Set(s) })
         if len(s) != 1 || s[0] != 1 {
                 panic(fmt.Sprintf("got %v, want %v", s, []int{1}))
         }
+
+        defer func() {
+                if recover() == nil {
+                        panic("did not panic as expected")
+                }
+        }()
+        // This should type check but should panic at run time,
+        // because it will make a slice of *SettableInt and then call
+        // Set on a nil value.
+        fromStrings3[*SettableInt]([]string{"1"})
 }
-- 
GitLab


From 68f3344fe95dde95685b0d7fbbf74d13f3e9ee04 Mon Sep 17 00:00:00 2001
From: eric fang <eric.fang@arm.com>
Date: Tue, 2 Mar 2021 06:05:00 +0000
Subject: [PATCH 1025/2400] cmd/compile: remove 8-byte alignment requirement of
 stack slot on ppc64

This CL applies CL 267999 to ppc64.

Fixes #42385

Change-Id: I6462d647d1abdf7cec99607c40ef4d1fed1941e5
Reviewed-on: https://go-review.googlesource.com/c/go/+/297770
Reviewed-by: eric fang <eric.fang@arm.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: eric fang <eric.fang@arm.com>
---
 src/cmd/compile/internal/ssagen/pgen.go | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/pgen.go b/src/cmd/compile/internal/ssagen/pgen.go
index c2225ce950..8fa5980dab 100644
--- a/src/cmd/compile/internal/ssagen/pgen.go
+++ b/src/cmd/compile/internal/ssagen/pgen.go
@@ -19,7 +19,6 @@ import (
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
 	"cmd/internal/src"
-	"cmd/internal/sys"
 )
 
 // cmpstackvarlt reports whether the stack variable a sorts before b.
@@ -133,9 +132,6 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 		} else {
 			lastHasPtr = false
 		}
-		if Arch.LinkArch.InFamily(sys.PPC64) {
-			s.stksize = types.Rnd(s.stksize, int64(types.PtrSize))
-		}
 		n.SetFrameOffset(-s.stksize)
 	}
 
-- 
GitLab


From 3a3b8164fdcb071955284c13cda6ee0f29fc8bd3 Mon Sep 17 00:00:00 2001
From: fanzha02 <fannie.zhang@arm.com>
Date: Mon, 1 Mar 2021 10:34:08 +0800
Subject: [PATCH 1026/2400] cmd/dist: refactor test constraints for
 misc/cgo/testsantizers

Currently, the cmd/dist runs test cases in misc/cgo/testsantizers only
when memeory sanitizer is supported, but the tsan tests in
misc/cgo/testsanitizers do not require support for -msan option, which
makes tsan tests can not be run on some unsupported -msan option platforms.

Therefore, this patch moves the test constraints from cmd/dist to
msan_test.go, so that the tsan tests in misc/cgo/testsanitizers
can be run on any system where the C compiler supports -fsanitize=thread
option.

Change-Id: I779c92eedd0270050f1a0b1a69ecce50c3712bc9
Reviewed-on: https://go-review.googlesource.com/c/go/+/297774
Trust: fannie zhang <Fannie.Zhang@arm.com>
Run-TryBot: fannie zhang <Fannie.Zhang@arm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 misc/cgo/testsanitizers/cc_test.go      | 11 +++++++++++
 misc/cgo/testsanitizers/cshared_test.go | 11 +++++++++++
 misc/cgo/testsanitizers/msan_test.go    | 13 +++++++++++++
 src/cmd/dist/test.go                    | 16 +++-------------
 src/cmd/internal/sys/supported.go       |  3 ++-
 5 files changed, 40 insertions(+), 14 deletions(-)

diff --git a/misc/cgo/testsanitizers/cc_test.go b/misc/cgo/testsanitizers/cc_test.go
index 0192a663dd..dab13364b8 100644
--- a/misc/cgo/testsanitizers/cc_test.go
+++ b/misc/cgo/testsanitizers/cc_test.go
@@ -440,3 +440,14 @@ func hangProneCmd(name string, arg ...string) *exec.Cmd {
 	}
 	return cmd
 }
+
+// mSanSupported is a copy of the function cmd/internal/sys.MSanSupported,
+// because the internal pacakage can't be used here.
+func mSanSupported(goos, goarch string) bool {
+	switch goos {
+	case "linux":
+		return goarch == "amd64" || goarch == "arm64"
+	default:
+		return false
+	}
+}
diff --git a/misc/cgo/testsanitizers/cshared_test.go b/misc/cgo/testsanitizers/cshared_test.go
index 56063ea620..b98360c4ae 100644
--- a/misc/cgo/testsanitizers/cshared_test.go
+++ b/misc/cgo/testsanitizers/cshared_test.go
@@ -19,6 +19,12 @@ func TestShared(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+
+	GOARCH, err := goEnv("GOARCH")
+	if err != nil {
+		t.Fatal(err)
+	}
+
 	libExt := "so"
 	if GOOS == "darwin" {
 		libExt = "dylib"
@@ -41,6 +47,11 @@ func TestShared(t *testing.T) {
 	for _, tc := range cases {
 		tc := tc
 		name := strings.TrimSuffix(tc.src, ".go")
+		//The memory sanitizer tests require support for the -msan option.
+		if tc.sanitizer == "memory" && !mSanSupported(GOOS, GOARCH) {
+			t.Logf("skipping %s test on %s/%s; -msan option is not supported.", name, GOOS, GOARCH)
+			continue
+		}
 		t.Run(name, func(t *testing.T) {
 			t.Parallel()
 			config := configure(tc.sanitizer)
diff --git a/misc/cgo/testsanitizers/msan_test.go b/misc/cgo/testsanitizers/msan_test.go
index 5e2f9759ba..2a3494fbfc 100644
--- a/misc/cgo/testsanitizers/msan_test.go
+++ b/misc/cgo/testsanitizers/msan_test.go
@@ -10,6 +10,19 @@ import (
 )
 
 func TestMSAN(t *testing.T) {
+	goos, err := goEnv("GOOS")
+	if err != nil {
+		t.Fatal(err)
+	}
+	goarch, err := goEnv("GOARCH")
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The msan tests require support for the -msan option.
+	if !mSanSupported(goos, goarch) {
+		t.Skipf("skipping on %s/%s; -msan option is not supported.", goos, goarch)
+	}
+
 	t.Parallel()
 	requireOvercommit(t)
 	config := configure("memory")
diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go
index 0c8e2c56bc..cbf3ec6d88 100644
--- a/src/cmd/dist/test.go
+++ b/src/cmd/dist/test.go
@@ -736,8 +736,9 @@ func (t *tester) registerTests() {
 		if gohostos == "linux" && goarch == "amd64" {
 			t.registerTest("testasan", "../misc/cgo/testasan", "go", "run", ".")
 		}
-		if mSanSupported(goos, goarch) {
-			t.registerHostTest("testsanitizers/msan", "../misc/cgo/testsanitizers", "misc/cgo/testsanitizers", ".")
+		if goos == "linux" {
+			// because syscall.SysProcAttri struct used in misc/cgo/testsanitizers is only built on linux.
+			t.registerHostTest("testsanitizers", "../misc/cgo/testsanitizers", "misc/cgo/testsanitizers", ".")
 		}
 		if t.hasBash() && goos != "android" && !t.iOS() && gohostos != "windows" {
 			t.registerHostTest("cgo_errors", "../misc/cgo/errors", "misc/cgo/errors", ".")
@@ -1640,17 +1641,6 @@ func raceDetectorSupported(goos, goarch string) bool {
 	}
 }
 
-// mSanSupported is a copy of the function cmd/internal/sys.MSanSupported,
-// which can't be used here because cmd/dist has to be buildable by Go 1.4.
-func mSanSupported(goos, goarch string) bool {
-	switch goos {
-	case "linux":
-		return goarch == "amd64" || goarch == "arm64"
-	default:
-		return false
-	}
-}
-
 // isUnsupportedVMASize reports whether the failure is caused by an unsupported
 // VMA for the race detector (for example, running the race detector on an
 // arm64 machine configured with 39-bit VMA)
diff --git a/src/cmd/internal/sys/supported.go b/src/cmd/internal/sys/supported.go
index 291acf0862..fa477b837f 100644
--- a/src/cmd/internal/sys/supported.go
+++ b/src/cmd/internal/sys/supported.go
@@ -23,7 +23,8 @@ func RaceDetectorSupported(goos, goarch string) bool {
 }
 
 // MSanSupported reports whether goos/goarch supports the memory
-// sanitizer option. There is a copy of this function in cmd/dist/test.go.
+// sanitizer option.
+// There is a copy of this function in misc/cgo/testsanitizers/cc_test.go.
 func MSanSupported(goos, goarch string) bool {
 	switch goos {
 	case "linux":
-- 
GitLab


From 79e3ee52f48411eb7c4edfe3daa55e2ecf7a6c61 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Wed, 10 Mar 2021 10:06:11 +0100
Subject: [PATCH 1027/2400] internal/syscall/unix: unify GetRandom
 implementation

The implementation of GetRandom for Linux, FreeBSD and DragonflyBSD can
be shared.

Also remove GRND_INSECURE on DragonflyBSD as pointed out by Ian in the
review of CL 269999.

Change-Id: I5bf4c1bd51ddb2ad600652a57e0bc1bafa1cf40d
Reviewed-on: https://go-review.googlesource.com/c/go/+/299133
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/internal/syscall/unix/getrandom.go        | 40 +++++++++++++++++++
 .../syscall/unix/getrandom_dragonfly.go       | 37 +----------------
 .../syscall/unix/getrandom_freebsd.go         | 34 +---------------
 src/internal/syscall/unix/getrandom_linux.go  | 33 ---------------
 4 files changed, 42 insertions(+), 102 deletions(-)
 create mode 100644 src/internal/syscall/unix/getrandom.go

diff --git a/src/internal/syscall/unix/getrandom.go b/src/internal/syscall/unix/getrandom.go
new file mode 100644
index 0000000000..d2c58c0f6f
--- /dev/null
+++ b/src/internal/syscall/unix/getrandom.go
@@ -0,0 +1,40 @@
+// Copyright 2021 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.
+
+//go:build dragonfly || freebsd || linux
+// +build dragonfly freebsd linux
+
+package unix
+
+import (
+	"sync/atomic"
+	"syscall"
+	"unsafe"
+)
+
+var getrandomUnsupported int32 // atomic
+
+// GetRandomFlag is a flag supported by the getrandom system call.
+type GetRandomFlag uintptr
+
+// GetRandom calls the getrandom system call.
+func GetRandom(p []byte, flags GetRandomFlag) (n int, err error) {
+	if len(p) == 0 {
+		return 0, nil
+	}
+	if atomic.LoadInt32(&getrandomUnsupported) != 0 {
+		return 0, syscall.ENOSYS
+	}
+	r1, _, errno := syscall.Syscall(getrandomTrap,
+		uintptr(unsafe.Pointer(&p[0])),
+		uintptr(len(p)),
+		uintptr(flags))
+	if errno != 0 {
+		if errno == syscall.ENOSYS {
+			atomic.StoreInt32(&getrandomUnsupported, 1)
+		}
+		return 0, errno
+	}
+	return int(r1), nil
+}
diff --git a/src/internal/syscall/unix/getrandom_dragonfly.go b/src/internal/syscall/unix/getrandom_dragonfly.go
index b345b4c00c..fbf78f9de8 100644
--- a/src/internal/syscall/unix/getrandom_dragonfly.go
+++ b/src/internal/syscall/unix/getrandom_dragonfly.go
@@ -4,19 +4,8 @@
 
 package unix
 
-import (
-	"sync/atomic"
-	"syscall"
-	"unsafe"
-)
-
-var randomUnsupported int32 // atomic
-
 // DragonFlyBSD getrandom system call number.
-const randomTrap uintptr = 550
-
-// GetRandomFlag is a flag supported by the getrandom system call.
-type GetRandomFlag uintptr
+const getrandomTrap uintptr = 550
 
 const (
 	// GRND_RANDOM is only set for portability purpose, no-op on DragonFlyBSD.
@@ -24,28 +13,4 @@ const (
 
 	// GRND_NONBLOCK means return EAGAIN rather than blocking.
 	GRND_NONBLOCK GetRandomFlag = 0x0002
-
-	// GRND_INSECURE is an GRND_NONBLOCK alias
-	GRND_INSECURE GetRandomFlag = 0x0004
 )
-
-// GetRandom calls the DragonFlyBSD getrandom system call.
-func GetRandom(p []byte, flags GetRandomFlag) (n int, err error) {
-	if len(p) == 0 {
-		return 0, nil
-	}
-	if atomic.LoadInt32(&randomUnsupported) != 0 {
-		return 0, syscall.ENOSYS
-	}
-	r1, _, errno := syscall.Syscall(randomTrap,
-		uintptr(unsafe.Pointer(&p[0])),
-		uintptr(len(p)),
-		uintptr(flags))
-	if errno != 0 {
-		if errno == syscall.ENOSYS {
-			atomic.StoreInt32(&randomUnsupported, 1)
-		}
-		return 0, errno
-	}
-	return int(r1), nil
-}
diff --git a/src/internal/syscall/unix/getrandom_freebsd.go b/src/internal/syscall/unix/getrandom_freebsd.go
index f1ba5730c9..8c4f3dff82 100644
--- a/src/internal/syscall/unix/getrandom_freebsd.go
+++ b/src/internal/syscall/unix/getrandom_freebsd.go
@@ -4,19 +4,8 @@
 
 package unix
 
-import (
-	"sync/atomic"
-	"syscall"
-	"unsafe"
-)
-
-var randomUnsupported int32 // atomic
-
 // FreeBSD getrandom system call number.
-const randomTrap uintptr = 563
-
-// GetRandomFlag is a flag supported by the getrandom system call.
-type GetRandomFlag uintptr
+const getrandomTrap uintptr = 563
 
 const (
 	// GRND_NONBLOCK means return EAGAIN rather than blocking.
@@ -25,24 +14,3 @@ const (
 	// GRND_RANDOM is only set for portability purpose, no-op on FreeBSD.
 	GRND_RANDOM GetRandomFlag = 0x0002
 )
-
-// GetRandom calls the FreeBSD getrandom system call.
-func GetRandom(p []byte, flags GetRandomFlag) (n int, err error) {
-	if len(p) == 0 {
-		return 0, nil
-	}
-	if atomic.LoadInt32(&randomUnsupported) != 0 {
-		return 0, syscall.ENOSYS
-	}
-	r1, _, errno := syscall.Syscall(randomTrap,
-		uintptr(unsafe.Pointer(&p[0])),
-		uintptr(len(p)),
-		uintptr(flags))
-	if errno != 0 {
-		if errno == syscall.ENOSYS {
-			atomic.StoreInt32(&randomUnsupported, 1)
-		}
-		return 0, errno
-	}
-	return int(r1), nil
-}
diff --git a/src/internal/syscall/unix/getrandom_linux.go b/src/internal/syscall/unix/getrandom_linux.go
index 490d516978..8ccd8d328a 100644
--- a/src/internal/syscall/unix/getrandom_linux.go
+++ b/src/internal/syscall/unix/getrandom_linux.go
@@ -4,17 +4,6 @@
 
 package unix
 
-import (
-	"sync/atomic"
-	"syscall"
-	"unsafe"
-)
-
-var randomUnsupported int32 // atomic
-
-// GetRandomFlag is a flag supported by the getrandom system call.
-type GetRandomFlag uintptr
-
 const (
 	// GRND_NONBLOCK means return EAGAIN rather than blocking.
 	GRND_NONBLOCK GetRandomFlag = 0x0001
@@ -22,25 +11,3 @@ const (
 	// GRND_RANDOM means use the /dev/random pool instead of /dev/urandom.
 	GRND_RANDOM GetRandomFlag = 0x0002
 )
-
-// GetRandom calls the Linux getrandom system call.
-// See https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=c6e9d6f38894798696f23c8084ca7edbf16ee895
-func GetRandom(p []byte, flags GetRandomFlag) (n int, err error) {
-	if len(p) == 0 {
-		return 0, nil
-	}
-	if atomic.LoadInt32(&randomUnsupported) != 0 {
-		return 0, syscall.ENOSYS
-	}
-	r1, _, errno := syscall.Syscall(getrandomTrap,
-		uintptr(unsafe.Pointer(&p[0])),
-		uintptr(len(p)),
-		uintptr(flags))
-	if errno != 0 {
-		if errno == syscall.ENOSYS {
-			atomic.StoreInt32(&randomUnsupported, 1)
-		}
-		return 0, errno
-	}
-	return int(r1), nil
-}
-- 
GitLab


From 9ece63f0647ec34cc729ad71a87254193014dcca Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Wed, 10 Mar 2021 10:26:20 +0100
Subject: [PATCH 1028/2400] crypto/rand, internal/syscall/unix: add support for
 getrandom syscall on solaris

The getrandom syscall is available on Solaris and Illumos, see
https://docs.oracle.com/cd/E88353_01/html/E37841/getrandom-2.html and
https://illumos.org/man/2/getrandom

Change-Id: Id1c65d6a5b2fbc80d20b43d8b32dab137ca950ca
Reviewed-on: https://go-review.googlesource.com/c/go/+/299134
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/crypto/rand/rand_batched.go               |  4 +-
 src/crypto/rand/rand_batched_test.go          |  4 +-
 src/crypto/rand/rand_solaris.go               | 10 ++++
 .../syscall/unix/getrandom_solaris.go         | 53 +++++++++++++++++++
 4 files changed, 67 insertions(+), 4 deletions(-)
 create mode 100644 src/crypto/rand/rand_solaris.go
 create mode 100644 src/internal/syscall/unix/getrandom_solaris.go

diff --git a/src/crypto/rand/rand_batched.go b/src/crypto/rand/rand_batched.go
index 538769a868..d7c5bf3562 100644
--- a/src/crypto/rand/rand_batched.go
+++ b/src/crypto/rand/rand_batched.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build linux || freebsd || dragonfly
-// +build linux freebsd dragonfly
+//go:build linux || freebsd || dragonfly || solaris
+// +build linux freebsd dragonfly solaris
 
 package rand
 
diff --git a/src/crypto/rand/rand_batched_test.go b/src/crypto/rand/rand_batched_test.go
index 814f15201a..2d20922c82 100644
--- a/src/crypto/rand/rand_batched_test.go
+++ b/src/crypto/rand/rand_batched_test.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build linux || freebsd || dragonfly
-// +build linux freebsd dragonfly
+//go:build linux || freebsd || dragonfly || solaris
+// +build linux freebsd dragonfly solaris
 
 package rand
 
diff --git a/src/crypto/rand/rand_solaris.go b/src/crypto/rand/rand_solaris.go
new file mode 100644
index 0000000000..bbad0fe557
--- /dev/null
+++ b/src/crypto/rand/rand_solaris.go
@@ -0,0 +1,10 @@
+// Copyright 2021 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 rand
+
+// maxGetRandomRead is the maximum number of bytes to ask for in one call to the
+// getrandom() syscall. Across all the Solaris platforms, 256 bytes is the
+// lowest number of bytes returned atomically per call.
+const maxGetRandomRead = 1 << 8
diff --git a/src/internal/syscall/unix/getrandom_solaris.go b/src/internal/syscall/unix/getrandom_solaris.go
new file mode 100644
index 0000000000..d86775cd98
--- /dev/null
+++ b/src/internal/syscall/unix/getrandom_solaris.go
@@ -0,0 +1,53 @@
+// Copyright 2021 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 unix
+
+import (
+	"sync/atomic"
+	"syscall"
+	"unsafe"
+)
+
+//go:cgo_import_dynamic libc_getrandom getrandom "libc.so"
+
+//go:linkname procGetrandom libc_getrandom
+
+var procGetrandom uintptr
+
+var getrandomUnsupported int32 // atomic
+
+// GetRandomFlag is a flag supported by the getrandom system call.
+type GetRandomFlag uintptr
+
+const (
+	// GRND_NONBLOCK means return EAGAIN rather than blocking.
+	GRND_NONBLOCK GetRandomFlag = 0x0001
+
+	// GRND_RANDOM means use the /dev/random pool instead of /dev/urandom.
+	GRND_RANDOM GetRandomFlag = 0x0002
+)
+
+// GetRandom calls the getrandom system call.
+func GetRandom(p []byte, flags GetRandomFlag) (n int, err error) {
+	if len(p) == 0 {
+		return 0, nil
+	}
+	if atomic.LoadInt32(&getrandomUnsupported) != 0 {
+		return 0, syscall.ENOSYS
+	}
+	r1, _, errno := syscall6(uintptr(unsafe.Pointer(&procGetrandom)),
+		3,
+		uintptr(unsafe.Pointer(&p[0])),
+		uintptr(len(p)),
+		uintptr(flags),
+		0, 0, 0)
+	if errno != 0 {
+		if errno == syscall.ENOSYS {
+			atomic.StoreInt32(&getrandomUnsupported, 1)
+		}
+		return 0, errno
+	}
+	return int(r1), nil
+}
-- 
GitLab


From b8e9ec856c2b2d717ab14e85f43e00b532c4370a Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Wed, 10 Mar 2021 07:21:56 -0700
Subject: [PATCH 1029/2400] syscall: use runtime.KeepAlive for
 ProcThreadAttributeList arguments

It turns out that if you write Go pointers to Go memory, the Go compiler
must be involved so that it generates various calls to the GC in the
process. Letting Windows write Go pointers to Go memory violated this.
So, we replace that with just a boring call to runtime.KeepAlive. That's
not a great API, but this is all internal code anyway. We fix it up
more elegantly for external consumption in x/sys/windows with CL 300369.

Fixes #44900.

Change-Id: Id6599a793af9c4815f6c9387b00796923f32cb97
Reviewed-on: https://go-review.googlesource.com/c/go/+/300349
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/syscall/exec_windows.go         |  3 +++
 src/syscall/syscall_windows.go      |  2 +-
 src/syscall/syscall_windows_test.go | 36 -----------------------------
 src/syscall/types_windows.go        |  8 +------
 4 files changed, 5 insertions(+), 44 deletions(-)

diff --git a/src/syscall/exec_windows.go b/src/syscall/exec_windows.go
index b20a27d28b..253e9e8c1f 100644
--- a/src/syscall/exec_windows.go
+++ b/src/syscall/exec_windows.go
@@ -7,6 +7,7 @@
 package syscall
 
 import (
+	"runtime"
 	"sync"
 	"unicode/utf16"
 	"unsafe"
@@ -368,6 +369,8 @@ func StartProcess(argv0 string, argv []string, attr *ProcAttr) (pid int, handle
 		return 0, 0, err
 	}
 	defer CloseHandle(Handle(pi.Thread))
+	runtime.KeepAlive(fd)
+	runtime.KeepAlive(sys)
 
 	return int(pi.ProcessId), uintptr(pi.Process), nil
 }
diff --git a/src/syscall/syscall_windows.go b/src/syscall/syscall_windows.go
index 05a7d3027d..65af6637ae 100644
--- a/src/syscall/syscall_windows.go
+++ b/src/syscall/syscall_windows.go
@@ -1257,7 +1257,7 @@ func newProcThreadAttributeList(maxAttrCount uint32) (*_PROC_THREAD_ATTRIBUTE_LI
 		return nil, err
 	}
 	// size is guaranteed to be ≥1 by initializeProcThreadAttributeList.
-	al := (*_PROC_THREAD_ATTRIBUTE_LIST)(unsafe.Pointer(&make([]unsafe.Pointer, (size+ptrSize-1)/ptrSize)[0]))
+	al := (*_PROC_THREAD_ATTRIBUTE_LIST)(unsafe.Pointer(&make([]byte, size)[0]))
 	err = initializeProcThreadAttributeList(al, maxAttrCount, 0, &size)
 	if err != nil {
 		return nil, err
diff --git a/src/syscall/syscall_windows_test.go b/src/syscall/syscall_windows_test.go
index d5e8d58b5a..a9ae54752b 100644
--- a/src/syscall/syscall_windows_test.go
+++ b/src/syscall/syscall_windows_test.go
@@ -7,11 +7,8 @@ package syscall_test
 import (
 	"os"
 	"path/filepath"
-	"runtime"
 	"syscall"
 	"testing"
-	"time"
-	"unsafe"
 )
 
 func TestWin32finddata(t *testing.T) {
@@ -78,36 +75,3 @@ func TestTOKEN_ALL_ACCESS(t *testing.T) {
 		t.Errorf("TOKEN_ALL_ACCESS = %x, want 0xF01FF", syscall.TOKEN_ALL_ACCESS)
 	}
 }
-
-func TestProcThreadAttributeListPointers(t *testing.T) {
-	list, err := syscall.NewProcThreadAttributeList(1)
-	if err != nil {
-		t.Errorf("unable to create ProcThreadAttributeList: %v", err)
-	}
-	done := make(chan struct{})
-	fds := make([]syscall.Handle, 20)
-	runtime.SetFinalizer(&fds[0], func(*syscall.Handle) {
-		close(done)
-	})
-	err = syscall.UpdateProcThreadAttribute(list, 0, syscall.PROC_THREAD_ATTRIBUTE_HANDLE_LIST, unsafe.Pointer(&fds[0]), uintptr(len(fds))*unsafe.Sizeof(fds[0]), nil, nil)
-	if err != nil {
-		syscall.DeleteProcThreadAttributeList(list)
-		t.Errorf("unable to update ProcThreadAttributeList: %v", err)
-		return
-	}
-	runtime.GC()
-	runtime.GC()
-	select {
-	case <-done:
-		t.Error("ProcThreadAttributeList was garbage collected unexpectedly")
-	default:
-	}
-	syscall.DeleteProcThreadAttributeList(list)
-	runtime.GC()
-	runtime.GC()
-	select {
-	case <-done:
-	case <-time.After(time.Second):
-		t.Error("ProcThreadAttributeList was not garbage collected after a second")
-	}
-}
diff --git a/src/syscall/types_windows.go b/src/syscall/types_windows.go
index 31fe7664c9..384b5b4f2c 100644
--- a/src/syscall/types_windows.go
+++ b/src/syscall/types_windows.go
@@ -4,8 +4,6 @@
 
 package syscall
 
-import "unsafe"
-
 const (
 	// Windows errors.
 	ERROR_FILE_NOT_FOUND      Errno = 2
@@ -493,11 +491,7 @@ type StartupInfo struct {
 }
 
 type _PROC_THREAD_ATTRIBUTE_LIST struct {
-	// This is of type unsafe.Pointer, not of type byte or uintptr, because
-	// the contents of it is mostly a list of pointers, and in most cases,
-	// that's a list of pointers to Go-allocated objects. In order to keep
-	// the GC from collecting these objects, we declare this as unsafe.Pointer.
-	_ [1]unsafe.Pointer
+	_ [1]byte
 }
 
 const (
-- 
GitLab


From 0fc370c5d26353a865a29a01f093942c949d530a Mon Sep 17 00:00:00 2001
From: "Matt T. Proud" <matt.proud@gmail.com>
Date: Thu, 25 Feb 2021 01:03:35 +0100
Subject: [PATCH 1030/2400] docs: clarify when APIs use context.Background.

The Go standard library retrofitted context support onto existing APIs
using context.Background and later offered variants that directly
supported user-defined context value specification. This commit makes
that behavior clear in documentation and suggests context-aware
alternatives if the user is looking for one.

An example motivation is supporting code for use in systems that expect
APIs to be cancelable for lifecycle correctness or load
shedding/management reasons, as alluded to in
https://blog.golang.org/context-and-structs.

Updates #44143

Change-Id: I2d7f954ddf9b48264d5ebc8d0007058ff9bddf14
Reviewed-on: https://go-review.googlesource.com/c/go/+/296152
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Jean de Klerk <deklerk@google.com>
Trust: Jean de Klerk <deklerk@google.com>
Run-TryBot: Jean de Klerk <deklerk@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/crypto/tls/tls.go        |  6 ++++++
 src/database/sql/sql.go      | 42 ++++++++++++++++++++++++++++++++++++
 src/net/dial.go              |  9 ++++++++
 src/net/http/request.go      |  2 +-
 src/net/http/socks_bundle.go |  2 ++
 src/net/lookup.go            | 21 ++++++++++++++++++
 6 files changed, 81 insertions(+), 1 deletion(-)

diff --git a/src/crypto/tls/tls.go b/src/crypto/tls/tls.go
index a389873d32..4989364958 100644
--- a/src/crypto/tls/tls.go
+++ b/src/crypto/tls/tls.go
@@ -111,6 +111,9 @@ func (timeoutError) Temporary() bool { return true }
 //
 // DialWithDialer interprets a nil configuration as equivalent to the zero
 // configuration; see the documentation of Config for the defaults.
+//
+// DialWithDialer uses context.Background internally; to specify the context,
+// use Dialer.DialContext with NetDialer set to the desired dialer.
 func DialWithDialer(dialer *net.Dialer, network, addr string, config *Config) (*Conn, error) {
 	return dial(context.Background(), dialer, network, addr, config)
 }
@@ -224,6 +227,9 @@ type Dialer struct {
 // handshake, returning the resulting TLS connection.
 //
 // The returned Conn, if any, will always be of type *Conn.
+//
+// Dial uses context.Background internally; to specify the context,
+// use DialContext.
 func (d *Dialer) Dial(network, addr string) (net.Conn, error) {
 	return d.DialContext(context.Background(), network, addr)
 }
diff --git a/src/database/sql/sql.go b/src/database/sql/sql.go
index 37bcb0d091..12cc524c63 100644
--- a/src/database/sql/sql.go
+++ b/src/database/sql/sql.go
@@ -813,6 +813,9 @@ func (db *DB) PingContext(ctx context.Context) error {
 
 // Ping verifies a connection to the database is still alive,
 // establishing a connection if necessary.
+//
+// Ping uses context.Background internally; to specify the context, use
+// PingContext.
 func (db *DB) Ping() error {
 	return db.PingContext(context.Background())
 }
@@ -1481,6 +1484,9 @@ func (db *DB) PrepareContext(ctx context.Context, query string) (*Stmt, error) {
 // returned statement.
 // The caller must call the statement's Close method
 // when the statement is no longer needed.
+//
+// Prepare uses context.Background internally; to specify the context, use
+// PrepareContext.
 func (db *DB) Prepare(query string) (*Stmt, error) {
 	return db.PrepareContext(context.Background(), query)
 }
@@ -1551,6 +1557,9 @@ func (db *DB) ExecContext(ctx context.Context, query string, args ...interface{}
 
 // Exec executes a query without returning any rows.
 // The args are for any placeholder parameters in the query.
+//
+// Exec uses context.Background internally; to specify the context, use
+// ExecContext.
 func (db *DB) Exec(query string, args ...interface{}) (Result, error) {
 	return db.ExecContext(context.Background(), query, args...)
 }
@@ -1621,6 +1630,9 @@ func (db *DB) QueryContext(ctx context.Context, query string, args ...interface{
 
 // Query executes a query that returns rows, typically a SELECT.
 // The args are for any placeholder parameters in the query.
+//
+// Query uses context.Background internally; to specify the context, use
+// QueryContext.
 func (db *DB) Query(query string, args ...interface{}) (*Rows, error) {
 	return db.QueryContext(context.Background(), query, args...)
 }
@@ -1719,6 +1731,9 @@ func (db *DB) QueryRowContext(ctx context.Context, query string, args ...interfa
 // If the query selects no rows, the *Row's Scan will return ErrNoRows.
 // Otherwise, the *Row's Scan scans the first selected row and discards
 // the rest.
+//
+// QueryRow uses context.Background internally; to specify the context, use
+// QueryRowContext.
 func (db *DB) QueryRow(query string, args ...interface{}) *Row {
 	return db.QueryRowContext(context.Background(), query, args...)
 }
@@ -1750,6 +1765,9 @@ func (db *DB) BeginTx(ctx context.Context, opts *TxOptions) (*Tx, error) {
 
 // Begin starts a transaction. The default isolation level is dependent on
 // the driver.
+//
+// Begin uses context.Background internally; to specify the context, use
+// BeginTx.
 func (db *DB) Begin() (*Tx, error) {
 	return db.BeginTx(context.Background(), nil)
 }
@@ -2255,6 +2273,9 @@ func (tx *Tx) PrepareContext(ctx context.Context, query string) (*Stmt, error) {
 // be used once the transaction has been committed or rolled back.
 //
 // To use an existing prepared statement on this transaction, see Tx.Stmt.
+//
+// Prepare uses context.Background internally; to specify the context, use
+// PrepareContext.
 func (tx *Tx) Prepare(query string) (*Stmt, error) {
 	return tx.PrepareContext(context.Background(), query)
 }
@@ -2358,6 +2379,9 @@ func (tx *Tx) StmtContext(ctx context.Context, stmt *Stmt) *Stmt {
 //
 // The returned statement operates within the transaction and will be closed
 // when the transaction has been committed or rolled back.
+//
+// Stmt uses context.Background internally; to specify the context, use
+// StmtContext.
 func (tx *Tx) Stmt(stmt *Stmt) *Stmt {
 	return tx.StmtContext(context.Background(), stmt)
 }
@@ -2374,6 +2398,9 @@ func (tx *Tx) ExecContext(ctx context.Context, query string, args ...interface{}
 
 // Exec executes a query that doesn't return rows.
 // For example: an INSERT and UPDATE.
+//
+// Exec uses context.Background internally; to specify the context, use
+// ExecContext.
 func (tx *Tx) Exec(query string, args ...interface{}) (Result, error) {
 	return tx.ExecContext(context.Background(), query, args...)
 }
@@ -2389,6 +2416,9 @@ func (tx *Tx) QueryContext(ctx context.Context, query string, args ...interface{
 }
 
 // Query executes a query that returns rows, typically a SELECT.
+//
+// Query uses context.Background internally; to specify the context, use
+// QueryContext.
 func (tx *Tx) Query(query string, args ...interface{}) (*Rows, error) {
 	return tx.QueryContext(context.Background(), query, args...)
 }
@@ -2410,6 +2440,9 @@ func (tx *Tx) QueryRowContext(ctx context.Context, query string, args ...interfa
 // If the query selects no rows, the *Row's Scan will return ErrNoRows.
 // Otherwise, the *Row's Scan scans the first selected row and discards
 // the rest.
+//
+// QueryRow uses context.Background internally; to specify the context, use
+// QueryRowContext.
 func (tx *Tx) QueryRow(query string, args ...interface{}) *Row {
 	return tx.QueryRowContext(context.Background(), query, args...)
 }
@@ -2516,6 +2549,9 @@ func (s *Stmt) ExecContext(ctx context.Context, args ...interface{}) (Result, er
 
 // Exec executes a prepared statement with the given arguments and
 // returns a Result summarizing the effect of the statement.
+//
+// Exec uses context.Background internally; to specify the context, use
+// ExecContext.
 func (s *Stmt) Exec(args ...interface{}) (Result, error) {
 	return s.ExecContext(context.Background(), args...)
 }
@@ -2687,6 +2723,9 @@ func (s *Stmt) QueryContext(ctx context.Context, args ...interface{}) (*Rows, er
 
 // Query executes a prepared query statement with the given arguments
 // and returns the query results as a *Rows.
+//
+// Query uses context.Background internally; to specify the context, use
+// QueryContext.
 func (s *Stmt) Query(args ...interface{}) (*Rows, error) {
 	return s.QueryContext(context.Background(), args...)
 }
@@ -2726,6 +2765,9 @@ func (s *Stmt) QueryRowContext(ctx context.Context, args ...interface{}) *Row {
 //
 //  var name string
 //  err := nameByUseridStmt.QueryRow(id).Scan(&name)
+//
+// QueryRow uses context.Background internally; to specify the context, use
+// QueryRowContext.
 func (s *Stmt) QueryRow(args ...interface{}) *Row {
 	return s.QueryRowContext(context.Background(), args...)
 }
diff --git a/src/net/dial.go b/src/net/dial.go
index 13a312a91a..486ced0f2a 100644
--- a/src/net/dial.go
+++ b/src/net/dial.go
@@ -344,6 +344,9 @@ type sysDialer struct {
 //
 // See func Dial for a description of the network and address
 // parameters.
+//
+// Dial uses context.Background internally; to specify the context, use
+// DialContext.
 func (d *Dialer) Dial(network, address string) (Conn, error) {
 	return d.DialContext(context.Background(), network, address)
 }
@@ -701,6 +704,9 @@ type sysListener struct {
 //
 // See func Dial for a description of the network and address
 // parameters.
+//
+// Listen uses context.Background internally; to specify the context, use
+// ListenConfig.Listen.
 func Listen(network, address string) (Listener, error) {
 	var lc ListenConfig
 	return lc.Listen(context.Background(), network, address)
@@ -728,6 +734,9 @@ func Listen(network, address string) (Listener, error) {
 //
 // See func Dial for a description of the network and address
 // parameters.
+//
+// ListenPacket uses context.Background internally; to specify the context, use
+// ListenConfig.ListenPacket.
 func ListenPacket(network, address string) (PacketConn, error) {
 	var lc ListenConfig
 	return lc.ListenPacket(context.Background(), network, address)
diff --git a/src/net/http/request.go b/src/net/http/request.go
index adba5406e9..5251ebea66 100644
--- a/src/net/http/request.go
+++ b/src/net/http/request.go
@@ -823,7 +823,7 @@ func validMethod(method string) bool {
 	return len(method) > 0 && strings.IndexFunc(method, isNotToken) == -1
 }
 
-// NewRequest wraps NewRequestWithContext using the background context.
+// NewRequest wraps NewRequestWithContext using context.Background.
 func NewRequest(method, url string, body io.Reader) (*Request, error) {
 	return NewRequestWithContext(context.Background(), method, url, body)
 }
diff --git a/src/net/http/socks_bundle.go b/src/net/http/socks_bundle.go
index e446669589..fc22391039 100644
--- a/src/net/http/socks_bundle.go
+++ b/src/net/http/socks_bundle.go
@@ -362,6 +362,8 @@ func (d *socksDialer) DialWithConn(ctx context.Context, c net.Conn, network, add
 // Unlike DialContext, it returns a raw transport connection instead
 // of a forward proxy connection.
 //
+// Dial uses context.Background internally.
+//
 // Deprecated: Use DialContext or DialWithConn instead.
 func (d *socksDialer) Dial(network, address string) (net.Conn, error) {
 	if err := d.validateTarget(network, address); err != nil {
diff --git a/src/net/lookup.go b/src/net/lookup.go
index 5f7119872a..03599503bd 100644
--- a/src/net/lookup.go
+++ b/src/net/lookup.go
@@ -166,6 +166,9 @@ func (r *Resolver) getLookupGroup() *singleflight.Group {
 
 // LookupHost looks up the given host using the local resolver.
 // It returns a slice of that host's addresses.
+//
+// LookupHost uses context.Background internally; to specify the context, use
+// Resolver.LookupHost.
 func LookupHost(host string) (addrs []string, err error) {
 	return DefaultResolver.LookupHost(context.Background(), host)
 }
@@ -353,6 +356,9 @@ func ipAddrsEface(addrs []IPAddr) []interface{} {
 }
 
 // LookupPort looks up the port for the given network and service.
+//
+// LookupPort uses context.Background internally; to specify the context, use
+// Resolver.LookupPort.
 func LookupPort(network, service string) (port int, err error) {
 	return DefaultResolver.LookupPort(context.Background(), network, service)
 }
@@ -389,6 +395,9 @@ func (r *Resolver) LookupPort(ctx context.Context, network, service string) (por
 // LookupCNAME does not return an error if host does not
 // contain DNS "CNAME" records, as long as host resolves to
 // address records.
+//
+// LookupCNAME uses context.Background internally; to specify the context, use
+// Resolver.LookupCNAME.
 func LookupCNAME(host string) (cname string, err error) {
 	return DefaultResolver.lookupCNAME(context.Background(), host)
 }
@@ -434,6 +443,9 @@ func (r *Resolver) LookupSRV(ctx context.Context, service, proto, name string) (
 }
 
 // LookupMX returns the DNS MX records for the given domain name sorted by preference.
+//
+// LookupMX uses context.Background internally; to specify the context, use
+// Resolver.LookupMX.
 func LookupMX(name string) ([]*MX, error) {
 	return DefaultResolver.lookupMX(context.Background(), name)
 }
@@ -444,6 +456,9 @@ func (r *Resolver) LookupMX(ctx context.Context, name string) ([]*MX, error) {
 }
 
 // LookupNS returns the DNS NS records for the given domain name.
+//
+// LookupNS uses context.Background internally; to specify the context, use
+// Resolver.LookupNS.
 func LookupNS(name string) ([]*NS, error) {
 	return DefaultResolver.lookupNS(context.Background(), name)
 }
@@ -454,6 +469,9 @@ func (r *Resolver) LookupNS(ctx context.Context, name string) ([]*NS, error) {
 }
 
 // LookupTXT returns the DNS TXT records for the given domain name.
+//
+// LookupTXT uses context.Background internally; to specify the context, use
+// Resolver.LookupTXT.
 func LookupTXT(name string) ([]string, error) {
 	return DefaultResolver.lookupTXT(context.Background(), name)
 }
@@ -468,6 +486,9 @@ func (r *Resolver) LookupTXT(ctx context.Context, name string) ([]string, error)
 //
 // When using the host C library resolver, at most one result will be
 // returned. To bypass the host resolver, use a custom Resolver.
+//
+// LookupAddr uses context.Background internally; to specify the context, use
+// Resolver.LookupAddr.
 func LookupAddr(addr string) (names []string, err error) {
 	return DefaultResolver.lookupAddr(context.Background(), addr)
 }
-- 
GitLab


From 415ca3f1f0fa05a98561752e0787f59b77f19645 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Wed, 10 Mar 2021 19:35:22 -0800
Subject: [PATCH 1031/2400] test: add test that caused a gofrontend internal
 error

For #44383

Change-Id: I3610105dad3574e210e226d3ba80a4ba5a7eeaa6
Reviewed-on: https://go-review.googlesource.com/c/go/+/300789
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 test/fixedbugs/issue44383.go | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 test/fixedbugs/issue44383.go

diff --git a/test/fixedbugs/issue44383.go b/test/fixedbugs/issue44383.go
new file mode 100644
index 0000000000..d2d57524d1
--- /dev/null
+++ b/test/fixedbugs/issue44383.go
@@ -0,0 +1,18 @@
+// compile
+
+// Copyright 2021 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.
+
+// Issue 44383: gofrontend internal compiler error
+
+package main
+
+func main() {
+	var b1, b2 byte
+	f := func() int {
+		var m map[byte]int
+		return m[b1/b2]
+	}
+	f()
+}
-- 
GitLab


From f009b5b2268a7fcdfe046057cbf2a75306dbfc5e Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Thu, 22 Oct 2020 16:55:55 +0000
Subject: [PATCH 1032/2400] runtime: support register ABI for finalizers

This change modifies runfinq to properly pass arguments to finalizers in
registers via reflectcall.

For #40724.

Change-Id: I414c0eff466ef315a0eb10507994e598dd29ccb2
Reviewed-on: https://go-review.googlesource.com/c/go/+/300112
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/abi_test.go    | 116 +++++++++++++++++++++++++++++++++++++
 src/runtime/export_test.go |  15 +++++
 src/runtime/mfinal.go      |  46 ++++++++++-----
 src/runtime/stubs.go       |  28 +++++++++
 4 files changed, 191 insertions(+), 14 deletions(-)
 create mode 100644 src/runtime/abi_test.go

diff --git a/src/runtime/abi_test.go b/src/runtime/abi_test.go
new file mode 100644
index 0000000000..fa365c0832
--- /dev/null
+++ b/src/runtime/abi_test.go
@@ -0,0 +1,116 @@
+// Copyright 2021 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.
+
+// +build goexperiment.regabi
+//go:build goexperiment.regabi
+
+// This file contains tests specific to making sure the register ABI
+// works in a bunch of contexts in the runtime.
+
+package runtime_test
+
+import (
+	"internal/abi"
+	"internal/testenv"
+	"os"
+	"os/exec"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+var regConfirmRun int
+
+//go:registerparams
+func regFinalizerPointer(v *Tint) (int, float32, [10]byte) {
+	regConfirmRun = *(*int)(v)
+	return 5151, 4.0, [10]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+}
+
+//go:registerparams
+func regFinalizerIface(v Tinter) (int, float32, [10]byte) {
+	regConfirmRun = *(*int)(v.(*Tint))
+	return 5151, 4.0, [10]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+}
+
+func TestFinalizerRegisterABI(t *testing.T) {
+	testenv.MustHaveExec(t)
+
+	// Actually run the test in a subprocess because we don't want
+	// finalizers from other tests interfering.
+	if os.Getenv("TEST_FINALIZER_REGABI") != "1" {
+		cmd := testenv.CleanCmdEnv(exec.Command(os.Args[0], "-test.run=TestFinalizerRegisterABI", "-test.v"))
+		cmd.Env = append(cmd.Env, "TEST_FINALIZER_REGABI=1")
+		out, err := cmd.CombinedOutput()
+		if !strings.Contains(string(out), "PASS\n") || err != nil {
+			t.Fatalf("%s\n(exit status %v)", string(out), err)
+		}
+		return
+	}
+
+	// Optimistically clear any latent finalizers from e.g. the testing
+	// package before continuing.
+	//
+	// It's possible that a finalizer only becomes available to run
+	// after this point, which would interfere with the test and could
+	// cause a crash, but because we're running in a separate process
+	// it's extremely unlikely.
+	runtime.GC()
+	runtime.GC()
+
+	// fing will only pick the new IntRegArgs up if it's currently
+	// sleeping and wakes up, so wait for it to go to sleep.
+	success := false
+	for i := 0; i < 100; i++ {
+		if runtime.FinalizerGAsleep() {
+			success = true
+			break
+		}
+		time.Sleep(20 * time.Millisecond)
+	}
+	if !success {
+		t.Fatal("finalizer not asleep?")
+	}
+
+	argRegsBefore := runtime.SetIntArgRegs(abi.IntArgRegs)
+	defer runtime.SetIntArgRegs(argRegsBefore)
+
+	tests := []struct {
+		name         string
+		fin          interface{}
+		confirmValue int
+	}{
+		{"Pointer", regFinalizerPointer, -1},
+		{"Interface", regFinalizerIface, -2},
+	}
+	for i := range tests {
+		test := &tests[i]
+		t.Run(test.name, func(t *testing.T) {
+			regConfirmRun = 0
+
+			x := new(Tint)
+			*x = (Tint)(test.confirmValue)
+			runtime.SetFinalizer(x, test.fin)
+
+			runtime.KeepAlive(x)
+
+			// Queue the finalizer.
+			runtime.GC()
+			runtime.GC()
+
+			for i := 0; i < 100; i++ {
+				time.Sleep(10 * time.Millisecond)
+				if regConfirmRun != 0 {
+					break
+				}
+			}
+			if regConfirmRun == 0 {
+				t.Fatal("finalizer failed to execute")
+			} else if regConfirmRun != test.confirmValue {
+				t.Fatalf("wrong finalizer executed? regConfirmRun = %d", regConfirmRun)
+			}
+		})
+	}
+}
diff --git a/src/runtime/export_test.go b/src/runtime/export_test.go
index 5a87024b8a..195b7b0519 100644
--- a/src/runtime/export_test.go
+++ b/src/runtime/export_test.go
@@ -1220,3 +1220,18 @@ func (th *TimeHistogram) Count(bucket, subBucket uint) (uint64, bool) {
 func (th *TimeHistogram) Record(duration int64) {
 	(*timeHistogram)(th).record(duration)
 }
+
+func SetIntArgRegs(a int) int {
+	lock(&finlock)
+	old := intArgRegs
+	intArgRegs = a
+	unlock(&finlock)
+	return old
+}
+
+func FinalizerGAsleep() bool {
+	lock(&finlock)
+	result := fingwait
+	unlock(&finlock)
+	return result
+}
diff --git a/src/runtime/mfinal.go b/src/runtime/mfinal.go
index e92ec80e3c..fd318d49a8 100644
--- a/src/runtime/mfinal.go
+++ b/src/runtime/mfinal.go
@@ -163,6 +163,7 @@ func runfinq() {
 	var (
 		frame    unsafe.Pointer
 		framecap uintptr
+		argRegs  int
 	)
 
 	for {
@@ -176,6 +177,7 @@ func runfinq() {
 			goparkunlock(&finlock, waitReasonFinalizerWait, traceEvGoBlock, 1)
 			continue
 		}
+		argRegs = intArgRegs
 		unlock(&finlock)
 		if raceenabled {
 			racefingo()
@@ -184,7 +186,22 @@ func runfinq() {
 			for i := fb.cnt; i > 0; i-- {
 				f := &fb.fin[i-1]
 
-				framesz := unsafe.Sizeof((interface{})(nil)) + f.nret
+				var regs abi.RegArgs
+				var framesz uintptr
+				if argRegs > 0 {
+					// The args can always be passed in registers if they're
+					// available, because platforms we support always have no
+					// argument registers available, or more than 2.
+					//
+					// But unfortunately because we can have an arbitrary
+					// amount of returns and it would be complex to try and
+					// figure out how many of those can get passed in registers,
+					// just conservatively assume none of them do.
+					framesz = f.nret
+				} else {
+					// Need to pass arguments on the stack too.
+					framesz = unsafe.Sizeof((interface{})(nil)) + f.nret
+				}
 				if framecap < framesz {
 					// The frame does not contain pointers interesting for GC,
 					// all not yet finalized objects are stored in finq.
@@ -197,33 +214,34 @@ func runfinq() {
 				if f.fint == nil {
 					throw("missing type in runfinq")
 				}
-				// frame is effectively uninitialized
-				// memory. That means we have to clear
-				// it before writing to it to avoid
-				// confusing the write barrier.
-				*(*[2]uintptr)(frame) = [2]uintptr{}
+				r := frame
+				if argRegs > 0 {
+					r = unsafe.Pointer(&regs.Ints)
+				} else {
+					// frame is effectively uninitialized
+					// memory. That means we have to clear
+					// it before writing to it to avoid
+					// confusing the write barrier.
+					*(*[2]uintptr)(frame) = [2]uintptr{}
+				}
 				switch f.fint.kind & kindMask {
 				case kindPtr:
 					// direct use of pointer
-					*(*unsafe.Pointer)(frame) = f.arg
+					*(*unsafe.Pointer)(r) = f.arg
 				case kindInterface:
 					ityp := (*interfacetype)(unsafe.Pointer(f.fint))
 					// set up with empty interface
-					(*eface)(frame)._type = &f.ot.typ
-					(*eface)(frame).data = f.arg
+					(*eface)(r)._type = &f.ot.typ
+					(*eface)(r).data = f.arg
 					if len(ityp.mhdr) != 0 {
 						// convert to interface with methods
 						// this conversion is guaranteed to succeed - we checked in SetFinalizer
-						(*iface)(frame).tab = assertE2I(ityp, (*eface)(frame)._type)
+						(*iface)(r).tab = assertE2I(ityp, (*eface)(r)._type)
 					}
 				default:
 					throw("bad kind in runfinq")
 				}
 				fingRunning = true
-				// Pass a dummy RegArgs for now.
-				//
-				// TODO(mknyszek): Pass arguments in registers.
-				var regs abi.RegArgs
 				reflectcall(nil, unsafe.Pointer(f.fn), frame, uint32(framesz), uint32(framesz), uint32(framesz), &regs)
 				fingRunning = false
 
diff --git a/src/runtime/stubs.go b/src/runtime/stubs.go
index 5011d7199e..a2e04a64a5 100644
--- a/src/runtime/stubs.go
+++ b/src/runtime/stubs.go
@@ -396,3 +396,31 @@ func addmoduledata()
 // Injected by the signal handler for panicking signals. On many platforms it just
 // jumps to sigpanic.
 func sigpanic0()
+
+// intArgRegs is used by the various register assignment
+// algorithm implementations in the runtime. These include:.
+// - Finalizers (mfinal.go)
+// - Windows callbacks (syscall_windows.go)
+//
+// Both are stripped-down versions of the algorithm since they
+// only have to deal with a subset of cases (finalizers only
+// take a pointer or interface argument, Go Windows callbacks
+// don't support floating point).
+//
+// It should be modified with care and are generally only
+// modified when testing this package.
+//
+// It should never be set higher than its internal/abi
+// constant counterparts, because the system relies on a
+// structure that is at least large enough to hold the
+// registers the system supports.
+//
+// Currently it's set to zero because using the actual
+// constant will break every part of the toolchain that
+// uses finalizers or Windows callbacks to call functions
+// The value that is currently commented out there should be
+// the actual value once we're ready to use the register ABI
+// everywhere.
+//
+// Protected by finlock.
+var intArgRegs = 0 // abi.IntArgRegs
-- 
GitLab


From 0a655598e150ee8ddd96573744c4b60735658f32 Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Wed, 10 Mar 2021 14:32:27 -0600
Subject: [PATCH 1033/2400] cmd/link: fix glink resolver generation on ppc64le

AddSymRef grows the section to fit the relocation. This was not
being accounted for. Instead, add a relocation and explicitly
populate it so we patch the desired instructions.

Change-Id: I583147e2545aea34c854f9d35ca920c57be60b90
Reviewed-on: https://go-review.googlesource.com/c/go/+/300949
Run-TryBot: Paul Murphy <murp@ibm.com>
Run-TryBot: Lynn Boger <laboger@linux.vnet.ibm.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Lynn Boger <laboger@linux.vnet.ibm.com>
---
 src/cmd/link/internal/ppc64/asm.go | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/cmd/link/internal/ppc64/asm.go b/src/cmd/link/internal/ppc64/asm.go
index 602f0b5299..83df8a7a13 100644
--- a/src/cmd/link/internal/ppc64/asm.go
+++ b/src/cmd/link/internal/ppc64/asm.go
@@ -1039,8 +1039,11 @@ func ensureglinkresolver(ctxt *ld.Link, ldr *loader.Loader) *loader.SymbolBuilde
 	glink.AddUint32(ctxt.Arch, 0x7800f082) // srdi r0,r0,2
 
 	// r11 = address of the first byte of the PLT
-	glink.AddSymRef(ctxt.Arch, ctxt.PLT, 0, objabi.R_ADDRPOWER, 8)
-
+	r, _ := glink.AddRel(objabi.R_ADDRPOWER)
+	r.SetSym(ctxt.PLT)
+	r.SetSiz(8)
+	r.SetOff(int32(glink.Size()))
+	r.SetAdd(0)
 	glink.AddUint32(ctxt.Arch, 0x3d600000) // addis r11,0,.plt@ha
 	glink.AddUint32(ctxt.Arch, 0x396b0000) // addi r11,r11,.plt@l
 
-- 
GitLab


From bbf79793bdeda04d520377406024d7bb66aa62dc Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Thu, 25 Feb 2021 09:32:38 -0800
Subject: [PATCH 1034/2400] io/fs: clarify additional File interface docs

Emphasize ReadDirFile. It isn't really optional,
and all filesystems have at least one directory (".").

The remaining two additional interfaces are optimizations.
Call them that.

Fully qualify package package io identifiers.

Change-Id: Ibc425a5dfd27e08c2c10c353f780e4a6304cfd87
Reviewed-on: https://go-review.googlesource.com/c/go/+/296390
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/io/fs/fs.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/io/fs/fs.go b/src/io/fs/fs.go
index 3d2e2ee2ac..e1be32478e 100644
--- a/src/io/fs/fs.go
+++ b/src/io/fs/fs.go
@@ -73,8 +73,8 @@ func ValidPath(name string) bool {
 
 // A File provides access to a single file.
 // The File interface is the minimum implementation required of the file.
-// A file may implement additional interfaces, such as
-// ReadDirFile, ReaderAt, or Seeker, to provide additional or optimized functionality.
+// Directory files should also implement ReadDirFile.
+// A file may implement io.ReaderAt or io.Seeker as optimizations.
 type File interface {
 	Stat() (FileInfo, error)
 	Read([]byte) (int, error)
-- 
GitLab


From 1853411d8376570295711f9084d494d458822578 Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Thu, 25 Feb 2021 09:44:35 -0800
Subject: [PATCH 1035/2400] testing/fstest: test that ReadDirFile on a non-dir
 fails

ReadDirFile implementations should return an error for non-directories.

Change-Id: I99888562cb6cf829017904ae8c1e8887a416c4cd
Reviewed-on: https://go-review.googlesource.com/c/go/+/296391
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/testing/fstest/testfs.go | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/testing/fstest/testfs.go b/src/testing/fstest/testfs.go
index 736bbf0590..89c5fa19af 100644
--- a/src/testing/fstest/testfs.go
+++ b/src/testing/fstest/testfs.go
@@ -119,6 +119,9 @@ func (t *fsTester) openDir(dir string) fs.ReadDirFile {
 		t.errorf("%s: Open: %v", dir, err)
 		return nil
 	}
+	// It'd be nice to test here that f.Read fails, because f is a directory.
+	// However, FreeBSD supports calling read on a directory.
+	// See https://groups.google.com/g/golang-dev/c/rh8jwxyG1PQ.
 	d, ok := f.(fs.ReadDirFile)
 	if !ok {
 		f.Close()
@@ -514,6 +517,12 @@ func (t *fsTester) checkFile(file string) {
 		return
 	}
 
+	if dir, ok := f.(fs.ReadDirFile); ok {
+		if _, err := dir.ReadDir(-1); err == nil {
+			t.errorf("%s: ReadDir of non-dir file should return an error", file)
+		}
+	}
+
 	data, err := ioutil.ReadAll(f)
 	if err != nil {
 		f.Close()
-- 
GitLab


From 86d66784297f83f67088cea768611621048160da Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Thu, 25 Feb 2021 11:10:57 -0800
Subject: [PATCH 1036/2400] testing/fstest: clarify TestFS docs

The sentence starts "fsys must only contain",
which leads the reader to believe that fsys must not contain others.
The rapid reversal leads to confusion.
I had to read it several times to be sure I'd parsed it correctly.

Remove "only"; rely on the rest of the sentence to clarify.

Change-Id: I9fb7935aed4f9839344d3a00b761d20981fba864
Reviewed-on: https://go-review.googlesource.com/c/go/+/296529
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/testing/fstest/testfs.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/testing/fstest/testfs.go b/src/testing/fstest/testfs.go
index 89c5fa19af..27c603167f 100644
--- a/src/testing/fstest/testfs.go
+++ b/src/testing/fstest/testfs.go
@@ -23,7 +23,7 @@ import (
 // opening and checking that each file behaves correctly.
 // It also checks that the file system contains at least the expected files.
 // As a special case, if no expected files are listed, fsys must be empty.
-// Otherwise, fsys must only contain at least the listed files: it can also contain others.
+// Otherwise, fsys must contain at least the listed files; it can also contain others.
 // The contents of fsys must not change concurrently with TestFS.
 //
 // If TestFS finds any misbehaviors, it returns an error reporting all of them.
-- 
GitLab


From ae9cd1299cd927dca511344eec1ca16cf91ca758 Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Wed, 16 Dec 2020 20:22:58 -0800
Subject: [PATCH 1037/2400] hash/maphash: manually inline setSeed
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Provides a minor performance win.

name            old time/op    new time/op    delta
Hash8Bytes-8      16.5ns ± 2%    16.5ns ± 4%    ~     (p=0.407 n=27+29)
Hash320Bytes-8    58.5ns ± 2%    55.0ns ± 2%  -6.01%  (p=0.000 n=29+28)
Hash1K-8           195ns ± 1%     190ns ± 2%  -2.23%  (p=0.000 n=30+30)
Hash8K-8          1.59µs ± 2%    1.57µs ± 2%  -0.88%  (p=0.002 n=30+30)

name            old speed      new speed      delta
Hash8Bytes-8     484MB/s ± 2%   485MB/s ± 4%    ~     (p=0.417 n=27+29)
Hash320Bytes-8  5.47GB/s ± 2%  5.82GB/s ± 2%  +6.39%  (p=0.000 n=29+28)
Hash1K-8        5.26GB/s ± 1%  5.39GB/s ± 2%  +2.29%  (p=0.000 n=30+30)
Hash8K-8        5.16GB/s ± 2%  5.21GB/s ± 2%  +0.89%  (p=0.002 n=30+30)

Updates #42710

Change-Id: Ia0d7264b648f96099202de21c6b69a9c1776f6c8
Reviewed-on: https://go-review.googlesource.com/c/go/+/278759
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/hash/maphash/maphash.go | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/src/hash/maphash/maphash.go b/src/hash/maphash/maphash.go
index f7ef1b41e8..c45964f89e 100644
--- a/src/hash/maphash/maphash.go
+++ b/src/hash/maphash/maphash.go
@@ -68,7 +68,9 @@ type Hash struct {
 // which does call h.initSeed.)
 func (h *Hash) initSeed() {
 	if h.seed.s == 0 {
-		h.setSeed(MakeSeed())
+		seed := MakeSeed()
+		h.seed = seed
+		h.state = seed
 	}
 }
 
@@ -123,17 +125,12 @@ func (h *Hash) Seed() Seed {
 // Two Hash objects with different seeds will very likely behave differently.
 // Any bytes added to h before this call will be discarded.
 func (h *Hash) SetSeed(seed Seed) {
-	h.setSeed(seed)
-	h.n = 0
-}
-
-// setSeed sets seed without discarding accumulated data.
-func (h *Hash) setSeed(seed Seed) {
 	if seed.s == 0 {
 		panic("maphash: use of uninitialized Seed")
 	}
 	h.seed = seed
 	h.state = seed
+	h.n = 0
 }
 
 // Reset discards all bytes added to h.
-- 
GitLab


From 64d323f45a5d6a36cdcb190bed56424a633af3ad Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Wed, 16 Dec 2020 19:38:39 -0800
Subject: [PATCH 1038/2400] hash/maphash: optimize Write and WriteString
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The existing code makes copies of every byte it hashes.
When passed a large chunk of memory, Write and WriteString
can skip the copying and initSeed for most of it.

To ensure that Write, WriteByte, and WriteString continue to
generate output that depends only on the sequence of bytes,
expand the grouping test to include WriteString and interleaved calls.
Also, make the test process a lot more data, to ensure that
Write* handled full buffers correctly.

name            old time/op    new time/op    delta
Hash8Bytes-8      17.1ns ± 3%    16.5ns ± 2%   -3.26%  (p=0.000 n=29+27)
Hash320Bytes-8    74.9ns ± 2%    58.5ns ± 2%  -21.86%  (p=0.000 n=30+29)
Hash1K-8           246ns ± 3%     195ns ± 1%  -20.82%  (p=0.000 n=29+30)
Hash8K-8          1.87µs ± 2%    1.59µs ± 2%  -15.04%  (p=0.000 n=26+30)

name            old speed      new speed      delta
Hash8Bytes-8     468MB/s ± 3%   484MB/s ± 2%   +3.36%  (p=0.000 n=29+27)
Hash320Bytes-8  4.28GB/s ± 2%  5.47GB/s ± 2%  +27.97%  (p=0.000 n=30+29)
Hash1K-8        4.17GB/s ± 3%  5.26GB/s ± 1%  +26.28%  (p=0.000 n=29+30)
Hash8K-8        4.38GB/s ± 2%  5.16GB/s ± 2%  +17.70%  (p=0.000 n=26+30)

Updates #42710

Change-Id: If3cdec1580ffb3e36fab9865e5a9d089c0a34bec
Reviewed-on: https://go-review.googlesource.com/c/go/+/278758
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/hash/maphash/maphash.go      | 78 ++++++++++++++++++++++++--------
 src/hash/maphash/maphash_test.go | 57 +++++++++++++++++++----
 2 files changed, 107 insertions(+), 28 deletions(-)

diff --git a/src/hash/maphash/maphash.go b/src/hash/maphash/maphash.go
index c45964f89e..5cc0c581c7 100644
--- a/src/hash/maphash/maphash.go
+++ b/src/hash/maphash/maphash.go
@@ -13,7 +13,10 @@
 //
 package maphash
 
-import "unsafe"
+import (
+	"internal/unsafeheader"
+	"unsafe"
+)
 
 // A Seed is a random value that selects the specific hash function
 // computed by a Hash. If two Hashes use the same Seeds, they
@@ -54,13 +57,19 @@ type Seed struct {
 // If multiple goroutines must compute the same seeded hash,
 // each can declare its own Hash and call SetSeed with a common Seed.
 type Hash struct {
-	_     [0]func() // not comparable
-	seed  Seed      // initial seed used for this hash
-	state Seed      // current hash of all flushed bytes
-	buf   [64]byte  // unflushed byte buffer
-	n     int       // number of unflushed bytes
+	_     [0]func()     // not comparable
+	seed  Seed          // initial seed used for this hash
+	state Seed          // current hash of all flushed bytes
+	buf   [bufSize]byte // unflushed byte buffer
+	n     int           // number of unflushed bytes
 }
 
+// bufSize is the size of the Hash write buffer.
+// The buffer ensures that writes depend only on the sequence of bytes,
+// not the sequence of WriteByte/Write/WriteString calls,
+// by always calling rthash with a full buffer (except for the tail).
+const bufSize = 64
+
 // initSeed seeds the hash if necessary.
 // initSeed is called lazily before any operation that actually uses h.seed/h.state.
 // Note that this does not include Write/WriteByte/WriteString in the case
@@ -89,27 +98,58 @@ func (h *Hash) WriteByte(b byte) error {
 // It always writes all of b and never fails; the count and error result are for implementing io.Writer.
 func (h *Hash) Write(b []byte) (int, error) {
 	size := len(b)
-	for h.n+len(b) > len(h.buf) {
+	// Deal with bytes left over in h.buf.
+	// h.n <= bufSize is always true.
+	// Checking it is ~free and it lets the compiler eliminate a bounds check.
+	if h.n > 0 && h.n <= bufSize {
 		k := copy(h.buf[h.n:], b)
-		h.n = len(h.buf)
+		h.n += k
+		if h.n < bufSize {
+			// Copied the entirety of b to h.buf.
+			return size, nil
+		}
 		b = b[k:]
 		h.flush()
+		// No need to set h.n = 0 here; it happens just before exit.
+	}
+	// Process as many full buffers as possible, without copying, and calling initSeed only once.
+	if len(b) > bufSize {
+		h.initSeed()
+		for len(b) > bufSize {
+			h.state.s = rthash(&b[0], bufSize, h.state.s)
+			b = b[bufSize:]
+		}
 	}
-	h.n += copy(h.buf[h.n:], b)
+	// Copy the tail.
+	copy(h.buf[:], b)
+	h.n = len(b)
 	return size, nil
 }
 
 // WriteString adds the bytes of s to the sequence of bytes hashed by h.
 // It always writes all of s and never fails; the count and error result are for implementing io.StringWriter.
 func (h *Hash) WriteString(s string) (int, error) {
+	// WriteString mirrors Write. See Write for comments.
 	size := len(s)
-	for h.n+len(s) > len(h.buf) {
+	if h.n > 0 && h.n <= bufSize {
 		k := copy(h.buf[h.n:], s)
-		h.n = len(h.buf)
+		h.n += k
+		if h.n < bufSize {
+			return size, nil
+		}
 		s = s[k:]
 		h.flush()
 	}
-	h.n += copy(h.buf[h.n:], s)
+	if len(s) > bufSize {
+		h.initSeed()
+		for len(s) > bufSize {
+			ptr := (*byte)((*unsafeheader.String)(unsafe.Pointer(&s)).Data)
+			h.state.s = rthash(ptr, bufSize, h.state.s)
+			s = s[bufSize:]
+		}
+	}
+	copy(h.buf[:], s)
+	h.n = len(s)
 	return size, nil
 }
 
@@ -147,7 +187,7 @@ func (h *Hash) flush() {
 		panic("maphash: flush of partially full buffer")
 	}
 	h.initSeed()
-	h.state.s = rthash(h.buf[:], h.state.s)
+	h.state.s = rthash(&h.buf[0], h.n, h.state.s)
 	h.n = 0
 }
 
@@ -160,7 +200,7 @@ func (h *Hash) flush() {
 // by using bit masking, shifting, or modular arithmetic.
 func (h *Hash) Sum64() uint64 {
 	h.initSeed()
-	return rthash(h.buf[:h.n], h.state.s)
+	return rthash(&h.buf[0], h.n, h.state.s)
 }
 
 // MakeSeed returns a new random seed.
@@ -181,18 +221,18 @@ func MakeSeed() Seed {
 //go:linkname runtime_fastrand runtime.fastrand
 func runtime_fastrand() uint32
 
-func rthash(b []byte, seed uint64) uint64 {
-	if len(b) == 0 {
+func rthash(ptr *byte, len int, seed uint64) uint64 {
+	if len == 0 {
 		return seed
 	}
 	// The runtime hasher only works on uintptr. For 64-bit
 	// architectures, we use the hasher directly. Otherwise,
 	// we use two parallel hashers on the lower and upper 32 bits.
 	if unsafe.Sizeof(uintptr(0)) == 8 {
-		return uint64(runtime_memhash(unsafe.Pointer(&b[0]), uintptr(seed), uintptr(len(b))))
+		return uint64(runtime_memhash(unsafe.Pointer(ptr), uintptr(seed), uintptr(len)))
 	}
-	lo := runtime_memhash(unsafe.Pointer(&b[0]), uintptr(seed), uintptr(len(b)))
-	hi := runtime_memhash(unsafe.Pointer(&b[0]), uintptr(seed>>32), uintptr(len(b)))
+	lo := runtime_memhash(unsafe.Pointer(ptr), uintptr(seed), uintptr(len))
+	hi := runtime_memhash(unsafe.Pointer(ptr), uintptr(seed>>32), uintptr(len))
 	return uint64(hi)<<32 | uint64(lo)
 }
 
diff --git a/src/hash/maphash/maphash_test.go b/src/hash/maphash/maphash_test.go
index daf6eb4786..78cdfc0e73 100644
--- a/src/hash/maphash/maphash_test.go
+++ b/src/hash/maphash/maphash_test.go
@@ -5,6 +5,7 @@
 package maphash
 
 import (
+	"bytes"
 	"hash"
 	"testing"
 )
@@ -34,19 +35,57 @@ func TestSeededHash(t *testing.T) {
 }
 
 func TestHashGrouping(t *testing.T) {
-	b := []byte("foo")
-	h1 := new(Hash)
-	h2 := new(Hash)
-	h2.SetSeed(h1.Seed())
-	h1.Write(b)
-	for _, x := range b {
-		err := h2.WriteByte(x)
+	b := bytes.Repeat([]byte("foo"), 100)
+	hh := make([]*Hash, 7)
+	for i := range hh {
+		hh[i] = new(Hash)
+	}
+	for _, h := range hh[1:] {
+		h.SetSeed(hh[0].Seed())
+	}
+	hh[0].Write(b)
+	hh[1].WriteString(string(b))
+
+	writeByte := func(h *Hash, b byte) {
+		err := h.WriteByte(b)
 		if err != nil {
 			t.Fatalf("WriteByte: %v", err)
 		}
 	}
-	if h1.Sum64() != h2.Sum64() {
-		t.Errorf("hash of \"foo\" and \"f\",\"o\",\"o\" not identical")
+	writeSingleByte := func(h *Hash, b byte) {
+		_, err := h.Write([]byte{b})
+		if err != nil {
+			t.Fatalf("Write single byte: %v", err)
+		}
+	}
+	writeStringSingleByte := func(h *Hash, b byte) {
+		_, err := h.WriteString(string([]byte{b}))
+		if err != nil {
+			t.Fatalf("WriteString single byte: %v", err)
+		}
+	}
+
+	for i, x := range b {
+		writeByte(hh[2], x)
+		writeSingleByte(hh[3], x)
+		if i == 0 {
+			writeByte(hh[4], x)
+		} else {
+			writeSingleByte(hh[4], x)
+		}
+		writeStringSingleByte(hh[5], x)
+		if i == 0 {
+			writeByte(hh[6], x)
+		} else {
+			writeStringSingleByte(hh[6], x)
+		}
+	}
+
+	sum := hh[0].Sum64()
+	for i, h := range hh {
+		if sum != h.Sum64() {
+			t.Errorf("hash %d not identical to a single Write", i)
+		}
 	}
 }
 
-- 
GitLab


From b0733ba12d1190859a95ee93edac940de8052fed Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Wed, 16 Dec 2020 20:28:43 -0800
Subject: [PATCH 1039/2400] hash/maphash: increase the buffer size
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This helps a lot for larger writes.

name            old time/op    new time/op    delta
Hash8Bytes-8      16.5ns ± 4%    16.8ns ± 2%   +1.76%  (p=0.000 n=29+30)
Hash320Bytes-8    55.0ns ± 2%    41.4ns ± 2%  -24.64%  (p=0.000 n=28+28)
Hash1K-8           190ns ± 2%     130ns ± 3%  -31.65%  (p=0.000 n=30+30)
Hash8K-8          1.57µs ± 2%    1.05µs ± 3%  -33.01%  (p=0.000 n=30+29)

name            old speed      new speed      delta
Hash8Bytes-8     485MB/s ± 4%   476MB/s ± 2%   -1.73%  (p=0.000 n=29+30)
Hash320Bytes-8  5.82GB/s ± 2%  7.72GB/s ± 3%  +32.55%  (p=0.000 n=28+29)
Hash1K-8        5.39GB/s ± 2%  7.88GB/s ± 3%  +46.32%  (p=0.000 n=30+30)
Hash8K-8        5.21GB/s ± 2%  7.77GB/s ± 3%  +49.28%  (p=0.000 n=30+29)

Updates #42710

Change-Id: Idaf4b2a8a41fc62fc16b54c9358cf2cc7009cf29
Reviewed-on: https://go-review.googlesource.com/c/go/+/278760
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/hash/maphash/maphash.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/hash/maphash/maphash.go b/src/hash/maphash/maphash.go
index 5cc0c581c7..d022d746a7 100644
--- a/src/hash/maphash/maphash.go
+++ b/src/hash/maphash/maphash.go
@@ -68,7 +68,7 @@ type Hash struct {
 // The buffer ensures that writes depend only on the sequence of bytes,
 // not the sequence of WriteByte/Write/WriteString calls,
 // by always calling rthash with a full buffer (except for the tail).
-const bufSize = 64
+const bufSize = 128
 
 // initSeed seeds the hash if necessary.
 // initSeed is called lazily before any operation that actually uses h.seed/h.state.
-- 
GitLab


From 43d5f213e22029039f234edd1ac72c4ff9dd5ae9 Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Thu, 7 Jan 2021 19:25:05 -0800
Subject: [PATCH 1040/2400] cmd/compile: optimize multi-register shifts on
 amd64
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

amd64 can shift in bits from another register instead of filling with 0/1.
This pattern is helpful when implementing 128 bit shifts or arbitrary length shifts.
In the standard library, it shows up in pure Go math/big.

Benchmarks results on amd64 with -tags=math_big_pure_go.

name                          old time/op  new time/op  delta
NonZeroShifts/1/shrVU-8       4.45ns ± 3%  4.39ns ± 1%   -1.28%  (p=0.000 n=30+27)
NonZeroShifts/1/shlVU-8       4.13ns ± 4%  4.10ns ± 2%     ~     (p=0.254 n=29+28)
NonZeroShifts/2/shrVU-8       5.55ns ± 1%  5.63ns ± 2%   +1.42%  (p=0.000 n=28+29)
NonZeroShifts/2/shlVU-8       5.70ns ± 2%  5.14ns ± 1%   -9.82%  (p=0.000 n=29+28)
NonZeroShifts/3/shrVU-8       6.79ns ± 2%  6.35ns ± 2%   -6.46%  (p=0.000 n=28+29)
NonZeroShifts/3/shlVU-8       6.69ns ± 1%  6.25ns ± 1%   -6.60%  (p=0.000 n=28+27)
NonZeroShifts/4/shrVU-8       7.79ns ± 2%  7.06ns ± 2%   -9.48%  (p=0.000 n=30+30)
NonZeroShifts/4/shlVU-8       7.82ns ± 1%  7.24ns ± 1%   -7.37%  (p=0.000 n=28+29)
NonZeroShifts/5/shrVU-8       8.90ns ± 3%  7.93ns ± 1%  -10.84%  (p=0.000 n=29+26)
NonZeroShifts/5/shlVU-8       8.68ns ± 1%  7.92ns ± 1%   -8.76%  (p=0.000 n=29+29)
NonZeroShifts/10/shrVU-8      14.4ns ± 1%  12.3ns ± 2%  -14.79%  (p=0.000 n=28+29)
NonZeroShifts/10/shlVU-8      14.1ns ± 1%  11.9ns ± 2%  -15.55%  (p=0.000 n=28+27)
NonZeroShifts/100/shrVU-8      118ns ± 1%    96ns ± 3%  -18.82%  (p=0.000 n=30+29)
NonZeroShifts/100/shlVU-8      120ns ± 2%    98ns ± 2%  -18.46%  (p=0.000 n=29+28)
NonZeroShifts/1000/shrVU-8    1.10µs ± 1%  0.88µs ± 2%  -19.63%  (p=0.000 n=29+30)
NonZeroShifts/1000/shlVU-8    1.10µs ± 2%  0.88µs ± 2%  -20.28%  (p=0.000 n=29+28)
NonZeroShifts/10000/shrVU-8   10.9µs ± 1%   8.7µs ± 1%  -19.78%  (p=0.000 n=28+27)
NonZeroShifts/10000/shlVU-8   10.9µs ± 2%   8.7µs ± 1%  -19.64%  (p=0.000 n=29+27)
NonZeroShifts/100000/shrVU-8   111µs ± 2%    90µs ± 2%  -19.39%  (p=0.000 n=28+29)
NonZeroShifts/100000/shlVU-8   113µs ± 2%    90µs ± 2%  -20.43%  (p=0.000 n=30+27)

The assembly version is still faster, unfortunately, but the gap is narrowing.
Speedup from pure Go to assembly:

name                          old time/op  new time/op  delta
NonZeroShifts/1/shrVU-8       4.39ns ± 1%  3.45ns ± 2%  -21.36%  (p=0.000 n=27+29)
NonZeroShifts/1/shlVU-8       4.10ns ± 2%  3.47ns ± 3%  -15.42%  (p=0.000 n=28+30)
NonZeroShifts/2/shrVU-8       5.63ns ± 2%  3.97ns ± 0%  -29.40%  (p=0.000 n=29+25)
NonZeroShifts/2/shlVU-8       5.14ns ± 1%  3.77ns ± 2%  -26.65%  (p=0.000 n=28+26)
NonZeroShifts/3/shrVU-8       6.35ns ± 2%  4.79ns ± 2%  -24.52%  (p=0.000 n=29+29)
NonZeroShifts/3/shlVU-8       6.25ns ± 1%  4.42ns ± 1%  -29.29%  (p=0.000 n=27+26)
NonZeroShifts/4/shrVU-8       7.06ns ± 2%  5.64ns ± 1%  -20.05%  (p=0.000 n=30+29)
NonZeroShifts/4/shlVU-8       7.24ns ± 1%  5.34ns ± 2%  -26.23%  (p=0.000 n=29+29)
NonZeroShifts/5/shrVU-8       7.93ns ± 1%  6.56ns ± 2%  -17.26%  (p=0.000 n=26+30)
NonZeroShifts/5/shlVU-8       7.92ns ± 1%  6.27ns ± 1%  -20.79%  (p=0.000 n=29+25)
NonZeroShifts/10/shrVU-8      12.3ns ± 2%  10.2ns ± 2%  -17.21%  (p=0.000 n=29+29)
NonZeroShifts/10/shlVU-8      11.9ns ± 2%  10.5ns ± 2%  -12.45%  (p=0.000 n=27+29)
NonZeroShifts/100/shrVU-8     95.9ns ± 3%  77.7ns ± 1%  -19.00%  (p=0.000 n=29+30)
NonZeroShifts/100/shlVU-8     97.5ns ± 2%  66.8ns ± 2%  -31.47%  (p=0.000 n=28+30)
NonZeroShifts/1000/shrVU-8     884ns ± 2%   705ns ± 1%  -20.17%  (p=0.000 n=30+28)
NonZeroShifts/1000/shlVU-8     880ns ± 2%   590ns ± 1%  -32.96%  (p=0.000 n=28+25)
NonZeroShifts/10000/shrVU-8   8.74µs ± 1%  7.34µs ± 3%  -15.94%  (p=0.000 n=27+30)
NonZeroShifts/10000/shlVU-8   8.73µs ± 1%  6.00µs ± 1%  -31.25%  (p=0.000 n=27+28)
NonZeroShifts/100000/shrVU-8  89.6µs ± 2%  75.5µs ± 2%  -15.80%  (p=0.000 n=29+29)
NonZeroShifts/100000/shlVU-8  89.6µs ± 2%  68.0µs ± 3%  -24.09%  (p=0.000 n=27+30)

Change-Id: I18f58d8f5513d737d9cdf09b8f9d14011ffe3958
Reviewed-on: https://go-review.googlesource.com/c/go/+/297050
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/amd64/ssa.go        |  9 ++++
 src/cmd/compile/internal/ssa/gen/AMD64.rules |  3 ++
 src/cmd/compile/internal/ssa/gen/AMD64Ops.go |  4 ++
 src/cmd/compile/internal/ssa/opGen.go        | 36 +++++++++++++++
 src/cmd/compile/internal/ssa/rewriteAMD64.go | 48 ++++++++++++++++++++
 test/codegen/shift.go                        | 13 ++++++
 6 files changed, 113 insertions(+)

diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index af398c814a..3798c37b34 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -253,6 +253,15 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssa.OpAMD64BTRL, ssa.OpAMD64BTRQ:
 		opregreg(s, v.Op.Asm(), v.Reg(), v.Args[1].Reg())
 
+	case ssa.OpAMD64SHRDQ, ssa.OpAMD64SHLDQ:
+		p := s.Prog(v.Op.Asm())
+		lo, hi, bits := v.Args[0].Reg(), v.Args[1].Reg(), v.Args[2].Reg()
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = bits
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = lo
+		p.SetFrom3Reg(hi)
+
 	case ssa.OpAMD64DIVQU, ssa.OpAMD64DIVLU, ssa.OpAMD64DIVWU:
 		// Arg[0] (the dividend) is in AX.
 		// Arg[1] (the divisor) can be in any other register.
diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules
index c61b460a56..bece886c0d 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64.rules
+++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules
@@ -902,6 +902,9 @@
 ((SHRB|SARB)const           x [0]) => x
 ((ROLQ|ROLL|ROLW|ROLB)const x [0]) => x
 
+// Multi-register shifts
+(ORQ (SH(R|L)Q lo bits) (SH(L|R)Q hi (NEGQ bits))) => (SH(R|L)DQ lo hi bits)
+
 // Note: the word and byte shifts keep the low 5 bits (not the low 4 or 3 bits)
 // because the x86 instructions are defined to use all 5 bits of the shift even
 // for the small shifts. I don't think we'll ever generate a weird shift (e.g.
diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
index 5f5ebaaa35..6bf5be9e47 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
+++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
@@ -122,6 +122,7 @@ func init() {
 		gp21sp         = regInfo{inputs: []regMask{gpsp, gp}, outputs: gponly}
 		gp21sb         = regInfo{inputs: []regMask{gpspsbg, gpsp}, outputs: gponly}
 		gp21shift      = regInfo{inputs: []regMask{gp, cx}, outputs: []regMask{gp}}
+		gp31shift      = regInfo{inputs: []regMask{gp, gp, cx}, outputs: []regMask{gp}}
 		gp11div        = regInfo{inputs: []regMask{ax, gpsp &^ dx}, outputs: []regMask{ax, dx}}
 		gp21hmul       = regInfo{inputs: []regMask{ax, gpsp}, outputs: []regMask{dx}, clobbers: ax}
 		gp21flags      = regInfo{inputs: []regMask{gp, gp}, outputs: []regMask{gp, 0}}
@@ -408,6 +409,9 @@ func init() {
 		{name: "SARWconst", argLength: 1, reg: gp11, asm: "SARW", aux: "Int8", resultInArg0: true, clobberFlags: true}, // signed int16(arg0) >> auxint, shift amount 0-15
 		{name: "SARBconst", argLength: 1, reg: gp11, asm: "SARB", aux: "Int8", resultInArg0: true, clobberFlags: true}, // signed int8(arg0) >> auxint, shift amount 0-7
 
+		{name: "SHRDQ", argLength: 3, reg: gp31shift, asm: "SHRQ", resultInArg0: true, clobberFlags: true}, // unsigned arg0 >> arg2, shifting in bits from arg1 (==(arg1<<64+arg0)>>arg2, keeping low 64 bits), shift amount is mod 64
+		{name: "SHLDQ", argLength: 3, reg: gp31shift, asm: "SHLQ", resultInArg0: true, clobberFlags: true}, // unsigned arg0 << arg2, shifting in bits from arg1 (==(arg0<<64+arg1)<<arg2, keeping high 64 bits), shift amount is mod 64
+
 		{name: "ROLQ", argLength: 2, reg: gp21shift, asm: "ROLQ", resultInArg0: true, clobberFlags: true},              // arg0 rotate left arg1 bits.
 		{name: "ROLL", argLength: 2, reg: gp21shift, asm: "ROLL", resultInArg0: true, clobberFlags: true},              // arg0 rotate left arg1 bits.
 		{name: "ROLW", argLength: 2, reg: gp21shift, asm: "ROLW", resultInArg0: true, clobberFlags: true},              // arg0 rotate left arg1 bits.
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index 34445cfbf1..e65c4c4a18 100644
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -732,6 +732,8 @@ const (
 	OpAMD64SARLconst
 	OpAMD64SARWconst
 	OpAMD64SARBconst
+	OpAMD64SHRDQ
+	OpAMD64SHLDQ
 	OpAMD64ROLQ
 	OpAMD64ROLL
 	OpAMD64ROLW
@@ -9101,6 +9103,40 @@ var opcodeTable = [...]opInfo{
 			},
 		},
 	},
+	{
+		name:         "SHRDQ",
+		argLen:       3,
+		resultInArg0: true,
+		clobberFlags: true,
+		asm:          x86.ASHRQ,
+		reg: regInfo{
+			inputs: []inputInfo{
+				{2, 2},     // CX
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+			},
+			outputs: []outputInfo{
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+			},
+		},
+	},
+	{
+		name:         "SHLDQ",
+		argLen:       3,
+		resultInArg0: true,
+		clobberFlags: true,
+		asm:          x86.ASHLQ,
+		reg: regInfo{
+			inputs: []inputInfo{
+				{2, 2},     // CX
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+				{1, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+			},
+			outputs: []outputInfo{
+				{0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+			},
+		},
+	},
 	{
 		name:         "ROLQ",
 		argLen:       2,
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index d208624d0e..ac5bf9d928 100644
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -18743,6 +18743,54 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool {
 		}
 		break
 	}
+	// match: (ORQ (SHRQ lo bits) (SHLQ hi (NEGQ bits)))
+	// result: (SHRDQ lo hi bits)
+	for {
+		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
+			if v_0.Op != OpAMD64SHRQ {
+				continue
+			}
+			bits := v_0.Args[1]
+			lo := v_0.Args[0]
+			if v_1.Op != OpAMD64SHLQ {
+				continue
+			}
+			_ = v_1.Args[1]
+			hi := v_1.Args[0]
+			v_1_1 := v_1.Args[1]
+			if v_1_1.Op != OpAMD64NEGQ || bits != v_1_1.Args[0] {
+				continue
+			}
+			v.reset(OpAMD64SHRDQ)
+			v.AddArg3(lo, hi, bits)
+			return true
+		}
+		break
+	}
+	// match: (ORQ (SHLQ lo bits) (SHRQ hi (NEGQ bits)))
+	// result: (SHLDQ lo hi bits)
+	for {
+		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
+			if v_0.Op != OpAMD64SHLQ {
+				continue
+			}
+			bits := v_0.Args[1]
+			lo := v_0.Args[0]
+			if v_1.Op != OpAMD64SHRQ {
+				continue
+			}
+			_ = v_1.Args[1]
+			hi := v_1.Args[0]
+			v_1_1 := v_1.Args[1]
+			if v_1_1.Op != OpAMD64NEGQ || bits != v_1_1.Args[0] {
+				continue
+			}
+			v.reset(OpAMD64SHLDQ)
+			v.AddArg3(lo, hi, bits)
+			return true
+		}
+		break
+	}
 	// match: (ORQ (MOVQconst [c]) (MOVQconst [d]))
 	// result: (MOVQconst [c|d])
 	for {
diff --git a/test/codegen/shift.go b/test/codegen/shift.go
index ab0ffc2e13..06f6f12473 100644
--- a/test/codegen/shift.go
+++ b/test/codegen/shift.go
@@ -288,3 +288,16 @@ func checkMergedShifts32(a [256]uint32, b [256]uint64, u uint32, v uint32) {
 	//ppc64: -"SLD", "RLWNM\t[$]10, R[0-9]+, [$]22, [$]28, R[0-9]+"
 	b[2] = b[v>>25]
 }
+
+// 128 bit shifts
+
+func check128bitShifts(x, y uint64, bits uint) (uint64, uint64) {
+	s := bits & 63
+	ŝ := (64 - bits) & 63
+	// check that the shift operation has two commas (three operands)
+	// amd64:"SHRQ.*,.*,"
+	shr := x>>s | y<<ŝ
+	// amd64:"SHLQ.*,.*,"
+	shl := x<<s | y>>ŝ
+	return shr, shl
+}
-- 
GitLab


From 4dd9c7cadcbe689ef607931ed839456509e59104 Mon Sep 17 00:00:00 2001
From: Michael Matloob <matloob@golang.org>
Date: Fri, 11 Dec 2020 17:03:17 -0500
Subject: [PATCH 1041/2400] cmd/go: remove some fsyncs when writing files

cache.Trim, dowloadZip, rewriteVersionList, writeDiskCache all use
renameio.WriteFile to write their respective files to disk. For the
uses in cache.Trim and downloadZip, instead do of renameio.WriteFile,
do a truncate to the length of the file, then write the relevant bytes
so that a corrupt file (which would contain null bytes because of
the truncate) could be detected. For rewriteVersionList, use
lockedfile.Transform to do the write (which does a truncate as part of
the write too. writeDiskCache stays the same in this CL.

Also desete renameio methods that aren't used and remove the
renameio.WriteFile wrapper and just use renameio.WriteToFile which it
wraps.

There is a possibility of corrupt files in the cache (which was true
even before this CL) so later CLs will add facilities to clear corrupt
files in the cache.

Change-Id: I0d0bda40095e4cb898314315bf313e71650d8d25
Reviewed-on: https://go-review.googlesource.com/c/go/+/277412
Trust: Michael Matloob <matloob@golang.org>
Run-TryBot: Michael Matloob <matloob@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/cache/cache.go            | 23 +++++--
 src/cmd/go/internal/modfetch/cache.go         | 64 ++++++++++++------
 src/cmd/go/internal/modfetch/fetch.go         | 66 +++++++++++++++----
 src/cmd/go/internal/renameio/renameio.go      |  8 +--
 src/cmd/go/internal/renameio/renameio_test.go |  2 +-
 5 files changed, 118 insertions(+), 45 deletions(-)

diff --git a/src/cmd/go/internal/cache/cache.go b/src/cmd/go/internal/cache/cache.go
index 41f921641d..d592d70497 100644
--- a/src/cmd/go/internal/cache/cache.go
+++ b/src/cmd/go/internal/cache/cache.go
@@ -19,7 +19,7 @@ import (
 	"strings"
 	"time"
 
-	"cmd/go/internal/renameio"
+	"cmd/go/internal/lockedfile"
 )
 
 // An ActionID is a cache action key, the hash of a complete description of a
@@ -294,10 +294,17 @@ func (c *Cache) Trim() {
 	// We maintain in dir/trim.txt the time of the last completed cache trim.
 	// If the cache has been trimmed recently enough, do nothing.
 	// This is the common case.
-	data, _ := renameio.ReadFile(filepath.Join(c.dir, "trim.txt"))
-	t, err := strconv.ParseInt(strings.TrimSpace(string(data)), 10, 64)
-	if err == nil && now.Sub(time.Unix(t, 0)) < trimInterval {
-		return
+	// If the trim file is corrupt, detected if the file can't be parsed, or the
+	// trim time is too far in the future, attempt the trim anyway. It's possible that
+	// the cache was full when the corruption happened. Attempting a trim on
+	// an empty cache is cheap, so there wouldn't be a big performance hit in that case.
+	if data, err := lockedfile.Read(filepath.Join(c.dir, "trim.txt")); err == nil {
+		if t, err := strconv.ParseInt(strings.TrimSpace(string(data)), 10, 64); err == nil {
+			lastTrim := time.Unix(t, 0)
+			if d := now.Sub(lastTrim); d < trimInterval && d > -mtimeInterval {
+				return
+			}
+		}
 	}
 
 	// Trim each of the 256 subdirectories.
@@ -311,7 +318,11 @@ func (c *Cache) Trim() {
 
 	// Ignore errors from here: if we don't write the complete timestamp, the
 	// cache will appear older than it is, and we'll trim it again next time.
-	renameio.WriteFile(filepath.Join(c.dir, "trim.txt"), []byte(fmt.Sprintf("%d", now.Unix())), 0666)
+	var b bytes.Buffer
+	fmt.Fprintf(&b, "%d", now.Unix())
+	if err := lockedfile.Write(filepath.Join(c.dir, "trim.txt"), &b, 0666); err != nil {
+		return
+	}
 }
 
 // trimSubdir trims a single cache subdirectory.
diff --git a/src/cmd/go/internal/modfetch/cache.go b/src/cmd/go/internal/modfetch/cache.go
index 10f774568d..50a2898f24 100644
--- a/src/cmd/go/internal/modfetch/cache.go
+++ b/src/cmd/go/internal/modfetch/cache.go
@@ -104,7 +104,9 @@ func DownloadDir(m module.Version) (string, error) {
 
 	// Check if a .ziphash file exists. It should be created before the
 	// zip is extracted, but if it was deleted (by another program?), we need
-	// to re-calculate it.
+	// to re-calculate it. Note that checkMod will repopulate the ziphash
+	// file if it doesn't exist, but if the module is excluded by checks
+	// through GONOSUMDB or GOPRIVATE, that check and repopulation won't happen.
 	ziphashPath, err := CachePath(m, "ziphash")
 	if err != nil {
 		return dir, err
@@ -326,7 +328,7 @@ func InfoFile(path, version string) (string, error) {
 	}
 
 	// Stat should have populated the disk cache for us.
-	file, _, err := readDiskStat(path, version)
+	file, err := CachePath(module.Version{Path: path, Version: version}, "info")
 	if err != nil {
 		return "", err
 	}
@@ -378,7 +380,7 @@ func GoModFile(path, version string) (string, error) {
 		return "", err
 	}
 	// GoMod should have populated the disk cache for us.
-	file, _, err := readDiskGoMod(path, version)
+	file, err := CachePath(module.Version{Path: path, Version: version}, "mod")
 	if err != nil {
 		return "", err
 	}
@@ -590,27 +592,34 @@ func writeDiskCache(file string, data []byte) error {
 
 // rewriteVersionList rewrites the version list in dir
 // after a new *.mod file has been written.
-func rewriteVersionList(dir string) {
+func rewriteVersionList(dir string) (err error) {
 	if filepath.Base(dir) != "@v" {
 		base.Fatalf("go: internal error: misuse of rewriteVersionList")
 	}
 
 	listFile := filepath.Join(dir, "list")
 
-	// We use a separate lockfile here instead of locking listFile itself because
-	// we want to use Rename to write the file atomically. The list may be read by
-	// a GOPROXY HTTP server, and if we crash midway through a rewrite (or if the
-	// HTTP server ignores our locking and serves the file midway through a
-	// rewrite) it's better to serve a stale list than a truncated one.
-	unlock, err := lockedfile.MutexAt(listFile + ".lock").Lock()
+	// Lock listfile when writing to it to try to avoid corruption to the file.
+	// Under rare circumstances, for instance, if the system loses power in the
+	// middle of a write it is possible for corrupt data to be written. This is
+	// not a problem for the go command itself, but may be an issue if the the
+	// cache is being served by a GOPROXY HTTP server. This will be corrected
+	// the next time a new version of the module is fetched and the file is rewritten.
+	// TODO(matloob): golang.org/issue/43313 covers adding a go mod verify
+	// command that removes module versions that fail checksums. It should also
+	// remove list files that are detected to be corrupt.
+	f, err := lockedfile.Edit(listFile)
 	if err != nil {
-		base.Fatalf("go: can't lock version list lockfile: %v", err)
+		return err
 	}
-	defer unlock()
-
+	defer func() {
+		if cerr := f.Close(); cerr != nil && err == nil {
+			err = cerr
+		}
+	}()
 	infos, err := os.ReadDir(dir)
 	if err != nil {
-		return
+		return err
 	}
 	var list []string
 	for _, info := range infos {
@@ -635,14 +644,29 @@ func rewriteVersionList(dir string) {
 		buf.WriteString(v)
 		buf.WriteString("\n")
 	}
-	old, _ := renameio.ReadFile(listFile)
-	if bytes.Equal(buf.Bytes(), old) {
-		return
+	if fi, err := f.Stat(); err == nil && int(fi.Size()) == buf.Len() {
+		old := make([]byte, buf.Len()+1)
+		if n, err := f.ReadAt(old, 0); err == io.EOF && n == buf.Len() && bytes.Equal(buf.Bytes(), old) {
+			return nil // No edit needed.
+		}
 	}
-
-	if err := renameio.WriteFile(listFile, buf.Bytes(), 0666); err != nil {
-		base.Fatalf("go: failed to write version list: %v", err)
+	// Remove existing contents, so that when we truncate to the actual size it will zero-fill,
+	// and we will be able to detect (some) incomplete writes as files containing trailing NUL bytes.
+	if err := f.Truncate(0); err != nil {
+		return err
 	}
+	// Reserve the final size and zero-fill.
+	if err := f.Truncate(int64(buf.Len())); err != nil {
+		return err
+	}
+	// Write the actual contents. If this fails partway through,
+	// the remainder of the file should remain as zeroes.
+	if _, err := f.Write(buf.Bytes()); err != nil {
+		f.Truncate(0)
+		return err
+	}
+
+	return nil
 }
 
 func checkCacheDir() error {
diff --git a/src/cmd/go/internal/modfetch/fetch.go b/src/cmd/go/internal/modfetch/fetch.go
index 7b4ce2154c..4ee490c5ea 100644
--- a/src/cmd/go/internal/modfetch/fetch.go
+++ b/src/cmd/go/internal/modfetch/fetch.go
@@ -8,6 +8,8 @@ import (
 	"archive/zip"
 	"bytes"
 	"context"
+	"crypto/sha256"
+	"encoding/base64"
 	"errors"
 	"fmt"
 	"io"
@@ -296,12 +298,6 @@ func downloadZip(ctx context.Context, mod module.Version, zipfile string) (err e
 		}
 	}
 
-	// Sync the file before renaming it: otherwise, after a crash the reader may
-	// observe a 0-length file instead of the actual contents.
-	// See https://golang.org/issue/22397#issuecomment-380831736.
-	if err := f.Sync(); err != nil {
-		return err
-	}
 	if err := f.Close(); err != nil {
 		return err
 	}
@@ -332,7 +328,21 @@ func hashZip(mod module.Version, zipfile, ziphashfile string) error {
 	if err := checkModSum(mod, hash); err != nil {
 		return err
 	}
-	return renameio.WriteFile(ziphashfile, []byte(hash), 0666)
+	hf, err := lockedfile.Create(ziphashfile)
+	if err != nil {
+		return err
+	}
+	if err := hf.Truncate(int64(len(hash))); err != nil {
+		return err
+	}
+	if _, err := hf.WriteAt([]byte(hash), 0); err != nil {
+		return err
+	}
+	if err := hf.Close(); err != nil {
+		return err
+	}
+
+	return nil
 }
 
 // makeDirsReadOnly makes a best-effort attempt to remove write permissions for dir
@@ -483,11 +493,24 @@ func checkMod(mod module.Version) {
 	if err != nil {
 		base.Fatalf("verifying %v", module.VersionError(mod, err))
 	}
-	data, err := renameio.ReadFile(ziphash)
+	data, err := lockedfile.Read(ziphash)
 	if err != nil {
 		base.Fatalf("verifying %v", module.VersionError(mod, err))
 	}
-	h := strings.TrimSpace(string(data))
+	data = bytes.TrimSpace(data)
+	if !isValidSum(data) {
+		// Recreate ziphash file from zip file and use that to check the mod sum.
+		zip, err := CachePath(mod, "zip")
+		if err != nil {
+			base.Fatalf("verifying %v", module.VersionError(mod, err))
+		}
+		err = hashZip(mod, zip, ziphash)
+		if err != nil {
+			base.Fatalf("verifying %v", module.VersionError(mod, err))
+		}
+		return
+	}
+	h := string(data)
 	if !strings.HasPrefix(h, "h1:") {
 		base.Fatalf("verifying %v", module.VersionError(mod, fmt.Errorf("unexpected ziphash: %q", h)))
 	}
@@ -632,11 +655,32 @@ func Sum(mod module.Version) string {
 	if err != nil {
 		return ""
 	}
-	data, err := renameio.ReadFile(ziphash)
+	data, err := lockedfile.Read(ziphash)
 	if err != nil {
 		return ""
 	}
-	return strings.TrimSpace(string(data))
+	data = bytes.TrimSpace(data)
+	if !isValidSum(data) {
+		return ""
+	}
+	return string(data)
+}
+
+// isValidSum returns true if data is the valid contents of a zip hash file.
+// Certain critical files are written to disk by first truncating
+// then writing the actual bytes, so that if the write fails
+// the corrupt file should contain at least one of the null
+// bytes written by the truncate operation.
+func isValidSum(data []byte) bool {
+	if bytes.IndexByte(data, '\000') >= 0 {
+		return false
+	}
+
+	if len(data) != len("h1:")+base64.StdEncoding.EncodedLen(sha256.Size) {
+		return false
+	}
+
+	return true
 }
 
 // WriteGoSum writes the go.sum file if it needs to be updated.
diff --git a/src/cmd/go/internal/renameio/renameio.go b/src/cmd/go/internal/renameio/renameio.go
index 9788171d6e..811f4573a0 100644
--- a/src/cmd/go/internal/renameio/renameio.go
+++ b/src/cmd/go/internal/renameio/renameio.go
@@ -31,12 +31,6 @@ func Pattern(filename string) string {
 //
 // That ensures that the final location, if it exists, is always a complete file.
 func WriteFile(filename string, data []byte, perm fs.FileMode) (err error) {
-	return WriteToFile(filename, bytes.NewReader(data), perm)
-}
-
-// WriteToFile is a variant of WriteFile that accepts the data as an io.Reader
-// instead of a slice.
-func WriteToFile(filename string, data io.Reader, perm fs.FileMode) (err error) {
 	f, err := tempFile(filepath.Dir(filename), filepath.Base(filename), perm)
 	if err != nil {
 		return err
@@ -51,7 +45,7 @@ func WriteToFile(filename string, data io.Reader, perm fs.FileMode) (err error)
 		}
 	}()
 
-	if _, err := io.Copy(f, data); err != nil {
+	if _, err := io.Copy(f, bytes.NewReader(data)); err != nil {
 		return err
 	}
 	// Sync the file before renaming it: otherwise, after a crash the reader may
diff --git a/src/cmd/go/internal/renameio/renameio_test.go b/src/cmd/go/internal/renameio/renameio_test.go
index dc3c1415db..1c8d7e311d 100644
--- a/src/cmd/go/internal/renameio/renameio_test.go
+++ b/src/cmd/go/internal/renameio/renameio_test.go
@@ -82,7 +82,7 @@ func TestConcurrentReadsAndWrites(t *testing.T) {
 			}
 
 			time.Sleep(time.Duration(rand.Intn(100)) * time.Microsecond)
-			data, err := ReadFile(path)
+			data, err := robustio.ReadFile(path)
 			if err == nil {
 				atomic.AddInt64(&readSuccesses, 1)
 			} else if robustio.IsEphemeralError(err) {
-- 
GitLab


From b3896fc331c36a539f825f1f656cef3f9cdffd3f Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Thu, 11 Mar 2021 15:04:16 -0500
Subject: [PATCH 1042/2400] net/http: revert change to generated file from CL
 296152

This file is generated, so the fix needs to happen upstream.
The file can then be regenerated using 'go generate net/http'.

Updates #44143

Change-Id: I13a1e7677470ba84a06976e5bbe24f4ce1e7cfb2
Reviewed-on: https://go-review.googlesource.com/c/go/+/301069
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Reviewed-by: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/net/http/socks_bundle.go | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/net/http/socks_bundle.go b/src/net/http/socks_bundle.go
index fc22391039..e446669589 100644
--- a/src/net/http/socks_bundle.go
+++ b/src/net/http/socks_bundle.go
@@ -362,8 +362,6 @@ func (d *socksDialer) DialWithConn(ctx context.Context, c net.Conn, network, add
 // Unlike DialContext, it returns a raw transport connection instead
 // of a forward proxy connection.
 //
-// Dial uses context.Background internally.
-//
 // Deprecated: Use DialContext or DialWithConn instead.
 func (d *socksDialer) Dial(network, address string) (net.Conn, error) {
 	if err := d.validateTarget(network, address); err != nil {
-- 
GitLab


From 7fc638d6f1679f2e35862555531bf479c3e5b99c Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 23 Dec 2020 19:49:39 -0800
Subject: [PATCH 1043/2400] cmd: move GOEXPERIMENT knob from make.bash to
 cmd/go

This CL changes GOEXPERIMENT to act like other GO[CONFIG] environment
variables. Namely, that it can be set at make.bash time to provide a
default value used by the toolchain, but then can be manually set when
running either cmd/go or the individual tools (compiler, assembler,
linker).

For example, it's now possible to test rsc.io/tmp/fieldtrack by simply
running:

GOEXPERIMENT=fieldtrack go test -gcflags=-l rsc.io/tmp/fieldtrack \
  -ldflags=-k=rsc.io/tmp/fieldtrack.tracked

without needing to re-run make.bash. (-gcflags=-l is needed because
the compiler's inlining abilities have improved, so calling a function
with a for loop is no longer sufficient to suppress inlining.)

Fixes #42681.

Change-Id: I2cf8995d5d0d05f6785a2ee1d3b54b2cfb3331ca
Reviewed-on: https://go-review.googlesource.com/c/go/+/300991
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/asm/internal/lex/input.go | 10 ++++++++++
 src/cmd/dist/build.go             | 16 ++++------------
 src/cmd/dist/buildruntime.go      |  6 ++----
 src/cmd/go/internal/cfg/cfg.go    | 13 +++++++------
 src/cmd/go/internal/work/exec.go  |  8 ++++++++
 src/cmd/go/internal/work/gc.go    | 12 ------------
 src/cmd/internal/objabi/util.go   | 25 +++++++++++++------------
 src/cmd/link/internal/ld/main.go  |  2 ++
 src/internal/cfg/cfg.go           |  1 +
 src/runtime/heapdump.go           |  2 +-
 src/runtime/internal/sys/arch.go  |  2 ++
 src/runtime/proc.go               |  2 +-
 12 files changed, 51 insertions(+), 48 deletions(-)

diff --git a/src/cmd/asm/internal/lex/input.go b/src/cmd/asm/internal/lex/input.go
index da4ebe6d6e..1d4d4be7bd 100644
--- a/src/cmd/asm/internal/lex/input.go
+++ b/src/cmd/asm/internal/lex/input.go
@@ -45,6 +45,16 @@ func NewInput(name string) *Input {
 // predefine installs the macros set by the -D flag on the command line.
 func predefine(defines flags.MultiFlag) map[string]*Macro {
 	macros := make(map[string]*Macro)
+
+	if *flags.CompilingRuntime && objabi.Regabi_enabled != 0 {
+		const name = "GOEXPERIMENT_REGABI"
+		macros[name] = &Macro{
+			name:   name,
+			args:   nil,
+			tokens: Tokenize("1"),
+		}
+	}
+
 	for _, name := range defines {
 		value := "1"
 		i := strings.IndexRune(name, '=')
diff --git a/src/cmd/dist/build.go b/src/cmd/dist/build.go
index 158cedbadc..b2d13e7db4 100644
--- a/src/cmd/dist/build.go
+++ b/src/cmd/dist/build.go
@@ -39,6 +39,7 @@ var (
 	goextlinkenabled string
 	gogcflags        string // For running built compiler
 	goldflags        string
+	goexperiment     string
 	workdir          string
 	tooldir          string
 	oldgoos          string
@@ -194,6 +195,9 @@ func xinit() {
 		goextlinkenabled = b
 	}
 
+	goexperiment = os.Getenv("GOEXPERIMENT")
+	// TODO(mdempsky): Validate known experiments?
+
 	gogcflags = os.Getenv("BOOT_GO_GCFLAGS")
 	goldflags = os.Getenv("BOOT_GO_LDFLAGS")
 
@@ -834,18 +838,6 @@ func runInstall(pkg string, ch chan struct{}) {
 	goasmh := pathf("%s/go_asm.h", workdir)
 	if IsRuntimePackagePath(pkg) {
 		asmArgs = append(asmArgs, "-compiling-runtime")
-		if os.Getenv("GOEXPERIMENT") == "regabi" {
-			// In order to make it easier to port runtime assembly
-			// to the register ABI, we introduce a macro
-			// indicating the experiment is enabled.
-			//
-			// Note: a similar change also appears in
-			// cmd/go/internal/work/gc.go.
-			//
-			// TODO(austin): Remove this once we commit to the
-			// register ABI (#40724).
-			asmArgs = append(asmArgs, "-D=GOEXPERIMENT_REGABI=1")
-		}
 	}
 
 	// Collect symabis from assembly code.
diff --git a/src/cmd/dist/buildruntime.go b/src/cmd/dist/buildruntime.go
index 2744951597..e0a101a353 100644
--- a/src/cmd/dist/buildruntime.go
+++ b/src/cmd/dist/buildruntime.go
@@ -20,7 +20,6 @@ import (
 //	package sys
 //
 //	const TheVersion = <version>
-//	const Goexperiment = <goexperiment>
 //	const StackGuardMultiplier = <multiplier value>
 //
 func mkzversion(dir, file string) {
@@ -30,7 +29,6 @@ func mkzversion(dir, file string) {
 	fmt.Fprintf(&buf, "package sys\n")
 	fmt.Fprintln(&buf)
 	fmt.Fprintf(&buf, "const TheVersion = `%s`\n", findgoversion())
-	fmt.Fprintf(&buf, "const Goexperiment = `%s`\n", os.Getenv("GOEXPERIMENT"))
 	fmt.Fprintf(&buf, "const StackGuardMultiplierDefault = %d\n", stackGuardMultiplierDefault())
 
 	writefile(buf.String(), file, writeSkipSame)
@@ -48,10 +46,10 @@ func mkzversion(dir, file string) {
 //	const defaultGOPPC64 = <goppc64>
 //	const defaultGOOS = runtime.GOOS
 //	const defaultGOARCH = runtime.GOARCH
+//	const defaultGOEXPERIMENT = <goexperiment>
 //	const defaultGO_EXTLINK_ENABLED = <goextlinkenabled>
 //	const version = <version>
 //	const stackGuardMultiplierDefault = <multiplier value>
-//	const goexperiment = <goexperiment>
 //
 // The use of runtime.GOOS and runtime.GOARCH makes sure that
 // a cross-compiled compiler expects to compile for its own target
@@ -77,11 +75,11 @@ func mkzbootstrap(file string) {
 	fmt.Fprintf(&buf, "const defaultGOPPC64 = `%s`\n", goppc64)
 	fmt.Fprintf(&buf, "const defaultGOOS = runtime.GOOS\n")
 	fmt.Fprintf(&buf, "const defaultGOARCH = runtime.GOARCH\n")
+	fmt.Fprintf(&buf, "const defaultGOEXPERIMENT = `%s`\n", goexperiment)
 	fmt.Fprintf(&buf, "const defaultGO_EXTLINK_ENABLED = `%s`\n", goextlinkenabled)
 	fmt.Fprintf(&buf, "const defaultGO_LDSO = `%s`\n", defaultldso)
 	fmt.Fprintf(&buf, "const version = `%s`\n", findgoversion())
 	fmt.Fprintf(&buf, "const stackGuardMultiplierDefault = %d\n", stackGuardMultiplierDefault())
-	fmt.Fprintf(&buf, "const goexperiment = `%s`\n", os.Getenv("GOEXPERIMENT"))
 
 	writefile(buf.String(), file, writeSkipSame)
 }
diff --git a/src/cmd/go/internal/cfg/cfg.go b/src/cmd/go/internal/cfg/cfg.go
index 810189c15d..a91b6a57b9 100644
--- a/src/cmd/go/internal/cfg/cfg.go
+++ b/src/cmd/go/internal/cfg/cfg.go
@@ -252,12 +252,13 @@ var (
 	GOMODCACHE   = envOr("GOMODCACHE", gopathDir("pkg/mod"))
 
 	// Used in envcmd.MkEnv and build ID computations.
-	GOARM    = envOr("GOARM", fmt.Sprint(objabi.GOARM))
-	GO386    = envOr("GO386", objabi.GO386)
-	GOMIPS   = envOr("GOMIPS", objabi.GOMIPS)
-	GOMIPS64 = envOr("GOMIPS64", objabi.GOMIPS64)
-	GOPPC64  = envOr("GOPPC64", fmt.Sprintf("%s%d", "power", objabi.GOPPC64))
-	GOWASM   = envOr("GOWASM", fmt.Sprint(objabi.GOWASM))
+	GOARM        = envOr("GOARM", fmt.Sprint(objabi.GOARM))
+	GO386        = envOr("GO386", objabi.GO386)
+	GOMIPS       = envOr("GOMIPS", objabi.GOMIPS)
+	GOMIPS64     = envOr("GOMIPS64", objabi.GOMIPS64)
+	GOPPC64      = envOr("GOPPC64", fmt.Sprintf("%s%d", "power", objabi.GOPPC64))
+	GOWASM       = envOr("GOWASM", fmt.Sprint(objabi.GOWASM))
+	GOEXPERIMENT = envOr("GOEXPERIMENT", objabi.GOEXPERIMENT)
 
 	GOPROXY    = envOr("GOPROXY", "https://proxy.golang.org,direct")
 	GOSUMDB    = envOr("GOSUMDB", "sum.golang.org")
diff --git a/src/cmd/go/internal/work/exec.go b/src/cmd/go/internal/work/exec.go
index 3980c5f898..bd5ae46739 100644
--- a/src/cmd/go/internal/work/exec.go
+++ b/src/cmd/go/internal/work/exec.go
@@ -276,6 +276,10 @@ func (b *Builder) buildActionID(a *Action) cache.ActionID {
 		key, val := cfg.GetArchEnv()
 		fmt.Fprintf(h, "%s=%s\n", key, val)
 
+		if exp := cfg.Getenv("GOEXPERIMENT"); exp != "" {
+			fmt.Fprintf(h, "GOEXPERIMENT=%q\n", exp)
+		}
+
 		// TODO(rsc): Convince compiler team not to add more magic environment variables,
 		// or perhaps restrict the environment variables passed to subprocesses.
 		// Because these are clumsy, undocumented special-case hacks
@@ -1246,6 +1250,10 @@ func (b *Builder) printLinkerConfig(h io.Writer, p *load.Package) {
 		key, val := cfg.GetArchEnv()
 		fmt.Fprintf(h, "%s=%s\n", key, val)
 
+		if exp := cfg.Getenv("GOEXPERIMENT"); exp != "" {
+			fmt.Fprintf(h, "GOEXPERIMENT=%q\n", exp)
+		}
+
 		// The linker writes source file paths that say GOROOT_FINAL, but
 		// only if -trimpath is not specified (see ld() in gc.go).
 		gorootFinal := cfg.GOROOT_FINAL
diff --git a/src/cmd/go/internal/work/gc.go b/src/cmd/go/internal/work/gc.go
index 2087855b3c..3cb7c5aff3 100644
--- a/src/cmd/go/internal/work/gc.go
+++ b/src/cmd/go/internal/work/gc.go
@@ -343,18 +343,6 @@ func asmArgs(a *Action, p *load.Package) []interface{} {
 	}
 	if objabi.IsRuntimePackagePath(pkgpath) {
 		args = append(args, "-compiling-runtime")
-		if objabi.Regabi_enabled != 0 {
-			// In order to make it easier to port runtime assembly
-			// to the register ABI, we introduce a macro
-			// indicating the experiment is enabled.
-			//
-			// Note: a similar change also appears in
-			// cmd/dist/build.go.
-			//
-			// TODO(austin): Remove this once we commit to the
-			// register ABI (#40724).
-			args = append(args, "-D=GOEXPERIMENT_REGABI=1")
-		}
 	}
 
 	if cfg.Goarch == "mips" || cfg.Goarch == "mipsle" {
diff --git a/src/cmd/internal/objabi/util.go b/src/cmd/internal/objabi/util.go
index 1f99f8ed5d..de8e6de4e6 100644
--- a/src/cmd/internal/objabi/util.go
+++ b/src/cmd/internal/objabi/util.go
@@ -21,17 +21,18 @@ func envOr(key, value string) string {
 var (
 	defaultGOROOT string // set by linker
 
-	GOROOT   = envOr("GOROOT", defaultGOROOT)
-	GOARCH   = envOr("GOARCH", defaultGOARCH)
-	GOOS     = envOr("GOOS", defaultGOOS)
-	GO386    = envOr("GO386", defaultGO386)
-	GOARM    = goarm()
-	GOMIPS   = gomips()
-	GOMIPS64 = gomips64()
-	GOPPC64  = goppc64()
-	GOWASM   = gowasm()
-	GO_LDSO  = defaultGO_LDSO
-	Version  = version
+	GOROOT       = envOr("GOROOT", defaultGOROOT)
+	GOARCH       = envOr("GOARCH", defaultGOARCH)
+	GOOS         = envOr("GOOS", defaultGOOS)
+	GOEXPERIMENT = envOr("GOEXPERIMENT", defaultGOEXPERIMENT)
+	GO386        = envOr("GO386", defaultGO386)
+	GOARM        = goarm()
+	GOMIPS       = gomips()
+	GOMIPS64     = gomips64()
+	GOPPC64      = goppc64()
+	GOWASM       = gowasm()
+	GO_LDSO      = defaultGO_LDSO
+	Version      = version
 )
 
 const (
@@ -124,7 +125,7 @@ func Getgoextlinkenabled() string {
 }
 
 func init() {
-	for _, f := range strings.Split(goexperiment, ",") {
+	for _, f := range strings.Split(GOEXPERIMENT, ",") {
 		if f != "" {
 			addexp(f)
 		}
diff --git a/src/cmd/link/internal/ld/main.go b/src/cmd/link/internal/ld/main.go
index 68dee18598..8e9a9b9207 100644
--- a/src/cmd/link/internal/ld/main.go
+++ b/src/cmd/link/internal/ld/main.go
@@ -119,6 +119,8 @@ func Main(arch *sys.Arch, theArch Arch) {
 	addstrdata1(ctxt, "runtime.defaultGOROOT="+final)
 	addstrdata1(ctxt, "cmd/internal/objabi.defaultGOROOT="+final)
 
+	addstrdata1(ctxt, "runtime/internal/sys.GOEXPERIMENT="+objabi.GOEXPERIMENT)
+
 	// TODO(matloob): define these above and then check flag values here
 	if ctxt.Arch.Family == sys.AMD64 && objabi.GOOS == "plan9" {
 		flag.BoolVar(&flag8, "8", false, "use 64-bit addresses in symbol table")
diff --git a/src/internal/cfg/cfg.go b/src/internal/cfg/cfg.go
index 553021374d..815994b679 100644
--- a/src/internal/cfg/cfg.go
+++ b/src/internal/cfg/cfg.go
@@ -39,6 +39,7 @@ const KnownEnv = `
 	GOCACHE
 	GOENV
 	GOEXE
+	GOEXPERIMENT
 	GOFLAGS
 	GOGCCFLAGS
 	GOHOSTARCH
diff --git a/src/runtime/heapdump.go b/src/runtime/heapdump.go
index 1b8c19b476..e0913162a4 100644
--- a/src/runtime/heapdump.go
+++ b/src/runtime/heapdump.go
@@ -532,7 +532,7 @@ func dumpparams() {
 	dumpint(uint64(arenaStart))
 	dumpint(uint64(arenaEnd))
 	dumpstr(sys.GOARCH)
-	dumpstr(sys.Goexperiment)
+	dumpstr(sys.GOEXPERIMENT)
 	dumpint(uint64(ncpu))
 }
 
diff --git a/src/runtime/internal/sys/arch.go b/src/runtime/internal/sys/arch.go
index 3c99a2f7da..f00c55913f 100644
--- a/src/runtime/internal/sys/arch.go
+++ b/src/runtime/internal/sys/arch.go
@@ -52,3 +52,5 @@ const MinFrameSize = _MinFrameSize
 // StackAlign is the required alignment of the SP register.
 // The stack must be at least word aligned, but some architectures require more.
 const StackAlign = _StackAlign
+
+var GOEXPERIMENT string // set by cmd/link
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 5f372bb063..8db3b767d1 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -6027,7 +6027,7 @@ func setMaxThreads(in int) (out int) {
 }
 
 func haveexperiment(name string) bool {
-	x := sys.Goexperiment
+	x := sys.GOEXPERIMENT
 	for x != "" {
 		xname := ""
 		i := bytealg.IndexByteString(x, ',')
-- 
GitLab


From 71a6c13164f2151c14ebaeccdfcb3633fc8b618e Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Wed, 10 Mar 2021 19:28:28 -0800
Subject: [PATCH 1044/2400] cmd/compile:  call types.CheckSize() in g.typ()

Restore code to call types.CheckSize() in g.typ(). There are certain
cases (involving maps) where we need to do CheckSize here. In general,
the old typechecker calls CheckSize() a lot, and we want to eliminate
calling it eventually, so should get do types.CheckSize() when we create
a new concrete type.

However, the test typeparams/cons.go does not work with just calling
types.CheckSize() in g.typ() (which is why I disabled the calls
originally). The reason is that g.typ() is called recursively within
types.go, so it can be called on a partially-created recursive type,
which leads to an error in CheckSize(). So, we need to call CheckSize()
only on fully-created top-level types. So, I divided typ() into typ()
and typ1(), where typ() is now the external entry point, and typ1() is
called within types.go. Now, typ() can call CheckSize() safely.

I also added in an extra condition - we do not currently need to call
CheckSize() on non-fully-instantiated types, since they will not make it
to the backend.  That could change a bit with dictionaries.

Fixes #44895

Change-Id: I783aa7d2999dd882ddbd99a7c19a6ff6ee420102
Reviewed-on: https://go-review.googlesource.com/c/go/+/300989
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/types.go | 54 ++++++++++++++-----------
 1 file changed, 31 insertions(+), 23 deletions(-)

diff --git a/src/cmd/compile/internal/noder/types.go b/src/cmd/compile/internal/noder/types.go
index 96bf75d594..58b7262455 100644
--- a/src/cmd/compile/internal/noder/types.go
+++ b/src/cmd/compile/internal/noder/types.go
@@ -30,6 +30,23 @@ func (g *irgen) pkg(pkg *types2.Package) *types.Pkg {
 // typ converts a types2.Type to a types.Type, including caching of previously
 // translated types.
 func (g *irgen) typ(typ types2.Type) *types.Type {
+	res := g.typ1(typ)
+
+	// Calculate the size for all concrete types seen by the frontend. The old
+	// typechecker calls CheckSize() a lot, and we want to eliminate calling
+	// it eventually, so we should do it here instead. We only call it for
+	// top-level types (i.e. we do it here rather in typ1), to make sure that
+	// recursive types have been fully constructed before we call CheckSize.
+	if res != nil && !res.IsUntyped() && !res.IsFuncArgStruct() && !res.HasTParam() {
+		types.CheckSize(res)
+	}
+	return res
+}
+
+// typ1 is like typ, but doesn't call CheckSize, since it may have only
+// constructed part of a recursive type. Should not be called from outside this
+// file (g.typ is the "external" entry point).
+func (g *irgen) typ1(typ types2.Type) *types.Type {
 	// Cache type2-to-type mappings. Important so that each defined generic
 	// type (instantiated or not) has a single types.Type representation.
 	// Also saves a lot of computation and memory by avoiding re-translating
@@ -38,13 +55,6 @@ func (g *irgen) typ(typ types2.Type) *types.Type {
 	if !ok {
 		res = g.typ0(typ)
 		g.typs[typ] = res
-
-		// Ensure we calculate the size for all concrete types seen by
-		// the frontend. This is another heavy hammer for something that
-		// should really be the backend's responsibility instead.
-		//if res != nil && !res.IsUntyped() && !res.IsFuncArgStruct() {
-		//	types.CheckSize(res)
-		//}
 	}
 	return res
 }
@@ -121,12 +131,12 @@ func (g *irgen) typ0(typ types2.Type) *types.Type {
 			// instantiated type.
 			rparams := make([]*types.Type, len(typ.TArgs()))
 			for i, targ := range typ.TArgs() {
-				rparams[i] = g.typ(targ)
+				rparams[i] = g.typ1(targ)
 			}
 			ntyp.SetRParams(rparams)
 			//fmt.Printf("Saw new type %v %v\n", instName, ntyp.HasTParam())
 
-			ntyp.SetUnderlying(g.typ(typ.Underlying()))
+			ntyp.SetUnderlying(g.typ1(typ.Underlying()))
 			g.fillinMethods(typ, ntyp)
 			return ntyp
 		}
@@ -137,23 +147,23 @@ func (g *irgen) typ0(typ types2.Type) *types.Type {
 		return obj.Type()
 
 	case *types2.Array:
-		return types.NewArray(g.typ(typ.Elem()), typ.Len())
+		return types.NewArray(g.typ1(typ.Elem()), typ.Len())
 	case *types2.Chan:
-		return types.NewChan(g.typ(typ.Elem()), dirs[typ.Dir()])
+		return types.NewChan(g.typ1(typ.Elem()), dirs[typ.Dir()])
 	case *types2.Map:
-		return types.NewMap(g.typ(typ.Key()), g.typ(typ.Elem()))
+		return types.NewMap(g.typ1(typ.Key()), g.typ1(typ.Elem()))
 	case *types2.Pointer:
-		return types.NewPtr(g.typ(typ.Elem()))
+		return types.NewPtr(g.typ1(typ.Elem()))
 	case *types2.Signature:
 		return g.signature(nil, typ)
 	case *types2.Slice:
-		return types.NewSlice(g.typ(typ.Elem()))
+		return types.NewSlice(g.typ1(typ.Elem()))
 
 	case *types2.Struct:
 		fields := make([]*types.Field, typ.NumFields())
 		for i := range fields {
 			v := typ.Field(i)
-			f := types.NewField(g.pos(v), g.selector(v), g.typ(v.Type()))
+			f := types.NewField(g.pos(v), g.selector(v), g.typ1(v.Type()))
 			f.Note = typ.Tag(i)
 			if v.Embedded() {
 				f.Embedded = 1
@@ -167,7 +177,7 @@ func (g *irgen) typ0(typ types2.Type) *types.Type {
 		for i := range embeddeds {
 			// TODO(mdempsky): Get embedding position.
 			e := typ.EmbeddedType(i)
-			embeddeds[i] = types.NewField(src.NoXPos, nil, g.typ(e))
+			embeddeds[i] = types.NewField(src.NoXPos, nil, g.typ1(e))
 		}
 
 		methods := make([]*types.Field, typ.NumExplicitMethods())
@@ -190,7 +200,7 @@ func (g *irgen) typ0(typ types2.Type) *types.Type {
 
 		// TODO(danscales): we don't currently need to use the bounds
 		// anywhere, so eventually we can probably remove.
-		bound := g.typ(typ.Bound())
+		bound := g.typ1(typ.Bound())
 		*tp.Methods() = *bound.Methods()
 		return tp
 
@@ -205,8 +215,6 @@ func (g *irgen) typ0(typ types2.Type) *types.Type {
 			fields[i] = g.param(typ.At(i))
 		}
 		t := types.NewStruct(types.LocalPkg, fields)
-		//types.CheckSize(t)
-		// Can only set after doing the types.CheckSize()
 		t.StructType().Funarg = types.FunargResults
 		return t
 
@@ -223,7 +231,7 @@ func (g *irgen) fillinMethods(typ *types2.Named, ntyp *types.Type) {
 	if typ.NumMethods() != 0 {
 		targs := make([]ir.Node, len(typ.TArgs()))
 		for i, targ := range typ.TArgs() {
-			targs[i] = ir.TypeNode(g.typ(targ))
+			targs[i] = ir.TypeNode(g.typ1(targ))
 		}
 
 		methods := make([]*types.Field, typ.NumMethods())
@@ -256,7 +264,7 @@ func (g *irgen) fillinMethods(typ *types2.Named, ntyp *types.Type) {
 					rparams := types2.AsSignature(m.Type()).RParams()
 					tparams := make([]*types.Field, len(rparams))
 					for i, rparam := range rparams {
-						tparams[i] = types.NewField(src.NoXPos, nil, g.typ(rparam.Type()))
+						tparams[i] = types.NewField(src.NoXPos, nil, g.typ1(rparam.Type()))
 					}
 					assert(len(tparams) == len(targs))
 					subst := &subster{
@@ -286,7 +294,7 @@ func (g *irgen) signature(recv *types.Field, sig *types2.Signature) *types.Type
 	tparams := make([]*types.Field, len(tparams2))
 	for i := range tparams {
 		tp := tparams2[i]
-		tparams[i] = types.NewField(g.pos(tp), g.sym(tp), g.typ(tp.Type()))
+		tparams[i] = types.NewField(g.pos(tp), g.sym(tp), g.typ1(tp.Type()))
 	}
 
 	do := func(typ *types2.Tuple) []*types.Field {
@@ -306,7 +314,7 @@ func (g *irgen) signature(recv *types.Field, sig *types2.Signature) *types.Type
 }
 
 func (g *irgen) param(v *types2.Var) *types.Field {
-	return types.NewField(g.pos(v), g.sym(v), g.typ(v.Type()))
+	return types.NewField(g.pos(v), g.sym(v), g.typ1(v.Type()))
 }
 
 func (g *irgen) sym(obj types2.Object) *types.Sym {
-- 
GitLab


From a607408403df7515f831fef64991222673a50a68 Mon Sep 17 00:00:00 2001
From: fanzha02 <fannie.zhang@arm.com>
Date: Wed, 20 Jan 2021 17:58:21 +0800
Subject: [PATCH 1045/2400] cmd/internal/obj/arm64: add support for op(extended
 register) with RSP arguments

Refer to ARM reference manual, like add(extended register) instructions,
the extension is encoded in the "option" field. If "Rd" or "Rn" is
RSP and "option" is "010" then LSL is preferred. Therefore, the instrution
"add Rm<<imm, RSP, RSP" or "add Rm<<imm RSP" is valid and can be encoded
as add(extended register) instruction.

But the current assembler can not handle like "op R1<<1, RSP, RSP"
instructions, this patch adds the support.

Because MVN(extended register) does not exist, remove it.

Add test cases.

Change-Id: I968749d75c6b93a4f297b39c73cc292e6b1035ad
Reviewed-on: https://go-review.googlesource.com/c/go/+/284900
Trust: fannie zhang <Fannie.Zhang@arm.com>
Run-TryBot: fannie zhang <Fannie.Zhang@arm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/asm/internal/asm/testdata/arm64.s     | 10 ++++
 .../asm/internal/asm/testdata/arm64error.s    |  3 ++
 src/cmd/internal/obj/arm64/asm7.go            | 46 +++++++++++++++++--
 3 files changed, 54 insertions(+), 5 deletions(-)

diff --git a/src/cmd/asm/internal/asm/testdata/arm64.s b/src/cmd/asm/internal/asm/testdata/arm64.s
index 8635708320..d859171103 100644
--- a/src/cmd/asm/internal/asm/testdata/arm64.s
+++ b/src/cmd/asm/internal/asm/testdata/arm64.s
@@ -64,6 +64,16 @@ TEXT	foo(SB), DUPOK|NOSPLIT, $-8
 	CMN	R1.SXTX<<2, R10                 // 5fe921ab
 	CMPW	R2.UXTH<<3, R11                 // 7f2d226b
 	CMNW	R1.SXTB, R9                     // 3f81212b
+	ADD	R1<<1, RSP, R3                  // e367218b
+	ADDW	R1<<2, R3, RSP                  // 7f48210b
+	SUB	R1<<3, RSP                      // ff6f21cb
+	SUBS	R1<<4, RSP, R3                  // e37321eb
+	ADDS	R1<<1, RSP, R4                  // e46721ab
+	CMP	R1<<2, RSP                      // ff6b21eb
+	CMN	R1<<3, RSP                      // ff6f21ab
+	ADDS	R1<<1, ZR, R4                   // e40701ab
+	ADD	R3<<50, ZR, ZR                  // ffcb038b
+	CMP	R4<<24, ZR                      // ff6304eb
 	CMPW	$0x60060, R2                    // CMPW	$393312, R2                       // 1b0c8052db00a0725f001b6b
 	CMPW	$40960, R0                      // 1f284071
 	CMPW	$27745, R2                      // 3b8c8d525f001b6b
diff --git a/src/cmd/asm/internal/asm/testdata/arm64error.s b/src/cmd/asm/internal/asm/testdata/arm64error.s
index 1c8eaa1752..64bade2051 100644
--- a/src/cmd/asm/internal/asm/testdata/arm64error.s
+++ b/src/cmd/asm/internal/asm/testdata/arm64error.s
@@ -368,4 +368,7 @@ TEXT errors(SB),$0
 	CASPD	(R2, R3), (R2), (R9, R10)                        // ERROR "destination register pair must start from even register"
 	CASPD	(R2, R4), (R2), (R8, R9)                         // ERROR "source register pair must be contiguous"
 	CASPD	(R2, R3), (R2), (R8, R10)                        // ERROR "destination register pair must be contiguous"
+	ADD	R1>>2, RSP, R3                                   // ERROR "illegal combination"
+	ADDS	R2<<3, R3, RSP                                   // ERROR "unexpected SP reference"
+	CMP	R1<<5, RSP                                       // ERROR "the left shift amount out of range 0 to 4"
 	RET
diff --git a/src/cmd/internal/obj/arm64/asm7.go b/src/cmd/internal/obj/arm64/asm7.go
index e9f18e1bf0..275799aad3 100644
--- a/src/cmd/internal/obj/arm64/asm7.go
+++ b/src/cmd/internal/obj/arm64/asm7.go
@@ -321,15 +321,17 @@ var optab = []Optab{
 	{ACMP, C_VCON, C_REG, C_NONE, C_NONE, 13, 20, 0, 0, 0},
 	{AADD, C_SHIFT, C_REG, C_NONE, C_REG, 3, 4, 0, 0, 0},
 	{AADD, C_SHIFT, C_NONE, C_NONE, C_REG, 3, 4, 0, 0, 0},
+	{AADD, C_SHIFT, C_RSP, C_NONE, C_RSP, 107, 4, 0, 0, 0},
+	{AADD, C_SHIFT, C_NONE, C_NONE, C_RSP, 107, 4, 0, 0, 0},
 	{AMVN, C_SHIFT, C_NONE, C_NONE, C_REG, 3, 4, 0, 0, 0},
 	{ACMP, C_SHIFT, C_REG, C_NONE, C_NONE, 3, 4, 0, 0, 0},
+	{ACMP, C_SHIFT, C_RSP, C_NONE, C_NONE, 107, 4, 0, 0, 0},
 	{ANEG, C_SHIFT, C_NONE, C_NONE, C_REG, 26, 4, 0, 0, 0},
 	{AADD, C_REG, C_RSP, C_NONE, C_RSP, 27, 4, 0, 0, 0},
 	{AADD, C_REG, C_NONE, C_NONE, C_RSP, 27, 4, 0, 0, 0},
 	{ACMP, C_REG, C_RSP, C_NONE, C_NONE, 27, 4, 0, 0, 0},
 	{AADD, C_EXTREG, C_RSP, C_NONE, C_RSP, 27, 4, 0, 0, 0},
 	{AADD, C_EXTREG, C_NONE, C_NONE, C_RSP, 27, 4, 0, 0, 0},
-	{AMVN, C_EXTREG, C_NONE, C_NONE, C_RSP, 27, 4, 0, 0, 0},
 	{ACMP, C_EXTREG, C_RSP, C_NONE, C_NONE, 27, 4, 0, 0, 0},
 	{AADD, C_REG, C_REG, C_NONE, C_REG, 1, 4, 0, 0, 0},
 	{AADD, C_REG, C_NONE, C_NONE, C_REG, 1, 4, 0, 0, 0},
@@ -5458,6 +5460,41 @@ func (c *ctxt7) asmout(p *obj.Prog, o *Optab, out []uint32) {
 			c.ctxt.Diag("illegal destination register: %v\n", p)
 		}
 		o1 |= enc | uint32(rs&31)<<16 | uint32(rb&31)<<5 | uint32(rt&31)
+
+	case 107: // op R<<n, RSP, RSP (extended register)
+		// Refer to ARM reference manual, if "Rd" or "Rn" is RSP,
+		// it can be encoded as op(extended regster) instruction.
+		if !(p.To.Reg == REGSP || p.Reg == REGSP) {
+			c.ctxt.Diag("expected SP reference: %v", p)
+			break
+		}
+		if p.To.Reg == REGSP && (p.As == AADDS || p.As == AADDSW || p.As == ASUBS || p.As == ASUBSW) {
+			c.ctxt.Diag("unexpected SP reference: %v", p)
+			break
+		}
+		amount := (p.From.Offset >> 10) & 63
+		shift := (p.From.Offset >> 22) & 3
+		if shift != 0 {
+			c.ctxt.Diag("illegal combination: %v", p)
+			break
+		}
+
+		if amount > 4 {
+			c.ctxt.Diag("the left shift amount out of range 0 to 4: %v", p)
+			break
+		}
+		rf := (p.From.Offset >> 16) & 31
+		rt := int(p.To.Reg)
+		r := int(p.Reg)
+		if p.To.Type == obj.TYPE_NONE {
+			rt = REGZERO
+		}
+		if r == 0 {
+			r = rt
+		}
+
+		o1 = c.opxrrr(p, p.As, false)
+		o1 |= uint32(rf)<<16 | uint32(amount&7)<<10 | (uint32(r&31) << 5) | uint32(rt&31)
 	}
 	out[0] = o1
 	out[1] = o2
@@ -6394,11 +6431,10 @@ func (c *ctxt7) opbit(p *obj.Prog, a obj.As) uint32 {
 func (c *ctxt7) opxrrr(p *obj.Prog, a obj.As, extend bool) uint32 {
 	extension := uint32(0)
 	if !extend {
-		switch a {
-		case AADD, ACMN, AADDS, ASUB, ACMP, ASUBS:
+		if isADDop(a) {
 			extension = LSL0_64
-
-		case AADDW, ACMNW, AADDSW, ASUBW, ACMPW, ASUBSW:
+		}
+		if isADDWop(a) {
 			extension = LSL0_32
 		}
 	}
-- 
GitLab


From 71330963c080960f2f398fcd711a1fa14f68d503 Mon Sep 17 00:00:00 2001
From: Andy Pan <panjf2000@gmail.com>
Date: Thu, 11 Mar 2021 22:34:45 +0800
Subject: [PATCH 1046/2400] internal/poll: fix some grammar errors

Change-Id: I25a6424bce9d372fa46e8bdd856095845d3397bf
Reviewed-on: https://go-review.googlesource.com/c/go/+/300889
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/internal/poll/splice_linux.go | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/internal/poll/splice_linux.go b/src/internal/poll/splice_linux.go
index 971f754f43..49350b1ddc 100644
--- a/src/internal/poll/splice_linux.go
+++ b/src/internal/poll/splice_linux.go
@@ -160,9 +160,9 @@ type splicePipe struct {
 	data int
 }
 
-// splicePipePool caches pipes to avoid high frequency construction and destruction of pipe buffers.
-// The garbage collector will free all pipes in the sync.Pool in periodically, thus we need to set up
-// a finalizer for each pipe to close the its file descriptors before the actual GC.
+// splicePipePool caches pipes to avoid high-frequency construction and destruction of pipe buffers.
+// The garbage collector will free all pipes in the sync.Pool periodically, thus we need to set up
+// a finalizer for each pipe to close its file descriptors before the actual GC.
 var splicePipePool = sync.Pool{New: newPoolPipe}
 
 func newPoolPipe() interface{} {
@@ -175,10 +175,10 @@ func newPoolPipe() interface{} {
 	return p
 }
 
-// getPipe tries to acquire a pipe buffer from the pool or create a new one with newPipe() if it gets nil from cache.
+// getPipe tries to acquire a pipe buffer from the pool or create a new one with newPipe() if it gets nil from the cache.
 //
 // Note that it may fail to create a new pipe buffer by newPipe(), in which case getPipe() will return a generic error
-// and system call name splice in string as the indication.
+// and system call name splice in a string as the indication.
 func getPipe() (*splicePipe, string, error) {
 	v := splicePipePool.Get()
 	if v == nil {
-- 
GitLab


From e87c4bb3ef9d1f0aee3c9cc9fec8bef7fcadd6d8 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Wed, 10 Mar 2021 17:27:30 -0800
Subject: [PATCH 1047/2400] cmd/compile:  fix noder.Addr() to not call
 typechecker

Simple change to avoid calling the old typechecker in noder.Addr(). This
fixes cases where generic code calls a pointer method with a non-pointer
receiver.

Added test typeparam/lockable.go that now works with this change.

For lockable.go to work, also fix incorrect check to decide whether to
translate an OXDOT now or later. We should delay translating an OXDOT
until instantiation (because we don't know how embedding, etc. will
work) if the receiver has any typeparam, not just if the receiver type
is a simple typeparam. We also have to handle OXDOT for now in
IsAddressable(), until we can remove calls to the old typechecker in
(*irgen).funcBody().

Change-Id: I77ee5efcef9a8f6c7133564106a32437e36ba4bb
Reviewed-on: https://go-review.googlesource.com/c/go/+/300990
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/ir/expr.go       |  7 ++++
 src/cmd/compile/internal/noder/expr.go    |  2 +-
 src/cmd/compile/internal/noder/helpers.go |  9 ++--
 test/typeparam/lockable.go                | 50 +++++++++++++++++++++++
 4 files changed, 64 insertions(+), 4 deletions(-)
 create mode 100644 test/typeparam/lockable.go

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 65ed3cff66..2d62b22d8c 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -740,6 +740,13 @@ func IsAddressable(n Node) bool {
 	case ODEREF, ODOTPTR:
 		return true
 
+	case OXDOT:
+		// TODO(danscales): remove this case as we remove calls to the old
+		// typechecker in (*irgen).funcBody().
+		if base.Flag.G == 0 {
+			return false
+		}
+		fallthrough
 	case ODOT:
 		n := n.(*SelectorExpr)
 		return IsAddressable(n.X)
diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index 06aa91199c..989ebf236e 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -188,7 +188,7 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 // than in typecheck.go.
 func (g *irgen) selectorExpr(pos src.XPos, typ types2.Type, expr *syntax.SelectorExpr) ir.Node {
 	x := g.expr(expr.X)
-	if x.Type().Kind() == types.TTYPEPARAM {
+	if x.Type().HasTParam() {
 		// Leave a method call on a type param as an OXDOT, since it can
 		// only be fully transformed once it has an instantiated type.
 		n := ir.NewSelectorExpr(pos, ir.OXDOT, x, typecheck.Lookup(expr.Sel.Value))
diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
index 4cb6bc3eab..2b084ff311 100644
--- a/src/cmd/compile/internal/noder/helpers.go
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -54,8 +54,11 @@ func Nil(pos src.XPos, typ *types.Type) ir.Node {
 // Expressions
 
 func Addr(pos src.XPos, x ir.Node) *ir.AddrExpr {
-	// TODO(mdempsky): Avoid typecheck.Expr. Probably just need to set OPTRLIT when appropriate.
-	n := typecheck.Expr(typecheck.NodAddrAt(pos, x)).(*ir.AddrExpr)
+	n := typecheck.NodAddrAt(pos, x)
+	switch x.Op() {
+	case ir.OARRAYLIT, ir.OMAPLIT, ir.OSLICELIT, ir.OSTRUCTLIT:
+		n.SetOp(ir.OPTRLIT)
+	}
 	typed(types.NewPtr(x.Type()), n)
 	return n
 }
@@ -125,7 +128,7 @@ func Call(pos src.XPos, typ *types.Type, fun ir.Node, args []ir.Node, dots bool)
 	n.IsDDD = dots
 
 	if fun.Op() == ir.OXDOT {
-		if fun.(*ir.SelectorExpr).X.Type().Kind() != types.TTYPEPARAM {
+		if !fun.(*ir.SelectorExpr).X.Type().HasTParam() {
 			base.FatalfAt(pos, "Expecting type param receiver in %v", fun)
 		}
 		// For methods called in a generic function, don't do any extra
diff --git a/test/typeparam/lockable.go b/test/typeparam/lockable.go
new file mode 100644
index 0000000000..d53817521f
--- /dev/null
+++ b/test/typeparam/lockable.go
@@ -0,0 +1,50 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 "sync"
+
+// A _Lockable is a value that may be safely simultaneously accessed
+// from multiple goroutines via the Get and Set methods.
+type _Lockable[T any] struct {
+	T
+	mu sync.Mutex
+}
+
+// Get returns the value stored in a _Lockable.
+func (l *_Lockable[T]) get() T {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	return l.T
+}
+
+// set sets the value in a _Lockable.
+func (l *_Lockable[T]) set(v T) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.T = v
+}
+
+func main() {
+	sl := _Lockable[string]{T: "a"}
+	if got := sl.get(); got != "a" {
+		panic(got)
+	}
+	sl.set("b")
+	if got := sl.get(); got != "b" {
+		panic(got)
+	}
+
+	il := _Lockable[int]{T: 1}
+	if got := il.get(); got != 1 {
+		panic(got)
+	}
+	il.set(2)
+	if got := il.get(); got != 2 {
+		panic(got)
+	}
+}
-- 
GitLab


From e8b82789cda6c9d9e3dfc9a652b4d7a823b834f2 Mon Sep 17 00:00:00 2001
From: Andy Pan <panjf2000@gmail.com>
Date: Thu, 11 Mar 2021 14:22:16 +0800
Subject: [PATCH 1048/2400] A+C: add new e-mail addresses for Andy Pan

Change-Id: I2be9cba124b407f27823b3a3778331b6118112cd
Reviewed-on: https://go-review.googlesource.com/c/go/+/300470
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 AUTHORS      | 2 +-
 CONTRIBUTORS | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/AUTHORS b/AUTHORS
index eb05706811..1763ab88d8 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -145,7 +145,7 @@ Andy Davis <andy@bigandian.com>
 Andy Finkenstadt <afinkenstadt@zynga.com>
 Andy Lindeman <andy@lindeman.io>
 Andy Maloney <asmaloney@gmail.com>
-Andy Pan <panjf2000@gmail.com>
+Andy Pan <panjf2000@gmail.com> <panjf2000@golangcn.org> <i@andypan.me>
 Andy Walker <walkeraj@gmail.com>
 Anfernee Yongkun Gui <anfernee.gui@gmail.com>
 Angelo Bulfone <mbulfone@gmail.com>
diff --git a/CONTRIBUTORS b/CONTRIBUTORS
index b176a03328..5574026b75 100644
--- a/CONTRIBUTORS
+++ b/CONTRIBUTORS
@@ -240,7 +240,7 @@ Andy Davis <andy@bigandian.com>
 Andy Finkenstadt <afinkenstadt@zynga.com>
 Andy Lindeman <andy@lindeman.io>
 Andy Maloney <asmaloney@gmail.com>
-Andy Pan <panjf2000@gmail.com>
+Andy Pan <panjf2000@gmail.com> <panjf2000@golangcn.org> <i@andypan.me>
 Andy Walker <walkeraj@gmail.com>
 Andy Wang <cbeuw.andy@gmail.com>
 Andy Williams <andy@andy.xyz>
-- 
GitLab


From 9289c120025be6fef3a27732229a38df3ebf47c7 Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Fri, 12 Mar 2021 15:45:18 +0000
Subject: [PATCH 1049/2400] Revert "testing/fstest: test that ReadDirFile on a
 non-dir fails"

This reverts commit 1853411d8376570295711f9084d494d458822578.

Reason for revert: broke plan 9 builder. fixes #44967

Change-Id: Ib89448d37f7ab8bb05dbd89ce744431d807eb4da
Reviewed-on: https://go-review.googlesource.com/c/go/+/301190
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
---
 src/testing/fstest/testfs.go | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/src/testing/fstest/testfs.go b/src/testing/fstest/testfs.go
index 27c603167f..e0ad60a17b 100644
--- a/src/testing/fstest/testfs.go
+++ b/src/testing/fstest/testfs.go
@@ -119,9 +119,6 @@ func (t *fsTester) openDir(dir string) fs.ReadDirFile {
 		t.errorf("%s: Open: %v", dir, err)
 		return nil
 	}
-	// It'd be nice to test here that f.Read fails, because f is a directory.
-	// However, FreeBSD supports calling read on a directory.
-	// See https://groups.google.com/g/golang-dev/c/rh8jwxyG1PQ.
 	d, ok := f.(fs.ReadDirFile)
 	if !ok {
 		f.Close()
@@ -517,12 +514,6 @@ func (t *fsTester) checkFile(file string) {
 		return
 	}
 
-	if dir, ok := f.(fs.ReadDirFile); ok {
-		if _, err := dir.ReadDir(-1); err == nil {
-			t.errorf("%s: ReadDir of non-dir file should return an error", file)
-		}
-	}
-
 	data, err := ioutil.ReadAll(f)
 	if err != nil {
 		f.Close()
-- 
GitLab


From 086357e8f617c325339fdaedd13563dbdb05b00d Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Fri, 12 Mar 2021 11:21:38 -0500
Subject: [PATCH 1050/2400] cmd/go: include default GOEXPERIMENT in build
 config

Currently, the build config includes GOEXPERIMENT environment
variable if it is not empty, but that doesn't take the default
value (set at make.bash/bat/rc time) into consideration. This
may cause standard library packages appearing stale, as the
build config appears changed.

This CL changes it to use cfg.GOEXPERIMENT variable, which
includes the default value (if it is not overwritten).

May fix regabi and staticlockranking builders.

Change-Id: I242f887167f8e99192010be5c1a046eb88ab0c2a
Reviewed-on: https://go-review.googlesource.com/c/go/+/301269
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/internal/work/exec.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/go/internal/work/exec.go b/src/cmd/go/internal/work/exec.go
index bd5ae46739..fd3d3e03bb 100644
--- a/src/cmd/go/internal/work/exec.go
+++ b/src/cmd/go/internal/work/exec.go
@@ -276,7 +276,7 @@ func (b *Builder) buildActionID(a *Action) cache.ActionID {
 		key, val := cfg.GetArchEnv()
 		fmt.Fprintf(h, "%s=%s\n", key, val)
 
-		if exp := cfg.Getenv("GOEXPERIMENT"); exp != "" {
+		if exp := cfg.GOEXPERIMENT; exp != "" {
 			fmt.Fprintf(h, "GOEXPERIMENT=%q\n", exp)
 		}
 
@@ -1250,7 +1250,7 @@ func (b *Builder) printLinkerConfig(h io.Writer, p *load.Package) {
 		key, val := cfg.GetArchEnv()
 		fmt.Fprintf(h, "%s=%s\n", key, val)
 
-		if exp := cfg.Getenv("GOEXPERIMENT"); exp != "" {
+		if exp := cfg.GOEXPERIMENT; exp != "" {
 			fmt.Fprintf(h, "GOEXPERIMENT=%q\n", exp)
 		}
 
-- 
GitLab


From 735647d92e839f9ac3a91864a2c34263338a35e6 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 8 Mar 2021 15:36:28 -0800
Subject: [PATCH 1051/2400] runtime: add alignment info to sizeclasses.go
 comments

I was curious about the minimum possible alignment for each size class
and the minimum size to guarantee any particular alignment (e.g., to
know at what class size you can start assuming heap bits are byte- or
word-aligned).

Change-Id: I205b750286e8914986533c4f60712c420c3e63e9
Reviewed-on: https://go-review.googlesource.com/c/go/+/299909
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/runtime/mksizeclasses.go |  26 ++++++-
 src/runtime/sizeclasses.go   | 145 +++++++++++++++++++----------------
 2 files changed, 101 insertions(+), 70 deletions(-)

diff --git a/src/runtime/mksizeclasses.go b/src/runtime/mksizeclasses.go
index b4a117d343..8b9bbe01e6 100644
--- a/src/runtime/mksizeclasses.go
+++ b/src/runtime/mksizeclasses.go
@@ -37,6 +37,7 @@ import (
 	"go/format"
 	"io"
 	"log"
+	"math/bits"
 	"os"
 )
 
@@ -242,8 +243,9 @@ nextk:
 }
 
 func printComment(w io.Writer, classes []class) {
-	fmt.Fprintf(w, "// %-5s  %-9s  %-10s  %-7s  %-10s  %-9s\n", "class", "bytes/obj", "bytes/span", "objects", "tail waste", "max waste")
+	fmt.Fprintf(w, "// %-5s  %-9s  %-10s  %-7s  %-10s  %-9s  %-9s\n", "class", "bytes/obj", "bytes/span", "objects", "tail waste", "max waste", "min align")
 	prevSize := 0
+	var minAligns [32]int
 	for i, c := range classes {
 		if i == 0 {
 			continue
@@ -252,8 +254,28 @@ func printComment(w io.Writer, classes []class) {
 		objects := spanSize / c.size
 		tailWaste := spanSize - c.size*(spanSize/c.size)
 		maxWaste := float64((c.size-prevSize-1)*objects+tailWaste) / float64(spanSize)
+		alignBits := bits.TrailingZeros(uint(c.size))
+		for i := range minAligns {
+			if i > alignBits {
+				minAligns[i] = 0
+			} else if minAligns[i] == 0 {
+				minAligns[i] = c.size
+			}
+		}
 		prevSize = c.size
-		fmt.Fprintf(w, "// %5d  %9d  %10d  %7d  %10d  %8.2f%%\n", i, c.size, spanSize, objects, tailWaste, 100*maxWaste)
+		fmt.Fprintf(w, "// %5d  %9d  %10d  %7d  %10d  %8.2f%%  %9d\n", i, c.size, spanSize, objects, tailWaste, 100*maxWaste, 1<<alignBits)
+	}
+	fmt.Fprintf(w, "\n")
+
+	fmt.Fprintf(w, "// %-9s  %-4s  %-12s\n", "alignment", "bits", "min obj size")
+	for bits, size := range minAligns {
+		if size == 0 {
+			break
+		}
+		if bits+1 < len(minAligns) && size == minAligns[bits+1] {
+			continue
+		}
+		fmt.Fprintf(w, "// %9d  %4d  %12d\n", 1<<bits, bits, size)
 	}
 	fmt.Fprintf(w, "\n")
 }
diff --git a/src/runtime/sizeclasses.go b/src/runtime/sizeclasses.go
index c5521ce1bd..d71ceeab7b 100644
--- a/src/runtime/sizeclasses.go
+++ b/src/runtime/sizeclasses.go
@@ -3,74 +3,83 @@
 
 package runtime
 
-// class  bytes/obj  bytes/span  objects  tail waste  max waste
-//     1          8        8192     1024           0     87.50%
-//     2         16        8192      512           0     43.75%
-//     3         24        8192      341           8     29.24%
-//     4         32        8192      256           0     21.88%
-//     5         48        8192      170          32     31.52%
-//     6         64        8192      128           0     23.44%
-//     7         80        8192      102          32     19.07%
-//     8         96        8192       85          32     15.95%
-//     9        112        8192       73          16     13.56%
-//    10        128        8192       64           0     11.72%
-//    11        144        8192       56         128     11.82%
-//    12        160        8192       51          32      9.73%
-//    13        176        8192       46          96      9.59%
-//    14        192        8192       42         128      9.25%
-//    15        208        8192       39          80      8.12%
-//    16        224        8192       36         128      8.15%
-//    17        240        8192       34          32      6.62%
-//    18        256        8192       32           0      5.86%
-//    19        288        8192       28         128     12.16%
-//    20        320        8192       25         192     11.80%
-//    21        352        8192       23          96      9.88%
-//    22        384        8192       21         128      9.51%
-//    23        416        8192       19         288     10.71%
-//    24        448        8192       18         128      8.37%
-//    25        480        8192       17          32      6.82%
-//    26        512        8192       16           0      6.05%
-//    27        576        8192       14         128     12.33%
-//    28        640        8192       12         512     15.48%
-//    29        704        8192       11         448     13.93%
-//    30        768        8192       10         512     13.94%
-//    31        896        8192        9         128     15.52%
-//    32       1024        8192        8           0     12.40%
-//    33       1152        8192        7         128     12.41%
-//    34       1280        8192        6         512     15.55%
-//    35       1408       16384       11         896     14.00%
-//    36       1536        8192        5         512     14.00%
-//    37       1792       16384        9         256     15.57%
-//    38       2048        8192        4           0     12.45%
-//    39       2304       16384        7         256     12.46%
-//    40       2688        8192        3         128     15.59%
-//    41       3072       24576        8           0     12.47%
-//    42       3200       16384        5         384      6.22%
-//    43       3456       24576        7         384      8.83%
-//    44       4096        8192        2           0     15.60%
-//    45       4864       24576        5         256     16.65%
-//    46       5376       16384        3         256     10.92%
-//    47       6144       24576        4           0     12.48%
-//    48       6528       32768        5         128      6.23%
-//    49       6784       40960        6         256      4.36%
-//    50       6912       49152        7         768      3.37%
-//    51       8192        8192        1           0     15.61%
-//    52       9472       57344        6         512     14.28%
-//    53       9728       49152        5         512      3.64%
-//    54      10240       40960        4           0      4.99%
-//    55      10880       32768        3         128      6.24%
-//    56      12288       24576        2           0     11.45%
-//    57      13568       40960        3         256      9.99%
-//    58      14336       57344        4           0      5.35%
-//    59      16384       16384        1           0     12.49%
-//    60      18432       73728        4           0     11.11%
-//    61      19072       57344        3         128      3.57%
-//    62      20480       40960        2           0      6.87%
-//    63      21760       65536        3         256      6.25%
-//    64      24576       24576        1           0     11.45%
-//    65      27264       81920        3         128     10.00%
-//    66      28672       57344        2           0      4.91%
-//    67      32768       32768        1           0     12.50%
+// class  bytes/obj  bytes/span  objects  tail waste  max waste  min align
+//     1          8        8192     1024           0     87.50%          8
+//     2         16        8192      512           0     43.75%         16
+//     3         24        8192      341           8     29.24%          8
+//     4         32        8192      256           0     21.88%         32
+//     5         48        8192      170          32     31.52%         16
+//     6         64        8192      128           0     23.44%         64
+//     7         80        8192      102          32     19.07%         16
+//     8         96        8192       85          32     15.95%         32
+//     9        112        8192       73          16     13.56%         16
+//    10        128        8192       64           0     11.72%        128
+//    11        144        8192       56         128     11.82%         16
+//    12        160        8192       51          32      9.73%         32
+//    13        176        8192       46          96      9.59%         16
+//    14        192        8192       42         128      9.25%         64
+//    15        208        8192       39          80      8.12%         16
+//    16        224        8192       36         128      8.15%         32
+//    17        240        8192       34          32      6.62%         16
+//    18        256        8192       32           0      5.86%        256
+//    19        288        8192       28         128     12.16%         32
+//    20        320        8192       25         192     11.80%         64
+//    21        352        8192       23          96      9.88%         32
+//    22        384        8192       21         128      9.51%        128
+//    23        416        8192       19         288     10.71%         32
+//    24        448        8192       18         128      8.37%         64
+//    25        480        8192       17          32      6.82%         32
+//    26        512        8192       16           0      6.05%        512
+//    27        576        8192       14         128     12.33%         64
+//    28        640        8192       12         512     15.48%        128
+//    29        704        8192       11         448     13.93%         64
+//    30        768        8192       10         512     13.94%        256
+//    31        896        8192        9         128     15.52%        128
+//    32       1024        8192        8           0     12.40%       1024
+//    33       1152        8192        7         128     12.41%        128
+//    34       1280        8192        6         512     15.55%        256
+//    35       1408       16384       11         896     14.00%        128
+//    36       1536        8192        5         512     14.00%        512
+//    37       1792       16384        9         256     15.57%        256
+//    38       2048        8192        4           0     12.45%       2048
+//    39       2304       16384        7         256     12.46%        256
+//    40       2688        8192        3         128     15.59%        128
+//    41       3072       24576        8           0     12.47%       1024
+//    42       3200       16384        5         384      6.22%        128
+//    43       3456       24576        7         384      8.83%        128
+//    44       4096        8192        2           0     15.60%       4096
+//    45       4864       24576        5         256     16.65%        256
+//    46       5376       16384        3         256     10.92%        256
+//    47       6144       24576        4           0     12.48%       2048
+//    48       6528       32768        5         128      6.23%        128
+//    49       6784       40960        6         256      4.36%        128
+//    50       6912       49152        7         768      3.37%        256
+//    51       8192        8192        1           0     15.61%       8192
+//    52       9472       57344        6         512     14.28%        256
+//    53       9728       49152        5         512      3.64%        512
+//    54      10240       40960        4           0      4.99%       2048
+//    55      10880       32768        3         128      6.24%        128
+//    56      12288       24576        2           0     11.45%       4096
+//    57      13568       40960        3         256      9.99%        256
+//    58      14336       57344        4           0      5.35%       2048
+//    59      16384       16384        1           0     12.49%      16384
+//    60      18432       73728        4           0     11.11%       2048
+//    61      19072       57344        3         128      3.57%        128
+//    62      20480       40960        2           0      6.87%       4096
+//    63      21760       65536        3         256      6.25%        256
+//    64      24576       24576        1           0     11.45%       8192
+//    65      27264       81920        3         128     10.00%        128
+//    66      28672       57344        2           0      4.91%       4096
+//    67      32768       32768        1           0     12.50%      32768
+
+// alignment  bits  min obj size
+//         8     3             8
+//        16     4            32
+//        32     5           256
+//        64     6           512
+//       128     7           768
+//      4096    12         28672
+//     32768    15         32768
 
 const (
 	_MaxSmallSize   = 32768
-- 
GitLab


From 4662029264e79f144eef4323631b3356624e884f Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 11 Mar 2021 15:45:52 -0800
Subject: [PATCH 1052/2400] runtime: simplify divmagic for span calculations
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

It's both simpler and faster to just unconditionally do two 32-bit
multiplies rather than a bunch of branching to try to avoid them.
This is safe thanks to the tight bounds derived in [1] and verified
during mksizeclasses.go.

Benchstat results below for compilebench benchmarks on my P920. See
also [2] for micro benchmarks comparing the new functions against the
originals (as well as several basic attempts at optimizing them).

name                      old time/op       new time/op       delta
Template                        295ms ± 3%        290ms ± 1%  -1.95%  (p=0.000 n=20+20)
Unicode                         113ms ± 3%        110ms ± 2%  -2.32%  (p=0.000 n=21+17)
GoTypes                         1.78s ± 1%        1.76s ± 1%  -1.23%  (p=0.000 n=21+20)
Compiler                        119ms ± 2%        117ms ± 4%  -1.53%  (p=0.007 n=20+20)
SSA                             14.3s ± 1%        13.8s ± 1%  -3.12%  (p=0.000 n=17+20)
Flate                           173ms ± 2%        170ms ± 1%  -1.64%  (p=0.000 n=20+19)
GoParser                        278ms ± 2%        273ms ± 2%  -1.92%  (p=0.000 n=20+19)
Reflect                         686ms ± 3%        671ms ± 3%  -2.18%  (p=0.000 n=19+20)
Tar                             255ms ± 2%        248ms ± 2%  -2.90%  (p=0.000 n=20+20)
XML                             335ms ± 3%        327ms ± 2%  -2.34%  (p=0.000 n=20+20)
LinkCompiler                    799ms ± 1%        799ms ± 1%    ~     (p=0.925 n=20+20)
ExternalLinkCompiler            1.90s ± 1%        1.90s ± 0%    ~     (p=0.327 n=20+20)
LinkWithoutDebugCompiler        385ms ± 1%        386ms ± 1%    ~     (p=0.251 n=18+20)
[Geo mean]                      512ms             504ms       -1.61%

name                      old user-time/op  new user-time/op  delta
Template                        286ms ± 4%        282ms ± 4%  -1.42%  (p=0.025 n=21+20)
Unicode                         104ms ± 9%        102ms ±14%    ~     (p=0.294 n=21+20)
GoTypes                         1.75s ± 3%        1.72s ± 2%  -1.36%  (p=0.000 n=21+20)
Compiler                        109ms ±11%        108ms ± 8%    ~     (p=0.187 n=21+19)
SSA                             14.0s ± 1%        13.5s ± 2%  -3.25%  (p=0.000 n=16+20)
Flate                           166ms ± 4%        164ms ± 4%  -1.34%  (p=0.032 n=19+19)
GoParser                        268ms ± 4%        263ms ± 4%  -1.71%  (p=0.011 n=18+20)
Reflect                         666ms ± 3%        654ms ± 4%  -1.77%  (p=0.002 n=18+20)
Tar                             245ms ± 5%        236ms ± 6%  -3.34%  (p=0.000 n=20+20)
XML                             320ms ± 4%        314ms ± 3%  -2.01%  (p=0.001 n=19+18)
LinkCompiler                    744ms ± 4%        747ms ± 3%    ~     (p=0.627 n=20+19)
ExternalLinkCompiler            1.71s ± 3%        1.72s ± 2%    ~     (p=0.149 n=20+20)
LinkWithoutDebugCompiler        345ms ± 6%        342ms ± 8%    ~     (p=0.355 n=20+20)
[Geo mean]                      484ms             477ms       -1.50%

[1] Daniel Lemire, Owen Kaser, Nathan Kurz. 2019. "Faster Remainder by
Direct Computation: Applications to Compilers and Software Libraries."
https://arxiv.org/abs/1902.01961

[2] https://github.com/mdempsky/benchdivmagic

Change-Id: Ie4d214e7a908b0d979c878f2d404bd56bdf374f6
Reviewed-on: https://go-review.googlesource.com/c/go/+/300994
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/mbitmap.go       |  48 +++++++-------
 src/runtime/mcentral.go      |   2 +-
 src/runtime/mheap.go         |  16 +----
 src/runtime/mksizeclasses.go | 118 ++++++++++++++++-------------------
 src/runtime/sizeclasses.go   |  10 +--
 5 files changed, 80 insertions(+), 114 deletions(-)

diff --git a/src/runtime/mbitmap.go b/src/runtime/mbitmap.go
index fbfaae0f93..2d12c563b8 100644
--- a/src/runtime/mbitmap.go
+++ b/src/runtime/mbitmap.go
@@ -226,16 +226,25 @@ func (s *mspan) isFree(index uintptr) bool {
 	return *bytep&mask == 0
 }
 
-func (s *mspan) objIndex(p uintptr) uintptr {
-	byteOffset := p - s.base()
-	if byteOffset == 0 {
-		return 0
-	}
-	if s.baseMask != 0 {
-		// s.baseMask is non-0, elemsize is a power of two, so shift by s.divShift
-		return byteOffset >> s.divShift
+// divideByElemSize returns n/s.elemsize.
+// n must be within [0, s.npages*_PageSize),
+// or may be exactly s.npages*_PageSize
+// if s.elemsize is from sizeclasses.go.
+func (s *mspan) divideByElemSize(n uintptr) uintptr {
+	const doubleCheck = false
+
+	// See explanation in mksizeclasses.go's computeDivMagic.
+	q := uintptr((uint64(n) * uint64(s.divMul)) >> 32)
+
+	if doubleCheck && q != n/s.elemsize {
+		println(n, "/", s.elemsize, "should be", n/s.elemsize, "but got", q)
+		throw("bad magic division")
 	}
-	return uintptr(((uint64(byteOffset) >> s.divShift) * uint64(s.divMul)) >> s.divShift2)
+	return q
+}
+
+func (s *mspan) objIndex(p uintptr) uintptr {
+	return s.divideByElemSize(p - s.base())
 }
 
 func markBitsForAddr(p uintptr) markBits {
@@ -388,24 +397,9 @@ func findObject(p, refBase, refOff uintptr) (base uintptr, s *mspan, objIndex ui
 		}
 		return
 	}
-	// If this span holds object of a power of 2 size, just mask off the bits to
-	// the interior of the object. Otherwise use the size to get the base.
-	if s.baseMask != 0 {
-		// optimize for power of 2 sized objects.
-		base = s.base()
-		base = base + (p-base)&uintptr(s.baseMask)
-		objIndex = (base - s.base()) >> s.divShift
-		// base = p & s.baseMask is faster for small spans,
-		// but doesn't work for large spans.
-		// Overall, it's faster to use the more general computation above.
-	} else {
-		base = s.base()
-		if p-base >= s.elemsize {
-			// n := (p - base) / s.elemsize, using division by multiplication
-			objIndex = uintptr(p-base) >> s.divShift * uintptr(s.divMul) >> s.divShift2
-			base += objIndex * s.elemsize
-		}
-	}
+
+	objIndex = s.objIndex(p)
+	base = s.base() + objIndex*s.elemsize
 	return
 }
 
diff --git a/src/runtime/mcentral.go b/src/runtime/mcentral.go
index cd20dec539..8664ed48ab 100644
--- a/src/runtime/mcentral.go
+++ b/src/runtime/mcentral.go
@@ -236,7 +236,7 @@ func (c *mcentral) grow() *mspan {
 
 	// Use division by multiplication and shifts to quickly compute:
 	// n := (npages << _PageShift) / size
-	n := (npages << _PageShift) >> s.divShift * uintptr(s.divMul) >> s.divShift2
+	n := s.divideByElemSize(npages << _PageShift)
 	s.limit = s.base() + size*n
 	heapBitsForAddr(s.base()).initSpan(s)
 	return s
diff --git a/src/runtime/mheap.go b/src/runtime/mheap.go
index 1855330da5..08019a4101 100644
--- a/src/runtime/mheap.go
+++ b/src/runtime/mheap.go
@@ -451,14 +451,11 @@ type mspan struct {
 	// h->sweepgen is incremented by 2 after every GC
 
 	sweepgen    uint32
-	divMul      uint16        // for divide by elemsize - divMagic.mul
-	baseMask    uint16        // if non-0, elemsize is a power of 2, & this will get object allocation base
+	divMul      uint32        // for divide by elemsize
 	allocCount  uint16        // number of allocated objects
 	spanclass   spanClass     // size class and noscan (uint8)
 	state       mSpanStateBox // mSpanInUse etc; accessed atomically (get/set methods)
 	needzero    uint8         // needs to be zeroed before allocation
-	divShift    uint8         // for divide by elemsize - divMagic.shift
-	divShift2   uint8         // for divide by elemsize - divMagic.shift2
 	elemsize    uintptr       // computed from sizeclass or from npages
 	limit       uintptr       // end of data in span
 	speciallock mutex         // guards specials list
@@ -1224,20 +1221,11 @@ HaveSpan:
 		if sizeclass := spanclass.sizeclass(); sizeclass == 0 {
 			s.elemsize = nbytes
 			s.nelems = 1
-
-			s.divShift = 0
 			s.divMul = 0
-			s.divShift2 = 0
-			s.baseMask = 0
 		} else {
 			s.elemsize = uintptr(class_to_size[sizeclass])
 			s.nelems = nbytes / s.elemsize
-
-			m := &class_to_divmagic[sizeclass]
-			s.divShift = m.shift
-			s.divMul = m.mul
-			s.divShift2 = m.shift2
-			s.baseMask = m.baseMask
+			s.divMul = class_to_divmagic[sizeclass]
 		}
 
 		// Initialize mark and allocation structures.
diff --git a/src/runtime/mksizeclasses.go b/src/runtime/mksizeclasses.go
index 8b9bbe01e6..ddbf1bf7fe 100644
--- a/src/runtime/mksizeclasses.go
+++ b/src/runtime/mksizeclasses.go
@@ -37,6 +37,7 @@ import (
 	"go/format"
 	"io"
 	"log"
+	"math"
 	"math/bits"
 	"os"
 )
@@ -88,11 +89,6 @@ const (
 type class struct {
 	size   int // max size
 	npages int // number of pages
-
-	mul    int
-	shift  uint
-	shift2 uint
-	mask   int
 }
 
 func powerOfTwo(x int) bool {
@@ -169,9 +165,9 @@ func makeClasses() []class {
 	return classes
 }
 
-// computeDivMagic computes some magic constants to implement
-// the division required to compute object number from span offset.
-// n / c.size is implemented as n >> c.shift * c.mul >> c.shift2
+// computeDivMagic checks that the division required to compute object
+// index from span offset can be computed using 32-bit multiplication.
+// n / c.size is implemented as (n * (^uint32(0)/uint32(c.size) + 1)) >> 32
 // for all 0 <= n <= c.npages * pageSize
 func computeDivMagic(c *class) {
 	// divisor
@@ -183,62 +179,60 @@ func computeDivMagic(c *class) {
 	// maximum input value for which the formula needs to work.
 	max := c.npages * pageSize
 
+	// As reported in [1], if n and d are unsigned N-bit integers, we
+	// can compute n / d as ⌊n * c / 2^F⌋, where c is ⌈2^F / d⌉ and F is
+	// computed with:
+	//
+	// 	Algorithm 2: Algorithm to select the number of fractional bits
+	// 	and the scaled approximate reciprocal in the case of unsigned
+	// 	integers.
+	//
+	// 	if d is a power of two then
+	// 		Let F ← log₂(d) and c = 1.
+	// 	else
+	// 		Let F ← N + L where L is the smallest integer
+	// 		such that d ≤ (2^(N+L) mod d) + 2^L.
+	// 	end if
+	//
+	// [1] "Faster Remainder by Direct Computation: Applications to
+	// Compilers and Software Libraries" Daniel Lemire, Owen Kaser,
+	// Nathan Kurz arXiv:1902.01961
+	//
+	// To minimize the risk of introducing errors, we implement the
+	// algorithm exactly as stated, rather than trying to adapt it to
+	// fit typical Go idioms.
+	N := bits.Len(uint(max))
+	var F int
 	if powerOfTwo(d) {
-		// If the size is a power of two, heapBitsForObject can divide even faster by masking.
-		// Compute this mask.
-		if max >= 1<<16 {
-			panic("max too big for power of two size")
+		F = int(math.Log2(float64(d)))
+		if d != 1<<F {
+			panic("imprecise log2")
 		}
-		c.mask = 1<<16 - d
-	}
-
-	// Compute pre-shift by factoring power of 2 out of d.
-	for d%2 == 0 {
-		c.shift++
-		d >>= 1
-		max >>= 1
-	}
-
-	// Find the smallest k that works.
-	// A small k allows us to fit the math required into 32 bits
-	// so we can use 32-bit multiplies and shifts on 32-bit platforms.
-nextk:
-	for k := uint(0); ; k++ {
-		mul := (int(1)<<k + d - 1) / d //  ⌈2^k / d⌉
-
-		// Test to see if mul works.
-		for n := 0; n <= max; n++ {
-			if n*mul>>k != n/d {
-				continue nextk
+	} else {
+		for L := 0; ; L++ {
+			if d <= ((1<<(N+L))%d)+(1<<L) {
+				F = N + L
+				break
 			}
 		}
-		if mul >= 1<<16 {
-			panic("mul too big")
-		}
-		if uint64(mul)*uint64(max) >= 1<<32 {
-			panic("mul*max too big")
-		}
-		c.mul = mul
-		c.shift2 = k
-		break
 	}
 
-	// double-check.
+	// Also, noted in the paper, F is the smallest number of fractional
+	// bits required. We use 32 bits, because it works for all size
+	// classes and is fast on all CPU architectures that we support.
+	if F > 32 {
+		fmt.Printf("d=%d max=%d N=%d F=%d\n", c.size, max, N, F)
+		panic("size class requires more than 32 bits of precision")
+	}
+
+	// Brute force double-check with the exact computation that will be
+	// done by the runtime.
+	m := ^uint32(0)/uint32(c.size) + 1
 	for n := 0; n <= max; n++ {
-		if n*c.mul>>c.shift2 != n/d {
-			fmt.Printf("d=%d max=%d mul=%d shift2=%d n=%d\n", d, max, c.mul, c.shift2, n)
-			panic("bad multiply magic")
-		}
-		// Also check the exact computations that will be done by the runtime,
-		// for both 32 and 64 bit operations.
-		if uint32(n)*uint32(c.mul)>>uint8(c.shift2) != uint32(n/d) {
-			fmt.Printf("d=%d max=%d mul=%d shift2=%d n=%d\n", d, max, c.mul, c.shift2, n)
+		if uint32((uint64(n)*uint64(m))>>32) != uint32(n/c.size) {
+			fmt.Printf("d=%d max=%d m=%d n=%d\n", d, max, m, n)
 			panic("bad 32-bit multiply magic")
 		}
-		if uint64(n)*uint64(c.mul)>>uint8(c.shift2) != uint64(n/d) {
-			fmt.Printf("d=%d max=%d mul=%d shift2=%d n=%d\n", d, max, c.mul, c.shift2, n)
-			panic("bad 64-bit multiply magic")
-		}
 	}
 }
 
@@ -302,15 +296,13 @@ func printClasses(w io.Writer, classes []class) {
 	}
 	fmt.Fprintln(w, "}")
 
-	fmt.Fprintln(w, "type divMagic struct {")
-	fmt.Fprintln(w, "  shift uint8")
-	fmt.Fprintln(w, "  shift2 uint8")
-	fmt.Fprintln(w, "  mul uint16")
-	fmt.Fprintln(w, "  baseMask uint16")
-	fmt.Fprintln(w, "}")
-	fmt.Fprint(w, "var class_to_divmagic = [_NumSizeClasses]divMagic {")
+	fmt.Fprint(w, "var class_to_divmagic = [_NumSizeClasses]uint32 {")
 	for _, c := range classes {
-		fmt.Fprintf(w, "{%d,%d,%d,%d},", c.shift, c.shift2, c.mul, c.mask)
+		if c.size == 0 {
+			fmt.Fprintf(w, "0,")
+			continue
+		}
+		fmt.Fprintf(w, "^uint32(0)/%d+1,", c.size)
 	}
 	fmt.Fprintln(w, "}")
 
diff --git a/src/runtime/sizeclasses.go b/src/runtime/sizeclasses.go
index d71ceeab7b..65c72cfb1a 100644
--- a/src/runtime/sizeclasses.go
+++ b/src/runtime/sizeclasses.go
@@ -92,14 +92,6 @@ const (
 
 var class_to_size = [_NumSizeClasses]uint16{0, 8, 16, 24, 32, 48, 64, 80, 96, 112, 128, 144, 160, 176, 192, 208, 224, 240, 256, 288, 320, 352, 384, 416, 448, 480, 512, 576, 640, 704, 768, 896, 1024, 1152, 1280, 1408, 1536, 1792, 2048, 2304, 2688, 3072, 3200, 3456, 4096, 4864, 5376, 6144, 6528, 6784, 6912, 8192, 9472, 9728, 10240, 10880, 12288, 13568, 14336, 16384, 18432, 19072, 20480, 21760, 24576, 27264, 28672, 32768}
 var class_to_allocnpages = [_NumSizeClasses]uint8{0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 3, 2, 3, 1, 3, 2, 3, 4, 5, 6, 1, 7, 6, 5, 4, 3, 5, 7, 2, 9, 7, 5, 8, 3, 10, 7, 4}
-
-type divMagic struct {
-	shift    uint8
-	shift2   uint8
-	mul      uint16
-	baseMask uint16
-}
-
-var class_to_divmagic = [_NumSizeClasses]divMagic{{0, 0, 0, 0}, {3, 0, 1, 65528}, {4, 0, 1, 65520}, {3, 11, 683, 0}, {5, 0, 1, 65504}, {4, 11, 683, 0}, {6, 0, 1, 65472}, {4, 10, 205, 0}, {5, 9, 171, 0}, {4, 11, 293, 0}, {7, 0, 1, 65408}, {4, 13, 911, 0}, {5, 10, 205, 0}, {4, 12, 373, 0}, {6, 9, 171, 0}, {4, 13, 631, 0}, {5, 11, 293, 0}, {4, 13, 547, 0}, {8, 0, 1, 65280}, {5, 9, 57, 0}, {6, 9, 103, 0}, {5, 12, 373, 0}, {7, 7, 43, 0}, {5, 10, 79, 0}, {6, 10, 147, 0}, {5, 11, 137, 0}, {9, 0, 1, 65024}, {6, 9, 57, 0}, {7, 9, 103, 0}, {6, 11, 187, 0}, {8, 7, 43, 0}, {7, 8, 37, 0}, {10, 0, 1, 64512}, {7, 9, 57, 0}, {8, 6, 13, 0}, {7, 11, 187, 0}, {9, 5, 11, 0}, {8, 8, 37, 0}, {11, 0, 1, 63488}, {8, 9, 57, 0}, {7, 10, 49, 0}, {10, 5, 11, 0}, {7, 10, 41, 0}, {7, 9, 19, 0}, {12, 0, 1, 61440}, {8, 9, 27, 0}, {8, 10, 49, 0}, {11, 5, 11, 0}, {7, 13, 161, 0}, {7, 13, 155, 0}, {8, 9, 19, 0}, {13, 0, 1, 57344}, {8, 12, 111, 0}, {9, 9, 27, 0}, {11, 6, 13, 0}, {7, 14, 193, 0}, {12, 3, 3, 0}, {8, 13, 155, 0}, {11, 8, 37, 0}, {14, 0, 1, 49152}, {11, 8, 29, 0}, {7, 13, 55, 0}, {12, 5, 7, 0}, {8, 14, 193, 0}, {13, 3, 3, 0}, {7, 14, 77, 0}, {12, 7, 19, 0}, {15, 0, 1, 32768}}
+var class_to_divmagic = [_NumSizeClasses]uint32{0, ^uint32(0)/8 + 1, ^uint32(0)/16 + 1, ^uint32(0)/24 + 1, ^uint32(0)/32 + 1, ^uint32(0)/48 + 1, ^uint32(0)/64 + 1, ^uint32(0)/80 + 1, ^uint32(0)/96 + 1, ^uint32(0)/112 + 1, ^uint32(0)/128 + 1, ^uint32(0)/144 + 1, ^uint32(0)/160 + 1, ^uint32(0)/176 + 1, ^uint32(0)/192 + 1, ^uint32(0)/208 + 1, ^uint32(0)/224 + 1, ^uint32(0)/240 + 1, ^uint32(0)/256 + 1, ^uint32(0)/288 + 1, ^uint32(0)/320 + 1, ^uint32(0)/352 + 1, ^uint32(0)/384 + 1, ^uint32(0)/416 + 1, ^uint32(0)/448 + 1, ^uint32(0)/480 + 1, ^uint32(0)/512 + 1, ^uint32(0)/576 + 1, ^uint32(0)/640 + 1, ^uint32(0)/704 + 1, ^uint32(0)/768 + 1, ^uint32(0)/896 + 1, ^uint32(0)/1024 + 1, ^uint32(0)/1152 + 1, ^uint32(0)/1280 + 1, ^uint32(0)/1408 + 1, ^uint32(0)/1536 + 1, ^uint32(0)/1792 + 1, ^uint32(0)/2048 + 1, ^uint32(0)/2304 + 1, ^uint32(0)/2688 + 1, ^uint32(0)/3072 + 1, ^uint32(0)/3200 + 1, ^uint32(0)/3456 + 1, ^uint32(0)/4096 + 1, ^uint32(0)/4864 + 1, ^uint32(0)/5376 + 1, ^uint32(0)/6144 + 1, ^uint32(0)/6528 + 1, ^uint32(0)/6784 + 1, ^uint32(0)/6912 + 1, ^uint32(0)/8192 + 1, ^uint32(0)/9472 + 1, ^uint32(0)/9728 + 1, ^uint32(0)/10240 + 1, ^uint32(0)/10880 + 1, ^uint32(0)/12288 + 1, ^uint32(0)/13568 + 1, ^uint32(0)/14336 + 1, ^uint32(0)/16384 + 1, ^uint32(0)/18432 + 1, ^uint32(0)/19072 + 1, ^uint32(0)/20480 + 1, ^uint32(0)/21760 + 1, ^uint32(0)/24576 + 1, ^uint32(0)/27264 + 1, ^uint32(0)/28672 + 1, ^uint32(0)/32768 + 1}
 var size_to_class8 = [smallSizeMax/smallSizeDiv + 1]uint8{0, 1, 2, 3, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23, 24, 24, 24, 24, 25, 25, 25, 25, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 30, 30, 30, 30, 30, 30, 30, 30, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32}
 var size_to_class128 = [(_MaxSmallSize-smallSizeMax)/largeSizeDiv + 1]uint8{32, 33, 34, 35, 36, 37, 37, 38, 38, 39, 39, 40, 40, 40, 41, 41, 41, 42, 43, 43, 44, 44, 44, 44, 44, 45, 45, 45, 45, 45, 45, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 48, 48, 48, 49, 49, 50, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 53, 53, 54, 54, 54, 54, 55, 55, 55, 55, 55, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 58, 58, 58, 58, 58, 58, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 61, 61, 61, 61, 61, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67}
-- 
GitLab


From cdd08e615a9b92742b21a94443720b6d70452510 Mon Sep 17 00:00:00 2001
From: Roland Shoemaker <roland@golang.org>
Date: Fri, 12 Mar 2021 09:51:50 -0800
Subject: [PATCH 1053/2400] cmd/go/internal/load: always set IsImportCycle when
 in a cycle

When hitting an import cycle in reusePackage, and there is already
an error set, make sure IsImportCycle is set so that we don't
end up stuck in a loop.

Fixes #25830

Change-Id: Iba966aea4a637dfc34ee22782a477209ac48c9bd
Reviewed-on: https://go-review.googlesource.com/c/go/+/301289
Trust: Roland Shoemaker <roland@golang.org>
Run-TryBot: Roland Shoemaker <roland@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/internal/load/pkg.go               |  5 +++++
 src/cmd/go/testdata/script/list_err_cycle.txt | 15 +++++++++++++++
 2 files changed, 20 insertions(+)
 create mode 100644 src/cmd/go/testdata/script/list_err_cycle.txt

diff --git a/src/cmd/go/internal/load/pkg.go b/src/cmd/go/internal/load/pkg.go
index 8b12faf4cd..61fde895f8 100644
--- a/src/cmd/go/internal/load/pkg.go
+++ b/src/cmd/go/internal/load/pkg.go
@@ -1323,6 +1323,11 @@ func reusePackage(p *Package, stk *ImportStack) *Package {
 				Err:           errors.New("import cycle not allowed"),
 				IsImportCycle: true,
 			}
+		} else if !p.Error.IsImportCycle {
+			// If the error is already set, but it does not indicate that
+			// we are in an import cycle, set IsImportCycle so that we don't
+			// end up stuck in a loop down the road.
+			p.Error.IsImportCycle = true
 		}
 		p.Incomplete = true
 	}
diff --git a/src/cmd/go/testdata/script/list_err_cycle.txt b/src/cmd/go/testdata/script/list_err_cycle.txt
new file mode 100644
index 0000000000..44b82a62b0
--- /dev/null
+++ b/src/cmd/go/testdata/script/list_err_cycle.txt
@@ -0,0 +1,15 @@
+# Check that we don't get infinite recursion when loading a package with
+# an import cycle and another error. Verifies #25830.
+! go list
+stderr 'found packages a \(a.go\) and b \(b.go\)'
+
+-- go.mod --
+module errcycle
+
+go 1.16
+-- a.go --
+package a
+
+import _ "errcycle"
+-- b.go --
+package b
\ No newline at end of file
-- 
GitLab


From 7240a18adbfcff5cfe750a1fa4af0fd42ade4381 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Fri, 5 Mar 2021 14:24:41 -0500
Subject: [PATCH 1054/2400] cmd/compile: test register ABI for method,
 interface, closure calls

This is enabled with a ridiculous magic name for method,
or for last input type passed, that needs to be changed
to something inutterable before actual release.

Ridiculous method name: MagicMethodNameForTestingRegisterABI
Ridiculous last (input) type name: MagicLastTypeNameForTestingRegisterABI

RLTN is tested with strings.Contains, so you can have
MagicLastTypeNameForTestingRegisterABI1
and
MagicLastTypeNameForTestingRegisterABI2
if that is helpful

Includes test test/abi/fibish2.go

Updates #44816.

Change-Id: I592a6edc71ca9bebdd1d00e24edee1ceebb3e43f
Reviewed-on: https://go-review.googlesource.com/c/go/+/299410
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/expand_calls.go  | 54 ++++++++--------
 src/cmd/compile/internal/ssa/gen/AMD64Ops.go  |  8 +--
 .../compile/internal/ssa/gen/genericOps.go    | 27 ++++++--
 src/cmd/compile/internal/ssa/op.go            | 47 ++++++++++++--
 src/cmd/compile/internal/ssa/opGen.go         |  8 +--
 src/cmd/compile/internal/ssagen/ssa.go        | 61 ++++++++++++++++---
 test/abi/fibish2.go                           | 40 ++++++++++++
 test/abi/fibish2.out                          |  1 +
 test/abi/fibish_closure.go                    | 34 +++++++++++
 test/abi/fibish_closure.out                   |  1 +
 test/abi/methods.go                           | 51 ++++++++++++++++
 test/abi/methods.out                          |  2 +
 12 files changed, 279 insertions(+), 55 deletions(-)
 create mode 100644 test/abi/fibish2.go
 create mode 100644 test/abi/fibish2.out
 create mode 100644 test/abi/fibish_closure.go
 create mode 100644 test/abi/fibish_closure.out
 create mode 100644 test/abi/methods.go
 create mode 100644 test/abi/methods.out

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index 6e2004224f..29a8f670b0 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -386,41 +386,34 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64,
 		which := selector.AuxInt
 		if which == aux.NResults() { // mem is after the results.
 			// rewrite v as a Copy of call -- the replacement call will produce a mem.
-			if call.Op == OpStaticLECall {
-				if leaf != selector {
-					panic("Unexpected selector of memory")
-				}
-				// StaticCall selector will address last element of Result.
-				// TODO do this for all the other call types eventually.
-				if aux.abiInfo == nil {
-					panic(badVal("aux.abiInfo nil for call", call))
-				}
-				if existing := x.memForCall[call.ID]; existing == nil {
-					selector.AuxInt = int64(aux.abiInfo.OutRegistersUsed())
-					x.memForCall[call.ID] = selector
-				} else {
-					selector.copyOf(existing)
-				}
+			if leaf != selector {
+				panic("Unexpected selector of memory")
+			}
+			if aux.abiInfo == nil {
+				panic(badVal("aux.abiInfo nil for call", call))
+			}
+			if existing := x.memForCall[call.ID]; existing == nil {
+				selector.AuxInt = int64(aux.abiInfo.OutRegistersUsed())
+				x.memForCall[call.ID] = selector
 			} else {
-				leaf.copyOf(call)
+				selector.copyOf(existing)
 			}
+
 		} else {
 			leafType := removeTrivialWrapperTypes(leaf.Type)
 			if x.canSSAType(leafType) {
 				pt := types.NewPtr(leafType)
 				// Any selection right out of the arg area/registers has to be same Block as call, use call as mem input.
-				if call.Op == OpStaticLECall { // TODO this is temporary until all calls are register-able
-					// Create a "mem" for any loads that need to occur.
-					if mem := x.memForCall[call.ID]; mem != nil {
-						if mem.Block != call.Block {
-							panic(fmt.Errorf("selector and call need to be in same block, selector=%s; call=%s", selector.LongString(), call.LongString()))
-						}
-						call = mem
-					} else {
-						mem = call.Block.NewValue1I(call.Pos.WithNotStmt(), OpSelectN, types.TypeMem, int64(aux.abiInfo.OutRegistersUsed()), call)
-						x.memForCall[call.ID] = mem
-						call = mem
+				// Create a "mem" for any loads that need to occur.
+				if mem := x.memForCall[call.ID]; mem != nil {
+					if mem.Block != call.Block {
+						panic(fmt.Errorf("selector and call need to be in same block, selector=%s; call=%s", selector.LongString(), call.LongString()))
 					}
+					call = mem
+				} else {
+					mem = call.Block.NewValue1I(call.Pos.WithNotStmt(), OpSelectN, types.TypeMem, int64(aux.abiInfo.OutRegistersUsed()), call)
+					x.memForCall[call.ID] = mem
+					call = mem
 				}
 				outParam := aux.abiInfo.OutParam(int(which))
 				if len(outParam.Registers) > 0 {
@@ -1350,14 +1343,15 @@ func expandCalls(f *Func) {
 			case OpStaticLECall:
 				v.Op = OpStaticCall
 				rts := abi.RegisterTypes(v.Aux.(*AuxCall).abiInfo.OutParams())
-				// TODO need to insert all the register types.
 				v.Type = types.NewResults(append(rts, types.TypeMem))
 			case OpClosureLECall:
 				v.Op = OpClosureCall
-				v.Type = types.TypeMem
+				rts := abi.RegisterTypes(v.Aux.(*AuxCall).abiInfo.OutParams())
+				v.Type = types.NewResults(append(rts, types.TypeMem))
 			case OpInterLECall:
 				v.Op = OpInterCall
-				v.Type = types.TypeMem
+				rts := abi.RegisterTypes(v.Aux.(*AuxCall).abiInfo.OutParams())
+				v.Type = types.NewResults(append(rts, types.TypeMem))
 			}
 		}
 	}
diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
index 6bf5be9e47..6c3fe1d192 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
+++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
@@ -775,10 +775,10 @@ func init() {
 			faultOnNilArg0: true,
 		},
 
-		// With a register ABI, the actual register info for these instructions (i.e., what is used in regalloc) is augmented with per-call-site bindings of additional arguments to specific registers.
-		{name: "CALLstatic", argLength: -1, reg: regInfo{clobbers: callerSave}, aux: "CallOff", clobberFlags: true, call: true},                                             // call static function aux.(*obj.LSym).  arg0=mem, auxint=argsize, returns mem
-		{name: "CALLclosure", argLength: 3, reg: regInfo{inputs: []regMask{gpsp, buildReg("DX"), 0}, clobbers: callerSave}, aux: "CallOff", clobberFlags: true, call: true}, // call function via closure.  arg0=codeptr, arg1=closure, arg2=mem, auxint=argsize, returns mem
-		{name: "CALLinter", argLength: 2, reg: regInfo{inputs: []regMask{gp}, clobbers: callerSave}, aux: "CallOff", clobberFlags: true, call: true},                        // call fn by pointer.  arg0=codeptr, arg1=mem, auxint=argsize, returns mem
+		// With a register ABI, the actual register info for these instructions (i.e., what is used in regalloc) is augmented with per-call-site bindings of additional arguments to specific in and out registers.
+		{name: "CALLstatic", argLength: -1, reg: regInfo{clobbers: callerSave}, aux: "CallOff", clobberFlags: true, call: true},                                              // call static function aux.(*obj.LSym).  last arg=mem, auxint=argsize, returns mem
+		{name: "CALLclosure", argLength: -1, reg: regInfo{inputs: []regMask{gpsp, buildReg("DX"), 0}, clobbers: callerSave}, aux: "CallOff", clobberFlags: true, call: true}, // call function via closure.  arg0=codeptr, arg1=closure, last arg=mem, auxint=argsize, returns mem
+		{name: "CALLinter", argLength: -1, reg: regInfo{inputs: []regMask{gp}, clobbers: callerSave}, aux: "CallOff", clobberFlags: true, call: true},                        // call fn by pointer.  arg0=codeptr, last arg=mem, auxint=argsize, returns mem
 
 		// arg0 = destination pointer
 		// arg1 = source pointer
diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go
index ee85156a42..2a5b77bad0 100644
--- a/src/cmd/compile/internal/ssa/gen/genericOps.go
+++ b/src/cmd/compile/internal/ssa/gen/genericOps.go
@@ -264,7 +264,7 @@ var genericOps = []opData{
 	//   ±0  → ±0 (sign preserved)
 	//   x<0 → NaN
 	//   NaN → NaN
-	{name: "Sqrt", argLength: 1}, // √arg0   (floating point, double precision)
+	{name: "Sqrt", argLength: 1},   // √arg0   (floating point, double precision)
 	{name: "Sqrt32", argLength: 1}, // √arg0 (floating point, single precision)
 
 	// Round to integer, float64 only.
@@ -396,9 +396,28 @@ var genericOps = []opData{
 	// TODO(josharian): ClosureCall and InterCall should have Int32 aux
 	// to match StaticCall's 32 bit arg size limit.
 	// TODO(drchase,josharian): could the arg size limit be bundled into the rules for CallOff?
-	{name: "ClosureCall", argLength: 3, aux: "CallOff", call: true},    // arg0=code pointer, arg1=context ptr, arg2=memory.  auxint=arg size.  Returns memory.
-	{name: "StaticCall", argLength: -1, aux: "CallOff", call: true},    // call function aux.(*obj.LSym), arg0..argN-1 are register inputs, argN=memory.  auxint=arg size.  Returns Result of register results, plus memory.
-	{name: "InterCall", argLength: 2, aux: "CallOff", call: true},      // interface call.  arg0=code pointer, arg1=memory, auxint=arg size.  Returns memory.
+
+	// Before lowering, LECalls receive their fixed inputs (first), memory (last),
+	// and a variable number of input values in the middle.
+	// They produce a variable number of result values.
+	// These values are not necessarily "SSA-able"; they can be too large,
+	// but in that case inputs are loaded immediately before with OpDereference,
+	// and outputs are stored immediately with OpStore.
+	//
+	// After call expansion, Calls have the same fixed-middle-memory arrangement of inputs,
+	// with the difference that the "middle" is only the register-resident inputs,
+	// and the non-register inputs are instead stored at ABI-defined offsets from SP
+	// (and the stores thread through the memory that is ultimately an input to the call).
+	// Outputs follow a similar pattern; register-resident outputs are the leading elements
+	// of a Result-typed output, with memory last, and any memory-resident outputs have been
+	// stored to ABI-defined locations.  Each non-memory input or output fits in a register.
+	//
+	// Subsequent architecture-specific lowering only changes the opcode.
+
+	{name: "ClosureCall", argLength: -1, aux: "CallOff", call: true}, // arg0=code pointer, arg1=context ptr, arg2..argN-1 are register inputs, argN=memory.  auxint=arg size.  Returns Result of register results, plus memory.
+	{name: "StaticCall", argLength: -1, aux: "CallOff", call: true},  // call function aux.(*obj.LSym), arg0..argN-1 are register inputs, argN=memory.  auxint=arg size.  Returns Result of register results, plus memory.
+	{name: "InterCall", argLength: -1, aux: "CallOff", call: true},   // interface call.  arg0=code pointer, arg1..argN-1 are register inputs, argN=memory, auxint=arg size.  Returns Result of register results, plus memory.
+
 	{name: "ClosureLECall", argLength: -1, aux: "CallOff", call: true}, // late-expanded closure call. arg0=code pointer, arg1=context ptr,  arg2..argN-1 are inputs, argN is mem. auxint = arg size. Result is tuple of result(s), plus mem.
 	{name: "StaticLECall", argLength: -1, aux: "CallOff", call: true},  // late-expanded static call function aux.(*ssa.AuxCall.Fn). arg0..argN-1 are inputs, argN is mem. auxint = arg size. Result is tuple of result(s), plus mem.
 	{name: "InterLECall", argLength: -1, aux: "CallOff", call: true},   // late-expanded interface call. arg0=code pointer, arg1..argN-1 are inputs, argN is mem. auxint = arg size. Result is tuple of result(s), plus mem.
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index 342df73d02..084098fb64 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -10,6 +10,7 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"fmt"
+	"strings"
 )
 
 // An Op encodes the specific operation that a Value performs.
@@ -68,6 +69,27 @@ type regInfo struct {
 	outputs []outputInfo
 }
 
+func (r *regInfo) String() string {
+	s := ""
+	s += "INS:\n"
+	for _, i := range r.inputs {
+		mask := fmt.Sprintf("%64b", i.regs)
+		mask = strings.Replace(mask, "0", ".", -1)
+		s += fmt.Sprintf("%2d |%s|\n", i.idx, mask)
+	}
+	s += "OUTS:\n"
+	for _, i := range r.outputs {
+		mask := fmt.Sprintf("%64b", i.regs)
+		mask = strings.Replace(mask, "0", ".", -1)
+		s += fmt.Sprintf("%2d |%s|\n", i.idx, mask)
+	}
+	s += "CLOBBERS:\n"
+	mask := fmt.Sprintf("%64b", r.clobbers)
+	mask = strings.Replace(mask, "0", ".", -1)
+	s += fmt.Sprintf("   |%s|\n", mask)
+	return s
+}
+
 type auxType int8
 
 type Param struct {
@@ -116,20 +138,25 @@ func (a *AuxCall) Reg(i *regInfo, c *Config) *regInfo {
 		a.reg = i
 		return a.reg
 	}
-	a.reg.inputs = append(a.reg.inputs, i.inputs...)
+
+	k := len(i.inputs)
 	for _, p := range a.abiInfo.InParams() {
 		for _, r := range p.Registers {
 			m := archRegForAbiReg(r, c)
-			a.reg.inputs = append(a.reg.inputs, inputInfo{idx: len(a.reg.inputs), regs: (1 << m)})
+			a.reg.inputs = append(a.reg.inputs, inputInfo{idx: k, regs: (1 << m)})
+			k++
 		}
 	}
-	a.reg.outputs = append(a.reg.outputs, i.outputs...)
+	a.reg.inputs = append(a.reg.inputs, i.inputs...) // These are less constrained, thus should come last
+	k = len(i.outputs)
 	for _, p := range a.abiInfo.OutParams() {
 		for _, r := range p.Registers {
 			m := archRegForAbiReg(r, c)
-			a.reg.outputs = append(a.reg.outputs, outputInfo{idx: len(a.reg.outputs), regs: (1 << m)})
+			a.reg.outputs = append(a.reg.outputs, outputInfo{idx: k, regs: (1 << m)})
+			k++
 		}
 	}
+	a.reg.outputs = append(a.reg.outputs, i.outputs...)
 	a.reg.clobbers = i.clobbers
 	return a.reg
 }
@@ -299,12 +326,20 @@ func StaticAuxCall(sym *obj.LSym, args []Param, results []Param, paramResultInfo
 
 // InterfaceAuxCall returns an AuxCall for an interface call.
 func InterfaceAuxCall(args []Param, results []Param, paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
-	return &AuxCall{Fn: nil, args: args, results: results, abiInfo: paramResultInfo}
+	var reg *regInfo
+	if paramResultInfo.InRegistersUsed()+paramResultInfo.OutRegistersUsed() > 0 {
+		reg = &regInfo{}
+	}
+	return &AuxCall{Fn: nil, args: args, results: results, abiInfo: paramResultInfo, reg: reg}
 }
 
 // ClosureAuxCall returns an AuxCall for a closure call.
 func ClosureAuxCall(args []Param, results []Param, paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
-	return &AuxCall{Fn: nil, args: args, results: results, abiInfo: paramResultInfo}
+	var reg *regInfo
+	if paramResultInfo.InRegistersUsed()+paramResultInfo.OutRegistersUsed() > 0 {
+		reg = &regInfo{}
+	}
+	return &AuxCall{Fn: nil, args: args, results: results, abiInfo: paramResultInfo, reg: reg}
 }
 
 func (*AuxCall) CanBeAnSSAAux() {}
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index e65c4c4a18..322e1c2283 100644
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -13275,7 +13275,7 @@ var opcodeTable = [...]opInfo{
 	{
 		name:         "CALLclosure",
 		auxType:      auxCallOff,
-		argLen:       3,
+		argLen:       -1,
 		clobberFlags: true,
 		call:         true,
 		reg: regInfo{
@@ -13289,7 +13289,7 @@ var opcodeTable = [...]opInfo{
 	{
 		name:         "CALLinter",
 		auxType:      auxCallOff,
-		argLen:       2,
+		argLen:       -1,
 		clobberFlags: true,
 		call:         true,
 		reg: regInfo{
@@ -35596,7 +35596,7 @@ var opcodeTable = [...]opInfo{
 	{
 		name:    "ClosureCall",
 		auxType: auxCallOff,
-		argLen:  3,
+		argLen:  -1,
 		call:    true,
 		generic: true,
 	},
@@ -35610,7 +35610,7 @@ var opcodeTable = [...]opInfo{
 	{
 		name:    "InterCall",
 		auxType: auxCallOff,
-		argLen:  2,
+		argLen:  -1,
 		call:    true,
 		generic: true,
 	},
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index f1f244cce6..7e461f4fe8 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -217,6 +217,10 @@ func AbiForFunc(fn *ir.Func) *abi.ABIConfig {
 	return abiForFunc(fn, ssaConfig.ABI0, ssaConfig.ABI1).Copy() // No idea what races will result, be safe
 }
 
+// TODO (NLT 2021-04-15) This must be changed to a name that cannot match; it may be helpful to other register ABI work to keep the trigger-logic
+const magicNameDotSuffix = ".MagicMethodNameForTestingRegisterABI"
+const magicLastTypeName = "MagicLastTypeNameForTestingRegisterABI"
+
 // abiForFunc implements ABI policy for a function, but does not return a copy of the ABI.
 // Passing a nil function returns ABIInternal.
 func abiForFunc(fn *ir.Func, abi0, abi1 *abi.ABIConfig) *abi.ABIConfig {
@@ -224,16 +228,38 @@ func abiForFunc(fn *ir.Func, abi0, abi1 *abi.ABIConfig) *abi.ABIConfig {
 	if !regabiEnabledForAllCompilation() {
 		a = abi0
 	}
-	if fn != nil && fn.Pragma&ir.RegisterParams != 0 { // TODO(register args) remove after register abi is working
+
+	if fn != nil {
 		name := ir.FuncName(fn)
-		if strings.Contains(name, ".") {
-			base.ErrorfAt(fn.Pos(), "Calls to //go:registerparams method %s won't work, remove the pragma from the declaration.", name)
+		magicName := strings.HasSuffix(name, magicNameDotSuffix)
+		if fn.Pragma&ir.RegisterParams != 0 { // TODO(register args) remove after register abi is working
+			if strings.Contains(name, ".") {
+				if !magicName {
+					base.ErrorfAt(fn.Pos(), "Calls to //go:registerparams method %s won't work, remove the pragma from the declaration.", name)
+				}
+			}
+			a = abi1
+		} else if magicName {
+			if base.FmtPos(fn.Pos()) == "<autogenerated>:1" {
+				// no way to put a pragma here, and it will error out in the real source code if they did not do it there.
+				a = abi1
+			} else {
+				base.ErrorfAt(fn.Pos(), "Methods with magic name %s (method %s) must also specify //go:registerparams", magicNameDotSuffix[1:], name)
+			}
+		}
+		if regAbiForFuncType(fn.Type().FuncType()) {
+			// fmt.Printf("Saw magic last type name for function %s\n", name)
+			a = abi1
 		}
-		a = abi1
 	}
 	return a
 }
 
+func regAbiForFuncType(ft *types.Func) bool {
+	np := ft.Params.NumFields()
+	return np > 0 && strings.Contains(ft.Params.FieldType(np-1).String(), magicLastTypeName)
+}
+
 func regabiEnabledForAllCompilation() bool {
 	// TODO compiler does not yet change behavior for GOEXPERIMENT=regabi
 	return false && objabi.Regabi_enabled != 0
@@ -4863,6 +4889,22 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 	var callArgs []*ssa.Value // For late-expansion, the args themselves (not stored, args to the call instead).
 	inRegisters := false
 
+	var magicFnNameSym *types.Sym
+	if fn.Name() != nil {
+		magicFnNameSym = fn.Name().Sym()
+		ss := magicFnNameSym.Name
+		if strings.HasSuffix(ss, magicNameDotSuffix) {
+			inRegisters = true
+		}
+	}
+	if magicFnNameSym == nil && n.Op() == ir.OCALLINTER {
+		magicFnNameSym = fn.(*ir.SelectorExpr).Sym()
+		ss := magicFnNameSym.Name
+		if strings.HasSuffix(ss, magicNameDotSuffix[1:]) {
+			inRegisters = true
+		}
+	}
+
 	switch n.Op() {
 	case ir.OCALLFUNC:
 		if k == callNormal && fn.Op() == ir.ONAME && fn.(*ir.Name).Class == ir.PFUNC {
@@ -4871,7 +4913,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			// TODO(register args) remove after register abi is working
 			inRegistersImported := fn.Pragma()&ir.RegisterParams != 0
 			inRegistersSamePackage := fn.Func != nil && fn.Func.Pragma&ir.RegisterParams != 0
-			inRegisters = inRegistersImported || inRegistersSamePackage
+			inRegisters = inRegisters || inRegistersImported || inRegistersSamePackage
 			break
 		}
 		closure = s.expr(fn)
@@ -4898,6 +4940,11 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 	types.CalcSize(fn.Type())
 	stksize := fn.Type().ArgWidth() // includes receiver, args, and results
 
+	if regAbiForFuncType(n.X.Type().FuncType()) {
+		// fmt.Printf("Saw magic last type in call %v\n", n)
+		inRegisters = true
+	}
+
 	callABI := s.f.ABI1
 	if !inRegisters {
 		callABI = s.f.ABI0
@@ -5047,11 +5094,11 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			// critical that we not clobber any arguments already
 			// stored onto the stack.
 			codeptr = s.rawLoad(types.Types[types.TUINTPTR], closure)
-			aux := ssa.ClosureAuxCall(ACArgs, ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
+			aux := ssa.ClosureAuxCall(ACArgs, ACResults, callABI.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
 			call = s.newValue2A(ssa.OpClosureLECall, aux.LateExpansionResultType(), aux, codeptr, closure)
 		case codeptr != nil:
 			// Note that the "receiver" parameter is nil because the actual receiver is the first input parameter.
-			aux := ssa.InterfaceAuxCall(ACArgs, ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
+			aux := ssa.InterfaceAuxCall(ACArgs, ACResults, params)
 			call = s.newValue1A(ssa.OpInterLECall, aux.LateExpansionResultType(), aux, codeptr)
 		case callee != nil:
 			aux := ssa.StaticAuxCall(callTargetLSym(callee, s.curfn.LSym), ACArgs, ACResults, params)
diff --git a/test/abi/fibish2.go b/test/abi/fibish2.go
new file mode 100644
index 0000000000..14f3f9ada7
--- /dev/null
+++ b/test/abi/fibish2.go
@@ -0,0 +1,40 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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 "fmt"
+
+// Test that register results are correctly returned (and passed)
+
+type MagicLastTypeNameForTestingRegisterABI func(int,MagicLastTypeNameForTestingRegisterABI) int
+
+//go:registerparams
+//go:noinline
+func minus(decrement int) MagicLastTypeNameForTestingRegisterABI {
+	return MagicLastTypeNameForTestingRegisterABI( func(x int, _ MagicLastTypeNameForTestingRegisterABI) int { return x-decrement} )
+}
+
+//go:noinline
+func f(x int, sub1 MagicLastTypeNameForTestingRegisterABI) (int, int) {
+
+	if x < 3 {
+		return 0, x
+	}
+
+	a, b := f(sub1(sub1(x, sub1), sub1), sub1)
+	c, d := f(sub1(x, sub1), sub1)
+	return a + d, b + c
+}
+
+func main() {
+	x := 40
+	a, b := f(x, minus(1))
+	fmt.Printf("f(%d)=%d,%d\n", x, a, b)
+}
diff --git a/test/abi/fibish2.out b/test/abi/fibish2.out
new file mode 100644
index 0000000000..9bd80c32c9
--- /dev/null
+++ b/test/abi/fibish2.out
@@ -0,0 +1 @@
+f(40)=39088169,126491972
diff --git a/test/abi/fibish_closure.go b/test/abi/fibish_closure.go
new file mode 100644
index 0000000000..988001ebac
--- /dev/null
+++ b/test/abi/fibish_closure.go
@@ -0,0 +1,34 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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 "fmt"
+
+// Test that register results are correctly returned (and passed)
+
+type MagicLastTypeNameForTestingRegisterABI func(int, MagicLastTypeNameForTestingRegisterABI) (int, int)
+
+//go:noinline
+func f(x int, unused MagicLastTypeNameForTestingRegisterABI) (int, int) {
+
+	if x < 3 {
+		return 0, x
+	}
+
+	a, b := f(x-2, unused)
+	c, d := f(x-1, unused)
+	return a + d, b + c
+}
+
+func main() {
+	x := 40
+	a, b := f(x, f)
+	fmt.Printf("f(%d)=%d,%d\n", x, a, b)
+}
diff --git a/test/abi/fibish_closure.out b/test/abi/fibish_closure.out
new file mode 100644
index 0000000000..9bd80c32c9
--- /dev/null
+++ b/test/abi/fibish_closure.out
@@ -0,0 +1 @@
+f(40)=39088169,126491972
diff --git a/test/abi/methods.go b/test/abi/methods.go
new file mode 100644
index 0000000000..9ecae9833e
--- /dev/null
+++ b/test/abi/methods.go
@@ -0,0 +1,51 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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 (
+	"fmt"
+)
+
+type toobig struct {
+	a,b,c string
+}
+
+//go:registerparams
+//go:noinline
+func (x *toobig) MagicMethodNameForTestingRegisterABI(y toobig, z toobig) toobig {
+	return toobig{x.a, y.b, z.c}
+}
+
+type AnInterface interface {
+	MagicMethodNameForTestingRegisterABI(y toobig, z toobig) toobig
+}
+
+//go:registerparams
+//go:noinline
+func I(a,b,c string) toobig {
+	return toobig{a,b,c}
+}
+
+// AnIid prevents the compiler from figuring out what the interface really is.
+//go:noinline
+func AnIid(x AnInterface) AnInterface {
+	return x
+}
+
+var tmp toobig
+func main() {
+	x := I("Ahoy", "1,", "2")
+	y := I("3", "there,", "4")
+	z := I("5", "6,", "Matey")
+	tmp = x.MagicMethodNameForTestingRegisterABI(y,z)
+	fmt.Println(tmp.a, tmp.b, tmp.c)
+	tmp = AnIid(&x).MagicMethodNameForTestingRegisterABI(y,z)
+	fmt.Println(tmp.a, tmp.b, tmp.c)
+}
diff --git a/test/abi/methods.out b/test/abi/methods.out
new file mode 100644
index 0000000000..5a72b0edf7
--- /dev/null
+++ b/test/abi/methods.out
@@ -0,0 +1,2 @@
+Ahoy there, Matey
+Ahoy there, Matey
-- 
GitLab


From 78052f4c4eac5a964a0037f6e18d1a2d31b65189 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Fri, 12 Mar 2021 10:56:08 -0500
Subject: [PATCH 1055/2400] cmd/compile: minor cleanup -- remove dead code
 conditional on test

It would fail now if it were turned on.

Updsates #44816.

Change-Id: I19d94f0cb2dd84271f5304c796d7c81e1e64af25
Reviewed-on: https://go-review.googlesource.com/c/go/+/301270
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssagen/ssa.go | 71 +++++++++-----------------
 1 file changed, 24 insertions(+), 47 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 7e461f4fe8..0029558963 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -1930,7 +1930,6 @@ const shareDeferExits = false
 // It returns a BlockRet block that ends the control flow. Its control value
 // will be set to the final memory state.
 func (s *state) exit() *ssa.Block {
-	lateResultLowering := s.f.DebugTest
 	if s.hasdefer {
 		if s.hasOpenDefers {
 			if shareDeferExits && s.lastDeferExit != nil && len(s.openDefers) == s.lastDeferCount {
@@ -1951,56 +1950,34 @@ func (s *state) exit() *ssa.Block {
 	var m *ssa.Value
 	// Do actual return.
 	// These currently turn into self-copies (in many cases).
-	if lateResultLowering {
-		resultFields := s.curfn.Type().Results().FieldSlice()
-		results := make([]*ssa.Value, len(resultFields)+1, len(resultFields)+1)
-		m = s.newValue0(ssa.OpMakeResult, s.f.OwnAux.LateExpansionResultType())
-		// Store SSAable and heap-escaped PPARAMOUT variables back to stack locations.
-		for i, f := range resultFields {
-			n := f.Nname.(*ir.Name)
-			s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
-			if s.canSSA(n) { // result is in some SSA variable
-				results[i] = s.variable(n, n.Type())
-			} else if !n.OnStack() { // result is actually heap allocated
-				ha := s.expr(n.Heapaddr)
-				s.instrumentFields(n.Type(), ha, instrumentRead)
-				results[i] = s.newValue2(ssa.OpDereference, n.Type(), ha, s.mem())
-			} else { // result is not SSA-able; not escaped, so not on heap, but too large for SSA.
-				// Before register ABI this ought to be a self-move, home=dest,
-				// With register ABI, it's still a self-move if parameter is on stack (i.e., too big or overflowed)
-				results[i] = s.newValue2(ssa.OpDereference, n.Type(), s.addr(n), s.mem())
-			}
+	resultFields := s.curfn.Type().Results().FieldSlice()
+	results := make([]*ssa.Value, len(resultFields)+1, len(resultFields)+1)
+	m = s.newValue0(ssa.OpMakeResult, s.f.OwnAux.LateExpansionResultType())
+	// Store SSAable and heap-escaped PPARAMOUT variables back to stack locations.
+	for i, f := range resultFields {
+		n := f.Nname.(*ir.Name)
+		s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
+		if s.canSSA(n) { // result is in some SSA variable
+			results[i] = s.variable(n, n.Type())
+		} else if !n.OnStack() { // result is actually heap allocated
+			ha := s.expr(n.Heapaddr)
+			s.instrumentFields(n.Type(), ha, instrumentRead)
+			results[i] = s.newValue2(ssa.OpDereference, n.Type(), ha, s.mem())
+		} else { // result is not SSA-able; not escaped, so not on heap, but too large for SSA.
+			// Before register ABI this ought to be a self-move, home=dest,
+			// With register ABI, it's still a self-move if parameter is on stack (i.e., too big or overflowed)
+			results[i] = s.newValue2(ssa.OpDereference, n.Type(), s.addr(n), s.mem())
 		}
+	}
 
-		// Run exit code. Today, this is just racefuncexit, in -race mode.
-		// TODO(register args) this seems risky here with a register-ABI, but not clear it is right to do it earlier either.
-		// Spills in register allocation might just fix it.
-		s.stmtList(s.curfn.Exit)
-
-		results[len(results)-1] = s.mem()
-		m.AddArgs(results...)
-	} else {
-		// Store SSAable and heap-escaped PPARAMOUT variables back to stack locations.
-		for _, f := range s.curfn.Type().Results().FieldSlice() {
-			n := f.Nname.(*ir.Name)
-			if s.canSSA(n) {
-				val := s.variable(n, n.Type())
-				s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
-				s.store(n.Type(), s.decladdrs[n], val)
-			} else if !n.OnStack() {
-				s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
-				s.move(n.Type(), s.decladdrs[n], s.expr(n.Heapaddr))
-			} // else, on stack but too large to SSA, the result is already in its destination by construction, so no store needed.
-
-			// TODO: if (SSA) val is ever spilled, we'd like to use the PPARAMOUT slot for spilling it. That won't happen currently.
-		}
+	// Run exit code. Today, this is just racefuncexit, in -race mode.
+	// TODO(register args) this seems risky here with a register-ABI, but not clear it is right to do it earlier either.
+	// Spills in register allocation might just fix it.
+	s.stmtList(s.curfn.Exit)
 
-		// Run exit code. Today, this is just racefuncexit, in -race mode.
-		s.stmtList(s.curfn.Exit)
+	results[len(results)-1] = s.mem()
+	m.AddArgs(results...)
 
-		// Do actual return.
-		m = s.mem()
-	}
 	b = s.endBlock()
 	b.Kind = ssa.BlockRet
 	b.SetControl(m)
-- 
GitLab


From 86bbf4beee276b9a7f9a427a9d1a9277bd904709 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Fri, 12 Mar 2021 13:48:32 -0500
Subject: [PATCH 1056/2400] cmd/go: fix godoc formatting for text from 'go help
 install'

Fixes #44846

Change-Id: I5a12c6437a91ce59307483ffcc70e084edc32197
Reviewed-on: https://go-review.googlesource.com/c/go/+/301329
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/alldocs.go             | 20 ++++++++++++--------
 src/cmd/go/internal/work/build.go | 20 ++++++++++++--------
 2 files changed, 24 insertions(+), 16 deletions(-)

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index a125e94cea..9aac344a3f 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -684,18 +684,22 @@
 // arguments must satisfy the following constraints:
 //
 // - Arguments must be package paths or package patterns (with "..." wildcards).
-//   They must not be standard packages (like fmt), meta-patterns (std, cmd,
-//   all), or relative or absolute file paths.
+// They must not be standard packages (like fmt), meta-patterns (std, cmd,
+// all), or relative or absolute file paths.
+//
 // - All arguments must have the same version suffix. Different queries are not
-//   allowed, even if they refer to the same version.
+// allowed, even if they refer to the same version.
+//
 // - All arguments must refer to packages in the same module at the same version.
+//
 // - No module is considered the "main" module. If the module containing
-//   packages named on the command line has a go.mod file, it must not contain
-//   directives (replace and exclude) that would cause it to be interpreted
-//   differently than if it were the main module. The module must not require
-//   a higher version of itself.
+// packages named on the command line has a go.mod file, it must not contain
+// directives (replace and exclude) that would cause it to be interpreted
+// differently than if it were the main module. The module must not require
+// a higher version of itself.
+//
 // - Package path arguments must refer to main packages. Pattern arguments
-//   will only match main packages.
+// will only match main packages.
 //
 // If the arguments don't have version suffixes, "go install" may run in
 // module-aware mode or GOPATH mode, depending on the GO111MODULE environment
diff --git a/src/cmd/go/internal/work/build.go b/src/cmd/go/internal/work/build.go
index a80eb27798..ad3a118510 100644
--- a/src/cmd/go/internal/work/build.go
+++ b/src/cmd/go/internal/work/build.go
@@ -482,18 +482,22 @@ To eliminate ambiguity about which module versions are used in the build, the
 arguments must satisfy the following constraints:
 
 - Arguments must be package paths or package patterns (with "..." wildcards).
-  They must not be standard packages (like fmt), meta-patterns (std, cmd,
-  all), or relative or absolute file paths.
+They must not be standard packages (like fmt), meta-patterns (std, cmd,
+all), or relative or absolute file paths.
+
 - All arguments must have the same version suffix. Different queries are not
-  allowed, even if they refer to the same version.
+allowed, even if they refer to the same version.
+
 - All arguments must refer to packages in the same module at the same version.
+
 - No module is considered the "main" module. If the module containing
-  packages named on the command line has a go.mod file, it must not contain
-  directives (replace and exclude) that would cause it to be interpreted
-  differently than if it were the main module. The module must not require
-  a higher version of itself.
+packages named on the command line has a go.mod file, it must not contain
+directives (replace and exclude) that would cause it to be interpreted
+differently than if it were the main module. The module must not require
+a higher version of itself.
+
 - Package path arguments must refer to main packages. Pattern arguments
-  will only match main packages.
+will only match main packages.
 
 If the arguments don't have version suffixes, "go install" may run in
 module-aware mode or GOPATH mode, depending on the GO111MODULE environment
-- 
GitLab


From 3eebc26700c8e9ccb7d9962ce1c7a02d605aba66 Mon Sep 17 00:00:00 2001
From: Dmitri Shuralyov <dmitshur@golang.org>
Date: Tue, 9 Mar 2021 23:27:11 -0500
Subject: [PATCH 1057/2400] delete favicon.ico and robots.txt
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The favicon.ico and robots.txt files have been with us in the root
directory since 2009 and 2011 respectively. Back then, the Go repo
had content for the golang.org website, which could be run locally.
Since these files were at the root of the website, they were added
to the corresponding location in the GOROOT tree—at the root.

In 2018, work started on factoring out golang.org website content
and code into a new golang.org/x/website repository (issue 29206).

The favicon.ico and robots.txt files were copied to x/website repo,
but some more work needed to be done before they would be picked up
and served when golangorg was executed in module mode. That work is
done by now (CL 293413 and CL 293414).

The scope of the godoc tool has also been reduced to just serving
Go package documentation and not the website (issue 32011), so it
can provide its own favicon.ico as needed (CL 300394).

This means these two files have no more use and can be deleted.
So long and goodbye!

Change-Id: Id71bdab6317c1dc481c9d85beaaac4b4eb92d379
Reviewed-on: https://go-review.googlesource.com/c/go/+/300549
Trust: Dmitri Shuralyov <dmitshur@golang.org>
Run-TryBot: Dmitri Shuralyov <dmitshur@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 favicon.ico | Bin 5686 -> 0 bytes
 robots.txt  |   2 --
 2 files changed, 2 deletions(-)
 delete mode 100644 favicon.ico
 delete mode 100644 robots.txt

diff --git a/favicon.ico b/favicon.ico
deleted file mode 100644
index 8d225846dbcda496ba803b828c4786b21cc84d01..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 5686
zcmZQzU}RuoP*4ET3Jfa*7#P$T7#IWuKzt5{3|0n)a{>$u8Vn2!3JeSk4h$f15Q_mX
z2=TM{55oT*mi?zC2H63^=#Bx2fiNxY2AK`A1B6HIM-2f`n1C=SjA)5Lc7QOd?F<Yc
zF%YJu-5|3;c7X7x{iq=T3KI|pg%K?=$PN%jwS6@HL16;Iv<!QY*&sVWn9}gSbujh+
zu?;a`eE(Pm(RBvMZV;x_{$~%*{{Q{wKNvr{wTEu@|F~29|Jj-B{~tfR0^1F8!^@}F
z|35jE^&cb$3S)d2<aZDz$N#_YmHuBjE8+i?$u<9{%-{Zh*0O{DXD>hWfAX9S|EEo^
z`oCd*Ji%}P*$u+v*#F~B<^QtY1OH2U4r9eN{oAQ)|D)>v|K4r<|Nr~V|NnnJ{{R2$
z`Tq-6ZUx&NoYeZ?*wXXAsg2M7$gBxqu?<@`{r~^z@c;jxPyYY+ZvFp%kLxkq1M)iv
z6ZHR+mjC~Mz4(s~{{8>||IDeq|K$~w;aFWm>;K(**U^>!|Nr;P|9>xLptu2KHwY85
z|NoDBnC2mgESO&Q-^bnLf1tPN|IKS>A<3XI|9=1f?@24%4IsNg7>oU%LE=B|l>Gnq
zVk(*;|Nnpc_U(UsV)B0tExrHMwe|o1{eJ)d-^23%|DI38P<!Rd)&CBTF8>XU%>HlQ
zvi1M}j|ai_gUklm5#nd@8H@e5Kyt4y<p2NoZZn3N(`U^3FDNVy#|IA`{{Qc38zg<8
zsSXGXfvb~ORQ><w>s_$@uP)?++ql7g7B|uD5A`=+53>K%*5v>H-fuxO@&Es6(`LZU
z1i9nDfrJ15J#EKozkfh5T&<jf%KzVA?ttw-xj6}Je~6#OMr8X#{47JmgDk&HX!QI4
z=w#0Se=nwE*#GtG*Z<Km@&8rTwEmZsSN{L^`y({`Cu69+c<IuAYg>o^I(mlxH*5gq
zi9=xfZyd<@Uy<tya>I`hf6H``8$x_6ox=kx|6SUh_W$jrg8zT+m;L|ypzQzu9}h6h
zMHT?X5v-g8=TBrwWcJ@5ka&XjE56?@{=aBq2*?fpL;WqnL;WmvH<fw*|9qqP|J>f-
z|8x6-{(rkw{QvJ`Q2u*`Y!ZU~<ut_aP&5BMZp7~1zu*4<dpYa>zXxUiukB0!Kch47
z|Hk=||G(ZWhS=|CaUsOt;z4$j!~b9RO8)=6TM7;*P&`d)_WS?!b|oY&e82nu|IerY
z|9`#o|KF<xU^OtmBk1z~|6VWt|Nryx|Np<70jJ@Aj~l>tEu0wg|K<6-{~*7E!ua;#
zOtAeSeimOt{mc)7(p_DV`~OV~qW|~Q`NHJ>XT;n8Kd>hL|4&e!g!z?78kE;Sdeh_W
z!REz=TK``>DfIuUnc@FaW9`6V!M+yPK=B{qXYmK*1{CaX@fgOB54Zk5sm1^QmW9#(
zuk20#|NLz3|Bu%S!C?jpHxL^n29g7*0jUM)f$0zRv%CXiBhmjr@efXe{${oz{+2sK
z{4DN;`dOR`^|Q!iU|?Vh_O*-*_OrN;qzCM7V)?;-7I%VuEy6%u;1EBH=ny}P!%*`M
zg!o!`g6t-QLqkKEgZ#`LL;Ni!h4@?S0l6{6&*B{v!`$-`%6|+|W8NR)Z)V%jz`#Vv
z{DGD~z`(#vE8GAYdcfjAkobQF25^1`jZ+9f$0`^ZIIyUO2nh;{Gsr6_GwA84GlcsY
zg8GXLrK#o&6&WTB)x~}ct0s9cES(g>P||al;ly%3hQ6807?v&WWH_<8h~dztDu(mB
zD;ZAh?`Jr3a2mtst0fHo@0K(CzYoF{4F4aNGW>r~$?)%C8N>63ml(c&`_1tE*MElJ
zfBrN4{`Vi`P>3T&$<YuP4S@j(0R<LGB*3CTBfbE?q^O99B-DHfE?HSFNf=*LQj(X8
zi$_vi3?eTqFVDxw$R{r^4B<=3F)&F=O35-XNwO%guyIStgZc6dOx&z2EZiJ?(lUIK
zl6>;=d>q^?3M}j#+}t292?=ttvnYT7J3BKA3o|=Ah>eaL7#SFd#jpqhssF$aDrgxP
E0E9iN`2YX_

diff --git a/robots.txt b/robots.txt
deleted file mode 100644
index 1f53798bb4..0000000000
--- a/robots.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-User-agent: *
-Disallow: /
-- 
GitLab


From 7b47f9a5f2092dcbc1546304f1f1b739883fa4c4 Mon Sep 17 00:00:00 2001
From: Michael Schaller <misch@google.com>
Date: Fri, 12 Mar 2021 12:12:48 +0000
Subject: [PATCH 1058/2400] cmd/compile: mention that -m can be increased or
 given multiple times

-m can be increased or it can be given up to 4 times to increase the verbosity of the printed optimization decisions: https://github.com/golang/go/search?q=LowerM

Change-Id: I0cc304385be052664fad455ff075846a3a63f298
GitHub-Last-Rev: 140f08529024dd17c5ca1cbad52dd1d17c6126c0
GitHub-Pull-Request: golang/go#44857
Reviewed-on: https://go-review.googlesource.com/c/go/+/299709
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/doc.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/doc.go b/src/cmd/compile/doc.go
index 46d4722086..b68ef274f3 100644
--- a/src/cmd/compile/doc.go
+++ b/src/cmd/compile/doc.go
@@ -83,7 +83,8 @@ Flags:
 		Without this flag, the -o output is a combination of both
 		linker and compiler input.
 	-m
-		Print optimization decisions.
+		Print optimization decisions. Higher values or repetition
+		produce more detail.
 	-memprofile file
 		Write memory profile for the compilation to file.
 	-memprofilerate rate
-- 
GitLab


From 16ad1ea8417bb842204bf7c982e3f19969b67458 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 11 Mar 2021 16:34:01 -0800
Subject: [PATCH 1059/2400] cmd/compile/internal/types2: simplify error
 reporting API (cleanup)

- Remove specialized errorf functions for invalid AST/argument/operation.
  Instead use prefix constants with the error message.

- Replace several calls to Checker.errorf with calls to Checker.error
  if there are no arguments to format.

- Replace a handful of %s format verbs with %v to satisfy vet check.

- Add a basic test that checks that we're not using Checker.errorf when
  we should be using Checker.error.

Change-Id: I7bc7c14f3cf774689ec8cd5782ea31b6e30dbcd6
Reviewed-on: https://go-review.googlesource.com/c/go/+/300995
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 .../compile/internal/types2/assignments.go    |  2 +-
 src/cmd/compile/internal/types2/builtins.go   | 44 ++++++------
 src/cmd/compile/internal/types2/call.go       |  4 +-
 src/cmd/compile/internal/types2/check.go      |  2 +-
 src/cmd/compile/internal/types2/decl.go       |  6 +-
 .../internal/types2/errorcalls_test.go        | 49 +++++++++++++
 src/cmd/compile/internal/types2/errors.go     | 28 ++++----
 src/cmd/compile/internal/types2/expr.go       | 68 +++++++++----------
 src/cmd/compile/internal/types2/labels.go     |  2 +-
 src/cmd/compile/internal/types2/resolver.go   | 16 ++---
 src/cmd/compile/internal/types2/stmt.go       | 16 ++---
 src/cmd/compile/internal/types2/typexpr.go    | 34 +++++-----
 src/cmd/compile/internal/types2/version.go    |  8 +--
 13 files changed, 162 insertions(+), 117 deletions(-)
 create mode 100644 src/cmd/compile/internal/types2/errorcalls_test.go

diff --git a/src/cmd/compile/internal/types2/assignments.go b/src/cmd/compile/internal/types2/assignments.go
index 00495f3976..18ae0ddf62 100644
--- a/src/cmd/compile/internal/types2/assignments.go
+++ b/src/cmd/compile/internal/types2/assignments.go
@@ -194,7 +194,7 @@ func (check *Checker) assignVar(lhs syntax.Expr, x *operand) Type {
 	case variable, mapindex:
 		// ok
 	case nilvalue:
-		check.errorf(&z, "cannot assign to nil") // default would print "untyped nil"
+		check.error(&z, "cannot assign to nil") // default would print "untyped nil"
 		return nil
 	default:
 		if sel, ok := z.expr.(*syntax.SelectorExpr); ok {
diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go
index a6a9b51dd1..55a9d69b30 100644
--- a/src/cmd/compile/internal/types2/builtins.go
+++ b/src/cmd/compile/internal/types2/builtins.go
@@ -21,8 +21,8 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 	// append is the only built-in that permits the use of ... for the last argument
 	bin := predeclaredFuncs[id]
 	if call.HasDots && id != _Append {
-		//check.invalidOpf(call.Ellipsis, "invalid use of ... with built-in %s", bin.name)
-		check.invalidOpf(call, "invalid use of ... with built-in %s", bin.name)
+		//check.errorf(call.Ellipsis, invalidOp + "invalid use of ... with built-in %s", bin.name)
+		check.errorf(call, invalidOp+"invalid use of ... with built-in %s", bin.name)
 		check.use(call.ArgList...)
 		return
 	}
@@ -68,7 +68,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 			msg = "too many"
 		}
 		if msg != "" {
-			check.invalidOpf(call, "%s arguments for %s (expected %d, found %d)", msg, call, bin.nargs, nargs)
+			check.errorf(call, invalidOp+"%s arguments for %v (expected %d, found %d)", msg, call, bin.nargs, nargs)
 			return
 		}
 	}
@@ -85,7 +85,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 		if s := asSlice(S); s != nil {
 			T = s.elem
 		} else {
-			check.invalidArgf(x, "%s is not a slice", x)
+			check.errorf(x, invalidArg+"%s is not a slice", x)
 			return
 		}
 
@@ -197,7 +197,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 		}
 
 		if mode == invalid && typ != Typ[Invalid] {
-			check.invalidArgf(x, "%s for %s", x, bin.name)
+			check.errorf(x, invalidArg+"%s for %s", x, bin.name)
 			return
 		}
 
@@ -212,11 +212,11 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 		// close(c)
 		c := asChan(x.typ)
 		if c == nil {
-			check.invalidArgf(x, "%s is not a channel", x)
+			check.errorf(x, invalidArg+"%s is not a channel", x)
 			return
 		}
 		if c.dir == RecvOnly {
-			check.invalidArgf(x, "%s must not be a receive-only channel", x)
+			check.errorf(x, invalidArg+"%s must not be a receive-only channel", x)
 			return
 		}
 
@@ -280,7 +280,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 
 		// both argument types must be identical
 		if !check.identical(x.typ, y.typ) {
-			check.invalidOpf(x, "%s (mismatched types %s and %s)", call, x.typ, y.typ)
+			check.errorf(x, invalidOp+"%v (mismatched types %s and %s)", call, x.typ, y.typ)
 			return
 		}
 
@@ -300,7 +300,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 		}
 		resTyp := check.applyTypeFunc(f, x.typ)
 		if resTyp == nil {
-			check.invalidArgf(x, "arguments have type %s, expected floating-point", x.typ)
+			check.errorf(x, invalidArg+"arguments have type %s, expected floating-point", x.typ)
 			return
 		}
 
@@ -340,12 +340,12 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 		}
 
 		if dst == nil || src == nil {
-			check.invalidArgf(x, "copy expects slice arguments; found %s and %s", x, &y)
+			check.errorf(x, invalidArg+"copy expects slice arguments; found %s and %s", x, &y)
 			return
 		}
 
 		if !check.identical(dst, src) {
-			check.invalidArgf(x, "arguments to copy %s and %s have different element types %s and %s", x, &y, dst, src)
+			check.errorf(x, invalidArg+"arguments to copy %s and %s have different element types %s and %s", x, &y, dst, src)
 			return
 		}
 
@@ -359,7 +359,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 		// delete(m, k)
 		m := asMap(x.typ)
 		if m == nil {
-			check.invalidArgf(x, "%s is not a map", x)
+			check.errorf(x, invalidArg+"%s is not a map", x)
 			return
 		}
 		arg(x, 1) // k
@@ -418,7 +418,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 		}
 		resTyp := check.applyTypeFunc(f, x.typ)
 		if resTyp == nil {
-			check.invalidArgf(x, "argument has type %s, expected complex type", x.typ)
+			check.errorf(x, invalidArg+"argument has type %s, expected complex type", x.typ)
 			return
 		}
 
@@ -473,7 +473,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 		}
 
 		if !valid(T) {
-			check.invalidArgf(arg0, "cannot make %s; type must be slice, map, or channel", arg0)
+			check.errorf(arg0, invalidArg+"cannot make %s; type must be slice, map, or channel", arg0)
 			return
 		}
 		if nargs < min || max < nargs {
@@ -495,7 +495,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 			}
 		}
 		if len(sizes) == 2 && sizes[0] > sizes[1] {
-			check.invalidArgf(call.ArgList[1], "length and capacity swapped")
+			check.error(call.ArgList[1], invalidArg+"length and capacity swapped")
 			// safe to continue
 		}
 		x.mode = value
@@ -578,7 +578,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 	case _Alignof:
 		// unsafe.Alignof(x T) uintptr
 		if asTypeParam(x.typ) != nil {
-			check.invalidOpf(call, "unsafe.Alignof undefined for %s", x)
+			check.errorf(call, invalidOp+"unsafe.Alignof undefined for %s", x)
 			return
 		}
 		check.assignment(x, nil, "argument to unsafe.Alignof")
@@ -597,7 +597,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 		arg0 := call.ArgList[0]
 		selx, _ := unparen(arg0).(*syntax.SelectorExpr)
 		if selx == nil {
-			check.invalidArgf(arg0, "%s is not a selector expression", arg0)
+			check.errorf(arg0, invalidArg+"%s is not a selector expression", arg0)
 			check.use(arg0)
 			return
 		}
@@ -612,18 +612,18 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 		obj, index, indirect := check.lookupFieldOrMethod(base, false, check.pkg, sel)
 		switch obj.(type) {
 		case nil:
-			check.invalidArgf(x, "%s has no single field %s", base, sel)
+			check.errorf(x, invalidArg+"%s has no single field %s", base, sel)
 			return
 		case *Func:
 			// TODO(gri) Using derefStructPtr may result in methods being found
 			// that don't actually exist. An error either way, but the error
 			// message is confusing. See: https://play.golang.org/p/al75v23kUy ,
 			// but go/types reports: "invalid argument: x.m is a method value".
-			check.invalidArgf(arg0, "%s is a method value", arg0)
+			check.errorf(arg0, invalidArg+"%s is a method value", arg0)
 			return
 		}
 		if indirect {
-			check.invalidArgf(x, "field %s is embedded via a pointer in %s", sel, base)
+			check.errorf(x, invalidArg+"field %s is embedded via a pointer in %s", sel, base)
 			return
 		}
 
@@ -639,7 +639,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 	case _Sizeof:
 		// unsafe.Sizeof(x T) uintptr
 		if asTypeParam(x.typ) != nil {
-			check.invalidOpf(call, "unsafe.Sizeof undefined for %s", x)
+			check.errorf(call, invalidOp+"unsafe.Sizeof undefined for %s", x)
 			return
 		}
 		check.assignment(x, nil, "argument to unsafe.Sizeof")
@@ -657,7 +657,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 		// The result of assert is the value of pred if there is no error.
 		// Note: assert is only available in self-test mode.
 		if x.mode != constant_ || !isBoolean(x.typ) {
-			check.invalidArgf(x, "%s is not a boolean constant", x)
+			check.errorf(x, invalidArg+"%s is not a boolean constant", x)
 			return
 		}
 		if x.val.Kind() != constant.Bool {
diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index 320e12d4d6..93f4c51937 100644
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -158,7 +158,7 @@ func (check *Checker) call(x *operand, call *syntax.CallExpr) exprKind {
 
 		sig := asSignature(x.typ)
 		if sig == nil {
-			check.invalidOpf(x, "cannot call non-function %s", x)
+			check.errorf(x, invalidOp+"cannot call non-function %s", x)
 			x.mode = invalid
 			x.expr = call
 			return statement
@@ -248,7 +248,7 @@ func (check *Checker) exprOrTypeList(elist []syntax.Expr) (xlist []*operand, ok
 			}
 		}
 		if 0 < ntypes && ntypes < len(xlist) {
-			check.errorf(xlist[0], "mix of value and type expressions")
+			check.error(xlist[0], "mix of value and type expressions")
 			ok = false
 		}
 	}
diff --git a/src/cmd/compile/internal/types2/check.go b/src/cmd/compile/internal/types2/check.go
index c853925a2a..7c1d4eae56 100644
--- a/src/cmd/compile/internal/types2/check.go
+++ b/src/cmd/compile/internal/types2/check.go
@@ -214,7 +214,7 @@ func (check *Checker) initFiles(files []*syntax.File) {
 			if name != "_" {
 				pkg.name = name
 			} else {
-				check.errorf(file.PkgName, "invalid package name _")
+				check.error(file.PkgName, "invalid package name _")
 			}
 			fallthrough
 
diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index 3528669bf9..07a22e8aad 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -629,14 +629,14 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *syntax.TypeDecl, def *Named
 	if alias && tdecl.TParamList != nil {
 		// The parser will ensure this but we may still get an invalid AST.
 		// Complain and continue as regular type definition.
-		check.errorf(tdecl, "generic type cannot be alias")
+		check.error(tdecl, "generic type cannot be alias")
 		alias = false
 	}
 
 	if alias {
 		// type alias declaration
 		if !check.allowVersion(obj.pkg, 1, 9) {
-			check.errorf(tdecl, "type aliases requires go1.9 or later")
+			check.error(tdecl, "type aliases requires go1.9 or later")
 		}
 
 		obj.typ = Typ[Invalid]
@@ -978,7 +978,7 @@ func (check *Checker) declStmt(list []syntax.Decl) {
 			check.pop().setColor(black)
 
 		default:
-			check.invalidASTf(s, "unknown syntax.Decl node %T", s)
+			check.errorf(s, invalidAST+"unknown syntax.Decl node %T", s)
 		}
 	}
 }
diff --git a/src/cmd/compile/internal/types2/errorcalls_test.go b/src/cmd/compile/internal/types2/errorcalls_test.go
new file mode 100644
index 0000000000..28bb33aaff
--- /dev/null
+++ b/src/cmd/compile/internal/types2/errorcalls_test.go
@@ -0,0 +1,49 @@
+// Copyright 2021 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 ast.
+
+package types2_test
+
+import (
+	"cmd/compile/internal/syntax"
+	"testing"
+)
+
+// TestErrorCalls makes sure that check.errorf calls have at
+// least 3 arguments (otherwise we should be using check.error).
+func TestErrorCalls(t *testing.T) {
+	files, err := pkgFiles(".")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for _, file := range files {
+		syntax.Walk(file, func(n syntax.Node) bool {
+			call, _ := n.(*syntax.CallExpr)
+			if call == nil {
+				return false
+			}
+			selx, _ := call.Fun.(*syntax.SelectorExpr)
+			if selx == nil {
+				return false
+			}
+			if !(isName(selx.X, "check") && isName(selx.Sel, "errorf")) {
+				return false
+			}
+			// check.errorf calls should have more than 2 arguments:
+			// position, format string, and arguments to format
+			if n := len(call.ArgList); n <= 2 {
+				t.Errorf("%s: got %d arguments, want > 2", call.Pos(), n)
+				return true
+			}
+			return false
+		})
+	}
+}
+
+func isName(n syntax.Node, name string) bool {
+	if n, ok := n.(*syntax.Name); ok {
+		return n.Value == name
+	}
+	return false
+}
diff --git a/src/cmd/compile/internal/types2/errors.go b/src/cmd/compile/internal/types2/errors.go
index 01df50c8e3..79fedc91e1 100644
--- a/src/cmd/compile/internal/types2/errors.go
+++ b/src/cmd/compile/internal/types2/errors.go
@@ -142,7 +142,7 @@ func (check *Checker) dump(format string, args ...interface{}) {
 	fmt.Println(check.sprintf(format, args...))
 }
 
-func (check *Checker) err(pos syntax.Pos, msg string, soft bool) {
+func (check *Checker) err(at poser, msg string, soft bool) {
 	// Cheap trick: Don't report errors with messages containing
 	// "invalid operand" or "invalid type" as those tend to be
 	// follow-on errors which don't add useful information. Only
@@ -152,6 +152,8 @@ func (check *Checker) err(pos syntax.Pos, msg string, soft bool) {
 		return
 	}
 
+	pos := posFor(at)
+
 	// If we are encountering an error while evaluating an inherited
 	// constant initialization expression, pos is the position of in
 	// the original expression, and not of the currently declared
@@ -179,32 +181,26 @@ func (check *Checker) err(pos syntax.Pos, msg string, soft bool) {
 	f(err)
 }
 
+const (
+	invalidAST = "invalid AST: "
+	invalidArg = "invalid argument: "
+	invalidOp  = "invalid operation: "
+)
+
 type poser interface {
 	Pos() syntax.Pos
 }
 
 func (check *Checker) error(at poser, msg string) {
-	check.err(posFor(at), msg, false)
+	check.err(at, msg, false)
 }
 
 func (check *Checker) errorf(at poser, format string, args ...interface{}) {
-	check.err(posFor(at), check.sprintf(format, args...), false)
+	check.err(at, check.sprintf(format, args...), false)
 }
 
 func (check *Checker) softErrorf(at poser, format string, args ...interface{}) {
-	check.err(posFor(at), check.sprintf(format, args...), true)
-}
-
-func (check *Checker) invalidASTf(at poser, format string, args ...interface{}) {
-	check.errorf(at, "invalid AST: "+format, args...)
-}
-
-func (check *Checker) invalidArgf(at poser, format string, args ...interface{}) {
-	check.errorf(at, "invalid argument: "+format, args...)
-}
-
-func (check *Checker) invalidOpf(at poser, format string, args ...interface{}) {
-	check.errorf(at, "invalid operation: "+format, args...)
+	check.err(at, check.sprintf(format, args...), true)
 }
 
 // posFor reports the left (= start) position of at.
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 584b8ee6a0..b89eb199eb 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -75,14 +75,14 @@ func (check *Checker) op(m opPredicates, x *operand, op syntax.Operator) bool {
 	if pred := m[op]; pred != nil {
 		if !pred(x.typ) {
 			if check.conf.CompilerErrorMessages {
-				check.invalidOpf(x, "operator %s not defined on %s", op, x)
+				check.errorf(x, invalidOp+"operator %s not defined on %s", op, x)
 			} else {
-				check.invalidOpf(x, "operator %s not defined for %s", op, x)
+				check.errorf(x, invalidOp+"operator %s not defined for %s", op, x)
 			}
 			return false
 		}
 	} else {
-		check.invalidASTf(x, "unknown operator %s", op)
+		check.errorf(x, invalidAST+"unknown operator %s", op)
 		return false
 	}
 	return true
@@ -108,7 +108,7 @@ func (check *Checker) overflow(x *operand) {
 		// TODO(gri) We should report exactly what went wrong. At the
 		//           moment we don't have the (go/constant) API for that.
 		//           See also TODO in go/constant/value.go.
-		check.errorf(pos, "constant result is not representable")
+		check.error(pos, "constant result is not representable")
 		return
 	}
 
@@ -169,7 +169,7 @@ func (check *Checker) unary(x *operand, e *syntax.Operation) {
 		// spec: "As an exception to the addressability
 		// requirement x may also be a composite literal."
 		if _, ok := unparen(e.X).(*syntax.CompositeLit); !ok && x.mode != variable {
-			check.invalidOpf(x, "cannot take address of %s", x)
+			check.errorf(x, invalidOp+"cannot take address of %s", x)
 			x.mode = invalid
 			return
 		}
@@ -180,12 +180,12 @@ func (check *Checker) unary(x *operand, e *syntax.Operation) {
 	case syntax.Recv:
 		typ := asChan(x.typ)
 		if typ == nil {
-			check.invalidOpf(x, "cannot receive from non-channel %s", x)
+			check.errorf(x, invalidOp+"cannot receive from non-channel %s", x)
 			x.mode = invalid
 			return
 		}
 		if typ.dir == SendOnly {
-			check.invalidOpf(x, "cannot receive from send-only channel %s", x)
+			check.errorf(x, invalidOp+"cannot receive from send-only channel %s", x)
 			x.mode = invalid
 			return
 		}
@@ -562,7 +562,7 @@ func (check *Checker) updateExprType(x syntax.Expr, typ Type, final bool) {
 		// We already know from the shift check that it is representable
 		// as an integer if it is a constant.
 		if !isInteger(typ) {
-			check.invalidOpf(x, "shifted operand %s (type %s) must be integer", x, typ)
+			check.errorf(x, invalidOp+"shifted operand %s (type %s) must be integer", x, typ)
 			return
 		}
 		// Even if we have an integer, if the value is a constant we
@@ -753,7 +753,7 @@ func (check *Checker) comparison(x, y *operand, op syntax.Operator) {
 
 	if err != "" {
 		// TODO(gri) better error message for cases where one can only compare against nil
-		check.invalidOpf(x, "cannot compare %s %s %s (%s)", x.expr, op, y.expr, err)
+		check.errorf(x, invalidOp+"cannot compare %s %s %s (%s)", x.expr, op, y.expr, err)
 		x.mode = invalid
 		return
 	}
@@ -791,7 +791,7 @@ func (check *Checker) shift(x, y *operand, e syntax.Expr, op syntax.Operator) {
 		// as an integer. Nothing to do.
 	} else {
 		// shift has no chance
-		check.invalidOpf(x, "shifted operand %s must be integer", x)
+		check.errorf(x, invalidOp+"shifted operand %s must be integer", x)
 		x.mode = invalid
 		return
 	}
@@ -803,7 +803,7 @@ func (check *Checker) shift(x, y *operand, e syntax.Expr, op syntax.Operator) {
 	if y.mode == constant_ {
 		yval := constant.ToInt(y.val) // consider -1, 1.0, but not -1.1
 		if yval.Kind() == constant.Int && constant.Sign(yval) < 0 {
-			check.invalidOpf(y, "negative shift count %s", y)
+			check.errorf(y, invalidOp+"negative shift count %s", y)
 			x.mode = invalid
 			return
 		}
@@ -818,11 +818,11 @@ func (check *Checker) shift(x, y *operand, e syntax.Expr, op syntax.Operator) {
 			return
 		}
 	} else if !isInteger(y.typ) {
-		check.invalidOpf(y, "shift count %s must be integer", y)
+		check.errorf(y, invalidOp+"shift count %s must be integer", y)
 		x.mode = invalid
 		return
 	} else if !isUnsigned(y.typ) && !check.allowVersion(check.pkg, 1, 13) {
-		check.invalidOpf(y, "signed shift count %s requires go1.13 or later", y)
+		check.errorf(y, invalidOp+"signed shift count %s requires go1.13 or later", y)
 		x.mode = invalid
 		return
 	}
@@ -842,7 +842,7 @@ func (check *Checker) shift(x, y *operand, e syntax.Expr, op syntax.Operator) {
 			const shiftBound = 1023 - 1 + 52 // so we can express smallestFloat64 (see issue #44057)
 			s, ok := constant.Uint64Val(y.val)
 			if !ok || s > shiftBound {
-				check.invalidOpf(y, "invalid shift count %s", y)
+				check.errorf(y, invalidOp+"invalid shift count %s", y)
 				x.mode = invalid
 				return
 			}
@@ -893,7 +893,7 @@ func (check *Checker) shift(x, y *operand, e syntax.Expr, op syntax.Operator) {
 
 	// non-constant shift - lhs must be an integer
 	if !isInteger(x.typ) {
-		check.invalidOpf(x, "shifted operand %s must be integer", x)
+		check.errorf(x, invalidOp+"shifted operand %s must be integer", x)
 		x.mode = invalid
 		return
 	}
@@ -963,7 +963,7 @@ func (check *Checker) binary(x *operand, e syntax.Expr, lhs, rhs syntax.Expr, op
 		// only report an error if we have valid types
 		// (otherwise we had an error reported elsewhere already)
 		if x.typ != Typ[Invalid] && y.typ != Typ[Invalid] {
-			check.invalidOpf(x, "mismatched types %s and %s", x.typ, y.typ)
+			check.errorf(x, invalidOp+"mismatched types %s and %s", x.typ, y.typ)
 		}
 		x.mode = invalid
 		return
@@ -977,7 +977,7 @@ func (check *Checker) binary(x *operand, e syntax.Expr, lhs, rhs syntax.Expr, op
 	if op == syntax.Div || op == syntax.Rem {
 		// check for zero divisor
 		if (x.mode == constant_ || isInteger(x.typ)) && y.mode == constant_ && constant.Sign(y.val) == 0 {
-			check.invalidOpf(&y, "division by zero")
+			check.error(&y, invalidOp+"division by zero")
 			x.mode = invalid
 			return
 		}
@@ -987,7 +987,7 @@ func (check *Checker) binary(x *operand, e syntax.Expr, lhs, rhs syntax.Expr, op
 			re, im := constant.Real(y.val), constant.Imag(y.val)
 			re2, im2 := constant.BinaryOp(re, token.MUL, re), constant.BinaryOp(im, token.MUL, im)
 			if constant.Sign(re2) == 0 && constant.Sign(im2) == 0 {
-				check.invalidOpf(&y, "division by zero")
+				check.error(&y, invalidOp+"division by zero")
 				x.mode = invalid
 				return
 			}
@@ -1038,7 +1038,7 @@ func (check *Checker) index(index syntax.Expr, max int64) (typ Type, val int64)
 
 	// the index must be of integer type
 	if !isInteger(x.typ) {
-		check.invalidArgf(&x, "index %s must be integer", &x)
+		check.errorf(&x, invalidArg+"index %s must be integer", &x)
 		return
 	}
 
@@ -1048,7 +1048,7 @@ func (check *Checker) index(index syntax.Expr, max int64) (typ Type, val int64)
 
 	// a constant index i must be in bounds
 	if constant.Sign(x.val) < 0 {
-		check.invalidArgf(&x, "index %s must not be negative", &x)
+		check.errorf(&x, invalidArg+"index %s must not be negative", &x)
 		return
 	}
 
@@ -1242,7 +1242,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 			x.mode = value
 			x.typ = sig
 		} else {
-			check.invalidASTf(e, "invalid function literal %s", e)
+			check.errorf(e, invalidAST+"invalid function literal %v", e)
 			goto Error
 		}
 
@@ -1608,23 +1608,23 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 		}
 
 		if !valid {
-			check.invalidOpf(x, "cannot index %s", x)
+			check.errorf(x, invalidOp+"cannot index %s", x)
 			goto Error
 		}
 
 		if e.Index == nil {
-			check.invalidASTf(e, "missing index for %s", x)
+			check.errorf(e, invalidAST+"missing index for %s", x)
 			goto Error
 		}
 
 		index := e.Index
 		if l, _ := index.(*syntax.ListExpr); l != nil {
 			if n := len(l.ElemList); n <= 1 {
-				check.invalidASTf(e, "invalid use of ListExpr for index expression %s with %d indices", e, n)
+				check.errorf(e, invalidAST+"invalid use of ListExpr for index expression %v with %d indices", e, n)
 				goto Error
 			}
 			// len(l.ElemList) > 1
-			check.invalidOpf(l.ElemList[1], "more than one index")
+			check.error(l.ElemList[1], invalidOp+"more than one index")
 			index = l.ElemList[0] // continue with first index
 		}
 
@@ -1651,7 +1651,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 		case *Basic:
 			if isString(typ) {
 				if e.Full {
-					check.invalidOpf(x, "3-index slice of string")
+					check.error(x, invalidOp+"3-index slice of string")
 					goto Error
 				}
 				valid = true
@@ -1669,7 +1669,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 			valid = true
 			length = typ.len
 			if x.mode != variable {
-				check.invalidOpf(x, "%s (slice of unaddressable value)", x)
+				check.errorf(x, invalidOp+"%s (slice of unaddressable value)", x)
 				goto Error
 			}
 			x.typ = &Slice{elem: typ.elem}
@@ -1686,12 +1686,12 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 			// x.typ doesn't change
 
 		case *Sum, *TypeParam:
-			check.errorf(x, "generic slice expressions not yet implemented")
+			check.error(x, "generic slice expressions not yet implemented")
 			goto Error
 		}
 
 		if !valid {
-			check.invalidOpf(x, "cannot slice %s", x)
+			check.errorf(x, invalidOp+"cannot slice %s", x)
 			goto Error
 		}
 
@@ -1699,7 +1699,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 
 		// spec: "Only the first index may be omitted; it defaults to 0."
 		if e.Full && (e.Index[1] == nil || e.Index[2] == nil) {
-			check.invalidASTf(e, "2nd and 3rd index required in 3-index slice")
+			check.error(e, invalidAST+"2nd and 3rd index required in 3-index slice")
 			goto Error
 		}
 
@@ -1756,7 +1756,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 		check.ordinaryType(x.Pos(), xtyp)
 		// x.(type) expressions are encoded via TypeSwitchGuards
 		if e.Type == nil {
-			check.invalidASTf(e, "invalid use of AssertExpr")
+			check.error(e, invalidAST+"invalid use of AssertExpr")
 			goto Error
 		}
 		T := check.varType(e.Type)
@@ -1769,7 +1769,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 
 	case *syntax.TypeSwitchGuard:
 		// x.(type) expressions are handled explicitly in type switches
-		check.invalidASTf(e, "use of .(type) outside type switch")
+		check.error(e, invalidAST+"use of .(type) outside type switch")
 		goto Error
 
 	case *syntax.CallExpr:
@@ -1811,7 +1811,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 						x.mode = variable
 						x.typ = typ.base
 					} else {
-						check.invalidOpf(x, "cannot indirect %s", x)
+						check.errorf(x, invalidOp+"cannot indirect %s", x)
 						goto Error
 					}
 				}
@@ -1837,7 +1837,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 
 	case *syntax.KeyValueExpr:
 		// key:value expressions are handled in composite literals
-		check.invalidASTf(e, "no key:value expected")
+		check.error(e, invalidAST+"no key:value expected")
 		goto Error
 
 	case *syntax.ArrayType, *syntax.SliceType, *syntax.StructType, *syntax.FuncType,
diff --git a/src/cmd/compile/internal/types2/labels.go b/src/cmd/compile/internal/types2/labels.go
index cbbd65aa9a..d5878692f5 100644
--- a/src/cmd/compile/internal/types2/labels.go
+++ b/src/cmd/compile/internal/types2/labels.go
@@ -212,7 +212,7 @@ func (check *Checker) blockBranches(all *Scope, parent *block, lstmt *syntax.Lab
 				}
 
 			default:
-				check.invalidASTf(s, "branch statement: %s %s", s.Tok, name)
+				check.errorf(s, invalidAST+"branch statement: %s %s", s.Tok, name)
 				return
 			}
 
diff --git a/src/cmd/compile/internal/types2/resolver.go b/src/cmd/compile/internal/types2/resolver.go
index fe551525c6..79938964c1 100644
--- a/src/cmd/compile/internal/types2/resolver.go
+++ b/src/cmd/compile/internal/types2/resolver.go
@@ -92,14 +92,14 @@ func (check *Checker) declarePkgObj(ident *syntax.Name, obj Object, d *declInfo)
 	// spec: "A package-scope or file-scope identifier with name init
 	// may only be declared to be a function with this (func()) signature."
 	if ident.Value == "init" {
-		check.errorf(ident, "cannot declare init - must be func")
+		check.error(ident, "cannot declare init - must be func")
 		return
 	}
 
 	// spec: "The main package must have package name main and declare
 	// a function main that takes no arguments and returns no value."
 	if ident.Value == "main" && check.pkg.name == "main" {
-		check.errorf(ident, "cannot declare main - must be func")
+		check.error(ident, "cannot declare main - must be func")
 		return
 	}
 
@@ -256,13 +256,13 @@ func (check *Checker) collectObjects() {
 					name = s.LocalPkgName.Value
 					if path == "C" {
 						// match cmd/compile (not prescribed by spec)
-						check.errorf(s.LocalPkgName, `cannot rename import "C"`)
+						check.error(s.LocalPkgName, `cannot rename import "C"`)
 						continue
 					}
 				}
 
 				if name == "init" {
-					check.errorf(s.LocalPkgName, "cannot import package as init - init must be a func")
+					check.error(s.LocalPkgName, "cannot import package as init - init must be a func")
 					continue
 				}
 
@@ -428,8 +428,8 @@ func (check *Checker) collectObjects() {
 					// method
 					// d.Recv != nil
 					if !methodTypeParamsOk && len(d.TParamList) != 0 {
-						//check.invalidASTf(d.TParamList.Pos(), "method must have no type parameters")
-						check.invalidASTf(d, "method must have no type parameters")
+						//check.error(d.TParamList.Pos(), invalidAST + "method must have no type parameters")
+						check.error(d, invalidAST+"method must have no type parameters")
 					}
 					ptr, recv, _ := check.unpackRecv(d.Recv.Type, false)
 					// (Methods with invalid receiver cannot be associated to a type, and
@@ -449,7 +449,7 @@ func (check *Checker) collectObjects() {
 				obj.setOrder(uint32(len(check.objMap)))
 
 			default:
-				check.invalidASTf(s, "unknown syntax.Decl node %T", s)
+				check.errorf(s, invalidAST+"unknown syntax.Decl node %T", s)
 			}
 		}
 	}
@@ -530,7 +530,7 @@ L: // unpack receiver type
 				case *syntax.BadExpr:
 					// ignore - error already reported by parser
 				case nil:
-					check.invalidASTf(ptyp, "parameterized receiver contains nil parameters")
+					check.error(ptyp, invalidAST+"parameterized receiver contains nil parameters")
 				default:
 					check.errorf(arg, "receiver type parameter %s must be an identifier", arg)
 				}
diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go
index 21244f6065..bf3c9dfa5f 100644
--- a/src/cmd/compile/internal/types2/stmt.go
+++ b/src/cmd/compile/internal/types2/stmt.go
@@ -357,12 +357,12 @@ func (check *Checker) stmt(ctxt stmtContext, s syntax.Stmt) {
 
 		tch := asChan(ch.typ)
 		if tch == nil {
-			check.invalidOpf(s, "cannot send to non-chan type %s", ch.typ)
+			check.errorf(s, invalidOp+"cannot send to non-chan type %s", ch.typ)
 			return
 		}
 
 		if tch.dir == RecvOnly {
-			check.invalidOpf(s, "cannot send to receive-only type %s", tch)
+			check.errorf(s, invalidOp+"cannot send to receive-only type %s", tch)
 			return
 		}
 
@@ -373,7 +373,7 @@ func (check *Checker) stmt(ctxt stmtContext, s syntax.Stmt) {
 		if s.Rhs == nil {
 			// x++ or x--
 			if len(lhs) != 1 {
-				check.invalidASTf(s, "%s%s requires one operand", s.Op, s.Op)
+				check.errorf(s, invalidAST+"%s%s requires one operand", s.Op, s.Op)
 				return
 			}
 			var x operand
@@ -382,7 +382,7 @@ func (check *Checker) stmt(ctxt stmtContext, s syntax.Stmt) {
 				return
 			}
 			if !isNumeric(x.typ) {
-				check.invalidOpf(lhs[0], "%s%s%s (non-numeric type %s)", lhs[0], s.Op, s.Op, x.typ)
+				check.errorf(lhs[0], invalidOp+"%s%s%s (non-numeric type %s)", lhs[0], s.Op, s.Op, x.typ)
 				return
 			}
 			check.assignVar(lhs[0], &x)
@@ -484,7 +484,7 @@ func (check *Checker) stmt(ctxt stmtContext, s syntax.Stmt) {
 			// goto's must have labels, should have been caught above
 			fallthrough
 		default:
-			check.invalidASTf(s, "branch statement: %s", s.Tok)
+			check.errorf(s, invalidAST+"branch statement: %s", s.Tok)
 		}
 
 	case *syntax.BlockStmt:
@@ -642,7 +642,7 @@ func (check *Checker) switchStmt(inner stmtContext, s *syntax.SwitchStmt) {
 	seen := make(valueMap) // map of seen case values to positions and types
 	for i, clause := range s.Body {
 		if clause == nil {
-			check.invalidASTf(clause, "incorrect expression switch case")
+			check.error(clause, invalidAST+"incorrect expression switch case")
 			continue
 		}
 		end := s.Rbrace
@@ -699,7 +699,7 @@ func (check *Checker) typeSwitchStmt(inner stmtContext, s *syntax.SwitchStmt, gu
 	seen := make(map[Type]syntax.Pos) // map of seen types to positions
 	for i, clause := range s.Body {
 		if clause == nil {
-			check.invalidASTf(s, "incorrect type switch case")
+			check.error(s, invalidAST+"incorrect type switch case")
 			continue
 		}
 		end := s.Rbrace
@@ -765,7 +765,7 @@ func (check *Checker) rangeStmt(inner stmtContext, s *syntax.ForStmt, rclause *s
 	var sValue syntax.Expr
 	if p, _ := sKey.(*syntax.ListExpr); p != nil {
 		if len(p.ElemList) != 2 {
-			check.invalidASTf(s, "invalid lhs in range clause")
+			check.error(s, invalidAST+"invalid lhs in range clause")
 			return
 		}
 		sKey = p.ElemList[0]
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 14bc91785e..7675ce6376 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -29,7 +29,7 @@ func (check *Checker) ident(x *operand, e *syntax.Name, def *Named, wantType boo
 	scope, obj := check.scope.LookupParent(e.Value, check.pos)
 	if obj == nil {
 		if e.Value == "_" {
-			check.errorf(e, "cannot use _ as value or type")
+			check.error(e, "cannot use _ as value or type")
 		} else {
 			if check.conf.CompilerErrorMessages {
 				check.errorf(e, "undefined: %s", e.Value)
@@ -76,7 +76,7 @@ func (check *Checker) ident(x *operand, e *syntax.Name, def *Named, wantType boo
 		}
 		if obj == universeIota {
 			if check.iota == nil {
-				check.errorf(e, "cannot use iota outside constant declaration")
+				check.error(e, "cannot use iota outside constant declaration")
 				return
 			}
 			x.val = check.iota
@@ -337,7 +337,7 @@ func (check *Checker) funcType(sig *Signature, recvPar *syntax.Field, tparams []
 		// (A separate check is needed when type-checking interface method signatures because
 		// they don't have a receiver specification.)
 		if recvPar != nil && !check.conf.AcceptMethodTypeParams {
-			check.errorf(ftyp, "methods cannot have type parameters")
+			check.error(ftyp, "methods cannot have type parameters")
 		}
 	}
 
@@ -511,7 +511,7 @@ func (check *Checker) typInternal(e0 syntax.Expr, def *Named) (T Type) {
 			typ.len = check.arrayLength(e.Len)
 		} else {
 			// [...]array
-			check.errorf(e, "invalid use of [...] array (outside a composite literal)")
+			check.error(e, "invalid use of [...] array (outside a composite literal)")
 			typ.len = -1
 		}
 		typ.elem = check.varType(e.Elem)
@@ -599,7 +599,7 @@ func (check *Checker) typInternal(e0 syntax.Expr, def *Named) (T Type) {
 		case syntax.RecvOnly:
 			dir = RecvOnly
 		default:
-			check.invalidASTf(e, "unknown channel direction %d", e.Dir)
+			check.errorf(e, invalidAST+"unknown channel direction %d", e.Dir)
 			// ok to continue
 		}
 
@@ -763,7 +763,7 @@ func (check *Checker) collectParams(scope *Scope, list []*syntax.Field, type0 sy
 			// named parameter
 			name := field.Name.Value
 			if name == "" {
-				check.invalidASTf(field.Name, "anonymous parameter")
+				check.error(field.Name, invalidAST+"anonymous parameter")
 				// ok to continue
 			}
 			par := NewParam(field.Name.Pos(), check.pkg, name, typ)
@@ -780,7 +780,7 @@ func (check *Checker) collectParams(scope *Scope, list []*syntax.Field, type0 sy
 	}
 
 	if named && anonymous {
-		check.invalidASTf(list[0], "list contains both named and anonymous parameters")
+		check.error(list[0], invalidAST+"list contains both named and anonymous parameters")
 		// ok to continue
 	}
 
@@ -817,9 +817,9 @@ func (check *Checker) interfaceType(ityp *Interface, iface *syntax.InterfaceType
 			name := f.Name.Value
 			if name == "_" {
 				if check.conf.CompilerErrorMessages {
-					check.errorf(f.Name, "methods must have a unique non-blank name")
+					check.error(f.Name, "methods must have a unique non-blank name")
 				} else {
-					check.errorf(f.Name, "invalid method name _")
+					check.error(f.Name, "invalid method name _")
 				}
 				continue // ignore
 			}
@@ -830,7 +830,7 @@ func (check *Checker) interfaceType(ityp *Interface, iface *syntax.InterfaceType
 				// the author intended to include all types.
 				types = append(types, f.Type)
 				if tname != nil && tname != f.Name {
-					check.errorf(f.Name, "cannot have multiple type lists in an interface")
+					check.error(f.Name, "cannot have multiple type lists in an interface")
 				}
 				tname = f.Name
 				continue
@@ -840,7 +840,7 @@ func (check *Checker) interfaceType(ityp *Interface, iface *syntax.InterfaceType
 			sig, _ := typ.(*Signature)
 			if sig == nil {
 				if typ != Typ[Invalid] {
-					check.invalidASTf(f.Type, "%s is not a method signature", typ)
+					check.errorf(f.Type, invalidAST+"%s is not a method signature", typ)
 				}
 				continue // ignore
 			}
@@ -849,7 +849,7 @@ func (check *Checker) interfaceType(ityp *Interface, iface *syntax.InterfaceType
 			// (This extra check is needed here because interface method signatures don't have
 			// a receiver specification.)
 			if sig.tparams != nil && !check.conf.AcceptMethodTypeParams {
-				check.errorf(f.Type, "methods cannot have type parameters")
+				check.error(f.Type, "methods cannot have type parameters")
 			}
 
 			// use named receiver type if available (for better error messages)
@@ -1087,7 +1087,7 @@ func (check *Checker) tag(t *syntax.BasicLit) string {
 				return val
 			}
 		}
-		check.invalidASTf(t, "incorrect tag syntax: %q", t.Value)
+		check.errorf(t, invalidAST+"incorrect tag syntax: %q", t.Value)
 	}
 	return ""
 }
@@ -1180,13 +1180,13 @@ func (check *Checker) structType(styp *Struct, e *syntax.StructType) {
 					}
 					// unsafe.Pointer is treated like a regular pointer
 					if t.kind == UnsafePointer {
-						check.errorf(embeddedPos, "embedded field type cannot be unsafe.Pointer")
+						check.error(embeddedPos, "embedded field type cannot be unsafe.Pointer")
 					}
 				case *Pointer:
-					check.errorf(embeddedPos, "embedded field type cannot be a pointer")
+					check.error(embeddedPos, "embedded field type cannot be a pointer")
 				case *Interface:
 					if isPtr {
-						check.errorf(embeddedPos, "embedded field type cannot be a pointer to an interface")
+						check.error(embeddedPos, "embedded field type cannot be a pointer to an interface")
 					}
 				}
 			})
@@ -1220,7 +1220,7 @@ func (check *Checker) collectTypeConstraints(pos syntax.Pos, types []syntax.Expr
 	list := make([]Type, 0, len(types)) // assume all types are correct
 	for _, texpr := range types {
 		if texpr == nil {
-			check.invalidASTf(pos, "missing type constraint")
+			check.error(pos, invalidAST+"missing type constraint")
 			continue
 		}
 		list = append(list, check.varType(texpr))
diff --git a/src/cmd/compile/internal/types2/version.go b/src/cmd/compile/internal/types2/version.go
index cb497f048e..d9d18b6f7a 100644
--- a/src/cmd/compile/internal/types2/version.go
+++ b/src/cmd/compile/internal/types2/version.go
@@ -21,7 +21,7 @@ func (check *Checker) langCompat(lit *syntax.BasicLit) {
 	}
 	// len(s) > 2
 	if strings.Contains(s, "_") {
-		check.errorf(lit, "underscores in numeric literals requires go1.13 or later")
+		check.error(lit, "underscores in numeric literals requires go1.13 or later")
 		return
 	}
 	if s[0] != '0' {
@@ -29,15 +29,15 @@ func (check *Checker) langCompat(lit *syntax.BasicLit) {
 	}
 	radix := s[1]
 	if radix == 'b' || radix == 'B' {
-		check.errorf(lit, "binary literals requires go1.13 or later")
+		check.error(lit, "binary literals requires go1.13 or later")
 		return
 	}
 	if radix == 'o' || radix == 'O' {
-		check.errorf(lit, "0o/0O-style octal literals requires go1.13 or later")
+		check.error(lit, "0o/0O-style octal literals requires go1.13 or later")
 		return
 	}
 	if lit.Kind != syntax.IntLit && (radix == 'x' || radix == 'X') {
-		check.errorf(lit, "hexadecimal floating-point literals requires go1.13 or later")
+		check.error(lit, "hexadecimal floating-point literals requires go1.13 or later")
 	}
 }
 
-- 
GitLab


From 7588ef0d9020c8e628adcd0a0046231252f0d90d Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 11 Mar 2021 18:10:08 -0800
Subject: [PATCH 1060/2400] cmd/compile/internal/types2: use self_test.go from
 go/types

This CL replaces self_test.go with the (improved) version
from go/types, modified for types2.

To see the differences between go/types/self_test.go and
this version, compare against patch set 1.

Change-Id: I7ae830a17f7a0de40cc1f5063166a7247f78ec27
Reviewed-on: https://go-review.googlesource.com/c/go/+/300997
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/self_test.go | 86 ++++++++++++--------
 1 file changed, 53 insertions(+), 33 deletions(-)

diff --git a/src/cmd/compile/internal/types2/self_test.go b/src/cmd/compile/internal/types2/self_test.go
index 6d7971e50f..4722fec988 100644
--- a/src/cmd/compile/internal/types2/self_test.go
+++ b/src/cmd/compile/internal/types2/self_test.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2013 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.
@@ -7,17 +6,15 @@ package types2_test
 
 import (
 	"cmd/compile/internal/syntax"
-	"flag"
-	"fmt"
+	"path"
 	"path/filepath"
+	"runtime"
 	"testing"
 	"time"
 
 	. "cmd/compile/internal/types2"
 )
 
-var benchmark = flag.Bool("b", false, "run benchmarks")
-
 func TestSelf(t *testing.T) {
 	files, err := pkgFiles(".")
 	if err != nil {
@@ -25,7 +22,7 @@ func TestSelf(t *testing.T) {
 	}
 
 	conf := Config{Importer: defaultImporter()}
-	_, err = conf.Check("go/types", files, nil)
+	_, err = conf.Check("cmd/compile/internal/types2", files, nil)
 	if err != nil {
 		// Importing go/constant doesn't work in the
 		// build dashboard environment. Don't report an error
@@ -36,46 +33,69 @@ func TestSelf(t *testing.T) {
 	}
 }
 
-func TestBenchmark(t *testing.T) {
-	if !*benchmark {
-		return
-	}
-
-	// We're not using testing's benchmarking mechanism directly
-	// because we want custom output.
-
-	for _, p := range []string{"types", "constant", filepath.Join("internal", "gcimporter")} {
-		path := filepath.Join("..", p)
-		runbench(t, path, false)
-		runbench(t, path, true)
-		fmt.Println()
+func BenchmarkCheck(b *testing.B) {
+	for _, p := range []string{
+		filepath.Join("src", "net", "http"),
+		filepath.Join("src", "go", "parser"),
+		filepath.Join("src", "go", "constant"),
+		filepath.Join("src", "go", "internal", "gcimporter"),
+	} {
+		b.Run(path.Base(p), func(b *testing.B) {
+			path := filepath.Join(runtime.GOROOT(), p)
+			for _, ignoreFuncBodies := range []bool{false, true} {
+				name := "funcbodies"
+				if ignoreFuncBodies {
+					name = "nofuncbodies"
+				}
+				b.Run(name, func(b *testing.B) {
+					b.Run("info", func(b *testing.B) {
+						runbench(b, path, ignoreFuncBodies, true)
+					})
+					b.Run("noinfo", func(b *testing.B) {
+						runbench(b, path, ignoreFuncBodies, false)
+					})
+				})
+			}
+		})
 	}
 }
 
-func runbench(t *testing.T, path string, ignoreFuncBodies bool) {
+func runbench(b *testing.B, path string, ignoreFuncBodies, writeInfo bool) {
 	files, err := pkgFiles(path)
 	if err != nil {
-		t.Fatal(err)
+		b.Fatal(err)
 	}
 
-	b := testing.Benchmark(func(b *testing.B) {
-		for i := 0; i < b.N; i++ {
-			conf := Config{IgnoreFuncBodies: ignoreFuncBodies}
-			conf.Check(path, files, nil)
-		}
-	})
-
 	// determine line count
 	var lines uint
 	for _, f := range files {
 		lines += f.EOF.Line()
 	}
 
-	d := time.Duration(b.NsPerOp())
-	fmt.Printf(
-		"%s: %s for %d lines (%d lines/s), ignoreFuncBodies = %v\n",
-		filepath.Base(path), d, lines, int64(float64(lines)/d.Seconds()), ignoreFuncBodies,
-	)
+	b.ResetTimer()
+	start := time.Now()
+	for i := 0; i < b.N; i++ {
+		conf := Config{
+			IgnoreFuncBodies: ignoreFuncBodies,
+			Importer:         defaultImporter(),
+		}
+		var info *Info
+		if writeInfo {
+			info = &Info{
+				Types:      make(map[syntax.Expr]TypeAndValue),
+				Defs:       make(map[*syntax.Name]Object),
+				Uses:       make(map[*syntax.Name]Object),
+				Implicits:  make(map[syntax.Node]Object),
+				Selections: make(map[*syntax.SelectorExpr]*Selection),
+				Scopes:     make(map[syntax.Node]*Scope),
+			}
+		}
+		if _, err := conf.Check(path, files, info); err != nil {
+			b.Fatal(err)
+		}
+	}
+	b.StopTimer()
+	b.ReportMetric(float64(lines)*float64(b.N)/time.Since(start).Seconds(), "lines/s")
 }
 
 func pkgFiles(path string) ([]*syntax.File, error) {
-- 
GitLab


From 73eb27bd3bdf727347a5e4d7d369d92f712f5ab5 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Thu, 11 Mar 2021 15:09:47 -0800
Subject: [PATCH 1061/2400] misc/cgo/testcarchive: don't use == for string
 equality in C code

For https://gcc.gnu.org/PR99553

Change-Id: I29a7fbfd89963d4139bc19af99330d70567938ea
Reviewed-on: https://go-review.googlesource.com/c/go/+/300993
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 misc/cgo/testcarchive/testdata/main_unix.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/misc/cgo/testcarchive/testdata/main_unix.c b/misc/cgo/testcarchive/testdata/main_unix.c
index b23ac1c242..bd00f9d233 100644
--- a/misc/cgo/testcarchive/testdata/main_unix.c
+++ b/misc/cgo/testcarchive/testdata/main_unix.c
@@ -36,7 +36,7 @@ int install_handler() {
 		return 2;
 	}
 	// gccgo does not set SA_ONSTACK for SIGSEGV.
-	if (getenv("GCCGO") == "" && (osa.sa_flags&SA_ONSTACK) == 0) {
+	if (getenv("GCCGO") == NULL && (osa.sa_flags&SA_ONSTACK) == 0) {
 		fprintf(stderr, "Go runtime did not install signal handler\n");
 		return 2;
 	}
-- 
GitLab


From 8e725f8452ac0ece548837a95d125bc67b9d8828 Mon Sep 17 00:00:00 2001
From: John Bampton <jbampton@gmail.com>
Date: Fri, 5 Mar 2021 01:53:00 +0000
Subject: [PATCH 1062/2400] all: use HTML5 br tags

In HTML5 br tags don't need a closing slash

Change-Id: Ic53c43faee08c5b1267daa9a02cc186b1c255ca1
GitHub-Last-Rev: 652208116944d01b23b8af8f1af485da5e916d32
GitHub-Pull-Request: golang/go#44283
Reviewed-on: https://go-review.googlesource.com/c/go/+/292370
Reviewed-by: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 misc/trace/trace_viewer_full.html    | 16 ++++++++--------
 src/cmd/compile/internal/ssa/html.go |  2 +-
 src/cmd/trace/mmu.go                 | 22 +++++++++++-----------
 src/encoding/xml/xml.go              |  2 +-
 src/encoding/xml/xml_test.go         |  2 +-
 src/net/http/pprof/pprof.go          |  2 +-
 6 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/misc/trace/trace_viewer_full.html b/misc/trace/trace_viewer_full.html
index ef2e0ea573..ae6e35fca2 100644
--- a/misc/trace/trace_viewer_full.html
+++ b/misc/trace/trace_viewer_full.html
@@ -993,13 +993,13 @@
     </style>
     <div style="padding-right: 200px">
       <div style="float:right;  border-style: solid; border-width: 1px; padding:20px">
-        X no feedback<br/>
-        0 uninitialized<br/>
-        . premonomorphic<br/>
-        1 monomorphic<br/>
-        ^ recompute handler<br/>
-        P polymorphic<br/>
-        N megamorphic<br/>
+        X no feedback<br>
+        0 uninitialized<br>
+        . premonomorphic<br>
+        1 monomorphic<br>
+        ^ recompute handler<br>
+        P polymorphic<br>
+        N megamorphic<br>
         G generic
       </div>
     </div>
@@ -3596,7 +3596,7 @@
     <div id="pipeline_per_frame_container">
       <div class="subtitle">Graphics Pipeline and Raster Tasks</div>
       <div class="description">
-        When raster tasks are completed in comparison to the rest of the graphics pipeline.<br/>
+        When raster tasks are completed in comparison to the rest of the graphics pipeline.<br>
         Only pages where raster tasks are completed after beginFrame is issued are included.
       </div>
       <tr-v-ui-raster-visualization id="rasterVisualization">
diff --git a/src/cmd/compile/internal/ssa/html.go b/src/cmd/compile/internal/ssa/html.go
index c06b5808e1..4d191199fb 100644
--- a/src/cmd/compile/internal/ssa/html.go
+++ b/src/cmd/compile/internal/ssa/html.go
@@ -1064,7 +1064,7 @@ func (f *Func) HTML(phase string, dot *dotWriter) string {
 	p := htmlFuncPrinter{w: buf}
 	fprintFunc(p, f)
 
-	// fprintFunc(&buf, f) // TODO: HTML, not text, <br /> for line breaks, etc.
+	// fprintFunc(&buf, f) // TODO: HTML, not text, <br> for line breaks, etc.
 	fmt.Fprint(buf, "</code>")
 	return buf.String()
 }
diff --git a/src/cmd/trace/mmu.go b/src/cmd/trace/mmu.go
index b92fac652c..1d1fd2ea94 100644
--- a/src/cmd/trace/mmu.go
+++ b/src/cmd/trace/mmu.go
@@ -283,7 +283,7 @@ var templMMU = `<!doctype html>
          .done(function(worst) {
             details.text('Lowest mutator utilization in ' + niceDuration(windowNS) + ' windows:');
             for (var i = 0; i < worst.length; i++) {
-              details.append($('<br/>'));
+              details.append($('<br>'));
               var text = worst[i].MutatorUtil.toFixed(3) + ' at time ' + niceDuration(worst[i].Time);
               details.append($('<a/>').text(text).attr('href', worst[i].URL));
             }
@@ -328,27 +328,27 @@ var templMMU = `<!doctype html>
       <div id="mmu_chart" style="width: 900px; height: 500px; display: inline-block; vertical-align: top">Loading plot...</div>
       <div id="options" style="display: inline-block; vertical-align: top">
         <p>
-          <b>View</b><br/>
+          <b>View</b><br>
           <input type="radio" name="view" id="system" checked><label for="system">System</label>
-          <span class="help">?<span>Consider whole system utilization. For example, if one of four procs is available to the mutator, mutator utilization will be 0.25. This is the standard definition of an MMU.</span></span><br/>
+          <span class="help">?<span>Consider whole system utilization. For example, if one of four procs is available to the mutator, mutator utilization will be 0.25. This is the standard definition of an MMU.</span></span><br>
           <input type="radio" name="view" id="perProc"><label for="perProc">Per-goroutine</label>
-          <span class="help">?<span>Consider per-goroutine utilization. When even one goroutine is interrupted by GC, mutator utilization is 0.</span></span><br/>
+          <span class="help">?<span>Consider per-goroutine utilization. When even one goroutine is interrupted by GC, mutator utilization is 0.</span></span><br>
         </p>
         <p>
-          <b>Include</b><br/>
+          <b>Include</b><br>
           <input type="checkbox" id="stw" checked><label for="stw">STW</label>
-          <span class="help">?<span>Stop-the-world stops all goroutines simultaneously.</span></span><br/>
+          <span class="help">?<span>Stop-the-world stops all goroutines simultaneously.</span></span><br>
           <input type="checkbox" id="background" checked><label for="background">Background workers</label>
-          <span class="help">?<span>Background workers are GC-specific goroutines. 25% of the CPU is dedicated to background workers during GC.</span></span><br/>
+          <span class="help">?<span>Background workers are GC-specific goroutines. 25% of the CPU is dedicated to background workers during GC.</span></span><br>
           <input type="checkbox" id="assist" checked><label for="assist">Mark assist</label>
-          <span class="help">?<span>Mark assists are performed by allocation to prevent the mutator from outpacing GC.</span></span><br/>
+          <span class="help">?<span>Mark assists are performed by allocation to prevent the mutator from outpacing GC.</span></span><br>
           <input type="checkbox" id="sweep"><label for="sweep">Sweep</label>
-          <span class="help">?<span>Sweep reclaims unused memory between GCs. (Enabling this may be very slow.).</span></span><br/>
+          <span class="help">?<span>Sweep reclaims unused memory between GCs. (Enabling this may be very slow.).</span></span><br>
         </p>
         <p>
-          <b>Display</b><br/>
+          <b>Display</b><br>
           <input type="checkbox" id="mut"><label for="mut">Show percentiles</label>
-          <span class="help">?<span>Display percentile mutator utilization in addition to minimum. E.g., p99 MU drops the worst 1% of windows.</span></span><br/>
+          <span class="help">?<span>Display percentile mutator utilization in addition to minimum. E.g., p99 MU drops the worst 1% of windows.</span></span><br>
         </p>
       </div>
     </div>
diff --git a/src/encoding/xml/xml.go b/src/encoding/xml/xml.go
index 6f9594d7ba..384d6ad4b8 100644
--- a/src/encoding/xml/xml.go
+++ b/src/encoding/xml/xml.go
@@ -261,7 +261,7 @@ func NewTokenDecoder(t TokenReader) *Decoder {
 // call to Token. To acquire a copy of the bytes, call CopyToken
 // or the token's Copy method.
 //
-// Token expands self-closing elements such as <br/>
+// Token expands self-closing elements such as <br>
 // into separate start and end elements returned by successive calls.
 //
 // Token guarantees that the StartElement and EndElement
diff --git a/src/encoding/xml/xml_test.go b/src/encoding/xml/xml_test.go
index 5672ebb375..5a10f5309d 100644
--- a/src/encoding/xml/xml_test.go
+++ b/src/encoding/xml/xml_test.go
@@ -940,7 +940,7 @@ func (m mapper) Token() (Token, error) {
 }
 
 func TestNewTokenDecoderIdempotent(t *testing.T) {
-	d := NewDecoder(strings.NewReader(`<br/>`))
+	d := NewDecoder(strings.NewReader(`<br>`))
 	d2 := NewTokenDecoder(d)
 	if d != d2 {
 		t.Error("NewTokenDecoder did not detect underlying Decoder")
diff --git a/src/net/http/pprof/pprof.go b/src/net/http/pprof/pprof.go
index 5389a388c1..a854fef5d3 100644
--- a/src/net/http/pprof/pprof.go
+++ b/src/net/http/pprof/pprof.go
@@ -431,7 +431,7 @@ Types of profiles available:
 
 	b.WriteString(`</table>
 <a href="goroutine?debug=2">full goroutine stack dump</a>
-<br/>
+<br>
 <p>
 Profile Descriptions:
 <ul>
-- 
GitLab


From a8a85281caf21831ee51ea8c879cbba94bcce256 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 12 Mar 2021 16:58:10 -0800
Subject: [PATCH 1063/2400] runtime: fix documented alignment of 32KiB and
 64KiB size classes

As Cherry pointed out on golang.org/cl/299909, the page allocator
doesn't guarantee any alignment for multi-page allocations, so object
alignments are thus implicitly capped at page alignment.

Change-Id: I6f5df27f269b095cde54056f876fe4240f69c5c7
Reviewed-on: https://go-review.googlesource.com/c/go/+/301292
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/runtime/mksizeclasses.go | 6 +++++-
 src/runtime/sizeclasses.go   | 6 +++---
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/runtime/mksizeclasses.go b/src/runtime/mksizeclasses.go
index ddbf1bf7fe..b1b10e9e02 100644
--- a/src/runtime/mksizeclasses.go
+++ b/src/runtime/mksizeclasses.go
@@ -239,7 +239,7 @@ func computeDivMagic(c *class) {
 func printComment(w io.Writer, classes []class) {
 	fmt.Fprintf(w, "// %-5s  %-9s  %-10s  %-7s  %-10s  %-9s  %-9s\n", "class", "bytes/obj", "bytes/span", "objects", "tail waste", "max waste", "min align")
 	prevSize := 0
-	var minAligns [32]int
+	var minAligns [pageShift + 1]int
 	for i, c := range classes {
 		if i == 0 {
 			continue
@@ -249,6 +249,10 @@ func printComment(w io.Writer, classes []class) {
 		tailWaste := spanSize - c.size*(spanSize/c.size)
 		maxWaste := float64((c.size-prevSize-1)*objects+tailWaste) / float64(spanSize)
 		alignBits := bits.TrailingZeros(uint(c.size))
+		if alignBits > pageShift {
+			// object alignment is capped at page alignment
+			alignBits = pageShift
+		}
 		for i := range minAligns {
 			if i > alignBits {
 				minAligns[i] = 0
diff --git a/src/runtime/sizeclasses.go b/src/runtime/sizeclasses.go
index 65c72cfb1a..067871eaf3 100644
--- a/src/runtime/sizeclasses.go
+++ b/src/runtime/sizeclasses.go
@@ -62,7 +62,7 @@ package runtime
 //    56      12288       24576        2           0     11.45%       4096
 //    57      13568       40960        3         256      9.99%        256
 //    58      14336       57344        4           0      5.35%       2048
-//    59      16384       16384        1           0     12.49%      16384
+//    59      16384       16384        1           0     12.49%       8192
 //    60      18432       73728        4           0     11.11%       2048
 //    61      19072       57344        3         128      3.57%        128
 //    62      20480       40960        2           0      6.87%       4096
@@ -70,7 +70,7 @@ package runtime
 //    64      24576       24576        1           0     11.45%       8192
 //    65      27264       81920        3         128     10.00%        128
 //    66      28672       57344        2           0      4.91%       4096
-//    67      32768       32768        1           0     12.50%      32768
+//    67      32768       32768        1           0     12.50%       8192
 
 // alignment  bits  min obj size
 //         8     3             8
@@ -79,7 +79,7 @@ package runtime
 //        64     6           512
 //       128     7           768
 //      4096    12         28672
-//     32768    15         32768
+//      8192    13         32768
 
 const (
 	_MaxSmallSize   = 32768
-- 
GitLab


From 59e012991a31dcf65a0ec79f99b7f4234f46cf2d Mon Sep 17 00:00:00 2001
From: Josh Deprez <DrJosh9000@users.noreply.github.com>
Date: Tue, 10 Nov 2020 21:27:04 +0000
Subject: [PATCH 1064/2400] net/http: note that "HTTP/2" is invalid for
 ParseHTTPVersion

Change-Id: Ieba05dea892ec9855a63b80e456bcf9188eef855
GitHub-Last-Rev: 5f7663ac4aaecb01a27a04309277240fd15759c9
GitHub-Pull-Request: golang/go#41806
Reviewed-on: https://go-review.googlesource.com/c/go/+/259758
Reviewed-by: Damien Neil <dneil@google.com>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Trust: Damien Neil <dneil@google.com>
---
 src/net/http/request.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/net/http/request.go b/src/net/http/request.go
index 5251ebea66..aca55b1ca7 100644
--- a/src/net/http/request.go
+++ b/src/net/http/request.go
@@ -779,7 +779,8 @@ func removeZone(host string) string {
 }
 
 // ParseHTTPVersion parses an HTTP version string.
-// "HTTP/1.0" returns (1, 0, true).
+// "HTTP/1.0" returns (1, 0, true). Note that strings without
+// a minor version, such as "HTTP/2", are not valid.
 func ParseHTTPVersion(vers string) (major, minor int, ok bool) {
 	const Big = 1000000 // arbitrary upper bound
 	switch vers {
-- 
GitLab


From 83e79c7b1474bfd7398cc69207587547885fa96e Mon Sep 17 00:00:00 2001
From: Mostyn Bramley-Moore <mostyn@antipode.se>
Date: Tue, 16 Feb 2021 16:01:39 +0000
Subject: [PATCH 1065/2400] crypto/ecdsa: fix dead reference link

The previous link broke, but it's available on the internet archive.

Fixes #39808

Change-Id: Ic2be74a1f0591600ca1acbe08e1bab8ba1e21abe
GitHub-Last-Rev: 6d6de5d2f451c6d53a1e55b62fb5a1fab0d49f10
GitHub-Pull-Request: golang/go#40165
Reviewed-on: https://go-review.googlesource.com/c/go/+/242103
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
---
 src/crypto/ecdsa/ecdsa.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/crypto/ecdsa/ecdsa.go b/src/crypto/ecdsa/ecdsa.go
index ccce873859..219436935f 100644
--- a/src/crypto/ecdsa/ecdsa.go
+++ b/src/crypto/ecdsa/ecdsa.go
@@ -17,7 +17,7 @@
 //   [Coron]
 //     https://cs.nyu.edu/~dodis/ps/merkle.pdf
 //   [Larsson]
-//     https://www.nada.kth.se/kurser/kth/2D1441/semteo03/lecturenotes/assump.pdf
+//     https://web.archive.org/web/20040719170906/https://www.nada.kth.se/kurser/kth/2D1441/semteo03/lecturenotes/assump.pdf
 package ecdsa
 
 // Further references:
-- 
GitLab


From b3235b75d109f06eec0d3603c606b2d8373b9d4c Mon Sep 17 00:00:00 2001
From: Aman Karmani <aman@tmm1.net>
Date: Tue, 2 Mar 2021 11:52:34 -0800
Subject: [PATCH 1066/2400] encoding/gob: ensure "duplicate type received"
 decoder errors surface up

Previously re-using a decoder with a new stream resulted in a confusing
"extra data in buffer" error message.

Change-Id: Ia4c4c3a2d4b63c59e37e53faa61a500d5ff6e5f1
Reviewed-on: https://go-review.googlesource.com/c/go/+/297949
Reviewed-by: Rob Pike <r@golang.org>
Run-TryBot: Rob Pike <r@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/encoding/gob/decoder.go      |  3 +++
 src/encoding/gob/encoder_test.go | 25 +++++++++++++++++++++++++
 2 files changed, 28 insertions(+)

diff --git a/src/encoding/gob/decoder.go b/src/encoding/gob/decoder.go
index b52aabe54b..7eb3093391 100644
--- a/src/encoding/gob/decoder.go
+++ b/src/encoding/gob/decoder.go
@@ -152,6 +152,9 @@ func (dec *Decoder) decodeTypeSequence(isInterface bool) typeId {
 		}
 		// Type definition for (-id) follows.
 		dec.recvType(-id)
+		if dec.err != nil {
+			break
+		}
 		// When decoding an interface, after a type there may be a
 		// DelimitedValue still in the buffer. Skip its count.
 		// (Alternatively, the buffer is empty and the byte count
diff --git a/src/encoding/gob/encoder_test.go b/src/encoding/gob/encoder_test.go
index fe2774948a..6183646f60 100644
--- a/src/encoding/gob/encoder_test.go
+++ b/src/encoding/gob/encoder_test.go
@@ -1127,3 +1127,28 @@ func TestBadData(t *testing.T) {
 		}
 	}
 }
+
+func TestDecodeErrorMultipleTypes(t *testing.T) {
+	type Test struct {
+		A string
+		B int
+	}
+	var b bytes.Buffer
+	NewEncoder(&b).Encode(Test{"one", 1})
+
+	var result, result2 Test
+	dec := NewDecoder(&b)
+	err := dec.Decode(&result)
+	if err != nil {
+		t.Errorf("decode: unexpected error %v", err)
+	}
+
+	b.Reset()
+	NewEncoder(&b).Encode(Test{"two", 2})
+	err = dec.Decode(&result2)
+	if err == nil {
+		t.Errorf("decode: expected duplicate type error, got nil")
+	} else if !strings.Contains(err.Error(), "duplicate type") {
+		t.Errorf("decode: expected duplicate type error, got %s", err.Error())
+	}
+}
-- 
GitLab


From 289d34a465d46e5c5c07034f5d54afbfda06f5b9 Mon Sep 17 00:00:00 2001
From: John Bampton <jbampton@gmail.com>
Date: Sat, 13 Mar 2021 11:25:15 +0000
Subject: [PATCH 1067/2400] all: remove duplicate words

Change-Id: Ib0469232a2b69a869e58d5d24990ad74ac96ea56
GitHub-Last-Rev: eb38e049ee1e773392ff3747e1eb2af20dd50dcd
GitHub-Pull-Request: golang/go#44805
Reviewed-on: https://go-review.googlesource.com/c/go/+/299109
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/bytes/buffer.go                                         | 2 +-
 src/cmd/compile/internal/ssa/func.go                        | 2 +-
 src/cmd/compile/internal/ssa/rewrite.go                     | 2 +-
 src/cmd/compile/internal/ssagen/abi.go                      | 2 +-
 src/cmd/compile/internal/syntax/scanner_test.go             | 2 +-
 src/cmd/compile/internal/types2/examples/methods.go2        | 2 +-
 src/cmd/compile/internal/types2/type.go                     | 2 +-
 src/cmd/go/internal/fsys/fsys.go                            | 2 +-
 src/cmd/go/internal/modfetch/cache.go                       | 2 +-
 src/cmd/go/internal/modfetch/sumdb.go                       | 2 +-
 src/cmd/go/internal/modload/query_test.go                   | 2 +-
 src/cmd/go/testdata/script/mod_lazy_new_import.txt          | 2 +-
 src/cmd/go/testdata/script/test_chatty_parallel_fail.txt    | 2 +-
 src/cmd/go/testdata/script/test_chatty_parallel_success.txt | 2 +-
 src/cmd/internal/obj/sym.go                                 | 2 +-
 src/cmd/link/internal/ld/macho_combine_dwarf.go             | 2 +-
 src/crypto/tls/handshake_client_test.go                     | 2 +-
 src/debug/dwarf/const.go                                    | 2 +-
 src/go/types/errorcodes.go                                  | 2 +-
 src/go/types/examples/methods.go2                           | 2 +-
 src/go/types/type.go                                        | 2 +-
 src/go/types/typexpr.go                                     | 2 +-
 src/net/http/h2_bundle.go                                   | 2 +-
 src/net/http/server.go                                      | 2 +-
 src/runtime/defer_test.go                                   | 2 +-
 src/runtime/memmove_ppc64x.s                                | 2 +-
 src/runtime/panic.go                                        | 2 +-
 src/runtime/proc.go                                         | 2 +-
 28 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/src/bytes/buffer.go b/src/bytes/buffer.go
index 549b077708..01764c694e 100644
--- a/src/bytes/buffer.go
+++ b/src/bytes/buffer.go
@@ -387,7 +387,7 @@ var errUnreadByte = errors.New("bytes.Buffer: UnreadByte: previous operation was
 
 // UnreadByte unreads the last byte returned by the most recent successful
 // read operation that read at least one byte. If a write has happened since
-// the last read, if the last read returned an error, or if the read read zero
+// the last read, if the last read returned an error, or if the read reads zero
 // bytes, UnreadByte returns an error.
 func (b *Buffer) UnreadByte() error {
 	if b.lastRead == opInvalid {
diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go
index a36529af03..ebbcea598b 100644
--- a/src/cmd/compile/internal/ssa/func.go
+++ b/src/cmd/compile/internal/ssa/func.go
@@ -551,7 +551,7 @@ func (b *Block) NewValue4(pos src.XPos, op Op, t *types.Type, arg0, arg1, arg2,
 	return v
 }
 
-// NewValue4I returns a new value in the block with four arguments and and auxint value.
+// NewValue4I returns a new value in the block with four arguments and auxint value.
 func (b *Block) NewValue4I(pos src.XPos, op Op, t *types.Type, auxint int64, arg0, arg1, arg2, arg3 *Value) *Value {
 	v := b.Func.newValue(op, t, b, pos)
 	v.AuxInt = auxint
diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go
index 5c56b2b346..3c222f80bf 100644
--- a/src/cmd/compile/internal/ssa/rewrite.go
+++ b/src/cmd/compile/internal/ssa/rewrite.go
@@ -1414,7 +1414,7 @@ func isPPC64WordRotateMask(v64 int64) bool {
 	return (v&vp == 0 || vn&vpn == 0) && v != 0
 }
 
-// Compress mask and and shift into single value of the form
+// Compress mask and shift into single value of the form
 // me | mb<<8 | rotate<<16 | nbits<<24 where me and mb can
 // be used to regenerate the input mask.
 func encodePPC64RotateMask(rotate, mask, nbits int64) int64 {
diff --git a/src/cmd/compile/internal/ssagen/abi.go b/src/cmd/compile/internal/ssagen/abi.go
index 7180b3816c..e3f3ac637b 100644
--- a/src/cmd/compile/internal/ssagen/abi.go
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -279,7 +279,7 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 	// things in registers and pushing them onto the stack prior to
 	// the ABI0 call, meaning that they will always need to allocate
 	// stack space. If the compiler marks them as NOSPLIT this seems
-	// as though it could lead to situations where the the linker's
+	// as though it could lead to situations where the linker's
 	// nosplit-overflow analysis would trigger a link failure. On the
 	// other hand if they not tagged NOSPLIT then this could cause
 	// problems when building the runtime (since there may be calls to
diff --git a/src/cmd/compile/internal/syntax/scanner_test.go b/src/cmd/compile/internal/syntax/scanner_test.go
index 04338629d4..fbe7b71163 100644
--- a/src/cmd/compile/internal/syntax/scanner_test.go
+++ b/src/cmd/compile/internal/syntax/scanner_test.go
@@ -547,7 +547,7 @@ func TestNumbers(t *testing.T) {
 				t.Errorf("%q: got error but bad not set", test.src)
 			}
 
-			// compute lit where where s.lit is not defined
+			// compute lit where s.lit is not defined
 			var lit string
 			switch s.tok {
 			case _Name, _Literal:
diff --git a/src/cmd/compile/internal/types2/examples/methods.go2 b/src/cmd/compile/internal/types2/examples/methods.go2
index 52f835f80e..7b6b13ddaa 100644
--- a/src/cmd/compile/internal/types2/examples/methods.go2
+++ b/src/cmd/compile/internal/types2/examples/methods.go2
@@ -43,7 +43,7 @@ func (t T1[[ /* ERROR must be an identifier */ ]int]) m2() {}
 func (t T1[int]) m3() { var _ int = 42 /* ERROR cannot convert 42 .* to int */ }
 
 // The names of the type parameters used in a parameterized receiver
-// type don't have to match the type parameter names in the the declaration
+// type don't have to match the type parameter names in the declaration
 // of the type used for the receiver. In our example, even though T1 is
 // declared with type parameter named A, methods using that receiver type
 // are free to use their own name for that type parameter. That is, the
diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
index ae6642a059..e4d6d0432d 100644
--- a/src/cmd/compile/internal/types2/type.go
+++ b/src/cmd/compile/internal/types2/type.go
@@ -522,7 +522,7 @@ func (t *Interface) iterate(f func(*Interface) bool, seen map[*Interface]bool) b
 }
 
 // isSatisfiedBy reports whether interface t's type list is satisfied by the type typ.
-// If the the type list is empty (absent), typ trivially satisfies the interface.
+// If the type list is empty (absent), typ trivially satisfies the interface.
 // TODO(gri) This is not a great name. Eventually, we should have a more comprehensive
 //           "implements" predicate.
 func (t *Interface) isSatisfiedBy(typ Type) bool {
diff --git a/src/cmd/go/internal/fsys/fsys.go b/src/cmd/go/internal/fsys/fsys.go
index 7b06c3c7f3..ae10946fb1 100644
--- a/src/cmd/go/internal/fsys/fsys.go
+++ b/src/cmd/go/internal/fsys/fsys.go
@@ -100,7 +100,7 @@ func Init(wd string) error {
 }
 
 func initFromJSON(overlayJSON OverlayJSON) error {
-	// Canonicalize the paths in in the overlay map.
+	// Canonicalize the paths in the overlay map.
 	// Use reverseCanonicalized to check for collisions:
 	// no two 'from' paths should canonicalize to the same path.
 	overlay = make(map[string]*node)
diff --git a/src/cmd/go/internal/modfetch/cache.go b/src/cmd/go/internal/modfetch/cache.go
index 50a2898f24..d6774e1ce1 100644
--- a/src/cmd/go/internal/modfetch/cache.go
+++ b/src/cmd/go/internal/modfetch/cache.go
@@ -144,7 +144,7 @@ func lockVersion(mod module.Version) (unlock func(), err error) {
 	return lockedfile.MutexAt(path).Lock()
 }
 
-// SideLock locks a file within the module cache that that previously guarded
+// SideLock locks a file within the module cache that previously guarded
 // edits to files outside the cache, such as go.sum and go.mod files in the
 // user's working directory.
 // If err is nil, the caller MUST eventually call the unlock function.
diff --git a/src/cmd/go/internal/modfetch/sumdb.go b/src/cmd/go/internal/modfetch/sumdb.go
index 118bb3d2d0..f233cba6df 100644
--- a/src/cmd/go/internal/modfetch/sumdb.go
+++ b/src/cmd/go/internal/modfetch/sumdb.go
@@ -185,7 +185,7 @@ func (c *dbClient) initBase() {
 		}
 	})
 	if errors.Is(err, fs.ErrNotExist) {
-		// No proxies, or all proxies failed (with 404, 410, or were were allowed
+		// No proxies, or all proxies failed (with 404, 410, or were allowed
 		// to fall back), or we reached an explicit "direct" or "off".
 		c.base = c.direct
 	} else if err != nil {
diff --git a/src/cmd/go/internal/modload/query_test.go b/src/cmd/go/internal/modload/query_test.go
index 6e39df45a7..a3f2f84505 100644
--- a/src/cmd/go/internal/modload/query_test.go
+++ b/src/cmd/go/internal/modload/query_test.go
@@ -106,7 +106,7 @@ var queryTests = []struct {
 	{path: queryRepo, query: "v1.9.10-pre2+metadata", vers: "v1.9.10-pre2.0.20190513201126-42abcb6df8ee"},
 	{path: queryRepo, query: "ed5ffdaa", vers: "v1.9.10-pre2.0.20191220134614-ed5ffdaa1f5e"},
 
-	// golang.org/issue/29262: The major version for for a module without a suffix
+	// golang.org/issue/29262: The major version for a module without a suffix
 	// should be based on the most recent tag (v1 as appropriate, not v0
 	// unconditionally).
 	{path: queryRepo, query: "42abcb6df8ee", vers: "v1.9.10-pre2.0.20190513201126-42abcb6df8ee"},
diff --git a/src/cmd/go/testdata/script/mod_lazy_new_import.txt b/src/cmd/go/testdata/script/mod_lazy_new_import.txt
index 02935bf236..1be61a1561 100644
--- a/src/cmd/go/testdata/script/mod_lazy_new_import.txt
+++ b/src/cmd/go/testdata/script/mod_lazy_new_import.txt
@@ -32,7 +32,7 @@ cmp go.mod go.mod.old
 cp lazy.go.new lazy.go
 go list all
 go list -m all
-stdout '^example.com/c v0.1.0' # not v0.2.0 as would be be resolved by 'latest'
+stdout '^example.com/c v0.1.0' # not v0.2.0 as would be resolved by 'latest'
 cmp go.mod go.mod.old
 
 # TODO(#36460):
diff --git a/src/cmd/go/testdata/script/test_chatty_parallel_fail.txt b/src/cmd/go/testdata/script/test_chatty_parallel_fail.txt
index 3b2791cb89..f8faa93663 100644
--- a/src/cmd/go/testdata/script/test_chatty_parallel_fail.txt
+++ b/src/cmd/go/testdata/script/test_chatty_parallel_fail.txt
@@ -22,7 +22,7 @@ import (
 	"flag"
 )
 
-// This test ensures the the order of CONT lines in parallel chatty tests.
+// This test ensures the order of CONT lines in parallel chatty tests.
 func TestChattyParallel(t *testing.T) {
 	t.Parallel()
 
diff --git a/src/cmd/go/testdata/script/test_chatty_parallel_success.txt b/src/cmd/go/testdata/script/test_chatty_parallel_success.txt
index 58b5ab7267..63034fa3b5 100644
--- a/src/cmd/go/testdata/script/test_chatty_parallel_success.txt
+++ b/src/cmd/go/testdata/script/test_chatty_parallel_success.txt
@@ -21,7 +21,7 @@ import (
 	"flag"
 )
 
-// This test ensures the the order of CONT lines in parallel chatty tests.
+// This test ensures the order of CONT lines in parallel chatty tests.
 func TestChattyParallel(t *testing.T) {
 	t.Parallel()
 
diff --git a/src/cmd/internal/obj/sym.go b/src/cmd/internal/obj/sym.go
index 4515bdd0d3..98c7364e2a 100644
--- a/src/cmd/internal/obj/sym.go
+++ b/src/cmd/internal/obj/sym.go
@@ -57,7 +57,7 @@ func Linknew(arch *LinkArch) *Link {
 	return ctxt
 }
 
-// LookupDerived looks up or creates the symbol with name name derived from symbol s.
+// LookupDerived looks up or creates the symbol with name derived from symbol s.
 // The resulting symbol will be static iff s is.
 func (ctxt *Link) LookupDerived(s *LSym, name string) *LSym {
 	if s.Static() {
diff --git a/src/cmd/link/internal/ld/macho_combine_dwarf.go b/src/cmd/link/internal/ld/macho_combine_dwarf.go
index 77ee8a4d62..ae873ca6fa 100644
--- a/src/cmd/link/internal/ld/macho_combine_dwarf.go
+++ b/src/cmd/link/internal/ld/macho_combine_dwarf.go
@@ -394,7 +394,7 @@ func machoUpdateDwarfHeader(r *loadCmdReader, compressedSects []*macho.Section,
 	// We want the DWARF segment to be considered non-loadable, so
 	// force vmaddr and vmsize to zero. In addition, set the initial
 	// protection to zero so as to make the dynamic loader happy,
-	// since otherwise it may complain that that the vm size and file
+	// since otherwise it may complain that the vm size and file
 	// size don't match for the segment. See issues 21647 and 32673
 	// for more context. Also useful to refer to the Apple dynamic
 	// loader source, specifically ImageLoaderMachO::sniffLoadCommands
diff --git a/src/crypto/tls/handshake_client_test.go b/src/crypto/tls/handshake_client_test.go
index 0e6c5a6370..693f9686a7 100644
--- a/src/crypto/tls/handshake_client_test.go
+++ b/src/crypto/tls/handshake_client_test.go
@@ -42,7 +42,7 @@ const (
 	// opensslSentinel on the connection.
 	opensslSendSentinel
 
-	// opensslKeyUpdate causes OpenSSL to send send a key update message to the
+	// opensslKeyUpdate causes OpenSSL to send a key update message to the
 	// client and request one back.
 	opensslKeyUpdate
 )
diff --git a/src/debug/dwarf/const.go b/src/debug/dwarf/const.go
index c60709199b..c0a74b08bb 100644
--- a/src/debug/dwarf/const.go
+++ b/src/debug/dwarf/const.go
@@ -427,7 +427,7 @@ const (
 	lneSetDiscriminator = 4
 )
 
-// Line table directory directory and file name entry formats.
+// Line table directory and file name entry formats.
 // These are new in DWARF 5.
 const (
 	lnctPath           = 0x01
diff --git a/src/go/types/errorcodes.go b/src/go/types/errorcodes.go
index 1e39aed07d..4d9db18f9c 100644
--- a/src/go/types/errorcodes.go
+++ b/src/go/types/errorcodes.go
@@ -162,7 +162,7 @@ const (
 	_UntypedNil
 
 	// _WrongAssignCount occurs when the number of values on the right-hand side
-	// of an assignment or or initialization expression does not match the number
+	// of an assignment or initialization expression does not match the number
 	// of variables on the left-hand side.
 	//
 	// Example:
diff --git a/src/go/types/examples/methods.go2 b/src/go/types/examples/methods.go2
index c294627837..76c6539e1b 100644
--- a/src/go/types/examples/methods.go2
+++ b/src/go/types/examples/methods.go2
@@ -42,7 +42,7 @@ func (t T1[[ /* ERROR must be an identifier */ ]int]) m2() {}
 func (t T1[int]) m3() { var _ int = 42 /* ERROR cannot use 42 .* as int */ }
 
 // The names of the type parameters used in a parameterized receiver
-// type don't have to match the type parameter names in the the declaration
+// type don't have to match the type parameter names in the declaration
 // of the type used for the receiver. In our example, even though T1 is
 // declared with type parameter named A, methods using that receiver type
 // are free to use their own name for that type parameter. That is, the
diff --git a/src/go/types/type.go b/src/go/types/type.go
index 201da95a58..21d49de3aa 100644
--- a/src/go/types/type.go
+++ b/src/go/types/type.go
@@ -519,7 +519,7 @@ func (t *Interface) iterate(f func(*Interface) bool, seen map[*Interface]bool) b
 }
 
 // isSatisfiedBy reports whether interface t's type list is satisfied by the type typ.
-// If the the type list is empty (absent), typ trivially satisfies the interface.
+// If the type list is empty (absent), typ trivially satisfies the interface.
 // TODO(gri) This is not a great name. Eventually, we should have a more comprehensive
 //           "implements" predicate.
 func (t *Interface) isSatisfiedBy(typ Type) bool {
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index 63e37de4b7..60a42b0426 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -690,7 +690,7 @@ func (check *Checker) typeList(list []ast.Expr) []Type {
 }
 
 // collectParams declares the parameters of list in scope and returns the corresponding
-// variable list. If type0 != nil, it is used instead of the the first type in list.
+// variable list. If type0 != nil, it is used instead of the first type in list.
 func (check *Checker) collectParams(scope *Scope, list *ast.FieldList, type0 ast.Expr, variadicOk bool) (params []*Var, variadic bool) {
 	if list == nil {
 		return
diff --git a/src/net/http/h2_bundle.go b/src/net/http/h2_bundle.go
index 0379848e70..feecc8ce9c 100644
--- a/src/net/http/h2_bundle.go
+++ b/src/net/http/h2_bundle.go
@@ -7297,7 +7297,7 @@ func (cc *http2ClientConn) canTakeNewRequestLocked() bool {
 	return st.canTakeNewRequest
 }
 
-// tooIdleLocked reports whether this connection has been been sitting idle
+// tooIdleLocked reports whether this connection has been sitting idle
 // for too much wall time.
 func (cc *http2ClientConn) tooIdleLocked() bool {
 	// The Round(0) strips the monontonic clock reading so the
diff --git a/src/net/http/server.go b/src/net/http/server.go
index ad99741177..ea3486289a 100644
--- a/src/net/http/server.go
+++ b/src/net/http/server.go
@@ -2638,7 +2638,7 @@ type Server struct {
 	// value.
 	ConnContext func(ctx context.Context, c net.Conn) context.Context
 
-	inShutdown atomicBool // true when when server is in shutdown
+	inShutdown atomicBool // true when server is in shutdown
 
 	disableKeepAlives int32     // accessed atomically.
 	nextProtoOnce     sync.Once // guards setupHTTP2_* init
diff --git a/src/runtime/defer_test.go b/src/runtime/defer_test.go
index 9a40ea1984..fc96144597 100644
--- a/src/runtime/defer_test.go
+++ b/src/runtime/defer_test.go
@@ -370,7 +370,7 @@ func g2() {
 	defer ap.method2()
 	defer ap.method1()
 	ff1(ap, 1, 2, 3, 4, 5, 6, 7, 8, 9)
-	// Try to get the stack to be be moved by growing it too large, so
+	// Try to get the stack to be moved by growing it too large, so
 	// existing stack-allocated defer becomes invalid.
 	rec1(2000)
 }
diff --git a/src/runtime/memmove_ppc64x.s b/src/runtime/memmove_ppc64x.s
index edc6452bba..dbd835506f 100644
--- a/src/runtime/memmove_ppc64x.s
+++ b/src/runtime/memmove_ppc64x.s
@@ -157,7 +157,7 @@ backwardlargeloop:
 
 backward32setup:
 	MOVD	QWORDS, CTR			// set up loop ctr
-	MOVD	$16, IDX16			// 32 bytes at at time
+	MOVD	$16, IDX16			// 32 bytes at a time
 
 backward32loop:
 	SUB	$32, TGT
diff --git a/src/runtime/panic.go b/src/runtime/panic.go
index e320eaa596..b5133fa5b4 100644
--- a/src/runtime/panic.go
+++ b/src/runtime/panic.go
@@ -699,7 +699,7 @@ func printpanics(p *_panic) {
 // specified by sp. If sp is nil, it uses the sp from the current defer record
 // (which has just been finished). Hence, it continues the stack scan from the
 // frame of the defer that just finished. It skips any frame that already has an
-// open-coded _defer record, which would have been been created from a previous
+// open-coded _defer record, which would have been created from a previous
 // (unrecovered) panic.
 //
 // Note: All entries of the defer chain (including this new open-coded entry) have
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 8db3b767d1..9ebfe70883 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -1318,7 +1318,7 @@ func mstart1() {
 		throw("bad runtime·mstart")
 	}
 
-	// Set up m.g0.sched as a label returning returning to just
+	// Set up m.g0.sched as a label returning to just
 	// after the mstart1 call in mstart0 above, for use by goexit0 and mcall.
 	// We're never coming back to mstart1 after we call schedule,
 	// so other calls can reuse the current frame.
-- 
GitLab


From fedb49487831e1168ebad7d313e23a8494bee6a2 Mon Sep 17 00:00:00 2001
From: Vitaly Zdanevich <zdanevich.vitaly@ya.ru>
Date: Mon, 8 Mar 2021 03:15:25 +0000
Subject: [PATCH 1068/2400] errors/wrap: do not call Elem() twice

Change-Id: I2fe6037c45a0dfe25f946a92ff97b5e3fbd69bc0
GitHub-Last-Rev: 644d479a27c0eccfc0b37e1a560ca09e47b5a972
GitHub-Pull-Request: golang/go#44851
Reviewed-on: https://go-review.googlesource.com/c/go/+/299629
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/errors/wrap.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/errors/wrap.go b/src/errors/wrap.go
index 7928fe673e..4eb4f9ae37 100644
--- a/src/errors/wrap.go
+++ b/src/errors/wrap.go
@@ -83,10 +83,10 @@ func As(err error, target interface{}) bool {
 	if typ.Kind() != reflectlite.Ptr || val.IsNil() {
 		panic("errors: target must be a non-nil pointer")
 	}
-	if e := typ.Elem(); e.Kind() != reflectlite.Interface && !e.Implements(errorType) {
+	targetType := typ.Elem()
+	if targetType.Kind() != reflectlite.Interface && !targetType.Implements(errorType) {
 		panic("errors: *target must be interface or implement error")
 	}
-	targetType := typ.Elem()
 	for err != nil {
 		if reflectlite.TypeOf(err).AssignableTo(targetType) {
 			val.Elem().Set(reflectlite.ValueOf(err))
-- 
GitLab


From 3224990dad27d5a06961a168c3760b13a6d140c1 Mon Sep 17 00:00:00 2001
From: zfCode <zfcode@qq.com>
Date: Sat, 13 Mar 2021 18:00:30 +0000
Subject: [PATCH 1069/2400] =?UTF-8?q?fmt:=20use=20=E2=80=9CtruncateString?=
 =?UTF-8?q?=E2=80=9D=20not=20=E2=80=9Ctruncate=E2=80=9D=20in=20method=20do?=
 =?UTF-8?q?c?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Change-Id: If1acb6a8533a782f80c7d1f0ad5155e98e1134dd
GitHub-Last-Rev: 03384a3d99dd89d802635f7ef48ce4456ec338b0
GitHub-Pull-Request: golang/go#44375
Reviewed-on: https://go-review.googlesource.com/c/go/+/293629
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Rob Pike <r@golang.org>
Trust: Rob Pike <r@golang.org>
---
 src/fmt/format.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/fmt/format.go b/src/fmt/format.go
index 4d12f82f7d..bd00e5a5e0 100644
--- a/src/fmt/format.go
+++ b/src/fmt/format.go
@@ -320,7 +320,7 @@ func (f *fmt) fmtInteger(u uint64, base int, isSigned bool, verb rune, digits st
 	f.zero = oldZero
 }
 
-// truncate truncates the string s to the specified precision, if present.
+// truncateString truncates the string s to the specified precision, if present.
 func (f *fmt) truncateString(s string) string {
 	if f.precPresent {
 		n := f.prec
-- 
GitLab


From 8336c311f848cb9adc76aeb8bd8172f67bda67e6 Mon Sep 17 00:00:00 2001
From: JulianChu <yulang.chu@gmail.com>
Date: Sat, 13 Mar 2021 17:44:10 +0000
Subject: [PATCH 1070/2400] io: add error check to WriteString Example test

Change-Id: I9ce1c79e5799f205aec3a4dc02645ed26bdc3581
GitHub-Last-Rev: 59b637db0154e55ddfdd55e54b9596dc3a0ad32d
GitHub-Pull-Request: golang/go#44533
Reviewed-on: https://go-review.googlesource.com/c/go/+/295389
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/io/example_test.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/io/example_test.go b/src/io/example_test.go
index 6d338acd14..a18df9feff 100644
--- a/src/io/example_test.go
+++ b/src/io/example_test.go
@@ -103,7 +103,9 @@ func ExampleReadFull() {
 }
 
 func ExampleWriteString() {
-	io.WriteString(os.Stdout, "Hello World")
+	if _, err := io.WriteString(os.Stdout, "Hello World"); err != nil {
+		log.Fatal(err)
+	}
 
 	// Output: Hello World
 }
-- 
GitLab


From 4bd4dfe96a0e7cd252ff0d53ba46618b54618d15 Mon Sep 17 00:00:00 2001
From: cui <cuiweixie@gmail.com>
Date: Mon, 11 Jan 2021 08:44:45 +0000
Subject: [PATCH 1071/2400] cmd/compile/internal/ssa: prealloc slice

Change-Id: I9943a4f931c251a69bc8244c0d7723a0a3552073
GitHub-Last-Rev: d9dd94ae4444cb0106756cdb98c1c5fa12fa5f79
GitHub-Pull-Request: golang/go#43622
Reviewed-on: https://go-review.googlesource.com/c/go/+/282992
Reviewed-by: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/cmd/compile/internal/ssa/lca.go | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ssa/lca.go b/src/cmd/compile/internal/ssa/lca.go
index 5cb73911df..90daebe44f 100644
--- a/src/cmd/compile/internal/ssa/lca.go
+++ b/src/cmd/compile/internal/ssa/lca.go
@@ -4,6 +4,10 @@
 
 package ssa
 
+import (
+	"math/bits"
+)
+
 // Code to compute lowest common ancestors in the dominator tree.
 // https://en.wikipedia.org/wiki/Lowest_common_ancestor
 // https://en.wikipedia.org/wiki/Range_minimum_query#Solution_using_constant_time_and_linearithmic_space
@@ -79,7 +83,7 @@ func makeLCArange(f *Func) *lcaRange {
 	}
 
 	// Compute fast range-minimum query data structure
-	var rangeMin [][]ID
+	rangeMin := make([][]ID, 0, bits.Len64(uint64(len(tour))))
 	rangeMin = append(rangeMin, tour) // 1-size windows are just the tour itself.
 	for logS, s := 1, 2; s < len(tour); logS, s = logS+1, s*2 {
 		r := make([]ID, len(tour)-s+1)
-- 
GitLab


From 1767d2cc2fed70e4f195474677f72712eaf28c9e Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Sat, 13 Mar 2021 18:00:17 +0100
Subject: [PATCH 1072/2400] io/fs: use testing.T.TempDir in TestWalkDir

Change-Id: I805ad51332e4efe27d47f6c6e3b0af945e0d4aa0
Reviewed-on: https://go-review.googlesource.com/c/go/+/301489
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/io/fs/walk_test.go | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/src/io/fs/walk_test.go b/src/io/fs/walk_test.go
index ebc4e50fb3..5e127e71cd 100644
--- a/src/io/fs/walk_test.go
+++ b/src/io/fs/walk_test.go
@@ -6,7 +6,6 @@ package fs_test
 
 import (
 	. "io/fs"
-	"io/ioutil"
 	"os"
 	pathpkg "path"
 	"testing"
@@ -96,11 +95,7 @@ func mark(entry DirEntry, err error, errors *[]error, clear bool) error {
 }
 
 func TestWalkDir(t *testing.T) {
-	tmpDir, err := ioutil.TempDir("", "TestWalk")
-	if err != nil {
-		t.Fatal("creating temp dir:", err)
-	}
-	defer os.RemoveAll(tmpDir)
+	tmpDir := t.TempDir()
 
 	origDir, err := os.Getwd()
 	if err != nil {
-- 
GitLab


From 7936efecc8981fab11b445d96cdb1480d9d8208b Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Sat, 13 Mar 2021 19:43:12 +0100
Subject: [PATCH 1073/2400] net/http: revert change from CL 299109 breaking
 TestAllDependencies

This code is generated from golang.org/x/net/http2 and thus any changes
first have to occur there. Otherwise TestAllDependencies fails on the
longtest builders.

Change-Id: I918afdd9388dd28bb3c8e55438be764c4f32c7c8
Reviewed-on: https://go-review.googlesource.com/c/go/+/301491
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/net/http/h2_bundle.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/net/http/h2_bundle.go b/src/net/http/h2_bundle.go
index feecc8ce9c..0379848e70 100644
--- a/src/net/http/h2_bundle.go
+++ b/src/net/http/h2_bundle.go
@@ -7297,7 +7297,7 @@ func (cc *http2ClientConn) canTakeNewRequestLocked() bool {
 	return st.canTakeNewRequest
 }
 
-// tooIdleLocked reports whether this connection has been sitting idle
+// tooIdleLocked reports whether this connection has been been sitting idle
 // for too much wall time.
 func (cc *http2ClientConn) tooIdleLocked() bool {
 	// The Round(0) strips the monontonic clock reading so the
-- 
GitLab


From 88b8a1608987d494f3f29618e7524e61712c31ba Mon Sep 17 00:00:00 2001
From: Koichi Shiraishi <zchee.io@gmail.com>
Date: Fri, 21 Aug 2020 21:23:18 +0900
Subject: [PATCH 1074/2400] cmd/cover: replace code using optimized
 golang.org/x/tools/cover
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

After CL 179377, this change deletes all the prior cmd/cover code
and instead vendors and type aliases code using the significantly
optimized  golang.org/x/tools/cover, which sped up ParseProfiles by
manually parsing profiles instead of a regex. The speed up was:

name         old time/op   new time/op   delta
ParseLine-12 2.43µs ± 2%   0.05µs ± 8%   -97.98% (p=0.000 n=10+9)

name         old speed     new speed       delta
ParseLine-12 42.5MB/s ± 2% 2103.2MB/s ± 7% +4853.14% (p=0.000 n=10+9)

Fixes #32211.

Change-Id: Ie4e8be7502f25eb95fae7a9d8334fc97b045d53f
Reviewed-on: https://go-review.googlesource.com/c/go/+/249759
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/cover/profile.go                      | 202 +-------------
 .../golang.org/x/tools/cover/profile.go       | 261 ++++++++++++++++++
 src/cmd/vendor/modules.txt                    |   1 +
 3 files changed, 268 insertions(+), 196 deletions(-)
 create mode 100644 src/cmd/vendor/golang.org/x/tools/cover/profile.go

diff --git a/src/cmd/cover/profile.go b/src/cmd/cover/profile.go
index 656c862740..839444edb7 100644
--- a/src/cmd/cover/profile.go
+++ b/src/cmd/cover/profile.go
@@ -4,217 +4,27 @@
 
 // This file provides support for parsing coverage profiles
 // generated by "go test -coverprofile=cover.out".
-// It is a copy of golang.org/x/tools/cover/profile.go.
+// It is a alias of golang.org/x/tools/cover/profile.go.
 
 package main
 
 import (
-	"bufio"
-	"fmt"
-	"math"
-	"os"
-	"regexp"
-	"sort"
-	"strconv"
-	"strings"
+	"golang.org/x/tools/cover"
 )
 
 // Profile represents the profiling data for a specific file.
-type Profile struct {
-	FileName string
-	Mode     string
-	Blocks   []ProfileBlock
-}
+type Profile = cover.Profile
 
 // ProfileBlock represents a single block of profiling data.
-type ProfileBlock struct {
-	StartLine, StartCol int
-	EndLine, EndCol     int
-	NumStmt, Count      int
-}
-
-type byFileName []*Profile
-
-func (p byFileName) Len() int           { return len(p) }
-func (p byFileName) Less(i, j int) bool { return p[i].FileName < p[j].FileName }
-func (p byFileName) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
+type ProfileBlock = cover.ProfileBlock
 
 // ParseProfiles parses profile data in the specified file and returns a
 // Profile for each source file described therein.
 func ParseProfiles(fileName string) ([]*Profile, error) {
-	pf, err := os.Open(fileName)
-	if err != nil {
-		return nil, err
-	}
-	defer pf.Close()
-
-	files := make(map[string]*Profile)
-	buf := bufio.NewReader(pf)
-	// First line is "mode: foo", where foo is "set", "count", or "atomic".
-	// Rest of file is in the format
-	//	encoding/base64/base64.go:34.44,37.40 3 1
-	// where the fields are: name.go:line.column,line.column numberOfStatements count
-	s := bufio.NewScanner(buf)
-	mode := ""
-	for s.Scan() {
-		line := s.Text()
-		if mode == "" {
-			const p = "mode: "
-			if !strings.HasPrefix(line, p) || line == p {
-				return nil, fmt.Errorf("bad mode line: %v", line)
-			}
-			mode = line[len(p):]
-			continue
-		}
-		m := lineRe.FindStringSubmatch(line)
-		if m == nil {
-			return nil, fmt.Errorf("line %q doesn't match expected format: %v", m, lineRe)
-		}
-		fn := m[1]
-		p := files[fn]
-		if p == nil {
-			p = &Profile{
-				FileName: fn,
-				Mode:     mode,
-			}
-			files[fn] = p
-		}
-		p.Blocks = append(p.Blocks, ProfileBlock{
-			StartLine: toInt(m[2]),
-			StartCol:  toInt(m[3]),
-			EndLine:   toInt(m[4]),
-			EndCol:    toInt(m[5]),
-			NumStmt:   toInt(m[6]),
-			Count:     toInt(m[7]),
-		})
-	}
-	if err := s.Err(); err != nil {
-		return nil, err
-	}
-	for _, p := range files {
-		sort.Sort(blocksByStart(p.Blocks))
-		// Merge samples from the same location.
-		j := 1
-		for i := 1; i < len(p.Blocks); i++ {
-			b := p.Blocks[i]
-			last := p.Blocks[j-1]
-			if b.StartLine == last.StartLine &&
-				b.StartCol == last.StartCol &&
-				b.EndLine == last.EndLine &&
-				b.EndCol == last.EndCol {
-				if b.NumStmt != last.NumStmt {
-					return nil, fmt.Errorf("inconsistent NumStmt: changed from %d to %d", last.NumStmt, b.NumStmt)
-				}
-				if mode == "set" {
-					p.Blocks[j-1].Count |= b.Count
-				} else {
-					p.Blocks[j-1].Count += b.Count
-				}
-				continue
-			}
-			p.Blocks[j] = b
-			j++
-		}
-		p.Blocks = p.Blocks[:j]
-	}
-	// Generate a sorted slice.
-	profiles := make([]*Profile, 0, len(files))
-	for _, profile := range files {
-		profiles = append(profiles, profile)
-	}
-	sort.Sort(byFileName(profiles))
-	return profiles, nil
-}
-
-type blocksByStart []ProfileBlock
-
-func (b blocksByStart) Len() int      { return len(b) }
-func (b blocksByStart) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
-func (b blocksByStart) Less(i, j int) bool {
-	bi, bj := b[i], b[j]
-	return bi.StartLine < bj.StartLine || bi.StartLine == bj.StartLine && bi.StartCol < bj.StartCol
-}
-
-var lineRe = regexp.MustCompile(`^(.+):([0-9]+).([0-9]+),([0-9]+).([0-9]+) ([0-9]+) ([0-9]+)$`)
-
-func toInt(s string) int {
-	i, err := strconv.Atoi(s)
-	if err != nil {
-		panic(err)
-	}
-	return i
+	return cover.ParseProfiles(fileName)
 }
 
 // Boundary represents the position in a source file of the beginning or end of a
 // block as reported by the coverage profile. In HTML mode, it will correspond to
 // the opening or closing of a <span> tag and will be used to colorize the source
-type Boundary struct {
-	Offset int     // Location as a byte offset in the source file.
-	Start  bool    // Is this the start of a block?
-	Count  int     // Event count from the cover profile.
-	Norm   float64 // Count normalized to [0..1].
-	Index  int     // Order in input file.
-}
-
-// Boundaries returns a Profile as a set of Boundary objects within the provided src.
-func (p *Profile) Boundaries(src []byte) (boundaries []Boundary) {
-	// Find maximum count.
-	max := 0
-	for _, b := range p.Blocks {
-		if b.Count > max {
-			max = b.Count
-		}
-	}
-	// Divisor for normalization.
-	divisor := math.Log(float64(max))
-
-	// boundary returns a Boundary, populating the Norm field with a normalized Count.
-	index := 0
-	boundary := func(offset int, start bool, count int) Boundary {
-		b := Boundary{Offset: offset, Start: start, Count: count, Index: index}
-		index++
-		if !start || count == 0 {
-			return b
-		}
-		if max <= 1 {
-			b.Norm = 0.8 // Profile is in "set" mode; we want a heat map. Use cov8 in the CSS.
-		} else if count > 0 {
-			b.Norm = math.Log(float64(count)) / divisor
-		}
-		return b
-	}
-
-	line, col := 1, 2 // TODO: Why is this 2?
-	for si, bi := 0, 0; si < len(src) && bi < len(p.Blocks); {
-		b := p.Blocks[bi]
-		if b.StartLine == line && b.StartCol == col {
-			boundaries = append(boundaries, boundary(si, true, b.Count))
-		}
-		if b.EndLine == line && b.EndCol == col || line > b.EndLine {
-			boundaries = append(boundaries, boundary(si, false, 0))
-			bi++
-			continue // Don't advance through src; maybe the next block starts here.
-		}
-		if src[si] == '\n' {
-			line++
-			col = 0
-		}
-		col++
-		si++
-	}
-	sort.Sort(boundariesByPos(boundaries))
-	return
-}
-
-type boundariesByPos []Boundary
-
-func (b boundariesByPos) Len() int      { return len(b) }
-func (b boundariesByPos) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
-func (b boundariesByPos) Less(i, j int) bool {
-	if b[i].Offset == b[j].Offset {
-		// Boundaries at the same offset should be ordered according to
-		// their original position.
-		return b[i].Index < b[j].Index
-	}
-	return b[i].Offset < b[j].Offset
-}
+type Boundary = cover.Boundary
diff --git a/src/cmd/vendor/golang.org/x/tools/cover/profile.go b/src/cmd/vendor/golang.org/x/tools/cover/profile.go
new file mode 100644
index 0000000000..57195774ce
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/tools/cover/profile.go
@@ -0,0 +1,261 @@
+// Copyright 2013 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 cover provides support for parsing coverage profiles
+// generated by "go test -coverprofile=cover.out".
+package cover // import "golang.org/x/tools/cover"
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"math"
+	"os"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+// Profile represents the profiling data for a specific file.
+type Profile struct {
+	FileName string
+	Mode     string
+	Blocks   []ProfileBlock
+}
+
+// ProfileBlock represents a single block of profiling data.
+type ProfileBlock struct {
+	StartLine, StartCol int
+	EndLine, EndCol     int
+	NumStmt, Count      int
+}
+
+type byFileName []*Profile
+
+func (p byFileName) Len() int           { return len(p) }
+func (p byFileName) Less(i, j int) bool { return p[i].FileName < p[j].FileName }
+func (p byFileName) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
+
+// ParseProfiles parses profile data in the specified file and returns a
+// Profile for each source file described therein.
+func ParseProfiles(fileName string) ([]*Profile, error) {
+	pf, err := os.Open(fileName)
+	if err != nil {
+		return nil, err
+	}
+	defer pf.Close()
+
+	files := make(map[string]*Profile)
+	buf := bufio.NewReader(pf)
+	// First line is "mode: foo", where foo is "set", "count", or "atomic".
+	// Rest of file is in the format
+	//	encoding/base64/base64.go:34.44,37.40 3 1
+	// where the fields are: name.go:line.column,line.column numberOfStatements count
+	s := bufio.NewScanner(buf)
+	mode := ""
+	for s.Scan() {
+		line := s.Text()
+		if mode == "" {
+			const p = "mode: "
+			if !strings.HasPrefix(line, p) || line == p {
+				return nil, fmt.Errorf("bad mode line: %v", line)
+			}
+			mode = line[len(p):]
+			continue
+		}
+		fn, b, err := parseLine(line)
+		if err != nil {
+			return nil, fmt.Errorf("line %q doesn't match expected format: %v", line, err)
+		}
+		p := files[fn]
+		if p == nil {
+			p = &Profile{
+				FileName: fn,
+				Mode:     mode,
+			}
+			files[fn] = p
+		}
+		p.Blocks = append(p.Blocks, b)
+	}
+	if err := s.Err(); err != nil {
+		return nil, err
+	}
+	for _, p := range files {
+		sort.Sort(blocksByStart(p.Blocks))
+		// Merge samples from the same location.
+		j := 1
+		for i := 1; i < len(p.Blocks); i++ {
+			b := p.Blocks[i]
+			last := p.Blocks[j-1]
+			if b.StartLine == last.StartLine &&
+				b.StartCol == last.StartCol &&
+				b.EndLine == last.EndLine &&
+				b.EndCol == last.EndCol {
+				if b.NumStmt != last.NumStmt {
+					return nil, fmt.Errorf("inconsistent NumStmt: changed from %d to %d", last.NumStmt, b.NumStmt)
+				}
+				if mode == "set" {
+					p.Blocks[j-1].Count |= b.Count
+				} else {
+					p.Blocks[j-1].Count += b.Count
+				}
+				continue
+			}
+			p.Blocks[j] = b
+			j++
+		}
+		p.Blocks = p.Blocks[:j]
+	}
+	// Generate a sorted slice.
+	profiles := make([]*Profile, 0, len(files))
+	for _, profile := range files {
+		profiles = append(profiles, profile)
+	}
+	sort.Sort(byFileName(profiles))
+	return profiles, nil
+}
+
+// parseLine parses a line from a coverage file.
+// It is equivalent to the regex
+// ^(.+):([0-9]+)\.([0-9]+),([0-9]+)\.([0-9]+) ([0-9]+) ([0-9]+)$
+//
+// However, it is much faster: https://golang.org/cl/179377
+func parseLine(l string) (fileName string, block ProfileBlock, err error) {
+	end := len(l)
+
+	b := ProfileBlock{}
+	b.Count, end, err = seekBack(l, ' ', end, "Count")
+	if err != nil {
+		return "", b, err
+	}
+	b.NumStmt, end, err = seekBack(l, ' ', end, "NumStmt")
+	if err != nil {
+		return "", b, err
+	}
+	b.EndCol, end, err = seekBack(l, '.', end, "EndCol")
+	if err != nil {
+		return "", b, err
+	}
+	b.EndLine, end, err = seekBack(l, ',', end, "EndLine")
+	if err != nil {
+		return "", b, err
+	}
+	b.StartCol, end, err = seekBack(l, '.', end, "StartCol")
+	if err != nil {
+		return "", b, err
+	}
+	b.StartLine, end, err = seekBack(l, ':', end, "StartLine")
+	if err != nil {
+		return "", b, err
+	}
+	fn := l[0:end]
+	if fn == "" {
+		return "", b, errors.New("a FileName cannot be blank")
+	}
+	return fn, b, nil
+}
+
+// seekBack searches backwards from end to find sep in l, then returns the
+// value between sep and end as an integer.
+// If seekBack fails, the returned error will reference what.
+func seekBack(l string, sep byte, end int, what string) (value int, nextSep int, err error) {
+	// Since we're seeking backwards and we know only ASCII is legal for these values,
+	// we can ignore the possibility of non-ASCII characters.
+	for start := end - 1; start >= 0; start-- {
+		if l[start] == sep {
+			i, err := strconv.Atoi(l[start+1 : end])
+			if err != nil {
+				return 0, 0, fmt.Errorf("couldn't parse %q: %v", what, err)
+			}
+			if i < 0 {
+				return 0, 0, fmt.Errorf("negative values are not allowed for %s, found %d", what, i)
+			}
+			return i, start, nil
+		}
+	}
+	return 0, 0, fmt.Errorf("couldn't find a %s before %s", string(sep), what)
+}
+
+type blocksByStart []ProfileBlock
+
+func (b blocksByStart) Len() int      { return len(b) }
+func (b blocksByStart) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
+func (b blocksByStart) Less(i, j int) bool {
+	bi, bj := b[i], b[j]
+	return bi.StartLine < bj.StartLine || bi.StartLine == bj.StartLine && bi.StartCol < bj.StartCol
+}
+
+// Boundary represents the position in a source file of the beginning or end of a
+// block as reported by the coverage profile. In HTML mode, it will correspond to
+// the opening or closing of a <span> tag and will be used to colorize the source
+type Boundary struct {
+	Offset int     // Location as a byte offset in the source file.
+	Start  bool    // Is this the start of a block?
+	Count  int     // Event count from the cover profile.
+	Norm   float64 // Count normalized to [0..1].
+	Index  int     // Order in input file.
+}
+
+// Boundaries returns a Profile as a set of Boundary objects within the provided src.
+func (p *Profile) Boundaries(src []byte) (boundaries []Boundary) {
+	// Find maximum count.
+	max := 0
+	for _, b := range p.Blocks {
+		if b.Count > max {
+			max = b.Count
+		}
+	}
+	// Divisor for normalization.
+	divisor := math.Log(float64(max))
+
+	// boundary returns a Boundary, populating the Norm field with a normalized Count.
+	index := 0
+	boundary := func(offset int, start bool, count int) Boundary {
+		b := Boundary{Offset: offset, Start: start, Count: count, Index: index}
+		index++
+		if !start || count == 0 {
+			return b
+		}
+		if max <= 1 {
+			b.Norm = 0.8 // Profile is in"set" mode; we want a heat map. Use cov8 in the CSS.
+		} else if count > 0 {
+			b.Norm = math.Log(float64(count)) / divisor
+		}
+		return b
+	}
+
+	line, col := 1, 2 // TODO: Why is this 2?
+	for si, bi := 0, 0; si < len(src) && bi < len(p.Blocks); {
+		b := p.Blocks[bi]
+		if b.StartLine == line && b.StartCol == col {
+			boundaries = append(boundaries, boundary(si, true, b.Count))
+		}
+		if b.EndLine == line && b.EndCol == col || line > b.EndLine {
+			boundaries = append(boundaries, boundary(si, false, 0))
+			bi++
+			continue // Don't advance through src; maybe the next block starts here.
+		}
+		if src[si] == '\n' {
+			line++
+			col = 0
+		}
+		col++
+		si++
+	}
+	sort.Sort(boundariesByPos(boundaries))
+	return
+}
+
+type boundariesByPos []Boundary
+
+func (b boundariesByPos) Len() int      { return len(b) }
+func (b boundariesByPos) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
+func (b boundariesByPos) Less(i, j int) bool {
+	if b[i].Offset == b[j].Offset {
+		// Boundaries at the same offset should be ordered according to
+		// their original position.
+		return b[i].Index < b[j].Index
+	}
+	return b[i].Offset < b[j].Offset
+}
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index af92df8721..7a8e98733a 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -46,6 +46,7 @@ golang.org/x/sys/unix
 golang.org/x/sys/windows
 # golang.org/x/tools v0.1.1-0.20210220032852-2363391a5b2f
 ## explicit
+golang.org/x/tools/cover
 golang.org/x/tools/go/analysis
 golang.org/x/tools/go/analysis/internal/analysisflags
 golang.org/x/tools/go/analysis/internal/facts
-- 
GitLab


From 061a6903a232cb868780b1e724a75bf92a728489 Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Sat, 13 Mar 2021 16:52:16 -0800
Subject: [PATCH 1075/2400] all: add internal/itoa package

This replaces five implementations scattered across low level packages.
(And I plan to use it in a sixth soon.)
Three of the five were byte-for-byte identical.

Change-Id: I3bbbeeac63723a487986c912b604e10ad1e042f4
Reviewed-on: https://go-review.googlesource.com/c/go/+/301549
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/go/build/deps_test.go          |  1 +
 src/internal/itoa/itoa.go          | 33 ++++++++++++++++++++++++
 src/internal/itoa/itoa_test.go     | 40 ++++++++++++++++++++++++++++++
 src/internal/poll/fd_io_plan9.go   |  3 ++-
 src/internal/poll/strconv.go       | 28 ---------------------
 src/net/dnsclient.go               |  3 ++-
 src/net/dnsclient_unix.go          |  3 ++-
 src/net/interface.go               |  3 ++-
 src/net/interface_plan9.go         |  5 ++--
 src/net/ip.go                      |  7 ++++--
 src/net/ipsock_plan9.go            |  5 ++--
 src/net/lookup_plan9.go            |  3 ++-
 src/net/parse.go                   | 26 -------------------
 src/net/tcpsock.go                 |  5 ++--
 src/net/tcpsockopt_plan9.go        |  3 ++-
 src/net/udpsock.go                 |  5 ++--
 src/os/exec_plan9.go               |  3 ++-
 src/os/exec_posix.go               |  5 ++--
 src/os/executable_plan9.go         |  7 ++++--
 src/os/signal/signal_plan9_test.go | 18 ++------------
 src/os/str.go                      | 26 -------------------
 src/os/tempfile.go                 |  7 ++++--
 src/syscall/dll_windows.go         |  3 ++-
 src/syscall/exec_linux.go          |  9 ++++---
 src/syscall/exec_plan9.go          |  3 ++-
 src/syscall/export_test.go         |  7 ------
 src/syscall/str.go                 | 24 ------------------
 src/syscall/syscall_js.go          |  5 ++--
 src/syscall/syscall_linux.go       |  7 ++++--
 src/syscall/syscall_test.go        | 17 -------------
 src/syscall/syscall_unix.go        |  5 ++--
 src/syscall/syscall_windows.go     |  5 ++--
 32 files changed, 143 insertions(+), 181 deletions(-)
 create mode 100644 src/internal/itoa/itoa.go
 create mode 100644 src/internal/itoa/itoa_test.go
 delete mode 100644 src/syscall/export_test.go
 delete mode 100644 src/syscall/str.go

diff --git a/src/go/build/deps_test.go b/src/go/build/deps_test.go
index e05d0aac2e..63ef2428b1 100644
--- a/src/go/build/deps_test.go
+++ b/src/go/build/deps_test.go
@@ -83,6 +83,7 @@ var depsRules = `
 	# RUNTIME is the core runtime group of packages, all of them very light-weight.
 	internal/abi, internal/cpu, unsafe
 	< internal/bytealg
+	< internal/itoa
 	< internal/unsafeheader
 	< runtime/internal/sys
 	< runtime/internal/atomic
diff --git a/src/internal/itoa/itoa.go b/src/internal/itoa/itoa.go
new file mode 100644
index 0000000000..c6062d9fe1
--- /dev/null
+++ b/src/internal/itoa/itoa.go
@@ -0,0 +1,33 @@
+// Copyright 2021 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.
+
+// Simple conversions to avoid depending on strconv.
+
+package itoa
+
+// Itoa converts val to a decimal string.
+func Itoa(val int) string {
+	if val < 0 {
+		return "-" + Uitoa(uint(-val))
+	}
+	return Uitoa(uint(val))
+}
+
+// Uitoa converts val to a decimal string.
+func Uitoa(val uint) string {
+	if val == 0 { // avoid string allocation
+		return "0"
+	}
+	var buf [20]byte // big enough for 64bit value base 10
+	i := len(buf) - 1
+	for val >= 10 {
+		q := val / 10
+		buf[i] = byte('0' + val - q*10)
+		i--
+		val = q
+	}
+	// val < 10
+	buf[i] = byte('0' + val)
+	return string(buf[i:])
+}
diff --git a/src/internal/itoa/itoa_test.go b/src/internal/itoa/itoa_test.go
new file mode 100644
index 0000000000..71931c1e3a
--- /dev/null
+++ b/src/internal/itoa/itoa_test.go
@@ -0,0 +1,40 @@
+// Copyright 2021 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 itoa_test
+
+import (
+	"fmt"
+	"internal/itoa"
+	"math"
+	"testing"
+)
+
+var (
+	minInt64  int64  = math.MinInt64
+	maxInt64  int64  = math.MaxInt64
+	maxUint64 uint64 = math.MaxUint64
+)
+
+func TestItoa(t *testing.T) {
+	tests := []int{int(minInt64), math.MinInt32, -999, -100, -1, 0, 1, 100, 999, math.MaxInt32, int(maxInt64)}
+	for _, tt := range tests {
+		got := itoa.Itoa(tt)
+		want := fmt.Sprint(tt)
+		if want != got {
+			t.Fatalf("Itoa(%d) = %s, want %s", tt, got, want)
+		}
+	}
+}
+
+func TestUitoa(t *testing.T) {
+	tests := []uint{0, 1, 100, 999, math.MaxUint32, uint(maxUint64)}
+	for _, tt := range tests {
+		got := itoa.Uitoa(tt)
+		want := fmt.Sprint(tt)
+		if want != got {
+			t.Fatalf("Uitoa(%d) = %s, want %s", tt, got, want)
+		}
+	}
+}
diff --git a/src/internal/poll/fd_io_plan9.go b/src/internal/poll/fd_io_plan9.go
index 287d11bd8c..3205ac8513 100644
--- a/src/internal/poll/fd_io_plan9.go
+++ b/src/internal/poll/fd_io_plan9.go
@@ -5,6 +5,7 @@
 package poll
 
 import (
+	"internal/itoa"
 	"runtime"
 	"sync"
 	"syscall"
@@ -71,7 +72,7 @@ func (aio *asyncIO) Cancel() {
 	if aio.pid == -1 {
 		return
 	}
-	f, e := syscall.Open("/proc/"+itoa(aio.pid)+"/note", syscall.O_WRONLY)
+	f, e := syscall.Open("/proc/"+itoa.Itoa(aio.pid)+"/note", syscall.O_WRONLY)
 	if e != nil {
 		return
 	}
diff --git a/src/internal/poll/strconv.go b/src/internal/poll/strconv.go
index fd5e20f1f4..c98332d3da 100644
--- a/src/internal/poll/strconv.go
+++ b/src/internal/poll/strconv.go
@@ -5,36 +5,8 @@
 //go:build plan9
 // +build plan9
 
-// Simple conversions to avoid depending on strconv.
-
 package poll
 
-// Convert integer to decimal string
-func itoa(val int) string {
-	if val < 0 {
-		return "-" + uitoa(uint(-val))
-	}
-	return uitoa(uint(val))
-}
-
-// Convert unsigned integer to decimal string
-func uitoa(val uint) string {
-	if val == 0 { // avoid string allocation
-		return "0"
-	}
-	var buf [20]byte // big enough for 64bit value base 10
-	i := len(buf) - 1
-	for val >= 10 {
-		q := val / 10
-		buf[i] = byte('0' + val - q*10)
-		i--
-		val = q
-	}
-	// val < 10
-	buf[i] = byte('0' + val)
-	return string(buf[i:])
-}
-
 // stringsHasSuffix is strings.HasSuffix. It reports whether s ends in
 // suffix.
 func stringsHasSuffix(s, suffix string) bool {
diff --git a/src/net/dnsclient.go b/src/net/dnsclient.go
index e9c73845d7..1bbe39650b 100644
--- a/src/net/dnsclient.go
+++ b/src/net/dnsclient.go
@@ -5,6 +5,7 @@
 package net
 
 import (
+	"internal/itoa"
 	"sort"
 
 	"golang.org/x/net/dns/dnsmessage"
@@ -33,7 +34,7 @@ func reverseaddr(addr string) (arpa string, err error) {
 		return "", &DNSError{Err: "unrecognized address", Name: addr}
 	}
 	if ip.To4() != nil {
-		return uitoa(uint(ip[15])) + "." + uitoa(uint(ip[14])) + "." + uitoa(uint(ip[13])) + "." + uitoa(uint(ip[12])) + ".in-addr.arpa.", nil
+		return itoa.Uitoa(uint(ip[15])) + "." + itoa.Uitoa(uint(ip[14])) + "." + itoa.Uitoa(uint(ip[13])) + "." + itoa.Uitoa(uint(ip[12])) + ".in-addr.arpa.", nil
 	}
 	// Must be IPv6
 	buf := make([]byte, 0, len(ip)*4+len("ip6.arpa."))
diff --git a/src/net/dnsclient_unix.go b/src/net/dnsclient_unix.go
index a3242ff3b2..86f64335ea 100644
--- a/src/net/dnsclient_unix.go
+++ b/src/net/dnsclient_unix.go
@@ -18,6 +18,7 @@ package net
 import (
 	"context"
 	"errors"
+	"internal/itoa"
 	"io"
 	"os"
 	"sync"
@@ -510,7 +511,7 @@ func (o hostLookupOrder) String() string {
 	if s, ok := lookupOrderName[o]; ok {
 		return s
 	}
-	return "hostLookupOrder=" + itoa(int(o)) + "??"
+	return "hostLookupOrder=" + itoa.Itoa(int(o)) + "??"
 }
 
 // goLookupHost is the native Go implementation of LookupHost.
diff --git a/src/net/interface.go b/src/net/interface.go
index 914aaa010f..0e5d3202c9 100644
--- a/src/net/interface.go
+++ b/src/net/interface.go
@@ -6,6 +6,7 @@ package net
 
 import (
 	"errors"
+	"internal/itoa"
 	"sync"
 	"time"
 )
@@ -230,7 +231,7 @@ func (zc *ipv6ZoneCache) name(index int) string {
 		zoneCache.RUnlock()
 	}
 	if !ok { // last resort
-		name = uitoa(uint(index))
+		name = itoa.Uitoa(uint(index))
 	}
 	return name
 }
diff --git a/src/net/interface_plan9.go b/src/net/interface_plan9.go
index 31bbaca467..957975c265 100644
--- a/src/net/interface_plan9.go
+++ b/src/net/interface_plan9.go
@@ -6,6 +6,7 @@ package net
 
 import (
 	"errors"
+	"internal/itoa"
 	"os"
 )
 
@@ -38,8 +39,8 @@ func interfaceTable(ifindex int) ([]Interface, error) {
 
 func readInterface(i int) (*Interface, error) {
 	ifc := &Interface{
-		Index: i + 1,                        // Offset the index by one to suit the contract
-		Name:  netdir + "/ipifc/" + itoa(i), // Name is the full path to the interface path in plan9
+		Index: i + 1,                             // Offset the index by one to suit the contract
+		Name:  netdir + "/ipifc/" + itoa.Itoa(i), // Name is the full path to the interface path in plan9
 	}
 
 	ifcstat := ifc.Name + "/status"
diff --git a/src/net/ip.go b/src/net/ip.go
index c00fe8ed3c..18e3f3a2f5 100644
--- a/src/net/ip.go
+++ b/src/net/ip.go
@@ -12,7 +12,10 @@
 
 package net
 
-import "internal/bytealg"
+import (
+	"internal/bytealg"
+	"internal/itoa"
+)
 
 // IP address lengths (bytes).
 const (
@@ -531,7 +534,7 @@ func (n *IPNet) String() string {
 	if l == -1 {
 		return nn.String() + "/" + m.String()
 	}
-	return nn.String() + "/" + uitoa(uint(l))
+	return nn.String() + "/" + itoa.Uitoa(uint(l))
 }
 
 // Parse IPv4 address (d.d.d.d).
diff --git a/src/net/ipsock_plan9.go b/src/net/ipsock_plan9.go
index 7a4b7a6041..8e984d5e5f 100644
--- a/src/net/ipsock_plan9.go
+++ b/src/net/ipsock_plan9.go
@@ -7,6 +7,7 @@ package net
 import (
 	"context"
 	"internal/bytealg"
+	"internal/itoa"
 	"io/fs"
 	"os"
 	"syscall"
@@ -336,9 +337,9 @@ func plan9LocalAddr(addr Addr) string {
 		if port == 0 {
 			return ""
 		}
-		return itoa(port)
+		return itoa.Itoa(port)
 	}
-	return ip.String() + "!" + itoa(port)
+	return ip.String() + "!" + itoa.Itoa(port)
 }
 
 func hangupCtlWrite(ctx context.Context, proto string, ctl *os.File, msg string) error {
diff --git a/src/net/lookup_plan9.go b/src/net/lookup_plan9.go
index 5fc23f098b..75c18b33ac 100644
--- a/src/net/lookup_plan9.go
+++ b/src/net/lookup_plan9.go
@@ -8,6 +8,7 @@ import (
 	"context"
 	"errors"
 	"internal/bytealg"
+	"internal/itoa"
 	"io"
 	"os"
 )
@@ -84,7 +85,7 @@ func queryCS1(ctx context.Context, net string, ip IP, port int) (clone, dest str
 	if len(ip) != 0 && !ip.IsUnspecified() {
 		ips = ip.String()
 	}
-	lines, err := queryCS(ctx, net, ips, itoa(port))
+	lines, err := queryCS(ctx, net, ips, itoa.Itoa(port))
 	if err != nil {
 		return
 	}
diff --git a/src/net/parse.go b/src/net/parse.go
index cdb35bb826..6c230ab63f 100644
--- a/src/net/parse.go
+++ b/src/net/parse.go
@@ -172,32 +172,6 @@ func xtoi2(s string, e byte) (byte, bool) {
 	return byte(n), ok && ei == 2
 }
 
-// Convert integer to decimal string.
-func itoa(val int) string {
-	if val < 0 {
-		return "-" + uitoa(uint(-val))
-	}
-	return uitoa(uint(val))
-}
-
-// Convert unsigned integer to decimal string.
-func uitoa(val uint) string {
-	if val == 0 { // avoid string allocation
-		return "0"
-	}
-	var buf [20]byte // big enough for 64bit value base 10
-	i := len(buf) - 1
-	for val >= 10 {
-		q := val / 10
-		buf[i] = byte('0' + val - q*10)
-		i--
-		val = q
-	}
-	// val < 10
-	buf[i] = byte('0' + val)
-	return string(buf[i:])
-}
-
 // Convert i to a hexadecimal string. Leading zeros are not printed.
 func appendHex(dst []byte, i uint32) []byte {
 	if i == 0 {
diff --git a/src/net/tcpsock.go b/src/net/tcpsock.go
index 9a9b03a1e8..19a90143f3 100644
--- a/src/net/tcpsock.go
+++ b/src/net/tcpsock.go
@@ -6,6 +6,7 @@ package net
 
 import (
 	"context"
+	"internal/itoa"
 	"io"
 	"os"
 	"syscall"
@@ -31,9 +32,9 @@ func (a *TCPAddr) String() string {
 	}
 	ip := ipEmptyString(a.IP)
 	if a.Zone != "" {
-		return JoinHostPort(ip+"%"+a.Zone, itoa(a.Port))
+		return JoinHostPort(ip+"%"+a.Zone, itoa.Itoa(a.Port))
 	}
-	return JoinHostPort(ip, itoa(a.Port))
+	return JoinHostPort(ip, itoa.Itoa(a.Port))
 }
 
 func (a *TCPAddr) isWildcard() bool {
diff --git a/src/net/tcpsockopt_plan9.go b/src/net/tcpsockopt_plan9.go
index fb56871857..264359dcf3 100644
--- a/src/net/tcpsockopt_plan9.go
+++ b/src/net/tcpsockopt_plan9.go
@@ -7,6 +7,7 @@
 package net
 
 import (
+	"internal/itoa"
 	"syscall"
 	"time"
 )
@@ -17,7 +18,7 @@ func setNoDelay(fd *netFD, noDelay bool) error {
 
 // Set keep alive period.
 func setKeepAlivePeriod(fd *netFD, d time.Duration) error {
-	cmd := "keepalive " + itoa(int(d/time.Millisecond))
+	cmd := "keepalive " + itoa.Itoa(int(d/time.Millisecond))
 	_, e := fd.ctl.WriteAt([]byte(cmd), 0)
 	return e
 }
diff --git a/src/net/udpsock.go b/src/net/udpsock.go
index 571e099abd..bcd0e2763e 100644
--- a/src/net/udpsock.go
+++ b/src/net/udpsock.go
@@ -6,6 +6,7 @@ package net
 
 import (
 	"context"
+	"internal/itoa"
 	"syscall"
 )
 
@@ -34,9 +35,9 @@ func (a *UDPAddr) String() string {
 	}
 	ip := ipEmptyString(a.IP)
 	if a.Zone != "" {
-		return JoinHostPort(ip+"%"+a.Zone, itoa(a.Port))
+		return JoinHostPort(ip+"%"+a.Zone, itoa.Itoa(a.Port))
 	}
-	return JoinHostPort(ip, itoa(a.Port))
+	return JoinHostPort(ip, itoa.Itoa(a.Port))
 }
 
 func (a *UDPAddr) isWildcard() bool {
diff --git a/src/os/exec_plan9.go b/src/os/exec_plan9.go
index 8580153911..cc84f97669 100644
--- a/src/os/exec_plan9.go
+++ b/src/os/exec_plan9.go
@@ -5,6 +5,7 @@
 package os
 
 import (
+	"internal/itoa"
 	"runtime"
 	"syscall"
 	"time"
@@ -40,7 +41,7 @@ func startProcess(name string, argv []string, attr *ProcAttr) (p *Process, err e
 }
 
 func (p *Process) writeProcFile(file string, data string) error {
-	f, e := OpenFile("/proc/"+itoa(p.Pid)+"/"+file, O_WRONLY, 0)
+	f, e := OpenFile("/proc/"+itoa.Itoa(p.Pid)+"/"+file, O_WRONLY, 0)
 	if e != nil {
 		return e
 	}
diff --git a/src/os/exec_posix.go b/src/os/exec_posix.go
index 443d4e0218..e8736f7c54 100644
--- a/src/os/exec_posix.go
+++ b/src/os/exec_posix.go
@@ -8,6 +8,7 @@
 package os
 
 import (
+	"internal/itoa"
 	"internal/syscall/execenv"
 	"runtime"
 	"syscall"
@@ -107,14 +108,14 @@ func (p *ProcessState) String() string {
 		if runtime.GOOS == "windows" && uint(code) >= 1<<16 { // windows uses large hex numbers
 			res = "exit status " + uitox(uint(code))
 		} else { // unix systems use small decimal integers
-			res = "exit status " + itoa(code) // unix
+			res = "exit status " + itoa.Itoa(code) // unix
 		}
 	case status.Signaled():
 		res = "signal: " + status.Signal().String()
 	case status.Stopped():
 		res = "stop signal: " + status.StopSignal().String()
 		if status.StopSignal() == syscall.SIGTRAP && status.TrapCause() != 0 {
-			res += " (trap " + itoa(status.TrapCause()) + ")"
+			res += " (trap " + itoa.Itoa(status.TrapCause()) + ")"
 		}
 	case status.Continued():
 		res = "continued"
diff --git a/src/os/executable_plan9.go b/src/os/executable_plan9.go
index 105c03f0c1..ad7a4410dc 100644
--- a/src/os/executable_plan9.go
+++ b/src/os/executable_plan9.go
@@ -7,10 +7,13 @@
 
 package os
 
-import "syscall"
+import (
+	"internal/itoa"
+	"syscall"
+)
 
 func executable() (string, error) {
-	fn := "/proc/" + itoa(Getpid()) + "/text"
+	fn := "/proc/" + itoa.Itoa(Getpid()) + "/text"
 	f, err := Open(fn)
 	if err != nil {
 		return "", err
diff --git a/src/os/signal/signal_plan9_test.go b/src/os/signal/signal_plan9_test.go
index 10bfdc3ff1..8357199aa4 100644
--- a/src/os/signal/signal_plan9_test.go
+++ b/src/os/signal/signal_plan9_test.go
@@ -5,6 +5,7 @@
 package signal
 
 import (
+	"internal/itoa"
 	"os"
 	"runtime"
 	"syscall"
@@ -155,23 +156,8 @@ func TestStop(t *testing.T) {
 	}
 }
 
-func itoa(val int) string {
-	if val < 0 {
-		return "-" + itoa(-val)
-	}
-	var buf [32]byte // big enough for int64
-	i := len(buf) - 1
-	for val >= 10 {
-		buf[i] = byte(val%10 + '0')
-		i--
-		val /= 10
-	}
-	buf[i] = byte(val + '0')
-	return string(buf[i:])
-}
-
 func postNote(pid int, note string) error {
-	f, err := os.OpenFile("/proc/"+itoa(pid)+"/note", os.O_WRONLY, 0)
+	f, err := os.OpenFile("/proc/"+itoa.Itoa(pid)+"/note", os.O_WRONLY, 0)
 	if err != nil {
 		return err
 	}
diff --git a/src/os/str.go b/src/os/str.go
index 9bfcc15aa8..35643e0d2f 100644
--- a/src/os/str.go
+++ b/src/os/str.go
@@ -6,32 +6,6 @@
 
 package os
 
-// itoa converts val (an int) to a decimal string.
-func itoa(val int) string {
-	if val < 0 {
-		return "-" + uitoa(uint(-val))
-	}
-	return uitoa(uint(val))
-}
-
-// uitoa converts val (a uint) to a decimal string.
-func uitoa(val uint) string {
-	if val == 0 { // avoid string allocation
-		return "0"
-	}
-	var buf [20]byte // big enough for 64bit value base 10
-	i := len(buf) - 1
-	for val >= 10 {
-		q := val / 10
-		buf[i] = byte('0' + val - q*10)
-		i--
-		val = q
-	}
-	// val < 10
-	buf[i] = byte('0' + val)
-	return string(buf[i:])
-}
-
 // itox converts val (an int) to a hexdecimal string.
 func itox(val int) string {
 	if val < 0 {
diff --git a/src/os/tempfile.go b/src/os/tempfile.go
index 1ad44f1163..5b681fcebf 100644
--- a/src/os/tempfile.go
+++ b/src/os/tempfile.go
@@ -4,7 +4,10 @@
 
 package os
 
-import "errors"
+import (
+	"errors"
+	"internal/itoa"
+)
 
 // fastrand provided by runtime.
 // We generate random temporary file names so that there's a good
@@ -13,7 +16,7 @@ import "errors"
 func fastrand() uint32
 
 func nextRandom() string {
-	return uitoa(uint(fastrand()))
+	return itoa.Uitoa(uint(fastrand()))
 }
 
 // CreateTemp creates a new temporary file in the directory dir,
diff --git a/src/syscall/dll_windows.go b/src/syscall/dll_windows.go
index d99da00089..16210ca5b5 100644
--- a/src/syscall/dll_windows.go
+++ b/src/syscall/dll_windows.go
@@ -5,6 +5,7 @@
 package syscall
 
 import (
+	"internal/itoa"
 	"internal/syscall/windows/sysdll"
 	"sync"
 	"sync/atomic"
@@ -215,7 +216,7 @@ func (p *Proc) Call(a ...uintptr) (r1, r2 uintptr, lastErr error) {
 	case 18:
 		return Syscall18(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17])
 	default:
-		panic("Call " + p.Name + " with too many arguments " + itoa(len(a)) + ".")
+		panic("Call " + p.Name + " with too many arguments " + itoa.Itoa(len(a)) + ".")
 	}
 }
 
diff --git a/src/syscall/exec_linux.go b/src/syscall/exec_linux.go
index 6353da4048..deb8aa38b7 100644
--- a/src/syscall/exec_linux.go
+++ b/src/syscall/exec_linux.go
@@ -8,6 +8,7 @@
 package syscall
 
 import (
+	"internal/itoa"
 	"runtime"
 	"unsafe"
 )
@@ -568,7 +569,7 @@ func forkExecPipe(p []int) (err error) {
 func formatIDMappings(idMap []SysProcIDMap) []byte {
 	var data []byte
 	for _, im := range idMap {
-		data = append(data, []byte(itoa(im.ContainerID)+" "+itoa(im.HostID)+" "+itoa(im.Size)+"\n")...)
+		data = append(data, []byte(itoa.Itoa(im.ContainerID)+" "+itoa.Itoa(im.HostID)+" "+itoa.Itoa(im.Size)+"\n")...)
 	}
 	return data
 }
@@ -597,7 +598,7 @@ func writeIDMappings(path string, idMap []SysProcIDMap) error {
 // This is needed since kernel 3.19, because you can't write gid_map without
 // disabling setgroups() system call.
 func writeSetgroups(pid int, enable bool) error {
-	sgf := "/proc/" + itoa(pid) + "/setgroups"
+	sgf := "/proc/" + itoa.Itoa(pid) + "/setgroups"
 	fd, err := Open(sgf, O_RDWR, 0)
 	if err != nil {
 		return err
@@ -622,7 +623,7 @@ func writeSetgroups(pid int, enable bool) error {
 // for a process and it is called from the parent process.
 func writeUidGidMappings(pid int, sys *SysProcAttr) error {
 	if sys.UidMappings != nil {
-		uidf := "/proc/" + itoa(pid) + "/uid_map"
+		uidf := "/proc/" + itoa.Itoa(pid) + "/uid_map"
 		if err := writeIDMappings(uidf, sys.UidMappings); err != nil {
 			return err
 		}
@@ -633,7 +634,7 @@ func writeUidGidMappings(pid int, sys *SysProcAttr) error {
 		if err := writeSetgroups(pid, sys.GidMappingsEnableSetgroups); err != nil && err != ENOENT {
 			return err
 		}
-		gidf := "/proc/" + itoa(pid) + "/gid_map"
+		gidf := "/proc/" + itoa.Itoa(pid) + "/gid_map"
 		if err := writeIDMappings(gidf, sys.GidMappings); err != nil {
 			return err
 		}
diff --git a/src/syscall/exec_plan9.go b/src/syscall/exec_plan9.go
index 12c4237f69..c469fe1812 100644
--- a/src/syscall/exec_plan9.go
+++ b/src/syscall/exec_plan9.go
@@ -7,6 +7,7 @@
 package syscall
 
 import (
+	"internal/itoa"
 	"runtime"
 	"sync"
 	"unsafe"
@@ -320,7 +321,7 @@ func cexecPipe(p []int) error {
 		return e
 	}
 
-	fd, e := Open("#d/"+itoa(p[1]), O_RDWR|O_CLOEXEC)
+	fd, e := Open("#d/"+itoa.Itoa(p[1]), O_RDWR|O_CLOEXEC)
 	if e != nil {
 		Close(p[0])
 		Close(p[1])
diff --git a/src/syscall/export_test.go b/src/syscall/export_test.go
deleted file mode 100644
index 55c09e667e..0000000000
--- a/src/syscall/export_test.go
+++ /dev/null
@@ -1,7 +0,0 @@
-// Copyright 2014 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 syscall
-
-var Itoa = itoa
diff --git a/src/syscall/str.go b/src/syscall/str.go
deleted file mode 100644
index 2ddf04b227..0000000000
--- a/src/syscall/str.go
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright 2009 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 syscall
-
-func itoa(val int) string { // do it here rather than with fmt to avoid dependency
-	if val < 0 {
-		return "-" + uitoa(uint(-val))
-	}
-	return uitoa(uint(val))
-}
-
-func uitoa(val uint) string {
-	var buf [32]byte // big enough for int64
-	i := len(buf) - 1
-	for val >= 10 {
-		buf[i] = byte(val%10 + '0')
-		i--
-		val /= 10
-	}
-	buf[i] = byte(val + '0')
-	return string(buf[i:])
-}
diff --git a/src/syscall/syscall_js.go b/src/syscall/syscall_js.go
index c17c6fcdcf..ed70d62284 100644
--- a/src/syscall/syscall_js.go
+++ b/src/syscall/syscall_js.go
@@ -8,6 +8,7 @@
 package syscall
 
 import (
+	"internal/itoa"
 	"internal/oserror"
 	"sync"
 	"unsafe"
@@ -60,7 +61,7 @@ func (e Errno) Error() string {
 			return s
 		}
 	}
-	return "errno " + itoa(int(e))
+	return "errno " + itoa.Itoa(int(e))
 }
 
 func (e Errno) Is(target error) bool {
@@ -106,7 +107,7 @@ func (s Signal) String() string {
 			return str
 		}
 	}
-	return "signal " + itoa(int(s))
+	return "signal " + itoa.Itoa(int(s))
 }
 
 var signals = [...]string{}
diff --git a/src/syscall/syscall_linux.go b/src/syscall/syscall_linux.go
index 3041f6f8fc..24e051dcbd 100644
--- a/src/syscall/syscall_linux.go
+++ b/src/syscall/syscall_linux.go
@@ -11,7 +11,10 @@
 
 package syscall
 
-import "unsafe"
+import (
+	"internal/itoa"
+	"unsafe"
+)
 
 func rawSyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr)
 
@@ -225,7 +228,7 @@ func Futimesat(dirfd int, path string, tv []Timeval) (err error) {
 func Futimes(fd int, tv []Timeval) (err error) {
 	// Believe it or not, this is the best we can do on Linux
 	// (and is what glibc does).
-	return Utimes("/proc/self/fd/"+itoa(fd), tv)
+	return Utimes("/proc/self/fd/"+itoa.Itoa(fd), tv)
 }
 
 const ImplementsGetwd = true
diff --git a/src/syscall/syscall_test.go b/src/syscall/syscall_test.go
index 5390f8aace..b2b9463b0f 100644
--- a/src/syscall/syscall_test.go
+++ b/src/syscall/syscall_test.go
@@ -5,7 +5,6 @@
 package syscall_test
 
 import (
-	"fmt"
 	"internal/testenv"
 	"os"
 	"runtime"
@@ -33,22 +32,6 @@ func TestEnv(t *testing.T) {
 	testSetGetenv(t, "TESTENV", "")
 }
 
-func TestItoa(t *testing.T) {
-	// Make most negative integer: 0x8000...
-	i := 1
-	for i<<1 != 0 {
-		i <<= 1
-	}
-	if i >= 0 {
-		t.Fatal("bad math")
-	}
-	s := syscall.Itoa(i)
-	f := fmt.Sprint(i)
-	if s != f {
-		t.Fatalf("itoa(%d) = %s, want %s", i, s, f)
-	}
-}
-
 // Check that permuting child process fds doesn't interfere with
 // reporting of fork/exec status. See Issue 14979.
 func TestExecErrPermutedFds(t *testing.T) {
diff --git a/src/syscall/syscall_unix.go b/src/syscall/syscall_unix.go
index 40fc8b8a30..5b405b99b4 100644
--- a/src/syscall/syscall_unix.go
+++ b/src/syscall/syscall_unix.go
@@ -8,6 +8,7 @@
 package syscall
 
 import (
+	"internal/itoa"
 	"internal/oserror"
 	"internal/race"
 	"internal/unsafeheader"
@@ -121,7 +122,7 @@ func (e Errno) Error() string {
 			return s
 		}
 	}
-	return "errno " + itoa(int(e))
+	return "errno " + itoa.Itoa(int(e))
 }
 
 func (e Errno) Is(target error) bool {
@@ -181,7 +182,7 @@ func (s Signal) String() string {
 			return str
 		}
 	}
-	return "signal " + itoa(int(s))
+	return "signal " + itoa.Itoa(int(s))
 }
 
 func Read(fd int, p []byte) (n int, err error) {
diff --git a/src/syscall/syscall_windows.go b/src/syscall/syscall_windows.go
index 65af6637ae..f9f78bd2b3 100644
--- a/src/syscall/syscall_windows.go
+++ b/src/syscall/syscall_windows.go
@@ -8,6 +8,7 @@ package syscall
 
 import (
 	errorspkg "errors"
+	"internal/itoa"
 	"internal/oserror"
 	"internal/race"
 	"internal/unsafeheader"
@@ -132,7 +133,7 @@ func (e Errno) Error() string {
 	if err != nil {
 		n, err = formatMessage(flags, 0, uint32(e), 0, b, nil)
 		if err != nil {
-			return "winapi error #" + itoa(int(e))
+			return "winapi error #" + itoa.Itoa(int(e))
 		}
 	}
 	// trim terminating \r and \n
@@ -1152,7 +1153,7 @@ func (s Signal) String() string {
 			return str
 		}
 	}
-	return "signal " + itoa(int(s))
+	return "signal " + itoa.Itoa(int(s))
 }
 
 func LoadCreateSymbolicLink() error {
-- 
GitLab


From a8b59fe3cdaeeb40c87d55122a45a2e390e60d88 Mon Sep 17 00:00:00 2001
From: Ariel Mashraki <ariel@mashraki.co.il>
Date: Sun, 14 Mar 2021 18:12:59 +0200
Subject: [PATCH 1076/2400] encoding/json: fix package shadowing in
 MarshalIndent example

Prior to this CL, pasting the example from the website causes a
compilation error for some programs because it was shadowing the
"json" package.

Change-Id: I39b68a66ca99468547f2027a7655cf1387b61e95
Reviewed-on: https://go-review.googlesource.com/c/go/+/301492
Reviewed-by: Joe Tsai <joetsai@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Joe Tsai <joetsai@google.com>
Run-TryBot: Joe Tsai <joetsai@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/encoding/json/example_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/encoding/json/example_test.go b/src/encoding/json/example_test.go
index 2088c34297..fbecf1b593 100644
--- a/src/encoding/json/example_test.go
+++ b/src/encoding/json/example_test.go
@@ -279,12 +279,12 @@ func ExampleMarshalIndent() {
 		"b": 2,
 	}
 
-	json, err := json.MarshalIndent(data, "<prefix>", "<indent>")
+	b, err := json.MarshalIndent(data, "<prefix>", "<indent>")
 	if err != nil {
 		log.Fatal(err)
 	}
 
-	fmt.Println(string(json))
+	fmt.Println(string(b))
 	// Output:
 	// {
 	// <prefix><indent>"a": 1,
-- 
GitLab


From 3cdd5c3bcc53298dd7de39cb6e2bd600308988b8 Mon Sep 17 00:00:00 2001
From: Alessandro Arzilli <alessandro.arzilli@gmail.com>
Date: Thu, 12 Nov 2020 16:02:55 +0100
Subject: [PATCH 1077/2400] cmd/link: regression test for issue #42484

Adds test to check that the compiler does not emit duplicate debug_line
entries for the end of sequence address.

Updates #42484

Change-Id: I3c5d1d606fcfd758aa1fd83ecc51d8edc054398b
Reviewed-on: https://go-review.googlesource.com/c/go/+/270197
TryBot-Result: Go Bot <gobot@golang.org>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/ld/dwarf_test.go        | 71 +++++++++++++++++++
 .../internal/ld/testdata/issue42484/main.go   | 16 +++++
 2 files changed, 87 insertions(+)
 create mode 100644 src/cmd/link/internal/ld/testdata/issue42484/main.go

diff --git a/src/cmd/link/internal/ld/dwarf_test.go b/src/cmd/link/internal/ld/dwarf_test.go
index f5f2258451..5e4151885a 100644
--- a/src/cmd/link/internal/ld/dwarf_test.go
+++ b/src/cmd/link/internal/ld/dwarf_test.go
@@ -1570,3 +1570,74 @@ func TestIssue39757(t *testing.T) {
 		}
 	}
 }
+
+func TestIssue42484(t *testing.T) {
+	testenv.MustHaveGoBuild(t)
+
+	if runtime.GOOS == "plan9" {
+		t.Skip("skipping on plan9; no DWARF symbol table in executables")
+	}
+
+	t.Parallel()
+
+	tmpdir, err := ioutil.TempDir("", "TestIssue42484")
+	if err != nil {
+		t.Fatalf("could not create directory: %v", err)
+	}
+	defer os.RemoveAll(tmpdir)
+	wd, err := os.Getwd()
+	if err != nil {
+		t.Fatalf("where am I? %v", err)
+	}
+	pdir := filepath.Join(wd, "testdata", "issue42484")
+	f := gobuildTestdata(t, tmpdir, pdir, NoOpt)
+
+	var lastAddr uint64
+	var lastFile string
+	var lastLine int
+
+	dw, err := f.DWARF()
+	if err != nil {
+		t.Fatalf("error parsing DWARF: %v", err)
+	}
+	rdr := dw.Reader()
+	for {
+		e, err := rdr.Next()
+		if err != nil {
+			t.Fatalf("error reading DWARF: %v", err)
+		}
+		if e == nil {
+			break
+		}
+		if e.Tag != dwarf.TagCompileUnit {
+			continue
+		}
+		lnrdr, err := dw.LineReader(e)
+		if err != nil {
+			t.Fatalf("error creating DWARF line reader: %v", err)
+		}
+		if lnrdr != nil {
+			var lne dwarf.LineEntry
+			for {
+				err := lnrdr.Next(&lne)
+				if err == io.EOF {
+					break
+				}
+				if err != nil {
+					t.Fatalf("error reading next DWARF line: %v", err)
+				}
+				if lne.EndSequence {
+					continue
+				}
+				if lne.Address == lastAddr && (lne.File.Name != lastFile || lne.Line != lastLine) {
+					t.Errorf("address %#x is assigned to both %s:%d and %s:%d", lastAddr, lastFile, lastLine, lne.File.Name, lne.Line)
+				}
+				lastAddr = lne.Address
+				lastFile = lne.File.Name
+				lastLine = lne.Line
+			}
+		}
+		rdr.SkipChildren()
+	}
+	f.Close()
+}
diff --git a/src/cmd/link/internal/ld/testdata/issue42484/main.go b/src/cmd/link/internal/ld/testdata/issue42484/main.go
new file mode 100644
index 0000000000..60fc110ffa
--- /dev/null
+++ b/src/cmd/link/internal/ld/testdata/issue42484/main.go
@@ -0,0 +1,16 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	a := 0
+	a++
+	b := 0
+	f1(a, b)
+}
+
+func f1(a, b int) {
+	fmt.Printf("%d %d\n", a, b)
+}
-- 
GitLab


From d0d38f0f707e69965a5f5a637fa568c646899d39 Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Sun, 14 Mar 2021 14:27:06 -0700
Subject: [PATCH 1078/2400] cmd/compile: fix whitespace in comment

The whitespace was there to align with the following comment,
but the extra whitespace was unnecessary; it wasn't gofmt'd.
Then the file got gofmt'd, but the whitespace didn't get fixed.

Change-Id: I45aad9605b99d83545e4e611ae3ea1b2ff9e6bf6
Reviewed-on: https://go-review.googlesource.com/c/go/+/301649
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/cmd/compile/internal/ssa/gen/genericOps.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go
index 2a5b77bad0..85c58ef74c 100644
--- a/src/cmd/compile/internal/ssa/gen/genericOps.go
+++ b/src/cmd/compile/internal/ssa/gen/genericOps.go
@@ -264,7 +264,7 @@ var genericOps = []opData{
 	//   ±0  → ±0 (sign preserved)
 	//   x<0 → NaN
 	//   NaN → NaN
-	{name: "Sqrt", argLength: 1},   // √arg0   (floating point, double precision)
+	{name: "Sqrt", argLength: 1},   // √arg0 (floating point, double precision)
 	{name: "Sqrt32", argLength: 1}, // √arg0 (floating point, single precision)
 
 	// Round to integer, float64 only.
-- 
GitLab


From 6ccb5c49cca52766f6d288d128db67be6392c579 Mon Sep 17 00:00:00 2001
From: Tao Qingyun <qingyunha@gmail.com>
Date: Sun, 14 Mar 2021 00:09:05 +0000
Subject: [PATCH 1079/2400] cmd/link/internal/ld: fix typo in a comment

Change-Id: I9ae39aa2da2bfa6bb5d3f279bca764128d9cc401
GitHub-Last-Rev: 7a5945ae120b911793a1510f371945ac17611440
GitHub-Pull-Request: golang/go#44990
Reviewed-on: https://go-review.googlesource.com/c/go/+/301529
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Trust: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/cmd/link/internal/ld/deadcode.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/link/internal/ld/deadcode.go b/src/cmd/link/internal/ld/deadcode.go
index ea98fea4e5..a52652566b 100644
--- a/src/cmd/link/internal/ld/deadcode.go
+++ b/src/cmd/link/internal/ld/deadcode.go
@@ -118,7 +118,7 @@ func (d *deadcodePass) flood() {
 
 		if isgotype {
 			if d.dynlink {
-				// When dynaamic linking, a type may be passed across DSO
+				// When dynamic linking, a type may be passed across DSO
 				// boundary and get converted to interface at the other side.
 				d.ldr.SetAttrUsedInIface(symIdx, true)
 			}
-- 
GitLab


From 4350e4961a6ea3d36a33271423735b37c96dd5bf Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Wed, 10 Mar 2021 17:06:54 -0600
Subject: [PATCH 1080/2400] crypto/md5: improve ppc64x performance
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This is mostly cleanup and simplification.  This removes
many unneeded register moves, loads, and bit twiddlings
which were holdovers from porting this from the amd64
version.

The updated code loads each block once per iteration
instead of once per round. Similarly, the logical
operations now match the original md5 specification.

Likewise, add extra sizes to the benchtest to give more
data points on how the implementation scales with input
size.

All in all, this is roughly a 20% improvement on ppc64le
code running on POWER9 (POWER8 is similar, but around
16%):

name                 old time/op    new time/op    delta
Hash8Bytes              297ns ± 0%     255ns ± 0%  -14.14%
Hash64                  527ns ± 0%     444ns ± 0%  -15.76%
Hash128                 771ns ± 0%     645ns ± 0%  -16.35%
Hash256                1.26µs ± 0%    1.05µs ± 0%  -16.68%
Hash512                2.23µs ± 0%    1.85µs ± 0%  -16.82%
Hash1K                 4.16µs ± 0%    3.46µs ± 0%  -16.83%
Hash8K                 31.2µs ± 0%    26.0µs ± 0%  -16.74%
Hash1M                 3.58ms ± 0%    2.98ms ± 0%  -16.74%
Hash8M                 26.1ms ± 0%    21.7ms ± 0%  -16.81%
Hash8BytesUnaligned     297ns ± 0%     255ns ± 0%  -14.08%
Hash1KUnaligned        4.16µs ± 0%    3.46µs ± 0%  -16.79%
Hash8KUnaligned        31.2µs ± 0%    26.0µs ± 0%  -16.78%

name                 old speed      new speed      delta
Hash8Bytes           26.9MB/s ± 0%  31.4MB/s ± 0%  +16.45%
Hash64                122MB/s ± 0%   144MB/s ± 0%  +18.69%
Hash128               166MB/s ± 0%   199MB/s ± 0%  +19.54%
Hash256               203MB/s ± 0%   244MB/s ± 0%  +20.01%
Hash512               230MB/s ± 0%   276MB/s ± 0%  +20.18%
Hash1K                246MB/s ± 0%   296MB/s ± 0%  +20.26%
Hash8K                263MB/s ± 0%   315MB/s ± 0%  +20.11%
Hash1M                293MB/s ± 0%   352MB/s ± 0%  +20.10%
Hash8M                321MB/s ± 0%   386MB/s ± 0%  +20.21%
Hash8BytesUnaligned  26.9MB/s ± 0%  31.4MB/s ± 0%  +16.41%
Hash1KUnaligned       246MB/s ± 0%   296MB/s ± 0%  +20.19%
Hash8KUnaligned       263MB/s ± 0%   315MB/s ± 0%  +20.15%

Change-Id: I269bfa6878966bb4f6a64dc349100f5dc453ab7c
Reviewed-on: https://go-review.googlesource.com/c/go/+/300613
Run-TryBot: Paul Murphy <murp@ibm.com>
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/crypto/md5/md5_test.go       |  26 ++-
 src/crypto/md5/md5block_ppc64x.s | 303 ++++++++++++++++---------------
 2 files changed, 182 insertions(+), 147 deletions(-)

diff --git a/src/crypto/md5/md5_test.go b/src/crypto/md5/md5_test.go
index c0ac0971c4..acd456af21 100644
--- a/src/crypto/md5/md5_test.go
+++ b/src/crypto/md5/md5_test.go
@@ -212,7 +212,7 @@ func TestLargeHashes(t *testing.T) {
 }
 
 var bench = New()
-var buf = make([]byte, 8192+1)
+var buf = make([]byte, 1024*1024*8+1)
 var sum = make([]byte, bench.Size())
 
 func benchmarkSize(b *testing.B, size int, unaligned bool) {
@@ -235,6 +235,22 @@ func BenchmarkHash8Bytes(b *testing.B) {
 	benchmarkSize(b, 8, false)
 }
 
+func BenchmarkHash64(b *testing.B) {
+	benchmarkSize(b, 64, false)
+}
+
+func BenchmarkHash128(b *testing.B) {
+	benchmarkSize(b, 128, false)
+}
+
+func BenchmarkHash256(b *testing.B) {
+	benchmarkSize(b, 256, false)
+}
+
+func BenchmarkHash512(b *testing.B) {
+	benchmarkSize(b, 512, false)
+}
+
 func BenchmarkHash1K(b *testing.B) {
 	benchmarkSize(b, 1024, false)
 }
@@ -243,6 +259,14 @@ func BenchmarkHash8K(b *testing.B) {
 	benchmarkSize(b, 8192, false)
 }
 
+func BenchmarkHash1M(b *testing.B) {
+	benchmarkSize(b, 1024*1024, false)
+}
+
+func BenchmarkHash8M(b *testing.B) {
+	benchmarkSize(b, 8*1024*1024, false)
+}
+
 func BenchmarkHash8BytesUnaligned(b *testing.B) {
 	benchmarkSize(b, 8, true)
 }
diff --git a/src/crypto/md5/md5block_ppc64x.s b/src/crypto/md5/md5block_ppc64x.s
index f309a1413d..e1f859e337 100644
--- a/src/crypto/md5/md5block_ppc64x.s
+++ b/src/crypto/md5/md5block_ppc64x.s
@@ -28,169 +28,179 @@
 	MOVWBR	(idx)(ptr), dst
 #endif
 
-TEXT ·block(SB),NOSPLIT,$0-32
-	MOVD	dig+0(FP), R10
-	MOVD	p+8(FP), R6
-	MOVD	p_len+16(FP), R5
-	SLD	$6, R5
-	SRD	$6, R5
-	ADD	R6, R5, R7
-
-	MOVWZ	0(R10), R22
-	MOVWZ	4(R10), R3
-	MOVWZ	8(R10), R4
-	MOVWZ	12(R10), R5
-	CMP	R6, R7
-	BEQ	end
-
-loop:
-	MOVWZ	R22, R14
-	MOVWZ	R3, R15
-	MOVWZ	R4, R16
-	MOVWZ	R5, R17
-
-	ENDIAN_MOVE(0,R6,R8,R21)
-	MOVWZ	R5, R9
+#define M00 R18
+#define M01 R19
+#define M02 R20
+#define M03 R24
+#define M04 R25
+#define M05 R26
+#define M06 R27
+#define M07 R28
+#define M08 R29
+#define M09 R21
+#define M10 R11
+#define M11 R8
+#define M12 R7
+#define M13 R12
+#define M14 R23
+#define M15 R10
 
 #define ROUND1(a, b, c, d, index, const, shift) \
-	XOR	c, R9; \
-	ADD	$const, a; \
-	ADD	R8, a; \
-	AND	b, R9; \
-	XOR	d, R9; \
-	ENDIAN_MOVE(index*4,R6,R8,R21); \
+	ADD	$const, index, R9; \
 	ADD	R9, a; \
-	RLWMI	$shift, a, $0xffffffff, a; \
-	MOVWZ	c, R9; \
-	ADD	b, a; \
-	MOVWZ	a, a
-
-	ROUND1(R22,R3,R4,R5, 1,0xd76aa478, 7);
-	ROUND1(R5,R22,R3,R4, 2,0xe8c7b756,12);
-	ROUND1(R4,R5,R22,R3, 3,0x242070db,17);
-	ROUND1(R3,R4,R5,R22, 4,0xc1bdceee,22);
-	ROUND1(R22,R3,R4,R5, 5,0xf57c0faf, 7);
-	ROUND1(R5,R22,R3,R4, 6,0x4787c62a,12);
-	ROUND1(R4,R5,R22,R3, 7,0xa8304613,17);
-	ROUND1(R3,R4,R5,R22, 8,0xfd469501,22);
-	ROUND1(R22,R3,R4,R5, 9,0x698098d8, 7);
-	ROUND1(R5,R22,R3,R4,10,0x8b44f7af,12);
-	ROUND1(R4,R5,R22,R3,11,0xffff5bb1,17);
-	ROUND1(R3,R4,R5,R22,12,0x895cd7be,22);
-	ROUND1(R22,R3,R4,R5,13,0x6b901122, 7);
-	ROUND1(R5,R22,R3,R4,14,0xfd987193,12);
-	ROUND1(R4,R5,R22,R3,15,0xa679438e,17);
-	ROUND1(R3,R4,R5,R22, 0,0x49b40821,22);
-
-	ENDIAN_MOVE(1*4,R6,R8,R21)
-	MOVWZ	R5, R9
-	MOVWZ	R5, R10
+	AND     b, c, R9; \
+	ANDN    b, d, R31; \
+	OR	R9, R31, R9; \
+	ADD	R9, a; \
+	ROTLW	$shift, a; \
+	ADD	b, a;
 
 #define ROUND2(a, b, c, d, index, const, shift) \
-	XOR	$0xffffffff, R9; \ // NOTW R9
-	ADD	$const, a; \
-	ADD	R8, a; \
-	AND	b, R10; \
-	AND	c, R9; \
-	ENDIAN_MOVE(index*4,R6,R8,R21); \
-	OR	R9, R10; \
-	MOVWZ	c, R9; \
-	ADD	R10, a; \
-	MOVWZ	c, R10; \
-	RLWMI	$shift, a, $0xffffffff, a; \
-	ADD	b, a; \
-	MOVWZ	a, a
-
-	ROUND2(R22,R3,R4,R5, 6,0xf61e2562, 5);
-	ROUND2(R5,R22,R3,R4,11,0xc040b340, 9);
-	ROUND2(R4,R5,R22,R3, 0,0x265e5a51,14);
-	ROUND2(R3,R4,R5,R22, 5,0xe9b6c7aa,20);
-	ROUND2(R22,R3,R4,R5,10,0xd62f105d, 5);
-	ROUND2(R5,R22,R3,R4,15, 0x2441453, 9);
-	ROUND2(R4,R5,R22,R3, 4,0xd8a1e681,14);
-	ROUND2(R3,R4,R5,R22, 9,0xe7d3fbc8,20);
-	ROUND2(R22,R3,R4,R5,14,0x21e1cde6, 5);
-	ROUND2(R5,R22,R3,R4, 3,0xc33707d6, 9);
-	ROUND2(R4,R5,R22,R3, 8,0xf4d50d87,14);
-	ROUND2(R3,R4,R5,R22,13,0x455a14ed,20);
-	ROUND2(R22,R3,R4,R5, 2,0xa9e3e905, 5);
-	ROUND2(R5,R22,R3,R4, 7,0xfcefa3f8, 9);
-	ROUND2(R4,R5,R22,R3,12,0x676f02d9,14);
-	ROUND2(R3,R4,R5,R22, 0,0x8d2a4c8a,20);
-
-	ENDIAN_MOVE(5*4,R6,R8,R21)
-	MOVWZ	R4, R9
+	ADD	$const, index, R9; \
+	ADD	R9, a; \
+	AND	b, d, R31; \
+	ANDN	d, c, R9; \
+	OR	R9, R31; \
+	ADD	R31, a; \
+	ROTLW	$shift, a; \
+	ADD	b, a;
 
 #define ROUND3(a, b, c, d, index, const, shift) \
-	ADD	$const, a; \
-	ADD	R8, a; \
-	ENDIAN_MOVE(index*4,R6,R8,R21); \
-	XOR	d, R9; \
-	XOR	b, R9; \
+	ADD	$const, index, R9; \
 	ADD	R9, a; \
-	RLWMI	$shift, a, $0xffffffff, a; \
-	MOVWZ	b, R9; \
-	ADD	b, a; \
-	MOVWZ	a, a
-
-	ROUND3(R22,R3,R4,R5, 8,0xfffa3942, 4);
-	ROUND3(R5,R22,R3,R4,11,0x8771f681,11);
-	ROUND3(R4,R5,R22,R3,14,0x6d9d6122,16);
-	ROUND3(R3,R4,R5,R22, 1,0xfde5380c,23);
-	ROUND3(R22,R3,R4,R5, 4,0xa4beea44, 4);
-	ROUND3(R5,R22,R3,R4, 7,0x4bdecfa9,11);
-	ROUND3(R4,R5,R22,R3,10,0xf6bb4b60,16);
-	ROUND3(R3,R4,R5,R22,13,0xbebfbc70,23);
-	ROUND3(R22,R3,R4,R5, 0,0x289b7ec6, 4);
-	ROUND3(R5,R22,R3,R4, 3,0xeaa127fa,11);
-	ROUND3(R4,R5,R22,R3, 6,0xd4ef3085,16);
-	ROUND3(R3,R4,R5,R22, 9, 0x4881d05,23);
-	ROUND3(R22,R3,R4,R5,12,0xd9d4d039, 4);
-	ROUND3(R5,R22,R3,R4,15,0xe6db99e5,11);
-	ROUND3(R4,R5,R22,R3, 2,0x1fa27cf8,16);
-	ROUND3(R3,R4,R5,R22, 0,0xc4ac5665,23);
-
-	ENDIAN_MOVE(0,R6,R8,R21)
-	MOVWZ	$0xffffffff, R9
-	XOR	R5, R9
+	XOR	d, c, R31; \
+	XOR	b, R31; \
+	ADD	R31, a; \
+	ROTLW	$shift, a; \
+	ADD	b, a;
 
 #define ROUND4(a, b, c, d, index, const, shift) \
-	ADD	$const, a; \
-	ADD	R8, a; \
-	OR	b, R9; \
-	XOR	c, R9; \
+	ADD	$const, index, R9; \
 	ADD	R9, a; \
-	ENDIAN_MOVE(index*4,R6,R8,R21); \
-	MOVWZ	$0xffffffff, R9; \
-	RLWMI	$shift, a, $0xffffffff, a; \
-	XOR	c, R9; \
-	ADD	b, a; \
-	MOVWZ	a, a
-
-	ROUND4(R22,R3,R4,R5, 7,0xf4292244, 6);
-	ROUND4(R5,R22,R3,R4,14,0x432aff97,10);
-	ROUND4(R4,R5,R22,R3, 5,0xab9423a7,15);
-	ROUND4(R3,R4,R5,R22,12,0xfc93a039,21);
-	ROUND4(R22,R3,R4,R5, 3,0x655b59c3, 6);
-	ROUND4(R5,R22,R3,R4,10,0x8f0ccc92,10);
-	ROUND4(R4,R5,R22,R3, 1,0xffeff47d,15);
-	ROUND4(R3,R4,R5,R22, 8,0x85845dd1,21);
-	ROUND4(R22,R3,R4,R5,15,0x6fa87e4f, 6);
-	ROUND4(R5,R22,R3,R4, 6,0xfe2ce6e0,10);
-	ROUND4(R4,R5,R22,R3,13,0xa3014314,15);
-	ROUND4(R3,R4,R5,R22, 4,0x4e0811a1,21);
-	ROUND4(R22,R3,R4,R5,11,0xf7537e82, 6);
-	ROUND4(R5,R22,R3,R4, 2,0xbd3af235,10);
-	ROUND4(R4,R5,R22,R3, 9,0x2ad7d2bb,15);
-	ROUND4(R3,R4,R5,R22, 0,0xeb86d391,21);
+	ORN     d, b, R31; \
+	XOR	c, R31; \
+	ADD	R31, a; \
+	ROTLW	$shift, a; \
+	ADD	b, a;
+
+
+TEXT ·block(SB),NOSPLIT,$0-32
+	MOVD	dig+0(FP), R10
+	MOVD	p+8(FP), R6
+	MOVD	p_len+16(FP), R5
+
+	// We assume p_len >= 64
+	SRD 	$6, R5
+	MOVD	R5, CTR
+
+	MOVWZ	0(R10), R22
+	MOVWZ	4(R10), R3
+	MOVWZ	8(R10), R4
+	MOVWZ	12(R10), R5
+
+loop:
+	MOVD	R22, R14
+	MOVD	R3, R15
+	MOVD	R4, R16
+	MOVD	R5, R17
+
+	ENDIAN_MOVE( 0,R6,M00,M15)
+	ENDIAN_MOVE( 4,R6,M01,M15)
+	ENDIAN_MOVE( 8,R6,M02,M15)
+	ENDIAN_MOVE(12,R6,M03,M15)
+
+	ROUND1(R22,R3,R4,R5,M00,0xd76aa478, 7);
+	ROUND1(R5,R22,R3,R4,M01,0xe8c7b756,12);
+	ROUND1(R4,R5,R22,R3,M02,0x242070db,17);
+	ROUND1(R3,R4,R5,R22,M03,0xc1bdceee,22);
+
+	ENDIAN_MOVE(16,R6,M04,M15)
+	ENDIAN_MOVE(20,R6,M05,M15)
+	ENDIAN_MOVE(24,R6,M06,M15)
+	ENDIAN_MOVE(28,R6,M07,M15)
+
+	ROUND1(R22,R3,R4,R5,M04,0xf57c0faf, 7);
+	ROUND1(R5,R22,R3,R4,M05,0x4787c62a,12);
+	ROUND1(R4,R5,R22,R3,M06,0xa8304613,17);
+	ROUND1(R3,R4,R5,R22,M07,0xfd469501,22);
+
+	ENDIAN_MOVE(32,R6,M08,M15)
+	ENDIAN_MOVE(36,R6,M09,M15)
+	ENDIAN_MOVE(40,R6,M10,M15)
+	ENDIAN_MOVE(44,R6,M11,M15)
+
+	ROUND1(R22,R3,R4,R5,M08,0x698098d8, 7);
+	ROUND1(R5,R22,R3,R4,M09,0x8b44f7af,12);
+	ROUND1(R4,R5,R22,R3,M10,0xffff5bb1,17);
+	ROUND1(R3,R4,R5,R22,M11,0x895cd7be,22);
+
+	ENDIAN_MOVE(48,R6,M12,M15)
+	ENDIAN_MOVE(52,R6,M13,M15)
+	ENDIAN_MOVE(56,R6,M14,M15)
+	ENDIAN_MOVE(60,R6,M15,M15)
+
+	ROUND1(R22,R3,R4,R5,M12,0x6b901122, 7);
+	ROUND1(R5,R22,R3,R4,M13,0xfd987193,12);
+	ROUND1(R4,R5,R22,R3,M14,0xa679438e,17);
+	ROUND1(R3,R4,R5,R22,M15,0x49b40821,22);
+
+	ROUND2(R22,R3,R4,R5,M01,0xf61e2562, 5);
+	ROUND2(R5,R22,R3,R4,M06,0xc040b340, 9);
+	ROUND2(R4,R5,R22,R3,M11,0x265e5a51,14);
+	ROUND2(R3,R4,R5,R22,M00,0xe9b6c7aa,20);
+	ROUND2(R22,R3,R4,R5,M05,0xd62f105d, 5);
+	ROUND2(R5,R22,R3,R4,M10, 0x2441453, 9);
+	ROUND2(R4,R5,R22,R3,M15,0xd8a1e681,14);
+	ROUND2(R3,R4,R5,R22,M04,0xe7d3fbc8,20);
+	ROUND2(R22,R3,R4,R5,M09,0x21e1cde6, 5);
+	ROUND2(R5,R22,R3,R4,M14,0xc33707d6, 9);
+	ROUND2(R4,R5,R22,R3,M03,0xf4d50d87,14);
+	ROUND2(R3,R4,R5,R22,M08,0x455a14ed,20);
+	ROUND2(R22,R3,R4,R5,M13,0xa9e3e905, 5);
+	ROUND2(R5,R22,R3,R4,M02,0xfcefa3f8, 9);
+	ROUND2(R4,R5,R22,R3,M07,0x676f02d9,14);
+	ROUND2(R3,R4,R5,R22,M12,0x8d2a4c8a,20);
+
+	ROUND3(R22,R3,R4,R5,M05,0xfffa3942, 4);
+	ROUND3(R5,R22,R3,R4,M08,0x8771f681,11);
+	ROUND3(R4,R5,R22,R3,M11,0x6d9d6122,16);
+	ROUND3(R3,R4,R5,R22,M14,0xfde5380c,23);
+	ROUND3(R22,R3,R4,R5,M01,0xa4beea44, 4);
+	ROUND3(R5,R22,R3,R4,M04,0x4bdecfa9,11);
+	ROUND3(R4,R5,R22,R3,M07,0xf6bb4b60,16);
+	ROUND3(R3,R4,R5,R22,M10,0xbebfbc70,23);
+	ROUND3(R22,R3,R4,R5,M13,0x289b7ec6, 4);
+	ROUND3(R5,R22,R3,R4,M00,0xeaa127fa,11);
+	ROUND3(R4,R5,R22,R3,M03,0xd4ef3085,16);
+	ROUND3(R3,R4,R5,R22,M06, 0x4881d05,23);
+	ROUND3(R22,R3,R4,R5,M09,0xd9d4d039, 4);
+	ROUND3(R5,R22,R3,R4,M12,0xe6db99e5,11);
+	ROUND3(R4,R5,R22,R3,M15,0x1fa27cf8,16);
+	ROUND3(R3,R4,R5,R22,M02,0xc4ac5665,23);
+
+	ROUND4(R22,R3,R4,R5,M00,0xf4292244, 6);
+	ROUND4(R5,R22,R3,R4,M07,0x432aff97,10);
+	ROUND4(R4,R5,R22,R3,M14,0xab9423a7,15);
+	ROUND4(R3,R4,R5,R22,M05,0xfc93a039,21);
+	ROUND4(R22,R3,R4,R5,M12,0x655b59c3, 6);
+	ROUND4(R5,R22,R3,R4,M03,0x8f0ccc92,10);
+	ROUND4(R4,R5,R22,R3,M10,0xffeff47d,15);
+	ROUND4(R3,R4,R5,R22,M01,0x85845dd1,21);
+	ROUND4(R22,R3,R4,R5,M08,0x6fa87e4f, 6);
+	ROUND4(R5,R22,R3,R4,M15,0xfe2ce6e0,10);
+	ROUND4(R4,R5,R22,R3,M06,0xa3014314,15);
+	ROUND4(R3,R4,R5,R22,M13,0x4e0811a1,21);
+	ROUND4(R22,R3,R4,R5,M04,0xf7537e82, 6);
+	ROUND4(R5,R22,R3,R4,M11,0xbd3af235,10);
+	ROUND4(R4,R5,R22,R3,M02,0x2ad7d2bb,15);
+	ROUND4(R3,R4,R5,R22,M09,0xeb86d391,21);
 
 	ADD	R14, R22
 	ADD	R15, R3
 	ADD	R16, R4
 	ADD	R17, R5
 	ADD	$64, R6
-	CMP	R6, R7
-	BLT	loop
+	BC	16, 0, loop // bdnz
 
 end:
 	MOVD	dig+0(FP), R10
@@ -198,4 +208,5 @@ end:
 	MOVWZ	R3, 4(R10)
 	MOVWZ	R4, 8(R10)
 	MOVWZ	R5, 12(R10)
+
 	RET
-- 
GitLab


From 7bfe32f39c59056c49f5776b104beaf09b010088 Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Tue, 9 Mar 2021 16:54:59 -0600
Subject: [PATCH 1081/2400] cmd/internal/obj: reorder ppc64 MOV* optab entries

These are always sorted and grouped during initialization of the
actual opcode -> optab map generation. Thus, their initial location
in optab is mostly aimed at readability. This cleanup is intends to
ease reviewing of future patches which simplify, combine, or remove
MOV* optab entries.

Change-Id: I87583ed34fab79e0f625880f419d499939e2a9e1
Reviewed-on: https://go-review.googlesource.com/c/go/+/300612
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/cmd/internal/obj/ppc64/asm9.go | 304 ++++++++++++++---------------
 1 file changed, 148 insertions(+), 156 deletions(-)

diff --git a/src/cmd/internal/obj/ppc64/asm9.go b/src/cmd/internal/obj/ppc64/asm9.go
index e979cabddf..799df09687 100644
--- a/src/cmd/internal/obj/ppc64/asm9.go
+++ b/src/cmd/internal/obj/ppc64/asm9.go
@@ -94,11 +94,6 @@ var optab = []Optab{
 	{as: obj.ATEXT, a1: C_ADDR, a6: C_TEXTSIZE, type_: 0, size: 0},
 	{as: obj.ATEXT, a1: C_ADDR, a3: C_LCON, a6: C_TEXTSIZE, type_: 0, size: 0},
 	/* move register */
-	{as: AMOVD, a1: C_REG, a6: C_REG, type_: 1, size: 4},
-	{as: AMOVB, a1: C_REG, a6: C_REG, type_: 12, size: 4},
-	{as: AMOVBZ, a1: C_REG, a6: C_REG, type_: 13, size: 4},
-	{as: AMOVW, a1: C_REG, a6: C_REG, type_: 12, size: 4},
-	{as: AMOVWZ, a1: C_REG, a6: C_REG, type_: 13, size: 4},
 	{as: AADD, a1: C_REG, a2: C_REG, a6: C_REG, type_: 2, size: 4},
 	{as: AADD, a1: C_REG, a6: C_REG, type_: 2, size: 4},
 	{as: AADD, a1: C_SCON, a2: C_REG, a6: C_REG, type_: 4, size: 4},
@@ -195,144 +190,177 @@ var optab = []Optab{
 	{as: AFADD, a1: C_FREG, a2: C_FREG, a6: C_FREG, type_: 2, size: 4},
 	{as: AFABS, a1: C_FREG, a6: C_FREG, type_: 33, size: 4},
 	{as: AFABS, a6: C_FREG, type_: 33, size: 4},
-	{as: AFMOVD, a1: C_FREG, a6: C_FREG, type_: 33, size: 4},
 	{as: AFMADD, a1: C_FREG, a2: C_FREG, a3: C_FREG, a6: C_FREG, type_: 34, size: 4},
 	{as: AFMUL, a1: C_FREG, a6: C_FREG, type_: 32, size: 4},
 	{as: AFMUL, a1: C_FREG, a2: C_FREG, a6: C_FREG, type_: 32, size: 4},
 
-	/* store, short offset */
-	{as: AMOVD, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
-	{as: AMOVW, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
-	{as: AMOVWZ, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
-	{as: AMOVBZ, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
-	{as: AMOVBZU, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
-	{as: AMOVB, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
 	{as: AMOVBU, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
-	{as: AMOVD, a1: C_REG, a6: C_SEXT, type_: 7, size: 4},
-	{as: AMOVW, a1: C_REG, a6: C_SEXT, type_: 7, size: 4},
-	{as: AMOVWZ, a1: C_REG, a6: C_SEXT, type_: 7, size: 4},
-	{as: AMOVBZ, a1: C_REG, a6: C_SEXT, type_: 7, size: 4},
-	{as: AMOVB, a1: C_REG, a6: C_SEXT, type_: 7, size: 4},
-	{as: AMOVD, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4},
-	{as: AMOVW, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4},
-	{as: AMOVWZ, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4},
-	{as: AMOVBZ, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4},
-	{as: AMOVB, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4},
-	{as: AMOVD, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
-	{as: AMOVW, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
-	{as: AMOVWZ, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
-	{as: AMOVBZ, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
-	{as: AMOVBZU, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
-	{as: AMOVB, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVBU, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
+	{as: AMOVBU, a1: C_SOREG, a6: C_REG, type_: 9, size: 8},
+	{as: AMOVBU, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 9, size: 8},
 
-	/* load, short offset */
-	{as: AMOVD, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4},
-	{as: AMOVW, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4},
-	{as: AMOVWZ, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4},
-	{as: AMOVBZ, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVBZU, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
+	{as: AMOVBZU, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
+	{as: AMOVBZU, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
 	{as: AMOVBZU, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4},
-	{as: AMOVB, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 9, size: 8},
-	{as: AMOVBU, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 9, size: 8},
-	{as: AMOVD, a1: C_SEXT, a6: C_REG, type_: 8, size: 4},
-	{as: AMOVW, a1: C_SEXT, a6: C_REG, type_: 8, size: 4},
-	{as: AMOVWZ, a1: C_SEXT, a6: C_REG, type_: 8, size: 4},
-	{as: AMOVBZ, a1: C_SEXT, a6: C_REG, type_: 8, size: 4},
-	{as: AMOVB, a1: C_SEXT, a6: C_REG, type_: 9, size: 8},
-	{as: AMOVD, a1: C_SAUTO, a6: C_REG, type_: 8, size: 4},
-	{as: AMOVW, a1: C_SAUTO, a6: C_REG, type_: 8, size: 4},
-	{as: AMOVWZ, a1: C_SAUTO, a6: C_REG, type_: 8, size: 4},
-	{as: AMOVBZ, a1: C_SAUTO, a6: C_REG, type_: 8, size: 4},
+
+	{as: AMOVHBR, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 44, size: 4},
+	{as: AMOVHBR, a1: C_REG, a6: C_ZOREG, type_: 44, size: 4},
+	{as: AMOVHBR, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 45, size: 4},
+	{as: AMOVHBR, a1: C_ZOREG, a6: C_REG, type_: 45, size: 4},
+
+	{as: AMOVB, a1: C_ADDR, a6: C_REG, type_: 76, size: 12},
+	{as: AMOVB, a1: C_LAUTO, a6: C_REG, type_: 37, size: 12},
+	{as: AMOVB, a1: C_LEXT, a6: C_REG, type_: 37, size: 12},
+	{as: AMOVB, a1: C_LOREG, a6: C_REG, type_: 37, size: 12},
+	{as: AMOVB, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
+	{as: AMOVB, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
+	{as: AMOVB, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8},
+	{as: AMOVB, a1: C_REG, a6: C_LEXT, type_: 35, size: 8},
+	{as: AMOVB, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
+	{as: AMOVB, a1: C_REG, a6: C_REG, type_: 12, size: 4},
+	{as: AMOVB, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4},
+	{as: AMOVB, a1: C_REG, a6: C_SEXT, type_: 7, size: 4},
+	{as: AMOVB, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVB, a1: C_SAUTO, a6: C_REG, type_: 9, size: 8},
-	{as: AMOVD, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
-	{as: AMOVW, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
-	{as: AMOVWZ, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
-	{as: AMOVBZ, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
-	{as: AMOVBZU, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVB, a1: C_SEXT, a6: C_REG, type_: 9, size: 8},
 	{as: AMOVB, a1: C_SOREG, a6: C_REG, type_: 9, size: 8},
-	{as: AMOVBU, a1: C_SOREG, a6: C_REG, type_: 9, size: 8},
+	{as: AMOVB, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 9, size: 8},
 
-	/* store, long offset */
-	{as: AMOVD, a1: C_REG, a6: C_LEXT, type_: 35, size: 8},
-	{as: AMOVW, a1: C_REG, a6: C_LEXT, type_: 35, size: 8},
-	{as: AMOVWZ, a1: C_REG, a6: C_LEXT, type_: 35, size: 8},
-	{as: AMOVBZ, a1: C_REG, a6: C_LEXT, type_: 35, size: 8},
-	{as: AMOVB, a1: C_REG, a6: C_LEXT, type_: 35, size: 8},
-	{as: AMOVD, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8},
-	{as: AMOVW, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8},
-	{as: AMOVWZ, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8},
+	{as: AMOVBZ, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
+	{as: AMOVBZ, a1: C_LAUTO, a6: C_REG, type_: 36, size: 8},
+	{as: AMOVBZ, a1: C_LEXT, a6: C_REG, type_: 36, size: 8},
+	{as: AMOVBZ, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
+	{as: AMOVBZ, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
+	{as: AMOVBZ, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 	{as: AMOVBZ, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8},
-	{as: AMOVB, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8},
-	{as: AMOVD, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
-	{as: AMOVW, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
-	{as: AMOVWZ, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
+	{as: AMOVBZ, a1: C_REG, a6: C_LEXT, type_: 35, size: 8},
 	{as: AMOVBZ, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
-	{as: AMOVB, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
-	{as: AMOVD, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
-	{as: AMOVW, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
-	{as: AMOVWZ, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
-	{as: AMOVBZ, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
-	{as: AMOVB, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
+	{as: AMOVBZ, a1: C_REG, a6: C_REG, type_: 13, size: 4},
+	{as: AMOVBZ, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4},
+	{as: AMOVBZ, a1: C_REG, a6: C_SEXT, type_: 7, size: 4},
+	{as: AMOVBZ, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
+	{as: AMOVBZ, a1: C_SAUTO, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVBZ, a1: C_SEXT, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVBZ, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVBZ, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4},
 
-	/* load, long offset */
-	{as: AMOVD, a1: C_LEXT, a6: C_REG, type_: 36, size: 8},
-	{as: AMOVW, a1: C_LEXT, a6: C_REG, type_: 36, size: 8},
-	{as: AMOVWZ, a1: C_LEXT, a6: C_REG, type_: 36, size: 8},
-	{as: AMOVBZ, a1: C_LEXT, a6: C_REG, type_: 36, size: 8},
-	{as: AMOVB, a1: C_LEXT, a6: C_REG, type_: 37, size: 12},
+	{as: AMOVD, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVD, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
+	{as: AMOVD, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVD, a1: C_CTR, a6: C_REG, type_: 66, size: 4},
+	{as: AMOVD, a1: C_GOTADDR, a6: C_REG, type_: 81, size: 8},
+	{as: AMOVD, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
 	{as: AMOVD, a1: C_LAUTO, a6: C_REG, type_: 36, size: 8},
-	{as: AMOVW, a1: C_LAUTO, a6: C_REG, type_: 36, size: 8},
-	{as: AMOVWZ, a1: C_LAUTO, a6: C_REG, type_: 36, size: 8},
-	{as: AMOVBZ, a1: C_LAUTO, a6: C_REG, type_: 36, size: 8},
-	{as: AMOVB, a1: C_LAUTO, a6: C_REG, type_: 37, size: 12},
+	{as: AMOVD, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
+	{as: AMOVD, a1: C_LECON, a6: C_REG, type_: 26, size: 8},
+	{as: AMOVD, a1: C_LEXT, a6: C_REG, type_: 36, size: 8},
 	{as: AMOVD, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
-	{as: AMOVW, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
-	{as: AMOVWZ, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
-	{as: AMOVBZ, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
-	{as: AMOVB, a1: C_LOREG, a6: C_REG, type_: 37, size: 12},
-	{as: AMOVD, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
-	{as: AMOVW, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
-	{as: AMOVWZ, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
-	{as: AMOVBZ, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
-	{as: AMOVB, a1: C_ADDR, a6: C_REG, type_: 76, size: 12},
-
-	{as: AMOVD, a1: C_TLS_LE, a6: C_REG, type_: 79, size: 4},
+	{as: AMOVD, a1: C_LR, a6: C_REG, type_: 66, size: 4},
+	{as: AMOVD, a1: C_MSR, a6: C_REG, type_: 54, size: 4}, /* mfmsr */
+	{as: AMOVD, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
+	{as: AMOVD, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
+	{as: AMOVD, a1: C_REG, a6: C_CTR, type_: 66, size: 4},
+	{as: AMOVD, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8},
+	{as: AMOVD, a1: C_REG, a6: C_LEXT, type_: 35, size: 8},
+	{as: AMOVD, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
+	{as: AMOVD, a1: C_REG, a6: C_LR, type_: 66, size: 4},
+	{as: AMOVD, a1: C_REG, a6: C_MSR, type_: 54, size: 4}, /* mtmsrd */
+	{as: AMOVD, a1: C_REG, a6: C_REG, type_: 1, size: 4},
+	{as: AMOVD, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4},
+	{as: AMOVD, a1: C_REG, a6: C_SEXT, type_: 7, size: 4},
+	{as: AMOVD, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
+	{as: AMOVD, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
+	{as: AMOVD, a1: C_REG, a6: C_XER, type_: 66, size: 4},
+	{as: AMOVD, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVD, a1: C_SAUTO, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVD, a1: C_SECON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVD, a1: C_SEXT, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVD, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVD, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
 	{as: AMOVD, a1: C_TLS_IE, a6: C_REG, type_: 80, size: 8},
-
-	{as: AMOVD, a1: C_GOTADDR, a6: C_REG, type_: 81, size: 8},
+	{as: AMOVD, a1: C_TLS_LE, a6: C_REG, type_: 79, size: 4},
 	{as: AMOVD, a1: C_TOCADDR, a6: C_REG, type_: 95, size: 8},
+	{as: AMOVD, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVD, a1: C_XER, a6: C_REG, type_: 66, size: 4},
+	{as: AMOVD, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4},
 
-	/* load constant */
-	{as: AMOVD, a1: C_SECON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVD, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVD, a1: C_LECON, a6: C_REG, type_: 26, size: 8},
-	{as: AMOVD, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
-	{as: AMOVD, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVD, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVW, a1: C_SECON, a6: C_REG, type_: 3, size: 4}, /* TO DO: check */
-	{as: AMOVW, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVW, a1: C_LECON, a6: C_REG, type_: 26, size: 8},
-	{as: AMOVW, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
 	{as: AMOVW, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVW, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
 	{as: AMOVW, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVWZ, a1: C_SECON, a6: C_REG, type_: 3, size: 4}, /* TO DO: check */
-	{as: AMOVWZ, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVWZ, a1: C_LECON, a6: C_REG, type_: 26, size: 8},
-	{as: AMOVWZ, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
+	{as: AMOVW, a1: C_CREG, a6: C_REG, type_: 68, size: 4},
+	{as: AMOVW, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
+	{as: AMOVW, a1: C_LAUTO, a6: C_REG, type_: 36, size: 8},
+	{as: AMOVW, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
+	{as: AMOVW, a1: C_LECON, a6: C_REG, type_: 26, size: 8},
+	{as: AMOVW, a1: C_LEXT, a6: C_REG, type_: 36, size: 8},
+	{as: AMOVW, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
+	{as: AMOVW, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
+	{as: AMOVW, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
+	{as: AMOVW, a1: C_REG, a6: C_CREG, type_: 69, size: 4},
+	{as: AMOVW, a1: C_REG, a6: C_CTR, type_: 66, size: 4},
+	{as: AMOVW, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8},
+	{as: AMOVW, a1: C_REG, a6: C_LEXT, type_: 35, size: 8},
+	{as: AMOVW, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
+	{as: AMOVW, a1: C_REG, a6: C_REG, type_: 12, size: 4},
+	{as: AMOVW, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4},
+	{as: AMOVW, a1: C_REG, a6: C_SEXT, type_: 7, size: 4},
+	{as: AMOVW, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
+	{as: AMOVW, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
+	{as: AMOVW, a1: C_REG, a6: C_XER, type_: 66, size: 4},
+	{as: AMOVW, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVW, a1: C_SAUTO, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVW, a1: C_SECON, a6: C_REG, type_: 3, size: 4}, /* TO DO: check */
+	{as: AMOVW, a1: C_SEXT, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVW, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVW, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
+	{as: AMOVW, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVW, a1: C_XER, a6: C_REG, type_: 66, size: 4},
+	{as: AMOVW, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4},
+
 	{as: AMOVWZ, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVWZ, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
 	{as: AMOVWZ, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4},
-
-	/* load unsigned/long constants (TO DO: check) */
-	{as: AMOVD, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVD, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
-	{as: AMOVW, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVW, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
-	{as: AMOVWZ, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVWZ, a1: C_CREG, a6: C_REG, type_: 68, size: 4},
+	{as: AMOVWZ, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
+	{as: AMOVWZ, a1: C_LAUTO, a6: C_REG, type_: 36, size: 8},
 	{as: AMOVWZ, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
-	{as: AMOVHBR, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 45, size: 4},
-	{as: AMOVHBR, a1: C_ZOREG, a6: C_REG, type_: 45, size: 4},
-	{as: AMOVHBR, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 44, size: 4},
-	{as: AMOVHBR, a1: C_REG, a6: C_ZOREG, type_: 44, size: 4},
+	{as: AMOVWZ, a1: C_LECON, a6: C_REG, type_: 26, size: 8},
+	{as: AMOVWZ, a1: C_LEXT, a6: C_REG, type_: 36, size: 8},
+	{as: AMOVWZ, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
+	{as: AMOVWZ, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
+	{as: AMOVWZ, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
+	{as: AMOVWZ, a1: C_REG, a6: C_CREG, type_: 69, size: 4},
+	{as: AMOVWZ, a1: C_REG, a6: C_CTR, type_: 66, size: 4},
+	{as: AMOVWZ, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8},
+	{as: AMOVWZ, a1: C_REG, a6: C_LEXT, type_: 35, size: 8},
+	{as: AMOVWZ, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
+	{as: AMOVWZ, a1: C_REG, a6: C_MSR, type_: 54, size: 4}, /* mtmsr */
+	{as: AMOVWZ, a1: C_REG, a6: C_REG, type_: 13, size: 4},
+	{as: AMOVWZ, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4},
+	{as: AMOVWZ, a1: C_REG, a6: C_SEXT, type_: 7, size: 4},
+	{as: AMOVWZ, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
+	{as: AMOVWZ, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
+	{as: AMOVWZ, a1: C_REG, a6: C_XER, type_: 66, size: 4},
+	{as: AMOVWZ, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVWZ, a1: C_SAUTO, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVWZ, a1: C_SECON, a6: C_REG, type_: 3, size: 4}, /* TO DO: check */
+	{as: AMOVWZ, a1: C_SEXT, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVWZ, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
+	{as: AMOVWZ, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
+	{as: AMOVWZ, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVWZ, a1: C_XER, a6: C_REG, type_: 66, size: 4},
+	{as: AMOVWZ, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4},
+
+	{as: AMOVFL, a1: C_CREG, a6: C_CREG, type_: 67, size: 4},
+	{as: AMOVFL, a1: C_FPSCR, a6: C_CREG, type_: 73, size: 4},
+	{as: AMOVFL, a1: C_FPSCR, a6: C_FREG, type_: 53, size: 4},
+	{as: AMOVFL, a1: C_FREG, a3: C_LCON, a6: C_FPSCR, type_: 64, size: 4},
+	{as: AMOVFL, a1: C_FREG, a6: C_FPSCR, type_: 64, size: 4},
+	{as: AMOVFL, a1: C_LCON, a6: C_FPSCR, type_: 65, size: 4},
+	{as: AMOVFL, a1: C_REG, a6: C_CREG, type_: 69, size: 4},
+	{as: AMOVFL, a1: C_REG, a6: C_LCON, type_: 69, size: 4},
+
 	{as: ASYSCALL, type_: 5, size: 4},
 	{as: ASYSCALL, a1: C_REG, type_: 77, size: 12},
 	{as: ASYSCALL, a1: C_SCON, type_: 77, size: 12},
@@ -352,6 +380,7 @@ var optab = []Optab{
 	{as: ABC, a1: C_SCON, a2: C_REG, a6: C_LR, type_: 18, size: 4},
 	{as: ABC, a1: C_SCON, a2: C_REG, a6: C_CTR, type_: 18, size: 4},
 	{as: ABC, a6: C_ZOREG, type_: 15, size: 8},
+	{as: AFMOVD, a1: C_FREG, a6: C_FREG, type_: 33, size: 4},
 	{as: AFMOVD, a1: C_SEXT, a6: C_FREG, type_: 8, size: 4},
 	{as: AFMOVD, a1: C_SAUTO, a6: C_FREG, type_: 8, size: 4},
 	{as: AFMOVD, a1: C_SOREG, a6: C_FREG, type_: 8, size: 4},
@@ -392,14 +421,6 @@ var optab = []Optab{
 	{as: AREMD, a1: C_REG, a6: C_REG, type_: 51, size: 12},
 	{as: AREMD, a1: C_REG, a2: C_REG, a6: C_REG, type_: 51, size: 12},
 	{as: AMTFSB0, a1: C_SCON, type_: 52, size: 4},
-	{as: AMOVFL, a1: C_FPSCR, a6: C_FREG, type_: 53, size: 4},
-	{as: AMOVFL, a1: C_FREG, a6: C_FPSCR, type_: 64, size: 4},
-	{as: AMOVFL, a1: C_FREG, a3: C_LCON, a6: C_FPSCR, type_: 64, size: 4},
-	{as: AMOVFL, a1: C_LCON, a6: C_FPSCR, type_: 65, size: 4},
-	{as: AMOVD, a1: C_MSR, a6: C_REG, type_: 54, size: 4},  /* mfmsr */
-	{as: AMOVD, a1: C_REG, a6: C_MSR, type_: 54, size: 4},  /* mtmsrd */
-	{as: AMOVWZ, a1: C_REG, a6: C_MSR, type_: 54, size: 4}, /* mtmsr */
-
 	/* Other ISA 2.05+ instructions */
 	{as: APOPCNTD, a1: C_REG, a6: C_REG, type_: 93, size: 4},            /* population count, x-form */
 	{as: ACMPB, a1: C_REG, a2: C_REG, a6: C_REG, type_: 92, size: 4},    /* compare byte, x-form */
@@ -562,35 +583,6 @@ var optab = []Optab{
 	/* VSX vector integer-FP conversion */
 	{as: AXVCVSXDDP, a1: C_VSREG, a6: C_VSREG, type_: 89, size: 4}, /* vsx vector integer-fp conversion, xx2-form */
 
-	/* 64-bit special registers */
-	{as: AMOVD, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
-	{as: AMOVD, a1: C_REG, a6: C_LR, type_: 66, size: 4},
-	{as: AMOVD, a1: C_REG, a6: C_CTR, type_: 66, size: 4},
-	{as: AMOVD, a1: C_REG, a6: C_XER, type_: 66, size: 4},
-	{as: AMOVD, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
-	{as: AMOVD, a1: C_LR, a6: C_REG, type_: 66, size: 4},
-	{as: AMOVD, a1: C_CTR, a6: C_REG, type_: 66, size: 4},
-	{as: AMOVD, a1: C_XER, a6: C_REG, type_: 66, size: 4},
-
-	/* 32-bit special registers (gloss over sign-extension or not?) */
-	{as: AMOVW, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
-	{as: AMOVW, a1: C_REG, a6: C_CTR, type_: 66, size: 4},
-	{as: AMOVW, a1: C_REG, a6: C_XER, type_: 66, size: 4},
-	{as: AMOVW, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
-	{as: AMOVW, a1: C_XER, a6: C_REG, type_: 66, size: 4},
-	{as: AMOVWZ, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
-	{as: AMOVWZ, a1: C_REG, a6: C_CTR, type_: 66, size: 4},
-	{as: AMOVWZ, a1: C_REG, a6: C_XER, type_: 66, size: 4},
-	{as: AMOVWZ, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
-	{as: AMOVWZ, a1: C_XER, a6: C_REG, type_: 66, size: 4},
-	{as: AMOVFL, a1: C_FPSCR, a6: C_CREG, type_: 73, size: 4},
-	{as: AMOVFL, a1: C_CREG, a6: C_CREG, type_: 67, size: 4},
-	{as: AMOVW, a1: C_CREG, a6: C_REG, type_: 68, size: 4},
-	{as: AMOVWZ, a1: C_CREG, a6: C_REG, type_: 68, size: 4},
-	{as: AMOVFL, a1: C_REG, a6: C_LCON, type_: 69, size: 4},
-	{as: AMOVFL, a1: C_REG, a6: C_CREG, type_: 69, size: 4},
-	{as: AMOVW, a1: C_REG, a6: C_CREG, type_: 69, size: 4},
-	{as: AMOVWZ, a1: C_REG, a6: C_CREG, type_: 69, size: 4},
 	{as: ACMP, a1: C_REG, a6: C_REG, type_: 70, size: 4},
 	{as: ACMP, a1: C_REG, a2: C_REG, a6: C_REG, type_: 70, size: 4},
 	{as: ACMP, a1: C_REG, a6: C_ADDCON, type_: 71, size: 4},
-- 
GitLab


From 0f4bb9627ebc27d4e669e41d7f58396e063abb70 Mon Sep 17 00:00:00 2001
From: Ethan Hur <ethan0311@gmail.com>
Date: Sun, 14 Mar 2021 13:43:26 +0000
Subject: [PATCH 1082/2400] cmd/compile: fix outdated comment

variable xtop has removed and refactored after go 1.16, but there are comments referring xtop.

It may mislead new contributors to be confused.

Change-Id: Id79c747d8daef14049b29e70a4ecd34054a28a5e
GitHub-Last-Rev: 94b55208862fdc9fa0de39aacf2c9ef9987cef56
GitHub-Pull-Request: golang/go#44995
Reviewed-on: https://go-review.googlesource.com/c/go/+/301629
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Trust: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/typecheck/func.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index 367df8e9f4..86058a0c73 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -308,7 +308,7 @@ func tcClosure(clo *ir.ClosureExpr, top int) {
 		return
 	}
 
-	// Don't give a name and add to xtop if we are typechecking an inlined
+	// Don't give a name and add to Target.Decls if we are typechecking an inlined
 	// body in ImportedBody(), since we only want to create the named function
 	// when the closure is actually inlined (and then we force a typecheck
 	// explicitly in (*inlsubst).node()).
@@ -354,7 +354,7 @@ func tcClosure(clo *ir.ClosureExpr, top int) {
 		ir.Dump(s, fn)
 	}
 	if !inTypeCheckInl {
-		// Add function to xtop once only when we give it a name
+		// Add function to Target.Decls once only when we give it a name
 		Target.Decls = append(Target.Decls, fn)
 	}
 }
-- 
GitLab


From 8ac6544564be04ed1c0bbf7831ad0f8ed1f067ed Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Mon, 15 Mar 2021 10:03:30 -0700
Subject: [PATCH 1083/2400] bytes: correct tense in comment

Undo incorrect change accidentally made in CL 299109.

Change-Id: Iba29827d0fbd3637c311cebc50c2f4ea437fc582
Reviewed-on: https://go-review.googlesource.com/c/go/+/301830
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/bytes/buffer.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/bytes/buffer.go b/src/bytes/buffer.go
index 01764c694e..549b077708 100644
--- a/src/bytes/buffer.go
+++ b/src/bytes/buffer.go
@@ -387,7 +387,7 @@ var errUnreadByte = errors.New("bytes.Buffer: UnreadByte: previous operation was
 
 // UnreadByte unreads the last byte returned by the most recent successful
 // read operation that read at least one byte. If a write has happened since
-// the last read, if the last read returned an error, or if the read reads zero
+// the last read, if the last read returned an error, or if the read read zero
 // bytes, UnreadByte returns an error.
 func (b *Buffer) UnreadByte() error {
 	if b.lastRead == opInvalid {
-- 
GitLab


From c4190fc34dbfe8c7859a91b07ed31a33633d08df Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Fri, 12 Mar 2021 18:45:52 -0500
Subject: [PATCH 1084/2400] cmd/compile: remove ARMv5 special case in register
 allocator

The register allocator has a special case that doesn't allocate
LR on ARMv5. This was necessary when softfloat expansion was done
by the assembler. Now softfloat calls are inserted by SSA, so it
works as normal. Remove this special case.

Change-Id: I5502f07597f4d4b675dc16b6b0d7cb47e1e8974b
Reviewed-on: https://go-review.googlesource.com/c/go/+/301792
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/ssa/regalloc.go | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go
index 15f6412a85..c104a36888 100644
--- a/src/cmd/compile/internal/ssa/regalloc.go
+++ b/src/cmd/compile/internal/ssa/regalloc.go
@@ -605,12 +605,6 @@ func (s *regAllocState) init(f *Func) {
 			// Leaf functions don't save/restore the link register.
 			s.allocatable &^= 1 << uint(s.f.Config.LinkReg)
 		}
-		if s.f.Config.arch == "arm" && objabi.GOARM == 5 {
-			// On ARMv5 we insert softfloat calls at each FP instruction.
-			// This clobbers LR almost everywhere. Disable allocating LR
-			// on ARMv5.
-			s.allocatable &^= 1 << uint(s.f.Config.LinkReg)
-		}
 	}
 	if s.f.Config.ctxt.Flag_dynlink {
 		switch s.f.Config.arch {
-- 
GitLab


From a8d9fb2fcd1fc11b41651e0ea608b3a3e90755b7 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Mon, 15 Mar 2021 17:54:35 +0100
Subject: [PATCH 1085/2400] cmd/internal/moddeps: fix typo in
 TestAllDependencies log messages

s/dependecies/dependencies/

Change-Id: I454668a36192e345965173d76be12cbd5917ea34
Reviewed-on: https://go-review.googlesource.com/c/go/+/301849
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 src/cmd/internal/moddeps/moddeps_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/internal/moddeps/moddeps_test.go b/src/cmd/internal/moddeps/moddeps_test.go
index cba401c896..78c291e203 100644
--- a/src/cmd/internal/moddeps/moddeps_test.go
+++ b/src/cmd/internal/moddeps/moddeps_test.go
@@ -61,7 +61,7 @@ func TestAllDependencies(t *testing.T) {
 				_, err := cmd.Output()
 				if err != nil {
 					t.Errorf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, cmd.Stderr)
-					t.Logf("(Run 'go mod vendor' in %s to ensure that dependecies have been vendored.)", m.Dir)
+					t.Logf("(Run 'go mod vendor' in %s to ensure that dependencies have been vendored.)", m.Dir)
 				}
 				return
 			}
@@ -179,7 +179,7 @@ func TestAllDependencies(t *testing.T) {
 			r.run(t, goBinCopy, "generate", `-run=^//go:generate bundle `, pkgs) // See issue 41409.
 			advice := "$ cd " + m.Dir + "\n" +
 				"$ go mod tidy                               # to remove extraneous dependencies\n" +
-				"$ go mod vendor                             # to vendor dependecies\n" +
+				"$ go mod vendor                             # to vendor dependencies\n" +
 				"$ go generate -run=bundle " + pkgs + "               # to regenerate bundled packages\n"
 			if m.Path == "std" {
 				r.run(t, goBinCopy, "generate", "syscall", "internal/syscall/...") // See issue 43440.
-- 
GitLab


From 2d4042d4ab3a2021819dce91eb228daf8fa5e557 Mon Sep 17 00:00:00 2001
From: Emmanuel T Odeke <emmanuel@orijtech.com>
Date: Fri, 26 Feb 2021 02:27:24 -0800
Subject: [PATCH 1086/2400] all: update golang.org/x/* dependencies

Updates src/ and src/cmd/* dependencies, using

    go mod vendor

as well as

    updatestd -branch=master -goroot=$GOROOT

This change was ran in anticipation of bringing in x/net/http2 CL 237957.

For #32112.
For #36905.

Change-Id: If8cefc348463b6d82d85020b57db411213720ef8
Reviewed-on: https://go-review.googlesource.com/c/go/+/296789
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Trust: Dmitri Shuralyov <dmitshur@golang.org>
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Alexander Rakoczy <alex@golang.org>
---
 src/cmd/go.mod                                |    13 +-
 src/cmd/go.sum                                |    25 +-
 .../pprof/internal/binutils/addr2liner.go     |    24 +-
 .../internal/binutils/addr2liner_llvm.go      |    36 +-
 .../pprof/internal/binutils/addr2liner_nm.go  |    58 +-
 .../pprof/internal/binutils/binutils.go       |    65 +-
 .../google/pprof/internal/binutils/disasm.go  |     3 +
 .../google/pprof/internal/driver/driver.go    |     6 +-
 .../google/pprof/internal/driver/webhtml.go   |     1 +
 .../google/pprof/internal/elfexec/elfexec.go  |    81 +
 .../google/pprof/internal/graph/dotgraph.go   |     4 +-
 .../pprof/internal/measurement/measurement.go |   240 +-
 .../google/pprof/internal/report/source.go    |   727 +-
 .../pprof/internal/report/source_html.go      |     3 +-
 .../github.com/google/pprof/profile/merge.go  |     5 +-
 .../google/pprof/profile/profile.go           |    18 +-
 .../golang.org/x/arch/arm64/arm64asm/inst.go  |    10 +-
 .../x/arch/arm64/arm64asm/plan9x.go           |    14 +-
 .../golang.org/x/arch/ppc64/ppc64asm/gnu.go   |   181 +-
 .../x/arch/ppc64/ppc64asm/tables.go           |    13 +-
 .../golang.org/x/arch/x86/x86asm/tables.go    | 16353 ++++++++--------
 .../golang.org/x/crypto/ed25519/ed25519.go    |     1 +
 .../x/crypto/ed25519/ed25519_go113.go         |     1 +
 .../x/crypto/ssh/terminal/terminal.go         |   987 +-
 src/cmd/vendor/golang.org/x/sys/plan9/asm.s   |     8 +
 .../golang.org/x/sys/plan9/asm_plan9_386.s    |    30 +
 .../golang.org/x/sys/plan9/asm_plan9_amd64.s  |    30 +
 .../golang.org/x/sys/plan9/asm_plan9_arm.s    |    25 +
 .../golang.org/x/sys/plan9/const_plan9.go     |    70 +
 .../golang.org/x/sys/plan9/dir_plan9.go       |   212 +
 .../golang.org/x/sys/plan9/env_plan9.go       |    31 +
 .../golang.org/x/sys/plan9/errors_plan9.go    |    50 +
 .../vendor/golang.org/x/sys/plan9/mkall.sh    |   150 +
 .../vendor/golang.org/x/sys/plan9/mkerrors.sh |   246 +
 .../golang.org/x/sys/plan9/mksysnum_plan9.sh  |    23 +
 .../golang.org/x/sys/plan9/pwd_go15_plan9.go  |    21 +
 .../golang.org/x/sys/plan9/pwd_plan9.go       |    23 +
 src/cmd/vendor/golang.org/x/sys/plan9/race.go |    30 +
 .../vendor/golang.org/x/sys/plan9/race0.go    |    25 +
 src/cmd/vendor/golang.org/x/sys/plan9/str.go  |    22 +
 .../vendor/golang.org/x/sys/plan9/syscall.go  |   116 +
 .../golang.org/x/sys/plan9/syscall_plan9.go   |   349 +
 .../x/sys/plan9/zsyscall_plan9_386.go         |   284 +
 .../x/sys/plan9/zsyscall_plan9_amd64.go       |   284 +
 .../x/sys/plan9/zsyscall_plan9_arm.go         |   284 +
 .../golang.org/x/sys/plan9/zsysnum_plan9.go   |    49 +
 .../vendor/golang.org/x/sys/unix/aliases.go   |     3 +-
 .../golang.org/x/sys/unix/asm_zos_s390x.s     |   426 +
 .../golang.org/x/sys/unix/cap_freebsd.go      |     1 +
 .../vendor/golang.org/x/sys/unix/constants.go |     3 +-
 .../golang.org/x/sys/unix/dev_aix_ppc.go      |     4 +-
 .../golang.org/x/sys/unix/dev_aix_ppc64.go    |     4 +-
 .../vendor/golang.org/x/sys/unix/dev_zos.go   |    29 +
 .../vendor/golang.org/x/sys/unix/dirent.go    |     1 +
 .../golang.org/x/sys/unix/endian_big.go       |     1 +
 .../golang.org/x/sys/unix/endian_little.go    |     1 +
 .../vendor/golang.org/x/sys/unix/env_unix.go  |     3 +-
 .../vendor/golang.org/x/sys/unix/epoll_zos.go |   221 +
 src/cmd/vendor/golang.org/x/sys/unix/fcntl.go |     1 +
 .../x/sys/unix/fcntl_linux_32bit.go           |     1 +
 src/cmd/vendor/golang.org/x/sys/unix/fdset.go |     1 +
 .../golang.org/x/sys/unix/fstatfs_zos.go      |   164 +
 src/cmd/vendor/golang.org/x/sys/unix/gccgo.go |     4 +-
 .../x/sys/unix/gccgo_linux_amd64.go           |     1 +
 src/cmd/vendor/golang.org/x/sys/unix/ioctl.go |     1 +
 .../vendor/golang.org/x/sys/unix/ioctl_zos.go |    74 +
 .../vendor/golang.org/x/sys/unix/mkerrors.sh  |    22 +-
 .../golang.org/x/sys/unix/pagesize_unix.go    |     1 +
 .../golang.org/x/sys/unix/ptrace_darwin.go    |     1 +
 .../golang.org/x/sys/unix/ptrace_ios.go       |     1 +
 src/cmd/vendor/golang.org/x/sys/unix/race.go  |     1 +
 src/cmd/vendor/golang.org/x/sys/unix/race0.go |     3 +-
 .../x/sys/unix/readdirent_getdents.go         |     1 +
 .../x/sys/unix/readdirent_getdirentries.go    |     1 +
 .../golang.org/x/sys/unix/sockcmsg_unix.go    |     3 +-
 .../x/sys/unix/sockcmsg_unix_other.go         |     7 +-
 src/cmd/vendor/golang.org/x/sys/unix/str.go   |     1 +
 .../vendor/golang.org/x/sys/unix/syscall.go   |     3 +-
 .../golang.org/x/sys/unix/syscall_aix.go      |     1 +
 .../golang.org/x/sys/unix/syscall_aix_ppc.go  |     4 +-
 .../x/sys/unix/syscall_aix_ppc64.go           |     4 +-
 .../golang.org/x/sys/unix/syscall_bsd.go      |     1 +
 .../x/sys/unix/syscall_darwin.1_12.go         |     1 +
 .../x/sys/unix/syscall_darwin.1_13.go         |     1 +
 .../golang.org/x/sys/unix/syscall_darwin.go   |     2 +-
 .../x/sys/unix/syscall_darwin_386.go          |     1 +
 .../x/sys/unix/syscall_darwin_amd64.go        |     1 +
 .../x/sys/unix/syscall_darwin_arm64.go        |     1 +
 .../x/sys/unix/syscall_darwin_libSystem.go    |     1 +
 .../x/sys/unix/syscall_dragonfly.go           |     7 +-
 .../x/sys/unix/syscall_dragonfly_amd64.go     |     1 +
 .../golang.org/x/sys/unix/syscall_freebsd.go  |     9 +
 .../x/sys/unix/syscall_freebsd_386.go         |     1 +
 .../x/sys/unix/syscall_freebsd_amd64.go       |     1 +
 .../x/sys/unix/syscall_freebsd_arm.go         |     1 +
 .../x/sys/unix/syscall_freebsd_arm64.go       |     1 +
 .../golang.org/x/sys/unix/syscall_illumos.go  |     1 +
 .../golang.org/x/sys/unix/syscall_linux.go    |    89 +-
 .../x/sys/unix/syscall_linux_386.go           |     1 +
 .../x/sys/unix/syscall_linux_amd64.go         |     1 +
 .../x/sys/unix/syscall_linux_amd64_gc.go      |     4 +-
 .../x/sys/unix/syscall_linux_arm.go           |     1 +
 .../x/sys/unix/syscall_linux_arm64.go         |     1 +
 .../golang.org/x/sys/unix/syscall_linux_gc.go |     1 +
 .../x/sys/unix/syscall_linux_gc_386.go        |     1 +
 .../x/sys/unix/syscall_linux_gc_arm.go        |     1 +
 .../x/sys/unix/syscall_linux_gccgo_386.go     |     1 +
 .../x/sys/unix/syscall_linux_gccgo_arm.go     |     1 +
 .../x/sys/unix/syscall_linux_mips64x.go       |     1 +
 .../x/sys/unix/syscall_linux_mipsx.go         |     1 +
 .../x/sys/unix/syscall_linux_ppc64x.go        |     1 +
 .../x/sys/unix/syscall_linux_riscv64.go       |     1 +
 .../x/sys/unix/syscall_linux_s390x.go         |     1 +
 .../x/sys/unix/syscall_linux_sparc64.go       |     1 +
 .../x/sys/unix/syscall_netbsd_386.go          |     1 +
 .../x/sys/unix/syscall_netbsd_amd64.go        |     1 +
 .../x/sys/unix/syscall_netbsd_arm.go          |     1 +
 .../x/sys/unix/syscall_netbsd_arm64.go        |     1 +
 .../x/sys/unix/syscall_openbsd_386.go         |     1 +
 .../x/sys/unix/syscall_openbsd_amd64.go       |     1 +
 .../x/sys/unix/syscall_openbsd_arm.go         |     1 +
 .../x/sys/unix/syscall_openbsd_arm64.go       |     1 +
 .../x/sys/unix/syscall_solaris_amd64.go       |     1 +
 .../golang.org/x/sys/unix/syscall_unix.go     |     1 +
 .../golang.org/x/sys/unix/syscall_unix_gc.go  |     5 +-
 .../x/sys/unix/syscall_unix_gc_ppc64x.go      |     1 +
 .../x/sys/unix/syscall_zos_s390x.go           |  1781 ++
 .../golang.org/x/sys/unix/timestruct.go       |     3 +-
 .../vendor/golang.org/x/sys/unix/xattr_bsd.go |     1 +
 .../golang.org/x/sys/unix/zerrors_aix_ppc.go  |     1 +
 .../x/sys/unix/zerrors_aix_ppc64.go           |     1 +
 .../x/sys/unix/zerrors_darwin_386.go          |     1 +
 .../x/sys/unix/zerrors_darwin_amd64.go        |     1 +
 .../x/sys/unix/zerrors_darwin_arm.go          |     1 +
 .../x/sys/unix/zerrors_darwin_arm64.go        |     1 +
 .../x/sys/unix/zerrors_dragonfly_amd64.go     |     1 +
 .../x/sys/unix/zerrors_freebsd_386.go         |     7 +
 .../x/sys/unix/zerrors_freebsd_amd64.go       |     7 +
 .../x/sys/unix/zerrors_freebsd_arm.go         |     7 +
 .../x/sys/unix/zerrors_freebsd_arm64.go       |     7 +
 .../golang.org/x/sys/unix/zerrors_linux.go    |     9 +
 .../x/sys/unix/zerrors_linux_386.go           |     7 +
 .../x/sys/unix/zerrors_linux_amd64.go         |     7 +
 .../x/sys/unix/zerrors_linux_arm.go           |     7 +
 .../x/sys/unix/zerrors_linux_arm64.go         |     7 +
 .../x/sys/unix/zerrors_linux_mips.go          |     7 +
 .../x/sys/unix/zerrors_linux_mips64.go        |     7 +
 .../x/sys/unix/zerrors_linux_mips64le.go      |     7 +
 .../x/sys/unix/zerrors_linux_mipsle.go        |     7 +
 .../x/sys/unix/zerrors_linux_ppc64.go         |     7 +
 .../x/sys/unix/zerrors_linux_ppc64le.go       |     7 +
 .../x/sys/unix/zerrors_linux_riscv64.go       |     7 +
 .../x/sys/unix/zerrors_linux_s390x.go         |     7 +
 .../x/sys/unix/zerrors_linux_sparc64.go       |     7 +
 .../x/sys/unix/zerrors_netbsd_386.go          |     1 +
 .../x/sys/unix/zerrors_netbsd_amd64.go        |     1 +
 .../x/sys/unix/zerrors_netbsd_arm.go          |     1 +
 .../x/sys/unix/zerrors_netbsd_arm64.go        |     1 +
 .../x/sys/unix/zerrors_openbsd_386.go         |     1 +
 .../x/sys/unix/zerrors_openbsd_amd64.go       |     1 +
 .../x/sys/unix/zerrors_openbsd_arm.go         |     1 +
 .../x/sys/unix/zerrors_openbsd_arm64.go       |     1 +
 .../x/sys/unix/zerrors_openbsd_mips64.go      |     1 +
 .../x/sys/unix/zerrors_solaris_amd64.go       |     1 +
 .../x/sys/unix/zerrors_zos_s390x.go           |   831 +
 .../x/sys/unix/zptrace_armnn_linux.go         |     1 +
 .../x/sys/unix/zptrace_mipsnn_linux.go        |     1 +
 .../x/sys/unix/zptrace_mipsnnle_linux.go      |     1 +
 .../x/sys/unix/zptrace_x86_linux.go           |     1 +
 .../golang.org/x/sys/unix/zsyscall_aix_ppc.go |     1 +
 .../x/sys/unix/zsyscall_aix_ppc64.go          |     1 +
 .../x/sys/unix/zsyscall_aix_ppc64_gc.go       |     4 +-
 .../x/sys/unix/zsyscall_aix_ppc64_gccgo.go    |     4 +-
 .../x/sys/unix/zsyscall_darwin_386.1_13.go    |     1 +
 .../x/sys/unix/zsyscall_darwin_386.go         |     1 +
 .../x/sys/unix/zsyscall_darwin_amd64.1_13.go  |     1 +
 .../x/sys/unix/zsyscall_darwin_amd64.go       |     1 +
 .../x/sys/unix/zsyscall_darwin_arm.1_13.go    |     1 +
 .../x/sys/unix/zsyscall_darwin_arm.go         |     1 +
 .../x/sys/unix/zsyscall_darwin_arm64.1_13.go  |     1 +
 .../x/sys/unix/zsyscall_darwin_arm64.go       |     1 +
 .../x/sys/unix/zsyscall_dragonfly_amd64.go    |     5 +-
 .../x/sys/unix/zsyscall_freebsd_386.go        |     1 +
 .../x/sys/unix/zsyscall_freebsd_amd64.go      |     1 +
 .../x/sys/unix/zsyscall_freebsd_arm.go        |     1 +
 .../x/sys/unix/zsyscall_freebsd_arm64.go      |     1 +
 .../x/sys/unix/zsyscall_illumos_amd64.go      |     1 +
 .../golang.org/x/sys/unix/zsyscall_linux.go   |     1 +
 .../x/sys/unix/zsyscall_linux_386.go          |     1 +
 .../x/sys/unix/zsyscall_linux_amd64.go        |     1 +
 .../x/sys/unix/zsyscall_linux_arm.go          |     1 +
 .../x/sys/unix/zsyscall_linux_arm64.go        |     1 +
 .../x/sys/unix/zsyscall_linux_mips.go         |     1 +
 .../x/sys/unix/zsyscall_linux_mips64.go       |     1 +
 .../x/sys/unix/zsyscall_linux_mips64le.go     |     1 +
 .../x/sys/unix/zsyscall_linux_mipsle.go       |     1 +
 .../x/sys/unix/zsyscall_linux_ppc64.go        |     1 +
 .../x/sys/unix/zsyscall_linux_ppc64le.go      |     1 +
 .../x/sys/unix/zsyscall_linux_riscv64.go      |     1 +
 .../x/sys/unix/zsyscall_linux_s390x.go        |     1 +
 .../x/sys/unix/zsyscall_linux_sparc64.go      |     1 +
 .../x/sys/unix/zsyscall_netbsd_386.go         |     1 +
 .../x/sys/unix/zsyscall_netbsd_amd64.go       |     1 +
 .../x/sys/unix/zsyscall_netbsd_arm.go         |     1 +
 .../x/sys/unix/zsyscall_netbsd_arm64.go       |     1 +
 .../x/sys/unix/zsyscall_openbsd_386.go        |     1 +
 .../x/sys/unix/zsyscall_openbsd_amd64.go      |     1 +
 .../x/sys/unix/zsyscall_openbsd_arm.go        |     1 +
 .../x/sys/unix/zsyscall_openbsd_arm64.go      |     1 +
 .../x/sys/unix/zsyscall_openbsd_mips64.go     |     1 +
 .../x/sys/unix/zsyscall_solaris_amd64.go      |     1 +
 .../x/sys/unix/zsyscall_zos_s390x.go          |  1217 ++
 .../x/sys/unix/zsysctl_openbsd_386.go         |     1 +
 .../x/sys/unix/zsysctl_openbsd_amd64.go       |     1 +
 .../x/sys/unix/zsysctl_openbsd_arm.go         |     1 +
 .../x/sys/unix/zsysctl_openbsd_arm64.go       |     1 +
 .../x/sys/unix/zsysctl_openbsd_mips64.go      |     1 +
 .../x/sys/unix/zsysnum_darwin_386.go          |     1 +
 .../x/sys/unix/zsysnum_darwin_amd64.go        |     1 +
 .../x/sys/unix/zsysnum_darwin_arm.go          |     1 +
 .../x/sys/unix/zsysnum_darwin_arm64.go        |     1 +
 .../x/sys/unix/zsysnum_dragonfly_amd64.go     |     1 +
 .../x/sys/unix/zsysnum_freebsd_386.go         |     1 +
 .../x/sys/unix/zsysnum_freebsd_amd64.go       |     1 +
 .../x/sys/unix/zsysnum_freebsd_arm.go         |     1 +
 .../x/sys/unix/zsysnum_freebsd_arm64.go       |     1 +
 .../x/sys/unix/zsysnum_linux_386.go           |     1 +
 .../x/sys/unix/zsysnum_linux_amd64.go         |     1 +
 .../x/sys/unix/zsysnum_linux_arm.go           |     1 +
 .../x/sys/unix/zsysnum_linux_arm64.go         |     1 +
 .../x/sys/unix/zsysnum_linux_mips.go          |     1 +
 .../x/sys/unix/zsysnum_linux_mips64.go        |     1 +
 .../x/sys/unix/zsysnum_linux_mips64le.go      |     1 +
 .../x/sys/unix/zsysnum_linux_mipsle.go        |     1 +
 .../x/sys/unix/zsysnum_linux_ppc64.go         |     1 +
 .../x/sys/unix/zsysnum_linux_ppc64le.go       |     1 +
 .../x/sys/unix/zsysnum_linux_riscv64.go       |     1 +
 .../x/sys/unix/zsysnum_linux_s390x.go         |     1 +
 .../x/sys/unix/zsysnum_linux_sparc64.go       |     1 +
 .../x/sys/unix/zsysnum_netbsd_386.go          |     1 +
 .../x/sys/unix/zsysnum_netbsd_amd64.go        |     1 +
 .../x/sys/unix/zsysnum_netbsd_arm.go          |     1 +
 .../x/sys/unix/zsysnum_netbsd_arm64.go        |     1 +
 .../x/sys/unix/zsysnum_openbsd_386.go         |     1 +
 .../x/sys/unix/zsysnum_openbsd_amd64.go       |     1 +
 .../x/sys/unix/zsysnum_openbsd_arm.go         |     1 +
 .../x/sys/unix/zsysnum_openbsd_arm64.go       |     1 +
 .../x/sys/unix/zsysnum_openbsd_mips64.go      |     1 +
 .../x/sys/unix/zsysnum_zos_s390x.go           |  2670 +++
 .../golang.org/x/sys/unix/ztypes_aix_ppc.go   |     1 +
 .../golang.org/x/sys/unix/ztypes_aix_ppc64.go |     1 +
 .../x/sys/unix/ztypes_darwin_386.go           |     1 +
 .../x/sys/unix/ztypes_darwin_amd64.go         |     1 +
 .../x/sys/unix/ztypes_darwin_arm.go           |     1 +
 .../x/sys/unix/ztypes_darwin_arm64.go         |     1 +
 .../x/sys/unix/ztypes_dragonfly_amd64.go      |     1 +
 .../x/sys/unix/ztypes_freebsd_386.go          |    10 +
 .../x/sys/unix/ztypes_freebsd_amd64.go        |    10 +
 .../x/sys/unix/ztypes_freebsd_arm.go          |    10 +
 .../x/sys/unix/ztypes_freebsd_arm64.go        |    10 +
 .../golang.org/x/sys/unix/ztypes_linux.go     |    30 +-
 .../golang.org/x/sys/unix/ztypes_linux_386.go |     1 +
 .../x/sys/unix/ztypes_linux_amd64.go          |     1 +
 .../golang.org/x/sys/unix/ztypes_linux_arm.go |     1 +
 .../x/sys/unix/ztypes_linux_arm64.go          |     1 +
 .../x/sys/unix/ztypes_linux_mips.go           |     1 +
 .../x/sys/unix/ztypes_linux_mips64.go         |     1 +
 .../x/sys/unix/ztypes_linux_mips64le.go       |     1 +
 .../x/sys/unix/ztypes_linux_mipsle.go         |     1 +
 .../x/sys/unix/ztypes_linux_ppc64.go          |     1 +
 .../x/sys/unix/ztypes_linux_ppc64le.go        |     1 +
 .../x/sys/unix/ztypes_linux_riscv64.go        |     1 +
 .../x/sys/unix/ztypes_linux_s390x.go          |     1 +
 .../x/sys/unix/ztypes_linux_sparc64.go        |     1 +
 .../x/sys/unix/ztypes_netbsd_386.go           |     1 +
 .../x/sys/unix/ztypes_netbsd_amd64.go         |     1 +
 .../x/sys/unix/ztypes_netbsd_arm.go           |     1 +
 .../x/sys/unix/ztypes_netbsd_arm64.go         |     1 +
 .../x/sys/unix/ztypes_openbsd_386.go          |     1 +
 .../x/sys/unix/ztypes_openbsd_amd64.go        |     1 +
 .../x/sys/unix/ztypes_openbsd_arm.go          |     1 +
 .../x/sys/unix/ztypes_openbsd_arm64.go        |     1 +
 .../x/sys/unix/ztypes_openbsd_mips64.go       |     1 +
 .../x/sys/unix/ztypes_solaris_amd64.go        |     1 +
 .../golang.org/x/sys/unix/ztypes_zos_s390x.go |   402 +
 .../golang.org/x/sys/windows/exec_windows.go  |    35 +
 .../golang.org/x/sys/windows/mkerrors.bash    |     7 +
 .../x/sys/windows/security_windows.go         |    13 +
 .../x/sys/windows/syscall_windows.go          |   190 +-
 .../golang.org/x/sys/windows/types_windows.go |   678 +
 .../x/sys/windows/zerrors_windows.go          |  2619 ++-
 .../x/sys/windows/zsyscall_windows.go         |   337 +-
 src/cmd/vendor/golang.org/x/term/AUTHORS      |     3 +
 .../vendor/golang.org/x/term/CONTRIBUTING.md  |    26 +
 src/cmd/vendor/golang.org/x/term/CONTRIBUTORS |     3 +
 src/cmd/vendor/golang.org/x/term/LICENSE      |    27 +
 src/cmd/vendor/golang.org/x/term/PATENTS      |    22 +
 src/cmd/vendor/golang.org/x/term/README.md    |    19 +
 src/cmd/vendor/golang.org/x/term/go.mod       |     5 +
 src/cmd/vendor/golang.org/x/term/go.sum       |     2 +
 .../terminal/util_plan9.go => term/term.go}   |    40 +-
 .../vendor/golang.org/x/term/term_plan9.go    |    42 +
 .../util_solaris.go => term/term_solaris.go}  |    41 +-
 .../terminal/util.go => term/term_unix.go}    |    48 +-
 .../util_linux.go => term/term_unix_aix.go}   |     4 +-
 .../util_bsd.go => term/term_unix_bsd.go}     |     3 +-
 .../util_aix.go => term/term_unix_linux.go}   |     6 +-
 .../vendor/golang.org/x/term/term_unix_zos.go |    10 +
 .../golang.org/x/term/term_unsupported.go     |    39 +
 .../util_windows.go => term/term_windows.go}  |    48 +-
 src/cmd/vendor/golang.org/x/term/terminal.go  |   987 +
 src/cmd/vendor/modules.txt                    |    14 +-
 src/go.mod                                    |    10 +-
 src/go.sum                                    |    19 +-
 src/net/http/h2_bundle.go                     |    30 +-
 .../x/crypto/chacha20/chacha_arm64.go         |     3 +-
 .../x/crypto/chacha20/chacha_arm64.s          |     2 +-
 .../x/crypto/chacha20/chacha_noasm.go         |     3 +-
 .../x/crypto/chacha20/chacha_ppc64le.go       |     3 +-
 .../x/crypto/chacha20/chacha_ppc64le.s        |     2 +-
 .../x/crypto/chacha20/chacha_s390x.go         |     3 +-
 .../x/crypto/chacha20/chacha_s390x.s          |     2 +-
 .../chacha20poly1305_amd64.go                 |     3 +-
 .../chacha20poly1305/chacha20poly1305_amd64.s |     2 +-
 .../chacha20poly1305_noasm.go                 |     3 +-
 .../x/crypto/curve25519/curve25519_amd64.go   |     3 +-
 .../x/crypto/curve25519/curve25519_amd64.s    |     2 +-
 .../x/crypto/curve25519/curve25519_noasm.go   |     3 +-
 .../x/crypto/internal/subtle/aliasing.go      |     3 +-
 ...iasing_appengine.go => aliasing_purego.go} |     3 +-
 .../x/crypto/poly1305/bits_compat.go          |     1 +
 .../x/crypto/poly1305/bits_go1.13.go          |     1 +
 .../golang.org/x/crypto/poly1305/mac_noasm.go |     3 +-
 .../golang.org/x/crypto/poly1305/sum_amd64.go |     3 +-
 .../golang.org/x/crypto/poly1305/sum_amd64.s  |     2 +-
 .../x/crypto/poly1305/sum_ppc64le.go          |     3 +-
 .../x/crypto/poly1305/sum_ppc64le.s           |     2 +-
 .../golang.org/x/crypto/poly1305/sum_s390x.go |     3 +-
 .../golang.org/x/crypto/poly1305/sum_s390x.s  |     2 +-
 .../golang.org/x/net/idna/idna10.0.0.go       |     1 +
 src/vendor/golang.org/x/net/idna/idna9.0.0.go |     1 +
 .../golang.org/x/net/idna/tables10.0.0.go     |     1 +
 .../golang.org/x/net/idna/tables11.0.0.go     |     1 +
 .../golang.org/x/net/idna/tables12.0.0.go     |     1 +
 .../golang.org/x/net/idna/tables13.0.0.go     |     1 +
 .../golang.org/x/net/idna/tables9.0.0.go      |     1 +
 .../golang.org/x/net/nettest/nettest_stub.go  |     1 +
 .../golang.org/x/net/nettest/nettest_unix.go  |     1 +
 src/vendor/golang.org/x/net/route/address.go  |     1 +
 src/vendor/golang.org/x/net/route/binary.go   |     1 +
 .../golang.org/x/net/route/interface.go       |     1 +
 .../x/net/route/interface_announce.go         |     1 +
 .../x/net/route/interface_classic.go          |     1 +
 .../x/net/route/interface_multicast.go        |     1 +
 src/vendor/golang.org/x/net/route/message.go  |     1 +
 src/vendor/golang.org/x/net/route/route.go    |     1 +
 .../golang.org/x/net/route/route_classic.go   |     1 +
 src/vendor/golang.org/x/net/route/sys.go      |     1 +
 src/vendor/golang.org/x/net/route/syscall.go  |     1 +
 .../x/net/route/syscall_go1_12_darwin.go      |     1 +
 src/vendor/golang.org/x/sys/cpu/cpu_aix.go    |     1 +
 .../golang.org/x/sys/cpu/cpu_gc_arm64.go      |     1 +
 .../golang.org/x/sys/cpu/cpu_gc_s390x.go      |     1 +
 src/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go |     1 +
 .../golang.org/x/sys/cpu/cpu_gccgo_arm64.go   |     1 +
 .../golang.org/x/sys/cpu/cpu_gccgo_s390x.go   |     1 +
 .../golang.org/x/sys/cpu/cpu_gccgo_x86.go     |     1 +
 src/vendor/golang.org/x/sys/cpu/cpu_linux.go  |     1 +
 .../golang.org/x/sys/cpu/cpu_linux_mips64x.go |     1 +
 .../golang.org/x/sys/cpu/cpu_linux_noinit.go  |     1 +
 .../golang.org/x/sys/cpu/cpu_linux_ppc64x.go  |     1 +
 .../golang.org/x/sys/cpu/cpu_mips64x.go       |     1 +
 src/vendor/golang.org/x/sys/cpu/cpu_mipsx.go  |     1 +
 .../golang.org/x/sys/cpu/cpu_other_arm.go     |     1 +
 .../golang.org/x/sys/cpu/cpu_other_arm64.go   |     4 +-
 .../golang.org/x/sys/cpu/cpu_other_mips64x.go |     1 +
 src/vendor/golang.org/x/sys/cpu/cpu_ppc64x.go |     1 +
 .../golang.org/x/sys/cpu/cpu_riscv64.go       |     1 +
 src/vendor/golang.org/x/sys/cpu/cpu_wasm.go   |     1 +
 src/vendor/golang.org/x/sys/cpu/cpu_x86.go    |     1 +
 .../golang.org/x/sys/cpu/syscall_aix_gccgo.go |     4 +-
 .../x/sys/cpu/syscall_aix_ppc64_gc.go         |     4 +-
 .../x/text/secure/bidirule/bidirule10.0.0.go  |     1 +
 .../x/text/secure/bidirule/bidirule9.0.0.go   |     1 +
 .../golang.org/x/text/unicode/bidi/bidi.go    |   221 +-
 .../golang.org/x/text/unicode/bidi/core.go    |    63 +-
 .../x/text/unicode/bidi/tables10.0.0.go       |     1 +
 .../x/text/unicode/bidi/tables11.0.0.go       |     1 +
 .../x/text/unicode/bidi/tables12.0.0.go       |     1 +
 .../x/text/unicode/bidi/tables13.0.0.go       |     1 +
 .../x/text/unicode/bidi/tables9.0.0.go        |     1 +
 .../x/text/unicode/norm/tables10.0.0.go       |     1 +
 .../x/text/unicode/norm/tables11.0.0.go       |     1 +
 .../x/text/unicode/norm/tables12.0.0.go       |     1 +
 .../x/text/unicode/norm/tables13.0.0.go       |     1 +
 .../x/text/unicode/norm/tables9.0.0.go        |     1 +
 src/vendor/modules.txt                        |     8 +-
 397 files changed, 25495 insertions(+), 9874 deletions(-)
 create mode 100644 src/cmd/vendor/golang.org/x/sys/plan9/asm.s
 create mode 100644 src/cmd/vendor/golang.org/x/sys/plan9/asm_plan9_386.s
 create mode 100644 src/cmd/vendor/golang.org/x/sys/plan9/asm_plan9_amd64.s
 create mode 100644 src/cmd/vendor/golang.org/x/sys/plan9/asm_plan9_arm.s
 create mode 100644 src/cmd/vendor/golang.org/x/sys/plan9/const_plan9.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/plan9/dir_plan9.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/plan9/env_plan9.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/plan9/errors_plan9.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/plan9/mkall.sh
 create mode 100644 src/cmd/vendor/golang.org/x/sys/plan9/mkerrors.sh
 create mode 100644 src/cmd/vendor/golang.org/x/sys/plan9/mksysnum_plan9.sh
 create mode 100644 src/cmd/vendor/golang.org/x/sys/plan9/pwd_go15_plan9.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/plan9/pwd_plan9.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/plan9/race.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/plan9/race0.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/plan9/str.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/plan9/syscall.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/plan9/syscall_plan9.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_386.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_amd64.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_arm.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/plan9/zsysnum_plan9.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/unix/asm_zos_s390x.s
 create mode 100644 src/cmd/vendor/golang.org/x/sys/unix/dev_zos.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/unix/epoll_zos.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/unix/fstatfs_zos.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/unix/ioctl_zos.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/unix/zsyscall_zos_s390x.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/unix/zsysnum_zos_s390x.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go
 create mode 100644 src/cmd/vendor/golang.org/x/term/AUTHORS
 create mode 100644 src/cmd/vendor/golang.org/x/term/CONTRIBUTING.md
 create mode 100644 src/cmd/vendor/golang.org/x/term/CONTRIBUTORS
 create mode 100644 src/cmd/vendor/golang.org/x/term/LICENSE
 create mode 100644 src/cmd/vendor/golang.org/x/term/PATENTS
 create mode 100644 src/cmd/vendor/golang.org/x/term/README.md
 create mode 100644 src/cmd/vendor/golang.org/x/term/go.mod
 create mode 100644 src/cmd/vendor/golang.org/x/term/go.sum
 rename src/cmd/vendor/golang.org/x/{crypto/ssh/terminal/util_plan9.go => term/term.go} (52%)
 create mode 100644 src/cmd/vendor/golang.org/x/term/term_plan9.go
 rename src/cmd/vendor/golang.org/x/{crypto/ssh/terminal/util_solaris.go => term/term_solaris.go} (61%)
 rename src/cmd/vendor/golang.org/x/{crypto/ssh/terminal/util.go => term/term_unix.go} (53%)
 rename src/cmd/vendor/golang.org/x/{crypto/ssh/terminal/util_linux.go => term/term_unix_aix.go} (74%)
 rename src/cmd/vendor/golang.org/x/{crypto/ssh/terminal/util_bsd.go => term/term_unix_bsd.go} (80%)
 rename src/cmd/vendor/golang.org/x/{crypto/ssh/terminal/util_aix.go => term/term_unix_linux.go} (71%)
 create mode 100644 src/cmd/vendor/golang.org/x/term/term_unix_zos.go
 create mode 100644 src/cmd/vendor/golang.org/x/term/term_unsupported.go
 rename src/cmd/vendor/golang.org/x/{crypto/ssh/terminal/util_windows.go => term/term_windows.go} (53%)
 create mode 100644 src/cmd/vendor/golang.org/x/term/terminal.go
 rename src/vendor/golang.org/x/crypto/internal/subtle/{aliasing_appengine.go => aliasing_purego.go} (97%)

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index 306143f088..d78fabe196 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -1,12 +1,13 @@
 module cmd
 
-go 1.16
+go 1.17
 
 require (
-	github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2
-	golang.org/x/arch v0.0.0-20201008161808-52c3e6f60cff
-	golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897
+	github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5
+	golang.org/x/arch v0.0.0-20210308155006-05f8f0431f72
+	golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83
 	golang.org/x/mod v0.4.3-0.20210310185834-19d50cac98aa
-	golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e // indirect
-	golang.org/x/tools v0.1.1-0.20210220032852-2363391a5b2f
+	golang.org/x/sys v0.0.0-20210309074719-68d13333faf2 // indirect
+	golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d // indirect
+	golang.org/x/tools v0.1.1-0.20210312185553-8e4f4c86593a
 )
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 97fbd5c0a9..706230f4cf 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -1,18 +1,18 @@
 github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
 github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
 github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
-github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2 h1:HyOHhUtuB/Ruw/L5s5pG2D0kckkN2/IzBs9OClGHnHI=
-github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
+github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5 h1:zIaiqGYDQwa4HVx5wGRTXbx38Pqxjemn4BP98wpzpXo=
+github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
 github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639 h1:mV02weKRL81bEnm8A0HT1/CAelMQDBuQIfLw8n+d6xI=
 github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-golang.org/x/arch v0.0.0-20201008161808-52c3e6f60cff h1:XmKBi9R6duxOB3lfc72wyrwiOY7X2Jl1wuI+RFOyMDE=
-golang.org/x/arch v0.0.0-20201008161808-52c3e6f60cff/go.mod h1:flIaEI6LNU6xOCD5PaJvn9wGP0agmIOqjrtsKGRguv4=
+golang.org/x/arch v0.0.0-20210308155006-05f8f0431f72 h1:CdaLHkic8S6xdhpWgHmtWij2rv2DTGwPuJZjjEDGk2w=
+golang.org/x/arch v0.0.0-20210308155006-05f8f0431f72/go.mod h1:flIaEI6LNU6xOCD5PaJvn9wGP0agmIOqjrtsKGRguv4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897 h1:pLI5jrR7OSLijeIDcmRxNmw2api+jEfxLoykJVice/E=
-golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 h1:/ZScEX8SfEmUGRHs0gxpqteO5nfNW6axyZbBdw9A12g=
+golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
 golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.3-0.20210310185834-19d50cac98aa h1:++oSKjoJSsXNHyhUdK1BtBKMAaMHER+GWyKN3319OZA=
 golang.org/x/mod v0.4.3-0.20210310185834-19d50cac98aa/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
@@ -23,17 +23,22 @@ golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e h1:f5mksnk+hgXHnImpZoWj64ja99j9zV7YUgrVG95uFE4=
-golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210309074719-68d13333faf2 h1:46ULzRKLh1CwgRq2dC5SlBzEqqNCi8rreOZnNrbqcIY=
+golang.org/x/sys v0.0.0-20210309074719-68d13333faf2/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
+golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d h1:SZxvLBoTP5yHO3Frd4z4vrF+DBX9vMVanchswa69toE=
+golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.1.1-0.20210220032852-2363391a5b2f h1:R8L2zr6nSvQoIIw/EiaPP6HfmxeiArf+Nh/CWTC60wQ=
-golang.org/x/tools v0.1.1-0.20210220032852-2363391a5b2f/go.mod h1:9bzcO0MWcOuT0tm1iBGzDVPshzfwoVvREIui8C+MHqU=
+golang.org/x/tools v0.1.1-0.20210312185553-8e4f4c86593a h1:dM42cKDDlU6VAcfE6/ANedIkHqAPncj3GWNGqjv0f0Q=
+golang.org/x/tools v0.1.1-0.20210312185553-8e4f4c86593a/go.mod h1:9bzcO0MWcOuT0tm1iBGzDVPshzfwoVvREIui8C+MHqU=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
diff --git a/src/cmd/vendor/github.com/google/pprof/internal/binutils/addr2liner.go b/src/cmd/vendor/github.com/google/pprof/internal/binutils/addr2liner.go
index c0661bf4aa..0c702398d3 100644
--- a/src/cmd/vendor/github.com/google/pprof/internal/binutils/addr2liner.go
+++ b/src/cmd/vendor/github.com/google/pprof/internal/binutils/addr2liner.go
@@ -70,7 +70,11 @@ func (a *addr2LinerJob) write(s string) error {
 }
 
 func (a *addr2LinerJob) readLine() (string, error) {
-	return a.out.ReadString('\n')
+	s, err := a.out.ReadString('\n')
+	if err != nil {
+		return "", err
+	}
+	return strings.TrimSpace(s), nil
 }
 
 // close releases any resources used by the addr2liner object.
@@ -115,19 +119,11 @@ func newAddr2Liner(cmd, file string, base uint64) (*addr2Liner, error) {
 	return a, nil
 }
 
-func (d *addr2Liner) readString() (string, error) {
-	s, err := d.rw.readLine()
-	if err != nil {
-		return "", err
-	}
-	return strings.TrimSpace(s), nil
-}
-
 // readFrame parses the addr2line output for a single address. It
 // returns a populated plugin.Frame and whether it has reached the end of the
 // data.
 func (d *addr2Liner) readFrame() (plugin.Frame, bool) {
-	funcname, err := d.readString()
+	funcname, err := d.rw.readLine()
 	if err != nil {
 		return plugin.Frame{}, true
 	}
@@ -135,12 +131,12 @@ func (d *addr2Liner) readFrame() (plugin.Frame, bool) {
 		// If addr2line returns a hex address we can assume it is the
 		// sentinel. Read and ignore next two lines of output from
 		// addr2line
-		d.readString()
-		d.readString()
+		d.rw.readLine()
+		d.rw.readLine()
 		return plugin.Frame{}, true
 	}
 
-	fileline, err := d.readString()
+	fileline, err := d.rw.readLine()
 	if err != nil {
 		return plugin.Frame{}, true
 	}
@@ -186,7 +182,7 @@ func (d *addr2Liner) rawAddrInfo(addr uint64) ([]plugin.Frame, error) {
 		return nil, err
 	}
 
-	resp, err := d.readString()
+	resp, err := d.rw.readLine()
 	if err != nil {
 		return nil, err
 	}
diff --git a/src/cmd/vendor/github.com/google/pprof/internal/binutils/addr2liner_llvm.go b/src/cmd/vendor/github.com/google/pprof/internal/binutils/addr2liner_llvm.go
index 68fa5593ad..24c48e649b 100644
--- a/src/cmd/vendor/github.com/google/pprof/internal/binutils/addr2liner_llvm.go
+++ b/src/cmd/vendor/github.com/google/pprof/internal/binutils/addr2liner_llvm.go
@@ -43,15 +43,21 @@ type llvmSymbolizerJob struct {
 	cmd *exec.Cmd
 	in  io.WriteCloser
 	out *bufio.Reader
+	// llvm-symbolizer requires the symbol type, CODE or DATA, for symbolization.
+	symType string
 }
 
 func (a *llvmSymbolizerJob) write(s string) error {
-	_, err := fmt.Fprint(a.in, s+"\n")
+	_, err := fmt.Fprintln(a.in, a.symType, s)
 	return err
 }
 
 func (a *llvmSymbolizerJob) readLine() (string, error) {
-	return a.out.ReadString('\n')
+	s, err := a.out.ReadString('\n')
+	if err != nil {
+		return "", err
+	}
+	return strings.TrimSpace(s), nil
 }
 
 // close releases any resources used by the llvmSymbolizer object.
@@ -64,13 +70,17 @@ func (a *llvmSymbolizerJob) close() {
 // information about the given executable file. If file is a shared
 // library, base should be the address at which it was mapped in the
 // program under consideration.
-func newLLVMSymbolizer(cmd, file string, base uint64) (*llvmSymbolizer, error) {
+func newLLVMSymbolizer(cmd, file string, base uint64, isData bool) (*llvmSymbolizer, error) {
 	if cmd == "" {
 		cmd = defaultLLVMSymbolizer
 	}
 
 	j := &llvmSymbolizerJob{
-		cmd: exec.Command(cmd, "-inlining", "-demangle=false"),
+		cmd:     exec.Command(cmd, "-inlining", "-demangle=false"),
+		symType: "CODE",
+	}
+	if isData {
+		j.symType = "DATA"
 	}
 
 	var err error
@@ -97,19 +107,11 @@ func newLLVMSymbolizer(cmd, file string, base uint64) (*llvmSymbolizer, error) {
 	return a, nil
 }
 
-func (d *llvmSymbolizer) readString() (string, error) {
-	s, err := d.rw.readLine()
-	if err != nil {
-		return "", err
-	}
-	return strings.TrimSpace(s), nil
-}
-
 // readFrame parses the llvm-symbolizer output for a single address. It
 // returns a populated plugin.Frame and whether it has reached the end of the
 // data.
 func (d *llvmSymbolizer) readFrame() (plugin.Frame, bool) {
-	funcname, err := d.readString()
+	funcname, err := d.rw.readLine()
 	if err != nil {
 		return plugin.Frame{}, true
 	}
@@ -121,13 +123,17 @@ func (d *llvmSymbolizer) readFrame() (plugin.Frame, bool) {
 		funcname = ""
 	}
 
-	fileline, err := d.readString()
+	fileline, err := d.rw.readLine()
 	if err != nil {
 		return plugin.Frame{Func: funcname}, true
 	}
 
 	linenumber := 0
-	if fileline == "??:0" {
+	// The llvm-symbolizer outputs the <file_name>:<line_number>:<column_number>.
+	// When it cannot identify the source code location, it outputs "??:0:0".
+	// Older versions output just the filename and line number, so we check for
+	// both conditions here.
+	if fileline == "??:0" || fileline == "??:0:0" {
 		fileline = ""
 	} else {
 		switch split := strings.Split(fileline, ":"); len(split) {
diff --git a/src/cmd/vendor/github.com/google/pprof/internal/binutils/addr2liner_nm.go b/src/cmd/vendor/github.com/google/pprof/internal/binutils/addr2liner_nm.go
index 1987bd3dab..8e0ccc728d 100644
--- a/src/cmd/vendor/github.com/google/pprof/internal/binutils/addr2liner_nm.go
+++ b/src/cmd/vendor/github.com/google/pprof/internal/binutils/addr2liner_nm.go
@@ -29,27 +29,42 @@ const (
 	defaultNM = "nm"
 )
 
-// addr2LinerNM is a connection to an nm command for obtaining address
+// addr2LinerNM is a connection to an nm command for obtaining symbol
 // information from a binary.
 type addr2LinerNM struct {
-	m []symbolInfo // Sorted list of addresses from binary.
+	m []symbolInfo // Sorted list of symbol addresses from binary.
 }
 
 type symbolInfo struct {
 	address uint64
+	size    uint64
 	name    string
+	symType string
 }
 
-//  newAddr2LinerNM starts the given nm command reporting information about the
-// given executable file. If file is a shared library, base should be
-// the address at which it was mapped in the program under
-// consideration.
+// isData returns if the symbol has a known data object symbol type.
+func (s *symbolInfo) isData() bool {
+	// The following symbol types are taken from https://linux.die.net/man/1/nm:
+	// Lowercase letter means local symbol, uppercase denotes a global symbol.
+	// - b or B: the symbol is in the uninitialized data section, e.g. .bss;
+	// - d or D: the symbol is in the initialized data section;
+	// - r or R: the symbol is in a read only data section;
+	// - v or V: the symbol is a weak object;
+	// - W: the symbol is a weak symbol that has not been specifically tagged as a
+	//      weak object symbol. Experiments with some binaries, showed these to be
+	//      mostly data objects.
+	return strings.ContainsAny(s.symType, "bBdDrRvVW")
+}
+
+// newAddr2LinerNM starts the given nm command reporting information about the
+// given executable file. If file is a shared library, base should be the
+// address at which it was mapped in the program under consideration.
 func newAddr2LinerNM(cmd, file string, base uint64) (*addr2LinerNM, error) {
 	if cmd == "" {
 		cmd = defaultNM
 	}
 	var b bytes.Buffer
-	c := exec.Command(cmd, "-n", file)
+	c := exec.Command(cmd, "--numeric-sort", "--print-size", "--format=posix", file)
 	c.Stdout = &b
 	if err := c.Run(); err != nil {
 		return nil, err
@@ -74,17 +89,23 @@ func parseAddr2LinerNM(base uint64, nm io.Reader) (*addr2LinerNM, error) {
 			return nil, err
 		}
 		line = strings.TrimSpace(line)
-		fields := strings.SplitN(line, " ", 3)
-		if len(fields) != 3 {
+		fields := strings.Split(line, " ")
+		if len(fields) != 4 {
+			continue
+		}
+		address, err := strconv.ParseUint(fields[2], 16, 64)
+		if err != nil {
 			continue
 		}
-		address, err := strconv.ParseUint(fields[0], 16, 64)
+		size, err := strconv.ParseUint(fields[3], 16, 64)
 		if err != nil {
 			continue
 		}
 		a.m = append(a.m, symbolInfo{
 			address: address + base,
-			name:    fields[2],
+			size:    size,
+			name:    fields[0],
+			symType: fields[1],
 		})
 	}
 
@@ -94,7 +115,7 @@ func parseAddr2LinerNM(base uint64, nm io.Reader) (*addr2LinerNM, error) {
 // addrInfo returns the stack frame information for a specific program
 // address. It returns nil if the address could not be identified.
 func (a *addr2LinerNM) addrInfo(addr uint64) ([]plugin.Frame, error) {
-	if len(a.m) == 0 || addr < a.m[0].address || addr > a.m[len(a.m)-1].address {
+	if len(a.m) == 0 || addr < a.m[0].address || addr >= (a.m[len(a.m)-1].address+a.m[len(a.m)-1].size) {
 		return nil, nil
 	}
 
@@ -113,12 +134,11 @@ func (a *addr2LinerNM) addrInfo(addr uint64) ([]plugin.Frame, error) {
 		}
 	}
 
-	// Address is between a.m[low] and a.m[high].
-	// Pick low, as it represents [low, high).
-	f := []plugin.Frame{
-		{
-			Func: a.m[low].name,
-		},
+	// Address is between a.m[low] and a.m[high]. Pick low, as it represents
+	// [low, high). For data symbols, we use a strict check that the address is in
+	// the [start, start + size) range of a.m[low].
+	if a.m[low].isData() && addr >= (a.m[low].address+a.m[low].size) {
+		return nil, nil
 	}
-	return f, nil
+	return []plugin.Frame{{Func: a.m[low].name}}, nil
 }
diff --git a/src/cmd/vendor/github.com/google/pprof/internal/binutils/binutils.go b/src/cmd/vendor/github.com/google/pprof/internal/binutils/binutils.go
index 4b67cc4ab0..576a6ee66a 100644
--- a/src/cmd/vendor/github.com/google/pprof/internal/binutils/binutils.go
+++ b/src/cmd/vendor/github.com/google/pprof/internal/binutils/binutils.go
@@ -18,6 +18,7 @@ package binutils
 import (
 	"debug/elf"
 	"debug/macho"
+	"debug/pe"
 	"encoding/binary"
 	"errors"
 	"fmt"
@@ -255,7 +256,7 @@ func (bu *Binutils) Disasm(file string, start, end uint64, intelSyntax bool) ([]
 	if !b.objdumpFound {
 		return nil, errors.New("cannot disasm: no objdump tool available")
 	}
-	args := []string{"--disassemble-all", "--demangle", "--no-show-raw-insn",
+	args := []string{"--disassemble", "--demangle", "--no-show-raw-insn",
 		"--line-numbers", fmt.Sprintf("--start-address=%#x", start),
 		fmt.Sprintf("--stop-address=%#x", end)}
 
@@ -337,6 +338,15 @@ func (bu *Binutils) Open(name string, start, limit, offset uint64) (plugin.ObjFi
 		return f, nil
 	}
 
+	peMagic := string(header[:2])
+	if peMagic == "MZ" {
+		f, err := b.openPE(name, start, limit, offset)
+		if err != nil {
+			return nil, fmt.Errorf("error reading PE file %s: %v", name, err)
+		}
+		return f, nil
+	}
+
 	return nil, fmt.Errorf("unrecognized binary format: %s", name)
 }
 
@@ -440,7 +450,23 @@ func (b *binrep) openELF(name string, start, limit, offset uint64) (plugin.ObjFi
 		}
 	}
 
-	base, err := elfexec.GetBase(&ef.FileHeader, elfexec.FindTextProgHeader(ef), stextOffset, start, limit, offset)
+	var ph *elf.ProgHeader
+	// For user space executables, find the actual program segment that is
+	// associated with the given mapping. Skip this search if limit <= start.
+	// We cannot use just a check on the start address of the mapping to tell if
+	// it's a kernel / .ko module mapping, because with quipper address remapping
+	// enabled, the address would be in the lower half of the address space.
+	if stextOffset == nil && start < limit && limit < (uint64(1)<<63) {
+		ph, err = elfexec.FindProgHeaderForMapping(ef, offset, limit-start)
+		if err != nil {
+			return nil, fmt.Errorf("failed to find program header for file %q, mapping pgoff %x, memsz=%x: %v", name, offset, limit-start, err)
+		}
+	} else {
+		// For the kernel, find the program segment that includes the .text section.
+		ph = elfexec.FindTextProgHeader(ef)
+	}
+
+	base, err := elfexec.GetBase(&ef.FileHeader, ph, stextOffset, start, limit, offset)
 	if err != nil {
 		return nil, fmt.Errorf("could not identify base for %s: %v", name, err)
 	}
@@ -451,10 +477,38 @@ func (b *binrep) openELF(name string, start, limit, offset uint64) (plugin.ObjFi
 			buildID = fmt.Sprintf("%x", id)
 		}
 	}
+	isData := ph != nil && ph.Flags&elf.PF_X == 0
+	if b.fast || (!b.addr2lineFound && !b.llvmSymbolizerFound) {
+		return &fileNM{file: file{b, name, base, buildID, isData}}, nil
+	}
+	return &fileAddr2Line{file: file{b, name, base, buildID, isData}}, nil
+}
+
+func (b *binrep) openPE(name string, start, limit, offset uint64) (plugin.ObjFile, error) {
+	pf, err := pe.Open(name)
+	if err != nil {
+		return nil, fmt.Errorf("error parsing %s: %v", name, err)
+	}
+	defer pf.Close()
+
+	var imageBase uint64
+	switch h := pf.OptionalHeader.(type) {
+	case *pe.OptionalHeader32:
+		imageBase = uint64(h.ImageBase)
+	case *pe.OptionalHeader64:
+		imageBase = uint64(h.ImageBase)
+	default:
+		return nil, fmt.Errorf("unknown OptionalHeader %T", pf.OptionalHeader)
+	}
+
+	var base uint64
+	if start > 0 {
+		base = start - imageBase
+	}
 	if b.fast || (!b.addr2lineFound && !b.llvmSymbolizerFound) {
-		return &fileNM{file: file{b, name, base, buildID}}, nil
+		return &fileNM{file: file{b: b, name: name, base: base}}, nil
 	}
-	return &fileAddr2Line{file: file{b, name, base, buildID}}, nil
+	return &fileAddr2Line{file: file{b: b, name: name, base: base}}, nil
 }
 
 // file implements the binutils.ObjFile interface.
@@ -463,6 +517,7 @@ type file struct {
 	name    string
 	base    uint64
 	buildID string
+	isData  bool
 }
 
 func (f *file) Name() string {
@@ -538,7 +593,7 @@ func (f *fileAddr2Line) SourceLine(addr uint64) ([]plugin.Frame, error) {
 }
 
 func (f *fileAddr2Line) init() {
-	if llvmSymbolizer, err := newLLVMSymbolizer(f.b.llvmSymbolizer, f.name, f.base); err == nil {
+	if llvmSymbolizer, err := newLLVMSymbolizer(f.b.llvmSymbolizer, f.name, f.base, f.isData); err == nil {
 		f.llvmSymbolizer = llvmSymbolizer
 		return
 	}
diff --git a/src/cmd/vendor/github.com/google/pprof/internal/binutils/disasm.go b/src/cmd/vendor/github.com/google/pprof/internal/binutils/disasm.go
index d0be614bdc..e64adf58cd 100644
--- a/src/cmd/vendor/github.com/google/pprof/internal/binutils/disasm.go
+++ b/src/cmd/vendor/github.com/google/pprof/internal/binutils/disasm.go
@@ -19,6 +19,7 @@ import (
 	"io"
 	"regexp"
 	"strconv"
+	"strings"
 
 	"github.com/google/pprof/internal/plugin"
 	"github.com/ianlancetaylor/demangle"
@@ -121,6 +122,7 @@ func disassemble(asm []byte) ([]plugin.Inst, error) {
 				break
 			}
 		}
+		input = strings.TrimSpace(input)
 
 		if fields := objdumpAsmOutputRE.FindStringSubmatch(input); len(fields) == 3 {
 			if address, err := strconv.ParseUint(fields[1], 16, 64); err == nil {
@@ -167,6 +169,7 @@ func nextSymbol(buf *bytes.Buffer) (uint64, string, error) {
 				return 0, "", err
 			}
 		}
+		line = strings.TrimSpace(line)
 
 		if fields := nmOutputRE.FindStringSubmatch(line); len(fields) == 4 {
 			if address, err := strconv.ParseUint(fields[1], 16, 64); err == nil {
diff --git a/src/cmd/vendor/github.com/google/pprof/internal/driver/driver.go b/src/cmd/vendor/github.com/google/pprof/internal/driver/driver.go
index 878f2e1ead..3967a12d45 100644
--- a/src/cmd/vendor/github.com/google/pprof/internal/driver/driver.go
+++ b/src/cmd/vendor/github.com/google/pprof/internal/driver/driver.go
@@ -163,7 +163,7 @@ func applyCommandOverrides(cmd string, outputFormat int, cfg config) config {
 	trim := cfg.Trim
 
 	switch cmd {
-	case "disasm", "weblist":
+	case "disasm":
 		trim = false
 		cfg.Granularity = "addresses"
 		// Force the 'noinlines' mode so that source locations for a given address
@@ -172,6 +172,10 @@ func applyCommandOverrides(cmd string, outputFormat int, cfg config) config {
 		// This is because the merge is done by address and in case of an inlined
 		// stack each of the inlined entries is a separate callgraph node.
 		cfg.NoInlines = true
+	case "weblist":
+		trim = false
+		cfg.Granularity = "addresses"
+		cfg.NoInlines = false // Need inline info to support call expansion
 	case "peek":
 		trim = false
 	case "list":
diff --git a/src/cmd/vendor/github.com/google/pprof/internal/driver/webhtml.go b/src/cmd/vendor/github.com/google/pprof/internal/driver/webhtml.go
index 4f7610c7e5..b8e8b50b94 100644
--- a/src/cmd/vendor/github.com/google/pprof/internal/driver/webhtml.go
+++ b/src/cmd/vendor/github.com/google/pprof/internal/driver/webhtml.go
@@ -62,6 +62,7 @@ a {
 .header .title h1 {
   font-size: 1.75em;
   margin-right: 1rem;
+  margin-bottom: 4px;
 }
 .header .title a {
   color: #212121;
diff --git a/src/cmd/vendor/github.com/google/pprof/internal/elfexec/elfexec.go b/src/cmd/vendor/github.com/google/pprof/internal/elfexec/elfexec.go
index d520765cc9..3b3c6ee89f 100644
--- a/src/cmd/vendor/github.com/google/pprof/internal/elfexec/elfexec.go
+++ b/src/cmd/vendor/github.com/google/pprof/internal/elfexec/elfexec.go
@@ -283,3 +283,84 @@ func FindTextProgHeader(f *elf.File) *elf.ProgHeader {
 	}
 	return nil
 }
+
+// FindProgHeaderForMapping returns the loadable program segment header that is
+// fully contained in the runtime mapping with file offset pgoff and memory size
+// memsz, or an error if the segment cannot be determined. The function returns
+// a nil program header and no error if the ELF binary has no loadable segments.
+func FindProgHeaderForMapping(f *elf.File, pgoff, memsz uint64) (*elf.ProgHeader, error) {
+	var headers []*elf.ProgHeader
+	loadables := 0
+	for _, p := range f.Progs {
+		if p.Type == elf.PT_LOAD && pgoff <= p.Off && p.Off+p.Memsz <= pgoff+memsz {
+			headers = append(headers, &p.ProgHeader)
+		}
+		if p.Type == elf.PT_LOAD {
+			loadables++
+		}
+	}
+	if len(headers) == 1 {
+		return headers[0], nil
+	}
+	// Some ELF files don't contain any program segments, e.g. .ko loadable kernel
+	// modules. Don't return an error in such cases.
+	if loadables == 0 {
+		return nil, nil
+	}
+	if len(headers) == 0 {
+		return nil, fmt.Errorf("no program header matches file offset %x and memory size %x", pgoff, memsz)
+	}
+
+	// Segments are mapped page aligned. In some cases, segments may be smaller
+	// than a page, which causes the next segment to start at a file offset that
+	// is logically on the same page if we were to align file offsets by page.
+	// Example:
+	//  LOAD           0x0000000000000000 0x0000000000400000 0x0000000000400000
+	//                 0x00000000000006fc 0x00000000000006fc  R E    0x200000
+	//  LOAD           0x0000000000000e10 0x0000000000600e10 0x0000000000600e10
+	//                 0x0000000000000230 0x0000000000000238  RW     0x200000
+	//
+	// In this case, perf records the following mappings for this executable:
+	// 0 0 [0xc0]: PERF_RECORD_MMAP2 87867/87867: [0x400000(0x1000) @ 0 00:3c 512041 0]: r-xp exename
+	// 0 0 [0xc0]: PERF_RECORD_MMAP2 87867/87867: [0x600000(0x2000) @ 0 00:3c 512041 0]: rw-p exename
+	//
+	// Both mappings have file offset 0. The first mapping is one page length and
+	// it can include only the first loadable segment. Due to page alignment, the
+	// second mapping starts also at file offset 0, and it spans two pages. It can
+	// include both the first and the second loadable segments. We must return the
+	// correct program header to compute the correct base offset.
+	//
+	// We cannot use the mapping protections to distinguish between segments,
+	// because protections are not passed through to this function.
+	// We cannot use the start address to differentiate between segments, because
+	// with ASLR, the mapping start address can be any value.
+	//
+	// We use a heuristic to compute the minimum mapping size required for a
+	// segment, assuming mappings are 4k page aligned, and return the segment that
+	// matches the given mapping size.
+	const pageSize = 4096
+
+	// The memory size based heuristic makes sense only if the mapping size is a
+	// multiple of 4k page size.
+	if memsz%pageSize != 0 {
+		return nil, fmt.Errorf("mapping size = %x and %d segments match the passed in mapping", memsz, len(headers))
+	}
+
+	// Return an error if no segment, or multiple segments match the size, so we can debug.
+	var ph *elf.ProgHeader
+	pageMask := ^uint64(pageSize - 1)
+	for _, h := range headers {
+		wantSize := (h.Vaddr+h.Memsz+pageSize-1)&pageMask - (h.Vaddr & pageMask)
+		if wantSize != memsz {
+			continue
+		}
+		if ph != nil {
+			return nil, fmt.Errorf("found second program header (%#v) that matches memsz %x, first program header is %#v", *h, memsz, *ph)
+		}
+		ph = h
+	}
+	if ph == nil {
+		return nil, fmt.Errorf("found %d matching program headers, but none matches mapping size %x", len(headers), memsz)
+	}
+	return ph, nil
+}
diff --git a/src/cmd/vendor/github.com/google/pprof/internal/graph/dotgraph.go b/src/cmd/vendor/github.com/google/pprof/internal/graph/dotgraph.go
index 8cb87da9af..8008675248 100644
--- a/src/cmd/vendor/github.com/google/pprof/internal/graph/dotgraph.go
+++ b/src/cmd/vendor/github.com/google/pprof/internal/graph/dotgraph.go
@@ -322,8 +322,8 @@ func (b *builder) addEdge(edge *Edge, from, to int, hasNodelets bool) {
 }
 
 // dotColor returns a color for the given score (between -1.0 and
-// 1.0), with -1.0 colored red, 0.0 colored grey, and 1.0 colored
-// green. If isBackground is true, then a light (low-saturation)
+// 1.0), with -1.0 colored green, 0.0 colored grey, and 1.0 colored
+// red. If isBackground is true, then a light (low-saturation)
 // color is returned (suitable for use as a background color);
 // otherwise, a darker color is returned (suitable for use as a
 // foreground color).
diff --git a/src/cmd/vendor/github.com/google/pprof/internal/measurement/measurement.go b/src/cmd/vendor/github.com/google/pprof/internal/measurement/measurement.go
index e95b261bc2..53325740a3 100644
--- a/src/cmd/vendor/github.com/google/pprof/internal/measurement/measurement.go
+++ b/src/cmd/vendor/github.com/google/pprof/internal/measurement/measurement.go
@@ -111,8 +111,9 @@ func compatibleValueTypes(v1, v2 *profile.ValueType) bool {
 	}
 
 	return v1.Unit == v2.Unit ||
-		(isTimeUnit(v1.Unit) && isTimeUnit(v2.Unit)) ||
-		(isMemoryUnit(v1.Unit) && isMemoryUnit(v2.Unit))
+		(timeUnits.sniffUnit(v1.Unit) != nil && timeUnits.sniffUnit(v2.Unit) != nil) ||
+		(memoryUnits.sniffUnit(v1.Unit) != nil && memoryUnits.sniffUnit(v2.Unit) != nil) ||
+		(gcuUnits.sniffUnit(v1.Unit) != nil && gcuUnits.sniffUnit(v2.Unit) != nil)
 }
 
 // Scale a measurement from an unit to a different unit and returns
@@ -124,12 +125,15 @@ func Scale(value int64, fromUnit, toUnit string) (float64, string) {
 		v, u := Scale(-value, fromUnit, toUnit)
 		return -v, u
 	}
-	if m, u, ok := memoryLabel(value, fromUnit, toUnit); ok {
+	if m, u, ok := memoryUnits.convertUnit(value, fromUnit, toUnit); ok {
 		return m, u
 	}
-	if t, u, ok := timeLabel(value, fromUnit, toUnit); ok {
+	if t, u, ok := timeUnits.convertUnit(value, fromUnit, toUnit); ok {
 		return t, u
 	}
+	if g, u, ok := gcuUnits.convertUnit(value, fromUnit, toUnit); ok {
+		return g, u
+	}
 	// Skip non-interesting units.
 	switch toUnit {
 	case "count", "sample", "unit", "minimum", "auto":
@@ -172,157 +176,121 @@ func Percentage(value, total int64) string {
 	}
 }
 
-// isMemoryUnit returns whether a name is recognized as a memory size
-// unit.
-func isMemoryUnit(unit string) bool {
-	switch strings.TrimSuffix(strings.ToLower(unit), "s") {
-	case "byte", "b", "kilobyte", "kb", "megabyte", "mb", "gigabyte", "gb":
-		return true
-	}
-	return false
+// unit includes a list of aliases representing a specific unit and a factor
+// which one can multiple a value in the specified unit by to get the value
+// in terms of the base unit.
+type unit struct {
+	canonicalName string
+	aliases       []string
+	factor        float64
 }
 
-func memoryLabel(value int64, fromUnit, toUnit string) (v float64, u string, ok bool) {
-	fromUnit = strings.TrimSuffix(strings.ToLower(fromUnit), "s")
-	toUnit = strings.TrimSuffix(strings.ToLower(toUnit), "s")
-
-	switch fromUnit {
-	case "byte", "b":
-	case "kb", "kbyte", "kilobyte":
-		value *= 1024
-	case "mb", "mbyte", "megabyte":
-		value *= 1024 * 1024
-	case "gb", "gbyte", "gigabyte":
-		value *= 1024 * 1024 * 1024
-	case "tb", "tbyte", "terabyte":
-		value *= 1024 * 1024 * 1024 * 1024
-	case "pb", "pbyte", "petabyte":
-		value *= 1024 * 1024 * 1024 * 1024 * 1024
-	default:
-		return 0, "", false
-	}
+// unitType includes a list of units that are within the same category (i.e.
+// memory or time units) and a default unit to use for this type of unit.
+type unitType struct {
+	defaultUnit unit
+	units       []unit
+}
 
-	if toUnit == "minimum" || toUnit == "auto" {
-		switch {
-		case value < 1024:
-			toUnit = "b"
-		case value < 1024*1024:
-			toUnit = "kb"
-		case value < 1024*1024*1024:
-			toUnit = "mb"
-		case value < 1024*1024*1024*1024:
-			toUnit = "gb"
-		case value < 1024*1024*1024*1024*1024:
-			toUnit = "tb"
-		default:
-			toUnit = "pb"
+// findByAlias returns the unit associated with the specified alias. It returns
+// nil if the unit with such alias is not found.
+func (ut unitType) findByAlias(alias string) *unit {
+	for _, u := range ut.units {
+		for _, a := range u.aliases {
+			if alias == a {
+				return &u
+			}
 		}
 	}
-
-	var output float64
-	switch toUnit {
-	default:
-		output, toUnit = float64(value), "B"
-	case "kb", "kbyte", "kilobyte":
-		output, toUnit = float64(value)/1024, "kB"
-	case "mb", "mbyte", "megabyte":
-		output, toUnit = float64(value)/(1024*1024), "MB"
-	case "gb", "gbyte", "gigabyte":
-		output, toUnit = float64(value)/(1024*1024*1024), "GB"
-	case "tb", "tbyte", "terabyte":
-		output, toUnit = float64(value)/(1024*1024*1024*1024), "TB"
-	case "pb", "pbyte", "petabyte":
-		output, toUnit = float64(value)/(1024*1024*1024*1024*1024), "PB"
-	}
-	return output, toUnit, true
+	return nil
 }
 
-// isTimeUnit returns whether a name is recognized as a time unit.
-func isTimeUnit(unit string) bool {
+// sniffUnit simpifies the input alias and returns the unit associated with the
+// specified alias. It returns nil if the unit with such alias is not found.
+func (ut unitType) sniffUnit(unit string) *unit {
 	unit = strings.ToLower(unit)
 	if len(unit) > 2 {
 		unit = strings.TrimSuffix(unit, "s")
 	}
-
-	switch unit {
-	case "nanosecond", "ns", "microsecond", "millisecond", "ms", "s", "second", "sec", "hr", "day", "week", "year":
-		return true
-	}
-	return false
+	return ut.findByAlias(unit)
 }
 
-func timeLabel(value int64, fromUnit, toUnit string) (v float64, u string, ok bool) {
-	fromUnit = strings.ToLower(fromUnit)
-	if len(fromUnit) > 2 {
-		fromUnit = strings.TrimSuffix(fromUnit, "s")
+// autoScale takes in the value with units of the base unit and returns
+// that value scaled to a reasonable unit if a reasonable unit is
+// found.
+func (ut unitType) autoScale(value float64) (float64, string, bool) {
+	var f float64
+	var unit string
+	for _, u := range ut.units {
+		if u.factor >= f && (value/u.factor) >= 1.0 {
+			f = u.factor
+			unit = u.canonicalName
+		}
 	}
-
-	toUnit = strings.ToLower(toUnit)
-	if len(toUnit) > 2 {
-		toUnit = strings.TrimSuffix(toUnit, "s")
+	if f == 0 {
+		return 0, "", false
 	}
+	return value / f, unit, true
+}
 
-	var d time.Duration
-	switch fromUnit {
-	case "nanosecond", "ns":
-		d = time.Duration(value) * time.Nanosecond
-	case "microsecond":
-		d = time.Duration(value) * time.Microsecond
-	case "millisecond", "ms":
-		d = time.Duration(value) * time.Millisecond
-	case "second", "sec", "s":
-		d = time.Duration(value) * time.Second
-	case "cycle":
-		return float64(value), "", true
-	default:
+// convertUnit converts a value from the fromUnit to the toUnit, autoscaling
+// the value if the toUnit is "minimum" or "auto". If the fromUnit is not
+// included in the unitType, then a false boolean will be returned. If the
+// toUnit is not in the unitType, the value will be returned in terms of the
+// default unitType.
+func (ut unitType) convertUnit(value int64, fromUnitStr, toUnitStr string) (float64, string, bool) {
+	fromUnit := ut.sniffUnit(fromUnitStr)
+	if fromUnit == nil {
 		return 0, "", false
 	}
-
-	if toUnit == "minimum" || toUnit == "auto" {
-		switch {
-		case d < 1*time.Microsecond:
-			toUnit = "ns"
-		case d < 1*time.Millisecond:
-			toUnit = "us"
-		case d < 1*time.Second:
-			toUnit = "ms"
-		case d < 1*time.Minute:
-			toUnit = "sec"
-		case d < 1*time.Hour:
-			toUnit = "min"
-		case d < 24*time.Hour:
-			toUnit = "hour"
-		case d < 15*24*time.Hour:
-			toUnit = "day"
-		case d < 120*24*time.Hour:
-			toUnit = "week"
-		default:
-			toUnit = "year"
+	v := float64(value) * fromUnit.factor
+	if toUnitStr == "minimum" || toUnitStr == "auto" {
+		if v, u, ok := ut.autoScale(v); ok {
+			return v, u, true
 		}
+		return v / ut.defaultUnit.factor, ut.defaultUnit.canonicalName, true
 	}
-
-	var output float64
-	dd := float64(d)
-	switch toUnit {
-	case "ns", "nanosecond":
-		output, toUnit = dd/float64(time.Nanosecond), "ns"
-	case "us", "microsecond":
-		output, toUnit = dd/float64(time.Microsecond), "us"
-	case "ms", "millisecond":
-		output, toUnit = dd/float64(time.Millisecond), "ms"
-	case "min", "minute":
-		output, toUnit = dd/float64(time.Minute), "mins"
-	case "hour", "hr":
-		output, toUnit = dd/float64(time.Hour), "hrs"
-	case "day":
-		output, toUnit = dd/float64(24*time.Hour), "days"
-	case "week", "wk":
-		output, toUnit = dd/float64(7*24*time.Hour), "wks"
-	case "year", "yr":
-		output, toUnit = dd/float64(365*24*time.Hour), "yrs"
-	default:
-		// "sec", "second", "s" handled by default case.
-		output, toUnit = dd/float64(time.Second), "s"
+	toUnit := ut.sniffUnit(toUnitStr)
+	if toUnit == nil {
+		return v / ut.defaultUnit.factor, ut.defaultUnit.canonicalName, true
 	}
-	return output, toUnit, true
+	return v / toUnit.factor, toUnit.canonicalName, true
+}
+
+var memoryUnits = unitType{
+	units: []unit{
+		{"B", []string{"b", "byte"}, 1},
+		{"kB", []string{"kb", "kbyte", "kilobyte"}, float64(1 << 10)},
+		{"MB", []string{"mb", "mbyte", "megabyte"}, float64(1 << 20)},
+		{"GB", []string{"gb", "gbyte", "gigabyte"}, float64(1 << 30)},
+		{"TB", []string{"tb", "tbyte", "terabyte"}, float64(1 << 40)},
+		{"PB", []string{"pb", "pbyte", "petabyte"}, float64(1 << 50)},
+	},
+	defaultUnit: unit{"B", []string{"b", "byte"}, 1},
+}
+
+var timeUnits = unitType{
+	units: []unit{
+		{"ns", []string{"ns", "nanosecond"}, float64(time.Nanosecond)},
+		{"us", []string{"μs", "us", "microsecond"}, float64(time.Microsecond)},
+		{"ms", []string{"ms", "millisecond"}, float64(time.Millisecond)},
+		{"s", []string{"s", "sec", "second"}, float64(time.Second)},
+		{"hrs", []string{"hour", "hr"}, float64(time.Hour)},
+	},
+	defaultUnit: unit{"s", []string{}, float64(time.Second)},
+}
+
+var gcuUnits = unitType{
+	units: []unit{
+		{"n*GCU", []string{"nanogcu"}, 1e-9},
+		{"u*GCU", []string{"microgcu"}, 1e-6},
+		{"m*GCU", []string{"milligcu"}, 1e-3},
+		{"GCU", []string{"gcu"}, 1},
+		{"k*GCU", []string{"kilogcu"}, 1e3},
+		{"M*GCU", []string{"megagcu"}, 1e6},
+		{"G*GCU", []string{"gigagcu"}, 1e9},
+		{"T*GCU", []string{"teragcu"}, 1e12},
+		{"P*GCU", []string{"petagcu"}, 1e15},
+	},
+	defaultUnit: unit{"GCU", []string{}, 1.0},
 }
diff --git a/src/cmd/vendor/github.com/google/pprof/internal/report/source.go b/src/cmd/vendor/github.com/google/pprof/internal/report/source.go
index b480535439..4f841eff5d 100644
--- a/src/cmd/vendor/github.com/google/pprof/internal/report/source.go
+++ b/src/cmd/vendor/github.com/google/pprof/internal/report/source.go
@@ -24,12 +24,15 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"regexp"
+	"sort"
 	"strconv"
 	"strings"
 
 	"github.com/google/pprof/internal/graph"
 	"github.com/google/pprof/internal/measurement"
 	"github.com/google/pprof/internal/plugin"
+	"github.com/google/pprof/profile"
 )
 
 // printSource prints an annotated source listing, include all
@@ -126,191 +129,554 @@ func printWebSource(w io.Writer, rpt *Report, obj plugin.ObjTool) error {
 	return nil
 }
 
+// sourcePrinter holds state needed for generating source+asm HTML listing.
+type sourcePrinter struct {
+	reader     *sourceReader
+	objectTool plugin.ObjTool
+	objects    map[string]plugin.ObjFile  // Opened object files
+	sym        *regexp.Regexp             // May be nil
+	files      map[string]*sourceFile     // Set of files to print.
+	insts      map[uint64]instructionInfo // Instructions of interest (keyed by address).
+
+	// Set of function names that we are interested in (because they had
+	// a sample and match sym).
+	interest map[string]bool
+
+	// Mapping from system function names to printable names.
+	prettyNames map[string]string
+}
+
+// instructionInfo holds collected information for an instruction.
+type instructionInfo struct {
+	objAddr   uint64 // Address in object file (with base subtracted out)
+	length    int    // Instruction length in bytes
+	disasm    string // Disassembly of instruction
+	file      string // For top-level function in which instruction occurs
+	line      int    // For top-level function in which instruction occurs
+	flat, cum int64  // Samples to report (divisor already applied)
+}
+
+// sourceFile contains collected information for files we will print.
+type sourceFile struct {
+	fname    string
+	cum      int64
+	flat     int64
+	lines    map[int][]sourceInst // Instructions to show per line
+	funcName map[int]string       // Function name per line
+}
+
+// sourceInst holds information for an instruction to be displayed.
+type sourceInst struct {
+	addr  uint64
+	stack []callID // Inlined call-stack
+}
+
+// sourceFunction contains information for a contiguous range of lines per function we
+// will print.
+type sourceFunction struct {
+	name       string
+	begin, end int // Line numbers (end is not included in the range)
+	flat, cum  int64
+}
+
+// addressRange is a range of addresses plus the object file that contains it.
+type addressRange struct {
+	begin, end uint64
+	obj        plugin.ObjFile
+	mapping    *profile.Mapping
+	score      int64 // Used to order ranges for processing
+}
+
 // PrintWebList prints annotated source listing of rpt to w.
+// rpt.prof should contain inlined call info.
 func PrintWebList(w io.Writer, rpt *Report, obj plugin.ObjTool, maxFiles int) error {
-	o := rpt.options
-	g := rpt.newGraph(nil)
+	sourcePath := rpt.options.SourcePath
+	if sourcePath == "" {
+		wd, err := os.Getwd()
+		if err != nil {
+			return fmt.Errorf("could not stat current dir: %v", err)
+		}
+		sourcePath = wd
+	}
+	sp := newSourcePrinter(rpt, obj, sourcePath)
+	sp.print(w, maxFiles, rpt)
+	sp.close()
+	return nil
+}
+
+func newSourcePrinter(rpt *Report, obj plugin.ObjTool, sourcePath string) *sourcePrinter {
+	sp := &sourcePrinter{
+		reader:      newSourceReader(sourcePath, rpt.options.TrimPath),
+		objectTool:  obj,
+		objects:     map[string]plugin.ObjFile{},
+		sym:         rpt.options.Symbol,
+		files:       map[string]*sourceFile{},
+		insts:       map[uint64]instructionInfo{},
+		prettyNames: map[string]string{},
+		interest:    map[string]bool{},
+	}
 
 	// If the regexp source can be parsed as an address, also match
 	// functions that land on that address.
 	var address *uint64
-	if hex, err := strconv.ParseUint(o.Symbol.String(), 0, 64); err == nil {
-		address = &hex
+	if sp.sym != nil {
+		if hex, err := strconv.ParseUint(sp.sym.String(), 0, 64); err == nil {
+			address = &hex
+		}
 	}
 
-	sourcePath := o.SourcePath
-	if sourcePath == "" {
-		wd, err := os.Getwd()
-		if err != nil {
-			return fmt.Errorf("could not stat current dir: %v", err)
+	addrs := map[uint64]bool{}
+	flat := map[uint64]int64{}
+	cum := map[uint64]int64{}
+
+	// Record an interest in the function corresponding to lines[index].
+	markInterest := func(addr uint64, lines []profile.Line, index int) {
+		fn := lines[index]
+		if fn.Function == nil {
+			return
 		}
-		sourcePath = wd
+		sp.interest[fn.Function.Name] = true
+		sp.interest[fn.Function.SystemName] = true
+		addrs[addr] = true
 	}
-	reader := newSourceReader(sourcePath, o.TrimPath)
 
-	type fileFunction struct {
-		fileName, functionName string
+	// See if sp.sym matches line.
+	matches := func(line profile.Line) bool {
+		if line.Function == nil {
+			return false
+		}
+		return sp.sym.MatchString(line.Function.Name) ||
+			sp.sym.MatchString(line.Function.SystemName) ||
+			sp.sym.MatchString(line.Function.Filename)
 	}
 
-	// Extract interesting symbols from binary files in the profile and
-	// classify samples per symbol.
-	symbols := symbolsFromBinaries(rpt.prof, g, o.Symbol, address, obj)
-	symNodes := nodesPerSymbol(g.Nodes, symbols)
+	// Extract sample counts and compute set of interesting functions.
+	for _, sample := range rpt.prof.Sample {
+		value := rpt.options.SampleValue(sample.Value)
+		if rpt.options.SampleMeanDivisor != nil {
+			div := rpt.options.SampleMeanDivisor(sample.Value)
+			if div != 0 {
+				value /= div
+			}
+		}
+
+		// Find call-sites matching sym.
+		for i := len(sample.Location) - 1; i >= 0; i-- {
+			loc := sample.Location[i]
+			for _, line := range loc.Line {
+				if line.Function == nil {
+					continue
+				}
+				sp.prettyNames[line.Function.SystemName] = line.Function.Name
+			}
 
-	// Identify sources associated to a symbol by examining
-	// symbol samples. Classify samples per source file.
-	fileNodes := make(map[fileFunction]graph.Nodes)
-	if len(symNodes) == 0 {
-		for _, n := range g.Nodes {
-			if n.Info.File == "" || !o.Symbol.MatchString(n.Info.Name) {
+			cum[loc.Address] += value
+			if i == 0 {
+				flat[loc.Address] += value
+			}
+
+			if sp.sym == nil || (address != nil && loc.Address == *address) {
+				// Interested in top-level entry of stack.
+				if len(loc.Line) > 0 {
+					markInterest(loc.Address, loc.Line, len(loc.Line)-1)
+				}
 				continue
 			}
-			ff := fileFunction{n.Info.File, n.Info.Name}
-			fileNodes[ff] = append(fileNodes[ff], n)
-		}
-	} else {
-		for _, nodes := range symNodes {
-			for _, n := range nodes {
-				if n.Info.File != "" {
-					ff := fileFunction{n.Info.File, n.Info.Name}
-					fileNodes[ff] = append(fileNodes[ff], n)
+
+			// Seach in inlined stack for a match.
+			matchFile := (loc.Mapping != nil && sp.sym.MatchString(loc.Mapping.File))
+			for j, line := range loc.Line {
+				if (j == 0 && matchFile) || matches(line) {
+					markInterest(loc.Address, loc.Line, j)
 				}
 			}
 		}
 	}
 
-	if len(fileNodes) == 0 {
-		return fmt.Errorf("no source information for %s", o.Symbol.String())
-	}
-
-	sourceFiles := make(graph.Nodes, 0, len(fileNodes))
-	for _, nodes := range fileNodes {
-		sNode := *nodes[0]
-		sNode.Flat, sNode.Cum = nodes.Sum()
-		sourceFiles = append(sourceFiles, &sNode)
-	}
+	sp.expandAddresses(rpt, addrs, flat)
+	sp.initSamples(flat, cum)
+	return sp
+}
 
-	// Limit number of files printed?
-	if maxFiles < 0 {
-		sourceFiles.Sort(graph.FileOrder)
-	} else {
-		sourceFiles.Sort(graph.FlatNameOrder)
-		if maxFiles < len(sourceFiles) {
-			sourceFiles = sourceFiles[:maxFiles]
+func (sp *sourcePrinter) close() {
+	for _, objFile := range sp.objects {
+		if objFile != nil {
+			objFile.Close()
 		}
 	}
+}
 
-	// Print each file associated with this function.
-	for _, n := range sourceFiles {
-		ff := fileFunction{n.Info.File, n.Info.Name}
-		fns := fileNodes[ff]
+func (sp *sourcePrinter) expandAddresses(rpt *Report, addrs map[uint64]bool, flat map[uint64]int64) {
+	// We found interesting addresses (ones with non-zero samples) above.
+	// Get covering address ranges and disassemble the ranges.
+	ranges := sp.splitIntoRanges(rpt.prof, addrs, flat)
 
-		asm := assemblyPerSourceLine(symbols, fns, ff.fileName, obj, o.IntelSyntax)
-		start, end := sourceCoordinates(asm)
+	// Trim ranges if there are too many.
+	const maxRanges = 25
+	sort.Slice(ranges, func(i, j int) bool {
+		return ranges[i].score > ranges[j].score
+	})
+	if len(ranges) > maxRanges {
+		ranges = ranges[:maxRanges]
+	}
 
-		fnodes, path, err := getSourceFromFile(ff.fileName, reader, fns, start, end)
+	for _, r := range ranges {
+		base := r.obj.Base()
+		insts, err := sp.objectTool.Disasm(r.mapping.File, r.begin-base, r.end-base,
+			rpt.options.IntelSyntax)
 		if err != nil {
-			fnodes, path = getMissingFunctionSource(ff.fileName, asm, start, end)
+			// TODO(sanjay): Report that the covered addresses are missing.
+			continue
 		}
 
-		printFunctionHeader(w, ff.functionName, path, n.Flat, n.Cum, rpt)
-		for _, fn := range fnodes {
-			printFunctionSourceLine(w, fn, asm[fn.Info.Lineno], reader, rpt)
+		var lastFrames []plugin.Frame
+		var lastAddr, maxAddr uint64
+		for i, inst := range insts {
+			addr := inst.Addr + base
+
+			// Guard against duplicate output from Disasm.
+			if addr <= maxAddr {
+				continue
+			}
+			maxAddr = addr
+
+			length := 1
+			if i+1 < len(insts) && insts[i+1].Addr > inst.Addr {
+				// Extend to next instruction.
+				length = int(insts[i+1].Addr - inst.Addr)
+			}
+
+			// Get inlined-call-stack for address.
+			frames, err := r.obj.SourceLine(addr)
+			if err != nil {
+				// Construct a frame from disassembler output.
+				frames = []plugin.Frame{{Func: inst.Function, File: inst.File, Line: inst.Line}}
+			}
+
+			x := instructionInfo{objAddr: inst.Addr, length: length, disasm: inst.Text}
+			if len(frames) > 0 {
+				// We could consider using the outer-most caller's source
+				// location so we give the some hint as to where the
+				// inlining happened that led to this instruction. So for
+				// example, suppose we have the following (inlined) call
+				// chains for this instruction:
+				//   F1->G->H
+				//   F2->G->H
+				// We could tag the instructions from the first call with
+				// F1 and instructions from the second call with F2. But
+				// that leads to a somewhat confusing display. So for now,
+				// we stick with just the inner-most location (i.e., H).
+				// In the future we will consider changing the display to
+				// make caller info more visible.
+				index := 0 // Inner-most frame
+				x.file = frames[index].File
+				x.line = frames[index].Line
+			}
+			sp.insts[addr] = x
+
+			// We sometimes get instructions with a zero reported line number.
+			// Make such instructions have the same line info as the preceding
+			// instruction, if an earlier instruction is found close enough.
+			const neighborhood = 32
+			if len(frames) > 0 && frames[0].Line != 0 {
+				lastFrames = frames
+				lastAddr = addr
+			} else if (addr-lastAddr <= neighborhood) && lastFrames != nil {
+				frames = lastFrames
+			}
+
+			// See if the stack contains a function we are interested in.
+			for i, f := range frames {
+				if !sp.interest[f.Func] {
+					continue
+				}
+
+				// Record sub-stack under frame's file/line.
+				fname := canonicalizeFileName(f.File)
+				file := sp.files[fname]
+				if file == nil {
+					file = &sourceFile{
+						fname:    fname,
+						lines:    map[int][]sourceInst{},
+						funcName: map[int]string{},
+					}
+					sp.files[fname] = file
+				}
+				callees := frames[:i]
+				stack := make([]callID, 0, len(callees))
+				for j := len(callees) - 1; j >= 0; j-- { // Reverse so caller is first
+					stack = append(stack, callID{
+						file: callees[j].File,
+						line: callees[j].Line,
+					})
+				}
+				file.lines[f.Line] = append(file.lines[f.Line], sourceInst{addr, stack})
+
+				// Remember the first function name encountered per source line
+				// and assume that that line belongs to that function.
+				if _, ok := file.funcName[f.Line]; !ok {
+					file.funcName[f.Line] = f.Func
+				}
+			}
 		}
-		printFunctionClosing(w)
 	}
-	return nil
 }
 
-// sourceCoordinates returns the lowest and highest line numbers from
-// a set of assembly statements.
-func sourceCoordinates(asm map[int][]assemblyInstruction) (start, end int) {
-	for l := range asm {
-		if start == 0 || l < start {
-			start = l
+// splitIntoRanges converts the set of addresses we are interested in into a set of address
+// ranges to disassemble.
+func (sp *sourcePrinter) splitIntoRanges(prof *profile.Profile, set map[uint64]bool, flat map[uint64]int64) []addressRange {
+	// List of mappings so we can stop expanding address ranges at mapping boundaries.
+	mappings := append([]*profile.Mapping{}, prof.Mapping...)
+	sort.Slice(mappings, func(i, j int) bool { return mappings[i].Start < mappings[j].Start })
+
+	var result []addressRange
+	addrs := make([]uint64, 0, len(set))
+	for addr := range set {
+		addrs = append(addrs, addr)
+	}
+	sort.Slice(addrs, func(i, j int) bool { return addrs[i] < addrs[j] })
+
+	mappingIndex := 0
+	const expand = 500 // How much to expand range to pick up nearby addresses.
+	for i, n := 0, len(addrs); i < n; {
+		begin, end := addrs[i], addrs[i]
+		sum := flat[begin]
+		i++
+
+		// Advance to mapping containing addrs[i]
+		for mappingIndex < len(mappings) && mappings[mappingIndex].Limit <= begin {
+			mappingIndex++
+		}
+		if mappingIndex >= len(mappings) {
+			// TODO(sanjay): Report missed address and its samples.
+			break
+		}
+		m := mappings[mappingIndex]
+		obj := sp.objectFile(m)
+		if obj == nil {
+			// TODO(sanjay): Report missed address and its samples.
+			continue
+		}
+
+		// Find following addresses that are close enough to addrs[i].
+		for i < n && addrs[i] <= end+2*expand && addrs[i] < m.Limit {
+			// When we expand ranges by "expand" on either side, the ranges
+			// for addrs[i] and addrs[i-1] will merge.
+			end = addrs[i]
+			sum += flat[end]
+			i++
 		}
-		if end == 0 || l > end {
-			end = l
+		if m.Start-begin >= expand {
+			begin -= expand
+		} else {
+			begin = m.Start
+		}
+		if m.Limit-end >= expand {
+			end += expand
+		} else {
+			end = m.Limit
 		}
+
+		result = append(result, addressRange{begin, end, obj, m, sum})
 	}
-	return start, end
+	return result
 }
 
-// assemblyPerSourceLine disassembles the binary containing a symbol
-// and classifies the assembly instructions according to its
-// corresponding source line, annotating them with a set of samples.
-func assemblyPerSourceLine(objSyms []*objSymbol, rs graph.Nodes, src string, obj plugin.ObjTool, intelSyntax bool) map[int][]assemblyInstruction {
-	assembly := make(map[int][]assemblyInstruction)
-	// Identify symbol to use for this collection of samples.
-	o := findMatchingSymbol(objSyms, rs)
-	if o == nil {
-		return assembly
+func (sp *sourcePrinter) initSamples(flat, cum map[uint64]int64) {
+	for addr, inst := range sp.insts {
+		// Move all samples that were assigned to the middle of an instruction to the
+		// beginning of that instruction. This takes care of samples that were recorded
+		// against pc+1.
+		instEnd := addr + uint64(inst.length)
+		for p := addr; p < instEnd; p++ {
+			inst.flat += flat[p]
+			inst.cum += cum[p]
+		}
+		sp.insts[addr] = inst
 	}
+}
 
-	// Extract assembly for matched symbol
-	insts, err := obj.Disasm(o.sym.File, o.sym.Start, o.sym.End, intelSyntax)
-	if err != nil {
-		return assembly
-	}
-
-	srcBase := filepath.Base(src)
-	anodes := annotateAssembly(insts, rs, o.base)
-	var lineno = 0
-	var prevline = 0
-	for _, an := range anodes {
-		// Do not rely solely on the line number produced by Disasm
-		// since it is not what we want in the presence of inlining.
-		//
-		// E.g., suppose we are printing source code for F and this
-		// instruction is from H where F called G called H and both
-		// of those calls were inlined. We want to use the line
-		// number from F, not from H (which is what Disasm gives us).
-		//
-		// So find the outer-most linenumber in the source file.
-		found := false
-		if frames, err := o.file.SourceLine(an.address + o.base); err == nil {
-			for i := len(frames) - 1; i >= 0; i-- {
-				if filepath.Base(frames[i].File) == srcBase {
-					for j := i - 1; j >= 0; j-- {
-						an.inlineCalls = append(an.inlineCalls, callID{frames[j].File, frames[j].Line})
-					}
-					lineno = frames[i].Line
-					found = true
-					break
+func (sp *sourcePrinter) print(w io.Writer, maxFiles int, rpt *Report) {
+	// Finalize per-file counts.
+	for _, file := range sp.files {
+		seen := map[uint64]bool{}
+		for _, line := range file.lines {
+			for _, x := range line {
+				if seen[x.addr] {
+					// Same address can be displayed multiple times in a file
+					// (e.g., if we show multiple inlined functions).
+					// Avoid double-counting samples in this case.
+					continue
 				}
+				seen[x.addr] = true
+				inst := sp.insts[x.addr]
+				file.cum += inst.cum
+				file.flat += inst.flat
 			}
 		}
-		if !found && filepath.Base(an.file) == srcBase {
-			lineno = an.line
+	}
+
+	// Get sorted list of files to print.
+	var files []*sourceFile
+	for _, f := range sp.files {
+		files = append(files, f)
+	}
+	order := func(i, j int) bool { return files[i].flat > files[j].flat }
+	if maxFiles < 0 {
+		// Order by name for compatibility with old code.
+		order = func(i, j int) bool { return files[i].fname < files[j].fname }
+		maxFiles = len(files)
+	}
+	sort.Slice(files, order)
+	for i, f := range files {
+		if i < maxFiles {
+			sp.printFile(w, f, rpt)
+		}
+	}
+}
+
+func (sp *sourcePrinter) printFile(w io.Writer, f *sourceFile, rpt *Report) {
+	for _, fn := range sp.functions(f) {
+		if fn.cum == 0 {
+			continue
 		}
+		printFunctionHeader(w, fn.name, f.fname, fn.flat, fn.cum, rpt)
+		var asm []assemblyInstruction
+		for l := fn.begin; l < fn.end; l++ {
+			lineContents, ok := sp.reader.line(f.fname, l)
+			if !ok {
+				if len(f.lines[l]) == 0 {
+					// Outside of range of valid lines and nothing to print.
+					continue
+				}
+				if l == 0 {
+					// Line number 0 shows up if line number is not known.
+					lineContents = "<instructions with unknown line numbers>"
+				} else {
+					// Past end of file, but have data to print.
+					lineContents = "???"
+				}
+			}
 
-		if lineno != 0 {
-			if lineno != prevline {
-				// This instruction starts a new block
-				// of contiguous instructions on this line.
-				an.startsBlock = true
+			// Make list of assembly instructions.
+			asm = asm[:0]
+			var flatSum, cumSum int64
+			var lastAddr uint64
+			for _, inst := range f.lines[l] {
+				addr := inst.addr
+				x := sp.insts[addr]
+				flatSum += x.flat
+				cumSum += x.cum
+				startsBlock := (addr != lastAddr+uint64(sp.insts[lastAddr].length))
+				lastAddr = addr
+
+				// divisors already applied, so leave flatDiv,cumDiv as 0
+				asm = append(asm, assemblyInstruction{
+					address:     x.objAddr,
+					instruction: x.disasm,
+					function:    fn.name,
+					file:        x.file,
+					line:        x.line,
+					flat:        x.flat,
+					cum:         x.cum,
+					startsBlock: startsBlock,
+					inlineCalls: inst.stack,
+				})
 			}
-			prevline = lineno
-			assembly[lineno] = append(assembly[lineno], an)
+
+			printFunctionSourceLine(w, l, flatSum, cumSum, lineContents, asm, sp.reader, rpt)
 		}
+		printFunctionClosing(w)
 	}
-
-	return assembly
 }
 
-// findMatchingSymbol looks for the symbol that corresponds to a set
-// of samples, by comparing their addresses.
-func findMatchingSymbol(objSyms []*objSymbol, ns graph.Nodes) *objSymbol {
-	for _, n := range ns {
-		for _, o := range objSyms {
-			if filepath.Base(o.sym.File) == filepath.Base(n.Info.Objfile) &&
-				o.sym.Start <= n.Info.Address-o.base &&
-				n.Info.Address-o.base <= o.sym.End {
-				return o
+// functions splits apart the lines to show in a file into a list of per-function ranges.
+func (sp *sourcePrinter) functions(f *sourceFile) []sourceFunction {
+	var funcs []sourceFunction
+
+	// Get interesting lines in sorted order.
+	lines := make([]int, 0, len(f.lines))
+	for l := range f.lines {
+		lines = append(lines, l)
+	}
+	sort.Ints(lines)
+
+	// Merge adjacent lines that are in same function and not too far apart.
+	const mergeLimit = 20
+	for _, l := range lines {
+		name := f.funcName[l]
+		if pretty, ok := sp.prettyNames[name]; ok {
+			// Use demangled name if available.
+			name = pretty
+		}
+
+		fn := sourceFunction{name: name, begin: l, end: l + 1}
+		for _, x := range f.lines[l] {
+			inst := sp.insts[x.addr]
+			fn.flat += inst.flat
+			fn.cum += inst.cum
+		}
+
+		// See if we should merge into preceding function.
+		if len(funcs) > 0 {
+			last := funcs[len(funcs)-1]
+			if l-last.end < mergeLimit && last.name == name {
+				last.end = l + 1
+				last.flat += fn.flat
+				last.cum += fn.cum
+				funcs[len(funcs)-1] = last
+				continue
 			}
 		}
+
+		// Add new function.
+		funcs = append(funcs, fn)
 	}
-	return nil
+
+	// Expand function boundaries to show neighborhood.
+	const expand = 5
+	for i, f := range funcs {
+		if i == 0 {
+			// Extend backwards, stopping at line number 1, but do not disturb 0
+			// since that is a special line number that can show up when addr2line
+			// cannot determine the real line number.
+			if f.begin > expand {
+				f.begin -= expand
+			} else if f.begin > 1 {
+				f.begin = 1
+			}
+		} else {
+			// Find gap from predecessor and divide between predecessor and f.
+			halfGap := (f.begin - funcs[i-1].end) / 2
+			if halfGap > expand {
+				halfGap = expand
+			}
+			funcs[i-1].end += halfGap
+			f.begin -= halfGap
+		}
+		funcs[i] = f
+	}
+
+	// Also extend the ending point of the last function.
+	if len(funcs) > 0 {
+		funcs[len(funcs)-1].end += expand
+	}
+
+	return funcs
+}
+
+// objectFile return the object for the named file, opening it if necessary.
+// It returns nil on error.
+func (sp *sourcePrinter) objectFile(m *profile.Mapping) plugin.ObjFile {
+	if object, ok := sp.objects[m.File]; ok {
+		return object // May be nil if we detected an error earlier.
+	}
+	object, err := sp.objectTool.Open(m.File, m.Start, m.Limit, m.Offset)
+	if err != nil {
+		object = nil
+	}
+	sp.objects[m.File] = object // Cache even on error.
+	return object
 }
 
 // printHeader prints the page header for a weblist report.
@@ -348,22 +714,23 @@ func printFunctionHeader(w io.Writer, name, path string, flatSum, cumSum int64,
 }
 
 // printFunctionSourceLine prints a source line and the corresponding assembly.
-func printFunctionSourceLine(w io.Writer, fn *graph.Node, assembly []assemblyInstruction, reader *sourceReader, rpt *Report) {
+func printFunctionSourceLine(w io.Writer, lineNo int, flat, cum int64, lineContents string,
+	assembly []assemblyInstruction, reader *sourceReader, rpt *Report) {
 	if len(assembly) == 0 {
 		fmt.Fprintf(w,
 			"<span class=line> %6d</span> <span class=nop>  %10s %10s %8s  %s </span>\n",
-			fn.Info.Lineno,
-			valueOrDot(fn.Flat, rpt), valueOrDot(fn.Cum, rpt),
-			"", template.HTMLEscapeString(fn.Info.Name))
+			lineNo,
+			valueOrDot(flat, rpt), valueOrDot(cum, rpt),
+			"", template.HTMLEscapeString(lineContents))
 		return
 	}
 
 	fmt.Fprintf(w,
 		"<span class=line> %6d</span> <span class=deadsrc>  %10s %10s %8s  %s </span>",
-		fn.Info.Lineno,
-		valueOrDot(fn.Flat, rpt), valueOrDot(fn.Cum, rpt),
-		"", template.HTMLEscapeString(fn.Info.Name))
-	srcIndent := indentation(fn.Info.Name)
+		lineNo,
+		valueOrDot(flat, rpt), valueOrDot(cum, rpt),
+		"", template.HTMLEscapeString(lineContents))
+	srcIndent := indentation(lineContents)
 	fmt.Fprint(w, "<span class=asm>")
 	var curCalls []callID
 	for i, an := range assembly {
@@ -374,15 +741,9 @@ func printFunctionSourceLine(w io.Writer, fn *graph.Node, assembly []assemblyIns
 
 		var fileline string
 		if an.file != "" {
-			fileline = fmt.Sprintf("%s:%d", template.HTMLEscapeString(an.file), an.line)
+			fileline = fmt.Sprintf("%s:%d", template.HTMLEscapeString(filepath.Base(an.file)), an.line)
 		}
 		flat, cum := an.flat, an.cum
-		if an.flatDiv != 0 {
-			flat = flat / an.flatDiv
-		}
-		if an.cumDiv != 0 {
-			cum = cum / an.cumDiv
-		}
 
 		// Print inlined call context.
 		for j, c := range an.inlineCalls {
@@ -398,15 +759,18 @@ func printFunctionSourceLine(w io.Writer, fn *graph.Node, assembly []assemblyIns
 			text := strings.Repeat(" ", srcIndent+4+4*j) + strings.TrimSpace(fline)
 			fmt.Fprintf(w, " %8s %10s %10s %8s  <span class=inlinesrc>%s</span> <span class=unimportant>%s:%d</span>\n",
 				"", "", "", "",
-				template.HTMLEscapeString(fmt.Sprintf("%-80s", text)),
+				template.HTMLEscapeString(rightPad(text, 80)),
 				template.HTMLEscapeString(filepath.Base(c.file)), c.line)
 		}
 		curCalls = an.inlineCalls
 		text := strings.Repeat(" ", srcIndent+4+4*len(curCalls)) + an.instruction
 		fmt.Fprintf(w, " %8s %10s %10s %8x: %s <span class=unimportant>%s</span>\n",
 			"", valueOrDot(flat, rpt), valueOrDot(cum, rpt), an.address,
-			template.HTMLEscapeString(fmt.Sprintf("%-80s", text)),
-			template.HTMLEscapeString(fileline))
+			template.HTMLEscapeString(rightPad(text, 80)),
+			// fileline should not be escaped since it was formed by appending
+			// line number (just digits) to an escaped file name. Escaping here
+			// would cause double-escaping of file name.
+			fileline)
 	}
 	fmt.Fprintln(w, "</span>")
 }
@@ -482,36 +846,6 @@ func getSourceFromFile(file string, reader *sourceReader, fns graph.Nodes, start
 	return src, file, nil
 }
 
-// getMissingFunctionSource creates a dummy function body to point to
-// the source file and annotates it with the samples in asm.
-func getMissingFunctionSource(filename string, asm map[int][]assemblyInstruction, start, end int) (graph.Nodes, string) {
-	var fnodes graph.Nodes
-	for i := start; i <= end; i++ {
-		insts := asm[i]
-		if len(insts) == 0 {
-			continue
-		}
-		var group assemblyInstruction
-		for _, insn := range insts {
-			group.flat += insn.flat
-			group.cum += insn.cum
-			group.flatDiv += insn.flatDiv
-			group.cumDiv += insn.cumDiv
-		}
-		flat := group.flatValue()
-		cum := group.cumValue()
-		fnodes = append(fnodes, &graph.Node{
-			Info: graph.NodeInfo{
-				Name:   "???",
-				Lineno: i,
-			},
-			Flat: flat,
-			Cum:  cum,
-		})
-	}
-	return fnodes, filename
-}
-
 // sourceReader provides access to source code with caching of file contents.
 type sourceReader struct {
 	// searchPath is a filepath.ListSeparator-separated list of directories where
@@ -543,6 +877,7 @@ func (reader *sourceReader) fileError(path string) error {
 	return reader.errors[path]
 }
 
+// line returns the line numbered "lineno" in path, or _,false if lineno is out of range.
 func (reader *sourceReader) line(path string, lineno int) (string, bool) {
 	lines, ok := reader.files[path]
 	if !ok {
@@ -651,3 +986,37 @@ func indentation(line string) int {
 	}
 	return column
 }
+
+// rightPad pads the input with spaces on the right-hand-side to make it have
+// at least width n. It treats tabs as enough spaces that lead to the next
+// 8-aligned tab-stop.
+func rightPad(s string, n int) string {
+	var str strings.Builder
+
+	// Convert tabs to spaces as we go so padding works regardless of what prefix
+	// is placed before the result.
+	column := 0
+	for _, c := range s {
+		column++
+		if c == '\t' {
+			str.WriteRune(' ')
+			for column%8 != 0 {
+				column++
+				str.WriteRune(' ')
+			}
+		} else {
+			str.WriteRune(c)
+		}
+	}
+	for column < n {
+		column++
+		str.WriteRune(' ')
+	}
+	return str.String()
+}
+
+func canonicalizeFileName(fname string) string {
+	fname = strings.TrimPrefix(fname, "/proc/self/cwd/")
+	fname = strings.TrimPrefix(fname, "./")
+	return filepath.Clean(fname)
+}
diff --git a/src/cmd/vendor/github.com/google/pprof/internal/report/source_html.go b/src/cmd/vendor/github.com/google/pprof/internal/report/source_html.go
index 02a6d77248..26e8bdbba8 100644
--- a/src/cmd/vendor/github.com/google/pprof/internal/report/source_html.go
+++ b/src/cmd/vendor/github.com/google/pprof/internal/report/source_html.go
@@ -25,12 +25,11 @@ func AddSourceTemplates(t *template.Template) {
 }
 
 const weblistPageCSS = `<style type="text/css">
-body {
+body #content{
 font-family: sans-serif;
 }
 h1 {
   font-size: 1.5em;
-  margin-bottom: 4px;
 }
 .legend {
   font-size: 1.25em;
diff --git a/src/cmd/vendor/github.com/google/pprof/profile/merge.go b/src/cmd/vendor/github.com/google/pprof/profile/merge.go
index 4dcc27f48e..5ab6e9b9b0 100644
--- a/src/cmd/vendor/github.com/google/pprof/profile/merge.go
+++ b/src/cmd/vendor/github.com/google/pprof/profile/merge.go
@@ -35,7 +35,10 @@ func (p *Profile) Compact() *Profile {
 // functions and mappings. Profiles must have identical profile sample
 // and period types or the merge will fail. profile.Period of the
 // resulting profile will be the maximum of all profiles, and
-// profile.TimeNanos will be the earliest nonzero one.
+// profile.TimeNanos will be the earliest nonzero one. Merges are
+// associative with the caveat of the first profile having some
+// specialization in how headers are combined. There may be other
+// subtleties now or in the future regarding associativity.
 func Merge(srcs []*Profile) (*Profile, error) {
 	if len(srcs) == 0 {
 		return nil, fmt.Errorf("no profiles to merge")
diff --git a/src/cmd/vendor/github.com/google/pprof/profile/profile.go b/src/cmd/vendor/github.com/google/pprof/profile/profile.go
index d94d8b3d1c..2590c8ddb4 100644
--- a/src/cmd/vendor/github.com/google/pprof/profile/profile.go
+++ b/src/cmd/vendor/github.com/google/pprof/profile/profile.go
@@ -22,6 +22,7 @@ import (
 	"fmt"
 	"io"
 	"io/ioutil"
+	"math"
 	"path/filepath"
 	"regexp"
 	"sort"
@@ -712,7 +713,8 @@ func (s *Sample) DiffBaseSample() bool {
 	return s.HasLabel("pprof::base", "true")
 }
 
-// Scale multiplies all sample values in a profile by a constant.
+// Scale multiplies all sample values in a profile by a constant and keeps
+// only samples that have at least one non-zero value.
 func (p *Profile) Scale(ratio float64) {
 	if ratio == 1 {
 		return
@@ -724,7 +726,8 @@ func (p *Profile) Scale(ratio float64) {
 	p.ScaleN(ratios)
 }
 
-// ScaleN multiplies each sample values in a sample by a different amount.
+// ScaleN multiplies each sample values in a sample by a different amount
+// and keeps only samples that have at least one non-zero value.
 func (p *Profile) ScaleN(ratios []float64) error {
 	if len(p.SampleType) != len(ratios) {
 		return fmt.Errorf("mismatched scale ratios, got %d, want %d", len(ratios), len(p.SampleType))
@@ -739,13 +742,22 @@ func (p *Profile) ScaleN(ratios []float64) error {
 	if allOnes {
 		return nil
 	}
+	fillIdx := 0
 	for _, s := range p.Sample {
+		keepSample := false
 		for i, v := range s.Value {
 			if ratios[i] != 1 {
-				s.Value[i] = int64(float64(v) * ratios[i])
+				val := int64(math.Round(float64(v) * ratios[i]))
+				s.Value[i] = val
+				keepSample = keepSample || val != 0
 			}
 		}
+		if keepSample {
+			p.Sample[fillIdx] = s
+			fillIdx++
+		}
 	}
+	p.Sample = p.Sample[:fillIdx]
 	return nil
 }
 
diff --git a/src/cmd/vendor/golang.org/x/arch/arm64/arm64asm/inst.go b/src/cmd/vendor/golang.org/x/arch/arm64/arm64asm/inst.go
index cf690e2c18..afeb9a3c10 100644
--- a/src/cmd/vendor/golang.org/x/arch/arm64/arm64asm/inst.go
+++ b/src/cmd/vendor/golang.org/x/arch/arm64/arm64asm/inst.go
@@ -538,10 +538,12 @@ type MemExtend struct {
 	Extend ExtShift
 	// Amount indicates the index shift amount (but also see ShiftMustBeZero field below).
 	Amount uint8
-	// ShiftMustBeZero is set to true when the shift amount must be 0, even if the
-	// Amount field is not 0. In GNU syntax, a #0 shift amount is printed if Amount
-	// is not 0 but ShiftMustBeZero is true; #0 is not printed if Amount is 0 and
-	// ShiftMustBeZero is true. Both cases represent shift by 0 bit.
+	// Refer to ARM reference manual, for byte load/store(register), the index
+	// shift amount must be 0, encoded in "S" as 0 if omitted, or as 1 if present.
+	// a.ShiftMustBeZero is set true indicates the index shift amount must be 0.
+	// In GNU syntax, a #0 shift amount is printed if Amount is 1 but ShiftMustBeZero
+	// is true; #0 is not printed if Amount is 0 and ShiftMustBeZero is true.
+	// Both cases represent shift by 0 bit.
 	ShiftMustBeZero bool
 }
 
diff --git a/src/cmd/vendor/golang.org/x/arch/arm64/arm64asm/plan9x.go b/src/cmd/vendor/golang.org/x/arch/arm64/arm64asm/plan9x.go
index c9e4570c59..bae42e284e 100644
--- a/src/cmd/vendor/golang.org/x/arch/arm64/arm64asm/plan9x.go
+++ b/src/cmd/vendor/golang.org/x/arch/arm64/arm64asm/plan9x.go
@@ -595,14 +595,18 @@ func plan9Arg(inst *Inst, pc uint64, symname func(uint64) (string, uint64), arg
 		}
 
 		if a.Extend == lsl {
+			// Refer to ARM reference manual, for byte load/store(register), the index
+			// shift amount must be 0, encoded in "S" as 0 if omitted, or as 1 if present.
 			// a.Amount indicates the index shift amount, encoded in "S" field.
-			// a.ShiftMustBeZero is set true when the index shift amount must be 0,
-			// even if the a.Amount field is not 0.
-			// When a.ShiftMustBeZero is ture, GNU syntax prints #0 shift amount if
-			// "S" equals to 1, or does not print #0 shift amount if "S" equals to 0.
-			// Go syntax should never print a zero index shift amount.
+			// a.ShiftMustBeZero is set true indicates the index shift amount must be 0.
+			// When a.ShiftMustBeZero is true, GNU syntax prints "[Xn, Xm lsl #0]" if "S"
+			// equals to 1, or prints "[Xn, Xm]" if "S" equals to 0.
 			if a.Amount != 0 && !a.ShiftMustBeZero {
 				index = fmt.Sprintf("(%s<<%d)", indexreg, a.Amount)
+			} else if a.ShiftMustBeZero && a.Amount == 1 {
+				// When a.ShiftMustBeZero is ture, Go syntax prints "(Rm<<0)" if "a.Amount"
+				// equals to 1.
+				index = fmt.Sprintf("(%s<<0)", indexreg)
 			} else {
 				index = fmt.Sprintf("(%s)", indexreg)
 			}
diff --git a/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/gnu.go b/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/gnu.go
index 1849a297d8..4631749745 100644
--- a/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/gnu.go
+++ b/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/gnu.go
@@ -11,8 +11,10 @@ import (
 )
 
 var (
-	condBit    = [4]string{"lt", "gt", "eq", "so"}
-	condBitNeg = [4]string{"ge", "le", "ne", "so"}
+	// bit 3 of index is a negated check.
+	condBit = [8]string{
+		"lt", "gt", "eq", "so",
+		"ge", "le", "ne", "ns"}
 )
 
 // GNUSyntax returns the GNU assembler syntax for the instruction, as defined by GNU binutils.
@@ -31,57 +33,144 @@ func GNUSyntax(inst Inst, pc uint64) string {
 	// Special handling for some ops
 	startArg := 0
 	sep := " "
-	switch inst.Op.String() {
-	case "bc":
-		bo := gnuArg(&inst, 0, inst.Args[0], PC)
-		bi := inst.Args[1]
-		switch bi := bi.(type) {
-		case CondReg:
-			if bi >= CR0 {
-				if bi == CR0 && bo == "16" {
-					buf.WriteString("bdnz")
+	opName := inst.Op.String()
+	switch opName {
+	case "bc", "bcl", "bca", "bcla", "bclr", "bclrl", "bcctr", "bcctrl", "bctar", "bctarl":
+		sfx := inst.Op.String()[2:]
+		bo := int(inst.Args[0].(Imm))
+		bi := inst.Args[1].(CondReg)
+		atsfx := [4]string{"", "?", "-", "+"}
+		decsfx := [2]string{"dnz", "dz"}
+
+		//BO field is... complicated (z == ignored bit, at == prediction hint)
+		//Paraphrased from ISA 3.1 Book I Section 2.4:
+		//
+		//0000z -> decrement ctr, b if ctr != 0 and CRbi == 0
+		//0001z -> decrement ctr, b if ctr == 0 and CRbi == 0
+		//001at -> b if CRbi == 0
+		//0100z -> decrement ctr, b if ctr != 0 and CRbi == 1
+		//0101z -> decrement ctr, b if ctr == 0 and CRbi == 1
+		//011at -> b if CRbi == 1
+		//1a00t -> decrement ctr, b if ctr != 0
+		//1a01t -> decrement ctr, b if ctr == 0
+		//1z1zz -> b always
+
+		// Decoding (in this order) we get
+		// BO & 0b00100 == 0b00000 -> dz if BO[1], else dnz (not simplified for bcctrl forms)
+		// BO & 0b10000 == 0b10000 -> (bc and bca forms not simplified), at = B[4]B[0] if B[2] != 0, done
+		// BO & 0b10000 == 0b00000 -> t if BO[3], else f
+		// BO & 0b10100 == 0b00100 -> at = B[0:1]
+
+		// BI fields rename as follows:
+		// less than            : lt BI%4==0 && test == t
+		// less than or equal   : le BI%4==1 && test == f
+		// equal 		: eq BI%4==2 && test == t
+		// greater than or equal: ge BI%4==0 && test == f
+		// greater than		: gt BI%4==1 && test == t
+		// not less than	: nl BI%4==0 && test == f
+		// not equal		: ne BI%4==2 && test == f
+		// not greater than	: ng BI%4==1 && test == f
+		// summary overflow	: so BI%4==3 && test == t
+		// not summary overflow : ns BI%4==3 && test == f
+		// unordered		: un BI%4==3 && test == t
+		// not unordered	: nu BI%4==3 && test == f
+		//
+		// Note, there are only 8 possible tests, but quite a few more
+		// ways to name fields.  For simplicity, we choose those in condBit.
+
+		at := 0   // 0 == no hint, 1 == reserved, 2 == not likely, 3 == likely
+		form := 1 // 1 == n/a,  0 == cr bit not set, 4 == cr bit set
+		cr := (bi - Cond0LT) / 4
+		bh := -1 // Only for lr/tar/ctr variants.
+		switch opName {
+		case "bclr", "bclrl", "bcctr", "bcctrl", "bctar", "bctarl":
+			bh = int(inst.Args[2].(Imm))
+		}
+
+		if bo&0x14 == 0x14 {
+			if bo == 0x14 && bi == Cond0LT { // preferred form of unconditional branch
+				// Likewise, avoid printing fake b/ba/bl/bla
+				if opName != "bc" && opName != "bca" && opName != "bcl" && opName != "bcla" {
+					startArg = 2
 				}
-				buf.WriteString(fmt.Sprintf("bc cr%d", bi-CR0))
 			}
-			cr := bi / 4
-			switch bo {
-			case "4":
-				bit := condBitNeg[(bi-Cond0LT)%4]
-				if cr == 0 {
-					buf.WriteString(fmt.Sprintf("b%s", bit))
-				} else {
-					buf.WriteString(fmt.Sprintf("b%s cr%d,", bit, cr))
-					sep = ""
-				}
-			case "12":
-				bit := condBit[(bi-Cond0LT)%4]
-				if cr == 0 {
-					buf.WriteString(fmt.Sprintf("b%s", bit))
-				} else {
-					buf.WriteString(fmt.Sprintf("b%s cr%d,", bit, cr))
-					sep = ""
+		} else if bo&0x04 == 0 { // ctr is decremented
+			if opName != "bcctr" && opName != "bcctrl" {
+				startArg = 1
+				tf := ""
+				if bo&0x10 == 0x00 {
+					tf = "f"
+					if bo&0x08 == 0x08 {
+						tf = "t"
+					}
 				}
-			case "8":
-				bit := condBit[(bi-Cond0LT)%4]
-				sep = ""
-				if cr == 0 {
-					buf.WriteString(fmt.Sprintf("bdnzt %s,", bit))
-				} else {
-					buf.WriteString(fmt.Sprintf("bdnzt cr%d,%s,", cr, bit))
+				sfx = decsfx[(bo>>1)&1] + tf + sfx
+			}
+			if bo&0x10 == 0x10 {
+				if opName != "bcctr" && opName != "bcctrl" {
+					startArg = 2
 				}
-			case "16":
-				if cr == 0 && bi == Cond0LT {
-					buf.WriteString("bdnz")
-				} else {
-					buf.WriteString(fmt.Sprintf("bdnz cr%d,", cr))
-					sep = ""
+				if bi != Cond0LT {
+					// A non-zero BI bit was encoded, but ignored by BO
+					startArg = 0
 				}
+				at = ((bo & 0x8) >> 2) | (bo & 0x1)
+			} else if bo&0x4 == 0x4 {
+				at = bo & 0x3
+			}
+		} else if bo&0x10 == 0x10 { // BI field is not used
+			if opName != "bca" && opName != "bc" {
+				at = ((bo & 0x8) >> 2) | (bo & 0x1)
+				startArg = 2
+			}
+			// If BI is encoded as a bit other than 0, no mnemonic.
+			if bo&0x14 == 0x14 {
+				startArg = 0
 			}
+		} else {
+			form = (bo & 0x8) >> 1
 			startArg = 2
-		default:
-			fmt.Printf("Unexpected bi: %d for bc with bo: %s\n", bi, bo)
+			if bo&0x14 == 0x04 {
+				at = bo & 0x3
+			}
 		}
-		startArg = 2
+		sfx += atsfx[at]
+
+		if form != 1 {
+			bit := int((bi-Cond0LT)%4) | (^form)&0x4
+			sfx = condBit[bit] + sfx
+		}
+
+		if at != 1 && startArg > 0 && bh <= 0 {
+			str := fmt.Sprintf("b%s", sfx)
+			if startArg > 1 && (cr != 0 || bh > 0) {
+				str += fmt.Sprintf(" cr%d", cr)
+				sep = ","
+			}
+			buf.WriteString(str)
+			if startArg < 2 && bh == 0 {
+				str := fmt.Sprintf(" %s",
+					gnuArg(&inst, 1, inst.Args[1], PC))
+				buf.WriteString(str)
+				startArg = 3
+			} else if bh == 0 {
+				startArg = 3
+			}
+		} else {
+			if startArg == 0 || bh > 0 || at == 1 {
+				buf.WriteString(inst.Op.String())
+				buf.WriteString(atsfx[at])
+				startArg = 0
+			} else {
+				buf.WriteString("b" + sfx)
+			}
+			if bh == 0 {
+				str := fmt.Sprintf(" %d,%s", bo, gnuArg(&inst, 1, inst.Args[1], PC))
+				buf.WriteString(str)
+				startArg = 3
+			}
+		}
+
 	case "mtspr":
 		opcode := inst.Op.String()
 		buf.WriteString(opcode[0:2])
@@ -198,7 +287,7 @@ func gnuArg(inst *Inst, argIndex int, arg Arg, pc uint64) string {
 		if arg <= Cond0SO {
 			return bit
 		}
-		return fmt.Sprintf("%s cr%d", bit, int(arg-Cond0LT)/4)
+		return fmt.Sprintf("4*cr%d+%s", int(arg-Cond0LT)/4, bit)
 	case Imm:
 		return fmt.Sprintf("%d", arg)
 	case SpReg:
diff --git a/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/tables.go b/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/tables.go
index 76f96356d2..971816ddac 100644
--- a/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/tables.go
+++ b/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/tables.go
@@ -2794,6 +2794,7 @@ var (
 	ap_FPReg_16_20             = &argField{Type: TypeFPReg, Shift: 0, BitFields: BitFields{{16, 5}}}
 	ap_FPReg_11_15             = &argField{Type: TypeFPReg, Shift: 0, BitFields: BitFields{{11, 5}}}
 	ap_FPReg_21_25             = &argField{Type: TypeFPReg, Shift: 0, BitFields: BitFields{{21, 5}}}
+	ap_ImmUnsigned_6_8         = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{6, 3}}}
 	ap_ImmUnsigned_16_19       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{16, 4}}}
 	ap_ImmUnsigned_15_15       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{15, 1}}}
 	ap_ImmUnsigned_7_14        = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{7, 8}}}
@@ -3653,21 +3654,21 @@ var instFormats = [...]instFormat{
 	{MCRFS, 0xfc0007fe, 0xfc000080, 0x63f801, // Move to Condition Register from FPSCR X-form (mcrfs BF,BFA)
 		[5]*argField{ap_CondRegField_6_8, ap_CondRegField_11_13}},
 	{MTFSFI, 0xfc0007ff, 0xfc00010c, 0x7e0800, // Move To FPSCR Field Immediate X-form (mtfsfi BF,U,W)
-		[5]*argField{ap_CondRegField_6_8, ap_ImmUnsigned_16_19, ap_ImmUnsigned_15_15}},
+		[5]*argField{ap_ImmUnsigned_6_8, ap_ImmUnsigned_16_19, ap_ImmUnsigned_15_15}},
 	{MTFSFICC, 0xfc0007ff, 0xfc00010d, 0x7e0800, // Move To FPSCR Field Immediate X-form (mtfsfi. BF,U,W)
-		[5]*argField{ap_CondRegField_6_8, ap_ImmUnsigned_16_19, ap_ImmUnsigned_15_15}},
+		[5]*argField{ap_ImmUnsigned_6_8, ap_ImmUnsigned_16_19, ap_ImmUnsigned_15_15}},
 	{MTFSF, 0xfc0007ff, 0xfc00058e, 0x0, // Move To FPSCR Fields XFL-form (mtfsf FLM,FRB,L,W)
 		[5]*argField{ap_ImmUnsigned_7_14, ap_FPReg_16_20, ap_ImmUnsigned_6_6, ap_ImmUnsigned_15_15}},
 	{MTFSFCC, 0xfc0007ff, 0xfc00058f, 0x0, // Move To FPSCR Fields XFL-form (mtfsf. FLM,FRB,L,W)
 		[5]*argField{ap_ImmUnsigned_7_14, ap_FPReg_16_20, ap_ImmUnsigned_6_6, ap_ImmUnsigned_15_15}},
 	{MTFSB0, 0xfc0007ff, 0xfc00008c, 0x1ff800, // Move To FPSCR Bit 0 X-form (mtfsb0 BT)
-		[5]*argField{ap_CondRegBit_6_10}},
+		[5]*argField{ap_ImmUnsigned_6_10}},
 	{MTFSB0CC, 0xfc0007ff, 0xfc00008d, 0x1ff800, // Move To FPSCR Bit 0 X-form (mtfsb0. BT)
-		[5]*argField{ap_CondRegBit_6_10}},
+		[5]*argField{ap_ImmUnsigned_6_10}},
 	{MTFSB1, 0xfc0007ff, 0xfc00004c, 0x1ff800, // Move To FPSCR Bit 1 X-form (mtfsb1 BT)
-		[5]*argField{ap_CondRegBit_6_10}},
+		[5]*argField{ap_ImmUnsigned_6_10}},
 	{MTFSB1CC, 0xfc0007ff, 0xfc00004d, 0x1ff800, // Move To FPSCR Bit 1 X-form (mtfsb1. BT)
-		[5]*argField{ap_CondRegBit_6_10}},
+		[5]*argField{ap_ImmUnsigned_6_10}},
 	{LVEBX, 0xfc0007fe, 0x7c00000e, 0x1, // Load Vector Element Byte Indexed X-form (lvebx VRT,RA,RB)
 		[5]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
 	{LVEHX, 0xfc0007fe, 0x7c00004e, 0x1, // Load Vector Element Halfword Indexed X-form (lvehx VRT,RA,RB)
diff --git a/src/cmd/vendor/golang.org/x/arch/x86/x86asm/tables.go b/src/cmd/vendor/golang.org/x/arch/x86/x86asm/tables.go
index 5635399c81..af3fb73c51 100644
--- a/src/cmd/vendor/golang.org/x/arch/x86/x86asm/tables.go
+++ b/src/cmd/vendor/golang.org/x/arch/x86/x86asm/tables.go
@@ -22,233 +22,233 @@ var decoder = [...]uint16{
 	0x0D, 685,
 	0x0E, 714,
 	0x0F, 721,
-	0x10, 8026,
-	0x11, 8032,
-	0x12, 8061,
-	0x13, 8067,
-	0x14, 8096,
-	0x15, 8102,
-	0x16, 8131,
-	0x17, 8138,
-	0x18, 8145,
-	0x19, 8151,
-	0x1A, 8180,
-	0x1B, 8186,
-	0x1C, 8215,
-	0x1D, 8221,
-	0x1E, 8250,
-	0x1F, 8257,
-	0x20, 8264,
-	0x21, 8270,
-	0x22, 8299,
-	0x23, 8305,
-	0x24, 8334,
-	0x25, 8340,
-	0x27, 8369,
-	0x28, 8375,
-	0x29, 8381,
-	0x2A, 8410,
-	0x2B, 8452,
-	0x2C, 8481,
-	0x2D, 8487,
-	0x2F, 8516,
-	0x30, 8522,
-	0x31, 8528,
-	0x32, 8557,
-	0x33, 8563,
-	0x34, 8592,
-	0x35, 8598,
-	0x37, 8627,
-	0x38, 8633,
-	0x39, 8639,
-	0x3A, 8668,
-	0x3B, 8674,
-	0x3C, 8703,
-	0x3D, 8709,
-	0x3F, 8738,
-	0x40, 8744,
-	0x41, 8744,
-	0x42, 8744,
-	0x43, 8744,
-	0x44, 8744,
-	0x45, 8744,
-	0x46, 8744,
-	0x47, 8744,
-	0x48, 8759,
-	0x49, 8759,
-	0x4a, 8759,
-	0x4b, 8759,
-	0x4c, 8759,
-	0x4d, 8759,
-	0x4e, 8759,
-	0x4f, 8759,
-	0x50, 8774,
-	0x51, 8774,
-	0x52, 8774,
-	0x53, 8774,
-	0x54, 8774,
-	0x55, 8774,
-	0x56, 8774,
-	0x57, 8774,
-	0x58, 8801,
-	0x59, 8801,
-	0x5a, 8801,
-	0x5b, 8801,
-	0x5c, 8801,
-	0x5d, 8801,
-	0x5e, 8801,
-	0x5f, 8801,
-	0x60, 8828,
-	0x61, 8841,
-	0x62, 8854,
-	0x63, 8873,
-	0x68, 8904,
-	0x69, 8923,
-	0x6A, 8958,
-	0x6B, 8963,
-	0x6C, 8998,
-	0x6D, 9001,
-	0x6E, 9014,
-	0x6F, 9017,
-	0x70, 9090,
-	0x71, 9095,
-	0x72, 9100,
-	0x73, 9105,
-	0x74, 9110,
-	0x75, 9115,
-	0x76, 9120,
-	0x77, 9125,
-	0x78, 9152,
-	0x79, 9157,
-	0x7A, 9162,
-	0x7B, 9167,
-	0x7C, 9172,
-	0x7D, 9177,
-	0x7E, 9182,
-	0x7F, 9187,
-	0x80, 9252,
-	0x81, 9309,
-	0x83, 9550,
-	0x84, 9791,
-	0x85, 9797,
-	0x86, 9826,
-	0x87, 9832,
-	0x88, 9861,
-	0x89, 9867,
-	0x8A, 9889,
-	0x8B, 9895,
-	0x8C, 9917,
-	0x8D, 9946,
-	0x8E, 9975,
-	0x8F, 10004,
-	0x90, 10040,
-	0x91, 10040,
-	0x92, 10040,
-	0x93, 10040,
-	0x94, 10040,
-	0x95, 10040,
-	0x96, 10040,
-	0x97, 10040,
-	0x98, 10066,
-	0x99, 10086,
-	0x9A, 10106,
-	0x9B, 10123,
-	0x9C, 10126,
-	0x9D, 10149,
-	0x9E, 10172,
-	0x9F, 10175,
-	0xA0, 10178,
-	0xA1, 10197,
-	0xA2, 10219,
-	0xA3, 10238,
-	0xA4, 10260,
-	0xA5, 10263,
-	0xA6, 10283,
-	0xA7, 10286,
-	0xA8, 10306,
-	0xA9, 10312,
-	0xAA, 10341,
-	0xAB, 10344,
-	0xAC, 10364,
-	0xAD, 10367,
-	0xAE, 10387,
-	0xAF, 10390,
-	0xb0, 10410,
-	0xb1, 10410,
-	0xb2, 10410,
-	0xb3, 10410,
-	0xb4, 10410,
-	0xb5, 10410,
-	0xb6, 10410,
-	0xb7, 10410,
-	0xb8, 10416,
-	0xb9, 10416,
-	0xba, 10416,
-	0xbb, 10416,
-	0xbc, 10416,
-	0xbd, 10416,
-	0xbe, 10416,
-	0xbf, 10416,
-	0xC0, 10445,
-	0xC1, 10496,
-	0xC2, 10694,
-	0xC3, 10699,
-	0xC4, 10702,
-	0xC5, 10721,
-	0xC6, 10740,
-	0xC7, 10764,
-	0xC8, 10825,
-	0xC9, 10832,
-	0xCA, 10855,
-	0xCB, 10860,
-	0xCC, 10863,
-	0xCD, 10867,
-	0xCE, 10872,
-	0xCF, 10878,
-	0xD0, 10898,
-	0xD1, 10942,
-	0xD2, 11133,
-	0xD3, 11177,
-	0xD4, 11368,
-	0xD5, 11376,
-	0xD7, 11384,
-	0xD8, 11397,
-	0xD9, 11606,
-	0xDA, 11825,
-	0xDB, 11957,
-	0xDC, 12128,
-	0xDD, 12297,
-	0xDE, 12436,
-	0xDF, 12610,
-	0xE0, 12721,
-	0xE1, 12726,
-	0xE2, 12731,
-	0xE3, 12736,
-	0xE4, 12762,
-	0xE5, 12768,
-	0xE6, 12790,
-	0xE7, 12796,
-	0xE8, 12854,
-	0xE9, 12885,
-	0xEA, 12916,
-	0xEB, 12933,
-	0xEC, 12938,
-	0xED, 12943,
-	0xEE, 12962,
-	0xEF, 12967,
-	0xF1, 12986,
-	0xF4, 12989,
-	0xF5, 12992,
-	0xF6, 12995,
-	0xF7, 13034,
-	0xF8, 13210,
-	0xF9, 13213,
-	0xFA, 13216,
-	0xFB, 13219,
-	0xFC, 13222,
-	0xFD, 13225,
-	0xFE, 13228,
-	0xFF, 13245,
+	0x10, 8045,
+	0x11, 8051,
+	0x12, 8080,
+	0x13, 8086,
+	0x14, 8115,
+	0x15, 8121,
+	0x16, 8150,
+	0x17, 8157,
+	0x18, 8164,
+	0x19, 8170,
+	0x1A, 8199,
+	0x1B, 8205,
+	0x1C, 8234,
+	0x1D, 8240,
+	0x1E, 8269,
+	0x1F, 8276,
+	0x20, 8283,
+	0x21, 8289,
+	0x22, 8318,
+	0x23, 8324,
+	0x24, 8353,
+	0x25, 8359,
+	0x27, 8388,
+	0x28, 8394,
+	0x29, 8400,
+	0x2A, 8429,
+	0x2B, 8471,
+	0x2C, 8500,
+	0x2D, 8506,
+	0x2F, 8535,
+	0x30, 8541,
+	0x31, 8547,
+	0x32, 8576,
+	0x33, 8582,
+	0x34, 8611,
+	0x35, 8617,
+	0x37, 8646,
+	0x38, 8652,
+	0x39, 8658,
+	0x3A, 8687,
+	0x3B, 8693,
+	0x3C, 8722,
+	0x3D, 8728,
+	0x3F, 8757,
+	0x40, 8763,
+	0x41, 8763,
+	0x42, 8763,
+	0x43, 8763,
+	0x44, 8763,
+	0x45, 8763,
+	0x46, 8763,
+	0x47, 8763,
+	0x48, 8778,
+	0x49, 8778,
+	0x4a, 8778,
+	0x4b, 8778,
+	0x4c, 8778,
+	0x4d, 8778,
+	0x4e, 8778,
+	0x4f, 8778,
+	0x50, 8793,
+	0x51, 8793,
+	0x52, 8793,
+	0x53, 8793,
+	0x54, 8793,
+	0x55, 8793,
+	0x56, 8793,
+	0x57, 8793,
+	0x58, 8820,
+	0x59, 8820,
+	0x5a, 8820,
+	0x5b, 8820,
+	0x5c, 8820,
+	0x5d, 8820,
+	0x5e, 8820,
+	0x5f, 8820,
+	0x60, 8847,
+	0x61, 8860,
+	0x62, 8873,
+	0x63, 8892,
+	0x68, 8923,
+	0x69, 8942,
+	0x6A, 8977,
+	0x6B, 8982,
+	0x6C, 9017,
+	0x6D, 9020,
+	0x6E, 9033,
+	0x6F, 9036,
+	0x70, 9109,
+	0x71, 9114,
+	0x72, 9119,
+	0x73, 9124,
+	0x74, 9129,
+	0x75, 9134,
+	0x76, 9139,
+	0x77, 9144,
+	0x78, 9171,
+	0x79, 9176,
+	0x7A, 9181,
+	0x7B, 9186,
+	0x7C, 9191,
+	0x7D, 9196,
+	0x7E, 9201,
+	0x7F, 9206,
+	0x80, 9271,
+	0x81, 9328,
+	0x83, 9569,
+	0x84, 9810,
+	0x85, 9816,
+	0x86, 9845,
+	0x87, 9851,
+	0x88, 9880,
+	0x89, 9886,
+	0x8A, 9908,
+	0x8B, 9914,
+	0x8C, 9936,
+	0x8D, 9965,
+	0x8E, 9994,
+	0x8F, 10023,
+	0x90, 10059,
+	0x91, 10059,
+	0x92, 10059,
+	0x93, 10059,
+	0x94, 10059,
+	0x95, 10059,
+	0x96, 10059,
+	0x97, 10059,
+	0x98, 10085,
+	0x99, 10105,
+	0x9A, 10125,
+	0x9B, 10142,
+	0x9C, 10145,
+	0x9D, 10168,
+	0x9E, 10191,
+	0x9F, 10194,
+	0xA0, 10197,
+	0xA1, 10216,
+	0xA2, 10238,
+	0xA3, 10257,
+	0xA4, 10279,
+	0xA5, 10282,
+	0xA6, 10302,
+	0xA7, 10305,
+	0xA8, 10325,
+	0xA9, 10331,
+	0xAA, 10360,
+	0xAB, 10363,
+	0xAC, 10383,
+	0xAD, 10386,
+	0xAE, 10406,
+	0xAF, 10409,
+	0xb0, 10429,
+	0xb1, 10429,
+	0xb2, 10429,
+	0xb3, 10429,
+	0xb4, 10429,
+	0xb5, 10429,
+	0xb6, 10429,
+	0xb7, 10429,
+	0xb8, 10435,
+	0xb9, 10435,
+	0xba, 10435,
+	0xbb, 10435,
+	0xbc, 10435,
+	0xbd, 10435,
+	0xbe, 10435,
+	0xbf, 10435,
+	0xC0, 10464,
+	0xC1, 10515,
+	0xC2, 10713,
+	0xC3, 10718,
+	0xC4, 10721,
+	0xC5, 10740,
+	0xC6, 10759,
+	0xC7, 10783,
+	0xC8, 10844,
+	0xC9, 10851,
+	0xCA, 10874,
+	0xCB, 10879,
+	0xCC, 10882,
+	0xCD, 10886,
+	0xCE, 10891,
+	0xCF, 10897,
+	0xD0, 10917,
+	0xD1, 10961,
+	0xD2, 11152,
+	0xD3, 11196,
+	0xD4, 11387,
+	0xD5, 11395,
+	0xD7, 11403,
+	0xD8, 11416,
+	0xD9, 11625,
+	0xDA, 11844,
+	0xDB, 11976,
+	0xDC, 12147,
+	0xDD, 12316,
+	0xDE, 12455,
+	0xDF, 12629,
+	0xE0, 12740,
+	0xE1, 12745,
+	0xE2, 12750,
+	0xE3, 12755,
+	0xE4, 12781,
+	0xE5, 12787,
+	0xE6, 12809,
+	0xE7, 12815,
+	0xE8, 12873,
+	0xE9, 12904,
+	0xEA, 12935,
+	0xEB, 12952,
+	0xEC, 12957,
+	0xED, 12962,
+	0xEE, 12981,
+	0xEF, 12986,
+	0xF1, 13005,
+	0xF4, 13008,
+	0xF5, 13011,
+	0xF6, 13014,
+	0xF7, 13053,
+	0xF8, 13229,
+	0xF9, 13232,
+	0xFA, 13235,
+	0xFB, 13238,
+	0xFC, 13241,
+	0xFD, 13244,
+	0xFE, 13247,
+	0xFF, 13264,
 	uint16(xFail),
 	/*490*/ uint16(xSetOp), uint16(ADD),
 	/*492*/ uint16(xReadSlashR),
@@ -400,587 +400,588 @@ var decoder = [...]uint16{
 	/*717*/ uint16(xSetOp), uint16(PUSH),
 	/*719*/ uint16(xArgCS),
 	/*720*/ uint16(xMatch),
-	/*721*/ uint16(xCondByte), 228,
-	0x00, 1180,
-	0x01, 1237,
-	0x02, 1345,
-	0x03, 1367,
-	0x05, 1389,
-	0x06, 1395,
-	0x07, 1398,
-	0x08, 1404,
-	0x09, 1407,
-	0x0B, 1410,
-	0x0D, 1413,
-	0x10, 1426,
-	0x11, 1460,
-	0x12, 1494,
-	0x13, 1537,
-	0x14, 1555,
-	0x15, 1573,
-	0x16, 1591,
-	0x17, 1626,
-	0x18, 1644,
-	0x1F, 1669,
-	0x20, 1690,
-	0x21, 1705,
-	0x22, 1720,
-	0x23, 1735,
-	0x24, 1750,
-	0x26, 1765,
-	0x28, 1780,
-	0x29, 1798,
-	0x2A, 1816,
-	0x2B, 1903,
-	0x2C, 1937,
-	0x2D, 2024,
-	0x2E, 2111,
-	0x2F, 2129,
-	0x30, 2147,
-	0x31, 2150,
-	0x32, 2153,
-	0x33, 2156,
-	0x34, 2159,
-	0x35, 2162,
-	0x38, 2172,
-	0x3A, 3073,
-	0x40, 3484,
-	0x41, 3513,
-	0x42, 3542,
-	0x43, 3571,
-	0x44, 3600,
-	0x45, 3629,
-	0x46, 3658,
-	0x47, 3687,
-	0x48, 3716,
-	0x49, 3745,
-	0x4A, 3774,
-	0x4B, 3803,
-	0x4C, 3832,
-	0x4D, 3861,
-	0x4E, 3890,
-	0x4F, 3919,
-	0x50, 3948,
-	0x51, 3966,
-	0x52, 4000,
-	0x53, 4018,
-	0x54, 4036,
-	0x55, 4054,
-	0x56, 4072,
-	0x57, 4090,
-	0x58, 4108,
-	0x59, 4142,
-	0x5A, 4176,
-	0x5B, 4210,
-	0x5C, 4236,
-	0x5D, 4270,
-	0x5E, 4304,
-	0x5F, 4338,
-	0x60, 4372,
-	0x61, 4390,
-	0x62, 4408,
-	0x63, 4426,
-	0x64, 4444,
-	0x65, 4462,
-	0x66, 4480,
-	0x67, 4498,
-	0x68, 4516,
-	0x69, 4534,
-	0x6A, 4552,
-	0x6B, 4570,
-	0x6C, 4588,
-	0x6D, 4598,
-	0x6E, 4608,
-	0x6F, 4675,
-	0x70, 4701,
-	0x71, 4743,
-	0x72, 4806,
-	0x73, 4869,
-	0x74, 4934,
-	0x75, 4952,
-	0x76, 4970,
-	0x77, 4988,
-	0x7C, 4991,
-	0x7D, 5009,
-	0x7E, 5027,
-	0x7F, 5104,
-	0x80, 5130,
-	0x81, 5161,
-	0x82, 5192,
-	0x83, 5223,
-	0x84, 5254,
-	0x85, 5285,
-	0x86, 5316,
-	0x87, 5347,
-	0x88, 5378,
-	0x89, 5409,
-	0x8A, 5440,
-	0x8B, 5471,
-	0x8C, 5502,
-	0x8D, 5533,
-	0x8E, 5564,
-	0x8F, 5595,
-	0x90, 5626,
-	0x91, 5631,
-	0x92, 5636,
-	0x93, 5641,
-	0x94, 5646,
-	0x95, 5651,
-	0x96, 5656,
-	0x97, 5661,
-	0x98, 5666,
-	0x99, 5671,
-	0x9A, 5676,
-	0x9B, 5681,
-	0x9C, 5686,
-	0x9D, 5691,
-	0x9E, 5696,
-	0x9F, 5701,
-	0xA0, 5706,
-	0xA1, 5710,
-	0xA2, 5737,
-	0xA3, 5740,
-	0xA4, 5769,
-	0xA5, 5804,
-	0xA8, 5836,
-	0xA9, 5840,
-	0xAA, 5867,
-	0xAB, 5870,
-	0xAC, 5899,
-	0xAD, 5934,
-	0xAE, 5966,
-	0xAF, 6224,
-	0xB0, 6253,
-	0xB1, 6259,
-	0xB2, 6288,
-	0xB3, 6317,
-	0xB4, 6346,
-	0xB5, 6375,
-	0xB6, 6404,
-	0xB7, 6433,
-	0xB8, 6462,
-	0xB9, 6499,
-	0xBA, 6502,
-	0xBB, 6627,
-	0xBC, 6656,
-	0xBD, 6723,
-	0xBE, 6790,
-	0xBF, 6819,
-	0xC0, 6848,
-	0xC1, 6854,
-	0xC2, 6883,
-	0xC3, 6925,
-	0xC4, 6954,
-	0xC5, 6976,
-	0xC6, 6998,
-	0xC7, 7020,
-	0xc8, 7149,
-	0xc9, 7149,
-	0xca, 7149,
-	0xcb, 7149,
-	0xcc, 7149,
-	0xcd, 7149,
-	0xce, 7149,
-	0xcf, 7149,
-	0xD0, 7172,
-	0xD1, 7190,
-	0xD2, 7208,
-	0xD3, 7226,
-	0xD4, 7244,
-	0xD5, 7262,
-	0xD6, 7280,
-	0xD7, 7306,
-	0xD8, 7324,
-	0xD9, 7342,
-	0xDA, 7360,
-	0xDB, 7378,
-	0xDC, 7396,
-	0xDD, 7414,
-	0xDE, 7432,
-	0xDF, 7450,
-	0xE0, 7468,
-	0xE1, 7486,
-	0xE2, 7504,
-	0xE3, 7522,
-	0xE4, 7540,
-	0xE5, 7558,
-	0xE6, 7576,
-	0xE7, 7602,
-	0xE8, 7620,
-	0xE9, 7638,
-	0xEA, 7656,
-	0xEB, 7674,
-	0xEC, 7692,
-	0xED, 7710,
-	0xEE, 7728,
-	0xEF, 7746,
-	0xF0, 7764,
-	0xF1, 7774,
-	0xF2, 7792,
-	0xF3, 7810,
-	0xF4, 7828,
-	0xF5, 7846,
-	0xF6, 7864,
-	0xF7, 7882,
-	0xF8, 7900,
-	0xF9, 7918,
-	0xFA, 7936,
-	0xFB, 7954,
-	0xFC, 7972,
-	0xFD, 7990,
-	0xFE, 8008,
+	/*721*/ uint16(xCondByte), 229,
+	0x00, 1182,
+	0x01, 1239,
+	0x02, 1347,
+	0x03, 1369,
+	0x05, 1391,
+	0x06, 1397,
+	0x07, 1400,
+	0x08, 1406,
+	0x09, 1409,
+	0x0B, 1412,
+	0x0D, 1415,
+	0x10, 1428,
+	0x11, 1462,
+	0x12, 1496,
+	0x13, 1539,
+	0x14, 1557,
+	0x15, 1575,
+	0x16, 1593,
+	0x17, 1628,
+	0x18, 1646,
+	0x1F, 1671,
+	0x20, 1692,
+	0x21, 1707,
+	0x22, 1722,
+	0x23, 1737,
+	0x24, 1752,
+	0x26, 1767,
+	0x28, 1782,
+	0x29, 1800,
+	0x2A, 1818,
+	0x2B, 1905,
+	0x2C, 1939,
+	0x2D, 2026,
+	0x2E, 2113,
+	0x2F, 2131,
+	0x30, 2149,
+	0x31, 2152,
+	0x32, 2155,
+	0x33, 2158,
+	0x34, 2161,
+	0x35, 2164,
+	0x38, 2174,
+	0x3A, 3075,
+	0x40, 3486,
+	0x41, 3515,
+	0x42, 3544,
+	0x43, 3573,
+	0x44, 3602,
+	0x45, 3631,
+	0x46, 3660,
+	0x47, 3689,
+	0x48, 3718,
+	0x49, 3747,
+	0x4A, 3776,
+	0x4B, 3805,
+	0x4C, 3834,
+	0x4D, 3863,
+	0x4E, 3892,
+	0x4F, 3921,
+	0x50, 3950,
+	0x51, 3968,
+	0x52, 4002,
+	0x53, 4020,
+	0x54, 4038,
+	0x55, 4056,
+	0x56, 4074,
+	0x57, 4092,
+	0x58, 4110,
+	0x59, 4144,
+	0x5A, 4178,
+	0x5B, 4212,
+	0x5C, 4238,
+	0x5D, 4272,
+	0x5E, 4306,
+	0x5F, 4340,
+	0x60, 4374,
+	0x61, 4392,
+	0x62, 4410,
+	0x63, 4428,
+	0x64, 4446,
+	0x65, 4464,
+	0x66, 4482,
+	0x67, 4500,
+	0x68, 4518,
+	0x69, 4536,
+	0x6A, 4554,
+	0x6B, 4572,
+	0x6C, 4590,
+	0x6D, 4600,
+	0x6E, 4610,
+	0x6F, 4677,
+	0x70, 4703,
+	0x71, 4745,
+	0x72, 4808,
+	0x73, 4871,
+	0x74, 4936,
+	0x75, 4954,
+	0x76, 4972,
+	0x77, 4990,
+	0x7C, 4993,
+	0x7D, 5011,
+	0x7E, 5029,
+	0x7F, 5106,
+	0x80, 5132,
+	0x81, 5163,
+	0x82, 5194,
+	0x83, 5225,
+	0x84, 5256,
+	0x85, 5287,
+	0x86, 5318,
+	0x87, 5349,
+	0x88, 5380,
+	0x89, 5411,
+	0x8A, 5442,
+	0x8B, 5473,
+	0x8C, 5504,
+	0x8D, 5535,
+	0x8E, 5566,
+	0x8F, 5597,
+	0x90, 5628,
+	0x91, 5633,
+	0x92, 5638,
+	0x93, 5643,
+	0x94, 5648,
+	0x95, 5653,
+	0x96, 5658,
+	0x97, 5663,
+	0x98, 5668,
+	0x99, 5673,
+	0x9A, 5678,
+	0x9B, 5683,
+	0x9C, 5688,
+	0x9D, 5693,
+	0x9E, 5698,
+	0x9F, 5703,
+	0xA0, 5708,
+	0xA1, 5712,
+	0xA2, 5739,
+	0xA3, 5742,
+	0xA4, 5771,
+	0xA5, 5806,
+	0xA8, 5838,
+	0xA9, 5842,
+	0xAA, 5869,
+	0xAB, 5872,
+	0xAC, 5901,
+	0xAD, 5936,
+	0xAE, 5968,
+	0xAF, 6226,
+	0xB0, 6255,
+	0xB1, 6261,
+	0xB2, 6290,
+	0xB3, 6319,
+	0xB4, 6348,
+	0xB5, 6377,
+	0xB6, 6406,
+	0xB7, 6435,
+	0xB8, 6464,
+	0xB9, 6501,
+	0xBA, 6511,
+	0xBB, 6636,
+	0xBC, 6665,
+	0xBD, 6732,
+	0xBE, 6799,
+	0xBF, 6828,
+	0xC0, 6857,
+	0xC1, 6863,
+	0xC2, 6892,
+	0xC3, 6934,
+	0xC4, 6963,
+	0xC5, 6985,
+	0xC6, 7007,
+	0xC7, 7029,
+	0xc8, 7158,
+	0xc9, 7158,
+	0xca, 7158,
+	0xcb, 7158,
+	0xcc, 7158,
+	0xcd, 7158,
+	0xce, 7158,
+	0xcf, 7158,
+	0xD0, 7181,
+	0xD1, 7199,
+	0xD2, 7217,
+	0xD3, 7235,
+	0xD4, 7253,
+	0xD5, 7271,
+	0xD6, 7289,
+	0xD7, 7315,
+	0xD8, 7333,
+	0xD9, 7351,
+	0xDA, 7369,
+	0xDB, 7387,
+	0xDC, 7405,
+	0xDD, 7423,
+	0xDE, 7441,
+	0xDF, 7459,
+	0xE0, 7477,
+	0xE1, 7495,
+	0xE2, 7513,
+	0xE3, 7531,
+	0xE4, 7549,
+	0xE5, 7567,
+	0xE6, 7585,
+	0xE7, 7611,
+	0xE8, 7629,
+	0xE9, 7647,
+	0xEA, 7665,
+	0xEB, 7683,
+	0xEC, 7701,
+	0xED, 7719,
+	0xEE, 7737,
+	0xEF, 7755,
+	0xF0, 7773,
+	0xF1, 7783,
+	0xF2, 7801,
+	0xF3, 7819,
+	0xF4, 7837,
+	0xF5, 7855,
+	0xF6, 7873,
+	0xF7, 7891,
+	0xF8, 7909,
+	0xF9, 7927,
+	0xFA, 7945,
+	0xFB, 7963,
+	0xFC, 7981,
+	0xFD, 7999,
+	0xFE, 8017,
+	0xFF, 8035,
 	uint16(xFail),
-	/*1180*/ uint16(xCondSlashR),
-	1189, // 0
-	1205, // 1
-	1221, // 2
-	1225, // 3
-	1229, // 4
-	1233, // 5
+	/*1182*/ uint16(xCondSlashR),
+	1191, // 0
+	1207, // 1
+	1223, // 2
+	1227, // 3
+	1231, // 4
+	1235, // 5
 	0,    // 6
 	0,    // 7
-	/*1189*/ uint16(xCondDataSize), 1193, 1197, 1201,
-	/*1193*/ uint16(xSetOp), uint16(SLDT),
-	/*1195*/ uint16(xArgRM16),
-	/*1196*/ uint16(xMatch),
-	/*1197*/ uint16(xSetOp), uint16(SLDT),
-	/*1199*/ uint16(xArgR32M16),
-	/*1200*/ uint16(xMatch),
-	/*1201*/ uint16(xSetOp), uint16(SLDT),
-	/*1203*/ uint16(xArgR64M16),
-	/*1204*/ uint16(xMatch),
-	/*1205*/ uint16(xCondDataSize), 1209, 1213, 1217,
-	/*1209*/ uint16(xSetOp), uint16(STR),
-	/*1211*/ uint16(xArgRM16),
-	/*1212*/ uint16(xMatch),
-	/*1213*/ uint16(xSetOp), uint16(STR),
-	/*1215*/ uint16(xArgR32M16),
-	/*1216*/ uint16(xMatch),
-	/*1217*/ uint16(xSetOp), uint16(STR),
-	/*1219*/ uint16(xArgR64M16),
-	/*1220*/ uint16(xMatch),
-	/*1221*/ uint16(xSetOp), uint16(LLDT),
-	/*1223*/ uint16(xArgRM16),
-	/*1224*/ uint16(xMatch),
-	/*1225*/ uint16(xSetOp), uint16(LTR),
-	/*1227*/ uint16(xArgRM16),
-	/*1228*/ uint16(xMatch),
-	/*1229*/ uint16(xSetOp), uint16(VERR),
-	/*1231*/ uint16(xArgRM16),
-	/*1232*/ uint16(xMatch),
-	/*1233*/ uint16(xSetOp), uint16(VERW),
-	/*1235*/ uint16(xArgRM16),
-	/*1236*/ uint16(xMatch),
-	/*1237*/ uint16(xCondByte), 8,
-	0xC8, 1318,
-	0xC9, 1321,
-	0xD0, 1324,
-	0xD1, 1327,
-	0xD5, 1330,
-	0xD6, 1333,
-	0xF8, 1336,
-	0xF9, 1342,
-	/*1255*/ uint16(xCondSlashR),
-	1264, // 0
-	1268, // 1
-	1272, // 2
-	1283, // 3
-	1294, // 4
+	/*1191*/ uint16(xCondDataSize), 1195, 1199, 1203,
+	/*1195*/ uint16(xSetOp), uint16(SLDT),
+	/*1197*/ uint16(xArgRM16),
+	/*1198*/ uint16(xMatch),
+	/*1199*/ uint16(xSetOp), uint16(SLDT),
+	/*1201*/ uint16(xArgR32M16),
+	/*1202*/ uint16(xMatch),
+	/*1203*/ uint16(xSetOp), uint16(SLDT),
+	/*1205*/ uint16(xArgR64M16),
+	/*1206*/ uint16(xMatch),
+	/*1207*/ uint16(xCondDataSize), 1211, 1215, 1219,
+	/*1211*/ uint16(xSetOp), uint16(STR),
+	/*1213*/ uint16(xArgRM16),
+	/*1214*/ uint16(xMatch),
+	/*1215*/ uint16(xSetOp), uint16(STR),
+	/*1217*/ uint16(xArgR32M16),
+	/*1218*/ uint16(xMatch),
+	/*1219*/ uint16(xSetOp), uint16(STR),
+	/*1221*/ uint16(xArgR64M16),
+	/*1222*/ uint16(xMatch),
+	/*1223*/ uint16(xSetOp), uint16(LLDT),
+	/*1225*/ uint16(xArgRM16),
+	/*1226*/ uint16(xMatch),
+	/*1227*/ uint16(xSetOp), uint16(LTR),
+	/*1229*/ uint16(xArgRM16),
+	/*1230*/ uint16(xMatch),
+	/*1231*/ uint16(xSetOp), uint16(VERR),
+	/*1233*/ uint16(xArgRM16),
+	/*1234*/ uint16(xMatch),
+	/*1235*/ uint16(xSetOp), uint16(VERW),
+	/*1237*/ uint16(xArgRM16),
+	/*1238*/ uint16(xMatch),
+	/*1239*/ uint16(xCondByte), 8,
+	0xC8, 1320,
+	0xC9, 1323,
+	0xD0, 1326,
+	0xD1, 1329,
+	0xD5, 1332,
+	0xD6, 1335,
+	0xF8, 1338,
+	0xF9, 1344,
+	/*1257*/ uint16(xCondSlashR),
+	1266, // 0
+	1270, // 1
+	1274, // 2
+	1285, // 3
+	1296, // 4
 	0,    // 5
-	1310, // 6
-	1314, // 7
-	/*1264*/ uint16(xSetOp), uint16(SGDT),
-	/*1266*/ uint16(xArgM),
-	/*1267*/ uint16(xMatch),
-	/*1268*/ uint16(xSetOp), uint16(SIDT),
-	/*1270*/ uint16(xArgM),
-	/*1271*/ uint16(xMatch),
-	/*1272*/ uint16(xCondIs64), 1275, 1279,
-	/*1275*/ uint16(xSetOp), uint16(LGDT),
-	/*1277*/ uint16(xArgM16and32),
-	/*1278*/ uint16(xMatch),
-	/*1279*/ uint16(xSetOp), uint16(LGDT),
-	/*1281*/ uint16(xArgM16and64),
-	/*1282*/ uint16(xMatch),
-	/*1283*/ uint16(xCondIs64), 1286, 1290,
-	/*1286*/ uint16(xSetOp), uint16(LIDT),
-	/*1288*/ uint16(xArgM16and32),
-	/*1289*/ uint16(xMatch),
-	/*1290*/ uint16(xSetOp), uint16(LIDT),
-	/*1292*/ uint16(xArgM16and64),
-	/*1293*/ uint16(xMatch),
-	/*1294*/ uint16(xCondDataSize), 1298, 1302, 1306,
-	/*1298*/ uint16(xSetOp), uint16(SMSW),
-	/*1300*/ uint16(xArgRM16),
-	/*1301*/ uint16(xMatch),
-	/*1302*/ uint16(xSetOp), uint16(SMSW),
-	/*1304*/ uint16(xArgR32M16),
-	/*1305*/ uint16(xMatch),
-	/*1306*/ uint16(xSetOp), uint16(SMSW),
-	/*1308*/ uint16(xArgR64M16),
-	/*1309*/ uint16(xMatch),
-	/*1310*/ uint16(xSetOp), uint16(LMSW),
-	/*1312*/ uint16(xArgRM16),
-	/*1313*/ uint16(xMatch),
-	/*1314*/ uint16(xSetOp), uint16(INVLPG),
-	/*1316*/ uint16(xArgM),
-	/*1317*/ uint16(xMatch),
-	/*1318*/ uint16(xSetOp), uint16(MONITOR),
-	/*1320*/ uint16(xMatch),
-	/*1321*/ uint16(xSetOp), uint16(MWAIT),
-	/*1323*/ uint16(xMatch),
-	/*1324*/ uint16(xSetOp), uint16(XGETBV),
-	/*1326*/ uint16(xMatch),
-	/*1327*/ uint16(xSetOp), uint16(XSETBV),
-	/*1329*/ uint16(xMatch),
-	/*1330*/ uint16(xSetOp), uint16(XEND),
-	/*1332*/ uint16(xMatch),
-	/*1333*/ uint16(xSetOp), uint16(XTEST),
-	/*1335*/ uint16(xMatch),
-	/*1336*/ uint16(xCondIs64), 0, 1339,
-	/*1339*/ uint16(xSetOp), uint16(SWAPGS),
-	/*1341*/ uint16(xMatch),
-	/*1342*/ uint16(xSetOp), uint16(RDTSCP),
-	/*1344*/ uint16(xMatch),
-	/*1345*/ uint16(xCondDataSize), 1349, 1355, 1361,
-	/*1349*/ uint16(xSetOp), uint16(LAR),
-	/*1351*/ uint16(xReadSlashR),
-	/*1352*/ uint16(xArgR16),
-	/*1353*/ uint16(xArgRM16),
-	/*1354*/ uint16(xMatch),
-	/*1355*/ uint16(xSetOp), uint16(LAR),
-	/*1357*/ uint16(xReadSlashR),
-	/*1358*/ uint16(xArgR32),
-	/*1359*/ uint16(xArgR32M16),
-	/*1360*/ uint16(xMatch),
-	/*1361*/ uint16(xSetOp), uint16(LAR),
-	/*1363*/ uint16(xReadSlashR),
-	/*1364*/ uint16(xArgR64),
-	/*1365*/ uint16(xArgR64M16),
-	/*1366*/ uint16(xMatch),
-	/*1367*/ uint16(xCondDataSize), 1371, 1377, 1383,
-	/*1371*/ uint16(xSetOp), uint16(LSL),
-	/*1373*/ uint16(xReadSlashR),
-	/*1374*/ uint16(xArgR16),
-	/*1375*/ uint16(xArgRM16),
-	/*1376*/ uint16(xMatch),
-	/*1377*/ uint16(xSetOp), uint16(LSL),
-	/*1379*/ uint16(xReadSlashR),
-	/*1380*/ uint16(xArgR32),
-	/*1381*/ uint16(xArgR32M16),
-	/*1382*/ uint16(xMatch),
-	/*1383*/ uint16(xSetOp), uint16(LSL),
-	/*1385*/ uint16(xReadSlashR),
-	/*1386*/ uint16(xArgR64),
-	/*1387*/ uint16(xArgR32M16),
-	/*1388*/ uint16(xMatch),
-	/*1389*/ uint16(xCondIs64), 0, 1392,
-	/*1392*/ uint16(xSetOp), uint16(SYSCALL),
-	/*1394*/ uint16(xMatch),
-	/*1395*/ uint16(xSetOp), uint16(CLTS),
-	/*1397*/ uint16(xMatch),
-	/*1398*/ uint16(xCondIs64), 0, 1401,
-	/*1401*/ uint16(xSetOp), uint16(SYSRET),
-	/*1403*/ uint16(xMatch),
-	/*1404*/ uint16(xSetOp), uint16(INVD),
-	/*1406*/ uint16(xMatch),
-	/*1407*/ uint16(xSetOp), uint16(WBINVD),
-	/*1409*/ uint16(xMatch),
-	/*1410*/ uint16(xSetOp), uint16(UD2),
-	/*1412*/ uint16(xMatch),
-	/*1413*/ uint16(xCondSlashR),
+	1312, // 6
+	1316, // 7
+	/*1266*/ uint16(xSetOp), uint16(SGDT),
+	/*1268*/ uint16(xArgM),
+	/*1269*/ uint16(xMatch),
+	/*1270*/ uint16(xSetOp), uint16(SIDT),
+	/*1272*/ uint16(xArgM),
+	/*1273*/ uint16(xMatch),
+	/*1274*/ uint16(xCondIs64), 1277, 1281,
+	/*1277*/ uint16(xSetOp), uint16(LGDT),
+	/*1279*/ uint16(xArgM16and32),
+	/*1280*/ uint16(xMatch),
+	/*1281*/ uint16(xSetOp), uint16(LGDT),
+	/*1283*/ uint16(xArgM16and64),
+	/*1284*/ uint16(xMatch),
+	/*1285*/ uint16(xCondIs64), 1288, 1292,
+	/*1288*/ uint16(xSetOp), uint16(LIDT),
+	/*1290*/ uint16(xArgM16and32),
+	/*1291*/ uint16(xMatch),
+	/*1292*/ uint16(xSetOp), uint16(LIDT),
+	/*1294*/ uint16(xArgM16and64),
+	/*1295*/ uint16(xMatch),
+	/*1296*/ uint16(xCondDataSize), 1300, 1304, 1308,
+	/*1300*/ uint16(xSetOp), uint16(SMSW),
+	/*1302*/ uint16(xArgRM16),
+	/*1303*/ uint16(xMatch),
+	/*1304*/ uint16(xSetOp), uint16(SMSW),
+	/*1306*/ uint16(xArgR32M16),
+	/*1307*/ uint16(xMatch),
+	/*1308*/ uint16(xSetOp), uint16(SMSW),
+	/*1310*/ uint16(xArgR64M16),
+	/*1311*/ uint16(xMatch),
+	/*1312*/ uint16(xSetOp), uint16(LMSW),
+	/*1314*/ uint16(xArgRM16),
+	/*1315*/ uint16(xMatch),
+	/*1316*/ uint16(xSetOp), uint16(INVLPG),
+	/*1318*/ uint16(xArgM),
+	/*1319*/ uint16(xMatch),
+	/*1320*/ uint16(xSetOp), uint16(MONITOR),
+	/*1322*/ uint16(xMatch),
+	/*1323*/ uint16(xSetOp), uint16(MWAIT),
+	/*1325*/ uint16(xMatch),
+	/*1326*/ uint16(xSetOp), uint16(XGETBV),
+	/*1328*/ uint16(xMatch),
+	/*1329*/ uint16(xSetOp), uint16(XSETBV),
+	/*1331*/ uint16(xMatch),
+	/*1332*/ uint16(xSetOp), uint16(XEND),
+	/*1334*/ uint16(xMatch),
+	/*1335*/ uint16(xSetOp), uint16(XTEST),
+	/*1337*/ uint16(xMatch),
+	/*1338*/ uint16(xCondIs64), 0, 1341,
+	/*1341*/ uint16(xSetOp), uint16(SWAPGS),
+	/*1343*/ uint16(xMatch),
+	/*1344*/ uint16(xSetOp), uint16(RDTSCP),
+	/*1346*/ uint16(xMatch),
+	/*1347*/ uint16(xCondDataSize), 1351, 1357, 1363,
+	/*1351*/ uint16(xSetOp), uint16(LAR),
+	/*1353*/ uint16(xReadSlashR),
+	/*1354*/ uint16(xArgR16),
+	/*1355*/ uint16(xArgRM16),
+	/*1356*/ uint16(xMatch),
+	/*1357*/ uint16(xSetOp), uint16(LAR),
+	/*1359*/ uint16(xReadSlashR),
+	/*1360*/ uint16(xArgR32),
+	/*1361*/ uint16(xArgR32M16),
+	/*1362*/ uint16(xMatch),
+	/*1363*/ uint16(xSetOp), uint16(LAR),
+	/*1365*/ uint16(xReadSlashR),
+	/*1366*/ uint16(xArgR64),
+	/*1367*/ uint16(xArgR64M16),
+	/*1368*/ uint16(xMatch),
+	/*1369*/ uint16(xCondDataSize), 1373, 1379, 1385,
+	/*1373*/ uint16(xSetOp), uint16(LSL),
+	/*1375*/ uint16(xReadSlashR),
+	/*1376*/ uint16(xArgR16),
+	/*1377*/ uint16(xArgRM16),
+	/*1378*/ uint16(xMatch),
+	/*1379*/ uint16(xSetOp), uint16(LSL),
+	/*1381*/ uint16(xReadSlashR),
+	/*1382*/ uint16(xArgR32),
+	/*1383*/ uint16(xArgR32M16),
+	/*1384*/ uint16(xMatch),
+	/*1385*/ uint16(xSetOp), uint16(LSL),
+	/*1387*/ uint16(xReadSlashR),
+	/*1388*/ uint16(xArgR64),
+	/*1389*/ uint16(xArgR32M16),
+	/*1390*/ uint16(xMatch),
+	/*1391*/ uint16(xCondIs64), 0, 1394,
+	/*1394*/ uint16(xSetOp), uint16(SYSCALL),
+	/*1396*/ uint16(xMatch),
+	/*1397*/ uint16(xSetOp), uint16(CLTS),
+	/*1399*/ uint16(xMatch),
+	/*1400*/ uint16(xCondIs64), 0, 1403,
+	/*1403*/ uint16(xSetOp), uint16(SYSRET),
+	/*1405*/ uint16(xMatch),
+	/*1406*/ uint16(xSetOp), uint16(INVD),
+	/*1408*/ uint16(xMatch),
+	/*1409*/ uint16(xSetOp), uint16(WBINVD),
+	/*1411*/ uint16(xMatch),
+	/*1412*/ uint16(xSetOp), uint16(UD2),
+	/*1414*/ uint16(xMatch),
+	/*1415*/ uint16(xCondSlashR),
 	0,    // 0
-	1422, // 1
+	1424, // 1
 	0,    // 2
 	0,    // 3
 	0,    // 4
 	0,    // 5
 	0,    // 6
 	0,    // 7
-	/*1422*/ uint16(xSetOp), uint16(PREFETCHW),
-	/*1424*/ uint16(xArgM8),
-	/*1425*/ uint16(xMatch),
-	/*1426*/ uint16(xCondPrefix), 4,
-	0xF3, 1454,
-	0xF2, 1448,
-	0x66, 1442,
-	0x0, 1436,
-	/*1436*/ uint16(xSetOp), uint16(MOVUPS),
-	/*1438*/ uint16(xReadSlashR),
-	/*1439*/ uint16(xArgXmm1),
-	/*1440*/ uint16(xArgXmm2M128),
-	/*1441*/ uint16(xMatch),
-	/*1442*/ uint16(xSetOp), uint16(MOVUPD),
-	/*1444*/ uint16(xReadSlashR),
-	/*1445*/ uint16(xArgXmm1),
-	/*1446*/ uint16(xArgXmm2M128),
-	/*1447*/ uint16(xMatch),
-	/*1448*/ uint16(xSetOp), uint16(MOVSD_XMM),
-	/*1450*/ uint16(xReadSlashR),
-	/*1451*/ uint16(xArgXmm1),
-	/*1452*/ uint16(xArgXmm2M64),
-	/*1453*/ uint16(xMatch),
-	/*1454*/ uint16(xSetOp), uint16(MOVSS),
-	/*1456*/ uint16(xReadSlashR),
-	/*1457*/ uint16(xArgXmm1),
-	/*1458*/ uint16(xArgXmm2M32),
-	/*1459*/ uint16(xMatch),
-	/*1460*/ uint16(xCondPrefix), 4,
-	0xF3, 1488,
-	0xF2, 1482,
-	0x66, 1476,
-	0x0, 1470,
-	/*1470*/ uint16(xSetOp), uint16(MOVUPS),
-	/*1472*/ uint16(xReadSlashR),
-	/*1473*/ uint16(xArgXmm2M128),
-	/*1474*/ uint16(xArgXmm1),
-	/*1475*/ uint16(xMatch),
-	/*1476*/ uint16(xSetOp), uint16(MOVUPD),
-	/*1478*/ uint16(xReadSlashR),
-	/*1479*/ uint16(xArgXmm2M128),
-	/*1480*/ uint16(xArgXmm),
-	/*1481*/ uint16(xMatch),
-	/*1482*/ uint16(xSetOp), uint16(MOVSD_XMM),
-	/*1484*/ uint16(xReadSlashR),
-	/*1485*/ uint16(xArgXmm2M64),
-	/*1486*/ uint16(xArgXmm1),
-	/*1487*/ uint16(xMatch),
-	/*1488*/ uint16(xSetOp), uint16(MOVSS),
-	/*1490*/ uint16(xReadSlashR),
-	/*1491*/ uint16(xArgXmm2M32),
-	/*1492*/ uint16(xArgXmm),
-	/*1493*/ uint16(xMatch),
-	/*1494*/ uint16(xCondPrefix), 4,
-	0xF3, 1531,
-	0xF2, 1525,
-	0x66, 1519,
-	0x0, 1504,
-	/*1504*/ uint16(xCondIsMem), 1507, 1513,
-	/*1507*/ uint16(xSetOp), uint16(MOVHLPS),
-	/*1509*/ uint16(xReadSlashR),
-	/*1510*/ uint16(xArgXmm1),
-	/*1511*/ uint16(xArgXmm2),
-	/*1512*/ uint16(xMatch),
-	/*1513*/ uint16(xSetOp), uint16(MOVLPS),
-	/*1515*/ uint16(xReadSlashR),
-	/*1516*/ uint16(xArgXmm),
-	/*1517*/ uint16(xArgM64),
-	/*1518*/ uint16(xMatch),
-	/*1519*/ uint16(xSetOp), uint16(MOVLPD),
-	/*1521*/ uint16(xReadSlashR),
-	/*1522*/ uint16(xArgXmm),
-	/*1523*/ uint16(xArgXmm2M64),
-	/*1524*/ uint16(xMatch),
-	/*1525*/ uint16(xSetOp), uint16(MOVDDUP),
-	/*1527*/ uint16(xReadSlashR),
-	/*1528*/ uint16(xArgXmm1),
-	/*1529*/ uint16(xArgXmm2M64),
-	/*1530*/ uint16(xMatch),
-	/*1531*/ uint16(xSetOp), uint16(MOVSLDUP),
-	/*1533*/ uint16(xReadSlashR),
-	/*1534*/ uint16(xArgXmm1),
-	/*1535*/ uint16(xArgXmm2M128),
-	/*1536*/ uint16(xMatch),
-	/*1537*/ uint16(xCondPrefix), 2,
-	0x66, 1549,
-	0x0, 1543,
-	/*1543*/ uint16(xSetOp), uint16(MOVLPS),
-	/*1545*/ uint16(xReadSlashR),
-	/*1546*/ uint16(xArgM64),
-	/*1547*/ uint16(xArgXmm),
-	/*1548*/ uint16(xMatch),
-	/*1549*/ uint16(xSetOp), uint16(MOVLPD),
-	/*1551*/ uint16(xReadSlashR),
-	/*1552*/ uint16(xArgXmm2M64),
-	/*1553*/ uint16(xArgXmm),
-	/*1554*/ uint16(xMatch),
-	/*1555*/ uint16(xCondPrefix), 2,
-	0x66, 1567,
-	0x0, 1561,
-	/*1561*/ uint16(xSetOp), uint16(UNPCKLPS),
-	/*1563*/ uint16(xReadSlashR),
-	/*1564*/ uint16(xArgXmm1),
-	/*1565*/ uint16(xArgXmm2M128),
-	/*1566*/ uint16(xMatch),
-	/*1567*/ uint16(xSetOp), uint16(UNPCKLPD),
-	/*1569*/ uint16(xReadSlashR),
-	/*1570*/ uint16(xArgXmm1),
-	/*1571*/ uint16(xArgXmm2M128),
-	/*1572*/ uint16(xMatch),
-	/*1573*/ uint16(xCondPrefix), 2,
-	0x66, 1585,
-	0x0, 1579,
-	/*1579*/ uint16(xSetOp), uint16(UNPCKHPS),
-	/*1581*/ uint16(xReadSlashR),
-	/*1582*/ uint16(xArgXmm1),
-	/*1583*/ uint16(xArgXmm2M128),
-	/*1584*/ uint16(xMatch),
-	/*1585*/ uint16(xSetOp), uint16(UNPCKHPD),
-	/*1587*/ uint16(xReadSlashR),
-	/*1588*/ uint16(xArgXmm1),
-	/*1589*/ uint16(xArgXmm2M128),
-	/*1590*/ uint16(xMatch),
-	/*1591*/ uint16(xCondPrefix), 3,
-	0xF3, 1620,
-	0x66, 1614,
-	0x0, 1599,
-	/*1599*/ uint16(xCondIsMem), 1602, 1608,
-	/*1602*/ uint16(xSetOp), uint16(MOVLHPS),
-	/*1604*/ uint16(xReadSlashR),
-	/*1605*/ uint16(xArgXmm1),
-	/*1606*/ uint16(xArgXmm2),
-	/*1607*/ uint16(xMatch),
-	/*1608*/ uint16(xSetOp), uint16(MOVHPS),
-	/*1610*/ uint16(xReadSlashR),
-	/*1611*/ uint16(xArgXmm),
-	/*1612*/ uint16(xArgM64),
-	/*1613*/ uint16(xMatch),
-	/*1614*/ uint16(xSetOp), uint16(MOVHPD),
-	/*1616*/ uint16(xReadSlashR),
-	/*1617*/ uint16(xArgXmm),
-	/*1618*/ uint16(xArgXmm2M64),
-	/*1619*/ uint16(xMatch),
-	/*1620*/ uint16(xSetOp), uint16(MOVSHDUP),
-	/*1622*/ uint16(xReadSlashR),
-	/*1623*/ uint16(xArgXmm1),
-	/*1624*/ uint16(xArgXmm2M128),
-	/*1625*/ uint16(xMatch),
-	/*1626*/ uint16(xCondPrefix), 2,
-	0x66, 1638,
-	0x0, 1632,
-	/*1632*/ uint16(xSetOp), uint16(MOVHPS),
-	/*1634*/ uint16(xReadSlashR),
-	/*1635*/ uint16(xArgM64),
-	/*1636*/ uint16(xArgXmm),
-	/*1637*/ uint16(xMatch),
-	/*1638*/ uint16(xSetOp), uint16(MOVHPD),
-	/*1640*/ uint16(xReadSlashR),
-	/*1641*/ uint16(xArgXmm2M64),
-	/*1642*/ uint16(xArgXmm),
-	/*1643*/ uint16(xMatch),
-	/*1644*/ uint16(xCondSlashR),
-	1653, // 0
-	1657, // 1
-	1661, // 2
-	1665, // 3
+	/*1424*/ uint16(xSetOp), uint16(PREFETCHW),
+	/*1426*/ uint16(xArgM8),
+	/*1427*/ uint16(xMatch),
+	/*1428*/ uint16(xCondPrefix), 4,
+	0xF3, 1456,
+	0xF2, 1450,
+	0x66, 1444,
+	0x0, 1438,
+	/*1438*/ uint16(xSetOp), uint16(MOVUPS),
+	/*1440*/ uint16(xReadSlashR),
+	/*1441*/ uint16(xArgXmm1),
+	/*1442*/ uint16(xArgXmm2M128),
+	/*1443*/ uint16(xMatch),
+	/*1444*/ uint16(xSetOp), uint16(MOVUPD),
+	/*1446*/ uint16(xReadSlashR),
+	/*1447*/ uint16(xArgXmm1),
+	/*1448*/ uint16(xArgXmm2M128),
+	/*1449*/ uint16(xMatch),
+	/*1450*/ uint16(xSetOp), uint16(MOVSD_XMM),
+	/*1452*/ uint16(xReadSlashR),
+	/*1453*/ uint16(xArgXmm1),
+	/*1454*/ uint16(xArgXmm2M64),
+	/*1455*/ uint16(xMatch),
+	/*1456*/ uint16(xSetOp), uint16(MOVSS),
+	/*1458*/ uint16(xReadSlashR),
+	/*1459*/ uint16(xArgXmm1),
+	/*1460*/ uint16(xArgXmm2M32),
+	/*1461*/ uint16(xMatch),
+	/*1462*/ uint16(xCondPrefix), 4,
+	0xF3, 1490,
+	0xF2, 1484,
+	0x66, 1478,
+	0x0, 1472,
+	/*1472*/ uint16(xSetOp), uint16(MOVUPS),
+	/*1474*/ uint16(xReadSlashR),
+	/*1475*/ uint16(xArgXmm2M128),
+	/*1476*/ uint16(xArgXmm1),
+	/*1477*/ uint16(xMatch),
+	/*1478*/ uint16(xSetOp), uint16(MOVUPD),
+	/*1480*/ uint16(xReadSlashR),
+	/*1481*/ uint16(xArgXmm2M128),
+	/*1482*/ uint16(xArgXmm),
+	/*1483*/ uint16(xMatch),
+	/*1484*/ uint16(xSetOp), uint16(MOVSD_XMM),
+	/*1486*/ uint16(xReadSlashR),
+	/*1487*/ uint16(xArgXmm2M64),
+	/*1488*/ uint16(xArgXmm1),
+	/*1489*/ uint16(xMatch),
+	/*1490*/ uint16(xSetOp), uint16(MOVSS),
+	/*1492*/ uint16(xReadSlashR),
+	/*1493*/ uint16(xArgXmm2M32),
+	/*1494*/ uint16(xArgXmm),
+	/*1495*/ uint16(xMatch),
+	/*1496*/ uint16(xCondPrefix), 4,
+	0xF3, 1533,
+	0xF2, 1527,
+	0x66, 1521,
+	0x0, 1506,
+	/*1506*/ uint16(xCondIsMem), 1509, 1515,
+	/*1509*/ uint16(xSetOp), uint16(MOVHLPS),
+	/*1511*/ uint16(xReadSlashR),
+	/*1512*/ uint16(xArgXmm1),
+	/*1513*/ uint16(xArgXmm2),
+	/*1514*/ uint16(xMatch),
+	/*1515*/ uint16(xSetOp), uint16(MOVLPS),
+	/*1517*/ uint16(xReadSlashR),
+	/*1518*/ uint16(xArgXmm),
+	/*1519*/ uint16(xArgM64),
+	/*1520*/ uint16(xMatch),
+	/*1521*/ uint16(xSetOp), uint16(MOVLPD),
+	/*1523*/ uint16(xReadSlashR),
+	/*1524*/ uint16(xArgXmm),
+	/*1525*/ uint16(xArgXmm2M64),
+	/*1526*/ uint16(xMatch),
+	/*1527*/ uint16(xSetOp), uint16(MOVDDUP),
+	/*1529*/ uint16(xReadSlashR),
+	/*1530*/ uint16(xArgXmm1),
+	/*1531*/ uint16(xArgXmm2M64),
+	/*1532*/ uint16(xMatch),
+	/*1533*/ uint16(xSetOp), uint16(MOVSLDUP),
+	/*1535*/ uint16(xReadSlashR),
+	/*1536*/ uint16(xArgXmm1),
+	/*1537*/ uint16(xArgXmm2M128),
+	/*1538*/ uint16(xMatch),
+	/*1539*/ uint16(xCondPrefix), 2,
+	0x66, 1551,
+	0x0, 1545,
+	/*1545*/ uint16(xSetOp), uint16(MOVLPS),
+	/*1547*/ uint16(xReadSlashR),
+	/*1548*/ uint16(xArgM64),
+	/*1549*/ uint16(xArgXmm),
+	/*1550*/ uint16(xMatch),
+	/*1551*/ uint16(xSetOp), uint16(MOVLPD),
+	/*1553*/ uint16(xReadSlashR),
+	/*1554*/ uint16(xArgXmm2M64),
+	/*1555*/ uint16(xArgXmm),
+	/*1556*/ uint16(xMatch),
+	/*1557*/ uint16(xCondPrefix), 2,
+	0x66, 1569,
+	0x0, 1563,
+	/*1563*/ uint16(xSetOp), uint16(UNPCKLPS),
+	/*1565*/ uint16(xReadSlashR),
+	/*1566*/ uint16(xArgXmm1),
+	/*1567*/ uint16(xArgXmm2M128),
+	/*1568*/ uint16(xMatch),
+	/*1569*/ uint16(xSetOp), uint16(UNPCKLPD),
+	/*1571*/ uint16(xReadSlashR),
+	/*1572*/ uint16(xArgXmm1),
+	/*1573*/ uint16(xArgXmm2M128),
+	/*1574*/ uint16(xMatch),
+	/*1575*/ uint16(xCondPrefix), 2,
+	0x66, 1587,
+	0x0, 1581,
+	/*1581*/ uint16(xSetOp), uint16(UNPCKHPS),
+	/*1583*/ uint16(xReadSlashR),
+	/*1584*/ uint16(xArgXmm1),
+	/*1585*/ uint16(xArgXmm2M128),
+	/*1586*/ uint16(xMatch),
+	/*1587*/ uint16(xSetOp), uint16(UNPCKHPD),
+	/*1589*/ uint16(xReadSlashR),
+	/*1590*/ uint16(xArgXmm1),
+	/*1591*/ uint16(xArgXmm2M128),
+	/*1592*/ uint16(xMatch),
+	/*1593*/ uint16(xCondPrefix), 3,
+	0xF3, 1622,
+	0x66, 1616,
+	0x0, 1601,
+	/*1601*/ uint16(xCondIsMem), 1604, 1610,
+	/*1604*/ uint16(xSetOp), uint16(MOVLHPS),
+	/*1606*/ uint16(xReadSlashR),
+	/*1607*/ uint16(xArgXmm1),
+	/*1608*/ uint16(xArgXmm2),
+	/*1609*/ uint16(xMatch),
+	/*1610*/ uint16(xSetOp), uint16(MOVHPS),
+	/*1612*/ uint16(xReadSlashR),
+	/*1613*/ uint16(xArgXmm),
+	/*1614*/ uint16(xArgM64),
+	/*1615*/ uint16(xMatch),
+	/*1616*/ uint16(xSetOp), uint16(MOVHPD),
+	/*1618*/ uint16(xReadSlashR),
+	/*1619*/ uint16(xArgXmm),
+	/*1620*/ uint16(xArgXmm2M64),
+	/*1621*/ uint16(xMatch),
+	/*1622*/ uint16(xSetOp), uint16(MOVSHDUP),
+	/*1624*/ uint16(xReadSlashR),
+	/*1625*/ uint16(xArgXmm1),
+	/*1626*/ uint16(xArgXmm2M128),
+	/*1627*/ uint16(xMatch),
+	/*1628*/ uint16(xCondPrefix), 2,
+	0x66, 1640,
+	0x0, 1634,
+	/*1634*/ uint16(xSetOp), uint16(MOVHPS),
+	/*1636*/ uint16(xReadSlashR),
+	/*1637*/ uint16(xArgM64),
+	/*1638*/ uint16(xArgXmm),
+	/*1639*/ uint16(xMatch),
+	/*1640*/ uint16(xSetOp), uint16(MOVHPD),
+	/*1642*/ uint16(xReadSlashR),
+	/*1643*/ uint16(xArgXmm2M64),
+	/*1644*/ uint16(xArgXmm),
+	/*1645*/ uint16(xMatch),
+	/*1646*/ uint16(xCondSlashR),
+	1655, // 0
+	1659, // 1
+	1663, // 2
+	1667, // 3
 	0,    // 4
 	0,    // 5
 	0,    // 6
 	0,    // 7
-	/*1653*/ uint16(xSetOp), uint16(PREFETCHNTA),
-	/*1655*/ uint16(xArgM8),
-	/*1656*/ uint16(xMatch),
-	/*1657*/ uint16(xSetOp), uint16(PREFETCHT0),
-	/*1659*/ uint16(xArgM8),
-	/*1660*/ uint16(xMatch),
-	/*1661*/ uint16(xSetOp), uint16(PREFETCHT1),
-	/*1663*/ uint16(xArgM8),
-	/*1664*/ uint16(xMatch),
-	/*1665*/ uint16(xSetOp), uint16(PREFETCHT2),
-	/*1667*/ uint16(xArgM8),
-	/*1668*/ uint16(xMatch),
-	/*1669*/ uint16(xCondSlashR),
-	1678, // 0
+	/*1655*/ uint16(xSetOp), uint16(PREFETCHNTA),
+	/*1657*/ uint16(xArgM8),
+	/*1658*/ uint16(xMatch),
+	/*1659*/ uint16(xSetOp), uint16(PREFETCHT0),
+	/*1661*/ uint16(xArgM8),
+	/*1662*/ uint16(xMatch),
+	/*1663*/ uint16(xSetOp), uint16(PREFETCHT1),
+	/*1665*/ uint16(xArgM8),
+	/*1666*/ uint16(xMatch),
+	/*1667*/ uint16(xSetOp), uint16(PREFETCHT2),
+	/*1669*/ uint16(xArgM8),
+	/*1670*/ uint16(xMatch),
+	/*1671*/ uint16(xCondSlashR),
+	1680, // 0
 	0,    // 1
 	0,    // 2
 	0,    // 3
@@ -988,5551 +989,5561 @@ var decoder = [...]uint16{
 	0,    // 5
 	0,    // 6
 	0,    // 7
-	/*1678*/ uint16(xCondDataSize), 1682, 1686, 0,
-	/*1682*/ uint16(xSetOp), uint16(NOP),
-	/*1684*/ uint16(xArgRM16),
-	/*1685*/ uint16(xMatch),
-	/*1686*/ uint16(xSetOp), uint16(NOP),
-	/*1688*/ uint16(xArgRM32),
-	/*1689*/ uint16(xMatch),
-	/*1690*/ uint16(xCondIs64), 1693, 1699,
-	/*1693*/ uint16(xSetOp), uint16(MOV),
-	/*1695*/ uint16(xReadSlashR),
-	/*1696*/ uint16(xArgRmf32),
-	/*1697*/ uint16(xArgCR0dashCR7),
-	/*1698*/ uint16(xMatch),
-	/*1699*/ uint16(xSetOp), uint16(MOV),
-	/*1701*/ uint16(xReadSlashR),
-	/*1702*/ uint16(xArgRmf64),
-	/*1703*/ uint16(xArgCR0dashCR7),
-	/*1704*/ uint16(xMatch),
-	/*1705*/ uint16(xCondIs64), 1708, 1714,
-	/*1708*/ uint16(xSetOp), uint16(MOV),
-	/*1710*/ uint16(xReadSlashR),
-	/*1711*/ uint16(xArgRmf32),
-	/*1712*/ uint16(xArgDR0dashDR7),
-	/*1713*/ uint16(xMatch),
-	/*1714*/ uint16(xSetOp), uint16(MOV),
-	/*1716*/ uint16(xReadSlashR),
-	/*1717*/ uint16(xArgRmf64),
-	/*1718*/ uint16(xArgDR0dashDR7),
-	/*1719*/ uint16(xMatch),
-	/*1720*/ uint16(xCondIs64), 1723, 1729,
-	/*1723*/ uint16(xSetOp), uint16(MOV),
-	/*1725*/ uint16(xReadSlashR),
-	/*1726*/ uint16(xArgCR0dashCR7),
-	/*1727*/ uint16(xArgRmf32),
-	/*1728*/ uint16(xMatch),
-	/*1729*/ uint16(xSetOp), uint16(MOV),
-	/*1731*/ uint16(xReadSlashR),
-	/*1732*/ uint16(xArgCR0dashCR7),
-	/*1733*/ uint16(xArgRmf64),
-	/*1734*/ uint16(xMatch),
-	/*1735*/ uint16(xCondIs64), 1738, 1744,
-	/*1738*/ uint16(xSetOp), uint16(MOV),
-	/*1740*/ uint16(xReadSlashR),
-	/*1741*/ uint16(xArgDR0dashDR7),
-	/*1742*/ uint16(xArgRmf32),
-	/*1743*/ uint16(xMatch),
-	/*1744*/ uint16(xSetOp), uint16(MOV),
-	/*1746*/ uint16(xReadSlashR),
-	/*1747*/ uint16(xArgDR0dashDR7),
-	/*1748*/ uint16(xArgRmf64),
-	/*1749*/ uint16(xMatch),
-	/*1750*/ uint16(xCondIs64), 1753, 1759,
-	/*1753*/ uint16(xSetOp), uint16(MOV),
-	/*1755*/ uint16(xReadSlashR),
-	/*1756*/ uint16(xArgRmf32),
-	/*1757*/ uint16(xArgTR0dashTR7),
-	/*1758*/ uint16(xMatch),
-	/*1759*/ uint16(xSetOp), uint16(MOV),
-	/*1761*/ uint16(xReadSlashR),
-	/*1762*/ uint16(xArgRmf64),
-	/*1763*/ uint16(xArgTR0dashTR7),
-	/*1764*/ uint16(xMatch),
-	/*1765*/ uint16(xCondIs64), 1768, 1774,
-	/*1768*/ uint16(xSetOp), uint16(MOV),
-	/*1770*/ uint16(xReadSlashR),
-	/*1771*/ uint16(xArgTR0dashTR7),
-	/*1772*/ uint16(xArgRmf32),
-	/*1773*/ uint16(xMatch),
-	/*1774*/ uint16(xSetOp), uint16(MOV),
-	/*1776*/ uint16(xReadSlashR),
-	/*1777*/ uint16(xArgTR0dashTR7),
-	/*1778*/ uint16(xArgRmf64),
-	/*1779*/ uint16(xMatch),
-	/*1780*/ uint16(xCondPrefix), 2,
-	0x66, 1792,
-	0x0, 1786,
-	/*1786*/ uint16(xSetOp), uint16(MOVAPS),
-	/*1788*/ uint16(xReadSlashR),
-	/*1789*/ uint16(xArgXmm1),
-	/*1790*/ uint16(xArgXmm2M128),
-	/*1791*/ uint16(xMatch),
-	/*1792*/ uint16(xSetOp), uint16(MOVAPD),
-	/*1794*/ uint16(xReadSlashR),
-	/*1795*/ uint16(xArgXmm1),
-	/*1796*/ uint16(xArgXmm2M128),
-	/*1797*/ uint16(xMatch),
-	/*1798*/ uint16(xCondPrefix), 2,
-	0x66, 1810,
-	0x0, 1804,
-	/*1804*/ uint16(xSetOp), uint16(MOVAPS),
-	/*1806*/ uint16(xReadSlashR),
-	/*1807*/ uint16(xArgXmm2M128),
-	/*1808*/ uint16(xArgXmm1),
-	/*1809*/ uint16(xMatch),
-	/*1810*/ uint16(xSetOp), uint16(MOVAPD),
-	/*1812*/ uint16(xReadSlashR),
-	/*1813*/ uint16(xArgXmm2M128),
-	/*1814*/ uint16(xArgXmm1),
-	/*1815*/ uint16(xMatch),
-	/*1816*/ uint16(xCondIs64), 1819, 1873,
-	/*1819*/ uint16(xCondPrefix), 4,
-	0xF3, 1857,
-	0xF2, 1841,
-	0x66, 1835,
-	0x0, 1829,
-	/*1829*/ uint16(xSetOp), uint16(CVTPI2PS),
-	/*1831*/ uint16(xReadSlashR),
-	/*1832*/ uint16(xArgXmm),
-	/*1833*/ uint16(xArgMmM64),
-	/*1834*/ uint16(xMatch),
-	/*1835*/ uint16(xSetOp), uint16(CVTPI2PD),
-	/*1837*/ uint16(xReadSlashR),
-	/*1838*/ uint16(xArgXmm),
-	/*1839*/ uint16(xArgMmM64),
-	/*1840*/ uint16(xMatch),
-	/*1841*/ uint16(xCondDataSize), 1845, 1851, 0,
-	/*1845*/ uint16(xSetOp), uint16(CVTSI2SD),
-	/*1847*/ uint16(xReadSlashR),
-	/*1848*/ uint16(xArgXmm),
-	/*1849*/ uint16(xArgRM32),
-	/*1850*/ uint16(xMatch),
-	/*1851*/ uint16(xSetOp), uint16(CVTSI2SD),
-	/*1853*/ uint16(xReadSlashR),
-	/*1854*/ uint16(xArgXmm),
-	/*1855*/ uint16(xArgRM32),
-	/*1856*/ uint16(xMatch),
-	/*1857*/ uint16(xCondDataSize), 1861, 1867, 0,
-	/*1861*/ uint16(xSetOp), uint16(CVTSI2SS),
-	/*1863*/ uint16(xReadSlashR),
-	/*1864*/ uint16(xArgXmm),
-	/*1865*/ uint16(xArgRM32),
-	/*1866*/ uint16(xMatch),
-	/*1867*/ uint16(xSetOp), uint16(CVTSI2SS),
-	/*1869*/ uint16(xReadSlashR),
-	/*1870*/ uint16(xArgXmm),
-	/*1871*/ uint16(xArgRM32),
-	/*1872*/ uint16(xMatch),
-	/*1873*/ uint16(xCondPrefix), 4,
-	0xF3, 1893,
-	0xF2, 1883,
-	0x66, 1835,
-	0x0, 1829,
-	/*1883*/ uint16(xCondDataSize), 1845, 1851, 1887,
-	/*1887*/ uint16(xSetOp), uint16(CVTSI2SD),
-	/*1889*/ uint16(xReadSlashR),
-	/*1890*/ uint16(xArgXmm),
-	/*1891*/ uint16(xArgRM64),
-	/*1892*/ uint16(xMatch),
-	/*1893*/ uint16(xCondDataSize), 1861, 1867, 1897,
-	/*1897*/ uint16(xSetOp), uint16(CVTSI2SS),
-	/*1899*/ uint16(xReadSlashR),
-	/*1900*/ uint16(xArgXmm),
-	/*1901*/ uint16(xArgRM64),
-	/*1902*/ uint16(xMatch),
-	/*1903*/ uint16(xCondPrefix), 4,
-	0xF3, 1931,
-	0xF2, 1925,
-	0x66, 1919,
-	0x0, 1913,
-	/*1913*/ uint16(xSetOp), uint16(MOVNTPS),
-	/*1915*/ uint16(xReadSlashR),
-	/*1916*/ uint16(xArgM128),
-	/*1917*/ uint16(xArgXmm),
-	/*1918*/ uint16(xMatch),
-	/*1919*/ uint16(xSetOp), uint16(MOVNTPD),
-	/*1921*/ uint16(xReadSlashR),
-	/*1922*/ uint16(xArgM128),
-	/*1923*/ uint16(xArgXmm),
-	/*1924*/ uint16(xMatch),
-	/*1925*/ uint16(xSetOp), uint16(MOVNTSD),
-	/*1927*/ uint16(xReadSlashR),
-	/*1928*/ uint16(xArgM64),
-	/*1929*/ uint16(xArgXmm),
-	/*1930*/ uint16(xMatch),
-	/*1931*/ uint16(xSetOp), uint16(MOVNTSS),
-	/*1933*/ uint16(xReadSlashR),
-	/*1934*/ uint16(xArgM32),
-	/*1935*/ uint16(xArgXmm),
-	/*1936*/ uint16(xMatch),
-	/*1937*/ uint16(xCondIs64), 1940, 1994,
-	/*1940*/ uint16(xCondPrefix), 4,
-	0xF3, 1978,
-	0xF2, 1962,
-	0x66, 1956,
-	0x0, 1950,
-	/*1950*/ uint16(xSetOp), uint16(CVTTPS2PI),
-	/*1952*/ uint16(xReadSlashR),
-	/*1953*/ uint16(xArgMm),
-	/*1954*/ uint16(xArgXmmM64),
-	/*1955*/ uint16(xMatch),
-	/*1956*/ uint16(xSetOp), uint16(CVTTPD2PI),
-	/*1958*/ uint16(xReadSlashR),
-	/*1959*/ uint16(xArgMm),
-	/*1960*/ uint16(xArgXmmM128),
-	/*1961*/ uint16(xMatch),
-	/*1962*/ uint16(xCondDataSize), 1966, 1972, 0,
-	/*1966*/ uint16(xSetOp), uint16(CVTTSD2SI),
-	/*1968*/ uint16(xReadSlashR),
-	/*1969*/ uint16(xArgR32),
-	/*1970*/ uint16(xArgXmmM64),
-	/*1971*/ uint16(xMatch),
-	/*1972*/ uint16(xSetOp), uint16(CVTTSD2SI),
-	/*1974*/ uint16(xReadSlashR),
-	/*1975*/ uint16(xArgR32),
-	/*1976*/ uint16(xArgXmmM64),
-	/*1977*/ uint16(xMatch),
-	/*1978*/ uint16(xCondDataSize), 1982, 1988, 0,
-	/*1982*/ uint16(xSetOp), uint16(CVTTSS2SI),
-	/*1984*/ uint16(xReadSlashR),
-	/*1985*/ uint16(xArgR32),
-	/*1986*/ uint16(xArgXmmM32),
-	/*1987*/ uint16(xMatch),
-	/*1988*/ uint16(xSetOp), uint16(CVTTSS2SI),
-	/*1990*/ uint16(xReadSlashR),
-	/*1991*/ uint16(xArgR32),
-	/*1992*/ uint16(xArgXmmM32),
-	/*1993*/ uint16(xMatch),
-	/*1994*/ uint16(xCondPrefix), 4,
-	0xF3, 2014,
-	0xF2, 2004,
-	0x66, 1956,
-	0x0, 1950,
-	/*2004*/ uint16(xCondDataSize), 1966, 1972, 2008,
-	/*2008*/ uint16(xSetOp), uint16(CVTTSD2SI),
-	/*2010*/ uint16(xReadSlashR),
-	/*2011*/ uint16(xArgR64),
-	/*2012*/ uint16(xArgXmmM64),
-	/*2013*/ uint16(xMatch),
-	/*2014*/ uint16(xCondDataSize), 1982, 1988, 2018,
-	/*2018*/ uint16(xSetOp), uint16(CVTTSS2SI),
-	/*2020*/ uint16(xReadSlashR),
-	/*2021*/ uint16(xArgR64),
-	/*2022*/ uint16(xArgXmmM32),
-	/*2023*/ uint16(xMatch),
-	/*2024*/ uint16(xCondIs64), 2027, 2081,
-	/*2027*/ uint16(xCondPrefix), 4,
-	0xF3, 2065,
-	0xF2, 2049,
-	0x66, 2043,
-	0x0, 2037,
-	/*2037*/ uint16(xSetOp), uint16(CVTPS2PI),
-	/*2039*/ uint16(xReadSlashR),
-	/*2040*/ uint16(xArgMm),
-	/*2041*/ uint16(xArgXmmM64),
-	/*2042*/ uint16(xMatch),
-	/*2043*/ uint16(xSetOp), uint16(CVTPD2PI),
-	/*2045*/ uint16(xReadSlashR),
-	/*2046*/ uint16(xArgMm),
-	/*2047*/ uint16(xArgXmmM128),
-	/*2048*/ uint16(xMatch),
-	/*2049*/ uint16(xCondDataSize), 2053, 2059, 0,
-	/*2053*/ uint16(xSetOp), uint16(CVTSD2SI),
-	/*2055*/ uint16(xReadSlashR),
-	/*2056*/ uint16(xArgR32),
-	/*2057*/ uint16(xArgXmmM64),
-	/*2058*/ uint16(xMatch),
-	/*2059*/ uint16(xSetOp), uint16(CVTSD2SI),
-	/*2061*/ uint16(xReadSlashR),
-	/*2062*/ uint16(xArgR32),
-	/*2063*/ uint16(xArgXmmM64),
-	/*2064*/ uint16(xMatch),
-	/*2065*/ uint16(xCondDataSize), 2069, 2075, 0,
-	/*2069*/ uint16(xSetOp), uint16(CVTSS2SI),
-	/*2071*/ uint16(xReadSlashR),
-	/*2072*/ uint16(xArgR32),
-	/*2073*/ uint16(xArgXmmM32),
-	/*2074*/ uint16(xMatch),
-	/*2075*/ uint16(xSetOp), uint16(CVTSS2SI),
-	/*2077*/ uint16(xReadSlashR),
-	/*2078*/ uint16(xArgR32),
-	/*2079*/ uint16(xArgXmmM32),
-	/*2080*/ uint16(xMatch),
-	/*2081*/ uint16(xCondPrefix), 4,
-	0xF3, 2101,
-	0xF2, 2091,
-	0x66, 2043,
-	0x0, 2037,
-	/*2091*/ uint16(xCondDataSize), 2053, 2059, 2095,
-	/*2095*/ uint16(xSetOp), uint16(CVTSD2SI),
-	/*2097*/ uint16(xReadSlashR),
-	/*2098*/ uint16(xArgR64),
-	/*2099*/ uint16(xArgXmmM64),
-	/*2100*/ uint16(xMatch),
-	/*2101*/ uint16(xCondDataSize), 2069, 2075, 2105,
-	/*2105*/ uint16(xSetOp), uint16(CVTSS2SI),
-	/*2107*/ uint16(xReadSlashR),
-	/*2108*/ uint16(xArgR64),
-	/*2109*/ uint16(xArgXmmM32),
-	/*2110*/ uint16(xMatch),
-	/*2111*/ uint16(xCondPrefix), 2,
-	0x66, 2123,
-	0x0, 2117,
-	/*2117*/ uint16(xSetOp), uint16(UCOMISS),
-	/*2119*/ uint16(xReadSlashR),
-	/*2120*/ uint16(xArgXmm1),
-	/*2121*/ uint16(xArgXmm2M32),
-	/*2122*/ uint16(xMatch),
-	/*2123*/ uint16(xSetOp), uint16(UCOMISD),
-	/*2125*/ uint16(xReadSlashR),
-	/*2126*/ uint16(xArgXmm1),
-	/*2127*/ uint16(xArgXmm2M64),
-	/*2128*/ uint16(xMatch),
-	/*2129*/ uint16(xCondPrefix), 2,
-	0x66, 2141,
-	0x0, 2135,
-	/*2135*/ uint16(xSetOp), uint16(COMISS),
-	/*2137*/ uint16(xReadSlashR),
-	/*2138*/ uint16(xArgXmm1),
-	/*2139*/ uint16(xArgXmm2M32),
-	/*2140*/ uint16(xMatch),
-	/*2141*/ uint16(xSetOp), uint16(COMISD),
-	/*2143*/ uint16(xReadSlashR),
-	/*2144*/ uint16(xArgXmm1),
-	/*2145*/ uint16(xArgXmm2M64),
-	/*2146*/ uint16(xMatch),
-	/*2147*/ uint16(xSetOp), uint16(WRMSR),
-	/*2149*/ uint16(xMatch),
-	/*2150*/ uint16(xSetOp), uint16(RDTSC),
-	/*2152*/ uint16(xMatch),
-	/*2153*/ uint16(xSetOp), uint16(RDMSR),
-	/*2155*/ uint16(xMatch),
-	/*2156*/ uint16(xSetOp), uint16(RDPMC),
-	/*2158*/ uint16(xMatch),
-	/*2159*/ uint16(xSetOp), uint16(SYSENTER),
-	/*2161*/ uint16(xMatch),
-	/*2162*/ uint16(xCondDataSize), 2166, 2166, 2169,
-	/*2166*/ uint16(xSetOp), uint16(SYSEXIT),
-	/*2168*/ uint16(xMatch),
-	/*2169*/ uint16(xSetOp), uint16(SYSEXIT),
-	/*2171*/ uint16(xMatch),
-	/*2172*/ uint16(xCondByte), 54,
-	0x00, 2283,
-	0x01, 2301,
-	0x02, 2319,
-	0x03, 2337,
-	0x04, 2355,
-	0x05, 2373,
-	0x06, 2391,
-	0x07, 2409,
-	0x08, 2427,
-	0x09, 2445,
-	0x0A, 2463,
-	0x0B, 2481,
-	0x10, 2499,
-	0x14, 2510,
-	0x15, 2521,
-	0x17, 2532,
-	0x1C, 2542,
-	0x1D, 2560,
-	0x1E, 2578,
-	0x20, 2596,
-	0x21, 2606,
-	0x22, 2616,
-	0x23, 2626,
-	0x24, 2636,
-	0x25, 2646,
-	0x28, 2656,
-	0x29, 2666,
-	0x2A, 2676,
-	0x2B, 2686,
-	0x30, 2696,
-	0x31, 2706,
-	0x32, 2716,
-	0x33, 2726,
-	0x34, 2736,
-	0x35, 2746,
-	0x37, 2756,
-	0x38, 2766,
-	0x39, 2776,
-	0x3A, 2786,
-	0x3B, 2796,
-	0x3C, 2806,
-	0x3D, 2816,
-	0x3E, 2826,
-	0x3F, 2836,
-	0x40, 2846,
-	0x41, 2856,
-	0x82, 2866,
-	0xDB, 2889,
-	0xDC, 2899,
-	0xDD, 2909,
-	0xDE, 2919,
-	0xDF, 2929,
-	0xF0, 2939,
-	0xF1, 3006,
+	/*1680*/ uint16(xCondDataSize), 1684, 1688, 0,
+	/*1684*/ uint16(xSetOp), uint16(NOP),
+	/*1686*/ uint16(xArgRM16),
+	/*1687*/ uint16(xMatch),
+	/*1688*/ uint16(xSetOp), uint16(NOP),
+	/*1690*/ uint16(xArgRM32),
+	/*1691*/ uint16(xMatch),
+	/*1692*/ uint16(xCondIs64), 1695, 1701,
+	/*1695*/ uint16(xSetOp), uint16(MOV),
+	/*1697*/ uint16(xReadSlashR),
+	/*1698*/ uint16(xArgRmf32),
+	/*1699*/ uint16(xArgCR0dashCR7),
+	/*1700*/ uint16(xMatch),
+	/*1701*/ uint16(xSetOp), uint16(MOV),
+	/*1703*/ uint16(xReadSlashR),
+	/*1704*/ uint16(xArgRmf64),
+	/*1705*/ uint16(xArgCR0dashCR7),
+	/*1706*/ uint16(xMatch),
+	/*1707*/ uint16(xCondIs64), 1710, 1716,
+	/*1710*/ uint16(xSetOp), uint16(MOV),
+	/*1712*/ uint16(xReadSlashR),
+	/*1713*/ uint16(xArgRmf32),
+	/*1714*/ uint16(xArgDR0dashDR7),
+	/*1715*/ uint16(xMatch),
+	/*1716*/ uint16(xSetOp), uint16(MOV),
+	/*1718*/ uint16(xReadSlashR),
+	/*1719*/ uint16(xArgRmf64),
+	/*1720*/ uint16(xArgDR0dashDR7),
+	/*1721*/ uint16(xMatch),
+	/*1722*/ uint16(xCondIs64), 1725, 1731,
+	/*1725*/ uint16(xSetOp), uint16(MOV),
+	/*1727*/ uint16(xReadSlashR),
+	/*1728*/ uint16(xArgCR0dashCR7),
+	/*1729*/ uint16(xArgRmf32),
+	/*1730*/ uint16(xMatch),
+	/*1731*/ uint16(xSetOp), uint16(MOV),
+	/*1733*/ uint16(xReadSlashR),
+	/*1734*/ uint16(xArgCR0dashCR7),
+	/*1735*/ uint16(xArgRmf64),
+	/*1736*/ uint16(xMatch),
+	/*1737*/ uint16(xCondIs64), 1740, 1746,
+	/*1740*/ uint16(xSetOp), uint16(MOV),
+	/*1742*/ uint16(xReadSlashR),
+	/*1743*/ uint16(xArgDR0dashDR7),
+	/*1744*/ uint16(xArgRmf32),
+	/*1745*/ uint16(xMatch),
+	/*1746*/ uint16(xSetOp), uint16(MOV),
+	/*1748*/ uint16(xReadSlashR),
+	/*1749*/ uint16(xArgDR0dashDR7),
+	/*1750*/ uint16(xArgRmf64),
+	/*1751*/ uint16(xMatch),
+	/*1752*/ uint16(xCondIs64), 1755, 1761,
+	/*1755*/ uint16(xSetOp), uint16(MOV),
+	/*1757*/ uint16(xReadSlashR),
+	/*1758*/ uint16(xArgRmf32),
+	/*1759*/ uint16(xArgTR0dashTR7),
+	/*1760*/ uint16(xMatch),
+	/*1761*/ uint16(xSetOp), uint16(MOV),
+	/*1763*/ uint16(xReadSlashR),
+	/*1764*/ uint16(xArgRmf64),
+	/*1765*/ uint16(xArgTR0dashTR7),
+	/*1766*/ uint16(xMatch),
+	/*1767*/ uint16(xCondIs64), 1770, 1776,
+	/*1770*/ uint16(xSetOp), uint16(MOV),
+	/*1772*/ uint16(xReadSlashR),
+	/*1773*/ uint16(xArgTR0dashTR7),
+	/*1774*/ uint16(xArgRmf32),
+	/*1775*/ uint16(xMatch),
+	/*1776*/ uint16(xSetOp), uint16(MOV),
+	/*1778*/ uint16(xReadSlashR),
+	/*1779*/ uint16(xArgTR0dashTR7),
+	/*1780*/ uint16(xArgRmf64),
+	/*1781*/ uint16(xMatch),
+	/*1782*/ uint16(xCondPrefix), 2,
+	0x66, 1794,
+	0x0, 1788,
+	/*1788*/ uint16(xSetOp), uint16(MOVAPS),
+	/*1790*/ uint16(xReadSlashR),
+	/*1791*/ uint16(xArgXmm1),
+	/*1792*/ uint16(xArgXmm2M128),
+	/*1793*/ uint16(xMatch),
+	/*1794*/ uint16(xSetOp), uint16(MOVAPD),
+	/*1796*/ uint16(xReadSlashR),
+	/*1797*/ uint16(xArgXmm1),
+	/*1798*/ uint16(xArgXmm2M128),
+	/*1799*/ uint16(xMatch),
+	/*1800*/ uint16(xCondPrefix), 2,
+	0x66, 1812,
+	0x0, 1806,
+	/*1806*/ uint16(xSetOp), uint16(MOVAPS),
+	/*1808*/ uint16(xReadSlashR),
+	/*1809*/ uint16(xArgXmm2M128),
+	/*1810*/ uint16(xArgXmm1),
+	/*1811*/ uint16(xMatch),
+	/*1812*/ uint16(xSetOp), uint16(MOVAPD),
+	/*1814*/ uint16(xReadSlashR),
+	/*1815*/ uint16(xArgXmm2M128),
+	/*1816*/ uint16(xArgXmm1),
+	/*1817*/ uint16(xMatch),
+	/*1818*/ uint16(xCondIs64), 1821, 1875,
+	/*1821*/ uint16(xCondPrefix), 4,
+	0xF3, 1859,
+	0xF2, 1843,
+	0x66, 1837,
+	0x0, 1831,
+	/*1831*/ uint16(xSetOp), uint16(CVTPI2PS),
+	/*1833*/ uint16(xReadSlashR),
+	/*1834*/ uint16(xArgXmm),
+	/*1835*/ uint16(xArgMmM64),
+	/*1836*/ uint16(xMatch),
+	/*1837*/ uint16(xSetOp), uint16(CVTPI2PD),
+	/*1839*/ uint16(xReadSlashR),
+	/*1840*/ uint16(xArgXmm),
+	/*1841*/ uint16(xArgMmM64),
+	/*1842*/ uint16(xMatch),
+	/*1843*/ uint16(xCondDataSize), 1847, 1853, 0,
+	/*1847*/ uint16(xSetOp), uint16(CVTSI2SD),
+	/*1849*/ uint16(xReadSlashR),
+	/*1850*/ uint16(xArgXmm),
+	/*1851*/ uint16(xArgRM32),
+	/*1852*/ uint16(xMatch),
+	/*1853*/ uint16(xSetOp), uint16(CVTSI2SD),
+	/*1855*/ uint16(xReadSlashR),
+	/*1856*/ uint16(xArgXmm),
+	/*1857*/ uint16(xArgRM32),
+	/*1858*/ uint16(xMatch),
+	/*1859*/ uint16(xCondDataSize), 1863, 1869, 0,
+	/*1863*/ uint16(xSetOp), uint16(CVTSI2SS),
+	/*1865*/ uint16(xReadSlashR),
+	/*1866*/ uint16(xArgXmm),
+	/*1867*/ uint16(xArgRM32),
+	/*1868*/ uint16(xMatch),
+	/*1869*/ uint16(xSetOp), uint16(CVTSI2SS),
+	/*1871*/ uint16(xReadSlashR),
+	/*1872*/ uint16(xArgXmm),
+	/*1873*/ uint16(xArgRM32),
+	/*1874*/ uint16(xMatch),
+	/*1875*/ uint16(xCondPrefix), 4,
+	0xF3, 1895,
+	0xF2, 1885,
+	0x66, 1837,
+	0x0, 1831,
+	/*1885*/ uint16(xCondDataSize), 1847, 1853, 1889,
+	/*1889*/ uint16(xSetOp), uint16(CVTSI2SD),
+	/*1891*/ uint16(xReadSlashR),
+	/*1892*/ uint16(xArgXmm),
+	/*1893*/ uint16(xArgRM64),
+	/*1894*/ uint16(xMatch),
+	/*1895*/ uint16(xCondDataSize), 1863, 1869, 1899,
+	/*1899*/ uint16(xSetOp), uint16(CVTSI2SS),
+	/*1901*/ uint16(xReadSlashR),
+	/*1902*/ uint16(xArgXmm),
+	/*1903*/ uint16(xArgRM64),
+	/*1904*/ uint16(xMatch),
+	/*1905*/ uint16(xCondPrefix), 4,
+	0xF3, 1933,
+	0xF2, 1927,
+	0x66, 1921,
+	0x0, 1915,
+	/*1915*/ uint16(xSetOp), uint16(MOVNTPS),
+	/*1917*/ uint16(xReadSlashR),
+	/*1918*/ uint16(xArgM128),
+	/*1919*/ uint16(xArgXmm),
+	/*1920*/ uint16(xMatch),
+	/*1921*/ uint16(xSetOp), uint16(MOVNTPD),
+	/*1923*/ uint16(xReadSlashR),
+	/*1924*/ uint16(xArgM128),
+	/*1925*/ uint16(xArgXmm),
+	/*1926*/ uint16(xMatch),
+	/*1927*/ uint16(xSetOp), uint16(MOVNTSD),
+	/*1929*/ uint16(xReadSlashR),
+	/*1930*/ uint16(xArgM64),
+	/*1931*/ uint16(xArgXmm),
+	/*1932*/ uint16(xMatch),
+	/*1933*/ uint16(xSetOp), uint16(MOVNTSS),
+	/*1935*/ uint16(xReadSlashR),
+	/*1936*/ uint16(xArgM32),
+	/*1937*/ uint16(xArgXmm),
+	/*1938*/ uint16(xMatch),
+	/*1939*/ uint16(xCondIs64), 1942, 1996,
+	/*1942*/ uint16(xCondPrefix), 4,
+	0xF3, 1980,
+	0xF2, 1964,
+	0x66, 1958,
+	0x0, 1952,
+	/*1952*/ uint16(xSetOp), uint16(CVTTPS2PI),
+	/*1954*/ uint16(xReadSlashR),
+	/*1955*/ uint16(xArgMm),
+	/*1956*/ uint16(xArgXmmM64),
+	/*1957*/ uint16(xMatch),
+	/*1958*/ uint16(xSetOp), uint16(CVTTPD2PI),
+	/*1960*/ uint16(xReadSlashR),
+	/*1961*/ uint16(xArgMm),
+	/*1962*/ uint16(xArgXmmM128),
+	/*1963*/ uint16(xMatch),
+	/*1964*/ uint16(xCondDataSize), 1968, 1974, 0,
+	/*1968*/ uint16(xSetOp), uint16(CVTTSD2SI),
+	/*1970*/ uint16(xReadSlashR),
+	/*1971*/ uint16(xArgR32),
+	/*1972*/ uint16(xArgXmmM64),
+	/*1973*/ uint16(xMatch),
+	/*1974*/ uint16(xSetOp), uint16(CVTTSD2SI),
+	/*1976*/ uint16(xReadSlashR),
+	/*1977*/ uint16(xArgR32),
+	/*1978*/ uint16(xArgXmmM64),
+	/*1979*/ uint16(xMatch),
+	/*1980*/ uint16(xCondDataSize), 1984, 1990, 0,
+	/*1984*/ uint16(xSetOp), uint16(CVTTSS2SI),
+	/*1986*/ uint16(xReadSlashR),
+	/*1987*/ uint16(xArgR32),
+	/*1988*/ uint16(xArgXmmM32),
+	/*1989*/ uint16(xMatch),
+	/*1990*/ uint16(xSetOp), uint16(CVTTSS2SI),
+	/*1992*/ uint16(xReadSlashR),
+	/*1993*/ uint16(xArgR32),
+	/*1994*/ uint16(xArgXmmM32),
+	/*1995*/ uint16(xMatch),
+	/*1996*/ uint16(xCondPrefix), 4,
+	0xF3, 2016,
+	0xF2, 2006,
+	0x66, 1958,
+	0x0, 1952,
+	/*2006*/ uint16(xCondDataSize), 1968, 1974, 2010,
+	/*2010*/ uint16(xSetOp), uint16(CVTTSD2SI),
+	/*2012*/ uint16(xReadSlashR),
+	/*2013*/ uint16(xArgR64),
+	/*2014*/ uint16(xArgXmmM64),
+	/*2015*/ uint16(xMatch),
+	/*2016*/ uint16(xCondDataSize), 1984, 1990, 2020,
+	/*2020*/ uint16(xSetOp), uint16(CVTTSS2SI),
+	/*2022*/ uint16(xReadSlashR),
+	/*2023*/ uint16(xArgR64),
+	/*2024*/ uint16(xArgXmmM32),
+	/*2025*/ uint16(xMatch),
+	/*2026*/ uint16(xCondIs64), 2029, 2083,
+	/*2029*/ uint16(xCondPrefix), 4,
+	0xF3, 2067,
+	0xF2, 2051,
+	0x66, 2045,
+	0x0, 2039,
+	/*2039*/ uint16(xSetOp), uint16(CVTPS2PI),
+	/*2041*/ uint16(xReadSlashR),
+	/*2042*/ uint16(xArgMm),
+	/*2043*/ uint16(xArgXmmM64),
+	/*2044*/ uint16(xMatch),
+	/*2045*/ uint16(xSetOp), uint16(CVTPD2PI),
+	/*2047*/ uint16(xReadSlashR),
+	/*2048*/ uint16(xArgMm),
+	/*2049*/ uint16(xArgXmmM128),
+	/*2050*/ uint16(xMatch),
+	/*2051*/ uint16(xCondDataSize), 2055, 2061, 0,
+	/*2055*/ uint16(xSetOp), uint16(CVTSD2SI),
+	/*2057*/ uint16(xReadSlashR),
+	/*2058*/ uint16(xArgR32),
+	/*2059*/ uint16(xArgXmmM64),
+	/*2060*/ uint16(xMatch),
+	/*2061*/ uint16(xSetOp), uint16(CVTSD2SI),
+	/*2063*/ uint16(xReadSlashR),
+	/*2064*/ uint16(xArgR32),
+	/*2065*/ uint16(xArgXmmM64),
+	/*2066*/ uint16(xMatch),
+	/*2067*/ uint16(xCondDataSize), 2071, 2077, 0,
+	/*2071*/ uint16(xSetOp), uint16(CVTSS2SI),
+	/*2073*/ uint16(xReadSlashR),
+	/*2074*/ uint16(xArgR32),
+	/*2075*/ uint16(xArgXmmM32),
+	/*2076*/ uint16(xMatch),
+	/*2077*/ uint16(xSetOp), uint16(CVTSS2SI),
+	/*2079*/ uint16(xReadSlashR),
+	/*2080*/ uint16(xArgR32),
+	/*2081*/ uint16(xArgXmmM32),
+	/*2082*/ uint16(xMatch),
+	/*2083*/ uint16(xCondPrefix), 4,
+	0xF3, 2103,
+	0xF2, 2093,
+	0x66, 2045,
+	0x0, 2039,
+	/*2093*/ uint16(xCondDataSize), 2055, 2061, 2097,
+	/*2097*/ uint16(xSetOp), uint16(CVTSD2SI),
+	/*2099*/ uint16(xReadSlashR),
+	/*2100*/ uint16(xArgR64),
+	/*2101*/ uint16(xArgXmmM64),
+	/*2102*/ uint16(xMatch),
+	/*2103*/ uint16(xCondDataSize), 2071, 2077, 2107,
+	/*2107*/ uint16(xSetOp), uint16(CVTSS2SI),
+	/*2109*/ uint16(xReadSlashR),
+	/*2110*/ uint16(xArgR64),
+	/*2111*/ uint16(xArgXmmM32),
+	/*2112*/ uint16(xMatch),
+	/*2113*/ uint16(xCondPrefix), 2,
+	0x66, 2125,
+	0x0, 2119,
+	/*2119*/ uint16(xSetOp), uint16(UCOMISS),
+	/*2121*/ uint16(xReadSlashR),
+	/*2122*/ uint16(xArgXmm1),
+	/*2123*/ uint16(xArgXmm2M32),
+	/*2124*/ uint16(xMatch),
+	/*2125*/ uint16(xSetOp), uint16(UCOMISD),
+	/*2127*/ uint16(xReadSlashR),
+	/*2128*/ uint16(xArgXmm1),
+	/*2129*/ uint16(xArgXmm2M64),
+	/*2130*/ uint16(xMatch),
+	/*2131*/ uint16(xCondPrefix), 2,
+	0x66, 2143,
+	0x0, 2137,
+	/*2137*/ uint16(xSetOp), uint16(COMISS),
+	/*2139*/ uint16(xReadSlashR),
+	/*2140*/ uint16(xArgXmm1),
+	/*2141*/ uint16(xArgXmm2M32),
+	/*2142*/ uint16(xMatch),
+	/*2143*/ uint16(xSetOp), uint16(COMISD),
+	/*2145*/ uint16(xReadSlashR),
+	/*2146*/ uint16(xArgXmm1),
+	/*2147*/ uint16(xArgXmm2M64),
+	/*2148*/ uint16(xMatch),
+	/*2149*/ uint16(xSetOp), uint16(WRMSR),
+	/*2151*/ uint16(xMatch),
+	/*2152*/ uint16(xSetOp), uint16(RDTSC),
+	/*2154*/ uint16(xMatch),
+	/*2155*/ uint16(xSetOp), uint16(RDMSR),
+	/*2157*/ uint16(xMatch),
+	/*2158*/ uint16(xSetOp), uint16(RDPMC),
+	/*2160*/ uint16(xMatch),
+	/*2161*/ uint16(xSetOp), uint16(SYSENTER),
+	/*2163*/ uint16(xMatch),
+	/*2164*/ uint16(xCondDataSize), 2168, 2168, 2171,
+	/*2168*/ uint16(xSetOp), uint16(SYSEXIT),
+	/*2170*/ uint16(xMatch),
+	/*2171*/ uint16(xSetOp), uint16(SYSEXIT),
+	/*2173*/ uint16(xMatch),
+	/*2174*/ uint16(xCondByte), 54,
+	0x00, 2285,
+	0x01, 2303,
+	0x02, 2321,
+	0x03, 2339,
+	0x04, 2357,
+	0x05, 2375,
+	0x06, 2393,
+	0x07, 2411,
+	0x08, 2429,
+	0x09, 2447,
+	0x0A, 2465,
+	0x0B, 2483,
+	0x10, 2501,
+	0x14, 2512,
+	0x15, 2523,
+	0x17, 2534,
+	0x1C, 2544,
+	0x1D, 2562,
+	0x1E, 2580,
+	0x20, 2598,
+	0x21, 2608,
+	0x22, 2618,
+	0x23, 2628,
+	0x24, 2638,
+	0x25, 2648,
+	0x28, 2658,
+	0x29, 2668,
+	0x2A, 2678,
+	0x2B, 2688,
+	0x30, 2698,
+	0x31, 2708,
+	0x32, 2718,
+	0x33, 2728,
+	0x34, 2738,
+	0x35, 2748,
+	0x37, 2758,
+	0x38, 2768,
+	0x39, 2778,
+	0x3A, 2788,
+	0x3B, 2798,
+	0x3C, 2808,
+	0x3D, 2818,
+	0x3E, 2828,
+	0x3F, 2838,
+	0x40, 2848,
+	0x41, 2858,
+	0x82, 2868,
+	0xDB, 2891,
+	0xDC, 2901,
+	0xDD, 2911,
+	0xDE, 2921,
+	0xDF, 2931,
+	0xF0, 2941,
+	0xF1, 3008,
 	uint16(xFail),
-	/*2283*/ uint16(xCondPrefix), 2,
-	0x66, 2295,
-	0x0, 2289,
-	/*2289*/ uint16(xSetOp), uint16(PSHUFB),
-	/*2291*/ uint16(xReadSlashR),
-	/*2292*/ uint16(xArgMm1),
-	/*2293*/ uint16(xArgMm2M64),
-	/*2294*/ uint16(xMatch),
-	/*2295*/ uint16(xSetOp), uint16(PSHUFB),
-	/*2297*/ uint16(xReadSlashR),
-	/*2298*/ uint16(xArgXmm1),
-	/*2299*/ uint16(xArgXmm2M128),
-	/*2300*/ uint16(xMatch),
-	/*2301*/ uint16(xCondPrefix), 2,
-	0x66, 2313,
-	0x0, 2307,
-	/*2307*/ uint16(xSetOp), uint16(PHADDW),
-	/*2309*/ uint16(xReadSlashR),
-	/*2310*/ uint16(xArgMm1),
-	/*2311*/ uint16(xArgMm2M64),
-	/*2312*/ uint16(xMatch),
-	/*2313*/ uint16(xSetOp), uint16(PHADDW),
-	/*2315*/ uint16(xReadSlashR),
-	/*2316*/ uint16(xArgXmm1),
-	/*2317*/ uint16(xArgXmm2M128),
-	/*2318*/ uint16(xMatch),
-	/*2319*/ uint16(xCondPrefix), 2,
-	0x66, 2331,
-	0x0, 2325,
-	/*2325*/ uint16(xSetOp), uint16(PHADDD),
-	/*2327*/ uint16(xReadSlashR),
-	/*2328*/ uint16(xArgMm1),
-	/*2329*/ uint16(xArgMm2M64),
-	/*2330*/ uint16(xMatch),
-	/*2331*/ uint16(xSetOp), uint16(PHADDD),
-	/*2333*/ uint16(xReadSlashR),
-	/*2334*/ uint16(xArgXmm1),
-	/*2335*/ uint16(xArgXmm2M128),
-	/*2336*/ uint16(xMatch),
-	/*2337*/ uint16(xCondPrefix), 2,
-	0x66, 2349,
-	0x0, 2343,
-	/*2343*/ uint16(xSetOp), uint16(PHADDSW),
-	/*2345*/ uint16(xReadSlashR),
-	/*2346*/ uint16(xArgMm1),
-	/*2347*/ uint16(xArgMm2M64),
-	/*2348*/ uint16(xMatch),
-	/*2349*/ uint16(xSetOp), uint16(PHADDSW),
-	/*2351*/ uint16(xReadSlashR),
-	/*2352*/ uint16(xArgXmm1),
-	/*2353*/ uint16(xArgXmm2M128),
-	/*2354*/ uint16(xMatch),
-	/*2355*/ uint16(xCondPrefix), 2,
-	0x66, 2367,
-	0x0, 2361,
-	/*2361*/ uint16(xSetOp), uint16(PMADDUBSW),
-	/*2363*/ uint16(xReadSlashR),
-	/*2364*/ uint16(xArgMm1),
-	/*2365*/ uint16(xArgMm2M64),
-	/*2366*/ uint16(xMatch),
-	/*2367*/ uint16(xSetOp), uint16(PMADDUBSW),
-	/*2369*/ uint16(xReadSlashR),
-	/*2370*/ uint16(xArgXmm1),
-	/*2371*/ uint16(xArgXmm2M128),
-	/*2372*/ uint16(xMatch),
-	/*2373*/ uint16(xCondPrefix), 2,
-	0x66, 2385,
-	0x0, 2379,
-	/*2379*/ uint16(xSetOp), uint16(PHSUBW),
-	/*2381*/ uint16(xReadSlashR),
-	/*2382*/ uint16(xArgMm1),
-	/*2383*/ uint16(xArgMm2M64),
-	/*2384*/ uint16(xMatch),
-	/*2385*/ uint16(xSetOp), uint16(PHSUBW),
-	/*2387*/ uint16(xReadSlashR),
-	/*2388*/ uint16(xArgXmm1),
-	/*2389*/ uint16(xArgXmm2M128),
-	/*2390*/ uint16(xMatch),
-	/*2391*/ uint16(xCondPrefix), 2,
-	0x66, 2403,
-	0x0, 2397,
-	/*2397*/ uint16(xSetOp), uint16(PHSUBD),
-	/*2399*/ uint16(xReadSlashR),
-	/*2400*/ uint16(xArgMm1),
-	/*2401*/ uint16(xArgMm2M64),
-	/*2402*/ uint16(xMatch),
-	/*2403*/ uint16(xSetOp), uint16(PHSUBD),
-	/*2405*/ uint16(xReadSlashR),
-	/*2406*/ uint16(xArgXmm1),
-	/*2407*/ uint16(xArgXmm2M128),
-	/*2408*/ uint16(xMatch),
-	/*2409*/ uint16(xCondPrefix), 2,
-	0x66, 2421,
-	0x0, 2415,
-	/*2415*/ uint16(xSetOp), uint16(PHSUBSW),
-	/*2417*/ uint16(xReadSlashR),
-	/*2418*/ uint16(xArgMm1),
-	/*2419*/ uint16(xArgMm2M64),
-	/*2420*/ uint16(xMatch),
-	/*2421*/ uint16(xSetOp), uint16(PHSUBSW),
-	/*2423*/ uint16(xReadSlashR),
-	/*2424*/ uint16(xArgXmm1),
-	/*2425*/ uint16(xArgXmm2M128),
-	/*2426*/ uint16(xMatch),
-	/*2427*/ uint16(xCondPrefix), 2,
-	0x66, 2439,
-	0x0, 2433,
-	/*2433*/ uint16(xSetOp), uint16(PSIGNB),
-	/*2435*/ uint16(xReadSlashR),
-	/*2436*/ uint16(xArgMm1),
-	/*2437*/ uint16(xArgMm2M64),
-	/*2438*/ uint16(xMatch),
-	/*2439*/ uint16(xSetOp), uint16(PSIGNB),
-	/*2441*/ uint16(xReadSlashR),
-	/*2442*/ uint16(xArgXmm1),
-	/*2443*/ uint16(xArgXmm2M128),
-	/*2444*/ uint16(xMatch),
-	/*2445*/ uint16(xCondPrefix), 2,
-	0x66, 2457,
-	0x0, 2451,
-	/*2451*/ uint16(xSetOp), uint16(PSIGNW),
-	/*2453*/ uint16(xReadSlashR),
-	/*2454*/ uint16(xArgMm1),
-	/*2455*/ uint16(xArgMm2M64),
-	/*2456*/ uint16(xMatch),
-	/*2457*/ uint16(xSetOp), uint16(PSIGNW),
-	/*2459*/ uint16(xReadSlashR),
-	/*2460*/ uint16(xArgXmm1),
-	/*2461*/ uint16(xArgXmm2M128),
-	/*2462*/ uint16(xMatch),
-	/*2463*/ uint16(xCondPrefix), 2,
-	0x66, 2475,
-	0x0, 2469,
-	/*2469*/ uint16(xSetOp), uint16(PSIGND),
-	/*2471*/ uint16(xReadSlashR),
-	/*2472*/ uint16(xArgMm1),
-	/*2473*/ uint16(xArgMm2M64),
-	/*2474*/ uint16(xMatch),
-	/*2475*/ uint16(xSetOp), uint16(PSIGND),
-	/*2477*/ uint16(xReadSlashR),
-	/*2478*/ uint16(xArgXmm1),
-	/*2479*/ uint16(xArgXmm2M128),
-	/*2480*/ uint16(xMatch),
-	/*2481*/ uint16(xCondPrefix), 2,
-	0x66, 2493,
-	0x0, 2487,
-	/*2487*/ uint16(xSetOp), uint16(PMULHRSW),
-	/*2489*/ uint16(xReadSlashR),
-	/*2490*/ uint16(xArgMm1),
-	/*2491*/ uint16(xArgMm2M64),
-	/*2492*/ uint16(xMatch),
-	/*2493*/ uint16(xSetOp), uint16(PMULHRSW),
-	/*2495*/ uint16(xReadSlashR),
-	/*2496*/ uint16(xArgXmm1),
-	/*2497*/ uint16(xArgXmm2M128),
-	/*2498*/ uint16(xMatch),
-	/*2499*/ uint16(xCondPrefix), 1,
-	0x66, 2503,
-	/*2503*/ uint16(xSetOp), uint16(PBLENDVB),
-	/*2505*/ uint16(xReadSlashR),
-	/*2506*/ uint16(xArgXmm1),
-	/*2507*/ uint16(xArgXmm2M128),
-	/*2508*/ uint16(xArgXMM0),
-	/*2509*/ uint16(xMatch),
-	/*2510*/ uint16(xCondPrefix), 1,
-	0x66, 2514,
-	/*2514*/ uint16(xSetOp), uint16(BLENDVPS),
-	/*2516*/ uint16(xReadSlashR),
-	/*2517*/ uint16(xArgXmm1),
-	/*2518*/ uint16(xArgXmm2M128),
-	/*2519*/ uint16(xArgXMM0),
-	/*2520*/ uint16(xMatch),
-	/*2521*/ uint16(xCondPrefix), 1,
-	0x66, 2525,
-	/*2525*/ uint16(xSetOp), uint16(BLENDVPD),
-	/*2527*/ uint16(xReadSlashR),
-	/*2528*/ uint16(xArgXmm1),
-	/*2529*/ uint16(xArgXmm2M128),
-	/*2530*/ uint16(xArgXMM0),
-	/*2531*/ uint16(xMatch),
-	/*2532*/ uint16(xCondPrefix), 1,
-	0x66, 2536,
-	/*2536*/ uint16(xSetOp), uint16(PTEST),
-	/*2538*/ uint16(xReadSlashR),
-	/*2539*/ uint16(xArgXmm1),
-	/*2540*/ uint16(xArgXmm2M128),
-	/*2541*/ uint16(xMatch),
-	/*2542*/ uint16(xCondPrefix), 2,
-	0x66, 2554,
-	0x0, 2548,
-	/*2548*/ uint16(xSetOp), uint16(PABSB),
-	/*2550*/ uint16(xReadSlashR),
-	/*2551*/ uint16(xArgMm1),
-	/*2552*/ uint16(xArgMm2M64),
-	/*2553*/ uint16(xMatch),
-	/*2554*/ uint16(xSetOp), uint16(PABSB),
-	/*2556*/ uint16(xReadSlashR),
-	/*2557*/ uint16(xArgXmm1),
-	/*2558*/ uint16(xArgXmm2M128),
-	/*2559*/ uint16(xMatch),
-	/*2560*/ uint16(xCondPrefix), 2,
-	0x66, 2572,
-	0x0, 2566,
-	/*2566*/ uint16(xSetOp), uint16(PABSW),
-	/*2568*/ uint16(xReadSlashR),
-	/*2569*/ uint16(xArgMm1),
-	/*2570*/ uint16(xArgMm2M64),
-	/*2571*/ uint16(xMatch),
-	/*2572*/ uint16(xSetOp), uint16(PABSW),
-	/*2574*/ uint16(xReadSlashR),
-	/*2575*/ uint16(xArgXmm1),
-	/*2576*/ uint16(xArgXmm2M128),
-	/*2577*/ uint16(xMatch),
-	/*2578*/ uint16(xCondPrefix), 2,
-	0x66, 2590,
-	0x0, 2584,
-	/*2584*/ uint16(xSetOp), uint16(PABSD),
-	/*2586*/ uint16(xReadSlashR),
-	/*2587*/ uint16(xArgMm1),
-	/*2588*/ uint16(xArgMm2M64),
-	/*2589*/ uint16(xMatch),
-	/*2590*/ uint16(xSetOp), uint16(PABSD),
-	/*2592*/ uint16(xReadSlashR),
-	/*2593*/ uint16(xArgXmm1),
-	/*2594*/ uint16(xArgXmm2M128),
-	/*2595*/ uint16(xMatch),
-	/*2596*/ uint16(xCondPrefix), 1,
-	0x66, 2600,
-	/*2600*/ uint16(xSetOp), uint16(PMOVSXBW),
-	/*2602*/ uint16(xReadSlashR),
-	/*2603*/ uint16(xArgXmm1),
-	/*2604*/ uint16(xArgXmm2M64),
-	/*2605*/ uint16(xMatch),
-	/*2606*/ uint16(xCondPrefix), 1,
-	0x66, 2610,
-	/*2610*/ uint16(xSetOp), uint16(PMOVSXBD),
-	/*2612*/ uint16(xReadSlashR),
-	/*2613*/ uint16(xArgXmm1),
-	/*2614*/ uint16(xArgXmm2M32),
-	/*2615*/ uint16(xMatch),
-	/*2616*/ uint16(xCondPrefix), 1,
-	0x66, 2620,
-	/*2620*/ uint16(xSetOp), uint16(PMOVSXBQ),
-	/*2622*/ uint16(xReadSlashR),
-	/*2623*/ uint16(xArgXmm1),
-	/*2624*/ uint16(xArgXmm2M16),
-	/*2625*/ uint16(xMatch),
-	/*2626*/ uint16(xCondPrefix), 1,
-	0x66, 2630,
-	/*2630*/ uint16(xSetOp), uint16(PMOVSXWD),
-	/*2632*/ uint16(xReadSlashR),
-	/*2633*/ uint16(xArgXmm1),
-	/*2634*/ uint16(xArgXmm2M64),
-	/*2635*/ uint16(xMatch),
-	/*2636*/ uint16(xCondPrefix), 1,
-	0x66, 2640,
-	/*2640*/ uint16(xSetOp), uint16(PMOVSXWQ),
-	/*2642*/ uint16(xReadSlashR),
-	/*2643*/ uint16(xArgXmm1),
-	/*2644*/ uint16(xArgXmm2M32),
-	/*2645*/ uint16(xMatch),
-	/*2646*/ uint16(xCondPrefix), 1,
-	0x66, 2650,
-	/*2650*/ uint16(xSetOp), uint16(PMOVSXDQ),
-	/*2652*/ uint16(xReadSlashR),
-	/*2653*/ uint16(xArgXmm1),
-	/*2654*/ uint16(xArgXmm2M64),
-	/*2655*/ uint16(xMatch),
-	/*2656*/ uint16(xCondPrefix), 1,
-	0x66, 2660,
-	/*2660*/ uint16(xSetOp), uint16(PMULDQ),
-	/*2662*/ uint16(xReadSlashR),
-	/*2663*/ uint16(xArgXmm1),
-	/*2664*/ uint16(xArgXmm2M128),
-	/*2665*/ uint16(xMatch),
-	/*2666*/ uint16(xCondPrefix), 1,
-	0x66, 2670,
-	/*2670*/ uint16(xSetOp), uint16(PCMPEQQ),
-	/*2672*/ uint16(xReadSlashR),
-	/*2673*/ uint16(xArgXmm1),
-	/*2674*/ uint16(xArgXmm2M128),
-	/*2675*/ uint16(xMatch),
-	/*2676*/ uint16(xCondPrefix), 1,
-	0x66, 2680,
-	/*2680*/ uint16(xSetOp), uint16(MOVNTDQA),
-	/*2682*/ uint16(xReadSlashR),
-	/*2683*/ uint16(xArgXmm1),
-	/*2684*/ uint16(xArgM128),
-	/*2685*/ uint16(xMatch),
-	/*2686*/ uint16(xCondPrefix), 1,
-	0x66, 2690,
-	/*2690*/ uint16(xSetOp), uint16(PACKUSDW),
-	/*2692*/ uint16(xReadSlashR),
-	/*2693*/ uint16(xArgXmm1),
-	/*2694*/ uint16(xArgXmm2M128),
-	/*2695*/ uint16(xMatch),
-	/*2696*/ uint16(xCondPrefix), 1,
-	0x66, 2700,
-	/*2700*/ uint16(xSetOp), uint16(PMOVZXBW),
-	/*2702*/ uint16(xReadSlashR),
-	/*2703*/ uint16(xArgXmm1),
-	/*2704*/ uint16(xArgXmm2M64),
-	/*2705*/ uint16(xMatch),
-	/*2706*/ uint16(xCondPrefix), 1,
-	0x66, 2710,
-	/*2710*/ uint16(xSetOp), uint16(PMOVZXBD),
-	/*2712*/ uint16(xReadSlashR),
-	/*2713*/ uint16(xArgXmm1),
-	/*2714*/ uint16(xArgXmm2M32),
-	/*2715*/ uint16(xMatch),
-	/*2716*/ uint16(xCondPrefix), 1,
-	0x66, 2720,
-	/*2720*/ uint16(xSetOp), uint16(PMOVZXBQ),
-	/*2722*/ uint16(xReadSlashR),
-	/*2723*/ uint16(xArgXmm1),
-	/*2724*/ uint16(xArgXmm2M16),
-	/*2725*/ uint16(xMatch),
-	/*2726*/ uint16(xCondPrefix), 1,
-	0x66, 2730,
-	/*2730*/ uint16(xSetOp), uint16(PMOVZXWD),
-	/*2732*/ uint16(xReadSlashR),
-	/*2733*/ uint16(xArgXmm1),
-	/*2734*/ uint16(xArgXmm2M64),
-	/*2735*/ uint16(xMatch),
-	/*2736*/ uint16(xCondPrefix), 1,
-	0x66, 2740,
-	/*2740*/ uint16(xSetOp), uint16(PMOVZXWQ),
-	/*2742*/ uint16(xReadSlashR),
-	/*2743*/ uint16(xArgXmm1),
-	/*2744*/ uint16(xArgXmm2M32),
-	/*2745*/ uint16(xMatch),
-	/*2746*/ uint16(xCondPrefix), 1,
-	0x66, 2750,
-	/*2750*/ uint16(xSetOp), uint16(PMOVZXDQ),
-	/*2752*/ uint16(xReadSlashR),
-	/*2753*/ uint16(xArgXmm1),
-	/*2754*/ uint16(xArgXmm2M64),
-	/*2755*/ uint16(xMatch),
-	/*2756*/ uint16(xCondPrefix), 1,
-	0x66, 2760,
-	/*2760*/ uint16(xSetOp), uint16(PCMPGTQ),
-	/*2762*/ uint16(xReadSlashR),
-	/*2763*/ uint16(xArgXmm1),
-	/*2764*/ uint16(xArgXmm2M128),
-	/*2765*/ uint16(xMatch),
-	/*2766*/ uint16(xCondPrefix), 1,
-	0x66, 2770,
-	/*2770*/ uint16(xSetOp), uint16(PMINSB),
-	/*2772*/ uint16(xReadSlashR),
-	/*2773*/ uint16(xArgXmm1),
-	/*2774*/ uint16(xArgXmm2M128),
-	/*2775*/ uint16(xMatch),
-	/*2776*/ uint16(xCondPrefix), 1,
-	0x66, 2780,
-	/*2780*/ uint16(xSetOp), uint16(PMINSD),
-	/*2782*/ uint16(xReadSlashR),
-	/*2783*/ uint16(xArgXmm1),
-	/*2784*/ uint16(xArgXmm2M128),
-	/*2785*/ uint16(xMatch),
-	/*2786*/ uint16(xCondPrefix), 1,
-	0x66, 2790,
-	/*2790*/ uint16(xSetOp), uint16(PMINUW),
-	/*2792*/ uint16(xReadSlashR),
-	/*2793*/ uint16(xArgXmm1),
-	/*2794*/ uint16(xArgXmm2M128),
-	/*2795*/ uint16(xMatch),
-	/*2796*/ uint16(xCondPrefix), 1,
-	0x66, 2800,
-	/*2800*/ uint16(xSetOp), uint16(PMINUD),
-	/*2802*/ uint16(xReadSlashR),
-	/*2803*/ uint16(xArgXmm1),
-	/*2804*/ uint16(xArgXmm2M128),
-	/*2805*/ uint16(xMatch),
-	/*2806*/ uint16(xCondPrefix), 1,
-	0x66, 2810,
-	/*2810*/ uint16(xSetOp), uint16(PMAXSB),
-	/*2812*/ uint16(xReadSlashR),
-	/*2813*/ uint16(xArgXmm1),
-	/*2814*/ uint16(xArgXmm2M128),
-	/*2815*/ uint16(xMatch),
-	/*2816*/ uint16(xCondPrefix), 1,
-	0x66, 2820,
-	/*2820*/ uint16(xSetOp), uint16(PMAXSD),
-	/*2822*/ uint16(xReadSlashR),
-	/*2823*/ uint16(xArgXmm1),
-	/*2824*/ uint16(xArgXmm2M128),
-	/*2825*/ uint16(xMatch),
-	/*2826*/ uint16(xCondPrefix), 1,
-	0x66, 2830,
-	/*2830*/ uint16(xSetOp), uint16(PMAXUW),
-	/*2832*/ uint16(xReadSlashR),
-	/*2833*/ uint16(xArgXmm1),
-	/*2834*/ uint16(xArgXmm2M128),
-	/*2835*/ uint16(xMatch),
-	/*2836*/ uint16(xCondPrefix), 1,
-	0x66, 2840,
-	/*2840*/ uint16(xSetOp), uint16(PMAXUD),
-	/*2842*/ uint16(xReadSlashR),
-	/*2843*/ uint16(xArgXmm1),
-	/*2844*/ uint16(xArgXmm2M128),
-	/*2845*/ uint16(xMatch),
-	/*2846*/ uint16(xCondPrefix), 1,
-	0x66, 2850,
-	/*2850*/ uint16(xSetOp), uint16(PMULLD),
-	/*2852*/ uint16(xReadSlashR),
-	/*2853*/ uint16(xArgXmm1),
-	/*2854*/ uint16(xArgXmm2M128),
-	/*2855*/ uint16(xMatch),
-	/*2856*/ uint16(xCondPrefix), 1,
-	0x66, 2860,
-	/*2860*/ uint16(xSetOp), uint16(PHMINPOSUW),
-	/*2862*/ uint16(xReadSlashR),
-	/*2863*/ uint16(xArgXmm1),
-	/*2864*/ uint16(xArgXmm2M128),
-	/*2865*/ uint16(xMatch),
-	/*2866*/ uint16(xCondIs64), 2869, 2879,
-	/*2869*/ uint16(xCondPrefix), 1,
-	0x66, 2873,
-	/*2873*/ uint16(xSetOp), uint16(INVPCID),
-	/*2875*/ uint16(xReadSlashR),
-	/*2876*/ uint16(xArgR32),
-	/*2877*/ uint16(xArgM128),
-	/*2878*/ uint16(xMatch),
-	/*2879*/ uint16(xCondPrefix), 1,
-	0x66, 2883,
-	/*2883*/ uint16(xSetOp), uint16(INVPCID),
-	/*2885*/ uint16(xReadSlashR),
-	/*2886*/ uint16(xArgR64),
-	/*2887*/ uint16(xArgM128),
-	/*2888*/ uint16(xMatch),
-	/*2889*/ uint16(xCondPrefix), 1,
-	0x66, 2893,
-	/*2893*/ uint16(xSetOp), uint16(AESIMC),
-	/*2895*/ uint16(xReadSlashR),
-	/*2896*/ uint16(xArgXmm1),
-	/*2897*/ uint16(xArgXmm2M128),
-	/*2898*/ uint16(xMatch),
-	/*2899*/ uint16(xCondPrefix), 1,
-	0x66, 2903,
-	/*2903*/ uint16(xSetOp), uint16(AESENC),
-	/*2905*/ uint16(xReadSlashR),
-	/*2906*/ uint16(xArgXmm1),
-	/*2907*/ uint16(xArgXmm2M128),
-	/*2908*/ uint16(xMatch),
-	/*2909*/ uint16(xCondPrefix), 1,
-	0x66, 2913,
-	/*2913*/ uint16(xSetOp), uint16(AESENCLAST),
-	/*2915*/ uint16(xReadSlashR),
-	/*2916*/ uint16(xArgXmm1),
-	/*2917*/ uint16(xArgXmm2M128),
-	/*2918*/ uint16(xMatch),
-	/*2919*/ uint16(xCondPrefix), 1,
-	0x66, 2923,
-	/*2923*/ uint16(xSetOp), uint16(AESDEC),
-	/*2925*/ uint16(xReadSlashR),
-	/*2926*/ uint16(xArgXmm1),
-	/*2927*/ uint16(xArgXmm2M128),
-	/*2928*/ uint16(xMatch),
-	/*2929*/ uint16(xCondPrefix), 1,
-	0x66, 2933,
-	/*2933*/ uint16(xSetOp), uint16(AESDECLAST),
-	/*2935*/ uint16(xReadSlashR),
-	/*2936*/ uint16(xArgXmm1),
-	/*2937*/ uint16(xArgXmm2M128),
-	/*2938*/ uint16(xMatch),
-	/*2939*/ uint16(xCondIs64), 2942, 2980,
-	/*2942*/ uint16(xCondPrefix), 2,
-	0xF2, 2964,
-	0x0, 2948,
-	/*2948*/ uint16(xCondDataSize), 2952, 2958, 0,
-	/*2952*/ uint16(xSetOp), uint16(MOVBE),
-	/*2954*/ uint16(xReadSlashR),
-	/*2955*/ uint16(xArgR16),
-	/*2956*/ uint16(xArgM16),
-	/*2957*/ uint16(xMatch),
-	/*2958*/ uint16(xSetOp), uint16(MOVBE),
-	/*2960*/ uint16(xReadSlashR),
-	/*2961*/ uint16(xArgR32),
-	/*2962*/ uint16(xArgM32),
-	/*2963*/ uint16(xMatch),
-	/*2964*/ uint16(xCondDataSize), 2968, 2974, 0,
-	/*2968*/ uint16(xSetOp), uint16(CRC32),
-	/*2970*/ uint16(xReadSlashR),
-	/*2971*/ uint16(xArgR32),
-	/*2972*/ uint16(xArgRM8),
-	/*2973*/ uint16(xMatch),
-	/*2974*/ uint16(xSetOp), uint16(CRC32),
-	/*2976*/ uint16(xReadSlashR),
-	/*2977*/ uint16(xArgR32),
-	/*2978*/ uint16(xArgRM8),
-	/*2979*/ uint16(xMatch),
-	/*2980*/ uint16(xCondPrefix), 2,
-	0xF2, 2996,
-	0x0, 2986,
-	/*2986*/ uint16(xCondDataSize), 2952, 2958, 2990,
-	/*2990*/ uint16(xSetOp), uint16(MOVBE),
-	/*2992*/ uint16(xReadSlashR),
-	/*2993*/ uint16(xArgR64),
-	/*2994*/ uint16(xArgM64),
-	/*2995*/ uint16(xMatch),
-	/*2996*/ uint16(xCondDataSize), 2968, 2974, 3000,
-	/*3000*/ uint16(xSetOp), uint16(CRC32),
-	/*3002*/ uint16(xReadSlashR),
-	/*3003*/ uint16(xArgR64),
-	/*3004*/ uint16(xArgRM8),
-	/*3005*/ uint16(xMatch),
-	/*3006*/ uint16(xCondIs64), 3009, 3047,
-	/*3009*/ uint16(xCondPrefix), 2,
-	0xF2, 3031,
-	0x0, 3015,
-	/*3015*/ uint16(xCondDataSize), 3019, 3025, 0,
-	/*3019*/ uint16(xSetOp), uint16(MOVBE),
-	/*3021*/ uint16(xReadSlashR),
-	/*3022*/ uint16(xArgM16),
-	/*3023*/ uint16(xArgR16),
-	/*3024*/ uint16(xMatch),
-	/*3025*/ uint16(xSetOp), uint16(MOVBE),
-	/*3027*/ uint16(xReadSlashR),
-	/*3028*/ uint16(xArgM32),
-	/*3029*/ uint16(xArgR32),
-	/*3030*/ uint16(xMatch),
-	/*3031*/ uint16(xCondDataSize), 3035, 3041, 0,
-	/*3035*/ uint16(xSetOp), uint16(CRC32),
-	/*3037*/ uint16(xReadSlashR),
-	/*3038*/ uint16(xArgR32),
-	/*3039*/ uint16(xArgRM16),
-	/*3040*/ uint16(xMatch),
-	/*3041*/ uint16(xSetOp), uint16(CRC32),
-	/*3043*/ uint16(xReadSlashR),
-	/*3044*/ uint16(xArgR32),
-	/*3045*/ uint16(xArgRM32),
-	/*3046*/ uint16(xMatch),
-	/*3047*/ uint16(xCondPrefix), 2,
-	0xF2, 3063,
-	0x0, 3053,
-	/*3053*/ uint16(xCondDataSize), 3019, 3025, 3057,
-	/*3057*/ uint16(xSetOp), uint16(MOVBE),
-	/*3059*/ uint16(xReadSlashR),
-	/*3060*/ uint16(xArgM64),
-	/*3061*/ uint16(xArgR64),
-	/*3062*/ uint16(xMatch),
-	/*3063*/ uint16(xCondDataSize), 3035, 3041, 3067,
-	/*3067*/ uint16(xSetOp), uint16(CRC32),
-	/*3069*/ uint16(xReadSlashR),
-	/*3070*/ uint16(xArgR64),
-	/*3071*/ uint16(xArgRM64),
-	/*3072*/ uint16(xMatch),
-	/*3073*/ uint16(xCondByte), 24,
-	0x08, 3124,
-	0x09, 3136,
-	0x0A, 3148,
-	0x0B, 3160,
-	0x0C, 3172,
-	0x0D, 3184,
-	0x0E, 3196,
-	0x0F, 3208,
-	0x14, 3230,
-	0x15, 3242,
-	0x16, 3254,
-	0x17, 3297,
-	0x20, 3309,
-	0x21, 3321,
-	0x22, 3333,
-	0x40, 3376,
-	0x41, 3388,
-	0x42, 3400,
-	0x44, 3412,
-	0x60, 3424,
-	0x61, 3436,
-	0x62, 3448,
-	0x63, 3460,
-	0xDF, 3472,
+	/*2285*/ uint16(xCondPrefix), 2,
+	0x66, 2297,
+	0x0, 2291,
+	/*2291*/ uint16(xSetOp), uint16(PSHUFB),
+	/*2293*/ uint16(xReadSlashR),
+	/*2294*/ uint16(xArgMm1),
+	/*2295*/ uint16(xArgMm2M64),
+	/*2296*/ uint16(xMatch),
+	/*2297*/ uint16(xSetOp), uint16(PSHUFB),
+	/*2299*/ uint16(xReadSlashR),
+	/*2300*/ uint16(xArgXmm1),
+	/*2301*/ uint16(xArgXmm2M128),
+	/*2302*/ uint16(xMatch),
+	/*2303*/ uint16(xCondPrefix), 2,
+	0x66, 2315,
+	0x0, 2309,
+	/*2309*/ uint16(xSetOp), uint16(PHADDW),
+	/*2311*/ uint16(xReadSlashR),
+	/*2312*/ uint16(xArgMm1),
+	/*2313*/ uint16(xArgMm2M64),
+	/*2314*/ uint16(xMatch),
+	/*2315*/ uint16(xSetOp), uint16(PHADDW),
+	/*2317*/ uint16(xReadSlashR),
+	/*2318*/ uint16(xArgXmm1),
+	/*2319*/ uint16(xArgXmm2M128),
+	/*2320*/ uint16(xMatch),
+	/*2321*/ uint16(xCondPrefix), 2,
+	0x66, 2333,
+	0x0, 2327,
+	/*2327*/ uint16(xSetOp), uint16(PHADDD),
+	/*2329*/ uint16(xReadSlashR),
+	/*2330*/ uint16(xArgMm1),
+	/*2331*/ uint16(xArgMm2M64),
+	/*2332*/ uint16(xMatch),
+	/*2333*/ uint16(xSetOp), uint16(PHADDD),
+	/*2335*/ uint16(xReadSlashR),
+	/*2336*/ uint16(xArgXmm1),
+	/*2337*/ uint16(xArgXmm2M128),
+	/*2338*/ uint16(xMatch),
+	/*2339*/ uint16(xCondPrefix), 2,
+	0x66, 2351,
+	0x0, 2345,
+	/*2345*/ uint16(xSetOp), uint16(PHADDSW),
+	/*2347*/ uint16(xReadSlashR),
+	/*2348*/ uint16(xArgMm1),
+	/*2349*/ uint16(xArgMm2M64),
+	/*2350*/ uint16(xMatch),
+	/*2351*/ uint16(xSetOp), uint16(PHADDSW),
+	/*2353*/ uint16(xReadSlashR),
+	/*2354*/ uint16(xArgXmm1),
+	/*2355*/ uint16(xArgXmm2M128),
+	/*2356*/ uint16(xMatch),
+	/*2357*/ uint16(xCondPrefix), 2,
+	0x66, 2369,
+	0x0, 2363,
+	/*2363*/ uint16(xSetOp), uint16(PMADDUBSW),
+	/*2365*/ uint16(xReadSlashR),
+	/*2366*/ uint16(xArgMm1),
+	/*2367*/ uint16(xArgMm2M64),
+	/*2368*/ uint16(xMatch),
+	/*2369*/ uint16(xSetOp), uint16(PMADDUBSW),
+	/*2371*/ uint16(xReadSlashR),
+	/*2372*/ uint16(xArgXmm1),
+	/*2373*/ uint16(xArgXmm2M128),
+	/*2374*/ uint16(xMatch),
+	/*2375*/ uint16(xCondPrefix), 2,
+	0x66, 2387,
+	0x0, 2381,
+	/*2381*/ uint16(xSetOp), uint16(PHSUBW),
+	/*2383*/ uint16(xReadSlashR),
+	/*2384*/ uint16(xArgMm1),
+	/*2385*/ uint16(xArgMm2M64),
+	/*2386*/ uint16(xMatch),
+	/*2387*/ uint16(xSetOp), uint16(PHSUBW),
+	/*2389*/ uint16(xReadSlashR),
+	/*2390*/ uint16(xArgXmm1),
+	/*2391*/ uint16(xArgXmm2M128),
+	/*2392*/ uint16(xMatch),
+	/*2393*/ uint16(xCondPrefix), 2,
+	0x66, 2405,
+	0x0, 2399,
+	/*2399*/ uint16(xSetOp), uint16(PHSUBD),
+	/*2401*/ uint16(xReadSlashR),
+	/*2402*/ uint16(xArgMm1),
+	/*2403*/ uint16(xArgMm2M64),
+	/*2404*/ uint16(xMatch),
+	/*2405*/ uint16(xSetOp), uint16(PHSUBD),
+	/*2407*/ uint16(xReadSlashR),
+	/*2408*/ uint16(xArgXmm1),
+	/*2409*/ uint16(xArgXmm2M128),
+	/*2410*/ uint16(xMatch),
+	/*2411*/ uint16(xCondPrefix), 2,
+	0x66, 2423,
+	0x0, 2417,
+	/*2417*/ uint16(xSetOp), uint16(PHSUBSW),
+	/*2419*/ uint16(xReadSlashR),
+	/*2420*/ uint16(xArgMm1),
+	/*2421*/ uint16(xArgMm2M64),
+	/*2422*/ uint16(xMatch),
+	/*2423*/ uint16(xSetOp), uint16(PHSUBSW),
+	/*2425*/ uint16(xReadSlashR),
+	/*2426*/ uint16(xArgXmm1),
+	/*2427*/ uint16(xArgXmm2M128),
+	/*2428*/ uint16(xMatch),
+	/*2429*/ uint16(xCondPrefix), 2,
+	0x66, 2441,
+	0x0, 2435,
+	/*2435*/ uint16(xSetOp), uint16(PSIGNB),
+	/*2437*/ uint16(xReadSlashR),
+	/*2438*/ uint16(xArgMm1),
+	/*2439*/ uint16(xArgMm2M64),
+	/*2440*/ uint16(xMatch),
+	/*2441*/ uint16(xSetOp), uint16(PSIGNB),
+	/*2443*/ uint16(xReadSlashR),
+	/*2444*/ uint16(xArgXmm1),
+	/*2445*/ uint16(xArgXmm2M128),
+	/*2446*/ uint16(xMatch),
+	/*2447*/ uint16(xCondPrefix), 2,
+	0x66, 2459,
+	0x0, 2453,
+	/*2453*/ uint16(xSetOp), uint16(PSIGNW),
+	/*2455*/ uint16(xReadSlashR),
+	/*2456*/ uint16(xArgMm1),
+	/*2457*/ uint16(xArgMm2M64),
+	/*2458*/ uint16(xMatch),
+	/*2459*/ uint16(xSetOp), uint16(PSIGNW),
+	/*2461*/ uint16(xReadSlashR),
+	/*2462*/ uint16(xArgXmm1),
+	/*2463*/ uint16(xArgXmm2M128),
+	/*2464*/ uint16(xMatch),
+	/*2465*/ uint16(xCondPrefix), 2,
+	0x66, 2477,
+	0x0, 2471,
+	/*2471*/ uint16(xSetOp), uint16(PSIGND),
+	/*2473*/ uint16(xReadSlashR),
+	/*2474*/ uint16(xArgMm1),
+	/*2475*/ uint16(xArgMm2M64),
+	/*2476*/ uint16(xMatch),
+	/*2477*/ uint16(xSetOp), uint16(PSIGND),
+	/*2479*/ uint16(xReadSlashR),
+	/*2480*/ uint16(xArgXmm1),
+	/*2481*/ uint16(xArgXmm2M128),
+	/*2482*/ uint16(xMatch),
+	/*2483*/ uint16(xCondPrefix), 2,
+	0x66, 2495,
+	0x0, 2489,
+	/*2489*/ uint16(xSetOp), uint16(PMULHRSW),
+	/*2491*/ uint16(xReadSlashR),
+	/*2492*/ uint16(xArgMm1),
+	/*2493*/ uint16(xArgMm2M64),
+	/*2494*/ uint16(xMatch),
+	/*2495*/ uint16(xSetOp), uint16(PMULHRSW),
+	/*2497*/ uint16(xReadSlashR),
+	/*2498*/ uint16(xArgXmm1),
+	/*2499*/ uint16(xArgXmm2M128),
+	/*2500*/ uint16(xMatch),
+	/*2501*/ uint16(xCondPrefix), 1,
+	0x66, 2505,
+	/*2505*/ uint16(xSetOp), uint16(PBLENDVB),
+	/*2507*/ uint16(xReadSlashR),
+	/*2508*/ uint16(xArgXmm1),
+	/*2509*/ uint16(xArgXmm2M128),
+	/*2510*/ uint16(xArgXMM0),
+	/*2511*/ uint16(xMatch),
+	/*2512*/ uint16(xCondPrefix), 1,
+	0x66, 2516,
+	/*2516*/ uint16(xSetOp), uint16(BLENDVPS),
+	/*2518*/ uint16(xReadSlashR),
+	/*2519*/ uint16(xArgXmm1),
+	/*2520*/ uint16(xArgXmm2M128),
+	/*2521*/ uint16(xArgXMM0),
+	/*2522*/ uint16(xMatch),
+	/*2523*/ uint16(xCondPrefix), 1,
+	0x66, 2527,
+	/*2527*/ uint16(xSetOp), uint16(BLENDVPD),
+	/*2529*/ uint16(xReadSlashR),
+	/*2530*/ uint16(xArgXmm1),
+	/*2531*/ uint16(xArgXmm2M128),
+	/*2532*/ uint16(xArgXMM0),
+	/*2533*/ uint16(xMatch),
+	/*2534*/ uint16(xCondPrefix), 1,
+	0x66, 2538,
+	/*2538*/ uint16(xSetOp), uint16(PTEST),
+	/*2540*/ uint16(xReadSlashR),
+	/*2541*/ uint16(xArgXmm1),
+	/*2542*/ uint16(xArgXmm2M128),
+	/*2543*/ uint16(xMatch),
+	/*2544*/ uint16(xCondPrefix), 2,
+	0x66, 2556,
+	0x0, 2550,
+	/*2550*/ uint16(xSetOp), uint16(PABSB),
+	/*2552*/ uint16(xReadSlashR),
+	/*2553*/ uint16(xArgMm1),
+	/*2554*/ uint16(xArgMm2M64),
+	/*2555*/ uint16(xMatch),
+	/*2556*/ uint16(xSetOp), uint16(PABSB),
+	/*2558*/ uint16(xReadSlashR),
+	/*2559*/ uint16(xArgXmm1),
+	/*2560*/ uint16(xArgXmm2M128),
+	/*2561*/ uint16(xMatch),
+	/*2562*/ uint16(xCondPrefix), 2,
+	0x66, 2574,
+	0x0, 2568,
+	/*2568*/ uint16(xSetOp), uint16(PABSW),
+	/*2570*/ uint16(xReadSlashR),
+	/*2571*/ uint16(xArgMm1),
+	/*2572*/ uint16(xArgMm2M64),
+	/*2573*/ uint16(xMatch),
+	/*2574*/ uint16(xSetOp), uint16(PABSW),
+	/*2576*/ uint16(xReadSlashR),
+	/*2577*/ uint16(xArgXmm1),
+	/*2578*/ uint16(xArgXmm2M128),
+	/*2579*/ uint16(xMatch),
+	/*2580*/ uint16(xCondPrefix), 2,
+	0x66, 2592,
+	0x0, 2586,
+	/*2586*/ uint16(xSetOp), uint16(PABSD),
+	/*2588*/ uint16(xReadSlashR),
+	/*2589*/ uint16(xArgMm1),
+	/*2590*/ uint16(xArgMm2M64),
+	/*2591*/ uint16(xMatch),
+	/*2592*/ uint16(xSetOp), uint16(PABSD),
+	/*2594*/ uint16(xReadSlashR),
+	/*2595*/ uint16(xArgXmm1),
+	/*2596*/ uint16(xArgXmm2M128),
+	/*2597*/ uint16(xMatch),
+	/*2598*/ uint16(xCondPrefix), 1,
+	0x66, 2602,
+	/*2602*/ uint16(xSetOp), uint16(PMOVSXBW),
+	/*2604*/ uint16(xReadSlashR),
+	/*2605*/ uint16(xArgXmm1),
+	/*2606*/ uint16(xArgXmm2M64),
+	/*2607*/ uint16(xMatch),
+	/*2608*/ uint16(xCondPrefix), 1,
+	0x66, 2612,
+	/*2612*/ uint16(xSetOp), uint16(PMOVSXBD),
+	/*2614*/ uint16(xReadSlashR),
+	/*2615*/ uint16(xArgXmm1),
+	/*2616*/ uint16(xArgXmm2M32),
+	/*2617*/ uint16(xMatch),
+	/*2618*/ uint16(xCondPrefix), 1,
+	0x66, 2622,
+	/*2622*/ uint16(xSetOp), uint16(PMOVSXBQ),
+	/*2624*/ uint16(xReadSlashR),
+	/*2625*/ uint16(xArgXmm1),
+	/*2626*/ uint16(xArgXmm2M16),
+	/*2627*/ uint16(xMatch),
+	/*2628*/ uint16(xCondPrefix), 1,
+	0x66, 2632,
+	/*2632*/ uint16(xSetOp), uint16(PMOVSXWD),
+	/*2634*/ uint16(xReadSlashR),
+	/*2635*/ uint16(xArgXmm1),
+	/*2636*/ uint16(xArgXmm2M64),
+	/*2637*/ uint16(xMatch),
+	/*2638*/ uint16(xCondPrefix), 1,
+	0x66, 2642,
+	/*2642*/ uint16(xSetOp), uint16(PMOVSXWQ),
+	/*2644*/ uint16(xReadSlashR),
+	/*2645*/ uint16(xArgXmm1),
+	/*2646*/ uint16(xArgXmm2M32),
+	/*2647*/ uint16(xMatch),
+	/*2648*/ uint16(xCondPrefix), 1,
+	0x66, 2652,
+	/*2652*/ uint16(xSetOp), uint16(PMOVSXDQ),
+	/*2654*/ uint16(xReadSlashR),
+	/*2655*/ uint16(xArgXmm1),
+	/*2656*/ uint16(xArgXmm2M64),
+	/*2657*/ uint16(xMatch),
+	/*2658*/ uint16(xCondPrefix), 1,
+	0x66, 2662,
+	/*2662*/ uint16(xSetOp), uint16(PMULDQ),
+	/*2664*/ uint16(xReadSlashR),
+	/*2665*/ uint16(xArgXmm1),
+	/*2666*/ uint16(xArgXmm2M128),
+	/*2667*/ uint16(xMatch),
+	/*2668*/ uint16(xCondPrefix), 1,
+	0x66, 2672,
+	/*2672*/ uint16(xSetOp), uint16(PCMPEQQ),
+	/*2674*/ uint16(xReadSlashR),
+	/*2675*/ uint16(xArgXmm1),
+	/*2676*/ uint16(xArgXmm2M128),
+	/*2677*/ uint16(xMatch),
+	/*2678*/ uint16(xCondPrefix), 1,
+	0x66, 2682,
+	/*2682*/ uint16(xSetOp), uint16(MOVNTDQA),
+	/*2684*/ uint16(xReadSlashR),
+	/*2685*/ uint16(xArgXmm1),
+	/*2686*/ uint16(xArgM128),
+	/*2687*/ uint16(xMatch),
+	/*2688*/ uint16(xCondPrefix), 1,
+	0x66, 2692,
+	/*2692*/ uint16(xSetOp), uint16(PACKUSDW),
+	/*2694*/ uint16(xReadSlashR),
+	/*2695*/ uint16(xArgXmm1),
+	/*2696*/ uint16(xArgXmm2M128),
+	/*2697*/ uint16(xMatch),
+	/*2698*/ uint16(xCondPrefix), 1,
+	0x66, 2702,
+	/*2702*/ uint16(xSetOp), uint16(PMOVZXBW),
+	/*2704*/ uint16(xReadSlashR),
+	/*2705*/ uint16(xArgXmm1),
+	/*2706*/ uint16(xArgXmm2M64),
+	/*2707*/ uint16(xMatch),
+	/*2708*/ uint16(xCondPrefix), 1,
+	0x66, 2712,
+	/*2712*/ uint16(xSetOp), uint16(PMOVZXBD),
+	/*2714*/ uint16(xReadSlashR),
+	/*2715*/ uint16(xArgXmm1),
+	/*2716*/ uint16(xArgXmm2M32),
+	/*2717*/ uint16(xMatch),
+	/*2718*/ uint16(xCondPrefix), 1,
+	0x66, 2722,
+	/*2722*/ uint16(xSetOp), uint16(PMOVZXBQ),
+	/*2724*/ uint16(xReadSlashR),
+	/*2725*/ uint16(xArgXmm1),
+	/*2726*/ uint16(xArgXmm2M16),
+	/*2727*/ uint16(xMatch),
+	/*2728*/ uint16(xCondPrefix), 1,
+	0x66, 2732,
+	/*2732*/ uint16(xSetOp), uint16(PMOVZXWD),
+	/*2734*/ uint16(xReadSlashR),
+	/*2735*/ uint16(xArgXmm1),
+	/*2736*/ uint16(xArgXmm2M64),
+	/*2737*/ uint16(xMatch),
+	/*2738*/ uint16(xCondPrefix), 1,
+	0x66, 2742,
+	/*2742*/ uint16(xSetOp), uint16(PMOVZXWQ),
+	/*2744*/ uint16(xReadSlashR),
+	/*2745*/ uint16(xArgXmm1),
+	/*2746*/ uint16(xArgXmm2M32),
+	/*2747*/ uint16(xMatch),
+	/*2748*/ uint16(xCondPrefix), 1,
+	0x66, 2752,
+	/*2752*/ uint16(xSetOp), uint16(PMOVZXDQ),
+	/*2754*/ uint16(xReadSlashR),
+	/*2755*/ uint16(xArgXmm1),
+	/*2756*/ uint16(xArgXmm2M64),
+	/*2757*/ uint16(xMatch),
+	/*2758*/ uint16(xCondPrefix), 1,
+	0x66, 2762,
+	/*2762*/ uint16(xSetOp), uint16(PCMPGTQ),
+	/*2764*/ uint16(xReadSlashR),
+	/*2765*/ uint16(xArgXmm1),
+	/*2766*/ uint16(xArgXmm2M128),
+	/*2767*/ uint16(xMatch),
+	/*2768*/ uint16(xCondPrefix), 1,
+	0x66, 2772,
+	/*2772*/ uint16(xSetOp), uint16(PMINSB),
+	/*2774*/ uint16(xReadSlashR),
+	/*2775*/ uint16(xArgXmm1),
+	/*2776*/ uint16(xArgXmm2M128),
+	/*2777*/ uint16(xMatch),
+	/*2778*/ uint16(xCondPrefix), 1,
+	0x66, 2782,
+	/*2782*/ uint16(xSetOp), uint16(PMINSD),
+	/*2784*/ uint16(xReadSlashR),
+	/*2785*/ uint16(xArgXmm1),
+	/*2786*/ uint16(xArgXmm2M128),
+	/*2787*/ uint16(xMatch),
+	/*2788*/ uint16(xCondPrefix), 1,
+	0x66, 2792,
+	/*2792*/ uint16(xSetOp), uint16(PMINUW),
+	/*2794*/ uint16(xReadSlashR),
+	/*2795*/ uint16(xArgXmm1),
+	/*2796*/ uint16(xArgXmm2M128),
+	/*2797*/ uint16(xMatch),
+	/*2798*/ uint16(xCondPrefix), 1,
+	0x66, 2802,
+	/*2802*/ uint16(xSetOp), uint16(PMINUD),
+	/*2804*/ uint16(xReadSlashR),
+	/*2805*/ uint16(xArgXmm1),
+	/*2806*/ uint16(xArgXmm2M128),
+	/*2807*/ uint16(xMatch),
+	/*2808*/ uint16(xCondPrefix), 1,
+	0x66, 2812,
+	/*2812*/ uint16(xSetOp), uint16(PMAXSB),
+	/*2814*/ uint16(xReadSlashR),
+	/*2815*/ uint16(xArgXmm1),
+	/*2816*/ uint16(xArgXmm2M128),
+	/*2817*/ uint16(xMatch),
+	/*2818*/ uint16(xCondPrefix), 1,
+	0x66, 2822,
+	/*2822*/ uint16(xSetOp), uint16(PMAXSD),
+	/*2824*/ uint16(xReadSlashR),
+	/*2825*/ uint16(xArgXmm1),
+	/*2826*/ uint16(xArgXmm2M128),
+	/*2827*/ uint16(xMatch),
+	/*2828*/ uint16(xCondPrefix), 1,
+	0x66, 2832,
+	/*2832*/ uint16(xSetOp), uint16(PMAXUW),
+	/*2834*/ uint16(xReadSlashR),
+	/*2835*/ uint16(xArgXmm1),
+	/*2836*/ uint16(xArgXmm2M128),
+	/*2837*/ uint16(xMatch),
+	/*2838*/ uint16(xCondPrefix), 1,
+	0x66, 2842,
+	/*2842*/ uint16(xSetOp), uint16(PMAXUD),
+	/*2844*/ uint16(xReadSlashR),
+	/*2845*/ uint16(xArgXmm1),
+	/*2846*/ uint16(xArgXmm2M128),
+	/*2847*/ uint16(xMatch),
+	/*2848*/ uint16(xCondPrefix), 1,
+	0x66, 2852,
+	/*2852*/ uint16(xSetOp), uint16(PMULLD),
+	/*2854*/ uint16(xReadSlashR),
+	/*2855*/ uint16(xArgXmm1),
+	/*2856*/ uint16(xArgXmm2M128),
+	/*2857*/ uint16(xMatch),
+	/*2858*/ uint16(xCondPrefix), 1,
+	0x66, 2862,
+	/*2862*/ uint16(xSetOp), uint16(PHMINPOSUW),
+	/*2864*/ uint16(xReadSlashR),
+	/*2865*/ uint16(xArgXmm1),
+	/*2866*/ uint16(xArgXmm2M128),
+	/*2867*/ uint16(xMatch),
+	/*2868*/ uint16(xCondIs64), 2871, 2881,
+	/*2871*/ uint16(xCondPrefix), 1,
+	0x66, 2875,
+	/*2875*/ uint16(xSetOp), uint16(INVPCID),
+	/*2877*/ uint16(xReadSlashR),
+	/*2878*/ uint16(xArgR32),
+	/*2879*/ uint16(xArgM128),
+	/*2880*/ uint16(xMatch),
+	/*2881*/ uint16(xCondPrefix), 1,
+	0x66, 2885,
+	/*2885*/ uint16(xSetOp), uint16(INVPCID),
+	/*2887*/ uint16(xReadSlashR),
+	/*2888*/ uint16(xArgR64),
+	/*2889*/ uint16(xArgM128),
+	/*2890*/ uint16(xMatch),
+	/*2891*/ uint16(xCondPrefix), 1,
+	0x66, 2895,
+	/*2895*/ uint16(xSetOp), uint16(AESIMC),
+	/*2897*/ uint16(xReadSlashR),
+	/*2898*/ uint16(xArgXmm1),
+	/*2899*/ uint16(xArgXmm2M128),
+	/*2900*/ uint16(xMatch),
+	/*2901*/ uint16(xCondPrefix), 1,
+	0x66, 2905,
+	/*2905*/ uint16(xSetOp), uint16(AESENC),
+	/*2907*/ uint16(xReadSlashR),
+	/*2908*/ uint16(xArgXmm1),
+	/*2909*/ uint16(xArgXmm2M128),
+	/*2910*/ uint16(xMatch),
+	/*2911*/ uint16(xCondPrefix), 1,
+	0x66, 2915,
+	/*2915*/ uint16(xSetOp), uint16(AESENCLAST),
+	/*2917*/ uint16(xReadSlashR),
+	/*2918*/ uint16(xArgXmm1),
+	/*2919*/ uint16(xArgXmm2M128),
+	/*2920*/ uint16(xMatch),
+	/*2921*/ uint16(xCondPrefix), 1,
+	0x66, 2925,
+	/*2925*/ uint16(xSetOp), uint16(AESDEC),
+	/*2927*/ uint16(xReadSlashR),
+	/*2928*/ uint16(xArgXmm1),
+	/*2929*/ uint16(xArgXmm2M128),
+	/*2930*/ uint16(xMatch),
+	/*2931*/ uint16(xCondPrefix), 1,
+	0x66, 2935,
+	/*2935*/ uint16(xSetOp), uint16(AESDECLAST),
+	/*2937*/ uint16(xReadSlashR),
+	/*2938*/ uint16(xArgXmm1),
+	/*2939*/ uint16(xArgXmm2M128),
+	/*2940*/ uint16(xMatch),
+	/*2941*/ uint16(xCondIs64), 2944, 2982,
+	/*2944*/ uint16(xCondPrefix), 2,
+	0xF2, 2966,
+	0x0, 2950,
+	/*2950*/ uint16(xCondDataSize), 2954, 2960, 0,
+	/*2954*/ uint16(xSetOp), uint16(MOVBE),
+	/*2956*/ uint16(xReadSlashR),
+	/*2957*/ uint16(xArgR16),
+	/*2958*/ uint16(xArgM16),
+	/*2959*/ uint16(xMatch),
+	/*2960*/ uint16(xSetOp), uint16(MOVBE),
+	/*2962*/ uint16(xReadSlashR),
+	/*2963*/ uint16(xArgR32),
+	/*2964*/ uint16(xArgM32),
+	/*2965*/ uint16(xMatch),
+	/*2966*/ uint16(xCondDataSize), 2970, 2976, 0,
+	/*2970*/ uint16(xSetOp), uint16(CRC32),
+	/*2972*/ uint16(xReadSlashR),
+	/*2973*/ uint16(xArgR32),
+	/*2974*/ uint16(xArgRM8),
+	/*2975*/ uint16(xMatch),
+	/*2976*/ uint16(xSetOp), uint16(CRC32),
+	/*2978*/ uint16(xReadSlashR),
+	/*2979*/ uint16(xArgR32),
+	/*2980*/ uint16(xArgRM8),
+	/*2981*/ uint16(xMatch),
+	/*2982*/ uint16(xCondPrefix), 2,
+	0xF2, 2998,
+	0x0, 2988,
+	/*2988*/ uint16(xCondDataSize), 2954, 2960, 2992,
+	/*2992*/ uint16(xSetOp), uint16(MOVBE),
+	/*2994*/ uint16(xReadSlashR),
+	/*2995*/ uint16(xArgR64),
+	/*2996*/ uint16(xArgM64),
+	/*2997*/ uint16(xMatch),
+	/*2998*/ uint16(xCondDataSize), 2970, 2976, 3002,
+	/*3002*/ uint16(xSetOp), uint16(CRC32),
+	/*3004*/ uint16(xReadSlashR),
+	/*3005*/ uint16(xArgR64),
+	/*3006*/ uint16(xArgRM8),
+	/*3007*/ uint16(xMatch),
+	/*3008*/ uint16(xCondIs64), 3011, 3049,
+	/*3011*/ uint16(xCondPrefix), 2,
+	0xF2, 3033,
+	0x0, 3017,
+	/*3017*/ uint16(xCondDataSize), 3021, 3027, 0,
+	/*3021*/ uint16(xSetOp), uint16(MOVBE),
+	/*3023*/ uint16(xReadSlashR),
+	/*3024*/ uint16(xArgM16),
+	/*3025*/ uint16(xArgR16),
+	/*3026*/ uint16(xMatch),
+	/*3027*/ uint16(xSetOp), uint16(MOVBE),
+	/*3029*/ uint16(xReadSlashR),
+	/*3030*/ uint16(xArgM32),
+	/*3031*/ uint16(xArgR32),
+	/*3032*/ uint16(xMatch),
+	/*3033*/ uint16(xCondDataSize), 3037, 3043, 0,
+	/*3037*/ uint16(xSetOp), uint16(CRC32),
+	/*3039*/ uint16(xReadSlashR),
+	/*3040*/ uint16(xArgR32),
+	/*3041*/ uint16(xArgRM16),
+	/*3042*/ uint16(xMatch),
+	/*3043*/ uint16(xSetOp), uint16(CRC32),
+	/*3045*/ uint16(xReadSlashR),
+	/*3046*/ uint16(xArgR32),
+	/*3047*/ uint16(xArgRM32),
+	/*3048*/ uint16(xMatch),
+	/*3049*/ uint16(xCondPrefix), 2,
+	0xF2, 3065,
+	0x0, 3055,
+	/*3055*/ uint16(xCondDataSize), 3021, 3027, 3059,
+	/*3059*/ uint16(xSetOp), uint16(MOVBE),
+	/*3061*/ uint16(xReadSlashR),
+	/*3062*/ uint16(xArgM64),
+	/*3063*/ uint16(xArgR64),
+	/*3064*/ uint16(xMatch),
+	/*3065*/ uint16(xCondDataSize), 3037, 3043, 3069,
+	/*3069*/ uint16(xSetOp), uint16(CRC32),
+	/*3071*/ uint16(xReadSlashR),
+	/*3072*/ uint16(xArgR64),
+	/*3073*/ uint16(xArgRM64),
+	/*3074*/ uint16(xMatch),
+	/*3075*/ uint16(xCondByte), 24,
+	0x08, 3126,
+	0x09, 3138,
+	0x0A, 3150,
+	0x0B, 3162,
+	0x0C, 3174,
+	0x0D, 3186,
+	0x0E, 3198,
+	0x0F, 3210,
+	0x14, 3232,
+	0x15, 3244,
+	0x16, 3256,
+	0x17, 3299,
+	0x20, 3311,
+	0x21, 3323,
+	0x22, 3335,
+	0x40, 3378,
+	0x41, 3390,
+	0x42, 3402,
+	0x44, 3414,
+	0x60, 3426,
+	0x61, 3438,
+	0x62, 3450,
+	0x63, 3462,
+	0xDF, 3474,
 	uint16(xFail),
-	/*3124*/ uint16(xCondPrefix), 1,
-	0x66, 3128,
-	/*3128*/ uint16(xSetOp), uint16(ROUNDPS),
-	/*3130*/ uint16(xReadSlashR),
-	/*3131*/ uint16(xReadIb),
-	/*3132*/ uint16(xArgXmm1),
-	/*3133*/ uint16(xArgXmm2M128),
-	/*3134*/ uint16(xArgImm8u),
-	/*3135*/ uint16(xMatch),
-	/*3136*/ uint16(xCondPrefix), 1,
-	0x66, 3140,
-	/*3140*/ uint16(xSetOp), uint16(ROUNDPD),
-	/*3142*/ uint16(xReadSlashR),
-	/*3143*/ uint16(xReadIb),
-	/*3144*/ uint16(xArgXmm1),
-	/*3145*/ uint16(xArgXmm2M128),
-	/*3146*/ uint16(xArgImm8u),
-	/*3147*/ uint16(xMatch),
-	/*3148*/ uint16(xCondPrefix), 1,
-	0x66, 3152,
-	/*3152*/ uint16(xSetOp), uint16(ROUNDSS),
-	/*3154*/ uint16(xReadSlashR),
-	/*3155*/ uint16(xReadIb),
-	/*3156*/ uint16(xArgXmm1),
-	/*3157*/ uint16(xArgXmm2M32),
-	/*3158*/ uint16(xArgImm8u),
-	/*3159*/ uint16(xMatch),
-	/*3160*/ uint16(xCondPrefix), 1,
-	0x66, 3164,
-	/*3164*/ uint16(xSetOp), uint16(ROUNDSD),
-	/*3166*/ uint16(xReadSlashR),
-	/*3167*/ uint16(xReadIb),
-	/*3168*/ uint16(xArgXmm1),
-	/*3169*/ uint16(xArgXmm2M64),
-	/*3170*/ uint16(xArgImm8u),
-	/*3171*/ uint16(xMatch),
-	/*3172*/ uint16(xCondPrefix), 1,
-	0x66, 3176,
-	/*3176*/ uint16(xSetOp), uint16(BLENDPS),
-	/*3178*/ uint16(xReadSlashR),
-	/*3179*/ uint16(xReadIb),
-	/*3180*/ uint16(xArgXmm1),
-	/*3181*/ uint16(xArgXmm2M128),
-	/*3182*/ uint16(xArgImm8u),
-	/*3183*/ uint16(xMatch),
-	/*3184*/ uint16(xCondPrefix), 1,
-	0x66, 3188,
-	/*3188*/ uint16(xSetOp), uint16(BLENDPD),
-	/*3190*/ uint16(xReadSlashR),
-	/*3191*/ uint16(xReadIb),
-	/*3192*/ uint16(xArgXmm1),
-	/*3193*/ uint16(xArgXmm2M128),
-	/*3194*/ uint16(xArgImm8u),
-	/*3195*/ uint16(xMatch),
-	/*3196*/ uint16(xCondPrefix), 1,
-	0x66, 3200,
-	/*3200*/ uint16(xSetOp), uint16(PBLENDW),
-	/*3202*/ uint16(xReadSlashR),
-	/*3203*/ uint16(xReadIb),
-	/*3204*/ uint16(xArgXmm1),
-	/*3205*/ uint16(xArgXmm2M128),
-	/*3206*/ uint16(xArgImm8u),
-	/*3207*/ uint16(xMatch),
-	/*3208*/ uint16(xCondPrefix), 2,
-	0x66, 3222,
-	0x0, 3214,
-	/*3214*/ uint16(xSetOp), uint16(PALIGNR),
-	/*3216*/ uint16(xReadSlashR),
-	/*3217*/ uint16(xReadIb),
-	/*3218*/ uint16(xArgMm1),
-	/*3219*/ uint16(xArgMm2M64),
-	/*3220*/ uint16(xArgImm8u),
-	/*3221*/ uint16(xMatch),
-	/*3222*/ uint16(xSetOp), uint16(PALIGNR),
-	/*3224*/ uint16(xReadSlashR),
-	/*3225*/ uint16(xReadIb),
-	/*3226*/ uint16(xArgXmm1),
-	/*3227*/ uint16(xArgXmm2M128),
-	/*3228*/ uint16(xArgImm8u),
-	/*3229*/ uint16(xMatch),
-	/*3230*/ uint16(xCondPrefix), 1,
-	0x66, 3234,
-	/*3234*/ uint16(xSetOp), uint16(PEXTRB),
-	/*3236*/ uint16(xReadSlashR),
-	/*3237*/ uint16(xReadIb),
-	/*3238*/ uint16(xArgR32M8),
-	/*3239*/ uint16(xArgXmm1),
-	/*3240*/ uint16(xArgImm8u),
-	/*3241*/ uint16(xMatch),
-	/*3242*/ uint16(xCondPrefix), 1,
-	0x66, 3246,
-	/*3246*/ uint16(xSetOp), uint16(PEXTRW),
-	/*3248*/ uint16(xReadSlashR),
-	/*3249*/ uint16(xReadIb),
-	/*3250*/ uint16(xArgR32M16),
-	/*3251*/ uint16(xArgXmm1),
-	/*3252*/ uint16(xArgImm8u),
-	/*3253*/ uint16(xMatch),
-	/*3254*/ uint16(xCondIs64), 3257, 3281,
-	/*3257*/ uint16(xCondPrefix), 1,
-	0x66, 3261,
-	/*3261*/ uint16(xCondDataSize), 3265, 3273, 0,
-	/*3265*/ uint16(xSetOp), uint16(PEXTRD),
-	/*3267*/ uint16(xReadSlashR),
-	/*3268*/ uint16(xReadIb),
-	/*3269*/ uint16(xArgRM32),
-	/*3270*/ uint16(xArgXmm1),
-	/*3271*/ uint16(xArgImm8u),
-	/*3272*/ uint16(xMatch),
-	/*3273*/ uint16(xSetOp), uint16(PEXTRD),
-	/*3275*/ uint16(xReadSlashR),
-	/*3276*/ uint16(xReadIb),
-	/*3277*/ uint16(xArgRM32),
-	/*3278*/ uint16(xArgXmm1),
-	/*3279*/ uint16(xArgImm8u),
-	/*3280*/ uint16(xMatch),
-	/*3281*/ uint16(xCondPrefix), 1,
-	0x66, 3285,
-	/*3285*/ uint16(xCondDataSize), 3265, 3273, 3289,
-	/*3289*/ uint16(xSetOp), uint16(PEXTRQ),
-	/*3291*/ uint16(xReadSlashR),
-	/*3292*/ uint16(xReadIb),
-	/*3293*/ uint16(xArgRM64),
-	/*3294*/ uint16(xArgXmm1),
-	/*3295*/ uint16(xArgImm8u),
-	/*3296*/ uint16(xMatch),
-	/*3297*/ uint16(xCondPrefix), 1,
-	0x66, 3301,
-	/*3301*/ uint16(xSetOp), uint16(EXTRACTPS),
-	/*3303*/ uint16(xReadSlashR),
-	/*3304*/ uint16(xReadIb),
-	/*3305*/ uint16(xArgRM32),
-	/*3306*/ uint16(xArgXmm1),
-	/*3307*/ uint16(xArgImm8u),
-	/*3308*/ uint16(xMatch),
-	/*3309*/ uint16(xCondPrefix), 1,
-	0x66, 3313,
-	/*3313*/ uint16(xSetOp), uint16(PINSRB),
-	/*3315*/ uint16(xReadSlashR),
-	/*3316*/ uint16(xReadIb),
-	/*3317*/ uint16(xArgXmm1),
-	/*3318*/ uint16(xArgR32M8),
-	/*3319*/ uint16(xArgImm8u),
-	/*3320*/ uint16(xMatch),
-	/*3321*/ uint16(xCondPrefix), 1,
-	0x66, 3325,
-	/*3325*/ uint16(xSetOp), uint16(INSERTPS),
-	/*3327*/ uint16(xReadSlashR),
-	/*3328*/ uint16(xReadIb),
-	/*3329*/ uint16(xArgXmm1),
-	/*3330*/ uint16(xArgXmm2M32),
-	/*3331*/ uint16(xArgImm8u),
-	/*3332*/ uint16(xMatch),
-	/*3333*/ uint16(xCondIs64), 3336, 3360,
-	/*3336*/ uint16(xCondPrefix), 1,
-	0x66, 3340,
-	/*3340*/ uint16(xCondDataSize), 3344, 3352, 0,
-	/*3344*/ uint16(xSetOp), uint16(PINSRD),
-	/*3346*/ uint16(xReadSlashR),
-	/*3347*/ uint16(xReadIb),
-	/*3348*/ uint16(xArgXmm1),
-	/*3349*/ uint16(xArgRM32),
-	/*3350*/ uint16(xArgImm8u),
-	/*3351*/ uint16(xMatch),
-	/*3352*/ uint16(xSetOp), uint16(PINSRD),
-	/*3354*/ uint16(xReadSlashR),
-	/*3355*/ uint16(xReadIb),
-	/*3356*/ uint16(xArgXmm1),
-	/*3357*/ uint16(xArgRM32),
-	/*3358*/ uint16(xArgImm8u),
-	/*3359*/ uint16(xMatch),
-	/*3360*/ uint16(xCondPrefix), 1,
-	0x66, 3364,
-	/*3364*/ uint16(xCondDataSize), 3344, 3352, 3368,
-	/*3368*/ uint16(xSetOp), uint16(PINSRQ),
-	/*3370*/ uint16(xReadSlashR),
-	/*3371*/ uint16(xReadIb),
-	/*3372*/ uint16(xArgXmm1),
-	/*3373*/ uint16(xArgRM64),
-	/*3374*/ uint16(xArgImm8u),
-	/*3375*/ uint16(xMatch),
-	/*3376*/ uint16(xCondPrefix), 1,
-	0x66, 3380,
-	/*3380*/ uint16(xSetOp), uint16(DPPS),
-	/*3382*/ uint16(xReadSlashR),
-	/*3383*/ uint16(xReadIb),
-	/*3384*/ uint16(xArgXmm1),
-	/*3385*/ uint16(xArgXmm2M128),
-	/*3386*/ uint16(xArgImm8u),
-	/*3387*/ uint16(xMatch),
-	/*3388*/ uint16(xCondPrefix), 1,
-	0x66, 3392,
-	/*3392*/ uint16(xSetOp), uint16(DPPD),
-	/*3394*/ uint16(xReadSlashR),
-	/*3395*/ uint16(xReadIb),
-	/*3396*/ uint16(xArgXmm1),
-	/*3397*/ uint16(xArgXmm2M128),
-	/*3398*/ uint16(xArgImm8u),
-	/*3399*/ uint16(xMatch),
-	/*3400*/ uint16(xCondPrefix), 1,
-	0x66, 3404,
-	/*3404*/ uint16(xSetOp), uint16(MPSADBW),
-	/*3406*/ uint16(xReadSlashR),
-	/*3407*/ uint16(xReadIb),
-	/*3408*/ uint16(xArgXmm1),
-	/*3409*/ uint16(xArgXmm2M128),
-	/*3410*/ uint16(xArgImm8u),
-	/*3411*/ uint16(xMatch),
-	/*3412*/ uint16(xCondPrefix), 1,
-	0x66, 3416,
-	/*3416*/ uint16(xSetOp), uint16(PCLMULQDQ),
-	/*3418*/ uint16(xReadSlashR),
-	/*3419*/ uint16(xReadIb),
-	/*3420*/ uint16(xArgXmm1),
-	/*3421*/ uint16(xArgXmm2M128),
-	/*3422*/ uint16(xArgImm8u),
-	/*3423*/ uint16(xMatch),
-	/*3424*/ uint16(xCondPrefix), 1,
-	0x66, 3428,
-	/*3428*/ uint16(xSetOp), uint16(PCMPESTRM),
-	/*3430*/ uint16(xReadSlashR),
-	/*3431*/ uint16(xReadIb),
-	/*3432*/ uint16(xArgXmm1),
-	/*3433*/ uint16(xArgXmm2M128),
-	/*3434*/ uint16(xArgImm8u),
-	/*3435*/ uint16(xMatch),
-	/*3436*/ uint16(xCondPrefix), 1,
-	0x66, 3440,
-	/*3440*/ uint16(xSetOp), uint16(PCMPESTRI),
-	/*3442*/ uint16(xReadSlashR),
-	/*3443*/ uint16(xReadIb),
-	/*3444*/ uint16(xArgXmm1),
-	/*3445*/ uint16(xArgXmm2M128),
-	/*3446*/ uint16(xArgImm8u),
-	/*3447*/ uint16(xMatch),
-	/*3448*/ uint16(xCondPrefix), 1,
-	0x66, 3452,
-	/*3452*/ uint16(xSetOp), uint16(PCMPISTRM),
-	/*3454*/ uint16(xReadSlashR),
-	/*3455*/ uint16(xReadIb),
-	/*3456*/ uint16(xArgXmm1),
-	/*3457*/ uint16(xArgXmm2M128),
-	/*3458*/ uint16(xArgImm8u),
-	/*3459*/ uint16(xMatch),
-	/*3460*/ uint16(xCondPrefix), 1,
-	0x66, 3464,
-	/*3464*/ uint16(xSetOp), uint16(PCMPISTRI),
-	/*3466*/ uint16(xReadSlashR),
-	/*3467*/ uint16(xReadIb),
-	/*3468*/ uint16(xArgXmm1),
-	/*3469*/ uint16(xArgXmm2M128),
-	/*3470*/ uint16(xArgImm8u),
-	/*3471*/ uint16(xMatch),
-	/*3472*/ uint16(xCondPrefix), 1,
-	0x66, 3476,
-	/*3476*/ uint16(xSetOp), uint16(AESKEYGENASSIST),
-	/*3478*/ uint16(xReadSlashR),
-	/*3479*/ uint16(xReadIb),
-	/*3480*/ uint16(xArgXmm1),
-	/*3481*/ uint16(xArgXmm2M128),
-	/*3482*/ uint16(xArgImm8u),
-	/*3483*/ uint16(xMatch),
-	/*3484*/ uint16(xCondIs64), 3487, 3503,
-	/*3487*/ uint16(xCondDataSize), 3491, 3497, 0,
-	/*3491*/ uint16(xSetOp), uint16(CMOVO),
-	/*3493*/ uint16(xReadSlashR),
-	/*3494*/ uint16(xArgR16),
-	/*3495*/ uint16(xArgRM16),
-	/*3496*/ uint16(xMatch),
-	/*3497*/ uint16(xSetOp), uint16(CMOVO),
-	/*3499*/ uint16(xReadSlashR),
-	/*3500*/ uint16(xArgR32),
-	/*3501*/ uint16(xArgRM32),
-	/*3502*/ uint16(xMatch),
-	/*3503*/ uint16(xCondDataSize), 3491, 3497, 3507,
-	/*3507*/ uint16(xSetOp), uint16(CMOVO),
-	/*3509*/ uint16(xReadSlashR),
-	/*3510*/ uint16(xArgR64),
-	/*3511*/ uint16(xArgRM64),
-	/*3512*/ uint16(xMatch),
-	/*3513*/ uint16(xCondIs64), 3516, 3532,
-	/*3516*/ uint16(xCondDataSize), 3520, 3526, 0,
-	/*3520*/ uint16(xSetOp), uint16(CMOVNO),
-	/*3522*/ uint16(xReadSlashR),
-	/*3523*/ uint16(xArgR16),
-	/*3524*/ uint16(xArgRM16),
-	/*3525*/ uint16(xMatch),
-	/*3526*/ uint16(xSetOp), uint16(CMOVNO),
-	/*3528*/ uint16(xReadSlashR),
-	/*3529*/ uint16(xArgR32),
-	/*3530*/ uint16(xArgRM32),
-	/*3531*/ uint16(xMatch),
-	/*3532*/ uint16(xCondDataSize), 3520, 3526, 3536,
-	/*3536*/ uint16(xSetOp), uint16(CMOVNO),
-	/*3538*/ uint16(xReadSlashR),
-	/*3539*/ uint16(xArgR64),
-	/*3540*/ uint16(xArgRM64),
-	/*3541*/ uint16(xMatch),
-	/*3542*/ uint16(xCondIs64), 3545, 3561,
-	/*3545*/ uint16(xCondDataSize), 3549, 3555, 0,
-	/*3549*/ uint16(xSetOp), uint16(CMOVB),
-	/*3551*/ uint16(xReadSlashR),
-	/*3552*/ uint16(xArgR16),
-	/*3553*/ uint16(xArgRM16),
-	/*3554*/ uint16(xMatch),
-	/*3555*/ uint16(xSetOp), uint16(CMOVB),
-	/*3557*/ uint16(xReadSlashR),
-	/*3558*/ uint16(xArgR32),
-	/*3559*/ uint16(xArgRM32),
-	/*3560*/ uint16(xMatch),
-	/*3561*/ uint16(xCondDataSize), 3549, 3555, 3565,
-	/*3565*/ uint16(xSetOp), uint16(CMOVB),
-	/*3567*/ uint16(xReadSlashR),
-	/*3568*/ uint16(xArgR64),
-	/*3569*/ uint16(xArgRM64),
-	/*3570*/ uint16(xMatch),
-	/*3571*/ uint16(xCondIs64), 3574, 3590,
-	/*3574*/ uint16(xCondDataSize), 3578, 3584, 0,
-	/*3578*/ uint16(xSetOp), uint16(CMOVAE),
-	/*3580*/ uint16(xReadSlashR),
-	/*3581*/ uint16(xArgR16),
-	/*3582*/ uint16(xArgRM16),
-	/*3583*/ uint16(xMatch),
-	/*3584*/ uint16(xSetOp), uint16(CMOVAE),
-	/*3586*/ uint16(xReadSlashR),
-	/*3587*/ uint16(xArgR32),
-	/*3588*/ uint16(xArgRM32),
-	/*3589*/ uint16(xMatch),
-	/*3590*/ uint16(xCondDataSize), 3578, 3584, 3594,
-	/*3594*/ uint16(xSetOp), uint16(CMOVAE),
-	/*3596*/ uint16(xReadSlashR),
-	/*3597*/ uint16(xArgR64),
-	/*3598*/ uint16(xArgRM64),
-	/*3599*/ uint16(xMatch),
-	/*3600*/ uint16(xCondIs64), 3603, 3619,
-	/*3603*/ uint16(xCondDataSize), 3607, 3613, 0,
-	/*3607*/ uint16(xSetOp), uint16(CMOVE),
-	/*3609*/ uint16(xReadSlashR),
-	/*3610*/ uint16(xArgR16),
-	/*3611*/ uint16(xArgRM16),
-	/*3612*/ uint16(xMatch),
-	/*3613*/ uint16(xSetOp), uint16(CMOVE),
-	/*3615*/ uint16(xReadSlashR),
-	/*3616*/ uint16(xArgR32),
-	/*3617*/ uint16(xArgRM32),
-	/*3618*/ uint16(xMatch),
-	/*3619*/ uint16(xCondDataSize), 3607, 3613, 3623,
-	/*3623*/ uint16(xSetOp), uint16(CMOVE),
-	/*3625*/ uint16(xReadSlashR),
-	/*3626*/ uint16(xArgR64),
-	/*3627*/ uint16(xArgRM64),
-	/*3628*/ uint16(xMatch),
-	/*3629*/ uint16(xCondIs64), 3632, 3648,
-	/*3632*/ uint16(xCondDataSize), 3636, 3642, 0,
-	/*3636*/ uint16(xSetOp), uint16(CMOVNE),
-	/*3638*/ uint16(xReadSlashR),
-	/*3639*/ uint16(xArgR16),
-	/*3640*/ uint16(xArgRM16),
-	/*3641*/ uint16(xMatch),
-	/*3642*/ uint16(xSetOp), uint16(CMOVNE),
-	/*3644*/ uint16(xReadSlashR),
-	/*3645*/ uint16(xArgR32),
-	/*3646*/ uint16(xArgRM32),
-	/*3647*/ uint16(xMatch),
-	/*3648*/ uint16(xCondDataSize), 3636, 3642, 3652,
-	/*3652*/ uint16(xSetOp), uint16(CMOVNE),
-	/*3654*/ uint16(xReadSlashR),
-	/*3655*/ uint16(xArgR64),
-	/*3656*/ uint16(xArgRM64),
-	/*3657*/ uint16(xMatch),
-	/*3658*/ uint16(xCondIs64), 3661, 3677,
-	/*3661*/ uint16(xCondDataSize), 3665, 3671, 0,
-	/*3665*/ uint16(xSetOp), uint16(CMOVBE),
-	/*3667*/ uint16(xReadSlashR),
-	/*3668*/ uint16(xArgR16),
-	/*3669*/ uint16(xArgRM16),
-	/*3670*/ uint16(xMatch),
-	/*3671*/ uint16(xSetOp), uint16(CMOVBE),
-	/*3673*/ uint16(xReadSlashR),
-	/*3674*/ uint16(xArgR32),
-	/*3675*/ uint16(xArgRM32),
-	/*3676*/ uint16(xMatch),
-	/*3677*/ uint16(xCondDataSize), 3665, 3671, 3681,
-	/*3681*/ uint16(xSetOp), uint16(CMOVBE),
-	/*3683*/ uint16(xReadSlashR),
-	/*3684*/ uint16(xArgR64),
-	/*3685*/ uint16(xArgRM64),
-	/*3686*/ uint16(xMatch),
-	/*3687*/ uint16(xCondIs64), 3690, 3706,
-	/*3690*/ uint16(xCondDataSize), 3694, 3700, 0,
-	/*3694*/ uint16(xSetOp), uint16(CMOVA),
-	/*3696*/ uint16(xReadSlashR),
-	/*3697*/ uint16(xArgR16),
-	/*3698*/ uint16(xArgRM16),
-	/*3699*/ uint16(xMatch),
-	/*3700*/ uint16(xSetOp), uint16(CMOVA),
-	/*3702*/ uint16(xReadSlashR),
-	/*3703*/ uint16(xArgR32),
-	/*3704*/ uint16(xArgRM32),
-	/*3705*/ uint16(xMatch),
-	/*3706*/ uint16(xCondDataSize), 3694, 3700, 3710,
-	/*3710*/ uint16(xSetOp), uint16(CMOVA),
-	/*3712*/ uint16(xReadSlashR),
-	/*3713*/ uint16(xArgR64),
-	/*3714*/ uint16(xArgRM64),
-	/*3715*/ uint16(xMatch),
-	/*3716*/ uint16(xCondIs64), 3719, 3735,
-	/*3719*/ uint16(xCondDataSize), 3723, 3729, 0,
-	/*3723*/ uint16(xSetOp), uint16(CMOVS),
-	/*3725*/ uint16(xReadSlashR),
-	/*3726*/ uint16(xArgR16),
-	/*3727*/ uint16(xArgRM16),
-	/*3728*/ uint16(xMatch),
-	/*3729*/ uint16(xSetOp), uint16(CMOVS),
-	/*3731*/ uint16(xReadSlashR),
-	/*3732*/ uint16(xArgR32),
-	/*3733*/ uint16(xArgRM32),
-	/*3734*/ uint16(xMatch),
-	/*3735*/ uint16(xCondDataSize), 3723, 3729, 3739,
-	/*3739*/ uint16(xSetOp), uint16(CMOVS),
-	/*3741*/ uint16(xReadSlashR),
-	/*3742*/ uint16(xArgR64),
-	/*3743*/ uint16(xArgRM64),
-	/*3744*/ uint16(xMatch),
-	/*3745*/ uint16(xCondIs64), 3748, 3764,
-	/*3748*/ uint16(xCondDataSize), 3752, 3758, 0,
-	/*3752*/ uint16(xSetOp), uint16(CMOVNS),
-	/*3754*/ uint16(xReadSlashR),
-	/*3755*/ uint16(xArgR16),
-	/*3756*/ uint16(xArgRM16),
-	/*3757*/ uint16(xMatch),
-	/*3758*/ uint16(xSetOp), uint16(CMOVNS),
-	/*3760*/ uint16(xReadSlashR),
-	/*3761*/ uint16(xArgR32),
-	/*3762*/ uint16(xArgRM32),
-	/*3763*/ uint16(xMatch),
-	/*3764*/ uint16(xCondDataSize), 3752, 3758, 3768,
-	/*3768*/ uint16(xSetOp), uint16(CMOVNS),
-	/*3770*/ uint16(xReadSlashR),
-	/*3771*/ uint16(xArgR64),
-	/*3772*/ uint16(xArgRM64),
-	/*3773*/ uint16(xMatch),
-	/*3774*/ uint16(xCondIs64), 3777, 3793,
-	/*3777*/ uint16(xCondDataSize), 3781, 3787, 0,
-	/*3781*/ uint16(xSetOp), uint16(CMOVP),
-	/*3783*/ uint16(xReadSlashR),
-	/*3784*/ uint16(xArgR16),
-	/*3785*/ uint16(xArgRM16),
-	/*3786*/ uint16(xMatch),
-	/*3787*/ uint16(xSetOp), uint16(CMOVP),
-	/*3789*/ uint16(xReadSlashR),
-	/*3790*/ uint16(xArgR32),
-	/*3791*/ uint16(xArgRM32),
-	/*3792*/ uint16(xMatch),
-	/*3793*/ uint16(xCondDataSize), 3781, 3787, 3797,
-	/*3797*/ uint16(xSetOp), uint16(CMOVP),
-	/*3799*/ uint16(xReadSlashR),
-	/*3800*/ uint16(xArgR64),
-	/*3801*/ uint16(xArgRM64),
-	/*3802*/ uint16(xMatch),
-	/*3803*/ uint16(xCondIs64), 3806, 3822,
-	/*3806*/ uint16(xCondDataSize), 3810, 3816, 0,
-	/*3810*/ uint16(xSetOp), uint16(CMOVNP),
-	/*3812*/ uint16(xReadSlashR),
-	/*3813*/ uint16(xArgR16),
-	/*3814*/ uint16(xArgRM16),
-	/*3815*/ uint16(xMatch),
-	/*3816*/ uint16(xSetOp), uint16(CMOVNP),
-	/*3818*/ uint16(xReadSlashR),
-	/*3819*/ uint16(xArgR32),
-	/*3820*/ uint16(xArgRM32),
-	/*3821*/ uint16(xMatch),
-	/*3822*/ uint16(xCondDataSize), 3810, 3816, 3826,
-	/*3826*/ uint16(xSetOp), uint16(CMOVNP),
-	/*3828*/ uint16(xReadSlashR),
-	/*3829*/ uint16(xArgR64),
-	/*3830*/ uint16(xArgRM64),
-	/*3831*/ uint16(xMatch),
-	/*3832*/ uint16(xCondIs64), 3835, 3851,
-	/*3835*/ uint16(xCondDataSize), 3839, 3845, 0,
-	/*3839*/ uint16(xSetOp), uint16(CMOVL),
-	/*3841*/ uint16(xReadSlashR),
-	/*3842*/ uint16(xArgR16),
-	/*3843*/ uint16(xArgRM16),
-	/*3844*/ uint16(xMatch),
-	/*3845*/ uint16(xSetOp), uint16(CMOVL),
-	/*3847*/ uint16(xReadSlashR),
-	/*3848*/ uint16(xArgR32),
-	/*3849*/ uint16(xArgRM32),
-	/*3850*/ uint16(xMatch),
-	/*3851*/ uint16(xCondDataSize), 3839, 3845, 3855,
-	/*3855*/ uint16(xSetOp), uint16(CMOVL),
-	/*3857*/ uint16(xReadSlashR),
-	/*3858*/ uint16(xArgR64),
-	/*3859*/ uint16(xArgRM64),
-	/*3860*/ uint16(xMatch),
-	/*3861*/ uint16(xCondIs64), 3864, 3880,
-	/*3864*/ uint16(xCondDataSize), 3868, 3874, 0,
-	/*3868*/ uint16(xSetOp), uint16(CMOVGE),
-	/*3870*/ uint16(xReadSlashR),
-	/*3871*/ uint16(xArgR16),
-	/*3872*/ uint16(xArgRM16),
-	/*3873*/ uint16(xMatch),
-	/*3874*/ uint16(xSetOp), uint16(CMOVGE),
-	/*3876*/ uint16(xReadSlashR),
-	/*3877*/ uint16(xArgR32),
-	/*3878*/ uint16(xArgRM32),
-	/*3879*/ uint16(xMatch),
-	/*3880*/ uint16(xCondDataSize), 3868, 3874, 3884,
-	/*3884*/ uint16(xSetOp), uint16(CMOVGE),
-	/*3886*/ uint16(xReadSlashR),
-	/*3887*/ uint16(xArgR64),
-	/*3888*/ uint16(xArgRM64),
-	/*3889*/ uint16(xMatch),
-	/*3890*/ uint16(xCondIs64), 3893, 3909,
-	/*3893*/ uint16(xCondDataSize), 3897, 3903, 0,
-	/*3897*/ uint16(xSetOp), uint16(CMOVLE),
-	/*3899*/ uint16(xReadSlashR),
-	/*3900*/ uint16(xArgR16),
-	/*3901*/ uint16(xArgRM16),
-	/*3902*/ uint16(xMatch),
-	/*3903*/ uint16(xSetOp), uint16(CMOVLE),
-	/*3905*/ uint16(xReadSlashR),
-	/*3906*/ uint16(xArgR32),
-	/*3907*/ uint16(xArgRM32),
-	/*3908*/ uint16(xMatch),
-	/*3909*/ uint16(xCondDataSize), 3897, 3903, 3913,
-	/*3913*/ uint16(xSetOp), uint16(CMOVLE),
-	/*3915*/ uint16(xReadSlashR),
-	/*3916*/ uint16(xArgR64),
-	/*3917*/ uint16(xArgRM64),
-	/*3918*/ uint16(xMatch),
-	/*3919*/ uint16(xCondIs64), 3922, 3938,
-	/*3922*/ uint16(xCondDataSize), 3926, 3932, 0,
-	/*3926*/ uint16(xSetOp), uint16(CMOVG),
-	/*3928*/ uint16(xReadSlashR),
-	/*3929*/ uint16(xArgR16),
-	/*3930*/ uint16(xArgRM16),
-	/*3931*/ uint16(xMatch),
-	/*3932*/ uint16(xSetOp), uint16(CMOVG),
-	/*3934*/ uint16(xReadSlashR),
-	/*3935*/ uint16(xArgR32),
-	/*3936*/ uint16(xArgRM32),
-	/*3937*/ uint16(xMatch),
-	/*3938*/ uint16(xCondDataSize), 3926, 3932, 3942,
-	/*3942*/ uint16(xSetOp), uint16(CMOVG),
-	/*3944*/ uint16(xReadSlashR),
-	/*3945*/ uint16(xArgR64),
-	/*3946*/ uint16(xArgRM64),
-	/*3947*/ uint16(xMatch),
-	/*3948*/ uint16(xCondPrefix), 2,
-	0x66, 3960,
-	0x0, 3954,
-	/*3954*/ uint16(xSetOp), uint16(MOVMSKPS),
-	/*3956*/ uint16(xReadSlashR),
-	/*3957*/ uint16(xArgR32),
-	/*3958*/ uint16(xArgXmm2),
-	/*3959*/ uint16(xMatch),
-	/*3960*/ uint16(xSetOp), uint16(MOVMSKPD),
-	/*3962*/ uint16(xReadSlashR),
-	/*3963*/ uint16(xArgR32),
-	/*3964*/ uint16(xArgXmm2),
-	/*3965*/ uint16(xMatch),
-	/*3966*/ uint16(xCondPrefix), 4,
-	0xF3, 3994,
-	0xF2, 3988,
-	0x66, 3982,
-	0x0, 3976,
-	/*3976*/ uint16(xSetOp), uint16(SQRTPS),
-	/*3978*/ uint16(xReadSlashR),
-	/*3979*/ uint16(xArgXmm1),
-	/*3980*/ uint16(xArgXmm2M128),
-	/*3981*/ uint16(xMatch),
-	/*3982*/ uint16(xSetOp), uint16(SQRTPD),
-	/*3984*/ uint16(xReadSlashR),
-	/*3985*/ uint16(xArgXmm1),
-	/*3986*/ uint16(xArgXmm2M128),
-	/*3987*/ uint16(xMatch),
-	/*3988*/ uint16(xSetOp), uint16(SQRTSD),
-	/*3990*/ uint16(xReadSlashR),
-	/*3991*/ uint16(xArgXmm1),
-	/*3992*/ uint16(xArgXmm2M64),
-	/*3993*/ uint16(xMatch),
-	/*3994*/ uint16(xSetOp), uint16(SQRTSS),
-	/*3996*/ uint16(xReadSlashR),
-	/*3997*/ uint16(xArgXmm1),
-	/*3998*/ uint16(xArgXmm2M32),
-	/*3999*/ uint16(xMatch),
-	/*4000*/ uint16(xCondPrefix), 2,
-	0xF3, 4012,
-	0x0, 4006,
-	/*4006*/ uint16(xSetOp), uint16(RSQRTPS),
-	/*4008*/ uint16(xReadSlashR),
-	/*4009*/ uint16(xArgXmm1),
-	/*4010*/ uint16(xArgXmm2M128),
-	/*4011*/ uint16(xMatch),
-	/*4012*/ uint16(xSetOp), uint16(RSQRTSS),
-	/*4014*/ uint16(xReadSlashR),
-	/*4015*/ uint16(xArgXmm1),
-	/*4016*/ uint16(xArgXmm2M32),
-	/*4017*/ uint16(xMatch),
-	/*4018*/ uint16(xCondPrefix), 2,
-	0xF3, 4030,
-	0x0, 4024,
-	/*4024*/ uint16(xSetOp), uint16(RCPPS),
-	/*4026*/ uint16(xReadSlashR),
-	/*4027*/ uint16(xArgXmm1),
-	/*4028*/ uint16(xArgXmm2M128),
-	/*4029*/ uint16(xMatch),
-	/*4030*/ uint16(xSetOp), uint16(RCPSS),
-	/*4032*/ uint16(xReadSlashR),
-	/*4033*/ uint16(xArgXmm1),
-	/*4034*/ uint16(xArgXmm2M32),
-	/*4035*/ uint16(xMatch),
-	/*4036*/ uint16(xCondPrefix), 2,
-	0x66, 4048,
-	0x0, 4042,
-	/*4042*/ uint16(xSetOp), uint16(ANDPS),
-	/*4044*/ uint16(xReadSlashR),
-	/*4045*/ uint16(xArgXmm1),
-	/*4046*/ uint16(xArgXmm2M128),
-	/*4047*/ uint16(xMatch),
-	/*4048*/ uint16(xSetOp), uint16(ANDPD),
-	/*4050*/ uint16(xReadSlashR),
-	/*4051*/ uint16(xArgXmm1),
-	/*4052*/ uint16(xArgXmm2M128),
-	/*4053*/ uint16(xMatch),
-	/*4054*/ uint16(xCondPrefix), 2,
-	0x66, 4066,
-	0x0, 4060,
-	/*4060*/ uint16(xSetOp), uint16(ANDNPS),
-	/*4062*/ uint16(xReadSlashR),
-	/*4063*/ uint16(xArgXmm1),
-	/*4064*/ uint16(xArgXmm2M128),
-	/*4065*/ uint16(xMatch),
-	/*4066*/ uint16(xSetOp), uint16(ANDNPD),
-	/*4068*/ uint16(xReadSlashR),
-	/*4069*/ uint16(xArgXmm1),
-	/*4070*/ uint16(xArgXmm2M128),
-	/*4071*/ uint16(xMatch),
-	/*4072*/ uint16(xCondPrefix), 2,
-	0x66, 4084,
-	0x0, 4078,
-	/*4078*/ uint16(xSetOp), uint16(ORPS),
-	/*4080*/ uint16(xReadSlashR),
-	/*4081*/ uint16(xArgXmm1),
-	/*4082*/ uint16(xArgXmm2M128),
-	/*4083*/ uint16(xMatch),
-	/*4084*/ uint16(xSetOp), uint16(ORPD),
-	/*4086*/ uint16(xReadSlashR),
-	/*4087*/ uint16(xArgXmm1),
-	/*4088*/ uint16(xArgXmm2M128),
-	/*4089*/ uint16(xMatch),
-	/*4090*/ uint16(xCondPrefix), 2,
-	0x66, 4102,
-	0x0, 4096,
-	/*4096*/ uint16(xSetOp), uint16(XORPS),
-	/*4098*/ uint16(xReadSlashR),
-	/*4099*/ uint16(xArgXmm1),
-	/*4100*/ uint16(xArgXmm2M128),
-	/*4101*/ uint16(xMatch),
-	/*4102*/ uint16(xSetOp), uint16(XORPD),
-	/*4104*/ uint16(xReadSlashR),
-	/*4105*/ uint16(xArgXmm1),
-	/*4106*/ uint16(xArgXmm2M128),
-	/*4107*/ uint16(xMatch),
-	/*4108*/ uint16(xCondPrefix), 4,
-	0xF3, 4136,
-	0xF2, 4130,
-	0x66, 4124,
-	0x0, 4118,
-	/*4118*/ uint16(xSetOp), uint16(ADDPS),
-	/*4120*/ uint16(xReadSlashR),
-	/*4121*/ uint16(xArgXmm1),
-	/*4122*/ uint16(xArgXmm2M128),
-	/*4123*/ uint16(xMatch),
-	/*4124*/ uint16(xSetOp), uint16(ADDPD),
-	/*4126*/ uint16(xReadSlashR),
-	/*4127*/ uint16(xArgXmm1),
-	/*4128*/ uint16(xArgXmm2M128),
-	/*4129*/ uint16(xMatch),
-	/*4130*/ uint16(xSetOp), uint16(ADDSD),
-	/*4132*/ uint16(xReadSlashR),
-	/*4133*/ uint16(xArgXmm1),
-	/*4134*/ uint16(xArgXmm2M64),
-	/*4135*/ uint16(xMatch),
-	/*4136*/ uint16(xSetOp), uint16(ADDSS),
-	/*4138*/ uint16(xReadSlashR),
-	/*4139*/ uint16(xArgXmm1),
-	/*4140*/ uint16(xArgXmm2M32),
-	/*4141*/ uint16(xMatch),
-	/*4142*/ uint16(xCondPrefix), 4,
-	0xF3, 4170,
-	0xF2, 4164,
-	0x66, 4158,
-	0x0, 4152,
-	/*4152*/ uint16(xSetOp), uint16(MULPS),
-	/*4154*/ uint16(xReadSlashR),
-	/*4155*/ uint16(xArgXmm1),
-	/*4156*/ uint16(xArgXmm2M128),
-	/*4157*/ uint16(xMatch),
-	/*4158*/ uint16(xSetOp), uint16(MULPD),
-	/*4160*/ uint16(xReadSlashR),
-	/*4161*/ uint16(xArgXmm1),
-	/*4162*/ uint16(xArgXmm2M128),
-	/*4163*/ uint16(xMatch),
-	/*4164*/ uint16(xSetOp), uint16(MULSD),
-	/*4166*/ uint16(xReadSlashR),
-	/*4167*/ uint16(xArgXmm1),
-	/*4168*/ uint16(xArgXmm2M64),
-	/*4169*/ uint16(xMatch),
-	/*4170*/ uint16(xSetOp), uint16(MULSS),
-	/*4172*/ uint16(xReadSlashR),
-	/*4173*/ uint16(xArgXmm1),
-	/*4174*/ uint16(xArgXmm2M32),
-	/*4175*/ uint16(xMatch),
-	/*4176*/ uint16(xCondPrefix), 4,
-	0xF3, 4204,
-	0xF2, 4198,
-	0x66, 4192,
-	0x0, 4186,
-	/*4186*/ uint16(xSetOp), uint16(CVTPS2PD),
-	/*4188*/ uint16(xReadSlashR),
-	/*4189*/ uint16(xArgXmm1),
-	/*4190*/ uint16(xArgXmm2M64),
-	/*4191*/ uint16(xMatch),
-	/*4192*/ uint16(xSetOp), uint16(CVTPD2PS),
-	/*4194*/ uint16(xReadSlashR),
-	/*4195*/ uint16(xArgXmm1),
-	/*4196*/ uint16(xArgXmm2M128),
-	/*4197*/ uint16(xMatch),
-	/*4198*/ uint16(xSetOp), uint16(CVTSD2SS),
-	/*4200*/ uint16(xReadSlashR),
-	/*4201*/ uint16(xArgXmm1),
-	/*4202*/ uint16(xArgXmm2M64),
-	/*4203*/ uint16(xMatch),
-	/*4204*/ uint16(xSetOp), uint16(CVTSS2SD),
-	/*4206*/ uint16(xReadSlashR),
-	/*4207*/ uint16(xArgXmm1),
-	/*4208*/ uint16(xArgXmm2M32),
-	/*4209*/ uint16(xMatch),
-	/*4210*/ uint16(xCondPrefix), 3,
-	0xF3, 4230,
-	0x66, 4224,
-	0x0, 4218,
-	/*4218*/ uint16(xSetOp), uint16(CVTDQ2PS),
-	/*4220*/ uint16(xReadSlashR),
-	/*4221*/ uint16(xArgXmm1),
-	/*4222*/ uint16(xArgXmm2M128),
-	/*4223*/ uint16(xMatch),
-	/*4224*/ uint16(xSetOp), uint16(CVTPS2DQ),
-	/*4226*/ uint16(xReadSlashR),
-	/*4227*/ uint16(xArgXmm1),
-	/*4228*/ uint16(xArgXmm2M128),
-	/*4229*/ uint16(xMatch),
-	/*4230*/ uint16(xSetOp), uint16(CVTTPS2DQ),
-	/*4232*/ uint16(xReadSlashR),
-	/*4233*/ uint16(xArgXmm1),
-	/*4234*/ uint16(xArgXmm2M128),
-	/*4235*/ uint16(xMatch),
-	/*4236*/ uint16(xCondPrefix), 4,
-	0xF3, 4264,
-	0xF2, 4258,
-	0x66, 4252,
-	0x0, 4246,
-	/*4246*/ uint16(xSetOp), uint16(SUBPS),
-	/*4248*/ uint16(xReadSlashR),
-	/*4249*/ uint16(xArgXmm1),
-	/*4250*/ uint16(xArgXmm2M128),
-	/*4251*/ uint16(xMatch),
-	/*4252*/ uint16(xSetOp), uint16(SUBPD),
-	/*4254*/ uint16(xReadSlashR),
-	/*4255*/ uint16(xArgXmm1),
-	/*4256*/ uint16(xArgXmm2M128),
-	/*4257*/ uint16(xMatch),
-	/*4258*/ uint16(xSetOp), uint16(SUBSD),
-	/*4260*/ uint16(xReadSlashR),
-	/*4261*/ uint16(xArgXmm1),
-	/*4262*/ uint16(xArgXmm2M64),
-	/*4263*/ uint16(xMatch),
-	/*4264*/ uint16(xSetOp), uint16(SUBSS),
-	/*4266*/ uint16(xReadSlashR),
-	/*4267*/ uint16(xArgXmm1),
-	/*4268*/ uint16(xArgXmm2M32),
-	/*4269*/ uint16(xMatch),
-	/*4270*/ uint16(xCondPrefix), 4,
-	0xF3, 4298,
-	0xF2, 4292,
-	0x66, 4286,
-	0x0, 4280,
-	/*4280*/ uint16(xSetOp), uint16(MINPS),
-	/*4282*/ uint16(xReadSlashR),
-	/*4283*/ uint16(xArgXmm1),
-	/*4284*/ uint16(xArgXmm2M128),
-	/*4285*/ uint16(xMatch),
-	/*4286*/ uint16(xSetOp), uint16(MINPD),
-	/*4288*/ uint16(xReadSlashR),
-	/*4289*/ uint16(xArgXmm1),
-	/*4290*/ uint16(xArgXmm2M128),
-	/*4291*/ uint16(xMatch),
-	/*4292*/ uint16(xSetOp), uint16(MINSD),
-	/*4294*/ uint16(xReadSlashR),
-	/*4295*/ uint16(xArgXmm1),
-	/*4296*/ uint16(xArgXmm2M64),
-	/*4297*/ uint16(xMatch),
-	/*4298*/ uint16(xSetOp), uint16(MINSS),
-	/*4300*/ uint16(xReadSlashR),
-	/*4301*/ uint16(xArgXmm1),
-	/*4302*/ uint16(xArgXmm2M32),
-	/*4303*/ uint16(xMatch),
-	/*4304*/ uint16(xCondPrefix), 4,
-	0xF3, 4332,
-	0xF2, 4326,
-	0x66, 4320,
-	0x0, 4314,
-	/*4314*/ uint16(xSetOp), uint16(DIVPS),
-	/*4316*/ uint16(xReadSlashR),
-	/*4317*/ uint16(xArgXmm1),
-	/*4318*/ uint16(xArgXmm2M128),
-	/*4319*/ uint16(xMatch),
-	/*4320*/ uint16(xSetOp), uint16(DIVPD),
-	/*4322*/ uint16(xReadSlashR),
-	/*4323*/ uint16(xArgXmm1),
-	/*4324*/ uint16(xArgXmm2M128),
-	/*4325*/ uint16(xMatch),
-	/*4326*/ uint16(xSetOp), uint16(DIVSD),
-	/*4328*/ uint16(xReadSlashR),
-	/*4329*/ uint16(xArgXmm1),
-	/*4330*/ uint16(xArgXmm2M64),
-	/*4331*/ uint16(xMatch),
-	/*4332*/ uint16(xSetOp), uint16(DIVSS),
-	/*4334*/ uint16(xReadSlashR),
-	/*4335*/ uint16(xArgXmm1),
-	/*4336*/ uint16(xArgXmm2M32),
-	/*4337*/ uint16(xMatch),
-	/*4338*/ uint16(xCondPrefix), 4,
-	0xF3, 4366,
-	0xF2, 4360,
-	0x66, 4354,
-	0x0, 4348,
-	/*4348*/ uint16(xSetOp), uint16(MAXPS),
-	/*4350*/ uint16(xReadSlashR),
-	/*4351*/ uint16(xArgXmm1),
-	/*4352*/ uint16(xArgXmm2M128),
-	/*4353*/ uint16(xMatch),
-	/*4354*/ uint16(xSetOp), uint16(MAXPD),
-	/*4356*/ uint16(xReadSlashR),
-	/*4357*/ uint16(xArgXmm1),
-	/*4358*/ uint16(xArgXmm2M128),
-	/*4359*/ uint16(xMatch),
-	/*4360*/ uint16(xSetOp), uint16(MAXSD),
-	/*4362*/ uint16(xReadSlashR),
-	/*4363*/ uint16(xArgXmm1),
-	/*4364*/ uint16(xArgXmm2M64),
-	/*4365*/ uint16(xMatch),
-	/*4366*/ uint16(xSetOp), uint16(MAXSS),
-	/*4368*/ uint16(xReadSlashR),
-	/*4369*/ uint16(xArgXmm1),
-	/*4370*/ uint16(xArgXmm2M32),
-	/*4371*/ uint16(xMatch),
-	/*4372*/ uint16(xCondPrefix), 2,
-	0x66, 4384,
-	0x0, 4378,
-	/*4378*/ uint16(xSetOp), uint16(PUNPCKLBW),
-	/*4380*/ uint16(xReadSlashR),
-	/*4381*/ uint16(xArgMm),
-	/*4382*/ uint16(xArgMmM32),
-	/*4383*/ uint16(xMatch),
-	/*4384*/ uint16(xSetOp), uint16(PUNPCKLBW),
-	/*4386*/ uint16(xReadSlashR),
-	/*4387*/ uint16(xArgXmm1),
-	/*4388*/ uint16(xArgXmm2M128),
-	/*4389*/ uint16(xMatch),
-	/*4390*/ uint16(xCondPrefix), 2,
-	0x66, 4402,
-	0x0, 4396,
-	/*4396*/ uint16(xSetOp), uint16(PUNPCKLWD),
-	/*4398*/ uint16(xReadSlashR),
-	/*4399*/ uint16(xArgMm),
-	/*4400*/ uint16(xArgMmM32),
-	/*4401*/ uint16(xMatch),
-	/*4402*/ uint16(xSetOp), uint16(PUNPCKLWD),
-	/*4404*/ uint16(xReadSlashR),
-	/*4405*/ uint16(xArgXmm1),
-	/*4406*/ uint16(xArgXmm2M128),
-	/*4407*/ uint16(xMatch),
-	/*4408*/ uint16(xCondPrefix), 2,
-	0x66, 4420,
-	0x0, 4414,
-	/*4414*/ uint16(xSetOp), uint16(PUNPCKLDQ),
-	/*4416*/ uint16(xReadSlashR),
-	/*4417*/ uint16(xArgMm),
-	/*4418*/ uint16(xArgMmM32),
-	/*4419*/ uint16(xMatch),
-	/*4420*/ uint16(xSetOp), uint16(PUNPCKLDQ),
-	/*4422*/ uint16(xReadSlashR),
-	/*4423*/ uint16(xArgXmm1),
-	/*4424*/ uint16(xArgXmm2M128),
-	/*4425*/ uint16(xMatch),
-	/*4426*/ uint16(xCondPrefix), 2,
-	0x66, 4438,
-	0x0, 4432,
-	/*4432*/ uint16(xSetOp), uint16(PACKSSWB),
-	/*4434*/ uint16(xReadSlashR),
-	/*4435*/ uint16(xArgMm1),
-	/*4436*/ uint16(xArgMm2M64),
-	/*4437*/ uint16(xMatch),
-	/*4438*/ uint16(xSetOp), uint16(PACKSSWB),
-	/*4440*/ uint16(xReadSlashR),
-	/*4441*/ uint16(xArgXmm1),
-	/*4442*/ uint16(xArgXmm2M128),
-	/*4443*/ uint16(xMatch),
-	/*4444*/ uint16(xCondPrefix), 2,
-	0x66, 4456,
-	0x0, 4450,
-	/*4450*/ uint16(xSetOp), uint16(PCMPGTB),
-	/*4452*/ uint16(xReadSlashR),
-	/*4453*/ uint16(xArgMm),
-	/*4454*/ uint16(xArgMmM64),
-	/*4455*/ uint16(xMatch),
-	/*4456*/ uint16(xSetOp), uint16(PCMPGTB),
-	/*4458*/ uint16(xReadSlashR),
-	/*4459*/ uint16(xArgXmm1),
-	/*4460*/ uint16(xArgXmm2M128),
-	/*4461*/ uint16(xMatch),
-	/*4462*/ uint16(xCondPrefix), 2,
-	0x66, 4474,
-	0x0, 4468,
-	/*4468*/ uint16(xSetOp), uint16(PCMPGTW),
-	/*4470*/ uint16(xReadSlashR),
-	/*4471*/ uint16(xArgMm),
-	/*4472*/ uint16(xArgMmM64),
-	/*4473*/ uint16(xMatch),
-	/*4474*/ uint16(xSetOp), uint16(PCMPGTW),
-	/*4476*/ uint16(xReadSlashR),
-	/*4477*/ uint16(xArgXmm1),
-	/*4478*/ uint16(xArgXmm2M128),
-	/*4479*/ uint16(xMatch),
-	/*4480*/ uint16(xCondPrefix), 2,
-	0x66, 4492,
-	0x0, 4486,
-	/*4486*/ uint16(xSetOp), uint16(PCMPGTD),
-	/*4488*/ uint16(xReadSlashR),
-	/*4489*/ uint16(xArgMm),
-	/*4490*/ uint16(xArgMmM64),
-	/*4491*/ uint16(xMatch),
-	/*4492*/ uint16(xSetOp), uint16(PCMPGTD),
-	/*4494*/ uint16(xReadSlashR),
-	/*4495*/ uint16(xArgXmm1),
-	/*4496*/ uint16(xArgXmm2M128),
-	/*4497*/ uint16(xMatch),
-	/*4498*/ uint16(xCondPrefix), 2,
-	0x66, 4510,
-	0x0, 4504,
-	/*4504*/ uint16(xSetOp), uint16(PACKUSWB),
-	/*4506*/ uint16(xReadSlashR),
-	/*4507*/ uint16(xArgMm),
-	/*4508*/ uint16(xArgMmM64),
-	/*4509*/ uint16(xMatch),
-	/*4510*/ uint16(xSetOp), uint16(PACKUSWB),
-	/*4512*/ uint16(xReadSlashR),
-	/*4513*/ uint16(xArgXmm1),
-	/*4514*/ uint16(xArgXmm2M128),
-	/*4515*/ uint16(xMatch),
-	/*4516*/ uint16(xCondPrefix), 2,
-	0x66, 4528,
-	0x0, 4522,
-	/*4522*/ uint16(xSetOp), uint16(PUNPCKHBW),
-	/*4524*/ uint16(xReadSlashR),
-	/*4525*/ uint16(xArgMm),
-	/*4526*/ uint16(xArgMmM64),
-	/*4527*/ uint16(xMatch),
-	/*4528*/ uint16(xSetOp), uint16(PUNPCKHBW),
-	/*4530*/ uint16(xReadSlashR),
-	/*4531*/ uint16(xArgXmm1),
-	/*4532*/ uint16(xArgXmm2M128),
-	/*4533*/ uint16(xMatch),
-	/*4534*/ uint16(xCondPrefix), 2,
-	0x66, 4546,
-	0x0, 4540,
-	/*4540*/ uint16(xSetOp), uint16(PUNPCKHWD),
-	/*4542*/ uint16(xReadSlashR),
-	/*4543*/ uint16(xArgMm),
-	/*4544*/ uint16(xArgMmM64),
-	/*4545*/ uint16(xMatch),
-	/*4546*/ uint16(xSetOp), uint16(PUNPCKHWD),
-	/*4548*/ uint16(xReadSlashR),
-	/*4549*/ uint16(xArgXmm1),
-	/*4550*/ uint16(xArgXmm2M128),
-	/*4551*/ uint16(xMatch),
-	/*4552*/ uint16(xCondPrefix), 2,
-	0x66, 4564,
-	0x0, 4558,
-	/*4558*/ uint16(xSetOp), uint16(PUNPCKHDQ),
-	/*4560*/ uint16(xReadSlashR),
-	/*4561*/ uint16(xArgMm),
-	/*4562*/ uint16(xArgMmM64),
-	/*4563*/ uint16(xMatch),
-	/*4564*/ uint16(xSetOp), uint16(PUNPCKHDQ),
-	/*4566*/ uint16(xReadSlashR),
-	/*4567*/ uint16(xArgXmm1),
-	/*4568*/ uint16(xArgXmm2M128),
-	/*4569*/ uint16(xMatch),
-	/*4570*/ uint16(xCondPrefix), 2,
-	0x66, 4582,
-	0x0, 4576,
-	/*4576*/ uint16(xSetOp), uint16(PACKSSDW),
-	/*4578*/ uint16(xReadSlashR),
-	/*4579*/ uint16(xArgMm1),
-	/*4580*/ uint16(xArgMm2M64),
-	/*4581*/ uint16(xMatch),
-	/*4582*/ uint16(xSetOp), uint16(PACKSSDW),
-	/*4584*/ uint16(xReadSlashR),
-	/*4585*/ uint16(xArgXmm1),
-	/*4586*/ uint16(xArgXmm2M128),
-	/*4587*/ uint16(xMatch),
-	/*4588*/ uint16(xCondPrefix), 1,
-	0x66, 4592,
-	/*4592*/ uint16(xSetOp), uint16(PUNPCKLQDQ),
-	/*4594*/ uint16(xReadSlashR),
-	/*4595*/ uint16(xArgXmm1),
-	/*4596*/ uint16(xArgXmm2M128),
-	/*4597*/ uint16(xMatch),
-	/*4598*/ uint16(xCondPrefix), 1,
-	0x66, 4602,
-	/*4602*/ uint16(xSetOp), uint16(PUNPCKHQDQ),
-	/*4604*/ uint16(xReadSlashR),
-	/*4605*/ uint16(xArgXmm1),
-	/*4606*/ uint16(xArgXmm2M128),
-	/*4607*/ uint16(xMatch),
-	/*4608*/ uint16(xCondIs64), 4611, 4649,
-	/*4611*/ uint16(xCondPrefix), 2,
-	0x66, 4633,
-	0x0, 4617,
-	/*4617*/ uint16(xCondDataSize), 4621, 4627, 0,
-	/*4621*/ uint16(xSetOp), uint16(MOVD),
-	/*4623*/ uint16(xReadSlashR),
-	/*4624*/ uint16(xArgMm),
-	/*4625*/ uint16(xArgRM32),
-	/*4626*/ uint16(xMatch),
-	/*4627*/ uint16(xSetOp), uint16(MOVD),
-	/*4629*/ uint16(xReadSlashR),
-	/*4630*/ uint16(xArgMm),
-	/*4631*/ uint16(xArgRM32),
-	/*4632*/ uint16(xMatch),
-	/*4633*/ uint16(xCondDataSize), 4637, 4643, 0,
-	/*4637*/ uint16(xSetOp), uint16(MOVD),
-	/*4639*/ uint16(xReadSlashR),
-	/*4640*/ uint16(xArgXmm),
-	/*4641*/ uint16(xArgRM32),
-	/*4642*/ uint16(xMatch),
-	/*4643*/ uint16(xSetOp), uint16(MOVD),
-	/*4645*/ uint16(xReadSlashR),
-	/*4646*/ uint16(xArgXmm),
-	/*4647*/ uint16(xArgRM32),
-	/*4648*/ uint16(xMatch),
-	/*4649*/ uint16(xCondPrefix), 2,
-	0x66, 4665,
-	0x0, 4655,
-	/*4655*/ uint16(xCondDataSize), 4621, 4627, 4659,
-	/*4659*/ uint16(xSetOp), uint16(MOVQ),
-	/*4661*/ uint16(xReadSlashR),
-	/*4662*/ uint16(xArgMm),
-	/*4663*/ uint16(xArgRM64),
-	/*4664*/ uint16(xMatch),
-	/*4665*/ uint16(xCondDataSize), 4637, 4643, 4669,
-	/*4669*/ uint16(xSetOp), uint16(MOVQ),
-	/*4671*/ uint16(xReadSlashR),
-	/*4672*/ uint16(xArgXmm),
-	/*4673*/ uint16(xArgRM64),
-	/*4674*/ uint16(xMatch),
-	/*4675*/ uint16(xCondPrefix), 3,
-	0xF3, 4695,
-	0x66, 4689,
-	0x0, 4683,
-	/*4683*/ uint16(xSetOp), uint16(MOVQ),
-	/*4685*/ uint16(xReadSlashR),
-	/*4686*/ uint16(xArgMm),
-	/*4687*/ uint16(xArgMmM64),
-	/*4688*/ uint16(xMatch),
-	/*4689*/ uint16(xSetOp), uint16(MOVDQA),
-	/*4691*/ uint16(xReadSlashR),
-	/*4692*/ uint16(xArgXmm1),
-	/*4693*/ uint16(xArgXmm2M128),
-	/*4694*/ uint16(xMatch),
-	/*4695*/ uint16(xSetOp), uint16(MOVDQU),
-	/*4697*/ uint16(xReadSlashR),
-	/*4698*/ uint16(xArgXmm1),
-	/*4699*/ uint16(xArgXmm2M128),
-	/*4700*/ uint16(xMatch),
-	/*4701*/ uint16(xCondPrefix), 4,
-	0xF3, 4735,
-	0xF2, 4727,
-	0x66, 4719,
-	0x0, 4711,
-	/*4711*/ uint16(xSetOp), uint16(PSHUFW),
-	/*4713*/ uint16(xReadSlashR),
-	/*4714*/ uint16(xReadIb),
-	/*4715*/ uint16(xArgMm1),
-	/*4716*/ uint16(xArgMm2M64),
-	/*4717*/ uint16(xArgImm8u),
-	/*4718*/ uint16(xMatch),
-	/*4719*/ uint16(xSetOp), uint16(PSHUFD),
-	/*4721*/ uint16(xReadSlashR),
-	/*4722*/ uint16(xReadIb),
-	/*4723*/ uint16(xArgXmm1),
-	/*4724*/ uint16(xArgXmm2M128),
-	/*4725*/ uint16(xArgImm8u),
-	/*4726*/ uint16(xMatch),
-	/*4727*/ uint16(xSetOp), uint16(PSHUFLW),
-	/*4729*/ uint16(xReadSlashR),
-	/*4730*/ uint16(xReadIb),
-	/*4731*/ uint16(xArgXmm1),
-	/*4732*/ uint16(xArgXmm2M128),
-	/*4733*/ uint16(xArgImm8u),
-	/*4734*/ uint16(xMatch),
-	/*4735*/ uint16(xSetOp), uint16(PSHUFHW),
-	/*4737*/ uint16(xReadSlashR),
-	/*4738*/ uint16(xReadIb),
-	/*4739*/ uint16(xArgXmm1),
-	/*4740*/ uint16(xArgXmm2M128),
-	/*4741*/ uint16(xArgImm8u),
-	/*4742*/ uint16(xMatch),
-	/*4743*/ uint16(xCondSlashR),
+	/*3126*/ uint16(xCondPrefix), 1,
+	0x66, 3130,
+	/*3130*/ uint16(xSetOp), uint16(ROUNDPS),
+	/*3132*/ uint16(xReadSlashR),
+	/*3133*/ uint16(xReadIb),
+	/*3134*/ uint16(xArgXmm1),
+	/*3135*/ uint16(xArgXmm2M128),
+	/*3136*/ uint16(xArgImm8u),
+	/*3137*/ uint16(xMatch),
+	/*3138*/ uint16(xCondPrefix), 1,
+	0x66, 3142,
+	/*3142*/ uint16(xSetOp), uint16(ROUNDPD),
+	/*3144*/ uint16(xReadSlashR),
+	/*3145*/ uint16(xReadIb),
+	/*3146*/ uint16(xArgXmm1),
+	/*3147*/ uint16(xArgXmm2M128),
+	/*3148*/ uint16(xArgImm8u),
+	/*3149*/ uint16(xMatch),
+	/*3150*/ uint16(xCondPrefix), 1,
+	0x66, 3154,
+	/*3154*/ uint16(xSetOp), uint16(ROUNDSS),
+	/*3156*/ uint16(xReadSlashR),
+	/*3157*/ uint16(xReadIb),
+	/*3158*/ uint16(xArgXmm1),
+	/*3159*/ uint16(xArgXmm2M32),
+	/*3160*/ uint16(xArgImm8u),
+	/*3161*/ uint16(xMatch),
+	/*3162*/ uint16(xCondPrefix), 1,
+	0x66, 3166,
+	/*3166*/ uint16(xSetOp), uint16(ROUNDSD),
+	/*3168*/ uint16(xReadSlashR),
+	/*3169*/ uint16(xReadIb),
+	/*3170*/ uint16(xArgXmm1),
+	/*3171*/ uint16(xArgXmm2M64),
+	/*3172*/ uint16(xArgImm8u),
+	/*3173*/ uint16(xMatch),
+	/*3174*/ uint16(xCondPrefix), 1,
+	0x66, 3178,
+	/*3178*/ uint16(xSetOp), uint16(BLENDPS),
+	/*3180*/ uint16(xReadSlashR),
+	/*3181*/ uint16(xReadIb),
+	/*3182*/ uint16(xArgXmm1),
+	/*3183*/ uint16(xArgXmm2M128),
+	/*3184*/ uint16(xArgImm8u),
+	/*3185*/ uint16(xMatch),
+	/*3186*/ uint16(xCondPrefix), 1,
+	0x66, 3190,
+	/*3190*/ uint16(xSetOp), uint16(BLENDPD),
+	/*3192*/ uint16(xReadSlashR),
+	/*3193*/ uint16(xReadIb),
+	/*3194*/ uint16(xArgXmm1),
+	/*3195*/ uint16(xArgXmm2M128),
+	/*3196*/ uint16(xArgImm8u),
+	/*3197*/ uint16(xMatch),
+	/*3198*/ uint16(xCondPrefix), 1,
+	0x66, 3202,
+	/*3202*/ uint16(xSetOp), uint16(PBLENDW),
+	/*3204*/ uint16(xReadSlashR),
+	/*3205*/ uint16(xReadIb),
+	/*3206*/ uint16(xArgXmm1),
+	/*3207*/ uint16(xArgXmm2M128),
+	/*3208*/ uint16(xArgImm8u),
+	/*3209*/ uint16(xMatch),
+	/*3210*/ uint16(xCondPrefix), 2,
+	0x66, 3224,
+	0x0, 3216,
+	/*3216*/ uint16(xSetOp), uint16(PALIGNR),
+	/*3218*/ uint16(xReadSlashR),
+	/*3219*/ uint16(xReadIb),
+	/*3220*/ uint16(xArgMm1),
+	/*3221*/ uint16(xArgMm2M64),
+	/*3222*/ uint16(xArgImm8u),
+	/*3223*/ uint16(xMatch),
+	/*3224*/ uint16(xSetOp), uint16(PALIGNR),
+	/*3226*/ uint16(xReadSlashR),
+	/*3227*/ uint16(xReadIb),
+	/*3228*/ uint16(xArgXmm1),
+	/*3229*/ uint16(xArgXmm2M128),
+	/*3230*/ uint16(xArgImm8u),
+	/*3231*/ uint16(xMatch),
+	/*3232*/ uint16(xCondPrefix), 1,
+	0x66, 3236,
+	/*3236*/ uint16(xSetOp), uint16(PEXTRB),
+	/*3238*/ uint16(xReadSlashR),
+	/*3239*/ uint16(xReadIb),
+	/*3240*/ uint16(xArgR32M8),
+	/*3241*/ uint16(xArgXmm1),
+	/*3242*/ uint16(xArgImm8u),
+	/*3243*/ uint16(xMatch),
+	/*3244*/ uint16(xCondPrefix), 1,
+	0x66, 3248,
+	/*3248*/ uint16(xSetOp), uint16(PEXTRW),
+	/*3250*/ uint16(xReadSlashR),
+	/*3251*/ uint16(xReadIb),
+	/*3252*/ uint16(xArgR32M16),
+	/*3253*/ uint16(xArgXmm1),
+	/*3254*/ uint16(xArgImm8u),
+	/*3255*/ uint16(xMatch),
+	/*3256*/ uint16(xCondIs64), 3259, 3283,
+	/*3259*/ uint16(xCondPrefix), 1,
+	0x66, 3263,
+	/*3263*/ uint16(xCondDataSize), 3267, 3275, 0,
+	/*3267*/ uint16(xSetOp), uint16(PEXTRD),
+	/*3269*/ uint16(xReadSlashR),
+	/*3270*/ uint16(xReadIb),
+	/*3271*/ uint16(xArgRM32),
+	/*3272*/ uint16(xArgXmm1),
+	/*3273*/ uint16(xArgImm8u),
+	/*3274*/ uint16(xMatch),
+	/*3275*/ uint16(xSetOp), uint16(PEXTRD),
+	/*3277*/ uint16(xReadSlashR),
+	/*3278*/ uint16(xReadIb),
+	/*3279*/ uint16(xArgRM32),
+	/*3280*/ uint16(xArgXmm1),
+	/*3281*/ uint16(xArgImm8u),
+	/*3282*/ uint16(xMatch),
+	/*3283*/ uint16(xCondPrefix), 1,
+	0x66, 3287,
+	/*3287*/ uint16(xCondDataSize), 3267, 3275, 3291,
+	/*3291*/ uint16(xSetOp), uint16(PEXTRQ),
+	/*3293*/ uint16(xReadSlashR),
+	/*3294*/ uint16(xReadIb),
+	/*3295*/ uint16(xArgRM64),
+	/*3296*/ uint16(xArgXmm1),
+	/*3297*/ uint16(xArgImm8u),
+	/*3298*/ uint16(xMatch),
+	/*3299*/ uint16(xCondPrefix), 1,
+	0x66, 3303,
+	/*3303*/ uint16(xSetOp), uint16(EXTRACTPS),
+	/*3305*/ uint16(xReadSlashR),
+	/*3306*/ uint16(xReadIb),
+	/*3307*/ uint16(xArgRM32),
+	/*3308*/ uint16(xArgXmm1),
+	/*3309*/ uint16(xArgImm8u),
+	/*3310*/ uint16(xMatch),
+	/*3311*/ uint16(xCondPrefix), 1,
+	0x66, 3315,
+	/*3315*/ uint16(xSetOp), uint16(PINSRB),
+	/*3317*/ uint16(xReadSlashR),
+	/*3318*/ uint16(xReadIb),
+	/*3319*/ uint16(xArgXmm1),
+	/*3320*/ uint16(xArgR32M8),
+	/*3321*/ uint16(xArgImm8u),
+	/*3322*/ uint16(xMatch),
+	/*3323*/ uint16(xCondPrefix), 1,
+	0x66, 3327,
+	/*3327*/ uint16(xSetOp), uint16(INSERTPS),
+	/*3329*/ uint16(xReadSlashR),
+	/*3330*/ uint16(xReadIb),
+	/*3331*/ uint16(xArgXmm1),
+	/*3332*/ uint16(xArgXmm2M32),
+	/*3333*/ uint16(xArgImm8u),
+	/*3334*/ uint16(xMatch),
+	/*3335*/ uint16(xCondIs64), 3338, 3362,
+	/*3338*/ uint16(xCondPrefix), 1,
+	0x66, 3342,
+	/*3342*/ uint16(xCondDataSize), 3346, 3354, 0,
+	/*3346*/ uint16(xSetOp), uint16(PINSRD),
+	/*3348*/ uint16(xReadSlashR),
+	/*3349*/ uint16(xReadIb),
+	/*3350*/ uint16(xArgXmm1),
+	/*3351*/ uint16(xArgRM32),
+	/*3352*/ uint16(xArgImm8u),
+	/*3353*/ uint16(xMatch),
+	/*3354*/ uint16(xSetOp), uint16(PINSRD),
+	/*3356*/ uint16(xReadSlashR),
+	/*3357*/ uint16(xReadIb),
+	/*3358*/ uint16(xArgXmm1),
+	/*3359*/ uint16(xArgRM32),
+	/*3360*/ uint16(xArgImm8u),
+	/*3361*/ uint16(xMatch),
+	/*3362*/ uint16(xCondPrefix), 1,
+	0x66, 3366,
+	/*3366*/ uint16(xCondDataSize), 3346, 3354, 3370,
+	/*3370*/ uint16(xSetOp), uint16(PINSRQ),
+	/*3372*/ uint16(xReadSlashR),
+	/*3373*/ uint16(xReadIb),
+	/*3374*/ uint16(xArgXmm1),
+	/*3375*/ uint16(xArgRM64),
+	/*3376*/ uint16(xArgImm8u),
+	/*3377*/ uint16(xMatch),
+	/*3378*/ uint16(xCondPrefix), 1,
+	0x66, 3382,
+	/*3382*/ uint16(xSetOp), uint16(DPPS),
+	/*3384*/ uint16(xReadSlashR),
+	/*3385*/ uint16(xReadIb),
+	/*3386*/ uint16(xArgXmm1),
+	/*3387*/ uint16(xArgXmm2M128),
+	/*3388*/ uint16(xArgImm8u),
+	/*3389*/ uint16(xMatch),
+	/*3390*/ uint16(xCondPrefix), 1,
+	0x66, 3394,
+	/*3394*/ uint16(xSetOp), uint16(DPPD),
+	/*3396*/ uint16(xReadSlashR),
+	/*3397*/ uint16(xReadIb),
+	/*3398*/ uint16(xArgXmm1),
+	/*3399*/ uint16(xArgXmm2M128),
+	/*3400*/ uint16(xArgImm8u),
+	/*3401*/ uint16(xMatch),
+	/*3402*/ uint16(xCondPrefix), 1,
+	0x66, 3406,
+	/*3406*/ uint16(xSetOp), uint16(MPSADBW),
+	/*3408*/ uint16(xReadSlashR),
+	/*3409*/ uint16(xReadIb),
+	/*3410*/ uint16(xArgXmm1),
+	/*3411*/ uint16(xArgXmm2M128),
+	/*3412*/ uint16(xArgImm8u),
+	/*3413*/ uint16(xMatch),
+	/*3414*/ uint16(xCondPrefix), 1,
+	0x66, 3418,
+	/*3418*/ uint16(xSetOp), uint16(PCLMULQDQ),
+	/*3420*/ uint16(xReadSlashR),
+	/*3421*/ uint16(xReadIb),
+	/*3422*/ uint16(xArgXmm1),
+	/*3423*/ uint16(xArgXmm2M128),
+	/*3424*/ uint16(xArgImm8u),
+	/*3425*/ uint16(xMatch),
+	/*3426*/ uint16(xCondPrefix), 1,
+	0x66, 3430,
+	/*3430*/ uint16(xSetOp), uint16(PCMPESTRM),
+	/*3432*/ uint16(xReadSlashR),
+	/*3433*/ uint16(xReadIb),
+	/*3434*/ uint16(xArgXmm1),
+	/*3435*/ uint16(xArgXmm2M128),
+	/*3436*/ uint16(xArgImm8u),
+	/*3437*/ uint16(xMatch),
+	/*3438*/ uint16(xCondPrefix), 1,
+	0x66, 3442,
+	/*3442*/ uint16(xSetOp), uint16(PCMPESTRI),
+	/*3444*/ uint16(xReadSlashR),
+	/*3445*/ uint16(xReadIb),
+	/*3446*/ uint16(xArgXmm1),
+	/*3447*/ uint16(xArgXmm2M128),
+	/*3448*/ uint16(xArgImm8u),
+	/*3449*/ uint16(xMatch),
+	/*3450*/ uint16(xCondPrefix), 1,
+	0x66, 3454,
+	/*3454*/ uint16(xSetOp), uint16(PCMPISTRM),
+	/*3456*/ uint16(xReadSlashR),
+	/*3457*/ uint16(xReadIb),
+	/*3458*/ uint16(xArgXmm1),
+	/*3459*/ uint16(xArgXmm2M128),
+	/*3460*/ uint16(xArgImm8u),
+	/*3461*/ uint16(xMatch),
+	/*3462*/ uint16(xCondPrefix), 1,
+	0x66, 3466,
+	/*3466*/ uint16(xSetOp), uint16(PCMPISTRI),
+	/*3468*/ uint16(xReadSlashR),
+	/*3469*/ uint16(xReadIb),
+	/*3470*/ uint16(xArgXmm1),
+	/*3471*/ uint16(xArgXmm2M128),
+	/*3472*/ uint16(xArgImm8u),
+	/*3473*/ uint16(xMatch),
+	/*3474*/ uint16(xCondPrefix), 1,
+	0x66, 3478,
+	/*3478*/ uint16(xSetOp), uint16(AESKEYGENASSIST),
+	/*3480*/ uint16(xReadSlashR),
+	/*3481*/ uint16(xReadIb),
+	/*3482*/ uint16(xArgXmm1),
+	/*3483*/ uint16(xArgXmm2M128),
+	/*3484*/ uint16(xArgImm8u),
+	/*3485*/ uint16(xMatch),
+	/*3486*/ uint16(xCondIs64), 3489, 3505,
+	/*3489*/ uint16(xCondDataSize), 3493, 3499, 0,
+	/*3493*/ uint16(xSetOp), uint16(CMOVO),
+	/*3495*/ uint16(xReadSlashR),
+	/*3496*/ uint16(xArgR16),
+	/*3497*/ uint16(xArgRM16),
+	/*3498*/ uint16(xMatch),
+	/*3499*/ uint16(xSetOp), uint16(CMOVO),
+	/*3501*/ uint16(xReadSlashR),
+	/*3502*/ uint16(xArgR32),
+	/*3503*/ uint16(xArgRM32),
+	/*3504*/ uint16(xMatch),
+	/*3505*/ uint16(xCondDataSize), 3493, 3499, 3509,
+	/*3509*/ uint16(xSetOp), uint16(CMOVO),
+	/*3511*/ uint16(xReadSlashR),
+	/*3512*/ uint16(xArgR64),
+	/*3513*/ uint16(xArgRM64),
+	/*3514*/ uint16(xMatch),
+	/*3515*/ uint16(xCondIs64), 3518, 3534,
+	/*3518*/ uint16(xCondDataSize), 3522, 3528, 0,
+	/*3522*/ uint16(xSetOp), uint16(CMOVNO),
+	/*3524*/ uint16(xReadSlashR),
+	/*3525*/ uint16(xArgR16),
+	/*3526*/ uint16(xArgRM16),
+	/*3527*/ uint16(xMatch),
+	/*3528*/ uint16(xSetOp), uint16(CMOVNO),
+	/*3530*/ uint16(xReadSlashR),
+	/*3531*/ uint16(xArgR32),
+	/*3532*/ uint16(xArgRM32),
+	/*3533*/ uint16(xMatch),
+	/*3534*/ uint16(xCondDataSize), 3522, 3528, 3538,
+	/*3538*/ uint16(xSetOp), uint16(CMOVNO),
+	/*3540*/ uint16(xReadSlashR),
+	/*3541*/ uint16(xArgR64),
+	/*3542*/ uint16(xArgRM64),
+	/*3543*/ uint16(xMatch),
+	/*3544*/ uint16(xCondIs64), 3547, 3563,
+	/*3547*/ uint16(xCondDataSize), 3551, 3557, 0,
+	/*3551*/ uint16(xSetOp), uint16(CMOVB),
+	/*3553*/ uint16(xReadSlashR),
+	/*3554*/ uint16(xArgR16),
+	/*3555*/ uint16(xArgRM16),
+	/*3556*/ uint16(xMatch),
+	/*3557*/ uint16(xSetOp), uint16(CMOVB),
+	/*3559*/ uint16(xReadSlashR),
+	/*3560*/ uint16(xArgR32),
+	/*3561*/ uint16(xArgRM32),
+	/*3562*/ uint16(xMatch),
+	/*3563*/ uint16(xCondDataSize), 3551, 3557, 3567,
+	/*3567*/ uint16(xSetOp), uint16(CMOVB),
+	/*3569*/ uint16(xReadSlashR),
+	/*3570*/ uint16(xArgR64),
+	/*3571*/ uint16(xArgRM64),
+	/*3572*/ uint16(xMatch),
+	/*3573*/ uint16(xCondIs64), 3576, 3592,
+	/*3576*/ uint16(xCondDataSize), 3580, 3586, 0,
+	/*3580*/ uint16(xSetOp), uint16(CMOVAE),
+	/*3582*/ uint16(xReadSlashR),
+	/*3583*/ uint16(xArgR16),
+	/*3584*/ uint16(xArgRM16),
+	/*3585*/ uint16(xMatch),
+	/*3586*/ uint16(xSetOp), uint16(CMOVAE),
+	/*3588*/ uint16(xReadSlashR),
+	/*3589*/ uint16(xArgR32),
+	/*3590*/ uint16(xArgRM32),
+	/*3591*/ uint16(xMatch),
+	/*3592*/ uint16(xCondDataSize), 3580, 3586, 3596,
+	/*3596*/ uint16(xSetOp), uint16(CMOVAE),
+	/*3598*/ uint16(xReadSlashR),
+	/*3599*/ uint16(xArgR64),
+	/*3600*/ uint16(xArgRM64),
+	/*3601*/ uint16(xMatch),
+	/*3602*/ uint16(xCondIs64), 3605, 3621,
+	/*3605*/ uint16(xCondDataSize), 3609, 3615, 0,
+	/*3609*/ uint16(xSetOp), uint16(CMOVE),
+	/*3611*/ uint16(xReadSlashR),
+	/*3612*/ uint16(xArgR16),
+	/*3613*/ uint16(xArgRM16),
+	/*3614*/ uint16(xMatch),
+	/*3615*/ uint16(xSetOp), uint16(CMOVE),
+	/*3617*/ uint16(xReadSlashR),
+	/*3618*/ uint16(xArgR32),
+	/*3619*/ uint16(xArgRM32),
+	/*3620*/ uint16(xMatch),
+	/*3621*/ uint16(xCondDataSize), 3609, 3615, 3625,
+	/*3625*/ uint16(xSetOp), uint16(CMOVE),
+	/*3627*/ uint16(xReadSlashR),
+	/*3628*/ uint16(xArgR64),
+	/*3629*/ uint16(xArgRM64),
+	/*3630*/ uint16(xMatch),
+	/*3631*/ uint16(xCondIs64), 3634, 3650,
+	/*3634*/ uint16(xCondDataSize), 3638, 3644, 0,
+	/*3638*/ uint16(xSetOp), uint16(CMOVNE),
+	/*3640*/ uint16(xReadSlashR),
+	/*3641*/ uint16(xArgR16),
+	/*3642*/ uint16(xArgRM16),
+	/*3643*/ uint16(xMatch),
+	/*3644*/ uint16(xSetOp), uint16(CMOVNE),
+	/*3646*/ uint16(xReadSlashR),
+	/*3647*/ uint16(xArgR32),
+	/*3648*/ uint16(xArgRM32),
+	/*3649*/ uint16(xMatch),
+	/*3650*/ uint16(xCondDataSize), 3638, 3644, 3654,
+	/*3654*/ uint16(xSetOp), uint16(CMOVNE),
+	/*3656*/ uint16(xReadSlashR),
+	/*3657*/ uint16(xArgR64),
+	/*3658*/ uint16(xArgRM64),
+	/*3659*/ uint16(xMatch),
+	/*3660*/ uint16(xCondIs64), 3663, 3679,
+	/*3663*/ uint16(xCondDataSize), 3667, 3673, 0,
+	/*3667*/ uint16(xSetOp), uint16(CMOVBE),
+	/*3669*/ uint16(xReadSlashR),
+	/*3670*/ uint16(xArgR16),
+	/*3671*/ uint16(xArgRM16),
+	/*3672*/ uint16(xMatch),
+	/*3673*/ uint16(xSetOp), uint16(CMOVBE),
+	/*3675*/ uint16(xReadSlashR),
+	/*3676*/ uint16(xArgR32),
+	/*3677*/ uint16(xArgRM32),
+	/*3678*/ uint16(xMatch),
+	/*3679*/ uint16(xCondDataSize), 3667, 3673, 3683,
+	/*3683*/ uint16(xSetOp), uint16(CMOVBE),
+	/*3685*/ uint16(xReadSlashR),
+	/*3686*/ uint16(xArgR64),
+	/*3687*/ uint16(xArgRM64),
+	/*3688*/ uint16(xMatch),
+	/*3689*/ uint16(xCondIs64), 3692, 3708,
+	/*3692*/ uint16(xCondDataSize), 3696, 3702, 0,
+	/*3696*/ uint16(xSetOp), uint16(CMOVA),
+	/*3698*/ uint16(xReadSlashR),
+	/*3699*/ uint16(xArgR16),
+	/*3700*/ uint16(xArgRM16),
+	/*3701*/ uint16(xMatch),
+	/*3702*/ uint16(xSetOp), uint16(CMOVA),
+	/*3704*/ uint16(xReadSlashR),
+	/*3705*/ uint16(xArgR32),
+	/*3706*/ uint16(xArgRM32),
+	/*3707*/ uint16(xMatch),
+	/*3708*/ uint16(xCondDataSize), 3696, 3702, 3712,
+	/*3712*/ uint16(xSetOp), uint16(CMOVA),
+	/*3714*/ uint16(xReadSlashR),
+	/*3715*/ uint16(xArgR64),
+	/*3716*/ uint16(xArgRM64),
+	/*3717*/ uint16(xMatch),
+	/*3718*/ uint16(xCondIs64), 3721, 3737,
+	/*3721*/ uint16(xCondDataSize), 3725, 3731, 0,
+	/*3725*/ uint16(xSetOp), uint16(CMOVS),
+	/*3727*/ uint16(xReadSlashR),
+	/*3728*/ uint16(xArgR16),
+	/*3729*/ uint16(xArgRM16),
+	/*3730*/ uint16(xMatch),
+	/*3731*/ uint16(xSetOp), uint16(CMOVS),
+	/*3733*/ uint16(xReadSlashR),
+	/*3734*/ uint16(xArgR32),
+	/*3735*/ uint16(xArgRM32),
+	/*3736*/ uint16(xMatch),
+	/*3737*/ uint16(xCondDataSize), 3725, 3731, 3741,
+	/*3741*/ uint16(xSetOp), uint16(CMOVS),
+	/*3743*/ uint16(xReadSlashR),
+	/*3744*/ uint16(xArgR64),
+	/*3745*/ uint16(xArgRM64),
+	/*3746*/ uint16(xMatch),
+	/*3747*/ uint16(xCondIs64), 3750, 3766,
+	/*3750*/ uint16(xCondDataSize), 3754, 3760, 0,
+	/*3754*/ uint16(xSetOp), uint16(CMOVNS),
+	/*3756*/ uint16(xReadSlashR),
+	/*3757*/ uint16(xArgR16),
+	/*3758*/ uint16(xArgRM16),
+	/*3759*/ uint16(xMatch),
+	/*3760*/ uint16(xSetOp), uint16(CMOVNS),
+	/*3762*/ uint16(xReadSlashR),
+	/*3763*/ uint16(xArgR32),
+	/*3764*/ uint16(xArgRM32),
+	/*3765*/ uint16(xMatch),
+	/*3766*/ uint16(xCondDataSize), 3754, 3760, 3770,
+	/*3770*/ uint16(xSetOp), uint16(CMOVNS),
+	/*3772*/ uint16(xReadSlashR),
+	/*3773*/ uint16(xArgR64),
+	/*3774*/ uint16(xArgRM64),
+	/*3775*/ uint16(xMatch),
+	/*3776*/ uint16(xCondIs64), 3779, 3795,
+	/*3779*/ uint16(xCondDataSize), 3783, 3789, 0,
+	/*3783*/ uint16(xSetOp), uint16(CMOVP),
+	/*3785*/ uint16(xReadSlashR),
+	/*3786*/ uint16(xArgR16),
+	/*3787*/ uint16(xArgRM16),
+	/*3788*/ uint16(xMatch),
+	/*3789*/ uint16(xSetOp), uint16(CMOVP),
+	/*3791*/ uint16(xReadSlashR),
+	/*3792*/ uint16(xArgR32),
+	/*3793*/ uint16(xArgRM32),
+	/*3794*/ uint16(xMatch),
+	/*3795*/ uint16(xCondDataSize), 3783, 3789, 3799,
+	/*3799*/ uint16(xSetOp), uint16(CMOVP),
+	/*3801*/ uint16(xReadSlashR),
+	/*3802*/ uint16(xArgR64),
+	/*3803*/ uint16(xArgRM64),
+	/*3804*/ uint16(xMatch),
+	/*3805*/ uint16(xCondIs64), 3808, 3824,
+	/*3808*/ uint16(xCondDataSize), 3812, 3818, 0,
+	/*3812*/ uint16(xSetOp), uint16(CMOVNP),
+	/*3814*/ uint16(xReadSlashR),
+	/*3815*/ uint16(xArgR16),
+	/*3816*/ uint16(xArgRM16),
+	/*3817*/ uint16(xMatch),
+	/*3818*/ uint16(xSetOp), uint16(CMOVNP),
+	/*3820*/ uint16(xReadSlashR),
+	/*3821*/ uint16(xArgR32),
+	/*3822*/ uint16(xArgRM32),
+	/*3823*/ uint16(xMatch),
+	/*3824*/ uint16(xCondDataSize), 3812, 3818, 3828,
+	/*3828*/ uint16(xSetOp), uint16(CMOVNP),
+	/*3830*/ uint16(xReadSlashR),
+	/*3831*/ uint16(xArgR64),
+	/*3832*/ uint16(xArgRM64),
+	/*3833*/ uint16(xMatch),
+	/*3834*/ uint16(xCondIs64), 3837, 3853,
+	/*3837*/ uint16(xCondDataSize), 3841, 3847, 0,
+	/*3841*/ uint16(xSetOp), uint16(CMOVL),
+	/*3843*/ uint16(xReadSlashR),
+	/*3844*/ uint16(xArgR16),
+	/*3845*/ uint16(xArgRM16),
+	/*3846*/ uint16(xMatch),
+	/*3847*/ uint16(xSetOp), uint16(CMOVL),
+	/*3849*/ uint16(xReadSlashR),
+	/*3850*/ uint16(xArgR32),
+	/*3851*/ uint16(xArgRM32),
+	/*3852*/ uint16(xMatch),
+	/*3853*/ uint16(xCondDataSize), 3841, 3847, 3857,
+	/*3857*/ uint16(xSetOp), uint16(CMOVL),
+	/*3859*/ uint16(xReadSlashR),
+	/*3860*/ uint16(xArgR64),
+	/*3861*/ uint16(xArgRM64),
+	/*3862*/ uint16(xMatch),
+	/*3863*/ uint16(xCondIs64), 3866, 3882,
+	/*3866*/ uint16(xCondDataSize), 3870, 3876, 0,
+	/*3870*/ uint16(xSetOp), uint16(CMOVGE),
+	/*3872*/ uint16(xReadSlashR),
+	/*3873*/ uint16(xArgR16),
+	/*3874*/ uint16(xArgRM16),
+	/*3875*/ uint16(xMatch),
+	/*3876*/ uint16(xSetOp), uint16(CMOVGE),
+	/*3878*/ uint16(xReadSlashR),
+	/*3879*/ uint16(xArgR32),
+	/*3880*/ uint16(xArgRM32),
+	/*3881*/ uint16(xMatch),
+	/*3882*/ uint16(xCondDataSize), 3870, 3876, 3886,
+	/*3886*/ uint16(xSetOp), uint16(CMOVGE),
+	/*3888*/ uint16(xReadSlashR),
+	/*3889*/ uint16(xArgR64),
+	/*3890*/ uint16(xArgRM64),
+	/*3891*/ uint16(xMatch),
+	/*3892*/ uint16(xCondIs64), 3895, 3911,
+	/*3895*/ uint16(xCondDataSize), 3899, 3905, 0,
+	/*3899*/ uint16(xSetOp), uint16(CMOVLE),
+	/*3901*/ uint16(xReadSlashR),
+	/*3902*/ uint16(xArgR16),
+	/*3903*/ uint16(xArgRM16),
+	/*3904*/ uint16(xMatch),
+	/*3905*/ uint16(xSetOp), uint16(CMOVLE),
+	/*3907*/ uint16(xReadSlashR),
+	/*3908*/ uint16(xArgR32),
+	/*3909*/ uint16(xArgRM32),
+	/*3910*/ uint16(xMatch),
+	/*3911*/ uint16(xCondDataSize), 3899, 3905, 3915,
+	/*3915*/ uint16(xSetOp), uint16(CMOVLE),
+	/*3917*/ uint16(xReadSlashR),
+	/*3918*/ uint16(xArgR64),
+	/*3919*/ uint16(xArgRM64),
+	/*3920*/ uint16(xMatch),
+	/*3921*/ uint16(xCondIs64), 3924, 3940,
+	/*3924*/ uint16(xCondDataSize), 3928, 3934, 0,
+	/*3928*/ uint16(xSetOp), uint16(CMOVG),
+	/*3930*/ uint16(xReadSlashR),
+	/*3931*/ uint16(xArgR16),
+	/*3932*/ uint16(xArgRM16),
+	/*3933*/ uint16(xMatch),
+	/*3934*/ uint16(xSetOp), uint16(CMOVG),
+	/*3936*/ uint16(xReadSlashR),
+	/*3937*/ uint16(xArgR32),
+	/*3938*/ uint16(xArgRM32),
+	/*3939*/ uint16(xMatch),
+	/*3940*/ uint16(xCondDataSize), 3928, 3934, 3944,
+	/*3944*/ uint16(xSetOp), uint16(CMOVG),
+	/*3946*/ uint16(xReadSlashR),
+	/*3947*/ uint16(xArgR64),
+	/*3948*/ uint16(xArgRM64),
+	/*3949*/ uint16(xMatch),
+	/*3950*/ uint16(xCondPrefix), 2,
+	0x66, 3962,
+	0x0, 3956,
+	/*3956*/ uint16(xSetOp), uint16(MOVMSKPS),
+	/*3958*/ uint16(xReadSlashR),
+	/*3959*/ uint16(xArgR32),
+	/*3960*/ uint16(xArgXmm2),
+	/*3961*/ uint16(xMatch),
+	/*3962*/ uint16(xSetOp), uint16(MOVMSKPD),
+	/*3964*/ uint16(xReadSlashR),
+	/*3965*/ uint16(xArgR32),
+	/*3966*/ uint16(xArgXmm2),
+	/*3967*/ uint16(xMatch),
+	/*3968*/ uint16(xCondPrefix), 4,
+	0xF3, 3996,
+	0xF2, 3990,
+	0x66, 3984,
+	0x0, 3978,
+	/*3978*/ uint16(xSetOp), uint16(SQRTPS),
+	/*3980*/ uint16(xReadSlashR),
+	/*3981*/ uint16(xArgXmm1),
+	/*3982*/ uint16(xArgXmm2M128),
+	/*3983*/ uint16(xMatch),
+	/*3984*/ uint16(xSetOp), uint16(SQRTPD),
+	/*3986*/ uint16(xReadSlashR),
+	/*3987*/ uint16(xArgXmm1),
+	/*3988*/ uint16(xArgXmm2M128),
+	/*3989*/ uint16(xMatch),
+	/*3990*/ uint16(xSetOp), uint16(SQRTSD),
+	/*3992*/ uint16(xReadSlashR),
+	/*3993*/ uint16(xArgXmm1),
+	/*3994*/ uint16(xArgXmm2M64),
+	/*3995*/ uint16(xMatch),
+	/*3996*/ uint16(xSetOp), uint16(SQRTSS),
+	/*3998*/ uint16(xReadSlashR),
+	/*3999*/ uint16(xArgXmm1),
+	/*4000*/ uint16(xArgXmm2M32),
+	/*4001*/ uint16(xMatch),
+	/*4002*/ uint16(xCondPrefix), 2,
+	0xF3, 4014,
+	0x0, 4008,
+	/*4008*/ uint16(xSetOp), uint16(RSQRTPS),
+	/*4010*/ uint16(xReadSlashR),
+	/*4011*/ uint16(xArgXmm1),
+	/*4012*/ uint16(xArgXmm2M128),
+	/*4013*/ uint16(xMatch),
+	/*4014*/ uint16(xSetOp), uint16(RSQRTSS),
+	/*4016*/ uint16(xReadSlashR),
+	/*4017*/ uint16(xArgXmm1),
+	/*4018*/ uint16(xArgXmm2M32),
+	/*4019*/ uint16(xMatch),
+	/*4020*/ uint16(xCondPrefix), 2,
+	0xF3, 4032,
+	0x0, 4026,
+	/*4026*/ uint16(xSetOp), uint16(RCPPS),
+	/*4028*/ uint16(xReadSlashR),
+	/*4029*/ uint16(xArgXmm1),
+	/*4030*/ uint16(xArgXmm2M128),
+	/*4031*/ uint16(xMatch),
+	/*4032*/ uint16(xSetOp), uint16(RCPSS),
+	/*4034*/ uint16(xReadSlashR),
+	/*4035*/ uint16(xArgXmm1),
+	/*4036*/ uint16(xArgXmm2M32),
+	/*4037*/ uint16(xMatch),
+	/*4038*/ uint16(xCondPrefix), 2,
+	0x66, 4050,
+	0x0, 4044,
+	/*4044*/ uint16(xSetOp), uint16(ANDPS),
+	/*4046*/ uint16(xReadSlashR),
+	/*4047*/ uint16(xArgXmm1),
+	/*4048*/ uint16(xArgXmm2M128),
+	/*4049*/ uint16(xMatch),
+	/*4050*/ uint16(xSetOp), uint16(ANDPD),
+	/*4052*/ uint16(xReadSlashR),
+	/*4053*/ uint16(xArgXmm1),
+	/*4054*/ uint16(xArgXmm2M128),
+	/*4055*/ uint16(xMatch),
+	/*4056*/ uint16(xCondPrefix), 2,
+	0x66, 4068,
+	0x0, 4062,
+	/*4062*/ uint16(xSetOp), uint16(ANDNPS),
+	/*4064*/ uint16(xReadSlashR),
+	/*4065*/ uint16(xArgXmm1),
+	/*4066*/ uint16(xArgXmm2M128),
+	/*4067*/ uint16(xMatch),
+	/*4068*/ uint16(xSetOp), uint16(ANDNPD),
+	/*4070*/ uint16(xReadSlashR),
+	/*4071*/ uint16(xArgXmm1),
+	/*4072*/ uint16(xArgXmm2M128),
+	/*4073*/ uint16(xMatch),
+	/*4074*/ uint16(xCondPrefix), 2,
+	0x66, 4086,
+	0x0, 4080,
+	/*4080*/ uint16(xSetOp), uint16(ORPS),
+	/*4082*/ uint16(xReadSlashR),
+	/*4083*/ uint16(xArgXmm1),
+	/*4084*/ uint16(xArgXmm2M128),
+	/*4085*/ uint16(xMatch),
+	/*4086*/ uint16(xSetOp), uint16(ORPD),
+	/*4088*/ uint16(xReadSlashR),
+	/*4089*/ uint16(xArgXmm1),
+	/*4090*/ uint16(xArgXmm2M128),
+	/*4091*/ uint16(xMatch),
+	/*4092*/ uint16(xCondPrefix), 2,
+	0x66, 4104,
+	0x0, 4098,
+	/*4098*/ uint16(xSetOp), uint16(XORPS),
+	/*4100*/ uint16(xReadSlashR),
+	/*4101*/ uint16(xArgXmm1),
+	/*4102*/ uint16(xArgXmm2M128),
+	/*4103*/ uint16(xMatch),
+	/*4104*/ uint16(xSetOp), uint16(XORPD),
+	/*4106*/ uint16(xReadSlashR),
+	/*4107*/ uint16(xArgXmm1),
+	/*4108*/ uint16(xArgXmm2M128),
+	/*4109*/ uint16(xMatch),
+	/*4110*/ uint16(xCondPrefix), 4,
+	0xF3, 4138,
+	0xF2, 4132,
+	0x66, 4126,
+	0x0, 4120,
+	/*4120*/ uint16(xSetOp), uint16(ADDPS),
+	/*4122*/ uint16(xReadSlashR),
+	/*4123*/ uint16(xArgXmm1),
+	/*4124*/ uint16(xArgXmm2M128),
+	/*4125*/ uint16(xMatch),
+	/*4126*/ uint16(xSetOp), uint16(ADDPD),
+	/*4128*/ uint16(xReadSlashR),
+	/*4129*/ uint16(xArgXmm1),
+	/*4130*/ uint16(xArgXmm2M128),
+	/*4131*/ uint16(xMatch),
+	/*4132*/ uint16(xSetOp), uint16(ADDSD),
+	/*4134*/ uint16(xReadSlashR),
+	/*4135*/ uint16(xArgXmm1),
+	/*4136*/ uint16(xArgXmm2M64),
+	/*4137*/ uint16(xMatch),
+	/*4138*/ uint16(xSetOp), uint16(ADDSS),
+	/*4140*/ uint16(xReadSlashR),
+	/*4141*/ uint16(xArgXmm1),
+	/*4142*/ uint16(xArgXmm2M32),
+	/*4143*/ uint16(xMatch),
+	/*4144*/ uint16(xCondPrefix), 4,
+	0xF3, 4172,
+	0xF2, 4166,
+	0x66, 4160,
+	0x0, 4154,
+	/*4154*/ uint16(xSetOp), uint16(MULPS),
+	/*4156*/ uint16(xReadSlashR),
+	/*4157*/ uint16(xArgXmm1),
+	/*4158*/ uint16(xArgXmm2M128),
+	/*4159*/ uint16(xMatch),
+	/*4160*/ uint16(xSetOp), uint16(MULPD),
+	/*4162*/ uint16(xReadSlashR),
+	/*4163*/ uint16(xArgXmm1),
+	/*4164*/ uint16(xArgXmm2M128),
+	/*4165*/ uint16(xMatch),
+	/*4166*/ uint16(xSetOp), uint16(MULSD),
+	/*4168*/ uint16(xReadSlashR),
+	/*4169*/ uint16(xArgXmm1),
+	/*4170*/ uint16(xArgXmm2M64),
+	/*4171*/ uint16(xMatch),
+	/*4172*/ uint16(xSetOp), uint16(MULSS),
+	/*4174*/ uint16(xReadSlashR),
+	/*4175*/ uint16(xArgXmm1),
+	/*4176*/ uint16(xArgXmm2M32),
+	/*4177*/ uint16(xMatch),
+	/*4178*/ uint16(xCondPrefix), 4,
+	0xF3, 4206,
+	0xF2, 4200,
+	0x66, 4194,
+	0x0, 4188,
+	/*4188*/ uint16(xSetOp), uint16(CVTPS2PD),
+	/*4190*/ uint16(xReadSlashR),
+	/*4191*/ uint16(xArgXmm1),
+	/*4192*/ uint16(xArgXmm2M64),
+	/*4193*/ uint16(xMatch),
+	/*4194*/ uint16(xSetOp), uint16(CVTPD2PS),
+	/*4196*/ uint16(xReadSlashR),
+	/*4197*/ uint16(xArgXmm1),
+	/*4198*/ uint16(xArgXmm2M128),
+	/*4199*/ uint16(xMatch),
+	/*4200*/ uint16(xSetOp), uint16(CVTSD2SS),
+	/*4202*/ uint16(xReadSlashR),
+	/*4203*/ uint16(xArgXmm1),
+	/*4204*/ uint16(xArgXmm2M64),
+	/*4205*/ uint16(xMatch),
+	/*4206*/ uint16(xSetOp), uint16(CVTSS2SD),
+	/*4208*/ uint16(xReadSlashR),
+	/*4209*/ uint16(xArgXmm1),
+	/*4210*/ uint16(xArgXmm2M32),
+	/*4211*/ uint16(xMatch),
+	/*4212*/ uint16(xCondPrefix), 3,
+	0xF3, 4232,
+	0x66, 4226,
+	0x0, 4220,
+	/*4220*/ uint16(xSetOp), uint16(CVTDQ2PS),
+	/*4222*/ uint16(xReadSlashR),
+	/*4223*/ uint16(xArgXmm1),
+	/*4224*/ uint16(xArgXmm2M128),
+	/*4225*/ uint16(xMatch),
+	/*4226*/ uint16(xSetOp), uint16(CVTPS2DQ),
+	/*4228*/ uint16(xReadSlashR),
+	/*4229*/ uint16(xArgXmm1),
+	/*4230*/ uint16(xArgXmm2M128),
+	/*4231*/ uint16(xMatch),
+	/*4232*/ uint16(xSetOp), uint16(CVTTPS2DQ),
+	/*4234*/ uint16(xReadSlashR),
+	/*4235*/ uint16(xArgXmm1),
+	/*4236*/ uint16(xArgXmm2M128),
+	/*4237*/ uint16(xMatch),
+	/*4238*/ uint16(xCondPrefix), 4,
+	0xF3, 4266,
+	0xF2, 4260,
+	0x66, 4254,
+	0x0, 4248,
+	/*4248*/ uint16(xSetOp), uint16(SUBPS),
+	/*4250*/ uint16(xReadSlashR),
+	/*4251*/ uint16(xArgXmm1),
+	/*4252*/ uint16(xArgXmm2M128),
+	/*4253*/ uint16(xMatch),
+	/*4254*/ uint16(xSetOp), uint16(SUBPD),
+	/*4256*/ uint16(xReadSlashR),
+	/*4257*/ uint16(xArgXmm1),
+	/*4258*/ uint16(xArgXmm2M128),
+	/*4259*/ uint16(xMatch),
+	/*4260*/ uint16(xSetOp), uint16(SUBSD),
+	/*4262*/ uint16(xReadSlashR),
+	/*4263*/ uint16(xArgXmm1),
+	/*4264*/ uint16(xArgXmm2M64),
+	/*4265*/ uint16(xMatch),
+	/*4266*/ uint16(xSetOp), uint16(SUBSS),
+	/*4268*/ uint16(xReadSlashR),
+	/*4269*/ uint16(xArgXmm1),
+	/*4270*/ uint16(xArgXmm2M32),
+	/*4271*/ uint16(xMatch),
+	/*4272*/ uint16(xCondPrefix), 4,
+	0xF3, 4300,
+	0xF2, 4294,
+	0x66, 4288,
+	0x0, 4282,
+	/*4282*/ uint16(xSetOp), uint16(MINPS),
+	/*4284*/ uint16(xReadSlashR),
+	/*4285*/ uint16(xArgXmm1),
+	/*4286*/ uint16(xArgXmm2M128),
+	/*4287*/ uint16(xMatch),
+	/*4288*/ uint16(xSetOp), uint16(MINPD),
+	/*4290*/ uint16(xReadSlashR),
+	/*4291*/ uint16(xArgXmm1),
+	/*4292*/ uint16(xArgXmm2M128),
+	/*4293*/ uint16(xMatch),
+	/*4294*/ uint16(xSetOp), uint16(MINSD),
+	/*4296*/ uint16(xReadSlashR),
+	/*4297*/ uint16(xArgXmm1),
+	/*4298*/ uint16(xArgXmm2M64),
+	/*4299*/ uint16(xMatch),
+	/*4300*/ uint16(xSetOp), uint16(MINSS),
+	/*4302*/ uint16(xReadSlashR),
+	/*4303*/ uint16(xArgXmm1),
+	/*4304*/ uint16(xArgXmm2M32),
+	/*4305*/ uint16(xMatch),
+	/*4306*/ uint16(xCondPrefix), 4,
+	0xF3, 4334,
+	0xF2, 4328,
+	0x66, 4322,
+	0x0, 4316,
+	/*4316*/ uint16(xSetOp), uint16(DIVPS),
+	/*4318*/ uint16(xReadSlashR),
+	/*4319*/ uint16(xArgXmm1),
+	/*4320*/ uint16(xArgXmm2M128),
+	/*4321*/ uint16(xMatch),
+	/*4322*/ uint16(xSetOp), uint16(DIVPD),
+	/*4324*/ uint16(xReadSlashR),
+	/*4325*/ uint16(xArgXmm1),
+	/*4326*/ uint16(xArgXmm2M128),
+	/*4327*/ uint16(xMatch),
+	/*4328*/ uint16(xSetOp), uint16(DIVSD),
+	/*4330*/ uint16(xReadSlashR),
+	/*4331*/ uint16(xArgXmm1),
+	/*4332*/ uint16(xArgXmm2M64),
+	/*4333*/ uint16(xMatch),
+	/*4334*/ uint16(xSetOp), uint16(DIVSS),
+	/*4336*/ uint16(xReadSlashR),
+	/*4337*/ uint16(xArgXmm1),
+	/*4338*/ uint16(xArgXmm2M32),
+	/*4339*/ uint16(xMatch),
+	/*4340*/ uint16(xCondPrefix), 4,
+	0xF3, 4368,
+	0xF2, 4362,
+	0x66, 4356,
+	0x0, 4350,
+	/*4350*/ uint16(xSetOp), uint16(MAXPS),
+	/*4352*/ uint16(xReadSlashR),
+	/*4353*/ uint16(xArgXmm1),
+	/*4354*/ uint16(xArgXmm2M128),
+	/*4355*/ uint16(xMatch),
+	/*4356*/ uint16(xSetOp), uint16(MAXPD),
+	/*4358*/ uint16(xReadSlashR),
+	/*4359*/ uint16(xArgXmm1),
+	/*4360*/ uint16(xArgXmm2M128),
+	/*4361*/ uint16(xMatch),
+	/*4362*/ uint16(xSetOp), uint16(MAXSD),
+	/*4364*/ uint16(xReadSlashR),
+	/*4365*/ uint16(xArgXmm1),
+	/*4366*/ uint16(xArgXmm2M64),
+	/*4367*/ uint16(xMatch),
+	/*4368*/ uint16(xSetOp), uint16(MAXSS),
+	/*4370*/ uint16(xReadSlashR),
+	/*4371*/ uint16(xArgXmm1),
+	/*4372*/ uint16(xArgXmm2M32),
+	/*4373*/ uint16(xMatch),
+	/*4374*/ uint16(xCondPrefix), 2,
+	0x66, 4386,
+	0x0, 4380,
+	/*4380*/ uint16(xSetOp), uint16(PUNPCKLBW),
+	/*4382*/ uint16(xReadSlashR),
+	/*4383*/ uint16(xArgMm),
+	/*4384*/ uint16(xArgMmM32),
+	/*4385*/ uint16(xMatch),
+	/*4386*/ uint16(xSetOp), uint16(PUNPCKLBW),
+	/*4388*/ uint16(xReadSlashR),
+	/*4389*/ uint16(xArgXmm1),
+	/*4390*/ uint16(xArgXmm2M128),
+	/*4391*/ uint16(xMatch),
+	/*4392*/ uint16(xCondPrefix), 2,
+	0x66, 4404,
+	0x0, 4398,
+	/*4398*/ uint16(xSetOp), uint16(PUNPCKLWD),
+	/*4400*/ uint16(xReadSlashR),
+	/*4401*/ uint16(xArgMm),
+	/*4402*/ uint16(xArgMmM32),
+	/*4403*/ uint16(xMatch),
+	/*4404*/ uint16(xSetOp), uint16(PUNPCKLWD),
+	/*4406*/ uint16(xReadSlashR),
+	/*4407*/ uint16(xArgXmm1),
+	/*4408*/ uint16(xArgXmm2M128),
+	/*4409*/ uint16(xMatch),
+	/*4410*/ uint16(xCondPrefix), 2,
+	0x66, 4422,
+	0x0, 4416,
+	/*4416*/ uint16(xSetOp), uint16(PUNPCKLDQ),
+	/*4418*/ uint16(xReadSlashR),
+	/*4419*/ uint16(xArgMm),
+	/*4420*/ uint16(xArgMmM32),
+	/*4421*/ uint16(xMatch),
+	/*4422*/ uint16(xSetOp), uint16(PUNPCKLDQ),
+	/*4424*/ uint16(xReadSlashR),
+	/*4425*/ uint16(xArgXmm1),
+	/*4426*/ uint16(xArgXmm2M128),
+	/*4427*/ uint16(xMatch),
+	/*4428*/ uint16(xCondPrefix), 2,
+	0x66, 4440,
+	0x0, 4434,
+	/*4434*/ uint16(xSetOp), uint16(PACKSSWB),
+	/*4436*/ uint16(xReadSlashR),
+	/*4437*/ uint16(xArgMm1),
+	/*4438*/ uint16(xArgMm2M64),
+	/*4439*/ uint16(xMatch),
+	/*4440*/ uint16(xSetOp), uint16(PACKSSWB),
+	/*4442*/ uint16(xReadSlashR),
+	/*4443*/ uint16(xArgXmm1),
+	/*4444*/ uint16(xArgXmm2M128),
+	/*4445*/ uint16(xMatch),
+	/*4446*/ uint16(xCondPrefix), 2,
+	0x66, 4458,
+	0x0, 4452,
+	/*4452*/ uint16(xSetOp), uint16(PCMPGTB),
+	/*4454*/ uint16(xReadSlashR),
+	/*4455*/ uint16(xArgMm),
+	/*4456*/ uint16(xArgMmM64),
+	/*4457*/ uint16(xMatch),
+	/*4458*/ uint16(xSetOp), uint16(PCMPGTB),
+	/*4460*/ uint16(xReadSlashR),
+	/*4461*/ uint16(xArgXmm1),
+	/*4462*/ uint16(xArgXmm2M128),
+	/*4463*/ uint16(xMatch),
+	/*4464*/ uint16(xCondPrefix), 2,
+	0x66, 4476,
+	0x0, 4470,
+	/*4470*/ uint16(xSetOp), uint16(PCMPGTW),
+	/*4472*/ uint16(xReadSlashR),
+	/*4473*/ uint16(xArgMm),
+	/*4474*/ uint16(xArgMmM64),
+	/*4475*/ uint16(xMatch),
+	/*4476*/ uint16(xSetOp), uint16(PCMPGTW),
+	/*4478*/ uint16(xReadSlashR),
+	/*4479*/ uint16(xArgXmm1),
+	/*4480*/ uint16(xArgXmm2M128),
+	/*4481*/ uint16(xMatch),
+	/*4482*/ uint16(xCondPrefix), 2,
+	0x66, 4494,
+	0x0, 4488,
+	/*4488*/ uint16(xSetOp), uint16(PCMPGTD),
+	/*4490*/ uint16(xReadSlashR),
+	/*4491*/ uint16(xArgMm),
+	/*4492*/ uint16(xArgMmM64),
+	/*4493*/ uint16(xMatch),
+	/*4494*/ uint16(xSetOp), uint16(PCMPGTD),
+	/*4496*/ uint16(xReadSlashR),
+	/*4497*/ uint16(xArgXmm1),
+	/*4498*/ uint16(xArgXmm2M128),
+	/*4499*/ uint16(xMatch),
+	/*4500*/ uint16(xCondPrefix), 2,
+	0x66, 4512,
+	0x0, 4506,
+	/*4506*/ uint16(xSetOp), uint16(PACKUSWB),
+	/*4508*/ uint16(xReadSlashR),
+	/*4509*/ uint16(xArgMm),
+	/*4510*/ uint16(xArgMmM64),
+	/*4511*/ uint16(xMatch),
+	/*4512*/ uint16(xSetOp), uint16(PACKUSWB),
+	/*4514*/ uint16(xReadSlashR),
+	/*4515*/ uint16(xArgXmm1),
+	/*4516*/ uint16(xArgXmm2M128),
+	/*4517*/ uint16(xMatch),
+	/*4518*/ uint16(xCondPrefix), 2,
+	0x66, 4530,
+	0x0, 4524,
+	/*4524*/ uint16(xSetOp), uint16(PUNPCKHBW),
+	/*4526*/ uint16(xReadSlashR),
+	/*4527*/ uint16(xArgMm),
+	/*4528*/ uint16(xArgMmM64),
+	/*4529*/ uint16(xMatch),
+	/*4530*/ uint16(xSetOp), uint16(PUNPCKHBW),
+	/*4532*/ uint16(xReadSlashR),
+	/*4533*/ uint16(xArgXmm1),
+	/*4534*/ uint16(xArgXmm2M128),
+	/*4535*/ uint16(xMatch),
+	/*4536*/ uint16(xCondPrefix), 2,
+	0x66, 4548,
+	0x0, 4542,
+	/*4542*/ uint16(xSetOp), uint16(PUNPCKHWD),
+	/*4544*/ uint16(xReadSlashR),
+	/*4545*/ uint16(xArgMm),
+	/*4546*/ uint16(xArgMmM64),
+	/*4547*/ uint16(xMatch),
+	/*4548*/ uint16(xSetOp), uint16(PUNPCKHWD),
+	/*4550*/ uint16(xReadSlashR),
+	/*4551*/ uint16(xArgXmm1),
+	/*4552*/ uint16(xArgXmm2M128),
+	/*4553*/ uint16(xMatch),
+	/*4554*/ uint16(xCondPrefix), 2,
+	0x66, 4566,
+	0x0, 4560,
+	/*4560*/ uint16(xSetOp), uint16(PUNPCKHDQ),
+	/*4562*/ uint16(xReadSlashR),
+	/*4563*/ uint16(xArgMm),
+	/*4564*/ uint16(xArgMmM64),
+	/*4565*/ uint16(xMatch),
+	/*4566*/ uint16(xSetOp), uint16(PUNPCKHDQ),
+	/*4568*/ uint16(xReadSlashR),
+	/*4569*/ uint16(xArgXmm1),
+	/*4570*/ uint16(xArgXmm2M128),
+	/*4571*/ uint16(xMatch),
+	/*4572*/ uint16(xCondPrefix), 2,
+	0x66, 4584,
+	0x0, 4578,
+	/*4578*/ uint16(xSetOp), uint16(PACKSSDW),
+	/*4580*/ uint16(xReadSlashR),
+	/*4581*/ uint16(xArgMm1),
+	/*4582*/ uint16(xArgMm2M64),
+	/*4583*/ uint16(xMatch),
+	/*4584*/ uint16(xSetOp), uint16(PACKSSDW),
+	/*4586*/ uint16(xReadSlashR),
+	/*4587*/ uint16(xArgXmm1),
+	/*4588*/ uint16(xArgXmm2M128),
+	/*4589*/ uint16(xMatch),
+	/*4590*/ uint16(xCondPrefix), 1,
+	0x66, 4594,
+	/*4594*/ uint16(xSetOp), uint16(PUNPCKLQDQ),
+	/*4596*/ uint16(xReadSlashR),
+	/*4597*/ uint16(xArgXmm1),
+	/*4598*/ uint16(xArgXmm2M128),
+	/*4599*/ uint16(xMatch),
+	/*4600*/ uint16(xCondPrefix), 1,
+	0x66, 4604,
+	/*4604*/ uint16(xSetOp), uint16(PUNPCKHQDQ),
+	/*4606*/ uint16(xReadSlashR),
+	/*4607*/ uint16(xArgXmm1),
+	/*4608*/ uint16(xArgXmm2M128),
+	/*4609*/ uint16(xMatch),
+	/*4610*/ uint16(xCondIs64), 4613, 4651,
+	/*4613*/ uint16(xCondPrefix), 2,
+	0x66, 4635,
+	0x0, 4619,
+	/*4619*/ uint16(xCondDataSize), 4623, 4629, 0,
+	/*4623*/ uint16(xSetOp), uint16(MOVD),
+	/*4625*/ uint16(xReadSlashR),
+	/*4626*/ uint16(xArgMm),
+	/*4627*/ uint16(xArgRM32),
+	/*4628*/ uint16(xMatch),
+	/*4629*/ uint16(xSetOp), uint16(MOVD),
+	/*4631*/ uint16(xReadSlashR),
+	/*4632*/ uint16(xArgMm),
+	/*4633*/ uint16(xArgRM32),
+	/*4634*/ uint16(xMatch),
+	/*4635*/ uint16(xCondDataSize), 4639, 4645, 0,
+	/*4639*/ uint16(xSetOp), uint16(MOVD),
+	/*4641*/ uint16(xReadSlashR),
+	/*4642*/ uint16(xArgXmm),
+	/*4643*/ uint16(xArgRM32),
+	/*4644*/ uint16(xMatch),
+	/*4645*/ uint16(xSetOp), uint16(MOVD),
+	/*4647*/ uint16(xReadSlashR),
+	/*4648*/ uint16(xArgXmm),
+	/*4649*/ uint16(xArgRM32),
+	/*4650*/ uint16(xMatch),
+	/*4651*/ uint16(xCondPrefix), 2,
+	0x66, 4667,
+	0x0, 4657,
+	/*4657*/ uint16(xCondDataSize), 4623, 4629, 4661,
+	/*4661*/ uint16(xSetOp), uint16(MOVQ),
+	/*4663*/ uint16(xReadSlashR),
+	/*4664*/ uint16(xArgMm),
+	/*4665*/ uint16(xArgRM64),
+	/*4666*/ uint16(xMatch),
+	/*4667*/ uint16(xCondDataSize), 4639, 4645, 4671,
+	/*4671*/ uint16(xSetOp), uint16(MOVQ),
+	/*4673*/ uint16(xReadSlashR),
+	/*4674*/ uint16(xArgXmm),
+	/*4675*/ uint16(xArgRM64),
+	/*4676*/ uint16(xMatch),
+	/*4677*/ uint16(xCondPrefix), 3,
+	0xF3, 4697,
+	0x66, 4691,
+	0x0, 4685,
+	/*4685*/ uint16(xSetOp), uint16(MOVQ),
+	/*4687*/ uint16(xReadSlashR),
+	/*4688*/ uint16(xArgMm),
+	/*4689*/ uint16(xArgMmM64),
+	/*4690*/ uint16(xMatch),
+	/*4691*/ uint16(xSetOp), uint16(MOVDQA),
+	/*4693*/ uint16(xReadSlashR),
+	/*4694*/ uint16(xArgXmm1),
+	/*4695*/ uint16(xArgXmm2M128),
+	/*4696*/ uint16(xMatch),
+	/*4697*/ uint16(xSetOp), uint16(MOVDQU),
+	/*4699*/ uint16(xReadSlashR),
+	/*4700*/ uint16(xArgXmm1),
+	/*4701*/ uint16(xArgXmm2M128),
+	/*4702*/ uint16(xMatch),
+	/*4703*/ uint16(xCondPrefix), 4,
+	0xF3, 4737,
+	0xF2, 4729,
+	0x66, 4721,
+	0x0, 4713,
+	/*4713*/ uint16(xSetOp), uint16(PSHUFW),
+	/*4715*/ uint16(xReadSlashR),
+	/*4716*/ uint16(xReadIb),
+	/*4717*/ uint16(xArgMm1),
+	/*4718*/ uint16(xArgMm2M64),
+	/*4719*/ uint16(xArgImm8u),
+	/*4720*/ uint16(xMatch),
+	/*4721*/ uint16(xSetOp), uint16(PSHUFD),
+	/*4723*/ uint16(xReadSlashR),
+	/*4724*/ uint16(xReadIb),
+	/*4725*/ uint16(xArgXmm1),
+	/*4726*/ uint16(xArgXmm2M128),
+	/*4727*/ uint16(xArgImm8u),
+	/*4728*/ uint16(xMatch),
+	/*4729*/ uint16(xSetOp), uint16(PSHUFLW),
+	/*4731*/ uint16(xReadSlashR),
+	/*4732*/ uint16(xReadIb),
+	/*4733*/ uint16(xArgXmm1),
+	/*4734*/ uint16(xArgXmm2M128),
+	/*4735*/ uint16(xArgImm8u),
+	/*4736*/ uint16(xMatch),
+	/*4737*/ uint16(xSetOp), uint16(PSHUFHW),
+	/*4739*/ uint16(xReadSlashR),
+	/*4740*/ uint16(xReadIb),
+	/*4741*/ uint16(xArgXmm1),
+	/*4742*/ uint16(xArgXmm2M128),
+	/*4743*/ uint16(xArgImm8u),
+	/*4744*/ uint16(xMatch),
+	/*4745*/ uint16(xCondSlashR),
 	0,    // 0
 	0,    // 1
-	4752, // 2
+	4754, // 2
 	0,    // 3
-	4770, // 4
+	4772, // 4
 	0,    // 5
-	4788, // 6
+	4790, // 6
 	0,    // 7
-	/*4752*/ uint16(xCondPrefix), 2,
-	0x66, 4764,
-	0x0, 4758,
-	/*4758*/ uint16(xSetOp), uint16(PSRLW),
-	/*4760*/ uint16(xReadIb),
-	/*4761*/ uint16(xArgMm2),
-	/*4762*/ uint16(xArgImm8u),
-	/*4763*/ uint16(xMatch),
-	/*4764*/ uint16(xSetOp), uint16(PSRLW),
-	/*4766*/ uint16(xReadIb),
-	/*4767*/ uint16(xArgXmm2),
-	/*4768*/ uint16(xArgImm8u),
-	/*4769*/ uint16(xMatch),
-	/*4770*/ uint16(xCondPrefix), 2,
-	0x66, 4782,
-	0x0, 4776,
-	/*4776*/ uint16(xSetOp), uint16(PSRAW),
-	/*4778*/ uint16(xReadIb),
-	/*4779*/ uint16(xArgMm2),
-	/*4780*/ uint16(xArgImm8u),
-	/*4781*/ uint16(xMatch),
-	/*4782*/ uint16(xSetOp), uint16(PSRAW),
-	/*4784*/ uint16(xReadIb),
-	/*4785*/ uint16(xArgXmm2),
-	/*4786*/ uint16(xArgImm8u),
-	/*4787*/ uint16(xMatch),
-	/*4788*/ uint16(xCondPrefix), 2,
-	0x66, 4800,
-	0x0, 4794,
-	/*4794*/ uint16(xSetOp), uint16(PSLLW),
-	/*4796*/ uint16(xReadIb),
-	/*4797*/ uint16(xArgMm2),
-	/*4798*/ uint16(xArgImm8u),
-	/*4799*/ uint16(xMatch),
-	/*4800*/ uint16(xSetOp), uint16(PSLLW),
-	/*4802*/ uint16(xReadIb),
-	/*4803*/ uint16(xArgXmm2),
-	/*4804*/ uint16(xArgImm8u),
-	/*4805*/ uint16(xMatch),
-	/*4806*/ uint16(xCondSlashR),
+	/*4754*/ uint16(xCondPrefix), 2,
+	0x66, 4766,
+	0x0, 4760,
+	/*4760*/ uint16(xSetOp), uint16(PSRLW),
+	/*4762*/ uint16(xReadIb),
+	/*4763*/ uint16(xArgMm2),
+	/*4764*/ uint16(xArgImm8u),
+	/*4765*/ uint16(xMatch),
+	/*4766*/ uint16(xSetOp), uint16(PSRLW),
+	/*4768*/ uint16(xReadIb),
+	/*4769*/ uint16(xArgXmm2),
+	/*4770*/ uint16(xArgImm8u),
+	/*4771*/ uint16(xMatch),
+	/*4772*/ uint16(xCondPrefix), 2,
+	0x66, 4784,
+	0x0, 4778,
+	/*4778*/ uint16(xSetOp), uint16(PSRAW),
+	/*4780*/ uint16(xReadIb),
+	/*4781*/ uint16(xArgMm2),
+	/*4782*/ uint16(xArgImm8u),
+	/*4783*/ uint16(xMatch),
+	/*4784*/ uint16(xSetOp), uint16(PSRAW),
+	/*4786*/ uint16(xReadIb),
+	/*4787*/ uint16(xArgXmm2),
+	/*4788*/ uint16(xArgImm8u),
+	/*4789*/ uint16(xMatch),
+	/*4790*/ uint16(xCondPrefix), 2,
+	0x66, 4802,
+	0x0, 4796,
+	/*4796*/ uint16(xSetOp), uint16(PSLLW),
+	/*4798*/ uint16(xReadIb),
+	/*4799*/ uint16(xArgMm2),
+	/*4800*/ uint16(xArgImm8u),
+	/*4801*/ uint16(xMatch),
+	/*4802*/ uint16(xSetOp), uint16(PSLLW),
+	/*4804*/ uint16(xReadIb),
+	/*4805*/ uint16(xArgXmm2),
+	/*4806*/ uint16(xArgImm8u),
+	/*4807*/ uint16(xMatch),
+	/*4808*/ uint16(xCondSlashR),
 	0,    // 0
 	0,    // 1
-	4815, // 2
+	4817, // 2
 	0,    // 3
-	4833, // 4
+	4835, // 4
 	0,    // 5
-	4851, // 6
+	4853, // 6
 	0,    // 7
-	/*4815*/ uint16(xCondPrefix), 2,
-	0x66, 4827,
-	0x0, 4821,
-	/*4821*/ uint16(xSetOp), uint16(PSRLD),
-	/*4823*/ uint16(xReadIb),
-	/*4824*/ uint16(xArgMm2),
-	/*4825*/ uint16(xArgImm8u),
-	/*4826*/ uint16(xMatch),
-	/*4827*/ uint16(xSetOp), uint16(PSRLD),
-	/*4829*/ uint16(xReadIb),
-	/*4830*/ uint16(xArgXmm2),
-	/*4831*/ uint16(xArgImm8u),
-	/*4832*/ uint16(xMatch),
-	/*4833*/ uint16(xCondPrefix), 2,
-	0x66, 4845,
-	0x0, 4839,
-	/*4839*/ uint16(xSetOp), uint16(PSRAD),
-	/*4841*/ uint16(xReadIb),
-	/*4842*/ uint16(xArgMm2),
-	/*4843*/ uint16(xArgImm8u),
-	/*4844*/ uint16(xMatch),
-	/*4845*/ uint16(xSetOp), uint16(PSRAD),
-	/*4847*/ uint16(xReadIb),
-	/*4848*/ uint16(xArgXmm2),
-	/*4849*/ uint16(xArgImm8u),
-	/*4850*/ uint16(xMatch),
-	/*4851*/ uint16(xCondPrefix), 2,
-	0x66, 4863,
-	0x0, 4857,
-	/*4857*/ uint16(xSetOp), uint16(PSLLD),
-	/*4859*/ uint16(xReadIb),
-	/*4860*/ uint16(xArgMm2),
-	/*4861*/ uint16(xArgImm8u),
-	/*4862*/ uint16(xMatch),
-	/*4863*/ uint16(xSetOp), uint16(PSLLD),
-	/*4865*/ uint16(xReadIb),
-	/*4866*/ uint16(xArgXmm2),
-	/*4867*/ uint16(xArgImm8u),
-	/*4868*/ uint16(xMatch),
-	/*4869*/ uint16(xCondSlashR),
+	/*4817*/ uint16(xCondPrefix), 2,
+	0x66, 4829,
+	0x0, 4823,
+	/*4823*/ uint16(xSetOp), uint16(PSRLD),
+	/*4825*/ uint16(xReadIb),
+	/*4826*/ uint16(xArgMm2),
+	/*4827*/ uint16(xArgImm8u),
+	/*4828*/ uint16(xMatch),
+	/*4829*/ uint16(xSetOp), uint16(PSRLD),
+	/*4831*/ uint16(xReadIb),
+	/*4832*/ uint16(xArgXmm2),
+	/*4833*/ uint16(xArgImm8u),
+	/*4834*/ uint16(xMatch),
+	/*4835*/ uint16(xCondPrefix), 2,
+	0x66, 4847,
+	0x0, 4841,
+	/*4841*/ uint16(xSetOp), uint16(PSRAD),
+	/*4843*/ uint16(xReadIb),
+	/*4844*/ uint16(xArgMm2),
+	/*4845*/ uint16(xArgImm8u),
+	/*4846*/ uint16(xMatch),
+	/*4847*/ uint16(xSetOp), uint16(PSRAD),
+	/*4849*/ uint16(xReadIb),
+	/*4850*/ uint16(xArgXmm2),
+	/*4851*/ uint16(xArgImm8u),
+	/*4852*/ uint16(xMatch),
+	/*4853*/ uint16(xCondPrefix), 2,
+	0x66, 4865,
+	0x0, 4859,
+	/*4859*/ uint16(xSetOp), uint16(PSLLD),
+	/*4861*/ uint16(xReadIb),
+	/*4862*/ uint16(xArgMm2),
+	/*4863*/ uint16(xArgImm8u),
+	/*4864*/ uint16(xMatch),
+	/*4865*/ uint16(xSetOp), uint16(PSLLD),
+	/*4867*/ uint16(xReadIb),
+	/*4868*/ uint16(xArgXmm2),
+	/*4869*/ uint16(xArgImm8u),
+	/*4870*/ uint16(xMatch),
+	/*4871*/ uint16(xCondSlashR),
 	0,    // 0
 	0,    // 1
-	4878, // 2
-	4896, // 3
+	4880, // 2
+	4898, // 3
 	0,    // 4
 	0,    // 5
-	4906, // 6
-	4924, // 7
-	/*4878*/ uint16(xCondPrefix), 2,
-	0x66, 4890,
-	0x0, 4884,
-	/*4884*/ uint16(xSetOp), uint16(PSRLQ),
-	/*4886*/ uint16(xReadIb),
-	/*4887*/ uint16(xArgMm2),
-	/*4888*/ uint16(xArgImm8u),
-	/*4889*/ uint16(xMatch),
-	/*4890*/ uint16(xSetOp), uint16(PSRLQ),
-	/*4892*/ uint16(xReadIb),
-	/*4893*/ uint16(xArgXmm2),
-	/*4894*/ uint16(xArgImm8u),
-	/*4895*/ uint16(xMatch),
-	/*4896*/ uint16(xCondPrefix), 1,
-	0x66, 4900,
-	/*4900*/ uint16(xSetOp), uint16(PSRLDQ),
-	/*4902*/ uint16(xReadIb),
-	/*4903*/ uint16(xArgXmm2),
-	/*4904*/ uint16(xArgImm8u),
-	/*4905*/ uint16(xMatch),
-	/*4906*/ uint16(xCondPrefix), 2,
-	0x66, 4918,
-	0x0, 4912,
-	/*4912*/ uint16(xSetOp), uint16(PSLLQ),
-	/*4914*/ uint16(xReadIb),
-	/*4915*/ uint16(xArgMm2),
-	/*4916*/ uint16(xArgImm8u),
-	/*4917*/ uint16(xMatch),
-	/*4918*/ uint16(xSetOp), uint16(PSLLQ),
-	/*4920*/ uint16(xReadIb),
-	/*4921*/ uint16(xArgXmm2),
-	/*4922*/ uint16(xArgImm8u),
-	/*4923*/ uint16(xMatch),
-	/*4924*/ uint16(xCondPrefix), 1,
-	0x66, 4928,
-	/*4928*/ uint16(xSetOp), uint16(PSLLDQ),
-	/*4930*/ uint16(xReadIb),
-	/*4931*/ uint16(xArgXmm2),
-	/*4932*/ uint16(xArgImm8u),
-	/*4933*/ uint16(xMatch),
-	/*4934*/ uint16(xCondPrefix), 2,
-	0x66, 4946,
-	0x0, 4940,
-	/*4940*/ uint16(xSetOp), uint16(PCMPEQB),
-	/*4942*/ uint16(xReadSlashR),
-	/*4943*/ uint16(xArgMm),
-	/*4944*/ uint16(xArgMmM64),
-	/*4945*/ uint16(xMatch),
-	/*4946*/ uint16(xSetOp), uint16(PCMPEQB),
-	/*4948*/ uint16(xReadSlashR),
-	/*4949*/ uint16(xArgXmm1),
-	/*4950*/ uint16(xArgXmm2M128),
-	/*4951*/ uint16(xMatch),
-	/*4952*/ uint16(xCondPrefix), 2,
-	0x66, 4964,
-	0x0, 4958,
-	/*4958*/ uint16(xSetOp), uint16(PCMPEQW),
-	/*4960*/ uint16(xReadSlashR),
-	/*4961*/ uint16(xArgMm),
-	/*4962*/ uint16(xArgMmM64),
-	/*4963*/ uint16(xMatch),
-	/*4964*/ uint16(xSetOp), uint16(PCMPEQW),
-	/*4966*/ uint16(xReadSlashR),
-	/*4967*/ uint16(xArgXmm1),
-	/*4968*/ uint16(xArgXmm2M128),
-	/*4969*/ uint16(xMatch),
-	/*4970*/ uint16(xCondPrefix), 2,
-	0x66, 4982,
-	0x0, 4976,
-	/*4976*/ uint16(xSetOp), uint16(PCMPEQD),
-	/*4978*/ uint16(xReadSlashR),
-	/*4979*/ uint16(xArgMm),
-	/*4980*/ uint16(xArgMmM64),
-	/*4981*/ uint16(xMatch),
-	/*4982*/ uint16(xSetOp), uint16(PCMPEQD),
-	/*4984*/ uint16(xReadSlashR),
-	/*4985*/ uint16(xArgXmm1),
-	/*4986*/ uint16(xArgXmm2M128),
-	/*4987*/ uint16(xMatch),
-	/*4988*/ uint16(xSetOp), uint16(EMMS),
-	/*4990*/ uint16(xMatch),
-	/*4991*/ uint16(xCondPrefix), 2,
-	0xF2, 5003,
-	0x66, 4997,
-	/*4997*/ uint16(xSetOp), uint16(HADDPD),
-	/*4999*/ uint16(xReadSlashR),
-	/*5000*/ uint16(xArgXmm1),
-	/*5001*/ uint16(xArgXmm2M128),
-	/*5002*/ uint16(xMatch),
-	/*5003*/ uint16(xSetOp), uint16(HADDPS),
-	/*5005*/ uint16(xReadSlashR),
-	/*5006*/ uint16(xArgXmm1),
-	/*5007*/ uint16(xArgXmm2M128),
-	/*5008*/ uint16(xMatch),
-	/*5009*/ uint16(xCondPrefix), 2,
-	0xF2, 5021,
-	0x66, 5015,
-	/*5015*/ uint16(xSetOp), uint16(HSUBPD),
-	/*5017*/ uint16(xReadSlashR),
-	/*5018*/ uint16(xArgXmm1),
-	/*5019*/ uint16(xArgXmm2M128),
-	/*5020*/ uint16(xMatch),
-	/*5021*/ uint16(xSetOp), uint16(HSUBPS),
-	/*5023*/ uint16(xReadSlashR),
-	/*5024*/ uint16(xArgXmm1),
-	/*5025*/ uint16(xArgXmm2M128),
-	/*5026*/ uint16(xMatch),
-	/*5027*/ uint16(xCondIs64), 5030, 5076,
-	/*5030*/ uint16(xCondPrefix), 3,
-	0xF3, 5070,
-	0x66, 5054,
-	0x0, 5038,
-	/*5038*/ uint16(xCondDataSize), 5042, 5048, 0,
-	/*5042*/ uint16(xSetOp), uint16(MOVD),
-	/*5044*/ uint16(xReadSlashR),
-	/*5045*/ uint16(xArgRM32),
-	/*5046*/ uint16(xArgMm),
-	/*5047*/ uint16(xMatch),
-	/*5048*/ uint16(xSetOp), uint16(MOVD),
-	/*5050*/ uint16(xReadSlashR),
-	/*5051*/ uint16(xArgRM32),
-	/*5052*/ uint16(xArgMm),
-	/*5053*/ uint16(xMatch),
-	/*5054*/ uint16(xCondDataSize), 5058, 5064, 0,
-	/*5058*/ uint16(xSetOp), uint16(MOVD),
-	/*5060*/ uint16(xReadSlashR),
-	/*5061*/ uint16(xArgRM32),
-	/*5062*/ uint16(xArgXmm),
-	/*5063*/ uint16(xMatch),
-	/*5064*/ uint16(xSetOp), uint16(MOVD),
-	/*5066*/ uint16(xReadSlashR),
-	/*5067*/ uint16(xArgRM32),
-	/*5068*/ uint16(xArgXmm),
-	/*5069*/ uint16(xMatch),
-	/*5070*/ uint16(xSetOp), uint16(MOVQ),
-	/*5072*/ uint16(xReadSlashR),
-	/*5073*/ uint16(xArgXmm1),
-	/*5074*/ uint16(xArgXmm2M64),
-	/*5075*/ uint16(xMatch),
-	/*5076*/ uint16(xCondPrefix), 3,
-	0xF3, 5070,
-	0x66, 5094,
-	0x0, 5084,
-	/*5084*/ uint16(xCondDataSize), 5042, 5048, 5088,
-	/*5088*/ uint16(xSetOp), uint16(MOVQ),
-	/*5090*/ uint16(xReadSlashR),
-	/*5091*/ uint16(xArgRM64),
-	/*5092*/ uint16(xArgMm),
-	/*5093*/ uint16(xMatch),
-	/*5094*/ uint16(xCondDataSize), 5058, 5064, 5098,
-	/*5098*/ uint16(xSetOp), uint16(MOVQ),
-	/*5100*/ uint16(xReadSlashR),
-	/*5101*/ uint16(xArgRM64),
-	/*5102*/ uint16(xArgXmm),
-	/*5103*/ uint16(xMatch),
-	/*5104*/ uint16(xCondPrefix), 3,
-	0xF3, 5124,
-	0x66, 5118,
-	0x0, 5112,
-	/*5112*/ uint16(xSetOp), uint16(MOVQ),
-	/*5114*/ uint16(xReadSlashR),
-	/*5115*/ uint16(xArgMmM64),
-	/*5116*/ uint16(xArgMm),
-	/*5117*/ uint16(xMatch),
-	/*5118*/ uint16(xSetOp), uint16(MOVDQA),
-	/*5120*/ uint16(xReadSlashR),
-	/*5121*/ uint16(xArgXmm2M128),
-	/*5122*/ uint16(xArgXmm1),
-	/*5123*/ uint16(xMatch),
-	/*5124*/ uint16(xSetOp), uint16(MOVDQU),
-	/*5126*/ uint16(xReadSlashR),
-	/*5127*/ uint16(xArgXmm2M128),
-	/*5128*/ uint16(xArgXmm1),
-	/*5129*/ uint16(xMatch),
-	/*5130*/ uint16(xCondIs64), 5133, 5147,
-	/*5133*/ uint16(xCondDataSize), 5137, 5142, 0,
-	/*5137*/ uint16(xSetOp), uint16(JO),
-	/*5139*/ uint16(xReadCw),
-	/*5140*/ uint16(xArgRel16),
-	/*5141*/ uint16(xMatch),
-	/*5142*/ uint16(xSetOp), uint16(JO),
-	/*5144*/ uint16(xReadCd),
-	/*5145*/ uint16(xArgRel32),
-	/*5146*/ uint16(xMatch),
-	/*5147*/ uint16(xCondDataSize), 5151, 5142, 5156,
-	/*5151*/ uint16(xSetOp), uint16(JO),
-	/*5153*/ uint16(xReadCd),
-	/*5154*/ uint16(xArgRel32),
-	/*5155*/ uint16(xMatch),
-	/*5156*/ uint16(xSetOp), uint16(JO),
-	/*5158*/ uint16(xReadCd),
-	/*5159*/ uint16(xArgRel32),
-	/*5160*/ uint16(xMatch),
-	/*5161*/ uint16(xCondIs64), 5164, 5178,
-	/*5164*/ uint16(xCondDataSize), 5168, 5173, 0,
-	/*5168*/ uint16(xSetOp), uint16(JNO),
-	/*5170*/ uint16(xReadCw),
-	/*5171*/ uint16(xArgRel16),
-	/*5172*/ uint16(xMatch),
-	/*5173*/ uint16(xSetOp), uint16(JNO),
-	/*5175*/ uint16(xReadCd),
-	/*5176*/ uint16(xArgRel32),
-	/*5177*/ uint16(xMatch),
-	/*5178*/ uint16(xCondDataSize), 5182, 5173, 5187,
-	/*5182*/ uint16(xSetOp), uint16(JNO),
-	/*5184*/ uint16(xReadCd),
-	/*5185*/ uint16(xArgRel32),
-	/*5186*/ uint16(xMatch),
-	/*5187*/ uint16(xSetOp), uint16(JNO),
-	/*5189*/ uint16(xReadCd),
-	/*5190*/ uint16(xArgRel32),
-	/*5191*/ uint16(xMatch),
-	/*5192*/ uint16(xCondIs64), 5195, 5209,
-	/*5195*/ uint16(xCondDataSize), 5199, 5204, 0,
-	/*5199*/ uint16(xSetOp), uint16(JB),
-	/*5201*/ uint16(xReadCw),
-	/*5202*/ uint16(xArgRel16),
-	/*5203*/ uint16(xMatch),
-	/*5204*/ uint16(xSetOp), uint16(JB),
-	/*5206*/ uint16(xReadCd),
-	/*5207*/ uint16(xArgRel32),
-	/*5208*/ uint16(xMatch),
-	/*5209*/ uint16(xCondDataSize), 5213, 5204, 5218,
-	/*5213*/ uint16(xSetOp), uint16(JB),
-	/*5215*/ uint16(xReadCd),
-	/*5216*/ uint16(xArgRel32),
-	/*5217*/ uint16(xMatch),
-	/*5218*/ uint16(xSetOp), uint16(JB),
-	/*5220*/ uint16(xReadCd),
-	/*5221*/ uint16(xArgRel32),
-	/*5222*/ uint16(xMatch),
-	/*5223*/ uint16(xCondIs64), 5226, 5240,
-	/*5226*/ uint16(xCondDataSize), 5230, 5235, 0,
-	/*5230*/ uint16(xSetOp), uint16(JAE),
-	/*5232*/ uint16(xReadCw),
-	/*5233*/ uint16(xArgRel16),
-	/*5234*/ uint16(xMatch),
-	/*5235*/ uint16(xSetOp), uint16(JAE),
-	/*5237*/ uint16(xReadCd),
-	/*5238*/ uint16(xArgRel32),
-	/*5239*/ uint16(xMatch),
-	/*5240*/ uint16(xCondDataSize), 5244, 5235, 5249,
-	/*5244*/ uint16(xSetOp), uint16(JAE),
-	/*5246*/ uint16(xReadCd),
-	/*5247*/ uint16(xArgRel32),
-	/*5248*/ uint16(xMatch),
-	/*5249*/ uint16(xSetOp), uint16(JAE),
-	/*5251*/ uint16(xReadCd),
-	/*5252*/ uint16(xArgRel32),
-	/*5253*/ uint16(xMatch),
-	/*5254*/ uint16(xCondIs64), 5257, 5271,
-	/*5257*/ uint16(xCondDataSize), 5261, 5266, 0,
-	/*5261*/ uint16(xSetOp), uint16(JE),
-	/*5263*/ uint16(xReadCw),
-	/*5264*/ uint16(xArgRel16),
-	/*5265*/ uint16(xMatch),
-	/*5266*/ uint16(xSetOp), uint16(JE),
-	/*5268*/ uint16(xReadCd),
-	/*5269*/ uint16(xArgRel32),
-	/*5270*/ uint16(xMatch),
-	/*5271*/ uint16(xCondDataSize), 5275, 5266, 5280,
-	/*5275*/ uint16(xSetOp), uint16(JE),
-	/*5277*/ uint16(xReadCd),
-	/*5278*/ uint16(xArgRel32),
-	/*5279*/ uint16(xMatch),
-	/*5280*/ uint16(xSetOp), uint16(JE),
-	/*5282*/ uint16(xReadCd),
-	/*5283*/ uint16(xArgRel32),
-	/*5284*/ uint16(xMatch),
-	/*5285*/ uint16(xCondIs64), 5288, 5302,
-	/*5288*/ uint16(xCondDataSize), 5292, 5297, 0,
-	/*5292*/ uint16(xSetOp), uint16(JNE),
-	/*5294*/ uint16(xReadCw),
-	/*5295*/ uint16(xArgRel16),
-	/*5296*/ uint16(xMatch),
-	/*5297*/ uint16(xSetOp), uint16(JNE),
-	/*5299*/ uint16(xReadCd),
-	/*5300*/ uint16(xArgRel32),
-	/*5301*/ uint16(xMatch),
-	/*5302*/ uint16(xCondDataSize), 5306, 5297, 5311,
-	/*5306*/ uint16(xSetOp), uint16(JNE),
-	/*5308*/ uint16(xReadCd),
-	/*5309*/ uint16(xArgRel32),
-	/*5310*/ uint16(xMatch),
-	/*5311*/ uint16(xSetOp), uint16(JNE),
-	/*5313*/ uint16(xReadCd),
-	/*5314*/ uint16(xArgRel32),
-	/*5315*/ uint16(xMatch),
-	/*5316*/ uint16(xCondIs64), 5319, 5333,
-	/*5319*/ uint16(xCondDataSize), 5323, 5328, 0,
-	/*5323*/ uint16(xSetOp), uint16(JBE),
-	/*5325*/ uint16(xReadCw),
-	/*5326*/ uint16(xArgRel16),
-	/*5327*/ uint16(xMatch),
-	/*5328*/ uint16(xSetOp), uint16(JBE),
-	/*5330*/ uint16(xReadCd),
-	/*5331*/ uint16(xArgRel32),
-	/*5332*/ uint16(xMatch),
-	/*5333*/ uint16(xCondDataSize), 5337, 5328, 5342,
-	/*5337*/ uint16(xSetOp), uint16(JBE),
-	/*5339*/ uint16(xReadCd),
-	/*5340*/ uint16(xArgRel32),
-	/*5341*/ uint16(xMatch),
-	/*5342*/ uint16(xSetOp), uint16(JBE),
-	/*5344*/ uint16(xReadCd),
-	/*5345*/ uint16(xArgRel32),
-	/*5346*/ uint16(xMatch),
-	/*5347*/ uint16(xCondIs64), 5350, 5364,
-	/*5350*/ uint16(xCondDataSize), 5354, 5359, 0,
-	/*5354*/ uint16(xSetOp), uint16(JA),
-	/*5356*/ uint16(xReadCw),
-	/*5357*/ uint16(xArgRel16),
-	/*5358*/ uint16(xMatch),
-	/*5359*/ uint16(xSetOp), uint16(JA),
-	/*5361*/ uint16(xReadCd),
-	/*5362*/ uint16(xArgRel32),
-	/*5363*/ uint16(xMatch),
-	/*5364*/ uint16(xCondDataSize), 5368, 5359, 5373,
-	/*5368*/ uint16(xSetOp), uint16(JA),
-	/*5370*/ uint16(xReadCd),
-	/*5371*/ uint16(xArgRel32),
-	/*5372*/ uint16(xMatch),
-	/*5373*/ uint16(xSetOp), uint16(JA),
-	/*5375*/ uint16(xReadCd),
-	/*5376*/ uint16(xArgRel32),
-	/*5377*/ uint16(xMatch),
-	/*5378*/ uint16(xCondIs64), 5381, 5395,
-	/*5381*/ uint16(xCondDataSize), 5385, 5390, 0,
-	/*5385*/ uint16(xSetOp), uint16(JS),
-	/*5387*/ uint16(xReadCw),
-	/*5388*/ uint16(xArgRel16),
-	/*5389*/ uint16(xMatch),
-	/*5390*/ uint16(xSetOp), uint16(JS),
-	/*5392*/ uint16(xReadCd),
-	/*5393*/ uint16(xArgRel32),
-	/*5394*/ uint16(xMatch),
-	/*5395*/ uint16(xCondDataSize), 5399, 5390, 5404,
-	/*5399*/ uint16(xSetOp), uint16(JS),
-	/*5401*/ uint16(xReadCd),
-	/*5402*/ uint16(xArgRel32),
-	/*5403*/ uint16(xMatch),
-	/*5404*/ uint16(xSetOp), uint16(JS),
-	/*5406*/ uint16(xReadCd),
-	/*5407*/ uint16(xArgRel32),
-	/*5408*/ uint16(xMatch),
-	/*5409*/ uint16(xCondIs64), 5412, 5426,
-	/*5412*/ uint16(xCondDataSize), 5416, 5421, 0,
-	/*5416*/ uint16(xSetOp), uint16(JNS),
-	/*5418*/ uint16(xReadCw),
-	/*5419*/ uint16(xArgRel16),
-	/*5420*/ uint16(xMatch),
-	/*5421*/ uint16(xSetOp), uint16(JNS),
-	/*5423*/ uint16(xReadCd),
-	/*5424*/ uint16(xArgRel32),
-	/*5425*/ uint16(xMatch),
-	/*5426*/ uint16(xCondDataSize), 5430, 5421, 5435,
-	/*5430*/ uint16(xSetOp), uint16(JNS),
-	/*5432*/ uint16(xReadCd),
-	/*5433*/ uint16(xArgRel32),
-	/*5434*/ uint16(xMatch),
-	/*5435*/ uint16(xSetOp), uint16(JNS),
-	/*5437*/ uint16(xReadCd),
-	/*5438*/ uint16(xArgRel32),
-	/*5439*/ uint16(xMatch),
-	/*5440*/ uint16(xCondIs64), 5443, 5457,
-	/*5443*/ uint16(xCondDataSize), 5447, 5452, 0,
-	/*5447*/ uint16(xSetOp), uint16(JP),
-	/*5449*/ uint16(xReadCw),
-	/*5450*/ uint16(xArgRel16),
-	/*5451*/ uint16(xMatch),
-	/*5452*/ uint16(xSetOp), uint16(JP),
-	/*5454*/ uint16(xReadCd),
-	/*5455*/ uint16(xArgRel32),
-	/*5456*/ uint16(xMatch),
-	/*5457*/ uint16(xCondDataSize), 5461, 5452, 5466,
-	/*5461*/ uint16(xSetOp), uint16(JP),
-	/*5463*/ uint16(xReadCd),
-	/*5464*/ uint16(xArgRel32),
-	/*5465*/ uint16(xMatch),
-	/*5466*/ uint16(xSetOp), uint16(JP),
-	/*5468*/ uint16(xReadCd),
-	/*5469*/ uint16(xArgRel32),
-	/*5470*/ uint16(xMatch),
-	/*5471*/ uint16(xCondIs64), 5474, 5488,
-	/*5474*/ uint16(xCondDataSize), 5478, 5483, 0,
-	/*5478*/ uint16(xSetOp), uint16(JNP),
-	/*5480*/ uint16(xReadCw),
-	/*5481*/ uint16(xArgRel16),
-	/*5482*/ uint16(xMatch),
-	/*5483*/ uint16(xSetOp), uint16(JNP),
-	/*5485*/ uint16(xReadCd),
-	/*5486*/ uint16(xArgRel32),
-	/*5487*/ uint16(xMatch),
-	/*5488*/ uint16(xCondDataSize), 5492, 5483, 5497,
-	/*5492*/ uint16(xSetOp), uint16(JNP),
-	/*5494*/ uint16(xReadCd),
-	/*5495*/ uint16(xArgRel32),
-	/*5496*/ uint16(xMatch),
-	/*5497*/ uint16(xSetOp), uint16(JNP),
-	/*5499*/ uint16(xReadCd),
-	/*5500*/ uint16(xArgRel32),
-	/*5501*/ uint16(xMatch),
-	/*5502*/ uint16(xCondIs64), 5505, 5519,
-	/*5505*/ uint16(xCondDataSize), 5509, 5514, 0,
-	/*5509*/ uint16(xSetOp), uint16(JL),
-	/*5511*/ uint16(xReadCw),
-	/*5512*/ uint16(xArgRel16),
-	/*5513*/ uint16(xMatch),
-	/*5514*/ uint16(xSetOp), uint16(JL),
-	/*5516*/ uint16(xReadCd),
-	/*5517*/ uint16(xArgRel32),
-	/*5518*/ uint16(xMatch),
-	/*5519*/ uint16(xCondDataSize), 5523, 5514, 5528,
-	/*5523*/ uint16(xSetOp), uint16(JL),
-	/*5525*/ uint16(xReadCd),
-	/*5526*/ uint16(xArgRel32),
-	/*5527*/ uint16(xMatch),
-	/*5528*/ uint16(xSetOp), uint16(JL),
-	/*5530*/ uint16(xReadCd),
-	/*5531*/ uint16(xArgRel32),
-	/*5532*/ uint16(xMatch),
-	/*5533*/ uint16(xCondIs64), 5536, 5550,
-	/*5536*/ uint16(xCondDataSize), 5540, 5545, 0,
-	/*5540*/ uint16(xSetOp), uint16(JGE),
-	/*5542*/ uint16(xReadCw),
-	/*5543*/ uint16(xArgRel16),
-	/*5544*/ uint16(xMatch),
-	/*5545*/ uint16(xSetOp), uint16(JGE),
-	/*5547*/ uint16(xReadCd),
-	/*5548*/ uint16(xArgRel32),
-	/*5549*/ uint16(xMatch),
-	/*5550*/ uint16(xCondDataSize), 5554, 5545, 5559,
-	/*5554*/ uint16(xSetOp), uint16(JGE),
-	/*5556*/ uint16(xReadCd),
-	/*5557*/ uint16(xArgRel32),
-	/*5558*/ uint16(xMatch),
-	/*5559*/ uint16(xSetOp), uint16(JGE),
-	/*5561*/ uint16(xReadCd),
-	/*5562*/ uint16(xArgRel32),
-	/*5563*/ uint16(xMatch),
-	/*5564*/ uint16(xCondIs64), 5567, 5581,
-	/*5567*/ uint16(xCondDataSize), 5571, 5576, 0,
-	/*5571*/ uint16(xSetOp), uint16(JLE),
-	/*5573*/ uint16(xReadCw),
-	/*5574*/ uint16(xArgRel16),
-	/*5575*/ uint16(xMatch),
-	/*5576*/ uint16(xSetOp), uint16(JLE),
-	/*5578*/ uint16(xReadCd),
-	/*5579*/ uint16(xArgRel32),
-	/*5580*/ uint16(xMatch),
-	/*5581*/ uint16(xCondDataSize), 5585, 5576, 5590,
-	/*5585*/ uint16(xSetOp), uint16(JLE),
-	/*5587*/ uint16(xReadCd),
-	/*5588*/ uint16(xArgRel32),
-	/*5589*/ uint16(xMatch),
-	/*5590*/ uint16(xSetOp), uint16(JLE),
-	/*5592*/ uint16(xReadCd),
-	/*5593*/ uint16(xArgRel32),
-	/*5594*/ uint16(xMatch),
-	/*5595*/ uint16(xCondIs64), 5598, 5612,
-	/*5598*/ uint16(xCondDataSize), 5602, 5607, 0,
-	/*5602*/ uint16(xSetOp), uint16(JG),
-	/*5604*/ uint16(xReadCw),
-	/*5605*/ uint16(xArgRel16),
-	/*5606*/ uint16(xMatch),
-	/*5607*/ uint16(xSetOp), uint16(JG),
-	/*5609*/ uint16(xReadCd),
-	/*5610*/ uint16(xArgRel32),
-	/*5611*/ uint16(xMatch),
-	/*5612*/ uint16(xCondDataSize), 5616, 5607, 5621,
-	/*5616*/ uint16(xSetOp), uint16(JG),
-	/*5618*/ uint16(xReadCd),
-	/*5619*/ uint16(xArgRel32),
-	/*5620*/ uint16(xMatch),
-	/*5621*/ uint16(xSetOp), uint16(JG),
-	/*5623*/ uint16(xReadCd),
-	/*5624*/ uint16(xArgRel32),
-	/*5625*/ uint16(xMatch),
-	/*5626*/ uint16(xSetOp), uint16(SETO),
-	/*5628*/ uint16(xReadSlashR),
-	/*5629*/ uint16(xArgRM8),
-	/*5630*/ uint16(xMatch),
-	/*5631*/ uint16(xSetOp), uint16(SETNO),
-	/*5633*/ uint16(xReadSlashR),
-	/*5634*/ uint16(xArgRM8),
-	/*5635*/ uint16(xMatch),
-	/*5636*/ uint16(xSetOp), uint16(SETB),
-	/*5638*/ uint16(xReadSlashR),
-	/*5639*/ uint16(xArgRM8),
-	/*5640*/ uint16(xMatch),
-	/*5641*/ uint16(xSetOp), uint16(SETAE),
-	/*5643*/ uint16(xReadSlashR),
-	/*5644*/ uint16(xArgRM8),
-	/*5645*/ uint16(xMatch),
-	/*5646*/ uint16(xSetOp), uint16(SETE),
-	/*5648*/ uint16(xReadSlashR),
-	/*5649*/ uint16(xArgRM8),
-	/*5650*/ uint16(xMatch),
-	/*5651*/ uint16(xSetOp), uint16(SETNE),
-	/*5653*/ uint16(xReadSlashR),
-	/*5654*/ uint16(xArgRM8),
-	/*5655*/ uint16(xMatch),
-	/*5656*/ uint16(xSetOp), uint16(SETBE),
-	/*5658*/ uint16(xReadSlashR),
-	/*5659*/ uint16(xArgRM8),
-	/*5660*/ uint16(xMatch),
-	/*5661*/ uint16(xSetOp), uint16(SETA),
-	/*5663*/ uint16(xReadSlashR),
-	/*5664*/ uint16(xArgRM8),
-	/*5665*/ uint16(xMatch),
-	/*5666*/ uint16(xSetOp), uint16(SETS),
-	/*5668*/ uint16(xReadSlashR),
-	/*5669*/ uint16(xArgRM8),
-	/*5670*/ uint16(xMatch),
-	/*5671*/ uint16(xSetOp), uint16(SETNS),
-	/*5673*/ uint16(xReadSlashR),
-	/*5674*/ uint16(xArgRM8),
-	/*5675*/ uint16(xMatch),
-	/*5676*/ uint16(xSetOp), uint16(SETP),
-	/*5678*/ uint16(xReadSlashR),
-	/*5679*/ uint16(xArgRM8),
-	/*5680*/ uint16(xMatch),
-	/*5681*/ uint16(xSetOp), uint16(SETNP),
-	/*5683*/ uint16(xReadSlashR),
-	/*5684*/ uint16(xArgRM8),
-	/*5685*/ uint16(xMatch),
-	/*5686*/ uint16(xSetOp), uint16(SETL),
-	/*5688*/ uint16(xReadSlashR),
-	/*5689*/ uint16(xArgRM8),
-	/*5690*/ uint16(xMatch),
-	/*5691*/ uint16(xSetOp), uint16(SETGE),
-	/*5693*/ uint16(xReadSlashR),
-	/*5694*/ uint16(xArgRM8),
-	/*5695*/ uint16(xMatch),
-	/*5696*/ uint16(xSetOp), uint16(SETLE),
-	/*5698*/ uint16(xReadSlashR),
-	/*5699*/ uint16(xArgRM8),
-	/*5700*/ uint16(xMatch),
-	/*5701*/ uint16(xSetOp), uint16(SETG),
-	/*5703*/ uint16(xReadSlashR),
-	/*5704*/ uint16(xArgRM8),
-	/*5705*/ uint16(xMatch),
-	/*5706*/ uint16(xSetOp), uint16(PUSH),
-	/*5708*/ uint16(xArgFS),
-	/*5709*/ uint16(xMatch),
-	/*5710*/ uint16(xCondIs64), 5713, 5725,
-	/*5713*/ uint16(xCondDataSize), 5717, 5721, 0,
-	/*5717*/ uint16(xSetOp), uint16(POP),
-	/*5719*/ uint16(xArgFS),
-	/*5720*/ uint16(xMatch),
-	/*5721*/ uint16(xSetOp), uint16(POP),
-	/*5723*/ uint16(xArgFS),
-	/*5724*/ uint16(xMatch),
-	/*5725*/ uint16(xCondDataSize), 5717, 5729, 5733,
-	/*5729*/ uint16(xSetOp), uint16(POP),
-	/*5731*/ uint16(xArgFS),
-	/*5732*/ uint16(xMatch),
-	/*5733*/ uint16(xSetOp), uint16(POP),
-	/*5735*/ uint16(xArgFS),
-	/*5736*/ uint16(xMatch),
-	/*5737*/ uint16(xSetOp), uint16(CPUID),
-	/*5739*/ uint16(xMatch),
-	/*5740*/ uint16(xCondIs64), 5743, 5759,
-	/*5743*/ uint16(xCondDataSize), 5747, 5753, 0,
-	/*5747*/ uint16(xSetOp), uint16(BT),
-	/*5749*/ uint16(xReadSlashR),
-	/*5750*/ uint16(xArgRM16),
-	/*5751*/ uint16(xArgR16),
-	/*5752*/ uint16(xMatch),
-	/*5753*/ uint16(xSetOp), uint16(BT),
-	/*5755*/ uint16(xReadSlashR),
-	/*5756*/ uint16(xArgRM32),
-	/*5757*/ uint16(xArgR32),
-	/*5758*/ uint16(xMatch),
-	/*5759*/ uint16(xCondDataSize), 5747, 5753, 5763,
-	/*5763*/ uint16(xSetOp), uint16(BT),
-	/*5765*/ uint16(xReadSlashR),
-	/*5766*/ uint16(xArgRM64),
-	/*5767*/ uint16(xArgR64),
-	/*5768*/ uint16(xMatch),
-	/*5769*/ uint16(xCondIs64), 5772, 5792,
-	/*5772*/ uint16(xCondDataSize), 5776, 5784, 0,
-	/*5776*/ uint16(xSetOp), uint16(SHLD),
-	/*5778*/ uint16(xReadSlashR),
-	/*5779*/ uint16(xReadIb),
-	/*5780*/ uint16(xArgRM16),
-	/*5781*/ uint16(xArgR16),
-	/*5782*/ uint16(xArgImm8u),
-	/*5783*/ uint16(xMatch),
-	/*5784*/ uint16(xSetOp), uint16(SHLD),
-	/*5786*/ uint16(xReadSlashR),
-	/*5787*/ uint16(xReadIb),
-	/*5788*/ uint16(xArgRM32),
-	/*5789*/ uint16(xArgR32),
-	/*5790*/ uint16(xArgImm8u),
-	/*5791*/ uint16(xMatch),
-	/*5792*/ uint16(xCondDataSize), 5776, 5784, 5796,
-	/*5796*/ uint16(xSetOp), uint16(SHLD),
-	/*5798*/ uint16(xReadSlashR),
-	/*5799*/ uint16(xReadIb),
-	/*5800*/ uint16(xArgRM64),
-	/*5801*/ uint16(xArgR64),
-	/*5802*/ uint16(xArgImm8u),
-	/*5803*/ uint16(xMatch),
-	/*5804*/ uint16(xCondIs64), 5807, 5825,
-	/*5807*/ uint16(xCondDataSize), 5811, 5818, 0,
-	/*5811*/ uint16(xSetOp), uint16(SHLD),
-	/*5813*/ uint16(xReadSlashR),
-	/*5814*/ uint16(xArgRM16),
-	/*5815*/ uint16(xArgR16),
-	/*5816*/ uint16(xArgCL),
-	/*5817*/ uint16(xMatch),
-	/*5818*/ uint16(xSetOp), uint16(SHLD),
-	/*5820*/ uint16(xReadSlashR),
-	/*5821*/ uint16(xArgRM32),
-	/*5822*/ uint16(xArgR32),
-	/*5823*/ uint16(xArgCL),
-	/*5824*/ uint16(xMatch),
-	/*5825*/ uint16(xCondDataSize), 5811, 5818, 5829,
-	/*5829*/ uint16(xSetOp), uint16(SHLD),
-	/*5831*/ uint16(xReadSlashR),
-	/*5832*/ uint16(xArgRM64),
-	/*5833*/ uint16(xArgR64),
-	/*5834*/ uint16(xArgCL),
-	/*5835*/ uint16(xMatch),
-	/*5836*/ uint16(xSetOp), uint16(PUSH),
-	/*5838*/ uint16(xArgGS),
-	/*5839*/ uint16(xMatch),
-	/*5840*/ uint16(xCondIs64), 5843, 5855,
-	/*5843*/ uint16(xCondDataSize), 5847, 5851, 0,
-	/*5847*/ uint16(xSetOp), uint16(POP),
-	/*5849*/ uint16(xArgGS),
-	/*5850*/ uint16(xMatch),
-	/*5851*/ uint16(xSetOp), uint16(POP),
-	/*5853*/ uint16(xArgGS),
-	/*5854*/ uint16(xMatch),
-	/*5855*/ uint16(xCondDataSize), 5847, 5859, 5863,
-	/*5859*/ uint16(xSetOp), uint16(POP),
-	/*5861*/ uint16(xArgGS),
-	/*5862*/ uint16(xMatch),
-	/*5863*/ uint16(xSetOp), uint16(POP),
-	/*5865*/ uint16(xArgGS),
-	/*5866*/ uint16(xMatch),
-	/*5867*/ uint16(xSetOp), uint16(RSM),
-	/*5869*/ uint16(xMatch),
-	/*5870*/ uint16(xCondIs64), 5873, 5889,
-	/*5873*/ uint16(xCondDataSize), 5877, 5883, 0,
-	/*5877*/ uint16(xSetOp), uint16(BTS),
-	/*5879*/ uint16(xReadSlashR),
-	/*5880*/ uint16(xArgRM16),
-	/*5881*/ uint16(xArgR16),
-	/*5882*/ uint16(xMatch),
-	/*5883*/ uint16(xSetOp), uint16(BTS),
-	/*5885*/ uint16(xReadSlashR),
-	/*5886*/ uint16(xArgRM32),
-	/*5887*/ uint16(xArgR32),
-	/*5888*/ uint16(xMatch),
-	/*5889*/ uint16(xCondDataSize), 5877, 5883, 5893,
-	/*5893*/ uint16(xSetOp), uint16(BTS),
-	/*5895*/ uint16(xReadSlashR),
-	/*5896*/ uint16(xArgRM64),
-	/*5897*/ uint16(xArgR64),
-	/*5898*/ uint16(xMatch),
-	/*5899*/ uint16(xCondIs64), 5902, 5922,
-	/*5902*/ uint16(xCondDataSize), 5906, 5914, 0,
-	/*5906*/ uint16(xSetOp), uint16(SHRD),
-	/*5908*/ uint16(xReadSlashR),
-	/*5909*/ uint16(xReadIb),
-	/*5910*/ uint16(xArgRM16),
-	/*5911*/ uint16(xArgR16),
-	/*5912*/ uint16(xArgImm8u),
-	/*5913*/ uint16(xMatch),
-	/*5914*/ uint16(xSetOp), uint16(SHRD),
-	/*5916*/ uint16(xReadSlashR),
-	/*5917*/ uint16(xReadIb),
-	/*5918*/ uint16(xArgRM32),
-	/*5919*/ uint16(xArgR32),
-	/*5920*/ uint16(xArgImm8u),
-	/*5921*/ uint16(xMatch),
-	/*5922*/ uint16(xCondDataSize), 5906, 5914, 5926,
-	/*5926*/ uint16(xSetOp), uint16(SHRD),
-	/*5928*/ uint16(xReadSlashR),
-	/*5929*/ uint16(xReadIb),
-	/*5930*/ uint16(xArgRM64),
-	/*5931*/ uint16(xArgR64),
-	/*5932*/ uint16(xArgImm8u),
-	/*5933*/ uint16(xMatch),
-	/*5934*/ uint16(xCondIs64), 5937, 5955,
-	/*5937*/ uint16(xCondDataSize), 5941, 5948, 0,
-	/*5941*/ uint16(xSetOp), uint16(SHRD),
-	/*5943*/ uint16(xReadSlashR),
-	/*5944*/ uint16(xArgRM16),
-	/*5945*/ uint16(xArgR16),
-	/*5946*/ uint16(xArgCL),
-	/*5947*/ uint16(xMatch),
-	/*5948*/ uint16(xSetOp), uint16(SHRD),
-	/*5950*/ uint16(xReadSlashR),
-	/*5951*/ uint16(xArgRM32),
-	/*5952*/ uint16(xArgR32),
-	/*5953*/ uint16(xArgCL),
-	/*5954*/ uint16(xMatch),
-	/*5955*/ uint16(xCondDataSize), 5941, 5948, 5959,
-	/*5959*/ uint16(xSetOp), uint16(SHRD),
-	/*5961*/ uint16(xReadSlashR),
-	/*5962*/ uint16(xArgRM64),
-	/*5963*/ uint16(xArgR64),
-	/*5964*/ uint16(xArgCL),
-	/*5965*/ uint16(xMatch),
-	/*5966*/ uint16(xCondByte), 3,
-	0xE8, 6215,
-	0xF0, 6218,
-	0xF8, 6221,
-	/*5974*/ uint16(xCondSlashR),
-	5983, // 0
-	6037, // 1
-	6091, // 2
-	6120, // 3
-	6149, // 4
-	6172, // 5
-	6195, // 6
-	6211, // 7
-	/*5983*/ uint16(xCondIs64), 5986, 5998,
-	/*5986*/ uint16(xCondDataSize), 5990, 5994, 0,
-	/*5990*/ uint16(xSetOp), uint16(FXSAVE),
-	/*5992*/ uint16(xArgM512byte),
-	/*5993*/ uint16(xMatch),
-	/*5994*/ uint16(xSetOp), uint16(FXSAVE),
-	/*5996*/ uint16(xArgM512byte),
-	/*5997*/ uint16(xMatch),
-	/*5998*/ uint16(xCondPrefix), 2,
-	0xF3, 6012,
-	0x0, 6004,
-	/*6004*/ uint16(xCondDataSize), 5990, 5994, 6008,
-	/*6008*/ uint16(xSetOp), uint16(FXSAVE64),
-	/*6010*/ uint16(xArgM512byte),
-	/*6011*/ uint16(xMatch),
-	/*6012*/ uint16(xCondDataSize), 6016, 6023, 6030,
-	/*6016*/ uint16(xCondIsMem), 6019, 0,
-	/*6019*/ uint16(xSetOp), uint16(RDFSBASE),
-	/*6021*/ uint16(xArgRM32),
-	/*6022*/ uint16(xMatch),
-	/*6023*/ uint16(xCondIsMem), 6026, 0,
-	/*6026*/ uint16(xSetOp), uint16(RDFSBASE),
-	/*6028*/ uint16(xArgRM32),
-	/*6029*/ uint16(xMatch),
-	/*6030*/ uint16(xCondIsMem), 6033, 0,
-	/*6033*/ uint16(xSetOp), uint16(RDFSBASE),
-	/*6035*/ uint16(xArgRM64),
-	/*6036*/ uint16(xMatch),
-	/*6037*/ uint16(xCondIs64), 6040, 6052,
-	/*6040*/ uint16(xCondDataSize), 6044, 6048, 0,
-	/*6044*/ uint16(xSetOp), uint16(FXRSTOR),
-	/*6046*/ uint16(xArgM512byte),
-	/*6047*/ uint16(xMatch),
-	/*6048*/ uint16(xSetOp), uint16(FXRSTOR),
-	/*6050*/ uint16(xArgM512byte),
-	/*6051*/ uint16(xMatch),
-	/*6052*/ uint16(xCondPrefix), 2,
-	0xF3, 6066,
-	0x0, 6058,
-	/*6058*/ uint16(xCondDataSize), 6044, 6048, 6062,
-	/*6062*/ uint16(xSetOp), uint16(FXRSTOR64),
-	/*6064*/ uint16(xArgM512byte),
-	/*6065*/ uint16(xMatch),
-	/*6066*/ uint16(xCondDataSize), 6070, 6077, 6084,
-	/*6070*/ uint16(xCondIsMem), 6073, 0,
-	/*6073*/ uint16(xSetOp), uint16(RDGSBASE),
-	/*6075*/ uint16(xArgRM32),
-	/*6076*/ uint16(xMatch),
-	/*6077*/ uint16(xCondIsMem), 6080, 0,
-	/*6080*/ uint16(xSetOp), uint16(RDGSBASE),
-	/*6082*/ uint16(xArgRM32),
-	/*6083*/ uint16(xMatch),
-	/*6084*/ uint16(xCondIsMem), 6087, 0,
-	/*6087*/ uint16(xSetOp), uint16(RDGSBASE),
-	/*6089*/ uint16(xArgRM64),
-	/*6090*/ uint16(xMatch),
-	/*6091*/ uint16(xCondIs64), 6094, 6098,
-	/*6094*/ uint16(xSetOp), uint16(LDMXCSR),
-	/*6096*/ uint16(xArgM32),
-	/*6097*/ uint16(xMatch),
-	/*6098*/ uint16(xCondPrefix), 2,
-	0xF3, 6104,
-	0x0, 6094,
-	/*6104*/ uint16(xCondDataSize), 6108, 6112, 6116,
-	/*6108*/ uint16(xSetOp), uint16(WRFSBASE),
-	/*6110*/ uint16(xArgRM32),
-	/*6111*/ uint16(xMatch),
-	/*6112*/ uint16(xSetOp), uint16(WRFSBASE),
-	/*6114*/ uint16(xArgRM32),
-	/*6115*/ uint16(xMatch),
-	/*6116*/ uint16(xSetOp), uint16(WRFSBASE),
-	/*6118*/ uint16(xArgRM64),
-	/*6119*/ uint16(xMatch),
-	/*6120*/ uint16(xCondIs64), 6123, 6127,
-	/*6123*/ uint16(xSetOp), uint16(STMXCSR),
-	/*6125*/ uint16(xArgM32),
-	/*6126*/ uint16(xMatch),
-	/*6127*/ uint16(xCondPrefix), 2,
-	0xF3, 6133,
-	0x0, 6123,
-	/*6133*/ uint16(xCondDataSize), 6137, 6141, 6145,
-	/*6137*/ uint16(xSetOp), uint16(WRGSBASE),
-	/*6139*/ uint16(xArgRM32),
-	/*6140*/ uint16(xMatch),
-	/*6141*/ uint16(xSetOp), uint16(WRGSBASE),
-	/*6143*/ uint16(xArgRM32),
-	/*6144*/ uint16(xMatch),
-	/*6145*/ uint16(xSetOp), uint16(WRGSBASE),
-	/*6147*/ uint16(xArgRM64),
-	/*6148*/ uint16(xMatch),
-	/*6149*/ uint16(xCondIs64), 6152, 6164,
-	/*6152*/ uint16(xCondDataSize), 6156, 6160, 0,
-	/*6156*/ uint16(xSetOp), uint16(XSAVE),
-	/*6158*/ uint16(xArgMem),
-	/*6159*/ uint16(xMatch),
-	/*6160*/ uint16(xSetOp), uint16(XSAVE),
-	/*6162*/ uint16(xArgMem),
-	/*6163*/ uint16(xMatch),
-	/*6164*/ uint16(xCondDataSize), 6156, 6160, 6168,
-	/*6168*/ uint16(xSetOp), uint16(XSAVE64),
-	/*6170*/ uint16(xArgMem),
-	/*6171*/ uint16(xMatch),
-	/*6172*/ uint16(xCondIs64), 6175, 6187,
-	/*6175*/ uint16(xCondDataSize), 6179, 6183, 0,
-	/*6179*/ uint16(xSetOp), uint16(XRSTOR),
-	/*6181*/ uint16(xArgMem),
-	/*6182*/ uint16(xMatch),
-	/*6183*/ uint16(xSetOp), uint16(XRSTOR),
-	/*6185*/ uint16(xArgMem),
-	/*6186*/ uint16(xMatch),
-	/*6187*/ uint16(xCondDataSize), 6179, 6183, 6191,
-	/*6191*/ uint16(xSetOp), uint16(XRSTOR64),
-	/*6193*/ uint16(xArgMem),
-	/*6194*/ uint16(xMatch),
-	/*6195*/ uint16(xCondDataSize), 6199, 6203, 6207,
-	/*6199*/ uint16(xSetOp), uint16(XSAVEOPT),
-	/*6201*/ uint16(xArgMem),
-	/*6202*/ uint16(xMatch),
-	/*6203*/ uint16(xSetOp), uint16(XSAVEOPT),
-	/*6205*/ uint16(xArgMem),
-	/*6206*/ uint16(xMatch),
-	/*6207*/ uint16(xSetOp), uint16(XSAVEOPT64),
-	/*6209*/ uint16(xArgMem),
-	/*6210*/ uint16(xMatch),
-	/*6211*/ uint16(xSetOp), uint16(CLFLUSH),
-	/*6213*/ uint16(xArgM8),
-	/*6214*/ uint16(xMatch),
-	/*6215*/ uint16(xSetOp), uint16(LFENCE),
-	/*6217*/ uint16(xMatch),
-	/*6218*/ uint16(xSetOp), uint16(MFENCE),
-	/*6220*/ uint16(xMatch),
-	/*6221*/ uint16(xSetOp), uint16(SFENCE),
-	/*6223*/ uint16(xMatch),
-	/*6224*/ uint16(xCondIs64), 6227, 6243,
-	/*6227*/ uint16(xCondDataSize), 6231, 6237, 0,
-	/*6231*/ uint16(xSetOp), uint16(IMUL),
-	/*6233*/ uint16(xReadSlashR),
-	/*6234*/ uint16(xArgR16),
-	/*6235*/ uint16(xArgRM16),
-	/*6236*/ uint16(xMatch),
-	/*6237*/ uint16(xSetOp), uint16(IMUL),
-	/*6239*/ uint16(xReadSlashR),
-	/*6240*/ uint16(xArgR32),
-	/*6241*/ uint16(xArgRM32),
-	/*6242*/ uint16(xMatch),
-	/*6243*/ uint16(xCondDataSize), 6231, 6237, 6247,
-	/*6247*/ uint16(xSetOp), uint16(IMUL),
-	/*6249*/ uint16(xReadSlashR),
-	/*6250*/ uint16(xArgR64),
-	/*6251*/ uint16(xArgRM64),
-	/*6252*/ uint16(xMatch),
-	/*6253*/ uint16(xSetOp), uint16(CMPXCHG),
-	/*6255*/ uint16(xReadSlashR),
-	/*6256*/ uint16(xArgRM8),
-	/*6257*/ uint16(xArgR8),
-	/*6258*/ uint16(xMatch),
-	/*6259*/ uint16(xCondIs64), 6262, 6278,
-	/*6262*/ uint16(xCondDataSize), 6266, 6272, 0,
-	/*6266*/ uint16(xSetOp), uint16(CMPXCHG),
-	/*6268*/ uint16(xReadSlashR),
-	/*6269*/ uint16(xArgRM16),
-	/*6270*/ uint16(xArgR16),
-	/*6271*/ uint16(xMatch),
-	/*6272*/ uint16(xSetOp), uint16(CMPXCHG),
-	/*6274*/ uint16(xReadSlashR),
-	/*6275*/ uint16(xArgRM32),
-	/*6276*/ uint16(xArgR32),
-	/*6277*/ uint16(xMatch),
-	/*6278*/ uint16(xCondDataSize), 6266, 6272, 6282,
-	/*6282*/ uint16(xSetOp), uint16(CMPXCHG),
-	/*6284*/ uint16(xReadSlashR),
-	/*6285*/ uint16(xArgRM64),
-	/*6286*/ uint16(xArgR64),
-	/*6287*/ uint16(xMatch),
-	/*6288*/ uint16(xCondIs64), 6291, 6307,
-	/*6291*/ uint16(xCondDataSize), 6295, 6301, 0,
-	/*6295*/ uint16(xSetOp), uint16(LSS),
-	/*6297*/ uint16(xReadSlashR),
-	/*6298*/ uint16(xArgR16),
-	/*6299*/ uint16(xArgM16colon16),
-	/*6300*/ uint16(xMatch),
-	/*6301*/ uint16(xSetOp), uint16(LSS),
-	/*6303*/ uint16(xReadSlashR),
-	/*6304*/ uint16(xArgR32),
-	/*6305*/ uint16(xArgM16colon32),
-	/*6306*/ uint16(xMatch),
-	/*6307*/ uint16(xCondDataSize), 6295, 6301, 6311,
-	/*6311*/ uint16(xSetOp), uint16(LSS),
-	/*6313*/ uint16(xReadSlashR),
-	/*6314*/ uint16(xArgR64),
-	/*6315*/ uint16(xArgM16colon64),
-	/*6316*/ uint16(xMatch),
-	/*6317*/ uint16(xCondIs64), 6320, 6336,
-	/*6320*/ uint16(xCondDataSize), 6324, 6330, 0,
-	/*6324*/ uint16(xSetOp), uint16(BTR),
-	/*6326*/ uint16(xReadSlashR),
-	/*6327*/ uint16(xArgRM16),
-	/*6328*/ uint16(xArgR16),
-	/*6329*/ uint16(xMatch),
-	/*6330*/ uint16(xSetOp), uint16(BTR),
-	/*6332*/ uint16(xReadSlashR),
-	/*6333*/ uint16(xArgRM32),
-	/*6334*/ uint16(xArgR32),
-	/*6335*/ uint16(xMatch),
-	/*6336*/ uint16(xCondDataSize), 6324, 6330, 6340,
-	/*6340*/ uint16(xSetOp), uint16(BTR),
-	/*6342*/ uint16(xReadSlashR),
-	/*6343*/ uint16(xArgRM64),
-	/*6344*/ uint16(xArgR64),
-	/*6345*/ uint16(xMatch),
-	/*6346*/ uint16(xCondIs64), 6349, 6365,
-	/*6349*/ uint16(xCondDataSize), 6353, 6359, 0,
-	/*6353*/ uint16(xSetOp), uint16(LFS),
-	/*6355*/ uint16(xReadSlashR),
-	/*6356*/ uint16(xArgR16),
-	/*6357*/ uint16(xArgM16colon16),
-	/*6358*/ uint16(xMatch),
-	/*6359*/ uint16(xSetOp), uint16(LFS),
-	/*6361*/ uint16(xReadSlashR),
-	/*6362*/ uint16(xArgR32),
-	/*6363*/ uint16(xArgM16colon32),
-	/*6364*/ uint16(xMatch),
-	/*6365*/ uint16(xCondDataSize), 6353, 6359, 6369,
-	/*6369*/ uint16(xSetOp), uint16(LFS),
-	/*6371*/ uint16(xReadSlashR),
-	/*6372*/ uint16(xArgR64),
-	/*6373*/ uint16(xArgM16colon64),
-	/*6374*/ uint16(xMatch),
-	/*6375*/ uint16(xCondIs64), 6378, 6394,
-	/*6378*/ uint16(xCondDataSize), 6382, 6388, 0,
-	/*6382*/ uint16(xSetOp), uint16(LGS),
-	/*6384*/ uint16(xReadSlashR),
-	/*6385*/ uint16(xArgR16),
-	/*6386*/ uint16(xArgM16colon16),
-	/*6387*/ uint16(xMatch),
-	/*6388*/ uint16(xSetOp), uint16(LGS),
-	/*6390*/ uint16(xReadSlashR),
-	/*6391*/ uint16(xArgR32),
-	/*6392*/ uint16(xArgM16colon32),
-	/*6393*/ uint16(xMatch),
-	/*6394*/ uint16(xCondDataSize), 6382, 6388, 6398,
-	/*6398*/ uint16(xSetOp), uint16(LGS),
-	/*6400*/ uint16(xReadSlashR),
-	/*6401*/ uint16(xArgR64),
-	/*6402*/ uint16(xArgM16colon64),
-	/*6403*/ uint16(xMatch),
-	/*6404*/ uint16(xCondIs64), 6407, 6423,
-	/*6407*/ uint16(xCondDataSize), 6411, 6417, 0,
-	/*6411*/ uint16(xSetOp), uint16(MOVZX),
-	/*6413*/ uint16(xReadSlashR),
-	/*6414*/ uint16(xArgR16),
-	/*6415*/ uint16(xArgRM8),
-	/*6416*/ uint16(xMatch),
-	/*6417*/ uint16(xSetOp), uint16(MOVZX),
-	/*6419*/ uint16(xReadSlashR),
-	/*6420*/ uint16(xArgR32),
-	/*6421*/ uint16(xArgRM8),
-	/*6422*/ uint16(xMatch),
-	/*6423*/ uint16(xCondDataSize), 6411, 6417, 6427,
-	/*6427*/ uint16(xSetOp), uint16(MOVZX),
-	/*6429*/ uint16(xReadSlashR),
-	/*6430*/ uint16(xArgR64),
-	/*6431*/ uint16(xArgRM8),
-	/*6432*/ uint16(xMatch),
-	/*6433*/ uint16(xCondIs64), 6436, 6452,
-	/*6436*/ uint16(xCondDataSize), 6440, 6446, 0,
-	/*6440*/ uint16(xSetOp), uint16(MOVZX),
-	/*6442*/ uint16(xReadSlashR),
-	/*6443*/ uint16(xArgR16),
-	/*6444*/ uint16(xArgRM16),
-	/*6445*/ uint16(xMatch),
-	/*6446*/ uint16(xSetOp), uint16(MOVZX),
-	/*6448*/ uint16(xReadSlashR),
-	/*6449*/ uint16(xArgR32),
-	/*6450*/ uint16(xArgRM16),
-	/*6451*/ uint16(xMatch),
-	/*6452*/ uint16(xCondDataSize), 6440, 6446, 6456,
-	/*6456*/ uint16(xSetOp), uint16(MOVZX),
-	/*6458*/ uint16(xReadSlashR),
-	/*6459*/ uint16(xArgR64),
-	/*6460*/ uint16(xArgRM16),
-	/*6461*/ uint16(xMatch),
-	/*6462*/ uint16(xCondIs64), 6465, 6485,
-	/*6465*/ uint16(xCondPrefix), 1,
-	0xF3, 6469,
-	/*6469*/ uint16(xCondDataSize), 6473, 6479, 0,
-	/*6473*/ uint16(xSetOp), uint16(POPCNT),
-	/*6475*/ uint16(xReadSlashR),
-	/*6476*/ uint16(xArgR16),
-	/*6477*/ uint16(xArgRM16),
-	/*6478*/ uint16(xMatch),
-	/*6479*/ uint16(xSetOp), uint16(POPCNT),
-	/*6481*/ uint16(xReadSlashR),
-	/*6482*/ uint16(xArgR32),
-	/*6483*/ uint16(xArgRM32),
-	/*6484*/ uint16(xMatch),
-	/*6485*/ uint16(xCondPrefix), 1,
-	0xF3, 6489,
-	/*6489*/ uint16(xCondDataSize), 6473, 6479, 6493,
-	/*6493*/ uint16(xSetOp), uint16(POPCNT),
-	/*6495*/ uint16(xReadSlashR),
-	/*6496*/ uint16(xArgR64),
-	/*6497*/ uint16(xArgRM64),
-	/*6498*/ uint16(xMatch),
-	/*6499*/ uint16(xSetOp), uint16(UD1),
-	/*6501*/ uint16(xMatch),
-	/*6502*/ uint16(xCondSlashR),
+	4908, // 6
+	4926, // 7
+	/*4880*/ uint16(xCondPrefix), 2,
+	0x66, 4892,
+	0x0, 4886,
+	/*4886*/ uint16(xSetOp), uint16(PSRLQ),
+	/*4888*/ uint16(xReadIb),
+	/*4889*/ uint16(xArgMm2),
+	/*4890*/ uint16(xArgImm8u),
+	/*4891*/ uint16(xMatch),
+	/*4892*/ uint16(xSetOp), uint16(PSRLQ),
+	/*4894*/ uint16(xReadIb),
+	/*4895*/ uint16(xArgXmm2),
+	/*4896*/ uint16(xArgImm8u),
+	/*4897*/ uint16(xMatch),
+	/*4898*/ uint16(xCondPrefix), 1,
+	0x66, 4902,
+	/*4902*/ uint16(xSetOp), uint16(PSRLDQ),
+	/*4904*/ uint16(xReadIb),
+	/*4905*/ uint16(xArgXmm2),
+	/*4906*/ uint16(xArgImm8u),
+	/*4907*/ uint16(xMatch),
+	/*4908*/ uint16(xCondPrefix), 2,
+	0x66, 4920,
+	0x0, 4914,
+	/*4914*/ uint16(xSetOp), uint16(PSLLQ),
+	/*4916*/ uint16(xReadIb),
+	/*4917*/ uint16(xArgMm2),
+	/*4918*/ uint16(xArgImm8u),
+	/*4919*/ uint16(xMatch),
+	/*4920*/ uint16(xSetOp), uint16(PSLLQ),
+	/*4922*/ uint16(xReadIb),
+	/*4923*/ uint16(xArgXmm2),
+	/*4924*/ uint16(xArgImm8u),
+	/*4925*/ uint16(xMatch),
+	/*4926*/ uint16(xCondPrefix), 1,
+	0x66, 4930,
+	/*4930*/ uint16(xSetOp), uint16(PSLLDQ),
+	/*4932*/ uint16(xReadIb),
+	/*4933*/ uint16(xArgXmm2),
+	/*4934*/ uint16(xArgImm8u),
+	/*4935*/ uint16(xMatch),
+	/*4936*/ uint16(xCondPrefix), 2,
+	0x66, 4948,
+	0x0, 4942,
+	/*4942*/ uint16(xSetOp), uint16(PCMPEQB),
+	/*4944*/ uint16(xReadSlashR),
+	/*4945*/ uint16(xArgMm),
+	/*4946*/ uint16(xArgMmM64),
+	/*4947*/ uint16(xMatch),
+	/*4948*/ uint16(xSetOp), uint16(PCMPEQB),
+	/*4950*/ uint16(xReadSlashR),
+	/*4951*/ uint16(xArgXmm1),
+	/*4952*/ uint16(xArgXmm2M128),
+	/*4953*/ uint16(xMatch),
+	/*4954*/ uint16(xCondPrefix), 2,
+	0x66, 4966,
+	0x0, 4960,
+	/*4960*/ uint16(xSetOp), uint16(PCMPEQW),
+	/*4962*/ uint16(xReadSlashR),
+	/*4963*/ uint16(xArgMm),
+	/*4964*/ uint16(xArgMmM64),
+	/*4965*/ uint16(xMatch),
+	/*4966*/ uint16(xSetOp), uint16(PCMPEQW),
+	/*4968*/ uint16(xReadSlashR),
+	/*4969*/ uint16(xArgXmm1),
+	/*4970*/ uint16(xArgXmm2M128),
+	/*4971*/ uint16(xMatch),
+	/*4972*/ uint16(xCondPrefix), 2,
+	0x66, 4984,
+	0x0, 4978,
+	/*4978*/ uint16(xSetOp), uint16(PCMPEQD),
+	/*4980*/ uint16(xReadSlashR),
+	/*4981*/ uint16(xArgMm),
+	/*4982*/ uint16(xArgMmM64),
+	/*4983*/ uint16(xMatch),
+	/*4984*/ uint16(xSetOp), uint16(PCMPEQD),
+	/*4986*/ uint16(xReadSlashR),
+	/*4987*/ uint16(xArgXmm1),
+	/*4988*/ uint16(xArgXmm2M128),
+	/*4989*/ uint16(xMatch),
+	/*4990*/ uint16(xSetOp), uint16(EMMS),
+	/*4992*/ uint16(xMatch),
+	/*4993*/ uint16(xCondPrefix), 2,
+	0xF2, 5005,
+	0x66, 4999,
+	/*4999*/ uint16(xSetOp), uint16(HADDPD),
+	/*5001*/ uint16(xReadSlashR),
+	/*5002*/ uint16(xArgXmm1),
+	/*5003*/ uint16(xArgXmm2M128),
+	/*5004*/ uint16(xMatch),
+	/*5005*/ uint16(xSetOp), uint16(HADDPS),
+	/*5007*/ uint16(xReadSlashR),
+	/*5008*/ uint16(xArgXmm1),
+	/*5009*/ uint16(xArgXmm2M128),
+	/*5010*/ uint16(xMatch),
+	/*5011*/ uint16(xCondPrefix), 2,
+	0xF2, 5023,
+	0x66, 5017,
+	/*5017*/ uint16(xSetOp), uint16(HSUBPD),
+	/*5019*/ uint16(xReadSlashR),
+	/*5020*/ uint16(xArgXmm1),
+	/*5021*/ uint16(xArgXmm2M128),
+	/*5022*/ uint16(xMatch),
+	/*5023*/ uint16(xSetOp), uint16(HSUBPS),
+	/*5025*/ uint16(xReadSlashR),
+	/*5026*/ uint16(xArgXmm1),
+	/*5027*/ uint16(xArgXmm2M128),
+	/*5028*/ uint16(xMatch),
+	/*5029*/ uint16(xCondIs64), 5032, 5078,
+	/*5032*/ uint16(xCondPrefix), 3,
+	0xF3, 5072,
+	0x66, 5056,
+	0x0, 5040,
+	/*5040*/ uint16(xCondDataSize), 5044, 5050, 0,
+	/*5044*/ uint16(xSetOp), uint16(MOVD),
+	/*5046*/ uint16(xReadSlashR),
+	/*5047*/ uint16(xArgRM32),
+	/*5048*/ uint16(xArgMm),
+	/*5049*/ uint16(xMatch),
+	/*5050*/ uint16(xSetOp), uint16(MOVD),
+	/*5052*/ uint16(xReadSlashR),
+	/*5053*/ uint16(xArgRM32),
+	/*5054*/ uint16(xArgMm),
+	/*5055*/ uint16(xMatch),
+	/*5056*/ uint16(xCondDataSize), 5060, 5066, 0,
+	/*5060*/ uint16(xSetOp), uint16(MOVD),
+	/*5062*/ uint16(xReadSlashR),
+	/*5063*/ uint16(xArgRM32),
+	/*5064*/ uint16(xArgXmm),
+	/*5065*/ uint16(xMatch),
+	/*5066*/ uint16(xSetOp), uint16(MOVD),
+	/*5068*/ uint16(xReadSlashR),
+	/*5069*/ uint16(xArgRM32),
+	/*5070*/ uint16(xArgXmm),
+	/*5071*/ uint16(xMatch),
+	/*5072*/ uint16(xSetOp), uint16(MOVQ),
+	/*5074*/ uint16(xReadSlashR),
+	/*5075*/ uint16(xArgXmm1),
+	/*5076*/ uint16(xArgXmm2M64),
+	/*5077*/ uint16(xMatch),
+	/*5078*/ uint16(xCondPrefix), 3,
+	0xF3, 5072,
+	0x66, 5096,
+	0x0, 5086,
+	/*5086*/ uint16(xCondDataSize), 5044, 5050, 5090,
+	/*5090*/ uint16(xSetOp), uint16(MOVQ),
+	/*5092*/ uint16(xReadSlashR),
+	/*5093*/ uint16(xArgRM64),
+	/*5094*/ uint16(xArgMm),
+	/*5095*/ uint16(xMatch),
+	/*5096*/ uint16(xCondDataSize), 5060, 5066, 5100,
+	/*5100*/ uint16(xSetOp), uint16(MOVQ),
+	/*5102*/ uint16(xReadSlashR),
+	/*5103*/ uint16(xArgRM64),
+	/*5104*/ uint16(xArgXmm),
+	/*5105*/ uint16(xMatch),
+	/*5106*/ uint16(xCondPrefix), 3,
+	0xF3, 5126,
+	0x66, 5120,
+	0x0, 5114,
+	/*5114*/ uint16(xSetOp), uint16(MOVQ),
+	/*5116*/ uint16(xReadSlashR),
+	/*5117*/ uint16(xArgMmM64),
+	/*5118*/ uint16(xArgMm),
+	/*5119*/ uint16(xMatch),
+	/*5120*/ uint16(xSetOp), uint16(MOVDQA),
+	/*5122*/ uint16(xReadSlashR),
+	/*5123*/ uint16(xArgXmm2M128),
+	/*5124*/ uint16(xArgXmm1),
+	/*5125*/ uint16(xMatch),
+	/*5126*/ uint16(xSetOp), uint16(MOVDQU),
+	/*5128*/ uint16(xReadSlashR),
+	/*5129*/ uint16(xArgXmm2M128),
+	/*5130*/ uint16(xArgXmm1),
+	/*5131*/ uint16(xMatch),
+	/*5132*/ uint16(xCondIs64), 5135, 5149,
+	/*5135*/ uint16(xCondDataSize), 5139, 5144, 0,
+	/*5139*/ uint16(xSetOp), uint16(JO),
+	/*5141*/ uint16(xReadCw),
+	/*5142*/ uint16(xArgRel16),
+	/*5143*/ uint16(xMatch),
+	/*5144*/ uint16(xSetOp), uint16(JO),
+	/*5146*/ uint16(xReadCd),
+	/*5147*/ uint16(xArgRel32),
+	/*5148*/ uint16(xMatch),
+	/*5149*/ uint16(xCondDataSize), 5153, 5144, 5158,
+	/*5153*/ uint16(xSetOp), uint16(JO),
+	/*5155*/ uint16(xReadCd),
+	/*5156*/ uint16(xArgRel32),
+	/*5157*/ uint16(xMatch),
+	/*5158*/ uint16(xSetOp), uint16(JO),
+	/*5160*/ uint16(xReadCd),
+	/*5161*/ uint16(xArgRel32),
+	/*5162*/ uint16(xMatch),
+	/*5163*/ uint16(xCondIs64), 5166, 5180,
+	/*5166*/ uint16(xCondDataSize), 5170, 5175, 0,
+	/*5170*/ uint16(xSetOp), uint16(JNO),
+	/*5172*/ uint16(xReadCw),
+	/*5173*/ uint16(xArgRel16),
+	/*5174*/ uint16(xMatch),
+	/*5175*/ uint16(xSetOp), uint16(JNO),
+	/*5177*/ uint16(xReadCd),
+	/*5178*/ uint16(xArgRel32),
+	/*5179*/ uint16(xMatch),
+	/*5180*/ uint16(xCondDataSize), 5184, 5175, 5189,
+	/*5184*/ uint16(xSetOp), uint16(JNO),
+	/*5186*/ uint16(xReadCd),
+	/*5187*/ uint16(xArgRel32),
+	/*5188*/ uint16(xMatch),
+	/*5189*/ uint16(xSetOp), uint16(JNO),
+	/*5191*/ uint16(xReadCd),
+	/*5192*/ uint16(xArgRel32),
+	/*5193*/ uint16(xMatch),
+	/*5194*/ uint16(xCondIs64), 5197, 5211,
+	/*5197*/ uint16(xCondDataSize), 5201, 5206, 0,
+	/*5201*/ uint16(xSetOp), uint16(JB),
+	/*5203*/ uint16(xReadCw),
+	/*5204*/ uint16(xArgRel16),
+	/*5205*/ uint16(xMatch),
+	/*5206*/ uint16(xSetOp), uint16(JB),
+	/*5208*/ uint16(xReadCd),
+	/*5209*/ uint16(xArgRel32),
+	/*5210*/ uint16(xMatch),
+	/*5211*/ uint16(xCondDataSize), 5215, 5206, 5220,
+	/*5215*/ uint16(xSetOp), uint16(JB),
+	/*5217*/ uint16(xReadCd),
+	/*5218*/ uint16(xArgRel32),
+	/*5219*/ uint16(xMatch),
+	/*5220*/ uint16(xSetOp), uint16(JB),
+	/*5222*/ uint16(xReadCd),
+	/*5223*/ uint16(xArgRel32),
+	/*5224*/ uint16(xMatch),
+	/*5225*/ uint16(xCondIs64), 5228, 5242,
+	/*5228*/ uint16(xCondDataSize), 5232, 5237, 0,
+	/*5232*/ uint16(xSetOp), uint16(JAE),
+	/*5234*/ uint16(xReadCw),
+	/*5235*/ uint16(xArgRel16),
+	/*5236*/ uint16(xMatch),
+	/*5237*/ uint16(xSetOp), uint16(JAE),
+	/*5239*/ uint16(xReadCd),
+	/*5240*/ uint16(xArgRel32),
+	/*5241*/ uint16(xMatch),
+	/*5242*/ uint16(xCondDataSize), 5246, 5237, 5251,
+	/*5246*/ uint16(xSetOp), uint16(JAE),
+	/*5248*/ uint16(xReadCd),
+	/*5249*/ uint16(xArgRel32),
+	/*5250*/ uint16(xMatch),
+	/*5251*/ uint16(xSetOp), uint16(JAE),
+	/*5253*/ uint16(xReadCd),
+	/*5254*/ uint16(xArgRel32),
+	/*5255*/ uint16(xMatch),
+	/*5256*/ uint16(xCondIs64), 5259, 5273,
+	/*5259*/ uint16(xCondDataSize), 5263, 5268, 0,
+	/*5263*/ uint16(xSetOp), uint16(JE),
+	/*5265*/ uint16(xReadCw),
+	/*5266*/ uint16(xArgRel16),
+	/*5267*/ uint16(xMatch),
+	/*5268*/ uint16(xSetOp), uint16(JE),
+	/*5270*/ uint16(xReadCd),
+	/*5271*/ uint16(xArgRel32),
+	/*5272*/ uint16(xMatch),
+	/*5273*/ uint16(xCondDataSize), 5277, 5268, 5282,
+	/*5277*/ uint16(xSetOp), uint16(JE),
+	/*5279*/ uint16(xReadCd),
+	/*5280*/ uint16(xArgRel32),
+	/*5281*/ uint16(xMatch),
+	/*5282*/ uint16(xSetOp), uint16(JE),
+	/*5284*/ uint16(xReadCd),
+	/*5285*/ uint16(xArgRel32),
+	/*5286*/ uint16(xMatch),
+	/*5287*/ uint16(xCondIs64), 5290, 5304,
+	/*5290*/ uint16(xCondDataSize), 5294, 5299, 0,
+	/*5294*/ uint16(xSetOp), uint16(JNE),
+	/*5296*/ uint16(xReadCw),
+	/*5297*/ uint16(xArgRel16),
+	/*5298*/ uint16(xMatch),
+	/*5299*/ uint16(xSetOp), uint16(JNE),
+	/*5301*/ uint16(xReadCd),
+	/*5302*/ uint16(xArgRel32),
+	/*5303*/ uint16(xMatch),
+	/*5304*/ uint16(xCondDataSize), 5308, 5299, 5313,
+	/*5308*/ uint16(xSetOp), uint16(JNE),
+	/*5310*/ uint16(xReadCd),
+	/*5311*/ uint16(xArgRel32),
+	/*5312*/ uint16(xMatch),
+	/*5313*/ uint16(xSetOp), uint16(JNE),
+	/*5315*/ uint16(xReadCd),
+	/*5316*/ uint16(xArgRel32),
+	/*5317*/ uint16(xMatch),
+	/*5318*/ uint16(xCondIs64), 5321, 5335,
+	/*5321*/ uint16(xCondDataSize), 5325, 5330, 0,
+	/*5325*/ uint16(xSetOp), uint16(JBE),
+	/*5327*/ uint16(xReadCw),
+	/*5328*/ uint16(xArgRel16),
+	/*5329*/ uint16(xMatch),
+	/*5330*/ uint16(xSetOp), uint16(JBE),
+	/*5332*/ uint16(xReadCd),
+	/*5333*/ uint16(xArgRel32),
+	/*5334*/ uint16(xMatch),
+	/*5335*/ uint16(xCondDataSize), 5339, 5330, 5344,
+	/*5339*/ uint16(xSetOp), uint16(JBE),
+	/*5341*/ uint16(xReadCd),
+	/*5342*/ uint16(xArgRel32),
+	/*5343*/ uint16(xMatch),
+	/*5344*/ uint16(xSetOp), uint16(JBE),
+	/*5346*/ uint16(xReadCd),
+	/*5347*/ uint16(xArgRel32),
+	/*5348*/ uint16(xMatch),
+	/*5349*/ uint16(xCondIs64), 5352, 5366,
+	/*5352*/ uint16(xCondDataSize), 5356, 5361, 0,
+	/*5356*/ uint16(xSetOp), uint16(JA),
+	/*5358*/ uint16(xReadCw),
+	/*5359*/ uint16(xArgRel16),
+	/*5360*/ uint16(xMatch),
+	/*5361*/ uint16(xSetOp), uint16(JA),
+	/*5363*/ uint16(xReadCd),
+	/*5364*/ uint16(xArgRel32),
+	/*5365*/ uint16(xMatch),
+	/*5366*/ uint16(xCondDataSize), 5370, 5361, 5375,
+	/*5370*/ uint16(xSetOp), uint16(JA),
+	/*5372*/ uint16(xReadCd),
+	/*5373*/ uint16(xArgRel32),
+	/*5374*/ uint16(xMatch),
+	/*5375*/ uint16(xSetOp), uint16(JA),
+	/*5377*/ uint16(xReadCd),
+	/*5378*/ uint16(xArgRel32),
+	/*5379*/ uint16(xMatch),
+	/*5380*/ uint16(xCondIs64), 5383, 5397,
+	/*5383*/ uint16(xCondDataSize), 5387, 5392, 0,
+	/*5387*/ uint16(xSetOp), uint16(JS),
+	/*5389*/ uint16(xReadCw),
+	/*5390*/ uint16(xArgRel16),
+	/*5391*/ uint16(xMatch),
+	/*5392*/ uint16(xSetOp), uint16(JS),
+	/*5394*/ uint16(xReadCd),
+	/*5395*/ uint16(xArgRel32),
+	/*5396*/ uint16(xMatch),
+	/*5397*/ uint16(xCondDataSize), 5401, 5392, 5406,
+	/*5401*/ uint16(xSetOp), uint16(JS),
+	/*5403*/ uint16(xReadCd),
+	/*5404*/ uint16(xArgRel32),
+	/*5405*/ uint16(xMatch),
+	/*5406*/ uint16(xSetOp), uint16(JS),
+	/*5408*/ uint16(xReadCd),
+	/*5409*/ uint16(xArgRel32),
+	/*5410*/ uint16(xMatch),
+	/*5411*/ uint16(xCondIs64), 5414, 5428,
+	/*5414*/ uint16(xCondDataSize), 5418, 5423, 0,
+	/*5418*/ uint16(xSetOp), uint16(JNS),
+	/*5420*/ uint16(xReadCw),
+	/*5421*/ uint16(xArgRel16),
+	/*5422*/ uint16(xMatch),
+	/*5423*/ uint16(xSetOp), uint16(JNS),
+	/*5425*/ uint16(xReadCd),
+	/*5426*/ uint16(xArgRel32),
+	/*5427*/ uint16(xMatch),
+	/*5428*/ uint16(xCondDataSize), 5432, 5423, 5437,
+	/*5432*/ uint16(xSetOp), uint16(JNS),
+	/*5434*/ uint16(xReadCd),
+	/*5435*/ uint16(xArgRel32),
+	/*5436*/ uint16(xMatch),
+	/*5437*/ uint16(xSetOp), uint16(JNS),
+	/*5439*/ uint16(xReadCd),
+	/*5440*/ uint16(xArgRel32),
+	/*5441*/ uint16(xMatch),
+	/*5442*/ uint16(xCondIs64), 5445, 5459,
+	/*5445*/ uint16(xCondDataSize), 5449, 5454, 0,
+	/*5449*/ uint16(xSetOp), uint16(JP),
+	/*5451*/ uint16(xReadCw),
+	/*5452*/ uint16(xArgRel16),
+	/*5453*/ uint16(xMatch),
+	/*5454*/ uint16(xSetOp), uint16(JP),
+	/*5456*/ uint16(xReadCd),
+	/*5457*/ uint16(xArgRel32),
+	/*5458*/ uint16(xMatch),
+	/*5459*/ uint16(xCondDataSize), 5463, 5454, 5468,
+	/*5463*/ uint16(xSetOp), uint16(JP),
+	/*5465*/ uint16(xReadCd),
+	/*5466*/ uint16(xArgRel32),
+	/*5467*/ uint16(xMatch),
+	/*5468*/ uint16(xSetOp), uint16(JP),
+	/*5470*/ uint16(xReadCd),
+	/*5471*/ uint16(xArgRel32),
+	/*5472*/ uint16(xMatch),
+	/*5473*/ uint16(xCondIs64), 5476, 5490,
+	/*5476*/ uint16(xCondDataSize), 5480, 5485, 0,
+	/*5480*/ uint16(xSetOp), uint16(JNP),
+	/*5482*/ uint16(xReadCw),
+	/*5483*/ uint16(xArgRel16),
+	/*5484*/ uint16(xMatch),
+	/*5485*/ uint16(xSetOp), uint16(JNP),
+	/*5487*/ uint16(xReadCd),
+	/*5488*/ uint16(xArgRel32),
+	/*5489*/ uint16(xMatch),
+	/*5490*/ uint16(xCondDataSize), 5494, 5485, 5499,
+	/*5494*/ uint16(xSetOp), uint16(JNP),
+	/*5496*/ uint16(xReadCd),
+	/*5497*/ uint16(xArgRel32),
+	/*5498*/ uint16(xMatch),
+	/*5499*/ uint16(xSetOp), uint16(JNP),
+	/*5501*/ uint16(xReadCd),
+	/*5502*/ uint16(xArgRel32),
+	/*5503*/ uint16(xMatch),
+	/*5504*/ uint16(xCondIs64), 5507, 5521,
+	/*5507*/ uint16(xCondDataSize), 5511, 5516, 0,
+	/*5511*/ uint16(xSetOp), uint16(JL),
+	/*5513*/ uint16(xReadCw),
+	/*5514*/ uint16(xArgRel16),
+	/*5515*/ uint16(xMatch),
+	/*5516*/ uint16(xSetOp), uint16(JL),
+	/*5518*/ uint16(xReadCd),
+	/*5519*/ uint16(xArgRel32),
+	/*5520*/ uint16(xMatch),
+	/*5521*/ uint16(xCondDataSize), 5525, 5516, 5530,
+	/*5525*/ uint16(xSetOp), uint16(JL),
+	/*5527*/ uint16(xReadCd),
+	/*5528*/ uint16(xArgRel32),
+	/*5529*/ uint16(xMatch),
+	/*5530*/ uint16(xSetOp), uint16(JL),
+	/*5532*/ uint16(xReadCd),
+	/*5533*/ uint16(xArgRel32),
+	/*5534*/ uint16(xMatch),
+	/*5535*/ uint16(xCondIs64), 5538, 5552,
+	/*5538*/ uint16(xCondDataSize), 5542, 5547, 0,
+	/*5542*/ uint16(xSetOp), uint16(JGE),
+	/*5544*/ uint16(xReadCw),
+	/*5545*/ uint16(xArgRel16),
+	/*5546*/ uint16(xMatch),
+	/*5547*/ uint16(xSetOp), uint16(JGE),
+	/*5549*/ uint16(xReadCd),
+	/*5550*/ uint16(xArgRel32),
+	/*5551*/ uint16(xMatch),
+	/*5552*/ uint16(xCondDataSize), 5556, 5547, 5561,
+	/*5556*/ uint16(xSetOp), uint16(JGE),
+	/*5558*/ uint16(xReadCd),
+	/*5559*/ uint16(xArgRel32),
+	/*5560*/ uint16(xMatch),
+	/*5561*/ uint16(xSetOp), uint16(JGE),
+	/*5563*/ uint16(xReadCd),
+	/*5564*/ uint16(xArgRel32),
+	/*5565*/ uint16(xMatch),
+	/*5566*/ uint16(xCondIs64), 5569, 5583,
+	/*5569*/ uint16(xCondDataSize), 5573, 5578, 0,
+	/*5573*/ uint16(xSetOp), uint16(JLE),
+	/*5575*/ uint16(xReadCw),
+	/*5576*/ uint16(xArgRel16),
+	/*5577*/ uint16(xMatch),
+	/*5578*/ uint16(xSetOp), uint16(JLE),
+	/*5580*/ uint16(xReadCd),
+	/*5581*/ uint16(xArgRel32),
+	/*5582*/ uint16(xMatch),
+	/*5583*/ uint16(xCondDataSize), 5587, 5578, 5592,
+	/*5587*/ uint16(xSetOp), uint16(JLE),
+	/*5589*/ uint16(xReadCd),
+	/*5590*/ uint16(xArgRel32),
+	/*5591*/ uint16(xMatch),
+	/*5592*/ uint16(xSetOp), uint16(JLE),
+	/*5594*/ uint16(xReadCd),
+	/*5595*/ uint16(xArgRel32),
+	/*5596*/ uint16(xMatch),
+	/*5597*/ uint16(xCondIs64), 5600, 5614,
+	/*5600*/ uint16(xCondDataSize), 5604, 5609, 0,
+	/*5604*/ uint16(xSetOp), uint16(JG),
+	/*5606*/ uint16(xReadCw),
+	/*5607*/ uint16(xArgRel16),
+	/*5608*/ uint16(xMatch),
+	/*5609*/ uint16(xSetOp), uint16(JG),
+	/*5611*/ uint16(xReadCd),
+	/*5612*/ uint16(xArgRel32),
+	/*5613*/ uint16(xMatch),
+	/*5614*/ uint16(xCondDataSize), 5618, 5609, 5623,
+	/*5618*/ uint16(xSetOp), uint16(JG),
+	/*5620*/ uint16(xReadCd),
+	/*5621*/ uint16(xArgRel32),
+	/*5622*/ uint16(xMatch),
+	/*5623*/ uint16(xSetOp), uint16(JG),
+	/*5625*/ uint16(xReadCd),
+	/*5626*/ uint16(xArgRel32),
+	/*5627*/ uint16(xMatch),
+	/*5628*/ uint16(xSetOp), uint16(SETO),
+	/*5630*/ uint16(xReadSlashR),
+	/*5631*/ uint16(xArgRM8),
+	/*5632*/ uint16(xMatch),
+	/*5633*/ uint16(xSetOp), uint16(SETNO),
+	/*5635*/ uint16(xReadSlashR),
+	/*5636*/ uint16(xArgRM8),
+	/*5637*/ uint16(xMatch),
+	/*5638*/ uint16(xSetOp), uint16(SETB),
+	/*5640*/ uint16(xReadSlashR),
+	/*5641*/ uint16(xArgRM8),
+	/*5642*/ uint16(xMatch),
+	/*5643*/ uint16(xSetOp), uint16(SETAE),
+	/*5645*/ uint16(xReadSlashR),
+	/*5646*/ uint16(xArgRM8),
+	/*5647*/ uint16(xMatch),
+	/*5648*/ uint16(xSetOp), uint16(SETE),
+	/*5650*/ uint16(xReadSlashR),
+	/*5651*/ uint16(xArgRM8),
+	/*5652*/ uint16(xMatch),
+	/*5653*/ uint16(xSetOp), uint16(SETNE),
+	/*5655*/ uint16(xReadSlashR),
+	/*5656*/ uint16(xArgRM8),
+	/*5657*/ uint16(xMatch),
+	/*5658*/ uint16(xSetOp), uint16(SETBE),
+	/*5660*/ uint16(xReadSlashR),
+	/*5661*/ uint16(xArgRM8),
+	/*5662*/ uint16(xMatch),
+	/*5663*/ uint16(xSetOp), uint16(SETA),
+	/*5665*/ uint16(xReadSlashR),
+	/*5666*/ uint16(xArgRM8),
+	/*5667*/ uint16(xMatch),
+	/*5668*/ uint16(xSetOp), uint16(SETS),
+	/*5670*/ uint16(xReadSlashR),
+	/*5671*/ uint16(xArgRM8),
+	/*5672*/ uint16(xMatch),
+	/*5673*/ uint16(xSetOp), uint16(SETNS),
+	/*5675*/ uint16(xReadSlashR),
+	/*5676*/ uint16(xArgRM8),
+	/*5677*/ uint16(xMatch),
+	/*5678*/ uint16(xSetOp), uint16(SETP),
+	/*5680*/ uint16(xReadSlashR),
+	/*5681*/ uint16(xArgRM8),
+	/*5682*/ uint16(xMatch),
+	/*5683*/ uint16(xSetOp), uint16(SETNP),
+	/*5685*/ uint16(xReadSlashR),
+	/*5686*/ uint16(xArgRM8),
+	/*5687*/ uint16(xMatch),
+	/*5688*/ uint16(xSetOp), uint16(SETL),
+	/*5690*/ uint16(xReadSlashR),
+	/*5691*/ uint16(xArgRM8),
+	/*5692*/ uint16(xMatch),
+	/*5693*/ uint16(xSetOp), uint16(SETGE),
+	/*5695*/ uint16(xReadSlashR),
+	/*5696*/ uint16(xArgRM8),
+	/*5697*/ uint16(xMatch),
+	/*5698*/ uint16(xSetOp), uint16(SETLE),
+	/*5700*/ uint16(xReadSlashR),
+	/*5701*/ uint16(xArgRM8),
+	/*5702*/ uint16(xMatch),
+	/*5703*/ uint16(xSetOp), uint16(SETG),
+	/*5705*/ uint16(xReadSlashR),
+	/*5706*/ uint16(xArgRM8),
+	/*5707*/ uint16(xMatch),
+	/*5708*/ uint16(xSetOp), uint16(PUSH),
+	/*5710*/ uint16(xArgFS),
+	/*5711*/ uint16(xMatch),
+	/*5712*/ uint16(xCondIs64), 5715, 5727,
+	/*5715*/ uint16(xCondDataSize), 5719, 5723, 0,
+	/*5719*/ uint16(xSetOp), uint16(POP),
+	/*5721*/ uint16(xArgFS),
+	/*5722*/ uint16(xMatch),
+	/*5723*/ uint16(xSetOp), uint16(POP),
+	/*5725*/ uint16(xArgFS),
+	/*5726*/ uint16(xMatch),
+	/*5727*/ uint16(xCondDataSize), 5719, 5731, 5735,
+	/*5731*/ uint16(xSetOp), uint16(POP),
+	/*5733*/ uint16(xArgFS),
+	/*5734*/ uint16(xMatch),
+	/*5735*/ uint16(xSetOp), uint16(POP),
+	/*5737*/ uint16(xArgFS),
+	/*5738*/ uint16(xMatch),
+	/*5739*/ uint16(xSetOp), uint16(CPUID),
+	/*5741*/ uint16(xMatch),
+	/*5742*/ uint16(xCondIs64), 5745, 5761,
+	/*5745*/ uint16(xCondDataSize), 5749, 5755, 0,
+	/*5749*/ uint16(xSetOp), uint16(BT),
+	/*5751*/ uint16(xReadSlashR),
+	/*5752*/ uint16(xArgRM16),
+	/*5753*/ uint16(xArgR16),
+	/*5754*/ uint16(xMatch),
+	/*5755*/ uint16(xSetOp), uint16(BT),
+	/*5757*/ uint16(xReadSlashR),
+	/*5758*/ uint16(xArgRM32),
+	/*5759*/ uint16(xArgR32),
+	/*5760*/ uint16(xMatch),
+	/*5761*/ uint16(xCondDataSize), 5749, 5755, 5765,
+	/*5765*/ uint16(xSetOp), uint16(BT),
+	/*5767*/ uint16(xReadSlashR),
+	/*5768*/ uint16(xArgRM64),
+	/*5769*/ uint16(xArgR64),
+	/*5770*/ uint16(xMatch),
+	/*5771*/ uint16(xCondIs64), 5774, 5794,
+	/*5774*/ uint16(xCondDataSize), 5778, 5786, 0,
+	/*5778*/ uint16(xSetOp), uint16(SHLD),
+	/*5780*/ uint16(xReadSlashR),
+	/*5781*/ uint16(xReadIb),
+	/*5782*/ uint16(xArgRM16),
+	/*5783*/ uint16(xArgR16),
+	/*5784*/ uint16(xArgImm8u),
+	/*5785*/ uint16(xMatch),
+	/*5786*/ uint16(xSetOp), uint16(SHLD),
+	/*5788*/ uint16(xReadSlashR),
+	/*5789*/ uint16(xReadIb),
+	/*5790*/ uint16(xArgRM32),
+	/*5791*/ uint16(xArgR32),
+	/*5792*/ uint16(xArgImm8u),
+	/*5793*/ uint16(xMatch),
+	/*5794*/ uint16(xCondDataSize), 5778, 5786, 5798,
+	/*5798*/ uint16(xSetOp), uint16(SHLD),
+	/*5800*/ uint16(xReadSlashR),
+	/*5801*/ uint16(xReadIb),
+	/*5802*/ uint16(xArgRM64),
+	/*5803*/ uint16(xArgR64),
+	/*5804*/ uint16(xArgImm8u),
+	/*5805*/ uint16(xMatch),
+	/*5806*/ uint16(xCondIs64), 5809, 5827,
+	/*5809*/ uint16(xCondDataSize), 5813, 5820, 0,
+	/*5813*/ uint16(xSetOp), uint16(SHLD),
+	/*5815*/ uint16(xReadSlashR),
+	/*5816*/ uint16(xArgRM16),
+	/*5817*/ uint16(xArgR16),
+	/*5818*/ uint16(xArgCL),
+	/*5819*/ uint16(xMatch),
+	/*5820*/ uint16(xSetOp), uint16(SHLD),
+	/*5822*/ uint16(xReadSlashR),
+	/*5823*/ uint16(xArgRM32),
+	/*5824*/ uint16(xArgR32),
+	/*5825*/ uint16(xArgCL),
+	/*5826*/ uint16(xMatch),
+	/*5827*/ uint16(xCondDataSize), 5813, 5820, 5831,
+	/*5831*/ uint16(xSetOp), uint16(SHLD),
+	/*5833*/ uint16(xReadSlashR),
+	/*5834*/ uint16(xArgRM64),
+	/*5835*/ uint16(xArgR64),
+	/*5836*/ uint16(xArgCL),
+	/*5837*/ uint16(xMatch),
+	/*5838*/ uint16(xSetOp), uint16(PUSH),
+	/*5840*/ uint16(xArgGS),
+	/*5841*/ uint16(xMatch),
+	/*5842*/ uint16(xCondIs64), 5845, 5857,
+	/*5845*/ uint16(xCondDataSize), 5849, 5853, 0,
+	/*5849*/ uint16(xSetOp), uint16(POP),
+	/*5851*/ uint16(xArgGS),
+	/*5852*/ uint16(xMatch),
+	/*5853*/ uint16(xSetOp), uint16(POP),
+	/*5855*/ uint16(xArgGS),
+	/*5856*/ uint16(xMatch),
+	/*5857*/ uint16(xCondDataSize), 5849, 5861, 5865,
+	/*5861*/ uint16(xSetOp), uint16(POP),
+	/*5863*/ uint16(xArgGS),
+	/*5864*/ uint16(xMatch),
+	/*5865*/ uint16(xSetOp), uint16(POP),
+	/*5867*/ uint16(xArgGS),
+	/*5868*/ uint16(xMatch),
+	/*5869*/ uint16(xSetOp), uint16(RSM),
+	/*5871*/ uint16(xMatch),
+	/*5872*/ uint16(xCondIs64), 5875, 5891,
+	/*5875*/ uint16(xCondDataSize), 5879, 5885, 0,
+	/*5879*/ uint16(xSetOp), uint16(BTS),
+	/*5881*/ uint16(xReadSlashR),
+	/*5882*/ uint16(xArgRM16),
+	/*5883*/ uint16(xArgR16),
+	/*5884*/ uint16(xMatch),
+	/*5885*/ uint16(xSetOp), uint16(BTS),
+	/*5887*/ uint16(xReadSlashR),
+	/*5888*/ uint16(xArgRM32),
+	/*5889*/ uint16(xArgR32),
+	/*5890*/ uint16(xMatch),
+	/*5891*/ uint16(xCondDataSize), 5879, 5885, 5895,
+	/*5895*/ uint16(xSetOp), uint16(BTS),
+	/*5897*/ uint16(xReadSlashR),
+	/*5898*/ uint16(xArgRM64),
+	/*5899*/ uint16(xArgR64),
+	/*5900*/ uint16(xMatch),
+	/*5901*/ uint16(xCondIs64), 5904, 5924,
+	/*5904*/ uint16(xCondDataSize), 5908, 5916, 0,
+	/*5908*/ uint16(xSetOp), uint16(SHRD),
+	/*5910*/ uint16(xReadSlashR),
+	/*5911*/ uint16(xReadIb),
+	/*5912*/ uint16(xArgRM16),
+	/*5913*/ uint16(xArgR16),
+	/*5914*/ uint16(xArgImm8u),
+	/*5915*/ uint16(xMatch),
+	/*5916*/ uint16(xSetOp), uint16(SHRD),
+	/*5918*/ uint16(xReadSlashR),
+	/*5919*/ uint16(xReadIb),
+	/*5920*/ uint16(xArgRM32),
+	/*5921*/ uint16(xArgR32),
+	/*5922*/ uint16(xArgImm8u),
+	/*5923*/ uint16(xMatch),
+	/*5924*/ uint16(xCondDataSize), 5908, 5916, 5928,
+	/*5928*/ uint16(xSetOp), uint16(SHRD),
+	/*5930*/ uint16(xReadSlashR),
+	/*5931*/ uint16(xReadIb),
+	/*5932*/ uint16(xArgRM64),
+	/*5933*/ uint16(xArgR64),
+	/*5934*/ uint16(xArgImm8u),
+	/*5935*/ uint16(xMatch),
+	/*5936*/ uint16(xCondIs64), 5939, 5957,
+	/*5939*/ uint16(xCondDataSize), 5943, 5950, 0,
+	/*5943*/ uint16(xSetOp), uint16(SHRD),
+	/*5945*/ uint16(xReadSlashR),
+	/*5946*/ uint16(xArgRM16),
+	/*5947*/ uint16(xArgR16),
+	/*5948*/ uint16(xArgCL),
+	/*5949*/ uint16(xMatch),
+	/*5950*/ uint16(xSetOp), uint16(SHRD),
+	/*5952*/ uint16(xReadSlashR),
+	/*5953*/ uint16(xArgRM32),
+	/*5954*/ uint16(xArgR32),
+	/*5955*/ uint16(xArgCL),
+	/*5956*/ uint16(xMatch),
+	/*5957*/ uint16(xCondDataSize), 5943, 5950, 5961,
+	/*5961*/ uint16(xSetOp), uint16(SHRD),
+	/*5963*/ uint16(xReadSlashR),
+	/*5964*/ uint16(xArgRM64),
+	/*5965*/ uint16(xArgR64),
+	/*5966*/ uint16(xArgCL),
+	/*5967*/ uint16(xMatch),
+	/*5968*/ uint16(xCondByte), 3,
+	0xE8, 6217,
+	0xF0, 6220,
+	0xF8, 6223,
+	/*5976*/ uint16(xCondSlashR),
+	5985, // 0
+	6039, // 1
+	6093, // 2
+	6122, // 3
+	6151, // 4
+	6174, // 5
+	6197, // 6
+	6213, // 7
+	/*5985*/ uint16(xCondIs64), 5988, 6000,
+	/*5988*/ uint16(xCondDataSize), 5992, 5996, 0,
+	/*5992*/ uint16(xSetOp), uint16(FXSAVE),
+	/*5994*/ uint16(xArgM512byte),
+	/*5995*/ uint16(xMatch),
+	/*5996*/ uint16(xSetOp), uint16(FXSAVE),
+	/*5998*/ uint16(xArgM512byte),
+	/*5999*/ uint16(xMatch),
+	/*6000*/ uint16(xCondPrefix), 2,
+	0xF3, 6014,
+	0x0, 6006,
+	/*6006*/ uint16(xCondDataSize), 5992, 5996, 6010,
+	/*6010*/ uint16(xSetOp), uint16(FXSAVE64),
+	/*6012*/ uint16(xArgM512byte),
+	/*6013*/ uint16(xMatch),
+	/*6014*/ uint16(xCondDataSize), 6018, 6025, 6032,
+	/*6018*/ uint16(xCondIsMem), 6021, 0,
+	/*6021*/ uint16(xSetOp), uint16(RDFSBASE),
+	/*6023*/ uint16(xArgRM32),
+	/*6024*/ uint16(xMatch),
+	/*6025*/ uint16(xCondIsMem), 6028, 0,
+	/*6028*/ uint16(xSetOp), uint16(RDFSBASE),
+	/*6030*/ uint16(xArgRM32),
+	/*6031*/ uint16(xMatch),
+	/*6032*/ uint16(xCondIsMem), 6035, 0,
+	/*6035*/ uint16(xSetOp), uint16(RDFSBASE),
+	/*6037*/ uint16(xArgRM64),
+	/*6038*/ uint16(xMatch),
+	/*6039*/ uint16(xCondIs64), 6042, 6054,
+	/*6042*/ uint16(xCondDataSize), 6046, 6050, 0,
+	/*6046*/ uint16(xSetOp), uint16(FXRSTOR),
+	/*6048*/ uint16(xArgM512byte),
+	/*6049*/ uint16(xMatch),
+	/*6050*/ uint16(xSetOp), uint16(FXRSTOR),
+	/*6052*/ uint16(xArgM512byte),
+	/*6053*/ uint16(xMatch),
+	/*6054*/ uint16(xCondPrefix), 2,
+	0xF3, 6068,
+	0x0, 6060,
+	/*6060*/ uint16(xCondDataSize), 6046, 6050, 6064,
+	/*6064*/ uint16(xSetOp), uint16(FXRSTOR64),
+	/*6066*/ uint16(xArgM512byte),
+	/*6067*/ uint16(xMatch),
+	/*6068*/ uint16(xCondDataSize), 6072, 6079, 6086,
+	/*6072*/ uint16(xCondIsMem), 6075, 0,
+	/*6075*/ uint16(xSetOp), uint16(RDGSBASE),
+	/*6077*/ uint16(xArgRM32),
+	/*6078*/ uint16(xMatch),
+	/*6079*/ uint16(xCondIsMem), 6082, 0,
+	/*6082*/ uint16(xSetOp), uint16(RDGSBASE),
+	/*6084*/ uint16(xArgRM32),
+	/*6085*/ uint16(xMatch),
+	/*6086*/ uint16(xCondIsMem), 6089, 0,
+	/*6089*/ uint16(xSetOp), uint16(RDGSBASE),
+	/*6091*/ uint16(xArgRM64),
+	/*6092*/ uint16(xMatch),
+	/*6093*/ uint16(xCondIs64), 6096, 6100,
+	/*6096*/ uint16(xSetOp), uint16(LDMXCSR),
+	/*6098*/ uint16(xArgM32),
+	/*6099*/ uint16(xMatch),
+	/*6100*/ uint16(xCondPrefix), 2,
+	0xF3, 6106,
+	0x0, 6096,
+	/*6106*/ uint16(xCondDataSize), 6110, 6114, 6118,
+	/*6110*/ uint16(xSetOp), uint16(WRFSBASE),
+	/*6112*/ uint16(xArgRM32),
+	/*6113*/ uint16(xMatch),
+	/*6114*/ uint16(xSetOp), uint16(WRFSBASE),
+	/*6116*/ uint16(xArgRM32),
+	/*6117*/ uint16(xMatch),
+	/*6118*/ uint16(xSetOp), uint16(WRFSBASE),
+	/*6120*/ uint16(xArgRM64),
+	/*6121*/ uint16(xMatch),
+	/*6122*/ uint16(xCondIs64), 6125, 6129,
+	/*6125*/ uint16(xSetOp), uint16(STMXCSR),
+	/*6127*/ uint16(xArgM32),
+	/*6128*/ uint16(xMatch),
+	/*6129*/ uint16(xCondPrefix), 2,
+	0xF3, 6135,
+	0x0, 6125,
+	/*6135*/ uint16(xCondDataSize), 6139, 6143, 6147,
+	/*6139*/ uint16(xSetOp), uint16(WRGSBASE),
+	/*6141*/ uint16(xArgRM32),
+	/*6142*/ uint16(xMatch),
+	/*6143*/ uint16(xSetOp), uint16(WRGSBASE),
+	/*6145*/ uint16(xArgRM32),
+	/*6146*/ uint16(xMatch),
+	/*6147*/ uint16(xSetOp), uint16(WRGSBASE),
+	/*6149*/ uint16(xArgRM64),
+	/*6150*/ uint16(xMatch),
+	/*6151*/ uint16(xCondIs64), 6154, 6166,
+	/*6154*/ uint16(xCondDataSize), 6158, 6162, 0,
+	/*6158*/ uint16(xSetOp), uint16(XSAVE),
+	/*6160*/ uint16(xArgMem),
+	/*6161*/ uint16(xMatch),
+	/*6162*/ uint16(xSetOp), uint16(XSAVE),
+	/*6164*/ uint16(xArgMem),
+	/*6165*/ uint16(xMatch),
+	/*6166*/ uint16(xCondDataSize), 6158, 6162, 6170,
+	/*6170*/ uint16(xSetOp), uint16(XSAVE64),
+	/*6172*/ uint16(xArgMem),
+	/*6173*/ uint16(xMatch),
+	/*6174*/ uint16(xCondIs64), 6177, 6189,
+	/*6177*/ uint16(xCondDataSize), 6181, 6185, 0,
+	/*6181*/ uint16(xSetOp), uint16(XRSTOR),
+	/*6183*/ uint16(xArgMem),
+	/*6184*/ uint16(xMatch),
+	/*6185*/ uint16(xSetOp), uint16(XRSTOR),
+	/*6187*/ uint16(xArgMem),
+	/*6188*/ uint16(xMatch),
+	/*6189*/ uint16(xCondDataSize), 6181, 6185, 6193,
+	/*6193*/ uint16(xSetOp), uint16(XRSTOR64),
+	/*6195*/ uint16(xArgMem),
+	/*6196*/ uint16(xMatch),
+	/*6197*/ uint16(xCondDataSize), 6201, 6205, 6209,
+	/*6201*/ uint16(xSetOp), uint16(XSAVEOPT),
+	/*6203*/ uint16(xArgMem),
+	/*6204*/ uint16(xMatch),
+	/*6205*/ uint16(xSetOp), uint16(XSAVEOPT),
+	/*6207*/ uint16(xArgMem),
+	/*6208*/ uint16(xMatch),
+	/*6209*/ uint16(xSetOp), uint16(XSAVEOPT64),
+	/*6211*/ uint16(xArgMem),
+	/*6212*/ uint16(xMatch),
+	/*6213*/ uint16(xSetOp), uint16(CLFLUSH),
+	/*6215*/ uint16(xArgM8),
+	/*6216*/ uint16(xMatch),
+	/*6217*/ uint16(xSetOp), uint16(LFENCE),
+	/*6219*/ uint16(xMatch),
+	/*6220*/ uint16(xSetOp), uint16(MFENCE),
+	/*6222*/ uint16(xMatch),
+	/*6223*/ uint16(xSetOp), uint16(SFENCE),
+	/*6225*/ uint16(xMatch),
+	/*6226*/ uint16(xCondIs64), 6229, 6245,
+	/*6229*/ uint16(xCondDataSize), 6233, 6239, 0,
+	/*6233*/ uint16(xSetOp), uint16(IMUL),
+	/*6235*/ uint16(xReadSlashR),
+	/*6236*/ uint16(xArgR16),
+	/*6237*/ uint16(xArgRM16),
+	/*6238*/ uint16(xMatch),
+	/*6239*/ uint16(xSetOp), uint16(IMUL),
+	/*6241*/ uint16(xReadSlashR),
+	/*6242*/ uint16(xArgR32),
+	/*6243*/ uint16(xArgRM32),
+	/*6244*/ uint16(xMatch),
+	/*6245*/ uint16(xCondDataSize), 6233, 6239, 6249,
+	/*6249*/ uint16(xSetOp), uint16(IMUL),
+	/*6251*/ uint16(xReadSlashR),
+	/*6252*/ uint16(xArgR64),
+	/*6253*/ uint16(xArgRM64),
+	/*6254*/ uint16(xMatch),
+	/*6255*/ uint16(xSetOp), uint16(CMPXCHG),
+	/*6257*/ uint16(xReadSlashR),
+	/*6258*/ uint16(xArgRM8),
+	/*6259*/ uint16(xArgR8),
+	/*6260*/ uint16(xMatch),
+	/*6261*/ uint16(xCondIs64), 6264, 6280,
+	/*6264*/ uint16(xCondDataSize), 6268, 6274, 0,
+	/*6268*/ uint16(xSetOp), uint16(CMPXCHG),
+	/*6270*/ uint16(xReadSlashR),
+	/*6271*/ uint16(xArgRM16),
+	/*6272*/ uint16(xArgR16),
+	/*6273*/ uint16(xMatch),
+	/*6274*/ uint16(xSetOp), uint16(CMPXCHG),
+	/*6276*/ uint16(xReadSlashR),
+	/*6277*/ uint16(xArgRM32),
+	/*6278*/ uint16(xArgR32),
+	/*6279*/ uint16(xMatch),
+	/*6280*/ uint16(xCondDataSize), 6268, 6274, 6284,
+	/*6284*/ uint16(xSetOp), uint16(CMPXCHG),
+	/*6286*/ uint16(xReadSlashR),
+	/*6287*/ uint16(xArgRM64),
+	/*6288*/ uint16(xArgR64),
+	/*6289*/ uint16(xMatch),
+	/*6290*/ uint16(xCondIs64), 6293, 6309,
+	/*6293*/ uint16(xCondDataSize), 6297, 6303, 0,
+	/*6297*/ uint16(xSetOp), uint16(LSS),
+	/*6299*/ uint16(xReadSlashR),
+	/*6300*/ uint16(xArgR16),
+	/*6301*/ uint16(xArgM16colon16),
+	/*6302*/ uint16(xMatch),
+	/*6303*/ uint16(xSetOp), uint16(LSS),
+	/*6305*/ uint16(xReadSlashR),
+	/*6306*/ uint16(xArgR32),
+	/*6307*/ uint16(xArgM16colon32),
+	/*6308*/ uint16(xMatch),
+	/*6309*/ uint16(xCondDataSize), 6297, 6303, 6313,
+	/*6313*/ uint16(xSetOp), uint16(LSS),
+	/*6315*/ uint16(xReadSlashR),
+	/*6316*/ uint16(xArgR64),
+	/*6317*/ uint16(xArgM16colon64),
+	/*6318*/ uint16(xMatch),
+	/*6319*/ uint16(xCondIs64), 6322, 6338,
+	/*6322*/ uint16(xCondDataSize), 6326, 6332, 0,
+	/*6326*/ uint16(xSetOp), uint16(BTR),
+	/*6328*/ uint16(xReadSlashR),
+	/*6329*/ uint16(xArgRM16),
+	/*6330*/ uint16(xArgR16),
+	/*6331*/ uint16(xMatch),
+	/*6332*/ uint16(xSetOp), uint16(BTR),
+	/*6334*/ uint16(xReadSlashR),
+	/*6335*/ uint16(xArgRM32),
+	/*6336*/ uint16(xArgR32),
+	/*6337*/ uint16(xMatch),
+	/*6338*/ uint16(xCondDataSize), 6326, 6332, 6342,
+	/*6342*/ uint16(xSetOp), uint16(BTR),
+	/*6344*/ uint16(xReadSlashR),
+	/*6345*/ uint16(xArgRM64),
+	/*6346*/ uint16(xArgR64),
+	/*6347*/ uint16(xMatch),
+	/*6348*/ uint16(xCondIs64), 6351, 6367,
+	/*6351*/ uint16(xCondDataSize), 6355, 6361, 0,
+	/*6355*/ uint16(xSetOp), uint16(LFS),
+	/*6357*/ uint16(xReadSlashR),
+	/*6358*/ uint16(xArgR16),
+	/*6359*/ uint16(xArgM16colon16),
+	/*6360*/ uint16(xMatch),
+	/*6361*/ uint16(xSetOp), uint16(LFS),
+	/*6363*/ uint16(xReadSlashR),
+	/*6364*/ uint16(xArgR32),
+	/*6365*/ uint16(xArgM16colon32),
+	/*6366*/ uint16(xMatch),
+	/*6367*/ uint16(xCondDataSize), 6355, 6361, 6371,
+	/*6371*/ uint16(xSetOp), uint16(LFS),
+	/*6373*/ uint16(xReadSlashR),
+	/*6374*/ uint16(xArgR64),
+	/*6375*/ uint16(xArgM16colon64),
+	/*6376*/ uint16(xMatch),
+	/*6377*/ uint16(xCondIs64), 6380, 6396,
+	/*6380*/ uint16(xCondDataSize), 6384, 6390, 0,
+	/*6384*/ uint16(xSetOp), uint16(LGS),
+	/*6386*/ uint16(xReadSlashR),
+	/*6387*/ uint16(xArgR16),
+	/*6388*/ uint16(xArgM16colon16),
+	/*6389*/ uint16(xMatch),
+	/*6390*/ uint16(xSetOp), uint16(LGS),
+	/*6392*/ uint16(xReadSlashR),
+	/*6393*/ uint16(xArgR32),
+	/*6394*/ uint16(xArgM16colon32),
+	/*6395*/ uint16(xMatch),
+	/*6396*/ uint16(xCondDataSize), 6384, 6390, 6400,
+	/*6400*/ uint16(xSetOp), uint16(LGS),
+	/*6402*/ uint16(xReadSlashR),
+	/*6403*/ uint16(xArgR64),
+	/*6404*/ uint16(xArgM16colon64),
+	/*6405*/ uint16(xMatch),
+	/*6406*/ uint16(xCondIs64), 6409, 6425,
+	/*6409*/ uint16(xCondDataSize), 6413, 6419, 0,
+	/*6413*/ uint16(xSetOp), uint16(MOVZX),
+	/*6415*/ uint16(xReadSlashR),
+	/*6416*/ uint16(xArgR16),
+	/*6417*/ uint16(xArgRM8),
+	/*6418*/ uint16(xMatch),
+	/*6419*/ uint16(xSetOp), uint16(MOVZX),
+	/*6421*/ uint16(xReadSlashR),
+	/*6422*/ uint16(xArgR32),
+	/*6423*/ uint16(xArgRM8),
+	/*6424*/ uint16(xMatch),
+	/*6425*/ uint16(xCondDataSize), 6413, 6419, 6429,
+	/*6429*/ uint16(xSetOp), uint16(MOVZX),
+	/*6431*/ uint16(xReadSlashR),
+	/*6432*/ uint16(xArgR64),
+	/*6433*/ uint16(xArgRM8),
+	/*6434*/ uint16(xMatch),
+	/*6435*/ uint16(xCondIs64), 6438, 6454,
+	/*6438*/ uint16(xCondDataSize), 6442, 6448, 0,
+	/*6442*/ uint16(xSetOp), uint16(MOVZX),
+	/*6444*/ uint16(xReadSlashR),
+	/*6445*/ uint16(xArgR16),
+	/*6446*/ uint16(xArgRM16),
+	/*6447*/ uint16(xMatch),
+	/*6448*/ uint16(xSetOp), uint16(MOVZX),
+	/*6450*/ uint16(xReadSlashR),
+	/*6451*/ uint16(xArgR32),
+	/*6452*/ uint16(xArgRM16),
+	/*6453*/ uint16(xMatch),
+	/*6454*/ uint16(xCondDataSize), 6442, 6448, 6458,
+	/*6458*/ uint16(xSetOp), uint16(MOVZX),
+	/*6460*/ uint16(xReadSlashR),
+	/*6461*/ uint16(xArgR64),
+	/*6462*/ uint16(xArgRM16),
+	/*6463*/ uint16(xMatch),
+	/*6464*/ uint16(xCondIs64), 6467, 6487,
+	/*6467*/ uint16(xCondPrefix), 1,
+	0xF3, 6471,
+	/*6471*/ uint16(xCondDataSize), 6475, 6481, 0,
+	/*6475*/ uint16(xSetOp), uint16(POPCNT),
+	/*6477*/ uint16(xReadSlashR),
+	/*6478*/ uint16(xArgR16),
+	/*6479*/ uint16(xArgRM16),
+	/*6480*/ uint16(xMatch),
+	/*6481*/ uint16(xSetOp), uint16(POPCNT),
+	/*6483*/ uint16(xReadSlashR),
+	/*6484*/ uint16(xArgR32),
+	/*6485*/ uint16(xArgRM32),
+	/*6486*/ uint16(xMatch),
+	/*6487*/ uint16(xCondPrefix), 1,
+	0xF3, 6491,
+	/*6491*/ uint16(xCondDataSize), 6475, 6481, 6495,
+	/*6495*/ uint16(xSetOp), uint16(POPCNT),
+	/*6497*/ uint16(xReadSlashR),
+	/*6498*/ uint16(xArgR64),
+	/*6499*/ uint16(xArgRM64),
+	/*6500*/ uint16(xMatch),
+	/*6501*/ uint16(xCondDataSize), 0, 6505, 0,
+	/*6505*/ uint16(xSetOp), uint16(UD1),
+	/*6507*/ uint16(xReadSlashR),
+	/*6508*/ uint16(xArgR32),
+	/*6509*/ uint16(xArgRM32),
+	/*6510*/ uint16(xMatch),
+	/*6511*/ uint16(xCondSlashR),
 	0,    // 0
 	0,    // 1
 	0,    // 2
 	0,    // 3
-	6511, // 4
-	6540, // 5
-	6569, // 6
-	6598, // 7
-	/*6511*/ uint16(xCondIs64), 6514, 6530,
-	/*6514*/ uint16(xCondDataSize), 6518, 6524, 0,
-	/*6518*/ uint16(xSetOp), uint16(BT),
-	/*6520*/ uint16(xReadIb),
-	/*6521*/ uint16(xArgRM16),
-	/*6522*/ uint16(xArgImm8u),
-	/*6523*/ uint16(xMatch),
-	/*6524*/ uint16(xSetOp), uint16(BT),
-	/*6526*/ uint16(xReadIb),
-	/*6527*/ uint16(xArgRM32),
-	/*6528*/ uint16(xArgImm8u),
-	/*6529*/ uint16(xMatch),
-	/*6530*/ uint16(xCondDataSize), 6518, 6524, 6534,
-	/*6534*/ uint16(xSetOp), uint16(BT),
-	/*6536*/ uint16(xReadIb),
-	/*6537*/ uint16(xArgRM64),
-	/*6538*/ uint16(xArgImm8u),
-	/*6539*/ uint16(xMatch),
-	/*6540*/ uint16(xCondIs64), 6543, 6559,
-	/*6543*/ uint16(xCondDataSize), 6547, 6553, 0,
-	/*6547*/ uint16(xSetOp), uint16(BTS),
-	/*6549*/ uint16(xReadIb),
-	/*6550*/ uint16(xArgRM16),
-	/*6551*/ uint16(xArgImm8u),
-	/*6552*/ uint16(xMatch),
-	/*6553*/ uint16(xSetOp), uint16(BTS),
-	/*6555*/ uint16(xReadIb),
-	/*6556*/ uint16(xArgRM32),
-	/*6557*/ uint16(xArgImm8u),
-	/*6558*/ uint16(xMatch),
-	/*6559*/ uint16(xCondDataSize), 6547, 6553, 6563,
-	/*6563*/ uint16(xSetOp), uint16(BTS),
-	/*6565*/ uint16(xReadIb),
-	/*6566*/ uint16(xArgRM64),
-	/*6567*/ uint16(xArgImm8u),
-	/*6568*/ uint16(xMatch),
-	/*6569*/ uint16(xCondIs64), 6572, 6588,
-	/*6572*/ uint16(xCondDataSize), 6576, 6582, 0,
-	/*6576*/ uint16(xSetOp), uint16(BTR),
-	/*6578*/ uint16(xReadIb),
-	/*6579*/ uint16(xArgRM16),
-	/*6580*/ uint16(xArgImm8u),
-	/*6581*/ uint16(xMatch),
-	/*6582*/ uint16(xSetOp), uint16(BTR),
-	/*6584*/ uint16(xReadIb),
-	/*6585*/ uint16(xArgRM32),
-	/*6586*/ uint16(xArgImm8u),
-	/*6587*/ uint16(xMatch),
-	/*6588*/ uint16(xCondDataSize), 6576, 6582, 6592,
-	/*6592*/ uint16(xSetOp), uint16(BTR),
-	/*6594*/ uint16(xReadIb),
-	/*6595*/ uint16(xArgRM64),
-	/*6596*/ uint16(xArgImm8u),
-	/*6597*/ uint16(xMatch),
-	/*6598*/ uint16(xCondIs64), 6601, 6617,
-	/*6601*/ uint16(xCondDataSize), 6605, 6611, 0,
-	/*6605*/ uint16(xSetOp), uint16(BTC),
-	/*6607*/ uint16(xReadIb),
-	/*6608*/ uint16(xArgRM16),
-	/*6609*/ uint16(xArgImm8u),
-	/*6610*/ uint16(xMatch),
-	/*6611*/ uint16(xSetOp), uint16(BTC),
-	/*6613*/ uint16(xReadIb),
-	/*6614*/ uint16(xArgRM32),
-	/*6615*/ uint16(xArgImm8u),
-	/*6616*/ uint16(xMatch),
-	/*6617*/ uint16(xCondDataSize), 6605, 6611, 6621,
-	/*6621*/ uint16(xSetOp), uint16(BTC),
-	/*6623*/ uint16(xReadIb),
-	/*6624*/ uint16(xArgRM64),
-	/*6625*/ uint16(xArgImm8u),
-	/*6626*/ uint16(xMatch),
-	/*6627*/ uint16(xCondIs64), 6630, 6646,
-	/*6630*/ uint16(xCondDataSize), 6634, 6640, 0,
-	/*6634*/ uint16(xSetOp), uint16(BTC),
-	/*6636*/ uint16(xReadSlashR),
-	/*6637*/ uint16(xArgRM16),
-	/*6638*/ uint16(xArgR16),
-	/*6639*/ uint16(xMatch),
-	/*6640*/ uint16(xSetOp), uint16(BTC),
-	/*6642*/ uint16(xReadSlashR),
-	/*6643*/ uint16(xArgRM32),
-	/*6644*/ uint16(xArgR32),
-	/*6645*/ uint16(xMatch),
-	/*6646*/ uint16(xCondDataSize), 6634, 6640, 6650,
-	/*6650*/ uint16(xSetOp), uint16(BTC),
-	/*6652*/ uint16(xReadSlashR),
-	/*6653*/ uint16(xArgRM64),
-	/*6654*/ uint16(xArgR64),
-	/*6655*/ uint16(xMatch),
-	/*6656*/ uint16(xCondIs64), 6659, 6697,
-	/*6659*/ uint16(xCondPrefix), 2,
-	0xF3, 6681,
-	0x0, 6665,
-	/*6665*/ uint16(xCondDataSize), 6669, 6675, 0,
-	/*6669*/ uint16(xSetOp), uint16(BSF),
-	/*6671*/ uint16(xReadSlashR),
-	/*6672*/ uint16(xArgR16),
-	/*6673*/ uint16(xArgRM16),
-	/*6674*/ uint16(xMatch),
-	/*6675*/ uint16(xSetOp), uint16(BSF),
-	/*6677*/ uint16(xReadSlashR),
-	/*6678*/ uint16(xArgR32),
-	/*6679*/ uint16(xArgRM32),
-	/*6680*/ uint16(xMatch),
-	/*6681*/ uint16(xCondDataSize), 6685, 6691, 0,
-	/*6685*/ uint16(xSetOp), uint16(TZCNT),
-	/*6687*/ uint16(xReadSlashR),
-	/*6688*/ uint16(xArgR16),
-	/*6689*/ uint16(xArgRM16),
-	/*6690*/ uint16(xMatch),
-	/*6691*/ uint16(xSetOp), uint16(TZCNT),
-	/*6693*/ uint16(xReadSlashR),
-	/*6694*/ uint16(xArgR32),
-	/*6695*/ uint16(xArgRM32),
-	/*6696*/ uint16(xMatch),
-	/*6697*/ uint16(xCondPrefix), 2,
-	0xF3, 6713,
-	0x0, 6703,
-	/*6703*/ uint16(xCondDataSize), 6669, 6675, 6707,
-	/*6707*/ uint16(xSetOp), uint16(BSF),
-	/*6709*/ uint16(xReadSlashR),
-	/*6710*/ uint16(xArgR64),
-	/*6711*/ uint16(xArgRM64),
-	/*6712*/ uint16(xMatch),
-	/*6713*/ uint16(xCondDataSize), 6685, 6691, 6717,
-	/*6717*/ uint16(xSetOp), uint16(TZCNT),
-	/*6719*/ uint16(xReadSlashR),
-	/*6720*/ uint16(xArgR64),
-	/*6721*/ uint16(xArgRM64),
-	/*6722*/ uint16(xMatch),
-	/*6723*/ uint16(xCondIs64), 6726, 6764,
-	/*6726*/ uint16(xCondPrefix), 2,
-	0xF3, 6748,
-	0x0, 6732,
-	/*6732*/ uint16(xCondDataSize), 6736, 6742, 0,
-	/*6736*/ uint16(xSetOp), uint16(BSR),
-	/*6738*/ uint16(xReadSlashR),
-	/*6739*/ uint16(xArgR16),
-	/*6740*/ uint16(xArgRM16),
-	/*6741*/ uint16(xMatch),
-	/*6742*/ uint16(xSetOp), uint16(BSR),
-	/*6744*/ uint16(xReadSlashR),
-	/*6745*/ uint16(xArgR32),
-	/*6746*/ uint16(xArgRM32),
-	/*6747*/ uint16(xMatch),
-	/*6748*/ uint16(xCondDataSize), 6752, 6758, 0,
-	/*6752*/ uint16(xSetOp), uint16(LZCNT),
-	/*6754*/ uint16(xReadSlashR),
-	/*6755*/ uint16(xArgR16),
-	/*6756*/ uint16(xArgRM16),
-	/*6757*/ uint16(xMatch),
-	/*6758*/ uint16(xSetOp), uint16(LZCNT),
-	/*6760*/ uint16(xReadSlashR),
-	/*6761*/ uint16(xArgR32),
-	/*6762*/ uint16(xArgRM32),
-	/*6763*/ uint16(xMatch),
-	/*6764*/ uint16(xCondPrefix), 2,
-	0xF3, 6780,
-	0x0, 6770,
-	/*6770*/ uint16(xCondDataSize), 6736, 6742, 6774,
-	/*6774*/ uint16(xSetOp), uint16(BSR),
-	/*6776*/ uint16(xReadSlashR),
-	/*6777*/ uint16(xArgR64),
-	/*6778*/ uint16(xArgRM64),
-	/*6779*/ uint16(xMatch),
-	/*6780*/ uint16(xCondDataSize), 6752, 6758, 6784,
-	/*6784*/ uint16(xSetOp), uint16(LZCNT),
-	/*6786*/ uint16(xReadSlashR),
-	/*6787*/ uint16(xArgR64),
-	/*6788*/ uint16(xArgRM64),
-	/*6789*/ uint16(xMatch),
-	/*6790*/ uint16(xCondIs64), 6793, 6809,
-	/*6793*/ uint16(xCondDataSize), 6797, 6803, 0,
-	/*6797*/ uint16(xSetOp), uint16(MOVSX),
-	/*6799*/ uint16(xReadSlashR),
-	/*6800*/ uint16(xArgR16),
-	/*6801*/ uint16(xArgRM8),
-	/*6802*/ uint16(xMatch),
-	/*6803*/ uint16(xSetOp), uint16(MOVSX),
-	/*6805*/ uint16(xReadSlashR),
-	/*6806*/ uint16(xArgR32),
-	/*6807*/ uint16(xArgRM8),
-	/*6808*/ uint16(xMatch),
-	/*6809*/ uint16(xCondDataSize), 6797, 6803, 6813,
-	/*6813*/ uint16(xSetOp), uint16(MOVSX),
-	/*6815*/ uint16(xReadSlashR),
-	/*6816*/ uint16(xArgR64),
-	/*6817*/ uint16(xArgRM8),
-	/*6818*/ uint16(xMatch),
-	/*6819*/ uint16(xCondIs64), 6822, 6838,
-	/*6822*/ uint16(xCondDataSize), 6826, 6832, 0,
-	/*6826*/ uint16(xSetOp), uint16(MOVSX),
-	/*6828*/ uint16(xReadSlashR),
-	/*6829*/ uint16(xArgR16),
-	/*6830*/ uint16(xArgRM16),
-	/*6831*/ uint16(xMatch),
-	/*6832*/ uint16(xSetOp), uint16(MOVSX),
-	/*6834*/ uint16(xReadSlashR),
-	/*6835*/ uint16(xArgR32),
-	/*6836*/ uint16(xArgRM16),
-	/*6837*/ uint16(xMatch),
-	/*6838*/ uint16(xCondDataSize), 6826, 6832, 6842,
-	/*6842*/ uint16(xSetOp), uint16(MOVSX),
-	/*6844*/ uint16(xReadSlashR),
-	/*6845*/ uint16(xArgR64),
-	/*6846*/ uint16(xArgRM16),
-	/*6847*/ uint16(xMatch),
-	/*6848*/ uint16(xSetOp), uint16(XADD),
-	/*6850*/ uint16(xReadSlashR),
-	/*6851*/ uint16(xArgRM8),
-	/*6852*/ uint16(xArgR8),
-	/*6853*/ uint16(xMatch),
-	/*6854*/ uint16(xCondIs64), 6857, 6873,
-	/*6857*/ uint16(xCondDataSize), 6861, 6867, 0,
-	/*6861*/ uint16(xSetOp), uint16(XADD),
-	/*6863*/ uint16(xReadSlashR),
-	/*6864*/ uint16(xArgRM16),
-	/*6865*/ uint16(xArgR16),
-	/*6866*/ uint16(xMatch),
-	/*6867*/ uint16(xSetOp), uint16(XADD),
-	/*6869*/ uint16(xReadSlashR),
-	/*6870*/ uint16(xArgRM32),
-	/*6871*/ uint16(xArgR32),
-	/*6872*/ uint16(xMatch),
-	/*6873*/ uint16(xCondDataSize), 6861, 6867, 6877,
-	/*6877*/ uint16(xSetOp), uint16(XADD),
-	/*6879*/ uint16(xReadSlashR),
-	/*6880*/ uint16(xArgRM64),
-	/*6881*/ uint16(xArgR64),
-	/*6882*/ uint16(xMatch),
-	/*6883*/ uint16(xCondPrefix), 4,
-	0xF3, 6917,
-	0xF2, 6909,
-	0x66, 6901,
-	0x0, 6893,
-	/*6893*/ uint16(xSetOp), uint16(CMPPS),
-	/*6895*/ uint16(xReadSlashR),
-	/*6896*/ uint16(xReadIb),
-	/*6897*/ uint16(xArgXmm1),
-	/*6898*/ uint16(xArgXmm2M128),
-	/*6899*/ uint16(xArgImm8u),
-	/*6900*/ uint16(xMatch),
-	/*6901*/ uint16(xSetOp), uint16(CMPPD),
-	/*6903*/ uint16(xReadSlashR),
-	/*6904*/ uint16(xReadIb),
-	/*6905*/ uint16(xArgXmm1),
-	/*6906*/ uint16(xArgXmm2M128),
-	/*6907*/ uint16(xArgImm8u),
-	/*6908*/ uint16(xMatch),
-	/*6909*/ uint16(xSetOp), uint16(CMPSD_XMM),
-	/*6911*/ uint16(xReadSlashR),
-	/*6912*/ uint16(xReadIb),
-	/*6913*/ uint16(xArgXmm1),
-	/*6914*/ uint16(xArgXmm2M64),
-	/*6915*/ uint16(xArgImm8u),
-	/*6916*/ uint16(xMatch),
-	/*6917*/ uint16(xSetOp), uint16(CMPSS),
-	/*6919*/ uint16(xReadSlashR),
-	/*6920*/ uint16(xReadIb),
-	/*6921*/ uint16(xArgXmm1),
-	/*6922*/ uint16(xArgXmm2M32),
-	/*6923*/ uint16(xArgImm8u),
-	/*6924*/ uint16(xMatch),
-	/*6925*/ uint16(xCondIs64), 6928, 6944,
-	/*6928*/ uint16(xCondDataSize), 6932, 6938, 0,
-	/*6932*/ uint16(xSetOp), uint16(MOVNTI),
-	/*6934*/ uint16(xReadSlashR),
-	/*6935*/ uint16(xArgM32),
-	/*6936*/ uint16(xArgR32),
-	/*6937*/ uint16(xMatch),
-	/*6938*/ uint16(xSetOp), uint16(MOVNTI),
-	/*6940*/ uint16(xReadSlashR),
-	/*6941*/ uint16(xArgM32),
-	/*6942*/ uint16(xArgR32),
-	/*6943*/ uint16(xMatch),
-	/*6944*/ uint16(xCondDataSize), 6932, 6938, 6948,
-	/*6948*/ uint16(xSetOp), uint16(MOVNTI),
-	/*6950*/ uint16(xReadSlashR),
-	/*6951*/ uint16(xArgM64),
-	/*6952*/ uint16(xArgR64),
-	/*6953*/ uint16(xMatch),
-	/*6954*/ uint16(xCondPrefix), 2,
-	0x66, 6968,
-	0x0, 6960,
-	/*6960*/ uint16(xSetOp), uint16(PINSRW),
-	/*6962*/ uint16(xReadSlashR),
-	/*6963*/ uint16(xReadIb),
-	/*6964*/ uint16(xArgMm),
-	/*6965*/ uint16(xArgR32M16),
-	/*6966*/ uint16(xArgImm8u),
-	/*6967*/ uint16(xMatch),
-	/*6968*/ uint16(xSetOp), uint16(PINSRW),
-	/*6970*/ uint16(xReadSlashR),
-	/*6971*/ uint16(xReadIb),
-	/*6972*/ uint16(xArgXmm),
-	/*6973*/ uint16(xArgR32M16),
-	/*6974*/ uint16(xArgImm8u),
-	/*6975*/ uint16(xMatch),
-	/*6976*/ uint16(xCondPrefix), 2,
-	0x66, 6990,
-	0x0, 6982,
-	/*6982*/ uint16(xSetOp), uint16(PEXTRW),
-	/*6984*/ uint16(xReadSlashR),
-	/*6985*/ uint16(xReadIb),
-	/*6986*/ uint16(xArgR32),
-	/*6987*/ uint16(xArgMm2),
-	/*6988*/ uint16(xArgImm8u),
-	/*6989*/ uint16(xMatch),
-	/*6990*/ uint16(xSetOp), uint16(PEXTRW),
-	/*6992*/ uint16(xReadSlashR),
-	/*6993*/ uint16(xReadIb),
-	/*6994*/ uint16(xArgR32),
-	/*6995*/ uint16(xArgXmm2),
-	/*6996*/ uint16(xArgImm8u),
-	/*6997*/ uint16(xMatch),
-	/*6998*/ uint16(xCondPrefix), 2,
-	0x66, 7012,
-	0x0, 7004,
-	/*7004*/ uint16(xSetOp), uint16(SHUFPS),
-	/*7006*/ uint16(xReadSlashR),
-	/*7007*/ uint16(xReadIb),
-	/*7008*/ uint16(xArgXmm1),
-	/*7009*/ uint16(xArgXmm2M128),
-	/*7010*/ uint16(xArgImm8u),
-	/*7011*/ uint16(xMatch),
-	/*7012*/ uint16(xSetOp), uint16(SHUFPD),
-	/*7014*/ uint16(xReadSlashR),
-	/*7015*/ uint16(xReadIb),
-	/*7016*/ uint16(xArgXmm1),
-	/*7017*/ uint16(xArgXmm2M128),
-	/*7018*/ uint16(xArgImm8u),
-	/*7019*/ uint16(xMatch),
-	/*7020*/ uint16(xCondSlashR),
+	6520, // 4
+	6549, // 5
+	6578, // 6
+	6607, // 7
+	/*6520*/ uint16(xCondIs64), 6523, 6539,
+	/*6523*/ uint16(xCondDataSize), 6527, 6533, 0,
+	/*6527*/ uint16(xSetOp), uint16(BT),
+	/*6529*/ uint16(xReadIb),
+	/*6530*/ uint16(xArgRM16),
+	/*6531*/ uint16(xArgImm8u),
+	/*6532*/ uint16(xMatch),
+	/*6533*/ uint16(xSetOp), uint16(BT),
+	/*6535*/ uint16(xReadIb),
+	/*6536*/ uint16(xArgRM32),
+	/*6537*/ uint16(xArgImm8u),
+	/*6538*/ uint16(xMatch),
+	/*6539*/ uint16(xCondDataSize), 6527, 6533, 6543,
+	/*6543*/ uint16(xSetOp), uint16(BT),
+	/*6545*/ uint16(xReadIb),
+	/*6546*/ uint16(xArgRM64),
+	/*6547*/ uint16(xArgImm8u),
+	/*6548*/ uint16(xMatch),
+	/*6549*/ uint16(xCondIs64), 6552, 6568,
+	/*6552*/ uint16(xCondDataSize), 6556, 6562, 0,
+	/*6556*/ uint16(xSetOp), uint16(BTS),
+	/*6558*/ uint16(xReadIb),
+	/*6559*/ uint16(xArgRM16),
+	/*6560*/ uint16(xArgImm8u),
+	/*6561*/ uint16(xMatch),
+	/*6562*/ uint16(xSetOp), uint16(BTS),
+	/*6564*/ uint16(xReadIb),
+	/*6565*/ uint16(xArgRM32),
+	/*6566*/ uint16(xArgImm8u),
+	/*6567*/ uint16(xMatch),
+	/*6568*/ uint16(xCondDataSize), 6556, 6562, 6572,
+	/*6572*/ uint16(xSetOp), uint16(BTS),
+	/*6574*/ uint16(xReadIb),
+	/*6575*/ uint16(xArgRM64),
+	/*6576*/ uint16(xArgImm8u),
+	/*6577*/ uint16(xMatch),
+	/*6578*/ uint16(xCondIs64), 6581, 6597,
+	/*6581*/ uint16(xCondDataSize), 6585, 6591, 0,
+	/*6585*/ uint16(xSetOp), uint16(BTR),
+	/*6587*/ uint16(xReadIb),
+	/*6588*/ uint16(xArgRM16),
+	/*6589*/ uint16(xArgImm8u),
+	/*6590*/ uint16(xMatch),
+	/*6591*/ uint16(xSetOp), uint16(BTR),
+	/*6593*/ uint16(xReadIb),
+	/*6594*/ uint16(xArgRM32),
+	/*6595*/ uint16(xArgImm8u),
+	/*6596*/ uint16(xMatch),
+	/*6597*/ uint16(xCondDataSize), 6585, 6591, 6601,
+	/*6601*/ uint16(xSetOp), uint16(BTR),
+	/*6603*/ uint16(xReadIb),
+	/*6604*/ uint16(xArgRM64),
+	/*6605*/ uint16(xArgImm8u),
+	/*6606*/ uint16(xMatch),
+	/*6607*/ uint16(xCondIs64), 6610, 6626,
+	/*6610*/ uint16(xCondDataSize), 6614, 6620, 0,
+	/*6614*/ uint16(xSetOp), uint16(BTC),
+	/*6616*/ uint16(xReadIb),
+	/*6617*/ uint16(xArgRM16),
+	/*6618*/ uint16(xArgImm8u),
+	/*6619*/ uint16(xMatch),
+	/*6620*/ uint16(xSetOp), uint16(BTC),
+	/*6622*/ uint16(xReadIb),
+	/*6623*/ uint16(xArgRM32),
+	/*6624*/ uint16(xArgImm8u),
+	/*6625*/ uint16(xMatch),
+	/*6626*/ uint16(xCondDataSize), 6614, 6620, 6630,
+	/*6630*/ uint16(xSetOp), uint16(BTC),
+	/*6632*/ uint16(xReadIb),
+	/*6633*/ uint16(xArgRM64),
+	/*6634*/ uint16(xArgImm8u),
+	/*6635*/ uint16(xMatch),
+	/*6636*/ uint16(xCondIs64), 6639, 6655,
+	/*6639*/ uint16(xCondDataSize), 6643, 6649, 0,
+	/*6643*/ uint16(xSetOp), uint16(BTC),
+	/*6645*/ uint16(xReadSlashR),
+	/*6646*/ uint16(xArgRM16),
+	/*6647*/ uint16(xArgR16),
+	/*6648*/ uint16(xMatch),
+	/*6649*/ uint16(xSetOp), uint16(BTC),
+	/*6651*/ uint16(xReadSlashR),
+	/*6652*/ uint16(xArgRM32),
+	/*6653*/ uint16(xArgR32),
+	/*6654*/ uint16(xMatch),
+	/*6655*/ uint16(xCondDataSize), 6643, 6649, 6659,
+	/*6659*/ uint16(xSetOp), uint16(BTC),
+	/*6661*/ uint16(xReadSlashR),
+	/*6662*/ uint16(xArgRM64),
+	/*6663*/ uint16(xArgR64),
+	/*6664*/ uint16(xMatch),
+	/*6665*/ uint16(xCondIs64), 6668, 6706,
+	/*6668*/ uint16(xCondPrefix), 2,
+	0xF3, 6690,
+	0x0, 6674,
+	/*6674*/ uint16(xCondDataSize), 6678, 6684, 0,
+	/*6678*/ uint16(xSetOp), uint16(BSF),
+	/*6680*/ uint16(xReadSlashR),
+	/*6681*/ uint16(xArgR16),
+	/*6682*/ uint16(xArgRM16),
+	/*6683*/ uint16(xMatch),
+	/*6684*/ uint16(xSetOp), uint16(BSF),
+	/*6686*/ uint16(xReadSlashR),
+	/*6687*/ uint16(xArgR32),
+	/*6688*/ uint16(xArgRM32),
+	/*6689*/ uint16(xMatch),
+	/*6690*/ uint16(xCondDataSize), 6694, 6700, 0,
+	/*6694*/ uint16(xSetOp), uint16(TZCNT),
+	/*6696*/ uint16(xReadSlashR),
+	/*6697*/ uint16(xArgR16),
+	/*6698*/ uint16(xArgRM16),
+	/*6699*/ uint16(xMatch),
+	/*6700*/ uint16(xSetOp), uint16(TZCNT),
+	/*6702*/ uint16(xReadSlashR),
+	/*6703*/ uint16(xArgR32),
+	/*6704*/ uint16(xArgRM32),
+	/*6705*/ uint16(xMatch),
+	/*6706*/ uint16(xCondPrefix), 2,
+	0xF3, 6722,
+	0x0, 6712,
+	/*6712*/ uint16(xCondDataSize), 6678, 6684, 6716,
+	/*6716*/ uint16(xSetOp), uint16(BSF),
+	/*6718*/ uint16(xReadSlashR),
+	/*6719*/ uint16(xArgR64),
+	/*6720*/ uint16(xArgRM64),
+	/*6721*/ uint16(xMatch),
+	/*6722*/ uint16(xCondDataSize), 6694, 6700, 6726,
+	/*6726*/ uint16(xSetOp), uint16(TZCNT),
+	/*6728*/ uint16(xReadSlashR),
+	/*6729*/ uint16(xArgR64),
+	/*6730*/ uint16(xArgRM64),
+	/*6731*/ uint16(xMatch),
+	/*6732*/ uint16(xCondIs64), 6735, 6773,
+	/*6735*/ uint16(xCondPrefix), 2,
+	0xF3, 6757,
+	0x0, 6741,
+	/*6741*/ uint16(xCondDataSize), 6745, 6751, 0,
+	/*6745*/ uint16(xSetOp), uint16(BSR),
+	/*6747*/ uint16(xReadSlashR),
+	/*6748*/ uint16(xArgR16),
+	/*6749*/ uint16(xArgRM16),
+	/*6750*/ uint16(xMatch),
+	/*6751*/ uint16(xSetOp), uint16(BSR),
+	/*6753*/ uint16(xReadSlashR),
+	/*6754*/ uint16(xArgR32),
+	/*6755*/ uint16(xArgRM32),
+	/*6756*/ uint16(xMatch),
+	/*6757*/ uint16(xCondDataSize), 6761, 6767, 0,
+	/*6761*/ uint16(xSetOp), uint16(LZCNT),
+	/*6763*/ uint16(xReadSlashR),
+	/*6764*/ uint16(xArgR16),
+	/*6765*/ uint16(xArgRM16),
+	/*6766*/ uint16(xMatch),
+	/*6767*/ uint16(xSetOp), uint16(LZCNT),
+	/*6769*/ uint16(xReadSlashR),
+	/*6770*/ uint16(xArgR32),
+	/*6771*/ uint16(xArgRM32),
+	/*6772*/ uint16(xMatch),
+	/*6773*/ uint16(xCondPrefix), 2,
+	0xF3, 6789,
+	0x0, 6779,
+	/*6779*/ uint16(xCondDataSize), 6745, 6751, 6783,
+	/*6783*/ uint16(xSetOp), uint16(BSR),
+	/*6785*/ uint16(xReadSlashR),
+	/*6786*/ uint16(xArgR64),
+	/*6787*/ uint16(xArgRM64),
+	/*6788*/ uint16(xMatch),
+	/*6789*/ uint16(xCondDataSize), 6761, 6767, 6793,
+	/*6793*/ uint16(xSetOp), uint16(LZCNT),
+	/*6795*/ uint16(xReadSlashR),
+	/*6796*/ uint16(xArgR64),
+	/*6797*/ uint16(xArgRM64),
+	/*6798*/ uint16(xMatch),
+	/*6799*/ uint16(xCondIs64), 6802, 6818,
+	/*6802*/ uint16(xCondDataSize), 6806, 6812, 0,
+	/*6806*/ uint16(xSetOp), uint16(MOVSX),
+	/*6808*/ uint16(xReadSlashR),
+	/*6809*/ uint16(xArgR16),
+	/*6810*/ uint16(xArgRM8),
+	/*6811*/ uint16(xMatch),
+	/*6812*/ uint16(xSetOp), uint16(MOVSX),
+	/*6814*/ uint16(xReadSlashR),
+	/*6815*/ uint16(xArgR32),
+	/*6816*/ uint16(xArgRM8),
+	/*6817*/ uint16(xMatch),
+	/*6818*/ uint16(xCondDataSize), 6806, 6812, 6822,
+	/*6822*/ uint16(xSetOp), uint16(MOVSX),
+	/*6824*/ uint16(xReadSlashR),
+	/*6825*/ uint16(xArgR64),
+	/*6826*/ uint16(xArgRM8),
+	/*6827*/ uint16(xMatch),
+	/*6828*/ uint16(xCondIs64), 6831, 6847,
+	/*6831*/ uint16(xCondDataSize), 6835, 6841, 0,
+	/*6835*/ uint16(xSetOp), uint16(MOVSX),
+	/*6837*/ uint16(xReadSlashR),
+	/*6838*/ uint16(xArgR16),
+	/*6839*/ uint16(xArgRM16),
+	/*6840*/ uint16(xMatch),
+	/*6841*/ uint16(xSetOp), uint16(MOVSX),
+	/*6843*/ uint16(xReadSlashR),
+	/*6844*/ uint16(xArgR32),
+	/*6845*/ uint16(xArgRM16),
+	/*6846*/ uint16(xMatch),
+	/*6847*/ uint16(xCondDataSize), 6835, 6841, 6851,
+	/*6851*/ uint16(xSetOp), uint16(MOVSX),
+	/*6853*/ uint16(xReadSlashR),
+	/*6854*/ uint16(xArgR64),
+	/*6855*/ uint16(xArgRM16),
+	/*6856*/ uint16(xMatch),
+	/*6857*/ uint16(xSetOp), uint16(XADD),
+	/*6859*/ uint16(xReadSlashR),
+	/*6860*/ uint16(xArgRM8),
+	/*6861*/ uint16(xArgR8),
+	/*6862*/ uint16(xMatch),
+	/*6863*/ uint16(xCondIs64), 6866, 6882,
+	/*6866*/ uint16(xCondDataSize), 6870, 6876, 0,
+	/*6870*/ uint16(xSetOp), uint16(XADD),
+	/*6872*/ uint16(xReadSlashR),
+	/*6873*/ uint16(xArgRM16),
+	/*6874*/ uint16(xArgR16),
+	/*6875*/ uint16(xMatch),
+	/*6876*/ uint16(xSetOp), uint16(XADD),
+	/*6878*/ uint16(xReadSlashR),
+	/*6879*/ uint16(xArgRM32),
+	/*6880*/ uint16(xArgR32),
+	/*6881*/ uint16(xMatch),
+	/*6882*/ uint16(xCondDataSize), 6870, 6876, 6886,
+	/*6886*/ uint16(xSetOp), uint16(XADD),
+	/*6888*/ uint16(xReadSlashR),
+	/*6889*/ uint16(xArgRM64),
+	/*6890*/ uint16(xArgR64),
+	/*6891*/ uint16(xMatch),
+	/*6892*/ uint16(xCondPrefix), 4,
+	0xF3, 6926,
+	0xF2, 6918,
+	0x66, 6910,
+	0x0, 6902,
+	/*6902*/ uint16(xSetOp), uint16(CMPPS),
+	/*6904*/ uint16(xReadSlashR),
+	/*6905*/ uint16(xReadIb),
+	/*6906*/ uint16(xArgXmm1),
+	/*6907*/ uint16(xArgXmm2M128),
+	/*6908*/ uint16(xArgImm8u),
+	/*6909*/ uint16(xMatch),
+	/*6910*/ uint16(xSetOp), uint16(CMPPD),
+	/*6912*/ uint16(xReadSlashR),
+	/*6913*/ uint16(xReadIb),
+	/*6914*/ uint16(xArgXmm1),
+	/*6915*/ uint16(xArgXmm2M128),
+	/*6916*/ uint16(xArgImm8u),
+	/*6917*/ uint16(xMatch),
+	/*6918*/ uint16(xSetOp), uint16(CMPSD_XMM),
+	/*6920*/ uint16(xReadSlashR),
+	/*6921*/ uint16(xReadIb),
+	/*6922*/ uint16(xArgXmm1),
+	/*6923*/ uint16(xArgXmm2M64),
+	/*6924*/ uint16(xArgImm8u),
+	/*6925*/ uint16(xMatch),
+	/*6926*/ uint16(xSetOp), uint16(CMPSS),
+	/*6928*/ uint16(xReadSlashR),
+	/*6929*/ uint16(xReadIb),
+	/*6930*/ uint16(xArgXmm1),
+	/*6931*/ uint16(xArgXmm2M32),
+	/*6932*/ uint16(xArgImm8u),
+	/*6933*/ uint16(xMatch),
+	/*6934*/ uint16(xCondIs64), 6937, 6953,
+	/*6937*/ uint16(xCondDataSize), 6941, 6947, 0,
+	/*6941*/ uint16(xSetOp), uint16(MOVNTI),
+	/*6943*/ uint16(xReadSlashR),
+	/*6944*/ uint16(xArgM32),
+	/*6945*/ uint16(xArgR32),
+	/*6946*/ uint16(xMatch),
+	/*6947*/ uint16(xSetOp), uint16(MOVNTI),
+	/*6949*/ uint16(xReadSlashR),
+	/*6950*/ uint16(xArgM32),
+	/*6951*/ uint16(xArgR32),
+	/*6952*/ uint16(xMatch),
+	/*6953*/ uint16(xCondDataSize), 6941, 6947, 6957,
+	/*6957*/ uint16(xSetOp), uint16(MOVNTI),
+	/*6959*/ uint16(xReadSlashR),
+	/*6960*/ uint16(xArgM64),
+	/*6961*/ uint16(xArgR64),
+	/*6962*/ uint16(xMatch),
+	/*6963*/ uint16(xCondPrefix), 2,
+	0x66, 6977,
+	0x0, 6969,
+	/*6969*/ uint16(xSetOp), uint16(PINSRW),
+	/*6971*/ uint16(xReadSlashR),
+	/*6972*/ uint16(xReadIb),
+	/*6973*/ uint16(xArgMm),
+	/*6974*/ uint16(xArgR32M16),
+	/*6975*/ uint16(xArgImm8u),
+	/*6976*/ uint16(xMatch),
+	/*6977*/ uint16(xSetOp), uint16(PINSRW),
+	/*6979*/ uint16(xReadSlashR),
+	/*6980*/ uint16(xReadIb),
+	/*6981*/ uint16(xArgXmm),
+	/*6982*/ uint16(xArgR32M16),
+	/*6983*/ uint16(xArgImm8u),
+	/*6984*/ uint16(xMatch),
+	/*6985*/ uint16(xCondPrefix), 2,
+	0x66, 6999,
+	0x0, 6991,
+	/*6991*/ uint16(xSetOp), uint16(PEXTRW),
+	/*6993*/ uint16(xReadSlashR),
+	/*6994*/ uint16(xReadIb),
+	/*6995*/ uint16(xArgR32),
+	/*6996*/ uint16(xArgMm2),
+	/*6997*/ uint16(xArgImm8u),
+	/*6998*/ uint16(xMatch),
+	/*6999*/ uint16(xSetOp), uint16(PEXTRW),
+	/*7001*/ uint16(xReadSlashR),
+	/*7002*/ uint16(xReadIb),
+	/*7003*/ uint16(xArgR32),
+	/*7004*/ uint16(xArgXmm2),
+	/*7005*/ uint16(xArgImm8u),
+	/*7006*/ uint16(xMatch),
+	/*7007*/ uint16(xCondPrefix), 2,
+	0x66, 7021,
+	0x0, 7013,
+	/*7013*/ uint16(xSetOp), uint16(SHUFPS),
+	/*7015*/ uint16(xReadSlashR),
+	/*7016*/ uint16(xReadIb),
+	/*7017*/ uint16(xArgXmm1),
+	/*7018*/ uint16(xArgXmm2M128),
+	/*7019*/ uint16(xArgImm8u),
+	/*7020*/ uint16(xMatch),
+	/*7021*/ uint16(xSetOp), uint16(SHUFPD),
+	/*7023*/ uint16(xReadSlashR),
+	/*7024*/ uint16(xReadIb),
+	/*7025*/ uint16(xArgXmm1),
+	/*7026*/ uint16(xArgXmm2M128),
+	/*7027*/ uint16(xArgImm8u),
+	/*7028*/ uint16(xMatch),
+	/*7029*/ uint16(xCondSlashR),
 	0,    // 0
-	7029, // 1
+	7038, // 1
 	0,    // 2
-	7052, // 3
-	7075, // 4
-	7098, // 5
-	7121, // 6
+	7061, // 3
+	7084, // 4
+	7107, // 5
+	7130, // 6
 	0,    // 7
-	/*7029*/ uint16(xCondIs64), 7032, 7044,
-	/*7032*/ uint16(xCondDataSize), 7036, 7040, 0,
-	/*7036*/ uint16(xSetOp), uint16(CMPXCHG8B),
-	/*7038*/ uint16(xArgM64),
-	/*7039*/ uint16(xMatch),
-	/*7040*/ uint16(xSetOp), uint16(CMPXCHG8B),
-	/*7042*/ uint16(xArgM64),
-	/*7043*/ uint16(xMatch),
-	/*7044*/ uint16(xCondDataSize), 7036, 7040, 7048,
-	/*7048*/ uint16(xSetOp), uint16(CMPXCHG16B),
-	/*7050*/ uint16(xArgM128),
-	/*7051*/ uint16(xMatch),
-	/*7052*/ uint16(xCondIs64), 7055, 7067,
-	/*7055*/ uint16(xCondDataSize), 7059, 7063, 0,
-	/*7059*/ uint16(xSetOp), uint16(XRSTORS),
-	/*7061*/ uint16(xArgMem),
-	/*7062*/ uint16(xMatch),
-	/*7063*/ uint16(xSetOp), uint16(XRSTORS),
-	/*7065*/ uint16(xArgMem),
-	/*7066*/ uint16(xMatch),
-	/*7067*/ uint16(xCondDataSize), 7059, 7063, 7071,
-	/*7071*/ uint16(xSetOp), uint16(XRSTORS64),
-	/*7073*/ uint16(xArgMem),
-	/*7074*/ uint16(xMatch),
-	/*7075*/ uint16(xCondIs64), 7078, 7090,
-	/*7078*/ uint16(xCondDataSize), 7082, 7086, 0,
-	/*7082*/ uint16(xSetOp), uint16(XSAVEC),
-	/*7084*/ uint16(xArgMem),
-	/*7085*/ uint16(xMatch),
-	/*7086*/ uint16(xSetOp), uint16(XSAVEC),
-	/*7088*/ uint16(xArgMem),
-	/*7089*/ uint16(xMatch),
-	/*7090*/ uint16(xCondDataSize), 7082, 7086, 7094,
-	/*7094*/ uint16(xSetOp), uint16(XSAVEC64),
-	/*7096*/ uint16(xArgMem),
-	/*7097*/ uint16(xMatch),
-	/*7098*/ uint16(xCondIs64), 7101, 7113,
-	/*7101*/ uint16(xCondDataSize), 7105, 7109, 0,
-	/*7105*/ uint16(xSetOp), uint16(XSAVES),
-	/*7107*/ uint16(xArgMem),
-	/*7108*/ uint16(xMatch),
-	/*7109*/ uint16(xSetOp), uint16(XSAVES),
-	/*7111*/ uint16(xArgMem),
-	/*7112*/ uint16(xMatch),
-	/*7113*/ uint16(xCondDataSize), 7105, 7109, 7117,
-	/*7117*/ uint16(xSetOp), uint16(XSAVES64),
-	/*7119*/ uint16(xArgMem),
-	/*7120*/ uint16(xMatch),
-	/*7121*/ uint16(xCondIs64), 7124, 7142,
-	/*7124*/ uint16(xCondDataSize), 7128, 7135, 0,
-	/*7128*/ uint16(xCondIsMem), 7131, 0,
-	/*7131*/ uint16(xSetOp), uint16(RDRAND),
-	/*7133*/ uint16(xArgRmf16),
-	/*7134*/ uint16(xMatch),
-	/*7135*/ uint16(xCondIsMem), 7138, 0,
-	/*7138*/ uint16(xSetOp), uint16(RDRAND),
-	/*7140*/ uint16(xArgRmf32),
-	/*7141*/ uint16(xMatch),
-	/*7142*/ uint16(xCondDataSize), 7128, 7135, 7146,
-	/*7146*/ uint16(xSetOp), uint16(RDRAND),
-	/*7148*/ uint16(xMatch),
-	/*7149*/ uint16(xCondIs64), 7152, 7164,
-	/*7152*/ uint16(xCondDataSize), 7156, 7160, 0,
-	/*7156*/ uint16(xSetOp), uint16(BSWAP),
-	/*7158*/ uint16(xArgR16op),
-	/*7159*/ uint16(xMatch),
-	/*7160*/ uint16(xSetOp), uint16(BSWAP),
-	/*7162*/ uint16(xArgR32op),
-	/*7163*/ uint16(xMatch),
-	/*7164*/ uint16(xCondDataSize), 7156, 7160, 7168,
-	/*7168*/ uint16(xSetOp), uint16(BSWAP),
-	/*7170*/ uint16(xArgR64op),
-	/*7171*/ uint16(xMatch),
-	/*7172*/ uint16(xCondPrefix), 2,
-	0xF2, 7184,
-	0x66, 7178,
-	/*7178*/ uint16(xSetOp), uint16(ADDSUBPD),
-	/*7180*/ uint16(xReadSlashR),
-	/*7181*/ uint16(xArgXmm1),
-	/*7182*/ uint16(xArgXmm2M128),
-	/*7183*/ uint16(xMatch),
-	/*7184*/ uint16(xSetOp), uint16(ADDSUBPS),
-	/*7186*/ uint16(xReadSlashR),
-	/*7187*/ uint16(xArgXmm1),
-	/*7188*/ uint16(xArgXmm2M128),
-	/*7189*/ uint16(xMatch),
-	/*7190*/ uint16(xCondPrefix), 2,
-	0x66, 7202,
-	0x0, 7196,
-	/*7196*/ uint16(xSetOp), uint16(PSRLW),
-	/*7198*/ uint16(xReadSlashR),
-	/*7199*/ uint16(xArgMm),
-	/*7200*/ uint16(xArgMmM64),
-	/*7201*/ uint16(xMatch),
-	/*7202*/ uint16(xSetOp), uint16(PSRLW),
-	/*7204*/ uint16(xReadSlashR),
-	/*7205*/ uint16(xArgXmm1),
-	/*7206*/ uint16(xArgXmm2M128),
-	/*7207*/ uint16(xMatch),
-	/*7208*/ uint16(xCondPrefix), 2,
-	0x66, 7220,
-	0x0, 7214,
-	/*7214*/ uint16(xSetOp), uint16(PSRLD),
-	/*7216*/ uint16(xReadSlashR),
-	/*7217*/ uint16(xArgMm),
-	/*7218*/ uint16(xArgMmM64),
-	/*7219*/ uint16(xMatch),
-	/*7220*/ uint16(xSetOp), uint16(PSRLD),
-	/*7222*/ uint16(xReadSlashR),
-	/*7223*/ uint16(xArgXmm1),
-	/*7224*/ uint16(xArgXmm2M128),
-	/*7225*/ uint16(xMatch),
-	/*7226*/ uint16(xCondPrefix), 2,
-	0x66, 7238,
-	0x0, 7232,
-	/*7232*/ uint16(xSetOp), uint16(PSRLQ),
-	/*7234*/ uint16(xReadSlashR),
-	/*7235*/ uint16(xArgMm),
-	/*7236*/ uint16(xArgMmM64),
-	/*7237*/ uint16(xMatch),
-	/*7238*/ uint16(xSetOp), uint16(PSRLQ),
-	/*7240*/ uint16(xReadSlashR),
-	/*7241*/ uint16(xArgXmm1),
-	/*7242*/ uint16(xArgXmm2M128),
-	/*7243*/ uint16(xMatch),
-	/*7244*/ uint16(xCondPrefix), 2,
-	0x66, 7256,
-	0x0, 7250,
-	/*7250*/ uint16(xSetOp), uint16(PADDQ),
-	/*7252*/ uint16(xReadSlashR),
-	/*7253*/ uint16(xArgMm1),
-	/*7254*/ uint16(xArgMm2M64),
-	/*7255*/ uint16(xMatch),
-	/*7256*/ uint16(xSetOp), uint16(PADDQ),
-	/*7258*/ uint16(xReadSlashR),
-	/*7259*/ uint16(xArgXmm1),
-	/*7260*/ uint16(xArgXmm2M128),
-	/*7261*/ uint16(xMatch),
-	/*7262*/ uint16(xCondPrefix), 2,
-	0x66, 7274,
-	0x0, 7268,
-	/*7268*/ uint16(xSetOp), uint16(PMULLW),
-	/*7270*/ uint16(xReadSlashR),
-	/*7271*/ uint16(xArgMm),
-	/*7272*/ uint16(xArgMmM64),
-	/*7273*/ uint16(xMatch),
-	/*7274*/ uint16(xSetOp), uint16(PMULLW),
-	/*7276*/ uint16(xReadSlashR),
-	/*7277*/ uint16(xArgXmm1),
-	/*7278*/ uint16(xArgXmm2M128),
-	/*7279*/ uint16(xMatch),
-	/*7280*/ uint16(xCondPrefix), 3,
-	0xF3, 7300,
-	0xF2, 7294,
-	0x66, 7288,
-	/*7288*/ uint16(xSetOp), uint16(MOVQ),
-	/*7290*/ uint16(xReadSlashR),
-	/*7291*/ uint16(xArgXmm2M64),
-	/*7292*/ uint16(xArgXmm1),
-	/*7293*/ uint16(xMatch),
-	/*7294*/ uint16(xSetOp), uint16(MOVDQ2Q),
-	/*7296*/ uint16(xReadSlashR),
-	/*7297*/ uint16(xArgMm),
-	/*7298*/ uint16(xArgXmm2),
-	/*7299*/ uint16(xMatch),
-	/*7300*/ uint16(xSetOp), uint16(MOVQ2DQ),
-	/*7302*/ uint16(xReadSlashR),
-	/*7303*/ uint16(xArgXmm1),
-	/*7304*/ uint16(xArgMm2),
-	/*7305*/ uint16(xMatch),
-	/*7306*/ uint16(xCondPrefix), 2,
-	0x66, 7318,
-	0x0, 7312,
-	/*7312*/ uint16(xSetOp), uint16(PMOVMSKB),
-	/*7314*/ uint16(xReadSlashR),
-	/*7315*/ uint16(xArgR32),
-	/*7316*/ uint16(xArgMm2),
-	/*7317*/ uint16(xMatch),
-	/*7318*/ uint16(xSetOp), uint16(PMOVMSKB),
-	/*7320*/ uint16(xReadSlashR),
-	/*7321*/ uint16(xArgR32),
-	/*7322*/ uint16(xArgXmm2),
-	/*7323*/ uint16(xMatch),
-	/*7324*/ uint16(xCondPrefix), 2,
-	0x66, 7336,
-	0x0, 7330,
-	/*7330*/ uint16(xSetOp), uint16(PSUBUSB),
-	/*7332*/ uint16(xReadSlashR),
-	/*7333*/ uint16(xArgMm),
-	/*7334*/ uint16(xArgMmM64),
-	/*7335*/ uint16(xMatch),
-	/*7336*/ uint16(xSetOp), uint16(PSUBUSB),
-	/*7338*/ uint16(xReadSlashR),
-	/*7339*/ uint16(xArgXmm1),
-	/*7340*/ uint16(xArgXmm2M128),
-	/*7341*/ uint16(xMatch),
-	/*7342*/ uint16(xCondPrefix), 2,
-	0x66, 7354,
-	0x0, 7348,
-	/*7348*/ uint16(xSetOp), uint16(PSUBUSW),
-	/*7350*/ uint16(xReadSlashR),
-	/*7351*/ uint16(xArgMm),
-	/*7352*/ uint16(xArgMmM64),
-	/*7353*/ uint16(xMatch),
-	/*7354*/ uint16(xSetOp), uint16(PSUBUSW),
-	/*7356*/ uint16(xReadSlashR),
-	/*7357*/ uint16(xArgXmm1),
-	/*7358*/ uint16(xArgXmm2M128),
-	/*7359*/ uint16(xMatch),
-	/*7360*/ uint16(xCondPrefix), 2,
-	0x66, 7372,
-	0x0, 7366,
-	/*7366*/ uint16(xSetOp), uint16(PMINUB),
-	/*7368*/ uint16(xReadSlashR),
-	/*7369*/ uint16(xArgMm1),
-	/*7370*/ uint16(xArgMm2M64),
-	/*7371*/ uint16(xMatch),
-	/*7372*/ uint16(xSetOp), uint16(PMINUB),
-	/*7374*/ uint16(xReadSlashR),
-	/*7375*/ uint16(xArgXmm1),
-	/*7376*/ uint16(xArgXmm2M128),
-	/*7377*/ uint16(xMatch),
-	/*7378*/ uint16(xCondPrefix), 2,
-	0x66, 7390,
-	0x0, 7384,
-	/*7384*/ uint16(xSetOp), uint16(PAND),
-	/*7386*/ uint16(xReadSlashR),
-	/*7387*/ uint16(xArgMm),
-	/*7388*/ uint16(xArgMmM64),
-	/*7389*/ uint16(xMatch),
-	/*7390*/ uint16(xSetOp), uint16(PAND),
-	/*7392*/ uint16(xReadSlashR),
-	/*7393*/ uint16(xArgXmm1),
-	/*7394*/ uint16(xArgXmm2M128),
-	/*7395*/ uint16(xMatch),
-	/*7396*/ uint16(xCondPrefix), 2,
-	0x66, 7408,
-	0x0, 7402,
-	/*7402*/ uint16(xSetOp), uint16(PADDUSB),
-	/*7404*/ uint16(xReadSlashR),
-	/*7405*/ uint16(xArgMm),
-	/*7406*/ uint16(xArgMmM64),
-	/*7407*/ uint16(xMatch),
-	/*7408*/ uint16(xSetOp), uint16(PADDUSB),
-	/*7410*/ uint16(xReadSlashR),
-	/*7411*/ uint16(xArgXmm1),
-	/*7412*/ uint16(xArgXmm2M128),
-	/*7413*/ uint16(xMatch),
-	/*7414*/ uint16(xCondPrefix), 2,
-	0x66, 7426,
-	0x0, 7420,
-	/*7420*/ uint16(xSetOp), uint16(PADDUSW),
-	/*7422*/ uint16(xReadSlashR),
-	/*7423*/ uint16(xArgMm),
-	/*7424*/ uint16(xArgMmM64),
-	/*7425*/ uint16(xMatch),
-	/*7426*/ uint16(xSetOp), uint16(PADDUSW),
-	/*7428*/ uint16(xReadSlashR),
-	/*7429*/ uint16(xArgXmm1),
-	/*7430*/ uint16(xArgXmm2M128),
-	/*7431*/ uint16(xMatch),
-	/*7432*/ uint16(xCondPrefix), 2,
-	0x66, 7444,
-	0x0, 7438,
-	/*7438*/ uint16(xSetOp), uint16(PMAXUB),
-	/*7440*/ uint16(xReadSlashR),
-	/*7441*/ uint16(xArgMm1),
-	/*7442*/ uint16(xArgMm2M64),
-	/*7443*/ uint16(xMatch),
-	/*7444*/ uint16(xSetOp), uint16(PMAXUB),
-	/*7446*/ uint16(xReadSlashR),
-	/*7447*/ uint16(xArgXmm1),
-	/*7448*/ uint16(xArgXmm2M128),
-	/*7449*/ uint16(xMatch),
-	/*7450*/ uint16(xCondPrefix), 2,
-	0x66, 7462,
-	0x0, 7456,
-	/*7456*/ uint16(xSetOp), uint16(PANDN),
-	/*7458*/ uint16(xReadSlashR),
-	/*7459*/ uint16(xArgMm),
-	/*7460*/ uint16(xArgMmM64),
-	/*7461*/ uint16(xMatch),
-	/*7462*/ uint16(xSetOp), uint16(PANDN),
-	/*7464*/ uint16(xReadSlashR),
-	/*7465*/ uint16(xArgXmm1),
-	/*7466*/ uint16(xArgXmm2M128),
-	/*7467*/ uint16(xMatch),
-	/*7468*/ uint16(xCondPrefix), 2,
-	0x66, 7480,
-	0x0, 7474,
-	/*7474*/ uint16(xSetOp), uint16(PAVGB),
-	/*7476*/ uint16(xReadSlashR),
-	/*7477*/ uint16(xArgMm1),
-	/*7478*/ uint16(xArgMm2M64),
-	/*7479*/ uint16(xMatch),
-	/*7480*/ uint16(xSetOp), uint16(PAVGB),
-	/*7482*/ uint16(xReadSlashR),
-	/*7483*/ uint16(xArgXmm1),
-	/*7484*/ uint16(xArgXmm2M128),
-	/*7485*/ uint16(xMatch),
-	/*7486*/ uint16(xCondPrefix), 2,
-	0x66, 7498,
-	0x0, 7492,
-	/*7492*/ uint16(xSetOp), uint16(PSRAW),
-	/*7494*/ uint16(xReadSlashR),
-	/*7495*/ uint16(xArgMm),
-	/*7496*/ uint16(xArgMmM64),
-	/*7497*/ uint16(xMatch),
-	/*7498*/ uint16(xSetOp), uint16(PSRAW),
-	/*7500*/ uint16(xReadSlashR),
-	/*7501*/ uint16(xArgXmm1),
-	/*7502*/ uint16(xArgXmm2M128),
-	/*7503*/ uint16(xMatch),
-	/*7504*/ uint16(xCondPrefix), 2,
-	0x66, 7516,
-	0x0, 7510,
-	/*7510*/ uint16(xSetOp), uint16(PSRAD),
-	/*7512*/ uint16(xReadSlashR),
-	/*7513*/ uint16(xArgMm),
-	/*7514*/ uint16(xArgMmM64),
-	/*7515*/ uint16(xMatch),
-	/*7516*/ uint16(xSetOp), uint16(PSRAD),
-	/*7518*/ uint16(xReadSlashR),
-	/*7519*/ uint16(xArgXmm1),
-	/*7520*/ uint16(xArgXmm2M128),
-	/*7521*/ uint16(xMatch),
-	/*7522*/ uint16(xCondPrefix), 2,
-	0x66, 7534,
-	0x0, 7528,
-	/*7528*/ uint16(xSetOp), uint16(PAVGW),
-	/*7530*/ uint16(xReadSlashR),
-	/*7531*/ uint16(xArgMm1),
-	/*7532*/ uint16(xArgMm2M64),
-	/*7533*/ uint16(xMatch),
-	/*7534*/ uint16(xSetOp), uint16(PAVGW),
-	/*7536*/ uint16(xReadSlashR),
-	/*7537*/ uint16(xArgXmm1),
-	/*7538*/ uint16(xArgXmm2M128),
-	/*7539*/ uint16(xMatch),
-	/*7540*/ uint16(xCondPrefix), 2,
-	0x66, 7552,
-	0x0, 7546,
-	/*7546*/ uint16(xSetOp), uint16(PMULHUW),
-	/*7548*/ uint16(xReadSlashR),
-	/*7549*/ uint16(xArgMm1),
-	/*7550*/ uint16(xArgMm2M64),
-	/*7551*/ uint16(xMatch),
-	/*7552*/ uint16(xSetOp), uint16(PMULHUW),
-	/*7554*/ uint16(xReadSlashR),
-	/*7555*/ uint16(xArgXmm1),
-	/*7556*/ uint16(xArgXmm2M128),
-	/*7557*/ uint16(xMatch),
-	/*7558*/ uint16(xCondPrefix), 2,
-	0x66, 7570,
-	0x0, 7564,
-	/*7564*/ uint16(xSetOp), uint16(PMULHW),
-	/*7566*/ uint16(xReadSlashR),
-	/*7567*/ uint16(xArgMm),
-	/*7568*/ uint16(xArgMmM64),
-	/*7569*/ uint16(xMatch),
-	/*7570*/ uint16(xSetOp), uint16(PMULHW),
-	/*7572*/ uint16(xReadSlashR),
-	/*7573*/ uint16(xArgXmm1),
-	/*7574*/ uint16(xArgXmm2M128),
-	/*7575*/ uint16(xMatch),
-	/*7576*/ uint16(xCondPrefix), 3,
-	0xF3, 7596,
-	0xF2, 7590,
-	0x66, 7584,
-	/*7584*/ uint16(xSetOp), uint16(CVTTPD2DQ),
-	/*7586*/ uint16(xReadSlashR),
-	/*7587*/ uint16(xArgXmm1),
-	/*7588*/ uint16(xArgXmm2M128),
-	/*7589*/ uint16(xMatch),
-	/*7590*/ uint16(xSetOp), uint16(CVTPD2DQ),
-	/*7592*/ uint16(xReadSlashR),
-	/*7593*/ uint16(xArgXmm1),
-	/*7594*/ uint16(xArgXmm2M128),
-	/*7595*/ uint16(xMatch),
-	/*7596*/ uint16(xSetOp), uint16(CVTDQ2PD),
-	/*7598*/ uint16(xReadSlashR),
-	/*7599*/ uint16(xArgXmm1),
-	/*7600*/ uint16(xArgXmm2M64),
-	/*7601*/ uint16(xMatch),
-	/*7602*/ uint16(xCondPrefix), 2,
-	0x66, 7614,
-	0x0, 7608,
-	/*7608*/ uint16(xSetOp), uint16(MOVNTQ),
-	/*7610*/ uint16(xReadSlashR),
-	/*7611*/ uint16(xArgM64),
-	/*7612*/ uint16(xArgMm),
-	/*7613*/ uint16(xMatch),
-	/*7614*/ uint16(xSetOp), uint16(MOVNTDQ),
-	/*7616*/ uint16(xReadSlashR),
-	/*7617*/ uint16(xArgM128),
-	/*7618*/ uint16(xArgXmm),
-	/*7619*/ uint16(xMatch),
-	/*7620*/ uint16(xCondPrefix), 2,
-	0x66, 7632,
-	0x0, 7626,
-	/*7626*/ uint16(xSetOp), uint16(PSUBSB),
-	/*7628*/ uint16(xReadSlashR),
-	/*7629*/ uint16(xArgMm),
-	/*7630*/ uint16(xArgMmM64),
-	/*7631*/ uint16(xMatch),
-	/*7632*/ uint16(xSetOp), uint16(PSUBSB),
-	/*7634*/ uint16(xReadSlashR),
-	/*7635*/ uint16(xArgXmm1),
-	/*7636*/ uint16(xArgXmm2M128),
-	/*7637*/ uint16(xMatch),
-	/*7638*/ uint16(xCondPrefix), 2,
-	0x66, 7650,
-	0x0, 7644,
-	/*7644*/ uint16(xSetOp), uint16(PSUBSW),
-	/*7646*/ uint16(xReadSlashR),
-	/*7647*/ uint16(xArgMm),
-	/*7648*/ uint16(xArgMmM64),
-	/*7649*/ uint16(xMatch),
-	/*7650*/ uint16(xSetOp), uint16(PSUBSW),
-	/*7652*/ uint16(xReadSlashR),
-	/*7653*/ uint16(xArgXmm1),
-	/*7654*/ uint16(xArgXmm2M128),
-	/*7655*/ uint16(xMatch),
-	/*7656*/ uint16(xCondPrefix), 2,
-	0x66, 7668,
-	0x0, 7662,
-	/*7662*/ uint16(xSetOp), uint16(PMINSW),
-	/*7664*/ uint16(xReadSlashR),
-	/*7665*/ uint16(xArgMm1),
-	/*7666*/ uint16(xArgMm2M64),
-	/*7667*/ uint16(xMatch),
-	/*7668*/ uint16(xSetOp), uint16(PMINSW),
-	/*7670*/ uint16(xReadSlashR),
-	/*7671*/ uint16(xArgXmm1),
-	/*7672*/ uint16(xArgXmm2M128),
-	/*7673*/ uint16(xMatch),
-	/*7674*/ uint16(xCondPrefix), 2,
-	0x66, 7686,
-	0x0, 7680,
-	/*7680*/ uint16(xSetOp), uint16(POR),
-	/*7682*/ uint16(xReadSlashR),
-	/*7683*/ uint16(xArgMm),
-	/*7684*/ uint16(xArgMmM64),
-	/*7685*/ uint16(xMatch),
-	/*7686*/ uint16(xSetOp), uint16(POR),
-	/*7688*/ uint16(xReadSlashR),
-	/*7689*/ uint16(xArgXmm1),
-	/*7690*/ uint16(xArgXmm2M128),
-	/*7691*/ uint16(xMatch),
-	/*7692*/ uint16(xCondPrefix), 2,
-	0x66, 7704,
-	0x0, 7698,
-	/*7698*/ uint16(xSetOp), uint16(PADDSB),
-	/*7700*/ uint16(xReadSlashR),
-	/*7701*/ uint16(xArgMm),
-	/*7702*/ uint16(xArgMmM64),
-	/*7703*/ uint16(xMatch),
-	/*7704*/ uint16(xSetOp), uint16(PADDSB),
-	/*7706*/ uint16(xReadSlashR),
-	/*7707*/ uint16(xArgXmm1),
-	/*7708*/ uint16(xArgXmm2M128),
-	/*7709*/ uint16(xMatch),
-	/*7710*/ uint16(xCondPrefix), 2,
-	0x66, 7722,
-	0x0, 7716,
-	/*7716*/ uint16(xSetOp), uint16(PADDSW),
-	/*7718*/ uint16(xReadSlashR),
-	/*7719*/ uint16(xArgMm),
-	/*7720*/ uint16(xArgMmM64),
-	/*7721*/ uint16(xMatch),
-	/*7722*/ uint16(xSetOp), uint16(PADDSW),
-	/*7724*/ uint16(xReadSlashR),
-	/*7725*/ uint16(xArgXmm1),
-	/*7726*/ uint16(xArgXmm2M128),
-	/*7727*/ uint16(xMatch),
-	/*7728*/ uint16(xCondPrefix), 2,
-	0x66, 7740,
-	0x0, 7734,
-	/*7734*/ uint16(xSetOp), uint16(PMAXSW),
-	/*7736*/ uint16(xReadSlashR),
-	/*7737*/ uint16(xArgMm1),
-	/*7738*/ uint16(xArgMm2M64),
-	/*7739*/ uint16(xMatch),
-	/*7740*/ uint16(xSetOp), uint16(PMAXSW),
-	/*7742*/ uint16(xReadSlashR),
-	/*7743*/ uint16(xArgXmm1),
-	/*7744*/ uint16(xArgXmm2M128),
-	/*7745*/ uint16(xMatch),
-	/*7746*/ uint16(xCondPrefix), 2,
-	0x66, 7758,
-	0x0, 7752,
-	/*7752*/ uint16(xSetOp), uint16(PXOR),
-	/*7754*/ uint16(xReadSlashR),
-	/*7755*/ uint16(xArgMm),
-	/*7756*/ uint16(xArgMmM64),
-	/*7757*/ uint16(xMatch),
-	/*7758*/ uint16(xSetOp), uint16(PXOR),
-	/*7760*/ uint16(xReadSlashR),
-	/*7761*/ uint16(xArgXmm1),
-	/*7762*/ uint16(xArgXmm2M128),
-	/*7763*/ uint16(xMatch),
-	/*7764*/ uint16(xCondPrefix), 1,
-	0xF2, 7768,
-	/*7768*/ uint16(xSetOp), uint16(LDDQU),
-	/*7770*/ uint16(xReadSlashR),
-	/*7771*/ uint16(xArgXmm1),
-	/*7772*/ uint16(xArgM128),
-	/*7773*/ uint16(xMatch),
-	/*7774*/ uint16(xCondPrefix), 2,
-	0x66, 7786,
-	0x0, 7780,
-	/*7780*/ uint16(xSetOp), uint16(PSLLW),
-	/*7782*/ uint16(xReadSlashR),
-	/*7783*/ uint16(xArgMm),
-	/*7784*/ uint16(xArgMmM64),
-	/*7785*/ uint16(xMatch),
-	/*7786*/ uint16(xSetOp), uint16(PSLLW),
-	/*7788*/ uint16(xReadSlashR),
-	/*7789*/ uint16(xArgXmm1),
-	/*7790*/ uint16(xArgXmm2M128),
-	/*7791*/ uint16(xMatch),
-	/*7792*/ uint16(xCondPrefix), 2,
-	0x66, 7804,
-	0x0, 7798,
-	/*7798*/ uint16(xSetOp), uint16(PSLLD),
-	/*7800*/ uint16(xReadSlashR),
-	/*7801*/ uint16(xArgMm),
-	/*7802*/ uint16(xArgMmM64),
-	/*7803*/ uint16(xMatch),
-	/*7804*/ uint16(xSetOp), uint16(PSLLD),
-	/*7806*/ uint16(xReadSlashR),
-	/*7807*/ uint16(xArgXmm1),
-	/*7808*/ uint16(xArgXmm2M128),
-	/*7809*/ uint16(xMatch),
-	/*7810*/ uint16(xCondPrefix), 2,
-	0x66, 7822,
-	0x0, 7816,
-	/*7816*/ uint16(xSetOp), uint16(PSLLQ),
-	/*7818*/ uint16(xReadSlashR),
-	/*7819*/ uint16(xArgMm),
-	/*7820*/ uint16(xArgMmM64),
-	/*7821*/ uint16(xMatch),
-	/*7822*/ uint16(xSetOp), uint16(PSLLQ),
-	/*7824*/ uint16(xReadSlashR),
-	/*7825*/ uint16(xArgXmm1),
-	/*7826*/ uint16(xArgXmm2M128),
-	/*7827*/ uint16(xMatch),
-	/*7828*/ uint16(xCondPrefix), 2,
-	0x66, 7840,
-	0x0, 7834,
-	/*7834*/ uint16(xSetOp), uint16(PMULUDQ),
-	/*7836*/ uint16(xReadSlashR),
-	/*7837*/ uint16(xArgMm1),
-	/*7838*/ uint16(xArgMm2M64),
-	/*7839*/ uint16(xMatch),
-	/*7840*/ uint16(xSetOp), uint16(PMULUDQ),
-	/*7842*/ uint16(xReadSlashR),
-	/*7843*/ uint16(xArgXmm1),
-	/*7844*/ uint16(xArgXmm2M128),
-	/*7845*/ uint16(xMatch),
-	/*7846*/ uint16(xCondPrefix), 2,
-	0x66, 7858,
-	0x0, 7852,
-	/*7852*/ uint16(xSetOp), uint16(PMADDWD),
-	/*7854*/ uint16(xReadSlashR),
-	/*7855*/ uint16(xArgMm),
-	/*7856*/ uint16(xArgMmM64),
-	/*7857*/ uint16(xMatch),
-	/*7858*/ uint16(xSetOp), uint16(PMADDWD),
-	/*7860*/ uint16(xReadSlashR),
-	/*7861*/ uint16(xArgXmm1),
-	/*7862*/ uint16(xArgXmm2M128),
-	/*7863*/ uint16(xMatch),
-	/*7864*/ uint16(xCondPrefix), 2,
-	0x66, 7876,
-	0x0, 7870,
-	/*7870*/ uint16(xSetOp), uint16(PSADBW),
-	/*7872*/ uint16(xReadSlashR),
-	/*7873*/ uint16(xArgMm1),
-	/*7874*/ uint16(xArgMm2M64),
-	/*7875*/ uint16(xMatch),
-	/*7876*/ uint16(xSetOp), uint16(PSADBW),
-	/*7878*/ uint16(xReadSlashR),
-	/*7879*/ uint16(xArgXmm1),
-	/*7880*/ uint16(xArgXmm2M128),
-	/*7881*/ uint16(xMatch),
-	/*7882*/ uint16(xCondPrefix), 2,
-	0x66, 7894,
-	0x0, 7888,
-	/*7888*/ uint16(xSetOp), uint16(MASKMOVQ),
-	/*7890*/ uint16(xReadSlashR),
-	/*7891*/ uint16(xArgMm1),
-	/*7892*/ uint16(xArgMm2),
-	/*7893*/ uint16(xMatch),
-	/*7894*/ uint16(xSetOp), uint16(MASKMOVDQU),
-	/*7896*/ uint16(xReadSlashR),
-	/*7897*/ uint16(xArgXmm1),
-	/*7898*/ uint16(xArgXmm2),
-	/*7899*/ uint16(xMatch),
-	/*7900*/ uint16(xCondPrefix), 2,
-	0x66, 7912,
-	0x0, 7906,
-	/*7906*/ uint16(xSetOp), uint16(PSUBB),
-	/*7908*/ uint16(xReadSlashR),
-	/*7909*/ uint16(xArgMm),
-	/*7910*/ uint16(xArgMmM64),
-	/*7911*/ uint16(xMatch),
-	/*7912*/ uint16(xSetOp), uint16(PSUBB),
-	/*7914*/ uint16(xReadSlashR),
-	/*7915*/ uint16(xArgXmm1),
-	/*7916*/ uint16(xArgXmm2M128),
-	/*7917*/ uint16(xMatch),
-	/*7918*/ uint16(xCondPrefix), 2,
-	0x66, 7930,
-	0x0, 7924,
-	/*7924*/ uint16(xSetOp), uint16(PSUBW),
-	/*7926*/ uint16(xReadSlashR),
-	/*7927*/ uint16(xArgMm),
-	/*7928*/ uint16(xArgMmM64),
-	/*7929*/ uint16(xMatch),
-	/*7930*/ uint16(xSetOp), uint16(PSUBW),
-	/*7932*/ uint16(xReadSlashR),
-	/*7933*/ uint16(xArgXmm1),
-	/*7934*/ uint16(xArgXmm2M128),
-	/*7935*/ uint16(xMatch),
-	/*7936*/ uint16(xCondPrefix), 2,
-	0x66, 7948,
-	0x0, 7942,
-	/*7942*/ uint16(xSetOp), uint16(PSUBD),
-	/*7944*/ uint16(xReadSlashR),
-	/*7945*/ uint16(xArgMm),
-	/*7946*/ uint16(xArgMmM64),
-	/*7947*/ uint16(xMatch),
-	/*7948*/ uint16(xSetOp), uint16(PSUBD),
-	/*7950*/ uint16(xReadSlashR),
-	/*7951*/ uint16(xArgXmm1),
-	/*7952*/ uint16(xArgXmm2M128),
-	/*7953*/ uint16(xMatch),
-	/*7954*/ uint16(xCondPrefix), 2,
-	0x66, 7966,
-	0x0, 7960,
-	/*7960*/ uint16(xSetOp), uint16(PSUBQ),
-	/*7962*/ uint16(xReadSlashR),
-	/*7963*/ uint16(xArgMm1),
-	/*7964*/ uint16(xArgMm2M64),
-	/*7965*/ uint16(xMatch),
-	/*7966*/ uint16(xSetOp), uint16(PSUBQ),
-	/*7968*/ uint16(xReadSlashR),
-	/*7969*/ uint16(xArgXmm1),
-	/*7970*/ uint16(xArgXmm2M128),
-	/*7971*/ uint16(xMatch),
-	/*7972*/ uint16(xCondPrefix), 2,
-	0x66, 7984,
-	0x0, 7978,
-	/*7978*/ uint16(xSetOp), uint16(PADDB),
-	/*7980*/ uint16(xReadSlashR),
-	/*7981*/ uint16(xArgMm),
-	/*7982*/ uint16(xArgMmM64),
-	/*7983*/ uint16(xMatch),
-	/*7984*/ uint16(xSetOp), uint16(PADDB),
-	/*7986*/ uint16(xReadSlashR),
-	/*7987*/ uint16(xArgXmm1),
-	/*7988*/ uint16(xArgXmm2M128),
-	/*7989*/ uint16(xMatch),
-	/*7990*/ uint16(xCondPrefix), 2,
-	0x66, 8002,
-	0x0, 7996,
-	/*7996*/ uint16(xSetOp), uint16(PADDW),
-	/*7998*/ uint16(xReadSlashR),
-	/*7999*/ uint16(xArgMm),
-	/*8000*/ uint16(xArgMmM64),
-	/*8001*/ uint16(xMatch),
-	/*8002*/ uint16(xSetOp), uint16(PADDW),
-	/*8004*/ uint16(xReadSlashR),
-	/*8005*/ uint16(xArgXmm1),
-	/*8006*/ uint16(xArgXmm2M128),
-	/*8007*/ uint16(xMatch),
-	/*8008*/ uint16(xCondPrefix), 2,
-	0x66, 8020,
-	0x0, 8014,
-	/*8014*/ uint16(xSetOp), uint16(PADDD),
-	/*8016*/ uint16(xReadSlashR),
-	/*8017*/ uint16(xArgMm),
-	/*8018*/ uint16(xArgMmM64),
-	/*8019*/ uint16(xMatch),
-	/*8020*/ uint16(xSetOp), uint16(PADDD),
-	/*8022*/ uint16(xReadSlashR),
-	/*8023*/ uint16(xArgXmm1),
-	/*8024*/ uint16(xArgXmm2M128),
-	/*8025*/ uint16(xMatch),
-	/*8026*/ uint16(xSetOp), uint16(ADC),
-	/*8028*/ uint16(xReadSlashR),
-	/*8029*/ uint16(xArgRM8),
-	/*8030*/ uint16(xArgR8),
-	/*8031*/ uint16(xMatch),
-	/*8032*/ uint16(xCondIs64), 8035, 8051,
-	/*8035*/ uint16(xCondDataSize), 8039, 8045, 0,
-	/*8039*/ uint16(xSetOp), uint16(ADC),
+	/*7038*/ uint16(xCondIs64), 7041, 7053,
+	/*7041*/ uint16(xCondDataSize), 7045, 7049, 0,
+	/*7045*/ uint16(xSetOp), uint16(CMPXCHG8B),
+	/*7047*/ uint16(xArgM64),
+	/*7048*/ uint16(xMatch),
+	/*7049*/ uint16(xSetOp), uint16(CMPXCHG8B),
+	/*7051*/ uint16(xArgM64),
+	/*7052*/ uint16(xMatch),
+	/*7053*/ uint16(xCondDataSize), 7045, 7049, 7057,
+	/*7057*/ uint16(xSetOp), uint16(CMPXCHG16B),
+	/*7059*/ uint16(xArgM128),
+	/*7060*/ uint16(xMatch),
+	/*7061*/ uint16(xCondIs64), 7064, 7076,
+	/*7064*/ uint16(xCondDataSize), 7068, 7072, 0,
+	/*7068*/ uint16(xSetOp), uint16(XRSTORS),
+	/*7070*/ uint16(xArgMem),
+	/*7071*/ uint16(xMatch),
+	/*7072*/ uint16(xSetOp), uint16(XRSTORS),
+	/*7074*/ uint16(xArgMem),
+	/*7075*/ uint16(xMatch),
+	/*7076*/ uint16(xCondDataSize), 7068, 7072, 7080,
+	/*7080*/ uint16(xSetOp), uint16(XRSTORS64),
+	/*7082*/ uint16(xArgMem),
+	/*7083*/ uint16(xMatch),
+	/*7084*/ uint16(xCondIs64), 7087, 7099,
+	/*7087*/ uint16(xCondDataSize), 7091, 7095, 0,
+	/*7091*/ uint16(xSetOp), uint16(XSAVEC),
+	/*7093*/ uint16(xArgMem),
+	/*7094*/ uint16(xMatch),
+	/*7095*/ uint16(xSetOp), uint16(XSAVEC),
+	/*7097*/ uint16(xArgMem),
+	/*7098*/ uint16(xMatch),
+	/*7099*/ uint16(xCondDataSize), 7091, 7095, 7103,
+	/*7103*/ uint16(xSetOp), uint16(XSAVEC64),
+	/*7105*/ uint16(xArgMem),
+	/*7106*/ uint16(xMatch),
+	/*7107*/ uint16(xCondIs64), 7110, 7122,
+	/*7110*/ uint16(xCondDataSize), 7114, 7118, 0,
+	/*7114*/ uint16(xSetOp), uint16(XSAVES),
+	/*7116*/ uint16(xArgMem),
+	/*7117*/ uint16(xMatch),
+	/*7118*/ uint16(xSetOp), uint16(XSAVES),
+	/*7120*/ uint16(xArgMem),
+	/*7121*/ uint16(xMatch),
+	/*7122*/ uint16(xCondDataSize), 7114, 7118, 7126,
+	/*7126*/ uint16(xSetOp), uint16(XSAVES64),
+	/*7128*/ uint16(xArgMem),
+	/*7129*/ uint16(xMatch),
+	/*7130*/ uint16(xCondIs64), 7133, 7151,
+	/*7133*/ uint16(xCondDataSize), 7137, 7144, 0,
+	/*7137*/ uint16(xCondIsMem), 7140, 0,
+	/*7140*/ uint16(xSetOp), uint16(RDRAND),
+	/*7142*/ uint16(xArgRmf16),
+	/*7143*/ uint16(xMatch),
+	/*7144*/ uint16(xCondIsMem), 7147, 0,
+	/*7147*/ uint16(xSetOp), uint16(RDRAND),
+	/*7149*/ uint16(xArgRmf32),
+	/*7150*/ uint16(xMatch),
+	/*7151*/ uint16(xCondDataSize), 7137, 7144, 7155,
+	/*7155*/ uint16(xSetOp), uint16(RDRAND),
+	/*7157*/ uint16(xMatch),
+	/*7158*/ uint16(xCondIs64), 7161, 7173,
+	/*7161*/ uint16(xCondDataSize), 7165, 7169, 0,
+	/*7165*/ uint16(xSetOp), uint16(BSWAP),
+	/*7167*/ uint16(xArgR16op),
+	/*7168*/ uint16(xMatch),
+	/*7169*/ uint16(xSetOp), uint16(BSWAP),
+	/*7171*/ uint16(xArgR32op),
+	/*7172*/ uint16(xMatch),
+	/*7173*/ uint16(xCondDataSize), 7165, 7169, 7177,
+	/*7177*/ uint16(xSetOp), uint16(BSWAP),
+	/*7179*/ uint16(xArgR64op),
+	/*7180*/ uint16(xMatch),
+	/*7181*/ uint16(xCondPrefix), 2,
+	0xF2, 7193,
+	0x66, 7187,
+	/*7187*/ uint16(xSetOp), uint16(ADDSUBPD),
+	/*7189*/ uint16(xReadSlashR),
+	/*7190*/ uint16(xArgXmm1),
+	/*7191*/ uint16(xArgXmm2M128),
+	/*7192*/ uint16(xMatch),
+	/*7193*/ uint16(xSetOp), uint16(ADDSUBPS),
+	/*7195*/ uint16(xReadSlashR),
+	/*7196*/ uint16(xArgXmm1),
+	/*7197*/ uint16(xArgXmm2M128),
+	/*7198*/ uint16(xMatch),
+	/*7199*/ uint16(xCondPrefix), 2,
+	0x66, 7211,
+	0x0, 7205,
+	/*7205*/ uint16(xSetOp), uint16(PSRLW),
+	/*7207*/ uint16(xReadSlashR),
+	/*7208*/ uint16(xArgMm),
+	/*7209*/ uint16(xArgMmM64),
+	/*7210*/ uint16(xMatch),
+	/*7211*/ uint16(xSetOp), uint16(PSRLW),
+	/*7213*/ uint16(xReadSlashR),
+	/*7214*/ uint16(xArgXmm1),
+	/*7215*/ uint16(xArgXmm2M128),
+	/*7216*/ uint16(xMatch),
+	/*7217*/ uint16(xCondPrefix), 2,
+	0x66, 7229,
+	0x0, 7223,
+	/*7223*/ uint16(xSetOp), uint16(PSRLD),
+	/*7225*/ uint16(xReadSlashR),
+	/*7226*/ uint16(xArgMm),
+	/*7227*/ uint16(xArgMmM64),
+	/*7228*/ uint16(xMatch),
+	/*7229*/ uint16(xSetOp), uint16(PSRLD),
+	/*7231*/ uint16(xReadSlashR),
+	/*7232*/ uint16(xArgXmm1),
+	/*7233*/ uint16(xArgXmm2M128),
+	/*7234*/ uint16(xMatch),
+	/*7235*/ uint16(xCondPrefix), 2,
+	0x66, 7247,
+	0x0, 7241,
+	/*7241*/ uint16(xSetOp), uint16(PSRLQ),
+	/*7243*/ uint16(xReadSlashR),
+	/*7244*/ uint16(xArgMm),
+	/*7245*/ uint16(xArgMmM64),
+	/*7246*/ uint16(xMatch),
+	/*7247*/ uint16(xSetOp), uint16(PSRLQ),
+	/*7249*/ uint16(xReadSlashR),
+	/*7250*/ uint16(xArgXmm1),
+	/*7251*/ uint16(xArgXmm2M128),
+	/*7252*/ uint16(xMatch),
+	/*7253*/ uint16(xCondPrefix), 2,
+	0x66, 7265,
+	0x0, 7259,
+	/*7259*/ uint16(xSetOp), uint16(PADDQ),
+	/*7261*/ uint16(xReadSlashR),
+	/*7262*/ uint16(xArgMm1),
+	/*7263*/ uint16(xArgMm2M64),
+	/*7264*/ uint16(xMatch),
+	/*7265*/ uint16(xSetOp), uint16(PADDQ),
+	/*7267*/ uint16(xReadSlashR),
+	/*7268*/ uint16(xArgXmm1),
+	/*7269*/ uint16(xArgXmm2M128),
+	/*7270*/ uint16(xMatch),
+	/*7271*/ uint16(xCondPrefix), 2,
+	0x66, 7283,
+	0x0, 7277,
+	/*7277*/ uint16(xSetOp), uint16(PMULLW),
+	/*7279*/ uint16(xReadSlashR),
+	/*7280*/ uint16(xArgMm),
+	/*7281*/ uint16(xArgMmM64),
+	/*7282*/ uint16(xMatch),
+	/*7283*/ uint16(xSetOp), uint16(PMULLW),
+	/*7285*/ uint16(xReadSlashR),
+	/*7286*/ uint16(xArgXmm1),
+	/*7287*/ uint16(xArgXmm2M128),
+	/*7288*/ uint16(xMatch),
+	/*7289*/ uint16(xCondPrefix), 3,
+	0xF3, 7309,
+	0xF2, 7303,
+	0x66, 7297,
+	/*7297*/ uint16(xSetOp), uint16(MOVQ),
+	/*7299*/ uint16(xReadSlashR),
+	/*7300*/ uint16(xArgXmm2M64),
+	/*7301*/ uint16(xArgXmm1),
+	/*7302*/ uint16(xMatch),
+	/*7303*/ uint16(xSetOp), uint16(MOVDQ2Q),
+	/*7305*/ uint16(xReadSlashR),
+	/*7306*/ uint16(xArgMm),
+	/*7307*/ uint16(xArgXmm2),
+	/*7308*/ uint16(xMatch),
+	/*7309*/ uint16(xSetOp), uint16(MOVQ2DQ),
+	/*7311*/ uint16(xReadSlashR),
+	/*7312*/ uint16(xArgXmm1),
+	/*7313*/ uint16(xArgMm2),
+	/*7314*/ uint16(xMatch),
+	/*7315*/ uint16(xCondPrefix), 2,
+	0x66, 7327,
+	0x0, 7321,
+	/*7321*/ uint16(xSetOp), uint16(PMOVMSKB),
+	/*7323*/ uint16(xReadSlashR),
+	/*7324*/ uint16(xArgR32),
+	/*7325*/ uint16(xArgMm2),
+	/*7326*/ uint16(xMatch),
+	/*7327*/ uint16(xSetOp), uint16(PMOVMSKB),
+	/*7329*/ uint16(xReadSlashR),
+	/*7330*/ uint16(xArgR32),
+	/*7331*/ uint16(xArgXmm2),
+	/*7332*/ uint16(xMatch),
+	/*7333*/ uint16(xCondPrefix), 2,
+	0x66, 7345,
+	0x0, 7339,
+	/*7339*/ uint16(xSetOp), uint16(PSUBUSB),
+	/*7341*/ uint16(xReadSlashR),
+	/*7342*/ uint16(xArgMm),
+	/*7343*/ uint16(xArgMmM64),
+	/*7344*/ uint16(xMatch),
+	/*7345*/ uint16(xSetOp), uint16(PSUBUSB),
+	/*7347*/ uint16(xReadSlashR),
+	/*7348*/ uint16(xArgXmm1),
+	/*7349*/ uint16(xArgXmm2M128),
+	/*7350*/ uint16(xMatch),
+	/*7351*/ uint16(xCondPrefix), 2,
+	0x66, 7363,
+	0x0, 7357,
+	/*7357*/ uint16(xSetOp), uint16(PSUBUSW),
+	/*7359*/ uint16(xReadSlashR),
+	/*7360*/ uint16(xArgMm),
+	/*7361*/ uint16(xArgMmM64),
+	/*7362*/ uint16(xMatch),
+	/*7363*/ uint16(xSetOp), uint16(PSUBUSW),
+	/*7365*/ uint16(xReadSlashR),
+	/*7366*/ uint16(xArgXmm1),
+	/*7367*/ uint16(xArgXmm2M128),
+	/*7368*/ uint16(xMatch),
+	/*7369*/ uint16(xCondPrefix), 2,
+	0x66, 7381,
+	0x0, 7375,
+	/*7375*/ uint16(xSetOp), uint16(PMINUB),
+	/*7377*/ uint16(xReadSlashR),
+	/*7378*/ uint16(xArgMm1),
+	/*7379*/ uint16(xArgMm2M64),
+	/*7380*/ uint16(xMatch),
+	/*7381*/ uint16(xSetOp), uint16(PMINUB),
+	/*7383*/ uint16(xReadSlashR),
+	/*7384*/ uint16(xArgXmm1),
+	/*7385*/ uint16(xArgXmm2M128),
+	/*7386*/ uint16(xMatch),
+	/*7387*/ uint16(xCondPrefix), 2,
+	0x66, 7399,
+	0x0, 7393,
+	/*7393*/ uint16(xSetOp), uint16(PAND),
+	/*7395*/ uint16(xReadSlashR),
+	/*7396*/ uint16(xArgMm),
+	/*7397*/ uint16(xArgMmM64),
+	/*7398*/ uint16(xMatch),
+	/*7399*/ uint16(xSetOp), uint16(PAND),
+	/*7401*/ uint16(xReadSlashR),
+	/*7402*/ uint16(xArgXmm1),
+	/*7403*/ uint16(xArgXmm2M128),
+	/*7404*/ uint16(xMatch),
+	/*7405*/ uint16(xCondPrefix), 2,
+	0x66, 7417,
+	0x0, 7411,
+	/*7411*/ uint16(xSetOp), uint16(PADDUSB),
+	/*7413*/ uint16(xReadSlashR),
+	/*7414*/ uint16(xArgMm),
+	/*7415*/ uint16(xArgMmM64),
+	/*7416*/ uint16(xMatch),
+	/*7417*/ uint16(xSetOp), uint16(PADDUSB),
+	/*7419*/ uint16(xReadSlashR),
+	/*7420*/ uint16(xArgXmm1),
+	/*7421*/ uint16(xArgXmm2M128),
+	/*7422*/ uint16(xMatch),
+	/*7423*/ uint16(xCondPrefix), 2,
+	0x66, 7435,
+	0x0, 7429,
+	/*7429*/ uint16(xSetOp), uint16(PADDUSW),
+	/*7431*/ uint16(xReadSlashR),
+	/*7432*/ uint16(xArgMm),
+	/*7433*/ uint16(xArgMmM64),
+	/*7434*/ uint16(xMatch),
+	/*7435*/ uint16(xSetOp), uint16(PADDUSW),
+	/*7437*/ uint16(xReadSlashR),
+	/*7438*/ uint16(xArgXmm1),
+	/*7439*/ uint16(xArgXmm2M128),
+	/*7440*/ uint16(xMatch),
+	/*7441*/ uint16(xCondPrefix), 2,
+	0x66, 7453,
+	0x0, 7447,
+	/*7447*/ uint16(xSetOp), uint16(PMAXUB),
+	/*7449*/ uint16(xReadSlashR),
+	/*7450*/ uint16(xArgMm1),
+	/*7451*/ uint16(xArgMm2M64),
+	/*7452*/ uint16(xMatch),
+	/*7453*/ uint16(xSetOp), uint16(PMAXUB),
+	/*7455*/ uint16(xReadSlashR),
+	/*7456*/ uint16(xArgXmm1),
+	/*7457*/ uint16(xArgXmm2M128),
+	/*7458*/ uint16(xMatch),
+	/*7459*/ uint16(xCondPrefix), 2,
+	0x66, 7471,
+	0x0, 7465,
+	/*7465*/ uint16(xSetOp), uint16(PANDN),
+	/*7467*/ uint16(xReadSlashR),
+	/*7468*/ uint16(xArgMm),
+	/*7469*/ uint16(xArgMmM64),
+	/*7470*/ uint16(xMatch),
+	/*7471*/ uint16(xSetOp), uint16(PANDN),
+	/*7473*/ uint16(xReadSlashR),
+	/*7474*/ uint16(xArgXmm1),
+	/*7475*/ uint16(xArgXmm2M128),
+	/*7476*/ uint16(xMatch),
+	/*7477*/ uint16(xCondPrefix), 2,
+	0x66, 7489,
+	0x0, 7483,
+	/*7483*/ uint16(xSetOp), uint16(PAVGB),
+	/*7485*/ uint16(xReadSlashR),
+	/*7486*/ uint16(xArgMm1),
+	/*7487*/ uint16(xArgMm2M64),
+	/*7488*/ uint16(xMatch),
+	/*7489*/ uint16(xSetOp), uint16(PAVGB),
+	/*7491*/ uint16(xReadSlashR),
+	/*7492*/ uint16(xArgXmm1),
+	/*7493*/ uint16(xArgXmm2M128),
+	/*7494*/ uint16(xMatch),
+	/*7495*/ uint16(xCondPrefix), 2,
+	0x66, 7507,
+	0x0, 7501,
+	/*7501*/ uint16(xSetOp), uint16(PSRAW),
+	/*7503*/ uint16(xReadSlashR),
+	/*7504*/ uint16(xArgMm),
+	/*7505*/ uint16(xArgMmM64),
+	/*7506*/ uint16(xMatch),
+	/*7507*/ uint16(xSetOp), uint16(PSRAW),
+	/*7509*/ uint16(xReadSlashR),
+	/*7510*/ uint16(xArgXmm1),
+	/*7511*/ uint16(xArgXmm2M128),
+	/*7512*/ uint16(xMatch),
+	/*7513*/ uint16(xCondPrefix), 2,
+	0x66, 7525,
+	0x0, 7519,
+	/*7519*/ uint16(xSetOp), uint16(PSRAD),
+	/*7521*/ uint16(xReadSlashR),
+	/*7522*/ uint16(xArgMm),
+	/*7523*/ uint16(xArgMmM64),
+	/*7524*/ uint16(xMatch),
+	/*7525*/ uint16(xSetOp), uint16(PSRAD),
+	/*7527*/ uint16(xReadSlashR),
+	/*7528*/ uint16(xArgXmm1),
+	/*7529*/ uint16(xArgXmm2M128),
+	/*7530*/ uint16(xMatch),
+	/*7531*/ uint16(xCondPrefix), 2,
+	0x66, 7543,
+	0x0, 7537,
+	/*7537*/ uint16(xSetOp), uint16(PAVGW),
+	/*7539*/ uint16(xReadSlashR),
+	/*7540*/ uint16(xArgMm1),
+	/*7541*/ uint16(xArgMm2M64),
+	/*7542*/ uint16(xMatch),
+	/*7543*/ uint16(xSetOp), uint16(PAVGW),
+	/*7545*/ uint16(xReadSlashR),
+	/*7546*/ uint16(xArgXmm1),
+	/*7547*/ uint16(xArgXmm2M128),
+	/*7548*/ uint16(xMatch),
+	/*7549*/ uint16(xCondPrefix), 2,
+	0x66, 7561,
+	0x0, 7555,
+	/*7555*/ uint16(xSetOp), uint16(PMULHUW),
+	/*7557*/ uint16(xReadSlashR),
+	/*7558*/ uint16(xArgMm1),
+	/*7559*/ uint16(xArgMm2M64),
+	/*7560*/ uint16(xMatch),
+	/*7561*/ uint16(xSetOp), uint16(PMULHUW),
+	/*7563*/ uint16(xReadSlashR),
+	/*7564*/ uint16(xArgXmm1),
+	/*7565*/ uint16(xArgXmm2M128),
+	/*7566*/ uint16(xMatch),
+	/*7567*/ uint16(xCondPrefix), 2,
+	0x66, 7579,
+	0x0, 7573,
+	/*7573*/ uint16(xSetOp), uint16(PMULHW),
+	/*7575*/ uint16(xReadSlashR),
+	/*7576*/ uint16(xArgMm),
+	/*7577*/ uint16(xArgMmM64),
+	/*7578*/ uint16(xMatch),
+	/*7579*/ uint16(xSetOp), uint16(PMULHW),
+	/*7581*/ uint16(xReadSlashR),
+	/*7582*/ uint16(xArgXmm1),
+	/*7583*/ uint16(xArgXmm2M128),
+	/*7584*/ uint16(xMatch),
+	/*7585*/ uint16(xCondPrefix), 3,
+	0xF3, 7605,
+	0xF2, 7599,
+	0x66, 7593,
+	/*7593*/ uint16(xSetOp), uint16(CVTTPD2DQ),
+	/*7595*/ uint16(xReadSlashR),
+	/*7596*/ uint16(xArgXmm1),
+	/*7597*/ uint16(xArgXmm2M128),
+	/*7598*/ uint16(xMatch),
+	/*7599*/ uint16(xSetOp), uint16(CVTPD2DQ),
+	/*7601*/ uint16(xReadSlashR),
+	/*7602*/ uint16(xArgXmm1),
+	/*7603*/ uint16(xArgXmm2M128),
+	/*7604*/ uint16(xMatch),
+	/*7605*/ uint16(xSetOp), uint16(CVTDQ2PD),
+	/*7607*/ uint16(xReadSlashR),
+	/*7608*/ uint16(xArgXmm1),
+	/*7609*/ uint16(xArgXmm2M64),
+	/*7610*/ uint16(xMatch),
+	/*7611*/ uint16(xCondPrefix), 2,
+	0x66, 7623,
+	0x0, 7617,
+	/*7617*/ uint16(xSetOp), uint16(MOVNTQ),
+	/*7619*/ uint16(xReadSlashR),
+	/*7620*/ uint16(xArgM64),
+	/*7621*/ uint16(xArgMm),
+	/*7622*/ uint16(xMatch),
+	/*7623*/ uint16(xSetOp), uint16(MOVNTDQ),
+	/*7625*/ uint16(xReadSlashR),
+	/*7626*/ uint16(xArgM128),
+	/*7627*/ uint16(xArgXmm),
+	/*7628*/ uint16(xMatch),
+	/*7629*/ uint16(xCondPrefix), 2,
+	0x66, 7641,
+	0x0, 7635,
+	/*7635*/ uint16(xSetOp), uint16(PSUBSB),
+	/*7637*/ uint16(xReadSlashR),
+	/*7638*/ uint16(xArgMm),
+	/*7639*/ uint16(xArgMmM64),
+	/*7640*/ uint16(xMatch),
+	/*7641*/ uint16(xSetOp), uint16(PSUBSB),
+	/*7643*/ uint16(xReadSlashR),
+	/*7644*/ uint16(xArgXmm1),
+	/*7645*/ uint16(xArgXmm2M128),
+	/*7646*/ uint16(xMatch),
+	/*7647*/ uint16(xCondPrefix), 2,
+	0x66, 7659,
+	0x0, 7653,
+	/*7653*/ uint16(xSetOp), uint16(PSUBSW),
+	/*7655*/ uint16(xReadSlashR),
+	/*7656*/ uint16(xArgMm),
+	/*7657*/ uint16(xArgMmM64),
+	/*7658*/ uint16(xMatch),
+	/*7659*/ uint16(xSetOp), uint16(PSUBSW),
+	/*7661*/ uint16(xReadSlashR),
+	/*7662*/ uint16(xArgXmm1),
+	/*7663*/ uint16(xArgXmm2M128),
+	/*7664*/ uint16(xMatch),
+	/*7665*/ uint16(xCondPrefix), 2,
+	0x66, 7677,
+	0x0, 7671,
+	/*7671*/ uint16(xSetOp), uint16(PMINSW),
+	/*7673*/ uint16(xReadSlashR),
+	/*7674*/ uint16(xArgMm1),
+	/*7675*/ uint16(xArgMm2M64),
+	/*7676*/ uint16(xMatch),
+	/*7677*/ uint16(xSetOp), uint16(PMINSW),
+	/*7679*/ uint16(xReadSlashR),
+	/*7680*/ uint16(xArgXmm1),
+	/*7681*/ uint16(xArgXmm2M128),
+	/*7682*/ uint16(xMatch),
+	/*7683*/ uint16(xCondPrefix), 2,
+	0x66, 7695,
+	0x0, 7689,
+	/*7689*/ uint16(xSetOp), uint16(POR),
+	/*7691*/ uint16(xReadSlashR),
+	/*7692*/ uint16(xArgMm),
+	/*7693*/ uint16(xArgMmM64),
+	/*7694*/ uint16(xMatch),
+	/*7695*/ uint16(xSetOp), uint16(POR),
+	/*7697*/ uint16(xReadSlashR),
+	/*7698*/ uint16(xArgXmm1),
+	/*7699*/ uint16(xArgXmm2M128),
+	/*7700*/ uint16(xMatch),
+	/*7701*/ uint16(xCondPrefix), 2,
+	0x66, 7713,
+	0x0, 7707,
+	/*7707*/ uint16(xSetOp), uint16(PADDSB),
+	/*7709*/ uint16(xReadSlashR),
+	/*7710*/ uint16(xArgMm),
+	/*7711*/ uint16(xArgMmM64),
+	/*7712*/ uint16(xMatch),
+	/*7713*/ uint16(xSetOp), uint16(PADDSB),
+	/*7715*/ uint16(xReadSlashR),
+	/*7716*/ uint16(xArgXmm1),
+	/*7717*/ uint16(xArgXmm2M128),
+	/*7718*/ uint16(xMatch),
+	/*7719*/ uint16(xCondPrefix), 2,
+	0x66, 7731,
+	0x0, 7725,
+	/*7725*/ uint16(xSetOp), uint16(PADDSW),
+	/*7727*/ uint16(xReadSlashR),
+	/*7728*/ uint16(xArgMm),
+	/*7729*/ uint16(xArgMmM64),
+	/*7730*/ uint16(xMatch),
+	/*7731*/ uint16(xSetOp), uint16(PADDSW),
+	/*7733*/ uint16(xReadSlashR),
+	/*7734*/ uint16(xArgXmm1),
+	/*7735*/ uint16(xArgXmm2M128),
+	/*7736*/ uint16(xMatch),
+	/*7737*/ uint16(xCondPrefix), 2,
+	0x66, 7749,
+	0x0, 7743,
+	/*7743*/ uint16(xSetOp), uint16(PMAXSW),
+	/*7745*/ uint16(xReadSlashR),
+	/*7746*/ uint16(xArgMm1),
+	/*7747*/ uint16(xArgMm2M64),
+	/*7748*/ uint16(xMatch),
+	/*7749*/ uint16(xSetOp), uint16(PMAXSW),
+	/*7751*/ uint16(xReadSlashR),
+	/*7752*/ uint16(xArgXmm1),
+	/*7753*/ uint16(xArgXmm2M128),
+	/*7754*/ uint16(xMatch),
+	/*7755*/ uint16(xCondPrefix), 2,
+	0x66, 7767,
+	0x0, 7761,
+	/*7761*/ uint16(xSetOp), uint16(PXOR),
+	/*7763*/ uint16(xReadSlashR),
+	/*7764*/ uint16(xArgMm),
+	/*7765*/ uint16(xArgMmM64),
+	/*7766*/ uint16(xMatch),
+	/*7767*/ uint16(xSetOp), uint16(PXOR),
+	/*7769*/ uint16(xReadSlashR),
+	/*7770*/ uint16(xArgXmm1),
+	/*7771*/ uint16(xArgXmm2M128),
+	/*7772*/ uint16(xMatch),
+	/*7773*/ uint16(xCondPrefix), 1,
+	0xF2, 7777,
+	/*7777*/ uint16(xSetOp), uint16(LDDQU),
+	/*7779*/ uint16(xReadSlashR),
+	/*7780*/ uint16(xArgXmm1),
+	/*7781*/ uint16(xArgM128),
+	/*7782*/ uint16(xMatch),
+	/*7783*/ uint16(xCondPrefix), 2,
+	0x66, 7795,
+	0x0, 7789,
+	/*7789*/ uint16(xSetOp), uint16(PSLLW),
+	/*7791*/ uint16(xReadSlashR),
+	/*7792*/ uint16(xArgMm),
+	/*7793*/ uint16(xArgMmM64),
+	/*7794*/ uint16(xMatch),
+	/*7795*/ uint16(xSetOp), uint16(PSLLW),
+	/*7797*/ uint16(xReadSlashR),
+	/*7798*/ uint16(xArgXmm1),
+	/*7799*/ uint16(xArgXmm2M128),
+	/*7800*/ uint16(xMatch),
+	/*7801*/ uint16(xCondPrefix), 2,
+	0x66, 7813,
+	0x0, 7807,
+	/*7807*/ uint16(xSetOp), uint16(PSLLD),
+	/*7809*/ uint16(xReadSlashR),
+	/*7810*/ uint16(xArgMm),
+	/*7811*/ uint16(xArgMmM64),
+	/*7812*/ uint16(xMatch),
+	/*7813*/ uint16(xSetOp), uint16(PSLLD),
+	/*7815*/ uint16(xReadSlashR),
+	/*7816*/ uint16(xArgXmm1),
+	/*7817*/ uint16(xArgXmm2M128),
+	/*7818*/ uint16(xMatch),
+	/*7819*/ uint16(xCondPrefix), 2,
+	0x66, 7831,
+	0x0, 7825,
+	/*7825*/ uint16(xSetOp), uint16(PSLLQ),
+	/*7827*/ uint16(xReadSlashR),
+	/*7828*/ uint16(xArgMm),
+	/*7829*/ uint16(xArgMmM64),
+	/*7830*/ uint16(xMatch),
+	/*7831*/ uint16(xSetOp), uint16(PSLLQ),
+	/*7833*/ uint16(xReadSlashR),
+	/*7834*/ uint16(xArgXmm1),
+	/*7835*/ uint16(xArgXmm2M128),
+	/*7836*/ uint16(xMatch),
+	/*7837*/ uint16(xCondPrefix), 2,
+	0x66, 7849,
+	0x0, 7843,
+	/*7843*/ uint16(xSetOp), uint16(PMULUDQ),
+	/*7845*/ uint16(xReadSlashR),
+	/*7846*/ uint16(xArgMm1),
+	/*7847*/ uint16(xArgMm2M64),
+	/*7848*/ uint16(xMatch),
+	/*7849*/ uint16(xSetOp), uint16(PMULUDQ),
+	/*7851*/ uint16(xReadSlashR),
+	/*7852*/ uint16(xArgXmm1),
+	/*7853*/ uint16(xArgXmm2M128),
+	/*7854*/ uint16(xMatch),
+	/*7855*/ uint16(xCondPrefix), 2,
+	0x66, 7867,
+	0x0, 7861,
+	/*7861*/ uint16(xSetOp), uint16(PMADDWD),
+	/*7863*/ uint16(xReadSlashR),
+	/*7864*/ uint16(xArgMm),
+	/*7865*/ uint16(xArgMmM64),
+	/*7866*/ uint16(xMatch),
+	/*7867*/ uint16(xSetOp), uint16(PMADDWD),
+	/*7869*/ uint16(xReadSlashR),
+	/*7870*/ uint16(xArgXmm1),
+	/*7871*/ uint16(xArgXmm2M128),
+	/*7872*/ uint16(xMatch),
+	/*7873*/ uint16(xCondPrefix), 2,
+	0x66, 7885,
+	0x0, 7879,
+	/*7879*/ uint16(xSetOp), uint16(PSADBW),
+	/*7881*/ uint16(xReadSlashR),
+	/*7882*/ uint16(xArgMm1),
+	/*7883*/ uint16(xArgMm2M64),
+	/*7884*/ uint16(xMatch),
+	/*7885*/ uint16(xSetOp), uint16(PSADBW),
+	/*7887*/ uint16(xReadSlashR),
+	/*7888*/ uint16(xArgXmm1),
+	/*7889*/ uint16(xArgXmm2M128),
+	/*7890*/ uint16(xMatch),
+	/*7891*/ uint16(xCondPrefix), 2,
+	0x66, 7903,
+	0x0, 7897,
+	/*7897*/ uint16(xSetOp), uint16(MASKMOVQ),
+	/*7899*/ uint16(xReadSlashR),
+	/*7900*/ uint16(xArgMm1),
+	/*7901*/ uint16(xArgMm2),
+	/*7902*/ uint16(xMatch),
+	/*7903*/ uint16(xSetOp), uint16(MASKMOVDQU),
+	/*7905*/ uint16(xReadSlashR),
+	/*7906*/ uint16(xArgXmm1),
+	/*7907*/ uint16(xArgXmm2),
+	/*7908*/ uint16(xMatch),
+	/*7909*/ uint16(xCondPrefix), 2,
+	0x66, 7921,
+	0x0, 7915,
+	/*7915*/ uint16(xSetOp), uint16(PSUBB),
+	/*7917*/ uint16(xReadSlashR),
+	/*7918*/ uint16(xArgMm),
+	/*7919*/ uint16(xArgMmM64),
+	/*7920*/ uint16(xMatch),
+	/*7921*/ uint16(xSetOp), uint16(PSUBB),
+	/*7923*/ uint16(xReadSlashR),
+	/*7924*/ uint16(xArgXmm1),
+	/*7925*/ uint16(xArgXmm2M128),
+	/*7926*/ uint16(xMatch),
+	/*7927*/ uint16(xCondPrefix), 2,
+	0x66, 7939,
+	0x0, 7933,
+	/*7933*/ uint16(xSetOp), uint16(PSUBW),
+	/*7935*/ uint16(xReadSlashR),
+	/*7936*/ uint16(xArgMm),
+	/*7937*/ uint16(xArgMmM64),
+	/*7938*/ uint16(xMatch),
+	/*7939*/ uint16(xSetOp), uint16(PSUBW),
+	/*7941*/ uint16(xReadSlashR),
+	/*7942*/ uint16(xArgXmm1),
+	/*7943*/ uint16(xArgXmm2M128),
+	/*7944*/ uint16(xMatch),
+	/*7945*/ uint16(xCondPrefix), 2,
+	0x66, 7957,
+	0x0, 7951,
+	/*7951*/ uint16(xSetOp), uint16(PSUBD),
+	/*7953*/ uint16(xReadSlashR),
+	/*7954*/ uint16(xArgMm),
+	/*7955*/ uint16(xArgMmM64),
+	/*7956*/ uint16(xMatch),
+	/*7957*/ uint16(xSetOp), uint16(PSUBD),
+	/*7959*/ uint16(xReadSlashR),
+	/*7960*/ uint16(xArgXmm1),
+	/*7961*/ uint16(xArgXmm2M128),
+	/*7962*/ uint16(xMatch),
+	/*7963*/ uint16(xCondPrefix), 2,
+	0x66, 7975,
+	0x0, 7969,
+	/*7969*/ uint16(xSetOp), uint16(PSUBQ),
+	/*7971*/ uint16(xReadSlashR),
+	/*7972*/ uint16(xArgMm1),
+	/*7973*/ uint16(xArgMm2M64),
+	/*7974*/ uint16(xMatch),
+	/*7975*/ uint16(xSetOp), uint16(PSUBQ),
+	/*7977*/ uint16(xReadSlashR),
+	/*7978*/ uint16(xArgXmm1),
+	/*7979*/ uint16(xArgXmm2M128),
+	/*7980*/ uint16(xMatch),
+	/*7981*/ uint16(xCondPrefix), 2,
+	0x66, 7993,
+	0x0, 7987,
+	/*7987*/ uint16(xSetOp), uint16(PADDB),
+	/*7989*/ uint16(xReadSlashR),
+	/*7990*/ uint16(xArgMm),
+	/*7991*/ uint16(xArgMmM64),
+	/*7992*/ uint16(xMatch),
+	/*7993*/ uint16(xSetOp), uint16(PADDB),
+	/*7995*/ uint16(xReadSlashR),
+	/*7996*/ uint16(xArgXmm1),
+	/*7997*/ uint16(xArgXmm2M128),
+	/*7998*/ uint16(xMatch),
+	/*7999*/ uint16(xCondPrefix), 2,
+	0x66, 8011,
+	0x0, 8005,
+	/*8005*/ uint16(xSetOp), uint16(PADDW),
+	/*8007*/ uint16(xReadSlashR),
+	/*8008*/ uint16(xArgMm),
+	/*8009*/ uint16(xArgMmM64),
+	/*8010*/ uint16(xMatch),
+	/*8011*/ uint16(xSetOp), uint16(PADDW),
+	/*8013*/ uint16(xReadSlashR),
+	/*8014*/ uint16(xArgXmm1),
+	/*8015*/ uint16(xArgXmm2M128),
+	/*8016*/ uint16(xMatch),
+	/*8017*/ uint16(xCondPrefix), 2,
+	0x66, 8029,
+	0x0, 8023,
+	/*8023*/ uint16(xSetOp), uint16(PADDD),
+	/*8025*/ uint16(xReadSlashR),
+	/*8026*/ uint16(xArgMm),
+	/*8027*/ uint16(xArgMmM64),
+	/*8028*/ uint16(xMatch),
+	/*8029*/ uint16(xSetOp), uint16(PADDD),
+	/*8031*/ uint16(xReadSlashR),
+	/*8032*/ uint16(xArgXmm1),
+	/*8033*/ uint16(xArgXmm2M128),
+	/*8034*/ uint16(xMatch),
+	/*8035*/ uint16(xCondDataSize), 0, 8039, 0,
+	/*8039*/ uint16(xSetOp), uint16(UD0),
 	/*8041*/ uint16(xReadSlashR),
-	/*8042*/ uint16(xArgRM16),
-	/*8043*/ uint16(xArgR16),
+	/*8042*/ uint16(xArgR32),
+	/*8043*/ uint16(xArgRM32),
 	/*8044*/ uint16(xMatch),
 	/*8045*/ uint16(xSetOp), uint16(ADC),
 	/*8047*/ uint16(xReadSlashR),
-	/*8048*/ uint16(xArgRM32),
-	/*8049*/ uint16(xArgR32),
+	/*8048*/ uint16(xArgRM8),
+	/*8049*/ uint16(xArgR8),
 	/*8050*/ uint16(xMatch),
-	/*8051*/ uint16(xCondDataSize), 8039, 8045, 8055,
-	/*8055*/ uint16(xSetOp), uint16(ADC),
-	/*8057*/ uint16(xReadSlashR),
-	/*8058*/ uint16(xArgRM64),
-	/*8059*/ uint16(xArgR64),
-	/*8060*/ uint16(xMatch),
-	/*8061*/ uint16(xSetOp), uint16(ADC),
-	/*8063*/ uint16(xReadSlashR),
-	/*8064*/ uint16(xArgR8),
-	/*8065*/ uint16(xArgRM8),
-	/*8066*/ uint16(xMatch),
-	/*8067*/ uint16(xCondIs64), 8070, 8086,
-	/*8070*/ uint16(xCondDataSize), 8074, 8080, 0,
+	/*8051*/ uint16(xCondIs64), 8054, 8070,
+	/*8054*/ uint16(xCondDataSize), 8058, 8064, 0,
+	/*8058*/ uint16(xSetOp), uint16(ADC),
+	/*8060*/ uint16(xReadSlashR),
+	/*8061*/ uint16(xArgRM16),
+	/*8062*/ uint16(xArgR16),
+	/*8063*/ uint16(xMatch),
+	/*8064*/ uint16(xSetOp), uint16(ADC),
+	/*8066*/ uint16(xReadSlashR),
+	/*8067*/ uint16(xArgRM32),
+	/*8068*/ uint16(xArgR32),
+	/*8069*/ uint16(xMatch),
+	/*8070*/ uint16(xCondDataSize), 8058, 8064, 8074,
 	/*8074*/ uint16(xSetOp), uint16(ADC),
 	/*8076*/ uint16(xReadSlashR),
-	/*8077*/ uint16(xArgR16),
-	/*8078*/ uint16(xArgRM16),
+	/*8077*/ uint16(xArgRM64),
+	/*8078*/ uint16(xArgR64),
 	/*8079*/ uint16(xMatch),
 	/*8080*/ uint16(xSetOp), uint16(ADC),
 	/*8082*/ uint16(xReadSlashR),
-	/*8083*/ uint16(xArgR32),
-	/*8084*/ uint16(xArgRM32),
+	/*8083*/ uint16(xArgR8),
+	/*8084*/ uint16(xArgRM8),
 	/*8085*/ uint16(xMatch),
-	/*8086*/ uint16(xCondDataSize), 8074, 8080, 8090,
-	/*8090*/ uint16(xSetOp), uint16(ADC),
-	/*8092*/ uint16(xReadSlashR),
-	/*8093*/ uint16(xArgR64),
-	/*8094*/ uint16(xArgRM64),
-	/*8095*/ uint16(xMatch),
-	/*8096*/ uint16(xSetOp), uint16(ADC),
-	/*8098*/ uint16(xReadIb),
-	/*8099*/ uint16(xArgAL),
-	/*8100*/ uint16(xArgImm8u),
-	/*8101*/ uint16(xMatch),
-	/*8102*/ uint16(xCondIs64), 8105, 8121,
-	/*8105*/ uint16(xCondDataSize), 8109, 8115, 0,
+	/*8086*/ uint16(xCondIs64), 8089, 8105,
+	/*8089*/ uint16(xCondDataSize), 8093, 8099, 0,
+	/*8093*/ uint16(xSetOp), uint16(ADC),
+	/*8095*/ uint16(xReadSlashR),
+	/*8096*/ uint16(xArgR16),
+	/*8097*/ uint16(xArgRM16),
+	/*8098*/ uint16(xMatch),
+	/*8099*/ uint16(xSetOp), uint16(ADC),
+	/*8101*/ uint16(xReadSlashR),
+	/*8102*/ uint16(xArgR32),
+	/*8103*/ uint16(xArgRM32),
+	/*8104*/ uint16(xMatch),
+	/*8105*/ uint16(xCondDataSize), 8093, 8099, 8109,
 	/*8109*/ uint16(xSetOp), uint16(ADC),
-	/*8111*/ uint16(xReadIw),
-	/*8112*/ uint16(xArgAX),
-	/*8113*/ uint16(xArgImm16),
+	/*8111*/ uint16(xReadSlashR),
+	/*8112*/ uint16(xArgR64),
+	/*8113*/ uint16(xArgRM64),
 	/*8114*/ uint16(xMatch),
 	/*8115*/ uint16(xSetOp), uint16(ADC),
-	/*8117*/ uint16(xReadId),
-	/*8118*/ uint16(xArgEAX),
-	/*8119*/ uint16(xArgImm32),
+	/*8117*/ uint16(xReadIb),
+	/*8118*/ uint16(xArgAL),
+	/*8119*/ uint16(xArgImm8u),
 	/*8120*/ uint16(xMatch),
-	/*8121*/ uint16(xCondDataSize), 8109, 8115, 8125,
-	/*8125*/ uint16(xSetOp), uint16(ADC),
-	/*8127*/ uint16(xReadId),
-	/*8128*/ uint16(xArgRAX),
-	/*8129*/ uint16(xArgImm32),
-	/*8130*/ uint16(xMatch),
-	/*8131*/ uint16(xCondIs64), 8134, 0,
-	/*8134*/ uint16(xSetOp), uint16(PUSH),
-	/*8136*/ uint16(xArgSS),
-	/*8137*/ uint16(xMatch),
-	/*8138*/ uint16(xCondIs64), 8141, 0,
-	/*8141*/ uint16(xSetOp), uint16(POP),
-	/*8143*/ uint16(xArgSS),
-	/*8144*/ uint16(xMatch),
-	/*8145*/ uint16(xSetOp), uint16(SBB),
-	/*8147*/ uint16(xReadSlashR),
-	/*8148*/ uint16(xArgRM8),
-	/*8149*/ uint16(xArgR8),
-	/*8150*/ uint16(xMatch),
-	/*8151*/ uint16(xCondIs64), 8154, 8170,
-	/*8154*/ uint16(xCondDataSize), 8158, 8164, 0,
-	/*8158*/ uint16(xSetOp), uint16(SBB),
-	/*8160*/ uint16(xReadSlashR),
-	/*8161*/ uint16(xArgRM16),
-	/*8162*/ uint16(xArgR16),
+	/*8121*/ uint16(xCondIs64), 8124, 8140,
+	/*8124*/ uint16(xCondDataSize), 8128, 8134, 0,
+	/*8128*/ uint16(xSetOp), uint16(ADC),
+	/*8130*/ uint16(xReadIw),
+	/*8131*/ uint16(xArgAX),
+	/*8132*/ uint16(xArgImm16),
+	/*8133*/ uint16(xMatch),
+	/*8134*/ uint16(xSetOp), uint16(ADC),
+	/*8136*/ uint16(xReadId),
+	/*8137*/ uint16(xArgEAX),
+	/*8138*/ uint16(xArgImm32),
+	/*8139*/ uint16(xMatch),
+	/*8140*/ uint16(xCondDataSize), 8128, 8134, 8144,
+	/*8144*/ uint16(xSetOp), uint16(ADC),
+	/*8146*/ uint16(xReadId),
+	/*8147*/ uint16(xArgRAX),
+	/*8148*/ uint16(xArgImm32),
+	/*8149*/ uint16(xMatch),
+	/*8150*/ uint16(xCondIs64), 8153, 0,
+	/*8153*/ uint16(xSetOp), uint16(PUSH),
+	/*8155*/ uint16(xArgSS),
+	/*8156*/ uint16(xMatch),
+	/*8157*/ uint16(xCondIs64), 8160, 0,
+	/*8160*/ uint16(xSetOp), uint16(POP),
+	/*8162*/ uint16(xArgSS),
 	/*8163*/ uint16(xMatch),
 	/*8164*/ uint16(xSetOp), uint16(SBB),
 	/*8166*/ uint16(xReadSlashR),
-	/*8167*/ uint16(xArgRM32),
-	/*8168*/ uint16(xArgR32),
+	/*8167*/ uint16(xArgRM8),
+	/*8168*/ uint16(xArgR8),
 	/*8169*/ uint16(xMatch),
-	/*8170*/ uint16(xCondDataSize), 8158, 8164, 8174,
-	/*8174*/ uint16(xSetOp), uint16(SBB),
-	/*8176*/ uint16(xReadSlashR),
-	/*8177*/ uint16(xArgRM64),
-	/*8178*/ uint16(xArgR64),
-	/*8179*/ uint16(xMatch),
-	/*8180*/ uint16(xSetOp), uint16(SBB),
-	/*8182*/ uint16(xReadSlashR),
-	/*8183*/ uint16(xArgR8),
-	/*8184*/ uint16(xArgRM8),
-	/*8185*/ uint16(xMatch),
-	/*8186*/ uint16(xCondIs64), 8189, 8205,
-	/*8189*/ uint16(xCondDataSize), 8193, 8199, 0,
+	/*8170*/ uint16(xCondIs64), 8173, 8189,
+	/*8173*/ uint16(xCondDataSize), 8177, 8183, 0,
+	/*8177*/ uint16(xSetOp), uint16(SBB),
+	/*8179*/ uint16(xReadSlashR),
+	/*8180*/ uint16(xArgRM16),
+	/*8181*/ uint16(xArgR16),
+	/*8182*/ uint16(xMatch),
+	/*8183*/ uint16(xSetOp), uint16(SBB),
+	/*8185*/ uint16(xReadSlashR),
+	/*8186*/ uint16(xArgRM32),
+	/*8187*/ uint16(xArgR32),
+	/*8188*/ uint16(xMatch),
+	/*8189*/ uint16(xCondDataSize), 8177, 8183, 8193,
 	/*8193*/ uint16(xSetOp), uint16(SBB),
 	/*8195*/ uint16(xReadSlashR),
-	/*8196*/ uint16(xArgR16),
-	/*8197*/ uint16(xArgRM16),
+	/*8196*/ uint16(xArgRM64),
+	/*8197*/ uint16(xArgR64),
 	/*8198*/ uint16(xMatch),
 	/*8199*/ uint16(xSetOp), uint16(SBB),
 	/*8201*/ uint16(xReadSlashR),
-	/*8202*/ uint16(xArgR32),
-	/*8203*/ uint16(xArgRM32),
+	/*8202*/ uint16(xArgR8),
+	/*8203*/ uint16(xArgRM8),
 	/*8204*/ uint16(xMatch),
-	/*8205*/ uint16(xCondDataSize), 8193, 8199, 8209,
-	/*8209*/ uint16(xSetOp), uint16(SBB),
-	/*8211*/ uint16(xReadSlashR),
-	/*8212*/ uint16(xArgR64),
-	/*8213*/ uint16(xArgRM64),
-	/*8214*/ uint16(xMatch),
-	/*8215*/ uint16(xSetOp), uint16(SBB),
-	/*8217*/ uint16(xReadIb),
-	/*8218*/ uint16(xArgAL),
-	/*8219*/ uint16(xArgImm8u),
-	/*8220*/ uint16(xMatch),
-	/*8221*/ uint16(xCondIs64), 8224, 8240,
-	/*8224*/ uint16(xCondDataSize), 8228, 8234, 0,
+	/*8205*/ uint16(xCondIs64), 8208, 8224,
+	/*8208*/ uint16(xCondDataSize), 8212, 8218, 0,
+	/*8212*/ uint16(xSetOp), uint16(SBB),
+	/*8214*/ uint16(xReadSlashR),
+	/*8215*/ uint16(xArgR16),
+	/*8216*/ uint16(xArgRM16),
+	/*8217*/ uint16(xMatch),
+	/*8218*/ uint16(xSetOp), uint16(SBB),
+	/*8220*/ uint16(xReadSlashR),
+	/*8221*/ uint16(xArgR32),
+	/*8222*/ uint16(xArgRM32),
+	/*8223*/ uint16(xMatch),
+	/*8224*/ uint16(xCondDataSize), 8212, 8218, 8228,
 	/*8228*/ uint16(xSetOp), uint16(SBB),
-	/*8230*/ uint16(xReadIw),
-	/*8231*/ uint16(xArgAX),
-	/*8232*/ uint16(xArgImm16),
+	/*8230*/ uint16(xReadSlashR),
+	/*8231*/ uint16(xArgR64),
+	/*8232*/ uint16(xArgRM64),
 	/*8233*/ uint16(xMatch),
 	/*8234*/ uint16(xSetOp), uint16(SBB),
-	/*8236*/ uint16(xReadId),
-	/*8237*/ uint16(xArgEAX),
-	/*8238*/ uint16(xArgImm32),
+	/*8236*/ uint16(xReadIb),
+	/*8237*/ uint16(xArgAL),
+	/*8238*/ uint16(xArgImm8u),
 	/*8239*/ uint16(xMatch),
-	/*8240*/ uint16(xCondDataSize), 8228, 8234, 8244,
-	/*8244*/ uint16(xSetOp), uint16(SBB),
-	/*8246*/ uint16(xReadId),
-	/*8247*/ uint16(xArgRAX),
-	/*8248*/ uint16(xArgImm32),
-	/*8249*/ uint16(xMatch),
-	/*8250*/ uint16(xCondIs64), 8253, 0,
-	/*8253*/ uint16(xSetOp), uint16(PUSH),
-	/*8255*/ uint16(xArgDS),
-	/*8256*/ uint16(xMatch),
-	/*8257*/ uint16(xCondIs64), 8260, 0,
-	/*8260*/ uint16(xSetOp), uint16(POP),
-	/*8262*/ uint16(xArgDS),
-	/*8263*/ uint16(xMatch),
-	/*8264*/ uint16(xSetOp), uint16(AND),
-	/*8266*/ uint16(xReadSlashR),
-	/*8267*/ uint16(xArgRM8),
-	/*8268*/ uint16(xArgR8),
-	/*8269*/ uint16(xMatch),
-	/*8270*/ uint16(xCondIs64), 8273, 8289,
-	/*8273*/ uint16(xCondDataSize), 8277, 8283, 0,
-	/*8277*/ uint16(xSetOp), uint16(AND),
-	/*8279*/ uint16(xReadSlashR),
-	/*8280*/ uint16(xArgRM16),
-	/*8281*/ uint16(xArgR16),
+	/*8240*/ uint16(xCondIs64), 8243, 8259,
+	/*8243*/ uint16(xCondDataSize), 8247, 8253, 0,
+	/*8247*/ uint16(xSetOp), uint16(SBB),
+	/*8249*/ uint16(xReadIw),
+	/*8250*/ uint16(xArgAX),
+	/*8251*/ uint16(xArgImm16),
+	/*8252*/ uint16(xMatch),
+	/*8253*/ uint16(xSetOp), uint16(SBB),
+	/*8255*/ uint16(xReadId),
+	/*8256*/ uint16(xArgEAX),
+	/*8257*/ uint16(xArgImm32),
+	/*8258*/ uint16(xMatch),
+	/*8259*/ uint16(xCondDataSize), 8247, 8253, 8263,
+	/*8263*/ uint16(xSetOp), uint16(SBB),
+	/*8265*/ uint16(xReadId),
+	/*8266*/ uint16(xArgRAX),
+	/*8267*/ uint16(xArgImm32),
+	/*8268*/ uint16(xMatch),
+	/*8269*/ uint16(xCondIs64), 8272, 0,
+	/*8272*/ uint16(xSetOp), uint16(PUSH),
+	/*8274*/ uint16(xArgDS),
+	/*8275*/ uint16(xMatch),
+	/*8276*/ uint16(xCondIs64), 8279, 0,
+	/*8279*/ uint16(xSetOp), uint16(POP),
+	/*8281*/ uint16(xArgDS),
 	/*8282*/ uint16(xMatch),
 	/*8283*/ uint16(xSetOp), uint16(AND),
 	/*8285*/ uint16(xReadSlashR),
-	/*8286*/ uint16(xArgRM32),
-	/*8287*/ uint16(xArgR32),
+	/*8286*/ uint16(xArgRM8),
+	/*8287*/ uint16(xArgR8),
 	/*8288*/ uint16(xMatch),
-	/*8289*/ uint16(xCondDataSize), 8277, 8283, 8293,
-	/*8293*/ uint16(xSetOp), uint16(AND),
-	/*8295*/ uint16(xReadSlashR),
-	/*8296*/ uint16(xArgRM64),
-	/*8297*/ uint16(xArgR64),
-	/*8298*/ uint16(xMatch),
-	/*8299*/ uint16(xSetOp), uint16(AND),
-	/*8301*/ uint16(xReadSlashR),
-	/*8302*/ uint16(xArgR8),
-	/*8303*/ uint16(xArgRM8),
-	/*8304*/ uint16(xMatch),
-	/*8305*/ uint16(xCondIs64), 8308, 8324,
-	/*8308*/ uint16(xCondDataSize), 8312, 8318, 0,
+	/*8289*/ uint16(xCondIs64), 8292, 8308,
+	/*8292*/ uint16(xCondDataSize), 8296, 8302, 0,
+	/*8296*/ uint16(xSetOp), uint16(AND),
+	/*8298*/ uint16(xReadSlashR),
+	/*8299*/ uint16(xArgRM16),
+	/*8300*/ uint16(xArgR16),
+	/*8301*/ uint16(xMatch),
+	/*8302*/ uint16(xSetOp), uint16(AND),
+	/*8304*/ uint16(xReadSlashR),
+	/*8305*/ uint16(xArgRM32),
+	/*8306*/ uint16(xArgR32),
+	/*8307*/ uint16(xMatch),
+	/*8308*/ uint16(xCondDataSize), 8296, 8302, 8312,
 	/*8312*/ uint16(xSetOp), uint16(AND),
 	/*8314*/ uint16(xReadSlashR),
-	/*8315*/ uint16(xArgR16),
-	/*8316*/ uint16(xArgRM16),
+	/*8315*/ uint16(xArgRM64),
+	/*8316*/ uint16(xArgR64),
 	/*8317*/ uint16(xMatch),
 	/*8318*/ uint16(xSetOp), uint16(AND),
 	/*8320*/ uint16(xReadSlashR),
-	/*8321*/ uint16(xArgR32),
-	/*8322*/ uint16(xArgRM32),
+	/*8321*/ uint16(xArgR8),
+	/*8322*/ uint16(xArgRM8),
 	/*8323*/ uint16(xMatch),
-	/*8324*/ uint16(xCondDataSize), 8312, 8318, 8328,
-	/*8328*/ uint16(xSetOp), uint16(AND),
-	/*8330*/ uint16(xReadSlashR),
-	/*8331*/ uint16(xArgR64),
-	/*8332*/ uint16(xArgRM64),
-	/*8333*/ uint16(xMatch),
-	/*8334*/ uint16(xSetOp), uint16(AND),
-	/*8336*/ uint16(xReadIb),
-	/*8337*/ uint16(xArgAL),
-	/*8338*/ uint16(xArgImm8u),
-	/*8339*/ uint16(xMatch),
-	/*8340*/ uint16(xCondIs64), 8343, 8359,
-	/*8343*/ uint16(xCondDataSize), 8347, 8353, 0,
+	/*8324*/ uint16(xCondIs64), 8327, 8343,
+	/*8327*/ uint16(xCondDataSize), 8331, 8337, 0,
+	/*8331*/ uint16(xSetOp), uint16(AND),
+	/*8333*/ uint16(xReadSlashR),
+	/*8334*/ uint16(xArgR16),
+	/*8335*/ uint16(xArgRM16),
+	/*8336*/ uint16(xMatch),
+	/*8337*/ uint16(xSetOp), uint16(AND),
+	/*8339*/ uint16(xReadSlashR),
+	/*8340*/ uint16(xArgR32),
+	/*8341*/ uint16(xArgRM32),
+	/*8342*/ uint16(xMatch),
+	/*8343*/ uint16(xCondDataSize), 8331, 8337, 8347,
 	/*8347*/ uint16(xSetOp), uint16(AND),
-	/*8349*/ uint16(xReadIw),
-	/*8350*/ uint16(xArgAX),
-	/*8351*/ uint16(xArgImm16),
+	/*8349*/ uint16(xReadSlashR),
+	/*8350*/ uint16(xArgR64),
+	/*8351*/ uint16(xArgRM64),
 	/*8352*/ uint16(xMatch),
 	/*8353*/ uint16(xSetOp), uint16(AND),
-	/*8355*/ uint16(xReadId),
-	/*8356*/ uint16(xArgEAX),
-	/*8357*/ uint16(xArgImm32),
+	/*8355*/ uint16(xReadIb),
+	/*8356*/ uint16(xArgAL),
+	/*8357*/ uint16(xArgImm8u),
 	/*8358*/ uint16(xMatch),
-	/*8359*/ uint16(xCondDataSize), 8347, 8353, 8363,
-	/*8363*/ uint16(xSetOp), uint16(AND),
-	/*8365*/ uint16(xReadId),
-	/*8366*/ uint16(xArgRAX),
-	/*8367*/ uint16(xArgImm32),
-	/*8368*/ uint16(xMatch),
-	/*8369*/ uint16(xCondIs64), 8372, 0,
-	/*8372*/ uint16(xSetOp), uint16(DAA),
-	/*8374*/ uint16(xMatch),
-	/*8375*/ uint16(xSetOp), uint16(SUB),
-	/*8377*/ uint16(xReadSlashR),
-	/*8378*/ uint16(xArgRM8),
-	/*8379*/ uint16(xArgR8),
-	/*8380*/ uint16(xMatch),
-	/*8381*/ uint16(xCondIs64), 8384, 8400,
-	/*8384*/ uint16(xCondDataSize), 8388, 8394, 0,
-	/*8388*/ uint16(xSetOp), uint16(SUB),
-	/*8390*/ uint16(xReadSlashR),
-	/*8391*/ uint16(xArgRM16),
-	/*8392*/ uint16(xArgR16),
+	/*8359*/ uint16(xCondIs64), 8362, 8378,
+	/*8362*/ uint16(xCondDataSize), 8366, 8372, 0,
+	/*8366*/ uint16(xSetOp), uint16(AND),
+	/*8368*/ uint16(xReadIw),
+	/*8369*/ uint16(xArgAX),
+	/*8370*/ uint16(xArgImm16),
+	/*8371*/ uint16(xMatch),
+	/*8372*/ uint16(xSetOp), uint16(AND),
+	/*8374*/ uint16(xReadId),
+	/*8375*/ uint16(xArgEAX),
+	/*8376*/ uint16(xArgImm32),
+	/*8377*/ uint16(xMatch),
+	/*8378*/ uint16(xCondDataSize), 8366, 8372, 8382,
+	/*8382*/ uint16(xSetOp), uint16(AND),
+	/*8384*/ uint16(xReadId),
+	/*8385*/ uint16(xArgRAX),
+	/*8386*/ uint16(xArgImm32),
+	/*8387*/ uint16(xMatch),
+	/*8388*/ uint16(xCondIs64), 8391, 0,
+	/*8391*/ uint16(xSetOp), uint16(DAA),
 	/*8393*/ uint16(xMatch),
 	/*8394*/ uint16(xSetOp), uint16(SUB),
 	/*8396*/ uint16(xReadSlashR),
-	/*8397*/ uint16(xArgRM32),
-	/*8398*/ uint16(xArgR32),
+	/*8397*/ uint16(xArgRM8),
+	/*8398*/ uint16(xArgR8),
 	/*8399*/ uint16(xMatch),
-	/*8400*/ uint16(xCondDataSize), 8388, 8394, 8404,
-	/*8404*/ uint16(xSetOp), uint16(SUB),
-	/*8406*/ uint16(xReadSlashR),
-	/*8407*/ uint16(xArgRM64),
-	/*8408*/ uint16(xArgR64),
-	/*8409*/ uint16(xMatch),
-	/*8410*/ uint16(xCondPrefix), 3,
-	0xC5, 8438,
-	0xC4, 8424,
-	0x0, 8418,
-	/*8418*/ uint16(xSetOp), uint16(SUB),
-	/*8420*/ uint16(xReadSlashR),
-	/*8421*/ uint16(xArgR8),
-	/*8422*/ uint16(xArgRM8),
-	/*8423*/ uint16(xMatch),
-	/*8424*/ uint16(xCondPrefix), 1,
-	0x66, 8428,
-	/*8428*/ uint16(xCondPrefix), 1,
-	0x0F38, 8432,
-	/*8432*/ uint16(xSetOp), uint16(VMOVNTDQA),
-	/*8434*/ uint16(xReadSlashR),
-	/*8435*/ uint16(xArgYmm1),
-	/*8436*/ uint16(xArgM256),
-	/*8437*/ uint16(xMatch),
-	/*8438*/ uint16(xCondPrefix), 1,
-	0x66, 8442,
-	/*8442*/ uint16(xCondPrefix), 1,
-	0x0F38, 8446,
-	/*8446*/ uint16(xSetOp), uint16(VMOVNTDQA),
-	/*8448*/ uint16(xReadSlashR),
-	/*8449*/ uint16(xArgYmm1),
-	/*8450*/ uint16(xArgM256),
-	/*8451*/ uint16(xMatch),
-	/*8452*/ uint16(xCondIs64), 8455, 8471,
-	/*8455*/ uint16(xCondDataSize), 8459, 8465, 0,
-	/*8459*/ uint16(xSetOp), uint16(SUB),
-	/*8461*/ uint16(xReadSlashR),
-	/*8462*/ uint16(xArgR16),
-	/*8463*/ uint16(xArgRM16),
-	/*8464*/ uint16(xMatch),
-	/*8465*/ uint16(xSetOp), uint16(SUB),
+	/*8400*/ uint16(xCondIs64), 8403, 8419,
+	/*8403*/ uint16(xCondDataSize), 8407, 8413, 0,
+	/*8407*/ uint16(xSetOp), uint16(SUB),
+	/*8409*/ uint16(xReadSlashR),
+	/*8410*/ uint16(xArgRM16),
+	/*8411*/ uint16(xArgR16),
+	/*8412*/ uint16(xMatch),
+	/*8413*/ uint16(xSetOp), uint16(SUB),
+	/*8415*/ uint16(xReadSlashR),
+	/*8416*/ uint16(xArgRM32),
+	/*8417*/ uint16(xArgR32),
+	/*8418*/ uint16(xMatch),
+	/*8419*/ uint16(xCondDataSize), 8407, 8413, 8423,
+	/*8423*/ uint16(xSetOp), uint16(SUB),
+	/*8425*/ uint16(xReadSlashR),
+	/*8426*/ uint16(xArgRM64),
+	/*8427*/ uint16(xArgR64),
+	/*8428*/ uint16(xMatch),
+	/*8429*/ uint16(xCondPrefix), 3,
+	0xC5, 8457,
+	0xC4, 8443,
+	0x0, 8437,
+	/*8437*/ uint16(xSetOp), uint16(SUB),
+	/*8439*/ uint16(xReadSlashR),
+	/*8440*/ uint16(xArgR8),
+	/*8441*/ uint16(xArgRM8),
+	/*8442*/ uint16(xMatch),
+	/*8443*/ uint16(xCondPrefix), 1,
+	0x66, 8447,
+	/*8447*/ uint16(xCondPrefix), 1,
+	0x0F38, 8451,
+	/*8451*/ uint16(xSetOp), uint16(VMOVNTDQA),
+	/*8453*/ uint16(xReadSlashR),
+	/*8454*/ uint16(xArgYmm1),
+	/*8455*/ uint16(xArgM256),
+	/*8456*/ uint16(xMatch),
+	/*8457*/ uint16(xCondPrefix), 1,
+	0x66, 8461,
+	/*8461*/ uint16(xCondPrefix), 1,
+	0x0F38, 8465,
+	/*8465*/ uint16(xSetOp), uint16(VMOVNTDQA),
 	/*8467*/ uint16(xReadSlashR),
-	/*8468*/ uint16(xArgR32),
-	/*8469*/ uint16(xArgRM32),
+	/*8468*/ uint16(xArgYmm1),
+	/*8469*/ uint16(xArgM256),
 	/*8470*/ uint16(xMatch),
-	/*8471*/ uint16(xCondDataSize), 8459, 8465, 8475,
-	/*8475*/ uint16(xSetOp), uint16(SUB),
-	/*8477*/ uint16(xReadSlashR),
-	/*8478*/ uint16(xArgR64),
-	/*8479*/ uint16(xArgRM64),
-	/*8480*/ uint16(xMatch),
-	/*8481*/ uint16(xSetOp), uint16(SUB),
-	/*8483*/ uint16(xReadIb),
-	/*8484*/ uint16(xArgAL),
-	/*8485*/ uint16(xArgImm8u),
-	/*8486*/ uint16(xMatch),
-	/*8487*/ uint16(xCondIs64), 8490, 8506,
-	/*8490*/ uint16(xCondDataSize), 8494, 8500, 0,
+	/*8471*/ uint16(xCondIs64), 8474, 8490,
+	/*8474*/ uint16(xCondDataSize), 8478, 8484, 0,
+	/*8478*/ uint16(xSetOp), uint16(SUB),
+	/*8480*/ uint16(xReadSlashR),
+	/*8481*/ uint16(xArgR16),
+	/*8482*/ uint16(xArgRM16),
+	/*8483*/ uint16(xMatch),
+	/*8484*/ uint16(xSetOp), uint16(SUB),
+	/*8486*/ uint16(xReadSlashR),
+	/*8487*/ uint16(xArgR32),
+	/*8488*/ uint16(xArgRM32),
+	/*8489*/ uint16(xMatch),
+	/*8490*/ uint16(xCondDataSize), 8478, 8484, 8494,
 	/*8494*/ uint16(xSetOp), uint16(SUB),
-	/*8496*/ uint16(xReadIw),
-	/*8497*/ uint16(xArgAX),
-	/*8498*/ uint16(xArgImm16),
+	/*8496*/ uint16(xReadSlashR),
+	/*8497*/ uint16(xArgR64),
+	/*8498*/ uint16(xArgRM64),
 	/*8499*/ uint16(xMatch),
 	/*8500*/ uint16(xSetOp), uint16(SUB),
-	/*8502*/ uint16(xReadId),
-	/*8503*/ uint16(xArgEAX),
-	/*8504*/ uint16(xArgImm32),
+	/*8502*/ uint16(xReadIb),
+	/*8503*/ uint16(xArgAL),
+	/*8504*/ uint16(xArgImm8u),
 	/*8505*/ uint16(xMatch),
-	/*8506*/ uint16(xCondDataSize), 8494, 8500, 8510,
-	/*8510*/ uint16(xSetOp), uint16(SUB),
-	/*8512*/ uint16(xReadId),
-	/*8513*/ uint16(xArgRAX),
-	/*8514*/ uint16(xArgImm32),
-	/*8515*/ uint16(xMatch),
-	/*8516*/ uint16(xCondIs64), 8519, 0,
-	/*8519*/ uint16(xSetOp), uint16(DAS),
-	/*8521*/ uint16(xMatch),
-	/*8522*/ uint16(xSetOp), uint16(XOR),
-	/*8524*/ uint16(xReadSlashR),
-	/*8525*/ uint16(xArgRM8),
-	/*8526*/ uint16(xArgR8),
-	/*8527*/ uint16(xMatch),
-	/*8528*/ uint16(xCondIs64), 8531, 8547,
-	/*8531*/ uint16(xCondDataSize), 8535, 8541, 0,
-	/*8535*/ uint16(xSetOp), uint16(XOR),
-	/*8537*/ uint16(xReadSlashR),
-	/*8538*/ uint16(xArgRM16),
-	/*8539*/ uint16(xArgR16),
+	/*8506*/ uint16(xCondIs64), 8509, 8525,
+	/*8509*/ uint16(xCondDataSize), 8513, 8519, 0,
+	/*8513*/ uint16(xSetOp), uint16(SUB),
+	/*8515*/ uint16(xReadIw),
+	/*8516*/ uint16(xArgAX),
+	/*8517*/ uint16(xArgImm16),
+	/*8518*/ uint16(xMatch),
+	/*8519*/ uint16(xSetOp), uint16(SUB),
+	/*8521*/ uint16(xReadId),
+	/*8522*/ uint16(xArgEAX),
+	/*8523*/ uint16(xArgImm32),
+	/*8524*/ uint16(xMatch),
+	/*8525*/ uint16(xCondDataSize), 8513, 8519, 8529,
+	/*8529*/ uint16(xSetOp), uint16(SUB),
+	/*8531*/ uint16(xReadId),
+	/*8532*/ uint16(xArgRAX),
+	/*8533*/ uint16(xArgImm32),
+	/*8534*/ uint16(xMatch),
+	/*8535*/ uint16(xCondIs64), 8538, 0,
+	/*8538*/ uint16(xSetOp), uint16(DAS),
 	/*8540*/ uint16(xMatch),
 	/*8541*/ uint16(xSetOp), uint16(XOR),
 	/*8543*/ uint16(xReadSlashR),
-	/*8544*/ uint16(xArgRM32),
-	/*8545*/ uint16(xArgR32),
+	/*8544*/ uint16(xArgRM8),
+	/*8545*/ uint16(xArgR8),
 	/*8546*/ uint16(xMatch),
-	/*8547*/ uint16(xCondDataSize), 8535, 8541, 8551,
-	/*8551*/ uint16(xSetOp), uint16(XOR),
-	/*8553*/ uint16(xReadSlashR),
-	/*8554*/ uint16(xArgRM64),
-	/*8555*/ uint16(xArgR64),
-	/*8556*/ uint16(xMatch),
-	/*8557*/ uint16(xSetOp), uint16(XOR),
-	/*8559*/ uint16(xReadSlashR),
-	/*8560*/ uint16(xArgR8),
-	/*8561*/ uint16(xArgRM8),
-	/*8562*/ uint16(xMatch),
-	/*8563*/ uint16(xCondIs64), 8566, 8582,
-	/*8566*/ uint16(xCondDataSize), 8570, 8576, 0,
+	/*8547*/ uint16(xCondIs64), 8550, 8566,
+	/*8550*/ uint16(xCondDataSize), 8554, 8560, 0,
+	/*8554*/ uint16(xSetOp), uint16(XOR),
+	/*8556*/ uint16(xReadSlashR),
+	/*8557*/ uint16(xArgRM16),
+	/*8558*/ uint16(xArgR16),
+	/*8559*/ uint16(xMatch),
+	/*8560*/ uint16(xSetOp), uint16(XOR),
+	/*8562*/ uint16(xReadSlashR),
+	/*8563*/ uint16(xArgRM32),
+	/*8564*/ uint16(xArgR32),
+	/*8565*/ uint16(xMatch),
+	/*8566*/ uint16(xCondDataSize), 8554, 8560, 8570,
 	/*8570*/ uint16(xSetOp), uint16(XOR),
 	/*8572*/ uint16(xReadSlashR),
-	/*8573*/ uint16(xArgR16),
-	/*8574*/ uint16(xArgRM16),
+	/*8573*/ uint16(xArgRM64),
+	/*8574*/ uint16(xArgR64),
 	/*8575*/ uint16(xMatch),
 	/*8576*/ uint16(xSetOp), uint16(XOR),
 	/*8578*/ uint16(xReadSlashR),
-	/*8579*/ uint16(xArgR32),
-	/*8580*/ uint16(xArgRM32),
+	/*8579*/ uint16(xArgR8),
+	/*8580*/ uint16(xArgRM8),
 	/*8581*/ uint16(xMatch),
-	/*8582*/ uint16(xCondDataSize), 8570, 8576, 8586,
-	/*8586*/ uint16(xSetOp), uint16(XOR),
-	/*8588*/ uint16(xReadSlashR),
-	/*8589*/ uint16(xArgR64),
-	/*8590*/ uint16(xArgRM64),
-	/*8591*/ uint16(xMatch),
-	/*8592*/ uint16(xSetOp), uint16(XOR),
-	/*8594*/ uint16(xReadIb),
-	/*8595*/ uint16(xArgAL),
-	/*8596*/ uint16(xArgImm8u),
-	/*8597*/ uint16(xMatch),
-	/*8598*/ uint16(xCondIs64), 8601, 8617,
-	/*8601*/ uint16(xCondDataSize), 8605, 8611, 0,
+	/*8582*/ uint16(xCondIs64), 8585, 8601,
+	/*8585*/ uint16(xCondDataSize), 8589, 8595, 0,
+	/*8589*/ uint16(xSetOp), uint16(XOR),
+	/*8591*/ uint16(xReadSlashR),
+	/*8592*/ uint16(xArgR16),
+	/*8593*/ uint16(xArgRM16),
+	/*8594*/ uint16(xMatch),
+	/*8595*/ uint16(xSetOp), uint16(XOR),
+	/*8597*/ uint16(xReadSlashR),
+	/*8598*/ uint16(xArgR32),
+	/*8599*/ uint16(xArgRM32),
+	/*8600*/ uint16(xMatch),
+	/*8601*/ uint16(xCondDataSize), 8589, 8595, 8605,
 	/*8605*/ uint16(xSetOp), uint16(XOR),
-	/*8607*/ uint16(xReadIw),
-	/*8608*/ uint16(xArgAX),
-	/*8609*/ uint16(xArgImm16),
+	/*8607*/ uint16(xReadSlashR),
+	/*8608*/ uint16(xArgR64),
+	/*8609*/ uint16(xArgRM64),
 	/*8610*/ uint16(xMatch),
 	/*8611*/ uint16(xSetOp), uint16(XOR),
-	/*8613*/ uint16(xReadId),
-	/*8614*/ uint16(xArgEAX),
-	/*8615*/ uint16(xArgImm32),
+	/*8613*/ uint16(xReadIb),
+	/*8614*/ uint16(xArgAL),
+	/*8615*/ uint16(xArgImm8u),
 	/*8616*/ uint16(xMatch),
-	/*8617*/ uint16(xCondDataSize), 8605, 8611, 8621,
-	/*8621*/ uint16(xSetOp), uint16(XOR),
-	/*8623*/ uint16(xReadId),
-	/*8624*/ uint16(xArgRAX),
-	/*8625*/ uint16(xArgImm32),
-	/*8626*/ uint16(xMatch),
-	/*8627*/ uint16(xCondIs64), 8630, 0,
-	/*8630*/ uint16(xSetOp), uint16(AAA),
-	/*8632*/ uint16(xMatch),
-	/*8633*/ uint16(xSetOp), uint16(CMP),
-	/*8635*/ uint16(xReadSlashR),
-	/*8636*/ uint16(xArgRM8),
-	/*8637*/ uint16(xArgR8),
-	/*8638*/ uint16(xMatch),
-	/*8639*/ uint16(xCondIs64), 8642, 8658,
-	/*8642*/ uint16(xCondDataSize), 8646, 8652, 0,
-	/*8646*/ uint16(xSetOp), uint16(CMP),
-	/*8648*/ uint16(xReadSlashR),
-	/*8649*/ uint16(xArgRM16),
-	/*8650*/ uint16(xArgR16),
+	/*8617*/ uint16(xCondIs64), 8620, 8636,
+	/*8620*/ uint16(xCondDataSize), 8624, 8630, 0,
+	/*8624*/ uint16(xSetOp), uint16(XOR),
+	/*8626*/ uint16(xReadIw),
+	/*8627*/ uint16(xArgAX),
+	/*8628*/ uint16(xArgImm16),
+	/*8629*/ uint16(xMatch),
+	/*8630*/ uint16(xSetOp), uint16(XOR),
+	/*8632*/ uint16(xReadId),
+	/*8633*/ uint16(xArgEAX),
+	/*8634*/ uint16(xArgImm32),
+	/*8635*/ uint16(xMatch),
+	/*8636*/ uint16(xCondDataSize), 8624, 8630, 8640,
+	/*8640*/ uint16(xSetOp), uint16(XOR),
+	/*8642*/ uint16(xReadId),
+	/*8643*/ uint16(xArgRAX),
+	/*8644*/ uint16(xArgImm32),
+	/*8645*/ uint16(xMatch),
+	/*8646*/ uint16(xCondIs64), 8649, 0,
+	/*8649*/ uint16(xSetOp), uint16(AAA),
 	/*8651*/ uint16(xMatch),
 	/*8652*/ uint16(xSetOp), uint16(CMP),
 	/*8654*/ uint16(xReadSlashR),
-	/*8655*/ uint16(xArgRM32),
-	/*8656*/ uint16(xArgR32),
+	/*8655*/ uint16(xArgRM8),
+	/*8656*/ uint16(xArgR8),
 	/*8657*/ uint16(xMatch),
-	/*8658*/ uint16(xCondDataSize), 8646, 8652, 8662,
-	/*8662*/ uint16(xSetOp), uint16(CMP),
-	/*8664*/ uint16(xReadSlashR),
-	/*8665*/ uint16(xArgRM64),
-	/*8666*/ uint16(xArgR64),
-	/*8667*/ uint16(xMatch),
-	/*8668*/ uint16(xSetOp), uint16(CMP),
-	/*8670*/ uint16(xReadSlashR),
-	/*8671*/ uint16(xArgR8),
-	/*8672*/ uint16(xArgRM8),
-	/*8673*/ uint16(xMatch),
-	/*8674*/ uint16(xCondIs64), 8677, 8693,
-	/*8677*/ uint16(xCondDataSize), 8681, 8687, 0,
+	/*8658*/ uint16(xCondIs64), 8661, 8677,
+	/*8661*/ uint16(xCondDataSize), 8665, 8671, 0,
+	/*8665*/ uint16(xSetOp), uint16(CMP),
+	/*8667*/ uint16(xReadSlashR),
+	/*8668*/ uint16(xArgRM16),
+	/*8669*/ uint16(xArgR16),
+	/*8670*/ uint16(xMatch),
+	/*8671*/ uint16(xSetOp), uint16(CMP),
+	/*8673*/ uint16(xReadSlashR),
+	/*8674*/ uint16(xArgRM32),
+	/*8675*/ uint16(xArgR32),
+	/*8676*/ uint16(xMatch),
+	/*8677*/ uint16(xCondDataSize), 8665, 8671, 8681,
 	/*8681*/ uint16(xSetOp), uint16(CMP),
 	/*8683*/ uint16(xReadSlashR),
-	/*8684*/ uint16(xArgR16),
-	/*8685*/ uint16(xArgRM16),
+	/*8684*/ uint16(xArgRM64),
+	/*8685*/ uint16(xArgR64),
 	/*8686*/ uint16(xMatch),
 	/*8687*/ uint16(xSetOp), uint16(CMP),
 	/*8689*/ uint16(xReadSlashR),
-	/*8690*/ uint16(xArgR32),
-	/*8691*/ uint16(xArgRM32),
+	/*8690*/ uint16(xArgR8),
+	/*8691*/ uint16(xArgRM8),
 	/*8692*/ uint16(xMatch),
-	/*8693*/ uint16(xCondDataSize), 8681, 8687, 8697,
-	/*8697*/ uint16(xSetOp), uint16(CMP),
-	/*8699*/ uint16(xReadSlashR),
-	/*8700*/ uint16(xArgR64),
-	/*8701*/ uint16(xArgRM64),
-	/*8702*/ uint16(xMatch),
-	/*8703*/ uint16(xSetOp), uint16(CMP),
-	/*8705*/ uint16(xReadIb),
-	/*8706*/ uint16(xArgAL),
-	/*8707*/ uint16(xArgImm8u),
-	/*8708*/ uint16(xMatch),
-	/*8709*/ uint16(xCondIs64), 8712, 8728,
-	/*8712*/ uint16(xCondDataSize), 8716, 8722, 0,
+	/*8693*/ uint16(xCondIs64), 8696, 8712,
+	/*8696*/ uint16(xCondDataSize), 8700, 8706, 0,
+	/*8700*/ uint16(xSetOp), uint16(CMP),
+	/*8702*/ uint16(xReadSlashR),
+	/*8703*/ uint16(xArgR16),
+	/*8704*/ uint16(xArgRM16),
+	/*8705*/ uint16(xMatch),
+	/*8706*/ uint16(xSetOp), uint16(CMP),
+	/*8708*/ uint16(xReadSlashR),
+	/*8709*/ uint16(xArgR32),
+	/*8710*/ uint16(xArgRM32),
+	/*8711*/ uint16(xMatch),
+	/*8712*/ uint16(xCondDataSize), 8700, 8706, 8716,
 	/*8716*/ uint16(xSetOp), uint16(CMP),
-	/*8718*/ uint16(xReadIw),
-	/*8719*/ uint16(xArgAX),
-	/*8720*/ uint16(xArgImm16),
+	/*8718*/ uint16(xReadSlashR),
+	/*8719*/ uint16(xArgR64),
+	/*8720*/ uint16(xArgRM64),
 	/*8721*/ uint16(xMatch),
 	/*8722*/ uint16(xSetOp), uint16(CMP),
-	/*8724*/ uint16(xReadId),
-	/*8725*/ uint16(xArgEAX),
-	/*8726*/ uint16(xArgImm32),
+	/*8724*/ uint16(xReadIb),
+	/*8725*/ uint16(xArgAL),
+	/*8726*/ uint16(xArgImm8u),
 	/*8727*/ uint16(xMatch),
-	/*8728*/ uint16(xCondDataSize), 8716, 8722, 8732,
-	/*8732*/ uint16(xSetOp), uint16(CMP),
-	/*8734*/ uint16(xReadId),
-	/*8735*/ uint16(xArgRAX),
-	/*8736*/ uint16(xArgImm32),
-	/*8737*/ uint16(xMatch),
-	/*8738*/ uint16(xCondIs64), 8741, 0,
-	/*8741*/ uint16(xSetOp), uint16(AAS),
-	/*8743*/ uint16(xMatch),
-	/*8744*/ uint16(xCondIs64), 8747, 0,
-	/*8747*/ uint16(xCondDataSize), 8751, 8755, 0,
-	/*8751*/ uint16(xSetOp), uint16(INC),
-	/*8753*/ uint16(xArgR16op),
-	/*8754*/ uint16(xMatch),
-	/*8755*/ uint16(xSetOp), uint16(INC),
-	/*8757*/ uint16(xArgR32op),
-	/*8758*/ uint16(xMatch),
-	/*8759*/ uint16(xCondIs64), 8762, 0,
-	/*8762*/ uint16(xCondDataSize), 8766, 8770, 0,
-	/*8766*/ uint16(xSetOp), uint16(DEC),
-	/*8768*/ uint16(xArgR16op),
-	/*8769*/ uint16(xMatch),
-	/*8770*/ uint16(xSetOp), uint16(DEC),
-	/*8772*/ uint16(xArgR32op),
+	/*8728*/ uint16(xCondIs64), 8731, 8747,
+	/*8731*/ uint16(xCondDataSize), 8735, 8741, 0,
+	/*8735*/ uint16(xSetOp), uint16(CMP),
+	/*8737*/ uint16(xReadIw),
+	/*8738*/ uint16(xArgAX),
+	/*8739*/ uint16(xArgImm16),
+	/*8740*/ uint16(xMatch),
+	/*8741*/ uint16(xSetOp), uint16(CMP),
+	/*8743*/ uint16(xReadId),
+	/*8744*/ uint16(xArgEAX),
+	/*8745*/ uint16(xArgImm32),
+	/*8746*/ uint16(xMatch),
+	/*8747*/ uint16(xCondDataSize), 8735, 8741, 8751,
+	/*8751*/ uint16(xSetOp), uint16(CMP),
+	/*8753*/ uint16(xReadId),
+	/*8754*/ uint16(xArgRAX),
+	/*8755*/ uint16(xArgImm32),
+	/*8756*/ uint16(xMatch),
+	/*8757*/ uint16(xCondIs64), 8760, 0,
+	/*8760*/ uint16(xSetOp), uint16(AAS),
+	/*8762*/ uint16(xMatch),
+	/*8763*/ uint16(xCondIs64), 8766, 0,
+	/*8766*/ uint16(xCondDataSize), 8770, 8774, 0,
+	/*8770*/ uint16(xSetOp), uint16(INC),
+	/*8772*/ uint16(xArgR16op),
 	/*8773*/ uint16(xMatch),
-	/*8774*/ uint16(xCondIs64), 8777, 8789,
-	/*8777*/ uint16(xCondDataSize), 8781, 8785, 0,
-	/*8781*/ uint16(xSetOp), uint16(PUSH),
-	/*8783*/ uint16(xArgR16op),
-	/*8784*/ uint16(xMatch),
-	/*8785*/ uint16(xSetOp), uint16(PUSH),
-	/*8787*/ uint16(xArgR32op),
+	/*8774*/ uint16(xSetOp), uint16(INC),
+	/*8776*/ uint16(xArgR32op),
+	/*8777*/ uint16(xMatch),
+	/*8778*/ uint16(xCondIs64), 8781, 0,
+	/*8781*/ uint16(xCondDataSize), 8785, 8789, 0,
+	/*8785*/ uint16(xSetOp), uint16(DEC),
+	/*8787*/ uint16(xArgR16op),
 	/*8788*/ uint16(xMatch),
-	/*8789*/ uint16(xCondDataSize), 8781, 8793, 8797,
-	/*8793*/ uint16(xSetOp), uint16(PUSH),
-	/*8795*/ uint16(xArgR64op),
-	/*8796*/ uint16(xMatch),
-	/*8797*/ uint16(xSetOp), uint16(PUSH),
-	/*8799*/ uint16(xArgR64op),
-	/*8800*/ uint16(xMatch),
-	/*8801*/ uint16(xCondIs64), 8804, 8816,
-	/*8804*/ uint16(xCondDataSize), 8808, 8812, 0,
-	/*8808*/ uint16(xSetOp), uint16(POP),
-	/*8810*/ uint16(xArgR16op),
-	/*8811*/ uint16(xMatch),
-	/*8812*/ uint16(xSetOp), uint16(POP),
-	/*8814*/ uint16(xArgR32op),
+	/*8789*/ uint16(xSetOp), uint16(DEC),
+	/*8791*/ uint16(xArgR32op),
+	/*8792*/ uint16(xMatch),
+	/*8793*/ uint16(xCondIs64), 8796, 8808,
+	/*8796*/ uint16(xCondDataSize), 8800, 8804, 0,
+	/*8800*/ uint16(xSetOp), uint16(PUSH),
+	/*8802*/ uint16(xArgR16op),
+	/*8803*/ uint16(xMatch),
+	/*8804*/ uint16(xSetOp), uint16(PUSH),
+	/*8806*/ uint16(xArgR32op),
+	/*8807*/ uint16(xMatch),
+	/*8808*/ uint16(xCondDataSize), 8800, 8812, 8816,
+	/*8812*/ uint16(xSetOp), uint16(PUSH),
+	/*8814*/ uint16(xArgR64op),
 	/*8815*/ uint16(xMatch),
-	/*8816*/ uint16(xCondDataSize), 8808, 8820, 8824,
-	/*8820*/ uint16(xSetOp), uint16(POP),
-	/*8822*/ uint16(xArgR64op),
-	/*8823*/ uint16(xMatch),
-	/*8824*/ uint16(xSetOp), uint16(POP),
-	/*8826*/ uint16(xArgR64op),
-	/*8827*/ uint16(xMatch),
-	/*8828*/ uint16(xCondIs64), 8831, 0,
-	/*8831*/ uint16(xCondDataSize), 8835, 8838, 0,
-	/*8835*/ uint16(xSetOp), uint16(PUSHA),
-	/*8837*/ uint16(xMatch),
-	/*8838*/ uint16(xSetOp), uint16(PUSHAD),
-	/*8840*/ uint16(xMatch),
-	/*8841*/ uint16(xCondIs64), 8844, 0,
-	/*8844*/ uint16(xCondDataSize), 8848, 8851, 0,
-	/*8848*/ uint16(xSetOp), uint16(POPA),
-	/*8850*/ uint16(xMatch),
-	/*8851*/ uint16(xSetOp), uint16(POPAD),
-	/*8853*/ uint16(xMatch),
-	/*8854*/ uint16(xCondIs64), 8857, 0,
-	/*8857*/ uint16(xCondDataSize), 8861, 8867, 0,
-	/*8861*/ uint16(xSetOp), uint16(BOUND),
-	/*8863*/ uint16(xReadSlashR),
-	/*8864*/ uint16(xArgR16),
-	/*8865*/ uint16(xArgM16and16),
-	/*8866*/ uint16(xMatch),
-	/*8867*/ uint16(xSetOp), uint16(BOUND),
-	/*8869*/ uint16(xReadSlashR),
-	/*8870*/ uint16(xArgR32),
-	/*8871*/ uint16(xArgM32and32),
+	/*8816*/ uint16(xSetOp), uint16(PUSH),
+	/*8818*/ uint16(xArgR64op),
+	/*8819*/ uint16(xMatch),
+	/*8820*/ uint16(xCondIs64), 8823, 8835,
+	/*8823*/ uint16(xCondDataSize), 8827, 8831, 0,
+	/*8827*/ uint16(xSetOp), uint16(POP),
+	/*8829*/ uint16(xArgR16op),
+	/*8830*/ uint16(xMatch),
+	/*8831*/ uint16(xSetOp), uint16(POP),
+	/*8833*/ uint16(xArgR32op),
+	/*8834*/ uint16(xMatch),
+	/*8835*/ uint16(xCondDataSize), 8827, 8839, 8843,
+	/*8839*/ uint16(xSetOp), uint16(POP),
+	/*8841*/ uint16(xArgR64op),
+	/*8842*/ uint16(xMatch),
+	/*8843*/ uint16(xSetOp), uint16(POP),
+	/*8845*/ uint16(xArgR64op),
+	/*8846*/ uint16(xMatch),
+	/*8847*/ uint16(xCondIs64), 8850, 0,
+	/*8850*/ uint16(xCondDataSize), 8854, 8857, 0,
+	/*8854*/ uint16(xSetOp), uint16(PUSHA),
+	/*8856*/ uint16(xMatch),
+	/*8857*/ uint16(xSetOp), uint16(PUSHAD),
+	/*8859*/ uint16(xMatch),
+	/*8860*/ uint16(xCondIs64), 8863, 0,
+	/*8863*/ uint16(xCondDataSize), 8867, 8870, 0,
+	/*8867*/ uint16(xSetOp), uint16(POPA),
+	/*8869*/ uint16(xMatch),
+	/*8870*/ uint16(xSetOp), uint16(POPAD),
 	/*8872*/ uint16(xMatch),
-	/*8873*/ uint16(xCondIs64), 8876, 8882,
-	/*8876*/ uint16(xSetOp), uint16(ARPL),
-	/*8878*/ uint16(xReadSlashR),
-	/*8879*/ uint16(xArgRM16),
-	/*8880*/ uint16(xArgR16),
-	/*8881*/ uint16(xMatch),
-	/*8882*/ uint16(xCondDataSize), 8886, 8892, 8898,
-	/*8886*/ uint16(xSetOp), uint16(MOVSXD),
+	/*8873*/ uint16(xCondIs64), 8876, 0,
+	/*8876*/ uint16(xCondDataSize), 8880, 8886, 0,
+	/*8880*/ uint16(xSetOp), uint16(BOUND),
+	/*8882*/ uint16(xReadSlashR),
+	/*8883*/ uint16(xArgR16),
+	/*8884*/ uint16(xArgM16and16),
+	/*8885*/ uint16(xMatch),
+	/*8886*/ uint16(xSetOp), uint16(BOUND),
 	/*8888*/ uint16(xReadSlashR),
-	/*8889*/ uint16(xArgR16),
-	/*8890*/ uint16(xArgRM32),
+	/*8889*/ uint16(xArgR32),
+	/*8890*/ uint16(xArgM32and32),
 	/*8891*/ uint16(xMatch),
-	/*8892*/ uint16(xSetOp), uint16(MOVSXD),
-	/*8894*/ uint16(xReadSlashR),
-	/*8895*/ uint16(xArgR32),
-	/*8896*/ uint16(xArgRM32),
-	/*8897*/ uint16(xMatch),
-	/*8898*/ uint16(xSetOp), uint16(MOVSXD),
-	/*8900*/ uint16(xReadSlashR),
-	/*8901*/ uint16(xArgR64),
-	/*8902*/ uint16(xArgRM32),
-	/*8903*/ uint16(xMatch),
-	/*8904*/ uint16(xCondDataSize), 8908, 8913, 8918,
-	/*8908*/ uint16(xSetOp), uint16(PUSH),
-	/*8910*/ uint16(xReadIw),
-	/*8911*/ uint16(xArgImm16),
-	/*8912*/ uint16(xMatch),
-	/*8913*/ uint16(xSetOp), uint16(PUSH),
-	/*8915*/ uint16(xReadId),
-	/*8916*/ uint16(xArgImm32),
-	/*8917*/ uint16(xMatch),
-	/*8918*/ uint16(xSetOp), uint16(PUSH),
-	/*8920*/ uint16(xReadId),
-	/*8921*/ uint16(xArgImm32),
+	/*8892*/ uint16(xCondIs64), 8895, 8901,
+	/*8895*/ uint16(xSetOp), uint16(ARPL),
+	/*8897*/ uint16(xReadSlashR),
+	/*8898*/ uint16(xArgRM16),
+	/*8899*/ uint16(xArgR16),
+	/*8900*/ uint16(xMatch),
+	/*8901*/ uint16(xCondDataSize), 8905, 8911, 8917,
+	/*8905*/ uint16(xSetOp), uint16(MOVSXD),
+	/*8907*/ uint16(xReadSlashR),
+	/*8908*/ uint16(xArgR16),
+	/*8909*/ uint16(xArgRM32),
+	/*8910*/ uint16(xMatch),
+	/*8911*/ uint16(xSetOp), uint16(MOVSXD),
+	/*8913*/ uint16(xReadSlashR),
+	/*8914*/ uint16(xArgR32),
+	/*8915*/ uint16(xArgRM32),
+	/*8916*/ uint16(xMatch),
+	/*8917*/ uint16(xSetOp), uint16(MOVSXD),
+	/*8919*/ uint16(xReadSlashR),
+	/*8920*/ uint16(xArgR64),
+	/*8921*/ uint16(xArgRM32),
 	/*8922*/ uint16(xMatch),
-	/*8923*/ uint16(xCondIs64), 8926, 8946,
-	/*8926*/ uint16(xCondDataSize), 8930, 8938, 0,
-	/*8930*/ uint16(xSetOp), uint16(IMUL),
-	/*8932*/ uint16(xReadSlashR),
-	/*8933*/ uint16(xReadIw),
-	/*8934*/ uint16(xArgR16),
-	/*8935*/ uint16(xArgRM16),
-	/*8936*/ uint16(xArgImm16),
-	/*8937*/ uint16(xMatch),
-	/*8938*/ uint16(xSetOp), uint16(IMUL),
-	/*8940*/ uint16(xReadSlashR),
-	/*8941*/ uint16(xReadId),
-	/*8942*/ uint16(xArgR32),
-	/*8943*/ uint16(xArgRM32),
-	/*8944*/ uint16(xArgImm32),
-	/*8945*/ uint16(xMatch),
-	/*8946*/ uint16(xCondDataSize), 8930, 8938, 8950,
-	/*8950*/ uint16(xSetOp), uint16(IMUL),
-	/*8952*/ uint16(xReadSlashR),
-	/*8953*/ uint16(xReadId),
-	/*8954*/ uint16(xArgR64),
-	/*8955*/ uint16(xArgRM64),
-	/*8956*/ uint16(xArgImm32),
-	/*8957*/ uint16(xMatch),
-	/*8958*/ uint16(xSetOp), uint16(PUSH),
-	/*8960*/ uint16(xReadIb),
-	/*8961*/ uint16(xArgImm8),
-	/*8962*/ uint16(xMatch),
-	/*8963*/ uint16(xCondIs64), 8966, 8986,
-	/*8966*/ uint16(xCondDataSize), 8970, 8978, 0,
-	/*8970*/ uint16(xSetOp), uint16(IMUL),
-	/*8972*/ uint16(xReadSlashR),
-	/*8973*/ uint16(xReadIb),
-	/*8974*/ uint16(xArgR16),
-	/*8975*/ uint16(xArgRM16),
-	/*8976*/ uint16(xArgImm8),
-	/*8977*/ uint16(xMatch),
-	/*8978*/ uint16(xSetOp), uint16(IMUL),
-	/*8980*/ uint16(xReadSlashR),
-	/*8981*/ uint16(xReadIb),
-	/*8982*/ uint16(xArgR32),
-	/*8983*/ uint16(xArgRM32),
-	/*8984*/ uint16(xArgImm8),
-	/*8985*/ uint16(xMatch),
-	/*8986*/ uint16(xCondDataSize), 8970, 8978, 8990,
-	/*8990*/ uint16(xSetOp), uint16(IMUL),
-	/*8992*/ uint16(xReadSlashR),
-	/*8993*/ uint16(xReadIb),
-	/*8994*/ uint16(xArgR64),
-	/*8995*/ uint16(xArgRM64),
-	/*8996*/ uint16(xArgImm8),
-	/*8997*/ uint16(xMatch),
-	/*8998*/ uint16(xSetOp), uint16(INSB),
-	/*9000*/ uint16(xMatch),
-	/*9001*/ uint16(xCondDataSize), 9005, 9008, 9011,
-	/*9005*/ uint16(xSetOp), uint16(INSW),
-	/*9007*/ uint16(xMatch),
-	/*9008*/ uint16(xSetOp), uint16(INSD),
-	/*9010*/ uint16(xMatch),
-	/*9011*/ uint16(xSetOp), uint16(INSD),
-	/*9013*/ uint16(xMatch),
-	/*9014*/ uint16(xSetOp), uint16(OUTSB),
+	/*8923*/ uint16(xCondDataSize), 8927, 8932, 8937,
+	/*8927*/ uint16(xSetOp), uint16(PUSH),
+	/*8929*/ uint16(xReadIw),
+	/*8930*/ uint16(xArgImm16),
+	/*8931*/ uint16(xMatch),
+	/*8932*/ uint16(xSetOp), uint16(PUSH),
+	/*8934*/ uint16(xReadId),
+	/*8935*/ uint16(xArgImm32),
+	/*8936*/ uint16(xMatch),
+	/*8937*/ uint16(xSetOp), uint16(PUSH),
+	/*8939*/ uint16(xReadId),
+	/*8940*/ uint16(xArgImm32),
+	/*8941*/ uint16(xMatch),
+	/*8942*/ uint16(xCondIs64), 8945, 8965,
+	/*8945*/ uint16(xCondDataSize), 8949, 8957, 0,
+	/*8949*/ uint16(xSetOp), uint16(IMUL),
+	/*8951*/ uint16(xReadSlashR),
+	/*8952*/ uint16(xReadIw),
+	/*8953*/ uint16(xArgR16),
+	/*8954*/ uint16(xArgRM16),
+	/*8955*/ uint16(xArgImm16),
+	/*8956*/ uint16(xMatch),
+	/*8957*/ uint16(xSetOp), uint16(IMUL),
+	/*8959*/ uint16(xReadSlashR),
+	/*8960*/ uint16(xReadId),
+	/*8961*/ uint16(xArgR32),
+	/*8962*/ uint16(xArgRM32),
+	/*8963*/ uint16(xArgImm32),
+	/*8964*/ uint16(xMatch),
+	/*8965*/ uint16(xCondDataSize), 8949, 8957, 8969,
+	/*8969*/ uint16(xSetOp), uint16(IMUL),
+	/*8971*/ uint16(xReadSlashR),
+	/*8972*/ uint16(xReadId),
+	/*8973*/ uint16(xArgR64),
+	/*8974*/ uint16(xArgRM64),
+	/*8975*/ uint16(xArgImm32),
+	/*8976*/ uint16(xMatch),
+	/*8977*/ uint16(xSetOp), uint16(PUSH),
+	/*8979*/ uint16(xReadIb),
+	/*8980*/ uint16(xArgImm8),
+	/*8981*/ uint16(xMatch),
+	/*8982*/ uint16(xCondIs64), 8985, 9005,
+	/*8985*/ uint16(xCondDataSize), 8989, 8997, 0,
+	/*8989*/ uint16(xSetOp), uint16(IMUL),
+	/*8991*/ uint16(xReadSlashR),
+	/*8992*/ uint16(xReadIb),
+	/*8993*/ uint16(xArgR16),
+	/*8994*/ uint16(xArgRM16),
+	/*8995*/ uint16(xArgImm8),
+	/*8996*/ uint16(xMatch),
+	/*8997*/ uint16(xSetOp), uint16(IMUL),
+	/*8999*/ uint16(xReadSlashR),
+	/*9000*/ uint16(xReadIb),
+	/*9001*/ uint16(xArgR32),
+	/*9002*/ uint16(xArgRM32),
+	/*9003*/ uint16(xArgImm8),
+	/*9004*/ uint16(xMatch),
+	/*9005*/ uint16(xCondDataSize), 8989, 8997, 9009,
+	/*9009*/ uint16(xSetOp), uint16(IMUL),
+	/*9011*/ uint16(xReadSlashR),
+	/*9012*/ uint16(xReadIb),
+	/*9013*/ uint16(xArgR64),
+	/*9014*/ uint16(xArgRM64),
+	/*9015*/ uint16(xArgImm8),
 	/*9016*/ uint16(xMatch),
-	/*9017*/ uint16(xCondPrefix), 3,
-	0xC5, 9064,
-	0xC4, 9038,
-	0x0, 9025,
-	/*9025*/ uint16(xCondDataSize), 9029, 9032, 9035,
-	/*9029*/ uint16(xSetOp), uint16(OUTSW),
-	/*9031*/ uint16(xMatch),
-	/*9032*/ uint16(xSetOp), uint16(OUTSD),
-	/*9034*/ uint16(xMatch),
-	/*9035*/ uint16(xSetOp), uint16(OUTSD),
-	/*9037*/ uint16(xMatch),
-	/*9038*/ uint16(xCondPrefix), 2,
-	0xF3, 9054,
-	0x66, 9044,
-	/*9044*/ uint16(xCondPrefix), 1,
-	0x0F, 9048,
-	/*9048*/ uint16(xSetOp), uint16(VMOVDQA),
-	/*9050*/ uint16(xReadSlashR),
-	/*9051*/ uint16(xArgYmm1),
-	/*9052*/ uint16(xArgYmm2M256),
+	/*9017*/ uint16(xSetOp), uint16(INSB),
+	/*9019*/ uint16(xMatch),
+	/*9020*/ uint16(xCondDataSize), 9024, 9027, 9030,
+	/*9024*/ uint16(xSetOp), uint16(INSW),
+	/*9026*/ uint16(xMatch),
+	/*9027*/ uint16(xSetOp), uint16(INSD),
+	/*9029*/ uint16(xMatch),
+	/*9030*/ uint16(xSetOp), uint16(INSD),
+	/*9032*/ uint16(xMatch),
+	/*9033*/ uint16(xSetOp), uint16(OUTSB),
+	/*9035*/ uint16(xMatch),
+	/*9036*/ uint16(xCondPrefix), 3,
+	0xC5, 9083,
+	0xC4, 9057,
+	0x0, 9044,
+	/*9044*/ uint16(xCondDataSize), 9048, 9051, 9054,
+	/*9048*/ uint16(xSetOp), uint16(OUTSW),
+	/*9050*/ uint16(xMatch),
+	/*9051*/ uint16(xSetOp), uint16(OUTSD),
 	/*9053*/ uint16(xMatch),
-	/*9054*/ uint16(xCondPrefix), 1,
-	0x0F, 9058,
-	/*9058*/ uint16(xSetOp), uint16(VMOVDQU),
-	/*9060*/ uint16(xReadSlashR),
-	/*9061*/ uint16(xArgYmm1),
-	/*9062*/ uint16(xArgYmm2M256),
-	/*9063*/ uint16(xMatch),
-	/*9064*/ uint16(xCondPrefix), 2,
-	0xF3, 9080,
-	0x66, 9070,
-	/*9070*/ uint16(xCondPrefix), 1,
-	0x0F, 9074,
-	/*9074*/ uint16(xSetOp), uint16(VMOVDQA),
-	/*9076*/ uint16(xReadSlashR),
-	/*9077*/ uint16(xArgYmm1),
-	/*9078*/ uint16(xArgYmm2M256),
-	/*9079*/ uint16(xMatch),
-	/*9080*/ uint16(xCondPrefix), 1,
-	0x0F, 9084,
-	/*9084*/ uint16(xSetOp), uint16(VMOVDQU),
-	/*9086*/ uint16(xReadSlashR),
-	/*9087*/ uint16(xArgYmm1),
-	/*9088*/ uint16(xArgYmm2M256),
-	/*9089*/ uint16(xMatch),
-	/*9090*/ uint16(xSetOp), uint16(JO),
-	/*9092*/ uint16(xReadCb),
-	/*9093*/ uint16(xArgRel8),
-	/*9094*/ uint16(xMatch),
-	/*9095*/ uint16(xSetOp), uint16(JNO),
-	/*9097*/ uint16(xReadCb),
-	/*9098*/ uint16(xArgRel8),
-	/*9099*/ uint16(xMatch),
-	/*9100*/ uint16(xSetOp), uint16(JB),
-	/*9102*/ uint16(xReadCb),
-	/*9103*/ uint16(xArgRel8),
-	/*9104*/ uint16(xMatch),
-	/*9105*/ uint16(xSetOp), uint16(JAE),
-	/*9107*/ uint16(xReadCb),
-	/*9108*/ uint16(xArgRel8),
-	/*9109*/ uint16(xMatch),
-	/*9110*/ uint16(xSetOp), uint16(JE),
-	/*9112*/ uint16(xReadCb),
-	/*9113*/ uint16(xArgRel8),
-	/*9114*/ uint16(xMatch),
-	/*9115*/ uint16(xSetOp), uint16(JNE),
-	/*9117*/ uint16(xReadCb),
-	/*9118*/ uint16(xArgRel8),
-	/*9119*/ uint16(xMatch),
-	/*9120*/ uint16(xSetOp), uint16(JBE),
-	/*9122*/ uint16(xReadCb),
-	/*9123*/ uint16(xArgRel8),
-	/*9124*/ uint16(xMatch),
-	/*9125*/ uint16(xCondPrefix), 3,
-	0xC5, 9145,
-	0xC4, 9138,
-	0x0, 9133,
-	/*9133*/ uint16(xSetOp), uint16(JA),
-	/*9135*/ uint16(xReadCb),
-	/*9136*/ uint16(xArgRel8),
-	/*9137*/ uint16(xMatch),
-	/*9138*/ uint16(xCondPrefix), 1,
-	0x0F, 9142,
-	/*9142*/ uint16(xSetOp), uint16(VZEROUPPER),
-	/*9144*/ uint16(xMatch),
-	/*9145*/ uint16(xCondPrefix), 1,
-	0x0F, 9149,
-	/*9149*/ uint16(xSetOp), uint16(VZEROUPPER),
-	/*9151*/ uint16(xMatch),
-	/*9152*/ uint16(xSetOp), uint16(JS),
+	/*9054*/ uint16(xSetOp), uint16(OUTSD),
+	/*9056*/ uint16(xMatch),
+	/*9057*/ uint16(xCondPrefix), 2,
+	0xF3, 9073,
+	0x66, 9063,
+	/*9063*/ uint16(xCondPrefix), 1,
+	0x0F, 9067,
+	/*9067*/ uint16(xSetOp), uint16(VMOVDQA),
+	/*9069*/ uint16(xReadSlashR),
+	/*9070*/ uint16(xArgYmm1),
+	/*9071*/ uint16(xArgYmm2M256),
+	/*9072*/ uint16(xMatch),
+	/*9073*/ uint16(xCondPrefix), 1,
+	0x0F, 9077,
+	/*9077*/ uint16(xSetOp), uint16(VMOVDQU),
+	/*9079*/ uint16(xReadSlashR),
+	/*9080*/ uint16(xArgYmm1),
+	/*9081*/ uint16(xArgYmm2M256),
+	/*9082*/ uint16(xMatch),
+	/*9083*/ uint16(xCondPrefix), 2,
+	0xF3, 9099,
+	0x66, 9089,
+	/*9089*/ uint16(xCondPrefix), 1,
+	0x0F, 9093,
+	/*9093*/ uint16(xSetOp), uint16(VMOVDQA),
+	/*9095*/ uint16(xReadSlashR),
+	/*9096*/ uint16(xArgYmm1),
+	/*9097*/ uint16(xArgYmm2M256),
+	/*9098*/ uint16(xMatch),
+	/*9099*/ uint16(xCondPrefix), 1,
+	0x0F, 9103,
+	/*9103*/ uint16(xSetOp), uint16(VMOVDQU),
+	/*9105*/ uint16(xReadSlashR),
+	/*9106*/ uint16(xArgYmm1),
+	/*9107*/ uint16(xArgYmm2M256),
+	/*9108*/ uint16(xMatch),
+	/*9109*/ uint16(xSetOp), uint16(JO),
+	/*9111*/ uint16(xReadCb),
+	/*9112*/ uint16(xArgRel8),
+	/*9113*/ uint16(xMatch),
+	/*9114*/ uint16(xSetOp), uint16(JNO),
+	/*9116*/ uint16(xReadCb),
+	/*9117*/ uint16(xArgRel8),
+	/*9118*/ uint16(xMatch),
+	/*9119*/ uint16(xSetOp), uint16(JB),
+	/*9121*/ uint16(xReadCb),
+	/*9122*/ uint16(xArgRel8),
+	/*9123*/ uint16(xMatch),
+	/*9124*/ uint16(xSetOp), uint16(JAE),
+	/*9126*/ uint16(xReadCb),
+	/*9127*/ uint16(xArgRel8),
+	/*9128*/ uint16(xMatch),
+	/*9129*/ uint16(xSetOp), uint16(JE),
+	/*9131*/ uint16(xReadCb),
+	/*9132*/ uint16(xArgRel8),
+	/*9133*/ uint16(xMatch),
+	/*9134*/ uint16(xSetOp), uint16(JNE),
+	/*9136*/ uint16(xReadCb),
+	/*9137*/ uint16(xArgRel8),
+	/*9138*/ uint16(xMatch),
+	/*9139*/ uint16(xSetOp), uint16(JBE),
+	/*9141*/ uint16(xReadCb),
+	/*9142*/ uint16(xArgRel8),
+	/*9143*/ uint16(xMatch),
+	/*9144*/ uint16(xCondPrefix), 3,
+	0xC5, 9164,
+	0xC4, 9157,
+	0x0, 9152,
+	/*9152*/ uint16(xSetOp), uint16(JA),
 	/*9154*/ uint16(xReadCb),
 	/*9155*/ uint16(xArgRel8),
 	/*9156*/ uint16(xMatch),
-	/*9157*/ uint16(xSetOp), uint16(JNS),
-	/*9159*/ uint16(xReadCb),
-	/*9160*/ uint16(xArgRel8),
-	/*9161*/ uint16(xMatch),
-	/*9162*/ uint16(xSetOp), uint16(JP),
-	/*9164*/ uint16(xReadCb),
-	/*9165*/ uint16(xArgRel8),
-	/*9166*/ uint16(xMatch),
-	/*9167*/ uint16(xSetOp), uint16(JNP),
-	/*9169*/ uint16(xReadCb),
-	/*9170*/ uint16(xArgRel8),
-	/*9171*/ uint16(xMatch),
-	/*9172*/ uint16(xSetOp), uint16(JL),
-	/*9174*/ uint16(xReadCb),
-	/*9175*/ uint16(xArgRel8),
-	/*9176*/ uint16(xMatch),
-	/*9177*/ uint16(xSetOp), uint16(JGE),
-	/*9179*/ uint16(xReadCb),
-	/*9180*/ uint16(xArgRel8),
-	/*9181*/ uint16(xMatch),
-	/*9182*/ uint16(xSetOp), uint16(JLE),
-	/*9184*/ uint16(xReadCb),
-	/*9185*/ uint16(xArgRel8),
-	/*9186*/ uint16(xMatch),
-	/*9187*/ uint16(xCondPrefix), 3,
-	0xC5, 9226,
-	0xC4, 9200,
-	0x0, 9195,
-	/*9195*/ uint16(xSetOp), uint16(JG),
-	/*9197*/ uint16(xReadCb),
-	/*9198*/ uint16(xArgRel8),
-	/*9199*/ uint16(xMatch),
-	/*9200*/ uint16(xCondPrefix), 2,
-	0xF3, 9216,
-	0x66, 9206,
-	/*9206*/ uint16(xCondPrefix), 1,
-	0x0F, 9210,
-	/*9210*/ uint16(xSetOp), uint16(VMOVDQA),
-	/*9212*/ uint16(xReadSlashR),
-	/*9213*/ uint16(xArgYmm2M256),
-	/*9214*/ uint16(xArgYmm1),
-	/*9215*/ uint16(xMatch),
-	/*9216*/ uint16(xCondPrefix), 1,
-	0x0F, 9220,
-	/*9220*/ uint16(xSetOp), uint16(VMOVDQU),
-	/*9222*/ uint16(xReadSlashR),
-	/*9223*/ uint16(xArgYmm2M256),
-	/*9224*/ uint16(xArgYmm1),
-	/*9225*/ uint16(xMatch),
-	/*9226*/ uint16(xCondPrefix), 2,
-	0xF3, 9242,
-	0x66, 9232,
-	/*9232*/ uint16(xCondPrefix), 1,
-	0x0F, 9236,
-	/*9236*/ uint16(xSetOp), uint16(VMOVDQA),
-	/*9238*/ uint16(xReadSlashR),
-	/*9239*/ uint16(xArgYmm2M256),
-	/*9240*/ uint16(xArgYmm1),
-	/*9241*/ uint16(xMatch),
-	/*9242*/ uint16(xCondPrefix), 1,
-	0x0F, 9246,
-	/*9246*/ uint16(xSetOp), uint16(VMOVDQU),
-	/*9248*/ uint16(xReadSlashR),
-	/*9249*/ uint16(xArgYmm2M256),
-	/*9250*/ uint16(xArgYmm1),
-	/*9251*/ uint16(xMatch),
-	/*9252*/ uint16(xCondSlashR),
-	9261, // 0
-	9267, // 1
-	9273, // 2
-	9279, // 3
-	9285, // 4
-	9291, // 5
-	9297, // 6
-	9303, // 7
-	/*9261*/ uint16(xSetOp), uint16(ADD),
-	/*9263*/ uint16(xReadIb),
-	/*9264*/ uint16(xArgRM8),
-	/*9265*/ uint16(xArgImm8u),
-	/*9266*/ uint16(xMatch),
-	/*9267*/ uint16(xSetOp), uint16(OR),
-	/*9269*/ uint16(xReadIb),
-	/*9270*/ uint16(xArgRM8),
-	/*9271*/ uint16(xArgImm8u),
-	/*9272*/ uint16(xMatch),
-	/*9273*/ uint16(xSetOp), uint16(ADC),
-	/*9275*/ uint16(xReadIb),
-	/*9276*/ uint16(xArgRM8),
-	/*9277*/ uint16(xArgImm8u),
-	/*9278*/ uint16(xMatch),
-	/*9279*/ uint16(xSetOp), uint16(SBB),
-	/*9281*/ uint16(xReadIb),
-	/*9282*/ uint16(xArgRM8),
-	/*9283*/ uint16(xArgImm8u),
-	/*9284*/ uint16(xMatch),
-	/*9285*/ uint16(xSetOp), uint16(AND),
-	/*9287*/ uint16(xReadIb),
-	/*9288*/ uint16(xArgRM8),
-	/*9289*/ uint16(xArgImm8u),
-	/*9290*/ uint16(xMatch),
-	/*9291*/ uint16(xSetOp), uint16(SUB),
-	/*9293*/ uint16(xReadIb),
-	/*9294*/ uint16(xArgRM8),
-	/*9295*/ uint16(xArgImm8u),
-	/*9296*/ uint16(xMatch),
-	/*9297*/ uint16(xSetOp), uint16(XOR),
-	/*9299*/ uint16(xReadIb),
-	/*9300*/ uint16(xArgRM8),
-	/*9301*/ uint16(xArgImm8u),
-	/*9302*/ uint16(xMatch),
-	/*9303*/ uint16(xSetOp), uint16(CMP),
-	/*9305*/ uint16(xReadIb),
-	/*9306*/ uint16(xArgRM8),
-	/*9307*/ uint16(xArgImm8u),
-	/*9308*/ uint16(xMatch),
-	/*9309*/ uint16(xCondSlashR),
-	9318, // 0
-	9347, // 1
-	9376, // 2
-	9405, // 3
-	9434, // 4
-	9463, // 5
-	9492, // 6
-	9521, // 7
-	/*9318*/ uint16(xCondIs64), 9321, 9337,
-	/*9321*/ uint16(xCondDataSize), 9325, 9331, 0,
-	/*9325*/ uint16(xSetOp), uint16(ADD),
-	/*9327*/ uint16(xReadIw),
-	/*9328*/ uint16(xArgRM16),
-	/*9329*/ uint16(xArgImm16),
-	/*9330*/ uint16(xMatch),
-	/*9331*/ uint16(xSetOp), uint16(ADD),
-	/*9333*/ uint16(xReadId),
-	/*9334*/ uint16(xArgRM32),
-	/*9335*/ uint16(xArgImm32),
-	/*9336*/ uint16(xMatch),
-	/*9337*/ uint16(xCondDataSize), 9325, 9331, 9341,
-	/*9341*/ uint16(xSetOp), uint16(ADD),
-	/*9343*/ uint16(xReadId),
-	/*9344*/ uint16(xArgRM64),
-	/*9345*/ uint16(xArgImm32),
-	/*9346*/ uint16(xMatch),
-	/*9347*/ uint16(xCondIs64), 9350, 9366,
-	/*9350*/ uint16(xCondDataSize), 9354, 9360, 0,
-	/*9354*/ uint16(xSetOp), uint16(OR),
-	/*9356*/ uint16(xReadIw),
-	/*9357*/ uint16(xArgRM16),
-	/*9358*/ uint16(xArgImm16),
-	/*9359*/ uint16(xMatch),
-	/*9360*/ uint16(xSetOp), uint16(OR),
+	/*9157*/ uint16(xCondPrefix), 1,
+	0x0F, 9161,
+	/*9161*/ uint16(xSetOp), uint16(VZEROUPPER),
+	/*9163*/ uint16(xMatch),
+	/*9164*/ uint16(xCondPrefix), 1,
+	0x0F, 9168,
+	/*9168*/ uint16(xSetOp), uint16(VZEROUPPER),
+	/*9170*/ uint16(xMatch),
+	/*9171*/ uint16(xSetOp), uint16(JS),
+	/*9173*/ uint16(xReadCb),
+	/*9174*/ uint16(xArgRel8),
+	/*9175*/ uint16(xMatch),
+	/*9176*/ uint16(xSetOp), uint16(JNS),
+	/*9178*/ uint16(xReadCb),
+	/*9179*/ uint16(xArgRel8),
+	/*9180*/ uint16(xMatch),
+	/*9181*/ uint16(xSetOp), uint16(JP),
+	/*9183*/ uint16(xReadCb),
+	/*9184*/ uint16(xArgRel8),
+	/*9185*/ uint16(xMatch),
+	/*9186*/ uint16(xSetOp), uint16(JNP),
+	/*9188*/ uint16(xReadCb),
+	/*9189*/ uint16(xArgRel8),
+	/*9190*/ uint16(xMatch),
+	/*9191*/ uint16(xSetOp), uint16(JL),
+	/*9193*/ uint16(xReadCb),
+	/*9194*/ uint16(xArgRel8),
+	/*9195*/ uint16(xMatch),
+	/*9196*/ uint16(xSetOp), uint16(JGE),
+	/*9198*/ uint16(xReadCb),
+	/*9199*/ uint16(xArgRel8),
+	/*9200*/ uint16(xMatch),
+	/*9201*/ uint16(xSetOp), uint16(JLE),
+	/*9203*/ uint16(xReadCb),
+	/*9204*/ uint16(xArgRel8),
+	/*9205*/ uint16(xMatch),
+	/*9206*/ uint16(xCondPrefix), 3,
+	0xC5, 9245,
+	0xC4, 9219,
+	0x0, 9214,
+	/*9214*/ uint16(xSetOp), uint16(JG),
+	/*9216*/ uint16(xReadCb),
+	/*9217*/ uint16(xArgRel8),
+	/*9218*/ uint16(xMatch),
+	/*9219*/ uint16(xCondPrefix), 2,
+	0xF3, 9235,
+	0x66, 9225,
+	/*9225*/ uint16(xCondPrefix), 1,
+	0x0F, 9229,
+	/*9229*/ uint16(xSetOp), uint16(VMOVDQA),
+	/*9231*/ uint16(xReadSlashR),
+	/*9232*/ uint16(xArgYmm2M256),
+	/*9233*/ uint16(xArgYmm1),
+	/*9234*/ uint16(xMatch),
+	/*9235*/ uint16(xCondPrefix), 1,
+	0x0F, 9239,
+	/*9239*/ uint16(xSetOp), uint16(VMOVDQU),
+	/*9241*/ uint16(xReadSlashR),
+	/*9242*/ uint16(xArgYmm2M256),
+	/*9243*/ uint16(xArgYmm1),
+	/*9244*/ uint16(xMatch),
+	/*9245*/ uint16(xCondPrefix), 2,
+	0xF3, 9261,
+	0x66, 9251,
+	/*9251*/ uint16(xCondPrefix), 1,
+	0x0F, 9255,
+	/*9255*/ uint16(xSetOp), uint16(VMOVDQA),
+	/*9257*/ uint16(xReadSlashR),
+	/*9258*/ uint16(xArgYmm2M256),
+	/*9259*/ uint16(xArgYmm1),
+	/*9260*/ uint16(xMatch),
+	/*9261*/ uint16(xCondPrefix), 1,
+	0x0F, 9265,
+	/*9265*/ uint16(xSetOp), uint16(VMOVDQU),
+	/*9267*/ uint16(xReadSlashR),
+	/*9268*/ uint16(xArgYmm2M256),
+	/*9269*/ uint16(xArgYmm1),
+	/*9270*/ uint16(xMatch),
+	/*9271*/ uint16(xCondSlashR),
+	9280, // 0
+	9286, // 1
+	9292, // 2
+	9298, // 3
+	9304, // 4
+	9310, // 5
+	9316, // 6
+	9322, // 7
+	/*9280*/ uint16(xSetOp), uint16(ADD),
+	/*9282*/ uint16(xReadIb),
+	/*9283*/ uint16(xArgRM8),
+	/*9284*/ uint16(xArgImm8u),
+	/*9285*/ uint16(xMatch),
+	/*9286*/ uint16(xSetOp), uint16(OR),
+	/*9288*/ uint16(xReadIb),
+	/*9289*/ uint16(xArgRM8),
+	/*9290*/ uint16(xArgImm8u),
+	/*9291*/ uint16(xMatch),
+	/*9292*/ uint16(xSetOp), uint16(ADC),
+	/*9294*/ uint16(xReadIb),
+	/*9295*/ uint16(xArgRM8),
+	/*9296*/ uint16(xArgImm8u),
+	/*9297*/ uint16(xMatch),
+	/*9298*/ uint16(xSetOp), uint16(SBB),
+	/*9300*/ uint16(xReadIb),
+	/*9301*/ uint16(xArgRM8),
+	/*9302*/ uint16(xArgImm8u),
+	/*9303*/ uint16(xMatch),
+	/*9304*/ uint16(xSetOp), uint16(AND),
+	/*9306*/ uint16(xReadIb),
+	/*9307*/ uint16(xArgRM8),
+	/*9308*/ uint16(xArgImm8u),
+	/*9309*/ uint16(xMatch),
+	/*9310*/ uint16(xSetOp), uint16(SUB),
+	/*9312*/ uint16(xReadIb),
+	/*9313*/ uint16(xArgRM8),
+	/*9314*/ uint16(xArgImm8u),
+	/*9315*/ uint16(xMatch),
+	/*9316*/ uint16(xSetOp), uint16(XOR),
+	/*9318*/ uint16(xReadIb),
+	/*9319*/ uint16(xArgRM8),
+	/*9320*/ uint16(xArgImm8u),
+	/*9321*/ uint16(xMatch),
+	/*9322*/ uint16(xSetOp), uint16(CMP),
+	/*9324*/ uint16(xReadIb),
+	/*9325*/ uint16(xArgRM8),
+	/*9326*/ uint16(xArgImm8u),
+	/*9327*/ uint16(xMatch),
+	/*9328*/ uint16(xCondSlashR),
+	9337, // 0
+	9366, // 1
+	9395, // 2
+	9424, // 3
+	9453, // 4
+	9482, // 5
+	9511, // 6
+	9540, // 7
+	/*9337*/ uint16(xCondIs64), 9340, 9356,
+	/*9340*/ uint16(xCondDataSize), 9344, 9350, 0,
+	/*9344*/ uint16(xSetOp), uint16(ADD),
+	/*9346*/ uint16(xReadIw),
+	/*9347*/ uint16(xArgRM16),
+	/*9348*/ uint16(xArgImm16),
+	/*9349*/ uint16(xMatch),
+	/*9350*/ uint16(xSetOp), uint16(ADD),
+	/*9352*/ uint16(xReadId),
+	/*9353*/ uint16(xArgRM32),
+	/*9354*/ uint16(xArgImm32),
+	/*9355*/ uint16(xMatch),
+	/*9356*/ uint16(xCondDataSize), 9344, 9350, 9360,
+	/*9360*/ uint16(xSetOp), uint16(ADD),
 	/*9362*/ uint16(xReadId),
-	/*9363*/ uint16(xArgRM32),
+	/*9363*/ uint16(xArgRM64),
 	/*9364*/ uint16(xArgImm32),
 	/*9365*/ uint16(xMatch),
-	/*9366*/ uint16(xCondDataSize), 9354, 9360, 9370,
-	/*9370*/ uint16(xSetOp), uint16(OR),
-	/*9372*/ uint16(xReadId),
-	/*9373*/ uint16(xArgRM64),
-	/*9374*/ uint16(xArgImm32),
-	/*9375*/ uint16(xMatch),
-	/*9376*/ uint16(xCondIs64), 9379, 9395,
-	/*9379*/ uint16(xCondDataSize), 9383, 9389, 0,
-	/*9383*/ uint16(xSetOp), uint16(ADC),
-	/*9385*/ uint16(xReadIw),
-	/*9386*/ uint16(xArgRM16),
-	/*9387*/ uint16(xArgImm16),
-	/*9388*/ uint16(xMatch),
-	/*9389*/ uint16(xSetOp), uint16(ADC),
+	/*9366*/ uint16(xCondIs64), 9369, 9385,
+	/*9369*/ uint16(xCondDataSize), 9373, 9379, 0,
+	/*9373*/ uint16(xSetOp), uint16(OR),
+	/*9375*/ uint16(xReadIw),
+	/*9376*/ uint16(xArgRM16),
+	/*9377*/ uint16(xArgImm16),
+	/*9378*/ uint16(xMatch),
+	/*9379*/ uint16(xSetOp), uint16(OR),
+	/*9381*/ uint16(xReadId),
+	/*9382*/ uint16(xArgRM32),
+	/*9383*/ uint16(xArgImm32),
+	/*9384*/ uint16(xMatch),
+	/*9385*/ uint16(xCondDataSize), 9373, 9379, 9389,
+	/*9389*/ uint16(xSetOp), uint16(OR),
 	/*9391*/ uint16(xReadId),
-	/*9392*/ uint16(xArgRM32),
+	/*9392*/ uint16(xArgRM64),
 	/*9393*/ uint16(xArgImm32),
 	/*9394*/ uint16(xMatch),
-	/*9395*/ uint16(xCondDataSize), 9383, 9389, 9399,
-	/*9399*/ uint16(xSetOp), uint16(ADC),
-	/*9401*/ uint16(xReadId),
-	/*9402*/ uint16(xArgRM64),
-	/*9403*/ uint16(xArgImm32),
-	/*9404*/ uint16(xMatch),
-	/*9405*/ uint16(xCondIs64), 9408, 9424,
-	/*9408*/ uint16(xCondDataSize), 9412, 9418, 0,
-	/*9412*/ uint16(xSetOp), uint16(SBB),
-	/*9414*/ uint16(xReadIw),
-	/*9415*/ uint16(xArgRM16),
-	/*9416*/ uint16(xArgImm16),
-	/*9417*/ uint16(xMatch),
-	/*9418*/ uint16(xSetOp), uint16(SBB),
+	/*9395*/ uint16(xCondIs64), 9398, 9414,
+	/*9398*/ uint16(xCondDataSize), 9402, 9408, 0,
+	/*9402*/ uint16(xSetOp), uint16(ADC),
+	/*9404*/ uint16(xReadIw),
+	/*9405*/ uint16(xArgRM16),
+	/*9406*/ uint16(xArgImm16),
+	/*9407*/ uint16(xMatch),
+	/*9408*/ uint16(xSetOp), uint16(ADC),
+	/*9410*/ uint16(xReadId),
+	/*9411*/ uint16(xArgRM32),
+	/*9412*/ uint16(xArgImm32),
+	/*9413*/ uint16(xMatch),
+	/*9414*/ uint16(xCondDataSize), 9402, 9408, 9418,
+	/*9418*/ uint16(xSetOp), uint16(ADC),
 	/*9420*/ uint16(xReadId),
-	/*9421*/ uint16(xArgRM32),
+	/*9421*/ uint16(xArgRM64),
 	/*9422*/ uint16(xArgImm32),
 	/*9423*/ uint16(xMatch),
-	/*9424*/ uint16(xCondDataSize), 9412, 9418, 9428,
-	/*9428*/ uint16(xSetOp), uint16(SBB),
-	/*9430*/ uint16(xReadId),
-	/*9431*/ uint16(xArgRM64),
-	/*9432*/ uint16(xArgImm32),
-	/*9433*/ uint16(xMatch),
-	/*9434*/ uint16(xCondIs64), 9437, 9453,
-	/*9437*/ uint16(xCondDataSize), 9441, 9447, 0,
-	/*9441*/ uint16(xSetOp), uint16(AND),
-	/*9443*/ uint16(xReadIw),
-	/*9444*/ uint16(xArgRM16),
-	/*9445*/ uint16(xArgImm16),
-	/*9446*/ uint16(xMatch),
-	/*9447*/ uint16(xSetOp), uint16(AND),
+	/*9424*/ uint16(xCondIs64), 9427, 9443,
+	/*9427*/ uint16(xCondDataSize), 9431, 9437, 0,
+	/*9431*/ uint16(xSetOp), uint16(SBB),
+	/*9433*/ uint16(xReadIw),
+	/*9434*/ uint16(xArgRM16),
+	/*9435*/ uint16(xArgImm16),
+	/*9436*/ uint16(xMatch),
+	/*9437*/ uint16(xSetOp), uint16(SBB),
+	/*9439*/ uint16(xReadId),
+	/*9440*/ uint16(xArgRM32),
+	/*9441*/ uint16(xArgImm32),
+	/*9442*/ uint16(xMatch),
+	/*9443*/ uint16(xCondDataSize), 9431, 9437, 9447,
+	/*9447*/ uint16(xSetOp), uint16(SBB),
 	/*9449*/ uint16(xReadId),
-	/*9450*/ uint16(xArgRM32),
+	/*9450*/ uint16(xArgRM64),
 	/*9451*/ uint16(xArgImm32),
 	/*9452*/ uint16(xMatch),
-	/*9453*/ uint16(xCondDataSize), 9441, 9447, 9457,
-	/*9457*/ uint16(xSetOp), uint16(AND),
-	/*9459*/ uint16(xReadId),
-	/*9460*/ uint16(xArgRM64),
-	/*9461*/ uint16(xArgImm32),
-	/*9462*/ uint16(xMatch),
-	/*9463*/ uint16(xCondIs64), 9466, 9482,
-	/*9466*/ uint16(xCondDataSize), 9470, 9476, 0,
-	/*9470*/ uint16(xSetOp), uint16(SUB),
-	/*9472*/ uint16(xReadIw),
-	/*9473*/ uint16(xArgRM16),
-	/*9474*/ uint16(xArgImm16),
-	/*9475*/ uint16(xMatch),
-	/*9476*/ uint16(xSetOp), uint16(SUB),
+	/*9453*/ uint16(xCondIs64), 9456, 9472,
+	/*9456*/ uint16(xCondDataSize), 9460, 9466, 0,
+	/*9460*/ uint16(xSetOp), uint16(AND),
+	/*9462*/ uint16(xReadIw),
+	/*9463*/ uint16(xArgRM16),
+	/*9464*/ uint16(xArgImm16),
+	/*9465*/ uint16(xMatch),
+	/*9466*/ uint16(xSetOp), uint16(AND),
+	/*9468*/ uint16(xReadId),
+	/*9469*/ uint16(xArgRM32),
+	/*9470*/ uint16(xArgImm32),
+	/*9471*/ uint16(xMatch),
+	/*9472*/ uint16(xCondDataSize), 9460, 9466, 9476,
+	/*9476*/ uint16(xSetOp), uint16(AND),
 	/*9478*/ uint16(xReadId),
-	/*9479*/ uint16(xArgRM32),
+	/*9479*/ uint16(xArgRM64),
 	/*9480*/ uint16(xArgImm32),
 	/*9481*/ uint16(xMatch),
-	/*9482*/ uint16(xCondDataSize), 9470, 9476, 9486,
-	/*9486*/ uint16(xSetOp), uint16(SUB),
-	/*9488*/ uint16(xReadId),
-	/*9489*/ uint16(xArgRM64),
-	/*9490*/ uint16(xArgImm32),
-	/*9491*/ uint16(xMatch),
-	/*9492*/ uint16(xCondIs64), 9495, 9511,
-	/*9495*/ uint16(xCondDataSize), 9499, 9505, 0,
-	/*9499*/ uint16(xSetOp), uint16(XOR),
-	/*9501*/ uint16(xReadIw),
-	/*9502*/ uint16(xArgRM16),
-	/*9503*/ uint16(xArgImm16),
-	/*9504*/ uint16(xMatch),
-	/*9505*/ uint16(xSetOp), uint16(XOR),
+	/*9482*/ uint16(xCondIs64), 9485, 9501,
+	/*9485*/ uint16(xCondDataSize), 9489, 9495, 0,
+	/*9489*/ uint16(xSetOp), uint16(SUB),
+	/*9491*/ uint16(xReadIw),
+	/*9492*/ uint16(xArgRM16),
+	/*9493*/ uint16(xArgImm16),
+	/*9494*/ uint16(xMatch),
+	/*9495*/ uint16(xSetOp), uint16(SUB),
+	/*9497*/ uint16(xReadId),
+	/*9498*/ uint16(xArgRM32),
+	/*9499*/ uint16(xArgImm32),
+	/*9500*/ uint16(xMatch),
+	/*9501*/ uint16(xCondDataSize), 9489, 9495, 9505,
+	/*9505*/ uint16(xSetOp), uint16(SUB),
 	/*9507*/ uint16(xReadId),
-	/*9508*/ uint16(xArgRM32),
+	/*9508*/ uint16(xArgRM64),
 	/*9509*/ uint16(xArgImm32),
 	/*9510*/ uint16(xMatch),
-	/*9511*/ uint16(xCondDataSize), 9499, 9505, 9515,
-	/*9515*/ uint16(xSetOp), uint16(XOR),
-	/*9517*/ uint16(xReadId),
-	/*9518*/ uint16(xArgRM64),
-	/*9519*/ uint16(xArgImm32),
-	/*9520*/ uint16(xMatch),
-	/*9521*/ uint16(xCondIs64), 9524, 9540,
-	/*9524*/ uint16(xCondDataSize), 9528, 9534, 0,
-	/*9528*/ uint16(xSetOp), uint16(CMP),
-	/*9530*/ uint16(xReadIw),
-	/*9531*/ uint16(xArgRM16),
-	/*9532*/ uint16(xArgImm16),
-	/*9533*/ uint16(xMatch),
-	/*9534*/ uint16(xSetOp), uint16(CMP),
+	/*9511*/ uint16(xCondIs64), 9514, 9530,
+	/*9514*/ uint16(xCondDataSize), 9518, 9524, 0,
+	/*9518*/ uint16(xSetOp), uint16(XOR),
+	/*9520*/ uint16(xReadIw),
+	/*9521*/ uint16(xArgRM16),
+	/*9522*/ uint16(xArgImm16),
+	/*9523*/ uint16(xMatch),
+	/*9524*/ uint16(xSetOp), uint16(XOR),
+	/*9526*/ uint16(xReadId),
+	/*9527*/ uint16(xArgRM32),
+	/*9528*/ uint16(xArgImm32),
+	/*9529*/ uint16(xMatch),
+	/*9530*/ uint16(xCondDataSize), 9518, 9524, 9534,
+	/*9534*/ uint16(xSetOp), uint16(XOR),
 	/*9536*/ uint16(xReadId),
-	/*9537*/ uint16(xArgRM32),
+	/*9537*/ uint16(xArgRM64),
 	/*9538*/ uint16(xArgImm32),
 	/*9539*/ uint16(xMatch),
-	/*9540*/ uint16(xCondDataSize), 9528, 9534, 9544,
-	/*9544*/ uint16(xSetOp), uint16(CMP),
-	/*9546*/ uint16(xReadId),
-	/*9547*/ uint16(xArgRM64),
-	/*9548*/ uint16(xArgImm32),
-	/*9549*/ uint16(xMatch),
-	/*9550*/ uint16(xCondSlashR),
-	9559, // 0
-	9588, // 1
-	9617, // 2
-	9646, // 3
-	9675, // 4
-	9704, // 5
-	9733, // 6
-	9762, // 7
-	/*9559*/ uint16(xCondIs64), 9562, 9578,
-	/*9562*/ uint16(xCondDataSize), 9566, 9572, 0,
-	/*9566*/ uint16(xSetOp), uint16(ADD),
-	/*9568*/ uint16(xReadIb),
-	/*9569*/ uint16(xArgRM16),
-	/*9570*/ uint16(xArgImm8),
-	/*9571*/ uint16(xMatch),
-	/*9572*/ uint16(xSetOp), uint16(ADD),
-	/*9574*/ uint16(xReadIb),
-	/*9575*/ uint16(xArgRM32),
-	/*9576*/ uint16(xArgImm8),
-	/*9577*/ uint16(xMatch),
-	/*9578*/ uint16(xCondDataSize), 9566, 9572, 9582,
-	/*9582*/ uint16(xSetOp), uint16(ADD),
-	/*9584*/ uint16(xReadIb),
-	/*9585*/ uint16(xArgRM64),
-	/*9586*/ uint16(xArgImm8),
-	/*9587*/ uint16(xMatch),
-	/*9588*/ uint16(xCondIs64), 9591, 9607,
-	/*9591*/ uint16(xCondDataSize), 9595, 9601, 0,
-	/*9595*/ uint16(xSetOp), uint16(OR),
-	/*9597*/ uint16(xReadIb),
-	/*9598*/ uint16(xArgRM16),
-	/*9599*/ uint16(xArgImm8),
-	/*9600*/ uint16(xMatch),
-	/*9601*/ uint16(xSetOp), uint16(OR),
+	/*9540*/ uint16(xCondIs64), 9543, 9559,
+	/*9543*/ uint16(xCondDataSize), 9547, 9553, 0,
+	/*9547*/ uint16(xSetOp), uint16(CMP),
+	/*9549*/ uint16(xReadIw),
+	/*9550*/ uint16(xArgRM16),
+	/*9551*/ uint16(xArgImm16),
+	/*9552*/ uint16(xMatch),
+	/*9553*/ uint16(xSetOp), uint16(CMP),
+	/*9555*/ uint16(xReadId),
+	/*9556*/ uint16(xArgRM32),
+	/*9557*/ uint16(xArgImm32),
+	/*9558*/ uint16(xMatch),
+	/*9559*/ uint16(xCondDataSize), 9547, 9553, 9563,
+	/*9563*/ uint16(xSetOp), uint16(CMP),
+	/*9565*/ uint16(xReadId),
+	/*9566*/ uint16(xArgRM64),
+	/*9567*/ uint16(xArgImm32),
+	/*9568*/ uint16(xMatch),
+	/*9569*/ uint16(xCondSlashR),
+	9578, // 0
+	9607, // 1
+	9636, // 2
+	9665, // 3
+	9694, // 4
+	9723, // 5
+	9752, // 6
+	9781, // 7
+	/*9578*/ uint16(xCondIs64), 9581, 9597,
+	/*9581*/ uint16(xCondDataSize), 9585, 9591, 0,
+	/*9585*/ uint16(xSetOp), uint16(ADD),
+	/*9587*/ uint16(xReadIb),
+	/*9588*/ uint16(xArgRM16),
+	/*9589*/ uint16(xArgImm8),
+	/*9590*/ uint16(xMatch),
+	/*9591*/ uint16(xSetOp), uint16(ADD),
+	/*9593*/ uint16(xReadIb),
+	/*9594*/ uint16(xArgRM32),
+	/*9595*/ uint16(xArgImm8),
+	/*9596*/ uint16(xMatch),
+	/*9597*/ uint16(xCondDataSize), 9585, 9591, 9601,
+	/*9601*/ uint16(xSetOp), uint16(ADD),
 	/*9603*/ uint16(xReadIb),
-	/*9604*/ uint16(xArgRM32),
+	/*9604*/ uint16(xArgRM64),
 	/*9605*/ uint16(xArgImm8),
 	/*9606*/ uint16(xMatch),
-	/*9607*/ uint16(xCondDataSize), 9595, 9601, 9611,
-	/*9611*/ uint16(xSetOp), uint16(OR),
-	/*9613*/ uint16(xReadIb),
-	/*9614*/ uint16(xArgRM64),
-	/*9615*/ uint16(xArgImm8),
-	/*9616*/ uint16(xMatch),
-	/*9617*/ uint16(xCondIs64), 9620, 9636,
-	/*9620*/ uint16(xCondDataSize), 9624, 9630, 0,
-	/*9624*/ uint16(xSetOp), uint16(ADC),
-	/*9626*/ uint16(xReadIb),
-	/*9627*/ uint16(xArgRM16),
-	/*9628*/ uint16(xArgImm8),
-	/*9629*/ uint16(xMatch),
-	/*9630*/ uint16(xSetOp), uint16(ADC),
+	/*9607*/ uint16(xCondIs64), 9610, 9626,
+	/*9610*/ uint16(xCondDataSize), 9614, 9620, 0,
+	/*9614*/ uint16(xSetOp), uint16(OR),
+	/*9616*/ uint16(xReadIb),
+	/*9617*/ uint16(xArgRM16),
+	/*9618*/ uint16(xArgImm8),
+	/*9619*/ uint16(xMatch),
+	/*9620*/ uint16(xSetOp), uint16(OR),
+	/*9622*/ uint16(xReadIb),
+	/*9623*/ uint16(xArgRM32),
+	/*9624*/ uint16(xArgImm8),
+	/*9625*/ uint16(xMatch),
+	/*9626*/ uint16(xCondDataSize), 9614, 9620, 9630,
+	/*9630*/ uint16(xSetOp), uint16(OR),
 	/*9632*/ uint16(xReadIb),
-	/*9633*/ uint16(xArgRM32),
+	/*9633*/ uint16(xArgRM64),
 	/*9634*/ uint16(xArgImm8),
 	/*9635*/ uint16(xMatch),
-	/*9636*/ uint16(xCondDataSize), 9624, 9630, 9640,
-	/*9640*/ uint16(xSetOp), uint16(ADC),
-	/*9642*/ uint16(xReadIb),
-	/*9643*/ uint16(xArgRM64),
-	/*9644*/ uint16(xArgImm8),
-	/*9645*/ uint16(xMatch),
-	/*9646*/ uint16(xCondIs64), 9649, 9665,
-	/*9649*/ uint16(xCondDataSize), 9653, 9659, 0,
-	/*9653*/ uint16(xSetOp), uint16(SBB),
-	/*9655*/ uint16(xReadIb),
-	/*9656*/ uint16(xArgRM16),
-	/*9657*/ uint16(xArgImm8),
-	/*9658*/ uint16(xMatch),
-	/*9659*/ uint16(xSetOp), uint16(SBB),
+	/*9636*/ uint16(xCondIs64), 9639, 9655,
+	/*9639*/ uint16(xCondDataSize), 9643, 9649, 0,
+	/*9643*/ uint16(xSetOp), uint16(ADC),
+	/*9645*/ uint16(xReadIb),
+	/*9646*/ uint16(xArgRM16),
+	/*9647*/ uint16(xArgImm8),
+	/*9648*/ uint16(xMatch),
+	/*9649*/ uint16(xSetOp), uint16(ADC),
+	/*9651*/ uint16(xReadIb),
+	/*9652*/ uint16(xArgRM32),
+	/*9653*/ uint16(xArgImm8),
+	/*9654*/ uint16(xMatch),
+	/*9655*/ uint16(xCondDataSize), 9643, 9649, 9659,
+	/*9659*/ uint16(xSetOp), uint16(ADC),
 	/*9661*/ uint16(xReadIb),
-	/*9662*/ uint16(xArgRM32),
+	/*9662*/ uint16(xArgRM64),
 	/*9663*/ uint16(xArgImm8),
 	/*9664*/ uint16(xMatch),
-	/*9665*/ uint16(xCondDataSize), 9653, 9659, 9669,
-	/*9669*/ uint16(xSetOp), uint16(SBB),
-	/*9671*/ uint16(xReadIb),
-	/*9672*/ uint16(xArgRM64),
-	/*9673*/ uint16(xArgImm8),
-	/*9674*/ uint16(xMatch),
-	/*9675*/ uint16(xCondIs64), 9678, 9694,
-	/*9678*/ uint16(xCondDataSize), 9682, 9688, 0,
-	/*9682*/ uint16(xSetOp), uint16(AND),
-	/*9684*/ uint16(xReadIb),
-	/*9685*/ uint16(xArgRM16),
-	/*9686*/ uint16(xArgImm8),
-	/*9687*/ uint16(xMatch),
-	/*9688*/ uint16(xSetOp), uint16(AND),
+	/*9665*/ uint16(xCondIs64), 9668, 9684,
+	/*9668*/ uint16(xCondDataSize), 9672, 9678, 0,
+	/*9672*/ uint16(xSetOp), uint16(SBB),
+	/*9674*/ uint16(xReadIb),
+	/*9675*/ uint16(xArgRM16),
+	/*9676*/ uint16(xArgImm8),
+	/*9677*/ uint16(xMatch),
+	/*9678*/ uint16(xSetOp), uint16(SBB),
+	/*9680*/ uint16(xReadIb),
+	/*9681*/ uint16(xArgRM32),
+	/*9682*/ uint16(xArgImm8),
+	/*9683*/ uint16(xMatch),
+	/*9684*/ uint16(xCondDataSize), 9672, 9678, 9688,
+	/*9688*/ uint16(xSetOp), uint16(SBB),
 	/*9690*/ uint16(xReadIb),
-	/*9691*/ uint16(xArgRM32),
+	/*9691*/ uint16(xArgRM64),
 	/*9692*/ uint16(xArgImm8),
 	/*9693*/ uint16(xMatch),
-	/*9694*/ uint16(xCondDataSize), 9682, 9688, 9698,
-	/*9698*/ uint16(xSetOp), uint16(AND),
-	/*9700*/ uint16(xReadIb),
-	/*9701*/ uint16(xArgRM64),
-	/*9702*/ uint16(xArgImm8),
-	/*9703*/ uint16(xMatch),
-	/*9704*/ uint16(xCondIs64), 9707, 9723,
-	/*9707*/ uint16(xCondDataSize), 9711, 9717, 0,
-	/*9711*/ uint16(xSetOp), uint16(SUB),
-	/*9713*/ uint16(xReadIb),
-	/*9714*/ uint16(xArgRM16),
-	/*9715*/ uint16(xArgImm8),
-	/*9716*/ uint16(xMatch),
-	/*9717*/ uint16(xSetOp), uint16(SUB),
+	/*9694*/ uint16(xCondIs64), 9697, 9713,
+	/*9697*/ uint16(xCondDataSize), 9701, 9707, 0,
+	/*9701*/ uint16(xSetOp), uint16(AND),
+	/*9703*/ uint16(xReadIb),
+	/*9704*/ uint16(xArgRM16),
+	/*9705*/ uint16(xArgImm8),
+	/*9706*/ uint16(xMatch),
+	/*9707*/ uint16(xSetOp), uint16(AND),
+	/*9709*/ uint16(xReadIb),
+	/*9710*/ uint16(xArgRM32),
+	/*9711*/ uint16(xArgImm8),
+	/*9712*/ uint16(xMatch),
+	/*9713*/ uint16(xCondDataSize), 9701, 9707, 9717,
+	/*9717*/ uint16(xSetOp), uint16(AND),
 	/*9719*/ uint16(xReadIb),
-	/*9720*/ uint16(xArgRM32),
+	/*9720*/ uint16(xArgRM64),
 	/*9721*/ uint16(xArgImm8),
 	/*9722*/ uint16(xMatch),
-	/*9723*/ uint16(xCondDataSize), 9711, 9717, 9727,
-	/*9727*/ uint16(xSetOp), uint16(SUB),
-	/*9729*/ uint16(xReadIb),
-	/*9730*/ uint16(xArgRM64),
-	/*9731*/ uint16(xArgImm8),
-	/*9732*/ uint16(xMatch),
-	/*9733*/ uint16(xCondIs64), 9736, 9752,
-	/*9736*/ uint16(xCondDataSize), 9740, 9746, 0,
-	/*9740*/ uint16(xSetOp), uint16(XOR),
-	/*9742*/ uint16(xReadIb),
-	/*9743*/ uint16(xArgRM16),
-	/*9744*/ uint16(xArgImm8),
-	/*9745*/ uint16(xMatch),
-	/*9746*/ uint16(xSetOp), uint16(XOR),
+	/*9723*/ uint16(xCondIs64), 9726, 9742,
+	/*9726*/ uint16(xCondDataSize), 9730, 9736, 0,
+	/*9730*/ uint16(xSetOp), uint16(SUB),
+	/*9732*/ uint16(xReadIb),
+	/*9733*/ uint16(xArgRM16),
+	/*9734*/ uint16(xArgImm8),
+	/*9735*/ uint16(xMatch),
+	/*9736*/ uint16(xSetOp), uint16(SUB),
+	/*9738*/ uint16(xReadIb),
+	/*9739*/ uint16(xArgRM32),
+	/*9740*/ uint16(xArgImm8),
+	/*9741*/ uint16(xMatch),
+	/*9742*/ uint16(xCondDataSize), 9730, 9736, 9746,
+	/*9746*/ uint16(xSetOp), uint16(SUB),
 	/*9748*/ uint16(xReadIb),
-	/*9749*/ uint16(xArgRM32),
+	/*9749*/ uint16(xArgRM64),
 	/*9750*/ uint16(xArgImm8),
 	/*9751*/ uint16(xMatch),
-	/*9752*/ uint16(xCondDataSize), 9740, 9746, 9756,
-	/*9756*/ uint16(xSetOp), uint16(XOR),
-	/*9758*/ uint16(xReadIb),
-	/*9759*/ uint16(xArgRM64),
-	/*9760*/ uint16(xArgImm8),
-	/*9761*/ uint16(xMatch),
-	/*9762*/ uint16(xCondIs64), 9765, 9781,
-	/*9765*/ uint16(xCondDataSize), 9769, 9775, 0,
-	/*9769*/ uint16(xSetOp), uint16(CMP),
-	/*9771*/ uint16(xReadIb),
-	/*9772*/ uint16(xArgRM16),
-	/*9773*/ uint16(xArgImm8),
-	/*9774*/ uint16(xMatch),
-	/*9775*/ uint16(xSetOp), uint16(CMP),
+	/*9752*/ uint16(xCondIs64), 9755, 9771,
+	/*9755*/ uint16(xCondDataSize), 9759, 9765, 0,
+	/*9759*/ uint16(xSetOp), uint16(XOR),
+	/*9761*/ uint16(xReadIb),
+	/*9762*/ uint16(xArgRM16),
+	/*9763*/ uint16(xArgImm8),
+	/*9764*/ uint16(xMatch),
+	/*9765*/ uint16(xSetOp), uint16(XOR),
+	/*9767*/ uint16(xReadIb),
+	/*9768*/ uint16(xArgRM32),
+	/*9769*/ uint16(xArgImm8),
+	/*9770*/ uint16(xMatch),
+	/*9771*/ uint16(xCondDataSize), 9759, 9765, 9775,
+	/*9775*/ uint16(xSetOp), uint16(XOR),
 	/*9777*/ uint16(xReadIb),
-	/*9778*/ uint16(xArgRM32),
+	/*9778*/ uint16(xArgRM64),
 	/*9779*/ uint16(xArgImm8),
 	/*9780*/ uint16(xMatch),
-	/*9781*/ uint16(xCondDataSize), 9769, 9775, 9785,
-	/*9785*/ uint16(xSetOp), uint16(CMP),
-	/*9787*/ uint16(xReadIb),
-	/*9788*/ uint16(xArgRM64),
-	/*9789*/ uint16(xArgImm8),
-	/*9790*/ uint16(xMatch),
-	/*9791*/ uint16(xSetOp), uint16(TEST),
-	/*9793*/ uint16(xReadSlashR),
-	/*9794*/ uint16(xArgRM8),
-	/*9795*/ uint16(xArgR8),
-	/*9796*/ uint16(xMatch),
-	/*9797*/ uint16(xCondIs64), 9800, 9816,
-	/*9800*/ uint16(xCondDataSize), 9804, 9810, 0,
-	/*9804*/ uint16(xSetOp), uint16(TEST),
-	/*9806*/ uint16(xReadSlashR),
-	/*9807*/ uint16(xArgRM16),
-	/*9808*/ uint16(xArgR16),
+	/*9781*/ uint16(xCondIs64), 9784, 9800,
+	/*9784*/ uint16(xCondDataSize), 9788, 9794, 0,
+	/*9788*/ uint16(xSetOp), uint16(CMP),
+	/*9790*/ uint16(xReadIb),
+	/*9791*/ uint16(xArgRM16),
+	/*9792*/ uint16(xArgImm8),
+	/*9793*/ uint16(xMatch),
+	/*9794*/ uint16(xSetOp), uint16(CMP),
+	/*9796*/ uint16(xReadIb),
+	/*9797*/ uint16(xArgRM32),
+	/*9798*/ uint16(xArgImm8),
+	/*9799*/ uint16(xMatch),
+	/*9800*/ uint16(xCondDataSize), 9788, 9794, 9804,
+	/*9804*/ uint16(xSetOp), uint16(CMP),
+	/*9806*/ uint16(xReadIb),
+	/*9807*/ uint16(xArgRM64),
+	/*9808*/ uint16(xArgImm8),
 	/*9809*/ uint16(xMatch),
 	/*9810*/ uint16(xSetOp), uint16(TEST),
 	/*9812*/ uint16(xReadSlashR),
-	/*9813*/ uint16(xArgRM32),
-	/*9814*/ uint16(xArgR32),
+	/*9813*/ uint16(xArgRM8),
+	/*9814*/ uint16(xArgR8),
 	/*9815*/ uint16(xMatch),
-	/*9816*/ uint16(xCondDataSize), 9804, 9810, 9820,
-	/*9820*/ uint16(xSetOp), uint16(TEST),
-	/*9822*/ uint16(xReadSlashR),
-	/*9823*/ uint16(xArgRM64),
-	/*9824*/ uint16(xArgR64),
-	/*9825*/ uint16(xMatch),
-	/*9826*/ uint16(xSetOp), uint16(XCHG),
-	/*9828*/ uint16(xReadSlashR),
-	/*9829*/ uint16(xArgRM8),
-	/*9830*/ uint16(xArgR8),
-	/*9831*/ uint16(xMatch),
-	/*9832*/ uint16(xCondIs64), 9835, 9851,
-	/*9835*/ uint16(xCondDataSize), 9839, 9845, 0,
-	/*9839*/ uint16(xSetOp), uint16(XCHG),
+	/*9816*/ uint16(xCondIs64), 9819, 9835,
+	/*9819*/ uint16(xCondDataSize), 9823, 9829, 0,
+	/*9823*/ uint16(xSetOp), uint16(TEST),
+	/*9825*/ uint16(xReadSlashR),
+	/*9826*/ uint16(xArgRM16),
+	/*9827*/ uint16(xArgR16),
+	/*9828*/ uint16(xMatch),
+	/*9829*/ uint16(xSetOp), uint16(TEST),
+	/*9831*/ uint16(xReadSlashR),
+	/*9832*/ uint16(xArgRM32),
+	/*9833*/ uint16(xArgR32),
+	/*9834*/ uint16(xMatch),
+	/*9835*/ uint16(xCondDataSize), 9823, 9829, 9839,
+	/*9839*/ uint16(xSetOp), uint16(TEST),
 	/*9841*/ uint16(xReadSlashR),
-	/*9842*/ uint16(xArgRM16),
-	/*9843*/ uint16(xArgR16),
+	/*9842*/ uint16(xArgRM64),
+	/*9843*/ uint16(xArgR64),
 	/*9844*/ uint16(xMatch),
 	/*9845*/ uint16(xSetOp), uint16(XCHG),
 	/*9847*/ uint16(xReadSlashR),
-	/*9848*/ uint16(xArgRM32),
-	/*9849*/ uint16(xArgR32),
+	/*9848*/ uint16(xArgRM8),
+	/*9849*/ uint16(xArgR8),
 	/*9850*/ uint16(xMatch),
-	/*9851*/ uint16(xCondDataSize), 9839, 9845, 9855,
-	/*9855*/ uint16(xSetOp), uint16(XCHG),
-	/*9857*/ uint16(xReadSlashR),
-	/*9858*/ uint16(xArgRM64),
-	/*9859*/ uint16(xArgR64),
-	/*9860*/ uint16(xMatch),
-	/*9861*/ uint16(xSetOp), uint16(MOV),
-	/*9863*/ uint16(xReadSlashR),
-	/*9864*/ uint16(xArgRM8),
-	/*9865*/ uint16(xArgR8),
-	/*9866*/ uint16(xMatch),
-	/*9867*/ uint16(xCondDataSize), 9871, 9877, 9883,
-	/*9871*/ uint16(xSetOp), uint16(MOV),
-	/*9873*/ uint16(xReadSlashR),
-	/*9874*/ uint16(xArgRM16),
-	/*9875*/ uint16(xArgR16),
-	/*9876*/ uint16(xMatch),
-	/*9877*/ uint16(xSetOp), uint16(MOV),
-	/*9879*/ uint16(xReadSlashR),
-	/*9880*/ uint16(xArgRM32),
-	/*9881*/ uint16(xArgR32),
-	/*9882*/ uint16(xMatch),
-	/*9883*/ uint16(xSetOp), uint16(MOV),
-	/*9885*/ uint16(xReadSlashR),
-	/*9886*/ uint16(xArgRM64),
-	/*9887*/ uint16(xArgR64),
-	/*9888*/ uint16(xMatch),
-	/*9889*/ uint16(xSetOp), uint16(MOV),
-	/*9891*/ uint16(xReadSlashR),
-	/*9892*/ uint16(xArgR8),
-	/*9893*/ uint16(xArgRM8),
-	/*9894*/ uint16(xMatch),
-	/*9895*/ uint16(xCondDataSize), 9899, 9905, 9911,
-	/*9899*/ uint16(xSetOp), uint16(MOV),
-	/*9901*/ uint16(xReadSlashR),
-	/*9902*/ uint16(xArgR16),
-	/*9903*/ uint16(xArgRM16),
-	/*9904*/ uint16(xMatch),
-	/*9905*/ uint16(xSetOp), uint16(MOV),
-	/*9907*/ uint16(xReadSlashR),
-	/*9908*/ uint16(xArgR32),
-	/*9909*/ uint16(xArgRM32),
-	/*9910*/ uint16(xMatch),
-	/*9911*/ uint16(xSetOp), uint16(MOV),
-	/*9913*/ uint16(xReadSlashR),
-	/*9914*/ uint16(xArgR64),
-	/*9915*/ uint16(xArgRM64),
-	/*9916*/ uint16(xMatch),
-	/*9917*/ uint16(xCondIs64), 9920, 9936,
-	/*9920*/ uint16(xCondDataSize), 9924, 9930, 0,
+	/*9851*/ uint16(xCondIs64), 9854, 9870,
+	/*9854*/ uint16(xCondDataSize), 9858, 9864, 0,
+	/*9858*/ uint16(xSetOp), uint16(XCHG),
+	/*9860*/ uint16(xReadSlashR),
+	/*9861*/ uint16(xArgRM16),
+	/*9862*/ uint16(xArgR16),
+	/*9863*/ uint16(xMatch),
+	/*9864*/ uint16(xSetOp), uint16(XCHG),
+	/*9866*/ uint16(xReadSlashR),
+	/*9867*/ uint16(xArgRM32),
+	/*9868*/ uint16(xArgR32),
+	/*9869*/ uint16(xMatch),
+	/*9870*/ uint16(xCondDataSize), 9858, 9864, 9874,
+	/*9874*/ uint16(xSetOp), uint16(XCHG),
+	/*9876*/ uint16(xReadSlashR),
+	/*9877*/ uint16(xArgRM64),
+	/*9878*/ uint16(xArgR64),
+	/*9879*/ uint16(xMatch),
+	/*9880*/ uint16(xSetOp), uint16(MOV),
+	/*9882*/ uint16(xReadSlashR),
+	/*9883*/ uint16(xArgRM8),
+	/*9884*/ uint16(xArgR8),
+	/*9885*/ uint16(xMatch),
+	/*9886*/ uint16(xCondDataSize), 9890, 9896, 9902,
+	/*9890*/ uint16(xSetOp), uint16(MOV),
+	/*9892*/ uint16(xReadSlashR),
+	/*9893*/ uint16(xArgRM16),
+	/*9894*/ uint16(xArgR16),
+	/*9895*/ uint16(xMatch),
+	/*9896*/ uint16(xSetOp), uint16(MOV),
+	/*9898*/ uint16(xReadSlashR),
+	/*9899*/ uint16(xArgRM32),
+	/*9900*/ uint16(xArgR32),
+	/*9901*/ uint16(xMatch),
+	/*9902*/ uint16(xSetOp), uint16(MOV),
+	/*9904*/ uint16(xReadSlashR),
+	/*9905*/ uint16(xArgRM64),
+	/*9906*/ uint16(xArgR64),
+	/*9907*/ uint16(xMatch),
+	/*9908*/ uint16(xSetOp), uint16(MOV),
+	/*9910*/ uint16(xReadSlashR),
+	/*9911*/ uint16(xArgR8),
+	/*9912*/ uint16(xArgRM8),
+	/*9913*/ uint16(xMatch),
+	/*9914*/ uint16(xCondDataSize), 9918, 9924, 9930,
+	/*9918*/ uint16(xSetOp), uint16(MOV),
+	/*9920*/ uint16(xReadSlashR),
+	/*9921*/ uint16(xArgR16),
+	/*9922*/ uint16(xArgRM16),
+	/*9923*/ uint16(xMatch),
 	/*9924*/ uint16(xSetOp), uint16(MOV),
 	/*9926*/ uint16(xReadSlashR),
-	/*9927*/ uint16(xArgRM16),
-	/*9928*/ uint16(xArgSreg),
+	/*9927*/ uint16(xArgR32),
+	/*9928*/ uint16(xArgRM32),
 	/*9929*/ uint16(xMatch),
 	/*9930*/ uint16(xSetOp), uint16(MOV),
 	/*9932*/ uint16(xReadSlashR),
-	/*9933*/ uint16(xArgR32M16),
-	/*9934*/ uint16(xArgSreg),
+	/*9933*/ uint16(xArgR64),
+	/*9934*/ uint16(xArgRM64),
 	/*9935*/ uint16(xMatch),
-	/*9936*/ uint16(xCondDataSize), 9924, 9930, 9940,
-	/*9940*/ uint16(xSetOp), uint16(MOV),
-	/*9942*/ uint16(xReadSlashR),
-	/*9943*/ uint16(xArgR64M16),
-	/*9944*/ uint16(xArgSreg),
-	/*9945*/ uint16(xMatch),
-	/*9946*/ uint16(xCondIs64), 9949, 9965,
-	/*9949*/ uint16(xCondDataSize), 9953, 9959, 0,
-	/*9953*/ uint16(xSetOp), uint16(LEA),
-	/*9955*/ uint16(xReadSlashR),
-	/*9956*/ uint16(xArgR16),
-	/*9957*/ uint16(xArgM),
-	/*9958*/ uint16(xMatch),
-	/*9959*/ uint16(xSetOp), uint16(LEA),
+	/*9936*/ uint16(xCondIs64), 9939, 9955,
+	/*9939*/ uint16(xCondDataSize), 9943, 9949, 0,
+	/*9943*/ uint16(xSetOp), uint16(MOV),
+	/*9945*/ uint16(xReadSlashR),
+	/*9946*/ uint16(xArgRM16),
+	/*9947*/ uint16(xArgSreg),
+	/*9948*/ uint16(xMatch),
+	/*9949*/ uint16(xSetOp), uint16(MOV),
+	/*9951*/ uint16(xReadSlashR),
+	/*9952*/ uint16(xArgR32M16),
+	/*9953*/ uint16(xArgSreg),
+	/*9954*/ uint16(xMatch),
+	/*9955*/ uint16(xCondDataSize), 9943, 9949, 9959,
+	/*9959*/ uint16(xSetOp), uint16(MOV),
 	/*9961*/ uint16(xReadSlashR),
-	/*9962*/ uint16(xArgR32),
-	/*9963*/ uint16(xArgM),
+	/*9962*/ uint16(xArgR64M16),
+	/*9963*/ uint16(xArgSreg),
 	/*9964*/ uint16(xMatch),
-	/*9965*/ uint16(xCondDataSize), 9953, 9959, 9969,
-	/*9969*/ uint16(xSetOp), uint16(LEA),
-	/*9971*/ uint16(xReadSlashR),
-	/*9972*/ uint16(xArgR64),
-	/*9973*/ uint16(xArgM),
-	/*9974*/ uint16(xMatch),
-	/*9975*/ uint16(xCondIs64), 9978, 9994,
-	/*9978*/ uint16(xCondDataSize), 9982, 9988, 0,
-	/*9982*/ uint16(xSetOp), uint16(MOV),
-	/*9984*/ uint16(xReadSlashR),
-	/*9985*/ uint16(xArgSreg),
-	/*9986*/ uint16(xArgRM16),
-	/*9987*/ uint16(xMatch),
-	/*9988*/ uint16(xSetOp), uint16(MOV),
+	/*9965*/ uint16(xCondIs64), 9968, 9984,
+	/*9968*/ uint16(xCondDataSize), 9972, 9978, 0,
+	/*9972*/ uint16(xSetOp), uint16(LEA),
+	/*9974*/ uint16(xReadSlashR),
+	/*9975*/ uint16(xArgR16),
+	/*9976*/ uint16(xArgM),
+	/*9977*/ uint16(xMatch),
+	/*9978*/ uint16(xSetOp), uint16(LEA),
+	/*9980*/ uint16(xReadSlashR),
+	/*9981*/ uint16(xArgR32),
+	/*9982*/ uint16(xArgM),
+	/*9983*/ uint16(xMatch),
+	/*9984*/ uint16(xCondDataSize), 9972, 9978, 9988,
+	/*9988*/ uint16(xSetOp), uint16(LEA),
 	/*9990*/ uint16(xReadSlashR),
-	/*9991*/ uint16(xArgSreg),
-	/*9992*/ uint16(xArgR32M16),
+	/*9991*/ uint16(xArgR64),
+	/*9992*/ uint16(xArgM),
 	/*9993*/ uint16(xMatch),
-	/*9994*/ uint16(xCondDataSize), 9982, 9988, 9998,
-	/*9998*/ uint16(xSetOp), uint16(MOV),
-	/*10000*/ uint16(xReadSlashR),
-	/*10001*/ uint16(xArgSreg),
-	/*10002*/ uint16(xArgR64M16),
-	/*10003*/ uint16(xMatch),
-	/*10004*/ uint16(xCondSlashR),
-	10013, // 0
+	/*9994*/ uint16(xCondIs64), 9997, 10013,
+	/*9997*/ uint16(xCondDataSize), 10001, 10007, 0,
+	/*10001*/ uint16(xSetOp), uint16(MOV),
+	/*10003*/ uint16(xReadSlashR),
+	/*10004*/ uint16(xArgSreg),
+	/*10005*/ uint16(xArgRM16),
+	/*10006*/ uint16(xMatch),
+	/*10007*/ uint16(xSetOp), uint16(MOV),
+	/*10009*/ uint16(xReadSlashR),
+	/*10010*/ uint16(xArgSreg),
+	/*10011*/ uint16(xArgR32M16),
+	/*10012*/ uint16(xMatch),
+	/*10013*/ uint16(xCondDataSize), 10001, 10007, 10017,
+	/*10017*/ uint16(xSetOp), uint16(MOV),
+	/*10019*/ uint16(xReadSlashR),
+	/*10020*/ uint16(xArgSreg),
+	/*10021*/ uint16(xArgR64M16),
+	/*10022*/ uint16(xMatch),
+	/*10023*/ uint16(xCondSlashR),
+	10032, // 0
 	0,     // 1
 	0,     // 2
 	0,     // 3
@@ -6540,458 +6551,458 @@ var decoder = [...]uint16{
 	0,     // 5
 	0,     // 6
 	0,     // 7
-	/*10013*/ uint16(xCondIs64), 10016, 10028,
-	/*10016*/ uint16(xCondDataSize), 10020, 10024, 0,
-	/*10020*/ uint16(xSetOp), uint16(POP),
-	/*10022*/ uint16(xArgRM16),
-	/*10023*/ uint16(xMatch),
-	/*10024*/ uint16(xSetOp), uint16(POP),
-	/*10026*/ uint16(xArgRM32),
-	/*10027*/ uint16(xMatch),
-	/*10028*/ uint16(xCondDataSize), 10020, 10032, 10036,
-	/*10032*/ uint16(xSetOp), uint16(POP),
-	/*10034*/ uint16(xArgRM64),
-	/*10035*/ uint16(xMatch),
-	/*10036*/ uint16(xSetOp), uint16(POP),
-	/*10038*/ uint16(xArgRM64),
-	/*10039*/ uint16(xMatch),
-	/*10040*/ uint16(xCondIs64), 10043, 10057,
-	/*10043*/ uint16(xCondDataSize), 10047, 10052, 0,
-	/*10047*/ uint16(xSetOp), uint16(XCHG),
-	/*10049*/ uint16(xArgR16op),
-	/*10050*/ uint16(xArgAX),
-	/*10051*/ uint16(xMatch),
-	/*10052*/ uint16(xSetOp), uint16(XCHG),
-	/*10054*/ uint16(xArgR32op),
-	/*10055*/ uint16(xArgEAX),
-	/*10056*/ uint16(xMatch),
-	/*10057*/ uint16(xCondDataSize), 10047, 10052, 10061,
-	/*10061*/ uint16(xSetOp), uint16(XCHG),
-	/*10063*/ uint16(xArgR64op),
-	/*10064*/ uint16(xArgRAX),
-	/*10065*/ uint16(xMatch),
-	/*10066*/ uint16(xCondIs64), 10069, 10079,
-	/*10069*/ uint16(xCondDataSize), 10073, 10076, 0,
-	/*10073*/ uint16(xSetOp), uint16(CBW),
+	/*10032*/ uint16(xCondIs64), 10035, 10047,
+	/*10035*/ uint16(xCondDataSize), 10039, 10043, 0,
+	/*10039*/ uint16(xSetOp), uint16(POP),
+	/*10041*/ uint16(xArgRM16),
+	/*10042*/ uint16(xMatch),
+	/*10043*/ uint16(xSetOp), uint16(POP),
+	/*10045*/ uint16(xArgRM32),
+	/*10046*/ uint16(xMatch),
+	/*10047*/ uint16(xCondDataSize), 10039, 10051, 10055,
+	/*10051*/ uint16(xSetOp), uint16(POP),
+	/*10053*/ uint16(xArgRM64),
+	/*10054*/ uint16(xMatch),
+	/*10055*/ uint16(xSetOp), uint16(POP),
+	/*10057*/ uint16(xArgRM64),
+	/*10058*/ uint16(xMatch),
+	/*10059*/ uint16(xCondIs64), 10062, 10076,
+	/*10062*/ uint16(xCondDataSize), 10066, 10071, 0,
+	/*10066*/ uint16(xSetOp), uint16(XCHG),
+	/*10068*/ uint16(xArgR16op),
+	/*10069*/ uint16(xArgAX),
+	/*10070*/ uint16(xMatch),
+	/*10071*/ uint16(xSetOp), uint16(XCHG),
+	/*10073*/ uint16(xArgR32op),
+	/*10074*/ uint16(xArgEAX),
 	/*10075*/ uint16(xMatch),
-	/*10076*/ uint16(xSetOp), uint16(CWDE),
-	/*10078*/ uint16(xMatch),
-	/*10079*/ uint16(xCondDataSize), 10073, 10076, 10083,
-	/*10083*/ uint16(xSetOp), uint16(CDQE),
-	/*10085*/ uint16(xMatch),
-	/*10086*/ uint16(xCondIs64), 10089, 10099,
-	/*10089*/ uint16(xCondDataSize), 10093, 10096, 0,
-	/*10093*/ uint16(xSetOp), uint16(CWD),
-	/*10095*/ uint16(xMatch),
-	/*10096*/ uint16(xSetOp), uint16(CDQ),
-	/*10098*/ uint16(xMatch),
-	/*10099*/ uint16(xCondDataSize), 10093, 10096, 10103,
-	/*10103*/ uint16(xSetOp), uint16(CQO),
-	/*10105*/ uint16(xMatch),
-	/*10106*/ uint16(xCondIs64), 10109, 0,
-	/*10109*/ uint16(xCondDataSize), 10113, 10118, 0,
-	/*10113*/ uint16(xSetOp), uint16(LCALL),
-	/*10115*/ uint16(xReadCd),
-	/*10116*/ uint16(xArgPtr16colon16),
+	/*10076*/ uint16(xCondDataSize), 10066, 10071, 10080,
+	/*10080*/ uint16(xSetOp), uint16(XCHG),
+	/*10082*/ uint16(xArgR64op),
+	/*10083*/ uint16(xArgRAX),
+	/*10084*/ uint16(xMatch),
+	/*10085*/ uint16(xCondIs64), 10088, 10098,
+	/*10088*/ uint16(xCondDataSize), 10092, 10095, 0,
+	/*10092*/ uint16(xSetOp), uint16(CBW),
+	/*10094*/ uint16(xMatch),
+	/*10095*/ uint16(xSetOp), uint16(CWDE),
+	/*10097*/ uint16(xMatch),
+	/*10098*/ uint16(xCondDataSize), 10092, 10095, 10102,
+	/*10102*/ uint16(xSetOp), uint16(CDQE),
+	/*10104*/ uint16(xMatch),
+	/*10105*/ uint16(xCondIs64), 10108, 10118,
+	/*10108*/ uint16(xCondDataSize), 10112, 10115, 0,
+	/*10112*/ uint16(xSetOp), uint16(CWD),
+	/*10114*/ uint16(xMatch),
+	/*10115*/ uint16(xSetOp), uint16(CDQ),
 	/*10117*/ uint16(xMatch),
-	/*10118*/ uint16(xSetOp), uint16(LCALL),
-	/*10120*/ uint16(xReadCp),
-	/*10121*/ uint16(xArgPtr16colon32),
-	/*10122*/ uint16(xMatch),
-	/*10123*/ uint16(xSetOp), uint16(FWAIT),
-	/*10125*/ uint16(xMatch),
-	/*10126*/ uint16(xCondIs64), 10129, 10139,
-	/*10129*/ uint16(xCondDataSize), 10133, 10136, 0,
-	/*10133*/ uint16(xSetOp), uint16(PUSHF),
-	/*10135*/ uint16(xMatch),
-	/*10136*/ uint16(xSetOp), uint16(PUSHFD),
-	/*10138*/ uint16(xMatch),
-	/*10139*/ uint16(xCondDataSize), 10133, 10143, 10146,
-	/*10143*/ uint16(xSetOp), uint16(PUSHFQ),
-	/*10145*/ uint16(xMatch),
-	/*10146*/ uint16(xSetOp), uint16(PUSHFQ),
-	/*10148*/ uint16(xMatch),
-	/*10149*/ uint16(xCondIs64), 10152, 10162,
-	/*10152*/ uint16(xCondDataSize), 10156, 10159, 0,
-	/*10156*/ uint16(xSetOp), uint16(POPF),
-	/*10158*/ uint16(xMatch),
-	/*10159*/ uint16(xSetOp), uint16(POPFD),
-	/*10161*/ uint16(xMatch),
-	/*10162*/ uint16(xCondDataSize), 10156, 10166, 10169,
-	/*10166*/ uint16(xSetOp), uint16(POPFQ),
-	/*10168*/ uint16(xMatch),
-	/*10169*/ uint16(xSetOp), uint16(POPFQ),
-	/*10171*/ uint16(xMatch),
-	/*10172*/ uint16(xSetOp), uint16(SAHF),
-	/*10174*/ uint16(xMatch),
-	/*10175*/ uint16(xSetOp), uint16(LAHF),
+	/*10118*/ uint16(xCondDataSize), 10112, 10115, 10122,
+	/*10122*/ uint16(xSetOp), uint16(CQO),
+	/*10124*/ uint16(xMatch),
+	/*10125*/ uint16(xCondIs64), 10128, 0,
+	/*10128*/ uint16(xCondDataSize), 10132, 10137, 0,
+	/*10132*/ uint16(xSetOp), uint16(LCALL),
+	/*10134*/ uint16(xReadCd),
+	/*10135*/ uint16(xArgPtr16colon16),
+	/*10136*/ uint16(xMatch),
+	/*10137*/ uint16(xSetOp), uint16(LCALL),
+	/*10139*/ uint16(xReadCp),
+	/*10140*/ uint16(xArgPtr16colon32),
+	/*10141*/ uint16(xMatch),
+	/*10142*/ uint16(xSetOp), uint16(FWAIT),
+	/*10144*/ uint16(xMatch),
+	/*10145*/ uint16(xCondIs64), 10148, 10158,
+	/*10148*/ uint16(xCondDataSize), 10152, 10155, 0,
+	/*10152*/ uint16(xSetOp), uint16(PUSHF),
+	/*10154*/ uint16(xMatch),
+	/*10155*/ uint16(xSetOp), uint16(PUSHFD),
+	/*10157*/ uint16(xMatch),
+	/*10158*/ uint16(xCondDataSize), 10152, 10162, 10165,
+	/*10162*/ uint16(xSetOp), uint16(PUSHFQ),
+	/*10164*/ uint16(xMatch),
+	/*10165*/ uint16(xSetOp), uint16(PUSHFQ),
+	/*10167*/ uint16(xMatch),
+	/*10168*/ uint16(xCondIs64), 10171, 10181,
+	/*10171*/ uint16(xCondDataSize), 10175, 10178, 0,
+	/*10175*/ uint16(xSetOp), uint16(POPF),
 	/*10177*/ uint16(xMatch),
-	/*10178*/ uint16(xCondIs64), 10181, 10187,
-	/*10181*/ uint16(xSetOp), uint16(MOV),
-	/*10183*/ uint16(xReadCm),
-	/*10184*/ uint16(xArgAL),
-	/*10185*/ uint16(xArgMoffs8),
-	/*10186*/ uint16(xMatch),
-	/*10187*/ uint16(xCondDataSize), 10181, 10181, 10191,
-	/*10191*/ uint16(xSetOp), uint16(MOV),
-	/*10193*/ uint16(xReadCm),
-	/*10194*/ uint16(xArgAL),
-	/*10195*/ uint16(xArgMoffs8),
+	/*10178*/ uint16(xSetOp), uint16(POPFD),
+	/*10180*/ uint16(xMatch),
+	/*10181*/ uint16(xCondDataSize), 10175, 10185, 10188,
+	/*10185*/ uint16(xSetOp), uint16(POPFQ),
+	/*10187*/ uint16(xMatch),
+	/*10188*/ uint16(xSetOp), uint16(POPFQ),
+	/*10190*/ uint16(xMatch),
+	/*10191*/ uint16(xSetOp), uint16(SAHF),
+	/*10193*/ uint16(xMatch),
+	/*10194*/ uint16(xSetOp), uint16(LAHF),
 	/*10196*/ uint16(xMatch),
-	/*10197*/ uint16(xCondDataSize), 10201, 10207, 10213,
-	/*10201*/ uint16(xSetOp), uint16(MOV),
-	/*10203*/ uint16(xReadCm),
-	/*10204*/ uint16(xArgAX),
-	/*10205*/ uint16(xArgMoffs16),
-	/*10206*/ uint16(xMatch),
-	/*10207*/ uint16(xSetOp), uint16(MOV),
-	/*10209*/ uint16(xReadCm),
-	/*10210*/ uint16(xArgEAX),
-	/*10211*/ uint16(xArgMoffs32),
-	/*10212*/ uint16(xMatch),
-	/*10213*/ uint16(xSetOp), uint16(MOV),
-	/*10215*/ uint16(xReadCm),
-	/*10216*/ uint16(xArgRAX),
-	/*10217*/ uint16(xArgMoffs64),
-	/*10218*/ uint16(xMatch),
-	/*10219*/ uint16(xCondIs64), 10222, 10228,
-	/*10222*/ uint16(xSetOp), uint16(MOV),
-	/*10224*/ uint16(xReadCm),
-	/*10225*/ uint16(xArgMoffs8),
-	/*10226*/ uint16(xArgAL),
-	/*10227*/ uint16(xMatch),
-	/*10228*/ uint16(xCondDataSize), 10222, 10222, 10232,
+	/*10197*/ uint16(xCondIs64), 10200, 10206,
+	/*10200*/ uint16(xSetOp), uint16(MOV),
+	/*10202*/ uint16(xReadCm),
+	/*10203*/ uint16(xArgAL),
+	/*10204*/ uint16(xArgMoffs8),
+	/*10205*/ uint16(xMatch),
+	/*10206*/ uint16(xCondDataSize), 10200, 10200, 10210,
+	/*10210*/ uint16(xSetOp), uint16(MOV),
+	/*10212*/ uint16(xReadCm),
+	/*10213*/ uint16(xArgAL),
+	/*10214*/ uint16(xArgMoffs8),
+	/*10215*/ uint16(xMatch),
+	/*10216*/ uint16(xCondDataSize), 10220, 10226, 10232,
+	/*10220*/ uint16(xSetOp), uint16(MOV),
+	/*10222*/ uint16(xReadCm),
+	/*10223*/ uint16(xArgAX),
+	/*10224*/ uint16(xArgMoffs16),
+	/*10225*/ uint16(xMatch),
+	/*10226*/ uint16(xSetOp), uint16(MOV),
+	/*10228*/ uint16(xReadCm),
+	/*10229*/ uint16(xArgEAX),
+	/*10230*/ uint16(xArgMoffs32),
+	/*10231*/ uint16(xMatch),
 	/*10232*/ uint16(xSetOp), uint16(MOV),
 	/*10234*/ uint16(xReadCm),
-	/*10235*/ uint16(xArgMoffs8),
-	/*10236*/ uint16(xArgAL),
+	/*10235*/ uint16(xArgRAX),
+	/*10236*/ uint16(xArgMoffs64),
 	/*10237*/ uint16(xMatch),
-	/*10238*/ uint16(xCondDataSize), 10242, 10248, 10254,
-	/*10242*/ uint16(xSetOp), uint16(MOV),
-	/*10244*/ uint16(xReadCm),
-	/*10245*/ uint16(xArgMoffs16),
-	/*10246*/ uint16(xArgAX),
-	/*10247*/ uint16(xMatch),
-	/*10248*/ uint16(xSetOp), uint16(MOV),
-	/*10250*/ uint16(xReadCm),
-	/*10251*/ uint16(xArgMoffs32),
-	/*10252*/ uint16(xArgEAX),
-	/*10253*/ uint16(xMatch),
-	/*10254*/ uint16(xSetOp), uint16(MOV),
-	/*10256*/ uint16(xReadCm),
-	/*10257*/ uint16(xArgMoffs64),
-	/*10258*/ uint16(xArgRAX),
-	/*10259*/ uint16(xMatch),
-	/*10260*/ uint16(xSetOp), uint16(MOVSB),
-	/*10262*/ uint16(xMatch),
-	/*10263*/ uint16(xCondIs64), 10266, 10276,
-	/*10266*/ uint16(xCondDataSize), 10270, 10273, 0,
-	/*10270*/ uint16(xSetOp), uint16(MOVSW),
+	/*10238*/ uint16(xCondIs64), 10241, 10247,
+	/*10241*/ uint16(xSetOp), uint16(MOV),
+	/*10243*/ uint16(xReadCm),
+	/*10244*/ uint16(xArgMoffs8),
+	/*10245*/ uint16(xArgAL),
+	/*10246*/ uint16(xMatch),
+	/*10247*/ uint16(xCondDataSize), 10241, 10241, 10251,
+	/*10251*/ uint16(xSetOp), uint16(MOV),
+	/*10253*/ uint16(xReadCm),
+	/*10254*/ uint16(xArgMoffs8),
+	/*10255*/ uint16(xArgAL),
+	/*10256*/ uint16(xMatch),
+	/*10257*/ uint16(xCondDataSize), 10261, 10267, 10273,
+	/*10261*/ uint16(xSetOp), uint16(MOV),
+	/*10263*/ uint16(xReadCm),
+	/*10264*/ uint16(xArgMoffs16),
+	/*10265*/ uint16(xArgAX),
+	/*10266*/ uint16(xMatch),
+	/*10267*/ uint16(xSetOp), uint16(MOV),
+	/*10269*/ uint16(xReadCm),
+	/*10270*/ uint16(xArgMoffs32),
+	/*10271*/ uint16(xArgEAX),
 	/*10272*/ uint16(xMatch),
-	/*10273*/ uint16(xSetOp), uint16(MOVSD),
-	/*10275*/ uint16(xMatch),
-	/*10276*/ uint16(xCondDataSize), 10270, 10273, 10280,
-	/*10280*/ uint16(xSetOp), uint16(MOVSQ),
-	/*10282*/ uint16(xMatch),
-	/*10283*/ uint16(xSetOp), uint16(CMPSB),
-	/*10285*/ uint16(xMatch),
-	/*10286*/ uint16(xCondIs64), 10289, 10299,
-	/*10289*/ uint16(xCondDataSize), 10293, 10296, 0,
-	/*10293*/ uint16(xSetOp), uint16(CMPSW),
-	/*10295*/ uint16(xMatch),
-	/*10296*/ uint16(xSetOp), uint16(CMPSD),
-	/*10298*/ uint16(xMatch),
-	/*10299*/ uint16(xCondDataSize), 10293, 10296, 10303,
-	/*10303*/ uint16(xSetOp), uint16(CMPSQ),
-	/*10305*/ uint16(xMatch),
-	/*10306*/ uint16(xSetOp), uint16(TEST),
-	/*10308*/ uint16(xReadIb),
-	/*10309*/ uint16(xArgAL),
-	/*10310*/ uint16(xArgImm8u),
-	/*10311*/ uint16(xMatch),
-	/*10312*/ uint16(xCondIs64), 10315, 10331,
-	/*10315*/ uint16(xCondDataSize), 10319, 10325, 0,
-	/*10319*/ uint16(xSetOp), uint16(TEST),
-	/*10321*/ uint16(xReadIw),
-	/*10322*/ uint16(xArgAX),
-	/*10323*/ uint16(xArgImm16),
+	/*10273*/ uint16(xSetOp), uint16(MOV),
+	/*10275*/ uint16(xReadCm),
+	/*10276*/ uint16(xArgMoffs64),
+	/*10277*/ uint16(xArgRAX),
+	/*10278*/ uint16(xMatch),
+	/*10279*/ uint16(xSetOp), uint16(MOVSB),
+	/*10281*/ uint16(xMatch),
+	/*10282*/ uint16(xCondIs64), 10285, 10295,
+	/*10285*/ uint16(xCondDataSize), 10289, 10292, 0,
+	/*10289*/ uint16(xSetOp), uint16(MOVSW),
+	/*10291*/ uint16(xMatch),
+	/*10292*/ uint16(xSetOp), uint16(MOVSD),
+	/*10294*/ uint16(xMatch),
+	/*10295*/ uint16(xCondDataSize), 10289, 10292, 10299,
+	/*10299*/ uint16(xSetOp), uint16(MOVSQ),
+	/*10301*/ uint16(xMatch),
+	/*10302*/ uint16(xSetOp), uint16(CMPSB),
+	/*10304*/ uint16(xMatch),
+	/*10305*/ uint16(xCondIs64), 10308, 10318,
+	/*10308*/ uint16(xCondDataSize), 10312, 10315, 0,
+	/*10312*/ uint16(xSetOp), uint16(CMPSW),
+	/*10314*/ uint16(xMatch),
+	/*10315*/ uint16(xSetOp), uint16(CMPSD),
+	/*10317*/ uint16(xMatch),
+	/*10318*/ uint16(xCondDataSize), 10312, 10315, 10322,
+	/*10322*/ uint16(xSetOp), uint16(CMPSQ),
 	/*10324*/ uint16(xMatch),
 	/*10325*/ uint16(xSetOp), uint16(TEST),
-	/*10327*/ uint16(xReadId),
-	/*10328*/ uint16(xArgEAX),
-	/*10329*/ uint16(xArgImm32),
+	/*10327*/ uint16(xReadIb),
+	/*10328*/ uint16(xArgAL),
+	/*10329*/ uint16(xArgImm8u),
 	/*10330*/ uint16(xMatch),
-	/*10331*/ uint16(xCondDataSize), 10319, 10325, 10335,
-	/*10335*/ uint16(xSetOp), uint16(TEST),
-	/*10337*/ uint16(xReadId),
-	/*10338*/ uint16(xArgRAX),
-	/*10339*/ uint16(xArgImm32),
-	/*10340*/ uint16(xMatch),
-	/*10341*/ uint16(xSetOp), uint16(STOSB),
+	/*10331*/ uint16(xCondIs64), 10334, 10350,
+	/*10334*/ uint16(xCondDataSize), 10338, 10344, 0,
+	/*10338*/ uint16(xSetOp), uint16(TEST),
+	/*10340*/ uint16(xReadIw),
+	/*10341*/ uint16(xArgAX),
+	/*10342*/ uint16(xArgImm16),
 	/*10343*/ uint16(xMatch),
-	/*10344*/ uint16(xCondIs64), 10347, 10357,
-	/*10347*/ uint16(xCondDataSize), 10351, 10354, 0,
-	/*10351*/ uint16(xSetOp), uint16(STOSW),
-	/*10353*/ uint16(xMatch),
-	/*10354*/ uint16(xSetOp), uint16(STOSD),
-	/*10356*/ uint16(xMatch),
-	/*10357*/ uint16(xCondDataSize), 10351, 10354, 10361,
-	/*10361*/ uint16(xSetOp), uint16(STOSQ),
-	/*10363*/ uint16(xMatch),
-	/*10364*/ uint16(xSetOp), uint16(LODSB),
-	/*10366*/ uint16(xMatch),
-	/*10367*/ uint16(xCondIs64), 10370, 10380,
-	/*10370*/ uint16(xCondDataSize), 10374, 10377, 0,
-	/*10374*/ uint16(xSetOp), uint16(LODSW),
-	/*10376*/ uint16(xMatch),
-	/*10377*/ uint16(xSetOp), uint16(LODSD),
-	/*10379*/ uint16(xMatch),
-	/*10380*/ uint16(xCondDataSize), 10374, 10377, 10384,
-	/*10384*/ uint16(xSetOp), uint16(LODSQ),
-	/*10386*/ uint16(xMatch),
-	/*10387*/ uint16(xSetOp), uint16(SCASB),
-	/*10389*/ uint16(xMatch),
-	/*10390*/ uint16(xCondIs64), 10393, 10403,
-	/*10393*/ uint16(xCondDataSize), 10397, 10400, 0,
-	/*10397*/ uint16(xSetOp), uint16(SCASW),
-	/*10399*/ uint16(xMatch),
-	/*10400*/ uint16(xSetOp), uint16(SCASD),
-	/*10402*/ uint16(xMatch),
-	/*10403*/ uint16(xCondDataSize), 10397, 10400, 10407,
-	/*10407*/ uint16(xSetOp), uint16(SCASQ),
-	/*10409*/ uint16(xMatch),
-	/*10410*/ uint16(xSetOp), uint16(MOV),
-	/*10412*/ uint16(xReadIb),
-	/*10413*/ uint16(xArgR8op),
-	/*10414*/ uint16(xArgImm8u),
-	/*10415*/ uint16(xMatch),
-	/*10416*/ uint16(xCondIs64), 10419, 10435,
-	/*10419*/ uint16(xCondDataSize), 10423, 10429, 0,
-	/*10423*/ uint16(xSetOp), uint16(MOV),
-	/*10425*/ uint16(xReadIw),
-	/*10426*/ uint16(xArgR16op),
-	/*10427*/ uint16(xArgImm16),
+	/*10344*/ uint16(xSetOp), uint16(TEST),
+	/*10346*/ uint16(xReadId),
+	/*10347*/ uint16(xArgEAX),
+	/*10348*/ uint16(xArgImm32),
+	/*10349*/ uint16(xMatch),
+	/*10350*/ uint16(xCondDataSize), 10338, 10344, 10354,
+	/*10354*/ uint16(xSetOp), uint16(TEST),
+	/*10356*/ uint16(xReadId),
+	/*10357*/ uint16(xArgRAX),
+	/*10358*/ uint16(xArgImm32),
+	/*10359*/ uint16(xMatch),
+	/*10360*/ uint16(xSetOp), uint16(STOSB),
+	/*10362*/ uint16(xMatch),
+	/*10363*/ uint16(xCondIs64), 10366, 10376,
+	/*10366*/ uint16(xCondDataSize), 10370, 10373, 0,
+	/*10370*/ uint16(xSetOp), uint16(STOSW),
+	/*10372*/ uint16(xMatch),
+	/*10373*/ uint16(xSetOp), uint16(STOSD),
+	/*10375*/ uint16(xMatch),
+	/*10376*/ uint16(xCondDataSize), 10370, 10373, 10380,
+	/*10380*/ uint16(xSetOp), uint16(STOSQ),
+	/*10382*/ uint16(xMatch),
+	/*10383*/ uint16(xSetOp), uint16(LODSB),
+	/*10385*/ uint16(xMatch),
+	/*10386*/ uint16(xCondIs64), 10389, 10399,
+	/*10389*/ uint16(xCondDataSize), 10393, 10396, 0,
+	/*10393*/ uint16(xSetOp), uint16(LODSW),
+	/*10395*/ uint16(xMatch),
+	/*10396*/ uint16(xSetOp), uint16(LODSD),
+	/*10398*/ uint16(xMatch),
+	/*10399*/ uint16(xCondDataSize), 10393, 10396, 10403,
+	/*10403*/ uint16(xSetOp), uint16(LODSQ),
+	/*10405*/ uint16(xMatch),
+	/*10406*/ uint16(xSetOp), uint16(SCASB),
+	/*10408*/ uint16(xMatch),
+	/*10409*/ uint16(xCondIs64), 10412, 10422,
+	/*10412*/ uint16(xCondDataSize), 10416, 10419, 0,
+	/*10416*/ uint16(xSetOp), uint16(SCASW),
+	/*10418*/ uint16(xMatch),
+	/*10419*/ uint16(xSetOp), uint16(SCASD),
+	/*10421*/ uint16(xMatch),
+	/*10422*/ uint16(xCondDataSize), 10416, 10419, 10426,
+	/*10426*/ uint16(xSetOp), uint16(SCASQ),
 	/*10428*/ uint16(xMatch),
 	/*10429*/ uint16(xSetOp), uint16(MOV),
-	/*10431*/ uint16(xReadId),
-	/*10432*/ uint16(xArgR32op),
-	/*10433*/ uint16(xArgImm32),
+	/*10431*/ uint16(xReadIb),
+	/*10432*/ uint16(xArgR8op),
+	/*10433*/ uint16(xArgImm8u),
 	/*10434*/ uint16(xMatch),
-	/*10435*/ uint16(xCondDataSize), 10423, 10429, 10439,
-	/*10439*/ uint16(xSetOp), uint16(MOV),
-	/*10441*/ uint16(xReadIo),
-	/*10442*/ uint16(xArgR64op),
-	/*10443*/ uint16(xArgImm64),
-	/*10444*/ uint16(xMatch),
-	/*10445*/ uint16(xCondSlashR),
-	10454, // 0
-	10460, // 1
-	10466, // 2
-	10472, // 3
-	10478, // 4
-	10484, // 5
+	/*10435*/ uint16(xCondIs64), 10438, 10454,
+	/*10438*/ uint16(xCondDataSize), 10442, 10448, 0,
+	/*10442*/ uint16(xSetOp), uint16(MOV),
+	/*10444*/ uint16(xReadIw),
+	/*10445*/ uint16(xArgR16op),
+	/*10446*/ uint16(xArgImm16),
+	/*10447*/ uint16(xMatch),
+	/*10448*/ uint16(xSetOp), uint16(MOV),
+	/*10450*/ uint16(xReadId),
+	/*10451*/ uint16(xArgR32op),
+	/*10452*/ uint16(xArgImm32),
+	/*10453*/ uint16(xMatch),
+	/*10454*/ uint16(xCondDataSize), 10442, 10448, 10458,
+	/*10458*/ uint16(xSetOp), uint16(MOV),
+	/*10460*/ uint16(xReadIo),
+	/*10461*/ uint16(xArgR64op),
+	/*10462*/ uint16(xArgImm64),
+	/*10463*/ uint16(xMatch),
+	/*10464*/ uint16(xCondSlashR),
+	10473, // 0
+	10479, // 1
+	10485, // 2
+	10491, // 3
+	10497, // 4
+	10503, // 5
 	0,     // 6
-	10490, // 7
-	/*10454*/ uint16(xSetOp), uint16(ROL),
-	/*10456*/ uint16(xReadIb),
-	/*10457*/ uint16(xArgRM8),
-	/*10458*/ uint16(xArgImm8u),
-	/*10459*/ uint16(xMatch),
-	/*10460*/ uint16(xSetOp), uint16(ROR),
-	/*10462*/ uint16(xReadIb),
-	/*10463*/ uint16(xArgRM8),
-	/*10464*/ uint16(xArgImm8u),
-	/*10465*/ uint16(xMatch),
-	/*10466*/ uint16(xSetOp), uint16(RCL),
-	/*10468*/ uint16(xReadIb),
-	/*10469*/ uint16(xArgRM8),
-	/*10470*/ uint16(xArgImm8u),
-	/*10471*/ uint16(xMatch),
-	/*10472*/ uint16(xSetOp), uint16(RCR),
-	/*10474*/ uint16(xReadIb),
-	/*10475*/ uint16(xArgRM8),
-	/*10476*/ uint16(xArgImm8u),
-	/*10477*/ uint16(xMatch),
-	/*10478*/ uint16(xSetOp), uint16(SHL),
-	/*10480*/ uint16(xReadIb),
-	/*10481*/ uint16(xArgRM8),
-	/*10482*/ uint16(xArgImm8u),
-	/*10483*/ uint16(xMatch),
-	/*10484*/ uint16(xSetOp), uint16(SHR),
-	/*10486*/ uint16(xReadIb),
-	/*10487*/ uint16(xArgRM8),
-	/*10488*/ uint16(xArgImm8u),
-	/*10489*/ uint16(xMatch),
-	/*10490*/ uint16(xSetOp), uint16(SAR),
-	/*10492*/ uint16(xReadIb),
-	/*10493*/ uint16(xArgRM8),
-	/*10494*/ uint16(xArgImm8u),
-	/*10495*/ uint16(xMatch),
-	/*10496*/ uint16(xCondSlashR),
-	10505, // 0
-	10527, // 1
-	10549, // 2
-	10578, // 3
-	10607, // 4
-	10636, // 5
-	0,     // 6
-	10665, // 7
-	/*10505*/ uint16(xCondDataSize), 10509, 10515, 10521,
-	/*10509*/ uint16(xSetOp), uint16(ROL),
+	10509, // 7
+	/*10473*/ uint16(xSetOp), uint16(ROL),
+	/*10475*/ uint16(xReadIb),
+	/*10476*/ uint16(xArgRM8),
+	/*10477*/ uint16(xArgImm8u),
+	/*10478*/ uint16(xMatch),
+	/*10479*/ uint16(xSetOp), uint16(ROR),
+	/*10481*/ uint16(xReadIb),
+	/*10482*/ uint16(xArgRM8),
+	/*10483*/ uint16(xArgImm8u),
+	/*10484*/ uint16(xMatch),
+	/*10485*/ uint16(xSetOp), uint16(RCL),
+	/*10487*/ uint16(xReadIb),
+	/*10488*/ uint16(xArgRM8),
+	/*10489*/ uint16(xArgImm8u),
+	/*10490*/ uint16(xMatch),
+	/*10491*/ uint16(xSetOp), uint16(RCR),
+	/*10493*/ uint16(xReadIb),
+	/*10494*/ uint16(xArgRM8),
+	/*10495*/ uint16(xArgImm8u),
+	/*10496*/ uint16(xMatch),
+	/*10497*/ uint16(xSetOp), uint16(SHL),
+	/*10499*/ uint16(xReadIb),
+	/*10500*/ uint16(xArgRM8),
+	/*10501*/ uint16(xArgImm8u),
+	/*10502*/ uint16(xMatch),
+	/*10503*/ uint16(xSetOp), uint16(SHR),
+	/*10505*/ uint16(xReadIb),
+	/*10506*/ uint16(xArgRM8),
+	/*10507*/ uint16(xArgImm8u),
+	/*10508*/ uint16(xMatch),
+	/*10509*/ uint16(xSetOp), uint16(SAR),
 	/*10511*/ uint16(xReadIb),
-	/*10512*/ uint16(xArgRM16),
+	/*10512*/ uint16(xArgRM8),
 	/*10513*/ uint16(xArgImm8u),
 	/*10514*/ uint16(xMatch),
-	/*10515*/ uint16(xSetOp), uint16(ROL),
-	/*10517*/ uint16(xReadIb),
-	/*10518*/ uint16(xArgRM32),
-	/*10519*/ uint16(xArgImm8u),
-	/*10520*/ uint16(xMatch),
-	/*10521*/ uint16(xSetOp), uint16(ROL),
-	/*10523*/ uint16(xReadIb),
-	/*10524*/ uint16(xArgRM64),
-	/*10525*/ uint16(xArgImm8u),
-	/*10526*/ uint16(xMatch),
-	/*10527*/ uint16(xCondDataSize), 10531, 10537, 10543,
-	/*10531*/ uint16(xSetOp), uint16(ROR),
-	/*10533*/ uint16(xReadIb),
-	/*10534*/ uint16(xArgRM16),
-	/*10535*/ uint16(xArgImm8u),
-	/*10536*/ uint16(xMatch),
-	/*10537*/ uint16(xSetOp), uint16(ROR),
-	/*10539*/ uint16(xReadIb),
-	/*10540*/ uint16(xArgRM32),
-	/*10541*/ uint16(xArgImm8u),
-	/*10542*/ uint16(xMatch),
-	/*10543*/ uint16(xSetOp), uint16(ROR),
-	/*10545*/ uint16(xReadIb),
-	/*10546*/ uint16(xArgRM64),
-	/*10547*/ uint16(xArgImm8u),
-	/*10548*/ uint16(xMatch),
-	/*10549*/ uint16(xCondIs64), 10552, 10568,
-	/*10552*/ uint16(xCondDataSize), 10556, 10562, 0,
-	/*10556*/ uint16(xSetOp), uint16(RCL),
+	/*10515*/ uint16(xCondSlashR),
+	10524, // 0
+	10546, // 1
+	10568, // 2
+	10597, // 3
+	10626, // 4
+	10655, // 5
+	0,     // 6
+	10684, // 7
+	/*10524*/ uint16(xCondDataSize), 10528, 10534, 10540,
+	/*10528*/ uint16(xSetOp), uint16(ROL),
+	/*10530*/ uint16(xReadIb),
+	/*10531*/ uint16(xArgRM16),
+	/*10532*/ uint16(xArgImm8u),
+	/*10533*/ uint16(xMatch),
+	/*10534*/ uint16(xSetOp), uint16(ROL),
+	/*10536*/ uint16(xReadIb),
+	/*10537*/ uint16(xArgRM32),
+	/*10538*/ uint16(xArgImm8u),
+	/*10539*/ uint16(xMatch),
+	/*10540*/ uint16(xSetOp), uint16(ROL),
+	/*10542*/ uint16(xReadIb),
+	/*10543*/ uint16(xArgRM64),
+	/*10544*/ uint16(xArgImm8u),
+	/*10545*/ uint16(xMatch),
+	/*10546*/ uint16(xCondDataSize), 10550, 10556, 10562,
+	/*10550*/ uint16(xSetOp), uint16(ROR),
+	/*10552*/ uint16(xReadIb),
+	/*10553*/ uint16(xArgRM16),
+	/*10554*/ uint16(xArgImm8u),
+	/*10555*/ uint16(xMatch),
+	/*10556*/ uint16(xSetOp), uint16(ROR),
 	/*10558*/ uint16(xReadIb),
-	/*10559*/ uint16(xArgRM16),
+	/*10559*/ uint16(xArgRM32),
 	/*10560*/ uint16(xArgImm8u),
 	/*10561*/ uint16(xMatch),
-	/*10562*/ uint16(xSetOp), uint16(RCL),
+	/*10562*/ uint16(xSetOp), uint16(ROR),
 	/*10564*/ uint16(xReadIb),
-	/*10565*/ uint16(xArgRM32),
+	/*10565*/ uint16(xArgRM64),
 	/*10566*/ uint16(xArgImm8u),
 	/*10567*/ uint16(xMatch),
-	/*10568*/ uint16(xCondDataSize), 10556, 10562, 10572,
-	/*10572*/ uint16(xSetOp), uint16(RCL),
-	/*10574*/ uint16(xReadIb),
-	/*10575*/ uint16(xArgRM64),
-	/*10576*/ uint16(xArgImm8u),
-	/*10577*/ uint16(xMatch),
-	/*10578*/ uint16(xCondIs64), 10581, 10597,
-	/*10581*/ uint16(xCondDataSize), 10585, 10591, 0,
-	/*10585*/ uint16(xSetOp), uint16(RCR),
-	/*10587*/ uint16(xReadIb),
-	/*10588*/ uint16(xArgRM16),
-	/*10589*/ uint16(xArgImm8u),
-	/*10590*/ uint16(xMatch),
-	/*10591*/ uint16(xSetOp), uint16(RCR),
+	/*10568*/ uint16(xCondIs64), 10571, 10587,
+	/*10571*/ uint16(xCondDataSize), 10575, 10581, 0,
+	/*10575*/ uint16(xSetOp), uint16(RCL),
+	/*10577*/ uint16(xReadIb),
+	/*10578*/ uint16(xArgRM16),
+	/*10579*/ uint16(xArgImm8u),
+	/*10580*/ uint16(xMatch),
+	/*10581*/ uint16(xSetOp), uint16(RCL),
+	/*10583*/ uint16(xReadIb),
+	/*10584*/ uint16(xArgRM32),
+	/*10585*/ uint16(xArgImm8u),
+	/*10586*/ uint16(xMatch),
+	/*10587*/ uint16(xCondDataSize), 10575, 10581, 10591,
+	/*10591*/ uint16(xSetOp), uint16(RCL),
 	/*10593*/ uint16(xReadIb),
-	/*10594*/ uint16(xArgRM32),
+	/*10594*/ uint16(xArgRM64),
 	/*10595*/ uint16(xArgImm8u),
 	/*10596*/ uint16(xMatch),
-	/*10597*/ uint16(xCondDataSize), 10585, 10591, 10601,
-	/*10601*/ uint16(xSetOp), uint16(RCR),
-	/*10603*/ uint16(xReadIb),
-	/*10604*/ uint16(xArgRM64),
-	/*10605*/ uint16(xArgImm8u),
-	/*10606*/ uint16(xMatch),
-	/*10607*/ uint16(xCondIs64), 10610, 10626,
-	/*10610*/ uint16(xCondDataSize), 10614, 10620, 0,
-	/*10614*/ uint16(xSetOp), uint16(SHL),
-	/*10616*/ uint16(xReadIb),
-	/*10617*/ uint16(xArgRM16),
-	/*10618*/ uint16(xArgImm8u),
-	/*10619*/ uint16(xMatch),
-	/*10620*/ uint16(xSetOp), uint16(SHL),
+	/*10597*/ uint16(xCondIs64), 10600, 10616,
+	/*10600*/ uint16(xCondDataSize), 10604, 10610, 0,
+	/*10604*/ uint16(xSetOp), uint16(RCR),
+	/*10606*/ uint16(xReadIb),
+	/*10607*/ uint16(xArgRM16),
+	/*10608*/ uint16(xArgImm8u),
+	/*10609*/ uint16(xMatch),
+	/*10610*/ uint16(xSetOp), uint16(RCR),
+	/*10612*/ uint16(xReadIb),
+	/*10613*/ uint16(xArgRM32),
+	/*10614*/ uint16(xArgImm8u),
+	/*10615*/ uint16(xMatch),
+	/*10616*/ uint16(xCondDataSize), 10604, 10610, 10620,
+	/*10620*/ uint16(xSetOp), uint16(RCR),
 	/*10622*/ uint16(xReadIb),
-	/*10623*/ uint16(xArgRM32),
+	/*10623*/ uint16(xArgRM64),
 	/*10624*/ uint16(xArgImm8u),
 	/*10625*/ uint16(xMatch),
-	/*10626*/ uint16(xCondDataSize), 10614, 10620, 10630,
-	/*10630*/ uint16(xSetOp), uint16(SHL),
-	/*10632*/ uint16(xReadIb),
-	/*10633*/ uint16(xArgRM64),
-	/*10634*/ uint16(xArgImm8u),
-	/*10635*/ uint16(xMatch),
-	/*10636*/ uint16(xCondIs64), 10639, 10655,
-	/*10639*/ uint16(xCondDataSize), 10643, 10649, 0,
-	/*10643*/ uint16(xSetOp), uint16(SHR),
-	/*10645*/ uint16(xReadIb),
-	/*10646*/ uint16(xArgRM16),
-	/*10647*/ uint16(xArgImm8u),
-	/*10648*/ uint16(xMatch),
-	/*10649*/ uint16(xSetOp), uint16(SHR),
+	/*10626*/ uint16(xCondIs64), 10629, 10645,
+	/*10629*/ uint16(xCondDataSize), 10633, 10639, 0,
+	/*10633*/ uint16(xSetOp), uint16(SHL),
+	/*10635*/ uint16(xReadIb),
+	/*10636*/ uint16(xArgRM16),
+	/*10637*/ uint16(xArgImm8u),
+	/*10638*/ uint16(xMatch),
+	/*10639*/ uint16(xSetOp), uint16(SHL),
+	/*10641*/ uint16(xReadIb),
+	/*10642*/ uint16(xArgRM32),
+	/*10643*/ uint16(xArgImm8u),
+	/*10644*/ uint16(xMatch),
+	/*10645*/ uint16(xCondDataSize), 10633, 10639, 10649,
+	/*10649*/ uint16(xSetOp), uint16(SHL),
 	/*10651*/ uint16(xReadIb),
-	/*10652*/ uint16(xArgRM32),
+	/*10652*/ uint16(xArgRM64),
 	/*10653*/ uint16(xArgImm8u),
 	/*10654*/ uint16(xMatch),
-	/*10655*/ uint16(xCondDataSize), 10643, 10649, 10659,
-	/*10659*/ uint16(xSetOp), uint16(SHR),
-	/*10661*/ uint16(xReadIb),
-	/*10662*/ uint16(xArgRM64),
-	/*10663*/ uint16(xArgImm8u),
-	/*10664*/ uint16(xMatch),
-	/*10665*/ uint16(xCondIs64), 10668, 10684,
-	/*10668*/ uint16(xCondDataSize), 10672, 10678, 0,
-	/*10672*/ uint16(xSetOp), uint16(SAR),
-	/*10674*/ uint16(xReadIb),
-	/*10675*/ uint16(xArgRM16),
-	/*10676*/ uint16(xArgImm8u),
-	/*10677*/ uint16(xMatch),
-	/*10678*/ uint16(xSetOp), uint16(SAR),
+	/*10655*/ uint16(xCondIs64), 10658, 10674,
+	/*10658*/ uint16(xCondDataSize), 10662, 10668, 0,
+	/*10662*/ uint16(xSetOp), uint16(SHR),
+	/*10664*/ uint16(xReadIb),
+	/*10665*/ uint16(xArgRM16),
+	/*10666*/ uint16(xArgImm8u),
+	/*10667*/ uint16(xMatch),
+	/*10668*/ uint16(xSetOp), uint16(SHR),
+	/*10670*/ uint16(xReadIb),
+	/*10671*/ uint16(xArgRM32),
+	/*10672*/ uint16(xArgImm8u),
+	/*10673*/ uint16(xMatch),
+	/*10674*/ uint16(xCondDataSize), 10662, 10668, 10678,
+	/*10678*/ uint16(xSetOp), uint16(SHR),
 	/*10680*/ uint16(xReadIb),
-	/*10681*/ uint16(xArgRM32),
+	/*10681*/ uint16(xArgRM64),
 	/*10682*/ uint16(xArgImm8u),
 	/*10683*/ uint16(xMatch),
-	/*10684*/ uint16(xCondDataSize), 10672, 10678, 10688,
-	/*10688*/ uint16(xSetOp), uint16(SAR),
-	/*10690*/ uint16(xReadIb),
-	/*10691*/ uint16(xArgRM64),
-	/*10692*/ uint16(xArgImm8u),
-	/*10693*/ uint16(xMatch),
-	/*10694*/ uint16(xSetOp), uint16(RET),
-	/*10696*/ uint16(xReadIw),
-	/*10697*/ uint16(xArgImm16u),
-	/*10698*/ uint16(xMatch),
-	/*10699*/ uint16(xSetOp), uint16(RET),
-	/*10701*/ uint16(xMatch),
-	/*10702*/ uint16(xCondIs64), 10705, 0,
-	/*10705*/ uint16(xCondDataSize), 10709, 10715, 0,
-	/*10709*/ uint16(xSetOp), uint16(LES),
-	/*10711*/ uint16(xReadSlashR),
-	/*10712*/ uint16(xArgR16),
-	/*10713*/ uint16(xArgM16colon16),
-	/*10714*/ uint16(xMatch),
-	/*10715*/ uint16(xSetOp), uint16(LES),
-	/*10717*/ uint16(xReadSlashR),
-	/*10718*/ uint16(xArgR32),
-	/*10719*/ uint16(xArgM16colon32),
+	/*10684*/ uint16(xCondIs64), 10687, 10703,
+	/*10687*/ uint16(xCondDataSize), 10691, 10697, 0,
+	/*10691*/ uint16(xSetOp), uint16(SAR),
+	/*10693*/ uint16(xReadIb),
+	/*10694*/ uint16(xArgRM16),
+	/*10695*/ uint16(xArgImm8u),
+	/*10696*/ uint16(xMatch),
+	/*10697*/ uint16(xSetOp), uint16(SAR),
+	/*10699*/ uint16(xReadIb),
+	/*10700*/ uint16(xArgRM32),
+	/*10701*/ uint16(xArgImm8u),
+	/*10702*/ uint16(xMatch),
+	/*10703*/ uint16(xCondDataSize), 10691, 10697, 10707,
+	/*10707*/ uint16(xSetOp), uint16(SAR),
+	/*10709*/ uint16(xReadIb),
+	/*10710*/ uint16(xArgRM64),
+	/*10711*/ uint16(xArgImm8u),
+	/*10712*/ uint16(xMatch),
+	/*10713*/ uint16(xSetOp), uint16(RET),
+	/*10715*/ uint16(xReadIw),
+	/*10716*/ uint16(xArgImm16u),
+	/*10717*/ uint16(xMatch),
+	/*10718*/ uint16(xSetOp), uint16(RET),
 	/*10720*/ uint16(xMatch),
 	/*10721*/ uint16(xCondIs64), 10724, 0,
 	/*10724*/ uint16(xCondDataSize), 10728, 10734, 0,
-	/*10728*/ uint16(xSetOp), uint16(LDS),
+	/*10728*/ uint16(xSetOp), uint16(LES),
 	/*10730*/ uint16(xReadSlashR),
 	/*10731*/ uint16(xArgR16),
 	/*10732*/ uint16(xArgM16colon16),
 	/*10733*/ uint16(xMatch),
-	/*10734*/ uint16(xSetOp), uint16(LDS),
+	/*10734*/ uint16(xSetOp), uint16(LES),
 	/*10736*/ uint16(xReadSlashR),
 	/*10737*/ uint16(xArgR32),
 	/*10738*/ uint16(xArgM16colon32),
 	/*10739*/ uint16(xMatch),
-	/*10740*/ uint16(xCondByte), 1,
-	0xF8, 10759,
-	/*10744*/ uint16(xCondSlashR),
-	10753, // 0
+	/*10740*/ uint16(xCondIs64), 10743, 0,
+	/*10743*/ uint16(xCondDataSize), 10747, 10753, 0,
+	/*10747*/ uint16(xSetOp), uint16(LDS),
+	/*10749*/ uint16(xReadSlashR),
+	/*10750*/ uint16(xArgR16),
+	/*10751*/ uint16(xArgM16colon16),
+	/*10752*/ uint16(xMatch),
+	/*10753*/ uint16(xSetOp), uint16(LDS),
+	/*10755*/ uint16(xReadSlashR),
+	/*10756*/ uint16(xArgR32),
+	/*10757*/ uint16(xArgM16colon32),
+	/*10758*/ uint16(xMatch),
+	/*10759*/ uint16(xCondByte), 1,
+	0xF8, 10778,
+	/*10763*/ uint16(xCondSlashR),
+	10772, // 0
 	0,     // 1
 	0,     // 2
 	0,     // 3
@@ -6999,19 +7010,19 @@ var decoder = [...]uint16{
 	0,     // 5
 	0,     // 6
 	0,     // 7
-	/*10753*/ uint16(xSetOp), uint16(MOV),
-	/*10755*/ uint16(xReadIb),
-	/*10756*/ uint16(xArgRM8),
-	/*10757*/ uint16(xArgImm8u),
-	/*10758*/ uint16(xMatch),
-	/*10759*/ uint16(xSetOp), uint16(XABORT),
-	/*10761*/ uint16(xReadIb),
-	/*10762*/ uint16(xArgImm8u),
-	/*10763*/ uint16(xMatch),
-	/*10764*/ uint16(xCondByte), 1,
-	0xF8, 10806,
-	/*10768*/ uint16(xCondSlashR),
-	10777, // 0
+	/*10772*/ uint16(xSetOp), uint16(MOV),
+	/*10774*/ uint16(xReadIb),
+	/*10775*/ uint16(xArgRM8),
+	/*10776*/ uint16(xArgImm8u),
+	/*10777*/ uint16(xMatch),
+	/*10778*/ uint16(xSetOp), uint16(XABORT),
+	/*10780*/ uint16(xReadIb),
+	/*10781*/ uint16(xArgImm8u),
+	/*10782*/ uint16(xMatch),
+	/*10783*/ uint16(xCondByte), 1,
+	0xF8, 10825,
+	/*10787*/ uint16(xCondSlashR),
+	10796, // 0
 	0,     // 1
 	0,     // 2
 	0,     // 3
@@ -7019,1662 +7030,1662 @@ var decoder = [...]uint16{
 	0,     // 5
 	0,     // 6
 	0,     // 7
-	/*10777*/ uint16(xCondIs64), 10780, 10796,
-	/*10780*/ uint16(xCondDataSize), 10784, 10790, 0,
-	/*10784*/ uint16(xSetOp), uint16(MOV),
-	/*10786*/ uint16(xReadIw),
-	/*10787*/ uint16(xArgRM16),
-	/*10788*/ uint16(xArgImm16),
-	/*10789*/ uint16(xMatch),
-	/*10790*/ uint16(xSetOp), uint16(MOV),
-	/*10792*/ uint16(xReadId),
-	/*10793*/ uint16(xArgRM32),
-	/*10794*/ uint16(xArgImm32),
-	/*10795*/ uint16(xMatch),
-	/*10796*/ uint16(xCondDataSize), 10784, 10790, 10800,
-	/*10800*/ uint16(xSetOp), uint16(MOV),
-	/*10802*/ uint16(xReadId),
-	/*10803*/ uint16(xArgRM64),
-	/*10804*/ uint16(xArgImm32),
-	/*10805*/ uint16(xMatch),
-	/*10806*/ uint16(xCondDataSize), 10810, 10815, 10820,
-	/*10810*/ uint16(xSetOp), uint16(XBEGIN),
-	/*10812*/ uint16(xReadCw),
-	/*10813*/ uint16(xArgRel16),
+	/*10796*/ uint16(xCondIs64), 10799, 10815,
+	/*10799*/ uint16(xCondDataSize), 10803, 10809, 0,
+	/*10803*/ uint16(xSetOp), uint16(MOV),
+	/*10805*/ uint16(xReadIw),
+	/*10806*/ uint16(xArgRM16),
+	/*10807*/ uint16(xArgImm16),
+	/*10808*/ uint16(xMatch),
+	/*10809*/ uint16(xSetOp), uint16(MOV),
+	/*10811*/ uint16(xReadId),
+	/*10812*/ uint16(xArgRM32),
+	/*10813*/ uint16(xArgImm32),
 	/*10814*/ uint16(xMatch),
-	/*10815*/ uint16(xSetOp), uint16(XBEGIN),
-	/*10817*/ uint16(xReadCd),
-	/*10818*/ uint16(xArgRel32),
-	/*10819*/ uint16(xMatch),
-	/*10820*/ uint16(xSetOp), uint16(XBEGIN),
-	/*10822*/ uint16(xReadCd),
-	/*10823*/ uint16(xArgRel32),
+	/*10815*/ uint16(xCondDataSize), 10803, 10809, 10819,
+	/*10819*/ uint16(xSetOp), uint16(MOV),
+	/*10821*/ uint16(xReadId),
+	/*10822*/ uint16(xArgRM64),
+	/*10823*/ uint16(xArgImm32),
 	/*10824*/ uint16(xMatch),
-	/*10825*/ uint16(xSetOp), uint16(ENTER),
-	/*10827*/ uint16(xReadIw),
-	/*10828*/ uint16(xReadIb),
-	/*10829*/ uint16(xArgImm16u),
-	/*10830*/ uint16(xArgImm8u),
-	/*10831*/ uint16(xMatch),
-	/*10832*/ uint16(xCondIs64), 10835, 10845,
-	/*10835*/ uint16(xCondDataSize), 10839, 10842, 0,
-	/*10839*/ uint16(xSetOp), uint16(LEAVE),
-	/*10841*/ uint16(xMatch),
-	/*10842*/ uint16(xSetOp), uint16(LEAVE),
-	/*10844*/ uint16(xMatch),
-	/*10845*/ uint16(xCondDataSize), 10839, 10849, 10852,
-	/*10849*/ uint16(xSetOp), uint16(LEAVE),
-	/*10851*/ uint16(xMatch),
-	/*10852*/ uint16(xSetOp), uint16(LEAVE),
-	/*10854*/ uint16(xMatch),
-	/*10855*/ uint16(xSetOp), uint16(LRET),
-	/*10857*/ uint16(xReadIw),
-	/*10858*/ uint16(xArgImm16u),
-	/*10859*/ uint16(xMatch),
-	/*10860*/ uint16(xSetOp), uint16(LRET),
-	/*10862*/ uint16(xMatch),
-	/*10863*/ uint16(xSetOp), uint16(INT),
-	/*10865*/ uint16(xArg3),
-	/*10866*/ uint16(xMatch),
-	/*10867*/ uint16(xSetOp), uint16(INT),
-	/*10869*/ uint16(xReadIb),
-	/*10870*/ uint16(xArgImm8u),
-	/*10871*/ uint16(xMatch),
-	/*10872*/ uint16(xCondIs64), 10875, 0,
-	/*10875*/ uint16(xSetOp), uint16(INTO),
-	/*10877*/ uint16(xMatch),
-	/*10878*/ uint16(xCondIs64), 10881, 10891,
-	/*10881*/ uint16(xCondDataSize), 10885, 10888, 0,
-	/*10885*/ uint16(xSetOp), uint16(IRET),
-	/*10887*/ uint16(xMatch),
-	/*10888*/ uint16(xSetOp), uint16(IRETD),
+	/*10825*/ uint16(xCondDataSize), 10829, 10834, 10839,
+	/*10829*/ uint16(xSetOp), uint16(XBEGIN),
+	/*10831*/ uint16(xReadCw),
+	/*10832*/ uint16(xArgRel16),
+	/*10833*/ uint16(xMatch),
+	/*10834*/ uint16(xSetOp), uint16(XBEGIN),
+	/*10836*/ uint16(xReadCd),
+	/*10837*/ uint16(xArgRel32),
+	/*10838*/ uint16(xMatch),
+	/*10839*/ uint16(xSetOp), uint16(XBEGIN),
+	/*10841*/ uint16(xReadCd),
+	/*10842*/ uint16(xArgRel32),
+	/*10843*/ uint16(xMatch),
+	/*10844*/ uint16(xSetOp), uint16(ENTER),
+	/*10846*/ uint16(xReadIw),
+	/*10847*/ uint16(xReadIb),
+	/*10848*/ uint16(xArgImm16u),
+	/*10849*/ uint16(xArgImm8u),
+	/*10850*/ uint16(xMatch),
+	/*10851*/ uint16(xCondIs64), 10854, 10864,
+	/*10854*/ uint16(xCondDataSize), 10858, 10861, 0,
+	/*10858*/ uint16(xSetOp), uint16(LEAVE),
+	/*10860*/ uint16(xMatch),
+	/*10861*/ uint16(xSetOp), uint16(LEAVE),
+	/*10863*/ uint16(xMatch),
+	/*10864*/ uint16(xCondDataSize), 10858, 10868, 10871,
+	/*10868*/ uint16(xSetOp), uint16(LEAVE),
+	/*10870*/ uint16(xMatch),
+	/*10871*/ uint16(xSetOp), uint16(LEAVE),
+	/*10873*/ uint16(xMatch),
+	/*10874*/ uint16(xSetOp), uint16(LRET),
+	/*10876*/ uint16(xReadIw),
+	/*10877*/ uint16(xArgImm16u),
+	/*10878*/ uint16(xMatch),
+	/*10879*/ uint16(xSetOp), uint16(LRET),
+	/*10881*/ uint16(xMatch),
+	/*10882*/ uint16(xSetOp), uint16(INT),
+	/*10884*/ uint16(xArg3),
+	/*10885*/ uint16(xMatch),
+	/*10886*/ uint16(xSetOp), uint16(INT),
+	/*10888*/ uint16(xReadIb),
+	/*10889*/ uint16(xArgImm8u),
 	/*10890*/ uint16(xMatch),
-	/*10891*/ uint16(xCondDataSize), 10885, 10888, 10895,
-	/*10895*/ uint16(xSetOp), uint16(IRETQ),
-	/*10897*/ uint16(xMatch),
-	/*10898*/ uint16(xCondSlashR),
-	10907, // 0
-	10912, // 1
-	10917, // 2
-	10922, // 3
-	10927, // 4
-	10932, // 5
-	0,     // 6
-	10937, // 7
-	/*10907*/ uint16(xSetOp), uint16(ROL),
-	/*10909*/ uint16(xArgRM8),
-	/*10910*/ uint16(xArg1),
-	/*10911*/ uint16(xMatch),
-	/*10912*/ uint16(xSetOp), uint16(ROR),
-	/*10914*/ uint16(xArgRM8),
-	/*10915*/ uint16(xArg1),
+	/*10891*/ uint16(xCondIs64), 10894, 0,
+	/*10894*/ uint16(xSetOp), uint16(INTO),
+	/*10896*/ uint16(xMatch),
+	/*10897*/ uint16(xCondIs64), 10900, 10910,
+	/*10900*/ uint16(xCondDataSize), 10904, 10907, 0,
+	/*10904*/ uint16(xSetOp), uint16(IRET),
+	/*10906*/ uint16(xMatch),
+	/*10907*/ uint16(xSetOp), uint16(IRETD),
+	/*10909*/ uint16(xMatch),
+	/*10910*/ uint16(xCondDataSize), 10904, 10907, 10914,
+	/*10914*/ uint16(xSetOp), uint16(IRETQ),
 	/*10916*/ uint16(xMatch),
-	/*10917*/ uint16(xSetOp), uint16(RCL),
-	/*10919*/ uint16(xArgRM8),
-	/*10920*/ uint16(xArg1),
-	/*10921*/ uint16(xMatch),
-	/*10922*/ uint16(xSetOp), uint16(RCR),
-	/*10924*/ uint16(xArgRM8),
-	/*10925*/ uint16(xArg1),
-	/*10926*/ uint16(xMatch),
-	/*10927*/ uint16(xSetOp), uint16(SHL),
-	/*10929*/ uint16(xArgRM8),
-	/*10930*/ uint16(xArg1),
-	/*10931*/ uint16(xMatch),
-	/*10932*/ uint16(xSetOp), uint16(SHR),
-	/*10934*/ uint16(xArgRM8),
-	/*10935*/ uint16(xArg1),
-	/*10936*/ uint16(xMatch),
-	/*10937*/ uint16(xSetOp), uint16(SAR),
-	/*10939*/ uint16(xArgRM8),
-	/*10940*/ uint16(xArg1),
-	/*10941*/ uint16(xMatch),
-	/*10942*/ uint16(xCondSlashR),
-	10951, // 0
-	10977, // 1
-	11003, // 2
-	11029, // 3
-	11055, // 4
-	11081, // 5
+	/*10917*/ uint16(xCondSlashR),
+	10926, // 0
+	10931, // 1
+	10936, // 2
+	10941, // 3
+	10946, // 4
+	10951, // 5
 	0,     // 6
-	11107, // 7
-	/*10951*/ uint16(xCondIs64), 10954, 10968,
-	/*10954*/ uint16(xCondDataSize), 10958, 10963, 0,
-	/*10958*/ uint16(xSetOp), uint16(ROL),
-	/*10960*/ uint16(xArgRM16),
-	/*10961*/ uint16(xArg1),
-	/*10962*/ uint16(xMatch),
-	/*10963*/ uint16(xSetOp), uint16(ROL),
-	/*10965*/ uint16(xArgRM32),
-	/*10966*/ uint16(xArg1),
-	/*10967*/ uint16(xMatch),
-	/*10968*/ uint16(xCondDataSize), 10958, 10963, 10972,
-	/*10972*/ uint16(xSetOp), uint16(ROL),
-	/*10974*/ uint16(xArgRM64),
-	/*10975*/ uint16(xArg1),
-	/*10976*/ uint16(xMatch),
-	/*10977*/ uint16(xCondIs64), 10980, 10994,
-	/*10980*/ uint16(xCondDataSize), 10984, 10989, 0,
-	/*10984*/ uint16(xSetOp), uint16(ROR),
-	/*10986*/ uint16(xArgRM16),
-	/*10987*/ uint16(xArg1),
-	/*10988*/ uint16(xMatch),
-	/*10989*/ uint16(xSetOp), uint16(ROR),
-	/*10991*/ uint16(xArgRM32),
-	/*10992*/ uint16(xArg1),
-	/*10993*/ uint16(xMatch),
-	/*10994*/ uint16(xCondDataSize), 10984, 10989, 10998,
-	/*10998*/ uint16(xSetOp), uint16(ROR),
-	/*11000*/ uint16(xArgRM64),
-	/*11001*/ uint16(xArg1),
-	/*11002*/ uint16(xMatch),
-	/*11003*/ uint16(xCondIs64), 11006, 11020,
-	/*11006*/ uint16(xCondDataSize), 11010, 11015, 0,
-	/*11010*/ uint16(xSetOp), uint16(RCL),
-	/*11012*/ uint16(xArgRM16),
-	/*11013*/ uint16(xArg1),
-	/*11014*/ uint16(xMatch),
-	/*11015*/ uint16(xSetOp), uint16(RCL),
-	/*11017*/ uint16(xArgRM32),
-	/*11018*/ uint16(xArg1),
-	/*11019*/ uint16(xMatch),
-	/*11020*/ uint16(xCondDataSize), 11010, 11015, 11024,
-	/*11024*/ uint16(xSetOp), uint16(RCL),
-	/*11026*/ uint16(xArgRM64),
-	/*11027*/ uint16(xArg1),
-	/*11028*/ uint16(xMatch),
-	/*11029*/ uint16(xCondIs64), 11032, 11046,
-	/*11032*/ uint16(xCondDataSize), 11036, 11041, 0,
-	/*11036*/ uint16(xSetOp), uint16(RCR),
-	/*11038*/ uint16(xArgRM16),
-	/*11039*/ uint16(xArg1),
-	/*11040*/ uint16(xMatch),
-	/*11041*/ uint16(xSetOp), uint16(RCR),
-	/*11043*/ uint16(xArgRM32),
-	/*11044*/ uint16(xArg1),
-	/*11045*/ uint16(xMatch),
-	/*11046*/ uint16(xCondDataSize), 11036, 11041, 11050,
-	/*11050*/ uint16(xSetOp), uint16(RCR),
-	/*11052*/ uint16(xArgRM64),
-	/*11053*/ uint16(xArg1),
-	/*11054*/ uint16(xMatch),
-	/*11055*/ uint16(xCondIs64), 11058, 11072,
-	/*11058*/ uint16(xCondDataSize), 11062, 11067, 0,
-	/*11062*/ uint16(xSetOp), uint16(SHL),
-	/*11064*/ uint16(xArgRM16),
-	/*11065*/ uint16(xArg1),
-	/*11066*/ uint16(xMatch),
-	/*11067*/ uint16(xSetOp), uint16(SHL),
-	/*11069*/ uint16(xArgRM32),
-	/*11070*/ uint16(xArg1),
-	/*11071*/ uint16(xMatch),
-	/*11072*/ uint16(xCondDataSize), 11062, 11067, 11076,
-	/*11076*/ uint16(xSetOp), uint16(SHL),
-	/*11078*/ uint16(xArgRM64),
-	/*11079*/ uint16(xArg1),
-	/*11080*/ uint16(xMatch),
-	/*11081*/ uint16(xCondIs64), 11084, 11098,
-	/*11084*/ uint16(xCondDataSize), 11088, 11093, 0,
-	/*11088*/ uint16(xSetOp), uint16(SHR),
-	/*11090*/ uint16(xArgRM16),
-	/*11091*/ uint16(xArg1),
-	/*11092*/ uint16(xMatch),
-	/*11093*/ uint16(xSetOp), uint16(SHR),
-	/*11095*/ uint16(xArgRM32),
-	/*11096*/ uint16(xArg1),
-	/*11097*/ uint16(xMatch),
-	/*11098*/ uint16(xCondDataSize), 11088, 11093, 11102,
-	/*11102*/ uint16(xSetOp), uint16(SHR),
-	/*11104*/ uint16(xArgRM64),
-	/*11105*/ uint16(xArg1),
-	/*11106*/ uint16(xMatch),
-	/*11107*/ uint16(xCondIs64), 11110, 11124,
-	/*11110*/ uint16(xCondDataSize), 11114, 11119, 0,
-	/*11114*/ uint16(xSetOp), uint16(SAR),
-	/*11116*/ uint16(xArgRM16),
-	/*11117*/ uint16(xArg1),
-	/*11118*/ uint16(xMatch),
-	/*11119*/ uint16(xSetOp), uint16(SAR),
-	/*11121*/ uint16(xArgRM32),
-	/*11122*/ uint16(xArg1),
-	/*11123*/ uint16(xMatch),
-	/*11124*/ uint16(xCondDataSize), 11114, 11119, 11128,
-	/*11128*/ uint16(xSetOp), uint16(SAR),
-	/*11130*/ uint16(xArgRM64),
-	/*11131*/ uint16(xArg1),
-	/*11132*/ uint16(xMatch),
-	/*11133*/ uint16(xCondSlashR),
-	11142, // 0
-	11147, // 1
-	11152, // 2
-	11157, // 3
-	11162, // 4
-	11167, // 5
+	10956, // 7
+	/*10926*/ uint16(xSetOp), uint16(ROL),
+	/*10928*/ uint16(xArgRM8),
+	/*10929*/ uint16(xArg1),
+	/*10930*/ uint16(xMatch),
+	/*10931*/ uint16(xSetOp), uint16(ROR),
+	/*10933*/ uint16(xArgRM8),
+	/*10934*/ uint16(xArg1),
+	/*10935*/ uint16(xMatch),
+	/*10936*/ uint16(xSetOp), uint16(RCL),
+	/*10938*/ uint16(xArgRM8),
+	/*10939*/ uint16(xArg1),
+	/*10940*/ uint16(xMatch),
+	/*10941*/ uint16(xSetOp), uint16(RCR),
+	/*10943*/ uint16(xArgRM8),
+	/*10944*/ uint16(xArg1),
+	/*10945*/ uint16(xMatch),
+	/*10946*/ uint16(xSetOp), uint16(SHL),
+	/*10948*/ uint16(xArgRM8),
+	/*10949*/ uint16(xArg1),
+	/*10950*/ uint16(xMatch),
+	/*10951*/ uint16(xSetOp), uint16(SHR),
+	/*10953*/ uint16(xArgRM8),
+	/*10954*/ uint16(xArg1),
+	/*10955*/ uint16(xMatch),
+	/*10956*/ uint16(xSetOp), uint16(SAR),
+	/*10958*/ uint16(xArgRM8),
+	/*10959*/ uint16(xArg1),
+	/*10960*/ uint16(xMatch),
+	/*10961*/ uint16(xCondSlashR),
+	10970, // 0
+	10996, // 1
+	11022, // 2
+	11048, // 3
+	11074, // 4
+	11100, // 5
 	0,     // 6
-	11172, // 7
-	/*11142*/ uint16(xSetOp), uint16(ROL),
-	/*11144*/ uint16(xArgRM8),
-	/*11145*/ uint16(xArgCL),
-	/*11146*/ uint16(xMatch),
-	/*11147*/ uint16(xSetOp), uint16(ROR),
-	/*11149*/ uint16(xArgRM8),
-	/*11150*/ uint16(xArgCL),
+	11126, // 7
+	/*10970*/ uint16(xCondIs64), 10973, 10987,
+	/*10973*/ uint16(xCondDataSize), 10977, 10982, 0,
+	/*10977*/ uint16(xSetOp), uint16(ROL),
+	/*10979*/ uint16(xArgRM16),
+	/*10980*/ uint16(xArg1),
+	/*10981*/ uint16(xMatch),
+	/*10982*/ uint16(xSetOp), uint16(ROL),
+	/*10984*/ uint16(xArgRM32),
+	/*10985*/ uint16(xArg1),
+	/*10986*/ uint16(xMatch),
+	/*10987*/ uint16(xCondDataSize), 10977, 10982, 10991,
+	/*10991*/ uint16(xSetOp), uint16(ROL),
+	/*10993*/ uint16(xArgRM64),
+	/*10994*/ uint16(xArg1),
+	/*10995*/ uint16(xMatch),
+	/*10996*/ uint16(xCondIs64), 10999, 11013,
+	/*10999*/ uint16(xCondDataSize), 11003, 11008, 0,
+	/*11003*/ uint16(xSetOp), uint16(ROR),
+	/*11005*/ uint16(xArgRM16),
+	/*11006*/ uint16(xArg1),
+	/*11007*/ uint16(xMatch),
+	/*11008*/ uint16(xSetOp), uint16(ROR),
+	/*11010*/ uint16(xArgRM32),
+	/*11011*/ uint16(xArg1),
+	/*11012*/ uint16(xMatch),
+	/*11013*/ uint16(xCondDataSize), 11003, 11008, 11017,
+	/*11017*/ uint16(xSetOp), uint16(ROR),
+	/*11019*/ uint16(xArgRM64),
+	/*11020*/ uint16(xArg1),
+	/*11021*/ uint16(xMatch),
+	/*11022*/ uint16(xCondIs64), 11025, 11039,
+	/*11025*/ uint16(xCondDataSize), 11029, 11034, 0,
+	/*11029*/ uint16(xSetOp), uint16(RCL),
+	/*11031*/ uint16(xArgRM16),
+	/*11032*/ uint16(xArg1),
+	/*11033*/ uint16(xMatch),
+	/*11034*/ uint16(xSetOp), uint16(RCL),
+	/*11036*/ uint16(xArgRM32),
+	/*11037*/ uint16(xArg1),
+	/*11038*/ uint16(xMatch),
+	/*11039*/ uint16(xCondDataSize), 11029, 11034, 11043,
+	/*11043*/ uint16(xSetOp), uint16(RCL),
+	/*11045*/ uint16(xArgRM64),
+	/*11046*/ uint16(xArg1),
+	/*11047*/ uint16(xMatch),
+	/*11048*/ uint16(xCondIs64), 11051, 11065,
+	/*11051*/ uint16(xCondDataSize), 11055, 11060, 0,
+	/*11055*/ uint16(xSetOp), uint16(RCR),
+	/*11057*/ uint16(xArgRM16),
+	/*11058*/ uint16(xArg1),
+	/*11059*/ uint16(xMatch),
+	/*11060*/ uint16(xSetOp), uint16(RCR),
+	/*11062*/ uint16(xArgRM32),
+	/*11063*/ uint16(xArg1),
+	/*11064*/ uint16(xMatch),
+	/*11065*/ uint16(xCondDataSize), 11055, 11060, 11069,
+	/*11069*/ uint16(xSetOp), uint16(RCR),
+	/*11071*/ uint16(xArgRM64),
+	/*11072*/ uint16(xArg1),
+	/*11073*/ uint16(xMatch),
+	/*11074*/ uint16(xCondIs64), 11077, 11091,
+	/*11077*/ uint16(xCondDataSize), 11081, 11086, 0,
+	/*11081*/ uint16(xSetOp), uint16(SHL),
+	/*11083*/ uint16(xArgRM16),
+	/*11084*/ uint16(xArg1),
+	/*11085*/ uint16(xMatch),
+	/*11086*/ uint16(xSetOp), uint16(SHL),
+	/*11088*/ uint16(xArgRM32),
+	/*11089*/ uint16(xArg1),
+	/*11090*/ uint16(xMatch),
+	/*11091*/ uint16(xCondDataSize), 11081, 11086, 11095,
+	/*11095*/ uint16(xSetOp), uint16(SHL),
+	/*11097*/ uint16(xArgRM64),
+	/*11098*/ uint16(xArg1),
+	/*11099*/ uint16(xMatch),
+	/*11100*/ uint16(xCondIs64), 11103, 11117,
+	/*11103*/ uint16(xCondDataSize), 11107, 11112, 0,
+	/*11107*/ uint16(xSetOp), uint16(SHR),
+	/*11109*/ uint16(xArgRM16),
+	/*11110*/ uint16(xArg1),
+	/*11111*/ uint16(xMatch),
+	/*11112*/ uint16(xSetOp), uint16(SHR),
+	/*11114*/ uint16(xArgRM32),
+	/*11115*/ uint16(xArg1),
+	/*11116*/ uint16(xMatch),
+	/*11117*/ uint16(xCondDataSize), 11107, 11112, 11121,
+	/*11121*/ uint16(xSetOp), uint16(SHR),
+	/*11123*/ uint16(xArgRM64),
+	/*11124*/ uint16(xArg1),
+	/*11125*/ uint16(xMatch),
+	/*11126*/ uint16(xCondIs64), 11129, 11143,
+	/*11129*/ uint16(xCondDataSize), 11133, 11138, 0,
+	/*11133*/ uint16(xSetOp), uint16(SAR),
+	/*11135*/ uint16(xArgRM16),
+	/*11136*/ uint16(xArg1),
+	/*11137*/ uint16(xMatch),
+	/*11138*/ uint16(xSetOp), uint16(SAR),
+	/*11140*/ uint16(xArgRM32),
+	/*11141*/ uint16(xArg1),
+	/*11142*/ uint16(xMatch),
+	/*11143*/ uint16(xCondDataSize), 11133, 11138, 11147,
+	/*11147*/ uint16(xSetOp), uint16(SAR),
+	/*11149*/ uint16(xArgRM64),
+	/*11150*/ uint16(xArg1),
 	/*11151*/ uint16(xMatch),
-	/*11152*/ uint16(xSetOp), uint16(RCL),
-	/*11154*/ uint16(xArgRM8),
-	/*11155*/ uint16(xArgCL),
-	/*11156*/ uint16(xMatch),
-	/*11157*/ uint16(xSetOp), uint16(RCR),
-	/*11159*/ uint16(xArgRM8),
-	/*11160*/ uint16(xArgCL),
-	/*11161*/ uint16(xMatch),
-	/*11162*/ uint16(xSetOp), uint16(SHL),
-	/*11164*/ uint16(xArgRM8),
-	/*11165*/ uint16(xArgCL),
-	/*11166*/ uint16(xMatch),
-	/*11167*/ uint16(xSetOp), uint16(SHR),
-	/*11169*/ uint16(xArgRM8),
-	/*11170*/ uint16(xArgCL),
-	/*11171*/ uint16(xMatch),
-	/*11172*/ uint16(xSetOp), uint16(SAR),
-	/*11174*/ uint16(xArgRM8),
-	/*11175*/ uint16(xArgCL),
-	/*11176*/ uint16(xMatch),
-	/*11177*/ uint16(xCondSlashR),
-	11186, // 0
-	11212, // 1
-	11238, // 2
-	11264, // 3
-	11290, // 4
-	11316, // 5
+	/*11152*/ uint16(xCondSlashR),
+	11161, // 0
+	11166, // 1
+	11171, // 2
+	11176, // 3
+	11181, // 4
+	11186, // 5
 	0,     // 6
-	11342, // 7
-	/*11186*/ uint16(xCondIs64), 11189, 11203,
-	/*11189*/ uint16(xCondDataSize), 11193, 11198, 0,
-	/*11193*/ uint16(xSetOp), uint16(ROL),
-	/*11195*/ uint16(xArgRM16),
-	/*11196*/ uint16(xArgCL),
-	/*11197*/ uint16(xMatch),
-	/*11198*/ uint16(xSetOp), uint16(ROL),
-	/*11200*/ uint16(xArgRM32),
-	/*11201*/ uint16(xArgCL),
-	/*11202*/ uint16(xMatch),
-	/*11203*/ uint16(xCondDataSize), 11193, 11198, 11207,
-	/*11207*/ uint16(xSetOp), uint16(ROL),
-	/*11209*/ uint16(xArgRM64),
-	/*11210*/ uint16(xArgCL),
-	/*11211*/ uint16(xMatch),
-	/*11212*/ uint16(xCondIs64), 11215, 11229,
-	/*11215*/ uint16(xCondDataSize), 11219, 11224, 0,
-	/*11219*/ uint16(xSetOp), uint16(ROR),
-	/*11221*/ uint16(xArgRM16),
-	/*11222*/ uint16(xArgCL),
-	/*11223*/ uint16(xMatch),
-	/*11224*/ uint16(xSetOp), uint16(ROR),
-	/*11226*/ uint16(xArgRM32),
-	/*11227*/ uint16(xArgCL),
-	/*11228*/ uint16(xMatch),
-	/*11229*/ uint16(xCondDataSize), 11219, 11224, 11233,
-	/*11233*/ uint16(xSetOp), uint16(ROR),
-	/*11235*/ uint16(xArgRM64),
-	/*11236*/ uint16(xArgCL),
-	/*11237*/ uint16(xMatch),
-	/*11238*/ uint16(xCondIs64), 11241, 11255,
-	/*11241*/ uint16(xCondDataSize), 11245, 11250, 0,
-	/*11245*/ uint16(xSetOp), uint16(RCL),
-	/*11247*/ uint16(xArgRM16),
-	/*11248*/ uint16(xArgCL),
-	/*11249*/ uint16(xMatch),
-	/*11250*/ uint16(xSetOp), uint16(RCL),
-	/*11252*/ uint16(xArgRM32),
-	/*11253*/ uint16(xArgCL),
-	/*11254*/ uint16(xMatch),
-	/*11255*/ uint16(xCondDataSize), 11245, 11250, 11259,
-	/*11259*/ uint16(xSetOp), uint16(RCL),
-	/*11261*/ uint16(xArgRM64),
-	/*11262*/ uint16(xArgCL),
-	/*11263*/ uint16(xMatch),
-	/*11264*/ uint16(xCondIs64), 11267, 11281,
-	/*11267*/ uint16(xCondDataSize), 11271, 11276, 0,
-	/*11271*/ uint16(xSetOp), uint16(RCR),
-	/*11273*/ uint16(xArgRM16),
-	/*11274*/ uint16(xArgCL),
-	/*11275*/ uint16(xMatch),
-	/*11276*/ uint16(xSetOp), uint16(RCR),
-	/*11278*/ uint16(xArgRM32),
-	/*11279*/ uint16(xArgCL),
-	/*11280*/ uint16(xMatch),
-	/*11281*/ uint16(xCondDataSize), 11271, 11276, 11285,
-	/*11285*/ uint16(xSetOp), uint16(RCR),
-	/*11287*/ uint16(xArgRM64),
-	/*11288*/ uint16(xArgCL),
-	/*11289*/ uint16(xMatch),
-	/*11290*/ uint16(xCondIs64), 11293, 11307,
-	/*11293*/ uint16(xCondDataSize), 11297, 11302, 0,
-	/*11297*/ uint16(xSetOp), uint16(SHL),
-	/*11299*/ uint16(xArgRM16),
-	/*11300*/ uint16(xArgCL),
-	/*11301*/ uint16(xMatch),
-	/*11302*/ uint16(xSetOp), uint16(SHL),
-	/*11304*/ uint16(xArgRM32),
-	/*11305*/ uint16(xArgCL),
-	/*11306*/ uint16(xMatch),
-	/*11307*/ uint16(xCondDataSize), 11297, 11302, 11311,
-	/*11311*/ uint16(xSetOp), uint16(SHL),
-	/*11313*/ uint16(xArgRM64),
-	/*11314*/ uint16(xArgCL),
-	/*11315*/ uint16(xMatch),
-	/*11316*/ uint16(xCondIs64), 11319, 11333,
-	/*11319*/ uint16(xCondDataSize), 11323, 11328, 0,
-	/*11323*/ uint16(xSetOp), uint16(SHR),
-	/*11325*/ uint16(xArgRM16),
-	/*11326*/ uint16(xArgCL),
-	/*11327*/ uint16(xMatch),
-	/*11328*/ uint16(xSetOp), uint16(SHR),
-	/*11330*/ uint16(xArgRM32),
-	/*11331*/ uint16(xArgCL),
-	/*11332*/ uint16(xMatch),
-	/*11333*/ uint16(xCondDataSize), 11323, 11328, 11337,
-	/*11337*/ uint16(xSetOp), uint16(SHR),
-	/*11339*/ uint16(xArgRM64),
-	/*11340*/ uint16(xArgCL),
-	/*11341*/ uint16(xMatch),
-	/*11342*/ uint16(xCondIs64), 11345, 11359,
-	/*11345*/ uint16(xCondDataSize), 11349, 11354, 0,
-	/*11349*/ uint16(xSetOp), uint16(SAR),
-	/*11351*/ uint16(xArgRM16),
-	/*11352*/ uint16(xArgCL),
-	/*11353*/ uint16(xMatch),
-	/*11354*/ uint16(xSetOp), uint16(SAR),
-	/*11356*/ uint16(xArgRM32),
-	/*11357*/ uint16(xArgCL),
-	/*11358*/ uint16(xMatch),
-	/*11359*/ uint16(xCondDataSize), 11349, 11354, 11363,
-	/*11363*/ uint16(xSetOp), uint16(SAR),
-	/*11365*/ uint16(xArgRM64),
-	/*11366*/ uint16(xArgCL),
-	/*11367*/ uint16(xMatch),
-	/*11368*/ uint16(xCondIs64), 11371, 0,
-	/*11371*/ uint16(xSetOp), uint16(AAM),
-	/*11373*/ uint16(xReadIb),
-	/*11374*/ uint16(xArgImm8u),
-	/*11375*/ uint16(xMatch),
-	/*11376*/ uint16(xCondIs64), 11379, 0,
-	/*11379*/ uint16(xSetOp), uint16(AAD),
-	/*11381*/ uint16(xReadIb),
-	/*11382*/ uint16(xArgImm8u),
-	/*11383*/ uint16(xMatch),
-	/*11384*/ uint16(xCondIs64), 11387, 11390,
-	/*11387*/ uint16(xSetOp), uint16(XLATB),
-	/*11389*/ uint16(xMatch),
-	/*11390*/ uint16(xCondDataSize), 11387, 11387, 11394,
-	/*11394*/ uint16(xSetOp), uint16(XLATB),
-	/*11396*/ uint16(xMatch),
-	/*11397*/ uint16(xCondByte), 64,
-	0xc0, 11568,
-	0xc1, 11568,
-	0xc2, 11568,
-	0xc3, 11568,
-	0xc4, 11568,
-	0xc5, 11568,
-	0xc6, 11568,
-	0xc7, 11568,
-	0xc8, 11573,
-	0xc9, 11573,
-	0xca, 11573,
-	0xcb, 11573,
-	0xcc, 11573,
-	0xcd, 11573,
-	0xce, 11573,
-	0xcf, 11573,
-	0xd0, 11578,
-	0xd1, 11578,
-	0xd2, 11578,
-	0xd3, 11578,
-	0xd4, 11578,
-	0xd5, 11578,
-	0xd6, 11578,
-	0xd7, 11578,
-	0xd8, 11582,
-	0xd9, 11582,
-	0xda, 11582,
-	0xdb, 11582,
-	0xdc, 11582,
-	0xdd, 11582,
-	0xde, 11582,
-	0xdf, 11582,
-	0xe0, 11586,
-	0xe1, 11586,
-	0xe2, 11586,
-	0xe3, 11586,
-	0xe4, 11586,
-	0xe5, 11586,
-	0xe6, 11586,
-	0xe7, 11586,
-	0xe8, 11591,
-	0xe9, 11591,
-	0xea, 11591,
-	0xeb, 11591,
-	0xec, 11591,
-	0xed, 11591,
-	0xee, 11591,
-	0xef, 11591,
-	0xf0, 11596,
-	0xf1, 11596,
-	0xf2, 11596,
-	0xf3, 11596,
-	0xf4, 11596,
-	0xf5, 11596,
-	0xf6, 11596,
-	0xf7, 11596,
-	0xf8, 11601,
-	0xf9, 11601,
-	0xfa, 11601,
-	0xfb, 11601,
-	0xfc, 11601,
-	0xfd, 11601,
-	0xfe, 11601,
-	0xff, 11601,
-	/*11527*/ uint16(xCondSlashR),
-	11536, // 0
-	11540, // 1
-	11544, // 2
-	11548, // 3
-	11552, // 4
-	11556, // 5
-	11560, // 6
-	11564, // 7
-	/*11536*/ uint16(xSetOp), uint16(FADD),
-	/*11538*/ uint16(xArgM32fp),
-	/*11539*/ uint16(xMatch),
-	/*11540*/ uint16(xSetOp), uint16(FMUL),
-	/*11542*/ uint16(xArgM32fp),
-	/*11543*/ uint16(xMatch),
-	/*11544*/ uint16(xSetOp), uint16(FCOM),
-	/*11546*/ uint16(xArgM32fp),
-	/*11547*/ uint16(xMatch),
-	/*11548*/ uint16(xSetOp), uint16(FCOMP),
-	/*11550*/ uint16(xArgM32fp),
-	/*11551*/ uint16(xMatch),
-	/*11552*/ uint16(xSetOp), uint16(FSUB),
-	/*11554*/ uint16(xArgM32fp),
-	/*11555*/ uint16(xMatch),
-	/*11556*/ uint16(xSetOp), uint16(FSUBR),
-	/*11558*/ uint16(xArgM32fp),
-	/*11559*/ uint16(xMatch),
-	/*11560*/ uint16(xSetOp), uint16(FDIV),
-	/*11562*/ uint16(xArgM32fp),
-	/*11563*/ uint16(xMatch),
-	/*11564*/ uint16(xSetOp), uint16(FDIVR),
-	/*11566*/ uint16(xArgM32fp),
-	/*11567*/ uint16(xMatch),
-	/*11568*/ uint16(xSetOp), uint16(FADD),
-	/*11570*/ uint16(xArgST),
-	/*11571*/ uint16(xArgSTi),
-	/*11572*/ uint16(xMatch),
-	/*11573*/ uint16(xSetOp), uint16(FMUL),
-	/*11575*/ uint16(xArgST),
-	/*11576*/ uint16(xArgSTi),
-	/*11577*/ uint16(xMatch),
-	/*11578*/ uint16(xSetOp), uint16(FCOM),
-	/*11580*/ uint16(xArgSTi),
-	/*11581*/ uint16(xMatch),
-	/*11582*/ uint16(xSetOp), uint16(FCOMP),
-	/*11584*/ uint16(xArgSTi),
-	/*11585*/ uint16(xMatch),
-	/*11586*/ uint16(xSetOp), uint16(FSUB),
-	/*11588*/ uint16(xArgST),
-	/*11589*/ uint16(xArgSTi),
-	/*11590*/ uint16(xMatch),
-	/*11591*/ uint16(xSetOp), uint16(FSUBR),
-	/*11593*/ uint16(xArgST),
-	/*11594*/ uint16(xArgSTi),
-	/*11595*/ uint16(xMatch),
-	/*11596*/ uint16(xSetOp), uint16(FDIV),
-	/*11598*/ uint16(xArgST),
+	11191, // 7
+	/*11161*/ uint16(xSetOp), uint16(ROL),
+	/*11163*/ uint16(xArgRM8),
+	/*11164*/ uint16(xArgCL),
+	/*11165*/ uint16(xMatch),
+	/*11166*/ uint16(xSetOp), uint16(ROR),
+	/*11168*/ uint16(xArgRM8),
+	/*11169*/ uint16(xArgCL),
+	/*11170*/ uint16(xMatch),
+	/*11171*/ uint16(xSetOp), uint16(RCL),
+	/*11173*/ uint16(xArgRM8),
+	/*11174*/ uint16(xArgCL),
+	/*11175*/ uint16(xMatch),
+	/*11176*/ uint16(xSetOp), uint16(RCR),
+	/*11178*/ uint16(xArgRM8),
+	/*11179*/ uint16(xArgCL),
+	/*11180*/ uint16(xMatch),
+	/*11181*/ uint16(xSetOp), uint16(SHL),
+	/*11183*/ uint16(xArgRM8),
+	/*11184*/ uint16(xArgCL),
+	/*11185*/ uint16(xMatch),
+	/*11186*/ uint16(xSetOp), uint16(SHR),
+	/*11188*/ uint16(xArgRM8),
+	/*11189*/ uint16(xArgCL),
+	/*11190*/ uint16(xMatch),
+	/*11191*/ uint16(xSetOp), uint16(SAR),
+	/*11193*/ uint16(xArgRM8),
+	/*11194*/ uint16(xArgCL),
+	/*11195*/ uint16(xMatch),
+	/*11196*/ uint16(xCondSlashR),
+	11205, // 0
+	11231, // 1
+	11257, // 2
+	11283, // 3
+	11309, // 4
+	11335, // 5
+	0,     // 6
+	11361, // 7
+	/*11205*/ uint16(xCondIs64), 11208, 11222,
+	/*11208*/ uint16(xCondDataSize), 11212, 11217, 0,
+	/*11212*/ uint16(xSetOp), uint16(ROL),
+	/*11214*/ uint16(xArgRM16),
+	/*11215*/ uint16(xArgCL),
+	/*11216*/ uint16(xMatch),
+	/*11217*/ uint16(xSetOp), uint16(ROL),
+	/*11219*/ uint16(xArgRM32),
+	/*11220*/ uint16(xArgCL),
+	/*11221*/ uint16(xMatch),
+	/*11222*/ uint16(xCondDataSize), 11212, 11217, 11226,
+	/*11226*/ uint16(xSetOp), uint16(ROL),
+	/*11228*/ uint16(xArgRM64),
+	/*11229*/ uint16(xArgCL),
+	/*11230*/ uint16(xMatch),
+	/*11231*/ uint16(xCondIs64), 11234, 11248,
+	/*11234*/ uint16(xCondDataSize), 11238, 11243, 0,
+	/*11238*/ uint16(xSetOp), uint16(ROR),
+	/*11240*/ uint16(xArgRM16),
+	/*11241*/ uint16(xArgCL),
+	/*11242*/ uint16(xMatch),
+	/*11243*/ uint16(xSetOp), uint16(ROR),
+	/*11245*/ uint16(xArgRM32),
+	/*11246*/ uint16(xArgCL),
+	/*11247*/ uint16(xMatch),
+	/*11248*/ uint16(xCondDataSize), 11238, 11243, 11252,
+	/*11252*/ uint16(xSetOp), uint16(ROR),
+	/*11254*/ uint16(xArgRM64),
+	/*11255*/ uint16(xArgCL),
+	/*11256*/ uint16(xMatch),
+	/*11257*/ uint16(xCondIs64), 11260, 11274,
+	/*11260*/ uint16(xCondDataSize), 11264, 11269, 0,
+	/*11264*/ uint16(xSetOp), uint16(RCL),
+	/*11266*/ uint16(xArgRM16),
+	/*11267*/ uint16(xArgCL),
+	/*11268*/ uint16(xMatch),
+	/*11269*/ uint16(xSetOp), uint16(RCL),
+	/*11271*/ uint16(xArgRM32),
+	/*11272*/ uint16(xArgCL),
+	/*11273*/ uint16(xMatch),
+	/*11274*/ uint16(xCondDataSize), 11264, 11269, 11278,
+	/*11278*/ uint16(xSetOp), uint16(RCL),
+	/*11280*/ uint16(xArgRM64),
+	/*11281*/ uint16(xArgCL),
+	/*11282*/ uint16(xMatch),
+	/*11283*/ uint16(xCondIs64), 11286, 11300,
+	/*11286*/ uint16(xCondDataSize), 11290, 11295, 0,
+	/*11290*/ uint16(xSetOp), uint16(RCR),
+	/*11292*/ uint16(xArgRM16),
+	/*11293*/ uint16(xArgCL),
+	/*11294*/ uint16(xMatch),
+	/*11295*/ uint16(xSetOp), uint16(RCR),
+	/*11297*/ uint16(xArgRM32),
+	/*11298*/ uint16(xArgCL),
+	/*11299*/ uint16(xMatch),
+	/*11300*/ uint16(xCondDataSize), 11290, 11295, 11304,
+	/*11304*/ uint16(xSetOp), uint16(RCR),
+	/*11306*/ uint16(xArgRM64),
+	/*11307*/ uint16(xArgCL),
+	/*11308*/ uint16(xMatch),
+	/*11309*/ uint16(xCondIs64), 11312, 11326,
+	/*11312*/ uint16(xCondDataSize), 11316, 11321, 0,
+	/*11316*/ uint16(xSetOp), uint16(SHL),
+	/*11318*/ uint16(xArgRM16),
+	/*11319*/ uint16(xArgCL),
+	/*11320*/ uint16(xMatch),
+	/*11321*/ uint16(xSetOp), uint16(SHL),
+	/*11323*/ uint16(xArgRM32),
+	/*11324*/ uint16(xArgCL),
+	/*11325*/ uint16(xMatch),
+	/*11326*/ uint16(xCondDataSize), 11316, 11321, 11330,
+	/*11330*/ uint16(xSetOp), uint16(SHL),
+	/*11332*/ uint16(xArgRM64),
+	/*11333*/ uint16(xArgCL),
+	/*11334*/ uint16(xMatch),
+	/*11335*/ uint16(xCondIs64), 11338, 11352,
+	/*11338*/ uint16(xCondDataSize), 11342, 11347, 0,
+	/*11342*/ uint16(xSetOp), uint16(SHR),
+	/*11344*/ uint16(xArgRM16),
+	/*11345*/ uint16(xArgCL),
+	/*11346*/ uint16(xMatch),
+	/*11347*/ uint16(xSetOp), uint16(SHR),
+	/*11349*/ uint16(xArgRM32),
+	/*11350*/ uint16(xArgCL),
+	/*11351*/ uint16(xMatch),
+	/*11352*/ uint16(xCondDataSize), 11342, 11347, 11356,
+	/*11356*/ uint16(xSetOp), uint16(SHR),
+	/*11358*/ uint16(xArgRM64),
+	/*11359*/ uint16(xArgCL),
+	/*11360*/ uint16(xMatch),
+	/*11361*/ uint16(xCondIs64), 11364, 11378,
+	/*11364*/ uint16(xCondDataSize), 11368, 11373, 0,
+	/*11368*/ uint16(xSetOp), uint16(SAR),
+	/*11370*/ uint16(xArgRM16),
+	/*11371*/ uint16(xArgCL),
+	/*11372*/ uint16(xMatch),
+	/*11373*/ uint16(xSetOp), uint16(SAR),
+	/*11375*/ uint16(xArgRM32),
+	/*11376*/ uint16(xArgCL),
+	/*11377*/ uint16(xMatch),
+	/*11378*/ uint16(xCondDataSize), 11368, 11373, 11382,
+	/*11382*/ uint16(xSetOp), uint16(SAR),
+	/*11384*/ uint16(xArgRM64),
+	/*11385*/ uint16(xArgCL),
+	/*11386*/ uint16(xMatch),
+	/*11387*/ uint16(xCondIs64), 11390, 0,
+	/*11390*/ uint16(xSetOp), uint16(AAM),
+	/*11392*/ uint16(xReadIb),
+	/*11393*/ uint16(xArgImm8u),
+	/*11394*/ uint16(xMatch),
+	/*11395*/ uint16(xCondIs64), 11398, 0,
+	/*11398*/ uint16(xSetOp), uint16(AAD),
+	/*11400*/ uint16(xReadIb),
+	/*11401*/ uint16(xArgImm8u),
+	/*11402*/ uint16(xMatch),
+	/*11403*/ uint16(xCondIs64), 11406, 11409,
+	/*11406*/ uint16(xSetOp), uint16(XLATB),
+	/*11408*/ uint16(xMatch),
+	/*11409*/ uint16(xCondDataSize), 11406, 11406, 11413,
+	/*11413*/ uint16(xSetOp), uint16(XLATB),
+	/*11415*/ uint16(xMatch),
+	/*11416*/ uint16(xCondByte), 64,
+	0xc0, 11587,
+	0xc1, 11587,
+	0xc2, 11587,
+	0xc3, 11587,
+	0xc4, 11587,
+	0xc5, 11587,
+	0xc6, 11587,
+	0xc7, 11587,
+	0xc8, 11592,
+	0xc9, 11592,
+	0xca, 11592,
+	0xcb, 11592,
+	0xcc, 11592,
+	0xcd, 11592,
+	0xce, 11592,
+	0xcf, 11592,
+	0xd0, 11597,
+	0xd1, 11597,
+	0xd2, 11597,
+	0xd3, 11597,
+	0xd4, 11597,
+	0xd5, 11597,
+	0xd6, 11597,
+	0xd7, 11597,
+	0xd8, 11601,
+	0xd9, 11601,
+	0xda, 11601,
+	0xdb, 11601,
+	0xdc, 11601,
+	0xdd, 11601,
+	0xde, 11601,
+	0xdf, 11601,
+	0xe0, 11605,
+	0xe1, 11605,
+	0xe2, 11605,
+	0xe3, 11605,
+	0xe4, 11605,
+	0xe5, 11605,
+	0xe6, 11605,
+	0xe7, 11605,
+	0xe8, 11610,
+	0xe9, 11610,
+	0xea, 11610,
+	0xeb, 11610,
+	0xec, 11610,
+	0xed, 11610,
+	0xee, 11610,
+	0xef, 11610,
+	0xf0, 11615,
+	0xf1, 11615,
+	0xf2, 11615,
+	0xf3, 11615,
+	0xf4, 11615,
+	0xf5, 11615,
+	0xf6, 11615,
+	0xf7, 11615,
+	0xf8, 11620,
+	0xf9, 11620,
+	0xfa, 11620,
+	0xfb, 11620,
+	0xfc, 11620,
+	0xfd, 11620,
+	0xfe, 11620,
+	0xff, 11620,
+	/*11546*/ uint16(xCondSlashR),
+	11555, // 0
+	11559, // 1
+	11563, // 2
+	11567, // 3
+	11571, // 4
+	11575, // 5
+	11579, // 6
+	11583, // 7
+	/*11555*/ uint16(xSetOp), uint16(FADD),
+	/*11557*/ uint16(xArgM32fp),
+	/*11558*/ uint16(xMatch),
+	/*11559*/ uint16(xSetOp), uint16(FMUL),
+	/*11561*/ uint16(xArgM32fp),
+	/*11562*/ uint16(xMatch),
+	/*11563*/ uint16(xSetOp), uint16(FCOM),
+	/*11565*/ uint16(xArgM32fp),
+	/*11566*/ uint16(xMatch),
+	/*11567*/ uint16(xSetOp), uint16(FCOMP),
+	/*11569*/ uint16(xArgM32fp),
+	/*11570*/ uint16(xMatch),
+	/*11571*/ uint16(xSetOp), uint16(FSUB),
+	/*11573*/ uint16(xArgM32fp),
+	/*11574*/ uint16(xMatch),
+	/*11575*/ uint16(xSetOp), uint16(FSUBR),
+	/*11577*/ uint16(xArgM32fp),
+	/*11578*/ uint16(xMatch),
+	/*11579*/ uint16(xSetOp), uint16(FDIV),
+	/*11581*/ uint16(xArgM32fp),
+	/*11582*/ uint16(xMatch),
+	/*11583*/ uint16(xSetOp), uint16(FDIVR),
+	/*11585*/ uint16(xArgM32fp),
+	/*11586*/ uint16(xMatch),
+	/*11587*/ uint16(xSetOp), uint16(FADD),
+	/*11589*/ uint16(xArgST),
+	/*11590*/ uint16(xArgSTi),
+	/*11591*/ uint16(xMatch),
+	/*11592*/ uint16(xSetOp), uint16(FMUL),
+	/*11594*/ uint16(xArgST),
+	/*11595*/ uint16(xArgSTi),
+	/*11596*/ uint16(xMatch),
+	/*11597*/ uint16(xSetOp), uint16(FCOM),
 	/*11599*/ uint16(xArgSTi),
 	/*11600*/ uint16(xMatch),
-	/*11601*/ uint16(xSetOp), uint16(FDIVR),
-	/*11603*/ uint16(xArgST),
-	/*11604*/ uint16(xArgSTi),
-	/*11605*/ uint16(xMatch),
-	/*11606*/ uint16(xCondByte), 44,
-	0xc0, 11733,
-	0xc1, 11733,
-	0xc2, 11733,
-	0xc3, 11733,
-	0xc4, 11733,
-	0xc5, 11733,
-	0xc6, 11733,
-	0xc7, 11733,
-	0xc8, 11737,
-	0xc9, 11737,
-	0xca, 11737,
-	0xcb, 11737,
-	0xcc, 11737,
-	0xcd, 11737,
-	0xce, 11737,
-	0xcf, 11737,
-	0xD0, 11741,
-	0xE0, 11744,
-	0xE1, 11747,
-	0xE4, 11750,
-	0xE5, 11753,
-	0xE8, 11756,
-	0xE9, 11759,
-	0xEA, 11762,
-	0xEB, 11765,
-	0xEC, 11768,
-	0xED, 11771,
-	0xEE, 11774,
-	0xF0, 11777,
-	0xF1, 11780,
-	0xF2, 11783,
-	0xF3, 11786,
-	0xF4, 11789,
-	0xF5, 11792,
-	0xF6, 11795,
-	0xF7, 11798,
-	0xF8, 11801,
-	0xF9, 11804,
-	0xFA, 11807,
-	0xFB, 11810,
-	0xFC, 11813,
-	0xFD, 11816,
-	0xFE, 11819,
-	0xFF, 11822,
-	/*11696*/ uint16(xCondSlashR),
-	11705, // 0
+	/*11601*/ uint16(xSetOp), uint16(FCOMP),
+	/*11603*/ uint16(xArgSTi),
+	/*11604*/ uint16(xMatch),
+	/*11605*/ uint16(xSetOp), uint16(FSUB),
+	/*11607*/ uint16(xArgST),
+	/*11608*/ uint16(xArgSTi),
+	/*11609*/ uint16(xMatch),
+	/*11610*/ uint16(xSetOp), uint16(FSUBR),
+	/*11612*/ uint16(xArgST),
+	/*11613*/ uint16(xArgSTi),
+	/*11614*/ uint16(xMatch),
+	/*11615*/ uint16(xSetOp), uint16(FDIV),
+	/*11617*/ uint16(xArgST),
+	/*11618*/ uint16(xArgSTi),
+	/*11619*/ uint16(xMatch),
+	/*11620*/ uint16(xSetOp), uint16(FDIVR),
+	/*11622*/ uint16(xArgST),
+	/*11623*/ uint16(xArgSTi),
+	/*11624*/ uint16(xMatch),
+	/*11625*/ uint16(xCondByte), 44,
+	0xc0, 11752,
+	0xc1, 11752,
+	0xc2, 11752,
+	0xc3, 11752,
+	0xc4, 11752,
+	0xc5, 11752,
+	0xc6, 11752,
+	0xc7, 11752,
+	0xc8, 11756,
+	0xc9, 11756,
+	0xca, 11756,
+	0xcb, 11756,
+	0xcc, 11756,
+	0xcd, 11756,
+	0xce, 11756,
+	0xcf, 11756,
+	0xD0, 11760,
+	0xE0, 11763,
+	0xE1, 11766,
+	0xE4, 11769,
+	0xE5, 11772,
+	0xE8, 11775,
+	0xE9, 11778,
+	0xEA, 11781,
+	0xEB, 11784,
+	0xEC, 11787,
+	0xED, 11790,
+	0xEE, 11793,
+	0xF0, 11796,
+	0xF1, 11799,
+	0xF2, 11802,
+	0xF3, 11805,
+	0xF4, 11808,
+	0xF5, 11811,
+	0xF6, 11814,
+	0xF7, 11817,
+	0xF8, 11820,
+	0xF9, 11823,
+	0xFA, 11826,
+	0xFB, 11829,
+	0xFC, 11832,
+	0xFD, 11835,
+	0xFE, 11838,
+	0xFF, 11841,
+	/*11715*/ uint16(xCondSlashR),
+	11724, // 0
 	0,     // 1
-	11709, // 2
-	11713, // 3
-	11717, // 4
-	11721, // 5
-	11725, // 6
-	11729, // 7
-	/*11705*/ uint16(xSetOp), uint16(FLD),
-	/*11707*/ uint16(xArgM32fp),
-	/*11708*/ uint16(xMatch),
-	/*11709*/ uint16(xSetOp), uint16(FST),
-	/*11711*/ uint16(xArgM32fp),
-	/*11712*/ uint16(xMatch),
-	/*11713*/ uint16(xSetOp), uint16(FSTP),
-	/*11715*/ uint16(xArgM32fp),
-	/*11716*/ uint16(xMatch),
-	/*11717*/ uint16(xSetOp), uint16(FLDENV),
-	/*11719*/ uint16(xArgM1428byte),
-	/*11720*/ uint16(xMatch),
-	/*11721*/ uint16(xSetOp), uint16(FLDCW),
-	/*11723*/ uint16(xArgM2byte),
-	/*11724*/ uint16(xMatch),
-	/*11725*/ uint16(xSetOp), uint16(FNSTENV),
-	/*11727*/ uint16(xArgM1428byte),
-	/*11728*/ uint16(xMatch),
-	/*11729*/ uint16(xSetOp), uint16(FNSTCW),
-	/*11731*/ uint16(xArgM2byte),
-	/*11732*/ uint16(xMatch),
-	/*11733*/ uint16(xSetOp), uint16(FLD),
-	/*11735*/ uint16(xArgSTi),
-	/*11736*/ uint16(xMatch),
-	/*11737*/ uint16(xSetOp), uint16(FXCH),
-	/*11739*/ uint16(xArgSTi),
-	/*11740*/ uint16(xMatch),
-	/*11741*/ uint16(xSetOp), uint16(FNOP),
+	11728, // 2
+	11732, // 3
+	11736, // 4
+	11740, // 5
+	11744, // 6
+	11748, // 7
+	/*11724*/ uint16(xSetOp), uint16(FLD),
+	/*11726*/ uint16(xArgM32fp),
+	/*11727*/ uint16(xMatch),
+	/*11728*/ uint16(xSetOp), uint16(FST),
+	/*11730*/ uint16(xArgM32fp),
+	/*11731*/ uint16(xMatch),
+	/*11732*/ uint16(xSetOp), uint16(FSTP),
+	/*11734*/ uint16(xArgM32fp),
+	/*11735*/ uint16(xMatch),
+	/*11736*/ uint16(xSetOp), uint16(FLDENV),
+	/*11738*/ uint16(xArgM1428byte),
+	/*11739*/ uint16(xMatch),
+	/*11740*/ uint16(xSetOp), uint16(FLDCW),
+	/*11742*/ uint16(xArgM2byte),
 	/*11743*/ uint16(xMatch),
-	/*11744*/ uint16(xSetOp), uint16(FCHS),
-	/*11746*/ uint16(xMatch),
-	/*11747*/ uint16(xSetOp), uint16(FABS),
-	/*11749*/ uint16(xMatch),
-	/*11750*/ uint16(xSetOp), uint16(FTST),
-	/*11752*/ uint16(xMatch),
-	/*11753*/ uint16(xSetOp), uint16(FXAM),
+	/*11744*/ uint16(xSetOp), uint16(FNSTENV),
+	/*11746*/ uint16(xArgM1428byte),
+	/*11747*/ uint16(xMatch),
+	/*11748*/ uint16(xSetOp), uint16(FNSTCW),
+	/*11750*/ uint16(xArgM2byte),
+	/*11751*/ uint16(xMatch),
+	/*11752*/ uint16(xSetOp), uint16(FLD),
+	/*11754*/ uint16(xArgSTi),
 	/*11755*/ uint16(xMatch),
-	/*11756*/ uint16(xSetOp), uint16(FLD1),
-	/*11758*/ uint16(xMatch),
-	/*11759*/ uint16(xSetOp), uint16(FLDL2T),
-	/*11761*/ uint16(xMatch),
-	/*11762*/ uint16(xSetOp), uint16(FLDL2E),
-	/*11764*/ uint16(xMatch),
-	/*11765*/ uint16(xSetOp), uint16(FLDPI),
-	/*11767*/ uint16(xMatch),
-	/*11768*/ uint16(xSetOp), uint16(FLDLG2),
-	/*11770*/ uint16(xMatch),
-	/*11771*/ uint16(xSetOp), uint16(FLDLN2),
-	/*11773*/ uint16(xMatch),
-	/*11774*/ uint16(xSetOp), uint16(FLDZ),
-	/*11776*/ uint16(xMatch),
-	/*11777*/ uint16(xSetOp), uint16(F2XM1),
-	/*11779*/ uint16(xMatch),
-	/*11780*/ uint16(xSetOp), uint16(FYL2X),
-	/*11782*/ uint16(xMatch),
-	/*11783*/ uint16(xSetOp), uint16(FPTAN),
-	/*11785*/ uint16(xMatch),
-	/*11786*/ uint16(xSetOp), uint16(FPATAN),
-	/*11788*/ uint16(xMatch),
-	/*11789*/ uint16(xSetOp), uint16(FXTRACT),
-	/*11791*/ uint16(xMatch),
-	/*11792*/ uint16(xSetOp), uint16(FPREM1),
-	/*11794*/ uint16(xMatch),
-	/*11795*/ uint16(xSetOp), uint16(FDECSTP),
-	/*11797*/ uint16(xMatch),
-	/*11798*/ uint16(xSetOp), uint16(FINCSTP),
-	/*11800*/ uint16(xMatch),
-	/*11801*/ uint16(xSetOp), uint16(FPREM),
-	/*11803*/ uint16(xMatch),
-	/*11804*/ uint16(xSetOp), uint16(FYL2XP1),
-	/*11806*/ uint16(xMatch),
-	/*11807*/ uint16(xSetOp), uint16(FSQRT),
-	/*11809*/ uint16(xMatch),
-	/*11810*/ uint16(xSetOp), uint16(FSINCOS),
-	/*11812*/ uint16(xMatch),
-	/*11813*/ uint16(xSetOp), uint16(FRNDINT),
-	/*11815*/ uint16(xMatch),
-	/*11816*/ uint16(xSetOp), uint16(FSCALE),
-	/*11818*/ uint16(xMatch),
-	/*11819*/ uint16(xSetOp), uint16(FSIN),
-	/*11821*/ uint16(xMatch),
-	/*11822*/ uint16(xSetOp), uint16(FCOS),
-	/*11824*/ uint16(xMatch),
-	/*11825*/ uint16(xCondByte), 33,
-	0xc0, 11934,
-	0xc1, 11934,
-	0xc2, 11934,
-	0xc3, 11934,
-	0xc4, 11934,
-	0xc5, 11934,
-	0xc6, 11934,
-	0xc7, 11934,
-	0xc8, 11939,
-	0xc9, 11939,
-	0xca, 11939,
-	0xcb, 11939,
-	0xcc, 11939,
-	0xcd, 11939,
-	0xce, 11939,
-	0xcf, 11939,
-	0xd0, 11944,
-	0xd1, 11944,
-	0xd2, 11944,
-	0xd3, 11944,
-	0xd4, 11944,
-	0xd5, 11944,
-	0xd6, 11944,
-	0xd7, 11944,
-	0xd8, 11949,
-	0xd9, 11949,
-	0xda, 11949,
-	0xdb, 11949,
-	0xdc, 11949,
-	0xdd, 11949,
-	0xde, 11949,
-	0xdf, 11949,
-	0xE9, 11954,
-	/*11893*/ uint16(xCondSlashR),
-	11902, // 0
-	11906, // 1
-	11910, // 2
-	11914, // 3
-	11918, // 4
-	11922, // 5
-	11926, // 6
-	11930, // 7
-	/*11902*/ uint16(xSetOp), uint16(FIADD),
-	/*11904*/ uint16(xArgM32int),
-	/*11905*/ uint16(xMatch),
-	/*11906*/ uint16(xSetOp), uint16(FIMUL),
-	/*11908*/ uint16(xArgM32int),
-	/*11909*/ uint16(xMatch),
-	/*11910*/ uint16(xSetOp), uint16(FICOM),
-	/*11912*/ uint16(xArgM32int),
-	/*11913*/ uint16(xMatch),
-	/*11914*/ uint16(xSetOp), uint16(FICOMP),
-	/*11916*/ uint16(xArgM32int),
-	/*11917*/ uint16(xMatch),
-	/*11918*/ uint16(xSetOp), uint16(FISUB),
-	/*11920*/ uint16(xArgM32int),
-	/*11921*/ uint16(xMatch),
-	/*11922*/ uint16(xSetOp), uint16(FISUBR),
-	/*11924*/ uint16(xArgM32int),
-	/*11925*/ uint16(xMatch),
-	/*11926*/ uint16(xSetOp), uint16(FIDIV),
-	/*11928*/ uint16(xArgM32int),
-	/*11929*/ uint16(xMatch),
-	/*11930*/ uint16(xSetOp), uint16(FIDIVR),
-	/*11932*/ uint16(xArgM32int),
-	/*11933*/ uint16(xMatch),
-	/*11934*/ uint16(xSetOp), uint16(FCMOVB),
-	/*11936*/ uint16(xArgST),
-	/*11937*/ uint16(xArgSTi),
-	/*11938*/ uint16(xMatch),
-	/*11939*/ uint16(xSetOp), uint16(FCMOVE),
-	/*11941*/ uint16(xArgST),
-	/*11942*/ uint16(xArgSTi),
-	/*11943*/ uint16(xMatch),
-	/*11944*/ uint16(xSetOp), uint16(FCMOVBE),
-	/*11946*/ uint16(xArgST),
-	/*11947*/ uint16(xArgSTi),
+	/*11756*/ uint16(xSetOp), uint16(FXCH),
+	/*11758*/ uint16(xArgSTi),
+	/*11759*/ uint16(xMatch),
+	/*11760*/ uint16(xSetOp), uint16(FNOP),
+	/*11762*/ uint16(xMatch),
+	/*11763*/ uint16(xSetOp), uint16(FCHS),
+	/*11765*/ uint16(xMatch),
+	/*11766*/ uint16(xSetOp), uint16(FABS),
+	/*11768*/ uint16(xMatch),
+	/*11769*/ uint16(xSetOp), uint16(FTST),
+	/*11771*/ uint16(xMatch),
+	/*11772*/ uint16(xSetOp), uint16(FXAM),
+	/*11774*/ uint16(xMatch),
+	/*11775*/ uint16(xSetOp), uint16(FLD1),
+	/*11777*/ uint16(xMatch),
+	/*11778*/ uint16(xSetOp), uint16(FLDL2T),
+	/*11780*/ uint16(xMatch),
+	/*11781*/ uint16(xSetOp), uint16(FLDL2E),
+	/*11783*/ uint16(xMatch),
+	/*11784*/ uint16(xSetOp), uint16(FLDPI),
+	/*11786*/ uint16(xMatch),
+	/*11787*/ uint16(xSetOp), uint16(FLDLG2),
+	/*11789*/ uint16(xMatch),
+	/*11790*/ uint16(xSetOp), uint16(FLDLN2),
+	/*11792*/ uint16(xMatch),
+	/*11793*/ uint16(xSetOp), uint16(FLDZ),
+	/*11795*/ uint16(xMatch),
+	/*11796*/ uint16(xSetOp), uint16(F2XM1),
+	/*11798*/ uint16(xMatch),
+	/*11799*/ uint16(xSetOp), uint16(FYL2X),
+	/*11801*/ uint16(xMatch),
+	/*11802*/ uint16(xSetOp), uint16(FPTAN),
+	/*11804*/ uint16(xMatch),
+	/*11805*/ uint16(xSetOp), uint16(FPATAN),
+	/*11807*/ uint16(xMatch),
+	/*11808*/ uint16(xSetOp), uint16(FXTRACT),
+	/*11810*/ uint16(xMatch),
+	/*11811*/ uint16(xSetOp), uint16(FPREM1),
+	/*11813*/ uint16(xMatch),
+	/*11814*/ uint16(xSetOp), uint16(FDECSTP),
+	/*11816*/ uint16(xMatch),
+	/*11817*/ uint16(xSetOp), uint16(FINCSTP),
+	/*11819*/ uint16(xMatch),
+	/*11820*/ uint16(xSetOp), uint16(FPREM),
+	/*11822*/ uint16(xMatch),
+	/*11823*/ uint16(xSetOp), uint16(FYL2XP1),
+	/*11825*/ uint16(xMatch),
+	/*11826*/ uint16(xSetOp), uint16(FSQRT),
+	/*11828*/ uint16(xMatch),
+	/*11829*/ uint16(xSetOp), uint16(FSINCOS),
+	/*11831*/ uint16(xMatch),
+	/*11832*/ uint16(xSetOp), uint16(FRNDINT),
+	/*11834*/ uint16(xMatch),
+	/*11835*/ uint16(xSetOp), uint16(FSCALE),
+	/*11837*/ uint16(xMatch),
+	/*11838*/ uint16(xSetOp), uint16(FSIN),
+	/*11840*/ uint16(xMatch),
+	/*11841*/ uint16(xSetOp), uint16(FCOS),
+	/*11843*/ uint16(xMatch),
+	/*11844*/ uint16(xCondByte), 33,
+	0xc0, 11953,
+	0xc1, 11953,
+	0xc2, 11953,
+	0xc3, 11953,
+	0xc4, 11953,
+	0xc5, 11953,
+	0xc6, 11953,
+	0xc7, 11953,
+	0xc8, 11958,
+	0xc9, 11958,
+	0xca, 11958,
+	0xcb, 11958,
+	0xcc, 11958,
+	0xcd, 11958,
+	0xce, 11958,
+	0xcf, 11958,
+	0xd0, 11963,
+	0xd1, 11963,
+	0xd2, 11963,
+	0xd3, 11963,
+	0xd4, 11963,
+	0xd5, 11963,
+	0xd6, 11963,
+	0xd7, 11963,
+	0xd8, 11968,
+	0xd9, 11968,
+	0xda, 11968,
+	0xdb, 11968,
+	0xdc, 11968,
+	0xdd, 11968,
+	0xde, 11968,
+	0xdf, 11968,
+	0xE9, 11973,
+	/*11912*/ uint16(xCondSlashR),
+	11921, // 0
+	11925, // 1
+	11929, // 2
+	11933, // 3
+	11937, // 4
+	11941, // 5
+	11945, // 6
+	11949, // 7
+	/*11921*/ uint16(xSetOp), uint16(FIADD),
+	/*11923*/ uint16(xArgM32int),
+	/*11924*/ uint16(xMatch),
+	/*11925*/ uint16(xSetOp), uint16(FIMUL),
+	/*11927*/ uint16(xArgM32int),
+	/*11928*/ uint16(xMatch),
+	/*11929*/ uint16(xSetOp), uint16(FICOM),
+	/*11931*/ uint16(xArgM32int),
+	/*11932*/ uint16(xMatch),
+	/*11933*/ uint16(xSetOp), uint16(FICOMP),
+	/*11935*/ uint16(xArgM32int),
+	/*11936*/ uint16(xMatch),
+	/*11937*/ uint16(xSetOp), uint16(FISUB),
+	/*11939*/ uint16(xArgM32int),
+	/*11940*/ uint16(xMatch),
+	/*11941*/ uint16(xSetOp), uint16(FISUBR),
+	/*11943*/ uint16(xArgM32int),
+	/*11944*/ uint16(xMatch),
+	/*11945*/ uint16(xSetOp), uint16(FIDIV),
+	/*11947*/ uint16(xArgM32int),
 	/*11948*/ uint16(xMatch),
-	/*11949*/ uint16(xSetOp), uint16(FCMOVU),
-	/*11951*/ uint16(xArgST),
-	/*11952*/ uint16(xArgSTi),
-	/*11953*/ uint16(xMatch),
-	/*11954*/ uint16(xSetOp), uint16(FUCOMPP),
-	/*11956*/ uint16(xMatch),
-	/*11957*/ uint16(xCondByte), 50,
-	0xc0, 12092,
-	0xc1, 12092,
-	0xc2, 12092,
-	0xc3, 12092,
-	0xc4, 12092,
-	0xc5, 12092,
-	0xc6, 12092,
-	0xc7, 12092,
-	0xc8, 12097,
-	0xc9, 12097,
-	0xca, 12097,
-	0xcb, 12097,
-	0xcc, 12097,
-	0xcd, 12097,
-	0xce, 12097,
-	0xcf, 12097,
-	0xd0, 12102,
-	0xd1, 12102,
-	0xd2, 12102,
-	0xd3, 12102,
-	0xd4, 12102,
-	0xd5, 12102,
-	0xd6, 12102,
-	0xd7, 12102,
-	0xd8, 12107,
-	0xd9, 12107,
-	0xda, 12107,
-	0xdb, 12107,
-	0xdc, 12107,
-	0xdd, 12107,
-	0xde, 12107,
-	0xdf, 12107,
-	0xE2, 12112,
-	0xE3, 12115,
-	0xe8, 12118,
-	0xe9, 12118,
-	0xea, 12118,
-	0xeb, 12118,
-	0xec, 12118,
-	0xed, 12118,
-	0xee, 12118,
-	0xef, 12118,
-	0xf0, 12123,
-	0xf1, 12123,
-	0xf2, 12123,
-	0xf3, 12123,
-	0xf4, 12123,
-	0xf5, 12123,
-	0xf6, 12123,
-	0xf7, 12123,
-	/*12059*/ uint16(xCondSlashR),
-	12068, // 0
-	12072, // 1
-	12076, // 2
-	12080, // 3
+	/*11949*/ uint16(xSetOp), uint16(FIDIVR),
+	/*11951*/ uint16(xArgM32int),
+	/*11952*/ uint16(xMatch),
+	/*11953*/ uint16(xSetOp), uint16(FCMOVB),
+	/*11955*/ uint16(xArgST),
+	/*11956*/ uint16(xArgSTi),
+	/*11957*/ uint16(xMatch),
+	/*11958*/ uint16(xSetOp), uint16(FCMOVE),
+	/*11960*/ uint16(xArgST),
+	/*11961*/ uint16(xArgSTi),
+	/*11962*/ uint16(xMatch),
+	/*11963*/ uint16(xSetOp), uint16(FCMOVBE),
+	/*11965*/ uint16(xArgST),
+	/*11966*/ uint16(xArgSTi),
+	/*11967*/ uint16(xMatch),
+	/*11968*/ uint16(xSetOp), uint16(FCMOVU),
+	/*11970*/ uint16(xArgST),
+	/*11971*/ uint16(xArgSTi),
+	/*11972*/ uint16(xMatch),
+	/*11973*/ uint16(xSetOp), uint16(FUCOMPP),
+	/*11975*/ uint16(xMatch),
+	/*11976*/ uint16(xCondByte), 50,
+	0xc0, 12111,
+	0xc1, 12111,
+	0xc2, 12111,
+	0xc3, 12111,
+	0xc4, 12111,
+	0xc5, 12111,
+	0xc6, 12111,
+	0xc7, 12111,
+	0xc8, 12116,
+	0xc9, 12116,
+	0xca, 12116,
+	0xcb, 12116,
+	0xcc, 12116,
+	0xcd, 12116,
+	0xce, 12116,
+	0xcf, 12116,
+	0xd0, 12121,
+	0xd1, 12121,
+	0xd2, 12121,
+	0xd3, 12121,
+	0xd4, 12121,
+	0xd5, 12121,
+	0xd6, 12121,
+	0xd7, 12121,
+	0xd8, 12126,
+	0xd9, 12126,
+	0xda, 12126,
+	0xdb, 12126,
+	0xdc, 12126,
+	0xdd, 12126,
+	0xde, 12126,
+	0xdf, 12126,
+	0xE2, 12131,
+	0xE3, 12134,
+	0xe8, 12137,
+	0xe9, 12137,
+	0xea, 12137,
+	0xeb, 12137,
+	0xec, 12137,
+	0xed, 12137,
+	0xee, 12137,
+	0xef, 12137,
+	0xf0, 12142,
+	0xf1, 12142,
+	0xf2, 12142,
+	0xf3, 12142,
+	0xf4, 12142,
+	0xf5, 12142,
+	0xf6, 12142,
+	0xf7, 12142,
+	/*12078*/ uint16(xCondSlashR),
+	12087, // 0
+	12091, // 1
+	12095, // 2
+	12099, // 3
 	0,     // 4
-	12084, // 5
+	12103, // 5
 	0,     // 6
-	12088, // 7
-	/*12068*/ uint16(xSetOp), uint16(FILD),
-	/*12070*/ uint16(xArgM32int),
-	/*12071*/ uint16(xMatch),
-	/*12072*/ uint16(xSetOp), uint16(FISTTP),
-	/*12074*/ uint16(xArgM32int),
-	/*12075*/ uint16(xMatch),
-	/*12076*/ uint16(xSetOp), uint16(FIST),
-	/*12078*/ uint16(xArgM32int),
-	/*12079*/ uint16(xMatch),
-	/*12080*/ uint16(xSetOp), uint16(FISTP),
-	/*12082*/ uint16(xArgM32int),
-	/*12083*/ uint16(xMatch),
-	/*12084*/ uint16(xSetOp), uint16(FLD),
-	/*12086*/ uint16(xArgM80fp),
-	/*12087*/ uint16(xMatch),
-	/*12088*/ uint16(xSetOp), uint16(FSTP),
-	/*12090*/ uint16(xArgM80fp),
-	/*12091*/ uint16(xMatch),
-	/*12092*/ uint16(xSetOp), uint16(FCMOVNB),
-	/*12094*/ uint16(xArgST),
-	/*12095*/ uint16(xArgSTi),
-	/*12096*/ uint16(xMatch),
-	/*12097*/ uint16(xSetOp), uint16(FCMOVNE),
-	/*12099*/ uint16(xArgST),
-	/*12100*/ uint16(xArgSTi),
-	/*12101*/ uint16(xMatch),
-	/*12102*/ uint16(xSetOp), uint16(FCMOVNBE),
-	/*12104*/ uint16(xArgST),
-	/*12105*/ uint16(xArgSTi),
+	12107, // 7
+	/*12087*/ uint16(xSetOp), uint16(FILD),
+	/*12089*/ uint16(xArgM32int),
+	/*12090*/ uint16(xMatch),
+	/*12091*/ uint16(xSetOp), uint16(FISTTP),
+	/*12093*/ uint16(xArgM32int),
+	/*12094*/ uint16(xMatch),
+	/*12095*/ uint16(xSetOp), uint16(FIST),
+	/*12097*/ uint16(xArgM32int),
+	/*12098*/ uint16(xMatch),
+	/*12099*/ uint16(xSetOp), uint16(FISTP),
+	/*12101*/ uint16(xArgM32int),
+	/*12102*/ uint16(xMatch),
+	/*12103*/ uint16(xSetOp), uint16(FLD),
+	/*12105*/ uint16(xArgM80fp),
 	/*12106*/ uint16(xMatch),
-	/*12107*/ uint16(xSetOp), uint16(FCMOVNU),
-	/*12109*/ uint16(xArgST),
-	/*12110*/ uint16(xArgSTi),
-	/*12111*/ uint16(xMatch),
-	/*12112*/ uint16(xSetOp), uint16(FNCLEX),
-	/*12114*/ uint16(xMatch),
-	/*12115*/ uint16(xSetOp), uint16(FNINIT),
-	/*12117*/ uint16(xMatch),
-	/*12118*/ uint16(xSetOp), uint16(FUCOMI),
-	/*12120*/ uint16(xArgST),
-	/*12121*/ uint16(xArgSTi),
-	/*12122*/ uint16(xMatch),
-	/*12123*/ uint16(xSetOp), uint16(FCOMI),
-	/*12125*/ uint16(xArgST),
-	/*12126*/ uint16(xArgSTi),
-	/*12127*/ uint16(xMatch),
-	/*12128*/ uint16(xCondByte), 48,
-	0xc0, 12267,
-	0xc1, 12267,
-	0xc2, 12267,
-	0xc3, 12267,
-	0xc4, 12267,
-	0xc5, 12267,
-	0xc6, 12267,
-	0xc7, 12267,
-	0xc8, 12272,
-	0xc9, 12272,
-	0xca, 12272,
-	0xcb, 12272,
-	0xcc, 12272,
-	0xcd, 12272,
-	0xce, 12272,
-	0xcf, 12272,
-	0xe0, 12277,
-	0xe1, 12277,
-	0xe2, 12277,
-	0xe3, 12277,
-	0xe4, 12277,
-	0xe5, 12277,
-	0xe6, 12277,
-	0xe7, 12277,
-	0xe8, 12282,
-	0xe9, 12282,
-	0xea, 12282,
-	0xeb, 12282,
-	0xec, 12282,
-	0xed, 12282,
-	0xee, 12282,
-	0xef, 12282,
-	0xf0, 12287,
-	0xf1, 12287,
-	0xf2, 12287,
-	0xf3, 12287,
-	0xf4, 12287,
-	0xf5, 12287,
-	0xf6, 12287,
-	0xf7, 12287,
-	0xf8, 12292,
-	0xf9, 12292,
-	0xfa, 12292,
-	0xfb, 12292,
-	0xfc, 12292,
-	0xfd, 12292,
-	0xfe, 12292,
-	0xff, 12292,
-	/*12226*/ uint16(xCondSlashR),
-	12235, // 0
-	12239, // 1
-	12243, // 2
-	12247, // 3
-	12251, // 4
-	12255, // 5
-	12259, // 6
-	12263, // 7
-	/*12235*/ uint16(xSetOp), uint16(FADD),
-	/*12237*/ uint16(xArgM64fp),
-	/*12238*/ uint16(xMatch),
-	/*12239*/ uint16(xSetOp), uint16(FMUL),
-	/*12241*/ uint16(xArgM64fp),
-	/*12242*/ uint16(xMatch),
-	/*12243*/ uint16(xSetOp), uint16(FCOM),
-	/*12245*/ uint16(xArgM64fp),
-	/*12246*/ uint16(xMatch),
-	/*12247*/ uint16(xSetOp), uint16(FCOMP),
-	/*12249*/ uint16(xArgM64fp),
-	/*12250*/ uint16(xMatch),
-	/*12251*/ uint16(xSetOp), uint16(FSUB),
-	/*12253*/ uint16(xArgM64fp),
-	/*12254*/ uint16(xMatch),
-	/*12255*/ uint16(xSetOp), uint16(FSUBR),
-	/*12257*/ uint16(xArgM64fp),
-	/*12258*/ uint16(xMatch),
-	/*12259*/ uint16(xSetOp), uint16(FDIV),
-	/*12261*/ uint16(xArgM64fp),
-	/*12262*/ uint16(xMatch),
-	/*12263*/ uint16(xSetOp), uint16(FDIVR),
-	/*12265*/ uint16(xArgM64fp),
-	/*12266*/ uint16(xMatch),
-	/*12267*/ uint16(xSetOp), uint16(FADD),
-	/*12269*/ uint16(xArgSTi),
-	/*12270*/ uint16(xArgST),
-	/*12271*/ uint16(xMatch),
-	/*12272*/ uint16(xSetOp), uint16(FMUL),
-	/*12274*/ uint16(xArgSTi),
-	/*12275*/ uint16(xArgST),
-	/*12276*/ uint16(xMatch),
-	/*12277*/ uint16(xSetOp), uint16(FSUBR),
-	/*12279*/ uint16(xArgSTi),
-	/*12280*/ uint16(xArgST),
+	/*12107*/ uint16(xSetOp), uint16(FSTP),
+	/*12109*/ uint16(xArgM80fp),
+	/*12110*/ uint16(xMatch),
+	/*12111*/ uint16(xSetOp), uint16(FCMOVNB),
+	/*12113*/ uint16(xArgST),
+	/*12114*/ uint16(xArgSTi),
+	/*12115*/ uint16(xMatch),
+	/*12116*/ uint16(xSetOp), uint16(FCMOVNE),
+	/*12118*/ uint16(xArgST),
+	/*12119*/ uint16(xArgSTi),
+	/*12120*/ uint16(xMatch),
+	/*12121*/ uint16(xSetOp), uint16(FCMOVNBE),
+	/*12123*/ uint16(xArgST),
+	/*12124*/ uint16(xArgSTi),
+	/*12125*/ uint16(xMatch),
+	/*12126*/ uint16(xSetOp), uint16(FCMOVNU),
+	/*12128*/ uint16(xArgST),
+	/*12129*/ uint16(xArgSTi),
+	/*12130*/ uint16(xMatch),
+	/*12131*/ uint16(xSetOp), uint16(FNCLEX),
+	/*12133*/ uint16(xMatch),
+	/*12134*/ uint16(xSetOp), uint16(FNINIT),
+	/*12136*/ uint16(xMatch),
+	/*12137*/ uint16(xSetOp), uint16(FUCOMI),
+	/*12139*/ uint16(xArgST),
+	/*12140*/ uint16(xArgSTi),
+	/*12141*/ uint16(xMatch),
+	/*12142*/ uint16(xSetOp), uint16(FCOMI),
+	/*12144*/ uint16(xArgST),
+	/*12145*/ uint16(xArgSTi),
+	/*12146*/ uint16(xMatch),
+	/*12147*/ uint16(xCondByte), 48,
+	0xc0, 12286,
+	0xc1, 12286,
+	0xc2, 12286,
+	0xc3, 12286,
+	0xc4, 12286,
+	0xc5, 12286,
+	0xc6, 12286,
+	0xc7, 12286,
+	0xc8, 12291,
+	0xc9, 12291,
+	0xca, 12291,
+	0xcb, 12291,
+	0xcc, 12291,
+	0xcd, 12291,
+	0xce, 12291,
+	0xcf, 12291,
+	0xe0, 12296,
+	0xe1, 12296,
+	0xe2, 12296,
+	0xe3, 12296,
+	0xe4, 12296,
+	0xe5, 12296,
+	0xe6, 12296,
+	0xe7, 12296,
+	0xe8, 12301,
+	0xe9, 12301,
+	0xea, 12301,
+	0xeb, 12301,
+	0xec, 12301,
+	0xed, 12301,
+	0xee, 12301,
+	0xef, 12301,
+	0xf0, 12306,
+	0xf1, 12306,
+	0xf2, 12306,
+	0xf3, 12306,
+	0xf4, 12306,
+	0xf5, 12306,
+	0xf6, 12306,
+	0xf7, 12306,
+	0xf8, 12311,
+	0xf9, 12311,
+	0xfa, 12311,
+	0xfb, 12311,
+	0xfc, 12311,
+	0xfd, 12311,
+	0xfe, 12311,
+	0xff, 12311,
+	/*12245*/ uint16(xCondSlashR),
+	12254, // 0
+	12258, // 1
+	12262, // 2
+	12266, // 3
+	12270, // 4
+	12274, // 5
+	12278, // 6
+	12282, // 7
+	/*12254*/ uint16(xSetOp), uint16(FADD),
+	/*12256*/ uint16(xArgM64fp),
+	/*12257*/ uint16(xMatch),
+	/*12258*/ uint16(xSetOp), uint16(FMUL),
+	/*12260*/ uint16(xArgM64fp),
+	/*12261*/ uint16(xMatch),
+	/*12262*/ uint16(xSetOp), uint16(FCOM),
+	/*12264*/ uint16(xArgM64fp),
+	/*12265*/ uint16(xMatch),
+	/*12266*/ uint16(xSetOp), uint16(FCOMP),
+	/*12268*/ uint16(xArgM64fp),
+	/*12269*/ uint16(xMatch),
+	/*12270*/ uint16(xSetOp), uint16(FSUB),
+	/*12272*/ uint16(xArgM64fp),
+	/*12273*/ uint16(xMatch),
+	/*12274*/ uint16(xSetOp), uint16(FSUBR),
+	/*12276*/ uint16(xArgM64fp),
+	/*12277*/ uint16(xMatch),
+	/*12278*/ uint16(xSetOp), uint16(FDIV),
+	/*12280*/ uint16(xArgM64fp),
 	/*12281*/ uint16(xMatch),
-	/*12282*/ uint16(xSetOp), uint16(FSUB),
-	/*12284*/ uint16(xArgSTi),
-	/*12285*/ uint16(xArgST),
-	/*12286*/ uint16(xMatch),
-	/*12287*/ uint16(xSetOp), uint16(FDIVR),
-	/*12289*/ uint16(xArgSTi),
-	/*12290*/ uint16(xArgST),
-	/*12291*/ uint16(xMatch),
-	/*12292*/ uint16(xSetOp), uint16(FDIV),
-	/*12294*/ uint16(xArgSTi),
-	/*12295*/ uint16(xArgST),
-	/*12296*/ uint16(xMatch),
-	/*12297*/ uint16(xCondByte), 40,
-	0xc0, 12416,
-	0xc1, 12416,
-	0xc2, 12416,
-	0xc3, 12416,
-	0xc4, 12416,
-	0xc5, 12416,
-	0xc6, 12416,
-	0xc7, 12416,
-	0xd0, 12420,
-	0xd1, 12420,
-	0xd2, 12420,
-	0xd3, 12420,
-	0xd4, 12420,
-	0xd5, 12420,
-	0xd6, 12420,
-	0xd7, 12420,
-	0xd8, 12424,
-	0xd9, 12424,
-	0xda, 12424,
-	0xdb, 12424,
-	0xdc, 12424,
-	0xdd, 12424,
-	0xde, 12424,
-	0xdf, 12424,
-	0xe0, 12428,
-	0xe1, 12428,
-	0xe2, 12428,
-	0xe3, 12428,
-	0xe4, 12428,
-	0xe5, 12428,
-	0xe6, 12428,
-	0xe7, 12428,
-	0xe8, 12432,
-	0xe9, 12432,
-	0xea, 12432,
-	0xeb, 12432,
-	0xec, 12432,
-	0xed, 12432,
-	0xee, 12432,
-	0xef, 12432,
-	/*12379*/ uint16(xCondSlashR),
-	12388, // 0
-	12392, // 1
-	12396, // 2
-	12400, // 3
-	12404, // 4
+	/*12282*/ uint16(xSetOp), uint16(FDIVR),
+	/*12284*/ uint16(xArgM64fp),
+	/*12285*/ uint16(xMatch),
+	/*12286*/ uint16(xSetOp), uint16(FADD),
+	/*12288*/ uint16(xArgSTi),
+	/*12289*/ uint16(xArgST),
+	/*12290*/ uint16(xMatch),
+	/*12291*/ uint16(xSetOp), uint16(FMUL),
+	/*12293*/ uint16(xArgSTi),
+	/*12294*/ uint16(xArgST),
+	/*12295*/ uint16(xMatch),
+	/*12296*/ uint16(xSetOp), uint16(FSUBR),
+	/*12298*/ uint16(xArgSTi),
+	/*12299*/ uint16(xArgST),
+	/*12300*/ uint16(xMatch),
+	/*12301*/ uint16(xSetOp), uint16(FSUB),
+	/*12303*/ uint16(xArgSTi),
+	/*12304*/ uint16(xArgST),
+	/*12305*/ uint16(xMatch),
+	/*12306*/ uint16(xSetOp), uint16(FDIVR),
+	/*12308*/ uint16(xArgSTi),
+	/*12309*/ uint16(xArgST),
+	/*12310*/ uint16(xMatch),
+	/*12311*/ uint16(xSetOp), uint16(FDIV),
+	/*12313*/ uint16(xArgSTi),
+	/*12314*/ uint16(xArgST),
+	/*12315*/ uint16(xMatch),
+	/*12316*/ uint16(xCondByte), 40,
+	0xc0, 12435,
+	0xc1, 12435,
+	0xc2, 12435,
+	0xc3, 12435,
+	0xc4, 12435,
+	0xc5, 12435,
+	0xc6, 12435,
+	0xc7, 12435,
+	0xd0, 12439,
+	0xd1, 12439,
+	0xd2, 12439,
+	0xd3, 12439,
+	0xd4, 12439,
+	0xd5, 12439,
+	0xd6, 12439,
+	0xd7, 12439,
+	0xd8, 12443,
+	0xd9, 12443,
+	0xda, 12443,
+	0xdb, 12443,
+	0xdc, 12443,
+	0xdd, 12443,
+	0xde, 12443,
+	0xdf, 12443,
+	0xe0, 12447,
+	0xe1, 12447,
+	0xe2, 12447,
+	0xe3, 12447,
+	0xe4, 12447,
+	0xe5, 12447,
+	0xe6, 12447,
+	0xe7, 12447,
+	0xe8, 12451,
+	0xe9, 12451,
+	0xea, 12451,
+	0xeb, 12451,
+	0xec, 12451,
+	0xed, 12451,
+	0xee, 12451,
+	0xef, 12451,
+	/*12398*/ uint16(xCondSlashR),
+	12407, // 0
+	12411, // 1
+	12415, // 2
+	12419, // 3
+	12423, // 4
 	0,     // 5
-	12408, // 6
-	12412, // 7
-	/*12388*/ uint16(xSetOp), uint16(FLD),
-	/*12390*/ uint16(xArgM64fp),
-	/*12391*/ uint16(xMatch),
-	/*12392*/ uint16(xSetOp), uint16(FISTTP),
-	/*12394*/ uint16(xArgM64int),
-	/*12395*/ uint16(xMatch),
-	/*12396*/ uint16(xSetOp), uint16(FST),
-	/*12398*/ uint16(xArgM64fp),
-	/*12399*/ uint16(xMatch),
-	/*12400*/ uint16(xSetOp), uint16(FSTP),
-	/*12402*/ uint16(xArgM64fp),
-	/*12403*/ uint16(xMatch),
-	/*12404*/ uint16(xSetOp), uint16(FRSTOR),
-	/*12406*/ uint16(xArgM94108byte),
-	/*12407*/ uint16(xMatch),
-	/*12408*/ uint16(xSetOp), uint16(FNSAVE),
-	/*12410*/ uint16(xArgM94108byte),
-	/*12411*/ uint16(xMatch),
-	/*12412*/ uint16(xSetOp), uint16(FNSTSW),
-	/*12414*/ uint16(xArgM2byte),
-	/*12415*/ uint16(xMatch),
-	/*12416*/ uint16(xSetOp), uint16(FFREE),
-	/*12418*/ uint16(xArgSTi),
-	/*12419*/ uint16(xMatch),
-	/*12420*/ uint16(xSetOp), uint16(FST),
-	/*12422*/ uint16(xArgSTi),
-	/*12423*/ uint16(xMatch),
-	/*12424*/ uint16(xSetOp), uint16(FSTP),
-	/*12426*/ uint16(xArgSTi),
-	/*12427*/ uint16(xMatch),
-	/*12428*/ uint16(xSetOp), uint16(FUCOM),
-	/*12430*/ uint16(xArgSTi),
-	/*12431*/ uint16(xMatch),
-	/*12432*/ uint16(xSetOp), uint16(FUCOMP),
-	/*12434*/ uint16(xArgSTi),
-	/*12435*/ uint16(xMatch),
-	/*12436*/ uint16(xCondByte), 49,
-	0xc0, 12577,
-	0xc1, 12577,
-	0xc2, 12577,
-	0xc3, 12577,
-	0xc4, 12577,
-	0xc5, 12577,
-	0xc6, 12577,
-	0xc7, 12577,
-	0xc8, 12582,
-	0xc9, 12582,
-	0xca, 12582,
-	0xcb, 12582,
-	0xcc, 12582,
-	0xcd, 12582,
-	0xce, 12582,
-	0xcf, 12582,
-	0xD9, 12587,
-	0xe0, 12590,
-	0xe1, 12590,
-	0xe2, 12590,
-	0xe3, 12590,
-	0xe4, 12590,
-	0xe5, 12590,
-	0xe6, 12590,
-	0xe7, 12590,
-	0xe8, 12595,
-	0xe9, 12595,
-	0xea, 12595,
-	0xeb, 12595,
-	0xec, 12595,
-	0xed, 12595,
-	0xee, 12595,
-	0xef, 12595,
-	0xf0, 12600,
-	0xf1, 12600,
-	0xf2, 12600,
-	0xf3, 12600,
-	0xf4, 12600,
-	0xf5, 12600,
-	0xf6, 12600,
-	0xf7, 12600,
-	0xf8, 12605,
-	0xf9, 12605,
-	0xfa, 12605,
-	0xfb, 12605,
-	0xfc, 12605,
-	0xfd, 12605,
-	0xfe, 12605,
-	0xff, 12605,
-	/*12536*/ uint16(xCondSlashR),
-	12545, // 0
-	12549, // 1
-	12553, // 2
-	12557, // 3
-	12561, // 4
-	12565, // 5
-	12569, // 6
-	12573, // 7
-	/*12545*/ uint16(xSetOp), uint16(FIADD),
-	/*12547*/ uint16(xArgM16int),
-	/*12548*/ uint16(xMatch),
-	/*12549*/ uint16(xSetOp), uint16(FIMUL),
-	/*12551*/ uint16(xArgM16int),
-	/*12552*/ uint16(xMatch),
-	/*12553*/ uint16(xSetOp), uint16(FICOM),
-	/*12555*/ uint16(xArgM16int),
-	/*12556*/ uint16(xMatch),
-	/*12557*/ uint16(xSetOp), uint16(FICOMP),
-	/*12559*/ uint16(xArgM16int),
-	/*12560*/ uint16(xMatch),
-	/*12561*/ uint16(xSetOp), uint16(FISUB),
-	/*12563*/ uint16(xArgM16int),
-	/*12564*/ uint16(xMatch),
-	/*12565*/ uint16(xSetOp), uint16(FISUBR),
-	/*12567*/ uint16(xArgM16int),
-	/*12568*/ uint16(xMatch),
-	/*12569*/ uint16(xSetOp), uint16(FIDIV),
-	/*12571*/ uint16(xArgM16int),
-	/*12572*/ uint16(xMatch),
-	/*12573*/ uint16(xSetOp), uint16(FIDIVR),
-	/*12575*/ uint16(xArgM16int),
-	/*12576*/ uint16(xMatch),
-	/*12577*/ uint16(xSetOp), uint16(FADDP),
-	/*12579*/ uint16(xArgSTi),
-	/*12580*/ uint16(xArgST),
-	/*12581*/ uint16(xMatch),
-	/*12582*/ uint16(xSetOp), uint16(FMULP),
-	/*12584*/ uint16(xArgSTi),
-	/*12585*/ uint16(xArgST),
-	/*12586*/ uint16(xMatch),
-	/*12587*/ uint16(xSetOp), uint16(FCOMPP),
-	/*12589*/ uint16(xMatch),
-	/*12590*/ uint16(xSetOp), uint16(FSUBRP),
-	/*12592*/ uint16(xArgSTi),
-	/*12593*/ uint16(xArgST),
-	/*12594*/ uint16(xMatch),
-	/*12595*/ uint16(xSetOp), uint16(FSUBP),
-	/*12597*/ uint16(xArgSTi),
-	/*12598*/ uint16(xArgST),
-	/*12599*/ uint16(xMatch),
-	/*12600*/ uint16(xSetOp), uint16(FDIVRP),
-	/*12602*/ uint16(xArgSTi),
-	/*12603*/ uint16(xArgST),
-	/*12604*/ uint16(xMatch),
-	/*12605*/ uint16(xSetOp), uint16(FDIVP),
-	/*12607*/ uint16(xArgSTi),
-	/*12608*/ uint16(xArgST),
-	/*12609*/ uint16(xMatch),
-	/*12610*/ uint16(xCondByte), 25,
-	0xc0, 12703,
-	0xc1, 12703,
-	0xc2, 12703,
-	0xc3, 12703,
-	0xc4, 12703,
-	0xc5, 12703,
-	0xc6, 12703,
-	0xc7, 12703,
-	0xE0, 12707,
-	0xe8, 12711,
-	0xe9, 12711,
-	0xea, 12711,
-	0xeb, 12711,
-	0xec, 12711,
-	0xed, 12711,
-	0xee, 12711,
-	0xef, 12711,
-	0xf0, 12716,
-	0xf1, 12716,
-	0xf2, 12716,
-	0xf3, 12716,
-	0xf4, 12716,
-	0xf5, 12716,
-	0xf6, 12716,
-	0xf7, 12716,
-	/*12662*/ uint16(xCondSlashR),
-	12671, // 0
-	12675, // 1
-	12679, // 2
-	12683, // 3
-	12687, // 4
-	12691, // 5
-	12695, // 6
-	12699, // 7
-	/*12671*/ uint16(xSetOp), uint16(FILD),
-	/*12673*/ uint16(xArgM16int),
-	/*12674*/ uint16(xMatch),
-	/*12675*/ uint16(xSetOp), uint16(FISTTP),
-	/*12677*/ uint16(xArgM16int),
-	/*12678*/ uint16(xMatch),
-	/*12679*/ uint16(xSetOp), uint16(FIST),
-	/*12681*/ uint16(xArgM16int),
-	/*12682*/ uint16(xMatch),
-	/*12683*/ uint16(xSetOp), uint16(FISTP),
-	/*12685*/ uint16(xArgM16int),
-	/*12686*/ uint16(xMatch),
-	/*12687*/ uint16(xSetOp), uint16(FBLD),
-	/*12689*/ uint16(xArgM80dec),
-	/*12690*/ uint16(xMatch),
-	/*12691*/ uint16(xSetOp), uint16(FILD),
-	/*12693*/ uint16(xArgM64int),
-	/*12694*/ uint16(xMatch),
-	/*12695*/ uint16(xSetOp), uint16(FBSTP),
-	/*12697*/ uint16(xArgM80bcd),
-	/*12698*/ uint16(xMatch),
-	/*12699*/ uint16(xSetOp), uint16(FISTP),
-	/*12701*/ uint16(xArgM64int),
-	/*12702*/ uint16(xMatch),
-	/*12703*/ uint16(xSetOp), uint16(FFREEP),
-	/*12705*/ uint16(xArgSTi),
-	/*12706*/ uint16(xMatch),
-	/*12707*/ uint16(xSetOp), uint16(FNSTSW),
-	/*12709*/ uint16(xArgAX),
-	/*12710*/ uint16(xMatch),
-	/*12711*/ uint16(xSetOp), uint16(FUCOMIP),
-	/*12713*/ uint16(xArgST),
-	/*12714*/ uint16(xArgSTi),
-	/*12715*/ uint16(xMatch),
-	/*12716*/ uint16(xSetOp), uint16(FCOMIP),
-	/*12718*/ uint16(xArgST),
-	/*12719*/ uint16(xArgSTi),
-	/*12720*/ uint16(xMatch),
-	/*12721*/ uint16(xSetOp), uint16(LOOPNE),
-	/*12723*/ uint16(xReadCb),
-	/*12724*/ uint16(xArgRel8),
+	12427, // 6
+	12431, // 7
+	/*12407*/ uint16(xSetOp), uint16(FLD),
+	/*12409*/ uint16(xArgM64fp),
+	/*12410*/ uint16(xMatch),
+	/*12411*/ uint16(xSetOp), uint16(FISTTP),
+	/*12413*/ uint16(xArgM64int),
+	/*12414*/ uint16(xMatch),
+	/*12415*/ uint16(xSetOp), uint16(FST),
+	/*12417*/ uint16(xArgM64fp),
+	/*12418*/ uint16(xMatch),
+	/*12419*/ uint16(xSetOp), uint16(FSTP),
+	/*12421*/ uint16(xArgM64fp),
+	/*12422*/ uint16(xMatch),
+	/*12423*/ uint16(xSetOp), uint16(FRSTOR),
+	/*12425*/ uint16(xArgM94108byte),
+	/*12426*/ uint16(xMatch),
+	/*12427*/ uint16(xSetOp), uint16(FNSAVE),
+	/*12429*/ uint16(xArgM94108byte),
+	/*12430*/ uint16(xMatch),
+	/*12431*/ uint16(xSetOp), uint16(FNSTSW),
+	/*12433*/ uint16(xArgM2byte),
+	/*12434*/ uint16(xMatch),
+	/*12435*/ uint16(xSetOp), uint16(FFREE),
+	/*12437*/ uint16(xArgSTi),
+	/*12438*/ uint16(xMatch),
+	/*12439*/ uint16(xSetOp), uint16(FST),
+	/*12441*/ uint16(xArgSTi),
+	/*12442*/ uint16(xMatch),
+	/*12443*/ uint16(xSetOp), uint16(FSTP),
+	/*12445*/ uint16(xArgSTi),
+	/*12446*/ uint16(xMatch),
+	/*12447*/ uint16(xSetOp), uint16(FUCOM),
+	/*12449*/ uint16(xArgSTi),
+	/*12450*/ uint16(xMatch),
+	/*12451*/ uint16(xSetOp), uint16(FUCOMP),
+	/*12453*/ uint16(xArgSTi),
+	/*12454*/ uint16(xMatch),
+	/*12455*/ uint16(xCondByte), 49,
+	0xc0, 12596,
+	0xc1, 12596,
+	0xc2, 12596,
+	0xc3, 12596,
+	0xc4, 12596,
+	0xc5, 12596,
+	0xc6, 12596,
+	0xc7, 12596,
+	0xc8, 12601,
+	0xc9, 12601,
+	0xca, 12601,
+	0xcb, 12601,
+	0xcc, 12601,
+	0xcd, 12601,
+	0xce, 12601,
+	0xcf, 12601,
+	0xD9, 12606,
+	0xe0, 12609,
+	0xe1, 12609,
+	0xe2, 12609,
+	0xe3, 12609,
+	0xe4, 12609,
+	0xe5, 12609,
+	0xe6, 12609,
+	0xe7, 12609,
+	0xe8, 12614,
+	0xe9, 12614,
+	0xea, 12614,
+	0xeb, 12614,
+	0xec, 12614,
+	0xed, 12614,
+	0xee, 12614,
+	0xef, 12614,
+	0xf0, 12619,
+	0xf1, 12619,
+	0xf2, 12619,
+	0xf3, 12619,
+	0xf4, 12619,
+	0xf5, 12619,
+	0xf6, 12619,
+	0xf7, 12619,
+	0xf8, 12624,
+	0xf9, 12624,
+	0xfa, 12624,
+	0xfb, 12624,
+	0xfc, 12624,
+	0xfd, 12624,
+	0xfe, 12624,
+	0xff, 12624,
+	/*12555*/ uint16(xCondSlashR),
+	12564, // 0
+	12568, // 1
+	12572, // 2
+	12576, // 3
+	12580, // 4
+	12584, // 5
+	12588, // 6
+	12592, // 7
+	/*12564*/ uint16(xSetOp), uint16(FIADD),
+	/*12566*/ uint16(xArgM16int),
+	/*12567*/ uint16(xMatch),
+	/*12568*/ uint16(xSetOp), uint16(FIMUL),
+	/*12570*/ uint16(xArgM16int),
+	/*12571*/ uint16(xMatch),
+	/*12572*/ uint16(xSetOp), uint16(FICOM),
+	/*12574*/ uint16(xArgM16int),
+	/*12575*/ uint16(xMatch),
+	/*12576*/ uint16(xSetOp), uint16(FICOMP),
+	/*12578*/ uint16(xArgM16int),
+	/*12579*/ uint16(xMatch),
+	/*12580*/ uint16(xSetOp), uint16(FISUB),
+	/*12582*/ uint16(xArgM16int),
+	/*12583*/ uint16(xMatch),
+	/*12584*/ uint16(xSetOp), uint16(FISUBR),
+	/*12586*/ uint16(xArgM16int),
+	/*12587*/ uint16(xMatch),
+	/*12588*/ uint16(xSetOp), uint16(FIDIV),
+	/*12590*/ uint16(xArgM16int),
+	/*12591*/ uint16(xMatch),
+	/*12592*/ uint16(xSetOp), uint16(FIDIVR),
+	/*12594*/ uint16(xArgM16int),
+	/*12595*/ uint16(xMatch),
+	/*12596*/ uint16(xSetOp), uint16(FADDP),
+	/*12598*/ uint16(xArgSTi),
+	/*12599*/ uint16(xArgST),
+	/*12600*/ uint16(xMatch),
+	/*12601*/ uint16(xSetOp), uint16(FMULP),
+	/*12603*/ uint16(xArgSTi),
+	/*12604*/ uint16(xArgST),
+	/*12605*/ uint16(xMatch),
+	/*12606*/ uint16(xSetOp), uint16(FCOMPP),
+	/*12608*/ uint16(xMatch),
+	/*12609*/ uint16(xSetOp), uint16(FSUBRP),
+	/*12611*/ uint16(xArgSTi),
+	/*12612*/ uint16(xArgST),
+	/*12613*/ uint16(xMatch),
+	/*12614*/ uint16(xSetOp), uint16(FSUBP),
+	/*12616*/ uint16(xArgSTi),
+	/*12617*/ uint16(xArgST),
+	/*12618*/ uint16(xMatch),
+	/*12619*/ uint16(xSetOp), uint16(FDIVRP),
+	/*12621*/ uint16(xArgSTi),
+	/*12622*/ uint16(xArgST),
+	/*12623*/ uint16(xMatch),
+	/*12624*/ uint16(xSetOp), uint16(FDIVP),
+	/*12626*/ uint16(xArgSTi),
+	/*12627*/ uint16(xArgST),
+	/*12628*/ uint16(xMatch),
+	/*12629*/ uint16(xCondByte), 25,
+	0xc0, 12722,
+	0xc1, 12722,
+	0xc2, 12722,
+	0xc3, 12722,
+	0xc4, 12722,
+	0xc5, 12722,
+	0xc6, 12722,
+	0xc7, 12722,
+	0xE0, 12726,
+	0xe8, 12730,
+	0xe9, 12730,
+	0xea, 12730,
+	0xeb, 12730,
+	0xec, 12730,
+	0xed, 12730,
+	0xee, 12730,
+	0xef, 12730,
+	0xf0, 12735,
+	0xf1, 12735,
+	0xf2, 12735,
+	0xf3, 12735,
+	0xf4, 12735,
+	0xf5, 12735,
+	0xf6, 12735,
+	0xf7, 12735,
+	/*12681*/ uint16(xCondSlashR),
+	12690, // 0
+	12694, // 1
+	12698, // 2
+	12702, // 3
+	12706, // 4
+	12710, // 5
+	12714, // 6
+	12718, // 7
+	/*12690*/ uint16(xSetOp), uint16(FILD),
+	/*12692*/ uint16(xArgM16int),
+	/*12693*/ uint16(xMatch),
+	/*12694*/ uint16(xSetOp), uint16(FISTTP),
+	/*12696*/ uint16(xArgM16int),
+	/*12697*/ uint16(xMatch),
+	/*12698*/ uint16(xSetOp), uint16(FIST),
+	/*12700*/ uint16(xArgM16int),
+	/*12701*/ uint16(xMatch),
+	/*12702*/ uint16(xSetOp), uint16(FISTP),
+	/*12704*/ uint16(xArgM16int),
+	/*12705*/ uint16(xMatch),
+	/*12706*/ uint16(xSetOp), uint16(FBLD),
+	/*12708*/ uint16(xArgM80dec),
+	/*12709*/ uint16(xMatch),
+	/*12710*/ uint16(xSetOp), uint16(FILD),
+	/*12712*/ uint16(xArgM64int),
+	/*12713*/ uint16(xMatch),
+	/*12714*/ uint16(xSetOp), uint16(FBSTP),
+	/*12716*/ uint16(xArgM80bcd),
+	/*12717*/ uint16(xMatch),
+	/*12718*/ uint16(xSetOp), uint16(FISTP),
+	/*12720*/ uint16(xArgM64int),
+	/*12721*/ uint16(xMatch),
+	/*12722*/ uint16(xSetOp), uint16(FFREEP),
+	/*12724*/ uint16(xArgSTi),
 	/*12725*/ uint16(xMatch),
-	/*12726*/ uint16(xSetOp), uint16(LOOPE),
-	/*12728*/ uint16(xReadCb),
-	/*12729*/ uint16(xArgRel8),
-	/*12730*/ uint16(xMatch),
-	/*12731*/ uint16(xSetOp), uint16(LOOP),
-	/*12733*/ uint16(xReadCb),
-	/*12734*/ uint16(xArgRel8),
-	/*12735*/ uint16(xMatch),
-	/*12736*/ uint16(xCondIs64), 12739, 12753,
-	/*12739*/ uint16(xCondAddrSize), 12743, 12748, 0,
-	/*12743*/ uint16(xSetOp), uint16(JCXZ),
-	/*12745*/ uint16(xReadCb),
-	/*12746*/ uint16(xArgRel8),
-	/*12747*/ uint16(xMatch),
-	/*12748*/ uint16(xSetOp), uint16(JECXZ),
-	/*12750*/ uint16(xReadCb),
-	/*12751*/ uint16(xArgRel8),
-	/*12752*/ uint16(xMatch),
-	/*12753*/ uint16(xCondAddrSize), 0, 12748, 12757,
-	/*12757*/ uint16(xSetOp), uint16(JRCXZ),
-	/*12759*/ uint16(xReadCb),
-	/*12760*/ uint16(xArgRel8),
-	/*12761*/ uint16(xMatch),
-	/*12762*/ uint16(xSetOp), uint16(IN),
-	/*12764*/ uint16(xReadIb),
-	/*12765*/ uint16(xArgAL),
-	/*12766*/ uint16(xArgImm8u),
-	/*12767*/ uint16(xMatch),
-	/*12768*/ uint16(xCondDataSize), 12772, 12778, 12784,
-	/*12772*/ uint16(xSetOp), uint16(IN),
-	/*12774*/ uint16(xReadIb),
-	/*12775*/ uint16(xArgAX),
-	/*12776*/ uint16(xArgImm8u),
-	/*12777*/ uint16(xMatch),
-	/*12778*/ uint16(xSetOp), uint16(IN),
-	/*12780*/ uint16(xReadIb),
-	/*12781*/ uint16(xArgEAX),
-	/*12782*/ uint16(xArgImm8u),
-	/*12783*/ uint16(xMatch),
-	/*12784*/ uint16(xSetOp), uint16(IN),
-	/*12786*/ uint16(xReadIb),
-	/*12787*/ uint16(xArgEAX),
-	/*12788*/ uint16(xArgImm8u),
-	/*12789*/ uint16(xMatch),
-	/*12790*/ uint16(xSetOp), uint16(OUT),
-	/*12792*/ uint16(xReadIb),
-	/*12793*/ uint16(xArgImm8u),
-	/*12794*/ uint16(xArgAL),
-	/*12795*/ uint16(xMatch),
-	/*12796*/ uint16(xCondPrefix), 3,
-	0xC5, 12840,
-	0xC4, 12826,
-	0x0, 12804,
-	/*12804*/ uint16(xCondDataSize), 12808, 12814, 12820,
-	/*12808*/ uint16(xSetOp), uint16(OUT),
-	/*12810*/ uint16(xReadIb),
-	/*12811*/ uint16(xArgImm8u),
-	/*12812*/ uint16(xArgAX),
-	/*12813*/ uint16(xMatch),
-	/*12814*/ uint16(xSetOp), uint16(OUT),
-	/*12816*/ uint16(xReadIb),
-	/*12817*/ uint16(xArgImm8u),
-	/*12818*/ uint16(xArgEAX),
-	/*12819*/ uint16(xMatch),
-	/*12820*/ uint16(xSetOp), uint16(OUT),
-	/*12822*/ uint16(xReadIb),
-	/*12823*/ uint16(xArgImm8u),
-	/*12824*/ uint16(xArgEAX),
-	/*12825*/ uint16(xMatch),
-	/*12826*/ uint16(xCondPrefix), 1,
-	0x66, 12830,
-	/*12830*/ uint16(xCondPrefix), 1,
-	0x0F, 12834,
-	/*12834*/ uint16(xSetOp), uint16(VMOVNTDQ),
-	/*12836*/ uint16(xReadSlashR),
-	/*12837*/ uint16(xArgM256),
-	/*12838*/ uint16(xArgYmm1),
-	/*12839*/ uint16(xMatch),
-	/*12840*/ uint16(xCondPrefix), 1,
-	0x66, 12844,
-	/*12844*/ uint16(xCondPrefix), 1,
-	0x0F, 12848,
-	/*12848*/ uint16(xSetOp), uint16(VMOVNTDQ),
-	/*12850*/ uint16(xReadSlashR),
-	/*12851*/ uint16(xArgM256),
-	/*12852*/ uint16(xArgYmm1),
-	/*12853*/ uint16(xMatch),
-	/*12854*/ uint16(xCondIs64), 12857, 12871,
-	/*12857*/ uint16(xCondDataSize), 12861, 12866, 0,
-	/*12861*/ uint16(xSetOp), uint16(CALL),
-	/*12863*/ uint16(xReadCw),
-	/*12864*/ uint16(xArgRel16),
-	/*12865*/ uint16(xMatch),
-	/*12866*/ uint16(xSetOp), uint16(CALL),
-	/*12868*/ uint16(xReadCd),
-	/*12869*/ uint16(xArgRel32),
-	/*12870*/ uint16(xMatch),
-	/*12871*/ uint16(xCondDataSize), 12875, 12866, 12880,
-	/*12875*/ uint16(xSetOp), uint16(CALL),
-	/*12877*/ uint16(xReadCd),
-	/*12878*/ uint16(xArgRel32),
-	/*12879*/ uint16(xMatch),
+	/*12726*/ uint16(xSetOp), uint16(FNSTSW),
+	/*12728*/ uint16(xArgAX),
+	/*12729*/ uint16(xMatch),
+	/*12730*/ uint16(xSetOp), uint16(FUCOMIP),
+	/*12732*/ uint16(xArgST),
+	/*12733*/ uint16(xArgSTi),
+	/*12734*/ uint16(xMatch),
+	/*12735*/ uint16(xSetOp), uint16(FCOMIP),
+	/*12737*/ uint16(xArgST),
+	/*12738*/ uint16(xArgSTi),
+	/*12739*/ uint16(xMatch),
+	/*12740*/ uint16(xSetOp), uint16(LOOPNE),
+	/*12742*/ uint16(xReadCb),
+	/*12743*/ uint16(xArgRel8),
+	/*12744*/ uint16(xMatch),
+	/*12745*/ uint16(xSetOp), uint16(LOOPE),
+	/*12747*/ uint16(xReadCb),
+	/*12748*/ uint16(xArgRel8),
+	/*12749*/ uint16(xMatch),
+	/*12750*/ uint16(xSetOp), uint16(LOOP),
+	/*12752*/ uint16(xReadCb),
+	/*12753*/ uint16(xArgRel8),
+	/*12754*/ uint16(xMatch),
+	/*12755*/ uint16(xCondIs64), 12758, 12772,
+	/*12758*/ uint16(xCondAddrSize), 12762, 12767, 0,
+	/*12762*/ uint16(xSetOp), uint16(JCXZ),
+	/*12764*/ uint16(xReadCb),
+	/*12765*/ uint16(xArgRel8),
+	/*12766*/ uint16(xMatch),
+	/*12767*/ uint16(xSetOp), uint16(JECXZ),
+	/*12769*/ uint16(xReadCb),
+	/*12770*/ uint16(xArgRel8),
+	/*12771*/ uint16(xMatch),
+	/*12772*/ uint16(xCondAddrSize), 0, 12767, 12776,
+	/*12776*/ uint16(xSetOp), uint16(JRCXZ),
+	/*12778*/ uint16(xReadCb),
+	/*12779*/ uint16(xArgRel8),
+	/*12780*/ uint16(xMatch),
+	/*12781*/ uint16(xSetOp), uint16(IN),
+	/*12783*/ uint16(xReadIb),
+	/*12784*/ uint16(xArgAL),
+	/*12785*/ uint16(xArgImm8u),
+	/*12786*/ uint16(xMatch),
+	/*12787*/ uint16(xCondDataSize), 12791, 12797, 12803,
+	/*12791*/ uint16(xSetOp), uint16(IN),
+	/*12793*/ uint16(xReadIb),
+	/*12794*/ uint16(xArgAX),
+	/*12795*/ uint16(xArgImm8u),
+	/*12796*/ uint16(xMatch),
+	/*12797*/ uint16(xSetOp), uint16(IN),
+	/*12799*/ uint16(xReadIb),
+	/*12800*/ uint16(xArgEAX),
+	/*12801*/ uint16(xArgImm8u),
+	/*12802*/ uint16(xMatch),
+	/*12803*/ uint16(xSetOp), uint16(IN),
+	/*12805*/ uint16(xReadIb),
+	/*12806*/ uint16(xArgEAX),
+	/*12807*/ uint16(xArgImm8u),
+	/*12808*/ uint16(xMatch),
+	/*12809*/ uint16(xSetOp), uint16(OUT),
+	/*12811*/ uint16(xReadIb),
+	/*12812*/ uint16(xArgImm8u),
+	/*12813*/ uint16(xArgAL),
+	/*12814*/ uint16(xMatch),
+	/*12815*/ uint16(xCondPrefix), 3,
+	0xC5, 12859,
+	0xC4, 12845,
+	0x0, 12823,
+	/*12823*/ uint16(xCondDataSize), 12827, 12833, 12839,
+	/*12827*/ uint16(xSetOp), uint16(OUT),
+	/*12829*/ uint16(xReadIb),
+	/*12830*/ uint16(xArgImm8u),
+	/*12831*/ uint16(xArgAX),
+	/*12832*/ uint16(xMatch),
+	/*12833*/ uint16(xSetOp), uint16(OUT),
+	/*12835*/ uint16(xReadIb),
+	/*12836*/ uint16(xArgImm8u),
+	/*12837*/ uint16(xArgEAX),
+	/*12838*/ uint16(xMatch),
+	/*12839*/ uint16(xSetOp), uint16(OUT),
+	/*12841*/ uint16(xReadIb),
+	/*12842*/ uint16(xArgImm8u),
+	/*12843*/ uint16(xArgEAX),
+	/*12844*/ uint16(xMatch),
+	/*12845*/ uint16(xCondPrefix), 1,
+	0x66, 12849,
+	/*12849*/ uint16(xCondPrefix), 1,
+	0x0F, 12853,
+	/*12853*/ uint16(xSetOp), uint16(VMOVNTDQ),
+	/*12855*/ uint16(xReadSlashR),
+	/*12856*/ uint16(xArgM256),
+	/*12857*/ uint16(xArgYmm1),
+	/*12858*/ uint16(xMatch),
+	/*12859*/ uint16(xCondPrefix), 1,
+	0x66, 12863,
+	/*12863*/ uint16(xCondPrefix), 1,
+	0x0F, 12867,
+	/*12867*/ uint16(xSetOp), uint16(VMOVNTDQ),
+	/*12869*/ uint16(xReadSlashR),
+	/*12870*/ uint16(xArgM256),
+	/*12871*/ uint16(xArgYmm1),
+	/*12872*/ uint16(xMatch),
+	/*12873*/ uint16(xCondIs64), 12876, 12890,
+	/*12876*/ uint16(xCondDataSize), 12880, 12885, 0,
 	/*12880*/ uint16(xSetOp), uint16(CALL),
-	/*12882*/ uint16(xReadCd),
-	/*12883*/ uint16(xArgRel32),
+	/*12882*/ uint16(xReadCw),
+	/*12883*/ uint16(xArgRel16),
 	/*12884*/ uint16(xMatch),
-	/*12885*/ uint16(xCondIs64), 12888, 12902,
-	/*12888*/ uint16(xCondDataSize), 12892, 12897, 0,
-	/*12892*/ uint16(xSetOp), uint16(JMP),
-	/*12894*/ uint16(xReadCw),
-	/*12895*/ uint16(xArgRel16),
-	/*12896*/ uint16(xMatch),
-	/*12897*/ uint16(xSetOp), uint16(JMP),
-	/*12899*/ uint16(xReadCd),
-	/*12900*/ uint16(xArgRel32),
-	/*12901*/ uint16(xMatch),
-	/*12902*/ uint16(xCondDataSize), 12906, 12897, 12911,
-	/*12906*/ uint16(xSetOp), uint16(JMP),
-	/*12908*/ uint16(xReadCd),
-	/*12909*/ uint16(xArgRel32),
-	/*12910*/ uint16(xMatch),
+	/*12885*/ uint16(xSetOp), uint16(CALL),
+	/*12887*/ uint16(xReadCd),
+	/*12888*/ uint16(xArgRel32),
+	/*12889*/ uint16(xMatch),
+	/*12890*/ uint16(xCondDataSize), 12894, 12885, 12899,
+	/*12894*/ uint16(xSetOp), uint16(CALL),
+	/*12896*/ uint16(xReadCd),
+	/*12897*/ uint16(xArgRel32),
+	/*12898*/ uint16(xMatch),
+	/*12899*/ uint16(xSetOp), uint16(CALL),
+	/*12901*/ uint16(xReadCd),
+	/*12902*/ uint16(xArgRel32),
+	/*12903*/ uint16(xMatch),
+	/*12904*/ uint16(xCondIs64), 12907, 12921,
+	/*12907*/ uint16(xCondDataSize), 12911, 12916, 0,
 	/*12911*/ uint16(xSetOp), uint16(JMP),
-	/*12913*/ uint16(xReadCd),
-	/*12914*/ uint16(xArgRel32),
+	/*12913*/ uint16(xReadCw),
+	/*12914*/ uint16(xArgRel16),
 	/*12915*/ uint16(xMatch),
-	/*12916*/ uint16(xCondIs64), 12919, 0,
-	/*12919*/ uint16(xCondDataSize), 12923, 12928, 0,
-	/*12923*/ uint16(xSetOp), uint16(LJMP),
-	/*12925*/ uint16(xReadCd),
-	/*12926*/ uint16(xArgPtr16colon16),
-	/*12927*/ uint16(xMatch),
-	/*12928*/ uint16(xSetOp), uint16(LJMP),
-	/*12930*/ uint16(xReadCp),
-	/*12931*/ uint16(xArgPtr16colon32),
-	/*12932*/ uint16(xMatch),
-	/*12933*/ uint16(xSetOp), uint16(JMP),
-	/*12935*/ uint16(xReadCb),
-	/*12936*/ uint16(xArgRel8),
-	/*12937*/ uint16(xMatch),
-	/*12938*/ uint16(xSetOp), uint16(IN),
-	/*12940*/ uint16(xArgAL),
-	/*12941*/ uint16(xArgDX),
-	/*12942*/ uint16(xMatch),
-	/*12943*/ uint16(xCondDataSize), 12947, 12952, 12957,
-	/*12947*/ uint16(xSetOp), uint16(IN),
-	/*12949*/ uint16(xArgAX),
-	/*12950*/ uint16(xArgDX),
+	/*12916*/ uint16(xSetOp), uint16(JMP),
+	/*12918*/ uint16(xReadCd),
+	/*12919*/ uint16(xArgRel32),
+	/*12920*/ uint16(xMatch),
+	/*12921*/ uint16(xCondDataSize), 12925, 12916, 12930,
+	/*12925*/ uint16(xSetOp), uint16(JMP),
+	/*12927*/ uint16(xReadCd),
+	/*12928*/ uint16(xArgRel32),
+	/*12929*/ uint16(xMatch),
+	/*12930*/ uint16(xSetOp), uint16(JMP),
+	/*12932*/ uint16(xReadCd),
+	/*12933*/ uint16(xArgRel32),
+	/*12934*/ uint16(xMatch),
+	/*12935*/ uint16(xCondIs64), 12938, 0,
+	/*12938*/ uint16(xCondDataSize), 12942, 12947, 0,
+	/*12942*/ uint16(xSetOp), uint16(LJMP),
+	/*12944*/ uint16(xReadCd),
+	/*12945*/ uint16(xArgPtr16colon16),
+	/*12946*/ uint16(xMatch),
+	/*12947*/ uint16(xSetOp), uint16(LJMP),
+	/*12949*/ uint16(xReadCp),
+	/*12950*/ uint16(xArgPtr16colon32),
 	/*12951*/ uint16(xMatch),
-	/*12952*/ uint16(xSetOp), uint16(IN),
-	/*12954*/ uint16(xArgEAX),
-	/*12955*/ uint16(xArgDX),
+	/*12952*/ uint16(xSetOp), uint16(JMP),
+	/*12954*/ uint16(xReadCb),
+	/*12955*/ uint16(xArgRel8),
 	/*12956*/ uint16(xMatch),
 	/*12957*/ uint16(xSetOp), uint16(IN),
-	/*12959*/ uint16(xArgEAX),
+	/*12959*/ uint16(xArgAL),
 	/*12960*/ uint16(xArgDX),
 	/*12961*/ uint16(xMatch),
-	/*12962*/ uint16(xSetOp), uint16(OUT),
-	/*12964*/ uint16(xArgDX),
-	/*12965*/ uint16(xArgAL),
-	/*12966*/ uint16(xMatch),
-	/*12967*/ uint16(xCondDataSize), 12971, 12976, 12981,
-	/*12971*/ uint16(xSetOp), uint16(OUT),
-	/*12973*/ uint16(xArgDX),
-	/*12974*/ uint16(xArgAX),
+	/*12962*/ uint16(xCondDataSize), 12966, 12971, 12976,
+	/*12966*/ uint16(xSetOp), uint16(IN),
+	/*12968*/ uint16(xArgAX),
+	/*12969*/ uint16(xArgDX),
+	/*12970*/ uint16(xMatch),
+	/*12971*/ uint16(xSetOp), uint16(IN),
+	/*12973*/ uint16(xArgEAX),
+	/*12974*/ uint16(xArgDX),
 	/*12975*/ uint16(xMatch),
-	/*12976*/ uint16(xSetOp), uint16(OUT),
-	/*12978*/ uint16(xArgDX),
-	/*12979*/ uint16(xArgEAX),
+	/*12976*/ uint16(xSetOp), uint16(IN),
+	/*12978*/ uint16(xArgEAX),
+	/*12979*/ uint16(xArgDX),
 	/*12980*/ uint16(xMatch),
 	/*12981*/ uint16(xSetOp), uint16(OUT),
 	/*12983*/ uint16(xArgDX),
-	/*12984*/ uint16(xArgEAX),
+	/*12984*/ uint16(xArgAL),
 	/*12985*/ uint16(xMatch),
-	/*12986*/ uint16(xSetOp), uint16(ICEBP),
-	/*12988*/ uint16(xMatch),
-	/*12989*/ uint16(xSetOp), uint16(HLT),
-	/*12991*/ uint16(xMatch),
-	/*12992*/ uint16(xSetOp), uint16(CMC),
+	/*12986*/ uint16(xCondDataSize), 12990, 12995, 13000,
+	/*12990*/ uint16(xSetOp), uint16(OUT),
+	/*12992*/ uint16(xArgDX),
+	/*12993*/ uint16(xArgAX),
 	/*12994*/ uint16(xMatch),
-	/*12995*/ uint16(xCondSlashR),
-	13004, // 0
-	0,     // 1
-	13010, // 2
-	13014, // 3
-	13018, // 4
-	13022, // 5
-	13026, // 6
-	13030, // 7
-	/*13004*/ uint16(xSetOp), uint16(TEST),
-	/*13006*/ uint16(xReadIb),
-	/*13007*/ uint16(xArgRM8),
-	/*13008*/ uint16(xArgImm8u),
-	/*13009*/ uint16(xMatch),
-	/*13010*/ uint16(xSetOp), uint16(NOT),
-	/*13012*/ uint16(xArgRM8),
+	/*12995*/ uint16(xSetOp), uint16(OUT),
+	/*12997*/ uint16(xArgDX),
+	/*12998*/ uint16(xArgEAX),
+	/*12999*/ uint16(xMatch),
+	/*13000*/ uint16(xSetOp), uint16(OUT),
+	/*13002*/ uint16(xArgDX),
+	/*13003*/ uint16(xArgEAX),
+	/*13004*/ uint16(xMatch),
+	/*13005*/ uint16(xSetOp), uint16(ICEBP),
+	/*13007*/ uint16(xMatch),
+	/*13008*/ uint16(xSetOp), uint16(HLT),
+	/*13010*/ uint16(xMatch),
+	/*13011*/ uint16(xSetOp), uint16(CMC),
 	/*13013*/ uint16(xMatch),
-	/*13014*/ uint16(xSetOp), uint16(NEG),
-	/*13016*/ uint16(xArgRM8),
-	/*13017*/ uint16(xMatch),
-	/*13018*/ uint16(xSetOp), uint16(MUL),
-	/*13020*/ uint16(xArgRM8),
-	/*13021*/ uint16(xMatch),
-	/*13022*/ uint16(xSetOp), uint16(IMUL),
-	/*13024*/ uint16(xArgRM8),
-	/*13025*/ uint16(xMatch),
-	/*13026*/ uint16(xSetOp), uint16(DIV),
-	/*13028*/ uint16(xArgRM8),
-	/*13029*/ uint16(xMatch),
-	/*13030*/ uint16(xSetOp), uint16(IDIV),
-	/*13032*/ uint16(xArgRM8),
-	/*13033*/ uint16(xMatch),
-	/*13034*/ uint16(xCondSlashR),
-	13043, // 0
+	/*13014*/ uint16(xCondSlashR),
+	13023, // 0
+	0,     // 1
+	13029, // 2
+	13033, // 3
+	13037, // 4
+	13041, // 5
+	13045, // 6
+	13049, // 7
+	/*13023*/ uint16(xSetOp), uint16(TEST),
+	/*13025*/ uint16(xReadIb),
+	/*13026*/ uint16(xArgRM8),
+	/*13027*/ uint16(xArgImm8u),
+	/*13028*/ uint16(xMatch),
+	/*13029*/ uint16(xSetOp), uint16(NOT),
+	/*13031*/ uint16(xArgRM8),
+	/*13032*/ uint16(xMatch),
+	/*13033*/ uint16(xSetOp), uint16(NEG),
+	/*13035*/ uint16(xArgRM8),
+	/*13036*/ uint16(xMatch),
+	/*13037*/ uint16(xSetOp), uint16(MUL),
+	/*13039*/ uint16(xArgRM8),
+	/*13040*/ uint16(xMatch),
+	/*13041*/ uint16(xSetOp), uint16(IMUL),
+	/*13043*/ uint16(xArgRM8),
+	/*13044*/ uint16(xMatch),
+	/*13045*/ uint16(xSetOp), uint16(DIV),
+	/*13047*/ uint16(xArgRM8),
+	/*13048*/ uint16(xMatch),
+	/*13049*/ uint16(xSetOp), uint16(IDIV),
+	/*13051*/ uint16(xArgRM8),
+	/*13052*/ uint16(xMatch),
+	/*13053*/ uint16(xCondSlashR),
+	13062, // 0
 	0,     // 1
-	13072, // 2
-	13095, // 3
-	13118, // 4
-	13141, // 5
-	13164, // 6
-	13187, // 7
-	/*13043*/ uint16(xCondIs64), 13046, 13062,
-	/*13046*/ uint16(xCondDataSize), 13050, 13056, 0,
-	/*13050*/ uint16(xSetOp), uint16(TEST),
-	/*13052*/ uint16(xReadIw),
-	/*13053*/ uint16(xArgRM16),
-	/*13054*/ uint16(xArgImm16),
-	/*13055*/ uint16(xMatch),
-	/*13056*/ uint16(xSetOp), uint16(TEST),
-	/*13058*/ uint16(xReadId),
-	/*13059*/ uint16(xArgRM32),
-	/*13060*/ uint16(xArgImm32),
-	/*13061*/ uint16(xMatch),
-	/*13062*/ uint16(xCondDataSize), 13050, 13056, 13066,
-	/*13066*/ uint16(xSetOp), uint16(TEST),
-	/*13068*/ uint16(xReadId),
-	/*13069*/ uint16(xArgRM64),
-	/*13070*/ uint16(xArgImm32),
-	/*13071*/ uint16(xMatch),
-	/*13072*/ uint16(xCondIs64), 13075, 13087,
-	/*13075*/ uint16(xCondDataSize), 13079, 13083, 0,
-	/*13079*/ uint16(xSetOp), uint16(NOT),
-	/*13081*/ uint16(xArgRM16),
-	/*13082*/ uint16(xMatch),
-	/*13083*/ uint16(xSetOp), uint16(NOT),
-	/*13085*/ uint16(xArgRM32),
-	/*13086*/ uint16(xMatch),
-	/*13087*/ uint16(xCondDataSize), 13079, 13083, 13091,
-	/*13091*/ uint16(xSetOp), uint16(NOT),
-	/*13093*/ uint16(xArgRM64),
-	/*13094*/ uint16(xMatch),
-	/*13095*/ uint16(xCondIs64), 13098, 13110,
-	/*13098*/ uint16(xCondDataSize), 13102, 13106, 0,
-	/*13102*/ uint16(xSetOp), uint16(NEG),
-	/*13104*/ uint16(xArgRM16),
+	13091, // 2
+	13114, // 3
+	13137, // 4
+	13160, // 5
+	13183, // 6
+	13206, // 7
+	/*13062*/ uint16(xCondIs64), 13065, 13081,
+	/*13065*/ uint16(xCondDataSize), 13069, 13075, 0,
+	/*13069*/ uint16(xSetOp), uint16(TEST),
+	/*13071*/ uint16(xReadIw),
+	/*13072*/ uint16(xArgRM16),
+	/*13073*/ uint16(xArgImm16),
+	/*13074*/ uint16(xMatch),
+	/*13075*/ uint16(xSetOp), uint16(TEST),
+	/*13077*/ uint16(xReadId),
+	/*13078*/ uint16(xArgRM32),
+	/*13079*/ uint16(xArgImm32),
+	/*13080*/ uint16(xMatch),
+	/*13081*/ uint16(xCondDataSize), 13069, 13075, 13085,
+	/*13085*/ uint16(xSetOp), uint16(TEST),
+	/*13087*/ uint16(xReadId),
+	/*13088*/ uint16(xArgRM64),
+	/*13089*/ uint16(xArgImm32),
+	/*13090*/ uint16(xMatch),
+	/*13091*/ uint16(xCondIs64), 13094, 13106,
+	/*13094*/ uint16(xCondDataSize), 13098, 13102, 0,
+	/*13098*/ uint16(xSetOp), uint16(NOT),
+	/*13100*/ uint16(xArgRM16),
+	/*13101*/ uint16(xMatch),
+	/*13102*/ uint16(xSetOp), uint16(NOT),
+	/*13104*/ uint16(xArgRM32),
 	/*13105*/ uint16(xMatch),
-	/*13106*/ uint16(xSetOp), uint16(NEG),
-	/*13108*/ uint16(xArgRM32),
-	/*13109*/ uint16(xMatch),
-	/*13110*/ uint16(xCondDataSize), 13102, 13106, 13114,
-	/*13114*/ uint16(xSetOp), uint16(NEG),
-	/*13116*/ uint16(xArgRM64),
-	/*13117*/ uint16(xMatch),
-	/*13118*/ uint16(xCondIs64), 13121, 13133,
-	/*13121*/ uint16(xCondDataSize), 13125, 13129, 0,
-	/*13125*/ uint16(xSetOp), uint16(MUL),
-	/*13127*/ uint16(xArgRM16),
+	/*13106*/ uint16(xCondDataSize), 13098, 13102, 13110,
+	/*13110*/ uint16(xSetOp), uint16(NOT),
+	/*13112*/ uint16(xArgRM64),
+	/*13113*/ uint16(xMatch),
+	/*13114*/ uint16(xCondIs64), 13117, 13129,
+	/*13117*/ uint16(xCondDataSize), 13121, 13125, 0,
+	/*13121*/ uint16(xSetOp), uint16(NEG),
+	/*13123*/ uint16(xArgRM16),
+	/*13124*/ uint16(xMatch),
+	/*13125*/ uint16(xSetOp), uint16(NEG),
+	/*13127*/ uint16(xArgRM32),
 	/*13128*/ uint16(xMatch),
-	/*13129*/ uint16(xSetOp), uint16(MUL),
-	/*13131*/ uint16(xArgRM32),
-	/*13132*/ uint16(xMatch),
-	/*13133*/ uint16(xCondDataSize), 13125, 13129, 13137,
-	/*13137*/ uint16(xSetOp), uint16(MUL),
-	/*13139*/ uint16(xArgRM64),
-	/*13140*/ uint16(xMatch),
-	/*13141*/ uint16(xCondIs64), 13144, 13156,
-	/*13144*/ uint16(xCondDataSize), 13148, 13152, 0,
-	/*13148*/ uint16(xSetOp), uint16(IMUL),
-	/*13150*/ uint16(xArgRM16),
+	/*13129*/ uint16(xCondDataSize), 13121, 13125, 13133,
+	/*13133*/ uint16(xSetOp), uint16(NEG),
+	/*13135*/ uint16(xArgRM64),
+	/*13136*/ uint16(xMatch),
+	/*13137*/ uint16(xCondIs64), 13140, 13152,
+	/*13140*/ uint16(xCondDataSize), 13144, 13148, 0,
+	/*13144*/ uint16(xSetOp), uint16(MUL),
+	/*13146*/ uint16(xArgRM16),
+	/*13147*/ uint16(xMatch),
+	/*13148*/ uint16(xSetOp), uint16(MUL),
+	/*13150*/ uint16(xArgRM32),
 	/*13151*/ uint16(xMatch),
-	/*13152*/ uint16(xSetOp), uint16(IMUL),
-	/*13154*/ uint16(xArgRM32),
-	/*13155*/ uint16(xMatch),
-	/*13156*/ uint16(xCondDataSize), 13148, 13152, 13160,
-	/*13160*/ uint16(xSetOp), uint16(IMUL),
-	/*13162*/ uint16(xArgRM64),
-	/*13163*/ uint16(xMatch),
-	/*13164*/ uint16(xCondIs64), 13167, 13179,
-	/*13167*/ uint16(xCondDataSize), 13171, 13175, 0,
-	/*13171*/ uint16(xSetOp), uint16(DIV),
-	/*13173*/ uint16(xArgRM16),
+	/*13152*/ uint16(xCondDataSize), 13144, 13148, 13156,
+	/*13156*/ uint16(xSetOp), uint16(MUL),
+	/*13158*/ uint16(xArgRM64),
+	/*13159*/ uint16(xMatch),
+	/*13160*/ uint16(xCondIs64), 13163, 13175,
+	/*13163*/ uint16(xCondDataSize), 13167, 13171, 0,
+	/*13167*/ uint16(xSetOp), uint16(IMUL),
+	/*13169*/ uint16(xArgRM16),
+	/*13170*/ uint16(xMatch),
+	/*13171*/ uint16(xSetOp), uint16(IMUL),
+	/*13173*/ uint16(xArgRM32),
 	/*13174*/ uint16(xMatch),
-	/*13175*/ uint16(xSetOp), uint16(DIV),
-	/*13177*/ uint16(xArgRM32),
-	/*13178*/ uint16(xMatch),
-	/*13179*/ uint16(xCondDataSize), 13171, 13175, 13183,
-	/*13183*/ uint16(xSetOp), uint16(DIV),
-	/*13185*/ uint16(xArgRM64),
-	/*13186*/ uint16(xMatch),
-	/*13187*/ uint16(xCondIs64), 13190, 13202,
-	/*13190*/ uint16(xCondDataSize), 13194, 13198, 0,
-	/*13194*/ uint16(xSetOp), uint16(IDIV),
-	/*13196*/ uint16(xArgRM16),
+	/*13175*/ uint16(xCondDataSize), 13167, 13171, 13179,
+	/*13179*/ uint16(xSetOp), uint16(IMUL),
+	/*13181*/ uint16(xArgRM64),
+	/*13182*/ uint16(xMatch),
+	/*13183*/ uint16(xCondIs64), 13186, 13198,
+	/*13186*/ uint16(xCondDataSize), 13190, 13194, 0,
+	/*13190*/ uint16(xSetOp), uint16(DIV),
+	/*13192*/ uint16(xArgRM16),
+	/*13193*/ uint16(xMatch),
+	/*13194*/ uint16(xSetOp), uint16(DIV),
+	/*13196*/ uint16(xArgRM32),
 	/*13197*/ uint16(xMatch),
-	/*13198*/ uint16(xSetOp), uint16(IDIV),
-	/*13200*/ uint16(xArgRM32),
-	/*13201*/ uint16(xMatch),
-	/*13202*/ uint16(xCondDataSize), 13194, 13198, 13206,
-	/*13206*/ uint16(xSetOp), uint16(IDIV),
-	/*13208*/ uint16(xArgRM64),
-	/*13209*/ uint16(xMatch),
-	/*13210*/ uint16(xSetOp), uint16(CLC),
-	/*13212*/ uint16(xMatch),
-	/*13213*/ uint16(xSetOp), uint16(STC),
-	/*13215*/ uint16(xMatch),
-	/*13216*/ uint16(xSetOp), uint16(CLI),
-	/*13218*/ uint16(xMatch),
-	/*13219*/ uint16(xSetOp), uint16(STI),
-	/*13221*/ uint16(xMatch),
-	/*13222*/ uint16(xSetOp), uint16(CLD),
-	/*13224*/ uint16(xMatch),
-	/*13225*/ uint16(xSetOp), uint16(STD),
-	/*13227*/ uint16(xMatch),
-	/*13228*/ uint16(xCondSlashR),
-	13237, // 0
-	13241, // 1
+	/*13198*/ uint16(xCondDataSize), 13190, 13194, 13202,
+	/*13202*/ uint16(xSetOp), uint16(DIV),
+	/*13204*/ uint16(xArgRM64),
+	/*13205*/ uint16(xMatch),
+	/*13206*/ uint16(xCondIs64), 13209, 13221,
+	/*13209*/ uint16(xCondDataSize), 13213, 13217, 0,
+	/*13213*/ uint16(xSetOp), uint16(IDIV),
+	/*13215*/ uint16(xArgRM16),
+	/*13216*/ uint16(xMatch),
+	/*13217*/ uint16(xSetOp), uint16(IDIV),
+	/*13219*/ uint16(xArgRM32),
+	/*13220*/ uint16(xMatch),
+	/*13221*/ uint16(xCondDataSize), 13213, 13217, 13225,
+	/*13225*/ uint16(xSetOp), uint16(IDIV),
+	/*13227*/ uint16(xArgRM64),
+	/*13228*/ uint16(xMatch),
+	/*13229*/ uint16(xSetOp), uint16(CLC),
+	/*13231*/ uint16(xMatch),
+	/*13232*/ uint16(xSetOp), uint16(STC),
+	/*13234*/ uint16(xMatch),
+	/*13235*/ uint16(xSetOp), uint16(CLI),
+	/*13237*/ uint16(xMatch),
+	/*13238*/ uint16(xSetOp), uint16(STI),
+	/*13240*/ uint16(xMatch),
+	/*13241*/ uint16(xSetOp), uint16(CLD),
+	/*13243*/ uint16(xMatch),
+	/*13244*/ uint16(xSetOp), uint16(STD),
+	/*13246*/ uint16(xMatch),
+	/*13247*/ uint16(xCondSlashR),
+	13256, // 0
+	13260, // 1
 	0,     // 2
 	0,     // 3
 	0,     // 4
 	0,     // 5
 	0,     // 6
 	0,     // 7
-	/*13237*/ uint16(xSetOp), uint16(INC),
-	/*13239*/ uint16(xArgRM8),
-	/*13240*/ uint16(xMatch),
-	/*13241*/ uint16(xSetOp), uint16(DEC),
-	/*13243*/ uint16(xArgRM8),
-	/*13244*/ uint16(xMatch),
-	/*13245*/ uint16(xCondSlashR),
-	13254, // 0
-	13277, // 1
-	13300, // 2
-	13319, // 3
-	13342, // 4
-	13361, // 5
-	13384, // 6
+	/*13256*/ uint16(xSetOp), uint16(INC),
+	/*13258*/ uint16(xArgRM8),
+	/*13259*/ uint16(xMatch),
+	/*13260*/ uint16(xSetOp), uint16(DEC),
+	/*13262*/ uint16(xArgRM8),
+	/*13263*/ uint16(xMatch),
+	/*13264*/ uint16(xCondSlashR),
+	13273, // 0
+	13296, // 1
+	13319, // 2
+	13338, // 3
+	13361, // 4
+	13380, // 5
+	13403, // 6
 	0,     // 7
-	/*13254*/ uint16(xCondIs64), 13257, 13269,
-	/*13257*/ uint16(xCondDataSize), 13261, 13265, 0,
-	/*13261*/ uint16(xSetOp), uint16(INC),
-	/*13263*/ uint16(xArgRM16),
-	/*13264*/ uint16(xMatch),
-	/*13265*/ uint16(xSetOp), uint16(INC),
-	/*13267*/ uint16(xArgRM32),
-	/*13268*/ uint16(xMatch),
-	/*13269*/ uint16(xCondDataSize), 13261, 13265, 13273,
-	/*13273*/ uint16(xSetOp), uint16(INC),
-	/*13275*/ uint16(xArgRM64),
-	/*13276*/ uint16(xMatch),
-	/*13277*/ uint16(xCondIs64), 13280, 13292,
-	/*13280*/ uint16(xCondDataSize), 13284, 13288, 0,
-	/*13284*/ uint16(xSetOp), uint16(DEC),
-	/*13286*/ uint16(xArgRM16),
+	/*13273*/ uint16(xCondIs64), 13276, 13288,
+	/*13276*/ uint16(xCondDataSize), 13280, 13284, 0,
+	/*13280*/ uint16(xSetOp), uint16(INC),
+	/*13282*/ uint16(xArgRM16),
+	/*13283*/ uint16(xMatch),
+	/*13284*/ uint16(xSetOp), uint16(INC),
+	/*13286*/ uint16(xArgRM32),
 	/*13287*/ uint16(xMatch),
-	/*13288*/ uint16(xSetOp), uint16(DEC),
-	/*13290*/ uint16(xArgRM32),
-	/*13291*/ uint16(xMatch),
-	/*13292*/ uint16(xCondDataSize), 13284, 13288, 13296,
-	/*13296*/ uint16(xSetOp), uint16(DEC),
-	/*13298*/ uint16(xArgRM64),
-	/*13299*/ uint16(xMatch),
-	/*13300*/ uint16(xCondIs64), 13303, 13315,
-	/*13303*/ uint16(xCondDataSize), 13307, 13311, 0,
-	/*13307*/ uint16(xSetOp), uint16(CALL),
-	/*13309*/ uint16(xArgRM16),
+	/*13288*/ uint16(xCondDataSize), 13280, 13284, 13292,
+	/*13292*/ uint16(xSetOp), uint16(INC),
+	/*13294*/ uint16(xArgRM64),
+	/*13295*/ uint16(xMatch),
+	/*13296*/ uint16(xCondIs64), 13299, 13311,
+	/*13299*/ uint16(xCondDataSize), 13303, 13307, 0,
+	/*13303*/ uint16(xSetOp), uint16(DEC),
+	/*13305*/ uint16(xArgRM16),
+	/*13306*/ uint16(xMatch),
+	/*13307*/ uint16(xSetOp), uint16(DEC),
+	/*13309*/ uint16(xArgRM32),
 	/*13310*/ uint16(xMatch),
-	/*13311*/ uint16(xSetOp), uint16(CALL),
-	/*13313*/ uint16(xArgRM32),
-	/*13314*/ uint16(xMatch),
-	/*13315*/ uint16(xSetOp), uint16(CALL),
+	/*13311*/ uint16(xCondDataSize), 13303, 13307, 13315,
+	/*13315*/ uint16(xSetOp), uint16(DEC),
 	/*13317*/ uint16(xArgRM64),
 	/*13318*/ uint16(xMatch),
 	/*13319*/ uint16(xCondIs64), 13322, 13334,
 	/*13322*/ uint16(xCondDataSize), 13326, 13330, 0,
-	/*13326*/ uint16(xSetOp), uint16(LCALL),
-	/*13328*/ uint16(xArgM16colon16),
+	/*13326*/ uint16(xSetOp), uint16(CALL),
+	/*13328*/ uint16(xArgRM16),
 	/*13329*/ uint16(xMatch),
-	/*13330*/ uint16(xSetOp), uint16(LCALL),
-	/*13332*/ uint16(xArgM16colon32),
+	/*13330*/ uint16(xSetOp), uint16(CALL),
+	/*13332*/ uint16(xArgRM32),
 	/*13333*/ uint16(xMatch),
-	/*13334*/ uint16(xCondDataSize), 13326, 13330, 13338,
-	/*13338*/ uint16(xSetOp), uint16(LCALL),
-	/*13340*/ uint16(xArgM16colon64),
-	/*13341*/ uint16(xMatch),
-	/*13342*/ uint16(xCondIs64), 13345, 13357,
-	/*13345*/ uint16(xCondDataSize), 13349, 13353, 0,
-	/*13349*/ uint16(xSetOp), uint16(JMP),
-	/*13351*/ uint16(xArgRM16),
+	/*13334*/ uint16(xSetOp), uint16(CALL),
+	/*13336*/ uint16(xArgRM64),
+	/*13337*/ uint16(xMatch),
+	/*13338*/ uint16(xCondIs64), 13341, 13353,
+	/*13341*/ uint16(xCondDataSize), 13345, 13349, 0,
+	/*13345*/ uint16(xSetOp), uint16(LCALL),
+	/*13347*/ uint16(xArgM16colon16),
+	/*13348*/ uint16(xMatch),
+	/*13349*/ uint16(xSetOp), uint16(LCALL),
+	/*13351*/ uint16(xArgM16colon32),
 	/*13352*/ uint16(xMatch),
-	/*13353*/ uint16(xSetOp), uint16(JMP),
-	/*13355*/ uint16(xArgRM32),
-	/*13356*/ uint16(xMatch),
-	/*13357*/ uint16(xSetOp), uint16(JMP),
-	/*13359*/ uint16(xArgRM64),
+	/*13353*/ uint16(xCondDataSize), 13345, 13349, 13357,
+	/*13357*/ uint16(xSetOp), uint16(LCALL),
+	/*13359*/ uint16(xArgM16colon64),
 	/*13360*/ uint16(xMatch),
 	/*13361*/ uint16(xCondIs64), 13364, 13376,
 	/*13364*/ uint16(xCondDataSize), 13368, 13372, 0,
-	/*13368*/ uint16(xSetOp), uint16(LJMP),
-	/*13370*/ uint16(xArgM16colon16),
+	/*13368*/ uint16(xSetOp), uint16(JMP),
+	/*13370*/ uint16(xArgRM16),
 	/*13371*/ uint16(xMatch),
-	/*13372*/ uint16(xSetOp), uint16(LJMP),
-	/*13374*/ uint16(xArgM16colon32),
+	/*13372*/ uint16(xSetOp), uint16(JMP),
+	/*13374*/ uint16(xArgRM32),
 	/*13375*/ uint16(xMatch),
-	/*13376*/ uint16(xCondDataSize), 13368, 13372, 13380,
-	/*13380*/ uint16(xSetOp), uint16(LJMP),
-	/*13382*/ uint16(xArgM16colon64),
-	/*13383*/ uint16(xMatch),
-	/*13384*/ uint16(xCondIs64), 13387, 13399,
-	/*13387*/ uint16(xCondDataSize), 13391, 13395, 0,
-	/*13391*/ uint16(xSetOp), uint16(PUSH),
-	/*13393*/ uint16(xArgRM16),
+	/*13376*/ uint16(xSetOp), uint16(JMP),
+	/*13378*/ uint16(xArgRM64),
+	/*13379*/ uint16(xMatch),
+	/*13380*/ uint16(xCondIs64), 13383, 13395,
+	/*13383*/ uint16(xCondDataSize), 13387, 13391, 0,
+	/*13387*/ uint16(xSetOp), uint16(LJMP),
+	/*13389*/ uint16(xArgM16colon16),
+	/*13390*/ uint16(xMatch),
+	/*13391*/ uint16(xSetOp), uint16(LJMP),
+	/*13393*/ uint16(xArgM16colon32),
 	/*13394*/ uint16(xMatch),
-	/*13395*/ uint16(xSetOp), uint16(PUSH),
-	/*13397*/ uint16(xArgRM32),
-	/*13398*/ uint16(xMatch),
-	/*13399*/ uint16(xCondDataSize), 13391, 13403, 13407,
-	/*13403*/ uint16(xSetOp), uint16(PUSH),
-	/*13405*/ uint16(xArgRM64),
-	/*13406*/ uint16(xMatch),
-	/*13407*/ uint16(xSetOp), uint16(PUSH),
-	/*13409*/ uint16(xArgRM64),
-	/*13410*/ uint16(xMatch),
+	/*13395*/ uint16(xCondDataSize), 13387, 13391, 13399,
+	/*13399*/ uint16(xSetOp), uint16(LJMP),
+	/*13401*/ uint16(xArgM16colon64),
+	/*13402*/ uint16(xMatch),
+	/*13403*/ uint16(xCondIs64), 13406, 13418,
+	/*13406*/ uint16(xCondDataSize), 13410, 13414, 0,
+	/*13410*/ uint16(xSetOp), uint16(PUSH),
+	/*13412*/ uint16(xArgRM16),
+	/*13413*/ uint16(xMatch),
+	/*13414*/ uint16(xSetOp), uint16(PUSH),
+	/*13416*/ uint16(xArgRM32),
+	/*13417*/ uint16(xMatch),
+	/*13418*/ uint16(xCondDataSize), 13410, 13422, 13426,
+	/*13422*/ uint16(xSetOp), uint16(PUSH),
+	/*13424*/ uint16(xArgRM64),
+	/*13425*/ uint16(xMatch),
+	/*13426*/ uint16(xSetOp), uint16(PUSH),
+	/*13428*/ uint16(xArgRM64),
+	/*13429*/ uint16(xMatch),
 }
 
 const (
@@ -9251,6 +9262,7 @@ const (
 	TZCNT
 	UCOMISD
 	UCOMISS
+	UD0
 	UD1
 	UD2
 	UNPCKHPD
@@ -9868,6 +9880,7 @@ var opNames = [...]string{
 	TZCNT:           "TZCNT",
 	UCOMISD:         "UCOMISD",
 	UCOMISS:         "UCOMISS",
+	UD0:             "UD0",
 	UD1:             "UD1",
 	UD2:             "UD2",
 	UNPCKHPD:        "UNPCKHPD",
diff --git a/src/cmd/vendor/golang.org/x/crypto/ed25519/ed25519.go b/src/cmd/vendor/golang.org/x/crypto/ed25519/ed25519.go
index c7f8c7e64e..71ad917dad 100644
--- a/src/cmd/vendor/golang.org/x/crypto/ed25519/ed25519.go
+++ b/src/cmd/vendor/golang.org/x/crypto/ed25519/ed25519.go
@@ -5,6 +5,7 @@
 // In Go 1.13, the ed25519 package was promoted to the standard library as
 // crypto/ed25519, and this package became a wrapper for the standard library one.
 //
+//go:build !go1.13
 // +build !go1.13
 
 // Package ed25519 implements the Ed25519 signature algorithm. See
diff --git a/src/cmd/vendor/golang.org/x/crypto/ed25519/ed25519_go113.go b/src/cmd/vendor/golang.org/x/crypto/ed25519/ed25519_go113.go
index d1448d8d22..b5974dc8b2 100644
--- a/src/cmd/vendor/golang.org/x/crypto/ed25519/ed25519_go113.go
+++ b/src/cmd/vendor/golang.org/x/crypto/ed25519/ed25519_go113.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.13
 // +build go1.13
 
 // Package ed25519 implements the Ed25519 signature algorithm. See
diff --git a/src/cmd/vendor/golang.org/x/crypto/ssh/terminal/terminal.go b/src/cmd/vendor/golang.org/x/crypto/ssh/terminal/terminal.go
index 2ffb97bfb8..a4d1919a9e 100644
--- a/src/cmd/vendor/golang.org/x/crypto/ssh/terminal/terminal.go
+++ b/src/cmd/vendor/golang.org/x/crypto/ssh/terminal/terminal.go
@@ -2,986 +2,75 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// Package terminal provides support functions for dealing with terminals, as
+// commonly found on UNIX systems.
+//
+// Deprecated: this package moved to golang.org/x/term.
 package terminal
 
 import (
-	"bytes"
 	"io"
-	"runtime"
-	"strconv"
-	"sync"
-	"unicode/utf8"
+
+	"golang.org/x/term"
 )
 
 // EscapeCodes contains escape sequences that can be written to the terminal in
 // order to achieve different styles of text.
-type EscapeCodes struct {
-	// Foreground colors
-	Black, Red, Green, Yellow, Blue, Magenta, Cyan, White []byte
-
-	// Reset all attributes
-	Reset []byte
-}
-
-var vt100EscapeCodes = EscapeCodes{
-	Black:   []byte{keyEscape, '[', '3', '0', 'm'},
-	Red:     []byte{keyEscape, '[', '3', '1', 'm'},
-	Green:   []byte{keyEscape, '[', '3', '2', 'm'},
-	Yellow:  []byte{keyEscape, '[', '3', '3', 'm'},
-	Blue:    []byte{keyEscape, '[', '3', '4', 'm'},
-	Magenta: []byte{keyEscape, '[', '3', '5', 'm'},
-	Cyan:    []byte{keyEscape, '[', '3', '6', 'm'},
-	White:   []byte{keyEscape, '[', '3', '7', 'm'},
-
-	Reset: []byte{keyEscape, '[', '0', 'm'},
-}
+type EscapeCodes = term.EscapeCodes
 
 // Terminal contains the state for running a VT100 terminal that is capable of
 // reading lines of input.
-type Terminal struct {
-	// AutoCompleteCallback, if non-null, is called for each keypress with
-	// the full input line and the current position of the cursor (in
-	// bytes, as an index into |line|). If it returns ok=false, the key
-	// press is processed normally. Otherwise it returns a replacement line
-	// and the new cursor position.
-	AutoCompleteCallback func(line string, pos int, key rune) (newLine string, newPos int, ok bool)
-
-	// Escape contains a pointer to the escape codes for this terminal.
-	// It's always a valid pointer, although the escape codes themselves
-	// may be empty if the terminal doesn't support them.
-	Escape *EscapeCodes
-
-	// lock protects the terminal and the state in this object from
-	// concurrent processing of a key press and a Write() call.
-	lock sync.Mutex
-
-	c      io.ReadWriter
-	prompt []rune
-
-	// line is the current line being entered.
-	line []rune
-	// pos is the logical position of the cursor in line
-	pos int
-	// echo is true if local echo is enabled
-	echo bool
-	// pasteActive is true iff there is a bracketed paste operation in
-	// progress.
-	pasteActive bool
-
-	// cursorX contains the current X value of the cursor where the left
-	// edge is 0. cursorY contains the row number where the first row of
-	// the current line is 0.
-	cursorX, cursorY int
-	// maxLine is the greatest value of cursorY so far.
-	maxLine int
-
-	termWidth, termHeight int
-
-	// outBuf contains the terminal data to be sent.
-	outBuf []byte
-	// remainder contains the remainder of any partial key sequences after
-	// a read. It aliases into inBuf.
-	remainder []byte
-	inBuf     [256]byte
-
-	// history contains previously entered commands so that they can be
-	// accessed with the up and down keys.
-	history stRingBuffer
-	// historyIndex stores the currently accessed history entry, where zero
-	// means the immediately previous entry.
-	historyIndex int
-	// When navigating up and down the history it's possible to return to
-	// the incomplete, initial line. That value is stored in
-	// historyPending.
-	historyPending string
-}
+type Terminal = term.Terminal
 
 // NewTerminal runs a VT100 terminal on the given ReadWriter. If the ReadWriter is
 // a local terminal, that terminal must first have been put into raw mode.
 // prompt is a string that is written at the start of each input line (i.e.
 // "> ").
 func NewTerminal(c io.ReadWriter, prompt string) *Terminal {
-	return &Terminal{
-		Escape:       &vt100EscapeCodes,
-		c:            c,
-		prompt:       []rune(prompt),
-		termWidth:    80,
-		termHeight:   24,
-		echo:         true,
-		historyIndex: -1,
-	}
-}
-
-const (
-	keyCtrlC     = 3
-	keyCtrlD     = 4
-	keyCtrlU     = 21
-	keyEnter     = '\r'
-	keyEscape    = 27
-	keyBackspace = 127
-	keyUnknown   = 0xd800 /* UTF-16 surrogate area */ + iota
-	keyUp
-	keyDown
-	keyLeft
-	keyRight
-	keyAltLeft
-	keyAltRight
-	keyHome
-	keyEnd
-	keyDeleteWord
-	keyDeleteLine
-	keyClearScreen
-	keyPasteStart
-	keyPasteEnd
-)
-
-var (
-	crlf       = []byte{'\r', '\n'}
-	pasteStart = []byte{keyEscape, '[', '2', '0', '0', '~'}
-	pasteEnd   = []byte{keyEscape, '[', '2', '0', '1', '~'}
-)
-
-// bytesToKey tries to parse a key sequence from b. If successful, it returns
-// the key and the remainder of the input. Otherwise it returns utf8.RuneError.
-func bytesToKey(b []byte, pasteActive bool) (rune, []byte) {
-	if len(b) == 0 {
-		return utf8.RuneError, nil
-	}
-
-	if !pasteActive {
-		switch b[0] {
-		case 1: // ^A
-			return keyHome, b[1:]
-		case 2: // ^B
-			return keyLeft, b[1:]
-		case 5: // ^E
-			return keyEnd, b[1:]
-		case 6: // ^F
-			return keyRight, b[1:]
-		case 8: // ^H
-			return keyBackspace, b[1:]
-		case 11: // ^K
-			return keyDeleteLine, b[1:]
-		case 12: // ^L
-			return keyClearScreen, b[1:]
-		case 23: // ^W
-			return keyDeleteWord, b[1:]
-		case 14: // ^N
-			return keyDown, b[1:]
-		case 16: // ^P
-			return keyUp, b[1:]
-		}
-	}
-
-	if b[0] != keyEscape {
-		if !utf8.FullRune(b) {
-			return utf8.RuneError, b
-		}
-		r, l := utf8.DecodeRune(b)
-		return r, b[l:]
-	}
-
-	if !pasteActive && len(b) >= 3 && b[0] == keyEscape && b[1] == '[' {
-		switch b[2] {
-		case 'A':
-			return keyUp, b[3:]
-		case 'B':
-			return keyDown, b[3:]
-		case 'C':
-			return keyRight, b[3:]
-		case 'D':
-			return keyLeft, b[3:]
-		case 'H':
-			return keyHome, b[3:]
-		case 'F':
-			return keyEnd, b[3:]
-		}
-	}
-
-	if !pasteActive && len(b) >= 6 && b[0] == keyEscape && b[1] == '[' && b[2] == '1' && b[3] == ';' && b[4] == '3' {
-		switch b[5] {
-		case 'C':
-			return keyAltRight, b[6:]
-		case 'D':
-			return keyAltLeft, b[6:]
-		}
-	}
-
-	if !pasteActive && len(b) >= 6 && bytes.Equal(b[:6], pasteStart) {
-		return keyPasteStart, b[6:]
-	}
-
-	if pasteActive && len(b) >= 6 && bytes.Equal(b[:6], pasteEnd) {
-		return keyPasteEnd, b[6:]
-	}
-
-	// If we get here then we have a key that we don't recognise, or a
-	// partial sequence. It's not clear how one should find the end of a
-	// sequence without knowing them all, but it seems that [a-zA-Z~] only
-	// appears at the end of a sequence.
-	for i, c := range b[0:] {
-		if c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c == '~' {
-			return keyUnknown, b[i+1:]
-		}
-	}
-
-	return utf8.RuneError, b
-}
-
-// queue appends data to the end of t.outBuf
-func (t *Terminal) queue(data []rune) {
-	t.outBuf = append(t.outBuf, []byte(string(data))...)
-}
-
-var eraseUnderCursor = []rune{' ', keyEscape, '[', 'D'}
-var space = []rune{' '}
-
-func isPrintable(key rune) bool {
-	isInSurrogateArea := key >= 0xd800 && key <= 0xdbff
-	return key >= 32 && !isInSurrogateArea
-}
-
-// moveCursorToPos appends data to t.outBuf which will move the cursor to the
-// given, logical position in the text.
-func (t *Terminal) moveCursorToPos(pos int) {
-	if !t.echo {
-		return
-	}
-
-	x := visualLength(t.prompt) + pos
-	y := x / t.termWidth
-	x = x % t.termWidth
-
-	up := 0
-	if y < t.cursorY {
-		up = t.cursorY - y
-	}
-
-	down := 0
-	if y > t.cursorY {
-		down = y - t.cursorY
-	}
-
-	left := 0
-	if x < t.cursorX {
-		left = t.cursorX - x
-	}
-
-	right := 0
-	if x > t.cursorX {
-		right = x - t.cursorX
-	}
-
-	t.cursorX = x
-	t.cursorY = y
-	t.move(up, down, left, right)
-}
-
-func (t *Terminal) move(up, down, left, right int) {
-	m := []rune{}
-
-	// 1 unit up can be expressed as ^[[A or ^[A
-	// 5 units up can be expressed as ^[[5A
-
-	if up == 1 {
-		m = append(m, keyEscape, '[', 'A')
-	} else if up > 1 {
-		m = append(m, keyEscape, '[')
-		m = append(m, []rune(strconv.Itoa(up))...)
-		m = append(m, 'A')
-	}
-
-	if down == 1 {
-		m = append(m, keyEscape, '[', 'B')
-	} else if down > 1 {
-		m = append(m, keyEscape, '[')
-		m = append(m, []rune(strconv.Itoa(down))...)
-		m = append(m, 'B')
-	}
-
-	if right == 1 {
-		m = append(m, keyEscape, '[', 'C')
-	} else if right > 1 {
-		m = append(m, keyEscape, '[')
-		m = append(m, []rune(strconv.Itoa(right))...)
-		m = append(m, 'C')
-	}
-
-	if left == 1 {
-		m = append(m, keyEscape, '[', 'D')
-	} else if left > 1 {
-		m = append(m, keyEscape, '[')
-		m = append(m, []rune(strconv.Itoa(left))...)
-		m = append(m, 'D')
-	}
-
-	t.queue(m)
-}
-
-func (t *Terminal) clearLineToRight() {
-	op := []rune{keyEscape, '[', 'K'}
-	t.queue(op)
-}
-
-const maxLineLength = 4096
-
-func (t *Terminal) setLine(newLine []rune, newPos int) {
-	if t.echo {
-		t.moveCursorToPos(0)
-		t.writeLine(newLine)
-		for i := len(newLine); i < len(t.line); i++ {
-			t.writeLine(space)
-		}
-		t.moveCursorToPos(newPos)
-	}
-	t.line = newLine
-	t.pos = newPos
-}
-
-func (t *Terminal) advanceCursor(places int) {
-	t.cursorX += places
-	t.cursorY += t.cursorX / t.termWidth
-	if t.cursorY > t.maxLine {
-		t.maxLine = t.cursorY
-	}
-	t.cursorX = t.cursorX % t.termWidth
-
-	if places > 0 && t.cursorX == 0 {
-		// Normally terminals will advance the current position
-		// when writing a character. But that doesn't happen
-		// for the last character in a line. However, when
-		// writing a character (except a new line) that causes
-		// a line wrap, the position will be advanced two
-		// places.
-		//
-		// So, if we are stopping at the end of a line, we
-		// need to write a newline so that our cursor can be
-		// advanced to the next line.
-		t.outBuf = append(t.outBuf, '\r', '\n')
-	}
-}
-
-func (t *Terminal) eraseNPreviousChars(n int) {
-	if n == 0 {
-		return
-	}
-
-	if t.pos < n {
-		n = t.pos
-	}
-	t.pos -= n
-	t.moveCursorToPos(t.pos)
-
-	copy(t.line[t.pos:], t.line[n+t.pos:])
-	t.line = t.line[:len(t.line)-n]
-	if t.echo {
-		t.writeLine(t.line[t.pos:])
-		for i := 0; i < n; i++ {
-			t.queue(space)
-		}
-		t.advanceCursor(n)
-		t.moveCursorToPos(t.pos)
-	}
-}
-
-// countToLeftWord returns then number of characters from the cursor to the
-// start of the previous word.
-func (t *Terminal) countToLeftWord() int {
-	if t.pos == 0 {
-		return 0
-	}
-
-	pos := t.pos - 1
-	for pos > 0 {
-		if t.line[pos] != ' ' {
-			break
-		}
-		pos--
-	}
-	for pos > 0 {
-		if t.line[pos] == ' ' {
-			pos++
-			break
-		}
-		pos--
-	}
-
-	return t.pos - pos
-}
-
-// countToRightWord returns then number of characters from the cursor to the
-// start of the next word.
-func (t *Terminal) countToRightWord() int {
-	pos := t.pos
-	for pos < len(t.line) {
-		if t.line[pos] == ' ' {
-			break
-		}
-		pos++
-	}
-	for pos < len(t.line) {
-		if t.line[pos] != ' ' {
-			break
-		}
-		pos++
-	}
-	return pos - t.pos
-}
-
-// visualLength returns the number of visible glyphs in s.
-func visualLength(runes []rune) int {
-	inEscapeSeq := false
-	length := 0
-
-	for _, r := range runes {
-		switch {
-		case inEscapeSeq:
-			if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') {
-				inEscapeSeq = false
-			}
-		case r == '\x1b':
-			inEscapeSeq = true
-		default:
-			length++
-		}
-	}
-
-	return length
-}
-
-// handleKey processes the given key and, optionally, returns a line of text
-// that the user has entered.
-func (t *Terminal) handleKey(key rune) (line string, ok bool) {
-	if t.pasteActive && key != keyEnter {
-		t.addKeyToLine(key)
-		return
-	}
-
-	switch key {
-	case keyBackspace:
-		if t.pos == 0 {
-			return
-		}
-		t.eraseNPreviousChars(1)
-	case keyAltLeft:
-		// move left by a word.
-		t.pos -= t.countToLeftWord()
-		t.moveCursorToPos(t.pos)
-	case keyAltRight:
-		// move right by a word.
-		t.pos += t.countToRightWord()
-		t.moveCursorToPos(t.pos)
-	case keyLeft:
-		if t.pos == 0 {
-			return
-		}
-		t.pos--
-		t.moveCursorToPos(t.pos)
-	case keyRight:
-		if t.pos == len(t.line) {
-			return
-		}
-		t.pos++
-		t.moveCursorToPos(t.pos)
-	case keyHome:
-		if t.pos == 0 {
-			return
-		}
-		t.pos = 0
-		t.moveCursorToPos(t.pos)
-	case keyEnd:
-		if t.pos == len(t.line) {
-			return
-		}
-		t.pos = len(t.line)
-		t.moveCursorToPos(t.pos)
-	case keyUp:
-		entry, ok := t.history.NthPreviousEntry(t.historyIndex + 1)
-		if !ok {
-			return "", false
-		}
-		if t.historyIndex == -1 {
-			t.historyPending = string(t.line)
-		}
-		t.historyIndex++
-		runes := []rune(entry)
-		t.setLine(runes, len(runes))
-	case keyDown:
-		switch t.historyIndex {
-		case -1:
-			return
-		case 0:
-			runes := []rune(t.historyPending)
-			t.setLine(runes, len(runes))
-			t.historyIndex--
-		default:
-			entry, ok := t.history.NthPreviousEntry(t.historyIndex - 1)
-			if ok {
-				t.historyIndex--
-				runes := []rune(entry)
-				t.setLine(runes, len(runes))
-			}
-		}
-	case keyEnter:
-		t.moveCursorToPos(len(t.line))
-		t.queue([]rune("\r\n"))
-		line = string(t.line)
-		ok = true
-		t.line = t.line[:0]
-		t.pos = 0
-		t.cursorX = 0
-		t.cursorY = 0
-		t.maxLine = 0
-	case keyDeleteWord:
-		// Delete zero or more spaces and then one or more characters.
-		t.eraseNPreviousChars(t.countToLeftWord())
-	case keyDeleteLine:
-		// Delete everything from the current cursor position to the
-		// end of line.
-		for i := t.pos; i < len(t.line); i++ {
-			t.queue(space)
-			t.advanceCursor(1)
-		}
-		t.line = t.line[:t.pos]
-		t.moveCursorToPos(t.pos)
-	case keyCtrlD:
-		// Erase the character under the current position.
-		// The EOF case when the line is empty is handled in
-		// readLine().
-		if t.pos < len(t.line) {
-			t.pos++
-			t.eraseNPreviousChars(1)
-		}
-	case keyCtrlU:
-		t.eraseNPreviousChars(t.pos)
-	case keyClearScreen:
-		// Erases the screen and moves the cursor to the home position.
-		t.queue([]rune("\x1b[2J\x1b[H"))
-		t.queue(t.prompt)
-		t.cursorX, t.cursorY = 0, 0
-		t.advanceCursor(visualLength(t.prompt))
-		t.setLine(t.line, t.pos)
-	default:
-		if t.AutoCompleteCallback != nil {
-			prefix := string(t.line[:t.pos])
-			suffix := string(t.line[t.pos:])
-
-			t.lock.Unlock()
-			newLine, newPos, completeOk := t.AutoCompleteCallback(prefix+suffix, len(prefix), key)
-			t.lock.Lock()
-
-			if completeOk {
-				t.setLine([]rune(newLine), utf8.RuneCount([]byte(newLine)[:newPos]))
-				return
-			}
-		}
-		if !isPrintable(key) {
-			return
-		}
-		if len(t.line) == maxLineLength {
-			return
-		}
-		t.addKeyToLine(key)
-	}
-	return
-}
-
-// addKeyToLine inserts the given key at the current position in the current
-// line.
-func (t *Terminal) addKeyToLine(key rune) {
-	if len(t.line) == cap(t.line) {
-		newLine := make([]rune, len(t.line), 2*(1+len(t.line)))
-		copy(newLine, t.line)
-		t.line = newLine
-	}
-	t.line = t.line[:len(t.line)+1]
-	copy(t.line[t.pos+1:], t.line[t.pos:])
-	t.line[t.pos] = key
-	if t.echo {
-		t.writeLine(t.line[t.pos:])
-	}
-	t.pos++
-	t.moveCursorToPos(t.pos)
-}
-
-func (t *Terminal) writeLine(line []rune) {
-	for len(line) != 0 {
-		remainingOnLine := t.termWidth - t.cursorX
-		todo := len(line)
-		if todo > remainingOnLine {
-			todo = remainingOnLine
-		}
-		t.queue(line[:todo])
-		t.advanceCursor(visualLength(line[:todo]))
-		line = line[todo:]
-	}
-}
-
-// writeWithCRLF writes buf to w but replaces all occurrences of \n with \r\n.
-func writeWithCRLF(w io.Writer, buf []byte) (n int, err error) {
-	for len(buf) > 0 {
-		i := bytes.IndexByte(buf, '\n')
-		todo := len(buf)
-		if i >= 0 {
-			todo = i
-		}
-
-		var nn int
-		nn, err = w.Write(buf[:todo])
-		n += nn
-		if err != nil {
-			return n, err
-		}
-		buf = buf[todo:]
-
-		if i >= 0 {
-			if _, err = w.Write(crlf); err != nil {
-				return n, err
-			}
-			n++
-			buf = buf[1:]
-		}
-	}
-
-	return n, nil
-}
-
-func (t *Terminal) Write(buf []byte) (n int, err error) {
-	t.lock.Lock()
-	defer t.lock.Unlock()
-
-	if t.cursorX == 0 && t.cursorY == 0 {
-		// This is the easy case: there's nothing on the screen that we
-		// have to move out of the way.
-		return writeWithCRLF(t.c, buf)
-	}
-
-	// We have a prompt and possibly user input on the screen. We
-	// have to clear it first.
-	t.move(0 /* up */, 0 /* down */, t.cursorX /* left */, 0 /* right */)
-	t.cursorX = 0
-	t.clearLineToRight()
-
-	for t.cursorY > 0 {
-		t.move(1 /* up */, 0, 0, 0)
-		t.cursorY--
-		t.clearLineToRight()
-	}
-
-	if _, err = t.c.Write(t.outBuf); err != nil {
-		return
-	}
-	t.outBuf = t.outBuf[:0]
-
-	if n, err = writeWithCRLF(t.c, buf); err != nil {
-		return
-	}
-
-	t.writeLine(t.prompt)
-	if t.echo {
-		t.writeLine(t.line)
-	}
-
-	t.moveCursorToPos(t.pos)
-
-	if _, err = t.c.Write(t.outBuf); err != nil {
-		return
-	}
-	t.outBuf = t.outBuf[:0]
-	return
-}
-
-// ReadPassword temporarily changes the prompt and reads a password, without
-// echo, from the terminal.
-func (t *Terminal) ReadPassword(prompt string) (line string, err error) {
-	t.lock.Lock()
-	defer t.lock.Unlock()
-
-	oldPrompt := t.prompt
-	t.prompt = []rune(prompt)
-	t.echo = false
-
-	line, err = t.readLine()
-
-	t.prompt = oldPrompt
-	t.echo = true
-
-	return
-}
-
-// ReadLine returns a line of input from the terminal.
-func (t *Terminal) ReadLine() (line string, err error) {
-	t.lock.Lock()
-	defer t.lock.Unlock()
-
-	return t.readLine()
-}
-
-func (t *Terminal) readLine() (line string, err error) {
-	// t.lock must be held at this point
-
-	if t.cursorX == 0 && t.cursorY == 0 {
-		t.writeLine(t.prompt)
-		t.c.Write(t.outBuf)
-		t.outBuf = t.outBuf[:0]
-	}
-
-	lineIsPasted := t.pasteActive
-
-	for {
-		rest := t.remainder
-		lineOk := false
-		for !lineOk {
-			var key rune
-			key, rest = bytesToKey(rest, t.pasteActive)
-			if key == utf8.RuneError {
-				break
-			}
-			if !t.pasteActive {
-				if key == keyCtrlD {
-					if len(t.line) == 0 {
-						return "", io.EOF
-					}
-				}
-				if key == keyCtrlC {
-					return "", io.EOF
-				}
-				if key == keyPasteStart {
-					t.pasteActive = true
-					if len(t.line) == 0 {
-						lineIsPasted = true
-					}
-					continue
-				}
-			} else if key == keyPasteEnd {
-				t.pasteActive = false
-				continue
-			}
-			if !t.pasteActive {
-				lineIsPasted = false
-			}
-			line, lineOk = t.handleKey(key)
-		}
-		if len(rest) > 0 {
-			n := copy(t.inBuf[:], rest)
-			t.remainder = t.inBuf[:n]
-		} else {
-			t.remainder = nil
-		}
-		t.c.Write(t.outBuf)
-		t.outBuf = t.outBuf[:0]
-		if lineOk {
-			if t.echo {
-				t.historyIndex = -1
-				t.history.Add(line)
-			}
-			if lineIsPasted {
-				err = ErrPasteIndicator
-			}
-			return
-		}
-
-		// t.remainder is a slice at the beginning of t.inBuf
-		// containing a partial key sequence
-		readBuf := t.inBuf[len(t.remainder):]
-		var n int
-
-		t.lock.Unlock()
-		n, err = t.c.Read(readBuf)
-		t.lock.Lock()
-
-		if err != nil {
-			return
-		}
-
-		t.remainder = t.inBuf[:n+len(t.remainder)]
-	}
-}
-
-// SetPrompt sets the prompt to be used when reading subsequent lines.
-func (t *Terminal) SetPrompt(prompt string) {
-	t.lock.Lock()
-	defer t.lock.Unlock()
-
-	t.prompt = []rune(prompt)
-}
-
-func (t *Terminal) clearAndRepaintLinePlusNPrevious(numPrevLines int) {
-	// Move cursor to column zero at the start of the line.
-	t.move(t.cursorY, 0, t.cursorX, 0)
-	t.cursorX, t.cursorY = 0, 0
-	t.clearLineToRight()
-	for t.cursorY < numPrevLines {
-		// Move down a line
-		t.move(0, 1, 0, 0)
-		t.cursorY++
-		t.clearLineToRight()
-	}
-	// Move back to beginning.
-	t.move(t.cursorY, 0, 0, 0)
-	t.cursorX, t.cursorY = 0, 0
-
-	t.queue(t.prompt)
-	t.advanceCursor(visualLength(t.prompt))
-	t.writeLine(t.line)
-	t.moveCursorToPos(t.pos)
-}
-
-func (t *Terminal) SetSize(width, height int) error {
-	t.lock.Lock()
-	defer t.lock.Unlock()
-
-	if width == 0 {
-		width = 1
-	}
-
-	oldWidth := t.termWidth
-	t.termWidth, t.termHeight = width, height
-
-	switch {
-	case width == oldWidth:
-		// If the width didn't change then nothing else needs to be
-		// done.
-		return nil
-	case len(t.line) == 0 && t.cursorX == 0 && t.cursorY == 0:
-		// If there is nothing on current line and no prompt printed,
-		// just do nothing
-		return nil
-	case width < oldWidth:
-		// Some terminals (e.g. xterm) will truncate lines that were
-		// too long when shinking. Others, (e.g. gnome-terminal) will
-		// attempt to wrap them. For the former, repainting t.maxLine
-		// works great, but that behaviour goes badly wrong in the case
-		// of the latter because they have doubled every full line.
-
-		// We assume that we are working on a terminal that wraps lines
-		// and adjust the cursor position based on every previous line
-		// wrapping and turning into two. This causes the prompt on
-		// xterms to move upwards, which isn't great, but it avoids a
-		// huge mess with gnome-terminal.
-		if t.cursorX >= t.termWidth {
-			t.cursorX = t.termWidth - 1
-		}
-		t.cursorY *= 2
-		t.clearAndRepaintLinePlusNPrevious(t.maxLine * 2)
-	case width > oldWidth:
-		// If the terminal expands then our position calculations will
-		// be wrong in the future because we think the cursor is
-		// |t.pos| chars into the string, but there will be a gap at
-		// the end of any wrapped line.
-		//
-		// But the position will actually be correct until we move, so
-		// we can move back to the beginning and repaint everything.
-		t.clearAndRepaintLinePlusNPrevious(t.maxLine)
-	}
-
-	_, err := t.c.Write(t.outBuf)
-	t.outBuf = t.outBuf[:0]
-	return err
-}
-
-type pasteIndicatorError struct{}
-
-func (pasteIndicatorError) Error() string {
-	return "terminal: ErrPasteIndicator not correctly handled"
+	return term.NewTerminal(c, prompt)
 }
 
 // ErrPasteIndicator may be returned from ReadLine as the error, in addition
 // to valid line data. It indicates that bracketed paste mode is enabled and
 // that the returned line consists only of pasted data. Programs may wish to
 // interpret pasted data more literally than typed data.
-var ErrPasteIndicator = pasteIndicatorError{}
+var ErrPasteIndicator = term.ErrPasteIndicator
 
-// SetBracketedPasteMode requests that the terminal bracket paste operations
-// with markers. Not all terminals support this but, if it is supported, then
-// enabling this mode will stop any autocomplete callback from running due to
-// pastes. Additionally, any lines that are completely pasted will be returned
-// from ReadLine with the error set to ErrPasteIndicator.
-func (t *Terminal) SetBracketedPasteMode(on bool) {
-	if on {
-		io.WriteString(t.c, "\x1b[?2004h")
-	} else {
-		io.WriteString(t.c, "\x1b[?2004l")
-	}
-}
+// State contains the state of a terminal.
+type State = term.State
 
-// stRingBuffer is a ring buffer of strings.
-type stRingBuffer struct {
-	// entries contains max elements.
-	entries []string
-	max     int
-	// head contains the index of the element most recently added to the ring.
-	head int
-	// size contains the number of elements in the ring.
-	size int
+// IsTerminal returns whether the given file descriptor is a terminal.
+func IsTerminal(fd int) bool {
+	return term.IsTerminal(fd)
 }
 
-func (s *stRingBuffer) Add(a string) {
-	if s.entries == nil {
-		const defaultNumEntries = 100
-		s.entries = make([]string, defaultNumEntries)
-		s.max = defaultNumEntries
-	}
+// ReadPassword reads a line of input from a terminal without local echo.  This
+// is commonly used for inputting passwords and other sensitive data. The slice
+// returned does not include the \n.
+func ReadPassword(fd int) ([]byte, error) {
+	return term.ReadPassword(fd)
+}
 
-	s.head = (s.head + 1) % s.max
-	s.entries[s.head] = a
-	if s.size < s.max {
-		s.size++
-	}
+// MakeRaw puts the terminal connected to the given file descriptor into raw
+// mode and returns the previous state of the terminal so that it can be
+// restored.
+func MakeRaw(fd int) (*State, error) {
+	return term.MakeRaw(fd)
 }
 
-// NthPreviousEntry returns the value passed to the nth previous call to Add.
-// If n is zero then the immediately prior value is returned, if one, then the
-// next most recent, and so on. If such an element doesn't exist then ok is
-// false.
-func (s *stRingBuffer) NthPreviousEntry(n int) (value string, ok bool) {
-	if n >= s.size {
-		return "", false
-	}
-	index := s.head - n
-	if index < 0 {
-		index += s.max
-	}
-	return s.entries[index], true
+// Restore restores the terminal connected to the given file descriptor to a
+// previous state.
+func Restore(fd int, oldState *State) error {
+	return term.Restore(fd, oldState)
 }
 
-// readPasswordLine reads from reader until it finds \n or io.EOF.
-// The slice returned does not include the \n.
-// readPasswordLine also ignores any \r it finds.
-// Windows uses \r as end of line. So, on Windows, readPasswordLine
-// reads until it finds \r and ignores any \n it finds during processing.
-func readPasswordLine(reader io.Reader) ([]byte, error) {
-	var buf [1]byte
-	var ret []byte
+// GetState returns the current state of a terminal which may be useful to
+// restore the terminal after a signal.
+func GetState(fd int) (*State, error) {
+	return term.GetState(fd)
+}
 
-	for {
-		n, err := reader.Read(buf[:])
-		if n > 0 {
-			switch buf[0] {
-			case '\b':
-				if len(ret) > 0 {
-					ret = ret[:len(ret)-1]
-				}
-			case '\n':
-				if runtime.GOOS != "windows" {
-					return ret, nil
-				}
-				// otherwise ignore \n
-			case '\r':
-				if runtime.GOOS == "windows" {
-					return ret, nil
-				}
-				// otherwise ignore \r
-			default:
-				ret = append(ret, buf[0])
-			}
-			continue
-		}
-		if err != nil {
-			if err == io.EOF && len(ret) > 0 {
-				return ret, nil
-			}
-			return ret, err
-		}
-	}
+// GetSize returns the dimensions of the given terminal.
+func GetSize(fd int) (width, height int, err error) {
+	return term.GetSize(fd)
 }
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/asm.s b/src/cmd/vendor/golang.org/x/sys/plan9/asm.s
new file mode 100644
index 0000000000..06449ebfa9
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/asm.s
@@ -0,0 +1,8 @@
+// Copyright 2014 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.
+
+#include "textflag.h"
+
+TEXT ·use(SB),NOSPLIT,$0
+	RET
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/asm_plan9_386.s b/src/cmd/vendor/golang.org/x/sys/plan9/asm_plan9_386.s
new file mode 100644
index 0000000000..bc5cab1f34
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/asm_plan9_386.s
@@ -0,0 +1,30 @@
+// Copyright 2009 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.
+
+#include "textflag.h"
+
+//
+// System call support for 386, Plan 9
+//
+
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
+
+TEXT	·Syscall(SB),NOSPLIT,$0-32
+	JMP	syscall·Syscall(SB)
+
+TEXT	·Syscall6(SB),NOSPLIT,$0-44
+	JMP	syscall·Syscall6(SB)
+
+TEXT ·RawSyscall(SB),NOSPLIT,$0-28
+	JMP	syscall·RawSyscall(SB)
+
+TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
+	JMP	syscall·RawSyscall6(SB)
+
+TEXT ·seek(SB),NOSPLIT,$0-36
+	JMP	syscall·seek(SB)
+
+TEXT ·exit(SB),NOSPLIT,$4-4
+	JMP	syscall·exit(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/asm_plan9_amd64.s b/src/cmd/vendor/golang.org/x/sys/plan9/asm_plan9_amd64.s
new file mode 100644
index 0000000000..d3448e6750
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/asm_plan9_amd64.s
@@ -0,0 +1,30 @@
+// Copyright 2009 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.
+
+#include "textflag.h"
+
+//
+// System call support for amd64, Plan 9
+//
+
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
+
+TEXT	·Syscall(SB),NOSPLIT,$0-64
+	JMP	syscall·Syscall(SB)
+
+TEXT	·Syscall6(SB),NOSPLIT,$0-88
+	JMP	syscall·Syscall6(SB)
+
+TEXT ·RawSyscall(SB),NOSPLIT,$0-56
+	JMP	syscall·RawSyscall(SB)
+
+TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
+	JMP	syscall·RawSyscall6(SB)
+
+TEXT ·seek(SB),NOSPLIT,$0-56
+	JMP	syscall·seek(SB)
+
+TEXT ·exit(SB),NOSPLIT,$8-8
+	JMP	syscall·exit(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/asm_plan9_arm.s b/src/cmd/vendor/golang.org/x/sys/plan9/asm_plan9_arm.s
new file mode 100644
index 0000000000..afb7c0a9b9
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/asm_plan9_arm.s
@@ -0,0 +1,25 @@
+// Copyright 2009 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.
+
+#include "textflag.h"
+
+// System call support for plan9 on arm
+
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
+
+TEXT ·Syscall(SB),NOSPLIT,$0-32
+	JMP	syscall·Syscall(SB)
+
+TEXT ·Syscall6(SB),NOSPLIT,$0-44
+	JMP	syscall·Syscall6(SB)
+
+TEXT ·RawSyscall(SB),NOSPLIT,$0-28
+	JMP	syscall·RawSyscall(SB)
+
+TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
+	JMP	syscall·RawSyscall6(SB)
+
+TEXT ·seek(SB),NOSPLIT,$0-36
+	JMP	syscall·exit(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/const_plan9.go b/src/cmd/vendor/golang.org/x/sys/plan9/const_plan9.go
new file mode 100644
index 0000000000..b4e85a3a9d
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/const_plan9.go
@@ -0,0 +1,70 @@
+package plan9
+
+// Plan 9 Constants
+
+// Open modes
+const (
+	O_RDONLY  = 0
+	O_WRONLY  = 1
+	O_RDWR    = 2
+	O_TRUNC   = 16
+	O_CLOEXEC = 32
+	O_EXCL    = 0x1000
+)
+
+// Rfork flags
+const (
+	RFNAMEG  = 1 << 0
+	RFENVG   = 1 << 1
+	RFFDG    = 1 << 2
+	RFNOTEG  = 1 << 3
+	RFPROC   = 1 << 4
+	RFMEM    = 1 << 5
+	RFNOWAIT = 1 << 6
+	RFCNAMEG = 1 << 10
+	RFCENVG  = 1 << 11
+	RFCFDG   = 1 << 12
+	RFREND   = 1 << 13
+	RFNOMNT  = 1 << 14
+)
+
+// Qid.Type bits
+const (
+	QTDIR    = 0x80
+	QTAPPEND = 0x40
+	QTEXCL   = 0x20
+	QTMOUNT  = 0x10
+	QTAUTH   = 0x08
+	QTTMP    = 0x04
+	QTFILE   = 0x00
+)
+
+// Dir.Mode bits
+const (
+	DMDIR    = 0x80000000
+	DMAPPEND = 0x40000000
+	DMEXCL   = 0x20000000
+	DMMOUNT  = 0x10000000
+	DMAUTH   = 0x08000000
+	DMTMP    = 0x04000000
+	DMREAD   = 0x4
+	DMWRITE  = 0x2
+	DMEXEC   = 0x1
+)
+
+const (
+	STATMAX    = 65535
+	ERRMAX     = 128
+	STATFIXLEN = 49
+)
+
+// Mount and bind flags
+const (
+	MREPL   = 0x0000
+	MBEFORE = 0x0001
+	MAFTER  = 0x0002
+	MORDER  = 0x0003
+	MCREATE = 0x0004
+	MCACHE  = 0x0010
+	MMASK   = 0x0017
+)
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/dir_plan9.go b/src/cmd/vendor/golang.org/x/sys/plan9/dir_plan9.go
new file mode 100644
index 0000000000..0955e0c53e
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/dir_plan9.go
@@ -0,0 +1,212 @@
+// Copyright 2012 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.
+
+// Plan 9 directory marshalling. See intro(5).
+
+package plan9
+
+import "errors"
+
+var (
+	ErrShortStat = errors.New("stat buffer too short")
+	ErrBadStat   = errors.New("malformed stat buffer")
+	ErrBadName   = errors.New("bad character in file name")
+)
+
+// A Qid represents a 9P server's unique identification for a file.
+type Qid struct {
+	Path uint64 // the file server's unique identification for the file
+	Vers uint32 // version number for given Path
+	Type uint8  // the type of the file (plan9.QTDIR for example)
+}
+
+// A Dir contains the metadata for a file.
+type Dir struct {
+	// system-modified data
+	Type uint16 // server type
+	Dev  uint32 // server subtype
+
+	// file data
+	Qid    Qid    // unique id from server
+	Mode   uint32 // permissions
+	Atime  uint32 // last read time
+	Mtime  uint32 // last write time
+	Length int64  // file length
+	Name   string // last element of path
+	Uid    string // owner name
+	Gid    string // group name
+	Muid   string // last modifier name
+}
+
+var nullDir = Dir{
+	Type: ^uint16(0),
+	Dev:  ^uint32(0),
+	Qid: Qid{
+		Path: ^uint64(0),
+		Vers: ^uint32(0),
+		Type: ^uint8(0),
+	},
+	Mode:   ^uint32(0),
+	Atime:  ^uint32(0),
+	Mtime:  ^uint32(0),
+	Length: ^int64(0),
+}
+
+// Null assigns special "don't touch" values to members of d to
+// avoid modifying them during plan9.Wstat.
+func (d *Dir) Null() { *d = nullDir }
+
+// Marshal encodes a 9P stat message corresponding to d into b
+//
+// If there isn't enough space in b for a stat message, ErrShortStat is returned.
+func (d *Dir) Marshal(b []byte) (n int, err error) {
+	n = STATFIXLEN + len(d.Name) + len(d.Uid) + len(d.Gid) + len(d.Muid)
+	if n > len(b) {
+		return n, ErrShortStat
+	}
+
+	for _, c := range d.Name {
+		if c == '/' {
+			return n, ErrBadName
+		}
+	}
+
+	b = pbit16(b, uint16(n)-2)
+	b = pbit16(b, d.Type)
+	b = pbit32(b, d.Dev)
+	b = pbit8(b, d.Qid.Type)
+	b = pbit32(b, d.Qid.Vers)
+	b = pbit64(b, d.Qid.Path)
+	b = pbit32(b, d.Mode)
+	b = pbit32(b, d.Atime)
+	b = pbit32(b, d.Mtime)
+	b = pbit64(b, uint64(d.Length))
+	b = pstring(b, d.Name)
+	b = pstring(b, d.Uid)
+	b = pstring(b, d.Gid)
+	b = pstring(b, d.Muid)
+
+	return n, nil
+}
+
+// UnmarshalDir decodes a single 9P stat message from b and returns the resulting Dir.
+//
+// If b is too small to hold a valid stat message, ErrShortStat is returned.
+//
+// If the stat message itself is invalid, ErrBadStat is returned.
+func UnmarshalDir(b []byte) (*Dir, error) {
+	if len(b) < STATFIXLEN {
+		return nil, ErrShortStat
+	}
+	size, buf := gbit16(b)
+	if len(b) != int(size)+2 {
+		return nil, ErrBadStat
+	}
+	b = buf
+
+	var d Dir
+	d.Type, b = gbit16(b)
+	d.Dev, b = gbit32(b)
+	d.Qid.Type, b = gbit8(b)
+	d.Qid.Vers, b = gbit32(b)
+	d.Qid.Path, b = gbit64(b)
+	d.Mode, b = gbit32(b)
+	d.Atime, b = gbit32(b)
+	d.Mtime, b = gbit32(b)
+
+	n, b := gbit64(b)
+	d.Length = int64(n)
+
+	var ok bool
+	if d.Name, b, ok = gstring(b); !ok {
+		return nil, ErrBadStat
+	}
+	if d.Uid, b, ok = gstring(b); !ok {
+		return nil, ErrBadStat
+	}
+	if d.Gid, b, ok = gstring(b); !ok {
+		return nil, ErrBadStat
+	}
+	if d.Muid, b, ok = gstring(b); !ok {
+		return nil, ErrBadStat
+	}
+
+	return &d, nil
+}
+
+// pbit8 copies the 8-bit number v to b and returns the remaining slice of b.
+func pbit8(b []byte, v uint8) []byte {
+	b[0] = byte(v)
+	return b[1:]
+}
+
+// pbit16 copies the 16-bit number v to b in little-endian order and returns the remaining slice of b.
+func pbit16(b []byte, v uint16) []byte {
+	b[0] = byte(v)
+	b[1] = byte(v >> 8)
+	return b[2:]
+}
+
+// pbit32 copies the 32-bit number v to b in little-endian order and returns the remaining slice of b.
+func pbit32(b []byte, v uint32) []byte {
+	b[0] = byte(v)
+	b[1] = byte(v >> 8)
+	b[2] = byte(v >> 16)
+	b[3] = byte(v >> 24)
+	return b[4:]
+}
+
+// pbit64 copies the 64-bit number v to b in little-endian order and returns the remaining slice of b.
+func pbit64(b []byte, v uint64) []byte {
+	b[0] = byte(v)
+	b[1] = byte(v >> 8)
+	b[2] = byte(v >> 16)
+	b[3] = byte(v >> 24)
+	b[4] = byte(v >> 32)
+	b[5] = byte(v >> 40)
+	b[6] = byte(v >> 48)
+	b[7] = byte(v >> 56)
+	return b[8:]
+}
+
+// pstring copies the string s to b, prepending it with a 16-bit length in little-endian order, and
+// returning the remaining slice of b..
+func pstring(b []byte, s string) []byte {
+	b = pbit16(b, uint16(len(s)))
+	n := copy(b, s)
+	return b[n:]
+}
+
+// gbit8 reads an 8-bit number from b and returns it with the remaining slice of b.
+func gbit8(b []byte) (uint8, []byte) {
+	return uint8(b[0]), b[1:]
+}
+
+// gbit16 reads a 16-bit number in little-endian order from b and returns it with the remaining slice of b.
+func gbit16(b []byte) (uint16, []byte) {
+	return uint16(b[0]) | uint16(b[1])<<8, b[2:]
+}
+
+// gbit32 reads a 32-bit number in little-endian order from b and returns it with the remaining slice of b.
+func gbit32(b []byte) (uint32, []byte) {
+	return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24, b[4:]
+}
+
+// gbit64 reads a 64-bit number in little-endian order from b and returns it with the remaining slice of b.
+func gbit64(b []byte) (uint64, []byte) {
+	lo := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
+	hi := uint32(b[4]) | uint32(b[5])<<8 | uint32(b[6])<<16 | uint32(b[7])<<24
+	return uint64(lo) | uint64(hi)<<32, b[8:]
+}
+
+// gstring reads a string from b, prefixed with a 16-bit length in little-endian order.
+// It returns the string with the remaining slice of b and a boolean. If the length is
+// greater than the number of bytes in b, the boolean will be false.
+func gstring(b []byte) (string, []byte, bool) {
+	n, b := gbit16(b)
+	if int(n) > len(b) {
+		return "", b, false
+	}
+	return string(b[:n]), b[n:], true
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/env_plan9.go b/src/cmd/vendor/golang.org/x/sys/plan9/env_plan9.go
new file mode 100644
index 0000000000..8f1918004f
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/env_plan9.go
@@ -0,0 +1,31 @@
+// Copyright 2011 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.
+
+// Plan 9 environment variables.
+
+package plan9
+
+import (
+	"syscall"
+)
+
+func Getenv(key string) (value string, found bool) {
+	return syscall.Getenv(key)
+}
+
+func Setenv(key, value string) error {
+	return syscall.Setenv(key, value)
+}
+
+func Clearenv() {
+	syscall.Clearenv()
+}
+
+func Environ() []string {
+	return syscall.Environ()
+}
+
+func Unsetenv(key string) error {
+	return syscall.Unsetenv(key)
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/errors_plan9.go b/src/cmd/vendor/golang.org/x/sys/plan9/errors_plan9.go
new file mode 100644
index 0000000000..65fe74d3ef
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/errors_plan9.go
@@ -0,0 +1,50 @@
+// Copyright 2011 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 plan9
+
+import "syscall"
+
+// Constants
+const (
+	// Invented values to support what package os expects.
+	O_CREAT    = 0x02000
+	O_APPEND   = 0x00400
+	O_NOCTTY   = 0x00000
+	O_NONBLOCK = 0x00000
+	O_SYNC     = 0x00000
+	O_ASYNC    = 0x00000
+
+	S_IFMT   = 0x1f000
+	S_IFIFO  = 0x1000
+	S_IFCHR  = 0x2000
+	S_IFDIR  = 0x4000
+	S_IFBLK  = 0x6000
+	S_IFREG  = 0x8000
+	S_IFLNK  = 0xa000
+	S_IFSOCK = 0xc000
+)
+
+// Errors
+var (
+	EINVAL       = syscall.NewError("bad arg in system call")
+	ENOTDIR      = syscall.NewError("not a directory")
+	EISDIR       = syscall.NewError("file is a directory")
+	ENOENT       = syscall.NewError("file does not exist")
+	EEXIST       = syscall.NewError("file already exists")
+	EMFILE       = syscall.NewError("no free file descriptors")
+	EIO          = syscall.NewError("i/o error")
+	ENAMETOOLONG = syscall.NewError("file name too long")
+	EINTR        = syscall.NewError("interrupted")
+	EPERM        = syscall.NewError("permission denied")
+	EBUSY        = syscall.NewError("no free devices")
+	ETIMEDOUT    = syscall.NewError("connection timed out")
+	EPLAN9       = syscall.NewError("not supported by plan 9")
+
+	// The following errors do not correspond to any
+	// Plan 9 system messages. Invented to support
+	// what package os and others expect.
+	EACCES       = syscall.NewError("access permission denied")
+	EAFNOSUPPORT = syscall.NewError("address family not supported by protocol")
+)
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/mkall.sh b/src/cmd/vendor/golang.org/x/sys/plan9/mkall.sh
new file mode 100644
index 0000000000..1650fbcc74
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/mkall.sh
@@ -0,0 +1,150 @@
+#!/usr/bin/env bash
+# Copyright 2009 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.
+
+# The plan9 package provides access to the raw system call
+# interface of the underlying operating system.  Porting Go to
+# a new architecture/operating system combination requires
+# some manual effort, though there are tools that automate
+# much of the process.  The auto-generated files have names
+# beginning with z.
+#
+# This script runs or (given -n) prints suggested commands to generate z files
+# for the current system.  Running those commands is not automatic.
+# This script is documentation more than anything else.
+#
+# * asm_${GOOS}_${GOARCH}.s
+#
+# This hand-written assembly file implements system call dispatch.
+# There are three entry points:
+#
+# 	func Syscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr);
+# 	func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr);
+# 	func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr);
+#
+# The first and second are the standard ones; they differ only in
+# how many arguments can be passed to the kernel.
+# The third is for low-level use by the ForkExec wrapper;
+# unlike the first two, it does not call into the scheduler to
+# let it know that a system call is running.
+#
+# * syscall_${GOOS}.go
+#
+# This hand-written Go file implements system calls that need
+# special handling and lists "//sys" comments giving prototypes
+# for ones that can be auto-generated.  Mksyscall reads those
+# comments to generate the stubs.
+#
+# * syscall_${GOOS}_${GOARCH}.go
+#
+# Same as syscall_${GOOS}.go except that it contains code specific
+# to ${GOOS} on one particular architecture.
+#
+# * types_${GOOS}.c
+#
+# This hand-written C file includes standard C headers and then
+# creates typedef or enum names beginning with a dollar sign
+# (use of $ in variable names is a gcc extension).  The hardest
+# part about preparing this file is figuring out which headers to
+# include and which symbols need to be #defined to get the
+# actual data structures that pass through to the kernel system calls.
+# Some C libraries present alternate versions for binary compatibility
+# and translate them on the way in and out of system calls, but
+# there is almost always a #define that can get the real ones.
+# See types_darwin.c and types_linux.c for examples.
+#
+# * zerror_${GOOS}_${GOARCH}.go
+#
+# This machine-generated file defines the system's error numbers,
+# error strings, and signal numbers.  The generator is "mkerrors.sh".
+# Usually no arguments are needed, but mkerrors.sh will pass its
+# arguments on to godefs.
+#
+# * zsyscall_${GOOS}_${GOARCH}.go
+#
+# Generated by mksyscall.pl; see syscall_${GOOS}.go above.
+#
+# * zsysnum_${GOOS}_${GOARCH}.go
+#
+# Generated by mksysnum_${GOOS}.
+#
+# * ztypes_${GOOS}_${GOARCH}.go
+#
+# Generated by godefs; see types_${GOOS}.c above.
+
+GOOSARCH="${GOOS}_${GOARCH}"
+
+# defaults
+mksyscall="go run mksyscall.go"
+mkerrors="./mkerrors.sh"
+zerrors="zerrors_$GOOSARCH.go"
+mksysctl=""
+zsysctl="zsysctl_$GOOSARCH.go"
+mksysnum=
+mktypes=
+run="sh"
+
+case "$1" in
+-syscalls)
+	for i in zsyscall*go
+	do
+		sed 1q $i | sed 's;^// ;;' | sh > _$i && gofmt < _$i > $i
+		rm _$i
+	done
+	exit 0
+	;;
+-n)
+	run="cat"
+	shift
+esac
+
+case "$#" in
+0)
+	;;
+*)
+	echo 'usage: mkall.sh [-n]' 1>&2
+	exit 2
+esac
+
+case "$GOOSARCH" in
+_* | *_ | _)
+	echo 'undefined $GOOS_$GOARCH:' "$GOOSARCH" 1>&2
+	exit 1
+	;;
+plan9_386)
+	mkerrors=
+	mksyscall="go run mksyscall.go -l32 -plan9 -tags plan9,386"
+	mksysnum="./mksysnum_plan9.sh /n/sources/plan9/sys/src/libc/9syscall/sys.h"
+	mktypes="XXX"
+	;;
+plan9_amd64)
+	mkerrors=
+	mksyscall="go run mksyscall.go -l32 -plan9 -tags plan9,amd64"
+	mksysnum="./mksysnum_plan9.sh /n/sources/plan9/sys/src/libc/9syscall/sys.h"
+	mktypes="XXX"
+	;;
+plan9_arm)
+	mkerrors=
+	mksyscall="go run mksyscall.go -l32 -plan9 -tags plan9,arm"
+	mksysnum="./mksysnum_plan9.sh /n/sources/plan9/sys/src/libc/9syscall/sys.h"
+	mktypes="XXX"
+	;;
+*)
+	echo 'unrecognized $GOOS_$GOARCH: ' "$GOOSARCH" 1>&2
+	exit 1
+	;;
+esac
+
+(
+	if [ -n "$mkerrors" ]; then echo "$mkerrors |gofmt >$zerrors"; fi
+	case "$GOOS" in
+	plan9)
+		syscall_goos="syscall_$GOOS.go"
+		if [ -n "$mksyscall" ]; then echo "$mksyscall $syscall_goos |gofmt >zsyscall_$GOOSARCH.go"; fi
+		;;
+	esac
+	if [ -n "$mksysctl" ]; then echo "$mksysctl |gofmt >$zsysctl"; fi
+	if [ -n "$mksysnum" ]; then echo "$mksysnum |gofmt >zsysnum_$GOOSARCH.go"; fi
+	if [ -n "$mktypes" ]; then echo "$mktypes types_$GOOS.go |gofmt >ztypes_$GOOSARCH.go"; fi
+) | $run
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/mkerrors.sh b/src/cmd/vendor/golang.org/x/sys/plan9/mkerrors.sh
new file mode 100644
index 0000000000..85309c4a5b
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/mkerrors.sh
@@ -0,0 +1,246 @@
+#!/usr/bin/env bash
+# Copyright 2009 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.
+
+# Generate Go code listing errors and other #defined constant
+# values (ENAMETOOLONG etc.), by asking the preprocessor
+# about the definitions.
+
+unset LANG
+export LC_ALL=C
+export LC_CTYPE=C
+
+CC=${CC:-gcc}
+
+uname=$(uname)
+
+includes='
+#include <sys/types.h>
+#include <sys/file.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <netinet/ip6.h>
+#include <netinet/tcp.h>
+#include <errno.h>
+#include <sys/signal.h>
+#include <signal.h>
+#include <sys/resource.h>
+'
+
+ccflags="$@"
+
+# Write go tool cgo -godefs input.
+(
+	echo package plan9
+	echo
+	echo '/*'
+	indirect="includes_$(uname)"
+	echo "${!indirect} $includes"
+	echo '*/'
+	echo 'import "C"'
+	echo
+	echo 'const ('
+
+	# The gcc command line prints all the #defines
+	# it encounters while processing the input
+	echo "${!indirect} $includes" | $CC -x c - -E -dM $ccflags |
+	awk '
+		$1 != "#define" || $2 ~ /\(/ || $3 == "" {next}
+
+		$2 ~ /^E([ABCD]X|[BIS]P|[SD]I|S|FL)$/ {next}  # 386 registers
+		$2 ~ /^(SIGEV_|SIGSTKSZ|SIGRT(MIN|MAX))/ {next}
+		$2 ~ /^(SCM_SRCRT)$/ {next}
+		$2 ~ /^(MAP_FAILED)$/ {next}
+
+		$2 !~ /^ETH_/ &&
+		$2 !~ /^EPROC_/ &&
+		$2 !~ /^EQUIV_/ &&
+		$2 !~ /^EXPR_/ &&
+		$2 ~ /^E[A-Z0-9_]+$/ ||
+		$2 ~ /^B[0-9_]+$/ ||
+		$2 ~ /^V[A-Z0-9]+$/ ||
+		$2 ~ /^CS[A-Z0-9]/ ||
+		$2 ~ /^I(SIG|CANON|CRNL|EXTEN|MAXBEL|STRIP|UTF8)$/ ||
+		$2 ~ /^IGN/ ||
+		$2 ~ /^IX(ON|ANY|OFF)$/ ||
+		$2 ~ /^IN(LCR|PCK)$/ ||
+		$2 ~ /(^FLU?SH)|(FLU?SH$)/ ||
+		$2 ~ /^C(LOCAL|READ)$/ ||
+		$2 == "BRKINT" ||
+		$2 == "HUPCL" ||
+		$2 == "PENDIN" ||
+		$2 == "TOSTOP" ||
+		$2 ~ /^PAR/ ||
+		$2 ~ /^SIG[^_]/ ||
+		$2 ~ /^O[CNPFP][A-Z]+[^_][A-Z]+$/ ||
+		$2 ~ /^IN_/ ||
+		$2 ~ /^LOCK_(SH|EX|NB|UN)$/ ||
+		$2 ~ /^(AF|SOCK|SO|SOL|IPPROTO|IP|IPV6|ICMP6|TCP|EVFILT|NOTE|EV|SHUT|PROT|MAP|PACKET|MSG|SCM|MCL|DT|MADV|PR)_/ ||
+		$2 == "ICMPV6_FILTER" ||
+		$2 == "SOMAXCONN" ||
+		$2 == "NAME_MAX" ||
+		$2 == "IFNAMSIZ" ||
+		$2 ~ /^CTL_(MAXNAME|NET|QUERY)$/ ||
+		$2 ~ /^SYSCTL_VERS/ ||
+		$2 ~ /^(MS|MNT)_/ ||
+		$2 ~ /^TUN(SET|GET|ATTACH|DETACH)/ ||
+		$2 ~ /^(O|F|FD|NAME|S|PTRACE|PT)_/ ||
+		$2 ~ /^LINUX_REBOOT_CMD_/ ||
+		$2 ~ /^LINUX_REBOOT_MAGIC[12]$/ ||
+		$2 !~ "NLA_TYPE_MASK" &&
+		$2 ~ /^(NETLINK|NLM|NLMSG|NLA|IFA|IFAN|RT|RTCF|RTN|RTPROT|RTNH|ARPHRD|ETH_P)_/ ||
+		$2 ~ /^SIOC/ ||
+		$2 ~ /^TIOC/ ||
+		$2 !~ "RTF_BITS" &&
+		$2 ~ /^(IFF|IFT|NET_RT|RTM|RTF|RTV|RTA|RTAX)_/ ||
+		$2 ~ /^BIOC/ ||
+		$2 ~ /^RUSAGE_(SELF|CHILDREN|THREAD)/ ||
+		$2 ~ /^RLIMIT_(AS|CORE|CPU|DATA|FSIZE|NOFILE|STACK)|RLIM_INFINITY/ ||
+		$2 ~ /^PRIO_(PROCESS|PGRP|USER)/ ||
+		$2 ~ /^CLONE_[A-Z_]+/ ||
+		$2 !~ /^(BPF_TIMEVAL)$/ &&
+		$2 ~ /^(BPF|DLT)_/ ||
+		$2 !~ "WMESGLEN" &&
+		$2 ~ /^W[A-Z0-9]+$/ {printf("\t%s = C.%s\n", $2, $2)}
+		$2 ~ /^__WCOREFLAG$/ {next}
+		$2 ~ /^__W[A-Z0-9]+$/ {printf("\t%s = C.%s\n", substr($2,3), $2)}
+
+		{next}
+	' | sort
+
+	echo ')'
+) >_const.go
+
+# Pull out the error names for later.
+errors=$(
+	echo '#include <errno.h>' | $CC -x c - -E -dM $ccflags |
+	awk '$1=="#define" && $2 ~ /^E[A-Z0-9_]+$/ { print $2 }' |
+	sort
+)
+
+# Pull out the signal names for later.
+signals=$(
+	echo '#include <signal.h>' | $CC -x c - -E -dM $ccflags |
+	awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print $2 }' |
+	egrep -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT)' |
+	sort
+)
+
+# Again, writing regexps to a file.
+echo '#include <errno.h>' | $CC -x c - -E -dM $ccflags |
+	awk '$1=="#define" && $2 ~ /^E[A-Z0-9_]+$/ { print "^\t" $2 "[ \t]*=" }' |
+	sort >_error.grep
+echo '#include <signal.h>' | $CC -x c - -E -dM $ccflags |
+	awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print "^\t" $2 "[ \t]*=" }' |
+	egrep -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT)' |
+	sort >_signal.grep
+
+echo '// mkerrors.sh' "$@"
+echo '// Code generated by the command above; DO NOT EDIT.'
+echo
+go tool cgo -godefs -- "$@" _const.go >_error.out
+cat _error.out | grep -vf _error.grep | grep -vf _signal.grep
+echo
+echo '// Errors'
+echo 'const ('
+cat _error.out | grep -f _error.grep | sed 's/=\(.*\)/= Errno(\1)/'
+echo ')'
+
+echo
+echo '// Signals'
+echo 'const ('
+cat _error.out | grep -f _signal.grep | sed 's/=\(.*\)/= Signal(\1)/'
+echo ')'
+
+# Run C program to print error and syscall strings.
+(
+	echo -E "
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <ctype.h>
+#include <string.h>
+#include <signal.h>
+
+#define nelem(x) (sizeof(x)/sizeof((x)[0]))
+
+enum { A = 'A', Z = 'Z', a = 'a', z = 'z' }; // avoid need for single quotes below
+
+int errors[] = {
+"
+	for i in $errors
+	do
+		echo -E '	'$i,
+	done
+
+	echo -E "
+};
+
+int signals[] = {
+"
+	for i in $signals
+	do
+		echo -E '	'$i,
+	done
+
+	# Use -E because on some systems bash builtin interprets \n itself.
+	echo -E '
+};
+
+static int
+intcmp(const void *a, const void *b)
+{
+	return *(int*)a - *(int*)b;
+}
+
+int
+main(void)
+{
+	int i, j, e;
+	char buf[1024], *p;
+
+	printf("\n\n// Error table\n");
+	printf("var errors = [...]string {\n");
+	qsort(errors, nelem(errors), sizeof errors[0], intcmp);
+	for(i=0; i<nelem(errors); i++) {
+		e = errors[i];
+		if(i > 0 && errors[i-1] == e)
+			continue;
+		strcpy(buf, strerror(e));
+		// lowercase first letter: Bad -> bad, but STREAM -> STREAM.
+		if(A <= buf[0] && buf[0] <= Z && a <= buf[1] && buf[1] <= z)
+			buf[0] += a - A;
+		printf("\t%d: \"%s\",\n", e, buf);
+	}
+	printf("}\n\n");
+	
+	printf("\n\n// Signal table\n");
+	printf("var signals = [...]string {\n");
+	qsort(signals, nelem(signals), sizeof signals[0], intcmp);
+	for(i=0; i<nelem(signals); i++) {
+		e = signals[i];
+		if(i > 0 && signals[i-1] == e)
+			continue;
+		strcpy(buf, strsignal(e));
+		// lowercase first letter: Bad -> bad, but STREAM -> STREAM.
+		if(A <= buf[0] && buf[0] <= Z && a <= buf[1] && buf[1] <= z)
+			buf[0] += a - A;
+		// cut trailing : number.
+		p = strrchr(buf, ":"[0]);
+		if(p)
+			*p = '\0';
+		printf("\t%d: \"%s\",\n", e, buf);
+	}
+	printf("}\n\n");
+
+	return 0;
+}
+
+'
+) >_errors.c
+
+$CC $ccflags -o _errors _errors.c && $GORUN ./_errors && rm -f _errors.c _errors _const.go _error.grep _signal.grep _error.out
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/mksysnum_plan9.sh b/src/cmd/vendor/golang.org/x/sys/plan9/mksysnum_plan9.sh
new file mode 100644
index 0000000000..3c3ab05810
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/mksysnum_plan9.sh
@@ -0,0 +1,23 @@
+#!/bin/sh
+# Copyright 2009 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.
+
+COMMAND="mksysnum_plan9.sh $@"
+
+cat <<EOF
+// $COMMAND
+// MACHINE GENERATED BY THE ABOVE COMMAND; DO NOT EDIT
+
+package plan9
+
+const(
+EOF
+
+SP='[ 	]' # space or tab
+sed "s/^#define${SP}\\([A-Z0-9_][A-Z0-9_]*\\)${SP}${SP}*\\([0-9][0-9]*\\)/SYS_\\1=\\2/g" \
+	< $1 | grep -v SYS__
+
+cat <<EOF
+)
+EOF
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/pwd_go15_plan9.go b/src/cmd/vendor/golang.org/x/sys/plan9/pwd_go15_plan9.go
new file mode 100644
index 0000000000..87ae9d2a33
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/pwd_go15_plan9.go
@@ -0,0 +1,21 @@
+// Copyright 2015 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.
+
+// +build go1.5
+
+package plan9
+
+import "syscall"
+
+func fixwd() {
+	syscall.Fixwd()
+}
+
+func Getwd() (wd string, err error) {
+	return syscall.Getwd()
+}
+
+func Chdir(path string) error {
+	return syscall.Chdir(path)
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/pwd_plan9.go b/src/cmd/vendor/golang.org/x/sys/plan9/pwd_plan9.go
new file mode 100644
index 0000000000..c07c798bc5
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/pwd_plan9.go
@@ -0,0 +1,23 @@
+// Copyright 2015 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.
+
+// +build !go1.5
+
+package plan9
+
+func fixwd() {
+}
+
+func Getwd() (wd string, err error) {
+	fd, err := open(".", O_RDONLY)
+	if err != nil {
+		return "", err
+	}
+	defer Close(fd)
+	return Fd2path(fd)
+}
+
+func Chdir(path string) error {
+	return chdir(path)
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/race.go b/src/cmd/vendor/golang.org/x/sys/plan9/race.go
new file mode 100644
index 0000000000..42edd93ef9
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/race.go
@@ -0,0 +1,30 @@
+// Copyright 2012 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.
+
+// +build plan9,race
+
+package plan9
+
+import (
+	"runtime"
+	"unsafe"
+)
+
+const raceenabled = true
+
+func raceAcquire(addr unsafe.Pointer) {
+	runtime.RaceAcquire(addr)
+}
+
+func raceReleaseMerge(addr unsafe.Pointer) {
+	runtime.RaceReleaseMerge(addr)
+}
+
+func raceReadRange(addr unsafe.Pointer, len int) {
+	runtime.RaceReadRange(addr, len)
+}
+
+func raceWriteRange(addr unsafe.Pointer, len int) {
+	runtime.RaceWriteRange(addr, len)
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/race0.go b/src/cmd/vendor/golang.org/x/sys/plan9/race0.go
new file mode 100644
index 0000000000..c89cf8fc0d
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/race0.go
@@ -0,0 +1,25 @@
+// Copyright 2012 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.
+
+// +build plan9,!race
+
+package plan9
+
+import (
+	"unsafe"
+)
+
+const raceenabled = false
+
+func raceAcquire(addr unsafe.Pointer) {
+}
+
+func raceReleaseMerge(addr unsafe.Pointer) {
+}
+
+func raceReadRange(addr unsafe.Pointer, len int) {
+}
+
+func raceWriteRange(addr unsafe.Pointer, len int) {
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/str.go b/src/cmd/vendor/golang.org/x/sys/plan9/str.go
new file mode 100644
index 0000000000..4f7f9ad7c8
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/str.go
@@ -0,0 +1,22 @@
+// Copyright 2009 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.
+
+// +build plan9
+
+package plan9
+
+func itoa(val int) string { // do it here rather than with fmt to avoid dependency
+	if val < 0 {
+		return "-" + itoa(-val)
+	}
+	var buf [32]byte // big enough for int64
+	i := len(buf) - 1
+	for val >= 10 {
+		buf[i] = byte(val%10 + '0')
+		i--
+		val /= 10
+	}
+	buf[i] = byte(val + '0')
+	return string(buf[i:])
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/syscall.go b/src/cmd/vendor/golang.org/x/sys/plan9/syscall.go
new file mode 100644
index 0000000000..e7363a2f54
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/syscall.go
@@ -0,0 +1,116 @@
+// Copyright 2009 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.
+
+// +build plan9
+
+// Package plan9 contains an interface to the low-level operating system
+// primitives. OS details vary depending on the underlying system, and
+// by default, godoc will display the OS-specific documentation for the current
+// system. If you want godoc to display documentation for another
+// system, set $GOOS and $GOARCH to the desired system. For example, if
+// you want to view documentation for freebsd/arm on linux/amd64, set $GOOS
+// to freebsd and $GOARCH to arm.
+//
+// The primary use of this package is inside other packages that provide a more
+// portable interface to the system, such as "os", "time" and "net".  Use
+// those packages rather than this one if you can.
+//
+// For details of the functions and data types in this package consult
+// the manuals for the appropriate operating system.
+//
+// These calls return err == nil to indicate success; otherwise
+// err represents an operating system error describing the failure and
+// holds a value of type syscall.ErrorString.
+package plan9 // import "golang.org/x/sys/plan9"
+
+import (
+	"bytes"
+	"strings"
+	"unsafe"
+
+	"golang.org/x/sys/internal/unsafeheader"
+)
+
+// ByteSliceFromString returns a NUL-terminated slice of bytes
+// containing the text of s. If s contains a NUL byte at any
+// location, it returns (nil, EINVAL).
+func ByteSliceFromString(s string) ([]byte, error) {
+	if strings.IndexByte(s, 0) != -1 {
+		return nil, EINVAL
+	}
+	a := make([]byte, len(s)+1)
+	copy(a, s)
+	return a, nil
+}
+
+// BytePtrFromString returns a pointer to a NUL-terminated array of
+// bytes containing the text of s. If s contains a NUL byte at any
+// location, it returns (nil, EINVAL).
+func BytePtrFromString(s string) (*byte, error) {
+	a, err := ByteSliceFromString(s)
+	if err != nil {
+		return nil, err
+	}
+	return &a[0], nil
+}
+
+// ByteSliceToString returns a string form of the text represented by the slice s, with a terminating NUL and any
+// bytes after the NUL removed.
+func ByteSliceToString(s []byte) string {
+	if i := bytes.IndexByte(s, 0); i != -1 {
+		s = s[:i]
+	}
+	return string(s)
+}
+
+// BytePtrToString takes a pointer to a sequence of text and returns the corresponding string.
+// If the pointer is nil, it returns the empty string. It assumes that the text sequence is terminated
+// at a zero byte; if the zero byte is not present, the program may crash.
+func BytePtrToString(p *byte) string {
+	if p == nil {
+		return ""
+	}
+	if *p == 0 {
+		return ""
+	}
+
+	// Find NUL terminator.
+	n := 0
+	for ptr := unsafe.Pointer(p); *(*byte)(ptr) != 0; n++ {
+		ptr = unsafe.Pointer(uintptr(ptr) + 1)
+	}
+
+	var s []byte
+	h := (*unsafeheader.Slice)(unsafe.Pointer(&s))
+	h.Data = unsafe.Pointer(p)
+	h.Len = n
+	h.Cap = n
+
+	return string(s)
+}
+
+// Single-word zero for use when we need a valid pointer to 0 bytes.
+// See mksyscall.pl.
+var _zero uintptr
+
+func (ts *Timespec) Unix() (sec int64, nsec int64) {
+	return int64(ts.Sec), int64(ts.Nsec)
+}
+
+func (tv *Timeval) Unix() (sec int64, nsec int64) {
+	return int64(tv.Sec), int64(tv.Usec) * 1000
+}
+
+func (ts *Timespec) Nano() int64 {
+	return int64(ts.Sec)*1e9 + int64(ts.Nsec)
+}
+
+func (tv *Timeval) Nano() int64 {
+	return int64(tv.Sec)*1e9 + int64(tv.Usec)*1000
+}
+
+// use is a no-op, but the compiler cannot see that it is.
+// Calling use(p) ensures that p is kept live until that point.
+//go:noescape
+func use(p unsafe.Pointer)
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/syscall_plan9.go b/src/cmd/vendor/golang.org/x/sys/plan9/syscall_plan9.go
new file mode 100644
index 0000000000..84e1471481
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/syscall_plan9.go
@@ -0,0 +1,349 @@
+// Copyright 2011 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.
+
+// Plan 9 system calls.
+// This file is compiled as ordinary Go code,
+// but it is also input to mksyscall,
+// which parses the //sys lines and generates system call stubs.
+// Note that sometimes we use a lowercase //sys name and
+// wrap it in our own nicer implementation.
+
+package plan9
+
+import (
+	"bytes"
+	"syscall"
+	"unsafe"
+)
+
+// A Note is a string describing a process note.
+// It implements the os.Signal interface.
+type Note string
+
+func (n Note) Signal() {}
+
+func (n Note) String() string {
+	return string(n)
+}
+
+var (
+	Stdin  = 0
+	Stdout = 1
+	Stderr = 2
+)
+
+// For testing: clients can set this flag to force
+// creation of IPv6 sockets to return EAFNOSUPPORT.
+var SocketDisableIPv6 bool
+
+func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.ErrorString)
+func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.ErrorString)
+func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr)
+func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr)
+
+func atoi(b []byte) (n uint) {
+	n = 0
+	for i := 0; i < len(b); i++ {
+		n = n*10 + uint(b[i]-'0')
+	}
+	return
+}
+
+func cstring(s []byte) string {
+	i := bytes.IndexByte(s, 0)
+	if i == -1 {
+		i = len(s)
+	}
+	return string(s[:i])
+}
+
+func errstr() string {
+	var buf [ERRMAX]byte
+
+	RawSyscall(SYS_ERRSTR, uintptr(unsafe.Pointer(&buf[0])), uintptr(len(buf)), 0)
+
+	buf[len(buf)-1] = 0
+	return cstring(buf[:])
+}
+
+// Implemented in assembly to import from runtime.
+func exit(code int)
+
+func Exit(code int) { exit(code) }
+
+func readnum(path string) (uint, error) {
+	var b [12]byte
+
+	fd, e := Open(path, O_RDONLY)
+	if e != nil {
+		return 0, e
+	}
+	defer Close(fd)
+
+	n, e := Pread(fd, b[:], 0)
+
+	if e != nil {
+		return 0, e
+	}
+
+	m := 0
+	for ; m < n && b[m] == ' '; m++ {
+	}
+
+	return atoi(b[m : n-1]), nil
+}
+
+func Getpid() (pid int) {
+	n, _ := readnum("#c/pid")
+	return int(n)
+}
+
+func Getppid() (ppid int) {
+	n, _ := readnum("#c/ppid")
+	return int(n)
+}
+
+func Read(fd int, p []byte) (n int, err error) {
+	return Pread(fd, p, -1)
+}
+
+func Write(fd int, p []byte) (n int, err error) {
+	return Pwrite(fd, p, -1)
+}
+
+var ioSync int64
+
+//sys	fd2path(fd int, buf []byte) (err error)
+func Fd2path(fd int) (path string, err error) {
+	var buf [512]byte
+
+	e := fd2path(fd, buf[:])
+	if e != nil {
+		return "", e
+	}
+	return cstring(buf[:]), nil
+}
+
+//sys	pipe(p *[2]int32) (err error)
+func Pipe(p []int) (err error) {
+	if len(p) != 2 {
+		return syscall.ErrorString("bad arg in system call")
+	}
+	var pp [2]int32
+	err = pipe(&pp)
+	p[0] = int(pp[0])
+	p[1] = int(pp[1])
+	return
+}
+
+// Underlying system call writes to newoffset via pointer.
+// Implemented in assembly to avoid allocation.
+func seek(placeholder uintptr, fd int, offset int64, whence int) (newoffset int64, err string)
+
+func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
+	newoffset, e := seek(0, fd, offset, whence)
+
+	if newoffset == -1 {
+		err = syscall.ErrorString(e)
+	}
+	return
+}
+
+func Mkdir(path string, mode uint32) (err error) {
+	fd, err := Create(path, O_RDONLY, DMDIR|mode)
+
+	if fd != -1 {
+		Close(fd)
+	}
+
+	return
+}
+
+type Waitmsg struct {
+	Pid  int
+	Time [3]uint32
+	Msg  string
+}
+
+func (w Waitmsg) Exited() bool   { return true }
+func (w Waitmsg) Signaled() bool { return false }
+
+func (w Waitmsg) ExitStatus() int {
+	if len(w.Msg) == 0 {
+		// a normal exit returns no message
+		return 0
+	}
+	return 1
+}
+
+//sys	await(s []byte) (n int, err error)
+func Await(w *Waitmsg) (err error) {
+	var buf [512]byte
+	var f [5][]byte
+
+	n, err := await(buf[:])
+
+	if err != nil || w == nil {
+		return
+	}
+
+	nf := 0
+	p := 0
+	for i := 0; i < n && nf < len(f)-1; i++ {
+		if buf[i] == ' ' {
+			f[nf] = buf[p:i]
+			p = i + 1
+			nf++
+		}
+	}
+	f[nf] = buf[p:]
+	nf++
+
+	if nf != len(f) {
+		return syscall.ErrorString("invalid wait message")
+	}
+	w.Pid = int(atoi(f[0]))
+	w.Time[0] = uint32(atoi(f[1]))
+	w.Time[1] = uint32(atoi(f[2]))
+	w.Time[2] = uint32(atoi(f[3]))
+	w.Msg = cstring(f[4])
+	if w.Msg == "''" {
+		// await() returns '' for no error
+		w.Msg = ""
+	}
+	return
+}
+
+func Unmount(name, old string) (err error) {
+	fixwd()
+	oldp, err := BytePtrFromString(old)
+	if err != nil {
+		return err
+	}
+	oldptr := uintptr(unsafe.Pointer(oldp))
+
+	var r0 uintptr
+	var e syscall.ErrorString
+
+	// bind(2) man page: If name is zero, everything bound or mounted upon old is unbound or unmounted.
+	if name == "" {
+		r0, _, e = Syscall(SYS_UNMOUNT, _zero, oldptr, 0)
+	} else {
+		namep, err := BytePtrFromString(name)
+		if err != nil {
+			return err
+		}
+		r0, _, e = Syscall(SYS_UNMOUNT, uintptr(unsafe.Pointer(namep)), oldptr, 0)
+	}
+
+	if int32(r0) == -1 {
+		err = e
+	}
+	return
+}
+
+func Fchdir(fd int) (err error) {
+	path, err := Fd2path(fd)
+
+	if err != nil {
+		return
+	}
+
+	return Chdir(path)
+}
+
+type Timespec struct {
+	Sec  int32
+	Nsec int32
+}
+
+type Timeval struct {
+	Sec  int32
+	Usec int32
+}
+
+func NsecToTimeval(nsec int64) (tv Timeval) {
+	nsec += 999 // round up to microsecond
+	tv.Usec = int32(nsec % 1e9 / 1e3)
+	tv.Sec = int32(nsec / 1e9)
+	return
+}
+
+func nsec() int64 {
+	var scratch int64
+
+	r0, _, _ := Syscall(SYS_NSEC, uintptr(unsafe.Pointer(&scratch)), 0, 0)
+	// TODO(aram): remove hack after I fix _nsec in the pc64 kernel.
+	if r0 == 0 {
+		return scratch
+	}
+	return int64(r0)
+}
+
+func Gettimeofday(tv *Timeval) error {
+	nsec := nsec()
+	*tv = NsecToTimeval(nsec)
+	return nil
+}
+
+func Getpagesize() int { return 0x1000 }
+
+func Getegid() (egid int) { return -1 }
+func Geteuid() (euid int) { return -1 }
+func Getgid() (gid int)   { return -1 }
+func Getuid() (uid int)   { return -1 }
+
+func Getgroups() (gids []int, err error) {
+	return make([]int, 0), nil
+}
+
+//sys	open(path string, mode int) (fd int, err error)
+func Open(path string, mode int) (fd int, err error) {
+	fixwd()
+	return open(path, mode)
+}
+
+//sys	create(path string, mode int, perm uint32) (fd int, err error)
+func Create(path string, mode int, perm uint32) (fd int, err error) {
+	fixwd()
+	return create(path, mode, perm)
+}
+
+//sys	remove(path string) (err error)
+func Remove(path string) error {
+	fixwd()
+	return remove(path)
+}
+
+//sys	stat(path string, edir []byte) (n int, err error)
+func Stat(path string, edir []byte) (n int, err error) {
+	fixwd()
+	return stat(path, edir)
+}
+
+//sys	bind(name string, old string, flag int) (err error)
+func Bind(name string, old string, flag int) (err error) {
+	fixwd()
+	return bind(name, old, flag)
+}
+
+//sys	mount(fd int, afd int, old string, flag int, aname string) (err error)
+func Mount(fd int, afd int, old string, flag int, aname string) (err error) {
+	fixwd()
+	return mount(fd, afd, old, flag, aname)
+}
+
+//sys	wstat(path string, edir []byte) (err error)
+func Wstat(path string, edir []byte) (err error) {
+	fixwd()
+	return wstat(path, edir)
+}
+
+//sys	chdir(path string) (err error)
+//sys	Dup(oldfd int, newfd int) (fd int, err error)
+//sys	Pread(fd int, p []byte, offset int64) (n int, err error)
+//sys	Pwrite(fd int, p []byte, offset int64) (n int, err error)
+//sys	Close(fd int) (err error)
+//sys	Fstat(fd int, edir []byte) (n int, err error)
+//sys	Fwstat(fd int, edir []byte) (err error)
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_386.go b/src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_386.go
new file mode 100644
index 0000000000..6819bc2094
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_386.go
@@ -0,0 +1,284 @@
+// go run mksyscall.go -l32 -plan9 -tags plan9,386 syscall_plan9.go
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+// +build plan9,386
+
+package plan9
+
+import "unsafe"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func fd2path(fd int, buf []byte) (err error) {
+	var _p0 unsafe.Pointer
+	if len(buf) > 0 {
+		_p0 = unsafe.Pointer(&buf[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_FD2PATH, uintptr(fd), uintptr(_p0), uintptr(len(buf)))
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func pipe(p *[2]int32) (err error) {
+	r0, _, e1 := Syscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func await(s []byte) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(s) > 0 {
+		_p0 = unsafe.Pointer(&s[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_AWAIT, uintptr(_p0), uintptr(len(s)), 0)
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func open(path string, mode int) (fd int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	fd = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func create(path string, mode int, perm uint32) (fd int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_CREATE, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
+	fd = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func remove(path string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_REMOVE, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func stat(path string, edir []byte) (n int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	var _p1 unsafe.Pointer
+	if len(edir) > 0 {
+		_p1 = unsafe.Pointer(&edir[0])
+	} else {
+		_p1 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func bind(name string, old string, flag int) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(name)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(old)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_BIND, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flag))
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func mount(fd int, afd int, old string, flag int, aname string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(old)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(aname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_MOUNT, uintptr(fd), uintptr(afd), uintptr(unsafe.Pointer(_p0)), uintptr(flag), uintptr(unsafe.Pointer(_p1)), 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func wstat(path string, edir []byte) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	var _p1 unsafe.Pointer
+	if len(edir) > 0 {
+		_p1 = unsafe.Pointer(&edir[0])
+	} else {
+		_p1 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_WSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func chdir(path string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Dup(oldfd int, newfd int) (fd int, err error) {
+	r0, _, e1 := Syscall(SYS_DUP, uintptr(oldfd), uintptr(newfd), 0)
+	fd = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Pread(fd int, p []byte, offset int64) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(p) > 0 {
+		_p0 = unsafe.Pointer(&p[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(p) > 0 {
+		_p0 = unsafe.Pointer(&p[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Close(fd int) (err error) {
+	r0, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fstat(fd int, edir []byte) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(edir) > 0 {
+		_p0 = unsafe.Pointer(&edir[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fwstat(fd int, edir []byte) (err error) {
+	var _p0 unsafe.Pointer
+	if len(edir) > 0 {
+		_p0 = unsafe.Pointer(&edir[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_FWSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_amd64.go b/src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_amd64.go
new file mode 100644
index 0000000000..418abbbfc7
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_amd64.go
@@ -0,0 +1,284 @@
+// go run mksyscall.go -l32 -plan9 -tags plan9,amd64 syscall_plan9.go
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+// +build plan9,amd64
+
+package plan9
+
+import "unsafe"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func fd2path(fd int, buf []byte) (err error) {
+	var _p0 unsafe.Pointer
+	if len(buf) > 0 {
+		_p0 = unsafe.Pointer(&buf[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_FD2PATH, uintptr(fd), uintptr(_p0), uintptr(len(buf)))
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func pipe(p *[2]int32) (err error) {
+	r0, _, e1 := Syscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func await(s []byte) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(s) > 0 {
+		_p0 = unsafe.Pointer(&s[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_AWAIT, uintptr(_p0), uintptr(len(s)), 0)
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func open(path string, mode int) (fd int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	fd = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func create(path string, mode int, perm uint32) (fd int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_CREATE, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
+	fd = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func remove(path string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_REMOVE, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func stat(path string, edir []byte) (n int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	var _p1 unsafe.Pointer
+	if len(edir) > 0 {
+		_p1 = unsafe.Pointer(&edir[0])
+	} else {
+		_p1 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func bind(name string, old string, flag int) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(name)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(old)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_BIND, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flag))
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func mount(fd int, afd int, old string, flag int, aname string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(old)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(aname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_MOUNT, uintptr(fd), uintptr(afd), uintptr(unsafe.Pointer(_p0)), uintptr(flag), uintptr(unsafe.Pointer(_p1)), 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func wstat(path string, edir []byte) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	var _p1 unsafe.Pointer
+	if len(edir) > 0 {
+		_p1 = unsafe.Pointer(&edir[0])
+	} else {
+		_p1 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_WSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func chdir(path string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Dup(oldfd int, newfd int) (fd int, err error) {
+	r0, _, e1 := Syscall(SYS_DUP, uintptr(oldfd), uintptr(newfd), 0)
+	fd = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Pread(fd int, p []byte, offset int64) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(p) > 0 {
+		_p0 = unsafe.Pointer(&p[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(p) > 0 {
+		_p0 = unsafe.Pointer(&p[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Close(fd int) (err error) {
+	r0, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fstat(fd int, edir []byte) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(edir) > 0 {
+		_p0 = unsafe.Pointer(&edir[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fwstat(fd int, edir []byte) (err error) {
+	var _p0 unsafe.Pointer
+	if len(edir) > 0 {
+		_p0 = unsafe.Pointer(&edir[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_FWSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_arm.go b/src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_arm.go
new file mode 100644
index 0000000000..3e8a1a58ca
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_arm.go
@@ -0,0 +1,284 @@
+// go run mksyscall.go -l32 -plan9 -tags plan9,arm syscall_plan9.go
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+// +build plan9,arm
+
+package plan9
+
+import "unsafe"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func fd2path(fd int, buf []byte) (err error) {
+	var _p0 unsafe.Pointer
+	if len(buf) > 0 {
+		_p0 = unsafe.Pointer(&buf[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_FD2PATH, uintptr(fd), uintptr(_p0), uintptr(len(buf)))
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func pipe(p *[2]int32) (err error) {
+	r0, _, e1 := Syscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func await(s []byte) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(s) > 0 {
+		_p0 = unsafe.Pointer(&s[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_AWAIT, uintptr(_p0), uintptr(len(s)), 0)
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func open(path string, mode int) (fd int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	fd = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func create(path string, mode int, perm uint32) (fd int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_CREATE, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
+	fd = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func remove(path string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_REMOVE, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func stat(path string, edir []byte) (n int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	var _p1 unsafe.Pointer
+	if len(edir) > 0 {
+		_p1 = unsafe.Pointer(&edir[0])
+	} else {
+		_p1 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func bind(name string, old string, flag int) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(name)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(old)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_BIND, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flag))
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func mount(fd int, afd int, old string, flag int, aname string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(old)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(aname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_MOUNT, uintptr(fd), uintptr(afd), uintptr(unsafe.Pointer(_p0)), uintptr(flag), uintptr(unsafe.Pointer(_p1)), 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func wstat(path string, edir []byte) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	var _p1 unsafe.Pointer
+	if len(edir) > 0 {
+		_p1 = unsafe.Pointer(&edir[0])
+	} else {
+		_p1 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_WSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func chdir(path string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Dup(oldfd int, newfd int) (fd int, err error) {
+	r0, _, e1 := Syscall(SYS_DUP, uintptr(oldfd), uintptr(newfd), 0)
+	fd = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Pread(fd int, p []byte, offset int64) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(p) > 0 {
+		_p0 = unsafe.Pointer(&p[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(p) > 0 {
+		_p0 = unsafe.Pointer(&p[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Close(fd int) (err error) {
+	r0, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fstat(fd int, edir []byte) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(edir) > 0 {
+		_p0 = unsafe.Pointer(&edir[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fwstat(fd int, edir []byte) (err error) {
+	var _p0 unsafe.Pointer
+	if len(edir) > 0 {
+		_p0 = unsafe.Pointer(&edir[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_FWSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/zsysnum_plan9.go b/src/cmd/vendor/golang.org/x/sys/plan9/zsysnum_plan9.go
new file mode 100644
index 0000000000..22e8abd43d
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/zsysnum_plan9.go
@@ -0,0 +1,49 @@
+// mksysnum_plan9.sh /opt/plan9/sys/src/libc/9syscall/sys.h
+// MACHINE GENERATED BY THE ABOVE COMMAND; DO NOT EDIT
+
+package plan9
+
+const (
+	SYS_SYSR1       = 0
+	SYS_BIND        = 2
+	SYS_CHDIR       = 3
+	SYS_CLOSE       = 4
+	SYS_DUP         = 5
+	SYS_ALARM       = 6
+	SYS_EXEC        = 7
+	SYS_EXITS       = 8
+	SYS_FAUTH       = 10
+	SYS_SEGBRK      = 12
+	SYS_OPEN        = 14
+	SYS_OSEEK       = 16
+	SYS_SLEEP       = 17
+	SYS_RFORK       = 19
+	SYS_PIPE        = 21
+	SYS_CREATE      = 22
+	SYS_FD2PATH     = 23
+	SYS_BRK_        = 24
+	SYS_REMOVE      = 25
+	SYS_NOTIFY      = 28
+	SYS_NOTED       = 29
+	SYS_SEGATTACH   = 30
+	SYS_SEGDETACH   = 31
+	SYS_SEGFREE     = 32
+	SYS_SEGFLUSH    = 33
+	SYS_RENDEZVOUS  = 34
+	SYS_UNMOUNT     = 35
+	SYS_SEMACQUIRE  = 37
+	SYS_SEMRELEASE  = 38
+	SYS_SEEK        = 39
+	SYS_FVERSION    = 40
+	SYS_ERRSTR      = 41
+	SYS_STAT        = 42
+	SYS_FSTAT       = 43
+	SYS_WSTAT       = 44
+	SYS_FWSTAT      = 45
+	SYS_MOUNT       = 46
+	SYS_AWAIT       = 47
+	SYS_PREAD       = 50
+	SYS_PWRITE      = 51
+	SYS_TSEMACQUIRE = 52
+	SYS_NSEC        = 53
+)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/aliases.go b/src/cmd/vendor/golang.org/x/sys/unix/aliases.go
index 951fce4d0d..abc89c104a 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/aliases.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/aliases.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
+//go:build (aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos) && go1.9
+// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos
 // +build go1.9
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_zos_s390x.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_zos_s390x.s
new file mode 100644
index 0000000000..3b54e18581
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/unix/asm_zos_s390x.s
@@ -0,0 +1,426 @@
+// Copyright 2020 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.
+
+//go:build zos && s390x && gc
+// +build zos
+// +build s390x
+// +build gc
+
+#include "textflag.h"
+
+#define PSALAA            1208(R0)
+#define GTAB64(x)           80(x)
+#define LCA64(x)            88(x)
+#define CAA(x)               8(x)
+#define EDCHPXV(x)        1016(x)       // in the CAA
+#define SAVSTACK_ASYNC(x)  336(x)       // in the LCA
+
+// SS_*, where x=SAVSTACK_ASYNC
+#define SS_LE(x)             0(x)
+#define SS_GO(x)             8(x)
+#define SS_ERRNO(x)         16(x)
+#define SS_ERRNOJR(x)       20(x)
+
+#define LE_CALL BYTE $0x0D; BYTE $0x76; // BL R7, R6
+
+TEXT ·clearErrno(SB),NOSPLIT,$0-0
+	BL	addrerrno<>(SB)
+	MOVD	$0, 0(R3)
+	RET
+
+// Returns the address of errno in R3.
+TEXT addrerrno<>(SB),NOSPLIT|NOFRAME,$0-0
+	// Get library control area (LCA).
+	MOVW	PSALAA, R8
+	MOVD	LCA64(R8), R8
+
+	// Get __errno FuncDesc.
+	MOVD	CAA(R8), R9
+	MOVD	EDCHPXV(R9), R9
+	ADD	$(0x156*16), R9
+	LMG	0(R9), R5, R6
+
+	// Switch to saved LE stack.
+	MOVD	SAVSTACK_ASYNC(R8), R9
+	MOVD	0(R9), R4
+	MOVD	$0, 0(R9)
+
+	// Call __errno function.
+	LE_CALL
+	NOPH
+
+	// Switch back to Go stack.
+	XOR	R0, R0      // Restore R0 to $0.
+	MOVD	R4, 0(R9)   // Save stack pointer.
+	RET
+
+TEXT ·syscall_syscall(SB),NOSPLIT,$0-56
+	BL	runtime·entersyscall(SB)
+	MOVD	a1+8(FP), R1
+	MOVD	a2+16(FP), R2
+	MOVD	a3+24(FP), R3
+
+	// Get library control area (LCA).
+	MOVW	PSALAA, R8
+	MOVD	LCA64(R8), R8
+
+	// Get function.
+	MOVD	CAA(R8), R9
+	MOVD	EDCHPXV(R9), R9
+	MOVD	trap+0(FP), R5
+	SLD	$4, R5
+	ADD	R5, R9
+	LMG	0(R9), R5, R6
+
+	// Restore LE stack.
+	MOVD	SAVSTACK_ASYNC(R8), R9
+	MOVD	0(R9), R4
+	MOVD	$0, 0(R9)
+
+	// Call function.
+	LE_CALL
+	NOPH
+	XOR	R0, R0      // Restore R0 to $0.
+	MOVD	R4, 0(R9)   // Save stack pointer.
+
+	MOVD	R3, r1+32(FP)
+	MOVD	R0, r2+40(FP)
+	MOVD	R0, err+48(FP)
+	MOVW	R3, R4
+	CMP	R4, $-1
+	BNE	done
+	BL	addrerrno<>(SB)
+	MOVWZ	0(R3), R3
+	MOVD	R3, err+48(FP)
+done:
+	BL	runtime·exitsyscall(SB)
+	RET
+
+TEXT ·syscall_rawsyscall(SB),NOSPLIT,$0-56
+	MOVD	a1+8(FP), R1
+	MOVD	a2+16(FP), R2
+	MOVD	a3+24(FP), R3
+
+	// Get library control area (LCA).
+	MOVW	PSALAA, R8
+	MOVD	LCA64(R8), R8
+
+	// Get function.
+	MOVD	CAA(R8), R9
+	MOVD	EDCHPXV(R9), R9
+	MOVD	trap+0(FP), R5
+	SLD	$4, R5
+	ADD	R5, R9
+	LMG	0(R9), R5, R6
+
+	// Restore LE stack.
+	MOVD	SAVSTACK_ASYNC(R8), R9
+	MOVD	0(R9), R4
+	MOVD	$0, 0(R9)
+
+	// Call function.
+	LE_CALL
+	NOPH
+	XOR	R0, R0      // Restore R0 to $0.
+	MOVD	R4, 0(R9)   // Save stack pointer.
+
+	MOVD	R3, r1+32(FP)
+	MOVD	R0, r2+40(FP)
+	MOVD	R0, err+48(FP)
+	MOVW	R3, R4
+	CMP	R4, $-1
+	BNE	done
+	BL	addrerrno<>(SB)
+	MOVWZ	0(R3), R3
+	MOVD	R3, err+48(FP)
+done:
+	RET
+
+TEXT ·syscall_syscall6(SB),NOSPLIT,$0-80
+	BL	runtime·entersyscall(SB)
+	MOVD	a1+8(FP), R1
+	MOVD	a2+16(FP), R2
+	MOVD	a3+24(FP), R3
+
+	// Get library control area (LCA).
+	MOVW	PSALAA, R8
+	MOVD	LCA64(R8), R8
+
+	// Get function.
+	MOVD	CAA(R8), R9
+	MOVD	EDCHPXV(R9), R9
+	MOVD	trap+0(FP), R5
+	SLD	$4, R5
+	ADD	R5, R9
+	LMG	0(R9), R5, R6
+
+	// Restore LE stack.
+	MOVD	SAVSTACK_ASYNC(R8), R9
+	MOVD	0(R9), R4
+	MOVD	$0, 0(R9)
+
+	// Fill in parameter list.
+	MOVD	a4+32(FP), R12
+	MOVD	R12, (2176+24)(R4)
+	MOVD	a5+40(FP), R12
+	MOVD	R12, (2176+32)(R4)
+	MOVD	a6+48(FP), R12
+	MOVD	R12, (2176+40)(R4)
+
+	// Call function.
+	LE_CALL
+	NOPH
+	XOR	R0, R0      // Restore R0 to $0.
+	MOVD	R4, 0(R9)   // Save stack pointer.
+
+	MOVD	R3, r1+56(FP)
+	MOVD	R0, r2+64(FP)
+	MOVD	R0, err+72(FP)
+	MOVW	R3, R4
+	CMP	R4, $-1
+	BNE	done
+	BL	addrerrno<>(SB)
+	MOVWZ	0(R3), R3
+	MOVD	R3, err+72(FP)
+done:
+	BL	runtime·exitsyscall(SB)
+	RET
+
+TEXT ·syscall_rawsyscall6(SB),NOSPLIT,$0-80
+	MOVD	a1+8(FP), R1
+	MOVD	a2+16(FP), R2
+	MOVD	a3+24(FP), R3
+
+	// Get library control area (LCA).
+	MOVW	PSALAA, R8
+	MOVD	LCA64(R8), R8
+
+	// Get function.
+	MOVD	CAA(R8), R9
+	MOVD	EDCHPXV(R9), R9
+	MOVD	trap+0(FP), R5
+	SLD	$4, R5
+	ADD	R5, R9
+	LMG	0(R9), R5, R6
+
+	// Restore LE stack.
+	MOVD	SAVSTACK_ASYNC(R8), R9
+	MOVD	0(R9), R4
+	MOVD	$0, 0(R9)
+
+	// Fill in parameter list.
+	MOVD	a4+32(FP), R12
+	MOVD	R12, (2176+24)(R4)
+	MOVD	a5+40(FP), R12
+	MOVD	R12, (2176+32)(R4)
+	MOVD	a6+48(FP), R12
+	MOVD	R12, (2176+40)(R4)
+
+	// Call function.
+	LE_CALL
+	NOPH
+	XOR	R0, R0      // Restore R0 to $0.
+	MOVD	R4, 0(R9)   // Save stack pointer.
+
+	MOVD	R3, r1+56(FP)
+	MOVD	R0, r2+64(FP)
+	MOVD	R0, err+72(FP)
+	MOVW	R3, R4
+	CMP	R4, $-1
+	BNE	done
+	BL	·rrno<>(SB)
+	MOVWZ	0(R3), R3
+	MOVD	R3, err+72(FP)
+done:
+	RET
+
+TEXT ·syscall_syscall9(SB),NOSPLIT,$0
+	BL	runtime·entersyscall(SB)
+	MOVD	a1+8(FP), R1
+	MOVD	a2+16(FP), R2
+	MOVD	a3+24(FP), R3
+
+	// Get library control area (LCA).
+	MOVW	PSALAA, R8
+	MOVD	LCA64(R8), R8
+
+	// Get function.
+	MOVD	CAA(R8), R9
+	MOVD	EDCHPXV(R9), R9
+	MOVD	trap+0(FP), R5
+	SLD	$4, R5
+	ADD	R5, R9
+	LMG	0(R9), R5, R6
+
+	// Restore LE stack.
+	MOVD	SAVSTACK_ASYNC(R8), R9
+	MOVD	0(R9), R4
+	MOVD	$0, 0(R9)
+
+	// Fill in parameter list.
+	MOVD	a4+32(FP), R12
+	MOVD	R12, (2176+24)(R4)
+	MOVD	a5+40(FP), R12
+	MOVD	R12, (2176+32)(R4)
+	MOVD	a6+48(FP), R12
+	MOVD	R12, (2176+40)(R4)
+	MOVD	a7+56(FP), R12
+	MOVD	R12, (2176+48)(R4)
+	MOVD	a8+64(FP), R12
+	MOVD	R12, (2176+56)(R4)
+	MOVD	a9+72(FP), R12
+	MOVD	R12, (2176+64)(R4)
+
+	// Call function.
+	LE_CALL
+	NOPH
+	XOR	R0, R0      // Restore R0 to $0.
+	MOVD	R4, 0(R9)   // Save stack pointer.
+
+	MOVD	R3, r1+80(FP)
+	MOVD	R0, r2+88(FP)
+	MOVD	R0, err+96(FP)
+	MOVW	R3, R4
+	CMP	R4, $-1
+	BNE	done
+	BL	addrerrno<>(SB)
+	MOVWZ	0(R3), R3
+	MOVD	R3, err+96(FP)
+done:
+        BL	runtime·exitsyscall(SB)
+        RET
+
+TEXT ·syscall_rawsyscall9(SB),NOSPLIT,$0
+	MOVD	a1+8(FP), R1
+	MOVD	a2+16(FP), R2
+	MOVD	a3+24(FP), R3
+
+	// Get library control area (LCA).
+	MOVW	PSALAA, R8
+	MOVD	LCA64(R8), R8
+
+	// Get function.
+	MOVD	CAA(R8), R9
+	MOVD	EDCHPXV(R9), R9
+	MOVD	trap+0(FP), R5
+	SLD	$4, R5
+	ADD	R5, R9
+	LMG	0(R9), R5, R6
+
+	// Restore LE stack.
+	MOVD	SAVSTACK_ASYNC(R8), R9
+	MOVD	0(R9), R4
+	MOVD	$0, 0(R9)
+
+	// Fill in parameter list.
+	MOVD	a4+32(FP), R12
+	MOVD	R12, (2176+24)(R4)
+	MOVD	a5+40(FP), R12
+	MOVD	R12, (2176+32)(R4)
+	MOVD	a6+48(FP), R12
+	MOVD	R12, (2176+40)(R4)
+	MOVD	a7+56(FP), R12
+	MOVD	R12, (2176+48)(R4)
+	MOVD	a8+64(FP), R12
+	MOVD	R12, (2176+56)(R4)
+	MOVD	a9+72(FP), R12
+	MOVD	R12, (2176+64)(R4)
+
+	// Call function.
+	LE_CALL
+	NOPH
+	XOR	R0, R0      // Restore R0 to $0.
+	MOVD	R4, 0(R9)   // Save stack pointer.
+
+	MOVD	R3, r1+80(FP)
+	MOVD	R0, r2+88(FP)
+	MOVD	R0, err+96(FP)
+	MOVW	R3, R4
+	CMP	R4, $-1
+	BNE	done
+	BL	addrerrno<>(SB)
+	MOVWZ	0(R3), R3
+	MOVD	R3, err+96(FP)
+done:
+	RET
+
+// func svcCall(fnptr unsafe.Pointer, argv *unsafe.Pointer, dsa *uint64)
+TEXT ·svcCall(SB),NOSPLIT,$0
+	BL	runtime·save_g(SB)   // Save g and stack pointer
+	MOVW	PSALAA, R8
+	MOVD	LCA64(R8), R8
+	MOVD	SAVSTACK_ASYNC(R8), R9
+	MOVD	R15, 0(R9)
+
+	MOVD	argv+8(FP), R1       // Move function arguments into registers
+	MOVD	dsa+16(FP), g
+	MOVD	fnptr+0(FP), R15
+
+	BYTE	$0x0D                // Branch to function
+	BYTE	$0xEF
+
+	BL	runtime·load_g(SB)   // Restore g and stack pointer
+	MOVW	PSALAA, R8
+	MOVD	LCA64(R8), R8
+	MOVD	SAVSTACK_ASYNC(R8), R9
+	MOVD	0(R9), R15
+
+	RET
+
+// func svcLoad(name *byte) unsafe.Pointer
+TEXT ·svcLoad(SB),NOSPLIT,$0
+	MOVD	R15, R2          // Save go stack pointer
+	MOVD	name+0(FP), R0   // Move SVC args into registers
+	MOVD	$0x80000000, R1
+	MOVD	$0, R15
+	BYTE	$0x0A            // SVC 08 LOAD
+	BYTE	$0x08
+	MOVW	R15, R3          // Save return code from SVC
+	MOVD	R2, R15          // Restore go stack pointer
+	CMP	R3, $0           // Check SVC return code
+	BNE	error
+
+	MOVD	$-2, R3          // Reset last bit of entry point to zero
+	AND	R0, R3
+	MOVD	R3, addr+8(FP)   // Return entry point returned by SVC
+	CMP	R0, R3           // Check if last bit of entry point was set
+	BNE	done
+
+	MOVD	R15, R2          // Save go stack pointer
+	MOVD	$0, R15          // Move SVC args into registers (entry point still in r0 from SVC 08)
+	BYTE	$0x0A            // SVC 09 DELETE
+	BYTE	$0x09
+	MOVD	R2, R15          // Restore go stack pointer
+
+error:
+	MOVD	$0, addr+8(FP)   // Return 0 on failure
+done:
+	XOR	R0, R0           // Reset r0 to 0
+	RET
+
+// func svcUnload(name *byte, fnptr unsafe.Pointer) int64
+TEXT ·svcUnload(SB),NOSPLIT,$0
+	MOVD	R15, R2          // Save go stack pointer
+	MOVD	name+0(FP), R0   // Move SVC args into registers
+	MOVD	addr+8(FP), R15
+	BYTE	$0x0A            // SVC 09
+	BYTE	$0x09
+	XOR	R0, R0           // Reset r0 to 0
+	MOVD	R15, R1          // Save SVC return code
+	MOVD	R2, R15          // Restore go stack pointer
+	MOVD	R1, rc+0(FP)     // Return SVC return code
+	RET
+
+// func gettid() uint64
+TEXT ·gettid(SB), NOSPLIT, $0
+	// Get library control area (LCA).
+	MOVW PSALAA, R8
+	MOVD LCA64(R8), R8
+
+	// Get CEECAATHDID
+	MOVD CAA(R8), R9
+	MOVD 0x3D0(R9), R9
+	MOVD R9, ret+0(FP)
+
+	RET
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/cap_freebsd.go b/src/cmd/vendor/golang.org/x/sys/unix/cap_freebsd.go
index df52048773..0b7c6adb86 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/cap_freebsd.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/cap_freebsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build freebsd
 // +build freebsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/constants.go b/src/cmd/vendor/golang.org/x/sys/unix/constants.go
index 3a6ac648dd..394a3965b6 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/constants.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/constants.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos
+// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos
 
 package unix
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/dev_aix_ppc.go b/src/cmd/vendor/golang.org/x/sys/unix/dev_aix_ppc.go
index 5e5fb45104..65a998508d 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/dev_aix_ppc.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/dev_aix_ppc.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build aix
-// +build ppc
+//go:build aix && ppc
+// +build aix,ppc
 
 // Functions to access/create device major and minor numbers matching the
 // encoding used by AIX.
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/dev_aix_ppc64.go b/src/cmd/vendor/golang.org/x/sys/unix/dev_aix_ppc64.go
index 8b401244c4..8fc08ad0aa 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/dev_aix_ppc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/dev_aix_ppc64.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build aix
-// +build ppc64
+//go:build aix && ppc64
+// +build aix,ppc64
 
 // Functions to access/create device major and minor numbers matching the
 // encoding used AIX.
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/dev_zos.go b/src/cmd/vendor/golang.org/x/sys/unix/dev_zos.go
new file mode 100644
index 0000000000..a388e59a0e
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/unix/dev_zos.go
@@ -0,0 +1,29 @@
+// Copyright 2020 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.
+
+//go:build zos && s390x
+// +build zos,s390x
+
+// Functions to access/create device major and minor numbers matching the
+// encoding used by z/OS.
+//
+// The information below is extracted and adapted from <sys/stat.h> macros.
+
+package unix
+
+// Major returns the major component of a z/OS device number.
+func Major(dev uint64) uint32 {
+	return uint32((dev >> 16) & 0x0000FFFF)
+}
+
+// Minor returns the minor component of a z/OS device number.
+func Minor(dev uint64) uint32 {
+	return uint32(dev & 0x0000FFFF)
+}
+
+// Mkdev returns a z/OS device number generated from the given major and minor
+// components.
+func Mkdev(major, minor uint32) uint64 {
+	return (uint64(major) << 16) | uint64(minor)
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/dirent.go b/src/cmd/vendor/golang.org/x/sys/unix/dirent.go
index 304016b688..e74e5eaa3b 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/dirent.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/dirent.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/endian_big.go b/src/cmd/vendor/golang.org/x/sys/unix/endian_big.go
index 86781eac22..a520265576 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/endian_big.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/endian_big.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //
+//go:build armbe || arm64be || m68k || mips || mips64 || mips64p32 || ppc || ppc64 || s390 || s390x || shbe || sparc || sparc64
 // +build armbe arm64be m68k mips mips64 mips64p32 ppc ppc64 s390 s390x shbe sparc sparc64
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/endian_little.go b/src/cmd/vendor/golang.org/x/sys/unix/endian_little.go
index 8822d8541f..4362f47e2c 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/endian_little.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/endian_little.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //
+//go:build 386 || amd64 || amd64p32 || alpha || arm || arm64 || mipsle || mips64le || mips64p32le || nios2 || ppc64le || riscv || riscv64 || sh
 // +build 386 amd64 amd64p32 alpha arm arm64 mipsle mips64le mips64p32le nios2 ppc64le riscv riscv64 sh
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/env_unix.go b/src/cmd/vendor/golang.org/x/sys/unix/env_unix.go
index 84178b0a13..29ccc4d133 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/env_unix.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/env_unix.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos
+// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos
 
 // Unix environment variables.
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/epoll_zos.go b/src/cmd/vendor/golang.org/x/sys/unix/epoll_zos.go
new file mode 100644
index 0000000000..cedaf7e024
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/unix/epoll_zos.go
@@ -0,0 +1,221 @@
+// Copyright 2020 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.
+
+//go:build zos && s390x
+// +build zos,s390x
+
+package unix
+
+import (
+	"sync"
+)
+
+// This file simulates epoll on z/OS using poll.
+
+// Analogous to epoll_event on Linux.
+// TODO(neeilan): Pad is because the Linux kernel expects a 96-bit struct. We never pass this to the kernel; remove?
+type EpollEvent struct {
+	Events uint32
+	Fd     int32
+	Pad    int32
+}
+
+const (
+	EPOLLERR      = 0x8
+	EPOLLHUP      = 0x10
+	EPOLLIN       = 0x1
+	EPOLLMSG      = 0x400
+	EPOLLOUT      = 0x4
+	EPOLLPRI      = 0x2
+	EPOLLRDBAND   = 0x80
+	EPOLLRDNORM   = 0x40
+	EPOLLWRBAND   = 0x200
+	EPOLLWRNORM   = 0x100
+	EPOLL_CTL_ADD = 0x1
+	EPOLL_CTL_DEL = 0x2
+	EPOLL_CTL_MOD = 0x3
+	// The following constants are part of the epoll API, but represent
+	// currently unsupported functionality on z/OS.
+	// EPOLL_CLOEXEC  = 0x80000
+	// EPOLLET        = 0x80000000
+	// EPOLLONESHOT   = 0x40000000
+	// EPOLLRDHUP     = 0x2000     // Typically used with edge-triggered notis
+	// EPOLLEXCLUSIVE = 0x10000000 // Exclusive wake-up mode
+	// EPOLLWAKEUP    = 0x20000000 // Relies on Linux's BLOCK_SUSPEND capability
+)
+
+// TODO(neeilan): We can eliminate these epToPoll / pToEpoll calls by using identical mask values for POLL/EPOLL
+// constants where possible The lower 16 bits of epoll events (uint32) can fit any system poll event (int16).
+
+// epToPollEvt converts epoll event field to poll equivalent.
+// In epoll, Events is a 32-bit field, while poll uses 16 bits.
+func epToPollEvt(events uint32) int16 {
+	var ep2p = map[uint32]int16{
+		EPOLLIN:  POLLIN,
+		EPOLLOUT: POLLOUT,
+		EPOLLHUP: POLLHUP,
+		EPOLLPRI: POLLPRI,
+		EPOLLERR: POLLERR,
+	}
+
+	var pollEvts int16 = 0
+	for epEvt, pEvt := range ep2p {
+		if (events & epEvt) != 0 {
+			pollEvts |= pEvt
+		}
+	}
+
+	return pollEvts
+}
+
+// pToEpollEvt converts 16 bit poll event bitfields to 32-bit epoll event fields.
+func pToEpollEvt(revents int16) uint32 {
+	var p2ep = map[int16]uint32{
+		POLLIN:  EPOLLIN,
+		POLLOUT: EPOLLOUT,
+		POLLHUP: EPOLLHUP,
+		POLLPRI: EPOLLPRI,
+		POLLERR: EPOLLERR,
+	}
+
+	var epollEvts uint32 = 0
+	for pEvt, epEvt := range p2ep {
+		if (revents & pEvt) != 0 {
+			epollEvts |= epEvt
+		}
+	}
+
+	return epollEvts
+}
+
+// Per-process epoll implementation.
+type epollImpl struct {
+	mu       sync.Mutex
+	epfd2ep  map[int]*eventPoll
+	nextEpfd int
+}
+
+// eventPoll holds a set of file descriptors being watched by the process. A process can have multiple epoll instances.
+// On Linux, this is an in-kernel data structure accessed through a fd.
+type eventPoll struct {
+	mu  sync.Mutex
+	fds map[int]*EpollEvent
+}
+
+// epoll impl for this process.
+var impl epollImpl = epollImpl{
+	epfd2ep:  make(map[int]*eventPoll),
+	nextEpfd: 0,
+}
+
+func (e *epollImpl) epollcreate(size int) (epfd int, err error) {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+	epfd = e.nextEpfd
+	e.nextEpfd++
+
+	e.epfd2ep[epfd] = &eventPoll{
+		fds: make(map[int]*EpollEvent),
+	}
+	return epfd, nil
+}
+
+func (e *epollImpl) epollcreate1(flag int) (fd int, err error) {
+	return e.epollcreate(4)
+}
+
+func (e *epollImpl) epollctl(epfd int, op int, fd int, event *EpollEvent) (err error) {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+
+	ep, ok := e.epfd2ep[epfd]
+	if !ok {
+
+		return EBADF
+	}
+
+	switch op {
+	case EPOLL_CTL_ADD:
+		// TODO(neeilan): When we make epfds and fds disjoint, detect epoll
+		// loops here (instances watching each other) and return ELOOP.
+		if _, ok := ep.fds[fd]; ok {
+			return EEXIST
+		}
+		ep.fds[fd] = event
+	case EPOLL_CTL_MOD:
+		if _, ok := ep.fds[fd]; !ok {
+			return ENOENT
+		}
+		ep.fds[fd] = event
+	case EPOLL_CTL_DEL:
+		if _, ok := ep.fds[fd]; !ok {
+			return ENOENT
+		}
+		delete(ep.fds, fd)
+
+	}
+	return nil
+}
+
+// Must be called while holding ep.mu
+func (ep *eventPoll) getFds() []int {
+	fds := make([]int, len(ep.fds))
+	for fd := range ep.fds {
+		fds = append(fds, fd)
+	}
+	return fds
+}
+
+func (e *epollImpl) epollwait(epfd int, events []EpollEvent, msec int) (n int, err error) {
+	e.mu.Lock() // in [rare] case of concurrent epollcreate + epollwait
+	ep, ok := e.epfd2ep[epfd]
+
+	if !ok {
+		e.mu.Unlock()
+		return 0, EBADF
+	}
+
+	pollfds := make([]PollFd, 4)
+	for fd, epollevt := range ep.fds {
+		pollfds = append(pollfds, PollFd{Fd: int32(fd), Events: epToPollEvt(epollevt.Events)})
+	}
+	e.mu.Unlock()
+
+	n, err = Poll(pollfds, msec)
+	if err != nil {
+		return n, err
+	}
+
+	i := 0
+	for _, pFd := range pollfds {
+		if pFd.Revents != 0 {
+			events[i] = EpollEvent{Fd: pFd.Fd, Events: pToEpollEvt(pFd.Revents)}
+			i++
+		}
+
+		if i == n {
+			break
+		}
+	}
+
+	return n, nil
+}
+
+func EpollCreate(size int) (fd int, err error) {
+	return impl.epollcreate(size)
+}
+
+func EpollCreate1(flag int) (fd int, err error) {
+	return impl.epollcreate1(flag)
+}
+
+func EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) {
+	return impl.epollctl(epfd, op, fd, event)
+}
+
+// Because EpollWait mutates events, the caller is expected to coordinate
+// concurrent access if calling with the same epfd from multiple goroutines.
+func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) {
+	return impl.epollwait(epfd, events, msec)
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/fcntl.go b/src/cmd/vendor/golang.org/x/sys/unix/fcntl.go
index 4dc5348643..e9b991258c 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/fcntl.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/fcntl.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly || freebsd || linux || netbsd || openbsd
 // +build dragonfly freebsd linux netbsd openbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/fcntl_linux_32bit.go b/src/cmd/vendor/golang.org/x/sys/unix/fcntl_linux_32bit.go
index 8db48e5e06..cb0dfbd09a 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/fcntl_linux_32bit.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/fcntl_linux_32bit.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (linux && 386) || (linux && arm) || (linux && mips) || (linux && mipsle)
 // +build linux,386 linux,arm linux,mips linux,mipsle
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/fdset.go b/src/cmd/vendor/golang.org/x/sys/unix/fdset.go
index b27be0a014..b1e07b2202 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/fdset.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/fdset.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/fstatfs_zos.go b/src/cmd/vendor/golang.org/x/sys/unix/fstatfs_zos.go
new file mode 100644
index 0000000000..e377cc9f49
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/unix/fstatfs_zos.go
@@ -0,0 +1,164 @@
+// Copyright 2020 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.
+
+//go:build zos && s390x
+// +build zos,s390x
+
+package unix
+
+import (
+	"unsafe"
+)
+
+// This file simulates fstatfs on z/OS using fstatvfs and w_getmntent.
+
+func Fstatfs(fd int, stat *Statfs_t) (err error) {
+	var stat_v Statvfs_t
+	err = Fstatvfs(fd, &stat_v)
+	if err == nil {
+		// populate stat
+		stat.Type = 0
+		stat.Bsize = stat_v.Bsize
+		stat.Blocks = stat_v.Blocks
+		stat.Bfree = stat_v.Bfree
+		stat.Bavail = stat_v.Bavail
+		stat.Files = stat_v.Files
+		stat.Ffree = stat_v.Ffree
+		stat.Fsid = stat_v.Fsid
+		stat.Namelen = stat_v.Namemax
+		stat.Frsize = stat_v.Frsize
+		stat.Flags = stat_v.Flag
+		for passn := 0; passn < 5; passn++ {
+			switch passn {
+			case 0:
+				err = tryGetmntent64(stat)
+				break
+			case 1:
+				err = tryGetmntent128(stat)
+				break
+			case 2:
+				err = tryGetmntent256(stat)
+				break
+			case 3:
+				err = tryGetmntent512(stat)
+				break
+			case 4:
+				err = tryGetmntent1024(stat)
+				break
+			default:
+				break
+			}
+			//proceed to return if: err is nil (found), err is nonnil but not ERANGE (another error occurred)
+			if err == nil || err != nil && err != ERANGE {
+				break
+			}
+		}
+	}
+	return err
+}
+
+func tryGetmntent64(stat *Statfs_t) (err error) {
+	var mnt_ent_buffer struct {
+		header       W_Mnth
+		filesys_info [64]W_Mntent
+	}
+	var buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer))
+	fs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size)
+	if err != nil {
+		return err
+	}
+	err = ERANGE //return ERANGE if no match is found in this batch
+	for i := 0; i < fs_count; i++ {
+		if stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) {
+			stat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0])
+			err = nil
+			break
+		}
+	}
+	return err
+}
+
+func tryGetmntent128(stat *Statfs_t) (err error) {
+	var mnt_ent_buffer struct {
+		header       W_Mnth
+		filesys_info [128]W_Mntent
+	}
+	var buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer))
+	fs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size)
+	if err != nil {
+		return err
+	}
+	err = ERANGE //return ERANGE if no match is found in this batch
+	for i := 0; i < fs_count; i++ {
+		if stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) {
+			stat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0])
+			err = nil
+			break
+		}
+	}
+	return err
+}
+
+func tryGetmntent256(stat *Statfs_t) (err error) {
+	var mnt_ent_buffer struct {
+		header       W_Mnth
+		filesys_info [256]W_Mntent
+	}
+	var buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer))
+	fs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size)
+	if err != nil {
+		return err
+	}
+	err = ERANGE //return ERANGE if no match is found in this batch
+	for i := 0; i < fs_count; i++ {
+		if stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) {
+			stat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0])
+			err = nil
+			break
+		}
+	}
+	return err
+}
+
+func tryGetmntent512(stat *Statfs_t) (err error) {
+	var mnt_ent_buffer struct {
+		header       W_Mnth
+		filesys_info [512]W_Mntent
+	}
+	var buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer))
+	fs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size)
+	if err != nil {
+		return err
+	}
+	err = ERANGE //return ERANGE if no match is found in this batch
+	for i := 0; i < fs_count; i++ {
+		if stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) {
+			stat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0])
+			err = nil
+			break
+		}
+	}
+	return err
+}
+
+func tryGetmntent1024(stat *Statfs_t) (err error) {
+	var mnt_ent_buffer struct {
+		header       W_Mnth
+		filesys_info [1024]W_Mntent
+	}
+	var buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer))
+	fs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size)
+	if err != nil {
+		return err
+	}
+	err = ERANGE //return ERANGE if no match is found in this batch
+	for i := 0; i < fs_count; i++ {
+		if stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) {
+			stat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0])
+			err = nil
+			break
+		}
+	}
+	return err
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/gccgo.go b/src/cmd/vendor/golang.org/x/sys/unix/gccgo.go
index 86032c11ef..0dee23222c 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/gccgo.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/gccgo.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build gccgo
-// +build !aix
+//go:build gccgo && !aix
+// +build gccgo,!aix
 
 package unix
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/gccgo_linux_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/gccgo_linux_amd64.go
index 251a977a81..e60e49a3d9 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/gccgo_linux_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/gccgo_linux_amd64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build gccgo && linux && amd64
 // +build gccgo,linux,amd64
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ioctl.go b/src/cmd/vendor/golang.org/x/sys/unix/ioctl.go
index 5641678613..6c7ad052e6 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ioctl.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ioctl.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ioctl_zos.go b/src/cmd/vendor/golang.org/x/sys/unix/ioctl_zos.go
new file mode 100644
index 0000000000..5384e7d91d
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ioctl_zos.go
@@ -0,0 +1,74 @@
+// Copyright 2020 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.
+
+//go:build zos && s390x
+// +build zos,s390x
+
+package unix
+
+import (
+	"runtime"
+	"unsafe"
+)
+
+// ioctl itself should not be exposed directly, but additional get/set
+// functions for specific types are permissible.
+
+// IoctlSetInt performs an ioctl operation which sets an integer value
+// on fd, using the specified request number.
+func IoctlSetInt(fd int, req uint, value int) error {
+	return ioctl(fd, req, uintptr(value))
+}
+
+// IoctlSetWinsize performs an ioctl on fd with a *Winsize argument.
+//
+// To change fd's window size, the req argument should be TIOCSWINSZ.
+func IoctlSetWinsize(fd int, req uint, value *Winsize) error {
+	// TODO: if we get the chance, remove the req parameter and
+	// hardcode TIOCSWINSZ.
+	err := ioctl(fd, req, uintptr(unsafe.Pointer(value)))
+	runtime.KeepAlive(value)
+	return err
+}
+
+// IoctlSetTermios performs an ioctl on fd with a *Termios.
+//
+// The req value is expected to be TCSETS, TCSETSW, or TCSETSF
+func IoctlSetTermios(fd int, req uint, value *Termios) error {
+	if (req != TCSETS) && (req != TCSETSW) && (req != TCSETSF) {
+		return ENOSYS
+	}
+	err := Tcsetattr(fd, int(req), value)
+	runtime.KeepAlive(value)
+	return err
+}
+
+// IoctlGetInt performs an ioctl operation which gets an integer value
+// from fd, using the specified request number.
+//
+// A few ioctl requests use the return value as an output parameter;
+// for those, IoctlRetInt should be used instead of this function.
+func IoctlGetInt(fd int, req uint) (int, error) {
+	var value int
+	err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
+	return value, err
+}
+
+func IoctlGetWinsize(fd int, req uint) (*Winsize, error) {
+	var value Winsize
+	err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
+	return &value, err
+}
+
+// IoctlGetTermios performs an ioctl on fd with a *Termios.
+//
+// The req value is expected to be TCGETS
+func IoctlGetTermios(fd int, req uint) (*Termios, error) {
+	var value Termios
+	if req != TCGETS {
+		return &value, ENOSYS
+	}
+	err := Tcgetattr(fd, &value)
+	return &value, err
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/mkerrors.sh b/src/cmd/vendor/golang.org/x/sys/unix/mkerrors.sh
index ca98cb485f..87f9d1e351 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/mkerrors.sh
+++ b/src/cmd/vendor/golang.org/x/sys/unix/mkerrors.sh
@@ -115,6 +115,7 @@ includes_FreeBSD='
 #include <sys/sched.h>
 #include <sys/select.h>
 #include <sys/socket.h>
+#include <sys/un.h>
 #include <sys/sockio.h>
 #include <sys/stat.h>
 #include <sys/sysctl.h>
@@ -214,6 +215,7 @@ struct ltchars {
 #include <linux/fsverity.h>
 #include <linux/genetlink.h>
 #include <linux/hdreg.h>
+#include <linux/hidraw.h>
 #include <linux/icmpv6.h>
 #include <linux/if.h>
 #include <linux/if_addr.h>
@@ -224,6 +226,7 @@ struct ltchars {
 #include <linux/if_tun.h>
 #include <linux/if_packet.h>
 #include <linux/if_xdp.h>
+#include <linux/input.h>
 #include <linux/kexec.h>
 #include <linux/keyctl.h>
 #include <linux/loop.h>
@@ -300,6 +303,17 @@ struct ltchars {
 // Including linux/l2tp.h here causes conflicts between linux/in.h
 // and netinet/in.h included via net/route.h above.
 #define IPPROTO_L2TP		115
+
+// Copied from linux/hid.h.
+// Keep in sync with the size of the referenced fields.
+#define _HIDIOCGRAWNAME_LEN	128 // sizeof_field(struct hid_device, name)
+#define _HIDIOCGRAWPHYS_LEN	64  // sizeof_field(struct hid_device, phys)
+#define _HIDIOCGRAWUNIQ_LEN	64  // sizeof_field(struct hid_device, uniq)
+
+#define _HIDIOCGRAWNAME		HIDIOCGRAWNAME(_HIDIOCGRAWNAME_LEN)
+#define _HIDIOCGRAWPHYS		HIDIOCGRAWPHYS(_HIDIOCGRAWPHYS_LEN)
+#define _HIDIOCGRAWUNIQ		HIDIOCGRAWUNIQ(_HIDIOCGRAWUNIQ_LEN)
+
 '
 
 includes_NetBSD='
@@ -447,6 +461,8 @@ ccflags="$@"
 		$2 !~ /^EPROC_/ &&
 		$2 !~ /^EQUIV_/ &&
 		$2 !~ /^EXPR_/ &&
+		$2 !~ /^EVIOC/ &&
+		$2 !~ /^EV_/ &&
 		$2 ~ /^E[A-Z0-9_]+$/ ||
 		$2 ~ /^B[0-9_]+$/ ||
 		$2 ~ /^(OLD|NEW)DEV$/ ||
@@ -481,7 +497,7 @@ ccflags="$@"
 		$2 ~ /^LOCK_(SH|EX|NB|UN)$/ ||
 		$2 ~ /^LO_(KEY|NAME)_SIZE$/ ||
 		$2 ~ /^LOOP_(CLR|CTL|GET|SET)_/ ||
-		$2 ~ /^(AF|SOCK|SO|SOL|IPPROTO|IP|IPV6|ICMP6|TCP|MCAST|EVFILT|NOTE|EV|SHUT|PROT|MAP|MFD|T?PACKET|MSG|SCM|MCL|DT|MADV|PR|LOCAL)_/ ||
+		$2 ~ /^(AF|SOCK|SO|SOL|IPPROTO|IP|IPV6|ICMP6|TCP|MCAST|EVFILT|NOTE|SHUT|PROT|MAP|MFD|T?PACKET|MSG|SCM|MCL|DT|MADV|PR|LOCAL)_/ ||
 		$2 ~ /^TP_STATUS_/ ||
 		$2 ~ /^FALLOC_/ ||
 		$2 == "ICMPV6_FILTER" ||
@@ -571,6 +587,9 @@ ccflags="$@"
 		$2 ~ /^W[A-Z0-9]+$/ ||
 		$2 ~/^PPPIOC/ ||
 		$2 ~ /^FAN_|FANOTIFY_/ ||
+		$2 == "HID_MAX_DESCRIPTOR_SIZE" ||
+		$2 ~ /^_?HIDIOC/ ||
+		$2 ~ /^BUS_(USB|HIL|BLUETOOTH|VIRTUAL)$/ ||
 		$2 ~ /^BLK[A-Z]*(GET$|SET$|BUF$|PART$|SIZE)/ {printf("\t%s = C.%s\n", $2, $2)}
 		$2 ~ /^__WCOREFLAG$/ {next}
 		$2 ~ /^__W[A-Z0-9]+$/ {printf("\t%s = C.%s\n", substr($2,3), $2)}
@@ -608,6 +627,7 @@ echo '#include <signal.h>' | $CC -x c - -E -dM $ccflags |
 echo '// mkerrors.sh' "$@"
 echo '// Code generated by the command above; see README.md. DO NOT EDIT.'
 echo
+echo "//go:build ${GOARCH} && ${GOOS}"
 echo "// +build ${GOARCH},${GOOS}"
 echo
 go tool cgo -godefs -- "$@" _const.go >_error.out
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/pagesize_unix.go b/src/cmd/vendor/golang.org/x/sys/unix/pagesize_unix.go
index bc2f3629a7..53f1b4c5b8 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/pagesize_unix.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/pagesize_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 // For Unix, get the pagesize from the runtime.
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ptrace_darwin.go b/src/cmd/vendor/golang.org/x/sys/unix/ptrace_darwin.go
index fc568b5403..463c3eff7f 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ptrace_darwin.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ptrace_darwin.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin && !ios
 // +build darwin,!ios
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ptrace_ios.go b/src/cmd/vendor/golang.org/x/sys/unix/ptrace_ios.go
index 183441c9a5..ed0509a011 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ptrace_ios.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ptrace_ios.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ios
 // +build ios
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/race.go b/src/cmd/vendor/golang.org/x/sys/unix/race.go
index 61712b51c9..6f6c5fec5a 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/race.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/race.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (darwin && race) || (linux && race) || (freebsd && race)
 // +build darwin,race linux,race freebsd,race
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/race0.go b/src/cmd/vendor/golang.org/x/sys/unix/race0.go
index ad026678c7..706e1322ae 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/race0.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/race0.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build aix darwin,!race linux,!race freebsd,!race netbsd openbsd solaris dragonfly
+//go:build aix || (darwin && !race) || (linux && !race) || (freebsd && !race) || netbsd || openbsd || solaris || dragonfly || zos
+// +build aix darwin,!race linux,!race freebsd,!race netbsd openbsd solaris dragonfly zos
 
 package unix
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/readdirent_getdents.go b/src/cmd/vendor/golang.org/x/sys/unix/readdirent_getdents.go
index 3a90aa6dfa..4d6257569e 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/readdirent_getdents.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/readdirent_getdents.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || dragonfly || freebsd || linux || netbsd || openbsd
 // +build aix dragonfly freebsd linux netbsd openbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/readdirent_getdirentries.go b/src/cmd/vendor/golang.org/x/sys/unix/readdirent_getdirentries.go
index 5fdae40b3a..2a4ba47c45 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/readdirent_getdirentries.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/readdirent_getdirentries.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin
 // +build darwin
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/sockcmsg_unix.go b/src/cmd/vendor/golang.org/x/sys/unix/sockcmsg_unix.go
index 003916ed7a..453a942c5d 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/sockcmsg_unix.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/sockcmsg_unix.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos
+// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos
 
 // Socket control messages
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/sockcmsg_unix_other.go b/src/cmd/vendor/golang.org/x/sys/unix/sockcmsg_unix_other.go
index 57a0021da5..0840fe4a57 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/sockcmsg_unix_other.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/sockcmsg_unix_other.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build aix darwin freebsd linux netbsd openbsd solaris
+//go:build aix || darwin || freebsd || linux || netbsd || openbsd || solaris || zos
+// +build aix darwin freebsd linux netbsd openbsd solaris zos
 
 package unix
 
@@ -36,6 +37,10 @@ func cmsgAlignOf(salen int) int {
 		if runtime.GOOS == "netbsd" && runtime.GOARCH == "arm64" {
 			salign = 16
 		}
+	case "zos":
+		// z/OS socket macros use [32-bit] sizeof(int) alignment,
+		// not pointer width.
+		salign = SizeofInt
 	}
 
 	return (salen + salign - 1) & ^(salign - 1)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/str.go b/src/cmd/vendor/golang.org/x/sys/unix/str.go
index 17fb698683..8ba89ed869 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/str.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/str.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall.go
index ab75ef9cc6..649fa87405 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos
+// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos
 
 // Package unix contains an interface to the low-level operating system
 // primitives. OS details vary depending on the underlying system, and
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix.go
index 423dcced7e..d2723225ec 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix
 // +build aix
 
 // Aix system calls.
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix_ppc.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix_ppc.go
index b3c8e3301c..e92a0be163 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix_ppc.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix_ppc.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build aix
-// +build ppc
+//go:build aix && ppc
+// +build aix,ppc
 
 package unix
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix_ppc64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix_ppc64.go
index 9a6e024179..16eed17098 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix_ppc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix_ppc64.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build aix
-// +build ppc64
+//go:build aix && ppc64
+// +build aix,ppc64
 
 package unix
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_bsd.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_bsd.go
index 678fb27777..95ac3946b5 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_bsd.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_bsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || netbsd || openbsd
 // +build darwin dragonfly freebsd netbsd openbsd
 
 // BSD system call wrappers shared by *BSD based systems
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.1_12.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.1_12.go
index b31ef03588..b0098607c7 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.1_12.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.1_12.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin && go1.12 && !go1.13
 // +build darwin,go1.12,!go1.13
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.1_13.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.1_13.go
index ee852f1abc..5fc3cda6fc 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.1_13.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.1_13.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin && go1.13
 // +build darwin,go1.13
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.go
index e771a3c5ef..1223d7aed1 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.go
@@ -382,7 +382,7 @@ func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err e
 // The usual level and opt are SOL_LOCAL and LOCAL_PEERCRED, respectively.
 func GetsockoptXucred(fd, level, opt int) (*Xucred, error) {
 	x := new(Xucred)
-	vallen := _Socklen(unsafe.Sizeof(Xucred{}))
+	vallen := _Socklen(SizeofXucred)
 	err := getsockopt(fd, level, opt, unsafe.Pointer(x), &vallen)
 	return x, err
 }
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_386.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_386.go
index ee065fcf2d..6474677122 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_386.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build 386 && darwin
 // +build 386,darwin
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_amd64.go
index 7a1f64a7b6..b37310ce9b 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_amd64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build amd64 && darwin
 // +build amd64,darwin
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_arm64.go
index 9f85fd4046..d51ec99630 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_arm64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build arm64 && darwin
 // +build arm64,darwin
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_libSystem.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_libSystem.go
index f34c86c899..38bec30026 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_libSystem.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_libSystem.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin && go1.12
 // +build darwin,go1.12
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_dragonfly.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_dragonfly.go
index 474141b625..5af108a503 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_dragonfly.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_dragonfly.go
@@ -105,13 +105,16 @@ func Pipe(p []int) (err error) {
 	return
 }
 
-//sysnb	pipe2(flags int) (r int, w int, err error)
+//sysnb	pipe2(p *[2]_C_int, flags int) (r int, w int, err error)
 
 func Pipe2(p []int, flags int) (err error) {
 	if len(p) != 2 {
 		return EINVAL
 	}
-	p[0], p[1], err = pipe2(flags)
+	var pp [2]_C_int
+	// pipe2 on dragonfly takes an fds array as an argument, but still
+	// returns the file descriptors.
+	p[0], p[1], err = pipe2(&pp, flags)
 	return err
 }
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_dragonfly_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_dragonfly_amd64.go
index a6b4830ac8..4e2d32120a 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_dragonfly_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_dragonfly_amd64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build amd64 && dragonfly
 // +build amd64,dragonfly
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd.go
index 15af63dd55..18c392cf36 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd.go
@@ -126,6 +126,15 @@ func SetsockoptIPMreqn(fd, level, opt int, mreq *IPMreqn) (err error) {
 	return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq))
 }
 
+// GetsockoptXucred is a getsockopt wrapper that returns an Xucred struct.
+// The usual level and opt are SOL_LOCAL and LOCAL_PEERCRED, respectively.
+func GetsockoptXucred(fd, level, opt int) (*Xucred, error) {
+	x := new(Xucred)
+	vallen := _Socklen(SizeofXucred)
+	err := getsockopt(fd, level, opt, unsafe.Pointer(x), &vallen)
+	return x, err
+}
+
 func Accept4(fd, flags int) (nfd int, sa Sockaddr, err error) {
 	var rsa RawSockaddrAny
 	var len _Socklen = SizeofSockaddrAny
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd_386.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd_386.go
index 72a506ddcb..342fc32b16 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd_386.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build 386 && freebsd
 // +build 386,freebsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd_amd64.go
index d5e376acae..a32d5aa4ae 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd_amd64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build amd64 && freebsd
 // +build amd64,freebsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd_arm.go
index 4ea45bce52..1e36d39abe 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd_arm.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build arm && freebsd
 // +build arm,freebsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd_arm64.go
index aa5326db19..a09a1537bd 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_freebsd_arm64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build arm64 && freebsd
 // +build arm64,freebsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_illumos.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_illumos.go
index 7a2d4120fc..bc442e3bac 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_illumos.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_illumos.go
@@ -4,6 +4,7 @@
 
 // illumos system calls not present on Solaris.
 
+//go:build amd64 && illumos
 // +build amd64,illumos
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go
index 1b21035700..0a48548e80 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go
@@ -137,12 +137,61 @@ func IoctlFileClone(destFd, srcFd int) error {
 	return ioctl(destFd, FICLONE, uintptr(srcFd))
 }
 
+type FileDedupeRange struct {
+	Src_offset uint64
+	Src_length uint64
+	Reserved1  uint16
+	Reserved2  uint32
+	Info       []FileDedupeRangeInfo
+}
+
+type FileDedupeRangeInfo struct {
+	Dest_fd       int64
+	Dest_offset   uint64
+	Bytes_deduped uint64
+	Status        int32
+	Reserved      uint32
+}
+
 // IoctlFileDedupeRange performs an FIDEDUPERANGE ioctl operation to share the
-// range of data conveyed in value with the file associated with the file
-// descriptor destFd. See the ioctl_fideduperange(2) man page for details.
-func IoctlFileDedupeRange(destFd int, value *FileDedupeRange) error {
-	err := ioctl(destFd, FIDEDUPERANGE, uintptr(unsafe.Pointer(value)))
-	runtime.KeepAlive(value)
+// range of data conveyed in value from the file associated with the file
+// descriptor srcFd to the value.Info destinations. See the
+// ioctl_fideduperange(2) man page for details.
+func IoctlFileDedupeRange(srcFd int, value *FileDedupeRange) error {
+	buf := make([]byte, SizeofRawFileDedupeRange+
+		len(value.Info)*SizeofRawFileDedupeRangeInfo)
+	rawrange := (*RawFileDedupeRange)(unsafe.Pointer(&buf[0]))
+	rawrange.Src_offset = value.Src_offset
+	rawrange.Src_length = value.Src_length
+	rawrange.Dest_count = uint16(len(value.Info))
+	rawrange.Reserved1 = value.Reserved1
+	rawrange.Reserved2 = value.Reserved2
+
+	for i := range value.Info {
+		rawinfo := (*RawFileDedupeRangeInfo)(unsafe.Pointer(
+			uintptr(unsafe.Pointer(&buf[0])) + uintptr(SizeofRawFileDedupeRange) +
+				uintptr(i*SizeofRawFileDedupeRangeInfo)))
+		rawinfo.Dest_fd = value.Info[i].Dest_fd
+		rawinfo.Dest_offset = value.Info[i].Dest_offset
+		rawinfo.Bytes_deduped = value.Info[i].Bytes_deduped
+		rawinfo.Status = value.Info[i].Status
+		rawinfo.Reserved = value.Info[i].Reserved
+	}
+
+	err := ioctl(srcFd, FIDEDUPERANGE, uintptr(unsafe.Pointer(&buf[0])))
+
+	// Output
+	for i := range value.Info {
+		rawinfo := (*RawFileDedupeRangeInfo)(unsafe.Pointer(
+			uintptr(unsafe.Pointer(&buf[0])) + uintptr(SizeofRawFileDedupeRange) +
+				uintptr(i*SizeofRawFileDedupeRangeInfo)))
+		value.Info[i].Dest_fd = rawinfo.Dest_fd
+		value.Info[i].Dest_offset = rawinfo.Dest_offset
+		value.Info[i].Bytes_deduped = rawinfo.Bytes_deduped
+		value.Info[i].Status = rawinfo.Status
+		value.Info[i].Reserved = rawinfo.Reserved
+	}
+
 	return err
 }
 
@@ -153,6 +202,36 @@ func IoctlWatchdogKeepalive(fd int) error {
 	return ioctl(fd, WDIOC_KEEPALIVE, 0)
 }
 
+func IoctlHIDGetDesc(fd int, value *HIDRawReportDescriptor) error {
+	err := ioctl(fd, HIDIOCGRDESC, uintptr(unsafe.Pointer(value)))
+	runtime.KeepAlive(value)
+	return err
+}
+
+func IoctlHIDGetRawInfo(fd int) (*HIDRawDevInfo, error) {
+	var value HIDRawDevInfo
+	err := ioctl(fd, HIDIOCGRAWINFO, uintptr(unsafe.Pointer(&value)))
+	return &value, err
+}
+
+func IoctlHIDGetRawName(fd int) (string, error) {
+	var value [_HIDIOCGRAWNAME_LEN]byte
+	err := ioctl(fd, _HIDIOCGRAWNAME, uintptr(unsafe.Pointer(&value[0])))
+	return ByteSliceToString(value[:]), err
+}
+
+func IoctlHIDGetRawPhys(fd int) (string, error) {
+	var value [_HIDIOCGRAWPHYS_LEN]byte
+	err := ioctl(fd, _HIDIOCGRAWPHYS, uintptr(unsafe.Pointer(&value[0])))
+	return ByteSliceToString(value[:]), err
+}
+
+func IoctlHIDGetRawUniq(fd int) (string, error) {
+	var value [_HIDIOCGRAWUNIQ_LEN]byte
+	err := ioctl(fd, _HIDIOCGRAWUNIQ, uintptr(unsafe.Pointer(&value[0])))
+	return ByteSliceToString(value[:]), err
+}
+
 //sys	Linkat(olddirfd int, oldpath string, newdirfd int, newpath string, flags int) (err error)
 
 func Link(oldpath string, newpath string) (err error) {
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_386.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_386.go
index 70e61bd5db..7b52e5d8a4 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_386.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build 386 && linux
 // +build 386,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_amd64.go
index 4be2acd32b..28b7641152 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_amd64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build amd64 && linux
 // +build amd64,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_amd64_gc.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_amd64_gc.go
index baa771f8ad..8b0f0f3aa5 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_amd64_gc.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_amd64_gc.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build amd64,linux
-// +build gc
+//go:build amd64 && linux && gc
+// +build amd64,linux,gc
 
 package unix
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_arm.go
index 322b8e0fb9..68877728ec 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_arm.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build arm && linux
 // +build arm,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go
index 9315cf415b..7ed7034761 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build arm64 && linux
 // +build arm64,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_gc.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_gc.go
index 9edf3961b0..2b1168d7d1 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_gc.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_gc.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && gc
 // +build linux,gc
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_gc_386.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_gc_386.go
index 90e33d8cf7..9843fb4896 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_gc_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_gc_386.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && gc && 386
 // +build linux,gc,386
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_gc_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_gc_arm.go
index 1a97baae73..a6008fccd5 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_gc_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_gc_arm.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build arm && gc && linux
 // +build arm,gc,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_gccgo_386.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_gccgo_386.go
index 308eb7aecf..7740af2428 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_gccgo_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_gccgo_386.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && gccgo && 386
 // +build linux,gccgo,386
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_gccgo_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_gccgo_arm.go
index aa7fc9e199..e16a12299a 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_gccgo_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_gccgo_arm.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && gccgo && arm
 // +build linux,gccgo,arm
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_mips64x.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_mips64x.go
index 5fc8a47f41..06dec06fa1 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_mips64x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_mips64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (mips64 || mips64le)
 // +build linux
 // +build mips64 mips64le
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_mipsx.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_mipsx.go
index 20b9825f87..8f0d0a5b59 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_mipsx.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_mipsx.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (mips || mipsle)
 // +build linux
 // +build mips mipsle
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_ppc64x.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_ppc64x.go
index 5162c39b0e..0b1f0d6da5 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_ppc64x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_ppc64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (ppc64 || ppc64le)
 // +build linux
 // +build ppc64 ppc64le
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go
index a6a66ece09..ce9bcd3171 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build riscv64 && linux
 // +build riscv64,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_s390x.go
index fcef0d1daf..a941d88815 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_s390x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_s390x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build s390x && linux
 // +build s390x,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go
index 3b88044830..49055a3cf5 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build sparc64 && linux
 // +build sparc64,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_netbsd_386.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_netbsd_386.go
index 24da8b5245..5199d282fd 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_netbsd_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_netbsd_386.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build 386 && netbsd
 // +build 386,netbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_netbsd_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_netbsd_amd64.go
index 25a0ac8258..70a9c52e98 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_netbsd_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_netbsd_amd64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build amd64 && netbsd
 // +build amd64,netbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_netbsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_netbsd_arm.go
index 21591ecd4d..3eb5942f93 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_netbsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_netbsd_arm.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build arm && netbsd
 // +build arm,netbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_netbsd_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_netbsd_arm64.go
index 8047496350..fc6ccfd810 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_netbsd_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_netbsd_arm64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build arm64 && netbsd
 // +build arm64,netbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd_386.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd_386.go
index 42b5a0e51e..6baabcdcb0 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd_386.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build 386 && openbsd
 // +build 386,openbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd_amd64.go
index 6ea4b48831..bab25360ea 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd_amd64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build amd64 && openbsd
 // +build amd64,openbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd_arm.go
index 1c3d26fa2c..8eed3c4d4e 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd_arm.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build arm && openbsd
 // +build arm,openbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd_arm64.go
index a8c458cb03..483dde99d4 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd_arm64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build arm64 && openbsd
 // +build arm64,openbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_solaris_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_solaris_amd64.go
index b22a34d7ae..0bd25ef81f 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_solaris_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_solaris_amd64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build amd64 && solaris
 // +build amd64,solaris
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_unix.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_unix.go
index 400ba9fbc9..a7618ceb55 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_unix.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_unix_gc.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_unix_gc.go
index 87bd161cef..5898e9a52b 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_unix_gc.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_unix_gc.go
@@ -2,8 +2,11 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris) && gc && !ppc64le && !ppc64
 // +build darwin dragonfly freebsd linux netbsd openbsd solaris
-// +build gc,!ppc64le,!ppc64
+// +build gc
+// +build !ppc64le
+// +build !ppc64
 
 package unix
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_unix_gc_ppc64x.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_unix_gc_ppc64x.go
index d36216c3ca..f6f707acf2 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_unix_gc_ppc64x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_unix_gc_ppc64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (ppc64le || ppc64) && gc
 // +build linux
 // +build ppc64le ppc64
 // +build gc
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go
new file mode 100644
index 0000000000..13f58d2b2f
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go
@@ -0,0 +1,1781 @@
+// Copyright 2020 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.
+
+//go:build zos && s390x
+// +build zos,s390x
+
+package unix
+
+import (
+	"bytes"
+	"runtime"
+	"sort"
+	"sync"
+	"syscall"
+	"unsafe"
+)
+
+const (
+	O_CLOEXEC = 0       // Dummy value (not supported).
+	AF_LOCAL  = AF_UNIX // AF_LOCAL is an alias for AF_UNIX
+)
+
+func syscall_syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
+func syscall_rawsyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
+func syscall_syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
+func syscall_rawsyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
+func syscall_syscall9(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno)
+func syscall_rawsyscall9(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno)
+
+func copyStat(stat *Stat_t, statLE *Stat_LE_t) {
+	stat.Dev = uint64(statLE.Dev)
+	stat.Ino = uint64(statLE.Ino)
+	stat.Nlink = uint64(statLE.Nlink)
+	stat.Mode = uint32(statLE.Mode)
+	stat.Uid = uint32(statLE.Uid)
+	stat.Gid = uint32(statLE.Gid)
+	stat.Rdev = uint64(statLE.Rdev)
+	stat.Size = statLE.Size
+	stat.Atim.Sec = int64(statLE.Atim)
+	stat.Atim.Nsec = 0 //zos doesn't return nanoseconds
+	stat.Mtim.Sec = int64(statLE.Mtim)
+	stat.Mtim.Nsec = 0 //zos doesn't return nanoseconds
+	stat.Ctim.Sec = int64(statLE.Ctim)
+	stat.Ctim.Nsec = 0 //zos doesn't return nanoseconds
+	stat.Blksize = int64(statLE.Blksize)
+	stat.Blocks = statLE.Blocks
+}
+
+func svcCall(fnptr unsafe.Pointer, argv *unsafe.Pointer, dsa *uint64)
+func svcLoad(name *byte) unsafe.Pointer
+func svcUnload(name *byte, fnptr unsafe.Pointer) int64
+
+func (d *Dirent) NameString() string {
+	if d == nil {
+		return ""
+	}
+	return string(d.Name[:d.Namlen])
+}
+
+func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) {
+	if sa.Port < 0 || sa.Port > 0xFFFF {
+		return nil, 0, EINVAL
+	}
+	sa.raw.Len = SizeofSockaddrInet4
+	sa.raw.Family = AF_INET
+	p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
+	p[0] = byte(sa.Port >> 8)
+	p[1] = byte(sa.Port)
+	for i := 0; i < len(sa.Addr); i++ {
+		sa.raw.Addr[i] = sa.Addr[i]
+	}
+	return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil
+}
+
+func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) {
+	if sa.Port < 0 || sa.Port > 0xFFFF {
+		return nil, 0, EINVAL
+	}
+	sa.raw.Len = SizeofSockaddrInet6
+	sa.raw.Family = AF_INET6
+	p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
+	p[0] = byte(sa.Port >> 8)
+	p[1] = byte(sa.Port)
+	sa.raw.Scope_id = sa.ZoneId
+	for i := 0; i < len(sa.Addr); i++ {
+		sa.raw.Addr[i] = sa.Addr[i]
+	}
+	return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil
+}
+
+func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) {
+	name := sa.Name
+	n := len(name)
+	if n >= len(sa.raw.Path) || n == 0 {
+		return nil, 0, EINVAL
+	}
+	sa.raw.Len = byte(3 + n) // 2 for Family, Len; 1 for NUL
+	sa.raw.Family = AF_UNIX
+	for i := 0; i < n; i++ {
+		sa.raw.Path[i] = int8(name[i])
+	}
+	return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil
+}
+
+func anyToSockaddr(_ int, rsa *RawSockaddrAny) (Sockaddr, error) {
+	// TODO(neeilan): Implement use of first param (fd)
+	switch rsa.Addr.Family {
+	case AF_UNIX:
+		pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa))
+		sa := new(SockaddrUnix)
+		// For z/OS, only replace NUL with @ when the
+		// length is not zero.
+		if pp.Len != 0 && pp.Path[0] == 0 {
+			// "Abstract" Unix domain socket.
+			// Rewrite leading NUL as @ for textual display.
+			// (This is the standard convention.)
+			// Not friendly to overwrite in place,
+			// but the callers below don't care.
+			pp.Path[0] = '@'
+		}
+
+		// Assume path ends at NUL.
+		//
+		// For z/OS, the length of the name is a field
+		// in the structure. To be on the safe side, we
+		// will still scan the name for a NUL but only
+		// to the length provided in the structure.
+		//
+		// This is not technically the Linux semantics for
+		// abstract Unix domain sockets--they are supposed
+		// to be uninterpreted fixed-size binary blobs--but
+		// everyone uses this convention.
+		n := 0
+		for n < int(pp.Len) && pp.Path[n] != 0 {
+			n++
+		}
+		bytes := (*[len(pp.Path)]byte)(unsafe.Pointer(&pp.Path[0]))[0:n]
+		sa.Name = string(bytes)
+		return sa, nil
+
+	case AF_INET:
+		pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa))
+		sa := new(SockaddrInet4)
+		p := (*[2]byte)(unsafe.Pointer(&pp.Port))
+		sa.Port = int(p[0])<<8 + int(p[1])
+		for i := 0; i < len(sa.Addr); i++ {
+			sa.Addr[i] = pp.Addr[i]
+		}
+		return sa, nil
+
+	case AF_INET6:
+		pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa))
+		sa := new(SockaddrInet6)
+		p := (*[2]byte)(unsafe.Pointer(&pp.Port))
+		sa.Port = int(p[0])<<8 + int(p[1])
+		sa.ZoneId = pp.Scope_id
+		for i := 0; i < len(sa.Addr); i++ {
+			sa.Addr[i] = pp.Addr[i]
+		}
+		return sa, nil
+	}
+	return nil, EAFNOSUPPORT
+}
+
+func Accept(fd int) (nfd int, sa Sockaddr, err error) {
+	var rsa RawSockaddrAny
+	var len _Socklen = SizeofSockaddrAny
+	nfd, err = accept(fd, &rsa, &len)
+	if err != nil {
+		return
+	}
+	// TODO(neeilan): Remove 0 in call
+	sa, err = anyToSockaddr(0, &rsa)
+	if err != nil {
+		Close(nfd)
+		nfd = 0
+	}
+	return
+}
+
+func (iov *Iovec) SetLen(length int) {
+	iov.Len = uint64(length)
+}
+
+func (msghdr *Msghdr) SetControllen(length int) {
+	msghdr.Controllen = int32(length)
+}
+
+func (cmsg *Cmsghdr) SetLen(length int) {
+	cmsg.Len = int32(length)
+}
+
+//sys   fcntl(fd int, cmd int, arg int) (val int, err error)
+//sys	read(fd int, p []byte) (n int, err error)
+//sys   readlen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_READ
+//sys	write(fd int, p []byte) (n int, err error)
+
+//sys	accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) = SYS___ACCEPT_A
+//sys	bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) = SYS___BIND_A
+//sys	connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) = SYS___CONNECT_A
+//sysnb	getgroups(n int, list *_Gid_t) (nn int, err error)
+//sysnb	setgroups(n int, list *_Gid_t) (err error)
+//sys	getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error)
+//sys	setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error)
+//sysnb	socket(domain int, typ int, proto int) (fd int, err error)
+//sysnb	socketpair(domain int, typ int, proto int, fd *[2]int32) (err error)
+//sysnb	getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) = SYS___GETPEERNAME_A
+//sysnb	getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) = SYS___GETSOCKNAME_A
+//sys	recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) = SYS___RECVFROM_A
+//sys	sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) = SYS___SENDTO_A
+//sys	recvmsg(s int, msg *Msghdr, flags int) (n int, err error) = SYS___RECVMSG_A
+//sys	sendmsg(s int, msg *Msghdr, flags int) (n int, err error) = SYS___SENDMSG_A
+//sys   mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) = SYS_MMAP
+//sys   munmap(addr uintptr, length uintptr) (err error) = SYS_MUNMAP
+//sys   ioctl(fd int, req uint, arg uintptr) (err error) = SYS_IOCTL
+
+//sys   Access(path string, mode uint32) (err error) = SYS___ACCESS_A
+//sys   Chdir(path string) (err error) = SYS___CHDIR_A
+//sys	Chown(path string, uid int, gid int) (err error) = SYS___CHOWN_A
+//sys	Chmod(path string, mode uint32) (err error) = SYS___CHMOD_A
+//sys   Creat(path string, mode uint32) (fd int, err error) = SYS___CREAT_A
+//sys	Dup(oldfd int) (fd int, err error)
+//sys	Dup2(oldfd int, newfd int) (err error)
+//sys	Exit(code int)
+//sys	Fchdir(fd int) (err error)
+//sys	Fchmod(fd int, mode uint32) (err error)
+//sys	Fchown(fd int, uid int, gid int) (err error)
+//sys	FcntlInt(fd uintptr, cmd int, arg int) (retval int, err error) = SYS_FCNTL
+//sys	fstat(fd int, stat *Stat_LE_t) (err error)
+
+func Fstat(fd int, stat *Stat_t) (err error) {
+	var statLE Stat_LE_t
+	err = fstat(fd, &statLE)
+	copyStat(stat, &statLE)
+	return
+}
+
+//sys	Fstatvfs(fd int, stat *Statvfs_t) (err error) = SYS_FSTATVFS
+//sys	Fsync(fd int) (err error)
+//sys	Ftruncate(fd int, length int64) (err error)
+//sys   Getpagesize() (pgsize int) = SYS_GETPAGESIZE
+//sys   Mprotect(b []byte, prot int) (err error) = SYS_MPROTECT
+//sys   Msync(b []byte, flags int) (err error) = SYS_MSYNC
+//sys   Poll(fds []PollFd, timeout int) (n int, err error) = SYS_POLL
+//sys   Times(tms *Tms) (ticks uintptr, err error) = SYS_TIMES
+//sys   W_Getmntent(buff *byte, size int) (lastsys int, err error) = SYS_W_GETMNTENT
+
+//sys   Mount(path string, filesystem string, fstype string, mtm uint32, parmlen int32, parm string) (err error) = SYS___MOUNT_A
+//sys   Unmount(filesystem string, mtm int) (err error) = SYS___UMOUNT_A
+//sys   Chroot(path string) (err error) = SYS___CHROOT_A
+//sysnb Uname(buf *Utsname) (err error) = SYS___UNAME_A
+
+func Ptsname(fd int) (name string, err error) {
+	r0, _, e1 := syscall_syscall(SYS___PTSNAME_A, uintptr(fd), 0, 0)
+	name = u2s(unsafe.Pointer(r0))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func u2s(cstr unsafe.Pointer) string {
+	str := (*[1024]uint8)(cstr)
+	i := 0
+	for str[i] != 0 {
+		i++
+	}
+	return string(str[:i])
+}
+
+func Close(fd int) (err error) {
+	_, _, e1 := syscall_syscall(SYS_CLOSE, uintptr(fd), 0, 0)
+	for i := 0; e1 == EAGAIN && i < 10; i++ {
+		_, _, _ = syscall_syscall(SYS_USLEEP, uintptr(10), 0, 0)
+		_, _, e1 = syscall_syscall(SYS_CLOSE, uintptr(fd), 0, 0)
+	}
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+var mapper = &mmapper{
+	active: make(map[*byte][]byte),
+	mmap:   mmap,
+	munmap: munmap,
+}
+
+// Dummy function: there are no semantics for Madvise on z/OS
+func Madvise(b []byte, advice int) (err error) {
+	return
+}
+
+func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) {
+	return mapper.Mmap(fd, offset, length, prot, flags)
+}
+
+func Munmap(b []byte) (err error) {
+	return mapper.Munmap(b)
+}
+
+//sys   Gethostname(buf []byte) (err error) = SYS___GETHOSTNAME_A
+//sysnb	Getegid() (egid int)
+//sysnb	Geteuid() (uid int)
+//sysnb	Getgid() (gid int)
+//sysnb	Getpid() (pid int)
+//sysnb	Getpgid(pid int) (pgid int, err error) = SYS_GETPGID
+
+func Getpgrp() (pid int) {
+	pid, _ = Getpgid(0)
+	return
+}
+
+//sysnb	Getppid() (pid int)
+//sys	Getpriority(which int, who int) (prio int, err error)
+//sysnb	Getrlimit(resource int, rlim *Rlimit) (err error) = SYS_GETRLIMIT
+
+//sysnb getrusage(who int, rusage *rusage_zos) (err error) = SYS_GETRUSAGE
+
+func Getrusage(who int, rusage *Rusage) (err error) {
+	var ruz rusage_zos
+	err = getrusage(who, &ruz)
+	//Only the first two fields of Rusage are set
+	rusage.Utime.Sec = ruz.Utime.Sec
+	rusage.Utime.Usec = int64(ruz.Utime.Usec)
+	rusage.Stime.Sec = ruz.Stime.Sec
+	rusage.Stime.Usec = int64(ruz.Stime.Usec)
+	return
+}
+
+//sysnb Getsid(pid int) (sid int, err error) = SYS_GETSID
+//sysnb	Getuid() (uid int)
+//sysnb	Kill(pid int, sig Signal) (err error)
+//sys	Lchown(path string, uid int, gid int) (err error) = SYS___LCHOWN_A
+//sys	Link(path string, link string) (err error) = SYS___LINK_A
+//sys	Listen(s int, n int) (err error)
+//sys	lstat(path string, stat *Stat_LE_t) (err error) = SYS___LSTAT_A
+
+func Lstat(path string, stat *Stat_t) (err error) {
+	var statLE Stat_LE_t
+	err = lstat(path, &statLE)
+	copyStat(stat, &statLE)
+	return
+}
+
+//sys	Mkdir(path string, mode uint32) (err error) = SYS___MKDIR_A
+//sys   Mkfifo(path string, mode uint32) (err error) = SYS___MKFIFO_A
+//sys	Mknod(path string, mode uint32, dev int) (err error) = SYS___MKNOD_A
+//sys	Pread(fd int, p []byte, offset int64) (n int, err error)
+//sys	Pwrite(fd int, p []byte, offset int64) (n int, err error)
+//sys	Readlink(path string, buf []byte) (n int, err error) = SYS___READLINK_A
+//sys	Rename(from string, to string) (err error) = SYS___RENAME_A
+//sys	Rmdir(path string) (err error) = SYS___RMDIR_A
+//sys   Seek(fd int, offset int64, whence int) (off int64, err error) = SYS_LSEEK
+//sys	Setpriority(which int, who int, prio int) (err error)
+//sysnb	Setpgid(pid int, pgid int) (err error) = SYS_SETPGID
+//sysnb	Setrlimit(resource int, lim *Rlimit) (err error)
+//sysnb	Setregid(rgid int, egid int) (err error) = SYS_SETREGID
+//sysnb	Setreuid(ruid int, euid int) (err error) = SYS_SETREUID
+//sysnb	Setsid() (pid int, err error) = SYS_SETSID
+//sys	Setuid(uid int) (err error) = SYS_SETUID
+//sys	Setgid(uid int) (err error) = SYS_SETGID
+//sys	Shutdown(fd int, how int) (err error)
+//sys	stat(path string, statLE *Stat_LE_t) (err error) = SYS___STAT_A
+
+func Stat(path string, sta *Stat_t) (err error) {
+	var statLE Stat_LE_t
+	err = stat(path, &statLE)
+	copyStat(sta, &statLE)
+	return
+}
+
+//sys	Symlink(path string, link string) (err error) = SYS___SYMLINK_A
+//sys	Sync() = SYS_SYNC
+//sys	Truncate(path string, length int64) (err error) = SYS___TRUNCATE_A
+//sys	Tcgetattr(fildes int, termptr *Termios) (err error) = SYS_TCGETATTR
+//sys	Tcsetattr(fildes int, when int, termptr *Termios) (err error) = SYS_TCSETATTR
+//sys	Umask(mask int) (oldmask int)
+//sys	Unlink(path string) (err error) = SYS___UNLINK_A
+//sys	Utime(path string, utim *Utimbuf) (err error) = SYS___UTIME_A
+
+//sys	open(path string, mode int, perm uint32) (fd int, err error) = SYS___OPEN_A
+
+func Open(path string, mode int, perm uint32) (fd int, err error) {
+	return open(path, mode, perm)
+}
+
+func Mkfifoat(dirfd int, path string, mode uint32) (err error) {
+	wd, err := Getwd()
+	if err != nil {
+		return err
+	}
+
+	if err := Fchdir(dirfd); err != nil {
+		return err
+	}
+	defer Chdir(wd)
+
+	return Mkfifo(path, mode)
+}
+
+//sys	remove(path string) (err error)
+
+func Remove(path string) error {
+	return remove(path)
+}
+
+const ImplementsGetwd = true
+
+func Getcwd(buf []byte) (n int, err error) {
+	var p unsafe.Pointer
+	if len(buf) > 0 {
+		p = unsafe.Pointer(&buf[0])
+	} else {
+		p = unsafe.Pointer(&_zero)
+	}
+	_, _, e := syscall_syscall(SYS___GETCWD_A, uintptr(p), uintptr(len(buf)), 0)
+	n = clen(buf) + 1
+	if e != 0 {
+		err = errnoErr(e)
+	}
+	return
+}
+
+func Getwd() (wd string, err error) {
+	var buf [PathMax]byte
+	n, err := Getcwd(buf[0:])
+	if err != nil {
+		return "", err
+	}
+	// Getcwd returns the number of bytes written to buf, including the NUL.
+	if n < 1 || n > len(buf) || buf[n-1] != 0 {
+		return "", EINVAL
+	}
+	return string(buf[0 : n-1]), nil
+}
+
+func Getgroups() (gids []int, err error) {
+	n, err := getgroups(0, nil)
+	if err != nil {
+		return nil, err
+	}
+	if n == 0 {
+		return nil, nil
+	}
+
+	// Sanity check group count.  Max is 1<<16 on Linux.
+	if n < 0 || n > 1<<20 {
+		return nil, EINVAL
+	}
+
+	a := make([]_Gid_t, n)
+	n, err = getgroups(n, &a[0])
+	if err != nil {
+		return nil, err
+	}
+	gids = make([]int, n)
+	for i, v := range a[0:n] {
+		gids[i] = int(v)
+	}
+	return
+}
+
+func Setgroups(gids []int) (err error) {
+	if len(gids) == 0 {
+		return setgroups(0, nil)
+	}
+
+	a := make([]_Gid_t, len(gids))
+	for i, v := range gids {
+		a[i] = _Gid_t(v)
+	}
+	return setgroups(len(a), &a[0])
+}
+
+func gettid() uint64
+
+func Gettid() (tid int) {
+	return int(gettid())
+}
+
+type WaitStatus uint32
+
+// Wait status is 7 bits at bottom, either 0 (exited),
+// 0x7F (stopped), or a signal number that caused an exit.
+// The 0x80 bit is whether there was a core dump.
+// An extra number (exit code, signal causing a stop)
+// is in the high bits.  At least that's the idea.
+// There are various irregularities.  For example, the
+// "continued" status is 0xFFFF, distinguishing itself
+// from stopped via the core dump bit.
+
+const (
+	mask    = 0x7F
+	core    = 0x80
+	exited  = 0x00
+	stopped = 0x7F
+	shift   = 8
+)
+
+func (w WaitStatus) Exited() bool { return w&mask == exited }
+
+func (w WaitStatus) Signaled() bool { return w&mask != stopped && w&mask != exited }
+
+func (w WaitStatus) Stopped() bool { return w&0xFF == stopped }
+
+func (w WaitStatus) Continued() bool { return w == 0xFFFF }
+
+func (w WaitStatus) CoreDump() bool { return w.Signaled() && w&core != 0 }
+
+func (w WaitStatus) ExitStatus() int {
+	if !w.Exited() {
+		return -1
+	}
+	return int(w>>shift) & 0xFF
+}
+
+func (w WaitStatus) Signal() Signal {
+	if !w.Signaled() {
+		return -1
+	}
+	return Signal(w & mask)
+}
+
+func (w WaitStatus) StopSignal() Signal {
+	if !w.Stopped() {
+		return -1
+	}
+	return Signal(w>>shift) & 0xFF
+}
+
+func (w WaitStatus) TrapCause() int { return -1 }
+
+//sys	waitpid(pid int, wstatus *_C_int, options int) (wpid int, err error)
+
+func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) {
+	// TODO(mundaym): z/OS doesn't have wait4. I don't think getrusage does what we want.
+	// At the moment rusage will not be touched.
+	var status _C_int
+	wpid, err = waitpid(pid, &status, options)
+	if wstatus != nil {
+		*wstatus = WaitStatus(status)
+	}
+	return
+}
+
+//sysnb	gettimeofday(tv *timeval_zos) (err error)
+
+func Gettimeofday(tv *Timeval) (err error) {
+	var tvz timeval_zos
+	err = gettimeofday(&tvz)
+	tv.Sec = tvz.Sec
+	tv.Usec = int64(tvz.Usec)
+	return
+}
+
+func Time(t *Time_t) (tt Time_t, err error) {
+	var tv Timeval
+	err = Gettimeofday(&tv)
+	if err != nil {
+		return 0, err
+	}
+	if t != nil {
+		*t = Time_t(tv.Sec)
+	}
+	return Time_t(tv.Sec), nil
+}
+
+func setTimespec(sec, nsec int64) Timespec {
+	return Timespec{Sec: sec, Nsec: nsec}
+}
+
+func setTimeval(sec, usec int64) Timeval { //fix
+	return Timeval{Sec: sec, Usec: usec}
+}
+
+//sysnb pipe(p *[2]_C_int) (err error)
+
+func Pipe(p []int) (err error) {
+	if len(p) != 2 {
+		return EINVAL
+	}
+	var pp [2]_C_int
+	err = pipe(&pp)
+	p[0] = int(pp[0])
+	p[1] = int(pp[1])
+	return
+}
+
+//sys	utimes(path string, timeval *[2]Timeval) (err error) = SYS___UTIMES_A
+
+func Utimes(path string, tv []Timeval) (err error) {
+	if len(tv) != 2 {
+		return EINVAL
+	}
+	return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
+}
+
+func UtimesNano(path string, ts []Timespec) error {
+	if len(ts) != 2 {
+		return EINVAL
+	}
+	// Not as efficient as it could be because Timespec and
+	// Timeval have different types in the different OSes
+	tv := [2]Timeval{
+		NsecToTimeval(TimespecToNsec(ts[0])),
+		NsecToTimeval(TimespecToNsec(ts[1])),
+	}
+	return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
+}
+
+func Getsockname(fd int) (sa Sockaddr, err error) {
+	var rsa RawSockaddrAny
+	var len _Socklen = SizeofSockaddrAny
+	if err = getsockname(fd, &rsa, &len); err != nil {
+		return
+	}
+	// TODO(neeilan) : Remove this 0 ( added to get sys/unix compiling on z/OS )
+	return anyToSockaddr(0, &rsa)
+}
+
+const (
+	// identifier constants
+	nwmHeaderIdentifier    = 0xd5e6d4c8
+	nwmFilterIdentifier    = 0xd5e6d4c6
+	nwmTCPConnIdentifier   = 0xd5e6d4c3
+	nwmRecHeaderIdentifier = 0xd5e6d4d9
+	nwmIPStatsIdentifier   = 0xd5e6d4c9d7e2e340
+	nwmIPGStatsIdentifier  = 0xd5e6d4c9d7c7e2e3
+	nwmTCPStatsIdentifier  = 0xd5e6d4e3c3d7e2e3
+	nwmUDPStatsIdentifier  = 0xd5e6d4e4c4d7e2e3
+	nwmICMPGStatsEntry     = 0xd5e6d4c9c3d4d7c7
+	nwmICMPTStatsEntry     = 0xd5e6d4c9c3d4d7e3
+
+	// nwmHeader constants
+	nwmVersion1   = 1
+	nwmVersion2   = 2
+	nwmCurrentVer = 2
+
+	nwmTCPConnType     = 1
+	nwmGlobalStatsType = 14
+
+	// nwmFilter constants
+	nwmFilterLclAddrMask = 0x20000000 // Local address
+	nwmFilterSrcAddrMask = 0x20000000 // Source address
+	nwmFilterLclPortMask = 0x10000000 // Local port
+	nwmFilterSrcPortMask = 0x10000000 // Source port
+
+	// nwmConnEntry constants
+	nwmTCPStateClosed   = 1
+	nwmTCPStateListen   = 2
+	nwmTCPStateSynSent  = 3
+	nwmTCPStateSynRcvd  = 4
+	nwmTCPStateEstab    = 5
+	nwmTCPStateFinWait1 = 6
+	nwmTCPStateFinWait2 = 7
+	nwmTCPStateClosWait = 8
+	nwmTCPStateLastAck  = 9
+	nwmTCPStateClosing  = 10
+	nwmTCPStateTimeWait = 11
+	nwmTCPStateDeletTCB = 12
+
+	// Existing constants on linux
+	BPF_TCP_CLOSE        = 1
+	BPF_TCP_LISTEN       = 2
+	BPF_TCP_SYN_SENT     = 3
+	BPF_TCP_SYN_RECV     = 4
+	BPF_TCP_ESTABLISHED  = 5
+	BPF_TCP_FIN_WAIT1    = 6
+	BPF_TCP_FIN_WAIT2    = 7
+	BPF_TCP_CLOSE_WAIT   = 8
+	BPF_TCP_LAST_ACK     = 9
+	BPF_TCP_CLOSING      = 10
+	BPF_TCP_TIME_WAIT    = 11
+	BPF_TCP_NEW_SYN_RECV = -1
+	BPF_TCP_MAX_STATES   = -2
+)
+
+type nwmTriplet struct {
+	offset uint32
+	length uint32
+	number uint32
+}
+
+type nwmQuadruplet struct {
+	offset uint32
+	length uint32
+	number uint32
+	match  uint32
+}
+
+type nwmHeader struct {
+	ident       uint32
+	length      uint32
+	version     uint16
+	nwmType     uint16
+	bytesNeeded uint32
+	options     uint32
+	_           [16]byte
+	inputDesc   nwmTriplet
+	outputDesc  nwmQuadruplet
+}
+
+type nwmFilter struct {
+	ident         uint32
+	flags         uint32
+	resourceName  [8]byte
+	resourceId    uint32
+	listenerId    uint32
+	local         [28]byte // union of sockaddr4 and sockaddr6
+	remote        [28]byte // union of sockaddr4 and sockaddr6
+	_             uint16
+	_             uint16
+	asid          uint16
+	_             [2]byte
+	tnLuName      [8]byte
+	tnMonGrp      uint32
+	tnAppl        [8]byte
+	applData      [40]byte
+	nInterface    [16]byte
+	dVipa         [16]byte
+	dVipaPfx      uint16
+	dVipaPort     uint16
+	dVipaFamily   byte
+	_             [3]byte
+	destXCF       [16]byte
+	destXCFPfx    uint16
+	destXCFFamily byte
+	_             [1]byte
+	targIP        [16]byte
+	targIPPfx     uint16
+	targIPFamily  byte
+	_             [1]byte
+	_             [20]byte
+}
+
+type nwmRecHeader struct {
+	ident  uint32
+	length uint32
+	number byte
+	_      [3]byte
+}
+
+type nwmTCPStatsEntry struct {
+	ident             uint64
+	currEstab         uint32
+	activeOpened      uint32
+	passiveOpened     uint32
+	connClosed        uint32
+	estabResets       uint32
+	attemptFails      uint32
+	passiveDrops      uint32
+	timeWaitReused    uint32
+	inSegs            uint64
+	predictAck        uint32
+	predictData       uint32
+	inDupAck          uint32
+	inBadSum          uint32
+	inBadLen          uint32
+	inShort           uint32
+	inDiscOldTime     uint32
+	inAllBeforeWin    uint32
+	inSomeBeforeWin   uint32
+	inAllAfterWin     uint32
+	inSomeAfterWin    uint32
+	inOutOfOrder      uint32
+	inAfterClose      uint32
+	inWinProbes       uint32
+	inWinUpdates      uint32
+	outWinUpdates     uint32
+	outSegs           uint64
+	outDelayAcks      uint32
+	outRsts           uint32
+	retransSegs       uint32
+	retransTimeouts   uint32
+	retransDrops      uint32
+	pmtuRetrans       uint32
+	pmtuErrors        uint32
+	outWinProbes      uint32
+	probeDrops        uint32
+	keepAliveProbes   uint32
+	keepAliveDrops    uint32
+	finwait2Drops     uint32
+	acceptCount       uint64
+	inBulkQSegs       uint64
+	inDiscards        uint64
+	connFloods        uint32
+	connStalls        uint32
+	cfgEphemDef       uint16
+	ephemInUse        uint16
+	ephemHiWater      uint16
+	flags             byte
+	_                 [1]byte
+	ephemExhaust      uint32
+	smcRCurrEstabLnks uint32
+	smcRLnkActTimeOut uint32
+	smcRActLnkOpened  uint32
+	smcRPasLnkOpened  uint32
+	smcRLnksClosed    uint32
+	smcRCurrEstab     uint32
+	smcRActiveOpened  uint32
+	smcRPassiveOpened uint32
+	smcRConnClosed    uint32
+	smcRInSegs        uint64
+	smcROutSegs       uint64
+	smcRInRsts        uint32
+	smcROutRsts       uint32
+	smcDCurrEstabLnks uint32
+	smcDActLnkOpened  uint32
+	smcDPasLnkOpened  uint32
+	smcDLnksClosed    uint32
+	smcDCurrEstab     uint32
+	smcDActiveOpened  uint32
+	smcDPassiveOpened uint32
+	smcDConnClosed    uint32
+	smcDInSegs        uint64
+	smcDOutSegs       uint64
+	smcDInRsts        uint32
+	smcDOutRsts       uint32
+}
+
+type nwmConnEntry struct {
+	ident             uint32
+	local             [28]byte // union of sockaddr4 and sockaddr6
+	remote            [28]byte // union of sockaddr4 and sockaddr6
+	startTime         [8]byte  // uint64, changed to prevent padding from being inserted
+	lastActivity      [8]byte  // uint64
+	bytesIn           [8]byte  // uint64
+	bytesOut          [8]byte  // uint64
+	inSegs            [8]byte  // uint64
+	outSegs           [8]byte  // uint64
+	state             uint16
+	activeOpen        byte
+	flag01            byte
+	outBuffered       uint32
+	inBuffered        uint32
+	maxSndWnd         uint32
+	reXmtCount        uint32
+	congestionWnd     uint32
+	ssThresh          uint32
+	roundTripTime     uint32
+	roundTripVar      uint32
+	sendMSS           uint32
+	sndWnd            uint32
+	rcvBufSize        uint32
+	sndBufSize        uint32
+	outOfOrderCount   uint32
+	lcl0WindowCount   uint32
+	rmt0WindowCount   uint32
+	dupacks           uint32
+	flag02            byte
+	sockOpt6Cont      byte
+	asid              uint16
+	resourceName      [8]byte
+	resourceId        uint32
+	subtask           uint32
+	sockOpt           byte
+	sockOpt6          byte
+	clusterConnFlag   byte
+	proto             byte
+	targetAppl        [8]byte
+	luName            [8]byte
+	clientUserId      [8]byte
+	logMode           [8]byte
+	timeStamp         uint32
+	timeStampAge      uint32
+	serverResourceId  uint32
+	intfName          [16]byte
+	ttlsStatPol       byte
+	ttlsStatConn      byte
+	ttlsSSLProt       uint16
+	ttlsNegCiph       [2]byte
+	ttlsSecType       byte
+	ttlsFIPS140Mode   byte
+	ttlsUserID        [8]byte
+	applData          [40]byte
+	inOldestTime      [8]byte // uint64
+	outOldestTime     [8]byte // uint64
+	tcpTrustedPartner byte
+	_                 [3]byte
+	bulkDataIntfName  [16]byte
+	ttlsNegCiph4      [4]byte
+	smcReason         uint32
+	lclSMCLinkId      uint32
+	rmtSMCLinkId      uint32
+	smcStatus         byte
+	smcFlags          byte
+	_                 [2]byte
+	rcvWnd            uint32
+	lclSMCBufSz       uint32
+	rmtSMCBufSz       uint32
+	ttlsSessID        [32]byte
+	ttlsSessIDLen     int16
+	_                 [1]byte
+	smcDStatus        byte
+	smcDReason        uint32
+}
+
+var svcNameTable [][]byte = [][]byte{
+	[]byte("\xc5\xe9\xc2\xd5\xd4\xc9\xc6\xf4"), // svc_EZBNMIF4
+}
+
+const (
+	svc_EZBNMIF4 = 0
+)
+
+func GetsockoptTCPInfo(fd, level, opt int) (*TCPInfo, error) {
+	jobname := []byte("\x5c\x40\x40\x40\x40\x40\x40\x40") // "*"
+	responseBuffer := [4096]byte{0}
+	var bufferAlet, reasonCode uint32 = 0, 0
+	var bufferLen, returnValue, returnCode int32 = 4096, 0, 0
+
+	dsa := [18]uint64{0}
+	var argv [7]unsafe.Pointer
+	argv[0] = unsafe.Pointer(&jobname[0])
+	argv[1] = unsafe.Pointer(&responseBuffer[0])
+	argv[2] = unsafe.Pointer(&bufferAlet)
+	argv[3] = unsafe.Pointer(&bufferLen)
+	argv[4] = unsafe.Pointer(&returnValue)
+	argv[5] = unsafe.Pointer(&returnCode)
+	argv[6] = unsafe.Pointer(&reasonCode)
+
+	request := (*struct {
+		header nwmHeader
+		filter nwmFilter
+	})(unsafe.Pointer(&responseBuffer[0]))
+
+	EZBNMIF4 := svcLoad(&svcNameTable[svc_EZBNMIF4][0])
+	if EZBNMIF4 == nil {
+		return nil, errnoErr(EINVAL)
+	}
+
+	// GetGlobalStats EZBNMIF4 call
+	request.header.ident = nwmHeaderIdentifier
+	request.header.length = uint32(unsafe.Sizeof(request.header))
+	request.header.version = nwmCurrentVer
+	request.header.nwmType = nwmGlobalStatsType
+	request.header.options = 0x80000000
+
+	svcCall(EZBNMIF4, &argv[0], &dsa[0])
+
+	// outputDesc field is filled by EZBNMIF4 on success
+	if returnCode != 0 || request.header.outputDesc.offset == 0 {
+		return nil, errnoErr(EINVAL)
+	}
+
+	// Check that EZBNMIF4 returned a nwmRecHeader
+	recHeader := (*nwmRecHeader)(unsafe.Pointer(&responseBuffer[request.header.outputDesc.offset]))
+	if recHeader.ident != nwmRecHeaderIdentifier {
+		return nil, errnoErr(EINVAL)
+	}
+
+	// Parse nwmTriplets to get offsets of returned entries
+	var sections []*uint64
+	var sectionDesc *nwmTriplet = (*nwmTriplet)(unsafe.Pointer(&responseBuffer[0]))
+	for i := uint32(0); i < uint32(recHeader.number); i++ {
+		offset := request.header.outputDesc.offset + uint32(unsafe.Sizeof(*recHeader)) + i*uint32(unsafe.Sizeof(*sectionDesc))
+		sectionDesc = (*nwmTriplet)(unsafe.Pointer(&responseBuffer[offset]))
+		for j := uint32(0); j < sectionDesc.number; j++ {
+			offset = request.header.outputDesc.offset + sectionDesc.offset + j*sectionDesc.length
+			sections = append(sections, (*uint64)(unsafe.Pointer(&responseBuffer[offset])))
+		}
+	}
+
+	// Find nwmTCPStatsEntry in returned entries
+	var tcpStats *nwmTCPStatsEntry = nil
+	for _, ptr := range sections {
+		switch *ptr {
+		case nwmTCPStatsIdentifier:
+			if tcpStats != nil {
+				return nil, errnoErr(EINVAL)
+			}
+			tcpStats = (*nwmTCPStatsEntry)(unsafe.Pointer(ptr))
+		case nwmIPStatsIdentifier:
+		case nwmIPGStatsIdentifier:
+		case nwmUDPStatsIdentifier:
+		case nwmICMPGStatsEntry:
+		case nwmICMPTStatsEntry:
+		default:
+			return nil, errnoErr(EINVAL)
+		}
+	}
+	if tcpStats == nil {
+		return nil, errnoErr(EINVAL)
+	}
+
+	// GetConnectionDetail EZBNMIF4 call
+	responseBuffer = [4096]byte{0}
+	dsa = [18]uint64{0}
+	bufferAlet, reasonCode = 0, 0
+	bufferLen, returnValue, returnCode = 4096, 0, 0
+	nameptr := (*uint32)(unsafe.Pointer(uintptr(0x21c))) // Get jobname of current process
+	nameptr = (*uint32)(unsafe.Pointer(uintptr(*nameptr + 12)))
+	argv[0] = unsafe.Pointer(uintptr(*nameptr))
+
+	request.header.ident = nwmHeaderIdentifier
+	request.header.length = uint32(unsafe.Sizeof(request.header))
+	request.header.version = nwmCurrentVer
+	request.header.nwmType = nwmTCPConnType
+	request.header.options = 0x80000000
+
+	request.filter.ident = nwmFilterIdentifier
+
+	var localSockaddr RawSockaddrAny
+	socklen := _Socklen(SizeofSockaddrAny)
+	err := getsockname(fd, &localSockaddr, &socklen)
+	if err != nil {
+		return nil, errnoErr(EINVAL)
+	}
+	if localSockaddr.Addr.Family == AF_INET {
+		localSockaddr := (*RawSockaddrInet4)(unsafe.Pointer(&localSockaddr.Addr))
+		localSockFilter := (*RawSockaddrInet4)(unsafe.Pointer(&request.filter.local[0]))
+		localSockFilter.Family = AF_INET
+		var i int
+		for i = 0; i < 4; i++ {
+			if localSockaddr.Addr[i] != 0 {
+				break
+			}
+		}
+		if i != 4 {
+			request.filter.flags |= nwmFilterLclAddrMask
+			for i = 0; i < 4; i++ {
+				localSockFilter.Addr[i] = localSockaddr.Addr[i]
+			}
+		}
+		if localSockaddr.Port != 0 {
+			request.filter.flags |= nwmFilterLclPortMask
+			localSockFilter.Port = localSockaddr.Port
+		}
+	} else if localSockaddr.Addr.Family == AF_INET6 {
+		localSockaddr := (*RawSockaddrInet6)(unsafe.Pointer(&localSockaddr.Addr))
+		localSockFilter := (*RawSockaddrInet6)(unsafe.Pointer(&request.filter.local[0]))
+		localSockFilter.Family = AF_INET6
+		var i int
+		for i = 0; i < 16; i++ {
+			if localSockaddr.Addr[i] != 0 {
+				break
+			}
+		}
+		if i != 16 {
+			request.filter.flags |= nwmFilterLclAddrMask
+			for i = 0; i < 16; i++ {
+				localSockFilter.Addr[i] = localSockaddr.Addr[i]
+			}
+		}
+		if localSockaddr.Port != 0 {
+			request.filter.flags |= nwmFilterLclPortMask
+			localSockFilter.Port = localSockaddr.Port
+		}
+	}
+
+	svcCall(EZBNMIF4, &argv[0], &dsa[0])
+
+	// outputDesc field is filled by EZBNMIF4 on success
+	if returnCode != 0 || request.header.outputDesc.offset == 0 {
+		return nil, errnoErr(EINVAL)
+	}
+
+	// Check that EZBNMIF4 returned a nwmConnEntry
+	conn := (*nwmConnEntry)(unsafe.Pointer(&responseBuffer[request.header.outputDesc.offset]))
+	if conn.ident != nwmTCPConnIdentifier {
+		return nil, errnoErr(EINVAL)
+	}
+
+	// Copy data from the returned data structures into tcpInfo
+	// Stats from nwmConnEntry are specific to that connection.
+	// Stats from nwmTCPStatsEntry are global (to the interface?)
+	// Fields may not be an exact match. Some fields have no equivalent.
+	var tcpinfo TCPInfo
+	tcpinfo.State = uint8(conn.state)
+	tcpinfo.Ca_state = 0 // dummy
+	tcpinfo.Retransmits = uint8(tcpStats.retransSegs)
+	tcpinfo.Probes = uint8(tcpStats.outWinProbes)
+	tcpinfo.Backoff = 0 // dummy
+	tcpinfo.Options = 0 // dummy
+	tcpinfo.Rto = tcpStats.retransTimeouts
+	tcpinfo.Ato = tcpStats.outDelayAcks
+	tcpinfo.Snd_mss = conn.sendMSS
+	tcpinfo.Rcv_mss = conn.sendMSS // dummy
+	tcpinfo.Unacked = 0            // dummy
+	tcpinfo.Sacked = 0             // dummy
+	tcpinfo.Lost = 0               // dummy
+	tcpinfo.Retrans = conn.reXmtCount
+	tcpinfo.Fackets = 0 // dummy
+	tcpinfo.Last_data_sent = uint32(*(*uint64)(unsafe.Pointer(&conn.lastActivity[0])))
+	tcpinfo.Last_ack_sent = uint32(*(*uint64)(unsafe.Pointer(&conn.outOldestTime[0])))
+	tcpinfo.Last_data_recv = uint32(*(*uint64)(unsafe.Pointer(&conn.inOldestTime[0])))
+	tcpinfo.Last_ack_recv = uint32(*(*uint64)(unsafe.Pointer(&conn.inOldestTime[0])))
+	tcpinfo.Pmtu = conn.sendMSS // dummy, NWMIfRouteMtu is a candidate
+	tcpinfo.Rcv_ssthresh = conn.ssThresh
+	tcpinfo.Rtt = conn.roundTripTime
+	tcpinfo.Rttvar = conn.roundTripVar
+	tcpinfo.Snd_ssthresh = conn.ssThresh // dummy
+	tcpinfo.Snd_cwnd = conn.congestionWnd
+	tcpinfo.Advmss = conn.sendMSS        // dummy
+	tcpinfo.Reordering = 0               // dummy
+	tcpinfo.Rcv_rtt = conn.roundTripTime // dummy
+	tcpinfo.Rcv_space = conn.sendMSS     // dummy
+	tcpinfo.Total_retrans = conn.reXmtCount
+
+	svcUnload(&svcNameTable[svc_EZBNMIF4][0], EZBNMIF4)
+
+	return &tcpinfo, nil
+}
+
+// GetsockoptString returns the string value of the socket option opt for the
+// socket associated with fd at the given socket level.
+func GetsockoptString(fd, level, opt int) (string, error) {
+	buf := make([]byte, 256)
+	vallen := _Socklen(len(buf))
+	err := getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen)
+	if err != nil {
+		return "", err
+	}
+
+	return string(buf[:vallen-1]), nil
+}
+
+func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) {
+	var msg Msghdr
+	var rsa RawSockaddrAny
+	msg.Name = (*byte)(unsafe.Pointer(&rsa))
+	msg.Namelen = SizeofSockaddrAny
+	var iov Iovec
+	if len(p) > 0 {
+		iov.Base = (*byte)(unsafe.Pointer(&p[0]))
+		iov.SetLen(len(p))
+	}
+	var dummy byte
+	if len(oob) > 0 {
+		// receive at least one normal byte
+		if len(p) == 0 {
+			iov.Base = &dummy
+			iov.SetLen(1)
+		}
+		msg.Control = (*byte)(unsafe.Pointer(&oob[0]))
+		msg.SetControllen(len(oob))
+	}
+	msg.Iov = &iov
+	msg.Iovlen = 1
+	if n, err = recvmsg(fd, &msg, flags); err != nil {
+		return
+	}
+	oobn = int(msg.Controllen)
+	recvflags = int(msg.Flags)
+	// source address is only specified if the socket is unconnected
+	if rsa.Addr.Family != AF_UNSPEC {
+		// TODO(neeilan): Remove 0 arg added to get this compiling on z/OS
+		from, err = anyToSockaddr(0, &rsa)
+	}
+	return
+}
+
+func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) {
+	_, err = SendmsgN(fd, p, oob, to, flags)
+	return
+}
+
+func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) {
+	var ptr unsafe.Pointer
+	var salen _Socklen
+	if to != nil {
+		var err error
+		ptr, salen, err = to.sockaddr()
+		if err != nil {
+			return 0, err
+		}
+	}
+	var msg Msghdr
+	msg.Name = (*byte)(unsafe.Pointer(ptr))
+	msg.Namelen = int32(salen)
+	var iov Iovec
+	if len(p) > 0 {
+		iov.Base = (*byte)(unsafe.Pointer(&p[0]))
+		iov.SetLen(len(p))
+	}
+	var dummy byte
+	if len(oob) > 0 {
+		// send at least one normal byte
+		if len(p) == 0 {
+			iov.Base = &dummy
+			iov.SetLen(1)
+		}
+		msg.Control = (*byte)(unsafe.Pointer(&oob[0]))
+		msg.SetControllen(len(oob))
+	}
+	msg.Iov = &iov
+	msg.Iovlen = 1
+	if n, err = sendmsg(fd, &msg, flags); err != nil {
+		return 0, err
+	}
+	if len(oob) > 0 && len(p) == 0 {
+		n = 0
+	}
+	return n, nil
+}
+
+func Opendir(name string) (uintptr, error) {
+	p, err := BytePtrFromString(name)
+	if err != nil {
+		return 0, err
+	}
+	dir, _, e := syscall_syscall(SYS___OPENDIR_A, uintptr(unsafe.Pointer(p)), 0, 0)
+	runtime.KeepAlive(unsafe.Pointer(p))
+	if e != 0 {
+		err = errnoErr(e)
+	}
+	return dir, err
+}
+
+// clearsyscall.Errno resets the errno value to 0.
+func clearErrno()
+
+func Readdir(dir uintptr) (*Dirent, error) {
+	var ent Dirent
+	var res uintptr
+	// __readdir_r_a returns errno at the end of the directory stream, rather than 0.
+	// Therefore to avoid false positives we clear errno before calling it.
+
+	// TODO(neeilan): Commented this out to get sys/unix compiling on z/OS. Uncomment and fix. Error: "undefined: clearsyscall"
+	//clearsyscall.Errno() // TODO(mundaym): check pre-emption rules.
+
+	e, _, _ := syscall_syscall(SYS___READDIR_R_A, dir, uintptr(unsafe.Pointer(&ent)), uintptr(unsafe.Pointer(&res)))
+	var err error
+	if e != 0 {
+		err = errnoErr(Errno(e))
+	}
+	if res == 0 {
+		return nil, err
+	}
+	return &ent, err
+}
+
+func Closedir(dir uintptr) error {
+	_, _, e := syscall_syscall(SYS_CLOSEDIR, dir, 0, 0)
+	if e != 0 {
+		return errnoErr(e)
+	}
+	return nil
+}
+
+func Seekdir(dir uintptr, pos int) {
+	_, _, _ = syscall_syscall(SYS_SEEKDIR, dir, uintptr(pos), 0)
+}
+
+func Telldir(dir uintptr) (int, error) {
+	p, _, e := syscall_syscall(SYS_TELLDIR, dir, 0, 0)
+	pos := int(p)
+	if pos == -1 {
+		return pos, errnoErr(e)
+	}
+	return pos, nil
+}
+
+// FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command.
+func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error {
+	// struct flock is packed on z/OS. We can't emulate that in Go so
+	// instead we pack it here.
+	var flock [24]byte
+	*(*int16)(unsafe.Pointer(&flock[0])) = lk.Type
+	*(*int16)(unsafe.Pointer(&flock[2])) = lk.Whence
+	*(*int64)(unsafe.Pointer(&flock[4])) = lk.Start
+	*(*int64)(unsafe.Pointer(&flock[12])) = lk.Len
+	*(*int32)(unsafe.Pointer(&flock[20])) = lk.Pid
+	_, _, errno := syscall_syscall(SYS_FCNTL, fd, uintptr(cmd), uintptr(unsafe.Pointer(&flock)))
+	lk.Type = *(*int16)(unsafe.Pointer(&flock[0]))
+	lk.Whence = *(*int16)(unsafe.Pointer(&flock[2]))
+	lk.Start = *(*int64)(unsafe.Pointer(&flock[4]))
+	lk.Len = *(*int64)(unsafe.Pointer(&flock[12]))
+	lk.Pid = *(*int32)(unsafe.Pointer(&flock[20]))
+	if errno == 0 {
+		return nil
+	}
+	return errno
+}
+
+func Flock(fd int, how int) error {
+
+	var flock_type int16
+	var fcntl_cmd int
+
+	switch how {
+	case LOCK_SH | LOCK_NB:
+		flock_type = F_RDLCK
+		fcntl_cmd = F_SETLK
+	case LOCK_EX | LOCK_NB:
+		flock_type = F_WRLCK
+		fcntl_cmd = F_SETLK
+	case LOCK_EX:
+		flock_type = F_WRLCK
+		fcntl_cmd = F_SETLKW
+	case LOCK_UN:
+		flock_type = F_UNLCK
+		fcntl_cmd = F_SETLKW
+	default:
+	}
+
+	flock := Flock_t{
+		Type:   int16(flock_type),
+		Whence: int16(0),
+		Start:  int64(0),
+		Len:    int64(0),
+		Pid:    int32(Getppid()),
+	}
+
+	err := FcntlFlock(uintptr(fd), fcntl_cmd, &flock)
+	return err
+}
+
+func Mlock(b []byte) (err error) {
+	_, _, e1 := syscall_syscall(SYS___MLOCKALL, _BPX_NONSWAP, 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func Mlock2(b []byte, flags int) (err error) {
+	_, _, e1 := syscall_syscall(SYS___MLOCKALL, _BPX_NONSWAP, 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func Mlockall(flags int) (err error) {
+	_, _, e1 := syscall_syscall(SYS___MLOCKALL, _BPX_NONSWAP, 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func Munlock(b []byte) (err error) {
+	_, _, e1 := syscall_syscall(SYS___MLOCKALL, _BPX_SWAP, 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func Munlockall() (err error) {
+	_, _, e1 := syscall_syscall(SYS___MLOCKALL, _BPX_SWAP, 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func ClockGettime(clockid int32, ts *Timespec) error {
+
+	var ticks_per_sec uint32 = 100 //TODO(kenan): value is currently hardcoded; need sysconf() call otherwise
+	var nsec_per_sec int64 = 1000000000
+
+	if ts == nil {
+		return EFAULT
+	}
+	if clockid == CLOCK_REALTIME || clockid == CLOCK_MONOTONIC {
+		var nanotime int64 = runtime.Nanotime1()
+		ts.Sec = nanotime / nsec_per_sec
+		ts.Nsec = nanotime % nsec_per_sec
+	} else if clockid == CLOCK_PROCESS_CPUTIME_ID || clockid == CLOCK_THREAD_CPUTIME_ID {
+		var tm Tms
+		_, err := Times(&tm)
+		if err != nil {
+			return EFAULT
+		}
+		ts.Sec = int64(tm.Utime / ticks_per_sec)
+		ts.Nsec = int64(tm.Utime) * nsec_per_sec / int64(ticks_per_sec)
+	} else {
+		return EINVAL
+	}
+	return nil
+}
+
+func Statfs(path string, stat *Statfs_t) (err error) {
+	fd, err := open(path, O_RDONLY, 0)
+	defer Close(fd)
+	if err != nil {
+		return err
+	}
+	return Fstatfs(fd, stat)
+}
+
+var (
+	Stdin  = 0
+	Stdout = 1
+	Stderr = 2
+)
+
+// Do the interface allocations only once for common
+// Errno values.
+var (
+	errEAGAIN error = syscall.EAGAIN
+	errEINVAL error = syscall.EINVAL
+	errENOENT error = syscall.ENOENT
+)
+
+var (
+	signalNameMapOnce sync.Once
+	signalNameMap     map[string]syscall.Signal
+)
+
+// errnoErr returns common boxed Errno values, to prevent
+// allocations at runtime.
+func errnoErr(e Errno) error {
+	switch e {
+	case 0:
+		return nil
+	case EAGAIN:
+		return errEAGAIN
+	case EINVAL:
+		return errEINVAL
+	case ENOENT:
+		return errENOENT
+	}
+	return e
+}
+
+// ErrnoName returns the error name for error number e.
+func ErrnoName(e Errno) string {
+	i := sort.Search(len(errorList), func(i int) bool {
+		return errorList[i].num >= e
+	})
+	if i < len(errorList) && errorList[i].num == e {
+		return errorList[i].name
+	}
+	return ""
+}
+
+// SignalName returns the signal name for signal number s.
+func SignalName(s syscall.Signal) string {
+	i := sort.Search(len(signalList), func(i int) bool {
+		return signalList[i].num >= s
+	})
+	if i < len(signalList) && signalList[i].num == s {
+		return signalList[i].name
+	}
+	return ""
+}
+
+// SignalNum returns the syscall.Signal for signal named s,
+// or 0 if a signal with such name is not found.
+// The signal name should start with "SIG".
+func SignalNum(s string) syscall.Signal {
+	signalNameMapOnce.Do(func() {
+		signalNameMap = make(map[string]syscall.Signal, len(signalList))
+		for _, signal := range signalList {
+			signalNameMap[signal.name] = signal.num
+		}
+	})
+	return signalNameMap[s]
+}
+
+// clen returns the index of the first NULL byte in n or len(n) if n contains no NULL byte.
+func clen(n []byte) int {
+	i := bytes.IndexByte(n, 0)
+	if i == -1 {
+		i = len(n)
+	}
+	return i
+}
+
+// Mmap manager, for use by operating system-specific implementations.
+
+type mmapper struct {
+	sync.Mutex
+	active map[*byte][]byte // active mappings; key is last byte in mapping
+	mmap   func(addr, length uintptr, prot, flags, fd int, offset int64) (uintptr, error)
+	munmap func(addr uintptr, length uintptr) error
+}
+
+func (m *mmapper) Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) {
+	if length <= 0 {
+		return nil, EINVAL
+	}
+
+	// Map the requested memory.
+	addr, errno := m.mmap(0, uintptr(length), prot, flags, fd, offset)
+	if errno != nil {
+		return nil, errno
+	}
+
+	// Slice memory layout
+	var sl = struct {
+		addr uintptr
+		len  int
+		cap  int
+	}{addr, length, length}
+
+	// Use unsafe to turn sl into a []byte.
+	b := *(*[]byte)(unsafe.Pointer(&sl))
+
+	// Register mapping in m and return it.
+	p := &b[cap(b)-1]
+	m.Lock()
+	defer m.Unlock()
+	m.active[p] = b
+	return b, nil
+}
+
+func (m *mmapper) Munmap(data []byte) (err error) {
+	if len(data) == 0 || len(data) != cap(data) {
+		return EINVAL
+	}
+
+	// Find the base of the mapping.
+	p := &data[cap(data)-1]
+	m.Lock()
+	defer m.Unlock()
+	b := m.active[p]
+	if b == nil || &b[0] != &data[0] {
+		return EINVAL
+	}
+
+	// Unmap the memory and update m.
+	if errno := m.munmap(uintptr(unsafe.Pointer(&b[0])), uintptr(len(b))); errno != nil {
+		return errno
+	}
+	delete(m.active, p)
+	return nil
+}
+
+func Read(fd int, p []byte) (n int, err error) {
+	n, err = read(fd, p)
+	if raceenabled {
+		if n > 0 {
+			raceWriteRange(unsafe.Pointer(&p[0]), n)
+		}
+		if err == nil {
+			raceAcquire(unsafe.Pointer(&ioSync))
+		}
+	}
+	return
+}
+
+func Write(fd int, p []byte) (n int, err error) {
+	if raceenabled {
+		raceReleaseMerge(unsafe.Pointer(&ioSync))
+	}
+	n, err = write(fd, p)
+	if raceenabled && n > 0 {
+		raceReadRange(unsafe.Pointer(&p[0]), n)
+	}
+	return
+}
+
+// For testing: clients can set this flag to force
+// creation of IPv6 sockets to return EAFNOSUPPORT.
+var SocketDisableIPv6 bool
+
+// Sockaddr represents a socket address.
+type Sockaddr interface {
+	sockaddr() (ptr unsafe.Pointer, len _Socklen, err error) // lowercase; only we can define Sockaddrs
+}
+
+// SockaddrInet4 implements the Sockaddr interface for AF_INET type sockets.
+type SockaddrInet4 struct {
+	Port int
+	Addr [4]byte
+	raw  RawSockaddrInet4
+}
+
+// SockaddrInet6 implements the Sockaddr interface for AF_INET6 type sockets.
+type SockaddrInet6 struct {
+	Port   int
+	ZoneId uint32
+	Addr   [16]byte
+	raw    RawSockaddrInet6
+}
+
+// SockaddrUnix implements the Sockaddr interface for AF_UNIX type sockets.
+type SockaddrUnix struct {
+	Name string
+	raw  RawSockaddrUnix
+}
+
+func Bind(fd int, sa Sockaddr) (err error) {
+	ptr, n, err := sa.sockaddr()
+	if err != nil {
+		return err
+	}
+	return bind(fd, ptr, n)
+}
+
+func Connect(fd int, sa Sockaddr) (err error) {
+	ptr, n, err := sa.sockaddr()
+	if err != nil {
+		return err
+	}
+	return connect(fd, ptr, n)
+}
+
+func Getpeername(fd int) (sa Sockaddr, err error) {
+	var rsa RawSockaddrAny
+	var len _Socklen = SizeofSockaddrAny
+	if err = getpeername(fd, &rsa, &len); err != nil {
+		return
+	}
+	return anyToSockaddr(fd, &rsa)
+}
+
+func GetsockoptByte(fd, level, opt int) (value byte, err error) {
+	var n byte
+	vallen := _Socklen(1)
+	err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen)
+	return n, err
+}
+
+func GetsockoptInt(fd, level, opt int) (value int, err error) {
+	var n int32
+	vallen := _Socklen(4)
+	err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen)
+	return int(n), err
+}
+
+func GetsockoptInet4Addr(fd, level, opt int) (value [4]byte, err error) {
+	vallen := _Socklen(4)
+	err = getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
+	return value, err
+}
+
+func GetsockoptIPMreq(fd, level, opt int) (*IPMreq, error) {
+	var value IPMreq
+	vallen := _Socklen(SizeofIPMreq)
+	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
+	return &value, err
+}
+
+func GetsockoptIPv6Mreq(fd, level, opt int) (*IPv6Mreq, error) {
+	var value IPv6Mreq
+	vallen := _Socklen(SizeofIPv6Mreq)
+	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
+	return &value, err
+}
+
+func GetsockoptIPv6MTUInfo(fd, level, opt int) (*IPv6MTUInfo, error) {
+	var value IPv6MTUInfo
+	vallen := _Socklen(SizeofIPv6MTUInfo)
+	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
+	return &value, err
+}
+
+func GetsockoptICMPv6Filter(fd, level, opt int) (*ICMPv6Filter, error) {
+	var value ICMPv6Filter
+	vallen := _Socklen(SizeofICMPv6Filter)
+	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
+	return &value, err
+}
+
+func GetsockoptLinger(fd, level, opt int) (*Linger, error) {
+	var linger Linger
+	vallen := _Socklen(SizeofLinger)
+	err := getsockopt(fd, level, opt, unsafe.Pointer(&linger), &vallen)
+	return &linger, err
+}
+
+func GetsockoptTimeval(fd, level, opt int) (*Timeval, error) {
+	var tv Timeval
+	vallen := _Socklen(unsafe.Sizeof(tv))
+	err := getsockopt(fd, level, opt, unsafe.Pointer(&tv), &vallen)
+	return &tv, err
+}
+
+func GetsockoptUint64(fd, level, opt int) (value uint64, err error) {
+	var n uint64
+	vallen := _Socklen(8)
+	err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen)
+	return n, err
+}
+
+func Recvfrom(fd int, p []byte, flags int) (n int, from Sockaddr, err error) {
+	var rsa RawSockaddrAny
+	var len _Socklen = SizeofSockaddrAny
+	if n, err = recvfrom(fd, p, flags, &rsa, &len); err != nil {
+		return
+	}
+	if rsa.Addr.Family != AF_UNSPEC {
+		from, err = anyToSockaddr(fd, &rsa)
+	}
+	return
+}
+
+func Sendto(fd int, p []byte, flags int, to Sockaddr) (err error) {
+	ptr, n, err := to.sockaddr()
+	if err != nil {
+		return err
+	}
+	return sendto(fd, p, flags, ptr, n)
+}
+
+func SetsockoptByte(fd, level, opt int, value byte) (err error) {
+	return setsockopt(fd, level, opt, unsafe.Pointer(&value), 1)
+}
+
+func SetsockoptInt(fd, level, opt int, value int) (err error) {
+	var n = int32(value)
+	return setsockopt(fd, level, opt, unsafe.Pointer(&n), 4)
+}
+
+func SetsockoptInet4Addr(fd, level, opt int, value [4]byte) (err error) {
+	return setsockopt(fd, level, opt, unsafe.Pointer(&value[0]), 4)
+}
+
+func SetsockoptIPMreq(fd, level, opt int, mreq *IPMreq) (err error) {
+	return setsockopt(fd, level, opt, unsafe.Pointer(mreq), SizeofIPMreq)
+}
+
+func SetsockoptIPv6Mreq(fd, level, opt int, mreq *IPv6Mreq) (err error) {
+	return setsockopt(fd, level, opt, unsafe.Pointer(mreq), SizeofIPv6Mreq)
+}
+
+func SetsockoptICMPv6Filter(fd, level, opt int, filter *ICMPv6Filter) error {
+	return setsockopt(fd, level, opt, unsafe.Pointer(filter), SizeofICMPv6Filter)
+}
+
+func SetsockoptLinger(fd, level, opt int, l *Linger) (err error) {
+	return setsockopt(fd, level, opt, unsafe.Pointer(l), SizeofLinger)
+}
+
+func SetsockoptString(fd, level, opt int, s string) (err error) {
+	var p unsafe.Pointer
+	if len(s) > 0 {
+		p = unsafe.Pointer(&[]byte(s)[0])
+	}
+	return setsockopt(fd, level, opt, p, uintptr(len(s)))
+}
+
+func SetsockoptTimeval(fd, level, opt int, tv *Timeval) (err error) {
+	return setsockopt(fd, level, opt, unsafe.Pointer(tv), unsafe.Sizeof(*tv))
+}
+
+func SetsockoptUint64(fd, level, opt int, value uint64) (err error) {
+	return setsockopt(fd, level, opt, unsafe.Pointer(&value), 8)
+}
+
+func Socket(domain, typ, proto int) (fd int, err error) {
+	if domain == AF_INET6 && SocketDisableIPv6 {
+		return -1, EAFNOSUPPORT
+	}
+	fd, err = socket(domain, typ, proto)
+	return
+}
+
+func Socketpair(domain, typ, proto int) (fd [2]int, err error) {
+	var fdx [2]int32
+	err = socketpair(domain, typ, proto, &fdx)
+	if err == nil {
+		fd[0] = int(fdx[0])
+		fd[1] = int(fdx[1])
+	}
+	return
+}
+
+var ioSync int64
+
+func CloseOnExec(fd int) { fcntl(fd, F_SETFD, FD_CLOEXEC) }
+
+func SetNonblock(fd int, nonblocking bool) (err error) {
+	flag, err := fcntl(fd, F_GETFL, 0)
+	if err != nil {
+		return err
+	}
+	if nonblocking {
+		flag |= O_NONBLOCK
+	} else {
+		flag &= ^O_NONBLOCK
+	}
+	_, err = fcntl(fd, F_SETFL, flag)
+	return err
+}
+
+// Exec calls execve(2), which replaces the calling executable in the process
+// tree. argv0 should be the full path to an executable ("/bin/ls") and the
+// executable name should also be the first argument in argv (["ls", "-l"]).
+// envv are the environment variables that should be passed to the new
+// process (["USER=go", "PWD=/tmp"]).
+func Exec(argv0 string, argv []string, envv []string) error {
+	return syscall.Exec(argv0, argv, envv)
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/timestruct.go b/src/cmd/vendor/golang.org/x/sys/unix/timestruct.go
index 103604299e..3d89304055 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/timestruct.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/timestruct.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos
+// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos
 
 package unix
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/xattr_bsd.go b/src/cmd/vendor/golang.org/x/sys/unix/xattr_bsd.go
index 30c1d71f4e..25df1e3780 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/xattr_bsd.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/xattr_bsd.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build freebsd || netbsd
 // +build freebsd netbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_aix_ppc.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_aix_ppc.go
index 104994bc6a..ca9799b79e 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_aix_ppc.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_aix_ppc.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -maix32
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build ppc && aix
 // +build ppc,aix
 
 // Created by cgo -godefs - DO NOT EDIT
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_aix_ppc64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_aix_ppc64.go
index 4fc8d30649..200c8c26fe 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_aix_ppc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_aix_ppc64.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -maix64
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build ppc64 && aix
 // +build ppc64,aix
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_386.go
index ec376f51bc..7ee196f7fc 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_386.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -m32
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build 386 && darwin
 // +build 386,darwin
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
index dcb96c26c0..0100cb12f1 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -m64
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build amd64 && darwin
 // +build amd64,darwin
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_arm.go
index 03feefbf8c..e748cb1105 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_arm.go
@@ -1,6 +1,7 @@
 // mkerrors.sh
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm && darwin
 // +build arm,darwin
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
index 8602b13633..df26a19681 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -m64
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm64 && darwin
 // +build arm64,darwin
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_dragonfly_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_dragonfly_amd64.go
index f5e91b7aba..17bba0e44f 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_dragonfly_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_dragonfly_amd64.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -m64
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build amd64 && dragonfly
 // +build amd64,dragonfly
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_freebsd_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_freebsd_386.go
index 3689c80848..9c7c5e1654 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_freebsd_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_freebsd_386.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -m32
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build 386 && freebsd
 // +build 386,freebsd
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
@@ -997,6 +998,11 @@ const (
 	KERN_OSRELEASE                 = 0x2
 	KERN_OSTYPE                    = 0x1
 	KERN_VERSION                   = 0x4
+	LOCAL_CONNWAIT                 = 0x4
+	LOCAL_CREDS                    = 0x2
+	LOCAL_CREDS_PERSISTENT         = 0x3
+	LOCAL_PEERCRED                 = 0x1
+	LOCAL_VENDOR                   = 0x80000000
 	LOCK_EX                        = 0x2
 	LOCK_NB                        = 0x4
 	LOCK_SH                        = 0x1
@@ -1375,6 +1381,7 @@ const (
 	SOCK_RDM                       = 0x4
 	SOCK_SEQPACKET                 = 0x5
 	SOCK_STREAM                    = 0x1
+	SOL_LOCAL                      = 0x0
 	SOL_SOCKET                     = 0xffff
 	SOMAXCONN                      = 0x80
 	SO_ACCEPTCONN                  = 0x2
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_freebsd_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_freebsd_amd64.go
index b8f7c3c930..b265abb25f 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_freebsd_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_freebsd_amd64.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -m64
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build amd64 && freebsd
 // +build amd64,freebsd
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
@@ -997,6 +998,11 @@ const (
 	KERN_OSRELEASE                 = 0x2
 	KERN_OSTYPE                    = 0x1
 	KERN_VERSION                   = 0x4
+	LOCAL_CONNWAIT                 = 0x4
+	LOCAL_CREDS                    = 0x2
+	LOCAL_CREDS_PERSISTENT         = 0x3
+	LOCAL_PEERCRED                 = 0x1
+	LOCAL_VENDOR                   = 0x80000000
 	LOCK_EX                        = 0x2
 	LOCK_NB                        = 0x4
 	LOCK_SH                        = 0x1
@@ -1376,6 +1382,7 @@ const (
 	SOCK_RDM                       = 0x4
 	SOCK_SEQPACKET                 = 0x5
 	SOCK_STREAM                    = 0x1
+	SOL_LOCAL                      = 0x0
 	SOL_SOCKET                     = 0xffff
 	SOMAXCONN                      = 0x80
 	SO_ACCEPTCONN                  = 0x2
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_freebsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_freebsd_arm.go
index be14bb1a4c..0326a6b3af 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_freebsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_freebsd_arm.go
@@ -1,6 +1,7 @@
 // mkerrors.sh
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm && freebsd
 // +build arm,freebsd
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
@@ -980,6 +981,11 @@ const (
 	KERN_OSRELEASE                 = 0x2
 	KERN_OSTYPE                    = 0x1
 	KERN_VERSION                   = 0x4
+	LOCAL_CONNWAIT                 = 0x4
+	LOCAL_CREDS                    = 0x2
+	LOCAL_CREDS_PERSISTENT         = 0x3
+	LOCAL_PEERCRED                 = 0x1
+	LOCAL_VENDOR                   = 0x80000000
 	LOCK_EX                        = 0x2
 	LOCK_NB                        = 0x4
 	LOCK_SH                        = 0x1
@@ -1341,6 +1347,7 @@ const (
 	SOCK_RDM                       = 0x4
 	SOCK_SEQPACKET                 = 0x5
 	SOCK_STREAM                    = 0x1
+	SOL_LOCAL                      = 0x0
 	SOL_SOCKET                     = 0xffff
 	SOMAXCONN                      = 0x80
 	SO_ACCEPTCONN                  = 0x2
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_freebsd_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_freebsd_arm64.go
index 7ce9c0081a..218d39906d 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_freebsd_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_freebsd_arm64.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -m64
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm64 && freebsd
 // +build arm64,freebsd
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
@@ -997,6 +998,11 @@ const (
 	KERN_OSRELEASE                 = 0x2
 	KERN_OSTYPE                    = 0x1
 	KERN_VERSION                   = 0x4
+	LOCAL_CONNWAIT                 = 0x4
+	LOCAL_CREDS                    = 0x2
+	LOCAL_CREDS_PERSISTENT         = 0x3
+	LOCAL_PEERCRED                 = 0x1
+	LOCAL_VENDOR                   = 0x80000000
 	LOCK_EX                        = 0x2
 	LOCK_NB                        = 0x4
 	LOCK_SH                        = 0x1
@@ -1376,6 +1382,7 @@ const (
 	SOCK_RDM                       = 0x4
 	SOCK_SEQPACKET                 = 0x5
 	SOCK_STREAM                    = 0x1
+	SOL_LOCAL                      = 0x0
 	SOL_SOCKET                     = 0xffff
 	SOMAXCONN                      = 0x80
 	SO_ACCEPTCONN                  = 0x2
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux.go
index c5e2f47930..504dd6cd2d 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux.go
@@ -1,5 +1,6 @@
 // Code generated by mkmerge.go; DO NOT EDIT.
 
+//go:build linux
 // +build linux
 
 package unix
@@ -244,6 +245,10 @@ const (
 	BS0                                         = 0x0
 	BTRFS_SUPER_MAGIC                           = 0x9123683e
 	BTRFS_TEST_MAGIC                            = 0x73727279
+	BUS_BLUETOOTH                               = 0x5
+	BUS_HIL                                     = 0x4
+	BUS_USB                                     = 0x3
+	BUS_VIRTUAL                                 = 0x6
 	CAN_BCM                                     = 0x2
 	CAN_EFF_FLAG                                = 0x80000000
 	CAN_EFF_ID_BITS                             = 0x1d
@@ -963,6 +968,7 @@ const (
 	HDIO_SET_XFER                               = 0x306
 	HDIO_TRISTATE_HWIF                          = 0x31b
 	HDIO_UNREGISTER_HWIF                        = 0x32a
+	HID_MAX_DESCRIPTOR_SIZE                     = 0x1000
 	HOSTFS_SUPER_MAGIC                          = 0xc0ffee
 	HPFS_SUPER_MAGIC                            = 0xf995e849
 	HUGETLBFS_MAGIC                             = 0x958458f6
@@ -2735,6 +2741,9 @@ const (
 	Z3FOLD_MAGIC                                = 0x33
 	ZONEFS_MAGIC                                = 0x5a4f4653
 	ZSMALLOC_MAGIC                              = 0x58295829
+	_HIDIOCGRAWNAME_LEN                         = 0x80
+	_HIDIOCGRAWPHYS_LEN                         = 0x40
+	_HIDIOCGRAWUNIQ_LEN                         = 0x40
 )
 
 // Errors
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
index c8d5b324c7..e91a1a9579 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -Wall -Werror -static -I/tmp/include -m32
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build 386 && linux
 // +build 386,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
@@ -93,6 +94,9 @@ const (
 	F_SETOWN                         = 0x8
 	F_UNLCK                          = 0x2
 	F_WRLCK                          = 0x1
+	HIDIOCGRAWINFO                   = 0x80084803
+	HIDIOCGRDESC                     = 0x90044802
+	HIDIOCGRDESCSIZE                 = 0x80044801
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
@@ -485,6 +489,9 @@ const (
 	X86_FXSR_MAGIC                   = 0x0
 	XCASE                            = 0x4
 	XTABS                            = 0x1800
+	_HIDIOCGRAWNAME                  = 0x80804804
+	_HIDIOCGRAWPHYS                  = 0x80404805
+	_HIDIOCGRAWUNIQ                  = 0x80404808
 )
 
 // Errors
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
index e605c08b0e..a9cbac6443 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -Wall -Werror -static -I/tmp/include -m64
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build amd64 && linux
 // +build amd64,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
@@ -93,6 +94,9 @@ const (
 	F_SETOWN                         = 0x8
 	F_UNLCK                          = 0x2
 	F_WRLCK                          = 0x1
+	HIDIOCGRAWINFO                   = 0x80084803
+	HIDIOCGRDESC                     = 0x90044802
+	HIDIOCGRDESCSIZE                 = 0x80044801
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
@@ -485,6 +489,9 @@ const (
 	WORDSIZE                         = 0x40
 	XCASE                            = 0x4
 	XTABS                            = 0x1800
+	_HIDIOCGRAWNAME                  = 0x80804804
+	_HIDIOCGRAWPHYS                  = 0x80404805
+	_HIDIOCGRAWUNIQ                  = 0x80404808
 )
 
 // Errors
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
index 0279fa1abd..d74f3c15a1 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -Wall -Werror -static -I/tmp/include
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm && linux
 // +build arm,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
@@ -92,6 +93,9 @@ const (
 	F_SETOWN                         = 0x8
 	F_UNLCK                          = 0x2
 	F_WRLCK                          = 0x1
+	HIDIOCGRAWINFO                   = 0x80084803
+	HIDIOCGRDESC                     = 0x90044802
+	HIDIOCGRDESCSIZE                 = 0x80044801
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
@@ -491,6 +495,9 @@ const (
 	WORDSIZE                         = 0x20
 	XCASE                            = 0x4
 	XTABS                            = 0x1800
+	_HIDIOCGRAWNAME                  = 0x80804804
+	_HIDIOCGRAWPHYS                  = 0x80404805
+	_HIDIOCGRAWUNIQ                  = 0x80404808
 )
 
 // Errors
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
index 20c286a112..e1538995b4 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -Wall -Werror -static -I/tmp/include -fsigned-char
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm64 && linux
 // +build arm64,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
@@ -95,6 +96,9 @@ const (
 	F_SETOWN                         = 0x8
 	F_UNLCK                          = 0x2
 	F_WRLCK                          = 0x1
+	HIDIOCGRAWINFO                   = 0x80084803
+	HIDIOCGRDESC                     = 0x90044802
+	HIDIOCGRDESCSIZE                 = 0x80044801
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
@@ -482,6 +486,9 @@ const (
 	WORDSIZE                         = 0x40
 	XCASE                            = 0x4
 	XTABS                            = 0x1800
+	_HIDIOCGRAWNAME                  = 0x80804804
+	_HIDIOCGRAWPHYS                  = 0x80404805
+	_HIDIOCGRAWUNIQ                  = 0x80404808
 )
 
 // Errors
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
index 1785f33d66..5e8e71ff86 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -Wall -Werror -static -I/tmp/include
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build mips && linux
 // +build mips,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
@@ -92,6 +93,9 @@ const (
 	F_SETOWN                         = 0x18
 	F_UNLCK                          = 0x2
 	F_WRLCK                          = 0x1
+	HIDIOCGRAWINFO                   = 0x40084803
+	HIDIOCGRDESC                     = 0x50044802
+	HIDIOCGRDESCSIZE                 = 0x40044801
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x100
@@ -487,6 +491,9 @@ const (
 	WORDSIZE                         = 0x20
 	XCASE                            = 0x4
 	XTABS                            = 0x1800
+	_HIDIOCGRAWNAME                  = 0x40804804
+	_HIDIOCGRAWPHYS                  = 0x40404805
+	_HIDIOCGRAWUNIQ                  = 0x40404808
 )
 
 // Errors
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
index acb1ef1bf5..e670ee1481 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -Wall -Werror -static -I/tmp/include
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build mips64 && linux
 // +build mips64,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
@@ -92,6 +93,9 @@ const (
 	F_SETOWN                         = 0x18
 	F_UNLCK                          = 0x2
 	F_WRLCK                          = 0x1
+	HIDIOCGRAWINFO                   = 0x40084803
+	HIDIOCGRDESC                     = 0x50044802
+	HIDIOCGRDESCSIZE                 = 0x40044801
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x100
@@ -487,6 +491,9 @@ const (
 	WORDSIZE                         = 0x40
 	XCASE                            = 0x4
 	XTABS                            = 0x1800
+	_HIDIOCGRAWNAME                  = 0x40804804
+	_HIDIOCGRAWPHYS                  = 0x40404805
+	_HIDIOCGRAWUNIQ                  = 0x40404808
 )
 
 // Errors
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
index 468a4e68c7..dd11eacb81 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -Wall -Werror -static -I/tmp/include
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build mips64le && linux
 // +build mips64le,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
@@ -92,6 +93,9 @@ const (
 	F_SETOWN                         = 0x18
 	F_UNLCK                          = 0x2
 	F_WRLCK                          = 0x1
+	HIDIOCGRAWINFO                   = 0x40084803
+	HIDIOCGRDESC                     = 0x50044802
+	HIDIOCGRDESCSIZE                 = 0x40044801
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x100
@@ -487,6 +491,9 @@ const (
 	WORDSIZE                         = 0x40
 	XCASE                            = 0x4
 	XTABS                            = 0x1800
+	_HIDIOCGRAWNAME                  = 0x40804804
+	_HIDIOCGRAWPHYS                  = 0x40404805
+	_HIDIOCGRAWUNIQ                  = 0x40404808
 )
 
 // Errors
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
index 6c9c7f2c76..a0a5b22ae9 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -Wall -Werror -static -I/tmp/include
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build mipsle && linux
 // +build mipsle,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
@@ -92,6 +93,9 @@ const (
 	F_SETOWN                         = 0x18
 	F_UNLCK                          = 0x2
 	F_WRLCK                          = 0x1
+	HIDIOCGRAWINFO                   = 0x40084803
+	HIDIOCGRDESC                     = 0x50044802
+	HIDIOCGRDESCSIZE                 = 0x40044801
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x100
@@ -487,6 +491,9 @@ const (
 	WORDSIZE                         = 0x20
 	XCASE                            = 0x4
 	XTABS                            = 0x1800
+	_HIDIOCGRAWNAME                  = 0x40804804
+	_HIDIOCGRAWPHYS                  = 0x40404805
+	_HIDIOCGRAWUNIQ                  = 0x40404808
 )
 
 // Errors
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
index 8961206e5f..e60102f6a9 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -Wall -Werror -static -I/tmp/include
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build ppc64 && linux
 // +build ppc64,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
@@ -92,6 +93,9 @@ const (
 	F_SETOWN                         = 0x8
 	F_UNLCK                          = 0x2
 	F_WRLCK                          = 0x1
+	HIDIOCGRAWINFO                   = 0x40084803
+	HIDIOCGRDESC                     = 0x50044802
+	HIDIOCGRDESCSIZE                 = 0x40044801
 	HUPCL                            = 0x4000
 	ICANON                           = 0x100
 	IEXTEN                           = 0x400
@@ -547,6 +551,9 @@ const (
 	WORDSIZE                         = 0x40
 	XCASE                            = 0x4000
 	XTABS                            = 0xc00
+	_HIDIOCGRAWNAME                  = 0x40804804
+	_HIDIOCGRAWPHYS                  = 0x40404805
+	_HIDIOCGRAWUNIQ                  = 0x40404808
 )
 
 // Errors
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
index 6bcf79dc2e..838ff4ea6d 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -Wall -Werror -static -I/tmp/include
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build ppc64le && linux
 // +build ppc64le,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
@@ -92,6 +93,9 @@ const (
 	F_SETOWN                         = 0x8
 	F_UNLCK                          = 0x2
 	F_WRLCK                          = 0x1
+	HIDIOCGRAWINFO                   = 0x40084803
+	HIDIOCGRDESC                     = 0x50044802
+	HIDIOCGRDESCSIZE                 = 0x40044801
 	HUPCL                            = 0x4000
 	ICANON                           = 0x100
 	IEXTEN                           = 0x400
@@ -547,6 +551,9 @@ const (
 	WORDSIZE                         = 0x40
 	XCASE                            = 0x4000
 	XTABS                            = 0xc00
+	_HIDIOCGRAWNAME                  = 0x40804804
+	_HIDIOCGRAWPHYS                  = 0x40404805
+	_HIDIOCGRAWUNIQ                  = 0x40404808
 )
 
 // Errors
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
index e861d97f1c..7cc98f09c3 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -Wall -Werror -static -I/tmp/include
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build riscv64 && linux
 // +build riscv64,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
@@ -92,6 +93,9 @@ const (
 	F_SETOWN                         = 0x8
 	F_UNLCK                          = 0x2
 	F_WRLCK                          = 0x1
+	HIDIOCGRAWINFO                   = 0x80084803
+	HIDIOCGRDESC                     = 0x90044802
+	HIDIOCGRDESCSIZE                 = 0x80044801
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
@@ -472,6 +476,9 @@ const (
 	WORDSIZE                         = 0x40
 	XCASE                            = 0x4
 	XTABS                            = 0x1800
+	_HIDIOCGRAWNAME                  = 0x80804804
+	_HIDIOCGRAWPHYS                  = 0x80404805
+	_HIDIOCGRAWUNIQ                  = 0x80404808
 )
 
 // Errors
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
index d39278bee5..a508392d25 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -Wall -Werror -static -I/tmp/include -fsigned-char
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build s390x && linux
 // +build s390x,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
@@ -92,6 +93,9 @@ const (
 	F_SETOWN                         = 0x8
 	F_UNLCK                          = 0x2
 	F_WRLCK                          = 0x1
+	HIDIOCGRAWINFO                   = 0x80084803
+	HIDIOCGRDESC                     = 0x90044802
+	HIDIOCGRDESCSIZE                 = 0x80044801
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
@@ -545,6 +549,9 @@ const (
 	WORDSIZE                         = 0x40
 	XCASE                            = 0x4
 	XTABS                            = 0x1800
+	_HIDIOCGRAWNAME                  = 0x80804804
+	_HIDIOCGRAWPHYS                  = 0x80404805
+	_HIDIOCGRAWUNIQ                  = 0x80404808
 )
 
 // Errors
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
index 6a742fa7ee..d5e2dc94fa 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -Wall -Werror -static -I/tmp/include
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build sparc64 && linux
 // +build sparc64,linux
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
@@ -96,6 +97,9 @@ const (
 	F_SETOWN                         = 0x6
 	F_UNLCK                          = 0x3
 	F_WRLCK                          = 0x2
+	HIDIOCGRAWINFO                   = 0x40084803
+	HIDIOCGRDESC                     = 0x50044802
+	HIDIOCGRDESCSIZE                 = 0x40044801
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
@@ -535,6 +539,9 @@ const (
 	WORDSIZE                         = 0x40
 	XCASE                            = 0x4
 	XTABS                            = 0x1800
+	_HIDIOCGRAWNAME                  = 0x40804804
+	_HIDIOCGRAWPHYS                  = 0x40404805
+	_HIDIOCGRAWUNIQ                  = 0x40404808
 	__TIOCFLUSH                      = 0x80047410
 )
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_netbsd_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_netbsd_386.go
index 20f3a5799f..72f7420d20 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_netbsd_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_netbsd_386.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -m32
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build 386 && netbsd
 // +build 386,netbsd
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_netbsd_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_netbsd_amd64.go
index 90b8fcd29c..8d4eb0c080 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_netbsd_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_netbsd_amd64.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -m64
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build amd64 && netbsd
 // +build amd64,netbsd
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_netbsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_netbsd_arm.go
index c5c03993b6..9eef9749f6 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_netbsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_netbsd_arm.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -marm
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm && netbsd
 // +build arm,netbsd
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_netbsd_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_netbsd_arm64.go
index 14dd3c1d1e..3b62ba192c 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_netbsd_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_netbsd_arm64.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -m64
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm64 && netbsd
 // +build arm64,netbsd
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_386.go
index c865a10df4..593cc0feff 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_386.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -m32
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build 386 && openbsd
 // +build 386,openbsd
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_amd64.go
index 9db6b2fb6e..25cb609481 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_amd64.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -m64
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build amd64 && openbsd
 // +build amd64,openbsd
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_arm.go
index 7072526a64..a4e4c22314 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_arm.go
@@ -1,6 +1,7 @@
 // mkerrors.sh
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm && openbsd
 // +build arm,openbsd
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_arm64.go
index ac5efbe5ac..90de7dfc33 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_arm64.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -m64
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm64 && openbsd
 // +build arm64,openbsd
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_mips64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_mips64.go
index a74639a46f..f1154ff56f 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_mips64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_mips64.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -m64
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build mips64 && openbsd
 // +build mips64,openbsd
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_solaris_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_solaris_amd64.go
index 5312c36cc8..65fb2c5cd8 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_solaris_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_solaris_amd64.go
@@ -1,6 +1,7 @@
 // mkerrors.sh -m64
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build amd64 && solaris
 // +build amd64,solaris
 
 // Code generated by cmd/cgo -godefs; DO NOT EDIT.
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go
new file mode 100644
index 0000000000..4117ce08a5
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go
@@ -0,0 +1,831 @@
+// Copyright 2020 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.
+
+//go:build zos && s390x
+// +build zos,s390x
+
+// Hand edited based on zerrors_linux_s390x.go
+// TODO: auto-generate.
+
+package unix
+
+const (
+	BRKINT                          = 0x0001
+	CLOCK_MONOTONIC                 = 0x1
+	CLOCK_PROCESS_CPUTIME_ID        = 0x2
+	CLOCK_REALTIME                  = 0x0
+	CLOCK_THREAD_CPUTIME_ID         = 0x3
+	CS8                             = 0x0030
+	CSIZE                           = 0x0030
+	ECHO                            = 0x00000008
+	ECHONL                          = 0x00000001
+	FD_CLOEXEC                      = 0x01
+	FD_CLOFORK                      = 0x02
+	FNDELAY                         = 0x04
+	F_CLOSFD                        = 9
+	F_CONTROL_CVT                   = 13
+	F_DUPFD                         = 0
+	F_DUPFD2                        = 8
+	F_GETFD                         = 1
+	F_GETFL                         = 259
+	F_GETLK                         = 5
+	F_GETOWN                        = 10
+	F_OK                            = 0x0
+	F_RDLCK                         = 1
+	F_SETFD                         = 2
+	F_SETFL                         = 4
+	F_SETLK                         = 6
+	F_SETLKW                        = 7
+	F_SETOWN                        = 11
+	F_SETTAG                        = 12
+	F_UNLCK                         = 3
+	F_WRLCK                         = 2
+	FSTYPE_ZFS                      = 0xe9 //"Z"
+	FSTYPE_HFS                      = 0xc8 //"H"
+	FSTYPE_NFS                      = 0xd5 //"N"
+	FSTYPE_TFS                      = 0xe3 //"T"
+	FSTYPE_AUTOMOUNT                = 0xc1 //"A"
+	IP6F_MORE_FRAG                  = 0x0001
+	IP6F_OFF_MASK                   = 0xfff8
+	IP6F_RESERVED_MASK              = 0x0006
+	IP6OPT_JUMBO                    = 0xc2
+	IP6OPT_JUMBO_LEN                = 6
+	IP6OPT_MUTABLE                  = 0x20
+	IP6OPT_NSAP_ADDR                = 0xc3
+	IP6OPT_PAD1                     = 0x00
+	IP6OPT_PADN                     = 0x01
+	IP6OPT_ROUTER_ALERT             = 0x05
+	IP6OPT_TUNNEL_LIMIT             = 0x04
+	IP6OPT_TYPE_DISCARD             = 0x40
+	IP6OPT_TYPE_FORCEICMP           = 0x80
+	IP6OPT_TYPE_ICMP                = 0xc0
+	IP6OPT_TYPE_SKIP                = 0x00
+	IP6_ALERT_AN                    = 0x0002
+	IP6_ALERT_MLD                   = 0x0000
+	IP6_ALERT_RSVP                  = 0x0001
+	IPPORT_RESERVED                 = 1024
+	IPPORT_USERRESERVED             = 5000
+	IPPROTO_AH                      = 51
+	IPPROTO_DSTOPTS                 = 60
+	IPPROTO_EGP                     = 8
+	IPPROTO_ESP                     = 50
+	IPPROTO_FRAGMENT                = 44
+	IPPROTO_GGP                     = 2
+	IPPROTO_HOPOPTS                 = 0
+	IPPROTO_ICMP                    = 1
+	IPPROTO_ICMPV6                  = 58
+	IPPROTO_IDP                     = 22
+	IPPROTO_IP                      = 0
+	IPPROTO_IPV6                    = 41
+	IPPROTO_MAX                     = 256
+	IPPROTO_NONE                    = 59
+	IPPROTO_PUP                     = 12
+	IPPROTO_RAW                     = 255
+	IPPROTO_ROUTING                 = 43
+	IPPROTO_TCP                     = 6
+	IPPROTO_UDP                     = 17
+	IPV6_ADDR_PREFERENCES           = 32
+	IPV6_CHECKSUM                   = 19
+	IPV6_DONTFRAG                   = 29
+	IPV6_DSTOPTS                    = 23
+	IPV6_HOPLIMIT                   = 11
+	IPV6_HOPOPTS                    = 22
+	IPV6_JOIN_GROUP                 = 5
+	IPV6_LEAVE_GROUP                = 6
+	IPV6_MULTICAST_HOPS             = 9
+	IPV6_MULTICAST_IF               = 7
+	IPV6_MULTICAST_LOOP             = 4
+	IPV6_NEXTHOP                    = 20
+	IPV6_PATHMTU                    = 12
+	IPV6_PKTINFO                    = 13
+	IPV6_PREFER_SRC_CGA             = 0x10
+	IPV6_PREFER_SRC_COA             = 0x02
+	IPV6_PREFER_SRC_HOME            = 0x01
+	IPV6_PREFER_SRC_NONCGA          = 0x20
+	IPV6_PREFER_SRC_PUBLIC          = 0x08
+	IPV6_PREFER_SRC_TMP             = 0x04
+	IPV6_RECVDSTOPTS                = 28
+	IPV6_RECVHOPLIMIT               = 14
+	IPV6_RECVHOPOPTS                = 26
+	IPV6_RECVPATHMTU                = 16
+	IPV6_RECVPKTINFO                = 15
+	IPV6_RECVRTHDR                  = 25
+	IPV6_RECVTCLASS                 = 31
+	IPV6_RTHDR                      = 21
+	IPV6_RTHDRDSTOPTS               = 24
+	IPV6_RTHDR_TYPE_0               = 0
+	IPV6_TCLASS                     = 30
+	IPV6_UNICAST_HOPS               = 3
+	IPV6_USE_MIN_MTU                = 18
+	IPV6_V6ONLY                     = 10
+	IP_ADD_MEMBERSHIP               = 5
+	IP_ADD_SOURCE_MEMBERSHIP        = 12
+	IP_BLOCK_SOURCE                 = 10
+	IP_DEFAULT_MULTICAST_LOOP       = 1
+	IP_DEFAULT_MULTICAST_TTL        = 1
+	IP_DROP_MEMBERSHIP              = 6
+	IP_DROP_SOURCE_MEMBERSHIP       = 13
+	IP_MAX_MEMBERSHIPS              = 20
+	IP_MULTICAST_IF                 = 7
+	IP_MULTICAST_LOOP               = 4
+	IP_MULTICAST_TTL                = 3
+	IP_OPTIONS                      = 1
+	IP_PKTINFO                      = 101
+	IP_RECVPKTINFO                  = 102
+	IP_TOS                          = 2
+	IP_TTL                          = 3
+	IP_UNBLOCK_SOURCE               = 11
+	ICANON                          = 0x0010
+	ICRNL                           = 0x0002
+	IEXTEN                          = 0x0020
+	IGNBRK                          = 0x0004
+	IGNCR                           = 0x0008
+	INLCR                           = 0x0020
+	ISIG                            = 0x0040
+	ISTRIP                          = 0x0080
+	IXON                            = 0x0200
+	IXOFF                           = 0x0100
+	LOCK_SH                         = 0x1 // Not exist on zOS
+	LOCK_EX                         = 0x2 // Not exist on zOS
+	LOCK_NB                         = 0x4 // Not exist on zOS
+	LOCK_UN                         = 0x8 // Not exist on zOS
+	POLLIN                          = 0x0003
+	POLLOUT                         = 0x0004
+	POLLPRI                         = 0x0010
+	POLLERR                         = 0x0020
+	POLLHUP                         = 0x0040
+	POLLNVAL                        = 0x0080
+	PROT_READ                       = 0x1 // mmap - page can be read
+	PROT_WRITE                      = 0x2 // page can be written
+	PROT_NONE                       = 0x4 // can't be accessed
+	PROT_EXEC                       = 0x8 // can be executed
+	MAP_PRIVATE                     = 0x1 // changes are private
+	MAP_SHARED                      = 0x2 // changes are shared
+	MAP_FIXED                       = 0x4 // place exactly
+	MS_SYNC                         = 0x1 // msync - synchronous writes
+	MS_ASYNC                        = 0x2 // asynchronous writes
+	MS_INVALIDATE                   = 0x4 // invalidate mappings
+	MTM_RDONLY                      = 0x80000000
+	MTM_RDWR                        = 0x40000000
+	MTM_UMOUNT                      = 0x10000000
+	MTM_IMMED                       = 0x08000000
+	MTM_FORCE                       = 0x04000000
+	MTM_DRAIN                       = 0x02000000
+	MTM_RESET                       = 0x01000000
+	MTM_SAMEMODE                    = 0x00100000
+	MTM_UNQSEFORCE                  = 0x00040000
+	MTM_NOSUID                      = 0x00000400
+	MTM_SYNCHONLY                   = 0x00000200
+	MTM_REMOUNT                     = 0x00000100
+	MTM_NOSECURITY                  = 0x00000080
+	O_ACCMODE                       = 0x03
+	O_APPEND                        = 0x08
+	O_ASYNCSIG                      = 0x0200
+	O_CREAT                         = 0x80
+	O_EXCL                          = 0x40
+	O_GETFL                         = 0x0F
+	O_LARGEFILE                     = 0x0400
+	O_NONBLOCK                      = 0x04
+	O_RDONLY                        = 0x02
+	O_RDWR                          = 0x03
+	O_SYNC                          = 0x0100
+	O_TRUNC                         = 0x10
+	O_WRONLY                        = 0x01
+	O_NOCTTY                        = 0x20
+	OPOST                           = 0x0001
+	ONLCR                           = 0x0004
+	PARENB                          = 0x0200
+	PARMRK                          = 0x0400
+	QUERYCVT                        = 3
+	RUSAGE_CHILDREN                 = -0x1
+	RUSAGE_SELF                     = 0x0 // RUSAGE_THREAD unsupported on z/OS
+	SEEK_CUR                        = 1
+	SEEK_END                        = 2
+	SEEK_SET                        = 0
+	SETAUTOCVTALL                   = 5
+	SETAUTOCVTON                    = 2
+	SETCVTALL                       = 4
+	SETCVTOFF                       = 0
+	SETCVTON                        = 1
+	AF_APPLETALK                    = 16
+	AF_CCITT                        = 10
+	AF_CHAOS                        = 5
+	AF_DATAKIT                      = 9
+	AF_DLI                          = 13
+	AF_ECMA                         = 8
+	AF_HYLINK                       = 15
+	AF_IMPLINK                      = 3
+	AF_INET                         = 2
+	AF_INET6                        = 19
+	AF_INTF                         = 20
+	AF_IUCV                         = 17
+	AF_LAT                          = 14
+	AF_LINK                         = 18
+	AF_MAX                          = 30
+	AF_NBS                          = 7
+	AF_NDD                          = 23
+	AF_NETWARE                      = 22
+	AF_NS                           = 6
+	AF_PUP                          = 4
+	AF_RIF                          = 21
+	AF_ROUTE                        = 20
+	AF_SNA                          = 11
+	AF_UNIX                         = 1
+	AF_UNSPEC                       = 0
+	IBMTCP_IMAGE                    = 1
+	MSG_ACK_EXPECTED                = 0x10
+	MSG_ACK_GEN                     = 0x40
+	MSG_ACK_TIMEOUT                 = 0x20
+	MSG_CONNTERM                    = 0x80
+	MSG_CTRUNC                      = 0x20
+	MSG_DONTROUTE                   = 0x4
+	MSG_EOF                         = 0x8000
+	MSG_EOR                         = 0x8
+	MSG_MAXIOVLEN                   = 16
+	MSG_NONBLOCK                    = 0x4000
+	MSG_OOB                         = 0x1
+	MSG_PEEK                        = 0x2
+	MSG_TRUNC                       = 0x10
+	MSG_WAITALL                     = 0x40
+	PRIO_PROCESS                    = 1
+	PRIO_PGRP                       = 2
+	PRIO_USER                       = 3
+	RLIMIT_CPU                      = 0
+	RLIMIT_FSIZE                    = 1
+	RLIMIT_DATA                     = 2
+	RLIMIT_STACK                    = 3
+	RLIMIT_CORE                     = 4
+	RLIMIT_AS                       = 5
+	RLIMIT_NOFILE                   = 6
+	RLIMIT_MEMLIMIT                 = 7
+	RLIM_INFINITY                   = 2147483647
+	SCM_RIGHTS                      = 0x01
+	SF_CLOSE                        = 0x00000002
+	SF_REUSE                        = 0x00000001
+	SHUT_RD                         = 0
+	SHUT_RDWR                       = 2
+	SHUT_WR                         = 1
+	SOCK_CONN_DGRAM                 = 6
+	SOCK_DGRAM                      = 2
+	SOCK_RAW                        = 3
+	SOCK_RDM                        = 4
+	SOCK_SEQPACKET                  = 5
+	SOCK_STREAM                     = 1
+	SOL_SOCKET                      = 0xffff
+	SOMAXCONN                       = 10
+	SO_ACCEPTCONN                   = 0x0002
+	SO_ACCEPTECONNABORTED           = 0x0006
+	SO_ACKNOW                       = 0x7700
+	SO_BROADCAST                    = 0x0020
+	SO_BULKMODE                     = 0x8000
+	SO_CKSUMRECV                    = 0x0800
+	SO_CLOSE                        = 0x01
+	SO_CLUSTERCONNTYPE              = 0x00004001
+	SO_CLUSTERCONNTYPE_INTERNAL     = 8
+	SO_CLUSTERCONNTYPE_NOCONN       = 0
+	SO_CLUSTERCONNTYPE_NONE         = 1
+	SO_CLUSTERCONNTYPE_SAME_CLUSTER = 2
+	SO_CLUSTERCONNTYPE_SAME_IMAGE   = 4
+	SO_DEBUG                        = 0x0001
+	SO_DONTROUTE                    = 0x0010
+	SO_ERROR                        = 0x1007
+	SO_IGNOREINCOMINGPUSH           = 0x1
+	SO_IGNORESOURCEVIPA             = 0x0002
+	SO_KEEPALIVE                    = 0x0008
+	SO_LINGER                       = 0x0080
+	SO_NONBLOCKLOCAL                = 0x8001
+	SO_NOREUSEADDR                  = 0x1000
+	SO_OOBINLINE                    = 0x0100
+	SO_OPTACK                       = 0x8004
+	SO_OPTMSS                       = 0x8003
+	SO_RCVBUF                       = 0x1002
+	SO_RCVLOWAT                     = 0x1004
+	SO_RCVTIMEO                     = 0x1006
+	SO_REUSEADDR                    = 0x0004
+	SO_REUSEPORT                    = 0x0200
+	SO_SECINFO                      = 0x00004002
+	SO_SET                          = 0x0200
+	SO_SNDBUF                       = 0x1001
+	SO_SNDLOWAT                     = 0x1003
+	SO_SNDTIMEO                     = 0x1005
+	SO_TYPE                         = 0x1008
+	SO_UNSET                        = 0x0400
+	SO_USELOOPBACK                  = 0x0040
+	SO_USE_IFBUFS                   = 0x0400
+	S_ISUID                         = 0x0800
+	S_ISGID                         = 0x0400
+	S_ISVTX                         = 0x0200
+	S_IRUSR                         = 0x0100
+	S_IWUSR                         = 0x0080
+	S_IXUSR                         = 0x0040
+	S_IRWXU                         = 0x01C0
+	S_IRGRP                         = 0x0020
+	S_IWGRP                         = 0x0010
+	S_IXGRP                         = 0x0008
+	S_IRWXG                         = 0x0038
+	S_IROTH                         = 0x0004
+	S_IWOTH                         = 0x0002
+	S_IXOTH                         = 0x0001
+	S_IRWXO                         = 0x0007
+	S_IREAD                         = S_IRUSR
+	S_IWRITE                        = S_IWUSR
+	S_IEXEC                         = S_IXUSR
+	S_IFDIR                         = 0x01000000
+	S_IFCHR                         = 0x02000000
+	S_IFREG                         = 0x03000000
+	S_IFFIFO                        = 0x04000000
+	S_IFIFO                         = 0x04000000
+	S_IFLNK                         = 0x05000000
+	S_IFBLK                         = 0x06000000
+	S_IFSOCK                        = 0x07000000
+	S_IFVMEXTL                      = 0xFE000000
+	S_IFVMEXTL_EXEC                 = 0x00010000
+	S_IFVMEXTL_DATA                 = 0x00020000
+	S_IFVMEXTL_MEL                  = 0x00030000
+	S_IFEXTL                        = 0x00000001
+	S_IFPROGCTL                     = 0x00000002
+	S_IFAPFCTL                      = 0x00000004
+	S_IFNOSHARE                     = 0x00000008
+	S_IFSHARELIB                    = 0x00000010
+	S_IFMT                          = 0xFF000000
+	S_IFMST                         = 0x00FF0000
+	TCP_KEEPALIVE                   = 0x8
+	TCP_NODELAY                     = 0x1
+	TIOCGWINSZ                      = 0x4008a368
+	TIOCSWINSZ                      = 0x8008a367
+	TIOCSBRK                        = 0x2000a77b
+	TIOCCBRK                        = 0x2000a77a
+	TIOCSTI                         = 0x8001a772
+	TIOCGPGRP                       = 0x4004a777 // _IOR(167, 119, int)
+	TCSANOW                         = 0
+	TCSETS                          = 0 // equivalent to TCSANOW for tcsetattr
+	TCSADRAIN                       = 1
+	TCSETSW                         = 1 // equivalent to TCSADRAIN for tcsetattr
+	TCSAFLUSH                       = 2
+	TCSETSF                         = 2 // equivalent to TCSAFLUSH for tcsetattr
+	TCGETS                          = 3 // not defined in ioctl.h -- zos golang only
+	TCIFLUSH                        = 0
+	TCOFLUSH                        = 1
+	TCIOFLUSH                       = 2
+	TCOOFF                          = 0
+	TCOON                           = 1
+	TCIOFF                          = 2
+	TCION                           = 3
+	TIOCSPGRP                       = 0x8004a776
+	TIOCNOTTY                       = 0x2000a771
+	TIOCEXCL                        = 0x2000a70d
+	TIOCNXCL                        = 0x2000a70e
+	TIOCGETD                        = 0x4004a700
+	TIOCSETD                        = 0x8004a701
+	TIOCPKT                         = 0x8004a770
+	TIOCSTOP                        = 0x2000a76f
+	TIOCSTART                       = 0x2000a76e
+	TIOCUCNTL                       = 0x8004a766
+	TIOCREMOTE                      = 0x8004a769
+	TIOCMGET                        = 0x4004a76a
+	TIOCMSET                        = 0x8004a76d
+	TIOCMBIC                        = 0x8004a76b
+	TIOCMBIS                        = 0x8004a76c
+	VINTR                           = 0
+	VQUIT                           = 1
+	VERASE                          = 2
+	VKILL                           = 3
+	VEOF                            = 4
+	VEOL                            = 5
+	VMIN                            = 6
+	VSTART                          = 7
+	VSTOP                           = 8
+	VSUSP                           = 9
+	VTIME                           = 10
+	WCONTINUED                      = 0x4
+	WNOHANG                         = 0x1
+	WUNTRACED                       = 0x2
+	_BPX_SWAP                       = 1
+	_BPX_NONSWAP                    = 2
+	MCL_CURRENT                     = 1  // for Linux compatibility -- no zos semantics
+	MCL_FUTURE                      = 2  // for Linux compatibility -- no zos semantics
+	MCL_ONFAULT                     = 3  // for Linux compatibility -- no zos semantics
+	MADV_NORMAL                     = 0  // for Linux compatibility -- no zos semantics
+	MADV_RANDOM                     = 1  // for Linux compatibility -- no zos semantics
+	MADV_SEQUENTIAL                 = 2  // for Linux compatibility -- no zos semantics
+	MADV_WILLNEED                   = 3  // for Linux compatibility -- no zos semantics
+	MADV_REMOVE                     = 4  // for Linux compatibility -- no zos semantics
+	MADV_DONTFORK                   = 5  // for Linux compatibility -- no zos semantics
+	MADV_DOFORK                     = 6  // for Linux compatibility -- no zos semantics
+	MADV_HWPOISON                   = 7  // for Linux compatibility -- no zos semantics
+	MADV_MERGEABLE                  = 8  // for Linux compatibility -- no zos semantics
+	MADV_UNMERGEABLE                = 9  // for Linux compatibility -- no zos semantics
+	MADV_SOFT_OFFLINE               = 10 // for Linux compatibility -- no zos semantics
+	MADV_HUGEPAGE                   = 11 // for Linux compatibility -- no zos semantics
+	MADV_NOHUGEPAGE                 = 12 // for Linux compatibility -- no zos semantics
+	MADV_DONTDUMP                   = 13 // for Linux compatibility -- no zos semantics
+	MADV_DODUMP                     = 14 // for Linux compatibility -- no zos semantics
+	MADV_FREE                       = 15 // for Linux compatibility -- no zos semantics
+	MADV_WIPEONFORK                 = 16 // for Linux compatibility -- no zos semantics
+	MADV_KEEPONFORK                 = 17 // for Linux compatibility -- no zos semantics
+	AT_SYMLINK_NOFOLLOW             = 1  // for Unix  compatibility -- no zos semantics
+	AT_FDCWD                        = 2  // for Unix  compatibility -- no zos semantics
+)
+
+const (
+	EDOM               = Errno(1)
+	ERANGE             = Errno(2)
+	EACCES             = Errno(111)
+	EAGAIN             = Errno(112)
+	EBADF              = Errno(113)
+	EBUSY              = Errno(114)
+	ECHILD             = Errno(115)
+	EDEADLK            = Errno(116)
+	EEXIST             = Errno(117)
+	EFAULT             = Errno(118)
+	EFBIG              = Errno(119)
+	EINTR              = Errno(120)
+	EINVAL             = Errno(121)
+	EIO                = Errno(122)
+	EISDIR             = Errno(123)
+	EMFILE             = Errno(124)
+	EMLINK             = Errno(125)
+	ENAMETOOLONG       = Errno(126)
+	ENFILE             = Errno(127)
+	ENODEV             = Errno(128)
+	ENOENT             = Errno(129)
+	ENOEXEC            = Errno(130)
+	ENOLCK             = Errno(131)
+	ENOMEM             = Errno(132)
+	ENOSPC             = Errno(133)
+	ENOSYS             = Errno(134)
+	ENOTDIR            = Errno(135)
+	ENOTEMPTY          = Errno(136)
+	ENOTTY             = Errno(137)
+	ENXIO              = Errno(138)
+	EPERM              = Errno(139)
+	EPIPE              = Errno(140)
+	EROFS              = Errno(141)
+	ESPIPE             = Errno(142)
+	ESRCH              = Errno(143)
+	EXDEV              = Errno(144)
+	E2BIG              = Errno(145)
+	ELOOP              = Errno(146)
+	EILSEQ             = Errno(147)
+	ENODATA            = Errno(148)
+	EOVERFLOW          = Errno(149)
+	EMVSNOTUP          = Errno(150)
+	ECMSSTORAGE        = Errno(151)
+	EMVSDYNALC         = Errno(151)
+	EMVSCVAF           = Errno(152)
+	EMVSCATLG          = Errno(153)
+	ECMSINITIAL        = Errno(156)
+	EMVSINITIAL        = Errno(156)
+	ECMSERR            = Errno(157)
+	EMVSERR            = Errno(157)
+	EMVSPARM           = Errno(158)
+	ECMSPFSFILE        = Errno(159)
+	EMVSPFSFILE        = Errno(159)
+	EMVSBADCHAR        = Errno(160)
+	ECMSPFSPERM        = Errno(162)
+	EMVSPFSPERM        = Errno(162)
+	EMVSSAFEXTRERR     = Errno(163)
+	EMVSSAF2ERR        = Errno(164)
+	EMVSTODNOTSET      = Errno(165)
+	EMVSPATHOPTS       = Errno(166)
+	EMVSNORTL          = Errno(167)
+	EMVSEXPIRE         = Errno(168)
+	EMVSPASSWORD       = Errno(169)
+	EMVSWLMERROR       = Errno(170)
+	EMVSCPLERROR       = Errno(171)
+	EMVSARMERROR       = Errno(172)
+	ELENOFORK          = Errno(200)
+	ELEMSGERR          = Errno(201)
+	EFPMASKINV         = Errno(202)
+	EFPMODEINV         = Errno(203)
+	EBUFLEN            = Errno(227)
+	EEXTLINK           = Errno(228)
+	ENODD              = Errno(229)
+	ECMSESMERR         = Errno(230)
+	ECPERR             = Errno(231)
+	ELEMULTITHREAD     = Errno(232)
+	ELEFENCE           = Errno(244)
+	EBADDATA           = Errno(245)
+	EUNKNOWN           = Errno(246)
+	ENOTSUP            = Errno(247)
+	EBADNAME           = Errno(248)
+	ENOTSAFE           = Errno(249)
+	ELEMULTITHREADFORK = Errno(257)
+	ECUNNOENV          = Errno(258)
+	ECUNNOCONV         = Errno(259)
+	ECUNNOTALIGNED     = Errno(260)
+	ECUNERR            = Errno(262)
+	EIBMBADCALL        = Errno(1000)
+	EIBMBADPARM        = Errno(1001)
+	EIBMSOCKOUTOFRANGE = Errno(1002)
+	EIBMSOCKINUSE      = Errno(1003)
+	EIBMIUCVERR        = Errno(1004)
+	EOFFLOADboxERROR   = Errno(1005)
+	EOFFLOADboxRESTART = Errno(1006)
+	EOFFLOADboxDOWN    = Errno(1007)
+	EIBMCONFLICT       = Errno(1008)
+	EIBMCANCELLED      = Errno(1009)
+	EIBMBADTCPNAME     = Errno(1011)
+	ENOTBLK            = Errno(1100)
+	ETXTBSY            = Errno(1101)
+	EWOULDBLOCK        = Errno(1102)
+	EINPROGRESS        = Errno(1103)
+	EALREADY           = Errno(1104)
+	ENOTSOCK           = Errno(1105)
+	EDESTADDRREQ       = Errno(1106)
+	EMSGSIZE           = Errno(1107)
+	EPROTOTYPE         = Errno(1108)
+	ENOPROTOOPT        = Errno(1109)
+	EPROTONOSUPPORT    = Errno(1110)
+	ESOCKTNOSUPPORT    = Errno(1111)
+	EOPNOTSUPP         = Errno(1112)
+	EPFNOSUPPORT       = Errno(1113)
+	EAFNOSUPPORT       = Errno(1114)
+	EADDRINUSE         = Errno(1115)
+	EADDRNOTAVAIL      = Errno(1116)
+	ENETDOWN           = Errno(1117)
+	ENETUNREACH        = Errno(1118)
+	ENETRESET          = Errno(1119)
+	ECONNABORTED       = Errno(1120)
+	ECONNRESET         = Errno(1121)
+	ENOBUFS            = Errno(1122)
+	EISCONN            = Errno(1123)
+	ENOTCONN           = Errno(1124)
+	ESHUTDOWN          = Errno(1125)
+	ETOOMANYREFS       = Errno(1126)
+	ETIMEDOUT          = Errno(1127)
+	ECONNREFUSED       = Errno(1128)
+	EHOSTDOWN          = Errno(1129)
+	EHOSTUNREACH       = Errno(1130)
+	EPROCLIM           = Errno(1131)
+	EUSERS             = Errno(1132)
+	EDQUOT             = Errno(1133)
+	ESTALE             = Errno(1134)
+	EREMOTE            = Errno(1135)
+	ENOSTR             = Errno(1136)
+	ETIME              = Errno(1137)
+	ENOSR              = Errno(1138)
+	ENOMSG             = Errno(1139)
+	EBADMSG            = Errno(1140)
+	EIDRM              = Errno(1141)
+	ENONET             = Errno(1142)
+	ERREMOTE           = Errno(1143)
+	ENOLINK            = Errno(1144)
+	EADV               = Errno(1145)
+	ESRMNT             = Errno(1146)
+	ECOMM              = Errno(1147)
+	EPROTO             = Errno(1148)
+	EMULTIHOP          = Errno(1149)
+	EDOTDOT            = Errno(1150)
+	EREMCHG            = Errno(1151)
+	ECANCELED          = Errno(1152)
+	EINTRNODATA        = Errno(1159)
+	ENOREUSE           = Errno(1160)
+	ENOMOVE            = Errno(1161)
+)
+
+// Signals
+const (
+	SIGHUP    = Signal(1)
+	SIGINT    = Signal(2)
+	SIGABRT   = Signal(3)
+	SIGILL    = Signal(4)
+	SIGPOLL   = Signal(5)
+	SIGURG    = Signal(6)
+	SIGSTOP   = Signal(7)
+	SIGFPE    = Signal(8)
+	SIGKILL   = Signal(9)
+	SIGBUS    = Signal(10)
+	SIGSEGV   = Signal(11)
+	SIGSYS    = Signal(12)
+	SIGPIPE   = Signal(13)
+	SIGALRM   = Signal(14)
+	SIGTERM   = Signal(15)
+	SIGUSR1   = Signal(16)
+	SIGUSR2   = Signal(17)
+	SIGABND   = Signal(18)
+	SIGCONT   = Signal(19)
+	SIGCHLD   = Signal(20)
+	SIGTTIN   = Signal(21)
+	SIGTTOU   = Signal(22)
+	SIGIO     = Signal(23)
+	SIGQUIT   = Signal(24)
+	SIGTSTP   = Signal(25)
+	SIGTRAP   = Signal(26)
+	SIGIOERR  = Signal(27)
+	SIGWINCH  = Signal(28)
+	SIGXCPU   = Signal(29)
+	SIGXFSZ   = Signal(30)
+	SIGVTALRM = Signal(31)
+	SIGPROF   = Signal(32)
+	SIGDANGER = Signal(33)
+	SIGTHSTOP = Signal(34)
+	SIGTHCONT = Signal(35)
+	SIGTRACE  = Signal(37)
+	SIGDCE    = Signal(38)
+	SIGDUMP   = Signal(39)
+)
+
+// Error table
+var errorList = [...]struct {
+	num  Errno
+	name string
+	desc string
+}{
+	{1, "EDC5001I", "A domain error occurred."},
+	{2, "EDC5002I", "A range error occurred."},
+	{111, "EDC5111I", "Permission denied."},
+	{112, "EDC5112I", "Resource temporarily unavailable."},
+	{113, "EDC5113I", "Bad file descriptor."},
+	{114, "EDC5114I", "Resource busy."},
+	{115, "EDC5115I", "No child processes."},
+	{116, "EDC5116I", "Resource deadlock avoided."},
+	{117, "EDC5117I", "File exists."},
+	{118, "EDC5118I", "Incorrect address."},
+	{119, "EDC5119I", "File too large."},
+	{120, "EDC5120I", "Interrupted function call."},
+	{121, "EDC5121I", "Invalid argument."},
+	{122, "EDC5122I", "Input/output error."},
+	{123, "EDC5123I", "Is a directory."},
+	{124, "EDC5124I", "Too many open files."},
+	{125, "EDC5125I", "Too many links."},
+	{126, "EDC5126I", "Filename too long."},
+	{127, "EDC5127I", "Too many open files in system."},
+	{128, "EDC5128I", "No such device."},
+	{129, "EDC5129I", "No such file or directory."},
+	{130, "EDC5130I", "Exec format error."},
+	{131, "EDC5131I", "No locks available."},
+	{132, "EDC5132I", "Not enough memory."},
+	{133, "EDC5133I", "No space left on device."},
+	{134, "EDC5134I", "Function not implemented."},
+	{135, "EDC5135I", "Not a directory."},
+	{136, "EDC5136I", "Directory not empty."},
+	{137, "EDC5137I", "Inappropriate I/O control operation."},
+	{138, "EDC5138I", "No such device or address."},
+	{139, "EDC5139I", "Operation not permitted."},
+	{140, "EDC5140I", "Broken pipe."},
+	{141, "EDC5141I", "Read-only file system."},
+	{142, "EDC5142I", "Invalid seek."},
+	{143, "EDC5143I", "No such process."},
+	{144, "EDC5144I", "Improper link."},
+	{145, "EDC5145I", "The parameter list is too long, or the message to receive was too large for the buffer."},
+	{146, "EDC5146I", "Too many levels of symbolic links."},
+	{147, "EDC5147I", "Illegal byte sequence."},
+	{148, "", ""},
+	{149, "EDC5149I", "Value Overflow Error."},
+	{150, "EDC5150I", "UNIX System Services is not active."},
+	{151, "EDC5151I", "Dynamic allocation error."},
+	{152, "EDC5152I", "Common VTOC access facility (CVAF) error."},
+	{153, "EDC5153I", "Catalog obtain error."},
+	{156, "EDC5156I", "Process initialization error."},
+	{157, "EDC5157I", "An internal error has occurred."},
+	{158, "EDC5158I", "Bad parameters were passed to the service."},
+	{159, "EDC5159I", "The Physical File System encountered a permanent file error."},
+	{160, "EDC5160I", "Bad character in environment variable name."},
+	{162, "EDC5162I", "The Physical File System encountered a system error."},
+	{163, "EDC5163I", "SAF/RACF extract error."},
+	{164, "EDC5164I", "SAF/RACF error."},
+	{165, "EDC5165I", "System TOD clock not set."},
+	{166, "EDC5166I", "Access mode argument on function call conflicts with PATHOPTS parameter on JCL DD statement."},
+	{167, "EDC5167I", "Access to the UNIX System Services version of the C RTL is denied."},
+	{168, "EDC5168I", "Password has expired."},
+	{169, "EDC5169I", "Password is invalid."},
+	{170, "EDC5170I", "An error was encountered with WLM."},
+	{171, "EDC5171I", "An error was encountered with CPL."},
+	{172, "EDC5172I", "An error was encountered with Application Response Measurement (ARM) component."},
+	{200, "EDC5200I", "The application contains a Language Environment member language that cannot tolerate a fork()."},
+	{201, "EDC5201I", "The Language Environment message file was not found in the hierarchical file system."},
+	{202, "EDC5202E", "DLL facilities are not supported under SPC environment."},
+	{203, "EDC5203E", "DLL facilities are not supported under POSIX environment."},
+	{227, "EDC5227I", "Buffer is not long enough to contain a path definition"},
+	{228, "EDC5228I", "The file referred to is an external link"},
+	{229, "EDC5229I", "No path definition for ddname in effect"},
+	{230, "EDC5230I", "ESM error."},
+	{231, "EDC5231I", "CP or the external security manager had an error"},
+	{232, "EDC5232I", "The function failed because it was invoked from a multithread environment."},
+	{244, "EDC5244I", "The program, module or DLL is not supported in this environment."},
+	{245, "EDC5245I", "Data is not valid."},
+	{246, "EDC5246I", "Unknown system state."},
+	{247, "EDC5247I", "Operation not supported."},
+	{248, "EDC5248I", "The object name specified is not correct."},
+	{249, "EDC5249I", "The function is not allowed."},
+	{257, "EDC5257I", "Function cannot be called in the child process of a fork() from a multithreaded process until exec() is called."},
+	{258, "EDC5258I", "A CUN_RS_NO_UNI_ENV error was issued by Unicode Services."},
+	{259, "EDC5259I", "A CUN_RS_NO_CONVERSION error was issued by Unicode Services."},
+	{260, "EDC5260I", "A CUN_RS_TABLE_NOT_ALIGNED error was issued by Unicode Services."},
+	{262, "EDC5262I", "An iconv() function encountered an unexpected error while using Unicode Services."},
+	{1000, "EDC8000I", "A bad socket-call constant was found in the IUCV header."},
+	{1001, "EDC8001I", "An error was found in the IUCV header."},
+	{1002, "EDC8002I", "A socket descriptor is out of range."},
+	{1003, "EDC8003I", "A socket descriptor is in use."},
+	{1004, "EDC8004I", "Request failed because of an IUCV error."},
+	{1005, "EDC8005I", "Offload box error."},
+	{1006, "EDC8006I", "Offload box restarted."},
+	{1007, "EDC8007I", "Offload box down."},
+	{1008, "EDC8008I", "Already a conflicting call outstanding on socket."},
+	{1009, "EDC8009I", "Request cancelled using a SOCKcallCANCEL request."},
+	{1011, "EDC8011I", "A name of a PFS was specified that either is not configured or is not a Sockets PFS."},
+	{1100, "EDC8100I", "Block device required."},
+	{1101, "EDC8101I", "Text file busy."},
+	{1102, "EDC8102I", "Operation would block."},
+	{1103, "EDC8103I", "Operation now in progress."},
+	{1104, "EDC8104I", "Connection already in progress."},
+	{1105, "EDC8105I", "Socket operation on non-socket."},
+	{1106, "EDC8106I", "Destination address required."},
+	{1107, "EDC8107I", "Message too long."},
+	{1108, "EDC8108I", "Protocol wrong type for socket."},
+	{1109, "EDC8109I", "Protocol not available."},
+	{1110, "EDC8110I", "Protocol not supported."},
+	{1111, "EDC8111I", "Socket type not supported."},
+	{1112, "EDC8112I", "Operation not supported on socket."},
+	{1113, "EDC8113I", "Protocol family not supported."},
+	{1114, "EDC8114I", "Address family not supported."},
+	{1115, "EDC8115I", "Address already in use."},
+	{1116, "EDC8116I", "Address not available."},
+	{1117, "EDC8117I", "Network is down."},
+	{1118, "EDC8118I", "Network is unreachable."},
+	{1119, "EDC8119I", "Network dropped connection on reset."},
+	{1120, "EDC8120I", "Connection ended abnormally."},
+	{1121, "EDC8121I", "Connection reset."},
+	{1122, "EDC8122I", "No buffer space available."},
+	{1123, "EDC8123I", "Socket already connected."},
+	{1124, "EDC8124I", "Socket not connected."},
+	{1125, "EDC8125I", "Can't send after socket shutdown."},
+	{1126, "EDC8126I", "Too many references; can't splice."},
+	{1127, "EDC8127I", "Connection timed out."},
+	{1128, "EDC8128I", "Connection refused."},
+	{1129, "EDC8129I", "Host is not available."},
+	{1130, "EDC8130I", "Host cannot be reached."},
+	{1131, "EDC8131I", "Too many processes."},
+	{1132, "EDC8132I", "Too many users."},
+	{1133, "EDC8133I", "Disk quota exceeded."},
+	{1134, "EDC8134I", "Stale file handle."},
+	{1135, "", ""},
+	{1136, "EDC8136I", "File is not a STREAM."},
+	{1137, "EDC8137I", "STREAMS ioctl() timeout."},
+	{1138, "EDC8138I", "No STREAMS resources."},
+	{1139, "EDC8139I", "The message identified by set_id and msg_id is not in the message catalog."},
+	{1140, "EDC8140I", "Bad message."},
+	{1141, "EDC8141I", "Identifier removed."},
+	{1142, "", ""},
+	{1143, "", ""},
+	{1144, "EDC8144I", "The link has been severed."},
+	{1145, "", ""},
+	{1146, "", ""},
+	{1147, "", ""},
+	{1148, "EDC8148I", "Protocol error."},
+	{1149, "EDC8149I", "Multihop not allowed."},
+	{1150, "", ""},
+	{1151, "", ""},
+	{1152, "EDC8152I", "The asynchronous I/O request has been canceled."},
+	{1159, "EDC8159I", "Function call was interrupted before any data was received."},
+	{1160, "EDC8160I", "Socket reuse is not supported."},
+	{1161, "EDC8161I", "The file system cannot currently be moved."},
+}
+
+// Signal table
+var signalList = [...]struct {
+	num  Signal
+	name string
+	desc string
+}{
+	{1, "SIGHUP", "hangup"},
+	{2, "SIGINT", "interrupt"},
+	{3, "SIGABT", "aborted"},
+	{4, "SIGILL", "illegal instruction"},
+	{5, "SIGPOLL", "pollable event"},
+	{6, "SIGURG", "urgent I/O condition"},
+	{7, "SIGSTOP", "stop process"},
+	{8, "SIGFPE", "floating point exception"},
+	{9, "SIGKILL", "killed"},
+	{10, "SIGBUS", "bus error"},
+	{11, "SIGSEGV", "segmentation fault"},
+	{12, "SIGSYS", "bad argument to routine"},
+	{13, "SIGPIPE", "broken pipe"},
+	{14, "SIGALRM", "alarm clock"},
+	{15, "SIGTERM", "terminated"},
+	{16, "SIGUSR1", "user defined signal 1"},
+	{17, "SIGUSR2", "user defined signal 2"},
+	{18, "SIGABND", "abend"},
+	{19, "SIGCONT", "continued"},
+	{20, "SIGCHLD", "child exited"},
+	{21, "SIGTTIN", "stopped (tty input)"},
+	{22, "SIGTTOU", "stopped (tty output)"},
+	{23, "SIGIO", "I/O possible"},
+	{24, "SIGQUIT", "quit"},
+	{25, "SIGTSTP", "stopped"},
+	{26, "SIGTRAP", "trace/breakpoint trap"},
+	{27, "SIGIOER", "I/O error"},
+	{28, "SIGWINCH", "window changed"},
+	{29, "SIGXCPU", "CPU time limit exceeded"},
+	{30, "SIGXFSZ", "file size limit exceeded"},
+	{31, "SIGVTALRM", "virtual timer expired"},
+	{32, "SIGPROF", "profiling timer expired"},
+	{33, "SIGDANGER", "danger"},
+	{34, "SIGTHSTOP", "stop thread"},
+	{35, "SIGTHCONT", "continue thread"},
+	{37, "SIGTRACE", "trace"},
+	{38, "", "DCE"},
+	{39, "SIGDUMP", "dump"},
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zptrace_armnn_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/zptrace_armnn_linux.go
index 89c5920e0c..bd001a6e1c 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zptrace_armnn_linux.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zptrace_armnn_linux.go
@@ -1,5 +1,6 @@
 // Code generated by linux/mkall.go generatePtracePair("arm", "arm64"). DO NOT EDIT.
 
+//go:build linux && (arm || arm64)
 // +build linux
 // +build arm arm64
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zptrace_mipsnn_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/zptrace_mipsnn_linux.go
index 24b841eec5..c34d0639be 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zptrace_mipsnn_linux.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zptrace_mipsnn_linux.go
@@ -1,5 +1,6 @@
 // Code generated by linux/mkall.go generatePtracePair("mips", "mips64"). DO NOT EDIT.
 
+//go:build linux && (mips || mips64)
 // +build linux
 // +build mips mips64
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zptrace_mipsnnle_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/zptrace_mipsnnle_linux.go
index 47b0489565..3ccf0c0c4a 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zptrace_mipsnnle_linux.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zptrace_mipsnnle_linux.go
@@ -1,5 +1,6 @@
 // Code generated by linux/mkall.go generatePtracePair("mipsle", "mips64le"). DO NOT EDIT.
 
+//go:build linux && (mipsle || mips64le)
 // +build linux
 // +build mipsle mips64le
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zptrace_x86_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/zptrace_x86_linux.go
index ea5d9cb536..7d65857004 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zptrace_x86_linux.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zptrace_x86_linux.go
@@ -1,5 +1,6 @@
 // Code generated by linux/mkall.go generatePtracePair("386", "amd64"). DO NOT EDIT.
 
+//go:build linux && (386 || amd64)
 // +build linux
 // +build 386 amd64
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc.go
index ed657ff1bc..91a23cc728 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc.go
@@ -1,6 +1,7 @@
 // go run mksyscall_aix_ppc.go -aix -tags aix,ppc syscall_aix.go syscall_aix_ppc.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build aix && ppc
 // +build aix,ppc
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64.go
index 664b293b43..33c2609b8b 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64.go
@@ -1,6 +1,7 @@
 // go run mksyscall_aix_ppc64.go -aix -tags aix,ppc64 syscall_aix.go syscall_aix_ppc64.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build aix && ppc64
 // +build aix,ppc64
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64_gc.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64_gc.go
index 0550da06d1..8b737fa971 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64_gc.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64_gc.go
@@ -1,8 +1,8 @@
 // go run mksyscall_aix_ppc64.go -aix -tags aix,ppc64 syscall_aix.go syscall_aix_ppc64.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
-// +build aix,ppc64
-// +build gc
+//go:build aix && ppc64 && gc
+// +build aix,ppc64,gc
 
 package unix
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64_gccgo.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64_gccgo.go
index cde4dbc5f5..3c260917ed 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64_gccgo.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64_gccgo.go
@@ -1,8 +1,8 @@
 // go run mksyscall_aix_ppc64.go -aix -tags aix,ppc64 syscall_aix.go syscall_aix_ppc64.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
-// +build aix,ppc64
-// +build gccgo
+//go:build aix && ppc64 && gccgo
+// +build aix,ppc64,gccgo
 
 package unix
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.1_13.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.1_13.go
index c8c142c59a..48a62e3906 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.1_13.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.1_13.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -l32 -tags darwin,386,go1.13 syscall_darwin.1_13.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build darwin && 386 && go1.13
 // +build darwin,386,go1.13
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.go
index 3877183483..a266636af6 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -l32 -tags darwin,386,go1.12 syscall_bsd.go syscall_darwin.go syscall_darwin_386.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build darwin && 386 && go1.12
 // +build darwin,386,go1.12
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.1_13.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.1_13.go
index 8882623613..e36299ead0 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.1_13.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.1_13.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -tags darwin,amd64,go1.13 syscall_darwin.1_13.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build darwin && amd64 && go1.13
 // +build darwin,amd64,go1.13
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
index 508e5639bf..f411162882 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -tags darwin,amd64,go1.12 syscall_bsd.go syscall_darwin.go syscall_darwin_amd64.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build darwin && amd64 && go1.12
 // +build darwin,amd64,go1.12
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.1_13.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.1_13.go
index de4738fff8..ed437f89a9 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.1_13.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.1_13.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -l32 -tags darwin,arm,go1.13 syscall_darwin.1_13.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build darwin && arm && go1.13
 // +build darwin,arm,go1.13
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.go
index c0c771f402..7f88cb5ea2 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -l32 -tags darwin,arm,go1.12 syscall_bsd.go syscall_darwin.go syscall_darwin_arm.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build darwin && arm && go1.12
 // +build darwin,arm,go1.12
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.1_13.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.1_13.go
index 870eb37abf..d30ec4e29a 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.1_13.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.1_13.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -tags darwin,arm64,go1.13 syscall_darwin.1_13.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build darwin && arm64 && go1.13
 // +build darwin,arm64,go1.13
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
index 9b01a79c41..a10df58d00 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -tags darwin,arm64,go1.12 syscall_bsd.go syscall_darwin.go syscall_darwin_arm64.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build darwin && arm64 && go1.12
 // +build darwin,arm64,go1.12
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_dragonfly_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_dragonfly_amd64.go
index 104f77d5b8..1b6eedfa61 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_dragonfly_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_dragonfly_amd64.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -dragonfly -tags dragonfly,amd64 syscall_bsd.go syscall_dragonfly.go syscall_dragonfly_amd64.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build dragonfly && amd64
 // +build dragonfly,amd64
 
 package unix
@@ -362,8 +363,8 @@ func pipe() (r int, w int, err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func pipe2(flags int) (r int, w int, err error) {
-	r0, r1, e1 := RawSyscall(SYS_PIPE2, uintptr(flags), 0, 0)
+func pipe2(p *[2]_C_int, flags int) (r int, w int, err error) {
+	r0, r1, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
 	r = int(r0)
 	w = int(r1)
 	if e1 != 0 {
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_freebsd_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_freebsd_386.go
index 600f1d26d2..3e9bddb7b2 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_freebsd_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_freebsd_386.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -l32 -tags freebsd,386 syscall_bsd.go syscall_freebsd.go syscall_freebsd_386.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build freebsd && 386
 // +build freebsd,386
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_freebsd_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_freebsd_amd64.go
index 064934b0d1..c72a462b91 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_freebsd_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_freebsd_amd64.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -tags freebsd,amd64 syscall_bsd.go syscall_freebsd.go syscall_freebsd_amd64.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build freebsd && amd64
 // +build freebsd,amd64
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm.go
index 31d2c46165..530d5df90c 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -l32 -arm -tags freebsd,arm syscall_bsd.go syscall_freebsd.go syscall_freebsd_arm.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build freebsd && arm
 // +build freebsd,arm
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm64.go
index 4adaaa5618..71e7df9e85 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm64.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -tags freebsd,arm64 syscall_bsd.go syscall_freebsd.go syscall_freebsd_arm64.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build freebsd && arm64
 // +build freebsd,arm64
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_illumos_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_illumos_amd64.go
index 665dd9e4b4..b57c7050d7 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_illumos_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_illumos_amd64.go
@@ -1,6 +1,7 @@
 // go run mksyscall_solaris.go -illumos -tags illumos,amd64 syscall_illumos.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build illumos && amd64
 // +build illumos,amd64
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux.go
index 2fbbbe5a89..3ee26f4ad1 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux.go
@@ -1,5 +1,6 @@
 // Code generated by mkmerge.go; DO NOT EDIT.
 
+//go:build linux
 // +build linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_386.go
index 19ebd3ff75..e37096e4de 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_386.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -l32 -tags linux,386 syscall_linux.go syscall_linux_386.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build linux && 386
 // +build linux,386
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_amd64.go
index 5c562182a1..9919d8486d 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_amd64.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -tags linux,amd64 syscall_linux.go syscall_linux_amd64.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build linux && amd64
 // +build linux,amd64
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_arm.go
index dc69d99c61..076754d48d 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_arm.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -l32 -arm -tags linux,arm syscall_linux.go syscall_linux_arm.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build linux && arm
 // +build linux,arm
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_arm64.go
index 1b897dee05..e893f987f9 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_arm64.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -tags linux,arm64 syscall_linux.go syscall_linux_arm64.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build linux && arm64
 // +build linux,arm64
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_mips.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_mips.go
index 49186843ae..4703cf3c33 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_mips.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_mips.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -b32 -arm -tags linux,mips syscall_linux.go syscall_linux_mipsx.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build linux && mips
 // +build linux,mips
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_mips64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_mips64.go
index 9171d3bd2a..a134f9a4d2 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_mips64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_mips64.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -tags linux,mips64 syscall_linux.go syscall_linux_mips64x.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build linux && mips64
 // +build linux,mips64
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_mips64le.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_mips64le.go
index 82286f04f9..b1fff2d946 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_mips64le.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_mips64le.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -tags linux,mips64le syscall_linux.go syscall_linux_mips64x.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build linux && mips64le
 // +build linux,mips64le
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_mipsle.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_mipsle.go
index 15920621c4..d13d6da01e 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_mipsle.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_mipsle.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -l32 -arm -tags linux,mipsle syscall_linux.go syscall_linux_mipsx.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build linux && mipsle
 // +build linux,mipsle
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64.go
index 73a42e2ccb..da8ec03966 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -tags linux,ppc64 syscall_linux.go syscall_linux_ppc64x.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build linux && ppc64
 // +build linux,ppc64
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64le.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64le.go
index 6b85595366..083f493bb6 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64le.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64le.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -tags linux,ppc64le syscall_linux.go syscall_linux_ppc64x.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build linux && ppc64le
 // +build linux,ppc64le
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_riscv64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_riscv64.go
index b76133447e..63b393b802 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_riscv64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_riscv64.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -tags linux,riscv64 syscall_linux.go syscall_linux_riscv64.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build linux && riscv64
 // +build linux,riscv64
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_s390x.go
index d7032ab1e4..bb347407d3 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_s390x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_s390x.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -tags linux,s390x syscall_linux.go syscall_linux_s390x.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build linux && s390x
 // +build linux,s390x
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_sparc64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_sparc64.go
index bcbbdd906e..8edc517e1e 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_sparc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_sparc64.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -tags linux,sparc64 syscall_linux.go syscall_linux_sparc64.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build linux && sparc64
 // +build linux,sparc64
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_386.go
index 1d6f71d99a..4726ab30a8 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_386.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -l32 -netbsd -tags netbsd,386 syscall_bsd.go syscall_netbsd.go syscall_netbsd_386.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build netbsd && 386
 // +build netbsd,386
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_amd64.go
index 82f50506ad..fe71456dbc 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_amd64.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -netbsd -tags netbsd,amd64 syscall_bsd.go syscall_netbsd.go syscall_netbsd_amd64.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build netbsd && amd64
 // +build netbsd,amd64
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm.go
index b4db55a0c8..0b5b2f0143 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -l32 -netbsd -arm -tags netbsd,arm syscall_bsd.go syscall_netbsd.go syscall_netbsd_arm.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build netbsd && arm
 // +build netbsd,arm
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm64.go
index e9f6d7975a..bfca28648f 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm64.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -netbsd -tags netbsd,arm64 syscall_bsd.go syscall_netbsd.go syscall_netbsd_arm64.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build netbsd && arm64
 // +build netbsd,arm64
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.go
index b44b31aeb1..8f80f4ade5 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -l32 -openbsd -tags openbsd,386 syscall_bsd.go syscall_openbsd.go syscall_openbsd_386.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build openbsd && 386
 // +build openbsd,386
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.go
index 67f93ee76d..3a47aca7bf 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -openbsd -tags openbsd,amd64 syscall_bsd.go syscall_openbsd.go syscall_openbsd_amd64.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build openbsd && amd64
 // +build openbsd,amd64
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.go
index d7c878b1d0..883a9b45e8 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -l32 -openbsd -arm -tags openbsd,arm syscall_bsd.go syscall_openbsd.go syscall_openbsd_arm.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build openbsd && arm
 // +build openbsd,arm
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.go
index 8facd695d5..aac7fdc95e 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -openbsd -tags openbsd,arm64 syscall_bsd.go syscall_openbsd.go syscall_openbsd_arm64.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build openbsd && arm64
 // +build openbsd,arm64
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.go
index ec6bd5bb73..8776187462 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.go
@@ -1,6 +1,7 @@
 // go run mksyscall.go -openbsd -tags openbsd,mips64 syscall_bsd.go syscall_openbsd.go syscall_openbsd_mips64.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build openbsd && mips64
 // +build openbsd,mips64
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go
index 9898ce1f47..7099f555aa 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go
@@ -1,6 +1,7 @@
 // go run mksyscall_solaris.go -tags solaris,amd64 syscall_solaris.go syscall_solaris_amd64.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build solaris && amd64
 // +build solaris,amd64
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_zos_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_zos_s390x.go
new file mode 100644
index 0000000000..8285ab8419
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_zos_s390x.go
@@ -0,0 +1,1217 @@
+// go run mksyscall.go -tags zos,s390x syscall_zos_s390x.go
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+//go:build zos && s390x
+// +build zos,s390x
+
+package unix
+
+import (
+	"unsafe"
+)
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func fcntl(fd int, cmd int, arg int) (val int, err error) {
+	r0, _, e1 := syscall_syscall(SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg))
+	val = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func read(fd int, p []byte) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(p) > 0 {
+		_p0 = unsafe.Pointer(&p[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := syscall_syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p)))
+	n = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
+	r0, _, e1 := syscall_syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
+	n = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func write(fd int, p []byte) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(p) > 0 {
+		_p0 = unsafe.Pointer(&p[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := syscall_syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)))
+	n = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
+	r0, _, e1 := syscall_syscall(SYS___ACCEPT_A, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	fd = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
+	_, _, e1 := syscall_syscall(SYS___BIND_A, uintptr(s), uintptr(addr), uintptr(addrlen))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
+	_, _, e1 := syscall_syscall(SYS___CONNECT_A, uintptr(s), uintptr(addr), uintptr(addrlen))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func getgroups(n int, list *_Gid_t) (nn int, err error) {
+	r0, _, e1 := syscall_rawsyscall(SYS_GETGROUPS, uintptr(n), uintptr(unsafe.Pointer(list)), 0)
+	nn = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func setgroups(n int, list *_Gid_t) (err error) {
+	_, _, e1 := syscall_rawsyscall(SYS_SETGROUPS, uintptr(n), uintptr(unsafe.Pointer(list)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
+	_, _, e1 := syscall_syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
+	_, _, e1 := syscall_syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func socket(domain int, typ int, proto int) (fd int, err error) {
+	r0, _, e1 := syscall_rawsyscall(SYS_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto))
+	fd = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
+	_, _, e1 := syscall_rawsyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
+	_, _, e1 := syscall_rawsyscall(SYS___GETPEERNAME_A, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
+	_, _, e1 := syscall_rawsyscall(SYS___GETSOCKNAME_A, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(p) > 0 {
+		_p0 = unsafe.Pointer(&p[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := syscall_syscall6(SYS___RECVFROM_A, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
+	n = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
+	var _p0 unsafe.Pointer
+	if len(buf) > 0 {
+		_p0 = unsafe.Pointer(&buf[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	_, _, e1 := syscall_syscall6(SYS___SENDTO_A, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
+	r0, _, e1 := syscall_syscall(SYS___RECVMSG_A, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
+	n = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
+	r0, _, e1 := syscall_syscall(SYS___SENDMSG_A, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
+	n = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
+	r0, _, e1 := syscall_syscall6(SYS_MMAP, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
+	ret = uintptr(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func munmap(addr uintptr, length uintptr) (err error) {
+	_, _, e1 := syscall_syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func ioctl(fd int, req uint, arg uintptr) (err error) {
+	_, _, e1 := syscall_syscall(SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(arg))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Access(path string, mode uint32) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall_syscall(SYS___ACCESS_A, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Chdir(path string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall_syscall(SYS___CHDIR_A, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Chown(path string, uid int, gid int) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall_syscall(SYS___CHOWN_A, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Chmod(path string, mode uint32) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall_syscall(SYS___CHMOD_A, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Creat(path string, mode uint32) (fd int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := syscall_syscall(SYS___CREAT_A, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	fd = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Dup(oldfd int) (fd int, err error) {
+	r0, _, e1 := syscall_syscall(SYS_DUP, uintptr(oldfd), 0, 0)
+	fd = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Dup2(oldfd int, newfd int) (err error) {
+	_, _, e1 := syscall_syscall(SYS_DUP2, uintptr(oldfd), uintptr(newfd), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Exit(code int) {
+	syscall_syscall(SYS_EXIT, uintptr(code), 0, 0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fchdir(fd int) (err error) {
+	_, _, e1 := syscall_syscall(SYS_FCHDIR, uintptr(fd), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fchmod(fd int, mode uint32) (err error) {
+	_, _, e1 := syscall_syscall(SYS_FCHMOD, uintptr(fd), uintptr(mode), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fchown(fd int, uid int, gid int) (err error) {
+	_, _, e1 := syscall_syscall(SYS_FCHOWN, uintptr(fd), uintptr(uid), uintptr(gid))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func FcntlInt(fd uintptr, cmd int, arg int) (retval int, err error) {
+	r0, _, e1 := syscall_syscall(SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg))
+	retval = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func fstat(fd int, stat *Stat_LE_t) (err error) {
+	_, _, e1 := syscall_syscall(SYS_FSTAT, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fstatvfs(fd int, stat *Statvfs_t) (err error) {
+	_, _, e1 := syscall_syscall(SYS_FSTATVFS, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fsync(fd int) (err error) {
+	_, _, e1 := syscall_syscall(SYS_FSYNC, uintptr(fd), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Ftruncate(fd int, length int64) (err error) {
+	_, _, e1 := syscall_syscall(SYS_FTRUNCATE, uintptr(fd), uintptr(length), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Getpagesize() (pgsize int) {
+	r0, _, _ := syscall_syscall(SYS_GETPAGESIZE, 0, 0, 0)
+	pgsize = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Mprotect(b []byte, prot int) (err error) {
+	var _p0 unsafe.Pointer
+	if len(b) > 0 {
+		_p0 = unsafe.Pointer(&b[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	_, _, e1 := syscall_syscall(SYS_MPROTECT, uintptr(_p0), uintptr(len(b)), uintptr(prot))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Msync(b []byte, flags int) (err error) {
+	var _p0 unsafe.Pointer
+	if len(b) > 0 {
+		_p0 = unsafe.Pointer(&b[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	_, _, e1 := syscall_syscall(SYS_MSYNC, uintptr(_p0), uintptr(len(b)), uintptr(flags))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Poll(fds []PollFd, timeout int) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(fds) > 0 {
+		_p0 = unsafe.Pointer(&fds[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := syscall_syscall(SYS_POLL, uintptr(_p0), uintptr(len(fds)), uintptr(timeout))
+	n = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Times(tms *Tms) (ticks uintptr, err error) {
+	r0, _, e1 := syscall_syscall(SYS_TIMES, uintptr(unsafe.Pointer(tms)), 0, 0)
+	ticks = uintptr(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func W_Getmntent(buff *byte, size int) (lastsys int, err error) {
+	r0, _, e1 := syscall_syscall(SYS_W_GETMNTENT, uintptr(unsafe.Pointer(buff)), uintptr(size), 0)
+	lastsys = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Mount(path string, filesystem string, fstype string, mtm uint32, parmlen int32, parm string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(filesystem)
+	if err != nil {
+		return
+	}
+	var _p2 *byte
+	_p2, err = BytePtrFromString(fstype)
+	if err != nil {
+		return
+	}
+	var _p3 *byte
+	_p3, err = BytePtrFromString(parm)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall_syscall6(SYS___MOUNT_A, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(_p2)), uintptr(mtm), uintptr(parmlen), uintptr(unsafe.Pointer(_p3)))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Unmount(filesystem string, mtm int) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(filesystem)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall_syscall(SYS___UMOUNT_A, uintptr(unsafe.Pointer(_p0)), uintptr(mtm), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Chroot(path string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall_syscall(SYS___CHROOT_A, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Uname(buf *Utsname) (err error) {
+	_, _, e1 := syscall_rawsyscall(SYS___UNAME_A, uintptr(unsafe.Pointer(buf)), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Gethostname(buf []byte) (err error) {
+	var _p0 unsafe.Pointer
+	if len(buf) > 0 {
+		_p0 = unsafe.Pointer(&buf[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	_, _, e1 := syscall_syscall(SYS___GETHOSTNAME_A, uintptr(_p0), uintptr(len(buf)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Getegid() (egid int) {
+	r0, _, _ := syscall_rawsyscall(SYS_GETEGID, 0, 0, 0)
+	egid = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Geteuid() (uid int) {
+	r0, _, _ := syscall_rawsyscall(SYS_GETEUID, 0, 0, 0)
+	uid = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Getgid() (gid int) {
+	r0, _, _ := syscall_rawsyscall(SYS_GETGID, 0, 0, 0)
+	gid = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Getpid() (pid int) {
+	r0, _, _ := syscall_rawsyscall(SYS_GETPID, 0, 0, 0)
+	pid = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Getpgid(pid int) (pgid int, err error) {
+	r0, _, e1 := syscall_rawsyscall(SYS_GETPGID, uintptr(pid), 0, 0)
+	pgid = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Getppid() (pid int) {
+	r0, _, _ := syscall_rawsyscall(SYS_GETPPID, 0, 0, 0)
+	pid = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Getpriority(which int, who int) (prio int, err error) {
+	r0, _, e1 := syscall_syscall(SYS_GETPRIORITY, uintptr(which), uintptr(who), 0)
+	prio = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Getrlimit(resource int, rlim *Rlimit) (err error) {
+	_, _, e1 := syscall_rawsyscall(SYS_GETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func getrusage(who int, rusage *rusage_zos) (err error) {
+	_, _, e1 := syscall_rawsyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Getsid(pid int) (sid int, err error) {
+	r0, _, e1 := syscall_rawsyscall(SYS_GETSID, uintptr(pid), 0, 0)
+	sid = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Getuid() (uid int) {
+	r0, _, _ := syscall_rawsyscall(SYS_GETUID, 0, 0, 0)
+	uid = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Kill(pid int, sig Signal) (err error) {
+	_, _, e1 := syscall_rawsyscall(SYS_KILL, uintptr(pid), uintptr(sig), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Lchown(path string, uid int, gid int) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall_syscall(SYS___LCHOWN_A, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Link(path string, link string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall_syscall(SYS___LINK_A, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Listen(s int, n int) (err error) {
+	_, _, e1 := syscall_syscall(SYS_LISTEN, uintptr(s), uintptr(n), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func lstat(path string, stat *Stat_LE_t) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall_syscall(SYS___LSTAT_A, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Mkdir(path string, mode uint32) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall_syscall(SYS___MKDIR_A, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Mkfifo(path string, mode uint32) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall_syscall(SYS___MKFIFO_A, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Mknod(path string, mode uint32, dev int) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall_syscall(SYS___MKNOD_A, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Pread(fd int, p []byte, offset int64) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(p) > 0 {
+		_p0 = unsafe.Pointer(&p[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := syscall_syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
+	n = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(p) > 0 {
+		_p0 = unsafe.Pointer(&p[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := syscall_syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
+	n = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Readlink(path string, buf []byte) (n int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	var _p1 unsafe.Pointer
+	if len(buf) > 0 {
+		_p1 = unsafe.Pointer(&buf[0])
+	} else {
+		_p1 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := syscall_syscall(SYS___READLINK_A, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
+	n = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Rename(from string, to string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(from)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(to)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall_syscall(SYS___RENAME_A, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Rmdir(path string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall_syscall(SYS___RMDIR_A, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Seek(fd int, offset int64, whence int) (off int64, err error) {
+	r0, _, e1 := syscall_syscall(SYS_LSEEK, uintptr(fd), uintptr(offset), uintptr(whence))
+	off = int64(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Setpriority(which int, who int, prio int) (err error) {
+	_, _, e1 := syscall_syscall(SYS_SETPRIORITY, uintptr(which), uintptr(who), uintptr(prio))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Setpgid(pid int, pgid int) (err error) {
+	_, _, e1 := syscall_rawsyscall(SYS_SETPGID, uintptr(pid), uintptr(pgid), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Setrlimit(resource int, lim *Rlimit) (err error) {
+	_, _, e1 := syscall_rawsyscall(SYS_SETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(lim)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Setregid(rgid int, egid int) (err error) {
+	_, _, e1 := syscall_rawsyscall(SYS_SETREGID, uintptr(rgid), uintptr(egid), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Setreuid(ruid int, euid int) (err error) {
+	_, _, e1 := syscall_rawsyscall(SYS_SETREUID, uintptr(ruid), uintptr(euid), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Setsid() (pid int, err error) {
+	r0, _, e1 := syscall_rawsyscall(SYS_SETSID, 0, 0, 0)
+	pid = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Setuid(uid int) (err error) {
+	_, _, e1 := syscall_syscall(SYS_SETUID, uintptr(uid), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Setgid(uid int) (err error) {
+	_, _, e1 := syscall_syscall(SYS_SETGID, uintptr(uid), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Shutdown(fd int, how int) (err error) {
+	_, _, e1 := syscall_syscall(SYS_SHUTDOWN, uintptr(fd), uintptr(how), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func stat(path string, statLE *Stat_LE_t) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall_syscall(SYS___STAT_A, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(statLE)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Symlink(path string, link string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall_syscall(SYS___SYMLINK_A, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Sync() {
+	syscall_syscall(SYS_SYNC, 0, 0, 0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Truncate(path string, length int64) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall_syscall(SYS___TRUNCATE_A, uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Tcgetattr(fildes int, termptr *Termios) (err error) {
+	_, _, e1 := syscall_syscall(SYS_TCGETATTR, uintptr(fildes), uintptr(unsafe.Pointer(termptr)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Tcsetattr(fildes int, when int, termptr *Termios) (err error) {
+	_, _, e1 := syscall_syscall(SYS_TCSETATTR, uintptr(fildes), uintptr(when), uintptr(unsafe.Pointer(termptr)))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Umask(mask int) (oldmask int) {
+	r0, _, _ := syscall_syscall(SYS_UMASK, uintptr(mask), 0, 0)
+	oldmask = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Unlink(path string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall_syscall(SYS___UNLINK_A, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Utime(path string, utim *Utimbuf) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall_syscall(SYS___UTIME_A, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(utim)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func open(path string, mode int, perm uint32) (fd int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := syscall_syscall(SYS___OPEN_A, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
+	fd = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func remove(path string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall_syscall(SYS_REMOVE, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func waitpid(pid int, wstatus *_C_int, options int) (wpid int, err error) {
+	r0, _, e1 := syscall_syscall(SYS_WAITPID, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options))
+	wpid = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func gettimeofday(tv *timeval_zos) (err error) {
+	_, _, e1 := syscall_rawsyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tv)), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func pipe(p *[2]_C_int) (err error) {
+	_, _, e1 := syscall_rawsyscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func utimes(path string, timeval *[2]Timeval) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall_syscall(SYS___UTIMES_A, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_386.go
index 102f1ab475..9e9d0b2a9c 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_386.go
@@ -1,6 +1,7 @@
 // go run mksysctl_openbsd.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build 386 && openbsd
 // +build 386,openbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_amd64.go
index 4866fced8a..adecd09667 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_amd64.go
@@ -1,6 +1,7 @@
 // go run mksysctl_openbsd.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build amd64 && openbsd
 // +build amd64,openbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_arm.go
index d3801eb24b..8ea52a4a18 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_arm.go
@@ -1,6 +1,7 @@
 // go run mksysctl_openbsd.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build arm && openbsd
 // +build arm,openbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_arm64.go
index ba4304fd23..154b57ae3e 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_arm64.go
@@ -1,6 +1,7 @@
 // go run mksysctl_openbsd.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build arm64 && openbsd
 // +build arm64,openbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_mips64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_mips64.go
index aca34b3493..d96bb2ba4d 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_mips64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_mips64.go
@@ -1,6 +1,7 @@
 // go run mksysctl_openbsd.go
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build mips64 && openbsd
 // +build mips64,openbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_386.go
index ad62324c7c..1794ffc924 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_386.go
@@ -1,6 +1,7 @@
 // go run mksysnum.go /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/usr/include/sys/syscall.h
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build 386 && darwin
 // +build 386,darwin
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_amd64.go
index a2fc91d6a8..f8298ff9b5 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_amd64.go
@@ -1,6 +1,7 @@
 // go run mksysnum.go /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/usr/include/sys/syscall.h
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build amd64 && darwin
 // +build amd64,darwin
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_arm.go
index 20d7808ace..6dc736449a 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_arm.go
@@ -1,6 +1,7 @@
 // go run mksysnum.go /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS11.1.sdk/usr/include/sys/syscall.h
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm && darwin
 // +build arm,darwin
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_arm64.go
index 527b9588cc..5eb433bbf0 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_arm64.go
@@ -1,6 +1,7 @@
 // go run mksysnum.go /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS11.1.sdk/usr/include/sys/syscall.h
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm64 && darwin
 // +build arm64,darwin
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_dragonfly_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_dragonfly_amd64.go
index 9912c6ee3d..703675c0c4 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_dragonfly_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_dragonfly_amd64.go
@@ -1,6 +1,7 @@
 // go run mksysnum.go https://gitweb.dragonflybsd.org/dragonfly.git/blob_plain/HEAD:/sys/kern/syscalls.master
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build amd64 && dragonfly
 // +build amd64,dragonfly
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_freebsd_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_freebsd_386.go
index 9474974b65..59d5dfc209 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_freebsd_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_freebsd_386.go
@@ -1,6 +1,7 @@
 // go run mksysnum.go https://svn.freebsd.org/base/stable/11/sys/kern/syscalls.master
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build 386 && freebsd
 // +build 386,freebsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_freebsd_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_freebsd_amd64.go
index 48a7beae7b..342d471d2e 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_freebsd_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_freebsd_amd64.go
@@ -1,6 +1,7 @@
 // go run mksysnum.go https://svn.freebsd.org/base/stable/11/sys/kern/syscalls.master
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build amd64 && freebsd
 // +build amd64,freebsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_freebsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_freebsd_arm.go
index 4a6dfd4a74..e2e3d72c5b 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_freebsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_freebsd_arm.go
@@ -1,6 +1,7 @@
 // go run mksysnum.go https://svn.freebsd.org/base/stable/11/sys/kern/syscalls.master
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm && freebsd
 // +build arm,freebsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_freebsd_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_freebsd_arm64.go
index 3e51af8edd..61ad5ca3c1 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_freebsd_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_freebsd_arm64.go
@@ -1,6 +1,7 @@
 // go run mksysnum.go https://svn.freebsd.org/base/stable/11/sys/kern/syscalls.master
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm64 && freebsd
 // +build arm64,freebsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
index c80f3c7bdd..8e53597134 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
@@ -1,6 +1,7 @@
 // go run linux/mksysnum.go -Wall -Werror -static -I/tmp/include -m32 /tmp/include/asm/unistd.h
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build 386 && linux
 // +build 386,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
index 2369995cec..d7dceb769b 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
@@ -1,6 +1,7 @@
 // go run linux/mksysnum.go -Wall -Werror -static -I/tmp/include -m64 /tmp/include/asm/unistd.h
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build amd64 && linux
 // +build amd64,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
index 971c5af6d4..04093a69fd 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
@@ -1,6 +1,7 @@
 // go run linux/mksysnum.go -Wall -Werror -static -I/tmp/include /tmp/include/asm/unistd.h
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm && linux
 // +build arm,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
index a5e410b24f..48f94f135d 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
@@ -1,6 +1,7 @@
 // go run linux/mksysnum.go -Wall -Werror -static -I/tmp/include -fsigned-char /tmp/include/asm/unistd.h
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm64 && linux
 // +build arm64,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
index 438a6ea4e6..499978c3e4 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
@@ -1,6 +1,7 @@
 // go run linux/mksysnum.go -Wall -Werror -static -I/tmp/include /tmp/include/asm/unistd.h
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build mips && linux
 // +build mips,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
index 622472da22..10d1db2be0 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
@@ -1,6 +1,7 @@
 // go run linux/mksysnum.go -Wall -Werror -static -I/tmp/include /tmp/include/asm/unistd.h
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build mips64 && linux
 // +build mips64,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
index e029b989b8..208d5dcd5a 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
@@ -1,6 +1,7 @@
 // go run linux/mksysnum.go -Wall -Werror -static -I/tmp/include /tmp/include/asm/unistd.h
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build mips64le && linux
 // +build mips64le,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
index 86a497b58d..f8250602eb 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
@@ -1,6 +1,7 @@
 // go run linux/mksysnum.go -Wall -Werror -static -I/tmp/include /tmp/include/asm/unistd.h
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build mipsle && linux
 // +build mipsle,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
index b6b0b5e602..d5ed3ff510 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
@@ -1,6 +1,7 @@
 // go run linux/mksysnum.go -Wall -Werror -static -I/tmp/include /tmp/include/asm/unistd.h
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build ppc64 && linux
 // +build ppc64,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
index b344db0146..e29b4424c2 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
@@ -1,6 +1,7 @@
 // go run linux/mksysnum.go -Wall -Werror -static -I/tmp/include /tmp/include/asm/unistd.h
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build ppc64le && linux
 // +build ppc64le,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
index 9b8fa53dcc..41deed6c3a 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
@@ -1,6 +1,7 @@
 // go run linux/mksysnum.go -Wall -Werror -static -I/tmp/include /tmp/include/asm/unistd.h
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build riscv64 && linux
 // +build riscv64,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
index 8261f72c0b..8e53a9e8ce 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
@@ -1,6 +1,7 @@
 // go run linux/mksysnum.go -Wall -Werror -static -I/tmp/include -fsigned-char /tmp/include/asm/unistd.h
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build s390x && linux
 // +build s390x,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
index f4bbeb3db5..596e5bc7d3 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
@@ -1,6 +1,7 @@
 // go run linux/mksysnum.go -Wall -Werror -static -I/tmp/include /tmp/include/asm/unistd.h
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build sparc64 && linux
 // +build sparc64,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_netbsd_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_netbsd_386.go
index e66a8c9d39..3a6699eba9 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_netbsd_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_netbsd_386.go
@@ -1,6 +1,7 @@
 // go run mksysnum.go http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build 386 && netbsd
 // +build 386,netbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_netbsd_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_netbsd_amd64.go
index 42c788f249..5677cd4f15 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_netbsd_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_netbsd_amd64.go
@@ -1,6 +1,7 @@
 // go run mksysnum.go http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build amd64 && netbsd
 // +build amd64,netbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_netbsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_netbsd_arm.go
index 0a0757179b..e784cb6db1 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_netbsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_netbsd_arm.go
@@ -1,6 +1,7 @@
 // go run mksysnum.go http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm && netbsd
 // +build arm,netbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_netbsd_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_netbsd_arm64.go
index 0291c0931b..bd4952efa5 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_netbsd_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_netbsd_arm64.go
@@ -1,6 +1,7 @@
 // go run mksysnum.go http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build arm64 && netbsd
 // +build arm64,netbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_386.go
index b0207d1c9b..817edbf95c 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_386.go
@@ -1,6 +1,7 @@
 // go run mksysnum.go https://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build 386 && openbsd
 // +build 386,openbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_amd64.go
index f0dec6f0b4..ea453614e6 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_amd64.go
@@ -1,6 +1,7 @@
 // go run mksysnum.go https://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build amd64 && openbsd
 // +build amd64,openbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_arm.go
index 33d1dc5404..467971eed6 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_arm.go
@@ -1,6 +1,7 @@
 // go run mksysnum.go https://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm && openbsd
 // +build arm,openbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_arm64.go
index fe2b689b63..32eec5ed56 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_arm64.go
@@ -1,6 +1,7 @@
 // go run mksysnum.go https://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm64 && openbsd
 // +build arm64,openbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_mips64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_mips64.go
index 5c08d573b3..a37f773756 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_mips64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_mips64.go
@@ -1,6 +1,7 @@
 // go run mksysnum.go https://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build mips64 && openbsd
 // +build mips64,openbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_zos_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_zos_s390x.go
new file mode 100644
index 0000000000..073daad43b
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_zos_s390x.go
@@ -0,0 +1,2670 @@
+// Copyright 2020 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.
+
+//go:build zos && s390x
+// +build zos,s390x
+
+package unix
+
+// TODO: auto-generate.
+
+const (
+	SYS_ACOSD128                        = 0xB80
+	SYS_ACOSD32                         = 0xB7E
+	SYS_ACOSD64                         = 0xB7F
+	SYS_ACOSHD128                       = 0xB83
+	SYS_ACOSHD32                        = 0xB81
+	SYS_ACOSHD64                        = 0xB82
+	SYS_AIO_FSYNC                       = 0xC69
+	SYS_ASCTIME                         = 0x0AE
+	SYS_ASCTIME64                       = 0xCD7
+	SYS_ASCTIME64_R                     = 0xCD8
+	SYS_ASIND128                        = 0xB86
+	SYS_ASIND32                         = 0xB84
+	SYS_ASIND64                         = 0xB85
+	SYS_ASINHD128                       = 0xB89
+	SYS_ASINHD32                        = 0xB87
+	SYS_ASINHD64                        = 0xB88
+	SYS_ATAN2D128                       = 0xB8F
+	SYS_ATAN2D32                        = 0xB8D
+	SYS_ATAN2D64                        = 0xB8E
+	SYS_ATAND128                        = 0xB8C
+	SYS_ATAND32                         = 0xB8A
+	SYS_ATAND64                         = 0xB8B
+	SYS_ATANHD128                       = 0xB92
+	SYS_ATANHD32                        = 0xB90
+	SYS_ATANHD64                        = 0xB91
+	SYS_BIND2ADDRSEL                    = 0xD59
+	SYS_C16RTOMB                        = 0xD40
+	SYS_C32RTOMB                        = 0xD41
+	SYS_CBRTD128                        = 0xB95
+	SYS_CBRTD32                         = 0xB93
+	SYS_CBRTD64                         = 0xB94
+	SYS_CEILD128                        = 0xB98
+	SYS_CEILD32                         = 0xB96
+	SYS_CEILD64                         = 0xB97
+	SYS_CLEARENV                        = 0x0C9
+	SYS_CLEARERR_UNLOCKED               = 0xCA1
+	SYS_CLOCK                           = 0x0AA
+	SYS_CLOGL                           = 0xA00
+	SYS_CLRMEMF                         = 0x0BD
+	SYS_CONJ                            = 0xA03
+	SYS_CONJF                           = 0xA06
+	SYS_CONJL                           = 0xA09
+	SYS_COPYSIGND128                    = 0xB9E
+	SYS_COPYSIGND32                     = 0xB9C
+	SYS_COPYSIGND64                     = 0xB9D
+	SYS_COSD128                         = 0xBA1
+	SYS_COSD32                          = 0xB9F
+	SYS_COSD64                          = 0xBA0
+	SYS_COSHD128                        = 0xBA4
+	SYS_COSHD32                         = 0xBA2
+	SYS_COSHD64                         = 0xBA3
+	SYS_CPOW                            = 0xA0C
+	SYS_CPOWF                           = 0xA0F
+	SYS_CPOWL                           = 0xA12
+	SYS_CPROJ                           = 0xA15
+	SYS_CPROJF                          = 0xA18
+	SYS_CPROJL                          = 0xA1B
+	SYS_CREAL                           = 0xA1E
+	SYS_CREALF                          = 0xA21
+	SYS_CREALL                          = 0xA24
+	SYS_CSIN                            = 0xA27
+	SYS_CSINF                           = 0xA2A
+	SYS_CSINH                           = 0xA30
+	SYS_CSINHF                          = 0xA33
+	SYS_CSINHL                          = 0xA36
+	SYS_CSINL                           = 0xA2D
+	SYS_CSNAP                           = 0x0C5
+	SYS_CSQRT                           = 0xA39
+	SYS_CSQRTF                          = 0xA3C
+	SYS_CSQRTL                          = 0xA3F
+	SYS_CTAN                            = 0xA42
+	SYS_CTANF                           = 0xA45
+	SYS_CTANH                           = 0xA4B
+	SYS_CTANHF                          = 0xA4E
+	SYS_CTANHL                          = 0xA51
+	SYS_CTANL                           = 0xA48
+	SYS_CTIME                           = 0x0AB
+	SYS_CTIME64                         = 0xCD9
+	SYS_CTIME64_R                       = 0xCDA
+	SYS_CTRACE                          = 0x0C6
+	SYS_DIFFTIME                        = 0x0A7
+	SYS_DIFFTIME64                      = 0xCDB
+	SYS_DLADDR                          = 0xC82
+	SYS_DYNALLOC                        = 0x0C3
+	SYS_DYNFREE                         = 0x0C2
+	SYS_ERFCD128                        = 0xBAA
+	SYS_ERFCD32                         = 0xBA8
+	SYS_ERFCD64                         = 0xBA9
+	SYS_ERFD128                         = 0xBA7
+	SYS_ERFD32                          = 0xBA5
+	SYS_ERFD64                          = 0xBA6
+	SYS_EXP2D128                        = 0xBB0
+	SYS_EXP2D32                         = 0xBAE
+	SYS_EXP2D64                         = 0xBAF
+	SYS_EXPD128                         = 0xBAD
+	SYS_EXPD32                          = 0xBAB
+	SYS_EXPD64                          = 0xBAC
+	SYS_EXPM1D128                       = 0xBB3
+	SYS_EXPM1D32                        = 0xBB1
+	SYS_EXPM1D64                        = 0xBB2
+	SYS_FABSD128                        = 0xBB6
+	SYS_FABSD32                         = 0xBB4
+	SYS_FABSD64                         = 0xBB5
+	SYS_FDELREC_UNLOCKED                = 0xCA2
+	SYS_FDIMD128                        = 0xBB9
+	SYS_FDIMD32                         = 0xBB7
+	SYS_FDIMD64                         = 0xBB8
+	SYS_FDOPEN_UNLOCKED                 = 0xCFC
+	SYS_FECLEAREXCEPT                   = 0xAEA
+	SYS_FEGETENV                        = 0xAEB
+	SYS_FEGETEXCEPTFLAG                 = 0xAEC
+	SYS_FEGETROUND                      = 0xAED
+	SYS_FEHOLDEXCEPT                    = 0xAEE
+	SYS_FEOF_UNLOCKED                   = 0xCA3
+	SYS_FERAISEEXCEPT                   = 0xAEF
+	SYS_FERROR_UNLOCKED                 = 0xCA4
+	SYS_FESETENV                        = 0xAF0
+	SYS_FESETEXCEPTFLAG                 = 0xAF1
+	SYS_FESETROUND                      = 0xAF2
+	SYS_FETCHEP                         = 0x0BF
+	SYS_FETESTEXCEPT                    = 0xAF3
+	SYS_FEUPDATEENV                     = 0xAF4
+	SYS_FE_DEC_GETROUND                 = 0xBBA
+	SYS_FE_DEC_SETROUND                 = 0xBBB
+	SYS_FFLUSH_UNLOCKED                 = 0xCA5
+	SYS_FGETC_UNLOCKED                  = 0xC80
+	SYS_FGETPOS64                       = 0xCEE
+	SYS_FGETPOS64_UNLOCKED              = 0xCF4
+	SYS_FGETPOS_UNLOCKED                = 0xCA6
+	SYS_FGETS_UNLOCKED                  = 0xC7C
+	SYS_FGETWC_UNLOCKED                 = 0xCA7
+	SYS_FGETWS_UNLOCKED                 = 0xCA8
+	SYS_FILENO_UNLOCKED                 = 0xCA9
+	SYS_FLDATA                          = 0x0C1
+	SYS_FLDATA_UNLOCKED                 = 0xCAA
+	SYS_FLOCATE_UNLOCKED                = 0xCAB
+	SYS_FLOORD128                       = 0xBBE
+	SYS_FLOORD32                        = 0xBBC
+	SYS_FLOORD64                        = 0xBBD
+	SYS_FMA                             = 0xA63
+	SYS_FMAD128                         = 0xBC1
+	SYS_FMAD32                          = 0xBBF
+	SYS_FMAD64                          = 0xBC0
+	SYS_FMAF                            = 0xA66
+	SYS_FMAL                            = 0xA69
+	SYS_FMAX                            = 0xA6C
+	SYS_FMAXD128                        = 0xBC4
+	SYS_FMAXD32                         = 0xBC2
+	SYS_FMAXD64                         = 0xBC3
+	SYS_FMAXF                           = 0xA6F
+	SYS_FMAXL                           = 0xA72
+	SYS_FMIN                            = 0xA75
+	SYS_FMIND128                        = 0xBC7
+	SYS_FMIND32                         = 0xBC5
+	SYS_FMIND64                         = 0xBC6
+	SYS_FMINF                           = 0xA78
+	SYS_FMINL                           = 0xA7B
+	SYS_FMODD128                        = 0xBCA
+	SYS_FMODD32                         = 0xBC8
+	SYS_FMODD64                         = 0xBC9
+	SYS_FOPEN64                         = 0xD49
+	SYS_FOPEN64_UNLOCKED                = 0xD4A
+	SYS_FOPEN_UNLOCKED                  = 0xCFA
+	SYS_FPRINTF_UNLOCKED                = 0xCAC
+	SYS_FPUTC_UNLOCKED                  = 0xC81
+	SYS_FPUTS_UNLOCKED                  = 0xC7E
+	SYS_FPUTWC_UNLOCKED                 = 0xCAD
+	SYS_FPUTWS_UNLOCKED                 = 0xCAE
+	SYS_FREAD_NOUPDATE                  = 0xCEC
+	SYS_FREAD_NOUPDATE_UNLOCKED         = 0xCED
+	SYS_FREAD_UNLOCKED                  = 0xC7B
+	SYS_FREEIFADDRS                     = 0xCE6
+	SYS_FREOPEN64                       = 0xD4B
+	SYS_FREOPEN64_UNLOCKED              = 0xD4C
+	SYS_FREOPEN_UNLOCKED                = 0xCFB
+	SYS_FREXPD128                       = 0xBCE
+	SYS_FREXPD32                        = 0xBCC
+	SYS_FREXPD64                        = 0xBCD
+	SYS_FSCANF_UNLOCKED                 = 0xCAF
+	SYS_FSEEK64                         = 0xCEF
+	SYS_FSEEK64_UNLOCKED                = 0xCF5
+	SYS_FSEEKO64                        = 0xCF0
+	SYS_FSEEKO64_UNLOCKED               = 0xCF6
+	SYS_FSEEKO_UNLOCKED                 = 0xCB1
+	SYS_FSEEK_UNLOCKED                  = 0xCB0
+	SYS_FSETPOS64                       = 0xCF1
+	SYS_FSETPOS64_UNLOCKED              = 0xCF7
+	SYS_FSETPOS_UNLOCKED                = 0xCB3
+	SYS_FTELL64                         = 0xCF2
+	SYS_FTELL64_UNLOCKED                = 0xCF8
+	SYS_FTELLO64                        = 0xCF3
+	SYS_FTELLO64_UNLOCKED               = 0xCF9
+	SYS_FTELLO_UNLOCKED                 = 0xCB5
+	SYS_FTELL_UNLOCKED                  = 0xCB4
+	SYS_FUPDATE                         = 0x0B5
+	SYS_FUPDATE_UNLOCKED                = 0xCB7
+	SYS_FWIDE_UNLOCKED                  = 0xCB8
+	SYS_FWPRINTF_UNLOCKED               = 0xCB9
+	SYS_FWRITE_UNLOCKED                 = 0xC7A
+	SYS_FWSCANF_UNLOCKED                = 0xCBA
+	SYS_GETDATE64                       = 0xD4F
+	SYS_GETIFADDRS                      = 0xCE7
+	SYS_GETIPV4SOURCEFILTER             = 0xC77
+	SYS_GETSOURCEFILTER                 = 0xC79
+	SYS_GETSYNTX                        = 0x0FD
+	SYS_GETS_UNLOCKED                   = 0xC7D
+	SYS_GETTIMEOFDAY64                  = 0xD50
+	SYS_GETWCHAR_UNLOCKED               = 0xCBC
+	SYS_GETWC_UNLOCKED                  = 0xCBB
+	SYS_GMTIME                          = 0x0B0
+	SYS_GMTIME64                        = 0xCDC
+	SYS_GMTIME64_R                      = 0xCDD
+	SYS_HYPOTD128                       = 0xBD1
+	SYS_HYPOTD32                        = 0xBCF
+	SYS_HYPOTD64                        = 0xBD0
+	SYS_ILOGBD128                       = 0xBD4
+	SYS_ILOGBD32                        = 0xBD2
+	SYS_ILOGBD64                        = 0xBD3
+	SYS_ILOGBF                          = 0xA7E
+	SYS_ILOGBL                          = 0xA81
+	SYS_INET6_IS_SRCADDR                = 0xD5A
+	SYS_ISBLANK                         = 0x0FE
+	SYS_ISWALNUM                        = 0x0FF
+	SYS_LDEXPD128                       = 0xBD7
+	SYS_LDEXPD32                        = 0xBD5
+	SYS_LDEXPD64                        = 0xBD6
+	SYS_LGAMMAD128                      = 0xBDA
+	SYS_LGAMMAD32                       = 0xBD8
+	SYS_LGAMMAD64                       = 0xBD9
+	SYS_LIO_LISTIO                      = 0xC6A
+	SYS_LLRINT                          = 0xA84
+	SYS_LLRINTD128                      = 0xBDD
+	SYS_LLRINTD32                       = 0xBDB
+	SYS_LLRINTD64                       = 0xBDC
+	SYS_LLRINTF                         = 0xA87
+	SYS_LLRINTL                         = 0xA8A
+	SYS_LLROUND                         = 0xA8D
+	SYS_LLROUNDD128                     = 0xBE0
+	SYS_LLROUNDD32                      = 0xBDE
+	SYS_LLROUNDD64                      = 0xBDF
+	SYS_LLROUNDF                        = 0xA90
+	SYS_LLROUNDL                        = 0xA93
+	SYS_LOCALTIM                        = 0x0B1
+	SYS_LOCALTIME                       = 0x0B1
+	SYS_LOCALTIME64                     = 0xCDE
+	SYS_LOCALTIME64_R                   = 0xCDF
+	SYS_LOG10D128                       = 0xBE6
+	SYS_LOG10D32                        = 0xBE4
+	SYS_LOG10D64                        = 0xBE5
+	SYS_LOG1PD128                       = 0xBE9
+	SYS_LOG1PD32                        = 0xBE7
+	SYS_LOG1PD64                        = 0xBE8
+	SYS_LOG2D128                        = 0xBEC
+	SYS_LOG2D32                         = 0xBEA
+	SYS_LOG2D64                         = 0xBEB
+	SYS_LOGBD128                        = 0xBEF
+	SYS_LOGBD32                         = 0xBED
+	SYS_LOGBD64                         = 0xBEE
+	SYS_LOGBF                           = 0xA96
+	SYS_LOGBL                           = 0xA99
+	SYS_LOGD128                         = 0xBE3
+	SYS_LOGD32                          = 0xBE1
+	SYS_LOGD64                          = 0xBE2
+	SYS_LRINT                           = 0xA9C
+	SYS_LRINTD128                       = 0xBF2
+	SYS_LRINTD32                        = 0xBF0
+	SYS_LRINTD64                        = 0xBF1
+	SYS_LRINTF                          = 0xA9F
+	SYS_LRINTL                          = 0xAA2
+	SYS_LROUNDD128                      = 0xBF5
+	SYS_LROUNDD32                       = 0xBF3
+	SYS_LROUNDD64                       = 0xBF4
+	SYS_LROUNDL                         = 0xAA5
+	SYS_MBLEN                           = 0x0AF
+	SYS_MBRTOC16                        = 0xD42
+	SYS_MBRTOC32                        = 0xD43
+	SYS_MEMSET                          = 0x0A3
+	SYS_MKTIME                          = 0x0AC
+	SYS_MKTIME64                        = 0xCE0
+	SYS_MODFD128                        = 0xBF8
+	SYS_MODFD32                         = 0xBF6
+	SYS_MODFD64                         = 0xBF7
+	SYS_NAN                             = 0xAA8
+	SYS_NAND128                         = 0xBFB
+	SYS_NAND32                          = 0xBF9
+	SYS_NAND64                          = 0xBFA
+	SYS_NANF                            = 0xAAA
+	SYS_NANL                            = 0xAAC
+	SYS_NEARBYINT                       = 0xAAE
+	SYS_NEARBYINTD128                   = 0xBFE
+	SYS_NEARBYINTD32                    = 0xBFC
+	SYS_NEARBYINTD64                    = 0xBFD
+	SYS_NEARBYINTF                      = 0xAB1
+	SYS_NEARBYINTL                      = 0xAB4
+	SYS_NEXTAFTERD128                   = 0xC01
+	SYS_NEXTAFTERD32                    = 0xBFF
+	SYS_NEXTAFTERD64                    = 0xC00
+	SYS_NEXTAFTERF                      = 0xAB7
+	SYS_NEXTAFTERL                      = 0xABA
+	SYS_NEXTTOWARD                      = 0xABD
+	SYS_NEXTTOWARDD128                  = 0xC04
+	SYS_NEXTTOWARDD32                   = 0xC02
+	SYS_NEXTTOWARDD64                   = 0xC03
+	SYS_NEXTTOWARDF                     = 0xAC0
+	SYS_NEXTTOWARDL                     = 0xAC3
+	SYS_NL_LANGINFO                     = 0x0FC
+	SYS_PERROR_UNLOCKED                 = 0xCBD
+	SYS_POSIX_FALLOCATE                 = 0xCE8
+	SYS_POSIX_MEMALIGN                  = 0xCE9
+	SYS_POSIX_OPENPT                    = 0xC66
+	SYS_POWD128                         = 0xC07
+	SYS_POWD32                          = 0xC05
+	SYS_POWD64                          = 0xC06
+	SYS_PRINTF_UNLOCKED                 = 0xCBE
+	SYS_PSELECT                         = 0xC67
+	SYS_PTHREAD_ATTR_GETSTACK           = 0xB3E
+	SYS_PTHREAD_ATTR_SETSTACK           = 0xB3F
+	SYS_PTHREAD_SECURITY_APPLID_NP      = 0xCE4
+	SYS_PUTS_UNLOCKED                   = 0xC7F
+	SYS_PUTWCHAR_UNLOCKED               = 0xCC0
+	SYS_PUTWC_UNLOCKED                  = 0xCBF
+	SYS_QUANTEXPD128                    = 0xD46
+	SYS_QUANTEXPD32                     = 0xD44
+	SYS_QUANTEXPD64                     = 0xD45
+	SYS_QUANTIZED128                    = 0xC0A
+	SYS_QUANTIZED32                     = 0xC08
+	SYS_QUANTIZED64                     = 0xC09
+	SYS_REMAINDERD128                   = 0xC0D
+	SYS_REMAINDERD32                    = 0xC0B
+	SYS_REMAINDERD64                    = 0xC0C
+	SYS_RESIZE_ALLOC                    = 0xCEB
+	SYS_REWIND_UNLOCKED                 = 0xCC1
+	SYS_RINTD128                        = 0xC13
+	SYS_RINTD32                         = 0xC11
+	SYS_RINTD64                         = 0xC12
+	SYS_RINTF                           = 0xACB
+	SYS_RINTL                           = 0xACD
+	SYS_ROUND                           = 0xACF
+	SYS_ROUNDD128                       = 0xC16
+	SYS_ROUNDD32                        = 0xC14
+	SYS_ROUNDD64                        = 0xC15
+	SYS_ROUNDF                          = 0xAD2
+	SYS_ROUNDL                          = 0xAD5
+	SYS_SAMEQUANTUMD128                 = 0xC19
+	SYS_SAMEQUANTUMD32                  = 0xC17
+	SYS_SAMEQUANTUMD64                  = 0xC18
+	SYS_SCALBLN                         = 0xAD8
+	SYS_SCALBLND128                     = 0xC1C
+	SYS_SCALBLND32                      = 0xC1A
+	SYS_SCALBLND64                      = 0xC1B
+	SYS_SCALBLNF                        = 0xADB
+	SYS_SCALBLNL                        = 0xADE
+	SYS_SCALBND128                      = 0xC1F
+	SYS_SCALBND32                       = 0xC1D
+	SYS_SCALBND64                       = 0xC1E
+	SYS_SCALBNF                         = 0xAE3
+	SYS_SCALBNL                         = 0xAE6
+	SYS_SCANF_UNLOCKED                  = 0xCC2
+	SYS_SCHED_YIELD                     = 0xB32
+	SYS_SETENV                          = 0x0C8
+	SYS_SETIPV4SOURCEFILTER             = 0xC76
+	SYS_SETSOURCEFILTER                 = 0xC78
+	SYS_SHM_OPEN                        = 0xC8C
+	SYS_SHM_UNLINK                      = 0xC8D
+	SYS_SIND128                         = 0xC22
+	SYS_SIND32                          = 0xC20
+	SYS_SIND64                          = 0xC21
+	SYS_SINHD128                        = 0xC25
+	SYS_SINHD32                         = 0xC23
+	SYS_SINHD64                         = 0xC24
+	SYS_SIZEOF_ALLOC                    = 0xCEA
+	SYS_SOCKATMARK                      = 0xC68
+	SYS_SQRTD128                        = 0xC28
+	SYS_SQRTD32                         = 0xC26
+	SYS_SQRTD64                         = 0xC27
+	SYS_STRCHR                          = 0x0A0
+	SYS_STRCSPN                         = 0x0A1
+	SYS_STRERROR                        = 0x0A8
+	SYS_STRERROR_R                      = 0xB33
+	SYS_STRFTIME                        = 0x0B2
+	SYS_STRLEN                          = 0x0A9
+	SYS_STRPBRK                         = 0x0A2
+	SYS_STRSPN                          = 0x0A4
+	SYS_STRSTR                          = 0x0A5
+	SYS_STRTOD128                       = 0xC2B
+	SYS_STRTOD32                        = 0xC29
+	SYS_STRTOD64                        = 0xC2A
+	SYS_STRTOK                          = 0x0A6
+	SYS_TAND128                         = 0xC2E
+	SYS_TAND32                          = 0xC2C
+	SYS_TAND64                          = 0xC2D
+	SYS_TANHD128                        = 0xC31
+	SYS_TANHD32                         = 0xC2F
+	SYS_TANHD64                         = 0xC30
+	SYS_TGAMMAD128                      = 0xC34
+	SYS_TGAMMAD32                       = 0xC32
+	SYS_TGAMMAD64                       = 0xC33
+	SYS_TIME                            = 0x0AD
+	SYS_TIME64                          = 0xCE1
+	SYS_TMPFILE64                       = 0xD4D
+	SYS_TMPFILE64_UNLOCKED              = 0xD4E
+	SYS_TMPFILE_UNLOCKED                = 0xCFD
+	SYS_TRUNCD128                       = 0xC40
+	SYS_TRUNCD32                        = 0xC3E
+	SYS_TRUNCD64                        = 0xC3F
+	SYS_UNGETC_UNLOCKED                 = 0xCC3
+	SYS_UNGETWC_UNLOCKED                = 0xCC4
+	SYS_UNSETENV                        = 0xB34
+	SYS_VFPRINTF_UNLOCKED               = 0xCC5
+	SYS_VFSCANF_UNLOCKED                = 0xCC7
+	SYS_VFWPRINTF_UNLOCKED              = 0xCC9
+	SYS_VFWSCANF_UNLOCKED               = 0xCCB
+	SYS_VPRINTF_UNLOCKED                = 0xCCD
+	SYS_VSCANF_UNLOCKED                 = 0xCCF
+	SYS_VWPRINTF_UNLOCKED               = 0xCD1
+	SYS_VWSCANF_UNLOCKED                = 0xCD3
+	SYS_WCSTOD128                       = 0xC43
+	SYS_WCSTOD32                        = 0xC41
+	SYS_WCSTOD64                        = 0xC42
+	SYS_WPRINTF_UNLOCKED                = 0xCD5
+	SYS_WSCANF_UNLOCKED                 = 0xCD6
+	SYS__FLUSHLBF                       = 0xD68
+	SYS__FLUSHLBF_UNLOCKED              = 0xD6F
+	SYS___ACOSHF_H                      = 0xA54
+	SYS___ACOSHL_H                      = 0xA55
+	SYS___ASINHF_H                      = 0xA56
+	SYS___ASINHL_H                      = 0xA57
+	SYS___ATANPID128                    = 0xC6D
+	SYS___ATANPID32                     = 0xC6B
+	SYS___ATANPID64                     = 0xC6C
+	SYS___CBRTF_H                       = 0xA58
+	SYS___CBRTL_H                       = 0xA59
+	SYS___CDUMP                         = 0x0C4
+	SYS___CLASS                         = 0xAFA
+	SYS___CLASS2                        = 0xB99
+	SYS___CLASS2D128                    = 0xC99
+	SYS___CLASS2D32                     = 0xC97
+	SYS___CLASS2D64                     = 0xC98
+	SYS___CLASS2F                       = 0xC91
+	SYS___CLASS2F_B                     = 0xC93
+	SYS___CLASS2F_H                     = 0xC94
+	SYS___CLASS2L                       = 0xC92
+	SYS___CLASS2L_B                     = 0xC95
+	SYS___CLASS2L_H                     = 0xC96
+	SYS___CLASS2_B                      = 0xB9A
+	SYS___CLASS2_H                      = 0xB9B
+	SYS___CLASS_B                       = 0xAFB
+	SYS___CLASS_H                       = 0xAFC
+	SYS___CLOGL_B                       = 0xA01
+	SYS___CLOGL_H                       = 0xA02
+	SYS___CLRENV                        = 0x0C9
+	SYS___CLRMF                         = 0x0BD
+	SYS___CODEPAGE_INFO                 = 0xC64
+	SYS___CONJF_B                       = 0xA07
+	SYS___CONJF_H                       = 0xA08
+	SYS___CONJL_B                       = 0xA0A
+	SYS___CONJL_H                       = 0xA0B
+	SYS___CONJ_B                        = 0xA04
+	SYS___CONJ_H                        = 0xA05
+	SYS___COPYSIGN_B                    = 0xA5A
+	SYS___COPYSIGN_H                    = 0xAF5
+	SYS___COSPID128                     = 0xC70
+	SYS___COSPID32                      = 0xC6E
+	SYS___COSPID64                      = 0xC6F
+	SYS___CPOWF_B                       = 0xA10
+	SYS___CPOWF_H                       = 0xA11
+	SYS___CPOWL_B                       = 0xA13
+	SYS___CPOWL_H                       = 0xA14
+	SYS___CPOW_B                        = 0xA0D
+	SYS___CPOW_H                        = 0xA0E
+	SYS___CPROJF_B                      = 0xA19
+	SYS___CPROJF_H                      = 0xA1A
+	SYS___CPROJL_B                      = 0xA1C
+	SYS___CPROJL_H                      = 0xA1D
+	SYS___CPROJ_B                       = 0xA16
+	SYS___CPROJ_H                       = 0xA17
+	SYS___CREALF_B                      = 0xA22
+	SYS___CREALF_H                      = 0xA23
+	SYS___CREALL_B                      = 0xA25
+	SYS___CREALL_H                      = 0xA26
+	SYS___CREAL_B                       = 0xA1F
+	SYS___CREAL_H                       = 0xA20
+	SYS___CSINF_B                       = 0xA2B
+	SYS___CSINF_H                       = 0xA2C
+	SYS___CSINHF_B                      = 0xA34
+	SYS___CSINHF_H                      = 0xA35
+	SYS___CSINHL_B                      = 0xA37
+	SYS___CSINHL_H                      = 0xA38
+	SYS___CSINH_B                       = 0xA31
+	SYS___CSINH_H                       = 0xA32
+	SYS___CSINL_B                       = 0xA2E
+	SYS___CSINL_H                       = 0xA2F
+	SYS___CSIN_B                        = 0xA28
+	SYS___CSIN_H                        = 0xA29
+	SYS___CSNAP                         = 0x0C5
+	SYS___CSQRTF_B                      = 0xA3D
+	SYS___CSQRTF_H                      = 0xA3E
+	SYS___CSQRTL_B                      = 0xA40
+	SYS___CSQRTL_H                      = 0xA41
+	SYS___CSQRT_B                       = 0xA3A
+	SYS___CSQRT_H                       = 0xA3B
+	SYS___CTANF_B                       = 0xA46
+	SYS___CTANF_H                       = 0xA47
+	SYS___CTANHF_B                      = 0xA4F
+	SYS___CTANHF_H                      = 0xA50
+	SYS___CTANHL_B                      = 0xA52
+	SYS___CTANHL_H                      = 0xA53
+	SYS___CTANH_B                       = 0xA4C
+	SYS___CTANH_H                       = 0xA4D
+	SYS___CTANL_B                       = 0xA49
+	SYS___CTANL_H                       = 0xA4A
+	SYS___CTAN_B                        = 0xA43
+	SYS___CTAN_H                        = 0xA44
+	SYS___CTEST                         = 0x0C7
+	SYS___CTRACE                        = 0x0C6
+	SYS___D1TOP                         = 0xC9B
+	SYS___D2TOP                         = 0xC9C
+	SYS___D4TOP                         = 0xC9D
+	SYS___DYNALL                        = 0x0C3
+	SYS___DYNFRE                        = 0x0C2
+	SYS___EXP2F_H                       = 0xA5E
+	SYS___EXP2L_H                       = 0xA5F
+	SYS___EXP2_H                        = 0xA5D
+	SYS___EXPM1F_H                      = 0xA5B
+	SYS___EXPM1L_H                      = 0xA5C
+	SYS___FBUFSIZE                      = 0xD60
+	SYS___FLBF                          = 0xD62
+	SYS___FLDATA                        = 0x0C1
+	SYS___FMAF_B                        = 0xA67
+	SYS___FMAF_H                        = 0xA68
+	SYS___FMAL_B                        = 0xA6A
+	SYS___FMAL_H                        = 0xA6B
+	SYS___FMAXF_B                       = 0xA70
+	SYS___FMAXF_H                       = 0xA71
+	SYS___FMAXL_B                       = 0xA73
+	SYS___FMAXL_H                       = 0xA74
+	SYS___FMAX_B                        = 0xA6D
+	SYS___FMAX_H                        = 0xA6E
+	SYS___FMA_B                         = 0xA64
+	SYS___FMA_H                         = 0xA65
+	SYS___FMINF_B                       = 0xA79
+	SYS___FMINF_H                       = 0xA7A
+	SYS___FMINL_B                       = 0xA7C
+	SYS___FMINL_H                       = 0xA7D
+	SYS___FMIN_B                        = 0xA76
+	SYS___FMIN_H                        = 0xA77
+	SYS___FPENDING                      = 0xD61
+	SYS___FPENDING_UNLOCKED             = 0xD6C
+	SYS___FPURGE                        = 0xD69
+	SYS___FPURGE_UNLOCKED               = 0xD70
+	SYS___FP_CAST_D                     = 0xBCB
+	SYS___FREADABLE                     = 0xD63
+	SYS___FREADAHEAD                    = 0xD6A
+	SYS___FREADAHEAD_UNLOCKED           = 0xD71
+	SYS___FREADING                      = 0xD65
+	SYS___FREADING_UNLOCKED             = 0xD6D
+	SYS___FSEEK2                        = 0xB3C
+	SYS___FSETERR                       = 0xD6B
+	SYS___FSETLOCKING                   = 0xD67
+	SYS___FTCHEP                        = 0x0BF
+	SYS___FTELL2                        = 0xB3B
+	SYS___FUPDT                         = 0x0B5
+	SYS___FWRITABLE                     = 0xD64
+	SYS___FWRITING                      = 0xD66
+	SYS___FWRITING_UNLOCKED             = 0xD6E
+	SYS___GETCB                         = 0x0B4
+	SYS___GETGRGID1                     = 0xD5B
+	SYS___GETGRNAM1                     = 0xD5C
+	SYS___GETTHENT                      = 0xCE5
+	SYS___GETTOD                        = 0xD3E
+	SYS___HYPOTF_H                      = 0xAF6
+	SYS___HYPOTL_H                      = 0xAF7
+	SYS___ILOGBF_B                      = 0xA7F
+	SYS___ILOGBF_H                      = 0xA80
+	SYS___ILOGBL_B                      = 0xA82
+	SYS___ILOGBL_H                      = 0xA83
+	SYS___ISBLANK_A                     = 0xB2E
+	SYS___ISBLNK                        = 0x0FE
+	SYS___ISWBLANK_A                    = 0xB2F
+	SYS___LE_CEEGTJS                    = 0xD72
+	SYS___LE_TRACEBACK                  = 0xB7A
+	SYS___LGAMMAL_H                     = 0xA62
+	SYS___LGAMMA_B_C99                  = 0xB39
+	SYS___LGAMMA_H_C99                  = 0xB38
+	SYS___LGAMMA_R_C99                  = 0xB3A
+	SYS___LLRINTF_B                     = 0xA88
+	SYS___LLRINTF_H                     = 0xA89
+	SYS___LLRINTL_B                     = 0xA8B
+	SYS___LLRINTL_H                     = 0xA8C
+	SYS___LLRINT_B                      = 0xA85
+	SYS___LLRINT_H                      = 0xA86
+	SYS___LLROUNDF_B                    = 0xA91
+	SYS___LLROUNDF_H                    = 0xA92
+	SYS___LLROUNDL_B                    = 0xA94
+	SYS___LLROUNDL_H                    = 0xA95
+	SYS___LLROUND_B                     = 0xA8E
+	SYS___LLROUND_H                     = 0xA8F
+	SYS___LOCALE_CTL                    = 0xD47
+	SYS___LOG1PF_H                      = 0xA60
+	SYS___LOG1PL_H                      = 0xA61
+	SYS___LOGBF_B                       = 0xA97
+	SYS___LOGBF_H                       = 0xA98
+	SYS___LOGBL_B                       = 0xA9A
+	SYS___LOGBL_H                       = 0xA9B
+	SYS___LOGIN_APPLID                  = 0xCE2
+	SYS___LRINTF_B                      = 0xAA0
+	SYS___LRINTF_H                      = 0xAA1
+	SYS___LRINTL_B                      = 0xAA3
+	SYS___LRINTL_H                      = 0xAA4
+	SYS___LRINT_B                       = 0xA9D
+	SYS___LRINT_H                       = 0xA9E
+	SYS___LROUNDF_FIXUP                 = 0xB31
+	SYS___LROUNDL_B                     = 0xAA6
+	SYS___LROUNDL_H                     = 0xAA7
+	SYS___LROUND_FIXUP                  = 0xB30
+	SYS___MOSERVICES                    = 0xD3D
+	SYS___MUST_STAY_CLEAN               = 0xB7C
+	SYS___NANF_B                        = 0xAAB
+	SYS___NANL_B                        = 0xAAD
+	SYS___NAN_B                         = 0xAA9
+	SYS___NEARBYINTF_B                  = 0xAB2
+	SYS___NEARBYINTF_H                  = 0xAB3
+	SYS___NEARBYINTL_B                  = 0xAB5
+	SYS___NEARBYINTL_H                  = 0xAB6
+	SYS___NEARBYINT_B                   = 0xAAF
+	SYS___NEARBYINT_H                   = 0xAB0
+	SYS___NEXTAFTERF_B                  = 0xAB8
+	SYS___NEXTAFTERF_H                  = 0xAB9
+	SYS___NEXTAFTERL_B                  = 0xABB
+	SYS___NEXTAFTERL_H                  = 0xABC
+	SYS___NEXTTOWARDF_B                 = 0xAC1
+	SYS___NEXTTOWARDF_H                 = 0xAC2
+	SYS___NEXTTOWARDL_B                 = 0xAC4
+	SYS___NEXTTOWARDL_H                 = 0xAC5
+	SYS___NEXTTOWARD_B                  = 0xABE
+	SYS___NEXTTOWARD_H                  = 0xABF
+	SYS___O_ENV                         = 0xB7D
+	SYS___PASSWD_APPLID                 = 0xCE3
+	SYS___PTOD1                         = 0xC9E
+	SYS___PTOD2                         = 0xC9F
+	SYS___PTOD4                         = 0xCA0
+	SYS___REGCOMP_STD                   = 0x0EA
+	SYS___REMAINDERF_H                  = 0xAC6
+	SYS___REMAINDERL_H                  = 0xAC7
+	SYS___REMQUOD128                    = 0xC10
+	SYS___REMQUOD32                     = 0xC0E
+	SYS___REMQUOD64                     = 0xC0F
+	SYS___REMQUOF_H                     = 0xAC9
+	SYS___REMQUOL_H                     = 0xACA
+	SYS___REMQUO_H                      = 0xAC8
+	SYS___RINTF_B                       = 0xACC
+	SYS___RINTL_B                       = 0xACE
+	SYS___ROUNDF_B                      = 0xAD3
+	SYS___ROUNDF_H                      = 0xAD4
+	SYS___ROUNDL_B                      = 0xAD6
+	SYS___ROUNDL_H                      = 0xAD7
+	SYS___ROUND_B                       = 0xAD0
+	SYS___ROUND_H                       = 0xAD1
+	SYS___SCALBLNF_B                    = 0xADC
+	SYS___SCALBLNF_H                    = 0xADD
+	SYS___SCALBLNL_B                    = 0xADF
+	SYS___SCALBLNL_H                    = 0xAE0
+	SYS___SCALBLN_B                     = 0xAD9
+	SYS___SCALBLN_H                     = 0xADA
+	SYS___SCALBNF_B                     = 0xAE4
+	SYS___SCALBNF_H                     = 0xAE5
+	SYS___SCALBNL_B                     = 0xAE7
+	SYS___SCALBNL_H                     = 0xAE8
+	SYS___SCALBN_B                      = 0xAE1
+	SYS___SCALBN_H                      = 0xAE2
+	SYS___SETENV                        = 0x0C8
+	SYS___SINPID128                     = 0xC73
+	SYS___SINPID32                      = 0xC71
+	SYS___SINPID64                      = 0xC72
+	SYS___SMF_RECORD2                   = 0xD48
+	SYS___STATIC_REINIT                 = 0xB3D
+	SYS___TGAMMAF_H_C99                 = 0xB79
+	SYS___TGAMMAL_H                     = 0xAE9
+	SYS___TGAMMA_H_C99                  = 0xB78
+	SYS___TOCSNAME2                     = 0xC9A
+	SYS_CEIL                            = 0x01F
+	SYS_CHAUDIT                         = 0x1E0
+	SYS_EXP                             = 0x01A
+	SYS_FCHAUDIT                        = 0x1E1
+	SYS_FREXP                           = 0x01D
+	SYS_GETGROUPSBYNAME                 = 0x1E2
+	SYS_GETPWUID                        = 0x1A0
+	SYS_GETUID                          = 0x1A1
+	SYS_ISATTY                          = 0x1A3
+	SYS_KILL                            = 0x1A4
+	SYS_LDEXP                           = 0x01E
+	SYS_LINK                            = 0x1A5
+	SYS_LOG10                           = 0x01C
+	SYS_LSEEK                           = 0x1A6
+	SYS_LSTAT                           = 0x1A7
+	SYS_MKDIR                           = 0x1A8
+	SYS_MKFIFO                          = 0x1A9
+	SYS_MKNOD                           = 0x1AA
+	SYS_MODF                            = 0x01B
+	SYS_MOUNT                           = 0x1AB
+	SYS_OPEN                            = 0x1AC
+	SYS_OPENDIR                         = 0x1AD
+	SYS_PATHCONF                        = 0x1AE
+	SYS_PAUSE                           = 0x1AF
+	SYS_PIPE                            = 0x1B0
+	SYS_PTHREAD_ATTR_DESTROY            = 0x1E7
+	SYS_PTHREAD_ATTR_GETDETACHSTATE     = 0x1EB
+	SYS_PTHREAD_ATTR_GETSTACKSIZE       = 0x1E9
+	SYS_PTHREAD_ATTR_GETWEIGHT_NP       = 0x1ED
+	SYS_PTHREAD_ATTR_INIT               = 0x1E6
+	SYS_PTHREAD_ATTR_SETDETACHSTATE     = 0x1EA
+	SYS_PTHREAD_ATTR_SETSTACKSIZE       = 0x1E8
+	SYS_PTHREAD_ATTR_SETWEIGHT_NP       = 0x1EC
+	SYS_PTHREAD_CANCEL                  = 0x1EE
+	SYS_PTHREAD_CLEANUP_POP             = 0x1F0
+	SYS_PTHREAD_CLEANUP_PUSH            = 0x1EF
+	SYS_PTHREAD_CONDATTR_DESTROY        = 0x1F2
+	SYS_PTHREAD_CONDATTR_INIT           = 0x1F1
+	SYS_PTHREAD_COND_BROADCAST          = 0x1F6
+	SYS_PTHREAD_COND_DESTROY            = 0x1F4
+	SYS_PTHREAD_COND_INIT               = 0x1F3
+	SYS_PTHREAD_COND_SIGNAL             = 0x1F5
+	SYS_PTHREAD_COND_TIMEDWAIT          = 0x1F8
+	SYS_PTHREAD_COND_WAIT               = 0x1F7
+	SYS_PTHREAD_CREATE                  = 0x1F9
+	SYS_PTHREAD_DETACH                  = 0x1FA
+	SYS_PTHREAD_EQUAL                   = 0x1FB
+	SYS_PTHREAD_EXIT                    = 0x1E4
+	SYS_PTHREAD_GETSPECIFIC             = 0x1FC
+	SYS_PTHREAD_JOIN                    = 0x1FD
+	SYS_PTHREAD_KEY_CREATE              = 0x1FE
+	SYS_PTHREAD_KILL                    = 0x1E5
+	SYS_PTHREAD_MUTEXATTR_INIT          = 0x1FF
+	SYS_READ                            = 0x1B2
+	SYS_READDIR                         = 0x1B3
+	SYS_READLINK                        = 0x1B4
+	SYS_REWINDDIR                       = 0x1B5
+	SYS_RMDIR                           = 0x1B6
+	SYS_SETEGID                         = 0x1B7
+	SYS_SETEUID                         = 0x1B8
+	SYS_SETGID                          = 0x1B9
+	SYS_SETPGID                         = 0x1BA
+	SYS_SETSID                          = 0x1BB
+	SYS_SETUID                          = 0x1BC
+	SYS_SIGACTION                       = 0x1BD
+	SYS_SIGADDSET                       = 0x1BE
+	SYS_SIGDELSET                       = 0x1BF
+	SYS_SIGEMPTYSET                     = 0x1C0
+	SYS_SIGFILLSET                      = 0x1C1
+	SYS_SIGISMEMBER                     = 0x1C2
+	SYS_SIGLONGJMP                      = 0x1C3
+	SYS_SIGPENDING                      = 0x1C4
+	SYS_SIGPROCMASK                     = 0x1C5
+	SYS_SIGSETJMP                       = 0x1C6
+	SYS_SIGSUSPEND                      = 0x1C7
+	SYS_SIGWAIT                         = 0x1E3
+	SYS_SLEEP                           = 0x1C8
+	SYS_STAT                            = 0x1C9
+	SYS_SYMLINK                         = 0x1CB
+	SYS_SYSCONF                         = 0x1CC
+	SYS_TCDRAIN                         = 0x1CD
+	SYS_TCFLOW                          = 0x1CE
+	SYS_TCFLUSH                         = 0x1CF
+	SYS_TCGETATTR                       = 0x1D0
+	SYS_TCGETPGRP                       = 0x1D1
+	SYS_TCSENDBREAK                     = 0x1D2
+	SYS_TCSETATTR                       = 0x1D3
+	SYS_TCSETPGRP                       = 0x1D4
+	SYS_TIMES                           = 0x1D5
+	SYS_TTYNAME                         = 0x1D6
+	SYS_TZSET                           = 0x1D7
+	SYS_UMASK                           = 0x1D8
+	SYS_UMOUNT                          = 0x1D9
+	SYS_UNAME                           = 0x1DA
+	SYS_UNLINK                          = 0x1DB
+	SYS_UTIME                           = 0x1DC
+	SYS_WAIT                            = 0x1DD
+	SYS_WAITPID                         = 0x1DE
+	SYS_WRITE                           = 0x1DF
+	SYS_W_GETPSENT                      = 0x1B1
+	SYS_W_IOCTL                         = 0x1A2
+	SYS_W_STATFS                        = 0x1CA
+	SYS_A64L                            = 0x2EF
+	SYS_BCMP                            = 0x2B9
+	SYS_BCOPY                           = 0x2BA
+	SYS_BZERO                           = 0x2BB
+	SYS_CATCLOSE                        = 0x2B6
+	SYS_CATGETS                         = 0x2B7
+	SYS_CATOPEN                         = 0x2B8
+	SYS_CRYPT                           = 0x2AC
+	SYS_DBM_CLEARERR                    = 0x2F7
+	SYS_DBM_CLOSE                       = 0x2F8
+	SYS_DBM_DELETE                      = 0x2F9
+	SYS_DBM_ERROR                       = 0x2FA
+	SYS_DBM_FETCH                       = 0x2FB
+	SYS_DBM_FIRSTKEY                    = 0x2FC
+	SYS_DBM_NEXTKEY                     = 0x2FD
+	SYS_DBM_OPEN                        = 0x2FE
+	SYS_DBM_STORE                       = 0x2FF
+	SYS_DRAND48                         = 0x2B2
+	SYS_ENCRYPT                         = 0x2AD
+	SYS_ENDUTXENT                       = 0x2E1
+	SYS_ERAND48                         = 0x2B3
+	SYS_ERF                             = 0x02C
+	SYS_ERFC                            = 0x02D
+	SYS_FCHDIR                          = 0x2D9
+	SYS_FFS                             = 0x2BC
+	SYS_FMTMSG                          = 0x2E5
+	SYS_FSTATVFS                        = 0x2B4
+	SYS_FTIME                           = 0x2F5
+	SYS_GAMMA                           = 0x02E
+	SYS_GETDATE                         = 0x2A6
+	SYS_GETPAGESIZE                     = 0x2D8
+	SYS_GETTIMEOFDAY                    = 0x2F6
+	SYS_GETUTXENT                       = 0x2E0
+	SYS_GETUTXID                        = 0x2E2
+	SYS_GETUTXLINE                      = 0x2E3
+	SYS_HCREATE                         = 0x2C6
+	SYS_HDESTROY                        = 0x2C7
+	SYS_HSEARCH                         = 0x2C8
+	SYS_HYPOT                           = 0x02B
+	SYS_INDEX                           = 0x2BD
+	SYS_INITSTATE                       = 0x2C2
+	SYS_INSQUE                          = 0x2CF
+	SYS_ISASCII                         = 0x2ED
+	SYS_JRAND48                         = 0x2E6
+	SYS_L64A                            = 0x2F0
+	SYS_LCONG48                         = 0x2EA
+	SYS_LFIND                           = 0x2C9
+	SYS_LRAND48                         = 0x2E7
+	SYS_LSEARCH                         = 0x2CA
+	SYS_MEMCCPY                         = 0x2D4
+	SYS_MRAND48                         = 0x2E8
+	SYS_NRAND48                         = 0x2E9
+	SYS_PCLOSE                          = 0x2D2
+	SYS_POPEN                           = 0x2D1
+	SYS_PUTUTXLINE                      = 0x2E4
+	SYS_RANDOM                          = 0x2C4
+	SYS_REMQUE                          = 0x2D0
+	SYS_RINDEX                          = 0x2BE
+	SYS_SEED48                          = 0x2EC
+	SYS_SETKEY                          = 0x2AE
+	SYS_SETSTATE                        = 0x2C3
+	SYS_SETUTXENT                       = 0x2DF
+	SYS_SRAND48                         = 0x2EB
+	SYS_SRANDOM                         = 0x2C5
+	SYS_STATVFS                         = 0x2B5
+	SYS_STRCASECMP                      = 0x2BF
+	SYS_STRDUP                          = 0x2C0
+	SYS_STRNCASECMP                     = 0x2C1
+	SYS_SWAB                            = 0x2D3
+	SYS_TDELETE                         = 0x2CB
+	SYS_TFIND                           = 0x2CC
+	SYS_TOASCII                         = 0x2EE
+	SYS_TSEARCH                         = 0x2CD
+	SYS_TWALK                           = 0x2CE
+	SYS_UALARM                          = 0x2F1
+	SYS_USLEEP                          = 0x2F2
+	SYS_WAIT3                           = 0x2A7
+	SYS_WAITID                          = 0x2A8
+	SYS_Y1                              = 0x02A
+	SYS___ATOE                          = 0x2DB
+	SYS___ATOE_L                        = 0x2DC
+	SYS___CATTRM                        = 0x2A9
+	SYS___CNVBLK                        = 0x2AF
+	SYS___CRYTRM                        = 0x2B0
+	SYS___DLGHT                         = 0x2A1
+	SYS___ECRTRM                        = 0x2B1
+	SYS___ETOA                          = 0x2DD
+	SYS___ETOA_L                        = 0x2DE
+	SYS___GDTRM                         = 0x2AA
+	SYS___OCLCK                         = 0x2DA
+	SYS___OPARGF                        = 0x2A2
+	SYS___OPERRF                        = 0x2A5
+	SYS___OPINDF                        = 0x2A4
+	SYS___OPOPTF                        = 0x2A3
+	SYS___RNDTRM                        = 0x2AB
+	SYS___SRCTRM                        = 0x2F4
+	SYS___TZONE                         = 0x2A0
+	SYS___UTXTRM                        = 0x2F3
+	SYS_ASIN                            = 0x03E
+	SYS_ISXDIGIT                        = 0x03B
+	SYS_SETLOCAL                        = 0x03A
+	SYS_SETLOCALE                       = 0x03A
+	SYS_SIN                             = 0x03F
+	SYS_TOLOWER                         = 0x03C
+	SYS_TOUPPER                         = 0x03D
+	SYS_ACCEPT_AND_RECV                 = 0x4F7
+	SYS_ATOL                            = 0x04E
+	SYS_CHECKSCH                        = 0x4BC
+	SYS_CHECKSCHENV                     = 0x4BC
+	SYS_CLEARERR                        = 0x04C
+	SYS_CONNECTS                        = 0x4B5
+	SYS_CONNECTSERVER                   = 0x4B5
+	SYS_CONNECTW                        = 0x4B4
+	SYS_CONNECTWORKMGR                  = 0x4B4
+	SYS_CONTINUE                        = 0x4B3
+	SYS_CONTINUEWORKUNIT                = 0x4B3
+	SYS_COPYSIGN                        = 0x4C2
+	SYS_CREATEWO                        = 0x4B2
+	SYS_CREATEWORKUNIT                  = 0x4B2
+	SYS_DELETEWO                        = 0x4B9
+	SYS_DELETEWORKUNIT                  = 0x4B9
+	SYS_DISCONNE                        = 0x4B6
+	SYS_DISCONNECTSERVER                = 0x4B6
+	SYS_FEOF                            = 0x04D
+	SYS_FERROR                          = 0x04A
+	SYS_FINITE                          = 0x4C8
+	SYS_GAMMA_R                         = 0x4E2
+	SYS_JOINWORK                        = 0x4B7
+	SYS_JOINWORKUNIT                    = 0x4B7
+	SYS_LEAVEWOR                        = 0x4B8
+	SYS_LEAVEWORKUNIT                   = 0x4B8
+	SYS_LGAMMA_R                        = 0x4EB
+	SYS_MATHERR                         = 0x4D0
+	SYS_PERROR                          = 0x04F
+	SYS_QUERYMET                        = 0x4BA
+	SYS_QUERYMETRICS                    = 0x4BA
+	SYS_QUERYSCH                        = 0x4BB
+	SYS_QUERYSCHENV                     = 0x4BB
+	SYS_REWIND                          = 0x04B
+	SYS_SCALBN                          = 0x4D4
+	SYS_SIGNIFIC                        = 0x4D5
+	SYS_SIGNIFICAND                     = 0x4D5
+	SYS___ACOSH_B                       = 0x4DA
+	SYS___ACOS_B                        = 0x4D9
+	SYS___ASINH_B                       = 0x4BE
+	SYS___ASIN_B                        = 0x4DB
+	SYS___ATAN2_B                       = 0x4DC
+	SYS___ATANH_B                       = 0x4DD
+	SYS___ATAN_B                        = 0x4BF
+	SYS___CBRT_B                        = 0x4C0
+	SYS___CEIL_B                        = 0x4C1
+	SYS___COSH_B                        = 0x4DE
+	SYS___COS_B                         = 0x4C3
+	SYS___DGHT                          = 0x4A8
+	SYS___ENVN                          = 0x4B0
+	SYS___ERFC_B                        = 0x4C5
+	SYS___ERF_B                         = 0x4C4
+	SYS___EXPM1_B                       = 0x4C6
+	SYS___EXP_B                         = 0x4DF
+	SYS___FABS_B                        = 0x4C7
+	SYS___FLOOR_B                       = 0x4C9
+	SYS___FMOD_B                        = 0x4E0
+	SYS___FP_SETMODE                    = 0x4F8
+	SYS___FREXP_B                       = 0x4CA
+	SYS___GAMMA_B                       = 0x4E1
+	SYS___GDRR                          = 0x4A1
+	SYS___HRRNO                         = 0x4A2
+	SYS___HYPOT_B                       = 0x4E3
+	SYS___ILOGB_B                       = 0x4CB
+	SYS___ISNAN_B                       = 0x4CC
+	SYS___J0_B                          = 0x4E4
+	SYS___J1_B                          = 0x4E6
+	SYS___JN_B                          = 0x4E8
+	SYS___LDEXP_B                       = 0x4CD
+	SYS___LGAMMA_B                      = 0x4EA
+	SYS___LOG10_B                       = 0x4ED
+	SYS___LOG1P_B                       = 0x4CE
+	SYS___LOGB_B                        = 0x4CF
+	SYS___LOGIN                         = 0x4F5
+	SYS___LOG_B                         = 0x4EC
+	SYS___MLOCKALL                      = 0x4B1
+	SYS___MODF_B                        = 0x4D1
+	SYS___NEXTAFTER_B                   = 0x4D2
+	SYS___OPENDIR2                      = 0x4F3
+	SYS___OPEN_STAT                     = 0x4F6
+	SYS___OPND                          = 0x4A5
+	SYS___OPPT                          = 0x4A6
+	SYS___OPRG                          = 0x4A3
+	SYS___OPRR                          = 0x4A4
+	SYS___PID_AFFINITY                  = 0x4BD
+	SYS___POW_B                         = 0x4EE
+	SYS___READDIR2                      = 0x4F4
+	SYS___REMAINDER_B                   = 0x4EF
+	SYS___RINT_B                        = 0x4D3
+	SYS___SCALB_B                       = 0x4F0
+	SYS___SIGACTIONSET                  = 0x4FB
+	SYS___SIGGM                         = 0x4A7
+	SYS___SINH_B                        = 0x4F1
+	SYS___SIN_B                         = 0x4D6
+	SYS___SQRT_B                        = 0x4F2
+	SYS___TANH_B                        = 0x4D8
+	SYS___TAN_B                         = 0x4D7
+	SYS___TRRNO                         = 0x4AF
+	SYS___TZNE                          = 0x4A9
+	SYS___TZZN                          = 0x4AA
+	SYS___UCREATE                       = 0x4FC
+	SYS___UFREE                         = 0x4FE
+	SYS___UHEAPREPORT                   = 0x4FF
+	SYS___UMALLOC                       = 0x4FD
+	SYS___Y0_B                          = 0x4E5
+	SYS___Y1_B                          = 0x4E7
+	SYS___YN_B                          = 0x4E9
+	SYS_ABORT                           = 0x05C
+	SYS_ASCTIME_R                       = 0x5E0
+	SYS_ATEXIT                          = 0x05D
+	SYS_CONNECTE                        = 0x5AE
+	SYS_CONNECTEXPORTIMPORT             = 0x5AE
+	SYS_CTIME_R                         = 0x5E1
+	SYS_DN_COMP                         = 0x5DF
+	SYS_DN_EXPAND                       = 0x5DD
+	SYS_DN_SKIPNAME                     = 0x5DE
+	SYS_EXIT                            = 0x05A
+	SYS_EXPORTWO                        = 0x5A1
+	SYS_EXPORTWORKUNIT                  = 0x5A1
+	SYS_EXTRACTW                        = 0x5A5
+	SYS_EXTRACTWORKUNIT                 = 0x5A5
+	SYS_FSEEKO                          = 0x5C9
+	SYS_FTELLO                          = 0x5C8
+	SYS_GETGRGID_R                      = 0x5E7
+	SYS_GETGRNAM_R                      = 0x5E8
+	SYS_GETLOGIN_R                      = 0x5E9
+	SYS_GETPWNAM_R                      = 0x5EA
+	SYS_GETPWUID_R                      = 0x5EB
+	SYS_GMTIME_R                        = 0x5E2
+	SYS_IMPORTWO                        = 0x5A3
+	SYS_IMPORTWORKUNIT                  = 0x5A3
+	SYS_INET_NTOP                       = 0x5D3
+	SYS_INET_PTON                       = 0x5D4
+	SYS_LLABS                           = 0x5CE
+	SYS_LLDIV                           = 0x5CB
+	SYS_LOCALTIME_R                     = 0x5E3
+	SYS_PTHREAD_ATFORK                  = 0x5ED
+	SYS_PTHREAD_ATTR_GETDETACHSTATE_U98 = 0x5FB
+	SYS_PTHREAD_ATTR_GETGUARDSIZE       = 0x5EE
+	SYS_PTHREAD_ATTR_GETSCHEDPARAM      = 0x5F9
+	SYS_PTHREAD_ATTR_GETSTACKADDR       = 0x5EF
+	SYS_PTHREAD_ATTR_SETDETACHSTATE_U98 = 0x5FC
+	SYS_PTHREAD_ATTR_SETGUARDSIZE       = 0x5F0
+	SYS_PTHREAD_ATTR_SETSCHEDPARAM      = 0x5FA
+	SYS_PTHREAD_ATTR_SETSTACKADDR       = 0x5F1
+	SYS_PTHREAD_CONDATTR_GETPSHARED     = 0x5F2
+	SYS_PTHREAD_CONDATTR_SETPSHARED     = 0x5F3
+	SYS_PTHREAD_DETACH_U98              = 0x5FD
+	SYS_PTHREAD_GETCONCURRENCY          = 0x5F4
+	SYS_PTHREAD_GETSPECIFIC_U98         = 0x5FE
+	SYS_PTHREAD_KEY_DELETE              = 0x5F5
+	SYS_PTHREAD_SETCANCELSTATE          = 0x5FF
+	SYS_PTHREAD_SETCONCURRENCY          = 0x5F6
+	SYS_PTHREAD_SIGMASK                 = 0x5F7
+	SYS_QUERYENC                        = 0x5AD
+	SYS_QUERYWORKUNITCLASSIFICATION     = 0x5AD
+	SYS_RAISE                           = 0x05E
+	SYS_RAND_R                          = 0x5E4
+	SYS_READDIR_R                       = 0x5E6
+	SYS_REALLOC                         = 0x05B
+	SYS_RES_INIT                        = 0x5D8
+	SYS_RES_MKQUERY                     = 0x5D7
+	SYS_RES_QUERY                       = 0x5D9
+	SYS_RES_QUERYDOMAIN                 = 0x5DC
+	SYS_RES_SEARCH                      = 0x5DA
+	SYS_RES_SEND                        = 0x5DB
+	SYS_SETJMP                          = 0x05F
+	SYS_SIGQUEUE                        = 0x5A9
+	SYS_STRTOK_R                        = 0x5E5
+	SYS_STRTOLL                         = 0x5B0
+	SYS_STRTOULL                        = 0x5B1
+	SYS_TTYNAME_R                       = 0x5EC
+	SYS_UNDOEXPO                        = 0x5A2
+	SYS_UNDOEXPORTWORKUNIT              = 0x5A2
+	SYS_UNDOIMPO                        = 0x5A4
+	SYS_UNDOIMPORTWORKUNIT              = 0x5A4
+	SYS_WCSTOLL                         = 0x5CC
+	SYS_WCSTOULL                        = 0x5CD
+	SYS___ABORT                         = 0x05C
+	SYS___CONSOLE2                      = 0x5D2
+	SYS___CPL                           = 0x5A6
+	SYS___DISCARDDATA                   = 0x5F8
+	SYS___DSA_PREV                      = 0x5B2
+	SYS___EP_FIND                       = 0x5B3
+	SYS___FP_SWAPMODE                   = 0x5AF
+	SYS___GETUSERID                     = 0x5AB
+	SYS___GET_CPUID                     = 0x5B9
+	SYS___GET_SYSTEM_SETTINGS           = 0x5BA
+	SYS___IPDOMAINNAME                  = 0x5AC
+	SYS___MAP_INIT                      = 0x5A7
+	SYS___MAP_SERVICE                   = 0x5A8
+	SYS___MOUNT                         = 0x5AA
+	SYS___MSGRCV_TIMED                  = 0x5B7
+	SYS___RES                           = 0x5D6
+	SYS___SEMOP_TIMED                   = 0x5B8
+	SYS___SERVER_THREADS_QUERY          = 0x5B4
+	SYS_FPRINTF                         = 0x06D
+	SYS_FSCANF                          = 0x06A
+	SYS_PRINTF                          = 0x06F
+	SYS_SETBUF                          = 0x06B
+	SYS_SETVBUF                         = 0x06C
+	SYS_SSCANF                          = 0x06E
+	SYS___CATGETS_A                     = 0x6C0
+	SYS___CHAUDIT_A                     = 0x6F4
+	SYS___CHMOD_A                       = 0x6E8
+	SYS___COLLATE_INIT_A                = 0x6AC
+	SYS___CREAT_A                       = 0x6F6
+	SYS___CTYPE_INIT_A                  = 0x6AF
+	SYS___DLLLOAD_A                     = 0x6DF
+	SYS___DLLQUERYFN_A                  = 0x6E0
+	SYS___DLLQUERYVAR_A                 = 0x6E1
+	SYS___E2A_L                         = 0x6E3
+	SYS___EXECLE_A                      = 0x6A0
+	SYS___EXECLP_A                      = 0x6A4
+	SYS___EXECVE_A                      = 0x6C1
+	SYS___EXECVP_A                      = 0x6C2
+	SYS___EXECV_A                       = 0x6B1
+	SYS___FPRINTF_A                     = 0x6FA
+	SYS___GETADDRINFO_A                 = 0x6BF
+	SYS___GETNAMEINFO_A                 = 0x6C4
+	SYS___GET_WCTYPE_STD_A              = 0x6AE
+	SYS___ICONV_OPEN_A                  = 0x6DE
+	SYS___IF_INDEXTONAME_A              = 0x6DC
+	SYS___IF_NAMETOINDEX_A              = 0x6DB
+	SYS___ISWCTYPE_A                    = 0x6B0
+	SYS___IS_WCTYPE_STD_A               = 0x6B2
+	SYS___LOCALECONV_A                  = 0x6B8
+	SYS___LOCALECONV_STD_A              = 0x6B9
+	SYS___LOCALE_INIT_A                 = 0x6B7
+	SYS___LSTAT_A                       = 0x6EE
+	SYS___LSTAT_O_A                     = 0x6EF
+	SYS___MKDIR_A                       = 0x6E9
+	SYS___MKFIFO_A                      = 0x6EC
+	SYS___MKNOD_A                       = 0x6F0
+	SYS___MONETARY_INIT_A               = 0x6BC
+	SYS___MOUNT_A                       = 0x6F1
+	SYS___NL_CSINFO_A                   = 0x6D6
+	SYS___NL_LANGINFO_A                 = 0x6BA
+	SYS___NL_LNAGINFO_STD_A             = 0x6BB
+	SYS___NL_MONINFO_A                  = 0x6D7
+	SYS___NL_NUMINFO_A                  = 0x6D8
+	SYS___NL_RESPINFO_A                 = 0x6D9
+	SYS___NL_TIMINFO_A                  = 0x6DA
+	SYS___NUMERIC_INIT_A                = 0x6C6
+	SYS___OPEN_A                        = 0x6F7
+	SYS___PRINTF_A                      = 0x6DD
+	SYS___RESP_INIT_A                   = 0x6C7
+	SYS___RPMATCH_A                     = 0x6C8
+	SYS___RPMATCH_C_A                   = 0x6C9
+	SYS___RPMATCH_STD_A                 = 0x6CA
+	SYS___SETLOCALE_A                   = 0x6F9
+	SYS___SPAWNP_A                      = 0x6C5
+	SYS___SPAWN_A                       = 0x6C3
+	SYS___SPRINTF_A                     = 0x6FB
+	SYS___STAT_A                        = 0x6EA
+	SYS___STAT_O_A                      = 0x6EB
+	SYS___STRCOLL_STD_A                 = 0x6A1
+	SYS___STRFMON_A                     = 0x6BD
+	SYS___STRFMON_STD_A                 = 0x6BE
+	SYS___STRFTIME_A                    = 0x6CC
+	SYS___STRFTIME_STD_A                = 0x6CD
+	SYS___STRPTIME_A                    = 0x6CE
+	SYS___STRPTIME_STD_A                = 0x6CF
+	SYS___STRXFRM_A                     = 0x6A2
+	SYS___STRXFRM_C_A                   = 0x6A3
+	SYS___STRXFRM_STD_A                 = 0x6A5
+	SYS___SYNTAX_INIT_A                 = 0x6D4
+	SYS___TIME_INIT_A                   = 0x6CB
+	SYS___TOD_INIT_A                    = 0x6D5
+	SYS___TOWLOWER_A                    = 0x6B3
+	SYS___TOWLOWER_STD_A                = 0x6B4
+	SYS___TOWUPPER_A                    = 0x6B5
+	SYS___TOWUPPER_STD_A                = 0x6B6
+	SYS___UMOUNT_A                      = 0x6F2
+	SYS___VFPRINTF_A                    = 0x6FC
+	SYS___VPRINTF_A                     = 0x6FD
+	SYS___VSPRINTF_A                    = 0x6FE
+	SYS___VSWPRINTF_A                   = 0x6FF
+	SYS___WCSCOLL_A                     = 0x6A6
+	SYS___WCSCOLL_C_A                   = 0x6A7
+	SYS___WCSCOLL_STD_A                 = 0x6A8
+	SYS___WCSFTIME_A                    = 0x6D0
+	SYS___WCSFTIME_STD_A                = 0x6D1
+	SYS___WCSXFRM_A                     = 0x6A9
+	SYS___WCSXFRM_C_A                   = 0x6AA
+	SYS___WCSXFRM_STD_A                 = 0x6AB
+	SYS___WCTYPE_A                      = 0x6AD
+	SYS___W_GETMNTENT_A                 = 0x6F5
+	SYS_____CCSIDTYPE_A                 = 0x6E6
+	SYS_____CHATTR_A                    = 0x6E2
+	SYS_____CSNAMETYPE_A                = 0x6E7
+	SYS_____OPEN_STAT_A                 = 0x6ED
+	SYS_____SPAWN2_A                    = 0x6D2
+	SYS_____SPAWNP2_A                   = 0x6D3
+	SYS_____TOCCSID_A                   = 0x6E4
+	SYS_____TOCSNAME_A                  = 0x6E5
+	SYS_ACL_FREE                        = 0x7FF
+	SYS_ACL_INIT                        = 0x7FE
+	SYS_FWIDE                           = 0x7DF
+	SYS_FWPRINTF                        = 0x7D1
+	SYS_FWRITE                          = 0x07E
+	SYS_FWSCANF                         = 0x7D5
+	SYS_GETCHAR                         = 0x07B
+	SYS_GETS                            = 0x07C
+	SYS_M_CREATE_LAYOUT                 = 0x7C9
+	SYS_M_DESTROY_LAYOUT                = 0x7CA
+	SYS_M_GETVALUES_LAYOUT              = 0x7CB
+	SYS_M_SETVALUES_LAYOUT              = 0x7CC
+	SYS_M_TRANSFORM_LAYOUT              = 0x7CD
+	SYS_M_WTRANSFORM_LAYOUT             = 0x7CE
+	SYS_PREAD                           = 0x7C7
+	SYS_PUTC                            = 0x07D
+	SYS_PUTCHAR                         = 0x07A
+	SYS_PUTS                            = 0x07F
+	SYS_PWRITE                          = 0x7C8
+	SYS_TOWCTRAN                        = 0x7D8
+	SYS_TOWCTRANS                       = 0x7D8
+	SYS_UNATEXIT                        = 0x7B5
+	SYS_VFWPRINT                        = 0x7D3
+	SYS_VFWPRINTF                       = 0x7D3
+	SYS_VWPRINTF                        = 0x7D4
+	SYS_WCTRANS                         = 0x7D7
+	SYS_WPRINTF                         = 0x7D2
+	SYS_WSCANF                          = 0x7D6
+	SYS___ASCTIME_R_A                   = 0x7A1
+	SYS___BASENAME_A                    = 0x7DC
+	SYS___BTOWC_A                       = 0x7E4
+	SYS___CDUMP_A                       = 0x7B7
+	SYS___CEE3DMP_A                     = 0x7B6
+	SYS___CEILF_H                       = 0x7F4
+	SYS___CEILL_H                       = 0x7F5
+	SYS___CEIL_H                        = 0x7EA
+	SYS___CRYPT_A                       = 0x7BE
+	SYS___CSNAP_A                       = 0x7B8
+	SYS___CTEST_A                       = 0x7B9
+	SYS___CTIME_R_A                     = 0x7A2
+	SYS___CTRACE_A                      = 0x7BA
+	SYS___DBM_OPEN_A                    = 0x7E6
+	SYS___DIRNAME_A                     = 0x7DD
+	SYS___FABSF_H                       = 0x7FA
+	SYS___FABSL_H                       = 0x7FB
+	SYS___FABS_H                        = 0x7ED
+	SYS___FGETWC_A                      = 0x7AA
+	SYS___FGETWS_A                      = 0x7AD
+	SYS___FLOORF_H                      = 0x7F6
+	SYS___FLOORL_H                      = 0x7F7
+	SYS___FLOOR_H                       = 0x7EB
+	SYS___FPUTWC_A                      = 0x7A5
+	SYS___FPUTWS_A                      = 0x7A8
+	SYS___GETTIMEOFDAY_A                = 0x7AE
+	SYS___GETWCHAR_A                    = 0x7AC
+	SYS___GETWC_A                       = 0x7AB
+	SYS___GLOB_A                        = 0x7DE
+	SYS___GMTIME_A                      = 0x7AF
+	SYS___GMTIME_R_A                    = 0x7B0
+	SYS___INET_PTON_A                   = 0x7BC
+	SYS___J0_H                          = 0x7EE
+	SYS___J1_H                          = 0x7EF
+	SYS___JN_H                          = 0x7F0
+	SYS___LOCALTIME_A                   = 0x7B1
+	SYS___LOCALTIME_R_A                 = 0x7B2
+	SYS___MALLOC24                      = 0x7FC
+	SYS___MALLOC31                      = 0x7FD
+	SYS___MKTIME_A                      = 0x7B3
+	SYS___MODFF_H                       = 0x7F8
+	SYS___MODFL_H                       = 0x7F9
+	SYS___MODF_H                        = 0x7EC
+	SYS___OPENDIR_A                     = 0x7C2
+	SYS___OSNAME                        = 0x7E0
+	SYS___PUTWCHAR_A                    = 0x7A7
+	SYS___PUTWC_A                       = 0x7A6
+	SYS___READDIR_A                     = 0x7C3
+	SYS___STRTOLL_A                     = 0x7A3
+	SYS___STRTOULL_A                    = 0x7A4
+	SYS___SYSLOG_A                      = 0x7BD
+	SYS___TZZNA                         = 0x7B4
+	SYS___UNGETWC_A                     = 0x7A9
+	SYS___UTIME_A                       = 0x7A0
+	SYS___VFPRINTF2_A                   = 0x7E7
+	SYS___VPRINTF2_A                    = 0x7E8
+	SYS___VSPRINTF2_A                   = 0x7E9
+	SYS___VSWPRNTF2_A                   = 0x7BB
+	SYS___WCSTOD_A                      = 0x7D9
+	SYS___WCSTOL_A                      = 0x7DA
+	SYS___WCSTOUL_A                     = 0x7DB
+	SYS___WCTOB_A                       = 0x7E5
+	SYS___Y0_H                          = 0x7F1
+	SYS___Y1_H                          = 0x7F2
+	SYS___YN_H                          = 0x7F3
+	SYS_____OPENDIR2_A                  = 0x7BF
+	SYS_____OSNAME_A                    = 0x7E1
+	SYS_____READDIR2_A                  = 0x7C0
+	SYS_DLCLOSE                         = 0x8DF
+	SYS_DLERROR                         = 0x8E0
+	SYS_DLOPEN                          = 0x8DD
+	SYS_DLSYM                           = 0x8DE
+	SYS_FLOCKFILE                       = 0x8D3
+	SYS_FTRYLOCKFILE                    = 0x8D4
+	SYS_FUNLOCKFILE                     = 0x8D5
+	SYS_GETCHAR_UNLOCKED                = 0x8D7
+	SYS_GETC_UNLOCKED                   = 0x8D6
+	SYS_PUTCHAR_UNLOCKED                = 0x8D9
+	SYS_PUTC_UNLOCKED                   = 0x8D8
+	SYS_SNPRINTF                        = 0x8DA
+	SYS_VSNPRINTF                       = 0x8DB
+	SYS_WCSCSPN                         = 0x08B
+	SYS_WCSLEN                          = 0x08C
+	SYS_WCSNCAT                         = 0x08D
+	SYS_WCSNCMP                         = 0x08A
+	SYS_WCSNCPY                         = 0x08F
+	SYS_WCSSPN                          = 0x08E
+	SYS___ABSF_H                        = 0x8E7
+	SYS___ABSL_H                        = 0x8E8
+	SYS___ABS_H                         = 0x8E6
+	SYS___ACOSF_H                       = 0x8EA
+	SYS___ACOSH_H                       = 0x8EC
+	SYS___ACOSL_H                       = 0x8EB
+	SYS___ACOS_H                        = 0x8E9
+	SYS___ASINF_H                       = 0x8EE
+	SYS___ASINH_H                       = 0x8F0
+	SYS___ASINL_H                       = 0x8EF
+	SYS___ASIN_H                        = 0x8ED
+	SYS___ATAN2F_H                      = 0x8F8
+	SYS___ATAN2L_H                      = 0x8F9
+	SYS___ATAN2_H                       = 0x8F7
+	SYS___ATANF_H                       = 0x8F2
+	SYS___ATANHF_H                      = 0x8F5
+	SYS___ATANHL_H                      = 0x8F6
+	SYS___ATANH_H                       = 0x8F4
+	SYS___ATANL_H                       = 0x8F3
+	SYS___ATAN_H                        = 0x8F1
+	SYS___CBRT_H                        = 0x8FA
+	SYS___COPYSIGNF_H                   = 0x8FB
+	SYS___COPYSIGNL_H                   = 0x8FC
+	SYS___COSF_H                        = 0x8FE
+	SYS___COSL_H                        = 0x8FF
+	SYS___COS_H                         = 0x8FD
+	SYS___DLERROR_A                     = 0x8D2
+	SYS___DLOPEN_A                      = 0x8D0
+	SYS___DLSYM_A                       = 0x8D1
+	SYS___GETUTXENT_A                   = 0x8C6
+	SYS___GETUTXID_A                    = 0x8C7
+	SYS___GETUTXLINE_A                  = 0x8C8
+	SYS___ITOA                          = 0x8AA
+	SYS___ITOA_A                        = 0x8B0
+	SYS___LE_CONDITION_TOKEN_BUILD      = 0x8A5
+	SYS___LE_MSG_ADD_INSERT             = 0x8A6
+	SYS___LE_MSG_GET                    = 0x8A7
+	SYS___LE_MSG_GET_AND_WRITE          = 0x8A8
+	SYS___LE_MSG_WRITE                  = 0x8A9
+	SYS___LLTOA                         = 0x8AE
+	SYS___LLTOA_A                       = 0x8B4
+	SYS___LTOA                          = 0x8AC
+	SYS___LTOA_A                        = 0x8B2
+	SYS___PUTCHAR_UNLOCKED_A            = 0x8CC
+	SYS___PUTC_UNLOCKED_A               = 0x8CB
+	SYS___PUTUTXLINE_A                  = 0x8C9
+	SYS___RESET_EXCEPTION_HANDLER       = 0x8E3
+	SYS___REXEC_A                       = 0x8C4
+	SYS___REXEC_AF_A                    = 0x8C5
+	SYS___SET_EXCEPTION_HANDLER         = 0x8E2
+	SYS___SNPRINTF_A                    = 0x8CD
+	SYS___SUPERKILL                     = 0x8A4
+	SYS___TCGETATTR_A                   = 0x8A1
+	SYS___TCSETATTR_A                   = 0x8A2
+	SYS___ULLTOA                        = 0x8AF
+	SYS___ULLTOA_A                      = 0x8B5
+	SYS___ULTOA                         = 0x8AD
+	SYS___ULTOA_A                       = 0x8B3
+	SYS___UTOA                          = 0x8AB
+	SYS___UTOA_A                        = 0x8B1
+	SYS___VHM_EVENT                     = 0x8E4
+	SYS___VSNPRINTF_A                   = 0x8CE
+	SYS_____GETENV_A                    = 0x8C3
+	SYS_____UTMPXNAME_A                 = 0x8CA
+	SYS_CACOSH                          = 0x9A0
+	SYS_CACOSHF                         = 0x9A3
+	SYS_CACOSHL                         = 0x9A6
+	SYS_CARG                            = 0x9A9
+	SYS_CARGF                           = 0x9AC
+	SYS_CARGL                           = 0x9AF
+	SYS_CASIN                           = 0x9B2
+	SYS_CASINF                          = 0x9B5
+	SYS_CASINH                          = 0x9BB
+	SYS_CASINHF                         = 0x9BE
+	SYS_CASINHL                         = 0x9C1
+	SYS_CASINL                          = 0x9B8
+	SYS_CATAN                           = 0x9C4
+	SYS_CATANF                          = 0x9C7
+	SYS_CATANH                          = 0x9CD
+	SYS_CATANHF                         = 0x9D0
+	SYS_CATANHL                         = 0x9D3
+	SYS_CATANL                          = 0x9CA
+	SYS_CCOS                            = 0x9D6
+	SYS_CCOSF                           = 0x9D9
+	SYS_CCOSH                           = 0x9DF
+	SYS_CCOSHF                          = 0x9E2
+	SYS_CCOSHL                          = 0x9E5
+	SYS_CCOSL                           = 0x9DC
+	SYS_CEXP                            = 0x9E8
+	SYS_CEXPF                           = 0x9EB
+	SYS_CEXPL                           = 0x9EE
+	SYS_CIMAG                           = 0x9F1
+	SYS_CIMAGF                          = 0x9F4
+	SYS_CIMAGL                          = 0x9F7
+	SYS_CLOGF                           = 0x9FD
+	SYS_MEMCHR                          = 0x09B
+	SYS_MEMCMP                          = 0x09A
+	SYS_STRCOLL                         = 0x09C
+	SYS_STRNCMP                         = 0x09D
+	SYS_STRRCHR                         = 0x09F
+	SYS_STRXFRM                         = 0x09E
+	SYS___CACOSHF_B                     = 0x9A4
+	SYS___CACOSHF_H                     = 0x9A5
+	SYS___CACOSHL_B                     = 0x9A7
+	SYS___CACOSHL_H                     = 0x9A8
+	SYS___CACOSH_B                      = 0x9A1
+	SYS___CACOSH_H                      = 0x9A2
+	SYS___CARGF_B                       = 0x9AD
+	SYS___CARGF_H                       = 0x9AE
+	SYS___CARGL_B                       = 0x9B0
+	SYS___CARGL_H                       = 0x9B1
+	SYS___CARG_B                        = 0x9AA
+	SYS___CARG_H                        = 0x9AB
+	SYS___CASINF_B                      = 0x9B6
+	SYS___CASINF_H                      = 0x9B7
+	SYS___CASINHF_B                     = 0x9BF
+	SYS___CASINHF_H                     = 0x9C0
+	SYS___CASINHL_B                     = 0x9C2
+	SYS___CASINHL_H                     = 0x9C3
+	SYS___CASINH_B                      = 0x9BC
+	SYS___CASINH_H                      = 0x9BD
+	SYS___CASINL_B                      = 0x9B9
+	SYS___CASINL_H                      = 0x9BA
+	SYS___CASIN_B                       = 0x9B3
+	SYS___CASIN_H                       = 0x9B4
+	SYS___CATANF_B                      = 0x9C8
+	SYS___CATANF_H                      = 0x9C9
+	SYS___CATANHF_B                     = 0x9D1
+	SYS___CATANHF_H                     = 0x9D2
+	SYS___CATANHL_B                     = 0x9D4
+	SYS___CATANHL_H                     = 0x9D5
+	SYS___CATANH_B                      = 0x9CE
+	SYS___CATANH_H                      = 0x9CF
+	SYS___CATANL_B                      = 0x9CB
+	SYS___CATANL_H                      = 0x9CC
+	SYS___CATAN_B                       = 0x9C5
+	SYS___CATAN_H                       = 0x9C6
+	SYS___CCOSF_B                       = 0x9DA
+	SYS___CCOSF_H                       = 0x9DB
+	SYS___CCOSHF_B                      = 0x9E3
+	SYS___CCOSHF_H                      = 0x9E4
+	SYS___CCOSHL_B                      = 0x9E6
+	SYS___CCOSHL_H                      = 0x9E7
+	SYS___CCOSH_B                       = 0x9E0
+	SYS___CCOSH_H                       = 0x9E1
+	SYS___CCOSL_B                       = 0x9DD
+	SYS___CCOSL_H                       = 0x9DE
+	SYS___CCOS_B                        = 0x9D7
+	SYS___CCOS_H                        = 0x9D8
+	SYS___CEXPF_B                       = 0x9EC
+	SYS___CEXPF_H                       = 0x9ED
+	SYS___CEXPL_B                       = 0x9EF
+	SYS___CEXPL_H                       = 0x9F0
+	SYS___CEXP_B                        = 0x9E9
+	SYS___CEXP_H                        = 0x9EA
+	SYS___CIMAGF_B                      = 0x9F5
+	SYS___CIMAGF_H                      = 0x9F6
+	SYS___CIMAGL_B                      = 0x9F8
+	SYS___CIMAGL_H                      = 0x9F9
+	SYS___CIMAG_B                       = 0x9F2
+	SYS___CIMAG_H                       = 0x9F3
+	SYS___CLOG                          = 0x9FA
+	SYS___CLOGF_B                       = 0x9FE
+	SYS___CLOGF_H                       = 0x9FF
+	SYS___CLOG_B                        = 0x9FB
+	SYS___CLOG_H                        = 0x9FC
+	SYS_ISWCTYPE                        = 0x10C
+	SYS_ISWXDIGI                        = 0x10A
+	SYS_ISWXDIGIT                       = 0x10A
+	SYS_MBSINIT                         = 0x10F
+	SYS_TOWLOWER                        = 0x10D
+	SYS_TOWUPPER                        = 0x10E
+	SYS_WCTYPE                          = 0x10B
+	SYS_WCSSTR                          = 0x11B
+	SYS___RPMTCH                        = 0x11A
+	SYS_WCSTOD                          = 0x12E
+	SYS_WCSTOK                          = 0x12C
+	SYS_WCSTOL                          = 0x12D
+	SYS_WCSTOUL                         = 0x12F
+	SYS_FGETWC                          = 0x13C
+	SYS_FGETWS                          = 0x13D
+	SYS_FPUTWC                          = 0x13E
+	SYS_FPUTWS                          = 0x13F
+	SYS_REGERROR                        = 0x13B
+	SYS_REGFREE                         = 0x13A
+	SYS_COLLEQUIV                       = 0x14F
+	SYS_COLLTOSTR                       = 0x14E
+	SYS_ISMCCOLLEL                      = 0x14C
+	SYS_STRTOCOLL                       = 0x14D
+	SYS_DLLFREE                         = 0x16F
+	SYS_DLLQUERYFN                      = 0x16D
+	SYS_DLLQUERYVAR                     = 0x16E
+	SYS_GETMCCOLL                       = 0x16A
+	SYS_GETWMCCOLL                      = 0x16B
+	SYS___ERR2AD                        = 0x16C
+	SYS_CFSETOSPEED                     = 0x17A
+	SYS_CHDIR                           = 0x17B
+	SYS_CHMOD                           = 0x17C
+	SYS_CHOWN                           = 0x17D
+	SYS_CLOSE                           = 0x17E
+	SYS_CLOSEDIR                        = 0x17F
+	SYS_LOG                             = 0x017
+	SYS_COSH                            = 0x018
+	SYS_FCHMOD                          = 0x18A
+	SYS_FCHOWN                          = 0x18B
+	SYS_FCNTL                           = 0x18C
+	SYS_FILENO                          = 0x18D
+	SYS_FORK                            = 0x18E
+	SYS_FPATHCONF                       = 0x18F
+	SYS_GETLOGIN                        = 0x19A
+	SYS_GETPGRP                         = 0x19C
+	SYS_GETPID                          = 0x19D
+	SYS_GETPPID                         = 0x19E
+	SYS_GETPWNAM                        = 0x19F
+	SYS_TANH                            = 0x019
+	SYS_W_GETMNTENT                     = 0x19B
+	SYS_POW                             = 0x020
+	SYS_PTHREAD_SELF                    = 0x20A
+	SYS_PTHREAD_SETINTR                 = 0x20B
+	SYS_PTHREAD_SETINTRTYPE             = 0x20C
+	SYS_PTHREAD_SETSPECIFIC             = 0x20D
+	SYS_PTHREAD_TESTINTR                = 0x20E
+	SYS_PTHREAD_YIELD                   = 0x20F
+	SYS_SQRT                            = 0x021
+	SYS_FLOOR                           = 0x022
+	SYS_J1                              = 0x023
+	SYS_WCSPBRK                         = 0x23F
+	SYS_BSEARCH                         = 0x24C
+	SYS_FABS                            = 0x024
+	SYS_GETENV                          = 0x24A
+	SYS_LDIV                            = 0x24D
+	SYS_SYSTEM                          = 0x24B
+	SYS_FMOD                            = 0x025
+	SYS___RETHROW                       = 0x25F
+	SYS___THROW                         = 0x25E
+	SYS_J0                              = 0x026
+	SYS_PUTENV                          = 0x26A
+	SYS___GETENV                        = 0x26F
+	SYS_SEMCTL                          = 0x27A
+	SYS_SEMGET                          = 0x27B
+	SYS_SEMOP                           = 0x27C
+	SYS_SHMAT                           = 0x27D
+	SYS_SHMCTL                          = 0x27E
+	SYS_SHMDT                           = 0x27F
+	SYS_YN                              = 0x027
+	SYS_JN                              = 0x028
+	SYS_SIGALTSTACK                     = 0x28A
+	SYS_SIGHOLD                         = 0x28B
+	SYS_SIGIGNORE                       = 0x28C
+	SYS_SIGINTERRUPT                    = 0x28D
+	SYS_SIGPAUSE                        = 0x28E
+	SYS_SIGRELSE                        = 0x28F
+	SYS_GETOPT                          = 0x29A
+	SYS_GETSUBOPT                       = 0x29D
+	SYS_LCHOWN                          = 0x29B
+	SYS_SETPGRP                         = 0x29E
+	SYS_TRUNCATE                        = 0x29C
+	SYS_Y0                              = 0x029
+	SYS___GDERR                         = 0x29F
+	SYS_ISALPHA                         = 0x030
+	SYS_VFORK                           = 0x30F
+	SYS__LONGJMP                        = 0x30D
+	SYS__SETJMP                         = 0x30E
+	SYS_GLOB                            = 0x31A
+	SYS_GLOBFREE                        = 0x31B
+	SYS_ISALNUM                         = 0x031
+	SYS_PUTW                            = 0x31C
+	SYS_SEEKDIR                         = 0x31D
+	SYS_TELLDIR                         = 0x31E
+	SYS_TEMPNAM                         = 0x31F
+	SYS_GETTIMEOFDAY_R                  = 0x32E
+	SYS_ISLOWER                         = 0x032
+	SYS_LGAMMA                          = 0x32C
+	SYS_REMAINDER                       = 0x32A
+	SYS_SCALB                           = 0x32B
+	SYS_SYNC                            = 0x32F
+	SYS_TTYSLOT                         = 0x32D
+	SYS_ENDPROTOENT                     = 0x33A
+	SYS_ENDSERVENT                      = 0x33B
+	SYS_GETHOSTBYADDR                   = 0x33D
+	SYS_GETHOSTBYADDR_R                 = 0x33C
+	SYS_GETHOSTBYNAME                   = 0x33F
+	SYS_GETHOSTBYNAME_R                 = 0x33E
+	SYS_ISCNTRL                         = 0x033
+	SYS_GETSERVBYNAME                   = 0x34A
+	SYS_GETSERVBYPORT                   = 0x34B
+	SYS_GETSERVENT                      = 0x34C
+	SYS_GETSOCKNAME                     = 0x34D
+	SYS_GETSOCKOPT                      = 0x34E
+	SYS_INET_ADDR                       = 0x34F
+	SYS_ISDIGIT                         = 0x034
+	SYS_ISGRAPH                         = 0x035
+	SYS_SELECT                          = 0x35B
+	SYS_SELECTEX                        = 0x35C
+	SYS_SEND                            = 0x35D
+	SYS_SENDTO                          = 0x35F
+	SYS_CHROOT                          = 0x36A
+	SYS_ISNAN                           = 0x36D
+	SYS_ISUPPER                         = 0x036
+	SYS_ULIMIT                          = 0x36C
+	SYS_UTIMES                          = 0x36E
+	SYS_W_STATVFS                       = 0x36B
+	SYS___H_ERRNO                       = 0x36F
+	SYS_GRANTPT                         = 0x37A
+	SYS_ISPRINT                         = 0x037
+	SYS_TCGETSID                        = 0x37C
+	SYS_UNLOCKPT                        = 0x37B
+	SYS___TCGETCP                       = 0x37D
+	SYS___TCSETCP                       = 0x37E
+	SYS___TCSETTABLES                   = 0x37F
+	SYS_ISPUNCT                         = 0x038
+	SYS_NLIST                           = 0x38C
+	SYS___IPDBCS                        = 0x38D
+	SYS___IPDSPX                        = 0x38E
+	SYS___IPMSGC                        = 0x38F
+	SYS___STHOSTENT                     = 0x38B
+	SYS___STSERVENT                     = 0x38A
+	SYS_ISSPACE                         = 0x039
+	SYS_COS                             = 0x040
+	SYS_T_ALLOC                         = 0x40A
+	SYS_T_BIND                          = 0x40B
+	SYS_T_CLOSE                         = 0x40C
+	SYS_T_CONNECT                       = 0x40D
+	SYS_T_ERROR                         = 0x40E
+	SYS_T_FREE                          = 0x40F
+	SYS_TAN                             = 0x041
+	SYS_T_RCVREL                        = 0x41A
+	SYS_T_RCVUDATA                      = 0x41B
+	SYS_T_RCVUDERR                      = 0x41C
+	SYS_T_SND                           = 0x41D
+	SYS_T_SNDDIS                        = 0x41E
+	SYS_T_SNDREL                        = 0x41F
+	SYS_GETPMSG                         = 0x42A
+	SYS_ISASTREAM                       = 0x42B
+	SYS_PUTMSG                          = 0x42C
+	SYS_PUTPMSG                         = 0x42D
+	SYS_SINH                            = 0x042
+	SYS___ISPOSIXON                     = 0x42E
+	SYS___OPENMVSREL                    = 0x42F
+	SYS_ACOS                            = 0x043
+	SYS_ATAN                            = 0x044
+	SYS_ATAN2                           = 0x045
+	SYS_FTELL                           = 0x046
+	SYS_FGETPOS                         = 0x047
+	SYS_SOCK_DEBUG                      = 0x47A
+	SYS_SOCK_DO_TESTSTOR                = 0x47D
+	SYS_TAKESOCKET                      = 0x47E
+	SYS___SERVER_INIT                   = 0x47F
+	SYS_FSEEK                           = 0x048
+	SYS___IPHOST                        = 0x48B
+	SYS___IPNODE                        = 0x48C
+	SYS___SERVER_CLASSIFY_CREATE        = 0x48D
+	SYS___SERVER_CLASSIFY_DESTROY       = 0x48E
+	SYS___SERVER_CLASSIFY_RESET         = 0x48F
+	SYS___SMF_RECORD                    = 0x48A
+	SYS_FSETPOS                         = 0x049
+	SYS___FNWSA                         = 0x49B
+	SYS___SPAWN2                        = 0x49D
+	SYS___SPAWNP2                       = 0x49E
+	SYS_ATOF                            = 0x050
+	SYS_PTHREAD_MUTEXATTR_GETPSHARED    = 0x50A
+	SYS_PTHREAD_MUTEXATTR_SETPSHARED    = 0x50B
+	SYS_PTHREAD_RWLOCK_DESTROY          = 0x50C
+	SYS_PTHREAD_RWLOCK_INIT             = 0x50D
+	SYS_PTHREAD_RWLOCK_RDLOCK           = 0x50E
+	SYS_PTHREAD_RWLOCK_TRYRDLOCK        = 0x50F
+	SYS_ATOI                            = 0x051
+	SYS___FP_CLASS                      = 0x51D
+	SYS___FP_CLR_FLAG                   = 0x51A
+	SYS___FP_FINITE                     = 0x51E
+	SYS___FP_ISNAN                      = 0x51F
+	SYS___FP_RAISE_XCP                  = 0x51C
+	SYS___FP_READ_FLAG                  = 0x51B
+	SYS_RAND                            = 0x052
+	SYS_SIGTIMEDWAIT                    = 0x52D
+	SYS_SIGWAITINFO                     = 0x52E
+	SYS___CHKBFP                        = 0x52F
+	SYS___FPC_RS                        = 0x52C
+	SYS___FPC_RW                        = 0x52A
+	SYS___FPC_SM                        = 0x52B
+	SYS_STRTOD                          = 0x053
+	SYS_STRTOL                          = 0x054
+	SYS_STRTOUL                         = 0x055
+	SYS_MALLOC                          = 0x056
+	SYS_SRAND                           = 0x057
+	SYS_CALLOC                          = 0x058
+	SYS_FREE                            = 0x059
+	SYS___OSENV                         = 0x59F
+	SYS___W_PIOCTL                      = 0x59E
+	SYS_LONGJMP                         = 0x060
+	SYS___FLOORF_B                      = 0x60A
+	SYS___FLOORL_B                      = 0x60B
+	SYS___FREXPF_B                      = 0x60C
+	SYS___FREXPL_B                      = 0x60D
+	SYS___LDEXPF_B                      = 0x60E
+	SYS___LDEXPL_B                      = 0x60F
+	SYS_SIGNAL                          = 0x061
+	SYS___ATAN2F_B                      = 0x61A
+	SYS___ATAN2L_B                      = 0x61B
+	SYS___COSHF_B                       = 0x61C
+	SYS___COSHL_B                       = 0x61D
+	SYS___EXPF_B                        = 0x61E
+	SYS___EXPL_B                        = 0x61F
+	SYS_TMPNAM                          = 0x062
+	SYS___ABSF_B                        = 0x62A
+	SYS___ABSL_B                        = 0x62C
+	SYS___ABS_B                         = 0x62B
+	SYS___FMODF_B                       = 0x62D
+	SYS___FMODL_B                       = 0x62E
+	SYS___MODFF_B                       = 0x62F
+	SYS_ATANL                           = 0x63A
+	SYS_CEILF                           = 0x63B
+	SYS_CEILL                           = 0x63C
+	SYS_COSF                            = 0x63D
+	SYS_COSHF                           = 0x63F
+	SYS_COSL                            = 0x63E
+	SYS_REMOVE                          = 0x063
+	SYS_POWL                            = 0x64A
+	SYS_RENAME                          = 0x064
+	SYS_SINF                            = 0x64B
+	SYS_SINHF                           = 0x64F
+	SYS_SINL                            = 0x64C
+	SYS_SQRTF                           = 0x64D
+	SYS_SQRTL                           = 0x64E
+	SYS_BTOWC                           = 0x65F
+	SYS_FREXPL                          = 0x65A
+	SYS_LDEXPF                          = 0x65B
+	SYS_LDEXPL                          = 0x65C
+	SYS_MODFF                           = 0x65D
+	SYS_MODFL                           = 0x65E
+	SYS_TMPFILE                         = 0x065
+	SYS_FREOPEN                         = 0x066
+	SYS___CHARMAP_INIT_A                = 0x66E
+	SYS___GETHOSTBYADDR_R_A             = 0x66C
+	SYS___GETHOSTBYNAME_A               = 0x66A
+	SYS___GETHOSTBYNAME_R_A             = 0x66D
+	SYS___MBLEN_A                       = 0x66F
+	SYS___RES_INIT_A                    = 0x66B
+	SYS_FCLOSE                          = 0x067
+	SYS___GETGRGID_R_A                  = 0x67D
+	SYS___WCSTOMBS_A                    = 0x67A
+	SYS___WCSTOMBS_STD_A                = 0x67B
+	SYS___WCSWIDTH_A                    = 0x67C
+	SYS___WCSWIDTH_ASIA                 = 0x67F
+	SYS___WCSWIDTH_STD_A                = 0x67E
+	SYS_FFLUSH                          = 0x068
+	SYS___GETLOGIN_R_A                  = 0x68E
+	SYS___GETPWNAM_R_A                  = 0x68C
+	SYS___GETPWUID_R_A                  = 0x68D
+	SYS___TTYNAME_R_A                   = 0x68F
+	SYS___WCWIDTH_ASIA                  = 0x68B
+	SYS___WCWIDTH_STD_A                 = 0x68A
+	SYS_FOPEN                           = 0x069
+	SYS___REGEXEC_A                     = 0x69A
+	SYS___REGEXEC_STD_A                 = 0x69B
+	SYS___REGFREE_A                     = 0x69C
+	SYS___REGFREE_STD_A                 = 0x69D
+	SYS___STRCOLL_A                     = 0x69E
+	SYS___STRCOLL_C_A                   = 0x69F
+	SYS_SCANF                           = 0x070
+	SYS___A64L_A                        = 0x70C
+	SYS___ECVT_A                        = 0x70D
+	SYS___FCVT_A                        = 0x70E
+	SYS___GCVT_A                        = 0x70F
+	SYS___STRTOUL_A                     = 0x70A
+	SYS_____AE_CORRESTBL_QUERY_A        = 0x70B
+	SYS_SPRINTF                         = 0x071
+	SYS___ACCESS_A                      = 0x71F
+	SYS___CATOPEN_A                     = 0x71E
+	SYS___GETOPT_A                      = 0x71D
+	SYS___REALPATH_A                    = 0x71A
+	SYS___SETENV_A                      = 0x71B
+	SYS___SYSTEM_A                      = 0x71C
+	SYS_FGETC                           = 0x072
+	SYS___GAI_STRERROR_A                = 0x72F
+	SYS___RMDIR_A                       = 0x72A
+	SYS___STATVFS_A                     = 0x72B
+	SYS___SYMLINK_A                     = 0x72C
+	SYS___TRUNCATE_A                    = 0x72D
+	SYS___UNLINK_A                      = 0x72E
+	SYS_VFPRINTF                        = 0x073
+	SYS___ISSPACE_A                     = 0x73A
+	SYS___ISUPPER_A                     = 0x73B
+	SYS___ISWALNUM_A                    = 0x73F
+	SYS___ISXDIGIT_A                    = 0x73C
+	SYS___TOLOWER_A                     = 0x73D
+	SYS___TOUPPER_A                     = 0x73E
+	SYS_VPRINTF                         = 0x074
+	SYS___CONFSTR_A                     = 0x74B
+	SYS___FDOPEN_A                      = 0x74E
+	SYS___FLDATA_A                      = 0x74F
+	SYS___FTOK_A                        = 0x74C
+	SYS___ISWXDIGIT_A                   = 0x74A
+	SYS___MKTEMP_A                      = 0x74D
+	SYS_VSPRINTF                        = 0x075
+	SYS___GETGRGID_A                    = 0x75A
+	SYS___GETGRNAM_A                    = 0x75B
+	SYS___GETGROUPSBYNAME_A             = 0x75C
+	SYS___GETHOSTENT_A                  = 0x75D
+	SYS___GETHOSTNAME_A                 = 0x75E
+	SYS___GETLOGIN_A                    = 0x75F
+	SYS_GETC                            = 0x076
+	SYS___CREATEWORKUNIT_A              = 0x76A
+	SYS___CTERMID_A                     = 0x76B
+	SYS___FMTMSG_A                      = 0x76C
+	SYS___INITGROUPS_A                  = 0x76D
+	SYS___MSGRCV_A                      = 0x76F
+	SYS_____LOGIN_A                     = 0x76E
+	SYS_FGETS                           = 0x077
+	SYS___STRCASECMP_A                  = 0x77B
+	SYS___STRNCASECMP_A                 = 0x77C
+	SYS___TTYNAME_A                     = 0x77D
+	SYS___UNAME_A                       = 0x77E
+	SYS___UTIMES_A                      = 0x77F
+	SYS_____SERVER_PWU_A                = 0x77A
+	SYS_FPUTC                           = 0x078
+	SYS___CREAT_O_A                     = 0x78E
+	SYS___ENVNA                         = 0x78F
+	SYS___FREAD_A                       = 0x78A
+	SYS___FWRITE_A                      = 0x78B
+	SYS___ISASCII                       = 0x78D
+	SYS___OPEN_O_A                      = 0x78C
+	SYS_FPUTS                           = 0x079
+	SYS___ASCTIME_A                     = 0x79C
+	SYS___CTIME_A                       = 0x79D
+	SYS___GETDATE_A                     = 0x79E
+	SYS___GETSERVBYPORT_A               = 0x79A
+	SYS___GETSERVENT_A                  = 0x79B
+	SYS___TZSET_A                       = 0x79F
+	SYS_ACL_FROM_TEXT                   = 0x80C
+	SYS_ACL_SET_FD                      = 0x80A
+	SYS_ACL_SET_FILE                    = 0x80B
+	SYS_ACL_SORT                        = 0x80E
+	SYS_ACL_TO_TEXT                     = 0x80D
+	SYS_UNGETC                          = 0x080
+	SYS___SHUTDOWN_REGISTRATION         = 0x80F
+	SYS_FREAD                           = 0x081
+	SYS_FREEADDRINFO                    = 0x81A
+	SYS_GAI_STRERROR                    = 0x81B
+	SYS_REXEC_AF                        = 0x81C
+	SYS___DYNALLOC_A                    = 0x81F
+	SYS___POE                           = 0x81D
+	SYS_WCSTOMBS                        = 0x082
+	SYS___INET_ADDR_A                   = 0x82F
+	SYS___NLIST_A                       = 0x82A
+	SYS_____TCGETCP_A                   = 0x82B
+	SYS_____TCSETCP_A                   = 0x82C
+	SYS_____W_PIOCTL_A                  = 0x82E
+	SYS_MBTOWC                          = 0x083
+	SYS___CABEND                        = 0x83D
+	SYS___LE_CIB_GET                    = 0x83E
+	SYS___RECVMSG_A                     = 0x83B
+	SYS___SENDMSG_A                     = 0x83A
+	SYS___SET_LAA_FOR_JIT               = 0x83F
+	SYS_____LCHATTR_A                   = 0x83C
+	SYS_WCTOMB                          = 0x084
+	SYS___CBRTL_B                       = 0x84A
+	SYS___COPYSIGNF_B                   = 0x84B
+	SYS___COPYSIGNL_B                   = 0x84C
+	SYS___COTANF_B                      = 0x84D
+	SYS___COTANL_B                      = 0x84F
+	SYS___COTAN_B                       = 0x84E
+	SYS_MBSTOWCS                        = 0x085
+	SYS___LOG1PL_B                      = 0x85A
+	SYS___LOG2F_B                       = 0x85B
+	SYS___LOG2L_B                       = 0x85D
+	SYS___LOG2_B                        = 0x85C
+	SYS___REMAINDERF_B                  = 0x85E
+	SYS___REMAINDERL_B                  = 0x85F
+	SYS_ACOSHF                          = 0x86E
+	SYS_ACOSHL                          = 0x86F
+	SYS_WCSCPY                          = 0x086
+	SYS___ERFCF_B                       = 0x86D
+	SYS___ERFF_B                        = 0x86C
+	SYS___LROUNDF_B                     = 0x86A
+	SYS___LROUND_B                      = 0x86B
+	SYS_COTANL                          = 0x87A
+	SYS_EXP2F                           = 0x87B
+	SYS_EXP2L                           = 0x87C
+	SYS_EXPM1F                          = 0x87D
+	SYS_EXPM1L                          = 0x87E
+	SYS_FDIMF                           = 0x87F
+	SYS_WCSCAT                          = 0x087
+	SYS___COTANL                        = 0x87A
+	SYS_REMAINDERF                      = 0x88A
+	SYS_REMAINDERL                      = 0x88B
+	SYS_REMAINDF                        = 0x88A
+	SYS_REMAINDL                        = 0x88B
+	SYS_REMQUO                          = 0x88D
+	SYS_REMQUOF                         = 0x88C
+	SYS_REMQUOL                         = 0x88E
+	SYS_TGAMMAF                         = 0x88F
+	SYS_WCSCHR                          = 0x088
+	SYS_ERFCF                           = 0x89B
+	SYS_ERFCL                           = 0x89C
+	SYS_ERFL                            = 0x89A
+	SYS_EXP2                            = 0x89E
+	SYS_WCSCMP                          = 0x089
+	SYS___EXP2_B                        = 0x89D
+	SYS___FAR_JUMP                      = 0x89F
+	SYS_ABS                             = 0x090
+	SYS___ERFCL_H                       = 0x90A
+	SYS___EXPF_H                        = 0x90C
+	SYS___EXPL_H                        = 0x90D
+	SYS___EXPM1_H                       = 0x90E
+	SYS___EXP_H                         = 0x90B
+	SYS___FDIM_H                        = 0x90F
+	SYS_DIV                             = 0x091
+	SYS___LOG2F_H                       = 0x91F
+	SYS___LOG2_H                        = 0x91E
+	SYS___LOGB_H                        = 0x91D
+	SYS___LOGF_H                        = 0x91B
+	SYS___LOGL_H                        = 0x91C
+	SYS___LOG_H                         = 0x91A
+	SYS_LABS                            = 0x092
+	SYS___POWL_H                        = 0x92A
+	SYS___REMAINDER_H                   = 0x92B
+	SYS___RINT_H                        = 0x92C
+	SYS___SCALB_H                       = 0x92D
+	SYS___SINF_H                        = 0x92F
+	SYS___SIN_H                         = 0x92E
+	SYS_STRNCPY                         = 0x093
+	SYS___TANHF_H                       = 0x93B
+	SYS___TANHL_H                       = 0x93C
+	SYS___TANH_H                        = 0x93A
+	SYS___TGAMMAF_H                     = 0x93E
+	SYS___TGAMMA_H                      = 0x93D
+	SYS___TRUNC_H                       = 0x93F
+	SYS_MEMCPY                          = 0x094
+	SYS_VFWSCANF                        = 0x94A
+	SYS_VSWSCANF                        = 0x94E
+	SYS_VWSCANF                         = 0x94C
+	SYS_INET6_RTH_ADD                   = 0x95D
+	SYS_INET6_RTH_INIT                  = 0x95C
+	SYS_INET6_RTH_REVERSE               = 0x95E
+	SYS_INET6_RTH_SEGMENTS              = 0x95F
+	SYS_INET6_RTH_SPACE                 = 0x95B
+	SYS_MEMMOVE                         = 0x095
+	SYS_WCSTOLD                         = 0x95A
+	SYS_STRCPY                          = 0x096
+	SYS_STRCMP                          = 0x097
+	SYS_CABS                            = 0x98E
+	SYS_STRCAT                          = 0x098
+	SYS___CABS_B                        = 0x98F
+	SYS___POW_II                        = 0x98A
+	SYS___POW_II_B                      = 0x98B
+	SYS___POW_II_H                      = 0x98C
+	SYS_CACOSF                          = 0x99A
+	SYS_CACOSL                          = 0x99D
+	SYS_STRNCAT                         = 0x099
+	SYS___CACOSF_B                      = 0x99B
+	SYS___CACOSF_H                      = 0x99C
+	SYS___CACOSL_B                      = 0x99E
+	SYS___CACOSL_H                      = 0x99F
+	SYS_ISWALPHA                        = 0x100
+	SYS_ISWBLANK                        = 0x101
+	SYS___ISWBLK                        = 0x101
+	SYS_ISWCNTRL                        = 0x102
+	SYS_ISWDIGIT                        = 0x103
+	SYS_ISWGRAPH                        = 0x104
+	SYS_ISWLOWER                        = 0x105
+	SYS_ISWPRINT                        = 0x106
+	SYS_ISWPUNCT                        = 0x107
+	SYS_ISWSPACE                        = 0x108
+	SYS_ISWUPPER                        = 0x109
+	SYS_WCTOB                           = 0x110
+	SYS_MBRLEN                          = 0x111
+	SYS_MBRTOWC                         = 0x112
+	SYS_MBSRTOWC                        = 0x113
+	SYS_MBSRTOWCS                       = 0x113
+	SYS_WCRTOMB                         = 0x114
+	SYS_WCSRTOMB                        = 0x115
+	SYS_WCSRTOMBS                       = 0x115
+	SYS___CSID                          = 0x116
+	SYS___WCSID                         = 0x117
+	SYS_STRPTIME                        = 0x118
+	SYS___STRPTM                        = 0x118
+	SYS_STRFMON                         = 0x119
+	SYS_WCSCOLL                         = 0x130
+	SYS_WCSXFRM                         = 0x131
+	SYS_WCSWIDTH                        = 0x132
+	SYS_WCWIDTH                         = 0x133
+	SYS_WCSFTIME                        = 0x134
+	SYS_SWPRINTF                        = 0x135
+	SYS_VSWPRINT                        = 0x136
+	SYS_VSWPRINTF                       = 0x136
+	SYS_SWSCANF                         = 0x137
+	SYS_REGCOMP                         = 0x138
+	SYS_REGEXEC                         = 0x139
+	SYS_GETWC                           = 0x140
+	SYS_GETWCHAR                        = 0x141
+	SYS_PUTWC                           = 0x142
+	SYS_PUTWCHAR                        = 0x143
+	SYS_UNGETWC                         = 0x144
+	SYS_ICONV_OPEN                      = 0x145
+	SYS_ICONV                           = 0x146
+	SYS_ICONV_CLOSE                     = 0x147
+	SYS_COLLRANGE                       = 0x150
+	SYS_CCLASS                          = 0x151
+	SYS_COLLORDER                       = 0x152
+	SYS___DEMANGLE                      = 0x154
+	SYS_FDOPEN                          = 0x155
+	SYS___ERRNO                         = 0x156
+	SYS___ERRNO2                        = 0x157
+	SYS___TERROR                        = 0x158
+	SYS_MAXCOLL                         = 0x169
+	SYS_DLLLOAD                         = 0x170
+	SYS__EXIT                           = 0x174
+	SYS_ACCESS                          = 0x175
+	SYS_ALARM                           = 0x176
+	SYS_CFGETISPEED                     = 0x177
+	SYS_CFGETOSPEED                     = 0x178
+	SYS_CFSETISPEED                     = 0x179
+	SYS_CREAT                           = 0x180
+	SYS_CTERMID                         = 0x181
+	SYS_DUP                             = 0x182
+	SYS_DUP2                            = 0x183
+	SYS_EXECL                           = 0x184
+	SYS_EXECLE                          = 0x185
+	SYS_EXECLP                          = 0x186
+	SYS_EXECV                           = 0x187
+	SYS_EXECVE                          = 0x188
+	SYS_EXECVP                          = 0x189
+	SYS_FSTAT                           = 0x190
+	SYS_FSYNC                           = 0x191
+	SYS_FTRUNCATE                       = 0x192
+	SYS_GETCWD                          = 0x193
+	SYS_GETEGID                         = 0x194
+	SYS_GETEUID                         = 0x195
+	SYS_GETGID                          = 0x196
+	SYS_GETGRGID                        = 0x197
+	SYS_GETGRNAM                        = 0x198
+	SYS_GETGROUPS                       = 0x199
+	SYS_PTHREAD_MUTEXATTR_DESTROY       = 0x200
+	SYS_PTHREAD_MUTEXATTR_SETKIND_NP    = 0x201
+	SYS_PTHREAD_MUTEXATTR_GETKIND_NP    = 0x202
+	SYS_PTHREAD_MUTEX_INIT              = 0x203
+	SYS_PTHREAD_MUTEX_DESTROY           = 0x204
+	SYS_PTHREAD_MUTEX_LOCK              = 0x205
+	SYS_PTHREAD_MUTEX_TRYLOCK           = 0x206
+	SYS_PTHREAD_MUTEX_UNLOCK            = 0x207
+	SYS_PTHREAD_ONCE                    = 0x209
+	SYS_TW_OPEN                         = 0x210
+	SYS_TW_FCNTL                        = 0x211
+	SYS_PTHREAD_JOIN_D4_NP              = 0x212
+	SYS_PTHREAD_CONDATTR_SETKIND_NP     = 0x213
+	SYS_PTHREAD_CONDATTR_GETKIND_NP     = 0x214
+	SYS_EXTLINK_NP                      = 0x215
+	SYS___PASSWD                        = 0x216
+	SYS_SETGROUPS                       = 0x217
+	SYS_INITGROUPS                      = 0x218
+	SYS_WCSRCHR                         = 0x240
+	SYS_SVC99                           = 0x241
+	SYS___SVC99                         = 0x241
+	SYS_WCSWCS                          = 0x242
+	SYS_LOCALECO                        = 0x243
+	SYS_LOCALECONV                      = 0x243
+	SYS___LIBREL                        = 0x244
+	SYS_RELEASE                         = 0x245
+	SYS___RLSE                          = 0x245
+	SYS_FLOCATE                         = 0x246
+	SYS___FLOCT                         = 0x246
+	SYS_FDELREC                         = 0x247
+	SYS___FDLREC                        = 0x247
+	SYS_FETCH                           = 0x248
+	SYS___FETCH                         = 0x248
+	SYS_QSORT                           = 0x249
+	SYS___CLEANUPCATCH                  = 0x260
+	SYS___CATCHMATCH                    = 0x261
+	SYS___CLEAN2UPCATCH                 = 0x262
+	SYS_GETPRIORITY                     = 0x270
+	SYS_NICE                            = 0x271
+	SYS_SETPRIORITY                     = 0x272
+	SYS_GETITIMER                       = 0x273
+	SYS_SETITIMER                       = 0x274
+	SYS_MSGCTL                          = 0x275
+	SYS_MSGGET                          = 0x276
+	SYS_MSGRCV                          = 0x277
+	SYS_MSGSND                          = 0x278
+	SYS_MSGXRCV                         = 0x279
+	SYS___MSGXR                         = 0x279
+	SYS_SHMGET                          = 0x280
+	SYS___GETIPC                        = 0x281
+	SYS_SETGRENT                        = 0x282
+	SYS_GETGRENT                        = 0x283
+	SYS_ENDGRENT                        = 0x284
+	SYS_SETPWENT                        = 0x285
+	SYS_GETPWENT                        = 0x286
+	SYS_ENDPWENT                        = 0x287
+	SYS_BSD_SIGNAL                      = 0x288
+	SYS_KILLPG                          = 0x289
+	SYS_SIGSET                          = 0x290
+	SYS_SIGSTACK                        = 0x291
+	SYS_GETRLIMIT                       = 0x292
+	SYS_SETRLIMIT                       = 0x293
+	SYS_GETRUSAGE                       = 0x294
+	SYS_MMAP                            = 0x295
+	SYS_MPROTECT                        = 0x296
+	SYS_MSYNC                           = 0x297
+	SYS_MUNMAP                          = 0x298
+	SYS_CONFSTR                         = 0x299
+	SYS___NDMTRM                        = 0x300
+	SYS_FTOK                            = 0x301
+	SYS_BASENAME                        = 0x302
+	SYS_DIRNAME                         = 0x303
+	SYS_GETDTABLESIZE                   = 0x304
+	SYS_MKSTEMP                         = 0x305
+	SYS_MKTEMP                          = 0x306
+	SYS_NFTW                            = 0x307
+	SYS_GETWD                           = 0x308
+	SYS_LOCKF                           = 0x309
+	SYS_WORDEXP                         = 0x310
+	SYS_WORDFREE                        = 0x311
+	SYS_GETPGID                         = 0x312
+	SYS_GETSID                          = 0x313
+	SYS___UTMPXNAME                     = 0x314
+	SYS_CUSERID                         = 0x315
+	SYS_GETPASS                         = 0x316
+	SYS_FNMATCH                         = 0x317
+	SYS_FTW                             = 0x318
+	SYS_GETW                            = 0x319
+	SYS_ACOSH                           = 0x320
+	SYS_ASINH                           = 0x321
+	SYS_ATANH                           = 0x322
+	SYS_CBRT                            = 0x323
+	SYS_EXPM1                           = 0x324
+	SYS_ILOGB                           = 0x325
+	SYS_LOGB                            = 0x326
+	SYS_LOG1P                           = 0x327
+	SYS_NEXTAFTER                       = 0x328
+	SYS_RINT                            = 0x329
+	SYS_SPAWN                           = 0x330
+	SYS_SPAWNP                          = 0x331
+	SYS_GETLOGIN_UU                     = 0x332
+	SYS_ECVT                            = 0x333
+	SYS_FCVT                            = 0x334
+	SYS_GCVT                            = 0x335
+	SYS_ACCEPT                          = 0x336
+	SYS_BIND                            = 0x337
+	SYS_CONNECT                         = 0x338
+	SYS_ENDHOSTENT                      = 0x339
+	SYS_GETHOSTENT                      = 0x340
+	SYS_GETHOSTID                       = 0x341
+	SYS_GETHOSTNAME                     = 0x342
+	SYS_GETNETBYADDR                    = 0x343
+	SYS_GETNETBYNAME                    = 0x344
+	SYS_GETNETENT                       = 0x345
+	SYS_GETPEERNAME                     = 0x346
+	SYS_GETPROTOBYNAME                  = 0x347
+	SYS_GETPROTOBYNUMBER                = 0x348
+	SYS_GETPROTOENT                     = 0x349
+	SYS_INET_LNAOF                      = 0x350
+	SYS_INET_MAKEADDR                   = 0x351
+	SYS_INET_NETOF                      = 0x352
+	SYS_INET_NETWORK                    = 0x353
+	SYS_INET_NTOA                       = 0x354
+	SYS_IOCTL                           = 0x355
+	SYS_LISTEN                          = 0x356
+	SYS_READV                           = 0x357
+	SYS_RECV                            = 0x358
+	SYS_RECVFROM                        = 0x359
+	SYS_SETHOSTENT                      = 0x360
+	SYS_SETNETENT                       = 0x361
+	SYS_SETPEER                         = 0x362
+	SYS_SETPROTOENT                     = 0x363
+	SYS_SETSERVENT                      = 0x364
+	SYS_SETSOCKOPT                      = 0x365
+	SYS_SHUTDOWN                        = 0x366
+	SYS_SOCKET                          = 0x367
+	SYS_SOCKETPAIR                      = 0x368
+	SYS_WRITEV                          = 0x369
+	SYS_ENDNETENT                       = 0x370
+	SYS_CLOSELOG                        = 0x371
+	SYS_OPENLOG                         = 0x372
+	SYS_SETLOGMASK                      = 0x373
+	SYS_SYSLOG                          = 0x374
+	SYS_PTSNAME                         = 0x375
+	SYS_SETREUID                        = 0x376
+	SYS_SETREGID                        = 0x377
+	SYS_REALPATH                        = 0x378
+	SYS___SIGNGAM                       = 0x379
+	SYS_POLL                            = 0x380
+	SYS_REXEC                           = 0x381
+	SYS___ISASCII2                      = 0x382
+	SYS___TOASCII2                      = 0x383
+	SYS_CHPRIORITY                      = 0x384
+	SYS_PTHREAD_ATTR_SETSYNCTYPE_NP     = 0x385
+	SYS_PTHREAD_ATTR_GETSYNCTYPE_NP     = 0x386
+	SYS_PTHREAD_SET_LIMIT_NP            = 0x387
+	SYS___STNETENT                      = 0x388
+	SYS___STPROTOENT                    = 0x389
+	SYS___SELECT1                       = 0x390
+	SYS_PTHREAD_SECURITY_NP             = 0x391
+	SYS___CHECK_RESOURCE_AUTH_NP        = 0x392
+	SYS___CONVERT_ID_NP                 = 0x393
+	SYS___OPENVMREL                     = 0x394
+	SYS_WMEMCHR                         = 0x395
+	SYS_WMEMCMP                         = 0x396
+	SYS_WMEMCPY                         = 0x397
+	SYS_WMEMMOVE                        = 0x398
+	SYS_WMEMSET                         = 0x399
+	SYS___FPUTWC                        = 0x400
+	SYS___PUTWC                         = 0x401
+	SYS___PWCHAR                        = 0x402
+	SYS___WCSFTM                        = 0x403
+	SYS___WCSTOK                        = 0x404
+	SYS___WCWDTH                        = 0x405
+	SYS_T_ACCEPT                        = 0x409
+	SYS_T_GETINFO                       = 0x410
+	SYS_T_GETPROTADDR                   = 0x411
+	SYS_T_GETSTATE                      = 0x412
+	SYS_T_LISTEN                        = 0x413
+	SYS_T_LOOK                          = 0x414
+	SYS_T_OPEN                          = 0x415
+	SYS_T_OPTMGMT                       = 0x416
+	SYS_T_RCV                           = 0x417
+	SYS_T_RCVCONNECT                    = 0x418
+	SYS_T_RCVDIS                        = 0x419
+	SYS_T_SNDUDATA                      = 0x420
+	SYS_T_STRERROR                      = 0x421
+	SYS_T_SYNC                          = 0x422
+	SYS_T_UNBIND                        = 0x423
+	SYS___T_ERRNO                       = 0x424
+	SYS___RECVMSG2                      = 0x425
+	SYS___SENDMSG2                      = 0x426
+	SYS_FATTACH                         = 0x427
+	SYS_FDETACH                         = 0x428
+	SYS_GETMSG                          = 0x429
+	SYS_GETCONTEXT                      = 0x430
+	SYS_SETCONTEXT                      = 0x431
+	SYS_MAKECONTEXT                     = 0x432
+	SYS_SWAPCONTEXT                     = 0x433
+	SYS_PTHREAD_GETSPECIFIC_D8_NP       = 0x434
+	SYS_GETCLIENTID                     = 0x470
+	SYS___GETCLIENTID                   = 0x471
+	SYS_GETSTABLESIZE                   = 0x472
+	SYS_GETIBMOPT                       = 0x473
+	SYS_GETIBMSOCKOPT                   = 0x474
+	SYS_GIVESOCKET                      = 0x475
+	SYS_IBMSFLUSH                       = 0x476
+	SYS_MAXDESC                         = 0x477
+	SYS_SETIBMOPT                       = 0x478
+	SYS_SETIBMSOCKOPT                   = 0x479
+	SYS___SERVER_PWU                    = 0x480
+	SYS_PTHREAD_TAG_NP                  = 0x481
+	SYS___CONSOLE                       = 0x482
+	SYS___WSINIT                        = 0x483
+	SYS___IPTCPN                        = 0x489
+	SYS___SERVER_CLASSIFY               = 0x490
+	SYS___HEAPRPT                       = 0x496
+	SYS___ISBFP                         = 0x500
+	SYS___FP_CAST                       = 0x501
+	SYS___CERTIFICATE                   = 0x502
+	SYS_SEND_FILE                       = 0x503
+	SYS_AIO_CANCEL                      = 0x504
+	SYS_AIO_ERROR                       = 0x505
+	SYS_AIO_READ                        = 0x506
+	SYS_AIO_RETURN                      = 0x507
+	SYS_AIO_SUSPEND                     = 0x508
+	SYS_AIO_WRITE                       = 0x509
+	SYS_PTHREAD_RWLOCK_TRYWRLOCK        = 0x510
+	SYS_PTHREAD_RWLOCK_UNLOCK           = 0x511
+	SYS_PTHREAD_RWLOCK_WRLOCK           = 0x512
+	SYS_PTHREAD_RWLOCKATTR_GETPSHARED   = 0x513
+	SYS_PTHREAD_RWLOCKATTR_SETPSHARED   = 0x514
+	SYS_PTHREAD_RWLOCKATTR_INIT         = 0x515
+	SYS_PTHREAD_RWLOCKATTR_DESTROY      = 0x516
+	SYS___CTTBL                         = 0x517
+	SYS_PTHREAD_MUTEXATTR_SETTYPE       = 0x518
+	SYS_PTHREAD_MUTEXATTR_GETTYPE       = 0x519
+	SYS___FP_UNORDERED                  = 0x520
+	SYS___FP_READ_RND                   = 0x521
+	SYS___FP_READ_RND_B                 = 0x522
+	SYS___FP_SWAP_RND                   = 0x523
+	SYS___FP_SWAP_RND_B                 = 0x524
+	SYS___FP_LEVEL                      = 0x525
+	SYS___FP_BTOH                       = 0x526
+	SYS___FP_HTOB                       = 0x527
+	SYS___FPC_RD                        = 0x528
+	SYS___FPC_WR                        = 0x529
+	SYS_PTHREAD_SETCANCELTYPE           = 0x600
+	SYS_PTHREAD_TESTCANCEL              = 0x601
+	SYS___ATANF_B                       = 0x602
+	SYS___ATANL_B                       = 0x603
+	SYS___CEILF_B                       = 0x604
+	SYS___CEILL_B                       = 0x605
+	SYS___COSF_B                        = 0x606
+	SYS___COSL_B                        = 0x607
+	SYS___FABSF_B                       = 0x608
+	SYS___FABSL_B                       = 0x609
+	SYS___SINF_B                        = 0x610
+	SYS___SINL_B                        = 0x611
+	SYS___TANF_B                        = 0x612
+	SYS___TANL_B                        = 0x613
+	SYS___TANHF_B                       = 0x614
+	SYS___TANHL_B                       = 0x615
+	SYS___ACOSF_B                       = 0x616
+	SYS___ACOSL_B                       = 0x617
+	SYS___ASINF_B                       = 0x618
+	SYS___ASINL_B                       = 0x619
+	SYS___LOGF_B                        = 0x620
+	SYS___LOGL_B                        = 0x621
+	SYS___LOG10F_B                      = 0x622
+	SYS___LOG10L_B                      = 0x623
+	SYS___POWF_B                        = 0x624
+	SYS___POWL_B                        = 0x625
+	SYS___SINHF_B                       = 0x626
+	SYS___SINHL_B                       = 0x627
+	SYS___SQRTF_B                       = 0x628
+	SYS___SQRTL_B                       = 0x629
+	SYS___MODFL_B                       = 0x630
+	SYS_ABSF                            = 0x631
+	SYS_ABSL                            = 0x632
+	SYS_ACOSF                           = 0x633
+	SYS_ACOSL                           = 0x634
+	SYS_ASINF                           = 0x635
+	SYS_ASINL                           = 0x636
+	SYS_ATAN2F                          = 0x637
+	SYS_ATAN2L                          = 0x638
+	SYS_ATANF                           = 0x639
+	SYS_COSHL                           = 0x640
+	SYS_EXPF                            = 0x641
+	SYS_EXPL                            = 0x642
+	SYS_TANHF                           = 0x643
+	SYS_TANHL                           = 0x644
+	SYS_LOG10F                          = 0x645
+	SYS_LOG10L                          = 0x646
+	SYS_LOGF                            = 0x647
+	SYS_LOGL                            = 0x648
+	SYS_POWF                            = 0x649
+	SYS_SINHL                           = 0x650
+	SYS_TANF                            = 0x651
+	SYS_TANL                            = 0x652
+	SYS_FABSF                           = 0x653
+	SYS_FABSL                           = 0x654
+	SYS_FLOORF                          = 0x655
+	SYS_FLOORL                          = 0x656
+	SYS_FMODF                           = 0x657
+	SYS_FMODL                           = 0x658
+	SYS_FREXPF                          = 0x659
+	SYS___CHATTR                        = 0x660
+	SYS___FCHATTR                       = 0x661
+	SYS___TOCCSID                       = 0x662
+	SYS___CSNAMETYPE                    = 0x663
+	SYS___TOCSNAME                      = 0x664
+	SYS___CCSIDTYPE                     = 0x665
+	SYS___AE_CORRESTBL_QUERY            = 0x666
+	SYS___AE_AUTOCONVERT_STATE          = 0x667
+	SYS_DN_FIND                         = 0x668
+	SYS___GETHOSTBYADDR_A               = 0x669
+	SYS___MBLEN_SB_A                    = 0x670
+	SYS___MBLEN_STD_A                   = 0x671
+	SYS___MBLEN_UTF                     = 0x672
+	SYS___MBSTOWCS_A                    = 0x673
+	SYS___MBSTOWCS_STD_A                = 0x674
+	SYS___MBTOWC_A                      = 0x675
+	SYS___MBTOWC_ISO1                   = 0x676
+	SYS___MBTOWC_SBCS                   = 0x677
+	SYS___MBTOWC_MBCS                   = 0x678
+	SYS___MBTOWC_UTF                    = 0x679
+	SYS___CSID_A                        = 0x680
+	SYS___CSID_STD_A                    = 0x681
+	SYS___WCSID_A                       = 0x682
+	SYS___WCSID_STD_A                   = 0x683
+	SYS___WCTOMB_A                      = 0x684
+	SYS___WCTOMB_ISO1                   = 0x685
+	SYS___WCTOMB_STD_A                  = 0x686
+	SYS___WCTOMB_UTF                    = 0x687
+	SYS___WCWIDTH_A                     = 0x688
+	SYS___GETGRNAM_R_A                  = 0x689
+	SYS___READDIR_R_A                   = 0x690
+	SYS___E2A_S                         = 0x691
+	SYS___FNMATCH_A                     = 0x692
+	SYS___FNMATCH_C_A                   = 0x693
+	SYS___EXECL_A                       = 0x694
+	SYS___FNMATCH_STD_A                 = 0x695
+	SYS___REGCOMP_A                     = 0x696
+	SYS___REGCOMP_STD_A                 = 0x697
+	SYS___REGERROR_A                    = 0x698
+	SYS___REGERROR_STD_A                = 0x699
+	SYS___SWPRINTF_A                    = 0x700
+	SYS___FSCANF_A                      = 0x701
+	SYS___SCANF_A                       = 0x702
+	SYS___SSCANF_A                      = 0x703
+	SYS___SWSCANF_A                     = 0x704
+	SYS___ATOF_A                        = 0x705
+	SYS___ATOI_A                        = 0x706
+	SYS___ATOL_A                        = 0x707
+	SYS___STRTOD_A                      = 0x708
+	SYS___STRTOL_A                      = 0x709
+	SYS___L64A_A                        = 0x710
+	SYS___STRERROR_A                    = 0x711
+	SYS___PERROR_A                      = 0x712
+	SYS___FETCH_A                       = 0x713
+	SYS___GETENV_A                      = 0x714
+	SYS___MKSTEMP_A                     = 0x717
+	SYS___PTSNAME_A                     = 0x718
+	SYS___PUTENV_A                      = 0x719
+	SYS___CHDIR_A                       = 0x720
+	SYS___CHOWN_A                       = 0x721
+	SYS___CHROOT_A                      = 0x722
+	SYS___GETCWD_A                      = 0x723
+	SYS___GETWD_A                       = 0x724
+	SYS___LCHOWN_A                      = 0x725
+	SYS___LINK_A                        = 0x726
+	SYS___PATHCONF_A                    = 0x727
+	SYS___IF_NAMEINDEX_A                = 0x728
+	SYS___READLINK_A                    = 0x729
+	SYS___EXTLINK_NP_A                  = 0x730
+	SYS___ISALNUM_A                     = 0x731
+	SYS___ISALPHA_A                     = 0x732
+	SYS___A2E_S                         = 0x733
+	SYS___ISCNTRL_A                     = 0x734
+	SYS___ISDIGIT_A                     = 0x735
+	SYS___ISGRAPH_A                     = 0x736
+	SYS___ISLOWER_A                     = 0x737
+	SYS___ISPRINT_A                     = 0x738
+	SYS___ISPUNCT_A                     = 0x739
+	SYS___ISWALPHA_A                    = 0x740
+	SYS___A2E_L                         = 0x741
+	SYS___ISWCNTRL_A                    = 0x742
+	SYS___ISWDIGIT_A                    = 0x743
+	SYS___ISWGRAPH_A                    = 0x744
+	SYS___ISWLOWER_A                    = 0x745
+	SYS___ISWPRINT_A                    = 0x746
+	SYS___ISWPUNCT_A                    = 0x747
+	SYS___ISWSPACE_A                    = 0x748
+	SYS___ISWUPPER_A                    = 0x749
+	SYS___REMOVE_A                      = 0x750
+	SYS___RENAME_A                      = 0x751
+	SYS___TMPNAM_A                      = 0x752
+	SYS___FOPEN_A                       = 0x753
+	SYS___FREOPEN_A                     = 0x754
+	SYS___CUSERID_A                     = 0x755
+	SYS___POPEN_A                       = 0x756
+	SYS___TEMPNAM_A                     = 0x757
+	SYS___FTW_A                         = 0x758
+	SYS___GETGRENT_A                    = 0x759
+	SYS___INET_NTOP_A                   = 0x760
+	SYS___GETPASS_A                     = 0x761
+	SYS___GETPWENT_A                    = 0x762
+	SYS___GETPWNAM_A                    = 0x763
+	SYS___GETPWUID_A                    = 0x764
+	SYS_____CHECK_RESOURCE_AUTH_NP_A    = 0x765
+	SYS___CHECKSCHENV_A                 = 0x766
+	SYS___CONNECTSERVER_A               = 0x767
+	SYS___CONNECTWORKMGR_A              = 0x768
+	SYS_____CONSOLE_A                   = 0x769
+	SYS___MSGSND_A                      = 0x770
+	SYS___MSGXRCV_A                     = 0x771
+	SYS___NFTW_A                        = 0x772
+	SYS_____PASSWD_A                    = 0x773
+	SYS___PTHREAD_SECURITY_NP_A         = 0x774
+	SYS___QUERYMETRICS_A                = 0x775
+	SYS___QUERYSCHENV                   = 0x776
+	SYS___READV_A                       = 0x777
+	SYS_____SERVER_CLASSIFY_A           = 0x778
+	SYS_____SERVER_INIT_A               = 0x779
+	SYS___W_GETPSENT_A                  = 0x780
+	SYS___WRITEV_A                      = 0x781
+	SYS___W_STATFS_A                    = 0x782
+	SYS___W_STATVFS_A                   = 0x783
+	SYS___FPUTC_A                       = 0x784
+	SYS___PUTCHAR_A                     = 0x785
+	SYS___PUTS_A                        = 0x786
+	SYS___FGETS_A                       = 0x787
+	SYS___GETS_A                        = 0x788
+	SYS___FPUTS_A                       = 0x789
+	SYS___PUTC_A                        = 0x790
+	SYS___AE_THREAD_SETMODE             = 0x791
+	SYS___AE_THREAD_SWAPMODE            = 0x792
+	SYS___GETNETBYADDR_A                = 0x793
+	SYS___GETNETBYNAME_A                = 0x794
+	SYS___GETNETENT_A                   = 0x795
+	SYS___GETPROTOBYNAME_A              = 0x796
+	SYS___GETPROTOBYNUMBER_A            = 0x797
+	SYS___GETPROTOENT_A                 = 0x798
+	SYS___GETSERVBYNAME_A               = 0x799
+	SYS_ACL_FIRST_ENTRY                 = 0x800
+	SYS_ACL_GET_ENTRY                   = 0x801
+	SYS_ACL_VALID                       = 0x802
+	SYS_ACL_CREATE_ENTRY                = 0x803
+	SYS_ACL_DELETE_ENTRY                = 0x804
+	SYS_ACL_UPDATE_ENTRY                = 0x805
+	SYS_ACL_DELETE_FD                   = 0x806
+	SYS_ACL_DELETE_FILE                 = 0x807
+	SYS_ACL_GET_FD                      = 0x808
+	SYS_ACL_GET_FILE                    = 0x809
+	SYS___ERFL_B                        = 0x810
+	SYS___ERFCL_B                       = 0x811
+	SYS___LGAMMAL_B                     = 0x812
+	SYS___SETHOOKEVENTS                 = 0x813
+	SYS_IF_NAMETOINDEX                  = 0x814
+	SYS_IF_INDEXTONAME                  = 0x815
+	SYS_IF_NAMEINDEX                    = 0x816
+	SYS_IF_FREENAMEINDEX                = 0x817
+	SYS_GETADDRINFO                     = 0x818
+	SYS_GETNAMEINFO                     = 0x819
+	SYS___DYNFREE_A                     = 0x820
+	SYS___RES_QUERY_A                   = 0x821
+	SYS___RES_SEARCH_A                  = 0x822
+	SYS___RES_QUERYDOMAIN_A             = 0x823
+	SYS___RES_MKQUERY_A                 = 0x824
+	SYS___RES_SEND_A                    = 0x825
+	SYS___DN_EXPAND_A                   = 0x826
+	SYS___DN_SKIPNAME_A                 = 0x827
+	SYS___DN_COMP_A                     = 0x828
+	SYS___DN_FIND_A                     = 0x829
+	SYS___INET_NTOA_A                   = 0x830
+	SYS___INET_NETWORK_A                = 0x831
+	SYS___ACCEPT_A                      = 0x832
+	SYS___ACCEPT_AND_RECV_A             = 0x833
+	SYS___BIND_A                        = 0x834
+	SYS___CONNECT_A                     = 0x835
+	SYS___GETPEERNAME_A                 = 0x836
+	SYS___GETSOCKNAME_A                 = 0x837
+	SYS___RECVFROM_A                    = 0x838
+	SYS___SENDTO_A                      = 0x839
+	SYS___LCHATTR                       = 0x840
+	SYS___WRITEDOWN                     = 0x841
+	SYS_PTHREAD_MUTEX_INIT2             = 0x842
+	SYS___ACOSHF_B                      = 0x843
+	SYS___ACOSHL_B                      = 0x844
+	SYS___ASINHF_B                      = 0x845
+	SYS___ASINHL_B                      = 0x846
+	SYS___ATANHF_B                      = 0x847
+	SYS___ATANHL_B                      = 0x848
+	SYS___CBRTF_B                       = 0x849
+	SYS___EXP2F_B                       = 0x850
+	SYS___EXP2L_B                       = 0x851
+	SYS___EXPM1F_B                      = 0x852
+	SYS___EXPM1L_B                      = 0x853
+	SYS___FDIMF_B                       = 0x854
+	SYS___FDIM_B                        = 0x855
+	SYS___FDIML_B                       = 0x856
+	SYS___HYPOTF_B                      = 0x857
+	SYS___HYPOTL_B                      = 0x858
+	SYS___LOG1PF_B                      = 0x859
+	SYS___REMQUOF_B                     = 0x860
+	SYS___REMQUO_B                      = 0x861
+	SYS___REMQUOL_B                     = 0x862
+	SYS___TGAMMAF_B                     = 0x863
+	SYS___TGAMMA_B                      = 0x864
+	SYS___TGAMMAL_B                     = 0x865
+	SYS___TRUNCF_B                      = 0x866
+	SYS___TRUNC_B                       = 0x867
+	SYS___TRUNCL_B                      = 0x868
+	SYS___LGAMMAF_B                     = 0x869
+	SYS_ASINHF                          = 0x870
+	SYS_ASINHL                          = 0x871
+	SYS_ATANHF                          = 0x872
+	SYS_ATANHL                          = 0x873
+	SYS_CBRTF                           = 0x874
+	SYS_CBRTL                           = 0x875
+	SYS_COPYSIGNF                       = 0x876
+	SYS_CPYSIGNF                        = 0x876
+	SYS_COPYSIGNL                       = 0x877
+	SYS_CPYSIGNL                        = 0x877
+	SYS_COTANF                          = 0x878
+	SYS___COTANF                        = 0x878
+	SYS_COTAN                           = 0x879
+	SYS___COTAN                         = 0x879
+	SYS_FDIM                            = 0x881
+	SYS_FDIML                           = 0x882
+	SYS_HYPOTF                          = 0x883
+	SYS_HYPOTL                          = 0x884
+	SYS_LOG1PF                          = 0x885
+	SYS_LOG1PL                          = 0x886
+	SYS_LOG2F                           = 0x887
+	SYS_LOG2                            = 0x888
+	SYS_LOG2L                           = 0x889
+	SYS_TGAMMA                          = 0x890
+	SYS_TGAMMAL                         = 0x891
+	SYS_TRUNCF                          = 0x892
+	SYS_TRUNC                           = 0x893
+	SYS_TRUNCL                          = 0x894
+	SYS_LGAMMAF                         = 0x895
+	SYS_LGAMMAL                         = 0x896
+	SYS_LROUNDF                         = 0x897
+	SYS_LROUND                          = 0x898
+	SYS_ERFF                            = 0x899
+	SYS___COSHF_H                       = 0x900
+	SYS___COSHL_H                       = 0x901
+	SYS___COTAN_H                       = 0x902
+	SYS___COTANF_H                      = 0x903
+	SYS___COTANL_H                      = 0x904
+	SYS___ERF_H                         = 0x905
+	SYS___ERFF_H                        = 0x906
+	SYS___ERFL_H                        = 0x907
+	SYS___ERFC_H                        = 0x908
+	SYS___ERFCF_H                       = 0x909
+	SYS___FDIMF_H                       = 0x910
+	SYS___FDIML_H                       = 0x911
+	SYS___FMOD_H                        = 0x912
+	SYS___FMODF_H                       = 0x913
+	SYS___FMODL_H                       = 0x914
+	SYS___GAMMA_H                       = 0x915
+	SYS___HYPOT_H                       = 0x916
+	SYS___ILOGB_H                       = 0x917
+	SYS___LGAMMA_H                      = 0x918
+	SYS___LGAMMAF_H                     = 0x919
+	SYS___LOG2L_H                       = 0x920
+	SYS___LOG1P_H                       = 0x921
+	SYS___LOG10_H                       = 0x922
+	SYS___LOG10F_H                      = 0x923
+	SYS___LOG10L_H                      = 0x924
+	SYS___LROUND_H                      = 0x925
+	SYS___LROUNDF_H                     = 0x926
+	SYS___NEXTAFTER_H                   = 0x927
+	SYS___POW_H                         = 0x928
+	SYS___POWF_H                        = 0x929
+	SYS___SINL_H                        = 0x930
+	SYS___SINH_H                        = 0x931
+	SYS___SINHF_H                       = 0x932
+	SYS___SINHL_H                       = 0x933
+	SYS___SQRT_H                        = 0x934
+	SYS___SQRTF_H                       = 0x935
+	SYS___SQRTL_H                       = 0x936
+	SYS___TAN_H                         = 0x937
+	SYS___TANF_H                        = 0x938
+	SYS___TANL_H                        = 0x939
+	SYS___TRUNCF_H                      = 0x940
+	SYS___TRUNCL_H                      = 0x941
+	SYS___COSH_H                        = 0x942
+	SYS___LE_DEBUG_SET_RESUME_MCH       = 0x943
+	SYS_VFSCANF                         = 0x944
+	SYS_VSCANF                          = 0x946
+	SYS_VSSCANF                         = 0x948
+	SYS_IMAXABS                         = 0x950
+	SYS_IMAXDIV                         = 0x951
+	SYS_STRTOIMAX                       = 0x952
+	SYS_STRTOUMAX                       = 0x953
+	SYS_WCSTOIMAX                       = 0x954
+	SYS_WCSTOUMAX                       = 0x955
+	SYS_ATOLL                           = 0x956
+	SYS_STRTOF                          = 0x957
+	SYS_STRTOLD                         = 0x958
+	SYS_WCSTOF                          = 0x959
+	SYS_INET6_RTH_GETADDR               = 0x960
+	SYS_INET6_OPT_INIT                  = 0x961
+	SYS_INET6_OPT_APPEND                = 0x962
+	SYS_INET6_OPT_FINISH                = 0x963
+	SYS_INET6_OPT_SET_VAL               = 0x964
+	SYS_INET6_OPT_NEXT                  = 0x965
+	SYS_INET6_OPT_FIND                  = 0x966
+	SYS_INET6_OPT_GET_VAL               = 0x967
+	SYS___POW_I                         = 0x987
+	SYS___POW_I_B                       = 0x988
+	SYS___POW_I_H                       = 0x989
+	SYS___CABS_H                        = 0x990
+	SYS_CABSF                           = 0x991
+	SYS___CABSF_B                       = 0x992
+	SYS___CABSF_H                       = 0x993
+	SYS_CABSL                           = 0x994
+	SYS___CABSL_B                       = 0x995
+	SYS___CABSL_H                       = 0x996
+	SYS_CACOS                           = 0x997
+	SYS___CACOS_B                       = 0x998
+	SYS___CACOS_H                       = 0x999
+)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc.go
index 295859c503..7a8161c1d1 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc.go
@@ -1,6 +1,7 @@
 // cgo -godefs types_aix.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build ppc && aix
 // +build ppc,aix
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc64.go
index a9ee0ffd44..07ed733c51 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc64.go
@@ -1,6 +1,7 @@
 // cgo -godefs types_aix.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build ppc64 && aix
 // +build ppc64,aix
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_386.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_386.go
index 725b4bee27..54db433355 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_386.go
@@ -1,6 +1,7 @@
 // cgo -godefs types_darwin.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build 386 && darwin
 // +build 386,darwin
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go
index bb39542f7a..eb73e52fb6 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go
@@ -1,6 +1,7 @@
 // cgo -godefs types_darwin.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build amd64 && darwin
 // +build amd64,darwin
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm.go
index f2a77bc4e2..8606d654e5 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm.go
@@ -1,6 +1,7 @@
 // cgo -godefs types_darwin.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm && darwin
 // +build arm,darwin
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go
index ec5b559272..dcb51f8404 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go
@@ -1,6 +1,7 @@
 // cgo -godefs types_darwin.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm64 && darwin
 // +build arm64,darwin
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_dragonfly_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_dragonfly_amd64.go
index 85506a05d4..1d049d7a12 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_dragonfly_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_dragonfly_amd64.go
@@ -1,6 +1,7 @@
 // cgo -godefs types_dragonfly.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build amd64 && dragonfly
 // +build amd64,dragonfly
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go
index 3e9dad33e3..c51bc88ffd 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go
@@ -1,6 +1,7 @@
 // cgo -godefs types_freebsd.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build 386 && freebsd
 // +build 386,freebsd
 
 package unix
@@ -250,6 +251,14 @@ type RawSockaddrAny struct {
 
 type _Socklen uint32
 
+type Xucred struct {
+	Version uint32
+	Uid     uint32
+	Ngroups int16
+	Groups  [16]uint32
+	_       *byte
+}
+
 type Linger struct {
 	Onoff  int32
 	Linger int32
@@ -312,6 +321,7 @@ const (
 	SizeofSockaddrAny      = 0x6c
 	SizeofSockaddrUnix     = 0x6a
 	SizeofSockaddrDatalink = 0x36
+	SizeofXucred           = 0x50
 	SizeofLinger           = 0x8
 	SizeofIovec            = 0x8
 	SizeofIPMreq           = 0x8
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go
index e00e615544..395b691871 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go
@@ -1,6 +1,7 @@
 // cgo -godefs types_freebsd.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build amd64 && freebsd
 // +build amd64,freebsd
 
 package unix
@@ -246,6 +247,14 @@ type RawSockaddrAny struct {
 
 type _Socklen uint32
 
+type Xucred struct {
+	Version uint32
+	Uid     uint32
+	Ngroups int16
+	Groups  [16]uint32
+	_       *byte
+}
+
 type Linger struct {
 	Onoff  int32
 	Linger int32
@@ -308,6 +317,7 @@ const (
 	SizeofSockaddrAny      = 0x6c
 	SizeofSockaddrUnix     = 0x6a
 	SizeofSockaddrDatalink = 0x36
+	SizeofXucred           = 0x58
 	SizeofLinger           = 0x8
 	SizeofIovec            = 0x10
 	SizeofIPMreq           = 0x8
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go
index 5da13c871b..d3f9d2541b 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go
@@ -1,6 +1,7 @@
 // cgo -godefs -- -fsigned-char types_freebsd.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm && freebsd
 // +build arm,freebsd
 
 package unix
@@ -248,6 +249,14 @@ type RawSockaddrAny struct {
 
 type _Socklen uint32
 
+type Xucred struct {
+	Version uint32
+	Uid     uint32
+	Ngroups int16
+	Groups  [16]uint32
+	_       *byte
+}
+
 type Linger struct {
 	Onoff  int32
 	Linger int32
@@ -310,6 +319,7 @@ const (
 	SizeofSockaddrAny      = 0x6c
 	SizeofSockaddrUnix     = 0x6a
 	SizeofSockaddrDatalink = 0x36
+	SizeofXucred           = 0x50
 	SizeofLinger           = 0x8
 	SizeofIovec            = 0x8
 	SizeofIPMreq           = 0x8
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go
index 995ecf9d4e..434d6e8e83 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go
@@ -1,6 +1,7 @@
 // cgo -godefs -- -fsigned-char types_freebsd.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm64 && freebsd
 // +build arm64,freebsd
 
 package unix
@@ -246,6 +247,14 @@ type RawSockaddrAny struct {
 
 type _Socklen uint32
 
+type Xucred struct {
+	Version uint32
+	Uid     uint32
+	Ngroups int16
+	Groups  [16]uint32
+	_       *byte
+}
+
 type Linger struct {
 	Onoff  int32
 	Linger int32
@@ -308,6 +317,7 @@ const (
 	SizeofSockaddrAny      = 0x6c
 	SizeofSockaddrUnix     = 0x6a
 	SizeofSockaddrDatalink = 0x36
+	SizeofXucred           = 0x58
 	SizeofLinger           = 0x8
 	SizeofIovec            = 0x10
 	SizeofIPMreq           = 0x8
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go
index ddd655769d..d3a18713bb 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go
@@ -1,5 +1,6 @@
 // Code generated by mkmerge.go; DO NOT EDIT.
 
+//go:build linux
 // +build linux
 
 package unix
@@ -83,7 +84,7 @@ type FileCloneRange struct {
 	Dest_offset uint64
 }
 
-type FileDedupeRange struct {
+type RawFileDedupeRange struct {
 	Src_offset uint64
 	Src_length uint64
 	Dest_count uint16
@@ -91,6 +92,21 @@ type FileDedupeRange struct {
 	Reserved2  uint32
 }
 
+type RawFileDedupeRangeInfo struct {
+	Dest_fd       int64
+	Dest_offset   uint64
+	Bytes_deduped uint64
+	Status        int32
+	Reserved      uint32
+}
+
+const (
+	SizeofRawFileDedupeRange     = 0x18
+	SizeofRawFileDedupeRangeInfo = 0x20
+	FILE_DEDUPE_RANGE_SAME       = 0x0
+	FILE_DEDUPE_RANGE_DIFFERS    = 0x1
+)
+
 type FscryptPolicy struct {
 	Version                   uint8
 	Contents_encryption_mode  uint8
@@ -3681,3 +3697,15 @@ const (
 	ETHTOOL_A_TUNNEL_INFO_UDP_PORTS           = 0x2
 	ETHTOOL_A_TUNNEL_INFO_MAX                 = 0x2
 )
+
+type (
+	HIDRawReportDescriptor struct {
+		Size  uint32
+		Value [4096]uint8
+	}
+	HIDRawDevInfo struct {
+		Bustype uint32
+		Vendor  int16
+		Product int16
+	}
+)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_386.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_386.go
index 088bd77e3b..4d4d283de5 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_386.go
@@ -1,6 +1,7 @@
 // cgo -godefs -- -Wall -Werror -static -I/tmp/include -m32 /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build 386 && linux
 // +build 386,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go
index 078d958ec9..8a2eed5ec4 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go
@@ -1,6 +1,7 @@
 // cgo -godefs -- -Wall -Werror -static -I/tmp/include -m64 /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build amd64 && linux
 // +build amd64,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go
index 2d39122f41..94b34add64 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go
@@ -1,6 +1,7 @@
 // cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm && linux
 // +build arm,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go
index 304cbd0453..2143de4d59 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go
@@ -1,6 +1,7 @@
 // cgo -godefs -- -Wall -Werror -static -I/tmp/include -fsigned-char /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm64 && linux
 // +build arm64,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go
index 7d9d57006a..a40216eee6 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go
@@ -1,6 +1,7 @@
 // cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build mips && linux
 // +build mips,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go
index a1eb2577b0..e834b069fd 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go
@@ -1,6 +1,7 @@
 // cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build mips64 && linux
 // +build mips64,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go
index 2e5ce3b6a6..e31083b048 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go
@@ -1,6 +1,7 @@
 // cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build mips64le && linux
 // +build mips64le,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go
index bbaa1200b6..42811f7fb5 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go
@@ -1,6 +1,7 @@
 // cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build mipsle && linux
 // +build mipsle,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go
index 0e6e8a7748..2a3afbaef9 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go
@@ -1,6 +1,7 @@
 // cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build ppc64 && linux
 // +build ppc64,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go
index 7382f385fa..c0de30a658 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go
@@ -1,6 +1,7 @@
 // cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build ppc64le && linux
 // +build ppc64le,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
index 28d5522166..74faf2e91f 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
@@ -1,6 +1,7 @@
 // cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build riscv64 && linux
 // +build riscv64,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go
index a91a7a44bd..9a8f0c2c6a 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go
@@ -1,6 +1,7 @@
 // cgo -godefs -- -Wall -Werror -static -I/tmp/include -fsigned-char /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build s390x && linux
 // +build s390x,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go
index f824b2358d..72cdda75bd 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go
@@ -1,6 +1,7 @@
 // cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build sparc64 && linux
 // +build sparc64,linux
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_386.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_386.go
index 3f11f88e3c..b10e73abf9 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_386.go
@@ -1,6 +1,7 @@
 // cgo -godefs types_netbsd.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build 386 && netbsd
 // +build 386,netbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_amd64.go
index 0bed83af57..28ed6d55ae 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_amd64.go
@@ -1,6 +1,7 @@
 // cgo -godefs types_netbsd.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build amd64 && netbsd
 // +build amd64,netbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm.go
index e4e3bf736d..4ba196ebe5 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm.go
@@ -1,6 +1,7 @@
 // cgo -godefs types_netbsd.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm && netbsd
 // +build arm,netbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm64.go
index efac861bb7..dd642bd9c8 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm64.go
@@ -1,6 +1,7 @@
 // cgo -godefs types_netbsd.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm64 && netbsd
 // +build arm64,netbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_386.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_386.go
index 80fa295f1d..1fdb0e5fa5 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_386.go
@@ -1,6 +1,7 @@
 // cgo -godefs types_openbsd.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build 386 && openbsd
 // +build 386,openbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_amd64.go
index 560dd6d08a..e2fc93c7c0 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_amd64.go
@@ -1,6 +1,7 @@
 // cgo -godefs types_openbsd.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build amd64 && openbsd
 // +build amd64,openbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm.go
index 0c1700fa43..8d34b5a2fc 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm.go
@@ -1,6 +1,7 @@
 // cgo -godefs -- -fsigned-char types_openbsd.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm && openbsd
 // +build arm,openbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm64.go
index 5b3e46633e..ea8f1a0d9b 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm64.go
@@ -1,6 +1,7 @@
 // cgo -godefs -- -fsigned-char types_openbsd.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build arm64 && openbsd
 // +build arm64,openbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_mips64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_mips64.go
index 62bff16709..ec6e8bc3f1 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_mips64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_mips64.go
@@ -1,6 +1,7 @@
 // cgo -godefs -- -fsigned-char types_openbsd.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build mips64 && openbsd
 // +build mips64,openbsd
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_solaris_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_solaris_amd64.go
index ca512aff7f..85effef9c1 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_solaris_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_solaris_amd64.go
@@ -1,6 +1,7 @@
 // cgo -godefs types_solaris.go | go run mkpost.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 
+//go:build amd64 && solaris
 // +build amd64,solaris
 
 package unix
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go
new file mode 100644
index 0000000000..8bffde78e5
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go
@@ -0,0 +1,402 @@
+// Copyright 2020 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.
+
+//go:build zos && s390x
+// +build zos,s390x
+
+// Hand edited based on ztypes_linux_s390x.go
+// TODO: auto-generate.
+
+package unix
+
+const (
+	SizeofPtr      = 0x8
+	SizeofShort    = 0x2
+	SizeofInt      = 0x4
+	SizeofLong     = 0x8
+	SizeofLongLong = 0x8
+	PathMax        = 0x1000
+)
+
+const (
+	SizeofSockaddrAny   = 128
+	SizeofCmsghdr       = 12
+	SizeofIPMreq        = 8
+	SizeofIPv6Mreq      = 20
+	SizeofICMPv6Filter  = 32
+	SizeofIPv6MTUInfo   = 32
+	SizeofLinger        = 8
+	SizeofSockaddrInet4 = 16
+	SizeofSockaddrInet6 = 28
+	SizeofTCPInfo       = 0x68
+)
+
+type (
+	_C_short     int16
+	_C_int       int32
+	_C_long      int64
+	_C_long_long int64
+)
+
+type Timespec struct {
+	Sec  int64
+	Nsec int64
+}
+
+type Timeval struct {
+	Sec  int64
+	Usec int64
+}
+
+type timeval_zos struct { //correct (with padding and all)
+	Sec  int64
+	_    [4]byte // pad
+	Usec int32
+}
+
+type Tms struct { //clock_t is 4-byte unsigned int in zos
+	Utime  uint32
+	Stime  uint32
+	Cutime uint32
+	Cstime uint32
+}
+
+type Time_t int64
+
+type Utimbuf struct {
+	Actime  int64
+	Modtime int64
+}
+
+type Utsname struct {
+	Sysname    [65]byte
+	Nodename   [65]byte
+	Release    [65]byte
+	Version    [65]byte
+	Machine    [65]byte
+	Domainname [65]byte
+}
+
+type RawSockaddrInet4 struct {
+	Len    uint8
+	Family uint8
+	Port   uint16
+	Addr   [4]byte /* in_addr */
+	Zero   [8]uint8
+}
+
+type RawSockaddrInet6 struct {
+	Len      uint8
+	Family   uint8
+	Port     uint16
+	Flowinfo uint32
+	Addr     [16]byte /* in6_addr */
+	Scope_id uint32
+}
+
+type RawSockaddrUnix struct {
+	Len    uint8
+	Family uint8
+	Path   [108]int8
+}
+
+type RawSockaddr struct {
+	Len    uint8
+	Family uint8
+	Data   [14]uint8
+}
+
+type RawSockaddrAny struct {
+	Addr RawSockaddr
+	_    [112]uint8 // pad
+}
+
+type _Socklen uint32
+
+type Linger struct {
+	Onoff  int32
+	Linger int32
+}
+
+type Iovec struct {
+	Base *byte
+	Len  uint64
+}
+
+type IPMreq struct {
+	Multiaddr [4]byte /* in_addr */
+	Interface [4]byte /* in_addr */
+}
+
+type IPv6Mreq struct {
+	Multiaddr [16]byte /* in6_addr */
+	Interface uint32
+}
+
+type Msghdr struct {
+	Name       *byte
+	Iov        *Iovec
+	Control    *byte
+	Flags      int32
+	Namelen    int32
+	Iovlen     int32
+	Controllen int32
+}
+
+type Cmsghdr struct {
+	Len   int32
+	Level int32
+	Type  int32
+}
+
+type Inet4Pktinfo struct {
+	Addr    [4]byte /* in_addr */
+	Ifindex uint32
+}
+
+type Inet6Pktinfo struct {
+	Addr    [16]byte /* in6_addr */
+	Ifindex uint32
+}
+
+type IPv6MTUInfo struct {
+	Addr RawSockaddrInet6
+	Mtu  uint32
+}
+
+type ICMPv6Filter struct {
+	Data [8]uint32
+}
+
+type TCPInfo struct {
+	State          uint8
+	Ca_state       uint8
+	Retransmits    uint8
+	Probes         uint8
+	Backoff        uint8
+	Options        uint8
+	Rto            uint32
+	Ato            uint32
+	Snd_mss        uint32
+	Rcv_mss        uint32
+	Unacked        uint32
+	Sacked         uint32
+	Lost           uint32
+	Retrans        uint32
+	Fackets        uint32
+	Last_data_sent uint32
+	Last_ack_sent  uint32
+	Last_data_recv uint32
+	Last_ack_recv  uint32
+	Pmtu           uint32
+	Rcv_ssthresh   uint32
+	Rtt            uint32
+	Rttvar         uint32
+	Snd_ssthresh   uint32
+	Snd_cwnd       uint32
+	Advmss         uint32
+	Reordering     uint32
+	Rcv_rtt        uint32
+	Rcv_space      uint32
+	Total_retrans  uint32
+}
+
+type _Gid_t uint32
+
+type rusage_zos struct {
+	Utime timeval_zos
+	Stime timeval_zos
+}
+
+type Rusage struct {
+	Utime    Timeval
+	Stime    Timeval
+	Maxrss   int64
+	Ixrss    int64
+	Idrss    int64
+	Isrss    int64
+	Minflt   int64
+	Majflt   int64
+	Nswap    int64
+	Inblock  int64
+	Oublock  int64
+	Msgsnd   int64
+	Msgrcv   int64
+	Nsignals int64
+	Nvcsw    int64
+	Nivcsw   int64
+}
+
+type Rlimit struct {
+	Cur uint64
+	Max uint64
+}
+
+// { int, short, short } in poll.h
+type PollFd struct {
+	Fd      int32
+	Events  int16
+	Revents int16
+}
+
+type Stat_t struct { //Linux Definition
+	Dev     uint64
+	Ino     uint64
+	Nlink   uint64
+	Mode    uint32
+	Uid     uint32
+	Gid     uint32
+	_       int32
+	Rdev    uint64
+	Size    int64
+	Atim    Timespec
+	Mtim    Timespec
+	Ctim    Timespec
+	Blksize int64
+	Blocks  int64
+	_       [3]int64
+}
+
+type Stat_LE_t struct {
+	_            [4]byte // eye catcher
+	Length       uint16
+	Version      uint16
+	Mode         int32
+	Ino          uint32
+	Dev          uint32
+	Nlink        int32
+	Uid          int32
+	Gid          int32
+	Size         int64
+	Atim31       [4]byte
+	Mtim31       [4]byte
+	Ctim31       [4]byte
+	Rdev         uint32
+	Auditoraudit uint32
+	Useraudit    uint32
+	Blksize      int32
+	Creatim31    [4]byte
+	AuditID      [16]byte
+	_            [4]byte // rsrvd1
+	File_tag     struct {
+		Ccsid   uint16
+		Txtflag uint16 // aggregating Txflag:1 deferred:1 rsvflags:14
+	}
+	CharsetID [8]byte
+	Blocks    int64
+	Genvalue  uint32
+	Reftim31  [4]byte
+	Fid       [8]byte
+	Filefmt   byte
+	Fspflag2  byte
+	_         [2]byte // rsrvd2
+	Ctimemsec int32
+	Seclabel  [8]byte
+	_         [4]byte // rsrvd3
+	_         [4]byte // rsrvd4
+	Atim      Time_t
+	Mtim      Time_t
+	Ctim      Time_t
+	Creatim   Time_t
+	Reftim    Time_t
+	_         [24]byte // rsrvd5
+}
+
+type Statvfs_t struct {
+	ID          [4]byte
+	Len         int32
+	Bsize       uint64
+	Blocks      uint64
+	Usedspace   uint64
+	Bavail      uint64
+	Flag        uint64
+	Maxfilesize int64
+	_           [16]byte
+	Frsize      uint64
+	Bfree       uint64
+	Files       uint32
+	Ffree       uint32
+	Favail      uint32
+	Namemax31   uint32
+	Invarsec    uint32
+	_           [4]byte
+	Fsid        uint64
+	Namemax     uint64
+}
+
+type Statfs_t struct {
+	Type    uint32
+	Bsize   uint64
+	Blocks  uint64
+	Bfree   uint64
+	Bavail  uint64
+	Files   uint32
+	Ffree   uint32
+	Fsid    uint64
+	Namelen uint64
+	Frsize  uint64
+	Flags   uint64
+}
+
+type Dirent struct {
+	Reclen uint16
+	Namlen uint16
+	Ino    uint32
+	Extra  uintptr
+	Name   [256]byte
+}
+
+// This struct is packed on z/OS so it can't be used directly.
+type Flock_t struct {
+	Type   int16
+	Whence int16
+	Start  int64
+	Len    int64
+	Pid    int32
+}
+
+type Termios struct {
+	Cflag uint32
+	Iflag uint32
+	Lflag uint32
+	Oflag uint32
+	Cc    [11]uint8
+}
+
+type Winsize struct {
+	Row    uint16
+	Col    uint16
+	Xpixel uint16
+	Ypixel uint16
+}
+
+type W_Mnth struct {
+	Hid   [4]byte
+	Size  int32
+	Cur1  int32 //32bit pointer
+	Cur2  int32 //^
+	Devno uint32
+	_     [4]byte
+}
+
+type W_Mntent struct {
+	Fstype       uint32
+	Mode         uint32
+	Dev          uint32
+	Parentdev    uint32
+	Rootino      uint32
+	Status       byte
+	Ddname       [9]byte
+	Fstname      [9]byte
+	Fsname       [45]byte
+	Pathlen      uint32
+	Mountpoint   [1024]byte
+	Jobname      [8]byte
+	PID          int32
+	Parmoffset   int32
+	Parmlen      int16
+	Owner        [8]byte
+	Quiesceowner [8]byte
+	_            [38]byte
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/windows/exec_windows.go b/src/cmd/vendor/golang.org/x/sys/windows/exec_windows.go
index 3606c3a8b3..9eb1fb633a 100644
--- a/src/cmd/vendor/golang.org/x/sys/windows/exec_windows.go
+++ b/src/cmd/vendor/golang.org/x/sys/windows/exec_windows.go
@@ -6,6 +6,11 @@
 
 package windows
 
+import (
+	errorspkg "errors"
+	"unsafe"
+)
+
 // EscapeArg rewrites command line argument s as prescribed
 // in http://msdn.microsoft.com/en-us/library/ms880421.
 // This function returns "" (2 double quotes) if s is empty.
@@ -95,3 +100,33 @@ func FullPath(name string) (path string, err error) {
 		}
 	}
 }
+
+// NewProcThreadAttributeList allocates a new ProcThreadAttributeList, with the requested maximum number of attributes.
+func NewProcThreadAttributeList(maxAttrCount uint32) (*ProcThreadAttributeList, error) {
+	var size uintptr
+	err := initializeProcThreadAttributeList(nil, maxAttrCount, 0, &size)
+	if err != ERROR_INSUFFICIENT_BUFFER {
+		if err == nil {
+			return nil, errorspkg.New("unable to query buffer size from InitializeProcThreadAttributeList")
+		}
+		return nil, err
+	}
+	const psize = unsafe.Sizeof(uintptr(0))
+	// size is guaranteed to be ≥1 by InitializeProcThreadAttributeList.
+	al := (*ProcThreadAttributeList)(unsafe.Pointer(&make([]unsafe.Pointer, (size+psize-1)/psize)[0]))
+	err = initializeProcThreadAttributeList(al, maxAttrCount, 0, &size)
+	if err != nil {
+		return nil, err
+	}
+	return al, err
+}
+
+// Update modifies the ProcThreadAttributeList using UpdateProcThreadAttribute.
+func (al *ProcThreadAttributeList) Update(attribute uintptr, flags uint32, value unsafe.Pointer, size uintptr, prevValue unsafe.Pointer, returnedSize *uintptr) error {
+	return updateProcThreadAttribute(al, flags, attribute, value, size, prevValue, returnedSize)
+}
+
+// Delete frees ProcThreadAttributeList's resources.
+func (al *ProcThreadAttributeList) Delete() {
+	deleteProcThreadAttributeList(al)
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/windows/mkerrors.bash b/src/cmd/vendor/golang.org/x/sys/windows/mkerrors.bash
index 2163843a11..58e0188fb7 100644
--- a/src/cmd/vendor/golang.org/x/sys/windows/mkerrors.bash
+++ b/src/cmd/vendor/golang.org/x/sys/windows/mkerrors.bash
@@ -9,6 +9,8 @@ shopt -s nullglob
 
 winerror="$(printf '%s\n' "/mnt/c/Program Files (x86)/Windows Kits/"/*/Include/*/shared/winerror.h | sort -Vr | head -n 1)"
 [[ -n $winerror ]] || { echo "Unable to find winerror.h" >&2; exit 1; }
+ntstatus="$(printf '%s\n' "/mnt/c/Program Files (x86)/Windows Kits/"/*/Include/*/shared/ntstatus.h | sort -Vr | head -n 1)"
+[[ -n $ntstatus ]] || { echo "Unable to find ntstatus.h" >&2; exit 1; }
 
 declare -A errors
 
@@ -59,5 +61,10 @@ declare -A errors
 		echo "$key $vtype = $value"
 	done < "$winerror"
 
+	while read -r line; do
+		[[ $line =~ ^#define\ (STATUS_[^\s]+)\ +\(\(NTSTATUS\)((0x)?[0-9a-fA-F]+)L?\) ]] || continue
+		echo "${BASH_REMATCH[1]} NTStatus = ${BASH_REMATCH[2]}"
+	done < "$ntstatus"
+
 	echo ")"
 } | gofmt > "zerrors_windows.go"
diff --git a/src/cmd/vendor/golang.org/x/sys/windows/security_windows.go b/src/cmd/vendor/golang.org/x/sys/windows/security_windows.go
index 69eb462c59..0e428ecbbd 100644
--- a/src/cmd/vendor/golang.org/x/sys/windows/security_windows.go
+++ b/src/cmd/vendor/golang.org/x/sys/windows/security_windows.go
@@ -908,6 +908,19 @@ type SECURITY_DESCRIPTOR struct {
 	dacl     *ACL
 }
 
+type SECURITY_QUALITY_OF_SERVICE struct {
+	Length              uint32
+	ImpersonationLevel  uint32
+	ContextTrackingMode byte
+	EffectiveOnly       byte
+}
+
+// Constants for the ContextTrackingMode field of SECURITY_QUALITY_OF_SERVICE.
+const (
+	SECURITY_STATIC_TRACKING  = 0
+	SECURITY_DYNAMIC_TRACKING = 1
+)
+
 type SecurityAttributes struct {
 	Length             uint32
 	SecurityDescriptor *SECURITY_DESCRIPTOR
diff --git a/src/cmd/vendor/golang.org/x/sys/windows/syscall_windows.go b/src/cmd/vendor/golang.org/x/sys/windows/syscall_windows.go
index 0197df8727..bb6aaf89e4 100644
--- a/src/cmd/vendor/golang.org/x/sys/windows/syscall_windows.go
+++ b/src/cmd/vendor/golang.org/x/sys/windows/syscall_windows.go
@@ -8,6 +8,8 @@ package windows
 
 import (
 	errorspkg "errors"
+	"fmt"
+	"runtime"
 	"sync"
 	"syscall"
 	"time"
@@ -65,9 +67,8 @@ const (
 	LOCKFILE_FAIL_IMMEDIATELY = 0x00000001
 	LOCKFILE_EXCLUSIVE_LOCK   = 0x00000002
 
-	// Return values of SleepEx and other APC functions
-	STATUS_USER_APC    = 0x000000C0
-	WAIT_IO_COMPLETION = STATUS_USER_APC
+	// Return value of SleepEx and other APC functions
+	WAIT_IO_COMPLETION = 0x000000C0
 )
 
 // StringToUTF16 is deprecated. Use UTF16FromString instead.
@@ -180,6 +181,11 @@ func NewCallbackCDecl(fn interface{}) uintptr {
 //sys	IsWow64Process(handle Handle, isWow64 *bool) (err error) = IsWow64Process
 //sys	IsWow64Process2(handle Handle, processMachine *uint16, nativeMachine *uint16) (err error) = IsWow64Process2?
 //sys	CreateFile(name *uint16, access uint32, mode uint32, sa *SecurityAttributes, createmode uint32, attrs uint32, templatefile Handle) (handle Handle, err error) [failretval==InvalidHandle] = CreateFileW
+//sys	CreateNamedPipe(name *uint16, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *SecurityAttributes) (handle Handle, err error)  [failretval==InvalidHandle] = CreateNamedPipeW
+//sys	ConnectNamedPipe(pipe Handle, overlapped *Overlapped) (err error)
+//sys	GetNamedPipeInfo(pipe Handle, flags *uint32, outSize *uint32, inSize *uint32, maxInstances *uint32) (err error)
+//sys	GetNamedPipeHandleState(pipe Handle, state *uint32, curInstances *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32, userName *uint16, maxUserNameSize uint32) (err error) = GetNamedPipeHandleStateW
+//sys	SetNamedPipeHandleState(pipe Handle, state *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32) (err error) = SetNamedPipeHandleState
 //sys	ReadFile(handle Handle, buf []byte, done *uint32, overlapped *Overlapped) (err error)
 //sys	WriteFile(handle Handle, buf []byte, done *uint32, overlapped *Overlapped) (err error)
 //sys	GetOverlappedResult(handle Handle, overlapped *Overlapped, done *uint32, wait bool) (err error)
@@ -208,12 +214,15 @@ func NewCallbackCDecl(fn interface{}) uintptr {
 //sys	GetSystemTimeAsFileTime(time *Filetime)
 //sys	GetSystemTimePreciseAsFileTime(time *Filetime)
 //sys	GetTimeZoneInformation(tzi *Timezoneinformation) (rc uint32, err error) [failretval==0xffffffff]
-//sys	CreateIoCompletionPort(filehandle Handle, cphandle Handle, key uint32, threadcnt uint32) (handle Handle, err error)
-//sys	GetQueuedCompletionStatus(cphandle Handle, qty *uint32, key *uint32, overlapped **Overlapped, timeout uint32) (err error)
-//sys	PostQueuedCompletionStatus(cphandle Handle, qty uint32, key uint32, overlapped *Overlapped) (err error)
+//sys	CreateIoCompletionPort(filehandle Handle, cphandle Handle, key uintptr, threadcnt uint32) (handle Handle, err error)
+//sys	GetQueuedCompletionStatus(cphandle Handle, qty *uint32, key *uintptr, overlapped **Overlapped, timeout uint32) (err error)
+//sys	PostQueuedCompletionStatus(cphandle Handle, qty uint32, key uintptr, overlapped *Overlapped) (err error)
 //sys	CancelIo(s Handle) (err error)
 //sys	CancelIoEx(s Handle, o *Overlapped) (err error)
 //sys	CreateProcess(appName *uint16, commandLine *uint16, procSecurity *SecurityAttributes, threadSecurity *SecurityAttributes, inheritHandles bool, creationFlags uint32, env *uint16, currentDir *uint16, startupInfo *StartupInfo, outProcInfo *ProcessInformation) (err error) = CreateProcessW
+//sys   initializeProcThreadAttributeList(attrlist *ProcThreadAttributeList, attrcount uint32, flags uint32, size *uintptr) (err error) = InitializeProcThreadAttributeList
+//sys   deleteProcThreadAttributeList(attrlist *ProcThreadAttributeList) = DeleteProcThreadAttributeList
+//sys   updateProcThreadAttribute(attrlist *ProcThreadAttributeList, flags uint32, attr uintptr, value unsafe.Pointer, size uintptr, prevvalue unsafe.Pointer, returnedsize *uintptr) (err error) = UpdateProcThreadAttribute
 //sys	OpenProcess(desiredAccess uint32, inheritHandle bool, processId uint32) (handle Handle, err error)
 //sys	ShellExecute(hwnd Handle, verb *uint16, file *uint16, args *uint16, cwd *uint16, showCmd int32) (err error) [failretval<=32] = shell32.ShellExecuteW
 //sys	GetWindowThreadProcessId(hwnd HWND, pid *uint32) (tid uint32, err error) = user32.GetWindowThreadProcessId
@@ -248,13 +257,14 @@ func NewCallbackCDecl(fn interface{}) uintptr {
 //sys	GetCommandLine() (cmd *uint16) = kernel32.GetCommandLineW
 //sys	CommandLineToArgv(cmd *uint16, argc *int32) (argv *[8192]*[8192]uint16, err error) [failretval==nil] = shell32.CommandLineToArgvW
 //sys	LocalFree(hmem Handle) (handle Handle, err error) [failretval!=0]
+//sys	LocalAlloc(flags uint32, length uint32) (ptr uintptr, err error)
 //sys	SetHandleInformation(handle Handle, mask uint32, flags uint32) (err error)
 //sys	FlushFileBuffers(handle Handle) (err error)
 //sys	GetFullPathName(path *uint16, buflen uint32, buf *uint16, fname **uint16) (n uint32, err error) = kernel32.GetFullPathNameW
 //sys	GetLongPathName(path *uint16, buf *uint16, buflen uint32) (n uint32, err error) = kernel32.GetLongPathNameW
 //sys	GetShortPathName(longpath *uint16, shortpath *uint16, buflen uint32) (n uint32, err error) = kernel32.GetShortPathNameW
 //sys	GetFinalPathNameByHandle(file Handle, filePath *uint16, filePathSize uint32, flags uint32) (n uint32, err error) = kernel32.GetFinalPathNameByHandleW
-//sys	CreateFileMapping(fhandle Handle, sa *SecurityAttributes, prot uint32, maxSizeHigh uint32, maxSizeLow uint32, name *uint16) (handle Handle, err error) = kernel32.CreateFileMappingW
+//sys	CreateFileMapping(fhandle Handle, sa *SecurityAttributes, prot uint32, maxSizeHigh uint32, maxSizeLow uint32, name *uint16) (handle Handle, err error) [failretval == 0 || e1 == ERROR_ALREADY_EXISTS] = kernel32.CreateFileMappingW
 //sys	MapViewOfFile(handle Handle, access uint32, offsetHigh uint32, offsetLow uint32, length uintptr) (addr uintptr, err error)
 //sys	UnmapViewOfFile(addr uintptr) (err error)
 //sys	FlushViewOfFile(addr uintptr, length uintptr) (err error)
@@ -283,6 +293,9 @@ func NewCallbackCDecl(fn interface{}) uintptr {
 //sys	CertVerifyCertificateChainPolicy(policyOID uintptr, chain *CertChainContext, para *CertChainPolicyPara, status *CertChainPolicyStatus) (err error) = crypt32.CertVerifyCertificateChainPolicy
 //sys	CertGetNameString(certContext *CertContext, nameType uint32, flags uint32, typePara unsafe.Pointer, name *uint16, size uint32) (chars uint32) = crypt32.CertGetNameStringW
 //sys	CertFindExtension(objId *byte, countExtensions uint32, extensions *CertExtension) (ret *CertExtension) = crypt32.CertFindExtension
+//sys   CertFindCertificateInStore(store Handle, certEncodingType uint32, findFlags uint32, findType uint32, findPara unsafe.Pointer, prevCertContext *CertContext) (cert *CertContext, err error) [failretval==nil] = crypt32.CertFindCertificateInStore
+//sys   CertFindChainInStore(store Handle, certEncodingType uint32, findFlags uint32, findType uint32, findPara unsafe.Pointer, prevChainContext *CertChainContext) (certchain *CertChainContext, err error) [failretval==nil] = crypt32.CertFindChainInStore
+//sys   CryptAcquireCertificatePrivateKey(cert *CertContext, flags uint32, parameters unsafe.Pointer, cryptProvOrNCryptKey *Handle, keySpec *uint32, callerFreeProvOrNCryptKey *bool) (err error) = crypt32.CryptAcquireCertificatePrivateKey
 //sys	CryptQueryObject(objectType uint32, object unsafe.Pointer, expectedContentTypeFlags uint32, expectedFormatTypeFlags uint32, flags uint32, msgAndCertEncodingType *uint32, contentType *uint32, formatType *uint32, certStore *Handle, msg *Handle, context *unsafe.Pointer) (err error) = crypt32.CryptQueryObject
 //sys	CryptDecodeObject(encodingType uint32, structType *byte, encodedBytes *byte, lenEncodedBytes uint32, flags uint32, decoded unsafe.Pointer, decodedLen *uint32) (err error) = crypt32.CryptDecodeObject
 //sys	CryptProtectData(dataIn *DataBlob, name *uint16, optionalEntropy *DataBlob, reserved uintptr, promptStruct *CryptProtectPromptStruct, flags uint32, dataOut *DataBlob) (err error) = crypt32.CryptProtectData
@@ -312,14 +325,14 @@ func NewCallbackCDecl(fn interface{}) uintptr {
 //sys	CreateSymbolicLink(symlinkfilename *uint16, targetfilename *uint16, flags uint32) (err error) [failretval&0xff==0] = CreateSymbolicLinkW
 //sys	CreateHardLink(filename *uint16, existingfilename *uint16, reserved uintptr) (err error) [failretval&0xff==0] = CreateHardLinkW
 //sys	GetCurrentThreadId() (id uint32)
-//sys	CreateEvent(eventAttrs *SecurityAttributes, manualReset uint32, initialState uint32, name *uint16) (handle Handle, err error) = kernel32.CreateEventW
-//sys	CreateEventEx(eventAttrs *SecurityAttributes, name *uint16, flags uint32, desiredAccess uint32) (handle Handle, err error) = kernel32.CreateEventExW
+//sys	CreateEvent(eventAttrs *SecurityAttributes, manualReset uint32, initialState uint32, name *uint16) (handle Handle, err error) [failretval == 0 || e1 == ERROR_ALREADY_EXISTS] = kernel32.CreateEventW
+//sys	CreateEventEx(eventAttrs *SecurityAttributes, name *uint16, flags uint32, desiredAccess uint32) (handle Handle, err error) [failretval == 0 || e1 == ERROR_ALREADY_EXISTS] = kernel32.CreateEventExW
 //sys	OpenEvent(desiredAccess uint32, inheritHandle bool, name *uint16) (handle Handle, err error) = kernel32.OpenEventW
 //sys	SetEvent(event Handle) (err error) = kernel32.SetEvent
 //sys	ResetEvent(event Handle) (err error) = kernel32.ResetEvent
 //sys	PulseEvent(event Handle) (err error) = kernel32.PulseEvent
-//sys	CreateMutex(mutexAttrs *SecurityAttributes, initialOwner bool, name *uint16) (handle Handle, err error) = kernel32.CreateMutexW
-//sys	CreateMutexEx(mutexAttrs *SecurityAttributes, name *uint16, flags uint32, desiredAccess uint32) (handle Handle, err error) = kernel32.CreateMutexExW
+//sys	CreateMutex(mutexAttrs *SecurityAttributes, initialOwner bool, name *uint16) (handle Handle, err error) [failretval == 0 || e1 == ERROR_ALREADY_EXISTS] = kernel32.CreateMutexW
+//sys	CreateMutexEx(mutexAttrs *SecurityAttributes, name *uint16, flags uint32, desiredAccess uint32) (handle Handle, err error) [failretval == 0 || e1 == ERROR_ALREADY_EXISTS] = kernel32.CreateMutexExW
 //sys	OpenMutex(desiredAccess uint32, inheritHandle bool, name *uint16) (handle Handle, err error) = kernel32.OpenMutexW
 //sys	ReleaseMutex(mutex Handle) (err error) = kernel32.ReleaseMutex
 //sys	SleepEx(milliseconds uint32, alertable bool) (ret uint32) = kernel32.SleepEx
@@ -334,10 +347,13 @@ func NewCallbackCDecl(fn interface{}) uintptr {
 //sys	SetInformationJobObject(job Handle, JobObjectInformationClass uint32, JobObjectInformation uintptr, JobObjectInformationLength uint32) (ret int, err error)
 //sys	GenerateConsoleCtrlEvent(ctrlEvent uint32, processGroupID uint32) (err error)
 //sys	GetProcessId(process Handle) (id uint32, err error)
+//sys	QueryFullProcessImageName(proc Handle, flags uint32, exeName *uint16, size *uint32) (err error) = kernel32.QueryFullProcessImageNameW
 //sys	OpenThread(desiredAccess uint32, inheritHandle bool, threadId uint32) (handle Handle, err error)
 //sys	SetProcessPriorityBoost(process Handle, disable bool) (err error) = kernel32.SetProcessPriorityBoost
 //sys	GetProcessWorkingSetSizeEx(hProcess Handle, lpMinimumWorkingSetSize *uintptr, lpMaximumWorkingSetSize *uintptr, flags *uint32)
 //sys	SetProcessWorkingSetSizeEx(hProcess Handle, dwMinimumWorkingSetSize uintptr, dwMaximumWorkingSetSize uintptr, flags uint32) (err error)
+//sys	GetCommTimeouts(handle Handle, timeouts *CommTimeouts) (err error)
+//sys	SetCommTimeouts(handle Handle, timeouts *CommTimeouts) (err error)
 
 // Volume Management Functions
 //sys	DefineDosDevice(flags uint32, deviceName *uint16, targetPath *uint16) (err error) = DefineDosDeviceW
@@ -367,16 +383,36 @@ func NewCallbackCDecl(fn interface{}) uintptr {
 //sys	stringFromGUID2(rguid *GUID, lpsz *uint16, cchMax int32) (chars int32) = ole32.StringFromGUID2
 //sys	coCreateGuid(pguid *GUID) (ret error) = ole32.CoCreateGuid
 //sys	CoTaskMemFree(address unsafe.Pointer) = ole32.CoTaskMemFree
-//sys	rtlGetVersion(info *OsVersionInfoEx) (ret error) = ntdll.RtlGetVersion
-//sys	rtlGetNtVersionNumbers(majorVersion *uint32, minorVersion *uint32, buildNumber *uint32) = ntdll.RtlGetNtVersionNumbers
+//sys	CoInitializeEx(reserved uintptr, coInit uint32) (ret error) = ole32.CoInitializeEx
+//sys	CoUninitialize() = ole32.CoUninitialize
+//sys	CoGetObject(name *uint16, bindOpts *BIND_OPTS3, guid *GUID, functionTable **uintptr) (ret error) = ole32.CoGetObject
 //sys	getProcessPreferredUILanguages(flags uint32, numLanguages *uint32, buf *uint16, bufSize *uint32) (err error) = kernel32.GetProcessPreferredUILanguages
 //sys	getThreadPreferredUILanguages(flags uint32, numLanguages *uint32, buf *uint16, bufSize *uint32) (err error) = kernel32.GetThreadPreferredUILanguages
 //sys	getUserPreferredUILanguages(flags uint32, numLanguages *uint32, buf *uint16, bufSize *uint32) (err error) = kernel32.GetUserPreferredUILanguages
 //sys	getSystemPreferredUILanguages(flags uint32, numLanguages *uint32, buf *uint16, bufSize *uint32) (err error) = kernel32.GetSystemPreferredUILanguages
+//sys	findResource(module Handle, name uintptr, resType uintptr) (resInfo Handle, err error) = kernel32.FindResourceW
+//sys	SizeofResource(module Handle, resInfo Handle) (size uint32, err error) = kernel32.SizeofResource
+//sys	LoadResource(module Handle, resInfo Handle) (resData Handle, err error) = kernel32.LoadResource
+//sys	LockResource(resData Handle) (addr uintptr, err error) = kernel32.LockResource
 
 // Process Status API (PSAPI)
 //sys	EnumProcesses(processIds []uint32, bytesReturned *uint32) (err error) = psapi.EnumProcesses
 
+// NT Native APIs
+//sys	rtlNtStatusToDosErrorNoTeb(ntstatus NTStatus) (ret syscall.Errno) = ntdll.RtlNtStatusToDosErrorNoTeb
+//sys	rtlGetVersion(info *OsVersionInfoEx) (ntstatus error) = ntdll.RtlGetVersion
+//sys	rtlGetNtVersionNumbers(majorVersion *uint32, minorVersion *uint32, buildNumber *uint32) = ntdll.RtlGetNtVersionNumbers
+//sys	RtlGetCurrentPeb() (peb *PEB) = ntdll.RtlGetCurrentPeb
+//sys	RtlInitUnicodeString(destinationString *NTUnicodeString, sourceString *uint16) = ntdll.RtlInitUnicodeString
+//sys	RtlInitString(destinationString *NTString, sourceString *byte) = ntdll.RtlInitString
+//sys	NtCreateFile(handle *Handle, access uint32, oa *OBJECT_ATTRIBUTES, iosb *IO_STATUS_BLOCK, allocationSize *int64, attributes uint32, share uint32, disposition uint32, options uint32, eabuffer uintptr, ealength uint32) (ntstatus error) = ntdll.NtCreateFile
+//sys	NtCreateNamedPipeFile(pipe *Handle, access uint32, oa *OBJECT_ATTRIBUTES, iosb *IO_STATUS_BLOCK, share uint32, disposition uint32, options uint32, typ uint32, readMode uint32, completionMode uint32, maxInstances uint32, inboundQuota uint32, outputQuota uint32, timeout *int64) (ntstatus error) = ntdll.NtCreateNamedPipeFile
+//sys	RtlDosPathNameToNtPathName(dosName *uint16, ntName *NTUnicodeString, ntFileNamePart *uint16, relativeName *RTL_RELATIVE_NAME) (ntstatus error) = ntdll.RtlDosPathNameToNtPathName_U_WithStatus
+//sys	RtlDosPathNameToRelativeNtPathName(dosName *uint16, ntName *NTUnicodeString, ntFileNamePart *uint16, relativeName *RTL_RELATIVE_NAME) (ntstatus error) = ntdll.RtlDosPathNameToRelativeNtPathName_U_WithStatus
+//sys	RtlDefaultNpAcl(acl **ACL) (ntstatus error) = ntdll.RtlDefaultNpAcl
+//sys	NtQueryInformationProcess(proc Handle, procInfoClass int32, procInfo unsafe.Pointer, procInfoLen uint32, retLen *uint32) (ntstatus error) = ntdll.NtQueryInformationProcess
+//sys	NtSetInformationProcess(proc Handle, procInfoClass int32, procInfo unsafe.Pointer, procInfoLen uint32) (ntstatus error) = ntdll.NtSetInformationProcess
+
 // syscall interface implementation for other packages
 
 // GetCurrentProcess returns the handle for the current process.
@@ -770,6 +806,7 @@ const socket_error = uintptr(^uint32(0))
 //sys	WSASend(s Handle, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32, overlapped *Overlapped, croutine *byte) (err error) [failretval==socket_error] = ws2_32.WSASend
 //sys	WSARecvFrom(s Handle, bufs *WSABuf, bufcnt uint32, recvd *uint32, flags *uint32,  from *RawSockaddrAny, fromlen *int32, overlapped *Overlapped, croutine *byte) (err error) [failretval==socket_error] = ws2_32.WSARecvFrom
 //sys	WSASendTo(s Handle, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32, to *RawSockaddrAny, tolen int32,  overlapped *Overlapped, croutine *byte) (err error) [failretval==socket_error] = ws2_32.WSASendTo
+//sys	WSASocket(af int32, typ int32, protocol int32, protoInfo *WSAProtocolInfo, group uint32, flags uint32) (handle Handle, err error) [failretval==InvalidHandle] = ws2_32.WSASocketW
 //sys	GetHostByName(name string) (h *Hostent, err error) [failretval==nil] = ws2_32.gethostbyname
 //sys	GetServByName(name string, proto string) (s *Servent, err error) [failretval==nil] = ws2_32.getservbyname
 //sys	Ntohs(netshort uint16) (u uint16) = ws2_32.ntohs
@@ -783,6 +820,7 @@ const socket_error = uintptr(^uint32(0))
 //sys	GetAdaptersInfo(ai *IpAdapterInfo, ol *uint32) (errcode error) = iphlpapi.GetAdaptersInfo
 //sys	SetFileCompletionNotificationModes(handle Handle, flags uint8) (err error) = kernel32.SetFileCompletionNotificationModes
 //sys	WSAEnumProtocols(protocols *int32, protocolBuffer *WSAProtocolInfo, bufferLength *uint32) (n int32, err error) [failretval==-1] = ws2_32.WSAEnumProtocolsW
+//sys	WSAGetOverlappedResult(h Handle, o *Overlapped, bytes *uint32, wait bool, flags *uint32) (err error) = ws2_32.WSAGetOverlappedResult
 //sys	GetAdaptersAddresses(family uint32, flags uint32, reserved uintptr, adapterAddresses *IpAdapterAddresses, sizePointer *uint32) (errcode error) = iphlpapi.GetAdaptersAddresses
 //sys	GetACP() (acp uint32) = kernel32.GetACP
 //sys	MultiByteToWideChar(codePage uint32, dwFlags uint32, str *byte, nstr int32, wchar *uint16, nwchar int32) (nwrite int32, err error) = kernel32.MultiByteToWideChar
@@ -1505,3 +1543,129 @@ func getUILanguages(flags uint32, f func(flags uint32, numLanguages *uint32, buf
 func SetConsoleCursorPosition(console Handle, position Coord) error {
 	return setConsoleCursorPosition(console, *((*uint32)(unsafe.Pointer(&position))))
 }
+
+func (s NTStatus) Errno() syscall.Errno {
+	return rtlNtStatusToDosErrorNoTeb(s)
+}
+
+func langID(pri, sub uint16) uint32 { return uint32(sub)<<10 | uint32(pri) }
+
+func (s NTStatus) Error() string {
+	b := make([]uint16, 300)
+	n, err := FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_FROM_HMODULE|FORMAT_MESSAGE_ARGUMENT_ARRAY, modntdll.Handle(), uint32(s), langID(LANG_ENGLISH, SUBLANG_ENGLISH_US), b, nil)
+	if err != nil {
+		return fmt.Sprintf("NTSTATUS 0x%08x", uint32(s))
+	}
+	// trim terminating \r and \n
+	for ; n > 0 && (b[n-1] == '\n' || b[n-1] == '\r'); n-- {
+	}
+	return string(utf16.Decode(b[:n]))
+}
+
+// NewNTUnicodeString returns a new NTUnicodeString structure for use with native
+// NT APIs that work over the NTUnicodeString type. Note that most Windows APIs
+// do not use NTUnicodeString, and instead UTF16PtrFromString should be used for
+// the more common *uint16 string type.
+func NewNTUnicodeString(s string) (*NTUnicodeString, error) {
+	var u NTUnicodeString
+	s16, err := UTF16PtrFromString(s)
+	if err != nil {
+		return nil, err
+	}
+	RtlInitUnicodeString(&u, s16)
+	return &u, nil
+}
+
+// Slice returns a uint16 slice that aliases the data in the NTUnicodeString.
+func (s *NTUnicodeString) Slice() []uint16 {
+	var slice []uint16
+	hdr := (*unsafeheader.Slice)(unsafe.Pointer(&slice))
+	hdr.Data = unsafe.Pointer(s.Buffer)
+	hdr.Len = int(s.Length)
+	hdr.Cap = int(s.MaximumLength)
+	return slice
+}
+
+func (s *NTUnicodeString) String() string {
+	return UTF16ToString(s.Slice())
+}
+
+// NewNTString returns a new NTString structure for use with native
+// NT APIs that work over the NTString type. Note that most Windows APIs
+// do not use NTString, and instead UTF16PtrFromString should be used for
+// the more common *uint16 string type.
+func NewNTString(s string) (*NTString, error) {
+	var nts NTString
+	s8, err := BytePtrFromString(s)
+	if err != nil {
+		return nil, err
+	}
+	RtlInitString(&nts, s8)
+	return &nts, nil
+}
+
+// Slice returns a byte slice that aliases the data in the NTString.
+func (s *NTString) Slice() []byte {
+	var slice []byte
+	hdr := (*unsafeheader.Slice)(unsafe.Pointer(&slice))
+	hdr.Data = unsafe.Pointer(s.Buffer)
+	hdr.Len = int(s.Length)
+	hdr.Cap = int(s.MaximumLength)
+	return slice
+}
+
+func (s *NTString) String() string {
+	return ByteSliceToString(s.Slice())
+}
+
+// FindResource resolves a resource of the given name and resource type.
+func FindResource(module Handle, name, resType ResourceIDOrString) (Handle, error) {
+	var namePtr, resTypePtr uintptr
+	var name16, resType16 *uint16
+	var err error
+	resolvePtr := func(i interface{}, keep **uint16) (uintptr, error) {
+		switch v := i.(type) {
+		case string:
+			*keep, err = UTF16PtrFromString(v)
+			if err != nil {
+				return 0, err
+			}
+			return uintptr(unsafe.Pointer(*keep)), nil
+		case ResourceID:
+			return uintptr(v), nil
+		}
+		return 0, errorspkg.New("parameter must be a ResourceID or a string")
+	}
+	namePtr, err = resolvePtr(name, &name16)
+	if err != nil {
+		return 0, err
+	}
+	resTypePtr, err = resolvePtr(resType, &resType16)
+	if err != nil {
+		return 0, err
+	}
+	resInfo, err := findResource(module, namePtr, resTypePtr)
+	runtime.KeepAlive(name16)
+	runtime.KeepAlive(resType16)
+	return resInfo, err
+}
+
+func LoadResourceData(module, resInfo Handle) (data []byte, err error) {
+	size, err := SizeofResource(module, resInfo)
+	if err != nil {
+		return
+	}
+	resData, err := LoadResource(module, resInfo)
+	if err != nil {
+		return
+	}
+	ptr, err := LockResource(resData)
+	if err != nil {
+		return
+	}
+	h := (*unsafeheader.Slice)(unsafe.Pointer(&data))
+	h.Data = unsafe.Pointer(ptr)
+	h.Len = int(size)
+	h.Cap = int(size)
+	return
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/windows/types_windows.go b/src/cmd/vendor/golang.org/x/sys/windows/types_windows.go
index fd4260762a..369cc91da7 100644
--- a/src/cmd/vendor/golang.org/x/sys/windows/types_windows.go
+++ b/src/cmd/vendor/golang.org/x/sys/windows/types_windows.go
@@ -10,6 +10,10 @@ import (
 	"unsafe"
 )
 
+// NTStatus corresponds with NTSTATUS, error values returned by ntdll.dll and
+// other native functions.
+type NTStatus uint32
+
 const (
 	// Invented values to support what package os expects.
 	O_RDONLY   = 0x00000
@@ -215,6 +219,18 @@ const (
 	INHERIT_PARENT_AFFINITY          = 0x00010000
 )
 
+const (
+	// attributes for ProcThreadAttributeList
+	PROC_THREAD_ATTRIBUTE_PARENT_PROCESS    = 0x00020000
+	PROC_THREAD_ATTRIBUTE_HANDLE_LIST       = 0x00020002
+	PROC_THREAD_ATTRIBUTE_GROUP_AFFINITY    = 0x00030003
+	PROC_THREAD_ATTRIBUTE_PREFERRED_NODE    = 0x00020004
+	PROC_THREAD_ATTRIBUTE_IDEAL_PROCESSOR   = 0x00030005
+	PROC_THREAD_ATTRIBUTE_MITIGATION_POLICY = 0x00020007
+	PROC_THREAD_ATTRIBUTE_UMS_THREAD        = 0x00030006
+	PROC_THREAD_ATTRIBUTE_PROTECTION_LEVEL  = 0x0002000b
+)
+
 const (
 	// flags for CreateToolhelp32Snapshot
 	TH32CS_SNAPHEAPLIST = 0x01
@@ -287,6 +303,23 @@ const (
 	PKCS12_NO_PERSIST_KEY              = 0x00008000
 	PKCS12_INCLUDE_EXTENDED_PROPERTIES = 0x00000010
 
+	/* Flags for CryptAcquireCertificatePrivateKey */
+	CRYPT_ACQUIRE_CACHE_FLAG             = 0x00000001
+	CRYPT_ACQUIRE_USE_PROV_INFO_FLAG     = 0x00000002
+	CRYPT_ACQUIRE_COMPARE_KEY_FLAG       = 0x00000004
+	CRYPT_ACQUIRE_NO_HEALING             = 0x00000008
+	CRYPT_ACQUIRE_SILENT_FLAG            = 0x00000040
+	CRYPT_ACQUIRE_WINDOW_HANDLE_FLAG     = 0x00000080
+	CRYPT_ACQUIRE_NCRYPT_KEY_FLAGS_MASK  = 0x00070000
+	CRYPT_ACQUIRE_ALLOW_NCRYPT_KEY_FLAG  = 0x00010000
+	CRYPT_ACQUIRE_PREFER_NCRYPT_KEY_FLAG = 0x00020000
+	CRYPT_ACQUIRE_ONLY_NCRYPT_KEY_FLAG   = 0x00040000
+
+	/* pdwKeySpec for CryptAcquireCertificatePrivateKey */
+	AT_KEYEXCHANGE       = 1
+	AT_SIGNATURE         = 2
+	CERT_NCRYPT_KEY_SPEC = 0xFFFFFFFF
+
 	/* Default usage match type is AND with value zero */
 	USAGE_MATCH_TYPE_AND = 0
 	USAGE_MATCH_TYPE_OR  = 1
@@ -412,6 +445,89 @@ const (
 	CERT_TRUST_IS_CA_TRUSTED                 = 0x00004000
 	CERT_TRUST_IS_COMPLEX_CHAIN              = 0x00010000
 
+	/* Certificate Information Flags */
+	CERT_INFO_VERSION_FLAG                 = 1
+	CERT_INFO_SERIAL_NUMBER_FLAG           = 2
+	CERT_INFO_SIGNATURE_ALGORITHM_FLAG     = 3
+	CERT_INFO_ISSUER_FLAG                  = 4
+	CERT_INFO_NOT_BEFORE_FLAG              = 5
+	CERT_INFO_NOT_AFTER_FLAG               = 6
+	CERT_INFO_SUBJECT_FLAG                 = 7
+	CERT_INFO_SUBJECT_PUBLIC_KEY_INFO_FLAG = 8
+	CERT_INFO_ISSUER_UNIQUE_ID_FLAG        = 9
+	CERT_INFO_SUBJECT_UNIQUE_ID_FLAG       = 10
+	CERT_INFO_EXTENSION_FLAG               = 11
+
+	/* dwFindType for CertFindCertificateInStore  */
+	CERT_COMPARE_MASK                     = 0xFFFF
+	CERT_COMPARE_SHIFT                    = 16
+	CERT_COMPARE_ANY                      = 0
+	CERT_COMPARE_SHA1_HASH                = 1
+	CERT_COMPARE_NAME                     = 2
+	CERT_COMPARE_ATTR                     = 3
+	CERT_COMPARE_MD5_HASH                 = 4
+	CERT_COMPARE_PROPERTY                 = 5
+	CERT_COMPARE_PUBLIC_KEY               = 6
+	CERT_COMPARE_HASH                     = CERT_COMPARE_SHA1_HASH
+	CERT_COMPARE_NAME_STR_A               = 7
+	CERT_COMPARE_NAME_STR_W               = 8
+	CERT_COMPARE_KEY_SPEC                 = 9
+	CERT_COMPARE_ENHKEY_USAGE             = 10
+	CERT_COMPARE_CTL_USAGE                = CERT_COMPARE_ENHKEY_USAGE
+	CERT_COMPARE_SUBJECT_CERT             = 11
+	CERT_COMPARE_ISSUER_OF                = 12
+	CERT_COMPARE_EXISTING                 = 13
+	CERT_COMPARE_SIGNATURE_HASH           = 14
+	CERT_COMPARE_KEY_IDENTIFIER           = 15
+	CERT_COMPARE_CERT_ID                  = 16
+	CERT_COMPARE_CROSS_CERT_DIST_POINTS   = 17
+	CERT_COMPARE_PUBKEY_MD5_HASH          = 18
+	CERT_COMPARE_SUBJECT_INFO_ACCESS      = 19
+	CERT_COMPARE_HASH_STR                 = 20
+	CERT_COMPARE_HAS_PRIVATE_KEY          = 21
+	CERT_FIND_ANY                         = (CERT_COMPARE_ANY << CERT_COMPARE_SHIFT)
+	CERT_FIND_SHA1_HASH                   = (CERT_COMPARE_SHA1_HASH << CERT_COMPARE_SHIFT)
+	CERT_FIND_MD5_HASH                    = (CERT_COMPARE_MD5_HASH << CERT_COMPARE_SHIFT)
+	CERT_FIND_SIGNATURE_HASH              = (CERT_COMPARE_SIGNATURE_HASH << CERT_COMPARE_SHIFT)
+	CERT_FIND_KEY_IDENTIFIER              = (CERT_COMPARE_KEY_IDENTIFIER << CERT_COMPARE_SHIFT)
+	CERT_FIND_HASH                        = CERT_FIND_SHA1_HASH
+	CERT_FIND_PROPERTY                    = (CERT_COMPARE_PROPERTY << CERT_COMPARE_SHIFT)
+	CERT_FIND_PUBLIC_KEY                  = (CERT_COMPARE_PUBLIC_KEY << CERT_COMPARE_SHIFT)
+	CERT_FIND_SUBJECT_NAME                = (CERT_COMPARE_NAME<<CERT_COMPARE_SHIFT | CERT_INFO_SUBJECT_FLAG)
+	CERT_FIND_SUBJECT_ATTR                = (CERT_COMPARE_ATTR<<CERT_COMPARE_SHIFT | CERT_INFO_SUBJECT_FLAG)
+	CERT_FIND_ISSUER_NAME                 = (CERT_COMPARE_NAME<<CERT_COMPARE_SHIFT | CERT_INFO_ISSUER_FLAG)
+	CERT_FIND_ISSUER_ATTR                 = (CERT_COMPARE_ATTR<<CERT_COMPARE_SHIFT | CERT_INFO_ISSUER_FLAG)
+	CERT_FIND_SUBJECT_STR_A               = (CERT_COMPARE_NAME_STR_A<<CERT_COMPARE_SHIFT | CERT_INFO_SUBJECT_FLAG)
+	CERT_FIND_SUBJECT_STR_W               = (CERT_COMPARE_NAME_STR_W<<CERT_COMPARE_SHIFT | CERT_INFO_SUBJECT_FLAG)
+	CERT_FIND_SUBJECT_STR                 = CERT_FIND_SUBJECT_STR_W
+	CERT_FIND_ISSUER_STR_A                = (CERT_COMPARE_NAME_STR_A<<CERT_COMPARE_SHIFT | CERT_INFO_ISSUER_FLAG)
+	CERT_FIND_ISSUER_STR_W                = (CERT_COMPARE_NAME_STR_W<<CERT_COMPARE_SHIFT | CERT_INFO_ISSUER_FLAG)
+	CERT_FIND_ISSUER_STR                  = CERT_FIND_ISSUER_STR_W
+	CERT_FIND_KEY_SPEC                    = (CERT_COMPARE_KEY_SPEC << CERT_COMPARE_SHIFT)
+	CERT_FIND_ENHKEY_USAGE                = (CERT_COMPARE_ENHKEY_USAGE << CERT_COMPARE_SHIFT)
+	CERT_FIND_CTL_USAGE                   = CERT_FIND_ENHKEY_USAGE
+	CERT_FIND_SUBJECT_CERT                = (CERT_COMPARE_SUBJECT_CERT << CERT_COMPARE_SHIFT)
+	CERT_FIND_ISSUER_OF                   = (CERT_COMPARE_ISSUER_OF << CERT_COMPARE_SHIFT)
+	CERT_FIND_EXISTING                    = (CERT_COMPARE_EXISTING << CERT_COMPARE_SHIFT)
+	CERT_FIND_CERT_ID                     = (CERT_COMPARE_CERT_ID << CERT_COMPARE_SHIFT)
+	CERT_FIND_CROSS_CERT_DIST_POINTS      = (CERT_COMPARE_CROSS_CERT_DIST_POINTS << CERT_COMPARE_SHIFT)
+	CERT_FIND_PUBKEY_MD5_HASH             = (CERT_COMPARE_PUBKEY_MD5_HASH << CERT_COMPARE_SHIFT)
+	CERT_FIND_SUBJECT_INFO_ACCESS         = (CERT_COMPARE_SUBJECT_INFO_ACCESS << CERT_COMPARE_SHIFT)
+	CERT_FIND_HASH_STR                    = (CERT_COMPARE_HASH_STR << CERT_COMPARE_SHIFT)
+	CERT_FIND_HAS_PRIVATE_KEY             = (CERT_COMPARE_HAS_PRIVATE_KEY << CERT_COMPARE_SHIFT)
+	CERT_FIND_OPTIONAL_ENHKEY_USAGE_FLAG  = 0x1
+	CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG  = 0x2
+	CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG = 0x4
+	CERT_FIND_NO_ENHKEY_USAGE_FLAG        = 0x8
+	CERT_FIND_OR_ENHKEY_USAGE_FLAG        = 0x10
+	CERT_FIND_VALID_ENHKEY_USAGE_FLAG     = 0x20
+	CERT_FIND_OPTIONAL_CTL_USAGE_FLAG     = CERT_FIND_OPTIONAL_ENHKEY_USAGE_FLAG
+	CERT_FIND_EXT_ONLY_CTL_USAGE_FLAG     = CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG
+	CERT_FIND_PROP_ONLY_CTL_USAGE_FLAG    = CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG
+	CERT_FIND_NO_CTL_USAGE_FLAG           = CERT_FIND_NO_ENHKEY_USAGE_FLAG
+	CERT_FIND_OR_CTL_USAGE_FLAG           = CERT_FIND_OR_ENHKEY_USAGE_FLAG
+	CERT_FIND_VALID_CTL_USAGE_FLAG        = CERT_FIND_VALID_ENHKEY_USAGE_FLAG
+
 	/* policyOID values for CertVerifyCertificateChainPolicy function */
 	CERT_CHAIN_POLICY_BASE              = 1
 	CERT_CHAIN_POLICY_AUTHENTICODE      = 2
@@ -423,6 +539,17 @@ const (
 	CERT_CHAIN_POLICY_EV                = 8
 	CERT_CHAIN_POLICY_SSL_F12           = 9
 
+	/* flag for dwFindType CertFindChainInStore  */
+	CERT_CHAIN_FIND_BY_ISSUER = 1
+
+	/* dwFindFlags for CertFindChainInStore when dwFindType == CERT_CHAIN_FIND_BY_ISSUER */
+	CERT_CHAIN_FIND_BY_ISSUER_COMPARE_KEY_FLAG    = 0x0001
+	CERT_CHAIN_FIND_BY_ISSUER_COMPLEX_CHAIN_FLAG  = 0x0002
+	CERT_CHAIN_FIND_BY_ISSUER_CACHE_ONLY_URL_FLAG = 0x0004
+	CERT_CHAIN_FIND_BY_ISSUER_LOCAL_MACHINE_FLAG  = 0x0008
+	CERT_CHAIN_FIND_BY_ISSUER_NO_KEY_FLAG         = 0x4000
+	CERT_CHAIN_FIND_BY_ISSUER_CACHE_ONLY_FLAG     = 0x8000
+
 	/* Certificate Store close flags */
 	CERT_CLOSE_STORE_FORCE_FLAG = 0x00000001
 	CERT_CLOSE_STORE_CHECK_FLAG = 0x00000002
@@ -683,6 +810,14 @@ type win32finddata1 struct {
 	Reserved1         uint32
 	FileName          [MAX_PATH]uint16
 	AlternateFileName [14]uint16
+
+	// The Microsoft documentation for this struct¹ describes three additional
+	// fields: dwFileType, dwCreatorType, and wFinderFlags. However, those fields
+	// are empirically only present in the macOS port of the Win32 API,² and thus
+	// not needed for binaries built for Windows.
+	//
+	// ¹ https://docs.microsoft.com/en-us/windows/win32/api/minwinbase/ns-minwinbase-win32_find_dataw describe
+	// ² https://golang.org/issue/42637#issuecomment-760715755.
 }
 
 func copyFindData(dst *Win32finddata, src *win32finddata1) {
@@ -767,6 +902,23 @@ type StartupInfo struct {
 	StdErr        Handle
 }
 
+type StartupInfoEx struct {
+	StartupInfo
+	ProcThreadAttributeList *ProcThreadAttributeList
+}
+
+// ProcThreadAttributeList is a placeholder type to represent a PROC_THREAD_ATTRIBUTE_LIST.
+//
+// To create a *ProcThreadAttributeList, use NewProcThreadAttributeList, and
+// free its memory using ProcThreadAttributeList.Delete.
+type ProcThreadAttributeList struct {
+	// This is of type unsafe.Pointer, not of type byte or uintptr, because
+	// the contents of it is mostly a list of pointers, and in most cases,
+	// that's a list of pointers to Go-allocated objects. In order to keep
+	// the GC from collecting these objects, we declare this as unsafe.Pointer.
+	_ [1]unsafe.Pointer
+}
+
 type ProcessInformation struct {
 	Process   Handle
 	Thread    Handle
@@ -920,6 +1072,18 @@ type WSAMsg struct {
 	Flags       uint32
 }
 
+// Flags for WSASocket
+const (
+	WSA_FLAG_OVERLAPPED             = 0x01
+	WSA_FLAG_MULTIPOINT_C_ROOT      = 0x02
+	WSA_FLAG_MULTIPOINT_C_LEAF      = 0x04
+	WSA_FLAG_MULTIPOINT_D_ROOT      = 0x08
+	WSA_FLAG_MULTIPOINT_D_LEAF      = 0x10
+	WSA_FLAG_ACCESS_SYSTEM_SECURITY = 0x40
+	WSA_FLAG_NO_HANDLE_INHERIT      = 0x80
+	WSA_FLAG_REGISTERED_IO          = 0x100
+)
+
 // Invented values to support what package os expects.
 const (
 	S_IFMT   = 0x1f000
@@ -1360,6 +1524,19 @@ type CryptProtectPromptStruct struct {
 	Prompt      *uint16
 }
 
+type CertChainFindByIssuerPara struct {
+	Size                   uint32
+	UsageIdentifier        *byte
+	KeySpec                uint32
+	AcquirePrivateKeyFlags uint32
+	IssuerCount            uint32
+	Issuer                 Pointer
+	FindCallback           Pointer
+	FindArg                Pointer
+	IssuerChainIndex       *uint32
+	IssuerElementIndex     *uint32
+}
+
 type WinTrustData struct {
 	Size                            uint32
 	PolicyCallbackData              uintptr
@@ -2091,3 +2268,504 @@ const (
 	// REG_NOTIFY_THREAD_AGNOSTIC indicates that the lifetime of the registration must not be tied to the lifetime of the thread issuing the RegNotifyChangeKeyValue call. Note: This flag value is only supported in Windows 8 and later.
 	REG_NOTIFY_THREAD_AGNOSTIC = 0x10000000
 )
+
+type CommTimeouts struct {
+	ReadIntervalTimeout         uint32
+	ReadTotalTimeoutMultiplier  uint32
+	ReadTotalTimeoutConstant    uint32
+	WriteTotalTimeoutMultiplier uint32
+	WriteTotalTimeoutConstant   uint32
+}
+
+// NTUnicodeString is a UTF-16 string for NT native APIs, corresponding to UNICODE_STRING.
+type NTUnicodeString struct {
+	Length        uint16
+	MaximumLength uint16
+	Buffer        *uint16
+}
+
+// NTString is an ANSI string for NT native APIs, corresponding to STRING.
+type NTString struct {
+	Length        uint16
+	MaximumLength uint16
+	Buffer        *byte
+}
+
+type LIST_ENTRY struct {
+	Flink *LIST_ENTRY
+	Blink *LIST_ENTRY
+}
+
+type LDR_DATA_TABLE_ENTRY struct {
+	reserved1          [2]uintptr
+	InMemoryOrderLinks LIST_ENTRY
+	reserved2          [2]uintptr
+	DllBase            uintptr
+	reserved3          [2]uintptr
+	FullDllName        NTUnicodeString
+	reserved4          [8]byte
+	reserved5          [3]uintptr
+	reserved6          uintptr
+	TimeDateStamp      uint32
+}
+
+type PEB_LDR_DATA struct {
+	reserved1               [8]byte
+	reserved2               [3]uintptr
+	InMemoryOrderModuleList LIST_ENTRY
+}
+
+type CURDIR struct {
+	DosPath NTUnicodeString
+	Handle  Handle
+}
+
+type RTL_DRIVE_LETTER_CURDIR struct {
+	Flags     uint16
+	Length    uint16
+	TimeStamp uint32
+	DosPath   NTString
+}
+
+type RTL_USER_PROCESS_PARAMETERS struct {
+	MaximumLength, Length uint32
+
+	Flags, DebugFlags uint32
+
+	ConsoleHandle                                Handle
+	ConsoleFlags                                 uint32
+	StandardInput, StandardOutput, StandardError Handle
+
+	CurrentDirectory CURDIR
+	DllPath          NTUnicodeString
+	ImagePathName    NTUnicodeString
+	CommandLine      NTUnicodeString
+	Environment      unsafe.Pointer
+
+	StartingX, StartingY, CountX, CountY, CountCharsX, CountCharsY, FillAttribute uint32
+
+	WindowFlags, ShowWindowFlags                     uint32
+	WindowTitle, DesktopInfo, ShellInfo, RuntimeData NTUnicodeString
+	CurrentDirectories                               [32]RTL_DRIVE_LETTER_CURDIR
+
+	EnvironmentSize, EnvironmentVersion uintptr
+
+	PackageDependencyData unsafe.Pointer
+	ProcessGroupId        uint32
+	LoaderThreads         uint32
+
+	RedirectionDllName               NTUnicodeString
+	HeapPartitionName                NTUnicodeString
+	DefaultThreadpoolCpuSetMasks     uintptr
+	DefaultThreadpoolCpuSetMaskCount uint32
+}
+
+type PEB struct {
+	reserved1              [2]byte
+	BeingDebugged          byte
+	BitField               byte
+	reserved3              uintptr
+	ImageBaseAddress       uintptr
+	Ldr                    *PEB_LDR_DATA
+	ProcessParameters      *RTL_USER_PROCESS_PARAMETERS
+	reserved4              [3]uintptr
+	AtlThunkSListPtr       uintptr
+	reserved5              uintptr
+	reserved6              uint32
+	reserved7              uintptr
+	reserved8              uint32
+	AtlThunkSListPtr32     uint32
+	reserved9              [45]uintptr
+	reserved10             [96]byte
+	PostProcessInitRoutine uintptr
+	reserved11             [128]byte
+	reserved12             [1]uintptr
+	SessionId              uint32
+}
+
+type OBJECT_ATTRIBUTES struct {
+	Length             uint32
+	RootDirectory      Handle
+	ObjectName         *NTUnicodeString
+	Attributes         uint32
+	SecurityDescriptor *SECURITY_DESCRIPTOR
+	SecurityQoS        *SECURITY_QUALITY_OF_SERVICE
+}
+
+// Values for the Attributes member of OBJECT_ATTRIBUTES.
+const (
+	OBJ_INHERIT                       = 0x00000002
+	OBJ_PERMANENT                     = 0x00000010
+	OBJ_EXCLUSIVE                     = 0x00000020
+	OBJ_CASE_INSENSITIVE              = 0x00000040
+	OBJ_OPENIF                        = 0x00000080
+	OBJ_OPENLINK                      = 0x00000100
+	OBJ_KERNEL_HANDLE                 = 0x00000200
+	OBJ_FORCE_ACCESS_CHECK            = 0x00000400
+	OBJ_IGNORE_IMPERSONATED_DEVICEMAP = 0x00000800
+	OBJ_DONT_REPARSE                  = 0x00001000
+	OBJ_VALID_ATTRIBUTES              = 0x00001FF2
+)
+
+type IO_STATUS_BLOCK struct {
+	Status      NTStatus
+	Information uintptr
+}
+
+type RTLP_CURDIR_REF struct {
+	RefCount int32
+	Handle   Handle
+}
+
+type RTL_RELATIVE_NAME struct {
+	RelativeName        NTUnicodeString
+	ContainingDirectory Handle
+	CurDirRef           *RTLP_CURDIR_REF
+}
+
+const (
+	// CreateDisposition flags for NtCreateFile and NtCreateNamedPipeFile.
+	FILE_SUPERSEDE           = 0x00000000
+	FILE_OPEN                = 0x00000001
+	FILE_CREATE              = 0x00000002
+	FILE_OPEN_IF             = 0x00000003
+	FILE_OVERWRITE           = 0x00000004
+	FILE_OVERWRITE_IF        = 0x00000005
+	FILE_MAXIMUM_DISPOSITION = 0x00000005
+
+	// CreateOptions flags for NtCreateFile and NtCreateNamedPipeFile.
+	FILE_DIRECTORY_FILE            = 0x00000001
+	FILE_WRITE_THROUGH             = 0x00000002
+	FILE_SEQUENTIAL_ONLY           = 0x00000004
+	FILE_NO_INTERMEDIATE_BUFFERING = 0x00000008
+	FILE_SYNCHRONOUS_IO_ALERT      = 0x00000010
+	FILE_SYNCHRONOUS_IO_NONALERT   = 0x00000020
+	FILE_NON_DIRECTORY_FILE        = 0x00000040
+	FILE_CREATE_TREE_CONNECTION    = 0x00000080
+	FILE_COMPLETE_IF_OPLOCKED      = 0x00000100
+	FILE_NO_EA_KNOWLEDGE           = 0x00000200
+	FILE_OPEN_REMOTE_INSTANCE      = 0x00000400
+	FILE_RANDOM_ACCESS             = 0x00000800
+	FILE_DELETE_ON_CLOSE           = 0x00001000
+	FILE_OPEN_BY_FILE_ID           = 0x00002000
+	FILE_OPEN_FOR_BACKUP_INTENT    = 0x00004000
+	FILE_NO_COMPRESSION            = 0x00008000
+	FILE_OPEN_REQUIRING_OPLOCK     = 0x00010000
+	FILE_DISALLOW_EXCLUSIVE        = 0x00020000
+	FILE_RESERVE_OPFILTER          = 0x00100000
+	FILE_OPEN_REPARSE_POINT        = 0x00200000
+	FILE_OPEN_NO_RECALL            = 0x00400000
+	FILE_OPEN_FOR_FREE_SPACE_QUERY = 0x00800000
+
+	// Parameter constants for NtCreateNamedPipeFile.
+
+	FILE_PIPE_BYTE_STREAM_TYPE = 0x00000000
+	FILE_PIPE_MESSAGE_TYPE     = 0x00000001
+
+	FILE_PIPE_ACCEPT_REMOTE_CLIENTS = 0x00000000
+	FILE_PIPE_REJECT_REMOTE_CLIENTS = 0x00000002
+
+	FILE_PIPE_TYPE_VALID_MASK = 0x00000003
+
+	FILE_PIPE_BYTE_STREAM_MODE = 0x00000000
+	FILE_PIPE_MESSAGE_MODE     = 0x00000001
+
+	FILE_PIPE_QUEUE_OPERATION    = 0x00000000
+	FILE_PIPE_COMPLETE_OPERATION = 0x00000001
+
+	FILE_PIPE_INBOUND     = 0x00000000
+	FILE_PIPE_OUTBOUND    = 0x00000001
+	FILE_PIPE_FULL_DUPLEX = 0x00000002
+
+	FILE_PIPE_DISCONNECTED_STATE = 0x00000001
+	FILE_PIPE_LISTENING_STATE    = 0x00000002
+	FILE_PIPE_CONNECTED_STATE    = 0x00000003
+	FILE_PIPE_CLOSING_STATE      = 0x00000004
+
+	FILE_PIPE_CLIENT_END = 0x00000000
+	FILE_PIPE_SERVER_END = 0x00000001
+)
+
+// ProcessInformationClasses for NtQueryInformationProcess and NtSetInformationProcess.
+const (
+	ProcessBasicInformation = iota
+	ProcessQuotaLimits
+	ProcessIoCounters
+	ProcessVmCounters
+	ProcessTimes
+	ProcessBasePriority
+	ProcessRaisePriority
+	ProcessDebugPort
+	ProcessExceptionPort
+	ProcessAccessToken
+	ProcessLdtInformation
+	ProcessLdtSize
+	ProcessDefaultHardErrorMode
+	ProcessIoPortHandlers
+	ProcessPooledUsageAndLimits
+	ProcessWorkingSetWatch
+	ProcessUserModeIOPL
+	ProcessEnableAlignmentFaultFixup
+	ProcessPriorityClass
+	ProcessWx86Information
+	ProcessHandleCount
+	ProcessAffinityMask
+	ProcessPriorityBoost
+	ProcessDeviceMap
+	ProcessSessionInformation
+	ProcessForegroundInformation
+	ProcessWow64Information
+	ProcessImageFileName
+	ProcessLUIDDeviceMapsEnabled
+	ProcessBreakOnTermination
+	ProcessDebugObjectHandle
+	ProcessDebugFlags
+	ProcessHandleTracing
+	ProcessIoPriority
+	ProcessExecuteFlags
+	ProcessTlsInformation
+	ProcessCookie
+	ProcessImageInformation
+	ProcessCycleTime
+	ProcessPagePriority
+	ProcessInstrumentationCallback
+	ProcessThreadStackAllocation
+	ProcessWorkingSetWatchEx
+	ProcessImageFileNameWin32
+	ProcessImageFileMapping
+	ProcessAffinityUpdateMode
+	ProcessMemoryAllocationMode
+	ProcessGroupInformation
+	ProcessTokenVirtualizationEnabled
+	ProcessConsoleHostProcess
+	ProcessWindowInformation
+	ProcessHandleInformation
+	ProcessMitigationPolicy
+	ProcessDynamicFunctionTableInformation
+	ProcessHandleCheckingMode
+	ProcessKeepAliveCount
+	ProcessRevokeFileHandles
+	ProcessWorkingSetControl
+	ProcessHandleTable
+	ProcessCheckStackExtentsMode
+	ProcessCommandLineInformation
+	ProcessProtectionInformation
+	ProcessMemoryExhaustion
+	ProcessFaultInformation
+	ProcessTelemetryIdInformation
+	ProcessCommitReleaseInformation
+	ProcessDefaultCpuSetsInformation
+	ProcessAllowedCpuSetsInformation
+	ProcessSubsystemProcess
+	ProcessJobMemoryInformation
+	ProcessInPrivate
+	ProcessRaiseUMExceptionOnInvalidHandleClose
+	ProcessIumChallengeResponse
+	ProcessChildProcessInformation
+	ProcessHighGraphicsPriorityInformation
+	ProcessSubsystemInformation
+	ProcessEnergyValues
+	ProcessActivityThrottleState
+	ProcessActivityThrottlePolicy
+	ProcessWin32kSyscallFilterInformation
+	ProcessDisableSystemAllowedCpuSets
+	ProcessWakeInformation
+	ProcessEnergyTrackingState
+	ProcessManageWritesToExecutableMemory
+	ProcessCaptureTrustletLiveDump
+	ProcessTelemetryCoverage
+	ProcessEnclaveInformation
+	ProcessEnableReadWriteVmLogging
+	ProcessUptimeInformation
+	ProcessImageSection
+	ProcessDebugAuthInformation
+	ProcessSystemResourceManagement
+	ProcessSequenceNumber
+	ProcessLoaderDetour
+	ProcessSecurityDomainInformation
+	ProcessCombineSecurityDomainsInformation
+	ProcessEnableLogging
+	ProcessLeapSecondInformation
+	ProcessFiberShadowStackAllocation
+	ProcessFreeFiberShadowStackAllocation
+	ProcessAltSystemCallInformation
+	ProcessDynamicEHContinuationTargets
+	ProcessDynamicEnforcedCetCompatibleRanges
+)
+
+type PROCESS_BASIC_INFORMATION struct {
+	ExitStatus                   NTStatus
+	PebBaseAddress               *PEB
+	AffinityMask                 uintptr
+	BasePriority                 int32
+	UniqueProcessId              uintptr
+	InheritedFromUniqueProcessId uintptr
+}
+
+// Constants for LocalAlloc flags.
+const (
+	LMEM_FIXED          = 0x0
+	LMEM_MOVEABLE       = 0x2
+	LMEM_NOCOMPACT      = 0x10
+	LMEM_NODISCARD      = 0x20
+	LMEM_ZEROINIT       = 0x40
+	LMEM_MODIFY         = 0x80
+	LMEM_DISCARDABLE    = 0xf00
+	LMEM_VALID_FLAGS    = 0xf72
+	LMEM_INVALID_HANDLE = 0x8000
+	LHND                = LMEM_MOVEABLE | LMEM_ZEROINIT
+	LPTR                = LMEM_FIXED | LMEM_ZEROINIT
+	NONZEROLHND         = LMEM_MOVEABLE
+	NONZEROLPTR         = LMEM_FIXED
+)
+
+// Constants for the CreateNamedPipe-family of functions.
+const (
+	PIPE_ACCESS_INBOUND  = 0x1
+	PIPE_ACCESS_OUTBOUND = 0x2
+	PIPE_ACCESS_DUPLEX   = 0x3
+
+	PIPE_CLIENT_END = 0x0
+	PIPE_SERVER_END = 0x1
+
+	PIPE_WAIT                  = 0x0
+	PIPE_NOWAIT                = 0x1
+	PIPE_READMODE_BYTE         = 0x0
+	PIPE_READMODE_MESSAGE      = 0x2
+	PIPE_TYPE_BYTE             = 0x0
+	PIPE_TYPE_MESSAGE          = 0x4
+	PIPE_ACCEPT_REMOTE_CLIENTS = 0x0
+	PIPE_REJECT_REMOTE_CLIENTS = 0x8
+
+	PIPE_UNLIMITED_INSTANCES = 255
+)
+
+// Constants for security attributes when opening named pipes.
+const (
+	SECURITY_ANONYMOUS      = SecurityAnonymous << 16
+	SECURITY_IDENTIFICATION = SecurityIdentification << 16
+	SECURITY_IMPERSONATION  = SecurityImpersonation << 16
+	SECURITY_DELEGATION     = SecurityDelegation << 16
+
+	SECURITY_CONTEXT_TRACKING = 0x40000
+	SECURITY_EFFECTIVE_ONLY   = 0x80000
+
+	SECURITY_SQOS_PRESENT     = 0x100000
+	SECURITY_VALID_SQOS_FLAGS = 0x1f0000
+)
+
+// ResourceID represents a 16-bit resource identifier, traditionally created with the MAKEINTRESOURCE macro.
+type ResourceID uint16
+
+// ResourceIDOrString must be either a ResourceID, to specify a resource or resource type by ID,
+// or a string, to specify a resource or resource type by name.
+type ResourceIDOrString interface{}
+
+// Predefined resource names and types.
+var (
+	// Predefined names.
+	CREATEPROCESS_MANIFEST_RESOURCE_ID                 ResourceID = 1
+	ISOLATIONAWARE_MANIFEST_RESOURCE_ID                ResourceID = 2
+	ISOLATIONAWARE_NOSTATICIMPORT_MANIFEST_RESOURCE_ID ResourceID = 3
+	ISOLATIONPOLICY_MANIFEST_RESOURCE_ID               ResourceID = 4
+	ISOLATIONPOLICY_BROWSER_MANIFEST_RESOURCE_ID       ResourceID = 5
+	MINIMUM_RESERVED_MANIFEST_RESOURCE_ID              ResourceID = 1  // inclusive
+	MAXIMUM_RESERVED_MANIFEST_RESOURCE_ID              ResourceID = 16 // inclusive
+
+	// Predefined types.
+	RT_CURSOR       ResourceID = 1
+	RT_BITMAP       ResourceID = 2
+	RT_ICON         ResourceID = 3
+	RT_MENU         ResourceID = 4
+	RT_DIALOG       ResourceID = 5
+	RT_STRING       ResourceID = 6
+	RT_FONTDIR      ResourceID = 7
+	RT_FONT         ResourceID = 8
+	RT_ACCELERATOR  ResourceID = 9
+	RT_RCDATA       ResourceID = 10
+	RT_MESSAGETABLE ResourceID = 11
+	RT_GROUP_CURSOR ResourceID = 12
+	RT_GROUP_ICON   ResourceID = 14
+	RT_VERSION      ResourceID = 16
+	RT_DLGINCLUDE   ResourceID = 17
+	RT_PLUGPLAY     ResourceID = 19
+	RT_VXD          ResourceID = 20
+	RT_ANICURSOR    ResourceID = 21
+	RT_ANIICON      ResourceID = 22
+	RT_HTML         ResourceID = 23
+	RT_MANIFEST     ResourceID = 24
+)
+
+type COAUTHIDENTITY struct {
+	User           *uint16
+	UserLength     uint32
+	Domain         *uint16
+	DomainLength   uint32
+	Password       *uint16
+	PasswordLength uint32
+	Flags          uint32
+}
+
+type COAUTHINFO struct {
+	AuthnSvc           uint32
+	AuthzSvc           uint32
+	ServerPrincName    *uint16
+	AuthnLevel         uint32
+	ImpersonationLevel uint32
+	AuthIdentityData   *COAUTHIDENTITY
+	Capabilities       uint32
+}
+
+type COSERVERINFO struct {
+	Reserved1 uint32
+	Aame      *uint16
+	AuthInfo  *COAUTHINFO
+	Reserved2 uint32
+}
+
+type BIND_OPTS3 struct {
+	CbStruct          uint32
+	Flags             uint32
+	Mode              uint32
+	TickCountDeadline uint32
+	TrackFlags        uint32
+	ClassContext      uint32
+	Locale            uint32
+	ServerInfo        *COSERVERINFO
+	Hwnd              HWND
+}
+
+const (
+	CLSCTX_INPROC_SERVER          = 0x1
+	CLSCTX_INPROC_HANDLER         = 0x2
+	CLSCTX_LOCAL_SERVER           = 0x4
+	CLSCTX_INPROC_SERVER16        = 0x8
+	CLSCTX_REMOTE_SERVER          = 0x10
+	CLSCTX_INPROC_HANDLER16       = 0x20
+	CLSCTX_RESERVED1              = 0x40
+	CLSCTX_RESERVED2              = 0x80
+	CLSCTX_RESERVED3              = 0x100
+	CLSCTX_RESERVED4              = 0x200
+	CLSCTX_NO_CODE_DOWNLOAD       = 0x400
+	CLSCTX_RESERVED5              = 0x800
+	CLSCTX_NO_CUSTOM_MARSHAL      = 0x1000
+	CLSCTX_ENABLE_CODE_DOWNLOAD   = 0x2000
+	CLSCTX_NO_FAILURE_LOG         = 0x4000
+	CLSCTX_DISABLE_AAA            = 0x8000
+	CLSCTX_ENABLE_AAA             = 0x10000
+	CLSCTX_FROM_DEFAULT_CONTEXT   = 0x20000
+	CLSCTX_ACTIVATE_32_BIT_SERVER = 0x40000
+	CLSCTX_ACTIVATE_64_BIT_SERVER = 0x80000
+	CLSCTX_ENABLE_CLOAKING        = 0x100000
+	CLSCTX_APPCONTAINER           = 0x400000
+	CLSCTX_ACTIVATE_AAA_AS_IU     = 0x800000
+	CLSCTX_PS_DLL                 = 0x80000000
+
+	COINIT_MULTITHREADED     = 0x0
+	COINIT_APARTMENTTHREADED = 0x2
+	COINIT_DISABLE_OLE1DDE   = 0x4
+	COINIT_SPEED_OVER_MEMORY = 0x8
+)
+
+// Flag for QueryFullProcessImageName.
+const PROCESS_NAME_NATIVE = 1
diff --git a/src/cmd/vendor/golang.org/x/sys/windows/zerrors_windows.go b/src/cmd/vendor/golang.org/x/sys/windows/zerrors_windows.go
index f021200352..0cf658fbd5 100644
--- a/src/cmd/vendor/golang.org/x/sys/windows/zerrors_windows.go
+++ b/src/cmd/vendor/golang.org/x/sys/windows/zerrors_windows.go
@@ -146,6 +146,7 @@ const (
 	FACILITY_WEP                                                                            = 2049
 	FACILITY_SYNCENGINE                                                                     = 2050
 	FACILITY_XBOX                                                                           = 2339
+	FACILITY_GAME                                                                           = 2340
 	FACILITY_PIX                                                                            = 2748
 	ERROR_SUCCESS                                                             syscall.Errno = 0
 	NO_ERROR                                                                                = 0
@@ -469,9 +470,18 @@ const (
 	ERROR_STORAGE_RESERVE_NOT_EMPTY                                           syscall.Errno = 419
 	ERROR_NOT_A_DAX_VOLUME                                                    syscall.Errno = 420
 	ERROR_NOT_DAX_MAPPABLE                                                    syscall.Errno = 421
-	ERROR_TIME_CRITICAL_THREAD                                                syscall.Errno = 422
+	ERROR_TIME_SENSITIVE_THREAD                                               syscall.Errno = 422
 	ERROR_DPL_NOT_SUPPORTED_FOR_USER                                          syscall.Errno = 423
 	ERROR_CASE_DIFFERING_NAMES_IN_DIR                                         syscall.Errno = 424
+	ERROR_FILE_NOT_SUPPORTED                                                  syscall.Errno = 425
+	ERROR_CLOUD_FILE_REQUEST_TIMEOUT                                          syscall.Errno = 426
+	ERROR_NO_TASK_QUEUE                                                       syscall.Errno = 427
+	ERROR_SRC_SRV_DLL_LOAD_FAILED                                             syscall.Errno = 428
+	ERROR_NOT_SUPPORTED_WITH_BTT                                              syscall.Errno = 429
+	ERROR_ENCRYPTION_DISABLED                                                 syscall.Errno = 430
+	ERROR_ENCRYPTING_METADATA_DISALLOWED                                      syscall.Errno = 431
+	ERROR_CANT_CLEAR_ENCRYPTION_FLAG                                          syscall.Errno = 432
+	ERROR_NO_SUCH_DEVICE                                                      syscall.Errno = 433
 	ERROR_CAPAUTHZ_NOT_DEVUNLOCKED                                            syscall.Errno = 450
 	ERROR_CAPAUTHZ_CHANGE_TYPE                                                syscall.Errno = 451
 	ERROR_CAPAUTHZ_NOT_PROVISIONED                                            syscall.Errno = 452
@@ -1593,6 +1603,8 @@ const (
 	ERROR_SYSTEM_INTEGRITY_POLICY_VIOLATION                                   syscall.Errno = 4551
 	ERROR_SYSTEM_INTEGRITY_INVALID_POLICY                                     syscall.Errno = 4552
 	ERROR_SYSTEM_INTEGRITY_POLICY_NOT_SIGNED                                  syscall.Errno = 4553
+	ERROR_SYSTEM_INTEGRITY_TOO_MANY_POLICIES                                  syscall.Errno = 4554
+	ERROR_SYSTEM_INTEGRITY_SUPPLEMENTAL_POLICY_NOT_AUTHORIZED                 syscall.Errno = 4555
 	ERROR_VSM_NOT_INITIALIZED                                                 syscall.Errno = 4560
 	ERROR_VSM_DMA_PROTECTION_NOT_IN_USE                                       syscall.Errno = 4561
 	ERROR_PLATFORM_MANIFEST_NOT_AUTHORIZED                                    syscall.Errno = 4570
@@ -1824,6 +1836,7 @@ const (
 	ERROR_CS_ENCRYPTION_NEW_ENCRYPTED_FILE                                    syscall.Errno = 6020
 	ERROR_CS_ENCRYPTION_FILE_NOT_CSE                                          syscall.Errno = 6021
 	ERROR_ENCRYPTION_POLICY_DENIES_OPERATION                                  syscall.Errno = 6022
+	ERROR_WIP_ENCRYPTION_FAILED                                               syscall.Errno = 6023
 	ERROR_NO_BROWSER_SERVERS_FOUND                                            syscall.Errno = 6118
 	SCHED_E_SERVICE_NOT_LOCALSYSTEM                                           syscall.Errno = 6200
 	ERROR_LOG_SECTOR_INVALID                                                  syscall.Errno = 6600
@@ -3000,6 +3013,7 @@ const (
 	ERROR_SMI_PRIMITIVE_INSTALLER_FAILED                                      syscall.Errno = 14108
 	ERROR_GENERIC_COMMAND_FAILED                                              syscall.Errno = 14109
 	ERROR_SXS_FILE_HASH_MISSING                                               syscall.Errno = 14110
+	ERROR_SXS_DUPLICATE_ACTIVATABLE_CLASS                                     syscall.Errno = 14111
 	ERROR_EVT_INVALID_CHANNEL_PATH                                            syscall.Errno = 15000
 	ERROR_EVT_INVALID_QUERY                                                   syscall.Errno = 15001
 	ERROR_EVT_PUBLISHER_METADATA_NOT_FOUND                                    syscall.Errno = 15002
@@ -3093,6 +3107,7 @@ const (
 	ERROR_PRI_MERGE_RESOURCE_PACKAGE_REQUIRED                                 syscall.Errno = 15157
 	ERROR_PRI_MERGE_INVALID_FILE_NAME                                         syscall.Errno = 15158
 	ERROR_MRM_PACKAGE_NOT_FOUND                                               syscall.Errno = 15159
+	ERROR_MRM_MISSING_DEFAULT_LANGUAGE                                        syscall.Errno = 15160
 	ERROR_MCA_INVALID_CAPABILITIES_STRING                                     syscall.Errno = 15200
 	ERROR_MCA_INVALID_VCP_VERSION                                             syscall.Errno = 15201
 	ERROR_MCA_MONITOR_VIOLATES_MCCS_SPECIFICATION                             syscall.Errno = 15202
@@ -3167,6 +3182,15 @@ const (
 	ERROR_DEPLOYMENT_OPTION_NOT_SUPPORTED                                     syscall.Errno = 15645
 	ERROR_APPINSTALLER_ACTIVATION_BLOCKED                                     syscall.Errno = 15646
 	ERROR_REGISTRATION_FROM_REMOTE_DRIVE_NOT_SUPPORTED                        syscall.Errno = 15647
+	ERROR_APPX_RAW_DATA_WRITE_FAILED                                          syscall.Errno = 15648
+	ERROR_DEPLOYMENT_BLOCKED_BY_VOLUME_POLICY_PACKAGE                         syscall.Errno = 15649
+	ERROR_DEPLOYMENT_BLOCKED_BY_VOLUME_POLICY_MACHINE                         syscall.Errno = 15650
+	ERROR_DEPLOYMENT_BLOCKED_BY_PROFILE_POLICY                                syscall.Errno = 15651
+	ERROR_DEPLOYMENT_FAILED_CONFLICTING_MUTABLE_PACKAGE_DIRECTORY             syscall.Errno = 15652
+	ERROR_SINGLETON_RESOURCE_INSTALLED_IN_ACTIVE_USER                         syscall.Errno = 15653
+	ERROR_DIFFERENT_VERSION_OF_PACKAGED_SERVICE_INSTALLED                     syscall.Errno = 15654
+	ERROR_SERVICE_EXISTS_AS_NON_PACKAGED_SERVICE                              syscall.Errno = 15655
+	ERROR_PACKAGED_SERVICE_REQUIRES_ADMIN_PRIVILEGES                          syscall.Errno = 15656
 	APPMODEL_ERROR_NO_PACKAGE                                                 syscall.Errno = 15700
 	APPMODEL_ERROR_PACKAGE_RUNTIME_CORRUPT                                    syscall.Errno = 15701
 	APPMODEL_ERROR_PACKAGE_IDENTITY_CORRUPT                                   syscall.Errno = 15702
@@ -3174,6 +3198,7 @@ const (
 	APPMODEL_ERROR_DYNAMIC_PROPERTY_READ_FAILED                               syscall.Errno = 15704
 	APPMODEL_ERROR_DYNAMIC_PROPERTY_INVALID                                   syscall.Errno = 15705
 	APPMODEL_ERROR_PACKAGE_NOT_AVAILABLE                                      syscall.Errno = 15706
+	APPMODEL_ERROR_NO_MUTABLE_DIRECTORY                                       syscall.Errno = 15707
 	ERROR_STATE_LOAD_STORE_FAILED                                             syscall.Errno = 15800
 	ERROR_STATE_GET_VERSION_FAILED                                            syscall.Errno = 15801
 	ERROR_STATE_SET_VERSION_FAILED                                            syscall.Errno = 15802
@@ -3204,7 +3229,8 @@ const (
 	E_NOT_SET                                                                               = ERROR_NOT_FOUND
 	E_NOT_VALID_STATE                                                                       = ERROR_INVALID_STATE
 	E_NOT_SUFFICIENT_BUFFER                                                                 = ERROR_INSUFFICIENT_BUFFER
-	E_TIME_CRITICAL_THREAD                                                                  = ERROR_TIME_CRITICAL_THREAD
+	E_TIME_SENSITIVE_THREAD                                                                 = ERROR_TIME_SENSITIVE_THREAD
+	E_NO_TASK_QUEUE                                                                         = ERROR_NO_TASK_QUEUE
 	NOERROR                                                                   syscall.Errno = 0
 	E_UNEXPECTED                                                              Handle        = 0x8000FFFF
 	E_NOTIMPL                                                                 Handle        = 0x80004001
@@ -3966,6 +3992,7 @@ const (
 	SEC_I_COMPLETE_NEEDED                                                     Handle        = 0x00090313
 	SEC_I_COMPLETE_AND_CONTINUE                                               Handle        = 0x00090314
 	SEC_I_LOCAL_LOGON                                                         Handle        = 0x00090315
+	SEC_I_GENERIC_EXTENSION_RECEIVED                                          Handle        = 0x00090316
 	SEC_E_BAD_PKGID                                                           Handle        = 0x80090316
 	SEC_E_CONTEXT_EXPIRED                                                     Handle        = 0x80090317
 	SEC_I_CONTEXT_EXPIRED                                                     Handle        = 0x00090317
@@ -4033,6 +4060,8 @@ const (
 	SEC_E_APPLICATION_PROTOCOL_MISMATCH                                       Handle        = 0x80090367
 	SEC_I_ASYNC_CALL_PENDING                                                  Handle        = 0x00090368
 	SEC_E_INVALID_UPN_NAME                                                    Handle        = 0x80090369
+	SEC_E_EXT_BUFFER_TOO_SMALL                                                Handle        = 0x8009036A
+	SEC_E_INSUFFICIENT_BUFFERS                                                Handle        = 0x8009036B
 	SEC_E_NO_SPM                                                                            = SEC_E_INTERNAL_ERROR
 	SEC_E_NOT_SUPPORTED                                                                     = SEC_E_UNSUPPORTED_FUNCTION
 	CRYPT_E_MSG_ERROR                                                         Handle        = 0x80091001
@@ -4637,6 +4666,8 @@ const (
 	ERROR_GRAPHICS_PRESENT_INVALID_WINDOW                                     Handle        = 0xC026200F
 	ERROR_GRAPHICS_PRESENT_BUFFER_NOT_BOUND                                   Handle        = 0xC0262010
 	ERROR_GRAPHICS_VAIL_STATE_CHANGED                                         Handle        = 0xC0262011
+	ERROR_GRAPHICS_INDIRECT_DISPLAY_ABANDON_SWAPCHAIN                         Handle        = 0xC0262012
+	ERROR_GRAPHICS_INDIRECT_DISPLAY_DEVICE_STOPPED                            Handle        = 0xC0262013
 	ERROR_GRAPHICS_NO_VIDEO_MEMORY                                            Handle        = 0xC0262100
 	ERROR_GRAPHICS_CANT_LOCK_MEMORY                                           Handle        = 0xC0262101
 	ERROR_GRAPHICS_ALLOCATION_BUSY                                            Handle        = 0xC0262102
@@ -5393,6 +5424,13 @@ const (
 	FVE_E_NOT_DE_VOLUME                                                       Handle        = 0x803100D7
 	FVE_E_PROTECTION_CANNOT_BE_DISABLED                                       Handle        = 0x803100D8
 	FVE_E_OSV_KSR_NOT_ALLOWED                                                 Handle        = 0x803100D9
+	FVE_E_AD_BACKUP_REQUIRED_POLICY_NOT_SET_OS_DRIVE                          Handle        = 0x803100DA
+	FVE_E_AD_BACKUP_REQUIRED_POLICY_NOT_SET_FIXED_DRIVE                       Handle        = 0x803100DB
+	FVE_E_AD_BACKUP_REQUIRED_POLICY_NOT_SET_REMOVABLE_DRIVE                   Handle        = 0x803100DC
+	FVE_E_KEY_ROTATION_NOT_SUPPORTED                                          Handle        = 0x803100DD
+	FVE_E_EXECUTE_REQUEST_SENT_TOO_SOON                                       Handle        = 0x803100DE
+	FVE_E_KEY_ROTATION_NOT_ENABLED                                            Handle        = 0x803100DF
+	FVE_E_DEVICE_NOT_JOINED                                                   Handle        = 0x803100E0
 	FWP_E_CALLOUT_NOT_FOUND                                                   Handle        = 0x80320001
 	FWP_E_CONDITION_NOT_FOUND                                                 Handle        = 0x80320002
 	FWP_E_FILTER_NOT_FOUND                                                    Handle        = 0x80320003
@@ -5881,6 +5919,12 @@ const (
 	GCN_E_NETCOMPARTMENT_NOT_FOUND                                            Handle        = 0x803B0027
 	GCN_E_NETINTERFACE_NOT_FOUND                                              Handle        = 0x803B0028
 	GCN_E_DEFAULTNAMESPACE_EXISTS                                             Handle        = 0x803B0029
+	HCN_E_ICS_DISABLED                                                        Handle        = 0x803B002A
+	HCN_E_ENDPOINT_NAMESPACE_ALREADY_EXISTS                                   Handle        = 0x803B002B
+	HCN_E_ENTITY_HAS_REFERENCES                                               Handle        = 0x803B002C
+	HCN_E_INVALID_INTERNAL_PORT                                               Handle        = 0x803B002D
+	HCN_E_NAMESPACE_ATTACH_FAILED                                             Handle        = 0x803B002E
+	HCN_E_ADDR_INVALID_OR_RESERVED                                            Handle        = 0x803B002F
 	SDIAG_E_CANCELLED                                                         syscall.Errno = 0x803C0100
 	SDIAG_E_SCRIPT                                                            syscall.Errno = 0x803C0101
 	SDIAG_E_POWERSHELL                                                        syscall.Errno = 0x803C0102
@@ -6846,8 +6890,2579 @@ const (
 	UTC_E_INSUFFICIENT_SPACE_TO_START_TRACE                                   Handle        = 0x87C51059
 	UTC_E_ESCALATION_CANCELLED_AT_SHUTDOWN                                    Handle        = 0x87C5105A
 	UTC_E_GETFILEINFOACTION_FILE_NOT_APPROVED                                 Handle        = 0x87C5105B
+	UTC_E_SETREGKEYACTION_TYPE_NOT_APPROVED                                   Handle        = 0x87C5105C
 	WINML_ERR_INVALID_DEVICE                                                  Handle        = 0x88900001
 	WINML_ERR_INVALID_BINDING                                                 Handle        = 0x88900002
 	WINML_ERR_VALUE_NOTFOUND                                                  Handle        = 0x88900003
 	WINML_ERR_SIZE_MISMATCH                                                   Handle        = 0x88900004
+	STATUS_WAIT_0                                                             NTStatus      = 0x00000000
+	STATUS_SUCCESS                                                            NTStatus      = 0x00000000
+	STATUS_WAIT_1                                                             NTStatus      = 0x00000001
+	STATUS_WAIT_2                                                             NTStatus      = 0x00000002
+	STATUS_WAIT_3                                                             NTStatus      = 0x00000003
+	STATUS_WAIT_63                                                            NTStatus      = 0x0000003F
+	STATUS_ABANDONED                                                          NTStatus      = 0x00000080
+	STATUS_ABANDONED_WAIT_0                                                   NTStatus      = 0x00000080
+	STATUS_ABANDONED_WAIT_63                                                  NTStatus      = 0x000000BF
+	STATUS_USER_APC                                                           NTStatus      = 0x000000C0
+	STATUS_ALREADY_COMPLETE                                                   NTStatus      = 0x000000FF
+	STATUS_KERNEL_APC                                                         NTStatus      = 0x00000100
+	STATUS_ALERTED                                                            NTStatus      = 0x00000101
+	STATUS_TIMEOUT                                                            NTStatus      = 0x00000102
+	STATUS_PENDING                                                            NTStatus      = 0x00000103
+	STATUS_REPARSE                                                            NTStatus      = 0x00000104
+	STATUS_MORE_ENTRIES                                                       NTStatus      = 0x00000105
+	STATUS_NOT_ALL_ASSIGNED                                                   NTStatus      = 0x00000106
+	STATUS_SOME_NOT_MAPPED                                                    NTStatus      = 0x00000107
+	STATUS_OPLOCK_BREAK_IN_PROGRESS                                           NTStatus      = 0x00000108
+	STATUS_VOLUME_MOUNTED                                                     NTStatus      = 0x00000109
+	STATUS_RXACT_COMMITTED                                                    NTStatus      = 0x0000010A
+	STATUS_NOTIFY_CLEANUP                                                     NTStatus      = 0x0000010B
+	STATUS_NOTIFY_ENUM_DIR                                                    NTStatus      = 0x0000010C
+	STATUS_NO_QUOTAS_FOR_ACCOUNT                                              NTStatus      = 0x0000010D
+	STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED                                   NTStatus      = 0x0000010E
+	STATUS_PAGE_FAULT_TRANSITION                                              NTStatus      = 0x00000110
+	STATUS_PAGE_FAULT_DEMAND_ZERO                                             NTStatus      = 0x00000111
+	STATUS_PAGE_FAULT_COPY_ON_WRITE                                           NTStatus      = 0x00000112
+	STATUS_PAGE_FAULT_GUARD_PAGE                                              NTStatus      = 0x00000113
+	STATUS_PAGE_FAULT_PAGING_FILE                                             NTStatus      = 0x00000114
+	STATUS_CACHE_PAGE_LOCKED                                                  NTStatus      = 0x00000115
+	STATUS_CRASH_DUMP                                                         NTStatus      = 0x00000116
+	STATUS_BUFFER_ALL_ZEROS                                                   NTStatus      = 0x00000117
+	STATUS_REPARSE_OBJECT                                                     NTStatus      = 0x00000118
+	STATUS_RESOURCE_REQUIREMENTS_CHANGED                                      NTStatus      = 0x00000119
+	STATUS_TRANSLATION_COMPLETE                                               NTStatus      = 0x00000120
+	STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY                                    NTStatus      = 0x00000121
+	STATUS_NOTHING_TO_TERMINATE                                               NTStatus      = 0x00000122
+	STATUS_PROCESS_NOT_IN_JOB                                                 NTStatus      = 0x00000123
+	STATUS_PROCESS_IN_JOB                                                     NTStatus      = 0x00000124
+	STATUS_VOLSNAP_HIBERNATE_READY                                            NTStatus      = 0x00000125
+	STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY                                 NTStatus      = 0x00000126
+	STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED                                 NTStatus      = 0x00000127
+	STATUS_INTERRUPT_STILL_CONNECTED                                          NTStatus      = 0x00000128
+	STATUS_PROCESS_CLONED                                                     NTStatus      = 0x00000129
+	STATUS_FILE_LOCKED_WITH_ONLY_READERS                                      NTStatus      = 0x0000012A
+	STATUS_FILE_LOCKED_WITH_WRITERS                                           NTStatus      = 0x0000012B
+	STATUS_VALID_IMAGE_HASH                                                   NTStatus      = 0x0000012C
+	STATUS_VALID_CATALOG_HASH                                                 NTStatus      = 0x0000012D
+	STATUS_VALID_STRONG_CODE_HASH                                             NTStatus      = 0x0000012E
+	STATUS_GHOSTED                                                            NTStatus      = 0x0000012F
+	STATUS_DATA_OVERWRITTEN                                                   NTStatus      = 0x00000130
+	STATUS_RESOURCEMANAGER_READ_ONLY                                          NTStatus      = 0x00000202
+	STATUS_RING_PREVIOUSLY_EMPTY                                              NTStatus      = 0x00000210
+	STATUS_RING_PREVIOUSLY_FULL                                               NTStatus      = 0x00000211
+	STATUS_RING_PREVIOUSLY_ABOVE_QUOTA                                        NTStatus      = 0x00000212
+	STATUS_RING_NEWLY_EMPTY                                                   NTStatus      = 0x00000213
+	STATUS_RING_SIGNAL_OPPOSITE_ENDPOINT                                      NTStatus      = 0x00000214
+	STATUS_OPLOCK_SWITCHED_TO_NEW_HANDLE                                      NTStatus      = 0x00000215
+	STATUS_OPLOCK_HANDLE_CLOSED                                               NTStatus      = 0x00000216
+	STATUS_WAIT_FOR_OPLOCK                                                    NTStatus      = 0x00000367
+	STATUS_REPARSE_GLOBAL                                                     NTStatus      = 0x00000368
+	STATUS_FLT_IO_COMPLETE                                                    NTStatus      = 0x001C0001
+	STATUS_OBJECT_NAME_EXISTS                                                 NTStatus      = 0x40000000
+	STATUS_THREAD_WAS_SUSPENDED                                               NTStatus      = 0x40000001
+	STATUS_WORKING_SET_LIMIT_RANGE                                            NTStatus      = 0x40000002
+	STATUS_IMAGE_NOT_AT_BASE                                                  NTStatus      = 0x40000003
+	STATUS_RXACT_STATE_CREATED                                                NTStatus      = 0x40000004
+	STATUS_SEGMENT_NOTIFICATION                                               NTStatus      = 0x40000005
+	STATUS_LOCAL_USER_SESSION_KEY                                             NTStatus      = 0x40000006
+	STATUS_BAD_CURRENT_DIRECTORY                                              NTStatus      = 0x40000007
+	STATUS_SERIAL_MORE_WRITES                                                 NTStatus      = 0x40000008
+	STATUS_REGISTRY_RECOVERED                                                 NTStatus      = 0x40000009
+	STATUS_FT_READ_RECOVERY_FROM_BACKUP                                       NTStatus      = 0x4000000A
+	STATUS_FT_WRITE_RECOVERY                                                  NTStatus      = 0x4000000B
+	STATUS_SERIAL_COUNTER_TIMEOUT                                             NTStatus      = 0x4000000C
+	STATUS_NULL_LM_PASSWORD                                                   NTStatus      = 0x4000000D
+	STATUS_IMAGE_MACHINE_TYPE_MISMATCH                                        NTStatus      = 0x4000000E
+	STATUS_RECEIVE_PARTIAL                                                    NTStatus      = 0x4000000F
+	STATUS_RECEIVE_EXPEDITED                                                  NTStatus      = 0x40000010
+	STATUS_RECEIVE_PARTIAL_EXPEDITED                                          NTStatus      = 0x40000011
+	STATUS_EVENT_DONE                                                         NTStatus      = 0x40000012
+	STATUS_EVENT_PENDING                                                      NTStatus      = 0x40000013
+	STATUS_CHECKING_FILE_SYSTEM                                               NTStatus      = 0x40000014
+	STATUS_FATAL_APP_EXIT                                                     NTStatus      = 0x40000015
+	STATUS_PREDEFINED_HANDLE                                                  NTStatus      = 0x40000016
+	STATUS_WAS_UNLOCKED                                                       NTStatus      = 0x40000017
+	STATUS_SERVICE_NOTIFICATION                                               NTStatus      = 0x40000018
+	STATUS_WAS_LOCKED                                                         NTStatus      = 0x40000019
+	STATUS_LOG_HARD_ERROR                                                     NTStatus      = 0x4000001A
+	STATUS_ALREADY_WIN32                                                      NTStatus      = 0x4000001B
+	STATUS_WX86_UNSIMULATE                                                    NTStatus      = 0x4000001C
+	STATUS_WX86_CONTINUE                                                      NTStatus      = 0x4000001D
+	STATUS_WX86_SINGLE_STEP                                                   NTStatus      = 0x4000001E
+	STATUS_WX86_BREAKPOINT                                                    NTStatus      = 0x4000001F
+	STATUS_WX86_EXCEPTION_CONTINUE                                            NTStatus      = 0x40000020
+	STATUS_WX86_EXCEPTION_LASTCHANCE                                          NTStatus      = 0x40000021
+	STATUS_WX86_EXCEPTION_CHAIN                                               NTStatus      = 0x40000022
+	STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE                                    NTStatus      = 0x40000023
+	STATUS_NO_YIELD_PERFORMED                                                 NTStatus      = 0x40000024
+	STATUS_TIMER_RESUME_IGNORED                                               NTStatus      = 0x40000025
+	STATUS_ARBITRATION_UNHANDLED                                              NTStatus      = 0x40000026
+	STATUS_CARDBUS_NOT_SUPPORTED                                              NTStatus      = 0x40000027
+	STATUS_WX86_CREATEWX86TIB                                                 NTStatus      = 0x40000028
+	STATUS_MP_PROCESSOR_MISMATCH                                              NTStatus      = 0x40000029
+	STATUS_HIBERNATED                                                         NTStatus      = 0x4000002A
+	STATUS_RESUME_HIBERNATION                                                 NTStatus      = 0x4000002B
+	STATUS_FIRMWARE_UPDATED                                                   NTStatus      = 0x4000002C
+	STATUS_DRIVERS_LEAKING_LOCKED_PAGES                                       NTStatus      = 0x4000002D
+	STATUS_MESSAGE_RETRIEVED                                                  NTStatus      = 0x4000002E
+	STATUS_SYSTEM_POWERSTATE_TRANSITION                                       NTStatus      = 0x4000002F
+	STATUS_ALPC_CHECK_COMPLETION_LIST                                         NTStatus      = 0x40000030
+	STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION                               NTStatus      = 0x40000031
+	STATUS_ACCESS_AUDIT_BY_POLICY                                             NTStatus      = 0x40000032
+	STATUS_ABANDON_HIBERFILE                                                  NTStatus      = 0x40000033
+	STATUS_BIZRULES_NOT_ENABLED                                               NTStatus      = 0x40000034
+	STATUS_FT_READ_FROM_COPY                                                  NTStatus      = 0x40000035
+	STATUS_IMAGE_AT_DIFFERENT_BASE                                            NTStatus      = 0x40000036
+	STATUS_PATCH_DEFERRED                                                     NTStatus      = 0x40000037
+	STATUS_HEURISTIC_DAMAGE_POSSIBLE                                          NTStatus      = 0x40190001
+	STATUS_GUARD_PAGE_VIOLATION                                               NTStatus      = 0x80000001
+	STATUS_DATATYPE_MISALIGNMENT                                              NTStatus      = 0x80000002
+	STATUS_BREAKPOINT                                                         NTStatus      = 0x80000003
+	STATUS_SINGLE_STEP                                                        NTStatus      = 0x80000004
+	STATUS_BUFFER_OVERFLOW                                                    NTStatus      = 0x80000005
+	STATUS_NO_MORE_FILES                                                      NTStatus      = 0x80000006
+	STATUS_WAKE_SYSTEM_DEBUGGER                                               NTStatus      = 0x80000007
+	STATUS_HANDLES_CLOSED                                                     NTStatus      = 0x8000000A
+	STATUS_NO_INHERITANCE                                                     NTStatus      = 0x8000000B
+	STATUS_GUID_SUBSTITUTION_MADE                                             NTStatus      = 0x8000000C
+	STATUS_PARTIAL_COPY                                                       NTStatus      = 0x8000000D
+	STATUS_DEVICE_PAPER_EMPTY                                                 NTStatus      = 0x8000000E
+	STATUS_DEVICE_POWERED_OFF                                                 NTStatus      = 0x8000000F
+	STATUS_DEVICE_OFF_LINE                                                    NTStatus      = 0x80000010
+	STATUS_DEVICE_BUSY                                                        NTStatus      = 0x80000011
+	STATUS_NO_MORE_EAS                                                        NTStatus      = 0x80000012
+	STATUS_INVALID_EA_NAME                                                    NTStatus      = 0x80000013
+	STATUS_EA_LIST_INCONSISTENT                                               NTStatus      = 0x80000014
+	STATUS_INVALID_EA_FLAG                                                    NTStatus      = 0x80000015
+	STATUS_VERIFY_REQUIRED                                                    NTStatus      = 0x80000016
+	STATUS_EXTRANEOUS_INFORMATION                                             NTStatus      = 0x80000017
+	STATUS_RXACT_COMMIT_NECESSARY                                             NTStatus      = 0x80000018
+	STATUS_NO_MORE_ENTRIES                                                    NTStatus      = 0x8000001A
+	STATUS_FILEMARK_DETECTED                                                  NTStatus      = 0x8000001B
+	STATUS_MEDIA_CHANGED                                                      NTStatus      = 0x8000001C
+	STATUS_BUS_RESET                                                          NTStatus      = 0x8000001D
+	STATUS_END_OF_MEDIA                                                       NTStatus      = 0x8000001E
+	STATUS_BEGINNING_OF_MEDIA                                                 NTStatus      = 0x8000001F
+	STATUS_MEDIA_CHECK                                                        NTStatus      = 0x80000020
+	STATUS_SETMARK_DETECTED                                                   NTStatus      = 0x80000021
+	STATUS_NO_DATA_DETECTED                                                   NTStatus      = 0x80000022
+	STATUS_REDIRECTOR_HAS_OPEN_HANDLES                                        NTStatus      = 0x80000023
+	STATUS_SERVER_HAS_OPEN_HANDLES                                            NTStatus      = 0x80000024
+	STATUS_ALREADY_DISCONNECTED                                               NTStatus      = 0x80000025
+	STATUS_LONGJUMP                                                           NTStatus      = 0x80000026
+	STATUS_CLEANER_CARTRIDGE_INSTALLED                                        NTStatus      = 0x80000027
+	STATUS_PLUGPLAY_QUERY_VETOED                                              NTStatus      = 0x80000028
+	STATUS_UNWIND_CONSOLIDATE                                                 NTStatus      = 0x80000029
+	STATUS_REGISTRY_HIVE_RECOVERED                                            NTStatus      = 0x8000002A
+	STATUS_DLL_MIGHT_BE_INSECURE                                              NTStatus      = 0x8000002B
+	STATUS_DLL_MIGHT_BE_INCOMPATIBLE                                          NTStatus      = 0x8000002C
+	STATUS_STOPPED_ON_SYMLINK                                                 NTStatus      = 0x8000002D
+	STATUS_CANNOT_GRANT_REQUESTED_OPLOCK                                      NTStatus      = 0x8000002E
+	STATUS_NO_ACE_CONDITION                                                   NTStatus      = 0x8000002F
+	STATUS_DEVICE_SUPPORT_IN_PROGRESS                                         NTStatus      = 0x80000030
+	STATUS_DEVICE_POWER_CYCLE_REQUIRED                                        NTStatus      = 0x80000031
+	STATUS_NO_WORK_DONE                                                       NTStatus      = 0x80000032
+	STATUS_CLUSTER_NODE_ALREADY_UP                                            NTStatus      = 0x80130001
+	STATUS_CLUSTER_NODE_ALREADY_DOWN                                          NTStatus      = 0x80130002
+	STATUS_CLUSTER_NETWORK_ALREADY_ONLINE                                     NTStatus      = 0x80130003
+	STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE                                    NTStatus      = 0x80130004
+	STATUS_CLUSTER_NODE_ALREADY_MEMBER                                        NTStatus      = 0x80130005
+	STATUS_FLT_BUFFER_TOO_SMALL                                               NTStatus      = 0x801C0001
+	STATUS_FVE_PARTIAL_METADATA                                               NTStatus      = 0x80210001
+	STATUS_FVE_TRANSIENT_STATE                                                NTStatus      = 0x80210002
+	STATUS_CLOUD_FILE_PROPERTY_BLOB_CHECKSUM_MISMATCH                         NTStatus      = 0x8000CF00
+	STATUS_UNSUCCESSFUL                                                       NTStatus      = 0xC0000001
+	STATUS_NOT_IMPLEMENTED                                                    NTStatus      = 0xC0000002
+	STATUS_INVALID_INFO_CLASS                                                 NTStatus      = 0xC0000003
+	STATUS_INFO_LENGTH_MISMATCH                                               NTStatus      = 0xC0000004
+	STATUS_ACCESS_VIOLATION                                                   NTStatus      = 0xC0000005
+	STATUS_IN_PAGE_ERROR                                                      NTStatus      = 0xC0000006
+	STATUS_PAGEFILE_QUOTA                                                     NTStatus      = 0xC0000007
+	STATUS_INVALID_HANDLE                                                     NTStatus      = 0xC0000008
+	STATUS_BAD_INITIAL_STACK                                                  NTStatus      = 0xC0000009
+	STATUS_BAD_INITIAL_PC                                                     NTStatus      = 0xC000000A
+	STATUS_INVALID_CID                                                        NTStatus      = 0xC000000B
+	STATUS_TIMER_NOT_CANCELED                                                 NTStatus      = 0xC000000C
+	STATUS_INVALID_PARAMETER                                                  NTStatus      = 0xC000000D
+	STATUS_NO_SUCH_DEVICE                                                     NTStatus      = 0xC000000E
+	STATUS_NO_SUCH_FILE                                                       NTStatus      = 0xC000000F
+	STATUS_INVALID_DEVICE_REQUEST                                             NTStatus      = 0xC0000010
+	STATUS_END_OF_FILE                                                        NTStatus      = 0xC0000011
+	STATUS_WRONG_VOLUME                                                       NTStatus      = 0xC0000012
+	STATUS_NO_MEDIA_IN_DEVICE                                                 NTStatus      = 0xC0000013
+	STATUS_UNRECOGNIZED_MEDIA                                                 NTStatus      = 0xC0000014
+	STATUS_NONEXISTENT_SECTOR                                                 NTStatus      = 0xC0000015
+	STATUS_MORE_PROCESSING_REQUIRED                                           NTStatus      = 0xC0000016
+	STATUS_NO_MEMORY                                                          NTStatus      = 0xC0000017
+	STATUS_CONFLICTING_ADDRESSES                                              NTStatus      = 0xC0000018
+	STATUS_NOT_MAPPED_VIEW                                                    NTStatus      = 0xC0000019
+	STATUS_UNABLE_TO_FREE_VM                                                  NTStatus      = 0xC000001A
+	STATUS_UNABLE_TO_DELETE_SECTION                                           NTStatus      = 0xC000001B
+	STATUS_INVALID_SYSTEM_SERVICE                                             NTStatus      = 0xC000001C
+	STATUS_ILLEGAL_INSTRUCTION                                                NTStatus      = 0xC000001D
+	STATUS_INVALID_LOCK_SEQUENCE                                              NTStatus      = 0xC000001E
+	STATUS_INVALID_VIEW_SIZE                                                  NTStatus      = 0xC000001F
+	STATUS_INVALID_FILE_FOR_SECTION                                           NTStatus      = 0xC0000020
+	STATUS_ALREADY_COMMITTED                                                  NTStatus      = 0xC0000021
+	STATUS_ACCESS_DENIED                                                      NTStatus      = 0xC0000022
+	STATUS_BUFFER_TOO_SMALL                                                   NTStatus      = 0xC0000023
+	STATUS_OBJECT_TYPE_MISMATCH                                               NTStatus      = 0xC0000024
+	STATUS_NONCONTINUABLE_EXCEPTION                                           NTStatus      = 0xC0000025
+	STATUS_INVALID_DISPOSITION                                                NTStatus      = 0xC0000026
+	STATUS_UNWIND                                                             NTStatus      = 0xC0000027
+	STATUS_BAD_STACK                                                          NTStatus      = 0xC0000028
+	STATUS_INVALID_UNWIND_TARGET                                              NTStatus      = 0xC0000029
+	STATUS_NOT_LOCKED                                                         NTStatus      = 0xC000002A
+	STATUS_PARITY_ERROR                                                       NTStatus      = 0xC000002B
+	STATUS_UNABLE_TO_DECOMMIT_VM                                              NTStatus      = 0xC000002C
+	STATUS_NOT_COMMITTED                                                      NTStatus      = 0xC000002D
+	STATUS_INVALID_PORT_ATTRIBUTES                                            NTStatus      = 0xC000002E
+	STATUS_PORT_MESSAGE_TOO_LONG                                              NTStatus      = 0xC000002F
+	STATUS_INVALID_PARAMETER_MIX                                              NTStatus      = 0xC0000030
+	STATUS_INVALID_QUOTA_LOWER                                                NTStatus      = 0xC0000031
+	STATUS_DISK_CORRUPT_ERROR                                                 NTStatus      = 0xC0000032
+	STATUS_OBJECT_NAME_INVALID                                                NTStatus      = 0xC0000033
+	STATUS_OBJECT_NAME_NOT_FOUND                                              NTStatus      = 0xC0000034
+	STATUS_OBJECT_NAME_COLLISION                                              NTStatus      = 0xC0000035
+	STATUS_PORT_DO_NOT_DISTURB                                                NTStatus      = 0xC0000036
+	STATUS_PORT_DISCONNECTED                                                  NTStatus      = 0xC0000037
+	STATUS_DEVICE_ALREADY_ATTACHED                                            NTStatus      = 0xC0000038
+	STATUS_OBJECT_PATH_INVALID                                                NTStatus      = 0xC0000039
+	STATUS_OBJECT_PATH_NOT_FOUND                                              NTStatus      = 0xC000003A
+	STATUS_OBJECT_PATH_SYNTAX_BAD                                             NTStatus      = 0xC000003B
+	STATUS_DATA_OVERRUN                                                       NTStatus      = 0xC000003C
+	STATUS_DATA_LATE_ERROR                                                    NTStatus      = 0xC000003D
+	STATUS_DATA_ERROR                                                         NTStatus      = 0xC000003E
+	STATUS_CRC_ERROR                                                          NTStatus      = 0xC000003F
+	STATUS_SECTION_TOO_BIG                                                    NTStatus      = 0xC0000040
+	STATUS_PORT_CONNECTION_REFUSED                                            NTStatus      = 0xC0000041
+	STATUS_INVALID_PORT_HANDLE                                                NTStatus      = 0xC0000042
+	STATUS_SHARING_VIOLATION                                                  NTStatus      = 0xC0000043
+	STATUS_QUOTA_EXCEEDED                                                     NTStatus      = 0xC0000044
+	STATUS_INVALID_PAGE_PROTECTION                                            NTStatus      = 0xC0000045
+	STATUS_MUTANT_NOT_OWNED                                                   NTStatus      = 0xC0000046
+	STATUS_SEMAPHORE_LIMIT_EXCEEDED                                           NTStatus      = 0xC0000047
+	STATUS_PORT_ALREADY_SET                                                   NTStatus      = 0xC0000048
+	STATUS_SECTION_NOT_IMAGE                                                  NTStatus      = 0xC0000049
+	STATUS_SUSPEND_COUNT_EXCEEDED                                             NTStatus      = 0xC000004A
+	STATUS_THREAD_IS_TERMINATING                                              NTStatus      = 0xC000004B
+	STATUS_BAD_WORKING_SET_LIMIT                                              NTStatus      = 0xC000004C
+	STATUS_INCOMPATIBLE_FILE_MAP                                              NTStatus      = 0xC000004D
+	STATUS_SECTION_PROTECTION                                                 NTStatus      = 0xC000004E
+	STATUS_EAS_NOT_SUPPORTED                                                  NTStatus      = 0xC000004F
+	STATUS_EA_TOO_LARGE                                                       NTStatus      = 0xC0000050
+	STATUS_NONEXISTENT_EA_ENTRY                                               NTStatus      = 0xC0000051
+	STATUS_NO_EAS_ON_FILE                                                     NTStatus      = 0xC0000052
+	STATUS_EA_CORRUPT_ERROR                                                   NTStatus      = 0xC0000053
+	STATUS_FILE_LOCK_CONFLICT                                                 NTStatus      = 0xC0000054
+	STATUS_LOCK_NOT_GRANTED                                                   NTStatus      = 0xC0000055
+	STATUS_DELETE_PENDING                                                     NTStatus      = 0xC0000056
+	STATUS_CTL_FILE_NOT_SUPPORTED                                             NTStatus      = 0xC0000057
+	STATUS_UNKNOWN_REVISION                                                   NTStatus      = 0xC0000058
+	STATUS_REVISION_MISMATCH                                                  NTStatus      = 0xC0000059
+	STATUS_INVALID_OWNER                                                      NTStatus      = 0xC000005A
+	STATUS_INVALID_PRIMARY_GROUP                                              NTStatus      = 0xC000005B
+	STATUS_NO_IMPERSONATION_TOKEN                                             NTStatus      = 0xC000005C
+	STATUS_CANT_DISABLE_MANDATORY                                             NTStatus      = 0xC000005D
+	STATUS_NO_LOGON_SERVERS                                                   NTStatus      = 0xC000005E
+	STATUS_NO_SUCH_LOGON_SESSION                                              NTStatus      = 0xC000005F
+	STATUS_NO_SUCH_PRIVILEGE                                                  NTStatus      = 0xC0000060
+	STATUS_PRIVILEGE_NOT_HELD                                                 NTStatus      = 0xC0000061
+	STATUS_INVALID_ACCOUNT_NAME                                               NTStatus      = 0xC0000062
+	STATUS_USER_EXISTS                                                        NTStatus      = 0xC0000063
+	STATUS_NO_SUCH_USER                                                       NTStatus      = 0xC0000064
+	STATUS_GROUP_EXISTS                                                       NTStatus      = 0xC0000065
+	STATUS_NO_SUCH_GROUP                                                      NTStatus      = 0xC0000066
+	STATUS_MEMBER_IN_GROUP                                                    NTStatus      = 0xC0000067
+	STATUS_MEMBER_NOT_IN_GROUP                                                NTStatus      = 0xC0000068
+	STATUS_LAST_ADMIN                                                         NTStatus      = 0xC0000069
+	STATUS_WRONG_PASSWORD                                                     NTStatus      = 0xC000006A
+	STATUS_ILL_FORMED_PASSWORD                                                NTStatus      = 0xC000006B
+	STATUS_PASSWORD_RESTRICTION                                               NTStatus      = 0xC000006C
+	STATUS_LOGON_FAILURE                                                      NTStatus      = 0xC000006D
+	STATUS_ACCOUNT_RESTRICTION                                                NTStatus      = 0xC000006E
+	STATUS_INVALID_LOGON_HOURS                                                NTStatus      = 0xC000006F
+	STATUS_INVALID_WORKSTATION                                                NTStatus      = 0xC0000070
+	STATUS_PASSWORD_EXPIRED                                                   NTStatus      = 0xC0000071
+	STATUS_ACCOUNT_DISABLED                                                   NTStatus      = 0xC0000072
+	STATUS_NONE_MAPPED                                                        NTStatus      = 0xC0000073
+	STATUS_TOO_MANY_LUIDS_REQUESTED                                           NTStatus      = 0xC0000074
+	STATUS_LUIDS_EXHAUSTED                                                    NTStatus      = 0xC0000075
+	STATUS_INVALID_SUB_AUTHORITY                                              NTStatus      = 0xC0000076
+	STATUS_INVALID_ACL                                                        NTStatus      = 0xC0000077
+	STATUS_INVALID_SID                                                        NTStatus      = 0xC0000078
+	STATUS_INVALID_SECURITY_DESCR                                             NTStatus      = 0xC0000079
+	STATUS_PROCEDURE_NOT_FOUND                                                NTStatus      = 0xC000007A
+	STATUS_INVALID_IMAGE_FORMAT                                               NTStatus      = 0xC000007B
+	STATUS_NO_TOKEN                                                           NTStatus      = 0xC000007C
+	STATUS_BAD_INHERITANCE_ACL                                                NTStatus      = 0xC000007D
+	STATUS_RANGE_NOT_LOCKED                                                   NTStatus      = 0xC000007E
+	STATUS_DISK_FULL                                                          NTStatus      = 0xC000007F
+	STATUS_SERVER_DISABLED                                                    NTStatus      = 0xC0000080
+	STATUS_SERVER_NOT_DISABLED                                                NTStatus      = 0xC0000081
+	STATUS_TOO_MANY_GUIDS_REQUESTED                                           NTStatus      = 0xC0000082
+	STATUS_GUIDS_EXHAUSTED                                                    NTStatus      = 0xC0000083
+	STATUS_INVALID_ID_AUTHORITY                                               NTStatus      = 0xC0000084
+	STATUS_AGENTS_EXHAUSTED                                                   NTStatus      = 0xC0000085
+	STATUS_INVALID_VOLUME_LABEL                                               NTStatus      = 0xC0000086
+	STATUS_SECTION_NOT_EXTENDED                                               NTStatus      = 0xC0000087
+	STATUS_NOT_MAPPED_DATA                                                    NTStatus      = 0xC0000088
+	STATUS_RESOURCE_DATA_NOT_FOUND                                            NTStatus      = 0xC0000089
+	STATUS_RESOURCE_TYPE_NOT_FOUND                                            NTStatus      = 0xC000008A
+	STATUS_RESOURCE_NAME_NOT_FOUND                                            NTStatus      = 0xC000008B
+	STATUS_ARRAY_BOUNDS_EXCEEDED                                              NTStatus      = 0xC000008C
+	STATUS_FLOAT_DENORMAL_OPERAND                                             NTStatus      = 0xC000008D
+	STATUS_FLOAT_DIVIDE_BY_ZERO                                               NTStatus      = 0xC000008E
+	STATUS_FLOAT_INEXACT_RESULT                                               NTStatus      = 0xC000008F
+	STATUS_FLOAT_INVALID_OPERATION                                            NTStatus      = 0xC0000090
+	STATUS_FLOAT_OVERFLOW                                                     NTStatus      = 0xC0000091
+	STATUS_FLOAT_STACK_CHECK                                                  NTStatus      = 0xC0000092
+	STATUS_FLOAT_UNDERFLOW                                                    NTStatus      = 0xC0000093
+	STATUS_INTEGER_DIVIDE_BY_ZERO                                             NTStatus      = 0xC0000094
+	STATUS_INTEGER_OVERFLOW                                                   NTStatus      = 0xC0000095
+	STATUS_PRIVILEGED_INSTRUCTION                                             NTStatus      = 0xC0000096
+	STATUS_TOO_MANY_PAGING_FILES                                              NTStatus      = 0xC0000097
+	STATUS_FILE_INVALID                                                       NTStatus      = 0xC0000098
+	STATUS_ALLOTTED_SPACE_EXCEEDED                                            NTStatus      = 0xC0000099
+	STATUS_INSUFFICIENT_RESOURCES                                             NTStatus      = 0xC000009A
+	STATUS_DFS_EXIT_PATH_FOUND                                                NTStatus      = 0xC000009B
+	STATUS_DEVICE_DATA_ERROR                                                  NTStatus      = 0xC000009C
+	STATUS_DEVICE_NOT_CONNECTED                                               NTStatus      = 0xC000009D
+	STATUS_DEVICE_POWER_FAILURE                                               NTStatus      = 0xC000009E
+	STATUS_FREE_VM_NOT_AT_BASE                                                NTStatus      = 0xC000009F
+	STATUS_MEMORY_NOT_ALLOCATED                                               NTStatus      = 0xC00000A0
+	STATUS_WORKING_SET_QUOTA                                                  NTStatus      = 0xC00000A1
+	STATUS_MEDIA_WRITE_PROTECTED                                              NTStatus      = 0xC00000A2
+	STATUS_DEVICE_NOT_READY                                                   NTStatus      = 0xC00000A3
+	STATUS_INVALID_GROUP_ATTRIBUTES                                           NTStatus      = 0xC00000A4
+	STATUS_BAD_IMPERSONATION_LEVEL                                            NTStatus      = 0xC00000A5
+	STATUS_CANT_OPEN_ANONYMOUS                                                NTStatus      = 0xC00000A6
+	STATUS_BAD_VALIDATION_CLASS                                               NTStatus      = 0xC00000A7
+	STATUS_BAD_TOKEN_TYPE                                                     NTStatus      = 0xC00000A8
+	STATUS_BAD_MASTER_BOOT_RECORD                                             NTStatus      = 0xC00000A9
+	STATUS_INSTRUCTION_MISALIGNMENT                                           NTStatus      = 0xC00000AA
+	STATUS_INSTANCE_NOT_AVAILABLE                                             NTStatus      = 0xC00000AB
+	STATUS_PIPE_NOT_AVAILABLE                                                 NTStatus      = 0xC00000AC
+	STATUS_INVALID_PIPE_STATE                                                 NTStatus      = 0xC00000AD
+	STATUS_PIPE_BUSY                                                          NTStatus      = 0xC00000AE
+	STATUS_ILLEGAL_FUNCTION                                                   NTStatus      = 0xC00000AF
+	STATUS_PIPE_DISCONNECTED                                                  NTStatus      = 0xC00000B0
+	STATUS_PIPE_CLOSING                                                       NTStatus      = 0xC00000B1
+	STATUS_PIPE_CONNECTED                                                     NTStatus      = 0xC00000B2
+	STATUS_PIPE_LISTENING                                                     NTStatus      = 0xC00000B3
+	STATUS_INVALID_READ_MODE                                                  NTStatus      = 0xC00000B4
+	STATUS_IO_TIMEOUT                                                         NTStatus      = 0xC00000B5
+	STATUS_FILE_FORCED_CLOSED                                                 NTStatus      = 0xC00000B6
+	STATUS_PROFILING_NOT_STARTED                                              NTStatus      = 0xC00000B7
+	STATUS_PROFILING_NOT_STOPPED                                              NTStatus      = 0xC00000B8
+	STATUS_COULD_NOT_INTERPRET                                                NTStatus      = 0xC00000B9
+	STATUS_FILE_IS_A_DIRECTORY                                                NTStatus      = 0xC00000BA
+	STATUS_NOT_SUPPORTED                                                      NTStatus      = 0xC00000BB
+	STATUS_REMOTE_NOT_LISTENING                                               NTStatus      = 0xC00000BC
+	STATUS_DUPLICATE_NAME                                                     NTStatus      = 0xC00000BD
+	STATUS_BAD_NETWORK_PATH                                                   NTStatus      = 0xC00000BE
+	STATUS_NETWORK_BUSY                                                       NTStatus      = 0xC00000BF
+	STATUS_DEVICE_DOES_NOT_EXIST                                              NTStatus      = 0xC00000C0
+	STATUS_TOO_MANY_COMMANDS                                                  NTStatus      = 0xC00000C1
+	STATUS_ADAPTER_HARDWARE_ERROR                                             NTStatus      = 0xC00000C2
+	STATUS_INVALID_NETWORK_RESPONSE                                           NTStatus      = 0xC00000C3
+	STATUS_UNEXPECTED_NETWORK_ERROR                                           NTStatus      = 0xC00000C4
+	STATUS_BAD_REMOTE_ADAPTER                                                 NTStatus      = 0xC00000C5
+	STATUS_PRINT_QUEUE_FULL                                                   NTStatus      = 0xC00000C6
+	STATUS_NO_SPOOL_SPACE                                                     NTStatus      = 0xC00000C7
+	STATUS_PRINT_CANCELLED                                                    NTStatus      = 0xC00000C8
+	STATUS_NETWORK_NAME_DELETED                                               NTStatus      = 0xC00000C9
+	STATUS_NETWORK_ACCESS_DENIED                                              NTStatus      = 0xC00000CA
+	STATUS_BAD_DEVICE_TYPE                                                    NTStatus      = 0xC00000CB
+	STATUS_BAD_NETWORK_NAME                                                   NTStatus      = 0xC00000CC
+	STATUS_TOO_MANY_NAMES                                                     NTStatus      = 0xC00000CD
+	STATUS_TOO_MANY_SESSIONS                                                  NTStatus      = 0xC00000CE
+	STATUS_SHARING_PAUSED                                                     NTStatus      = 0xC00000CF
+	STATUS_REQUEST_NOT_ACCEPTED                                               NTStatus      = 0xC00000D0
+	STATUS_REDIRECTOR_PAUSED                                                  NTStatus      = 0xC00000D1
+	STATUS_NET_WRITE_FAULT                                                    NTStatus      = 0xC00000D2
+	STATUS_PROFILING_AT_LIMIT                                                 NTStatus      = 0xC00000D3
+	STATUS_NOT_SAME_DEVICE                                                    NTStatus      = 0xC00000D4
+	STATUS_FILE_RENAMED                                                       NTStatus      = 0xC00000D5
+	STATUS_VIRTUAL_CIRCUIT_CLOSED                                             NTStatus      = 0xC00000D6
+	STATUS_NO_SECURITY_ON_OBJECT                                              NTStatus      = 0xC00000D7
+	STATUS_CANT_WAIT                                                          NTStatus      = 0xC00000D8
+	STATUS_PIPE_EMPTY                                                         NTStatus      = 0xC00000D9
+	STATUS_CANT_ACCESS_DOMAIN_INFO                                            NTStatus      = 0xC00000DA
+	STATUS_CANT_TERMINATE_SELF                                                NTStatus      = 0xC00000DB
+	STATUS_INVALID_SERVER_STATE                                               NTStatus      = 0xC00000DC
+	STATUS_INVALID_DOMAIN_STATE                                               NTStatus      = 0xC00000DD
+	STATUS_INVALID_DOMAIN_ROLE                                                NTStatus      = 0xC00000DE
+	STATUS_NO_SUCH_DOMAIN                                                     NTStatus      = 0xC00000DF
+	STATUS_DOMAIN_EXISTS                                                      NTStatus      = 0xC00000E0
+	STATUS_DOMAIN_LIMIT_EXCEEDED                                              NTStatus      = 0xC00000E1
+	STATUS_OPLOCK_NOT_GRANTED                                                 NTStatus      = 0xC00000E2
+	STATUS_INVALID_OPLOCK_PROTOCOL                                            NTStatus      = 0xC00000E3
+	STATUS_INTERNAL_DB_CORRUPTION                                             NTStatus      = 0xC00000E4
+	STATUS_INTERNAL_ERROR                                                     NTStatus      = 0xC00000E5
+	STATUS_GENERIC_NOT_MAPPED                                                 NTStatus      = 0xC00000E6
+	STATUS_BAD_DESCRIPTOR_FORMAT                                              NTStatus      = 0xC00000E7
+	STATUS_INVALID_USER_BUFFER                                                NTStatus      = 0xC00000E8
+	STATUS_UNEXPECTED_IO_ERROR                                                NTStatus      = 0xC00000E9
+	STATUS_UNEXPECTED_MM_CREATE_ERR                                           NTStatus      = 0xC00000EA
+	STATUS_UNEXPECTED_MM_MAP_ERROR                                            NTStatus      = 0xC00000EB
+	STATUS_UNEXPECTED_MM_EXTEND_ERR                                           NTStatus      = 0xC00000EC
+	STATUS_NOT_LOGON_PROCESS                                                  NTStatus      = 0xC00000ED
+	STATUS_LOGON_SESSION_EXISTS                                               NTStatus      = 0xC00000EE
+	STATUS_INVALID_PARAMETER_1                                                NTStatus      = 0xC00000EF
+	STATUS_INVALID_PARAMETER_2                                                NTStatus      = 0xC00000F0
+	STATUS_INVALID_PARAMETER_3                                                NTStatus      = 0xC00000F1
+	STATUS_INVALID_PARAMETER_4                                                NTStatus      = 0xC00000F2
+	STATUS_INVALID_PARAMETER_5                                                NTStatus      = 0xC00000F3
+	STATUS_INVALID_PARAMETER_6                                                NTStatus      = 0xC00000F4
+	STATUS_INVALID_PARAMETER_7                                                NTStatus      = 0xC00000F5
+	STATUS_INVALID_PARAMETER_8                                                NTStatus      = 0xC00000F6
+	STATUS_INVALID_PARAMETER_9                                                NTStatus      = 0xC00000F7
+	STATUS_INVALID_PARAMETER_10                                               NTStatus      = 0xC00000F8
+	STATUS_INVALID_PARAMETER_11                                               NTStatus      = 0xC00000F9
+	STATUS_INVALID_PARAMETER_12                                               NTStatus      = 0xC00000FA
+	STATUS_REDIRECTOR_NOT_STARTED                                             NTStatus      = 0xC00000FB
+	STATUS_REDIRECTOR_STARTED                                                 NTStatus      = 0xC00000FC
+	STATUS_STACK_OVERFLOW                                                     NTStatus      = 0xC00000FD
+	STATUS_NO_SUCH_PACKAGE                                                    NTStatus      = 0xC00000FE
+	STATUS_BAD_FUNCTION_TABLE                                                 NTStatus      = 0xC00000FF
+	STATUS_VARIABLE_NOT_FOUND                                                 NTStatus      = 0xC0000100
+	STATUS_DIRECTORY_NOT_EMPTY                                                NTStatus      = 0xC0000101
+	STATUS_FILE_CORRUPT_ERROR                                                 NTStatus      = 0xC0000102
+	STATUS_NOT_A_DIRECTORY                                                    NTStatus      = 0xC0000103
+	STATUS_BAD_LOGON_SESSION_STATE                                            NTStatus      = 0xC0000104
+	STATUS_LOGON_SESSION_COLLISION                                            NTStatus      = 0xC0000105
+	STATUS_NAME_TOO_LONG                                                      NTStatus      = 0xC0000106
+	STATUS_FILES_OPEN                                                         NTStatus      = 0xC0000107
+	STATUS_CONNECTION_IN_USE                                                  NTStatus      = 0xC0000108
+	STATUS_MESSAGE_NOT_FOUND                                                  NTStatus      = 0xC0000109
+	STATUS_PROCESS_IS_TERMINATING                                             NTStatus      = 0xC000010A
+	STATUS_INVALID_LOGON_TYPE                                                 NTStatus      = 0xC000010B
+	STATUS_NO_GUID_TRANSLATION                                                NTStatus      = 0xC000010C
+	STATUS_CANNOT_IMPERSONATE                                                 NTStatus      = 0xC000010D
+	STATUS_IMAGE_ALREADY_LOADED                                               NTStatus      = 0xC000010E
+	STATUS_ABIOS_NOT_PRESENT                                                  NTStatus      = 0xC000010F
+	STATUS_ABIOS_LID_NOT_EXIST                                                NTStatus      = 0xC0000110
+	STATUS_ABIOS_LID_ALREADY_OWNED                                            NTStatus      = 0xC0000111
+	STATUS_ABIOS_NOT_LID_OWNER                                                NTStatus      = 0xC0000112
+	STATUS_ABIOS_INVALID_COMMAND                                              NTStatus      = 0xC0000113
+	STATUS_ABIOS_INVALID_LID                                                  NTStatus      = 0xC0000114
+	STATUS_ABIOS_SELECTOR_NOT_AVAILABLE                                       NTStatus      = 0xC0000115
+	STATUS_ABIOS_INVALID_SELECTOR                                             NTStatus      = 0xC0000116
+	STATUS_NO_LDT                                                             NTStatus      = 0xC0000117
+	STATUS_INVALID_LDT_SIZE                                                   NTStatus      = 0xC0000118
+	STATUS_INVALID_LDT_OFFSET                                                 NTStatus      = 0xC0000119
+	STATUS_INVALID_LDT_DESCRIPTOR                                             NTStatus      = 0xC000011A
+	STATUS_INVALID_IMAGE_NE_FORMAT                                            NTStatus      = 0xC000011B
+	STATUS_RXACT_INVALID_STATE                                                NTStatus      = 0xC000011C
+	STATUS_RXACT_COMMIT_FAILURE                                               NTStatus      = 0xC000011D
+	STATUS_MAPPED_FILE_SIZE_ZERO                                              NTStatus      = 0xC000011E
+	STATUS_TOO_MANY_OPENED_FILES                                              NTStatus      = 0xC000011F
+	STATUS_CANCELLED                                                          NTStatus      = 0xC0000120
+	STATUS_CANNOT_DELETE                                                      NTStatus      = 0xC0000121
+	STATUS_INVALID_COMPUTER_NAME                                              NTStatus      = 0xC0000122
+	STATUS_FILE_DELETED                                                       NTStatus      = 0xC0000123
+	STATUS_SPECIAL_ACCOUNT                                                    NTStatus      = 0xC0000124
+	STATUS_SPECIAL_GROUP                                                      NTStatus      = 0xC0000125
+	STATUS_SPECIAL_USER                                                       NTStatus      = 0xC0000126
+	STATUS_MEMBERS_PRIMARY_GROUP                                              NTStatus      = 0xC0000127
+	STATUS_FILE_CLOSED                                                        NTStatus      = 0xC0000128
+	STATUS_TOO_MANY_THREADS                                                   NTStatus      = 0xC0000129
+	STATUS_THREAD_NOT_IN_PROCESS                                              NTStatus      = 0xC000012A
+	STATUS_TOKEN_ALREADY_IN_USE                                               NTStatus      = 0xC000012B
+	STATUS_PAGEFILE_QUOTA_EXCEEDED                                            NTStatus      = 0xC000012C
+	STATUS_COMMITMENT_LIMIT                                                   NTStatus      = 0xC000012D
+	STATUS_INVALID_IMAGE_LE_FORMAT                                            NTStatus      = 0xC000012E
+	STATUS_INVALID_IMAGE_NOT_MZ                                               NTStatus      = 0xC000012F
+	STATUS_INVALID_IMAGE_PROTECT                                              NTStatus      = 0xC0000130
+	STATUS_INVALID_IMAGE_WIN_16                                               NTStatus      = 0xC0000131
+	STATUS_LOGON_SERVER_CONFLICT                                              NTStatus      = 0xC0000132
+	STATUS_TIME_DIFFERENCE_AT_DC                                              NTStatus      = 0xC0000133
+	STATUS_SYNCHRONIZATION_REQUIRED                                           NTStatus      = 0xC0000134
+	STATUS_DLL_NOT_FOUND                                                      NTStatus      = 0xC0000135
+	STATUS_OPEN_FAILED                                                        NTStatus      = 0xC0000136
+	STATUS_IO_PRIVILEGE_FAILED                                                NTStatus      = 0xC0000137
+	STATUS_ORDINAL_NOT_FOUND                                                  NTStatus      = 0xC0000138
+	STATUS_ENTRYPOINT_NOT_FOUND                                               NTStatus      = 0xC0000139
+	STATUS_CONTROL_C_EXIT                                                     NTStatus      = 0xC000013A
+	STATUS_LOCAL_DISCONNECT                                                   NTStatus      = 0xC000013B
+	STATUS_REMOTE_DISCONNECT                                                  NTStatus      = 0xC000013C
+	STATUS_REMOTE_RESOURCES                                                   NTStatus      = 0xC000013D
+	STATUS_LINK_FAILED                                                        NTStatus      = 0xC000013E
+	STATUS_LINK_TIMEOUT                                                       NTStatus      = 0xC000013F
+	STATUS_INVALID_CONNECTION                                                 NTStatus      = 0xC0000140
+	STATUS_INVALID_ADDRESS                                                    NTStatus      = 0xC0000141
+	STATUS_DLL_INIT_FAILED                                                    NTStatus      = 0xC0000142
+	STATUS_MISSING_SYSTEMFILE                                                 NTStatus      = 0xC0000143
+	STATUS_UNHANDLED_EXCEPTION                                                NTStatus      = 0xC0000144
+	STATUS_APP_INIT_FAILURE                                                   NTStatus      = 0xC0000145
+	STATUS_PAGEFILE_CREATE_FAILED                                             NTStatus      = 0xC0000146
+	STATUS_NO_PAGEFILE                                                        NTStatus      = 0xC0000147
+	STATUS_INVALID_LEVEL                                                      NTStatus      = 0xC0000148
+	STATUS_WRONG_PASSWORD_CORE                                                NTStatus      = 0xC0000149
+	STATUS_ILLEGAL_FLOAT_CONTEXT                                              NTStatus      = 0xC000014A
+	STATUS_PIPE_BROKEN                                                        NTStatus      = 0xC000014B
+	STATUS_REGISTRY_CORRUPT                                                   NTStatus      = 0xC000014C
+	STATUS_REGISTRY_IO_FAILED                                                 NTStatus      = 0xC000014D
+	STATUS_NO_EVENT_PAIR                                                      NTStatus      = 0xC000014E
+	STATUS_UNRECOGNIZED_VOLUME                                                NTStatus      = 0xC000014F
+	STATUS_SERIAL_NO_DEVICE_INITED                                            NTStatus      = 0xC0000150
+	STATUS_NO_SUCH_ALIAS                                                      NTStatus      = 0xC0000151
+	STATUS_MEMBER_NOT_IN_ALIAS                                                NTStatus      = 0xC0000152
+	STATUS_MEMBER_IN_ALIAS                                                    NTStatus      = 0xC0000153
+	STATUS_ALIAS_EXISTS                                                       NTStatus      = 0xC0000154
+	STATUS_LOGON_NOT_GRANTED                                                  NTStatus      = 0xC0000155
+	STATUS_TOO_MANY_SECRETS                                                   NTStatus      = 0xC0000156
+	STATUS_SECRET_TOO_LONG                                                    NTStatus      = 0xC0000157
+	STATUS_INTERNAL_DB_ERROR                                                  NTStatus      = 0xC0000158
+	STATUS_FULLSCREEN_MODE                                                    NTStatus      = 0xC0000159
+	STATUS_TOO_MANY_CONTEXT_IDS                                               NTStatus      = 0xC000015A
+	STATUS_LOGON_TYPE_NOT_GRANTED                                             NTStatus      = 0xC000015B
+	STATUS_NOT_REGISTRY_FILE                                                  NTStatus      = 0xC000015C
+	STATUS_NT_CROSS_ENCRYPTION_REQUIRED                                       NTStatus      = 0xC000015D
+	STATUS_DOMAIN_CTRLR_CONFIG_ERROR                                          NTStatus      = 0xC000015E
+	STATUS_FT_MISSING_MEMBER                                                  NTStatus      = 0xC000015F
+	STATUS_ILL_FORMED_SERVICE_ENTRY                                           NTStatus      = 0xC0000160
+	STATUS_ILLEGAL_CHARACTER                                                  NTStatus      = 0xC0000161
+	STATUS_UNMAPPABLE_CHARACTER                                               NTStatus      = 0xC0000162
+	STATUS_UNDEFINED_CHARACTER                                                NTStatus      = 0xC0000163
+	STATUS_FLOPPY_VOLUME                                                      NTStatus      = 0xC0000164
+	STATUS_FLOPPY_ID_MARK_NOT_FOUND                                           NTStatus      = 0xC0000165
+	STATUS_FLOPPY_WRONG_CYLINDER                                              NTStatus      = 0xC0000166
+	STATUS_FLOPPY_UNKNOWN_ERROR                                               NTStatus      = 0xC0000167
+	STATUS_FLOPPY_BAD_REGISTERS                                               NTStatus      = 0xC0000168
+	STATUS_DISK_RECALIBRATE_FAILED                                            NTStatus      = 0xC0000169
+	STATUS_DISK_OPERATION_FAILED                                              NTStatus      = 0xC000016A
+	STATUS_DISK_RESET_FAILED                                                  NTStatus      = 0xC000016B
+	STATUS_SHARED_IRQ_BUSY                                                    NTStatus      = 0xC000016C
+	STATUS_FT_ORPHANING                                                       NTStatus      = 0xC000016D
+	STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT                                   NTStatus      = 0xC000016E
+	STATUS_PARTITION_FAILURE                                                  NTStatus      = 0xC0000172
+	STATUS_INVALID_BLOCK_LENGTH                                               NTStatus      = 0xC0000173
+	STATUS_DEVICE_NOT_PARTITIONED                                             NTStatus      = 0xC0000174
+	STATUS_UNABLE_TO_LOCK_MEDIA                                               NTStatus      = 0xC0000175
+	STATUS_UNABLE_TO_UNLOAD_MEDIA                                             NTStatus      = 0xC0000176
+	STATUS_EOM_OVERFLOW                                                       NTStatus      = 0xC0000177
+	STATUS_NO_MEDIA                                                           NTStatus      = 0xC0000178
+	STATUS_NO_SUCH_MEMBER                                                     NTStatus      = 0xC000017A
+	STATUS_INVALID_MEMBER                                                     NTStatus      = 0xC000017B
+	STATUS_KEY_DELETED                                                        NTStatus      = 0xC000017C
+	STATUS_NO_LOG_SPACE                                                       NTStatus      = 0xC000017D
+	STATUS_TOO_MANY_SIDS                                                      NTStatus      = 0xC000017E
+	STATUS_LM_CROSS_ENCRYPTION_REQUIRED                                       NTStatus      = 0xC000017F
+	STATUS_KEY_HAS_CHILDREN                                                   NTStatus      = 0xC0000180
+	STATUS_CHILD_MUST_BE_VOLATILE                                             NTStatus      = 0xC0000181
+	STATUS_DEVICE_CONFIGURATION_ERROR                                         NTStatus      = 0xC0000182
+	STATUS_DRIVER_INTERNAL_ERROR                                              NTStatus      = 0xC0000183
+	STATUS_INVALID_DEVICE_STATE                                               NTStatus      = 0xC0000184
+	STATUS_IO_DEVICE_ERROR                                                    NTStatus      = 0xC0000185
+	STATUS_DEVICE_PROTOCOL_ERROR                                              NTStatus      = 0xC0000186
+	STATUS_BACKUP_CONTROLLER                                                  NTStatus      = 0xC0000187
+	STATUS_LOG_FILE_FULL                                                      NTStatus      = 0xC0000188
+	STATUS_TOO_LATE                                                           NTStatus      = 0xC0000189
+	STATUS_NO_TRUST_LSA_SECRET                                                NTStatus      = 0xC000018A
+	STATUS_NO_TRUST_SAM_ACCOUNT                                               NTStatus      = 0xC000018B
+	STATUS_TRUSTED_DOMAIN_FAILURE                                             NTStatus      = 0xC000018C
+	STATUS_TRUSTED_RELATIONSHIP_FAILURE                                       NTStatus      = 0xC000018D
+	STATUS_EVENTLOG_FILE_CORRUPT                                              NTStatus      = 0xC000018E
+	STATUS_EVENTLOG_CANT_START                                                NTStatus      = 0xC000018F
+	STATUS_TRUST_FAILURE                                                      NTStatus      = 0xC0000190
+	STATUS_MUTANT_LIMIT_EXCEEDED                                              NTStatus      = 0xC0000191
+	STATUS_NETLOGON_NOT_STARTED                                               NTStatus      = 0xC0000192
+	STATUS_ACCOUNT_EXPIRED                                                    NTStatus      = 0xC0000193
+	STATUS_POSSIBLE_DEADLOCK                                                  NTStatus      = 0xC0000194
+	STATUS_NETWORK_CREDENTIAL_CONFLICT                                        NTStatus      = 0xC0000195
+	STATUS_REMOTE_SESSION_LIMIT                                               NTStatus      = 0xC0000196
+	STATUS_EVENTLOG_FILE_CHANGED                                              NTStatus      = 0xC0000197
+	STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT                                  NTStatus      = 0xC0000198
+	STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT                                  NTStatus      = 0xC0000199
+	STATUS_NOLOGON_SERVER_TRUST_ACCOUNT                                       NTStatus      = 0xC000019A
+	STATUS_DOMAIN_TRUST_INCONSISTENT                                          NTStatus      = 0xC000019B
+	STATUS_FS_DRIVER_REQUIRED                                                 NTStatus      = 0xC000019C
+	STATUS_IMAGE_ALREADY_LOADED_AS_DLL                                        NTStatus      = 0xC000019D
+	STATUS_INCOMPATIBLE_WITH_GLOBAL_SHORT_NAME_REGISTRY_SETTING               NTStatus      = 0xC000019E
+	STATUS_SHORT_NAMES_NOT_ENABLED_ON_VOLUME                                  NTStatus      = 0xC000019F
+	STATUS_SECURITY_STREAM_IS_INCONSISTENT                                    NTStatus      = 0xC00001A0
+	STATUS_INVALID_LOCK_RANGE                                                 NTStatus      = 0xC00001A1
+	STATUS_INVALID_ACE_CONDITION                                              NTStatus      = 0xC00001A2
+	STATUS_IMAGE_SUBSYSTEM_NOT_PRESENT                                        NTStatus      = 0xC00001A3
+	STATUS_NOTIFICATION_GUID_ALREADY_DEFINED                                  NTStatus      = 0xC00001A4
+	STATUS_INVALID_EXCEPTION_HANDLER                                          NTStatus      = 0xC00001A5
+	STATUS_DUPLICATE_PRIVILEGES                                               NTStatus      = 0xC00001A6
+	STATUS_NOT_ALLOWED_ON_SYSTEM_FILE                                         NTStatus      = 0xC00001A7
+	STATUS_REPAIR_NEEDED                                                      NTStatus      = 0xC00001A8
+	STATUS_QUOTA_NOT_ENABLED                                                  NTStatus      = 0xC00001A9
+	STATUS_NO_APPLICATION_PACKAGE                                             NTStatus      = 0xC00001AA
+	STATUS_FILE_METADATA_OPTIMIZATION_IN_PROGRESS                             NTStatus      = 0xC00001AB
+	STATUS_NOT_SAME_OBJECT                                                    NTStatus      = 0xC00001AC
+	STATUS_FATAL_MEMORY_EXHAUSTION                                            NTStatus      = 0xC00001AD
+	STATUS_ERROR_PROCESS_NOT_IN_JOB                                           NTStatus      = 0xC00001AE
+	STATUS_CPU_SET_INVALID                                                    NTStatus      = 0xC00001AF
+	STATUS_IO_DEVICE_INVALID_DATA                                             NTStatus      = 0xC00001B0
+	STATUS_IO_UNALIGNED_WRITE                                                 NTStatus      = 0xC00001B1
+	STATUS_NETWORK_OPEN_RESTRICTION                                           NTStatus      = 0xC0000201
+	STATUS_NO_USER_SESSION_KEY                                                NTStatus      = 0xC0000202
+	STATUS_USER_SESSION_DELETED                                               NTStatus      = 0xC0000203
+	STATUS_RESOURCE_LANG_NOT_FOUND                                            NTStatus      = 0xC0000204
+	STATUS_INSUFF_SERVER_RESOURCES                                            NTStatus      = 0xC0000205
+	STATUS_INVALID_BUFFER_SIZE                                                NTStatus      = 0xC0000206
+	STATUS_INVALID_ADDRESS_COMPONENT                                          NTStatus      = 0xC0000207
+	STATUS_INVALID_ADDRESS_WILDCARD                                           NTStatus      = 0xC0000208
+	STATUS_TOO_MANY_ADDRESSES                                                 NTStatus      = 0xC0000209
+	STATUS_ADDRESS_ALREADY_EXISTS                                             NTStatus      = 0xC000020A
+	STATUS_ADDRESS_CLOSED                                                     NTStatus      = 0xC000020B
+	STATUS_CONNECTION_DISCONNECTED                                            NTStatus      = 0xC000020C
+	STATUS_CONNECTION_RESET                                                   NTStatus      = 0xC000020D
+	STATUS_TOO_MANY_NODES                                                     NTStatus      = 0xC000020E
+	STATUS_TRANSACTION_ABORTED                                                NTStatus      = 0xC000020F
+	STATUS_TRANSACTION_TIMED_OUT                                              NTStatus      = 0xC0000210
+	STATUS_TRANSACTION_NO_RELEASE                                             NTStatus      = 0xC0000211
+	STATUS_TRANSACTION_NO_MATCH                                               NTStatus      = 0xC0000212
+	STATUS_TRANSACTION_RESPONDED                                              NTStatus      = 0xC0000213
+	STATUS_TRANSACTION_INVALID_ID                                             NTStatus      = 0xC0000214
+	STATUS_TRANSACTION_INVALID_TYPE                                           NTStatus      = 0xC0000215
+	STATUS_NOT_SERVER_SESSION                                                 NTStatus      = 0xC0000216
+	STATUS_NOT_CLIENT_SESSION                                                 NTStatus      = 0xC0000217
+	STATUS_CANNOT_LOAD_REGISTRY_FILE                                          NTStatus      = 0xC0000218
+	STATUS_DEBUG_ATTACH_FAILED                                                NTStatus      = 0xC0000219
+	STATUS_SYSTEM_PROCESS_TERMINATED                                          NTStatus      = 0xC000021A
+	STATUS_DATA_NOT_ACCEPTED                                                  NTStatus      = 0xC000021B
+	STATUS_NO_BROWSER_SERVERS_FOUND                                           NTStatus      = 0xC000021C
+	STATUS_VDM_HARD_ERROR                                                     NTStatus      = 0xC000021D
+	STATUS_DRIVER_CANCEL_TIMEOUT                                              NTStatus      = 0xC000021E
+	STATUS_REPLY_MESSAGE_MISMATCH                                             NTStatus      = 0xC000021F
+	STATUS_MAPPED_ALIGNMENT                                                   NTStatus      = 0xC0000220
+	STATUS_IMAGE_CHECKSUM_MISMATCH                                            NTStatus      = 0xC0000221
+	STATUS_LOST_WRITEBEHIND_DATA                                              NTStatus      = 0xC0000222
+	STATUS_CLIENT_SERVER_PARAMETERS_INVALID                                   NTStatus      = 0xC0000223
+	STATUS_PASSWORD_MUST_CHANGE                                               NTStatus      = 0xC0000224
+	STATUS_NOT_FOUND                                                          NTStatus      = 0xC0000225
+	STATUS_NOT_TINY_STREAM                                                    NTStatus      = 0xC0000226
+	STATUS_RECOVERY_FAILURE                                                   NTStatus      = 0xC0000227
+	STATUS_STACK_OVERFLOW_READ                                                NTStatus      = 0xC0000228
+	STATUS_FAIL_CHECK                                                         NTStatus      = 0xC0000229
+	STATUS_DUPLICATE_OBJECTID                                                 NTStatus      = 0xC000022A
+	STATUS_OBJECTID_EXISTS                                                    NTStatus      = 0xC000022B
+	STATUS_CONVERT_TO_LARGE                                                   NTStatus      = 0xC000022C
+	STATUS_RETRY                                                              NTStatus      = 0xC000022D
+	STATUS_FOUND_OUT_OF_SCOPE                                                 NTStatus      = 0xC000022E
+	STATUS_ALLOCATE_BUCKET                                                    NTStatus      = 0xC000022F
+	STATUS_PROPSET_NOT_FOUND                                                  NTStatus      = 0xC0000230
+	STATUS_MARSHALL_OVERFLOW                                                  NTStatus      = 0xC0000231
+	STATUS_INVALID_VARIANT                                                    NTStatus      = 0xC0000232
+	STATUS_DOMAIN_CONTROLLER_NOT_FOUND                                        NTStatus      = 0xC0000233
+	STATUS_ACCOUNT_LOCKED_OUT                                                 NTStatus      = 0xC0000234
+	STATUS_HANDLE_NOT_CLOSABLE                                                NTStatus      = 0xC0000235
+	STATUS_CONNECTION_REFUSED                                                 NTStatus      = 0xC0000236
+	STATUS_GRACEFUL_DISCONNECT                                                NTStatus      = 0xC0000237
+	STATUS_ADDRESS_ALREADY_ASSOCIATED                                         NTStatus      = 0xC0000238
+	STATUS_ADDRESS_NOT_ASSOCIATED                                             NTStatus      = 0xC0000239
+	STATUS_CONNECTION_INVALID                                                 NTStatus      = 0xC000023A
+	STATUS_CONNECTION_ACTIVE                                                  NTStatus      = 0xC000023B
+	STATUS_NETWORK_UNREACHABLE                                                NTStatus      = 0xC000023C
+	STATUS_HOST_UNREACHABLE                                                   NTStatus      = 0xC000023D
+	STATUS_PROTOCOL_UNREACHABLE                                               NTStatus      = 0xC000023E
+	STATUS_PORT_UNREACHABLE                                                   NTStatus      = 0xC000023F
+	STATUS_REQUEST_ABORTED                                                    NTStatus      = 0xC0000240
+	STATUS_CONNECTION_ABORTED                                                 NTStatus      = 0xC0000241
+	STATUS_BAD_COMPRESSION_BUFFER                                             NTStatus      = 0xC0000242
+	STATUS_USER_MAPPED_FILE                                                   NTStatus      = 0xC0000243
+	STATUS_AUDIT_FAILED                                                       NTStatus      = 0xC0000244
+	STATUS_TIMER_RESOLUTION_NOT_SET                                           NTStatus      = 0xC0000245
+	STATUS_CONNECTION_COUNT_LIMIT                                             NTStatus      = 0xC0000246
+	STATUS_LOGIN_TIME_RESTRICTION                                             NTStatus      = 0xC0000247
+	STATUS_LOGIN_WKSTA_RESTRICTION                                            NTStatus      = 0xC0000248
+	STATUS_IMAGE_MP_UP_MISMATCH                                               NTStatus      = 0xC0000249
+	STATUS_INSUFFICIENT_LOGON_INFO                                            NTStatus      = 0xC0000250
+	STATUS_BAD_DLL_ENTRYPOINT                                                 NTStatus      = 0xC0000251
+	STATUS_BAD_SERVICE_ENTRYPOINT                                             NTStatus      = 0xC0000252
+	STATUS_LPC_REPLY_LOST                                                     NTStatus      = 0xC0000253
+	STATUS_IP_ADDRESS_CONFLICT1                                               NTStatus      = 0xC0000254
+	STATUS_IP_ADDRESS_CONFLICT2                                               NTStatus      = 0xC0000255
+	STATUS_REGISTRY_QUOTA_LIMIT                                               NTStatus      = 0xC0000256
+	STATUS_PATH_NOT_COVERED                                                   NTStatus      = 0xC0000257
+	STATUS_NO_CALLBACK_ACTIVE                                                 NTStatus      = 0xC0000258
+	STATUS_LICENSE_QUOTA_EXCEEDED                                             NTStatus      = 0xC0000259
+	STATUS_PWD_TOO_SHORT                                                      NTStatus      = 0xC000025A
+	STATUS_PWD_TOO_RECENT                                                     NTStatus      = 0xC000025B
+	STATUS_PWD_HISTORY_CONFLICT                                               NTStatus      = 0xC000025C
+	STATUS_PLUGPLAY_NO_DEVICE                                                 NTStatus      = 0xC000025E
+	STATUS_UNSUPPORTED_COMPRESSION                                            NTStatus      = 0xC000025F
+	STATUS_INVALID_HW_PROFILE                                                 NTStatus      = 0xC0000260
+	STATUS_INVALID_PLUGPLAY_DEVICE_PATH                                       NTStatus      = 0xC0000261
+	STATUS_DRIVER_ORDINAL_NOT_FOUND                                           NTStatus      = 0xC0000262
+	STATUS_DRIVER_ENTRYPOINT_NOT_FOUND                                        NTStatus      = 0xC0000263
+	STATUS_RESOURCE_NOT_OWNED                                                 NTStatus      = 0xC0000264
+	STATUS_TOO_MANY_LINKS                                                     NTStatus      = 0xC0000265
+	STATUS_QUOTA_LIST_INCONSISTENT                                            NTStatus      = 0xC0000266
+	STATUS_FILE_IS_OFFLINE                                                    NTStatus      = 0xC0000267
+	STATUS_EVALUATION_EXPIRATION                                              NTStatus      = 0xC0000268
+	STATUS_ILLEGAL_DLL_RELOCATION                                             NTStatus      = 0xC0000269
+	STATUS_LICENSE_VIOLATION                                                  NTStatus      = 0xC000026A
+	STATUS_DLL_INIT_FAILED_LOGOFF                                             NTStatus      = 0xC000026B
+	STATUS_DRIVER_UNABLE_TO_LOAD                                              NTStatus      = 0xC000026C
+	STATUS_DFS_UNAVAILABLE                                                    NTStatus      = 0xC000026D
+	STATUS_VOLUME_DISMOUNTED                                                  NTStatus      = 0xC000026E
+	STATUS_WX86_INTERNAL_ERROR                                                NTStatus      = 0xC000026F
+	STATUS_WX86_FLOAT_STACK_CHECK                                             NTStatus      = 0xC0000270
+	STATUS_VALIDATE_CONTINUE                                                  NTStatus      = 0xC0000271
+	STATUS_NO_MATCH                                                           NTStatus      = 0xC0000272
+	STATUS_NO_MORE_MATCHES                                                    NTStatus      = 0xC0000273
+	STATUS_NOT_A_REPARSE_POINT                                                NTStatus      = 0xC0000275
+	STATUS_IO_REPARSE_TAG_INVALID                                             NTStatus      = 0xC0000276
+	STATUS_IO_REPARSE_TAG_MISMATCH                                            NTStatus      = 0xC0000277
+	STATUS_IO_REPARSE_DATA_INVALID                                            NTStatus      = 0xC0000278
+	STATUS_IO_REPARSE_TAG_NOT_HANDLED                                         NTStatus      = 0xC0000279
+	STATUS_PWD_TOO_LONG                                                       NTStatus      = 0xC000027A
+	STATUS_STOWED_EXCEPTION                                                   NTStatus      = 0xC000027B
+	STATUS_CONTEXT_STOWED_EXCEPTION                                           NTStatus      = 0xC000027C
+	STATUS_REPARSE_POINT_NOT_RESOLVED                                         NTStatus      = 0xC0000280
+	STATUS_DIRECTORY_IS_A_REPARSE_POINT                                       NTStatus      = 0xC0000281
+	STATUS_RANGE_LIST_CONFLICT                                                NTStatus      = 0xC0000282
+	STATUS_SOURCE_ELEMENT_EMPTY                                               NTStatus      = 0xC0000283
+	STATUS_DESTINATION_ELEMENT_FULL                                           NTStatus      = 0xC0000284
+	STATUS_ILLEGAL_ELEMENT_ADDRESS                                            NTStatus      = 0xC0000285
+	STATUS_MAGAZINE_NOT_PRESENT                                               NTStatus      = 0xC0000286
+	STATUS_REINITIALIZATION_NEEDED                                            NTStatus      = 0xC0000287
+	STATUS_DEVICE_REQUIRES_CLEANING                                           NTStatus      = 0x80000288
+	STATUS_DEVICE_DOOR_OPEN                                                   NTStatus      = 0x80000289
+	STATUS_ENCRYPTION_FAILED                                                  NTStatus      = 0xC000028A
+	STATUS_DECRYPTION_FAILED                                                  NTStatus      = 0xC000028B
+	STATUS_RANGE_NOT_FOUND                                                    NTStatus      = 0xC000028C
+	STATUS_NO_RECOVERY_POLICY                                                 NTStatus      = 0xC000028D
+	STATUS_NO_EFS                                                             NTStatus      = 0xC000028E
+	STATUS_WRONG_EFS                                                          NTStatus      = 0xC000028F
+	STATUS_NO_USER_KEYS                                                       NTStatus      = 0xC0000290
+	STATUS_FILE_NOT_ENCRYPTED                                                 NTStatus      = 0xC0000291
+	STATUS_NOT_EXPORT_FORMAT                                                  NTStatus      = 0xC0000292
+	STATUS_FILE_ENCRYPTED                                                     NTStatus      = 0xC0000293
+	STATUS_WAKE_SYSTEM                                                        NTStatus      = 0x40000294
+	STATUS_WMI_GUID_NOT_FOUND                                                 NTStatus      = 0xC0000295
+	STATUS_WMI_INSTANCE_NOT_FOUND                                             NTStatus      = 0xC0000296
+	STATUS_WMI_ITEMID_NOT_FOUND                                               NTStatus      = 0xC0000297
+	STATUS_WMI_TRY_AGAIN                                                      NTStatus      = 0xC0000298
+	STATUS_SHARED_POLICY                                                      NTStatus      = 0xC0000299
+	STATUS_POLICY_OBJECT_NOT_FOUND                                            NTStatus      = 0xC000029A
+	STATUS_POLICY_ONLY_IN_DS                                                  NTStatus      = 0xC000029B
+	STATUS_VOLUME_NOT_UPGRADED                                                NTStatus      = 0xC000029C
+	STATUS_REMOTE_STORAGE_NOT_ACTIVE                                          NTStatus      = 0xC000029D
+	STATUS_REMOTE_STORAGE_MEDIA_ERROR                                         NTStatus      = 0xC000029E
+	STATUS_NO_TRACKING_SERVICE                                                NTStatus      = 0xC000029F
+	STATUS_SERVER_SID_MISMATCH                                                NTStatus      = 0xC00002A0
+	STATUS_DS_NO_ATTRIBUTE_OR_VALUE                                           NTStatus      = 0xC00002A1
+	STATUS_DS_INVALID_ATTRIBUTE_SYNTAX                                        NTStatus      = 0xC00002A2
+	STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED                                        NTStatus      = 0xC00002A3
+	STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS                                       NTStatus      = 0xC00002A4
+	STATUS_DS_BUSY                                                            NTStatus      = 0xC00002A5
+	STATUS_DS_UNAVAILABLE                                                     NTStatus      = 0xC00002A6
+	STATUS_DS_NO_RIDS_ALLOCATED                                               NTStatus      = 0xC00002A7
+	STATUS_DS_NO_MORE_RIDS                                                    NTStatus      = 0xC00002A8
+	STATUS_DS_INCORRECT_ROLE_OWNER                                            NTStatus      = 0xC00002A9
+	STATUS_DS_RIDMGR_INIT_ERROR                                               NTStatus      = 0xC00002AA
+	STATUS_DS_OBJ_CLASS_VIOLATION                                             NTStatus      = 0xC00002AB
+	STATUS_DS_CANT_ON_NON_LEAF                                                NTStatus      = 0xC00002AC
+	STATUS_DS_CANT_ON_RDN                                                     NTStatus      = 0xC00002AD
+	STATUS_DS_CANT_MOD_OBJ_CLASS                                              NTStatus      = 0xC00002AE
+	STATUS_DS_CROSS_DOM_MOVE_FAILED                                           NTStatus      = 0xC00002AF
+	STATUS_DS_GC_NOT_AVAILABLE                                                NTStatus      = 0xC00002B0
+	STATUS_DIRECTORY_SERVICE_REQUIRED                                         NTStatus      = 0xC00002B1
+	STATUS_REPARSE_ATTRIBUTE_CONFLICT                                         NTStatus      = 0xC00002B2
+	STATUS_CANT_ENABLE_DENY_ONLY                                              NTStatus      = 0xC00002B3
+	STATUS_FLOAT_MULTIPLE_FAULTS                                              NTStatus      = 0xC00002B4
+	STATUS_FLOAT_MULTIPLE_TRAPS                                               NTStatus      = 0xC00002B5
+	STATUS_DEVICE_REMOVED                                                     NTStatus      = 0xC00002B6
+	STATUS_JOURNAL_DELETE_IN_PROGRESS                                         NTStatus      = 0xC00002B7
+	STATUS_JOURNAL_NOT_ACTIVE                                                 NTStatus      = 0xC00002B8
+	STATUS_NOINTERFACE                                                        NTStatus      = 0xC00002B9
+	STATUS_DS_RIDMGR_DISABLED                                                 NTStatus      = 0xC00002BA
+	STATUS_DS_ADMIN_LIMIT_EXCEEDED                                            NTStatus      = 0xC00002C1
+	STATUS_DRIVER_FAILED_SLEEP                                                NTStatus      = 0xC00002C2
+	STATUS_MUTUAL_AUTHENTICATION_FAILED                                       NTStatus      = 0xC00002C3
+	STATUS_CORRUPT_SYSTEM_FILE                                                NTStatus      = 0xC00002C4
+	STATUS_DATATYPE_MISALIGNMENT_ERROR                                        NTStatus      = 0xC00002C5
+	STATUS_WMI_READ_ONLY                                                      NTStatus      = 0xC00002C6
+	STATUS_WMI_SET_FAILURE                                                    NTStatus      = 0xC00002C7
+	STATUS_COMMITMENT_MINIMUM                                                 NTStatus      = 0xC00002C8
+	STATUS_REG_NAT_CONSUMPTION                                                NTStatus      = 0xC00002C9
+	STATUS_TRANSPORT_FULL                                                     NTStatus      = 0xC00002CA
+	STATUS_DS_SAM_INIT_FAILURE                                                NTStatus      = 0xC00002CB
+	STATUS_ONLY_IF_CONNECTED                                                  NTStatus      = 0xC00002CC
+	STATUS_DS_SENSITIVE_GROUP_VIOLATION                                       NTStatus      = 0xC00002CD
+	STATUS_PNP_RESTART_ENUMERATION                                            NTStatus      = 0xC00002CE
+	STATUS_JOURNAL_ENTRY_DELETED                                              NTStatus      = 0xC00002CF
+	STATUS_DS_CANT_MOD_PRIMARYGROUPID                                         NTStatus      = 0xC00002D0
+	STATUS_SYSTEM_IMAGE_BAD_SIGNATURE                                         NTStatus      = 0xC00002D1
+	STATUS_PNP_REBOOT_REQUIRED                                                NTStatus      = 0xC00002D2
+	STATUS_POWER_STATE_INVALID                                                NTStatus      = 0xC00002D3
+	STATUS_DS_INVALID_GROUP_TYPE                                              NTStatus      = 0xC00002D4
+	STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN                              NTStatus      = 0xC00002D5
+	STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN                               NTStatus      = 0xC00002D6
+	STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER                                   NTStatus      = 0xC00002D7
+	STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER                               NTStatus      = 0xC00002D8
+	STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER                                NTStatus      = 0xC00002D9
+	STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER                             NTStatus      = 0xC00002DA
+	STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER                        NTStatus      = 0xC00002DB
+	STATUS_DS_HAVE_PRIMARY_MEMBERS                                            NTStatus      = 0xC00002DC
+	STATUS_WMI_NOT_SUPPORTED                                                  NTStatus      = 0xC00002DD
+	STATUS_INSUFFICIENT_POWER                                                 NTStatus      = 0xC00002DE
+	STATUS_SAM_NEED_BOOTKEY_PASSWORD                                          NTStatus      = 0xC00002DF
+	STATUS_SAM_NEED_BOOTKEY_FLOPPY                                            NTStatus      = 0xC00002E0
+	STATUS_DS_CANT_START                                                      NTStatus      = 0xC00002E1
+	STATUS_DS_INIT_FAILURE                                                    NTStatus      = 0xC00002E2
+	STATUS_SAM_INIT_FAILURE                                                   NTStatus      = 0xC00002E3
+	STATUS_DS_GC_REQUIRED                                                     NTStatus      = 0xC00002E4
+	STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY                                      NTStatus      = 0xC00002E5
+	STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS                                      NTStatus      = 0xC00002E6
+	STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED                                  NTStatus      = 0xC00002E7
+	STATUS_MULTIPLE_FAULT_VIOLATION                                           NTStatus      = 0xC00002E8
+	STATUS_CURRENT_DOMAIN_NOT_ALLOWED                                         NTStatus      = 0xC00002E9
+	STATUS_CANNOT_MAKE                                                        NTStatus      = 0xC00002EA
+	STATUS_SYSTEM_SHUTDOWN                                                    NTStatus      = 0xC00002EB
+	STATUS_DS_INIT_FAILURE_CONSOLE                                            NTStatus      = 0xC00002EC
+	STATUS_DS_SAM_INIT_FAILURE_CONSOLE                                        NTStatus      = 0xC00002ED
+	STATUS_UNFINISHED_CONTEXT_DELETED                                         NTStatus      = 0xC00002EE
+	STATUS_NO_TGT_REPLY                                                       NTStatus      = 0xC00002EF
+	STATUS_OBJECTID_NOT_FOUND                                                 NTStatus      = 0xC00002F0
+	STATUS_NO_IP_ADDRESSES                                                    NTStatus      = 0xC00002F1
+	STATUS_WRONG_CREDENTIAL_HANDLE                                            NTStatus      = 0xC00002F2
+	STATUS_CRYPTO_SYSTEM_INVALID                                              NTStatus      = 0xC00002F3
+	STATUS_MAX_REFERRALS_EXCEEDED                                             NTStatus      = 0xC00002F4
+	STATUS_MUST_BE_KDC                                                        NTStatus      = 0xC00002F5
+	STATUS_STRONG_CRYPTO_NOT_SUPPORTED                                        NTStatus      = 0xC00002F6
+	STATUS_TOO_MANY_PRINCIPALS                                                NTStatus      = 0xC00002F7
+	STATUS_NO_PA_DATA                                                         NTStatus      = 0xC00002F8
+	STATUS_PKINIT_NAME_MISMATCH                                               NTStatus      = 0xC00002F9
+	STATUS_SMARTCARD_LOGON_REQUIRED                                           NTStatus      = 0xC00002FA
+	STATUS_KDC_INVALID_REQUEST                                                NTStatus      = 0xC00002FB
+	STATUS_KDC_UNABLE_TO_REFER                                                NTStatus      = 0xC00002FC
+	STATUS_KDC_UNKNOWN_ETYPE                                                  NTStatus      = 0xC00002FD
+	STATUS_SHUTDOWN_IN_PROGRESS                                               NTStatus      = 0xC00002FE
+	STATUS_SERVER_SHUTDOWN_IN_PROGRESS                                        NTStatus      = 0xC00002FF
+	STATUS_NOT_SUPPORTED_ON_SBS                                               NTStatus      = 0xC0000300
+	STATUS_WMI_GUID_DISCONNECTED                                              NTStatus      = 0xC0000301
+	STATUS_WMI_ALREADY_DISABLED                                               NTStatus      = 0xC0000302
+	STATUS_WMI_ALREADY_ENABLED                                                NTStatus      = 0xC0000303
+	STATUS_MFT_TOO_FRAGMENTED                                                 NTStatus      = 0xC0000304
+	STATUS_COPY_PROTECTION_FAILURE                                            NTStatus      = 0xC0000305
+	STATUS_CSS_AUTHENTICATION_FAILURE                                         NTStatus      = 0xC0000306
+	STATUS_CSS_KEY_NOT_PRESENT                                                NTStatus      = 0xC0000307
+	STATUS_CSS_KEY_NOT_ESTABLISHED                                            NTStatus      = 0xC0000308
+	STATUS_CSS_SCRAMBLED_SECTOR                                               NTStatus      = 0xC0000309
+	STATUS_CSS_REGION_MISMATCH                                                NTStatus      = 0xC000030A
+	STATUS_CSS_RESETS_EXHAUSTED                                               NTStatus      = 0xC000030B
+	STATUS_PASSWORD_CHANGE_REQUIRED                                           NTStatus      = 0xC000030C
+	STATUS_LOST_MODE_LOGON_RESTRICTION                                        NTStatus      = 0xC000030D
+	STATUS_PKINIT_FAILURE                                                     NTStatus      = 0xC0000320
+	STATUS_SMARTCARD_SUBSYSTEM_FAILURE                                        NTStatus      = 0xC0000321
+	STATUS_NO_KERB_KEY                                                        NTStatus      = 0xC0000322
+	STATUS_HOST_DOWN                                                          NTStatus      = 0xC0000350
+	STATUS_UNSUPPORTED_PREAUTH                                                NTStatus      = 0xC0000351
+	STATUS_EFS_ALG_BLOB_TOO_BIG                                               NTStatus      = 0xC0000352
+	STATUS_PORT_NOT_SET                                                       NTStatus      = 0xC0000353
+	STATUS_DEBUGGER_INACTIVE                                                  NTStatus      = 0xC0000354
+	STATUS_DS_VERSION_CHECK_FAILURE                                           NTStatus      = 0xC0000355
+	STATUS_AUDITING_DISABLED                                                  NTStatus      = 0xC0000356
+	STATUS_PRENT4_MACHINE_ACCOUNT                                             NTStatus      = 0xC0000357
+	STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER                                   NTStatus      = 0xC0000358
+	STATUS_INVALID_IMAGE_WIN_32                                               NTStatus      = 0xC0000359
+	STATUS_INVALID_IMAGE_WIN_64                                               NTStatus      = 0xC000035A
+	STATUS_BAD_BINDINGS                                                       NTStatus      = 0xC000035B
+	STATUS_NETWORK_SESSION_EXPIRED                                            NTStatus      = 0xC000035C
+	STATUS_APPHELP_BLOCK                                                      NTStatus      = 0xC000035D
+	STATUS_ALL_SIDS_FILTERED                                                  NTStatus      = 0xC000035E
+	STATUS_NOT_SAFE_MODE_DRIVER                                               NTStatus      = 0xC000035F
+	STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT                                  NTStatus      = 0xC0000361
+	STATUS_ACCESS_DISABLED_BY_POLICY_PATH                                     NTStatus      = 0xC0000362
+	STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER                                NTStatus      = 0xC0000363
+	STATUS_ACCESS_DISABLED_BY_POLICY_OTHER                                    NTStatus      = 0xC0000364
+	STATUS_FAILED_DRIVER_ENTRY                                                NTStatus      = 0xC0000365
+	STATUS_DEVICE_ENUMERATION_ERROR                                           NTStatus      = 0xC0000366
+	STATUS_MOUNT_POINT_NOT_RESOLVED                                           NTStatus      = 0xC0000368
+	STATUS_INVALID_DEVICE_OBJECT_PARAMETER                                    NTStatus      = 0xC0000369
+	STATUS_MCA_OCCURED                                                        NTStatus      = 0xC000036A
+	STATUS_DRIVER_BLOCKED_CRITICAL                                            NTStatus      = 0xC000036B
+	STATUS_DRIVER_BLOCKED                                                     NTStatus      = 0xC000036C
+	STATUS_DRIVER_DATABASE_ERROR                                              NTStatus      = 0xC000036D
+	STATUS_SYSTEM_HIVE_TOO_LARGE                                              NTStatus      = 0xC000036E
+	STATUS_INVALID_IMPORT_OF_NON_DLL                                          NTStatus      = 0xC000036F
+	STATUS_DS_SHUTTING_DOWN                                                   NTStatus      = 0x40000370
+	STATUS_NO_SECRETS                                                         NTStatus      = 0xC0000371
+	STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY                              NTStatus      = 0xC0000372
+	STATUS_FAILED_STACK_SWITCH                                                NTStatus      = 0xC0000373
+	STATUS_HEAP_CORRUPTION                                                    NTStatus      = 0xC0000374
+	STATUS_SMARTCARD_WRONG_PIN                                                NTStatus      = 0xC0000380
+	STATUS_SMARTCARD_CARD_BLOCKED                                             NTStatus      = 0xC0000381
+	STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED                                   NTStatus      = 0xC0000382
+	STATUS_SMARTCARD_NO_CARD                                                  NTStatus      = 0xC0000383
+	STATUS_SMARTCARD_NO_KEY_CONTAINER                                         NTStatus      = 0xC0000384
+	STATUS_SMARTCARD_NO_CERTIFICATE                                           NTStatus      = 0xC0000385
+	STATUS_SMARTCARD_NO_KEYSET                                                NTStatus      = 0xC0000386
+	STATUS_SMARTCARD_IO_ERROR                                                 NTStatus      = 0xC0000387
+	STATUS_DOWNGRADE_DETECTED                                                 NTStatus      = 0xC0000388
+	STATUS_SMARTCARD_CERT_REVOKED                                             NTStatus      = 0xC0000389
+	STATUS_ISSUING_CA_UNTRUSTED                                               NTStatus      = 0xC000038A
+	STATUS_REVOCATION_OFFLINE_C                                               NTStatus      = 0xC000038B
+	STATUS_PKINIT_CLIENT_FAILURE                                              NTStatus      = 0xC000038C
+	STATUS_SMARTCARD_CERT_EXPIRED                                             NTStatus      = 0xC000038D
+	STATUS_DRIVER_FAILED_PRIOR_UNLOAD                                         NTStatus      = 0xC000038E
+	STATUS_SMARTCARD_SILENT_CONTEXT                                           NTStatus      = 0xC000038F
+	STATUS_PER_USER_TRUST_QUOTA_EXCEEDED                                      NTStatus      = 0xC0000401
+	STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED                                      NTStatus      = 0xC0000402
+	STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED                                   NTStatus      = 0xC0000403
+	STATUS_DS_NAME_NOT_UNIQUE                                                 NTStatus      = 0xC0000404
+	STATUS_DS_DUPLICATE_ID_FOUND                                              NTStatus      = 0xC0000405
+	STATUS_DS_GROUP_CONVERSION_ERROR                                          NTStatus      = 0xC0000406
+	STATUS_VOLSNAP_PREPARE_HIBERNATE                                          NTStatus      = 0xC0000407
+	STATUS_USER2USER_REQUIRED                                                 NTStatus      = 0xC0000408
+	STATUS_STACK_BUFFER_OVERRUN                                               NTStatus      = 0xC0000409
+	STATUS_NO_S4U_PROT_SUPPORT                                                NTStatus      = 0xC000040A
+	STATUS_CROSSREALM_DELEGATION_FAILURE                                      NTStatus      = 0xC000040B
+	STATUS_REVOCATION_OFFLINE_KDC                                             NTStatus      = 0xC000040C
+	STATUS_ISSUING_CA_UNTRUSTED_KDC                                           NTStatus      = 0xC000040D
+	STATUS_KDC_CERT_EXPIRED                                                   NTStatus      = 0xC000040E
+	STATUS_KDC_CERT_REVOKED                                                   NTStatus      = 0xC000040F
+	STATUS_PARAMETER_QUOTA_EXCEEDED                                           NTStatus      = 0xC0000410
+	STATUS_HIBERNATION_FAILURE                                                NTStatus      = 0xC0000411
+	STATUS_DELAY_LOAD_FAILED                                                  NTStatus      = 0xC0000412
+	STATUS_AUTHENTICATION_FIREWALL_FAILED                                     NTStatus      = 0xC0000413
+	STATUS_VDM_DISALLOWED                                                     NTStatus      = 0xC0000414
+	STATUS_HUNG_DISPLAY_DRIVER_THREAD                                         NTStatus      = 0xC0000415
+	STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE            NTStatus      = 0xC0000416
+	STATUS_INVALID_CRUNTIME_PARAMETER                                         NTStatus      = 0xC0000417
+	STATUS_NTLM_BLOCKED                                                       NTStatus      = 0xC0000418
+	STATUS_DS_SRC_SID_EXISTS_IN_FOREST                                        NTStatus      = 0xC0000419
+	STATUS_DS_DOMAIN_NAME_EXISTS_IN_FOREST                                    NTStatus      = 0xC000041A
+	STATUS_DS_FLAT_NAME_EXISTS_IN_FOREST                                      NTStatus      = 0xC000041B
+	STATUS_INVALID_USER_PRINCIPAL_NAME                                        NTStatus      = 0xC000041C
+	STATUS_FATAL_USER_CALLBACK_EXCEPTION                                      NTStatus      = 0xC000041D
+	STATUS_ASSERTION_FAILURE                                                  NTStatus      = 0xC0000420
+	STATUS_VERIFIER_STOP                                                      NTStatus      = 0xC0000421
+	STATUS_CALLBACK_POP_STACK                                                 NTStatus      = 0xC0000423
+	STATUS_INCOMPATIBLE_DRIVER_BLOCKED                                        NTStatus      = 0xC0000424
+	STATUS_HIVE_UNLOADED                                                      NTStatus      = 0xC0000425
+	STATUS_COMPRESSION_DISABLED                                               NTStatus      = 0xC0000426
+	STATUS_FILE_SYSTEM_LIMITATION                                             NTStatus      = 0xC0000427
+	STATUS_INVALID_IMAGE_HASH                                                 NTStatus      = 0xC0000428
+	STATUS_NOT_CAPABLE                                                        NTStatus      = 0xC0000429
+	STATUS_REQUEST_OUT_OF_SEQUENCE                                            NTStatus      = 0xC000042A
+	STATUS_IMPLEMENTATION_LIMIT                                               NTStatus      = 0xC000042B
+	STATUS_ELEVATION_REQUIRED                                                 NTStatus      = 0xC000042C
+	STATUS_NO_SECURITY_CONTEXT                                                NTStatus      = 0xC000042D
+	STATUS_PKU2U_CERT_FAILURE                                                 NTStatus      = 0xC000042F
+	STATUS_BEYOND_VDL                                                         NTStatus      = 0xC0000432
+	STATUS_ENCOUNTERED_WRITE_IN_PROGRESS                                      NTStatus      = 0xC0000433
+	STATUS_PTE_CHANGED                                                        NTStatus      = 0xC0000434
+	STATUS_PURGE_FAILED                                                       NTStatus      = 0xC0000435
+	STATUS_CRED_REQUIRES_CONFIRMATION                                         NTStatus      = 0xC0000440
+	STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE                              NTStatus      = 0xC0000441
+	STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER                                   NTStatus      = 0xC0000442
+	STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE                              NTStatus      = 0xC0000443
+	STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE                                   NTStatus      = 0xC0000444
+	STATUS_CS_ENCRYPTION_FILE_NOT_CSE                                         NTStatus      = 0xC0000445
+	STATUS_INVALID_LABEL                                                      NTStatus      = 0xC0000446
+	STATUS_DRIVER_PROCESS_TERMINATED                                          NTStatus      = 0xC0000450
+	STATUS_AMBIGUOUS_SYSTEM_DEVICE                                            NTStatus      = 0xC0000451
+	STATUS_SYSTEM_DEVICE_NOT_FOUND                                            NTStatus      = 0xC0000452
+	STATUS_RESTART_BOOT_APPLICATION                                           NTStatus      = 0xC0000453
+	STATUS_INSUFFICIENT_NVRAM_RESOURCES                                       NTStatus      = 0xC0000454
+	STATUS_INVALID_SESSION                                                    NTStatus      = 0xC0000455
+	STATUS_THREAD_ALREADY_IN_SESSION                                          NTStatus      = 0xC0000456
+	STATUS_THREAD_NOT_IN_SESSION                                              NTStatus      = 0xC0000457
+	STATUS_INVALID_WEIGHT                                                     NTStatus      = 0xC0000458
+	STATUS_REQUEST_PAUSED                                                     NTStatus      = 0xC0000459
+	STATUS_NO_RANGES_PROCESSED                                                NTStatus      = 0xC0000460
+	STATUS_DISK_RESOURCES_EXHAUSTED                                           NTStatus      = 0xC0000461
+	STATUS_NEEDS_REMEDIATION                                                  NTStatus      = 0xC0000462
+	STATUS_DEVICE_FEATURE_NOT_SUPPORTED                                       NTStatus      = 0xC0000463
+	STATUS_DEVICE_UNREACHABLE                                                 NTStatus      = 0xC0000464
+	STATUS_INVALID_TOKEN                                                      NTStatus      = 0xC0000465
+	STATUS_SERVER_UNAVAILABLE                                                 NTStatus      = 0xC0000466
+	STATUS_FILE_NOT_AVAILABLE                                                 NTStatus      = 0xC0000467
+	STATUS_DEVICE_INSUFFICIENT_RESOURCES                                      NTStatus      = 0xC0000468
+	STATUS_PACKAGE_UPDATING                                                   NTStatus      = 0xC0000469
+	STATUS_NOT_READ_FROM_COPY                                                 NTStatus      = 0xC000046A
+	STATUS_FT_WRITE_FAILURE                                                   NTStatus      = 0xC000046B
+	STATUS_FT_DI_SCAN_REQUIRED                                                NTStatus      = 0xC000046C
+	STATUS_OBJECT_NOT_EXTERNALLY_BACKED                                       NTStatus      = 0xC000046D
+	STATUS_EXTERNAL_BACKING_PROVIDER_UNKNOWN                                  NTStatus      = 0xC000046E
+	STATUS_COMPRESSION_NOT_BENEFICIAL                                         NTStatus      = 0xC000046F
+	STATUS_DATA_CHECKSUM_ERROR                                                NTStatus      = 0xC0000470
+	STATUS_INTERMIXED_KERNEL_EA_OPERATION                                     NTStatus      = 0xC0000471
+	STATUS_TRIM_READ_ZERO_NOT_SUPPORTED                                       NTStatus      = 0xC0000472
+	STATUS_TOO_MANY_SEGMENT_DESCRIPTORS                                       NTStatus      = 0xC0000473
+	STATUS_INVALID_OFFSET_ALIGNMENT                                           NTStatus      = 0xC0000474
+	STATUS_INVALID_FIELD_IN_PARAMETER_LIST                                    NTStatus      = 0xC0000475
+	STATUS_OPERATION_IN_PROGRESS                                              NTStatus      = 0xC0000476
+	STATUS_INVALID_INITIATOR_TARGET_PATH                                      NTStatus      = 0xC0000477
+	STATUS_SCRUB_DATA_DISABLED                                                NTStatus      = 0xC0000478
+	STATUS_NOT_REDUNDANT_STORAGE                                              NTStatus      = 0xC0000479
+	STATUS_RESIDENT_FILE_NOT_SUPPORTED                                        NTStatus      = 0xC000047A
+	STATUS_COMPRESSED_FILE_NOT_SUPPORTED                                      NTStatus      = 0xC000047B
+	STATUS_DIRECTORY_NOT_SUPPORTED                                            NTStatus      = 0xC000047C
+	STATUS_IO_OPERATION_TIMEOUT                                               NTStatus      = 0xC000047D
+	STATUS_SYSTEM_NEEDS_REMEDIATION                                           NTStatus      = 0xC000047E
+	STATUS_APPX_INTEGRITY_FAILURE_CLR_NGEN                                    NTStatus      = 0xC000047F
+	STATUS_SHARE_UNAVAILABLE                                                  NTStatus      = 0xC0000480
+	STATUS_APISET_NOT_HOSTED                                                  NTStatus      = 0xC0000481
+	STATUS_APISET_NOT_PRESENT                                                 NTStatus      = 0xC0000482
+	STATUS_DEVICE_HARDWARE_ERROR                                              NTStatus      = 0xC0000483
+	STATUS_FIRMWARE_SLOT_INVALID                                              NTStatus      = 0xC0000484
+	STATUS_FIRMWARE_IMAGE_INVALID                                             NTStatus      = 0xC0000485
+	STATUS_STORAGE_TOPOLOGY_ID_MISMATCH                                       NTStatus      = 0xC0000486
+	STATUS_WIM_NOT_BOOTABLE                                                   NTStatus      = 0xC0000487
+	STATUS_BLOCKED_BY_PARENTAL_CONTROLS                                       NTStatus      = 0xC0000488
+	STATUS_NEEDS_REGISTRATION                                                 NTStatus      = 0xC0000489
+	STATUS_QUOTA_ACTIVITY                                                     NTStatus      = 0xC000048A
+	STATUS_CALLBACK_INVOKE_INLINE                                             NTStatus      = 0xC000048B
+	STATUS_BLOCK_TOO_MANY_REFERENCES                                          NTStatus      = 0xC000048C
+	STATUS_MARKED_TO_DISALLOW_WRITES                                          NTStatus      = 0xC000048D
+	STATUS_NETWORK_ACCESS_DENIED_EDP                                          NTStatus      = 0xC000048E
+	STATUS_ENCLAVE_FAILURE                                                    NTStatus      = 0xC000048F
+	STATUS_PNP_NO_COMPAT_DRIVERS                                              NTStatus      = 0xC0000490
+	STATUS_PNP_DRIVER_PACKAGE_NOT_FOUND                                       NTStatus      = 0xC0000491
+	STATUS_PNP_DRIVER_CONFIGURATION_NOT_FOUND                                 NTStatus      = 0xC0000492
+	STATUS_PNP_DRIVER_CONFIGURATION_INCOMPLETE                                NTStatus      = 0xC0000493
+	STATUS_PNP_FUNCTION_DRIVER_REQUIRED                                       NTStatus      = 0xC0000494
+	STATUS_PNP_DEVICE_CONFIGURATION_PENDING                                   NTStatus      = 0xC0000495
+	STATUS_DEVICE_HINT_NAME_BUFFER_TOO_SMALL                                  NTStatus      = 0xC0000496
+	STATUS_PACKAGE_NOT_AVAILABLE                                              NTStatus      = 0xC0000497
+	STATUS_DEVICE_IN_MAINTENANCE                                              NTStatus      = 0xC0000499
+	STATUS_NOT_SUPPORTED_ON_DAX                                               NTStatus      = 0xC000049A
+	STATUS_FREE_SPACE_TOO_FRAGMENTED                                          NTStatus      = 0xC000049B
+	STATUS_DAX_MAPPING_EXISTS                                                 NTStatus      = 0xC000049C
+	STATUS_CHILD_PROCESS_BLOCKED                                              NTStatus      = 0xC000049D
+	STATUS_STORAGE_LOST_DATA_PERSISTENCE                                      NTStatus      = 0xC000049E
+	STATUS_VRF_CFG_ENABLED                                                    NTStatus      = 0xC000049F
+	STATUS_PARTITION_TERMINATING                                              NTStatus      = 0xC00004A0
+	STATUS_EXTERNAL_SYSKEY_NOT_SUPPORTED                                      NTStatus      = 0xC00004A1
+	STATUS_ENCLAVE_VIOLATION                                                  NTStatus      = 0xC00004A2
+	STATUS_FILE_PROTECTED_UNDER_DPL                                           NTStatus      = 0xC00004A3
+	STATUS_VOLUME_NOT_CLUSTER_ALIGNED                                         NTStatus      = 0xC00004A4
+	STATUS_NO_PHYSICALLY_ALIGNED_FREE_SPACE_FOUND                             NTStatus      = 0xC00004A5
+	STATUS_APPX_FILE_NOT_ENCRYPTED                                            NTStatus      = 0xC00004A6
+	STATUS_RWRAW_ENCRYPTED_FILE_NOT_ENCRYPTED                                 NTStatus      = 0xC00004A7
+	STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILEOFFSET                       NTStatus      = 0xC00004A8
+	STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILERANGE                        NTStatus      = 0xC00004A9
+	STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_PARAMETER                        NTStatus      = 0xC00004AA
+	STATUS_FT_READ_FAILURE                                                    NTStatus      = 0xC00004AB
+	STATUS_PATCH_CONFLICT                                                     NTStatus      = 0xC00004AC
+	STATUS_STORAGE_RESERVE_ID_INVALID                                         NTStatus      = 0xC00004AD
+	STATUS_STORAGE_RESERVE_DOES_NOT_EXIST                                     NTStatus      = 0xC00004AE
+	STATUS_STORAGE_RESERVE_ALREADY_EXISTS                                     NTStatus      = 0xC00004AF
+	STATUS_STORAGE_RESERVE_NOT_EMPTY                                          NTStatus      = 0xC00004B0
+	STATUS_NOT_A_DAX_VOLUME                                                   NTStatus      = 0xC00004B1
+	STATUS_NOT_DAX_MAPPABLE                                                   NTStatus      = 0xC00004B2
+	STATUS_CASE_DIFFERING_NAMES_IN_DIR                                        NTStatus      = 0xC00004B3
+	STATUS_FILE_NOT_SUPPORTED                                                 NTStatus      = 0xC00004B4
+	STATUS_NOT_SUPPORTED_WITH_BTT                                             NTStatus      = 0xC00004B5
+	STATUS_ENCRYPTION_DISABLED                                                NTStatus      = 0xC00004B6
+	STATUS_ENCRYPTING_METADATA_DISALLOWED                                     NTStatus      = 0xC00004B7
+	STATUS_CANT_CLEAR_ENCRYPTION_FLAG                                         NTStatus      = 0xC00004B8
+	STATUS_INVALID_TASK_NAME                                                  NTStatus      = 0xC0000500
+	STATUS_INVALID_TASK_INDEX                                                 NTStatus      = 0xC0000501
+	STATUS_THREAD_ALREADY_IN_TASK                                             NTStatus      = 0xC0000502
+	STATUS_CALLBACK_BYPASS                                                    NTStatus      = 0xC0000503
+	STATUS_UNDEFINED_SCOPE                                                    NTStatus      = 0xC0000504
+	STATUS_INVALID_CAP                                                        NTStatus      = 0xC0000505
+	STATUS_NOT_GUI_PROCESS                                                    NTStatus      = 0xC0000506
+	STATUS_DEVICE_HUNG                                                        NTStatus      = 0xC0000507
+	STATUS_CONTAINER_ASSIGNED                                                 NTStatus      = 0xC0000508
+	STATUS_JOB_NO_CONTAINER                                                   NTStatus      = 0xC0000509
+	STATUS_DEVICE_UNRESPONSIVE                                                NTStatus      = 0xC000050A
+	STATUS_REPARSE_POINT_ENCOUNTERED                                          NTStatus      = 0xC000050B
+	STATUS_ATTRIBUTE_NOT_PRESENT                                              NTStatus      = 0xC000050C
+	STATUS_NOT_A_TIERED_VOLUME                                                NTStatus      = 0xC000050D
+	STATUS_ALREADY_HAS_STREAM_ID                                              NTStatus      = 0xC000050E
+	STATUS_JOB_NOT_EMPTY                                                      NTStatus      = 0xC000050F
+	STATUS_ALREADY_INITIALIZED                                                NTStatus      = 0xC0000510
+	STATUS_ENCLAVE_NOT_TERMINATED                                             NTStatus      = 0xC0000511
+	STATUS_ENCLAVE_IS_TERMINATING                                             NTStatus      = 0xC0000512
+	STATUS_SMB1_NOT_AVAILABLE                                                 NTStatus      = 0xC0000513
+	STATUS_SMR_GARBAGE_COLLECTION_REQUIRED                                    NTStatus      = 0xC0000514
+	STATUS_INTERRUPTED                                                        NTStatus      = 0xC0000515
+	STATUS_THREAD_NOT_RUNNING                                                 NTStatus      = 0xC0000516
+	STATUS_FAIL_FAST_EXCEPTION                                                NTStatus      = 0xC0000602
+	STATUS_IMAGE_CERT_REVOKED                                                 NTStatus      = 0xC0000603
+	STATUS_DYNAMIC_CODE_BLOCKED                                               NTStatus      = 0xC0000604
+	STATUS_IMAGE_CERT_EXPIRED                                                 NTStatus      = 0xC0000605
+	STATUS_STRICT_CFG_VIOLATION                                               NTStatus      = 0xC0000606
+	STATUS_SET_CONTEXT_DENIED                                                 NTStatus      = 0xC000060A
+	STATUS_CROSS_PARTITION_VIOLATION                                          NTStatus      = 0xC000060B
+	STATUS_PORT_CLOSED                                                        NTStatus      = 0xC0000700
+	STATUS_MESSAGE_LOST                                                       NTStatus      = 0xC0000701
+	STATUS_INVALID_MESSAGE                                                    NTStatus      = 0xC0000702
+	STATUS_REQUEST_CANCELED                                                   NTStatus      = 0xC0000703
+	STATUS_RECURSIVE_DISPATCH                                                 NTStatus      = 0xC0000704
+	STATUS_LPC_RECEIVE_BUFFER_EXPECTED                                        NTStatus      = 0xC0000705
+	STATUS_LPC_INVALID_CONNECTION_USAGE                                       NTStatus      = 0xC0000706
+	STATUS_LPC_REQUESTS_NOT_ALLOWED                                           NTStatus      = 0xC0000707
+	STATUS_RESOURCE_IN_USE                                                    NTStatus      = 0xC0000708
+	STATUS_HARDWARE_MEMORY_ERROR                                              NTStatus      = 0xC0000709
+	STATUS_THREADPOOL_HANDLE_EXCEPTION                                        NTStatus      = 0xC000070A
+	STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED                          NTStatus      = 0xC000070B
+	STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED                  NTStatus      = 0xC000070C
+	STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED                      NTStatus      = 0xC000070D
+	STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED                       NTStatus      = 0xC000070E
+	STATUS_THREADPOOL_RELEASED_DURING_OPERATION                               NTStatus      = 0xC000070F
+	STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING                              NTStatus      = 0xC0000710
+	STATUS_APC_RETURNED_WHILE_IMPERSONATING                                   NTStatus      = 0xC0000711
+	STATUS_PROCESS_IS_PROTECTED                                               NTStatus      = 0xC0000712
+	STATUS_MCA_EXCEPTION                                                      NTStatus      = 0xC0000713
+	STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE                                     NTStatus      = 0xC0000714
+	STATUS_SYMLINK_CLASS_DISABLED                                             NTStatus      = 0xC0000715
+	STATUS_INVALID_IDN_NORMALIZATION                                          NTStatus      = 0xC0000716
+	STATUS_NO_UNICODE_TRANSLATION                                             NTStatus      = 0xC0000717
+	STATUS_ALREADY_REGISTERED                                                 NTStatus      = 0xC0000718
+	STATUS_CONTEXT_MISMATCH                                                   NTStatus      = 0xC0000719
+	STATUS_PORT_ALREADY_HAS_COMPLETION_LIST                                   NTStatus      = 0xC000071A
+	STATUS_CALLBACK_RETURNED_THREAD_PRIORITY                                  NTStatus      = 0xC000071B
+	STATUS_INVALID_THREAD                                                     NTStatus      = 0xC000071C
+	STATUS_CALLBACK_RETURNED_TRANSACTION                                      NTStatus      = 0xC000071D
+	STATUS_CALLBACK_RETURNED_LDR_LOCK                                         NTStatus      = 0xC000071E
+	STATUS_CALLBACK_RETURNED_LANG                                             NTStatus      = 0xC000071F
+	STATUS_CALLBACK_RETURNED_PRI_BACK                                         NTStatus      = 0xC0000720
+	STATUS_CALLBACK_RETURNED_THREAD_AFFINITY                                  NTStatus      = 0xC0000721
+	STATUS_LPC_HANDLE_COUNT_EXCEEDED                                          NTStatus      = 0xC0000722
+	STATUS_EXECUTABLE_MEMORY_WRITE                                            NTStatus      = 0xC0000723
+	STATUS_KERNEL_EXECUTABLE_MEMORY_WRITE                                     NTStatus      = 0xC0000724
+	STATUS_ATTACHED_EXECUTABLE_MEMORY_WRITE                                   NTStatus      = 0xC0000725
+	STATUS_TRIGGERED_EXECUTABLE_MEMORY_WRITE                                  NTStatus      = 0xC0000726
+	STATUS_DISK_REPAIR_DISABLED                                               NTStatus      = 0xC0000800
+	STATUS_DS_DOMAIN_RENAME_IN_PROGRESS                                       NTStatus      = 0xC0000801
+	STATUS_DISK_QUOTA_EXCEEDED                                                NTStatus      = 0xC0000802
+	STATUS_DATA_LOST_REPAIR                                                   NTStatus      = 0x80000803
+	STATUS_CONTENT_BLOCKED                                                    NTStatus      = 0xC0000804
+	STATUS_BAD_CLUSTERS                                                       NTStatus      = 0xC0000805
+	STATUS_VOLUME_DIRTY                                                       NTStatus      = 0xC0000806
+	STATUS_DISK_REPAIR_REDIRECTED                                             NTStatus      = 0x40000807
+	STATUS_DISK_REPAIR_UNSUCCESSFUL                                           NTStatus      = 0xC0000808
+	STATUS_CORRUPT_LOG_OVERFULL                                               NTStatus      = 0xC0000809
+	STATUS_CORRUPT_LOG_CORRUPTED                                              NTStatus      = 0xC000080A
+	STATUS_CORRUPT_LOG_UNAVAILABLE                                            NTStatus      = 0xC000080B
+	STATUS_CORRUPT_LOG_DELETED_FULL                                           NTStatus      = 0xC000080C
+	STATUS_CORRUPT_LOG_CLEARED                                                NTStatus      = 0xC000080D
+	STATUS_ORPHAN_NAME_EXHAUSTED                                              NTStatus      = 0xC000080E
+	STATUS_PROACTIVE_SCAN_IN_PROGRESS                                         NTStatus      = 0xC000080F
+	STATUS_ENCRYPTED_IO_NOT_POSSIBLE                                          NTStatus      = 0xC0000810
+	STATUS_CORRUPT_LOG_UPLEVEL_RECORDS                                        NTStatus      = 0xC0000811
+	STATUS_FILE_CHECKED_OUT                                                   NTStatus      = 0xC0000901
+	STATUS_CHECKOUT_REQUIRED                                                  NTStatus      = 0xC0000902
+	STATUS_BAD_FILE_TYPE                                                      NTStatus      = 0xC0000903
+	STATUS_FILE_TOO_LARGE                                                     NTStatus      = 0xC0000904
+	STATUS_FORMS_AUTH_REQUIRED                                                NTStatus      = 0xC0000905
+	STATUS_VIRUS_INFECTED                                                     NTStatus      = 0xC0000906
+	STATUS_VIRUS_DELETED                                                      NTStatus      = 0xC0000907
+	STATUS_BAD_MCFG_TABLE                                                     NTStatus      = 0xC0000908
+	STATUS_CANNOT_BREAK_OPLOCK                                                NTStatus      = 0xC0000909
+	STATUS_BAD_KEY                                                            NTStatus      = 0xC000090A
+	STATUS_BAD_DATA                                                           NTStatus      = 0xC000090B
+	STATUS_NO_KEY                                                             NTStatus      = 0xC000090C
+	STATUS_FILE_HANDLE_REVOKED                                                NTStatus      = 0xC0000910
+	STATUS_WOW_ASSERTION                                                      NTStatus      = 0xC0009898
+	STATUS_INVALID_SIGNATURE                                                  NTStatus      = 0xC000A000
+	STATUS_HMAC_NOT_SUPPORTED                                                 NTStatus      = 0xC000A001
+	STATUS_AUTH_TAG_MISMATCH                                                  NTStatus      = 0xC000A002
+	STATUS_INVALID_STATE_TRANSITION                                           NTStatus      = 0xC000A003
+	STATUS_INVALID_KERNEL_INFO_VERSION                                        NTStatus      = 0xC000A004
+	STATUS_INVALID_PEP_INFO_VERSION                                           NTStatus      = 0xC000A005
+	STATUS_HANDLE_REVOKED                                                     NTStatus      = 0xC000A006
+	STATUS_EOF_ON_GHOSTED_RANGE                                               NTStatus      = 0xC000A007
+	STATUS_IPSEC_QUEUE_OVERFLOW                                               NTStatus      = 0xC000A010
+	STATUS_ND_QUEUE_OVERFLOW                                                  NTStatus      = 0xC000A011
+	STATUS_HOPLIMIT_EXCEEDED                                                  NTStatus      = 0xC000A012
+	STATUS_PROTOCOL_NOT_SUPPORTED                                             NTStatus      = 0xC000A013
+	STATUS_FASTPATH_REJECTED                                                  NTStatus      = 0xC000A014
+	STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED                         NTStatus      = 0xC000A080
+	STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR                         NTStatus      = 0xC000A081
+	STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR                             NTStatus      = 0xC000A082
+	STATUS_XML_PARSE_ERROR                                                    NTStatus      = 0xC000A083
+	STATUS_XMLDSIG_ERROR                                                      NTStatus      = 0xC000A084
+	STATUS_WRONG_COMPARTMENT                                                  NTStatus      = 0xC000A085
+	STATUS_AUTHIP_FAILURE                                                     NTStatus      = 0xC000A086
+	STATUS_DS_OID_MAPPED_GROUP_CANT_HAVE_MEMBERS                              NTStatus      = 0xC000A087
+	STATUS_DS_OID_NOT_FOUND                                                   NTStatus      = 0xC000A088
+	STATUS_INCORRECT_ACCOUNT_TYPE                                             NTStatus      = 0xC000A089
+	STATUS_HASH_NOT_SUPPORTED                                                 NTStatus      = 0xC000A100
+	STATUS_HASH_NOT_PRESENT                                                   NTStatus      = 0xC000A101
+	STATUS_SECONDARY_IC_PROVIDER_NOT_REGISTERED                               NTStatus      = 0xC000A121
+	STATUS_GPIO_CLIENT_INFORMATION_INVALID                                    NTStatus      = 0xC000A122
+	STATUS_GPIO_VERSION_NOT_SUPPORTED                                         NTStatus      = 0xC000A123
+	STATUS_GPIO_INVALID_REGISTRATION_PACKET                                   NTStatus      = 0xC000A124
+	STATUS_GPIO_OPERATION_DENIED                                              NTStatus      = 0xC000A125
+	STATUS_GPIO_INCOMPATIBLE_CONNECT_MODE                                     NTStatus      = 0xC000A126
+	STATUS_GPIO_INTERRUPT_ALREADY_UNMASKED                                    NTStatus      = 0x8000A127
+	STATUS_CANNOT_SWITCH_RUNLEVEL                                             NTStatus      = 0xC000A141
+	STATUS_INVALID_RUNLEVEL_SETTING                                           NTStatus      = 0xC000A142
+	STATUS_RUNLEVEL_SWITCH_TIMEOUT                                            NTStatus      = 0xC000A143
+	STATUS_SERVICES_FAILED_AUTOSTART                                          NTStatus      = 0x4000A144
+	STATUS_RUNLEVEL_SWITCH_AGENT_TIMEOUT                                      NTStatus      = 0xC000A145
+	STATUS_RUNLEVEL_SWITCH_IN_PROGRESS                                        NTStatus      = 0xC000A146
+	STATUS_NOT_APPCONTAINER                                                   NTStatus      = 0xC000A200
+	STATUS_NOT_SUPPORTED_IN_APPCONTAINER                                      NTStatus      = 0xC000A201
+	STATUS_INVALID_PACKAGE_SID_LENGTH                                         NTStatus      = 0xC000A202
+	STATUS_LPAC_ACCESS_DENIED                                                 NTStatus      = 0xC000A203
+	STATUS_ADMINLESS_ACCESS_DENIED                                            NTStatus      = 0xC000A204
+	STATUS_APP_DATA_NOT_FOUND                                                 NTStatus      = 0xC000A281
+	STATUS_APP_DATA_EXPIRED                                                   NTStatus      = 0xC000A282
+	STATUS_APP_DATA_CORRUPT                                                   NTStatus      = 0xC000A283
+	STATUS_APP_DATA_LIMIT_EXCEEDED                                            NTStatus      = 0xC000A284
+	STATUS_APP_DATA_REBOOT_REQUIRED                                           NTStatus      = 0xC000A285
+	STATUS_OFFLOAD_READ_FLT_NOT_SUPPORTED                                     NTStatus      = 0xC000A2A1
+	STATUS_OFFLOAD_WRITE_FLT_NOT_SUPPORTED                                    NTStatus      = 0xC000A2A2
+	STATUS_OFFLOAD_READ_FILE_NOT_SUPPORTED                                    NTStatus      = 0xC000A2A3
+	STATUS_OFFLOAD_WRITE_FILE_NOT_SUPPORTED                                   NTStatus      = 0xC000A2A4
+	STATUS_WOF_WIM_HEADER_CORRUPT                                             NTStatus      = 0xC000A2A5
+	STATUS_WOF_WIM_RESOURCE_TABLE_CORRUPT                                     NTStatus      = 0xC000A2A6
+	STATUS_WOF_FILE_RESOURCE_TABLE_CORRUPT                                    NTStatus      = 0xC000A2A7
+	STATUS_FILE_SYSTEM_VIRTUALIZATION_UNAVAILABLE                             NTStatus      = 0xC000CE01
+	STATUS_FILE_SYSTEM_VIRTUALIZATION_METADATA_CORRUPT                        NTStatus      = 0xC000CE02
+	STATUS_FILE_SYSTEM_VIRTUALIZATION_BUSY                                    NTStatus      = 0xC000CE03
+	STATUS_FILE_SYSTEM_VIRTUALIZATION_PROVIDER_UNKNOWN                        NTStatus      = 0xC000CE04
+	STATUS_FILE_SYSTEM_VIRTUALIZATION_INVALID_OPERATION                       NTStatus      = 0xC000CE05
+	STATUS_CLOUD_FILE_SYNC_ROOT_METADATA_CORRUPT                              NTStatus      = 0xC000CF00
+	STATUS_CLOUD_FILE_PROVIDER_NOT_RUNNING                                    NTStatus      = 0xC000CF01
+	STATUS_CLOUD_FILE_METADATA_CORRUPT                                        NTStatus      = 0xC000CF02
+	STATUS_CLOUD_FILE_METADATA_TOO_LARGE                                      NTStatus      = 0xC000CF03
+	STATUS_CLOUD_FILE_PROPERTY_BLOB_TOO_LARGE                                 NTStatus      = 0x8000CF04
+	STATUS_CLOUD_FILE_TOO_MANY_PROPERTY_BLOBS                                 NTStatus      = 0x8000CF05
+	STATUS_CLOUD_FILE_PROPERTY_VERSION_NOT_SUPPORTED                          NTStatus      = 0xC000CF06
+	STATUS_NOT_A_CLOUD_FILE                                                   NTStatus      = 0xC000CF07
+	STATUS_CLOUD_FILE_NOT_IN_SYNC                                             NTStatus      = 0xC000CF08
+	STATUS_CLOUD_FILE_ALREADY_CONNECTED                                       NTStatus      = 0xC000CF09
+	STATUS_CLOUD_FILE_NOT_SUPPORTED                                           NTStatus      = 0xC000CF0A
+	STATUS_CLOUD_FILE_INVALID_REQUEST                                         NTStatus      = 0xC000CF0B
+	STATUS_CLOUD_FILE_READ_ONLY_VOLUME                                        NTStatus      = 0xC000CF0C
+	STATUS_CLOUD_FILE_CONNECTED_PROVIDER_ONLY                                 NTStatus      = 0xC000CF0D
+	STATUS_CLOUD_FILE_VALIDATION_FAILED                                       NTStatus      = 0xC000CF0E
+	STATUS_CLOUD_FILE_AUTHENTICATION_FAILED                                   NTStatus      = 0xC000CF0F
+	STATUS_CLOUD_FILE_INSUFFICIENT_RESOURCES                                  NTStatus      = 0xC000CF10
+	STATUS_CLOUD_FILE_NETWORK_UNAVAILABLE                                     NTStatus      = 0xC000CF11
+	STATUS_CLOUD_FILE_UNSUCCESSFUL                                            NTStatus      = 0xC000CF12
+	STATUS_CLOUD_FILE_NOT_UNDER_SYNC_ROOT                                     NTStatus      = 0xC000CF13
+	STATUS_CLOUD_FILE_IN_USE                                                  NTStatus      = 0xC000CF14
+	STATUS_CLOUD_FILE_PINNED                                                  NTStatus      = 0xC000CF15
+	STATUS_CLOUD_FILE_REQUEST_ABORTED                                         NTStatus      = 0xC000CF16
+	STATUS_CLOUD_FILE_PROPERTY_CORRUPT                                        NTStatus      = 0xC000CF17
+	STATUS_CLOUD_FILE_ACCESS_DENIED                                           NTStatus      = 0xC000CF18
+	STATUS_CLOUD_FILE_INCOMPATIBLE_HARDLINKS                                  NTStatus      = 0xC000CF19
+	STATUS_CLOUD_FILE_PROPERTY_LOCK_CONFLICT                                  NTStatus      = 0xC000CF1A
+	STATUS_CLOUD_FILE_REQUEST_CANCELED                                        NTStatus      = 0xC000CF1B
+	STATUS_CLOUD_FILE_PROVIDER_TERMINATED                                     NTStatus      = 0xC000CF1D
+	STATUS_NOT_A_CLOUD_SYNC_ROOT                                              NTStatus      = 0xC000CF1E
+	STATUS_CLOUD_FILE_REQUEST_TIMEOUT                                         NTStatus      = 0xC000CF1F
+	STATUS_ACPI_INVALID_OPCODE                                                NTStatus      = 0xC0140001
+	STATUS_ACPI_STACK_OVERFLOW                                                NTStatus      = 0xC0140002
+	STATUS_ACPI_ASSERT_FAILED                                                 NTStatus      = 0xC0140003
+	STATUS_ACPI_INVALID_INDEX                                                 NTStatus      = 0xC0140004
+	STATUS_ACPI_INVALID_ARGUMENT                                              NTStatus      = 0xC0140005
+	STATUS_ACPI_FATAL                                                         NTStatus      = 0xC0140006
+	STATUS_ACPI_INVALID_SUPERNAME                                             NTStatus      = 0xC0140007
+	STATUS_ACPI_INVALID_ARGTYPE                                               NTStatus      = 0xC0140008
+	STATUS_ACPI_INVALID_OBJTYPE                                               NTStatus      = 0xC0140009
+	STATUS_ACPI_INVALID_TARGETTYPE                                            NTStatus      = 0xC014000A
+	STATUS_ACPI_INCORRECT_ARGUMENT_COUNT                                      NTStatus      = 0xC014000B
+	STATUS_ACPI_ADDRESS_NOT_MAPPED                                            NTStatus      = 0xC014000C
+	STATUS_ACPI_INVALID_EVENTTYPE                                             NTStatus      = 0xC014000D
+	STATUS_ACPI_HANDLER_COLLISION                                             NTStatus      = 0xC014000E
+	STATUS_ACPI_INVALID_DATA                                                  NTStatus      = 0xC014000F
+	STATUS_ACPI_INVALID_REGION                                                NTStatus      = 0xC0140010
+	STATUS_ACPI_INVALID_ACCESS_SIZE                                           NTStatus      = 0xC0140011
+	STATUS_ACPI_ACQUIRE_GLOBAL_LOCK                                           NTStatus      = 0xC0140012
+	STATUS_ACPI_ALREADY_INITIALIZED                                           NTStatus      = 0xC0140013
+	STATUS_ACPI_NOT_INITIALIZED                                               NTStatus      = 0xC0140014
+	STATUS_ACPI_INVALID_MUTEX_LEVEL                                           NTStatus      = 0xC0140015
+	STATUS_ACPI_MUTEX_NOT_OWNED                                               NTStatus      = 0xC0140016
+	STATUS_ACPI_MUTEX_NOT_OWNER                                               NTStatus      = 0xC0140017
+	STATUS_ACPI_RS_ACCESS                                                     NTStatus      = 0xC0140018
+	STATUS_ACPI_INVALID_TABLE                                                 NTStatus      = 0xC0140019
+	STATUS_ACPI_REG_HANDLER_FAILED                                            NTStatus      = 0xC0140020
+	STATUS_ACPI_POWER_REQUEST_FAILED                                          NTStatus      = 0xC0140021
+	STATUS_CTX_WINSTATION_NAME_INVALID                                        NTStatus      = 0xC00A0001
+	STATUS_CTX_INVALID_PD                                                     NTStatus      = 0xC00A0002
+	STATUS_CTX_PD_NOT_FOUND                                                   NTStatus      = 0xC00A0003
+	STATUS_CTX_CDM_CONNECT                                                    NTStatus      = 0x400A0004
+	STATUS_CTX_CDM_DISCONNECT                                                 NTStatus      = 0x400A0005
+	STATUS_CTX_CLOSE_PENDING                                                  NTStatus      = 0xC00A0006
+	STATUS_CTX_NO_OUTBUF                                                      NTStatus      = 0xC00A0007
+	STATUS_CTX_MODEM_INF_NOT_FOUND                                            NTStatus      = 0xC00A0008
+	STATUS_CTX_INVALID_MODEMNAME                                              NTStatus      = 0xC00A0009
+	STATUS_CTX_RESPONSE_ERROR                                                 NTStatus      = 0xC00A000A
+	STATUS_CTX_MODEM_RESPONSE_TIMEOUT                                         NTStatus      = 0xC00A000B
+	STATUS_CTX_MODEM_RESPONSE_NO_CARRIER                                      NTStatus      = 0xC00A000C
+	STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE                                     NTStatus      = 0xC00A000D
+	STATUS_CTX_MODEM_RESPONSE_BUSY                                            NTStatus      = 0xC00A000E
+	STATUS_CTX_MODEM_RESPONSE_VOICE                                           NTStatus      = 0xC00A000F
+	STATUS_CTX_TD_ERROR                                                       NTStatus      = 0xC00A0010
+	STATUS_CTX_LICENSE_CLIENT_INVALID                                         NTStatus      = 0xC00A0012
+	STATUS_CTX_LICENSE_NOT_AVAILABLE                                          NTStatus      = 0xC00A0013
+	STATUS_CTX_LICENSE_EXPIRED                                                NTStatus      = 0xC00A0014
+	STATUS_CTX_WINSTATION_NOT_FOUND                                           NTStatus      = 0xC00A0015
+	STATUS_CTX_WINSTATION_NAME_COLLISION                                      NTStatus      = 0xC00A0016
+	STATUS_CTX_WINSTATION_BUSY                                                NTStatus      = 0xC00A0017
+	STATUS_CTX_BAD_VIDEO_MODE                                                 NTStatus      = 0xC00A0018
+	STATUS_CTX_GRAPHICS_INVALID                                               NTStatus      = 0xC00A0022
+	STATUS_CTX_NOT_CONSOLE                                                    NTStatus      = 0xC00A0024
+	STATUS_CTX_CLIENT_QUERY_TIMEOUT                                           NTStatus      = 0xC00A0026
+	STATUS_CTX_CONSOLE_DISCONNECT                                             NTStatus      = 0xC00A0027
+	STATUS_CTX_CONSOLE_CONNECT                                                NTStatus      = 0xC00A0028
+	STATUS_CTX_SHADOW_DENIED                                                  NTStatus      = 0xC00A002A
+	STATUS_CTX_WINSTATION_ACCESS_DENIED                                       NTStatus      = 0xC00A002B
+	STATUS_CTX_INVALID_WD                                                     NTStatus      = 0xC00A002E
+	STATUS_CTX_WD_NOT_FOUND                                                   NTStatus      = 0xC00A002F
+	STATUS_CTX_SHADOW_INVALID                                                 NTStatus      = 0xC00A0030
+	STATUS_CTX_SHADOW_DISABLED                                                NTStatus      = 0xC00A0031
+	STATUS_RDP_PROTOCOL_ERROR                                                 NTStatus      = 0xC00A0032
+	STATUS_CTX_CLIENT_LICENSE_NOT_SET                                         NTStatus      = 0xC00A0033
+	STATUS_CTX_CLIENT_LICENSE_IN_USE                                          NTStatus      = 0xC00A0034
+	STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE                                    NTStatus      = 0xC00A0035
+	STATUS_CTX_SHADOW_NOT_RUNNING                                             NTStatus      = 0xC00A0036
+	STATUS_CTX_LOGON_DISABLED                                                 NTStatus      = 0xC00A0037
+	STATUS_CTX_SECURITY_LAYER_ERROR                                           NTStatus      = 0xC00A0038
+	STATUS_TS_INCOMPATIBLE_SESSIONS                                           NTStatus      = 0xC00A0039
+	STATUS_TS_VIDEO_SUBSYSTEM_ERROR                                           NTStatus      = 0xC00A003A
+	STATUS_PNP_BAD_MPS_TABLE                                                  NTStatus      = 0xC0040035
+	STATUS_PNP_TRANSLATION_FAILED                                             NTStatus      = 0xC0040036
+	STATUS_PNP_IRQ_TRANSLATION_FAILED                                         NTStatus      = 0xC0040037
+	STATUS_PNP_INVALID_ID                                                     NTStatus      = 0xC0040038
+	STATUS_IO_REISSUE_AS_CACHED                                               NTStatus      = 0xC0040039
+	STATUS_MUI_FILE_NOT_FOUND                                                 NTStatus      = 0xC00B0001
+	STATUS_MUI_INVALID_FILE                                                   NTStatus      = 0xC00B0002
+	STATUS_MUI_INVALID_RC_CONFIG                                              NTStatus      = 0xC00B0003
+	STATUS_MUI_INVALID_LOCALE_NAME                                            NTStatus      = 0xC00B0004
+	STATUS_MUI_INVALID_ULTIMATEFALLBACK_NAME                                  NTStatus      = 0xC00B0005
+	STATUS_MUI_FILE_NOT_LOADED                                                NTStatus      = 0xC00B0006
+	STATUS_RESOURCE_ENUM_USER_STOP                                            NTStatus      = 0xC00B0007
+	STATUS_FLT_NO_HANDLER_DEFINED                                             NTStatus      = 0xC01C0001
+	STATUS_FLT_CONTEXT_ALREADY_DEFINED                                        NTStatus      = 0xC01C0002
+	STATUS_FLT_INVALID_ASYNCHRONOUS_REQUEST                                   NTStatus      = 0xC01C0003
+	STATUS_FLT_DISALLOW_FAST_IO                                               NTStatus      = 0xC01C0004
+	STATUS_FLT_INVALID_NAME_REQUEST                                           NTStatus      = 0xC01C0005
+	STATUS_FLT_NOT_SAFE_TO_POST_OPERATION                                     NTStatus      = 0xC01C0006
+	STATUS_FLT_NOT_INITIALIZED                                                NTStatus      = 0xC01C0007
+	STATUS_FLT_FILTER_NOT_READY                                               NTStatus      = 0xC01C0008
+	STATUS_FLT_POST_OPERATION_CLEANUP                                         NTStatus      = 0xC01C0009
+	STATUS_FLT_INTERNAL_ERROR                                                 NTStatus      = 0xC01C000A
+	STATUS_FLT_DELETING_OBJECT                                                NTStatus      = 0xC01C000B
+	STATUS_FLT_MUST_BE_NONPAGED_POOL                                          NTStatus      = 0xC01C000C
+	STATUS_FLT_DUPLICATE_ENTRY                                                NTStatus      = 0xC01C000D
+	STATUS_FLT_CBDQ_DISABLED                                                  NTStatus      = 0xC01C000E
+	STATUS_FLT_DO_NOT_ATTACH                                                  NTStatus      = 0xC01C000F
+	STATUS_FLT_DO_NOT_DETACH                                                  NTStatus      = 0xC01C0010
+	STATUS_FLT_INSTANCE_ALTITUDE_COLLISION                                    NTStatus      = 0xC01C0011
+	STATUS_FLT_INSTANCE_NAME_COLLISION                                        NTStatus      = 0xC01C0012
+	STATUS_FLT_FILTER_NOT_FOUND                                               NTStatus      = 0xC01C0013
+	STATUS_FLT_VOLUME_NOT_FOUND                                               NTStatus      = 0xC01C0014
+	STATUS_FLT_INSTANCE_NOT_FOUND                                             NTStatus      = 0xC01C0015
+	STATUS_FLT_CONTEXT_ALLOCATION_NOT_FOUND                                   NTStatus      = 0xC01C0016
+	STATUS_FLT_INVALID_CONTEXT_REGISTRATION                                   NTStatus      = 0xC01C0017
+	STATUS_FLT_NAME_CACHE_MISS                                                NTStatus      = 0xC01C0018
+	STATUS_FLT_NO_DEVICE_OBJECT                                               NTStatus      = 0xC01C0019
+	STATUS_FLT_VOLUME_ALREADY_MOUNTED                                         NTStatus      = 0xC01C001A
+	STATUS_FLT_ALREADY_ENLISTED                                               NTStatus      = 0xC01C001B
+	STATUS_FLT_CONTEXT_ALREADY_LINKED                                         NTStatus      = 0xC01C001C
+	STATUS_FLT_NO_WAITER_FOR_REPLY                                            NTStatus      = 0xC01C0020
+	STATUS_FLT_REGISTRATION_BUSY                                              NTStatus      = 0xC01C0023
+	STATUS_SXS_SECTION_NOT_FOUND                                              NTStatus      = 0xC0150001
+	STATUS_SXS_CANT_GEN_ACTCTX                                                NTStatus      = 0xC0150002
+	STATUS_SXS_INVALID_ACTCTXDATA_FORMAT                                      NTStatus      = 0xC0150003
+	STATUS_SXS_ASSEMBLY_NOT_FOUND                                             NTStatus      = 0xC0150004
+	STATUS_SXS_MANIFEST_FORMAT_ERROR                                          NTStatus      = 0xC0150005
+	STATUS_SXS_MANIFEST_PARSE_ERROR                                           NTStatus      = 0xC0150006
+	STATUS_SXS_ACTIVATION_CONTEXT_DISABLED                                    NTStatus      = 0xC0150007
+	STATUS_SXS_KEY_NOT_FOUND                                                  NTStatus      = 0xC0150008
+	STATUS_SXS_VERSION_CONFLICT                                               NTStatus      = 0xC0150009
+	STATUS_SXS_WRONG_SECTION_TYPE                                             NTStatus      = 0xC015000A
+	STATUS_SXS_THREAD_QUERIES_DISABLED                                        NTStatus      = 0xC015000B
+	STATUS_SXS_ASSEMBLY_MISSING                                               NTStatus      = 0xC015000C
+	STATUS_SXS_RELEASE_ACTIVATION_CONTEXT                                     NTStatus      = 0x4015000D
+	STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET                                    NTStatus      = 0xC015000E
+	STATUS_SXS_EARLY_DEACTIVATION                                             NTStatus      = 0xC015000F
+	STATUS_SXS_INVALID_DEACTIVATION                                           NTStatus      = 0xC0150010
+	STATUS_SXS_MULTIPLE_DEACTIVATION                                          NTStatus      = 0xC0150011
+	STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY                        NTStatus      = 0xC0150012
+	STATUS_SXS_PROCESS_TERMINATION_REQUESTED                                  NTStatus      = 0xC0150013
+	STATUS_SXS_CORRUPT_ACTIVATION_STACK                                       NTStatus      = 0xC0150014
+	STATUS_SXS_CORRUPTION                                                     NTStatus      = 0xC0150015
+	STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE                               NTStatus      = 0xC0150016
+	STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME                                NTStatus      = 0xC0150017
+	STATUS_SXS_IDENTITY_DUPLICATE_ATTRIBUTE                                   NTStatus      = 0xC0150018
+	STATUS_SXS_IDENTITY_PARSE_ERROR                                           NTStatus      = 0xC0150019
+	STATUS_SXS_COMPONENT_STORE_CORRUPT                                        NTStatus      = 0xC015001A
+	STATUS_SXS_FILE_HASH_MISMATCH                                             NTStatus      = 0xC015001B
+	STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT                  NTStatus      = 0xC015001C
+	STATUS_SXS_IDENTITIES_DIFFERENT                                           NTStatus      = 0xC015001D
+	STATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT                                   NTStatus      = 0xC015001E
+	STATUS_SXS_FILE_NOT_PART_OF_ASSEMBLY                                      NTStatus      = 0xC015001F
+	STATUS_ADVANCED_INSTALLER_FAILED                                          NTStatus      = 0xC0150020
+	STATUS_XML_ENCODING_MISMATCH                                              NTStatus      = 0xC0150021
+	STATUS_SXS_MANIFEST_TOO_BIG                                               NTStatus      = 0xC0150022
+	STATUS_SXS_SETTING_NOT_REGISTERED                                         NTStatus      = 0xC0150023
+	STATUS_SXS_TRANSACTION_CLOSURE_INCOMPLETE                                 NTStatus      = 0xC0150024
+	STATUS_SMI_PRIMITIVE_INSTALLER_FAILED                                     NTStatus      = 0xC0150025
+	STATUS_GENERIC_COMMAND_FAILED                                             NTStatus      = 0xC0150026
+	STATUS_SXS_FILE_HASH_MISSING                                              NTStatus      = 0xC0150027
+	STATUS_CLUSTER_INVALID_NODE                                               NTStatus      = 0xC0130001
+	STATUS_CLUSTER_NODE_EXISTS                                                NTStatus      = 0xC0130002
+	STATUS_CLUSTER_JOIN_IN_PROGRESS                                           NTStatus      = 0xC0130003
+	STATUS_CLUSTER_NODE_NOT_FOUND                                             NTStatus      = 0xC0130004
+	STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND                                       NTStatus      = 0xC0130005
+	STATUS_CLUSTER_NETWORK_EXISTS                                             NTStatus      = 0xC0130006
+	STATUS_CLUSTER_NETWORK_NOT_FOUND                                          NTStatus      = 0xC0130007
+	STATUS_CLUSTER_NETINTERFACE_EXISTS                                        NTStatus      = 0xC0130008
+	STATUS_CLUSTER_NETINTERFACE_NOT_FOUND                                     NTStatus      = 0xC0130009
+	STATUS_CLUSTER_INVALID_REQUEST                                            NTStatus      = 0xC013000A
+	STATUS_CLUSTER_INVALID_NETWORK_PROVIDER                                   NTStatus      = 0xC013000B
+	STATUS_CLUSTER_NODE_DOWN                                                  NTStatus      = 0xC013000C
+	STATUS_CLUSTER_NODE_UNREACHABLE                                           NTStatus      = 0xC013000D
+	STATUS_CLUSTER_NODE_NOT_MEMBER                                            NTStatus      = 0xC013000E
+	STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS                                       NTStatus      = 0xC013000F
+	STATUS_CLUSTER_INVALID_NETWORK                                            NTStatus      = 0xC0130010
+	STATUS_CLUSTER_NO_NET_ADAPTERS                                            NTStatus      = 0xC0130011
+	STATUS_CLUSTER_NODE_UP                                                    NTStatus      = 0xC0130012
+	STATUS_CLUSTER_NODE_PAUSED                                                NTStatus      = 0xC0130013
+	STATUS_CLUSTER_NODE_NOT_PAUSED                                            NTStatus      = 0xC0130014
+	STATUS_CLUSTER_NO_SECURITY_CONTEXT                                        NTStatus      = 0xC0130015
+	STATUS_CLUSTER_NETWORK_NOT_INTERNAL                                       NTStatus      = 0xC0130016
+	STATUS_CLUSTER_POISONED                                                   NTStatus      = 0xC0130017
+	STATUS_CLUSTER_NON_CSV_PATH                                               NTStatus      = 0xC0130018
+	STATUS_CLUSTER_CSV_VOLUME_NOT_LOCAL                                       NTStatus      = 0xC0130019
+	STATUS_CLUSTER_CSV_READ_OPLOCK_BREAK_IN_PROGRESS                          NTStatus      = 0xC0130020
+	STATUS_CLUSTER_CSV_AUTO_PAUSE_ERROR                                       NTStatus      = 0xC0130021
+	STATUS_CLUSTER_CSV_REDIRECTED                                             NTStatus      = 0xC0130022
+	STATUS_CLUSTER_CSV_NOT_REDIRECTED                                         NTStatus      = 0xC0130023
+	STATUS_CLUSTER_CSV_VOLUME_DRAINING                                        NTStatus      = 0xC0130024
+	STATUS_CLUSTER_CSV_SNAPSHOT_CREATION_IN_PROGRESS                          NTStatus      = 0xC0130025
+	STATUS_CLUSTER_CSV_VOLUME_DRAINING_SUCCEEDED_DOWNLEVEL                    NTStatus      = 0xC0130026
+	STATUS_CLUSTER_CSV_NO_SNAPSHOTS                                           NTStatus      = 0xC0130027
+	STATUS_CSV_IO_PAUSE_TIMEOUT                                               NTStatus      = 0xC0130028
+	STATUS_CLUSTER_CSV_INVALID_HANDLE                                         NTStatus      = 0xC0130029
+	STATUS_CLUSTER_CSV_SUPPORTED_ONLY_ON_COORDINATOR                          NTStatus      = 0xC0130030
+	STATUS_CLUSTER_CAM_TICKET_REPLAY_DETECTED                                 NTStatus      = 0xC0130031
+	STATUS_TRANSACTIONAL_CONFLICT                                             NTStatus      = 0xC0190001
+	STATUS_INVALID_TRANSACTION                                                NTStatus      = 0xC0190002
+	STATUS_TRANSACTION_NOT_ACTIVE                                             NTStatus      = 0xC0190003
+	STATUS_TM_INITIALIZATION_FAILED                                           NTStatus      = 0xC0190004
+	STATUS_RM_NOT_ACTIVE                                                      NTStatus      = 0xC0190005
+	STATUS_RM_METADATA_CORRUPT                                                NTStatus      = 0xC0190006
+	STATUS_TRANSACTION_NOT_JOINED                                             NTStatus      = 0xC0190007
+	STATUS_DIRECTORY_NOT_RM                                                   NTStatus      = 0xC0190008
+	STATUS_COULD_NOT_RESIZE_LOG                                               NTStatus      = 0x80190009
+	STATUS_TRANSACTIONS_UNSUPPORTED_REMOTE                                    NTStatus      = 0xC019000A
+	STATUS_LOG_RESIZE_INVALID_SIZE                                            NTStatus      = 0xC019000B
+	STATUS_REMOTE_FILE_VERSION_MISMATCH                                       NTStatus      = 0xC019000C
+	STATUS_CRM_PROTOCOL_ALREADY_EXISTS                                        NTStatus      = 0xC019000F
+	STATUS_TRANSACTION_PROPAGATION_FAILED                                     NTStatus      = 0xC0190010
+	STATUS_CRM_PROTOCOL_NOT_FOUND                                             NTStatus      = 0xC0190011
+	STATUS_TRANSACTION_SUPERIOR_EXISTS                                        NTStatus      = 0xC0190012
+	STATUS_TRANSACTION_REQUEST_NOT_VALID                                      NTStatus      = 0xC0190013
+	STATUS_TRANSACTION_NOT_REQUESTED                                          NTStatus      = 0xC0190014
+	STATUS_TRANSACTION_ALREADY_ABORTED                                        NTStatus      = 0xC0190015
+	STATUS_TRANSACTION_ALREADY_COMMITTED                                      NTStatus      = 0xC0190016
+	STATUS_TRANSACTION_INVALID_MARSHALL_BUFFER                                NTStatus      = 0xC0190017
+	STATUS_CURRENT_TRANSACTION_NOT_VALID                                      NTStatus      = 0xC0190018
+	STATUS_LOG_GROWTH_FAILED                                                  NTStatus      = 0xC0190019
+	STATUS_OBJECT_NO_LONGER_EXISTS                                            NTStatus      = 0xC0190021
+	STATUS_STREAM_MINIVERSION_NOT_FOUND                                       NTStatus      = 0xC0190022
+	STATUS_STREAM_MINIVERSION_NOT_VALID                                       NTStatus      = 0xC0190023
+	STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION                NTStatus      = 0xC0190024
+	STATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT                           NTStatus      = 0xC0190025
+	STATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONS                               NTStatus      = 0xC0190026
+	STATUS_HANDLE_NO_LONGER_VALID                                             NTStatus      = 0xC0190028
+	STATUS_NO_TXF_METADATA                                                    NTStatus      = 0x80190029
+	STATUS_LOG_CORRUPTION_DETECTED                                            NTStatus      = 0xC0190030
+	STATUS_CANT_RECOVER_WITH_HANDLE_OPEN                                      NTStatus      = 0x80190031
+	STATUS_RM_DISCONNECTED                                                    NTStatus      = 0xC0190032
+	STATUS_ENLISTMENT_NOT_SUPERIOR                                            NTStatus      = 0xC0190033
+	STATUS_RECOVERY_NOT_NEEDED                                                NTStatus      = 0x40190034
+	STATUS_RM_ALREADY_STARTED                                                 NTStatus      = 0x40190035
+	STATUS_FILE_IDENTITY_NOT_PERSISTENT                                       NTStatus      = 0xC0190036
+	STATUS_CANT_BREAK_TRANSACTIONAL_DEPENDENCY                                NTStatus      = 0xC0190037
+	STATUS_CANT_CROSS_RM_BOUNDARY                                             NTStatus      = 0xC0190038
+	STATUS_TXF_DIR_NOT_EMPTY                                                  NTStatus      = 0xC0190039
+	STATUS_INDOUBT_TRANSACTIONS_EXIST                                         NTStatus      = 0xC019003A
+	STATUS_TM_VOLATILE                                                        NTStatus      = 0xC019003B
+	STATUS_ROLLBACK_TIMER_EXPIRED                                             NTStatus      = 0xC019003C
+	STATUS_TXF_ATTRIBUTE_CORRUPT                                              NTStatus      = 0xC019003D
+	STATUS_EFS_NOT_ALLOWED_IN_TRANSACTION                                     NTStatus      = 0xC019003E
+	STATUS_TRANSACTIONAL_OPEN_NOT_ALLOWED                                     NTStatus      = 0xC019003F
+	STATUS_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE                              NTStatus      = 0xC0190040
+	STATUS_TXF_METADATA_ALREADY_PRESENT                                       NTStatus      = 0x80190041
+	STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET                                NTStatus      = 0x80190042
+	STATUS_TRANSACTION_REQUIRED_PROMOTION                                     NTStatus      = 0xC0190043
+	STATUS_CANNOT_EXECUTE_FILE_IN_TRANSACTION                                 NTStatus      = 0xC0190044
+	STATUS_TRANSACTIONS_NOT_FROZEN                                            NTStatus      = 0xC0190045
+	STATUS_TRANSACTION_FREEZE_IN_PROGRESS                                     NTStatus      = 0xC0190046
+	STATUS_NOT_SNAPSHOT_VOLUME                                                NTStatus      = 0xC0190047
+	STATUS_NO_SAVEPOINT_WITH_OPEN_FILES                                       NTStatus      = 0xC0190048
+	STATUS_SPARSE_NOT_ALLOWED_IN_TRANSACTION                                  NTStatus      = 0xC0190049
+	STATUS_TM_IDENTITY_MISMATCH                                               NTStatus      = 0xC019004A
+	STATUS_FLOATED_SECTION                                                    NTStatus      = 0xC019004B
+	STATUS_CANNOT_ACCEPT_TRANSACTED_WORK                                      NTStatus      = 0xC019004C
+	STATUS_CANNOT_ABORT_TRANSACTIONS                                          NTStatus      = 0xC019004D
+	STATUS_TRANSACTION_NOT_FOUND                                              NTStatus      = 0xC019004E
+	STATUS_RESOURCEMANAGER_NOT_FOUND                                          NTStatus      = 0xC019004F
+	STATUS_ENLISTMENT_NOT_FOUND                                               NTStatus      = 0xC0190050
+	STATUS_TRANSACTIONMANAGER_NOT_FOUND                                       NTStatus      = 0xC0190051
+	STATUS_TRANSACTIONMANAGER_NOT_ONLINE                                      NTStatus      = 0xC0190052
+	STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION                         NTStatus      = 0xC0190053
+	STATUS_TRANSACTION_NOT_ROOT                                               NTStatus      = 0xC0190054
+	STATUS_TRANSACTION_OBJECT_EXPIRED                                         NTStatus      = 0xC0190055
+	STATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION                             NTStatus      = 0xC0190056
+	STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED                                  NTStatus      = 0xC0190057
+	STATUS_TRANSACTION_RECORD_TOO_LONG                                        NTStatus      = 0xC0190058
+	STATUS_NO_LINK_TRACKING_IN_TRANSACTION                                    NTStatus      = 0xC0190059
+	STATUS_OPERATION_NOT_SUPPORTED_IN_TRANSACTION                             NTStatus      = 0xC019005A
+	STATUS_TRANSACTION_INTEGRITY_VIOLATED                                     NTStatus      = 0xC019005B
+	STATUS_TRANSACTIONMANAGER_IDENTITY_MISMATCH                               NTStatus      = 0xC019005C
+	STATUS_RM_CANNOT_BE_FROZEN_FOR_SNAPSHOT                                   NTStatus      = 0xC019005D
+	STATUS_TRANSACTION_MUST_WRITETHROUGH                                      NTStatus      = 0xC019005E
+	STATUS_TRANSACTION_NO_SUPERIOR                                            NTStatus      = 0xC019005F
+	STATUS_EXPIRED_HANDLE                                                     NTStatus      = 0xC0190060
+	STATUS_TRANSACTION_NOT_ENLISTED                                           NTStatus      = 0xC0190061
+	STATUS_LOG_SECTOR_INVALID                                                 NTStatus      = 0xC01A0001
+	STATUS_LOG_SECTOR_PARITY_INVALID                                          NTStatus      = 0xC01A0002
+	STATUS_LOG_SECTOR_REMAPPED                                                NTStatus      = 0xC01A0003
+	STATUS_LOG_BLOCK_INCOMPLETE                                               NTStatus      = 0xC01A0004
+	STATUS_LOG_INVALID_RANGE                                                  NTStatus      = 0xC01A0005
+	STATUS_LOG_BLOCKS_EXHAUSTED                                               NTStatus      = 0xC01A0006
+	STATUS_LOG_READ_CONTEXT_INVALID                                           NTStatus      = 0xC01A0007
+	STATUS_LOG_RESTART_INVALID                                                NTStatus      = 0xC01A0008
+	STATUS_LOG_BLOCK_VERSION                                                  NTStatus      = 0xC01A0009
+	STATUS_LOG_BLOCK_INVALID                                                  NTStatus      = 0xC01A000A
+	STATUS_LOG_READ_MODE_INVALID                                              NTStatus      = 0xC01A000B
+	STATUS_LOG_NO_RESTART                                                     NTStatus      = 0x401A000C
+	STATUS_LOG_METADATA_CORRUPT                                               NTStatus      = 0xC01A000D
+	STATUS_LOG_METADATA_INVALID                                               NTStatus      = 0xC01A000E
+	STATUS_LOG_METADATA_INCONSISTENT                                          NTStatus      = 0xC01A000F
+	STATUS_LOG_RESERVATION_INVALID                                            NTStatus      = 0xC01A0010
+	STATUS_LOG_CANT_DELETE                                                    NTStatus      = 0xC01A0011
+	STATUS_LOG_CONTAINER_LIMIT_EXCEEDED                                       NTStatus      = 0xC01A0012
+	STATUS_LOG_START_OF_LOG                                                   NTStatus      = 0xC01A0013
+	STATUS_LOG_POLICY_ALREADY_INSTALLED                                       NTStatus      = 0xC01A0014
+	STATUS_LOG_POLICY_NOT_INSTALLED                                           NTStatus      = 0xC01A0015
+	STATUS_LOG_POLICY_INVALID                                                 NTStatus      = 0xC01A0016
+	STATUS_LOG_POLICY_CONFLICT                                                NTStatus      = 0xC01A0017
+	STATUS_LOG_PINNED_ARCHIVE_TAIL                                            NTStatus      = 0xC01A0018
+	STATUS_LOG_RECORD_NONEXISTENT                                             NTStatus      = 0xC01A0019
+	STATUS_LOG_RECORDS_RESERVED_INVALID                                       NTStatus      = 0xC01A001A
+	STATUS_LOG_SPACE_RESERVED_INVALID                                         NTStatus      = 0xC01A001B
+	STATUS_LOG_TAIL_INVALID                                                   NTStatus      = 0xC01A001C
+	STATUS_LOG_FULL                                                           NTStatus      = 0xC01A001D
+	STATUS_LOG_MULTIPLEXED                                                    NTStatus      = 0xC01A001E
+	STATUS_LOG_DEDICATED                                                      NTStatus      = 0xC01A001F
+	STATUS_LOG_ARCHIVE_NOT_IN_PROGRESS                                        NTStatus      = 0xC01A0020
+	STATUS_LOG_ARCHIVE_IN_PROGRESS                                            NTStatus      = 0xC01A0021
+	STATUS_LOG_EPHEMERAL                                                      NTStatus      = 0xC01A0022
+	STATUS_LOG_NOT_ENOUGH_CONTAINERS                                          NTStatus      = 0xC01A0023
+	STATUS_LOG_CLIENT_ALREADY_REGISTERED                                      NTStatus      = 0xC01A0024
+	STATUS_LOG_CLIENT_NOT_REGISTERED                                          NTStatus      = 0xC01A0025
+	STATUS_LOG_FULL_HANDLER_IN_PROGRESS                                       NTStatus      = 0xC01A0026
+	STATUS_LOG_CONTAINER_READ_FAILED                                          NTStatus      = 0xC01A0027
+	STATUS_LOG_CONTAINER_WRITE_FAILED                                         NTStatus      = 0xC01A0028
+	STATUS_LOG_CONTAINER_OPEN_FAILED                                          NTStatus      = 0xC01A0029
+	STATUS_LOG_CONTAINER_STATE_INVALID                                        NTStatus      = 0xC01A002A
+	STATUS_LOG_STATE_INVALID                                                  NTStatus      = 0xC01A002B
+	STATUS_LOG_PINNED                                                         NTStatus      = 0xC01A002C
+	STATUS_LOG_METADATA_FLUSH_FAILED                                          NTStatus      = 0xC01A002D
+	STATUS_LOG_INCONSISTENT_SECURITY                                          NTStatus      = 0xC01A002E
+	STATUS_LOG_APPENDED_FLUSH_FAILED                                          NTStatus      = 0xC01A002F
+	STATUS_LOG_PINNED_RESERVATION                                             NTStatus      = 0xC01A0030
+	STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD                                   NTStatus      = 0xC01B00EA
+	STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED                         NTStatus      = 0x801B00EB
+	STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST                                  NTStatus      = 0x401B00EC
+	STATUS_MONITOR_NO_DESCRIPTOR                                              NTStatus      = 0xC01D0001
+	STATUS_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT                                  NTStatus      = 0xC01D0002
+	STATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUM                                NTStatus      = 0xC01D0003
+	STATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCK                              NTStatus      = 0xC01D0004
+	STATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED                          NTStatus      = 0xC01D0005
+	STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK                         NTStatus      = 0xC01D0006
+	STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK                         NTStatus      = 0xC01D0007
+	STATUS_MONITOR_NO_MORE_DESCRIPTOR_DATA                                    NTStatus      = 0xC01D0008
+	STATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCK                              NTStatus      = 0xC01D0009
+	STATUS_MONITOR_INVALID_MANUFACTURE_DATE                                   NTStatus      = 0xC01D000A
+	STATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER                                  NTStatus      = 0xC01E0000
+	STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER                                   NTStatus      = 0xC01E0001
+	STATUS_GRAPHICS_INVALID_DISPLAY_ADAPTER                                   NTStatus      = 0xC01E0002
+	STATUS_GRAPHICS_ADAPTER_WAS_RESET                                         NTStatus      = 0xC01E0003
+	STATUS_GRAPHICS_INVALID_DRIVER_MODEL                                      NTStatus      = 0xC01E0004
+	STATUS_GRAPHICS_PRESENT_MODE_CHANGED                                      NTStatus      = 0xC01E0005
+	STATUS_GRAPHICS_PRESENT_OCCLUDED                                          NTStatus      = 0xC01E0006
+	STATUS_GRAPHICS_PRESENT_DENIED                                            NTStatus      = 0xC01E0007
+	STATUS_GRAPHICS_CANNOTCOLORCONVERT                                        NTStatus      = 0xC01E0008
+	STATUS_GRAPHICS_DRIVER_MISMATCH                                           NTStatus      = 0xC01E0009
+	STATUS_GRAPHICS_PARTIAL_DATA_POPULATED                                    NTStatus      = 0x401E000A
+	STATUS_GRAPHICS_PRESENT_REDIRECTION_DISABLED                              NTStatus      = 0xC01E000B
+	STATUS_GRAPHICS_PRESENT_UNOCCLUDED                                        NTStatus      = 0xC01E000C
+	STATUS_GRAPHICS_WINDOWDC_NOT_AVAILABLE                                    NTStatus      = 0xC01E000D
+	STATUS_GRAPHICS_WINDOWLESS_PRESENT_DISABLED                               NTStatus      = 0xC01E000E
+	STATUS_GRAPHICS_PRESENT_INVALID_WINDOW                                    NTStatus      = 0xC01E000F
+	STATUS_GRAPHICS_PRESENT_BUFFER_NOT_BOUND                                  NTStatus      = 0xC01E0010
+	STATUS_GRAPHICS_VAIL_STATE_CHANGED                                        NTStatus      = 0xC01E0011
+	STATUS_GRAPHICS_INDIRECT_DISPLAY_ABANDON_SWAPCHAIN                        NTStatus      = 0xC01E0012
+	STATUS_GRAPHICS_INDIRECT_DISPLAY_DEVICE_STOPPED                           NTStatus      = 0xC01E0013
+	STATUS_GRAPHICS_NO_VIDEO_MEMORY                                           NTStatus      = 0xC01E0100
+	STATUS_GRAPHICS_CANT_LOCK_MEMORY                                          NTStatus      = 0xC01E0101
+	STATUS_GRAPHICS_ALLOCATION_BUSY                                           NTStatus      = 0xC01E0102
+	STATUS_GRAPHICS_TOO_MANY_REFERENCES                                       NTStatus      = 0xC01E0103
+	STATUS_GRAPHICS_TRY_AGAIN_LATER                                           NTStatus      = 0xC01E0104
+	STATUS_GRAPHICS_TRY_AGAIN_NOW                                             NTStatus      = 0xC01E0105
+	STATUS_GRAPHICS_ALLOCATION_INVALID                                        NTStatus      = 0xC01E0106
+	STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE                          NTStatus      = 0xC01E0107
+	STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED                          NTStatus      = 0xC01E0108
+	STATUS_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION                              NTStatus      = 0xC01E0109
+	STATUS_GRAPHICS_INVALID_ALLOCATION_USAGE                                  NTStatus      = 0xC01E0110
+	STATUS_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION                             NTStatus      = 0xC01E0111
+	STATUS_GRAPHICS_ALLOCATION_CLOSED                                         NTStatus      = 0xC01E0112
+	STATUS_GRAPHICS_INVALID_ALLOCATION_INSTANCE                               NTStatus      = 0xC01E0113
+	STATUS_GRAPHICS_INVALID_ALLOCATION_HANDLE                                 NTStatus      = 0xC01E0114
+	STATUS_GRAPHICS_WRONG_ALLOCATION_DEVICE                                   NTStatus      = 0xC01E0115
+	STATUS_GRAPHICS_ALLOCATION_CONTENT_LOST                                   NTStatus      = 0xC01E0116
+	STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE                                   NTStatus      = 0xC01E0200
+	STATUS_GRAPHICS_SKIP_ALLOCATION_PREPARATION                               NTStatus      = 0x401E0201
+	STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY                                    NTStatus      = 0xC01E0300
+	STATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED                              NTStatus      = 0xC01E0301
+	STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED                    NTStatus      = 0xC01E0302
+	STATUS_GRAPHICS_INVALID_VIDPN                                             NTStatus      = 0xC01E0303
+	STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE                              NTStatus      = 0xC01E0304
+	STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET                              NTStatus      = 0xC01E0305
+	STATUS_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED                              NTStatus      = 0xC01E0306
+	STATUS_GRAPHICS_MODE_NOT_PINNED                                           NTStatus      = 0x401E0307
+	STATUS_GRAPHICS_INVALID_VIDPN_SOURCEMODESET                               NTStatus      = 0xC01E0308
+	STATUS_GRAPHICS_INVALID_VIDPN_TARGETMODESET                               NTStatus      = 0xC01E0309
+	STATUS_GRAPHICS_INVALID_FREQUENCY                                         NTStatus      = 0xC01E030A
+	STATUS_GRAPHICS_INVALID_ACTIVE_REGION                                     NTStatus      = 0xC01E030B
+	STATUS_GRAPHICS_INVALID_TOTAL_REGION                                      NTStatus      = 0xC01E030C
+	STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE                         NTStatus      = 0xC01E0310
+	STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE                         NTStatus      = 0xC01E0311
+	STATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET                            NTStatus      = 0xC01E0312
+	STATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY                                  NTStatus      = 0xC01E0313
+	STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET                                   NTStatus      = 0xC01E0314
+	STATUS_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET                             NTStatus      = 0xC01E0315
+	STATUS_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET                             NTStatus      = 0xC01E0316
+	STATUS_GRAPHICS_SOURCE_ALREADY_IN_SET                                     NTStatus      = 0xC01E0317
+	STATUS_GRAPHICS_TARGET_ALREADY_IN_SET                                     NTStatus      = 0xC01E0318
+	STATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATH                                NTStatus      = 0xC01E0319
+	STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY                             NTStatus      = 0xC01E031A
+	STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET                         NTStatus      = 0xC01E031B
+	STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE                            NTStatus      = 0xC01E031C
+	STATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET                                 NTStatus      = 0xC01E031D
+	STATUS_GRAPHICS_NO_PREFERRED_MODE                                         NTStatus      = 0x401E031E
+	STATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET                             NTStatus      = 0xC01E031F
+	STATUS_GRAPHICS_STALE_MODESET                                             NTStatus      = 0xC01E0320
+	STATUS_GRAPHICS_INVALID_MONITOR_SOURCEMODESET                             NTStatus      = 0xC01E0321
+	STATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODE                               NTStatus      = 0xC01E0322
+	STATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN                           NTStatus      = 0xC01E0323
+	STATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUE                                    NTStatus      = 0xC01E0324
+	STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION           NTStatus      = 0xC01E0325
+	STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES                   NTStatus      = 0xC01E0326
+	STATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGY                                      NTStatus      = 0xC01E0327
+	STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE                     NTStatus      = 0xC01E0328
+	STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET                     NTStatus      = 0xC01E0329
+	STATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSET                              NTStatus      = 0xC01E032A
+	STATUS_GRAPHICS_INVALID_MONITORDESCRIPTOR                                 NTStatus      = 0xC01E032B
+	STATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET                              NTStatus      = 0xC01E032C
+	STATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET                          NTStatus      = 0xC01E032D
+	STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE                       NTStatus      = 0xC01E032E
+	STATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE                          NTStatus      = 0xC01E032F
+	STATUS_GRAPHICS_RESOURCES_NOT_RELATED                                     NTStatus      = 0xC01E0330
+	STATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE                                  NTStatus      = 0xC01E0331
+	STATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE                                  NTStatus      = 0xC01E0332
+	STATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET                                 NTStatus      = 0xC01E0333
+	STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER              NTStatus      = 0xC01E0334
+	STATUS_GRAPHICS_NO_VIDPNMGR                                               NTStatus      = 0xC01E0335
+	STATUS_GRAPHICS_NO_ACTIVE_VIDPN                                           NTStatus      = 0xC01E0336
+	STATUS_GRAPHICS_STALE_VIDPN_TOPOLOGY                                      NTStatus      = 0xC01E0337
+	STATUS_GRAPHICS_MONITOR_NOT_CONNECTED                                     NTStatus      = 0xC01E0338
+	STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY                                    NTStatus      = 0xC01E0339
+	STATUS_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE                               NTStatus      = 0xC01E033A
+	STATUS_GRAPHICS_INVALID_VISIBLEREGION_SIZE                                NTStatus      = 0xC01E033B
+	STATUS_GRAPHICS_INVALID_STRIDE                                            NTStatus      = 0xC01E033C
+	STATUS_GRAPHICS_INVALID_PIXELFORMAT                                       NTStatus      = 0xC01E033D
+	STATUS_GRAPHICS_INVALID_COLORBASIS                                        NTStatus      = 0xC01E033E
+	STATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODE                              NTStatus      = 0xC01E033F
+	STATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGY                                    NTStatus      = 0xC01E0340
+	STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT                        NTStatus      = 0xC01E0341
+	STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE                                       NTStatus      = 0xC01E0342
+	STATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN                                  NTStatus      = 0xC01E0343
+	STATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL                           NTStatus      = 0xC01E0344
+	STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION              NTStatus      = 0xC01E0345
+	STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED        NTStatus      = 0xC01E0346
+	STATUS_GRAPHICS_INVALID_GAMMA_RAMP                                        NTStatus      = 0xC01E0347
+	STATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED                                  NTStatus      = 0xC01E0348
+	STATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED                               NTStatus      = 0xC01E0349
+	STATUS_GRAPHICS_MODE_NOT_IN_MODESET                                       NTStatus      = 0xC01E034A
+	STATUS_GRAPHICS_DATASET_IS_EMPTY                                          NTStatus      = 0x401E034B
+	STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET                               NTStatus      = 0x401E034C
+	STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON              NTStatus      = 0xC01E034D
+	STATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPE                                 NTStatus      = 0xC01E034E
+	STATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPE                               NTStatus      = 0xC01E034F
+	STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS                         NTStatus      = 0xC01E0350
+	STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED           NTStatus      = 0x401E0351
+	STATUS_GRAPHICS_INVALID_SCANLINE_ORDERING                                 NTStatus      = 0xC01E0352
+	STATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED                              NTStatus      = 0xC01E0353
+	STATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS                          NTStatus      = 0xC01E0354
+	STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT                               NTStatus      = 0xC01E0355
+	STATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM                            NTStatus      = 0xC01E0356
+	STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN                         NTStatus      = 0xC01E0357
+	STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT                 NTStatus      = 0xC01E0358
+	STATUS_GRAPHICS_MAX_NUM_PATHS_REACHED                                     NTStatus      = 0xC01E0359
+	STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION                        NTStatus      = 0xC01E035A
+	STATUS_GRAPHICS_INVALID_CLIENT_TYPE                                       NTStatus      = 0xC01E035B
+	STATUS_GRAPHICS_CLIENTVIDPN_NOT_SET                                       NTStatus      = 0xC01E035C
+	STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED                         NTStatus      = 0xC01E0400
+	STATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED                            NTStatus      = 0xC01E0401
+	STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS                                      NTStatus      = 0x401E042F
+	STATUS_GRAPHICS_NOT_A_LINKED_ADAPTER                                      NTStatus      = 0xC01E0430
+	STATUS_GRAPHICS_LEADLINK_NOT_ENUMERATED                                   NTStatus      = 0xC01E0431
+	STATUS_GRAPHICS_CHAINLINKS_NOT_ENUMERATED                                 NTStatus      = 0xC01E0432
+	STATUS_GRAPHICS_ADAPTER_CHAIN_NOT_READY                                   NTStatus      = 0xC01E0433
+	STATUS_GRAPHICS_CHAINLINKS_NOT_STARTED                                    NTStatus      = 0xC01E0434
+	STATUS_GRAPHICS_CHAINLINKS_NOT_POWERED_ON                                 NTStatus      = 0xC01E0435
+	STATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE                            NTStatus      = 0xC01E0436
+	STATUS_GRAPHICS_LEADLINK_START_DEFERRED                                   NTStatus      = 0x401E0437
+	STATUS_GRAPHICS_NOT_POST_DEVICE_DRIVER                                    NTStatus      = 0xC01E0438
+	STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY                                    NTStatus      = 0x401E0439
+	STATUS_GRAPHICS_START_DEFERRED                                            NTStatus      = 0x401E043A
+	STATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED                               NTStatus      = 0xC01E043B
+	STATUS_GRAPHICS_DEPENDABLE_CHILD_STATUS                                   NTStatus      = 0x401E043C
+	STATUS_GRAPHICS_OPM_NOT_SUPPORTED                                         NTStatus      = 0xC01E0500
+	STATUS_GRAPHICS_COPP_NOT_SUPPORTED                                        NTStatus      = 0xC01E0501
+	STATUS_GRAPHICS_UAB_NOT_SUPPORTED                                         NTStatus      = 0xC01E0502
+	STATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS                          NTStatus      = 0xC01E0503
+	STATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXIST                            NTStatus      = 0xC01E0505
+	STATUS_GRAPHICS_OPM_INTERNAL_ERROR                                        NTStatus      = 0xC01E050B
+	STATUS_GRAPHICS_OPM_INVALID_HANDLE                                        NTStatus      = 0xC01E050C
+	STATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH                            NTStatus      = 0xC01E050E
+	STATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLED                                 NTStatus      = 0xC01E050F
+	STATUS_GRAPHICS_OPM_THEATER_MODE_ENABLED                                  NTStatus      = 0xC01E0510
+	STATUS_GRAPHICS_PVP_HFS_FAILED                                            NTStatus      = 0xC01E0511
+	STATUS_GRAPHICS_OPM_INVALID_SRM                                           NTStatus      = 0xC01E0512
+	STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP                          NTStatus      = 0xC01E0513
+	STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP                           NTStatus      = 0xC01E0514
+	STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA                         NTStatus      = 0xC01E0515
+	STATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SET                                    NTStatus      = 0xC01E0516
+	STATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGH                                   NTStatus      = 0xC01E0517
+	STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE                      NTStatus      = 0xC01E0518
+	STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS                     NTStatus      = 0xC01E051A
+	STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS         NTStatus      = 0xC01E051C
+	STATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST                           NTStatus      = 0xC01E051D
+	STATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR                                 NTStatus      = 0xC01E051E
+	STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS          NTStatus      = 0xC01E051F
+	STATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED                               NTStatus      = 0xC01E0520
+	STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST                         NTStatus      = 0xC01E0521
+	STATUS_GRAPHICS_I2C_NOT_SUPPORTED                                         NTStatus      = 0xC01E0580
+	STATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST                                 NTStatus      = 0xC01E0581
+	STATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA                               NTStatus      = 0xC01E0582
+	STATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATA                                  NTStatus      = 0xC01E0583
+	STATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED                                   NTStatus      = 0xC01E0584
+	STATUS_GRAPHICS_DDCCI_INVALID_DATA                                        NTStatus      = 0xC01E0585
+	STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE         NTStatus      = 0xC01E0586
+	STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING                         NTStatus      = 0xC01E0587
+	STATUS_GRAPHICS_MCA_INTERNAL_ERROR                                        NTStatus      = 0xC01E0588
+	STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND                             NTStatus      = 0xC01E0589
+	STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH                              NTStatus      = 0xC01E058A
+	STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM                            NTStatus      = 0xC01E058B
+	STATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE                           NTStatus      = 0xC01E058C
+	STATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTS                                  NTStatus      = 0xC01E058D
+	STATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED                            NTStatus      = 0xC01E05E0
+	STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME                     NTStatus      = 0xC01E05E1
+	STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP                    NTStatus      = 0xC01E05E2
+	STATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED                           NTStatus      = 0xC01E05E3
+	STATUS_GRAPHICS_INVALID_POINTER                                           NTStatus      = 0xC01E05E4
+	STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE                  NTStatus      = 0xC01E05E5
+	STATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL                                 NTStatus      = 0xC01E05E6
+	STATUS_GRAPHICS_INTERNAL_ERROR                                            NTStatus      = 0xC01E05E7
+	STATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS                           NTStatus      = 0xC01E05E8
+	STATUS_FVE_LOCKED_VOLUME                                                  NTStatus      = 0xC0210000
+	STATUS_FVE_NOT_ENCRYPTED                                                  NTStatus      = 0xC0210001
+	STATUS_FVE_BAD_INFORMATION                                                NTStatus      = 0xC0210002
+	STATUS_FVE_TOO_SMALL                                                      NTStatus      = 0xC0210003
+	STATUS_FVE_FAILED_WRONG_FS                                                NTStatus      = 0xC0210004
+	STATUS_FVE_BAD_PARTITION_SIZE                                             NTStatus      = 0xC0210005
+	STATUS_FVE_FS_NOT_EXTENDED                                                NTStatus      = 0xC0210006
+	STATUS_FVE_FS_MOUNTED                                                     NTStatus      = 0xC0210007
+	STATUS_FVE_NO_LICENSE                                                     NTStatus      = 0xC0210008
+	STATUS_FVE_ACTION_NOT_ALLOWED                                             NTStatus      = 0xC0210009
+	STATUS_FVE_BAD_DATA                                                       NTStatus      = 0xC021000A
+	STATUS_FVE_VOLUME_NOT_BOUND                                               NTStatus      = 0xC021000B
+	STATUS_FVE_NOT_DATA_VOLUME                                                NTStatus      = 0xC021000C
+	STATUS_FVE_CONV_READ_ERROR                                                NTStatus      = 0xC021000D
+	STATUS_FVE_CONV_WRITE_ERROR                                               NTStatus      = 0xC021000E
+	STATUS_FVE_OVERLAPPED_UPDATE                                              NTStatus      = 0xC021000F
+	STATUS_FVE_FAILED_SECTOR_SIZE                                             NTStatus      = 0xC0210010
+	STATUS_FVE_FAILED_AUTHENTICATION                                          NTStatus      = 0xC0210011
+	STATUS_FVE_NOT_OS_VOLUME                                                  NTStatus      = 0xC0210012
+	STATUS_FVE_KEYFILE_NOT_FOUND                                              NTStatus      = 0xC0210013
+	STATUS_FVE_KEYFILE_INVALID                                                NTStatus      = 0xC0210014
+	STATUS_FVE_KEYFILE_NO_VMK                                                 NTStatus      = 0xC0210015
+	STATUS_FVE_TPM_DISABLED                                                   NTStatus      = 0xC0210016
+	STATUS_FVE_TPM_SRK_AUTH_NOT_ZERO                                          NTStatus      = 0xC0210017
+	STATUS_FVE_TPM_INVALID_PCR                                                NTStatus      = 0xC0210018
+	STATUS_FVE_TPM_NO_VMK                                                     NTStatus      = 0xC0210019
+	STATUS_FVE_PIN_INVALID                                                    NTStatus      = 0xC021001A
+	STATUS_FVE_AUTH_INVALID_APPLICATION                                       NTStatus      = 0xC021001B
+	STATUS_FVE_AUTH_INVALID_CONFIG                                            NTStatus      = 0xC021001C
+	STATUS_FVE_DEBUGGER_ENABLED                                               NTStatus      = 0xC021001D
+	STATUS_FVE_DRY_RUN_FAILED                                                 NTStatus      = 0xC021001E
+	STATUS_FVE_BAD_METADATA_POINTER                                           NTStatus      = 0xC021001F
+	STATUS_FVE_OLD_METADATA_COPY                                              NTStatus      = 0xC0210020
+	STATUS_FVE_REBOOT_REQUIRED                                                NTStatus      = 0xC0210021
+	STATUS_FVE_RAW_ACCESS                                                     NTStatus      = 0xC0210022
+	STATUS_FVE_RAW_BLOCKED                                                    NTStatus      = 0xC0210023
+	STATUS_FVE_NO_AUTOUNLOCK_MASTER_KEY                                       NTStatus      = 0xC0210024
+	STATUS_FVE_MOR_FAILED                                                     NTStatus      = 0xC0210025
+	STATUS_FVE_NO_FEATURE_LICENSE                                             NTStatus      = 0xC0210026
+	STATUS_FVE_POLICY_USER_DISABLE_RDV_NOT_ALLOWED                            NTStatus      = 0xC0210027
+	STATUS_FVE_CONV_RECOVERY_FAILED                                           NTStatus      = 0xC0210028
+	STATUS_FVE_VIRTUALIZED_SPACE_TOO_BIG                                      NTStatus      = 0xC0210029
+	STATUS_FVE_INVALID_DATUM_TYPE                                             NTStatus      = 0xC021002A
+	STATUS_FVE_VOLUME_TOO_SMALL                                               NTStatus      = 0xC0210030
+	STATUS_FVE_ENH_PIN_INVALID                                                NTStatus      = 0xC0210031
+	STATUS_FVE_FULL_ENCRYPTION_NOT_ALLOWED_ON_TP_STORAGE                      NTStatus      = 0xC0210032
+	STATUS_FVE_WIPE_NOT_ALLOWED_ON_TP_STORAGE                                 NTStatus      = 0xC0210033
+	STATUS_FVE_NOT_ALLOWED_ON_CSV_STACK                                       NTStatus      = 0xC0210034
+	STATUS_FVE_NOT_ALLOWED_ON_CLUSTER                                         NTStatus      = 0xC0210035
+	STATUS_FVE_NOT_ALLOWED_TO_UPGRADE_WHILE_CONVERTING                        NTStatus      = 0xC0210036
+	STATUS_FVE_WIPE_CANCEL_NOT_APPLICABLE                                     NTStatus      = 0xC0210037
+	STATUS_FVE_EDRIVE_DRY_RUN_FAILED                                          NTStatus      = 0xC0210038
+	STATUS_FVE_SECUREBOOT_DISABLED                                            NTStatus      = 0xC0210039
+	STATUS_FVE_SECUREBOOT_CONFIG_CHANGE                                       NTStatus      = 0xC021003A
+	STATUS_FVE_DEVICE_LOCKEDOUT                                               NTStatus      = 0xC021003B
+	STATUS_FVE_VOLUME_EXTEND_PREVENTS_EOW_DECRYPT                             NTStatus      = 0xC021003C
+	STATUS_FVE_NOT_DE_VOLUME                                                  NTStatus      = 0xC021003D
+	STATUS_FVE_PROTECTION_DISABLED                                            NTStatus      = 0xC021003E
+	STATUS_FVE_PROTECTION_CANNOT_BE_DISABLED                                  NTStatus      = 0xC021003F
+	STATUS_FVE_OSV_KSR_NOT_ALLOWED                                            NTStatus      = 0xC0210040
+	STATUS_FWP_CALLOUT_NOT_FOUND                                              NTStatus      = 0xC0220001
+	STATUS_FWP_CONDITION_NOT_FOUND                                            NTStatus      = 0xC0220002
+	STATUS_FWP_FILTER_NOT_FOUND                                               NTStatus      = 0xC0220003
+	STATUS_FWP_LAYER_NOT_FOUND                                                NTStatus      = 0xC0220004
+	STATUS_FWP_PROVIDER_NOT_FOUND                                             NTStatus      = 0xC0220005
+	STATUS_FWP_PROVIDER_CONTEXT_NOT_FOUND                                     NTStatus      = 0xC0220006
+	STATUS_FWP_SUBLAYER_NOT_FOUND                                             NTStatus      = 0xC0220007
+	STATUS_FWP_NOT_FOUND                                                      NTStatus      = 0xC0220008
+	STATUS_FWP_ALREADY_EXISTS                                                 NTStatus      = 0xC0220009
+	STATUS_FWP_IN_USE                                                         NTStatus      = 0xC022000A
+	STATUS_FWP_DYNAMIC_SESSION_IN_PROGRESS                                    NTStatus      = 0xC022000B
+	STATUS_FWP_WRONG_SESSION                                                  NTStatus      = 0xC022000C
+	STATUS_FWP_NO_TXN_IN_PROGRESS                                             NTStatus      = 0xC022000D
+	STATUS_FWP_TXN_IN_PROGRESS                                                NTStatus      = 0xC022000E
+	STATUS_FWP_TXN_ABORTED                                                    NTStatus      = 0xC022000F
+	STATUS_FWP_SESSION_ABORTED                                                NTStatus      = 0xC0220010
+	STATUS_FWP_INCOMPATIBLE_TXN                                               NTStatus      = 0xC0220011
+	STATUS_FWP_TIMEOUT                                                        NTStatus      = 0xC0220012
+	STATUS_FWP_NET_EVENTS_DISABLED                                            NTStatus      = 0xC0220013
+	STATUS_FWP_INCOMPATIBLE_LAYER                                             NTStatus      = 0xC0220014
+	STATUS_FWP_KM_CLIENTS_ONLY                                                NTStatus      = 0xC0220015
+	STATUS_FWP_LIFETIME_MISMATCH                                              NTStatus      = 0xC0220016
+	STATUS_FWP_BUILTIN_OBJECT                                                 NTStatus      = 0xC0220017
+	STATUS_FWP_TOO_MANY_CALLOUTS                                              NTStatus      = 0xC0220018
+	STATUS_FWP_NOTIFICATION_DROPPED                                           NTStatus      = 0xC0220019
+	STATUS_FWP_TRAFFIC_MISMATCH                                               NTStatus      = 0xC022001A
+	STATUS_FWP_INCOMPATIBLE_SA_STATE                                          NTStatus      = 0xC022001B
+	STATUS_FWP_NULL_POINTER                                                   NTStatus      = 0xC022001C
+	STATUS_FWP_INVALID_ENUMERATOR                                             NTStatus      = 0xC022001D
+	STATUS_FWP_INVALID_FLAGS                                                  NTStatus      = 0xC022001E
+	STATUS_FWP_INVALID_NET_MASK                                               NTStatus      = 0xC022001F
+	STATUS_FWP_INVALID_RANGE                                                  NTStatus      = 0xC0220020
+	STATUS_FWP_INVALID_INTERVAL                                               NTStatus      = 0xC0220021
+	STATUS_FWP_ZERO_LENGTH_ARRAY                                              NTStatus      = 0xC0220022
+	STATUS_FWP_NULL_DISPLAY_NAME                                              NTStatus      = 0xC0220023
+	STATUS_FWP_INVALID_ACTION_TYPE                                            NTStatus      = 0xC0220024
+	STATUS_FWP_INVALID_WEIGHT                                                 NTStatus      = 0xC0220025
+	STATUS_FWP_MATCH_TYPE_MISMATCH                                            NTStatus      = 0xC0220026
+	STATUS_FWP_TYPE_MISMATCH                                                  NTStatus      = 0xC0220027
+	STATUS_FWP_OUT_OF_BOUNDS                                                  NTStatus      = 0xC0220028
+	STATUS_FWP_RESERVED                                                       NTStatus      = 0xC0220029
+	STATUS_FWP_DUPLICATE_CONDITION                                            NTStatus      = 0xC022002A
+	STATUS_FWP_DUPLICATE_KEYMOD                                               NTStatus      = 0xC022002B
+	STATUS_FWP_ACTION_INCOMPATIBLE_WITH_LAYER                                 NTStatus      = 0xC022002C
+	STATUS_FWP_ACTION_INCOMPATIBLE_WITH_SUBLAYER                              NTStatus      = 0xC022002D
+	STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_LAYER                                NTStatus      = 0xC022002E
+	STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_CALLOUT                              NTStatus      = 0xC022002F
+	STATUS_FWP_INCOMPATIBLE_AUTH_METHOD                                       NTStatus      = 0xC0220030
+	STATUS_FWP_INCOMPATIBLE_DH_GROUP                                          NTStatus      = 0xC0220031
+	STATUS_FWP_EM_NOT_SUPPORTED                                               NTStatus      = 0xC0220032
+	STATUS_FWP_NEVER_MATCH                                                    NTStatus      = 0xC0220033
+	STATUS_FWP_PROVIDER_CONTEXT_MISMATCH                                      NTStatus      = 0xC0220034
+	STATUS_FWP_INVALID_PARAMETER                                              NTStatus      = 0xC0220035
+	STATUS_FWP_TOO_MANY_SUBLAYERS                                             NTStatus      = 0xC0220036
+	STATUS_FWP_CALLOUT_NOTIFICATION_FAILED                                    NTStatus      = 0xC0220037
+	STATUS_FWP_INVALID_AUTH_TRANSFORM                                         NTStatus      = 0xC0220038
+	STATUS_FWP_INVALID_CIPHER_TRANSFORM                                       NTStatus      = 0xC0220039
+	STATUS_FWP_INCOMPATIBLE_CIPHER_TRANSFORM                                  NTStatus      = 0xC022003A
+	STATUS_FWP_INVALID_TRANSFORM_COMBINATION                                  NTStatus      = 0xC022003B
+	STATUS_FWP_DUPLICATE_AUTH_METHOD                                          NTStatus      = 0xC022003C
+	STATUS_FWP_INVALID_TUNNEL_ENDPOINT                                        NTStatus      = 0xC022003D
+	STATUS_FWP_L2_DRIVER_NOT_READY                                            NTStatus      = 0xC022003E
+	STATUS_FWP_KEY_DICTATOR_ALREADY_REGISTERED                                NTStatus      = 0xC022003F
+	STATUS_FWP_KEY_DICTATION_INVALID_KEYING_MATERIAL                          NTStatus      = 0xC0220040
+	STATUS_FWP_CONNECTIONS_DISABLED                                           NTStatus      = 0xC0220041
+	STATUS_FWP_INVALID_DNS_NAME                                               NTStatus      = 0xC0220042
+	STATUS_FWP_STILL_ON                                                       NTStatus      = 0xC0220043
+	STATUS_FWP_IKEEXT_NOT_RUNNING                                             NTStatus      = 0xC0220044
+	STATUS_FWP_TCPIP_NOT_READY                                                NTStatus      = 0xC0220100
+	STATUS_FWP_INJECT_HANDLE_CLOSING                                          NTStatus      = 0xC0220101
+	STATUS_FWP_INJECT_HANDLE_STALE                                            NTStatus      = 0xC0220102
+	STATUS_FWP_CANNOT_PEND                                                    NTStatus      = 0xC0220103
+	STATUS_FWP_DROP_NOICMP                                                    NTStatus      = 0xC0220104
+	STATUS_NDIS_CLOSING                                                       NTStatus      = 0xC0230002
+	STATUS_NDIS_BAD_VERSION                                                   NTStatus      = 0xC0230004
+	STATUS_NDIS_BAD_CHARACTERISTICS                                           NTStatus      = 0xC0230005
+	STATUS_NDIS_ADAPTER_NOT_FOUND                                             NTStatus      = 0xC0230006
+	STATUS_NDIS_OPEN_FAILED                                                   NTStatus      = 0xC0230007
+	STATUS_NDIS_DEVICE_FAILED                                                 NTStatus      = 0xC0230008
+	STATUS_NDIS_MULTICAST_FULL                                                NTStatus      = 0xC0230009
+	STATUS_NDIS_MULTICAST_EXISTS                                              NTStatus      = 0xC023000A
+	STATUS_NDIS_MULTICAST_NOT_FOUND                                           NTStatus      = 0xC023000B
+	STATUS_NDIS_REQUEST_ABORTED                                               NTStatus      = 0xC023000C
+	STATUS_NDIS_RESET_IN_PROGRESS                                             NTStatus      = 0xC023000D
+	STATUS_NDIS_NOT_SUPPORTED                                                 NTStatus      = 0xC02300BB
+	STATUS_NDIS_INVALID_PACKET                                                NTStatus      = 0xC023000F
+	STATUS_NDIS_ADAPTER_NOT_READY                                             NTStatus      = 0xC0230011
+	STATUS_NDIS_INVALID_LENGTH                                                NTStatus      = 0xC0230014
+	STATUS_NDIS_INVALID_DATA                                                  NTStatus      = 0xC0230015
+	STATUS_NDIS_BUFFER_TOO_SHORT                                              NTStatus      = 0xC0230016
+	STATUS_NDIS_INVALID_OID                                                   NTStatus      = 0xC0230017
+	STATUS_NDIS_ADAPTER_REMOVED                                               NTStatus      = 0xC0230018
+	STATUS_NDIS_UNSUPPORTED_MEDIA                                             NTStatus      = 0xC0230019
+	STATUS_NDIS_GROUP_ADDRESS_IN_USE                                          NTStatus      = 0xC023001A
+	STATUS_NDIS_FILE_NOT_FOUND                                                NTStatus      = 0xC023001B
+	STATUS_NDIS_ERROR_READING_FILE                                            NTStatus      = 0xC023001C
+	STATUS_NDIS_ALREADY_MAPPED                                                NTStatus      = 0xC023001D
+	STATUS_NDIS_RESOURCE_CONFLICT                                             NTStatus      = 0xC023001E
+	STATUS_NDIS_MEDIA_DISCONNECTED                                            NTStatus      = 0xC023001F
+	STATUS_NDIS_INVALID_ADDRESS                                               NTStatus      = 0xC0230022
+	STATUS_NDIS_INVALID_DEVICE_REQUEST                                        NTStatus      = 0xC0230010
+	STATUS_NDIS_PAUSED                                                        NTStatus      = 0xC023002A
+	STATUS_NDIS_INTERFACE_NOT_FOUND                                           NTStatus      = 0xC023002B
+	STATUS_NDIS_UNSUPPORTED_REVISION                                          NTStatus      = 0xC023002C
+	STATUS_NDIS_INVALID_PORT                                                  NTStatus      = 0xC023002D
+	STATUS_NDIS_INVALID_PORT_STATE                                            NTStatus      = 0xC023002E
+	STATUS_NDIS_LOW_POWER_STATE                                               NTStatus      = 0xC023002F
+	STATUS_NDIS_REINIT_REQUIRED                                               NTStatus      = 0xC0230030
+	STATUS_NDIS_NO_QUEUES                                                     NTStatus      = 0xC0230031
+	STATUS_NDIS_DOT11_AUTO_CONFIG_ENABLED                                     NTStatus      = 0xC0232000
+	STATUS_NDIS_DOT11_MEDIA_IN_USE                                            NTStatus      = 0xC0232001
+	STATUS_NDIS_DOT11_POWER_STATE_INVALID                                     NTStatus      = 0xC0232002
+	STATUS_NDIS_PM_WOL_PATTERN_LIST_FULL                                      NTStatus      = 0xC0232003
+	STATUS_NDIS_PM_PROTOCOL_OFFLOAD_LIST_FULL                                 NTStatus      = 0xC0232004
+	STATUS_NDIS_DOT11_AP_CHANNEL_CURRENTLY_NOT_AVAILABLE                      NTStatus      = 0xC0232005
+	STATUS_NDIS_DOT11_AP_BAND_CURRENTLY_NOT_AVAILABLE                         NTStatus      = 0xC0232006
+	STATUS_NDIS_DOT11_AP_CHANNEL_NOT_ALLOWED                                  NTStatus      = 0xC0232007
+	STATUS_NDIS_DOT11_AP_BAND_NOT_ALLOWED                                     NTStatus      = 0xC0232008
+	STATUS_NDIS_INDICATION_REQUIRED                                           NTStatus      = 0x40230001
+	STATUS_NDIS_OFFLOAD_POLICY                                                NTStatus      = 0xC023100F
+	STATUS_NDIS_OFFLOAD_CONNECTION_REJECTED                                   NTStatus      = 0xC0231012
+	STATUS_NDIS_OFFLOAD_PATH_REJECTED                                         NTStatus      = 0xC0231013
+	STATUS_TPM_ERROR_MASK                                                     NTStatus      = 0xC0290000
+	STATUS_TPM_AUTHFAIL                                                       NTStatus      = 0xC0290001
+	STATUS_TPM_BADINDEX                                                       NTStatus      = 0xC0290002
+	STATUS_TPM_BAD_PARAMETER                                                  NTStatus      = 0xC0290003
+	STATUS_TPM_AUDITFAILURE                                                   NTStatus      = 0xC0290004
+	STATUS_TPM_CLEAR_DISABLED                                                 NTStatus      = 0xC0290005
+	STATUS_TPM_DEACTIVATED                                                    NTStatus      = 0xC0290006
+	STATUS_TPM_DISABLED                                                       NTStatus      = 0xC0290007
+	STATUS_TPM_DISABLED_CMD                                                   NTStatus      = 0xC0290008
+	STATUS_TPM_FAIL                                                           NTStatus      = 0xC0290009
+	STATUS_TPM_BAD_ORDINAL                                                    NTStatus      = 0xC029000A
+	STATUS_TPM_INSTALL_DISABLED                                               NTStatus      = 0xC029000B
+	STATUS_TPM_INVALID_KEYHANDLE                                              NTStatus      = 0xC029000C
+	STATUS_TPM_KEYNOTFOUND                                                    NTStatus      = 0xC029000D
+	STATUS_TPM_INAPPROPRIATE_ENC                                              NTStatus      = 0xC029000E
+	STATUS_TPM_MIGRATEFAIL                                                    NTStatus      = 0xC029000F
+	STATUS_TPM_INVALID_PCR_INFO                                               NTStatus      = 0xC0290010
+	STATUS_TPM_NOSPACE                                                        NTStatus      = 0xC0290011
+	STATUS_TPM_NOSRK                                                          NTStatus      = 0xC0290012
+	STATUS_TPM_NOTSEALED_BLOB                                                 NTStatus      = 0xC0290013
+	STATUS_TPM_OWNER_SET                                                      NTStatus      = 0xC0290014
+	STATUS_TPM_RESOURCES                                                      NTStatus      = 0xC0290015
+	STATUS_TPM_SHORTRANDOM                                                    NTStatus      = 0xC0290016
+	STATUS_TPM_SIZE                                                           NTStatus      = 0xC0290017
+	STATUS_TPM_WRONGPCRVAL                                                    NTStatus      = 0xC0290018
+	STATUS_TPM_BAD_PARAM_SIZE                                                 NTStatus      = 0xC0290019
+	STATUS_TPM_SHA_THREAD                                                     NTStatus      = 0xC029001A
+	STATUS_TPM_SHA_ERROR                                                      NTStatus      = 0xC029001B
+	STATUS_TPM_FAILEDSELFTEST                                                 NTStatus      = 0xC029001C
+	STATUS_TPM_AUTH2FAIL                                                      NTStatus      = 0xC029001D
+	STATUS_TPM_BADTAG                                                         NTStatus      = 0xC029001E
+	STATUS_TPM_IOERROR                                                        NTStatus      = 0xC029001F
+	STATUS_TPM_ENCRYPT_ERROR                                                  NTStatus      = 0xC0290020
+	STATUS_TPM_DECRYPT_ERROR                                                  NTStatus      = 0xC0290021
+	STATUS_TPM_INVALID_AUTHHANDLE                                             NTStatus      = 0xC0290022
+	STATUS_TPM_NO_ENDORSEMENT                                                 NTStatus      = 0xC0290023
+	STATUS_TPM_INVALID_KEYUSAGE                                               NTStatus      = 0xC0290024
+	STATUS_TPM_WRONG_ENTITYTYPE                                               NTStatus      = 0xC0290025
+	STATUS_TPM_INVALID_POSTINIT                                               NTStatus      = 0xC0290026
+	STATUS_TPM_INAPPROPRIATE_SIG                                              NTStatus      = 0xC0290027
+	STATUS_TPM_BAD_KEY_PROPERTY                                               NTStatus      = 0xC0290028
+	STATUS_TPM_BAD_MIGRATION                                                  NTStatus      = 0xC0290029
+	STATUS_TPM_BAD_SCHEME                                                     NTStatus      = 0xC029002A
+	STATUS_TPM_BAD_DATASIZE                                                   NTStatus      = 0xC029002B
+	STATUS_TPM_BAD_MODE                                                       NTStatus      = 0xC029002C
+	STATUS_TPM_BAD_PRESENCE                                                   NTStatus      = 0xC029002D
+	STATUS_TPM_BAD_VERSION                                                    NTStatus      = 0xC029002E
+	STATUS_TPM_NO_WRAP_TRANSPORT                                              NTStatus      = 0xC029002F
+	STATUS_TPM_AUDITFAIL_UNSUCCESSFUL                                         NTStatus      = 0xC0290030
+	STATUS_TPM_AUDITFAIL_SUCCESSFUL                                           NTStatus      = 0xC0290031
+	STATUS_TPM_NOTRESETABLE                                                   NTStatus      = 0xC0290032
+	STATUS_TPM_NOTLOCAL                                                       NTStatus      = 0xC0290033
+	STATUS_TPM_BAD_TYPE                                                       NTStatus      = 0xC0290034
+	STATUS_TPM_INVALID_RESOURCE                                               NTStatus      = 0xC0290035
+	STATUS_TPM_NOTFIPS                                                        NTStatus      = 0xC0290036
+	STATUS_TPM_INVALID_FAMILY                                                 NTStatus      = 0xC0290037
+	STATUS_TPM_NO_NV_PERMISSION                                               NTStatus      = 0xC0290038
+	STATUS_TPM_REQUIRES_SIGN                                                  NTStatus      = 0xC0290039
+	STATUS_TPM_KEY_NOTSUPPORTED                                               NTStatus      = 0xC029003A
+	STATUS_TPM_AUTH_CONFLICT                                                  NTStatus      = 0xC029003B
+	STATUS_TPM_AREA_LOCKED                                                    NTStatus      = 0xC029003C
+	STATUS_TPM_BAD_LOCALITY                                                   NTStatus      = 0xC029003D
+	STATUS_TPM_READ_ONLY                                                      NTStatus      = 0xC029003E
+	STATUS_TPM_PER_NOWRITE                                                    NTStatus      = 0xC029003F
+	STATUS_TPM_FAMILYCOUNT                                                    NTStatus      = 0xC0290040
+	STATUS_TPM_WRITE_LOCKED                                                   NTStatus      = 0xC0290041
+	STATUS_TPM_BAD_ATTRIBUTES                                                 NTStatus      = 0xC0290042
+	STATUS_TPM_INVALID_STRUCTURE                                              NTStatus      = 0xC0290043
+	STATUS_TPM_KEY_OWNER_CONTROL                                              NTStatus      = 0xC0290044
+	STATUS_TPM_BAD_COUNTER                                                    NTStatus      = 0xC0290045
+	STATUS_TPM_NOT_FULLWRITE                                                  NTStatus      = 0xC0290046
+	STATUS_TPM_CONTEXT_GAP                                                    NTStatus      = 0xC0290047
+	STATUS_TPM_MAXNVWRITES                                                    NTStatus      = 0xC0290048
+	STATUS_TPM_NOOPERATOR                                                     NTStatus      = 0xC0290049
+	STATUS_TPM_RESOURCEMISSING                                                NTStatus      = 0xC029004A
+	STATUS_TPM_DELEGATE_LOCK                                                  NTStatus      = 0xC029004B
+	STATUS_TPM_DELEGATE_FAMILY                                                NTStatus      = 0xC029004C
+	STATUS_TPM_DELEGATE_ADMIN                                                 NTStatus      = 0xC029004D
+	STATUS_TPM_TRANSPORT_NOTEXCLUSIVE                                         NTStatus      = 0xC029004E
+	STATUS_TPM_OWNER_CONTROL                                                  NTStatus      = 0xC029004F
+	STATUS_TPM_DAA_RESOURCES                                                  NTStatus      = 0xC0290050
+	STATUS_TPM_DAA_INPUT_DATA0                                                NTStatus      = 0xC0290051
+	STATUS_TPM_DAA_INPUT_DATA1                                                NTStatus      = 0xC0290052
+	STATUS_TPM_DAA_ISSUER_SETTINGS                                            NTStatus      = 0xC0290053
+	STATUS_TPM_DAA_TPM_SETTINGS                                               NTStatus      = 0xC0290054
+	STATUS_TPM_DAA_STAGE                                                      NTStatus      = 0xC0290055
+	STATUS_TPM_DAA_ISSUER_VALIDITY                                            NTStatus      = 0xC0290056
+	STATUS_TPM_DAA_WRONG_W                                                    NTStatus      = 0xC0290057
+	STATUS_TPM_BAD_HANDLE                                                     NTStatus      = 0xC0290058
+	STATUS_TPM_BAD_DELEGATE                                                   NTStatus      = 0xC0290059
+	STATUS_TPM_BADCONTEXT                                                     NTStatus      = 0xC029005A
+	STATUS_TPM_TOOMANYCONTEXTS                                                NTStatus      = 0xC029005B
+	STATUS_TPM_MA_TICKET_SIGNATURE                                            NTStatus      = 0xC029005C
+	STATUS_TPM_MA_DESTINATION                                                 NTStatus      = 0xC029005D
+	STATUS_TPM_MA_SOURCE                                                      NTStatus      = 0xC029005E
+	STATUS_TPM_MA_AUTHORITY                                                   NTStatus      = 0xC029005F
+	STATUS_TPM_PERMANENTEK                                                    NTStatus      = 0xC0290061
+	STATUS_TPM_BAD_SIGNATURE                                                  NTStatus      = 0xC0290062
+	STATUS_TPM_NOCONTEXTSPACE                                                 NTStatus      = 0xC0290063
+	STATUS_TPM_20_E_ASYMMETRIC                                                NTStatus      = 0xC0290081
+	STATUS_TPM_20_E_ATTRIBUTES                                                NTStatus      = 0xC0290082
+	STATUS_TPM_20_E_HASH                                                      NTStatus      = 0xC0290083
+	STATUS_TPM_20_E_VALUE                                                     NTStatus      = 0xC0290084
+	STATUS_TPM_20_E_HIERARCHY                                                 NTStatus      = 0xC0290085
+	STATUS_TPM_20_E_KEY_SIZE                                                  NTStatus      = 0xC0290087
+	STATUS_TPM_20_E_MGF                                                       NTStatus      = 0xC0290088
+	STATUS_TPM_20_E_MODE                                                      NTStatus      = 0xC0290089
+	STATUS_TPM_20_E_TYPE                                                      NTStatus      = 0xC029008A
+	STATUS_TPM_20_E_HANDLE                                                    NTStatus      = 0xC029008B
+	STATUS_TPM_20_E_KDF                                                       NTStatus      = 0xC029008C
+	STATUS_TPM_20_E_RANGE                                                     NTStatus      = 0xC029008D
+	STATUS_TPM_20_E_AUTH_FAIL                                                 NTStatus      = 0xC029008E
+	STATUS_TPM_20_E_NONCE                                                     NTStatus      = 0xC029008F
+	STATUS_TPM_20_E_PP                                                        NTStatus      = 0xC0290090
+	STATUS_TPM_20_E_SCHEME                                                    NTStatus      = 0xC0290092
+	STATUS_TPM_20_E_SIZE                                                      NTStatus      = 0xC0290095
+	STATUS_TPM_20_E_SYMMETRIC                                                 NTStatus      = 0xC0290096
+	STATUS_TPM_20_E_TAG                                                       NTStatus      = 0xC0290097
+	STATUS_TPM_20_E_SELECTOR                                                  NTStatus      = 0xC0290098
+	STATUS_TPM_20_E_INSUFFICIENT                                              NTStatus      = 0xC029009A
+	STATUS_TPM_20_E_SIGNATURE                                                 NTStatus      = 0xC029009B
+	STATUS_TPM_20_E_KEY                                                       NTStatus      = 0xC029009C
+	STATUS_TPM_20_E_POLICY_FAIL                                               NTStatus      = 0xC029009D
+	STATUS_TPM_20_E_INTEGRITY                                                 NTStatus      = 0xC029009F
+	STATUS_TPM_20_E_TICKET                                                    NTStatus      = 0xC02900A0
+	STATUS_TPM_20_E_RESERVED_BITS                                             NTStatus      = 0xC02900A1
+	STATUS_TPM_20_E_BAD_AUTH                                                  NTStatus      = 0xC02900A2
+	STATUS_TPM_20_E_EXPIRED                                                   NTStatus      = 0xC02900A3
+	STATUS_TPM_20_E_POLICY_CC                                                 NTStatus      = 0xC02900A4
+	STATUS_TPM_20_E_BINDING                                                   NTStatus      = 0xC02900A5
+	STATUS_TPM_20_E_CURVE                                                     NTStatus      = 0xC02900A6
+	STATUS_TPM_20_E_ECC_POINT                                                 NTStatus      = 0xC02900A7
+	STATUS_TPM_20_E_INITIALIZE                                                NTStatus      = 0xC0290100
+	STATUS_TPM_20_E_FAILURE                                                   NTStatus      = 0xC0290101
+	STATUS_TPM_20_E_SEQUENCE                                                  NTStatus      = 0xC0290103
+	STATUS_TPM_20_E_PRIVATE                                                   NTStatus      = 0xC029010B
+	STATUS_TPM_20_E_HMAC                                                      NTStatus      = 0xC0290119
+	STATUS_TPM_20_E_DISABLED                                                  NTStatus      = 0xC0290120
+	STATUS_TPM_20_E_EXCLUSIVE                                                 NTStatus      = 0xC0290121
+	STATUS_TPM_20_E_ECC_CURVE                                                 NTStatus      = 0xC0290123
+	STATUS_TPM_20_E_AUTH_TYPE                                                 NTStatus      = 0xC0290124
+	STATUS_TPM_20_E_AUTH_MISSING                                              NTStatus      = 0xC0290125
+	STATUS_TPM_20_E_POLICY                                                    NTStatus      = 0xC0290126
+	STATUS_TPM_20_E_PCR                                                       NTStatus      = 0xC0290127
+	STATUS_TPM_20_E_PCR_CHANGED                                               NTStatus      = 0xC0290128
+	STATUS_TPM_20_E_UPGRADE                                                   NTStatus      = 0xC029012D
+	STATUS_TPM_20_E_TOO_MANY_CONTEXTS                                         NTStatus      = 0xC029012E
+	STATUS_TPM_20_E_AUTH_UNAVAILABLE                                          NTStatus      = 0xC029012F
+	STATUS_TPM_20_E_REBOOT                                                    NTStatus      = 0xC0290130
+	STATUS_TPM_20_E_UNBALANCED                                                NTStatus      = 0xC0290131
+	STATUS_TPM_20_E_COMMAND_SIZE                                              NTStatus      = 0xC0290142
+	STATUS_TPM_20_E_COMMAND_CODE                                              NTStatus      = 0xC0290143
+	STATUS_TPM_20_E_AUTHSIZE                                                  NTStatus      = 0xC0290144
+	STATUS_TPM_20_E_AUTH_CONTEXT                                              NTStatus      = 0xC0290145
+	STATUS_TPM_20_E_NV_RANGE                                                  NTStatus      = 0xC0290146
+	STATUS_TPM_20_E_NV_SIZE                                                   NTStatus      = 0xC0290147
+	STATUS_TPM_20_E_NV_LOCKED                                                 NTStatus      = 0xC0290148
+	STATUS_TPM_20_E_NV_AUTHORIZATION                                          NTStatus      = 0xC0290149
+	STATUS_TPM_20_E_NV_UNINITIALIZED                                          NTStatus      = 0xC029014A
+	STATUS_TPM_20_E_NV_SPACE                                                  NTStatus      = 0xC029014B
+	STATUS_TPM_20_E_NV_DEFINED                                                NTStatus      = 0xC029014C
+	STATUS_TPM_20_E_BAD_CONTEXT                                               NTStatus      = 0xC0290150
+	STATUS_TPM_20_E_CPHASH                                                    NTStatus      = 0xC0290151
+	STATUS_TPM_20_E_PARENT                                                    NTStatus      = 0xC0290152
+	STATUS_TPM_20_E_NEEDS_TEST                                                NTStatus      = 0xC0290153
+	STATUS_TPM_20_E_NO_RESULT                                                 NTStatus      = 0xC0290154
+	STATUS_TPM_20_E_SENSITIVE                                                 NTStatus      = 0xC0290155
+	STATUS_TPM_COMMAND_BLOCKED                                                NTStatus      = 0xC0290400
+	STATUS_TPM_INVALID_HANDLE                                                 NTStatus      = 0xC0290401
+	STATUS_TPM_DUPLICATE_VHANDLE                                              NTStatus      = 0xC0290402
+	STATUS_TPM_EMBEDDED_COMMAND_BLOCKED                                       NTStatus      = 0xC0290403
+	STATUS_TPM_EMBEDDED_COMMAND_UNSUPPORTED                                   NTStatus      = 0xC0290404
+	STATUS_TPM_RETRY                                                          NTStatus      = 0xC0290800
+	STATUS_TPM_NEEDS_SELFTEST                                                 NTStatus      = 0xC0290801
+	STATUS_TPM_DOING_SELFTEST                                                 NTStatus      = 0xC0290802
+	STATUS_TPM_DEFEND_LOCK_RUNNING                                            NTStatus      = 0xC0290803
+	STATUS_TPM_COMMAND_CANCELED                                               NTStatus      = 0xC0291001
+	STATUS_TPM_TOO_MANY_CONTEXTS                                              NTStatus      = 0xC0291002
+	STATUS_TPM_NOT_FOUND                                                      NTStatus      = 0xC0291003
+	STATUS_TPM_ACCESS_DENIED                                                  NTStatus      = 0xC0291004
+	STATUS_TPM_INSUFFICIENT_BUFFER                                            NTStatus      = 0xC0291005
+	STATUS_TPM_PPI_FUNCTION_UNSUPPORTED                                       NTStatus      = 0xC0291006
+	STATUS_PCP_ERROR_MASK                                                     NTStatus      = 0xC0292000
+	STATUS_PCP_DEVICE_NOT_READY                                               NTStatus      = 0xC0292001
+	STATUS_PCP_INVALID_HANDLE                                                 NTStatus      = 0xC0292002
+	STATUS_PCP_INVALID_PARAMETER                                              NTStatus      = 0xC0292003
+	STATUS_PCP_FLAG_NOT_SUPPORTED                                             NTStatus      = 0xC0292004
+	STATUS_PCP_NOT_SUPPORTED                                                  NTStatus      = 0xC0292005
+	STATUS_PCP_BUFFER_TOO_SMALL                                               NTStatus      = 0xC0292006
+	STATUS_PCP_INTERNAL_ERROR                                                 NTStatus      = 0xC0292007
+	STATUS_PCP_AUTHENTICATION_FAILED                                          NTStatus      = 0xC0292008
+	STATUS_PCP_AUTHENTICATION_IGNORED                                         NTStatus      = 0xC0292009
+	STATUS_PCP_POLICY_NOT_FOUND                                               NTStatus      = 0xC029200A
+	STATUS_PCP_PROFILE_NOT_FOUND                                              NTStatus      = 0xC029200B
+	STATUS_PCP_VALIDATION_FAILED                                              NTStatus      = 0xC029200C
+	STATUS_PCP_DEVICE_NOT_FOUND                                               NTStatus      = 0xC029200D
+	STATUS_PCP_WRONG_PARENT                                                   NTStatus      = 0xC029200E
+	STATUS_PCP_KEY_NOT_LOADED                                                 NTStatus      = 0xC029200F
+	STATUS_PCP_NO_KEY_CERTIFICATION                                           NTStatus      = 0xC0292010
+	STATUS_PCP_KEY_NOT_FINALIZED                                              NTStatus      = 0xC0292011
+	STATUS_PCP_ATTESTATION_CHALLENGE_NOT_SET                                  NTStatus      = 0xC0292012
+	STATUS_PCP_NOT_PCR_BOUND                                                  NTStatus      = 0xC0292013
+	STATUS_PCP_KEY_ALREADY_FINALIZED                                          NTStatus      = 0xC0292014
+	STATUS_PCP_KEY_USAGE_POLICY_NOT_SUPPORTED                                 NTStatus      = 0xC0292015
+	STATUS_PCP_KEY_USAGE_POLICY_INVALID                                       NTStatus      = 0xC0292016
+	STATUS_PCP_SOFT_KEY_ERROR                                                 NTStatus      = 0xC0292017
+	STATUS_PCP_KEY_NOT_AUTHENTICATED                                          NTStatus      = 0xC0292018
+	STATUS_PCP_KEY_NOT_AIK                                                    NTStatus      = 0xC0292019
+	STATUS_PCP_KEY_NOT_SIGNING_KEY                                            NTStatus      = 0xC029201A
+	STATUS_PCP_LOCKED_OUT                                                     NTStatus      = 0xC029201B
+	STATUS_PCP_CLAIM_TYPE_NOT_SUPPORTED                                       NTStatus      = 0xC029201C
+	STATUS_PCP_TPM_VERSION_NOT_SUPPORTED                                      NTStatus      = 0xC029201D
+	STATUS_PCP_BUFFER_LENGTH_MISMATCH                                         NTStatus      = 0xC029201E
+	STATUS_PCP_IFX_RSA_KEY_CREATION_BLOCKED                                   NTStatus      = 0xC029201F
+	STATUS_PCP_TICKET_MISSING                                                 NTStatus      = 0xC0292020
+	STATUS_PCP_RAW_POLICY_NOT_SUPPORTED                                       NTStatus      = 0xC0292021
+	STATUS_PCP_KEY_HANDLE_INVALIDATED                                         NTStatus      = 0xC0292022
+	STATUS_PCP_UNSUPPORTED_PSS_SALT                                           NTStatus      = 0x40292023
+	STATUS_RTPM_CONTEXT_CONTINUE                                              NTStatus      = 0x00293000
+	STATUS_RTPM_CONTEXT_COMPLETE                                              NTStatus      = 0x00293001
+	STATUS_RTPM_NO_RESULT                                                     NTStatus      = 0xC0293002
+	STATUS_RTPM_PCR_READ_INCOMPLETE                                           NTStatus      = 0xC0293003
+	STATUS_RTPM_INVALID_CONTEXT                                               NTStatus      = 0xC0293004
+	STATUS_RTPM_UNSUPPORTED_CMD                                               NTStatus      = 0xC0293005
+	STATUS_TPM_ZERO_EXHAUST_ENABLED                                           NTStatus      = 0xC0294000
+	STATUS_HV_INVALID_HYPERCALL_CODE                                          NTStatus      = 0xC0350002
+	STATUS_HV_INVALID_HYPERCALL_INPUT                                         NTStatus      = 0xC0350003
+	STATUS_HV_INVALID_ALIGNMENT                                               NTStatus      = 0xC0350004
+	STATUS_HV_INVALID_PARAMETER                                               NTStatus      = 0xC0350005
+	STATUS_HV_ACCESS_DENIED                                                   NTStatus      = 0xC0350006
+	STATUS_HV_INVALID_PARTITION_STATE                                         NTStatus      = 0xC0350007
+	STATUS_HV_OPERATION_DENIED                                                NTStatus      = 0xC0350008
+	STATUS_HV_UNKNOWN_PROPERTY                                                NTStatus      = 0xC0350009
+	STATUS_HV_PROPERTY_VALUE_OUT_OF_RANGE                                     NTStatus      = 0xC035000A
+	STATUS_HV_INSUFFICIENT_MEMORY                                             NTStatus      = 0xC035000B
+	STATUS_HV_PARTITION_TOO_DEEP                                              NTStatus      = 0xC035000C
+	STATUS_HV_INVALID_PARTITION_ID                                            NTStatus      = 0xC035000D
+	STATUS_HV_INVALID_VP_INDEX                                                NTStatus      = 0xC035000E
+	STATUS_HV_INVALID_PORT_ID                                                 NTStatus      = 0xC0350011
+	STATUS_HV_INVALID_CONNECTION_ID                                           NTStatus      = 0xC0350012
+	STATUS_HV_INSUFFICIENT_BUFFERS                                            NTStatus      = 0xC0350013
+	STATUS_HV_NOT_ACKNOWLEDGED                                                NTStatus      = 0xC0350014
+	STATUS_HV_INVALID_VP_STATE                                                NTStatus      = 0xC0350015
+	STATUS_HV_ACKNOWLEDGED                                                    NTStatus      = 0xC0350016
+	STATUS_HV_INVALID_SAVE_RESTORE_STATE                                      NTStatus      = 0xC0350017
+	STATUS_HV_INVALID_SYNIC_STATE                                             NTStatus      = 0xC0350018
+	STATUS_HV_OBJECT_IN_USE                                                   NTStatus      = 0xC0350019
+	STATUS_HV_INVALID_PROXIMITY_DOMAIN_INFO                                   NTStatus      = 0xC035001A
+	STATUS_HV_NO_DATA                                                         NTStatus      = 0xC035001B
+	STATUS_HV_INACTIVE                                                        NTStatus      = 0xC035001C
+	STATUS_HV_NO_RESOURCES                                                    NTStatus      = 0xC035001D
+	STATUS_HV_FEATURE_UNAVAILABLE                                             NTStatus      = 0xC035001E
+	STATUS_HV_INSUFFICIENT_BUFFER                                             NTStatus      = 0xC0350033
+	STATUS_HV_INSUFFICIENT_DEVICE_DOMAINS                                     NTStatus      = 0xC0350038
+	STATUS_HV_CPUID_FEATURE_VALIDATION_ERROR                                  NTStatus      = 0xC035003C
+	STATUS_HV_CPUID_XSAVE_FEATURE_VALIDATION_ERROR                            NTStatus      = 0xC035003D
+	STATUS_HV_PROCESSOR_STARTUP_TIMEOUT                                       NTStatus      = 0xC035003E
+	STATUS_HV_SMX_ENABLED                                                     NTStatus      = 0xC035003F
+	STATUS_HV_INVALID_LP_INDEX                                                NTStatus      = 0xC0350041
+	STATUS_HV_INVALID_REGISTER_VALUE                                          NTStatus      = 0xC0350050
+	STATUS_HV_INVALID_VTL_STATE                                               NTStatus      = 0xC0350051
+	STATUS_HV_NX_NOT_DETECTED                                                 NTStatus      = 0xC0350055
+	STATUS_HV_INVALID_DEVICE_ID                                               NTStatus      = 0xC0350057
+	STATUS_HV_INVALID_DEVICE_STATE                                            NTStatus      = 0xC0350058
+	STATUS_HV_PENDING_PAGE_REQUESTS                                           NTStatus      = 0x00350059
+	STATUS_HV_PAGE_REQUEST_INVALID                                            NTStatus      = 0xC0350060
+	STATUS_HV_INVALID_CPU_GROUP_ID                                            NTStatus      = 0xC035006F
+	STATUS_HV_INVALID_CPU_GROUP_STATE                                         NTStatus      = 0xC0350070
+	STATUS_HV_OPERATION_FAILED                                                NTStatus      = 0xC0350071
+	STATUS_HV_NOT_ALLOWED_WITH_NESTED_VIRT_ACTIVE                             NTStatus      = 0xC0350072
+	STATUS_HV_INSUFFICIENT_ROOT_MEMORY                                        NTStatus      = 0xC0350073
+	STATUS_HV_NOT_PRESENT                                                     NTStatus      = 0xC0351000
+	STATUS_VID_DUPLICATE_HANDLER                                              NTStatus      = 0xC0370001
+	STATUS_VID_TOO_MANY_HANDLERS                                              NTStatus      = 0xC0370002
+	STATUS_VID_QUEUE_FULL                                                     NTStatus      = 0xC0370003
+	STATUS_VID_HANDLER_NOT_PRESENT                                            NTStatus      = 0xC0370004
+	STATUS_VID_INVALID_OBJECT_NAME                                            NTStatus      = 0xC0370005
+	STATUS_VID_PARTITION_NAME_TOO_LONG                                        NTStatus      = 0xC0370006
+	STATUS_VID_MESSAGE_QUEUE_NAME_TOO_LONG                                    NTStatus      = 0xC0370007
+	STATUS_VID_PARTITION_ALREADY_EXISTS                                       NTStatus      = 0xC0370008
+	STATUS_VID_PARTITION_DOES_NOT_EXIST                                       NTStatus      = 0xC0370009
+	STATUS_VID_PARTITION_NAME_NOT_FOUND                                       NTStatus      = 0xC037000A
+	STATUS_VID_MESSAGE_QUEUE_ALREADY_EXISTS                                   NTStatus      = 0xC037000B
+	STATUS_VID_EXCEEDED_MBP_ENTRY_MAP_LIMIT                                   NTStatus      = 0xC037000C
+	STATUS_VID_MB_STILL_REFERENCED                                            NTStatus      = 0xC037000D
+	STATUS_VID_CHILD_GPA_PAGE_SET_CORRUPTED                                   NTStatus      = 0xC037000E
+	STATUS_VID_INVALID_NUMA_SETTINGS                                          NTStatus      = 0xC037000F
+	STATUS_VID_INVALID_NUMA_NODE_INDEX                                        NTStatus      = 0xC0370010
+	STATUS_VID_NOTIFICATION_QUEUE_ALREADY_ASSOCIATED                          NTStatus      = 0xC0370011
+	STATUS_VID_INVALID_MEMORY_BLOCK_HANDLE                                    NTStatus      = 0xC0370012
+	STATUS_VID_PAGE_RANGE_OVERFLOW                                            NTStatus      = 0xC0370013
+	STATUS_VID_INVALID_MESSAGE_QUEUE_HANDLE                                   NTStatus      = 0xC0370014
+	STATUS_VID_INVALID_GPA_RANGE_HANDLE                                       NTStatus      = 0xC0370015
+	STATUS_VID_NO_MEMORY_BLOCK_NOTIFICATION_QUEUE                             NTStatus      = 0xC0370016
+	STATUS_VID_MEMORY_BLOCK_LOCK_COUNT_EXCEEDED                               NTStatus      = 0xC0370017
+	STATUS_VID_INVALID_PPM_HANDLE                                             NTStatus      = 0xC0370018
+	STATUS_VID_MBPS_ARE_LOCKED                                                NTStatus      = 0xC0370019
+	STATUS_VID_MESSAGE_QUEUE_CLOSED                                           NTStatus      = 0xC037001A
+	STATUS_VID_VIRTUAL_PROCESSOR_LIMIT_EXCEEDED                               NTStatus      = 0xC037001B
+	STATUS_VID_STOP_PENDING                                                   NTStatus      = 0xC037001C
+	STATUS_VID_INVALID_PROCESSOR_STATE                                        NTStatus      = 0xC037001D
+	STATUS_VID_EXCEEDED_KM_CONTEXT_COUNT_LIMIT                                NTStatus      = 0xC037001E
+	STATUS_VID_KM_INTERFACE_ALREADY_INITIALIZED                               NTStatus      = 0xC037001F
+	STATUS_VID_MB_PROPERTY_ALREADY_SET_RESET                                  NTStatus      = 0xC0370020
+	STATUS_VID_MMIO_RANGE_DESTROYED                                           NTStatus      = 0xC0370021
+	STATUS_VID_INVALID_CHILD_GPA_PAGE_SET                                     NTStatus      = 0xC0370022
+	STATUS_VID_RESERVE_PAGE_SET_IS_BEING_USED                                 NTStatus      = 0xC0370023
+	STATUS_VID_RESERVE_PAGE_SET_TOO_SMALL                                     NTStatus      = 0xC0370024
+	STATUS_VID_MBP_ALREADY_LOCKED_USING_RESERVED_PAGE                         NTStatus      = 0xC0370025
+	STATUS_VID_MBP_COUNT_EXCEEDED_LIMIT                                       NTStatus      = 0xC0370026
+	STATUS_VID_SAVED_STATE_CORRUPT                                            NTStatus      = 0xC0370027
+	STATUS_VID_SAVED_STATE_UNRECOGNIZED_ITEM                                  NTStatus      = 0xC0370028
+	STATUS_VID_SAVED_STATE_INCOMPATIBLE                                       NTStatus      = 0xC0370029
+	STATUS_VID_VTL_ACCESS_DENIED                                              NTStatus      = 0xC037002A
+	STATUS_VID_REMOTE_NODE_PARENT_GPA_PAGES_USED                              NTStatus      = 0x80370001
+	STATUS_IPSEC_BAD_SPI                                                      NTStatus      = 0xC0360001
+	STATUS_IPSEC_SA_LIFETIME_EXPIRED                                          NTStatus      = 0xC0360002
+	STATUS_IPSEC_WRONG_SA                                                     NTStatus      = 0xC0360003
+	STATUS_IPSEC_REPLAY_CHECK_FAILED                                          NTStatus      = 0xC0360004
+	STATUS_IPSEC_INVALID_PACKET                                               NTStatus      = 0xC0360005
+	STATUS_IPSEC_INTEGRITY_CHECK_FAILED                                       NTStatus      = 0xC0360006
+	STATUS_IPSEC_CLEAR_TEXT_DROP                                              NTStatus      = 0xC0360007
+	STATUS_IPSEC_AUTH_FIREWALL_DROP                                           NTStatus      = 0xC0360008
+	STATUS_IPSEC_THROTTLE_DROP                                                NTStatus      = 0xC0360009
+	STATUS_IPSEC_DOSP_BLOCK                                                   NTStatus      = 0xC0368000
+	STATUS_IPSEC_DOSP_RECEIVED_MULTICAST                                      NTStatus      = 0xC0368001
+	STATUS_IPSEC_DOSP_INVALID_PACKET                                          NTStatus      = 0xC0368002
+	STATUS_IPSEC_DOSP_STATE_LOOKUP_FAILED                                     NTStatus      = 0xC0368003
+	STATUS_IPSEC_DOSP_MAX_ENTRIES                                             NTStatus      = 0xC0368004
+	STATUS_IPSEC_DOSP_KEYMOD_NOT_ALLOWED                                      NTStatus      = 0xC0368005
+	STATUS_IPSEC_DOSP_MAX_PER_IP_RATELIMIT_QUEUES                             NTStatus      = 0xC0368006
+	STATUS_VOLMGR_INCOMPLETE_REGENERATION                                     NTStatus      = 0x80380001
+	STATUS_VOLMGR_INCOMPLETE_DISK_MIGRATION                                   NTStatus      = 0x80380002
+	STATUS_VOLMGR_DATABASE_FULL                                               NTStatus      = 0xC0380001
+	STATUS_VOLMGR_DISK_CONFIGURATION_CORRUPTED                                NTStatus      = 0xC0380002
+	STATUS_VOLMGR_DISK_CONFIGURATION_NOT_IN_SYNC                              NTStatus      = 0xC0380003
+	STATUS_VOLMGR_PACK_CONFIG_UPDATE_FAILED                                   NTStatus      = 0xC0380004
+	STATUS_VOLMGR_DISK_CONTAINS_NON_SIMPLE_VOLUME                             NTStatus      = 0xC0380005
+	STATUS_VOLMGR_DISK_DUPLICATE                                              NTStatus      = 0xC0380006
+	STATUS_VOLMGR_DISK_DYNAMIC                                                NTStatus      = 0xC0380007
+	STATUS_VOLMGR_DISK_ID_INVALID                                             NTStatus      = 0xC0380008
+	STATUS_VOLMGR_DISK_INVALID                                                NTStatus      = 0xC0380009
+	STATUS_VOLMGR_DISK_LAST_VOTER                                             NTStatus      = 0xC038000A
+	STATUS_VOLMGR_DISK_LAYOUT_INVALID                                         NTStatus      = 0xC038000B
+	STATUS_VOLMGR_DISK_LAYOUT_NON_BASIC_BETWEEN_BASIC_PARTITIONS              NTStatus      = 0xC038000C
+	STATUS_VOLMGR_DISK_LAYOUT_NOT_CYLINDER_ALIGNED                            NTStatus      = 0xC038000D
+	STATUS_VOLMGR_DISK_LAYOUT_PARTITIONS_TOO_SMALL                            NTStatus      = 0xC038000E
+	STATUS_VOLMGR_DISK_LAYOUT_PRIMARY_BETWEEN_LOGICAL_PARTITIONS              NTStatus      = 0xC038000F
+	STATUS_VOLMGR_DISK_LAYOUT_TOO_MANY_PARTITIONS                             NTStatus      = 0xC0380010
+	STATUS_VOLMGR_DISK_MISSING                                                NTStatus      = 0xC0380011
+	STATUS_VOLMGR_DISK_NOT_EMPTY                                              NTStatus      = 0xC0380012
+	STATUS_VOLMGR_DISK_NOT_ENOUGH_SPACE                                       NTStatus      = 0xC0380013
+	STATUS_VOLMGR_DISK_REVECTORING_FAILED                                     NTStatus      = 0xC0380014
+	STATUS_VOLMGR_DISK_SECTOR_SIZE_INVALID                                    NTStatus      = 0xC0380015
+	STATUS_VOLMGR_DISK_SET_NOT_CONTAINED                                      NTStatus      = 0xC0380016
+	STATUS_VOLMGR_DISK_USED_BY_MULTIPLE_MEMBERS                               NTStatus      = 0xC0380017
+	STATUS_VOLMGR_DISK_USED_BY_MULTIPLE_PLEXES                                NTStatus      = 0xC0380018
+	STATUS_VOLMGR_DYNAMIC_DISK_NOT_SUPPORTED                                  NTStatus      = 0xC0380019
+	STATUS_VOLMGR_EXTENT_ALREADY_USED                                         NTStatus      = 0xC038001A
+	STATUS_VOLMGR_EXTENT_NOT_CONTIGUOUS                                       NTStatus      = 0xC038001B
+	STATUS_VOLMGR_EXTENT_NOT_IN_PUBLIC_REGION                                 NTStatus      = 0xC038001C
+	STATUS_VOLMGR_EXTENT_NOT_SECTOR_ALIGNED                                   NTStatus      = 0xC038001D
+	STATUS_VOLMGR_EXTENT_OVERLAPS_EBR_PARTITION                               NTStatus      = 0xC038001E
+	STATUS_VOLMGR_EXTENT_VOLUME_LENGTHS_DO_NOT_MATCH                          NTStatus      = 0xC038001F
+	STATUS_VOLMGR_FAULT_TOLERANT_NOT_SUPPORTED                                NTStatus      = 0xC0380020
+	STATUS_VOLMGR_INTERLEAVE_LENGTH_INVALID                                   NTStatus      = 0xC0380021
+	STATUS_VOLMGR_MAXIMUM_REGISTERED_USERS                                    NTStatus      = 0xC0380022
+	STATUS_VOLMGR_MEMBER_IN_SYNC                                              NTStatus      = 0xC0380023
+	STATUS_VOLMGR_MEMBER_INDEX_DUPLICATE                                      NTStatus      = 0xC0380024
+	STATUS_VOLMGR_MEMBER_INDEX_INVALID                                        NTStatus      = 0xC0380025
+	STATUS_VOLMGR_MEMBER_MISSING                                              NTStatus      = 0xC0380026
+	STATUS_VOLMGR_MEMBER_NOT_DETACHED                                         NTStatus      = 0xC0380027
+	STATUS_VOLMGR_MEMBER_REGENERATING                                         NTStatus      = 0xC0380028
+	STATUS_VOLMGR_ALL_DISKS_FAILED                                            NTStatus      = 0xC0380029
+	STATUS_VOLMGR_NO_REGISTERED_USERS                                         NTStatus      = 0xC038002A
+	STATUS_VOLMGR_NO_SUCH_USER                                                NTStatus      = 0xC038002B
+	STATUS_VOLMGR_NOTIFICATION_RESET                                          NTStatus      = 0xC038002C
+	STATUS_VOLMGR_NUMBER_OF_MEMBERS_INVALID                                   NTStatus      = 0xC038002D
+	STATUS_VOLMGR_NUMBER_OF_PLEXES_INVALID                                    NTStatus      = 0xC038002E
+	STATUS_VOLMGR_PACK_DUPLICATE                                              NTStatus      = 0xC038002F
+	STATUS_VOLMGR_PACK_ID_INVALID                                             NTStatus      = 0xC0380030
+	STATUS_VOLMGR_PACK_INVALID                                                NTStatus      = 0xC0380031
+	STATUS_VOLMGR_PACK_NAME_INVALID                                           NTStatus      = 0xC0380032
+	STATUS_VOLMGR_PACK_OFFLINE                                                NTStatus      = 0xC0380033
+	STATUS_VOLMGR_PACK_HAS_QUORUM                                             NTStatus      = 0xC0380034
+	STATUS_VOLMGR_PACK_WITHOUT_QUORUM                                         NTStatus      = 0xC0380035
+	STATUS_VOLMGR_PARTITION_STYLE_INVALID                                     NTStatus      = 0xC0380036
+	STATUS_VOLMGR_PARTITION_UPDATE_FAILED                                     NTStatus      = 0xC0380037
+	STATUS_VOLMGR_PLEX_IN_SYNC                                                NTStatus      = 0xC0380038
+	STATUS_VOLMGR_PLEX_INDEX_DUPLICATE                                        NTStatus      = 0xC0380039
+	STATUS_VOLMGR_PLEX_INDEX_INVALID                                          NTStatus      = 0xC038003A
+	STATUS_VOLMGR_PLEX_LAST_ACTIVE                                            NTStatus      = 0xC038003B
+	STATUS_VOLMGR_PLEX_MISSING                                                NTStatus      = 0xC038003C
+	STATUS_VOLMGR_PLEX_REGENERATING                                           NTStatus      = 0xC038003D
+	STATUS_VOLMGR_PLEX_TYPE_INVALID                                           NTStatus      = 0xC038003E
+	STATUS_VOLMGR_PLEX_NOT_RAID5                                              NTStatus      = 0xC038003F
+	STATUS_VOLMGR_PLEX_NOT_SIMPLE                                             NTStatus      = 0xC0380040
+	STATUS_VOLMGR_STRUCTURE_SIZE_INVALID                                      NTStatus      = 0xC0380041
+	STATUS_VOLMGR_TOO_MANY_NOTIFICATION_REQUESTS                              NTStatus      = 0xC0380042
+	STATUS_VOLMGR_TRANSACTION_IN_PROGRESS                                     NTStatus      = 0xC0380043
+	STATUS_VOLMGR_UNEXPECTED_DISK_LAYOUT_CHANGE                               NTStatus      = 0xC0380044
+	STATUS_VOLMGR_VOLUME_CONTAINS_MISSING_DISK                                NTStatus      = 0xC0380045
+	STATUS_VOLMGR_VOLUME_ID_INVALID                                           NTStatus      = 0xC0380046
+	STATUS_VOLMGR_VOLUME_LENGTH_INVALID                                       NTStatus      = 0xC0380047
+	STATUS_VOLMGR_VOLUME_LENGTH_NOT_SECTOR_SIZE_MULTIPLE                      NTStatus      = 0xC0380048
+	STATUS_VOLMGR_VOLUME_NOT_MIRRORED                                         NTStatus      = 0xC0380049
+	STATUS_VOLMGR_VOLUME_NOT_RETAINED                                         NTStatus      = 0xC038004A
+	STATUS_VOLMGR_VOLUME_OFFLINE                                              NTStatus      = 0xC038004B
+	STATUS_VOLMGR_VOLUME_RETAINED                                             NTStatus      = 0xC038004C
+	STATUS_VOLMGR_NUMBER_OF_EXTENTS_INVALID                                   NTStatus      = 0xC038004D
+	STATUS_VOLMGR_DIFFERENT_SECTOR_SIZE                                       NTStatus      = 0xC038004E
+	STATUS_VOLMGR_BAD_BOOT_DISK                                               NTStatus      = 0xC038004F
+	STATUS_VOLMGR_PACK_CONFIG_OFFLINE                                         NTStatus      = 0xC0380050
+	STATUS_VOLMGR_PACK_CONFIG_ONLINE                                          NTStatus      = 0xC0380051
+	STATUS_VOLMGR_NOT_PRIMARY_PACK                                            NTStatus      = 0xC0380052
+	STATUS_VOLMGR_PACK_LOG_UPDATE_FAILED                                      NTStatus      = 0xC0380053
+	STATUS_VOLMGR_NUMBER_OF_DISKS_IN_PLEX_INVALID                             NTStatus      = 0xC0380054
+	STATUS_VOLMGR_NUMBER_OF_DISKS_IN_MEMBER_INVALID                           NTStatus      = 0xC0380055
+	STATUS_VOLMGR_VOLUME_MIRRORED                                             NTStatus      = 0xC0380056
+	STATUS_VOLMGR_PLEX_NOT_SIMPLE_SPANNED                                     NTStatus      = 0xC0380057
+	STATUS_VOLMGR_NO_VALID_LOG_COPIES                                         NTStatus      = 0xC0380058
+	STATUS_VOLMGR_PRIMARY_PACK_PRESENT                                        NTStatus      = 0xC0380059
+	STATUS_VOLMGR_NUMBER_OF_DISKS_INVALID                                     NTStatus      = 0xC038005A
+	STATUS_VOLMGR_MIRROR_NOT_SUPPORTED                                        NTStatus      = 0xC038005B
+	STATUS_VOLMGR_RAID5_NOT_SUPPORTED                                         NTStatus      = 0xC038005C
+	STATUS_BCD_NOT_ALL_ENTRIES_IMPORTED                                       NTStatus      = 0x80390001
+	STATUS_BCD_TOO_MANY_ELEMENTS                                              NTStatus      = 0xC0390002
+	STATUS_BCD_NOT_ALL_ENTRIES_SYNCHRONIZED                                   NTStatus      = 0x80390003
+	STATUS_VHD_DRIVE_FOOTER_MISSING                                           NTStatus      = 0xC03A0001
+	STATUS_VHD_DRIVE_FOOTER_CHECKSUM_MISMATCH                                 NTStatus      = 0xC03A0002
+	STATUS_VHD_DRIVE_FOOTER_CORRUPT                                           NTStatus      = 0xC03A0003
+	STATUS_VHD_FORMAT_UNKNOWN                                                 NTStatus      = 0xC03A0004
+	STATUS_VHD_FORMAT_UNSUPPORTED_VERSION                                     NTStatus      = 0xC03A0005
+	STATUS_VHD_SPARSE_HEADER_CHECKSUM_MISMATCH                                NTStatus      = 0xC03A0006
+	STATUS_VHD_SPARSE_HEADER_UNSUPPORTED_VERSION                              NTStatus      = 0xC03A0007
+	STATUS_VHD_SPARSE_HEADER_CORRUPT                                          NTStatus      = 0xC03A0008
+	STATUS_VHD_BLOCK_ALLOCATION_FAILURE                                       NTStatus      = 0xC03A0009
+	STATUS_VHD_BLOCK_ALLOCATION_TABLE_CORRUPT                                 NTStatus      = 0xC03A000A
+	STATUS_VHD_INVALID_BLOCK_SIZE                                             NTStatus      = 0xC03A000B
+	STATUS_VHD_BITMAP_MISMATCH                                                NTStatus      = 0xC03A000C
+	STATUS_VHD_PARENT_VHD_NOT_FOUND                                           NTStatus      = 0xC03A000D
+	STATUS_VHD_CHILD_PARENT_ID_MISMATCH                                       NTStatus      = 0xC03A000E
+	STATUS_VHD_CHILD_PARENT_TIMESTAMP_MISMATCH                                NTStatus      = 0xC03A000F
+	STATUS_VHD_METADATA_READ_FAILURE                                          NTStatus      = 0xC03A0010
+	STATUS_VHD_METADATA_WRITE_FAILURE                                         NTStatus      = 0xC03A0011
+	STATUS_VHD_INVALID_SIZE                                                   NTStatus      = 0xC03A0012
+	STATUS_VHD_INVALID_FILE_SIZE                                              NTStatus      = 0xC03A0013
+	STATUS_VIRTDISK_PROVIDER_NOT_FOUND                                        NTStatus      = 0xC03A0014
+	STATUS_VIRTDISK_NOT_VIRTUAL_DISK                                          NTStatus      = 0xC03A0015
+	STATUS_VHD_PARENT_VHD_ACCESS_DENIED                                       NTStatus      = 0xC03A0016
+	STATUS_VHD_CHILD_PARENT_SIZE_MISMATCH                                     NTStatus      = 0xC03A0017
+	STATUS_VHD_DIFFERENCING_CHAIN_CYCLE_DETECTED                              NTStatus      = 0xC03A0018
+	STATUS_VHD_DIFFERENCING_CHAIN_ERROR_IN_PARENT                             NTStatus      = 0xC03A0019
+	STATUS_VIRTUAL_DISK_LIMITATION                                            NTStatus      = 0xC03A001A
+	STATUS_VHD_INVALID_TYPE                                                   NTStatus      = 0xC03A001B
+	STATUS_VHD_INVALID_STATE                                                  NTStatus      = 0xC03A001C
+	STATUS_VIRTDISK_UNSUPPORTED_DISK_SECTOR_SIZE                              NTStatus      = 0xC03A001D
+	STATUS_VIRTDISK_DISK_ALREADY_OWNED                                        NTStatus      = 0xC03A001E
+	STATUS_VIRTDISK_DISK_ONLINE_AND_WRITABLE                                  NTStatus      = 0xC03A001F
+	STATUS_CTLOG_TRACKING_NOT_INITIALIZED                                     NTStatus      = 0xC03A0020
+	STATUS_CTLOG_LOGFILE_SIZE_EXCEEDED_MAXSIZE                                NTStatus      = 0xC03A0021
+	STATUS_CTLOG_VHD_CHANGED_OFFLINE                                          NTStatus      = 0xC03A0022
+	STATUS_CTLOG_INVALID_TRACKING_STATE                                       NTStatus      = 0xC03A0023
+	STATUS_CTLOG_INCONSISTENT_TRACKING_FILE                                   NTStatus      = 0xC03A0024
+	STATUS_VHD_METADATA_FULL                                                  NTStatus      = 0xC03A0028
+	STATUS_VHD_INVALID_CHANGE_TRACKING_ID                                     NTStatus      = 0xC03A0029
+	STATUS_VHD_CHANGE_TRACKING_DISABLED                                       NTStatus      = 0xC03A002A
+	STATUS_VHD_MISSING_CHANGE_TRACKING_INFORMATION                            NTStatus      = 0xC03A0030
+	STATUS_VHD_RESIZE_WOULD_TRUNCATE_DATA                                     NTStatus      = 0xC03A0031
+	STATUS_VHD_COULD_NOT_COMPUTE_MINIMUM_VIRTUAL_SIZE                         NTStatus      = 0xC03A0032
+	STATUS_VHD_ALREADY_AT_OR_BELOW_MINIMUM_VIRTUAL_SIZE                       NTStatus      = 0xC03A0033
+	STATUS_QUERY_STORAGE_ERROR                                                NTStatus      = 0x803A0001
+	STATUS_GDI_HANDLE_LEAK                                                    NTStatus      = 0x803F0001
+	STATUS_RKF_KEY_NOT_FOUND                                                  NTStatus      = 0xC0400001
+	STATUS_RKF_DUPLICATE_KEY                                                  NTStatus      = 0xC0400002
+	STATUS_RKF_BLOB_FULL                                                      NTStatus      = 0xC0400003
+	STATUS_RKF_STORE_FULL                                                     NTStatus      = 0xC0400004
+	STATUS_RKF_FILE_BLOCKED                                                   NTStatus      = 0xC0400005
+	STATUS_RKF_ACTIVE_KEY                                                     NTStatus      = 0xC0400006
+	STATUS_RDBSS_RESTART_OPERATION                                            NTStatus      = 0xC0410001
+	STATUS_RDBSS_CONTINUE_OPERATION                                           NTStatus      = 0xC0410002
+	STATUS_RDBSS_POST_OPERATION                                               NTStatus      = 0xC0410003
+	STATUS_RDBSS_RETRY_LOOKUP                                                 NTStatus      = 0xC0410004
+	STATUS_BTH_ATT_INVALID_HANDLE                                             NTStatus      = 0xC0420001
+	STATUS_BTH_ATT_READ_NOT_PERMITTED                                         NTStatus      = 0xC0420002
+	STATUS_BTH_ATT_WRITE_NOT_PERMITTED                                        NTStatus      = 0xC0420003
+	STATUS_BTH_ATT_INVALID_PDU                                                NTStatus      = 0xC0420004
+	STATUS_BTH_ATT_INSUFFICIENT_AUTHENTICATION                                NTStatus      = 0xC0420005
+	STATUS_BTH_ATT_REQUEST_NOT_SUPPORTED                                      NTStatus      = 0xC0420006
+	STATUS_BTH_ATT_INVALID_OFFSET                                             NTStatus      = 0xC0420007
+	STATUS_BTH_ATT_INSUFFICIENT_AUTHORIZATION                                 NTStatus      = 0xC0420008
+	STATUS_BTH_ATT_PREPARE_QUEUE_FULL                                         NTStatus      = 0xC0420009
+	STATUS_BTH_ATT_ATTRIBUTE_NOT_FOUND                                        NTStatus      = 0xC042000A
+	STATUS_BTH_ATT_ATTRIBUTE_NOT_LONG                                         NTStatus      = 0xC042000B
+	STATUS_BTH_ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZE                           NTStatus      = 0xC042000C
+	STATUS_BTH_ATT_INVALID_ATTRIBUTE_VALUE_LENGTH                             NTStatus      = 0xC042000D
+	STATUS_BTH_ATT_UNLIKELY                                                   NTStatus      = 0xC042000E
+	STATUS_BTH_ATT_INSUFFICIENT_ENCRYPTION                                    NTStatus      = 0xC042000F
+	STATUS_BTH_ATT_UNSUPPORTED_GROUP_TYPE                                     NTStatus      = 0xC0420010
+	STATUS_BTH_ATT_INSUFFICIENT_RESOURCES                                     NTStatus      = 0xC0420011
+	STATUS_BTH_ATT_UNKNOWN_ERROR                                              NTStatus      = 0xC0421000
+	STATUS_SECUREBOOT_ROLLBACK_DETECTED                                       NTStatus      = 0xC0430001
+	STATUS_SECUREBOOT_POLICY_VIOLATION                                        NTStatus      = 0xC0430002
+	STATUS_SECUREBOOT_INVALID_POLICY                                          NTStatus      = 0xC0430003
+	STATUS_SECUREBOOT_POLICY_PUBLISHER_NOT_FOUND                              NTStatus      = 0xC0430004
+	STATUS_SECUREBOOT_POLICY_NOT_SIGNED                                       NTStatus      = 0xC0430005
+	STATUS_SECUREBOOT_NOT_ENABLED                                             NTStatus      = 0x80430006
+	STATUS_SECUREBOOT_FILE_REPLACED                                           NTStatus      = 0xC0430007
+	STATUS_SECUREBOOT_POLICY_NOT_AUTHORIZED                                   NTStatus      = 0xC0430008
+	STATUS_SECUREBOOT_POLICY_UNKNOWN                                          NTStatus      = 0xC0430009
+	STATUS_SECUREBOOT_POLICY_MISSING_ANTIROLLBACKVERSION                      NTStatus      = 0xC043000A
+	STATUS_SECUREBOOT_PLATFORM_ID_MISMATCH                                    NTStatus      = 0xC043000B
+	STATUS_SECUREBOOT_POLICY_ROLLBACK_DETECTED                                NTStatus      = 0xC043000C
+	STATUS_SECUREBOOT_POLICY_UPGRADE_MISMATCH                                 NTStatus      = 0xC043000D
+	STATUS_SECUREBOOT_REQUIRED_POLICY_FILE_MISSING                            NTStatus      = 0xC043000E
+	STATUS_SECUREBOOT_NOT_BASE_POLICY                                         NTStatus      = 0xC043000F
+	STATUS_SECUREBOOT_NOT_SUPPLEMENTAL_POLICY                                 NTStatus      = 0xC0430010
+	STATUS_PLATFORM_MANIFEST_NOT_AUTHORIZED                                   NTStatus      = 0xC0EB0001
+	STATUS_PLATFORM_MANIFEST_INVALID                                          NTStatus      = 0xC0EB0002
+	STATUS_PLATFORM_MANIFEST_FILE_NOT_AUTHORIZED                              NTStatus      = 0xC0EB0003
+	STATUS_PLATFORM_MANIFEST_CATALOG_NOT_AUTHORIZED                           NTStatus      = 0xC0EB0004
+	STATUS_PLATFORM_MANIFEST_BINARY_ID_NOT_FOUND                              NTStatus      = 0xC0EB0005
+	STATUS_PLATFORM_MANIFEST_NOT_ACTIVE                                       NTStatus      = 0xC0EB0006
+	STATUS_PLATFORM_MANIFEST_NOT_SIGNED                                       NTStatus      = 0xC0EB0007
+	STATUS_SYSTEM_INTEGRITY_ROLLBACK_DETECTED                                 NTStatus      = 0xC0E90001
+	STATUS_SYSTEM_INTEGRITY_POLICY_VIOLATION                                  NTStatus      = 0xC0E90002
+	STATUS_SYSTEM_INTEGRITY_INVALID_POLICY                                    NTStatus      = 0xC0E90003
+	STATUS_SYSTEM_INTEGRITY_POLICY_NOT_SIGNED                                 NTStatus      = 0xC0E90004
+	STATUS_SYSTEM_INTEGRITY_TOO_MANY_POLICIES                                 NTStatus      = 0xC0E90005
+	STATUS_SYSTEM_INTEGRITY_SUPPLEMENTAL_POLICY_NOT_AUTHORIZED                NTStatus      = 0xC0E90006
+	STATUS_NO_APPLICABLE_APP_LICENSES_FOUND                                   NTStatus      = 0xC0EA0001
+	STATUS_CLIP_LICENSE_NOT_FOUND                                             NTStatus      = 0xC0EA0002
+	STATUS_CLIP_DEVICE_LICENSE_MISSING                                        NTStatus      = 0xC0EA0003
+	STATUS_CLIP_LICENSE_INVALID_SIGNATURE                                     NTStatus      = 0xC0EA0004
+	STATUS_CLIP_KEYHOLDER_LICENSE_MISSING_OR_INVALID                          NTStatus      = 0xC0EA0005
+	STATUS_CLIP_LICENSE_EXPIRED                                               NTStatus      = 0xC0EA0006
+	STATUS_CLIP_LICENSE_SIGNED_BY_UNKNOWN_SOURCE                              NTStatus      = 0xC0EA0007
+	STATUS_CLIP_LICENSE_NOT_SIGNED                                            NTStatus      = 0xC0EA0008
+	STATUS_CLIP_LICENSE_HARDWARE_ID_OUT_OF_TOLERANCE                          NTStatus      = 0xC0EA0009
+	STATUS_CLIP_LICENSE_DEVICE_ID_MISMATCH                                    NTStatus      = 0xC0EA000A
+	STATUS_AUDIO_ENGINE_NODE_NOT_FOUND                                        NTStatus      = 0xC0440001
+	STATUS_HDAUDIO_EMPTY_CONNECTION_LIST                                      NTStatus      = 0xC0440002
+	STATUS_HDAUDIO_CONNECTION_LIST_NOT_SUPPORTED                              NTStatus      = 0xC0440003
+	STATUS_HDAUDIO_NO_LOGICAL_DEVICES_CREATED                                 NTStatus      = 0xC0440004
+	STATUS_HDAUDIO_NULL_LINKED_LIST_ENTRY                                     NTStatus      = 0xC0440005
+	STATUS_SPACES_REPAIRED                                                    NTStatus      = 0x00E70000
+	STATUS_SPACES_PAUSE                                                       NTStatus      = 0x00E70001
+	STATUS_SPACES_COMPLETE                                                    NTStatus      = 0x00E70002
+	STATUS_SPACES_REDIRECT                                                    NTStatus      = 0x00E70003
+	STATUS_SPACES_FAULT_DOMAIN_TYPE_INVALID                                   NTStatus      = 0xC0E70001
+	STATUS_SPACES_RESILIENCY_TYPE_INVALID                                     NTStatus      = 0xC0E70003
+	STATUS_SPACES_DRIVE_SECTOR_SIZE_INVALID                                   NTStatus      = 0xC0E70004
+	STATUS_SPACES_DRIVE_REDUNDANCY_INVALID                                    NTStatus      = 0xC0E70006
+	STATUS_SPACES_NUMBER_OF_DATA_COPIES_INVALID                               NTStatus      = 0xC0E70007
+	STATUS_SPACES_INTERLEAVE_LENGTH_INVALID                                   NTStatus      = 0xC0E70009
+	STATUS_SPACES_NUMBER_OF_COLUMNS_INVALID                                   NTStatus      = 0xC0E7000A
+	STATUS_SPACES_NOT_ENOUGH_DRIVES                                           NTStatus      = 0xC0E7000B
+	STATUS_SPACES_EXTENDED_ERROR                                              NTStatus      = 0xC0E7000C
+	STATUS_SPACES_PROVISIONING_TYPE_INVALID                                   NTStatus      = 0xC0E7000D
+	STATUS_SPACES_ALLOCATION_SIZE_INVALID                                     NTStatus      = 0xC0E7000E
+	STATUS_SPACES_ENCLOSURE_AWARE_INVALID                                     NTStatus      = 0xC0E7000F
+	STATUS_SPACES_WRITE_CACHE_SIZE_INVALID                                    NTStatus      = 0xC0E70010
+	STATUS_SPACES_NUMBER_OF_GROUPS_INVALID                                    NTStatus      = 0xC0E70011
+	STATUS_SPACES_DRIVE_OPERATIONAL_STATE_INVALID                             NTStatus      = 0xC0E70012
+	STATUS_SPACES_UPDATE_COLUMN_STATE                                         NTStatus      = 0xC0E70013
+	STATUS_SPACES_MAP_REQUIRED                                                NTStatus      = 0xC0E70014
+	STATUS_SPACES_UNSUPPORTED_VERSION                                         NTStatus      = 0xC0E70015
+	STATUS_SPACES_CORRUPT_METADATA                                            NTStatus      = 0xC0E70016
+	STATUS_SPACES_DRT_FULL                                                    NTStatus      = 0xC0E70017
+	STATUS_SPACES_INCONSISTENCY                                               NTStatus      = 0xC0E70018
+	STATUS_SPACES_LOG_NOT_READY                                               NTStatus      = 0xC0E70019
+	STATUS_SPACES_NO_REDUNDANCY                                               NTStatus      = 0xC0E7001A
+	STATUS_SPACES_DRIVE_NOT_READY                                             NTStatus      = 0xC0E7001B
+	STATUS_SPACES_DRIVE_SPLIT                                                 NTStatus      = 0xC0E7001C
+	STATUS_SPACES_DRIVE_LOST_DATA                                             NTStatus      = 0xC0E7001D
+	STATUS_SPACES_ENTRY_INCOMPLETE                                            NTStatus      = 0xC0E7001E
+	STATUS_SPACES_ENTRY_INVALID                                               NTStatus      = 0xC0E7001F
+	STATUS_SPACES_MARK_DIRTY                                                  NTStatus      = 0xC0E70020
+	STATUS_VOLSNAP_BOOTFILE_NOT_VALID                                         NTStatus      = 0xC0500003
+	STATUS_VOLSNAP_ACTIVATION_TIMEOUT                                         NTStatus      = 0xC0500004
+	STATUS_IO_PREEMPTED                                                       NTStatus      = 0xC0510001
+	STATUS_SVHDX_ERROR_STORED                                                 NTStatus      = 0xC05C0000
+	STATUS_SVHDX_ERROR_NOT_AVAILABLE                                          NTStatus      = 0xC05CFF00
+	STATUS_SVHDX_UNIT_ATTENTION_AVAILABLE                                     NTStatus      = 0xC05CFF01
+	STATUS_SVHDX_UNIT_ATTENTION_CAPACITY_DATA_CHANGED                         NTStatus      = 0xC05CFF02
+	STATUS_SVHDX_UNIT_ATTENTION_RESERVATIONS_PREEMPTED                        NTStatus      = 0xC05CFF03
+	STATUS_SVHDX_UNIT_ATTENTION_RESERVATIONS_RELEASED                         NTStatus      = 0xC05CFF04
+	STATUS_SVHDX_UNIT_ATTENTION_REGISTRATIONS_PREEMPTED                       NTStatus      = 0xC05CFF05
+	STATUS_SVHDX_UNIT_ATTENTION_OPERATING_DEFINITION_CHANGED                  NTStatus      = 0xC05CFF06
+	STATUS_SVHDX_RESERVATION_CONFLICT                                         NTStatus      = 0xC05CFF07
+	STATUS_SVHDX_WRONG_FILE_TYPE                                              NTStatus      = 0xC05CFF08
+	STATUS_SVHDX_VERSION_MISMATCH                                             NTStatus      = 0xC05CFF09
+	STATUS_VHD_SHARED                                                         NTStatus      = 0xC05CFF0A
+	STATUS_SVHDX_NO_INITIATOR                                                 NTStatus      = 0xC05CFF0B
+	STATUS_VHDSET_BACKING_STORAGE_NOT_FOUND                                   NTStatus      = 0xC05CFF0C
+	STATUS_SMB_NO_PREAUTH_INTEGRITY_HASH_OVERLAP                              NTStatus      = 0xC05D0000
+	STATUS_SMB_BAD_CLUSTER_DIALECT                                            NTStatus      = 0xC05D0001
+	STATUS_SMB_GUEST_LOGON_BLOCKED                                            NTStatus      = 0xC05D0002
+	STATUS_SECCORE_INVALID_COMMAND                                            NTStatus      = 0xC0E80000
+	STATUS_VSM_NOT_INITIALIZED                                                NTStatus      = 0xC0450000
+	STATUS_VSM_DMA_PROTECTION_NOT_IN_USE                                      NTStatus      = 0xC0450001
+	STATUS_APPEXEC_CONDITION_NOT_SATISFIED                                    NTStatus      = 0xC0EC0000
+	STATUS_APPEXEC_HANDLE_INVALIDATED                                         NTStatus      = 0xC0EC0001
+	STATUS_APPEXEC_INVALID_HOST_GENERATION                                    NTStatus      = 0xC0EC0002
+	STATUS_APPEXEC_UNEXPECTED_PROCESS_REGISTRATION                            NTStatus      = 0xC0EC0003
+	STATUS_APPEXEC_INVALID_HOST_STATE                                         NTStatus      = 0xC0EC0004
+	STATUS_APPEXEC_NO_DONOR                                                   NTStatus      = 0xC0EC0005
+	STATUS_APPEXEC_HOST_ID_MISMATCH                                           NTStatus      = 0xC0EC0006
+	STATUS_APPEXEC_UNKNOWN_USER                                               NTStatus      = 0xC0EC0007
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/windows/zsyscall_windows.go b/src/cmd/vendor/golang.org/x/sys/windows/zsyscall_windows.go
index c38c59d772..559bc845c9 100644
--- a/src/cmd/vendor/golang.org/x/sys/windows/zsyscall_windows.go
+++ b/src/cmd/vendor/golang.org/x/sys/windows/zsyscall_windows.go
@@ -146,6 +146,8 @@ var (
 	procCertDeleteCertificateFromStore                       = modcrypt32.NewProc("CertDeleteCertificateFromStore")
 	procCertDuplicateCertificateContext                      = modcrypt32.NewProc("CertDuplicateCertificateContext")
 	procCertEnumCertificatesInStore                          = modcrypt32.NewProc("CertEnumCertificatesInStore")
+	procCertFindCertificateInStore                           = modcrypt32.NewProc("CertFindCertificateInStore")
+	procCertFindChainInStore                                 = modcrypt32.NewProc("CertFindChainInStore")
 	procCertFindExtension                                    = modcrypt32.NewProc("CertFindExtension")
 	procCertFreeCertificateChain                             = modcrypt32.NewProc("CertFreeCertificateChain")
 	procCertFreeCertificateContext                           = modcrypt32.NewProc("CertFreeCertificateContext")
@@ -154,6 +156,7 @@ var (
 	procCertOpenStore                                        = modcrypt32.NewProc("CertOpenStore")
 	procCertOpenSystemStoreW                                 = modcrypt32.NewProc("CertOpenSystemStoreW")
 	procCertVerifyCertificateChainPolicy                     = modcrypt32.NewProc("CertVerifyCertificateChainPolicy")
+	procCryptAcquireCertificatePrivateKey                    = modcrypt32.NewProc("CryptAcquireCertificatePrivateKey")
 	procCryptDecodeObject                                    = modcrypt32.NewProc("CryptDecodeObject")
 	procCryptProtectData                                     = modcrypt32.NewProc("CryptProtectData")
 	procCryptQueryObject                                     = modcrypt32.NewProc("CryptQueryObject")
@@ -169,6 +172,7 @@ var (
 	procCancelIo                                             = modkernel32.NewProc("CancelIo")
 	procCancelIoEx                                           = modkernel32.NewProc("CancelIoEx")
 	procCloseHandle                                          = modkernel32.NewProc("CloseHandle")
+	procConnectNamedPipe                                     = modkernel32.NewProc("ConnectNamedPipe")
 	procCreateDirectoryW                                     = modkernel32.NewProc("CreateDirectoryW")
 	procCreateEventExW                                       = modkernel32.NewProc("CreateEventExW")
 	procCreateEventW                                         = modkernel32.NewProc("CreateEventW")
@@ -179,12 +183,14 @@ var (
 	procCreateJobObjectW                                     = modkernel32.NewProc("CreateJobObjectW")
 	procCreateMutexExW                                       = modkernel32.NewProc("CreateMutexExW")
 	procCreateMutexW                                         = modkernel32.NewProc("CreateMutexW")
+	procCreateNamedPipeW                                     = modkernel32.NewProc("CreateNamedPipeW")
 	procCreatePipe                                           = modkernel32.NewProc("CreatePipe")
 	procCreateProcessW                                       = modkernel32.NewProc("CreateProcessW")
 	procCreateSymbolicLinkW                                  = modkernel32.NewProc("CreateSymbolicLinkW")
 	procCreateToolhelp32Snapshot                             = modkernel32.NewProc("CreateToolhelp32Snapshot")
 	procDefineDosDeviceW                                     = modkernel32.NewProc("DefineDosDeviceW")
 	procDeleteFileW                                          = modkernel32.NewProc("DeleteFileW")
+	procDeleteProcThreadAttributeList                        = modkernel32.NewProc("DeleteProcThreadAttributeList")
 	procDeleteVolumeMountPointW                              = modkernel32.NewProc("DeleteVolumeMountPointW")
 	procDeviceIoControl                                      = modkernel32.NewProc("DeviceIoControl")
 	procDuplicateHandle                                      = modkernel32.NewProc("DuplicateHandle")
@@ -199,6 +205,7 @@ var (
 	procFindNextFileW                                        = modkernel32.NewProc("FindNextFileW")
 	procFindNextVolumeMountPointW                            = modkernel32.NewProc("FindNextVolumeMountPointW")
 	procFindNextVolumeW                                      = modkernel32.NewProc("FindNextVolumeW")
+	procFindResourceW                                        = modkernel32.NewProc("FindResourceW")
 	procFindVolumeClose                                      = modkernel32.NewProc("FindVolumeClose")
 	procFindVolumeMountPointClose                            = modkernel32.NewProc("FindVolumeMountPointClose")
 	procFlushFileBuffers                                     = modkernel32.NewProc("FlushFileBuffers")
@@ -208,6 +215,7 @@ var (
 	procFreeLibrary                                          = modkernel32.NewProc("FreeLibrary")
 	procGenerateConsoleCtrlEvent                             = modkernel32.NewProc("GenerateConsoleCtrlEvent")
 	procGetACP                                               = modkernel32.NewProc("GetACP")
+	procGetCommTimeouts                                      = modkernel32.NewProc("GetCommTimeouts")
 	procGetCommandLineW                                      = modkernel32.NewProc("GetCommandLineW")
 	procGetComputerNameExW                                   = modkernel32.NewProc("GetComputerNameExW")
 	procGetComputerNameW                                     = modkernel32.NewProc("GetComputerNameW")
@@ -234,6 +242,8 @@ var (
 	procGetLongPathNameW                                     = modkernel32.NewProc("GetLongPathNameW")
 	procGetModuleFileNameW                                   = modkernel32.NewProc("GetModuleFileNameW")
 	procGetModuleHandleExW                                   = modkernel32.NewProc("GetModuleHandleExW")
+	procGetNamedPipeHandleStateW                             = modkernel32.NewProc("GetNamedPipeHandleStateW")
+	procGetNamedPipeInfo                                     = modkernel32.NewProc("GetNamedPipeInfo")
 	procGetOverlappedResult                                  = modkernel32.NewProc("GetOverlappedResult")
 	procGetPriorityClass                                     = modkernel32.NewProc("GetPriorityClass")
 	procGetProcAddress                                       = modkernel32.NewProc("GetProcAddress")
@@ -263,12 +273,16 @@ var (
 	procGetVolumePathNameW                                   = modkernel32.NewProc("GetVolumePathNameW")
 	procGetVolumePathNamesForVolumeNameW                     = modkernel32.NewProc("GetVolumePathNamesForVolumeNameW")
 	procGetWindowsDirectoryW                                 = modkernel32.NewProc("GetWindowsDirectoryW")
+	procInitializeProcThreadAttributeList                    = modkernel32.NewProc("InitializeProcThreadAttributeList")
 	procIsWow64Process                                       = modkernel32.NewProc("IsWow64Process")
 	procIsWow64Process2                                      = modkernel32.NewProc("IsWow64Process2")
 	procLoadLibraryExW                                       = modkernel32.NewProc("LoadLibraryExW")
 	procLoadLibraryW                                         = modkernel32.NewProc("LoadLibraryW")
+	procLoadResource                                         = modkernel32.NewProc("LoadResource")
+	procLocalAlloc                                           = modkernel32.NewProc("LocalAlloc")
 	procLocalFree                                            = modkernel32.NewProc("LocalFree")
 	procLockFileEx                                           = modkernel32.NewProc("LockFileEx")
+	procLockResource                                         = modkernel32.NewProc("LockResource")
 	procMapViewOfFile                                        = modkernel32.NewProc("MapViewOfFile")
 	procMoveFileExW                                          = modkernel32.NewProc("MoveFileExW")
 	procMoveFileW                                            = modkernel32.NewProc("MoveFileW")
@@ -283,6 +297,7 @@ var (
 	procProcessIdToSessionId                                 = modkernel32.NewProc("ProcessIdToSessionId")
 	procPulseEvent                                           = modkernel32.NewProc("PulseEvent")
 	procQueryDosDeviceW                                      = modkernel32.NewProc("QueryDosDeviceW")
+	procQueryFullProcessImageNameW                           = modkernel32.NewProc("QueryFullProcessImageNameW")
 	procQueryInformationJobObject                            = modkernel32.NewProc("QueryInformationJobObject")
 	procReadConsoleW                                         = modkernel32.NewProc("ReadConsoleW")
 	procReadDirectoryChangesW                                = modkernel32.NewProc("ReadDirectoryChangesW")
@@ -291,6 +306,7 @@ var (
 	procRemoveDirectoryW                                     = modkernel32.NewProc("RemoveDirectoryW")
 	procResetEvent                                           = modkernel32.NewProc("ResetEvent")
 	procResumeThread                                         = modkernel32.NewProc("ResumeThread")
+	procSetCommTimeouts                                      = modkernel32.NewProc("SetCommTimeouts")
 	procSetConsoleCursorPosition                             = modkernel32.NewProc("SetConsoleCursorPosition")
 	procSetConsoleMode                                       = modkernel32.NewProc("SetConsoleMode")
 	procSetCurrentDirectoryW                                 = modkernel32.NewProc("SetCurrentDirectoryW")
@@ -307,6 +323,7 @@ var (
 	procSetFileTime                                          = modkernel32.NewProc("SetFileTime")
 	procSetHandleInformation                                 = modkernel32.NewProc("SetHandleInformation")
 	procSetInformationJobObject                              = modkernel32.NewProc("SetInformationJobObject")
+	procSetNamedPipeHandleState                              = modkernel32.NewProc("SetNamedPipeHandleState")
 	procSetPriorityClass                                     = modkernel32.NewProc("SetPriorityClass")
 	procSetProcessPriorityBoost                              = modkernel32.NewProc("SetProcessPriorityBoost")
 	procSetProcessShutdownParameters                         = modkernel32.NewProc("SetProcessShutdownParameters")
@@ -314,6 +331,7 @@ var (
 	procSetStdHandle                                         = modkernel32.NewProc("SetStdHandle")
 	procSetVolumeLabelW                                      = modkernel32.NewProc("SetVolumeLabelW")
 	procSetVolumeMountPointW                                 = modkernel32.NewProc("SetVolumeMountPointW")
+	procSizeofResource                                       = modkernel32.NewProc("SizeofResource")
 	procSleepEx                                              = modkernel32.NewProc("SleepEx")
 	procTerminateJobObject                                   = modkernel32.NewProc("TerminateJobObject")
 	procTerminateProcess                                     = modkernel32.NewProc("TerminateProcess")
@@ -321,6 +339,7 @@ var (
 	procThread32Next                                         = modkernel32.NewProc("Thread32Next")
 	procUnlockFileEx                                         = modkernel32.NewProc("UnlockFileEx")
 	procUnmapViewOfFile                                      = modkernel32.NewProc("UnmapViewOfFile")
+	procUpdateProcThreadAttribute                            = modkernel32.NewProc("UpdateProcThreadAttribute")
 	procVirtualAlloc                                         = modkernel32.NewProc("VirtualAlloc")
 	procVirtualFree                                          = modkernel32.NewProc("VirtualFree")
 	procVirtualLock                                          = modkernel32.NewProc("VirtualLock")
@@ -336,11 +355,25 @@ var (
 	procNetApiBufferFree                                     = modnetapi32.NewProc("NetApiBufferFree")
 	procNetGetJoinInformation                                = modnetapi32.NewProc("NetGetJoinInformation")
 	procNetUserGetInfo                                       = modnetapi32.NewProc("NetUserGetInfo")
+	procNtCreateFile                                         = modntdll.NewProc("NtCreateFile")
+	procNtCreateNamedPipeFile                                = modntdll.NewProc("NtCreateNamedPipeFile")
+	procNtQueryInformationProcess                            = modntdll.NewProc("NtQueryInformationProcess")
+	procNtSetInformationProcess                              = modntdll.NewProc("NtSetInformationProcess")
+	procRtlDefaultNpAcl                                      = modntdll.NewProc("RtlDefaultNpAcl")
+	procRtlDosPathNameToNtPathName_U_WithStatus              = modntdll.NewProc("RtlDosPathNameToNtPathName_U_WithStatus")
+	procRtlDosPathNameToRelativeNtPathName_U_WithStatus      = modntdll.NewProc("RtlDosPathNameToRelativeNtPathName_U_WithStatus")
+	procRtlGetCurrentPeb                                     = modntdll.NewProc("RtlGetCurrentPeb")
 	procRtlGetNtVersionNumbers                               = modntdll.NewProc("RtlGetNtVersionNumbers")
 	procRtlGetVersion                                        = modntdll.NewProc("RtlGetVersion")
+	procRtlInitString                                        = modntdll.NewProc("RtlInitString")
+	procRtlInitUnicodeString                                 = modntdll.NewProc("RtlInitUnicodeString")
+	procRtlNtStatusToDosErrorNoTeb                           = modntdll.NewProc("RtlNtStatusToDosErrorNoTeb")
 	procCLSIDFromString                                      = modole32.NewProc("CLSIDFromString")
 	procCoCreateGuid                                         = modole32.NewProc("CoCreateGuid")
+	procCoGetObject                                          = modole32.NewProc("CoGetObject")
+	procCoInitializeEx                                       = modole32.NewProc("CoInitializeEx")
 	procCoTaskMemFree                                        = modole32.NewProc("CoTaskMemFree")
+	procCoUninitialize                                       = modole32.NewProc("CoUninitialize")
 	procStringFromGUID2                                      = modole32.NewProc("StringFromGUID2")
 	procEnumProcesses                                        = modpsapi.NewProc("EnumProcesses")
 	procSubscribeServiceChangeNotifications                  = modsechost.NewProc("SubscribeServiceChangeNotifications")
@@ -362,11 +395,13 @@ var (
 	procGetAddrInfoW                                         = modws2_32.NewProc("GetAddrInfoW")
 	procWSACleanup                                           = modws2_32.NewProc("WSACleanup")
 	procWSAEnumProtocolsW                                    = modws2_32.NewProc("WSAEnumProtocolsW")
+	procWSAGetOverlappedResult                               = modws2_32.NewProc("WSAGetOverlappedResult")
 	procWSAIoctl                                             = modws2_32.NewProc("WSAIoctl")
 	procWSARecv                                              = modws2_32.NewProc("WSARecv")
 	procWSARecvFrom                                          = modws2_32.NewProc("WSARecvFrom")
 	procWSASend                                              = modws2_32.NewProc("WSASend")
 	procWSASendTo                                            = modws2_32.NewProc("WSASendTo")
+	procWSASocketW                                           = modws2_32.NewProc("WSASocketW")
 	procWSAStartup                                           = modws2_32.NewProc("WSAStartup")
 	procbind                                                 = modws2_32.NewProc("bind")
 	procclosesocket                                          = modws2_32.NewProc("closesocket")
@@ -1210,6 +1245,24 @@ func CertEnumCertificatesInStore(store Handle, prevContext *CertContext) (contex
 	return
 }
 
+func CertFindCertificateInStore(store Handle, certEncodingType uint32, findFlags uint32, findType uint32, findPara unsafe.Pointer, prevCertContext *CertContext) (cert *CertContext, err error) {
+	r0, _, e1 := syscall.Syscall6(procCertFindCertificateInStore.Addr(), 6, uintptr(store), uintptr(certEncodingType), uintptr(findFlags), uintptr(findType), uintptr(findPara), uintptr(unsafe.Pointer(prevCertContext)))
+	cert = (*CertContext)(unsafe.Pointer(r0))
+	if cert == nil {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func CertFindChainInStore(store Handle, certEncodingType uint32, findFlags uint32, findType uint32, findPara unsafe.Pointer, prevChainContext *CertChainContext) (certchain *CertChainContext, err error) {
+	r0, _, e1 := syscall.Syscall6(procCertFindChainInStore.Addr(), 6, uintptr(store), uintptr(certEncodingType), uintptr(findFlags), uintptr(findType), uintptr(findPara), uintptr(unsafe.Pointer(prevChainContext)))
+	certchain = (*CertChainContext)(unsafe.Pointer(r0))
+	if certchain == nil {
+		err = errnoErr(e1)
+	}
+	return
+}
+
 func CertFindExtension(objId *byte, countExtensions uint32, extensions *CertExtension) (ret *CertExtension) {
 	r0, _, _ := syscall.Syscall(procCertFindExtension.Addr(), 3, uintptr(unsafe.Pointer(objId)), uintptr(countExtensions), uintptr(unsafe.Pointer(extensions)))
 	ret = (*CertExtension)(unsafe.Pointer(r0))
@@ -1269,6 +1322,19 @@ func CertVerifyCertificateChainPolicy(policyOID uintptr, chain *CertChainContext
 	return
 }
 
+func CryptAcquireCertificatePrivateKey(cert *CertContext, flags uint32, parameters unsafe.Pointer, cryptProvOrNCryptKey *Handle, keySpec *uint32, callerFreeProvOrNCryptKey *bool) (err error) {
+	var _p0 uint32
+	if *callerFreeProvOrNCryptKey {
+		_p0 = 1
+	}
+	r1, _, e1 := syscall.Syscall6(procCryptAcquireCertificatePrivateKey.Addr(), 6, uintptr(unsafe.Pointer(cert)), uintptr(flags), uintptr(parameters), uintptr(unsafe.Pointer(cryptProvOrNCryptKey)), uintptr(unsafe.Pointer(keySpec)), uintptr(unsafe.Pointer(&_p0)))
+	*callerFreeProvOrNCryptKey = _p0 != 0
+	if r1 == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
 func CryptDecodeObject(encodingType uint32, structType *byte, encodedBytes *byte, lenEncodedBytes uint32, flags uint32, decoded unsafe.Pointer, decodedLen *uint32) (err error) {
 	r1, _, e1 := syscall.Syscall9(procCryptDecodeObject.Addr(), 7, uintptr(encodingType), uintptr(unsafe.Pointer(structType)), uintptr(unsafe.Pointer(encodedBytes)), uintptr(lenEncodedBytes), uintptr(flags), uintptr(decoded), uintptr(unsafe.Pointer(decodedLen)), 0, 0)
 	if r1 == 0 {
@@ -1394,6 +1460,14 @@ func CloseHandle(handle Handle) (err error) {
 	return
 }
 
+func ConnectNamedPipe(pipe Handle, overlapped *Overlapped) (err error) {
+	r1, _, e1 := syscall.Syscall(procConnectNamedPipe.Addr(), 2, uintptr(pipe), uintptr(unsafe.Pointer(overlapped)), 0)
+	if r1 == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
 func CreateDirectory(path *uint16, sa *SecurityAttributes) (err error) {
 	r1, _, e1 := syscall.Syscall(procCreateDirectoryW.Addr(), 2, uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(sa)), 0)
 	if r1 == 0 {
@@ -1405,7 +1479,7 @@ func CreateDirectory(path *uint16, sa *SecurityAttributes) (err error) {
 func CreateEventEx(eventAttrs *SecurityAttributes, name *uint16, flags uint32, desiredAccess uint32) (handle Handle, err error) {
 	r0, _, e1 := syscall.Syscall6(procCreateEventExW.Addr(), 4, uintptr(unsafe.Pointer(eventAttrs)), uintptr(unsafe.Pointer(name)), uintptr(flags), uintptr(desiredAccess), 0, 0)
 	handle = Handle(r0)
-	if handle == 0 {
+	if handle == 0 || e1 == ERROR_ALREADY_EXISTS {
 		err = errnoErr(e1)
 	}
 	return
@@ -1414,7 +1488,7 @@ func CreateEventEx(eventAttrs *SecurityAttributes, name *uint16, flags uint32, d
 func CreateEvent(eventAttrs *SecurityAttributes, manualReset uint32, initialState uint32, name *uint16) (handle Handle, err error) {
 	r0, _, e1 := syscall.Syscall6(procCreateEventW.Addr(), 4, uintptr(unsafe.Pointer(eventAttrs)), uintptr(manualReset), uintptr(initialState), uintptr(unsafe.Pointer(name)), 0, 0)
 	handle = Handle(r0)
-	if handle == 0 {
+	if handle == 0 || e1 == ERROR_ALREADY_EXISTS {
 		err = errnoErr(e1)
 	}
 	return
@@ -1423,7 +1497,7 @@ func CreateEvent(eventAttrs *SecurityAttributes, manualReset uint32, initialStat
 func CreateFileMapping(fhandle Handle, sa *SecurityAttributes, prot uint32, maxSizeHigh uint32, maxSizeLow uint32, name *uint16) (handle Handle, err error) {
 	r0, _, e1 := syscall.Syscall6(procCreateFileMappingW.Addr(), 6, uintptr(fhandle), uintptr(unsafe.Pointer(sa)), uintptr(prot), uintptr(maxSizeHigh), uintptr(maxSizeLow), uintptr(unsafe.Pointer(name)))
 	handle = Handle(r0)
-	if handle == 0 {
+	if handle == 0 || e1 == ERROR_ALREADY_EXISTS {
 		err = errnoErr(e1)
 	}
 	return
@@ -1446,7 +1520,7 @@ func CreateHardLink(filename *uint16, existingfilename *uint16, reserved uintptr
 	return
 }
 
-func CreateIoCompletionPort(filehandle Handle, cphandle Handle, key uint32, threadcnt uint32) (handle Handle, err error) {
+func CreateIoCompletionPort(filehandle Handle, cphandle Handle, key uintptr, threadcnt uint32) (handle Handle, err error) {
 	r0, _, e1 := syscall.Syscall6(procCreateIoCompletionPort.Addr(), 4, uintptr(filehandle), uintptr(cphandle), uintptr(key), uintptr(threadcnt), 0, 0)
 	handle = Handle(r0)
 	if handle == 0 {
@@ -1467,7 +1541,7 @@ func CreateJobObject(jobAttr *SecurityAttributes, name *uint16) (handle Handle,
 func CreateMutexEx(mutexAttrs *SecurityAttributes, name *uint16, flags uint32, desiredAccess uint32) (handle Handle, err error) {
 	r0, _, e1 := syscall.Syscall6(procCreateMutexExW.Addr(), 4, uintptr(unsafe.Pointer(mutexAttrs)), uintptr(unsafe.Pointer(name)), uintptr(flags), uintptr(desiredAccess), 0, 0)
 	handle = Handle(r0)
-	if handle == 0 {
+	if handle == 0 || e1 == ERROR_ALREADY_EXISTS {
 		err = errnoErr(e1)
 	}
 	return
@@ -1480,7 +1554,16 @@ func CreateMutex(mutexAttrs *SecurityAttributes, initialOwner bool, name *uint16
 	}
 	r0, _, e1 := syscall.Syscall(procCreateMutexW.Addr(), 3, uintptr(unsafe.Pointer(mutexAttrs)), uintptr(_p0), uintptr(unsafe.Pointer(name)))
 	handle = Handle(r0)
-	if handle == 0 {
+	if handle == 0 || e1 == ERROR_ALREADY_EXISTS {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func CreateNamedPipe(name *uint16, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *SecurityAttributes) (handle Handle, err error) {
+	r0, _, e1 := syscall.Syscall9(procCreateNamedPipeW.Addr(), 8, uintptr(unsafe.Pointer(name)), uintptr(flags), uintptr(pipeMode), uintptr(maxInstances), uintptr(outSize), uintptr(inSize), uintptr(defaultTimeout), uintptr(unsafe.Pointer(sa)), 0)
+	handle = Handle(r0)
+	if handle == InvalidHandle {
 		err = errnoErr(e1)
 	}
 	return
@@ -1539,6 +1622,11 @@ func DeleteFile(path *uint16) (err error) {
 	return
 }
 
+func deleteProcThreadAttributeList(attrlist *ProcThreadAttributeList) {
+	syscall.Syscall(procDeleteProcThreadAttributeList.Addr(), 1, uintptr(unsafe.Pointer(attrlist)), 0, 0)
+	return
+}
+
 func DeleteVolumeMountPoint(volumeMountPoint *uint16) (err error) {
 	r1, _, e1 := syscall.Syscall(procDeleteVolumeMountPointW.Addr(), 1, uintptr(unsafe.Pointer(volumeMountPoint)), 0, 0)
 	if r1 == 0 {
@@ -1669,6 +1757,15 @@ func FindNextVolume(findVolume Handle, volumeName *uint16, bufferLength uint32)
 	return
 }
 
+func findResource(module Handle, name uintptr, resType uintptr) (resInfo Handle, err error) {
+	r0, _, e1 := syscall.Syscall(procFindResourceW.Addr(), 3, uintptr(module), uintptr(name), uintptr(resType))
+	resInfo = Handle(r0)
+	if resInfo == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
 func FindVolumeClose(findVolume Handle) (err error) {
 	r1, _, e1 := syscall.Syscall(procFindVolumeClose.Addr(), 1, uintptr(findVolume), 0, 0)
 	if r1 == 0 {
@@ -1744,6 +1841,14 @@ func GetACP() (acp uint32) {
 	return
 }
 
+func GetCommTimeouts(handle Handle, timeouts *CommTimeouts) (err error) {
+	r1, _, e1 := syscall.Syscall(procGetCommTimeouts.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(timeouts)), 0)
+	if r1 == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
 func GetCommandLine() (cmd *uint16) {
 	r0, _, _ := syscall.Syscall(procGetCommandLineW.Addr(), 0, 0, 0, 0)
 	cmd = (*uint16)(unsafe.Pointer(r0))
@@ -1955,6 +2060,22 @@ func GetModuleHandleEx(flags uint32, moduleName *uint16, module *Handle) (err er
 	return
 }
 
+func GetNamedPipeHandleState(pipe Handle, state *uint32, curInstances *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32, userName *uint16, maxUserNameSize uint32) (err error) {
+	r1, _, e1 := syscall.Syscall9(procGetNamedPipeHandleStateW.Addr(), 7, uintptr(pipe), uintptr(unsafe.Pointer(state)), uintptr(unsafe.Pointer(curInstances)), uintptr(unsafe.Pointer(maxCollectionCount)), uintptr(unsafe.Pointer(collectDataTimeout)), uintptr(unsafe.Pointer(userName)), uintptr(maxUserNameSize), 0, 0)
+	if r1 == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func GetNamedPipeInfo(pipe Handle, flags *uint32, outSize *uint32, inSize *uint32, maxInstances *uint32) (err error) {
+	r1, _, e1 := syscall.Syscall6(procGetNamedPipeInfo.Addr(), 5, uintptr(pipe), uintptr(unsafe.Pointer(flags)), uintptr(unsafe.Pointer(outSize)), uintptr(unsafe.Pointer(inSize)), uintptr(unsafe.Pointer(maxInstances)), 0)
+	if r1 == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
 func GetOverlappedResult(handle Handle, overlapped *Overlapped, done *uint32, wait bool) (err error) {
 	var _p0 uint32
 	if wait {
@@ -2032,7 +2153,7 @@ func GetProcessWorkingSetSizeEx(hProcess Handle, lpMinimumWorkingSetSize *uintpt
 	return
 }
 
-func GetQueuedCompletionStatus(cphandle Handle, qty *uint32, key *uint32, overlapped **Overlapped, timeout uint32) (err error) {
+func GetQueuedCompletionStatus(cphandle Handle, qty *uint32, key *uintptr, overlapped **Overlapped, timeout uint32) (err error) {
 	r1, _, e1 := syscall.Syscall6(procGetQueuedCompletionStatus.Addr(), 5, uintptr(cphandle), uintptr(unsafe.Pointer(qty)), uintptr(unsafe.Pointer(key)), uintptr(unsafe.Pointer(overlapped)), uintptr(timeout), 0)
 	if r1 == 0 {
 		err = errnoErr(e1)
@@ -2200,6 +2321,14 @@ func getWindowsDirectory(dir *uint16, dirLen uint32) (len uint32, err error) {
 	return
 }
 
+func initializeProcThreadAttributeList(attrlist *ProcThreadAttributeList, attrcount uint32, flags uint32, size *uintptr) (err error) {
+	r1, _, e1 := syscall.Syscall6(procInitializeProcThreadAttributeList.Addr(), 4, uintptr(unsafe.Pointer(attrlist)), uintptr(attrcount), uintptr(flags), uintptr(unsafe.Pointer(size)), 0, 0)
+	if r1 == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
 func IsWow64Process(handle Handle, isWow64 *bool) (err error) {
 	var _p0 uint32
 	if *isWow64 {
@@ -2261,6 +2390,24 @@ func _LoadLibrary(libname *uint16) (handle Handle, err error) {
 	return
 }
 
+func LoadResource(module Handle, resInfo Handle) (resData Handle, err error) {
+	r0, _, e1 := syscall.Syscall(procLoadResource.Addr(), 2, uintptr(module), uintptr(resInfo), 0)
+	resData = Handle(r0)
+	if resData == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func LocalAlloc(flags uint32, length uint32) (ptr uintptr, err error) {
+	r0, _, e1 := syscall.Syscall(procLocalAlloc.Addr(), 2, uintptr(flags), uintptr(length), 0)
+	ptr = uintptr(r0)
+	if ptr == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
 func LocalFree(hmem Handle) (handle Handle, err error) {
 	r0, _, e1 := syscall.Syscall(procLocalFree.Addr(), 1, uintptr(hmem), 0, 0)
 	handle = Handle(r0)
@@ -2278,6 +2425,15 @@ func LockFileEx(file Handle, flags uint32, reserved uint32, bytesLow uint32, byt
 	return
 }
 
+func LockResource(resData Handle) (addr uintptr, err error) {
+	r0, _, e1 := syscall.Syscall(procLockResource.Addr(), 1, uintptr(resData), 0, 0)
+	addr = uintptr(r0)
+	if addr == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
 func MapViewOfFile(handle Handle, access uint32, offsetHigh uint32, offsetLow uint32, length uintptr) (addr uintptr, err error) {
 	r0, _, e1 := syscall.Syscall6(procMapViewOfFile.Addr(), 5, uintptr(handle), uintptr(access), uintptr(offsetHigh), uintptr(offsetLow), uintptr(length), 0)
 	addr = uintptr(r0)
@@ -2364,7 +2520,7 @@ func OpenThread(desiredAccess uint32, inheritHandle bool, threadId uint32) (hand
 	return
 }
 
-func PostQueuedCompletionStatus(cphandle Handle, qty uint32, key uint32, overlapped *Overlapped) (err error) {
+func PostQueuedCompletionStatus(cphandle Handle, qty uint32, key uintptr, overlapped *Overlapped) (err error) {
 	r1, _, e1 := syscall.Syscall6(procPostQueuedCompletionStatus.Addr(), 4, uintptr(cphandle), uintptr(qty), uintptr(key), uintptr(unsafe.Pointer(overlapped)), 0, 0)
 	if r1 == 0 {
 		err = errnoErr(e1)
@@ -2413,6 +2569,14 @@ func QueryDosDevice(deviceName *uint16, targetPath *uint16, max uint32) (n uint3
 	return
 }
 
+func QueryFullProcessImageName(proc Handle, flags uint32, exeName *uint16, size *uint32) (err error) {
+	r1, _, e1 := syscall.Syscall6(procQueryFullProcessImageNameW.Addr(), 4, uintptr(proc), uintptr(flags), uintptr(unsafe.Pointer(exeName)), uintptr(unsafe.Pointer(size)), 0, 0)
+	if r1 == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
 func QueryInformationJobObject(job Handle, JobObjectInformationClass int32, JobObjectInformation uintptr, JobObjectInformationLength uint32, retlen *uint32) (err error) {
 	r1, _, e1 := syscall.Syscall6(procQueryInformationJobObject.Addr(), 5, uintptr(job), uintptr(JobObjectInformationClass), uintptr(JobObjectInformation), uintptr(JobObjectInformationLength), uintptr(unsafe.Pointer(retlen)), 0)
 	if r1 == 0 {
@@ -2486,6 +2650,14 @@ func ResumeThread(thread Handle) (ret uint32, err error) {
 	return
 }
 
+func SetCommTimeouts(handle Handle, timeouts *CommTimeouts) (err error) {
+	r1, _, e1 := syscall.Syscall(procSetCommTimeouts.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(timeouts)), 0)
+	if r1 == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
 func setConsoleCursorPosition(console Handle, position uint32) (err error) {
 	r1, _, e1 := syscall.Syscall(procSetConsoleCursorPosition.Addr(), 2, uintptr(console), uintptr(position), 0)
 	if r1 == 0 {
@@ -2623,6 +2795,14 @@ func SetInformationJobObject(job Handle, JobObjectInformationClass uint32, JobOb
 	return
 }
 
+func SetNamedPipeHandleState(pipe Handle, state *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32) (err error) {
+	r1, _, e1 := syscall.Syscall6(procSetNamedPipeHandleState.Addr(), 4, uintptr(pipe), uintptr(unsafe.Pointer(state)), uintptr(unsafe.Pointer(maxCollectionCount)), uintptr(unsafe.Pointer(collectDataTimeout)), 0, 0)
+	if r1 == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
 func SetPriorityClass(process Handle, priorityClass uint32) (err error) {
 	r1, _, e1 := syscall.Syscall(procSetPriorityClass.Addr(), 2, uintptr(process), uintptr(priorityClass), 0)
 	if r1 == 0 {
@@ -2683,6 +2863,15 @@ func SetVolumeMountPoint(volumeMountPoint *uint16, volumeName *uint16) (err erro
 	return
 }
 
+func SizeofResource(module Handle, resInfo Handle) (size uint32, err error) {
+	r0, _, e1 := syscall.Syscall(procSizeofResource.Addr(), 2, uintptr(module), uintptr(resInfo), 0)
+	size = uint32(r0)
+	if size == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
 func SleepEx(milliseconds uint32, alertable bool) (ret uint32) {
 	var _p0 uint32
 	if alertable {
@@ -2741,6 +2930,14 @@ func UnmapViewOfFile(addr uintptr) (err error) {
 	return
 }
 
+func updateProcThreadAttribute(attrlist *ProcThreadAttributeList, flags uint32, attr uintptr, value unsafe.Pointer, size uintptr, prevvalue unsafe.Pointer, returnedsize *uintptr) (err error) {
+	r1, _, e1 := syscall.Syscall9(procUpdateProcThreadAttribute.Addr(), 7, uintptr(unsafe.Pointer(attrlist)), uintptr(flags), uintptr(attr), uintptr(value), uintptr(size), uintptr(prevvalue), uintptr(unsafe.Pointer(returnedsize)), 0, 0)
+	if r1 == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
 func VirtualAlloc(address uintptr, size uintptr, alloctype uint32, protect uint32) (value uintptr, err error) {
 	r0, _, e1 := syscall.Syscall6(procVirtualAlloc.Addr(), 4, uintptr(address), uintptr(size), uintptr(alloctype), uintptr(protect), 0, 0)
 	value = uintptr(r0)
@@ -2869,19 +3066,97 @@ func NetUserGetInfo(serverName *uint16, userName *uint16, level uint32, buf **by
 	return
 }
 
+func NtCreateFile(handle *Handle, access uint32, oa *OBJECT_ATTRIBUTES, iosb *IO_STATUS_BLOCK, allocationSize *int64, attributes uint32, share uint32, disposition uint32, options uint32, eabuffer uintptr, ealength uint32) (ntstatus error) {
+	r0, _, _ := syscall.Syscall12(procNtCreateFile.Addr(), 11, uintptr(unsafe.Pointer(handle)), uintptr(access), uintptr(unsafe.Pointer(oa)), uintptr(unsafe.Pointer(iosb)), uintptr(unsafe.Pointer(allocationSize)), uintptr(attributes), uintptr(share), uintptr(disposition), uintptr(options), uintptr(eabuffer), uintptr(ealength), 0)
+	if r0 != 0 {
+		ntstatus = NTStatus(r0)
+	}
+	return
+}
+
+func NtCreateNamedPipeFile(pipe *Handle, access uint32, oa *OBJECT_ATTRIBUTES, iosb *IO_STATUS_BLOCK, share uint32, disposition uint32, options uint32, typ uint32, readMode uint32, completionMode uint32, maxInstances uint32, inboundQuota uint32, outputQuota uint32, timeout *int64) (ntstatus error) {
+	r0, _, _ := syscall.Syscall15(procNtCreateNamedPipeFile.Addr(), 14, uintptr(unsafe.Pointer(pipe)), uintptr(access), uintptr(unsafe.Pointer(oa)), uintptr(unsafe.Pointer(iosb)), uintptr(share), uintptr(disposition), uintptr(options), uintptr(typ), uintptr(readMode), uintptr(completionMode), uintptr(maxInstances), uintptr(inboundQuota), uintptr(outputQuota), uintptr(unsafe.Pointer(timeout)), 0)
+	if r0 != 0 {
+		ntstatus = NTStatus(r0)
+	}
+	return
+}
+
+func NtQueryInformationProcess(proc Handle, procInfoClass int32, procInfo unsafe.Pointer, procInfoLen uint32, retLen *uint32) (ntstatus error) {
+	r0, _, _ := syscall.Syscall6(procNtQueryInformationProcess.Addr(), 5, uintptr(proc), uintptr(procInfoClass), uintptr(procInfo), uintptr(procInfoLen), uintptr(unsafe.Pointer(retLen)), 0)
+	if r0 != 0 {
+		ntstatus = NTStatus(r0)
+	}
+	return
+}
+
+func NtSetInformationProcess(proc Handle, procInfoClass int32, procInfo unsafe.Pointer, procInfoLen uint32) (ntstatus error) {
+	r0, _, _ := syscall.Syscall6(procNtSetInformationProcess.Addr(), 4, uintptr(proc), uintptr(procInfoClass), uintptr(procInfo), uintptr(procInfoLen), 0, 0)
+	if r0 != 0 {
+		ntstatus = NTStatus(r0)
+	}
+	return
+}
+
+func RtlDefaultNpAcl(acl **ACL) (ntstatus error) {
+	r0, _, _ := syscall.Syscall(procRtlDefaultNpAcl.Addr(), 1, uintptr(unsafe.Pointer(acl)), 0, 0)
+	if r0 != 0 {
+		ntstatus = NTStatus(r0)
+	}
+	return
+}
+
+func RtlDosPathNameToNtPathName(dosName *uint16, ntName *NTUnicodeString, ntFileNamePart *uint16, relativeName *RTL_RELATIVE_NAME) (ntstatus error) {
+	r0, _, _ := syscall.Syscall6(procRtlDosPathNameToNtPathName_U_WithStatus.Addr(), 4, uintptr(unsafe.Pointer(dosName)), uintptr(unsafe.Pointer(ntName)), uintptr(unsafe.Pointer(ntFileNamePart)), uintptr(unsafe.Pointer(relativeName)), 0, 0)
+	if r0 != 0 {
+		ntstatus = NTStatus(r0)
+	}
+	return
+}
+
+func RtlDosPathNameToRelativeNtPathName(dosName *uint16, ntName *NTUnicodeString, ntFileNamePart *uint16, relativeName *RTL_RELATIVE_NAME) (ntstatus error) {
+	r0, _, _ := syscall.Syscall6(procRtlDosPathNameToRelativeNtPathName_U_WithStatus.Addr(), 4, uintptr(unsafe.Pointer(dosName)), uintptr(unsafe.Pointer(ntName)), uintptr(unsafe.Pointer(ntFileNamePart)), uintptr(unsafe.Pointer(relativeName)), 0, 0)
+	if r0 != 0 {
+		ntstatus = NTStatus(r0)
+	}
+	return
+}
+
+func RtlGetCurrentPeb() (peb *PEB) {
+	r0, _, _ := syscall.Syscall(procRtlGetCurrentPeb.Addr(), 0, 0, 0, 0)
+	peb = (*PEB)(unsafe.Pointer(r0))
+	return
+}
+
 func rtlGetNtVersionNumbers(majorVersion *uint32, minorVersion *uint32, buildNumber *uint32) {
 	syscall.Syscall(procRtlGetNtVersionNumbers.Addr(), 3, uintptr(unsafe.Pointer(majorVersion)), uintptr(unsafe.Pointer(minorVersion)), uintptr(unsafe.Pointer(buildNumber)))
 	return
 }
 
-func rtlGetVersion(info *OsVersionInfoEx) (ret error) {
+func rtlGetVersion(info *OsVersionInfoEx) (ntstatus error) {
 	r0, _, _ := syscall.Syscall(procRtlGetVersion.Addr(), 1, uintptr(unsafe.Pointer(info)), 0, 0)
 	if r0 != 0 {
-		ret = syscall.Errno(r0)
+		ntstatus = NTStatus(r0)
 	}
 	return
 }
 
+func RtlInitString(destinationString *NTString, sourceString *byte) {
+	syscall.Syscall(procRtlInitString.Addr(), 2, uintptr(unsafe.Pointer(destinationString)), uintptr(unsafe.Pointer(sourceString)), 0)
+	return
+}
+
+func RtlInitUnicodeString(destinationString *NTUnicodeString, sourceString *uint16) {
+	syscall.Syscall(procRtlInitUnicodeString.Addr(), 2, uintptr(unsafe.Pointer(destinationString)), uintptr(unsafe.Pointer(sourceString)), 0)
+	return
+}
+
+func rtlNtStatusToDosErrorNoTeb(ntstatus NTStatus) (ret syscall.Errno) {
+	r0, _, _ := syscall.Syscall(procRtlNtStatusToDosErrorNoTeb.Addr(), 1, uintptr(ntstatus), 0, 0)
+	ret = syscall.Errno(r0)
+	return
+}
+
 func clsidFromString(lpsz *uint16, pclsid *GUID) (ret error) {
 	r0, _, _ := syscall.Syscall(procCLSIDFromString.Addr(), 2, uintptr(unsafe.Pointer(lpsz)), uintptr(unsafe.Pointer(pclsid)), 0)
 	if r0 != 0 {
@@ -2898,11 +3173,32 @@ func coCreateGuid(pguid *GUID) (ret error) {
 	return
 }
 
+func CoGetObject(name *uint16, bindOpts *BIND_OPTS3, guid *GUID, functionTable **uintptr) (ret error) {
+	r0, _, _ := syscall.Syscall6(procCoGetObject.Addr(), 4, uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(bindOpts)), uintptr(unsafe.Pointer(guid)), uintptr(unsafe.Pointer(functionTable)), 0, 0)
+	if r0 != 0 {
+		ret = syscall.Errno(r0)
+	}
+	return
+}
+
+func CoInitializeEx(reserved uintptr, coInit uint32) (ret error) {
+	r0, _, _ := syscall.Syscall(procCoInitializeEx.Addr(), 2, uintptr(reserved), uintptr(coInit), 0)
+	if r0 != 0 {
+		ret = syscall.Errno(r0)
+	}
+	return
+}
+
 func CoTaskMemFree(address unsafe.Pointer) {
 	syscall.Syscall(procCoTaskMemFree.Addr(), 1, uintptr(address), 0, 0)
 	return
 }
 
+func CoUninitialize() {
+	syscall.Syscall(procCoUninitialize.Addr(), 0, 0, 0, 0)
+	return
+}
+
 func stringFromGUID2(rguid *GUID, lpsz *uint16, cchMax int32) (chars int32) {
 	r0, _, _ := syscall.Syscall(procStringFromGUID2.Addr(), 3, uintptr(unsafe.Pointer(rguid)), uintptr(unsafe.Pointer(lpsz)), uintptr(cchMax))
 	chars = int32(r0)
@@ -3081,6 +3377,18 @@ func WSAEnumProtocols(protocols *int32, protocolBuffer *WSAProtocolInfo, bufferL
 	return
 }
 
+func WSAGetOverlappedResult(h Handle, o *Overlapped, bytes *uint32, wait bool, flags *uint32) (err error) {
+	var _p0 uint32
+	if wait {
+		_p0 = 1
+	}
+	r1, _, e1 := syscall.Syscall6(procWSAGetOverlappedResult.Addr(), 5, uintptr(h), uintptr(unsafe.Pointer(o)), uintptr(unsafe.Pointer(bytes)), uintptr(_p0), uintptr(unsafe.Pointer(flags)), 0)
+	if r1 == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
 func WSAIoctl(s Handle, iocc uint32, inbuf *byte, cbif uint32, outbuf *byte, cbob uint32, cbbr *uint32, overlapped *Overlapped, completionRoutine uintptr) (err error) {
 	r1, _, e1 := syscall.Syscall9(procWSAIoctl.Addr(), 9, uintptr(s), uintptr(iocc), uintptr(unsafe.Pointer(inbuf)), uintptr(cbif), uintptr(unsafe.Pointer(outbuf)), uintptr(cbob), uintptr(unsafe.Pointer(cbbr)), uintptr(unsafe.Pointer(overlapped)), uintptr(completionRoutine))
 	if r1 == socket_error {
@@ -3121,6 +3429,15 @@ func WSASendTo(s Handle, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32
 	return
 }
 
+func WSASocket(af int32, typ int32, protocol int32, protoInfo *WSAProtocolInfo, group uint32, flags uint32) (handle Handle, err error) {
+	r0, _, e1 := syscall.Syscall6(procWSASocketW.Addr(), 6, uintptr(af), uintptr(typ), uintptr(protocol), uintptr(unsafe.Pointer(protoInfo)), uintptr(group), uintptr(flags))
+	handle = Handle(r0)
+	if handle == InvalidHandle {
+		err = errnoErr(e1)
+	}
+	return
+}
+
 func WSAStartup(verreq uint32, data *WSAData) (sockerr error) {
 	r0, _, _ := syscall.Syscall(procWSAStartup.Addr(), 2, uintptr(verreq), uintptr(unsafe.Pointer(data)), 0)
 	if r0 != 0 {
diff --git a/src/cmd/vendor/golang.org/x/term/AUTHORS b/src/cmd/vendor/golang.org/x/term/AUTHORS
new file mode 100644
index 0000000000..15167cd746
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/term/AUTHORS
@@ -0,0 +1,3 @@
+# This source code refers to The Go Authors for copyright purposes.
+# The master list of authors is in the main Go distribution,
+# visible at http://tip.golang.org/AUTHORS.
diff --git a/src/cmd/vendor/golang.org/x/term/CONTRIBUTING.md b/src/cmd/vendor/golang.org/x/term/CONTRIBUTING.md
new file mode 100644
index 0000000000..d0485e887a
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/term/CONTRIBUTING.md
@@ -0,0 +1,26 @@
+# Contributing to Go
+
+Go is an open source project.
+
+It is the work of hundreds of contributors. We appreciate your help!
+
+## Filing issues
+
+When [filing an issue](https://golang.org/issue/new), make sure to answer these five questions:
+
+1.  What version of Go are you using (`go version`)?
+2.  What operating system and processor architecture are you using?
+3.  What did you do?
+4.  What did you expect to see?
+5.  What did you see instead?
+
+General questions should go to the [golang-nuts mailing list](https://groups.google.com/group/golang-nuts) instead of the issue tracker.
+The gophers there will answer or ask you to file an issue if you've tripped over a bug.
+
+## Contributing code
+
+Please read the [Contribution Guidelines](https://golang.org/doc/contribute.html)
+before sending patches.
+
+Unless otherwise noted, the Go source files are distributed under
+the BSD-style license found in the LICENSE file.
diff --git a/src/cmd/vendor/golang.org/x/term/CONTRIBUTORS b/src/cmd/vendor/golang.org/x/term/CONTRIBUTORS
new file mode 100644
index 0000000000..1c4577e968
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/term/CONTRIBUTORS
@@ -0,0 +1,3 @@
+# This source code was written by the Go contributors.
+# The master list of contributors is in the main Go distribution,
+# visible at http://tip.golang.org/CONTRIBUTORS.
diff --git a/src/cmd/vendor/golang.org/x/term/LICENSE b/src/cmd/vendor/golang.org/x/term/LICENSE
new file mode 100644
index 0000000000..6a66aea5ea
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/term/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2009 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/src/cmd/vendor/golang.org/x/term/PATENTS b/src/cmd/vendor/golang.org/x/term/PATENTS
new file mode 100644
index 0000000000..733099041f
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/term/PATENTS
@@ -0,0 +1,22 @@
+Additional IP Rights Grant (Patents)
+
+"This implementation" means the copyrightable works distributed by
+Google as part of the Go project.
+
+Google hereby grants to You a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable (except as stated in this section)
+patent license to make, have made, use, offer to sell, sell, import,
+transfer and otherwise run, modify and propagate the contents of this
+implementation of Go, where such license applies only to those patent
+claims, both currently owned or controlled by Google and acquired in
+the future, licensable by Google that are necessarily infringed by this
+implementation of Go.  This grant does not include claims that would be
+infringed only as a consequence of further modification of this
+implementation.  If you or your agent or exclusive licensee institute or
+order or agree to the institution of patent litigation against any
+entity (including a cross-claim or counterclaim in a lawsuit) alleging
+that this implementation of Go or any code incorporated within this
+implementation of Go constitutes direct or contributory patent
+infringement, or inducement of patent infringement, then any patent
+rights granted to you under this License for this implementation of Go
+shall terminate as of the date such litigation is filed.
diff --git a/src/cmd/vendor/golang.org/x/term/README.md b/src/cmd/vendor/golang.org/x/term/README.md
new file mode 100644
index 0000000000..d03d0aefef
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/term/README.md
@@ -0,0 +1,19 @@
+# Go terminal/console support
+
+[![Go Reference](https://pkg.go.dev/badge/golang.org/x/term.svg)](https://pkg.go.dev/golang.org/x/term)
+
+This repository provides Go terminal and console support packages.
+
+## Download/Install
+
+The easiest way to install is to run `go get -u golang.org/x/term`. You can
+also manually git clone the repository to `$GOPATH/src/golang.org/x/term`.
+
+## Report Issues / Send Patches
+
+This repository uses Gerrit for code changes. To learn how to submit changes to
+this repository, see https://golang.org/doc/contribute.html.
+
+The main issue tracker for the term repository is located at
+https://github.com/golang/go/issues. Prefix your issue with "x/term:" in the
+subject line, so it is easy to find.
diff --git a/src/cmd/vendor/golang.org/x/term/go.mod b/src/cmd/vendor/golang.org/x/term/go.mod
new file mode 100644
index 0000000000..d45f52851e
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/term/go.mod
@@ -0,0 +1,5 @@
+module golang.org/x/term
+
+go 1.11
+
+require golang.org/x/sys v0.0.0-20201119102817-f84b799fce68
diff --git a/src/cmd/vendor/golang.org/x/term/go.sum b/src/cmd/vendor/golang.org/x/term/go.sum
new file mode 100644
index 0000000000..de9e09c654
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/term/go.sum
@@ -0,0 +1,2 @@
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68 h1:nxC68pudNYkKU6jWhgrqdreuFiOQWj1Fs7T3VrH4Pjw=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
diff --git a/src/cmd/vendor/golang.org/x/crypto/ssh/terminal/util_plan9.go b/src/cmd/vendor/golang.org/x/term/term.go
similarity index 52%
rename from src/cmd/vendor/golang.org/x/crypto/ssh/terminal/util_plan9.go
rename to src/cmd/vendor/golang.org/x/term/term.go
index 9317ac7ede..2a4ccf8012 100644
--- a/src/cmd/vendor/golang.org/x/crypto/ssh/terminal/util_plan9.go
+++ b/src/cmd/vendor/golang.org/x/term/term.go
@@ -1,58 +1,58 @@
-// Copyright 2016 The Go Authors. All rights reserved.
+// Copyright 2019 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 terminal provides support functions for dealing with terminals, as
+// Package term provides support functions for dealing with terminals, as
 // commonly found on UNIX systems.
 //
 // Putting a terminal into raw mode is the most common requirement:
 //
-// 	oldState, err := terminal.MakeRaw(0)
+// 	oldState, err := term.MakeRaw(0)
 // 	if err != nil {
 // 	        panic(err)
 // 	}
-// 	defer terminal.Restore(0, oldState)
-package terminal
+// 	defer term.Restore(0, oldState)
+package term
 
-import (
-	"fmt"
-	"runtime"
-)
-
-type State struct{}
+// State contains the state of a terminal.
+type State struct {
+	state
+}
 
 // IsTerminal returns whether the given file descriptor is a terminal.
 func IsTerminal(fd int) bool {
-	return false
+	return isTerminal(fd)
 }
 
-// MakeRaw put the terminal connected to the given file descriptor into raw
+// MakeRaw puts the terminal connected to the given file descriptor into raw
 // mode and returns the previous state of the terminal so that it can be
 // restored.
 func MakeRaw(fd int) (*State, error) {
-	return nil, fmt.Errorf("terminal: MakeRaw not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
+	return makeRaw(fd)
 }
 
 // GetState returns the current state of a terminal which may be useful to
 // restore the terminal after a signal.
 func GetState(fd int) (*State, error) {
-	return nil, fmt.Errorf("terminal: GetState not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
+	return getState(fd)
 }
 
 // Restore restores the terminal connected to the given file descriptor to a
 // previous state.
-func Restore(fd int, state *State) error {
-	return fmt.Errorf("terminal: Restore not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
+func Restore(fd int, oldState *State) error {
+	return restore(fd, oldState)
 }
 
-// GetSize returns the dimensions of the given terminal.
+// GetSize returns the visible dimensions of the given terminal.
+//
+// These dimensions don't include any scrollback buffer height.
 func GetSize(fd int) (width, height int, err error) {
-	return 0, 0, fmt.Errorf("terminal: GetSize not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
+	return getSize(fd)
 }
 
 // ReadPassword reads a line of input from a terminal without local echo.  This
 // is commonly used for inputting passwords and other sensitive data. The slice
 // returned does not include the \n.
 func ReadPassword(fd int) ([]byte, error) {
-	return nil, fmt.Errorf("terminal: ReadPassword not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
+	return readPassword(fd)
 }
diff --git a/src/cmd/vendor/golang.org/x/term/term_plan9.go b/src/cmd/vendor/golang.org/x/term/term_plan9.go
new file mode 100644
index 0000000000..21afa55cdb
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/term/term_plan9.go
@@ -0,0 +1,42 @@
+// Copyright 2019 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 term
+
+import (
+	"fmt"
+	"runtime"
+
+	"golang.org/x/sys/plan9"
+)
+
+type state struct{}
+
+func isTerminal(fd int) bool {
+	path, err := plan9.Fd2path(fd)
+	if err != nil {
+		return false
+	}
+	return path == "/dev/cons" || path == "/mnt/term/dev/cons"
+}
+
+func makeRaw(fd int) (*State, error) {
+	return nil, fmt.Errorf("terminal: MakeRaw not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
+}
+
+func getState(fd int) (*State, error) {
+	return nil, fmt.Errorf("terminal: GetState not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
+}
+
+func restore(fd int, state *State) error {
+	return fmt.Errorf("terminal: Restore not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
+}
+
+func getSize(fd int) (width, height int, err error) {
+	return 0, 0, fmt.Errorf("terminal: GetSize not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
+}
+
+func readPassword(fd int) ([]byte, error) {
+	return nil, fmt.Errorf("terminal: ReadPassword not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
+}
diff --git a/src/cmd/vendor/golang.org/x/crypto/ssh/terminal/util_solaris.go b/src/cmd/vendor/golang.org/x/term/term_solaris.go
similarity index 61%
rename from src/cmd/vendor/golang.org/x/crypto/ssh/terminal/util_solaris.go
rename to src/cmd/vendor/golang.org/x/term/term_solaris.go
index 3d5f06a9f0..b9da29744b 100644
--- a/src/cmd/vendor/golang.org/x/crypto/ssh/terminal/util_solaris.go
+++ b/src/cmd/vendor/golang.org/x/term/term_solaris.go
@@ -1,32 +1,27 @@
-// Copyright 2015 The Go Authors. All rights reserved.
+// Copyright 2019 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.
 
-// +build solaris
-
-package terminal // import "golang.org/x/crypto/ssh/terminal"
+package term
 
 import (
-	"golang.org/x/sys/unix"
 	"io"
 	"syscall"
+
+	"golang.org/x/sys/unix"
 )
 
 // State contains the state of a terminal.
-type State struct {
+type state struct {
 	termios unix.Termios
 }
 
-// IsTerminal returns whether the given file descriptor is a terminal.
-func IsTerminal(fd int) bool {
+func isTerminal(fd int) bool {
 	_, err := unix.IoctlGetTermio(fd, unix.TCGETA)
 	return err == nil
 }
 
-// ReadPassword reads a line of input from a terminal without local echo.  This
-// is commonly used for inputting passwords and other sensitive data. The slice
-// returned does not include the \n.
-func ReadPassword(fd int) ([]byte, error) {
+func readPassword(fd int) ([]byte, error) {
 	// see also: http://src.illumos.org/source/xref/illumos-gate/usr/src/lib/libast/common/uwin/getpass.c
 	val, err := unix.IoctlGetTermios(fd, unix.TCGETS)
 	if err != nil {
@@ -70,17 +65,14 @@ func ReadPassword(fd int) ([]byte, error) {
 	return ret, nil
 }
 
-// MakeRaw puts the terminal connected to the given file descriptor into raw
-// mode and returns the previous state of the terminal so that it can be
-// restored.
-// see http://cr.illumos.org/~webrev/andy_js/1060/
-func MakeRaw(fd int) (*State, error) {
+func makeRaw(fd int) (*State, error) {
+	// see http://cr.illumos.org/~webrev/andy_js/1060/
 	termios, err := unix.IoctlGetTermios(fd, unix.TCGETS)
 	if err != nil {
 		return nil, err
 	}
 
-	oldState := State{termios: *termios}
+	oldState := State{state{termios: *termios}}
 
 	termios.Iflag &^= unix.IGNBRK | unix.BRKINT | unix.PARMRK | unix.ISTRIP | unix.INLCR | unix.IGNCR | unix.ICRNL | unix.IXON
 	termios.Oflag &^= unix.OPOST
@@ -97,25 +89,20 @@ func MakeRaw(fd int) (*State, error) {
 	return &oldState, nil
 }
 
-// Restore restores the terminal connected to the given file descriptor to a
-// previous state.
-func Restore(fd int, oldState *State) error {
+func restore(fd int, oldState *State) error {
 	return unix.IoctlSetTermios(fd, unix.TCSETS, &oldState.termios)
 }
 
-// GetState returns the current state of a terminal which may be useful to
-// restore the terminal after a signal.
-func GetState(fd int) (*State, error) {
+func getState(fd int) (*State, error) {
 	termios, err := unix.IoctlGetTermios(fd, unix.TCGETS)
 	if err != nil {
 		return nil, err
 	}
 
-	return &State{termios: *termios}, nil
+	return &State{state{termios: *termios}}, nil
 }
 
-// GetSize returns the dimensions of the given terminal.
-func GetSize(fd int) (width, height int, err error) {
+func getSize(fd int) (width, height int, err error) {
 	ws, err := unix.IoctlGetWinsize(fd, unix.TIOCGWINSZ)
 	if err != nil {
 		return 0, 0, err
diff --git a/src/cmd/vendor/golang.org/x/crypto/ssh/terminal/util.go b/src/cmd/vendor/golang.org/x/term/term_unix.go
similarity index 53%
rename from src/cmd/vendor/golang.org/x/crypto/ssh/terminal/util.go
rename to src/cmd/vendor/golang.org/x/term/term_unix.go
index 3911040840..6849b6ee5b 100644
--- a/src/cmd/vendor/golang.org/x/crypto/ssh/terminal/util.go
+++ b/src/cmd/vendor/golang.org/x/term/term_unix.go
@@ -1,46 +1,32 @@
-// Copyright 2011 The Go Authors. All rights reserved.
+// Copyright 2019 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.
 
-// +build aix darwin dragonfly freebsd linux,!appengine netbsd openbsd
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || zos
+// +build aix darwin dragonfly freebsd linux netbsd openbsd zos
 
-// Package terminal provides support functions for dealing with terminals, as
-// commonly found on UNIX systems.
-//
-// Putting a terminal into raw mode is the most common requirement:
-//
-// 	oldState, err := terminal.MakeRaw(0)
-// 	if err != nil {
-// 	        panic(err)
-// 	}
-// 	defer terminal.Restore(0, oldState)
-package terminal // import "golang.org/x/crypto/ssh/terminal"
+package term
 
 import (
 	"golang.org/x/sys/unix"
 )
 
-// State contains the state of a terminal.
-type State struct {
+type state struct {
 	termios unix.Termios
 }
 
-// IsTerminal returns whether the given file descriptor is a terminal.
-func IsTerminal(fd int) bool {
+func isTerminal(fd int) bool {
 	_, err := unix.IoctlGetTermios(fd, ioctlReadTermios)
 	return err == nil
 }
 
-// MakeRaw put the terminal connected to the given file descriptor into raw
-// mode and returns the previous state of the terminal so that it can be
-// restored.
-func MakeRaw(fd int) (*State, error) {
+func makeRaw(fd int) (*State, error) {
 	termios, err := unix.IoctlGetTermios(fd, ioctlReadTermios)
 	if err != nil {
 		return nil, err
 	}
 
-	oldState := State{termios: *termios}
+	oldState := State{state{termios: *termios}}
 
 	// This attempts to replicate the behaviour documented for cfmakeraw in
 	// the termios(3) manpage.
@@ -58,25 +44,20 @@ func MakeRaw(fd int) (*State, error) {
 	return &oldState, nil
 }
 
-// GetState returns the current state of a terminal which may be useful to
-// restore the terminal after a signal.
-func GetState(fd int) (*State, error) {
+func getState(fd int) (*State, error) {
 	termios, err := unix.IoctlGetTermios(fd, ioctlReadTermios)
 	if err != nil {
 		return nil, err
 	}
 
-	return &State{termios: *termios}, nil
+	return &State{state{termios: *termios}}, nil
 }
 
-// Restore restores the terminal connected to the given file descriptor to a
-// previous state.
-func Restore(fd int, state *State) error {
+func restore(fd int, state *State) error {
 	return unix.IoctlSetTermios(fd, ioctlWriteTermios, &state.termios)
 }
 
-// GetSize returns the dimensions of the given terminal.
-func GetSize(fd int) (width, height int, err error) {
+func getSize(fd int) (width, height int, err error) {
 	ws, err := unix.IoctlGetWinsize(fd, unix.TIOCGWINSZ)
 	if err != nil {
 		return -1, -1, err
@@ -91,10 +72,7 @@ func (r passwordReader) Read(buf []byte) (int, error) {
 	return unix.Read(int(r), buf)
 }
 
-// ReadPassword reads a line of input from a terminal without local echo.  This
-// is commonly used for inputting passwords and other sensitive data. The slice
-// returned does not include the \n.
-func ReadPassword(fd int) ([]byte, error) {
+func readPassword(fd int) ([]byte, error) {
 	termios, err := unix.IoctlGetTermios(fd, ioctlReadTermios)
 	if err != nil {
 		return nil, err
diff --git a/src/cmd/vendor/golang.org/x/crypto/ssh/terminal/util_linux.go b/src/cmd/vendor/golang.org/x/term/term_unix_aix.go
similarity index 74%
rename from src/cmd/vendor/golang.org/x/crypto/ssh/terminal/util_linux.go
rename to src/cmd/vendor/golang.org/x/term/term_unix_aix.go
index 5fadfe8a1d..2d5efd26ad 100644
--- a/src/cmd/vendor/golang.org/x/crypto/ssh/terminal/util_linux.go
+++ b/src/cmd/vendor/golang.org/x/term/term_unix_aix.go
@@ -1,8 +1,8 @@
-// Copyright 2013 The Go Authors. All rights reserved.
+// Copyright 2019 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 terminal
+package term
 
 import "golang.org/x/sys/unix"
 
diff --git a/src/cmd/vendor/golang.org/x/crypto/ssh/terminal/util_bsd.go b/src/cmd/vendor/golang.org/x/term/term_unix_bsd.go
similarity index 80%
rename from src/cmd/vendor/golang.org/x/crypto/ssh/terminal/util_bsd.go
rename to src/cmd/vendor/golang.org/x/term/term_unix_bsd.go
index cb23a59049..853b3d6986 100644
--- a/src/cmd/vendor/golang.org/x/crypto/ssh/terminal/util_bsd.go
+++ b/src/cmd/vendor/golang.org/x/term/term_unix_bsd.go
@@ -2,9 +2,10 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || netbsd || openbsd
 // +build darwin dragonfly freebsd netbsd openbsd
 
-package terminal
+package term
 
 import "golang.org/x/sys/unix"
 
diff --git a/src/cmd/vendor/golang.org/x/crypto/ssh/terminal/util_aix.go b/src/cmd/vendor/golang.org/x/term/term_unix_linux.go
similarity index 71%
rename from src/cmd/vendor/golang.org/x/crypto/ssh/terminal/util_aix.go
rename to src/cmd/vendor/golang.org/x/term/term_unix_linux.go
index dfcd627859..2d5efd26ad 100644
--- a/src/cmd/vendor/golang.org/x/crypto/ssh/terminal/util_aix.go
+++ b/src/cmd/vendor/golang.org/x/term/term_unix_linux.go
@@ -1,10 +1,8 @@
-// Copyright 2018 The Go Authors. All rights reserved.
+// Copyright 2019 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.
 
-// +build aix
-
-package terminal
+package term
 
 import "golang.org/x/sys/unix"
 
diff --git a/src/cmd/vendor/golang.org/x/term/term_unix_zos.go b/src/cmd/vendor/golang.org/x/term/term_unix_zos.go
new file mode 100644
index 0000000000..b85ab89989
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/term/term_unix_zos.go
@@ -0,0 +1,10 @@
+// Copyright 2020 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 term
+
+import "golang.org/x/sys/unix"
+
+const ioctlReadTermios = unix.TCGETS
+const ioctlWriteTermios = unix.TCSETS
diff --git a/src/cmd/vendor/golang.org/x/term/term_unsupported.go b/src/cmd/vendor/golang.org/x/term/term_unsupported.go
new file mode 100644
index 0000000000..f1df850651
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/term/term_unsupported.go
@@ -0,0 +1,39 @@
+// Copyright 2019 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.
+
+//go:build !aix && !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !zos && !windows && !solaris && !plan9
+// +build !aix,!darwin,!dragonfly,!freebsd,!linux,!netbsd,!openbsd,!zos,!windows,!solaris,!plan9
+
+package term
+
+import (
+	"fmt"
+	"runtime"
+)
+
+type state struct{}
+
+func isTerminal(fd int) bool {
+	return false
+}
+
+func makeRaw(fd int) (*State, error) {
+	return nil, fmt.Errorf("terminal: MakeRaw not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
+}
+
+func getState(fd int) (*State, error) {
+	return nil, fmt.Errorf("terminal: GetState not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
+}
+
+func restore(fd int, state *State) error {
+	return fmt.Errorf("terminal: Restore not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
+}
+
+func getSize(fd int) (width, height int, err error) {
+	return 0, 0, fmt.Errorf("terminal: GetSize not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
+}
+
+func readPassword(fd int) ([]byte, error) {
+	return nil, fmt.Errorf("terminal: ReadPassword not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
+}
diff --git a/src/cmd/vendor/golang.org/x/crypto/ssh/terminal/util_windows.go b/src/cmd/vendor/golang.org/x/term/term_windows.go
similarity index 53%
rename from src/cmd/vendor/golang.org/x/crypto/ssh/terminal/util_windows.go
rename to src/cmd/vendor/golang.org/x/term/term_windows.go
index f614e9cb60..465f560604 100644
--- a/src/cmd/vendor/golang.org/x/crypto/ssh/terminal/util_windows.go
+++ b/src/cmd/vendor/golang.org/x/term/term_windows.go
@@ -1,20 +1,8 @@
-// Copyright 2011 The Go Authors. All rights reserved.
+// Copyright 2019 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.
 
-// +build windows
-
-// Package terminal provides support functions for dealing with terminals, as
-// commonly found on UNIX systems.
-//
-// Putting a terminal into raw mode is the most common requirement:
-//
-// 	oldState, err := terminal.MakeRaw(0)
-// 	if err != nil {
-// 	        panic(err)
-// 	}
-// 	defer terminal.Restore(0, oldState)
-package terminal
+package term
 
 import (
 	"os"
@@ -22,21 +10,17 @@ import (
 	"golang.org/x/sys/windows"
 )
 
-type State struct {
+type state struct {
 	mode uint32
 }
 
-// IsTerminal returns whether the given file descriptor is a terminal.
-func IsTerminal(fd int) bool {
+func isTerminal(fd int) bool {
 	var st uint32
 	err := windows.GetConsoleMode(windows.Handle(fd), &st)
 	return err == nil
 }
 
-// MakeRaw put the terminal connected to the given file descriptor into raw
-// mode and returns the previous state of the terminal so that it can be
-// restored.
-func MakeRaw(fd int) (*State, error) {
+func makeRaw(fd int) (*State, error) {
 	var st uint32
 	if err := windows.GetConsoleMode(windows.Handle(fd), &st); err != nil {
 		return nil, err
@@ -45,29 +29,22 @@ func MakeRaw(fd int) (*State, error) {
 	if err := windows.SetConsoleMode(windows.Handle(fd), raw); err != nil {
 		return nil, err
 	}
-	return &State{st}, nil
+	return &State{state{st}}, nil
 }
 
-// GetState returns the current state of a terminal which may be useful to
-// restore the terminal after a signal.
-func GetState(fd int) (*State, error) {
+func getState(fd int) (*State, error) {
 	var st uint32
 	if err := windows.GetConsoleMode(windows.Handle(fd), &st); err != nil {
 		return nil, err
 	}
-	return &State{st}, nil
+	return &State{state{st}}, nil
 }
 
-// Restore restores the terminal connected to the given file descriptor to a
-// previous state.
-func Restore(fd int, state *State) error {
+func restore(fd int, state *State) error {
 	return windows.SetConsoleMode(windows.Handle(fd), state.mode)
 }
 
-// GetSize returns the visible dimensions of the given terminal.
-//
-// These dimensions don't include any scrollback buffer height.
-func GetSize(fd int) (width, height int, err error) {
+func getSize(fd int) (width, height int, err error) {
 	var info windows.ConsoleScreenBufferInfo
 	if err := windows.GetConsoleScreenBufferInfo(windows.Handle(fd), &info); err != nil {
 		return 0, 0, err
@@ -75,10 +52,7 @@ func GetSize(fd int) (width, height int, err error) {
 	return int(info.Window.Right - info.Window.Left + 1), int(info.Window.Bottom - info.Window.Top + 1), nil
 }
 
-// ReadPassword reads a line of input from a terminal without local echo.  This
-// is commonly used for inputting passwords and other sensitive data. The slice
-// returned does not include the \n.
-func ReadPassword(fd int) ([]byte, error) {
+func readPassword(fd int) ([]byte, error) {
 	var st uint32
 	if err := windows.GetConsoleMode(windows.Handle(fd), &st); err != nil {
 		return nil, err
diff --git a/src/cmd/vendor/golang.org/x/term/terminal.go b/src/cmd/vendor/golang.org/x/term/terminal.go
new file mode 100644
index 0000000000..535ab8257c
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/term/terminal.go
@@ -0,0 +1,987 @@
+// Copyright 2011 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 term
+
+import (
+	"bytes"
+	"io"
+	"runtime"
+	"strconv"
+	"sync"
+	"unicode/utf8"
+)
+
+// EscapeCodes contains escape sequences that can be written to the terminal in
+// order to achieve different styles of text.
+type EscapeCodes struct {
+	// Foreground colors
+	Black, Red, Green, Yellow, Blue, Magenta, Cyan, White []byte
+
+	// Reset all attributes
+	Reset []byte
+}
+
+var vt100EscapeCodes = EscapeCodes{
+	Black:   []byte{keyEscape, '[', '3', '0', 'm'},
+	Red:     []byte{keyEscape, '[', '3', '1', 'm'},
+	Green:   []byte{keyEscape, '[', '3', '2', 'm'},
+	Yellow:  []byte{keyEscape, '[', '3', '3', 'm'},
+	Blue:    []byte{keyEscape, '[', '3', '4', 'm'},
+	Magenta: []byte{keyEscape, '[', '3', '5', 'm'},
+	Cyan:    []byte{keyEscape, '[', '3', '6', 'm'},
+	White:   []byte{keyEscape, '[', '3', '7', 'm'},
+
+	Reset: []byte{keyEscape, '[', '0', 'm'},
+}
+
+// Terminal contains the state for running a VT100 terminal that is capable of
+// reading lines of input.
+type Terminal struct {
+	// AutoCompleteCallback, if non-null, is called for each keypress with
+	// the full input line and the current position of the cursor (in
+	// bytes, as an index into |line|). If it returns ok=false, the key
+	// press is processed normally. Otherwise it returns a replacement line
+	// and the new cursor position.
+	AutoCompleteCallback func(line string, pos int, key rune) (newLine string, newPos int, ok bool)
+
+	// Escape contains a pointer to the escape codes for this terminal.
+	// It's always a valid pointer, although the escape codes themselves
+	// may be empty if the terminal doesn't support them.
+	Escape *EscapeCodes
+
+	// lock protects the terminal and the state in this object from
+	// concurrent processing of a key press and a Write() call.
+	lock sync.Mutex
+
+	c      io.ReadWriter
+	prompt []rune
+
+	// line is the current line being entered.
+	line []rune
+	// pos is the logical position of the cursor in line
+	pos int
+	// echo is true if local echo is enabled
+	echo bool
+	// pasteActive is true iff there is a bracketed paste operation in
+	// progress.
+	pasteActive bool
+
+	// cursorX contains the current X value of the cursor where the left
+	// edge is 0. cursorY contains the row number where the first row of
+	// the current line is 0.
+	cursorX, cursorY int
+	// maxLine is the greatest value of cursorY so far.
+	maxLine int
+
+	termWidth, termHeight int
+
+	// outBuf contains the terminal data to be sent.
+	outBuf []byte
+	// remainder contains the remainder of any partial key sequences after
+	// a read. It aliases into inBuf.
+	remainder []byte
+	inBuf     [256]byte
+
+	// history contains previously entered commands so that they can be
+	// accessed with the up and down keys.
+	history stRingBuffer
+	// historyIndex stores the currently accessed history entry, where zero
+	// means the immediately previous entry.
+	historyIndex int
+	// When navigating up and down the history it's possible to return to
+	// the incomplete, initial line. That value is stored in
+	// historyPending.
+	historyPending string
+}
+
+// NewTerminal runs a VT100 terminal on the given ReadWriter. If the ReadWriter is
+// a local terminal, that terminal must first have been put into raw mode.
+// prompt is a string that is written at the start of each input line (i.e.
+// "> ").
+func NewTerminal(c io.ReadWriter, prompt string) *Terminal {
+	return &Terminal{
+		Escape:       &vt100EscapeCodes,
+		c:            c,
+		prompt:       []rune(prompt),
+		termWidth:    80,
+		termHeight:   24,
+		echo:         true,
+		historyIndex: -1,
+	}
+}
+
+const (
+	keyCtrlC     = 3
+	keyCtrlD     = 4
+	keyCtrlU     = 21
+	keyEnter     = '\r'
+	keyEscape    = 27
+	keyBackspace = 127
+	keyUnknown   = 0xd800 /* UTF-16 surrogate area */ + iota
+	keyUp
+	keyDown
+	keyLeft
+	keyRight
+	keyAltLeft
+	keyAltRight
+	keyHome
+	keyEnd
+	keyDeleteWord
+	keyDeleteLine
+	keyClearScreen
+	keyPasteStart
+	keyPasteEnd
+)
+
+var (
+	crlf       = []byte{'\r', '\n'}
+	pasteStart = []byte{keyEscape, '[', '2', '0', '0', '~'}
+	pasteEnd   = []byte{keyEscape, '[', '2', '0', '1', '~'}
+)
+
+// bytesToKey tries to parse a key sequence from b. If successful, it returns
+// the key and the remainder of the input. Otherwise it returns utf8.RuneError.
+func bytesToKey(b []byte, pasteActive bool) (rune, []byte) {
+	if len(b) == 0 {
+		return utf8.RuneError, nil
+	}
+
+	if !pasteActive {
+		switch b[0] {
+		case 1: // ^A
+			return keyHome, b[1:]
+		case 2: // ^B
+			return keyLeft, b[1:]
+		case 5: // ^E
+			return keyEnd, b[1:]
+		case 6: // ^F
+			return keyRight, b[1:]
+		case 8: // ^H
+			return keyBackspace, b[1:]
+		case 11: // ^K
+			return keyDeleteLine, b[1:]
+		case 12: // ^L
+			return keyClearScreen, b[1:]
+		case 23: // ^W
+			return keyDeleteWord, b[1:]
+		case 14: // ^N
+			return keyDown, b[1:]
+		case 16: // ^P
+			return keyUp, b[1:]
+		}
+	}
+
+	if b[0] != keyEscape {
+		if !utf8.FullRune(b) {
+			return utf8.RuneError, b
+		}
+		r, l := utf8.DecodeRune(b)
+		return r, b[l:]
+	}
+
+	if !pasteActive && len(b) >= 3 && b[0] == keyEscape && b[1] == '[' {
+		switch b[2] {
+		case 'A':
+			return keyUp, b[3:]
+		case 'B':
+			return keyDown, b[3:]
+		case 'C':
+			return keyRight, b[3:]
+		case 'D':
+			return keyLeft, b[3:]
+		case 'H':
+			return keyHome, b[3:]
+		case 'F':
+			return keyEnd, b[3:]
+		}
+	}
+
+	if !pasteActive && len(b) >= 6 && b[0] == keyEscape && b[1] == '[' && b[2] == '1' && b[3] == ';' && b[4] == '3' {
+		switch b[5] {
+		case 'C':
+			return keyAltRight, b[6:]
+		case 'D':
+			return keyAltLeft, b[6:]
+		}
+	}
+
+	if !pasteActive && len(b) >= 6 && bytes.Equal(b[:6], pasteStart) {
+		return keyPasteStart, b[6:]
+	}
+
+	if pasteActive && len(b) >= 6 && bytes.Equal(b[:6], pasteEnd) {
+		return keyPasteEnd, b[6:]
+	}
+
+	// If we get here then we have a key that we don't recognise, or a
+	// partial sequence. It's not clear how one should find the end of a
+	// sequence without knowing them all, but it seems that [a-zA-Z~] only
+	// appears at the end of a sequence.
+	for i, c := range b[0:] {
+		if c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c == '~' {
+			return keyUnknown, b[i+1:]
+		}
+	}
+
+	return utf8.RuneError, b
+}
+
+// queue appends data to the end of t.outBuf
+func (t *Terminal) queue(data []rune) {
+	t.outBuf = append(t.outBuf, []byte(string(data))...)
+}
+
+var eraseUnderCursor = []rune{' ', keyEscape, '[', 'D'}
+var space = []rune{' '}
+
+func isPrintable(key rune) bool {
+	isInSurrogateArea := key >= 0xd800 && key <= 0xdbff
+	return key >= 32 && !isInSurrogateArea
+}
+
+// moveCursorToPos appends data to t.outBuf which will move the cursor to the
+// given, logical position in the text.
+func (t *Terminal) moveCursorToPos(pos int) {
+	if !t.echo {
+		return
+	}
+
+	x := visualLength(t.prompt) + pos
+	y := x / t.termWidth
+	x = x % t.termWidth
+
+	up := 0
+	if y < t.cursorY {
+		up = t.cursorY - y
+	}
+
+	down := 0
+	if y > t.cursorY {
+		down = y - t.cursorY
+	}
+
+	left := 0
+	if x < t.cursorX {
+		left = t.cursorX - x
+	}
+
+	right := 0
+	if x > t.cursorX {
+		right = x - t.cursorX
+	}
+
+	t.cursorX = x
+	t.cursorY = y
+	t.move(up, down, left, right)
+}
+
+func (t *Terminal) move(up, down, left, right int) {
+	m := []rune{}
+
+	// 1 unit up can be expressed as ^[[A or ^[A
+	// 5 units up can be expressed as ^[[5A
+
+	if up == 1 {
+		m = append(m, keyEscape, '[', 'A')
+	} else if up > 1 {
+		m = append(m, keyEscape, '[')
+		m = append(m, []rune(strconv.Itoa(up))...)
+		m = append(m, 'A')
+	}
+
+	if down == 1 {
+		m = append(m, keyEscape, '[', 'B')
+	} else if down > 1 {
+		m = append(m, keyEscape, '[')
+		m = append(m, []rune(strconv.Itoa(down))...)
+		m = append(m, 'B')
+	}
+
+	if right == 1 {
+		m = append(m, keyEscape, '[', 'C')
+	} else if right > 1 {
+		m = append(m, keyEscape, '[')
+		m = append(m, []rune(strconv.Itoa(right))...)
+		m = append(m, 'C')
+	}
+
+	if left == 1 {
+		m = append(m, keyEscape, '[', 'D')
+	} else if left > 1 {
+		m = append(m, keyEscape, '[')
+		m = append(m, []rune(strconv.Itoa(left))...)
+		m = append(m, 'D')
+	}
+
+	t.queue(m)
+}
+
+func (t *Terminal) clearLineToRight() {
+	op := []rune{keyEscape, '[', 'K'}
+	t.queue(op)
+}
+
+const maxLineLength = 4096
+
+func (t *Terminal) setLine(newLine []rune, newPos int) {
+	if t.echo {
+		t.moveCursorToPos(0)
+		t.writeLine(newLine)
+		for i := len(newLine); i < len(t.line); i++ {
+			t.writeLine(space)
+		}
+		t.moveCursorToPos(newPos)
+	}
+	t.line = newLine
+	t.pos = newPos
+}
+
+func (t *Terminal) advanceCursor(places int) {
+	t.cursorX += places
+	t.cursorY += t.cursorX / t.termWidth
+	if t.cursorY > t.maxLine {
+		t.maxLine = t.cursorY
+	}
+	t.cursorX = t.cursorX % t.termWidth
+
+	if places > 0 && t.cursorX == 0 {
+		// Normally terminals will advance the current position
+		// when writing a character. But that doesn't happen
+		// for the last character in a line. However, when
+		// writing a character (except a new line) that causes
+		// a line wrap, the position will be advanced two
+		// places.
+		//
+		// So, if we are stopping at the end of a line, we
+		// need to write a newline so that our cursor can be
+		// advanced to the next line.
+		t.outBuf = append(t.outBuf, '\r', '\n')
+	}
+}
+
+func (t *Terminal) eraseNPreviousChars(n int) {
+	if n == 0 {
+		return
+	}
+
+	if t.pos < n {
+		n = t.pos
+	}
+	t.pos -= n
+	t.moveCursorToPos(t.pos)
+
+	copy(t.line[t.pos:], t.line[n+t.pos:])
+	t.line = t.line[:len(t.line)-n]
+	if t.echo {
+		t.writeLine(t.line[t.pos:])
+		for i := 0; i < n; i++ {
+			t.queue(space)
+		}
+		t.advanceCursor(n)
+		t.moveCursorToPos(t.pos)
+	}
+}
+
+// countToLeftWord returns then number of characters from the cursor to the
+// start of the previous word.
+func (t *Terminal) countToLeftWord() int {
+	if t.pos == 0 {
+		return 0
+	}
+
+	pos := t.pos - 1
+	for pos > 0 {
+		if t.line[pos] != ' ' {
+			break
+		}
+		pos--
+	}
+	for pos > 0 {
+		if t.line[pos] == ' ' {
+			pos++
+			break
+		}
+		pos--
+	}
+
+	return t.pos - pos
+}
+
+// countToRightWord returns then number of characters from the cursor to the
+// start of the next word.
+func (t *Terminal) countToRightWord() int {
+	pos := t.pos
+	for pos < len(t.line) {
+		if t.line[pos] == ' ' {
+			break
+		}
+		pos++
+	}
+	for pos < len(t.line) {
+		if t.line[pos] != ' ' {
+			break
+		}
+		pos++
+	}
+	return pos - t.pos
+}
+
+// visualLength returns the number of visible glyphs in s.
+func visualLength(runes []rune) int {
+	inEscapeSeq := false
+	length := 0
+
+	for _, r := range runes {
+		switch {
+		case inEscapeSeq:
+			if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') {
+				inEscapeSeq = false
+			}
+		case r == '\x1b':
+			inEscapeSeq = true
+		default:
+			length++
+		}
+	}
+
+	return length
+}
+
+// handleKey processes the given key and, optionally, returns a line of text
+// that the user has entered.
+func (t *Terminal) handleKey(key rune) (line string, ok bool) {
+	if t.pasteActive && key != keyEnter {
+		t.addKeyToLine(key)
+		return
+	}
+
+	switch key {
+	case keyBackspace:
+		if t.pos == 0 {
+			return
+		}
+		t.eraseNPreviousChars(1)
+	case keyAltLeft:
+		// move left by a word.
+		t.pos -= t.countToLeftWord()
+		t.moveCursorToPos(t.pos)
+	case keyAltRight:
+		// move right by a word.
+		t.pos += t.countToRightWord()
+		t.moveCursorToPos(t.pos)
+	case keyLeft:
+		if t.pos == 0 {
+			return
+		}
+		t.pos--
+		t.moveCursorToPos(t.pos)
+	case keyRight:
+		if t.pos == len(t.line) {
+			return
+		}
+		t.pos++
+		t.moveCursorToPos(t.pos)
+	case keyHome:
+		if t.pos == 0 {
+			return
+		}
+		t.pos = 0
+		t.moveCursorToPos(t.pos)
+	case keyEnd:
+		if t.pos == len(t.line) {
+			return
+		}
+		t.pos = len(t.line)
+		t.moveCursorToPos(t.pos)
+	case keyUp:
+		entry, ok := t.history.NthPreviousEntry(t.historyIndex + 1)
+		if !ok {
+			return "", false
+		}
+		if t.historyIndex == -1 {
+			t.historyPending = string(t.line)
+		}
+		t.historyIndex++
+		runes := []rune(entry)
+		t.setLine(runes, len(runes))
+	case keyDown:
+		switch t.historyIndex {
+		case -1:
+			return
+		case 0:
+			runes := []rune(t.historyPending)
+			t.setLine(runes, len(runes))
+			t.historyIndex--
+		default:
+			entry, ok := t.history.NthPreviousEntry(t.historyIndex - 1)
+			if ok {
+				t.historyIndex--
+				runes := []rune(entry)
+				t.setLine(runes, len(runes))
+			}
+		}
+	case keyEnter:
+		t.moveCursorToPos(len(t.line))
+		t.queue([]rune("\r\n"))
+		line = string(t.line)
+		ok = true
+		t.line = t.line[:0]
+		t.pos = 0
+		t.cursorX = 0
+		t.cursorY = 0
+		t.maxLine = 0
+	case keyDeleteWord:
+		// Delete zero or more spaces and then one or more characters.
+		t.eraseNPreviousChars(t.countToLeftWord())
+	case keyDeleteLine:
+		// Delete everything from the current cursor position to the
+		// end of line.
+		for i := t.pos; i < len(t.line); i++ {
+			t.queue(space)
+			t.advanceCursor(1)
+		}
+		t.line = t.line[:t.pos]
+		t.moveCursorToPos(t.pos)
+	case keyCtrlD:
+		// Erase the character under the current position.
+		// The EOF case when the line is empty is handled in
+		// readLine().
+		if t.pos < len(t.line) {
+			t.pos++
+			t.eraseNPreviousChars(1)
+		}
+	case keyCtrlU:
+		t.eraseNPreviousChars(t.pos)
+	case keyClearScreen:
+		// Erases the screen and moves the cursor to the home position.
+		t.queue([]rune("\x1b[2J\x1b[H"))
+		t.queue(t.prompt)
+		t.cursorX, t.cursorY = 0, 0
+		t.advanceCursor(visualLength(t.prompt))
+		t.setLine(t.line, t.pos)
+	default:
+		if t.AutoCompleteCallback != nil {
+			prefix := string(t.line[:t.pos])
+			suffix := string(t.line[t.pos:])
+
+			t.lock.Unlock()
+			newLine, newPos, completeOk := t.AutoCompleteCallback(prefix+suffix, len(prefix), key)
+			t.lock.Lock()
+
+			if completeOk {
+				t.setLine([]rune(newLine), utf8.RuneCount([]byte(newLine)[:newPos]))
+				return
+			}
+		}
+		if !isPrintable(key) {
+			return
+		}
+		if len(t.line) == maxLineLength {
+			return
+		}
+		t.addKeyToLine(key)
+	}
+	return
+}
+
+// addKeyToLine inserts the given key at the current position in the current
+// line.
+func (t *Terminal) addKeyToLine(key rune) {
+	if len(t.line) == cap(t.line) {
+		newLine := make([]rune, len(t.line), 2*(1+len(t.line)))
+		copy(newLine, t.line)
+		t.line = newLine
+	}
+	t.line = t.line[:len(t.line)+1]
+	copy(t.line[t.pos+1:], t.line[t.pos:])
+	t.line[t.pos] = key
+	if t.echo {
+		t.writeLine(t.line[t.pos:])
+	}
+	t.pos++
+	t.moveCursorToPos(t.pos)
+}
+
+func (t *Terminal) writeLine(line []rune) {
+	for len(line) != 0 {
+		remainingOnLine := t.termWidth - t.cursorX
+		todo := len(line)
+		if todo > remainingOnLine {
+			todo = remainingOnLine
+		}
+		t.queue(line[:todo])
+		t.advanceCursor(visualLength(line[:todo]))
+		line = line[todo:]
+	}
+}
+
+// writeWithCRLF writes buf to w but replaces all occurrences of \n with \r\n.
+func writeWithCRLF(w io.Writer, buf []byte) (n int, err error) {
+	for len(buf) > 0 {
+		i := bytes.IndexByte(buf, '\n')
+		todo := len(buf)
+		if i >= 0 {
+			todo = i
+		}
+
+		var nn int
+		nn, err = w.Write(buf[:todo])
+		n += nn
+		if err != nil {
+			return n, err
+		}
+		buf = buf[todo:]
+
+		if i >= 0 {
+			if _, err = w.Write(crlf); err != nil {
+				return n, err
+			}
+			n++
+			buf = buf[1:]
+		}
+	}
+
+	return n, nil
+}
+
+func (t *Terminal) Write(buf []byte) (n int, err error) {
+	t.lock.Lock()
+	defer t.lock.Unlock()
+
+	if t.cursorX == 0 && t.cursorY == 0 {
+		// This is the easy case: there's nothing on the screen that we
+		// have to move out of the way.
+		return writeWithCRLF(t.c, buf)
+	}
+
+	// We have a prompt and possibly user input on the screen. We
+	// have to clear it first.
+	t.move(0 /* up */, 0 /* down */, t.cursorX /* left */, 0 /* right */)
+	t.cursorX = 0
+	t.clearLineToRight()
+
+	for t.cursorY > 0 {
+		t.move(1 /* up */, 0, 0, 0)
+		t.cursorY--
+		t.clearLineToRight()
+	}
+
+	if _, err = t.c.Write(t.outBuf); err != nil {
+		return
+	}
+	t.outBuf = t.outBuf[:0]
+
+	if n, err = writeWithCRLF(t.c, buf); err != nil {
+		return
+	}
+
+	t.writeLine(t.prompt)
+	if t.echo {
+		t.writeLine(t.line)
+	}
+
+	t.moveCursorToPos(t.pos)
+
+	if _, err = t.c.Write(t.outBuf); err != nil {
+		return
+	}
+	t.outBuf = t.outBuf[:0]
+	return
+}
+
+// ReadPassword temporarily changes the prompt and reads a password, without
+// echo, from the terminal.
+func (t *Terminal) ReadPassword(prompt string) (line string, err error) {
+	t.lock.Lock()
+	defer t.lock.Unlock()
+
+	oldPrompt := t.prompt
+	t.prompt = []rune(prompt)
+	t.echo = false
+
+	line, err = t.readLine()
+
+	t.prompt = oldPrompt
+	t.echo = true
+
+	return
+}
+
+// ReadLine returns a line of input from the terminal.
+func (t *Terminal) ReadLine() (line string, err error) {
+	t.lock.Lock()
+	defer t.lock.Unlock()
+
+	return t.readLine()
+}
+
+func (t *Terminal) readLine() (line string, err error) {
+	// t.lock must be held at this point
+
+	if t.cursorX == 0 && t.cursorY == 0 {
+		t.writeLine(t.prompt)
+		t.c.Write(t.outBuf)
+		t.outBuf = t.outBuf[:0]
+	}
+
+	lineIsPasted := t.pasteActive
+
+	for {
+		rest := t.remainder
+		lineOk := false
+		for !lineOk {
+			var key rune
+			key, rest = bytesToKey(rest, t.pasteActive)
+			if key == utf8.RuneError {
+				break
+			}
+			if !t.pasteActive {
+				if key == keyCtrlD {
+					if len(t.line) == 0 {
+						return "", io.EOF
+					}
+				}
+				if key == keyCtrlC {
+					return "", io.EOF
+				}
+				if key == keyPasteStart {
+					t.pasteActive = true
+					if len(t.line) == 0 {
+						lineIsPasted = true
+					}
+					continue
+				}
+			} else if key == keyPasteEnd {
+				t.pasteActive = false
+				continue
+			}
+			if !t.pasteActive {
+				lineIsPasted = false
+			}
+			line, lineOk = t.handleKey(key)
+		}
+		if len(rest) > 0 {
+			n := copy(t.inBuf[:], rest)
+			t.remainder = t.inBuf[:n]
+		} else {
+			t.remainder = nil
+		}
+		t.c.Write(t.outBuf)
+		t.outBuf = t.outBuf[:0]
+		if lineOk {
+			if t.echo {
+				t.historyIndex = -1
+				t.history.Add(line)
+			}
+			if lineIsPasted {
+				err = ErrPasteIndicator
+			}
+			return
+		}
+
+		// t.remainder is a slice at the beginning of t.inBuf
+		// containing a partial key sequence
+		readBuf := t.inBuf[len(t.remainder):]
+		var n int
+
+		t.lock.Unlock()
+		n, err = t.c.Read(readBuf)
+		t.lock.Lock()
+
+		if err != nil {
+			return
+		}
+
+		t.remainder = t.inBuf[:n+len(t.remainder)]
+	}
+}
+
+// SetPrompt sets the prompt to be used when reading subsequent lines.
+func (t *Terminal) SetPrompt(prompt string) {
+	t.lock.Lock()
+	defer t.lock.Unlock()
+
+	t.prompt = []rune(prompt)
+}
+
+func (t *Terminal) clearAndRepaintLinePlusNPrevious(numPrevLines int) {
+	// Move cursor to column zero at the start of the line.
+	t.move(t.cursorY, 0, t.cursorX, 0)
+	t.cursorX, t.cursorY = 0, 0
+	t.clearLineToRight()
+	for t.cursorY < numPrevLines {
+		// Move down a line
+		t.move(0, 1, 0, 0)
+		t.cursorY++
+		t.clearLineToRight()
+	}
+	// Move back to beginning.
+	t.move(t.cursorY, 0, 0, 0)
+	t.cursorX, t.cursorY = 0, 0
+
+	t.queue(t.prompt)
+	t.advanceCursor(visualLength(t.prompt))
+	t.writeLine(t.line)
+	t.moveCursorToPos(t.pos)
+}
+
+func (t *Terminal) SetSize(width, height int) error {
+	t.lock.Lock()
+	defer t.lock.Unlock()
+
+	if width == 0 {
+		width = 1
+	}
+
+	oldWidth := t.termWidth
+	t.termWidth, t.termHeight = width, height
+
+	switch {
+	case width == oldWidth:
+		// If the width didn't change then nothing else needs to be
+		// done.
+		return nil
+	case len(t.line) == 0 && t.cursorX == 0 && t.cursorY == 0:
+		// If there is nothing on current line and no prompt printed,
+		// just do nothing
+		return nil
+	case width < oldWidth:
+		// Some terminals (e.g. xterm) will truncate lines that were
+		// too long when shinking. Others, (e.g. gnome-terminal) will
+		// attempt to wrap them. For the former, repainting t.maxLine
+		// works great, but that behaviour goes badly wrong in the case
+		// of the latter because they have doubled every full line.
+
+		// We assume that we are working on a terminal that wraps lines
+		// and adjust the cursor position based on every previous line
+		// wrapping and turning into two. This causes the prompt on
+		// xterms to move upwards, which isn't great, but it avoids a
+		// huge mess with gnome-terminal.
+		if t.cursorX >= t.termWidth {
+			t.cursorX = t.termWidth - 1
+		}
+		t.cursorY *= 2
+		t.clearAndRepaintLinePlusNPrevious(t.maxLine * 2)
+	case width > oldWidth:
+		// If the terminal expands then our position calculations will
+		// be wrong in the future because we think the cursor is
+		// |t.pos| chars into the string, but there will be a gap at
+		// the end of any wrapped line.
+		//
+		// But the position will actually be correct until we move, so
+		// we can move back to the beginning and repaint everything.
+		t.clearAndRepaintLinePlusNPrevious(t.maxLine)
+	}
+
+	_, err := t.c.Write(t.outBuf)
+	t.outBuf = t.outBuf[:0]
+	return err
+}
+
+type pasteIndicatorError struct{}
+
+func (pasteIndicatorError) Error() string {
+	return "terminal: ErrPasteIndicator not correctly handled"
+}
+
+// ErrPasteIndicator may be returned from ReadLine as the error, in addition
+// to valid line data. It indicates that bracketed paste mode is enabled and
+// that the returned line consists only of pasted data. Programs may wish to
+// interpret pasted data more literally than typed data.
+var ErrPasteIndicator = pasteIndicatorError{}
+
+// SetBracketedPasteMode requests that the terminal bracket paste operations
+// with markers. Not all terminals support this but, if it is supported, then
+// enabling this mode will stop any autocomplete callback from running due to
+// pastes. Additionally, any lines that are completely pasted will be returned
+// from ReadLine with the error set to ErrPasteIndicator.
+func (t *Terminal) SetBracketedPasteMode(on bool) {
+	if on {
+		io.WriteString(t.c, "\x1b[?2004h")
+	} else {
+		io.WriteString(t.c, "\x1b[?2004l")
+	}
+}
+
+// stRingBuffer is a ring buffer of strings.
+type stRingBuffer struct {
+	// entries contains max elements.
+	entries []string
+	max     int
+	// head contains the index of the element most recently added to the ring.
+	head int
+	// size contains the number of elements in the ring.
+	size int
+}
+
+func (s *stRingBuffer) Add(a string) {
+	if s.entries == nil {
+		const defaultNumEntries = 100
+		s.entries = make([]string, defaultNumEntries)
+		s.max = defaultNumEntries
+	}
+
+	s.head = (s.head + 1) % s.max
+	s.entries[s.head] = a
+	if s.size < s.max {
+		s.size++
+	}
+}
+
+// NthPreviousEntry returns the value passed to the nth previous call to Add.
+// If n is zero then the immediately prior value is returned, if one, then the
+// next most recent, and so on. If such an element doesn't exist then ok is
+// false.
+func (s *stRingBuffer) NthPreviousEntry(n int) (value string, ok bool) {
+	if n >= s.size {
+		return "", false
+	}
+	index := s.head - n
+	if index < 0 {
+		index += s.max
+	}
+	return s.entries[index], true
+}
+
+// readPasswordLine reads from reader until it finds \n or io.EOF.
+// The slice returned does not include the \n.
+// readPasswordLine also ignores any \r it finds.
+// Windows uses \r as end of line. So, on Windows, readPasswordLine
+// reads until it finds \r and ignores any \n it finds during processing.
+func readPasswordLine(reader io.Reader) ([]byte, error) {
+	var buf [1]byte
+	var ret []byte
+
+	for {
+		n, err := reader.Read(buf[:])
+		if n > 0 {
+			switch buf[0] {
+			case '\b':
+				if len(ret) > 0 {
+					ret = ret[:len(ret)-1]
+				}
+			case '\n':
+				if runtime.GOOS != "windows" {
+					return ret, nil
+				}
+				// otherwise ignore \n
+			case '\r':
+				if runtime.GOOS == "windows" {
+					return ret, nil
+				}
+				// otherwise ignore \r
+			default:
+				ret = append(ret, buf[0])
+			}
+			continue
+		}
+		if err != nil {
+			if err == io.EOF && len(ret) > 0 {
+				return ret, nil
+			}
+			return ret, err
+		}
+	}
+}
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 7a8e98733a..3dd50ccddb 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -1,4 +1,4 @@
-# github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2
+# github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5
 ## explicit
 github.com/google/pprof/driver
 github.com/google/pprof/internal/binutils
@@ -17,13 +17,13 @@ github.com/google/pprof/third_party/d3flamegraph
 github.com/google/pprof/third_party/svgpan
 # github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639
 github.com/ianlancetaylor/demangle
-# golang.org/x/arch v0.0.0-20201008161808-52c3e6f60cff
+# golang.org/x/arch v0.0.0-20210308155006-05f8f0431f72
 ## explicit
 golang.org/x/arch/arm/armasm
 golang.org/x/arch/arm64/arm64asm
 golang.org/x/arch/ppc64/ppc64asm
 golang.org/x/arch/x86/x86asm
-# golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897
+# golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83
 ## explicit
 golang.org/x/crypto/ed25519
 golang.org/x/crypto/ed25519/internal/edwards25519
@@ -39,12 +39,16 @@ golang.org/x/mod/sumdb/dirhash
 golang.org/x/mod/sumdb/note
 golang.org/x/mod/sumdb/tlog
 golang.org/x/mod/zip
-# golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e
+# golang.org/x/sys v0.0.0-20210309074719-68d13333faf2
 ## explicit
 golang.org/x/sys/internal/unsafeheader
+golang.org/x/sys/plan9
 golang.org/x/sys/unix
 golang.org/x/sys/windows
-# golang.org/x/tools v0.1.1-0.20210220032852-2363391a5b2f
+# golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d
+## explicit
+golang.org/x/term
+# golang.org/x/tools v0.1.1-0.20210312185553-8e4f4c86593a
 ## explicit
 golang.org/x/tools/cover
 golang.org/x/tools/go/analysis
diff --git a/src/go.mod b/src/go.mod
index 999dc96787..2ddab18077 100644
--- a/src/go.mod
+++ b/src/go.mod
@@ -1,10 +1,10 @@
 module std
 
-go 1.16
+go 1.17
 
 require (
-	golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897
-	golang.org/x/net v0.0.0-20201209123823-ac852fbbde11
-	golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e // indirect
-	golang.org/x/text v0.3.4 // indirect
+	golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83
+	golang.org/x/net v0.0.0-20210226172049-e18ecbb05110
+	golang.org/x/sys v0.0.0-20210309074719-68d13333faf2 // indirect
+	golang.org/x/text v0.3.6-0.20210227105805-e3aa4adf54f6 // indirect
 )
diff --git a/src/go.sum b/src/go.sum
index 6dd5f4eafd..85c7dd9268 100644
--- a/src/go.sum
+++ b/src/go.sum
@@ -1,17 +1,18 @@
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897 h1:pLI5jrR7OSLijeIDcmRxNmw2api+jEfxLoykJVice/E=
-golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 h1:/ZScEX8SfEmUGRHs0gxpqteO5nfNW6axyZbBdw9A12g=
+golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20201209123823-ac852fbbde11 h1:lwlPPsmjDKK0J6eG6xDWd5XPehI0R024zxjDnw3esPA=
-golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110 h1:qWPm9rbaAMKs8Bq/9LRpbMqxWRVUAQwMI9fVrssnTfw=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e h1:f5mksnk+hgXHnImpZoWj64ja99j9zV7YUgrVG95uFE4=
-golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210309074719-68d13333faf2 h1:46ULzRKLh1CwgRq2dC5SlBzEqqNCi8rreOZnNrbqcIY=
+golang.org/x/sys v0.0.0-20210309074719-68d13333faf2/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.4 h1:0YWbFKbhXG/wIiuHDSKpS0Iy7FSA+u45VtBMfQcFTTc=
-golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6-0.20210227105805-e3aa4adf54f6 h1:lmoh2ZlEN/VfIYVdeta6HbTPLqajF5r8riIp1MACt2A=
+golang.org/x/text v0.3.6-0.20210227105805-e3aa4adf54f6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
diff --git a/src/net/http/h2_bundle.go b/src/net/http/h2_bundle.go
index 0379848e70..ad311946d5 100644
--- a/src/net/http/h2_bundle.go
+++ b/src/net/http/h2_bundle.go
@@ -4865,7 +4865,9 @@ func (sc *http2serverConn) startGracefulShutdown() {
 	sc.shutdownOnce.Do(func() { sc.sendServeMsg(http2gracefulShutdownMsg) })
 }
 
-// After sending GOAWAY, the connection will close after goAwayTimeout.
+// After sending GOAWAY with an error code (non-graceful shutdown), the
+// connection will close after goAwayTimeout.
+//
 // If we close the connection immediately after sending GOAWAY, there may
 // be unsent data in our kernel receive buffer, which will cause the kernel
 // to send a TCP RST on close() instead of a FIN. This RST will abort the
@@ -5201,23 +5203,37 @@ func (sc *http2serverConn) processSettingInitialWindowSize(val uint32) error {
 
 func (sc *http2serverConn) processData(f *http2DataFrame) error {
 	sc.serveG.check()
-	if sc.inGoAway && sc.goAwayCode != http2ErrCodeNo {
+	id := f.Header().StreamID
+	if sc.inGoAway && (sc.goAwayCode != http2ErrCodeNo || id > sc.maxClientStreamID) {
+		// Discard all DATA frames if the GOAWAY is due to an
+		// error, or:
+		//
+		// Section 6.8: After sending a GOAWAY frame, the sender
+		// can discard frames for streams initiated by the
+		// receiver with identifiers higher than the identified
+		// last stream.
 		return nil
 	}
-	data := f.Data()
 
-	// "If a DATA frame is received whose stream is not in "open"
-	// or "half closed (local)" state, the recipient MUST respond
-	// with a stream error (Section 5.4.2) of type STREAM_CLOSED."
-	id := f.Header().StreamID
+	data := f.Data()
 	state, st := sc.state(id)
 	if id == 0 || state == http2stateIdle {
+		// Section 6.1: "DATA frames MUST be associated with a
+		// stream. If a DATA frame is received whose stream
+		// identifier field is 0x0, the recipient MUST respond
+		// with a connection error (Section 5.4.1) of type
+		// PROTOCOL_ERROR."
+		//
 		// Section 5.1: "Receiving any frame other than HEADERS
 		// or PRIORITY on a stream in this state MUST be
 		// treated as a connection error (Section 5.4.1) of
 		// type PROTOCOL_ERROR."
 		return http2ConnectionError(http2ErrCodeProtocol)
 	}
+
+	// "If a DATA frame is received whose stream is not in "open"
+	// or "half closed (local)" state, the recipient MUST respond
+	// with a stream error (Section 5.4.2) of type STREAM_CLOSED."
 	if st == nil || state != http2stateOpen || st.gotTrailerHeader || st.resetQueued {
 		// This includes sending a RST_STREAM if the stream is
 		// in stateHalfClosedLocal (which currently means that
diff --git a/src/vendor/golang.org/x/crypto/chacha20/chacha_arm64.go b/src/vendor/golang.org/x/crypto/chacha20/chacha_arm64.go
index b799e440b4..94c71ac1ac 100644
--- a/src/vendor/golang.org/x/crypto/chacha20/chacha_arm64.go
+++ b/src/vendor/golang.org/x/crypto/chacha20/chacha_arm64.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build go1.11,!gccgo,!purego
+//go:build go1.11 && gc && !purego
+// +build go1.11,gc,!purego
 
 package chacha20
 
diff --git a/src/vendor/golang.org/x/crypto/chacha20/chacha_arm64.s b/src/vendor/golang.org/x/crypto/chacha20/chacha_arm64.s
index 891481539a..8fb49a13e3 100644
--- a/src/vendor/golang.org/x/crypto/chacha20/chacha_arm64.s
+++ b/src/vendor/golang.org/x/crypto/chacha20/chacha_arm64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build go1.11,!gccgo,!purego
+// +build go1.11,gc,!purego
 
 #include "textflag.h"
 
diff --git a/src/vendor/golang.org/x/crypto/chacha20/chacha_noasm.go b/src/vendor/golang.org/x/crypto/chacha20/chacha_noasm.go
index 4635307b8f..025b49897e 100644
--- a/src/vendor/golang.org/x/crypto/chacha20/chacha_noasm.go
+++ b/src/vendor/golang.org/x/crypto/chacha20/chacha_noasm.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !arm64,!s390x,!ppc64le arm64,!go1.11 gccgo purego
+//go:build (!arm64 && !s390x && !ppc64le) || (arm64 && !go1.11) || !gc || purego
+// +build !arm64,!s390x,!ppc64le arm64,!go1.11 !gc purego
 
 package chacha20
 
diff --git a/src/vendor/golang.org/x/crypto/chacha20/chacha_ppc64le.go b/src/vendor/golang.org/x/crypto/chacha20/chacha_ppc64le.go
index b799330341..da420b2e97 100644
--- a/src/vendor/golang.org/x/crypto/chacha20/chacha_ppc64le.go
+++ b/src/vendor/golang.org/x/crypto/chacha20/chacha_ppc64le.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !gccgo,!purego
+//go:build gc && !purego
+// +build gc,!purego
 
 package chacha20
 
diff --git a/src/vendor/golang.org/x/crypto/chacha20/chacha_ppc64le.s b/src/vendor/golang.org/x/crypto/chacha20/chacha_ppc64le.s
index 23c6021643..3dad4b2fa2 100644
--- a/src/vendor/golang.org/x/crypto/chacha20/chacha_ppc64le.s
+++ b/src/vendor/golang.org/x/crypto/chacha20/chacha_ppc64le.s
@@ -19,7 +19,7 @@
 // The differences in this and the original implementation are
 // due to the calling conventions and initialization of constants.
 
-// +build !gccgo,!purego
+// +build gc,!purego
 
 #include "textflag.h"
 
diff --git a/src/vendor/golang.org/x/crypto/chacha20/chacha_s390x.go b/src/vendor/golang.org/x/crypto/chacha20/chacha_s390x.go
index a9244bdf4d..c5898db465 100644
--- a/src/vendor/golang.org/x/crypto/chacha20/chacha_s390x.go
+++ b/src/vendor/golang.org/x/crypto/chacha20/chacha_s390x.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !gccgo,!purego
+//go:build gc && !purego
+// +build gc,!purego
 
 package chacha20
 
diff --git a/src/vendor/golang.org/x/crypto/chacha20/chacha_s390x.s b/src/vendor/golang.org/x/crypto/chacha20/chacha_s390x.s
index 89c658c410..818161189b 100644
--- a/src/vendor/golang.org/x/crypto/chacha20/chacha_s390x.s
+++ b/src/vendor/golang.org/x/crypto/chacha20/chacha_s390x.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !gccgo,!purego
+// +build gc,!purego
 
 #include "go_asm.h"
 #include "textflag.h"
diff --git a/src/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305_amd64.go b/src/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305_amd64.go
index cda77819b8..25959b9a6e 100644
--- a/src/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305_amd64.go
+++ b/src/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305_amd64.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !gccgo,!purego
+//go:build gc && !purego
+// +build gc,!purego
 
 package chacha20poly1305
 
diff --git a/src/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305_amd64.s b/src/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305_amd64.s
index 3469c87288..55226b0e6c 100644
--- a/src/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305_amd64.s
+++ b/src/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305_amd64.s
@@ -4,7 +4,7 @@
 
 // This file was originally from https://golang.org/cl/24717 by Vlad Krasnov of CloudFlare.
 
-// +build !gccgo,!purego
+// +build gc,!purego
 
 #include "textflag.h"
 // General register allocation
diff --git a/src/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305_noasm.go b/src/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305_noasm.go
index 9ce4aa9fe6..f832b33d45 100644
--- a/src/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305_noasm.go
+++ b/src/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305_noasm.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !amd64 gccgo purego
+//go:build !amd64 || !gc || purego
+// +build !amd64 !gc purego
 
 package chacha20poly1305
 
diff --git a/src/vendor/golang.org/x/crypto/curve25519/curve25519_amd64.go b/src/vendor/golang.org/x/crypto/curve25519/curve25519_amd64.go
index 5120b779b9..84858480df 100644
--- a/src/vendor/golang.org/x/crypto/curve25519/curve25519_amd64.go
+++ b/src/vendor/golang.org/x/crypto/curve25519/curve25519_amd64.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build amd64,!gccgo,!appengine,!purego
+//go:build amd64 && gc && !purego
+// +build amd64,gc,!purego
 
 package curve25519
 
diff --git a/src/vendor/golang.org/x/crypto/curve25519/curve25519_amd64.s b/src/vendor/golang.org/x/crypto/curve25519/curve25519_amd64.s
index 0250c88859..6c53380926 100644
--- a/src/vendor/golang.org/x/crypto/curve25519/curve25519_amd64.s
+++ b/src/vendor/golang.org/x/crypto/curve25519/curve25519_amd64.s
@@ -5,7 +5,7 @@
 // This code was translated into a form compatible with 6a from the public
 // domain sources in SUPERCOP: https://bench.cr.yp.to/supercop.html
 
-// +build amd64,!gccgo,!appengine,!purego
+// +build amd64,gc,!purego
 
 #define REDMASK51     0x0007FFFFFFFFFFFF
 
diff --git a/src/vendor/golang.org/x/crypto/curve25519/curve25519_noasm.go b/src/vendor/golang.org/x/crypto/curve25519/curve25519_noasm.go
index 047d49afc2..259728af7d 100644
--- a/src/vendor/golang.org/x/crypto/curve25519/curve25519_noasm.go
+++ b/src/vendor/golang.org/x/crypto/curve25519/curve25519_noasm.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !amd64 gccgo appengine purego
+//go:build !amd64 || !gc || purego
+// +build !amd64 !gc purego
 
 package curve25519
 
diff --git a/src/vendor/golang.org/x/crypto/internal/subtle/aliasing.go b/src/vendor/golang.org/x/crypto/internal/subtle/aliasing.go
index f38797bfa1..4fad24f8dc 100644
--- a/src/vendor/golang.org/x/crypto/internal/subtle/aliasing.go
+++ b/src/vendor/golang.org/x/crypto/internal/subtle/aliasing.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !appengine
+//go:build !purego
+// +build !purego
 
 // Package subtle implements functions that are often useful in cryptographic
 // code but require careful thought to use correctly.
diff --git a/src/vendor/golang.org/x/crypto/internal/subtle/aliasing_appengine.go b/src/vendor/golang.org/x/crypto/internal/subtle/aliasing_purego.go
similarity index 97%
rename from src/vendor/golang.org/x/crypto/internal/subtle/aliasing_appengine.go
rename to src/vendor/golang.org/x/crypto/internal/subtle/aliasing_purego.go
index 0cc4a8a642..80ccbed2c0 100644
--- a/src/vendor/golang.org/x/crypto/internal/subtle/aliasing_appengine.go
+++ b/src/vendor/golang.org/x/crypto/internal/subtle/aliasing_purego.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build appengine
+//go:build purego
+// +build purego
 
 // Package subtle implements functions that are often useful in cryptographic
 // code but require careful thought to use correctly.
diff --git a/src/vendor/golang.org/x/crypto/poly1305/bits_compat.go b/src/vendor/golang.org/x/crypto/poly1305/bits_compat.go
index 157a69f61b..45b5c966b2 100644
--- a/src/vendor/golang.org/x/crypto/poly1305/bits_compat.go
+++ b/src/vendor/golang.org/x/crypto/poly1305/bits_compat.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !go1.13
 // +build !go1.13
 
 package poly1305
diff --git a/src/vendor/golang.org/x/crypto/poly1305/bits_go1.13.go b/src/vendor/golang.org/x/crypto/poly1305/bits_go1.13.go
index a0a185f0fc..ed52b3418a 100644
--- a/src/vendor/golang.org/x/crypto/poly1305/bits_go1.13.go
+++ b/src/vendor/golang.org/x/crypto/poly1305/bits_go1.13.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.13
 // +build go1.13
 
 package poly1305
diff --git a/src/vendor/golang.org/x/crypto/poly1305/mac_noasm.go b/src/vendor/golang.org/x/crypto/poly1305/mac_noasm.go
index d118f30ed5..f184b67d98 100644
--- a/src/vendor/golang.org/x/crypto/poly1305/mac_noasm.go
+++ b/src/vendor/golang.org/x/crypto/poly1305/mac_noasm.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !amd64,!ppc64le,!s390x gccgo purego
+//go:build (!amd64 && !ppc64le && !s390x) || !gc || purego
+// +build !amd64,!ppc64le,!s390x !gc purego
 
 package poly1305
 
diff --git a/src/vendor/golang.org/x/crypto/poly1305/sum_amd64.go b/src/vendor/golang.org/x/crypto/poly1305/sum_amd64.go
index 99e5a1d50e..6d522333f2 100644
--- a/src/vendor/golang.org/x/crypto/poly1305/sum_amd64.go
+++ b/src/vendor/golang.org/x/crypto/poly1305/sum_amd64.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !gccgo,!purego
+//go:build gc && !purego
+// +build gc,!purego
 
 package poly1305
 
diff --git a/src/vendor/golang.org/x/crypto/poly1305/sum_amd64.s b/src/vendor/golang.org/x/crypto/poly1305/sum_amd64.s
index 8d394a212e..2cb0373140 100644
--- a/src/vendor/golang.org/x/crypto/poly1305/sum_amd64.s
+++ b/src/vendor/golang.org/x/crypto/poly1305/sum_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !gccgo,!purego
+// +build gc,!purego
 
 #include "textflag.h"
 
diff --git a/src/vendor/golang.org/x/crypto/poly1305/sum_ppc64le.go b/src/vendor/golang.org/x/crypto/poly1305/sum_ppc64le.go
index 2e7a120b19..4a069941a6 100644
--- a/src/vendor/golang.org/x/crypto/poly1305/sum_ppc64le.go
+++ b/src/vendor/golang.org/x/crypto/poly1305/sum_ppc64le.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !gccgo,!purego
+//go:build gc && !purego
+// +build gc,!purego
 
 package poly1305
 
diff --git a/src/vendor/golang.org/x/crypto/poly1305/sum_ppc64le.s b/src/vendor/golang.org/x/crypto/poly1305/sum_ppc64le.s
index 4e02813879..5cd7494b21 100644
--- a/src/vendor/golang.org/x/crypto/poly1305/sum_ppc64le.s
+++ b/src/vendor/golang.org/x/crypto/poly1305/sum_ppc64le.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !gccgo,!purego
+// +build gc,!purego
 
 #include "textflag.h"
 
diff --git a/src/vendor/golang.org/x/crypto/poly1305/sum_s390x.go b/src/vendor/golang.org/x/crypto/poly1305/sum_s390x.go
index 958fedc079..62cc9f8470 100644
--- a/src/vendor/golang.org/x/crypto/poly1305/sum_s390x.go
+++ b/src/vendor/golang.org/x/crypto/poly1305/sum_s390x.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !gccgo,!purego
+//go:build gc && !purego
+// +build gc,!purego
 
 package poly1305
 
diff --git a/src/vendor/golang.org/x/crypto/poly1305/sum_s390x.s b/src/vendor/golang.org/x/crypto/poly1305/sum_s390x.s
index 0fa9ee6e0b..bdd882c606 100644
--- a/src/vendor/golang.org/x/crypto/poly1305/sum_s390x.s
+++ b/src/vendor/golang.org/x/crypto/poly1305/sum_s390x.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !gccgo,!purego
+// +build gc,!purego
 
 #include "textflag.h"
 
diff --git a/src/vendor/golang.org/x/net/idna/idna10.0.0.go b/src/vendor/golang.org/x/net/idna/idna10.0.0.go
index a98a31f403..7e69ee1b22 100644
--- a/src/vendor/golang.org/x/net/idna/idna10.0.0.go
+++ b/src/vendor/golang.org/x/net/idna/idna10.0.0.go
@@ -4,6 +4,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.10
 // +build go1.10
 
 // Package idna implements IDNA2008 using the compatibility processing
diff --git a/src/vendor/golang.org/x/net/idna/idna9.0.0.go b/src/vendor/golang.org/x/net/idna/idna9.0.0.go
index 8842146b5d..7c7456374c 100644
--- a/src/vendor/golang.org/x/net/idna/idna9.0.0.go
+++ b/src/vendor/golang.org/x/net/idna/idna9.0.0.go
@@ -4,6 +4,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !go1.10
 // +build !go1.10
 
 // Package idna implements IDNA2008 using the compatibility processing
diff --git a/src/vendor/golang.org/x/net/idna/tables10.0.0.go b/src/vendor/golang.org/x/net/idna/tables10.0.0.go
index 54fddb4b16..d1d62ef459 100644
--- a/src/vendor/golang.org/x/net/idna/tables10.0.0.go
+++ b/src/vendor/golang.org/x/net/idna/tables10.0.0.go
@@ -1,5 +1,6 @@
 // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
 
+//go:build go1.10 && !go1.13
 // +build go1.10,!go1.13
 
 package idna
diff --git a/src/vendor/golang.org/x/net/idna/tables11.0.0.go b/src/vendor/golang.org/x/net/idna/tables11.0.0.go
index 8ce0811fdf..167efba712 100644
--- a/src/vendor/golang.org/x/net/idna/tables11.0.0.go
+++ b/src/vendor/golang.org/x/net/idna/tables11.0.0.go
@@ -1,5 +1,6 @@
 // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
 
+//go:build go1.13 && !go1.14
 // +build go1.13,!go1.14
 
 package idna
diff --git a/src/vendor/golang.org/x/net/idna/tables12.0.0.go b/src/vendor/golang.org/x/net/idna/tables12.0.0.go
index f39f0cb4cd..ab40f7bcc3 100644
--- a/src/vendor/golang.org/x/net/idna/tables12.0.0.go
+++ b/src/vendor/golang.org/x/net/idna/tables12.0.0.go
@@ -1,5 +1,6 @@
 // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
 
+//go:build go1.14 && !go1.16
 // +build go1.14,!go1.16
 
 package idna
diff --git a/src/vendor/golang.org/x/net/idna/tables13.0.0.go b/src/vendor/golang.org/x/net/idna/tables13.0.0.go
index e8c7a36d7a..390c5e56d2 100644
--- a/src/vendor/golang.org/x/net/idna/tables13.0.0.go
+++ b/src/vendor/golang.org/x/net/idna/tables13.0.0.go
@@ -1,5 +1,6 @@
 // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
 
+//go:build go1.16
 // +build go1.16
 
 package idna
diff --git a/src/vendor/golang.org/x/net/idna/tables9.0.0.go b/src/vendor/golang.org/x/net/idna/tables9.0.0.go
index 8b65fa1678..4074b5332e 100644
--- a/src/vendor/golang.org/x/net/idna/tables9.0.0.go
+++ b/src/vendor/golang.org/x/net/idna/tables9.0.0.go
@@ -1,5 +1,6 @@
 // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
 
+//go:build !go1.10
 // +build !go1.10
 
 package idna
diff --git a/src/vendor/golang.org/x/net/nettest/nettest_stub.go b/src/vendor/golang.org/x/net/nettest/nettest_stub.go
index 22c2461c1c..6e3a9312b9 100644
--- a/src/vendor/golang.org/x/net/nettest/nettest_stub.go
+++ b/src/vendor/golang.org/x/net/nettest/nettest_stub.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !aix && !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris && !windows && !zos
 // +build !aix,!darwin,!dragonfly,!freebsd,!linux,!netbsd,!openbsd,!solaris,!windows,!zos
 
 package nettest
diff --git a/src/vendor/golang.org/x/net/nettest/nettest_unix.go b/src/vendor/golang.org/x/net/nettest/nettest_unix.go
index c1b13593fe..b1cb8b2f3b 100644
--- a/src/vendor/golang.org/x/net/nettest/nettest_unix.go
+++ b/src/vendor/golang.org/x/net/nettest/nettest_unix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos
 
 package nettest
diff --git a/src/vendor/golang.org/x/net/route/address.go b/src/vendor/golang.org/x/net/route/address.go
index 3c2fe15a97..4f6ad968a2 100644
--- a/src/vendor/golang.org/x/net/route/address.go
+++ b/src/vendor/golang.org/x/net/route/address.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || netbsd || openbsd
 // +build darwin dragonfly freebsd netbsd openbsd
 
 package route
diff --git a/src/vendor/golang.org/x/net/route/binary.go b/src/vendor/golang.org/x/net/route/binary.go
index 6910520eca..a5e28f1e9c 100644
--- a/src/vendor/golang.org/x/net/route/binary.go
+++ b/src/vendor/golang.org/x/net/route/binary.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || netbsd || openbsd
 // +build darwin dragonfly freebsd netbsd openbsd
 
 package route
diff --git a/src/vendor/golang.org/x/net/route/interface.go b/src/vendor/golang.org/x/net/route/interface.go
index 05ef2a9ce3..9e9407830c 100644
--- a/src/vendor/golang.org/x/net/route/interface.go
+++ b/src/vendor/golang.org/x/net/route/interface.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || netbsd || openbsd
 // +build darwin dragonfly freebsd netbsd openbsd
 
 package route
diff --git a/src/vendor/golang.org/x/net/route/interface_announce.go b/src/vendor/golang.org/x/net/route/interface_announce.go
index 520d657b57..8282bfe9e2 100644
--- a/src/vendor/golang.org/x/net/route/interface_announce.go
+++ b/src/vendor/golang.org/x/net/route/interface_announce.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly || freebsd || netbsd
 // +build dragonfly freebsd netbsd
 
 package route
diff --git a/src/vendor/golang.org/x/net/route/interface_classic.go b/src/vendor/golang.org/x/net/route/interface_classic.go
index ac4e7a6805..85b7e993bb 100644
--- a/src/vendor/golang.org/x/net/route/interface_classic.go
+++ b/src/vendor/golang.org/x/net/route/interface_classic.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || netbsd
 // +build darwin dragonfly netbsd
 
 package route
diff --git a/src/vendor/golang.org/x/net/route/interface_multicast.go b/src/vendor/golang.org/x/net/route/interface_multicast.go
index 1e99a9cc64..dd0b214baa 100644
--- a/src/vendor/golang.org/x/net/route/interface_multicast.go
+++ b/src/vendor/golang.org/x/net/route/interface_multicast.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd
 // +build darwin dragonfly freebsd
 
 package route
diff --git a/src/vendor/golang.org/x/net/route/message.go b/src/vendor/golang.org/x/net/route/message.go
index 80c482ae94..d53bb7f9b1 100644
--- a/src/vendor/golang.org/x/net/route/message.go
+++ b/src/vendor/golang.org/x/net/route/message.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || netbsd || openbsd
 // +build darwin dragonfly freebsd netbsd openbsd
 
 package route
diff --git a/src/vendor/golang.org/x/net/route/route.go b/src/vendor/golang.org/x/net/route/route.go
index 4462cf1b6f..e3d6da0549 100644
--- a/src/vendor/golang.org/x/net/route/route.go
+++ b/src/vendor/golang.org/x/net/route/route.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || netbsd || openbsd
 // +build darwin dragonfly freebsd netbsd openbsd
 
 // Package route provides basic functions for the manipulation of
diff --git a/src/vendor/golang.org/x/net/route/route_classic.go b/src/vendor/golang.org/x/net/route/route_classic.go
index b83add668e..d6ee42f1b1 100644
--- a/src/vendor/golang.org/x/net/route/route_classic.go
+++ b/src/vendor/golang.org/x/net/route/route_classic.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || netbsd
 // +build darwin dragonfly freebsd netbsd
 
 package route
diff --git a/src/vendor/golang.org/x/net/route/sys.go b/src/vendor/golang.org/x/net/route/sys.go
index a0ab3e9c73..537484ae5a 100644
--- a/src/vendor/golang.org/x/net/route/sys.go
+++ b/src/vendor/golang.org/x/net/route/sys.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || dragonfly || freebsd || netbsd || openbsd
 // +build darwin dragonfly freebsd netbsd openbsd
 
 package route
diff --git a/src/vendor/golang.org/x/net/route/syscall.go b/src/vendor/golang.org/x/net/route/syscall.go
index 72431b0341..97166dd3c4 100644
--- a/src/vendor/golang.org/x/net/route/syscall.go
+++ b/src/vendor/golang.org/x/net/route/syscall.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build dragonfly || freebsd || netbsd || openbsd
 // +build dragonfly freebsd netbsd openbsd
 
 package route
diff --git a/src/vendor/golang.org/x/net/route/syscall_go1_12_darwin.go b/src/vendor/golang.org/x/net/route/syscall_go1_12_darwin.go
index 7922a6836f..7a13e4fd90 100644
--- a/src/vendor/golang.org/x/net/route/syscall_go1_12_darwin.go
+++ b/src/vendor/golang.org/x/net/route/syscall_go1_12_darwin.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.12
 // +build go1.12
 
 package route
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_aix.go b/src/vendor/golang.org/x/sys/cpu/cpu_aix.go
index 464a209cf5..28b521643b 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_aix.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_aix.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build aix
 // +build aix
 
 package cpu
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_gc_arm64.go b/src/vendor/golang.org/x/sys/cpu/cpu_gc_arm64.go
index 7f7f272a01..ccf542a73d 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_gc_arm64.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_gc_arm64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build gc
 // +build gc
 
 package cpu
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_gc_s390x.go b/src/vendor/golang.org/x/sys/cpu/cpu_gc_s390x.go
index 75a9556616..0af2f24841 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_gc_s390x.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_gc_s390x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build gc
 // +build gc
 
 package cpu
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go b/src/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go
index 4adb89cf9c..fa7cdb9bcd 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (386 || amd64 || amd64p32) && gc
 // +build 386 amd64 amd64p32
 // +build gc
 
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_gccgo_arm64.go b/src/vendor/golang.org/x/sys/cpu/cpu_gccgo_arm64.go
index 53ca8d65c3..2aff318911 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_gccgo_arm64.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_gccgo_arm64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build gccgo
 // +build gccgo
 
 package cpu
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_gccgo_s390x.go b/src/vendor/golang.org/x/sys/cpu/cpu_gccgo_s390x.go
index aa986f7782..4bfbda6199 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_gccgo_s390x.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_gccgo_s390x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build gccgo
 // +build gccgo
 
 package cpu
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go b/src/vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go
index ba49b91bd3..8478a6d597 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (386 || amd64 || amd64p32) && gccgo
 // +build 386 amd64 amd64p32
 // +build gccgo
 
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_linux.go b/src/vendor/golang.org/x/sys/cpu/cpu_linux.go
index 6fc874f7fe..159a686f6f 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_linux.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_linux.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !386 && !amd64 && !amd64p32 && !arm64
 // +build !386,!amd64,!amd64p32,!arm64
 
 package cpu
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_linux_mips64x.go b/src/vendor/golang.org/x/sys/cpu/cpu_linux_mips64x.go
index 5a41890053..6000db4cdd 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_linux_mips64x.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_linux_mips64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (mips64 || mips64le)
 // +build linux
 // +build mips64 mips64le
 
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_linux_noinit.go b/src/vendor/golang.org/x/sys/cpu/cpu_linux_noinit.go
index 42b5d33cb6..f4992b1a59 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_linux_noinit.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_linux_noinit.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && !arm && !arm64 && !mips64 && !mips64le && !ppc64 && !ppc64le && !s390x
 // +build linux,!arm,!arm64,!mips64,!mips64le,!ppc64,!ppc64le,!s390x
 
 package cpu
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_linux_ppc64x.go b/src/vendor/golang.org/x/sys/cpu/cpu_linux_ppc64x.go
index 99f8a6399e..021356d6de 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_linux_ppc64x.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_linux_ppc64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (ppc64 || ppc64le)
 // +build linux
 // +build ppc64 ppc64le
 
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_mips64x.go b/src/vendor/golang.org/x/sys/cpu/cpu_mips64x.go
index 57b5b677de..f4063c6642 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_mips64x.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_mips64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips64 || mips64le
 // +build mips64 mips64le
 
 package cpu
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_mipsx.go b/src/vendor/golang.org/x/sys/cpu/cpu_mipsx.go
index cfc1946b7b..07c4e36d8f 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_mipsx.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_mipsx.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips || mipsle
 // +build mips mipsle
 
 package cpu
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_other_arm.go b/src/vendor/golang.org/x/sys/cpu/cpu_other_arm.go
index b412efc1bd..d7b4fb4ccc 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_other_arm.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_other_arm.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !linux && arm
 // +build !linux,arm
 
 package cpu
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_other_arm64.go b/src/vendor/golang.org/x/sys/cpu/cpu_other_arm64.go
index 16c1c4090e..f8c484f589 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_other_arm64.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_other_arm64.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !linux,!netbsd
-// +build arm64
+//go:build !linux && !netbsd && arm64
+// +build !linux,!netbsd,arm64
 
 package cpu
 
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_other_mips64x.go b/src/vendor/golang.org/x/sys/cpu/cpu_other_mips64x.go
index f49fad6778..0dafe9644a 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_other_mips64x.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_other_mips64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !linux && (mips64 || mips64le)
 // +build !linux
 // +build mips64 mips64le
 
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_ppc64x.go b/src/vendor/golang.org/x/sys/cpu/cpu_ppc64x.go
index d28d675b5f..4e8acd1658 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_ppc64x.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_ppc64x.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 package cpu
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_riscv64.go b/src/vendor/golang.org/x/sys/cpu/cpu_riscv64.go
index 8b08de341b..bd6c128af9 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_riscv64.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_riscv64.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build riscv64
 // +build riscv64
 
 package cpu
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_wasm.go b/src/vendor/golang.org/x/sys/cpu/cpu_wasm.go
index 5382f2a227..7747d888a6 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_wasm.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_wasm.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build wasm
 // +build wasm
 
 package cpu
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_x86.go b/src/vendor/golang.org/x/sys/cpu/cpu_x86.go
index 48d4293319..fd380c0a71 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_x86.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_x86.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build 386 || amd64 || amd64p32
 // +build 386 amd64 amd64p32
 
 package cpu
diff --git a/src/vendor/golang.org/x/sys/cpu/syscall_aix_gccgo.go b/src/vendor/golang.org/x/sys/cpu/syscall_aix_gccgo.go
index 76fbe40b76..a864f24d75 100644
--- a/src/vendor/golang.org/x/sys/cpu/syscall_aix_gccgo.go
+++ b/src/vendor/golang.org/x/sys/cpu/syscall_aix_gccgo.go
@@ -8,8 +8,8 @@
 // Morever, this file will be used during the building of
 // gccgo's libgo and thus must not used a CGo method.
 
-// +build aix
-// +build gccgo
+//go:build aix && gccgo
+// +build aix,gccgo
 
 package cpu
 
diff --git a/src/vendor/golang.org/x/sys/cpu/syscall_aix_ppc64_gc.go b/src/vendor/golang.org/x/sys/cpu/syscall_aix_ppc64_gc.go
index 5b427d67e2..904be42ffd 100644
--- a/src/vendor/golang.org/x/sys/cpu/syscall_aix_ppc64_gc.go
+++ b/src/vendor/golang.org/x/sys/cpu/syscall_aix_ppc64_gc.go
@@ -6,8 +6,8 @@
 // system call on AIX without depending on x/sys/unix.
 // (See golang.org/issue/32102)
 
-// +build aix,ppc64
-// +build gc
+//go:build aix && ppc64 && gc
+// +build aix,ppc64,gc
 
 package cpu
 
diff --git a/src/vendor/golang.org/x/text/secure/bidirule/bidirule10.0.0.go b/src/vendor/golang.org/x/text/secure/bidirule/bidirule10.0.0.go
index e4c62289f9..8a7392c4a1 100644
--- a/src/vendor/golang.org/x/text/secure/bidirule/bidirule10.0.0.go
+++ b/src/vendor/golang.org/x/text/secure/bidirule/bidirule10.0.0.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.10
 // +build go1.10
 
 package bidirule
diff --git a/src/vendor/golang.org/x/text/secure/bidirule/bidirule9.0.0.go b/src/vendor/golang.org/x/text/secure/bidirule/bidirule9.0.0.go
index 02b9e1e9d4..bb0a920018 100644
--- a/src/vendor/golang.org/x/text/secure/bidirule/bidirule9.0.0.go
+++ b/src/vendor/golang.org/x/text/secure/bidirule/bidirule9.0.0.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !go1.10
 // +build !go1.10
 
 package bidirule
diff --git a/src/vendor/golang.org/x/text/unicode/bidi/bidi.go b/src/vendor/golang.org/x/text/unicode/bidi/bidi.go
index e8edc54cc2..fd057601bd 100644
--- a/src/vendor/golang.org/x/text/unicode/bidi/bidi.go
+++ b/src/vendor/golang.org/x/text/unicode/bidi/bidi.go
@@ -12,15 +12,14 @@
 // and without notice.
 package bidi // import "golang.org/x/text/unicode/bidi"
 
-// TODO:
-// The following functionality would not be hard to implement, but hinges on
-// the definition of a Segmenter interface. For now this is up to the user.
-// - Iterate over paragraphs
-// - Segmenter to iterate over runs directly from a given text.
-// Also:
+// TODO
 // - Transformer for reordering?
 // - Transformer (validator, really) for Bidi Rule.
 
+import (
+	"bytes"
+)
+
 // This API tries to avoid dealing with embedding levels for now. Under the hood
 // these will be computed, but the question is to which extent the user should
 // know they exist. We should at some point allow the user to specify an
@@ -49,7 +48,9 @@ const (
 	Neutral
 )
 
-type options struct{}
+type options struct {
+	defaultDirection Direction
+}
 
 // An Option is an option for Bidi processing.
 type Option func(*options)
@@ -66,12 +67,62 @@ type Option func(*options)
 // DefaultDirection sets the default direction for a Paragraph. The direction is
 // overridden if the text contains directional characters.
 func DefaultDirection(d Direction) Option {
-	panic("unimplemented")
+	return func(opts *options) {
+		opts.defaultDirection = d
+	}
 }
 
 // A Paragraph holds a single Paragraph for Bidi processing.
 type Paragraph struct {
-	// buffers
+	p          []byte
+	o          Ordering
+	opts       []Option
+	types      []Class
+	pairTypes  []bracketType
+	pairValues []rune
+	runes      []rune
+	options    options
+}
+
+// Initialize the p.pairTypes, p.pairValues and p.types from the input previously
+// set by p.SetBytes() or p.SetString(). Also limit the input up to (and including) a paragraph
+// separator (bidi class B).
+//
+// The function p.Order() needs these values to be set, so this preparation could be postponed.
+// But since the SetBytes and SetStrings functions return the length of the input up to the paragraph
+// separator, the whole input needs to be processed anyway and should not be done twice.
+//
+// The function has the same return values as SetBytes() / SetString()
+func (p *Paragraph) prepareInput() (n int, err error) {
+	p.runes = bytes.Runes(p.p)
+	bytecount := 0
+	// clear slices from previous SetString or SetBytes
+	p.pairTypes = nil
+	p.pairValues = nil
+	p.types = nil
+
+	for _, r := range p.runes {
+		props, i := LookupRune(r)
+		bytecount += i
+		cls := props.Class()
+		if cls == B {
+			return bytecount, nil
+		}
+		p.types = append(p.types, cls)
+		if props.IsOpeningBracket() {
+			p.pairTypes = append(p.pairTypes, bpOpen)
+			p.pairValues = append(p.pairValues, r)
+		} else if props.IsBracket() {
+			// this must be a closing bracket,
+			// since IsOpeningBracket is not true
+			p.pairTypes = append(p.pairTypes, bpClose)
+			p.pairValues = append(p.pairValues, r)
+		} else {
+			p.pairTypes = append(p.pairTypes, bpNone)
+			p.pairValues = append(p.pairValues, 0)
+		}
+	}
+	return bytecount, nil
 }
 
 // SetBytes configures p for the given paragraph text. It replaces text
@@ -80,70 +131,150 @@ type Paragraph struct {
 // consumed from b including this separator. Error may be non-nil if options are
 // given.
 func (p *Paragraph) SetBytes(b []byte, opts ...Option) (n int, err error) {
-	panic("unimplemented")
+	p.p = b
+	p.opts = opts
+	return p.prepareInput()
 }
 
-// SetString configures p for the given paragraph text. It replaces text
-// previously set by SetBytes or SetString. If b contains a paragraph separator
+// SetString configures s for the given paragraph text. It replaces text
+// previously set by SetBytes or SetString. If s contains a paragraph separator
 // it will only process the first paragraph and report the number of bytes
-// consumed from b including this separator. Error may be non-nil if options are
+// consumed from s including this separator. Error may be non-nil if options are
 // given.
 func (p *Paragraph) SetString(s string, opts ...Option) (n int, err error) {
-	panic("unimplemented")
+	p.p = []byte(s)
+	p.opts = opts
+	return p.prepareInput()
 }
 
 // IsLeftToRight reports whether the principle direction of rendering for this
 // paragraphs is left-to-right. If this returns false, the principle direction
 // of rendering is right-to-left.
 func (p *Paragraph) IsLeftToRight() bool {
-	panic("unimplemented")
+	return p.Direction() == LeftToRight
 }
 
 // Direction returns the direction of the text of this paragraph.
 //
 // The direction may be LeftToRight, RightToLeft, Mixed, or Neutral.
 func (p *Paragraph) Direction() Direction {
-	panic("unimplemented")
+	return p.o.Direction()
 }
 
+// TODO: what happens if the position is > len(input)? This should return an error.
+
 // RunAt reports the Run at the given position of the input text.
 //
 // This method can be used for computing line breaks on paragraphs.
 func (p *Paragraph) RunAt(pos int) Run {
-	panic("unimplemented")
+	c := 0
+	runNumber := 0
+	for i, r := range p.o.runes {
+		c += len(r)
+		if pos < c {
+			runNumber = i
+		}
+	}
+	return p.o.Run(runNumber)
+}
+
+func calculateOrdering(levels []level, runes []rune) Ordering {
+	var curDir Direction
+
+	prevDir := Neutral
+	prevI := 0
+
+	o := Ordering{}
+	// lvl = 0,2,4,...: left to right
+	// lvl = 1,3,5,...: right to left
+	for i, lvl := range levels {
+		if lvl%2 == 0 {
+			curDir = LeftToRight
+		} else {
+			curDir = RightToLeft
+		}
+		if curDir != prevDir {
+			if i > 0 {
+				o.runes = append(o.runes, runes[prevI:i])
+				o.directions = append(o.directions, prevDir)
+				o.startpos = append(o.startpos, prevI)
+			}
+			prevI = i
+			prevDir = curDir
+		}
+	}
+	o.runes = append(o.runes, runes[prevI:])
+	o.directions = append(o.directions, prevDir)
+	o.startpos = append(o.startpos, prevI)
+	return o
 }
 
 // Order computes the visual ordering of all the runs in a Paragraph.
 func (p *Paragraph) Order() (Ordering, error) {
-	panic("unimplemented")
+	if len(p.types) == 0 {
+		return Ordering{}, nil
+	}
+
+	for _, fn := range p.opts {
+		fn(&p.options)
+	}
+	lvl := level(-1)
+	if p.options.defaultDirection == RightToLeft {
+		lvl = 1
+	}
+	para, err := newParagraph(p.types, p.pairTypes, p.pairValues, lvl)
+	if err != nil {
+		return Ordering{}, err
+	}
+
+	levels := para.getLevels([]int{len(p.types)})
+
+	p.o = calculateOrdering(levels, p.runes)
+	return p.o, nil
 }
 
 // Line computes the visual ordering of runs for a single line starting and
 // ending at the given positions in the original text.
 func (p *Paragraph) Line(start, end int) (Ordering, error) {
-	panic("unimplemented")
+	lineTypes := p.types[start:end]
+	para, err := newParagraph(lineTypes, p.pairTypes[start:end], p.pairValues[start:end], -1)
+	if err != nil {
+		return Ordering{}, err
+	}
+	levels := para.getLevels([]int{len(lineTypes)})
+	o := calculateOrdering(levels, p.runes[start:end])
+	return o, nil
 }
 
 // An Ordering holds the computed visual order of runs of a Paragraph. Calling
 // SetBytes or SetString on the originating Paragraph invalidates an Ordering.
 // The methods of an Ordering should only be called by one goroutine at a time.
-type Ordering struct{}
+type Ordering struct {
+	runes      [][]rune
+	directions []Direction
+	startpos   []int
+}
 
 // Direction reports the directionality of the runs.
 //
 // The direction may be LeftToRight, RightToLeft, Mixed, or Neutral.
 func (o *Ordering) Direction() Direction {
-	panic("unimplemented")
+	return o.directions[0]
 }
 
 // NumRuns returns the number of runs.
 func (o *Ordering) NumRuns() int {
-	panic("unimplemented")
+	return len(o.runes)
 }
 
 // Run returns the ith run within the ordering.
 func (o *Ordering) Run(i int) Run {
-	panic("unimplemented")
+	r := Run{
+		runes:     o.runes[i],
+		direction: o.directions[i],
+		startpos:  o.startpos[i],
+	}
+	return r
 }
 
 // TODO: perhaps with options.
@@ -155,16 +286,19 @@ func (o *Ordering) Run(i int) Run {
 
 // A Run is a continuous sequence of characters of a single direction.
 type Run struct {
+	runes     []rune
+	direction Direction
+	startpos  int
 }
 
 // String returns the text of the run in its original order.
 func (r *Run) String() string {
-	panic("unimplemented")
+	return string(r.runes)
 }
 
 // Bytes returns the text of the run in its original order.
 func (r *Run) Bytes() []byte {
-	panic("unimplemented")
+	return []byte(r.String())
 }
 
 // TODO: methods for
@@ -174,25 +308,52 @@ func (r *Run) Bytes() []byte {
 
 // Direction reports the direction of the run.
 func (r *Run) Direction() Direction {
-	panic("unimplemented")
+	return r.direction
 }
 
-// Position of the Run within the text passed to SetBytes or SetString of the
+// Pos returns the position of the Run within the text passed to SetBytes or SetString of the
 // originating Paragraph value.
 func (r *Run) Pos() (start, end int) {
-	panic("unimplemented")
+	return r.startpos, r.startpos + len(r.runes) - 1
 }
 
 // AppendReverse reverses the order of characters of in, appends them to out,
 // and returns the result. Modifiers will still follow the runes they modify.
 // Brackets are replaced with their counterparts.
 func AppendReverse(out, in []byte) []byte {
-	panic("unimplemented")
+	ret := make([]byte, len(in)+len(out))
+	copy(ret, out)
+	inRunes := bytes.Runes(in)
+
+	for i, r := range inRunes {
+		prop, _ := LookupRune(r)
+		if prop.IsBracket() {
+			inRunes[i] = prop.reverseBracket(r)
+		}
+	}
+
+	for i, j := 0, len(inRunes)-1; i < j; i, j = i+1, j-1 {
+		inRunes[i], inRunes[j] = inRunes[j], inRunes[i]
+	}
+	copy(ret[len(out):], string(inRunes))
+
+	return ret
 }
 
 // ReverseString reverses the order of characters in s and returns a new string.
 // Modifiers will still follow the runes they modify. Brackets are replaced with
 // their counterparts.
 func ReverseString(s string) string {
-	panic("unimplemented")
+	input := []rune(s)
+	li := len(input)
+	ret := make([]rune, li)
+	for i, r := range input {
+		prop, _ := LookupRune(r)
+		if prop.IsBracket() {
+			ret[li-i-1] = prop.reverseBracket(r)
+		} else {
+			ret[li-i-1] = r
+		}
+	}
+	return string(ret)
 }
diff --git a/src/vendor/golang.org/x/text/unicode/bidi/core.go b/src/vendor/golang.org/x/text/unicode/bidi/core.go
index 50deb6600a..e4c0811016 100644
--- a/src/vendor/golang.org/x/text/unicode/bidi/core.go
+++ b/src/vendor/golang.org/x/text/unicode/bidi/core.go
@@ -4,7 +4,10 @@
 
 package bidi
 
-import "log"
+import (
+	"fmt"
+	"log"
+)
 
 // This implementation is a port based on the reference implementation found at:
 // https://www.unicode.org/Public/PROGRAMS/BidiReferenceJava/
@@ -97,13 +100,20 @@ type paragraph struct {
 // rune (suggested is the rune of the open bracket for opening and matching
 // close brackets, after normalization). The embedding levels are optional, but
 // may be supplied to encode embedding levels of styled text.
-//
-// TODO: return an error.
-func newParagraph(types []Class, pairTypes []bracketType, pairValues []rune, levels level) *paragraph {
-	validateTypes(types)
-	validatePbTypes(pairTypes)
-	validatePbValues(pairValues, pairTypes)
-	validateParagraphEmbeddingLevel(levels)
+func newParagraph(types []Class, pairTypes []bracketType, pairValues []rune, levels level) (*paragraph, error) {
+	var err error
+	if err = validateTypes(types); err != nil {
+		return nil, err
+	}
+	if err = validatePbTypes(pairTypes); err != nil {
+		return nil, err
+	}
+	if err = validatePbValues(pairValues, pairTypes); err != nil {
+		return nil, err
+	}
+	if err = validateParagraphEmbeddingLevel(levels); err != nil {
+		return nil, err
+	}
 
 	p := &paragraph{
 		initialTypes:   append([]Class(nil), types...),
@@ -115,7 +125,7 @@ func newParagraph(types []Class, pairTypes []bracketType, pairValues []rune, lev
 		resultTypes: append([]Class(nil), types...),
 	}
 	p.run()
-	return p
+	return p, nil
 }
 
 func (p *paragraph) Len() int { return len(p.initialTypes) }
@@ -1001,58 +1011,61 @@ func typeForLevel(level level) Class {
 	return R
 }
 
-// TODO: change validation to not panic
-
-func validateTypes(types []Class) {
+func validateTypes(types []Class) error {
 	if len(types) == 0 {
-		log.Panic("types is null")
+		return fmt.Errorf("types is null")
 	}
 	for i, t := range types[:len(types)-1] {
 		if t == B {
-			log.Panicf("B type before end of paragraph at index: %d", i)
+			return fmt.Errorf("B type before end of paragraph at index: %d", i)
 		}
 	}
+	return nil
 }
 
-func validateParagraphEmbeddingLevel(embeddingLevel level) {
+func validateParagraphEmbeddingLevel(embeddingLevel level) error {
 	if embeddingLevel != implicitLevel &&
 		embeddingLevel != 0 &&
 		embeddingLevel != 1 {
-		log.Panicf("illegal paragraph embedding level: %d", embeddingLevel)
+		return fmt.Errorf("illegal paragraph embedding level: %d", embeddingLevel)
 	}
+	return nil
 }
 
-func validateLineBreaks(linebreaks []int, textLength int) {
+func validateLineBreaks(linebreaks []int, textLength int) error {
 	prev := 0
 	for i, next := range linebreaks {
 		if next <= prev {
-			log.Panicf("bad linebreak: %d at index: %d", next, i)
+			return fmt.Errorf("bad linebreak: %d at index: %d", next, i)
 		}
 		prev = next
 	}
 	if prev != textLength {
-		log.Panicf("last linebreak was %d, want %d", prev, textLength)
+		return fmt.Errorf("last linebreak was %d, want %d", prev, textLength)
 	}
+	return nil
 }
 
-func validatePbTypes(pairTypes []bracketType) {
+func validatePbTypes(pairTypes []bracketType) error {
 	if len(pairTypes) == 0 {
-		log.Panic("pairTypes is null")
+		return fmt.Errorf("pairTypes is null")
 	}
 	for i, pt := range pairTypes {
 		switch pt {
 		case bpNone, bpOpen, bpClose:
 		default:
-			log.Panicf("illegal pairType value at %d: %v", i, pairTypes[i])
+			return fmt.Errorf("illegal pairType value at %d: %v", i, pairTypes[i])
 		}
 	}
+	return nil
 }
 
-func validatePbValues(pairValues []rune, pairTypes []bracketType) {
+func validatePbValues(pairValues []rune, pairTypes []bracketType) error {
 	if pairValues == nil {
-		log.Panic("pairValues is null")
+		return fmt.Errorf("pairValues is null")
 	}
 	if len(pairTypes) != len(pairValues) {
-		log.Panic("pairTypes is different length from pairValues")
+		return fmt.Errorf("pairTypes is different length from pairValues")
 	}
+	return nil
 }
diff --git a/src/vendor/golang.org/x/text/unicode/bidi/tables10.0.0.go b/src/vendor/golang.org/x/text/unicode/bidi/tables10.0.0.go
index d8c94e1bd1..42fa8d72ce 100644
--- a/src/vendor/golang.org/x/text/unicode/bidi/tables10.0.0.go
+++ b/src/vendor/golang.org/x/text/unicode/bidi/tables10.0.0.go
@@ -1,5 +1,6 @@
 // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
 
+//go:build go1.10 && !go1.13
 // +build go1.10,!go1.13
 
 package bidi
diff --git a/src/vendor/golang.org/x/text/unicode/bidi/tables11.0.0.go b/src/vendor/golang.org/x/text/unicode/bidi/tables11.0.0.go
index 16b11db538..56a0e1ea21 100644
--- a/src/vendor/golang.org/x/text/unicode/bidi/tables11.0.0.go
+++ b/src/vendor/golang.org/x/text/unicode/bidi/tables11.0.0.go
@@ -1,5 +1,6 @@
 // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
 
+//go:build go1.13 && !go1.14
 // +build go1.13,!go1.14
 
 package bidi
diff --git a/src/vendor/golang.org/x/text/unicode/bidi/tables12.0.0.go b/src/vendor/golang.org/x/text/unicode/bidi/tables12.0.0.go
index 647f2d4279..baacf32b43 100644
--- a/src/vendor/golang.org/x/text/unicode/bidi/tables12.0.0.go
+++ b/src/vendor/golang.org/x/text/unicode/bidi/tables12.0.0.go
@@ -1,5 +1,6 @@
 // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
 
+//go:build go1.14 && !go1.16
 // +build go1.14,!go1.16
 
 package bidi
diff --git a/src/vendor/golang.org/x/text/unicode/bidi/tables13.0.0.go b/src/vendor/golang.org/x/text/unicode/bidi/tables13.0.0.go
index c937d0976f..f248effae1 100644
--- a/src/vendor/golang.org/x/text/unicode/bidi/tables13.0.0.go
+++ b/src/vendor/golang.org/x/text/unicode/bidi/tables13.0.0.go
@@ -1,5 +1,6 @@
 // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
 
+//go:build go1.16
 // +build go1.16
 
 package bidi
diff --git a/src/vendor/golang.org/x/text/unicode/bidi/tables9.0.0.go b/src/vendor/golang.org/x/text/unicode/bidi/tables9.0.0.go
index 0ca0193ebe..f517fdb202 100644
--- a/src/vendor/golang.org/x/text/unicode/bidi/tables9.0.0.go
+++ b/src/vendor/golang.org/x/text/unicode/bidi/tables9.0.0.go
@@ -1,5 +1,6 @@
 // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
 
+//go:build !go1.10
 // +build !go1.10
 
 package bidi
diff --git a/src/vendor/golang.org/x/text/unicode/norm/tables10.0.0.go b/src/vendor/golang.org/x/text/unicode/norm/tables10.0.0.go
index 26fbd55a12..f5a0788277 100644
--- a/src/vendor/golang.org/x/text/unicode/norm/tables10.0.0.go
+++ b/src/vendor/golang.org/x/text/unicode/norm/tables10.0.0.go
@@ -1,5 +1,6 @@
 // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
 
+//go:build go1.10 && !go1.13
 // +build go1.10,!go1.13
 
 package norm
diff --git a/src/vendor/golang.org/x/text/unicode/norm/tables11.0.0.go b/src/vendor/golang.org/x/text/unicode/norm/tables11.0.0.go
index 2c58f09baa..cb7239c437 100644
--- a/src/vendor/golang.org/x/text/unicode/norm/tables11.0.0.go
+++ b/src/vendor/golang.org/x/text/unicode/norm/tables11.0.0.go
@@ -1,5 +1,6 @@
 // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
 
+//go:build go1.13 && !go1.14
 // +build go1.13,!go1.14
 
 package norm
diff --git a/src/vendor/golang.org/x/text/unicode/norm/tables12.0.0.go b/src/vendor/golang.org/x/text/unicode/norm/tables12.0.0.go
index 7e1ae096e5..11b2733001 100644
--- a/src/vendor/golang.org/x/text/unicode/norm/tables12.0.0.go
+++ b/src/vendor/golang.org/x/text/unicode/norm/tables12.0.0.go
@@ -1,5 +1,6 @@
 // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
 
+//go:build go1.14 && !go1.16
 // +build go1.14,!go1.16
 
 package norm
diff --git a/src/vendor/golang.org/x/text/unicode/norm/tables13.0.0.go b/src/vendor/golang.org/x/text/unicode/norm/tables13.0.0.go
index 9ea1b42140..96a130d30e 100644
--- a/src/vendor/golang.org/x/text/unicode/norm/tables13.0.0.go
+++ b/src/vendor/golang.org/x/text/unicode/norm/tables13.0.0.go
@@ -1,5 +1,6 @@
 // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
 
+//go:build go1.16
 // +build go1.16
 
 package norm
diff --git a/src/vendor/golang.org/x/text/unicode/norm/tables9.0.0.go b/src/vendor/golang.org/x/text/unicode/norm/tables9.0.0.go
index 9429069291..0175eae50a 100644
--- a/src/vendor/golang.org/x/text/unicode/norm/tables9.0.0.go
+++ b/src/vendor/golang.org/x/text/unicode/norm/tables9.0.0.go
@@ -1,5 +1,6 @@
 // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
 
+//go:build !go1.10
 // +build !go1.10
 
 package norm
diff --git a/src/vendor/modules.txt b/src/vendor/modules.txt
index 06e6ef1945..15a3aef4f8 100644
--- a/src/vendor/modules.txt
+++ b/src/vendor/modules.txt
@@ -1,4 +1,4 @@
-# golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897
+# golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83
 ## explicit
 golang.org/x/crypto/chacha20
 golang.org/x/crypto/chacha20poly1305
@@ -8,7 +8,7 @@ golang.org/x/crypto/curve25519
 golang.org/x/crypto/hkdf
 golang.org/x/crypto/internal/subtle
 golang.org/x/crypto/poly1305
-# golang.org/x/net v0.0.0-20201209123823-ac852fbbde11
+# golang.org/x/net v0.0.0-20210226172049-e18ecbb05110
 ## explicit
 golang.org/x/net/dns/dnsmessage
 golang.org/x/net/http/httpguts
@@ -18,10 +18,10 @@ golang.org/x/net/idna
 golang.org/x/net/lif
 golang.org/x/net/nettest
 golang.org/x/net/route
-# golang.org/x/sys v0.0.0-20210218145245-beda7e5e158e
+# golang.org/x/sys v0.0.0-20210309074719-68d13333faf2
 ## explicit
 golang.org/x/sys/cpu
-# golang.org/x/text v0.3.4
+# golang.org/x/text v0.3.6-0.20210227105805-e3aa4adf54f6
 ## explicit
 golang.org/x/text/secure/bidirule
 golang.org/x/text/transform
-- 
GitLab


From cc4e6160a78742bba6ac8e9be225cd7a58da7a60 Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Thu, 11 Feb 2021 10:49:55 -0800
Subject: [PATCH 1087/2400] net: use mid-stack inlining with ReadFromUDP to
 avoid an allocation
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This commit rewrites ReadFromUDP to be mid-stack inlined
and pass a UDPAddr for lower layers to fill in.

This lets performance-sensitive clients avoid an allocation.
It requires some care on their part to prevent the UDPAddr
from escaping, but it is now possible.
The UDPAddr trivially does not escape in the benchmark,
as it is immediately discarded.

name                  old time/op    new time/op    delta
WriteToReadFromUDP-8    17.2µs ± 6%    17.1µs ± 5%     ~     (p=0.387 n=9+9)

name                  old alloc/op   new alloc/op   delta
WriteToReadFromUDP-8      112B ± 0%       64B ± 0%  -42.86%  (p=0.000 n=10+10)

name                  old allocs/op  new allocs/op  delta
WriteToReadFromUDP-8      3.00 ± 0%      2.00 ± 0%  -33.33%  (p=0.000 n=10+10)

Updates #43451

Co-authored-by: Filippo Valsorda <filippo@golang.org>
Change-Id: I1f9d2ab66bd7e4eff07fe39000cfa0b45717bd13
Reviewed-on: https://go-review.googlesource.com/c/go/+/291509
Run-TryBot: Filippo Valsorda <filippo@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
Trust: Filippo Valsorda <filippo@golang.org>
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
---
 src/cmd/compile/internal/test/inl_test.go |  5 ++++-
 src/net/udpsock.go                        | 22 +++++++++++++---------
 src/net/udpsock_plan9.go                  |  7 ++++---
 src/net/udpsock_posix.go                  |  7 +++----
 src/net/udpsock_test.go                   | 21 +++++++++++++++++++++
 5 files changed, 45 insertions(+), 17 deletions(-)

diff --git a/src/cmd/compile/internal/test/inl_test.go b/src/cmd/compile/internal/test/inl_test.go
index 9d31975b31..fb9942a8da 100644
--- a/src/cmd/compile/internal/test/inl_test.go
+++ b/src/cmd/compile/internal/test/inl_test.go
@@ -16,7 +16,7 @@ import (
 	"testing"
 )
 
-// TestIntendedInlining tests that specific runtime functions are inlined.
+// TestIntendedInlining tests that specific functions are inlined.
 // This allows refactoring for code clarity and re-use without fear that
 // changes to the compiler will cause silent performance regressions.
 func TestIntendedInlining(t *testing.T) {
@@ -155,6 +155,9 @@ func TestIntendedInlining(t *testing.T) {
 			"(*rngSource).Int63",
 			"(*rngSource).Uint64",
 		},
+		"net": {
+			"(*UDPConn).ReadFromUDP",
+		},
 	}
 
 	if runtime.GOARCH != "386" && runtime.GOARCH != "mips64" && runtime.GOARCH != "mips64le" && runtime.GOARCH != "riscv64" {
diff --git a/src/net/udpsock.go b/src/net/udpsock.go
index bcd0e2763e..70f2ce226a 100644
--- a/src/net/udpsock.go
+++ b/src/net/udpsock.go
@@ -100,11 +100,20 @@ func (c *UDPConn) SyscallConn() (syscall.RawConn, error) {
 }
 
 // ReadFromUDP acts like ReadFrom but returns a UDPAddr.
-func (c *UDPConn) ReadFromUDP(b []byte) (int, *UDPAddr, error) {
+func (c *UDPConn) ReadFromUDP(b []byte) (n int, addr *UDPAddr, err error) {
+	// This function is designed to allow the caller to control the lifetime
+	// of the returned *UDPAddr and thereby prevent an allocation.
+	// See https://blog.filippo.io/efficient-go-apis-with-the-inliner/.
+	// The real work is done by readFromUDP, below.
+	return c.readFromUDP(b, &UDPAddr{})
+}
+
+// readFromUDP implements ReadFromUDP.
+func (c *UDPConn) readFromUDP(b []byte, addr *UDPAddr) (int, *UDPAddr, error) {
 	if !c.ok() {
 		return 0, nil, syscall.EINVAL
 	}
-	n, addr, err := c.readFrom(b)
+	n, addr, err := c.readFrom(b, addr)
 	if err != nil {
 		err = &OpError{Op: "read", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err}
 	}
@@ -113,14 +122,9 @@ func (c *UDPConn) ReadFromUDP(b []byte) (int, *UDPAddr, error) {
 
 // ReadFrom implements the PacketConn ReadFrom method.
 func (c *UDPConn) ReadFrom(b []byte) (int, Addr, error) {
-	if !c.ok() {
-		return 0, nil, syscall.EINVAL
-	}
-	n, addr, err := c.readFrom(b)
-	if err != nil {
-		err = &OpError{Op: "read", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err}
-	}
+	n, addr, err := c.readFromUDP(b, &UDPAddr{})
 	if addr == nil {
+		// Return Addr(nil), not Addr(*UDPConn(nil)).
 		return n, nil, err
 	}
 	return n, addr, err
diff --git a/src/net/udpsock_plan9.go b/src/net/udpsock_plan9.go
index 79986ce4da..1df293d1db 100644
--- a/src/net/udpsock_plan9.go
+++ b/src/net/udpsock_plan9.go
@@ -11,7 +11,7 @@ import (
 	"syscall"
 )
 
-func (c *UDPConn) readFrom(b []byte) (n int, addr *UDPAddr, err error) {
+func (c *UDPConn) readFrom(b []byte, addr *UDPAddr) (int, *UDPAddr, error) {
 	buf := make([]byte, udpHeaderSize+len(b))
 	m, err := c.fd.Read(buf)
 	if err != nil {
@@ -23,8 +23,9 @@ func (c *UDPConn) readFrom(b []byte) (n int, addr *UDPAddr, err error) {
 	buf = buf[:m]
 
 	h, buf := unmarshalUDPHeader(buf)
-	n = copy(b, buf)
-	return n, &UDPAddr{IP: h.raddr, Port: int(h.rport)}, nil
+	n := copy(b, buf)
+	*addr = UDPAddr{IP: h.raddr, Port: int(h.rport)}
+	return n, addr, nil
 }
 
 func (c *UDPConn) readMsg(b, oob []byte) (n, oobn, flags int, addr *UDPAddr, err error) {
diff --git a/src/net/udpsock_posix.go b/src/net/udpsock_posix.go
index 58c69f18ad..3b5346e573 100644
--- a/src/net/udpsock_posix.go
+++ b/src/net/udpsock_posix.go
@@ -43,14 +43,13 @@ func (a *UDPAddr) toLocal(net string) sockaddr {
 	return &UDPAddr{loopbackIP(net), a.Port, a.Zone}
 }
 
-func (c *UDPConn) readFrom(b []byte) (int, *UDPAddr, error) {
-	var addr *UDPAddr
+func (c *UDPConn) readFrom(b []byte, addr *UDPAddr) (int, *UDPAddr, error) {
 	n, sa, err := c.fd.readFrom(b)
 	switch sa := sa.(type) {
 	case *syscall.SockaddrInet4:
-		addr = &UDPAddr{IP: sa.Addr[0:], Port: sa.Port}
+		*addr = UDPAddr{IP: sa.Addr[0:], Port: sa.Port}
 	case *syscall.SockaddrInet6:
-		addr = &UDPAddr{IP: sa.Addr[0:], Port: sa.Port, Zone: zoneCache.name(int(sa.ZoneId))}
+		*addr = UDPAddr{IP: sa.Addr[0:], Port: sa.Port, Zone: zoneCache.name(int(sa.ZoneId))}
 	}
 	return n, addr, err
 }
diff --git a/src/net/udpsock_test.go b/src/net/udpsock_test.go
index 7a1ed4eb18..8aa64baefe 100644
--- a/src/net/udpsock_test.go
+++ b/src/net/udpsock_test.go
@@ -445,3 +445,24 @@ func TestUDPReadSizeError(t *testing.T) {
 		}
 	}
 }
+
+func BenchmarkWriteToReadFromUDP(b *testing.B) {
+	conn, err := ListenUDP("udp4", new(UDPAddr))
+	if err != nil {
+		b.Fatal(err)
+	}
+	addr := conn.LocalAddr()
+	buf := make([]byte, 8)
+	b.ResetTimer()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		_, err := conn.WriteTo(buf, addr)
+		if err != nil {
+			b.Fatal(err)
+		}
+		_, _, err = conn.ReadFromUDP(buf)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
-- 
GitLab


From 4d014e723165f28b34458edb4aa9136e0fb4c702 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Tue, 27 Oct 2020 00:17:15 +0100
Subject: [PATCH 1088/2400] encoding/xml: handle leading, trailing, or double
 colons in names

Before this change, <:name> would parse as <name>, which could cause
issues in applications that rely on the parse-encode cycle to
round-trip. Similarly, <x name:=""> would parse as expected but then
have the attribute dropped when serializing because its name was empty.
Finally, <a:b:c> would parse and get serialized incorrectly. All these
values are invalid XML, but to minimize the impact of this change, we
parse them whole into Name.Local.

This issue was reported by Juho Nurminen of Mattermost as it leads to
round-trip mismatches. See #43168. It's not being fixed in a security
release because round-trip stability is not a currently supported
security property of encoding/xml, and we don't believe these fixes
would be sufficient to reliably guarantee it in the future.

Fixes CVE-2020-29509
Fixes CVE-2020-29511
Updates #43168

Change-Id: I68321c4d867305046f664347192948a889af3c7f
Reviewed-on: https://go-review.googlesource.com/c/go/+/277892
Run-TryBot: Filippo Valsorda <filippo@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Filippo Valsorda <filippo@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
---
 src/encoding/xml/xml.go      |  5 ++--
 src/encoding/xml/xml_test.go | 56 ++++++++++++++++++++++++++++++++++++
 2 files changed, 59 insertions(+), 2 deletions(-)

diff --git a/src/encoding/xml/xml.go b/src/encoding/xml/xml.go
index 384d6ad4b8..c902f1295a 100644
--- a/src/encoding/xml/xml.go
+++ b/src/encoding/xml/xml.go
@@ -1156,8 +1156,9 @@ func (d *Decoder) nsname() (name Name, ok bool) {
 	if !ok {
 		return
 	}
-	i := strings.Index(s, ":")
-	if i < 0 {
+	if strings.Count(s, ":") > 1 {
+		name.Local = s
+	} else if i := strings.Index(s, ":"); i < 1 || i > len(s)-2 {
 		name.Local = s
 	} else {
 		name.Space = s[0:i]
diff --git a/src/encoding/xml/xml_test.go b/src/encoding/xml/xml_test.go
index 5a10f5309d..47d0c39167 100644
--- a/src/encoding/xml/xml_test.go
+++ b/src/encoding/xml/xml_test.go
@@ -1003,3 +1003,59 @@ func TestTokenUnmarshaler(t *testing.T) {
 	d := NewTokenDecoder(tokReader{})
 	d.Decode(&Failure{})
 }
+
+func testRoundTrip(t *testing.T, input string) {
+	d := NewDecoder(strings.NewReader(input))
+	var tokens []Token
+	var buf bytes.Buffer
+	e := NewEncoder(&buf)
+	for {
+		tok, err := d.Token()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			t.Fatalf("invalid input: %v", err)
+		}
+		if err := e.EncodeToken(tok); err != nil {
+			t.Fatalf("failed to re-encode input: %v", err)
+		}
+		tokens = append(tokens, CopyToken(tok))
+	}
+	if err := e.Flush(); err != nil {
+		t.Fatal(err)
+	}
+
+	d = NewDecoder(&buf)
+	for {
+		tok, err := d.Token()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			t.Fatalf("failed to decode output: %v", err)
+		}
+		if len(tokens) == 0 {
+			t.Fatalf("unexpected token: %#v", tok)
+		}
+		a, b := tokens[0], tok
+		if !reflect.DeepEqual(a, b) {
+			t.Fatalf("token mismatch: %#v vs %#v", a, b)
+		}
+		tokens = tokens[1:]
+	}
+	if len(tokens) > 0 {
+		t.Fatalf("lost tokens: %#v", tokens)
+	}
+}
+
+func TestRoundTrip(t *testing.T) {
+	tests := map[string]string{
+		"leading colon":  `<::Test ::foo="bar"><:::Hello></:::Hello><Hello></Hello></::Test>`,
+		"trailing colon": `<foo abc:="x"></foo>`,
+		"double colon":   `<x:y:foo></x:y:foo>`,
+	}
+	for name, input := range tests {
+		t.Run(name, func(t *testing.T) { testRoundTrip(t, input) })
+	}
+}
-- 
GitLab


From a9cfd55e2b09735a25976d1b008a0a3c767494f8 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Tue, 27 Oct 2020 00:21:30 +0100
Subject: [PATCH 1089/2400] encoding/xml: replace comments inside directives
 with a space

A Directive (like <!ENTITY xxx []>) can't have other nodes nested inside
it (in our data structure representation), so there is no way to
preserve comments. The previous behavior was to just elide them, which
however might change the semantic meaning of the surrounding markup.
Instead, replace them with a space which hopefully has the same semantic
effect of the comment.

Directives are not actually a node type in the XML spec, which instead
specifies each of them separately (<!ENTITY, <!DOCTYPE, etc.), each with
its own grammar. The rules for where and when the comments are allowed
are not straightforward, and can't be implemented without implementing
custom logic for each of the directives.

Simply preserving the comments in the body of the directive would be
problematic, as there can be unmatched quotes inside the comment.
Whether those quotes are considered meaningful semantically or not,
other parsers might disagree and interpret the output differently.

This issue was reported by Juho Nurminen of Mattermost as it leads to
round-trip mismatches. See #43168. It's not being fixed in a security
release because round-trip stability is not a currently supported
security property of encoding/xml, and we don't believe these fixes
would be sufficient to reliably guarantee it in the future.

Fixes CVE-2020-29510
Updates #43168

Change-Id: Icd86c75beff3e1e0689543efebdad10ed5178ce3
Reviewed-on: https://go-review.googlesource.com/c/go/+/277893
Run-TryBot: Filippo Valsorda <filippo@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Filippo Valsorda <filippo@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
---
 src/encoding/xml/xml.go      |  6 ++++++
 src/encoding/xml/xml_test.go | 13 +++++++------
 2 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/src/encoding/xml/xml.go b/src/encoding/xml/xml.go
index c902f1295a..c14954df15 100644
--- a/src/encoding/xml/xml.go
+++ b/src/encoding/xml/xml.go
@@ -768,6 +768,12 @@ func (d *Decoder) rawToken() (Token, error) {
 					}
 					b0, b1 = b1, b
 				}
+
+				// Replace the comment with a space in the returned Directive
+				// body, so that markup parts that were separated by the comment
+				// (like a "<" and a "!") don't get joined when re-encoding the
+				// Directive, taking new semantic meaning.
+				d.buf.WriteByte(' ')
 			}
 		}
 		return Directive(d.buf.Bytes()), nil
diff --git a/src/encoding/xml/xml_test.go b/src/encoding/xml/xml_test.go
index 47d0c39167..19152dbdb6 100644
--- a/src/encoding/xml/xml_test.go
+++ b/src/encoding/xml/xml_test.go
@@ -802,11 +802,11 @@ var directivesWithCommentsInput = `
 
 var directivesWithCommentsTokens = []Token{
 	CharData("\n"),
-	Directive(`DOCTYPE [<!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#">]`),
+	Directive(`DOCTYPE [ <!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#">]`),
 	CharData("\n"),
-	Directive(`DOCTYPE [<!ENTITY go "Golang">]`),
+	Directive(`DOCTYPE [<!ENTITY go "Golang"> ]`),
 	CharData("\n"),
-	Directive(`DOCTYPE <!-> <!>    [<!ENTITY go "Golang">]`),
+	Directive(`DOCTYPE <!-> <!>       [<!ENTITY go "Golang"> ]`),
 	CharData("\n"),
 }
 
@@ -1051,9 +1051,10 @@ func testRoundTrip(t *testing.T, input string) {
 
 func TestRoundTrip(t *testing.T) {
 	tests := map[string]string{
-		"leading colon":  `<::Test ::foo="bar"><:::Hello></:::Hello><Hello></Hello></::Test>`,
-		"trailing colon": `<foo abc:="x"></foo>`,
-		"double colon":   `<x:y:foo></x:y:foo>`,
+		"leading colon":          `<::Test ::foo="bar"><:::Hello></:::Hello><Hello></Hello></::Test>`,
+		"trailing colon":         `<foo abc:="x"></foo>`,
+		"double colon":           `<x:y:foo></x:y:foo>`,
+		"comments in directives": `<!ENTITY x<!<!-- c1 [ " -->--x --> > <e></e> <!DOCTYPE xxx [ x<!-- c2 " -->--x ]>`,
 	}
 	for name, input := range tests {
 		t.Run(name, func(t *testing.T) { testRoundTrip(t, input) })
-- 
GitLab


From bd6aeca9686d5e672ffda1ea0cfeac7a3e7a20a4 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Mon, 16 Nov 2020 21:57:32 +0000
Subject: [PATCH 1090/2400] runtime: prepare arenas for use incrementally

This change moves the call of sysMap from (*mheap).sysAlloc into
(*mheap).grow, so we only sysMap what we're going to use in the near
future (thanks to the curArena mechanism). The purpose of this change is
to better support systems with strict overcommit rules which generally
accept reserved memory but not prepared memory (see malloc.go for exact
descriptions of these states).

This move requires changing linearAlloc to only optionally map memory.
In one case, with mheap.heapArenaAlloc, we do want it to map memory. But
now in the other case, with mheap.arena, we don't, because we want grow
to take care of it.

The risk with this change is we may make more syscalls than before on
systems with 64 MiB arenas, but because heap growth is relatively rare
this is unlikely to be a noticable issue. We also bound the amount of
syscalls made by only extending curArena (and thus mapping) by
pallocChunkPages*pageSize which is 4 MiB.

Fixes #42612.

Change-Id: I736df696afe78ddb1a747a896caa0db8726027e5
Reviewed-on: https://go-review.googlesource.com/c/go/+/270537
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
---
 src/runtime/export_test.go |  3 ---
 src/runtime/malloc.go      | 30 ++++++++++++++------------
 src/runtime/mheap.go       | 43 ++++++++++++++++++++++++++++----------
 3 files changed, 49 insertions(+), 27 deletions(-)

diff --git a/src/runtime/export_test.go b/src/runtime/export_test.go
index 195b7b0519..c03cf136f2 100644
--- a/src/runtime/export_test.go
+++ b/src/runtime/export_test.go
@@ -404,9 +404,6 @@ func ReadMemStatsSlow() (base, slow MemStats) {
 			slow.HeapReleased += uint64(pg) * pageSize
 		}
 
-		// Unused space in the current arena also counts as released space.
-		slow.HeapReleased += uint64(mheap_.curArena.end - mheap_.curArena.base)
-
 		getg().m.mallocing--
 	})
 
diff --git a/src/runtime/malloc.go b/src/runtime/malloc.go
index f20ded5bf7..8435f96532 100644
--- a/src/runtime/malloc.go
+++ b/src/runtime/malloc.go
@@ -568,7 +568,7 @@ func mallocinit() {
 		const arenaMetaSize = (1 << arenaBits) * unsafe.Sizeof(heapArena{})
 		meta := uintptr(sysReserve(nil, arenaMetaSize))
 		if meta != 0 {
-			mheap_.heapArenaAlloc.init(meta, arenaMetaSize)
+			mheap_.heapArenaAlloc.init(meta, arenaMetaSize, true)
 		}
 
 		// We want to start the arena low, but if we're linked
@@ -605,7 +605,7 @@ func mallocinit() {
 		for _, arenaSize := range arenaSizes {
 			a, size := sysReserveAligned(unsafe.Pointer(p), arenaSize, heapArenaBytes)
 			if a != nil {
-				mheap_.arena.init(uintptr(a), size)
+				mheap_.arena.init(uintptr(a), size, false)
 				p = mheap_.arena.end // For hint below
 				break
 			}
@@ -622,8 +622,8 @@ func mallocinit() {
 // heapArenaBytes. sysAlloc returns nil on failure.
 // There is no corresponding free function.
 //
-// sysAlloc returns a memory region in the Prepared state. This region must
-// be transitioned to Ready before use.
+// sysAlloc returns a memory region in the Reserved state. This region must
+// be transitioned to Prepared and then Ready before use.
 //
 // h must be locked.
 func (h *mheap) sysAlloc(n uintptr) (v unsafe.Pointer, size uintptr) {
@@ -725,9 +725,6 @@ func (h *mheap) sysAlloc(n uintptr) (v unsafe.Pointer, size uintptr) {
 		throw("misrounded allocation in sysAlloc")
 	}
 
-	// Transition from Reserved to Prepared.
-	sysMap(v, size, &memstats.heap_sys)
-
 mapped:
 	// Create arena metadata.
 	for ri := arenaIndex(uintptr(v)); ri <= arenaIndex(uintptr(v)+size-1); ri++ {
@@ -1400,15 +1397,19 @@ func inPersistentAlloc(p uintptr) bool {
 }
 
 // linearAlloc is a simple linear allocator that pre-reserves a region
-// of memory and then maps that region into the Ready state as needed. The
-// caller is responsible for locking.
+// of memory and then optionally maps that region into the Ready state
+// as needed.
+//
+// The caller is responsible for locking.
 type linearAlloc struct {
 	next   uintptr // next free byte
 	mapped uintptr // one byte past end of mapped space
 	end    uintptr // end of reserved space
+
+	mapMemory bool // transition memory from Reserved to Ready if true
 }
 
-func (l *linearAlloc) init(base, size uintptr) {
+func (l *linearAlloc) init(base, size uintptr, mapMemory bool) {
 	if base+size < base {
 		// Chop off the last byte. The runtime isn't prepared
 		// to deal with situations where the bounds could overflow.
@@ -1418,6 +1419,7 @@ func (l *linearAlloc) init(base, size uintptr) {
 	}
 	l.next, l.mapped = base, base
 	l.end = base + size
+	l.mapMemory = mapMemory
 }
 
 func (l *linearAlloc) alloc(size, align uintptr, sysStat *sysMemStat) unsafe.Pointer {
@@ -1427,9 +1429,11 @@ func (l *linearAlloc) alloc(size, align uintptr, sysStat *sysMemStat) unsafe.Poi
 	}
 	l.next = p + size
 	if pEnd := alignUp(l.next-1, physPageSize); pEnd > l.mapped {
-		// Transition from Reserved to Prepared to Ready.
-		sysMap(unsafe.Pointer(l.mapped), pEnd-l.mapped, sysStat)
-		sysUsed(unsafe.Pointer(l.mapped), pEnd-l.mapped)
+		if l.mapMemory {
+			// Transition from Reserved to Prepared to Ready.
+			sysMap(unsafe.Pointer(l.mapped), pEnd-l.mapped, sysStat)
+			sysUsed(unsafe.Pointer(l.mapped), pEnd-l.mapped)
+		}
 		l.mapped = pEnd
 	}
 	return unsafe.Pointer(p)
diff --git a/src/runtime/mheap.go b/src/runtime/mheap.go
index 08019a4101..13ea337735 100644
--- a/src/runtime/mheap.go
+++ b/src/runtime/mheap.go
@@ -1320,6 +1320,10 @@ func (h *mheap) grow(npage uintptr) bool {
 	assertLockHeld(&h.lock)
 
 	// We must grow the heap in whole palloc chunks.
+	// We call sysMap below but note that because we
+	// round up to pallocChunkPages which is on the order
+	// of MiB (generally >= to the huge page size) we
+	// won't be calling it too much.
 	ask := alignUp(npage, pallocChunkPages) * pageSize
 
 	totalGrowth := uintptr(0)
@@ -1346,6 +1350,17 @@ func (h *mheap) grow(npage uintptr) bool {
 			// remains of the current space and switch to
 			// the new space. This should be rare.
 			if size := h.curArena.end - h.curArena.base; size != 0 {
+				// Transition this space from Reserved to Prepared and mark it
+				// as released since we'll be able to start using it after updating
+				// the page allocator and releasing the lock at any time.
+				sysMap(unsafe.Pointer(h.curArena.base), size, &memstats.heap_sys)
+				// Update stats.
+				atomic.Xadd64(&memstats.heap_released, int64(size))
+				stats := memstats.heapStats.acquire()
+				atomic.Xaddint64(&stats.released, int64(size))
+				memstats.heapStats.release()
+				// Update the page allocator's structures to make this
+				// space ready for allocation.
 				h.pages.grow(h.curArena.base, size)
 				totalGrowth += size
 			}
@@ -1354,17 +1369,6 @@ func (h *mheap) grow(npage uintptr) bool {
 			h.curArena.end = uintptr(av) + asize
 		}
 
-		// The memory just allocated counts as both released
-		// and idle, even though it's not yet backed by spans.
-		//
-		// The allocation is always aligned to the heap arena
-		// size which is always > physPageSize, so its safe to
-		// just add directly to heap_released.
-		atomic.Xadd64(&memstats.heap_released, int64(asize))
-		stats := memstats.heapStats.acquire()
-		atomic.Xaddint64(&stats.released, int64(asize))
-		memstats.heapStats.release()
-
 		// Recalculate nBase.
 		// We know this won't overflow, because sysAlloc returned
 		// a valid region starting at h.curArena.base which is at
@@ -1375,6 +1379,23 @@ func (h *mheap) grow(npage uintptr) bool {
 	// Grow into the current arena.
 	v := h.curArena.base
 	h.curArena.base = nBase
+
+	// Transition the space we're going to use from Reserved to Prepared.
+	sysMap(unsafe.Pointer(v), nBase-v, &memstats.heap_sys)
+
+	// The memory just allocated counts as both released
+	// and idle, even though it's not yet backed by spans.
+	//
+	// The allocation is always aligned to the heap arena
+	// size which is always > physPageSize, so its safe to
+	// just add directly to heap_released.
+	atomic.Xadd64(&memstats.heap_released, int64(nBase-v))
+	stats := memstats.heapStats.acquire()
+	atomic.Xaddint64(&stats.released, int64(nBase-v))
+	memstats.heapStats.release()
+
+	// Update the page allocator's structures to make this
+	// space ready for allocation.
 	h.pages.grow(v, nBase-v)
 	totalGrowth += nBase - v
 
-- 
GitLab


From dca9c11845a950130c37f4f4e5ffb55848ff7155 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Sat, 13 Mar 2021 22:41:51 -0800
Subject: [PATCH 1091/2400] cmd/compile:  add support for generic channels and
 type conversion during calls

Add support for channels in subster.typ(). Add new test file chans.go.

To support assignability of bidirectional channel args to directional
channel params, I needed to type check generic calls after they are
instantiated. (Eventually, we will create separate functions to just do
the assignability logic, so we don't need to call the old typechecker in
this case.) So, for generic calls, we now leave the call as OCALL (as a
signal that the call still needs typechecking), and do typecheck.Call()
during stenciling.

Smaller changes:
 - Set the type of an instantiated OCLOSURE node (and not just the associated
   OFUNC node)

 - In instTypeName2, filter out the space that types2.TypeString inserts
   after a common in a typelist. Our standard naming requires no space
   after the comma.

 - With the assignability fix above, I no longer need the explicit
   conversions in cons.go.

Change-Id: I148858bfc6708c0aa3f50bad7debce2b8c8c091f
Reviewed-on: https://go-review.googlesource.com/c/go/+/301669
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/helpers.go |  21 +-
 src/cmd/compile/internal/noder/stencil.go |  34 +-
 src/cmd/compile/internal/noder/types.go   |  11 +-
 test/typeparam/chans.go                   | 413 ++++++++++++++++++++++
 test/typeparam/cons.go                    |   5 +-
 5 files changed, 456 insertions(+), 28 deletions(-)
 create mode 100644 test/typeparam/chans.go

diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
index 2b084ff311..cf7a3e22b3 100644
--- a/src/cmd/compile/internal/noder/helpers.go
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -138,30 +138,19 @@ func Call(pos src.XPos, typ *types.Type, fun ir.Node, args []ir.Node, dots bool)
 		return n
 	}
 	if fun.Op() != ir.OFUNCINST {
-		// If no type params, still do normal typechecking, since we're
-		// still missing some things done by tcCall below (mainly
-		// typecheckargs and typecheckaste).
+		// If no type params, do normal typechecking, since we're
+		// still missing some things done by tcCall (mainly
+		// typecheckaste/assignconvfn - implementing assignability of args
+		// to params).  This will convert OCALL to OCALLFUNC.
 		typecheck.Call(n)
 		return n
 	}
 
+	// Leave the op as OCALL, which indicates the call still needs typechecking.
 	n.Use = ir.CallUseExpr
 	if fun.Type().NumResults() == 0 {
 		n.Use = ir.CallUseStmt
 	}
-
-	// Rewrite call node depending on use.
-	switch fun.Op() {
-	case ir.ODOTINTER:
-		n.SetOp(ir.OCALLINTER)
-
-	case ir.ODOTMETH:
-		n.SetOp(ir.OCALLMETH)
-
-	default:
-		n.SetOp(ir.OCALLFUNC)
-	}
-
 	typed(typ, n)
 	return n
 }
diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 071a2f44c2..d8e1eaab65 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -73,7 +73,7 @@ func (g *irgen) stencil() {
 				// immediately called.
 				foundFuncInst = true
 			}
-			if n.Op() != ir.OCALLFUNC || n.(*ir.CallExpr).X.Op() != ir.OFUNCINST {
+			if n.Op() != ir.OCALL || n.(*ir.CallExpr).X.Op() != ir.OFUNCINST {
 				return
 			}
 			// We have found a function call using a generic function
@@ -95,6 +95,10 @@ func (g *irgen) stencil() {
 				copy(withRecv[1:], call.Args)
 				call.Args = withRecv
 			}
+			// Do the typechecking of the Call now, which changes OCALL
+			// to OCALLFUNC and does typecheckaste/assignconvfn.
+			call.SetTypecheck(0)
+			typecheck.Call(call)
 			modified = true
 		})
 
@@ -348,7 +352,8 @@ func (subst *subster) node(n ir.Node) ir.Node {
 				// an error.
 				_, isCallExpr := m.(*ir.CallExpr)
 				_, isStructKeyExpr := m.(*ir.StructKeyExpr)
-				if !isCallExpr && !isStructKeyExpr {
+				if !isCallExpr && !isStructKeyExpr && x.Op() != ir.OPANIC &&
+					x.Op() != ir.OCLOSE {
 					base.Fatalf(fmt.Sprintf("Nil type for %v", x))
 				}
 			} else if x.Op() != ir.OCLOSURE {
@@ -382,10 +387,13 @@ func (subst *subster) node(n ir.Node) ir.Node {
 				call.X.SetTypecheck(0)
 				call.X.SetType(nil)
 				typecheck.Callee(call.X)
-				m.SetTypecheck(0)
-				typecheck.Call(m.(*ir.CallExpr))
-			} else {
-				base.FatalfAt(call.Pos(), "Expecting OCALLPART or OTYPE with CALL")
+				call.SetTypecheck(0)
+				typecheck.Call(call)
+			} else if call.X.Op() != ir.OFUNCINST {
+				// A call with an OFUNCINST will get typechecked
+				// in stencil() once we have created & attached the
+				// instantiation to be called.
+				base.FatalfAt(call.Pos(), "Expecting OCALLPART or OTYPE or OFUNCINST with CALL")
 			}
 		}
 
@@ -420,6 +428,7 @@ func (subst *subster) node(n ir.Node) ir.Node {
 			// Set Ntype for now to be compatible with later parts of compiler
 			newfn.Nname.Ntype = subst.node(oldfn.Nname.Ntype).(ir.Ntype)
 			typed(subst.typ(oldfn.Nname.Type()), newfn.Nname)
+			typed(newfn.Nname.Type(), m)
 			newfn.SetTypecheck(1)
 			subst.g.target.Decls = append(subst.g.target.Decls, newfn)
 		}
@@ -664,7 +673,18 @@ func (subst *subster) typ(t *types.Type) *types.Type {
 			newt = nil
 		}
 
-		// TODO: case TCHAN
+	case types.TCHAN:
+		elem := t.Elem()
+		newelem := subst.typ(elem)
+		if newelem != elem {
+			newt = types.NewChan(newelem, t.ChanDir())
+			if !newt.HasTParam() {
+				// TODO(danscales): not sure why I have to do this
+				// only for channels.....
+				types.CheckSize(newt)
+			}
+		}
+
 		// TODO: case TMAP
 	}
 	if newt == nil {
diff --git a/src/cmd/compile/internal/noder/types.go b/src/cmd/compile/internal/noder/types.go
index 58b7262455..c5506ab472 100644
--- a/src/cmd/compile/internal/noder/types.go
+++ b/src/cmd/compile/internal/noder/types.go
@@ -68,8 +68,15 @@ func instTypeName2(name string, targs []types2.Type) string {
 		if i > 0 {
 			b.WriteByte(',')
 		}
-		b.WriteString(types2.TypeString(targ,
-			func(*types2.Package) string { return "" }))
+		tname := types2.TypeString(targ,
+			func(*types2.Package) string { return "" })
+		if strings.Index(tname, ", ") >= 0 {
+			// types2.TypeString puts spaces after a comma in a type
+			// list, but we don't want spaces in our actual type names
+			// and method/function names derived from them.
+			tname = strings.Replace(tname, ", ", ",", -1)
+		}
+		b.WriteString(tname)
 	}
 	b.WriteByte(']')
 	return b.String()
diff --git a/test/typeparam/chans.go b/test/typeparam/chans.go
new file mode 100644
index 0000000000..2fcd4af75e
--- /dev/null
+++ b/test/typeparam/chans.go
@@ -0,0 +1,413 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 chans provides utility functions for working with channels.
+package main
+
+import (
+	"context"
+	"fmt"
+	"runtime"
+	"sort"
+	"sync"
+	"time"
+)
+
+// _Equal reports whether two slices are equal: the same length and all
+// elements equal. All floating point NaNs are considered equal.
+func _SliceEqual[Elem comparable](s1, s2 []Elem) bool {
+	if len(s1) != len(s2) {
+		return false
+	}
+	for i, v1 := range s1 {
+		v2 := s2[i]
+		if v1 != v2 {
+			isNaN := func(f Elem) bool { return f != f }
+			if !isNaN(v1) || !isNaN(v2) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// _ReadAll reads from c until the channel is closed or the context is
+// canceled, returning all the values read.
+func _ReadAll[Elem any](ctx context.Context, c <-chan Elem) []Elem {
+	var r []Elem
+	for {
+		select {
+		case <-ctx.Done():
+			return r
+		case v, ok := <-c:
+			if !ok {
+				return r
+			}
+			r = append(r, v)
+		}
+	}
+}
+
+// _Merge merges two channels into a single channel.
+// This will leave a goroutine running until either both channels are closed
+// or the context is canceled, at which point the returned channel is closed.
+func _Merge[Elem any](ctx context.Context, c1, c2 <-chan Elem) <-chan Elem {
+	r := make(chan Elem)
+	go func(ctx context.Context, c1, c2 <-chan Elem, r chan<- Elem) {
+		defer close(r)
+		for c1 != nil || c2 != nil {
+			select {
+			case <-ctx.Done():
+				return
+			case v1, ok := <-c1:
+				if ok {
+					r <- v1
+				} else {
+					c1 = nil
+				}
+			case v2, ok := <-c2:
+				if ok {
+					r <- v2
+				} else {
+					c2 = nil
+				}
+			}
+		}
+	}(ctx, c1, c2, r)
+	return r
+}
+
+// _Filter calls f on each value read from c. If f returns true the value
+// is sent on the returned channel. This will leave a goroutine running
+// until c is closed or the context is canceled, at which point the
+// returned channel is closed.
+func _Filter[Elem any](ctx context.Context, c <-chan Elem, f func(Elem) bool) <-chan Elem {
+	r := make(chan Elem)
+	go func(ctx context.Context, c <-chan Elem, f func(Elem) bool, r chan<- Elem) {
+		defer close(r)
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case v, ok := <-c:
+				if !ok {
+					return
+				}
+				if f(v) {
+					r <- v
+				}
+			}
+		}
+	}(ctx, c, f, r)
+	return r
+}
+
+// _Sink returns a channel that discards all values sent to it.
+// This will leave a goroutine running until the context is canceled
+// or the returned channel is closed.
+func _Sink[Elem any](ctx context.Context) chan<- Elem {
+	r := make(chan Elem)
+	go func(ctx context.Context, r <-chan Elem) {
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case _, ok := <-r:
+				if !ok {
+					return
+				}
+			}
+		}
+	}(ctx, r)
+	return r
+}
+
+// An Exclusive is a value that may only be used by a single goroutine
+// at a time. This is implemented using channels rather than a mutex.
+type _Exclusive[Val any] struct {
+	c chan Val
+}
+
+// _MakeExclusive makes an initialized exclusive value.
+func _MakeExclusive[Val any](initial Val) *_Exclusive[Val] {
+	r := &_Exclusive[Val]{
+		c: make(chan Val, 1),
+	}
+	r.c <- initial
+	return r
+}
+
+// _Acquire acquires the exclusive value for private use.
+// It must be released using the Release method.
+func (e *_Exclusive[Val]) Acquire() Val {
+	return <-e.c
+}
+
+// TryAcquire attempts to acquire the value. The ok result reports whether
+// the value was acquired. If the value is acquired, it must be released
+// using the Release method.
+func (e *_Exclusive[Val]) TryAcquire() (v Val, ok bool) {
+	select {
+	case r := <-e.c:
+		return r, true
+	default:
+		return v, false
+	}
+}
+
+// Release updates and releases the value.
+// This method panics if the value has not been acquired.
+func (e *_Exclusive[Val]) Release(v Val) {
+	select {
+	case e.c <- v:
+	default:
+		panic("_Exclusive Release without Acquire")
+	}
+}
+
+// Ranger returns a Sender and a Receiver. The Receiver provides a
+// Next method to retrieve values. The Sender provides a Send method
+// to send values and a Close method to stop sending values. The Next
+// method indicates when the Sender has been closed, and the Send
+// method indicates when the Receiver has been freed.
+//
+// This is a convenient way to exit a goroutine sending values when
+// the receiver stops reading them.
+func _Ranger[Elem any]() (*_Sender[Elem], *_Receiver[Elem]) {
+	c := make(chan Elem)
+	d := make(chan struct{})
+	s := &_Sender[Elem]{
+		values: c,
+		done:   d,
+	}
+	r := &_Receiver[Elem] {
+		values: c,
+		done:   d,
+	}
+	runtime.SetFinalizer(r, (*_Receiver[Elem]).finalize)
+	return s, r
+}
+
+// A _Sender is used to send values to a Receiver.
+type _Sender[Elem any] struct {
+	values chan<- Elem
+	done   <-chan struct{}
+}
+
+// Send sends a value to the receiver. It reports whether the value was sent.
+// The value will not be sent if the context is closed or the receiver
+// is freed.
+func (s *_Sender[Elem]) Send(ctx context.Context, v Elem) bool {
+	select {
+	case <-ctx.Done():
+		return false
+	case s.values <- v:
+		return true
+	case <-s.done:
+		return false
+	}
+}
+
+// Close tells the receiver that no more values will arrive.
+// After Close is called, the _Sender may no longer be used.
+func (s *_Sender[Elem]) Close() {
+	close(s.values)
+}
+
+// A _Receiver receives values from a _Sender.
+type _Receiver[Elem any] struct {
+	values <-chan Elem
+	done   chan<- struct{}
+}
+
+// Next returns the next value from the channel. The bool result indicates
+// whether the value is valid.
+func (r *_Receiver[Elem]) Next(ctx context.Context) (v Elem, ok bool) {
+	select {
+	case <-ctx.Done():
+	case v, ok = <-r.values:
+	}
+	return v, ok
+}
+
+// finalize is a finalizer for the receiver.
+func (r *_Receiver[Elem]) finalize() {
+	close(r.done)
+}
+
+func TestReadAll() {
+	c := make(chan int)
+	go func() {
+		c <- 4
+		c <- 2
+		c <- 5
+		close(c)
+	}()
+	got := _ReadAll(context.Background(), c)
+	want := []int{4, 2, 5}
+	if !_SliceEqual(got, want) {
+		panic(fmt.Sprintf("_ReadAll returned %v, want %v", got, want))
+	}
+}
+
+func TestMerge() {
+	c1 := make(chan int)
+	c2 := make(chan int)
+	go func() {
+		c1 <- 1
+		c1 <- 3
+		c1 <- 5
+		close(c1)
+	}()
+	go func() {
+		c2 <- 2
+		c2 <- 4
+		c2 <- 6
+		close(c2)
+	}()
+	ctx := context.Background()
+	got := _ReadAll(ctx, _Merge(ctx, c1, c2))
+	sort.Ints(got)
+	want := []int{1, 2, 3, 4, 5, 6}
+	if !_SliceEqual(got, want) {
+		panic(fmt.Sprintf("_Merge returned %v, want %v", got, want))
+	}
+}
+
+func TestFilter() {
+	c := make(chan int)
+	go func() {
+		c <- 1
+		c <- 2
+		c <- 3
+		close(c)
+	}()
+	even := func(i int) bool { return i%2 == 0 }
+	ctx := context.Background()
+	got := _ReadAll(ctx, _Filter(ctx, c, even))
+	want := []int{2}
+	if !_SliceEqual(got, want) {
+		panic(fmt.Sprintf("_Filter returned %v, want %v", got, want))
+	}
+}
+
+func TestSink() {
+	c := _Sink[int](context.Background())
+	after := time.NewTimer(time.Minute)
+	defer after.Stop()
+	send := func(v int) {
+		select {
+		case c <- v:
+		case <-after.C:
+			panic("timed out sending to _Sink")
+		}
+	}
+	send(1)
+	send(2)
+	send(3)
+	close(c)
+}
+
+func TestExclusive() {
+	val := 0
+	ex := _MakeExclusive(&val)
+
+	var wg sync.WaitGroup
+	f := func() {
+		defer wg.Done()
+		for i := 0; i < 10; i++ {
+			p := ex.Acquire()
+			(*p)++
+			ex.Release(p)
+		}
+	}
+
+	wg.Add(2)
+	go f()
+	go f()
+
+	wg.Wait()
+	if val != 20 {
+		panic(fmt.Sprintf("after Acquire/Release loop got %d, want 20", val))
+	}
+}
+
+func TestExclusiveTry() {
+	s := ""
+	ex := _MakeExclusive(&s)
+	p, ok := ex.TryAcquire()
+	if !ok {
+		panic("TryAcquire failed")
+	}
+	*p = "a"
+
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		_, ok := ex.TryAcquire()
+		if ok {
+			panic(fmt.Sprintf("TryAcquire succeeded unexpectedly"))
+		}
+	}()
+	wg.Wait()
+
+	ex.Release(p)
+
+	p, ok = ex.TryAcquire()
+	if !ok {
+		panic(fmt.Sprintf("TryAcquire failed"))
+	}
+}
+
+func TestRanger() {
+	s, r := _Ranger[int]()
+
+	ctx := context.Background()
+	go func() {
+		// Receive one value then exit.
+		v, ok := r.Next(ctx)
+		if !ok {
+			panic(fmt.Sprintf("did not receive any values"))
+		} else if v != 1 {
+			panic(fmt.Sprintf("received %d, want 1", v))
+		}
+	}()
+
+	c1 := make(chan bool)
+	c2 := make(chan bool)
+	go func() {
+		defer close(c2)
+		if !s.Send(ctx, 1) {
+			panic(fmt.Sprintf("Send failed unexpectedly"))
+		}
+		close(c1)
+		if s.Send(ctx, 2) {
+			panic(fmt.Sprintf("Send succeeded unexpectedly"))
+		}
+	}()
+
+	<-c1
+
+	// Force a garbage collection to try to get the finalizers to run.
+	runtime.GC()
+
+	select {
+	case <-c2:
+	case <-time.After(time.Minute):
+		panic("_Ranger Send should have failed, but timed out")
+	}
+}
+
+func main() {
+	TestReadAll()
+	TestMerge()
+	TestFilter()
+	TestSink()
+	TestExclusive()
+	TestExclusiveTry()
+	TestRanger()
+}
diff --git a/test/typeparam/cons.go b/test/typeparam/cons.go
index 08a825f59f..8d255ebdb8 100644
--- a/test/typeparam/cons.go
+++ b/test/typeparam/cons.go
@@ -88,9 +88,8 @@ func _Map[a, b any](f _Function[a, b], xs _List[a]) _List[b] {
 
 func main() {
 	var xs _List[int] = _Cons[int]{3, _Cons[int]{6, _Nil[int]{}}}
-	// TODO(danscales): Remove conversion calls in next two, needed for now.
-	var ys _List[int] = _Map[int, int](_Function[int, int](incr{-5}), xs)
-	var xz _List[bool] = _Map[int, bool](_Function[int, bool](pos{}), ys)
+	var ys _List[int] = _Map[int, int](incr{-5}, xs)
+	var xz _List[bool] = _Map[int, bool](pos{}, ys)
 	cs1 := xz.(_Cons[bool])
 	cs2 := cs1.Tail.(_Cons[bool])
 	_, ok := cs2.Tail.(_Nil[bool])
-- 
GitLab


From c2360956389a30a27407fb857fd4916f20f8dc01 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Sun, 14 Mar 2021 20:13:05 -0700
Subject: [PATCH 1092/2400] cmd/compile: add support for generic maps

Add support for maps in subster.typ(). Add new test cases maps.go and set.go.

Change substitution of a TFUNC in subster.typ() to always create new
param and result structs if any of the receiver, param, or result
structs get substituted. All these func structs must be copied, because
they have offset fields that are dependent, and so must have an
independent copy for each new signature (else there will be an error
later when frame offsets are calculated).

Change-Id: I576942a62f06b46b6f005abc98f65533008de8dc
Reviewed-on: https://go-review.googlesource.com/c/go/+/301670
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/stencil.go |  41 +++-
 test/typeparam/maps.go                    | 260 ++++++++++++++++++++
 test/typeparam/sets.go                    | 280 ++++++++++++++++++++++
 3 files changed, 572 insertions(+), 9 deletions(-)
 create mode 100644 test/typeparam/maps.go
 create mode 100644 test/typeparam/sets.go

diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index d8e1eaab65..78c7ddeabe 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -461,9 +461,11 @@ func (subst *subster) list(l []ir.Node) []ir.Node {
 }
 
 // tstruct substitutes type params in types of the fields of a structure type. For
-// each field, if Nname is set, tstruct also translates the Nname using subst.vars, if
-// Nname is in subst.vars.
-func (subst *subster) tstruct(t *types.Type) *types.Type {
+// each field, if Nname is set, tstruct also translates the Nname using
+// subst.vars, if Nname is in subst.vars. To always force the creation of a new
+// (top-level) struct, regardless of whether anything changed with the types or
+// names of the struct's fields, set force to true.
+func (subst *subster) tstruct(t *types.Type, force bool) *types.Type {
 	if t.NumFields() == 0 {
 		if t.HasTParam() {
 			// For an empty struct, we need to return a new type,
@@ -474,6 +476,9 @@ func (subst *subster) tstruct(t *types.Type) *types.Type {
 		return t
 	}
 	var newfields []*types.Field
+	if force {
+		newfields = make([]*types.Field, t.NumFields())
+	}
 	for i, f := range t.Fields().Slice() {
 		t2 := subst.typ(f.Type)
 		if (t2 != f.Type || f.Nname != nil) && newfields == nil {
@@ -650,20 +655,33 @@ func (subst *subster) typ(t *types.Type) *types.Type {
 		}
 
 	case types.TSTRUCT:
-		newt = subst.tstruct(t)
+		newt = subst.tstruct(t, false)
 		if newt == t {
 			newt = nil
 		}
 
 	case types.TFUNC:
-		newrecvs := subst.tstruct(t.Recvs())
-		newparams := subst.tstruct(t.Params())
-		newresults := subst.tstruct(t.Results())
+		newrecvs := subst.tstruct(t.Recvs(), false)
+		newparams := subst.tstruct(t.Params(), false)
+		newresults := subst.tstruct(t.Results(), false)
 		if newrecvs != t.Recvs() || newparams != t.Params() || newresults != t.Results() {
+			// If any types have changed, then the all the fields of
+			// of recv, params, and results must be copied, because they have
+			// offset fields that are dependent, and so must have an
+			// independent copy for each new signature.
 			var newrecv *types.Field
 			if newrecvs.NumFields() > 0 {
+				if newrecvs == t.Recvs() {
+					newrecvs = subst.tstruct(t.Recvs(), true)
+				}
 				newrecv = newrecvs.Field(0)
 			}
+			if newparams == t.Params() {
+				newparams = subst.tstruct(t.Params(), true)
+			}
+			if newresults == t.Results() {
+				newresults = subst.tstruct(t.Results(), true)
+			}
 			newt = types.NewSignature(t.Pkg(), newrecv, t.TParams().FieldSlice(), newparams.FieldSlice(), newresults.FieldSlice())
 		}
 
@@ -673,6 +691,13 @@ func (subst *subster) typ(t *types.Type) *types.Type {
 			newt = nil
 		}
 
+	case types.TMAP:
+		newkey := subst.typ(t.Key())
+		newval := subst.typ(t.Elem())
+		if newkey != t.Key() || newval != t.Elem() {
+			newt = types.NewMap(newkey, newval)
+		}
+
 	case types.TCHAN:
 		elem := t.Elem()
 		newelem := subst.typ(elem)
@@ -684,8 +709,6 @@ func (subst *subster) typ(t *types.Type) *types.Type {
 				types.CheckSize(newt)
 			}
 		}
-
-		// TODO: case TMAP
 	}
 	if newt == nil {
 		// Even though there were typeparams in the type, there may be no
diff --git a/test/typeparam/maps.go b/test/typeparam/maps.go
new file mode 100644
index 0000000000..d18dd59aed
--- /dev/null
+++ b/test/typeparam/maps.go
@@ -0,0 +1,260 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 (
+	"fmt"
+	"math"
+	"sort"
+)
+
+// _Equal reports whether two slices are equal: the same length and all
+// elements equal. All floating point NaNs are considered equal.
+func _SliceEqual[Elem comparable](s1, s2 []Elem) bool {
+	if len(s1) != len(s2) {
+		return false
+	}
+	for i, v1 := range s1 {
+		v2 := s2[i]
+		if v1 != v2 {
+			isNaN := func(f Elem) bool { return f != f }
+			if !isNaN(v1) || !isNaN(v2) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// _Keys returns the keys of the map m.
+// The keys will be an indeterminate order.
+func _Keys[K comparable, V any](m map[K]V) []K {
+	r := make([]K, 0, len(m))
+	for k := range m {
+		r = append(r, k)
+	}
+	return r
+}
+
+// _Values returns the values of the map m.
+// The values will be in an indeterminate order.
+func _Values[K comparable, V any](m map[K]V) []V {
+	r := make([]V, 0, len(m))
+	for _, v := range m {
+		r = append(r, v)
+	}
+	return r
+}
+
+// _Equal reports whether two maps contain the same key/value pairs.
+// _Values are compared using ==.
+func _Equal[K, V comparable](m1, m2 map[K]V) bool {
+	if len(m1) != len(m2) {
+		return false
+	}
+	for k, v1 := range m1 {
+		if v2, ok := m2[k]; !ok || v1 != v2 {
+			return false
+		}
+	}
+	return true
+}
+
+// _Copy returns a copy of m.
+func _Copy[K comparable, V any](m map[K]V) map[K]V {
+	r := make(map[K]V, len(m))
+	for k, v := range m {
+		r[k] = v
+	}
+	return r
+}
+
+// _Add adds all key/value pairs in m2 to m1. _Keys in m2 that are already
+// present in m1 will be overwritten with the value in m2.
+func _Add[K comparable, V any](m1, m2 map[K]V) {
+	for k, v := range m2 {
+		m1[k] = v
+	}
+}
+
+// _Sub removes all keys in m2 from m1. _Keys in m2 that are not present
+// in m1 are ignored. The values in m2 are ignored.
+func _Sub[K comparable, V any](m1, m2 map[K]V) {
+	for k := range m2 {
+		delete(m1, k)
+	}
+}
+
+// _Intersect removes all keys from m1 that are not present in m2.
+// _Keys in m2 that are not in m1 are ignored. The values in m2 are ignored.
+func _Intersect[K comparable, V any](m1, m2 map[K]V) {
+	for k := range m1 {
+		if _, ok := m2[k]; !ok {
+			delete(m1, k)
+		}
+	}
+}
+
+// _Filter deletes any key/value pairs from m for which f returns false.
+func _Filter[K comparable, V any](m map[K]V, f func(K, V) bool) {
+	for k, v := range m {
+		if !f(k, v) {
+			delete(m, k)
+		}
+	}
+}
+
+// _TransformValues applies f to each value in m. The keys remain unchanged.
+func _TransformValues[K comparable, V any](m map[K]V, f func(V) V) {
+	for k, v := range m {
+		m[k] = f(v)
+	}
+}
+
+var m1 = map[int]int{1: 2, 2: 4, 4: 8, 8: 16}
+var m2 = map[int]string{1: "2", 2: "4", 4: "8", 8: "16"}
+
+func TestKeys() {
+	want := []int{1, 2, 4, 8}
+
+	got1 := _Keys(m1)
+	sort.Ints(got1)
+	if !_SliceEqual(got1, want) {
+		panic(fmt.Sprintf("_Keys(%v) = %v, want %v", m1, got1, want))
+	}
+
+	got2 := _Keys(m2)
+	sort.Ints(got2)
+	if !_SliceEqual(got2, want) {
+		panic(fmt.Sprintf("_Keys(%v) = %v, want %v", m2, got2, want))
+	}
+}
+
+func TestValues() {
+	got1 := _Values(m1)
+	want1 := []int{2, 4, 8, 16}
+	sort.Ints(got1)
+	if !_SliceEqual(got1, want1) {
+		panic(fmt.Sprintf("_Values(%v) = %v, want %v", m1, got1, want1))
+	}
+
+	got2 := _Values(m2)
+	want2 := []string{"16", "2", "4", "8"}
+	sort.Strings(got2)
+	if !_SliceEqual(got2, want2) {
+		panic(fmt.Sprintf("_Values(%v) = %v, want %v", m2, got2, want2))
+	}
+}
+
+func TestEqual() {
+	if !_Equal(m1, m1) {
+		panic(fmt.Sprintf("_Equal(%v, %v) = false, want true", m1, m1))
+	}
+	if _Equal(m1, nil) {
+		panic(fmt.Sprintf("_Equal(%v, nil) = true, want false", m1))
+	}
+	if _Equal(nil, m1) {
+		panic(fmt.Sprintf("_Equal(nil, %v) = true, want false", m1))
+	}
+	if !_Equal[int, int](nil, nil) {
+		panic("_Equal(nil, nil) = false, want true")
+	}
+	if ms := map[int]int{1: 2}; _Equal(m1, ms) {
+		panic(fmt.Sprintf("_Equal(%v, %v) = true, want false", m1, ms))
+	}
+
+	// Comparing NaN for equality is expected to fail.
+	mf := map[int]float64{1: 0, 2: math.NaN()}
+	if _Equal(mf, mf) {
+		panic(fmt.Sprintf("_Equal(%v, %v) = true, want false", mf, mf))
+	}
+}
+
+func TestCopy() {
+	m2 := _Copy(m1)
+	if !_Equal(m1, m2) {
+		panic(fmt.Sprintf("_Copy(%v) = %v, want %v", m1, m2, m1))
+	}
+	m2[16] = 32
+	if _Equal(m1, m2) {
+		panic(fmt.Sprintf("_Equal(%v, %v) = true, want false", m1, m2))
+	}
+}
+
+func TestAdd() {
+	mc := _Copy(m1)
+	_Add(mc, mc)
+	if !_Equal(mc, m1) {
+		panic(fmt.Sprintf("_Add(%v, %v) = %v, want %v", m1, m1, mc, m1))
+	}
+	_Add(mc, map[int]int{16: 32})
+	want := map[int]int{1: 2, 2: 4, 4: 8, 8: 16, 16: 32}
+	if !_Equal(mc, want) {
+		panic(fmt.Sprintf("_Add result = %v, want %v", mc, want))
+	}
+}
+
+func TestSub() {
+	mc := _Copy(m1)
+	_Sub(mc, mc)
+	if len(mc) > 0 {
+		panic(fmt.Sprintf("_Sub(%v, %v) = %v, want empty map", m1, m1, mc))
+	}
+	mc = _Copy(m1)
+	_Sub(mc, map[int]int{1: 0})
+	want := map[int]int{2: 4, 4: 8, 8: 16}
+	if !_Equal(mc, want) {
+		panic(fmt.Sprintf("_Sub result = %v, want %v", mc, want))
+	}
+}
+
+func TestIntersect() {
+	mc := _Copy(m1)
+	_Intersect(mc, mc)
+	if !_Equal(mc, m1) {
+		panic(fmt.Sprintf("_Intersect(%v, %v) = %v, want %v", m1, m1, mc, m1))
+	}
+	_Intersect(mc, map[int]int{1: 0, 2: 0})
+	want := map[int]int{1: 2, 2: 4}
+	if !_Equal(mc, want) {
+		panic(fmt.Sprintf("_Intersect result = %v, want %v", mc, want))
+	}
+}
+
+func TestFilter() {
+	mc := _Copy(m1)
+	_Filter(mc, func(int, int) bool { return true })
+	if !_Equal(mc, m1) {
+		panic(fmt.Sprintf("_Filter(%v, true) = %v, want %v", m1, mc, m1))
+	}
+	_Filter(mc, func(k, v int) bool { return k < 3 })
+	want := map[int]int{1: 2, 2: 4}
+	if !_Equal(mc, want) {
+		panic(fmt.Sprintf("_Filter result = %v, want %v", mc, want))
+	}
+}
+
+func TestTransformValues() {
+	mc := _Copy(m1)
+	_TransformValues(mc, func(i int) int { return i / 2 })
+	want := map[int]int{1: 1, 2: 2, 4: 4, 8: 8}
+	if !_Equal(mc, want) {
+		panic(fmt.Sprintf("_TransformValues result = %v, want %v", mc, want))
+	}
+}
+
+func main() {
+	TestKeys()
+	TestValues()
+	TestEqual()
+	TestCopy()
+	TestAdd()
+	TestSub()
+	TestIntersect()
+	TestFilter()
+	TestTransformValues()
+}
diff --git a/test/typeparam/sets.go b/test/typeparam/sets.go
new file mode 100644
index 0000000000..258514489e
--- /dev/null
+++ b/test/typeparam/sets.go
@@ -0,0 +1,280 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 (
+	"fmt"
+	"sort"
+)
+
+// _Equal reports whether two slices are equal: the same length and all
+// elements equal. All floating point NaNs are considered equal.
+func _SliceEqual[Elem comparable](s1, s2 []Elem) bool {
+	if len(s1) != len(s2) {
+		return false
+	}
+	for i, v1 := range s1 {
+		v2 := s2[i]
+		if v1 != v2 {
+			isNaN := func(f Elem) bool { return f != f }
+			if !isNaN(v1) || !isNaN(v2) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// A _Set is a set of elements of some type.
+type _Set[Elem comparable] struct {
+	m map[Elem]struct{}
+}
+
+// _Make makes a new set.
+func _Make[Elem comparable]() _Set[Elem] {
+	return _Set[Elem]{m: make(map[Elem]struct{})}
+}
+
+// Add adds an element to a set.
+func (s _Set[Elem]) Add(v Elem) {
+	s.m[v] = struct{}{}
+}
+
+// Delete removes an element from a set. If the element is not present
+// in the set, this does nothing.
+func (s _Set[Elem]) Delete(v Elem) {
+	delete(s.m, v)
+}
+
+// Contains reports whether v is in the set.
+func (s _Set[Elem]) Contains(v Elem) bool {
+	_, ok := s.m[v]
+	return ok
+}
+
+// Len returns the number of elements in the set.
+func (s _Set[Elem]) Len() int {
+	return len(s.m)
+}
+
+// Values returns the values in the set.
+// The values will be in an indeterminate order.
+func (s _Set[Elem]) Values() []Elem {
+	r := make([]Elem, 0, len(s.m))
+	for v := range s.m {
+		r = append(r, v)
+	}
+	return r
+}
+
+// _Equal reports whether two sets contain the same elements.
+func _Equal[Elem comparable](s1, s2 _Set[Elem]) bool {
+	if len(s1.m) != len(s2.m) {
+		return false
+	}
+	for v1 := range s1.m {
+		if !s2.Contains(v1) {
+			return false
+		}
+	}
+	return true
+}
+
+// Copy returns a copy of s.
+func (s _Set[Elem]) Copy() _Set[Elem] {
+	r := _Set[Elem]{m: make(map[Elem]struct{}, len(s.m))}
+	for v := range s.m {
+		r.m[v] = struct{}{}
+	}
+	return r
+}
+
+// AddSet adds all the elements of s2 to s.
+func (s _Set[Elem]) AddSet(s2 _Set[Elem]) {
+	for v := range s2.m {
+		s.m[v] = struct{}{}
+	}
+}
+
+// SubSet removes all elements in s2 from s.
+// Values in s2 that are not in s are ignored.
+func (s _Set[Elem]) SubSet(s2 _Set[Elem]) {
+	for v := range s2.m {
+		delete(s.m, v)
+	}
+}
+
+// Intersect removes all elements from s that are not present in s2.
+// Values in s2 that are not in s are ignored.
+func (s _Set[Elem]) Intersect(s2 _Set[Elem]) {
+	for v := range s.m {
+		if !s2.Contains(v) {
+			delete(s.m, v)
+		}
+	}
+}
+
+// Iterate calls f on every element in the set.
+func (s _Set[Elem]) Iterate(f func(Elem)) {
+	for v := range s.m {
+		f(v)
+	}
+}
+
+// Filter deletes any elements from s for which f returns false.
+func (s _Set[Elem]) Filter(f func(Elem) bool) {
+	for v := range s.m {
+		if !f(v) {
+			delete(s.m, v)
+		}
+	}
+}
+
+func TestSet() {
+	s1 := _Make[int]()
+	if got := s1.Len(); got != 0 {
+		panic(fmt.Sprintf("Len of empty set = %d, want 0", got))
+	}
+	s1.Add(1)
+	s1.Add(1)
+	s1.Add(1)
+	if got := s1.Len(); got != 1 {
+		panic(fmt.Sprintf("(%v).Len() == %d, want 1", s1, got))
+	}
+	s1.Add(2)
+	s1.Add(3)
+	s1.Add(4)
+	if got := s1.Len(); got != 4 {
+		panic(fmt.Sprintf("(%v).Len() == %d, want 4", s1, got))
+	}
+	if !s1.Contains(1) {
+		panic(fmt.Sprintf("(%v).Contains(1) == false, want true", s1))
+	}
+	if s1.Contains(5) {
+		panic(fmt.Sprintf("(%v).Contains(5) == true, want false", s1))
+	}
+	vals := s1.Values()
+	sort.Ints(vals)
+	w1 := []int{1, 2, 3, 4}
+	if !_SliceEqual(vals,  w1) {
+		panic(fmt.Sprintf("(%v).Values() == %v, want %v", s1, vals, w1))
+	}
+}
+
+func TestEqual() {
+	s1 := _Make[string]()
+	s2 := _Make[string]()
+	if !_Equal(s1, s2) {
+		panic(fmt.Sprintf("_Equal(%v, %v) = false, want true", s1, s2))
+	}
+	s1.Add("hello")
+	s1.Add("world")
+	if got := s1.Len(); got != 2 {
+		panic(fmt.Sprintf("(%v).Len() == %d, want 2", s1, got))
+	}
+	if _Equal(s1, s2) {
+		panic(fmt.Sprintf("_Equal(%v, %v) = true, want false", s1, s2))
+	}
+}
+
+func TestCopy() {
+	s1 := _Make[float64]()
+	s1.Add(0)
+	s2 := s1.Copy()
+	if !_Equal(s1, s2) {
+		panic(fmt.Sprintf("_Equal(%v, %v) = false, want true", s1, s2))
+	}
+	s1.Add(1)
+	if _Equal(s1, s2) {
+		panic(fmt.Sprintf("_Equal(%v, %v) = true, want false", s1, s2))
+	}
+}
+
+func TestAddSet() {
+	s1 := _Make[int]()
+	s1.Add(1)
+	s1.Add(2)
+	s2 := _Make[int]()
+	s2.Add(2)
+	s2.Add(3)
+	s1.AddSet(s2)
+	if got := s1.Len(); got != 3 {
+		panic(fmt.Sprintf("(%v).Len() == %d, want 3", s1, got))
+	}
+	s2.Add(1)
+	if !_Equal(s1, s2) {
+		panic(fmt.Sprintf("_Equal(%v, %v) = false, want true", s1, s2))
+	}
+}
+
+func TestSubSet() {
+	s1 := _Make[int]()
+	s1.Add(1)
+	s1.Add(2)
+	s2 := _Make[int]()
+	s2.Add(2)
+	s2.Add(3)
+	s1.SubSet(s2)
+	if got := s1.Len(); got != 1 {
+		panic(fmt.Sprintf("(%v).Len() == %d, want 1", s1, got))
+	}
+	if vals, want := s1.Values(), []int{1}; !_SliceEqual(vals, want) {
+		panic(fmt.Sprintf("after SubSet got %v, want %v", vals, want))
+	}
+}
+
+func TestIntersect() {
+	s1 := _Make[int]()
+	s1.Add(1)
+	s1.Add(2)
+	s2 := _Make[int]()
+	s2.Add(2)
+	s2.Add(3)
+	s1.Intersect(s2)
+	if got := s1.Len(); got != 1 {
+		panic(fmt.Sprintf("(%v).Len() == %d, want 1", s1, got))
+	}
+	if vals, want := s1.Values(), []int{2}; !_SliceEqual(vals, want) {
+		panic(fmt.Sprintf("after Intersect got %v, want %v", vals, want))
+	}
+}
+
+func TestIterate() {
+	s1 := _Make[int]()
+	s1.Add(1)
+	s1.Add(2)
+	s1.Add(3)
+	s1.Add(4)
+	tot := 0
+	s1.Iterate(func(i int) { tot += i })
+	if tot != 10 {
+		panic(fmt.Sprintf("total of %v == %d, want 10", s1, tot))
+	}
+}
+
+func TestFilter() {
+	s1 := _Make[int]()
+	s1.Add(1)
+	s1.Add(2)
+	s1.Add(3)
+	s1.Filter(func(v int) bool { return v%2 == 0 })
+	if vals, want := s1.Values(), []int{2}; !_SliceEqual(vals, want) {
+		panic(fmt.Sprintf("after Filter got %v, want %v", vals, want))
+	}
+
+}
+
+func main() {
+	TestSet()
+	TestEqual()
+	TestCopy()
+	TestAddSet()
+	TestSubSet()
+	TestIntersect()
+	TestIterate()
+	TestFilter()
+}
-- 
GitLab


From 96aecdcb36ad5240a9858f7f7d77ace30f2deaaa Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Sun, 14 Mar 2021 13:46:23 -0700
Subject: [PATCH 1093/2400] cmd/compile: fix case where func-valued field of a
 generic type is called

Added test example orderedmap.go (binary search tree) that requires this
fix (calling function compare in _Map).

Also added new tests slices.go and metrics.go that just work.

Change-Id: Ifa5f42ab6eee9aa54c40f0eca19e00a87f8f608a
Reviewed-on: https://go-review.googlesource.com/c/go/+/301829
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/stencil.go |   7 +
 test/typeparam/metrics.go                 | 196 +++++++++++++
 test/typeparam/orderedmap.go              | 286 +++++++++++++++++++
 test/typeparam/slices.go                  | 318 ++++++++++++++++++++++
 4 files changed, 807 insertions(+)
 create mode 100644 test/typeparam/metrics.go
 create mode 100644 test/typeparam/orderedmap.go
 create mode 100644 test/typeparam/slices.go

diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 78c7ddeabe..64b3a942e2 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -389,6 +389,13 @@ func (subst *subster) node(n ir.Node) ir.Node {
 				typecheck.Callee(call.X)
 				call.SetTypecheck(0)
 				typecheck.Call(call)
+			} else if call.X.Op() == ir.ODOT || call.X.Op() == ir.ODOTPTR {
+				// An OXDOT for a generic receiver was resolved to
+				// an access to a field which has a function
+				// value. Typecheck the call to that function, now
+				// that the OXDOT was resolved.
+				call.SetTypecheck(0)
+				typecheck.Call(call)
 			} else if call.X.Op() != ir.OFUNCINST {
 				// A call with an OFUNCINST will get typechecked
 				// in stencil() once we have created & attached the
diff --git a/test/typeparam/metrics.go b/test/typeparam/metrics.go
new file mode 100644
index 0000000000..8a39d9945d
--- /dev/null
+++ b/test/typeparam/metrics.go
@@ -0,0 +1,196 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 metrics provides tracking arbitrary metrics composed of
+// values of comparable types.
+package main
+
+import (
+	"fmt"
+	"sort"
+	"sync"
+)
+
+// _Metric1 tracks metrics of values of some type.
+type _Metric1[T comparable] struct {
+	mu sync.Mutex
+	m  map[T]int
+}
+
+// Add adds another instance of some value.
+func (m *_Metric1[T]) Add(v T) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.m == nil {
+		m.m = make(map[T]int)
+	}
+	m.m[v]++
+}
+
+// Count returns the number of instances we've seen of v.
+func (m *_Metric1[T]) Count(v T) int {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	return m.m[v]
+}
+
+// Metrics returns all the values we've seen, in an indeterminate order.
+func (m *_Metric1[T]) Metrics() []T {
+	return _Keys(m.m)
+}
+
+type key2[T1, T2 comparable] struct {
+	f1 T1
+	f2 T2
+}
+
+// _Metric2 tracks metrics of pairs of values.
+type _Metric2[T1, T2 comparable] struct {
+	mu sync.Mutex
+	m  map[key2[T1, T2]]int
+}
+
+// Add adds another instance of some pair of values.
+func (m *_Metric2[T1, T2]) Add(v1 T1, v2 T2) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.m == nil {
+		m.m = make(map[key2[T1, T2]]int)
+	}
+	m.m[key2[T1, T2]{v1, v2}]++
+}
+
+// Count returns the number of instances we've seen of v1/v2.
+func (m *_Metric2[T1, T2]) Count(v1 T1, v2 T2) int {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	return m.m[key2[T1, T2]{v1, v2}]
+}
+
+// Metrics returns all the values we've seen, in an indeterminate order.
+func (m *_Metric2[T1, T2]) Metrics() (r1 []T1, r2 []T2) {
+	for _, k := range _Keys(m.m) {
+		r1 = append(r1, k.f1)
+		r2 = append(r2, k.f2)
+	}
+	return r1, r2
+}
+
+type key3[T1, T2, T3 comparable] struct {
+	f1 T1
+	f2 T2
+	f3 T3
+}
+
+// _Metric3 tracks metrics of triplets of values.
+type _Metric3[T1, T2, T3 comparable] struct {
+	mu sync.Mutex
+	m  map[key3[T1, T2, T3]]int
+}
+
+// Add adds another instance of some triplet of values.
+func (m *_Metric3[T1, T2, T3]) Add(v1 T1, v2 T2, v3 T3) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.m == nil {
+		m.m = make(map[key3[T1, T2, T3]]int)
+	}
+	m.m[key3[T1, T2, T3]{v1, v2, v3}]++
+}
+
+// Count returns the number of instances we've seen of v1/v2/v3.
+func (m *_Metric3[T1, T2, T3]) Count(v1 T1, v2 T2, v3 T3) int {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	return m.m[key3[T1, T2, T3]{v1, v2, v3}]
+}
+
+// Metrics returns all the values we've seen, in an indeterminate order.
+func (m *_Metric3[T1, T2, T3]) Metrics() (r1 []T1, r2 []T2, r3 []T3) {
+	for k := range m.m {
+		r1 = append(r1, k.f1)
+		r2 = append(r2, k.f2)
+		r3 = append(r3, k.f3)
+	}
+	return r1, r2, r3
+}
+
+type S struct{ a, b, c string }
+
+func TestMetrics() {
+	m1 := _Metric1[string]{}
+	if got := m1.Count("a"); got != 0 {
+		panic(fmt.Sprintf("Count(%q) = %d, want 0", "a", got))
+	}
+	m1.Add("a")
+	m1.Add("a")
+	if got := m1.Count("a"); got != 2 {
+		panic(fmt.Sprintf("Count(%q) = %d, want 2", "a", got))
+	}
+	if got, want := m1.Metrics(), []string{"a"}; !_SlicesEqual(got, want) {
+		panic(fmt.Sprintf("Metrics = %v, want %v", got, want))
+	}
+
+	m2 := _Metric2[int, float64]{}
+	m2.Add(1, 1)
+	m2.Add(2, 2)
+	m2.Add(3, 3)
+	m2.Add(3, 3)
+	k1, k2 := m2.Metrics()
+
+	sort.Ints(k1)
+	w1 := []int{1, 2, 3}
+	if !_SlicesEqual(k1, w1) {
+		panic(fmt.Sprintf("_Metric2.Metrics first slice = %v, want %v", k1, w1))
+	}
+
+	sort.Float64s(k2)
+	w2 := []float64{1, 2, 3}
+	if !_SlicesEqual(k2, w2) {
+		panic(fmt.Sprintf("_Metric2.Metrics first slice = %v, want %v", k2, w2))
+	}
+
+	m3 := _Metric3[string, S, S]{}
+	m3.Add("a", S{"d", "e", "f"}, S{"g", "h", "i"})
+	m3.Add("a", S{"d", "e", "f"}, S{"g", "h", "i"})
+	m3.Add("a", S{"d", "e", "f"}, S{"g", "h", "i"})
+	m3.Add("b", S{"d", "e", "f"}, S{"g", "h", "i"})
+	if got := m3.Count("a", S{"d", "e", "f"}, S{"g", "h", "i"}); got != 3 {
+		panic(fmt.Sprintf("Count(%v, %v, %v) = %d, want 3", "a", S{"d", "e", "f"}, S{"g", "h", "i"}, got))
+	}
+}
+
+func main() {
+	TestMetrics()
+}
+
+// _Equal reports whether two slices are equal: the same length and all
+// elements equal. All floating point NaNs are considered equal.
+func _SlicesEqual[Elem comparable](s1, s2 []Elem) bool {
+	if len(s1) != len(s2) {
+		return false
+	}
+	for i, v1 := range s1 {
+		v2 := s2[i]
+		if v1 != v2 {
+			isNaN := func(f Elem) bool { return f != f }
+			if !isNaN(v1) || !isNaN(v2) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// _Keys returns the keys of the map m.
+// The keys will be an indeterminate order.
+func _Keys[K comparable, V any](m map[K]V) []K {
+	r := make([]K, 0, len(m))
+	for k := range m {
+		r = append(r, k)
+	}
+	return r
+}
diff --git a/test/typeparam/orderedmap.go b/test/typeparam/orderedmap.go
new file mode 100644
index 0000000000..db1b374267
--- /dev/null
+++ b/test/typeparam/orderedmap.go
@@ -0,0 +1,286 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 orderedmap provides an ordered map, implemented as a binary tree.
+package main
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"runtime"
+)
+
+type Ordered interface {
+        type int, int8, int16, int32, int64,
+                uint, uint8, uint16, uint32, uint64, uintptr,
+                float32, float64,
+                string
+}
+
+// _Map is an ordered map.
+type _Map[K, V any] struct {
+	root    *node[K, V]
+	compare func(K, K) int
+}
+
+// node is the type of a node in the binary tree.
+type node[K, V any] struct {
+	key         K
+	val         V
+	left, right *node[K, V]
+}
+
+// _New returns a new map. It takes a comparison function that compares two
+// keys and returns < 0 if the first is less, == 0 if they are equal,
+// > 0 if the first is greater.
+func _New[K, V any](compare func(K, K) int) *_Map[K, V] {
+	return &_Map[K, V]{compare: compare}
+}
+
+// _NewOrdered returns a new map whose key is an ordered type.
+// This is like _New, but does not require providing a compare function.
+// The map compare function uses the obvious key ordering.
+func _NewOrdered[K Ordered, V any]() *_Map[K, V] {
+	return _New[K, V](func(k1, k2 K) int {
+		switch {
+		case k1 < k2:
+			return -1
+		case k1 == k2:
+			return 0
+		default:
+			return 1
+		}
+	})
+}
+
+// find looks up key in the map, returning either a pointer to the slot of the
+// node holding key, or a pointer to the slot where should a node would go.
+func (m *_Map[K, V]) find(key K) **node[K, V] {
+	pn := &m.root
+	for *pn != nil {
+		switch cmp := m.compare(key, (*pn).key); {
+		case cmp < 0:
+			pn = &(*pn).left
+		case cmp > 0:
+			pn = &(*pn).right
+		default:
+			return pn
+		}
+	}
+	return pn
+}
+
+// Insert inserts a new key/value into the map.
+// If the key is already present, the value is replaced.
+// Reports whether this is a new key.
+func (m *_Map[K, V]) Insert(key K, val V) bool {
+	pn := m.find(key)
+	if *pn != nil {
+		(*pn).val = val
+		return false
+	}
+	*pn = &node[K, V]{key: key, val: val}
+	return true
+}
+
+// Find returns the value associated with a key, or the zero value
+// if not present. The found result reports whether the key was found.
+func (m *_Map[K, V]) Find(key K) (V, bool) {
+	pn := m.find(key)
+	if *pn == nil {
+		var zero V
+		return zero, false
+	}
+	return (*pn).val, true
+}
+
+// keyValue is a pair of key and value used while iterating.
+type keyValue[K, V any] struct {
+	key K
+	val V
+}
+
+// iterate returns an iterator that traverses the map.
+func (m *_Map[K, V]) Iterate() *_Iterator[K, V] {
+	sender, receiver := _Ranger[keyValue[K, V]]()
+	var f func(*node[K, V]) bool
+	f = func(n *node[K, V]) bool {
+		if n == nil {
+			return true
+		}
+		// Stop the traversal if Send fails, which means that
+		// nothing is listening to the receiver.
+		return f(n.left) &&
+			sender.Send(context.Background(), keyValue[K, V]{n.key, n.val}) &&
+			f(n.right)
+	}
+	go func() {
+		f(m.root)
+		sender.Close()
+	}()
+	return &_Iterator[K, V]{receiver}
+}
+
+// _Iterator is used to iterate over the map.
+type _Iterator[K, V any] struct {
+	r *_Receiver[keyValue[K, V]]
+}
+
+// Next returns the next key and value pair, and a boolean that reports
+// whether they are valid. If not valid, we have reached the end of the map.
+func (it *_Iterator[K, V]) Next() (K, V, bool) {
+	keyval, ok := it.r.Next(context.Background())
+	if !ok {
+		var zerok K
+		var zerov V
+		return zerok, zerov, false
+	}
+	return keyval.key, keyval.val, true
+}
+
+func TestMap() {
+	m := _New[[]byte, int](bytes.Compare)
+
+	if _, found := m.Find([]byte("a")); found {
+		panic(fmt.Sprintf("unexpectedly found %q in empty map", []byte("a")))
+	}
+	if !m.Insert([]byte("a"), 'a') {
+		panic(fmt.Sprintf("key %q unexpectedly already present", []byte("a")))
+	}
+	if !m.Insert([]byte("c"), 'c') {
+		panic(fmt.Sprintf("key %q unexpectedly already present", []byte("c")))
+	}
+	if !m.Insert([]byte("b"), 'b') {
+		panic(fmt.Sprintf("key %q unexpectedly already present", []byte("b")))
+	}
+	if m.Insert([]byte("c"), 'x') {
+		panic(fmt.Sprintf("key %q unexpectedly not present", []byte("c")))
+	}
+
+	if v, found := m.Find([]byte("a")); !found {
+		panic(fmt.Sprintf("did not find %q", []byte("a")))
+	} else if v != 'a' {
+		panic(fmt.Sprintf("key %q returned wrong value %c, expected %c", []byte("a"), v, 'a'))
+	}
+	if v, found := m.Find([]byte("c")); !found {
+		panic(fmt.Sprintf("did not find %q", []byte("c")))
+	} else if v != 'x' {
+		panic(fmt.Sprintf("key %q returned wrong value %c, expected %c", []byte("c"), v, 'x'))
+	}
+
+	if _, found := m.Find([]byte("d")); found {
+		panic(fmt.Sprintf("unexpectedly found %q", []byte("d")))
+	}
+
+	gather := func(it *_Iterator[[]byte, int]) []int {
+		var r []int
+		for {
+			_, v, ok := it.Next()
+			if !ok {
+				return r
+			}
+			r = append(r, v)
+		}
+	}
+	got := gather(m.Iterate())
+	want := []int{'a', 'b', 'x'}
+	if !_SliceEqual(got, want) {
+		panic(fmt.Sprintf("Iterate returned %v, want %v", got, want))
+	}
+}
+
+func main() {
+	TestMap()
+}
+
+// _Equal reports whether two slices are equal: the same length and all
+// elements equal. All floating point NaNs are considered equal.
+func _SliceEqual[Elem comparable](s1, s2 []Elem) bool {
+	if len(s1) != len(s2) {
+		return false
+	}
+	for i, v1 := range s1 {
+		v2 := s2[i]
+		if v1 != v2 {
+			isNaN := func(f Elem) bool { return f != f }
+			if !isNaN(v1) || !isNaN(v2) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// Ranger returns a Sender and a Receiver. The Receiver provides a
+// Next method to retrieve values. The Sender provides a Send method
+// to send values and a Close method to stop sending values. The Next
+// method indicates when the Sender has been closed, and the Send
+// method indicates when the Receiver has been freed.
+//
+// This is a convenient way to exit a goroutine sending values when
+// the receiver stops reading them.
+func _Ranger[Elem any]() (*_Sender[Elem], *_Receiver[Elem]) {
+	c := make(chan Elem)
+	d := make(chan struct{})
+	s := &_Sender[Elem]{
+		values: c,
+		done:   d,
+	}
+	r := &_Receiver[Elem] {
+		values: c,
+		done:   d,
+	}
+	runtime.SetFinalizer(r, (*_Receiver[Elem]).finalize)
+	return s, r
+}
+
+// A _Sender is used to send values to a Receiver.
+type _Sender[Elem any] struct {
+	values chan<- Elem
+	done   <-chan struct{}
+}
+
+// Send sends a value to the receiver. It reports whether the value was sent.
+// The value will not be sent if the context is closed or the receiver
+// is freed.
+func (s *_Sender[Elem]) Send(ctx context.Context, v Elem) bool {
+	select {
+	case <-ctx.Done():
+		return false
+	case s.values <- v:
+		return true
+	case <-s.done:
+		return false
+	}
+}
+
+// Close tells the receiver that no more values will arrive.
+// After Close is called, the _Sender may no longer be used.
+func (s *_Sender[Elem]) Close() {
+	close(s.values)
+}
+
+// A _Receiver receives values from a _Sender.
+type _Receiver[Elem any] struct {
+	values <-chan Elem
+	done   chan<- struct{}
+}
+
+// Next returns the next value from the channel. The bool result indicates
+// whether the value is valid.
+func (r *_Receiver[Elem]) Next(ctx context.Context) (v Elem, ok bool) {
+	select {
+	case <-ctx.Done():
+	case v, ok = <-r.values:
+	}
+	return v, ok
+}
+
+// finalize is a finalizer for the receiver.
+func (r *_Receiver[Elem]) finalize() {
+	close(r.done)
+}
diff --git a/test/typeparam/slices.go b/test/typeparam/slices.go
new file mode 100644
index 0000000000..149199eb64
--- /dev/null
+++ b/test/typeparam/slices.go
@@ -0,0 +1,318 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 slices provides functions for basic operations on
+// slices of any element type.
+package main
+
+import (
+	"fmt"
+	"math"
+	"strings"
+)
+
+type Ordered interface {
+        type int, int8, int16, int32, int64,
+                uint, uint8, uint16, uint32, uint64, uintptr,
+                float32, float64,
+                string
+}
+
+type Integer interface {
+        type int, int8, int16, int32, int64,
+                uint, uint8, uint16, uint32, uint64, uintptr
+}
+
+// Max returns the maximum of two values of some ordered type.
+func _Max[T Ordered](a, b T) T {
+        if a > b {
+                return a
+        }
+        return b
+}
+
+// Min returns the minimum of two values of some ordered type.
+func _Min[T Ordered](a, b T) T {
+        if a < b {
+                return a
+        }
+        return b
+}
+
+// _Equal reports whether two slices are equal: the same length and all
+// elements equal. All floating point NaNs are considered equal.
+func _Equal[Elem comparable](s1, s2 []Elem) bool {
+	if len(s1) != len(s2) {
+		return false
+	}
+	for i, v1 := range s1 {
+		v2 := s2[i]
+		if v1 != v2 {
+			isNaN := func(f Elem) bool { return f != f }
+			if !isNaN(v1) || !isNaN(v2) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// _EqualFn reports whether two slices are equal using a comparision
+// function on each element.
+func _EqualFn[Elem any](s1, s2 []Elem, eq func(Elem, Elem) bool) bool {
+	if len(s1) != len(s2) {
+		return false
+	}
+	for i, v1 := range s1 {
+		v2 := s2[i]
+		if !eq(v1, v2) {
+			return false
+		}
+	}
+	return true
+}
+
+// _Map turns a []Elem1 to a []Elem2 using a mapping function.
+func _Map[Elem1, Elem2 any](s []Elem1, f func(Elem1) Elem2) []Elem2 {
+	r := make([]Elem2, len(s))
+	for i, v := range s {
+		r[i] = f(v)
+	}
+	return r
+}
+
+// _Reduce reduces a []Elem1 to a single value of type Elem2 using
+// a reduction function.
+func _Reduce[Elem1, Elem2 any](s []Elem1, initializer Elem2, f func(Elem2, Elem1) Elem2) Elem2 {
+	r := initializer
+	for _, v := range s {
+		r = f(r, v)
+	}
+	return r
+}
+
+// _Filter filters values from a slice using a filter function.
+func _Filter[Elem any](s []Elem, f func(Elem) bool) []Elem {
+	var r []Elem
+	for _, v := range s {
+		if f(v) {
+			r = append(r, v)
+		}
+	}
+	return r
+}
+
+// _Max returns the maximum element in a slice of some ordered type.
+// If the slice is empty it returns the zero value of the element type.
+func _SliceMax[Elem Ordered](s []Elem) Elem {
+	if len(s) == 0 {
+		var zero Elem
+		return zero
+	}
+	return _Reduce(s[1:], s[0], _Max[Elem])
+}
+
+// _Min returns the minimum element in a slice of some ordered type.
+// If the slice is empty it returns the zero value of the element type.
+func _SliceMin[Elem Ordered](s []Elem) Elem {
+	if len(s) == 0 {
+		var zero Elem
+		return zero
+	}
+	return _Reduce(s[1:], s[0], _Min[Elem])
+}
+
+// _Append adds values to the end of a slice, returning a new slice.
+// This is like the predeclared append function; it's an example
+// of how to write it using generics. We used to write code like
+// this before append was added to the language, but we had to write
+// a separate copy for each type.
+func _Append[T any](s []T, t ...T) []T {
+	lens := len(s)
+	tot := lens + len(t)
+	if tot <= cap(s) {
+		s = s[:tot]
+	} else {
+		news := make([]T, tot, tot + tot/2)
+		_Copy(news, s)
+		s = news
+	}
+	_Copy(s[lens:tot], t)
+	return s
+}
+
+// _Copy copies values from t to s, stopping when either slice is full,
+// returning the number of values copied. This is like the predeclared
+// copy function; it's an example of how to write it using generics.
+func _Copy[T any](s, t []T) int {
+	i := 0
+	for ; i < len(s) && i < len(t); i++ {
+		s[i] = t[i]
+	}
+	return i
+}
+
+func TestEqual() {
+        s1 := []int{1, 2, 3}
+        if !_Equal(s1, s1) {
+                panic(fmt.Sprintf("_Equal(%v, %v) = false, want true", s1, s1))
+        }
+        s2 := []int{1, 2, 3}
+        if !_Equal(s1, s2) {
+                panic(fmt.Sprintf("_Equal(%v, %v) = false, want true", s1, s2))
+        }
+        s2 = append(s2, 4)
+        if _Equal(s1, s2) {
+                panic(fmt.Sprintf("_Equal(%v, %v) = true, want false", s1, s2))
+        }
+
+        s3 := []float64{1, 2, math.NaN()}
+        if !_Equal(s3, s3) {
+                panic(fmt.Sprintf("_Equal(%v, %v) = false, want true", s3, s3))
+        }
+
+        if _Equal(s1, nil) {
+                panic(fmt.Sprintf("_Equal(%v, nil) = true, want false", s1))
+        }
+        if _Equal(nil, s1) {
+                panic(fmt.Sprintf("_Equal(nil, %v) = true, want false", s1))
+        }
+        if !_Equal(s1[:0], nil) {
+                panic(fmt.Sprintf("_Equal(%v, nil = false, want true", s1[:0]))
+        }
+}
+
+func offByOne[Elem Integer](a, b Elem) bool {
+	return a == b + 1 || a == b - 1
+}
+
+func TestEqualFn() {
+	s1 := []int{1, 2, 3}
+	s2 := []int{2, 3, 4}
+	if _EqualFn(s1, s1, offByOne[int]) {
+		panic(fmt.Sprintf("_EqualFn(%v, %v, offByOne) = true, want false", s1, s1))
+	}
+	if !_EqualFn(s1, s2, offByOne[int]) {
+		panic(fmt.Sprintf("_EqualFn(%v, %v, offByOne) = false, want true", s1, s2))
+	}
+
+	if !_EqualFn(s1[:0], nil, offByOne[int]) {
+		panic(fmt.Sprintf("_EqualFn(%v, nil, offByOne) = false, want true", s1[:0]))
+	}
+
+	s3 := []string{"a", "b", "c"}
+	s4 := []string{"A", "B", "C"}
+	if !_EqualFn(s3, s4, strings.EqualFold) {
+		panic(fmt.Sprintf("_EqualFn(%v, %v, strings.EqualFold) = false, want true", s3, s4))
+	}
+}
+
+func TestMap() {
+	s1 := []int{1, 2, 3}
+	s2 := _Map(s1, func(i int) float64 { return float64(i) * 2.5 })
+	if want := []float64{2.5, 5, 7.5}; !_Equal(s2, want) {
+		panic(fmt.Sprintf("_Map(%v, ...) = %v, want %v", s1, s2, want))
+	}
+
+	s3 := []string{"Hello", "World"}
+	s4 := _Map(s3, strings.ToLower)
+	if want := []string{"hello", "world"}; !_Equal(s4, want) {
+		panic(fmt.Sprintf("_Map(%v, strings.ToLower) = %v, want %v", s3, s4, want))
+	}
+
+	s5 := _Map(nil, func(i int) int { return i })
+	if len(s5) != 0 {
+		panic(fmt.Sprintf("_Map(nil, identity) = %v, want empty slice", s5))
+	}
+}
+
+func TestReduce() {
+	s1 := []int{1, 2, 3}
+	r := _Reduce(s1, 0, func(f float64, i int) float64 { return float64(i) * 2.5 + f })
+	if want := 15.0; r != want {
+		panic(fmt.Sprintf("_Reduce(%v, 0, ...) = %v, want %v", s1, r, want))
+	}
+
+	if got := _Reduce(nil, 0, func(i, j int) int { return i + j}); got != 0 {
+		panic(fmt.Sprintf("_Reduce(nil, 0, add) = %v, want 0", got))
+	}
+}
+
+func TestFilter() {
+	s1 := []int{1, 2, 3}
+	s2 := _Filter(s1, func(i int) bool { return i%2 == 0 })
+	if want := []int{2}; !_Equal(s2, want) {
+		panic(fmt.Sprintf("_Filter(%v, even) = %v, want %v", s1, s2, want))
+	}
+
+	if s3 := _Filter(s1[:0], func(i int) bool { return true }); len(s3) > 0 {
+		panic(fmt.Sprintf("_Filter(%v, identity) = %v, want empty slice", s1[:0], s3))
+	}
+}
+
+func TestMax() {
+	s1 := []int{1, 2, 3, -5}
+	if got, want := _SliceMax(s1), 3; got != want {
+		panic(fmt.Sprintf("_Max(%v) = %d, want %d", s1, got, want))
+	}
+
+	s2 := []string{"aaa", "a", "aa", "aaaa"}
+	if got, want := _SliceMax(s2), "aaaa"; got != want {
+		panic(fmt.Sprintf("_Max(%v) = %q, want %q", s2, got, want))
+	}
+
+	if got, want := _SliceMax(s2[:0]), ""; got != want {
+		panic(fmt.Sprintf("_Max(%v) = %q, want %q", s2[:0], got, want))
+	}
+}
+
+func TestMin() {
+	s1 := []int{1, 2, 3, -5}
+	if got, want := _SliceMin(s1), -5; got != want {
+		panic(fmt.Sprintf("_Min(%v) = %d, want %d", s1, got, want))
+	}
+
+	s2 := []string{"aaa", "a", "aa", "aaaa"}
+	if got, want := _SliceMin(s2), "a"; got != want {
+		panic(fmt.Sprintf("_Min(%v) = %q, want %q", s2, got, want))
+	}
+
+	if got, want := _SliceMin(s2[:0]), ""; got != want {
+		panic(fmt.Sprintf("_Min(%v) = %q, want %q", s2[:0], got, want))
+	}
+}
+
+func TestAppend() {
+	s := []int{1, 2, 3}
+	s = _Append(s, 4, 5, 6)
+	want := []int{1, 2, 3, 4, 5, 6}
+	if !_Equal(s, want) {
+		panic(fmt.Sprintf("after _Append got %v, want %v", s, want))
+	}
+}
+
+func TestCopy() {
+	s1 := []int{1, 2, 3}
+	s2 := []int{4, 5}
+	if got := _Copy(s1, s2); got != 2 {
+		panic(fmt.Sprintf("_Copy returned %d, want 2", got))
+	}
+	want := []int{4, 5, 3}
+	if !_Equal(s1, want) {
+		panic(fmt.Sprintf("after _Copy got %v, want %v", s1, want))
+	}
+}
+func main() {
+	TestEqual()
+	TestEqualFn()
+	TestMap()
+	TestReduce()
+	TestFilter()
+	TestMax()
+	TestMin()
+	TestAppend()
+	TestCopy()
+}
-- 
GitLab


From 8ed438c077d82c4b4662c327dbbdb3c64e7547ca Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Wed, 10 Mar 2021 20:54:11 -0500
Subject: [PATCH 1094/2400] cmd/compile: spill output parameters passed in
 registers as autos

ALSO:
found evidence that stack maps for bodyless methods are wrong.
gofmt in test/abi
removed never-executed code in types/size.go

Updates #44816.

Change-Id: I658c33f049337fb6f1e625f0c55430d25bfa877e
Reviewed-on: https://go-review.googlesource.com/c/go/+/300749
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/abi/abiutils.go      | 31 ++++++--
 src/cmd/compile/internal/dwarfgen/dwarf.go    | 10 ++-
 src/cmd/compile/internal/gc/compile.go        |  2 +-
 src/cmd/compile/internal/ir/name.go           | 75 ++++++++++---------
 src/cmd/compile/internal/liveness/plive.go    | 19 +++--
 src/cmd/compile/internal/ssa/op.go            | 10 +++
 src/cmd/compile/internal/ssagen/pgen.go       | 18 +++--
 src/cmd/compile/internal/ssagen/ssa.go        | 30 ++++----
 .../compile/internal/test/abiutilsaux_test.go |  2 +-
 src/cmd/compile/internal/types/size.go        | 12 +--
 src/cmd/compile/internal/types/type.go        |  4 +-
 test/abi/fibish2.go                           |  4 +-
 test/abi/leaf.go                              | 36 +++++++++
 test/abi/leaf2.go                             | 43 +++++++++++
 test/abi/methods.go                           | 11 +--
 test/abi/spills3.go                           | 48 ++++++++++++
 test/abi/spills4.go                           | 44 +++++++++++
 17 files changed, 309 insertions(+), 90 deletions(-)
 create mode 100644 test/abi/leaf.go
 create mode 100644 test/abi/leaf2.go
 create mode 100644 test/abi/spills3.go
 create mode 100644 test/abi/spills4.go

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index ecde34313a..e92827fc7f 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -69,6 +69,14 @@ func (a *ABIParamResultInfo) SpillAreaSize() int64 {
 	return a.spillAreaSize
 }
 
+// ArgWidth returns the amount of stack needed for all the inputs
+// and outputs of a function or method, including ABI-defined parameter
+// slots and ABI-defined spill slots for register-resident parameters.
+// The name is inherited from (*Type).ArgWidth(), which it replaces.
+func (a *ABIParamResultInfo) ArgWidth() int64 {
+	return a.spillAreaSize + a.offsetToSpillArea
+}
+
 // RegIndex stores the index into the set of machine registers used by
 // the ABI on a specific architecture for parameter passing.  RegIndex
 // values 0 through N-1 (where N is the number of integer registers
@@ -414,20 +422,25 @@ func (config *ABIConfig) ABIAnalyzeFuncType(ft *types.Func) *ABIParamResultInfo
 
 // ABIAnalyze returns the same result as ABIAnalyzeFuncType, but also
 // updates the offsets of all the receiver, input, and output fields.
-func (config *ABIConfig) ABIAnalyze(t *types.Type) *ABIParamResultInfo {
+// If setNname is true, it also sets the FrameOffset of the Nname for
+// the field(s); this is for use when compiling a function and figuring out
+// spill locations.  Doing this for callers can cause races for register
+// outputs because their frame location transitions from BOGUS_FUNARG_OFFSET
+// to zero to an as-if-AUTO offset that has no use for callers.
+func (config *ABIConfig) ABIAnalyze(t *types.Type, setNname bool) *ABIParamResultInfo {
 	ft := t.FuncType()
 	result := config.ABIAnalyzeFuncType(ft)
 	// Fill in the frame offsets for receiver, inputs, results
 	k := 0
 	if t.NumRecvs() != 0 {
-		config.updateOffset(result, ft.Receiver.FieldSlice()[0], result.inparams[0], false)
+		config.updateOffset(result, ft.Receiver.FieldSlice()[0], result.inparams[0], false, setNname)
 		k++
 	}
 	for i, f := range ft.Params.FieldSlice() {
-		config.updateOffset(result, f, result.inparams[k+i], false)
+		config.updateOffset(result, f, result.inparams[k+i], false, setNname)
 	}
 	for i, f := range ft.Results.FieldSlice() {
-		config.updateOffset(result, f, result.outparams[i], true)
+		config.updateOffset(result, f, result.outparams[i], true, setNname)
 	}
 	return result
 }
@@ -442,7 +455,7 @@ func FieldOffsetOf(f *types.Field) int64 {
 	return f.Offset
 }
 
-func (config *ABIConfig) updateOffset(result *ABIParamResultInfo, f *types.Field, a ABIParamAssignment, isReturn bool) {
+func (config *ABIConfig) updateOffset(result *ABIParamResultInfo, f *types.Field, a ABIParamAssignment, isReturn, setNname bool) {
 	// Everything except return values in registers has either a frame home (if not in a register) or a frame spill location.
 	if !isReturn || len(a.Registers) == 0 {
 		// The type frame offset DOES NOT show effects of minimum frame size.
@@ -455,11 +468,19 @@ func (config *ABIConfig) updateOffset(result *ABIParamResultInfo, f *types.Field
 			// Set the Offset the first time. After that, we may recompute it, but it should never change.
 			f.Offset = off
 			if f.Nname != nil {
+				// always set it in this case.
 				f.Nname.(*ir.Name).SetFrameOffset(off)
+				f.Nname.(*ir.Name).SetIsOutputParamInRegisters(false)
 			}
 		} else if fOffset != off {
 			panic(fmt.Errorf("Offset changed from %d to %d", fOffset, off))
 		}
+	} else {
+		if setNname && f.Nname != nil {
+			fname := f.Nname.(*ir.Name)
+			fname.SetIsOutputParamInRegisters(true)
+			fname.SetFrameOffset(0)
+		}
 	}
 }
 
diff --git a/src/cmd/compile/internal/dwarfgen/dwarf.go b/src/cmd/compile/internal/dwarfgen/dwarf.go
index 70168cffeb..53752097ed 100644
--- a/src/cmd/compile/internal/dwarfgen/dwarf.go
+++ b/src/cmd/compile/internal/dwarfgen/dwarf.go
@@ -265,6 +265,13 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 	var offs int64
 
 	switch n.Class {
+	case ir.PPARAM, ir.PPARAMOUT:
+		if !n.IsOutputParamInRegisters() {
+			abbrev = dwarf.DW_ABRV_PARAM
+			offs = n.FrameOffset() + base.Ctxt.FixedFrameSize()
+			break
+		}
+		fallthrough
 	case ir.PAUTO:
 		offs = n.FrameOffset()
 		abbrev = dwarf.DW_ABRV_AUTO
@@ -275,9 +282,6 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 			offs -= int64(types.PtrSize)
 		}
 
-	case ir.PPARAM, ir.PPARAMOUT:
-		abbrev = dwarf.DW_ABRV_PARAM
-		offs = n.FrameOffset() + base.Ctxt.FixedFrameSize()
 	default:
 		base.Fatalf("createSimpleVar unexpected class %v for node %v", n.Class, n)
 	}
diff --git a/src/cmd/compile/internal/gc/compile.go b/src/cmd/compile/internal/gc/compile.go
index 2d7a74a403..83cfceb2c8 100644
--- a/src/cmd/compile/internal/gc/compile.go
+++ b/src/cmd/compile/internal/gc/compile.go
@@ -45,7 +45,7 @@ func enqueueFunc(fn *ir.Func) {
 		ssagen.InitLSym(fn, false)
 		types.CalcSize(fn.Type()) // TODO register args; remove this once all is done by abiutils
 		a := ssagen.AbiForFunc(fn)
-		a.ABIAnalyze(fn.Type()) // will set parameter spill/home locations correctly
+		a.ABIAnalyze(fn.Type(), true) // will set parameter spill/home locations correctly
 		liveness.WriteFuncMap(fn)
 		return
 	}
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 16c30324e5..5738aa1f3f 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -246,44 +246,47 @@ func (n *Name) Alias() bool { return n.flags&nameAlias != 0 }
 func (n *Name) SetAlias(alias bool) { n.flags.set(nameAlias, alias) }
 
 const (
-	nameReadonly              = 1 << iota
-	nameByval                 // is the variable captured by value or by reference
-	nameNeedzero              // if it contains pointers, needs to be zeroed on function entry
-	nameAutoTemp              // is the variable a temporary (implies no dwarf info. reset if escapes to heap)
-	nameUsed                  // for variable declared and not used error
-	nameIsClosureVar          // PAUTOHEAP closure pseudo-variable; original (if any) at n.Defn
-	nameIsOutputParamHeapAddr // pointer to a result parameter's heap copy
-	nameAddrtaken             // address taken, even if not moved to heap
-	nameInlFormal             // PAUTO created by inliner, derived from callee formal
-	nameInlLocal              // PAUTO created by inliner, derived from callee local
-	nameOpenDeferSlot         // if temporary var storing info for open-coded defers
-	nameLibfuzzerExtraCounter // if PEXTERN should be assigned to __libfuzzer_extra_counters section
-	nameAlias                 // is type name an alias
+	nameReadonly                 = 1 << iota
+	nameByval                    // is the variable captured by value or by reference
+	nameNeedzero                 // if it contains pointers, needs to be zeroed on function entry
+	nameAutoTemp                 // is the variable a temporary (implies no dwarf info. reset if escapes to heap)
+	nameUsed                     // for variable declared and not used error
+	nameIsClosureVar             // PAUTOHEAP closure pseudo-variable; original (if any) at n.Defn
+	nameIsOutputParamHeapAddr    // pointer to a result parameter's heap copy
+	nameIsOutputParamInRegisters // output parameter in registers spills as an auto
+	nameAddrtaken                // address taken, even if not moved to heap
+	nameInlFormal                // PAUTO created by inliner, derived from callee formal
+	nameInlLocal                 // PAUTO created by inliner, derived from callee local
+	nameOpenDeferSlot            // if temporary var storing info for open-coded defers
+	nameLibfuzzerExtraCounter    // if PEXTERN should be assigned to __libfuzzer_extra_counters section
+	nameAlias                    // is type name an alias
 )
 
-func (n *Name) Readonly() bool              { return n.flags&nameReadonly != 0 }
-func (n *Name) Needzero() bool              { return n.flags&nameNeedzero != 0 }
-func (n *Name) AutoTemp() bool              { return n.flags&nameAutoTemp != 0 }
-func (n *Name) Used() bool                  { return n.flags&nameUsed != 0 }
-func (n *Name) IsClosureVar() bool          { return n.flags&nameIsClosureVar != 0 }
-func (n *Name) IsOutputParamHeapAddr() bool { return n.flags&nameIsOutputParamHeapAddr != 0 }
-func (n *Name) Addrtaken() bool             { return n.flags&nameAddrtaken != 0 }
-func (n *Name) InlFormal() bool             { return n.flags&nameInlFormal != 0 }
-func (n *Name) InlLocal() bool              { return n.flags&nameInlLocal != 0 }
-func (n *Name) OpenDeferSlot() bool         { return n.flags&nameOpenDeferSlot != 0 }
-func (n *Name) LibfuzzerExtraCounter() bool { return n.flags&nameLibfuzzerExtraCounter != 0 }
-
-func (n *Name) setReadonly(b bool)              { n.flags.set(nameReadonly, b) }
-func (n *Name) SetNeedzero(b bool)              { n.flags.set(nameNeedzero, b) }
-func (n *Name) SetAutoTemp(b bool)              { n.flags.set(nameAutoTemp, b) }
-func (n *Name) SetUsed(b bool)                  { n.flags.set(nameUsed, b) }
-func (n *Name) SetIsClosureVar(b bool)          { n.flags.set(nameIsClosureVar, b) }
-func (n *Name) SetIsOutputParamHeapAddr(b bool) { n.flags.set(nameIsOutputParamHeapAddr, b) }
-func (n *Name) SetAddrtaken(b bool)             { n.flags.set(nameAddrtaken, b) }
-func (n *Name) SetInlFormal(b bool)             { n.flags.set(nameInlFormal, b) }
-func (n *Name) SetInlLocal(b bool)              { n.flags.set(nameInlLocal, b) }
-func (n *Name) SetOpenDeferSlot(b bool)         { n.flags.set(nameOpenDeferSlot, b) }
-func (n *Name) SetLibfuzzerExtraCounter(b bool) { n.flags.set(nameLibfuzzerExtraCounter, b) }
+func (n *Name) Readonly() bool                 { return n.flags&nameReadonly != 0 }
+func (n *Name) Needzero() bool                 { return n.flags&nameNeedzero != 0 }
+func (n *Name) AutoTemp() bool                 { return n.flags&nameAutoTemp != 0 }
+func (n *Name) Used() bool                     { return n.flags&nameUsed != 0 }
+func (n *Name) IsClosureVar() bool             { return n.flags&nameIsClosureVar != 0 }
+func (n *Name) IsOutputParamHeapAddr() bool    { return n.flags&nameIsOutputParamHeapAddr != 0 }
+func (n *Name) IsOutputParamInRegisters() bool { return n.flags&nameIsOutputParamInRegisters != 0 }
+func (n *Name) Addrtaken() bool                { return n.flags&nameAddrtaken != 0 }
+func (n *Name) InlFormal() bool                { return n.flags&nameInlFormal != 0 }
+func (n *Name) InlLocal() bool                 { return n.flags&nameInlLocal != 0 }
+func (n *Name) OpenDeferSlot() bool            { return n.flags&nameOpenDeferSlot != 0 }
+func (n *Name) LibfuzzerExtraCounter() bool    { return n.flags&nameLibfuzzerExtraCounter != 0 }
+
+func (n *Name) setReadonly(b bool)                 { n.flags.set(nameReadonly, b) }
+func (n *Name) SetNeedzero(b bool)                 { n.flags.set(nameNeedzero, b) }
+func (n *Name) SetAutoTemp(b bool)                 { n.flags.set(nameAutoTemp, b) }
+func (n *Name) SetUsed(b bool)                     { n.flags.set(nameUsed, b) }
+func (n *Name) SetIsClosureVar(b bool)             { n.flags.set(nameIsClosureVar, b) }
+func (n *Name) SetIsOutputParamHeapAddr(b bool)    { n.flags.set(nameIsOutputParamHeapAddr, b) }
+func (n *Name) SetIsOutputParamInRegisters(b bool) { n.flags.set(nameIsOutputParamInRegisters, b) }
+func (n *Name) SetAddrtaken(b bool)                { n.flags.set(nameAddrtaken, b) }
+func (n *Name) SetInlFormal(b bool)                { n.flags.set(nameInlFormal, b) }
+func (n *Name) SetInlLocal(b bool)                 { n.flags.set(nameInlLocal, b) }
+func (n *Name) SetOpenDeferSlot(b bool)            { n.flags.set(nameOpenDeferSlot, b) }
+func (n *Name) SetLibfuzzerExtraCounter(b bool)    { n.flags.set(nameLibfuzzerExtraCounter, b) }
 
 // OnStack reports whether variable n may reside on the stack.
 func (n *Name) OnStack() bool {
diff --git a/src/cmd/compile/internal/liveness/plive.go b/src/cmd/compile/internal/liveness/plive.go
index 48a26cf66a..f3fbb8b9b1 100644
--- a/src/cmd/compile/internal/liveness/plive.go
+++ b/src/cmd/compile/internal/liveness/plive.go
@@ -405,11 +405,17 @@ func (lv *liveness) pointerMap(liveout bitvec.BitVec, vars []*ir.Name, args, loc
 		}
 		node := vars[i]
 		switch node.Class {
+		case ir.PPARAM, ir.PPARAMOUT:
+			if !node.IsOutputParamInRegisters() {
+				if node.FrameOffset() < 0 {
+					lv.f.Fatalf("Node %v has frameoffset %d\n", node.Sym().Name, node.FrameOffset())
+				}
+				typebits.Set(node.Type(), node.FrameOffset(), args)
+				break
+			}
+			fallthrough // PPARAMOUT in registers acts memory-allocates like an AUTO
 		case ir.PAUTO:
 			typebits.Set(node.Type(), node.FrameOffset()+lv.stkptrsize, locals)
-
-		case ir.PPARAM, ir.PPARAMOUT:
-			typebits.Set(node.Type(), node.FrameOffset(), args)
 		}
 	}
 }
@@ -1083,8 +1089,10 @@ func (lv *liveness) emit() (argsSym, liveSym *obj.LSym) {
 	for _, n := range lv.vars {
 		switch n.Class {
 		case ir.PPARAM, ir.PPARAMOUT:
-			if maxArgNode == nil || n.FrameOffset() > maxArgNode.FrameOffset() {
-				maxArgNode = n
+			if !n.IsOutputParamInRegisters() {
+				if maxArgNode == nil || n.FrameOffset() > maxArgNode.FrameOffset() {
+					maxArgNode = n
+				}
 			}
 		}
 	}
@@ -1282,6 +1290,7 @@ func isfat(t *types.Type) bool {
 	return false
 }
 
+// TODO THIS IS ALL WRONG AND NEEDS TO USE ABI.
 func WriteFuncMap(fn *ir.Func) {
 	if ir.FuncName(fn) == "_" || fn.Sym().Linkname != "" {
 		return
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index 084098fb64..fe9ba0e156 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -191,6 +191,16 @@ func archRegForAbiReg(r abi.RegIndex, c *Config) uint8 {
 	return uint8(m)
 }
 
+// ArgWidth returns the amount of stack needed for all the inputs
+// and outputs of a function or method, including ABI-defined parameter
+// slots and ABI-defined spill slots for register-resident parameters.
+//
+// The name is taken from the types package's ArgWidth(<function type>),
+// which predated changes to the ABI; this version handles those changes.
+func (a *AuxCall) ArgWidth() int64 {
+	return a.abiInfo.ArgWidth()
+}
+
 // OffsetOfResult returns the SP offset of result which (indexed 0, 1, etc).
 func (a *AuxCall) ParamAssignmentForResult(which int64) *abi.ABIParamAssignment {
 	return a.abiInfo.OutParam(int(which))
diff --git a/src/cmd/compile/internal/ssagen/pgen.go b/src/cmd/compile/internal/ssagen/pgen.go
index 8fa5980dab..0088f10fa8 100644
--- a/src/cmd/compile/internal/ssagen/pgen.go
+++ b/src/cmd/compile/internal/ssagen/pgen.go
@@ -104,7 +104,9 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 	// Reassign stack offsets of the locals that are used.
 	lastHasPtr := false
 	for i, n := range fn.Dcl {
-		if n.Op() != ir.ONAME || n.Class != ir.PAUTO {
+		if n.Op() != ir.ONAME || n.Class != ir.PAUTO && !(n.Class == ir.PPARAMOUT && n.IsOutputParamInRegisters()) {
+			// i.e., stack assign if AUTO, or if PARAMOUT in registers (which has no predefined spill locations)
+			// TODO figure out when we don't need to spill output params.
 			continue
 		}
 		if !n.Used() {
@@ -148,9 +150,9 @@ const maxStackSize = 1 << 30
 func Compile(fn *ir.Func, worker int) {
 	f := buildssa(fn, worker)
 	// Note: check arg size to fix issue 25507.
-	if f.Frontend().(*ssafn).stksize >= maxStackSize || fn.Type().ArgWidth() >= maxStackSize {
+	if f.Frontend().(*ssafn).stksize >= maxStackSize || f.OwnAux.ArgWidth() >= maxStackSize {
 		largeStackFramesMu.Lock()
-		largeStackFrames = append(largeStackFrames, largeStack{locals: f.Frontend().(*ssafn).stksize, args: fn.Type().ArgWidth(), pos: fn.Pos()})
+		largeStackFrames = append(largeStackFrames, largeStack{locals: f.Frontend().(*ssafn).stksize, args: f.OwnAux.ArgWidth(), pos: fn.Pos()})
 		largeStackFramesMu.Unlock()
 		return
 	}
@@ -166,7 +168,7 @@ func Compile(fn *ir.Func, worker int) {
 	if pp.Text.To.Offset >= maxStackSize {
 		largeStackFramesMu.Lock()
 		locals := f.Frontend().(*ssafn).stksize
-		largeStackFrames = append(largeStackFrames, largeStack{locals: locals, args: fn.Type().ArgWidth(), callee: pp.Text.To.Offset - locals, pos: fn.Pos()})
+		largeStackFrames = append(largeStackFrames, largeStack{locals: locals, args: f.OwnAux.ArgWidth(), callee: pp.Text.To.Offset - locals, pos: fn.Pos()})
 		largeStackFramesMu.Unlock()
 		return
 	}
@@ -189,6 +191,12 @@ func StackOffset(slot ssa.LocalSlot) int32 {
 	n := slot.N
 	var off int64
 	switch n.Class {
+	case ir.PPARAM, ir.PPARAMOUT:
+		if !n.IsOutputParamInRegisters() {
+			off = n.FrameOffset() + base.Ctxt.FixedFrameSize()
+			break
+		}
+		fallthrough // PPARAMOUT in registers allocates like an AUTO
 	case ir.PAUTO:
 		off = n.FrameOffset()
 		if base.Ctxt.FixedFrameSize() == 0 {
@@ -197,8 +205,6 @@ func StackOffset(slot ssa.LocalSlot) int32 {
 		if objabi.Framepointer_enabled {
 			off -= int64(types.PtrSize)
 		}
-	case ir.PPARAM, ir.PPARAMOUT:
-		off = n.FrameOffset() + base.Ctxt.FixedFrameSize()
 	}
 	return int32(off + slot.Off)
 }
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 0029558963..6a3c0d28cb 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -372,7 +372,7 @@ func (s *state) emitOpenDeferInfo() {
 }
 
 func okOffset(offset int64) int64 {
-	if offset >= types.BOGUS_FUNARG_OFFSET {
+	if offset == types.BOGUS_FUNARG_OFFSET {
 		panic(fmt.Errorf("Bogus offset %d", offset))
 	}
 	return offset
@@ -516,7 +516,7 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 	}
 
 	var params *abi.ABIParamResultInfo
-	params = s.f.ABISelf.ABIAnalyze(fn.Type())
+	params = s.f.ABISelf.ABIAnalyze(fn.Type(), true)
 
 	// Generate addresses of local declarations
 	s.decladdrs = map[*ir.Name]*ssa.Value{}
@@ -4914,8 +4914,6 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			closure = iclosure
 		}
 	}
-	types.CalcSize(fn.Type())
-	stksize := fn.Type().ArgWidth() // includes receiver, args, and results
 
 	if regAbiForFuncType(n.X.Type().FuncType()) {
 		// fmt.Printf("Saw magic last type in call %v\n", n)
@@ -4927,7 +4925,9 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		callABI = s.f.ABI0
 	}
 
-	params := callABI.ABIAnalyze(n.X.Type())
+	params := callABI.ABIAnalyze(n.X.Type(), false /* Do not set (register) nNames from caller side -- can cause races. */ )
+	types.CalcSize(fn.Type())
+	stksize := params.ArgWidth() // includes receiver, args, and results
 
 	res := n.X.Type().Results()
 	if k == callNormal {
@@ -6838,13 +6838,13 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 		f.HTMLWriter.WriteColumn("genssa", "genssa", "ssa-prog", buf.String())
 	}
 
-	defframe(&s, e)
+	defframe(&s, e, f)
 
 	f.HTMLWriter.Close()
 	f.HTMLWriter = nil
 }
 
-func defframe(s *State, e *ssafn) {
+func defframe(s *State, e *ssafn, f *ssa.Func) {
 	pp := s.pp
 
 	frame := types.Rnd(s.maxarg+e.stksize, int64(types.RegSize))
@@ -6854,7 +6854,7 @@ func defframe(s *State, e *ssafn) {
 
 	// Fill in argument and frame size.
 	pp.Text.To.Type = obj.TYPE_TEXTSIZE
-	pp.Text.To.Val = int32(types.Rnd(e.curfn.Type().ArgWidth(), int64(types.RegSize)))
+	pp.Text.To.Val = int32(types.Rnd(f.OwnAux.ArgWidth(), int64(types.RegSize)))
 	pp.Text.To.Offset = frame
 
 	// Insert code to zero ambiguously live variables so that the
@@ -6957,14 +6957,18 @@ func AddAux2(a *obj.Addr, v *ssa.Value, offset int64) {
 		a.Name = obj.NAME_EXTERN
 		a.Sym = n
 	case *ir.Name:
-		if n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT {
+		if n.Class == ir.PPARAM || (n.Class == ir.PPARAMOUT && !n.IsOutputParamInRegisters()) {
 			a.Name = obj.NAME_PARAM
 			a.Sym = ir.Orig(n).(*ir.Name).Linksym()
 			a.Offset += n.FrameOffset()
 			break
 		}
 		a.Name = obj.NAME_AUTO
-		a.Sym = n.Linksym()
+		if n.Class == ir.PPARAMOUT {
+			a.Sym = ir.Orig(n).(*ir.Name).Linksym()
+		} else {
+			a.Sym = n.Linksym()
+		}
 		a.Offset += n.FrameOffset()
 	default:
 		v.Fatalf("aux in %s not implemented %#v", v, v.Aux)
@@ -7108,7 +7112,7 @@ func AddrAuto(a *obj.Addr, v *ssa.Value) {
 	a.Sym = n.Linksym()
 	a.Reg = int16(Arch.REGSP)
 	a.Offset = n.FrameOffset() + off
-	if n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT {
+	if n.Class == ir.PPARAM || (n.Class == ir.PPARAMOUT && !n.IsOutputParamInRegisters()) {
 		a.Name = obj.NAME_PARAM
 	} else {
 		a.Name = obj.NAME_AUTO
@@ -7545,10 +7549,10 @@ func AddrForParamSlot(slot *ssa.LocalSlot, addr *obj.Addr) {
 	addr.Type = obj.TYPE_MEM
 	addr.Sym = n.Linksym()
 	addr.Offset = off
-	if n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT {
+	if n.Class == ir.PPARAM || (n.Class == ir.PPARAMOUT && !n.IsOutputParamInRegisters()) {
 		addr.Name = obj.NAME_PARAM
 		addr.Offset += n.FrameOffset()
-	} else {
+	} else { // out parameters in registers allocate stack slots like autos.
 		addr.Name = obj.NAME_AUTO
 	}
 }
diff --git a/src/cmd/compile/internal/test/abiutilsaux_test.go b/src/cmd/compile/internal/test/abiutilsaux_test.go
index 7eb273273d..b945633133 100644
--- a/src/cmd/compile/internal/test/abiutilsaux_test.go
+++ b/src/cmd/compile/internal/test/abiutilsaux_test.go
@@ -119,7 +119,7 @@ func abitest(t *testing.T, ft *types.Type, exp expectedDump) {
 	types.CalcSize(ft)
 
 	// Analyze with full set of registers.
-	regRes := configAMD64.ABIAnalyze(ft)
+	regRes := configAMD64.ABIAnalyze(ft, false)
 	regResString := strings.TrimSpace(regRes.String())
 
 	// Check results.
diff --git a/src/cmd/compile/internal/types/size.go b/src/cmd/compile/internal/types/size.go
index ef23cdf5fe..a75429f0ab 100644
--- a/src/cmd/compile/internal/types/size.go
+++ b/src/cmd/compile/internal/types/size.go
@@ -163,19 +163,9 @@ func calcStructOffset(errtype *Type, t *Type, o int64, flag int) int64 {
 		if f.Type.Align > 0 {
 			o = Rnd(o, int64(f.Type.Align))
 		}
-		if isStruct { // For receiver/args/results, depends on ABI
+		if isStruct { // For receiver/args/results, do not set, it depends on ABI
 			f.Offset = o
 		}
-		if f.Nname != nil {
-			// addrescapes has similar code to update these offsets.
-			// Usually addrescapes runs after calcStructOffset,
-			// in which case we could drop this,
-			// but function closure functions are the exception.
-			// NOTE(rsc): This comment may be stale.
-			// It's possible the ordering has changed and this is
-			// now the common case. I'm not sure.
-			f.Nname.(VarObject).RecordFrameOffset(o)
-		}
 
 		w := f.Type.Width
 		if w < 0 {
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index ffaf755345..7bf63764b8 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -1750,7 +1750,7 @@ func NewTypeParam(pkg *Pkg) *Type {
 	return t
 }
 
-const BOGUS_FUNARG_OFFSET = 1000000000
+const BOGUS_FUNARG_OFFSET = -1000000000
 
 func unzeroFieldOffsets(f []*Field) {
 	for i := range f {
@@ -1759,7 +1759,7 @@ func unzeroFieldOffsets(f []*Field) {
 }
 
 // NewSignature returns a new function type for the given receiver,
-// parametes, results, and type parameters, any of which may be nil.
+// parameters, results, and type parameters, any of which may be nil.
 func NewSignature(pkg *Pkg, recv *Field, tparams, params, results []*Field) *Type {
 	var recvs []*Field
 	if recv != nil {
diff --git a/test/abi/fibish2.go b/test/abi/fibish2.go
index 14f3f9ada7..388aabc8b0 100644
--- a/test/abi/fibish2.go
+++ b/test/abi/fibish2.go
@@ -13,12 +13,12 @@ import "fmt"
 
 // Test that register results are correctly returned (and passed)
 
-type MagicLastTypeNameForTestingRegisterABI func(int,MagicLastTypeNameForTestingRegisterABI) int
+type MagicLastTypeNameForTestingRegisterABI func(int, MagicLastTypeNameForTestingRegisterABI) int
 
 //go:registerparams
 //go:noinline
 func minus(decrement int) MagicLastTypeNameForTestingRegisterABI {
-	return MagicLastTypeNameForTestingRegisterABI( func(x int, _ MagicLastTypeNameForTestingRegisterABI) int { return x-decrement} )
+	return MagicLastTypeNameForTestingRegisterABI(func(x int, _ MagicLastTypeNameForTestingRegisterABI) int { return x - decrement })
 }
 
 //go:noinline
diff --git a/test/abi/leaf.go b/test/abi/leaf.go
new file mode 100644
index 0000000000..f893f5dddb
--- /dev/null
+++ b/test/abi/leaf.go
@@ -0,0 +1,36 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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.
+
+// wasm is excluded because the compiler chatter about register abi pragma ends up
+// on stdout, and causes the expected output to not match.
+
+package main
+
+import "fmt"
+
+type i5f5 struct {
+	a, b          int16
+	c, d, e       int32
+	r, s, t, u, v float32
+}
+
+//go:registerparams
+//go:noinline
+func F(x i5f5) i5f5 {
+	return x
+}
+
+func main() {
+	x := i5f5{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+	y := x
+	z := F(x)
+	if y != z {
+		fmt.Printf("y=%v, z=%v\n", y, z)
+	}
+}
diff --git a/test/abi/leaf2.go b/test/abi/leaf2.go
new file mode 100644
index 0000000000..d2018d5313
--- /dev/null
+++ b/test/abi/leaf2.go
@@ -0,0 +1,43 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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.
+
+// wasm is excluded because the compiler chatter about register abi pragma ends up
+// on stdout, and causes the expected output to not match.
+
+package main
+
+import "fmt"
+
+type i4 struct {
+	a, b, c, d int
+}
+
+//go:registerparams
+//go:noinline
+func F(x i4) i4 {
+	ab := x.a + x.b
+	bc := x.b + x.c
+	cd := x.c + x.d
+	ad := x.a + x.d
+	ba := x.a - x.b
+	cb := x.b - x.c
+	dc := x.c - x.d
+	da := x.a - x.d
+
+	return i4{ab*bc + da, cd*ad + cb, ba*cb + ad, dc*da + bc}
+}
+
+func main() {
+	x := i4{1, 2, 3, 4}
+	y := x
+	z := F(x)
+	if (i4{12, 34, 6, 8}) != z {
+		fmt.Printf("y=%v, z=%v\n", y, z)
+	}
+}
diff --git a/test/abi/methods.go b/test/abi/methods.go
index 9ecae9833e..3dcd3e327a 100644
--- a/test/abi/methods.go
+++ b/test/abi/methods.go
@@ -14,7 +14,7 @@ import (
 )
 
 type toobig struct {
-	a,b,c string
+	a, b, c string
 }
 
 //go:registerparams
@@ -29,8 +29,8 @@ type AnInterface interface {
 
 //go:registerparams
 //go:noinline
-func I(a,b,c string) toobig {
-	return toobig{a,b,c}
+func I(a, b, c string) toobig {
+	return toobig{a, b, c}
 }
 
 // AnIid prevents the compiler from figuring out what the interface really is.
@@ -40,12 +40,13 @@ func AnIid(x AnInterface) AnInterface {
 }
 
 var tmp toobig
+
 func main() {
 	x := I("Ahoy", "1,", "2")
 	y := I("3", "there,", "4")
 	z := I("5", "6,", "Matey")
-	tmp = x.MagicMethodNameForTestingRegisterABI(y,z)
+	tmp = x.MagicMethodNameForTestingRegisterABI(y, z)
 	fmt.Println(tmp.a, tmp.b, tmp.c)
-	tmp = AnIid(&x).MagicMethodNameForTestingRegisterABI(y,z)
+	tmp = AnIid(&x).MagicMethodNameForTestingRegisterABI(y, z)
 	fmt.Println(tmp.a, tmp.b, tmp.c)
 }
diff --git a/test/abi/spills3.go b/test/abi/spills3.go
new file mode 100644
index 0000000000..247828437b
--- /dev/null
+++ b/test/abi/spills3.go
@@ -0,0 +1,48 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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.
+
+// wasm is excluded because the compiler chatter about register abi pragma ends up
+// on stdout, and causes the expected output to not match.
+
+package main
+
+import "fmt"
+
+type i4 struct {
+	a, b, c, d int
+}
+
+//go:noinline
+func spills(px *i4) {
+}
+
+//go:registerparams
+//go:noinline
+func F(x i4) i4 {
+	ab := x.a + x.b
+	bc := x.b + x.c
+	cd := x.c + x.d
+	ad := x.a + x.d
+	ba := x.a - x.b
+	cb := x.b - x.c
+	dc := x.c - x.d
+	da := x.a - x.d
+	i := i4{ab*bc + da, cd*ad + cb, ba*cb + ad, dc*da + bc}
+	spills(&i)
+	return i
+}
+
+func main() {
+	x := i4{1, 2, 3, 4}
+	y := x
+	z := F(x)
+	if z != (i4{12, 34, 6, 8}) {
+		fmt.Printf("y=%v, z=%v\n", y, z)
+	}
+}
diff --git a/test/abi/spills4.go b/test/abi/spills4.go
new file mode 100644
index 0000000000..205f5a64c0
--- /dev/null
+++ b/test/abi/spills4.go
@@ -0,0 +1,44 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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.
+
+// wasm is excluded because the compiler chatter about register abi pragma ends up
+// on stdout, and causes the expected output to not match.
+
+package main
+
+import "fmt"
+
+type i5f5 struct {
+	a, b          int16
+	c, d, e       int32
+	r, s, t, u, v float32
+}
+
+//go:noinline
+func spills(_ *float32) {
+
+}
+
+//go:registerparams
+//go:noinline
+func F(x i5f5) i5f5 {
+	y := x.v
+	spills(&y)
+	x.r = y
+	return x
+}
+
+func main() {
+	x := i5f5{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+	y := x
+	z := F(x)
+	if (i5f5{1, 2, 3, 4, 5, 10, 7, 8, 9, 10}) != z {
+		fmt.Printf("y=%v, z=%v\n", y, z)
+	}
+}
-- 
GitLab


From e61c9ddb7f1a790f6a52f563dccb4ac264f2e704 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Mon, 15 Mar 2021 21:12:08 +0000
Subject: [PATCH 1095/2400] Revert "cmd/compile: spill output parameters passed
 in registers as autos"

This reverts commit 8ed438c077d82c4b4662c327dbbdb3c64e7547ca, CL 300749.

Reason for revert: Looks like it crashes on link-register architectures

Change-Id: I0c261df58900008cada3359889d2a87508158447
Reviewed-on: https://go-review.googlesource.com/c/go/+/302053
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/abi/abiutils.go      | 31 ++------
 src/cmd/compile/internal/dwarfgen/dwarf.go    | 10 +--
 src/cmd/compile/internal/gc/compile.go        |  2 +-
 src/cmd/compile/internal/ir/name.go           | 75 +++++++++----------
 src/cmd/compile/internal/liveness/plive.go    | 19 ++---
 src/cmd/compile/internal/ssa/op.go            | 10 ---
 src/cmd/compile/internal/ssagen/pgen.go       | 18 ++---
 src/cmd/compile/internal/ssagen/ssa.go        | 30 ++++----
 .../compile/internal/test/abiutilsaux_test.go |  2 +-
 src/cmd/compile/internal/types/size.go        | 12 ++-
 src/cmd/compile/internal/types/type.go        |  4 +-
 test/abi/fibish2.go                           |  4 +-
 test/abi/leaf.go                              | 36 ---------
 test/abi/leaf2.go                             | 43 -----------
 test/abi/methods.go                           | 11 ++-
 test/abi/spills3.go                           | 48 ------------
 test/abi/spills4.go                           | 44 -----------
 17 files changed, 90 insertions(+), 309 deletions(-)
 delete mode 100644 test/abi/leaf.go
 delete mode 100644 test/abi/leaf2.go
 delete mode 100644 test/abi/spills3.go
 delete mode 100644 test/abi/spills4.go

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index e92827fc7f..ecde34313a 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -69,14 +69,6 @@ func (a *ABIParamResultInfo) SpillAreaSize() int64 {
 	return a.spillAreaSize
 }
 
-// ArgWidth returns the amount of stack needed for all the inputs
-// and outputs of a function or method, including ABI-defined parameter
-// slots and ABI-defined spill slots for register-resident parameters.
-// The name is inherited from (*Type).ArgWidth(), which it replaces.
-func (a *ABIParamResultInfo) ArgWidth() int64 {
-	return a.spillAreaSize + a.offsetToSpillArea
-}
-
 // RegIndex stores the index into the set of machine registers used by
 // the ABI on a specific architecture for parameter passing.  RegIndex
 // values 0 through N-1 (where N is the number of integer registers
@@ -422,25 +414,20 @@ func (config *ABIConfig) ABIAnalyzeFuncType(ft *types.Func) *ABIParamResultInfo
 
 // ABIAnalyze returns the same result as ABIAnalyzeFuncType, but also
 // updates the offsets of all the receiver, input, and output fields.
-// If setNname is true, it also sets the FrameOffset of the Nname for
-// the field(s); this is for use when compiling a function and figuring out
-// spill locations.  Doing this for callers can cause races for register
-// outputs because their frame location transitions from BOGUS_FUNARG_OFFSET
-// to zero to an as-if-AUTO offset that has no use for callers.
-func (config *ABIConfig) ABIAnalyze(t *types.Type, setNname bool) *ABIParamResultInfo {
+func (config *ABIConfig) ABIAnalyze(t *types.Type) *ABIParamResultInfo {
 	ft := t.FuncType()
 	result := config.ABIAnalyzeFuncType(ft)
 	// Fill in the frame offsets for receiver, inputs, results
 	k := 0
 	if t.NumRecvs() != 0 {
-		config.updateOffset(result, ft.Receiver.FieldSlice()[0], result.inparams[0], false, setNname)
+		config.updateOffset(result, ft.Receiver.FieldSlice()[0], result.inparams[0], false)
 		k++
 	}
 	for i, f := range ft.Params.FieldSlice() {
-		config.updateOffset(result, f, result.inparams[k+i], false, setNname)
+		config.updateOffset(result, f, result.inparams[k+i], false)
 	}
 	for i, f := range ft.Results.FieldSlice() {
-		config.updateOffset(result, f, result.outparams[i], true, setNname)
+		config.updateOffset(result, f, result.outparams[i], true)
 	}
 	return result
 }
@@ -455,7 +442,7 @@ func FieldOffsetOf(f *types.Field) int64 {
 	return f.Offset
 }
 
-func (config *ABIConfig) updateOffset(result *ABIParamResultInfo, f *types.Field, a ABIParamAssignment, isReturn, setNname bool) {
+func (config *ABIConfig) updateOffset(result *ABIParamResultInfo, f *types.Field, a ABIParamAssignment, isReturn bool) {
 	// Everything except return values in registers has either a frame home (if not in a register) or a frame spill location.
 	if !isReturn || len(a.Registers) == 0 {
 		// The type frame offset DOES NOT show effects of minimum frame size.
@@ -468,19 +455,11 @@ func (config *ABIConfig) updateOffset(result *ABIParamResultInfo, f *types.Field
 			// Set the Offset the first time. After that, we may recompute it, but it should never change.
 			f.Offset = off
 			if f.Nname != nil {
-				// always set it in this case.
 				f.Nname.(*ir.Name).SetFrameOffset(off)
-				f.Nname.(*ir.Name).SetIsOutputParamInRegisters(false)
 			}
 		} else if fOffset != off {
 			panic(fmt.Errorf("Offset changed from %d to %d", fOffset, off))
 		}
-	} else {
-		if setNname && f.Nname != nil {
-			fname := f.Nname.(*ir.Name)
-			fname.SetIsOutputParamInRegisters(true)
-			fname.SetFrameOffset(0)
-		}
 	}
 }
 
diff --git a/src/cmd/compile/internal/dwarfgen/dwarf.go b/src/cmd/compile/internal/dwarfgen/dwarf.go
index 53752097ed..70168cffeb 100644
--- a/src/cmd/compile/internal/dwarfgen/dwarf.go
+++ b/src/cmd/compile/internal/dwarfgen/dwarf.go
@@ -265,13 +265,6 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 	var offs int64
 
 	switch n.Class {
-	case ir.PPARAM, ir.PPARAMOUT:
-		if !n.IsOutputParamInRegisters() {
-			abbrev = dwarf.DW_ABRV_PARAM
-			offs = n.FrameOffset() + base.Ctxt.FixedFrameSize()
-			break
-		}
-		fallthrough
 	case ir.PAUTO:
 		offs = n.FrameOffset()
 		abbrev = dwarf.DW_ABRV_AUTO
@@ -282,6 +275,9 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 			offs -= int64(types.PtrSize)
 		}
 
+	case ir.PPARAM, ir.PPARAMOUT:
+		abbrev = dwarf.DW_ABRV_PARAM
+		offs = n.FrameOffset() + base.Ctxt.FixedFrameSize()
 	default:
 		base.Fatalf("createSimpleVar unexpected class %v for node %v", n.Class, n)
 	}
diff --git a/src/cmd/compile/internal/gc/compile.go b/src/cmd/compile/internal/gc/compile.go
index 83cfceb2c8..2d7a74a403 100644
--- a/src/cmd/compile/internal/gc/compile.go
+++ b/src/cmd/compile/internal/gc/compile.go
@@ -45,7 +45,7 @@ func enqueueFunc(fn *ir.Func) {
 		ssagen.InitLSym(fn, false)
 		types.CalcSize(fn.Type()) // TODO register args; remove this once all is done by abiutils
 		a := ssagen.AbiForFunc(fn)
-		a.ABIAnalyze(fn.Type(), true) // will set parameter spill/home locations correctly
+		a.ABIAnalyze(fn.Type()) // will set parameter spill/home locations correctly
 		liveness.WriteFuncMap(fn)
 		return
 	}
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 5738aa1f3f..16c30324e5 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -246,47 +246,44 @@ func (n *Name) Alias() bool { return n.flags&nameAlias != 0 }
 func (n *Name) SetAlias(alias bool) { n.flags.set(nameAlias, alias) }
 
 const (
-	nameReadonly                 = 1 << iota
-	nameByval                    // is the variable captured by value or by reference
-	nameNeedzero                 // if it contains pointers, needs to be zeroed on function entry
-	nameAutoTemp                 // is the variable a temporary (implies no dwarf info. reset if escapes to heap)
-	nameUsed                     // for variable declared and not used error
-	nameIsClosureVar             // PAUTOHEAP closure pseudo-variable; original (if any) at n.Defn
-	nameIsOutputParamHeapAddr    // pointer to a result parameter's heap copy
-	nameIsOutputParamInRegisters // output parameter in registers spills as an auto
-	nameAddrtaken                // address taken, even if not moved to heap
-	nameInlFormal                // PAUTO created by inliner, derived from callee formal
-	nameInlLocal                 // PAUTO created by inliner, derived from callee local
-	nameOpenDeferSlot            // if temporary var storing info for open-coded defers
-	nameLibfuzzerExtraCounter    // if PEXTERN should be assigned to __libfuzzer_extra_counters section
-	nameAlias                    // is type name an alias
+	nameReadonly              = 1 << iota
+	nameByval                 // is the variable captured by value or by reference
+	nameNeedzero              // if it contains pointers, needs to be zeroed on function entry
+	nameAutoTemp              // is the variable a temporary (implies no dwarf info. reset if escapes to heap)
+	nameUsed                  // for variable declared and not used error
+	nameIsClosureVar          // PAUTOHEAP closure pseudo-variable; original (if any) at n.Defn
+	nameIsOutputParamHeapAddr // pointer to a result parameter's heap copy
+	nameAddrtaken             // address taken, even if not moved to heap
+	nameInlFormal             // PAUTO created by inliner, derived from callee formal
+	nameInlLocal              // PAUTO created by inliner, derived from callee local
+	nameOpenDeferSlot         // if temporary var storing info for open-coded defers
+	nameLibfuzzerExtraCounter // if PEXTERN should be assigned to __libfuzzer_extra_counters section
+	nameAlias                 // is type name an alias
 )
 
-func (n *Name) Readonly() bool                 { return n.flags&nameReadonly != 0 }
-func (n *Name) Needzero() bool                 { return n.flags&nameNeedzero != 0 }
-func (n *Name) AutoTemp() bool                 { return n.flags&nameAutoTemp != 0 }
-func (n *Name) Used() bool                     { return n.flags&nameUsed != 0 }
-func (n *Name) IsClosureVar() bool             { return n.flags&nameIsClosureVar != 0 }
-func (n *Name) IsOutputParamHeapAddr() bool    { return n.flags&nameIsOutputParamHeapAddr != 0 }
-func (n *Name) IsOutputParamInRegisters() bool { return n.flags&nameIsOutputParamInRegisters != 0 }
-func (n *Name) Addrtaken() bool                { return n.flags&nameAddrtaken != 0 }
-func (n *Name) InlFormal() bool                { return n.flags&nameInlFormal != 0 }
-func (n *Name) InlLocal() bool                 { return n.flags&nameInlLocal != 0 }
-func (n *Name) OpenDeferSlot() bool            { return n.flags&nameOpenDeferSlot != 0 }
-func (n *Name) LibfuzzerExtraCounter() bool    { return n.flags&nameLibfuzzerExtraCounter != 0 }
-
-func (n *Name) setReadonly(b bool)                 { n.flags.set(nameReadonly, b) }
-func (n *Name) SetNeedzero(b bool)                 { n.flags.set(nameNeedzero, b) }
-func (n *Name) SetAutoTemp(b bool)                 { n.flags.set(nameAutoTemp, b) }
-func (n *Name) SetUsed(b bool)                     { n.flags.set(nameUsed, b) }
-func (n *Name) SetIsClosureVar(b bool)             { n.flags.set(nameIsClosureVar, b) }
-func (n *Name) SetIsOutputParamHeapAddr(b bool)    { n.flags.set(nameIsOutputParamHeapAddr, b) }
-func (n *Name) SetIsOutputParamInRegisters(b bool) { n.flags.set(nameIsOutputParamInRegisters, b) }
-func (n *Name) SetAddrtaken(b bool)                { n.flags.set(nameAddrtaken, b) }
-func (n *Name) SetInlFormal(b bool)                { n.flags.set(nameInlFormal, b) }
-func (n *Name) SetInlLocal(b bool)                 { n.flags.set(nameInlLocal, b) }
-func (n *Name) SetOpenDeferSlot(b bool)            { n.flags.set(nameOpenDeferSlot, b) }
-func (n *Name) SetLibfuzzerExtraCounter(b bool)    { n.flags.set(nameLibfuzzerExtraCounter, b) }
+func (n *Name) Readonly() bool              { return n.flags&nameReadonly != 0 }
+func (n *Name) Needzero() bool              { return n.flags&nameNeedzero != 0 }
+func (n *Name) AutoTemp() bool              { return n.flags&nameAutoTemp != 0 }
+func (n *Name) Used() bool                  { return n.flags&nameUsed != 0 }
+func (n *Name) IsClosureVar() bool          { return n.flags&nameIsClosureVar != 0 }
+func (n *Name) IsOutputParamHeapAddr() bool { return n.flags&nameIsOutputParamHeapAddr != 0 }
+func (n *Name) Addrtaken() bool             { return n.flags&nameAddrtaken != 0 }
+func (n *Name) InlFormal() bool             { return n.flags&nameInlFormal != 0 }
+func (n *Name) InlLocal() bool              { return n.flags&nameInlLocal != 0 }
+func (n *Name) OpenDeferSlot() bool         { return n.flags&nameOpenDeferSlot != 0 }
+func (n *Name) LibfuzzerExtraCounter() bool { return n.flags&nameLibfuzzerExtraCounter != 0 }
+
+func (n *Name) setReadonly(b bool)              { n.flags.set(nameReadonly, b) }
+func (n *Name) SetNeedzero(b bool)              { n.flags.set(nameNeedzero, b) }
+func (n *Name) SetAutoTemp(b bool)              { n.flags.set(nameAutoTemp, b) }
+func (n *Name) SetUsed(b bool)                  { n.flags.set(nameUsed, b) }
+func (n *Name) SetIsClosureVar(b bool)          { n.flags.set(nameIsClosureVar, b) }
+func (n *Name) SetIsOutputParamHeapAddr(b bool) { n.flags.set(nameIsOutputParamHeapAddr, b) }
+func (n *Name) SetAddrtaken(b bool)             { n.flags.set(nameAddrtaken, b) }
+func (n *Name) SetInlFormal(b bool)             { n.flags.set(nameInlFormal, b) }
+func (n *Name) SetInlLocal(b bool)              { n.flags.set(nameInlLocal, b) }
+func (n *Name) SetOpenDeferSlot(b bool)         { n.flags.set(nameOpenDeferSlot, b) }
+func (n *Name) SetLibfuzzerExtraCounter(b bool) { n.flags.set(nameLibfuzzerExtraCounter, b) }
 
 // OnStack reports whether variable n may reside on the stack.
 func (n *Name) OnStack() bool {
diff --git a/src/cmd/compile/internal/liveness/plive.go b/src/cmd/compile/internal/liveness/plive.go
index f3fbb8b9b1..48a26cf66a 100644
--- a/src/cmd/compile/internal/liveness/plive.go
+++ b/src/cmd/compile/internal/liveness/plive.go
@@ -405,17 +405,11 @@ func (lv *liveness) pointerMap(liveout bitvec.BitVec, vars []*ir.Name, args, loc
 		}
 		node := vars[i]
 		switch node.Class {
-		case ir.PPARAM, ir.PPARAMOUT:
-			if !node.IsOutputParamInRegisters() {
-				if node.FrameOffset() < 0 {
-					lv.f.Fatalf("Node %v has frameoffset %d\n", node.Sym().Name, node.FrameOffset())
-				}
-				typebits.Set(node.Type(), node.FrameOffset(), args)
-				break
-			}
-			fallthrough // PPARAMOUT in registers acts memory-allocates like an AUTO
 		case ir.PAUTO:
 			typebits.Set(node.Type(), node.FrameOffset()+lv.stkptrsize, locals)
+
+		case ir.PPARAM, ir.PPARAMOUT:
+			typebits.Set(node.Type(), node.FrameOffset(), args)
 		}
 	}
 }
@@ -1089,10 +1083,8 @@ func (lv *liveness) emit() (argsSym, liveSym *obj.LSym) {
 	for _, n := range lv.vars {
 		switch n.Class {
 		case ir.PPARAM, ir.PPARAMOUT:
-			if !n.IsOutputParamInRegisters() {
-				if maxArgNode == nil || n.FrameOffset() > maxArgNode.FrameOffset() {
-					maxArgNode = n
-				}
+			if maxArgNode == nil || n.FrameOffset() > maxArgNode.FrameOffset() {
+				maxArgNode = n
 			}
 		}
 	}
@@ -1290,7 +1282,6 @@ func isfat(t *types.Type) bool {
 	return false
 }
 
-// TODO THIS IS ALL WRONG AND NEEDS TO USE ABI.
 func WriteFuncMap(fn *ir.Func) {
 	if ir.FuncName(fn) == "_" || fn.Sym().Linkname != "" {
 		return
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index fe9ba0e156..084098fb64 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -191,16 +191,6 @@ func archRegForAbiReg(r abi.RegIndex, c *Config) uint8 {
 	return uint8(m)
 }
 
-// ArgWidth returns the amount of stack needed for all the inputs
-// and outputs of a function or method, including ABI-defined parameter
-// slots and ABI-defined spill slots for register-resident parameters.
-//
-// The name is taken from the types package's ArgWidth(<function type>),
-// which predated changes to the ABI; this version handles those changes.
-func (a *AuxCall) ArgWidth() int64 {
-	return a.abiInfo.ArgWidth()
-}
-
 // OffsetOfResult returns the SP offset of result which (indexed 0, 1, etc).
 func (a *AuxCall) ParamAssignmentForResult(which int64) *abi.ABIParamAssignment {
 	return a.abiInfo.OutParam(int(which))
diff --git a/src/cmd/compile/internal/ssagen/pgen.go b/src/cmd/compile/internal/ssagen/pgen.go
index 0088f10fa8..8fa5980dab 100644
--- a/src/cmd/compile/internal/ssagen/pgen.go
+++ b/src/cmd/compile/internal/ssagen/pgen.go
@@ -104,9 +104,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 	// Reassign stack offsets of the locals that are used.
 	lastHasPtr := false
 	for i, n := range fn.Dcl {
-		if n.Op() != ir.ONAME || n.Class != ir.PAUTO && !(n.Class == ir.PPARAMOUT && n.IsOutputParamInRegisters()) {
-			// i.e., stack assign if AUTO, or if PARAMOUT in registers (which has no predefined spill locations)
-			// TODO figure out when we don't need to spill output params.
+		if n.Op() != ir.ONAME || n.Class != ir.PAUTO {
 			continue
 		}
 		if !n.Used() {
@@ -150,9 +148,9 @@ const maxStackSize = 1 << 30
 func Compile(fn *ir.Func, worker int) {
 	f := buildssa(fn, worker)
 	// Note: check arg size to fix issue 25507.
-	if f.Frontend().(*ssafn).stksize >= maxStackSize || f.OwnAux.ArgWidth() >= maxStackSize {
+	if f.Frontend().(*ssafn).stksize >= maxStackSize || fn.Type().ArgWidth() >= maxStackSize {
 		largeStackFramesMu.Lock()
-		largeStackFrames = append(largeStackFrames, largeStack{locals: f.Frontend().(*ssafn).stksize, args: f.OwnAux.ArgWidth(), pos: fn.Pos()})
+		largeStackFrames = append(largeStackFrames, largeStack{locals: f.Frontend().(*ssafn).stksize, args: fn.Type().ArgWidth(), pos: fn.Pos()})
 		largeStackFramesMu.Unlock()
 		return
 	}
@@ -168,7 +166,7 @@ func Compile(fn *ir.Func, worker int) {
 	if pp.Text.To.Offset >= maxStackSize {
 		largeStackFramesMu.Lock()
 		locals := f.Frontend().(*ssafn).stksize
-		largeStackFrames = append(largeStackFrames, largeStack{locals: locals, args: f.OwnAux.ArgWidth(), callee: pp.Text.To.Offset - locals, pos: fn.Pos()})
+		largeStackFrames = append(largeStackFrames, largeStack{locals: locals, args: fn.Type().ArgWidth(), callee: pp.Text.To.Offset - locals, pos: fn.Pos()})
 		largeStackFramesMu.Unlock()
 		return
 	}
@@ -191,12 +189,6 @@ func StackOffset(slot ssa.LocalSlot) int32 {
 	n := slot.N
 	var off int64
 	switch n.Class {
-	case ir.PPARAM, ir.PPARAMOUT:
-		if !n.IsOutputParamInRegisters() {
-			off = n.FrameOffset() + base.Ctxt.FixedFrameSize()
-			break
-		}
-		fallthrough // PPARAMOUT in registers allocates like an AUTO
 	case ir.PAUTO:
 		off = n.FrameOffset()
 		if base.Ctxt.FixedFrameSize() == 0 {
@@ -205,6 +197,8 @@ func StackOffset(slot ssa.LocalSlot) int32 {
 		if objabi.Framepointer_enabled {
 			off -= int64(types.PtrSize)
 		}
+	case ir.PPARAM, ir.PPARAMOUT:
+		off = n.FrameOffset() + base.Ctxt.FixedFrameSize()
 	}
 	return int32(off + slot.Off)
 }
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 6a3c0d28cb..0029558963 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -372,7 +372,7 @@ func (s *state) emitOpenDeferInfo() {
 }
 
 func okOffset(offset int64) int64 {
-	if offset == types.BOGUS_FUNARG_OFFSET {
+	if offset >= types.BOGUS_FUNARG_OFFSET {
 		panic(fmt.Errorf("Bogus offset %d", offset))
 	}
 	return offset
@@ -516,7 +516,7 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 	}
 
 	var params *abi.ABIParamResultInfo
-	params = s.f.ABISelf.ABIAnalyze(fn.Type(), true)
+	params = s.f.ABISelf.ABIAnalyze(fn.Type())
 
 	// Generate addresses of local declarations
 	s.decladdrs = map[*ir.Name]*ssa.Value{}
@@ -4914,6 +4914,8 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			closure = iclosure
 		}
 	}
+	types.CalcSize(fn.Type())
+	stksize := fn.Type().ArgWidth() // includes receiver, args, and results
 
 	if regAbiForFuncType(n.X.Type().FuncType()) {
 		// fmt.Printf("Saw magic last type in call %v\n", n)
@@ -4925,9 +4927,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		callABI = s.f.ABI0
 	}
 
-	params := callABI.ABIAnalyze(n.X.Type(), false /* Do not set (register) nNames from caller side -- can cause races. */ )
-	types.CalcSize(fn.Type())
-	stksize := params.ArgWidth() // includes receiver, args, and results
+	params := callABI.ABIAnalyze(n.X.Type())
 
 	res := n.X.Type().Results()
 	if k == callNormal {
@@ -6838,13 +6838,13 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 		f.HTMLWriter.WriteColumn("genssa", "genssa", "ssa-prog", buf.String())
 	}
 
-	defframe(&s, e, f)
+	defframe(&s, e)
 
 	f.HTMLWriter.Close()
 	f.HTMLWriter = nil
 }
 
-func defframe(s *State, e *ssafn, f *ssa.Func) {
+func defframe(s *State, e *ssafn) {
 	pp := s.pp
 
 	frame := types.Rnd(s.maxarg+e.stksize, int64(types.RegSize))
@@ -6854,7 +6854,7 @@ func defframe(s *State, e *ssafn, f *ssa.Func) {
 
 	// Fill in argument and frame size.
 	pp.Text.To.Type = obj.TYPE_TEXTSIZE
-	pp.Text.To.Val = int32(types.Rnd(f.OwnAux.ArgWidth(), int64(types.RegSize)))
+	pp.Text.To.Val = int32(types.Rnd(e.curfn.Type().ArgWidth(), int64(types.RegSize)))
 	pp.Text.To.Offset = frame
 
 	// Insert code to zero ambiguously live variables so that the
@@ -6957,18 +6957,14 @@ func AddAux2(a *obj.Addr, v *ssa.Value, offset int64) {
 		a.Name = obj.NAME_EXTERN
 		a.Sym = n
 	case *ir.Name:
-		if n.Class == ir.PPARAM || (n.Class == ir.PPARAMOUT && !n.IsOutputParamInRegisters()) {
+		if n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT {
 			a.Name = obj.NAME_PARAM
 			a.Sym = ir.Orig(n).(*ir.Name).Linksym()
 			a.Offset += n.FrameOffset()
 			break
 		}
 		a.Name = obj.NAME_AUTO
-		if n.Class == ir.PPARAMOUT {
-			a.Sym = ir.Orig(n).(*ir.Name).Linksym()
-		} else {
-			a.Sym = n.Linksym()
-		}
+		a.Sym = n.Linksym()
 		a.Offset += n.FrameOffset()
 	default:
 		v.Fatalf("aux in %s not implemented %#v", v, v.Aux)
@@ -7112,7 +7108,7 @@ func AddrAuto(a *obj.Addr, v *ssa.Value) {
 	a.Sym = n.Linksym()
 	a.Reg = int16(Arch.REGSP)
 	a.Offset = n.FrameOffset() + off
-	if n.Class == ir.PPARAM || (n.Class == ir.PPARAMOUT && !n.IsOutputParamInRegisters()) {
+	if n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT {
 		a.Name = obj.NAME_PARAM
 	} else {
 		a.Name = obj.NAME_AUTO
@@ -7549,10 +7545,10 @@ func AddrForParamSlot(slot *ssa.LocalSlot, addr *obj.Addr) {
 	addr.Type = obj.TYPE_MEM
 	addr.Sym = n.Linksym()
 	addr.Offset = off
-	if n.Class == ir.PPARAM || (n.Class == ir.PPARAMOUT && !n.IsOutputParamInRegisters()) {
+	if n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT {
 		addr.Name = obj.NAME_PARAM
 		addr.Offset += n.FrameOffset()
-	} else { // out parameters in registers allocate stack slots like autos.
+	} else {
 		addr.Name = obj.NAME_AUTO
 	}
 }
diff --git a/src/cmd/compile/internal/test/abiutilsaux_test.go b/src/cmd/compile/internal/test/abiutilsaux_test.go
index b945633133..7eb273273d 100644
--- a/src/cmd/compile/internal/test/abiutilsaux_test.go
+++ b/src/cmd/compile/internal/test/abiutilsaux_test.go
@@ -119,7 +119,7 @@ func abitest(t *testing.T, ft *types.Type, exp expectedDump) {
 	types.CalcSize(ft)
 
 	// Analyze with full set of registers.
-	regRes := configAMD64.ABIAnalyze(ft, false)
+	regRes := configAMD64.ABIAnalyze(ft)
 	regResString := strings.TrimSpace(regRes.String())
 
 	// Check results.
diff --git a/src/cmd/compile/internal/types/size.go b/src/cmd/compile/internal/types/size.go
index a75429f0ab..ef23cdf5fe 100644
--- a/src/cmd/compile/internal/types/size.go
+++ b/src/cmd/compile/internal/types/size.go
@@ -163,9 +163,19 @@ func calcStructOffset(errtype *Type, t *Type, o int64, flag int) int64 {
 		if f.Type.Align > 0 {
 			o = Rnd(o, int64(f.Type.Align))
 		}
-		if isStruct { // For receiver/args/results, do not set, it depends on ABI
+		if isStruct { // For receiver/args/results, depends on ABI
 			f.Offset = o
 		}
+		if f.Nname != nil {
+			// addrescapes has similar code to update these offsets.
+			// Usually addrescapes runs after calcStructOffset,
+			// in which case we could drop this,
+			// but function closure functions are the exception.
+			// NOTE(rsc): This comment may be stale.
+			// It's possible the ordering has changed and this is
+			// now the common case. I'm not sure.
+			f.Nname.(VarObject).RecordFrameOffset(o)
+		}
 
 		w := f.Type.Width
 		if w < 0 {
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 7bf63764b8..ffaf755345 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -1750,7 +1750,7 @@ func NewTypeParam(pkg *Pkg) *Type {
 	return t
 }
 
-const BOGUS_FUNARG_OFFSET = -1000000000
+const BOGUS_FUNARG_OFFSET = 1000000000
 
 func unzeroFieldOffsets(f []*Field) {
 	for i := range f {
@@ -1759,7 +1759,7 @@ func unzeroFieldOffsets(f []*Field) {
 }
 
 // NewSignature returns a new function type for the given receiver,
-// parameters, results, and type parameters, any of which may be nil.
+// parametes, results, and type parameters, any of which may be nil.
 func NewSignature(pkg *Pkg, recv *Field, tparams, params, results []*Field) *Type {
 	var recvs []*Field
 	if recv != nil {
diff --git a/test/abi/fibish2.go b/test/abi/fibish2.go
index 388aabc8b0..14f3f9ada7 100644
--- a/test/abi/fibish2.go
+++ b/test/abi/fibish2.go
@@ -13,12 +13,12 @@ import "fmt"
 
 // Test that register results are correctly returned (and passed)
 
-type MagicLastTypeNameForTestingRegisterABI func(int, MagicLastTypeNameForTestingRegisterABI) int
+type MagicLastTypeNameForTestingRegisterABI func(int,MagicLastTypeNameForTestingRegisterABI) int
 
 //go:registerparams
 //go:noinline
 func minus(decrement int) MagicLastTypeNameForTestingRegisterABI {
-	return MagicLastTypeNameForTestingRegisterABI(func(x int, _ MagicLastTypeNameForTestingRegisterABI) int { return x - decrement })
+	return MagicLastTypeNameForTestingRegisterABI( func(x int, _ MagicLastTypeNameForTestingRegisterABI) int { return x-decrement} )
 }
 
 //go:noinline
diff --git a/test/abi/leaf.go b/test/abi/leaf.go
deleted file mode 100644
index f893f5dddb..0000000000
--- a/test/abi/leaf.go
+++ /dev/null
@@ -1,36 +0,0 @@
-// run
-
-//go:build !wasm
-// +build !wasm
-
-// Copyright 2021 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.
-
-// wasm is excluded because the compiler chatter about register abi pragma ends up
-// on stdout, and causes the expected output to not match.
-
-package main
-
-import "fmt"
-
-type i5f5 struct {
-	a, b          int16
-	c, d, e       int32
-	r, s, t, u, v float32
-}
-
-//go:registerparams
-//go:noinline
-func F(x i5f5) i5f5 {
-	return x
-}
-
-func main() {
-	x := i5f5{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
-	y := x
-	z := F(x)
-	if y != z {
-		fmt.Printf("y=%v, z=%v\n", y, z)
-	}
-}
diff --git a/test/abi/leaf2.go b/test/abi/leaf2.go
deleted file mode 100644
index d2018d5313..0000000000
--- a/test/abi/leaf2.go
+++ /dev/null
@@ -1,43 +0,0 @@
-// run
-
-//go:build !wasm
-// +build !wasm
-
-// Copyright 2021 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.
-
-// wasm is excluded because the compiler chatter about register abi pragma ends up
-// on stdout, and causes the expected output to not match.
-
-package main
-
-import "fmt"
-
-type i4 struct {
-	a, b, c, d int
-}
-
-//go:registerparams
-//go:noinline
-func F(x i4) i4 {
-	ab := x.a + x.b
-	bc := x.b + x.c
-	cd := x.c + x.d
-	ad := x.a + x.d
-	ba := x.a - x.b
-	cb := x.b - x.c
-	dc := x.c - x.d
-	da := x.a - x.d
-
-	return i4{ab*bc + da, cd*ad + cb, ba*cb + ad, dc*da + bc}
-}
-
-func main() {
-	x := i4{1, 2, 3, 4}
-	y := x
-	z := F(x)
-	if (i4{12, 34, 6, 8}) != z {
-		fmt.Printf("y=%v, z=%v\n", y, z)
-	}
-}
diff --git a/test/abi/methods.go b/test/abi/methods.go
index 3dcd3e327a..9ecae9833e 100644
--- a/test/abi/methods.go
+++ b/test/abi/methods.go
@@ -14,7 +14,7 @@ import (
 )
 
 type toobig struct {
-	a, b, c string
+	a,b,c string
 }
 
 //go:registerparams
@@ -29,8 +29,8 @@ type AnInterface interface {
 
 //go:registerparams
 //go:noinline
-func I(a, b, c string) toobig {
-	return toobig{a, b, c}
+func I(a,b,c string) toobig {
+	return toobig{a,b,c}
 }
 
 // AnIid prevents the compiler from figuring out what the interface really is.
@@ -40,13 +40,12 @@ func AnIid(x AnInterface) AnInterface {
 }
 
 var tmp toobig
-
 func main() {
 	x := I("Ahoy", "1,", "2")
 	y := I("3", "there,", "4")
 	z := I("5", "6,", "Matey")
-	tmp = x.MagicMethodNameForTestingRegisterABI(y, z)
+	tmp = x.MagicMethodNameForTestingRegisterABI(y,z)
 	fmt.Println(tmp.a, tmp.b, tmp.c)
-	tmp = AnIid(&x).MagicMethodNameForTestingRegisterABI(y, z)
+	tmp = AnIid(&x).MagicMethodNameForTestingRegisterABI(y,z)
 	fmt.Println(tmp.a, tmp.b, tmp.c)
 }
diff --git a/test/abi/spills3.go b/test/abi/spills3.go
deleted file mode 100644
index 247828437b..0000000000
--- a/test/abi/spills3.go
+++ /dev/null
@@ -1,48 +0,0 @@
-// run
-
-//go:build !wasm
-// +build !wasm
-
-// Copyright 2021 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.
-
-// wasm is excluded because the compiler chatter about register abi pragma ends up
-// on stdout, and causes the expected output to not match.
-
-package main
-
-import "fmt"
-
-type i4 struct {
-	a, b, c, d int
-}
-
-//go:noinline
-func spills(px *i4) {
-}
-
-//go:registerparams
-//go:noinline
-func F(x i4) i4 {
-	ab := x.a + x.b
-	bc := x.b + x.c
-	cd := x.c + x.d
-	ad := x.a + x.d
-	ba := x.a - x.b
-	cb := x.b - x.c
-	dc := x.c - x.d
-	da := x.a - x.d
-	i := i4{ab*bc + da, cd*ad + cb, ba*cb + ad, dc*da + bc}
-	spills(&i)
-	return i
-}
-
-func main() {
-	x := i4{1, 2, 3, 4}
-	y := x
-	z := F(x)
-	if z != (i4{12, 34, 6, 8}) {
-		fmt.Printf("y=%v, z=%v\n", y, z)
-	}
-}
diff --git a/test/abi/spills4.go b/test/abi/spills4.go
deleted file mode 100644
index 205f5a64c0..0000000000
--- a/test/abi/spills4.go
+++ /dev/null
@@ -1,44 +0,0 @@
-// run
-
-//go:build !wasm
-// +build !wasm
-
-// Copyright 2021 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.
-
-// wasm is excluded because the compiler chatter about register abi pragma ends up
-// on stdout, and causes the expected output to not match.
-
-package main
-
-import "fmt"
-
-type i5f5 struct {
-	a, b          int16
-	c, d, e       int32
-	r, s, t, u, v float32
-}
-
-//go:noinline
-func spills(_ *float32) {
-
-}
-
-//go:registerparams
-//go:noinline
-func F(x i5f5) i5f5 {
-	y := x.v
-	spills(&y)
-	x.r = y
-	return x
-}
-
-func main() {
-	x := i5f5{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
-	y := x
-	z := F(x)
-	if (i5f5{1, 2, 3, 4, 5, 10, 7, 8, 9, 10}) != z {
-		fmt.Printf("y=%v, z=%v\n", y, z)
-	}
-}
-- 
GitLab


From de2b27dee761143116b2ecb303b67e018c5e7473 Mon Sep 17 00:00:00 2001
From: Prajwal Koirala <16564273+Prajwal-Koirala@users.noreply.github.com>
Date: Mon, 15 Mar 2021 06:13:23 +0000
Subject: [PATCH 1096/2400] all: run gofmt

Fixes #44980

Change-Id: Icef35319d1582d8367c8911e15d11b0224957327
GitHub-Last-Rev: 2113e97e837c1ef5de9ba6a7bd62db92e644c500
GitHub-Pull-Request: golang/go#45005
Reviewed-on: https://go-review.googlesource.com/c/go/+/301632
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Josh Bleecher Snyder <josharian@gmail.com>
---
 misc/cgo/testplugin/testdata/method2/main.go  |  2 +-
 src/cmd/compile/internal/ssa/gen/S390XOps.go  |  2 +-
 src/cmd/cover/testdata/toolexec.go            |  2 +-
 src/cmd/go/testdata/addmod.go                 |  2 +-
 .../riscv/testdata/testbranch/branch_test.go  |  8 ++--
 src/cmd/link/internal/ld/elf.go               | 39 +++++++++----------
 .../ld/testdata/deadcode/ifacemethod3.go      |  2 +-
 src/runtime/testdata/testwinsignal/main.go    | 38 +++++++++---------
 8 files changed, 47 insertions(+), 48 deletions(-)

diff --git a/misc/cgo/testplugin/testdata/method2/main.go b/misc/cgo/testplugin/testdata/method2/main.go
index 6a87e7b6a0..89afbda3d4 100644
--- a/misc/cgo/testplugin/testdata/method2/main.go
+++ b/misc/cgo/testplugin/testdata/method2/main.go
@@ -15,7 +15,7 @@ import (
 
 var t p.T
 
-type I interface { M() }
+type I interface{ M() }
 
 func main() {
 	pl, err := plugin.Open("method2.so")
diff --git a/src/cmd/compile/internal/ssa/gen/S390XOps.go b/src/cmd/compile/internal/ssa/gen/S390XOps.go
index 1ddad1febd..5b33ba710e 100644
--- a/src/cmd/compile/internal/ssa/gen/S390XOps.go
+++ b/src/cmd/compile/internal/ssa/gen/S390XOps.go
@@ -381,7 +381,7 @@ func init() {
 		{name: "NOT", argLength: 1, reg: gp11, resultInArg0: true, clobberFlags: true},  // ^arg0
 		{name: "NOTW", argLength: 1, reg: gp11, resultInArg0: true, clobberFlags: true}, // ^arg0
 
-		{name: "FSQRT", argLength: 1, reg: fp11, asm: "FSQRT"}, // sqrt(arg0)
+		{name: "FSQRT", argLength: 1, reg: fp11, asm: "FSQRT"},   // sqrt(arg0)
 		{name: "FSQRTS", argLength: 1, reg: fp11, asm: "FSQRTS"}, // sqrt(arg0), float32
 
 		// Conditional register-register moves.
diff --git a/src/cmd/cover/testdata/toolexec.go b/src/cmd/cover/testdata/toolexec.go
index 386de79038..458adaeaaa 100644
--- a/src/cmd/cover/testdata/toolexec.go
+++ b/src/cmd/cover/testdata/toolexec.go
@@ -15,8 +15,8 @@
 package main
 
 import (
-	"os"
 	exec "internal/execabs"
+	"os"
 	"strings"
 )
 
diff --git a/src/cmd/go/testdata/addmod.go b/src/cmd/go/testdata/addmod.go
index 09fc8e713b..03869e68de 100644
--- a/src/cmd/go/testdata/addmod.go
+++ b/src/cmd/go/testdata/addmod.go
@@ -22,10 +22,10 @@ import (
 	"bytes"
 	"flag"
 	"fmt"
+	exec "internal/execabs"
 	"io/fs"
 	"log"
 	"os"
-	exec "internal/execabs"
 	"path/filepath"
 	"strings"
 
diff --git a/src/cmd/internal/obj/riscv/testdata/testbranch/branch_test.go b/src/cmd/internal/obj/riscv/testdata/testbranch/branch_test.go
index 3fa95222ff..de412c64a7 100644
--- a/src/cmd/internal/obj/riscv/testdata/testbranch/branch_test.go
+++ b/src/cmd/internal/obj/riscv/testdata/testbranch/branch_test.go
@@ -25,13 +25,13 @@ func testBLTU(a, b int64) (r bool)
 func testBLTZ(a int64) (r bool)
 func testBNEZ(a int64) (r bool)
 
-func testGoBGE(a, b int64) bool { return a >= b }
+func testGoBGE(a, b int64) bool  { return a >= b }
 func testGoBGEU(a, b int64) bool { return uint64(a) >= uint64(b) }
-func testGoBGT(a, b int64) bool { return a > b }
+func testGoBGT(a, b int64) bool  { return a > b }
 func testGoBGTU(a, b int64) bool { return uint64(a) > uint64(b) }
-func testGoBLE(a, b int64) bool { return a <= b }
+func testGoBLE(a, b int64) bool  { return a <= b }
 func testGoBLEU(a, b int64) bool { return uint64(a) <= uint64(b) }
-func testGoBLT(a, b int64) bool { return a < b }
+func testGoBLT(a, b int64) bool  { return a < b }
 func testGoBLTZ(a, b int64) bool { return uint64(a) < uint64(b) }
 
 func TestBranchCondition(t *testing.T) {
diff --git a/src/cmd/link/internal/ld/elf.go b/src/cmd/link/internal/ld/elf.go
index d3e598b312..b4af0931cc 100644
--- a/src/cmd/link/internal/ld/elf.go
+++ b/src/cmd/link/internal/ld/elf.go
@@ -522,22 +522,22 @@ func elfwriteinterp(out *OutBuf) int {
 // member of .gnu.attributes of MIPS for fpAbi
 const (
 	// No floating point is present in the module (default)
-	MIPS_FPABI_NONE    = 0
+	MIPS_FPABI_NONE = 0
 	// FP code in the module uses the FP32 ABI for a 32-bit ABI
-	MIPS_FPABI_ANY     = 1
+	MIPS_FPABI_ANY = 1
 	// FP code in the module only uses single precision ABI
-	MIPS_FPABI_SINGLE  = 2
+	MIPS_FPABI_SINGLE = 2
 	// FP code in the module uses soft-float ABI
-	MIPS_FPABI_SOFT    = 3
+	MIPS_FPABI_SOFT = 3
 	// FP code in the module assumes an FPU with FR=1 and has 12
 	// callee-saved doubles. Historic, no longer supported.
-	MIPS_FPABI_HIST    = 4
+	MIPS_FPABI_HIST = 4
 	// FP code in the module uses the FPXX  ABI
-	MIPS_FPABI_FPXX    = 5
+	MIPS_FPABI_FPXX = 5
 	// FP code in the module uses the FP64  ABI
-	MIPS_FPABI_FP64    = 6
+	MIPS_FPABI_FP64 = 6
 	// FP code in the module uses the FP64A ABI
-	MIPS_FPABI_FP64A   = 7
+	MIPS_FPABI_FP64A = 7
 )
 
 func elfMipsAbiFlags(sh *ElfShdr, startva uint64, resoff uint64) int {
@@ -585,7 +585,7 @@ func elfWriteMipsAbiFlags(ctxt *Link) int {
 	ctxt.Out.Write8(1)  // cpr1Size
 	ctxt.Out.Write8(0)  // cpr2Size
 	if objabi.GOMIPS == "softfloat" {
-		ctxt.Out.Write8(MIPS_FPABI_SOFT)  // fpAbi
+		ctxt.Out.Write8(MIPS_FPABI_SOFT) // fpAbi
 	} else {
 		// Go cannot make sure non odd-number-fpr is used (ie, in load a double from memory).
 		// So, we mark the object is MIPS I style paired float/double register scheme,
@@ -594,12 +594,12 @@ func elfWriteMipsAbiFlags(ctxt *Link) int {
 		// Note: MIPS_FPABI_ANY is bad naming: in fact it is MIPS I style FPR usage.
 		//       It is not for 'ANY'.
 		// TODO: switch to FPXX after be sure that no odd-number-fpr is used.
-		ctxt.Out.Write8(MIPS_FPABI_ANY)   // fpAbi
+		ctxt.Out.Write8(MIPS_FPABI_ANY) // fpAbi
 	}
-	ctxt.Out.Write32(0)  // isaExt
-	ctxt.Out.Write32(0)  // ases
-	ctxt.Out.Write32(0)  // flags1
-	ctxt.Out.Write32(0)  // flags2
+	ctxt.Out.Write32(0) // isaExt
+	ctxt.Out.Write32(0) // ases
+	ctxt.Out.Write32(0) // flags1
+	ctxt.Out.Write32(0) // flags2
 	return int(sh.Size)
 }
 
@@ -1538,7 +1538,6 @@ func (ctxt *Link) doelf() {
 		addgonote(ctxt, ".note.go.buildid", ELF_NOTE_GOBUILDID_TAG, []byte(*flagBuildid))
 	}
 
-
 	//type mipsGnuAttributes struct {
 	//	version uint8   // 'A'
 	//	length  uint32  // 15 including itself
@@ -1552,12 +1551,12 @@ func (ctxt *Link) doelf() {
 		gnuattributes := ldr.CreateSymForUpdate(".gnu.attributes", 0)
 		gnuattributes.SetType(sym.SELFROSECT)
 		gnuattributes.SetReachable(true)
-		gnuattributes.AddUint8('A')  // version 'A'
-		gnuattributes.AddUint32(ctxt.Arch, 15) // length 15 including itself
+		gnuattributes.AddUint8('A')               // version 'A'
+		gnuattributes.AddUint32(ctxt.Arch, 15)    // length 15 including itself
 		gnuattributes.AddBytes([]byte("gnu\x00")) // "gnu\0"
-		gnuattributes.AddUint8(1) // 1:file, 2: section, 3: symbol, 1 here
-		gnuattributes.AddUint32(ctxt.Arch, 7) // tag length, including tag, 7 here
-		gnuattributes.AddUint8(4) // 4 for FP, 8 for MSA
+		gnuattributes.AddUint8(1)                 // 1:file, 2: section, 3: symbol, 1 here
+		gnuattributes.AddUint32(ctxt.Arch, 7)     // tag length, including tag, 7 here
+		gnuattributes.AddUint8(4)                 // 4 for FP, 8 for MSA
 		if objabi.GOMIPS == "softfloat" {
 			gnuattributes.AddUint8(MIPS_FPABI_SOFT)
 		} else {
diff --git a/src/cmd/link/internal/ld/testdata/deadcode/ifacemethod3.go b/src/cmd/link/internal/ld/testdata/deadcode/ifacemethod3.go
index 9a8dfbce5f..37c89374cb 100644
--- a/src/cmd/link/internal/ld/testdata/deadcode/ifacemethod3.go
+++ b/src/cmd/link/internal/ld/testdata/deadcode/ifacemethod3.go
@@ -14,7 +14,7 @@ type S int
 
 func (s S) M() { println("S.M") }
 
-type I interface { M() }
+type I interface{ M() }
 
 type T float64
 
diff --git a/src/runtime/testdata/testwinsignal/main.go b/src/runtime/testdata/testwinsignal/main.go
index d8cd884ffa..1e7c9475fd 100644
--- a/src/runtime/testdata/testwinsignal/main.go
+++ b/src/runtime/testdata/testwinsignal/main.go
@@ -1,19 +1,19 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"os/signal"
-	"time"
-)
-
-func main() {
-	c := make(chan os.Signal, 1)
-	signal.Notify(c)
-
-	fmt.Println("ready")
-	sig := <-c
-
-	time.Sleep(time.Second)
-	fmt.Println(sig)
-}
+package main
+
+import (
+	"fmt"
+	"os"
+	"os/signal"
+	"time"
+)
+
+func main() {
+	c := make(chan os.Signal, 1)
+	signal.Notify(c)
+
+	fmt.Println("ready")
+	sig := <-c
+
+	time.Sleep(time.Second)
+	fmt.Println(sig)
+}
-- 
GitLab


From 661f3f15d5c96704a2fe9e91c6c40f73ff896606 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Mon, 15 Mar 2021 23:10:21 +0100
Subject: [PATCH 1097/2400] net: fix BenchmarkWriteToReadFromUDP on Windows

Using 0.0.0.0 for ListenUDP listens on all addresses. Calling LocalAddr
on that Conn returns 0.0.0.0. Sending to 0.0.0.0 doesn't seem to work on
Windows. See #22827.

Change-Id: I4a48fbabe65a63e07600a65309977cec08a9c1e5
Reviewed-on: https://go-review.googlesource.com/c/go/+/301850
Run-TryBot: Filippo Valsorda <filippo@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
Trust: Filippo Valsorda <filippo@golang.org>
---
 src/net/udpsock_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/net/udpsock_test.go b/src/net/udpsock_test.go
index 8aa64baefe..b4000b5664 100644
--- a/src/net/udpsock_test.go
+++ b/src/net/udpsock_test.go
@@ -447,7 +447,7 @@ func TestUDPReadSizeError(t *testing.T) {
 }
 
 func BenchmarkWriteToReadFromUDP(b *testing.B) {
-	conn, err := ListenUDP("udp4", new(UDPAddr))
+	conn, err := ListenUDP("udp4", &UDPAddr{IP: IPv4(127, 0, 0, 1)})
 	if err != nil {
 		b.Fatal(err)
 	}
-- 
GitLab


From d7cc2f1d7c60b51c600c7d0c808610985dcd9b0c Mon Sep 17 00:00:00 2001
From: Paschalis Tsilias <paschalis.tsilias@gmail.com>
Date: Fri, 15 Jan 2021 17:40:20 +0200
Subject: [PATCH 1098/2400] reflect: panic if ArrayOf is called with negative
 length

Since we cannot change the signature of reflect.ArrayOf to return an
error, we panic instead of producing a wrong result.

Fixes #43603

Change-Id: I23915df8d190f35af4d00ab86768868cd621e839
Reviewed-on: https://go-review.googlesource.com/c/go/+/284136
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/reflect/all_test.go |  8 ++++++++
 src/reflect/type.go     | 40 ++++++++++++++++++++++------------------
 2 files changed, 30 insertions(+), 18 deletions(-)

diff --git a/src/reflect/all_test.go b/src/reflect/all_test.go
index 35cc469d74..accda7fa74 100644
--- a/src/reflect/all_test.go
+++ b/src/reflect/all_test.go
@@ -4636,6 +4636,14 @@ func TestArrayOfDirectIface(t *testing.T) {
 	}
 }
 
+// Ensure passing in negative lengths panics.
+// See https://golang.org/issue/43603
+func TestArrayOfPanicOnNegativeLength(t *testing.T) {
+	shouldPanic("reflect: negative length passed to ArrayOf", func() {
+		ArrayOf(-1, TypeOf(byte(0)))
+	})
+}
+
 func TestSliceOf(t *testing.T) {
 	// check construction and use of type not in binary
 	type T int
diff --git a/src/reflect/type.go b/src/reflect/type.go
index dc235ea8f7..c213b31941 100644
--- a/src/reflect/type.go
+++ b/src/reflect/type.go
@@ -2835,22 +2835,26 @@ func typeptrdata(t *rtype) uintptr {
 // See cmd/compile/internal/gc/reflect.go for derivation of constant.
 const maxPtrmaskBytes = 2048
 
-// ArrayOf returns the array type with the given count and element type.
+// ArrayOf returns the array type with the given length and element type.
 // For example, if t represents int, ArrayOf(5, t) represents [5]int.
 //
 // If the resulting type would be larger than the available address space,
 // ArrayOf panics.
-func ArrayOf(count int, elem Type) Type {
+func ArrayOf(length int, elem Type) Type {
+	if length < 0 {
+		panic("reflect: negative length passed to ArrayOf")
+	}
+
 	typ := elem.(*rtype)
 
 	// Look in cache.
-	ckey := cacheKey{Array, typ, nil, uintptr(count)}
+	ckey := cacheKey{Array, typ, nil, uintptr(length)}
 	if array, ok := lookupCache.Load(ckey); ok {
 		return array.(Type)
 	}
 
 	// Look in known types.
-	s := "[" + strconv.Itoa(count) + "]" + typ.String()
+	s := "[" + strconv.Itoa(length) + "]" + typ.String()
 	for _, tt := range typesByString(s) {
 		array := (*arrayType)(unsafe.Pointer(tt))
 		if array.elem == typ {
@@ -2866,7 +2870,7 @@ func ArrayOf(count int, elem Type) Type {
 	array.tflag = typ.tflag & tflagRegularMemory
 	array.str = resolveReflectName(newName(s, "", false))
 	array.hash = fnv1(typ.hash, '[')
-	for n := uint32(count); n > 0; n >>= 8 {
+	for n := uint32(length); n > 0; n >>= 8 {
 		array.hash = fnv1(array.hash, byte(n))
 	}
 	array.hash = fnv1(array.hash, ']')
@@ -2874,17 +2878,17 @@ func ArrayOf(count int, elem Type) Type {
 	array.ptrToThis = 0
 	if typ.size > 0 {
 		max := ^uintptr(0) / typ.size
-		if uintptr(count) > max {
+		if uintptr(length) > max {
 			panic("reflect.ArrayOf: array size would exceed virtual address space")
 		}
 	}
-	array.size = typ.size * uintptr(count)
-	if count > 0 && typ.ptrdata != 0 {
-		array.ptrdata = typ.size*uintptr(count-1) + typ.ptrdata
+	array.size = typ.size * uintptr(length)
+	if length > 0 && typ.ptrdata != 0 {
+		array.ptrdata = typ.size*uintptr(length-1) + typ.ptrdata
 	}
 	array.align = typ.align
 	array.fieldAlign = typ.fieldAlign
-	array.len = uintptr(count)
+	array.len = uintptr(length)
 	array.slice = SliceOf(elem).(*rtype)
 
 	switch {
@@ -2893,7 +2897,7 @@ func ArrayOf(count int, elem Type) Type {
 		array.gcdata = nil
 		array.ptrdata = 0
 
-	case count == 1:
+	case length == 1:
 		// In memory, 1-element array looks just like the element.
 		array.kind |= typ.kind & kindGCProg
 		array.gcdata = typ.gcdata
@@ -2902,7 +2906,7 @@ func ArrayOf(count int, elem Type) Type {
 	case typ.kind&kindGCProg == 0 && array.size <= maxPtrmaskBytes*8*ptrSize:
 		// Element is small with pointer mask; array is still small.
 		// Create direct pointer mask by turning each 1 bit in elem
-		// into count 1 bits in larger mask.
+		// into length 1 bits in larger mask.
 		mask := make([]byte, (array.ptrdata/ptrSize+7)/8)
 		emitGCMask(mask, 0, typ, array.len)
 		array.gcdata = &mask[0]
@@ -2923,14 +2927,14 @@ func ArrayOf(count int, elem Type) Type {
 				prog = appendVarint(prog, elemWords-elemPtrs-1)
 			}
 		}
-		// Repeat count-1 times.
+		// Repeat length-1 times.
 		if elemWords < 0x80 {
 			prog = append(prog, byte(elemWords|0x80))
 		} else {
 			prog = append(prog, 0x80)
 			prog = appendVarint(prog, elemWords)
 		}
-		prog = appendVarint(prog, uintptr(count)-1)
+		prog = appendVarint(prog, uintptr(length)-1)
 		prog = append(prog, 0)
 		*(*uint32)(unsafe.Pointer(&prog[0])) = uint32(len(prog) - 4)
 		array.kind |= kindGCProg
@@ -2944,9 +2948,9 @@ func ArrayOf(count int, elem Type) Type {
 	array.equal = nil
 	if eequal := etyp.equal; eequal != nil {
 		array.equal = func(p, q unsafe.Pointer) bool {
-			for i := 0; i < count; i++ {
-				pi := arrayAt(p, i, esize, "i < count")
-				qi := arrayAt(q, i, esize, "i < count")
+			for i := 0; i < length; i++ {
+				pi := arrayAt(p, i, esize, "i < length")
+				qi := arrayAt(q, i, esize, "i < length")
 				if !eequal(pi, qi) {
 					return false
 				}
@@ -2957,7 +2961,7 @@ func ArrayOf(count int, elem Type) Type {
 	}
 
 	switch {
-	case count == 1 && !ifaceIndir(typ):
+	case length == 1 && !ifaceIndir(typ):
 		// array of 1 direct iface type can be direct
 		array.kind |= kindDirectIface
 	default:
-- 
GitLab


From a9b3c4bd0602f95afc58328d9953534f5e5fe4f6 Mon Sep 17 00:00:00 2001
From: Joel Courtney <euphemize@gmail.com>
Date: Mon, 15 Mar 2021 22:28:31 +0000
Subject: [PATCH 1099/2400] time: add Time.IsDST() to check if its Location is
 in Daylight Savings Time

Fixes #42102

Change-Id: I2cd2fdf67c794c3e99ed1c24786f7f779da73962
GitHub-Last-Rev: bbfa92135734cbd55895012fa492e51686a7b58b
GitHub-Pull-Request: golang/go#42103
Reviewed-on: https://go-review.googlesource.com/c/go/+/264077
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Rob Pike <r@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/time/format.go        |  2 +-
 src/time/time.go          | 20 +++++++++++++-------
 src/time/time_test.go     | 36 ++++++++++++++++++++++++++++++++++++
 src/time/zoneinfo.go      | 37 +++++++++++++++++++++++--------------
 src/time/zoneinfo_read.go |  2 +-
 src/time/zoneinfo_test.go | 23 ++++++++++++-----------
 6 files changed, 86 insertions(+), 34 deletions(-)

diff --git a/src/time/format.go b/src/time/format.go
index f11fb7ed30..c4f3358f59 100644
--- a/src/time/format.go
+++ b/src/time/format.go
@@ -1152,7 +1152,7 @@ func parse(layout, value string, defaultLocation, local *Location) (Time, error)
 
 		// Look for local zone with the given offset.
 		// If that zone was in effect at the given time, use it.
-		name, offset, _, _ := local.lookup(t.unixSec())
+		name, offset, _, _, _ := local.lookup(t.unixSec())
 		if offset == zoneOffset && (zoneName == "" || name == zoneName) {
 			t.setLoc(local)
 			return t, nil
diff --git a/src/time/time.go b/src/time/time.go
index 8ae62308e5..7e5192a0c9 100644
--- a/src/time/time.go
+++ b/src/time/time.go
@@ -440,7 +440,7 @@ func (t Time) abs() uint64 {
 		if l.cacheZone != nil && l.cacheStart <= sec && sec < l.cacheEnd {
 			sec += int64(l.cacheZone.offset)
 		} else {
-			_, offset, _, _ := l.lookup(sec)
+			_, offset, _, _, _ := l.lookup(sec)
 			sec += int64(offset)
 		}
 	}
@@ -461,7 +461,7 @@ func (t Time) locabs() (name string, offset int, abs uint64) {
 			name = l.cacheZone.name
 			offset = l.cacheZone.offset
 		} else {
-			name, offset, _, _ = l.lookup(sec)
+			name, offset, _, _, _ = l.lookup(sec)
 		}
 		sec += int64(offset)
 	} else {
@@ -1114,7 +1114,7 @@ func (t Time) Location() *Location {
 // Zone computes the time zone in effect at time t, returning the abbreviated
 // name of the zone (such as "CET") and its offset in seconds east of UTC.
 func (t Time) Zone() (name string, offset int) {
-	name, offset, _, _ = t.loc.lookup(t.unixSec())
+	name, offset, _, _, _ = t.loc.lookup(t.unixSec())
 	return
 }
 
@@ -1212,7 +1212,7 @@ func (t *Time) UnmarshalBinary(data []byte) error {
 
 	if offset == -1*60 {
 		t.setLoc(&utcLoc)
-	} else if _, localoff, _, _ := Local.lookup(t.unixSec()); offset == localoff {
+	} else if _, localoff, _, _, _ := Local.lookup(t.unixSec()); offset == localoff {
 		t.setLoc(Local)
 	} else {
 		t.setLoc(FixedZone("", offset))
@@ -1302,6 +1302,12 @@ func Unix(sec int64, nsec int64) Time {
 	return unixTime(sec, int32(nsec))
 }
 
+// IsDST reports whether the time in the configured location is in Daylight Savings Time.
+func (t *Time) IsDST() bool {
+	_, _, _, _, isDST := t.loc.lookup(t.Unix())
+	return isDST
+}
+
 func isLeap(year int) bool {
 	return year%4 == 0 && (year%100 != 0 || year%400 == 0)
 }
@@ -1377,13 +1383,13 @@ func Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) T
 	// The lookup function expects UTC, so we pass t in the
 	// hope that it will not be too close to a zone transition,
 	// and then adjust if it is.
-	_, offset, start, end := loc.lookup(unix)
+	_, offset, start, end, _ := loc.lookup(unix)
 	if offset != 0 {
 		switch utc := unix - int64(offset); {
 		case utc < start:
-			_, offset, _, _ = loc.lookup(start - 1)
+			_, offset, _, _, _ = loc.lookup(start - 1)
 		case utc >= end:
-			_, offset, _, _ = loc.lookup(end)
+			_, offset, _, _, _ = loc.lookup(end)
 		}
 		unix -= int64(offset)
 	}
diff --git a/src/time/time_test.go b/src/time/time_test.go
index 154198a1ce..8884731e1d 100644
--- a/src/time/time_test.go
+++ b/src/time/time_test.go
@@ -1465,3 +1465,39 @@ func TestConcurrentTimerResetStop(t *testing.T) {
 	}
 	wg.Wait()
 }
+
+func TestTimeIsDST(t *testing.T) {
+	ForceZipFileForTesting(true)
+	defer ForceZipFileForTesting(false)
+
+	tzWithDST, err := LoadLocation("Australia/Sydney")
+	if err != nil {
+		t.Fatalf("could not load tz 'Australia/Sydney': %v", err)
+	}
+	tzWithoutDST, err := LoadLocation("Australia/Brisbane")
+	if err != nil {
+		t.Fatalf("could not load tz 'Australia/Brisbane': %v", err)
+	}
+	tzFixed := FixedZone("FIXED_TIME", 12345)
+
+	tests := [...]struct {
+		time   Time
+		want bool
+	}{
+		0: {Date(2009, 1, 1, 12, 0, 0, 0, UTC), false},
+		1: {Date(2009, 6, 1, 12, 0, 0, 0, UTC), false},
+		2: {Date(2009, 1, 1, 12, 0, 0, 0, tzWithDST), true},
+		3: {Date(2009, 6, 1, 12, 0, 0, 0, tzWithDST), false},
+		4: {Date(2009, 1, 1, 12, 0, 0, 0, tzWithoutDST), false},
+		5: {Date(2009, 6, 1, 12, 0, 0, 0, tzWithoutDST), false},
+		6: {Date(2009, 1, 1, 12, 0, 0, 0, tzFixed), false},
+		7: {Date(2009, 6, 1, 12, 0, 0, 0, tzFixed), false},
+	}
+
+	for i, tt := range tests {
+		got := tt.time.IsDST()
+		if got != tt.want {
+			t.Errorf("#%d:: (%#v).IsDST()=%t, want %t", i, tt.time.Format(RFC3339), got, tt.want)
+		}
+	}
+}
diff --git a/src/time/zoneinfo.go b/src/time/zoneinfo.go
index 6db9443474..57aed03fec 100644
--- a/src/time/zoneinfo.go
+++ b/src/time/zoneinfo.go
@@ -121,7 +121,7 @@ func FixedZone(name string, offset int) *Location {
 // the start and end times bracketing sec when that zone is in effect,
 // the offset in seconds east of UTC (such as -5*60*60), and whether
 // the daylight savings is being observed at that time.
-func (l *Location) lookup(sec int64) (name string, offset int, start, end int64) {
+func (l *Location) lookup(sec int64) (name string, offset int, start, end int64, isDST bool) {
 	l = l.get()
 
 	if len(l.zone) == 0 {
@@ -129,6 +129,7 @@ func (l *Location) lookup(sec int64) (name string, offset int, start, end int64)
 		offset = 0
 		start = alpha
 		end = omega
+		isDST = false
 		return
 	}
 
@@ -137,6 +138,7 @@ func (l *Location) lookup(sec int64) (name string, offset int, start, end int64)
 		offset = zone.offset
 		start = l.cacheStart
 		end = l.cacheEnd
+		isDST = zone.isDST
 		return
 	}
 
@@ -150,6 +152,7 @@ func (l *Location) lookup(sec int64) (name string, offset int, start, end int64)
 		} else {
 			end = omega
 		}
+		isDST = zone.isDST
 		return
 	}
 
@@ -174,12 +177,13 @@ func (l *Location) lookup(sec int64) (name string, offset int, start, end int64)
 	offset = zone.offset
 	start = tx[lo].when
 	// end = maintained during the search
+	isDST = zone.isDST
 
 	// If we're at the end of the known zone transitions,
 	// try the extend string.
 	if lo == len(tx)-1 && l.extend != "" {
-		if ename, eoffset, estart, eend, ok := tzset(l.extend, end, sec); ok {
-			return ename, eoffset, estart, eend
+		if ename, eoffset, estart, eend, eisDST, ok := tzset(l.extend, end, sec); ok {
+			return ename, eoffset, estart, eend, eisDST
 		}
 	}
 
@@ -244,7 +248,7 @@ func (l *Location) firstZoneUsed() bool {
 // We call this a tzset string since in C the function tzset reads TZ.
 // The return values are as for lookup, plus ok which reports whether the
 // parse succeeded.
-func tzset(s string, initEnd, sec int64) (name string, offset int, start, end int64, ok bool) {
+func tzset(s string, initEnd, sec int64) (name string, offset int, start, end int64, isDST, ok bool) {
 	var (
 		stdName, dstName     string
 		stdOffset, dstOffset int
@@ -255,7 +259,7 @@ func tzset(s string, initEnd, sec int64) (name string, offset int, start, end in
 		stdOffset, s, ok = tzsetOffset(s)
 	}
 	if !ok {
-		return "", 0, 0, 0, false
+		return "", 0, 0, 0, false, false
 	}
 
 	// The numbers in the tzset string are added to local time to get UTC,
@@ -265,7 +269,7 @@ func tzset(s string, initEnd, sec int64) (name string, offset int, start, end in
 
 	if len(s) == 0 || s[0] == ',' {
 		// No daylight savings time.
-		return stdName, stdOffset, initEnd, omega, true
+		return stdName, stdOffset, initEnd, omega, false, true
 	}
 
 	dstName, s, ok = tzsetName(s)
@@ -278,7 +282,7 @@ func tzset(s string, initEnd, sec int64) (name string, offset int, start, end in
 		}
 	}
 	if !ok {
-		return "", 0, 0, 0, false
+		return "", 0, 0, 0, false, false
 	}
 
 	if len(s) == 0 {
@@ -287,19 +291,19 @@ func tzset(s string, initEnd, sec int64) (name string, offset int, start, end in
 	}
 	// The TZ definition does not mention ';' here but tzcode accepts it.
 	if s[0] != ',' && s[0] != ';' {
-		return "", 0, 0, 0, false
+		return "", 0, 0, 0, false, false
 	}
 	s = s[1:]
 
 	var startRule, endRule rule
 	startRule, s, ok = tzsetRule(s)
 	if !ok || len(s) == 0 || s[0] != ',' {
-		return "", 0, 0, 0, false
+		return "", 0, 0, 0, false, false
 	}
 	s = s[1:]
 	endRule, s, ok = tzsetRule(s)
 	if !ok || len(s) > 0 {
-		return "", 0, 0, 0, false
+		return "", 0, 0, 0, false, false
 	}
 
 	year, _, _, yday := absDate(uint64(sec+unixToInternal+internalToAbsolute), false)
@@ -313,10 +317,15 @@ func tzset(s string, initEnd, sec int64) (name string, offset int, start, end in
 
 	startSec := int64(tzruleTime(year, startRule, stdOffset))
 	endSec := int64(tzruleTime(year, endRule, dstOffset))
+	dstIsDST, stdIsDST := true, false
+	// Note: this is a flipping of "DST" and "STD" while retaining the labels
+	// This happens in southern hemispheres. The labelling here thus is a little
+	// inconsistent with the goal.
 	if endSec < startSec {
 		startSec, endSec = endSec, startSec
 		stdName, dstName = dstName, stdName
 		stdOffset, dstOffset = dstOffset, stdOffset
+		stdIsDST, dstIsDST = dstIsDST, stdIsDST
 	}
 
 	// The start and end values that we return are accurate
@@ -324,11 +333,11 @@ func tzset(s string, initEnd, sec int64) (name string, offset int, start, end in
 	// just the start and end of the year. That suffices for
 	// the only caller that cares, which is Date.
 	if ysec < startSec {
-		return stdName, stdOffset, abs, startSec + abs, true
+		return stdName, stdOffset, abs, startSec + abs, stdIsDST, true
 	} else if ysec >= endSec {
-		return stdName, stdOffset, endSec + abs, abs + 365*secondsPerDay, true
+		return stdName, stdOffset, endSec + abs, abs + 365*secondsPerDay, stdIsDST, true
 	} else {
-		return dstName, dstOffset, startSec + abs, endSec + abs, true
+		return dstName, dstOffset, startSec + abs, endSec + abs, dstIsDST, true
 	}
 }
 
@@ -587,7 +596,7 @@ func (l *Location) lookupName(name string, unix int64) (offset int, ok bool) {
 	for i := range l.zone {
 		zone := &l.zone[i]
 		if zone.name == name {
-			nam, offset, _, _ := l.lookup(unix - int64(zone.offset))
+			nam, offset, _, _, _ := l.lookup(unix - int64(zone.offset))
 			if nam == zone.name {
 				return offset, true
 			}
diff --git a/src/time/zoneinfo_read.go b/src/time/zoneinfo_read.go
index c739864815..7ac25b1e62 100644
--- a/src/time/zoneinfo_read.go
+++ b/src/time/zoneinfo_read.go
@@ -329,7 +329,7 @@ func LoadLocationFromTZData(name string, data []byte) (*Location, error) {
 			} else if l.extend != "" {
 				// If we're at the end of the known zone transitions,
 				// try the extend string.
-				if name, _, estart, eend, ok := tzset(l.extend, l.cacheEnd, sec); ok {
+				if name, _, estart, eend, _, ok := tzset(l.extend, l.cacheEnd, sec); ok {
 					l.cacheStart = estart
 					l.cacheEnd = eend
 					// Find the zone that is returned by tzset,
diff --git a/src/time/zoneinfo_test.go b/src/time/zoneinfo_test.go
index d043e1e9f1..a3f41d0356 100644
--- a/src/time/zoneinfo_test.go
+++ b/src/time/zoneinfo_test.go
@@ -239,20 +239,21 @@ func TestTzset(t *testing.T) {
 		off   int
 		start int64
 		end   int64
+		isDST bool
 		ok    bool
 	}{
-		{"", 0, 0, "", 0, 0, 0, false},
-		{"PST8PDT,M3.2.0,M11.1.0", 0, 2159200800, "PDT", -7 * 60 * 60, 2152173600, 2172733200, true},
-		{"PST8PDT,M3.2.0,M11.1.0", 0, 2152173599, "PST", -8 * 60 * 60, 2145916800, 2152173600, true},
-		{"PST8PDT,M3.2.0,M11.1.0", 0, 2152173600, "PDT", -7 * 60 * 60, 2152173600, 2172733200, true},
-		{"PST8PDT,M3.2.0,M11.1.0", 0, 2152173601, "PDT", -7 * 60 * 60, 2152173600, 2172733200, true},
-		{"PST8PDT,M3.2.0,M11.1.0", 0, 2172733199, "PDT", -7 * 60 * 60, 2152173600, 2172733200, true},
-		{"PST8PDT,M3.2.0,M11.1.0", 0, 2172733200, "PST", -8 * 60 * 60, 2172733200, 2177452800, true},
-		{"PST8PDT,M3.2.0,M11.1.0", 0, 2172733201, "PST", -8 * 60 * 60, 2172733200, 2177452800, true},
+		{"", 0, 0, "", 0, 0, 0, false, false},
+		{"PST8PDT,M3.2.0,M11.1.0", 0, 2159200800, "PDT", -7 * 60 * 60, 2152173600, 2172733200, true, true},
+		{"PST8PDT,M3.2.0,M11.1.0", 0, 2152173599, "PST", -8 * 60 * 60, 2145916800, 2152173600, false, true},
+		{"PST8PDT,M3.2.0,M11.1.0", 0, 2152173600, "PDT", -7 * 60 * 60, 2152173600, 2172733200, true, true},
+		{"PST8PDT,M3.2.0,M11.1.0", 0, 2152173601, "PDT", -7 * 60 * 60, 2152173600, 2172733200, true, true},
+		{"PST8PDT,M3.2.0,M11.1.0", 0, 2172733199, "PDT", -7 * 60 * 60, 2152173600, 2172733200, true, true},
+		{"PST8PDT,M3.2.0,M11.1.0", 0, 2172733200, "PST", -8 * 60 * 60, 2172733200, 2177452800, false, true},
+		{"PST8PDT,M3.2.0,M11.1.0", 0, 2172733201, "PST", -8 * 60 * 60, 2172733200, 2177452800, false, true},
 	} {
-		name, off, start, end, ok := time.Tzset(test.inStr, test.inEnd, test.inSec)
-		if name != test.name || off != test.off || start != test.start || end != test.end || ok != test.ok {
-			t.Errorf("tzset(%q, %d, %d) = %q, %d, %d, %d, %t, want %q, %d, %d, %d, %t", test.inStr, test.inEnd, test.inSec, name, off, start, end, ok, test.name, test.off, test.start, test.end, test.ok)
+		name, off, start, end, isDST, ok := time.Tzset(test.inStr, test.inEnd, test.inSec)
+		if name != test.name || off != test.off || start != test.start || end != test.end || isDST != test.isDST || ok != test.ok {
+			t.Errorf("tzset(%q, %d, %d) = %q, %d, %d, %d, %t, %t, want %q, %d, %d, %d, %t, %t", test.inStr, test.inEnd, test.inSec, name, off, start, end, isDST, ok, test.name, test.off, test.start, test.end, test.isDST, test.ok)
 		}
 	}
 }
-- 
GitLab


From f02a26bed0f21de7aeef7a60cf62dac2e3dab737 Mon Sep 17 00:00:00 2001
From: Emmanuel T Odeke <emmanuel@orijtech.com>
Date: Thu, 11 Mar 2021 17:34:09 -0800
Subject: [PATCH 1100/2400] time: support "," as separator for fractional
 seconds

Accepts comma "," as a separator for fractional seconds
hence we now accept:
* 2006-01-02 15:04:05,999999999 -0700 MST
* Mon Jan _2 15:04:05,120007 2006
* Mon Jan 2 15:04:05,120007 2006

This change follows the recommendations of ISO 8601 per

   https://en.wikipedia.org/wiki/ISO_8601#cite_note-26

which states

   ISO 8601:2004(E), ISO, 2004-12-01, "4.2.2.4 ...
   the decimal fraction shall be divided from the integer
   part by the decimal sign specified in ISO 31-0, i.e.
   the comma [,] or full stop [.]. Of these, the comma
   is the preferred sign."

Unfortunately, I couldn't directly access the ISO 8601 document
because suddenly it is behind a paywall on the ISO website,
charging CHF 158 (USD 179) for 38 pages :-(

However, this follows publicly available cited literature, as well
as the recommendations from the proposal approval.

Fixes #6189
Updates #27746
Updates #26002
Updates #36145
Updates #43813
Fixes #43823

Change-Id: Ibe96064e8ee27c239be78c880fa561a1a41e190c
Reviewed-on: https://go-review.googlesource.com/c/go/+/300996
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Rob Pike <r@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/time/format.go      | 30 ++++++++++++++++++------------
 src/time/format_test.go | 18 +++++++++++++++---
 2 files changed, 33 insertions(+), 15 deletions(-)

diff --git a/src/time/format.go b/src/time/format.go
index c4f3358f59..7586035872 100644
--- a/src/time/format.go
+++ b/src/time/format.go
@@ -26,13 +26,14 @@ import "errors"
 // compatibility with fixed-width Unix time formats.
 //
 // A decimal point followed by one or more zeros represents a fractional
-// second, printed to the given number of decimal places. A decimal point
-// followed by one or more nines represents a fractional second, printed to
-// the given number of decimal places, with trailing zeros removed.
+// second, printed to the given number of decimal places.
+// Either a comma or decimal point followed by one or more nines represents
+// a fractional second, printed to the given number of decimal places, with
+// trailing zeros removed.
 // When parsing (only), the input may contain a fractional second
 // field immediately after the seconds field, even if the layout does not
-// signify its presence. In that case a decimal point followed by a maximal
-// series of digits is parsed as a fractional second.
+// signify its presence. In that case either a comma or a decimal point
+// followed by a maximal series of digits is parsed as a fractional second.
 //
 // Numeric time zone offsets format as follows:
 //	-0700  ±hhmm
@@ -261,7 +262,7 @@ func nextStdChunk(layout string) (prefix string, std int, suffix string) {
 				return layout[0:i], stdISO8601ShortTZ, layout[i+3:]
 			}
 
-		case '.': // .000 or .999 - repeated digits for fractional seconds.
+		case '.', ',': // ,000, or .000, or ,999, or .999 - repeated digits for fractional seconds.
 			if i+1 < len(layout) && (layout[i+1] == '0' || layout[i+1] == '9') {
 				ch := layout[i+1]
 				j := i + 1
@@ -484,9 +485,10 @@ func (t Time) String() string {
 // desired output. The same display rules will then be applied to the time
 // value.
 //
-// A fractional second is represented by adding a period and zeros
-// to the end of the seconds section of layout string, as in "15:04:05.000"
-// to format a time stamp with millisecond precision.
+// A fractional second is represented by adding either a comma or a
+// period and zeros to the end of the seconds section of layout string,
+// as in "15:04:05,000" or "15:04:05.000" to format a time stamp with
+// millisecond precision.
 //
 // Predefined layouts ANSIC, UnixDate, RFC3339 and others describe standard
 // and convenient representations of the reference time. For more information
@@ -940,7 +942,7 @@ func parse(layout, value string, defaultLocation, local *Location) (Time, error)
 			}
 			// Special case: do we have a fractional second but no
 			// fractional second in the format?
-			if len(value) >= 2 && value[0] == '.' && isDigit(value, 1) {
+			if len(value) >= 2 && commaOrPeriod(value[0]) && isDigit(value, 1) {
 				_, std, _ = nextStdChunk(layout)
 				std &= stdMask
 				if std == stdFracSecond0 || std == stdFracSecond9 {
@@ -1070,7 +1072,7 @@ func parse(layout, value string, defaultLocation, local *Location) (Time, error)
 			value = value[ndigit:]
 
 		case stdFracSecond9:
-			if len(value) < 2 || value[0] != '.' || value[1] < '0' || '9' < value[1] {
+			if len(value) < 2 || !commaOrPeriod(value[0]) || value[1] < '0' || '9' < value[1] {
 				// Fractional second omitted.
 				break
 			}
@@ -1279,8 +1281,12 @@ func parseSignedOffset(value string) int {
 	return len(value) - len(rem)
 }
 
+func commaOrPeriod(b byte) bool {
+	return b == '.' || b == ','
+}
+
 func parseNanoseconds(value string, nbytes int) (ns int, rangeErrString string, err error) {
-	if value[0] != '.' {
+	if !commaOrPeriod(value[0]) {
 		err = errBad
 		return
 	}
diff --git a/src/time/format_test.go b/src/time/format_test.go
index 4574d20319..9e96d4a295 100644
--- a/src/time/format_test.go
+++ b/src/time/format_test.go
@@ -207,9 +207,13 @@ var parseTests = []ParseTest{
 	{"ANSIC", ANSIC, "THU FEB 4 21:00:57 2010", false, true, 1, 0},
 	{"ANSIC", ANSIC, "thu feb 4 21:00:57 2010", false, true, 1, 0},
 	// Fractional seconds.
-	{"millisecond", "Mon Jan _2 15:04:05.000 2006", "Thu Feb  4 21:00:57.012 2010", false, true, 1, 3},
-	{"microsecond", "Mon Jan _2 15:04:05.000000 2006", "Thu Feb  4 21:00:57.012345 2010", false, true, 1, 6},
-	{"nanosecond", "Mon Jan _2 15:04:05.000000000 2006", "Thu Feb  4 21:00:57.012345678 2010", false, true, 1, 9},
+	{"millisecond:: dot separator", "Mon Jan _2 15:04:05.000 2006", "Thu Feb  4 21:00:57.012 2010", false, true, 1, 3},
+	{"microsecond:: dot separator", "Mon Jan _2 15:04:05.000000 2006", "Thu Feb  4 21:00:57.012345 2010", false, true, 1, 6},
+	{"nanosecond:: dot separator", "Mon Jan _2 15:04:05.000000000 2006", "Thu Feb  4 21:00:57.012345678 2010", false, true, 1, 9},
+	{"millisecond:: comma separator", "Mon Jan _2 15:04:05,000 2006", "Thu Feb  4 21:00:57.012 2010", false, true, 1, 3},
+	{"microsecond:: comma separator", "Mon Jan _2 15:04:05,000000 2006", "Thu Feb  4 21:00:57.012345 2010", false, true, 1, 6},
+	{"nanosecond:: comma separator", "Mon Jan _2 15:04:05,000000000 2006", "Thu Feb  4 21:00:57.012345678 2010", false, true, 1, 9},
+
 	// Leading zeros in other places should not be taken as fractional seconds.
 	{"zero1", "2006.01.02.15.04.05.0", "2010.02.04.21.00.57.0", false, false, 1, 1},
 	{"zero2", "2006.01.02.15.04.05.00", "2010.02.04.21.00.57.01", false, false, 1, 2},
@@ -222,12 +226,20 @@ var parseTests = []ParseTest{
 	// Accept any number of fractional second digits (including none) for .999...
 	// In Go 1, .999... was completely ignored in the format, meaning the first two
 	// cases would succeed, but the next four would not. Go 1.1 accepts all six.
+	// decimal "." separator.
 	{"", "2006-01-02 15:04:05.9999 -0700 MST", "2010-02-04 21:00:57 -0800 PST", true, false, 1, 0},
 	{"", "2006-01-02 15:04:05.999999999 -0700 MST", "2010-02-04 21:00:57 -0800 PST", true, false, 1, 0},
 	{"", "2006-01-02 15:04:05.9999 -0700 MST", "2010-02-04 21:00:57.0123 -0800 PST", true, false, 1, 4},
 	{"", "2006-01-02 15:04:05.999999999 -0700 MST", "2010-02-04 21:00:57.0123 -0800 PST", true, false, 1, 4},
 	{"", "2006-01-02 15:04:05.9999 -0700 MST", "2010-02-04 21:00:57.012345678 -0800 PST", true, false, 1, 9},
 	{"", "2006-01-02 15:04:05.999999999 -0700 MST", "2010-02-04 21:00:57.012345678 -0800 PST", true, false, 1, 9},
+	// comma "," separator.
+	{"", "2006-01-02 15:04:05,9999 -0700 MST", "2010-02-04 21:00:57 -0800 PST", true, false, 1, 0},
+	{"", "2006-01-02 15:04:05,999999999 -0700 MST", "2010-02-04 21:00:57 -0800 PST", true, false, 1, 0},
+	{"", "2006-01-02 15:04:05,9999 -0700 MST", "2010-02-04 21:00:57.0123 -0800 PST", true, false, 1, 4},
+	{"", "2006-01-02 15:04:05,999999999 -0700 MST", "2010-02-04 21:00:57.0123 -0800 PST", true, false, 1, 4},
+	{"", "2006-01-02 15:04:05,9999 -0700 MST", "2010-02-04 21:00:57.012345678 -0800 PST", true, false, 1, 9},
+	{"", "2006-01-02 15:04:05,999999999 -0700 MST", "2010-02-04 21:00:57.012345678 -0800 PST", true, false, 1, 9},
 
 	// issue 4502.
 	{"", StampNano, "Feb  4 21:00:57.012345678", false, false, -1, 9},
-- 
GitLab


From 78f90152364d68268a14b2907ae26379f314baf4 Mon Sep 17 00:00:00 2001
From: Meng Zhuo <mzh@golangcn.org>
Date: Mon, 15 Mar 2021 19:48:39 +0800
Subject: [PATCH 1101/2400] runtime: using wyhash for memhashFallback on 32bit
 platform
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

wyhash is a general hash function that:

1. Default hash function of Zig, Nim
2. Passed Smhasher, BigCrush and PractRand
3. Less code
4. 3~26% faster than internal hashmap

name                  old time/op    new time/op    delta
Hash5                   67.8ns ± 0%    65.4ns ± 0%   -3.45%  (p=0.000 n=7+10)
Hash16                  82.5ns ± 0%    74.2ns ± 0%  -10.12%  (p=0.000 n=6+8)
Hash64                   121ns ± 0%     102ns ± 0%  -15.82%  (p=0.000 n=7+10)
Hash1024                1.13µs ± 0%    0.89µs ± 0%  -20.58%  (p=0.000 n=10+9)
Hash65536               68.9µs ± 0%    54.4µs ± 0%  -21.04%  (p=0.000 n=10+7)
HashStringSpeed          103ns ± 2%      93ns ± 3%  -10.24%  (p=0.000 n=9+10)
HashBytesSpeed           191ns ± 2%     180ns ± 1%   -5.40%  (p=0.000 n=10+8)
HashInt32Speed          59.0ns ± 2%    59.1ns ± 1%     ~     (p=0.655 n=9+8)
HashInt64Speed          72.7ns ± 3%    66.1ns ± 5%   -9.04%  (p=0.000 n=10+10)
HashStringArraySpeed     270ns ± 1%     222ns ± 2%  -17.91%  (p=0.000 n=10+10)
FastrandHashiter         108ns ± 0%     109ns ± 1%   +0.96%  (p=0.002 n=10+10)

name                  old speed      new speed      delta
Hash5                 73.8MB/s ± 0%  76.4MB/s ± 0%   +3.58%  (p=0.000 n=7+10)
Hash16                 194MB/s ± 0%   216MB/s ± 0%  +11.25%  (p=0.000 n=10+8)
Hash64                 530MB/s ± 0%   630MB/s ± 0%  +18.74%  (p=0.000 n=8+10)
Hash1024               910MB/s ± 0%  1145MB/s ± 0%  +25.88%  (p=0.000 n=10+9)
Hash65536              951MB/s ± 0%  1204MB/s ± 0%  +26.64%  (p=0.000 n=10+7)

Update #43130

Change-Id: Id00c54b116a2411fcf675e95896fffb85f0e25b6
Reviewed-on: https://go-review.googlesource.com/c/go/+/280372
Trust: Meng Zhuo <mzh@golangcn.org>
Run-TryBot: Meng Zhuo <mzh@golangcn.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/runtime/hash32.go | 136 +++++++++++++-----------------------------
 1 file changed, 43 insertions(+), 93 deletions(-)

diff --git a/src/runtime/hash32.go b/src/runtime/hash32.go
index 7fa8eb7cab..7c22c76b87 100644
--- a/src/runtime/hash32.go
+++ b/src/runtime/hash32.go
@@ -3,8 +3,7 @@
 // license that can be found in the LICENSE file.
 
 // Hashing algorithm inspired by
-//   xxhash: https://code.google.com/p/xxhash/
-// cityhash: https://code.google.com/p/cityhash/
+// wyhash: https://github.com/wangyi-fudan/wyhash/blob/ceb019b530e2c1c14d70b79bfa2bc49de7d95bc1/Modern%20Non-Cryptographic%20Hash%20Function%20and%20Pseudorandom%20Number%20Generator.pdf
 
 //go:build 386 || arm || mips || mipsle
 // +build 386 arm mips mipsle
@@ -13,101 +12,52 @@ package runtime
 
 import "unsafe"
 
-const (
-	// Constants for multiplication: four random odd 32-bit numbers.
-	m1 = 3168982561
-	m2 = 3339683297
-	m3 = 832293441
-	m4 = 2336365089
-)
-
-func memhashFallback(p unsafe.Pointer, seed, s uintptr) uintptr {
-	h := uint32(seed + s*hashkey[0])
-tail:
-	switch {
-	case s == 0:
-	case s < 4:
-		h ^= uint32(*(*byte)(p))
-		h ^= uint32(*(*byte)(add(p, s>>1))) << 8
-		h ^= uint32(*(*byte)(add(p, s-1))) << 16
-		h = rotl_15(h*m1) * m2
-	case s == 4:
-		h ^= readUnaligned32(p)
-		h = rotl_15(h*m1) * m2
-	case s <= 8:
-		h ^= readUnaligned32(p)
-		h = rotl_15(h*m1) * m2
-		h ^= readUnaligned32(add(p, s-4))
-		h = rotl_15(h*m1) * m2
-	case s <= 16:
-		h ^= readUnaligned32(p)
-		h = rotl_15(h*m1) * m2
-		h ^= readUnaligned32(add(p, 4))
-		h = rotl_15(h*m1) * m2
-		h ^= readUnaligned32(add(p, s-8))
-		h = rotl_15(h*m1) * m2
-		h ^= readUnaligned32(add(p, s-4))
-		h = rotl_15(h*m1) * m2
-	default:
-		v1 := h
-		v2 := uint32(seed * hashkey[1])
-		v3 := uint32(seed * hashkey[2])
-		v4 := uint32(seed * hashkey[3])
-		for s >= 16 {
-			v1 ^= readUnaligned32(p)
-			v1 = rotl_15(v1*m1) * m2
-			p = add(p, 4)
-			v2 ^= readUnaligned32(p)
-			v2 = rotl_15(v2*m2) * m3
-			p = add(p, 4)
-			v3 ^= readUnaligned32(p)
-			v3 = rotl_15(v3*m3) * m4
-			p = add(p, 4)
-			v4 ^= readUnaligned32(p)
-			v4 = rotl_15(v4*m4) * m1
-			p = add(p, 4)
-			s -= 16
-		}
-		h = v1 ^ v2 ^ v3 ^ v4
-		goto tail
-	}
-	h ^= h >> 17
-	h *= m3
-	h ^= h >> 13
-	h *= m4
-	h ^= h >> 16
-	return uintptr(h)
-}
-
 func memhash32Fallback(p unsafe.Pointer, seed uintptr) uintptr {
-	h := uint32(seed + 4*hashkey[0])
-	h ^= readUnaligned32(p)
-	h = rotl_15(h*m1) * m2
-	h ^= h >> 17
-	h *= m3
-	h ^= h >> 13
-	h *= m4
-	h ^= h >> 16
-	return uintptr(h)
+	a, b := mix32(uint32(seed), uint32(4^hashkey[0]))
+	t := readUnaligned32(p)
+	a ^= t
+	b ^= t
+	a, b = mix32(a, b)
+	a, b = mix32(a, b)
+	return uintptr(a ^ b)
 }
 
 func memhash64Fallback(p unsafe.Pointer, seed uintptr) uintptr {
-	h := uint32(seed + 8*hashkey[0])
-	h ^= readUnaligned32(p)
-	h = rotl_15(h*m1) * m2
-	h ^= readUnaligned32(add(p, 4))
-	h = rotl_15(h*m1) * m2
-	h ^= h >> 17
-	h *= m3
-	h ^= h >> 13
-	h *= m4
-	h ^= h >> 16
-	return uintptr(h)
+	a, b := mix32(uint32(seed), uint32(8^hashkey[0]))
+	a ^= readUnaligned32(p)
+	b ^= readUnaligned32(add(p, 4))
+	a, b = mix32(a, b)
+	a, b = mix32(a, b)
+	return uintptr(a ^ b)
+}
+
+func memhashFallback(p unsafe.Pointer, seed, s uintptr) uintptr {
+
+	a, b := mix32(uint32(seed), uint32(s^hashkey[0]))
+	if s == 0 {
+		return uintptr(a ^ b)
+	}
+	for ; s > 8; s -= 8 {
+		a ^= readUnaligned32(p)
+		b ^= readUnaligned32(add(p, 4))
+		a, b = mix32(a, b)
+		p = add(p, 8)
+	}
+	if s >= 4 {
+		a ^= readUnaligned32(p)
+		b ^= readUnaligned32(add(p, s-4))
+	} else {
+		t := uint32(*(*byte)(p))
+		t |= uint32(*(*byte)(add(p, s>>1))) << 8
+		t |= uint32(*(*byte)(add(p, s-1))) << 16
+		b ^= t
+	}
+	a, b = mix32(a, b)
+	a, b = mix32(a, b)
+	return uintptr(a ^ b)
 }
 
-// Note: in order to get the compiler to issue rotl instructions, we
-// need to constant fold the shift amount by hand.
-// TODO: convince the compiler to issue rotl instructions after inlining.
-func rotl_15(x uint32) uint32 {
-	return (x << 15) | (x >> (32 - 15))
+func mix32(a, b uint32) (uint32, uint32) {
+	c := uint64(a^uint32(hashkey[1])) * uint64(b^uint32(hashkey[2]))
+	return uint32(c), uint32(c >> 32)
 }
-- 
GitLab


From 15f16706fb93a0720decd175ad2147be96a8e1e4 Mon Sep 17 00:00:00 2001
From: Andy Pan <panjf2000@gmail.com>
Date: Sun, 14 Mar 2021 13:19:12 +0800
Subject: [PATCH 1102/2400] internal/poll: eliminate the redundant type
 conversions of FD.Sysfd

Change-Id: Ib75662f717320510319c696520e645f54eec97f7
Reviewed-on: https://go-review.googlesource.com/c/go/+/301569
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/internal/poll/sendfile_bsd.go     | 2 +-
 src/internal/poll/sendfile_linux.go   | 2 +-
 src/internal/poll/sendfile_solaris.go | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/internal/poll/sendfile_bsd.go b/src/internal/poll/sendfile_bsd.go
index 9eda85882c..3ba30a2154 100644
--- a/src/internal/poll/sendfile_bsd.go
+++ b/src/internal/poll/sendfile_bsd.go
@@ -23,7 +23,7 @@ func SendFile(dstFD *FD, src int, pos, remain int64) (int64, error) {
 		return 0, err
 	}
 
-	dst := int(dstFD.Sysfd)
+	dst := dstFD.Sysfd
 	var written int64
 	var err error
 	for remain > 0 {
diff --git a/src/internal/poll/sendfile_linux.go b/src/internal/poll/sendfile_linux.go
index d6442e8666..6e7852347b 100644
--- a/src/internal/poll/sendfile_linux.go
+++ b/src/internal/poll/sendfile_linux.go
@@ -20,7 +20,7 @@ func SendFile(dstFD *FD, src int, remain int64) (int64, error) {
 		return 0, err
 	}
 
-	dst := int(dstFD.Sysfd)
+	dst := dstFD.Sysfd
 	var written int64
 	var err error
 	for remain > 0 {
diff --git a/src/internal/poll/sendfile_solaris.go b/src/internal/poll/sendfile_solaris.go
index 748c85131e..0a884307bb 100644
--- a/src/internal/poll/sendfile_solaris.go
+++ b/src/internal/poll/sendfile_solaris.go
@@ -24,7 +24,7 @@ func SendFile(dstFD *FD, src int, pos, remain int64) (int64, error) {
 		return 0, err
 	}
 
-	dst := int(dstFD.Sysfd)
+	dst := dstFD.Sysfd
 	var written int64
 	var err error
 	for remain > 0 {
-- 
GitLab


From 051bf37833780726aacf3c88f1bbec56b3540b34 Mon Sep 17 00:00:00 2001
From: eric fang <eric.fang@arm.com>
Date: Thu, 11 Jun 2020 09:35:24 +0000
Subject: [PATCH 1103/2400] cmd/compile/internal/ssa: handle more cases in fuse
 pass
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Currently fuseBlockIf handls four cases where s0 and s1 have only one predecessor
node. In fact, even if s0 and s1 have multiple predecessor nodes, it can be optimized
as well. This patch handles these cases.

This CL does not bring significant performance changes, it is more like an optimization
of dead code elimination. So it detects a lot of benchmarks whose functions are
completely optimized, such as BenchmarkNeIfaceConcrete, BenchmarkEqIfaceConcrete,
BenchmarkFullJapaneseRune, BenchmarkClearFat{8, 12, 16,...1024}, Benchmark{En|De}codeRune,
and BenchmarkCopyFat{8, 12, 16,...1024} and many others that I didn't check.

Test result of compilecmp on linux amd64, the data on linux arm64 is similar.
name                      old time/op                 new time/op                 delta
Template                    466131893.640000ns +-16%    455546571.480000ns +-12%    ~     (p=0.066 n=50+50)
Unicode                     195858206.980000ns +- 9%    197387526.224490ns +- 9%    ~     (p=0.231 n=50+49)
GoTypes                    1581961264.260000ns +- 7%   1581828319.640000ns +- 5%    ~     (p=0.964 n=50+50)
Compiler                   7425890449.259998ns +- 2%   7424138343.632654ns +- 2%    ~     (p=0.815 n=50+49)
SSA                       17392652203.380009ns +- 1%  17248314507.854172ns +- 1%  -0.83%  (p=0.000 n=50+48)
Flate                       298061504.940000ns +-12%    292773080.632653ns +-12%    ~     (p=0.165 n=50+49)
GoParser                    376046929.420000ns +- 9%    370746254.693878ns +- 9%    ~     (p=0.231 n=50+49)
Reflect                     995721330.160000ns +- 7%    985916024.620000ns +- 7%    ~     (p=0.103 n=50+50)
Tar                         398878287.040000ns +-10%    399186737.000000ns +-11%    ~     (p=0.883 n=50+50)
XML                         555898064.200000ns +- 8%    554877077.100000ns +-10%    ~     (p=0.926 n=50+50)
LinkCompiler                757995424.632653ns +- 7%    758301900.420000ns +- 7%    ~     (p=0.437 n=49+50)
ExternalLinkCompiler       2399985741.270834ns +- 4%   2396112274.630435ns +- 4%    ~     (p=0.766 n=48+46)
LinkWithoutDebugCompiler    450472710.700000ns +- 9%    448935188.720000ns +- 7%    ~     (p=0.668 n=50+50)
[Geo mean]                   927951041.671984ns          922858781.007286ns       -0.55%

name                      old user-time/op            new user-time/op            delta
Template                    639484500.000000ns +-16%    630857140.000000ns +-13%    ~     (p=0.363 n=50+50)
Unicode                     370072081.632653ns +-11%    375108300.000000ns +-10%    ~     (p=0.248 n=49+50)
GoTypes                    2205838860.000000ns +- 5%   2206640900.000000ns +- 3%    ~     (p=0.915 n=50+50)
Compiler                  10337224272.727268ns +- 2%  10366187152.173916ns +- 2%    ~     (p=0.324 n=44+46)
SSA                       23843616104.166660ns +- 3%  23678281387.755112ns +- 3%  -0.69%  (p=0.002 n=48+49)
Flate                       396446760.000000ns +-15%    391245333.333333ns +-10%    ~     (p=0.313 n=50+48)
GoParser                    509121660.000000ns +-10%    505938620.000000ns +- 9%    ~     (p=0.436 n=50+50)
Reflect                    1328136212.765958ns +- 6%   1312627440.000000ns +- 8%    ~     (p=0.068 n=47+50)
Tar                         563039480.000000ns +-10%    563064360.000000ns +-10%    ~     (p=0.953 n=50+50)
XML                         775596380.000000ns +- 9%    774736920.000000ns +-11%    ~     (p=0.899 n=50+50)
LinkCompiler               1315155260.000000ns +- 9%   1312946860.000001ns +- 6%    ~     (p=0.861 n=50+50)
ExternalLinkCompiler       2739635480.000000ns +- 6%   2732580380.000000ns +- 6%    ~     (p=0.943 n=50+50)
LinkWithoutDebugCompiler    537418600.000000ns +-10%    535914620.000000ns +- 9%    ~     (p=0.734 n=50+50)
[Geo mean]                  1296231259.389525ns         1291929605.124197ns       -0.33%

name                      old alloc/op                new alloc/op                delta
Template                                35.0MB +- 0%                35.0MB +- 0%    ~     (p=0.586 n=50+50)
Unicode                                 29.3MB +- 0%                29.3MB +- 0%  +0.01%  (p=0.004 n=50+50)
GoTypes                                  116MB +- 0%                 116MB +- 0%    ~     (p=0.102 n=50+50)
Compiler                                 555MB +- 0%                 555MB +- 0%    ~     (p=0.285 n=50+50)
SSA                                     1.37GB +- 0%                1.36GB +- 0%  -0.98%  (p=0.000 n=49+49)
Flate                                   21.8MB +- 0%                21.8MB +- 0%    ~     (p=0.475 n=50+49)
GoParser                                26.7MB +- 0%                26.7MB +- 0%    ~     (p=0.385 n=50+50)
Reflect                                 74.2MB +- 0%                74.3MB +- 0%  +0.01%  (p=0.006 n=49+50)
Tar                                     32.7MB +- 0%                32.7MB +- 0%    ~     (p=0.125 n=50+50)
XML                                     41.8MB +- 0%                41.8MB +- 0%    ~     (p=0.649 n=49+50)
LinkCompiler                             105MB +- 0%                 105MB +- 0%  -0.05%  (p=0.000 n=50+48)
ExternalLinkCompiler                    92.6MB +- 0%                92.6MB +- 0%  -0.02%  (p=0.000 n=50+50)
LinkWithoutDebugCompiler                63.9MB +- 0%                63.9MB +- 0%  -0.05%  (p=0.000 n=50+50)
[Geo mean]                               77.0MB                      76.9MB       -0.08%

name                      old allocs/op               new allocs/op               delta
Template                                  344k +- 0%                  344k +- 0%    ~     (p=0.091 n=50+50)
Unicode                                   340k +- 0%                  340k +- 0%    ~     (p=0.084 n=50+50)
GoTypes                                  1.19M +- 0%                 1.19M +- 0%    ~     (p=0.634 n=50+50)
Compiler                                 5.05M +- 0%                 5.05M +- 0%    ~     (p=0.428 n=50+48)
SSA                                      12.9M +- 0%                 12.8M +- 0%  -0.94%  (p=0.000 n=48+50)
Flate                                     216k +- 0%                  216k +- 0%    ~     (p=0.959 n=50+50)
GoParser                                  275k +- 0%                  275k +- 0%    ~     (p=0.705 n=50+50)
Reflect                                   887k +- 0%                  887k +- 0%    ~     (p=0.136 n=50+50)
Tar                                       318k +- 0%                  318k +- 0%  +0.01%  (p=0.007 n=50+48)
XML                                       396k +- 0%                  396k +- 0%    ~     (p=0.577 n=48+50)
LinkCompiler                              457k +- 0%                  457k +- 0%  -0.02%  (p=0.000 n=50+48)
ExternalLinkCompiler                      459k +- 0%                  459k +- 0%  -0.02%  (p=0.000 n=50+49)
LinkWithoutDebugCompiler                  111k +- 0%                  111k +- 0%  -0.09%  (p=0.000 n=50+50)
[Geo mean]                                 603k                        603k       -0.08%

name                      old maxRSS/op               new maxRSS/op               delta
Template                                 33.7M +- 5%                 33.7M +- 3%    ~     (p=0.798 n=50+48)
Unicode                                  35.2M +- 5%                 35.3M +- 5%    ~     (p=0.586 n=50+50)
GoTypes                                  73.5M +- 5%                 73.2M +- 5%    ~     (p=0.436 n=50+50)
Compiler                                  315M +- 3%                  315M +- 3%    ~     (p=0.726 n=49+48)
SSA                                       705M +- 5%                  691M +- 5%  -2.01%  (p=0.000 n=50+50)
Flate                                    25.2M +- 3%                 25.0M +- 3%    ~     (p=0.122 n=49+49)
GoParser                                 27.7M +- 5%                 27.7M +- 3%    ~     (p=0.967 n=50+50)
Reflect                                  54.6M +- 4%                 54.8M +- 4%    ~     (p=0.418 n=50+50)
Tar                                      32.2M +- 4%                 32.1M +- 3%    ~     (p=0.644 n=50+49)
XML                                      38.7M +- 5%                 38.9M +- 5%    ~     (p=0.612 n=50+50)
LinkCompiler                              159M +- 1%                  159M +- 1%    ~     (p=0.302 n=49+50)
ExternalLinkCompiler                      171M +- 1%                  170M +- 1%  -0.33%  (p=0.000 n=50+50)
LinkWithoutDebugCompiler                  133M +- 1%                  132M +- 1%  -0.44%  (p=0.000 n=48+50)
[Geo mean]                                76.9M                       76.8M       -0.25%

name                      old text-bytes              new text-bytes              delta
HelloSize                                804kB +- 0%                 804kB +- 0%    ~     (all equal)

name                      old data-bytes              new data-bytes              delta
HelloSize                               13.2kB +- 0%                13.2kB +- 0%    ~     (all equal)

name                      old bss-bytes               new bss-bytes               delta
HelloSize                                206kB +- 0%                 206kB +- 0%    ~     (all equal)

name                      old exe-bytes               new exe-bytes               delta
HelloSize                               1.20MB +- 0%                1.20MB +- 0%    ~     (all equal)

file    before    after     Δ       %
api     4904729   4904881   +152    +0.003%
asm     4849768   4849696   -72     -0.001%
buildid 2604760   2604768   +8      +0.000%
cgo     4505984   4506000   +16     +0.000%
compile 18936732  18864939  -71793  -0.379%
cover   4787385   4787377   -8      -0.000%
dist    3451964   3451988   +24     +0.001%
doc     3794929   3794913   -16     -0.000%
fix     3201863   3201847   -16     -0.000%
link    6467231   6467327   +96     +0.001%
objdump 4400076   4400132   +56     +0.001%
pprof   13354395  13354507  +112    +0.001%
trace   10186673  10187273  +600    +0.006%
vet     6727213   6727277   +64     +0.001%
total   105284348 105213571 -70777  -0.067%

Change-Id: I5020d112021f165a4ae18aa56402d8690330d8fb
Reviewed-on: https://go-review.googlesource.com/c/go/+/239457
Reviewed-by: eric fang <eric.fang@arm.com>
Reviewed-by: Keith Randall <khr@golang.org>
Trust: eric fang <eric.fang@arm.com>
Run-TryBot: eric fang <eric.fang@arm.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ssa/fuse.go      |  97 ++++++++++----------
 src/cmd/compile/internal/ssa/fuse_test.go | 104 +++++++++++++++++++++-
 2 files changed, 153 insertions(+), 48 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/fuse.go b/src/cmd/compile/internal/ssa/fuse.go
index c51461cbff..236d5bbc55 100644
--- a/src/cmd/compile/internal/ssa/fuse.go
+++ b/src/cmd/compile/internal/ssa/fuse.go
@@ -51,11 +51,11 @@ func fuse(f *Func, typ fuseType) {
 
 // fuseBlockIf handles the following cases where s0 and s1 are empty blocks.
 //
-//   b        b        b      b
-//  / \      | \      / |    | |
-// s0  s1    |  s1   s0 |    | |
-//  \ /      | /      \ |    | |
-//   ss      ss        ss     ss
+//       b        b           b       b
+//    \ / \ /    | \  /    \ / |     | |
+//     s0  s1    |  s1      s0 |     | |
+//      \ /      | /         \ |     | |
+//       ss      ss           ss      ss
 //
 // If all Phi ops in ss have identical variables for slots corresponding to
 // s0, s1 and b then the branch can be dropped.
@@ -69,11 +69,11 @@ func fuseBlockIf(b *Block) bool {
 	if b.Kind != BlockIf {
 		return false
 	}
-
+	// It doesn't matter how much Preds does s0 or s1 have.
 	var ss0, ss1 *Block
 	s0 := b.Succs[0].b
 	i0 := b.Succs[0].i
-	if s0.Kind != BlockPlain || len(s0.Preds) != 1 || !isEmpty(s0) {
+	if s0.Kind != BlockPlain || !isEmpty(s0) {
 		s0, ss0 = b, s0
 	} else {
 		ss0 = s0.Succs[0].b
@@ -81,15 +81,25 @@ func fuseBlockIf(b *Block) bool {
 	}
 	s1 := b.Succs[1].b
 	i1 := b.Succs[1].i
-	if s1.Kind != BlockPlain || len(s1.Preds) != 1 || !isEmpty(s1) {
+	if s1.Kind != BlockPlain || !isEmpty(s1) {
 		s1, ss1 = b, s1
 	} else {
 		ss1 = s1.Succs[0].b
 		i1 = s1.Succs[0].i
 	}
-
 	if ss0 != ss1 {
-		return false
+		if s0.Kind == BlockPlain && isEmpty(s0) && s1.Kind == BlockPlain && isEmpty(s1) {
+			// Two special cases where both s0, s1 and ss are empty blocks.
+			if s0 == ss1 {
+				s0, ss0 = b, ss1
+			} else if ss0 == s1 {
+				s1, ss1 = b, ss0
+			} else {
+				return false
+			}
+		} else {
+			return false
+		}
 	}
 	ss := ss0
 
@@ -102,48 +112,45 @@ func fuseBlockIf(b *Block) bool {
 		}
 	}
 
-	// Now we have two of following b->ss, b->s0->ss and b->s1->ss,
-	// with s0 and s1 empty if exist.
-	// We can replace it with b->ss without if all OpPhis in ss
-	// have identical predecessors (verified above).
-	// No critical edge is introduced because b will have one successor.
-	if s0 != b && s1 != b {
-		// Replace edge b->s0->ss with b->ss.
-		// We need to keep a slot for Phis corresponding to b.
-		b.Succs[0] = Edge{ss, i0}
-		ss.Preds[i0] = Edge{b, 0}
-		b.removeEdge(1)
-		s1.removeEdge(0)
-	} else if s0 != b {
-		b.removeEdge(0)
+	// We do not need to redirect the Preds of s0 and s1 to ss,
+	// the following optimization will do this.
+	b.removeEdge(0)
+	if s0 != b && len(s0.Preds) == 0 {
 		s0.removeEdge(0)
-	} else if s1 != b {
-		b.removeEdge(1)
-		s1.removeEdge(0)
-	} else {
-		b.removeEdge(1)
+		// Move any (dead) values in s0 to b,
+		// where they will be eliminated by the next deadcode pass.
+		for _, v := range s0.Values {
+			v.Block = b
+		}
+		b.Values = append(b.Values, s0.Values...)
+		// Clear s0.
+		s0.Kind = BlockInvalid
+		s0.Values = nil
+		s0.Succs = nil
+		s0.Preds = nil
 	}
+
 	b.Kind = BlockPlain
 	b.Likely = BranchUnknown
 	b.ResetControls()
-
-	// Trash the empty blocks s0 and s1.
-	blocks := [...]*Block{s0, s1}
-	for _, s := range &blocks {
-		if s == b {
-			continue
+	// The values in b may be dead codes, and clearing them in time may
+	// obtain new optimization opportunities.
+	// First put dead values that can be deleted into a slice walkValues.
+	// Then put their arguments in walkValues before resetting the dead values
+	// in walkValues, because the arguments may also become dead values.
+	walkValues := []*Value{}
+	for _, v := range b.Values {
+		if v.Uses == 0 && v.removeable() {
+			walkValues = append(walkValues, v)
 		}
-		// Move any (dead) values in s0 or s1 to b,
-		// where they will be eliminated by the next deadcode pass.
-		for _, v := range s.Values {
-			v.Block = b
+	}
+	for len(walkValues) != 0 {
+		v := walkValues[len(walkValues)-1]
+		walkValues = walkValues[:len(walkValues)-1]
+		if v.Uses == 0 && v.removeable() {
+			walkValues = append(walkValues, v.Args...)
+			v.reset(OpInvalid)
 		}
-		b.Values = append(b.Values, s.Values...)
-		// Clear s.
-		s.Kind = BlockInvalid
-		s.Values = nil
-		s.Succs = nil
-		s.Preds = nil
 	}
 	return true
 }
diff --git a/src/cmd/compile/internal/ssa/fuse_test.go b/src/cmd/compile/internal/ssa/fuse_test.go
index 15190997f2..27a14b1781 100644
--- a/src/cmd/compile/internal/ssa/fuse_test.go
+++ b/src/cmd/compile/internal/ssa/fuse_test.go
@@ -104,6 +104,18 @@ func TestFuseHandlesPhis(t *testing.T) {
 
 func TestFuseEliminatesEmptyBlocks(t *testing.T) {
 	c := testConfig(t)
+	// Case 1, plain type empty blocks z0 ~ z3 will be eliminated.
+	//     entry
+	//       |
+	//      z0
+	//       |
+	//      z1
+	//       |
+	//      z2
+	//       |
+	//      z3
+	//       |
+	//     exit
 	fun := c.Fun("entry",
 		Bloc("entry",
 			Valu("mem", OpInitMem, types.TypeMem, 0, nil),
@@ -126,16 +138,77 @@ func TestFuseEliminatesEmptyBlocks(t *testing.T) {
 
 	for k, b := range fun.blocks {
 		if k[:1] == "z" && b.Kind != BlockInvalid {
-			t.Errorf("%s was not eliminated, but should have", k)
+			t.Errorf("case1 %s was not eliminated, but should have", k)
+		}
+	}
+
+	// Case 2, empty blocks with If branch, z0 and z1 will be eliminated.
+	//     entry
+	//     /  \
+	//    z0  z1
+	//     \  /
+	//     exit
+	fun = c.Fun("entry",
+		Bloc("entry",
+			Valu("mem", OpInitMem, types.TypeMem, 0, nil),
+			Valu("c", OpArg, c.config.Types.Bool, 0, nil),
+			If("c", "z0", "z1")),
+		Bloc("z0",
+			Goto("exit")),
+		Bloc("z1",
+			Goto("exit")),
+		Bloc("exit",
+			Exit("mem"),
+		))
+
+	CheckFunc(fun.f)
+	fuseLate(fun.f)
+
+	for k, b := range fun.blocks {
+		if k[:1] == "z" && b.Kind != BlockInvalid {
+			t.Errorf("case2 %s was not eliminated, but should have", k)
+		}
+	}
+
+	// Case 3, empty blocks with multiple predecessors, z0 and z1 will be eliminated.
+	//     entry
+	//      |  \
+	//      |  b0
+	//      | /  \
+	//      z0   z1
+	//       \   /
+	//       exit
+	fun = c.Fun("entry",
+		Bloc("entry",
+			Valu("mem", OpInitMem, types.TypeMem, 0, nil),
+			Valu("c1", OpArg, c.config.Types.Bool, 0, nil),
+			If("c1", "b0", "z0")),
+		Bloc("b0",
+			Valu("c2", OpArg, c.config.Types.Bool, 0, nil),
+			If("c2", "z1", "z0")),
+		Bloc("z0",
+			Goto("exit")),
+		Bloc("z1",
+			Goto("exit")),
+		Bloc("exit",
+			Exit("mem"),
+		))
+
+	CheckFunc(fun.f)
+	fuseLate(fun.f)
+
+	for k, b := range fun.blocks {
+		if k[:1] == "z" && b.Kind != BlockInvalid {
+			t.Errorf("case3 %s was not eliminated, but should have", k)
 		}
 	}
 }
 
 func TestFuseSideEffects(t *testing.T) {
-	// Test that we don't fuse branches that have side effects but
+	c := testConfig(t)
+	// Case1, test that we don't fuse branches that have side effects but
 	// have no use (e.g. followed by infinite loop).
 	// See issue #36005.
-	c := testConfig(t)
 	fun := c.Fun("entry",
 		Bloc("entry",
 			Valu("mem", OpInitMem, types.TypeMem, 0, nil),
@@ -163,6 +236,31 @@ func TestFuseSideEffects(t *testing.T) {
 			t.Errorf("else is eliminated, but should not")
 		}
 	}
+
+	// Case2, z0 contains a value that has side effect, z0 shouldn't be eliminated.
+	//     entry
+	//      | \
+	//      |  z0
+	//      | /
+	//     exit
+	fun = c.Fun("entry",
+		Bloc("entry",
+			Valu("mem", OpInitMem, types.TypeMem, 0, nil),
+			Valu("c1", OpArg, c.config.Types.Bool, 0, nil),
+			Valu("p", OpArg, c.config.Types.IntPtr, 0, nil),
+			If("c1", "z0", "exit")),
+		Bloc("z0",
+			Valu("nilcheck", OpNilCheck, types.TypeVoid, 0, nil, "p", "mem"),
+			Goto("exit")),
+		Bloc("exit",
+			Exit("mem"),
+		))
+	CheckFunc(fun.f)
+	fuseLate(fun.f)
+	z0, ok := fun.blocks["z0"]
+	if !ok || z0.Kind == BlockInvalid {
+		t.Errorf("case2 z0 is eliminated, but should not")
+	}
 }
 
 func BenchmarkFuse(b *testing.B) {
-- 
GitLab


From 600259b099d3ba215912ce957143febe84c684fb Mon Sep 17 00:00:00 2001
From: erifan01 <eric.fang@arm.com>
Date: Thu, 23 Jul 2020 10:24:56 +0800
Subject: [PATCH 1104/2400] cmd/compile: use depth first topological sort
 algorithm for layout
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The current layout algorithm tries to put consecutive blocks together,
so the priority of the successor block is higher than the priority of
the zero indegree block. This algorithm is beneficial for subsequent
register allocation, but will result in more branch instructions.
The depth-first topological sorting algorithm is a well-known layout
algorithm, which has applications in many languages, and it helps to
reduce branch instructions. This CL applies it to the layout pass.
The test results show that it helps to reduce the code size.

This CL also includes the following changes:
1, Removed the primary predecessor mechanism. The new layout algorithm is
  not very friendly to register allocator in some cases, in order to adapt
  to the new layout algorithm, a new primary predecessor selection strategy
  is introduced.
2, Since the new layout implementation may place non-loop blocks between
  loop blocks, some adaptive modifications have also been made to looprotate
  pass.
3, The layout also affects the results of codegen, so this CL also adjusted
  several codegen tests accordingly.

It is inevitable that this CL will cause the code size or performance of a
few functions to decrease, but the number of cases it improves is much larger
than the number of cases it drops.

Statistical data from compilecmp on linux/amd64 is as follow:
name                      old time/op       new time/op       delta
Template                        382ms ± 4%        382ms ± 4%    ~     (p=0.497 n=49+50)
Unicode                         170ms ± 9%        169ms ± 8%    ~     (p=0.344 n=48+50)
GoTypes                         2.01s ± 4%        2.01s ± 4%    ~     (p=0.628 n=50+48)
Compiler                        190ms ±10%        189ms ± 9%    ~     (p=0.734 n=50+50)
SSA                             11.8s ± 2%        11.8s ± 3%    ~     (p=0.877 n=50+50)
Flate                           241ms ± 9%        241ms ± 8%    ~     (p=0.897 n=50+49)
GoParser                        366ms ± 3%        361ms ± 4%  -1.21%  (p=0.004 n=47+50)
Reflect                         835ms ± 3%        838ms ± 3%    ~     (p=0.275 n=50+49)
Tar                             336ms ± 4%        335ms ± 3%    ~     (p=0.454 n=48+48)
XML                             433ms ± 4%        431ms ± 3%    ~     (p=0.071 n=49+48)
LinkCompiler                    706ms ± 4%        705ms ± 4%    ~     (p=0.608 n=50+49)
ExternalLinkCompiler            1.85s ± 3%        1.83s ± 2%  -1.47%  (p=0.000 n=49+48)
LinkWithoutDebugCompiler        437ms ± 5%        437ms ± 6%    ~     (p=0.953 n=49+50)
[Geo mean]                      615ms             613ms       -0.37%

name                      old alloc/op      new alloc/op      delta
Template                       38.7MB ± 1%       38.7MB ± 1%    ~     (p=0.834 n=50+50)
Unicode                        28.1MB ± 0%       28.1MB ± 0%  -0.22%  (p=0.000 n=49+50)
GoTypes                         168MB ± 1%        168MB ± 1%    ~     (p=0.054 n=47+47)
Compiler                       23.0MB ± 1%       23.0MB ± 1%    ~     (p=0.432 n=50+50)
SSA                            1.54GB ± 0%       1.54GB ± 0%  +0.21%  (p=0.000 n=50+50)
Flate                          23.6MB ± 1%       23.6MB ± 1%    ~     (p=0.153 n=43+46)
GoParser                       35.1MB ± 1%       35.1MB ± 2%    ~     (p=0.202 n=50+50)
Reflect                        84.7MB ± 1%       84.7MB ± 1%    ~     (p=0.333 n=48+49)
Tar                            34.5MB ± 1%       34.5MB ± 1%    ~     (p=0.406 n=46+49)
XML                            44.3MB ± 2%       44.2MB ± 3%    ~     (p=0.981 n=50+50)
LinkCompiler                    131MB ± 0%        128MB ± 0%  -2.74%  (p=0.000 n=50+50)
ExternalLinkCompiler            120MB ± 0%        120MB ± 0%  +0.01%  (p=0.007 n=50+50)
LinkWithoutDebugCompiler       77.3MB ± 0%       77.3MB ± 0%  -0.02%  (p=0.000 n=50+50)
[Geo mean]                     69.3MB            69.1MB       -0.22%

file      before    after     Δ        %
addr2line 4104220   4043684   -60536   -1.475%
api       5342502   5249678   -92824   -1.737%
asm       4973785   4858257   -115528  -2.323%
buildid   2667844   2625660   -42184   -1.581%
cgo       4686849   4616313   -70536   -1.505%
compile   23667431  23268406  -399025  -1.686%
cover     4959676   4874108   -85568   -1.725%
dist      3515934   3450422   -65512   -1.863%
doc       3995581   3925469   -70112   -1.755%
fix       3379202   3318522   -60680   -1.796%
link      6743249   6629913   -113336  -1.681%
nm        4047529   3991777   -55752   -1.377%
objdump   4456151   4388151   -68000   -1.526%
pack      2435040   2398072   -36968   -1.518%
pprof     13804080  13565808  -238272  -1.726%
test2json 2690043   2645987   -44056   -1.638%
trace     10418492  10232716  -185776  -1.783%
vet       7258259   7121259   -137000  -1.888%
total     113145867 111204202 -1941665 -1.716%

The situation on linux/arm64 is as follow:
name                      old time/op       new time/op       delta
Template                        280ms ± 1%        282ms ± 1%  +0.75%  (p=0.000 n=46+48)
Unicode                         124ms ± 2%        124ms ± 2%  +0.37%  (p=0.045 n=50+50)
GoTypes                         1.69s ± 1%        1.70s ± 1%  +0.56%  (p=0.000 n=49+50)
Compiler                        122ms ± 1%        123ms ± 1%  +0.93%  (p=0.000 n=50+50)
SSA                             12.6s ± 1%        12.7s ± 0%  +0.72%  (p=0.000 n=50+50)
Flate                           170ms ± 1%        172ms ± 1%  +0.97%  (p=0.000 n=49+49)
GoParser                        262ms ± 1%        263ms ± 1%  +0.39%  (p=0.000 n=49+48)
Reflect                         639ms ± 1%        650ms ± 1%  +1.63%  (p=0.000 n=49+49)
Tar                             243ms ± 1%        245ms ± 1%  +0.82%  (p=0.000 n=50+50)
XML                             324ms ± 1%        327ms ± 1%  +0.72%  (p=0.000 n=50+49)
LinkCompiler                    597ms ± 1%        596ms ± 1%  -0.27%  (p=0.001 n=48+47)
ExternalLinkCompiler            1.90s ± 1%        1.88s ± 1%  -1.00%  (p=0.000 n=50+50)
LinkWithoutDebugCompiler        364ms ± 1%        363ms ± 1%    ~     (p=0.220 n=49+50)
[Geo mean]                      485ms             488ms       +0.49%

name                      old alloc/op      new alloc/op      delta
Template                       38.7MB ± 0%       38.8MB ± 1%    ~     (p=0.093 n=43+49)
Unicode                        28.4MB ± 0%       28.4MB ± 0%  +0.03%  (p=0.000 n=49+45)
GoTypes                         169MB ± 1%        169MB ± 1%  +0.23%  (p=0.010 n=50+50)
Compiler                       23.2MB ± 1%       23.2MB ± 1%  +0.11%  (p=0.000 n=40+44)
SSA                            1.54GB ± 0%       1.55GB ± 0%  +0.45%  (p=0.000 n=47+49)
Flate                          23.8MB ± 2%       23.8MB ± 1%    ~     (p=0.543 n=50+50)
GoParser                       35.3MB ± 1%       35.4MB ± 1%    ~     (p=0.792 n=50+50)
Reflect                        85.2MB ± 1%       85.2MB ± 0%    ~     (p=0.055 n=50+47)
Tar                            34.5MB ± 1%       34.5MB ± 1%  +0.06%  (p=0.015 n=50+50)
XML                            43.8MB ± 2%       43.9MB ± 2%  +0.19%  (p=0.000 n=48+48)
LinkCompiler                    137MB ± 0%        136MB ± 0%  -0.92%  (p=0.000 n=50+50)
ExternalLinkCompiler            127MB ± 0%        127MB ± 0%    ~     (p=0.516 n=50+50)
LinkWithoutDebugCompiler       84.0MB ± 0%       84.0MB ± 0%    ~     (p=0.057 n=50+50)
[Geo mean]                     70.4MB            70.4MB       +0.01%

file      before    after     Δ        %
addr2line 4021557   4002933   -18624   -0.463%
api       5127847   5028503   -99344   -1.937%
asm       5034716   4936836   -97880   -1.944%
buildid   2608118   2594094   -14024   -0.538%
cgo       4488592   4398320   -90272   -2.011%
compile   22501129  22213592  -287537  -1.278%
cover     4742301   4713573   -28728   -0.606%
dist      3388071   3365311   -22760   -0.672%
doc       3802250   3776082   -26168   -0.688%
fix       3306147   3216939   -89208   -2.698%
link      6404483   6363699   -40784   -0.637%
nm        3941026   3921930   -19096   -0.485%
objdump   4383330   4295122   -88208   -2.012%
pack      2404547   2389515   -15032   -0.625%
pprof     12996234  12856818  -139416  -1.073%
test2json 2668500   2586788   -81712   -3.062%
trace     9816276   9609580   -206696  -2.106%
vet       6900682   6787338   -113344  -1.643%
total     108535806 107056973 -1478833 -1.363%

Change-Id: Iaec1cdcaacca8025e9babb0fb8a532fddb70c87d
Reviewed-on: https://go-review.googlesource.com/c/go/+/255239
Reviewed-by: eric fang <eric.fang@arm.com>
Reviewed-by: Keith Randall <khr@golang.org>
Trust: eric fang <eric.fang@arm.com>
---
 src/cmd/compile/internal/ssa/block.go      | 16 +++++
 src/cmd/compile/internal/ssa/layout.go     | 62 +++++++++++-------
 src/cmd/compile/internal/ssa/looprotate.go | 23 ++++---
 src/cmd/compile/internal/ssa/regalloc.go   | 76 ++++++++++++++--------
 test/codegen/arithmetic.go                 |  8 +++
 test/codegen/comparisons.go                |  8 +--
 6 files changed, 130 insertions(+), 63 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/block.go b/src/cmd/compile/internal/ssa/block.go
index 937c757b21..71ca774431 100644
--- a/src/cmd/compile/internal/ssa/block.go
+++ b/src/cmd/compile/internal/ssa/block.go
@@ -358,6 +358,22 @@ func (b *Block) AuxIntString() string {
 	}
 }
 
+// likelyBranch reports whether block b is the likely branch of all of its predecessors.
+func (b *Block) likelyBranch() bool {
+	if len(b.Preds) == 0 {
+		return false
+	}
+	for _, e := range b.Preds {
+		p := e.b
+		if len(p.Succs) == 1 || len(p.Succs) == 2 && (p.Likely == BranchLikely && p.Succs[0].b == b ||
+			p.Likely == BranchUnlikely && p.Succs[1].b == b) {
+			continue
+		}
+		return false
+	}
+	return true
+}
+
 func (b *Block) Logf(msg string, args ...interface{})   { b.Func.Logf(msg, args...) }
 func (b *Block) Log() bool                              { return b.Func.Log() }
 func (b *Block) Fatalf(msg string, args ...interface{}) { b.Func.Fatalf(msg, args...) }
diff --git a/src/cmd/compile/internal/ssa/layout.go b/src/cmd/compile/internal/ssa/layout.go
index 30b7b97d04..a7fd73aead 100644
--- a/src/cmd/compile/internal/ssa/layout.go
+++ b/src/cmd/compile/internal/ssa/layout.go
@@ -41,8 +41,13 @@ func layoutOrder(f *Func) []*Block {
 	indegree := make([]int, f.NumBlocks())
 	posdegree := f.newSparseSet(f.NumBlocks()) // blocks with positive remaining degree
 	defer f.retSparseSet(posdegree)
-	zerodegree := f.newSparseSet(f.NumBlocks()) // blocks with zero remaining degree
-	defer f.retSparseSet(zerodegree)
+	// blocks with zero remaining degree. Use slice to simulate a LIFO queue to implement
+	// the depth-first topology sorting algorithm.
+	var zerodegree []ID
+	// LIFO queue. Track the successor blocks of the scheduled block so that when we
+	// encounter loops, we choose to schedule the successor block of the most recently
+	// scheduled block.
+	var succs []ID
 	exit := f.newSparseSet(f.NumBlocks()) // exit blocks
 	defer f.retSparseSet(exit)
 
@@ -88,7 +93,8 @@ func layoutOrder(f *Func) []*Block {
 		}
 		indegree[b.ID] = len(b.Preds)
 		if len(b.Preds) == 0 {
-			zerodegree.add(b.ID)
+			// Push an element to the tail of the queue.
+			zerodegree = append(zerodegree, b.ID)
 		} else {
 			posdegree.add(b.ID)
 		}
@@ -105,12 +111,24 @@ blockloop:
 			break
 		}
 
-		for _, e := range b.Succs {
-			c := e.b
+		// Here, the order of traversing the b.Succs affects the direction in which the topological
+		// sort advances in depth. Take the following cfg as an example, regardless of other factors.
+		//           b1
+		//         0/ \1
+		//        b2   b3
+		// Traverse b.Succs in order, the right child node b3 will be scheduled immediately after
+		// b1, traverse b.Succs in reverse order, the left child node b2 will be scheduled
+		// immediately after b1. The test results show that reverse traversal performs a little
+		// better.
+		// Note: You need to consider both layout and register allocation when testing performance.
+		for i := len(b.Succs) - 1; i >= 0; i-- {
+			c := b.Succs[i].b
 			indegree[c.ID]--
 			if indegree[c.ID] == 0 {
 				posdegree.remove(c.ID)
-				zerodegree.add(c.ID)
+				zerodegree = append(zerodegree, c.ID)
+			} else {
+				succs = append(succs, c.ID)
 			}
 		}
 
@@ -132,30 +150,30 @@ blockloop:
 
 		// Use degree for now.
 		bid = 0
-		mindegree := f.NumBlocks()
-		for _, e := range order[len(order)-1].Succs {
-			c := e.b
-			if scheduled[c.ID] || c.Kind == BlockExit {
-				continue
-			}
-			if indegree[c.ID] < mindegree {
-				mindegree = indegree[c.ID]
-				bid = c.ID
-			}
-		}
-		if bid != 0 {
-			continue
-		}
 		// TODO: improve this part
 		// No successor of the previously scheduled block works.
 		// Pick a zero-degree block if we can.
-		for zerodegree.size() > 0 {
-			cid := zerodegree.pop()
+		for len(zerodegree) > 0 {
+			// Pop an element from the tail of the queue.
+			cid := zerodegree[len(zerodegree)-1]
+			zerodegree = zerodegree[:len(zerodegree)-1]
+			if !scheduled[cid] {
+				bid = cid
+				continue blockloop
+			}
+		}
+
+		// Still nothing, pick the unscheduled successor block encountered most recently.
+		for len(succs) > 0 {
+			// Pop an element from the tail of the queue.
+			cid := succs[len(succs)-1]
+			succs = succs[:len(succs)-1]
 			if !scheduled[cid] {
 				bid = cid
 				continue blockloop
 			}
 		}
+
 		// Still nothing, pick any non-exit block.
 		for posdegree.size() > 0 {
 			cid := posdegree.pop()
diff --git a/src/cmd/compile/internal/ssa/looprotate.go b/src/cmd/compile/internal/ssa/looprotate.go
index 2e5e421df7..35010a78d8 100644
--- a/src/cmd/compile/internal/ssa/looprotate.go
+++ b/src/cmd/compile/internal/ssa/looprotate.go
@@ -68,12 +68,15 @@ func loopRotate(f *Func) {
 			if nextb == p { // original loop predecessor is next
 				break
 			}
-			if loopnest.b2l[nextb.ID] != loop { // about to leave loop
-				break
+			if loopnest.b2l[nextb.ID] == loop {
+				after[p.ID] = append(after[p.ID], nextb)
 			}
-			after[p.ID] = append(after[p.ID], nextb)
 			b = nextb
 		}
+		// Swap b and p so that we'll handle p before b when moving blocks.
+		f.Blocks[idToIdx[loop.header.ID]] = p
+		f.Blocks[idToIdx[p.ID]] = loop.header
+		idToIdx[loop.header.ID], idToIdx[p.ID] = idToIdx[p.ID], idToIdx[loop.header.ID]
 
 		// Place b after p.
 		for _, b := range after[p.ID] {
@@ -86,21 +89,23 @@ func loopRotate(f *Func) {
 	// before the rest of the loop.  And that relies on the
 	// fact that we only identify reducible loops.
 	j := 0
-	for i, b := range f.Blocks {
+	// Some blocks that are not part of a loop may be placed
+	// between loop blocks. In order to avoid these blocks from
+	// being overwritten, use a temporary slice.
+	newOrder := make([]*Block, 0, f.NumBlocks())
+	for _, b := range f.Blocks {
 		if _, ok := move[b.ID]; ok {
 			continue
 		}
-		f.Blocks[j] = b
+		newOrder = append(newOrder, b)
 		j++
 		for _, a := range after[b.ID] {
-			if j > i {
-				f.Fatalf("head before tail in loop %s", b)
-			}
-			f.Blocks[j] = a
+			newOrder = append(newOrder, a)
 			j++
 		}
 	}
 	if j != len(f.Blocks) {
 		f.Fatalf("bad reordering in looprotate")
 	}
+	f.Blocks = newOrder
 }
diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go
index c104a36888..18908681df 100644
--- a/src/cmd/compile/internal/ssa/regalloc.go
+++ b/src/cmd/compile/internal/ssa/regalloc.go
@@ -241,12 +241,6 @@ type regAllocState struct {
 	GReg        register
 	allocatable regMask
 
-	// for each block, its primary predecessor.
-	// A predecessor of b is primary if it is the closest
-	// predecessor that appears before b in the layout order.
-	// We record the index in the Preds list where the primary predecessor sits.
-	primary []int32
-
 	// live values at the end of each block.  live[b.ID] is a list of value IDs
 	// which are live at the end of b, together with a count of how many instructions
 	// forward to the next use.
@@ -304,6 +298,9 @@ type regAllocState struct {
 
 	// choose a good order in which to visit blocks for allocation purposes.
 	visitOrder []*Block
+
+	// blockOrder[b.ID] corresponds to the index of block b in visitOrder.
+	blockOrder []int32
 }
 
 type endReg struct {
@@ -636,9 +633,9 @@ func (s *regAllocState) init(f *Func) {
 
 	// Compute block order. This array allows us to distinguish forward edges
 	// from backward edges and compute how far they go.
-	blockOrder := make([]int32, f.NumBlocks())
+	s.blockOrder = make([]int32, f.NumBlocks())
 	for i, b := range s.visitOrder {
-		blockOrder[b.ID] = int32(i)
+		s.blockOrder[b.ID] = int32(i)
 	}
 
 	s.regs = make([]regState, s.numRegs)
@@ -664,22 +661,6 @@ func (s *regAllocState) init(f *Func) {
 	}
 	s.computeLive()
 
-	// Compute primary predecessors.
-	s.primary = make([]int32, f.NumBlocks())
-	for _, b := range s.visitOrder {
-		best := -1
-		for i, e := range b.Preds {
-			p := e.b
-			if blockOrder[p.ID] >= blockOrder[b.ID] {
-				continue // backward edge
-			}
-			if best == -1 || blockOrder[p.ID] > blockOrder[b.Preds[best].b.ID] {
-				best = i
-			}
-		}
-		s.primary[b.ID] = int32(best)
-	}
-
 	s.endRegs = make([][]endReg, f.NumBlocks())
 	s.startRegs = make([][]startReg, f.NumBlocks())
 	s.spillLive = make([][]ID, f.NumBlocks())
@@ -957,10 +938,49 @@ func (s *regAllocState) regalloc(f *Func) {
 			// This is the complicated case. We have more than one predecessor,
 			// which means we may have Phi ops.
 
-			// Start with the final register state of the primary predecessor
-			idx := s.primary[b.ID]
+			// Start with the final register state of the predecessor with least spill values.
+			// This is based on the following points:
+			// 1, The less spill value indicates that the register pressure of this path is smaller,
+			//    so the values of this block are more likely to be allocated to registers.
+			// 2, Avoid the predecessor that contains the function call, because the predecessor that
+			//    contains the function call usually generates a lot of spills and lose the previous
+			//    allocation state.
+			// TODO: Improve this part. At least the size of endRegs of the predecessor also has
+			// an impact on the code size and compiler speed. But it is not easy to find a simple
+			// and efficient method that combines multiple factors.
+			idx := -1
+			for i, p := range b.Preds {
+				// If the predecessor has not been visited yet, skip it because its end state
+				// (redRegs and spillLive) has not been computed yet.
+				pb := p.b
+				if s.blockOrder[pb.ID] >= s.blockOrder[b.ID] {
+					continue
+				}
+				if idx == -1 {
+					idx = i
+					continue
+				}
+				pSel := b.Preds[idx].b
+				if len(s.spillLive[pb.ID]) < len(s.spillLive[pSel.ID]) {
+					idx = i
+				} else if len(s.spillLive[pb.ID]) == len(s.spillLive[pSel.ID]) {
+					// Use a bit of likely information. After critical pass, pb and pSel must
+					// be plain blocks, so check edge pb->pb.Preds instead of edge pb->b.
+					// TODO: improve the prediction of the likely predecessor. The following
+					// method is only suitable for the simplest cases. For complex cases,
+					// the prediction may be inaccurate, but this does not affect the
+					// correctness of the program.
+					// According to the layout algorithm, the predecessor with the
+					// smaller blockOrder is the true branch, and the test results show
+					// that it is better to choose the predecessor with a smaller
+					// blockOrder than no choice.
+					if pb.likelyBranch() && !pSel.likelyBranch() || s.blockOrder[pb.ID] < s.blockOrder[pSel.ID] {
+						idx = i
+					}
+				}
+			}
 			if idx < 0 {
-				f.Fatalf("block with no primary predecessor %s", b)
+				f.Fatalf("bad visitOrder, no predecessor of %s has been visited before it", b)
 			}
 			p := b.Preds[idx].b
 			s.setState(s.endRegs[p.ID])
@@ -1048,7 +1068,7 @@ func (s *regAllocState) regalloc(f *Func) {
 				// If one of the other inputs of v is in a register, and the register is available,
 				// select this register, which can save some unnecessary copies.
 				for i, pe := range b.Preds {
-					if int32(i) == idx {
+					if i == idx {
 						continue
 					}
 					ri := noRegister
diff --git a/test/codegen/arithmetic.go b/test/codegen/arithmetic.go
index 0bdb66a376..dea7e0ba61 100644
--- a/test/codegen/arithmetic.go
+++ b/test/codegen/arithmetic.go
@@ -322,6 +322,9 @@ func NoFix64A(divr int64) (int64, int64) {
 	if divr > 5 {
 		d /= divr // amd64:-"JMP"
 		e %= divr // amd64:-"JMP"
+		// The following statement is to avoid conflict between the above check
+		// and the normal JMP generated at the end of the block.
+		d += e
 	}
 	return d, e
 }
@@ -333,6 +336,7 @@ func NoFix64B(divd int64) (int64, int64) {
 	if divd > -9223372036854775808 {
 		d = divd / divr // amd64:-"JMP"
 		e = divd % divr // amd64:-"JMP"
+		d += e
 	}
 	return d, e
 }
@@ -347,6 +351,7 @@ func NoFix32A(divr int32) (int32, int32) {
 		// amd64:-"JMP"
 		// 386:-"JMP"
 		e %= divr
+		d += e
 	}
 	return d, e
 }
@@ -362,6 +367,7 @@ func NoFix32B(divd int32) (int32, int32) {
 		// amd64:-"JMP"
 		// 386:-"JMP"
 		e = divd % divr
+		d += e
 	}
 	return d, e
 }
@@ -376,6 +382,7 @@ func NoFix16A(divr int16) (int16, int16) {
 		// amd64:-"JMP"
 		// 386:-"JMP"
 		e %= divr
+		d += e
 	}
 	return d, e
 }
@@ -391,6 +398,7 @@ func NoFix16B(divd int16) (int16, int16) {
 		// amd64:-"JMP"
 		// 386:-"JMP"
 		e = divd % divr
+		d += e
 	}
 	return d, e
 }
diff --git a/test/codegen/comparisons.go b/test/codegen/comparisons.go
index 02bed38661..719063cdc3 100644
--- a/test/codegen/comparisons.go
+++ b/test/codegen/comparisons.go
@@ -426,7 +426,7 @@ func UintGeqZero(a uint8, b uint16, c uint32, d uint64) int {
 }
 
 func UintGtZero(a uint8, b uint16, c uint32, d uint64) int {
-	// arm64: `CBZW`, `CBNZW`, `CBNZ`, -`(CMPW|CMP|BLS|BHI)`
+	// arm64: `(CBN?ZW)`, `(CBN?Z[^W])`, -`(CMPW|CMP|BLS|BHI)`
 	if a > 0 || b > 0 || c > 0 || d > 0 {
 		return 1
 	}
@@ -434,7 +434,7 @@ func UintGtZero(a uint8, b uint16, c uint32, d uint64) int {
 }
 
 func UintLeqZero(a uint8, b uint16, c uint32, d uint64) int {
-	// arm64: `CBNZW`, `CBZW`, `CBZ`, -`(CMPW|CMP|BHI|BLS)`
+	// arm64: `(CBN?ZW)`, `(CBN?Z[^W])`, -`(CMPW|CMP|BHI|BLS)`
 	if a <= 0 || b <= 0 || c <= 0 || d <= 0 {
 		return 1
 	}
@@ -442,7 +442,7 @@ func UintLeqZero(a uint8, b uint16, c uint32, d uint64) int {
 }
 
 func UintLtOne(a uint8, b uint16, c uint32, d uint64) int {
-	// arm64: `CBNZW`, `CBZW`, `CBZW`, `CBZ`, -`(CMPW|CMP|BHS|BLO)`
+	// arm64: `(CBN?ZW)`, `(CBN?Z[^W])`, -`(CMPW|CMP|BHS|BLO)`
 	if a < 1 || b < 1 || c < 1 || d < 1 {
 		return 1
 	}
@@ -450,7 +450,7 @@ func UintLtOne(a uint8, b uint16, c uint32, d uint64) int {
 }
 
 func UintGeqOne(a uint8, b uint16, c uint32, d uint64) int {
-	// arm64: `CBZW`, `CBNZW`, `CBNZ`, -`(CMPW|CMP|BLO|BHS)`
+	// arm64: `(CBN?ZW)`, `(CBN?Z[^W])`, -`(CMPW|CMP|BLO|BHS)`
 	if a >= 1 || b >= 1 || c >= 1 || d >= 1 {
 		return 1
 	}
-- 
GitLab


From afe517590cc5e236a8f4f3af35ca64ca1d55b2e5 Mon Sep 17 00:00:00 2001
From: Meng Zhuo <mzh@golangcn.org>
Date: Tue, 16 Mar 2021 17:04:31 +0800
Subject: [PATCH 1105/2400] cmd/compile: loads from readonly globals into const
 for mips64x

Ref: CL 141118
Update #26498

Change-Id: If4ea55c080b9aa10183eefe81fefbd4072deaf3a
Reviewed-on: https://go-review.googlesource.com/c/go/+/280646
Trust: Meng Zhuo <mzh@golangcn.org>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/gen/MIPS64.rules |  6 ++
 src/cmd/compile/internal/ssa/rewriteMIPS64.go | 58 +++++++++++++++++++
 test/codegen/strings.go                       |  1 +
 3 files changed, 65 insertions(+)

diff --git a/src/cmd/compile/internal/ssa/gen/MIPS64.rules b/src/cmd/compile/internal/ssa/gen/MIPS64.rules
index bc51a0d53d..bb91dcd5ee 100644
--- a/src/cmd/compile/internal/ssa/gen/MIPS64.rules
+++ b/src/cmd/compile/internal/ssa/gen/MIPS64.rules
@@ -681,3 +681,9 @@
 (GTZ (MOVVconst [c]) yes no) && c <= 0 => (First no yes)
 (GEZ (MOVVconst [c]) yes no) && c >= 0 => (First yes no)
 (GEZ (MOVVconst [c]) yes no) && c <  0 => (First no yes)
+
+// fold readonly sym load
+(MOVBload [off] {sym} (SB) _) && symIsRO(sym) => (MOVVconst [int64(read8(sym, int64(off)))])
+(MOVHload [off] {sym} (SB) _) && symIsRO(sym) => (MOVVconst [int64(read16(sym, int64(off), config.ctxt.Arch.ByteOrder))])
+(MOVWload [off] {sym} (SB) _) && symIsRO(sym) => (MOVVconst [int64(read32(sym, int64(off), config.ctxt.Arch.ByteOrder))])
+(MOVVload  [off] {sym} (SB) _) && symIsRO(sym) => (MOVVconst [int64(read64(sym, int64(off), config.ctxt.Arch.ByteOrder))])
diff --git a/src/cmd/compile/internal/ssa/rewriteMIPS64.go b/src/cmd/compile/internal/ssa/rewriteMIPS64.go
index 541bdd694a..79da4dfb72 100644
--- a/src/cmd/compile/internal/ssa/rewriteMIPS64.go
+++ b/src/cmd/compile/internal/ssa/rewriteMIPS64.go
@@ -2668,6 +2668,19 @@ func rewriteValueMIPS64_OpMIPS64MOVBload(v *Value) bool {
 		v.AddArg2(ptr, mem)
 		return true
 	}
+	// match: (MOVBload [off] {sym} (SB) _)
+	// cond: symIsRO(sym)
+	// result: (MOVVconst [int64(read8(sym, int64(off)))])
+	for {
+		off := auxIntToInt32(v.AuxInt)
+		sym := auxToSym(v.Aux)
+		if v_0.Op != OpSB || !(symIsRO(sym)) {
+			break
+		}
+		v.reset(OpMIPS64MOVVconst)
+		v.AuxInt = int64ToAuxInt(int64(read8(sym, int64(off))))
+		return true
+	}
 	return false
 }
 func rewriteValueMIPS64_OpMIPS64MOVBreg(v *Value) bool {
@@ -3232,6 +3245,8 @@ func rewriteValueMIPS64_OpMIPS64MOVHUreg(v *Value) bool {
 func rewriteValueMIPS64_OpMIPS64MOVHload(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
+	b := v.Block
+	config := b.Func.Config
 	// match: (MOVHload [off1] {sym} (ADDVconst [off2] ptr) mem)
 	// cond: is32Bit(int64(off1)+off2)
 	// result: (MOVHload [off1+int32(off2)] {sym} ptr mem)
@@ -3275,6 +3290,19 @@ func rewriteValueMIPS64_OpMIPS64MOVHload(v *Value) bool {
 		v.AddArg2(ptr, mem)
 		return true
 	}
+	// match: (MOVHload [off] {sym} (SB) _)
+	// cond: symIsRO(sym)
+	// result: (MOVVconst [int64(read16(sym, int64(off), config.ctxt.Arch.ByteOrder))])
+	for {
+		off := auxIntToInt32(v.AuxInt)
+		sym := auxToSym(v.Aux)
+		if v_0.Op != OpSB || !(symIsRO(sym)) {
+			break
+		}
+		v.reset(OpMIPS64MOVVconst)
+		v.AuxInt = int64ToAuxInt(int64(read16(sym, int64(off), config.ctxt.Arch.ByteOrder)))
+		return true
+	}
 	return false
 }
 func rewriteValueMIPS64_OpMIPS64MOVHreg(v *Value) bool {
@@ -3544,6 +3572,8 @@ func rewriteValueMIPS64_OpMIPS64MOVHstorezero(v *Value) bool {
 func rewriteValueMIPS64_OpMIPS64MOVVload(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
+	b := v.Block
+	config := b.Func.Config
 	// match: (MOVVload [off1] {sym} (ADDVconst [off2] ptr) mem)
 	// cond: is32Bit(int64(off1)+off2)
 	// result: (MOVVload [off1+int32(off2)] {sym} ptr mem)
@@ -3587,6 +3617,19 @@ func rewriteValueMIPS64_OpMIPS64MOVVload(v *Value) bool {
 		v.AddArg2(ptr, mem)
 		return true
 	}
+	// match: (MOVVload [off] {sym} (SB) _)
+	// cond: symIsRO(sym)
+	// result: (MOVVconst [int64(read64(sym, int64(off), config.ctxt.Arch.ByteOrder))])
+	for {
+		off := auxIntToInt32(v.AuxInt)
+		sym := auxToSym(v.Aux)
+		if v_0.Op != OpSB || !(symIsRO(sym)) {
+			break
+		}
+		v.reset(OpMIPS64MOVVconst)
+		v.AuxInt = int64ToAuxInt(int64(read64(sym, int64(off), config.ctxt.Arch.ByteOrder)))
+		return true
+	}
 	return false
 }
 func rewriteValueMIPS64_OpMIPS64MOVVnop(v *Value) bool {
@@ -3878,6 +3921,8 @@ func rewriteValueMIPS64_OpMIPS64MOVWUreg(v *Value) bool {
 func rewriteValueMIPS64_OpMIPS64MOVWload(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
+	b := v.Block
+	config := b.Func.Config
 	// match: (MOVWload [off1] {sym} (ADDVconst [off2] ptr) mem)
 	// cond: is32Bit(int64(off1)+off2)
 	// result: (MOVWload [off1+int32(off2)] {sym} ptr mem)
@@ -3921,6 +3966,19 @@ func rewriteValueMIPS64_OpMIPS64MOVWload(v *Value) bool {
 		v.AddArg2(ptr, mem)
 		return true
 	}
+	// match: (MOVWload [off] {sym} (SB) _)
+	// cond: symIsRO(sym)
+	// result: (MOVVconst [int64(read32(sym, int64(off), config.ctxt.Arch.ByteOrder))])
+	for {
+		off := auxIntToInt32(v.AuxInt)
+		sym := auxToSym(v.Aux)
+		if v_0.Op != OpSB || !(symIsRO(sym)) {
+			break
+		}
+		v.reset(OpMIPS64MOVVconst)
+		v.AuxInt = int64ToAuxInt(int64(read32(sym, int64(off), config.ctxt.Arch.ByteOrder)))
+		return true
+	}
 	return false
 }
 func rewriteValueMIPS64_OpMIPS64MOVWreg(v *Value) bool {
diff --git a/test/codegen/strings.go b/test/codegen/strings.go
index 0859e241cb..19e1dbda51 100644
--- a/test/codegen/strings.go
+++ b/test/codegen/strings.go
@@ -30,6 +30,7 @@ func ConstantLoad() {
 	//   arm:`MOVW\t\$48`,`MOVW\t\$49`,`MOVW\t\$50`
 	// arm64:`MOVD\t\$12592`,`MOVD\t\$50`
 	//  wasm:`I64Const\t\$12592`,`I64Store16\t\$0`,`I64Const\t\$50`,`I64Store8\t\$2`
+	// mips64:`MOVV\t\$48`,`MOVV\t\$49`,`MOVV\t\$50`
 	bsink = []byte("012")
 
 	// 858927408 = 0x33323130
-- 
GitLab


From 26c32de7c9a6bb54d0144d1cc2f00cc334778cac Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 12 Mar 2021 11:26:51 -0500
Subject: [PATCH 1106/2400] cmd/go/internal/modcmd: in 'go mod tidy', suspend
 go.mod writes until tidy

For #36460

Change-Id: Ia8633f37aec8c7ed532bf7278867251e5e2a4285
Reviewed-on: https://go-review.googlesource.com/c/go/+/301370
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modcmd/tidy.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/cmd/go/internal/modcmd/tidy.go b/src/cmd/go/internal/modcmd/tidy.go
index 34ff86ff18..33ecd80bcb 100644
--- a/src/cmd/go/internal/modcmd/tidy.go
+++ b/src/cmd/go/internal/modcmd/tidy.go
@@ -60,6 +60,7 @@ func runTidy(ctx context.Context, cmd *base.Command, args []string) {
 	// request that their test dependencies be included.
 	modload.ForceUseModules = true
 	modload.RootMode = modload.NeedRoot
+	modload.DisallowWriteGoMod() // Suppress writing until we've tidied the file.
 
 	modload.LoadPackages(ctx, modload.PackageOpts{
 		Tags:                     imports.AnyTags(),
@@ -72,5 +73,7 @@ func runTidy(ctx context.Context, cmd *base.Command, args []string) {
 
 	modload.TidyBuildList()
 	modload.TrimGoSum()
+
+	modload.AllowWriteGoMod()
 	modload.WriteGoMod()
 }
-- 
GitLab


From 120b9eb1c38f9b074cd3f284647e0735348fa1f4 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 12 Mar 2021 11:28:05 -0500
Subject: [PATCH 1107/2400] cmd/go/internal/modload: in readonly mode, do not
 read go.mod files missing checksums

This was causing test failures while revising CL 293689: splitting the
roots out from the rest of the module graph may allow 'go list -e' to
proceed even when the rest of the module graph can't be loaded (e.g.
due to missing go.mod checksums). If that occurs, it becomes more
important that the moduleInfo helper function itself avoid fetching
unchecked files.

For #36460

Change-Id: I088509eeb3008cc6e8bfe85a00ec2bf500bf9423
Reviewed-on: https://go-review.googlesource.com/c/go/+/301371
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modload/build.go | 40 ++++++++++++++++++----------
 1 file changed, 26 insertions(+), 14 deletions(-)

diff --git a/src/cmd/go/internal/modload/build.go b/src/cmd/go/internal/modload/build.go
index 5a151b4802..b32997d29e 100644
--- a/src/cmd/go/internal/modload/build.go
+++ b/src/cmd/go/internal/modload/build.go
@@ -168,7 +168,10 @@ func moduleInfo(ctx context.Context, m module.Version, fromBuildList, listRetrac
 
 	// completeFromModCache fills in the extra fields in m using the module cache.
 	completeFromModCache := func(m *modinfo.ModulePublic) {
-		mod := module.Version{Path: m.Path, Version: m.Version}
+		checksumOk := func(suffix string) bool {
+			return !fromBuildList || m.Version == "" || cfg.BuildMod == "mod" ||
+				modfetch.HaveSum(module.Version{Path: m.Path, Version: m.Version + suffix})
+		}
 
 		if m.Version != "" {
 			if q, err := Query(ctx, m.Path, m.Version, "", nil); err != nil {
@@ -177,28 +180,37 @@ func moduleInfo(ctx context.Context, m module.Version, fromBuildList, listRetrac
 				m.Version = q.Version
 				m.Time = &q.Time
 			}
+		}
+		mod := module.Version{Path: m.Path, Version: m.Version}
+
+		if m.GoVersion == "" && checksumOk("/go.mod") {
+			// Load the go.mod file to determine the Go version, since it hasn't
+			// already been populated from rawGoVersion.
+			if summary, err := rawGoModSummary(mod); err == nil && summary.goVersionV != "" {
+				m.GoVersion = summary.goVersionV[1:]
+			}
+		}
 
-			gomod, err := modfetch.CachePath(mod, "mod")
-			if err == nil {
-				if info, err := os.Stat(gomod); err == nil && info.Mode().IsRegular() {
-					m.GoMod = gomod
+		if m.Version != "" {
+			if checksumOk("/go.mod") {
+				gomod, err := modfetch.CachePath(mod, "mod")
+				if err == nil {
+					if info, err := os.Stat(gomod); err == nil && info.Mode().IsRegular() {
+						m.GoMod = gomod
+					}
 				}
 			}
-			dir, err := modfetch.DownloadDir(mod)
-			if err == nil {
-				m.Dir = dir
+			if checksumOk("") {
+				dir, err := modfetch.DownloadDir(mod)
+				if err == nil {
+					m.Dir = dir
+				}
 			}
 
 			if listRetracted {
 				addRetraction(ctx, m)
 			}
 		}
-
-		if m.GoVersion == "" {
-			if summary, err := rawGoModSummary(mod); err == nil && summary.goVersionV != "" {
-				m.GoVersion = summary.goVersionV[1:]
-			}
-		}
 	}
 
 	if !fromBuildList {
-- 
GitLab


From 0089f8b2f5a4e3db944cf4b61314bdef45fa1b81 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 5 Mar 2021 11:30:23 -0500
Subject: [PATCH 1108/2400] cmd/go: test that 'go mod tidy' retains upgraded
 indirect dependencies

For #36460

Change-Id: I63596e1c95d0c702073cdb016579598d79cc95ef
Reviewed-on: https://go-review.googlesource.com/c/go/+/300158
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 .../go/testdata/script/mod_tidy_indirect.txt  | 67 +++++++++++++++++++
 1 file changed, 67 insertions(+)
 create mode 100644 src/cmd/go/testdata/script/mod_tidy_indirect.txt

diff --git a/src/cmd/go/testdata/script/mod_tidy_indirect.txt b/src/cmd/go/testdata/script/mod_tidy_indirect.txt
new file mode 100644
index 0000000000..1f092b223b
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_tidy_indirect.txt
@@ -0,0 +1,67 @@
+cp go.mod go.mod.orig
+go mod tidy
+cmp go.mod go.mod.orig
+
+-- go.mod --
+module example.com/tidy
+
+go 1.16
+
+require (
+	example.net/incomplete v0.1.0
+	example.net/indirect v0.2.0 // indirect
+	example.net/toolow v0.1.0
+)
+
+replace (
+	example.net/incomplete v0.1.0 => ./incomplete
+	example.net/indirect v0.1.0 => ./indirect.1
+	example.net/indirect v0.2.0 => ./indirect.2
+	example.net/toolow v0.1.0 => ./toolow
+)
+-- tidy.go --
+package tidy
+
+import (
+	_ "example.net/incomplete"
+	_ "example.net/toolow"
+)
+
+-- incomplete/go.mod --
+module example.net/incomplete
+
+go 1.16
+
+// This module omits a needed requirement on example.net/indirect.
+-- incomplete/incomplete.go --
+package incomplete
+
+import _ "example.net/indirect/newpkg"
+
+-- toolow/go.mod --
+module example.net/toolow
+
+go 1.16
+
+require example.net/indirect v0.1.0
+-- toolow/toolow.go --
+package toolow
+
+import _ "example.net/indirect/oldpkg"
+
+-- indirect.1/go.mod --
+module example.net/indirect
+
+go 1.16
+-- indirect.1/oldpkg/oldpkg.go --
+package oldpkg
+
+
+-- indirect.2/go.mod --
+module example.net/indirect
+
+go 1.16
+-- indirect.2/oldpkg/oldpkg.go --
+package oldpkg
+-- indirect.2/newpkg/newpkg.go --
+package newpkg
-- 
GitLab


From 860704317e02d699e4e4a24103853c4782d746c1 Mon Sep 17 00:00:00 2001
From: Johan Brandhorst <johan.brandhorst@gmail.com>
Date: Sat, 1 Aug 2020 12:18:31 +0100
Subject: [PATCH 1109/2400] crypto/tls: add HandshakeContext method to Conn

Adds the (*tls.Conn).HandshakeContext method. This allows
us to pass the context provided down the call stack to
eventually reach the tls.ClientHelloInfo and
tls.CertificateRequestInfo structs.
These contexts are exposed to the user as read-only via Context()
methods.

This allows users of (*tls.Config).GetCertificate and
(*tls.Config).GetClientCertificate to use the context for
request scoped parameters and cancellation.

Replace uses of (*tls.Conn).Handshake with (*tls.Conn).HandshakeContext
where appropriate, to propagate existing contexts.

Fixes #32406

Change-Id: I259939c744bdc9b805bf51a845a8bc462c042483
Reviewed-on: https://go-review.googlesource.com/c/go/+/295370
Run-TryBot: Johan Brandhorst-Satzkorn <johan.brandhorst@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Katie Hockman <katie@golang.org>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
---
 doc/go1.17.html                          |  26 +++++
 src/crypto/tls/common.go                 |  21 ++++
 src/crypto/tls/conn.go                   |  62 +++++++++++-
 src/crypto/tls/handshake_client.go       |  11 ++-
 src/crypto/tls/handshake_client_test.go  |  36 +++++++
 src/crypto/tls/handshake_client_tls13.go |   3 +
 src/crypto/tls/handshake_server.go       |  17 ++--
 src/crypto/tls/handshake_server_test.go  | 119 ++++++++++++++++++++++-
 src/crypto/tls/handshake_server_tls13.go |   4 +-
 src/crypto/tls/tls.go                    |  55 ++---------
 src/net/http/server.go                   |   2 +-
 src/net/http/transport.go                |  10 +-
 src/net/http/transport_test.go           |   2 +-
 13 files changed, 299 insertions(+), 69 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index a07290714f..34cfce7a06 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -79,6 +79,23 @@ Do not send CLs removing the interior tags from such phrases.
   TODO: complete this section
 </p>
 
+<h3 id="crypto/tls"><a href="/pkg/crypto/tls">crypto/tls</a></h3>
+
+<p><!-- CL 295370 -->
+  <a href="/pkg/crypto/tls#Conn.HandshakeContext">(*Conn).HandshakeContext</a> was added to
+  allow the user to control cancellation of an in-progress TLS Handshake.
+  The context provided is propagated into the
+  <a href="/pkg/crypto/tls#ClientHelloInfo">ClientHelloInfo</a>
+  and <a href="/pkg/crypto/tls#CertificateRequestInfo">CertificateRequestInfo</a>
+  structs and accessible through the new
+  <a href="/pkg/crypto/tls#ClientHelloInfo.Context">(*ClientHelloInfo).Context</a>
+  and
+  <a href="/pkg/crypto/tls#CertificateRequestInfo.Context">
+      (*CertificateRequestInfo).Context
+  </a> methods respectively. Canceling the context after the handshake has finished
+  has no effect.
+</p>
+
 <h3 id="minor_library_changes">Minor changes to the library</h3>
 
 <p>
@@ -87,6 +104,15 @@ Do not send CLs removing the interior tags from such phrases.
   in mind.
 </p>
 
+<dl id="net/http"><dt><a href="/pkg/net/http/">net/http</a></dt>
+  <p>
+    The <a href="/pkg/net/http/"><code>net/http</code></a> package now uses the new
+    <a href="/pkg/crypto/tls#Conn.HandshakeContext"><code>(*tls.Conn).HandshakeContext</code></a>
+    with the <a href="/pkg/net/http/#Request"><code>Request</code></a> context
+    when performing TLS handshakes in the client or server.
+  </p>
+</dl><!-- net/http -->
+
 <p>
   TODO: complete this section
 </p>
diff --git a/src/crypto/tls/common.go b/src/crypto/tls/common.go
index eec6e1ebbd..5b68742975 100644
--- a/src/crypto/tls/common.go
+++ b/src/crypto/tls/common.go
@@ -7,6 +7,7 @@ package tls
 import (
 	"bytes"
 	"container/list"
+	"context"
 	"crypto"
 	"crypto/ecdsa"
 	"crypto/ed25519"
@@ -443,6 +444,16 @@ type ClientHelloInfo struct {
 	// config is embedded by the GetCertificate or GetConfigForClient caller,
 	// for use with SupportsCertificate.
 	config *Config
+
+	// ctx is the context of the handshake that is in progress.
+	ctx context.Context
+}
+
+// Context returns the context of the handshake that is in progress.
+// This context is a child of the context passed to HandshakeContext,
+// if any, and is canceled when the handshake concludes.
+func (c *ClientHelloInfo) Context() context.Context {
+	return c.ctx
 }
 
 // CertificateRequestInfo contains information from a server's
@@ -461,6 +472,16 @@ type CertificateRequestInfo struct {
 
 	// Version is the TLS version that was negotiated for this connection.
 	Version uint16
+
+	// ctx is the context of the handshake that is in progress.
+	ctx context.Context
+}
+
+// Context returns the context of the handshake that is in progress.
+// This context is a child of the context passed to HandshakeContext,
+// if any, and is canceled when the handshake concludes.
+func (c *CertificateRequestInfo) Context() context.Context {
+	return c.ctx
 }
 
 // RenegotiationSupport enumerates the different levels of support for TLS
diff --git a/src/crypto/tls/conn.go b/src/crypto/tls/conn.go
index 72ad52c194..969f357834 100644
--- a/src/crypto/tls/conn.go
+++ b/src/crypto/tls/conn.go
@@ -8,6 +8,7 @@ package tls
 
 import (
 	"bytes"
+	"context"
 	"crypto/cipher"
 	"crypto/subtle"
 	"crypto/x509"
@@ -27,7 +28,7 @@ type Conn struct {
 	// constant
 	conn        net.Conn
 	isClient    bool
-	handshakeFn func() error // (*Conn).clientHandshake or serverHandshake
+	handshakeFn func(context.Context) error // (*Conn).clientHandshake or serverHandshake
 
 	// handshakeStatus is 1 if the connection is currently transferring
 	// application data (i.e. is not currently processing a handshake).
@@ -1190,7 +1191,7 @@ func (c *Conn) handleRenegotiation() error {
 	defer c.handshakeMutex.Unlock()
 
 	atomic.StoreUint32(&c.handshakeStatus, 0)
-	if c.handshakeErr = c.clientHandshake(); c.handshakeErr == nil {
+	if c.handshakeErr = c.clientHandshake(context.Background()); c.handshakeErr == nil {
 		c.handshakes++
 	}
 	return c.handshakeErr
@@ -1373,8 +1374,61 @@ func (c *Conn) closeNotify() error {
 // first Read or Write will call it automatically.
 //
 // For control over canceling or setting a timeout on a handshake, use
-// the Dialer's DialContext method.
+// HandshakeContext or the Dialer's DialContext method instead.
 func (c *Conn) Handshake() error {
+	return c.HandshakeContext(context.Background())
+}
+
+// HandshakeContext runs the client or server handshake
+// protocol if it has not yet been run.
+//
+// The provided Context must be non-nil. If the context is canceled before
+// the handshake is complete, the handshake is interrupted and an error is returned.
+// Once the handshake has completed, cancellation of the context will not affect the
+// connection.
+//
+// Most uses of this package need not call HandshakeContext explicitly: the
+// first Read or Write will call it automatically.
+func (c *Conn) HandshakeContext(ctx context.Context) error {
+	// Delegate to unexported method for named return
+	// without confusing documented signature.
+	return c.handshakeContext(ctx)
+}
+
+func (c *Conn) handshakeContext(ctx context.Context) (ret error) {
+	handshakeCtx, cancel := context.WithCancel(ctx)
+	// Note: defer this before starting the "interrupter" goroutine
+	// so that we can tell the difference between the input being canceled and
+	// this cancellation. In the former case, we need to close the connection.
+	defer cancel()
+
+	// Start the "interrupter" goroutine, if this context might be canceled.
+	// (The background context cannot).
+	//
+	// The interrupter goroutine waits for the input context to be done and
+	// closes the connection if this happens before the function returns.
+	if ctx.Done() != nil {
+		done := make(chan struct{})
+		interruptRes := make(chan error, 1)
+		defer func() {
+			close(done)
+			if ctxErr := <-interruptRes; ctxErr != nil {
+				// Return context error to user.
+				ret = ctxErr
+			}
+		}()
+		go func() {
+			select {
+			case <-handshakeCtx.Done():
+				// Close the connection, discarding the error
+				_ = c.conn.Close()
+				interruptRes <- handshakeCtx.Err()
+			case <-done:
+				interruptRes <- nil
+			}
+		}()
+	}
+
 	c.handshakeMutex.Lock()
 	defer c.handshakeMutex.Unlock()
 
@@ -1388,7 +1442,7 @@ func (c *Conn) Handshake() error {
 	c.in.Lock()
 	defer c.in.Unlock()
 
-	c.handshakeErr = c.handshakeFn()
+	c.handshakeErr = c.handshakeFn(handshakeCtx)
 	if c.handshakeErr == nil {
 		c.handshakes++
 	} else {
diff --git a/src/crypto/tls/handshake_client.go b/src/crypto/tls/handshake_client.go
index e684b21d52..92e33e7169 100644
--- a/src/crypto/tls/handshake_client.go
+++ b/src/crypto/tls/handshake_client.go
@@ -6,6 +6,7 @@ package tls
 
 import (
 	"bytes"
+	"context"
 	"crypto"
 	"crypto/ecdsa"
 	"crypto/ed25519"
@@ -24,6 +25,7 @@ import (
 
 type clientHandshakeState struct {
 	c            *Conn
+	ctx          context.Context
 	serverHello  *serverHelloMsg
 	hello        *clientHelloMsg
 	suite        *cipherSuite
@@ -134,7 +136,7 @@ func (c *Conn) makeClientHello() (*clientHelloMsg, ecdheParameters, error) {
 	return hello, params, nil
 }
 
-func (c *Conn) clientHandshake() (err error) {
+func (c *Conn) clientHandshake(ctx context.Context) (err error) {
 	if c.config == nil {
 		c.config = defaultConfig()
 	}
@@ -198,6 +200,7 @@ func (c *Conn) clientHandshake() (err error) {
 	if c.vers == VersionTLS13 {
 		hs := &clientHandshakeStateTLS13{
 			c:           c,
+			ctx:         ctx,
 			serverHello: serverHello,
 			hello:       hello,
 			ecdheParams: ecdheParams,
@@ -212,6 +215,7 @@ func (c *Conn) clientHandshake() (err error) {
 
 	hs := &clientHandshakeState{
 		c:           c,
+		ctx:         ctx,
 		serverHello: serverHello,
 		hello:       hello,
 		session:     session,
@@ -540,7 +544,7 @@ func (hs *clientHandshakeState) doFullHandshake() error {
 		certRequested = true
 		hs.finishedHash.Write(certReq.marshal())
 
-		cri := certificateRequestInfoFromMsg(c.vers, certReq)
+		cri := certificateRequestInfoFromMsg(hs.ctx, c.vers, certReq)
 		if chainToSend, err = c.getClientCertificate(cri); err != nil {
 			c.sendAlert(alertInternalError)
 			return err
@@ -880,10 +884,11 @@ func (c *Conn) verifyServerCertificate(certificates [][]byte) error {
 
 // certificateRequestInfoFromMsg generates a CertificateRequestInfo from a TLS
 // <= 1.2 CertificateRequest, making an effort to fill in missing information.
-func certificateRequestInfoFromMsg(vers uint16, certReq *certificateRequestMsg) *CertificateRequestInfo {
+func certificateRequestInfoFromMsg(ctx context.Context, vers uint16, certReq *certificateRequestMsg) *CertificateRequestInfo {
 	cri := &CertificateRequestInfo{
 		AcceptableCAs: certReq.certificateAuthorities,
 		Version:       vers,
+		ctx:           ctx,
 	}
 
 	var rsaAvail, ecAvail bool
diff --git a/src/crypto/tls/handshake_client_test.go b/src/crypto/tls/handshake_client_test.go
index 693f9686a7..2f30b3008d 100644
--- a/src/crypto/tls/handshake_client_test.go
+++ b/src/crypto/tls/handshake_client_test.go
@@ -6,6 +6,7 @@ package tls
 
 import (
 	"bytes"
+	"context"
 	"crypto/rsa"
 	"crypto/x509"
 	"encoding/base64"
@@ -20,6 +21,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"reflect"
+	"runtime"
 	"strconv"
 	"strings"
 	"testing"
@@ -2511,3 +2513,37 @@ func testResumptionKeepsOCSPAndSCT(t *testing.T, ver uint16) {
 			serverConfig.Certificates[0].SignedCertificateTimestamps, ccs.SignedCertificateTimestamps)
 	}
 }
+
+func TestClientHandshakeContextCancellation(t *testing.T) {
+	c, s := localPipe(t)
+	serverConfig := testConfig.Clone()
+	serverErr := make(chan error, 1)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	go func() {
+		defer close(serverErr)
+		defer s.Close()
+		conn := Server(s, serverConfig)
+		_, err := conn.readClientHello(ctx)
+		cancel()
+		serverErr <- err
+	}()
+	cli := Client(c, testConfig)
+	err := cli.HandshakeContext(ctx)
+	if err == nil {
+		t.Fatal("Client handshake did not error when the context was canceled")
+	}
+	if err != context.Canceled {
+		t.Errorf("Unexpected client handshake error: %v", err)
+	}
+	if err := <-serverErr; err != nil {
+		t.Errorf("Unexpected server error: %v", err)
+	}
+	if runtime.GOARCH == "wasm" {
+		t.Skip("conn.Close does not error as expected when called multiple times on WASM")
+	}
+	err = cli.Close()
+	if err == nil {
+		t.Error("Client connection was not closed when the context was canceled")
+	}
+}
diff --git a/src/crypto/tls/handshake_client_tls13.go b/src/crypto/tls/handshake_client_tls13.go
index daa5d97fd3..be37c681c6 100644
--- a/src/crypto/tls/handshake_client_tls13.go
+++ b/src/crypto/tls/handshake_client_tls13.go
@@ -6,6 +6,7 @@ package tls
 
 import (
 	"bytes"
+	"context"
 	"crypto"
 	"crypto/hmac"
 	"crypto/rsa"
@@ -17,6 +18,7 @@ import (
 
 type clientHandshakeStateTLS13 struct {
 	c           *Conn
+	ctx         context.Context
 	serverHello *serverHelloMsg
 	hello       *clientHelloMsg
 	ecdheParams ecdheParameters
@@ -555,6 +557,7 @@ func (hs *clientHandshakeStateTLS13) sendClientCertificate() error {
 		AcceptableCAs:    hs.certReq.certificateAuthorities,
 		SignatureSchemes: hs.certReq.supportedSignatureAlgorithms,
 		Version:          c.vers,
+		ctx:              hs.ctx,
 	})
 	if err != nil {
 		return err
diff --git a/src/crypto/tls/handshake_server.go b/src/crypto/tls/handshake_server.go
index 9c3e0f636e..5a572a9db1 100644
--- a/src/crypto/tls/handshake_server.go
+++ b/src/crypto/tls/handshake_server.go
@@ -5,6 +5,7 @@
 package tls
 
 import (
+	"context"
 	"crypto"
 	"crypto/ecdsa"
 	"crypto/ed25519"
@@ -23,6 +24,7 @@ import (
 // It's discarded once the handshake has completed.
 type serverHandshakeState struct {
 	c            *Conn
+	ctx          context.Context
 	clientHello  *clientHelloMsg
 	hello        *serverHelloMsg
 	suite        *cipherSuite
@@ -37,8 +39,8 @@ type serverHandshakeState struct {
 }
 
 // serverHandshake performs a TLS handshake as a server.
-func (c *Conn) serverHandshake() error {
-	clientHello, err := c.readClientHello()
+func (c *Conn) serverHandshake(ctx context.Context) error {
+	clientHello, err := c.readClientHello(ctx)
 	if err != nil {
 		return err
 	}
@@ -46,6 +48,7 @@ func (c *Conn) serverHandshake() error {
 	if c.vers == VersionTLS13 {
 		hs := serverHandshakeStateTLS13{
 			c:           c,
+			ctx:         ctx,
 			clientHello: clientHello,
 		}
 		return hs.handshake()
@@ -53,6 +56,7 @@ func (c *Conn) serverHandshake() error {
 
 	hs := serverHandshakeState{
 		c:           c,
+		ctx:         ctx,
 		clientHello: clientHello,
 	}
 	return hs.handshake()
@@ -124,7 +128,7 @@ func (hs *serverHandshakeState) handshake() error {
 }
 
 // readClientHello reads a ClientHello message and selects the protocol version.
-func (c *Conn) readClientHello() (*clientHelloMsg, error) {
+func (c *Conn) readClientHello(ctx context.Context) (*clientHelloMsg, error) {
 	msg, err := c.readHandshake()
 	if err != nil {
 		return nil, err
@@ -138,7 +142,7 @@ func (c *Conn) readClientHello() (*clientHelloMsg, error) {
 	var configForClient *Config
 	originalConfig := c.config
 	if c.config.GetConfigForClient != nil {
-		chi := clientHelloInfo(c, clientHello)
+		chi := clientHelloInfo(ctx, c, clientHello)
 		if configForClient, err = c.config.GetConfigForClient(chi); err != nil {
 			c.sendAlert(alertInternalError)
 			return nil, err
@@ -220,7 +224,7 @@ func (hs *serverHandshakeState) processClientHello() error {
 		}
 	}
 
-	hs.cert, err = c.config.getCertificate(clientHelloInfo(c, hs.clientHello))
+	hs.cert, err = c.config.getCertificate(clientHelloInfo(hs.ctx, c, hs.clientHello))
 	if err != nil {
 		if err == errNoCertificates {
 			c.sendAlert(alertUnrecognizedName)
@@ -828,7 +832,7 @@ func (c *Conn) processCertsFromClient(certificate Certificate) error {
 	return nil
 }
 
-func clientHelloInfo(c *Conn, clientHello *clientHelloMsg) *ClientHelloInfo {
+func clientHelloInfo(ctx context.Context, c *Conn, clientHello *clientHelloMsg) *ClientHelloInfo {
 	supportedVersions := clientHello.supportedVersions
 	if len(clientHello.supportedVersions) == 0 {
 		supportedVersions = supportedVersionsFromMax(clientHello.vers)
@@ -844,5 +848,6 @@ func clientHelloInfo(c *Conn, clientHello *clientHelloMsg) *ClientHelloInfo {
 		SupportedVersions: supportedVersions,
 		Conn:              c.conn,
 		config:            c.config,
+		ctx:               ctx,
 	}
 }
diff --git a/src/crypto/tls/handshake_server_test.go b/src/crypto/tls/handshake_server_test.go
index d6bf9e439b..432b4cfe35 100644
--- a/src/crypto/tls/handshake_server_test.go
+++ b/src/crypto/tls/handshake_server_test.go
@@ -6,6 +6,7 @@ package tls
 
 import (
 	"bytes"
+	"context"
 	"crypto"
 	"crypto/elliptic"
 	"crypto/x509"
@@ -17,6 +18,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"runtime"
 	"strings"
 	"testing"
 	"time"
@@ -38,10 +40,12 @@ func testClientHelloFailure(t *testing.T, serverConfig *Config, m handshakeMessa
 		cli.writeRecord(recordTypeHandshake, m.marshal())
 		c.Close()
 	}()
+	ctx := context.Background()
 	conn := Server(s, serverConfig)
-	ch, err := conn.readClientHello()
+	ch, err := conn.readClientHello(ctx)
 	hs := serverHandshakeState{
 		c:           conn,
+		ctx:         ctx,
 		clientHello: ch,
 	}
 	if err == nil {
@@ -1421,9 +1425,11 @@ func TestSNIGivenOnFailure(t *testing.T) {
 		c.Close()
 	}()
 	conn := Server(s, serverConfig)
-	ch, err := conn.readClientHello()
+	ctx := context.Background()
+	ch, err := conn.readClientHello(ctx)
 	hs := serverHandshakeState{
 		c:           conn,
+		ctx:         ctx,
 		clientHello: ch,
 	}
 	if err == nil {
@@ -1939,3 +1945,112 @@ func TestAESCipherReordering13(t *testing.T) {
 		})
 	}
 }
+
+func TestServerHandshakeContextCancellation(t *testing.T) {
+	c, s := localPipe(t)
+	clientConfig := testConfig.Clone()
+	clientErr := make(chan error, 1)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	go func() {
+		defer close(clientErr)
+		defer c.Close()
+		clientHello := &clientHelloMsg{
+			vers:               VersionTLS10,
+			random:             make([]byte, 32),
+			cipherSuites:       []uint16{TLS_RSA_WITH_RC4_128_SHA},
+			compressionMethods: []uint8{compressionNone},
+		}
+		cli := Client(c, clientConfig)
+		_, err := cli.writeRecord(recordTypeHandshake, clientHello.marshal())
+		cancel()
+		clientErr <- err
+	}()
+	conn := Server(s, testConfig)
+	err := conn.HandshakeContext(ctx)
+	if err == nil {
+		t.Fatal("Server handshake did not error when the context was canceled")
+	}
+	if err != context.Canceled {
+		t.Errorf("Unexpected server handshake error: %v", err)
+	}
+	if err := <-clientErr; err != nil {
+		t.Errorf("Unexpected client error: %v", err)
+	}
+	if runtime.GOARCH == "wasm" {
+		t.Skip("conn.Close does not error as expected when called multiple times on WASM")
+	}
+	err = conn.Close()
+	if err == nil {
+		t.Error("Server connection was not closed when the context was canceled")
+	}
+}
+
+// TestHandshakeContextHierarchy tests whether the contexts
+// available to GetClientCertificate and GetCertificate are
+// derived from the context provided to HandshakeContext, and
+// that those contexts are cancelled after HandshakeContext has
+// returned.
+func TestHandshakeContextHierarchy(t *testing.T) {
+	c, s := localPipe(t)
+	clientErr := make(chan error, 1)
+	clientConfig := testConfig.Clone()
+	serverConfig := testConfig.Clone()
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	key := struct{}{}
+	ctx = context.WithValue(ctx, key, true)
+	go func() {
+		defer close(clientErr)
+		defer c.Close()
+		var innerCtx context.Context
+		clientConfig.Certificates = nil
+		clientConfig.GetClientCertificate = func(certificateRequest *CertificateRequestInfo) (*Certificate, error) {
+			if val, ok := certificateRequest.Context().Value(key).(bool); !ok || !val {
+				t.Errorf("GetClientCertificate context was not child of HandshakeContext")
+			}
+			innerCtx = certificateRequest.Context()
+			return &Certificate{
+				Certificate: [][]byte{testRSACertificate},
+				PrivateKey:  testRSAPrivateKey,
+			}, nil
+		}
+		cli := Client(c, clientConfig)
+		err := cli.HandshakeContext(ctx)
+		if err != nil {
+			clientErr <- err
+			return
+		}
+		select {
+		case <-innerCtx.Done():
+		default:
+			t.Errorf("GetClientCertificate context was not cancelled after HandshakeContext returned.")
+		}
+	}()
+	var innerCtx context.Context
+	serverConfig.Certificates = nil
+	serverConfig.ClientAuth = RequestClientCert
+	serverConfig.GetCertificate = func(clientHello *ClientHelloInfo) (*Certificate, error) {
+		if val, ok := clientHello.Context().Value(key).(bool); !ok || !val {
+			t.Errorf("GetClientCertificate context was not child of HandshakeContext")
+		}
+		innerCtx = clientHello.Context()
+		return &Certificate{
+			Certificate: [][]byte{testRSACertificate},
+			PrivateKey:  testRSAPrivateKey,
+		}, nil
+	}
+	conn := Server(s, serverConfig)
+	err := conn.HandshakeContext(ctx)
+	if err != nil {
+		t.Errorf("Unexpected server handshake error: %v", err)
+	}
+	select {
+	case <-innerCtx.Done():
+	default:
+		t.Errorf("GetCertificate context was not cancelled after HandshakeContext returned.")
+	}
+	if err := <-clientErr; err != nil {
+		t.Errorf("Unexpected client error: %v", err)
+	}
+}
diff --git a/src/crypto/tls/handshake_server_tls13.go b/src/crypto/tls/handshake_server_tls13.go
index c2c288aed4..c7837d2955 100644
--- a/src/crypto/tls/handshake_server_tls13.go
+++ b/src/crypto/tls/handshake_server_tls13.go
@@ -6,6 +6,7 @@ package tls
 
 import (
 	"bytes"
+	"context"
 	"crypto"
 	"crypto/hmac"
 	"crypto/rsa"
@@ -23,6 +24,7 @@ const maxClientPSKIdentities = 5
 
 type serverHandshakeStateTLS13 struct {
 	c               *Conn
+	ctx             context.Context
 	clientHello     *clientHelloMsg
 	hello           *serverHelloMsg
 	sentDummyCCS    bool
@@ -374,7 +376,7 @@ func (hs *serverHandshakeStateTLS13) pickCertificate() error {
 		return c.sendAlert(alertMissingExtension)
 	}
 
-	certificate, err := c.config.getCertificate(clientHelloInfo(c, hs.clientHello))
+	certificate, err := c.config.getCertificate(clientHelloInfo(hs.ctx, c, hs.clientHello))
 	if err != nil {
 		if err == errNoCertificates {
 			c.sendAlert(alertUnrecognizedName)
diff --git a/src/crypto/tls/tls.go b/src/crypto/tls/tls.go
index 4989364958..b529c70523 100644
--- a/src/crypto/tls/tls.go
+++ b/src/crypto/tls/tls.go
@@ -25,7 +25,6 @@ import (
 	"net"
 	"os"
 	"strings"
-	"time"
 )
 
 // Server returns a new TLS server side connection
@@ -119,28 +118,16 @@ func DialWithDialer(dialer *net.Dialer, network, addr string, config *Config) (*
 }
 
 func dial(ctx context.Context, netDialer *net.Dialer, network, addr string, config *Config) (*Conn, error) {
-	// We want the Timeout and Deadline values from dialer to cover the
-	// whole process: TCP connection and TLS handshake. This means that we
-	// also need to start our own timers now.
-	timeout := netDialer.Timeout
-
-	if !netDialer.Deadline.IsZero() {
-		deadlineTimeout := time.Until(netDialer.Deadline)
-		if timeout == 0 || deadlineTimeout < timeout {
-			timeout = deadlineTimeout
-		}
+	if netDialer.Timeout != 0 {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, netDialer.Timeout)
+		defer cancel()
 	}
 
-	// hsErrCh is non-nil if we might not wait for Handshake to complete.
-	var hsErrCh chan error
-	if timeout != 0 || ctx.Done() != nil {
-		hsErrCh = make(chan error, 2)
-	}
-	if timeout != 0 {
-		timer := time.AfterFunc(timeout, func() {
-			hsErrCh <- timeoutError{}
-		})
-		defer timer.Stop()
+	if !netDialer.Deadline.IsZero() {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithDeadline(ctx, netDialer.Deadline)
+		defer cancel()
 	}
 
 	rawConn, err := netDialer.DialContext(ctx, network, addr)
@@ -167,34 +154,10 @@ func dial(ctx context.Context, netDialer *net.Dialer, network, addr string, conf
 	}
 
 	conn := Client(rawConn, config)
-
-	if hsErrCh == nil {
-		err = conn.Handshake()
-	} else {
-		go func() {
-			hsErrCh <- conn.Handshake()
-		}()
-
-		select {
-		case <-ctx.Done():
-			err = ctx.Err()
-		case err = <-hsErrCh:
-			if err != nil {
-				// If the error was due to the context
-				// closing, prefer the context's error, rather
-				// than some random network teardown error.
-				if e := ctx.Err(); e != nil {
-					err = e
-				}
-			}
-		}
-	}
-
-	if err != nil {
+	if err := conn.HandshakeContext(ctx); err != nil {
 		rawConn.Close()
 		return nil, err
 	}
-
 	return conn, nil
 }
 
diff --git a/src/net/http/server.go b/src/net/http/server.go
index ea3486289a..f095b7edd2 100644
--- a/src/net/http/server.go
+++ b/src/net/http/server.go
@@ -1837,7 +1837,7 @@ func (c *conn) serve(ctx context.Context) {
 		if d := c.server.WriteTimeout; d != 0 {
 			c.rwc.SetWriteDeadline(time.Now().Add(d))
 		}
-		if err := tlsConn.Handshake(); err != nil {
+		if err := tlsConn.HandshakeContext(ctx); err != nil {
 			// If the handshake failed due to the client not speaking
 			// TLS, assume they're speaking plaintext HTTP and write a
 			// 400 response on the TLS conn's underlying net.Conn.
diff --git a/src/net/http/transport.go b/src/net/http/transport.go
index 0aa48273dd..6358c3897e 100644
--- a/src/net/http/transport.go
+++ b/src/net/http/transport.go
@@ -1505,7 +1505,7 @@ func (t *Transport) decConnsPerHost(key connectMethodKey) {
 // Add TLS to a persistent connection, i.e. negotiate a TLS session. If pconn is already a TLS
 // tunnel, this function establishes a nested TLS session inside the encrypted channel.
 // The remote endpoint's name may be overridden by TLSClientConfig.ServerName.
-func (pconn *persistConn) addTLS(name string, trace *httptrace.ClientTrace) error {
+func (pconn *persistConn) addTLS(ctx context.Context, name string, trace *httptrace.ClientTrace) error {
 	// Initiate TLS and check remote host name against certificate.
 	cfg := cloneTLSConfig(pconn.t.TLSClientConfig)
 	if cfg.ServerName == "" {
@@ -1527,7 +1527,7 @@ func (pconn *persistConn) addTLS(name string, trace *httptrace.ClientTrace) erro
 		if trace != nil && trace.TLSHandshakeStart != nil {
 			trace.TLSHandshakeStart()
 		}
-		err := tlsConn.Handshake()
+		err := tlsConn.HandshakeContext(ctx)
 		if timer != nil {
 			timer.Stop()
 		}
@@ -1583,7 +1583,7 @@ func (t *Transport) dialConn(ctx context.Context, cm connectMethod) (pconn *pers
 			if trace != nil && trace.TLSHandshakeStart != nil {
 				trace.TLSHandshakeStart()
 			}
-			if err := tc.Handshake(); err != nil {
+			if err := tc.HandshakeContext(ctx); err != nil {
 				go pconn.conn.Close()
 				if trace != nil && trace.TLSHandshakeDone != nil {
 					trace.TLSHandshakeDone(tls.ConnectionState{}, err)
@@ -1607,7 +1607,7 @@ func (t *Transport) dialConn(ctx context.Context, cm connectMethod) (pconn *pers
 			if firstTLSHost, _, err = net.SplitHostPort(cm.addr()); err != nil {
 				return nil, wrapErr(err)
 			}
-			if err = pconn.addTLS(firstTLSHost, trace); err != nil {
+			if err = pconn.addTLS(ctx, firstTLSHost, trace); err != nil {
 				return nil, wrapErr(err)
 			}
 		}
@@ -1721,7 +1721,7 @@ func (t *Transport) dialConn(ctx context.Context, cm connectMethod) (pconn *pers
 	}
 
 	if cm.proxyURL != nil && cm.targetScheme == "https" {
-		if err := pconn.addTLS(cm.tlsHost(), trace); err != nil {
+		if err := pconn.addTLS(ctx, cm.tlsHost(), trace); err != nil {
 			return nil, err
 		}
 	}
diff --git a/src/net/http/transport_test.go b/src/net/http/transport_test.go
index ba85a61683..7f6e0938c2 100644
--- a/src/net/http/transport_test.go
+++ b/src/net/http/transport_test.go
@@ -3734,7 +3734,7 @@ func TestTransportDialTLSContext(t *testing.T) {
 		if err != nil {
 			return nil, err
 		}
-		return c, c.Handshake()
+		return c, c.HandshakeContext(ctx)
 	}
 
 	req, err := NewRequest("GET", ts.URL, nil)
-- 
GitLab


From bd0fc0b9c32e3697380a6484154accacdb928f97 Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Wed, 10 Mar 2021 14:41:38 -0600
Subject: [PATCH 1110/2400] cmd/link: preserve elf phdr flags when loading
 external objects

Preserve program header flags when passing them through loadelf.Load.
They shouldn't be coerced to 0 on non-ARM platforms which set them
such as ppc64le.

Change-Id: I022613356f910d812de2fc22eac949960eeb53b3
Reviewed-on: https://go-review.googlesource.com/c/go/+/300950
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/cmd/link/internal/loadelf/ldelf.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/cmd/link/internal/loadelf/ldelf.go b/src/cmd/link/internal/loadelf/ldelf.go
index 6e3b2c077d..e373a6e0b4 100644
--- a/src/cmd/link/internal/loadelf/ldelf.go
+++ b/src/cmd/link/internal/loadelf/ldelf.go
@@ -252,6 +252,8 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, f *bio.Reader,
 		return nil, 0, fmt.Errorf("loadelf: %s: %v", pn, fmt.Sprintf(str, args...))
 	}
 
+	ehdrFlags = initEhdrFlags
+
 	base := f.Offset()
 
 	var hdrbuf [64]byte
-- 
GitLab


From e31e84010e0989e1df4bd2c55d529497119bb345 Mon Sep 17 00:00:00 2001
From: Meng Zhuo <mzh@golangcn.org>
Date: Tue, 16 Mar 2021 18:51:41 +0800
Subject: [PATCH 1111/2400] cmd/asm: add rotr/drotr for mips64
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This CL encodes:

ROTR rd, rt, sa
ROTRV rd, rt, rs

=> ROTR (SCON|REG), (REG,)? REG

DROTR rd, rt, sa
DROTR32 rd, rt, sa
DROTRV rd, rt, rs

=> ROTRV (SCON|REG), (REG,)? REG

Note: ROTRV will handle const over 32
Ref: The MIPS64® Instruction Set Reference Manual Revision 6.05
Change-Id: Ibe69f999b83eb43843d088cf1ac5a13c995269a5
Reviewed-on: https://go-review.googlesource.com/c/go/+/280114
Trust: Meng Zhuo <mzh@golangcn.org>
Run-TryBot: Meng Zhuo <mzh@golangcn.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/asm/internal/asm/testdata/mips64.s |  8 ++++++++
 src/cmd/internal/obj/mips/a.out.go         |  2 ++
 src/cmd/internal/obj/mips/anames.go        |  2 ++
 src/cmd/internal/obj/mips/asm0.go          | 15 ++++++++++++++-
 4 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/src/cmd/asm/internal/asm/testdata/mips64.s b/src/cmd/asm/internal/asm/testdata/mips64.s
index 21ab82f319..99044d89f7 100644
--- a/src/cmd/asm/internal/asm/testdata/mips64.s
+++ b/src/cmd/asm/internal/asm/testdata/mips64.s
@@ -407,6 +407,8 @@ label4:
 	SRLV	R27, R6, R17	// 03668816
 	SRA	R11, R19, R20	// 0173a007
 	SRAV	R20, R19, R19	// 02939817
+	ROTR	R19, R18, R20	// 0272a046
+	ROTRV	R9, R13, R16	// 012d8056
 
 //	LSHW rreg ',' rreg
 //	{
@@ -418,6 +420,8 @@ label4:
 	SRLV	R27, R6   	// 03663016
 	SRA	R11, R19	// 01739807
 	SRAV	R20, R19	// 02939817
+	ROTR	R20, R19	// 02939846
+	ROTRV	R16, R9		// 02094856
 
 //	LSHW imm ',' sreg ',' rreg
 //	{
@@ -429,6 +433,8 @@ label4:
 	SRLV	$31, R6, R17	// 00068ffa
 	SRA	$8, R8, R19	// 00089a03
 	SRAV	$19, R8, R7	// 00083cfb
+	ROTR	$12, R8, R3	// 00281b02
+	ROTRV	$8, R22, R22	// 0036b23a
 
 //	LSHW imm ',' rreg
 //	{
@@ -440,6 +446,8 @@ label4:
 	SRLV	$31, R17	// 00118ffa
 	SRA	$3, R12		// 000c60c3
 	SRAV	$12, R3		// 00031b3b
+	ROTR	$12, R8		// 00284302
+	ROTRV	$63, R22	// 0036b7fe
 
 
 //	LAND/LXOR/LNOR/LOR rreg ',' rreg
diff --git a/src/cmd/internal/obj/mips/a.out.go b/src/cmd/internal/obj/mips/a.out.go
index ddd048a17f..c6ce53a8da 100644
--- a/src/cmd/internal/obj/mips/a.out.go
+++ b/src/cmd/internal/obj/mips/a.out.go
@@ -390,6 +390,8 @@ const (
 	AREM
 	AREMU
 	ARFE
+	AROTR
+	AROTRV
 	ASC
 	ASCV
 	ASGT
diff --git a/src/cmd/internal/obj/mips/anames.go b/src/cmd/internal/obj/mips/anames.go
index 2a44e4ca70..ca2ad5ae26 100644
--- a/src/cmd/internal/obj/mips/anames.go
+++ b/src/cmd/internal/obj/mips/anames.go
@@ -78,6 +78,8 @@ var Anames = []string{
 	"REM",
 	"REMU",
 	"RFE",
+	"ROTR",
+	"ROTRV",
 	"SC",
 	"SCV",
 	"SGT",
diff --git a/src/cmd/internal/obj/mips/asm0.go b/src/cmd/internal/obj/mips/asm0.go
index fd29f9fa21..e475ffdc14 100644
--- a/src/cmd/internal/obj/mips/asm0.go
+++ b/src/cmd/internal/obj/mips/asm0.go
@@ -1022,10 +1022,12 @@ func buildop(ctxt *obj.Link) {
 		case ASLL:
 			opset(ASRL, r0)
 			opset(ASRA, r0)
+			opset(AROTR, r0)
 
 		case ASLLV:
 			opset(ASRAV, r0)
 			opset(ASRLV, r0)
+			opset(AROTRV, r0)
 
 		case ASUB:
 			opset(ASUBU, r0)
@@ -1732,12 +1734,16 @@ func (c *ctxt0) oprrr(a obj.As) uint32 {
 		return OP(0, 6)
 	case ASRA:
 		return OP(0, 7)
+	case AROTR:
+		return OP(8, 6)
 	case ASLLV:
 		return OP(2, 4)
 	case ASRLV:
 		return OP(2, 6)
 	case ASRAV:
 		return OP(2, 7)
+	case AROTRV:
+		return OP(10, 6)
 	case AADDV:
 		return OP(5, 4)
 	case AADDVU:
@@ -1916,6 +1922,8 @@ func (c *ctxt0) opirr(a obj.As) uint32 {
 		return OP(0, 2)
 	case ASRA:
 		return OP(0, 3)
+	case AROTR:
+		return OP(0, 2) | 1<<21
 	case AADDV:
 		return SP(3, 0)
 	case AADDVU:
@@ -2028,12 +2036,16 @@ func (c *ctxt0) opirr(a obj.As) uint32 {
 		return OP(7, 2)
 	case ASRAV:
 		return OP(7, 3)
+	case AROTRV:
+		return OP(7, 2) | 1<<21
 	case -ASLLV:
 		return OP(7, 4)
 	case -ASRLV:
 		return OP(7, 6)
 	case -ASRAV:
 		return OP(7, 7)
+	case -AROTRV:
+		return OP(7, 6) | 1<<21
 
 	case ATEQ:
 		return OP(6, 4)
@@ -2061,7 +2073,8 @@ func vshift(a obj.As) bool {
 	switch a {
 	case ASLLV,
 		ASRLV,
-		ASRAV:
+		ASRAV,
+		AROTRV:
 		return true
 	}
 	return false
-- 
GitLab


From 832a01aad409dc0e41eabb53bfdb64d1a41b2c83 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Mon, 15 Mar 2021 10:27:06 -0700
Subject: [PATCH 1112/2400] cmd/compile:  deal with comparable embedded in a
 constraint

Ignore an embedded type in an interface which is the predeclared
interface "comparable" (which currently can only be in a type
constraint), since the name doesn't resolve and the "comparable" type
doesn't have any relevant methods (for the purposes of the compiler).

Added new test case graph.go that needs this fix.

Change-Id: I2443d2c3dfeb9d0a78aaaaf91a2808ae2759d247
Reviewed-on: https://go-review.googlesource.com/c/go/+/301831
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/types.go |  11 +-
 src/cmd/compile/internal/types2/type.go |   1 +
 test/typeparam/graph.go                 | 231 ++++++++++++++++++++++++
 3 files changed, 242 insertions(+), 1 deletion(-)
 create mode 100644 test/typeparam/graph.go

diff --git a/src/cmd/compile/internal/noder/types.go b/src/cmd/compile/internal/noder/types.go
index c5506ab472..b196cb5945 100644
--- a/src/cmd/compile/internal/noder/types.go
+++ b/src/cmd/compile/internal/noder/types.go
@@ -181,11 +181,20 @@ func (g *irgen) typ0(typ types2.Type) *types.Type {
 
 	case *types2.Interface:
 		embeddeds := make([]*types.Field, typ.NumEmbeddeds())
+		j := 0
 		for i := range embeddeds {
 			// TODO(mdempsky): Get embedding position.
 			e := typ.EmbeddedType(i)
-			embeddeds[i] = types.NewField(src.NoXPos, nil, g.typ1(e))
+			if t := types2.AsInterface(e); t != nil && t.IsComparable() {
+				// Ignore predefined type 'comparable', since it
+				// doesn't resolve and it doesn't have any
+				// relevant methods.
+				continue
+			}
+			embeddeds[j] = types.NewField(src.NoXPos, nil, g.typ1(e))
+			j++
 		}
+		embeddeds = embeddeds[:j]
 
 		methods := make([]*types.Field, typ.NumExplicitMethods())
 		for i := range methods {
diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
index e4d6d0432d..277ed06026 100644
--- a/src/cmd/compile/internal/types2/type.go
+++ b/src/cmd/compile/internal/types2/type.go
@@ -971,3 +971,4 @@ func asTypeParam(t Type) *TypeParam {
 func AsPointer(t Type) *Pointer     { return asPointer(t) }
 func AsNamed(t Type) *Named         { return asNamed(t) }
 func AsSignature(t Type) *Signature { return asSignature(t) }
+func AsInterface(t Type) *Interface { return asInterface(t) }
diff --git a/test/typeparam/graph.go b/test/typeparam/graph.go
new file mode 100644
index 0000000000..f2a2630ad0
--- /dev/null
+++ b/test/typeparam/graph.go
@@ -0,0 +1,231 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 (
+	"errors"
+	"fmt"
+)
+
+// _Equal reports whether two slices are equal: the same length and all
+// elements equal. All floating point NaNs are considered equal.
+func _SliceEqual[Elem comparable](s1, s2 []Elem) bool {
+	if len(s1) != len(s2) {
+		return false
+	}
+	for i, v1 := range s1 {
+		v2 := s2[i]
+		if v1 != v2 {
+			isNaN := func(f Elem) bool { return f != f }
+			if !isNaN(v1) || !isNaN(v2) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// A Graph is a collection of nodes. A node may have an arbitrary number
+// of edges. An edge connects two nodes. Both nodes and edges must be
+// comparable. This is an undirected simple graph.
+type _Graph[_Node _NodeC[_Edge], _Edge _EdgeC[_Node]] struct {
+	nodes []_Node
+}
+
+// _NodeC is the contraints on a node in a graph, given the _Edge type.
+type _NodeC[_Edge any] interface {
+	comparable
+	Edges() []_Edge
+}
+
+// Edgec is the constraints on an edge in a graph, given the _Node type.
+type _EdgeC[_Node any] interface {
+	comparable
+	Nodes() (a, b _Node)
+}
+
+// _New creates a new _Graph from a collection of Nodes.
+func _New[_Node _NodeC[_Edge], _Edge _EdgeC[_Node]](nodes []_Node) *_Graph[_Node, _Edge] {
+	return &_Graph[_Node, _Edge]{nodes: nodes}
+}
+
+// nodePath holds the path to a node during ShortestPath.
+// This should ideally be a type defined inside ShortestPath,
+// but the translator tool doesn't support that.
+type nodePath[_Node _NodeC[_Edge], _Edge _EdgeC[_Node]] struct {
+	node _Node
+	path []_Edge
+}
+
+// ShortestPath returns the shortest path between two nodes,
+// as an ordered list of edges. If there are multiple shortest paths,
+// which one is returned is unpredictable.
+func (g *_Graph[_Node, _Edge]) ShortestPath(from, to _Node) ([]_Edge, error) {
+	visited := make(map[_Node]bool)
+	visited[from] = true
+	workqueue := []nodePath[_Node, _Edge]{nodePath[_Node, _Edge]{from, nil}}
+	for len(workqueue) > 0 {
+		current := workqueue
+		workqueue = nil
+		for _, np := range current {
+			edges := np.node.Edges()
+			for _, edge := range edges {
+				a, b := edge.Nodes()
+				if a == np.node {
+					a = b
+				}
+				if !visited[a] {
+					ve := append([]_Edge(nil), np.path...)
+					ve = append(ve, edge)
+					if a == to {
+						return ve, nil
+					}
+					workqueue = append(workqueue, nodePath[_Node, _Edge]{a, ve})
+					visited[a] = true
+				}
+			}
+		}
+	}
+	return nil, errors.New("no path")
+}
+
+type direction int
+
+const (
+	north direction = iota
+	ne
+	east
+	se
+	south
+	sw
+	west
+	nw
+	up
+	down
+)
+
+func (dir direction) String() string {
+	strs := map[direction]string{
+		north: "north",
+		ne:    "ne",
+		east:  "east",
+		se:    "se",
+		south: "south",
+		sw:    "sw",
+		west:  "west",
+		nw:    "nw",
+		up:    "up",
+		down:  "down",
+	}
+	if str, ok := strs[dir]; ok {
+		return str
+	}
+	return fmt.Sprintf("direction %d", dir)
+}
+
+type mazeRoom struct {
+	index int
+	exits [10]int
+}
+
+type mazeEdge struct {
+	from, to int
+	dir      direction
+}
+
+// Edges returns the exits from the room.
+func (m mazeRoom) Edges() []mazeEdge {
+	var r []mazeEdge
+	for i, exit := range m.exits {
+		if exit != 0 {
+			r = append(r, mazeEdge{
+				from: m.index,
+				to:   exit,
+				dir:  direction(i),
+			})
+		}
+	}
+	return r
+}
+
+// Nodes returns the rooms connected by an edge.
+//go:noinline
+func (e mazeEdge) Nodes() (mazeRoom, mazeRoom) {
+	m1, ok := zork[e.from]
+	if !ok {
+		panic("bad edge")
+	}
+	m2, ok := zork[e.to]
+	if !ok {
+		panic("bad edge")
+	}
+	return m1, m2
+}
+
+// The first maze in Zork. Room indexes based on original Fortran data file.
+// You are in a maze of twisty little passages, all alike.
+var zork = map[int]mazeRoom{
+	11: {exits: [10]int{north: 11, south: 12, east: 14}}, // west to Troll Room
+	12: {exits: [10]int{south: 11, north: 14, east: 13}},
+	13: {exits: [10]int{west: 12, north: 14, up: 16}},
+	14: {exits: [10]int{west: 13, north: 11, east: 15}},
+	15: {exits: [10]int{south: 14}},                   // Dead End
+	16: {exits: [10]int{east: 17, north: 13, sw: 18}}, // skeleton, etc.
+	17: {exits: [10]int{west: 16}},                    // Dead End
+	18: {exits: [10]int{down: 16, east: 19, west: 18, up: 22}},
+	19: {exits: [10]int{up: 29, west: 18, ne: 15, east: 20, south: 30}},
+	20: {exits: [10]int{ne: 19, west: 20, se: 21}},
+	21: {exits: [10]int{north: 20}}, // Dead End
+	22: {exits: [10]int{north: 18, east: 24, down: 23, south: 28, west: 26, nw: 22}},
+	23: {exits: [10]int{east: 22, west: 28, up: 24}},
+	24: {exits: [10]int{ne: 25, down: 23, nw: 28, sw: 26}},
+	25: {exits: [10]int{sw: 24}}, // Grating room (up to Clearing)
+	26: {exits: [10]int{west: 16, sw: 24, east: 28, up: 22, north: 27}},
+	27: {exits: [10]int{south: 26}}, // Dead End
+	28: {exits: [10]int{east: 22, down: 26, south: 23, west: 24}},
+	29: {exits: [10]int{west: 30, nw: 29, ne: 19, south: 19}},
+	30: {exits: [10]int{west: 29, south: 19}}, // ne to Cyclops Room
+}
+
+func TestShortestPath() {
+	// The Zork maze is not a proper undirected simple graph,
+	// as there are some one way paths (e.g., 19 -> 15),
+	// but for this test that doesn't matter.
+
+	// Set the index field in the map. Simpler than doing it in the
+	// composite literal.
+	for k := range zork {
+		r := zork[k]
+		r.index = k
+		zork[k] = r
+	}
+
+	var nodes []mazeRoom
+	for idx, room := range zork {
+		mridx := room
+		mridx.index = idx
+		nodes = append(nodes, mridx)
+	}
+	g := _New[mazeRoom, mazeEdge](nodes)
+	path, err := g.ShortestPath(zork[11], zork[30])
+	if err != nil {
+		panic(fmt.Sprintf("%v", err))
+	}
+	var steps []direction
+	for _, edge := range path {
+		steps = append(steps, edge.dir)
+	}
+	want := []direction{east, west, up, sw, east, south}
+	if !_SliceEqual(steps, want) {
+		panic(fmt.Sprintf("ShortestPath returned %v, want %v", steps, want))
+	}
+}
+
+
+func main() {
+	TestShortestPath()
+}
-- 
GitLab


From 0ec2c4abbad7d678ebc4afc4c69af7d952fc3404 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Wed, 10 Mar 2021 20:54:11 -0500
Subject: [PATCH 1113/2400] cmd/compile: (fixed) spill output parameters passed
 in registers as autos

Repair of CL 300749.

ALSO:
found evidence that stack maps for bodyless methods are wrong.
gofmt in test/abi
removed never-executed code in types/size.go

Updates #44816.
Updates #40724.

Change-Id: Ifeb5fee60f60e7c7b58ee0457f58a3265d6cf3f6
Reviewed-on: https://go-review.googlesource.com/c/go/+/302071
Trust: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/abi/abiutils.go      | 31 ++++++--
 src/cmd/compile/internal/dwarfgen/dwarf.go    | 10 ++-
 src/cmd/compile/internal/gc/compile.go        |  2 +-
 src/cmd/compile/internal/ir/name.go           | 75 ++++++++++---------
 src/cmd/compile/internal/liveness/plive.go    | 19 +++--
 src/cmd/compile/internal/ssa/op.go            | 10 +++
 src/cmd/compile/internal/ssagen/pgen.go       | 18 +++--
 src/cmd/compile/internal/ssagen/ssa.go        | 30 ++++----
 .../compile/internal/test/abiutilsaux_test.go |  2 +-
 src/cmd/compile/internal/types/size.go        | 12 +--
 src/cmd/compile/internal/types/type.go        |  4 +-
 test/abi/fibish2.go                           |  4 +-
 test/abi/leaf.go                              | 36 +++++++++
 test/abi/leaf2.go                             | 43 +++++++++++
 test/abi/methods.go                           | 11 +--
 test/abi/spills3.go                           | 48 ++++++++++++
 test/abi/spills4.go                           | 44 +++++++++++
 17 files changed, 309 insertions(+), 90 deletions(-)
 create mode 100644 test/abi/leaf.go
 create mode 100644 test/abi/leaf2.go
 create mode 100644 test/abi/spills3.go
 create mode 100644 test/abi/spills4.go

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index ecde34313a..7573c13158 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -69,6 +69,14 @@ func (a *ABIParamResultInfo) SpillAreaSize() int64 {
 	return a.spillAreaSize
 }
 
+// ArgWidth returns the amount of stack needed for all the inputs
+// and outputs of a function or method, including ABI-defined parameter
+// slots and ABI-defined spill slots for register-resident parameters.
+// The name is inherited from (*Type).ArgWidth(), which it replaces.
+func (a *ABIParamResultInfo) ArgWidth() int64 {
+	return a.spillAreaSize + a.offsetToSpillArea - a.config.LocalsOffset()
+}
+
 // RegIndex stores the index into the set of machine registers used by
 // the ABI on a specific architecture for parameter passing.  RegIndex
 // values 0 through N-1 (where N is the number of integer registers
@@ -414,20 +422,25 @@ func (config *ABIConfig) ABIAnalyzeFuncType(ft *types.Func) *ABIParamResultInfo
 
 // ABIAnalyze returns the same result as ABIAnalyzeFuncType, but also
 // updates the offsets of all the receiver, input, and output fields.
-func (config *ABIConfig) ABIAnalyze(t *types.Type) *ABIParamResultInfo {
+// If setNname is true, it also sets the FrameOffset of the Nname for
+// the field(s); this is for use when compiling a function and figuring out
+// spill locations.  Doing this for callers can cause races for register
+// outputs because their frame location transitions from BOGUS_FUNARG_OFFSET
+// to zero to an as-if-AUTO offset that has no use for callers.
+func (config *ABIConfig) ABIAnalyze(t *types.Type, setNname bool) *ABIParamResultInfo {
 	ft := t.FuncType()
 	result := config.ABIAnalyzeFuncType(ft)
 	// Fill in the frame offsets for receiver, inputs, results
 	k := 0
 	if t.NumRecvs() != 0 {
-		config.updateOffset(result, ft.Receiver.FieldSlice()[0], result.inparams[0], false)
+		config.updateOffset(result, ft.Receiver.FieldSlice()[0], result.inparams[0], false, setNname)
 		k++
 	}
 	for i, f := range ft.Params.FieldSlice() {
-		config.updateOffset(result, f, result.inparams[k+i], false)
+		config.updateOffset(result, f, result.inparams[k+i], false, setNname)
 	}
 	for i, f := range ft.Results.FieldSlice() {
-		config.updateOffset(result, f, result.outparams[i], true)
+		config.updateOffset(result, f, result.outparams[i], true, setNname)
 	}
 	return result
 }
@@ -442,7 +455,7 @@ func FieldOffsetOf(f *types.Field) int64 {
 	return f.Offset
 }
 
-func (config *ABIConfig) updateOffset(result *ABIParamResultInfo, f *types.Field, a ABIParamAssignment, isReturn bool) {
+func (config *ABIConfig) updateOffset(result *ABIParamResultInfo, f *types.Field, a ABIParamAssignment, isReturn, setNname bool) {
 	// Everything except return values in registers has either a frame home (if not in a register) or a frame spill location.
 	if !isReturn || len(a.Registers) == 0 {
 		// The type frame offset DOES NOT show effects of minimum frame size.
@@ -455,11 +468,19 @@ func (config *ABIConfig) updateOffset(result *ABIParamResultInfo, f *types.Field
 			// Set the Offset the first time. After that, we may recompute it, but it should never change.
 			f.Offset = off
 			if f.Nname != nil {
+				// always set it in this case.
 				f.Nname.(*ir.Name).SetFrameOffset(off)
+				f.Nname.(*ir.Name).SetIsOutputParamInRegisters(false)
 			}
 		} else if fOffset != off {
 			panic(fmt.Errorf("Offset changed from %d to %d", fOffset, off))
 		}
+	} else {
+		if setNname && f.Nname != nil {
+			fname := f.Nname.(*ir.Name)
+			fname.SetIsOutputParamInRegisters(true)
+			fname.SetFrameOffset(0)
+		}
 	}
 }
 
diff --git a/src/cmd/compile/internal/dwarfgen/dwarf.go b/src/cmd/compile/internal/dwarfgen/dwarf.go
index 70168cffeb..53752097ed 100644
--- a/src/cmd/compile/internal/dwarfgen/dwarf.go
+++ b/src/cmd/compile/internal/dwarfgen/dwarf.go
@@ -265,6 +265,13 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 	var offs int64
 
 	switch n.Class {
+	case ir.PPARAM, ir.PPARAMOUT:
+		if !n.IsOutputParamInRegisters() {
+			abbrev = dwarf.DW_ABRV_PARAM
+			offs = n.FrameOffset() + base.Ctxt.FixedFrameSize()
+			break
+		}
+		fallthrough
 	case ir.PAUTO:
 		offs = n.FrameOffset()
 		abbrev = dwarf.DW_ABRV_AUTO
@@ -275,9 +282,6 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 			offs -= int64(types.PtrSize)
 		}
 
-	case ir.PPARAM, ir.PPARAMOUT:
-		abbrev = dwarf.DW_ABRV_PARAM
-		offs = n.FrameOffset() + base.Ctxt.FixedFrameSize()
 	default:
 		base.Fatalf("createSimpleVar unexpected class %v for node %v", n.Class, n)
 	}
diff --git a/src/cmd/compile/internal/gc/compile.go b/src/cmd/compile/internal/gc/compile.go
index 2d7a74a403..83cfceb2c8 100644
--- a/src/cmd/compile/internal/gc/compile.go
+++ b/src/cmd/compile/internal/gc/compile.go
@@ -45,7 +45,7 @@ func enqueueFunc(fn *ir.Func) {
 		ssagen.InitLSym(fn, false)
 		types.CalcSize(fn.Type()) // TODO register args; remove this once all is done by abiutils
 		a := ssagen.AbiForFunc(fn)
-		a.ABIAnalyze(fn.Type()) // will set parameter spill/home locations correctly
+		a.ABIAnalyze(fn.Type(), true) // will set parameter spill/home locations correctly
 		liveness.WriteFuncMap(fn)
 		return
 	}
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 16c30324e5..5738aa1f3f 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -246,44 +246,47 @@ func (n *Name) Alias() bool { return n.flags&nameAlias != 0 }
 func (n *Name) SetAlias(alias bool) { n.flags.set(nameAlias, alias) }
 
 const (
-	nameReadonly              = 1 << iota
-	nameByval                 // is the variable captured by value or by reference
-	nameNeedzero              // if it contains pointers, needs to be zeroed on function entry
-	nameAutoTemp              // is the variable a temporary (implies no dwarf info. reset if escapes to heap)
-	nameUsed                  // for variable declared and not used error
-	nameIsClosureVar          // PAUTOHEAP closure pseudo-variable; original (if any) at n.Defn
-	nameIsOutputParamHeapAddr // pointer to a result parameter's heap copy
-	nameAddrtaken             // address taken, even if not moved to heap
-	nameInlFormal             // PAUTO created by inliner, derived from callee formal
-	nameInlLocal              // PAUTO created by inliner, derived from callee local
-	nameOpenDeferSlot         // if temporary var storing info for open-coded defers
-	nameLibfuzzerExtraCounter // if PEXTERN should be assigned to __libfuzzer_extra_counters section
-	nameAlias                 // is type name an alias
+	nameReadonly                 = 1 << iota
+	nameByval                    // is the variable captured by value or by reference
+	nameNeedzero                 // if it contains pointers, needs to be zeroed on function entry
+	nameAutoTemp                 // is the variable a temporary (implies no dwarf info. reset if escapes to heap)
+	nameUsed                     // for variable declared and not used error
+	nameIsClosureVar             // PAUTOHEAP closure pseudo-variable; original (if any) at n.Defn
+	nameIsOutputParamHeapAddr    // pointer to a result parameter's heap copy
+	nameIsOutputParamInRegisters // output parameter in registers spills as an auto
+	nameAddrtaken                // address taken, even if not moved to heap
+	nameInlFormal                // PAUTO created by inliner, derived from callee formal
+	nameInlLocal                 // PAUTO created by inliner, derived from callee local
+	nameOpenDeferSlot            // if temporary var storing info for open-coded defers
+	nameLibfuzzerExtraCounter    // if PEXTERN should be assigned to __libfuzzer_extra_counters section
+	nameAlias                    // is type name an alias
 )
 
-func (n *Name) Readonly() bool              { return n.flags&nameReadonly != 0 }
-func (n *Name) Needzero() bool              { return n.flags&nameNeedzero != 0 }
-func (n *Name) AutoTemp() bool              { return n.flags&nameAutoTemp != 0 }
-func (n *Name) Used() bool                  { return n.flags&nameUsed != 0 }
-func (n *Name) IsClosureVar() bool          { return n.flags&nameIsClosureVar != 0 }
-func (n *Name) IsOutputParamHeapAddr() bool { return n.flags&nameIsOutputParamHeapAddr != 0 }
-func (n *Name) Addrtaken() bool             { return n.flags&nameAddrtaken != 0 }
-func (n *Name) InlFormal() bool             { return n.flags&nameInlFormal != 0 }
-func (n *Name) InlLocal() bool              { return n.flags&nameInlLocal != 0 }
-func (n *Name) OpenDeferSlot() bool         { return n.flags&nameOpenDeferSlot != 0 }
-func (n *Name) LibfuzzerExtraCounter() bool { return n.flags&nameLibfuzzerExtraCounter != 0 }
-
-func (n *Name) setReadonly(b bool)              { n.flags.set(nameReadonly, b) }
-func (n *Name) SetNeedzero(b bool)              { n.flags.set(nameNeedzero, b) }
-func (n *Name) SetAutoTemp(b bool)              { n.flags.set(nameAutoTemp, b) }
-func (n *Name) SetUsed(b bool)                  { n.flags.set(nameUsed, b) }
-func (n *Name) SetIsClosureVar(b bool)          { n.flags.set(nameIsClosureVar, b) }
-func (n *Name) SetIsOutputParamHeapAddr(b bool) { n.flags.set(nameIsOutputParamHeapAddr, b) }
-func (n *Name) SetAddrtaken(b bool)             { n.flags.set(nameAddrtaken, b) }
-func (n *Name) SetInlFormal(b bool)             { n.flags.set(nameInlFormal, b) }
-func (n *Name) SetInlLocal(b bool)              { n.flags.set(nameInlLocal, b) }
-func (n *Name) SetOpenDeferSlot(b bool)         { n.flags.set(nameOpenDeferSlot, b) }
-func (n *Name) SetLibfuzzerExtraCounter(b bool) { n.flags.set(nameLibfuzzerExtraCounter, b) }
+func (n *Name) Readonly() bool                 { return n.flags&nameReadonly != 0 }
+func (n *Name) Needzero() bool                 { return n.flags&nameNeedzero != 0 }
+func (n *Name) AutoTemp() bool                 { return n.flags&nameAutoTemp != 0 }
+func (n *Name) Used() bool                     { return n.flags&nameUsed != 0 }
+func (n *Name) IsClosureVar() bool             { return n.flags&nameIsClosureVar != 0 }
+func (n *Name) IsOutputParamHeapAddr() bool    { return n.flags&nameIsOutputParamHeapAddr != 0 }
+func (n *Name) IsOutputParamInRegisters() bool { return n.flags&nameIsOutputParamInRegisters != 0 }
+func (n *Name) Addrtaken() bool                { return n.flags&nameAddrtaken != 0 }
+func (n *Name) InlFormal() bool                { return n.flags&nameInlFormal != 0 }
+func (n *Name) InlLocal() bool                 { return n.flags&nameInlLocal != 0 }
+func (n *Name) OpenDeferSlot() bool            { return n.flags&nameOpenDeferSlot != 0 }
+func (n *Name) LibfuzzerExtraCounter() bool    { return n.flags&nameLibfuzzerExtraCounter != 0 }
+
+func (n *Name) setReadonly(b bool)                 { n.flags.set(nameReadonly, b) }
+func (n *Name) SetNeedzero(b bool)                 { n.flags.set(nameNeedzero, b) }
+func (n *Name) SetAutoTemp(b bool)                 { n.flags.set(nameAutoTemp, b) }
+func (n *Name) SetUsed(b bool)                     { n.flags.set(nameUsed, b) }
+func (n *Name) SetIsClosureVar(b bool)             { n.flags.set(nameIsClosureVar, b) }
+func (n *Name) SetIsOutputParamHeapAddr(b bool)    { n.flags.set(nameIsOutputParamHeapAddr, b) }
+func (n *Name) SetIsOutputParamInRegisters(b bool) { n.flags.set(nameIsOutputParamInRegisters, b) }
+func (n *Name) SetAddrtaken(b bool)                { n.flags.set(nameAddrtaken, b) }
+func (n *Name) SetInlFormal(b bool)                { n.flags.set(nameInlFormal, b) }
+func (n *Name) SetInlLocal(b bool)                 { n.flags.set(nameInlLocal, b) }
+func (n *Name) SetOpenDeferSlot(b bool)            { n.flags.set(nameOpenDeferSlot, b) }
+func (n *Name) SetLibfuzzerExtraCounter(b bool)    { n.flags.set(nameLibfuzzerExtraCounter, b) }
 
 // OnStack reports whether variable n may reside on the stack.
 func (n *Name) OnStack() bool {
diff --git a/src/cmd/compile/internal/liveness/plive.go b/src/cmd/compile/internal/liveness/plive.go
index 48a26cf66a..f3fbb8b9b1 100644
--- a/src/cmd/compile/internal/liveness/plive.go
+++ b/src/cmd/compile/internal/liveness/plive.go
@@ -405,11 +405,17 @@ func (lv *liveness) pointerMap(liveout bitvec.BitVec, vars []*ir.Name, args, loc
 		}
 		node := vars[i]
 		switch node.Class {
+		case ir.PPARAM, ir.PPARAMOUT:
+			if !node.IsOutputParamInRegisters() {
+				if node.FrameOffset() < 0 {
+					lv.f.Fatalf("Node %v has frameoffset %d\n", node.Sym().Name, node.FrameOffset())
+				}
+				typebits.Set(node.Type(), node.FrameOffset(), args)
+				break
+			}
+			fallthrough // PPARAMOUT in registers acts memory-allocates like an AUTO
 		case ir.PAUTO:
 			typebits.Set(node.Type(), node.FrameOffset()+lv.stkptrsize, locals)
-
-		case ir.PPARAM, ir.PPARAMOUT:
-			typebits.Set(node.Type(), node.FrameOffset(), args)
 		}
 	}
 }
@@ -1083,8 +1089,10 @@ func (lv *liveness) emit() (argsSym, liveSym *obj.LSym) {
 	for _, n := range lv.vars {
 		switch n.Class {
 		case ir.PPARAM, ir.PPARAMOUT:
-			if maxArgNode == nil || n.FrameOffset() > maxArgNode.FrameOffset() {
-				maxArgNode = n
+			if !n.IsOutputParamInRegisters() {
+				if maxArgNode == nil || n.FrameOffset() > maxArgNode.FrameOffset() {
+					maxArgNode = n
+				}
 			}
 		}
 	}
@@ -1282,6 +1290,7 @@ func isfat(t *types.Type) bool {
 	return false
 }
 
+// TODO THIS IS ALL WRONG AND NEEDS TO USE ABI.
 func WriteFuncMap(fn *ir.Func) {
 	if ir.FuncName(fn) == "_" || fn.Sym().Linkname != "" {
 		return
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index 084098fb64..fe9ba0e156 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -191,6 +191,16 @@ func archRegForAbiReg(r abi.RegIndex, c *Config) uint8 {
 	return uint8(m)
 }
 
+// ArgWidth returns the amount of stack needed for all the inputs
+// and outputs of a function or method, including ABI-defined parameter
+// slots and ABI-defined spill slots for register-resident parameters.
+//
+// The name is taken from the types package's ArgWidth(<function type>),
+// which predated changes to the ABI; this version handles those changes.
+func (a *AuxCall) ArgWidth() int64 {
+	return a.abiInfo.ArgWidth()
+}
+
 // OffsetOfResult returns the SP offset of result which (indexed 0, 1, etc).
 func (a *AuxCall) ParamAssignmentForResult(which int64) *abi.ABIParamAssignment {
 	return a.abiInfo.OutParam(int(which))
diff --git a/src/cmd/compile/internal/ssagen/pgen.go b/src/cmd/compile/internal/ssagen/pgen.go
index 8fa5980dab..0088f10fa8 100644
--- a/src/cmd/compile/internal/ssagen/pgen.go
+++ b/src/cmd/compile/internal/ssagen/pgen.go
@@ -104,7 +104,9 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 	// Reassign stack offsets of the locals that are used.
 	lastHasPtr := false
 	for i, n := range fn.Dcl {
-		if n.Op() != ir.ONAME || n.Class != ir.PAUTO {
+		if n.Op() != ir.ONAME || n.Class != ir.PAUTO && !(n.Class == ir.PPARAMOUT && n.IsOutputParamInRegisters()) {
+			// i.e., stack assign if AUTO, or if PARAMOUT in registers (which has no predefined spill locations)
+			// TODO figure out when we don't need to spill output params.
 			continue
 		}
 		if !n.Used() {
@@ -148,9 +150,9 @@ const maxStackSize = 1 << 30
 func Compile(fn *ir.Func, worker int) {
 	f := buildssa(fn, worker)
 	// Note: check arg size to fix issue 25507.
-	if f.Frontend().(*ssafn).stksize >= maxStackSize || fn.Type().ArgWidth() >= maxStackSize {
+	if f.Frontend().(*ssafn).stksize >= maxStackSize || f.OwnAux.ArgWidth() >= maxStackSize {
 		largeStackFramesMu.Lock()
-		largeStackFrames = append(largeStackFrames, largeStack{locals: f.Frontend().(*ssafn).stksize, args: fn.Type().ArgWidth(), pos: fn.Pos()})
+		largeStackFrames = append(largeStackFrames, largeStack{locals: f.Frontend().(*ssafn).stksize, args: f.OwnAux.ArgWidth(), pos: fn.Pos()})
 		largeStackFramesMu.Unlock()
 		return
 	}
@@ -166,7 +168,7 @@ func Compile(fn *ir.Func, worker int) {
 	if pp.Text.To.Offset >= maxStackSize {
 		largeStackFramesMu.Lock()
 		locals := f.Frontend().(*ssafn).stksize
-		largeStackFrames = append(largeStackFrames, largeStack{locals: locals, args: fn.Type().ArgWidth(), callee: pp.Text.To.Offset - locals, pos: fn.Pos()})
+		largeStackFrames = append(largeStackFrames, largeStack{locals: locals, args: f.OwnAux.ArgWidth(), callee: pp.Text.To.Offset - locals, pos: fn.Pos()})
 		largeStackFramesMu.Unlock()
 		return
 	}
@@ -189,6 +191,12 @@ func StackOffset(slot ssa.LocalSlot) int32 {
 	n := slot.N
 	var off int64
 	switch n.Class {
+	case ir.PPARAM, ir.PPARAMOUT:
+		if !n.IsOutputParamInRegisters() {
+			off = n.FrameOffset() + base.Ctxt.FixedFrameSize()
+			break
+		}
+		fallthrough // PPARAMOUT in registers allocates like an AUTO
 	case ir.PAUTO:
 		off = n.FrameOffset()
 		if base.Ctxt.FixedFrameSize() == 0 {
@@ -197,8 +205,6 @@ func StackOffset(slot ssa.LocalSlot) int32 {
 		if objabi.Framepointer_enabled {
 			off -= int64(types.PtrSize)
 		}
-	case ir.PPARAM, ir.PPARAMOUT:
-		off = n.FrameOffset() + base.Ctxt.FixedFrameSize()
 	}
 	return int32(off + slot.Off)
 }
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 0029558963..6a3c0d28cb 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -372,7 +372,7 @@ func (s *state) emitOpenDeferInfo() {
 }
 
 func okOffset(offset int64) int64 {
-	if offset >= types.BOGUS_FUNARG_OFFSET {
+	if offset == types.BOGUS_FUNARG_OFFSET {
 		panic(fmt.Errorf("Bogus offset %d", offset))
 	}
 	return offset
@@ -516,7 +516,7 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 	}
 
 	var params *abi.ABIParamResultInfo
-	params = s.f.ABISelf.ABIAnalyze(fn.Type())
+	params = s.f.ABISelf.ABIAnalyze(fn.Type(), true)
 
 	// Generate addresses of local declarations
 	s.decladdrs = map[*ir.Name]*ssa.Value{}
@@ -4914,8 +4914,6 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			closure = iclosure
 		}
 	}
-	types.CalcSize(fn.Type())
-	stksize := fn.Type().ArgWidth() // includes receiver, args, and results
 
 	if regAbiForFuncType(n.X.Type().FuncType()) {
 		// fmt.Printf("Saw magic last type in call %v\n", n)
@@ -4927,7 +4925,9 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		callABI = s.f.ABI0
 	}
 
-	params := callABI.ABIAnalyze(n.X.Type())
+	params := callABI.ABIAnalyze(n.X.Type(), false /* Do not set (register) nNames from caller side -- can cause races. */ )
+	types.CalcSize(fn.Type())
+	stksize := params.ArgWidth() // includes receiver, args, and results
 
 	res := n.X.Type().Results()
 	if k == callNormal {
@@ -6838,13 +6838,13 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 		f.HTMLWriter.WriteColumn("genssa", "genssa", "ssa-prog", buf.String())
 	}
 
-	defframe(&s, e)
+	defframe(&s, e, f)
 
 	f.HTMLWriter.Close()
 	f.HTMLWriter = nil
 }
 
-func defframe(s *State, e *ssafn) {
+func defframe(s *State, e *ssafn, f *ssa.Func) {
 	pp := s.pp
 
 	frame := types.Rnd(s.maxarg+e.stksize, int64(types.RegSize))
@@ -6854,7 +6854,7 @@ func defframe(s *State, e *ssafn) {
 
 	// Fill in argument and frame size.
 	pp.Text.To.Type = obj.TYPE_TEXTSIZE
-	pp.Text.To.Val = int32(types.Rnd(e.curfn.Type().ArgWidth(), int64(types.RegSize)))
+	pp.Text.To.Val = int32(types.Rnd(f.OwnAux.ArgWidth(), int64(types.RegSize)))
 	pp.Text.To.Offset = frame
 
 	// Insert code to zero ambiguously live variables so that the
@@ -6957,14 +6957,18 @@ func AddAux2(a *obj.Addr, v *ssa.Value, offset int64) {
 		a.Name = obj.NAME_EXTERN
 		a.Sym = n
 	case *ir.Name:
-		if n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT {
+		if n.Class == ir.PPARAM || (n.Class == ir.PPARAMOUT && !n.IsOutputParamInRegisters()) {
 			a.Name = obj.NAME_PARAM
 			a.Sym = ir.Orig(n).(*ir.Name).Linksym()
 			a.Offset += n.FrameOffset()
 			break
 		}
 		a.Name = obj.NAME_AUTO
-		a.Sym = n.Linksym()
+		if n.Class == ir.PPARAMOUT {
+			a.Sym = ir.Orig(n).(*ir.Name).Linksym()
+		} else {
+			a.Sym = n.Linksym()
+		}
 		a.Offset += n.FrameOffset()
 	default:
 		v.Fatalf("aux in %s not implemented %#v", v, v.Aux)
@@ -7108,7 +7112,7 @@ func AddrAuto(a *obj.Addr, v *ssa.Value) {
 	a.Sym = n.Linksym()
 	a.Reg = int16(Arch.REGSP)
 	a.Offset = n.FrameOffset() + off
-	if n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT {
+	if n.Class == ir.PPARAM || (n.Class == ir.PPARAMOUT && !n.IsOutputParamInRegisters()) {
 		a.Name = obj.NAME_PARAM
 	} else {
 		a.Name = obj.NAME_AUTO
@@ -7545,10 +7549,10 @@ func AddrForParamSlot(slot *ssa.LocalSlot, addr *obj.Addr) {
 	addr.Type = obj.TYPE_MEM
 	addr.Sym = n.Linksym()
 	addr.Offset = off
-	if n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT {
+	if n.Class == ir.PPARAM || (n.Class == ir.PPARAMOUT && !n.IsOutputParamInRegisters()) {
 		addr.Name = obj.NAME_PARAM
 		addr.Offset += n.FrameOffset()
-	} else {
+	} else { // out parameters in registers allocate stack slots like autos.
 		addr.Name = obj.NAME_AUTO
 	}
 }
diff --git a/src/cmd/compile/internal/test/abiutilsaux_test.go b/src/cmd/compile/internal/test/abiutilsaux_test.go
index 7eb273273d..b945633133 100644
--- a/src/cmd/compile/internal/test/abiutilsaux_test.go
+++ b/src/cmd/compile/internal/test/abiutilsaux_test.go
@@ -119,7 +119,7 @@ func abitest(t *testing.T, ft *types.Type, exp expectedDump) {
 	types.CalcSize(ft)
 
 	// Analyze with full set of registers.
-	regRes := configAMD64.ABIAnalyze(ft)
+	regRes := configAMD64.ABIAnalyze(ft, false)
 	regResString := strings.TrimSpace(regRes.String())
 
 	// Check results.
diff --git a/src/cmd/compile/internal/types/size.go b/src/cmd/compile/internal/types/size.go
index ef23cdf5fe..a75429f0ab 100644
--- a/src/cmd/compile/internal/types/size.go
+++ b/src/cmd/compile/internal/types/size.go
@@ -163,19 +163,9 @@ func calcStructOffset(errtype *Type, t *Type, o int64, flag int) int64 {
 		if f.Type.Align > 0 {
 			o = Rnd(o, int64(f.Type.Align))
 		}
-		if isStruct { // For receiver/args/results, depends on ABI
+		if isStruct { // For receiver/args/results, do not set, it depends on ABI
 			f.Offset = o
 		}
-		if f.Nname != nil {
-			// addrescapes has similar code to update these offsets.
-			// Usually addrescapes runs after calcStructOffset,
-			// in which case we could drop this,
-			// but function closure functions are the exception.
-			// NOTE(rsc): This comment may be stale.
-			// It's possible the ordering has changed and this is
-			// now the common case. I'm not sure.
-			f.Nname.(VarObject).RecordFrameOffset(o)
-		}
 
 		w := f.Type.Width
 		if w < 0 {
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index ffaf755345..7bf63764b8 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -1750,7 +1750,7 @@ func NewTypeParam(pkg *Pkg) *Type {
 	return t
 }
 
-const BOGUS_FUNARG_OFFSET = 1000000000
+const BOGUS_FUNARG_OFFSET = -1000000000
 
 func unzeroFieldOffsets(f []*Field) {
 	for i := range f {
@@ -1759,7 +1759,7 @@ func unzeroFieldOffsets(f []*Field) {
 }
 
 // NewSignature returns a new function type for the given receiver,
-// parametes, results, and type parameters, any of which may be nil.
+// parameters, results, and type parameters, any of which may be nil.
 func NewSignature(pkg *Pkg, recv *Field, tparams, params, results []*Field) *Type {
 	var recvs []*Field
 	if recv != nil {
diff --git a/test/abi/fibish2.go b/test/abi/fibish2.go
index 14f3f9ada7..388aabc8b0 100644
--- a/test/abi/fibish2.go
+++ b/test/abi/fibish2.go
@@ -13,12 +13,12 @@ import "fmt"
 
 // Test that register results are correctly returned (and passed)
 
-type MagicLastTypeNameForTestingRegisterABI func(int,MagicLastTypeNameForTestingRegisterABI) int
+type MagicLastTypeNameForTestingRegisterABI func(int, MagicLastTypeNameForTestingRegisterABI) int
 
 //go:registerparams
 //go:noinline
 func minus(decrement int) MagicLastTypeNameForTestingRegisterABI {
-	return MagicLastTypeNameForTestingRegisterABI( func(x int, _ MagicLastTypeNameForTestingRegisterABI) int { return x-decrement} )
+	return MagicLastTypeNameForTestingRegisterABI(func(x int, _ MagicLastTypeNameForTestingRegisterABI) int { return x - decrement })
 }
 
 //go:noinline
diff --git a/test/abi/leaf.go b/test/abi/leaf.go
new file mode 100644
index 0000000000..f893f5dddb
--- /dev/null
+++ b/test/abi/leaf.go
@@ -0,0 +1,36 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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.
+
+// wasm is excluded because the compiler chatter about register abi pragma ends up
+// on stdout, and causes the expected output to not match.
+
+package main
+
+import "fmt"
+
+type i5f5 struct {
+	a, b          int16
+	c, d, e       int32
+	r, s, t, u, v float32
+}
+
+//go:registerparams
+//go:noinline
+func F(x i5f5) i5f5 {
+	return x
+}
+
+func main() {
+	x := i5f5{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+	y := x
+	z := F(x)
+	if y != z {
+		fmt.Printf("y=%v, z=%v\n", y, z)
+	}
+}
diff --git a/test/abi/leaf2.go b/test/abi/leaf2.go
new file mode 100644
index 0000000000..d2018d5313
--- /dev/null
+++ b/test/abi/leaf2.go
@@ -0,0 +1,43 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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.
+
+// wasm is excluded because the compiler chatter about register abi pragma ends up
+// on stdout, and causes the expected output to not match.
+
+package main
+
+import "fmt"
+
+type i4 struct {
+	a, b, c, d int
+}
+
+//go:registerparams
+//go:noinline
+func F(x i4) i4 {
+	ab := x.a + x.b
+	bc := x.b + x.c
+	cd := x.c + x.d
+	ad := x.a + x.d
+	ba := x.a - x.b
+	cb := x.b - x.c
+	dc := x.c - x.d
+	da := x.a - x.d
+
+	return i4{ab*bc + da, cd*ad + cb, ba*cb + ad, dc*da + bc}
+}
+
+func main() {
+	x := i4{1, 2, 3, 4}
+	y := x
+	z := F(x)
+	if (i4{12, 34, 6, 8}) != z {
+		fmt.Printf("y=%v, z=%v\n", y, z)
+	}
+}
diff --git a/test/abi/methods.go b/test/abi/methods.go
index 9ecae9833e..3dcd3e327a 100644
--- a/test/abi/methods.go
+++ b/test/abi/methods.go
@@ -14,7 +14,7 @@ import (
 )
 
 type toobig struct {
-	a,b,c string
+	a, b, c string
 }
 
 //go:registerparams
@@ -29,8 +29,8 @@ type AnInterface interface {
 
 //go:registerparams
 //go:noinline
-func I(a,b,c string) toobig {
-	return toobig{a,b,c}
+func I(a, b, c string) toobig {
+	return toobig{a, b, c}
 }
 
 // AnIid prevents the compiler from figuring out what the interface really is.
@@ -40,12 +40,13 @@ func AnIid(x AnInterface) AnInterface {
 }
 
 var tmp toobig
+
 func main() {
 	x := I("Ahoy", "1,", "2")
 	y := I("3", "there,", "4")
 	z := I("5", "6,", "Matey")
-	tmp = x.MagicMethodNameForTestingRegisterABI(y,z)
+	tmp = x.MagicMethodNameForTestingRegisterABI(y, z)
 	fmt.Println(tmp.a, tmp.b, tmp.c)
-	tmp = AnIid(&x).MagicMethodNameForTestingRegisterABI(y,z)
+	tmp = AnIid(&x).MagicMethodNameForTestingRegisterABI(y, z)
 	fmt.Println(tmp.a, tmp.b, tmp.c)
 }
diff --git a/test/abi/spills3.go b/test/abi/spills3.go
new file mode 100644
index 0000000000..247828437b
--- /dev/null
+++ b/test/abi/spills3.go
@@ -0,0 +1,48 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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.
+
+// wasm is excluded because the compiler chatter about register abi pragma ends up
+// on stdout, and causes the expected output to not match.
+
+package main
+
+import "fmt"
+
+type i4 struct {
+	a, b, c, d int
+}
+
+//go:noinline
+func spills(px *i4) {
+}
+
+//go:registerparams
+//go:noinline
+func F(x i4) i4 {
+	ab := x.a + x.b
+	bc := x.b + x.c
+	cd := x.c + x.d
+	ad := x.a + x.d
+	ba := x.a - x.b
+	cb := x.b - x.c
+	dc := x.c - x.d
+	da := x.a - x.d
+	i := i4{ab*bc + da, cd*ad + cb, ba*cb + ad, dc*da + bc}
+	spills(&i)
+	return i
+}
+
+func main() {
+	x := i4{1, 2, 3, 4}
+	y := x
+	z := F(x)
+	if z != (i4{12, 34, 6, 8}) {
+		fmt.Printf("y=%v, z=%v\n", y, z)
+	}
+}
diff --git a/test/abi/spills4.go b/test/abi/spills4.go
new file mode 100644
index 0000000000..205f5a64c0
--- /dev/null
+++ b/test/abi/spills4.go
@@ -0,0 +1,44 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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.
+
+// wasm is excluded because the compiler chatter about register abi pragma ends up
+// on stdout, and causes the expected output to not match.
+
+package main
+
+import "fmt"
+
+type i5f5 struct {
+	a, b          int16
+	c, d, e       int32
+	r, s, t, u, v float32
+}
+
+//go:noinline
+func spills(_ *float32) {
+
+}
+
+//go:registerparams
+//go:noinline
+func F(x i5f5) i5f5 {
+	y := x.v
+	spills(&y)
+	x.r = y
+	return x
+}
+
+func main() {
+	x := i5f5{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+	y := x
+	z := F(x)
+	if (i5f5{1, 2, 3, 4, 5, 10, 7, 8, 9, 10}) != z {
+		fmt.Printf("y=%v, z=%v\n", y, z)
+	}
+}
-- 
GitLab


From d206ca5cac60ddff222a25e1dc96d6b0e96c21b5 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Tue, 16 Mar 2021 12:03:08 -0400
Subject: [PATCH 1114/2400] cmd/compile: fix open defer of method call

Code generation for open defers failed to account for
presence of method receiver and thus was OFF BY ONE.

Fixes #45062.
Updates #44816.
Updates #40724.

Change-Id: Ia90ea8fd0f7d823e1f757c406f9127136c2ffdd2
Reviewed-on: https://go-review.googlesource.com/c/go/+/302249
Trust: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssagen/ssa.go |  6 +++--
 test/abi/open_defer_1.go               | 36 ++++++++++++++++++++++++++
 2 files changed, 40 insertions(+), 2 deletions(-)
 create mode 100644 test/abi/open_defer_1.go

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 6a3c0d28cb..45e39478fa 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -353,10 +353,12 @@ func (s *state) emitOpenDeferInfo() {
 			numArgs++
 		}
 		off = dvarint(x, off, int64(numArgs))
+		argAdjust := 0 // presence of receiver offsets the parameter count.
 		if r.rcvrNode != nil {
 			off = dvarint(x, off, -okOffset(r.rcvrNode.FrameOffset()))
 			off = dvarint(x, off, s.config.PtrSize)
 			off = dvarint(x, off, 0) // This is okay because defer records use ABI0 (for now)
+			argAdjust++
 		}
 
 		// TODO(register args) assume abi0 for this?
@@ -366,7 +368,7 @@ func (s *state) emitOpenDeferInfo() {
 			f := getParam(r.n, j)
 			off = dvarint(x, off, -okOffset(arg.FrameOffset()))
 			off = dvarint(x, off, f.Type.Size())
-			off = dvarint(x, off, okOffset(pri.InParam(j).FrameOffset(pri))-ab.LocalsOffset()) // defer does not want the fixed frame adjustment
+			off = dvarint(x, off, okOffset(pri.InParam(j+argAdjust).FrameOffset(pri))-ab.LocalsOffset()) // defer does not want the fixed frame adjustment
 		}
 	}
 }
@@ -4925,7 +4927,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		callABI = s.f.ABI0
 	}
 
-	params := callABI.ABIAnalyze(n.X.Type(), false /* Do not set (register) nNames from caller side -- can cause races. */ )
+	params := callABI.ABIAnalyze(n.X.Type(), false /* Do not set (register) nNames from caller side -- can cause races. */)
 	types.CalcSize(fn.Type())
 	stksize := params.ArgWidth() // includes receiver, args, and results
 
diff --git a/test/abi/open_defer_1.go b/test/abi/open_defer_1.go
new file mode 100644
index 0000000000..0a0ace3905
--- /dev/null
+++ b/test/abi/open_defer_1.go
@@ -0,0 +1,36 @@
+// run
+
+// Copyright 2021 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.
+
+// For #45062, miscompilation of open defer of method invocation
+
+package main
+
+func main() {
+	var x, y, z int = -1, -2, -3
+	F(x, y, z)
+}
+
+//go:noinline
+func F(x, y, z int) {
+	defer i.M(x, y, z)
+	defer func() { recover() }()
+	panic("XXX")
+}
+
+type T int
+
+func (t *T) M(x, y, z int) {
+	if x == -1 && y == -2 && z == -3 {
+		return
+	}
+	println("FAIL: Expected -1, -2, -3, but x, y, z =", x, y, z)
+}
+
+var t T = 42
+
+type I interface{ M(x, y, z int) }
+
+var i I = &t
-- 
GitLab


From 13a0f7b50299f9ab40dad7c855539af65e34d132 Mon Sep 17 00:00:00 2001
From: nobishino <nobishii11@gmail.com>
Date: Tue, 16 Mar 2021 19:49:13 +0000
Subject: [PATCH 1115/2400] spec: clarify that signed integers>=0 are permitted
 as shift counts

In Go1.13 and above, signed integers are permitted as shift counts as long as they are >=0.
However, the comments in the "Arithmetic operators" section says shift operators accept "unsigned integer" as of right operands. Replacing this with "integer>=0" resolves the misunderstanding that shift
operators permit only unsigned integers.

Reference: Go1.13 Release Notes: https://golang.org/doc/go1.13

Change-Id: Icd3c7734d539ab702590e992a618c9251c653c37
GitHub-Last-Rev: 4f263a48d3b19ca06a277c5fef78df55e9a92b10
GitHub-Pull-Request: golang/go#44664
Reviewed-on: https://go-review.googlesource.com/c/go/+/297249
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Trust: Robert Griesemer <gri@golang.org>
---
 doc/go_spec.html | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index 2a1322fb0f..39617cf524 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1,6 +1,6 @@
 <!--{
 	"Title": "The Go Programming Language Specification",
-	"Subtitle": "Version of Feb 24, 2021",
+	"Subtitle": "Version of Mar 16, 2021",
 	"Path": "/ref/spec"
 }-->
 
@@ -3681,8 +3681,8 @@ The bitwise logical and shift operators apply to integers only.
 ^    bitwise XOR            integers
 &amp;^   bit clear (AND NOT)    integers
 
-&lt;&lt;   left shift             integer &lt;&lt; unsigned integer
-&gt;&gt;   right shift            integer &gt;&gt; unsigned integer
+&lt;&lt;   left shift             integer &lt;&lt; integer >= 0
+&gt;&gt;   right shift            integer &gt;&gt; integer >= 0
 </pre>
 
 
-- 
GitLab


From 18246672593fd59c2671bc6407c06fd020716708 Mon Sep 17 00:00:00 2001
From: cui <cuiweixie@gmail.com>
Date: Sun, 14 Mar 2021 18:55:59 +0000
Subject: [PATCH 1116/2400] cmd/compile/internal/ssa: delete unused files

Change-Id: I5d640091375feb873517368ce05f0ba46c35714f
GitHub-Last-Rev: cdaf6ba33664f3602e563aa93009e0f4f4865b32
GitHub-Pull-Request: golang/go#44997
Reviewed-on: https://go-review.googlesource.com/c/go/+/301630
Reviewed-by: David Chase <drchase@google.com>
Trust: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ssa/redblack32.go    | 429 ------------------
 .../compile/internal/ssa/redblack32_test.go   | 274 -----------
 src/cmd/compile/internal/ssa/sparsetreemap.go | 189 --------
 3 files changed, 892 deletions(-)
 delete mode 100644 src/cmd/compile/internal/ssa/redblack32.go
 delete mode 100644 src/cmd/compile/internal/ssa/redblack32_test.go
 delete mode 100644 src/cmd/compile/internal/ssa/sparsetreemap.go

diff --git a/src/cmd/compile/internal/ssa/redblack32.go b/src/cmd/compile/internal/ssa/redblack32.go
deleted file mode 100644
index fc9cc71ba0..0000000000
--- a/src/cmd/compile/internal/ssa/redblack32.go
+++ /dev/null
@@ -1,429 +0,0 @@
-// Copyright 2016 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 ssa
-
-import "fmt"
-
-const (
-	rankLeaf rbrank = 1
-	rankZero rbrank = 0
-)
-
-type rbrank int8
-
-// RBTint32 is a red-black tree with data stored at internal nodes,
-// following Tarjan, Data Structures and Network Algorithms,
-// pp 48-52, using explicit rank instead of red and black.
-// Deletion is not yet implemented because it is not yet needed.
-// Extra operations glb, lub, glbEq, lubEq are provided for
-// use in sparse lookup algorithms.
-type RBTint32 struct {
-	root *node32
-	// An extra-clever implementation will have special cases
-	// for small sets, but we are not extra-clever today.
-}
-
-func (t *RBTint32) String() string {
-	if t.root == nil {
-		return "[]"
-	}
-	return "[" + t.root.String() + "]"
-}
-
-func (t *node32) String() string {
-	s := ""
-	if t.left != nil {
-		s = t.left.String() + " "
-	}
-	s = s + fmt.Sprintf("k=%d,d=%v", t.key, t.data)
-	if t.right != nil {
-		s = s + " " + t.right.String()
-	}
-	return s
-}
-
-type node32 struct {
-	// Standard conventions hold for left = smaller, right = larger
-	left, right, parent *node32
-	data                interface{}
-	key                 int32
-	rank                rbrank // From Tarjan pp 48-49:
-	// If x is a node with a parent, then x.rank <= x.parent.rank <= x.rank+1.
-	// If x is a node with a grandparent, then x.rank < x.parent.parent.rank.
-	// If x is an "external [null] node", then x.rank = 0 && x.parent.rank = 1.
-	// Any node with one or more null children should have rank = 1.
-}
-
-// makeNode returns a new leaf node with the given key and nil data.
-func (t *RBTint32) makeNode(key int32) *node32 {
-	return &node32{key: key, rank: rankLeaf}
-}
-
-// IsEmpty reports whether t is empty.
-func (t *RBTint32) IsEmpty() bool {
-	return t.root == nil
-}
-
-// IsSingle reports whether t is a singleton (leaf).
-func (t *RBTint32) IsSingle() bool {
-	return t.root != nil && t.root.isLeaf()
-}
-
-// VisitInOrder applies f to the key and data pairs in t,
-// with keys ordered from smallest to largest.
-func (t *RBTint32) VisitInOrder(f func(int32, interface{})) {
-	if t.root == nil {
-		return
-	}
-	t.root.visitInOrder(f)
-}
-
-func (n *node32) Data() interface{} {
-	if n == nil {
-		return nil
-	}
-	return n.data
-}
-
-func (n *node32) keyAndData() (k int32, d interface{}) {
-	if n == nil {
-		k = 0
-		d = nil
-	} else {
-		k = n.key
-		d = n.data
-	}
-	return
-}
-
-func (n *node32) Rank() rbrank {
-	if n == nil {
-		return 0
-	}
-	return n.rank
-}
-
-// Find returns the data associated with key in the tree, or
-// nil if key is not in the tree.
-func (t *RBTint32) Find(key int32) interface{} {
-	return t.root.find(key).Data()
-}
-
-// Insert adds key to the tree and associates key with data.
-// If key was already in the tree, it updates the associated data.
-// Insert returns the previous data associated with key,
-// or nil if key was not present.
-// Insert panics if data is nil.
-func (t *RBTint32) Insert(key int32, data interface{}) interface{} {
-	if data == nil {
-		panic("Cannot insert nil data into tree")
-	}
-	n := t.root
-	var newroot *node32
-	if n == nil {
-		n = t.makeNode(key)
-		newroot = n
-	} else {
-		newroot, n = n.insert(key, t)
-	}
-	r := n.data
-	n.data = data
-	t.root = newroot
-	return r
-}
-
-// Min returns the minimum element of t and its associated data.
-// If t is empty, then (0, nil) is returned.
-func (t *RBTint32) Min() (k int32, d interface{}) {
-	return t.root.min().keyAndData()
-}
-
-// Max returns the maximum element of t and its associated data.
-// If t is empty, then (0, nil) is returned.
-func (t *RBTint32) Max() (k int32, d interface{}) {
-	return t.root.max().keyAndData()
-}
-
-// Glb returns the greatest-lower-bound-exclusive of x and its associated
-// data.  If x has no glb in the tree, then (0, nil) is returned.
-func (t *RBTint32) Glb(x int32) (k int32, d interface{}) {
-	return t.root.glb(x, false).keyAndData()
-}
-
-// GlbEq returns the greatest-lower-bound-inclusive of x and its associated
-// data.  If x has no glbEQ in the tree, then (0, nil) is returned.
-func (t *RBTint32) GlbEq(x int32) (k int32, d interface{}) {
-	return t.root.glb(x, true).keyAndData()
-}
-
-// Lub returns the least-upper-bound-exclusive of x and its associated
-// data.  If x has no lub in the tree, then (0, nil) is returned.
-func (t *RBTint32) Lub(x int32) (k int32, d interface{}) {
-	return t.root.lub(x, false).keyAndData()
-}
-
-// LubEq returns the least-upper-bound-inclusive of x and its associated
-// data.  If x has no lubEq in the tree, then (0, nil) is returned.
-func (t *RBTint32) LubEq(x int32) (k int32, d interface{}) {
-	return t.root.lub(x, true).keyAndData()
-}
-
-func (t *node32) isLeaf() bool {
-	return t.left == nil && t.right == nil
-}
-
-func (t *node32) visitInOrder(f func(int32, interface{})) {
-	if t.left != nil {
-		t.left.visitInOrder(f)
-	}
-	f(t.key, t.data)
-	if t.right != nil {
-		t.right.visitInOrder(f)
-	}
-}
-
-func (t *node32) maxChildRank() rbrank {
-	if t.left == nil {
-		if t.right == nil {
-			return rankZero
-		}
-		return t.right.rank
-	}
-	if t.right == nil {
-		return t.left.rank
-	}
-	if t.right.rank > t.left.rank {
-		return t.right.rank
-	}
-	return t.left.rank
-}
-
-func (t *node32) minChildRank() rbrank {
-	if t.left == nil || t.right == nil {
-		return rankZero
-	}
-	if t.right.rank < t.left.rank {
-		return t.right.rank
-	}
-	return t.left.rank
-}
-
-func (t *node32) find(key int32) *node32 {
-	for t != nil {
-		if key < t.key {
-			t = t.left
-		} else if key > t.key {
-			t = t.right
-		} else {
-			return t
-		}
-	}
-	return nil
-}
-
-func (t *node32) min() *node32 {
-	if t == nil {
-		return t
-	}
-	for t.left != nil {
-		t = t.left
-	}
-	return t
-}
-
-func (t *node32) max() *node32 {
-	if t == nil {
-		return t
-	}
-	for t.right != nil {
-		t = t.right
-	}
-	return t
-}
-
-func (t *node32) glb(key int32, allow_eq bool) *node32 {
-	var best *node32
-	for t != nil {
-		if key <= t.key {
-			if key == t.key && allow_eq {
-				return t
-			}
-			// t is too big, glb is to left.
-			t = t.left
-		} else {
-			// t is a lower bound, record it and seek a better one.
-			best = t
-			t = t.right
-		}
-	}
-	return best
-}
-
-func (t *node32) lub(key int32, allow_eq bool) *node32 {
-	var best *node32
-	for t != nil {
-		if key >= t.key {
-			if key == t.key && allow_eq {
-				return t
-			}
-			// t is too small, lub is to right.
-			t = t.right
-		} else {
-			// t is a upper bound, record it and seek a better one.
-			best = t
-			t = t.left
-		}
-	}
-	return best
-}
-
-func (t *node32) insert(x int32, w *RBTint32) (newroot, newnode *node32) {
-	// defaults
-	newroot = t
-	newnode = t
-	if x == t.key {
-		return
-	}
-	if x < t.key {
-		if t.left == nil {
-			n := w.makeNode(x)
-			n.parent = t
-			t.left = n
-			newnode = n
-			return
-		}
-		var new_l *node32
-		new_l, newnode = t.left.insert(x, w)
-		t.left = new_l
-		new_l.parent = t
-		newrank := 1 + new_l.maxChildRank()
-		if newrank > t.rank {
-			if newrank > 1+t.right.Rank() { // rotations required
-				if new_l.left.Rank() < new_l.right.Rank() {
-					// double rotation
-					t.left = new_l.rightToRoot()
-				}
-				newroot = t.leftToRoot()
-				return
-			} else {
-				t.rank = newrank
-			}
-		}
-	} else { // x > t.key
-		if t.right == nil {
-			n := w.makeNode(x)
-			n.parent = t
-			t.right = n
-			newnode = n
-			return
-		}
-		var new_r *node32
-		new_r, newnode = t.right.insert(x, w)
-		t.right = new_r
-		new_r.parent = t
-		newrank := 1 + new_r.maxChildRank()
-		if newrank > t.rank {
-			if newrank > 1+t.left.Rank() { // rotations required
-				if new_r.right.Rank() < new_r.left.Rank() {
-					// double rotation
-					t.right = new_r.leftToRoot()
-				}
-				newroot = t.rightToRoot()
-				return
-			} else {
-				t.rank = newrank
-			}
-		}
-	}
-	return
-}
-
-func (t *node32) rightToRoot() *node32 {
-	//    this
-	// left  right
-	//      rl   rr
-	//
-	// becomes
-	//
-	//       right
-	//    this   rr
-	// left  rl
-	//
-	right := t.right
-	rl := right.left
-	right.parent = t.parent
-	right.left = t
-	t.parent = right
-	// parent's child ptr fixed in caller
-	t.right = rl
-	if rl != nil {
-		rl.parent = t
-	}
-	return right
-}
-
-func (t *node32) leftToRoot() *node32 {
-	//     this
-	//  left  right
-	// ll  lr
-	//
-	// becomes
-	//
-	//    left
-	//   ll  this
-	//      lr  right
-	//
-	left := t.left
-	lr := left.right
-	left.parent = t.parent
-	left.right = t
-	t.parent = left
-	// parent's child ptr fixed in caller
-	t.left = lr
-	if lr != nil {
-		lr.parent = t
-	}
-	return left
-}
-
-// next returns the successor of t in a left-to-right
-// walk of the tree in which t is embedded.
-func (t *node32) next() *node32 {
-	// If there is a right child, it is to the right
-	r := t.right
-	if r != nil {
-		return r.min()
-	}
-	// if t is p.left, then p, else repeat.
-	p := t.parent
-	for p != nil {
-		if p.left == t {
-			return p
-		}
-		t = p
-		p = t.parent
-	}
-	return nil
-}
-
-// prev returns the predecessor of t in a left-to-right
-// walk of the tree in which t is embedded.
-func (t *node32) prev() *node32 {
-	// If there is a left child, it is to the left
-	l := t.left
-	if l != nil {
-		return l.max()
-	}
-	// if t is p.right, then p, else repeat.
-	p := t.parent
-	for p != nil {
-		if p.right == t {
-			return p
-		}
-		t = p
-		p = t.parent
-	}
-	return nil
-}
diff --git a/src/cmd/compile/internal/ssa/redblack32_test.go b/src/cmd/compile/internal/ssa/redblack32_test.go
deleted file mode 100644
index 376e8cff8d..0000000000
--- a/src/cmd/compile/internal/ssa/redblack32_test.go
+++ /dev/null
@@ -1,274 +0,0 @@
-// Copyright 2016 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 ssa
-
-import (
-	"fmt"
-	"testing"
-)
-
-type sstring string
-
-func (s sstring) String() string {
-	return string(s)
-}
-
-// wellFormed ensures that a red-black tree meets
-// all of its invariants and returns a string identifying
-// the first problem encountered. If there is no problem
-// then the returned string is empty. The size is also
-// returned to allow comparison of calculated tree size
-// with expected.
-func (t *RBTint32) wellFormed() (s string, i int) {
-	if t.root == nil {
-		s = ""
-		i = 0
-		return
-	}
-	return t.root.wellFormedSubtree(nil, -0x80000000, 0x7fffffff)
-}
-
-// wellFormedSubtree ensures that a red-black subtree meets
-// all of its invariants and returns a string identifying
-// the first problem encountered. If there is no problem
-// then the returned string is empty. The size is also
-// returned to allow comparison of calculated tree size
-// with expected.
-func (t *node32) wellFormedSubtree(parent *node32, min, max int32) (s string, i int) {
-	i = -1 // initialize to a failing value
-	s = "" // s is the reason for failure; empty means okay.
-
-	if t.parent != parent {
-		s = "t.parent != parent"
-		return
-	}
-
-	if min >= t.key {
-		s = "min >= t.key"
-		return
-	}
-
-	if max <= t.key {
-		s = "max <= t.key"
-		return
-	}
-
-	l := t.left
-	r := t.right
-	if l == nil && r == nil {
-		if t.rank != rankLeaf {
-			s = "leaf rank wrong"
-			return
-		}
-	}
-	if l != nil {
-		if t.rank < l.rank {
-			s = "t.rank < l.rank"
-		} else if t.rank > 1+l.rank {
-			s = "t.rank > 1+l.rank"
-		} else if t.rank <= l.maxChildRank() {
-			s = "t.rank <= l.maxChildRank()"
-		} else if t.key <= l.key {
-			s = "t.key <= l.key"
-		}
-		if s != "" {
-			return
-		}
-	} else {
-		if t.rank != 1 {
-			s = "t w/ left nil has rank != 1"
-			return
-		}
-	}
-	if r != nil {
-		if t.rank < r.rank {
-			s = "t.rank < r.rank"
-		} else if t.rank > 1+r.rank {
-			s = "t.rank > 1+r.rank"
-		} else if t.rank <= r.maxChildRank() {
-			s = "t.rank <= r.maxChildRank()"
-		} else if t.key >= r.key {
-			s = "t.key >= r.key"
-		}
-		if s != "" {
-			return
-		}
-	} else {
-		if t.rank != 1 {
-			s = "t w/ right nil has rank != 1"
-			return
-		}
-	}
-	ii := 1
-	if l != nil {
-		res, il := l.wellFormedSubtree(t, min, t.key)
-		if res != "" {
-			s = "L." + res
-			return
-		}
-		ii += il
-	}
-	if r != nil {
-		res, ir := r.wellFormedSubtree(t, t.key, max)
-		if res != "" {
-			s = "R." + res
-			return
-		}
-		ii += ir
-	}
-	i = ii
-	return
-}
-
-func (t *RBTint32) DebugString() string {
-	if t.root == nil {
-		return ""
-	}
-	return t.root.DebugString()
-}
-
-// DebugString prints the tree with nested information
-// to allow an eyeball check on the tree balance.
-func (t *node32) DebugString() string {
-	s := ""
-	if t.left != nil {
-		s += "["
-		s += t.left.DebugString()
-		s += "]"
-	}
-	s += fmt.Sprintf("%v=%v:%d", t.key, t.data, t.rank)
-	if t.right != nil {
-		s += "["
-		s += t.right.DebugString()
-		s += "]"
-	}
-	return s
-}
-
-func allRBT32Ops(te *testing.T, x []int32) {
-	t := &RBTint32{}
-	for i, d := range x {
-		x[i] = d + d // Double everything for glb/lub testing
-	}
-
-	// fmt.Printf("Inserting double of %v", x)
-	k := 0
-	min := int32(0x7fffffff)
-	max := int32(-0x80000000)
-	for _, d := range x {
-		if d < min {
-			min = d
-		}
-
-		if d > max {
-			max = d
-		}
-
-		t.Insert(d, sstring(fmt.Sprintf("%v", d)))
-		k++
-		s, i := t.wellFormed()
-		if i != k {
-			te.Errorf("Wrong tree size %v, expected %v for %v", i, k, t.DebugString())
-		}
-		if s != "" {
-			te.Errorf("Tree consistency problem at %v", s)
-			return
-		}
-	}
-
-	oops := false
-
-	for _, d := range x {
-		s := fmt.Sprintf("%v", d)
-		f := t.Find(d)
-
-		// data
-		if s != fmt.Sprintf("%v", f) {
-			te.Errorf("s(%v) != f(%v)", s, f)
-			oops = true
-		}
-	}
-
-	if !oops {
-		for _, d := range x {
-			s := fmt.Sprintf("%v", d)
-
-			kg, g := t.Glb(d + 1)
-			kge, ge := t.GlbEq(d)
-			kl, l := t.Lub(d - 1)
-			kle, le := t.LubEq(d)
-
-			// keys
-			if d != kg {
-				te.Errorf("d(%v) != kg(%v)", d, kg)
-			}
-			if d != kl {
-				te.Errorf("d(%v) != kl(%v)", d, kl)
-			}
-			if d != kge {
-				te.Errorf("d(%v) != kge(%v)", d, kge)
-			}
-			if d != kle {
-				te.Errorf("d(%v) != kle(%v)", d, kle)
-			}
-			// data
-			if s != fmt.Sprintf("%v", g) {
-				te.Errorf("s(%v) != g(%v)", s, g)
-			}
-			if s != fmt.Sprintf("%v", l) {
-				te.Errorf("s(%v) != l(%v)", s, l)
-			}
-			if s != fmt.Sprintf("%v", ge) {
-				te.Errorf("s(%v) != ge(%v)", s, ge)
-			}
-			if s != fmt.Sprintf("%v", le) {
-				te.Errorf("s(%v) != le(%v)", s, le)
-			}
-		}
-
-		for _, d := range x {
-			s := fmt.Sprintf("%v", d)
-			kge, ge := t.GlbEq(d + 1)
-			kle, le := t.LubEq(d - 1)
-			if d != kge {
-				te.Errorf("d(%v) != kge(%v)", d, kge)
-			}
-			if d != kle {
-				te.Errorf("d(%v) != kle(%v)", d, kle)
-			}
-			if s != fmt.Sprintf("%v", ge) {
-				te.Errorf("s(%v) != ge(%v)", s, ge)
-			}
-			if s != fmt.Sprintf("%v", le) {
-				te.Errorf("s(%v) != le(%v)", s, le)
-			}
-		}
-
-		kg, g := t.Glb(min)
-		kge, ge := t.GlbEq(min - 1)
-		kl, l := t.Lub(max)
-		kle, le := t.LubEq(max + 1)
-		fmin := t.Find(min - 1)
-		fmax := t.Find(min + 11)
-
-		if kg != 0 || kge != 0 || kl != 0 || kle != 0 {
-			te.Errorf("Got non-zero-key for missing query")
-		}
-
-		if g != nil || ge != nil || l != nil || le != nil || fmin != nil || fmax != nil {
-			te.Errorf("Got non-error-data for missing query")
-		}
-
-	}
-}
-
-func TestAllRBTreeOps(t *testing.T) {
-	allRBT32Ops(t, []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25})
-	allRBT32Ops(t, []int32{22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 3, 2, 1, 25, 24, 23, 12, 11, 10, 9, 8, 7, 6, 5, 4})
-	allRBT32Ops(t, []int32{25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1})
-	allRBT32Ops(t, []int32{1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24})
-	allRBT32Ops(t, []int32{1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 24, 22, 20, 18, 16, 14, 12, 10, 8, 6, 4, 2})
-	allRBT32Ops(t, []int32{24, 22, 20, 18, 16, 14, 12, 10, 8, 6, 4, 2, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25})
-}
diff --git a/src/cmd/compile/internal/ssa/sparsetreemap.go b/src/cmd/compile/internal/ssa/sparsetreemap.go
deleted file mode 100644
index d26467517e..0000000000
--- a/src/cmd/compile/internal/ssa/sparsetreemap.go
+++ /dev/null
@@ -1,189 +0,0 @@
-// Copyright 2016 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 ssa
-
-import "fmt"
-
-// A SparseTreeMap encodes a subset of nodes within a tree
-// used for sparse-ancestor queries.
-//
-// Combined with a SparseTreeHelper, this supports an Insert
-// to add a tree node to the set and a Find operation to locate
-// the nearest tree ancestor of a given node such that the
-// ancestor is also in the set.
-//
-// Given a set of blocks {B1, B2, B3} within the dominator tree, established
-// by stm.Insert()ing B1, B2, B3, etc, a query at block B
-// (performed with stm.Find(stm, B, adjust, helper))
-// will return the member of the set that is the nearest strict
-// ancestor of B within the dominator tree, or nil if none exists.
-// The expected complexity of this operation is the log of the size
-// the set, given certain assumptions about sparsity (the log complexity
-// could be guaranteed with additional data structures whose constant-
-// factor overhead has not yet been justified.)
-//
-// The adjust parameter allows positioning of the insertion
-// and lookup points within a block -- one of
-// AdjustBefore, AdjustWithin, AdjustAfter,
-// where lookups at AdjustWithin can find insertions at
-// AdjustBefore in the same block, and lookups at AdjustAfter
-// can find insertions at either AdjustBefore or AdjustWithin
-// in the same block.  (Note that this assumes a gappy numbering
-// such that exit number or exit number is separated from its
-// nearest neighbor by at least 3).
-//
-// The Sparse Tree lookup algorithm is described by
-// Paul F. Dietz. Maintaining order in a linked list. In
-// Proceedings of the Fourteenth Annual ACM Symposium on
-// Theory of Computing, pages 122–127, May 1982.
-// and by
-// Ben Wegbreit. Faster retrieval from context trees.
-// Communications of the ACM, 19(9):526–529, September 1976.
-type SparseTreeMap RBTint32
-
-// A SparseTreeHelper contains indexing and allocation data
-// structures common to a collection of SparseTreeMaps, as well
-// as exposing some useful control-flow-related data to other
-// packages, such as gc.
-type SparseTreeHelper struct {
-	Sdom   []SparseTreeNode // indexed by block.ID
-	Po     []*Block         // exported data; the blocks, in a post-order
-	Dom    []*Block         // exported data; the dominator of this block.
-	Ponums []int32          // exported data; Po[Ponums[b.ID]] == b; the index of b in Po
-}
-
-// NewSparseTreeHelper returns a SparseTreeHelper for use
-// in the gc package, for example in phi-function placement.
-func NewSparseTreeHelper(f *Func) *SparseTreeHelper {
-	dom := f.Idom()
-	ponums := make([]int32, f.NumBlocks())
-	po := postorderWithNumbering(f, ponums)
-	return makeSparseTreeHelper(newSparseTree(f, dom), dom, po, ponums)
-}
-
-func (h *SparseTreeHelper) NewTree() *SparseTreeMap {
-	return &SparseTreeMap{}
-}
-
-func makeSparseTreeHelper(sdom SparseTree, dom, po []*Block, ponums []int32) *SparseTreeHelper {
-	helper := &SparseTreeHelper{Sdom: []SparseTreeNode(sdom),
-		Dom:    dom,
-		Po:     po,
-		Ponums: ponums,
-	}
-	return helper
-}
-
-// A sparseTreeMapEntry contains the data stored in a binary search
-// data structure indexed by (dominator tree walk) entry and exit numbers.
-// Each entry is added twice, once keyed by entry-1/entry/entry+1 and
-// once keyed by exit+1/exit/exit-1.
-//
-// Within a sparse tree, the two entries added bracket all their descendant
-// entries within the tree; the first insertion is keyed by entry number,
-// which comes before all the entry and exit numbers of descendants, and
-// the second insertion is keyed by exit number, which comes after all the
-// entry and exit numbers of the descendants.
-type sparseTreeMapEntry struct {
-	index        *SparseTreeNode // references the entry and exit numbers for a block in the sparse tree
-	block        *Block          // TODO: store this in a separate index.
-	data         interface{}
-	sparseParent *sparseTreeMapEntry // references the nearest ancestor of this block in the sparse tree.
-	adjust       int32               // at what adjustment was this node entered into the sparse tree? The same block may be entered more than once, but at different adjustments.
-}
-
-// Insert creates a definition within b with data x.
-// adjust indicates where in the block should be inserted:
-// AdjustBefore means defined at a phi function (visible Within or After in the same block)
-// AdjustWithin means defined within the block (visible After in the same block)
-// AdjustAfter means after the block (visible within child blocks)
-func (m *SparseTreeMap) Insert(b *Block, adjust int32, x interface{}, helper *SparseTreeHelper) {
-	rbtree := (*RBTint32)(m)
-	blockIndex := &helper.Sdom[b.ID]
-	if blockIndex.entry == 0 {
-		// assert unreachable
-		return
-	}
-	// sp will be the sparse parent in this sparse tree (nearest ancestor in the larger tree that is also in this sparse tree)
-	sp := m.findEntry(b, adjust, helper)
-	entry := &sparseTreeMapEntry{index: blockIndex, block: b, data: x, sparseParent: sp, adjust: adjust}
-
-	right := blockIndex.exit - adjust
-	_ = rbtree.Insert(right, entry)
-
-	left := blockIndex.entry + adjust
-	_ = rbtree.Insert(left, entry)
-
-	// This newly inserted block may now be the sparse parent of some existing nodes (the new sparse children of this block)
-	// Iterate over nodes bracketed by this new node to correct their parent, but not over the proper sparse descendants of those nodes.
-	_, d := rbtree.Lub(left) // Lub (not EQ) of left is either right or a sparse child
-	for tme := d.(*sparseTreeMapEntry); tme != entry; tme = d.(*sparseTreeMapEntry) {
-		tme.sparseParent = entry
-		// all descendants of tme are unchanged;
-		// next sparse sibling (or right-bracketing sparse parent == entry) is first node after tme.index.exit - tme.adjust
-		_, d = rbtree.Lub(tme.index.exit - tme.adjust)
-	}
-}
-
-// Find returns the definition visible from block b, or nil if none can be found.
-// Adjust indicates where the block should be searched.
-// AdjustBefore searches before the phi functions of b.
-// AdjustWithin searches starting at the phi functions of b.
-// AdjustAfter searches starting at the exit from the block, including normal within-block definitions.
-//
-// Note that Finds are properly nested with Inserts:
-// m.Insert(b, a) followed by m.Find(b, a) will not return the result of the insert,
-// but m.Insert(b, AdjustBefore) followed by m.Find(b, AdjustWithin) will.
-//
-// Another way to think of this is that Find searches for inputs, Insert defines outputs.
-func (m *SparseTreeMap) Find(b *Block, adjust int32, helper *SparseTreeHelper) interface{} {
-	v := m.findEntry(b, adjust, helper)
-	if v == nil {
-		return nil
-	}
-	return v.data
-}
-
-func (m *SparseTreeMap) findEntry(b *Block, adjust int32, helper *SparseTreeHelper) *sparseTreeMapEntry {
-	rbtree := (*RBTint32)(m)
-	if rbtree == nil {
-		return nil
-	}
-	blockIndex := &helper.Sdom[b.ID]
-
-	// The Glb (not EQ) of this probe is either the entry-indexed end of a sparse parent
-	// or the exit-indexed end of a sparse sibling
-	_, v := rbtree.Glb(blockIndex.entry + adjust)
-
-	if v == nil {
-		return nil
-	}
-
-	otherEntry := v.(*sparseTreeMapEntry)
-	if otherEntry.index.exit >= blockIndex.exit { // otherEntry exit after blockIndex exit; therefore, brackets
-		return otherEntry
-	}
-	// otherEntry is a sparse Sibling, and shares the same sparse parent (nearest ancestor within larger tree)
-	sp := otherEntry.sparseParent
-	if sp != nil {
-		if sp.index.exit < blockIndex.exit { // no ancestor found
-			return nil
-		}
-		return sp
-	}
-	return nil
-}
-
-func (m *SparseTreeMap) String() string {
-	tree := (*RBTint32)(m)
-	return tree.String()
-}
-
-func (e *sparseTreeMapEntry) String() string {
-	if e == nil {
-		return "nil"
-	}
-	return fmt.Sprintf("(index=%v, block=%v, data=%v)->%v", e.index, e.block, e.data, e.sparseParent)
-}
-- 
GitLab


From 72d98df88e3cbbbe482f7d421c6fd5cbd84423b4 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Mon, 15 Mar 2021 16:48:51 -0400
Subject: [PATCH 1117/2400] cmd/go: bail out from script tests earlier when a
 timeout occurs

(I needed this to debug an accidental infinite-recursion I introduced
while revising CL 293689.)

Fixes #38768

Change-Id: I306122f15b5bbd2fc5e836b32fd4dd5992ea891e
Reviewed-on: https://go-review.googlesource.com/c/go/+/302052
Trust: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/script_test.go | 132 ++++++++++++++++++++------------------
 1 file changed, 71 insertions(+), 61 deletions(-)

diff --git a/src/cmd/go/script_test.go b/src/cmd/go/script_test.go
index dfaa40548e..1f38be8ee4 100644
--- a/src/cmd/go/script_test.go
+++ b/src/cmd/go/script_test.go
@@ -41,6 +41,33 @@ func TestScript(t *testing.T) {
 	testenv.MustHaveGoBuild(t)
 	testenv.SkipIfShortAndSlow(t)
 
+	var (
+		ctx         = context.Background()
+		gracePeriod = 100 * time.Millisecond
+	)
+	if deadline, ok := t.Deadline(); ok {
+		timeout := time.Until(deadline)
+
+		// If time allows, increase the termination grace period to 5% of the
+		// remaining time.
+		if gp := timeout / 20; gp > gracePeriod {
+			gracePeriod = gp
+		}
+
+		// When we run commands that execute subprocesses, we want to reserve two
+		// grace periods to clean up. We will send the first termination signal when
+		// the context expires, then wait one grace period for the process to
+		// produce whatever useful output it can (such as a stack trace). After the
+		// first grace period expires, we'll escalate to os.Kill, leaving the second
+		// grace period for the test function to record its output before the test
+		// process itself terminates.
+		timeout -= 2 * gracePeriod
+
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, timeout)
+		t.Cleanup(cancel)
+	}
+
 	files, err := filepath.Glob("testdata/script/*.txt")
 	if err != nil {
 		t.Fatal(err)
@@ -50,40 +77,51 @@ func TestScript(t *testing.T) {
 		name := strings.TrimSuffix(filepath.Base(file), ".txt")
 		t.Run(name, func(t *testing.T) {
 			t.Parallel()
-			ts := &testScript{t: t, name: name, file: file}
+			ctx, cancel := context.WithCancel(ctx)
+			ts := &testScript{
+				t:           t,
+				ctx:         ctx,
+				cancel:      cancel,
+				gracePeriod: gracePeriod,
+				name:        name,
+				file:        file,
+			}
 			ts.setup()
 			if !*testWork {
 				defer removeAll(ts.workdir)
 			}
 			ts.run()
+			cancel()
 		})
 	}
 }
 
 // A testScript holds execution state for a single test script.
 type testScript struct {
-	t          *testing.T
-	workdir    string            // temporary work dir ($WORK)
-	log        bytes.Buffer      // test execution log (printed at end of test)
-	mark       int               // offset of next log truncation
-	cd         string            // current directory during test execution; initially $WORK/gopath/src
-	name       string            // short name of test ("foo")
-	file       string            // full file name ("testdata/script/foo.txt")
-	lineno     int               // line number currently executing
-	line       string            // line currently executing
-	env        []string          // environment list (for os/exec)
-	envMap     map[string]string // environment mapping (matches env)
-	stdout     string            // standard output from last 'go' command; for 'stdout' command
-	stderr     string            // standard error from last 'go' command; for 'stderr' command
-	stopped    bool              // test wants to stop early
-	start      time.Time         // time phase started
-	background []*backgroundCmd  // backgrounded 'exec' and 'go' commands
+	t           *testing.T
+	ctx         context.Context
+	cancel      context.CancelFunc
+	gracePeriod time.Duration
+	workdir     string            // temporary work dir ($WORK)
+	log         bytes.Buffer      // test execution log (printed at end of test)
+	mark        int               // offset of next log truncation
+	cd          string            // current directory during test execution; initially $WORK/gopath/src
+	name        string            // short name of test ("foo")
+	file        string            // full file name ("testdata/script/foo.txt")
+	lineno      int               // line number currently executing
+	line        string            // line currently executing
+	env         []string          // environment list (for os/exec)
+	envMap      map[string]string // environment mapping (matches env)
+	stdout      string            // standard output from last 'go' command; for 'stdout' command
+	stderr      string            // standard error from last 'go' command; for 'stderr' command
+	stopped     bool              // test wants to stop early
+	start       time.Time         // time phase started
+	background  []*backgroundCmd  // backgrounded 'exec' and 'go' commands
 }
 
 type backgroundCmd struct {
 	want           simpleStatus
 	args           []string
-	cancel         context.CancelFunc
 	done           <-chan struct{}
 	err            error
 	stdout, stderr strings.Builder
@@ -109,6 +147,10 @@ var extraEnvKeys = []string{
 
 // setup sets up the test execution temporary directory and environment.
 func (ts *testScript) setup() {
+	if err := ts.ctx.Err(); err != nil {
+		ts.t.Fatalf("test interrupted during setup: %v", err)
+	}
+
 	StartProxy()
 	ts.workdir = filepath.Join(testTmpDir, "script-"+ts.name)
 	ts.check(os.MkdirAll(filepath.Join(ts.workdir, "tmp"), 0777))
@@ -200,9 +242,7 @@ func (ts *testScript) run() {
 		// On a normal exit from the test loop, background processes are cleaned up
 		// before we print PASS. If we return early (e.g., due to a test failure),
 		// don't print anything about the processes that were still running.
-		for _, bg := range ts.background {
-			bg.cancel()
-		}
+		ts.cancel()
 		for _, bg := range ts.background {
 			<-bg.done
 		}
@@ -275,6 +315,10 @@ Script:
 		fmt.Fprintf(&ts.log, "> %s\n", line)
 
 		for _, cond := range parsed.conds {
+			if err := ts.ctx.Err(); err != nil {
+				ts.fatalf("test interrupted: %v", err)
+			}
+
 			// Known conds are: $GOOS, $GOARCH, runtime.Compiler, and 'short' (for testing.Short).
 			//
 			// NOTE: If you make changes here, update testdata/script/README too!
@@ -356,9 +400,7 @@ Script:
 		}
 	}
 
-	for _, bg := range ts.background {
-		bg.cancel()
-	}
+	ts.cancel()
 	ts.cmdWait(success, nil)
 
 	// Final phase ended.
@@ -798,9 +840,7 @@ func (ts *testScript) cmdSkip(want simpleStatus, args []string) {
 
 	// Before we mark the test as skipped, shut down any background processes and
 	// make sure they have returned the correct status.
-	for _, bg := range ts.background {
-		bg.cancel()
-	}
+	ts.cancel()
 	ts.cmdWait(success, nil)
 
 	if len(args) == 1 {
@@ -1065,38 +1105,9 @@ func (ts *testScript) exec(command string, args ...string) (stdout, stderr strin
 func (ts *testScript) startBackground(want simpleStatus, command string, args ...string) (*backgroundCmd, error) {
 	done := make(chan struct{})
 	bg := &backgroundCmd{
-		want:   want,
-		args:   append([]string{command}, args...),
-		done:   done,
-		cancel: func() {},
-	}
-
-	ctx := context.Background()
-	gracePeriod := 100 * time.Millisecond
-	if deadline, ok := ts.t.Deadline(); ok {
-		timeout := time.Until(deadline)
-		// If time allows, increase the termination grace period to 5% of the
-		// remaining time.
-		if gp := timeout / 20; gp > gracePeriod {
-			gracePeriod = gp
-		}
-
-		// Send the first termination signal with two grace periods remaining.
-		// If it still hasn't finished after the first period has elapsed,
-		// we'll escalate to os.Kill with a second period remaining until the
-		// test deadline..
-		timeout -= 2 * gracePeriod
-
-		if timeout <= 0 {
-			// The test has less than the grace period remaining. There is no point in
-			// even starting the command, because it will be terminated immediately.
-			// Save the expense of starting it in the first place.
-			bg.err = context.DeadlineExceeded
-			close(done)
-			return bg, nil
-		}
-
-		ctx, bg.cancel = context.WithTimeout(ctx, timeout)
+		want: want,
+		args: append([]string{command}, args...),
+		done: done,
 	}
 
 	cmd := exec.Command(command, args...)
@@ -1105,12 +1116,11 @@ func (ts *testScript) startBackground(want simpleStatus, command string, args ..
 	cmd.Stdout = &bg.stdout
 	cmd.Stderr = &bg.stderr
 	if err := cmd.Start(); err != nil {
-		bg.cancel()
 		return nil, err
 	}
 
 	go func() {
-		bg.err = waitOrStop(ctx, cmd, stopSignal(), gracePeriod)
+		bg.err = waitOrStop(ts.ctx, cmd, stopSignal(), ts.gracePeriod)
 		close(done)
 	}()
 	return bg, nil
-- 
GitLab


From c870e863298a44ead08e0b797d62ea74d7b7c971 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Wed, 13 Jan 2021 15:45:28 -0800
Subject: [PATCH 1118/2400] cmd/asm: when dynamic linking, reject code that
 uses a clobbered R15

The assember uses R15 as scratch space when assembling global variable
references in dynamically linked code. If the assembly code uses the
clobbered value of R15, report an error. The user is probably expecting
some other value in that register.

Getting rid of the R15 use isn't very practical (we could save a
register to a field in the G maybe, but that gets cumbersome).

Fixes #43661

Change-Id: I43f848a3d8b8a28931ec733386b85e6e9a42d8ff
Reviewed-on: https://go-review.googlesource.com/c/go/+/283474
Trust: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/asm/internal/asm/endtoend_test.go     |  14 ++-
 .../internal/asm/testdata/amd64dynlinkerror.s |  68 +++++++++++
 src/cmd/internal/obj/link.go                  |   1 +
 src/cmd/internal/obj/plist.go                 |   3 +
 src/cmd/internal/obj/x86/obj6.go              | 115 ++++++++++++++++++
 5 files changed, 200 insertions(+), 1 deletion(-)
 create mode 100644 src/cmd/asm/internal/asm/testdata/amd64dynlinkerror.s

diff --git a/src/cmd/asm/internal/asm/endtoend_test.go b/src/cmd/asm/internal/asm/endtoend_test.go
index 92cf64575b..ee2982df39 100644
--- a/src/cmd/asm/internal/asm/endtoend_test.go
+++ b/src/cmd/asm/internal/asm/endtoend_test.go
@@ -270,7 +270,7 @@ var (
 	errQuotesRE = regexp.MustCompile(`"([^"]*)"`)
 )
 
-func testErrors(t *testing.T, goarch, file string) {
+func testErrors(t *testing.T, goarch, file string, flags ...string) {
 	input := filepath.Join("testdata", file+".s")
 	architecture, ctxt := setArch(goarch)
 	lexer := lex.NewLexer(input)
@@ -292,6 +292,14 @@ func testErrors(t *testing.T, goarch, file string) {
 		}
 		errBuf.WriteString(s)
 	}
+	for _, flag := range flags {
+		switch flag {
+		case "dynlink":
+			ctxt.Flag_dynlink = true
+		default:
+			t.Errorf("unknown flag %s", flag)
+		}
+	}
 	pList.Firstpc, ok = parser.Parse()
 	obj.Flushplist(ctxt, pList, nil, "")
 	if ok && !failed {
@@ -430,6 +438,10 @@ func TestAMD64Errors(t *testing.T) {
 	testErrors(t, "amd64", "amd64error")
 }
 
+func TestAMD64DynLinkErrors(t *testing.T) {
+	testErrors(t, "amd64", "amd64dynlinkerror", "dynlink")
+}
+
 func TestMIPSEndToEnd(t *testing.T) {
 	testEndToEnd(t, "mips", "mips")
 	testEndToEnd(t, "mips64", "mips64")
diff --git a/src/cmd/asm/internal/asm/testdata/amd64dynlinkerror.s b/src/cmd/asm/internal/asm/testdata/amd64dynlinkerror.s
new file mode 100644
index 0000000000..1eee1a17db
--- /dev/null
+++ b/src/cmd/asm/internal/asm/testdata/amd64dynlinkerror.s
@@ -0,0 +1,68 @@
+// Copyright 2021 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.
+
+// Test to make sure that if we use R15 after it is clobbered by
+// a global variable access while dynamic linking, we get an error.
+// See issue 43661.
+
+TEXT ·a1(SB), 0, $0-0
+	CMPL runtime·writeBarrier(SB), $0
+	MOVL $0, R15
+	RET
+TEXT ·a2(SB), 0, $0-0
+	CMPL runtime·writeBarrier(SB), $0
+	MOVQ $0, R15
+	RET
+TEXT ·a3(SB), 0, $0-0
+	CMPL runtime·writeBarrier(SB), $0
+	XORL R15, R15
+	RET
+TEXT ·a4(SB), 0, $0-0
+	CMPL runtime·writeBarrier(SB), $0
+	XORQ R15, R15
+	RET
+TEXT ·a5(SB), 0, $0-0
+	CMPL runtime·writeBarrier(SB), $0
+	XORL R15, R15
+	RET
+TEXT ·a6(SB), 0, $0-0
+	CMPL runtime·writeBarrier(SB), $0
+	POPQ R15
+	PUSHQ R15
+	RET
+TEXT ·a7(SB), 0, $0-0
+	CMPL runtime·writeBarrier(SB), $0
+	MOVQ R15, AX // ERROR "when dynamic linking, R15 is clobbered by a global variable access and is used here"
+	RET
+TEXT ·a8(SB), 0, $0-0
+	CMPL runtime·writeBarrier(SB), $0
+	ADDQ AX, R15 // ERROR "when dynamic linking, R15 is clobbered by a global variable access and is used here"
+	RET
+TEXT ·a9(SB), 0, $0-0
+	CMPL runtime·writeBarrier(SB), $0
+	ORQ R15, R15 // ERROR "when dynamic linking, R15 is clobbered by a global variable access and is used here"
+	RET
+TEXT ·a10(SB), 0, $0-0
+	CMPL runtime·writeBarrier(SB), $0
+	JEQ one
+	ORQ R15, R15 // ERROR "when dynamic linking, R15 is clobbered by a global variable access and is used here"
+one:
+	RET
+TEXT ·a11(SB), 0, $0-0
+	CMPL runtime·writeBarrier(SB), $0
+	JEQ one
+	JMP two
+one:
+	ORQ R15, R15 // ERROR "when dynamic linking, R15 is clobbered by a global variable access and is used here"
+two:
+	RET
+TEXT ·a12(SB), 0, $0-0
+	CMPL runtime·writeBarrier(SB), $0
+	JMP one
+two:
+	ORQ R15, R15
+	RET
+one:
+	MOVL $0, R15
+	JMP two
diff --git a/src/cmd/internal/obj/link.go b/src/cmd/internal/obj/link.go
index 448f45b47b..c34a769a82 100644
--- a/src/cmd/internal/obj/link.go
+++ b/src/cmd/internal/obj/link.go
@@ -949,6 +949,7 @@ func (ctxt *Link) FixedFrameSize() int64 {
 type LinkArch struct {
 	*sys.Arch
 	Init           func(*Link)
+	ErrorCheck     func(*Link, *LSym)
 	Preprocess     func(*Link, *LSym, ProgAlloc)
 	Assemble       func(*Link, *LSym, ProgAlloc)
 	Progedit       func(*Link, *Prog, ProgAlloc)
diff --git a/src/cmd/internal/obj/plist.go b/src/cmd/internal/obj/plist.go
index 177083261c..b2f2bdcaed 100644
--- a/src/cmd/internal/obj/plist.go
+++ b/src/cmd/internal/obj/plist.go
@@ -107,6 +107,9 @@ func Flushplist(ctxt *Link, plist *Plist, newprog ProgAlloc, myimportpath string
 	// Turn functions into machine code images.
 	for _, s := range text {
 		mkfwd(s)
+		if ctxt.Arch.ErrorCheck != nil {
+			ctxt.Arch.ErrorCheck(ctxt, s)
+		}
 		linkpatch(ctxt, s, newprog)
 		ctxt.Arch.Preprocess(ctxt, s, newprog)
 		ctxt.Arch.Assemble(ctxt, s, newprog)
diff --git a/src/cmd/internal/obj/x86/obj6.go b/src/cmd/internal/obj/x86/obj6.go
index d70cbebc5e..02af8eaa82 100644
--- a/src/cmd/internal/obj/x86/obj6.go
+++ b/src/cmd/internal/obj/x86/obj6.go
@@ -37,6 +37,7 @@ import (
 	"cmd/internal/sys"
 	"log"
 	"math"
+	"path"
 	"strings"
 )
 
@@ -563,6 +564,11 @@ func rewriteToPcrel(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
 	obj.Nopout(p)
 }
 
+// Prog.mark
+const (
+	markBit = 1 << 0 // used in errorCheck to avoid duplicate work
+)
+
 func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 	if cursym.Func().Text == nil || cursym.Func().Text.Link == nil {
 		return
@@ -1196,6 +1202,114 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
 	return end
 }
 
+func isR15(r int16) bool {
+	return r == REG_R15 || r == REG_R15B
+}
+func addrMentionsR15(a *obj.Addr) bool {
+	if a == nil {
+		return false
+	}
+	return isR15(a.Reg) || isR15(a.Index)
+}
+func progMentionsR15(p *obj.Prog) bool {
+	return addrMentionsR15(&p.From) || addrMentionsR15(&p.To) || isR15(p.Reg) || addrMentionsR15(p.GetFrom3())
+}
+
+// progOverwritesR15 reports whether p writes to R15 and does not depend on
+// the previous value of R15.
+func progOverwritesR15(p *obj.Prog) bool {
+	if !(p.To.Type == obj.TYPE_REG && isR15(p.To.Reg)) {
+		// Not writing to R15.
+		return false
+	}
+	if (p.As == AXORL || p.As == AXORQ) && p.From.Type == obj.TYPE_REG && isR15(p.From.Reg) {
+		// These look like uses of R15, but aren't, so we must detect these
+		// before the use check below.
+		return true
+	}
+	if addrMentionsR15(&p.From) || isR15(p.Reg) || addrMentionsR15(p.GetFrom3()) {
+		// use before overwrite
+		return false
+	}
+	if p.As == AMOVL || p.As == AMOVQ || p.As == APOPQ {
+		return true
+		// TODO: MOVB might be ok if we only ever use R15B.
+	}
+	return false
+}
+
+func addrUsesGlobal(a *obj.Addr) bool {
+	if a == nil {
+		return false
+	}
+	return a.Name == obj.NAME_EXTERN && !a.Sym.Local()
+}
+func progUsesGlobal(p *obj.Prog) bool {
+	if p.As == obj.ACALL || p.As == obj.ATEXT || p.As == obj.AFUNCDATA || p.As == obj.ARET || p.As == obj.AJMP {
+		// These opcodes don't use a GOT to access their argument (see rewriteToUseGot),
+		// or R15 would be dead at them anyway.
+		return false
+	}
+	if p.As == ALEAQ {
+		// The GOT entry is placed directly in the destination register; R15 is not used.
+		return false
+	}
+	return addrUsesGlobal(&p.From) || addrUsesGlobal(&p.To) || addrUsesGlobal(p.GetFrom3())
+}
+
+func errorCheck(ctxt *obj.Link, s *obj.LSym) {
+	// When dynamic linking, R15 is used to access globals. Reject code that
+	// uses R15 after a global variable access.
+	if !ctxt.Flag_dynlink {
+		return
+	}
+
+	// Flood fill all the instructions where R15's value is junk.
+	// If there are any uses of R15 in that set, report an error.
+	var work []*obj.Prog
+	var mentionsR15 bool
+	for p := s.Func().Text; p != nil; p = p.Link {
+		if progUsesGlobal(p) {
+			work = append(work, p)
+			p.Mark |= markBit
+		}
+		if progMentionsR15(p) {
+			mentionsR15 = true
+		}
+	}
+	if mentionsR15 {
+		for len(work) > 0 {
+			p := work[len(work)-1]
+			work = work[:len(work)-1]
+			if q := p.To.Target(); q != nil && q.Mark&markBit == 0 {
+				q.Mark |= markBit
+				work = append(work, q)
+			}
+			if p.As == obj.AJMP || p.As == obj.ARET {
+				continue // no fallthrough
+			}
+			if progMentionsR15(p) {
+				if progOverwritesR15(p) {
+					// R15 is overwritten by this instruction. Its value is not junk any more.
+					continue
+				}
+				pos := ctxt.PosTable.Pos(p.Pos)
+				ctxt.Diag("%s:%s: when dynamic linking, R15 is clobbered by a global variable access and is used here: %v", path.Base(pos.Filename()), pos.LineNumber(), p)
+				break // only report one error
+			}
+			if q := p.Link; q != nil && q.Mark&markBit == 0 {
+				q.Mark |= markBit
+				work = append(work, q)
+			}
+		}
+	}
+
+	// Clean up.
+	for p := s.Func().Text; p != nil; p = p.Link {
+		p.Mark &^= markBit
+	}
+}
+
 var unaryDst = map[obj.As]bool{
 	ABSWAPL:     true,
 	ABSWAPQ:     true,
@@ -1284,6 +1398,7 @@ var unaryDst = map[obj.As]bool{
 var Linkamd64 = obj.LinkArch{
 	Arch:           sys.ArchAMD64,
 	Init:           instinit,
+	ErrorCheck:     errorCheck,
 	Preprocess:     preprocess,
 	Assemble:       span6,
 	Progedit:       progedit,
-- 
GitLab


From dc1556eaef871074895ed9fdf6028475d53235be Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 11 Mar 2021 15:00:50 -0500
Subject: [PATCH 1119/2400] cmd/compile: update some comments

Update some symbol references after refactoring.

Change-Id: I134eec453b69efae97eb8a13e52ff8c14d38442a
Reviewed-on: https://go-review.googlesource.com/c/go/+/301790
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/reflectdata/reflect.go | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index 06a7f91c52..0e1de35887 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -1525,7 +1525,7 @@ func dgcptrmask(t *types.Type) *obj.LSym {
 
 // fillptrmask fills in ptrmask with 1s corresponding to the
 // word offsets in t that hold pointers.
-// ptrmask is assumed to fit at least typeptrdata(t)/Widthptr bits.
+// ptrmask is assumed to fit at least types.PtrDataSize(t)/PtrSize bits.
 func fillptrmask(t *types.Type, ptrmask []byte) {
 	for i := range ptrmask {
 		ptrmask[i] = 0
@@ -1546,8 +1546,9 @@ func fillptrmask(t *types.Type, ptrmask []byte) {
 }
 
 // dgcprog emits and returns the symbol containing a GC program for type t
-// along with the size of the data described by the program (in the range [typeptrdata(t), t.Width]).
-// In practice, the size is typeptrdata(t) except for non-trivial arrays.
+// along with the size of the data described by the program (in the range
+// [types.PtrDataSize(t), t.Width]).
+// In practice, the size is types.PtrDataSize(t) except for non-trivial arrays.
 // For non-trivial arrays, the program describes the full t.Width size.
 func dgcprog(t *types.Type) (*obj.LSym, int64) {
 	types.CalcSize(t)
@@ -1833,7 +1834,7 @@ func MarkUsedIfaceMethod(n *ir.CallExpr) {
 	tsym := TypeLinksym(ityp)
 	r := obj.Addrel(ir.CurFunc.LSym)
 	r.Sym = tsym
-	// dot.Xoffset is the method index * Widthptr (the offset of code pointer
+	// dot.Xoffset is the method index * PtrSize (the offset of code pointer
 	// in itab).
 	midx := dot.Offset() / int64(types.PtrSize)
 	r.Add = InterfaceMethodOffset(ityp, midx)
-- 
GitLab


From 7a1e963058460d4136603b86386f2bae6fe0d5f2 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Fri, 12 Mar 2021 23:21:09 -0500
Subject: [PATCH 1120/2400] cmd/compile, cmd/link: dynamically export writable
 static tmps

Static tmps are private to a package, but with plugins a package
can be shared among multiple DSOs. They need to have a consistent
view of the static tmps, especially for writable ones. So export
them. (Read-only static tmps have the same values anyway, so it
doesn't matter. Also Mach-O doesn't support dynamically exporting
read-only symbols anyway.)

Fixes #44956.

Change-Id: I921e25b7ab73cd5d5347800eccdb7931e3448779
Reviewed-on: https://go-review.googlesource.com/c/go/+/301793
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 misc/cgo/testplugin/plugin_test.go            |  7 +++
 .../testdata/issue44956/base/base.go          |  7 +++
 .../testplugin/testdata/issue44956/main.go    | 47 +++++++++++++++++++
 .../testplugin/testdata/issue44956/plugin1.go |  9 ++++
 .../testplugin/testdata/issue44956/plugin2.go | 11 +++++
 src/cmd/compile/internal/staticinit/sched.go  |  1 -
 src/cmd/compile/internal/walk/complit.go      |  3 +-
 src/cmd/link/internal/ld/symtab.go            |  9 +++-
 8 files changed, 91 insertions(+), 3 deletions(-)
 create mode 100644 misc/cgo/testplugin/testdata/issue44956/base/base.go
 create mode 100644 misc/cgo/testplugin/testdata/issue44956/main.go
 create mode 100644 misc/cgo/testplugin/testdata/issue44956/plugin1.go
 create mode 100644 misc/cgo/testplugin/testdata/issue44956/plugin2.go

diff --git a/misc/cgo/testplugin/plugin_test.go b/misc/cgo/testplugin/plugin_test.go
index 2d991012c8..8869528015 100644
--- a/misc/cgo/testplugin/plugin_test.go
+++ b/misc/cgo/testplugin/plugin_test.go
@@ -209,3 +209,10 @@ func TestMethod2(t *testing.T) {
 	goCmd(t, "build", "-o", "method2.exe", "./method2/main.go")
 	run(t, "./method2.exe")
 }
+
+func TestIssue44956(t *testing.T) {
+	goCmd(t, "build", "-buildmode=plugin", "-o", "issue44956p1.so", "./issue44956/plugin1.go")
+	goCmd(t, "build", "-buildmode=plugin", "-o", "issue44956p2.so", "./issue44956/plugin2.go")
+	goCmd(t, "build", "-o", "issue44956.exe", "./issue44956/main.go")
+	run(t, "./issue44956.exe")
+}
diff --git a/misc/cgo/testplugin/testdata/issue44956/base/base.go b/misc/cgo/testplugin/testdata/issue44956/base/base.go
new file mode 100644
index 0000000000..609aa0dff4
--- /dev/null
+++ b/misc/cgo/testplugin/testdata/issue44956/base/base.go
@@ -0,0 +1,7 @@
+// Copyright 2021 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 base
+
+var X = &map[int]int{123: 456}
diff --git a/misc/cgo/testplugin/testdata/issue44956/main.go b/misc/cgo/testplugin/testdata/issue44956/main.go
new file mode 100644
index 0000000000..287a60585e
--- /dev/null
+++ b/misc/cgo/testplugin/testdata/issue44956/main.go
@@ -0,0 +1,47 @@
+// Copyright 2021 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.
+
+// Issue 44956: writable static temp is not exported correctly.
+// In the test below, package base is
+//
+//     X = &map{...}
+//
+// which compiles to
+//
+//     X = &stmp           // static
+//     stmp = makemap(...) // in init function
+//
+// plugin1 and plugin2 both import base. plugin1 doesn't use
+// base.X, so that symbol is deadcoded in plugin1.
+//
+// plugin1 is loaded first. base.init runs at that point, which
+// initialize base.stmp.
+//
+// plugin2 is then loaded. base.init already ran, so it doesn't run
+// again. When base.stmp is not exported, plugin2's base.X points to
+// its own private base.stmp, which is not initialized, fail.
+
+package main
+
+import "plugin"
+
+func main() {
+	_, err := plugin.Open("issue44956p1.so")
+	if err != nil {
+		panic("FAIL")
+	}
+
+	p2, err := plugin.Open("issue44956p2.so")
+	if err != nil {
+		panic("FAIL")
+	}
+	f, err := p2.Lookup("F")
+	if err != nil {
+		panic("FAIL")
+	}
+	x := f.(func() *map[int]int)()
+	if x == nil || (*x)[123] != 456 {
+		panic("FAIL")
+	}
+}
diff --git a/misc/cgo/testplugin/testdata/issue44956/plugin1.go b/misc/cgo/testplugin/testdata/issue44956/plugin1.go
new file mode 100644
index 0000000000..499fa31abf
--- /dev/null
+++ b/misc/cgo/testplugin/testdata/issue44956/plugin1.go
@@ -0,0 +1,9 @@
+// Copyright 2021 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 _ "testplugin/issue44956/base"
+
+func main() {}
diff --git a/misc/cgo/testplugin/testdata/issue44956/plugin2.go b/misc/cgo/testplugin/testdata/issue44956/plugin2.go
new file mode 100644
index 0000000000..a73542ca71
--- /dev/null
+++ b/misc/cgo/testplugin/testdata/issue44956/plugin2.go
@@ -0,0 +1,11 @@
+// Copyright 2021 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 "testplugin/issue44956/base"
+
+func F() *map[int]int { return base.X }
+
+func main() {}
diff --git a/src/cmd/compile/internal/staticinit/sched.go b/src/cmd/compile/internal/staticinit/sched.go
index f3ad82e7b6..0c97b6de74 100644
--- a/src/cmd/compile/internal/staticinit/sched.go
+++ b/src/cmd/compile/internal/staticinit/sched.go
@@ -459,7 +459,6 @@ func StaticName(t *types.Type) *ir.Name {
 	statuniqgen++
 	typecheck.Declare(n, ir.PEXTERN)
 	n.SetType(t)
-	n.Linksym().Set(obj.AttrLocal, true)
 	return n
 }
 
diff --git a/src/cmd/compile/internal/walk/complit.go b/src/cmd/compile/internal/walk/complit.go
index 73442dc404..54f2c5fefe 100644
--- a/src/cmd/compile/internal/walk/complit.go
+++ b/src/cmd/compile/internal/walk/complit.go
@@ -55,11 +55,12 @@ func (c initContext) String() string {
 	return "inNonInitFunction"
 }
 
-// readonlystaticname returns a name backed by a (writable) static data symbol.
+// readonlystaticname returns a name backed by a read-only static data symbol.
 func readonlystaticname(t *types.Type) *ir.Name {
 	n := staticinit.StaticName(t)
 	n.MarkReadonly()
 	n.Linksym().Set(obj.AttrContentAddressable, true)
+	n.Linksym().Set(obj.AttrLocal, true)
 	return n
 }
 
diff --git a/src/cmd/link/internal/ld/symtab.go b/src/cmd/link/internal/ld/symtab.go
index 85a8ff42ad..ca8ef8641e 100644
--- a/src/cmd/link/internal/ld/symtab.go
+++ b/src/cmd/link/internal/ld/symtab.go
@@ -31,6 +31,7 @@
 package ld
 
 import (
+	"cmd/internal/obj"
 	"cmd/internal/objabi"
 	"cmd/link/internal/loader"
 	"cmd/link/internal/sym"
@@ -140,7 +141,9 @@ func putelfsym(ctxt *Link, x loader.Sym, typ elf.SymType, curbind elf.SymBind) {
 	// One pass for each binding: elf.STB_LOCAL, elf.STB_GLOBAL,
 	// maybe one day elf.STB_WEAK.
 	bind := elf.STB_GLOBAL
-	if ldr.IsFileLocal(x) || ldr.AttrVisibilityHidden(x) || ldr.AttrLocal(x) {
+	if ldr.IsFileLocal(x) && !isStaticTmp(sname) || ldr.AttrVisibilityHidden(x) || ldr.AttrLocal(x) {
+		// Static tmp is package local, but a package can be shared among multiple DSOs.
+		// They need to have a single view of the static tmp that are writable.
 		bind = elf.STB_LOCAL
 	}
 
@@ -856,3 +859,7 @@ func setCarrierSize(typ sym.SymKind, sz int64) {
 	}
 	CarrierSymByType[typ].Size = sz
 }
+
+func isStaticTmp(name string) bool {
+	return strings.Contains(name, "."+obj.StaticNamePref)
+}
-- 
GitLab


From 68f8e1af29ab12cfa97eb119a7d12a7ea2295e4d Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 11 Mar 2021 18:23:30 -0800
Subject: [PATCH 1121/2400] cmd/compile/internal/types2: review of call.go

The changes between (equivalent, and reviewed) go/types/call.go
and call.go can be seen by comparing patchset 1 and 2. The actual
changes are removing the "// UNREVIEWED" marker, renaming of
sig_params to sigParams, and a couple of comment adjustments.
These additional changes reduce the difference between this
file and the go/types version.

Note that the verification pass using a MethodSet doesn't
exist because there's no MethodSet in types2.

Change-Id: I4d49460e0457401ed705dff5cfd17c9ff259d89f
Reviewed-on: https://go-review.googlesource.com/c/go/+/300998
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/call.go | 26 ++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index 93f4c51937..2ee22c8a19 100644
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2013 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.
@@ -324,8 +323,8 @@ func (check *Checker) arguments(call *syntax.CallExpr, sig *Signature, args []*o
 	ddd := call.HasDots
 
 	// set up parameters
-	sig_params := sig.params // adjusted for variadic functions (may be nil for empty parameter lists!)
-	adjusted := false        // indicates if sig_params is different from t.params
+	sigParams := sig.params // adjusted for variadic functions (may be nil for empty parameter lists!)
+	adjusted := false       // indicates if sigParams is different from t.params
 	if sig.variadic {
 		if ddd {
 			// variadic_func(a, b, c...)
@@ -348,7 +347,7 @@ func (check *Checker) arguments(call *syntax.CallExpr, sig *Signature, args []*o
 				for len(vars) < nargs {
 					vars = append(vars, NewParam(last.pos, last.pkg, last.name, typ))
 				}
-				sig_params = NewTuple(vars...) // possibly nil!
+				sigParams = NewTuple(vars...) // possibly nil!
 				adjusted = true
 				npars = nargs
 			} else {
@@ -380,7 +379,7 @@ func (check *Checker) arguments(call *syntax.CallExpr, sig *Signature, args []*o
 	if len(sig.tparams) > 0 {
 		// TODO(gri) provide position information for targs so we can feed
 		//           it to the instantiate call for better error reporting
-		targs, failed := check.infer(sig.tparams, sig_params, args)
+		targs, failed := check.infer(sig.tparams, sigParams, args)
 		if targs == nil {
 			return // error already reported
 		}
@@ -419,15 +418,15 @@ func (check *Checker) arguments(call *syntax.CallExpr, sig *Signature, args []*o
 		// need to compute it from the adjusted list; otherwise we can
 		// simply use the result signature's parameter list.
 		if adjusted {
-			sig_params = check.subst(call.Pos(), sig_params, makeSubstMap(sig.tparams, targs)).(*Tuple)
+			sigParams = check.subst(call.Pos(), sigParams, makeSubstMap(sig.tparams, targs)).(*Tuple)
 		} else {
-			sig_params = rsig.params
+			sigParams = rsig.params
 		}
 	}
 
 	// check arguments
 	for i, a := range args {
-		check.assignment(a, sig_params.vars[i].typ, "argument")
+		check.assignment(a, sigParams.vars[i].typ, "argument")
 	}
 
 	return
@@ -597,9 +596,9 @@ func (check *Checker) selector(x *operand, e *syntax.SelectorExpr) {
 	if m, _ := obj.(*Func); m != nil {
 		// check.dump("### found method %s", m)
 		check.objDecl(m, nil)
-		// If m has a parameterized receiver type, infer the type arguments
-		// from the actual receiver provided and then substitute the type
-		// parameters accordingly.
+		// If m has a parameterized receiver type, infer the type arguments from
+		// the actual receiver provided and then substitute the type parameters in
+		// the signature accordingly.
 		// TODO(gri) factor this code out
 		sig := m.typ.(*Signature)
 		if len(sig.rparams) > 0 {
@@ -610,7 +609,7 @@ func (check *Checker) selector(x *operand, e *syntax.SelectorExpr) {
 			// Traverse the embedding to find that type (issue #44688).
 			recv := x.typ
 			for i := 0; i < len(index)-1; i++ {
-				// The embedded type is always a struct or a pointer to
+				// The embedded type is either a struct or a pointer to
 				// a struct except for the last one (which we don't need).
 				recv = asStruct(derefStructPtr(recv)).Field(index[i]).typ
 			}
@@ -633,7 +632,8 @@ func (check *Checker) selector(x *operand, e *syntax.SelectorExpr) {
 			if failed >= 0 {
 				// We may reach here if there were other errors (see issue #40056).
 				// check.infer will report a follow-up error.
-				// TODO(gri) avoid the follow-up error as it is confusing (there's no inference in the source code)
+				// TODO(gri) avoid the follow-up error as it is confusing
+				//           (there's no inference in the source code)
 				goto Error
 			}
 			// Don't modify m. Instead - for now - make a copy of m and use that instead.
-- 
GitLab


From 63b0a0a5b83e28f55ce68cf1099d9c5ff3998b60 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 16 Mar 2021 17:09:23 -0700
Subject: [PATCH 1122/2400] spec: fix rendering of >=

Follow-up on https://golang.org/cl/297249.

Change-Id: Ib4df91df530e4e7d7dd8c54d89c834cee55031f8
Reviewed-on: https://go-review.googlesource.com/c/go/+/302370
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 doc/go_spec.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index 39617cf524..8c9003434c 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -3681,8 +3681,8 @@ The bitwise logical and shift operators apply to integers only.
 ^    bitwise XOR            integers
 &amp;^   bit clear (AND NOT)    integers
 
-&lt;&lt;   left shift             integer &lt;&lt; integer >= 0
-&gt;&gt;   right shift            integer &gt;&gt; integer >= 0
+&lt;&lt;   left shift             integer &lt;&lt; integer &gt;= 0
+&gt;&gt;   right shift            integer &gt;&gt; integer &gt;= 0
 </pre>
 
 
-- 
GitLab


From a826f7dc45f2e0f210341893bd70740aef6b777d Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Tue, 16 Mar 2021 13:31:20 -0700
Subject: [PATCH 1123/2400] debug/dwarf: support DW_FORM_rnglistx aka
 formRnglistx

Change-Id: I7df915978af3488f46a27595a1b04d0d33f81f7b
Reviewed-on: https://go-review.googlesource.com/c/go/+/302369
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/debug/dwarf/entry.go              |  66 ++++++++++++++++++++++++--
 src/debug/dwarf/entry_test.go         |  13 +++++
 src/debug/dwarf/line_test.go          |  23 +++++++++
 src/debug/dwarf/testdata/rnglistx.c   |  19 ++++++++
 src/debug/dwarf/testdata/rnglistx.elf | Bin 0 -> 11024 bytes
 5 files changed, 116 insertions(+), 5 deletions(-)
 create mode 100644 src/debug/dwarf/testdata/rnglistx.c
 create mode 100755 src/debug/dwarf/testdata/rnglistx.elf

diff --git a/src/debug/dwarf/entry.go b/src/debug/dwarf/entry.go
index 3fc73b8ead..9f5ac57080 100644
--- a/src/debug/dwarf/entry.go
+++ b/src/debug/dwarf/entry.go
@@ -317,7 +317,7 @@ const (
 	// the "mac" section.
 	ClassMacPtr
 
-	// ClassMacPtr represents values that are an int64 offset into
+	// ClassRangeListPtr represents values that are an int64 offset into
 	// the "rangelist" section.
 	ClassRangeListPtr
 
@@ -355,7 +355,7 @@ const (
 	// into the "loclists" section.
 	ClassLocList
 
-	// ClassRngList represents values that are an int64 offset
+	// ClassRngList represents values that are a uint64 offset
 	// from the base of the "rnglists" section.
 	ClassRngList
 
@@ -464,6 +464,35 @@ func (b *buf) entry(cu *Entry, atab abbrevTable, ubase Offset, vers int) *Entry
 		return val
 	}
 
+	resolveRnglistx := func(rnglistsBase, off uint64) uint64 {
+		is64, _ := b.format.dwarf64()
+		if is64 {
+			off *= 8
+		} else {
+			off *= 4
+		}
+		off += rnglistsBase
+		if uint64(int(off)) != off {
+			b.error("DW_FORM_rnglistx offset out of range")
+		}
+
+		b1 := makeBuf(b.dwarf, b.format, "rnglists", 0, b.dwarf.rngLists)
+		b1.skip(int(off))
+		if is64 {
+			off = b1.uint64()
+		} else {
+			off = uint64(b1.uint32())
+		}
+		if b1.err != nil {
+			b.err = b1.err
+			return 0
+		}
+		if uint64(int(off)) != off {
+			b.error("DW_FORM_rnglistx indirect offset out of range")
+		}
+		return rnglistsBase + off
+	}
+
 	for i := range e.Field {
 		e.Field[i].Attr = a.field[i].attr
 		e.Field[i].Class = a.field[i].class
@@ -709,7 +738,21 @@ func (b *buf) entry(cu *Entry, atab abbrevTable, ubase Offset, vers int) *Entry
 
 		// rnglist
 		case formRnglistx:
-			val = b.uint()
+			off := b.uint()
+
+			// We have to adjust by the rnglists_base of
+			// the compilation unit. This won't work if
+			// the program uses Reader.Seek to skip over
+			// the unit. Not much we can do about that.
+			var rnglistsBase int64
+			if cu != nil {
+				rnglistsBase, _ = cu.Val(AttrRnglistsBase).(int64)
+			} else if a.tag == TagCompileUnit {
+				delay = append(delay, delayed{i, off, formRnglistx})
+				break
+			}
+
+			val = resolveRnglistx(uint64(rnglistsBase), off)
 		}
 
 		e.Field[i].Val = val
@@ -734,6 +777,12 @@ func (b *buf) entry(cu *Entry, atab abbrevTable, ubase Offset, vers int) *Entry
 			if b.err != nil {
 				return nil
 			}
+		case formRnglistx:
+			rnglistsBase, _ := e.Val(AttrRnglistsBase).(int64)
+			e.Field[del.idx].Val = resolveRnglistx(uint64(rnglistsBase), del.off)
+			if b.err != nil {
+				return nil
+			}
 		}
 	}
 
@@ -993,8 +1042,15 @@ func (d *Data) Ranges(e *Entry) ([][2]uint64, error) {
 			return d.dwarf5Ranges(u, cu, base, ranges, ret)
 
 		case ClassRngList:
-			// TODO: support DW_FORM_rnglistx
-			return ret, nil
+			rnglist, ok := field.Val.(uint64)
+			if !ok {
+				return ret, nil
+			}
+			cu, base, err := d.baseAddressForEntry(e)
+			if err != nil {
+				return nil, err
+			}
+			return d.dwarf5Ranges(u, cu, base, int64(rnglist), ret)
 
 		default:
 			return ret, nil
diff --git a/src/debug/dwarf/entry_test.go b/src/debug/dwarf/entry_test.go
index b54f8b4f8d..1f41d742ea 100644
--- a/src/debug/dwarf/entry_test.go
+++ b/src/debug/dwarf/entry_test.go
@@ -84,6 +84,19 @@ func TestRangesSection(t *testing.T) {
 	testRanges(t, "testdata/ranges.elf", want)
 }
 
+func TestRangesRnglistx(t *testing.T) {
+	want := []wantRange{
+		{0x401000, [][2]uint64{{0x401020, 0x40102c}, {0x401000, 0x40101d}}},
+		{0x40101c, [][2]uint64{{0x401020, 0x40102c}, {0x401000, 0x40101d}}},
+		{0x40101d, nil},
+		{0x40101f, nil},
+		{0x401020, [][2]uint64{{0x401020, 0x40102c}, {0x401000, 0x40101d}}},
+		{0x40102b, [][2]uint64{{0x401020, 0x40102c}, {0x401000, 0x40101d}}},
+		{0x40102c, nil},
+	}
+	testRanges(t, "testdata/rnglistx.elf", want)
+}
+
 func testRanges(t *testing.T, name string, want []wantRange) {
 	d := elfData(t, name)
 	r := d.Reader()
diff --git a/src/debug/dwarf/line_test.go b/src/debug/dwarf/line_test.go
index b13818e8b5..9c6b6ff5b0 100644
--- a/src/debug/dwarf/line_test.go
+++ b/src/debug/dwarf/line_test.go
@@ -117,6 +117,29 @@ func TestLineELFClang(t *testing.T) {
 	testLineTable(t, want, files, elfData(t, "testdata/line-clang.elf"))
 }
 
+func TestLineRnglists(t *testing.T) {
+	// Test a newer file, generated by clang.
+	file := &LineFile{Name: "/usr/local/google/home/iant/foo.c"}
+	want := []LineEntry{
+		{Address: 0x401020, File: file, Line: 12, IsStmt: true},
+		{Address: 0x401020, File: file, Line: 13, Column: 12, IsStmt: true, PrologueEnd: true},
+		{Address: 0x401022, File: file, Line: 13, Column: 7},
+		{Address: 0x401024, File: file, Line: 17, Column: 1, IsStmt: true},
+		{Address: 0x401027, File: file, Line: 16, Column: 10, IsStmt: true},
+		{Address: 0x40102c, EndSequence: true},
+		{Address: 0x401000, File: file, Line: 2, IsStmt: true},
+		{Address: 0x401000, File: file, Line: 6, Column: 17, IsStmt: true, PrologueEnd: true},
+		{Address: 0x401002, File: file, Line: 6, Column: 3},
+		{Address: 0x401019, File: file, Line: 9, Column: 3, IsStmt: true},
+		{Address: 0x40101a, File: file, Line: 0, Column: 3},
+		{Address: 0x40101c, File: file, Line: 9, Column: 3},
+		{Address: 0x40101d, EndSequence: true},
+	}
+	files := [][]*LineFile{{file}}
+
+	testLineTable(t, want, files, elfData(t, "testdata/rnglistx.elf"))
+}
+
 func TestLineSeek(t *testing.T) {
 	d := elfData(t, "testdata/line-gcc.elf")
 
diff --git a/src/debug/dwarf/testdata/rnglistx.c b/src/debug/dwarf/testdata/rnglistx.c
new file mode 100644
index 0000000000..877043584d
--- /dev/null
+++ b/src/debug/dwarf/testdata/rnglistx.c
@@ -0,0 +1,19 @@
+// clang -gdwarf-5 -O2 -nostdlib
+
+__attribute__((noinline, cold))
+static int sum(int i) {
+  int j, s;
+
+  s = 0;
+  for (j = 0; j < i; j++) {
+    s += j * i;
+  }
+  return s;
+}
+
+int main(int argc, char** argv) {
+  if (argc == 0) {
+    return 0;
+  }
+  return sum(argc);
+}
diff --git a/src/debug/dwarf/testdata/rnglistx.elf b/src/debug/dwarf/testdata/rnglistx.elf
new file mode 100755
index 0000000000000000000000000000000000000000..c2d7f55479125b2bde8d3889945737fb58c49896
GIT binary patch
literal 11024
zcmb<-^>JfjWMqH=CI&kOFi*e%ECeAL7%r%RxnRP9!GeL6!GS@LK>)0l1uP09U^*al
z1lTYJ1{lpC08s}LW(6^!d<Lj}Fj@yB$H2e<qmlK2?Nfj%P=MIO0HqV4!Y~@9FW_lO
z3O;=@P<=2Otd@a+A@FHQ3L8|87z*YcV$_bR84ZEa5Eu=C(GVC7fzc2c4S~@R7!85Z
z5Eu=C(GVC70eXc%>;F2jUibgK{{KAq*PrmX__CM9^8X3`^~Vnz9yrV|&(Qk6l-cmW
z;g?tb|Nl=fH;vje8UmvsFd71*Aut*OqaiRF0;3@?8UmvsFd71*Aut*Oqai@u5MY#M
zwg%04Gl7i#@c+LL0|SG?hyVXAKzs%U1`#ODSQW&;SRueD&BM+yfsp|`tq#)n;Qjyq
zJWw^Dxo-mo28K27|NobTiY4bH=A|o?r4|)u=I1G-=jW&Aq#Em%6qV*>D`=Ren5P;f
z8W|^>r5PER8m5>eC#G4XStMIn7#W&d8YG(-B$-;6B&BLHOkrSPU}a$B0GZ0jzyoD5
zFff4K4H9Jl$$?w~!b}Vxk};f_fv1&$fq|JZlnurTVQ1j!WME)miDY14U}Rur0=bki
zoRxtIs*)4JVq@T9U<L`XF>*r~4D2kdEF66d3=ABT85kJYIoKE(7zG(sRfSoZRg1(0
z#HCdQ8AFwe#Y@C{7{wVFnDiJ0rG?lWB&sBtRjs(Kxz!~-h3zF77?@cZm?R)Vp27?a
zEFKK?!cB~ljf~O^46N8RF)*;1Ffb`0w6Lo%Fss^eb8|B=aPTvL3}NU1hY$yYImla#
zjKBGK85kMC3p*GYKrDICiVFs2MtLTFRyjsc)G^#+V?ANdta#ybsLMaITvrJe1_n+h
z1?WNyW^P7S9xh>4b~Zg$Mm8f>E^8)M21Z7(8rUKYVOBvdF;-?aJvNR^Hs*2#W==gO
zMg~SkDn)u)e!gBZgMMjok$z5oa$=4?B>CuP<maa9XC~&AFytm?<}qaEl`s^S<}xG}
zr6+@kGKS=g#3F`FhAf6+29QTt88{eV-cpBp59S3UXt06O5hw*of`X5Ug+Yv2kYPTH
zlq`s1U_=)XhUx-^DQKk#GXoDZlPrS?SQwld8Qd8d7<?HR7%~|c81fhx7>XDe7|IwJ
z7^)c<7#bKD7(hv@oq>S?los)M5fTUxGjWj2pj9|9e<7)12IUUux)>y324)6k1_i9*
zAip51gs_<zz$<ki93+yN0sG1rW(Ia7RR|_CIFBOuFcvcdCya?gGc$0Z@L?Qg25uM=
zg=PlldK4irhnayFOd}JJnEQw^rU`O66H<7BN(Y!e76wf95SK79z}6qZ)G9MT%19U=
zM$3W4nHd-ypzD^P5?Txl3_=Wy@N^0)zd%y@IMkcr5NCj-7f^nPk9YSAjd%5kcMEd#
zb&dCM31WzkPbw~sFD^+eg65t0)Re@MM27g(yc7loz2eH;lEfqiz2cH02%Q0Am84db
zFzBUb#HSS{=BCDHq!b}|40_4=xw)x%B@B8gsY#{j@tJvP`7m~3Qc_WB8H|^cnU@M<
z7nc;ln29MM^B|gY@{@Bii%W`Oaz%ORDE#7*qWJu@wBl5R5|F9!Amcy*Mj@64<$neS
zM9PNcD^TTzydDi|4^$Y+V_;B(>Iao4U_n?ugRWNtl}BK4D1n~iK=IAUz)%3w56h<t
zQ2nT>h5;i-Swigx)x%ILz*GWMKd4v&3qT1_J^(Rcv=dZ6NDLV-hw7h!EQm#|9~Lo?
z7JE>@FfcH5fjCGQW-m-A28aHWQ2jkHg-{w@e+E=Py8lC!AR4+M6r6<Vhtb7Q{cr_P
z#sjE+XfQxUK`jV46U?Z`p`QU%ATTg6fbuO^A(VjG3*|EO<Iryg)h`ZH2&K{W&&Q$P
z7pfoDu7hd^m2@yBnBD}{j~;%lQ2o$g0ILNNF#C~dSlR{2!|)2IehsK3Ke)U@q+bcB
rLQqY>3}quz7gQlUYX}7=VfMlV1VPO`7zc^whOS>dgd_%HqU#3$6>2Ls

literal 0
HcmV?d00001

-- 
GitLab


From a98a0a75b415d8e3adb3ff5a2c20e485d9c24ac0 Mon Sep 17 00:00:00 2001
From: Andrey Bokhanko <andreybokhanko@gmail.com>
Date: Thu, 14 Jan 2021 15:30:14 +0000
Subject: [PATCH 1124/2400] os/user: make user.LookupGroupId function work for
 large entries

The existing implementation of user.LookupGroupId function works
incorrectly with very large (>64K symbols) entries in /etc/group file.
This patch fixes this.

Fixes #43636

Change-Id: I453321f1ab15fd4d0002f97fcec7d0789e1e0da5
Reviewed-on: https://go-review.googlesource.com/c/go/+/283601
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/os/user/lookup_unix.go      | 73 +++++++++++++++++++++++++++------
 src/os/user/lookup_unix_test.go | 16 +++++++-
 2 files changed, 75 insertions(+), 14 deletions(-)

diff --git a/src/os/user/lookup_unix.go b/src/os/user/lookup_unix.go
index ed8c2dee9d..97c611fad4 100644
--- a/src/os/user/lookup_unix.go
+++ b/src/os/user/lookup_unix.go
@@ -33,23 +33,72 @@ type lineFunc func(line []byte) (v interface{}, err error)
 // readColonFile parses r as an /etc/group or /etc/passwd style file, running
 // fn for each row. readColonFile returns a value, an error, or (nil, nil) if
 // the end of the file is reached without a match.
-func readColonFile(r io.Reader, fn lineFunc) (v interface{}, err error) {
-	bs := bufio.NewScanner(r)
-	for bs.Scan() {
-		line := bs.Bytes()
+//
+// readCols is the minimum number of colon-separated fields that will be passed
+// to fn; in a long line additional fields may be silently discarded.
+func readColonFile(r io.Reader, fn lineFunc, readCols int) (v interface{}, err error) {
+	rd := bufio.NewReader(r)
+
+	// Read the file line-by-line.
+	for {
+		var isPrefix bool
+		var wholeLine []byte
+
+		// Read the next line. We do so in chunks (as much as reader's
+		// buffer is able to keep), check if we read enough columns
+		// already on each step and store final result in wholeLine.
+		for {
+			var line []byte
+			line, isPrefix, err = rd.ReadLine()
+
+			if err != nil {
+				// We should return (nil, nil) if EOF is reached
+				// without a match.
+				if err == io.EOF {
+					err = nil
+				}
+				return nil, err
+			}
+
+			// Simple common case: line is short enough to fit in a
+			// single reader's buffer.
+			if !isPrefix && len(wholeLine) == 0 {
+				wholeLine = line
+				break
+			}
+
+			wholeLine = append(wholeLine, line...)
+
+			// Check if we read the whole line (or enough columns)
+			// already.
+			if !isPrefix || bytes.Count(wholeLine, []byte{':'}) >= readCols {
+				break
+			}
+		}
+
 		// There's no spec for /etc/passwd or /etc/group, but we try to follow
 		// the same rules as the glibc parser, which allows comments and blank
 		// space at the beginning of a line.
-		line = bytes.TrimSpace(line)
-		if len(line) == 0 || line[0] == '#' {
+		wholeLine = bytes.TrimSpace(wholeLine)
+		if len(wholeLine) == 0 || wholeLine[0] == '#' {
 			continue
 		}
-		v, err = fn(line)
+		v, err = fn(wholeLine)
 		if v != nil || err != nil {
 			return
 		}
+
+		// If necessary, skip the rest of the line
+		for ; isPrefix; _, isPrefix, err = rd.ReadLine() {
+			if err != nil {
+				// We should return (nil, nil) if EOF is reached without a match.
+				if err == io.EOF {
+					err = nil
+				}
+				return nil, err
+			}
+		}
 	}
-	return nil, bs.Err()
 }
 
 func matchGroupIndexValue(value string, idx int) lineFunc {
@@ -80,7 +129,7 @@ func matchGroupIndexValue(value string, idx int) lineFunc {
 }
 
 func findGroupId(id string, r io.Reader) (*Group, error) {
-	if v, err := readColonFile(r, matchGroupIndexValue(id, 2)); err != nil {
+	if v, err := readColonFile(r, matchGroupIndexValue(id, 2), 3); err != nil {
 		return nil, err
 	} else if v != nil {
 		return v.(*Group), nil
@@ -89,7 +138,7 @@ func findGroupId(id string, r io.Reader) (*Group, error) {
 }
 
 func findGroupName(name string, r io.Reader) (*Group, error) {
-	if v, err := readColonFile(r, matchGroupIndexValue(name, 0)); err != nil {
+	if v, err := readColonFile(r, matchGroupIndexValue(name, 0), 3); err != nil {
 		return nil, err
 	} else if v != nil {
 		return v.(*Group), nil
@@ -144,7 +193,7 @@ func findUserId(uid string, r io.Reader) (*User, error) {
 	if e != nil {
 		return nil, errors.New("user: invalid userid " + uid)
 	}
-	if v, err := readColonFile(r, matchUserIndexValue(uid, 2)); err != nil {
+	if v, err := readColonFile(r, matchUserIndexValue(uid, 2), 6); err != nil {
 		return nil, err
 	} else if v != nil {
 		return v.(*User), nil
@@ -153,7 +202,7 @@ func findUserId(uid string, r io.Reader) (*User, error) {
 }
 
 func findUsername(name string, r io.Reader) (*User, error) {
-	if v, err := readColonFile(r, matchUserIndexValue(name, 0)); err != nil {
+	if v, err := readColonFile(r, matchUserIndexValue(name, 0), 6); err != nil {
 		return nil, err
 	} else if v != nil {
 		return v.(*User), nil
diff --git a/src/os/user/lookup_unix_test.go b/src/os/user/lookup_unix_test.go
index c697802171..060cfe186f 100644
--- a/src/os/user/lookup_unix_test.go
+++ b/src/os/user/lookup_unix_test.go
@@ -9,12 +9,13 @@
 package user
 
 import (
+	"fmt"
 	"reflect"
 	"strings"
 	"testing"
 )
 
-const testGroupFile = `# See the opendirectoryd(8) man page for additional 
+var testGroupFile = `# See the opendirectoryd(8) man page for additional 
 # information about Open Directory.
 ##
 nobody:*:-2:
@@ -30,7 +31,7 @@ daemon:*:1:root
 # comment:*:4:found
      # comment:*:4:found
 kmem:*:2:root
-`
+` + largeGroup()
 
 var groupTests = []struct {
 	in   string
@@ -49,9 +50,20 @@ var groupTests = []struct {
 	{testGroupFile, "invalidgid", ""},
 	{testGroupFile, "indented", "7"},
 	{testGroupFile, "# comment", ""},
+	{testGroupFile, "largegroup", "1000"},
 	{"", "emptyfile", ""},
 }
 
+// Generate a proper "largegroup" entry for testGroupFile string
+func largeGroup() (res string) {
+	var b strings.Builder
+	b.WriteString("largegroup:x:1000:user1")
+	for i := 2; i <= 7500; i++ {
+		fmt.Fprintf(&b, ",user%d", i)
+	}
+	return b.String()
+}
+
 func TestFindGroupName(t *testing.T) {
 	for _, tt := range groupTests {
 		got, err := findGroupName(tt.name, strings.NewReader(tt.in))
-- 
GitLab


From 119d76d98e4a367ad9b35dfa436692e2976c99aa Mon Sep 17 00:00:00 2001
From: Meng Zhuo <mzh@golangcn.org>
Date: Tue, 16 Mar 2021 16:31:08 +0800
Subject: [PATCH 1125/2400] math/bits: folded reverse tables by using const
 string
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

linux/mips64le

name            old time/op  new time/op  delta
Reverse         2.31ns ± 1%  2.27ns ± 1%  -1.53%  (p=0.001 n=10+10)
Reverse8        0.65ns ± 1%  0.65ns ± 1%  -1.19%  (p=0.000 n=9+10)
Reverse16       1.15ns ± 2%  1.14ns ± 2%    ~     (p=0.062 n=9+10)
Reverse32       1.96ns ± 1%  1.94ns ± 1%  -1.16%  (p=0.000 n=10+9)
Reverse64       2.29ns ± 1%  2.26ns ± 0%  -0.94%  (p=0.000 n=9+9)
ReverseBytes    0.66ns ± 3%  0.65ns ± 1%  -1.58%  (p=0.006 n=9+10)
ReverseBytes16  0.66ns ± 2%  0.65ns ± 1%  -2.05%  (p=0.000 n=10+9)
ReverseBytes32  0.41ns ± 1%  0.40ns ± 0%  -1.68%  (p=0.000 n=10+10)
ReverseBytes64  0.66ns ± 1%  0.65ns ± 1%  -1.50%  (p=0.000 n=10+9)

cpu=1 benchtime=100ms count=100

name            old time/op  new time/op  delta
Reverse         28.0ns ± 3%  27.7ns ± 3%   -0.80%  (p=0.000 n=100+98)
Reverse8        2.24ns ± 1%  2.24ns ± 1%     ~     (p=0.142 n=98+100)
Reverse16       4.07ns ± 3%  4.05ns ± 3%   -0.66%  (p=0.000 n=99+99)
Reverse32       11.3ns ± 0%  11.3ns ± 0%     ~     (p=0.283 n=94+97)
Reverse64       12.6ns ± 0%  12.6ns ± 0%   +0.60%  (p=0.000 n=100+98)
ReverseBytes    5.25ns ± 1%  5.24ns ± 1%   -0.18%  (p=0.000 n=100+100)
ReverseBytes16  2.00ns ± 0%  2.21ns ± 3%  +10.07%  (p=0.000 n=88+100)
ReverseBytes32  4.08ns ± 2%  4.13ns ± 2%   +1.39%  (p=0.000 n=99+99)
ReverseBytes64  5.48ns ± 1%  5.45ns ± 1%   -0.50%  (p=0.000 n=98+99)

Update #43403

Change-Id: I7e7e00bb17608739d9f6b927c6dfef2580493a0e
Reviewed-on: https://go-review.googlesource.com/c/go/+/280645
Trust: Meng Zhuo <mzh@golangcn.org>
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/math/bits/bits_tables.go | 140 +++++++++++++++++------------------
 src/math/bits/make_tables.go |  13 ++--
 2 files changed, 74 insertions(+), 79 deletions(-)

diff --git a/src/math/bits/bits_tables.go b/src/math/bits/bits_tables.go
index f1e15a0d0e..f869b8d5c3 100644
--- a/src/math/bits/bits_tables.go
+++ b/src/math/bits/bits_tables.go
@@ -6,78 +6,74 @@
 
 package bits
 
-var ntz8tab = [256]uint8{
-	0x08, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00,
-	0x04, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00,
-	0x05, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00,
-	0x04, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00,
-	0x06, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00,
-	0x04, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00,
-	0x05, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00,
-	0x04, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00,
-	0x07, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00,
-	0x04, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00,
-	0x05, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00,
-	0x04, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00,
-	0x06, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00,
-	0x04, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00,
-	0x05, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00,
-	0x04, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00,
-}
+const ntz8tab = "" +
+	"\x08\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00" +
+	"\x04\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00" +
+	"\x05\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00" +
+	"\x04\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00" +
+	"\x06\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00" +
+	"\x04\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00" +
+	"\x05\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00" +
+	"\x04\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00" +
+	"\x07\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00" +
+	"\x04\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00" +
+	"\x05\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00" +
+	"\x04\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00" +
+	"\x06\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00" +
+	"\x04\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00" +
+	"\x05\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00" +
+	"\x04\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00"
 
-var pop8tab = [256]uint8{
-	0x00, 0x01, 0x01, 0x02, 0x01, 0x02, 0x02, 0x03, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x04,
-	0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x04, 0x02, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05,
-	0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x04, 0x02, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05,
-	0x02, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05, 0x03, 0x04, 0x04, 0x05, 0x04, 0x05, 0x05, 0x06,
-	0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x04, 0x02, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05,
-	0x02, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05, 0x03, 0x04, 0x04, 0x05, 0x04, 0x05, 0x05, 0x06,
-	0x02, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05, 0x03, 0x04, 0x04, 0x05, 0x04, 0x05, 0x05, 0x06,
-	0x03, 0x04, 0x04, 0x05, 0x04, 0x05, 0x05, 0x06, 0x04, 0x05, 0x05, 0x06, 0x05, 0x06, 0x06, 0x07,
-	0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x04, 0x02, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05,
-	0x02, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05, 0x03, 0x04, 0x04, 0x05, 0x04, 0x05, 0x05, 0x06,
-	0x02, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05, 0x03, 0x04, 0x04, 0x05, 0x04, 0x05, 0x05, 0x06,
-	0x03, 0x04, 0x04, 0x05, 0x04, 0x05, 0x05, 0x06, 0x04, 0x05, 0x05, 0x06, 0x05, 0x06, 0x06, 0x07,
-	0x02, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05, 0x03, 0x04, 0x04, 0x05, 0x04, 0x05, 0x05, 0x06,
-	0x03, 0x04, 0x04, 0x05, 0x04, 0x05, 0x05, 0x06, 0x04, 0x05, 0x05, 0x06, 0x05, 0x06, 0x06, 0x07,
-	0x03, 0x04, 0x04, 0x05, 0x04, 0x05, 0x05, 0x06, 0x04, 0x05, 0x05, 0x06, 0x05, 0x06, 0x06, 0x07,
-	0x04, 0x05, 0x05, 0x06, 0x05, 0x06, 0x06, 0x07, 0x05, 0x06, 0x06, 0x07, 0x06, 0x07, 0x07, 0x08,
-}
+const pop8tab = "" +
+	"\x00\x01\x01\x02\x01\x02\x02\x03\x01\x02\x02\x03\x02\x03\x03\x04" +
+	"\x01\x02\x02\x03\x02\x03\x03\x04\x02\x03\x03\x04\x03\x04\x04\x05" +
+	"\x01\x02\x02\x03\x02\x03\x03\x04\x02\x03\x03\x04\x03\x04\x04\x05" +
+	"\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06" +
+	"\x01\x02\x02\x03\x02\x03\x03\x04\x02\x03\x03\x04\x03\x04\x04\x05" +
+	"\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06" +
+	"\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06" +
+	"\x03\x04\x04\x05\x04\x05\x05\x06\x04\x05\x05\x06\x05\x06\x06\x07" +
+	"\x01\x02\x02\x03\x02\x03\x03\x04\x02\x03\x03\x04\x03\x04\x04\x05" +
+	"\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06" +
+	"\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06" +
+	"\x03\x04\x04\x05\x04\x05\x05\x06\x04\x05\x05\x06\x05\x06\x06\x07" +
+	"\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06" +
+	"\x03\x04\x04\x05\x04\x05\x05\x06\x04\x05\x05\x06\x05\x06\x06\x07" +
+	"\x03\x04\x04\x05\x04\x05\x05\x06\x04\x05\x05\x06\x05\x06\x06\x07" +
+	"\x04\x05\x05\x06\x05\x06\x06\x07\x05\x06\x06\x07\x06\x07\x07\x08"
 
-var rev8tab = [256]uint8{
-	0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
-	0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8, 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
-	0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
-	0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
-	0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
-	0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea, 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
-	0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
-	0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
-	0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1, 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
-	0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
-	0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5, 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
-	0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed, 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
-	0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
-	0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb, 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
-	0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7, 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
-	0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
-}
+const rev8tab = "" +
+	"\x00\x80\x40\xc0\x20\xa0\x60\xe0\x10\x90\x50\xd0\x30\xb0\x70\xf0" +
+	"\x08\x88\x48\xc8\x28\xa8\x68\xe8\x18\x98\x58\xd8\x38\xb8\x78\xf8" +
+	"\x04\x84\x44\xc4\x24\xa4\x64\xe4\x14\x94\x54\xd4\x34\xb4\x74\xf4" +
+	"\x0c\x8c\x4c\xcc\x2c\xac\x6c\xec\x1c\x9c\x5c\xdc\x3c\xbc\x7c\xfc" +
+	"\x02\x82\x42\xc2\x22\xa2\x62\xe2\x12\x92\x52\xd2\x32\xb2\x72\xf2" +
+	"\x0a\x8a\x4a\xca\x2a\xaa\x6a\xea\x1a\x9a\x5a\xda\x3a\xba\x7a\xfa" +
+	"\x06\x86\x46\xc6\x26\xa6\x66\xe6\x16\x96\x56\xd6\x36\xb6\x76\xf6" +
+	"\x0e\x8e\x4e\xce\x2e\xae\x6e\xee\x1e\x9e\x5e\xde\x3e\xbe\x7e\xfe" +
+	"\x01\x81\x41\xc1\x21\xa1\x61\xe1\x11\x91\x51\xd1\x31\xb1\x71\xf1" +
+	"\x09\x89\x49\xc9\x29\xa9\x69\xe9\x19\x99\x59\xd9\x39\xb9\x79\xf9" +
+	"\x05\x85\x45\xc5\x25\xa5\x65\xe5\x15\x95\x55\xd5\x35\xb5\x75\xf5" +
+	"\x0d\x8d\x4d\xcd\x2d\xad\x6d\xed\x1d\x9d\x5d\xdd\x3d\xbd\x7d\xfd" +
+	"\x03\x83\x43\xc3\x23\xa3\x63\xe3\x13\x93\x53\xd3\x33\xb3\x73\xf3" +
+	"\x0b\x8b\x4b\xcb\x2b\xab\x6b\xeb\x1b\x9b\x5b\xdb\x3b\xbb\x7b\xfb" +
+	"\x07\x87\x47\xc7\x27\xa7\x67\xe7\x17\x97\x57\xd7\x37\xb7\x77\xf7" +
+	"\x0f\x8f\x4f\xcf\x2f\xaf\x6f\xef\x1f\x9f\x5f\xdf\x3f\xbf\x7f\xff"
 
-var len8tab = [256]uint8{
-	0x00, 0x01, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-	0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-	0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-	0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-	0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-	0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-	0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-	0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-	0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-	0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-	0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-	0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-	0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-}
+const len8tab = "" +
+	"\x00\x01\x02\x02\x03\x03\x03\x03\x04\x04\x04\x04\x04\x04\x04\x04" +
+	"\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05" +
+	"\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06" +
+	"\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06" +
+	"\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07" +
+	"\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07" +
+	"\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07" +
+	"\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07" +
+	"\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08" +
+	"\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08" +
+	"\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08" +
+	"\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08" +
+	"\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08" +
+	"\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08" +
+	"\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08" +
+	"\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08"
diff --git a/src/math/bits/make_tables.go b/src/math/bits/make_tables.go
index 5ab0b5fc57..867025ea61 100644
--- a/src/math/bits/make_tables.go
+++ b/src/math/bits/make_tables.go
@@ -48,16 +48,15 @@ func main() {
 }
 
 func gen(w io.Writer, name string, f func(uint8) uint8) {
-	fmt.Fprintf(w, "var %s = [256]uint8{", name)
+	// Use a const string to allow the compiler to constant-evaluate lookups at constant index.
+	fmt.Fprintf(w, "const %s = \"\"+\n\"", name)
 	for i := 0; i < 256; i++ {
-		if i%16 == 0 {
-			fmt.Fprint(w, "\n\t")
-		} else {
-			fmt.Fprint(w, " ")
+		fmt.Fprintf(w, "\\x%02x", f(uint8(i)))
+		if i%16 == 15 && i != 255 {
+			fmt.Fprint(w, "\"+\n\"")
 		}
-		fmt.Fprintf(w, "%#02x,", f(uint8(i)))
 	}
-	fmt.Fprint(w, "\n}\n\n")
+	fmt.Fprint(w, "\"\n\n")
 }
 
 func ntz8(x uint8) (n uint8) {
-- 
GitLab


From 72b501cb0326f62a20621636942e5a95fc3c1466 Mon Sep 17 00:00:00 2001
From: Agniva De Sarker <agnivade@yahoo.co.in>
Date: Fri, 27 Nov 2020 11:25:00 +0530
Subject: [PATCH 1126/2400] compress/lzw: add Reset method to Reader and Writer
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

We add a Reset method which clears any internal state of an encoder
or a decoder to let it be reused again as a new Writer or Reader respectively.

We also export the encoder and decoder structs, renaming them
to be Reader and Writer, and we guarantee that the underlying types
from the constructors will always be Reader and Writer respectively.

Benchmark results by reusing the encoder:
on cpu: Intel(R) Core(TM) i5-8265U CPU @ 1.60GHz

name                 time/op
Decoder/1e4-8          93.6µs ± 1%
Decoder/1e-Reuse4-8    87.7µs ± 1%
Decoder/1e5-8           877µs ± 1%
Decoder/1e-Reuse5-8     860µs ± 3%
Decoder/1e6-8          8.79ms ± 1%
Decoder/1e-Reuse6-8    8.82ms ± 4%
Encoder/1e4-8           168µs ± 2%
Encoder/1e-Reuse4-8     160µs ± 1%
Encoder/1e5-8          1.64ms ± 1%
Encoder/1e-Reuse5-8    1.61ms ± 2%
Encoder/1e6-8          16.2ms ± 6%
Encoder/1e-Reuse6-8    15.8ms ± 2%

name                 speed
Decoder/1e4-8         107MB/s ± 1%
Decoder/1e-Reuse4-8   114MB/s ± 1%
Decoder/1e5-8         114MB/s ± 1%
Decoder/1e-Reuse5-8   116MB/s ± 3%
Decoder/1e6-8         114MB/s ± 1%
Decoder/1e-Reuse6-8   113MB/s ± 5%
Encoder/1e4-8        59.7MB/s ± 2%
Encoder/1e-Reuse4-8  62.4MB/s ± 1%
Encoder/1e5-8        61.1MB/s ± 1%
Encoder/1e-Reuse5-8  62.0MB/s ± 2%
Encoder/1e6-8        61.7MB/s ± 5%
Encoder/1e-Reuse6-8  63.4MB/s ± 2%

name                 alloc/op
Decoder/1e4-8          21.8kB ± 0%
Decoder/1e-Reuse4-8     50.0B ± 0%
Decoder/1e5-8          21.8kB ± 0%
Decoder/1e-Reuse5-8     70.4B ± 2%
Decoder/1e6-8          21.9kB ± 0%
Decoder/1e-Reuse6-8      271B ± 3%
Encoder/1e4-8          77.9kB ± 0%
Encoder/1e-Reuse4-8    4.17kB ± 0%
Encoder/1e5-8          77.9kB ± 0%
Encoder/1e-Reuse5-8    4.27kB ± 0%
Encoder/1e6-8          77.9kB ± 0%
Encoder/1e-Reuse6-8    5.22kB ± 0%

name                 allocs/op
Decoder/1e4-8            2.00 ± 0%
Decoder/1e-Reuse4-8      1.00 ± 0%
Decoder/1e5-8            2.00 ± 0%
Decoder/1e-Reuse5-8      1.00 ± 0%
Decoder/1e6-8            2.00 ± 0%
Decoder/1e-Reuse6-8      1.00 ± 0%
Encoder/1e4-8            3.00 ± 0%
Encoder/1e-Reuse4-8      2.00 ± 0%
Encoder/1e5-8            3.00 ± 0%
Encoder/1e-Reuse5-8      2.00 ± 0%
Encoder/1e6-8            3.00 ± 0%
Encoder/1e-Reuse6-8      2.00 ± 0%

Fixes #26535

Change-Id: Icde613fea6234a5bdce95f1e49910f5687e30b22
Reviewed-on: https://go-review.googlesource.com/c/go/+/273667
Trust: Agniva De Sarker <agniva.quicksilver@gmail.com>
Trust: Joe Tsai <thebrokentoaster@gmail.com>
Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
---
 src/compress/lzw/reader.go      | 207 ++++++++++++++++++--------------
 src/compress/lzw/reader_test.go |  88 ++++++++++++--
 src/compress/lzw/writer.go      | 206 ++++++++++++++++---------------
 src/compress/lzw/writer_test.go |  54 +++++++++
 4 files changed, 349 insertions(+), 206 deletions(-)

diff --git a/src/compress/lzw/reader.go b/src/compress/lzw/reader.go
index f08021190c..952870a56a 100644
--- a/src/compress/lzw/reader.go
+++ b/src/compress/lzw/reader.go
@@ -42,15 +42,15 @@ const (
 	flushBuffer        = 1 << maxWidth
 )
 
-// decoder is the state from which the readXxx method converts a byte
-// stream into a code stream.
-type decoder struct {
+// Reader is an io.Reader which can be used to read compressed data in the
+// LZW format.
+type Reader struct {
 	r        io.ByteReader
 	bits     uint32
 	nBits    uint
 	width    uint
-	read     func(*decoder) (uint16, error) // readLSB or readMSB
-	litWidth int                            // width in bits of literal codes
+	read     func(*Reader) (uint16, error) // readLSB or readMSB
+	litWidth int                           // width in bits of literal codes
 	err      error
 
 	// The first 1<<litWidth codes are literal codes.
@@ -87,148 +87,158 @@ type decoder struct {
 }
 
 // readLSB returns the next code for "Least Significant Bits first" data.
-func (d *decoder) readLSB() (uint16, error) {
-	for d.nBits < d.width {
-		x, err := d.r.ReadByte()
+func (r *Reader) readLSB() (uint16, error) {
+	for r.nBits < r.width {
+		x, err := r.r.ReadByte()
 		if err != nil {
 			return 0, err
 		}
-		d.bits |= uint32(x) << d.nBits
-		d.nBits += 8
+		r.bits |= uint32(x) << r.nBits
+		r.nBits += 8
 	}
-	code := uint16(d.bits & (1<<d.width - 1))
-	d.bits >>= d.width
-	d.nBits -= d.width
+	code := uint16(r.bits & (1<<r.width - 1))
+	r.bits >>= r.width
+	r.nBits -= r.width
 	return code, nil
 }
 
 // readMSB returns the next code for "Most Significant Bits first" data.
-func (d *decoder) readMSB() (uint16, error) {
-	for d.nBits < d.width {
-		x, err := d.r.ReadByte()
+func (r *Reader) readMSB() (uint16, error) {
+	for r.nBits < r.width {
+		x, err := r.r.ReadByte()
 		if err != nil {
 			return 0, err
 		}
-		d.bits |= uint32(x) << (24 - d.nBits)
-		d.nBits += 8
+		r.bits |= uint32(x) << (24 - r.nBits)
+		r.nBits += 8
 	}
-	code := uint16(d.bits >> (32 - d.width))
-	d.bits <<= d.width
-	d.nBits -= d.width
+	code := uint16(r.bits >> (32 - r.width))
+	r.bits <<= r.width
+	r.nBits -= r.width
 	return code, nil
 }
 
-func (d *decoder) Read(b []byte) (int, error) {
+// Read implements io.Reader, reading uncompressed bytes from its underlying Reader.
+func (r *Reader) Read(b []byte) (int, error) {
 	for {
-		if len(d.toRead) > 0 {
-			n := copy(b, d.toRead)
-			d.toRead = d.toRead[n:]
+		if len(r.toRead) > 0 {
+			n := copy(b, r.toRead)
+			r.toRead = r.toRead[n:]
 			return n, nil
 		}
-		if d.err != nil {
-			return 0, d.err
+		if r.err != nil {
+			return 0, r.err
 		}
-		d.decode()
+		r.decode()
 	}
 }
 
 // decode decompresses bytes from r and leaves them in d.toRead.
 // read specifies how to decode bytes into codes.
 // litWidth is the width in bits of literal codes.
-func (d *decoder) decode() {
+func (r *Reader) decode() {
 	// Loop over the code stream, converting codes into decompressed bytes.
 loop:
 	for {
-		code, err := d.read(d)
+		code, err := r.read(r)
 		if err != nil {
 			if err == io.EOF {
 				err = io.ErrUnexpectedEOF
 			}
-			d.err = err
+			r.err = err
 			break
 		}
 		switch {
-		case code < d.clear:
+		case code < r.clear:
 			// We have a literal code.
-			d.output[d.o] = uint8(code)
-			d.o++
-			if d.last != decoderInvalidCode {
+			r.output[r.o] = uint8(code)
+			r.o++
+			if r.last != decoderInvalidCode {
 				// Save what the hi code expands to.
-				d.suffix[d.hi] = uint8(code)
-				d.prefix[d.hi] = d.last
+				r.suffix[r.hi] = uint8(code)
+				r.prefix[r.hi] = r.last
 			}
-		case code == d.clear:
-			d.width = 1 + uint(d.litWidth)
-			d.hi = d.eof
-			d.overflow = 1 << d.width
-			d.last = decoderInvalidCode
+		case code == r.clear:
+			r.width = 1 + uint(r.litWidth)
+			r.hi = r.eof
+			r.overflow = 1 << r.width
+			r.last = decoderInvalidCode
 			continue
-		case code == d.eof:
-			d.err = io.EOF
+		case code == r.eof:
+			r.err = io.EOF
 			break loop
-		case code <= d.hi:
-			c, i := code, len(d.output)-1
-			if code == d.hi && d.last != decoderInvalidCode {
+		case code <= r.hi:
+			c, i := code, len(r.output)-1
+			if code == r.hi && r.last != decoderInvalidCode {
 				// code == hi is a special case which expands to the last expansion
 				// followed by the head of the last expansion. To find the head, we walk
 				// the prefix chain until we find a literal code.
-				c = d.last
-				for c >= d.clear {
-					c = d.prefix[c]
+				c = r.last
+				for c >= r.clear {
+					c = r.prefix[c]
 				}
-				d.output[i] = uint8(c)
+				r.output[i] = uint8(c)
 				i--
-				c = d.last
+				c = r.last
 			}
 			// Copy the suffix chain into output and then write that to w.
-			for c >= d.clear {
-				d.output[i] = d.suffix[c]
+			for c >= r.clear {
+				r.output[i] = r.suffix[c]
 				i--
-				c = d.prefix[c]
+				c = r.prefix[c]
 			}
-			d.output[i] = uint8(c)
-			d.o += copy(d.output[d.o:], d.output[i:])
-			if d.last != decoderInvalidCode {
+			r.output[i] = uint8(c)
+			r.o += copy(r.output[r.o:], r.output[i:])
+			if r.last != decoderInvalidCode {
 				// Save what the hi code expands to.
-				d.suffix[d.hi] = uint8(c)
-				d.prefix[d.hi] = d.last
+				r.suffix[r.hi] = uint8(c)
+				r.prefix[r.hi] = r.last
 			}
 		default:
-			d.err = errors.New("lzw: invalid code")
+			r.err = errors.New("lzw: invalid code")
 			break loop
 		}
-		d.last, d.hi = code, d.hi+1
-		if d.hi >= d.overflow {
-			if d.hi > d.overflow {
+		r.last, r.hi = code, r.hi+1
+		if r.hi >= r.overflow {
+			if r.hi > r.overflow {
 				panic("unreachable")
 			}
-			if d.width == maxWidth {
-				d.last = decoderInvalidCode
+			if r.width == maxWidth {
+				r.last = decoderInvalidCode
 				// Undo the d.hi++ a few lines above, so that (1) we maintain
 				// the invariant that d.hi < d.overflow, and (2) d.hi does not
 				// eventually overflow a uint16.
-				d.hi--
+				r.hi--
 			} else {
-				d.width++
-				d.overflow = 1 << d.width
+				r.width++
+				r.overflow = 1 << r.width
 			}
 		}
-		if d.o >= flushBuffer {
+		if r.o >= flushBuffer {
 			break
 		}
 	}
 	// Flush pending output.
-	d.toRead = d.output[:d.o]
-	d.o = 0
+	r.toRead = r.output[:r.o]
+	r.o = 0
 }
 
 var errClosed = errors.New("lzw: reader/writer is closed")
 
-func (d *decoder) Close() error {
-	d.err = errClosed // in case any Reads come along
+// Close closes the Reader and returns an error for any future read operation.
+// It does not close the underlying io.Reader.
+func (r *Reader) Close() error {
+	r.err = errClosed // in case any Reads come along
 	return nil
 }
 
+// Reset clears the Reader's state and allows it to be reused again
+// as a new Reader.
+func (r *Reader) Reset(src io.Reader, order Order, litWidth int) {
+	*r = Reader{}
+	r.init(src, order, litWidth)
+}
+
 // NewReader creates a new io.ReadCloser.
 // Reads from the returned io.ReadCloser read and decompress data from r.
 // If r does not also implement io.ByteReader,
@@ -238,32 +248,43 @@ func (d *decoder) Close() error {
 // The number of bits to use for literal codes, litWidth, must be in the
 // range [2,8] and is typically 8. It must equal the litWidth
 // used during compression.
+//
+// It is guaranteed that the underlying type of the returned io.ReadCloser
+// is a *Reader.
 func NewReader(r io.Reader, order Order, litWidth int) io.ReadCloser {
-	d := new(decoder)
+	return newReader(r, order, litWidth)
+}
+
+func newReader(src io.Reader, order Order, litWidth int) *Reader {
+	r := new(Reader)
+	r.init(src, order, litWidth)
+	return r
+}
+
+func (r *Reader) init(src io.Reader, order Order, litWidth int) {
 	switch order {
 	case LSB:
-		d.read = (*decoder).readLSB
+		r.read = (*Reader).readLSB
 	case MSB:
-		d.read = (*decoder).readMSB
+		r.read = (*Reader).readMSB
 	default:
-		d.err = errors.New("lzw: unknown order")
-		return d
+		r.err = errors.New("lzw: unknown order")
+		return
 	}
 	if litWidth < 2 || 8 < litWidth {
-		d.err = fmt.Errorf("lzw: litWidth %d out of range", litWidth)
-		return d
+		r.err = fmt.Errorf("lzw: litWidth %d out of range", litWidth)
+		return
 	}
-	if br, ok := r.(io.ByteReader); ok {
-		d.r = br
-	} else {
-		d.r = bufio.NewReader(r)
-	}
-	d.litWidth = litWidth
-	d.width = 1 + uint(litWidth)
-	d.clear = uint16(1) << uint(litWidth)
-	d.eof, d.hi = d.clear+1, d.clear+1
-	d.overflow = uint16(1) << d.width
-	d.last = decoderInvalidCode
 
-	return d
+	br, ok := src.(io.ByteReader)
+	if !ok && src != nil {
+		br = bufio.NewReader(src)
+	}
+	r.r = br
+	r.litWidth = litWidth
+	r.width = 1 + uint(litWidth)
+	r.clear = uint16(1) << uint(litWidth)
+	r.eof, r.hi = r.clear+1, r.clear+1
+	r.overflow = uint16(1) << r.width
+	r.last = decoderInvalidCode
 }
diff --git a/src/compress/lzw/reader_test.go b/src/compress/lzw/reader_test.go
index d1eb76d042..9a2a477302 100644
--- a/src/compress/lzw/reader_test.go
+++ b/src/compress/lzw/reader_test.go
@@ -120,6 +120,53 @@ func TestReader(t *testing.T) {
 	}
 }
 
+func TestReaderReset(t *testing.T) {
+	var b bytes.Buffer
+	for _, tt := range lzwTests {
+		d := strings.Split(tt.desc, ";")
+		var order Order
+		switch d[1] {
+		case "LSB":
+			order = LSB
+		case "MSB":
+			order = MSB
+		default:
+			t.Errorf("%s: bad order %q", tt.desc, d[1])
+		}
+		litWidth, _ := strconv.Atoi(d[2])
+		rc := NewReader(strings.NewReader(tt.compressed), order, litWidth)
+		defer rc.Close()
+		b.Reset()
+		n, err := io.Copy(&b, rc)
+		b1 := b.Bytes()
+		if err != nil {
+			if err != tt.err {
+				t.Errorf("%s: io.Copy: %v want %v", tt.desc, err, tt.err)
+			}
+			if err == io.ErrUnexpectedEOF {
+				// Even if the input is truncated, we should still return the
+				// partial decoded result.
+				if n == 0 || !strings.HasPrefix(tt.raw, b.String()) {
+					t.Errorf("got %d bytes (%q), want a non-empty prefix of %q", n, b.String(), tt.raw)
+				}
+			}
+			continue
+		}
+
+		b.Reset()
+		rc.(*Reader).Reset(strings.NewReader(tt.compressed), order, litWidth)
+		n, err = io.Copy(&b, rc)
+		b2 := b.Bytes()
+		if err != nil {
+			t.Errorf("%s: io.Copy: %v want %v", tt.desc, err, nil)
+			continue
+		}
+		if !bytes.Equal(b1, b2) {
+			t.Errorf("bytes read were not the same")
+		}
+	}
+}
+
 type devZero struct{}
 
 func (devZero) Read(p []byte) (int, error) {
@@ -131,7 +178,7 @@ func (devZero) Read(p []byte) (int, error) {
 
 func TestHiCodeDoesNotOverflow(t *testing.T) {
 	r := NewReader(devZero{}, LSB, 8)
-	d := r.(*decoder)
+	d := r.(*Reader)
 	buf := make([]byte, 1024)
 	oldHi := uint16(0)
 	for i := 0; i < 100; i++ {
@@ -226,28 +273,43 @@ func BenchmarkDecoder(b *testing.B) {
 		b.Fatalf("test file has no data")
 	}
 
+	getInputBuf := func(buf []byte, n int) []byte {
+		compressed := new(bytes.Buffer)
+		w := NewWriter(compressed, LSB, 8)
+		for i := 0; i < n; i += len(buf) {
+			if len(buf) > n-i {
+				buf = buf[:n-i]
+			}
+			w.Write(buf)
+		}
+		w.Close()
+		return compressed.Bytes()
+	}
+
 	for e := 4; e <= 6; e++ {
 		n := int(math.Pow10(e))
 		b.Run(fmt.Sprint("1e", e), func(b *testing.B) {
 			b.StopTimer()
 			b.SetBytes(int64(n))
-			buf0 := buf
-			compressed := new(bytes.Buffer)
-			w := NewWriter(compressed, LSB, 8)
-			for i := 0; i < n; i += len(buf0) {
-				if len(buf0) > n-i {
-					buf0 = buf0[:n-i]
-				}
-				w.Write(buf0)
-			}
-			w.Close()
-			buf1 := compressed.Bytes()
-			buf0, compressed, w = nil, nil, nil
+			buf1 := getInputBuf(buf, n)
 			runtime.GC()
 			b.StartTimer()
 			for i := 0; i < b.N; i++ {
 				io.Copy(io.Discard, NewReader(bytes.NewReader(buf1), LSB, 8))
 			}
 		})
+		b.Run(fmt.Sprint("1e-Reuse", e), func(b *testing.B) {
+			b.StopTimer()
+			b.SetBytes(int64(n))
+			buf1 := getInputBuf(buf, n)
+			runtime.GC()
+			b.StartTimer()
+			r := NewReader(bytes.NewReader(buf1), LSB, 8)
+			for i := 0; i < b.N; i++ {
+				io.Copy(io.Discard, r)
+				r.Close()
+				r.(*Reader).Reset(bytes.NewReader(buf1), LSB, 8)
+			}
+		})
 	}
 }
diff --git a/src/compress/lzw/writer.go b/src/compress/lzw/writer.go
index 6ddb335f31..552bdc2ce1 100644
--- a/src/compress/lzw/writer.go
+++ b/src/compress/lzw/writer.go
@@ -17,19 +17,6 @@ type writer interface {
 	Flush() error
 }
 
-// An errWriteCloser is an io.WriteCloser that always returns a given error.
-type errWriteCloser struct {
-	err error
-}
-
-func (e *errWriteCloser) Write([]byte) (int, error) {
-	return 0, e.err
-}
-
-func (e *errWriteCloser) Close() error {
-	return e.err
-}
-
 const (
 	// A code is a 12 bit value, stored as a uint32 when encoding to avoid
 	// type conversions when shifting bits.
@@ -44,14 +31,15 @@ const (
 	invalidEntry = 0
 )
 
-// encoder is LZW compressor.
-type encoder struct {
+// Writer is an LZW compressor. It writes the compressed form of the data
+// to an underlying writer (see NewWriter).
+type Writer struct {
 	// w is the writer that compressed bytes are written to.
 	w writer
 	// order, write, bits, nBits and width are the state for
 	// converting a code stream into a byte stream.
 	order Order
-	write func(*encoder, uint32) error
+	write func(*Writer, uint32) error
 	bits  uint32
 	nBits uint
 	width uint
@@ -63,7 +51,7 @@ type encoder struct {
 	// savedCode is the accumulated code at the end of the most recent Write
 	// call. It is equal to invalidCode if there was no such call.
 	savedCode uint32
-	// err is the first error encountered during writing. Closing the encoder
+	// err is the first error encountered during writing. Closing the writer
 	// will make any future Write calls return errClosed
 	err error
 	// table is the hash table from 20-bit keys to 12-bit values. Each table
@@ -74,80 +62,80 @@ type encoder struct {
 }
 
 // writeLSB writes the code c for "Least Significant Bits first" data.
-func (e *encoder) writeLSB(c uint32) error {
-	e.bits |= c << e.nBits
-	e.nBits += e.width
-	for e.nBits >= 8 {
-		if err := e.w.WriteByte(uint8(e.bits)); err != nil {
+func (w *Writer) writeLSB(c uint32) error {
+	w.bits |= c << w.nBits
+	w.nBits += w.width
+	for w.nBits >= 8 {
+		if err := w.w.WriteByte(uint8(w.bits)); err != nil {
 			return err
 		}
-		e.bits >>= 8
-		e.nBits -= 8
+		w.bits >>= 8
+		w.nBits -= 8
 	}
 	return nil
 }
 
 // writeMSB writes the code c for "Most Significant Bits first" data.
-func (e *encoder) writeMSB(c uint32) error {
-	e.bits |= c << (32 - e.width - e.nBits)
-	e.nBits += e.width
-	for e.nBits >= 8 {
-		if err := e.w.WriteByte(uint8(e.bits >> 24)); err != nil {
+func (w *Writer) writeMSB(c uint32) error {
+	w.bits |= c << (32 - w.width - w.nBits)
+	w.nBits += w.width
+	for w.nBits >= 8 {
+		if err := w.w.WriteByte(uint8(w.bits >> 24)); err != nil {
 			return err
 		}
-		e.bits <<= 8
-		e.nBits -= 8
+		w.bits <<= 8
+		w.nBits -= 8
 	}
 	return nil
 }
 
-// errOutOfCodes is an internal error that means that the encoder has run out
+// errOutOfCodes is an internal error that means that the writer has run out
 // of unused codes and a clear code needs to be sent next.
 var errOutOfCodes = errors.New("lzw: out of codes")
 
 // incHi increments e.hi and checks for both overflow and running out of
 // unused codes. In the latter case, incHi sends a clear code, resets the
-// encoder state and returns errOutOfCodes.
-func (e *encoder) incHi() error {
-	e.hi++
-	if e.hi == e.overflow {
-		e.width++
-		e.overflow <<= 1
+// writer state and returns errOutOfCodes.
+func (w *Writer) incHi() error {
+	w.hi++
+	if w.hi == w.overflow {
+		w.width++
+		w.overflow <<= 1
 	}
-	if e.hi == maxCode {
-		clear := uint32(1) << e.litWidth
-		if err := e.write(e, clear); err != nil {
+	if w.hi == maxCode {
+		clear := uint32(1) << w.litWidth
+		if err := w.write(w, clear); err != nil {
 			return err
 		}
-		e.width = e.litWidth + 1
-		e.hi = clear + 1
-		e.overflow = clear << 1
-		for i := range e.table {
-			e.table[i] = invalidEntry
+		w.width = w.litWidth + 1
+		w.hi = clear + 1
+		w.overflow = clear << 1
+		for i := range w.table {
+			w.table[i] = invalidEntry
 		}
 		return errOutOfCodes
 	}
 	return nil
 }
 
-// Write writes a compressed representation of p to e's underlying writer.
-func (e *encoder) Write(p []byte) (n int, err error) {
-	if e.err != nil {
-		return 0, e.err
+// Write writes a compressed representation of p to w's underlying writer.
+func (w *Writer) Write(p []byte) (n int, err error) {
+	if w.err != nil {
+		return 0, w.err
 	}
 	if len(p) == 0 {
 		return 0, nil
 	}
-	if maxLit := uint8(1<<e.litWidth - 1); maxLit != 0xff {
+	if maxLit := uint8(1<<w.litWidth - 1); maxLit != 0xff {
 		for _, x := range p {
 			if x > maxLit {
-				e.err = errors.New("lzw: input byte too large for the litWidth")
-				return 0, e.err
+				w.err = errors.New("lzw: input byte too large for the litWidth")
+				return 0, w.err
 			}
 		}
 	}
 	n = len(p)
-	code := e.savedCode
+	code := w.savedCode
 	if code == invalidCode {
 		// The first code sent is always a literal code.
 		code, p = uint32(p[0]), p[1:]
@@ -159,77 +147,84 @@ loop:
 		// If there is a hash table hit for this key then we continue the loop
 		// and do not emit a code yet.
 		hash := (key>>12 ^ key) & tableMask
-		for h, t := hash, e.table[hash]; t != invalidEntry; {
+		for h, t := hash, w.table[hash]; t != invalidEntry; {
 			if key == t>>12 {
 				code = t & maxCode
 				continue loop
 			}
 			h = (h + 1) & tableMask
-			t = e.table[h]
+			t = w.table[h]
 		}
 		// Otherwise, write the current code, and literal becomes the start of
 		// the next emitted code.
-		if e.err = e.write(e, code); e.err != nil {
-			return 0, e.err
+		if w.err = w.write(w, code); w.err != nil {
+			return 0, w.err
 		}
 		code = literal
 		// Increment e.hi, the next implied code. If we run out of codes, reset
-		// the encoder state (including clearing the hash table) and continue.
-		if err1 := e.incHi(); err1 != nil {
+		// the writer state (including clearing the hash table) and continue.
+		if err1 := w.incHi(); err1 != nil {
 			if err1 == errOutOfCodes {
 				continue
 			}
-			e.err = err1
-			return 0, e.err
+			w.err = err1
+			return 0, w.err
 		}
 		// Otherwise, insert key -> e.hi into the map that e.table represents.
 		for {
-			if e.table[hash] == invalidEntry {
-				e.table[hash] = (key << 12) | e.hi
+			if w.table[hash] == invalidEntry {
+				w.table[hash] = (key << 12) | w.hi
 				break
 			}
 			hash = (hash + 1) & tableMask
 		}
 	}
-	e.savedCode = code
+	w.savedCode = code
 	return n, nil
 }
 
-// Close closes the encoder, flushing any pending output. It does not close or
-// flush e's underlying writer.
-func (e *encoder) Close() error {
-	if e.err != nil {
-		if e.err == errClosed {
+// Close closes the Writer, flushing any pending output. It does not close
+// w's underlying writer.
+func (w *Writer) Close() error {
+	if w.err != nil {
+		if w.err == errClosed {
 			return nil
 		}
-		return e.err
+		return w.err
 	}
 	// Make any future calls to Write return errClosed.
-	e.err = errClosed
+	w.err = errClosed
 	// Write the savedCode if valid.
-	if e.savedCode != invalidCode {
-		if err := e.write(e, e.savedCode); err != nil {
+	if w.savedCode != invalidCode {
+		if err := w.write(w, w.savedCode); err != nil {
 			return err
 		}
-		if err := e.incHi(); err != nil && err != errOutOfCodes {
+		if err := w.incHi(); err != nil && err != errOutOfCodes {
 			return err
 		}
 	}
 	// Write the eof code.
-	eof := uint32(1)<<e.litWidth + 1
-	if err := e.write(e, eof); err != nil {
+	eof := uint32(1)<<w.litWidth + 1
+	if err := w.write(w, eof); err != nil {
 		return err
 	}
 	// Write the final bits.
-	if e.nBits > 0 {
-		if e.order == MSB {
-			e.bits >>= 24
+	if w.nBits > 0 {
+		if w.order == MSB {
+			w.bits >>= 24
 		}
-		if err := e.w.WriteByte(uint8(e.bits)); err != nil {
+		if err := w.w.WriteByte(uint8(w.bits)); err != nil {
 			return err
 		}
 	}
-	return e.w.Flush()
+	return w.w.Flush()
+}
+
+// Reset clears the Writer's state and allows it to be reused again
+// as a new Writer.
+func (w *Writer) Reset(dst io.Writer, order Order, litWidth int) {
+	*w = Writer{}
+	w.init(dst, order, litWidth)
 }
 
 // NewWriter creates a new io.WriteCloser.
@@ -238,32 +233,43 @@ func (e *encoder) Close() error {
 // finished writing.
 // The number of bits to use for literal codes, litWidth, must be in the
 // range [2,8] and is typically 8. Input bytes must be less than 1<<litWidth.
+//
+// It is guaranteed that the underlying type of the returned io.WriteCloser
+// is a *Writer.
 func NewWriter(w io.Writer, order Order, litWidth int) io.WriteCloser {
-	var write func(*encoder, uint32) error
+	return newWriter(w, order, litWidth)
+}
+
+func newWriter(dst io.Writer, order Order, litWidth int) *Writer {
+	w := new(Writer)
+	w.init(dst, order, litWidth)
+	return w
+}
+
+func (w *Writer) init(dst io.Writer, order Order, litWidth int) {
 	switch order {
 	case LSB:
-		write = (*encoder).writeLSB
+		w.write = (*Writer).writeLSB
 	case MSB:
-		write = (*encoder).writeMSB
+		w.write = (*Writer).writeMSB
 	default:
-		return &errWriteCloser{errors.New("lzw: unknown order")}
+		w.err = errors.New("lzw: unknown order")
+		return
 	}
 	if litWidth < 2 || 8 < litWidth {
-		return &errWriteCloser{fmt.Errorf("lzw: litWidth %d out of range", litWidth)}
+		w.err = fmt.Errorf("lzw: litWidth %d out of range", litWidth)
+		return
 	}
-	bw, ok := w.(writer)
-	if !ok {
-		bw = bufio.NewWriter(w)
+	bw, ok := dst.(writer)
+	if !ok && dst != nil {
+		bw = bufio.NewWriter(dst)
 	}
+	w.w = bw
 	lw := uint(litWidth)
-	return &encoder{
-		w:         bw,
-		order:     order,
-		write:     write,
-		width:     1 + lw,
-		litWidth:  lw,
-		hi:        1<<lw + 1,
-		overflow:  1 << (lw + 1),
-		savedCode: invalidCode,
-	}
+	w.order = order
+	w.width = 1 + lw
+	w.litWidth = lw
+	w.hi = 1<<lw + 1
+	w.overflow = 1 << (lw + 1)
+	w.savedCode = invalidCode
 }
diff --git a/src/compress/lzw/writer_test.go b/src/compress/lzw/writer_test.go
index 1a5dbcae93..9f59c8bb18 100644
--- a/src/compress/lzw/writer_test.go
+++ b/src/compress/lzw/writer_test.go
@@ -5,6 +5,7 @@
 package lzw
 
 import (
+	"bytes"
 	"fmt"
 	"internal/testenv"
 	"io"
@@ -105,6 +106,50 @@ func TestWriter(t *testing.T) {
 	}
 }
 
+func TestWriterReset(t *testing.T) {
+	for _, order := range [...]Order{LSB, MSB} {
+		t.Run(fmt.Sprintf("Order %d", order), func(t *testing.T) {
+			for litWidth := 6; litWidth <= 8; litWidth++ {
+				t.Run(fmt.Sprintf("LitWidth %d", litWidth), func(t *testing.T) {
+					var data []byte
+					if litWidth == 6 {
+						data = []byte{1, 2, 3}
+					} else {
+						data = []byte(`lorem ipsum dolor sit amet`)
+					}
+					var buf bytes.Buffer
+					w := NewWriter(&buf, order, litWidth)
+					if _, err := w.Write(data); err != nil {
+						t.Errorf("write: %v: %v", string(data), err)
+					}
+
+					if err := w.Close(); err != nil {
+						t.Errorf("close: %v", err)
+					}
+
+					b1 := buf.Bytes()
+					buf.Reset()
+
+					w.(*Writer).Reset(&buf, order, litWidth)
+
+					if _, err := w.Write(data); err != nil {
+						t.Errorf("write: %v: %v", string(data), err)
+					}
+
+					if err := w.Close(); err != nil {
+						t.Errorf("close: %v", err)
+					}
+					b2 := buf.Bytes()
+
+					if !bytes.Equal(b1, b2) {
+						t.Errorf("bytes written were not same")
+					}
+				})
+			}
+		})
+	}
+}
+
 func TestWriterReturnValues(t *testing.T) {
 	w := NewWriter(io.Discard, LSB, 8)
 	n, err := w.Write([]byte("asdf"))
@@ -152,5 +197,14 @@ func BenchmarkEncoder(b *testing.B) {
 				w.Close()
 			}
 		})
+		b.Run(fmt.Sprint("1e-Reuse", e), func(b *testing.B) {
+			b.SetBytes(int64(n))
+			w := NewWriter(io.Discard, LSB, 8)
+			for i := 0; i < b.N; i++ {
+				w.Write(buf1)
+				w.Close()
+				w.(*Writer).Reset(io.Discard, LSB, 8)
+			}
+		})
 	}
 }
-- 
GitLab


From 2f3db220d1ff1610e315d95d276782d4533f052b Mon Sep 17 00:00:00 2001
From: Johan Brandhorst <johan.brandhorst@gmail.com>
Date: Wed, 17 Mar 2021 14:13:35 +0000
Subject: [PATCH 1127/2400] crypto/tls: remove flaky cancellation test

This will be reintroduced again once the source of the
flakiness has been determined and fixed.

Fixes #45084

Change-Id: I6677b27fcd71e8c9bb8edbe8e3be70e5a271ebd3
Reviewed-on: https://go-review.googlesource.com/c/go/+/302569
Trust: Johan Brandhorst-Satzkorn <johan.brandhorst@gmail.com>
Trust: Katie Hockman <katie@golang.org>
Run-TryBot: Johan Brandhorst-Satzkorn <johan.brandhorst@gmail.com>
Run-TryBot: Katie Hockman <katie@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/crypto/tls/handshake_client_test.go | 36 -------------------------
 1 file changed, 36 deletions(-)

diff --git a/src/crypto/tls/handshake_client_test.go b/src/crypto/tls/handshake_client_test.go
index 2f30b3008d..693f9686a7 100644
--- a/src/crypto/tls/handshake_client_test.go
+++ b/src/crypto/tls/handshake_client_test.go
@@ -6,7 +6,6 @@ package tls
 
 import (
 	"bytes"
-	"context"
 	"crypto/rsa"
 	"crypto/x509"
 	"encoding/base64"
@@ -21,7 +20,6 @@ import (
 	"os/exec"
 	"path/filepath"
 	"reflect"
-	"runtime"
 	"strconv"
 	"strings"
 	"testing"
@@ -2513,37 +2511,3 @@ func testResumptionKeepsOCSPAndSCT(t *testing.T, ver uint16) {
 			serverConfig.Certificates[0].SignedCertificateTimestamps, ccs.SignedCertificateTimestamps)
 	}
 }
-
-func TestClientHandshakeContextCancellation(t *testing.T) {
-	c, s := localPipe(t)
-	serverConfig := testConfig.Clone()
-	serverErr := make(chan error, 1)
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	go func() {
-		defer close(serverErr)
-		defer s.Close()
-		conn := Server(s, serverConfig)
-		_, err := conn.readClientHello(ctx)
-		cancel()
-		serverErr <- err
-	}()
-	cli := Client(c, testConfig)
-	err := cli.HandshakeContext(ctx)
-	if err == nil {
-		t.Fatal("Client handshake did not error when the context was canceled")
-	}
-	if err != context.Canceled {
-		t.Errorf("Unexpected client handshake error: %v", err)
-	}
-	if err := <-serverErr; err != nil {
-		t.Errorf("Unexpected server error: %v", err)
-	}
-	if runtime.GOARCH == "wasm" {
-		t.Skip("conn.Close does not error as expected when called multiple times on WASM")
-	}
-	err = cli.Close()
-	if err == nil {
-		t.Error("Client connection was not closed when the context was canceled")
-	}
-}
-- 
GitLab


From 70d54df4f6bd63b0057d718c6fc3fffc0d94bbc1 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Fri, 12 Mar 2021 11:36:02 -0800
Subject: [PATCH 1128/2400] cmd/compile:  getting more built-ins to work with
 generics

For Builtin ops, we currently stay with using the old
typechecker to transform the call to a more specific expression
and possibly use more specific ops. However, for a bunch of the
ops, we delay calling the old typechecker if any of the args have
type params, for a variety of reasons.

In the near future, we will start creating separate functions that do
the same transformations as the old typechecker for calls, builtins,
indexing, comparisons, etc. These functions can then be called at noder
time for nodes with no type params, and at stenciling time for nodes
with type params.

Remove unnecessary calls to types1 typechecker for most kinds of
statements (still need it for SendStmt, AssignStmt, ReturnStmt, and
SelectStmt). In particular, we don't need it for RangeStmt, and this
avoids some complaints by the types1 typechecker on generic code.

Other small changes:
 - Fix check on whether to delay calling types1-typechecker on type
   conversions. Should check if HasTParam is true, rather than if the
   type is directly a TYPEPARAM.

 - Don't call types1-typechecker on an indexing operation if the left
   operand has a typeparam in its type and is not obviously a TMAP,
   TSLICE, or TARRAY. As above, we will eventually have to create a new
   function that can do the required transformations (for complicated
   cases) at noder time or stenciling time.

 - Copy n.BuiltinOp in subster.node()

 - The complex arithmetic example in absdiff.go now works.

 - Added new tests double.go and append.go

 - Added new example with a new() call in settable.go

Change-Id: I8f377afb6126cab1826bd3c2732aa8cdf1f7e0b4
Reviewed-on: https://go-review.googlesource.com/c/go/+/301951
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/expr.go    |   2 +-
 src/cmd/compile/internal/noder/helpers.go |  56 ++++++++---
 src/cmd/compile/internal/noder/stencil.go |  23 ++++-
 src/cmd/compile/internal/noder/stmt.go    |  29 ++++--
 test/typeparam/absdiff.go                 |  35 ++++---
 test/typeparam/append.go                  |  31 ++++++
 test/typeparam/double.go                  |  50 ++++++++++
 test/typeparam/settable.go                | 116 +++++++++++++---------
 8 files changed, 252 insertions(+), 90 deletions(-)
 create mode 100644 test/typeparam/append.go
 create mode 100644 test/typeparam/double.go

diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index 989ebf236e..1ca5552879 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -135,7 +135,7 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 			index := g.expr(expr.Index)
 			if index.Op() != ir.OTYPE {
 				// This is just a normal index expression
-				return Index(pos, g.expr(expr.X), index)
+				return Index(pos, g.typ(typ), g.expr(expr.X), index)
 			}
 			// This is generic function instantiation with a single type
 			targs = []ir.Node{index}
diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
index cf7a3e22b3..1210d4b58c 100644
--- a/src/cmd/compile/internal/noder/helpers.go
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -83,11 +83,12 @@ func Binary(pos src.XPos, op ir.Op, x, y ir.Node) ir.Node {
 }
 
 func Call(pos src.XPos, typ *types.Type, fun ir.Node, args []ir.Node, dots bool) ir.Node {
-	// TODO(mdempsky): This should not be so difficult.
+	n := ir.NewCallExpr(pos, ir.OCALL, fun, args)
+	n.IsDDD = dots
+
 	if fun.Op() == ir.OTYPE {
 		// Actually a type conversion, not a function call.
-		n := ir.NewCallExpr(pos, ir.OCALL, fun, args)
-		if fun.Type().Kind() == types.TTYPEPARAM {
+		if fun.Type().HasTParam() || args[0].Type().HasTParam() {
 			// For type params, don't typecheck until we actually know
 			// the type.
 			return typed(typ, n)
@@ -96,9 +97,34 @@ func Call(pos src.XPos, typ *types.Type, fun ir.Node, args []ir.Node, dots bool)
 	}
 
 	if fun, ok := fun.(*ir.Name); ok && fun.BuiltinOp != 0 {
-		// Call to a builtin function.
-		n := ir.NewCallExpr(pos, ir.OCALL, fun, args)
-		n.IsDDD = dots
+		// For Builtin ops, we currently stay with using the old
+		// typechecker to transform the call to a more specific expression
+		// and possibly use more specific ops. However, for a bunch of the
+		// ops, we delay doing the old typechecker if any of the args have
+		// type params, for a variety of reasons:
+		//
+		// OMAKE: hard to choose specific ops OMAKESLICE, etc. until arg type is known
+		// OREAL/OIMAG: can't determine type float32/float64 until arg type know
+		// OLEN/OCAP: old typechecker will complain if arg is not obviously a slice/array.
+		// OAPPEND: old typechecker will complain if arg is not obviously slice, etc.
+		//
+		// We will eventually break out the transforming functionality
+		// needed for builtin's, and call it here or during stenciling, as
+		// appropriate.
+		switch fun.BuiltinOp {
+		case ir.OMAKE, ir.OREAL, ir.OIMAG, ir.OLEN, ir.OCAP, ir.OAPPEND:
+			hasTParam := false
+			for _, arg := range args {
+				if arg.Type().HasTParam() {
+					hasTParam = true
+					break
+				}
+			}
+			if hasTParam {
+				return typed(typ, n)
+			}
+		}
+
 		switch fun.BuiltinOp {
 		case ir.OCLOSE, ir.ODELETE, ir.OPANIC, ir.OPRINT, ir.OPRINTN:
 			return typecheck.Stmt(n)
@@ -124,9 +150,6 @@ func Call(pos src.XPos, typ *types.Type, fun ir.Node, args []ir.Node, dots bool)
 		}
 	}
 
-	n := ir.NewCallExpr(pos, ir.OCALL, fun, args)
-	n.IsDDD = dots
-
 	if fun.Op() == ir.OXDOT {
 		if !fun.(*ir.SelectorExpr).X.Type().HasTParam() {
 			base.FatalfAt(pos, "Expecting type param receiver in %v", fun)
@@ -230,9 +253,18 @@ func method(typ *types.Type, index int) *types.Field {
 	return types.ReceiverBaseType(typ).Methods().Index(index)
 }
 
-func Index(pos src.XPos, x, index ir.Node) ir.Node {
-	// TODO(mdempsky): Avoid typecheck.Expr (which will call tcIndex)
-	return typecheck.Expr(ir.NewIndexExpr(pos, x, index))
+func Index(pos src.XPos, typ *types.Type, x, index ir.Node) ir.Node {
+	n := ir.NewIndexExpr(pos, x, index)
+	// TODO(danscales): Temporary fix. Need to separate out the
+	// transformations done by the old typechecker (in tcIndex()), to be
+	// called here or after stenciling.
+	if x.Type().HasTParam() && x.Type().Kind() != types.TMAP &&
+		x.Type().Kind() != types.TSLICE && x.Type().Kind() != types.TARRAY {
+		// Old typechecker will complain if arg is not obviously a slice/array/map.
+		typed(typ, n)
+		return n
+	}
+	return typecheck.Expr(n)
 }
 
 func Slice(pos src.XPos, x, low, high, max ir.Node) ir.Node {
diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 64b3a942e2..55aee9b6ff 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -330,8 +330,13 @@ func (subst *subster) node(n ir.Node) ir.Node {
 				m.SetIsClosureVar(true)
 			}
 			t := x.Type()
-			newt := subst.typ(t)
-			m.SetType(newt)
+			if t == nil {
+				assert(name.BuiltinOp != 0)
+			} else {
+				newt := subst.typ(t)
+				m.SetType(newt)
+			}
+			m.BuiltinOp = name.BuiltinOp
 			m.Curfn = subst.newf
 			m.Class = name.Class
 			m.Func = name.Func
@@ -396,11 +401,23 @@ func (subst *subster) node(n ir.Node) ir.Node {
 				// that the OXDOT was resolved.
 				call.SetTypecheck(0)
 				typecheck.Call(call)
+			} else if name := call.X.Name(); name != nil {
+				switch name.BuiltinOp {
+				case ir.OMAKE, ir.OREAL, ir.OIMAG, ir.OLEN, ir.OCAP, ir.OAPPEND:
+					// Call old typechecker (to do any
+					// transformations) now that we know the
+					// type of the args.
+					m.SetTypecheck(0)
+					m = typecheck.Expr(m)
+				default:
+					base.FatalfAt(call.Pos(), "Unexpected builtin op")
+				}
+
 			} else if call.X.Op() != ir.OFUNCINST {
 				// A call with an OFUNCINST will get typechecked
 				// in stencil() once we have created & attached the
 				// instantiation to be called.
-				base.FatalfAt(call.Pos(), "Expecting OCALLPART or OTYPE or OFUNCINST with CALL")
+				base.FatalfAt(call.Pos(), "Expecting OCALLPART or OTYPE or OFUNCINST or builtin with CALL")
 			}
 		}
 
diff --git a/src/cmd/compile/internal/noder/stmt.go b/src/cmd/compile/internal/noder/stmt.go
index 1775116f41..31c6bfe5c8 100644
--- a/src/cmd/compile/internal/noder/stmt.go
+++ b/src/cmd/compile/internal/noder/stmt.go
@@ -28,7 +28,11 @@ func (g *irgen) stmts(stmts []syntax.Stmt) []ir.Node {
 
 func (g *irgen) stmt(stmt syntax.Stmt) ir.Node {
 	// TODO(mdempsky): Remove dependency on typecheck.
-	return typecheck.Stmt(g.stmt0(stmt))
+	n := g.stmt0(stmt)
+	if n != nil {
+		n.SetTypecheck(1)
+	}
+	return n
 }
 
 func (g *irgen) stmt0(stmt syntax.Stmt) ir.Node {
@@ -46,17 +50,20 @@ func (g *irgen) stmt0(stmt syntax.Stmt) ir.Node {
 		}
 		return x
 	case *syntax.SendStmt:
-		return ir.NewSendStmt(g.pos(stmt), g.expr(stmt.Chan), g.expr(stmt.Value))
+		n := ir.NewSendStmt(g.pos(stmt), g.expr(stmt.Chan), g.expr(stmt.Value))
+		// Need to do the AssignConv() in tcSend().
+		return typecheck.Stmt(n)
 	case *syntax.DeclStmt:
 		return ir.NewBlockStmt(g.pos(stmt), g.decls(stmt.DeclList))
 
 	case *syntax.AssignStmt:
 		if stmt.Op != 0 && stmt.Op != syntax.Def {
 			op := g.op(stmt.Op, binOps[:])
+			// May need to insert ConvExpr nodes on the args in tcArith
 			if stmt.Rhs == nil {
-				return IncDec(g.pos(stmt), op, g.expr(stmt.Lhs))
+				return typecheck.Stmt(IncDec(g.pos(stmt), op, g.expr(stmt.Lhs)))
 			}
-			return ir.NewAssignOpStmt(g.pos(stmt), op, g.expr(stmt.Lhs), g.expr(stmt.Rhs))
+			return typecheck.Stmt(ir.NewAssignOpStmt(g.pos(stmt), op, g.expr(stmt.Lhs), g.expr(stmt.Rhs)))
 		}
 
 		names, lhs := g.assignList(stmt.Lhs, stmt.Op == syntax.Def)
@@ -65,25 +72,31 @@ func (g *irgen) stmt0(stmt syntax.Stmt) ir.Node {
 		if len(lhs) == 1 && len(rhs) == 1 {
 			n := ir.NewAssignStmt(g.pos(stmt), lhs[0], rhs[0])
 			n.Def = initDefn(n, names)
-			return n
+			// Need to set Assigned in checkassign for maps
+			return typecheck.Stmt(n)
 		}
 
 		n := ir.NewAssignListStmt(g.pos(stmt), ir.OAS2, lhs, rhs)
 		n.Def = initDefn(n, names)
-		return n
+		// Need to do tcAssignList().
+		return typecheck.Stmt(n)
 
 	case *syntax.BranchStmt:
 		return ir.NewBranchStmt(g.pos(stmt), g.tokOp(int(stmt.Tok), branchOps[:]), g.name(stmt.Label))
 	case *syntax.CallStmt:
 		return ir.NewGoDeferStmt(g.pos(stmt), g.tokOp(int(stmt.Tok), callOps[:]), g.expr(stmt.Call))
 	case *syntax.ReturnStmt:
-		return ir.NewReturnStmt(g.pos(stmt), g.exprList(stmt.Results))
+		n := ir.NewReturnStmt(g.pos(stmt), g.exprList(stmt.Results))
+		// Need to do typecheckaste() for multiple return values
+		return typecheck.Stmt(n)
 	case *syntax.IfStmt:
 		return g.ifStmt(stmt)
 	case *syntax.ForStmt:
 		return g.forStmt(stmt)
 	case *syntax.SelectStmt:
-		return g.selectStmt(stmt)
+		n := g.selectStmt(stmt)
+		// Need to convert assignments to OSELRECV2 in tcSelect()
+		return typecheck.Stmt(n)
 	case *syntax.SwitchStmt:
 		return g.switchStmt(stmt)
 
diff --git a/test/typeparam/absdiff.go b/test/typeparam/absdiff.go
index 5dd58f14f7..1381d7c92c 100644
--- a/test/typeparam/absdiff.go
+++ b/test/typeparam/absdiff.go
@@ -8,7 +8,7 @@ package main
 
 import (
 	"fmt"
-	//"math"
+	"math"
 )
 
 type Numeric interface {
@@ -57,14 +57,14 @@ func (a orderedAbs[T]) Abs() orderedAbs[T] {
 
 // complexAbs is a helper type that defines an Abs method for
 // complex types.
-// type complexAbs[T Complex] T
+type complexAbs[T Complex] T
 
-// func (a complexAbs[T]) Abs() complexAbs[T] {
-// 	r := float64(real(a))
-// 	i := float64(imag(a))
-// 	d := math.Sqrt(r * r + i * i)
-// 	return complexAbs[T](complex(d, 0))
-// }
+func (a complexAbs[T]) Abs() complexAbs[T] {
+	r := float64(real(a))
+	i := float64(imag(a))
+	d := math.Sqrt(r * r + i * i)
+	return complexAbs[T](complex(d, 0))
+}
 
 // OrderedAbsDifference returns the absolute value of the difference
 // between a and b, where a and b are of an ordered type.
@@ -74,9 +74,9 @@ func orderedAbsDifference[T orderedNumeric](a, b T) T {
 
 // ComplexAbsDifference returns the absolute value of the difference
 // between a and b, where a and b are of a complex type.
-// func complexAbsDifference[T Complex](a, b T) T {
-// 	return T(absDifference(complexAbs[T](a), complexAbs[T](b)))
-// }
+func complexAbsDifference[T Complex](a, b T) T {
+	return T(absDifference(complexAbs[T](a), complexAbs[T](b)))
+}
 
 func main() {
 	if got, want := orderedAbsDifference(1.0, -2.0), 3.0; got != want {
@@ -89,11 +89,10 @@ func main() {
 		panic(fmt.Sprintf("got = %v, want = %v", got, want))
 	}
 
-	// Still have to handle built-ins real/abs to make this work
-	// if got, want := complexAbsDifference(5.0 + 2.0i, 2.0 - 2.0i), 5; got != want {
-	//	panic(fmt.Sprintf("got = %v, want = %v", got, want)
-	// }
-	// if got, want := complexAbsDifference(2.0 - 2.0i, 5.0 + 2.0i), 5; got != want {
-	//	panic(fmt.Sprintf("got = %v, want = %v", got, want)
-	// }
+	if got, want := complexAbsDifference(5.0 + 2.0i, 2.0 - 2.0i), 5+0i; got != want {
+		panic(fmt.Sprintf("got = %v, want = %v", got, want))
+	}
+	if got, want := complexAbsDifference(2.0 - 2.0i, 5.0 + 2.0i), 5+0i; got != want {
+		panic(fmt.Sprintf("got = %v, want = %v", got, want))
+	}
 }
diff --git a/test/typeparam/append.go b/test/typeparam/append.go
new file mode 100644
index 0000000000..8b9bc2039f
--- /dev/null
+++ b/test/typeparam/append.go
@@ -0,0 +1,31 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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
+
+type Recv <-chan int
+
+type sliceOf[E any] interface {
+	type []E
+}
+
+func _Append[S sliceOf[T], T any](s S, t ...T) S {
+	return append(s, t...)
+}
+
+func main() {
+	recv := make(Recv)
+	a := _Append([]Recv{recv}, recv)
+	if len(a) != 2 || a[0] != recv || a[1] != recv {
+		panic(a)
+	}
+
+	recv2 := make(chan<- int)
+	a2 := _Append([]chan<- int{recv2}, recv2)
+	if len(a2) != 2 || a2[0] != recv2 || a2[1] != recv2 {
+		panic(a)
+	}
+}
diff --git a/test/typeparam/double.go b/test/typeparam/double.go
new file mode 100644
index 0000000000..1f7a26c7f4
--- /dev/null
+++ b/test/typeparam/double.go
@@ -0,0 +1,50 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 (
+	"fmt"
+	"reflect"
+)
+
+type Number interface {
+	type int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr, float32, float64
+}
+
+type MySlice []int
+
+type _SliceOf[E any] interface {
+	type []E
+}
+
+func _DoubleElems[S _SliceOf[E], E Number](s S) S {
+	r := make(S, len(s))
+	for i, v := range s {
+		r[i] = v + v
+	}
+	return r
+}
+
+func main() {
+	arg := MySlice{1, 2, 3}
+	want := MySlice{2, 4, 6}
+	got := _DoubleElems[MySlice, int](arg)
+	if !reflect.DeepEqual(got, want) {
+                panic(fmt.Sprintf("got %s, want %s", got, want))
+	}
+
+	// constraint type inference
+	got = _DoubleElems[MySlice](arg)
+	if !reflect.DeepEqual(got, want) {
+                panic(fmt.Sprintf("got %s, want %s", got, want))
+	}
+
+	got = _DoubleElems(arg)
+	if !reflect.DeepEqual(got, want) {
+                panic(fmt.Sprintf("got %s, want %s", got, want))
+	}
+}
diff --git a/test/typeparam/settable.go b/test/typeparam/settable.go
index 29874fb189..588166da85 100644
--- a/test/typeparam/settable.go
+++ b/test/typeparam/settable.go
@@ -14,44 +14,58 @@ import (
 // Various implementations of fromStrings().
 
 type _Setter[B any] interface {
-        Set(string)
+	Set(string)
 	type *B
 }
 
 // Takes two type parameters where PT = *T
 func fromStrings1[T any, PT _Setter[T]](s []string) []T {
-        result := make([]T, len(s))
-        for i, v := range s {
-                // The type of &result[i] is *T which is in the type list
-                // of Setter, so we can convert it to PT.
-                p := PT(&result[i])
-                // PT has a Set method.
-                p.Set(v)
-        }
-        return result
+	result := make([]T, len(s))
+	for i, v := range s {
+		// The type of &result[i] is *T which is in the type list
+		// of Setter, so we can convert it to PT.
+		p := PT(&result[i])
+		// PT has a Set method.
+		p.Set(v)
+	}
+	return result
 }
 
+func fromStrings1a[T any, PT _Setter[T]](s []string) []PT {
+	result := make([]PT, len(s))
+	for i, v := range s {
+		// The type new(T) is *T which is in the type list
+		// of Setter, so we can convert it to PT.
+		result[i] = PT(new(T))
+		p := result[i]
+		// PT has a Set method.
+		p.Set(v)
+	}
+	return result
+}
+
+
 // Takes one type parameter and a set function
 func fromStrings2[T any](s []string, set func(*T, string)) []T {
-        results := make([]T, len(s))
-        for i, v := range s {
-                set(&results[i], v)
-        }
-        return results
+	results := make([]T, len(s))
+	for i, v := range s {
+		set(&results[i], v)
+	}
+	return results
 }
 
 type _Setter2 interface {
-        Set(string)
+	Set(string)
 }
 
 // Takes only one type parameter, but causes a panic (see below)
 func fromStrings3[T _Setter2](s []string) []T {
-        results := make([]T, len(s))
-        for i, v := range s {
+	results := make([]T, len(s))
+	for i, v := range s {
 		// Panics if T is a pointer type because receiver is T(nil).
 		results[i].Set(v)
-        }
-        return results
+	}
+	return results
 }
 
 // Two concrete types with the appropriate Set method.
@@ -59,11 +73,11 @@ func fromStrings3[T _Setter2](s []string) []T {
 type SettableInt int
 
 func (p *SettableInt) Set(s string) {
-        i, err := strconv.Atoi(s)
-        if err != nil {
-                panic(err)
-        }
-        *p = SettableInt(i)
+	i, err := strconv.Atoi(s)
+	if err != nil {
+		panic(err)
+	}
+	*p = SettableInt(i)
 }
 
 type SettableString struct {
@@ -71,34 +85,40 @@ type SettableString struct {
 }
 
 func (x *SettableString) Set(s string) {
-        x.s = s
+	x.s = s
 }
 
 func main() {
-        s := fromStrings1[SettableInt, *SettableInt]([]string{"1"})
-        if len(s) != 1 || s[0] != 1 {
-                panic(fmt.Sprintf("got %v, want %v", s, []int{1}))
-        }
+	s := fromStrings1[SettableInt, *SettableInt]([]string{"1"})
+	if len(s) != 1 || s[0] != 1 {
+		panic(fmt.Sprintf("got %v, want %v", s, []int{1}))
+	}
+
+	s2 := fromStrings1a[SettableInt, *SettableInt]([]string{"1"})
+	if len(s2) != 1 || *s2[0] != 1 {
+		x := 1
+		panic(fmt.Sprintf("got %v, want %v", s2, []*int{&x}))
+	}
 
 	// Test out constraint type inference, which should determine that the second
 	// type param is *SettableString.
 	ps := fromStrings1[SettableString]([]string{"x", "y"})
-        if len(ps) != 2 || ps[0] != (SettableString{"x"}) || ps[1] != (SettableString{"y"}) {
-                panic(s)
-        }
-
-        s = fromStrings2([]string{"1"}, func(p *SettableInt, s string) { p.Set(s) })
-        if len(s) != 1 || s[0] != 1 {
-                panic(fmt.Sprintf("got %v, want %v", s, []int{1}))
-        }
-
-        defer func() {
-                if recover() == nil {
-                        panic("did not panic as expected")
-                }
-        }()
-        // This should type check but should panic at run time,
-        // because it will make a slice of *SettableInt and then call
-        // Set on a nil value.
-        fromStrings3[*SettableInt]([]string{"1"})
+	if len(ps) != 2 || ps[0] != (SettableString{"x"}) || ps[1] != (SettableString{"y"}) {
+		panic(s)
+	}
+
+	s = fromStrings2([]string{"1"}, func(p *SettableInt, s string) { p.Set(s) })
+	if len(s) != 1 || s[0] != 1 {
+		panic(fmt.Sprintf("got %v, want %v", s, []int{1}))
+	}
+
+	defer func() {
+		if recover() == nil {
+			panic("did not panic as expected")
+		}
+	}()
+	// This should type check but should panic at run time,
+	// because it will make a slice of *SettableInt and then call
+	// Set on a nil value.
+	fromStrings3[*SettableInt]([]string{"1"})
 }
-- 
GitLab


From 0bd308ff27822378dc2db77d6dd0ad3c15ed2e08 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 17 Mar 2021 12:42:19 -0400
Subject: [PATCH 1129/2400] go/parser: avoid formatting a panic message if an
 assertion succeeds

tryResolve is an extremely hot method on the parser. Eliminating this
formatting led to a 20% performance improvement in BenchmarkParse.

Change-Id: Idf8850404bd72d45d1351356427a85086422ea68
Reviewed-on: https://go-review.googlesource.com/c/go/+/302629
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/parser/parser.go | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/go/parser/parser.go b/src/go/parser/parser.go
index ed1867b3b3..b86d6bad46 100644
--- a/src/go/parser/parser.go
+++ b/src/go/parser/parser.go
@@ -181,7 +181,10 @@ func (p *parser) tryResolve(x ast.Expr, collectUnresolved bool) {
 	if ident == nil {
 		return
 	}
-	assert(ident.Obj == nil, fmt.Sprintf("identifier %s already declared or resolved", ident.Name))
+	// Don't use assert here, to avoid needless formatting of the message below.
+	if ident.Obj != nil {
+		panic(fmt.Sprintf("identifier %s already declared or resolved", ident.Name))
+	}
 	if ident.Name == "_" {
 		return
 	}
-- 
GitLab


From 8628bf9a972993bdb978b7d6fa7a6bb1ca2cddbe Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Fri, 12 Mar 2021 18:38:02 -0500
Subject: [PATCH 1130/2400] cmd/compile: resurrect clobberdead mode

This CL resurrects the clobberdead debugging mode (CL 23924).
When -clobberdead flag is set (TODO: make it GOEXPERIMENT?), the
compiler inserts code that clobbers all dead stack slots that
contains pointers.

Mark windows syscall functions cgo_unsafe_args, as the code
actually does that, by taking the address of one argument and
passing it to cgocall.

Change-Id: Ie09a015f4bd14ae6053cc707866e30ae509b9d6f
Reviewed-on: https://go-review.googlesource.com/c/go/+/301791
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/base/flag.go         |   1 +
 src/cmd/compile/internal/liveness/plive.go    | 165 +++++++++++++++++-
 .../compile/internal/test/clobberdead_test.go |  47 +++++
 src/runtime/syscall_windows.go                |   9 +
 test/codegen/clobberdead.go                   |  32 ++++
 5 files changed, 251 insertions(+), 3 deletions(-)
 create mode 100644 src/cmd/compile/internal/test/clobberdead_test.go
 create mode 100644 test/codegen/clobberdead.go

diff --git a/src/cmd/compile/internal/base/flag.go b/src/cmd/compile/internal/base/flag.go
index ade17fc0cd..1087f97d07 100644
--- a/src/cmd/compile/internal/base/flag.go
+++ b/src/cmd/compile/internal/base/flag.go
@@ -90,6 +90,7 @@ type CmdFlags struct {
 	BuildID            string       "help:\"record `id` as the build id in the export metadata\""
 	CPUProfile         string       "help:\"write cpu profile to `file`\""
 	Complete           bool         "help:\"compiling complete package (no C or assembly)\""
+	ClobberDead        bool         "help:\"clobber dead stack slots (for debugging)\""
 	Dwarf              bool         "help:\"generate DWARF symbols\""
 	DwarfBASEntries    *bool        "help:\"use base address selection entries in DWARF\""                        // &Ctxt.UseBASEntries, set below
 	DwarfLocationLists *bool        "help:\"add location lists to DWARF in optimized mode\""                      // &Ctxt.Flag_locationlists, set below
diff --git a/src/cmd/compile/internal/liveness/plive.go b/src/cmd/compile/internal/liveness/plive.go
index f3fbb8b9b1..c09a8401f7 100644
--- a/src/cmd/compile/internal/liveness/plive.go
+++ b/src/cmd/compile/internal/liveness/plive.go
@@ -16,7 +16,9 @@ package liveness
 
 import (
 	"crypto/md5"
+	"crypto/sha1"
 	"fmt"
+	"os"
 	"sort"
 	"strings"
 
@@ -30,6 +32,7 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
+	"cmd/internal/src"
 )
 
 // OpVarDef is an annotation for the liveness analysis, marking a place
@@ -123,9 +126,9 @@ type liveness struct {
 	unsafePoints bitvec.BitVec
 
 	// An array with a bit vector for each safe point in the
-	// current Block during Liveness.epilogue. Indexed in Value
+	// current Block during liveness.epilogue. Indexed in Value
 	// order for that block. Additionally, for the entry block
-	// livevars[0] is the entry bitmap. Liveness.compact moves
+	// livevars[0] is the entry bitmap. liveness.compact moves
 	// these to stackMaps.
 	livevars []bitvec.BitVec
 
@@ -136,6 +139,8 @@ type liveness struct {
 	stackMaps   []bitvec.BitVec
 
 	cache progeffectscache
+
+	doClobber bool // Whether to clobber dead stack slots in this function.
 }
 
 // Map maps from *ssa.Value to LivenessIndex.
@@ -387,6 +392,9 @@ func newliveness(fn *ir.Func, f *ssa.Func, vars []*ir.Name, idx map[*ir.Name]int
 	lv.livenessMap.reset()
 
 	lv.markUnsafePoints()
+
+	lv.enableClobber()
+
 	return lv
 }
 
@@ -820,6 +828,10 @@ func (lv *liveness) epilogue() {
 			live.Or(*live, liveout)
 		}
 
+		if lv.doClobber {
+			lv.clobber(b)
+		}
+
 		// The liveness maps for this block are now complete. Compact them.
 		lv.compact(b)
 	}
@@ -873,7 +885,7 @@ func (lv *liveness) compact(b *ssa.Block) {
 	}
 	for _, v := range b.Values {
 		hasStackMap := lv.hasStackMap(v)
-		isUnsafePoint := lv.allUnsafe || lv.unsafePoints.Get(int32(v.ID))
+		isUnsafePoint := lv.allUnsafe || v.Op != ssa.OpClobber && lv.unsafePoints.Get(int32(v.ID))
 		idx := objw.LivenessIndex{StackMapIndex: objw.StackMapDontCare, IsUnsafePoint: isUnsafePoint}
 		if hasStackMap {
 			idx.StackMapIndex = lv.stackMapSet.add(lv.livevars[pos])
@@ -888,6 +900,153 @@ func (lv *liveness) compact(b *ssa.Block) {
 	lv.livevars = lv.livevars[:0]
 }
 
+func (lv *liveness) enableClobber() {
+	// The clobberdead experiment inserts code to clobber pointer slots in all
+	// the dead variables (locals and args) at every synchronous safepoint.
+	if !base.Flag.ClobberDead {
+		return
+	}
+	if lv.fn.Pragma&ir.CgoUnsafeArgs != 0 {
+		// C or assembly code uses the exact frame layout. Don't clobber.
+		return
+	}
+	if len(lv.vars) > 10000 || len(lv.f.Blocks) > 10000 {
+		// Be careful to avoid doing too much work.
+		// Bail if >10000 variables or >10000 blocks.
+		// Otherwise, giant functions make this experiment generate too much code.
+		return
+	}
+	if lv.f.Name == "forkAndExecInChild" || lv.f.Name == "wbBufFlush" {
+		// forkAndExecInChild calls vfork on some platforms.
+		// The code we add here clobbers parts of the stack in the child.
+		// When the parent resumes, it is using the same stack frame. But the
+		// child has clobbered stack variables that the parent needs. Boom!
+		// In particular, the sys argument gets clobbered.
+		//
+		// runtime.wbBufFlush must not modify its arguments. See the comments
+		// in runtime/mwbbuf.go:wbBufFlush.
+		return
+	}
+	if h := os.Getenv("GOCLOBBERDEADHASH"); h != "" {
+		// Clobber only functions where the hash of the function name matches a pattern.
+		// Useful for binary searching for a miscompiled function.
+		hstr := ""
+		for _, b := range sha1.Sum([]byte(lv.f.Name)) {
+			hstr += fmt.Sprintf("%08b", b)
+		}
+		if !strings.HasSuffix(hstr, h) {
+			return
+		}
+		fmt.Printf("\t\t\tCLOBBERDEAD %s\n", lv.f.Name)
+	}
+	lv.doClobber = true
+}
+
+// Inserts code to clobber pointer slots in all the dead variables (locals and args)
+// at every synchronous safepoint in b.
+func (lv *liveness) clobber(b *ssa.Block) {
+	// Copy block's values to a temporary.
+	oldSched := append([]*ssa.Value{}, b.Values...)
+	b.Values = b.Values[:0]
+	idx := 0
+
+	// Clobber pointer slots in all dead variables at entry.
+	if b == lv.f.Entry {
+		for len(oldSched) > 0 && len(oldSched[0].Args) == 0 {
+			// Skip argless ops. We need to skip at least
+			// the lowered ClosurePtr op, because it
+			// really wants to be first. This will also
+			// skip ops like InitMem and SP, which are ok.
+			b.Values = append(b.Values, oldSched[0])
+			oldSched = oldSched[1:]
+		}
+		clobber(lv, b, lv.livevars[0])
+		idx++
+	}
+
+	// Copy values into schedule, adding clobbering around safepoints.
+	for _, v := range oldSched {
+		if !lv.hasStackMap(v) {
+			b.Values = append(b.Values, v)
+			continue
+		}
+		clobber(lv, b, lv.livevars[idx])
+		b.Values = append(b.Values, v)
+		idx++
+	}
+}
+
+// clobber generates code to clobber pointer slots in all dead variables
+// (those not marked in live). Clobbering instructions are added to the end
+// of b.Values.
+func clobber(lv *liveness, b *ssa.Block, live bitvec.BitVec) {
+	for i, n := range lv.vars {
+		if !live.Get(int32(i)) && !n.Addrtaken() {
+			// Don't clobber stack objects (address-taken). They are
+			// tracked dynamically.
+			clobberVar(b, n)
+		}
+	}
+}
+
+// clobberVar generates code to trash the pointers in v.
+// Clobbering instructions are added to the end of b.Values.
+func clobberVar(b *ssa.Block, v *ir.Name) {
+	clobberWalk(b, v, 0, v.Type())
+}
+
+// b = block to which we append instructions
+// v = variable
+// offset = offset of (sub-portion of) variable to clobber (in bytes)
+// t = type of sub-portion of v.
+func clobberWalk(b *ssa.Block, v *ir.Name, offset int64, t *types.Type) {
+	if !t.HasPointers() {
+		return
+	}
+	switch t.Kind() {
+	case types.TPTR,
+		types.TUNSAFEPTR,
+		types.TFUNC,
+		types.TCHAN,
+		types.TMAP:
+		clobberPtr(b, v, offset)
+
+	case types.TSTRING:
+		// struct { byte *str; int len; }
+		clobberPtr(b, v, offset)
+
+	case types.TINTER:
+		// struct { Itab *tab; void *data; }
+		// or, when isnilinter(t)==true:
+		// struct { Type *type; void *data; }
+		clobberPtr(b, v, offset)
+		clobberPtr(b, v, offset+int64(types.PtrSize))
+
+	case types.TSLICE:
+		// struct { byte *array; int len; int cap; }
+		clobberPtr(b, v, offset)
+
+	case types.TARRAY:
+		for i := int64(0); i < t.NumElem(); i++ {
+			clobberWalk(b, v, offset+i*t.Elem().Size(), t.Elem())
+		}
+
+	case types.TSTRUCT:
+		for _, t1 := range t.Fields().Slice() {
+			clobberWalk(b, v, offset+t1.Offset, t1.Type)
+		}
+
+	default:
+		base.Fatalf("clobberWalk: unexpected type, %v", t)
+	}
+}
+
+// clobberPtr generates a clobber of the pointer at offset offset in v.
+// The clobber instruction is added at the end of b.
+func clobberPtr(b *ssa.Block, v *ir.Name, offset int64) {
+	b.NewValue0IA(src.NoXPos, ssa.OpClobber, types.TypeVoid, offset, v)
+}
+
 func (lv *liveness) showlive(v *ssa.Value, live bitvec.BitVec) {
 	if base.Flag.Live == 0 || ir.FuncName(lv.fn) == "init" || strings.HasPrefix(ir.FuncName(lv.fn), ".") {
 		return
diff --git a/src/cmd/compile/internal/test/clobberdead_test.go b/src/cmd/compile/internal/test/clobberdead_test.go
new file mode 100644
index 0000000000..3e2aadcbf5
--- /dev/null
+++ b/src/cmd/compile/internal/test/clobberdead_test.go
@@ -0,0 +1,47 @@
+// Copyright 2021 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 test
+
+import (
+	"internal/testenv"
+	"io/ioutil"
+	"os/exec"
+	"path/filepath"
+	"testing"
+)
+
+const helloSrc = `
+package main
+import "fmt"
+func main() { fmt.Println("hello") }
+`
+
+func TestClobberDead(t *testing.T) {
+	// Test that clobberdead mode generates correct program.
+
+	if testing.Short() {
+		// This test rebuilds the runtime with a special flag, which
+		// takes a while.
+		t.Skip("skip in short mode")
+	}
+	testenv.MustHaveGoRun(t)
+	t.Parallel()
+
+	tmpdir := t.TempDir()
+	src := filepath.Join(tmpdir, "x.go")
+	err := ioutil.WriteFile(src, []byte(helloSrc), 0644)
+	if err != nil {
+		t.Fatalf("write file failed: %v", err)
+	}
+
+	cmd := exec.Command(testenv.GoToolPath(t), "run", "-gcflags=all=-clobberdead", src)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("go run failed: %v\n%s", err, out)
+	}
+	if string(out) != "hello\n" {
+		t.Errorf("wrong output: got %q, want %q", out, "hello\n")
+	}
+}
diff --git a/src/runtime/syscall_windows.go b/src/runtime/syscall_windows.go
index 7cf9318bdb..191892f047 100644
--- a/src/runtime/syscall_windows.go
+++ b/src/runtime/syscall_windows.go
@@ -263,6 +263,7 @@ const _LOAD_LIBRARY_SEARCH_SYSTEM32 = 0x00000800
 // to the full path inside of system32 for use with vanilla LoadLibrary.
 //go:linkname syscall_loadsystemlibrary syscall.loadsystemlibrary
 //go:nosplit
+//go:cgo_unsafe_args
 func syscall_loadsystemlibrary(filename *uint16, absoluteFilepath *uint16) (handle, err uintptr) {
 	lockOSThread()
 	c := &getg().m.syscall
@@ -293,6 +294,7 @@ func syscall_loadsystemlibrary(filename *uint16, absoluteFilepath *uint16) (hand
 
 //go:linkname syscall_loadlibrary syscall.loadlibrary
 //go:nosplit
+//go:cgo_unsafe_args
 func syscall_loadlibrary(filename *uint16) (handle, err uintptr) {
 	lockOSThread()
 	defer unlockOSThread()
@@ -310,6 +312,7 @@ func syscall_loadlibrary(filename *uint16) (handle, err uintptr) {
 
 //go:linkname syscall_getprocaddress syscall.getprocaddress
 //go:nosplit
+//go:cgo_unsafe_args
 func syscall_getprocaddress(handle uintptr, procname *byte) (outhandle, err uintptr) {
 	lockOSThread()
 	defer unlockOSThread()
@@ -327,6 +330,7 @@ func syscall_getprocaddress(handle uintptr, procname *byte) (outhandle, err uint
 
 //go:linkname syscall_Syscall syscall.Syscall
 //go:nosplit
+//go:cgo_unsafe_args
 func syscall_Syscall(fn, nargs, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
 	lockOSThread()
 	defer unlockOSThread()
@@ -340,6 +344,7 @@ func syscall_Syscall(fn, nargs, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
 
 //go:linkname syscall_Syscall6 syscall.Syscall6
 //go:nosplit
+//go:cgo_unsafe_args
 func syscall_Syscall6(fn, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) {
 	lockOSThread()
 	defer unlockOSThread()
@@ -353,6 +358,7 @@ func syscall_Syscall6(fn, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err ui
 
 //go:linkname syscall_Syscall9 syscall.Syscall9
 //go:nosplit
+//go:cgo_unsafe_args
 func syscall_Syscall9(fn, nargs, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2, err uintptr) {
 	lockOSThread()
 	defer unlockOSThread()
@@ -366,6 +372,7 @@ func syscall_Syscall9(fn, nargs, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1
 
 //go:linkname syscall_Syscall12 syscall.Syscall12
 //go:nosplit
+//go:cgo_unsafe_args
 func syscall_Syscall12(fn, nargs, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12 uintptr) (r1, r2, err uintptr) {
 	lockOSThread()
 	defer unlockOSThread()
@@ -379,6 +386,7 @@ func syscall_Syscall12(fn, nargs, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
 
 //go:linkname syscall_Syscall15 syscall.Syscall15
 //go:nosplit
+//go:cgo_unsafe_args
 func syscall_Syscall15(fn, nargs, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) {
 	lockOSThread()
 	defer unlockOSThread()
@@ -392,6 +400,7 @@ func syscall_Syscall15(fn, nargs, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
 
 //go:linkname syscall_Syscall18 syscall.Syscall18
 //go:nosplit
+//go:cgo_unsafe_args
 func syscall_Syscall18(fn, nargs, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18 uintptr) (r1, r2, err uintptr) {
 	lockOSThread()
 	defer unlockOSThread()
diff --git a/test/codegen/clobberdead.go b/test/codegen/clobberdead.go
new file mode 100644
index 0000000000..f8d964cba6
--- /dev/null
+++ b/test/codegen/clobberdead.go
@@ -0,0 +1,32 @@
+// asmcheck -gcflags=-clobberdead
+
+// +build amd64
+
+// Copyright 2021 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 codegen
+
+type T [2]*int // contain pointer, not SSA-able (so locals are not registerized)
+
+var p1, p2, p3 T
+
+func F() {
+	// 3735936685 is 0xdeaddead
+	// clobber x, y at entry. not clobber z (stack object).
+	// amd64:`MOVL\t\$3735936685, ""\.x`, `MOVL\t\$3735936685, ""\.y`, -`MOVL\t\$3735936685, ""\.z`
+	x, y, z := p1, p2, p3
+	addrTaken(&z)
+	// x is dead at the call (the value of x is loaded before the CALL), y is not
+	// amd64:`MOVL\t\$3735936685, ""\.x`, -`MOVL\t\$3735936685, ""\.y`
+	use(x)
+	// amd64:`MOVL\t\$3735936685, ""\.x`, `MOVL\t\$3735936685, ""\.y`
+	use(y)
+}
+
+//go:noinline
+func use(T) {}
+
+//go:noinline
+func addrTaken(*T) {}
-- 
GitLab


From 5423f6023cff995f1077ac83e132705893a8af79 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Tue, 16 Mar 2021 21:24:09 -0700
Subject: [PATCH 1131/2400] test: add bug that failed when run with gccgo

Change-Id: Ie52d70d2ae8a21acacf0745a4093650b03ac43f9
Reviewed-on: https://go-review.googlesource.com/c/go/+/302371
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 test/fixedbugs/bug512.go | 52 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 test/fixedbugs/bug512.go

diff --git a/test/fixedbugs/bug512.go b/test/fixedbugs/bug512.go
new file mode 100644
index 0000000000..6be6eb98fe
--- /dev/null
+++ b/test/fixedbugs/bug512.go
@@ -0,0 +1,52 @@
+// run
+
+// Copyright 2021 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.
+
+// Gccgo did not make a copy of a value receiver when using a
+// goroutine to call a method.
+
+package main
+
+import (
+	"sync"
+	"sync/atomic"
+)
+
+var wg sync.WaitGroup
+
+type S struct {
+	i1, i2 int32
+}
+
+var done int32
+
+func (s S) Check(v1, v2 int32) {
+	for {
+		if g1 := atomic.LoadInt32(&s.i1); v1 != g1 {
+			panic(g1)
+		}
+		if g2 := atomic.LoadInt32(&s.i2); v2 != g2 {
+			panic(g2)
+		}
+		if atomic.LoadInt32(&done) != 0 {
+			break
+		}
+	}
+	wg.Done()
+}
+
+func F() {
+	s := S{1, 2}
+	go s.Check(1, 2)
+	atomic.StoreInt32(&s.i1, 3)
+	atomic.StoreInt32(&s.i2, 4)
+	atomic.StoreInt32(&done, 1)
+}
+
+func main() {
+	wg.Add(1)
+	F()
+	wg.Wait()
+}
-- 
GitLab


From a5df88355cb8998856a5dbd3550b98e5de1f6009 Mon Sep 17 00:00:00 2001
From: Andy Pan <panjf2000@gmail.com>
Date: Fri, 12 Mar 2021 19:40:46 +0800
Subject: [PATCH 1132/2400] time: check int64 overflow in Time.addSec

Change-Id: Ibbed54239228e7ea31ef5978d427425899c3b943
Reviewed-on: https://go-review.googlesource.com/c/go/+/300890
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Baokun Lee <bk@golangcn.org>
---
 src/time/export_test.go   |  1 +
 src/time/internal_test.go |  2 ++
 src/time/time.go          | 11 +++++++++--
 src/time/time_test.go     | 27 ++++++++++++++++++++++++++-
 4 files changed, 38 insertions(+), 3 deletions(-)

diff --git a/src/time/export_test.go b/src/time/export_test.go
index f4a8cd9b72..0f2d21053a 100644
--- a/src/time/export_test.go
+++ b/src/time/export_test.go
@@ -51,6 +51,7 @@ const (
 	RuleJulian       = RuleKind(ruleJulian)
 	RuleDOY          = RuleKind(ruleDOY)
 	RuleMonthWeekDay = RuleKind(ruleMonthWeekDay)
+	UnixToInternal   = unixToInternal
 )
 
 type Rule struct {
diff --git a/src/time/internal_test.go b/src/time/internal_test.go
index ffe54e47c2..87a4208b05 100644
--- a/src/time/internal_test.go
+++ b/src/time/internal_test.go
@@ -62,4 +62,6 @@ func CheckRuntimeTimerPeriodOverflow() {
 var (
 	MinMonoTime = Time{wall: 1 << 63, ext: -1 << 63, loc: UTC}
 	MaxMonoTime = Time{wall: 1 << 63, ext: 1<<63 - 1, loc: UTC}
+
+	NotMonoNegativeTime = Time{wall: 0, ext: -1<<63 + 50}
 )
diff --git a/src/time/time.go b/src/time/time.go
index 7e5192a0c9..841f989293 100644
--- a/src/time/time.go
+++ b/src/time/time.go
@@ -189,8 +189,15 @@ func (t *Time) addSec(d int64) {
 		t.stripMono()
 	}
 
-	// TODO: Check for overflow.
-	t.ext += d
+	// Check if the sum of t.ext and d overflows and handle it properly.
+	sum := t.ext + d
+	if (sum > t.ext) == (d > 0) {
+		t.ext = sum
+	} else if d > 0 {
+		t.ext = 1<<63 - 1
+	} else {
+		t.ext = -(1<<63 - 1)
+	}
 }
 
 // setLoc sets the location associated with the time.
diff --git a/src/time/time_test.go b/src/time/time_test.go
index 8884731e1d..3a58bfe4e9 100644
--- a/src/time/time_test.go
+++ b/src/time/time_test.go
@@ -1481,7 +1481,7 @@ func TestTimeIsDST(t *testing.T) {
 	tzFixed := FixedZone("FIXED_TIME", 12345)
 
 	tests := [...]struct {
-		time   Time
+		time Time
 		want bool
 	}{
 		0: {Date(2009, 1, 1, 12, 0, 0, 0, UTC), false},
@@ -1501,3 +1501,28 @@ func TestTimeIsDST(t *testing.T) {
 		}
 	}
 }
+
+func TestTimeAddSecOverflow(t *testing.T) {
+	// Test it with positive delta.
+	var maxInt64 int64 = 1<<63 - 1
+	timeExt := maxInt64 - UnixToInternal - 50
+	notMonoTime := Unix(timeExt, 0)
+	for i := int64(0); i < 100; i++ {
+		sec := notMonoTime.Unix()
+		notMonoTime = notMonoTime.Add(Duration(i * 1e9))
+		if newSec := notMonoTime.Unix(); newSec != sec+i && newSec+UnixToInternal != maxInt64 {
+			t.Fatalf("time ext: %d overflows with positive delta, overflow threshold: %d", newSec, maxInt64)
+		}
+	}
+
+	// Test it with negative delta.
+	maxInt64 = -maxInt64
+	notMonoTime = NotMonoNegativeTime
+	for i := int64(0); i > -100; i-- {
+		sec := notMonoTime.Unix()
+		notMonoTime = notMonoTime.Add(Duration(i * 1e9))
+		if newSec := notMonoTime.Unix(); newSec != sec+i && newSec+UnixToInternal != maxInt64 {
+			t.Fatalf("time ext: %d overflows with positive delta, overflow threshold: %d", newSec, maxInt64)
+		}
+	}
+}
-- 
GitLab


From 4313c2886160613ca62742d0f46665cf8954213c Mon Sep 17 00:00:00 2001
From: Andrey Bokhanko <andreybokhanko@gmail.com>
Date: Sat, 13 Mar 2021 00:21:18 +0800
Subject: [PATCH 1133/2400] cmd/cgo: check whether C compiler exists

Currently we print a cryptic message if a C compiler doesn't exist.
This patch adds more graceful handling.

Fixes #44271

Change-Id: I44f16ef6eb2853fee22fa1d996e41ec6c9ee82f1
Reviewed-on: https://go-review.googlesource.com/c/go/+/301249
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/cgo/main.go | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/cmd/cgo/main.go b/src/cmd/cgo/main.go
index 5767c54307..77ac5e0d3a 100644
--- a/src/cmd/cgo/main.go
+++ b/src/cmd/cgo/main.go
@@ -20,6 +20,7 @@ import (
 	"io"
 	"io/ioutil"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"reflect"
 	"runtime"
@@ -302,6 +303,14 @@ func main() {
 
 	p := newPackage(args[:i])
 
+	// We need a C compiler to be available. Check this.
+	gccName := p.gccBaseCmd()[0]
+	_, err := exec.LookPath(gccName)
+	if err != nil {
+		fatalf("C compiler %q not found: %v", gccName, err)
+		os.Exit(2)
+	}
+
 	// Record CGO_LDFLAGS from the environment for external linking.
 	if ldflags := os.Getenv("CGO_LDFLAGS"); ldflags != "" {
 		args, err := splitQuoted(ldflags)
-- 
GitLab


From 7e00049b5545cac8705d6df1e337c5ddc70e65e4 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Mon, 15 Mar 2021 12:40:34 -0400
Subject: [PATCH 1134/2400] cmd/go: only add a 'go' directive to the main
 module when the go.mod file will be written

Then, write the 'go.mod' file with that version before further
processing. That way, if the command errors out due to a change in
behavior, the reason for the change in behavior will be visible in the
file diffs.

If the 'go.mod' file cannot be written (due to -mod=readonly or
-mod=vendor), assume Go 1.11 instead of the current Go release.
(cmd/go has added 'go' directives automatically, including in 'go mod
init', since Go 1.12.)

For #44976

Change-Id: If9d4af557366f134f40ce4c5638688ba3bab8380
Reviewed-on: https://go-review.googlesource.com/c/go/+/302051
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 doc/go1.17.html                               |  12 ++
 src/cmd/go/internal/modload/build.go          |   8 +-
 src/cmd/go/internal/modload/init.go           | 107 ++++++++++++------
 src/cmd/go/internal/modload/modfile.go        |   5 +-
 src/cmd/go/internal/work/gc.go                |  14 ++-
 src/cmd/go/testdata/script/embed.txt          |   1 +
 .../script/mod_go_version_missing.txt         |  97 ++++++++++++++++
 src/cmd/go/testdata/script/mod_outside.txt    |  14 +++
 src/cmd/go/testdata/script/mod_test.txt       |   2 +
 9 files changed, 219 insertions(+), 41 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/mod_go_version_missing.txt

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 34cfce7a06..22b2ff1156 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -55,6 +55,18 @@ Do not send CLs removing the interior tags from such phrases.
   <code>environment</code> for details.
 </p>
 
+<h4 id="missing-go-directive"><code>go.mod</code> files missing <code>go</code> directives</h4>
+
+<p><!-- golang.org/issue/44976 -->
+  If the main module's <code>go.mod</code> file does not contain
+  a <a href="/doc/modules/gomod-ref#go"><code>go</code> directive</a> and
+  the <code>go</code> command cannot update the <code>go.mod</code> file, the
+  <code>go</code> command now assumes <code>go 1.11</code> instead of the
+  current release. (<code>go</code> <code>mod</code> <code>init</code> has added
+  <code>go</code> directives automatically <a href="/doc/go1.12#modules">since
+  Go 1.12</a>.)
+</p>
+
 <h2 id="runtime">Runtime</h2>
 
 <p>
diff --git a/src/cmd/go/internal/modload/build.go b/src/cmd/go/internal/modload/build.go
index b32997d29e..5f18a38e93 100644
--- a/src/cmd/go/internal/modload/build.go
+++ b/src/cmd/go/internal/modload/build.go
@@ -147,12 +147,14 @@ func moduleInfo(ctx context.Context, m module.Version, fromBuildList, listRetrac
 			Version: m.Version,
 			Main:    true,
 		}
+		if v, ok := rawGoVersion.Load(Target); ok {
+			info.GoVersion = v.(string)
+		} else {
+			panic("internal error: GoVersion not set for main module")
+		}
 		if HasModRoot() {
 			info.Dir = ModRoot()
 			info.GoMod = ModFilePath()
-			if modFile.Go != nil {
-				info.GoVersion = modFile.Go.Version
-			}
 		}
 		return info
 	}
diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index 8ec1c8681a..2466a3bdfd 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -35,11 +35,30 @@ import (
 	"golang.org/x/mod/semver"
 )
 
+// Variables set by other packages.
+//
+// TODO(#40775): See if these can be plumbed as explicit parameters.
+var (
+	// RootMode determines whether a module root is needed.
+	RootMode Root
+
+	// ForceUseModules may be set to force modules to be enabled when
+	// GO111MODULE=auto or to report an error when GO111MODULE=off.
+	ForceUseModules bool
+
+	allowMissingModuleImports bool
+)
+
+// Variables set in Init.
 var (
 	initialized bool
+	modRoot     string
+	gopath      string
+)
 
-	modRoot string
-	Target  module.Version
+// Variables set in initTarget (during {Load,Create}ModFile).
+var (
+	Target module.Version
 
 	// targetPrefix is the path prefix for packages in Target, without a trailing
 	// slash. For most modules, targetPrefix is just Target.Path, but the
@@ -49,17 +68,6 @@ var (
 	// targetInGorootSrc caches whether modRoot is within GOROOT/src.
 	// The "std" module is special within GOROOT/src, but not otherwise.
 	targetInGorootSrc bool
-
-	gopath string
-
-	// RootMode determines whether a module root is needed.
-	RootMode Root
-
-	// ForceUseModules may be set to force modules to be enabled when
-	// GO111MODULE=auto or to report an error when GO111MODULE=off.
-	ForceUseModules bool
-
-	allowMissingModuleImports bool
 )
 
 type Root int
@@ -362,6 +370,7 @@ func LoadModFile(ctx context.Context) {
 		Target = module.Version{Path: "command-line-arguments"}
 		targetPrefix = "command-line-arguments"
 		buildList = []module.Version{Target}
+		rawGoVersion.Store(Target, latestGoVersion())
 		return
 	}
 
@@ -377,24 +386,29 @@ func LoadModFile(ctx context.Context) {
 		// Errors returned by modfile.Parse begin with file:line.
 		base.Fatalf("go: errors parsing go.mod:\n%s\n", err)
 	}
-	modFile = f
-	index = indexModFile(data, f, fixed)
-
 	if f.Module == nil {
 		// No module declaration. Must add module path.
 		base.Fatalf("go: no module declaration in go.mod. To specify the module path:\n\tgo mod edit -module=example.com/mod")
 	}
 
+	modFile = f
+	initTarget(f.Module.Mod)
+	index = indexModFile(data, f, fixed)
+
 	if err := checkModulePathLax(f.Module.Mod.Path); err != nil {
 		base.Fatalf("go: %v", err)
 	}
 
 	setDefaultBuildMod() // possibly enable automatic vendoring
-	modFileToBuildList()
+	buildList = modFileToBuildList(modFile)
 	if cfg.BuildMod == "vendor" {
 		readVendorList()
 		checkVendorConsistency()
 	}
+	if index.goVersionV == "" && cfg.BuildMod == "mod" {
+		addGoStmt()
+		WriteGoMod()
+	}
 }
 
 // CreateModFile initializes a new module by creating a go.mod file.
@@ -427,6 +441,7 @@ func CreateModFile(ctx context.Context, modPath string) {
 	fmt.Fprintf(os.Stderr, "go: creating new go.mod: module %s\n", modPath)
 	modFile = new(modfile.File)
 	modFile.AddModuleStmt(modPath)
+	initTarget(modFile.Module.Mod)
 	addGoStmt() // Add the go directive before converted module requirements.
 
 	convertedFrom, err := convertLegacyConfig(modPath)
@@ -437,7 +452,7 @@ func CreateModFile(ctx context.Context, modPath string) {
 		base.Fatalf("go: %v", err)
 	}
 
-	modFileToBuildList()
+	buildList = modFileToBuildList(modFile)
 	WriteGoMod()
 
 	// Suggest running 'go mod tidy' unless the project is empty. Even if we
@@ -563,19 +578,31 @@ func AllowMissingModuleImports() {
 	allowMissingModuleImports = true
 }
 
-// modFileToBuildList initializes buildList from the modFile.
-func modFileToBuildList() {
-	Target = modFile.Module.Mod
-	targetPrefix = Target.Path
+// initTarget sets Target and associated variables according to modFile,
+func initTarget(m module.Version) {
+	Target = m
+	targetPrefix = m.Path
+
 	if rel := search.InDir(base.Cwd, cfg.GOROOTsrc); rel != "" {
 		targetInGorootSrc = true
-		if Target.Path == "std" {
+		if m.Path == "std" {
+			// The "std" module in GOROOT/src is the Go standard library. Unlike other
+			// modules, the packages in the "std" module have no import-path prefix.
+			//
+			// Modules named "std" outside of GOROOT/src do not receive this special
+			// treatment, so it is possible to run 'go test .' in other GOROOTs to
+			// test individual packages using a combination of the modified package
+			// and the ordinary standard library.
+			// (See https://golang.org/issue/30756.)
 			targetPrefix = ""
 		}
 	}
+}
 
+// modFileToBuildList returns the list of non-excluded requirements from f.
+func modFileToBuildList(f *modfile.File) []module.Version {
 	list := []module.Version{Target}
-	for _, r := range modFile.Require {
+	for _, r := range f.Require {
 		if index != nil && index.exclude[r.Mod] {
 			if cfg.BuildMod == "mod" {
 				fmt.Fprintf(os.Stderr, "go: dropping requirement on excluded version %s %s\n", r.Mod.Path, r.Mod.Version)
@@ -586,7 +613,7 @@ func modFileToBuildList() {
 			list = append(list, r.Mod)
 		}
 	}
-	buildList = list
+	return list
 }
 
 // setDefaultBuildMod sets a default value for cfg.BuildMod if the -mod flag
@@ -650,20 +677,29 @@ func convertLegacyConfig(modPath string) (from string, err error) {
 	return "", nil
 }
 
-// addGoStmt adds a go directive to the go.mod file if it does not already include one.
-// The 'go' version added, if any, is the latest version supported by this toolchain.
+// addGoStmt adds a go directive to the go.mod file if it does not already
+// include one. The 'go' version added, if any, is the latest version supported
+// by this toolchain.
 func addGoStmt() {
 	if modFile.Go != nil && modFile.Go.Version != "" {
 		return
 	}
+	v := latestGoVersion()
+	if err := modFile.AddGoStmt(v); err != nil {
+		base.Fatalf("go: internal error: %v", err)
+	}
+	rawGoVersion.Store(Target, v)
+}
+
+// latestGoVersion returns the latest version of the Go language supported by
+// this toolchain.
+func latestGoVersion() string {
 	tags := build.Default.ReleaseTags
 	version := tags[len(tags)-1]
 	if !strings.HasPrefix(version, "go") || !modfile.GoVersionRE.MatchString(version[2:]) {
 		base.Fatalf("go: unrecognized default version %q", version)
 	}
-	if err := modFile.AddGoStmt(version[2:]); err != nil {
-		base.Fatalf("go: internal error: %v", err)
-	}
+	return version[2:]
 }
 
 var altConfigs = []string{
@@ -880,10 +916,6 @@ func WriteGoMod() {
 		return
 	}
 
-	if cfg.BuildMod != "readonly" {
-		addGoStmt()
-	}
-
 	if loaded != nil {
 		reqs := MinReqs()
 		min, err := reqs.Required(Target)
@@ -1010,7 +1042,12 @@ func keepSums(keepBuildListZips bool) map[module.Version]bool {
 	}
 	buildList, err := mvs.BuildList(Target, reqs)
 	if err != nil {
-		panic(fmt.Sprintf("unexpected error reloading build list: %v", err))
+		// This call to mvs.BuildList should not fail if we have already read the
+		// complete build list. However, the initial “build list” initialized by
+		// modFileToBuildList is not complete: it contains only the explicit
+		// dependencies of the main module. So this call can fair if this is the
+		// first time we have actually loaded the real build list.
+		base.Fatalf("go: %v", err)
 	}
 
 	actualMods := make(map[string]module.Version)
diff --git a/src/cmd/go/internal/modload/modfile.go b/src/cmd/go/internal/modload/modfile.go
index c6667d0bf7..2afa831583 100644
--- a/src/cmd/go/internal/modload/modfile.go
+++ b/src/cmd/go/internal/modload/modfile.go
@@ -257,10 +257,13 @@ func indexModFile(data []byte, modFile *modfile.File, needsFix bool) *modFileInd
 	}
 
 	i.goVersionV = ""
-	if modFile.Go != nil {
+	if modFile.Go == nil {
+		rawGoVersion.Store(Target, "")
+	} else {
 		// We're going to use the semver package to compare Go versions, so go ahead
 		// and add the "v" prefix it expects once instead of every time.
 		i.goVersionV = "v" + modFile.Go.Version
+		rawGoVersion.Store(Target, modFile.Go.Version)
 	}
 
 	i.require = make(map[module.Version]requireMeta, len(modFile.Require))
diff --git a/src/cmd/go/internal/work/gc.go b/src/cmd/go/internal/work/gc.go
index 3cb7c5aff3..0fb6156c5a 100644
--- a/src/cmd/go/internal/work/gc.go
+++ b/src/cmd/go/internal/work/gc.go
@@ -63,8 +63,18 @@ func (gcToolchain) gc(b *Builder, a *Action, archive string, importcfg, embedcfg
 
 	pkgpath := pkgPath(a)
 	gcargs := []string{"-p", pkgpath}
-	if p.Module != nil && p.Module.GoVersion != "" && allowedVersion(p.Module.GoVersion) {
-		gcargs = append(gcargs, "-lang=go"+p.Module.GoVersion)
+	if p.Module != nil {
+		v := p.Module.GoVersion
+		if v == "" {
+			// We started adding a 'go' directive to the go.mod file unconditionally
+			// as of Go 1.12, so any module that still lacks such a directive must
+			// either have been authored before then, or have a hand-edited go.mod
+			// file that hasn't been updated by cmd/go since that edit.
+			v = "1.11"
+		}
+		if allowedVersion(v) {
+			gcargs = append(gcargs, "-lang=go"+v)
+		}
 	}
 	if p.Standard {
 		gcargs = append(gcargs, "-std")
diff --git a/src/cmd/go/testdata/script/embed.txt b/src/cmd/go/testdata/script/embed.txt
index 6ad42e9cd1..04b17cd62b 100644
--- a/src/cmd/go/testdata/script/embed.txt
+++ b/src/cmd/go/testdata/script/embed.txt
@@ -107,3 +107,4 @@ import _ "m"
 -- go.mod --
 module m
 
+go 1.16
diff --git a/src/cmd/go/testdata/script/mod_go_version_missing.txt b/src/cmd/go/testdata/script/mod_go_version_missing.txt
new file mode 100644
index 0000000000..43ddea7954
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_go_version_missing.txt
@@ -0,0 +1,97 @@
+cp go.mod go.mod.orig
+
+# With -mod=readonly, we should not update the go version in use.
+#
+# We started adding the go version automatically in Go 1.12, so a module without
+# one encountered in the wild (such as in the module cache) should assume Go
+# 1.11 semantics.
+
+# For Go 1.11 modules, 'all' should include dependencies of tests.
+# (They are pruned out as of Go 1.16.)
+
+go list -mod=readonly all
+stdout '^example.com/dep$'
+stdout '^example.com/testdep$'
+cp stdout list-1.txt
+cmp go.mod go.mod.orig
+
+# For Go 1.11 modules, automatic vendoring should not take effect.
+# (That behavior was added in Go 1.14.)
+
+go list all  # should default to -mod=readonly, not -mod=vendor.
+cmp stdout list-1.txt
+
+# When we set -mod=mod, the go version should be updated immediately,
+# narrowing the "all" pattern reported by that command.
+
+go list -mod=mod all
+! stdout '^example.com/testdep$'
+cp stdout list-2.txt
+cmpenv go.mod go.mod.want
+
+go list -mod=mod all
+cmp stdout list-2.txt
+
+# The updated version should have been written back to go.mod, so
+# automatic vendoring should come into effect (and fail).
+! go list all
+stderr '^go: inconsistent vendoring'
+
+cp go.mod.orig go.mod
+
+# In readonly or vendor mode (not -mod=mod), the inferred Go version is 1.11.
+# For Go 1.11 modules, Go 1.13 features should not be enabled.
+
+! go build -mod=readonly .
+stderr '^# example\.com/m\n\.[/\\]m\.go:5:11: underscores in numeric literals requires go1\.13 or later \(-lang was set to go1\.11; check go\.mod\)$'
+cmp go.mod go.mod.orig
+
+
+-- go.mod --
+module example.com/m
+
+require example.com/dep v0.1.0
+
+replace (
+	example.com/dep v0.1.0 => ./dep
+	example.com/testdep v0.1.0 => ./testdep
+)
+-- go.mod.want --
+module example.com/m
+
+go $goversion
+
+require example.com/dep v0.1.0
+
+replace (
+	example.com/dep v0.1.0 => ./dep
+	example.com/testdep v0.1.0 => ./testdep
+)
+-- vendor/example.com/dep/dep.go --
+package dep
+import _ "example.com/bananas"
+-- vendor/modules.txt --
+HAHAHA this is broken.
+
+-- m.go --
+package m
+
+import _ "example.com/dep"
+
+const x = 1_000
+
+-- dep/go.mod --
+module example.com/dep
+
+require example.com/testdep v0.1.0
+-- dep/dep.go --
+package dep
+-- dep/dep_test.go --
+package dep_test
+
+import _ "example.com/testdep"
+
+-- testdep/go.mod --
+module example.com/testdep
+-- testdep/testdep.go --
+package testdep
diff --git a/src/cmd/go/testdata/script/mod_outside.txt b/src/cmd/go/testdata/script/mod_outside.txt
index 7c57db9f7c..0b01492cde 100644
--- a/src/cmd/go/testdata/script/mod_outside.txt
+++ b/src/cmd/go/testdata/script/mod_outside.txt
@@ -169,6 +169,8 @@ go build -n -o ignore ./stdonly/stdonly.go
 # 'go build' should succeed for standard-library packages.
 go build -n fmt
 
+# 'go build' should use the latest version of the Go language.
+go build ./newgo/newgo.go
 
 # 'go doc' without arguments implicitly operates on the current directory, and should fail.
 # TODO(golang.org/issue/32027): currently, it succeeds.
@@ -331,3 +333,15 @@ func Test(t *testing.T) {
 	fmt.Println("stdonly was tested")
 }
 
+-- newgo/newgo.go --
+// Package newgo requires Go 1.14 or newer.
+package newgo
+
+import "io"
+
+const C = 299_792_458
+
+type ReadWriteCloser interface {
+	io.ReadCloser
+	io.WriteCloser
+}
diff --git a/src/cmd/go/testdata/script/mod_test.txt b/src/cmd/go/testdata/script/mod_test.txt
index 50f00355c1..76f1d7a9a4 100644
--- a/src/cmd/go/testdata/script/mod_test.txt
+++ b/src/cmd/go/testdata/script/mod_test.txt
@@ -60,6 +60,8 @@ go list -test
 -- a/go.mod.empty --
 module example.com/user/a
 
+go 1.11
+
 -- a/a.go --
 package a
 
-- 
GitLab


From f82ce7fb230c0c0934be8975bd8b56c953c29422 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Wed, 17 Mar 2021 14:15:28 -0700
Subject: [PATCH 1135/2400] cmd/link: improve nonexistent package error message

Change-Id: I207541efa6a34bc21e7a00584376622b59e2bf6d
Reviewed-on: https://go-review.googlesource.com/c/go/+/302749
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/link/internal/loader/loader.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/link/internal/loader/loader.go b/src/cmd/link/internal/loader/loader.go
index 5df4348a36..668e698cbf 100644
--- a/src/cmd/link/internal/loader/loader.go
+++ b/src/cmd/link/internal/loader/loader.go
@@ -2208,7 +2208,7 @@ func loadObjRefs(l *Loader, r *oReader, arch *sys.Arch) {
 		pkg := r.Pkg(i)
 		objidx, ok := l.objByPkg[pkg]
 		if !ok {
-			log.Fatalf("reference of nonexisted package %s, from %v", pkg, r.unit.Lib)
+			log.Fatalf("%v: reference to nonexistent package %s", r.unit.Lib, pkg)
 		}
 		r.pkg[i] = objidx
 	}
-- 
GitLab


From f38b6428a2d1beae784a9402368e4d7f9c7cd8c5 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Wed, 17 Mar 2021 11:17:02 +0100
Subject: [PATCH 1136/2400] crypto/rand, internal/syscall/unix: add support for
 getentropy syscall on darwin

The getentropy syscall is available on macOS since version 10.12, which
is the minimum required version since Go 1.15.

Change-Id: I294259af0b11df9669e4dc5fa891d2f2f039d91a
Reviewed-on: https://go-review.googlesource.com/c/go/+/302489
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 .../{rand_openbsd.go => rand_getentropy.go}   |  7 ++--
 src/internal/syscall/unix/asm_darwin.s        |  8 +++++
 .../syscall/unix/getentropy_darwin.go         | 32 +++++++++++++++++++
 3 files changed, 45 insertions(+), 2 deletions(-)
 rename src/crypto/rand/{rand_openbsd.go => rand_getentropy.go} (79%)
 create mode 100644 src/internal/syscall/unix/asm_darwin.s
 create mode 100644 src/internal/syscall/unix/getentropy_darwin.go

diff --git a/src/crypto/rand/rand_openbsd.go b/src/crypto/rand/rand_getentropy.go
similarity index 79%
rename from src/crypto/rand/rand_openbsd.go
rename to src/crypto/rand/rand_getentropy.go
index 9cc39f72d1..f82018a495 100644
--- a/src/crypto/rand/rand_openbsd.go
+++ b/src/crypto/rand/rand_getentropy.go
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin || openbsd
+// +build darwin openbsd
+
 package rand
 
 import (
@@ -9,10 +12,10 @@ import (
 )
 
 func init() {
-	altGetRandom = getRandomOpenBSD
+	altGetRandom = getEntropy
 }
 
-func getRandomOpenBSD(p []byte) (ok bool) {
+func getEntropy(p []byte) (ok bool) {
 	// getentropy(2) returns a maximum of 256 bytes per call
 	for i := 0; i < len(p); i += 256 {
 		end := i + 256
diff --git a/src/internal/syscall/unix/asm_darwin.s b/src/internal/syscall/unix/asm_darwin.s
new file mode 100644
index 0000000000..8fbdc1d866
--- /dev/null
+++ b/src/internal/syscall/unix/asm_darwin.s
@@ -0,0 +1,8 @@
+// Copyright 2021 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.
+
+#include "textflag.h"
+
+TEXT ·libc_getentropy_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getentropy(SB)
diff --git a/src/internal/syscall/unix/getentropy_darwin.go b/src/internal/syscall/unix/getentropy_darwin.go
new file mode 100644
index 0000000000..6da6f84d95
--- /dev/null
+++ b/src/internal/syscall/unix/getentropy_darwin.go
@@ -0,0 +1,32 @@
+// Copyright 2021 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 unix
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+//go:cgo_import_dynamic libc_getentropy getentropy "/usr/lib/libSystem.B.dylib"
+
+func libc_getentropy_trampoline()
+
+// GetEntropy calls the macOS getentropy system call.
+func GetEntropy(p []byte) error {
+	_, _, errno := syscall_syscall(funcPC(libc_getentropy_trampoline),
+		uintptr(unsafe.Pointer(&p[0])),
+		uintptr(len(p)),
+		0)
+	if errno != 0 {
+		return errno
+	}
+	return nil
+}
+
+//go:linkname syscall_syscall syscall.syscall
+func syscall_syscall(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno)
+
+//go:linkname funcPC runtime.funcPC
+func funcPC(f interface{}) uintptr
-- 
GitLab


From 2583c1b4df979eae16fab6527275030a630da42b Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 17 Mar 2021 16:49:02 -0700
Subject: [PATCH 1137/2400] go/types: add test case for issue #45096

This verifies that issue #45096 is not an issue for go/types.

Updates #45096.

Change-Id: I4e987b5d4928f0c864d0d2c0379149443beb4d5c
Reviewed-on: https://go-review.googlesource.com/c/go/+/302754
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/go/types/api_test.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go
index 0226a857bd..427aa04e47 100644
--- a/src/go/types/api_test.go
+++ b/src/go/types/api_test.go
@@ -341,6 +341,9 @@ func TestTypesInfo(t *testing.T) {
 
 		// instantiated types must be sanitized
 		{genericPkg + `g0; type t[P any] int; var x struct{ f t[int] }; var _ = x.f`, `x.f`, `generic_g0.t[int]`},
+
+		// issue 45096
+		{genericPkg + `issue45096; func _[T interface{ type int8, int16, int32  }](x T) { _ = x < 0 }`, `0`, `T₁`},
 	}
 
 	for _, test := range tests {
-- 
GitLab


From 51e4bb236cb8feb8118ed6dd768ddac834dad2ef Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 17 Mar 2021 16:59:47 -0700
Subject: [PATCH 1138/2400] cmd/compile/internal/types2: delay recording types
 of untyped operands when checking against type parameters

Don't eagerly record the target type for an untyped operand if the
target type is just one of possibly many types in the type list of
a type parameter. Instead, record expression type only after we
checked that all types in the type list are ok.

Also, update assertion in Checker.recordTypeAndValue since (currently),
a type parameter is not considered a const type. We may change that,
eventually.

This is a temporary (but working) solution. Eventually we should
copy the approach taken in go/types.

Fixes #45096.

Change-Id: Icf61ee893aca6ead32bfc45ee5831572e672357b
Reviewed-on: https://go-review.googlesource.com/c/go/+/302755
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/types2/api_test.go |  3 +++
 src/cmd/compile/internal/types2/check.go    |  4 +++-
 src/cmd/compile/internal/types2/expr.go     | 16 ++++++++++------
 3 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go
index 9d23b5b2a6..a06a073f97 100644
--- a/src/cmd/compile/internal/types2/api_test.go
+++ b/src/cmd/compile/internal/types2/api_test.go
@@ -337,6 +337,9 @@ func TestTypesInfo(t *testing.T) {
 
 		// instantiated types must be sanitized
 		{`package g0; type t[P any] int; var x struct{ f t[int] }; var _ = x.f`, `x.f`, `g0.t[int]`},
+
+		// issue 45096
+		{`package issue45096; func _[T interface{ type int8, int16, int32  }](x T) { _ = x < 0 }`, `0`, `T₁`},
 	}
 
 	for _, test := range tests {
diff --git a/src/cmd/compile/internal/types2/check.go b/src/cmd/compile/internal/types2/check.go
index 7c1d4eae56..c65666e802 100644
--- a/src/cmd/compile/internal/types2/check.go
+++ b/src/cmd/compile/internal/types2/check.go
@@ -335,7 +335,9 @@ func (check *Checker) recordTypeAndValue(x syntax.Expr, mode operandMode, typ Ty
 	}
 	if mode == constant_ {
 		assert(val != nil)
-		assert(typ == Typ[Invalid] || isConstType(typ))
+		// We check is(typ, IsConstType) here as constant expressions may be
+		// recorded as type parameters.
+		assert(typ == Typ[Invalid] || is(typ, IsConstType))
 	}
 	if m := check.Types; m != nil {
 		m[x] = TypeAndValue{mode, typ, val}
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index b89eb199eb..4cdec84604 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -628,7 +628,7 @@ func (check *Checker) convertUntyped(x *operand, target Type) {
 
 		for _, t := range unpack(types) {
 			x := *x // make a copy; convertUntypedInternal modifies x
-			check.convertUntypedInternal(&x, t)
+			check.convertUntypedInternal(&x, t, false)
 			if x.mode == invalid {
 				goto Error
 			}
@@ -639,7 +639,7 @@ func (check *Checker) convertUntyped(x *operand, target Type) {
 		return
 	}
 
-	check.convertUntypedInternal(x, target)
+	check.convertUntypedInternal(x, target, true)
 	return
 
 Error:
@@ -649,7 +649,7 @@ Error:
 }
 
 // convertUntypedInternal should only be called by convertUntyped.
-func (check *Checker) convertUntypedInternal(x *operand, target Type) {
+func (check *Checker) convertUntypedInternal(x *operand, target Type, update bool) {
 	assert(isTyped(target))
 
 	if x.isNil() {
@@ -669,7 +669,9 @@ func (check *Checker) convertUntypedInternal(x *operand, target Type) {
 				return
 			}
 			// expression value may have been rounded - update if needed
-			check.updateExprVal(x.expr, x.val)
+			if update {
+				check.updateExprVal(x.expr, x.val)
+			}
 		} else {
 			// Non-constant untyped values may appear as the
 			// result of comparisons (untyped bool), intermediate
@@ -694,7 +696,7 @@ func (check *Checker) convertUntypedInternal(x *operand, target Type) {
 		}
 	case *Sum:
 		t.is(func(t Type) bool {
-			check.convertUntypedInternal(x, t)
+			check.convertUntypedInternal(x, t, false)
 			return x.mode != invalid
 		})
 	case *Interface:
@@ -712,7 +714,9 @@ func (check *Checker) convertUntypedInternal(x *operand, target Type) {
 
 OK:
 	x.typ = target
-	check.updateExprType(x.expr, target, true)
+	if update {
+		check.updateExprType(x.expr, target, true)
+	}
 	return
 
 Error:
-- 
GitLab


From f5e6d3e879f487066d1a05b8000a7187247558f7 Mon Sep 17 00:00:00 2001
From: fanzha02 <fannie.zhang@arm.com>
Date: Mon, 18 Jan 2021 14:32:49 +0800
Subject: [PATCH 1139/2400] cmd/compile: add rewrite rules for conditional
 instructions on arm64

This CL adds rewrite rules for CSETM, CSINC, CSINV, and CSNEG. By adding
these rules, we can save one instruction.

For example,

  func test(cond bool, a int) int {
    if cond {
      a++
    }
    return a
  }

Before:

  MOVD "".a+8(RSP), R0
  ADD $1, R0, R1
  MOVBU "".cond(RSP), R2
  CMPW $0, R2
  CSEL NE, R1, R0, R0

After:

  MOVBU "".cond(RSP), R0
  CMPW $0, R0
  MOVD "".a+8(RSP), R0
  CSINC EQ, R0, R0, R0

This patch is a copy of CL 285694. Co-authored-by: JunchenLi
<junchen.li@arm.com>

Change-Id: Ic1a79e8b8ece409b533becfcb7950f11e7b76f24
Reviewed-on: https://go-review.googlesource.com/c/go/+/302231
Trust: fannie zhang <Fannie.Zhang@arm.com>
Run-TryBot: fannie zhang <Fannie.Zhang@arm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/arm64/ssa.go        |  14 ++
 src/cmd/compile/internal/ssa/gen/ARM64.rules |  16 +-
 src/cmd/compile/internal/ssa/gen/ARM64Ops.go |   8 +-
 src/cmd/compile/internal/ssa/opGen.go        |  60 ++++++
 src/cmd/compile/internal/ssa/rewriteARM64.go | 204 +++++++++++++++++++
 test/codegen/condmove.go                     | 198 +++++++++++++++++-
 6 files changed, 494 insertions(+), 6 deletions(-)

diff --git a/src/cmd/compile/internal/arm64/ssa.go b/src/cmd/compile/internal/arm64/ssa.go
index 056a6eb62d..3250b49c92 100644
--- a/src/cmd/compile/internal/arm64/ssa.go
+++ b/src/cmd/compile/internal/arm64/ssa.go
@@ -956,6 +956,20 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.SetFrom3Reg(r1)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
+	case ssa.OpARM64CSINC, ssa.OpARM64CSINV, ssa.OpARM64CSNEG:
+		p := s.Prog(v.Op.Asm())
+		p.From.Type = obj.TYPE_REG // assembler encodes conditional bits in Reg
+		p.From.Reg = condBits[ssa.Op(v.AuxInt)]
+		p.Reg = v.Args[0].Reg()
+		p.SetFrom3Reg(v.Args[1].Reg())
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = v.Reg()
+	case ssa.OpARM64CSETM:
+		p := s.Prog(arm64.ACSETM)
+		p.From.Type = obj.TYPE_REG // assembler encodes conditional bits in Reg
+		p.From.Reg = condBits[ssa.Op(v.AuxInt)]
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = v.Reg()
 	case ssa.OpARM64DUFFZERO:
 		// runtime.duffzero expects start address in R20
 		p := s.Prog(obj.ADUFFZERO)
diff --git a/src/cmd/compile/internal/ssa/gen/ARM64.rules b/src/cmd/compile/internal/ssa/gen/ARM64.rules
index ea912f9f97..6f30c11bd1 100644
--- a/src/cmd/compile/internal/ssa/gen/ARM64.rules
+++ b/src/cmd/compile/internal/ssa/gen/ARM64.rules
@@ -1359,8 +1359,18 @@
 (XOR x (MVN y)) => (EON x y)
 (OR  x (MVN y)) => (ORN x y)
 (MVN (XOR x y)) => (EON x y)
+
+(CSEL [cc] (MOVDconst [-1]) (MOVDconst [0]) flag) => (CSETM [cc] flag)
+(CSEL [cc] (MOVDconst [0]) (MOVDconst [-1]) flag) => (CSETM [arm64Negate(cc)] flag)
 (CSEL [cc] x (MOVDconst [0]) flag) => (CSEL0 [cc] x flag)
 (CSEL [cc] (MOVDconst [0]) y flag) => (CSEL0 [arm64Negate(cc)] y flag)
+(CSEL [cc] x (ADDconst [1] a) flag) => (CSINC [cc] x a flag)
+(CSEL [cc] (ADDconst [1] a) x flag) => (CSINC [arm64Negate(cc)] x a flag)
+(CSEL [cc] x (MVN a) flag) => (CSINV [cc] x a flag)
+(CSEL [cc] (MVN a) x flag) => (CSINV [arm64Negate(cc)] x a flag)
+(CSEL [cc] x (NEG a) flag) => (CSNEG [cc] x a flag)
+(CSEL [cc] (NEG a) x flag) => (CSNEG [arm64Negate(cc)] x a flag)
+
 (SUB x (SUB y z)) => (SUB (ADD <v.Type> x z) y)
 (SUB (SUB x y) z) => (SUB x (ADD <y.Type> y z))
 
@@ -1515,9 +1525,13 @@
 (LEnoov (InvertFlags cmp) yes no) => (GEnoov cmp yes no)
 (GTnoov (InvertFlags cmp) yes no) => (LTnoov cmp yes no)
 
-// absorb InvertFlags into CSEL(0)
+// absorb InvertFlags into conditional instructions
 (CSEL [cc] x y (InvertFlags cmp)) => (CSEL [arm64Invert(cc)] x y cmp)
 (CSEL0 [cc] x (InvertFlags cmp)) => (CSEL0 [arm64Invert(cc)] x cmp)
+(CSETM [cc] (InvertFlags cmp)) => (CSETM [arm64Invert(cc)] cmp)
+(CSINC [cc] x y (InvertFlags cmp)) => (CSINC [arm64Invert(cc)] x y cmp)
+(CSINV [cc] x y (InvertFlags cmp)) => (CSINV [arm64Invert(cc)] x y cmp)
+(CSNEG [cc] x y (InvertFlags cmp)) => (CSNEG [arm64Invert(cc)] x y cmp)
 
 // absorb flag constants into boolean values
 (Equal (FlagConstant [fc])) => (MOVDconst [b2i(fc.eq())])
diff --git a/src/cmd/compile/internal/ssa/gen/ARM64Ops.go b/src/cmd/compile/internal/ssa/gen/ARM64Ops.go
index 0a4fd14b2b..59a5ffaca4 100644
--- a/src/cmd/compile/internal/ssa/gen/ARM64Ops.go
+++ b/src/cmd/compile/internal/ssa/gen/ARM64Ops.go
@@ -472,8 +472,12 @@ func init() {
 
 		// conditional instructions; auxint is
 		// one of the arm64 comparison pseudo-ops (LessThan, LessThanU, etc.)
-		{name: "CSEL", argLength: 3, reg: gp2flags1, asm: "CSEL", aux: "CCop"},  // auxint(flags) ? arg0 : arg1
-		{name: "CSEL0", argLength: 2, reg: gp1flags1, asm: "CSEL", aux: "CCop"}, // auxint(flags) ? arg0 : 0
+		{name: "CSEL", argLength: 3, reg: gp2flags1, asm: "CSEL", aux: "CCop"},   // auxint(flags) ? arg0 : arg1
+		{name: "CSEL0", argLength: 2, reg: gp1flags1, asm: "CSEL", aux: "CCop"},  // auxint(flags) ? arg0 : 0
+		{name: "CSINC", argLength: 3, reg: gp2flags1, asm: "CSINC", aux: "CCop"}, // auxint(flags) ? arg0 : arg1 + 1
+		{name: "CSINV", argLength: 3, reg: gp2flags1, asm: "CSINV", aux: "CCop"}, // auxint(flags) ? arg0 : ^arg1
+		{name: "CSNEG", argLength: 3, reg: gp2flags1, asm: "CSNEG", aux: "CCop"}, // auxint(flags) ? arg0 : -arg1
+		{name: "CSETM", argLength: 1, reg: readflags, asm: "CSETM", aux: "CCop"}, // auxint(flags) ? -1 : 0
 
 		// function calls
 		{name: "CALLstatic", argLength: 1, reg: regInfo{clobbers: callerSave}, aux: "CallOff", clobberFlags: true, call: true},                                               // call static function aux.(*obj.LSym).  arg0=mem, auxint=argsize, returns mem
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index 322e1c2283..436a79a173 100644
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -1556,6 +1556,10 @@ const (
 	OpARM64FRINTZD
 	OpARM64CSEL
 	OpARM64CSEL0
+	OpARM64CSINC
+	OpARM64CSINV
+	OpARM64CSNEG
+	OpARM64CSETM
 	OpARM64CALLstatic
 	OpARM64CALLclosure
 	OpARM64CALLinter
@@ -20774,6 +20778,62 @@ var opcodeTable = [...]opInfo{
 			},
 		},
 	},
+	{
+		name:    "CSINC",
+		auxType: auxCCop,
+		argLen:  3,
+		asm:     arm64.ACSINC,
+		reg: regInfo{
+			inputs: []inputInfo{
+				{0, 670826495}, // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R19 R20 R21 R22 R23 R24 R25 R26 R30
+				{1, 670826495}, // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R19 R20 R21 R22 R23 R24 R25 R26 R30
+			},
+			outputs: []outputInfo{
+				{0, 670826495}, // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R19 R20 R21 R22 R23 R24 R25 R26 R30
+			},
+		},
+	},
+	{
+		name:    "CSINV",
+		auxType: auxCCop,
+		argLen:  3,
+		asm:     arm64.ACSINV,
+		reg: regInfo{
+			inputs: []inputInfo{
+				{0, 670826495}, // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R19 R20 R21 R22 R23 R24 R25 R26 R30
+				{1, 670826495}, // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R19 R20 R21 R22 R23 R24 R25 R26 R30
+			},
+			outputs: []outputInfo{
+				{0, 670826495}, // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R19 R20 R21 R22 R23 R24 R25 R26 R30
+			},
+		},
+	},
+	{
+		name:    "CSNEG",
+		auxType: auxCCop,
+		argLen:  3,
+		asm:     arm64.ACSNEG,
+		reg: regInfo{
+			inputs: []inputInfo{
+				{0, 670826495}, // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R19 R20 R21 R22 R23 R24 R25 R26 R30
+				{1, 670826495}, // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R19 R20 R21 R22 R23 R24 R25 R26 R30
+			},
+			outputs: []outputInfo{
+				{0, 670826495}, // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R19 R20 R21 R22 R23 R24 R25 R26 R30
+			},
+		},
+	},
+	{
+		name:    "CSETM",
+		auxType: auxCCop,
+		argLen:  1,
+		asm:     arm64.ACSETM,
+		reg: regInfo{
+			outputs: []outputInfo{
+				{0, 670826495}, // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R19 R20 R21 R22 R23 R24 R25 R26 R30
+			},
+		},
+	},
 	{
 		name:         "CALLstatic",
 		auxType:      auxCallOff,
diff --git a/src/cmd/compile/internal/ssa/rewriteARM64.go b/src/cmd/compile/internal/ssa/rewriteARM64.go
index 55bb486600..da80ad6fca 100644
--- a/src/cmd/compile/internal/ssa/rewriteARM64.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM64.go
@@ -69,6 +69,14 @@ func rewriteValueARM64(v *Value) bool {
 		return rewriteValueARM64_OpARM64CSEL(v)
 	case OpARM64CSEL0:
 		return rewriteValueARM64_OpARM64CSEL0(v)
+	case OpARM64CSETM:
+		return rewriteValueARM64_OpARM64CSETM(v)
+	case OpARM64CSINC:
+		return rewriteValueARM64_OpARM64CSINC(v)
+	case OpARM64CSINV:
+		return rewriteValueARM64_OpARM64CSINV(v)
+	case OpARM64CSNEG:
+		return rewriteValueARM64_OpARM64CSNEG(v)
 	case OpARM64DIV:
 		return rewriteValueARM64_OpARM64DIV(v)
 	case OpARM64DIVW:
@@ -3215,6 +3223,32 @@ func rewriteValueARM64_OpARM64CSEL(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
+	// match: (CSEL [cc] (MOVDconst [-1]) (MOVDconst [0]) flag)
+	// result: (CSETM [cc] flag)
+	for {
+		cc := auxIntToOp(v.AuxInt)
+		if v_0.Op != OpARM64MOVDconst || auxIntToInt64(v_0.AuxInt) != -1 || v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
+			break
+		}
+		flag := v_2
+		v.reset(OpARM64CSETM)
+		v.AuxInt = opToAuxInt(cc)
+		v.AddArg(flag)
+		return true
+	}
+	// match: (CSEL [cc] (MOVDconst [0]) (MOVDconst [-1]) flag)
+	// result: (CSETM [arm64Negate(cc)] flag)
+	for {
+		cc := auxIntToOp(v.AuxInt)
+		if v_0.Op != OpARM64MOVDconst || auxIntToInt64(v_0.AuxInt) != 0 || v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != -1 {
+			break
+		}
+		flag := v_2
+		v.reset(OpARM64CSETM)
+		v.AuxInt = opToAuxInt(arm64Negate(cc))
+		v.AddArg(flag)
+		return true
+	}
 	// match: (CSEL [cc] x (MOVDconst [0]) flag)
 	// result: (CSEL0 [cc] x flag)
 	for {
@@ -3243,6 +3277,96 @@ func rewriteValueARM64_OpARM64CSEL(v *Value) bool {
 		v.AddArg2(y, flag)
 		return true
 	}
+	// match: (CSEL [cc] x (ADDconst [1] a) flag)
+	// result: (CSINC [cc] x a flag)
+	for {
+		cc := auxIntToOp(v.AuxInt)
+		x := v_0
+		if v_1.Op != OpARM64ADDconst || auxIntToInt64(v_1.AuxInt) != 1 {
+			break
+		}
+		a := v_1.Args[0]
+		flag := v_2
+		v.reset(OpARM64CSINC)
+		v.AuxInt = opToAuxInt(cc)
+		v.AddArg3(x, a, flag)
+		return true
+	}
+	// match: (CSEL [cc] (ADDconst [1] a) x flag)
+	// result: (CSINC [arm64Negate(cc)] x a flag)
+	for {
+		cc := auxIntToOp(v.AuxInt)
+		if v_0.Op != OpARM64ADDconst || auxIntToInt64(v_0.AuxInt) != 1 {
+			break
+		}
+		a := v_0.Args[0]
+		x := v_1
+		flag := v_2
+		v.reset(OpARM64CSINC)
+		v.AuxInt = opToAuxInt(arm64Negate(cc))
+		v.AddArg3(x, a, flag)
+		return true
+	}
+	// match: (CSEL [cc] x (MVN a) flag)
+	// result: (CSINV [cc] x a flag)
+	for {
+		cc := auxIntToOp(v.AuxInt)
+		x := v_0
+		if v_1.Op != OpARM64MVN {
+			break
+		}
+		a := v_1.Args[0]
+		flag := v_2
+		v.reset(OpARM64CSINV)
+		v.AuxInt = opToAuxInt(cc)
+		v.AddArg3(x, a, flag)
+		return true
+	}
+	// match: (CSEL [cc] (MVN a) x flag)
+	// result: (CSINV [arm64Negate(cc)] x a flag)
+	for {
+		cc := auxIntToOp(v.AuxInt)
+		if v_0.Op != OpARM64MVN {
+			break
+		}
+		a := v_0.Args[0]
+		x := v_1
+		flag := v_2
+		v.reset(OpARM64CSINV)
+		v.AuxInt = opToAuxInt(arm64Negate(cc))
+		v.AddArg3(x, a, flag)
+		return true
+	}
+	// match: (CSEL [cc] x (NEG a) flag)
+	// result: (CSNEG [cc] x a flag)
+	for {
+		cc := auxIntToOp(v.AuxInt)
+		x := v_0
+		if v_1.Op != OpARM64NEG {
+			break
+		}
+		a := v_1.Args[0]
+		flag := v_2
+		v.reset(OpARM64CSNEG)
+		v.AuxInt = opToAuxInt(cc)
+		v.AddArg3(x, a, flag)
+		return true
+	}
+	// match: (CSEL [cc] (NEG a) x flag)
+	// result: (CSNEG [arm64Negate(cc)] x a flag)
+	for {
+		cc := auxIntToOp(v.AuxInt)
+		if v_0.Op != OpARM64NEG {
+			break
+		}
+		a := v_0.Args[0]
+		x := v_1
+		flag := v_2
+		v.reset(OpARM64CSNEG)
+		v.AuxInt = opToAuxInt(arm64Negate(cc))
+		v.AddArg3(x, a, flag)
+		return true
+	}
 	// match: (CSEL [cc] x y (InvertFlags cmp))
 	// result: (CSEL [arm64Invert(cc)] x y cmp)
 	for {
@@ -3405,6 +3529,86 @@ func rewriteValueARM64_OpARM64CSEL0(v *Value) bool {
 	}
 	return false
 }
+func rewriteValueARM64_OpARM64CSETM(v *Value) bool {
+	v_0 := v.Args[0]
+	// match: (CSETM [cc] (InvertFlags cmp))
+	// result: (CSETM [arm64Invert(cc)] cmp)
+	for {
+		cc := auxIntToOp(v.AuxInt)
+		if v_0.Op != OpARM64InvertFlags {
+			break
+		}
+		cmp := v_0.Args[0]
+		v.reset(OpARM64CSETM)
+		v.AuxInt = opToAuxInt(arm64Invert(cc))
+		v.AddArg(cmp)
+		return true
+	}
+	return false
+}
+func rewriteValueARM64_OpARM64CSINC(v *Value) bool {
+	v_2 := v.Args[2]
+	v_1 := v.Args[1]
+	v_0 := v.Args[0]
+	// match: (CSINC [cc] x y (InvertFlags cmp))
+	// result: (CSINC [arm64Invert(cc)] x y cmp)
+	for {
+		cc := auxIntToOp(v.AuxInt)
+		x := v_0
+		y := v_1
+		if v_2.Op != OpARM64InvertFlags {
+			break
+		}
+		cmp := v_2.Args[0]
+		v.reset(OpARM64CSINC)
+		v.AuxInt = opToAuxInt(arm64Invert(cc))
+		v.AddArg3(x, y, cmp)
+		return true
+	}
+	return false
+}
+func rewriteValueARM64_OpARM64CSINV(v *Value) bool {
+	v_2 := v.Args[2]
+	v_1 := v.Args[1]
+	v_0 := v.Args[0]
+	// match: (CSINV [cc] x y (InvertFlags cmp))
+	// result: (CSINV [arm64Invert(cc)] x y cmp)
+	for {
+		cc := auxIntToOp(v.AuxInt)
+		x := v_0
+		y := v_1
+		if v_2.Op != OpARM64InvertFlags {
+			break
+		}
+		cmp := v_2.Args[0]
+		v.reset(OpARM64CSINV)
+		v.AuxInt = opToAuxInt(arm64Invert(cc))
+		v.AddArg3(x, y, cmp)
+		return true
+	}
+	return false
+}
+func rewriteValueARM64_OpARM64CSNEG(v *Value) bool {
+	v_2 := v.Args[2]
+	v_1 := v.Args[1]
+	v_0 := v.Args[0]
+	// match: (CSNEG [cc] x y (InvertFlags cmp))
+	// result: (CSNEG [arm64Invert(cc)] x y cmp)
+	for {
+		cc := auxIntToOp(v.AuxInt)
+		x := v_0
+		y := v_1
+		if v_2.Op != OpARM64InvertFlags {
+			break
+		}
+		cmp := v_2.Args[0]
+		v.reset(OpARM64CSNEG)
+		v.AuxInt = opToAuxInt(arm64Invert(cc))
+		v.AddArg3(x, y, cmp)
+		return true
+	}
+	return false
+}
 func rewriteValueARM64_OpARM64DIV(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
diff --git a/test/codegen/condmove.go b/test/codegen/condmove.go
index 7579dd1890..707f223fa3 100644
--- a/test/codegen/condmove.go
+++ b/test/codegen/condmove.go
@@ -32,7 +32,7 @@ func cmovuintptr(x, y uintptr) uintptr {
 		x = -y
 	}
 	// amd64:"CMOVQ(HI|CS)"
-	// arm64:"CSEL\t(LO|HI)"
+	// arm64:"CSNEG\tLS"
 	// wasm:"Select"
 	return x
 }
@@ -42,7 +42,7 @@ func cmov32bit(x, y uint32) uint32 {
 		x = -y
 	}
 	// amd64:"CMOVL(HI|CS)"
-	// arm64:"CSEL\t(LO|HI)"
+	// arm64:"CSNEG\t(LS|HS)"
 	// wasm:"Select"
 	return x
 }
@@ -52,7 +52,7 @@ func cmov16bit(x, y uint16) uint16 {
 		x = -y
 	}
 	// amd64:"CMOVW(HI|CS)"
-	// arm64:"CSEL\t(LO|HI)"
+	// arm64:"CSNEG\t(LS|HS)"
 	// wasm:"Select"
 	return x
 }
@@ -208,3 +208,195 @@ func cmovstore(a []int, i int, b bool) {
 	// amd64:"CMOVQNE"
 	a[i] = 7
 }
+
+var r0, r1, r2, r3, r4, r5 int
+
+func cmovinc(cond bool, a, b, c int) {
+	var x0, x1 int
+
+	if cond {
+		x0 = a
+	} else {
+		x0 = b + 1
+	}
+	// arm64:"CSINC\tNE", -"CSEL"
+	r0 = x0
+
+	if cond {
+		x1 = b + 1
+	} else {
+		x1 = a
+	}
+	// arm64:"CSINC\tEQ", -"CSEL"
+	r1 = x1
+
+	if cond {
+		c++
+	}
+	// arm64:"CSINC\tEQ", -"CSEL"
+	r2 = c
+}
+
+func cmovinv(cond bool, a, b int) {
+	var x0, x1 int
+
+	if cond {
+		x0 = a
+	} else {
+		x0 = ^b
+	}
+	// arm64:"CSINV\tNE", -"CSEL"
+	r0 = x0
+
+	if cond {
+		x1 = ^b
+	} else {
+		x1 = a
+	}
+	// arm64:"CSINV\tEQ", -"CSEL"
+	r1 = x1
+}
+
+func cmovneg(cond bool, a, b, c int) {
+	var x0, x1 int
+
+	if cond {
+		x0 = a
+	} else {
+		x0 = -b
+	}
+	// arm64:"CSNEG\tNE", -"CSEL"
+	r0 = x0
+
+	if cond {
+		x1 = -b
+	} else {
+		x1 = a
+	}
+	// arm64:"CSNEG\tEQ", -"CSEL"
+	r1 = x1
+}
+
+func cmovsetm(cond bool, x int) {
+	var x0, x1 int
+
+	if cond {
+		x0 = -1
+	} else {
+		x0 = 0
+	}
+	// arm64:"CSETM\tNE", -"CSEL"
+	r0 = x0
+
+	if cond {
+		x1 = 0
+	} else {
+		x1 = -1
+	}
+	// arm64:"CSETM\tEQ", -"CSEL"
+	r1 = x1
+}
+
+func cmovFcmp0(s, t float64, a, b int) {
+	var x0, x1, x2, x3, x4, x5 int
+
+	if s < t {
+		x0 = a
+	} else {
+		x0 = b + 1
+	}
+	// arm64:"CSINC\tMI", -"CSEL"
+	r0 = x0
+
+	if s <= t {
+		x1 = a
+	} else {
+		x1 = ^b
+	}
+	// arm64:"CSINV\tLS", -"CSEL"
+	r1 = x1
+
+	if s > t {
+		x2 = a
+	} else {
+		x2 = -b
+	}
+	// arm64:"CSNEG\tMI", -"CSEL"
+	r2 = x2
+
+	if s >= t {
+		x3 = -1
+	} else {
+		x3 = 0
+	}
+	// arm64:"CSETM\tLS", -"CSEL"
+	r3 = x3
+
+	if s == t {
+		x4 = a
+	} else {
+		x4 = b + 1
+	}
+	// arm64:"CSINC\tEQ", -"CSEL"
+	r4 = x4
+
+	if s != t {
+		x5 = a
+	} else {
+		x5 = b + 1
+	}
+	// arm64:"CSINC\tNE", -"CSEL"
+	r5 = x5
+}
+
+func cmovFcmp1(s, t float64, a, b int) {
+	var x0, x1, x2, x3, x4, x5 int
+
+	if s < t {
+		x0 = b + 1
+	} else {
+		x0 = a
+	}
+	// arm64:"CSINC\tPL", -"CSEL"
+	r0 = x0
+
+	if s <= t {
+		x1 = ^b
+	} else {
+		x1 = a
+	}
+	// arm64:"CSINV\tHI", -"CSEL"
+	r1 = x1
+
+	if s > t {
+		x2 = -b
+	} else {
+		x2 = a
+	}
+	// arm64:"CSNEG\tPL", -"CSEL"
+	r2 = x2
+
+	if s >= t {
+		x3 = 0
+	} else {
+		x3 = -1
+	}
+	// arm64:"CSETM\tHI", -"CSEL"
+	r3 = x3
+
+	if s == t {
+		x4 = b + 1
+	} else {
+		x4 = a
+	}
+	// arm64:"CSINC\tNE", -"CSEL"
+	r4 = x4
+
+	if s != t {
+		x5 = b + 1
+	} else {
+		x5 = a
+	}
+	// arm64:"CSINC\tEQ", -"CSEL"
+	r5 = x5
+}
-- 
GitLab


From 65178441297002592a65d4f92c1dc97994ac7d24 Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Thu, 18 Mar 2021 03:37:58 +1100
Subject: [PATCH 1140/2400] cmd/compile: use a single const MOV operand for
 riscv64

Most platforms only use a single MOV const operand - remove the MOV{B,H,W}const
operands from riscv64 and consistently use MOVDconst instead. The implementation
of all four is the same and there is no benefit gained from having multiple const
operands (in fact it requires a lot more rewrite rules).

Change-Id: I0ba7d7554e371a1de762ef5f3745e9c0c30d41ac
Reviewed-on: https://go-review.googlesource.com/c/go/+/302610
Trust: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Michael Munday <mike.munday@lowrisc.org>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/riscv64/ssa.go       |   2 +-
 .../compile/internal/ssa/gen/RISCV64.rules    | 136 ++--
 .../compile/internal/ssa/gen/RISCV64Ops.go    |   3 -
 src/cmd/compile/internal/ssa/opGen.go         |  39 -
 .../compile/internal/ssa/rewriteRISCV64.go    | 711 ++++--------------
 5 files changed, 180 insertions(+), 711 deletions(-)

diff --git a/src/cmd/compile/internal/riscv64/ssa.go b/src/cmd/compile/internal/riscv64/ssa.go
index 5576dd4e48..4a858de191 100644
--- a/src/cmd/compile/internal/riscv64/ssa.go
+++ b/src/cmd/compile/internal/riscv64/ssa.go
@@ -301,7 +301,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.Reg = v.Args[0].Reg()
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
-	case ssa.OpRISCV64MOVBconst, ssa.OpRISCV64MOVHconst, ssa.OpRISCV64MOVWconst, ssa.OpRISCV64MOVDconst:
+	case ssa.OpRISCV64MOVDconst:
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_CONST
 		p.From.Offset = v.AuxInt
diff --git a/src/cmd/compile/internal/ssa/gen/RISCV64.rules b/src/cmd/compile/internal/ssa/gen/RISCV64.rules
index dbe04f1d58..c66109cc44 100644
--- a/src/cmd/compile/internal/ssa/gen/RISCV64.rules
+++ b/src/cmd/compile/internal/ssa/gen/RISCV64.rules
@@ -222,9 +222,9 @@
 (Rsh64x64 <t> x y) => (SRA <t> x                 (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] y))))
 
 // rotates
-(RotateLeft8 <t> x (MOVBconst [c])) => (Or8 (Lsh8x64 <t> x (MOVBconst [c&7])) (Rsh8Ux64 <t> x (MOVBconst [-c&7])))
-(RotateLeft16 <t> x (MOVHconst [c])) => (Or16 (Lsh16x64 <t> x (MOVHconst [c&15])) (Rsh16Ux64 <t> x (MOVHconst [-c&15])))
-(RotateLeft32 <t> x (MOVWconst [c])) => (Or32 (Lsh32x64 <t> x (MOVWconst [c&31])) (Rsh32Ux64 <t> x (MOVWconst [-c&31])))
+(RotateLeft8  <t> x (MOVDconst [c])) => (Or8  (Lsh8x64  <t> x (MOVDconst [c&7]))  (Rsh8Ux64  <t> x (MOVDconst [-c&7])))
+(RotateLeft16 <t> x (MOVDconst [c])) => (Or16 (Lsh16x64 <t> x (MOVDconst [c&15])) (Rsh16Ux64 <t> x (MOVDconst [-c&15])))
+(RotateLeft32 <t> x (MOVDconst [c])) => (Or32 (Lsh32x64 <t> x (MOVDconst [c&31])) (Rsh32Ux64 <t> x (MOVDconst [-c&31])))
 (RotateLeft64 <t> x (MOVDconst [c])) => (Or64 (Lsh64x64 <t> x (MOVDconst [c&63])) (Rsh64Ux64 <t> x (MOVDconst [-c&63])))
 
 (Less64  ...) => (SLT  ...)
@@ -354,45 +354,45 @@
 
 // Small zeroing
 (Zero [0] _ mem) => mem
-(Zero [1] ptr mem) => (MOVBstore ptr (MOVBconst [0]) mem)
+(Zero [1] ptr mem) => (MOVBstore ptr (MOVDconst [0]) mem)
 (Zero [2] {t} ptr mem) && t.Alignment()%2 == 0 =>
-	(MOVHstore ptr (MOVHconst [0]) mem)
+	(MOVHstore ptr (MOVDconst [0]) mem)
 (Zero [2] ptr mem) =>
-	(MOVBstore [1] ptr (MOVBconst [0])
-		(MOVBstore ptr (MOVBconst [0]) mem))
+	(MOVBstore [1] ptr (MOVDconst [0])
+		(MOVBstore ptr (MOVDconst [0]) mem))
 (Zero [4] {t} ptr mem) && t.Alignment()%4 == 0 =>
-	(MOVWstore ptr (MOVWconst [0]) mem)
+	(MOVWstore ptr (MOVDconst [0]) mem)
 (Zero [4] {t} ptr mem) && t.Alignment()%2 == 0 =>
-	(MOVHstore [2] ptr (MOVHconst [0])
-		(MOVHstore ptr (MOVHconst [0]) mem))
+	(MOVHstore [2] ptr (MOVDconst [0])
+		(MOVHstore ptr (MOVDconst [0]) mem))
 (Zero [4] ptr mem) =>
-	(MOVBstore [3] ptr (MOVBconst [0])
-		(MOVBstore [2] ptr (MOVBconst [0])
-			(MOVBstore [1] ptr (MOVBconst [0])
-				(MOVBstore ptr (MOVBconst [0]) mem))))
+	(MOVBstore [3] ptr (MOVDconst [0])
+		(MOVBstore [2] ptr (MOVDconst [0])
+			(MOVBstore [1] ptr (MOVDconst [0])
+				(MOVBstore ptr (MOVDconst [0]) mem))))
 (Zero [8] {t} ptr mem) && t.Alignment()%8 == 0 =>
 	(MOVDstore ptr (MOVDconst [0]) mem)
 (Zero [8] {t} ptr mem) && t.Alignment()%4 == 0 =>
-	(MOVWstore [4] ptr (MOVWconst [0])
-		(MOVWstore ptr (MOVWconst [0]) mem))
+	(MOVWstore [4] ptr (MOVDconst [0])
+		(MOVWstore ptr (MOVDconst [0]) mem))
 (Zero [8] {t} ptr mem) && t.Alignment()%2 == 0 =>
-	(MOVHstore [6] ptr (MOVHconst [0])
-		(MOVHstore [4] ptr (MOVHconst [0])
-			(MOVHstore [2] ptr (MOVHconst [0])
-				(MOVHstore ptr (MOVHconst [0]) mem))))
+	(MOVHstore [6] ptr (MOVDconst [0])
+		(MOVHstore [4] ptr (MOVDconst [0])
+			(MOVHstore [2] ptr (MOVDconst [0])
+				(MOVHstore ptr (MOVDconst [0]) mem))))
 
 (Zero [3] ptr mem) =>
-	(MOVBstore [2] ptr (MOVBconst [0])
-		(MOVBstore [1] ptr (MOVBconst [0])
-			(MOVBstore ptr (MOVBconst [0]) mem)))
+	(MOVBstore [2] ptr (MOVDconst [0])
+		(MOVBstore [1] ptr (MOVDconst [0])
+			(MOVBstore ptr (MOVDconst [0]) mem)))
 (Zero [6] {t} ptr mem) && t.Alignment()%2 == 0 =>
-	(MOVHstore [4] ptr (MOVHconst [0])
-		(MOVHstore [2] ptr (MOVHconst [0])
-			(MOVHstore ptr (MOVHconst [0]) mem)))
+	(MOVHstore [4] ptr (MOVDconst [0])
+		(MOVHstore [2] ptr (MOVDconst [0])
+			(MOVHstore ptr (MOVDconst [0]) mem)))
 (Zero [12] {t} ptr mem) && t.Alignment()%4 == 0 =>
-	(MOVWstore [8] ptr (MOVWconst [0])
-		(MOVWstore [4] ptr (MOVWconst [0])
-			(MOVWstore ptr (MOVWconst [0]) mem)))
+	(MOVWstore [8] ptr (MOVDconst [0])
+		(MOVWstore [4] ptr (MOVDconst [0])
+			(MOVWstore ptr (MOVDconst [0]) mem)))
 (Zero [16] {t} ptr mem) && t.Alignment()%8 == 0 =>
 	(MOVDstore [8] ptr (MOVDconst [0])
 		(MOVDstore ptr (MOVDconst [0]) mem))
@@ -522,16 +522,14 @@
 (OffPtr [off] ptr) && is32Bit(off) => (ADDI [off] ptr)
 (OffPtr [off] ptr) => (ADD (MOVDconst [off]) ptr)
 
-// TODO(jsing): Check if we actually need MOV{B,H,W}const as most platforms
-// use a single MOVDconst op.
-(Const8 ...) => (MOVBconst ...)
-(Const16 ...) => (MOVHconst ...)
-(Const32 ...) => (MOVWconst ...)
-(Const64 ...) => (MOVDconst ...)
-(Const32F [val]) => (FMVSX (MOVWconst [int32(math.Float32bits(val))]))
+(Const8  [val]) => (MOVDconst [int64(val)])
+(Const16 [val]) => (MOVDconst [int64(val)])
+(Const32 [val]) => (MOVDconst [int64(val)])
+(Const64 [val]) => (MOVDconst [int64(val)])
+(Const32F [val]) => (FMVSX (MOVDconst [int64(math.Float32bits(val))]))
 (Const64F [val]) => (FMVDX (MOVDconst [int64(math.Float64bits(val))]))
 (ConstNil) => (MOVDconst [0])
-(ConstBool [val]) => (MOVBconst [int8(b2i(val))])
+(ConstBool [val]) => (MOVDconst [int64(b2i(val))])
 
 // Convert 64 bit immediate to two 32 bit immediates, combine with add and shift.
 // The lower 32 bit immediate will be treated as signed,
@@ -612,24 +610,18 @@
 (BNE cond (MOVDconst [0]) yes no) => (BNEZ cond yes no)
 
 // Store zero
-(MOVBstore [off] {sym} ptr (MOVBconst [0]) mem) => (MOVBstorezero [off] {sym} ptr mem)
-(MOVHstore [off] {sym} ptr (MOVHconst [0]) mem) => (MOVHstorezero [off] {sym} ptr mem)
-(MOVWstore [off] {sym} ptr (MOVWconst [0]) mem) => (MOVWstorezero [off] {sym} ptr mem)
+(MOVBstore [off] {sym} ptr (MOVDconst [0]) mem) => (MOVBstorezero [off] {sym} ptr mem)
+(MOVHstore [off] {sym} ptr (MOVDconst [0]) mem) => (MOVHstorezero [off] {sym} ptr mem)
+(MOVWstore [off] {sym} ptr (MOVDconst [0]) mem) => (MOVWstorezero [off] {sym} ptr mem)
 (MOVDstore [off] {sym} ptr (MOVDconst [0]) mem) => (MOVDstorezero [off] {sym} ptr mem)
 
 // Avoid sign/zero extension for consts.
-(MOVBreg  (MOVBconst [c])) => (MOVDconst [int64(c)])
-(MOVHreg  (MOVBconst [c])) => (MOVDconst [int64(c)])
-(MOVHreg  (MOVHconst [c])) => (MOVDconst [int64(c)])
-(MOVWreg  (MOVBconst [c])) => (MOVDconst [int64(c)])
-(MOVWreg  (MOVHconst [c])) => (MOVDconst [int64(c)])
-(MOVWreg  (MOVWconst [c])) => (MOVDconst [int64(c)])
-(MOVBUreg (MOVBconst [c])) => (MOVDconst [int64(uint8(c))])
-(MOVHUreg (MOVBconst [c])) => (MOVDconst [int64(uint16(c))])
-(MOVHUreg (MOVHconst [c])) => (MOVDconst [int64(uint16(c))])
-(MOVWUreg (MOVBconst [c])) => (MOVDconst [int64(uint32(c))])
-(MOVWUreg (MOVHconst [c])) => (MOVDconst [int64(uint32(c))])
-(MOVWUreg (MOVWconst [c])) => (MOVDconst [int64(uint32(c))])
+(MOVBreg  (MOVDconst [c])) => (MOVDconst [int64(c)])
+(MOVHreg  (MOVDconst [c])) => (MOVDconst [int64(c)])
+(MOVWreg  (MOVDconst [c])) => (MOVDconst [int64(c)])
+(MOVBUreg (MOVDconst [c])) => (MOVDconst [int64(uint8(c))])
+(MOVHUreg (MOVDconst [c])) => (MOVDconst [int64(uint16(c))])
+(MOVWUreg (MOVDconst [c])) => (MOVDconst [int64(uint32(c))])
 
 // Avoid sign/zero extension after properly typed load.
 (MOVBreg  x:(MOVBload  _ _)) => (MOVDreg x)
@@ -695,60 +687,24 @@
 (MOVDnop (MOVDconst [c])) => (MOVDconst [c])
 
 // Fold constant into immediate instructions where possible.
-(ADD (MOVBconst [val]) x) => (ADDI [int64(val)] x)
-(ADD (MOVHconst [val]) x) => (ADDI [int64(val)] x)
-(ADD (MOVWconst [val]) x) => (ADDI [int64(val)] x)
 (ADD (MOVDconst [val]) x) && is32Bit(val) => (ADDI [val] x)
-
-(AND (MOVBconst [val]) x) => (ANDI [int64(val)] x)
-(AND (MOVHconst [val]) x) => (ANDI [int64(val)] x)
-(AND (MOVWconst [val]) x) => (ANDI [int64(val)] x)
 (AND (MOVDconst [val]) x) && is32Bit(val) => (ANDI [val] x)
-
-(OR (MOVBconst [val]) x) => (ORI [int64(val)] x)
-(OR (MOVHconst [val]) x) => (ORI [int64(val)] x)
-(OR (MOVWconst [val]) x) => (ORI [int64(val)] x)
-(OR (MOVDconst [val]) x) && is32Bit(val) => (ORI [val] x)
-
-(XOR (MOVBconst [val]) x) => (XORI [int64(val)] x)
-(XOR (MOVHconst [val]) x) => (XORI [int64(val)] x)
-(XOR (MOVWconst [val]) x) => (XORI [int64(val)] x)
+(OR  (MOVDconst [val]) x) && is32Bit(val) => (ORI  [val] x)
 (XOR (MOVDconst [val]) x) && is32Bit(val) => (XORI [val] x)
-
-(SLL x (MOVBconst [val])) => (SLLI [int64(val&63)] x)
-(SLL x (MOVHconst [val])) => (SLLI [int64(val&63)] x)
-(SLL x (MOVWconst [val])) => (SLLI [int64(val&63)] x)
 (SLL x (MOVDconst [val])) => (SLLI [int64(val&63)] x)
-
-(SRL x (MOVBconst [val])) => (SRLI [int64(val&63)] x)
-(SRL x (MOVHconst [val])) => (SRLI [int64(val&63)] x)
-(SRL x (MOVWconst [val])) => (SRLI [int64(val&63)] x)
 (SRL x (MOVDconst [val])) => (SRLI [int64(val&63)] x)
-
-(SRA x (MOVBconst [val])) => (SRAI [int64(val&63)] x)
-(SRA x (MOVHconst [val])) => (SRAI [int64(val&63)] x)
-(SRA x (MOVWconst [val])) => (SRAI [int64(val&63)] x)
 (SRA x (MOVDconst [val])) => (SRAI [int64(val&63)] x)
 
 // Convert subtraction of a const into ADDI with negative immediate, where possible.
-(SUB x (MOVBconst [val])) => (ADDI [-int64(val)] x)
-(SUB x (MOVHconst [val])) => (ADDI [-int64(val)] x)
-(SUB x (MOVWconst [val])) && is32Bit(-int64(val)) => (ADDI [-int64(val)] x)
 (SUB x (MOVDconst [val])) && is32Bit(-val) => (ADDI [-val] x)
 
 // Subtraction of zero.
-(SUB x (MOVBconst [0])) => x
-(SUB x (MOVHconst [0])) => x
-(SUB x (MOVWconst [0])) => x
 (SUB x (MOVDconst [0])) => x
 
 // Subtraction of zero with sign extension.
-(SUBW x (MOVWconst [0])) => (ADDIW [0] x)
+(SUBW x (MOVDconst [0])) => (ADDIW [0] x)
 
 // Subtraction from zero.
-(SUB (MOVBconst [0]) x) => (NEG x)
-(SUB (MOVHconst [0]) x) => (NEG x)
-(SUB (MOVWconst [0]) x) => (NEG x)
 (SUB (MOVDconst [0]) x) => (NEG x)
 
 // Subtraction from zero with sign extension.
diff --git a/src/cmd/compile/internal/ssa/gen/RISCV64Ops.go b/src/cmd/compile/internal/ssa/gen/RISCV64Ops.go
index 92a0c3c84c..0ac9c5f62a 100644
--- a/src/cmd/compile/internal/ssa/gen/RISCV64Ops.go
+++ b/src/cmd/compile/internal/ssa/gen/RISCV64Ops.go
@@ -168,9 +168,6 @@ func init() {
 		{name: "MOVaddr", argLength: 1, reg: gp11sb, asm: "MOV", aux: "SymOff", rematerializeable: true, symEffect: "RdWr"}, // arg0 + auxint + offset encoded in aux
 		// auxint+aux == add auxint and the offset of the symbol in aux (if any) to the effective address
 
-		{name: "MOVBconst", reg: gp01, asm: "MOV", typ: "UInt8", aux: "Int8", rematerializeable: true},   // 8 low bits of auxint
-		{name: "MOVHconst", reg: gp01, asm: "MOV", typ: "UInt16", aux: "Int16", rematerializeable: true}, // 16 low bits of auxint
-		{name: "MOVWconst", reg: gp01, asm: "MOV", typ: "UInt32", aux: "Int32", rematerializeable: true}, // 32 low bits of auxint
 		{name: "MOVDconst", reg: gp01, asm: "MOV", typ: "UInt64", aux: "Int64", rematerializeable: true}, // auxint
 
 		// Loads: load <size> bits from arg0+auxint+aux and extend to 64 bits; arg1=mem
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index 436a79a173..d572466b98 100644
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -2089,9 +2089,6 @@ const (
 	OpRISCV64REMW
 	OpRISCV64REMUW
 	OpRISCV64MOVaddr
-	OpRISCV64MOVBconst
-	OpRISCV64MOVHconst
-	OpRISCV64MOVWconst
 	OpRISCV64MOVDconst
 	OpRISCV64MOVBload
 	OpRISCV64MOVHload
@@ -27904,42 +27901,6 @@ var opcodeTable = [...]opInfo{
 			},
 		},
 	},
-	{
-		name:              "MOVBconst",
-		auxType:           auxInt8,
-		argLen:            0,
-		rematerializeable: true,
-		asm:               riscv.AMOV,
-		reg: regInfo{
-			outputs: []outputInfo{
-				{0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30
-			},
-		},
-	},
-	{
-		name:              "MOVHconst",
-		auxType:           auxInt16,
-		argLen:            0,
-		rematerializeable: true,
-		asm:               riscv.AMOV,
-		reg: regInfo{
-			outputs: []outputInfo{
-				{0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30
-			},
-		},
-	},
-	{
-		name:              "MOVWconst",
-		auxType:           auxInt32,
-		argLen:            0,
-		rematerializeable: true,
-		asm:               riscv.AMOV,
-		reg: regInfo{
-			outputs: []outputInfo{
-				{0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30
-			},
-		},
-	},
 	{
 		name:              "MOVDconst",
 		auxType:           auxInt64,
diff --git a/src/cmd/compile/internal/ssa/rewriteRISCV64.go b/src/cmd/compile/internal/ssa/rewriteRISCV64.go
index 895f380d33..69ae8f5df9 100644
--- a/src/cmd/compile/internal/ssa/rewriteRISCV64.go
+++ b/src/cmd/compile/internal/ssa/rewriteRISCV64.go
@@ -116,21 +116,17 @@ func rewriteValueRISCV64(v *Value) bool {
 		v.Op = OpRISCV64NOT
 		return true
 	case OpConst16:
-		v.Op = OpRISCV64MOVHconst
-		return true
+		return rewriteValueRISCV64_OpConst16(v)
 	case OpConst32:
-		v.Op = OpRISCV64MOVWconst
-		return true
+		return rewriteValueRISCV64_OpConst32(v)
 	case OpConst32F:
 		return rewriteValueRISCV64_OpConst32F(v)
 	case OpConst64:
-		v.Op = OpRISCV64MOVDconst
-		return true
+		return rewriteValueRISCV64_OpConst64(v)
 	case OpConst64F:
 		return rewriteValueRISCV64_OpConst64F(v)
 	case OpConst8:
-		v.Op = OpRISCV64MOVBconst
-		return true
+		return rewriteValueRISCV64_OpConst8(v)
 	case OpConstBool:
 		return rewriteValueRISCV64_OpConstBool(v)
 	case OpConstNil:
@@ -785,20 +781,50 @@ func rewriteValueRISCV64_OpAvg64u(v *Value) bool {
 		return true
 	}
 }
+func rewriteValueRISCV64_OpConst16(v *Value) bool {
+	// match: (Const16 [val])
+	// result: (MOVDconst [int64(val)])
+	for {
+		val := auxIntToInt16(v.AuxInt)
+		v.reset(OpRISCV64MOVDconst)
+		v.AuxInt = int64ToAuxInt(int64(val))
+		return true
+	}
+}
+func rewriteValueRISCV64_OpConst32(v *Value) bool {
+	// match: (Const32 [val])
+	// result: (MOVDconst [int64(val)])
+	for {
+		val := auxIntToInt32(v.AuxInt)
+		v.reset(OpRISCV64MOVDconst)
+		v.AuxInt = int64ToAuxInt(int64(val))
+		return true
+	}
+}
 func rewriteValueRISCV64_OpConst32F(v *Value) bool {
 	b := v.Block
 	typ := &b.Func.Config.Types
 	// match: (Const32F [val])
-	// result: (FMVSX (MOVWconst [int32(math.Float32bits(val))]))
+	// result: (FMVSX (MOVDconst [int64(math.Float32bits(val))]))
 	for {
 		val := auxIntToFloat32(v.AuxInt)
 		v.reset(OpRISCV64FMVSX)
-		v0 := b.NewValue0(v.Pos, OpRISCV64MOVWconst, typ.UInt32)
-		v0.AuxInt = int32ToAuxInt(int32(math.Float32bits(val)))
+		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
+		v0.AuxInt = int64ToAuxInt(int64(math.Float32bits(val)))
 		v.AddArg(v0)
 		return true
 	}
 }
+func rewriteValueRISCV64_OpConst64(v *Value) bool {
+	// match: (Const64 [val])
+	// result: (MOVDconst [int64(val)])
+	for {
+		val := auxIntToInt64(v.AuxInt)
+		v.reset(OpRISCV64MOVDconst)
+		v.AuxInt = int64ToAuxInt(int64(val))
+		return true
+	}
+}
 func rewriteValueRISCV64_OpConst64F(v *Value) bool {
 	b := v.Block
 	typ := &b.Func.Config.Types
@@ -813,13 +839,23 @@ func rewriteValueRISCV64_OpConst64F(v *Value) bool {
 		return true
 	}
 }
+func rewriteValueRISCV64_OpConst8(v *Value) bool {
+	// match: (Const8 [val])
+	// result: (MOVDconst [int64(val)])
+	for {
+		val := auxIntToInt8(v.AuxInt)
+		v.reset(OpRISCV64MOVDconst)
+		v.AuxInt = int64ToAuxInt(int64(val))
+		return true
+	}
+}
 func rewriteValueRISCV64_OpConstBool(v *Value) bool {
 	// match: (ConstBool [val])
-	// result: (MOVBconst [int8(b2i(val))])
+	// result: (MOVDconst [int64(b2i(val))])
 	for {
 		val := auxIntToBool(v.AuxInt)
-		v.reset(OpRISCV64MOVBconst)
-		v.AuxInt = int8ToAuxInt(int8(b2i(val)))
+		v.reset(OpRISCV64MOVDconst)
+		v.AuxInt = int64ToAuxInt(int64(b2i(val)))
 		return true
 	}
 }
@@ -2708,54 +2744,6 @@ func rewriteValueRISCV64_OpPanicBounds(v *Value) bool {
 func rewriteValueRISCV64_OpRISCV64ADD(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
-	// match: (ADD (MOVBconst [val]) x)
-	// result: (ADDI [int64(val)] x)
-	for {
-		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
-			if v_0.Op != OpRISCV64MOVBconst {
-				continue
-			}
-			val := auxIntToInt8(v_0.AuxInt)
-			x := v_1
-			v.reset(OpRISCV64ADDI)
-			v.AuxInt = int64ToAuxInt(int64(val))
-			v.AddArg(x)
-			return true
-		}
-		break
-	}
-	// match: (ADD (MOVHconst [val]) x)
-	// result: (ADDI [int64(val)] x)
-	for {
-		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
-			if v_0.Op != OpRISCV64MOVHconst {
-				continue
-			}
-			val := auxIntToInt16(v_0.AuxInt)
-			x := v_1
-			v.reset(OpRISCV64ADDI)
-			v.AuxInt = int64ToAuxInt(int64(val))
-			v.AddArg(x)
-			return true
-		}
-		break
-	}
-	// match: (ADD (MOVWconst [val]) x)
-	// result: (ADDI [int64(val)] x)
-	for {
-		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
-			if v_0.Op != OpRISCV64MOVWconst {
-				continue
-			}
-			val := auxIntToInt32(v_0.AuxInt)
-			x := v_1
-			v.reset(OpRISCV64ADDI)
-			v.AuxInt = int64ToAuxInt(int64(val))
-			v.AddArg(x)
-			return true
-		}
-		break
-	}
 	// match: (ADD (MOVDconst [val]) x)
 	// cond: is32Bit(val)
 	// result: (ADDI [val] x)
@@ -2815,54 +2803,6 @@ func rewriteValueRISCV64_OpRISCV64ADDI(v *Value) bool {
 func rewriteValueRISCV64_OpRISCV64AND(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
-	// match: (AND (MOVBconst [val]) x)
-	// result: (ANDI [int64(val)] x)
-	for {
-		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
-			if v_0.Op != OpRISCV64MOVBconst {
-				continue
-			}
-			val := auxIntToInt8(v_0.AuxInt)
-			x := v_1
-			v.reset(OpRISCV64ANDI)
-			v.AuxInt = int64ToAuxInt(int64(val))
-			v.AddArg(x)
-			return true
-		}
-		break
-	}
-	// match: (AND (MOVHconst [val]) x)
-	// result: (ANDI [int64(val)] x)
-	for {
-		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
-			if v_0.Op != OpRISCV64MOVHconst {
-				continue
-			}
-			val := auxIntToInt16(v_0.AuxInt)
-			x := v_1
-			v.reset(OpRISCV64ANDI)
-			v.AuxInt = int64ToAuxInt(int64(val))
-			v.AddArg(x)
-			return true
-		}
-		break
-	}
-	// match: (AND (MOVWconst [val]) x)
-	// result: (ANDI [int64(val)] x)
-	for {
-		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
-			if v_0.Op != OpRISCV64MOVWconst {
-				continue
-			}
-			val := auxIntToInt32(v_0.AuxInt)
-			x := v_1
-			v.reset(OpRISCV64ANDI)
-			v.AuxInt = int64ToAuxInt(int64(val))
-			v.AddArg(x)
-			return true
-		}
-		break
-	}
 	// match: (AND (MOVDconst [val]) x)
 	// cond: is32Bit(val)
 	// result: (ANDI [val] x)
@@ -2936,13 +2876,13 @@ func rewriteValueRISCV64_OpRISCV64MOVBUload(v *Value) bool {
 func rewriteValueRISCV64_OpRISCV64MOVBUreg(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
-	// match: (MOVBUreg (MOVBconst [c]))
+	// match: (MOVBUreg (MOVDconst [c]))
 	// result: (MOVDconst [int64(uint8(c))])
 	for {
-		if v_0.Op != OpRISCV64MOVBconst {
+		if v_0.Op != OpRISCV64MOVDconst {
 			break
 		}
-		c := auxIntToInt8(v_0.AuxInt)
+		c := auxIntToInt64(v_0.AuxInt)
 		v.reset(OpRISCV64MOVDconst)
 		v.AuxInt = int64ToAuxInt(int64(uint8(c)))
 		return true
@@ -3046,13 +2986,13 @@ func rewriteValueRISCV64_OpRISCV64MOVBload(v *Value) bool {
 func rewriteValueRISCV64_OpRISCV64MOVBreg(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
-	// match: (MOVBreg (MOVBconst [c]))
+	// match: (MOVBreg (MOVDconst [c]))
 	// result: (MOVDconst [int64(c)])
 	for {
-		if v_0.Op != OpRISCV64MOVBconst {
+		if v_0.Op != OpRISCV64MOVDconst {
 			break
 		}
-		c := auxIntToInt8(v_0.AuxInt)
+		c := auxIntToInt64(v_0.AuxInt)
 		v.reset(OpRISCV64MOVDconst)
 		v.AuxInt = int64ToAuxInt(int64(c))
 		return true
@@ -3154,13 +3094,13 @@ func rewriteValueRISCV64_OpRISCV64MOVBstore(v *Value) bool {
 		v.AddArg3(base, val, mem)
 		return true
 	}
-	// match: (MOVBstore [off] {sym} ptr (MOVBconst [0]) mem)
+	// match: (MOVBstore [off] {sym} ptr (MOVDconst [0]) mem)
 	// result: (MOVBstorezero [off] {sym} ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
 		ptr := v_0
-		if v_1.Op != OpRISCV64MOVBconst || auxIntToInt8(v_1.AuxInt) != 0 {
+		if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
 			break
 		}
 		mem := v_2
@@ -3612,24 +3552,13 @@ func rewriteValueRISCV64_OpRISCV64MOVHUload(v *Value) bool {
 func rewriteValueRISCV64_OpRISCV64MOVHUreg(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
-	// match: (MOVHUreg (MOVBconst [c]))
+	// match: (MOVHUreg (MOVDconst [c]))
 	// result: (MOVDconst [int64(uint16(c))])
 	for {
-		if v_0.Op != OpRISCV64MOVBconst {
-			break
-		}
-		c := auxIntToInt8(v_0.AuxInt)
-		v.reset(OpRISCV64MOVDconst)
-		v.AuxInt = int64ToAuxInt(int64(uint16(c)))
-		return true
-	}
-	// match: (MOVHUreg (MOVHconst [c]))
-	// result: (MOVDconst [int64(uint16(c))])
-	for {
-		if v_0.Op != OpRISCV64MOVHconst {
+		if v_0.Op != OpRISCV64MOVDconst {
 			break
 		}
-		c := auxIntToInt16(v_0.AuxInt)
+		c := auxIntToInt64(v_0.AuxInt)
 		v.reset(OpRISCV64MOVDconst)
 		v.AuxInt = int64ToAuxInt(int64(uint16(c)))
 		return true
@@ -3755,24 +3684,13 @@ func rewriteValueRISCV64_OpRISCV64MOVHload(v *Value) bool {
 func rewriteValueRISCV64_OpRISCV64MOVHreg(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
-	// match: (MOVHreg (MOVBconst [c]))
-	// result: (MOVDconst [int64(c)])
-	for {
-		if v_0.Op != OpRISCV64MOVBconst {
-			break
-		}
-		c := auxIntToInt8(v_0.AuxInt)
-		v.reset(OpRISCV64MOVDconst)
-		v.AuxInt = int64ToAuxInt(int64(c))
-		return true
-	}
-	// match: (MOVHreg (MOVHconst [c]))
+	// match: (MOVHreg (MOVDconst [c]))
 	// result: (MOVDconst [int64(c)])
 	for {
-		if v_0.Op != OpRISCV64MOVHconst {
+		if v_0.Op != OpRISCV64MOVDconst {
 			break
 		}
-		c := auxIntToInt16(v_0.AuxInt)
+		c := auxIntToInt64(v_0.AuxInt)
 		v.reset(OpRISCV64MOVDconst)
 		v.AuxInt = int64ToAuxInt(int64(c))
 		return true
@@ -3918,13 +3836,13 @@ func rewriteValueRISCV64_OpRISCV64MOVHstore(v *Value) bool {
 		v.AddArg3(base, val, mem)
 		return true
 	}
-	// match: (MOVHstore [off] {sym} ptr (MOVHconst [0]) mem)
+	// match: (MOVHstore [off] {sym} ptr (MOVDconst [0]) mem)
 	// result: (MOVHstorezero [off] {sym} ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
 		ptr := v_0
-		if v_1.Op != OpRISCV64MOVHconst || auxIntToInt16(v_1.AuxInt) != 0 {
+		if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
 			break
 		}
 		mem := v_2
@@ -4103,35 +4021,13 @@ func rewriteValueRISCV64_OpRISCV64MOVWUload(v *Value) bool {
 func rewriteValueRISCV64_OpRISCV64MOVWUreg(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
-	// match: (MOVWUreg (MOVBconst [c]))
+	// match: (MOVWUreg (MOVDconst [c]))
 	// result: (MOVDconst [int64(uint32(c))])
 	for {
-		if v_0.Op != OpRISCV64MOVBconst {
-			break
-		}
-		c := auxIntToInt8(v_0.AuxInt)
-		v.reset(OpRISCV64MOVDconst)
-		v.AuxInt = int64ToAuxInt(int64(uint32(c)))
-		return true
-	}
-	// match: (MOVWUreg (MOVHconst [c]))
-	// result: (MOVDconst [int64(uint32(c))])
-	for {
-		if v_0.Op != OpRISCV64MOVHconst {
-			break
-		}
-		c := auxIntToInt16(v_0.AuxInt)
-		v.reset(OpRISCV64MOVDconst)
-		v.AuxInt = int64ToAuxInt(int64(uint32(c)))
-		return true
-	}
-	// match: (MOVWUreg (MOVWconst [c]))
-	// result: (MOVDconst [int64(uint32(c))])
-	for {
-		if v_0.Op != OpRISCV64MOVWconst {
+		if v_0.Op != OpRISCV64MOVDconst {
 			break
 		}
-		c := auxIntToInt32(v_0.AuxInt)
+		c := auxIntToInt64(v_0.AuxInt)
 		v.reset(OpRISCV64MOVDconst)
 		v.AuxInt = int64ToAuxInt(int64(uint32(c)))
 		return true
@@ -4279,35 +4175,13 @@ func rewriteValueRISCV64_OpRISCV64MOVWload(v *Value) bool {
 func rewriteValueRISCV64_OpRISCV64MOVWreg(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
-	// match: (MOVWreg (MOVBconst [c]))
-	// result: (MOVDconst [int64(c)])
-	for {
-		if v_0.Op != OpRISCV64MOVBconst {
-			break
-		}
-		c := auxIntToInt8(v_0.AuxInt)
-		v.reset(OpRISCV64MOVDconst)
-		v.AuxInt = int64ToAuxInt(int64(c))
-		return true
-	}
-	// match: (MOVWreg (MOVHconst [c]))
-	// result: (MOVDconst [int64(c)])
-	for {
-		if v_0.Op != OpRISCV64MOVHconst {
-			break
-		}
-		c := auxIntToInt16(v_0.AuxInt)
-		v.reset(OpRISCV64MOVDconst)
-		v.AuxInt = int64ToAuxInt(int64(c))
-		return true
-	}
-	// match: (MOVWreg (MOVWconst [c]))
+	// match: (MOVWreg (MOVDconst [c]))
 	// result: (MOVDconst [int64(c)])
 	for {
-		if v_0.Op != OpRISCV64MOVWconst {
+		if v_0.Op != OpRISCV64MOVDconst {
 			break
 		}
-		c := auxIntToInt32(v_0.AuxInt)
+		c := auxIntToInt64(v_0.AuxInt)
 		v.reset(OpRISCV64MOVDconst)
 		v.AuxInt = int64ToAuxInt(int64(c))
 		return true
@@ -4486,13 +4360,13 @@ func rewriteValueRISCV64_OpRISCV64MOVWstore(v *Value) bool {
 		v.AddArg3(base, val, mem)
 		return true
 	}
-	// match: (MOVWstore [off] {sym} ptr (MOVWconst [0]) mem)
+	// match: (MOVWstore [off] {sym} ptr (MOVDconst [0]) mem)
 	// result: (MOVWstorezero [off] {sym} ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
 		ptr := v_0
-		if v_1.Op != OpRISCV64MOVWconst || auxIntToInt32(v_1.AuxInt) != 0 {
+		if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
 			break
 		}
 		mem := v_2
@@ -4589,54 +4463,6 @@ func rewriteValueRISCV64_OpRISCV64MOVWstorezero(v *Value) bool {
 func rewriteValueRISCV64_OpRISCV64OR(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
-	// match: (OR (MOVBconst [val]) x)
-	// result: (ORI [int64(val)] x)
-	for {
-		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
-			if v_0.Op != OpRISCV64MOVBconst {
-				continue
-			}
-			val := auxIntToInt8(v_0.AuxInt)
-			x := v_1
-			v.reset(OpRISCV64ORI)
-			v.AuxInt = int64ToAuxInt(int64(val))
-			v.AddArg(x)
-			return true
-		}
-		break
-	}
-	// match: (OR (MOVHconst [val]) x)
-	// result: (ORI [int64(val)] x)
-	for {
-		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
-			if v_0.Op != OpRISCV64MOVHconst {
-				continue
-			}
-			val := auxIntToInt16(v_0.AuxInt)
-			x := v_1
-			v.reset(OpRISCV64ORI)
-			v.AuxInt = int64ToAuxInt(int64(val))
-			v.AddArg(x)
-			return true
-		}
-		break
-	}
-	// match: (OR (MOVWconst [val]) x)
-	// result: (ORI [int64(val)] x)
-	for {
-		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
-			if v_0.Op != OpRISCV64MOVWconst {
-				continue
-			}
-			val := auxIntToInt32(v_0.AuxInt)
-			x := v_1
-			v.reset(OpRISCV64ORI)
-			v.AuxInt = int64ToAuxInt(int64(val))
-			v.AddArg(x)
-			return true
-		}
-		break
-	}
 	// match: (OR (MOVDconst [val]) x)
 	// cond: is32Bit(val)
 	// result: (ORI [val] x)
@@ -4662,45 +4488,6 @@ func rewriteValueRISCV64_OpRISCV64OR(v *Value) bool {
 func rewriteValueRISCV64_OpRISCV64SLL(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
-	// match: (SLL x (MOVBconst [val]))
-	// result: (SLLI [int64(val&63)] x)
-	for {
-		x := v_0
-		if v_1.Op != OpRISCV64MOVBconst {
-			break
-		}
-		val := auxIntToInt8(v_1.AuxInt)
-		v.reset(OpRISCV64SLLI)
-		v.AuxInt = int64ToAuxInt(int64(val & 63))
-		v.AddArg(x)
-		return true
-	}
-	// match: (SLL x (MOVHconst [val]))
-	// result: (SLLI [int64(val&63)] x)
-	for {
-		x := v_0
-		if v_1.Op != OpRISCV64MOVHconst {
-			break
-		}
-		val := auxIntToInt16(v_1.AuxInt)
-		v.reset(OpRISCV64SLLI)
-		v.AuxInt = int64ToAuxInt(int64(val & 63))
-		v.AddArg(x)
-		return true
-	}
-	// match: (SLL x (MOVWconst [val]))
-	// result: (SLLI [int64(val&63)] x)
-	for {
-		x := v_0
-		if v_1.Op != OpRISCV64MOVWconst {
-			break
-		}
-		val := auxIntToInt32(v_1.AuxInt)
-		v.reset(OpRISCV64SLLI)
-		v.AuxInt = int64ToAuxInt(int64(val & 63))
-		v.AddArg(x)
-		return true
-	}
 	// match: (SLL x (MOVDconst [val]))
 	// result: (SLLI [int64(val&63)] x)
 	for {
@@ -4719,45 +4506,6 @@ func rewriteValueRISCV64_OpRISCV64SLL(v *Value) bool {
 func rewriteValueRISCV64_OpRISCV64SRA(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
-	// match: (SRA x (MOVBconst [val]))
-	// result: (SRAI [int64(val&63)] x)
-	for {
-		x := v_0
-		if v_1.Op != OpRISCV64MOVBconst {
-			break
-		}
-		val := auxIntToInt8(v_1.AuxInt)
-		v.reset(OpRISCV64SRAI)
-		v.AuxInt = int64ToAuxInt(int64(val & 63))
-		v.AddArg(x)
-		return true
-	}
-	// match: (SRA x (MOVHconst [val]))
-	// result: (SRAI [int64(val&63)] x)
-	for {
-		x := v_0
-		if v_1.Op != OpRISCV64MOVHconst {
-			break
-		}
-		val := auxIntToInt16(v_1.AuxInt)
-		v.reset(OpRISCV64SRAI)
-		v.AuxInt = int64ToAuxInt(int64(val & 63))
-		v.AddArg(x)
-		return true
-	}
-	// match: (SRA x (MOVWconst [val]))
-	// result: (SRAI [int64(val&63)] x)
-	for {
-		x := v_0
-		if v_1.Op != OpRISCV64MOVWconst {
-			break
-		}
-		val := auxIntToInt32(v_1.AuxInt)
-		v.reset(OpRISCV64SRAI)
-		v.AuxInt = int64ToAuxInt(int64(val & 63))
-		v.AddArg(x)
-		return true
-	}
 	// match: (SRA x (MOVDconst [val]))
 	// result: (SRAI [int64(val&63)] x)
 	for {
@@ -4776,45 +4524,6 @@ func rewriteValueRISCV64_OpRISCV64SRA(v *Value) bool {
 func rewriteValueRISCV64_OpRISCV64SRL(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
-	// match: (SRL x (MOVBconst [val]))
-	// result: (SRLI [int64(val&63)] x)
-	for {
-		x := v_0
-		if v_1.Op != OpRISCV64MOVBconst {
-			break
-		}
-		val := auxIntToInt8(v_1.AuxInt)
-		v.reset(OpRISCV64SRLI)
-		v.AuxInt = int64ToAuxInt(int64(val & 63))
-		v.AddArg(x)
-		return true
-	}
-	// match: (SRL x (MOVHconst [val]))
-	// result: (SRLI [int64(val&63)] x)
-	for {
-		x := v_0
-		if v_1.Op != OpRISCV64MOVHconst {
-			break
-		}
-		val := auxIntToInt16(v_1.AuxInt)
-		v.reset(OpRISCV64SRLI)
-		v.AuxInt = int64ToAuxInt(int64(val & 63))
-		v.AddArg(x)
-		return true
-	}
-	// match: (SRL x (MOVWconst [val]))
-	// result: (SRLI [int64(val&63)] x)
-	for {
-		x := v_0
-		if v_1.Op != OpRISCV64MOVWconst {
-			break
-		}
-		val := auxIntToInt32(v_1.AuxInt)
-		v.reset(OpRISCV64SRLI)
-		v.AuxInt = int64ToAuxInt(int64(val & 63))
-		v.AddArg(x)
-		return true
-	}
 	// match: (SRL x (MOVDconst [val]))
 	// result: (SRLI [int64(val&63)] x)
 	for {
@@ -4833,49 +4542,6 @@ func rewriteValueRISCV64_OpRISCV64SRL(v *Value) bool {
 func rewriteValueRISCV64_OpRISCV64SUB(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
-	// match: (SUB x (MOVBconst [val]))
-	// result: (ADDI [-int64(val)] x)
-	for {
-		x := v_0
-		if v_1.Op != OpRISCV64MOVBconst {
-			break
-		}
-		val := auxIntToInt8(v_1.AuxInt)
-		v.reset(OpRISCV64ADDI)
-		v.AuxInt = int64ToAuxInt(-int64(val))
-		v.AddArg(x)
-		return true
-	}
-	// match: (SUB x (MOVHconst [val]))
-	// result: (ADDI [-int64(val)] x)
-	for {
-		x := v_0
-		if v_1.Op != OpRISCV64MOVHconst {
-			break
-		}
-		val := auxIntToInt16(v_1.AuxInt)
-		v.reset(OpRISCV64ADDI)
-		v.AuxInt = int64ToAuxInt(-int64(val))
-		v.AddArg(x)
-		return true
-	}
-	// match: (SUB x (MOVWconst [val]))
-	// cond: is32Bit(-int64(val))
-	// result: (ADDI [-int64(val)] x)
-	for {
-		x := v_0
-		if v_1.Op != OpRISCV64MOVWconst {
-			break
-		}
-		val := auxIntToInt32(v_1.AuxInt)
-		if !(is32Bit(-int64(val))) {
-			break
-		}
-		v.reset(OpRISCV64ADDI)
-		v.AuxInt = int64ToAuxInt(-int64(val))
-		v.AddArg(x)
-		return true
-	}
 	// match: (SUB x (MOVDconst [val]))
 	// cond: is32Bit(-val)
 	// result: (ADDI [-val] x)
@@ -4893,36 +4559,6 @@ func rewriteValueRISCV64_OpRISCV64SUB(v *Value) bool {
 		v.AddArg(x)
 		return true
 	}
-	// match: (SUB x (MOVBconst [0]))
-	// result: x
-	for {
-		x := v_0
-		if v_1.Op != OpRISCV64MOVBconst || auxIntToInt8(v_1.AuxInt) != 0 {
-			break
-		}
-		v.copyOf(x)
-		return true
-	}
-	// match: (SUB x (MOVHconst [0]))
-	// result: x
-	for {
-		x := v_0
-		if v_1.Op != OpRISCV64MOVHconst || auxIntToInt16(v_1.AuxInt) != 0 {
-			break
-		}
-		v.copyOf(x)
-		return true
-	}
-	// match: (SUB x (MOVWconst [0]))
-	// result: x
-	for {
-		x := v_0
-		if v_1.Op != OpRISCV64MOVWconst || auxIntToInt32(v_1.AuxInt) != 0 {
-			break
-		}
-		v.copyOf(x)
-		return true
-	}
 	// match: (SUB x (MOVDconst [0]))
 	// result: x
 	for {
@@ -4933,39 +4569,6 @@ func rewriteValueRISCV64_OpRISCV64SUB(v *Value) bool {
 		v.copyOf(x)
 		return true
 	}
-	// match: (SUB (MOVBconst [0]) x)
-	// result: (NEG x)
-	for {
-		if v_0.Op != OpRISCV64MOVBconst || auxIntToInt8(v_0.AuxInt) != 0 {
-			break
-		}
-		x := v_1
-		v.reset(OpRISCV64NEG)
-		v.AddArg(x)
-		return true
-	}
-	// match: (SUB (MOVHconst [0]) x)
-	// result: (NEG x)
-	for {
-		if v_0.Op != OpRISCV64MOVHconst || auxIntToInt16(v_0.AuxInt) != 0 {
-			break
-		}
-		x := v_1
-		v.reset(OpRISCV64NEG)
-		v.AddArg(x)
-		return true
-	}
-	// match: (SUB (MOVWconst [0]) x)
-	// result: (NEG x)
-	for {
-		if v_0.Op != OpRISCV64MOVWconst || auxIntToInt32(v_0.AuxInt) != 0 {
-			break
-		}
-		x := v_1
-		v.reset(OpRISCV64NEG)
-		v.AddArg(x)
-		return true
-	}
 	// match: (SUB (MOVDconst [0]) x)
 	// result: (NEG x)
 	for {
@@ -4982,11 +4585,11 @@ func rewriteValueRISCV64_OpRISCV64SUB(v *Value) bool {
 func rewriteValueRISCV64_OpRISCV64SUBW(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
-	// match: (SUBW x (MOVWconst [0]))
+	// match: (SUBW x (MOVDconst [0]))
 	// result: (ADDIW [0] x)
 	for {
 		x := v_0
-		if v_1.Op != OpRISCV64MOVWconst || auxIntToInt32(v_1.AuxInt) != 0 {
+		if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
 			break
 		}
 		v.reset(OpRISCV64ADDIW)
@@ -5010,54 +4613,6 @@ func rewriteValueRISCV64_OpRISCV64SUBW(v *Value) bool {
 func rewriteValueRISCV64_OpRISCV64XOR(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
-	// match: (XOR (MOVBconst [val]) x)
-	// result: (XORI [int64(val)] x)
-	for {
-		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
-			if v_0.Op != OpRISCV64MOVBconst {
-				continue
-			}
-			val := auxIntToInt8(v_0.AuxInt)
-			x := v_1
-			v.reset(OpRISCV64XORI)
-			v.AuxInt = int64ToAuxInt(int64(val))
-			v.AddArg(x)
-			return true
-		}
-		break
-	}
-	// match: (XOR (MOVHconst [val]) x)
-	// result: (XORI [int64(val)] x)
-	for {
-		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
-			if v_0.Op != OpRISCV64MOVHconst {
-				continue
-			}
-			val := auxIntToInt16(v_0.AuxInt)
-			x := v_1
-			v.reset(OpRISCV64XORI)
-			v.AuxInt = int64ToAuxInt(int64(val))
-			v.AddArg(x)
-			return true
-		}
-		break
-	}
-	// match: (XOR (MOVWconst [val]) x)
-	// result: (XORI [int64(val)] x)
-	for {
-		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
-			if v_0.Op != OpRISCV64MOVWconst {
-				continue
-			}
-			val := auxIntToInt32(v_0.AuxInt)
-			x := v_1
-			v.reset(OpRISCV64XORI)
-			v.AuxInt = int64ToAuxInt(int64(val))
-			v.AddArg(x)
-			return true
-		}
-		break
-	}
 	// match: (XOR (MOVDconst [val]) x)
 	// cond: is32Bit(val)
 	// result: (XORI [val] x)
@@ -5085,23 +4640,23 @@ func rewriteValueRISCV64_OpRotateLeft16(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
 	typ := &b.Func.Config.Types
-	// match: (RotateLeft16 <t> x (MOVHconst [c]))
-	// result: (Or16 (Lsh16x64 <t> x (MOVHconst [c&15])) (Rsh16Ux64 <t> x (MOVHconst [-c&15])))
+	// match: (RotateLeft16 <t> x (MOVDconst [c]))
+	// result: (Or16 (Lsh16x64 <t> x (MOVDconst [c&15])) (Rsh16Ux64 <t> x (MOVDconst [-c&15])))
 	for {
 		t := v.Type
 		x := v_0
-		if v_1.Op != OpRISCV64MOVHconst {
+		if v_1.Op != OpRISCV64MOVDconst {
 			break
 		}
-		c := auxIntToInt16(v_1.AuxInt)
+		c := auxIntToInt64(v_1.AuxInt)
 		v.reset(OpOr16)
 		v0 := b.NewValue0(v.Pos, OpLsh16x64, t)
-		v1 := b.NewValue0(v.Pos, OpRISCV64MOVHconst, typ.UInt16)
-		v1.AuxInt = int16ToAuxInt(c & 15)
+		v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
+		v1.AuxInt = int64ToAuxInt(c & 15)
 		v0.AddArg2(x, v1)
 		v2 := b.NewValue0(v.Pos, OpRsh16Ux64, t)
-		v3 := b.NewValue0(v.Pos, OpRISCV64MOVHconst, typ.UInt16)
-		v3.AuxInt = int16ToAuxInt(-c & 15)
+		v3 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
+		v3.AuxInt = int64ToAuxInt(-c & 15)
 		v2.AddArg2(x, v3)
 		v.AddArg2(v0, v2)
 		return true
@@ -5113,23 +4668,23 @@ func rewriteValueRISCV64_OpRotateLeft32(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
 	typ := &b.Func.Config.Types
-	// match: (RotateLeft32 <t> x (MOVWconst [c]))
-	// result: (Or32 (Lsh32x64 <t> x (MOVWconst [c&31])) (Rsh32Ux64 <t> x (MOVWconst [-c&31])))
+	// match: (RotateLeft32 <t> x (MOVDconst [c]))
+	// result: (Or32 (Lsh32x64 <t> x (MOVDconst [c&31])) (Rsh32Ux64 <t> x (MOVDconst [-c&31])))
 	for {
 		t := v.Type
 		x := v_0
-		if v_1.Op != OpRISCV64MOVWconst {
+		if v_1.Op != OpRISCV64MOVDconst {
 			break
 		}
-		c := auxIntToInt32(v_1.AuxInt)
+		c := auxIntToInt64(v_1.AuxInt)
 		v.reset(OpOr32)
 		v0 := b.NewValue0(v.Pos, OpLsh32x64, t)
-		v1 := b.NewValue0(v.Pos, OpRISCV64MOVWconst, typ.UInt32)
-		v1.AuxInt = int32ToAuxInt(c & 31)
+		v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
+		v1.AuxInt = int64ToAuxInt(c & 31)
 		v0.AddArg2(x, v1)
 		v2 := b.NewValue0(v.Pos, OpRsh32Ux64, t)
-		v3 := b.NewValue0(v.Pos, OpRISCV64MOVWconst, typ.UInt32)
-		v3.AuxInt = int32ToAuxInt(-c & 31)
+		v3 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
+		v3.AuxInt = int64ToAuxInt(-c & 31)
 		v2.AddArg2(x, v3)
 		v.AddArg2(v0, v2)
 		return true
@@ -5169,23 +4724,23 @@ func rewriteValueRISCV64_OpRotateLeft8(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
 	typ := &b.Func.Config.Types
-	// match: (RotateLeft8 <t> x (MOVBconst [c]))
-	// result: (Or8 (Lsh8x64 <t> x (MOVBconst [c&7])) (Rsh8Ux64 <t> x (MOVBconst [-c&7])))
+	// match: (RotateLeft8 <t> x (MOVDconst [c]))
+	// result: (Or8 (Lsh8x64 <t> x (MOVDconst [c&7])) (Rsh8Ux64 <t> x (MOVDconst [-c&7])))
 	for {
 		t := v.Type
 		x := v_0
-		if v_1.Op != OpRISCV64MOVBconst {
+		if v_1.Op != OpRISCV64MOVDconst {
 			break
 		}
-		c := auxIntToInt8(v_1.AuxInt)
+		c := auxIntToInt64(v_1.AuxInt)
 		v.reset(OpOr8)
 		v0 := b.NewValue0(v.Pos, OpLsh8x64, t)
-		v1 := b.NewValue0(v.Pos, OpRISCV64MOVBconst, typ.UInt8)
-		v1.AuxInt = int8ToAuxInt(c & 7)
+		v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
+		v1.AuxInt = int64ToAuxInt(c & 7)
 		v0.AddArg2(x, v1)
 		v2 := b.NewValue0(v.Pos, OpRsh8Ux64, t)
-		v3 := b.NewValue0(v.Pos, OpRISCV64MOVBconst, typ.UInt8)
-		v3.AuxInt = int8ToAuxInt(-c & 7)
+		v3 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
+		v3.AuxInt = int64ToAuxInt(-c & 7)
 		v2.AddArg2(x, v3)
 		v.AddArg2(v0, v2)
 		return true
@@ -6186,7 +5741,7 @@ func rewriteValueRISCV64_OpZero(v *Value) bool {
 		return true
 	}
 	// match: (Zero [1] ptr mem)
-	// result: (MOVBstore ptr (MOVBconst [0]) mem)
+	// result: (MOVBstore ptr (MOVDconst [0]) mem)
 	for {
 		if auxIntToInt64(v.AuxInt) != 1 {
 			break
@@ -6194,14 +5749,14 @@ func rewriteValueRISCV64_OpZero(v *Value) bool {
 		ptr := v_0
 		mem := v_1
 		v.reset(OpRISCV64MOVBstore)
-		v0 := b.NewValue0(v.Pos, OpRISCV64MOVBconst, typ.UInt8)
-		v0.AuxInt = int8ToAuxInt(0)
+		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
+		v0.AuxInt = int64ToAuxInt(0)
 		v.AddArg3(ptr, v0, mem)
 		return true
 	}
 	// match: (Zero [2] {t} ptr mem)
 	// cond: t.Alignment()%2 == 0
-	// result: (MOVHstore ptr (MOVHconst [0]) mem)
+	// result: (MOVHstore ptr (MOVDconst [0]) mem)
 	for {
 		if auxIntToInt64(v.AuxInt) != 2 {
 			break
@@ -6213,13 +5768,13 @@ func rewriteValueRISCV64_OpZero(v *Value) bool {
 			break
 		}
 		v.reset(OpRISCV64MOVHstore)
-		v0 := b.NewValue0(v.Pos, OpRISCV64MOVHconst, typ.UInt16)
-		v0.AuxInt = int16ToAuxInt(0)
+		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
+		v0.AuxInt = int64ToAuxInt(0)
 		v.AddArg3(ptr, v0, mem)
 		return true
 	}
 	// match: (Zero [2] ptr mem)
-	// result: (MOVBstore [1] ptr (MOVBconst [0]) (MOVBstore ptr (MOVBconst [0]) mem))
+	// result: (MOVBstore [1] ptr (MOVDconst [0]) (MOVBstore ptr (MOVDconst [0]) mem))
 	for {
 		if auxIntToInt64(v.AuxInt) != 2 {
 			break
@@ -6228,8 +5783,8 @@ func rewriteValueRISCV64_OpZero(v *Value) bool {
 		mem := v_1
 		v.reset(OpRISCV64MOVBstore)
 		v.AuxInt = int32ToAuxInt(1)
-		v0 := b.NewValue0(v.Pos, OpRISCV64MOVBconst, typ.UInt8)
-		v0.AuxInt = int8ToAuxInt(0)
+		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
+		v0.AuxInt = int64ToAuxInt(0)
 		v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
 		v1.AddArg3(ptr, v0, mem)
 		v.AddArg3(ptr, v0, v1)
@@ -6237,7 +5792,7 @@ func rewriteValueRISCV64_OpZero(v *Value) bool {
 	}
 	// match: (Zero [4] {t} ptr mem)
 	// cond: t.Alignment()%4 == 0
-	// result: (MOVWstore ptr (MOVWconst [0]) mem)
+	// result: (MOVWstore ptr (MOVDconst [0]) mem)
 	for {
 		if auxIntToInt64(v.AuxInt) != 4 {
 			break
@@ -6249,14 +5804,14 @@ func rewriteValueRISCV64_OpZero(v *Value) bool {
 			break
 		}
 		v.reset(OpRISCV64MOVWstore)
-		v0 := b.NewValue0(v.Pos, OpRISCV64MOVWconst, typ.UInt32)
-		v0.AuxInt = int32ToAuxInt(0)
+		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
+		v0.AuxInt = int64ToAuxInt(0)
 		v.AddArg3(ptr, v0, mem)
 		return true
 	}
 	// match: (Zero [4] {t} ptr mem)
 	// cond: t.Alignment()%2 == 0
-	// result: (MOVHstore [2] ptr (MOVHconst [0]) (MOVHstore ptr (MOVHconst [0]) mem))
+	// result: (MOVHstore [2] ptr (MOVDconst [0]) (MOVHstore ptr (MOVDconst [0]) mem))
 	for {
 		if auxIntToInt64(v.AuxInt) != 4 {
 			break
@@ -6269,15 +5824,15 @@ func rewriteValueRISCV64_OpZero(v *Value) bool {
 		}
 		v.reset(OpRISCV64MOVHstore)
 		v.AuxInt = int32ToAuxInt(2)
-		v0 := b.NewValue0(v.Pos, OpRISCV64MOVHconst, typ.UInt16)
-		v0.AuxInt = int16ToAuxInt(0)
+		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
+		v0.AuxInt = int64ToAuxInt(0)
 		v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
 		v1.AddArg3(ptr, v0, mem)
 		v.AddArg3(ptr, v0, v1)
 		return true
 	}
 	// match: (Zero [4] ptr mem)
-	// result: (MOVBstore [3] ptr (MOVBconst [0]) (MOVBstore [2] ptr (MOVBconst [0]) (MOVBstore [1] ptr (MOVBconst [0]) (MOVBstore ptr (MOVBconst [0]) mem))))
+	// result: (MOVBstore [3] ptr (MOVDconst [0]) (MOVBstore [2] ptr (MOVDconst [0]) (MOVBstore [1] ptr (MOVDconst [0]) (MOVBstore ptr (MOVDconst [0]) mem))))
 	for {
 		if auxIntToInt64(v.AuxInt) != 4 {
 			break
@@ -6286,8 +5841,8 @@ func rewriteValueRISCV64_OpZero(v *Value) bool {
 		mem := v_1
 		v.reset(OpRISCV64MOVBstore)
 		v.AuxInt = int32ToAuxInt(3)
-		v0 := b.NewValue0(v.Pos, OpRISCV64MOVBconst, typ.UInt8)
-		v0.AuxInt = int8ToAuxInt(0)
+		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
+		v0.AuxInt = int64ToAuxInt(0)
 		v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
 		v1.AuxInt = int32ToAuxInt(2)
 		v2 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
@@ -6320,7 +5875,7 @@ func rewriteValueRISCV64_OpZero(v *Value) bool {
 	}
 	// match: (Zero [8] {t} ptr mem)
 	// cond: t.Alignment()%4 == 0
-	// result: (MOVWstore [4] ptr (MOVWconst [0]) (MOVWstore ptr (MOVWconst [0]) mem))
+	// result: (MOVWstore [4] ptr (MOVDconst [0]) (MOVWstore ptr (MOVDconst [0]) mem))
 	for {
 		if auxIntToInt64(v.AuxInt) != 8 {
 			break
@@ -6333,8 +5888,8 @@ func rewriteValueRISCV64_OpZero(v *Value) bool {
 		}
 		v.reset(OpRISCV64MOVWstore)
 		v.AuxInt = int32ToAuxInt(4)
-		v0 := b.NewValue0(v.Pos, OpRISCV64MOVWconst, typ.UInt32)
-		v0.AuxInt = int32ToAuxInt(0)
+		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
+		v0.AuxInt = int64ToAuxInt(0)
 		v1 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
 		v1.AddArg3(ptr, v0, mem)
 		v.AddArg3(ptr, v0, v1)
@@ -6342,7 +5897,7 @@ func rewriteValueRISCV64_OpZero(v *Value) bool {
 	}
 	// match: (Zero [8] {t} ptr mem)
 	// cond: t.Alignment()%2 == 0
-	// result: (MOVHstore [6] ptr (MOVHconst [0]) (MOVHstore [4] ptr (MOVHconst [0]) (MOVHstore [2] ptr (MOVHconst [0]) (MOVHstore ptr (MOVHconst [0]) mem))))
+	// result: (MOVHstore [6] ptr (MOVDconst [0]) (MOVHstore [4] ptr (MOVDconst [0]) (MOVHstore [2] ptr (MOVDconst [0]) (MOVHstore ptr (MOVDconst [0]) mem))))
 	for {
 		if auxIntToInt64(v.AuxInt) != 8 {
 			break
@@ -6355,8 +5910,8 @@ func rewriteValueRISCV64_OpZero(v *Value) bool {
 		}
 		v.reset(OpRISCV64MOVHstore)
 		v.AuxInt = int32ToAuxInt(6)
-		v0 := b.NewValue0(v.Pos, OpRISCV64MOVHconst, typ.UInt16)
-		v0.AuxInt = int16ToAuxInt(0)
+		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
+		v0.AuxInt = int64ToAuxInt(0)
 		v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
 		v1.AuxInt = int32ToAuxInt(4)
 		v2 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
@@ -6369,7 +5924,7 @@ func rewriteValueRISCV64_OpZero(v *Value) bool {
 		return true
 	}
 	// match: (Zero [3] ptr mem)
-	// result: (MOVBstore [2] ptr (MOVBconst [0]) (MOVBstore [1] ptr (MOVBconst [0]) (MOVBstore ptr (MOVBconst [0]) mem)))
+	// result: (MOVBstore [2] ptr (MOVDconst [0]) (MOVBstore [1] ptr (MOVDconst [0]) (MOVBstore ptr (MOVDconst [0]) mem)))
 	for {
 		if auxIntToInt64(v.AuxInt) != 3 {
 			break
@@ -6378,8 +5933,8 @@ func rewriteValueRISCV64_OpZero(v *Value) bool {
 		mem := v_1
 		v.reset(OpRISCV64MOVBstore)
 		v.AuxInt = int32ToAuxInt(2)
-		v0 := b.NewValue0(v.Pos, OpRISCV64MOVBconst, typ.UInt8)
-		v0.AuxInt = int8ToAuxInt(0)
+		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
+		v0.AuxInt = int64ToAuxInt(0)
 		v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
 		v1.AuxInt = int32ToAuxInt(1)
 		v2 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
@@ -6390,7 +5945,7 @@ func rewriteValueRISCV64_OpZero(v *Value) bool {
 	}
 	// match: (Zero [6] {t} ptr mem)
 	// cond: t.Alignment()%2 == 0
-	// result: (MOVHstore [4] ptr (MOVHconst [0]) (MOVHstore [2] ptr (MOVHconst [0]) (MOVHstore ptr (MOVHconst [0]) mem)))
+	// result: (MOVHstore [4] ptr (MOVDconst [0]) (MOVHstore [2] ptr (MOVDconst [0]) (MOVHstore ptr (MOVDconst [0]) mem)))
 	for {
 		if auxIntToInt64(v.AuxInt) != 6 {
 			break
@@ -6403,8 +5958,8 @@ func rewriteValueRISCV64_OpZero(v *Value) bool {
 		}
 		v.reset(OpRISCV64MOVHstore)
 		v.AuxInt = int32ToAuxInt(4)
-		v0 := b.NewValue0(v.Pos, OpRISCV64MOVHconst, typ.UInt16)
-		v0.AuxInt = int16ToAuxInt(0)
+		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
+		v0.AuxInt = int64ToAuxInt(0)
 		v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
 		v1.AuxInt = int32ToAuxInt(2)
 		v2 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
@@ -6415,7 +5970,7 @@ func rewriteValueRISCV64_OpZero(v *Value) bool {
 	}
 	// match: (Zero [12] {t} ptr mem)
 	// cond: t.Alignment()%4 == 0
-	// result: (MOVWstore [8] ptr (MOVWconst [0]) (MOVWstore [4] ptr (MOVWconst [0]) (MOVWstore ptr (MOVWconst [0]) mem)))
+	// result: (MOVWstore [8] ptr (MOVDconst [0]) (MOVWstore [4] ptr (MOVDconst [0]) (MOVWstore ptr (MOVDconst [0]) mem)))
 	for {
 		if auxIntToInt64(v.AuxInt) != 12 {
 			break
@@ -6428,8 +5983,8 @@ func rewriteValueRISCV64_OpZero(v *Value) bool {
 		}
 		v.reset(OpRISCV64MOVWstore)
 		v.AuxInt = int32ToAuxInt(8)
-		v0 := b.NewValue0(v.Pos, OpRISCV64MOVWconst, typ.UInt32)
-		v0.AuxInt = int32ToAuxInt(0)
+		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
+		v0.AuxInt = int64ToAuxInt(0)
 		v1 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
 		v1.AuxInt = int32ToAuxInt(4)
 		v2 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
-- 
GitLab


From 42c25e65f321a75b9be1725d77ea3e7175dc34ad Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Wed, 17 Mar 2021 01:39:11 +1100
Subject: [PATCH 1141/2400] cmd/compile: actually intrinsify
 runtime/internal/atomic.{And,Or}{8,} on RISCV64

Actually enable intrinsics for runtime/internal/atomic.{And,Or}{8,} on RISCV64.
This seems to have been lost when CL 268098 was rebased.

Change-Id: If072daa79c8964b186c127d5e065a7cc9e23ba27
Reviewed-on: https://go-review.googlesource.com/c/go/+/302229
Trust: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssagen/ssa.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 45e39478fa..293062b8ec 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -4019,25 +4019,25 @@ func InitTables() {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicAnd8, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
-		sys.AMD64, sys.MIPS, sys.PPC64, sys.S390X)
+		sys.AMD64, sys.MIPS, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "And",
 		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicAnd32, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
-		sys.AMD64, sys.MIPS, sys.PPC64, sys.S390X)
+		sys.AMD64, sys.MIPS, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Or8",
 		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicOr8, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
-		sys.AMD64, sys.ARM64, sys.MIPS, sys.PPC64, sys.S390X)
+		sys.AMD64, sys.ARM64, sys.MIPS, sys.PPC64, sys.RISCV64, sys.S390X)
 	addF("runtime/internal/atomic", "Or",
 		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			s.vars[memVar] = s.newValue3(ssa.OpAtomicOr32, types.TypeMem, args[0], args[1], s.mem())
 			return nil
 		},
-		sys.AMD64, sys.MIPS, sys.PPC64, sys.S390X)
+		sys.AMD64, sys.MIPS, sys.PPC64, sys.RISCV64, sys.S390X)
 
 	atomicAndOrEmitterARM64 := func(s *state, n *ir.CallExpr, args []*ssa.Value, op ssa.Op, typ types.Kind) {
 		s.vars[memVar] = s.newValue3(op, types.TypeMem, args[0], args[1], s.mem())
-- 
GitLab


From c2d625168fd636a390e1e69b10c7f3c98569ded8 Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Thu, 18 Mar 2021 03:32:32 +1100
Subject: [PATCH 1142/2400] cmd/compile,cmd/internal/obj/riscv: load >32-bit
 constants from memory for riscv64

Follow what MIPS does and load >32-bit constants from memory using two instructions,
rather than generating a four to six instruction sequence. This removes more than 2,500
instructions from the Go binary. This also makes it possible to load >32-bit constants
via a single assembly instruction, if required.

Change-Id: Ie679a0754071e6d8c52fe0d027f00eb241b3a758
Reviewed-on: https://go-review.googlesource.com/c/go/+/302609
Trust: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/asm/internal/asm/testdata/riscv64.s   | 25 +++++-----
 .../compile/internal/ssa/gen/RISCV64.rules    |  9 ----
 .../compile/internal/ssa/rewriteRISCV64.go    | 47 -------------------
 src/cmd/internal/obj/riscv/obj.go             |  9 ++++
 4 files changed, 23 insertions(+), 67 deletions(-)

diff --git a/src/cmd/asm/internal/asm/testdata/riscv64.s b/src/cmd/asm/internal/asm/testdata/riscv64.s
index 9a49d96ca0..77c0764c48 100644
--- a/src/cmd/asm/internal/asm/testdata/riscv64.s
+++ b/src/cmd/asm/internal/asm/testdata/riscv64.s
@@ -280,6 +280,9 @@ start:
 	MOV	$2047, X5				// 9b02f07f
 	MOV	$-2048, X5				// 9b020080
 
+	// Converted to load of symbol.
+	MOV	$4294967296, X5				// 97020000
+
 	MOV	(X5), X6				// 03b30200
 	MOV	4(X5), X6				// 03b34200
 	MOVB	(X5), X6				// 03830200
@@ -325,7 +328,7 @@ start:
 	// These jumps can get printed as jumps to 2 because they go to the
 	// second instruction in the function (the first instruction is an
 	// invisible stack pointer adjustment).
-	JMP	start		// JMP	2		// 6ff09fc2
+	JMP	start		// JMP	2		// 6ff01fc2
 	JMP	(X5)					// 67800200
 	JMP	4(X5)					// 67804200
 
@@ -338,16 +341,16 @@ start:
 	JMP	asmtest(SB)				// 970f0000
 
 	// Branch pseudo-instructions
-	BEQZ	X5, start	// BEQZ	X5, 2		// e38602c0
-	BGEZ	X5, start	// BGEZ	X5, 2		// e3d402c0
-	BGT	X5, X6, start	// BGT	X5, X6, 2	// e34253c0
-	BGTU	X5, X6, start	// BGTU	X5, X6, 2	// e36053c0
-	BGTZ	X5, start	// BGTZ	X5, 2		// e34e50be
-	BLE	X5, X6, start	// BLE	X5, X6, 2	// e35c53be
-	BLEU	X5, X6, start	// BLEU	X5, X6, 2	// e37a53be
-	BLEZ	X5, start	// BLEZ	X5, 2		// e35850be
-	BLTZ	X5, start	// BLTZ	X5, 2		// e3c602be
-	BNEZ	X5, start	// BNEZ	X5, 2		// e39402be
+	BEQZ	X5, start	// BEQZ	X5, 2		// e38202c0
+	BGEZ	X5, start	// BGEZ	X5, 2		// e3d002c0
+	BGT	X5, X6, start	// BGT	X5, X6, 2	// e34e53be
+	BGTU	X5, X6, start	// BGTU	X5, X6, 2	// e36c53be
+	BGTZ	X5, start	// BGTZ	X5, 2		// e34a50be
+	BLE	X5, X6, start	// BLE	X5, X6, 2	// e35853be
+	BLEU	X5, X6, start	// BLEU	X5, X6, 2	// e37653be
+	BLEZ	X5, start	// BLEZ	X5, 2		// e35450be
+	BLTZ	X5, start	// BLTZ	X5, 2		// e3c202be
+	BNEZ	X5, start	// BNEZ	X5, 2		// e39002be
 
 	// Set pseudo-instructions
 	SEQZ	X15, X15				// 93b71700
diff --git a/src/cmd/compile/internal/ssa/gen/RISCV64.rules b/src/cmd/compile/internal/ssa/gen/RISCV64.rules
index c66109cc44..ec013c11ed 100644
--- a/src/cmd/compile/internal/ssa/gen/RISCV64.rules
+++ b/src/cmd/compile/internal/ssa/gen/RISCV64.rules
@@ -531,15 +531,6 @@
 (ConstNil) => (MOVDconst [0])
 (ConstBool [val]) => (MOVDconst [int64(b2i(val))])
 
-// Convert 64 bit immediate to two 32 bit immediates, combine with add and shift.
-// The lower 32 bit immediate will be treated as signed,
-// so if it is negative, adjust for the borrow by incrementing the top half.
-// We don't have to worry about overflow from the increment,
-// because if the top half is all 1s, and int32(c) is negative,
-// then the overall constant fits in an int32.
-(MOVDconst <t> [c]) && !is32Bit(c) && int32(c) <  0 => (ADD (SLLI <t> [32] (MOVDconst [c>>32+1])) (MOVDconst [int64(int32(c))]))
-(MOVDconst <t> [c]) && !is32Bit(c) && int32(c) >= 0 => (ADD (SLLI <t> [32] (MOVDconst [c>>32+0])) (MOVDconst [int64(int32(c))]))
-
 (Addr {sym} base) => (MOVaddr {sym} [0] base)
 (LocalAddr {sym} base _) => (MOVaddr {sym} base)
 
diff --git a/src/cmd/compile/internal/ssa/rewriteRISCV64.go b/src/cmd/compile/internal/ssa/rewriteRISCV64.go
index 69ae8f5df9..767c7dda1f 100644
--- a/src/cmd/compile/internal/ssa/rewriteRISCV64.go
+++ b/src/cmd/compile/internal/ssa/rewriteRISCV64.go
@@ -438,8 +438,6 @@ func rewriteValueRISCV64(v *Value) bool {
 		return rewriteValueRISCV64_OpRISCV64MOVBstore(v)
 	case OpRISCV64MOVBstorezero:
 		return rewriteValueRISCV64_OpRISCV64MOVBstorezero(v)
-	case OpRISCV64MOVDconst:
-		return rewriteValueRISCV64_OpRISCV64MOVDconst(v)
 	case OpRISCV64MOVDload:
 		return rewriteValueRISCV64_OpRISCV64MOVDload(v)
 	case OpRISCV64MOVDnop:
@@ -3262,51 +3260,6 @@ func rewriteValueRISCV64_OpRISCV64MOVBstorezero(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueRISCV64_OpRISCV64MOVDconst(v *Value) bool {
-	b := v.Block
-	typ := &b.Func.Config.Types
-	// match: (MOVDconst <t> [c])
-	// cond: !is32Bit(c) && int32(c) < 0
-	// result: (ADD (SLLI <t> [32] (MOVDconst [c>>32+1])) (MOVDconst [int64(int32(c))]))
-	for {
-		t := v.Type
-		c := auxIntToInt64(v.AuxInt)
-		if !(!is32Bit(c) && int32(c) < 0) {
-			break
-		}
-		v.reset(OpRISCV64ADD)
-		v0 := b.NewValue0(v.Pos, OpRISCV64SLLI, t)
-		v0.AuxInt = int64ToAuxInt(32)
-		v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
-		v1.AuxInt = int64ToAuxInt(c>>32 + 1)
-		v0.AddArg(v1)
-		v2 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
-		v2.AuxInt = int64ToAuxInt(int64(int32(c)))
-		v.AddArg2(v0, v2)
-		return true
-	}
-	// match: (MOVDconst <t> [c])
-	// cond: !is32Bit(c) && int32(c) >= 0
-	// result: (ADD (SLLI <t> [32] (MOVDconst [c>>32+0])) (MOVDconst [int64(int32(c))]))
-	for {
-		t := v.Type
-		c := auxIntToInt64(v.AuxInt)
-		if !(!is32Bit(c) && int32(c) >= 0) {
-			break
-		}
-		v.reset(OpRISCV64ADD)
-		v0 := b.NewValue0(v.Pos, OpRISCV64SLLI, t)
-		v0.AuxInt = int64ToAuxInt(32)
-		v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
-		v1.AuxInt = int64ToAuxInt(c>>32 + 0)
-		v0.AddArg(v1)
-		v2 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
-		v2.AuxInt = int64ToAuxInt(int64(int32(c)))
-		v.AddArg2(v0, v2)
-		return true
-	}
-	return false
-}
 func rewriteValueRISCV64_OpRISCV64MOVDload(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
diff --git a/src/cmd/internal/obj/riscv/obj.go b/src/cmd/internal/obj/riscv/obj.go
index 391c2486ca..ee6fb0909b 100644
--- a/src/cmd/internal/obj/riscv/obj.go
+++ b/src/cmd/internal/obj/riscv/obj.go
@@ -151,6 +151,15 @@ func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
 	case ASBREAK:
 		// SBREAK is the old name for EBREAK.
 		p.As = AEBREAK
+
+	case AMOV:
+		// Put >32-bit constants in memory and load them.
+		if p.From.Type == obj.TYPE_CONST && p.From.Name == obj.NAME_NONE && p.From.Reg == 0 && int64(int32(p.From.Offset)) != p.From.Offset {
+			p.From.Type = obj.TYPE_MEM
+			p.From.Sym = ctxt.Int64Sym(p.From.Offset)
+			p.From.Name = obj.NAME_EXTERN
+			p.From.Offset = 0
+		}
 	}
 }
 
-- 
GitLab


From 732ea4c2dcc1bcbcff65c31047ebb54364e7865d Mon Sep 17 00:00:00 2001
From: Rabin Gaire <rabingaire20@gmail.com>
Date: Sun, 6 Dec 2020 23:17:20 +0545
Subject: [PATCH 1143/2400] sort: add example tests for SearchFloat64s and
 SearchInts

Change-Id: I5fa4773467e3f515250deead72fdce3e4bd0973b
Reviewed-on: https://go-review.googlesource.com/c/go/+/275457
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Robert Griesemer <gri@golang.org>
---
 src/sort/example_search_test.go | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/src/sort/example_search_test.go b/src/sort/example_search_test.go
index 6928f0f092..856422a385 100644
--- a/src/sort/example_search_test.go
+++ b/src/sort/example_search_test.go
@@ -40,3 +40,35 @@ func ExampleSearch_descendingOrder() {
 	// Output:
 	// found 6 at index 7 in [55 45 36 28 21 15 10 6 3 1]
 }
+
+// This example demonstrates searching for float64 in a list sorted in ascending order.
+func ExampleSearchFloat64s() {
+	a := []float64{1.0, 2.0, 3.3, 4.6, 6.1, 7.2, 8.0}
+
+	x := 2.0
+	i := sort.SearchFloat64s(a, x)
+	fmt.Printf("found %g at index %d in %v\n", x, i, a)
+
+	x = 0.5
+	i = sort.SearchFloat64s(a, x)
+	fmt.Printf("%g not found, can be inserted at index %d in %v\n", x, i, a)
+	// Output:
+	// found 2 at index 1 in [1 2 3.3 4.6 6.1 7.2 8]
+	// 0.5 not found, can be inserted at index 0 in [1 2 3.3 4.6 6.1 7.2 8]
+}
+
+// This example demonstrates searching for int in a list sorted in ascending order.
+func ExampleSearchInts() {
+	a := []int{1, 2, 3, 4, 6, 7, 8}
+
+	x := 2
+	i := sort.SearchInts(a, x)
+	fmt.Printf("found %d at index %d in %v\n", x, i, a)
+
+	x = 5
+	i = sort.SearchInts(a, x)
+	fmt.Printf("%d not found, can be inserted at index %d in %v\n", x, i, a)
+	// Output:
+	// found 2 at index 1 in [1 2 3 4 6 7 8]
+	// 5 not found, can be inserted at index 4 in [1 2 3 4 6 7 8]
+}
-- 
GitLab


From 9de49ae01ad332d8cbb79a3094c3fc3d6b6931e6 Mon Sep 17 00:00:00 2001
From: Richard Pickering <richard.pickering@hotmail.co.uk>
Date: Mon, 15 Mar 2021 18:16:05 +0000
Subject: [PATCH 1144/2400] crypto/rsa: correct EncryptOAEP doc comment

Fixes #44777

Corrected the documentation comment on the EncryptOAEP function from
'if a given public key is used to decrypt two types of messages' to
'if a given public key is used to encrypt two types of messages'.

Change-Id: I02aff90d0414960eae72352c0e4d8ba2e8f8eca6
GitHub-Last-Rev: ea28663f8719e8fd0dcb10cf97ffbdcf4bd9674f
GitHub-Pull-Request: golang/go#45032
Reviewed-on: https://go-review.googlesource.com/c/go/+/301714
Reviewed-by: Filippo Valsorda <filippo@golang.org>
Run-TryBot: Filippo Valsorda <filippo@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Robert Findley <rfindley@google.com>
---
 src/crypto/rsa/rsa.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/crypto/rsa/rsa.go b/src/crypto/rsa/rsa.go
index 178ade666a..6fd59b3940 100644
--- a/src/crypto/rsa/rsa.go
+++ b/src/crypto/rsa/rsa.go
@@ -401,7 +401,7 @@ func encrypt(c *big.Int, pub *PublicKey, m *big.Int) *big.Int {
 //
 // The label parameter may contain arbitrary data that will not be encrypted,
 // but which gives important context to the message. For example, if a given
-// public key is used to decrypt two types of messages then distinct label
+// public key is used to encrypt two types of messages then distinct label
 // values could be used to ensure that a ciphertext for one purpose cannot be
 // used for another by an attacker. If not required it can be empty.
 //
-- 
GitLab


From db4adb1a9ba2ecd8809aab9bf26cc25d2f0c877b Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Wed, 17 Mar 2021 23:55:07 -0400
Subject: [PATCH 1145/2400] cmd/link: print symbol versions in stack bound
 check

When the stack bound check fails, print the call chain with
symbol versions (along with the names). Now that we have ABI
wrappers and wrappers do consume stack space, it is clearer to
distinguish the wrappers vs. the underlying functions.

Change-Id: Id1d922e3e7934b31317f233aff3d9667b6ac90c8
Reviewed-on: https://go-review.googlesource.com/c/go/+/302869
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/ld/lib.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index 4c69d24354..500dca2b8b 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -2416,7 +2416,7 @@ func (sc *stkChk) print(ch *chain, limit int) {
 	ctxt := sc.ctxt
 	var name string
 	if ch.sym != 0 {
-		name = ldr.SymName(ch.sym)
+		name = fmt.Sprintf("%s<%d>", ldr.SymName(ch.sym), ldr.SymVersion(ch.sym))
 		if ldr.IsNoSplit(ch.sym) {
 			name += " (nosplit)"
 		}
-- 
GitLab


From 6b6ea3271fd4f0ed99d5390461db9fa45ce4c164 Mon Sep 17 00:00:00 2001
From: Andy Pan <panjf2000@gmail.com>
Date: Thu, 18 Mar 2021 10:45:04 +0800
Subject: [PATCH 1146/2400] cmd/go: use the global rooted path name

Change-Id: I4a450af5f35f0ad4e4652789f1eda4d3171610e7
Reviewed-on: https://go-review.googlesource.com/c/go/+/302852
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Trust: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/base/path.go | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/cmd/go/internal/base/path.go b/src/cmd/go/internal/base/path.go
index 7a51181c97..cb4adbde42 100644
--- a/src/cmd/go/internal/base/path.go
+++ b/src/cmd/go/internal/base/path.go
@@ -32,10 +32,8 @@ func ShortPath(path string) string {
 // made relative to the current directory if they would be shorter.
 func RelPaths(paths []string) []string {
 	var out []string
-	// TODO(rsc): Can this use Cwd from above?
-	pwd, _ := os.Getwd()
 	for _, p := range paths {
-		rel, err := filepath.Rel(pwd, p)
+		rel, err := filepath.Rel(Cwd, p)
 		if err == nil && len(rel) < len(p) {
 			p = rel
 		}
-- 
GitLab


From e726e2a6087683eb21afe79ef8b5a1dbef80b0f1 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 26 Feb 2021 13:28:23 -0500
Subject: [PATCH 1147/2400] cmd/go: suppress errors for 'go get' of module
 paths that are also constrained-out packages

Fixes #33526

Change-Id: Iedd2d6dbe440499bf074ac632513319a22f2d648
Reviewed-on: https://go-review.googlesource.com/c/go/+/297009
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modget/get.go             | 25 ++++++++++---
 src/cmd/go/internal/modload/load.go           | 36 +++++++++++++------
 .../go/testdata/script/mod_get_pkgtags.txt    | 14 ++++++++
 3 files changed, 60 insertions(+), 15 deletions(-)

diff --git a/src/cmd/go/internal/modget/get.go b/src/cmd/go/internal/modget/get.go
index 6b416d3622..4892db8781 100644
--- a/src/cmd/go/internal/modget/get.go
+++ b/src/cmd/go/internal/modget/get.go
@@ -369,7 +369,23 @@ func runGet(ctx context.Context, cmd *base.Command, args []string) {
 	// directory.
 	if !*getD && len(pkgPatterns) > 0 {
 		work.BuildInit()
-		pkgs := load.PackagesAndErrors(ctx, pkgPatterns)
+
+		var pkgs []*load.Package
+		for _, pkg := range load.PackagesAndErrors(ctx, pkgPatterns) {
+			if pkg.Error != nil {
+				var noGo *load.NoGoError
+				if errors.As(pkg.Error.Err, &noGo) {
+					if m := modload.PackageModule(pkg.ImportPath); m.Path == pkg.ImportPath {
+						// pkg is at the root of a module, and doesn't exist with the current
+						// build tags. Probably the user just wanted to change the version of
+						// that module — not also build the package — so suppress the error.
+						// (See https://golang.org/issue/33526.)
+						continue
+					}
+				}
+			}
+			pkgs = append(pkgs, pkg)
+		}
 		load.CheckPackageErrors(pkgs)
 		work.InstallPackages(ctx, pkgPatterns, pkgs)
 		// TODO(#40276): After Go 1.16, print a deprecation notice when building and
@@ -1453,6 +1469,7 @@ func (r *resolver) checkPackagesAndRetractions(ctx context.Context, pkgPatterns
 			LoadTests:                *getT,
 			ResolveMissingImports:    false,
 			AllowErrors:              true,
+			SilenceNoGoErrors:        true,
 		}
 		matches, pkgs := modload.LoadPackages(ctx, pkgOpts, pkgPatterns...)
 		for _, m := range matches {
@@ -1468,9 +1485,9 @@ func (r *resolver) checkPackagesAndRetractions(ctx context.Context, pkgPatterns
 					// associated with either the package or its test — ErrNoGo must
 					// indicate that none of those source files happen to apply in this
 					// configuration. If we are actually building the package (no -d
-					// flag), the compiler will report the problem; otherwise, assume that
-					// the user is going to build or test it in some other configuration
-					// and suppress the error.
+					// flag), we will report the problem then; otherwise, assume that the
+					// user is going to build or test this package in some other
+					// configuration and suppress the error.
 					continue
 				}
 
diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index 2e62a7659f..1be6a71bbf 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -181,6 +181,15 @@ type PackageOpts struct {
 	// future version).
 	SilenceMissingStdImports bool
 
+	// SilenceNoGoErrors indicates that LoadPackages should not print
+	// imports.ErrNoGo errors.
+	// This allows the caller to invoke LoadPackages (and report other errors)
+	// without knowing whether the requested packages exist for the given tags.
+	//
+	// Note that if a requested package does not exist *at all*, it will fail
+	// during module resolution and the error will not be suppressed.
+	SilenceNoGoErrors bool
+
 	// SilenceUnmatchedWarnings suppresses the warnings normally emitted for
 	// patterns that did not match any packages.
 	SilenceUnmatchedWarnings bool
@@ -290,6 +299,10 @@ func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (ma
 	// Report errors, if any.
 	checkMultiplePaths()
 	for _, pkg := range loaded.pkgs {
+		if !pkg.isTest() {
+			loadedPackages = append(loadedPackages, pkg.path)
+		}
+
 		if pkg.err != nil {
 			if sumErr := (*ImportMissingSumError)(nil); errors.As(pkg.err, &sumErr) {
 				if importer := pkg.stack; importer != nil {
@@ -298,23 +311,24 @@ func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (ma
 					sumErr.importerIsTest = importer.testOf != nil
 				}
 			}
-			silence := opts.SilenceErrors
+
+			if opts.SilenceErrors {
+				continue
+			}
 			if stdErr := (*ImportMissingError)(nil); errors.As(pkg.err, &stdErr) &&
 				stdErr.isStd && opts.SilenceMissingStdImports {
-				silence = true
+				continue
+			}
+			if opts.SilenceNoGoErrors && errors.Is(pkg.err, imports.ErrNoGo) {
+				continue
 			}
 
-			if !silence {
-				if opts.AllowErrors {
-					fmt.Fprintf(os.Stderr, "%s: %v\n", pkg.stackText(), pkg.err)
-				} else {
-					base.Errorf("%s: %v", pkg.stackText(), pkg.err)
-				}
+			if opts.AllowErrors {
+				fmt.Fprintf(os.Stderr, "%s: %v\n", pkg.stackText(), pkg.err)
+			} else {
+				base.Errorf("%s: %v", pkg.stackText(), pkg.err)
 			}
 		}
-		if !pkg.isTest() {
-			loadedPackages = append(loadedPackages, pkg.path)
-		}
 	}
 	if !opts.SilenceErrors {
 		// Also list errors in matching patterns (such as directory permission
diff --git a/src/cmd/go/testdata/script/mod_get_pkgtags.txt b/src/cmd/go/testdata/script/mod_get_pkgtags.txt
index c0a57f3fab..0c79ec71b7 100644
--- a/src/cmd/go/testdata/script/mod_get_pkgtags.txt
+++ b/src/cmd/go/testdata/script/mod_get_pkgtags.txt
@@ -16,6 +16,7 @@ go mod edit -droprequire example.net/tools
 # error out if dependencies of tag-guarded files are missing.
 
 go get -d example.net/tools@v0.1.0
+! stderr 'no Go source files'
 
 ! go list example.net/tools
 stderr '^package example.net/tools: build constraints exclude all Go files in .*[/\\]tools$'
@@ -30,6 +31,19 @@ go list -deps example.net/cmd/tool
 stderr '^no required module provides package example.net/missing; to add it:\n\tgo get example.net/missing$'
 
 
+# https://golang.org/issue/33526: 'go get' without '-d' should succeed
+# for a module whose root is a constrained-out package.
+#
+# Ideally it should silently succeed, but today it logs the "no Go source files"
+# error and succeeds anyway.
+
+go get example.net/tools@v0.1.0
+! stderr .
+
+! go build example.net/tools
+stderr '^package example.net/tools: build constraints exclude all Go files in .*[/\\]tools$'
+
+
 # https://golang.org/issue/29268
 # 'go get' should fetch modules whose roots contain test-only packages, but
 # without the -t flag shouldn't error out if the test has missing dependencies.
-- 
GitLab


From b7cb92ad12e6e988ad73313773e1ca229a333005 Mon Sep 17 00:00:00 2001
From: Michael Matloob <matloob@golang.org>
Date: Mon, 15 Mar 2021 13:59:24 -0400
Subject: [PATCH 1148/2400] cmd/go: remove renameio package and its last usage

The last primary usage of renameio was the WriteFile in
modfetch.WriteDiskCache. Because it's not guaranteed that the fsync in
WriteDiskCache will eliminate file corruption, and it slows down tests
on Macs significantly, inline that last usage, removing the fsync.

Also, remove the uses of renameio.Pattern. The ziphash file is no
longer written to a temporary location before being copied to its
final location, so that usage can just be cut. The remaining use is
for the zipfile . Remove the first because the files are no longer
written using the pattern anyway, so that the pattern variable has no
effect. Replace it with a local pattern variable that is also passed
to os.CreateTemp.

Change-Id: Icf3adabf2a26c37b82afa1d07f821a46b30d69ce
Reviewed-on: https://go-review.googlesource.com/c/go/+/301889
Trust: Michael Matloob <matloob@golang.org>
Run-TryBot: Michael Matloob <matloob@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/internal/modfetch/cache.go         |  43 ++++-
 src/cmd/go/internal/modfetch/fetch.go         |  12 +-
 src/cmd/go/internal/renameio/renameio.go      |  88 ----------
 src/cmd/go/internal/renameio/renameio_test.go | 161 ------------------
 src/cmd/go/internal/renameio/umask_test.go    |  43 -----
 5 files changed, 45 insertions(+), 302 deletions(-)
 delete mode 100644 src/cmd/go/internal/renameio/renameio.go
 delete mode 100644 src/cmd/go/internal/renameio/renameio_test.go
 delete mode 100644 src/cmd/go/internal/renameio/umask_test.go

diff --git a/src/cmd/go/internal/modfetch/cache.go b/src/cmd/go/internal/modfetch/cache.go
index d6774e1ce1..776def7cbc 100644
--- a/src/cmd/go/internal/modfetch/cache.go
+++ b/src/cmd/go/internal/modfetch/cache.go
@@ -11,8 +11,10 @@ import (
 	"fmt"
 	"io"
 	"io/fs"
+	"math/rand"
 	"os"
 	"path/filepath"
+	"strconv"
 	"strings"
 	"sync"
 
@@ -21,7 +23,7 @@ import (
 	"cmd/go/internal/lockedfile"
 	"cmd/go/internal/modfetch/codehost"
 	"cmd/go/internal/par"
-	"cmd/go/internal/renameio"
+	"cmd/go/internal/robustio"
 
 	"golang.org/x/mod/module"
 	"golang.org/x/mod/semver"
@@ -543,7 +545,7 @@ func readDiskCache(path, rev, suffix string) (file string, data []byte, err erro
 	if err != nil {
 		return "", nil, errNotCached
 	}
-	data, err = renameio.ReadFile(file)
+	data, err = robustio.ReadFile(file)
 	if err != nil {
 		return file, nil, errNotCached
 	}
@@ -580,7 +582,29 @@ func writeDiskCache(file string, data []byte) error {
 		return err
 	}
 
-	if err := renameio.WriteFile(file, data, 0666); err != nil {
+	// Write the file to a temporary location, and then rename it to its final
+	// path to reduce the likelihood of a corrupt file existing at that final path.
+	f, err := tempFile(filepath.Dir(file), filepath.Base(file), 0666)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		// Only call os.Remove on f.Name() if we failed to rename it: otherwise,
+		// some other process may have created a new file with the same name after
+		// the rename completed.
+		if err != nil {
+			f.Close()
+			os.Remove(f.Name())
+		}
+	}()
+
+	if _, err := f.Write(data); err != nil {
+		return err
+	}
+	if err := f.Close(); err != nil {
+		return err
+	}
+	if err := robustio.Rename(f.Name(), file); err != nil {
 		return err
 	}
 
@@ -590,6 +614,19 @@ func writeDiskCache(file string, data []byte) error {
 	return nil
 }
 
+// tempFile creates a new temporary file with given permission bits.
+func tempFile(dir, prefix string, perm fs.FileMode) (f *os.File, err error) {
+	for i := 0; i < 10000; i++ {
+		name := filepath.Join(dir, prefix+strconv.Itoa(rand.Intn(1000000000))+".tmp")
+		f, err = os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_EXCL, perm)
+		if os.IsExist(err) {
+			continue
+		}
+		break
+	}
+	return
+}
+
 // rewriteVersionList rewrites the version list in dir
 // after a new *.mod file has been written.
 func rewriteVersionList(dir string) (err error) {
diff --git a/src/cmd/go/internal/modfetch/fetch.go b/src/cmd/go/internal/modfetch/fetch.go
index 4ee490c5ea..e40593abae 100644
--- a/src/cmd/go/internal/modfetch/fetch.go
+++ b/src/cmd/go/internal/modfetch/fetch.go
@@ -24,7 +24,6 @@ import (
 	"cmd/go/internal/cfg"
 	"cmd/go/internal/lockedfile"
 	"cmd/go/internal/par"
-	"cmd/go/internal/renameio"
 	"cmd/go/internal/robustio"
 	"cmd/go/internal/trace"
 
@@ -223,11 +222,10 @@ func downloadZip(ctx context.Context, mod module.Version, zipfile string) (err e
 	// Clean up any remaining tempfiles from previous runs.
 	// This is only safe to do because the lock file ensures that their
 	// writers are no longer active.
-	for _, base := range []string{zipfile, zipfile + "hash"} {
-		if old, err := filepath.Glob(renameio.Pattern(base)); err == nil {
-			for _, path := range old {
-				os.Remove(path) // best effort
-			}
+	tmpPattern := filepath.Base(zipfile) + "*.tmp"
+	if old, err := filepath.Glob(filepath.Join(filepath.Dir(zipfile), tmpPattern)); err == nil {
+		for _, path := range old {
+			os.Remove(path) // best effort
 		}
 	}
 
@@ -242,7 +240,7 @@ func downloadZip(ctx context.Context, mod module.Version, zipfile string) (err e
 	// contents of the file (by hashing it) before we commit it. Because the file
 	// is zip-compressed, we need an actual file — or at least an io.ReaderAt — to
 	// validate it: we can't just tee the stream as we write it.
-	f, err := os.CreateTemp(filepath.Dir(zipfile), filepath.Base(renameio.Pattern(zipfile)))
+	f, err := os.CreateTemp(filepath.Dir(zipfile), tmpPattern)
 	if err != nil {
 		return err
 	}
diff --git a/src/cmd/go/internal/renameio/renameio.go b/src/cmd/go/internal/renameio/renameio.go
deleted file mode 100644
index 811f4573a0..0000000000
--- a/src/cmd/go/internal/renameio/renameio.go
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright 2018 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 renameio writes files atomically by renaming temporary files.
-package renameio
-
-import (
-	"bytes"
-	"io"
-	"io/fs"
-	"math/rand"
-	"os"
-	"path/filepath"
-	"strconv"
-
-	"cmd/go/internal/robustio"
-)
-
-const patternSuffix = ".tmp"
-
-// Pattern returns a glob pattern that matches the unrenamed temporary files
-// created when writing to filename.
-func Pattern(filename string) string {
-	return filepath.Join(filepath.Dir(filename), filepath.Base(filename)+patternSuffix)
-}
-
-// WriteFile is like os.WriteFile, but first writes data to an arbitrary
-// file in the same directory as filename, then renames it atomically to the
-// final name.
-//
-// That ensures that the final location, if it exists, is always a complete file.
-func WriteFile(filename string, data []byte, perm fs.FileMode) (err error) {
-	f, err := tempFile(filepath.Dir(filename), filepath.Base(filename), perm)
-	if err != nil {
-		return err
-	}
-	defer func() {
-		// Only call os.Remove on f.Name() if we failed to rename it: otherwise,
-		// some other process may have created a new file with the same name after
-		// that.
-		if err != nil {
-			f.Close()
-			os.Remove(f.Name())
-		}
-	}()
-
-	if _, err := io.Copy(f, bytes.NewReader(data)); err != nil {
-		return err
-	}
-	// Sync the file before renaming it: otherwise, after a crash the reader may
-	// observe a 0-length file instead of the actual contents.
-	// See https://golang.org/issue/22397#issuecomment-380831736.
-	if err := f.Sync(); err != nil {
-		return err
-	}
-	if err := f.Close(); err != nil {
-		return err
-	}
-
-	return robustio.Rename(f.Name(), filename)
-}
-
-// ReadFile is like os.ReadFile, but on Windows retries spurious errors that
-// may occur if the file is concurrently replaced.
-//
-// Errors are classified heuristically and retries are bounded, so even this
-// function may occasionally return a spurious error on Windows.
-// If so, the error will likely wrap one of:
-// 	- syscall.ERROR_ACCESS_DENIED
-// 	- syscall.ERROR_FILE_NOT_FOUND
-// 	- internal/syscall/windows.ERROR_SHARING_VIOLATION
-func ReadFile(filename string) ([]byte, error) {
-	return robustio.ReadFile(filename)
-}
-
-// tempFile creates a new temporary file with given permission bits.
-func tempFile(dir, prefix string, perm fs.FileMode) (f *os.File, err error) {
-	for i := 0; i < 10000; i++ {
-		name := filepath.Join(dir, prefix+strconv.Itoa(rand.Intn(1000000000))+patternSuffix)
-		f, err = os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_EXCL, perm)
-		if os.IsExist(err) {
-			continue
-		}
-		break
-	}
-	return
-}
diff --git a/src/cmd/go/internal/renameio/renameio_test.go b/src/cmd/go/internal/renameio/renameio_test.go
deleted file mode 100644
index 1c8d7e311d..0000000000
--- a/src/cmd/go/internal/renameio/renameio_test.go
+++ /dev/null
@@ -1,161 +0,0 @@
-// Copyright 2019 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.
-
-//go:build !plan9
-// +build !plan9
-
-package renameio
-
-import (
-	"encoding/binary"
-	"errors"
-	"internal/testenv"
-	"math/rand"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"syscall"
-	"testing"
-	"time"
-
-	"cmd/go/internal/robustio"
-)
-
-func TestConcurrentReadsAndWrites(t *testing.T) {
-	if runtime.GOOS == "darwin" && strings.HasSuffix(testenv.Builder(), "-10_14") {
-		testenv.SkipFlaky(t, 33041)
-	}
-
-	dir, err := os.MkdirTemp("", "renameio")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
-	path := filepath.Join(dir, "blob.bin")
-
-	const chunkWords = 8 << 10
-	buf := make([]byte, 2*chunkWords*8)
-	for i := uint64(0); i < 2*chunkWords; i++ {
-		binary.LittleEndian.PutUint64(buf[i*8:], i)
-	}
-
-	var attempts int64 = 128
-	if !testing.Short() {
-		attempts *= 16
-	}
-	const parallel = 32
-
-	var sem = make(chan bool, parallel)
-
-	var (
-		writeSuccesses, readSuccesses int64 // atomic
-		writeErrnoSeen, readErrnoSeen sync.Map
-	)
-
-	for n := attempts; n > 0; n-- {
-		sem <- true
-		go func() {
-			defer func() { <-sem }()
-
-			time.Sleep(time.Duration(rand.Intn(100)) * time.Microsecond)
-			offset := rand.Intn(chunkWords)
-			chunk := buf[offset*8 : (offset+chunkWords)*8]
-			if err := WriteFile(path, chunk, 0666); err == nil {
-				atomic.AddInt64(&writeSuccesses, 1)
-			} else if robustio.IsEphemeralError(err) {
-				var (
-					errno syscall.Errno
-					dup   bool
-				)
-				if errors.As(err, &errno) {
-					_, dup = writeErrnoSeen.LoadOrStore(errno, true)
-				}
-				if !dup {
-					t.Logf("ephemeral error: %v", err)
-				}
-			} else {
-				t.Errorf("unexpected error: %v", err)
-			}
-
-			time.Sleep(time.Duration(rand.Intn(100)) * time.Microsecond)
-			data, err := robustio.ReadFile(path)
-			if err == nil {
-				atomic.AddInt64(&readSuccesses, 1)
-			} else if robustio.IsEphemeralError(err) {
-				var (
-					errno syscall.Errno
-					dup   bool
-				)
-				if errors.As(err, &errno) {
-					_, dup = readErrnoSeen.LoadOrStore(errno, true)
-				}
-				if !dup {
-					t.Logf("ephemeral error: %v", err)
-				}
-				return
-			} else {
-				t.Errorf("unexpected error: %v", err)
-				return
-			}
-
-			if len(data) != 8*chunkWords {
-				t.Errorf("read %d bytes, but each write is a %d-byte file", len(data), 8*chunkWords)
-				return
-			}
-
-			u := binary.LittleEndian.Uint64(data)
-			for i := 1; i < chunkWords; i++ {
-				next := binary.LittleEndian.Uint64(data[i*8:])
-				if next != u+1 {
-					t.Errorf("wrote sequential integers, but read integer out of sequence at offset %d", i)
-					return
-				}
-				u = next
-			}
-		}()
-	}
-
-	for n := parallel; n > 0; n-- {
-		sem <- true
-	}
-
-	var minWriteSuccesses int64 = attempts
-	if runtime.GOOS == "windows" {
-		// Windows produces frequent "Access is denied" errors under heavy rename load.
-		// As long as those are the only errors and *some* of the writes succeed, we're happy.
-		minWriteSuccesses = attempts / 4
-	}
-
-	if writeSuccesses < minWriteSuccesses {
-		t.Errorf("%d (of %d) writes succeeded; want ≥ %d", writeSuccesses, attempts, minWriteSuccesses)
-	} else {
-		t.Logf("%d (of %d) writes succeeded (ok: ≥ %d)", writeSuccesses, attempts, minWriteSuccesses)
-	}
-
-	var minReadSuccesses int64 = attempts
-
-	switch runtime.GOOS {
-	case "windows":
-		// Windows produces frequent "Access is denied" errors under heavy rename load.
-		// As long as those are the only errors and *some* of the reads succeed, we're happy.
-		minReadSuccesses = attempts / 4
-
-	case "darwin", "ios":
-		// The filesystem on certain versions of macOS (10.14) and iOS (affected
-		// versions TBD) occasionally fail with "no such file or directory" errors.
-		// See https://golang.org/issue/33041 and https://golang.org/issue/42066.
-		// The flake rate is fairly low, so ensure that at least 75% of attempts
-		// succeed.
-		minReadSuccesses = attempts - (attempts / 4)
-	}
-
-	if readSuccesses < minReadSuccesses {
-		t.Errorf("%d (of %d) reads succeeded; want ≥ %d", readSuccesses, attempts, minReadSuccesses)
-	} else {
-		t.Logf("%d (of %d) reads succeeded (ok: ≥ %d)", readSuccesses, attempts, minReadSuccesses)
-	}
-}
diff --git a/src/cmd/go/internal/renameio/umask_test.go b/src/cmd/go/internal/renameio/umask_test.go
deleted file mode 100644
index bed45af6ed..0000000000
--- a/src/cmd/go/internal/renameio/umask_test.go
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright 2019 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.
-
-//go:build !plan9 && !windows && !js
-// +build !plan9,!windows,!js
-
-package renameio
-
-import (
-	"io/fs"
-	"os"
-	"path/filepath"
-	"syscall"
-	"testing"
-)
-
-func TestWriteFileModeAppliesUmask(t *testing.T) {
-	dir, err := os.MkdirTemp("", "renameio")
-	if err != nil {
-		t.Fatalf("Failed to create temporary directory: %v", err)
-	}
-	defer os.RemoveAll(dir)
-
-	const mode = 0644
-	const umask = 0007
-	defer syscall.Umask(syscall.Umask(umask))
-
-	file := filepath.Join(dir, "testWrite")
-	err = WriteFile(file, []byte("go-build"), mode)
-	if err != nil {
-		t.Fatalf("Failed to write file: %v", err)
-	}
-
-	fi, err := os.Stat(file)
-	if err != nil {
-		t.Fatalf("Stat %q (looking for mode %#o): %s", file, mode, err)
-	}
-
-	if fi.Mode()&fs.ModePerm != 0640 {
-		t.Errorf("Stat %q: mode %#o want %#o", file, fi.Mode()&fs.ModePerm, 0640)
-	}
-}
-- 
GitLab


From 06ca809410649e24c1a3a079a0a859bae2d4613a Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Mon, 15 Mar 2021 15:43:45 -0400
Subject: [PATCH 1149/2400] cmd/internal/objabi: centralize GOEXPERIMENT
 parsing

objabi parses GOEXPERIMENT, but most of the consumers look at the raw
GOEXPERIMENT string that objabi gets from the environment. Centralize
this logic by only exposing the parsed GOEXPERIMENT value from objabi.
This sets us up for the next few changes. It also has the nice but
mostly useless property that the order of experiment names will be
canonicalized in build cache hashes.

After this, the only remaining place that looks at raw GOEXPERIMENT is
cmd/dist, which we'll fix in the next CL.

For #40724.

Change-Id: Idb150f848e17c184fae91372ca8b361591472f51
Reviewed-on: https://go-review.googlesource.com/c/go/+/302049
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/go/internal/cfg/cfg.go   | 13 +++---
 src/cmd/go/internal/work/exec.go | 11 +++---
 src/cmd/go/internal/work/init.go | 11 ++----
 src/cmd/internal/objabi/flag.go  |  2 +-
 src/cmd/internal/objabi/util.go  | 68 +++++++++++++++++++++-----------
 5 files changed, 60 insertions(+), 45 deletions(-)

diff --git a/src/cmd/go/internal/cfg/cfg.go b/src/cmd/go/internal/cfg/cfg.go
index a91b6a57b9..810189c15d 100644
--- a/src/cmd/go/internal/cfg/cfg.go
+++ b/src/cmd/go/internal/cfg/cfg.go
@@ -252,13 +252,12 @@ var (
 	GOMODCACHE   = envOr("GOMODCACHE", gopathDir("pkg/mod"))
 
 	// Used in envcmd.MkEnv and build ID computations.
-	GOARM        = envOr("GOARM", fmt.Sprint(objabi.GOARM))
-	GO386        = envOr("GO386", objabi.GO386)
-	GOMIPS       = envOr("GOMIPS", objabi.GOMIPS)
-	GOMIPS64     = envOr("GOMIPS64", objabi.GOMIPS64)
-	GOPPC64      = envOr("GOPPC64", fmt.Sprintf("%s%d", "power", objabi.GOPPC64))
-	GOWASM       = envOr("GOWASM", fmt.Sprint(objabi.GOWASM))
-	GOEXPERIMENT = envOr("GOEXPERIMENT", objabi.GOEXPERIMENT)
+	GOARM    = envOr("GOARM", fmt.Sprint(objabi.GOARM))
+	GO386    = envOr("GO386", objabi.GO386)
+	GOMIPS   = envOr("GOMIPS", objabi.GOMIPS)
+	GOMIPS64 = envOr("GOMIPS64", objabi.GOMIPS64)
+	GOPPC64  = envOr("GOPPC64", fmt.Sprintf("%s%d", "power", objabi.GOPPC64))
+	GOWASM   = envOr("GOWASM", fmt.Sprint(objabi.GOWASM))
 
 	GOPROXY    = envOr("GOPROXY", "https://proxy.golang.org,direct")
 	GOSUMDB    = envOr("GOSUMDB", "sum.golang.org")
diff --git a/src/cmd/go/internal/work/exec.go b/src/cmd/go/internal/work/exec.go
index fd3d3e03bb..11b7360d26 100644
--- a/src/cmd/go/internal/work/exec.go
+++ b/src/cmd/go/internal/work/exec.go
@@ -8,7 +8,6 @@ package work
 
 import (
 	"bytes"
-	"cmd/go/internal/fsys"
 	"context"
 	"encoding/json"
 	"errors"
@@ -31,10 +30,12 @@ import (
 	"cmd/go/internal/base"
 	"cmd/go/internal/cache"
 	"cmd/go/internal/cfg"
+	"cmd/go/internal/fsys"
 	"cmd/go/internal/load"
 	"cmd/go/internal/modload"
 	"cmd/go/internal/str"
 	"cmd/go/internal/trace"
+	"cmd/internal/objabi"
 )
 
 // actionList returns the list of actions in the dag rooted at root
@@ -276,8 +277,8 @@ func (b *Builder) buildActionID(a *Action) cache.ActionID {
 		key, val := cfg.GetArchEnv()
 		fmt.Fprintf(h, "%s=%s\n", key, val)
 
-		if exp := cfg.GOEXPERIMENT; exp != "" {
-			fmt.Fprintf(h, "GOEXPERIMENT=%q\n", exp)
+		if objabi.GOEXPERIMENT != "" {
+			fmt.Fprintf(h, "GOEXPERIMENT=%q\n", objabi.GOEXPERIMENT)
 		}
 
 		// TODO(rsc): Convince compiler team not to add more magic environment variables,
@@ -1250,8 +1251,8 @@ func (b *Builder) printLinkerConfig(h io.Writer, p *load.Package) {
 		key, val := cfg.GetArchEnv()
 		fmt.Fprintf(h, "%s=%s\n", key, val)
 
-		if exp := cfg.GOEXPERIMENT; exp != "" {
-			fmt.Fprintf(h, "GOEXPERIMENT=%q\n", exp)
+		if objabi.GOEXPERIMENT != "" {
+			fmt.Fprintf(h, "GOEXPERIMENT=%q\n", objabi.GOEXPERIMENT)
 		}
 
 		// The linker writes source file paths that say GOROOT_FINAL, but
diff --git a/src/cmd/go/internal/work/init.go b/src/cmd/go/internal/work/init.go
index ba7c7c2fbb..30c9a2b7cc 100644
--- a/src/cmd/go/internal/work/init.go
+++ b/src/cmd/go/internal/work/init.go
@@ -52,14 +52,9 @@ func BuildInit() {
 	// build tag with the same name but prefixed by "goexperiment." which can be
 	// used for compiling alternative files for the experiment. This allows
 	// changes for the experiment, like extra struct fields in the runtime,
-	// without affecting the base non-experiment code at all. [2:] strips the
-	// leading "X:" from objabi.Expstring().
-	exp := objabi.Expstring()[2:]
-	if exp != "none" {
-		experiments := strings.Split(exp, ",")
-		for _, expt := range experiments {
-			cfg.BuildContext.BuildTags = append(cfg.BuildContext.BuildTags, "goexperiment."+expt)
-		}
+	// without affecting the base non-experiment code at all.
+	for _, expt := range strings.Split(objabi.GOEXPERIMENT, ",") {
+		cfg.BuildContext.BuildTags = append(cfg.BuildContext.BuildTags, "goexperiment."+expt)
 	}
 }
 
diff --git a/src/cmd/internal/objabi/flag.go b/src/cmd/internal/objabi/flag.go
index 3fd73f3c57..25b0185f64 100644
--- a/src/cmd/internal/objabi/flag.go
+++ b/src/cmd/internal/objabi/flag.go
@@ -95,7 +95,7 @@ func (versionFlag) Set(s string) error {
 	// to distinguish go1.10.2 with an experiment
 	// from go1.10.2 without an experiment.
 	p := Expstring()
-	if p == DefaultExpstring() {
+	if p == defaultExpstring {
 		p = ""
 	}
 	sep := ""
diff --git a/src/cmd/internal/objabi/util.go b/src/cmd/internal/objabi/util.go
index de8e6de4e6..81e2b28600 100644
--- a/src/cmd/internal/objabi/util.go
+++ b/src/cmd/internal/objabi/util.go
@@ -21,18 +21,23 @@ func envOr(key, value string) string {
 var (
 	defaultGOROOT string // set by linker
 
-	GOROOT       = envOr("GOROOT", defaultGOROOT)
-	GOARCH       = envOr("GOARCH", defaultGOARCH)
-	GOOS         = envOr("GOOS", defaultGOOS)
-	GOEXPERIMENT = envOr("GOEXPERIMENT", defaultGOEXPERIMENT)
-	GO386        = envOr("GO386", defaultGO386)
-	GOARM        = goarm()
-	GOMIPS       = gomips()
-	GOMIPS64     = gomips64()
-	GOPPC64      = goppc64()
-	GOWASM       = gowasm()
-	GO_LDSO      = defaultGO_LDSO
-	Version      = version
+	GOROOT   = envOr("GOROOT", defaultGOROOT)
+	GOARCH   = envOr("GOARCH", defaultGOARCH)
+	GOOS     = envOr("GOOS", defaultGOOS)
+	GO386    = envOr("GO386", defaultGO386)
+	GOARM    = goarm()
+	GOMIPS   = gomips()
+	GOMIPS64 = gomips64()
+	GOPPC64  = goppc64()
+	GOWASM   = gowasm()
+	GO_LDSO  = defaultGO_LDSO
+	Version  = version
+
+	// GOEXPERIMENT is a comma-separated list of enabled
+	// experiments. This is derived from the GOEXPERIMENT
+	// environment variable if set, or the value of GOEXPERIMENT
+	// when make.bash was run if not.
+	GOEXPERIMENT string // Set by package init
 )
 
 const (
@@ -125,7 +130,12 @@ func Getgoextlinkenabled() string {
 }
 
 func init() {
-	for _, f := range strings.Split(GOEXPERIMENT, ",") {
+	// Capture "default" experiments.
+	defaultExpstring = Expstring()
+
+	goexperiment := envOr("GOEXPERIMENT", defaultGOEXPERIMENT)
+
+	for _, f := range strings.Split(goexperiment, ",") {
 		if f != "" {
 			addexp(f)
 		}
@@ -135,6 +145,9 @@ func init() {
 	if GOARCH != "amd64" {
 		Regabi_enabled = 0
 	}
+
+	// Set GOEXPERIMENT to the parsed and canonicalized set of experiments.
+	GOEXPERIMENT = expList()
 }
 
 // Note: must agree with runtime.framepointer_enabled.
@@ -171,7 +184,6 @@ var (
 // Toolchain experiments.
 // These are controlled by the GOEXPERIMENT environment
 // variable recorded when the toolchain is built.
-// This list is also known to cmd/gc.
 var exper = []struct {
 	name string
 	val  *int
@@ -182,21 +194,29 @@ var exper = []struct {
 	{"regabi", &Regabi_enabled},
 }
 
-var defaultExpstring = Expstring()
-
-func DefaultExpstring() string {
-	return defaultExpstring
-}
+var defaultExpstring string
 
-func Expstring() string {
-	buf := "X"
+// expList returns the list of enabled GOEXPERIMENTS as a
+// commas-separated list.
+func expList() string {
+	buf := ""
 	for i := range exper {
 		if *exper[i].val != 0 {
 			buf += "," + exper[i].name
 		}
 	}
-	if buf == "X" {
-		buf += ",none"
+	if len(buf) == 0 {
+		return ""
+	}
+	return buf[1:]
+}
+
+// Expstring returns the GOEXPERIMENT string that should appear in Go
+// version signatures. This always starts with "X:".
+func Expstring() string {
+	list := expList()
+	if list == "" {
+		return "X:none"
 	}
-	return "X:" + buf[2:]
+	return "X:" + list
 }
-- 
GitLab


From 6461d74bf203925c981c889034ac5f713dc9db0b Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Mon, 15 Mar 2021 15:53:21 -0400
Subject: [PATCH 1150/2400] cmd/dist: build bootstrap without GOEXPERIMENT

Currently, dist attempts to build the bootstrap with the GOEXPERIMENT
set in the environment. However, the logic is incomplete and notably
requires a hack to enable the appropriate build tags for
GOEXPERIMENT=regabi. Without this hack, the build becomes skewed
between a compiler that uses regabi and a runtime that doesn't when
building toolchain2.

We could try to improve the GOEXPERIMENT processing in cmd/dist, but
it will always chase cmd/internal/objabi and it's quite difficult to
share the logic with objabi because of the constraints on building
cmd/dist.

Instead, we switch to building go_bootstrap without any GOEXPERIMENT
and only start using GOEXPERIMENT once we have a working, modern
cmd/go (which has all the GOEXPERIMENT logic in it). We also build
toolchain1 without any GOEXPERIMENT set, in case the bootstrap
toolchain is recent enough to understand build-time GOEXPERIMENT
settings.

As part of this, we make GOEXPERIMENT=none mean "no experiments". This
is necessary since, now that we support setting GOEXPERIMENT at build
time, we need an explicit way to say "ignore all baked-in experiments".

For #40724.

Change-Id: I115399579b766a7a8b2f352f7e5efea5305666cd
Reviewed-on: https://go-review.googlesource.com/c/go/+/302050
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/dist/build.go           | 21 ++++++++++++++++-----
 src/cmd/internal/objabi/util.go |  9 ++++++---
 2 files changed, 22 insertions(+), 8 deletions(-)

diff --git a/src/cmd/dist/build.go b/src/cmd/dist/build.go
index b2d13e7db4..acf38e3785 100644
--- a/src/cmd/dist/build.go
+++ b/src/cmd/dist/build.go
@@ -974,11 +974,6 @@ func matchtag(tag string) bool {
 		}
 		return !matchtag(tag[1:])
 	}
-	if os.Getenv("GOEXPERIMENT") == "regabi" && tag == "goexperiment.regabi" {
-		// TODO: maybe we can handle GOEXPERIMENT more generally.
-		// Or remove once we commit to regabi (#40724).
-		return true
-	}
 	return tag == "gc" || tag == goos || tag == goarch || tag == "cmd_go_bootstrap" || tag == "go1.1" ||
 		(goos == "android" && tag == "linux") ||
 		(goos == "illumos" && tag == "solaris") ||
@@ -1268,6 +1263,20 @@ func cmdbootstrap() {
 	// go tool may complain.
 	os.Setenv("GOPATH", pathf("%s/pkg/obj/gopath", goroot))
 
+	// Disable GOEXPERIMENT when building toolchain1 and
+	// go_bootstrap. We don't need any experiments for the
+	// bootstrap toolchain, and this lets us avoid duplicating the
+	// GOEXPERIMENT-related build logic from cmd/go here. If the
+	// bootstrap toolchain is < Go 1.17, it will ignore this
+	// anyway since GOEXPERIMENT is baked in; otherwise it will
+	// pick it up from the environment we set here. Once we're
+	// using toolchain1 with dist as the build system, we need to
+	// override this to keep the experiments assumed by the
+	// toolchain and by dist consistent. Once go_bootstrap takes
+	// over the build process, we'll set this back to the original
+	// GOEXPERIMENT.
+	os.Setenv("GOEXPERIMENT", "none")
+
 	if debug {
 		// cmd/buildid is used in debug mode.
 		toolchain = append(toolchain, "cmd/buildid")
@@ -1345,6 +1354,8 @@ func cmdbootstrap() {
 	}
 	xprintf("Building Go toolchain2 using go_bootstrap and Go toolchain1.\n")
 	os.Setenv("CC", compilerEnvLookup(defaultcc, goos, goarch))
+	// Now that cmd/go is in charge of the build process, enable GOEXPERIMENT.
+	os.Setenv("GOEXPERIMENT", goexperiment)
 	goInstall(goBootstrap, append([]string{"-i"}, toolchain...)...)
 	if debug {
 		run("", ShowOutput|CheckExit, pathf("%s/compile", tooldir), "-V=full")
diff --git a/src/cmd/internal/objabi/util.go b/src/cmd/internal/objabi/util.go
index 81e2b28600..9308a6d2eb 100644
--- a/src/cmd/internal/objabi/util.go
+++ b/src/cmd/internal/objabi/util.go
@@ -135,9 +135,12 @@ func init() {
 
 	goexperiment := envOr("GOEXPERIMENT", defaultGOEXPERIMENT)
 
-	for _, f := range strings.Split(goexperiment, ",") {
-		if f != "" {
-			addexp(f)
+	// GOEXPERIMENT=none overrides all experiments enabled at dist time.
+	if goexperiment != "none" {
+		for _, f := range strings.Split(goexperiment, ",") {
+			if f != "" {
+				addexp(f)
+			}
 		}
 	}
 
-- 
GitLab


From af4388aee195c4328a779ba8f8171ad1632feb7e Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Mon, 15 Mar 2021 16:23:21 -0400
Subject: [PATCH 1151/2400] cmd/internal/objabi: support boolean GOEXPERIMENTs

Currently, objabi exports GOEXPERIMENT flags as ints that are either 0
or 1. Since the dawn of time, there's been a comment saying that we
*could* support general integers here, but it's never happened and all
the "== 0" and "!= 0" and "== 1" are driving me crazy and are making
the code harder to read and maintain. Hence, this CL adds support for
boolean GOEXPERIMENT flags. We'll introduce some bool-typed flags in
the next CL.

Change-Id: I7813400db130a9b8f71a644fe7912808dbe645bc
Reviewed-on: https://go-review.googlesource.com/c/go/+/302069
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/internal/objabi/util.go | 28 ++++++++++++++++++++--------
 1 file changed, 20 insertions(+), 8 deletions(-)

diff --git a/src/cmd/internal/objabi/util.go b/src/cmd/internal/objabi/util.go
index 9308a6d2eb..8c96ceca35 100644
--- a/src/cmd/internal/objabi/util.go
+++ b/src/cmd/internal/objabi/util.go
@@ -157,17 +157,22 @@ func init() {
 var Framepointer_enabled = GOARCH == "amd64" || GOARCH == "arm64"
 
 func addexp(s string) {
-	// Could do general integer parsing here, but the runtime copy doesn't yet.
-	v := 1
+	// Could do general integer parsing here, but the runtime.haveexperiment doesn't yet.
+	v, vb := 1, true
 	name := s
 	if len(name) > 2 && name[:2] == "no" {
-		v = 0
+		v, vb = 0, false
 		name = name[2:]
 	}
 	for i := 0; i < len(exper); i++ {
 		if exper[i].name == name {
-			if exper[i].val != nil {
-				*exper[i].val = v
+			switch val := exper[i].val.(type) {
+			case *int:
+				*val = v
+			case *bool:
+				*val = vb
+			default:
+				panic("bad GOEXPERIMENT type for " + s)
 			}
 			return
 		}
@@ -189,7 +194,7 @@ var (
 // variable recorded when the toolchain is built.
 var exper = []struct {
 	name string
-	val  *int
+	val  interface{} // Must be *int or *bool
 }{
 	{"fieldtrack", &Fieldtrack_enabled},
 	{"preemptibleloops", &Preemptibleloops_enabled},
@@ -204,8 +209,15 @@ var defaultExpstring string
 func expList() string {
 	buf := ""
 	for i := range exper {
-		if *exper[i].val != 0 {
-			buf += "," + exper[i].name
+		switch val := exper[i].val.(type) {
+		case *int:
+			if *val != 0 {
+				buf += "," + exper[i].name
+			}
+		case *bool:
+			if *val {
+				buf += "," + exper[i].name
+			}
 		}
 	}
 	if len(buf) == 0 {
-- 
GitLab


From c71acbfe8372099877cdc989b546389b05222600 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Wed, 17 Mar 2021 18:28:38 -0400
Subject: [PATCH 1152/2400] test: make nosplit test invariant to ABI wrappers

Currently, the nosplit test disables ABI wrapper generation because it
generates a main.main in assembly, and so the ABI wrapper for calling
from runtime.main to main.main counts against the nosplit limit, which
cases some of the tests to fail.

Fix this by first entering ABI0 in a splittable context and then
calling from there into the test entry point, since this doesn't
introduce an ABI wrapper.

While we're here, this CL removes the test's check for the
framepointer experiment. That's now statically enabled, so it doesn't
appear in the experiment line, and enabling any other experiment
causes the test to think that the framepointer experiment *isn't*
enabled.

For #40724.

Change-Id: I6291eb9391f129779e726c5fc8c41b7b4a14eeb9
Reviewed-on: https://go-review.googlesource.com/c/go/+/302772
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 test/nosplit.go | 178 ++++++++++++++++++++++++------------------------
 1 file changed, 88 insertions(+), 90 deletions(-)

diff --git a/test/nosplit.go b/test/nosplit.go
index 8a3fa9bf35..7c7e1bfd99 100644
--- a/test/nosplit.go
+++ b/test/nosplit.go
@@ -21,6 +21,8 @@ import (
 	"strings"
 )
 
+const debug = false
+
 var tests = `
 # These are test cases for the linker analysis that detects chains of
 # nosplit functions that would cause a stack overflow.
@@ -33,8 +35,8 @@ var tests = `
 # The body is assembly code, with some shorthands.
 # The shorthand 'call x' stands for CALL x(SB).
 # The shorthand 'callind' stands for 'CALL R0', where R0 is a register.
-# Each test case must define a function named main, and it must be first.
-# That is, a line beginning "main " indicates the start of a new test case.
+# Each test case must define a function named start, and it must be first.
+# That is, a line beginning "start " indicates the start of a new test case.
 # Within a stanza, ; can be used instead of \n to separate lines.
 #
 # After the function definition, the test case ends with an optional
@@ -46,41 +48,41 @@ var tests = `
 # that are only 32-bit aligned.
 
 # Ordinary function should work
-main 0
+start 0
 
 # Large frame marked nosplit is always wrong.
-main 10000 nosplit
+start 10000 nosplit
 REJECT
 
 # Calling a large frame is okay.
-main 0 call big
+start 0 call big
 big 10000
 
 # But not if the frame is nosplit.
-main 0 call big
+start 0 call big
 big 10000 nosplit
 REJECT
 
 # Recursion is okay.
-main 0 call main
+start 0 call start
 
 # Recursive nosplit runs out of space.
-main 0 nosplit call main
+start 0 nosplit call start
 REJECT
 
 # Chains of ordinary functions okay.
-main 0 call f1
+start 0 call f1
 f1 80 call f2
 f2 80
 
 # Chains of nosplit must fit in the stack limit, 128 bytes.
-main 0 call f1
+start 0 call f1
 f1 80 nosplit call f2
 f2 80 nosplit
 REJECT
 
 # Larger chains.
-main 0 call f1
+start 0 call f1
 f1 16 call f2
 f2 16 call f3
 f3 16 call f4
@@ -91,7 +93,7 @@ f7 16 call f8
 f8 16 call end
 end 1000
 
-main 0 call f1
+start 0 call f1
 f1 16 nosplit call f2
 f2 16 nosplit call f3
 f3 16 nosplit call f4
@@ -106,27 +108,27 @@ REJECT
 # Test cases near the 128-byte limit.
 
 # Ordinary stack split frame is always okay.
-main 112
-main 116
-main 120
-main 124
-main 128
-main 132
-main 136
+start 112
+start 116
+start 120
+start 124
+start 128
+start 132
+start 136
 
 # A nosplit leaf can use the whole 128-CallSize bytes available on entry.
 # (CallSize is 32 on ppc64, 8 on amd64 for frame pointer.)
-main 96 nosplit
-main 100 nosplit; REJECT ppc64 ppc64le
-main 104 nosplit; REJECT ppc64 ppc64le arm64
-main 108 nosplit; REJECT ppc64 ppc64le
-main 112 nosplit; REJECT ppc64 ppc64le arm64
-main 116 nosplit; REJECT ppc64 ppc64le
-main 120 nosplit; REJECT ppc64 ppc64le amd64 arm64
-main 124 nosplit; REJECT ppc64 ppc64le amd64
-main 128 nosplit; REJECT
-main 132 nosplit; REJECT
-main 136 nosplit; REJECT
+start 96 nosplit
+start 100 nosplit; REJECT ppc64 ppc64le
+start 104 nosplit; REJECT ppc64 ppc64le arm64
+start 108 nosplit; REJECT ppc64 ppc64le
+start 112 nosplit; REJECT ppc64 ppc64le arm64
+start 116 nosplit; REJECT ppc64 ppc64le
+start 120 nosplit; REJECT ppc64 ppc64le amd64 arm64
+start 124 nosplit; REJECT ppc64 ppc64le amd64
+start 128 nosplit; REJECT
+start 132 nosplit; REJECT
+start 136 nosplit; REJECT
 
 # Calling a nosplit function from a nosplit function requires
 # having room for the saved caller PC and the called frame.
@@ -134,55 +136,55 @@ main 136 nosplit; REJECT
 # Because arm64 doesn't save LR in the leaf, it gets an extra 8 bytes.
 # ppc64 doesn't save LR in the leaf, but CallSize is 32, so it gets 24 bytes.
 # Because AMD64 uses frame pointer, it has 8 fewer bytes.
-main 96 nosplit call f; f 0 nosplit
-main 100 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le
-main 104 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le arm64
-main 108 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le
-main 112 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le amd64 arm64
-main 116 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le amd64
-main 120 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le amd64 arm64
-main 124 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le amd64 386
-main 128 nosplit call f; f 0 nosplit; REJECT
-main 132 nosplit call f; f 0 nosplit; REJECT
-main 136 nosplit call f; f 0 nosplit; REJECT
+start 96 nosplit call f; f 0 nosplit
+start 100 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le
+start 104 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le arm64
+start 108 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le
+start 112 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le amd64 arm64
+start 116 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le amd64
+start 120 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le amd64 arm64
+start 124 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le amd64 386
+start 128 nosplit call f; f 0 nosplit; REJECT
+start 132 nosplit call f; f 0 nosplit; REJECT
+start 136 nosplit call f; f 0 nosplit; REJECT
 
 # Calling a splitting function from a nosplit function requires
 # having room for the saved caller PC of the call but also the
 # saved caller PC for the call to morestack.
 # Architectures differ in the same way as before.
-main 96 nosplit call f; f 0 call f
-main 100 nosplit call f; f 0 call f; REJECT ppc64 ppc64le
-main 104 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 arm64
-main 108 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64
-main 112 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 arm64
-main 116 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64
-main 120 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 386 arm64
-main 124 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 386
-main 128 nosplit call f; f 0 call f; REJECT
-main 132 nosplit call f; f 0 call f; REJECT
-main 136 nosplit call f; f 0 call f; REJECT
+start 96 nosplit call f; f 0 call f
+start 100 nosplit call f; f 0 call f; REJECT ppc64 ppc64le
+start 104 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 arm64
+start 108 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64
+start 112 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 arm64
+start 116 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64
+start 120 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 386 arm64
+start 124 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 386
+start 128 nosplit call f; f 0 call f; REJECT
+start 132 nosplit call f; f 0 call f; REJECT
+start 136 nosplit call f; f 0 call f; REJECT
 
 # Indirect calls are assumed to be splitting functions.
-main 96 nosplit callind
-main 100 nosplit callind; REJECT ppc64 ppc64le
-main 104 nosplit callind; REJECT ppc64 ppc64le amd64 arm64
-main 108 nosplit callind; REJECT ppc64 ppc64le amd64
-main 112 nosplit callind; REJECT ppc64 ppc64le amd64 arm64
-main 116 nosplit callind; REJECT ppc64 ppc64le amd64
-main 120 nosplit callind; REJECT ppc64 ppc64le amd64 386 arm64
-main 124 nosplit callind; REJECT ppc64 ppc64le amd64 386
-main 128 nosplit callind; REJECT
-main 132 nosplit callind; REJECT
-main 136 nosplit callind; REJECT
+start 96 nosplit callind
+start 100 nosplit callind; REJECT ppc64 ppc64le
+start 104 nosplit callind; REJECT ppc64 ppc64le amd64 arm64
+start 108 nosplit callind; REJECT ppc64 ppc64le amd64
+start 112 nosplit callind; REJECT ppc64 ppc64le amd64 arm64
+start 116 nosplit callind; REJECT ppc64 ppc64le amd64
+start 120 nosplit callind; REJECT ppc64 ppc64le amd64 386 arm64
+start 124 nosplit callind; REJECT ppc64 ppc64le amd64 386
+start 128 nosplit callind; REJECT
+start 132 nosplit callind; REJECT
+start 136 nosplit callind; REJECT
 
 # Issue 7623
-main 0 call f; f 112
-main 0 call f; f 116
-main 0 call f; f 120
-main 0 call f; f 124
-main 0 call f; f 128
-main 0 call f; f 132
-main 0 call f; f 136
+start 0 call f; f 112
+start 0 call f; f 116
+start 0 call f; f 120
+start 0 call f; f 124
+start 0 call f; f 128
+start 0 call f; f 132
+start 0 call f; f 136
 `
 
 var (
@@ -199,17 +201,6 @@ func main() {
 		goarch = runtime.GOARCH
 	}
 
-	version, err := exec.Command("go", "tool", "compile", "-V").Output()
-	if err != nil {
-		bug()
-		fmt.Printf("running go tool compile -V: %v\n", err)
-		return
-	}
-	if s := string(version); goarch == "amd64" && strings.Contains(s, "X:") && !strings.Contains(s, "framepointer") {
-		// Skip this test if framepointer is NOT enabled on AMD64
-		return
-	}
-
 	dir, err := ioutil.TempDir("", "go-test-nosplit")
 	if err != nil {
 		bug()
@@ -231,7 +222,7 @@ func main() {
 TestCases:
 	for len(tests) > 0 {
 		var stanza string
-		i := strings.Index(tests, "\nmain ")
+		i := strings.Index(tests, "\nstart ")
 		if i < 0 {
 			stanza, tests = tests, ""
 		} else {
@@ -293,6 +284,14 @@ TestCases:
 			fmt.Fprintf(&buf, "#define REGISTER AX\n")
 		}
 
+		// Since all of the functions we're generating are
+		// ABI0, first enter ABI0 via a splittable function
+		// and then go to the chain we're testing. This way we
+		// don't have to account for ABI wrappers in the chain.
+		fmt.Fprintf(&gobuf, "func main0()\n")
+		fmt.Fprintf(&gobuf, "func main() { main0() }\n")
+		fmt.Fprintf(&buf, "TEXT ·main0(SB),0,$0-0\n\tCALL ·start(SB)\n")
+
 		for _, line := range strings.Split(lines, "\n") {
 			line = strings.TrimSpace(line)
 			if line == "" {
@@ -346,6 +345,12 @@ TestCases:
 			}
 		}
 
+		if debug {
+			fmt.Printf("===\n%s\n", strings.TrimSpace(stanza))
+			fmt.Printf("-- main.go --\n%s", gobuf.String())
+			fmt.Printf("-- asm.s --\n%s", buf.String())
+		}
+
 		if err := ioutil.WriteFile(filepath.Join(dir, "asm.s"), buf.Bytes(), 0666); err != nil {
 			log.Fatal(err)
 		}
@@ -353,14 +358,7 @@ TestCases:
 			log.Fatal(err)
 		}
 
-		// Turn off ABI0 wrapper generation for now. The problem here is
-		// that in these test cases main.main is an assembly routine,
-		// thus calls to it will have to go through an ABI wrapper. The
-		// ABI wrapper will consume some stack space, which throws off
-		// the numbers.
-		workaround := "-gcflags=-abiwrap=0"
-
-		cmd := exec.Command("go", "build", workaround)
+		cmd := exec.Command("go", "build")
 		cmd.Dir = dir
 		output, err := cmd.CombinedOutput()
 		if err == nil {
-- 
GitLab


From eaa1ddee84cfdfbd47183b03962744fea52624f0 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Mon, 15 Mar 2021 16:48:54 -0400
Subject: [PATCH 1153/2400] all: explode GOEXPERIMENT=regabi into 5
 sub-experiments

This separates GOEXPERIMENT=regabi into five sub-experiments:
regabiwrappers, regabig, regabireflect, regabidefer, and regabiargs.
Setting GOEXPERIMENT=regabi now implies the working subset of these
(currently, regabiwrappers, regabig, and regabireflect).

This simplifies testing, helps derisk the register ABI project,
and will also help with performance comparisons.

This replaces the -abiwrap flag to the compiler and linker with
the regabiwrappers experiment.

As part of this, regabiargs now enables registers for all calls
in the compiler. Previously, this was statically disabled in
regabiEnabledForAllCompilation, but now that we can control it
independently, this isn't necessary.

For #40724.

Change-Id: I5171e60cda6789031f2ef034cc2e7c5d62459122
Reviewed-on: https://go-review.googlesource.com/c/go/+/302070
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/asm/internal/lex/input.go            | 30 +++++++--
 src/cmd/compile/internal/amd64/ggen.go       |  4 +-
 src/cmd/compile/internal/amd64/ssa.go        | 16 ++---
 src/cmd/compile/internal/base/flag.go        |  2 -
 src/cmd/compile/internal/ssa/config.go       |  3 +-
 src/cmd/compile/internal/ssa/gen/AMD64.rules |  2 +-
 src/cmd/compile/internal/ssa/rewriteAMD64.go |  5 +-
 src/cmd/compile/internal/ssagen/abi.go       |  4 +-
 src/cmd/compile/internal/ssagen/ssa.go       |  5 +-
 src/cmd/internal/obj/x86/obj6.go             |  4 +-
 src/cmd/internal/objabi/util.go              | 65 +++++++++++++++++++-
 src/cmd/link/internal/ld/lib.go              |  8 +--
 src/cmd/link/internal/ld/main.go             |  1 -
 src/cmd/link/internal/ld/symtab.go           |  2 +-
 src/internal/abi/abi_amd64.go                |  4 +-
 src/internal/abi/abi_generic.go              |  4 +-
 src/runtime/abi_test.go                      |  4 +-
 src/runtime/asm_amd64.s                      |  8 +--
 src/runtime/race_amd64.s                     | 12 ++--
 src/runtime/sys_linux_amd64.s                |  8 +--
 20 files changed, 131 insertions(+), 60 deletions(-)

diff --git a/src/cmd/asm/internal/lex/input.go b/src/cmd/asm/internal/lex/input.go
index 1d4d4be7bd..d3ad328954 100644
--- a/src/cmd/asm/internal/lex/input.go
+++ b/src/cmd/asm/internal/lex/input.go
@@ -46,12 +46,30 @@ func NewInput(name string) *Input {
 func predefine(defines flags.MultiFlag) map[string]*Macro {
 	macros := make(map[string]*Macro)
 
-	if *flags.CompilingRuntime && objabi.Regabi_enabled != 0 {
-		const name = "GOEXPERIMENT_REGABI"
-		macros[name] = &Macro{
-			name:   name,
-			args:   nil,
-			tokens: Tokenize("1"),
+	// Set macros for various GOEXPERIMENTs so we can easily
+	// switch runtime assembly code based on them.
+	if *flags.CompilingRuntime {
+		set := func(name string) {
+			macros[name] = &Macro{
+				name:   name,
+				args:   nil,
+				tokens: Tokenize("1"),
+			}
+		}
+		if objabi.Experiment.RegabiWrappers {
+			set("GOEXPERIMENT_REGABI_WRAPPERS")
+		}
+		if objabi.Experiment.RegabiG {
+			set("GOEXPERIMENT_REGABI_G")
+		}
+		if objabi.Experiment.RegabiReflect {
+			set("GOEXPERIMENT_REGABI_REFLECT")
+		}
+		if objabi.Experiment.RegabiDefer {
+			set("GOEXPERIMENT_REGABI_DEFER")
+		}
+		if objabi.Experiment.RegabiArgs {
+			set("GOEXPERIMENT_REGABI_ARGS")
 		}
 	}
 
diff --git a/src/cmd/compile/internal/amd64/ggen.go b/src/cmd/compile/internal/amd64/ggen.go
index 14c3bd1129..259a083f75 100644
--- a/src/cmd/compile/internal/amd64/ggen.go
+++ b/src/cmd/compile/internal/amd64/ggen.go
@@ -85,7 +85,7 @@ func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.
 		}
 		p = pp.Append(p, x86.AMOVQ, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_MEM, x86.REG_SP, off)
 	} else if !isPlan9 && cnt <= int64(8*types.RegSize) {
-		if objabi.Regabi_enabled == 0 && *state&x15 == 0 {
+		if !objabi.Experiment.RegabiG && *state&x15 == 0 {
 			p = pp.Append(p, x86.AXORPS, obj.TYPE_REG, x86.REG_X15, 0, obj.TYPE_REG, x86.REG_X15, 0)
 			*state |= x15
 		}
@@ -98,7 +98,7 @@ func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.
 			p = pp.Append(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X15, 0, obj.TYPE_MEM, x86.REG_SP, off+cnt-int64(16))
 		}
 	} else if !isPlan9 && (cnt <= int64(128*types.RegSize)) {
-		if objabi.Regabi_enabled == 0 && *state&x15 == 0 {
+		if !objabi.Experiment.RegabiG && *state&x15 == 0 {
 			p = pp.Append(p, x86.AXORPS, obj.TYPE_REG, x86.REG_X15, 0, obj.TYPE_REG, x86.REG_X15, 0)
 			*state |= x15
 		}
diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index 3798c37b34..bdd9da77b0 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -827,8 +827,8 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		if s.ABI != obj.ABIInternal {
 			v.Fatalf("MOVOstorezero can be only used in ABIInternal functions")
 		}
-		if !(objabi.Regabi_enabled == 1 && base.Flag.ABIWrap) {
-			// zeroing X15 manually if wrappers are not used
+		if !objabi.Experiment.RegabiG {
+			// zero X15 manually
 			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
 		}
 		p := s.Prog(v.Op.Asm())
@@ -921,8 +921,8 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		if s.ABI != obj.ABIInternal {
 			v.Fatalf("MOVOconst can be only used in ABIInternal functions")
 		}
-		if !(objabi.Regabi_enabled == 1 && base.Flag.ABIWrap) {
-			// zeroing X15 manually if wrappers are not used
+		if !objabi.Experiment.RegabiG {
+			// zero X15 manually
 			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
 		}
 		off := duffStart(v.AuxInt)
@@ -1004,20 +1004,20 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		// Closure pointer is DX.
 		ssagen.CheckLoweredGetClosurePtr(v)
 	case ssa.OpAMD64LoweredGetG:
-		if objabi.Regabi_enabled == 1 && base.Flag.ABIWrap {
+		if objabi.Experiment.RegabiG {
 			v.Fatalf("LoweredGetG should not appear in new ABI")
 		}
 		r := v.Reg()
 		getgFromTLS(s, r)
 	case ssa.OpAMD64CALLstatic:
-		if objabi.Regabi_enabled == 1 && s.ABI == obj.ABI0 && v.Aux.(*ssa.AuxCall).Fn.ABI() == obj.ABIInternal {
+		if objabi.Experiment.RegabiG && s.ABI == obj.ABI0 && v.Aux.(*ssa.AuxCall).Fn.ABI() == obj.ABIInternal {
 			// zeroing X15 when entering ABIInternal from ABI0
 			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
 			// set G register from TLS
 			getgFromTLS(s, x86.REG_R14)
 		}
 		s.Call(v)
-		if objabi.Regabi_enabled == 1 && s.ABI == obj.ABIInternal && v.Aux.(*ssa.AuxCall).Fn.ABI() == obj.ABI0 {
+		if objabi.Experiment.RegabiG && s.ABI == obj.ABIInternal && v.Aux.(*ssa.AuxCall).Fn.ABI() == obj.ABI0 {
 			// zeroing X15 when entering ABIInternal from ABI0
 			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
 			// set G register from TLS
@@ -1304,7 +1304,7 @@ func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
 	case ssa.BlockRet:
 		s.Prog(obj.ARET)
 	case ssa.BlockRetJmp:
-		if objabi.Regabi_enabled == 1 && s.ABI == obj.ABI0 && b.Aux.(*obj.LSym).ABI() == obj.ABIInternal {
+		if objabi.Experiment.RegabiG && s.ABI == obj.ABI0 && b.Aux.(*obj.LSym).ABI() == obj.ABIInternal {
 			// zeroing X15 when entering ABIInternal from ABI0
 			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
 			// set G register from TLS
diff --git a/src/cmd/compile/internal/base/flag.go b/src/cmd/compile/internal/base/flag.go
index 1087f97d07..959fededa9 100644
--- a/src/cmd/compile/internal/base/flag.go
+++ b/src/cmd/compile/internal/base/flag.go
@@ -82,7 +82,6 @@ type CmdFlags struct {
 	CompilingRuntime bool "flag:\"+\" help:\"compiling runtime\""
 
 	// Longer names
-	ABIWrap            bool         "help:\"enable generation of ABI wrappers\""
 	ABIWrapLimit       int          "help:\"emit at most N ABI wrappers (for debugging)\""
 	AsmHdr             string       "help:\"write assembly header to `file`\""
 	Bench              string       "help:\"append benchmark times to `file`\""
@@ -147,7 +146,6 @@ func ParseFlags() {
 	Flag.LowerP = &Ctxt.Pkgpath
 	Flag.LowerV = &Ctxt.Debugvlog
 
-	Flag.ABIWrap = objabi.Regabi_enabled != 0
 	Flag.Dwarf = objabi.GOARCH != "wasm"
 	Flag.DwarfBASEntries = &Ctxt.UseBASEntries
 	Flag.DwarfLocationLists = &Ctxt.Flag_locationlists
diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go
index 9921b51cc7..75fa71ce35 100644
--- a/src/cmd/compile/internal/ssa/config.go
+++ b/src/cmd/compile/internal/ssa/config.go
@@ -6,7 +6,6 @@ package ssa
 
 import (
 	"cmd/compile/internal/abi"
-	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -204,7 +203,7 @@ func NewConfig(arch string, types Types, ctxt *obj.Link, optimize bool) *Config
 		c.floatParamRegs = paramFloatRegAMD64
 		c.FPReg = framepointerRegAMD64
 		c.LinkReg = linkRegAMD64
-		c.hasGReg = base.Flag.ABIWrap
+		c.hasGReg = objabi.Experiment.RegabiG
 	case "386":
 		c.PtrSize = 4
 		c.RegSize = 4
diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules
index bece886c0d..7dc381bd81 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64.rules
+++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules
@@ -460,7 +460,7 @@
 (IsInBounds idx len) => (SETB (CMPQ idx len))
 (IsSliceInBounds idx len) => (SETBE (CMPQ idx len))
 (NilCheck ...) => (LoweredNilCheck ...)
-(GetG mem) && !(objabi.Regabi_enabled == 1 && base.Flag.ABIWrap) => (LoweredGetG mem) // only lower in old ABI. in new ABI we have a G register.
+(GetG mem) && !objabi.Experiment.RegabiG => (LoweredGetG mem) // only lower in old ABI. in new ABI we have a G register.
 (GetClosurePtr ...) => (LoweredGetClosurePtr ...)
 (GetCallerPC ...) => (LoweredGetCallerPC ...)
 (GetCallerSP ...) => (LoweredGetCallerSP ...)
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index ac5bf9d928..36f872d0c4 100644
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -5,7 +5,6 @@ package ssa
 
 import "math"
 import "cmd/internal/objabi"
-import "cmd/compile/internal/base"
 import "cmd/compile/internal/types"
 
 func rewriteValueAMD64(v *Value) bool {
@@ -30273,11 +30272,11 @@ func rewriteValueAMD64_OpFloor(v *Value) bool {
 func rewriteValueAMD64_OpGetG(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (GetG mem)
-	// cond: !(objabi.Regabi_enabled == 1 && base.Flag.ABIWrap)
+	// cond: !objabi.Experiment.RegabiG
 	// result: (LoweredGetG mem)
 	for {
 		mem := v_0
-		if !(!(objabi.Regabi_enabled == 1 && base.Flag.ABIWrap)) {
+		if !(!objabi.Experiment.RegabiG) {
 			break
 		}
 		v.reset(OpAMD64LoweredGetG)
diff --git a/src/cmd/compile/internal/ssagen/abi.go b/src/cmd/compile/internal/ssagen/abi.go
index e3f3ac637b..6d391ed9f7 100644
--- a/src/cmd/compile/internal/ssagen/abi.go
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -24,7 +24,7 @@ import (
 // useNewABIWrapGen returns TRUE if the compiler should generate an
 // ABI wrapper for the function 'f'.
 func useABIWrapGen(f *ir.Func) bool {
-	if !base.Flag.ABIWrap {
+	if !objabi.Experiment.RegabiWrappers {
 		return false
 	}
 
@@ -140,7 +140,7 @@ func ReadSymABIs(file, myimportpath string) {
 func InitLSym(f *ir.Func, hasBody bool) {
 	// FIXME: for new-style ABI wrappers, we set up the lsym at the
 	// point the wrapper is created.
-	if f.LSym != nil && base.Flag.ABIWrap {
+	if f.LSym != nil && objabi.Experiment.RegabiWrappers {
 		return
 	}
 	staticdata.NeedFuncSym(f.Sym())
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 293062b8ec..e97535e748 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -261,8 +261,7 @@ func regAbiForFuncType(ft *types.Func) bool {
 }
 
 func regabiEnabledForAllCompilation() bool {
-	// TODO compiler does not yet change behavior for GOEXPERIMENT=regabi
-	return false && objabi.Regabi_enabled != 0
+	return objabi.Experiment.RegabiArgs
 }
 
 // getParam returns the Field of ith param of node n (which is a
@@ -7448,7 +7447,7 @@ func clobberBase(n ir.Node) ir.Node {
 //
 func callTargetLSym(callee *ir.Name, callerLSym *obj.LSym) *obj.LSym {
 	lsym := callee.Linksym()
-	if !base.Flag.ABIWrap {
+	if !objabi.Experiment.RegabiWrappers {
 		return lsym
 	}
 	fn := callee.Func
diff --git a/src/cmd/internal/obj/x86/obj6.go b/src/cmd/internal/obj/x86/obj6.go
index 02af8eaa82..2fbeaad572 100644
--- a/src/cmd/internal/obj/x86/obj6.go
+++ b/src/cmd/internal/obj/x86/obj6.go
@@ -646,13 +646,13 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 
 	var regg int16
 	if !p.From.Sym.NoSplit() || (p.From.Sym.Wrapper() && !p.From.Sym.ABIWrapper()) {
-		if ctxt.Arch.Family == sys.AMD64 && objabi.Regabi_enabled != 0 && cursym.ABI() == obj.ABIInternal {
+		if ctxt.Arch.Family == sys.AMD64 && objabi.Experiment.RegabiG && cursym.ABI() == obj.ABIInternal {
 			regg = REGG // use the g register directly in ABIInternal
 		} else {
 			p = obj.Appendp(p, newprog)
 			regg = REG_CX
 			if ctxt.Arch.Family == sys.AMD64 {
-				// Using this register means that stacksplit works w/ //go:registerparams even when objabi.Regabi_enabled == 0
+				// Using this register means that stacksplit works w/ //go:registerparams even when !objabi.Experiment.RegabiG
 				regg = REGG // == REG_R14
 			}
 			p = load_g(ctxt, p, newprog, regg) // load g into regg
diff --git a/src/cmd/internal/objabi/util.go b/src/cmd/internal/objabi/util.go
index 8c96ceca35..548e9d0a30 100644
--- a/src/cmd/internal/objabi/util.go
+++ b/src/cmd/internal/objabi/util.go
@@ -146,7 +146,28 @@ func init() {
 
 	// regabi is only supported on amd64.
 	if GOARCH != "amd64" {
-		Regabi_enabled = 0
+		Experiment.regabi = false
+		Experiment.RegabiWrappers = false
+		Experiment.RegabiG = false
+		Experiment.RegabiReflect = false
+		Experiment.RegabiDefer = false
+		Experiment.RegabiArgs = false
+	}
+	// Setting regabi sets working sub-experiments.
+	if Experiment.regabi {
+		Experiment.RegabiWrappers = true
+		Experiment.RegabiG = true
+		Experiment.RegabiReflect = true
+		// Not ready yet:
+		//Experiment.RegabiDefer = true
+		//Experiment.RegabiArgs = true
+	}
+	// Check regabi dependencies.
+	if Experiment.RegabiG && !Experiment.RegabiWrappers {
+		panic("GOEXPERIMENT regabig requires regabiwrappers")
+	}
+	if Experiment.RegabiArgs && !(Experiment.RegabiWrappers && Experiment.RegabiReflect && Experiment.RegabiDefer) {
+		panic("GOEXPERIMENT regabiargs requires regabiwrappers,regabireflect,regabidefer")
 	}
 
 	// Set GOEXPERIMENT to the parsed and canonicalized set of experiments.
@@ -186,9 +207,42 @@ var (
 	Fieldtrack_enabled        int
 	Preemptibleloops_enabled  int
 	Staticlockranking_enabled int
-	Regabi_enabled            int
 )
 
+// Experiment contains flags for GOEXPERIMENTs.
+//
+// TODO(austin): Move the package-level experiment flags into this.
+var Experiment ExpFlags
+
+type ExpFlags struct {
+	// regabi is split into several sub-experiments that can be
+	// enabled individually. GOEXPERIMENT=regabi implies the
+	// subset that are currently "working". Not all combinations work.
+	regabi bool
+	// RegabiWrappers enables ABI wrappers for calling between
+	// ABI0 and ABIInternal functions. Without this, the ABIs are
+	// assumed to be identical so cross-ABI calls are direct.
+	RegabiWrappers bool
+	// RegabiG enables dedicated G and zero registers in
+	// ABIInternal.
+	//
+	// Requires wrappers because it makes the ABIs incompatible.
+	RegabiG bool
+	// RegabiReflect enables the register-passing paths in
+	// reflection calls. This is also gated by intArgRegs in
+	// reflect and runtime (which are disabled by default) so it
+	// can be used in targeted tests.
+	RegabiReflect bool
+	// RegabiDefer enables desugaring defer and go calls
+	// into argument-less closures.
+	RegabiDefer bool
+	// RegabiArgs enables register arguments/results in all
+	// compiled Go functions.
+	//
+	// Requires wrappers, reflect, defer.
+	RegabiArgs bool
+}
+
 // Toolchain experiments.
 // These are controlled by the GOEXPERIMENT environment
 // variable recorded when the toolchain is built.
@@ -199,7 +253,12 @@ var exper = []struct {
 	{"fieldtrack", &Fieldtrack_enabled},
 	{"preemptibleloops", &Preemptibleloops_enabled},
 	{"staticlockranking", &Staticlockranking_enabled},
-	{"regabi", &Regabi_enabled},
+	{"regabi", &Experiment.regabi},
+	{"regabiwrappers", &Experiment.RegabiWrappers},
+	{"regabig", &Experiment.RegabiG},
+	{"regabireflect", &Experiment.RegabiReflect},
+	{"regabidefer", &Experiment.RegabiDefer},
+	{"regabiargs", &Experiment.RegabiArgs},
 }
 
 var defaultExpstring string
diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index 500dca2b8b..c96a9be355 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -493,7 +493,7 @@ func (ctxt *Link) loadlib() {
 	default:
 		log.Fatalf("invalid -strictdups flag value %d", *FlagStrictDups)
 	}
-	if !*flagAbiWrap || ctxt.linkShared {
+	if !objabi.Experiment.RegabiWrappers || ctxt.linkShared {
 		// Use ABI aliases if ABI wrappers are not used.
 		// TODO: for now we still use ABI aliases in shared linkage, even if
 		// the wrapper is enabled.
@@ -2116,7 +2116,7 @@ func ldshlibsyms(ctxt *Link, shlib string) {
 
 	// collect text symbol ABI versions.
 	symabi := make(map[string]int) // map (unmangled) symbol name to version
-	if *flagAbiWrap {
+	if objabi.Experiment.RegabiWrappers {
 		for _, elfsym := range syms {
 			if elf.ST_TYPE(elfsym.Info) != elf.STT_FUNC {
 				continue
@@ -2144,7 +2144,7 @@ func ldshlibsyms(ctxt *Link, shlib string) {
 		symname := elfsym.Name // (unmangled) symbol name
 		if elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC && strings.HasPrefix(elfsym.Name, "type.") {
 			ver = sym.SymVerABIInternal
-		} else if *flagAbiWrap && elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC {
+		} else if objabi.Experiment.RegabiWrappers && elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC {
 			if strings.HasSuffix(elfsym.Name, ".abiinternal") {
 				ver = sym.SymVerABIInternal
 				symname = strings.TrimSuffix(elfsym.Name, ".abiinternal")
@@ -2194,7 +2194,7 @@ func ldshlibsyms(ctxt *Link, shlib string) {
 		// mangle Go function names in the .so to include the
 		// ABI.
 		if elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC && ver == 0 {
-			if *flagAbiWrap {
+			if objabi.Experiment.RegabiWrappers {
 				if _, ok := symabi[symname]; ok {
 					continue // only use alias for functions w/o ABI wrappers
 				}
diff --git a/src/cmd/link/internal/ld/main.go b/src/cmd/link/internal/ld/main.go
index 8e9a9b9207..3c5355df9c 100644
--- a/src/cmd/link/internal/ld/main.go
+++ b/src/cmd/link/internal/ld/main.go
@@ -95,7 +95,6 @@ var (
 	cpuprofile        = flag.String("cpuprofile", "", "write cpu profile to `file`")
 	memprofile        = flag.String("memprofile", "", "write memory profile to `file`")
 	memprofilerate    = flag.Int64("memprofilerate", 0, "set runtime.MemProfileRate to `rate`")
-	flagAbiWrap       = flag.Bool("abiwrap", objabi.Regabi_enabled != 0, "support ABI wrapper functions")
 	benchmarkFlag     = flag.String("benchmark", "", "set to 'mem' or 'cpu' to enable phase benchmarking")
 	benchmarkFileFlag = flag.String("benchmarkprofile", "", "emit phase profiles to `base`_phase.{cpu,mem}prof")
 )
diff --git a/src/cmd/link/internal/ld/symtab.go b/src/cmd/link/internal/ld/symtab.go
index ca8ef8641e..f48822a72e 100644
--- a/src/cmd/link/internal/ld/symtab.go
+++ b/src/cmd/link/internal/ld/symtab.go
@@ -121,7 +121,7 @@ func putelfsym(ctxt *Link, x loader.Sym, typ elf.SymType, curbind elf.SymBind) {
 	// sym or marker relocation to associate the wrapper with the
 	// wrapped function.
 	//
-	if *flagAbiWrap {
+	if objabi.Experiment.RegabiWrappers {
 		if !ldr.IsExternal(x) && ldr.SymType(x) == sym.STEXT {
 			// First case
 			if ldr.SymVersion(x) == sym.SymVerABIInternal {
diff --git a/src/internal/abi/abi_amd64.go b/src/internal/abi/abi_amd64.go
index 07c3ec1aab..aff71f6a58 100644
--- a/src/internal/abi/abi_amd64.go
+++ b/src/internal/abi/abi_amd64.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build goexperiment.regabi
-// +build goexperiment.regabi
+//go:build goexperiment.regabireflect
+// +build goexperiment.regabireflect
 
 package abi
 
diff --git a/src/internal/abi/abi_generic.go b/src/internal/abi/abi_generic.go
index 1e36f36e80..69400f930f 100644
--- a/src/internal/abi/abi_generic.go
+++ b/src/internal/abi/abi_generic.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build !goexperiment.regabi
-// +build !goexperiment.regabi
+//go:build !goexperiment.regabireflect
+// +build !goexperiment.regabireflect
 
 package abi
 
diff --git a/src/runtime/abi_test.go b/src/runtime/abi_test.go
index fa365c0832..f50ed879d4 100644
--- a/src/runtime/abi_test.go
+++ b/src/runtime/abi_test.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build goexperiment.regabi
-//go:build goexperiment.regabi
+//go:build goexperiment.regabireflect
+// +build goexperiment.regabireflect
 
 // This file contains tests specific to making sure the register ABI
 // works in a bunch of contexts in the runtime.
diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index ddd6a5bd5b..ab3f639929 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -442,7 +442,7 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0
 	MOVL	$0, DX
 	JMP	runtime·morestack(SB)
 
-#ifdef GOEXPERIMENT_REGABI
+#ifdef GOEXPERIMENT_REGABI_REFLECT
 // spillArgs stores return values from registers to a *internal/abi.RegArgs in R12.
 TEXT spillArgs<>(SB),NOSPLIT,$0-0
 	MOVQ AX, 0(R12)
@@ -660,7 +660,7 @@ TEXT runtime·jmpdefer(SB), NOSPLIT, $0-16
 // or else unwinding from systemstack_switch is incorrect.
 // Smashes R9.
 TEXT gosave_systemstack_switch<>(SB),NOSPLIT,$0
-#ifndef GOEXPERIMENT_REGABI
+#ifndef GOEXPERIMENT_REGABI_G
 	get_tls(R14)
 	MOVQ	g(R14), R14
 #endif
@@ -1461,7 +1461,7 @@ TEXT runtime·addmoduledata(SB),NOSPLIT,$0-0
 // signals. It is quite painful to set X15 in the signal context,
 // so we do it here.
 TEXT ·sigpanic0<ABIInternal>(SB),NOSPLIT,$0-0
-#ifdef GOEXPERIMENT_REGABI
+#ifdef GOEXPERIMENT_REGABI_G
 	get_tls(R14)
 	MOVQ	g(R14), R14
 	XORPS	X15, X15
@@ -1483,7 +1483,7 @@ TEXT runtime·gcWriteBarrier<ABIInternal>(SB),NOSPLIT,$112
 	MOVQ	R13, 104(SP)
 	// TODO: Consider passing g.m.p in as an argument so they can be shared
 	// across a sequence of write barriers.
-#ifdef GOEXPERIMENT_REGABI
+#ifdef GOEXPERIMENT_REGABI_G
 	MOVQ	g_m(R14), R13
 #else
 	get_tls(R13)
diff --git a/src/runtime/race_amd64.s b/src/runtime/race_amd64.s
index 287bb9fc0a..5f6b86a1fe 100644
--- a/src/runtime/race_amd64.s
+++ b/src/runtime/race_amd64.s
@@ -146,7 +146,7 @@ TEXT	runtime·racewriterangepc1(SB), NOSPLIT, $0-24
 // If addr (RARG1) is out of range, do nothing.
 // Otherwise, setup goroutine context and invoke racecall. Other arguments already set.
 TEXT	racecalladdr<>(SB), NOSPLIT, $0-0
-#ifndef GOEXPERIMENT_REGABI
+#ifndef GOEXPERIMENT_REGABI_G
 	get_tls(R12)
 	MOVQ	g(R12), R14
 #endif
@@ -177,7 +177,7 @@ TEXT	runtime·racefuncenter(SB), NOSPLIT, $0-8
 // R11 = caller's return address
 TEXT	racefuncenter<>(SB), NOSPLIT, $0-0
 	MOVQ	DX, BX		// save function entry context (for closures)
-#ifndef GOEXPERIMENT_REGABI
+#ifndef GOEXPERIMENT_REGABI_G
 	get_tls(R12)
 	MOVQ	g(R12), R14
 #endif
@@ -193,7 +193,7 @@ TEXT	racefuncenter<>(SB), NOSPLIT, $0-0
 // func runtime·racefuncexit()
 // Called from instrumented code.
 TEXT	runtime·racefuncexit(SB), NOSPLIT, $0-0
-#ifndef GOEXPERIMENT_REGABI
+#ifndef GOEXPERIMENT_REGABI_G
 	get_tls(R12)
 	MOVQ	g(R12), R14
 #endif
@@ -355,7 +355,7 @@ racecallatomic_data:
 	JAE	racecallatomic_ignore
 racecallatomic_ok:
 	// Addr is within the good range, call the atomic function.
-#ifndef GOEXPERIMENT_REGABI
+#ifndef GOEXPERIMENT_REGABI_G
 	get_tls(R12)
 	MOVQ	g(R12), R14
 #endif
@@ -370,7 +370,7 @@ racecallatomic_ignore:
 	// An attempt to synchronize on the address would cause crash.
 	MOVQ	AX, BX	// remember the original function
 	MOVQ	$__tsan_go_ignore_sync_begin(SB), AX
-#ifndef GOEXPERIMENT_REGABI
+#ifndef GOEXPERIMENT_REGABI_G
 	get_tls(R12)
 	MOVQ	g(R12), R14
 #endif
@@ -401,7 +401,7 @@ TEXT	runtime·racecall(SB), NOSPLIT, $0-0
 
 // Switches SP to g0 stack and calls (AX). Arguments already set.
 TEXT	racecall<>(SB), NOSPLIT, $0-0
-#ifndef GOEXPERIMENT_REGABI
+#ifndef GOEXPERIMENT_REGABI_G
 	get_tls(R12)
 	MOVQ	g(R12), R14
 #endif
diff --git a/src/runtime/sys_linux_amd64.s b/src/runtime/sys_linux_amd64.s
index d48573c2c5..584f2c5b1e 100644
--- a/src/runtime/sys_linux_amd64.s
+++ b/src/runtime/sys_linux_amd64.s
@@ -215,7 +215,7 @@ TEXT runtime·walltime1(SB),NOSPLIT,$16-12
 
 	MOVQ	SP, R12	// Save old SP; R12 unchanged by C code.
 
-#ifdef GOEXPERIMENT_REGABI
+#ifdef GOEXPERIMENT_REGABI_G
 	MOVQ	g_m(R14), BX // BX unchanged by C code.
 #else
 	get_tls(CX)
@@ -236,7 +236,7 @@ TEXT runtime·walltime1(SB),NOSPLIT,$16-12
 	MOVQ	CX, m_vdsoPC(BX)
 	MOVQ	DX, m_vdsoSP(BX)
 
-#ifdef GOEXPERIMENT_REGABI
+#ifdef GOEXPERIMENT_REGABI_G
 	CMPQ	R14, m_curg(BX)	// Only switch if on curg.
 #else
 	CMPQ	AX, m_curg(BX)	// Only switch if on curg.
@@ -283,7 +283,7 @@ TEXT runtime·nanotime1(SB),NOSPLIT,$16-8
 
 	MOVQ	SP, R12	// Save old SP; R12 unchanged by C code.
 
-#ifdef GOEXPERIMENT_REGABI
+#ifdef GOEXPERIMENT_REGABI_G
 	MOVQ	g_m(R14), BX // BX unchanged by C code.
 #else
 	get_tls(CX)
@@ -304,7 +304,7 @@ TEXT runtime·nanotime1(SB),NOSPLIT,$16-8
 	MOVQ	CX, m_vdsoPC(BX)
 	MOVQ	DX, m_vdsoSP(BX)
 
-#ifdef GOEXPERIMENT_REGABI
+#ifdef GOEXPERIMENT_REGABI_G
 	CMPQ	R14, m_curg(BX)	// Only switch if on curg.
 #else
 	CMPQ	AX, m_curg(BX)	// Only switch if on curg.
-- 
GitLab


From f47fab938eb19e383258b3501560b46d2e47158a Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Wed, 17 Mar 2021 17:54:41 -0700
Subject: [PATCH 1154/2400] cmd/compile: remove unneeded calls to typecheck in
 noder2

Remove unneeded calls to typecheck in noder2 associated with g.use() and
g.obj(). These routines are already setting the types2-derived type
correctly for ONAME nodes, and there is no typechecker1-related
transformations related to ONAME nodes, other than making sure that
newly created closure variables have their type set.

Tested through normal -G=3 testing in all.bash (all of go/tests).

Change-Id: I1b790ab9948959685fca3a768401458201833671
Reviewed-on: https://go-review.googlesource.com/c/go/+/303029
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/noder/expr.go   |  7 ++-----
 src/cmd/compile/internal/noder/object.go | 20 ++++++++++++++++----
 2 files changed, 18 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index 1ca5552879..957295bdf0 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -30,7 +30,6 @@ func (g *irgen) expr(expr syntax.Expr) ir.Node {
 	}
 	switch {
 	case tv.IsBuiltin():
-		// TODO(mdempsky): Handle in CallExpr?
 		return g.use(expr.(*syntax.Name))
 	case tv.IsType():
 		return ir.TypeNode(g.typ(tv.Type))
@@ -82,8 +81,7 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 		if _, isNil := g.info.Uses[expr].(*types2.Nil); isNil {
 			return Nil(pos, g.typ(typ))
 		}
-		// TODO(mdempsky): Remove dependency on typecheck.Expr.
-		return typecheck.Expr(g.use(expr))
+		return g.use(expr)
 
 	case *syntax.CompositeLit:
 		return g.compLit(typ, expr)
@@ -157,8 +155,7 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 		// Qualified identifier.
 		if name, ok := expr.X.(*syntax.Name); ok {
 			if _, ok := g.info.Uses[name].(*types2.PkgName); ok {
-				// TODO(mdempsky): Remove dependency on typecheck.Expr.
-				return typecheck.Expr(g.use(expr.Sel))
+				return g.use(expr.Sel)
 			}
 		}
 		return g.selectorExpr(pos, typ, expr)
diff --git a/src/cmd/compile/internal/noder/object.go b/src/cmd/compile/internal/noder/object.go
index b4e5c022db..6c8ed4af97 100644
--- a/src/cmd/compile/internal/noder/object.go
+++ b/src/cmd/compile/internal/noder/object.go
@@ -22,16 +22,26 @@ func (g *irgen) def(name *syntax.Name) (*ir.Name, types2.Object) {
 	return g.obj(obj), obj
 }
 
+// use returns the Name node associated with the use of name. The returned node
+// will have the correct type and be marked as typechecked.
 func (g *irgen) use(name *syntax.Name) *ir.Name {
-	obj, ok := g.info.Uses[name]
+	obj2, ok := g.info.Uses[name]
 	if !ok {
 		base.FatalfAt(g.pos(name), "unknown name %v", name)
 	}
-	return ir.CaptureName(g.pos(obj), ir.CurFunc, g.obj(obj))
+	obj := ir.CaptureName(g.pos(obj2), ir.CurFunc, g.obj(obj2))
+	if obj.Defn != nil && obj.Defn.Op() == ir.ONAME {
+		// If CaptureName created a closure variable, then transfer the
+		// type of the captured name to the new closure variable.
+		obj.SetTypecheck(1)
+		obj.SetType(obj.Defn.Type())
+	}
+	return obj
 }
 
-// obj returns the Name that represents the given object. If no such
-// Name exists yet, it will be implicitly created.
+// obj returns the Name that represents the given object. If no such Name exists
+// yet, it will be implicitly created. The returned node will have the correct
+// type and be marked as typechecked.
 //
 // For objects declared at function scope, ir.CurFunc must already be
 // set to the respective function when the Name is created.
@@ -45,6 +55,7 @@ func (g *irgen) obj(obj types2.Object) *ir.Name {
 		}
 		n := typecheck.Resolve(ir.NewIdent(src.NoXPos, sym))
 		if n, ok := n.(*ir.Name); ok {
+			n.SetTypecheck(1)
 			return n
 		}
 		base.FatalfAt(g.pos(obj), "failed to resolve %v", obj)
@@ -117,6 +128,7 @@ func (g *irgen) obj(obj types2.Object) *ir.Name {
 	}
 
 	g.objs[obj] = name
+	name.SetTypecheck(1)
 	return name
 }
 
-- 
GitLab


From b95e4b7850a504748655ad4f025379701afc206c Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 17 Mar 2021 22:44:16 -0700
Subject: [PATCH 1155/2400] go/types: minor simplification in assignableTo
 (cleanup)

Also, clarify doc string.

Change-Id: If1c5f8e29e2c2080dd899ef76196e97b7b992389
Reviewed-on: https://go-review.googlesource.com/c/go/+/302758
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/go/types/operand.go | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/src/go/types/operand.go b/src/go/types/operand.go
index 8344c059c4..6463728cec 100644
--- a/src/go/types/operand.go
+++ b/src/go/types/operand.go
@@ -222,9 +222,10 @@ func (x *operand) isNil() bool {
 
 // assignableTo reports whether x is assignable to a variable of type T. If the
 // result is false and a non-nil reason is provided, it may be set to a more
-// detailed explanation of the failure (result != ""). The check parameter may
-// be nil if assignableTo is invoked through an exported API call, i.e., when
-// all methods have been type-checked.
+// detailed explanation of the failure (result != ""). The returned error code
+// is only valid if the (first) result is false. The check parameter may be nil
+// if assignableTo is invoked through an exported API call, i.e., when all
+// methods have been type-checked.
 func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, errorCode) {
 	if x.mode == invalid || T == Typ[Invalid] {
 		return true, 0 // avoid spurious errors
@@ -285,11 +286,7 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er
 	// and at least one of V or T is not a named type
 	if Vc, ok := Vu.(*Chan); ok && Vc.dir == SendRecv {
 		if Tc, ok := Tu.(*Chan); ok && check.identical(Vc.elem, Tc.elem) {
-			if !isNamed(V) || !isNamed(T) {
-				return true, 0
-			} else {
-				return false, _InvalidChanAssign
-			}
+			return !isNamed(V) || !isNamed(T), _InvalidChanAssign
 		}
 	}
 
-- 
GitLab


From e4253cd023e77743ae11d79c4be3dd6db8138aa9 Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Wed, 10 Mar 2021 15:10:05 -0600
Subject: [PATCH 1156/2400] cmd/link: Add section data slice to
 Archrelocvariant

PPC64 needs to preserve bits when applying some relocations. DS form
relocations must preserve the lower two bits, and thus needs to inspect
the section data as it streams out.

Similarly, the overflow checking requires inspecting the primary
opcode to see if the value is sign or zero extended.

The existing PPC64 code no longer works as the slice returned by
(loader*).Data is cleared as we layout the symbol and process
relocations.  This data is always the section undergoing relocation,
thus we can directly inspect the contents to preserve bits or
check for overflows.

Change-Id: I239211f7e5e96208673663b6553b3017adae7e01
Reviewed-on: https://go-review.googlesource.com/c/go/+/300555
Run-TryBot: Paul Murphy <murp@ibm.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/cmd/link/internal/amd64/asm.go   |  2 +-
 src/cmd/link/internal/arm/asm.go     |  2 +-
 src/cmd/link/internal/arm64/asm.go   |  2 +-
 src/cmd/link/internal/ld/data.go     |  2 +-
 src/cmd/link/internal/ld/lib.go      |  2 +-
 src/cmd/link/internal/mips/asm.go    |  2 +-
 src/cmd/link/internal/mips64/asm.go  |  2 +-
 src/cmd/link/internal/ppc64/asm.go   | 15 ++++++++-------
 src/cmd/link/internal/riscv64/asm.go |  2 +-
 src/cmd/link/internal/s390x/asm.go   |  2 +-
 src/cmd/link/internal/x86/asm.go     |  2 +-
 11 files changed, 18 insertions(+), 17 deletions(-)

diff --git a/src/cmd/link/internal/amd64/asm.go b/src/cmd/link/internal/amd64/asm.go
index 2d09a6160a..fb960491de 100644
--- a/src/cmd/link/internal/amd64/asm.go
+++ b/src/cmd/link/internal/amd64/asm.go
@@ -548,7 +548,7 @@ func archreloc(*ld.Target, *loader.Loader, *ld.ArchSyms, loader.Reloc, loader.Sy
 	return -1, 0, false
 }
 
-func archrelocvariant(*ld.Target, *loader.Loader, loader.Reloc, sym.RelocVariant, loader.Sym, int64) int64 {
+func archrelocvariant(*ld.Target, *loader.Loader, loader.Reloc, sym.RelocVariant, loader.Sym, int64, []byte) int64 {
 	log.Fatalf("unexpected relocation variant")
 	return -1
 }
diff --git a/src/cmd/link/internal/arm/asm.go b/src/cmd/link/internal/arm/asm.go
index 03caeae7be..efdaff198d 100644
--- a/src/cmd/link/internal/arm/asm.go
+++ b/src/cmd/link/internal/arm/asm.go
@@ -565,7 +565,7 @@ func archreloc(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, r loade
 	return val, 0, false
 }
 
-func archrelocvariant(*ld.Target, *loader.Loader, loader.Reloc, sym.RelocVariant, loader.Sym, int64) int64 {
+func archrelocvariant(*ld.Target, *loader.Loader, loader.Reloc, sym.RelocVariant, loader.Sym, int64, []byte) int64 {
 	log.Fatalf("unexpected relocation variant")
 	return -1
 }
diff --git a/src/cmd/link/internal/arm64/asm.go b/src/cmd/link/internal/arm64/asm.go
index 72093268c2..90ae38594e 100644
--- a/src/cmd/link/internal/arm64/asm.go
+++ b/src/cmd/link/internal/arm64/asm.go
@@ -865,7 +865,7 @@ func archreloc(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, r loade
 	return val, 0, false
 }
 
-func archrelocvariant(*ld.Target, *loader.Loader, loader.Reloc, sym.RelocVariant, loader.Sym, int64) int64 {
+func archrelocvariant(*ld.Target, *loader.Loader, loader.Reloc, sym.RelocVariant, loader.Sym, int64, []byte) int64 {
 	log.Fatalf("unexpected relocation variant")
 	return -1
 }
diff --git a/src/cmd/link/internal/ld/data.go b/src/cmd/link/internal/ld/data.go
index a9d17c806e..6de2d893ae 100644
--- a/src/cmd/link/internal/ld/data.go
+++ b/src/cmd/link/internal/ld/data.go
@@ -507,7 +507,7 @@ func (st *relocSymState) relocsym(s loader.Sym, P []byte) {
 
 		if target.IsPPC64() || target.IsS390X() {
 			if rv != sym.RV_NONE {
-				o = thearch.Archrelocvariant(target, ldr, r, rv, s, o)
+				o = thearch.Archrelocvariant(target, ldr, r, rv, s, o, P)
 			}
 		}
 
diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index c96a9be355..d136cbad80 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -223,7 +223,7 @@ type Arch struct {
 	// to-be-relocated data item (from sym.P). Return is an updated
 	// offset value.
 	Archrelocvariant func(target *Target, ldr *loader.Loader, rel loader.Reloc,
-		rv sym.RelocVariant, sym loader.Sym, offset int64) (relocatedOffset int64)
+		rv sym.RelocVariant, sym loader.Sym, offset int64, data []byte) (relocatedOffset int64)
 
 	// Generate a trampoline for a call from s to rs if necessary. ri is
 	// index of the relocation.
diff --git a/src/cmd/link/internal/mips/asm.go b/src/cmd/link/internal/mips/asm.go
index 17b1b20aff..8505dc6109 100644
--- a/src/cmd/link/internal/mips/asm.go
+++ b/src/cmd/link/internal/mips/asm.go
@@ -140,7 +140,7 @@ func archreloc(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, r loade
 	return val, 0, false
 }
 
-func archrelocvariant(*ld.Target, *loader.Loader, loader.Reloc, sym.RelocVariant, loader.Sym, int64) int64 {
+func archrelocvariant(*ld.Target, *loader.Loader, loader.Reloc, sym.RelocVariant, loader.Sym, int64, []byte) int64 {
 	return -1
 }
 
diff --git a/src/cmd/link/internal/mips64/asm.go b/src/cmd/link/internal/mips64/asm.go
index 4789b411eb..55b4ba2fc8 100644
--- a/src/cmd/link/internal/mips64/asm.go
+++ b/src/cmd/link/internal/mips64/asm.go
@@ -138,7 +138,7 @@ func archreloc(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, r loade
 	return val, 0, false
 }
 
-func archrelocvariant(*ld.Target, *loader.Loader, loader.Reloc, sym.RelocVariant, loader.Sym, int64) int64 {
+func archrelocvariant(*ld.Target, *loader.Loader, loader.Reloc, sym.RelocVariant, loader.Sym, int64, []byte) int64 {
 	return -1
 }
 
diff --git a/src/cmd/link/internal/ppc64/asm.go b/src/cmd/link/internal/ppc64/asm.go
index 83df8a7a13..aa2532ad37 100644
--- a/src/cmd/link/internal/ppc64/asm.go
+++ b/src/cmd/link/internal/ppc64/asm.go
@@ -859,7 +859,7 @@ func archreloc(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, r loade
 	return val, nExtReloc, false
 }
 
-func archrelocvariant(target *ld.Target, ldr *loader.Loader, r loader.Reloc, rv sym.RelocVariant, s loader.Sym, t int64) (relocatedOffset int64) {
+func archrelocvariant(target *ld.Target, ldr *loader.Loader, r loader.Reloc, rv sym.RelocVariant, s loader.Sym, t int64, p []byte) (relocatedOffset int64) {
 	rs := ldr.ResolveABIAlias(r.Sym())
 	switch rv & sym.RV_TYPE_MASK {
 	default:
@@ -875,9 +875,10 @@ func archrelocvariant(target *ld.Target, ldr *loader.Loader, r loader.Reloc, rv
 			// overflow depends on the instruction
 			var o1 uint32
 			if target.IsBigEndian() {
-				o1 = binary.BigEndian.Uint32(ldr.Data(s)[r.Off()-2:])
+				o1 = binary.BigEndian.Uint32(p[r.Off()-2:])
+
 			} else {
-				o1 = binary.LittleEndian.Uint32(ldr.Data(s)[r.Off():])
+				o1 = binary.LittleEndian.Uint32(p[r.Off():])
 			}
 			switch o1 >> 26 {
 			case 24, // ori
@@ -909,9 +910,9 @@ func archrelocvariant(target *ld.Target, ldr *loader.Loader, r loader.Reloc, rv
 			// overflow depends on the instruction
 			var o1 uint32
 			if target.IsBigEndian() {
-				o1 = binary.BigEndian.Uint32(ldr.Data(s)[r.Off()-2:])
+				o1 = binary.BigEndian.Uint32(p[r.Off()-2:])
 			} else {
-				o1 = binary.LittleEndian.Uint32(ldr.Data(s)[r.Off():])
+				o1 = binary.LittleEndian.Uint32(p[r.Off():])
 			}
 			switch o1 >> 26 {
 			case 25, // oris
@@ -933,9 +934,9 @@ func archrelocvariant(target *ld.Target, ldr *loader.Loader, r loader.Reloc, rv
 	case sym.RV_POWER_DS:
 		var o1 uint32
 		if target.IsBigEndian() {
-			o1 = uint32(binary.BigEndian.Uint16(ldr.Data(s)[r.Off():]))
+			o1 = uint32(binary.BigEndian.Uint16(p[r.Off():]))
 		} else {
-			o1 = uint32(binary.LittleEndian.Uint16(ldr.Data(s)[r.Off():]))
+			o1 = uint32(binary.LittleEndian.Uint16(p[r.Off():]))
 		}
 		if t&3 != 0 {
 			ldr.Errorf(s, "relocation for %s+%d is not aligned: %d", ldr.SymName(rs), r.Off(), t)
diff --git a/src/cmd/link/internal/riscv64/asm.go b/src/cmd/link/internal/riscv64/asm.go
index c18e0540d8..6eace617dc 100644
--- a/src/cmd/link/internal/riscv64/asm.go
+++ b/src/cmd/link/internal/riscv64/asm.go
@@ -230,7 +230,7 @@ func archreloc(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, r loade
 	return val, 0, false
 }
 
-func archrelocvariant(*ld.Target, *loader.Loader, loader.Reloc, sym.RelocVariant, loader.Sym, int64) int64 {
+func archrelocvariant(*ld.Target, *loader.Loader, loader.Reloc, sym.RelocVariant, loader.Sym, int64, []byte) int64 {
 	log.Fatalf("archrelocvariant")
 	return -1
 }
diff --git a/src/cmd/link/internal/s390x/asm.go b/src/cmd/link/internal/s390x/asm.go
index 78d2cc81e4..1952971dcb 100644
--- a/src/cmd/link/internal/s390x/asm.go
+++ b/src/cmd/link/internal/s390x/asm.go
@@ -371,7 +371,7 @@ func archreloc(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, r loade
 	return val, 0, false
 }
 
-func archrelocvariant(target *ld.Target, ldr *loader.Loader, r loader.Reloc, rv sym.RelocVariant, s loader.Sym, t int64) int64 {
+func archrelocvariant(target *ld.Target, ldr *loader.Loader, r loader.Reloc, rv sym.RelocVariant, s loader.Sym, t int64, p []byte) int64 {
 	switch rv & sym.RV_TYPE_MASK {
 	default:
 		ldr.Errorf(s, "unexpected relocation variant %d", rv)
diff --git a/src/cmd/link/internal/x86/asm.go b/src/cmd/link/internal/x86/asm.go
index af0ce11255..5f6bcfb8b1 100644
--- a/src/cmd/link/internal/x86/asm.go
+++ b/src/cmd/link/internal/x86/asm.go
@@ -415,7 +415,7 @@ func archreloc(*ld.Target, *loader.Loader, *ld.ArchSyms, loader.Reloc, loader.Sy
 	return -1, 0, false
 }
 
-func archrelocvariant(*ld.Target, *loader.Loader, loader.Reloc, sym.RelocVariant, loader.Sym, int64) int64 {
+func archrelocvariant(*ld.Target, *loader.Loader, loader.Reloc, sym.RelocVariant, loader.Sym, int64, []byte) int64 {
 	log.Fatalf("unexpected relocation variant")
 	return -1
 }
-- 
GitLab


From 79d03ad7396c781aa490442a3c853b5cb627298d Mon Sep 17 00:00:00 2001
From: Elvina Yakubova <elvinayakubova@gmail.com>
Date: Thu, 24 Dec 2020 22:38:06 +0300
Subject: [PATCH 1157/2400] runtime/pprof: move common code to
 writeProfileInternal function

This patch provides changes according to TODO. Since writeMutex and
writeBlock functions have a lot of code in common, it is better to
move this code to one function.

Change-Id: I81aaad067b0cb1647824909f3b5f6861add3a7ba
Reviewed-on: https://go-review.googlesource.com/c/go/+/280152
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: Hyang-Ah Hana Kim <hyangah@gmail.com>
---
 src/runtime/pprof/pprof.go | 58 +++++++++-----------------------------
 1 file changed, 13 insertions(+), 45 deletions(-)

diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index d3b7df3c1b..99eda10f1c 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -843,45 +843,7 @@ func countMutex() int {
 
 // writeBlock writes the current blocking profile to w.
 func writeBlock(w io.Writer, debug int) error {
-	var p []runtime.BlockProfileRecord
-	n, ok := runtime.BlockProfile(nil)
-	for {
-		p = make([]runtime.BlockProfileRecord, n+50)
-		n, ok = runtime.BlockProfile(p)
-		if ok {
-			p = p[:n]
-			break
-		}
-	}
-
-	sort.Slice(p, func(i, j int) bool { return p[i].Cycles > p[j].Cycles })
-
-	if debug <= 0 {
-		return printCountCycleProfile(w, "contentions", "delay", scaleBlockProfile, p)
-	}
-
-	b := bufio.NewWriter(w)
-	tw := tabwriter.NewWriter(w, 1, 8, 1, '\t', 0)
-	w = tw
-
-	fmt.Fprintf(w, "--- contention:\n")
-	fmt.Fprintf(w, "cycles/second=%v\n", runtime_cyclesPerSecond())
-	for i := range p {
-		r := &p[i]
-		fmt.Fprintf(w, "%v %v @", r.Cycles, r.Count)
-		for _, pc := range r.Stack() {
-			fmt.Fprintf(w, " %#x", pc)
-		}
-		fmt.Fprint(w, "\n")
-		if debug > 0 {
-			printStackRecord(w, r.Stack(), true)
-		}
-	}
-
-	if tw != nil {
-		tw.Flush()
-	}
-	return b.Flush()
+	return writeProfileInternal(w, debug, "contention", runtime.BlockProfile, scaleBlockProfile)
 }
 
 func scaleBlockProfile(cnt int64, ns float64) (int64, float64) {
@@ -894,12 +856,16 @@ func scaleBlockProfile(cnt int64, ns float64) (int64, float64) {
 
 // writeMutex writes the current mutex profile to w.
 func writeMutex(w io.Writer, debug int) error {
-	// TODO(pjw): too much common code with writeBlock. FIX!
+	return writeProfileInternal(w, debug, "mutex", runtime.MutexProfile, scaleMutexProfile)
+}
+
+// writeProfileInternal writes the current blocking or mutex profile depending on the passed parameters
+func writeProfileInternal(w io.Writer, debug int, name string, runtimeProfile func([]runtime.BlockProfileRecord) (int, bool), scaleProfile func(int64, float64) (int64, float64)) error {
 	var p []runtime.BlockProfileRecord
-	n, ok := runtime.MutexProfile(nil)
+	n, ok := runtimeProfile(nil)
 	for {
 		p = make([]runtime.BlockProfileRecord, n+50)
-		n, ok = runtime.MutexProfile(p)
+		n, ok = runtimeProfile(p)
 		if ok {
 			p = p[:n]
 			break
@@ -909,16 +875,18 @@ func writeMutex(w io.Writer, debug int) error {
 	sort.Slice(p, func(i, j int) bool { return p[i].Cycles > p[j].Cycles })
 
 	if debug <= 0 {
-		return printCountCycleProfile(w, "contentions", "delay", scaleMutexProfile, p)
+		return printCountCycleProfile(w, "contentions", "delay", scaleProfile, p)
 	}
 
 	b := bufio.NewWriter(w)
 	tw := tabwriter.NewWriter(w, 1, 8, 1, '\t', 0)
 	w = tw
 
-	fmt.Fprintf(w, "--- mutex:\n")
+	fmt.Fprintf(w, "--- %v:\n", name)
 	fmt.Fprintf(w, "cycles/second=%v\n", runtime_cyclesPerSecond())
-	fmt.Fprintf(w, "sampling period=%d\n", runtime.SetMutexProfileFraction(-1))
+	if name == "mutex" {
+		fmt.Fprintf(w, "sampling period=%d\n", runtime.SetMutexProfileFraction(-1))
+	}
 	for i := range p {
 		r := &p[i]
 		fmt.Fprintf(w, "%v %v @", r.Cycles, r.Count)
-- 
GitLab


From bdbba224040a0f079a80368d9956f85a10577045 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Fri, 5 Mar 2021 19:47:34 +0000
Subject: [PATCH 1158/2400] reflect: add tests for reflect.Value.Call for the
 new ABI

This change adds tests for reflect.Value.Call for calling functions
using the new register-based ABI.

For #40724.

Change-Id: Ia9afd43e26dd80c7e36dd135a5b71acce8074801
Reviewed-on: https://go-review.googlesource.com/c/go/+/299269
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/reflect/abi_test.go    | 447 +++++++++++++++++++++++++++++++++++++
 src/reflect/export_test.go |  15 +-
 2 files changed, 461 insertions(+), 1 deletion(-)
 create mode 100644 src/reflect/abi_test.go

diff --git a/src/reflect/abi_test.go b/src/reflect/abi_test.go
new file mode 100644
index 0000000000..418896ee87
--- /dev/null
+++ b/src/reflect/abi_test.go
@@ -0,0 +1,447 @@
+// Copyright 2021 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.
+
+// +build goexperiment.regabi
+//go:build goexperiment.regabi
+
+package reflect_test
+
+import (
+	"internal/abi"
+	"math/rand"
+	"reflect"
+	"runtime"
+	"testing"
+	"testing/quick"
+)
+
+func TestReflectValueCallABI(t *testing.T) {
+	// Enable register-based reflect.Call and ensure we don't
+	// use potentially incorrect cached versions by clearing
+	// the cache before we start and after we're done.
+	var oldRegs struct {
+		ints, floats int
+		floatSize    uintptr
+	}
+	oldRegs.ints = *reflect.IntArgRegs
+	oldRegs.floats = *reflect.FloatArgRegs
+	oldRegs.floatSize = *reflect.FloatRegSize
+	*reflect.IntArgRegs = abi.IntArgRegs
+	*reflect.FloatArgRegs = abi.FloatArgRegs
+	*reflect.FloatRegSize = uintptr(abi.EffectiveFloatRegSize)
+	reflect.ClearLayoutCache()
+	defer func() {
+		*reflect.IntArgRegs = oldRegs.ints
+		*reflect.FloatArgRegs = oldRegs.floats
+		*reflect.FloatRegSize = oldRegs.floatSize
+		reflect.ClearLayoutCache()
+	}()
+
+	// Execute the functions defined below which all have the
+	// same form and perform the same function: pass all arguments
+	// to return values. The purpose is to test the call boundary
+	// and make sure it works.
+	r := rand.New(rand.NewSource(genValueRandSeed))
+	for _, fn := range []interface{}{
+		passNone,
+		passInt,
+		passInt8,
+		passInt16,
+		passInt32,
+		passInt64,
+		passUint,
+		passUint8,
+		passUint16,
+		passUint32,
+		passUint64,
+		passFloat32,
+		passFloat64,
+		passComplex64,
+		passComplex128,
+		passManyInt,
+		passManyFloat64,
+		passArray1,
+		passArray,
+		passArray1Mix,
+		passString,
+		// TODO(mknyszek): Test passing interface values.
+		passSlice,
+		passPointer,
+		passStruct1,
+		passStruct2,
+		passStruct3,
+		passStruct4,
+		passStruct5,
+		passStruct6,
+		passStruct7,
+		passStruct8,
+		passStruct9,
+		passStruct10,
+		// TODO(mknyszek): Test passing unsafe.Pointer values.
+		// TODO(mknyszek): Test passing chan values.
+		passStruct11,
+		passStruct12,
+		passStruct13,
+		pass2Struct1,
+		passEmptyStruct,
+	} {
+		fn := reflect.ValueOf(fn)
+		t.Run(runtime.FuncForPC(fn.Pointer()).Name(), func(t *testing.T) {
+			typ := fn.Type()
+			if typ.Kind() != reflect.Func {
+				t.Fatalf("test case is not a function, has type: %s", typ.String())
+			}
+			if typ.NumIn() != typ.NumOut() {
+				t.Fatalf("test case has different number of inputs and outputs: %d in, %d out", typ.NumIn(), typ.NumOut())
+			}
+			var args []reflect.Value
+			for i := 0; i < typ.NumIn(); i++ {
+				args = append(args, genValue(t, typ.In(i), r))
+			}
+			results := fn.Call(args)
+			for i := range results {
+				x, y := args[i].Interface(), results[i].Interface()
+				if reflect.DeepEqual(x, y) {
+					continue
+				}
+				t.Errorf("arg and result %d differ: got %+v, want %+v", i, x, y)
+			}
+		})
+	}
+}
+
+// Functions for testing reflect.Value.Call.
+
+//go:registerparams
+//go:noinline
+func passNone() {}
+
+//go:registerparams
+//go:noinline
+func passInt(a int) int {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passInt8(a int8) int8 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passInt16(a int16) int16 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passInt32(a int32) int32 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passInt64(a int64) int64 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passUint(a uint) uint {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passUint8(a uint8) uint8 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passUint16(a uint16) uint16 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passUint32(a uint32) uint32 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passUint64(a uint64) uint64 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passFloat32(a float32) float32 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passFloat64(a float64) float64 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passComplex64(a complex64) complex64 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passComplex128(a complex128) complex128 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passArray1(a [1]uint32) [1]uint32 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passArray(a [2]uintptr) [2]uintptr {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passArray1Mix(a int, b [1]uint32, c float64) (int, [1]uint32, float64) {
+	return a, b, c
+}
+
+//go:registerparams
+//go:noinline
+func passString(a string) string {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passSlice(a []byte) []byte {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passPointer(a *byte) *byte {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passManyInt(a, b, c, d, e, f, g, h, i, j int) (int, int, int, int, int, int, int, int, int, int) {
+	return a, b, c, d, e, f, g, h, i, j
+}
+
+//go:registerparams
+//go:noinline
+func passManyFloat64(a, b, c, d, e, f, g, h, i, j, l, m, n, o, p, q, r, s, t float64) (float64, float64, float64, float64, float64, float64, float64, float64, float64, float64, float64, float64, float64, float64, float64, float64, float64, float64, float64) {
+	return a, b, c, d, e, f, g, h, i, j, l, m, n, o, p, q, r, s, t
+}
+
+//go:registerparams
+//go:noinline
+func passStruct1(a Struct1) Struct1 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct2(a Struct2) Struct2 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct3(a Struct3) Struct3 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct4(a Struct4) Struct4 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct5(a Struct5) Struct5 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct6(a Struct6) Struct6 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct7(a Struct7) Struct7 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct8(a Struct8) Struct8 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct9(a Struct9) Struct9 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct10(a Struct10) Struct10 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct11(a Struct11) Struct11 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct12(a Struct12) Struct12 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct13(a Struct13) Struct13 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func pass2Struct1(a, b Struct1) (x, y Struct1) {
+	return a, b
+}
+
+//go:registerparams
+//go:noinline
+func passEmptyStruct(a int, b struct{}, c float64) (int, struct{}, float64) {
+	return a, b, c
+}
+
+// Struct1 is a simple integer-only aggregate struct.
+type Struct1 struct {
+	A, B, C uint
+}
+
+// Struct2 is Struct1 but with an array-typed field that will
+// force it to get passed on the stack.
+type Struct2 struct {
+	A, B, C uint
+	D       [2]uint32
+}
+
+// Struct3 is Struct2 but with an anonymous array-typed field.
+// This should act identically to Struct2.
+type Struct3 struct {
+	A, B, C uint
+	D       [2]uint32
+}
+
+// Struct4 has byte-length fields that should
+// each use up a whole registers.
+type Struct4 struct {
+	A, B int8
+	C, D uint8
+	E    bool
+}
+
+// Struct5 is a relatively large struct
+// with both integer and floating point values.
+type Struct5 struct {
+	A             uint16
+	B             int16
+	C, D          uint32
+	E             int32
+	F, G, H, I, J float32
+}
+
+// Struct6 has a nested struct.
+type Struct6 struct {
+	Struct1
+}
+
+// Struct7 is a struct with a nested array-typed field
+// that cannot be passed in registers as a result.
+type Struct7 struct {
+	Struct1
+	Struct2
+}
+
+// Struct8 is large aggregate struct type that may be
+// passed in registers.
+type Struct8 struct {
+	Struct5
+	Struct1
+}
+
+// Struct9 is a type that has an array type nested
+// 2 layers deep, and as a result needs to be passed
+// on the stack.
+type Struct9 struct {
+	Struct1
+	Struct7
+}
+
+// Struct10 is a struct type that is too large to be
+// passed in registers.
+type Struct10 struct {
+	Struct5
+	Struct8
+}
+
+// Struct11 is a struct type that has several reference
+// types in it.
+type Struct11 struct {
+	X map[string]int
+}
+
+// Struct12 has Struct11 embedded into it to test more
+// paths.
+type Struct12 struct {
+	A int
+	Struct11
+}
+
+// Struct13 tests an empty field.
+type Struct13 struct {
+	A int
+	X struct{}
+	B int
+}
+
+const genValueRandSeed = 0
+
+// genValue generates a pseudorandom reflect.Value with type t.
+// The reflect.Value produced by this function is always the same
+// for the same type.
+func genValue(t *testing.T, typ reflect.Type, r *rand.Rand) reflect.Value {
+	// Re-seed and reset the PRNG because we want each value with the
+	// same type to be the same random value.
+	r.Seed(genValueRandSeed)
+	v, ok := quick.Value(typ, r)
+	if !ok {
+		t.Fatal("failed to generate value")
+	}
+	return v
+}
diff --git a/src/reflect/export_test.go b/src/reflect/export_test.go
index ddcfca9dee..3a5ed5af3c 100644
--- a/src/reflect/export_test.go
+++ b/src/reflect/export_test.go
@@ -4,7 +4,10 @@
 
 package reflect
 
-import "unsafe"
+import (
+	"sync"
+	"unsafe"
+)
 
 // MakeRO returns a copy of v with the read-only flag set.
 func MakeRO(v Value) Value {
@@ -17,6 +20,12 @@ func IsRO(v Value) bool {
 	return v.flag&flagStickyRO != 0
 }
 
+var (
+	IntArgRegs   = &intArgRegs
+	FloatArgRegs = &floatArgRegs
+	FloatRegSize = &floatRegSize
+)
+
 var CallGC = &callGC
 
 const PtrSize = ptrSize
@@ -122,3 +131,7 @@ func ResolveReflectName(s string) {
 type Buffer struct {
 	buf []byte
 }
+
+func ClearLayoutCache() {
+	layoutCache = sync.Map{}
+}
-- 
GitLab


From d3ab6b50496a58ff3deb2502b6c8b9b38947eeca Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Thu, 18 Mar 2021 11:35:45 -0400
Subject: [PATCH 1159/2400] test: switch fieldtrack test to use GOEXPERIMENT

Now that we can set GOEXPERIMENT at build time, we no longer need
-d=fieldtrack in the compiler to enabled field tracking at build time.
Switch the one test that uses -d=fieldtrack to use GOEXPERIMENT
instead so we can eliminate this debug flag and centralize on
GOEXPERIMENT.

Updates #42681.

Change-Id: I14c352c9a97187b9c5ec8027ff672d685f22f543
Reviewed-on: https://go-review.googlesource.com/c/go/+/302969
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 test/fixedbugs/issue42686.go | 2 +-
 test/run.go                  | 6 +++++-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/test/fixedbugs/issue42686.go b/test/fixedbugs/issue42686.go
index 962bdd35cb..9f9075ca7d 100644
--- a/test/fixedbugs/issue42686.go
+++ b/test/fixedbugs/issue42686.go
@@ -1,4 +1,4 @@
-// compile -d=fieldtrack
+// compile -goexperiment fieldtrack
 
 // Copyright 2020 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/run.go b/test/run.go
index 4c01886560..7d5a558f2d 100644
--- a/test/run.go
+++ b/test/run.go
@@ -513,7 +513,7 @@ func (t *test) run() {
 		return
 	}
 
-	var args, flags []string
+	var args, flags, runenv []string
 	var tim int
 	wantError := false
 	wantAuto := false
@@ -572,6 +572,9 @@ func (t *test) run() {
 			if err != nil {
 				t.err = fmt.Errorf("need number of seconds for -t timeout, got %s instead", args[0])
 			}
+		case "-goexperiment": // set GOEXPERIMENT environment
+			args = args[1:]
+			runenv = append(runenv, "GOEXPERIMENT="+args[0])
 
 		default:
 			flags = append(flags, args[0])
@@ -628,6 +631,7 @@ func (t *test) run() {
 		if tempDirIsGOPATH {
 			cmd.Env = append(cmd.Env, "GOPATH="+t.tempDir)
 		}
+		cmd.Env = append(cmd.Env, runenv...)
 
 		var err error
 
-- 
GitLab


From 0c93b16d015663a60ac77900ca0dcfab92310790 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Tue, 16 Mar 2021 17:06:25 -0400
Subject: [PATCH 1160/2400] cmd: move experiment flags into objabi.Experiment

This moves all remaining GOEXPERIMENT flags into the objabi.Experiment
struct, drops the "_enabled" from their name, and makes them all bool
typed.

We also drop DebugFlags.Fieldtrack because the previous CL shifted the
one test that used it to use GOEXPERIMENT instead.

Change-Id: I3406fe62b1c300bb4caeaffa6ca5ce56a70497fe
Reviewed-on: https://go-review.googlesource.com/c/go/+/302389
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/base/debug.go     |  9 +------
 src/cmd/compile/internal/base/flag.go      |  2 +-
 src/cmd/compile/internal/dwarfgen/dwarf.go |  2 +-
 src/cmd/compile/internal/noder/lex.go      |  2 +-
 src/cmd/compile/internal/ssa/compile.go    |  2 +-
 src/cmd/compile/internal/ssa/regalloc.go   |  2 +-
 src/cmd/compile/internal/ssagen/pgen.go    |  4 ++--
 src/cmd/compile/internal/walk/expr.go      |  2 +-
 src/cmd/go/internal/work/gc.go             |  2 +-
 src/cmd/internal/objabi/util.go            | 28 ++++++++++++----------
 src/cmd/link/internal/ld/deadcode.go       |  4 ++--
 src/cmd/link/internal/ld/main.go           |  2 +-
 src/runtime/runtime2.go                    |  2 +-
 13 files changed, 29 insertions(+), 34 deletions(-)

diff --git a/src/cmd/compile/internal/base/debug.go b/src/cmd/compile/internal/base/debug.go
index b9fa3d882e..7590dc1bfa 100644
--- a/src/cmd/compile/internal/base/debug.go
+++ b/src/cmd/compile/internal/base/debug.go
@@ -13,14 +13,10 @@ import (
 	"reflect"
 	"strconv"
 	"strings"
-
-	"cmd/internal/objabi"
 )
 
 // Debug holds the parsed debugging configuration values.
-var Debug = DebugFlags{
-	Fieldtrack: &objabi.Fieldtrack_enabled,
-}
+var Debug DebugFlags
 
 // DebugFlags defines the debugging configuration values (see var Debug).
 // Each struct field is a different value, named for the lower-case of the field name.
@@ -38,7 +34,6 @@ type DebugFlags struct {
 	DumpPtrs             int    `help:"show Node pointers values in dump output"`
 	DwarfInl             int    `help:"print information about DWARF inlined function creation"`
 	Export               int    `help:"print export data"`
-	Fieldtrack           *int   `help:"enable field tracking"`
 	GCProg               int    `help:"print dump of GC programs"`
 	InlFuncsWithClosures int    `help:"allow functions with closures to be inlined"`
 	Libfuzzer            int    `help:"enable coverage instrumentation for libfuzzer"`
@@ -86,8 +81,6 @@ func init() {
 			panic(fmt.Sprintf("base.Debug.%s has invalid type %v (must be int or string)", f.Name, f.Type))
 		case *int, *string:
 			// ok
-		case **int:
-			ptr = *ptr.(**int) // record the *int itself
 		}
 		debugTab = append(debugTab, debugField{name, help, ptr})
 	}
diff --git a/src/cmd/compile/internal/base/flag.go b/src/cmd/compile/internal/base/flag.go
index 959fededa9..751ab1b5c7 100644
--- a/src/cmd/compile/internal/base/flag.go
+++ b/src/cmd/compile/internal/base/flag.go
@@ -339,7 +339,7 @@ func concurrentBackendAllowed() bool {
 		return false
 	}
 	// TODO: Test and delete this condition.
-	if objabi.Fieldtrack_enabled != 0 {
+	if objabi.Experiment.FieldTrack {
 		return false
 	}
 	// TODO: fix races and enable the following flags
diff --git a/src/cmd/compile/internal/dwarfgen/dwarf.go b/src/cmd/compile/internal/dwarfgen/dwarf.go
index 53752097ed..7b5863bbc6 100644
--- a/src/cmd/compile/internal/dwarfgen/dwarf.go
+++ b/src/cmd/compile/internal/dwarfgen/dwarf.go
@@ -278,7 +278,7 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 		if base.Ctxt.FixedFrameSize() == 0 {
 			offs -= int64(types.PtrSize)
 		}
-		if objabi.Framepointer_enabled {
+		if objabi.FramePointerEnabled {
 			offs -= int64(types.PtrSize)
 		}
 
diff --git a/src/cmd/compile/internal/noder/lex.go b/src/cmd/compile/internal/noder/lex.go
index 36cfb9bc23..60b724d154 100644
--- a/src/cmd/compile/internal/noder/lex.go
+++ b/src/cmd/compile/internal/noder/lex.go
@@ -44,7 +44,7 @@ func pragmaFlag(verb string) ir.PragmaFlag {
 	case "go:build":
 		return ir.GoBuildPragma
 	case "go:nointerface":
-		if objabi.Fieldtrack_enabled != 0 {
+		if objabi.Experiment.FieldTrack {
 			return ir.Nointerface
 		}
 	case "go:noescape":
diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go
index c267274366..b1bcd4566e 100644
--- a/src/cmd/compile/internal/ssa/compile.go
+++ b/src/cmd/compile/internal/ssa/compile.go
@@ -454,7 +454,7 @@ var passes = [...]pass{
 	{name: "dse", fn: dse},
 	{name: "writebarrier", fn: writebarrier, required: true}, // expand write barrier ops
 	{name: "insert resched checks", fn: insertLoopReschedChecks,
-		disabled: objabi.Preemptibleloops_enabled == 0}, // insert resched checks in loops.
+		disabled: !objabi.Experiment.PreemptibleLoops}, // insert resched checks in loops.
 	{name: "lower", fn: lower, required: true},
 	{name: "addressing modes", fn: addressingModes, required: false},
 	{name: "lowered deadcode for cse", fn: deadcode}, // deadcode immediately before CSE avoids CSE making dead values live again
diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go
index 18908681df..42df8387e4 100644
--- a/src/cmd/compile/internal/ssa/regalloc.go
+++ b/src/cmd/compile/internal/ssa/regalloc.go
@@ -594,7 +594,7 @@ func (s *regAllocState) init(f *Func) {
 	if s.f.Config.hasGReg {
 		s.allocatable &^= 1 << s.GReg
 	}
-	if objabi.Framepointer_enabled && s.f.Config.FPReg >= 0 {
+	if objabi.FramePointerEnabled && s.f.Config.FPReg >= 0 {
 		s.allocatable &^= 1 << uint(s.f.Config.FPReg)
 	}
 	if s.f.Config.LinkReg != -1 {
diff --git a/src/cmd/compile/internal/ssagen/pgen.go b/src/cmd/compile/internal/ssagen/pgen.go
index 0088f10fa8..0cb506fb74 100644
--- a/src/cmd/compile/internal/ssagen/pgen.go
+++ b/src/cmd/compile/internal/ssagen/pgen.go
@@ -202,7 +202,7 @@ func StackOffset(slot ssa.LocalSlot) int32 {
 		if base.Ctxt.FixedFrameSize() == 0 {
 			off -= int64(types.PtrSize)
 		}
-		if objabi.Framepointer_enabled {
+		if objabi.FramePointerEnabled {
 			off -= int64(types.PtrSize)
 		}
 	}
@@ -215,7 +215,7 @@ func fieldtrack(fnsym *obj.LSym, tracked map[*obj.LSym]struct{}) {
 	if fnsym == nil {
 		return
 	}
-	if objabi.Fieldtrack_enabled == 0 || len(tracked) == 0 {
+	if !objabi.Experiment.FieldTrack || len(tracked) == 0 {
 		return
 	}
 
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 1d90029298..4cc5b65d3e 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -931,7 +931,7 @@ func usemethod(n *ir.CallExpr) {
 }
 
 func usefield(n *ir.SelectorExpr) {
-	if objabi.Fieldtrack_enabled == 0 {
+	if !objabi.Experiment.FieldTrack {
 		return
 	}
 
diff --git a/src/cmd/go/internal/work/gc.go b/src/cmd/go/internal/work/gc.go
index 0fb6156c5a..95fffeabd6 100644
--- a/src/cmd/go/internal/work/gc.go
+++ b/src/cmd/go/internal/work/gc.go
@@ -223,7 +223,7 @@ CheckFlags:
 	}
 
 	// TODO: Test and delete these conditions.
-	if objabi.Fieldtrack_enabled != 0 || objabi.Preemptibleloops_enabled != 0 {
+	if objabi.Experiment.FieldTrack || objabi.Experiment.PreemptibleLoops {
 		canDashC = false
 	}
 
diff --git a/src/cmd/internal/objabi/util.go b/src/cmd/internal/objabi/util.go
index 548e9d0a30..9fbe6490e0 100644
--- a/src/cmd/internal/objabi/util.go
+++ b/src/cmd/internal/objabi/util.go
@@ -174,8 +174,14 @@ func init() {
 	GOEXPERIMENT = expList()
 }
 
+// FramePointerEnabled enables the use of platform conventions for
+// saving frame pointers.
+//
+// This used to be an experiment, but now it's always enabled on
+// platforms that support it.
+//
 // Note: must agree with runtime.framepointer_enabled.
-var Framepointer_enabled = GOARCH == "amd64" || GOARCH == "arm64"
+var FramePointerEnabled = GOARCH == "amd64" || GOARCH == "arm64"
 
 func addexp(s string) {
 	// Could do general integer parsing here, but the runtime.haveexperiment doesn't yet.
@@ -203,18 +209,14 @@ func addexp(s string) {
 	os.Exit(2)
 }
 
-var (
-	Fieldtrack_enabled        int
-	Preemptibleloops_enabled  int
-	Staticlockranking_enabled int
-)
-
 // Experiment contains flags for GOEXPERIMENTs.
-//
-// TODO(austin): Move the package-level experiment flags into this.
-var Experiment ExpFlags
+var Experiment = ExpFlags{}
 
 type ExpFlags struct {
+	FieldTrack        bool
+	PreemptibleLoops  bool
+	StaticLockRanking bool
+
 	// regabi is split into several sub-experiments that can be
 	// enabled individually. GOEXPERIMENT=regabi implies the
 	// subset that are currently "working". Not all combinations work.
@@ -250,9 +252,9 @@ var exper = []struct {
 	name string
 	val  interface{} // Must be *int or *bool
 }{
-	{"fieldtrack", &Fieldtrack_enabled},
-	{"preemptibleloops", &Preemptibleloops_enabled},
-	{"staticlockranking", &Staticlockranking_enabled},
+	{"fieldtrack", &Experiment.FieldTrack},
+	{"preemptibleloops", &Experiment.PreemptibleLoops},
+	{"staticlockranking", &Experiment.StaticLockRanking},
 	{"regabi", &Experiment.regabi},
 	{"regabiwrappers", &Experiment.RegabiWrappers},
 	{"regabig", &Experiment.RegabiG},
diff --git a/src/cmd/link/internal/ld/deadcode.go b/src/cmd/link/internal/ld/deadcode.go
index a52652566b..33468b429c 100644
--- a/src/cmd/link/internal/ld/deadcode.go
+++ b/src/cmd/link/internal/ld/deadcode.go
@@ -32,7 +32,7 @@ type deadcodePass struct {
 func (d *deadcodePass) init() {
 	d.ldr.InitReachable()
 	d.ifaceMethod = make(map[methodsig]bool)
-	if objabi.Fieldtrack_enabled != 0 {
+	if objabi.Experiment.FieldTrack {
 		d.ldr.Reachparent = make([]loader.Sym, d.ldr.NSym())
 	}
 	d.dynlink = d.ctxt.DynlinkingGo()
@@ -255,7 +255,7 @@ func (d *deadcodePass) mark(symIdx, parent loader.Sym) {
 	if symIdx != 0 && !d.ldr.AttrReachable(symIdx) {
 		d.wq.push(symIdx)
 		d.ldr.SetAttrReachable(symIdx, true)
-		if objabi.Fieldtrack_enabled != 0 && d.ldr.Reachparent[symIdx] == 0 {
+		if objabi.Experiment.FieldTrack && d.ldr.Reachparent[symIdx] == 0 {
 			d.ldr.Reachparent[symIdx] = parent
 		}
 		if *flagDumpDep {
diff --git a/src/cmd/link/internal/ld/main.go b/src/cmd/link/internal/ld/main.go
index 3c5355df9c..78df50ee2d 100644
--- a/src/cmd/link/internal/ld/main.go
+++ b/src/cmd/link/internal/ld/main.go
@@ -251,7 +251,7 @@ func Main(arch *sys.Arch, theArch Arch) {
 
 	bench.Start("dostrdata")
 	ctxt.dostrdata()
-	if objabi.Fieldtrack_enabled != 0 {
+	if objabi.Experiment.FieldTrack {
 		bench.Start("fieldtrack")
 		fieldtrack(ctxt.Arch, ctxt.loader)
 	}
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index f5318e6f11..e5f948ec86 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -1105,5 +1105,5 @@ var (
 	isarchive bool // -buildmode=c-archive
 )
 
-// Must agree with cmd/internal/objabi.Framepointer_enabled.
+// Must agree with cmd/internal/objabi.Experiment.FramePointer.
 const framepointer_enabled = GOARCH == "amd64" || GOARCH == "arm64"
-- 
GitLab


From 095ba225973152734b0722e7c5758accb2639c15 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Wed, 17 Mar 2021 12:22:58 -0400
Subject: [PATCH 1161/2400] cmd/internal/objabi,runtime: simplify
 sys.GOEXPERIMENT parsing

Previously, the runtime had to understand the full syntax of the
GOEXPERIMENT environment variable. Now, sys.GOEXPERIMENT is the
pre-processed experiment list produced by objabi, so we can simplify
the runtime parser.

Change-Id: I0d113a4347dde50a35b8b1f2b0110c88fe802921
Reviewed-on: https://go-review.googlesource.com/c/go/+/303049
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/internal/objabi/util.go | 3 ++-
 src/runtime/proc.go             | 6 +++---
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/cmd/internal/objabi/util.go b/src/cmd/internal/objabi/util.go
index 9fbe6490e0..2a33f0d84a 100644
--- a/src/cmd/internal/objabi/util.go
+++ b/src/cmd/internal/objabi/util.go
@@ -171,6 +171,7 @@ func init() {
 	}
 
 	// Set GOEXPERIMENT to the parsed and canonicalized set of experiments.
+	// This format must be parseable by runtime.haveexperiment.
 	GOEXPERIMENT = expList()
 }
 
@@ -184,7 +185,7 @@ func init() {
 var FramePointerEnabled = GOARCH == "amd64" || GOARCH == "arm64"
 
 func addexp(s string) {
-	// Could do general integer parsing here, but the runtime.haveexperiment doesn't yet.
+	// We could do general integer parsing here, but there's no need yet.
 	v, vb := 1, true
 	name := s
 	if len(name) > 2 && name[:2] == "no" {
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 9ebfe70883..a666f86abc 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -6027,6 +6027,9 @@ func setMaxThreads(in int) (out int) {
 }
 
 func haveexperiment(name string) bool {
+	// GOEXPERIMENT is a comma-separated list of enabled
+	// experiments. It's not the raw environment variable, but a
+	// pre-processed list from cmd/internal/objabi.
 	x := sys.GOEXPERIMENT
 	for x != "" {
 		xname := ""
@@ -6039,9 +6042,6 @@ func haveexperiment(name string) bool {
 		if xname == name {
 			return true
 		}
-		if len(xname) > 2 && xname[:2] == "no" && xname[2:] == name {
-			return false
-		}
 	}
 	return false
 }
-- 
GitLab


From 90b1ed1602ad8db08a5b1bde4aae5f8569b21915 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Thu, 18 Mar 2021 11:56:46 -0700
Subject: [PATCH 1162/2400] cmd/compile: get untyped constants working in
 generic functions

types2 will give us a constant with a type T, if an untyped constant is
used with another operand of type T (in a provably correct way). When we
substitute in the type args during stenciling, we now know the real type
of the constant. We may then need to change the BasicLit.val to be the
correct type (e.g. convert an int64Val constant to a floatVal constant).
Otherwise, later parts of the compiler will be confused.

Updated tests list.go and double.go with uses of untyped constants.

Change-Id: I9966bbb0dea3a7de1c5a6420f8ad8af9ca84a33e
Reviewed-on: https://go-review.googlesource.com/c/go/+/303089
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/stencil.go | 26 ++++++--
 test/typeparam/double.go                  | 22 +++++++
 test/typeparam/list.go                    | 78 +++++++++++++++++------
 3 files changed, 101 insertions(+), 25 deletions(-)

diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 55aee9b6ff..51ef46c7e7 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -367,7 +367,24 @@ func (subst *subster) node(n ir.Node) ir.Node {
 		}
 		ir.EditChildren(m, edit)
 
-		if x.Op() == ir.OXDOT {
+		switch x.Op() {
+		case ir.OLITERAL:
+			t := m.Type()
+			if t != x.Type() {
+				// types2 will give us a constant with a type T,
+				// if an untyped constant is used with another
+				// operand of type T (in a provably correct way).
+				// When we substitute in the type args during
+				// stenciling, we now know the real type of the
+				// constant. We may then need to change the
+				// BasicLit.val to be the correct type (e.g.
+				// convert an int64Val constant to a floatVal
+				// constant).
+				m.SetType(types.UntypedInt) // use any untyped type for DefaultLit to work
+				m = typecheck.DefaultLit(m, t)
+			}
+
+		case ir.OXDOT:
 			// A method value/call via a type param will have been left as an
 			// OXDOT. When we see this during stenciling, finish the
 			// typechecking, now that we have the instantiated receiver type.
@@ -377,8 +394,8 @@ func (subst *subster) node(n ir.Node) ir.Node {
 			m.SetTypecheck(0)
 			// m will transform to an OCALLPART
 			typecheck.Expr(m)
-		}
-		if x.Op() == ir.OCALL {
+
+		case ir.OCALL:
 			call := m.(*ir.CallExpr)
 			if call.X.Op() == ir.OTYPE {
 				// Do typechecking on a conversion, now that we
@@ -419,9 +436,8 @@ func (subst *subster) node(n ir.Node) ir.Node {
 				// instantiation to be called.
 				base.FatalfAt(call.Pos(), "Expecting OCALLPART or OTYPE or OFUNCINST or builtin with CALL")
 			}
-		}
 
-		if x.Op() == ir.OCLOSURE {
+		case ir.OCLOSURE:
 			x := x.(*ir.ClosureExpr)
 			// Need to save/duplicate x.Func.Nname,
 			// x.Func.Nname.Ntype, x.Func.Dcl, x.Func.ClosureVars, and
diff --git a/test/typeparam/double.go b/test/typeparam/double.go
index 1f7a26c7f4..ce78ec9748 100644
--- a/test/typeparam/double.go
+++ b/test/typeparam/double.go
@@ -16,6 +16,7 @@ type Number interface {
 }
 
 type MySlice []int
+type MyFloatSlice []float64
 
 type _SliceOf[E any] interface {
 	type []E
@@ -29,6 +30,15 @@ func _DoubleElems[S _SliceOf[E], E Number](s S) S {
 	return r
 }
 
+// Test use of untyped constant in an expression with a generically-typed parameter
+func _DoubleElems2[S _SliceOf[E], E Number](s S) S {
+	r := make(S, len(s))
+	for i, v := range s {
+		r[i] = v * 2
+	}
+	return r
+}
+
 func main() {
 	arg := MySlice{1, 2, 3}
 	want := MySlice{2, 4, 6}
@@ -47,4 +57,16 @@ func main() {
 	if !reflect.DeepEqual(got, want) {
                 panic(fmt.Sprintf("got %s, want %s", got, want))
 	}
+
+	farg := MyFloatSlice{1.2, 2.0, 3.5}
+	fwant := MyFloatSlice{2.4, 4.0, 7.0}
+	fgot := _DoubleElems(farg)
+	if !reflect.DeepEqual(fgot, fwant) {
+                panic(fmt.Sprintf("got %s, want %s", fgot, fwant))
+	}
+
+	fgot = _DoubleElems2(farg)
+	if !reflect.DeepEqual(fgot, fwant) {
+                panic(fmt.Sprintf("got %s, want %s", fgot, fwant))
+	}
 }
diff --git a/test/typeparam/list.go b/test/typeparam/list.go
index 64230060de..579078f02f 100644
--- a/test/typeparam/list.go
+++ b/test/typeparam/list.go
@@ -17,13 +17,13 @@ type Ordered interface {
                 string
 }
 
-// List is a linked list of ordered values of type T.
-type list[T Ordered] struct {
-	next *list[T]
+// _List is a linked list of ordered values of type T.
+type _List[T Ordered] struct {
+	next *_List[T]
 	val  T
 }
 
-func (l *list[T]) largest() T {
+func (l *_List[T]) Largest() T {
 	var max T
 	for p := l; p != nil; p = p.next {
 		if p.val > max {
@@ -33,33 +33,71 @@ func (l *list[T]) largest() T {
 	return max
 }
 
+type OrderedNum interface {
+        type int, int8, int16, int32, int64,
+                uint, uint8, uint16, uint32, uint64, uintptr,
+                float32, float64
+}
+
+// _ListNum is a linked _List of ordered numeric values of type T.
+type _ListNum[T OrderedNum] struct {
+	next *_ListNum[T]
+	val  T
+}
+
+const Clip = 5
+
+// clippedLargest returns the largest in the list of OrderNums, but a max of 5.
+// Test use of untyped constant in an expression with a generically-typed parameter
+func (l *_ListNum[T]) ClippedLargest() T {
+	var max T
+	for p := l; p != nil; p = p.next {
+		if p.val > max && p.val < Clip {
+			max = p.val
+		}
+	}
+	return max
+}
 
 func main() {
-	i3 := &list[int]{nil, 1}
-	i2 := &list[int]{i3, 3}
-	i1 := &list[int]{i2, 2}
-	if got, want := i1.largest(), 3; got != want {
+	i3 := &_List[int]{nil, 1}
+	i2 := &_List[int]{i3, 3}
+	i1 := &_List[int]{i2, 2}
+	if got, want := i1.Largest(), 3; got != want {
                 panic(fmt.Sprintf("got %d, want %d", got, want))
 	}
 
-	b3 := &list[byte]{nil, byte(1)}
-	b2 := &list[byte]{b3, byte(3)}
-	b1 := &list[byte]{b2, byte(2)}
-	if got, want := b1.largest(), byte(3); got != want {
+	b3 := &_List[byte]{nil, byte(1)}
+	b2 := &_List[byte]{b3, byte(3)}
+	b1 := &_List[byte]{b2, byte(2)}
+	if got, want := b1.Largest(), byte(3); got != want {
                 panic(fmt.Sprintf("got %d, want %d", got, want))
 	}
 
-	f3 := &list[float64]{nil, 13.5}
-	f2 := &list[float64]{f3, 1.2}
-	f1 := &list[float64]{f2, 4.5}
-	if got, want := f1.largest(), 13.5; got != want {
+	f3 := &_List[float64]{nil, 13.5}
+	f2 := &_List[float64]{f3, 1.2}
+	f1 := &_List[float64]{f2, 4.5}
+	if got, want := f1.Largest(), 13.5; got != want {
                 panic(fmt.Sprintf("got %f, want %f", got, want))
 	}
 
-	s3 := &list[string]{nil, "dd"}
-	s2 := &list[string]{s3, "aa"}
-	s1 := &list[string]{s2, "bb"}
-	if got, want := s1.largest(), "dd"; got != want {
+	s3 := &_List[string]{nil, "dd"}
+	s2 := &_List[string]{s3, "aa"}
+	s1 := &_List[string]{s2, "bb"}
+	if got, want := s1.Largest(), "dd"; got != want {
                 panic(fmt.Sprintf("got %s, want %s", got, want))
 	}
+
+	j3 := &_ListNum[int]{nil, 1}
+	j2 := &_ListNum[int]{j3, 32}
+	j1 := &_ListNum[int]{j2, 2}
+	if got, want := j1.ClippedLargest(), 2; got != want {
+                panic(fmt.Sprintf("got %d, want %d", got, want))
+	}
+	g3 := &_ListNum[float64]{nil, 13.5}
+	g2 := &_ListNum[float64]{g3, 1.2}
+	g1 := &_ListNum[float64]{g2, 4.5}
+	if got, want := g1.ClippedLargest(), 4.5; got != want {
+                panic(fmt.Sprintf("got %f, want %f", got, want))
+	}
 }
-- 
GitLab


From dcc96e4b9403a3a1e135b81d5f556a72a04a2add Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Wed, 17 Mar 2021 18:02:26 -0700
Subject: [PATCH 1163/2400] io/ioutil: use correct Go version in redirection
 comments

Change-Id: I282f428137ca3360a58167c94e26f3dfdf59fb63
Reviewed-on: https://go-review.googlesource.com/c/go/+/302756
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/io/ioutil/tempfile.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/io/ioutil/tempfile.go b/src/io/ioutil/tempfile.go
index 4b272e5a5d..c43db2c080 100644
--- a/src/io/ioutil/tempfile.go
+++ b/src/io/ioutil/tempfile.go
@@ -20,7 +20,7 @@ import (
 // to find the pathname of the file. It is the caller's responsibility
 // to remove the file when no longer needed.
 //
-// As of Go 1.16, this function simply calls os.CreateTemp.
+// As of Go 1.17, this function simply calls os.CreateTemp.
 func TempFile(dir, pattern string) (f *os.File, err error) {
 	return os.CreateTemp(dir, pattern)
 }
@@ -35,7 +35,7 @@ func TempFile(dir, pattern string) (f *os.File, err error) {
 // will not choose the same directory. It is the caller's responsibility
 // to remove the directory when no longer needed.
 //
-// As of Go 1.16, this function simply calls os.MkdirTemp.
+// As of Go 1.17, this function simply calls os.MkdirTemp.
 func TempDir(dir, pattern string) (name string, err error) {
 	return os.MkdirTemp(dir, pattern)
 }
-- 
GitLab


From 67048432026062a98a3937a865aeb05a398148c5 Mon Sep 17 00:00:00 2001
From: Tao Qingyun <qingyunha@gmail.com>
Date: Thu, 18 Mar 2021 00:10:38 +0000
Subject: [PATCH 1164/2400] testing: update helperNames just before checking it

parent's helperNames has not been set when frameSkip called, moving
helperNames initilazing to frameSkip.

Fixes #44887

Change-Id: I5107c5951033e5e47d1ac441eac3ba5344a7bdc0
GitHub-Last-Rev: 44b90b2e2eeca8e2bb4a2084ec6fdd279c88f76d
GitHub-Pull-Request: golang/go#45071
Reviewed-on: https://go-review.googlesource.com/c/go/+/302469
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/testing/helper_test.go | 32 ++++++++++++++++++++++++++++++++
 src/testing/testing.go     | 15 +++++++--------
 2 files changed, 39 insertions(+), 8 deletions(-)

diff --git a/src/testing/helper_test.go b/src/testing/helper_test.go
index 8858196cf0..b27fd62ee8 100644
--- a/src/testing/helper_test.go
+++ b/src/testing/helper_test.go
@@ -71,6 +71,38 @@ func TestTBHelperParallel(t *T) {
 	}
 }
 
+func TestTBHelperLineNumer(t *T) {
+	var buf bytes.Buffer
+	ctx := newTestContext(1, newMatcher(regexp.MatchString, "", ""))
+	t1 := &T{
+		common: common{
+			signal: make(chan bool),
+			w:      &buf,
+		},
+		context: ctx,
+	}
+	t1.Run("Test", func(t *T) {
+		helperA := func(t *T) {
+			t.Helper()
+			t.Run("subtest", func(t *T) {
+				t.Helper()
+				t.Fatal("fatal error message")
+			})
+		}
+		helperA(t)
+	})
+
+	want := "helper_test.go:92: fatal error message"
+	got := ""
+	lines := strings.Split(strings.TrimSpace(buf.String()), "\n")
+	if len(lines) > 0 {
+		got = strings.TrimSpace(lines[len(lines)-1])
+	}
+	if got != want {
+		t.Errorf("got output:\n\n%v\nwant:\n\n%v", got, want)
+	}
+}
+
 type noopWriter int
 
 func (nw *noopWriter) Write(b []byte) (int, error) { return len(b), nil }
diff --git a/src/testing/testing.go b/src/testing/testing.go
index fafc67c5b7..383e56a20e 100644
--- a/src/testing/testing.go
+++ b/src/testing/testing.go
@@ -509,6 +509,13 @@ func (c *common) frameSkip(skip int) runtime.Frame {
 			}
 			return prevFrame
 		}
+		// If more helper PCs have been added since we last did the conversion
+		if c.helperNames == nil {
+			c.helperNames = make(map[string]struct{})
+			for pc := range c.helperPCs {
+				c.helperNames[pcToName(pc)] = struct{}{}
+			}
+		}
 		if _, ok := c.helperNames[frame.Function]; !ok {
 			// Found a frame that wasn't inside a helper function.
 			return frame
@@ -521,14 +528,6 @@ func (c *common) frameSkip(skip int) runtime.Frame {
 // and inserts the final newline if needed and indentation spaces for formatting.
 // This function must be called with c.mu held.
 func (c *common) decorate(s string, skip int) string {
-	// If more helper PCs have been added since we last did the conversion
-	if c.helperNames == nil {
-		c.helperNames = make(map[string]struct{})
-		for pc := range c.helperPCs {
-			c.helperNames[pcToName(pc)] = struct{}{}
-		}
-	}
-
 	frame := c.frameSkip(skip)
 	file := frame.File
 	line := frame.Line
-- 
GitLab


From 9136d958ab258bc4f128c8582ab713c482ec33ed Mon Sep 17 00:00:00 2001
From: fanzha02 <fannie.zhang@arm.com>
Date: Fri, 4 Dec 2020 14:02:55 +0800
Subject: [PATCH 1165/2400] cmd/asm: complete the support for VDUP on arm64

"VMOV Vn.<T>[index], Vn" is equivalent to "VDUP Vn.<T>[index], Vn", and
the latter has a higher priority in the disassembler than the former.
But the assembler doesn't support to encode this combination of VDUP,
this leads to an inconsistency between assembler and disassembler.

For example, if we assemble "VMOV V20.S[0], V20" to hex then decode it,
we'll get "VDUP V20.S[0], V20".

  VMOV V20.S[0], V20 -> 9406045e -> VDUP V20.S[0], V20 -> error

But we cannot assemble this VDUP again.

Similar reason for "VDUP Rn, Vd.<T>". This CL completes the support for
VDUP.

This patch is a copy of CL 276092. Co-authored-by: JunchenLi
<junchen.li@arm.com>

Change-Id: I8f8d86cf1911d5b16bb40d189f1dc34b24416aaf
Reviewed-on: https://go-review.googlesource.com/c/go/+/302929
Trust: fannie zhang <Fannie.Zhang@arm.com>
Run-TryBot: fannie zhang <Fannie.Zhang@arm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/asm/internal/asm/testdata/arm64.s    |  3 +++
 src/cmd/asm/internal/asm/testdata/arm64enc.s |  2 ++
 src/cmd/internal/obj/arm64/asm7.go           | 10 ++++++----
 3 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/src/cmd/asm/internal/asm/testdata/arm64.s b/src/cmd/asm/internal/asm/testdata/arm64.s
index d859171103..1146c1a789 100644
--- a/src/cmd/asm/internal/asm/testdata/arm64.s
+++ b/src/cmd/asm/internal/asm/testdata/arm64.s
@@ -596,9 +596,12 @@ TEXT	foo(SB), DUPOK|NOSPLIT, $-8
 	VMOV	R20, V1.S[0]          // 811e044e
 	VMOV	R20, V1.S[1]          // 811e0c4e
 	VMOV	R1, V9.H4             // 290c020e
+	VDUP	R1, V9.H4             // 290c020e
 	VMOV	R22, V11.D2           // cb0e084e
+	VDUP	R22, V11.D2           // cb0e084e
 	VMOV	V2.B16, V4.B16        // 441ca24e
 	VMOV	V20.S[0], V20         // 9406045e
+	VDUP	V20.S[0], V20         // 9406045e
 	VMOV	V12.D[0], V12.D[1]    // 8c05186e
 	VMOV	V10.S[0], V12.S[1]    // 4c050c6e
 	VMOV	V9.H[0], V12.H[1]     // 2c05066e
diff --git a/src/cmd/asm/internal/asm/testdata/arm64enc.s b/src/cmd/asm/internal/asm/testdata/arm64enc.s
index f71f7b0484..a29862822d 100644
--- a/src/cmd/asm/internal/asm/testdata/arm64enc.s
+++ b/src/cmd/asm/internal/asm/testdata/arm64enc.s
@@ -669,6 +669,7 @@ TEXT asmtest(SB),DUPOK|NOSPLIT,$-8
    VCMEQ V24.S4, V13.S4, V12.S4                                // ac8db86e
    VCNT V13.B8, V11.B8                                         // ab59200e
    VMOV V31.B[15], V18                                         // f2071f5e
+   VDUP V31.B[15], V18                                         // f2071f5e
    VDUP V31.B[13], V20.B16                                     // f4071b4e
    VEOR V4.B8, V18.B8, V7.B8                                   // 471e242e
    VEXT $4, V2.B8, V1.B8, V3.B8                                // 2320022e
@@ -700,6 +701,7 @@ TEXT asmtest(SB),DUPOK|NOSPLIT,$-8
    //TODO FMOVS.W 71(R29), F28                                 // bc7f44bc
    FMOVS 6160(R4), F23                                         // 971058bd
    VMOV V18.B[10], V27                                         // 5b06155e
+   VDUP V18.B[10], V27                                         // 5b06155e
    VMOV V12.B[2], V28.B[12]                                    // 9c15196e
    VMOV R30, V4.B[13]                                          // c41f1b4e
    VMOV V2.B16, V4.B16                                         // 441ca24e
diff --git a/src/cmd/internal/obj/arm64/asm7.go b/src/cmd/internal/obj/arm64/asm7.go
index 275799aad3..20f1843951 100644
--- a/src/cmd/internal/obj/arm64/asm7.go
+++ b/src/cmd/internal/obj/arm64/asm7.go
@@ -501,6 +501,8 @@ var optab = []Optab{
 	{AVMOV, C_REG, C_NONE, C_NONE, C_ELEM, 78, 4, 0, 0, 0},
 	{AVMOV, C_ARNG, C_NONE, C_NONE, C_ARNG, 83, 4, 0, 0, 0},
 	{AVDUP, C_ELEM, C_NONE, C_NONE, C_ARNG, 79, 4, 0, 0, 0},
+	{AVDUP, C_ELEM, C_NONE, C_NONE, C_VREG, 80, 4, 0, 0, 0},
+	{AVDUP, C_REG, C_NONE, C_NONE, C_ARNG, 82, 4, 0, 0, 0},
 	{AVMOVI, C_ADDCON, C_NONE, C_NONE, C_ARNG, 86, 4, 0, 0, 0},
 	{AVFMLA, C_ARNG, C_ARNG, C_NONE, C_ARNG, 72, 4, 0, 0, 0},
 	{AVEXT, C_VCON, C_ARNG, C_ARNG, C_ARNG, 94, 4, 0, 0, 0},
@@ -4653,13 +4655,13 @@ func (c *ctxt7) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		o1 |= (uint32(Q&1) << 30) | (uint32(imm5&0x1f) << 16)
 		o1 |= (uint32(rf&31) << 5) | uint32(rt&31)
 
-	case 80: /* vmov V.<T>[index], Vn */
+	case 80: /* vmov/vdup V.<T>[index], Vn */
 		rf := int(p.From.Reg)
 		rt := int(p.To.Reg)
 		imm5 := 0
 		index := int(p.From.Index)
 		switch p.As {
-		case AVMOV:
+		case AVMOV, AVDUP:
 			o1 = 1<<30 | 15<<25 | 1<<10
 			switch (p.From.Reg >> 5) & 15 {
 			case ARNG_B:
@@ -4709,7 +4711,7 @@ func (c *ctxt7) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		o1 = c.maskOpvldvst(p, o1)
 		o1 |= uint32(r&31) << 5
 
-	case 82: /* vmov Rn, Vd.<T> */
+	case 82: /* vmov/vdup Rn, Vd.<T> */
 		rf := int(p.From.Reg)
 		rt := int(p.To.Reg)
 		o1 = 7<<25 | 3<<10
@@ -4737,7 +4739,7 @@ func (c *ctxt7) asmout(p *obj.Prog, o *Optab, out []uint32) {
 			Q = 1
 			imm5 = 2
 		default:
-			c.ctxt.Diag("invalid arrangement on VMOV Rn, Vd.<T>: %v\n", p)
+			c.ctxt.Diag("invalid arrangement: %v\n", p)
 		}
 		o1 |= (Q & 1 << 30) | (imm5 & 0x1f << 16)
 		o1 |= (uint32(rf&31) << 5) | uint32(rt&31)
-- 
GitLab


From ed3ae9a340e506d873e57444a8eb28cd06e933a2 Mon Sep 17 00:00:00 2001
From: Agniva De Sarker <agnivade@yahoo.co.in>
Date: Thu, 17 Dec 2020 12:43:19 +0530
Subject: [PATCH 1166/2400] cmd/doc: properly display interface methods
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Previously, we used to call doc.ToText to print each comment
in a comment group attached to an interface method. This broke any
preformatted code block attached to the comment, and displayed everything
aligned to a single column. Additionally, the name of the interface
also wasn't displayed which didn't show which interface
the method belonged to.

To fix this, we print the entire interface node using format.Node
which takes care of displaying the comments correctly, and we also
filter out the methods that don't match, so that the method can be
displayed as belonging to an interface.

As an example, previously it would show:

// Comment before exported method.
//
// // Code block showing how to use ExportedMethod
// func DoSomething() error {
// ExportedMethod()
// return nil
// }
func ExportedMethod()  // Comment on line with exported method.

Now, it shows:

type ExportedInterface interface {
	// Comment before exported method.
	//
	//	// Code block showing how to use ExportedMethod
	//	func DoSomething() error {
	//		ExportedMethod()
	//		return nil
	//	}
	ExportedMethod() // Comment on line with exported method.

}

Fixes #43188

Change-Id: I28099fe4aab35e08049b2616a3506240f57133cc
Reviewed-on: https://go-review.googlesource.com/c/go/+/279433
Trust: Agniva De Sarker <agniva.quicksilver@gmail.com>
Trust: Daniel Martí <mvdan@mvdan.cc>
Reviewed-by: Rob Pike <r@golang.org>
---
 src/cmd/doc/doc_test.go     |  7 +++----
 src/cmd/doc/pkg.go          | 28 +++++++++++++++-------------
 src/cmd/doc/testdata/pkg.go |  7 +++++++
 3 files changed, 25 insertions(+), 17 deletions(-)

diff --git a/src/cmd/doc/doc_test.go b/src/cmd/doc/doc_test.go
index 39530e3c2d..af7793133e 100644
--- a/src/cmd/doc/doc_test.go
+++ b/src/cmd/doc/doc_test.go
@@ -579,7 +579,7 @@ var tests = []test{
 		[]string{
 			`Comment about exported interface`, // Include comment.
 			`type ExportedInterface interface`, // Interface definition.
-			`Comment before exported method.*\n.*ExportedMethod\(\)` +
+			`Comment before exported method.\n.*//\n.*//	// Code block showing how to use ExportedMethod\n.*//	func DoSomething\(\) error {\n.*//		ExportedMethod\(\)\n.*//		return nil\n.*//	}\n.*//.*\n.*ExportedMethod\(\)` +
 				`.*Comment on line with exported method`,
 			`io.Reader.*Comment on line with embedded Reader`,
 			`error.*Comment on line with embedded error`,
@@ -599,8 +599,7 @@ var tests = []test{
 		[]string{
 			`Comment about exported interface`, // Include comment.
 			`type ExportedInterface interface`, // Interface definition.
-			`Comment before exported method.*\n.*ExportedMethod\(\)` +
-				`.*Comment on line with exported method`,
+			`Comment before exported method.\n.*//\n.*//	// Code block showing how to use ExportedMethod\n.*//	func DoSomething\(\) error {\n.*//		ExportedMethod\(\)\n.*//		return nil\n.*//	}\n.*//.*\n.*ExportedMethod\(\)` + `.*Comment on line with exported method`,
 			`unexportedMethod\(\).*Comment on line with unexported method`,
 			`io.Reader.*Comment on line with embedded Reader`,
 			`error.*Comment on line with embedded error`,
@@ -615,7 +614,7 @@ var tests = []test{
 		"interface method",
 		[]string{p, `ExportedInterface.ExportedMethod`},
 		[]string{
-			`Comment before exported method.*\n.*ExportedMethod\(\)` +
+			`Comment before exported method.\n.*//\n.*//	// Code block showing how to use ExportedMethod\n.*//	func DoSomething\(\) error {\n.*//		ExportedMethod\(\)\n.*//		return nil\n.*//	}\n.*//.*\n.*ExportedMethod\(\)` +
 				`.*Comment on line with exported method`,
 		},
 		[]string{
diff --git a/src/cmd/doc/pkg.go b/src/cmd/doc/pkg.go
index c2e06ebc8b..587f0bdc14 100644
--- a/src/cmd/doc/pkg.go
+++ b/src/cmd/doc/pkg.go
@@ -950,6 +950,9 @@ func (pkg *Package) printMethodDoc(symbol, method string) bool {
 			// Not an interface type.
 			continue
 		}
+
+		// Collect and print only the methods that match.
+		var methods []*ast.Field
 		for _, iMethod := range inter.Methods.List {
 			// This is an interface, so there can be only one name.
 			// TODO: Anonymous methods (embedding)
@@ -958,22 +961,21 @@ func (pkg *Package) printMethodDoc(symbol, method string) bool {
 			}
 			name := iMethod.Names[0].Name
 			if match(method, name) {
-				if iMethod.Doc != nil {
-					for _, comment := range iMethod.Doc.List {
-						doc.ToText(&pkg.buf, comment.Text, "", indent, indentedWidth)
-					}
-				}
-				s := pkg.oneLineNode(iMethod.Type)
-				// Hack: s starts "func" but there is no name present.
-				// We could instead build a FuncDecl but it's not worthwhile.
-				lineComment := ""
-				if iMethod.Comment != nil {
-					lineComment = fmt.Sprintf("  %s", iMethod.Comment.List[0].Text)
-				}
-				pkg.Printf("func %s%s%s\n", name, s[4:], lineComment)
+				methods = append(methods, iMethod)
 				found = true
 			}
 		}
+		if found {
+			pkg.Printf("type %s ", spec.Name)
+			inter.Methods.List, methods = methods, inter.Methods.List
+			err := format.Node(&pkg.buf, pkg.fs, inter)
+			if err != nil {
+				log.Fatal(err)
+			}
+			pkg.newlines(1)
+			// Restore the original methods.
+			inter.Methods.List = methods
+		}
 	}
 	return found
 }
diff --git a/src/cmd/doc/testdata/pkg.go b/src/cmd/doc/testdata/pkg.go
index d695bdf1c5..5ece832565 100644
--- a/src/cmd/doc/testdata/pkg.go
+++ b/src/cmd/doc/testdata/pkg.go
@@ -111,6 +111,13 @@ const unexportedTypedConstant ExportedType = 1 // In a separate section to test
 // Comment about exported interface.
 type ExportedInterface interface {
 	// Comment before exported method.
+	//
+	//	// Code block showing how to use ExportedMethod
+	//	func DoSomething() error {
+	//		ExportedMethod()
+	//		return nil
+	//	}
+	//
 	ExportedMethod()   // Comment on line with exported method.
 	unexportedMethod() // Comment on line with unexported method.
 	io.Reader          // Comment on line with embedded Reader.
-- 
GitLab


From 196b104bc172c8ba7e0565293722de319071ade3 Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Tue, 9 Mar 2021 16:55:03 -0600
Subject: [PATCH 1167/2400] cmd/internal/obj/ppc64: consolidate memory
 classifications

Several classifications exist only to help disambiguate an
implied register (i.e $0/R0 as the implied second register
argument when loading constants, or pseudo-registers used
exclusively by the assembler front-end).

The register determination is folded into getimpliedreg. The
classifications and their related optab entries are removed
or updated.

Change-Id: Iffb167aa9fa57fbc1a537c79fbdfb36cb38f9d95
Reviewed-on: https://go-review.googlesource.com/c/go/+/301789
Run-TryBot: Paul Murphy <murp@ibm.com>
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/internal/obj/ppc64/a.out.go   |   8 +-
 src/cmd/internal/obj/ppc64/anames9.go |   4 -
 src/cmd/internal/obj/ppc64/asm9.go    | 114 ++++++++------------------
 3 files changed, 35 insertions(+), 91 deletions(-)

diff --git a/src/cmd/internal/obj/ppc64/a.out.go b/src/cmd/internal/obj/ppc64/a.out.go
index 4c97302f83..59777803be 100644
--- a/src/cmd/internal/obj/ppc64/a.out.go
+++ b/src/cmd/internal/obj/ppc64/a.out.go
@@ -375,13 +375,9 @@ const (
 	C_SBRA
 	C_LBRA
 	C_LBRAPIC
-	C_SAUTO
-	C_LAUTO
-	C_SEXT
-	C_LEXT
 	C_ZOREG // conjecture: either (1) register + zeroed offset, or (2) "R0" implies zero or C_REG
-	C_SOREG // register + signed offset
-	C_LOREG
+	C_SOREG // D/DS form memory operation
+	C_LOREG // 32 bit addis + D/DS-form memory operation
 	C_FPSCR
 	C_MSR
 	C_XER
diff --git a/src/cmd/internal/obj/ppc64/anames9.go b/src/cmd/internal/obj/ppc64/anames9.go
index 4699a15d3b..7e93e6a15a 100644
--- a/src/cmd/internal/obj/ppc64/anames9.go
+++ b/src/cmd/internal/obj/ppc64/anames9.go
@@ -27,10 +27,6 @@ var cnames9 = []string{
 	"SBRA",
 	"LBRA",
 	"LBRAPIC",
-	"SAUTO",
-	"LAUTO",
-	"SEXT",
-	"LEXT",
 	"ZOREG",
 	"SOREG",
 	"LOREG",
diff --git a/src/cmd/internal/obj/ppc64/asm9.go b/src/cmd/internal/obj/ppc64/asm9.go
index 799df09687..1a97dda715 100644
--- a/src/cmd/internal/obj/ppc64/asm9.go
+++ b/src/cmd/internal/obj/ppc64/asm9.go
@@ -89,8 +89,8 @@ type Optab struct {
 // Likewise, each slice of optab is dynamically sorted using the ocmp Sort interface
 // to arrange entries to minimize text size of each opcode.
 var optab = []Optab{
-	{as: obj.ATEXT, a1: C_LEXT, a6: C_TEXTSIZE, type_: 0, size: 0},
-	{as: obj.ATEXT, a1: C_LEXT, a3: C_LCON, a6: C_TEXTSIZE, type_: 0, size: 0},
+	{as: obj.ATEXT, a1: C_LOREG, a6: C_TEXTSIZE, type_: 0, size: 0},
+	{as: obj.ATEXT, a1: C_LOREG, a3: C_LCON, a6: C_TEXTSIZE, type_: 0, size: 0},
 	{as: obj.ATEXT, a1: C_ADDR, a6: C_TEXTSIZE, type_: 0, size: 0},
 	{as: obj.ATEXT, a1: C_ADDR, a3: C_LCON, a6: C_TEXTSIZE, type_: 0, size: 0},
 	/* move register */
@@ -210,38 +210,22 @@ var optab = []Optab{
 	{as: AMOVHBR, a1: C_ZOREG, a6: C_REG, type_: 45, size: 4},
 
 	{as: AMOVB, a1: C_ADDR, a6: C_REG, type_: 76, size: 12},
-	{as: AMOVB, a1: C_LAUTO, a6: C_REG, type_: 37, size: 12},
-	{as: AMOVB, a1: C_LEXT, a6: C_REG, type_: 37, size: 12},
 	{as: AMOVB, a1: C_LOREG, a6: C_REG, type_: 37, size: 12},
 	{as: AMOVB, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
 	{as: AMOVB, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
-	{as: AMOVB, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8},
-	{as: AMOVB, a1: C_REG, a6: C_LEXT, type_: 35, size: 8},
 	{as: AMOVB, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
 	{as: AMOVB, a1: C_REG, a6: C_REG, type_: 12, size: 4},
-	{as: AMOVB, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4},
-	{as: AMOVB, a1: C_REG, a6: C_SEXT, type_: 7, size: 4},
 	{as: AMOVB, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
-	{as: AMOVB, a1: C_SAUTO, a6: C_REG, type_: 9, size: 8},
-	{as: AMOVB, a1: C_SEXT, a6: C_REG, type_: 9, size: 8},
 	{as: AMOVB, a1: C_SOREG, a6: C_REG, type_: 9, size: 8},
 	{as: AMOVB, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 9, size: 8},
 
 	{as: AMOVBZ, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
-	{as: AMOVBZ, a1: C_LAUTO, a6: C_REG, type_: 36, size: 8},
-	{as: AMOVBZ, a1: C_LEXT, a6: C_REG, type_: 36, size: 8},
 	{as: AMOVBZ, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
 	{as: AMOVBZ, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
 	{as: AMOVBZ, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
-	{as: AMOVBZ, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8},
-	{as: AMOVBZ, a1: C_REG, a6: C_LEXT, type_: 35, size: 8},
 	{as: AMOVBZ, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
 	{as: AMOVBZ, a1: C_REG, a6: C_REG, type_: 13, size: 4},
-	{as: AMOVBZ, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4},
-	{as: AMOVBZ, a1: C_REG, a6: C_SEXT, type_: 7, size: 4},
 	{as: AMOVBZ, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
-	{as: AMOVBZ, a1: C_SAUTO, a6: C_REG, type_: 8, size: 4},
-	{as: AMOVBZ, a1: C_SEXT, a6: C_REG, type_: 8, size: 4},
 	{as: AMOVBZ, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
 	{as: AMOVBZ, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4},
 
@@ -251,31 +235,23 @@ var optab = []Optab{
 	{as: AMOVD, a1: C_CTR, a6: C_REG, type_: 66, size: 4},
 	{as: AMOVD, a1: C_GOTADDR, a6: C_REG, type_: 81, size: 8},
 	{as: AMOVD, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
-	{as: AMOVD, a1: C_LAUTO, a6: C_REG, type_: 36, size: 8},
 	{as: AMOVD, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
 	{as: AMOVD, a1: C_LECON, a6: C_REG, type_: 26, size: 8},
-	{as: AMOVD, a1: C_LEXT, a6: C_REG, type_: 36, size: 8},
 	{as: AMOVD, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
 	{as: AMOVD, a1: C_LR, a6: C_REG, type_: 66, size: 4},
 	{as: AMOVD, a1: C_MSR, a6: C_REG, type_: 54, size: 4}, /* mfmsr */
 	{as: AMOVD, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
 	{as: AMOVD, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 	{as: AMOVD, a1: C_REG, a6: C_CTR, type_: 66, size: 4},
-	{as: AMOVD, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8},
-	{as: AMOVD, a1: C_REG, a6: C_LEXT, type_: 35, size: 8},
 	{as: AMOVD, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
 	{as: AMOVD, a1: C_REG, a6: C_LR, type_: 66, size: 4},
 	{as: AMOVD, a1: C_REG, a6: C_MSR, type_: 54, size: 4}, /* mtmsrd */
 	{as: AMOVD, a1: C_REG, a6: C_REG, type_: 1, size: 4},
-	{as: AMOVD, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4},
-	{as: AMOVD, a1: C_REG, a6: C_SEXT, type_: 7, size: 4},
 	{as: AMOVD, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVD, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
 	{as: AMOVD, a1: C_REG, a6: C_XER, type_: 66, size: 4},
 	{as: AMOVD, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVD, a1: C_SAUTO, a6: C_REG, type_: 8, size: 4},
 	{as: AMOVD, a1: C_SECON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVD, a1: C_SEXT, a6: C_REG, type_: 8, size: 4},
 	{as: AMOVD, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
 	{as: AMOVD, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
 	{as: AMOVD, a1: C_TLS_IE, a6: C_REG, type_: 80, size: 8},
@@ -290,28 +266,20 @@ var optab = []Optab{
 	{as: AMOVW, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4},
 	{as: AMOVW, a1: C_CREG, a6: C_REG, type_: 68, size: 4},
 	{as: AMOVW, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
-	{as: AMOVW, a1: C_LAUTO, a6: C_REG, type_: 36, size: 8},
 	{as: AMOVW, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
 	{as: AMOVW, a1: C_LECON, a6: C_REG, type_: 26, size: 8},
-	{as: AMOVW, a1: C_LEXT, a6: C_REG, type_: 36, size: 8},
 	{as: AMOVW, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
 	{as: AMOVW, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
 	{as: AMOVW, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 	{as: AMOVW, a1: C_REG, a6: C_CREG, type_: 69, size: 4},
 	{as: AMOVW, a1: C_REG, a6: C_CTR, type_: 66, size: 4},
-	{as: AMOVW, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8},
-	{as: AMOVW, a1: C_REG, a6: C_LEXT, type_: 35, size: 8},
 	{as: AMOVW, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
 	{as: AMOVW, a1: C_REG, a6: C_REG, type_: 12, size: 4},
-	{as: AMOVW, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4},
-	{as: AMOVW, a1: C_REG, a6: C_SEXT, type_: 7, size: 4},
 	{as: AMOVW, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVW, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
 	{as: AMOVW, a1: C_REG, a6: C_XER, type_: 66, size: 4},
 	{as: AMOVW, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVW, a1: C_SAUTO, a6: C_REG, type_: 8, size: 4},
 	{as: AMOVW, a1: C_SECON, a6: C_REG, type_: 3, size: 4}, /* TO DO: check */
-	{as: AMOVW, a1: C_SEXT, a6: C_REG, type_: 8, size: 4},
 	{as: AMOVW, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
 	{as: AMOVW, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
 	{as: AMOVW, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
@@ -323,29 +291,21 @@ var optab = []Optab{
 	{as: AMOVWZ, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4},
 	{as: AMOVWZ, a1: C_CREG, a6: C_REG, type_: 68, size: 4},
 	{as: AMOVWZ, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
-	{as: AMOVWZ, a1: C_LAUTO, a6: C_REG, type_: 36, size: 8},
 	{as: AMOVWZ, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
 	{as: AMOVWZ, a1: C_LECON, a6: C_REG, type_: 26, size: 8},
-	{as: AMOVWZ, a1: C_LEXT, a6: C_REG, type_: 36, size: 8},
 	{as: AMOVWZ, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
 	{as: AMOVWZ, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
 	{as: AMOVWZ, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 	{as: AMOVWZ, a1: C_REG, a6: C_CREG, type_: 69, size: 4},
 	{as: AMOVWZ, a1: C_REG, a6: C_CTR, type_: 66, size: 4},
-	{as: AMOVWZ, a1: C_REG, a6: C_LAUTO, type_: 35, size: 8},
-	{as: AMOVWZ, a1: C_REG, a6: C_LEXT, type_: 35, size: 8},
 	{as: AMOVWZ, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
 	{as: AMOVWZ, a1: C_REG, a6: C_MSR, type_: 54, size: 4}, /* mtmsr */
 	{as: AMOVWZ, a1: C_REG, a6: C_REG, type_: 13, size: 4},
-	{as: AMOVWZ, a1: C_REG, a6: C_SAUTO, type_: 7, size: 4},
-	{as: AMOVWZ, a1: C_REG, a6: C_SEXT, type_: 7, size: 4},
 	{as: AMOVWZ, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVWZ, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
 	{as: AMOVWZ, a1: C_REG, a6: C_XER, type_: 66, size: 4},
 	{as: AMOVWZ, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVWZ, a1: C_SAUTO, a6: C_REG, type_: 8, size: 4},
 	{as: AMOVWZ, a1: C_SECON, a6: C_REG, type_: 3, size: 4}, /* TO DO: check */
-	{as: AMOVWZ, a1: C_SEXT, a6: C_REG, type_: 8, size: 4},
 	{as: AMOVWZ, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
 	{as: AMOVWZ, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
 	{as: AMOVWZ, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
@@ -381,20 +341,12 @@ var optab = []Optab{
 	{as: ABC, a1: C_SCON, a2: C_REG, a6: C_CTR, type_: 18, size: 4},
 	{as: ABC, a6: C_ZOREG, type_: 15, size: 8},
 	{as: AFMOVD, a1: C_FREG, a6: C_FREG, type_: 33, size: 4},
-	{as: AFMOVD, a1: C_SEXT, a6: C_FREG, type_: 8, size: 4},
-	{as: AFMOVD, a1: C_SAUTO, a6: C_FREG, type_: 8, size: 4},
 	{as: AFMOVD, a1: C_SOREG, a6: C_FREG, type_: 8, size: 4},
-	{as: AFMOVD, a1: C_LEXT, a6: C_FREG, type_: 36, size: 8},
-	{as: AFMOVD, a1: C_LAUTO, a6: C_FREG, type_: 36, size: 8},
 	{as: AFMOVD, a1: C_LOREG, a6: C_FREG, type_: 36, size: 8},
 	{as: AFMOVD, a1: C_ZCON, a6: C_FREG, type_: 24, size: 4},
 	{as: AFMOVD, a1: C_ADDCON, a6: C_FREG, type_: 24, size: 8},
 	{as: AFMOVD, a1: C_ADDR, a6: C_FREG, type_: 75, size: 8},
-	{as: AFMOVD, a1: C_FREG, a6: C_SEXT, type_: 7, size: 4},
-	{as: AFMOVD, a1: C_FREG, a6: C_SAUTO, type_: 7, size: 4},
 	{as: AFMOVD, a1: C_FREG, a6: C_SOREG, type_: 7, size: 4},
-	{as: AFMOVD, a1: C_FREG, a6: C_LEXT, type_: 35, size: 8},
-	{as: AFMOVD, a1: C_FREG, a6: C_LAUTO, type_: 35, size: 8},
 	{as: AFMOVD, a1: C_FREG, a6: C_LOREG, type_: 35, size: 8},
 	{as: AFMOVD, a1: C_FREG, a6: C_ADDR, type_: 74, size: 8},
 	{as: AFMOVSX, a1: C_ZOREG, a2: C_REG, a6: C_FREG, type_: 45, size: 4},
@@ -679,15 +631,25 @@ func addpad(pc, a int64, ctxt *obj.Link, cursym *obj.LSym) int {
 // in handwritten asm like "MOVD R5, foosymbol" where a base register is not supplied,
 // or "MOVD R5, foo+10(SP) or pseudo-register is used.  The other common case is when
 // generating constants in register like "MOVD $constant, Rx".
-func getimpliedreg(a *obj.Addr) int {
+func (c *ctxt9) getimpliedreg(a *obj.Addr, p *obj.Prog) int {
 	switch oclass(a) {
-	case C_ZOREG, C_SOREG, C_LOREG, C_ADDCON, C_ANDCON, C_UCON, C_SCON, C_LCON:
+	case C_ADDCON, C_ANDCON, C_UCON, C_LCON, C_SCON, C_ZCON:
 		return REGZERO
-	case C_SEXT, C_LEXT, C_SECON, C_LECON:
+	case C_SECON, C_LECON:
 		return REGSB
-	case C_SAUTO, C_LAUTO, C_SACON, C_LACON:
+	case C_SACON, C_LACON:
 		return REGSP
+	case C_LOREG, C_SOREG, C_ZOREG:
+		switch a.Name {
+		case obj.NAME_EXTERN, obj.NAME_STATIC:
+			return REGSB
+		case obj.NAME_AUTO, obj.NAME_PARAM:
+			return REGSP
+		case obj.NAME_NONE:
+			return REGZERO
+		}
 	}
+	c.ctxt.Diag("failed to determine implied reg for class %v (%v)", DRconv(oclass(a)), p)
 	return 0
 }
 
@@ -904,7 +866,7 @@ func (c *ctxt9) aclass(a *obj.Addr) int {
 				}
 				return C_ADDR
 			}
-			return C_LEXT
+			return C_LOREG
 
 		case obj.NAME_GOTREF:
 			return C_GOTADDR
@@ -915,16 +877,16 @@ func (c *ctxt9) aclass(a *obj.Addr) int {
 		case obj.NAME_AUTO:
 			c.instoffset = int64(c.autosize) + a.Offset
 			if c.instoffset >= -BIG && c.instoffset < BIG {
-				return C_SAUTO
+				return C_SOREG
 			}
-			return C_LAUTO
+			return C_LOREG
 
 		case obj.NAME_PARAM:
 			c.instoffset = int64(c.autosize) + a.Offset + c.ctxt.FixedFrameSize()
 			if c.instoffset >= -BIG && c.instoffset < BIG {
-				return C_SAUTO
+				return C_SOREG
 			}
-			return C_LAUTO
+			return C_LOREG
 
 		case obj.NAME_NONE:
 			c.instoffset = a.Offset
@@ -1156,13 +1118,13 @@ func cmp(a int, b int) bool {
 			return true
 		}
 
-	case C_LEXT:
-		if b == C_SEXT {
+	case C_SOREG:
+		if b == C_ZOREG {
 			return true
 		}
 
-	case C_LAUTO:
-		if b == C_SAUTO {
+	case C_LOREG:
+		if b == C_SOREG || b == C_ZOREG {
 			return true
 		}
 
@@ -1171,16 +1133,6 @@ func cmp(a int, b int) bool {
 			return r0iszero != 0 /*TypeKind(100016)*/
 		}
 
-	case C_LOREG:
-		if b == C_ZOREG || b == C_SOREG {
-			return true
-		}
-
-	case C_SOREG:
-		if b == C_ZOREG {
-			return true
-		}
-
 	case C_ANY:
 		return true
 	}
@@ -2513,7 +2465,7 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		v := int32(d)
 		r := int(p.From.Reg)
 		if r == 0 {
-			r = getimpliedreg(&p.From)
+			r = c.getimpliedreg(&p.From, p)
 		}
 		if r0iszero != 0 /*TypeKind(100016)*/ && p.To.Reg == 0 && (r != 0 || v != 0) {
 			c.ctxt.Diag("literal operation on R0\n%v", p)
@@ -2586,7 +2538,7 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		r := int(p.To.Reg)
 
 		if r == 0 {
-			r = getimpliedreg(&p.To)
+			r = c.getimpliedreg(&p.To, p)
 		}
 		v := c.regoff(&p.To)
 		if p.To.Type == obj.TYPE_MEM && p.To.Index != 0 {
@@ -2622,7 +2574,7 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		r := int(p.From.Reg)
 
 		if r == 0 {
-			r = getimpliedreg(&p.From)
+			r = c.getimpliedreg(&p.From, p)
 		}
 		v := c.regoff(&p.From)
 		if p.From.Type == obj.TYPE_MEM && p.From.Index != 0 {
@@ -2653,7 +2605,7 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		r := int(p.From.Reg)
 
 		if r == 0 {
-			r = getimpliedreg(&p.From)
+			r = c.getimpliedreg(&p.From, p)
 		}
 		v := c.regoff(&p.From)
 		if p.From.Type == obj.TYPE_MEM && p.From.Index != 0 {
@@ -3043,7 +2995,7 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		v := c.regoff(&p.From)
 		r := int(p.From.Reg)
 		if r == 0 {
-			r = getimpliedreg(&p.From)
+			r = c.getimpliedreg(&p.From, p)
 		}
 		o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(v)))
 		o2 = AOP_IRR(OP_ADDI, uint32(p.To.Reg), REGTMP, uint32(v))
@@ -3187,7 +3139,7 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 
 		r := int(p.To.Reg)
 		if r == 0 {
-			r = getimpliedreg(&p.To)
+			r = c.getimpliedreg(&p.To, p)
 		}
 		// Offsets in DS form stores must be a multiple of 4
 		inst := c.opstore(p.As)
@@ -3202,7 +3154,7 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 
 		r := int(p.From.Reg)
 		if r == 0 {
-			r = getimpliedreg(&p.From)
+			r = c.getimpliedreg(&p.From, p)
 		}
 		o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(v)))
 		o2 = AOP_IRR(c.opload(p.As), uint32(p.To.Reg), REGTMP, uint32(v))
@@ -3212,7 +3164,7 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 
 		r := int(p.From.Reg)
 		if r == 0 {
-			r = getimpliedreg(&p.From)
+			r = c.getimpliedreg(&p.From, p)
 		}
 		o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(v)))
 		o2 = AOP_IRR(c.opload(p.As), uint32(p.To.Reg), REGTMP, uint32(v))
-- 
GitLab


From a937729c2c2f6950a32bc5cd0f5b88700882f078 Mon Sep 17 00:00:00 2001
From: Emmanuel T Odeke <emmanuel@orijtech.com>
Date: Sun, 7 Mar 2021 15:30:47 -0800
Subject: [PATCH 1168/2400] net/http: mention NewRequestWithContext+Client.Do
 for custom contexts

Adds mentions of NewRequestWithContext and *Client.Do as prescriptions
for how to use a specified context.Context, to the docs of:
* (*Client).Get
* (*Client).Head
* (*Client).Post
* (*Client).PostForm
* Get
* Head
* Post
* PostForm

given that we can't remove those convenience functions, nor
change the method signatures, except for Go2.

Fixes #35562

Change-Id: I4859e6757e7f958c9067ac4ef15881cfba7d1f8d
Reviewed-on: https://go-review.googlesource.com/c/go/+/299610
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Damien Neil <dneil@google.com>
---
 src/net/http/client.go | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/src/net/http/client.go b/src/net/http/client.go
index 88e2028bc3..82e665829e 100644
--- a/src/net/http/client.go
+++ b/src/net/http/client.go
@@ -442,6 +442,9 @@ func basicAuth(username, password string) string {
 //
 // To make a request with custom headers, use NewRequest and
 // DefaultClient.Do.
+//
+// To make a request with a specified context.Context, use NewRequestWithContext
+// and DefaultClient.Do.
 func Get(url string) (resp *Response, err error) {
 	return DefaultClient.Get(url)
 }
@@ -466,6 +469,9 @@ func Get(url string) (resp *Response, err error) {
 // Caller should close resp.Body when done reading from it.
 //
 // To make a request with custom headers, use NewRequest and Client.Do.
+//
+// To make a request with a specified context.Context, use NewRequestWithContext
+// and Client.Do.
 func (c *Client) Get(url string) (resp *Response, err error) {
 	req, err := NewRequest("GET", url, nil)
 	if err != nil {
@@ -821,6 +827,9 @@ func defaultCheckRedirect(req *Request, via []*Request) error {
 //
 // See the Client.Do method documentation for details on how redirects
 // are handled.
+//
+// To make a request with a specified context.Context, use NewRequestWithContext
+// and DefaultClient.Do.
 func Post(url, contentType string, body io.Reader) (resp *Response, err error) {
 	return DefaultClient.Post(url, contentType, body)
 }
@@ -834,6 +843,9 @@ func Post(url, contentType string, body io.Reader) (resp *Response, err error) {
 //
 // To set custom headers, use NewRequest and Client.Do.
 //
+// To make a request with a specified context.Context, use NewRequestWithContext
+// and Client.Do.
+//
 // See the Client.Do method documentation for details on how redirects
 // are handled.
 func (c *Client) Post(url, contentType string, body io.Reader) (resp *Response, err error) {
@@ -858,6 +870,9 @@ func (c *Client) Post(url, contentType string, body io.Reader) (resp *Response,
 //
 // See the Client.Do method documentation for details on how redirects
 // are handled.
+//
+// To make a request with a specified context.Context, use NewRequestWithContext
+// and DefaultClient.Do.
 func PostForm(url string, data url.Values) (resp *Response, err error) {
 	return DefaultClient.PostForm(url, data)
 }
@@ -873,6 +888,9 @@ func PostForm(url string, data url.Values) (resp *Response, err error) {
 //
 // See the Client.Do method documentation for details on how redirects
 // are handled.
+//
+// To make a request with a specified context.Context, use NewRequestWithContext
+// and Client.Do.
 func (c *Client) PostForm(url string, data url.Values) (resp *Response, err error) {
 	return c.Post(url, "application/x-www-form-urlencoded", strings.NewReader(data.Encode()))
 }
@@ -888,6 +906,9 @@ func (c *Client) PostForm(url string, data url.Values) (resp *Response, err erro
 //    308 (Permanent Redirect)
 //
 // Head is a wrapper around DefaultClient.Head
+//
+// To make a request with a specified context.Context, use NewRequestWithContext
+// and DefaultClient.Do.
 func Head(url string) (resp *Response, err error) {
 	return DefaultClient.Head(url)
 }
@@ -901,6 +922,9 @@ func Head(url string) (resp *Response, err error) {
 //    303 (See Other)
 //    307 (Temporary Redirect)
 //    308 (Permanent Redirect)
+//
+// To make a request with a specified context.Context, use NewRequestWithContext
+// and Client.Do.
 func (c *Client) Head(url string) (resp *Response, err error) {
 	req, err := NewRequest("HEAD", url, nil)
 	if err != nil {
-- 
GitLab


From e58fb90c753ce8ac1ccd6e26035e7ec0f4f108bc Mon Sep 17 00:00:00 2001
From: Emmanuel T Odeke <emmanuel@orijtech.com>
Date: Sun, 7 Mar 2021 14:56:52 -0800
Subject: [PATCH 1169/2400] net/http: make ExampleGet show StatusCode checks
 for non-1XX,2XX responses

Updates ExampleGet to show how to handle bad responses with non-1XX,2XX
status codes. Given that the canonical examples are copied, we need
to have them properly check against failures. This is a bug I've seen
often in the wild, that's exacerbated when for example unmarshalling
JSON or even protobufs, and no errors are returned by the decoders,
so code fails silently after making a request for example to a gateway
that they were unauthorized to access.

Fixes #39778

Change-Id: I1cd688f2fab47581c8cf228235d3662b4c8e4315
Reviewed-on: https://go-review.googlesource.com/c/go/+/299609
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Damien Neil <dneil@google.com>
---
 src/net/http/example_test.go | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/net/http/example_test.go b/src/net/http/example_test.go
index c677d52238..2f411d1d2e 100644
--- a/src/net/http/example_test.go
+++ b/src/net/http/example_test.go
@@ -45,12 +45,15 @@ func ExampleGet() {
 	if err != nil {
 		log.Fatal(err)
 	}
-	robots, err := io.ReadAll(res.Body)
+	body, err := io.ReadAll(res.Body)
 	res.Body.Close()
+	if res.StatusCode > 299 {
+		log.Fatalf("Response failed with status code: %d and\nbody: %s\n", res.StatusCode, body)
+	}
 	if err != nil {
 		log.Fatal(err)
 	}
-	fmt.Printf("%s", robots)
+	fmt.Printf("%s", body)
 }
 
 func ExampleFileServer() {
-- 
GitLab


From 4deaa6a178d89631302470f78574c1e957cf84a5 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Thu, 18 Mar 2021 16:01:23 +0000
Subject: [PATCH 1170/2400] runtime: call nanotimeQPC from nanotime1 without a
 wrapper

This changes makes it so that nanotimeQPC calls nanotime1 without an ABI
wrapper by specifying the ABIInternal version directly. The reason why
this is necessary is because ABI wrappers typically require additional
stack space, and nanotimeQPC is used deep within nosplit contexts,
and with the ABI wrappers now enabled, this exhausts the stack guard
space held for nosplit functions. Rather than increase the stack guard,
we choose to do this.

For #40724.

Change-Id: Ia9173ca903335a9d6f380f57f4a45e49b58da6bb
Reviewed-on: https://go-review.googlesource.com/c/go/+/303069
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/sys_windows_amd64.s | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/runtime/sys_windows_amd64.s b/src/runtime/sys_windows_amd64.s
index aba2811e59..a7c519ae19 100644
--- a/src/runtime/sys_windows_amd64.s
+++ b/src/runtime/sys_windows_amd64.s
@@ -464,7 +464,13 @@ loop:
 	MOVQ	CX, ret+0(FP)
 	RET
 useQPC:
-	JMP	runtime·nanotimeQPC(SB)
+	// Call with ABIInternal because we could be
+	// very deep in a nosplit context and the wrapper
+	// adds stack space.
+	// TODO(#40724): The result from nanotimeQPC will
+	// be passed in a register, so store that to the
+	// stack so we can return through a wrapper.
+	JMP	runtime·nanotimeQPC<ABIInternal>(SB)
 	RET
 
 TEXT time·now(SB),NOSPLIT,$0-24
-- 
GitLab


From 836dbdb15b766696eadd141ea2430f3549c58ec5 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Mon, 15 Mar 2021 21:48:58 +0000
Subject: [PATCH 1171/2400] runtime: mark Windows' address-taken asm routines
 as ABIInternal

In the runtime there are Windows-specific assembly routines that are
address-taken via funcPC and are not intended to be called through a
wrapper. Mark them as ABIInternal so that we don't grab the wrapper,
because that will break in all sorts of contexts.

For #40724.
For #44065.

Change-Id: I12a728786786f423e5b229f8622e4a80ec27a31c
Reviewed-on: https://go-review.googlesource.com/c/go/+/302109
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/sys_windows_386.s         | 22 +++++++++++-----------
 src/runtime/sys_windows_amd64.s       | 22 +++++++++++-----------
 src/runtime/sys_windows_arm.s         | 22 +++++++++++-----------
 src/runtime/sys_windows_arm64.s       | 26 +++++++++++++-------------
 src/runtime/wincallback.go            |  6 +++---
 src/runtime/zcallback_windows.s       |  2 +-
 src/runtime/zcallback_windows_arm.s   |  2 +-
 src/runtime/zcallback_windows_arm64.s |  2 +-
 8 files changed, 52 insertions(+), 52 deletions(-)

diff --git a/src/runtime/sys_windows_386.s b/src/runtime/sys_windows_386.s
index 4f00c58c16..e3fd90e05f 100644
--- a/src/runtime/sys_windows_386.s
+++ b/src/runtime/sys_windows_386.s
@@ -7,7 +7,7 @@
 #include "textflag.h"
 
 // void runtime·asmstdcall(void *c);
-TEXT runtime·asmstdcall(SB),NOSPLIT,$0
+TEXT runtime·asmstdcall<ABIInternal>(SB),NOSPLIT,$0
 	MOVL	fn+0(FP), BX
 
 	// SetLastError(0).
@@ -144,29 +144,29 @@ done:
 	BYTE $0xC2; WORD $4
 	RET // unreached; make assembler happy
 
-TEXT runtime·exceptiontramp(SB),NOSPLIT,$0
+TEXT runtime·exceptiontramp<ABIInternal>(SB),NOSPLIT,$0
 	MOVL	$runtime·exceptionhandler(SB), AX
 	JMP	sigtramp<>(SB)
 
-TEXT runtime·firstcontinuetramp(SB),NOSPLIT,$0-0
+TEXT runtime·firstcontinuetramp<ABIInternal>(SB),NOSPLIT,$0-0
 	// is never called
 	INT	$3
 
-TEXT runtime·lastcontinuetramp(SB),NOSPLIT,$0-0
+TEXT runtime·lastcontinuetramp<ABIInternal>(SB),NOSPLIT,$0-0
 	MOVL	$runtime·lastcontinuehandler(SB), AX
 	JMP	sigtramp<>(SB)
 
 // Called by OS using stdcall ABI: bool ctrlhandler(uint32).
-TEXT runtime·ctrlhandler(SB),NOSPLIT,$0
+TEXT runtime·ctrlhandler<ABIInternal>(SB),NOSPLIT,$0
 	PUSHL	$runtime·ctrlhandler1(SB)
 	NOP	SP	// tell vet SP changed - stop checking offsets
-	CALL	runtime·externalthreadhandler(SB)
+	CALL	runtime·externalthreadhandler<ABIInternal>(SB)
 	MOVL	4(SP), CX
 	ADDL	$12, SP
 	JMP	CX
 
 // Called by OS using stdcall ABI: uint32 profileloop(void*).
-TEXT runtime·profileloop(SB),NOSPLIT,$0
+TEXT runtime·profileloop<ABIInternal>(SB),NOSPLIT,$0
 	PUSHL	$runtime·profileloop1(SB)
 	NOP	SP	// tell vet SP changed - stop checking offsets
 	CALL	runtime·externalthreadhandler(SB)
@@ -174,7 +174,7 @@ TEXT runtime·profileloop(SB),NOSPLIT,$0
 	ADDL	$12, SP
 	JMP	CX
 
-TEXT runtime·externalthreadhandler(SB),NOSPLIT|TOPFRAME,$0
+TEXT runtime·externalthreadhandler<ABIInternal>(SB),NOSPLIT|TOPFRAME,$0
 	PUSHL	BP
 	MOVL	SP, BP
 	PUSHL	BX
@@ -227,7 +227,7 @@ TEXT runtime·externalthreadhandler(SB),NOSPLIT|TOPFRAME,$0
 
 GLOBL runtime·cbctxts(SB), NOPTR, $4
 
-TEXT runtime·callbackasm1(SB),NOSPLIT,$0
+TEXT runtime·callbackasm1<ABIInternal>(SB),NOSPLIT,$0
   	MOVL	0(SP), AX	// will use to find our callback context
 
 	// remove return address from stack, we are not returning to callbackasm, but to its caller.
@@ -246,7 +246,7 @@ TEXT runtime·callbackasm1(SB),NOSPLIT,$0
 	CLD
 
 	// determine index into runtime·cbs table
-	SUBL	$runtime·callbackasm(SB), AX
+	SUBL	$runtime·callbackasm<ABIInternal>(SB), AX
 	MOVL	$0, DX
 	MOVL	$5, BX	// divide by 5 because each call instruction in runtime·callbacks is 5 bytes long
 	DIVL	BX
@@ -316,7 +316,7 @@ TEXT tstart<>(SB),NOSPLIT,$0
 	RET
 
 // uint32 tstart_stdcall(M *newm);
-TEXT runtime·tstart_stdcall(SB),NOSPLIT,$0
+TEXT runtime·tstart_stdcall<ABIInternal>(SB),NOSPLIT,$0
 	MOVL	newm+0(FP), BX
 
 	PUSHL	BX
diff --git a/src/runtime/sys_windows_amd64.s b/src/runtime/sys_windows_amd64.s
index a7c519ae19..574def1038 100644
--- a/src/runtime/sys_windows_amd64.s
+++ b/src/runtime/sys_windows_amd64.s
@@ -11,7 +11,7 @@
 #define maxargs 16
 
 // void runtime·asmstdcall(void *c);
-TEXT runtime·asmstdcall(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·asmstdcall<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
 	// asmcgocall will put first argument into CX.
 	PUSHQ	CX			// save for later
 	MOVQ	libcall_fn(CX), AX
@@ -190,32 +190,32 @@ done:
 
 	RET
 
-TEXT runtime·exceptiontramp(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·exceptiontramp<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
 	MOVQ	$runtime·exceptionhandler(SB), AX
 	JMP	sigtramp<>(SB)
 
-TEXT runtime·firstcontinuetramp(SB),NOSPLIT|NOFRAME,$0-0
+TEXT runtime·firstcontinuetramp<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-0
 	MOVQ	$runtime·firstcontinuehandler(SB), AX
 	JMP	sigtramp<>(SB)
 
-TEXT runtime·lastcontinuetramp(SB),NOSPLIT|NOFRAME,$0-0
+TEXT runtime·lastcontinuetramp<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-0
 	MOVQ	$runtime·lastcontinuehandler(SB), AX
 	JMP	sigtramp<>(SB)
 
-TEXT runtime·ctrlhandler(SB),NOSPLIT|NOFRAME,$8
+TEXT runtime·ctrlhandler<ABIInternal>(SB),NOSPLIT|NOFRAME,$8
 	MOVQ	CX, 16(SP)		// spill
 	MOVQ	$runtime·ctrlhandler1(SB), CX
 	MOVQ	CX, 0(SP)
-	CALL	runtime·externalthreadhandler(SB)
+	CALL	runtime·externalthreadhandler<ABIInternal>(SB)
 	RET
 
-TEXT runtime·profileloop(SB),NOSPLIT|NOFRAME,$8
+TEXT runtime·profileloop<ABIInternal>(SB),NOSPLIT|NOFRAME,$8
 	MOVQ	$runtime·profileloop1(SB), CX
 	MOVQ	CX, 0(SP)
-	CALL	runtime·externalthreadhandler(SB)
+	CALL	runtime·externalthreadhandler<ABIInternal>(SB)
 	RET
 
-TEXT runtime·externalthreadhandler(SB),NOSPLIT|NOFRAME|TOPFRAME,$0
+TEXT runtime·externalthreadhandler<ABIInternal>(SB),NOSPLIT|NOFRAME|TOPFRAME,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	PUSHQ	BX
@@ -287,7 +287,7 @@ TEXT runtime·callbackasm1(SB),NOSPLIT,$0
 	ADDQ	$8, SP
 
 	// determine index into runtime·cbs table
-	MOVQ	$runtime·callbackasm(SB), DX
+	MOVQ	$runtime·callbackasm<ABIInternal>(SB), DX
 	SUBQ	DX, AX
 	MOVQ	$0, DX
 	MOVQ	$5, CX	// divide by 5 because each call instruction in runtime·callbacks is 5 bytes long
@@ -343,7 +343,7 @@ TEXT runtime·callbackasm1(SB),NOSPLIT,$0
 	RET
 
 // uint32 tstart_stdcall(M *newm);
-TEXT runtime·tstart_stdcall(SB),NOSPLIT,$0
+TEXT runtime·tstart_stdcall<ABIInternal>(SB),NOSPLIT,$0
 	// CX contains first arg newm
 	MOVQ	m_g0(CX), DX		// g
 
diff --git a/src/runtime/sys_windows_arm.s b/src/runtime/sys_windows_arm.s
index 9a5d9b1dd4..275b827fcb 100644
--- a/src/runtime/sys_windows_arm.s
+++ b/src/runtime/sys_windows_arm.s
@@ -9,7 +9,7 @@
 // Note: For system ABI, R0-R3 are args, R4-R11 are callee-save.
 
 // void runtime·asmstdcall(void *c);
-TEXT runtime·asmstdcall(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·asmstdcall<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
 	MOVM.DB.W [R4, R5, R14], (R13)	// push {r4, r5, lr}
 	MOVW	R0, R4			// put libcall * in r4
 	MOVW	R13, R5			// save stack pointer in r5
@@ -221,25 +221,25 @@ TEXT sigresume<>(SB),NOSPLIT|NOFRAME,$0
 	MOVW	R0, R13
 	B	(R1)
 
-TEXT runtime·exceptiontramp(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·exceptiontramp<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
 	MOVW	$runtime·exceptionhandler(SB), R1
 	B	sigtramp<>(SB)
 
-TEXT runtime·firstcontinuetramp(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·firstcontinuetramp<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
 	MOVW	$runtime·firstcontinuehandler(SB), R1
 	B	sigtramp<>(SB)
 
-TEXT runtime·lastcontinuetramp(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·lastcontinuetramp<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
 	MOVW	$runtime·lastcontinuehandler(SB), R1
 	B	sigtramp<>(SB)
 
-TEXT runtime·ctrlhandler(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·ctrlhandler<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
 	MOVW	$runtime·ctrlhandler1(SB), R1
-	B	runtime·externalthreadhandler(SB)
+	B	runtime·externalthreadhandler<ABIInternal>(SB)
 
-TEXT runtime·profileloop(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·profileloop<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
 	MOVW	$runtime·profileloop1(SB), R1
-	B	runtime·externalthreadhandler(SB)
+	B	runtime·externalthreadhandler<ABIInternal>(SB)
 
 // int32 externalthreadhandler(uint32 arg, int (*func)(uint32))
 // stack layout:
@@ -262,7 +262,7 @@ TEXT runtime·profileloop(SB),NOSPLIT|NOFRAME,$0
 // 0 | slot for LR    |
 //   +----------------+
 //
-TEXT runtime·externalthreadhandler(SB),NOSPLIT|NOFRAME|TOPFRAME,$0
+TEXT runtime·externalthreadhandler<ABIInternal>(SB),NOSPLIT|NOFRAME|TOPFRAME,$0
 	MOVM.DB.W [R4-R11, R14], (R13)		// push {r4-r11, lr}
 	SUB	$(m__size + g__size + 20), R13	// space for locals
 	MOVW	R14, 0(R13)			// push LR again for anything unwinding the stack
@@ -310,7 +310,7 @@ TEXT runtime·externalthreadhandler(SB),NOSPLIT|NOFRAME|TOPFRAME,$0
 
 GLOBL runtime·cbctxts(SB), NOPTR, $4
 
-TEXT runtime·callbackasm1(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·callbackasm1<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
 	// On entry, the trampoline in zcallback_windows_arm.s left
 	// the callback index in R12 (which is volatile in the C ABI).
 
@@ -349,7 +349,7 @@ TEXT runtime·callbackasm1(SB),NOSPLIT|NOFRAME,$0
 	B	(R12)	// return
 
 // uint32 tstart_stdcall(M *newm);
-TEXT runtime·tstart_stdcall(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·tstart_stdcall<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
 	MOVM.DB.W [R4-R11, R14], (R13)		// push {r4-r11, lr}
 
 	MOVW	m_g0(R0), g
diff --git a/src/runtime/sys_windows_arm64.s b/src/runtime/sys_windows_arm64.s
index 53960488f9..c8c96acd06 100644
--- a/src/runtime/sys_windows_arm64.s
+++ b/src/runtime/sys_windows_arm64.s
@@ -17,7 +17,7 @@
 // load_g and save_g (in tls_arm64.s) clobber R27 (REGTMP) and R0.
 
 // void runtime·asmstdcall(void *c);
-TEXT runtime·asmstdcall(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·asmstdcall<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
 	STP.W	(R29, R30), -32(RSP)	// allocate C ABI stack frame
 	STP	(R19, R20), 16(RSP) // save old R19, R20
 	MOVD	R0, R19	// save libcall pointer
@@ -287,29 +287,29 @@ TEXT sigresume<>(SB),NOSPLIT|NOFRAME,$0
 	MOVD	R0, RSP
 	B	(R1)
 
-TEXT runtime·exceptiontramp(SB),NOSPLIT|NOFRAME,$0
-	MOVD	$runtime·exceptionhandler(SB), R1
+TEXT runtime·exceptiontramp<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
+	MOVD	$runtime·exceptionhandler<ABIInternal>(SB), R1
 	B	sigtramp<>(SB)
 
-TEXT runtime·firstcontinuetramp(SB),NOSPLIT|NOFRAME,$0
-	MOVD	$runtime·firstcontinuehandler(SB), R1
+TEXT runtime·firstcontinuetramp<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
+	MOVD	$runtime·firstcontinuehandler<ABIInternal>(SB), R1
 	B	sigtramp<>(SB)
 
 TEXT runtime·lastcontinuetramp(SB),NOSPLIT|NOFRAME,$0
-	MOVD	$runtime·lastcontinuehandler(SB), R1
+	MOVD	$runtime·lastcontinuehandler<ABIInternal>(SB), R1
 	B	sigtramp<>(SB)
 
-TEXT runtime·ctrlhandler(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·ctrlhandler<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
 	MOVD	$runtime·ctrlhandler1(SB), R1
-	B	runtime·externalthreadhandler(SB)
+	B	runtime·externalthreadhandler<ABIInternal>(SB)
 
-TEXT runtime·profileloop(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·profileloop<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
 	MOVD	$runtime·profileloop1(SB), R1
-	B	runtime·externalthreadhandler(SB)
+	B	runtime·externalthreadhandler<ABIInternal>(SB)
 
 // externalthreadhander called with R0 = uint32 arg, R1 = Go function f.
 // Need to call f(arg), which returns a uint32, and return it in R0.
-TEXT runtime·externalthreadhandler(SB),NOSPLIT|TOPFRAME,$96-0
+TEXT runtime·externalthreadhandler<ABIInternal>(SB),NOSPLIT|TOPFRAME,$96-0
 	NO_LOCAL_POINTERS
 
 	// Push C callee-save registers R19-R28. LR, FP already saved.
@@ -369,7 +369,7 @@ TEXT runtime·externalthreadhandler(SB),NOSPLIT|TOPFRAME,$96-0
 
 GLOBL runtime·cbctxts(SB), NOPTR, $4
 
-TEXT runtime·callbackasm1(SB),NOSPLIT,$208-0
+TEXT runtime·callbackasm1<ABIInternal>(SB),NOSPLIT,$208-0
 	NO_LOCAL_POINTERS
 
 	// On entry, the trampoline in zcallback_windows_arm64.s left
@@ -416,7 +416,7 @@ TEXT runtime·callbackasm1(SB),NOSPLIT,$208-0
 	RET
 
 // uint32 tstart_stdcall(M *newm);
-TEXT runtime·tstart_stdcall(SB),NOSPLIT,$96-0
+TEXT runtime·tstart_stdcall<ABIInternal>(SB),NOSPLIT,$96-0
 	SAVE_R19_TO_R28(-10*8)
 
 	MOVD	m_g0(R0), g
diff --git a/src/runtime/wincallback.go b/src/runtime/wincallback.go
index 56f0674f4e..8411c98412 100644
--- a/src/runtime/wincallback.go
+++ b/src/runtime/wincallback.go
@@ -31,7 +31,7 @@ func genasm386Amd64() {
 // CALL instruction in runtime·callbackasm. This determines
 // which Go callback function is executed later on.
 
-TEXT runtime·callbackasm(SB),7,$0
+TEXT runtime·callbackasm<ABIInternal>(SB),7,$0
 `)
 	for i := 0; i < maxCallback; i++ {
 		buf.WriteString("\tCALL\truntime·callbackasm1(SB)\n")
@@ -59,7 +59,7 @@ func genasmArm() {
 // It then calls the Go implementation for that callback.
 #include "textflag.h"
 
-TEXT runtime·callbackasm(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·callbackasm<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
 `)
 	for i := 0; i < maxCallback; i++ {
 		buf.WriteString(fmt.Sprintf("\tMOVW\t$%d, R12\n", i))
@@ -87,7 +87,7 @@ func genasmArm64() {
 // It then calls the Go implementation for that callback.
 #include "textflag.h"
 
-TEXT runtime·callbackasm(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·callbackasm<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
 `)
 	for i := 0; i < maxCallback; i++ {
 		buf.WriteString(fmt.Sprintf("\tMOVD\t$%d, R12\n", i))
diff --git a/src/runtime/zcallback_windows.s b/src/runtime/zcallback_windows.s
index 7772eef329..37ffb38aca 100644
--- a/src/runtime/zcallback_windows.s
+++ b/src/runtime/zcallback_windows.s
@@ -9,7 +9,7 @@
 // CALL instruction in runtime·callbackasm. This determines
 // which Go callback function is executed later on.
 
-TEXT runtime·callbackasm(SB),7,$0
+TEXT runtime·callbackasm<ABIInternal>(SB),7,$0
 	CALL	runtime·callbackasm1(SB)
 	CALL	runtime·callbackasm1(SB)
 	CALL	runtime·callbackasm1(SB)
diff --git a/src/runtime/zcallback_windows_arm.s b/src/runtime/zcallback_windows_arm.s
index f943d84cbf..a73a813acb 100644
--- a/src/runtime/zcallback_windows_arm.s
+++ b/src/runtime/zcallback_windows_arm.s
@@ -9,7 +9,7 @@
 // It then calls the Go implementation for that callback.
 #include "textflag.h"
 
-TEXT runtime·callbackasm(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·callbackasm<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
 	MOVW	$0, R12
 	B	runtime·callbackasm1(SB)
 	MOVW	$1, R12
diff --git a/src/runtime/zcallback_windows_arm64.s b/src/runtime/zcallback_windows_arm64.s
index 69fb05788c..2a6bda0990 100644
--- a/src/runtime/zcallback_windows_arm64.s
+++ b/src/runtime/zcallback_windows_arm64.s
@@ -9,7 +9,7 @@
 // It then calls the Go implementation for that callback.
 #include "textflag.h"
 
-TEXT runtime·callbackasm(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·callbackasm<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
 	MOVD	$0, R12
 	B	runtime·callbackasm1(SB)
 	MOVD	$1, R12
-- 
GitLab


From 482903150dff1a4e9791330aed24ae607005fc18 Mon Sep 17 00:00:00 2001
From: Antonio Garcia <garcia.olais@gmail.com>
Date: Fri, 19 Mar 2021 15:29:09 +0000
Subject: [PATCH 1172/2400] syscall: fix typo in exec_windows_test.go

nothign -> nothing

Change-Id: I3f5cf20cc094d280f6cafa179eaefd745874dec1
GitHub-Last-Rev: a4cf42f27574ab8567d0f45bcd4dfbe018587214
GitHub-Pull-Request: golang/go#45118
Reviewed-on: https://go-review.googlesource.com/c/go/+/303269
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/syscall/exec_windows_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/syscall/exec_windows_test.go b/src/syscall/exec_windows_test.go
index fb2c767c35..aeafb564b3 100644
--- a/src/syscall/exec_windows_test.go
+++ b/src/syscall/exec_windows_test.go
@@ -52,7 +52,7 @@ func TestChangingProcessParent(t *testing.T) {
 	if os.Getenv("GO_WANT_HELPER_PROCESS") == "parent" {
 		// in parent process
 
-		// Parent does nothign. It is just used as a parent of a child process.
+		// Parent does nothing. It is just used as a parent of a child process.
 		time.Sleep(time.Minute)
 		os.Exit(0)
 	}
-- 
GitLab


From 1c590661e7d3b477662f76ead56f39567ea8345a Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 19 Mar 2021 11:48:22 -0400
Subject: [PATCH 1173/2400] testing: allow parallel-subtest goroutines to exit
 when the subtest is complete

Fixes #45127
Updates #38768

Change-Id: I7f41901d5bcc07741ac9f5f2a24d2b07ef633cb1
Reviewed-on: https://go-review.googlesource.com/c/go/+/303330
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 .../test_finished_subtest_goroutines.txt      | 52 +++++++++++++++++++
 src/testing/testing.go                        | 13 ++---
 2 files changed, 59 insertions(+), 6 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/test_finished_subtest_goroutines.txt

diff --git a/src/cmd/go/testdata/script/test_finished_subtest_goroutines.txt b/src/cmd/go/testdata/script/test_finished_subtest_goroutines.txt
new file mode 100644
index 0000000000..8db821eb77
--- /dev/null
+++ b/src/cmd/go/testdata/script/test_finished_subtest_goroutines.txt
@@ -0,0 +1,52 @@
+# Regression test for https://golang.org/issue/45127:
+# Goroutines for completed parallel subtests should exit immediately,
+# not block until earlier subtests have finished.
+
+[short] skip
+
+! go test .
+stdout 'panic: slow failure'
+! stdout '\[chan send'
+
+-- go.mod --
+module golang.org/issue45127
+
+go 1.16
+-- issue45127_test.go --
+package main
+
+import (
+	"fmt"
+	"runtime"
+	"runtime/debug"
+	"sync"
+	"testing"
+)
+
+func TestTestingGoroutineLeak(t *testing.T) {
+	debug.SetTraceback("all")
+
+	var wg sync.WaitGroup
+	const nFast = 10
+
+	t.Run("slow", func(t *testing.T) {
+		t.Parallel()
+		wg.Wait()
+		for i := 0; i < nFast; i++ {
+			// If the subtest goroutines are going to park on the channel
+			// send, allow them to park now. If they're not going to park,
+			// make sure they have had a chance to run to completion so
+			// that they aren't spuriously parked when we panic.
+			runtime.Gosched()
+		}
+		panic("slow failure")
+	})
+
+	wg.Add(nFast)
+	for i := 0; i < nFast; i++ {
+		t.Run(fmt.Sprintf("leaky%d", i), func(t *testing.T) {
+			t.Parallel()
+			wg.Done()
+		})
+	}
+}
diff --git a/src/testing/testing.go b/src/testing/testing.go
index 383e56a20e..0df6e45ec4 100644
--- a/src/testing/testing.go
+++ b/src/testing/testing.go
@@ -1258,7 +1258,7 @@ func (t *T) Run(name string, f func(t *T)) bool {
 	t = &T{
 		common: common{
 			barrier: make(chan bool),
-			signal:  make(chan bool),
+			signal:  make(chan bool, 1),
 			name:    testName,
 			parent:  &t.common,
 			level:   t.level + 1,
@@ -1539,7 +1539,7 @@ func runTests(matchString func(pat, str string) (bool, error), tests []InternalT
 			ctx.deadline = deadline
 			t := &T{
 				common: common{
-					signal:  make(chan bool),
+					signal:  make(chan bool, 1),
 					barrier: make(chan bool),
 					w:       os.Stdout,
 				},
@@ -1552,11 +1552,12 @@ func runTests(matchString func(pat, str string) (bool, error), tests []InternalT
 				for _, test := range tests {
 					t.Run(test.Name, test.F)
 				}
-				// Run catching the signal rather than the tRunner as a separate
-				// goroutine to avoid adding a goroutine during the sequential
-				// phase as this pollutes the stacktrace output when aborting.
-				go func() { <-t.signal }()
 			})
+			select {
+			case <-t.signal:
+			default:
+				panic("internal error: tRunner exited without sending on t.signal")
+			}
 			ok = ok && !t.Failed()
 			ran = ran || t.ran
 		}
-- 
GitLab


From 3b0d28808df261747d7561badf91498bbb5d3e3e Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Thu, 18 Mar 2021 21:01:37 -0400
Subject: [PATCH 1174/2400] cmd/go: assume Go 1.16 instead of Go 1.11 for
 dependencies that lack explicit 'go' directives

Fixes #45109
Updates #44976
Updates #36876

Change-Id: Icb00f8b6e0d4e076d82da1697e7058b9e7603916
Reviewed-on: https://go-review.googlesource.com/c/go/+/303229
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 doc/go1.17.html                               | 12 ++++++
 src/cmd/go/internal/modload/init.go           | 42 +++++++++++++++----
 src/cmd/go/internal/work/gc.go                | 10 ++++-
 .../testdata/script/mod_go_version_vendor.txt | 36 ++++++++++++++++
 4 files changed, 92 insertions(+), 8 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/mod_go_version_vendor.txt

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 22b2ff1156..cd61dd8cef 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -67,6 +67,18 @@ Do not send CLs removing the interior tags from such phrases.
   Go 1.12</a>.)
 </p>
 
+<p><!-- golang.org/issue/44976 -->
+  If a module dependency lacks an explicit <code>go.mod</code> file, or
+  its <code>go.mod</code> file does not contain
+  a <a href="/doc/modules/gomod-ref#go"><code>go</code> directive</a>,
+  the <code>go</code> command now assumes <code>go 1.16</code> for that
+  dependency instead of the current release. (Dependencies developed in GOPATH
+  mode may lack a <code>go.mod</code> file, and
+  the <code>vendor/modules.txt</code> has to date never recorded
+  the <code>go</code> versions indicated by dependencies' <code>go.mod</code>
+  files.)
+</p>
+
 <h2 id="runtime">Runtime</h2>
 
 <p>
diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index 2466a3bdfd..dd97a6bfb9 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -405,9 +405,38 @@ func LoadModFile(ctx context.Context) {
 		readVendorList()
 		checkVendorConsistency()
 	}
-	if index.goVersionV == "" && cfg.BuildMod == "mod" {
-		addGoStmt()
-		WriteGoMod()
+	if index.goVersionV == "" {
+		// The main module necessarily has a go.mod file, and that file lacks a
+		// 'go' directive. The 'go' command has been adding that directive
+		// automatically since Go 1.12, so this module either dates to Go 1.11 or
+		// has been erroneously hand-edited.
+		//
+		// If we are able to modify the go.mod file, we will add a 'go' directive
+		// to at least make the situation explicit going forward.
+		if cfg.BuildMod == "mod" {
+			// TODO(#44976): If we implicitly upgrade to the latest Go version once
+			// lazy loading is implemented, we could accidentally prune out
+			// dependencies from what was formerly a Go 1.11 module, resulting in
+			// downgrades (if only lower requirements on that module remain) and/or
+			// upgrades (if no requirement remains and we end up re-resolving to
+			// latest).
+			//
+			// We should probably instead load the dependencies using Go 1.11
+			// semantics to ensure that we capture everything that is relevant, or
+			// perhaps error out and let the user tell us which version they intend.
+			//
+			// If we are running 'go mod tidy' in particular, we will have enough
+			// information to upgrade the 'go' version after loading is complete.
+			addGoStmt(latestGoVersion())
+			WriteGoMod()
+		} else {
+			// Reproducibility requires that if we change the semantics of a module,
+			// we write some explicit change to its go.mod file. We cannot write to
+			// the go.mod file (because we are in readonly or vendor mode), so we must
+			// not change its semantics either. The go.mod file looks as if it were
+			// created by Go 1.11, so assume Go 1.11 semantics.
+			rawGoVersion.Store(Target, "1.11")
+		}
 	}
 }
 
@@ -442,7 +471,7 @@ func CreateModFile(ctx context.Context, modPath string) {
 	modFile = new(modfile.File)
 	modFile.AddModuleStmt(modPath)
 	initTarget(modFile.Module.Mod)
-	addGoStmt() // Add the go directive before converted module requirements.
+	addGoStmt(latestGoVersion()) // Add the go directive before converted module requirements.
 
 	convertedFrom, err := convertLegacyConfig(modPath)
 	if convertedFrom != "" {
@@ -680,11 +709,10 @@ func convertLegacyConfig(modPath string) (from string, err error) {
 // addGoStmt adds a go directive to the go.mod file if it does not already
 // include one. The 'go' version added, if any, is the latest version supported
 // by this toolchain.
-func addGoStmt() {
+func addGoStmt(v string) {
 	if modFile.Go != nil && modFile.Go.Version != "" {
 		return
 	}
-	v := latestGoVersion()
 	if err := modFile.AddGoStmt(v); err != nil {
 		base.Fatalf("go: internal error: %v", err)
 	}
@@ -692,7 +720,7 @@ func addGoStmt() {
 }
 
 // latestGoVersion returns the latest version of the Go language supported by
-// this toolchain.
+// this toolchain, like "1.17".
 func latestGoVersion() string {
 	tags := build.Default.ReleaseTags
 	version := tags[len(tags)-1]
diff --git a/src/cmd/go/internal/work/gc.go b/src/cmd/go/internal/work/gc.go
index 95fffeabd6..c71196469b 100644
--- a/src/cmd/go/internal/work/gc.go
+++ b/src/cmd/go/internal/work/gc.go
@@ -70,7 +70,15 @@ func (gcToolchain) gc(b *Builder, a *Action, archive string, importcfg, embedcfg
 			// as of Go 1.12, so any module that still lacks such a directive must
 			// either have been authored before then, or have a hand-edited go.mod
 			// file that hasn't been updated by cmd/go since that edit.
-			v = "1.11"
+			//
+			// Unfortunately, through at least Go 1.16 we didn't add versions to
+			// vendor/modules.txt. So this could also be a vendored 1.16 dependency.
+			//
+			// Fortunately, there were no breaking changes to the language between Go
+			// 1.11 and 1.16, so if we assume Go 1.16 semantics we will not introduce
+			// any spurious errors — we will only mask errors, and not particularly
+			// important ones at that.
+			v = "1.16"
 		}
 		if allowedVersion(v) {
 			gcargs = append(gcargs, "-lang=go"+v)
diff --git a/src/cmd/go/testdata/script/mod_go_version_vendor.txt b/src/cmd/go/testdata/script/mod_go_version_vendor.txt
new file mode 100644
index 0000000000..05be54886f
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_go_version_vendor.txt
@@ -0,0 +1,36 @@
+# Regression test for https://golang.org/issue/45109:
+# Dependencies that use post-1.11 Go features should build
+# when compiled as vendored dependencies of Go 1.16 modules.
+
+[short] skip
+
+go mod init example.com/foo
+go mod edit -replace=example.com/use113@v0.1.0=./use113
+
+go mod vendor
+! grep 1.13 vendor/modules.txt  # TODO(#36876): record dependency versions.
+go build .
+
+
+# In Go 1.16 and earlier, 'go mod vendor' did not record dependency versions.
+# That still should not cause a build failure.
+
+go mod edit -go=1.16
+go mod vendor
+! grep 1.13 vendor/modules.txt
+go build .
+
+
+-- foo.go --
+package foo
+
+import _ "example.com/use113"
+
+-- use113/go.mod --
+module example.com/use113
+
+go 1.13
+-- use113/use113.go --
+package use113
+
+const x = 1_000
-- 
GitLab


From 9f2a71b6e7b418182dd0467e7d054ccf8130c026 Mon Sep 17 00:00:00 2001
From: Dilyn Corner <dilyn.corner@gmail.com>
Date: Fri, 19 Mar 2021 18:18:18 +0000
Subject: [PATCH 1175/2400] make.bash: this change modifies Go to correctly
 select a dyamic linker

Alpine Linux is not the only musl-based Linux distribution. Checking for
/etc/alpine-release excludes many other distributions (Oasis, KISS,
Sabotage, sta.li). Not having the correct GO_LDSO set during go builds will
result in the wrong linker/loader on nonalpine musl systems for pie builds.
Instead, the dynamic loader should be checked for every system and set. This
results in the correct dynamic linker being found on glibc systems
(/lib/ld-linux-x86-64.so.2) and musl systems (/lib/ld-musl-x84_64.so.1).

Fixes #45034

Change-Id: I4c9389abc759aa34431dc6c781022636b81d6910
GitHub-Last-Rev: e17b9eb10693bfce7c9ce03af3b15bd0e56e8dbe
GitHub-Pull-Request: golang/go#45036
Reviewed-on: https://go-review.googlesource.com/c/go/+/301989
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Cherry Zhang <cherryyz@google.com>
---
 src/make.bash | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/make.bash b/src/make.bash
index b58f27bb1b..3d1b0c87e7 100755
--- a/src/make.bash
+++ b/src/make.bash
@@ -130,13 +130,12 @@ if [ "$(uname -s)" = "GNU/kFreeBSD" ]; then
 	export CGO_ENABLED=0
 fi
 
-# On Alpine Linux, use the musl dynamic linker/loader
-if [ -f "/etc/alpine-release" ]; then
-	if type readelf >/dev/null 2>&1; then
-		echo "int main() { return 0; }" | ${CC:-gcc} -o ./test-alpine-ldso -x c -
-		export GO_LDSO=$(readelf -l ./test-alpine-ldso | grep 'interpreter:' | sed -e 's/^.*interpreter: \(.*\)[]]/\1/')
-		rm -f ./test-alpine-ldso
-	fi
+# Test which linker/loader our system is using
+if type readelf >/dev/null 2>&1; then
+	echo "int main() { return 0; }" | ${CC:-cc} -o ./test-musl-ldso -x c - || continue
+	LDSO=$(readelf -l ./test-musl-ldso | grep 'interpreter:' | sed -e 's/^.*interpreter: \(.*\)[]]/\1/') >/dev/null 2>&1
+	[ -z "$LDSO" ] || export GO_LDSO="$LDSO"
+	rm -f ./test-musl-ldso
 fi
 
 # Clean old generated file that will cause problems in the build.
-- 
GitLab


From 6ae3b70ef255cd7317764a12b7230f293683f2c5 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Wed, 17 Mar 2021 19:15:38 -0400
Subject: [PATCH 1176/2400] cmd/compile: add clobberdeadreg mode

When -clobberdeadreg flag is set, the compiler inserts code that
clobbers integer registers at call sites. This may be helpful for
debugging register ABI.

Only implemented on AMD64 for now.

Change-Id: Ia203d3f891c30fd95d0103489056fe01d63a2899
Reviewed-on: https://go-review.googlesource.com/c/go/+/302809
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/amd64/ssa.go         |  7 ++++
 src/cmd/compile/internal/arm/ssa.go           |  2 +-
 src/cmd/compile/internal/arm64/ssa.go         |  2 +-
 src/cmd/compile/internal/base/flag.go         |  1 +
 src/cmd/compile/internal/mips/ssa.go          |  2 +-
 src/cmd/compile/internal/mips64/ssa.go        |  2 +-
 src/cmd/compile/internal/ppc64/ssa.go         |  2 +-
 src/cmd/compile/internal/riscv64/ssa.go       |  3 ++
 src/cmd/compile/internal/s390x/ssa.go         |  2 +-
 .../compile/internal/ssa/gen/genericOps.go    |  1 +
 src/cmd/compile/internal/ssa/opGen.go         |  6 ++++
 src/cmd/compile/internal/ssa/regalloc.go      | 31 +++++++++++++++++
 .../compile/internal/test/clobberdead_test.go | 10 +++++-
 src/cmd/compile/internal/wasm/ssa.go          |  3 ++
 src/cmd/compile/internal/x86/ssa.go           |  2 ++
 src/runtime/sys_darwin_amd64.s                |  2 +-
 test/codegen/clobberdeadreg.go                | 33 +++++++++++++++++++
 17 files changed, 103 insertions(+), 8 deletions(-)
 create mode 100644 test/codegen/clobberdeadreg.go

diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index bdd9da77b0..2c767d36d7 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -1242,6 +1242,13 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Reg = x86.REG_SP
 		ssagen.AddAux(&p.To, v)
 		p.To.Offset += 4
+	case ssa.OpClobberReg:
+		x := uint64(0xdeaddeaddeaddead)
+		p := s.Prog(x86.AMOVQ)
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = int64(x)
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = v.Reg()
 	default:
 		v.Fatalf("genValue not implemented: %s", v.LongString())
 	}
diff --git a/src/cmd/compile/internal/arm/ssa.go b/src/cmd/compile/internal/arm/ssa.go
index 7b2fec3765..832f940c26 100644
--- a/src/cmd/compile/internal/arm/ssa.go
+++ b/src/cmd/compile/internal/arm/ssa.go
@@ -861,7 +861,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		v.Fatalf("FlagConstant op should never make it to codegen %v", v.LongString())
 	case ssa.OpARMInvertFlags:
 		v.Fatalf("InvertFlags should never make it to codegen %v", v.LongString())
-	case ssa.OpClobber:
+	case ssa.OpClobber, ssa.OpClobberReg:
 		// TODO: implement for clobberdead experiment. Nop is ok for now.
 	default:
 		v.Fatalf("genValue not implemented: %s", v.LongString())
diff --git a/src/cmd/compile/internal/arm64/ssa.go b/src/cmd/compile/internal/arm64/ssa.go
index 3250b49c92..afd0d66d72 100644
--- a/src/cmd/compile/internal/arm64/ssa.go
+++ b/src/cmd/compile/internal/arm64/ssa.go
@@ -1100,7 +1100,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		v.Fatalf("FlagConstant op should never make it to codegen %v", v.LongString())
 	case ssa.OpARM64InvertFlags:
 		v.Fatalf("InvertFlags should never make it to codegen %v", v.LongString())
-	case ssa.OpClobber:
+	case ssa.OpClobber, ssa.OpClobberReg:
 		// TODO: implement for clobberdead experiment. Nop is ok for now.
 	default:
 		v.Fatalf("genValue not implemented: %s", v.LongString())
diff --git a/src/cmd/compile/internal/base/flag.go b/src/cmd/compile/internal/base/flag.go
index 751ab1b5c7..eb46ed99af 100644
--- a/src/cmd/compile/internal/base/flag.go
+++ b/src/cmd/compile/internal/base/flag.go
@@ -90,6 +90,7 @@ type CmdFlags struct {
 	CPUProfile         string       "help:\"write cpu profile to `file`\""
 	Complete           bool         "help:\"compiling complete package (no C or assembly)\""
 	ClobberDead        bool         "help:\"clobber dead stack slots (for debugging)\""
+	ClobberDeadReg     bool         "help:\"clobber dead registers (for debugging)\""
 	Dwarf              bool         "help:\"generate DWARF symbols\""
 	DwarfBASEntries    *bool        "help:\"use base address selection entries in DWARF\""                        // &Ctxt.UseBASEntries, set below
 	DwarfLocationLists *bool        "help:\"add location lists to DWARF in optimized mode\""                      // &Ctxt.Flag_locationlists, set below
diff --git a/src/cmd/compile/internal/mips/ssa.go b/src/cmd/compile/internal/mips/ssa.go
index 13736d12b4..e0447f38cb 100644
--- a/src/cmd/compile/internal/mips/ssa.go
+++ b/src/cmd/compile/internal/mips/ssa.go
@@ -798,7 +798,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p := s.Prog(obj.AGETCALLERPC)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
-	case ssa.OpClobber:
+	case ssa.OpClobber, ssa.OpClobberReg:
 		// TODO: implement for clobberdead experiment. Nop is ok for now.
 	default:
 		v.Fatalf("genValue not implemented: %s", v.LongString())
diff --git a/src/cmd/compile/internal/mips64/ssa.go b/src/cmd/compile/internal/mips64/ssa.go
index c5a3ca305a..e821a00876 100644
--- a/src/cmd/compile/internal/mips64/ssa.go
+++ b/src/cmd/compile/internal/mips64/ssa.go
@@ -765,7 +765,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p := s.Prog(obj.AGETCALLERPC)
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
-	case ssa.OpClobber:
+	case ssa.OpClobber, ssa.OpClobberReg:
 		// TODO: implement for clobberdead experiment. Nop is ok for now.
 	default:
 		v.Fatalf("genValue not implemented: %s", v.LongString())
diff --git a/src/cmd/compile/internal/ppc64/ssa.go b/src/cmd/compile/internal/ppc64/ssa.go
index 899f5ee6af..a0ad69a68d 100644
--- a/src/cmd/compile/internal/ppc64/ssa.go
+++ b/src/cmd/compile/internal/ppc64/ssa.go
@@ -1927,7 +1927,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		v.Fatalf("InvertFlags should never make it to codegen %v", v.LongString())
 	case ssa.OpPPC64FlagEQ, ssa.OpPPC64FlagLT, ssa.OpPPC64FlagGT:
 		v.Fatalf("Flag* ops should never make it to codegen %v", v.LongString())
-	case ssa.OpClobber:
+	case ssa.OpClobber, ssa.OpClobberReg:
 		// TODO: implement for clobberdead experiment. Nop is ok for now.
 	default:
 		v.Fatalf("genValue not implemented: %s", v.LongString())
diff --git a/src/cmd/compile/internal/riscv64/ssa.go b/src/cmd/compile/internal/riscv64/ssa.go
index 4a858de191..64a9b3b33b 100644
--- a/src/cmd/compile/internal/riscv64/ssa.go
+++ b/src/cmd/compile/internal/riscv64/ssa.go
@@ -629,6 +629,9 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Sym = ir.Syms.Duffcopy
 		p.To.Offset = v.AuxInt
 
+	case ssa.OpClobber, ssa.OpClobberReg:
+		// TODO: implement for clobberdead experiment. Nop is ok for now.
+
 	default:
 		v.Fatalf("Unhandled op %v", v.Op)
 	}
diff --git a/src/cmd/compile/internal/s390x/ssa.go b/src/cmd/compile/internal/s390x/ssa.go
index 7646be6147..ddc05b36ad 100644
--- a/src/cmd/compile/internal/s390x/ssa.go
+++ b/src/cmd/compile/internal/s390x/ssa.go
@@ -844,7 +844,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		bne.To.SetTarget(cs)
 	case ssa.OpS390XSYNC:
 		s.Prog(s390x.ASYNC)
-	case ssa.OpClobber:
+	case ssa.OpClobber, ssa.OpClobberReg:
 		// TODO: implement for clobberdead experiment. Nop is ok for now.
 	default:
 		v.Fatalf("genValue not implemented: %s", v.LongString())
diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go
index 85c58ef74c..c38d22e07f 100644
--- a/src/cmd/compile/internal/ssa/gen/genericOps.go
+++ b/src/cmd/compile/internal/ssa/gen/genericOps.go
@@ -613,6 +613,7 @@ var genericOps = []opData{
 
 	// Clobber experiment op
 	{name: "Clobber", argLength: 0, typ: "Void", aux: "SymOff", symEffect: "None"}, // write an invalid pointer value to the given pointer slot of a stack variable
+	{name: "ClobberReg", argLength: 0, typ: "Void"},                                // clobber a register
 }
 
 //     kind          controls        successors   implicit exit
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index d572466b98..db51ed95c5 100644
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -2921,6 +2921,7 @@ const (
 	OpAtomicOr8Variant
 	OpAtomicOr32Variant
 	OpClobber
+	OpClobberReg
 )
 
 var opcodeTable = [...]opInfo{
@@ -36373,6 +36374,11 @@ var opcodeTable = [...]opInfo{
 		symEffect: SymNone,
 		generic:   true,
 	},
+	{
+		name:    "ClobberReg",
+		argLen:  0,
+		generic: true,
+	},
 }
 
 func (o Op) Asm() obj.As          { return opcodeTable[o].asm }
diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go
index 42df8387e4..1baff184b0 100644
--- a/src/cmd/compile/internal/ssa/regalloc.go
+++ b/src/cmd/compile/internal/ssa/regalloc.go
@@ -114,6 +114,7 @@
 package ssa
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/objabi"
@@ -301,6 +302,9 @@ type regAllocState struct {
 
 	// blockOrder[b.ID] corresponds to the index of block b in visitOrder.
 	blockOrder []int32
+
+	// whether to insert instructions that clobber dead registers at call sites
+	doClobber bool
 }
 
 type endReg struct {
@@ -339,6 +343,17 @@ func (s *regAllocState) freeRegs(m regMask) {
 	}
 }
 
+// clobberRegs inserts instructions that clobber registers listed in m.
+func (s *regAllocState) clobberRegs(m regMask) {
+	m &= s.allocatable & s.f.Config.gpRegMask // only integer register can contain pointers, only clobber them
+	for m != 0 {
+		r := pickReg(m)
+		m &^= 1 << r
+		x := s.curBlock.NewValue0(src.NoXPos, OpClobberReg, types.TypeVoid)
+		s.f.setHome(x, &s.registers[r])
+	}
+}
+
 // setOrig records that c's original value is the same as
 // v's original value.
 func (s *regAllocState) setOrig(c *Value, v *Value) {
@@ -700,6 +715,14 @@ func (s *regAllocState) init(f *Func) {
 			}
 		}
 	}
+
+	// The clobberdeadreg experiment inserts code to clobber dead registers
+	// at call sites.
+	// Ignore huge functions to avoid doing too much work.
+	if base.Flag.ClobberDeadReg && len(s.f.Blocks) <= 10000 {
+		// TODO: honor GOCLOBBERDEADHASH, or maybe GOSSAHASH.
+		s.doClobber = true
+	}
 }
 
 // Adds a use record for id at distance dist from the start of the block.
@@ -1314,6 +1337,9 @@ func (s *regAllocState) regalloc(f *Func) {
 			}
 			if len(regspec.inputs) == 0 && len(regspec.outputs) == 0 {
 				// No register allocation required (or none specified yet)
+				if s.doClobber && v.Op.IsCall() {
+					s.clobberRegs(regspec.clobbers)
+				}
 				s.freeRegs(regspec.clobbers)
 				b.Values = append(b.Values, v)
 				s.advanceUses(v)
@@ -1475,6 +1501,11 @@ func (s *regAllocState) regalloc(f *Func) {
 			}
 
 			// Dump any registers which will be clobbered
+			if s.doClobber && v.Op.IsCall() {
+				// clobber registers that are marked as clobber in regmask, but
+				// don't clobber inputs.
+				s.clobberRegs(regspec.clobbers &^ s.tmpused &^ s.nospill)
+			}
 			s.freeRegs(regspec.clobbers)
 			s.tmpused |= regspec.clobbers
 
diff --git a/src/cmd/compile/internal/test/clobberdead_test.go b/src/cmd/compile/internal/test/clobberdead_test.go
index 3e2aadcbf5..88b7d34623 100644
--- a/src/cmd/compile/internal/test/clobberdead_test.go
+++ b/src/cmd/compile/internal/test/clobberdead_test.go
@@ -20,7 +20,15 @@ func main() { fmt.Println("hello") }
 
 func TestClobberDead(t *testing.T) {
 	// Test that clobberdead mode generates correct program.
+	runHello(t, "-clobberdead")
+}
+
+func TestClobberDeadReg(t *testing.T) {
+	// Test that clobberdeadreg mode generates correct program.
+	runHello(t, "-clobberdeadreg")
+}
 
+func runHello(t *testing.T, flag string) {
 	if testing.Short() {
 		// This test rebuilds the runtime with a special flag, which
 		// takes a while.
@@ -36,7 +44,7 @@ func TestClobberDead(t *testing.T) {
 		t.Fatalf("write file failed: %v", err)
 	}
 
-	cmd := exec.Command(testenv.GoToolPath(t), "run", "-gcflags=all=-clobberdead", src)
+	cmd := exec.Command(testenv.GoToolPath(t), "run", "-gcflags=all="+flag, src)
 	out, err := cmd.CombinedOutput()
 	if err != nil {
 		t.Fatalf("go run failed: %v\n%s", err, out)
diff --git a/src/cmd/compile/internal/wasm/ssa.go b/src/cmd/compile/internal/wasm/ssa.go
index e4ef9d7c6a..904871b15f 100644
--- a/src/cmd/compile/internal/wasm/ssa.go
+++ b/src/cmd/compile/internal/wasm/ssa.go
@@ -190,6 +190,9 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p := s.Prog(storeOp(v.Type))
 		ssagen.AddrAuto(&p.To, v)
 
+	case ssa.OpClobber, ssa.OpClobberReg:
+		// TODO: implement for clobberdead experiment. Nop is ok for now.
+
 	default:
 		if v.Type.IsMemory() {
 			return
diff --git a/src/cmd/compile/internal/x86/ssa.go b/src/cmd/compile/internal/x86/ssa.go
index e8c92c0f00..a06fdbcb71 100644
--- a/src/cmd/compile/internal/x86/ssa.go
+++ b/src/cmd/compile/internal/x86/ssa.go
@@ -832,6 +832,8 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Type = obj.TYPE_MEM
 		p.To.Reg = x86.REG_SP
 		ssagen.AddAux(&p.To, v)
+	case ssa.OpClobberReg:
+		// TODO: implement for clobberdead experiment. Nop is ok for now.
 	default:
 		v.Fatalf("genValue not implemented: %s", v.LongString())
 	}
diff --git a/src/runtime/sys_darwin_amd64.s b/src/runtime/sys_darwin_amd64.s
index 0fe8c7e172..3e9eccf19e 100644
--- a/src/runtime/sys_darwin_amd64.s
+++ b/src/runtime/sys_darwin_amd64.s
@@ -434,7 +434,7 @@ TEXT runtime·fcntl_trampoline<ABIInternal>(SB),NOSPLIT,$0
 // mstart_stub is the first function executed on a new thread started by pthread_create.
 // It just does some low-level setup and then calls mstart.
 // Note: called with the C calling convention.
-TEXT runtime·mstart_stub(SB),NOSPLIT,$0
+TEXT runtime·mstart_stub<ABIInternal>(SB),NOSPLIT,$0
 	// DI points to the m.
 	// We are already on m's g0 stack.
 
diff --git a/test/codegen/clobberdeadreg.go b/test/codegen/clobberdeadreg.go
new file mode 100644
index 0000000000..026850afba
--- /dev/null
+++ b/test/codegen/clobberdeadreg.go
@@ -0,0 +1,33 @@
+// asmcheck -gcflags=-clobberdeadreg
+
+// +build amd64
+
+// Copyright 2021 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 codegen
+
+type S struct {
+	a, b, c, d, e, f int
+}
+
+func F(a, b, c int, d S) {
+	// -2401018187971961171 is 0xdeaddeaddeaddead
+	// amd64:`MOVQ\t\$-2401018187971961171, AX`, `MOVQ\t\$-2401018187971961171, BX`, `MOVQ\t\$-2401018187971961171, CX`
+	// amd64:`MOVQ\t\$-2401018187971961171, DX`, `MOVQ\t\$-2401018187971961171, SI`, `MOVQ\t\$-2401018187971961171, DI`
+	// amd64:`MOVQ\t\$-2401018187971961171, R8`, `MOVQ\t\$-2401018187971961171, R9`, `MOVQ\t\$-2401018187971961171, R10`
+	// amd64:`MOVQ\t\$-2401018187971961171, R11`, `MOVQ\t\$-2401018187971961171, R12`, `MOVQ\t\$-2401018187971961171, R13`
+	// amd64:-`MOVQ\t\$-2401018187971961171, BP` // frame pointer is not clobbered
+	StackArgsCall(a, b, c, d)
+	// amd64:`MOVQ\t\$-2401018187971961171, R12`, `MOVQ\t\$-2401018187971961171, R13`, `MOVQ\t\$-2401018187971961171, DX`
+	// amd64:-`MOVQ\t\$-2401018187971961171, AX`, -`MOVQ\t\$-2401018187971961171, R11` // register args are not clobbered
+	RegArgsCall(a, b, c, d)
+}
+
+//go:noinline
+func StackArgsCall(int, int, int, S) {}
+
+//go:noinline
+//go:registerparams
+func RegArgsCall(int, int, int, S) {}
-- 
GitLab


From e0fae78e1deeaae5bc3c6a8426ece37c62445bf4 Mon Sep 17 00:00:00 2001
From: Youfu Zhang <zhangyoufu@gmail.com>
Date: Tue, 23 Feb 2021 03:52:43 +0000
Subject: [PATCH 1177/2400] runtime: fix stack alignment for Windows amd64 lib
 entry

Windows amd64 calling convention requires 16-bytes aligned
stack pointer. Before this patch, the real frame size is
0x48 (frame size) + 0x10 (frame pointer & return address),
which does not satisfy the alignment requirement.

_cgo_sys_thread_create eventually calls NtCreateThread,
which receives a pointer to a ThreadContext structure
allocated from (mis-aligned) stack, and may fail with
STATUS_DATATYPE_MISALIGNMENT on some implementations.

BP is saved/restored by prolog/epilog.
AX, CX, DX are volatile, no need to save and restore.

Fixes #41075

Change-Id: I01c0a22b4bf3b4cfdebf4df587445aa46c667973
GitHub-Last-Rev: 15d2bd740e3e61c9753b3e1b574fdb5da538459c
GitHub-Pull-Request: golang/go#44524
Reviewed-on: https://go-review.googlesource.com/c/go/+/295329
Trust: Alex Brainman <alex.brainman@gmail.com>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Alex Brainman <alex.brainman@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Christopher Nelson <nadiasvertex@gmail.com>
---
 src/runtime/rt0_windows_amd64.s | 14 +-------------
 1 file changed, 1 insertion(+), 13 deletions(-)

diff --git a/src/runtime/rt0_windows_amd64.s b/src/runtime/rt0_windows_amd64.s
index 345e141802..e60bf4c86d 100644
--- a/src/runtime/rt0_windows_amd64.s
+++ b/src/runtime/rt0_windows_amd64.s
@@ -16,24 +16,12 @@ TEXT _rt0_amd64_windows(SB),NOSPLIT,$-8
 // phase.
 // Leave space for four pointers on the stack as required
 // by the Windows amd64 calling convention.
-TEXT _rt0_amd64_windows_lib(SB),NOSPLIT,$0x48
-	MOVQ	BP, 0x20(SP)
-	MOVQ	BX, 0x28(SP)
-	MOVQ	AX, 0x30(SP)
-	MOVQ  CX, 0x38(SP)
-	MOVQ  DX, 0x40(SP)
-
+TEXT _rt0_amd64_windows_lib(SB),NOSPLIT,$0x20
 	// Create a new thread to do the runtime initialization and return.
 	MOVQ	_cgo_sys_thread_create(SB), AX
 	MOVQ	$_rt0_amd64_windows_lib_go(SB), CX
 	MOVQ	$0, DX
 	CALL	AX
-
-	MOVQ	0x20(SP), BP
-	MOVQ	0x28(SP), BX
-	MOVQ	0x30(SP), AX
-	MOVQ	0x38(SP), CX
-	MOVQ	0x40(SP), DX
 	RET
 
 TEXT _rt0_amd64_windows_lib_go(SB),NOSPLIT,$0
-- 
GitLab


From d8394bfc7fa728da9654f5e902df03a29d2a03ca Mon Sep 17 00:00:00 2001
From: eric fang <eric.fang@arm.com>
Date: Mon, 15 Mar 2021 06:55:37 +0000
Subject: [PATCH 1178/2400] cmd/internal/obj/arm64: mark functions with small
 stacks NOSPLIT
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This change omits the stack check on arm64 when the size of a stack
frame is less than obj.StackSmall.

The effect is not very significant, because CL 92040 has set the leaf
function with a framesize of 0 to NOFRAME, which makes the code
prologue on arm64 much closer to other architectures. But it is not
without effect, for example, it is effective for std library functions
such as runtime.usleep, fmt.isSpace, etc. Since this CL is very simple,
I think this optimization is worthwhile.

compilecmp results on linux/arm64:
name                      old time/op       new time/op       delta
Template                        284ms ± 1%        283ms ± 1%  -0.29%  (p=0.000 n=50+50)
Unicode                         125ms ± 2%        125ms ± 1%    ~     (p=0.445 n=49+49)
GoTypes                         1.70s ± 1%        1.69s ± 1%  -0.36%  (p=0.000 n=50+50)
Compiler                        124ms ± 1%        124ms ± 1%  -0.31%  (p=0.003 n=48+48)
SSA                             12.7s ± 1%        12.7s ± 1%    ~     (p=0.117 n=50+50)
Flate                           172ms ± 1%        171ms ± 1%  -0.55%  (p=0.000 n=50+50)
GoParser                        265ms ± 1%        264ms ± 1%  -0.23%  (p=0.000 n=47+48)
Reflect                         653ms ± 1%        646ms ± 1%  -1.12%  (p=0.000 n=48+50)
Tar                             246ms ± 1%        245ms ± 1%  -0.41%  (p=0.000 n=46+47)
XML                             328ms ± 1%        327ms ± 1%  -0.18%  (p=0.020 n=46+50)
LinkCompiler                    599ms ± 1%        598ms ± 1%    ~     (p=0.237 n=50+49)
ExternalLinkCompiler            1.87s ± 1%        1.87s ± 1%  -0.18%  (p=0.000 n=50+50)
LinkWithoutDebugCompiler        365ms ± 1%        364ms ± 2%    ~     (p=0.131 n=50+50)
[Geo mean]                      490ms             488ms       -0.32%

name                      old alloc/op      new alloc/op      delta
Template                       38.8MB ± 1%       38.8MB ± 1%  +0.16%  (p=0.013 n=47+49)
Unicode                        28.4MB ± 0%       28.4MB ± 0%    ~     (p=0.512 n=46+44)
GoTypes                         169MB ± 1%        169MB ± 1%    ~     (p=0.628 n=50+50)
Compiler                       23.2MB ± 1%       23.2MB ± 1%    ~     (p=0.424 n=46+44)
SSA                            1.55GB ± 0%       1.55GB ± 0%    ~     (p=0.603 n=48+50)
Flate                          23.7MB ± 1%       23.8MB ± 1%    ~     (p=0.797 n=50+50)
GoParser                       35.3MB ± 1%       35.3MB ± 1%    ~     (p=0.932 n=49+49)
Reflect                        85.0MB ± 0%       84.9MB ± 0%  -0.05%  (p=0.038 n=45+40)
Tar                            34.4MB ± 1%       34.5MB ± 1%    ~     (p=0.288 n=50+50)
XML                            43.8MB ± 2%       43.9MB ± 2%    ~     (p=0.798 n=46+49)
LinkCompiler                    136MB ± 0%        136MB ± 0%    ~     (p=0.750 n=50+50)
ExternalLinkCompiler            127MB ± 0%        127MB ± 0%    ~     (p=0.852 n=50+50)
LinkWithoutDebugCompiler       84.1MB ± 0%       84.1MB ± 0%    ~     (p=0.890 n=50+50)
[Geo mean]                     70.4MB            70.4MB       +0.01%

file      before    after     Δ       %
addr2line 4006004   4006012   +8      +0.000%
asm       4936863   4936919   +56     +0.001%
buildid   2594947   2594859   -88     -0.003%
cgo       4399702   4399806   +104    +0.002%
compile   22233139  22233107  -32     -0.000%
cover     4443681   4443785   +104    +0.002%
dist      3365902   3365806   -96     -0.003%
doc       3776175   3776231   +56     +0.001%
fix       3218624   3218552   -72     -0.002%
nm        3923345   3923329   -16     -0.000%
objdump   4295473   4295673   +200    +0.005%
pack      2390561   2390497   -64     -0.003%
pprof     12866419  12866275  -144    -0.001%
test2json 2587113   2587129   +16     +0.001%
trace     9609814   9609710   -104    -0.001%
vet       6790272   6791048   +776    +0.011%
total     106832751 106833455 +704    +0.001%

Updates #13379 (for arm64)

Change-Id: I07664ab0b978c66c0b18b8482222e9ba3772290d
Reviewed-on: https://go-review.googlesource.com/c/go/+/302853
Reviewed-by: eric fang <eric.fang@arm.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: eric fang <eric.fang@arm.com>
Run-TryBot: eric fang <eric.fang@arm.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/internal/obj/arm64/obj7.go | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/cmd/internal/obj/arm64/obj7.go b/src/cmd/internal/obj/arm64/obj7.go
index 425cb88f7e..bed21dbe53 100644
--- a/src/cmd/internal/obj/arm64/obj7.go
+++ b/src/cmd/internal/obj/arm64/obj7.go
@@ -539,6 +539,12 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 				}
 			}
 
+			if p.Mark&LEAF != 0 && c.autosize < objabi.StackSmall {
+				// A leaf function with a small stack can be marked
+				// NOSPLIT, avoiding a stack check.
+				p.From.Sym.Set(obj.AttrNoSplit, true)
+			}
+
 			if !p.From.Sym.NoSplit() {
 				p = c.stacksplit(p, c.autosize) // emit split check
 			}
-- 
GitLab


From e838c76a6ea99007b872669b06590a41278f6188 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 19 Mar 2021 15:55:30 -0400
Subject: [PATCH 1179/2400] cmd/go/internal/modload: remove
 go116EnableNarrowAll constant

This constant existed in case there was a serious problem with the
change to the "all" pattern in Go 1.16 (CL 240623), so that we could
roll back the change in behavior by just flipping the constant without
introducing merge conflicts elsewhere.

Go 1.16 has been out for a while and the new "all" behavior seems fine,
so we can jettison this feature flag.

For #36460

Change-Id: Ic2730edcee81514d56c7086e11542468eb63c84a
Reviewed-on: https://go-review.googlesource.com/c/go/+/303431
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modload/modfile.go | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/cmd/go/internal/modload/modfile.go b/src/cmd/go/internal/modload/modfile.go
index 2afa831583..6cbad46c4d 100644
--- a/src/cmd/go/internal/modload/modfile.go
+++ b/src/cmd/go/internal/modload/modfile.go
@@ -29,7 +29,6 @@ import (
 // module-module "all" pattern no longer closes over the dependencies of
 // tests outside of the main module.
 const narrowAllVersionV = "v1.16"
-const go116EnableNarrowAll = true
 
 var modFile *modfile.File
 
@@ -300,9 +299,6 @@ func indexModFile(data []byte, modFile *modfile.File, needsFix bool) *modFileInd
 // (Otherwise — as in Go 1.16+ — the "all" pattern includes only the packages
 // transitively *imported by* the packages and tests in the main module.)
 func (i *modFileIndex) allPatternClosesOverTests() bool {
-	if !go116EnableNarrowAll {
-		return true
-	}
 	if i != nil && semver.Compare(i.goVersionV, narrowAllVersionV) < 0 {
 		// The module explicitly predates the change in "all" for lazy loading, so
 		// continue to use the older interpretation. (If i == nil, we not in any
-- 
GitLab


From bd8b3fe5be9e9a5a2579c013451c07d53b827c56 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Daniel=20Mart=C3=AD?= <mvdan@mvdan.cc>
Date: Thu, 31 Dec 2020 12:41:53 +0000
Subject: [PATCH 1180/2400] cmd/compile: make no-op rewrite funcs smaller
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This doesn't change any behavior, but should help the compiler realise
that these funcs really do nothing at all.

Change-Id: Ib26c02ef264691acac983538ec300f91d6ff98db
Reviewed-on: https://go-review.googlesource.com/c/go/+/280314
Trust: Daniel Martí <mvdan@mvdan.cc>
Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/ssa/gen/rulegen.go           | 9 +++++++--
 src/cmd/compile/internal/ssa/rewrite386splitload.go   | 2 --
 src/cmd/compile/internal/ssa/rewriteAMD64splitload.go | 2 --
 src/cmd/compile/internal/ssa/rewriteWasm.go           | 2 --
 src/cmd/compile/internal/ssa/rewritedec.go            | 2 --
 src/cmd/compile/internal/ssa/rewritedec64.go          | 2 --
 6 files changed, 7 insertions(+), 12 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go
index 6388aab362..a3ce726dc3 100644
--- a/src/cmd/compile/internal/ssa/gen/rulegen.go
+++ b/src/cmd/compile/internal/ssa/gen/rulegen.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build gen
 // +build gen
 
 // This program generates Go code that applies rewrite rules to a Value.
@@ -194,7 +195,9 @@ func genRulesSuffix(arch arch, suff string) {
 		swc.add(stmtf("return rewriteValue%s%s_%s(v)", arch.name, suff, op))
 		sw.add(swc)
 	}
-	fn.add(sw)
+	if len(sw.List) > 0 { // skip if empty
+		fn.add(sw)
+	}
 	fn.add(stmtf("return false"))
 	genFile.add(fn)
 
@@ -264,7 +267,9 @@ func genRulesSuffix(arch arch, suff string) {
 		}
 		sw.add(swc)
 	}
-	fn.add(sw)
+	if len(sw.List) > 0 { // skip if empty
+		fn.add(sw)
+	}
 	fn.add(stmtf("return false"))
 	genFile.add(fn)
 
diff --git a/src/cmd/compile/internal/ssa/rewrite386splitload.go b/src/cmd/compile/internal/ssa/rewrite386splitload.go
index 90b5df8ae0..670e7f4f8f 100644
--- a/src/cmd/compile/internal/ssa/rewrite386splitload.go
+++ b/src/cmd/compile/internal/ssa/rewrite386splitload.go
@@ -156,7 +156,5 @@ func rewriteValue386splitload_Op386CMPWload(v *Value) bool {
 	}
 }
 func rewriteBlock386splitload(b *Block) bool {
-	switch b.Kind {
-	}
 	return false
 }
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64splitload.go b/src/cmd/compile/internal/ssa/rewriteAMD64splitload.go
index 1b8680c052..ae50aaa466 100644
--- a/src/cmd/compile/internal/ssa/rewriteAMD64splitload.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64splitload.go
@@ -847,7 +847,5 @@ func rewriteValueAMD64splitload_OpAMD64CMPWloadidx2(v *Value) bool {
 	}
 }
 func rewriteBlockAMD64splitload(b *Block) bool {
-	switch b.Kind {
-	}
 	return false
 }
diff --git a/src/cmd/compile/internal/ssa/rewriteWasm.go b/src/cmd/compile/internal/ssa/rewriteWasm.go
index 7258bc4f8e..6efcdfe371 100644
--- a/src/cmd/compile/internal/ssa/rewriteWasm.go
+++ b/src/cmd/compile/internal/ssa/rewriteWasm.go
@@ -4902,7 +4902,5 @@ func rewriteValueWasm_OpZeroExt8to64(v *Value) bool {
 	}
 }
 func rewriteBlockWasm(b *Block) bool {
-	switch b.Kind {
-	}
 	return false
 }
diff --git a/src/cmd/compile/internal/ssa/rewritedec.go b/src/cmd/compile/internal/ssa/rewritedec.go
index e0fa9768d9..4b7db60551 100644
--- a/src/cmd/compile/internal/ssa/rewritedec.go
+++ b/src/cmd/compile/internal/ssa/rewritedec.go
@@ -409,7 +409,5 @@ func rewriteValuedec_OpStringPtr(v *Value) bool {
 	return false
 }
 func rewriteBlockdec(b *Block) bool {
-	switch b.Kind {
-	}
 	return false
 }
diff --git a/src/cmd/compile/internal/ssa/rewritedec64.go b/src/cmd/compile/internal/ssa/rewritedec64.go
index 60b727f45f..7d9656a4c8 100644
--- a/src/cmd/compile/internal/ssa/rewritedec64.go
+++ b/src/cmd/compile/internal/ssa/rewritedec64.go
@@ -2458,7 +2458,5 @@ func rewriteValuedec64_OpZeroExt8to64(v *Value) bool {
 	}
 }
 func rewriteBlockdec64(b *Block) bool {
-	switch b.Kind {
-	}
 	return false
 }
-- 
GitLab


From 5437b5a24ba52c06d7ff627f01ed1876558959d2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Daniel=20Mart=C3=AD?= <mvdan@mvdan.cc>
Date: Mon, 22 Mar 2021 11:35:02 +0100
Subject: [PATCH 1181/2400] cmd/compile: disallow rewrite rules from declaring
 reserved names
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

If I change a rule in ARM64.rules to use the variable name "b" in a
conflicting way, rulegen would previously not complain, and the compiler
would later give a confusing error:

	$ go run *.go && go build cmd/compile/internal/ssa
	# cmd/compile/internal/ssa
	../rewriteARM64.go:24236:10: b.NewValue0 undefined (type int64 has no field or method NewValue0)

Make rulegen complain early about those cases. Sometimes they might
happen to be harmless, but in general they can easily cause confusion or
unintended effect due to shadowing.

After the change, with the same conflicting rule:

	$ go run *.go && go build cmd/compile/internal/ssa
	2021/03/22 11:31:49 rule ARM64.rules:495 uses the reserved name b
	exit status 1

Note that 24 existing rules were using reserved names. It seems like the
shadowing was harmless, as it wasn't causing typechecking issues nor did
it seem to cause unintended behavior when the rule rewrite code ran.

The bool values "b" were renamed "t", since that seems to have a
precedent in other rules and in the fmt package.

Sequential values like "a b c" were renamed to "x y z", since "b" is
reserved.

Finally, "typ" was renamed to "_typ", since there doesn't seem to be an
obviously better answer.

Passes all three of:

	$ GOARCH=amd64 go build -toolexec 'toolstash -cmp' -a std
	$ GOARCH=arm64 go build -toolexec 'toolstash -cmp' -a std
	$ GOARCH=mips64 go build -toolexec 'toolstash -cmp' -a std

Fixes #45154.

Change-Id: I1cce194dc7b477886a9c218c17973e996bcedccf
Reviewed-on: https://go-review.googlesource.com/c/go/+/303549
Trust: Daniel Martí <mvdan@mvdan.cc>
Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/ssa/gen/ARM.rules    |   2 +-
 src/cmd/compile/internal/ssa/gen/ARM64.rules  |   2 +-
 src/cmd/compile/internal/ssa/gen/MIPS.rules   |   2 +-
 src/cmd/compile/internal/ssa/gen/MIPS64.rules |   2 +-
 src/cmd/compile/internal/ssa/gen/PPC64.rules  |   2 +-
 src/cmd/compile/internal/ssa/gen/S390X.rules  |   2 +-
 .../compile/internal/ssa/gen/generic.rules    |  36 ++--
 src/cmd/compile/internal/ssa/gen/rulegen.go   |  64 ++++---
 src/cmd/compile/internal/ssa/rewriteARM.go    |   8 +-
 src/cmd/compile/internal/ssa/rewriteARM64.go  |   8 +-
 src/cmd/compile/internal/ssa/rewriteMIPS.go   |   8 +-
 src/cmd/compile/internal/ssa/rewriteMIPS64.go |   8 +-
 src/cmd/compile/internal/ssa/rewritePPC64.go  |   8 +-
 src/cmd/compile/internal/ssa/rewriteS390X.go  |   8 +-
 .../compile/internal/ssa/rewritegeneric.go    | 170 +++++++++---------
 15 files changed, 177 insertions(+), 153 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/gen/ARM.rules b/src/cmd/compile/internal/ssa/gen/ARM.rules
index f46f4238f7..5c6438a986 100644
--- a/src/cmd/compile/internal/ssa/gen/ARM.rules
+++ b/src/cmd/compile/internal/ssa/gen/ARM.rules
@@ -173,7 +173,7 @@
 (Const(8|16|32) [val]) => (MOVWconst [int32(val)])
 (Const(32|64)F [val]) => (MOV(F|D)const [float64(val)])
 (ConstNil) => (MOVWconst [0])
-(ConstBool [b]) => (MOVWconst [b2i32(b)])
+(ConstBool [t]) => (MOVWconst [b2i32(t)])
 
 // truncations
 // Because we ignore high parts of registers, truncates are just copies.
diff --git a/src/cmd/compile/internal/ssa/gen/ARM64.rules b/src/cmd/compile/internal/ssa/gen/ARM64.rules
index 6f30c11bd1..7f9f8298de 100644
--- a/src/cmd/compile/internal/ssa/gen/ARM64.rules
+++ b/src/cmd/compile/internal/ssa/gen/ARM64.rules
@@ -198,7 +198,7 @@
 (Const(64|32|16|8) [val]) => (MOVDconst [int64(val)])
 (Const(32F|64F) [val]) => (FMOV(S|D)const [float64(val)])
 (ConstNil) => (MOVDconst [0])
-(ConstBool [b]) => (MOVDconst [b2i(b)])
+(ConstBool [t]) => (MOVDconst [b2i(t)])
 
 (Slicemask <t> x) => (SRAconst (NEG <t> x) [63])
 
diff --git a/src/cmd/compile/internal/ssa/gen/MIPS.rules b/src/cmd/compile/internal/ssa/gen/MIPS.rules
index 6b59555cbe..4ac9668ea9 100644
--- a/src/cmd/compile/internal/ssa/gen/MIPS.rules
+++ b/src/cmd/compile/internal/ssa/gen/MIPS.rules
@@ -144,7 +144,7 @@
 (Const(32|16|8) [val]) => (MOVWconst [int32(val)])
 (Const(32|64)F ...) => (MOV(F|D)const ...)
 (ConstNil) => (MOVWconst [0])
-(ConstBool [b]) => (MOVWconst [b2i32(b)])
+(ConstBool [t]) => (MOVWconst [b2i32(t)])
 
 // truncations
 // Because we ignore high parts of registers, truncates are just copies.
diff --git a/src/cmd/compile/internal/ssa/gen/MIPS64.rules b/src/cmd/compile/internal/ssa/gen/MIPS64.rules
index bb91dcd5ee..fd04a6c3a8 100644
--- a/src/cmd/compile/internal/ssa/gen/MIPS64.rules
+++ b/src/cmd/compile/internal/ssa/gen/MIPS64.rules
@@ -134,7 +134,7 @@
 (Const(64|32|16|8) [val]) => (MOVVconst [int64(val)])
 (Const(32|64)F [val]) => (MOV(F|D)const [float64(val)])
 (ConstNil) => (MOVVconst [0])
-(ConstBool [b]) => (MOVVconst [int64(b2i(b))])
+(ConstBool [t]) => (MOVVconst [int64(b2i(t))])
 
 (Slicemask <t> x) => (SRAVconst (NEGV <t> x) [63])
 
diff --git a/src/cmd/compile/internal/ssa/gen/PPC64.rules b/src/cmd/compile/internal/ssa/gen/PPC64.rules
index b618cde529..f83ff75761 100644
--- a/src/cmd/compile/internal/ssa/gen/PPC64.rules
+++ b/src/cmd/compile/internal/ssa/gen/PPC64.rules
@@ -101,7 +101,7 @@
 (Const(64|32|16|8) [val]) => (MOVDconst [int64(val)])
 (Const(32|64)F ...) => (FMOV(S|D)const ...)
 (ConstNil) => (MOVDconst [0])
-(ConstBool [b]) => (MOVDconst [b2i(b)])
+(ConstBool [t]) => (MOVDconst [b2i(t)])
 
 // Constant folding
 (FABS (FMOVDconst [x])) => (FMOVDconst [math.Abs(x)])
diff --git a/src/cmd/compile/internal/ssa/gen/S390X.rules b/src/cmd/compile/internal/ssa/gen/S390X.rules
index 0fdd231d71..88762f7045 100644
--- a/src/cmd/compile/internal/ssa/gen/S390X.rules
+++ b/src/cmd/compile/internal/ssa/gen/S390X.rules
@@ -428,7 +428,7 @@
 (Const(64|32|16|8) [val]) => (MOVDconst [int64(val)])
 (Const(32|64)F ...) => (FMOV(S|D)const ...)
 (ConstNil) => (MOVDconst [0])
-(ConstBool [b]) => (MOVDconst [b2i(b)])
+(ConstBool [t]) => (MOVDconst [b2i(t)])
 
 // Lowering calls
 (StaticCall ...) => (CALLstatic ...)
diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules
index 9dd20a7cfa..6b5fd99c7e 100644
--- a/src/cmd/compile/internal/ssa/gen/generic.rules
+++ b/src/cmd/compile/internal/ssa/gen/generic.rules
@@ -768,7 +768,7 @@
 	=> mem
 
 // Collapse OffPtr
-(OffPtr (OffPtr p [b]) [a]) => (OffPtr p [a+b])
+(OffPtr (OffPtr p [y]) [x]) => (OffPtr p [x+y])
 (OffPtr p [0]) && v.Type.Compare(p.Type) == types.CMPeq => p
 
 // indexing operations
@@ -847,7 +847,7 @@
             f0 mem))))
 
 // Putting struct{*byte} and similar into direct interfaces.
-(IMake typ (StructMake1 val)) => (IMake typ val)
+(IMake _typ (StructMake1 val)) => (IMake _typ val)
 (StructSelect [0] (IData x)) => (IData x)
 
 // un-SSAable values use mem->mem copies
@@ -869,7 +869,7 @@
 (Store dst (ArrayMake1 e) mem) => (Store {e.Type} dst e mem)
 
 // Putting [1]*byte and similar into direct interfaces.
-(IMake typ (ArrayMake1 val)) => (IMake typ val)
+(IMake _typ (ArrayMake1 val)) => (IMake _typ val)
 (ArraySelect [0] (IData x)) => (IData x)
 
 // string ops
@@ -1974,9 +1974,9 @@
 (Sqrt (Const64F [c])) && !math.IsNaN(math.Sqrt(c)) => (Const64F [math.Sqrt(c)])
 
 // for rewriting results of some late-expanded rewrites (below)
-(SelectN [0] (MakeResult a ___)) => a
-(SelectN [1] (MakeResult a b ___)) => b
-(SelectN [2] (MakeResult a b c ___)) => c
+(SelectN [0] (MakeResult x ___)) => x
+(SelectN [1] (MakeResult x y ___)) => y
+(SelectN [2] (MakeResult x y z ___)) => z
 
 // for late-expanded calls, recognize newobject and remove zeroing and nilchecks
 (Zero (SelectN [0] call:(StaticLECall _ _)) mem:(SelectN [1] call))
@@ -2013,18 +2013,18 @@
 // Evaluate constant address comparisons.
 (EqPtr  x x) => (ConstBool [true])
 (NeqPtr x x) => (ConstBool [false])
-(EqPtr  (Addr {a} _) (Addr {b} _)) => (ConstBool [a == b])
-(EqPtr  (Addr {a} _) (OffPtr [o] (Addr {b} _))) => (ConstBool [a == b && o == 0])
-(EqPtr  (OffPtr [o1] (Addr {a} _)) (OffPtr [o2] (Addr {b} _))) => (ConstBool [a == b && o1 == o2])
-(NeqPtr (Addr {a} _) (Addr {b} _)) => (ConstBool [a != b])
-(NeqPtr (Addr {a} _) (OffPtr [o] (Addr {b} _))) => (ConstBool [a != b || o != 0])
-(NeqPtr (OffPtr [o1] (Addr {a} _)) (OffPtr [o2] (Addr {b} _))) => (ConstBool [a != b || o1 != o2])
-(EqPtr  (LocalAddr {a} _ _) (LocalAddr {b} _ _)) => (ConstBool [a == b])
-(EqPtr  (LocalAddr {a} _ _) (OffPtr [o] (LocalAddr {b} _ _))) => (ConstBool [a == b && o == 0])
-(EqPtr  (OffPtr [o1] (LocalAddr {a} _ _)) (OffPtr [o2] (LocalAddr {b} _ _))) => (ConstBool [a == b && o1 == o2])
-(NeqPtr (LocalAddr {a} _ _) (LocalAddr {b} _ _)) => (ConstBool [a != b])
-(NeqPtr (LocalAddr {a} _ _) (OffPtr [o] (LocalAddr {b} _ _))) => (ConstBool [a != b || o != 0])
-(NeqPtr (OffPtr [o1] (LocalAddr {a} _ _)) (OffPtr [o2] (LocalAddr {b} _ _))) => (ConstBool [a != b || o1 != o2])
+(EqPtr  (Addr {x} _) (Addr {y} _)) => (ConstBool [x == y])
+(EqPtr  (Addr {x} _) (OffPtr [o] (Addr {y} _))) => (ConstBool [x == y && o == 0])
+(EqPtr  (OffPtr [o1] (Addr {x} _)) (OffPtr [o2] (Addr {y} _))) => (ConstBool [x == y && o1 == o2])
+(NeqPtr (Addr {x} _) (Addr {y} _)) => (ConstBool [x != y])
+(NeqPtr (Addr {x} _) (OffPtr [o] (Addr {y} _))) => (ConstBool [x != y || o != 0])
+(NeqPtr (OffPtr [o1] (Addr {x} _)) (OffPtr [o2] (Addr {y} _))) => (ConstBool [x != y || o1 != o2])
+(EqPtr  (LocalAddr {x} _ _) (LocalAddr {y} _ _)) => (ConstBool [x == y])
+(EqPtr  (LocalAddr {x} _ _) (OffPtr [o] (LocalAddr {y} _ _))) => (ConstBool [x == y && o == 0])
+(EqPtr  (OffPtr [o1] (LocalAddr {x} _ _)) (OffPtr [o2] (LocalAddr {y} _ _))) => (ConstBool [x == y && o1 == o2])
+(NeqPtr (LocalAddr {x} _ _) (LocalAddr {y} _ _)) => (ConstBool [x != y])
+(NeqPtr (LocalAddr {x} _ _) (OffPtr [o] (LocalAddr {y} _ _))) => (ConstBool [x != y || o != 0])
+(NeqPtr (OffPtr [o1] (LocalAddr {x} _ _)) (OffPtr [o2] (LocalAddr {y} _ _))) => (ConstBool [x != y || o1 != o2])
 (EqPtr  (OffPtr [o1] p1) p2) && isSamePtr(p1, p2) => (ConstBool [o1 == 0])
 (NeqPtr (OffPtr [o1] p1) p2) && isSamePtr(p1, p2) => (ConstBool [o1 != 0])
 (EqPtr  (OffPtr [o1] p1) (OffPtr [o2] p2)) && isSamePtr(p1, p2) => (ConstBool [o1 == o2])
diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go
index a3ce726dc3..fd672b2f74 100644
--- a/src/cmd/compile/internal/ssa/gen/rulegen.go
+++ b/src/cmd/compile/internal/ssa/gen/rulegen.go
@@ -218,10 +218,10 @@ func genRulesSuffix(arch arch, suff string) {
 			Suffix: fmt.Sprintf("_%s", op),
 			ArgLen: opByName(arch, op).argLength,
 		}
-		fn.add(declf("b", "v.Block"))
-		fn.add(declf("config", "b.Func.Config"))
-		fn.add(declf("fe", "b.Func.fe"))
-		fn.add(declf("typ", "&b.Func.Config.Types"))
+		fn.add(declReserved("b", "v.Block"))
+		fn.add(declReserved("config", "b.Func.Config"))
+		fn.add(declReserved("fe", "b.Func.fe"))
+		fn.add(declReserved("typ", "&b.Func.Config.Types"))
 		for _, rule := range rules {
 			if rr != nil && !rr.CanFail {
 				log.Fatalf("unconditional rule %s is followed by other rules", rr.Match)
@@ -250,8 +250,8 @@ func genRulesSuffix(arch arch, suff string) {
 	// Generate block rewrite function. There are only a few block types
 	// so we can make this one function with a switch.
 	fn = &Func{Kind: "Block"}
-	fn.add(declf("config", "b.Func.Config"))
-	fn.add(declf("typ", "&b.Func.Config.Types"))
+	fn.add(declReserved("config", "b.Func.Config"))
+	fn.add(declReserved("typ", "&b.Func.Config.Types"))
 
 	sw = &Switch{Expr: exprf("b.Kind")}
 	ops = ops[:0]
@@ -828,12 +828,36 @@ func stmtf(format string, a ...interface{}) Statement {
 	return file.Decls[0].(*ast.FuncDecl).Body.List[0]
 }
 
-// declf constructs a simple "name := value" declaration, using exprf for its
-// value.
-func declf(name, format string, a ...interface{}) *Declare {
+var reservedNames = map[string]bool{
+	"v":      true, // Values[i], etc
+	"b":      true, // v.Block
+	"config": true, // b.Func.Config
+	"fe":     true, // b.Func.fe
+	"typ":    true, // &b.Func.Config.Types
+}
+
+// declf constructs a simple "name := value" declaration,
+// using exprf for its value.
+//
+// name must not be one of reservedNames.
+// This helps prevent unintended shadowing and name clashes.
+// To declare a reserved name, use declReserved.
+func declf(loc, name, format string, a ...interface{}) *Declare {
+	if reservedNames[name] {
+		log.Fatalf("rule %s uses the reserved name %s", loc, name)
+	}
 	return &Declare{name, exprf(format, a...)}
 }
 
+// declReserved is like declf, but the name must be one of reservedNames.
+// Calls to declReserved should generally be static and top-level.
+func declReserved(name, value string) *Declare {
+	if !reservedNames[name] {
+		panic(fmt.Sprintf("declReserved call does not use a reserved name: %q", name))
+	}
+	return &Declare{name, exprf(value)}
+}
+
 // breakf constructs a simple "if cond { break }" statement, using exprf for its
 // condition.
 func breakf(format string, a ...interface{}) *CondBreak {
@@ -858,7 +882,7 @@ func genBlockRewrite(rule Rule, arch arch, data blockData) *RuleRewrite {
 			if vname == "" {
 				vname = fmt.Sprintf("v_%v", i)
 			}
-			rr.add(declf(vname, cname))
+			rr.add(declf(rr.Loc, vname, cname))
 			p, op := genMatch0(rr, arch, expr, vname, nil, false) // TODO: pass non-nil cnt?
 			if op != "" {
 				check := fmt.Sprintf("%s.Op == %s", cname, op)
@@ -873,7 +897,7 @@ func genBlockRewrite(rule Rule, arch arch, data blockData) *RuleRewrite {
 			}
 			pos[i] = p
 		} else {
-			rr.add(declf(arg, cname))
+			rr.add(declf(rr.Loc, arg, cname))
 			pos[i] = arg + ".Pos"
 		}
 	}
@@ -893,7 +917,7 @@ func genBlockRewrite(rule Rule, arch arch, data blockData) *RuleRewrite {
 		if !token.IsIdentifier(e.name) || rr.declared(e.name) {
 			rr.add(breakf("%sTo%s(b.%s) != %s", unTitle(e.field), title(e.dclType), e.field, e.name))
 		} else {
-			rr.add(declf(e.name, "%sTo%s(b.%s)", unTitle(e.field), title(e.dclType), e.field))
+			rr.add(declf(rr.Loc, e.name, "%sTo%s(b.%s)", unTitle(e.field), title(e.dclType), e.field))
 		}
 	}
 	if rr.Cond != "" {
@@ -1043,11 +1067,11 @@ func genMatch0(rr *RuleRewrite, arch arch, match, v string, cnt map[string]int,
 		} else {
 			switch e.field {
 			case "Aux":
-				rr.add(declf(e.name, "auxTo%s(%s.%s)", title(e.dclType), v, e.field))
+				rr.add(declf(rr.Loc, e.name, "auxTo%s(%s.%s)", title(e.dclType), v, e.field))
 			case "AuxInt":
-				rr.add(declf(e.name, "auxIntTo%s(%s.%s)", title(e.dclType), v, e.field))
+				rr.add(declf(rr.Loc, e.name, "auxIntTo%s(%s.%s)", title(e.dclType), v, e.field))
 			case "Type":
-				rr.add(declf(e.name, "%s.%s", v, e.field))
+				rr.add(declf(rr.Loc, e.name, "%s.%s", v, e.field))
 			}
 		}
 	}
@@ -1077,7 +1101,7 @@ func genMatch0(rr *RuleRewrite, arch arch, match, v string, cnt map[string]int,
 				continue
 			}
 			if !rr.declared(a) && token.IsIdentifier(a) && !(commutative && len(args) == 2) {
-				rr.add(declf(a, "%s.Args[%d]", v, n))
+				rr.add(declf(rr.Loc, a, "%s.Args[%d]", v, n))
 				// delete the last argument so it is not reprocessed
 				args = args[:n]
 			} else {
@@ -1089,7 +1113,7 @@ func genMatch0(rr *RuleRewrite, arch arch, match, v string, cnt map[string]int,
 	if commutative && !pregenTop {
 		for i := 0; i <= 1; i++ {
 			vname := fmt.Sprintf("%s_%d", v, i)
-			rr.add(declf(vname, "%s.Args[%d]", v, i))
+			rr.add(declf(rr.Loc, vname, "%s.Args[%d]", v, i))
 		}
 	}
 	if commutative {
@@ -1116,7 +1140,7 @@ func genMatch0(rr *RuleRewrite, arch arch, match, v string, cnt map[string]int,
 				rr.add(breakf("%s != %s", arg, rhs))
 			} else {
 				if arg != rhs {
-					rr.add(declf(arg, "%s", rhs))
+					rr.add(declf(rr.Loc, arg, "%s", rhs))
 				}
 			}
 			continue
@@ -1131,7 +1155,7 @@ func genMatch0(rr *RuleRewrite, arch arch, match, v string, cnt map[string]int,
 		}
 
 		if argname != rhs {
-			rr.add(declf(argname, "%s", rhs))
+			rr.add(declf(rr.Loc, argname, "%s", rhs))
 		}
 		bexpr := exprf("%s.Op != addLater", argname)
 		rr.add(&CondBreak{Cond: bexpr})
@@ -1208,7 +1232,7 @@ func genResult0(rr *RuleRewrite, arch arch, result string, top, move bool, pos s
 			v = resname
 		}
 		rr.Alloc++
-		rr.add(declf(v, "b.NewValue0(%s, Op%s%s, %s)", pos, oparch, op.name, typ))
+		rr.add(declf(rr.Loc, v, "b.NewValue0(%s, Op%s%s, %s)", pos, oparch, op.name, typ))
 		if move && top {
 			// Rewrite original into a copy
 			rr.add(stmtf("v.copyOf(%s)", v))
diff --git a/src/cmd/compile/internal/ssa/rewriteARM.go b/src/cmd/compile/internal/ssa/rewriteARM.go
index ed1f85e340..175bbc3e7e 100644
--- a/src/cmd/compile/internal/ssa/rewriteARM.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM.go
@@ -13031,12 +13031,12 @@ func rewriteValueARM_OpConst8(v *Value) bool {
 	}
 }
 func rewriteValueARM_OpConstBool(v *Value) bool {
-	// match: (ConstBool [b])
-	// result: (MOVWconst [b2i32(b)])
+	// match: (ConstBool [t])
+	// result: (MOVWconst [b2i32(t)])
 	for {
-		b := auxIntToBool(v.AuxInt)
+		t := auxIntToBool(v.AuxInt)
 		v.reset(OpARMMOVWconst)
-		v.AuxInt = int32ToAuxInt(b2i32(b))
+		v.AuxInt = int32ToAuxInt(b2i32(t))
 		return true
 	}
 }
diff --git a/src/cmd/compile/internal/ssa/rewriteARM64.go b/src/cmd/compile/internal/ssa/rewriteARM64.go
index da80ad6fca..eb650b6a50 100644
--- a/src/cmd/compile/internal/ssa/rewriteARM64.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM64.go
@@ -22253,12 +22253,12 @@ func rewriteValueARM64_OpConst8(v *Value) bool {
 	}
 }
 func rewriteValueARM64_OpConstBool(v *Value) bool {
-	// match: (ConstBool [b])
-	// result: (MOVDconst [b2i(b)])
+	// match: (ConstBool [t])
+	// result: (MOVDconst [b2i(t)])
 	for {
-		b := auxIntToBool(v.AuxInt)
+		t := auxIntToBool(v.AuxInt)
 		v.reset(OpARM64MOVDconst)
-		v.AuxInt = int64ToAuxInt(b2i(b))
+		v.AuxInt = int64ToAuxInt(b2i(t))
 		return true
 	}
 }
diff --git a/src/cmd/compile/internal/ssa/rewriteMIPS.go b/src/cmd/compile/internal/ssa/rewriteMIPS.go
index fdf329cbd0..429369d631 100644
--- a/src/cmd/compile/internal/ssa/rewriteMIPS.go
+++ b/src/cmd/compile/internal/ssa/rewriteMIPS.go
@@ -872,12 +872,12 @@ func rewriteValueMIPS_OpConst8(v *Value) bool {
 	}
 }
 func rewriteValueMIPS_OpConstBool(v *Value) bool {
-	// match: (ConstBool [b])
-	// result: (MOVWconst [b2i32(b)])
+	// match: (ConstBool [t])
+	// result: (MOVWconst [b2i32(t)])
 	for {
-		b := auxIntToBool(v.AuxInt)
+		t := auxIntToBool(v.AuxInt)
 		v.reset(OpMIPSMOVWconst)
-		v.AuxInt = int32ToAuxInt(b2i32(b))
+		v.AuxInt = int32ToAuxInt(b2i32(t))
 		return true
 	}
 }
diff --git a/src/cmd/compile/internal/ssa/rewriteMIPS64.go b/src/cmd/compile/internal/ssa/rewriteMIPS64.go
index 79da4dfb72..772d7b66ef 100644
--- a/src/cmd/compile/internal/ssa/rewriteMIPS64.go
+++ b/src/cmd/compile/internal/ssa/rewriteMIPS64.go
@@ -835,12 +835,12 @@ func rewriteValueMIPS64_OpConst8(v *Value) bool {
 	}
 }
 func rewriteValueMIPS64_OpConstBool(v *Value) bool {
-	// match: (ConstBool [b])
-	// result: (MOVVconst [int64(b2i(b))])
+	// match: (ConstBool [t])
+	// result: (MOVVconst [int64(b2i(t))])
 	for {
-		b := auxIntToBool(v.AuxInt)
+		t := auxIntToBool(v.AuxInt)
 		v.reset(OpMIPS64MOVVconst)
-		v.AuxInt = int64ToAuxInt(int64(b2i(b)))
+		v.AuxInt = int64ToAuxInt(int64(b2i(t)))
 		return true
 	}
 }
diff --git a/src/cmd/compile/internal/ssa/rewritePPC64.go b/src/cmd/compile/internal/ssa/rewritePPC64.go
index a5bbc836cc..f181d433cc 100644
--- a/src/cmd/compile/internal/ssa/rewritePPC64.go
+++ b/src/cmd/compile/internal/ssa/rewritePPC64.go
@@ -1234,12 +1234,12 @@ func rewriteValuePPC64_OpConst8(v *Value) bool {
 	}
 }
 func rewriteValuePPC64_OpConstBool(v *Value) bool {
-	// match: (ConstBool [b])
-	// result: (MOVDconst [b2i(b)])
+	// match: (ConstBool [t])
+	// result: (MOVDconst [b2i(t)])
 	for {
-		b := auxIntToBool(v.AuxInt)
+		t := auxIntToBool(v.AuxInt)
 		v.reset(OpPPC64MOVDconst)
-		v.AuxInt = int64ToAuxInt(b2i(b))
+		v.AuxInt = int64ToAuxInt(b2i(t))
 		return true
 	}
 }
diff --git a/src/cmd/compile/internal/ssa/rewriteS390X.go b/src/cmd/compile/internal/ssa/rewriteS390X.go
index f02362a0d4..8b41d62c31 100644
--- a/src/cmd/compile/internal/ssa/rewriteS390X.go
+++ b/src/cmd/compile/internal/ssa/rewriteS390X.go
@@ -1321,12 +1321,12 @@ func rewriteValueS390X_OpConst8(v *Value) bool {
 	}
 }
 func rewriteValueS390X_OpConstBool(v *Value) bool {
-	// match: (ConstBool [b])
-	// result: (MOVDconst [b2i(b)])
+	// match: (ConstBool [t])
+	// result: (MOVDconst [b2i(t)])
 	for {
-		b := auxIntToBool(v.AuxInt)
+		t := auxIntToBool(v.AuxInt)
 		v.reset(OpS390XMOVDconst)
-		v.AuxInt = int64ToAuxInt(b2i(b))
+		v.AuxInt = int64ToAuxInt(b2i(t))
 		return true
 	}
 }
diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go
index 7e7cf458ff..535fc8916d 100644
--- a/src/cmd/compile/internal/ssa/rewritegeneric.go
+++ b/src/cmd/compile/internal/ssa/rewritegeneric.go
@@ -8152,32 +8152,32 @@ func rewriteValuegeneric_OpEqPtr(v *Value) bool {
 		v.AuxInt = boolToAuxInt(true)
 		return true
 	}
-	// match: (EqPtr (Addr {a} _) (Addr {b} _))
-	// result: (ConstBool [a == b])
+	// match: (EqPtr (Addr {x} _) (Addr {y} _))
+	// result: (ConstBool [x == y])
 	for {
 		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 			if v_0.Op != OpAddr {
 				continue
 			}
-			a := auxToSym(v_0.Aux)
+			x := auxToSym(v_0.Aux)
 			if v_1.Op != OpAddr {
 				continue
 			}
-			b := auxToSym(v_1.Aux)
+			y := auxToSym(v_1.Aux)
 			v.reset(OpConstBool)
-			v.AuxInt = boolToAuxInt(a == b)
+			v.AuxInt = boolToAuxInt(x == y)
 			return true
 		}
 		break
 	}
-	// match: (EqPtr (Addr {a} _) (OffPtr [o] (Addr {b} _)))
-	// result: (ConstBool [a == b && o == 0])
+	// match: (EqPtr (Addr {x} _) (OffPtr [o] (Addr {y} _)))
+	// result: (ConstBool [x == y && o == 0])
 	for {
 		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 			if v_0.Op != OpAddr {
 				continue
 			}
-			a := auxToSym(v_0.Aux)
+			x := auxToSym(v_0.Aux)
 			if v_1.Op != OpOffPtr {
 				continue
 			}
@@ -8186,15 +8186,15 @@ func rewriteValuegeneric_OpEqPtr(v *Value) bool {
 			if v_1_0.Op != OpAddr {
 				continue
 			}
-			b := auxToSym(v_1_0.Aux)
+			y := auxToSym(v_1_0.Aux)
 			v.reset(OpConstBool)
-			v.AuxInt = boolToAuxInt(a == b && o == 0)
+			v.AuxInt = boolToAuxInt(x == y && o == 0)
 			return true
 		}
 		break
 	}
-	// match: (EqPtr (OffPtr [o1] (Addr {a} _)) (OffPtr [o2] (Addr {b} _)))
-	// result: (ConstBool [a == b && o1 == o2])
+	// match: (EqPtr (OffPtr [o1] (Addr {x} _)) (OffPtr [o2] (Addr {y} _)))
+	// result: (ConstBool [x == y && o1 == o2])
 	for {
 		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 			if v_0.Op != OpOffPtr {
@@ -8205,7 +8205,7 @@ func rewriteValuegeneric_OpEqPtr(v *Value) bool {
 			if v_0_0.Op != OpAddr {
 				continue
 			}
-			a := auxToSym(v_0_0.Aux)
+			x := auxToSym(v_0_0.Aux)
 			if v_1.Op != OpOffPtr {
 				continue
 			}
@@ -8214,39 +8214,39 @@ func rewriteValuegeneric_OpEqPtr(v *Value) bool {
 			if v_1_0.Op != OpAddr {
 				continue
 			}
-			b := auxToSym(v_1_0.Aux)
+			y := auxToSym(v_1_0.Aux)
 			v.reset(OpConstBool)
-			v.AuxInt = boolToAuxInt(a == b && o1 == o2)
+			v.AuxInt = boolToAuxInt(x == y && o1 == o2)
 			return true
 		}
 		break
 	}
-	// match: (EqPtr (LocalAddr {a} _ _) (LocalAddr {b} _ _))
-	// result: (ConstBool [a == b])
+	// match: (EqPtr (LocalAddr {x} _ _) (LocalAddr {y} _ _))
+	// result: (ConstBool [x == y])
 	for {
 		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 			if v_0.Op != OpLocalAddr {
 				continue
 			}
-			a := auxToSym(v_0.Aux)
+			x := auxToSym(v_0.Aux)
 			if v_1.Op != OpLocalAddr {
 				continue
 			}
-			b := auxToSym(v_1.Aux)
+			y := auxToSym(v_1.Aux)
 			v.reset(OpConstBool)
-			v.AuxInt = boolToAuxInt(a == b)
+			v.AuxInt = boolToAuxInt(x == y)
 			return true
 		}
 		break
 	}
-	// match: (EqPtr (LocalAddr {a} _ _) (OffPtr [o] (LocalAddr {b} _ _)))
-	// result: (ConstBool [a == b && o == 0])
+	// match: (EqPtr (LocalAddr {x} _ _) (OffPtr [o] (LocalAddr {y} _ _)))
+	// result: (ConstBool [x == y && o == 0])
 	for {
 		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 			if v_0.Op != OpLocalAddr {
 				continue
 			}
-			a := auxToSym(v_0.Aux)
+			x := auxToSym(v_0.Aux)
 			if v_1.Op != OpOffPtr {
 				continue
 			}
@@ -8255,15 +8255,15 @@ func rewriteValuegeneric_OpEqPtr(v *Value) bool {
 			if v_1_0.Op != OpLocalAddr {
 				continue
 			}
-			b := auxToSym(v_1_0.Aux)
+			y := auxToSym(v_1_0.Aux)
 			v.reset(OpConstBool)
-			v.AuxInt = boolToAuxInt(a == b && o == 0)
+			v.AuxInt = boolToAuxInt(x == y && o == 0)
 			return true
 		}
 		break
 	}
-	// match: (EqPtr (OffPtr [o1] (LocalAddr {a} _ _)) (OffPtr [o2] (LocalAddr {b} _ _)))
-	// result: (ConstBool [a == b && o1 == o2])
+	// match: (EqPtr (OffPtr [o1] (LocalAddr {x} _ _)) (OffPtr [o2] (LocalAddr {y} _ _)))
+	// result: (ConstBool [x == y && o1 == o2])
 	for {
 		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 			if v_0.Op != OpOffPtr {
@@ -8274,7 +8274,7 @@ func rewriteValuegeneric_OpEqPtr(v *Value) bool {
 			if v_0_0.Op != OpLocalAddr {
 				continue
 			}
-			a := auxToSym(v_0_0.Aux)
+			x := auxToSym(v_0_0.Aux)
 			if v_1.Op != OpOffPtr {
 				continue
 			}
@@ -8283,9 +8283,9 @@ func rewriteValuegeneric_OpEqPtr(v *Value) bool {
 			if v_1_0.Op != OpLocalAddr {
 				continue
 			}
-			b := auxToSym(v_1_0.Aux)
+			y := auxToSym(v_1_0.Aux)
 			v.reset(OpConstBool)
-			v.AuxInt = boolToAuxInt(a == b && o1 == o2)
+			v.AuxInt = boolToAuxInt(x == y && o1 == o2)
 			return true
 		}
 		break
@@ -8532,28 +8532,28 @@ func rewriteValuegeneric_OpEqSlice(v *Value) bool {
 func rewriteValuegeneric_OpIMake(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
-	// match: (IMake typ (StructMake1 val))
-	// result: (IMake typ val)
+	// match: (IMake _typ (StructMake1 val))
+	// result: (IMake _typ val)
 	for {
-		typ := v_0
+		_typ := v_0
 		if v_1.Op != OpStructMake1 {
 			break
 		}
 		val := v_1.Args[0]
 		v.reset(OpIMake)
-		v.AddArg2(typ, val)
+		v.AddArg2(_typ, val)
 		return true
 	}
-	// match: (IMake typ (ArrayMake1 val))
-	// result: (IMake typ val)
+	// match: (IMake _typ (ArrayMake1 val))
+	// result: (IMake _typ val)
 	for {
-		typ := v_0
+		_typ := v_0
 		if v_1.Op != OpArrayMake1 {
 			break
 		}
 		val := v_1.Args[0]
 		v.reset(OpIMake)
-		v.AddArg2(typ, val)
+		v.AddArg2(_typ, val)
 		return true
 	}
 	return false
@@ -15710,32 +15710,32 @@ func rewriteValuegeneric_OpNeqPtr(v *Value) bool {
 		v.AuxInt = boolToAuxInt(false)
 		return true
 	}
-	// match: (NeqPtr (Addr {a} _) (Addr {b} _))
-	// result: (ConstBool [a != b])
+	// match: (NeqPtr (Addr {x} _) (Addr {y} _))
+	// result: (ConstBool [x != y])
 	for {
 		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 			if v_0.Op != OpAddr {
 				continue
 			}
-			a := auxToSym(v_0.Aux)
+			x := auxToSym(v_0.Aux)
 			if v_1.Op != OpAddr {
 				continue
 			}
-			b := auxToSym(v_1.Aux)
+			y := auxToSym(v_1.Aux)
 			v.reset(OpConstBool)
-			v.AuxInt = boolToAuxInt(a != b)
+			v.AuxInt = boolToAuxInt(x != y)
 			return true
 		}
 		break
 	}
-	// match: (NeqPtr (Addr {a} _) (OffPtr [o] (Addr {b} _)))
-	// result: (ConstBool [a != b || o != 0])
+	// match: (NeqPtr (Addr {x} _) (OffPtr [o] (Addr {y} _)))
+	// result: (ConstBool [x != y || o != 0])
 	for {
 		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 			if v_0.Op != OpAddr {
 				continue
 			}
-			a := auxToSym(v_0.Aux)
+			x := auxToSym(v_0.Aux)
 			if v_1.Op != OpOffPtr {
 				continue
 			}
@@ -15744,15 +15744,15 @@ func rewriteValuegeneric_OpNeqPtr(v *Value) bool {
 			if v_1_0.Op != OpAddr {
 				continue
 			}
-			b := auxToSym(v_1_0.Aux)
+			y := auxToSym(v_1_0.Aux)
 			v.reset(OpConstBool)
-			v.AuxInt = boolToAuxInt(a != b || o != 0)
+			v.AuxInt = boolToAuxInt(x != y || o != 0)
 			return true
 		}
 		break
 	}
-	// match: (NeqPtr (OffPtr [o1] (Addr {a} _)) (OffPtr [o2] (Addr {b} _)))
-	// result: (ConstBool [a != b || o1 != o2])
+	// match: (NeqPtr (OffPtr [o1] (Addr {x} _)) (OffPtr [o2] (Addr {y} _)))
+	// result: (ConstBool [x != y || o1 != o2])
 	for {
 		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 			if v_0.Op != OpOffPtr {
@@ -15763,7 +15763,7 @@ func rewriteValuegeneric_OpNeqPtr(v *Value) bool {
 			if v_0_0.Op != OpAddr {
 				continue
 			}
-			a := auxToSym(v_0_0.Aux)
+			x := auxToSym(v_0_0.Aux)
 			if v_1.Op != OpOffPtr {
 				continue
 			}
@@ -15772,39 +15772,39 @@ func rewriteValuegeneric_OpNeqPtr(v *Value) bool {
 			if v_1_0.Op != OpAddr {
 				continue
 			}
-			b := auxToSym(v_1_0.Aux)
+			y := auxToSym(v_1_0.Aux)
 			v.reset(OpConstBool)
-			v.AuxInt = boolToAuxInt(a != b || o1 != o2)
+			v.AuxInt = boolToAuxInt(x != y || o1 != o2)
 			return true
 		}
 		break
 	}
-	// match: (NeqPtr (LocalAddr {a} _ _) (LocalAddr {b} _ _))
-	// result: (ConstBool [a != b])
+	// match: (NeqPtr (LocalAddr {x} _ _) (LocalAddr {y} _ _))
+	// result: (ConstBool [x != y])
 	for {
 		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 			if v_0.Op != OpLocalAddr {
 				continue
 			}
-			a := auxToSym(v_0.Aux)
+			x := auxToSym(v_0.Aux)
 			if v_1.Op != OpLocalAddr {
 				continue
 			}
-			b := auxToSym(v_1.Aux)
+			y := auxToSym(v_1.Aux)
 			v.reset(OpConstBool)
-			v.AuxInt = boolToAuxInt(a != b)
+			v.AuxInt = boolToAuxInt(x != y)
 			return true
 		}
 		break
 	}
-	// match: (NeqPtr (LocalAddr {a} _ _) (OffPtr [o] (LocalAddr {b} _ _)))
-	// result: (ConstBool [a != b || o != 0])
+	// match: (NeqPtr (LocalAddr {x} _ _) (OffPtr [o] (LocalAddr {y} _ _)))
+	// result: (ConstBool [x != y || o != 0])
 	for {
 		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 			if v_0.Op != OpLocalAddr {
 				continue
 			}
-			a := auxToSym(v_0.Aux)
+			x := auxToSym(v_0.Aux)
 			if v_1.Op != OpOffPtr {
 				continue
 			}
@@ -15813,15 +15813,15 @@ func rewriteValuegeneric_OpNeqPtr(v *Value) bool {
 			if v_1_0.Op != OpLocalAddr {
 				continue
 			}
-			b := auxToSym(v_1_0.Aux)
+			y := auxToSym(v_1_0.Aux)
 			v.reset(OpConstBool)
-			v.AuxInt = boolToAuxInt(a != b || o != 0)
+			v.AuxInt = boolToAuxInt(x != y || o != 0)
 			return true
 		}
 		break
 	}
-	// match: (NeqPtr (OffPtr [o1] (LocalAddr {a} _ _)) (OffPtr [o2] (LocalAddr {b} _ _)))
-	// result: (ConstBool [a != b || o1 != o2])
+	// match: (NeqPtr (OffPtr [o1] (LocalAddr {x} _ _)) (OffPtr [o2] (LocalAddr {y} _ _)))
+	// result: (ConstBool [x != y || o1 != o2])
 	for {
 		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 			if v_0.Op != OpOffPtr {
@@ -15832,7 +15832,7 @@ func rewriteValuegeneric_OpNeqPtr(v *Value) bool {
 			if v_0_0.Op != OpLocalAddr {
 				continue
 			}
-			a := auxToSym(v_0_0.Aux)
+			x := auxToSym(v_0_0.Aux)
 			if v_1.Op != OpOffPtr {
 				continue
 			}
@@ -15841,9 +15841,9 @@ func rewriteValuegeneric_OpNeqPtr(v *Value) bool {
 			if v_1_0.Op != OpLocalAddr {
 				continue
 			}
-			b := auxToSym(v_1_0.Aux)
+			y := auxToSym(v_1_0.Aux)
 			v.reset(OpConstBool)
-			v.AuxInt = boolToAuxInt(a != b || o1 != o2)
+			v.AuxInt = boolToAuxInt(x != y || o1 != o2)
 			return true
 		}
 		break
@@ -16532,17 +16532,17 @@ func rewriteValuegeneric_OpNot(v *Value) bool {
 }
 func rewriteValuegeneric_OpOffPtr(v *Value) bool {
 	v_0 := v.Args[0]
-	// match: (OffPtr (OffPtr p [b]) [a])
-	// result: (OffPtr p [a+b])
+	// match: (OffPtr (OffPtr p [y]) [x])
+	// result: (OffPtr p [x+y])
 	for {
-		a := auxIntToInt64(v.AuxInt)
+		x := auxIntToInt64(v.AuxInt)
 		if v_0.Op != OpOffPtr {
 			break
 		}
-		b := auxIntToInt64(v_0.AuxInt)
+		y := auxIntToInt64(v_0.AuxInt)
 		p := v_0.Args[0]
 		v.reset(OpOffPtr)
-		v.AuxInt = int64ToAuxInt(a + b)
+		v.AuxInt = int64ToAuxInt(x + y)
 		v.AddArg(p)
 		return true
 	}
@@ -20678,34 +20678,34 @@ func rewriteValuegeneric_OpSelectN(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
 	config := b.Func.Config
-	// match: (SelectN [0] (MakeResult a ___))
-	// result: a
+	// match: (SelectN [0] (MakeResult x ___))
+	// result: x
 	for {
 		if auxIntToInt64(v.AuxInt) != 0 || v_0.Op != OpMakeResult || len(v_0.Args) < 1 {
 			break
 		}
-		a := v_0.Args[0]
-		v.copyOf(a)
+		x := v_0.Args[0]
+		v.copyOf(x)
 		return true
 	}
-	// match: (SelectN [1] (MakeResult a b ___))
-	// result: b
+	// match: (SelectN [1] (MakeResult x y ___))
+	// result: y
 	for {
 		if auxIntToInt64(v.AuxInt) != 1 || v_0.Op != OpMakeResult || len(v_0.Args) < 2 {
 			break
 		}
-		b := v_0.Args[1]
-		v.copyOf(b)
+		y := v_0.Args[1]
+		v.copyOf(y)
 		return true
 	}
-	// match: (SelectN [2] (MakeResult a b c ___))
-	// result: c
+	// match: (SelectN [2] (MakeResult x y z ___))
+	// result: z
 	for {
 		if auxIntToInt64(v.AuxInt) != 2 || v_0.Op != OpMakeResult || len(v_0.Args) < 3 {
 			break
 		}
-		c := v_0.Args[2]
-		v.copyOf(c)
+		z := v_0.Args[2]
+		v.copyOf(z)
 		return true
 	}
 	// match: (SelectN [0] call:(StaticCall {sym} s1:(Store _ (Const64 [sz]) s2:(Store _ src s3:(Store {t} _ dst mem)))))
-- 
GitLab


From 8fd0f83552d3ef9ca38c031bec93a36b189e3e11 Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Sun, 21 Mar 2021 00:58:18 +1100
Subject: [PATCH 1182/2400] cmd/compile/internal/ssa: correct sign extension
 for consts on riscv64

Correct sign extension handling for consts on riscv64. This fixes a bug
in part exposed by CL 302609 - previously 64 bit consts were rewritten into
multiple 32 bit consts and the expansion would result in sign/zero extension
not being eliminated. With this change a MOVDconst with a 64 bit value can be
followed by a MOV{B,H,W}reg, which will be eliminated without actually
truncating to a smaller value.

Change-Id: I8d9cd380217466997b341e008a1f139bc11a0d51
Reviewed-on: https://go-review.googlesource.com/c/go/+/303350
Trust: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/gen/RISCV64.rules |  6 +++---
 src/cmd/compile/internal/ssa/rewriteRISCV64.go | 12 ++++++------
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/gen/RISCV64.rules b/src/cmd/compile/internal/ssa/gen/RISCV64.rules
index ec013c11ed..9cdd62edbe 100644
--- a/src/cmd/compile/internal/ssa/gen/RISCV64.rules
+++ b/src/cmd/compile/internal/ssa/gen/RISCV64.rules
@@ -607,9 +607,9 @@
 (MOVDstore [off] {sym} ptr (MOVDconst [0]) mem) => (MOVDstorezero [off] {sym} ptr mem)
 
 // Avoid sign/zero extension for consts.
-(MOVBreg  (MOVDconst [c])) => (MOVDconst [int64(c)])
-(MOVHreg  (MOVDconst [c])) => (MOVDconst [int64(c)])
-(MOVWreg  (MOVDconst [c])) => (MOVDconst [int64(c)])
+(MOVBreg  (MOVDconst [c])) => (MOVDconst [int64(int8(c))])
+(MOVHreg  (MOVDconst [c])) => (MOVDconst [int64(int16(c))])
+(MOVWreg  (MOVDconst [c])) => (MOVDconst [int64(int32(c))])
 (MOVBUreg (MOVDconst [c])) => (MOVDconst [int64(uint8(c))])
 (MOVHUreg (MOVDconst [c])) => (MOVDconst [int64(uint16(c))])
 (MOVWUreg (MOVDconst [c])) => (MOVDconst [int64(uint32(c))])
diff --git a/src/cmd/compile/internal/ssa/rewriteRISCV64.go b/src/cmd/compile/internal/ssa/rewriteRISCV64.go
index 767c7dda1f..431fb1aaf6 100644
--- a/src/cmd/compile/internal/ssa/rewriteRISCV64.go
+++ b/src/cmd/compile/internal/ssa/rewriteRISCV64.go
@@ -2985,14 +2985,14 @@ func rewriteValueRISCV64_OpRISCV64MOVBreg(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
 	// match: (MOVBreg (MOVDconst [c]))
-	// result: (MOVDconst [int64(c)])
+	// result: (MOVDconst [int64(int8(c))])
 	for {
 		if v_0.Op != OpRISCV64MOVDconst {
 			break
 		}
 		c := auxIntToInt64(v_0.AuxInt)
 		v.reset(OpRISCV64MOVDconst)
-		v.AuxInt = int64ToAuxInt(int64(c))
+		v.AuxInt = int64ToAuxInt(int64(int8(c)))
 		return true
 	}
 	// match: (MOVBreg x:(MOVBload _ _))
@@ -3638,14 +3638,14 @@ func rewriteValueRISCV64_OpRISCV64MOVHreg(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
 	// match: (MOVHreg (MOVDconst [c]))
-	// result: (MOVDconst [int64(c)])
+	// result: (MOVDconst [int64(int16(c))])
 	for {
 		if v_0.Op != OpRISCV64MOVDconst {
 			break
 		}
 		c := auxIntToInt64(v_0.AuxInt)
 		v.reset(OpRISCV64MOVDconst)
-		v.AuxInt = int64ToAuxInt(int64(c))
+		v.AuxInt = int64ToAuxInt(int64(int16(c)))
 		return true
 	}
 	// match: (MOVHreg x:(MOVBload _ _))
@@ -4129,14 +4129,14 @@ func rewriteValueRISCV64_OpRISCV64MOVWreg(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
 	// match: (MOVWreg (MOVDconst [c]))
-	// result: (MOVDconst [int64(c)])
+	// result: (MOVDconst [int64(int32(c))])
 	for {
 		if v_0.Op != OpRISCV64MOVDconst {
 			break
 		}
 		c := auxIntToInt64(v_0.AuxInt)
 		v.reset(OpRISCV64MOVDconst)
-		v.AuxInt = int64ToAuxInt(int64(c))
+		v.AuxInt = int64ToAuxInt(int64(int32(c)))
 		return true
 	}
 	// match: (MOVWreg x:(MOVBload _ _))
-- 
GitLab


From 78afca22c9485dbd44da3b909866bbb9c1eaf440 Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Fri, 19 Mar 2021 20:19:33 -0600
Subject: [PATCH 1183/2400] runtime: fix bogus NtCurrentTeb()->TlsSlots[n]
 calculation on windows/arm64

runtime.save_g adds X18 to runtime.tls_g in order to have a pointer to
thread local storage. X18 represents a pointer to the TEB on ARM64 and
runtime.tls_g is set in runtime.wintls at initialization time. This
function calls TlsAlloc to allocate a "TLS slot", which is supposed to
index into NtCurrentTeb()->TlsSlots. So the full calculation we want is:

    X18 + offsetof(TEB, TlsSlots) + 8*TlsAllocReturnValue

It makes sense to store the complete value of "offsetof(TEB,
TlsSlots) + TlsAllocReturnValue" into runtime.tls_g so that the
calculation can simplify to:

    X18 + runtime.tls_g

But, instead of computing that, we're currently doing something kind of
strange, in which we:

    - call TlsAlloc, which puts its return value into X0
    - make sure X0 is less than 64, so we don't overflow
    - set runtime.tls_g to 8*X1 + offsetof(TEB, TlsSlots)

The question is: why are we using X1 instead of X0? What is in X1?

Probably it was, by luck, zero before, and TlsAlloc returned zero, so
there was no problem. But on recent versions of Windows, X1 is some
other garbage value and not zero, so we eventually crash when trying to
dereference X18 + runtime.tls_g.

This commit fixes the problem by just computing:

   runtime.tls_g = 8*X0 + offsetof(TEB, TlsSlots)

Fixes #45138.

Change-Id: I560426bae7468217bd183ac6c6eb4b56a3815b09
Reviewed-on: https://go-review.googlesource.com/c/go/+/303273
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/sys_windows_arm64.s | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/runtime/sys_windows_arm64.s b/src/runtime/sys_windows_arm64.s
index c8c96acd06..0b77e6d048 100644
--- a/src/runtime/sys_windows_arm64.s
+++ b/src/runtime/sys_windows_arm64.s
@@ -573,7 +573,7 @@ TEXT runtime·wintls(SB),NOSPLIT,$0
 ok:
 
 	// Save offset from R18 into tls_g.
-	LSL	$3, R1
-	ADD	$TEB_TlsSlots, R1
-	MOVD	R1, runtime·tls_g(SB)
+	LSL	$3, R0
+	ADD	$TEB_TlsSlots, R0
+	MOVD	R0, runtime·tls_g(SB)
 	RET
-- 
GitLab


From ba6b8e75ed16b3e9ecb305399e5ec2e29778e299 Mon Sep 17 00:00:00 2001
From: Shuhei Takahashi <nya@chromium.org>
Date: Mon, 22 Mar 2021 13:35:49 +0900
Subject: [PATCH 1184/2400] os/exec: avoid flaky Wait in TestContextCancel

This change just increases the timeout to 1 minute to avoid test
flakiness.

Fixes #42061

Change-Id: Id258488ee8f062cd5e68b68bb5cf11e15fdbb396
Reviewed-on: https://go-review.googlesource.com/c/go/+/303351
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Benny Siegert <bsiegert@gmail.com>
---
 src/os/exec/exec_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/os/exec/exec_test.go b/src/os/exec/exec_test.go
index 57591a38ab..05cf807583 100644
--- a/src/os/exec/exec_test.go
+++ b/src/os/exec/exec_test.go
@@ -1099,7 +1099,7 @@ func TestContextCancel(t *testing.T) {
 		if _, err := io.WriteString(w, "echo"); err != nil {
 			break
 		}
-		if time.Since(start) > time.Second {
+		if time.Since(start) > time.Minute {
 			t.Fatal("canceling context did not stop program")
 		}
 		time.Sleep(time.Millisecond)
-- 
GitLab


From 196c33e92d86eb21fe1cb7d244ea61209b4a554e Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Fri, 12 Mar 2021 13:37:24 -0500
Subject: [PATCH 1185/2400] cmd/compile: fix WriteFuncMap for new ABI.

replaced old type-based logic with new abi-based logic;
earlier versions of this CL compared them for equality.
For not-in-a-register, they match everywhere tested.

also modified GetFrameOffset to make it more like the one it replaces;
the LocalsOffset is subtracted.

Change-Id: I65ce7f0646c493c277df6b6f46e4839a0d886ac9
Reviewed-on: https://go-review.googlesource.com/c/go/+/302072
Trust: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/abi/abiutils.go   | 24 +++++++++++-------
 src/cmd/compile/internal/gc/compile.go     |  4 +--
 src/cmd/compile/internal/liveness/plive.go | 29 +++++++++++++---------
 src/cmd/compile/internal/objw/objw.go      |  6 +++++
 src/cmd/compile/internal/ssagen/ssa.go     |  2 +-
 5 files changed, 41 insertions(+), 24 deletions(-)

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index 7573c13158..8495ed7c51 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -236,16 +236,22 @@ func (a *ABIParamAssignment) SpillOffset() int32 {
 	return a.offset
 }
 
-// FrameOffset returns the location that a value would spill to, if any exists.
-// For register-allocated inputs, that is their spill offset reserved for morestack
-// (might as well use it, it is there); for stack-allocated inputs and outputs,
-// that is their location on the stack.  For register-allocated outputs, there is
-// no defined spill area, so return -1.
+// FrameOffset returns the frame-pointer-relative location that a function
+// would spill its input or output parameter to, if such a spill slot exists.
+// For register-allocated inputs that is their spill offset reserved for morestack;
+// for stack-allocated inputs and outputs, that is their location on the stack.
+// For register-allocated outputs, there is no defined spill area, so return -1.
+// (In a future version of the ABI, register-resident inputs may lose their defined
+// spill area to help reduce stack sizes.)
 func (a *ABIParamAssignment) FrameOffset(i *ABIParamResultInfo) int64 {
-	if len(a.Registers) == 0 || a.offset == -1 {
-		return int64(a.offset)
+	if a.offset == -1 {
+		return -1
 	}
-	return int64(a.offset) + i.SpillAreaOffset()
+	if len(a.Registers) == 0 { // passed on stack
+		return int64(a.offset) - i.config.LocalsOffset()
+	}
+	// spill area for registers
+	return int64(a.offset) + i.SpillAreaOffset() - i.config.LocalsOffset()
 }
 
 // RegAmounts holds a specified number of integer/float registers.
@@ -462,7 +468,7 @@ func (config *ABIConfig) updateOffset(result *ABIParamResultInfo, f *types.Field
 		// Getting this wrong breaks stackmaps, see liveness/plive.go:WriteFuncMap and typebits/typebits.go:Set
 		parameterUpdateMu.Lock()
 		defer parameterUpdateMu.Unlock()
-		off := a.FrameOffset(result) - config.LocalsOffset()
+		off := a.FrameOffset(result)
 		fOffset := f.Offset
 		if fOffset == types.BOGUS_FUNARG_OFFSET {
 			// Set the Offset the first time. After that, we may recompute it, but it should never change.
diff --git a/src/cmd/compile/internal/gc/compile.go b/src/cmd/compile/internal/gc/compile.go
index 83cfceb2c8..e066d3345e 100644
--- a/src/cmd/compile/internal/gc/compile.go
+++ b/src/cmd/compile/internal/gc/compile.go
@@ -45,8 +45,8 @@ func enqueueFunc(fn *ir.Func) {
 		ssagen.InitLSym(fn, false)
 		types.CalcSize(fn.Type()) // TODO register args; remove this once all is done by abiutils
 		a := ssagen.AbiForFunc(fn)
-		a.ABIAnalyze(fn.Type(), true) // will set parameter spill/home locations correctly
-		liveness.WriteFuncMap(fn)
+		abiInfo := a.ABIAnalyze(fn.Type(), true) // will set parameter spill/home locations correctly
+		liveness.WriteFuncMap(fn, abiInfo)
 		return
 	}
 
diff --git a/src/cmd/compile/internal/liveness/plive.go b/src/cmd/compile/internal/liveness/plive.go
index c09a8401f7..5d8e8b115d 100644
--- a/src/cmd/compile/internal/liveness/plive.go
+++ b/src/cmd/compile/internal/liveness/plive.go
@@ -22,6 +22,7 @@ import (
 	"sort"
 	"strings"
 
+	"cmd/compile/internal/abi"
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/bitvec"
 	"cmd/compile/internal/ir"
@@ -1449,32 +1450,36 @@ func isfat(t *types.Type) bool {
 	return false
 }
 
-// TODO THIS IS ALL WRONG AND NEEDS TO USE ABI.
-func WriteFuncMap(fn *ir.Func) {
+// WriteFuncMap writes the pointer bitmaps for bodyless function fn's
+// inputs and outputs as the value of symbol <fn>.args_stackmap.
+// If fn has outputs, two bitmaps are written, otherwise just one.
+func WriteFuncMap(fn *ir.Func, abiInfo *abi.ABIParamResultInfo) {
 	if ir.FuncName(fn) == "_" || fn.Sym().Linkname != "" {
 		return
 	}
 	types.CalcSize(fn.Type())
-	lsym := base.Ctxt.Lookup(fn.LSym.Name + ".args_stackmap")
-	nptr := int(fn.Type().ArgWidth() / int64(types.PtrSize))
+	nptr := int(abiInfo.ArgWidth() / int64(types.PtrSize))
 	bv := bitvec.New(int32(nptr) * 2)
+
+	for _, p := range abiInfo.InParams() {
+		typebits.Set(p.Type, p.FrameOffset(abiInfo), bv)
+	}
+
 	nbitmap := 1
 	if fn.Type().NumResults() > 0 {
 		nbitmap = 2
 	}
+	lsym := base.Ctxt.Lookup(fn.LSym.Name + ".args_stackmap")
 	off := objw.Uint32(lsym, 0, uint32(nbitmap))
 	off = objw.Uint32(lsym, off, uint32(bv.N))
-
-	if ir.IsMethod(fn) {
-		typebits.Set(fn.Type().Recvs(), 0, bv)
-	}
-	if fn.Type().NumParams() > 0 {
-		typebits.Set(fn.Type().Params(), 0, bv)
-	}
 	off = objw.BitVec(lsym, off, bv)
 
 	if fn.Type().NumResults() > 0 {
-		typebits.Set(fn.Type().Results(), 0, bv)
+		for _, p := range abiInfo.OutParams() {
+			if len(p.Registers) == 0 {
+				typebits.Set(p.Type, p.FrameOffset(abiInfo), bv)
+			}
+		}
 		off = objw.BitVec(lsym, off, bv)
 	}
 
diff --git a/src/cmd/compile/internal/objw/objw.go b/src/cmd/compile/internal/objw/objw.go
index dfbcf51556..50ce7b747d 100644
--- a/src/cmd/compile/internal/objw/objw.go
+++ b/src/cmd/compile/internal/objw/objw.go
@@ -11,6 +11,8 @@ import (
 	"cmd/internal/obj"
 )
 
+// Uint8 writes an unsigned byte v into s at offset off,
+// and returns the next unused offset (i.e., off+1).
 func Uint8(s *obj.LSym, off int, v uint8) int {
 	return UintN(s, off, uint64(v), 1)
 }
@@ -27,6 +29,8 @@ func Uintptr(s *obj.LSym, off int, v uint64) int {
 	return UintN(s, off, v, types.PtrSize)
 }
 
+// UintN writes an unsigned integer v of size wid bytes into s at offset off,
+// and returns the next unused offset.
 func UintN(s *obj.LSym, off int, v uint64, wid int) int {
 	if off&(wid-1) != 0 {
 		base.Fatalf("duintxxLSym: misaligned: v=%d wid=%d off=%d", v, wid, off)
@@ -62,6 +66,8 @@ func Global(s *obj.LSym, width int32, flags int16) {
 	base.Ctxt.Globl(s, int64(width), int(flags))
 }
 
+// Bitvec writes the contents of bv into s as sequence of bytes
+// in little-endian order, and returns the next unused offset.
 func BitVec(s *obj.LSym, off int, bv bitvec.BitVec) int {
 	// Runtime reads the bitmaps as byte arrays. Oblige.
 	for j := 0; int32(j) < bv.N; j += 8 {
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index e97535e748..5d23b3bd79 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -367,7 +367,7 @@ func (s *state) emitOpenDeferInfo() {
 			f := getParam(r.n, j)
 			off = dvarint(x, off, -okOffset(arg.FrameOffset()))
 			off = dvarint(x, off, f.Type.Size())
-			off = dvarint(x, off, okOffset(pri.InParam(j+argAdjust).FrameOffset(pri))-ab.LocalsOffset()) // defer does not want the fixed frame adjustment
+			off = dvarint(x, off, okOffset(pri.InParam(j+argAdjust).FrameOffset(pri)))
 		}
 	}
 }
-- 
GitLab


From a93849b9e2326cffe4c9aef656b507e2cead8e5f Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Fri, 19 Mar 2021 15:21:14 -0400
Subject: [PATCH 1186/2400] cmd/compile: remove now-redundant AuxCall.args

Cleanup, ABI information subsumes this.

Updates #40724

Change-Id: I6c69da44380f7b0d159b22acacbd68dc000e4725
Reviewed-on: https://go-review.googlesource.com/c/go/+/303432
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 .../compile/internal/ssa/loopreschedchecks.go |  2 +-
 src/cmd/compile/internal/ssa/op.go            | 22 +++++--------------
 src/cmd/compile/internal/ssa/rewrite.go       |  2 +-
 src/cmd/compile/internal/ssa/writebarrier.go  |  2 +-
 src/cmd/compile/internal/ssagen/ssa.go        | 16 +++++---------
 5 files changed, 14 insertions(+), 30 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/loopreschedchecks.go b/src/cmd/compile/internal/ssa/loopreschedchecks.go
index 5308d1ac48..2af6e8472c 100644
--- a/src/cmd/compile/internal/ssa/loopreschedchecks.go
+++ b/src/cmd/compile/internal/ssa/loopreschedchecks.go
@@ -247,7 +247,7 @@ func insertLoopReschedChecks(f *Func) {
 		//    goto header
 		resched := f.fe.Syslook("goschedguarded")
 		// TODO(register args) -- will need more details
-		mem1 := sched.NewValue1A(bb.Pos, OpStaticCall, types.TypeMem, StaticAuxCall(resched, nil, nil, nil), mem0)
+		mem1 := sched.NewValue1A(bb.Pos, OpStaticCall, types.TypeMem, StaticAuxCall(resched, nil, nil), mem0)
 		sched.AddEdgeTo(h)
 		headerMemPhi.AddArg(mem1)
 
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index fe9ba0e156..9e7e169137 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -112,7 +112,6 @@ func (a *AuxNameOffset) String() string {
 type AuxCall struct {
 	// TODO(register args) this information is largely redundant with ../abi information, needs cleanup once new ABI is in place.
 	Fn      *obj.LSym
-	args    []Param // Includes receiver for method calls.  Does NOT include hidden closure pointer.
 	results []Param
 	reg     *regInfo                // regInfo for this call // TODO for now nil means ignore
 	abiInfo *abi.ABIParamResultInfo // TODO remove fields above redundant with this information.
@@ -285,17 +284,6 @@ func (a *AuxCall) String() string {
 		fn = fmt.Sprintf("AuxCall{%v", a.Fn)
 	}
 
-	if len(a.args) == 0 {
-		fn += "()"
-	} else {
-		s := "("
-		for _, arg := range a.args {
-			fn += fmt.Sprintf("%s[%v,%v]", s, arg.Type, arg.Offset)
-			s = ","
-		}
-		fn += ")"
-	}
-
 	if len(a.results) > 0 { // usual is zero or one; only some RT calls have more than one.
 		if len(a.results) == 1 {
 			fn += fmt.Sprintf("[%v,%v]", a.results[0].Type, a.results[0].Offset)
@@ -323,7 +311,7 @@ func ACParamsToTypes(ps []Param) (ts []*types.Type) {
 }
 
 // StaticAuxCall returns an AuxCall for a static call.
-func StaticAuxCall(sym *obj.LSym, args []Param, results []Param, paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
+func StaticAuxCall(sym *obj.LSym, results []Param, paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
 	if paramResultInfo == nil {
 		panic(fmt.Errorf("Nil paramResultInfo, sym=%v", sym))
 	}
@@ -331,7 +319,7 @@ func StaticAuxCall(sym *obj.LSym, args []Param, results []Param, paramResultInfo
 	if paramResultInfo.InRegistersUsed()+paramResultInfo.OutRegistersUsed() > 0 {
 		reg = &regInfo{}
 	}
-	return &AuxCall{Fn: sym, args: args, results: results, abiInfo: paramResultInfo, reg: reg}
+	return &AuxCall{Fn: sym, results: results, abiInfo: paramResultInfo, reg: reg}
 }
 
 // InterfaceAuxCall returns an AuxCall for an interface call.
@@ -340,7 +328,7 @@ func InterfaceAuxCall(args []Param, results []Param, paramResultInfo *abi.ABIPar
 	if paramResultInfo.InRegistersUsed()+paramResultInfo.OutRegistersUsed() > 0 {
 		reg = &regInfo{}
 	}
-	return &AuxCall{Fn: nil, args: args, results: results, abiInfo: paramResultInfo, reg: reg}
+	return &AuxCall{Fn: nil, results: results, abiInfo: paramResultInfo, reg: reg}
 }
 
 // ClosureAuxCall returns an AuxCall for a closure call.
@@ -349,7 +337,7 @@ func ClosureAuxCall(args []Param, results []Param, paramResultInfo *abi.ABIParam
 	if paramResultInfo.InRegistersUsed()+paramResultInfo.OutRegistersUsed() > 0 {
 		reg = &regInfo{}
 	}
-	return &AuxCall{Fn: nil, args: args, results: results, abiInfo: paramResultInfo, reg: reg}
+	return &AuxCall{Fn: nil, results: results, abiInfo: paramResultInfo, reg: reg}
 }
 
 func (*AuxCall) CanBeAnSSAAux() {}
@@ -361,7 +349,7 @@ func OwnAuxCall(fn *obj.LSym, args []Param, results []Param, paramResultInfo *ab
 	if paramResultInfo.InRegistersUsed()+paramResultInfo.OutRegistersUsed() > 0 {
 		reg = &regInfo{}
 	}
-	return &AuxCall{Fn: fn, args: args, results: results, abiInfo: paramResultInfo, reg: reg}
+	return &AuxCall{Fn: fn, results: results, abiInfo: paramResultInfo, reg: reg}
 }
 
 const (
diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go
index 3c222f80bf..9e67c3482c 100644
--- a/src/cmd/compile/internal/ssa/rewrite.go
+++ b/src/cmd/compile/internal/ssa/rewrite.go
@@ -765,7 +765,7 @@ func devirt(v *Value, aux Aux, sym Sym, offset int64) *AuxCall {
 		return nil
 	}
 	va := aux.(*AuxCall)
-	return StaticAuxCall(lsym, va.args, va.results, va.abiInfo)
+	return StaticAuxCall(lsym, va.results, va.abiInfo)
 }
 
 // de-virtualize an InterLECall
diff --git a/src/cmd/compile/internal/ssa/writebarrier.go b/src/cmd/compile/internal/ssa/writebarrier.go
index 0af039577f..9b956a4577 100644
--- a/src/cmd/compile/internal/ssa/writebarrier.go
+++ b/src/cmd/compile/internal/ssa/writebarrier.go
@@ -516,7 +516,7 @@ func wbcall(pos src.XPos, b *Block, fn, typ *obj.LSym, ptr, val, mem, sp, sb *Va
 	off = round(off, config.PtrSize)
 
 	// issue call
-	mem = b.NewValue1A(pos, OpStaticCall, types.TypeResultMem, StaticAuxCall(fn, ACArgs, nil, b.Func.ABIDefault.ABIAnalyzeTypes(nil, argTypes, nil)), mem)
+	mem = b.NewValue1A(pos, OpStaticCall, types.TypeResultMem, StaticAuxCall(fn, nil, b.Func.ABIDefault.ABIAnalyzeTypes(nil, argTypes, nil)), mem)
 	mem.AuxInt = off - config.ctxt.FixedFrameSize()
 	return b.NewValue1I(pos, OpSelectN, types.TypeMem, 0, mem)
 }
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 5d23b3bd79..f142810cf3 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -4814,8 +4814,7 @@ func (s *state) openDeferExit() {
 			aux := ssa.ClosureAuxCall(ACArgs, ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
 			call = s.newValue2A(ssa.OpClosureLECall, aux.LateExpansionResultType(), aux, codeptr, v)
 		} else {
-			aux := ssa.StaticAuxCall(fn.(*ir.Name).Linksym(), ACArgs, ACResults,
-				s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
+			aux := ssa.StaticAuxCall(fn.(*ir.Name).Linksym(), ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
 			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 		}
 		callArgs = append(callArgs, s.mem())
@@ -4995,8 +4994,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 
 		// Call runtime.deferprocStack with pointer to _defer record.
 		ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(base.Ctxt.FixedFrameSize())})
-		aux := ssa.StaticAuxCall(ir.Syms.DeferprocStack, ACArgs, ACResults,
-			s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
+		aux := ssa.StaticAuxCall(ir.Syms.DeferprocStack, ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
 		callArgs = append(callArgs, addr, s.mem())
 		call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 		call.AddArgs(callArgs...)
@@ -5058,12 +5056,10 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		// call target
 		switch {
 		case k == callDefer:
-			aux := ssa.StaticAuxCall(ir.Syms.Deferproc, ACArgs, ACResults,
-				s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults))) // TODO paramResultInfo for DeferProc
+			aux := ssa.StaticAuxCall(ir.Syms.Deferproc, ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults))) // TODO paramResultInfo for DeferProc
 			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 		case k == callGo:
-			aux := ssa.StaticAuxCall(ir.Syms.Newproc, ACArgs, ACResults,
-				s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
+			aux := ssa.StaticAuxCall(ir.Syms.Newproc, ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
 			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux) // TODO paramResultInfo for NewProc
 		case closure != nil:
 			// rawLoad because loading the code pointer from a
@@ -5079,7 +5075,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			aux := ssa.InterfaceAuxCall(ACArgs, ACResults, params)
 			call = s.newValue1A(ssa.OpInterLECall, aux.LateExpansionResultType(), aux, codeptr)
 		case callee != nil:
-			aux := ssa.StaticAuxCall(callTargetLSym(callee, s.curfn.LSym), ACArgs, ACResults, params)
+			aux := ssa.StaticAuxCall(callTargetLSym(callee, s.curfn.LSym), ACResults, params)
 			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 		default:
 			s.Fatalf("bad call type %v %v", n.Op(), n)
@@ -5546,7 +5542,7 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
 
 	// Issue call
 	var call *ssa.Value
-	aux := ssa.StaticAuxCall(fn, ACArgs, ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, callArgTypes, results))
+	aux := ssa.StaticAuxCall(fn, ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, callArgTypes, results))
 	callArgs = append(callArgs, s.mem())
 	call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 	call.AddArgs(callArgs...)
-- 
GitLab


From d9691ffa37820e2a7e70679164eac29c675874b2 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Thu, 18 Mar 2021 11:18:44 -0400
Subject: [PATCH 1187/2400] cmd/compile/internal/walk: relocate a stray comment

The explanatory comment and the associated version counter variable
for the helper routine "wrapCall" seem to have been left behind in
walk.go during the big refactoring -- move it back to where it should
be, next to wrapCall in stmt.go. Also fix a small buglet in the
comment itself.

Change-Id: I8637a838214b216581be59e01149a72282a46526
Reviewed-on: https://go-review.googlesource.com/c/go/+/303729
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/walk/stmt.go | 18 ++++++++++++++++++
 src/cmd/compile/internal/walk/walk.go | 18 ------------------
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/src/cmd/compile/internal/walk/stmt.go b/src/cmd/compile/internal/walk/stmt.go
index 0c851506cb..836ac6b6ab 100644
--- a/src/cmd/compile/internal/walk/stmt.go
+++ b/src/cmd/compile/internal/walk/stmt.go
@@ -233,6 +233,24 @@ func walkIf(n *ir.IfStmt) ir.Node {
 	return n
 }
 
+// Rewrite
+//	go builtin(x, y, z)
+// into
+//	go func(a1, a2, a3) {
+//		builtin(a1, a2, a3)
+//	}(x, y, z)
+// for print, println, and delete.
+//
+// Rewrite
+//	go f(x, y, uintptr(unsafe.Pointer(z)))
+// into
+//	go func(a1, a2, a3) {
+//		f(a1, a2, uintptr(a3))
+//	}(x, y, unsafe.Pointer(z))
+// for function contains unsafe-uintptr arguments.
+
+var wrapCall_prgen int
+
 // The result of wrapCall MUST be assigned back to n, e.g.
 // 	n.Left = wrapCall(n.Left, init)
 func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index b47d96dc4c..d889786c72 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -237,24 +237,6 @@ func walkAppendArgs(n *ir.CallExpr, init *ir.Nodes) {
 	}
 }
 
-// Rewrite
-//	go builtin(x, y, z)
-// into
-//	go func(a1, a2, a3) {
-//		builtin(a1, a2, a3)
-//	}(x, y, z)
-// for print, println, and delete.
-//
-// Rewrite
-//	go f(x, y, uintptr(unsafe.Pointer(z)))
-// into
-//	go func(a1, a2, a3) {
-//		builtin(a1, a2, uintptr(a3))
-//	}(x, y, unsafe.Pointer(z))
-// for function contains unsafe-uintptr arguments.
-
-var wrapCall_prgen int
-
 // appendWalkStmt typechecks and walks stmt and then appends it to init.
 func appendWalkStmt(init *ir.Nodes, stmt ir.Node) {
 	op := stmt.Op()
-- 
GitLab


From 1c9e587b90172e7654db897d8c938ffc665e1673 Mon Sep 17 00:00:00 2001
From: 6543 <6543@obermui.de>
Date: Mon, 22 Mar 2021 21:16:27 +0000
Subject: [PATCH 1188/2400] net: add IP.IsPrivate

Adds a new method IsPrivate to check if an IP is
private according to RFC 1918 & RFC 4193.

Fixes #29146

Change-Id: If77b9e1746d86029df66ae9f18437b1f65a18b59
GitHub-Last-Rev: 09f4ba75988c87b90550d071866ab1d6634ef681
GitHub-Pull-Request: golang/go#42793
Reviewed-on: https://go-review.googlesource.com/c/go/+/272668
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/net/ip.go      | 21 +++++++++++++++++++++
 src/net/ip_test.go | 22 ++++++++++++++++++++++
 2 files changed, 43 insertions(+)

diff --git a/src/net/ip.go b/src/net/ip.go
index 18e3f3a2f5..da51dab800 100644
--- a/src/net/ip.go
+++ b/src/net/ip.go
@@ -128,6 +128,27 @@ func (ip IP) IsLoopback() bool {
 	return ip.Equal(IPv6loopback)
 }
 
+// IsPrivate reports whether ip is a private address, according to
+// RFC 1918 (IPv4 addresses) and RFC 4193 (IPv6 addresses).
+func (ip IP) IsPrivate() bool {
+	if ip4 := ip.To4(); ip4 != nil {
+		// Following RFC 4193, Section 3. Local IPv6 Unicast Addresses which says:
+		//   The Internet Assigned Numbers Authority (IANA) has reserved the
+		//   following three blocks of the IPv4 address space for private internets:
+		//     10.0.0.0        -   10.255.255.255  (10/8 prefix)
+		//     172.16.0.0      -   172.31.255.255  (172.16/12 prefix)
+		//     192.168.0.0     -   192.168.255.255 (192.168/16 prefix)
+		return ip4[0] == 10 ||
+			(ip4[0] == 172 && ip4[1]&0xf0 == 16) ||
+			(ip4[0] == 192 && ip4[1] == 168)
+	}
+	// Following RFC 4193, Section 3. Private Address Space which says:
+	//   The Internet Assigned Numbers Authority (IANA) has reserved the
+	//   following block of the IPv6 address space for local internets:
+	//     FC00::  -  FDFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF (FC00::/7 prefix)
+	return len(ip) == IPv6len && ip[0]&0xfe == 0xfc
+}
+
 // IsMulticast reports whether ip is a multicast address.
 func (ip IP) IsMulticast() bool {
 	if ip4 := ip.To4(); ip4 != nil {
diff --git a/src/net/ip_test.go b/src/net/ip_test.go
index 1e09ae9db4..3af5e41ceb 100644
--- a/src/net/ip_test.go
+++ b/src/net/ip_test.go
@@ -691,6 +691,28 @@ var ipAddrScopeTests = []struct {
 	{IP.IsGlobalUnicast, IP{0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false},
 	{IP.IsGlobalUnicast, IP{0xff, 0x05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false},
 	{IP.IsGlobalUnicast, nil, false},
+	{IP.IsPrivate, nil, false},
+	{IP.IsPrivate, IPv4(1, 1, 1, 1), false},
+	{IP.IsPrivate, IPv4(9, 255, 255, 255), false},
+	{IP.IsPrivate, IPv4(10, 0, 0, 0), true},
+	{IP.IsPrivate, IPv4(10, 255, 255, 255), true},
+	{IP.IsPrivate, IPv4(11, 0, 0, 0), false},
+	{IP.IsPrivate, IPv4(172, 15, 255, 255), false},
+	{IP.IsPrivate, IPv4(172, 16, 0, 0), true},
+	{IP.IsPrivate, IPv4(172, 16, 255, 255), true},
+	{IP.IsPrivate, IPv4(172, 23, 18, 255), true},
+	{IP.IsPrivate, IPv4(172, 31, 255, 255), true},
+	{IP.IsPrivate, IPv4(172, 31, 0, 0), true},
+	{IP.IsPrivate, IPv4(172, 32, 0, 0), false},
+	{IP.IsPrivate, IPv4(192, 167, 255, 255), false},
+	{IP.IsPrivate, IPv4(192, 168, 0, 0), true},
+	{IP.IsPrivate, IPv4(192, 168, 255, 255), true},
+	{IP.IsPrivate, IPv4(192, 169, 0, 0), false},
+	{IP.IsPrivate, IP{0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, false},
+	{IP.IsPrivate, IP{0xfc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, true},
+	{IP.IsPrivate, IP{0xfc, 0xff, 0x12, 0, 0, 0, 0, 0x44, 0, 0, 0, 0, 0, 0, 0, 0}, true},
+	{IP.IsPrivate, IP{0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, true},
+	{IP.IsPrivate, IP{0xfe, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false},
 }
 
 func name(f interface{}) string {
-- 
GitLab


From c819907754a30229da197546a36eb4a160e5908f Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Thu, 7 Jan 2021 16:25:41 -0500
Subject: [PATCH 1189/2400] cmd/{compile,link}: relocate generation of DWARF
 for global vars

Move DWARF generation for global variables from the linker to the
compiler. This effectively parallelizes this part of DWARF generation,
speeds up the linker minutely, and gives us a slightly more rational
implementation (there was really no compelling reason to do DWARF gen
for globals in the linker).

Change-Id: I0c1c98d3a647258697e90eb91d1d8a9f6f7f376a
Reviewed-on: https://go-review.googlesource.com/c/go/+/295011
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
---
 src/cmd/compile/internal/gc/main.go           |  2 +-
 src/cmd/compile/internal/gc/obj.go            |  1 +
 src/cmd/internal/dwarf/dwarf.go               |  9 +++
 src/cmd/internal/obj/dwarf.go                 | 25 ++++++++
 src/cmd/link/internal/ld/dwarf.go             | 58 ++++++++-----------
 src/cmd/link/internal/sym/compilation_unit.go |  1 +
 6 files changed, 60 insertions(+), 36 deletions(-)

diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 726a0685d5..c46989edb4 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -105,7 +105,7 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	// Record flags that affect the build result. (And don't
 	// record flags that don't, since that would cause spurious
 	// changes in the binary.)
-	dwarfgen.RecordFlags("B", "N", "l", "msan", "race", "shared", "dynlink", "dwarflocationlists", "dwarfbasentries", "smallframes", "spectre")
+	dwarfgen.RecordFlags("B", "N", "l", "msan", "race", "shared", "dynlink", "dwarf", "dwarflocationlists", "dwarfbasentries", "smallframes", "spectre")
 
 	if !base.EnableTrace && base.Flag.LowerT {
 		log.Fatalf("compiler not built with support for -t")
diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 0472af7441..d18011a9e5 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -195,6 +195,7 @@ func dumpGlobal(n *ir.Name) {
 	}
 	types.CalcSize(n.Type())
 	ggloblnod(n)
+	base.Ctxt.DwarfGlobal(base.Ctxt.Pkgpath, types.TypeSymName(n.Type()), n.Linksym())
 }
 
 func dumpGlobalConst(n ir.Node) {
diff --git a/src/cmd/internal/dwarf/dwarf.go b/src/cmd/internal/dwarf/dwarf.go
index 70d792fec6..c48e1723c8 100644
--- a/src/cmd/internal/dwarf/dwarf.go
+++ b/src/cmd/internal/dwarf/dwarf.go
@@ -1041,6 +1041,15 @@ func PutIntConst(ctxt Context, info, typ Sym, name string, val int64) {
 	putattr(ctxt, info, DW_ABRV_INT_CONSTANT, DW_FORM_sdata, DW_CLS_CONSTANT, val, nil)
 }
 
+// PutGlobal writes a DIE for a global variable.
+func PutGlobal(ctxt Context, info, typ, gvar Sym, name string) {
+	Uleb128put(ctxt, info, DW_ABRV_VARIABLE)
+	putattr(ctxt, info, DW_ABRV_VARIABLE, DW_FORM_string, DW_CLS_STRING, int64(len(name)), name)
+	putattr(ctxt, info, DW_ABRV_VARIABLE, DW_FORM_block1, DW_CLS_ADDRESS, 0, gvar)
+	putattr(ctxt, info, DW_ABRV_VARIABLE, DW_FORM_ref_addr, DW_CLS_REFERENCE, 0, typ)
+	putattr(ctxt, info, DW_ABRV_VARIABLE, DW_FORM_flag, DW_CLS_FLAG, 1, nil)
+}
+
 // PutBasedRanges writes a range table to sym. All addresses in ranges are
 // relative to some base address, which must be arranged by the caller
 // (e.g., with a DW_AT_low_pc attribute, or in a BASE-prefixed range).
diff --git a/src/cmd/internal/obj/dwarf.go b/src/cmd/internal/obj/dwarf.go
index 87c62e2981..6dd53ffd12 100644
--- a/src/cmd/internal/obj/dwarf.go
+++ b/src/cmd/internal/obj/dwarf.go
@@ -402,6 +402,31 @@ func (ctxt *Link) DwarfIntConst(myimportpath, name, typename string, val int64)
 	dwarf.PutIntConst(dwCtxt{ctxt}, s, ctxt.Lookup(dwarf.InfoPrefix+typename), myimportpath+"."+name, val)
 }
 
+// DwarfGlobal creates a link symbol containing a DWARF entry for
+// a global variable.
+func (ctxt *Link) DwarfGlobal(myimportpath, typename string, varSym *LSym) {
+	if myimportpath == "" || varSym.Local() {
+		return
+	}
+	var varname string
+	if varSym.Pkg == "_" {
+		// The frontend uses package "_" to mark symbols that should not
+		// be referenced by index, e.g. linkname'd symbols.
+		varname = varSym.Name
+	} else {
+		// Convert "".<name> into a fully qualified package.sym name.
+		varname = objabi.PathToPrefix(myimportpath) + varSym.Name[len(`""`):]
+	}
+	dieSymName := dwarf.InfoPrefix + varname
+	dieSym := ctxt.LookupInit(dieSymName, func(s *LSym) {
+		s.Type = objabi.SDWARFVAR
+		s.Set(AttrDuplicateOK, true) // needed for shared linkage
+		ctxt.Data = append(ctxt.Data, s)
+	})
+	typeSym := ctxt.Lookup(dwarf.InfoPrefix + typename)
+	dwarf.PutGlobal(dwCtxt{ctxt}, dieSym, typeSym, varSym, varname)
+}
+
 func (ctxt *Link) DwarfAbstractFunc(curfn interface{}, s *LSym, myimportpath string) {
 	absfn := ctxt.DwFixups.AbsFuncDwarfSym(s)
 	if absfn.Size != 0 {
diff --git a/src/cmd/link/internal/ld/dwarf.go b/src/cmd/link/internal/ld/dwarf.go
index 561f6f1475..3c3f0e5b85 100644
--- a/src/cmd/link/internal/ld/dwarf.go
+++ b/src/cmd/link/internal/ld/dwarf.go
@@ -458,12 +458,6 @@ func newmemberoffsetattr(die *dwarf.DWDie, offs int32) {
 	newattr(die, dwarf.DW_AT_data_member_location, dwarf.DW_CLS_CONSTANT, int64(offs), nil)
 }
 
-// GDB doesn't like FORM_addr for AT_location, so emit a
-// location expression that evals to a const.
-func (d *dwctxt) newabslocexprattr(die *dwarf.DWDie, addr int64, symIdx loader.Sym) {
-	newattr(die, dwarf.DW_AT_location, dwarf.DW_CLS_ADDRESS, addr, dwSym(symIdx))
-}
-
 func (d *dwctxt) lookupOrDiag(n string) loader.Sym {
 	symIdx := d.ldr.Lookup(n, 0)
 	if symIdx == 0 {
@@ -1020,25 +1014,6 @@ func (d *dwctxt) synthesizechantypes(ctxt *Link, die *dwarf.DWDie) {
 	}
 }
 
-func (d *dwctxt) dwarfDefineGlobal(ctxt *Link, symIdx loader.Sym, str string, v int64, gotype loader.Sym) {
-	// Find a suitable CU DIE to include the global.
-	// One would think it's as simple as just looking at the unit, but that might
-	// not have any reachable code. So, we go to the runtime's CU if our unit
-	// isn't otherwise reachable.
-	unit := d.ldr.SymUnit(symIdx)
-	if unit == nil {
-		unit = ctxt.runtimeCU
-	}
-	ver := d.ldr.SymVersion(symIdx)
-	dv := d.newdie(unit.DWInfo, dwarf.DW_ABRV_VARIABLE, str, int(ver))
-	d.newabslocexprattr(dv, v, symIdx)
-	if d.ldr.SymVersion(symIdx) < sym.SymVerStatic {
-		newattr(dv, dwarf.DW_AT_external, dwarf.DW_CLS_FLAG, 1, 0)
-	}
-	dt := d.defgotype(gotype)
-	d.newrefattr(dv, dwarf.DW_AT_type, dt)
-}
-
 // createUnitLength creates the initial length field with value v and update
 // offset of unit_length if needed.
 func (d *dwctxt) createUnitLength(su *loader.SymbolBuilder, v uint64) {
@@ -1552,7 +1527,7 @@ func appendSyms(syms []loader.Sym, src []sym.LoaderSym) []loader.Sym {
 
 func (d *dwctxt) writeUnitInfo(u *sym.CompilationUnit, abbrevsym loader.Sym, infoEpilog loader.Sym) []loader.Sym {
 	syms := []loader.Sym{}
-	if len(u.Textp) == 0 && u.DWInfo.Child == nil {
+	if len(u.Textp) == 0 && u.DWInfo.Child == nil && len(u.VarDIEs) == 0 {
 		return syms
 	}
 
@@ -1583,6 +1558,7 @@ func (d *dwctxt) writeUnitInfo(u *sym.CompilationUnit, abbrevsym loader.Sym, inf
 	if u.Consts != 0 {
 		cu = append(cu, loader.Sym(u.Consts))
 	}
+	cu = appendSyms(cu, u.VarDIEs)
 	var cusize int64
 	for _, child := range cu {
 		cusize += int64(len(d.ldr.Data(child)))
@@ -1907,10 +1883,11 @@ func dwarfGenerateDebugInfo(ctxt *Link) {
 		checkStrictDups = 1
 	}
 
-	// Create DIEs for global variables and the types they use.
-	// FIXME: ideally this should be done in the compiler, since
-	// for globals there isn't any abiguity about which package
-	// a global belongs to.
+	// Make a pass through all data symbols, looking for those
+	// corresponding to reachable, Go-generated, user-visible
+	// global variables. For each global of this sort, locate
+	// the corresponding compiler-generated DIE symbol and tack
+	// it onto the list associated with the unit.
 	for idx := loader.Sym(1); idx < loader.Sym(d.ldr.NDef()); idx++ {
 		if !d.ldr.AttrReachable(idx) ||
 			d.ldr.AttrNotInSymbolTable(idx) ||
@@ -1925,7 +1902,8 @@ func dwarfGenerateDebugInfo(ctxt *Link) {
 			continue
 		}
 		// Skip things with no type
-		if d.ldr.SymGoType(idx) == 0 {
+		gt := d.ldr.SymGoType(idx)
+		if gt == 0 {
 			continue
 		}
 		// Skip file local symbols (this includes static tmps, stack
@@ -1939,10 +1917,20 @@ func dwarfGenerateDebugInfo(ctxt *Link) {
 			continue
 		}
 
-		// Create DIE for global.
-		sv := d.ldr.SymValue(idx)
-		gt := d.ldr.SymGoType(idx)
-		d.dwarfDefineGlobal(ctxt, idx, sn, sv, gt)
+		// Find compiler-generated DWARF info sym for global in question,
+		// and tack it onto the appropriate unit.  Note that there are
+		// circumstances under which we can't find the compiler-generated
+		// symbol-- this typically happens as a result of compiler options
+		// (e.g. compile package X with "-dwarf=0").
+
+		// FIXME: use an aux sym or a relocation here instead of a
+		// name lookup.
+		varDIE := d.ldr.Lookup(dwarf.InfoPrefix+sn, 0)
+		if varDIE != 0 {
+			unit := d.ldr.SymUnit(idx)
+			d.defgotype(gt)
+			unit.VarDIEs = append(unit.VarDIEs, sym.LoaderSym(varDIE))
+		}
 	}
 
 	d.synthesizestringtypes(ctxt, dwtypes.Child)
diff --git a/src/cmd/link/internal/sym/compilation_unit.go b/src/cmd/link/internal/sym/compilation_unit.go
index 5d7206db66..926cbc3d20 100644
--- a/src/cmd/link/internal/sym/compilation_unit.go
+++ b/src/cmd/link/internal/sym/compilation_unit.go
@@ -29,6 +29,7 @@ type CompilationUnit struct {
 
 	Consts    LoaderSym   // Package constants DIEs
 	FuncDIEs  []LoaderSym // Function DIE subtrees
+	VarDIEs   []LoaderSym // Global variable DIEs
 	AbsFnDIEs []LoaderSym // Abstract function DIE subtrees
 	RangeSyms []LoaderSym // Symbols for debug_range
 	Textp     []LoaderSym // Text symbols in this CU
-- 
GitLab


From d25476ebb2c645495db7ae22585a8e74171b106e Mon Sep 17 00:00:00 2001
From: eric fang <eric.fang@arm.com>
Date: Thu, 4 Mar 2021 03:41:52 +0000
Subject: [PATCH 1190/2400] cmd/internal/obj/arm64: fix constant pool size
 calculation error

The current calculation method of constant pool size is:
  c.pool.size = -c.pool.size & (funcAlign - 1)
  c.pool.size += uint32(sz)
This doesn't make sense. This CL changes it as:
  if q.As == ADWORD {
    c.pool.size = roundUp(c.pool.size, 8)
  }
  c.pool.size += uint32(sz)
which takes into account the padding size generated by aligning DWORD to
8 bytes.

It's unnecessary to set the Pc field in addpool and addpool128 because
the Pc value will be reset in function span7, so remove the related lines.

Change-Id: I5eb8f259be55a6b97fc2c20958b4a602bffa4f88
Reviewed-on: https://go-review.googlesource.com/c/go/+/298609
Reviewed-by: eric fang <eric.fang@arm.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: eric fang <eric.fang@arm.com>
Run-TryBot: eric fang <eric.fang@arm.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/internal/obj/arm64/asm7.go | 26 ++++++++++++++++++--------
 1 file changed, 18 insertions(+), 8 deletions(-)

diff --git a/src/cmd/internal/obj/arm64/asm7.go b/src/cmd/internal/obj/arm64/asm7.go
index 20f1843951..b0e29c26e8 100644
--- a/src/cmd/internal/obj/arm64/asm7.go
+++ b/src/cmd/internal/obj/arm64/asm7.go
@@ -1200,19 +1200,16 @@ func (c *ctxt7) flushpool(p *obj.Prog, skip int) {
 // addpool128 adds a 128-bit constant to literal pool by two consecutive DWORD
 // instructions, the 128-bit constant is formed by ah.Offset<<64+al.Offset.
 func (c *ctxt7) addpool128(p *obj.Prog, al, ah *obj.Addr) {
-	lit := al.Offset
 	q := c.newprog()
 	q.As = ADWORD
 	q.To.Type = obj.TYPE_CONST
-	q.To.Offset = lit
-	q.Pc = int64(c.pool.size)
+	q.To.Offset = al.Offset
 
-	lit = ah.Offset
 	t := c.newprog()
 	t.As = ADWORD
 	t.To.Type = obj.TYPE_CONST
-	t.To.Offset = lit
-	t.Pc = int64(c.pool.size + 8)
+	t.To.Offset = ah.Offset
+
 	q.Link = t
 
 	if c.blitrl == nil {
@@ -1223,6 +1220,7 @@ func (c *ctxt7) addpool128(p *obj.Prog, al, ah *obj.Addr) {
 	}
 
 	c.elitrl = t
+	c.pool.size = roundUp(c.pool.size, 16)
 	c.pool.size += 16
 	p.Pool = q
 }
@@ -1267,7 +1265,6 @@ func (c *ctxt7) addpool(p *obj.Prog, a *obj.Addr) {
 
 	q := c.newprog()
 	*q = *t
-	q.Pc = int64(c.pool.size)
 	if c.blitrl == nil {
 		c.blitrl = q
 		c.pool.start = uint32(p.Pc)
@@ -1275,11 +1272,24 @@ func (c *ctxt7) addpool(p *obj.Prog, a *obj.Addr) {
 		c.elitrl.Link = q
 	}
 	c.elitrl = q
-	c.pool.size = -c.pool.size & (funcAlign - 1)
+	if q.As == ADWORD {
+		// make DWORD 8-byte aligned, this is not required by ISA,
+		// just to avoid performance penalties when loading from
+		// the constant pool across a cache line.
+		c.pool.size = roundUp(c.pool.size, 8)
+	}
 	c.pool.size += uint32(sz)
 	p.Pool = q
 }
 
+// roundUp rounds up x to "to".
+func roundUp(x, to uint32) uint32 {
+	if to == 0 || to&(to-1) != 0 {
+		log.Fatalf("rounded up to a value that is not a power of 2: %d\n", to)
+	}
+	return (x + to - 1) &^ (to - 1)
+}
+
 func (c *ctxt7) regoff(a *obj.Addr) uint32 {
 	c.instoffset = 0
 	c.aclass(a)
-- 
GitLab


From b182ba7fabcd233a03bb8169634605a7fac6a856 Mon Sep 17 00:00:00 2001
From: fanzha02 <fannie.zhang@arm.com>
Date: Wed, 20 May 2020 08:49:59 +0000
Subject: [PATCH 1191/2400] cmd/compile: optimize codes with arm64 REV16
 instruction

Optimize some patterns into rev16/rev16w instruction.

Pattern1:
    (c & 0xff00ff00)>>8 | (c & 0x00ff00ff)<<8
To:
    rev16w c

Pattern2:
    (c & 0xff00ff00ff00ff00)>>8 | (c & 0x00ff00ff00ff00ff)<<8
To:
    rev16 c

This patch is a copy of CL 239637, contributed by Alice Xu(dianhong.xu@arm.com).

Change-Id: I96936c1db87618bc1903c04221c7e9b2779455b3
Reviewed-on: https://go-review.googlesource.com/c/go/+/268377
Trust: fannie zhang <Fannie.Zhang@arm.com>
Run-TryBot: fannie zhang <Fannie.Zhang@arm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/arm64/ssa.go         |   1 +
 src/cmd/compile/internal/ssa/gen/ARM64.rules  |  16 ++
 src/cmd/compile/internal/ssa/gen/ARM64Ops.go  |   1 +
 src/cmd/compile/internal/ssa/opGen.go         |  14 ++
 src/cmd/compile/internal/ssa/rewriteARM64.go  | 225 ++++++++++++++++++
 .../internal/test/testdata/arith_test.go      |  43 ++++
 test/codegen/bitfield.go                      |  20 ++
 7 files changed, 320 insertions(+)

diff --git a/src/cmd/compile/internal/arm64/ssa.go b/src/cmd/compile/internal/arm64/ssa.go
index afd0d66d72..0c997bc4b3 100644
--- a/src/cmd/compile/internal/arm64/ssa.go
+++ b/src/cmd/compile/internal/arm64/ssa.go
@@ -915,6 +915,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssa.OpARM64FCVTDS,
 		ssa.OpARM64REV,
 		ssa.OpARM64REVW,
+		ssa.OpARM64REV16,
 		ssa.OpARM64REV16W,
 		ssa.OpARM64RBIT,
 		ssa.OpARM64RBITW,
diff --git a/src/cmd/compile/internal/ssa/gen/ARM64.rules b/src/cmd/compile/internal/ssa/gen/ARM64.rules
index 7f9f8298de..1d2efdabe0 100644
--- a/src/cmd/compile/internal/ssa/gen/ARM64.rules
+++ b/src/cmd/compile/internal/ssa/gen/ARM64.rules
@@ -1762,9 +1762,25 @@
 		(CMPconst [64]  (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y))))) && cc == OpARM64LessThanU
 	=> (RORW x y)
 
+// rev16w | rev16
 // ((x>>8) | (x<<8)) => (REV16W x), the type of x is uint16, "|" can also be "^" or "+".
 ((ADDshiftLL|ORshiftLL|XORshiftLL) <typ.UInt16> [8] (UBFX <typ.UInt16> [armBFAuxInt(8, 8)] x) x) => (REV16W x)
 
+// ((x & 0xff00ff00)>>8) | ((x & 0x00ff00ff)<<8), "|" can also be "^" or "+".
+((ADDshiftLL|ORshiftLL|XORshiftLL) [8] (UBFX [armBFAuxInt(8, 24)] (ANDconst [c1] x)) (ANDconst [c2] x))
+	&& uint32(c1) == 0xff00ff00 && uint32(c2) == 0x00ff00ff
+	=> (REV16W x)
+
+// ((x & 0xff00ff00ff00ff00)>>8) | ((x & 0x00ff00ff00ff00ff)<<8), "|" can also be "^" or "+".
+((ADDshiftLL|ORshiftLL|XORshiftLL) [8] (SRLconst [8] (ANDconst [c1] x)) (ANDconst [c2] x))
+	&& (uint64(c1) == 0xff00ff00ff00ff00 && uint64(c2) == 0x00ff00ff00ff00ff)
+	=> (REV16 x)
+
+// ((x & 0xff00ff00)>>8) | ((x & 0x00ff00ff)<<8), "|" can also be "^" or "+".
+((ADDshiftLL|ORshiftLL|XORshiftLL) [8] (SRLconst [8] (ANDconst [c1] x)) (ANDconst [c2] x))
+	&& (uint64(c1) == 0xff00ff00 && uint64(c2) == 0x00ff00ff)
+	=> (REV16 (ANDconst <x.Type> [0xffffffff] x))
+
 // Extract from reg pair
 (ADDshiftLL [c] (SRLconst x [64-c]) x2) => (EXTRconst [64-c] x2 x)
 ( ORshiftLL [c] (SRLconst x [64-c]) x2) => (EXTRconst [64-c] x2 x)
diff --git a/src/cmd/compile/internal/ssa/gen/ARM64Ops.go b/src/cmd/compile/internal/ssa/gen/ARM64Ops.go
index 59a5ffaca4..148843cd8d 100644
--- a/src/cmd/compile/internal/ssa/gen/ARM64Ops.go
+++ b/src/cmd/compile/internal/ssa/gen/ARM64Ops.go
@@ -239,6 +239,7 @@ func init() {
 		{name: "FSQRTS", argLength: 1, reg: fp11, asm: "FSQRTS"},                              // sqrt(arg0), float32
 		{name: "REV", argLength: 1, reg: gp11, asm: "REV"},                                    // byte reverse, 64-bit
 		{name: "REVW", argLength: 1, reg: gp11, asm: "REVW"},                                  // byte reverse, 32-bit
+		{name: "REV16", argLength: 1, reg: gp11, asm: "REV16"},                                // byte reverse in each 16-bit halfword, 64-bit
 		{name: "REV16W", argLength: 1, reg: gp11, asm: "REV16W"},                              // byte reverse in each 16-bit halfword, 32-bit
 		{name: "RBIT", argLength: 1, reg: gp11, asm: "RBIT"},                                  // bit reverse, 64-bit
 		{name: "RBITW", argLength: 1, reg: gp11, asm: "RBITW"},                                // bit reverse, 32-bit
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index db51ed95c5..3f84a09289 100644
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -1366,6 +1366,7 @@ const (
 	OpARM64FSQRTS
 	OpARM64REV
 	OpARM64REVW
+	OpARM64REV16
 	OpARM64REV16W
 	OpARM64RBIT
 	OpARM64RBITW
@@ -18212,6 +18213,19 @@ var opcodeTable = [...]opInfo{
 			},
 		},
 	},
+	{
+		name:   "REV16",
+		argLen: 1,
+		asm:    arm64.AREV16,
+		reg: regInfo{
+			inputs: []inputInfo{
+				{0, 805044223}, // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R19 R20 R21 R22 R23 R24 R25 R26 g R30
+			},
+			outputs: []outputInfo{
+				{0, 670826495}, // R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R19 R20 R21 R22 R23 R24 R25 R26 R30
+			},
+		},
+	},
 	{
 		name:   "REV16W",
 		argLen: 1,
diff --git a/src/cmd/compile/internal/ssa/rewriteARM64.go b/src/cmd/compile/internal/ssa/rewriteARM64.go
index eb650b6a50..c961310018 100644
--- a/src/cmd/compile/internal/ssa/rewriteARM64.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM64.go
@@ -1772,6 +1772,81 @@ func rewriteValueARM64_OpARM64ADDshiftLL(v *Value) bool {
 		v.AddArg(x)
 		return true
 	}
+	// match: (ADDshiftLL [8] (UBFX [armBFAuxInt(8, 24)] (ANDconst [c1] x)) (ANDconst [c2] x))
+	// cond: uint32(c1) == 0xff00ff00 && uint32(c2) == 0x00ff00ff
+	// result: (REV16W x)
+	for {
+		if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64UBFX || auxIntToArm64BitField(v_0.AuxInt) != armBFAuxInt(8, 24) {
+			break
+		}
+		v_0_0 := v_0.Args[0]
+		if v_0_0.Op != OpARM64ANDconst {
+			break
+		}
+		c1 := auxIntToInt64(v_0_0.AuxInt)
+		x := v_0_0.Args[0]
+		if v_1.Op != OpARM64ANDconst {
+			break
+		}
+		c2 := auxIntToInt64(v_1.AuxInt)
+		if x != v_1.Args[0] || !(uint32(c1) == 0xff00ff00 && uint32(c2) == 0x00ff00ff) {
+			break
+		}
+		v.reset(OpARM64REV16W)
+		v.AddArg(x)
+		return true
+	}
+	// match: (ADDshiftLL [8] (SRLconst [8] (ANDconst [c1] x)) (ANDconst [c2] x))
+	// cond: (uint64(c1) == 0xff00ff00ff00ff00 && uint64(c2) == 0x00ff00ff00ff00ff)
+	// result: (REV16 x)
+	for {
+		if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != 8 {
+			break
+		}
+		v_0_0 := v_0.Args[0]
+		if v_0_0.Op != OpARM64ANDconst {
+			break
+		}
+		c1 := auxIntToInt64(v_0_0.AuxInt)
+		x := v_0_0.Args[0]
+		if v_1.Op != OpARM64ANDconst {
+			break
+		}
+		c2 := auxIntToInt64(v_1.AuxInt)
+		if x != v_1.Args[0] || !(uint64(c1) == 0xff00ff00ff00ff00 && uint64(c2) == 0x00ff00ff00ff00ff) {
+			break
+		}
+		v.reset(OpARM64REV16)
+		v.AddArg(x)
+		return true
+	}
+	// match: (ADDshiftLL [8] (SRLconst [8] (ANDconst [c1] x)) (ANDconst [c2] x))
+	// cond: (uint64(c1) == 0xff00ff00 && uint64(c2) == 0x00ff00ff)
+	// result: (REV16 (ANDconst <x.Type> [0xffffffff] x))
+	for {
+		if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != 8 {
+			break
+		}
+		v_0_0 := v_0.Args[0]
+		if v_0_0.Op != OpARM64ANDconst {
+			break
+		}
+		c1 := auxIntToInt64(v_0_0.AuxInt)
+		x := v_0_0.Args[0]
+		if v_1.Op != OpARM64ANDconst {
+			break
+		}
+		c2 := auxIntToInt64(v_1.AuxInt)
+		if x != v_1.Args[0] || !(uint64(c1) == 0xff00ff00 && uint64(c2) == 0x00ff00ff) {
+			break
+		}
+		v.reset(OpARM64REV16)
+		v0 := b.NewValue0(v.Pos, OpARM64ANDconst, x.Type)
+		v0.AuxInt = int64ToAuxInt(0xffffffff)
+		v0.AddArg(x)
+		v.AddArg(v0)
+		return true
+	}
 	// match: (ADDshiftLL [c] (SRLconst x [64-c]) x2)
 	// result: (EXTRconst [64-c] x2 x)
 	for {
@@ -17850,6 +17925,81 @@ func rewriteValueARM64_OpARM64ORshiftLL(v *Value) bool {
 		v.AddArg(x)
 		return true
 	}
+	// match: (ORshiftLL [8] (UBFX [armBFAuxInt(8, 24)] (ANDconst [c1] x)) (ANDconst [c2] x))
+	// cond: uint32(c1) == 0xff00ff00 && uint32(c2) == 0x00ff00ff
+	// result: (REV16W x)
+	for {
+		if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64UBFX || auxIntToArm64BitField(v_0.AuxInt) != armBFAuxInt(8, 24) {
+			break
+		}
+		v_0_0 := v_0.Args[0]
+		if v_0_0.Op != OpARM64ANDconst {
+			break
+		}
+		c1 := auxIntToInt64(v_0_0.AuxInt)
+		x := v_0_0.Args[0]
+		if v_1.Op != OpARM64ANDconst {
+			break
+		}
+		c2 := auxIntToInt64(v_1.AuxInt)
+		if x != v_1.Args[0] || !(uint32(c1) == 0xff00ff00 && uint32(c2) == 0x00ff00ff) {
+			break
+		}
+		v.reset(OpARM64REV16W)
+		v.AddArg(x)
+		return true
+	}
+	// match: (ORshiftLL [8] (SRLconst [8] (ANDconst [c1] x)) (ANDconst [c2] x))
+	// cond: (uint64(c1) == 0xff00ff00ff00ff00 && uint64(c2) == 0x00ff00ff00ff00ff)
+	// result: (REV16 x)
+	for {
+		if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != 8 {
+			break
+		}
+		v_0_0 := v_0.Args[0]
+		if v_0_0.Op != OpARM64ANDconst {
+			break
+		}
+		c1 := auxIntToInt64(v_0_0.AuxInt)
+		x := v_0_0.Args[0]
+		if v_1.Op != OpARM64ANDconst {
+			break
+		}
+		c2 := auxIntToInt64(v_1.AuxInt)
+		if x != v_1.Args[0] || !(uint64(c1) == 0xff00ff00ff00ff00 && uint64(c2) == 0x00ff00ff00ff00ff) {
+			break
+		}
+		v.reset(OpARM64REV16)
+		v.AddArg(x)
+		return true
+	}
+	// match: (ORshiftLL [8] (SRLconst [8] (ANDconst [c1] x)) (ANDconst [c2] x))
+	// cond: (uint64(c1) == 0xff00ff00 && uint64(c2) == 0x00ff00ff)
+	// result: (REV16 (ANDconst <x.Type> [0xffffffff] x))
+	for {
+		if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != 8 {
+			break
+		}
+		v_0_0 := v_0.Args[0]
+		if v_0_0.Op != OpARM64ANDconst {
+			break
+		}
+		c1 := auxIntToInt64(v_0_0.AuxInt)
+		x := v_0_0.Args[0]
+		if v_1.Op != OpARM64ANDconst {
+			break
+		}
+		c2 := auxIntToInt64(v_1.AuxInt)
+		if x != v_1.Args[0] || !(uint64(c1) == 0xff00ff00 && uint64(c2) == 0x00ff00ff) {
+			break
+		}
+		v.reset(OpARM64REV16)
+		v0 := b.NewValue0(v.Pos, OpARM64ANDconst, x.Type)
+		v0.AuxInt = int64ToAuxInt(0xffffffff)
+		v0.AddArg(x)
+		v.AddArg(v0)
+		return true
+	}
 	// match: ( ORshiftLL [c] (SRLconst x [64-c]) x2)
 	// result: (EXTRconst [64-c] x2 x)
 	for {
@@ -21723,6 +21873,81 @@ func rewriteValueARM64_OpARM64XORshiftLL(v *Value) bool {
 		v.AddArg(x)
 		return true
 	}
+	// match: (XORshiftLL [8] (UBFX [armBFAuxInt(8, 24)] (ANDconst [c1] x)) (ANDconst [c2] x))
+	// cond: uint32(c1) == 0xff00ff00 && uint32(c2) == 0x00ff00ff
+	// result: (REV16W x)
+	for {
+		if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64UBFX || auxIntToArm64BitField(v_0.AuxInt) != armBFAuxInt(8, 24) {
+			break
+		}
+		v_0_0 := v_0.Args[0]
+		if v_0_0.Op != OpARM64ANDconst {
+			break
+		}
+		c1 := auxIntToInt64(v_0_0.AuxInt)
+		x := v_0_0.Args[0]
+		if v_1.Op != OpARM64ANDconst {
+			break
+		}
+		c2 := auxIntToInt64(v_1.AuxInt)
+		if x != v_1.Args[0] || !(uint32(c1) == 0xff00ff00 && uint32(c2) == 0x00ff00ff) {
+			break
+		}
+		v.reset(OpARM64REV16W)
+		v.AddArg(x)
+		return true
+	}
+	// match: (XORshiftLL [8] (SRLconst [8] (ANDconst [c1] x)) (ANDconst [c2] x))
+	// cond: (uint64(c1) == 0xff00ff00ff00ff00 && uint64(c2) == 0x00ff00ff00ff00ff)
+	// result: (REV16 x)
+	for {
+		if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != 8 {
+			break
+		}
+		v_0_0 := v_0.Args[0]
+		if v_0_0.Op != OpARM64ANDconst {
+			break
+		}
+		c1 := auxIntToInt64(v_0_0.AuxInt)
+		x := v_0_0.Args[0]
+		if v_1.Op != OpARM64ANDconst {
+			break
+		}
+		c2 := auxIntToInt64(v_1.AuxInt)
+		if x != v_1.Args[0] || !(uint64(c1) == 0xff00ff00ff00ff00 && uint64(c2) == 0x00ff00ff00ff00ff) {
+			break
+		}
+		v.reset(OpARM64REV16)
+		v.AddArg(x)
+		return true
+	}
+	// match: (XORshiftLL [8] (SRLconst [8] (ANDconst [c1] x)) (ANDconst [c2] x))
+	// cond: (uint64(c1) == 0xff00ff00 && uint64(c2) == 0x00ff00ff)
+	// result: (REV16 (ANDconst <x.Type> [0xffffffff] x))
+	for {
+		if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != 8 {
+			break
+		}
+		v_0_0 := v_0.Args[0]
+		if v_0_0.Op != OpARM64ANDconst {
+			break
+		}
+		c1 := auxIntToInt64(v_0_0.AuxInt)
+		x := v_0_0.Args[0]
+		if v_1.Op != OpARM64ANDconst {
+			break
+		}
+		c2 := auxIntToInt64(v_1.AuxInt)
+		if x != v_1.Args[0] || !(uint64(c1) == 0xff00ff00 && uint64(c2) == 0x00ff00ff) {
+			break
+		}
+		v.reset(OpARM64REV16)
+		v0 := b.NewValue0(v.Pos, OpARM64ANDconst, x.Type)
+		v0.AuxInt = int64ToAuxInt(0xffffffff)
+		v0.AddArg(x)
+		v.AddArg(v0)
+		return true
+	}
 	// match: (XORshiftLL [c] (SRLconst x [64-c]) x2)
 	// result: (EXTRconst [64-c] x2 x)
 	for {
diff --git a/src/cmd/compile/internal/test/testdata/arith_test.go b/src/cmd/compile/internal/test/testdata/arith_test.go
index 158fedc28e..7d54a9181d 100644
--- a/src/cmd/compile/internal/test/testdata/arith_test.go
+++ b/src/cmd/compile/internal/test/testdata/arith_test.go
@@ -1452,3 +1452,46 @@ func testDivisibility(t *testing.T) {
 		}
 	}
 }
+
+//go:noinline
+func genREV16_1(c uint64) uint64 {
+	b := ((c & 0xff00ff00ff00ff00) >> 8) | ((c & 0x00ff00ff00ff00ff) << 8)
+	return b
+}
+
+//go:noinline
+func genREV16_2(c uint64) uint64 {
+	b := ((c & 0xff00ff00) >> 8) | ((c & 0x00ff00ff) << 8)
+	return b
+}
+
+//go:noinline
+func genREV16W(c uint32) uint32 {
+	b := ((c & 0xff00ff00) >> 8) | ((c & 0x00ff00ff) << 8)
+	return b
+}
+
+func TestREV16(t *testing.T) {
+	x := uint64(0x8f7f6f5f4f3f2f1f)
+	want1 := uint64(0x7f8f5f6f3f4f1f2f)
+	want2 := uint64(0x3f4f1f2f)
+
+	got1 := genREV16_1(x)
+	if got1 != want1 {
+		t.Errorf("genREV16_1(%#x) = %#x want %#x", x, got1, want1)
+	}
+	got2 := genREV16_2(x)
+	if got2 != want2 {
+		t.Errorf("genREV16_2(%#x) = %#x want %#x", x, got2, want2)
+	}
+}
+
+func TestREV16W(t *testing.T) {
+	x := uint32(0x4f3f2f1f)
+	want := uint32(0x3f4f1f2f)
+
+	got := genREV16W(x)
+	if got != want {
+		t.Errorf("genREV16W(%#x) = %#x want %#x", x, got, want)
+	}
+}
diff --git a/test/codegen/bitfield.go b/test/codegen/bitfield.go
index 7abc1c2783..8acefbd027 100644
--- a/test/codegen/bitfield.go
+++ b/test/codegen/bitfield.go
@@ -244,3 +244,23 @@ func shift_no_cmp(x int) int {
 	// mips64:`SLLV\t[$]17`,-`SGT`
 	return x << 17
 }
+
+func rev16(c uint64) (uint64, uint64, uint64) {
+	// arm64:`REV16`,-`AND`,-`LSR`,-`AND`,-`ORR\tR[0-9]+<<8`
+	b1 := ((c & 0xff00ff00ff00ff00) >> 8) | ((c & 0x00ff00ff00ff00ff) << 8)
+	// arm64:-`ADD\tR[0-9]+<<8`
+	b2 := ((c & 0xff00ff00ff00ff00) >> 8) + ((c & 0x00ff00ff00ff00ff) << 8)
+	// arm64:-`EOR\tR[0-9]+<<8`
+	b3 := ((c & 0xff00ff00ff00ff00) >> 8) ^ ((c & 0x00ff00ff00ff00ff) << 8)
+	return b1, b2, b3
+}
+
+func rev16w(c uint32) (uint32, uint32, uint32) {
+	// arm64:`REV16W`,-`AND`,-`UBFX`,-`AND`,-`ORR\tR[0-9]+<<8`
+	b1 := ((c & 0xff00ff00) >> 8) | ((c & 0x00ff00ff) << 8)
+	// arm64:-`ADD\tR[0-9]+<<8`
+	b2 := ((c & 0xff00ff00) >> 8) + ((c & 0x00ff00ff) << 8)
+	// arm64:-`EOR\tR[0-9]+<<8`
+	b3 := ((c & 0xff00ff00) >> 8) ^ ((c & 0x00ff00ff) << 8)
+	return b1, b2, b3
+}
-- 
GitLab


From b8371d495bb291f61e4fa3ac1b84116c70ac1223 Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Thu, 11 Feb 2021 19:10:10 +0100
Subject: [PATCH 1192/2400] runtime: support long paths without fixup on
 Windows 10 >= 1607

Windows 10 >= 1607 allows CreateFile and friends to use long paths if
bit 0x80 of the PEB's BitField member is set.

In time this means we'll be able to entirely drop our long path hacks,
which have never really worked right (see bugs below). Until that point,
we'll simply have things working well on recent Windows.

Updates #41734.
Updates #21782.
Updates #36375.

Change-Id: I765de6ea4859dd4e4b8ca80af7f337994734118e
Reviewed-on: https://go-review.googlesource.com/c/go/+/291291
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
---
 src/os/export_windows_test.go |  1 +
 src/os/path_windows.go        |  7 +++
 src/os/path_windows_test.go   | 23 +++++++++
 src/runtime/os_windows.go     | 97 +++++++++++++++++++++++++++++++----
 4 files changed, 118 insertions(+), 10 deletions(-)

diff --git a/src/os/export_windows_test.go b/src/os/export_windows_test.go
index f36fadb58b..ff4f8995f8 100644
--- a/src/os/export_windows_test.go
+++ b/src/os/export_windows_test.go
@@ -8,6 +8,7 @@ package os
 
 var (
 	FixLongPath       = fixLongPath
+	CanUseLongPaths   = canUseLongPaths
 	NewConsoleFile    = newConsoleFile
 	CommandLineToArgv = commandLineToArgv
 )
diff --git a/src/os/path_windows.go b/src/os/path_windows.go
index 87b1cac531..a96245f358 100644
--- a/src/os/path_windows.go
+++ b/src/os/path_windows.go
@@ -128,6 +128,10 @@ func dirname(path string) string {
 	return vol + dir
 }
 
+// This is set via go:linkname on runtime.canUseLongPaths, and is true when the OS
+// supports opting into proper long path handling without the need for fixups.
+var canUseLongPaths bool
+
 // fixLongPath returns the extended-length (\\?\-prefixed) form of
 // path when needed, in order to avoid the default 260 character file
 // path limit imposed by Windows. If path is not easily converted to
@@ -137,6 +141,9 @@ func dirname(path string) string {
 //
 // See https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx#maxpath
 func fixLongPath(path string) string {
+	if canUseLongPaths {
+		return path
+	}
 	// Do nothing (and don't allocate) if the path is "short".
 	// Empirically (at least on the Windows Server 2013 builder),
 	// the kernel is arbitrarily okay with < 248 bytes. That
diff --git a/src/os/path_windows_test.go b/src/os/path_windows_test.go
index 869db8fd6c..a23a079f77 100644
--- a/src/os/path_windows_test.go
+++ b/src/os/path_windows_test.go
@@ -12,6 +12,9 @@ import (
 )
 
 func TestFixLongPath(t *testing.T) {
+	if os.CanUseLongPaths {
+		return
+	}
 	// 248 is long enough to trigger the longer-than-248 checks in
 	// fixLongPath, but short enough not to make a path component
 	// longer than 255, which is illegal on Windows. (which
@@ -46,6 +49,26 @@ func TestFixLongPath(t *testing.T) {
 	}
 }
 
+func TestMkdirAllLongPath(t *testing.T) {
+	tmpDir, err := os.MkdirTemp("", "TestMkdirAllLongPath")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmpDir)
+	path := tmpDir
+	for i := 0; i < 100; i++ {
+		path += `\another-path-component`
+	}
+	err = os.MkdirAll(path, 0777)
+	if err != nil {
+		t.Fatalf("MkdirAll(%q) failed; %v", path, err)
+	}
+	err = os.RemoveAll(tmpDir)
+	if err != nil {
+		t.Fatalf("RemoveAll(%q) failed; %v", tmpDir, err)
+	}
+}
+
 func TestMkdirAllExtendedLength(t *testing.T) {
 	tmpDir, err := os.MkdirTemp("", "TestMkdirAllExtendedLength")
 	if err != nil {
diff --git a/src/runtime/os_windows.go b/src/runtime/os_windows.go
index f4e21a93ed..707c9054b5 100644
--- a/src/runtime/os_windows.go
+++ b/src/runtime/os_windows.go
@@ -18,6 +18,7 @@ const (
 //go:cgo_import_dynamic runtime._AddVectoredExceptionHandler AddVectoredExceptionHandler%2 "kernel32.dll"
 //go:cgo_import_dynamic runtime._CloseHandle CloseHandle%1 "kernel32.dll"
 //go:cgo_import_dynamic runtime._CreateEventA CreateEventA%4 "kernel32.dll"
+//go:cgo_import_dynamic runtime._CreateFileA CreateFileA%7 "kernel32.dll"
 //go:cgo_import_dynamic runtime._CreateIoCompletionPort CreateIoCompletionPort%4 "kernel32.dll"
 //go:cgo_import_dynamic runtime._CreateThread CreateThread%6 "kernel32.dll"
 //go:cgo_import_dynamic runtime._CreateWaitableTimerA CreateWaitableTimerA%3 "kernel32.dll"
@@ -67,6 +68,7 @@ var (
 	_AddVectoredExceptionHandler,
 	_CloseHandle,
 	_CreateEventA,
+	_CreateFileA,
 	_CreateIoCompletionPort,
 	_CreateThread,
 	_CreateWaitableTimerA,
@@ -132,7 +134,9 @@ var (
 	// Load ntdll.dll manually during startup, otherwise Mingw
 	// links wrong printf function to cgo executable (see issue
 	// 12030 for details).
-	_NtWaitForSingleObject stdFunction
+	_NtWaitForSingleObject  stdFunction
+	_RtlGetCurrentPeb       stdFunction
+	_RtlGetNtVersionNumbers stdFunction
 
 	// These are from non-kernel32.dll, so we prefer to LoadLibraryEx them.
 	_timeBeginPeriod,
@@ -219,21 +223,22 @@ func windowsFindfunc(lib uintptr, name []byte) stdFunction {
 	return stdFunction(unsafe.Pointer(f))
 }
 
-var sysDirectory [521]byte
+const _MAX_PATH = 260 // https://docs.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation
+var sysDirectory [_MAX_PATH + 1]byte
 var sysDirectoryLen uintptr
 
 func windowsLoadSystemLib(name []byte) uintptr {
+	if sysDirectoryLen == 0 {
+		l := stdcall2(_GetSystemDirectoryA, uintptr(unsafe.Pointer(&sysDirectory[0])), uintptr(len(sysDirectory)-1))
+		if l == 0 || l > uintptr(len(sysDirectory)-1) {
+			throw("Unable to determine system directory")
+		}
+		sysDirectory[l] = '\\'
+		sysDirectoryLen = l + 1
+	}
 	if useLoadLibraryEx {
 		return stdcall3(_LoadLibraryExA, uintptr(unsafe.Pointer(&name[0])), 0, _LOAD_LIBRARY_SEARCH_SYSTEM32)
 	} else {
-		if sysDirectoryLen == 0 {
-			l := stdcall2(_GetSystemDirectoryA, uintptr(unsafe.Pointer(&sysDirectory[0])), uintptr(len(sysDirectory)-1))
-			if l == 0 || l > uintptr(len(sysDirectory)-1) {
-				throw("Unable to determine system directory")
-			}
-			sysDirectory[l] = '\\'
-			sysDirectoryLen = l + 1
-		}
 		absName := append(sysDirectory[:sysDirectoryLen], name...)
 		return stdcall1(_LoadLibraryA, uintptr(unsafe.Pointer(&absName[0])))
 	}
@@ -266,6 +271,8 @@ func loadOptionalSyscalls() {
 		throw("ntdll.dll not found")
 	}
 	_NtWaitForSingleObject = windowsFindfunc(n32, []byte("NtWaitForSingleObject\000"))
+	_RtlGetCurrentPeb = windowsFindfunc(n32, []byte("RtlGetCurrentPeb\000"))
+	_RtlGetNtVersionNumbers = windowsFindfunc(n32, []byte("RtlGetNtVersionNumbers\000"))
 
 	if !haveCputicksAsm {
 		_QueryPerformanceCounter = windowsFindfunc(k32, []byte("QueryPerformanceCounter\000"))
@@ -471,6 +478,74 @@ func initHighResTimer() {
 	}
 }
 
+//go:linkname canUseLongPaths os.canUseLongPaths
+var canUseLongPaths bool
+
+// We want this to be large enough to hold the contents of sysDirectory, *plus*
+// a slash and another component that itself is greater than MAX_PATH.
+var longFileName [(_MAX_PATH+1)*2 + 1]byte
+
+// initLongPathSupport initializes the canUseLongPaths variable, which is
+// linked into os.canUseLongPaths for determining whether or not long paths
+// need to be fixed up. In the best case, this function is running on newer
+// Windows 10 builds, which have a bit field member of the PEB called
+// "IsLongPathAwareProcess." When this is set, we don't need to go through the
+// error-prone fixup function in order to access long paths. So this init
+// function first checks the Windows build number, sets the flag, and then
+// tests to see if it's actually working. If everything checks out, then
+// canUseLongPaths is set to true, and later when called, os.fixLongPath
+// returns early without doing work.
+func initLongPathSupport() {
+	const (
+		IsLongPathAwareProcess = 0x80
+		PebBitFieldOffset      = 3
+		OPEN_EXISTING          = 3
+		ERROR_PATH_NOT_FOUND   = 3
+	)
+
+	// Check that we're ≥ 10.0.15063.
+	var maj, min, build uint32
+	stdcall3(_RtlGetNtVersionNumbers, uintptr(unsafe.Pointer(&maj)), uintptr(unsafe.Pointer(&min)), uintptr(unsafe.Pointer(&build)))
+	if maj < 10 || (maj == 10 && min == 0 && build&0xffff < 15063) {
+		return
+	}
+
+	// Set the IsLongPathAwareProcess flag of the PEB's bit field.
+	bitField := (*byte)(unsafe.Pointer(stdcall0(_RtlGetCurrentPeb) + PebBitFieldOffset))
+	originalBitField := *bitField
+	*bitField |= IsLongPathAwareProcess
+
+	// Check that this actually has an effect, by constructing a large file
+	// path and seeing whether we get ERROR_PATH_NOT_FOUND, rather than
+	// some other error, which would indicate the path is too long, and
+	// hence long path support is not successful. This whole section is NOT
+	// strictly necessary, but is a nice validity check for the near to
+	// medium term, when this functionality is still relatively new in
+	// Windows.
+	getRandomData(longFileName[len(longFileName)-33 : len(longFileName)-1])
+	start := copy(longFileName[:], sysDirectory[:sysDirectoryLen])
+	const dig = "0123456789abcdef"
+	for i := 0; i < 32; i++ {
+		longFileName[start+i*2] = dig[longFileName[len(longFileName)-33+i]>>4]
+		longFileName[start+i*2+1] = dig[longFileName[len(longFileName)-33+i]&0xf]
+	}
+	start += 64
+	for i := start; i < len(longFileName)-1; i++ {
+		longFileName[i] = 'A'
+	}
+	stdcall7(_CreateFileA, uintptr(unsafe.Pointer(&longFileName[0])), 0, 0, 0, OPEN_EXISTING, 0, 0)
+	// The ERROR_PATH_NOT_FOUND error value is distinct from
+	// ERROR_FILE_NOT_FOUND or ERROR_INVALID_NAME, the latter of which we
+	// expect here due to the final component being too long.
+	if getlasterror() == ERROR_PATH_NOT_FOUND {
+		*bitField = originalBitField
+		println("runtime: warning: IsLongPathAwareProcess failed to enable long paths; proceeding in fixup mode")
+		return
+	}
+
+	canUseLongPaths = true
+}
+
 func osinit() {
 	asmstdcallAddr = unsafe.Pointer(funcPC(asmstdcall))
 
@@ -487,6 +562,8 @@ func osinit() {
 	initHighResTimer()
 	timeBeginPeriodRetValue = osRelax(false)
 
+	initLongPathSupport()
+
 	ncpu = getproccount()
 
 	physPageSize = getPageSize()
-- 
GitLab


From 0265b6475f08f2c23a742132db87c357fcbfa458 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Thu, 18 Mar 2021 14:36:39 -0700
Subject: [PATCH 1193/2400] cmd/compile: replace calls to typecheck with
 transform functions

For additions, compares, and slices, create transform functions that do
just the transformations for those nodes by the typecheck package (given
that the code has been fully typechecked by types2). For nodes that have
no args with typeparams, we call these transform functions directly in
noder2. But for nodes that have args with typeparams, we have to delay
and call the tranform functions during stenciling, since we don't know
the specific types involved.

We indicate that a node still needs transformation by setting Typecheck
to a new value 3. This value means the current type of the node has been
set (via types2), but the node may still need transformation.

Had to export typcheck.IsCmp and typecheck.Assignop from the typecheck
package.

Added new tests list2.go (required delaying compare typecheck/transform
because of != compare in checkList) and adder.go (requires delaying add
typecheck/transform, since it can do addition for numbers or strings).

There are several more transformation functions needed for expressions
(indexing, calls, etc.) and several more complicated ones needed for
statements (mainly various kinds of assignments).

Change-Id: I7d89d13a4108308ea0304a4b815ab60b40c59b0a
Reviewed-on: https://go-review.googlesource.com/c/go/+/303091
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/ir/node.go           |   6 +
 src/cmd/compile/internal/noder/expr.go        |   6 +-
 src/cmd/compile/internal/noder/helpers.go     | 126 +++-
 src/cmd/compile/internal/noder/stencil.go     |  17 +
 src/cmd/compile/internal/typecheck/expr.go    |   8 +-
 src/cmd/compile/internal/typecheck/stmt.go    |   6 +-
 src/cmd/compile/internal/typecheck/subr.go    |   6 +-
 .../compile/internal/typecheck/typecheck.go   |   4 +-
 test/typeparam/adder.go                       |  29 +
 test/typeparam/list2.go                       | 601 ++++++++++++++++++
 10 files changed, 785 insertions(+), 24 deletions(-)
 create mode 100644 test/typeparam/adder.go
 create mode 100644 test/typeparam/list2.go

diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 38f9123582..7bce0e985c 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -48,6 +48,12 @@ type Node interface {
 	SetEsc(x uint16)
 	Diag() bool
 	SetDiag(x bool)
+
+	// Typecheck values:
+	//  0 means the node is not typechecked
+	//  1 means the node is completely typechecked
+	//  2 means typechecking of the node is in progress
+	//  3 means the node has its type from types2, but may need transformation
 	Typecheck() uint8
 	SetTypecheck(x uint8)
 	NonNil() bool
diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index 957295bdf0..effc63c09a 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -64,7 +64,7 @@ func (g *irgen) expr(expr syntax.Expr) ir.Node {
 	}
 
 	n := g.expr0(typ, expr)
-	if n.Typecheck() != 1 {
+	if n.Typecheck() != 1 && n.Typecheck() != 3 {
 		base.FatalfAt(g.pos(expr), "missed typecheck: %+v", n)
 	}
 	if !g.match(n.Type(), typ, tv.HasOk()) {
@@ -161,7 +161,7 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 		return g.selectorExpr(pos, typ, expr)
 
 	case *syntax.SliceExpr:
-		return Slice(pos, g.expr(expr.X), g.expr(expr.Index[0]), g.expr(expr.Index[1]), g.expr(expr.Index[2]))
+		return Slice(pos, g.typ(typ), g.expr(expr.X), g.expr(expr.Index[0]), g.expr(expr.Index[1]), g.expr(expr.Index[2]))
 
 	case *syntax.Operation:
 		if expr.Y == nil {
@@ -171,7 +171,7 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 		case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
 			return Compare(pos, g.typ(typ), op, g.expr(expr.X), g.expr(expr.Y))
 		default:
-			return Binary(pos, op, g.expr(expr.X), g.expr(expr.Y))
+			return Binary(pos, op, g.typ(typ), g.expr(expr.X), g.expr(expr.Y))
 		}
 
 	default:
diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
index 1210d4b58c..e4a1a54fe8 100644
--- a/src/cmd/compile/internal/noder/helpers.go
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -67,16 +67,47 @@ func Assert(pos src.XPos, x ir.Node, typ *types.Type) ir.Node {
 	return typed(typ, ir.NewTypeAssertExpr(pos, x, nil))
 }
 
-func Binary(pos src.XPos, op ir.Op, x, y ir.Node) ir.Node {
+// transformAdd transforms an addition operation (currently just addition of
+// strings). Equivalent to the "binary operators" case in typecheck.typecheck1.
+func transformAdd(n *ir.BinaryExpr) ir.Node {
+	l := n.X
+	if l.Type().IsString() {
+		var add *ir.AddStringExpr
+		if l.Op() == ir.OADDSTR {
+			add = l.(*ir.AddStringExpr)
+			add.SetPos(n.Pos())
+		} else {
+			add = ir.NewAddStringExpr(n.Pos(), []ir.Node{l})
+		}
+		r := n.Y
+		if r.Op() == ir.OADDSTR {
+			r := r.(*ir.AddStringExpr)
+			add.List.Append(r.List.Take()...)
+		} else {
+			add.List.Append(r)
+		}
+		add.SetType(l.Type())
+		return add
+	}
+	return n
+}
+
+func Binary(pos src.XPos, op ir.Op, typ *types.Type, x, y ir.Node) ir.Node {
 	switch op {
 	case ir.OANDAND, ir.OOROR:
 		return typed(x.Type(), ir.NewLogicalExpr(pos, op, x, y))
 	case ir.OADD:
-		if x.Type().IsString() {
-			// TODO(mdempsky): Construct OADDSTR directly.
-			return typecheck.Expr(ir.NewBinaryExpr(pos, op, x, y))
+		n := ir.NewBinaryExpr(pos, op, x, y)
+		if x.Type().HasTParam() || y.Type().HasTParam() {
+			// Delay transformAdd() if either arg has a type param,
+			// since it needs to know the exact types to decide whether
+			// to transform OADD to OADDSTR.
+			n.SetType(typ)
+			n.SetTypecheck(3)
+			return n
 		}
-		fallthrough
+		n1 := transformAdd(n)
+		return typed(typ, n1)
 	default:
 		return typed(x.Type(), ir.NewBinaryExpr(pos, op, x, y))
 	}
@@ -178,12 +209,56 @@ func Call(pos src.XPos, typ *types.Type, fun ir.Node, args []ir.Node, dots bool)
 	return n
 }
 
+// transformCompare transforms a compare operation (currently just equals/not
+// equals). Equivalent to the "comparison operators" case in
+// typecheck.typecheck1, including tcArith.
+func transformCompare(n *ir.BinaryExpr) {
+	if (n.Op() == ir.OEQ || n.Op() == ir.ONE) && !types.Identical(n.X.Type(), n.Y.Type()) {
+		// Comparison is okay as long as one side is assignable to the
+		// other. The only allowed case where the conversion is not CONVNOP is
+		// "concrete == interface". In that case, check comparability of
+		// the concrete type. The conversion allocates, so only do it if
+		// the concrete type is huge.
+		l, r := n.X, n.Y
+		lt, rt := l.Type(), r.Type()
+		converted := false
+		if rt.Kind() != types.TBLANK {
+			aop, _ := typecheck.Assignop(lt, rt)
+			if aop != ir.OXXX {
+				types.CalcSize(lt)
+				if rt.IsInterface() == lt.IsInterface() || lt.Width >= 1<<16 {
+					l = ir.NewConvExpr(base.Pos, aop, rt, l)
+					l.SetTypecheck(1)
+				}
+
+				converted = true
+			}
+		}
+
+		if !converted && lt.Kind() != types.TBLANK {
+			aop, _ := typecheck.Assignop(rt, lt)
+			if aop != ir.OXXX {
+				types.CalcSize(rt)
+				if rt.IsInterface() == lt.IsInterface() || rt.Width >= 1<<16 {
+					r = ir.NewConvExpr(base.Pos, aop, lt, r)
+					r.SetTypecheck(1)
+				}
+			}
+		}
+		n.X, n.Y = l, r
+	}
+}
+
 func Compare(pos src.XPos, typ *types.Type, op ir.Op, x, y ir.Node) ir.Node {
 	n := ir.NewBinaryExpr(pos, op, x, y)
-	if !types.Identical(x.Type(), y.Type()) {
-		// TODO(mdempsky): Handle subtleties of constructing mixed-typed comparisons.
-		n = typecheck.Expr(n).(*ir.BinaryExpr)
+	if x.Type().HasTParam() || y.Type().HasTParam() {
+		// Delay transformCompare() if either arg has a type param, since
+		// it needs to know the exact types to decide on any needed conversions.
+		n.SetType(typ)
+		n.SetTypecheck(3)
+		return n
 	}
+	transformCompare(n)
 	return typed(typ, n)
 }
 
@@ -267,13 +342,42 @@ func Index(pos src.XPos, typ *types.Type, x, index ir.Node) ir.Node {
 	return typecheck.Expr(n)
 }
 
-func Slice(pos src.XPos, x, low, high, max ir.Node) ir.Node {
+// transformSlice transforms a slice operation.  Equivalent to typecheck.tcSlice.
+func transformSlice(n *ir.SliceExpr) {
+	l := n.X
+	if l.Type().IsArray() {
+		addr := typecheck.NodAddr(n.X)
+		addr.SetImplicit(true)
+		typed(types.NewPtr(n.X.Type()), addr)
+		n.X = addr
+		l = addr
+	}
+	t := l.Type()
+	if t.IsString() {
+		n.SetOp(ir.OSLICESTR)
+	} else if t.IsPtr() && t.Elem().IsArray() {
+		if n.Op().IsSlice3() {
+			n.SetOp(ir.OSLICE3ARR)
+		} else {
+			n.SetOp(ir.OSLICEARR)
+		}
+	}
+}
+
+func Slice(pos src.XPos, typ *types.Type, x, low, high, max ir.Node) ir.Node {
 	op := ir.OSLICE
 	if max != nil {
 		op = ir.OSLICE3
 	}
-	// TODO(mdempsky): Avoid typecheck.Expr.
-	return typecheck.Expr(ir.NewSliceExpr(pos, op, x, low, high, max))
+	n := ir.NewSliceExpr(pos, op, x, low, high, max)
+	if x.Type().HasTParam() {
+		// transformSlice needs to know if x.Type() is a string or an array or a slice.
+		n.SetType(typ)
+		n.SetTypecheck(3)
+		return n
+	}
+	transformSlice(n)
+	return typed(typ, n)
 }
 
 func Unary(pos src.XPos, op ir.Op, x ir.Node) ir.Node {
diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 51ef46c7e7..1b76bb27c5 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -367,6 +367,23 @@ func (subst *subster) node(n ir.Node) ir.Node {
 		}
 		ir.EditChildren(m, edit)
 
+		if x.Typecheck() == 3 {
+			// These are nodes whose transforms were delayed until
+			// their instantiated type was known.
+			if typecheck.IsCmp(x.Op()) {
+				transformCompare(m.(*ir.BinaryExpr))
+				m.SetTypecheck(1)
+			} else if x.Op() == ir.OSLICE || x.Op() == ir.OSLICE3 {
+				transformSlice(m.(*ir.SliceExpr))
+				m.SetTypecheck(1)
+			} else if x.Op() == ir.OADD {
+				m = transformAdd(m.(*ir.BinaryExpr))
+				m.SetTypecheck(1)
+			} else {
+				base.Fatalf("Unexpected node with Typecheck() == 3")
+			}
+		}
+
 		switch x.Op() {
 		case ir.OLITERAL:
 			t := m.Type()
diff --git a/src/cmd/compile/internal/typecheck/expr.go b/src/cmd/compile/internal/typecheck/expr.go
index 10a4c1b1dc..fb39709686 100644
--- a/src/cmd/compile/internal/typecheck/expr.go
+++ b/src/cmd/compile/internal/typecheck/expr.go
@@ -77,6 +77,10 @@ func tcShift(n, l, r ir.Node) (ir.Node, ir.Node, *types.Type) {
 	return l, r, t
 }
 
+func IsCmp(op ir.Op) bool {
+	return iscmp[op]
+}
+
 // tcArith typechecks operands of a binary arithmetic expression.
 // The result of tcArith MUST be assigned back to original operands,
 // t is the type of the expression, and should be set by the caller. e.g:
@@ -102,7 +106,7 @@ func tcArith(n ir.Node, op ir.Op, l, r ir.Node) (ir.Node, ir.Node, *types.Type)
 		// The conversion allocates, so only do it if the concrete type is huge.
 		converted := false
 		if r.Type().Kind() != types.TBLANK {
-			aop, _ = assignop(l.Type(), r.Type())
+			aop, _ = Assignop(l.Type(), r.Type())
 			if aop != ir.OXXX {
 				if r.Type().IsInterface() && !l.Type().IsInterface() && !types.IsComparable(l.Type()) {
 					base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(l.Type()))
@@ -121,7 +125,7 @@ func tcArith(n ir.Node, op ir.Op, l, r ir.Node) (ir.Node, ir.Node, *types.Type)
 		}
 
 		if !converted && l.Type().Kind() != types.TBLANK {
-			aop, _ = assignop(r.Type(), l.Type())
+			aop, _ = Assignop(r.Type(), l.Type())
 			if aop != ir.OXXX {
 				if l.Type().IsInterface() && !r.Type().IsInterface() && !types.IsComparable(r.Type()) {
 					base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(r.Type()))
diff --git a/src/cmd/compile/internal/typecheck/stmt.go b/src/cmd/compile/internal/typecheck/stmt.go
index 14ed175be9..175216f279 100644
--- a/src/cmd/compile/internal/typecheck/stmt.go
+++ b/src/cmd/compile/internal/typecheck/stmt.go
@@ -74,7 +74,7 @@ func typecheckrangeExpr(n *ir.RangeStmt) {
 			if ir.DeclaredBy(nn, n) {
 				nn.SetType(t)
 			} else if nn.Type() != nil {
-				if op, why := assignop(t, nn.Type()); op == ir.OXXX {
+				if op, why := Assignop(t, nn.Type()); op == ir.OXXX {
 					base.ErrorfAt(n.Pos(), "cannot assign type %v to %L in range%s", t, nn, why)
 				}
 			}
@@ -519,8 +519,8 @@ func tcSwitchExpr(n *ir.SwitchStmt) {
 			} else if t.IsInterface() && !n1.Type().IsInterface() && !types.IsComparable(n1.Type()) {
 				base.ErrorfAt(ncase.Pos(), "invalid case %L in switch (incomparable type)", n1)
 			} else {
-				op1, _ := assignop(n1.Type(), t)
-				op2, _ := assignop(t, n1.Type())
+				op1, _ := Assignop(n1.Type(), t)
+				op2, _ := Assignop(t, n1.Type())
 				if op1 == ir.OXXX && op2 == ir.OXXX {
 					if n.Tag != nil {
 						base.ErrorfAt(ncase.Pos(), "invalid case %v in switch on %v (mismatched types %v and %v)", n1, n.Tag, n1.Type(), t)
diff --git a/src/cmd/compile/internal/typecheck/subr.go b/src/cmd/compile/internal/typecheck/subr.go
index c40cfa2288..e58ef9fb05 100644
--- a/src/cmd/compile/internal/typecheck/subr.go
+++ b/src/cmd/compile/internal/typecheck/subr.go
@@ -317,7 +317,7 @@ func assignconvfn(n ir.Node, t *types.Type, context func() string) ir.Node {
 		return n
 	}
 
-	op, why := assignop(n.Type(), t)
+	op, why := Assignop(n.Type(), t)
 	if op == ir.OXXX {
 		base.Errorf("cannot use %L as type %v in %s%s", n, t, context(), why)
 		op = ir.OCONV
@@ -333,7 +333,7 @@ func assignconvfn(n ir.Node, t *types.Type, context func() string) ir.Node {
 // If so, return op code to use in conversion.
 // If not, return OXXX. In this case, the string return parameter may
 // hold a reason why. In all other cases, it'll be the empty string.
-func assignop(src, dst *types.Type) (ir.Op, string) {
+func Assignop(src, dst *types.Type) (ir.Op, string) {
 	if src == dst {
 		return ir.OCONVNOP, ""
 	}
@@ -483,7 +483,7 @@ func convertop(srcConstant bool, src, dst *types.Type) (ir.Op, string) {
 	}
 
 	// 1. src can be assigned to dst.
-	op, why := assignop(src, dst)
+	op, why := Assignop(src, dst)
 	if op != ir.OXXX {
 		return op, why
 	}
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 30632ac18b..f06a8623d0 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -297,7 +297,7 @@ func typecheck(n ir.Node, top int) (res ir.Node) {
 
 	// Skip typecheck if already done.
 	// But re-typecheck ONAME/OTYPE/OLITERAL/OPACK node in case context has changed.
-	if n.Typecheck() == 1 {
+	if n.Typecheck() == 1 || n.Typecheck() == 3 {
 		switch n.Op() {
 		case ir.ONAME, ir.OTYPE, ir.OLITERAL, ir.OPACK:
 			break
@@ -1640,7 +1640,7 @@ func checkassignto(src *types.Type, dst ir.Node) {
 		return
 	}
 
-	if op, why := assignop(src, dst.Type()); op == ir.OXXX {
+	if op, why := Assignop(src, dst.Type()); op == ir.OXXX {
 		base.Errorf("cannot assign %v to %L in multiple assignment%s", src, dst, why)
 		return
 	}
diff --git a/test/typeparam/adder.go b/test/typeparam/adder.go
new file mode 100644
index 0000000000..0c25ad4ef2
--- /dev/null
+++ b/test/typeparam/adder.go
@@ -0,0 +1,29 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 (
+	"fmt"
+)
+
+type AddType interface {
+	type int, int64, string
+}
+
+// _Add can add numbers or strings
+func _Add[T AddType](a, b T) T {
+	return a + b
+}
+
+func main() {
+	if got, want := _Add(5, 3), 8; got != want {
+		panic(fmt.Sprintf("got %d, want %d", got, want))
+	}
+	if got, want := _Add("ab", "cd"), "abcd"; got != want {
+		panic(fmt.Sprintf("got %d, want %d", got, want))
+	}
+}
diff --git a/test/typeparam/list2.go b/test/typeparam/list2.go
new file mode 100644
index 0000000000..385193d876
--- /dev/null
+++ b/test/typeparam/list2.go
@@ -0,0 +1,601 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 list provides a doubly linked list of some element type
+// (generic form of the "container/list" package).
+
+package main
+
+import (
+	"fmt"
+	"strconv"
+)
+
+// Element is an element of a linked list.
+type _Element[T any] struct {
+	// Next and previous pointers in the doubly-linked list of elements.
+	// To simplify the implementation, internally a list l is implemented
+	// as a ring, such that &l.root is both the next element of the last
+	// list element (l.Back()) and the previous element of the first list
+	// element (l.Front()).
+	next, prev *_Element[T]
+
+	// The list to which this element belongs.
+	list *_List[T]
+
+	// The value stored with this element.
+	Value T
+}
+
+// Next returns the next list element or nil.
+func (e *_Element[T]) Next() *_Element[T] {
+	if p := e.next; e.list != nil && p != &e.list.root {
+		return p
+	}
+	return nil
+}
+
+// Prev returns the previous list element or nil.
+func (e *_Element[T]) Prev() *_Element[T] {
+	if p := e.prev; e.list != nil && p != &e.list.root {
+		return p
+	}
+	return nil
+}
+
+// _List represents a doubly linked list.
+// The zero value for _List is an empty list ready to use.
+type _List[T any] struct {
+	root _Element[T] // sentinel list element, only &root, root.prev, and root.next are used
+	len  int     // current list length excluding (this) sentinel element
+}
+
+// Init initializes or clears list l.
+func (l *_List[T]) Init() *_List[T] {
+	l.root.next = &l.root
+	l.root.prev = &l.root
+	l.len = 0
+	return l
+}
+
+// New returns an initialized list.
+func _New[T any]() *_List[T] { return new(_List[T]).Init() }
+
+// Len returns the number of elements of list l.
+// The complexity is O(1).
+func (l *_List[_]) Len() int { return l.len }
+
+// Front returns the first element of list l or nil if the list is empty.
+func (l *_List[T]) Front() *_Element[T] {
+	if l.len == 0 {
+		return nil
+	}
+	return l.root.next
+}
+
+// Back returns the last element of list l or nil if the list is empty.
+func (l *_List[T]) Back() *_Element[T] {
+	if l.len == 0 {
+		return nil
+	}
+	return l.root.prev
+}
+
+// lazyInit lazily initializes a zero _List value.
+func (l *_List[_]) lazyInit() {
+	if l.root.next == nil {
+		l.Init()
+	}
+}
+
+// insert inserts e after at, increments l.len, and returns e.
+func (l *_List[T]) insert(e, at *_Element[T]) *_Element[T] {
+	e.prev = at
+	e.next = at.next
+	e.prev.next = e
+	e.next.prev = e
+	e.list = l
+	l.len++
+	return e
+}
+
+// insertValue is a convenience wrapper for insert(&_Element[T]{Value: v}, at).
+func (l *_List[T]) insertValue(v T, at *_Element[T]) *_Element[T] {
+	return l.insert(&_Element[T]{Value: v}, at)
+}
+
+// remove removes e from its list, decrements l.len, and returns e.
+func (l *_List[T]) remove(e *_Element[T]) *_Element[T] {
+	e.prev.next = e.next
+	e.next.prev = e.prev
+	e.next = nil // avoid memory leaks
+	e.prev = nil // avoid memory leaks
+	e.list = nil
+	l.len--
+	return e
+}
+
+// move moves e to next to at and returns e.
+func (l *_List[T]) move(e, at *_Element[T]) *_Element[T] {
+	if e == at {
+		return e
+	}
+	e.prev.next = e.next
+	e.next.prev = e.prev
+
+	e.prev = at
+	e.next = at.next
+	e.prev.next = e
+	e.next.prev = e
+
+	return e
+}
+
+// Remove removes e from l if e is an element of list l.
+// It returns the element value e.Value.
+// The element must not be nil.
+func (l *_List[T]) Remove(e *_Element[T]) T {
+	if e.list == l {
+		// if e.list == l, l must have been initialized when e was inserted
+		// in l or l == nil (e is a zero _Element) and l.remove will crash
+		l.remove(e)
+	}
+	return e.Value
+}
+
+// PushFront inserts a new element e with value v at the front of list l and returns e.
+func (l *_List[T]) PushFront(v T) *_Element[T] {
+	l.lazyInit()
+	return l.insertValue(v, &l.root)
+}
+
+// PushBack inserts a new element e with value v at the back of list l and returns e.
+func (l *_List[T]) PushBack(v T) *_Element[T] {
+	l.lazyInit()
+	return l.insertValue(v, l.root.prev)
+}
+
+// InsertBefore inserts a new element e with value v immediately before mark and returns e.
+// If mark is not an element of l, the list is not modified.
+// The mark must not be nil.
+func (l *_List[T]) InsertBefore(v T, mark *_Element[T]) *_Element[T] {
+	if mark.list != l {
+		return nil
+	}
+	// see comment in _List.Remove about initialization of l
+	return l.insertValue(v, mark.prev)
+}
+
+// InsertAfter inserts a new element e with value v immediately after mark and returns e.
+// If mark is not an element of l, the list is not modified.
+// The mark must not be nil.
+func (l *_List[T]) InsertAfter(v T, mark *_Element[T]) *_Element[T] {
+	if mark.list != l {
+		return nil
+	}
+	// see comment in _List.Remove about initialization of l
+	return l.insertValue(v, mark)
+}
+
+// MoveToFront moves element e to the front of list l.
+// If e is not an element of l, the list is not modified.
+// The element must not be nil.
+func (l *_List[T]) MoveToFront(e *_Element[T]) {
+	if e.list != l || l.root.next == e {
+		return
+	}
+	// see comment in _List.Remove about initialization of l
+	l.move(e, &l.root)
+}
+
+// MoveToBack moves element e to the back of list l.
+// If e is not an element of l, the list is not modified.
+// The element must not be nil.
+func (l *_List[T]) MoveToBack(e *_Element[T]) {
+	if e.list != l || l.root.prev == e {
+		return
+	}
+	// see comment in _List.Remove about initialization of l
+	l.move(e, l.root.prev)
+}
+
+// MoveBefore moves element e to its new position before mark.
+// If e or mark is not an element of l, or e == mark, the list is not modified.
+// The element and mark must not be nil.
+func (l *_List[T]) MoveBefore(e, mark *_Element[T]) {
+	if e.list != l || e == mark || mark.list != l {
+		return
+	}
+	l.move(e, mark.prev)
+}
+
+// MoveAfter moves element e to its new position after mark.
+// If e or mark is not an element of l, or e == mark, the list is not modified.
+// The element and mark must not be nil.
+func (l *_List[T]) MoveAfter(e, mark *_Element[T]) {
+	if e.list != l || e == mark || mark.list != l {
+		return
+	}
+	l.move(e, mark)
+}
+
+// PushBackList inserts a copy of an other list at the back of list l.
+// The lists l and other may be the same. They must not be nil.
+func (l *_List[T]) PushBackList(other *_List[T]) {
+	l.lazyInit()
+	for i, e := other.Len(), other.Front(); i > 0; i, e = i-1, e.Next() {
+		l.insertValue(e.Value, l.root.prev)
+	}
+}
+
+// PushFrontList inserts a copy of an other list at the front of list l.
+// The lists l and other may be the same. They must not be nil.
+func (l *_List[T]) PushFrontList(other *_List[T]) {
+	l.lazyInit()
+	for i, e := other.Len(), other.Back(); i > 0; i, e = i-1, e.Prev() {
+		l.insertValue(e.Value, &l.root)
+	}
+}
+
+// Transform runs a transform function on a list returning a new list.
+func _Transform[TElem1, TElem2 any](lst *_List[TElem1], f func(TElem1) TElem2) *_List[TElem2] {
+	ret := _New[TElem2]()
+	for p := lst.Front(); p != nil; p = p.Next() {
+		ret.PushBack(f(p.Value))
+	}
+	return ret
+}
+
+func checkListLen[T any](l *_List[T], len int) bool {
+	if n := l.Len(); n != len {
+		panic(fmt.Sprintf("l.Len() = %d, want %d", n, len))
+		return false
+	}
+	return true
+}
+
+func checkListPointers[T any](l *_List[T], es []*_Element[T]) {
+	root := &l.root
+
+	if !checkListLen(l, len(es)) {
+		return
+	}
+
+	// zero length lists must be the zero value or properly initialized (sentinel circle)
+	if len(es) == 0 {
+		if l.root.next != nil && l.root.next != root || l.root.prev != nil && l.root.prev != root {
+			panic(fmt.Sprintf("l.root.next = %p, l.root.prev = %p; both should both be nil or %p", l.root.next, l.root.prev, root))
+		}
+		return
+	}
+	// len(es) > 0
+
+	// check internal and external prev/next connections
+	for i, e := range es {
+		prev := root
+		Prev := (*_Element[T])(nil)
+		if i > 0 {
+			prev = es[i-1]
+			Prev = prev
+		}
+		if p := e.prev; p != prev {
+			panic(fmt.Sprintf("elt[%d](%p).prev = %p, want %p", i, e, p, prev))
+		}
+		if p := e.Prev(); p != Prev {
+			panic(fmt.Sprintf("elt[%d](%p).Prev() = %p, want %p", i, e, p, Prev))
+		}
+
+		next := root
+		Next := (*_Element[T])(nil)
+		if i < len(es)-1 {
+			next = es[i+1]
+			Next = next
+		}
+		if n := e.next; n != next {
+			panic(fmt.Sprintf("elt[%d](%p).next = %p, want %p", i, e, n, next))
+		}
+		if n := e.Next(); n != Next {
+			panic(fmt.Sprintf("elt[%d](%p).Next() = %p, want %p", i, e, n, Next))
+		}
+	}
+}
+
+func TestList() {
+	l := _New[string]()
+	checkListPointers(l, []*(_Element[string]){})
+
+	// Single element list
+	e := l.PushFront("a")
+	checkListPointers(l, []*(_Element[string]){e})
+	l.MoveToFront(e)
+	checkListPointers(l, []*(_Element[string]){e})
+	l.MoveToBack(e)
+	checkListPointers(l, []*(_Element[string]){e})
+	l.Remove(e)
+	checkListPointers(l, []*(_Element[string]){})
+
+	// Bigger list
+	l2 := _New[int]()
+	e2 := l2.PushFront(2)
+	e1 := l2.PushFront(1)
+	e3 := l2.PushBack(3)
+	e4 := l2.PushBack(600)
+	checkListPointers(l2, []*(_Element[int]){e1, e2, e3, e4})
+
+	l2.Remove(e2)
+	checkListPointers(l2, []*(_Element[int]){e1, e3, e4})
+
+	l2.MoveToFront(e3) // move from middle
+	checkListPointers(l2, []*(_Element[int]){e3, e1, e4})
+
+	l2.MoveToFront(e1)
+	l2.MoveToBack(e3) // move from middle
+	checkListPointers(l2, []*(_Element[int]){e1, e4, e3})
+
+	l2.MoveToFront(e3) // move from back
+	checkListPointers(l2, []*(_Element[int]){e3, e1, e4})
+	l2.MoveToFront(e3) // should be no-op
+	checkListPointers(l2, []*(_Element[int]){e3, e1, e4})
+
+	l2.MoveToBack(e3) // move from front
+	checkListPointers(l2, []*(_Element[int]){e1, e4, e3})
+	l2.MoveToBack(e3) // should be no-op
+	checkListPointers(l2, []*(_Element[int]){e1, e4, e3})
+
+	e2 = l2.InsertBefore(2, e1) // insert before front
+	checkListPointers(l2, []*(_Element[int]){e2, e1, e4, e3})
+	l2.Remove(e2)
+	e2 = l2.InsertBefore(2, e4) // insert before middle
+	checkListPointers(l2, []*(_Element[int]){e1, e2, e4, e3})
+	l2.Remove(e2)
+	e2 = l2.InsertBefore(2, e3) // insert before back
+	checkListPointers(l2, []*(_Element[int]){e1, e4, e2, e3})
+	l2.Remove(e2)
+
+	e2 = l2.InsertAfter(2, e1) // insert after front
+	checkListPointers(l2, []*(_Element[int]){e1, e2, e4, e3})
+	l2.Remove(e2)
+	e2 = l2.InsertAfter(2, e4) // insert after middle
+	checkListPointers(l2, []*(_Element[int]){e1, e4, e2, e3})
+	l2.Remove(e2)
+	e2 = l2.InsertAfter(2, e3) // insert after back
+	checkListPointers(l2, []*(_Element[int]){e1, e4, e3, e2})
+	l2.Remove(e2)
+
+	// Check standard iteration.
+	sum := 0
+	for e := l2.Front(); e != nil; e = e.Next() {
+		sum += e.Value
+	}
+	if sum != 604 {
+		panic(fmt.Sprintf("sum over l = %d, want 604", sum))
+	}
+
+	// Clear all elements by iterating
+	var next *_Element[int]
+	for e := l2.Front(); e != nil; e = next {
+		next = e.Next()
+		l2.Remove(e)
+	}
+	checkListPointers(l2, []*(_Element[int]){})
+}
+
+func checkList[T comparable](l *_List[T], es []interface{}) {
+	if !checkListLen(l, len(es)) {
+		return
+	}
+
+	i := 0
+	for e := l.Front(); e != nil; e = e.Next() {
+		le := e.Value
+		// Comparison between a generically-typed variable le and an interface.
+		if le != es[i] {
+			panic(fmt.Sprintf("elt[%d].Value = %v, want %v", i, le, es[i]))
+		}
+		i++
+	}
+}
+
+func TestExtending() {
+	l1 := _New[int]()
+	l2 := _New[int]()
+
+	l1.PushBack(1)
+	l1.PushBack(2)
+	l1.PushBack(3)
+
+	l2.PushBack(4)
+	l2.PushBack(5)
+
+	l3 := _New[int]()
+	l3.PushBackList(l1)
+	checkList(l3, []interface{}{1, 2, 3})
+	l3.PushBackList(l2)
+	checkList(l3, []interface{}{1, 2, 3, 4, 5})
+
+	l3 = _New[int]()
+	l3.PushFrontList(l2)
+	checkList(l3, []interface{}{4, 5})
+	l3.PushFrontList(l1)
+	checkList(l3, []interface{}{1, 2, 3, 4, 5})
+
+	checkList(l1, []interface{}{1, 2, 3})
+	checkList(l2, []interface{}{4, 5})
+
+	l3 = _New[int]()
+	l3.PushBackList(l1)
+	checkList(l3, []interface{}{1, 2, 3})
+	l3.PushBackList(l3)
+	checkList(l3, []interface{}{1, 2, 3, 1, 2, 3})
+
+	l3 = _New[int]()
+	l3.PushFrontList(l1)
+	checkList(l3, []interface{}{1, 2, 3})
+	l3.PushFrontList(l3)
+	checkList(l3, []interface{}{1, 2, 3, 1, 2, 3})
+
+	l3 = _New[int]()
+	l1.PushBackList(l3)
+	checkList(l1, []interface{}{1, 2, 3})
+	l1.PushFrontList(l3)
+	checkList(l1, []interface{}{1, 2, 3})
+}
+
+func TestRemove() {
+	l := _New[int]()
+	e1 := l.PushBack(1)
+	e2 := l.PushBack(2)
+	checkListPointers(l, []*(_Element[int]){e1, e2})
+	e := l.Front()
+	l.Remove(e)
+	checkListPointers(l, []*(_Element[int]){e2})
+	l.Remove(e)
+	checkListPointers(l, []*(_Element[int]){e2})
+}
+
+func TestIssue4103() {
+	l1 := _New[int]()
+	l1.PushBack(1)
+	l1.PushBack(2)
+
+	l2 := _New[int]()
+	l2.PushBack(3)
+	l2.PushBack(4)
+
+	e := l1.Front()
+	l2.Remove(e) // l2 should not change because e is not an element of l2
+	if n := l2.Len(); n != 2 {
+		panic(fmt.Sprintf("l2.Len() = %d, want 2", n))
+	}
+
+	l1.InsertBefore(8, e)
+	if n := l1.Len(); n != 3 {
+		panic(fmt.Sprintf("l1.Len() = %d, want 3", n))
+	}
+}
+
+func TestIssue6349() {
+	l := _New[int]()
+	l.PushBack(1)
+	l.PushBack(2)
+
+	e := l.Front()
+	l.Remove(e)
+	if e.Value != 1 {
+		panic(fmt.Sprintf("e.value = %d, want 1", e.Value))
+	}
+	if e.Next() != nil {
+		panic(fmt.Sprintf("e.Next() != nil"))
+	}
+	if e.Prev() != nil {
+		panic(fmt.Sprintf("e.Prev() != nil"))
+	}
+}
+
+func TestMove() {
+	l := _New[int]()
+	e1 := l.PushBack(1)
+	e2 := l.PushBack(2)
+	e3 := l.PushBack(3)
+	e4 := l.PushBack(4)
+
+	l.MoveAfter(e3, e3)
+	checkListPointers(l, []*(_Element[int]){e1, e2, e3, e4})
+	l.MoveBefore(e2, e2)
+	checkListPointers(l, []*(_Element[int]){e1, e2, e3, e4})
+
+	l.MoveAfter(e3, e2)
+	checkListPointers(l, []*(_Element[int]){e1, e2, e3, e4})
+	l.MoveBefore(e2, e3)
+	checkListPointers(l, []*(_Element[int]){e1, e2, e3, e4})
+
+	l.MoveBefore(e2, e4)
+	checkListPointers(l, []*(_Element[int]){e1, e3, e2, e4})
+	e2, e3 = e3, e2
+
+	l.MoveBefore(e4, e1)
+	checkListPointers(l, []*(_Element[int]){e4, e1, e2, e3})
+	e1, e2, e3, e4 = e4, e1, e2, e3
+
+	l.MoveAfter(e4, e1)
+	checkListPointers(l, []*(_Element[int]){e1, e4, e2, e3})
+	e2, e3, e4 = e4, e2, e3
+
+	l.MoveAfter(e2, e3)
+	checkListPointers(l, []*(_Element[int]){e1, e3, e2, e4})
+	e2, e3 = e3, e2
+}
+
+// Test PushFront, PushBack, PushFrontList, PushBackList with uninitialized _List
+func TestZeroList() {
+	var l1 = new(_List[int])
+	l1.PushFront(1)
+	checkList(l1, []interface{}{1})
+
+	var l2 = new(_List[int])
+	l2.PushBack(1)
+	checkList(l2, []interface{}{1})
+
+	var l3 = new(_List[int])
+	l3.PushFrontList(l1)
+	checkList(l3, []interface{}{1})
+
+	var l4 = new(_List[int])
+	l4.PushBackList(l2)
+	checkList(l4, []interface{}{1})
+}
+
+// Test that a list l is not modified when calling InsertBefore with a mark that is not an element of l.
+func TestInsertBeforeUnknownMark() {
+	var l _List[int]
+	l.PushBack(1)
+	l.PushBack(2)
+	l.PushBack(3)
+	l.InsertBefore(1, new(_Element[int]))
+	checkList(&l, []interface{}{1, 2, 3})
+}
+
+// Test that a list l is not modified when calling InsertAfter with a mark that is not an element of l.
+func TestInsertAfterUnknownMark() {
+	var l _List[int]
+	l.PushBack(1)
+	l.PushBack(2)
+	l.PushBack(3)
+	l.InsertAfter(1, new(_Element[int]))
+	checkList(&l, []interface{}{1, 2, 3})
+}
+
+// Test that a list l is not modified when calling MoveAfter or MoveBefore with a mark that is not an element of l.
+func TestMoveUnknownMark() {
+	var l1 _List[int]
+	e1 := l1.PushBack(1)
+
+	var l2 _List[int]
+	e2 := l2.PushBack(2)
+
+	l1.MoveAfter(e1, e2)
+	checkList(&l1, []interface{}{1})
+	checkList(&l2, []interface{}{2})
+
+	l1.MoveBefore(e1, e2)
+	checkList(&l1, []interface{}{1})
+	checkList(&l2, []interface{}{2})
+}
+
+// Test the Transform function.
+func TestTransform() {
+	l1 := _New[int]()
+	l1.PushBack(1)
+	l1.PushBack(2)
+	l2 := _Transform(l1, strconv.Itoa)
+	checkList(l2, []interface{}{"1", "2"})
+}
+
+
+func main() {
+	TestList()
+}
+
-- 
GitLab


From 8f19394b62a5b1651cd66eefb1bfeacc278966b9 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 17 Mar 2021 22:13:16 -0700
Subject: [PATCH 1194/2400] cmd/compile/internal/types2: refactor untyped
 conversions

Based on https://golang.org/cl/284256 for go/types.
Brings this code more in line with go/types.

Adjusted various tests to match new error messages which
generally are now better: for assignment errors, instead
of a generic "cannot convert" we now say "cannot use"
followed by a clearer reason as to why not.

Major differences to go/types with respect to the changed
files:

- Some of the new code now returns error codes, but they
  are only used internally for now, and not reported with
  errors.

- go/types does not "convert" untyped nil values to target
  types, but here we do. This is unchanged from how types2
  handled this before this CL.

Change-Id: If45336d7ee679ece100f6d9d9f291a6ea55004d8
Reviewed-on: https://go-review.googlesource.com/c/go/+/302757
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/api.go        |   3 +-
 .../compile/internal/types2/assignments.go    |  28 ++-
 src/cmd/compile/internal/types2/builtins.go   |  32 +--
 src/cmd/compile/internal/types2/call.go       |   2 +-
 .../compile/internal/types2/conversions.go    |   2 +-
 .../internal/types2/examples/methods.go2      |   2 +-
 src/cmd/compile/internal/types2/expr.go       | 230 ++++++++++--------
 src/cmd/compile/internal/types2/operand.go    |  62 ++---
 .../internal/types2/testdata/builtins.src     |   6 +-
 .../internal/types2/testdata/constdecl.src    |   8 +-
 .../types2/testdata/decls2/decls2b.src        |   6 +-
 .../internal/types2/testdata/expr3.src        |  16 +-
 .../internal/types2/testdata/issues.src       |   4 +-
 .../internal/types2/testdata/stmt0.src        |  18 +-
 .../internal/types2/testdata/typeparams.go2   |   4 +-
 test/convlit.go                               |   2 +-
 test/fixedbugs/bug205.go                      |   2 +-
 test/fixedbugs/bug397.go                      |   2 +-
 test/fixedbugs/issue11326.go                  |  16 +-
 test/fixedbugs/issue11371.go                  |  12 +-
 test/fixedbugs/issue13559.go                  | 114 ++++-----
 test/fixedbugs/issue6402.go                   |   2 +-
 test/fixedbugs/issue7153.go                   |   2 +-
 23 files changed, 300 insertions(+), 275 deletions(-)

diff --git a/src/cmd/compile/internal/types2/api.go b/src/cmd/compile/internal/types2/api.go
index 30f0430ff1..acb196a336 100644
--- a/src/cmd/compile/internal/types2/api.go
+++ b/src/cmd/compile/internal/types2/api.go
@@ -415,7 +415,8 @@ func AssertableTo(V *Interface, T Type) bool {
 // AssignableTo reports whether a value of type V is assignable to a variable of type T.
 func AssignableTo(V, T Type) bool {
 	x := operand{mode: value, typ: V}
-	return x.assignableTo(nil, T, nil) // check not needed for non-constant x
+	ok, _ := x.assignableTo(nil, T, nil) // check not needed for non-constant x
+	return ok
 }
 
 // ConvertibleTo reports whether a value of type V is convertible to a value of type T.
diff --git a/src/cmd/compile/internal/types2/assignments.go b/src/cmd/compile/internal/types2/assignments.go
index 18ae0ddf62..272e2fee6e 100644
--- a/src/cmd/compile/internal/types2/assignments.go
+++ b/src/cmd/compile/internal/types2/assignments.go
@@ -33,8 +33,8 @@ func (check *Checker) assignment(x *operand, T Type, context string) {
 		// spec: "If an untyped constant is assigned to a variable of interface
 		// type or the blank identifier, the constant is first converted to type
 		// bool, rune, int, float64, complex128 or string respectively, depending
-		// on whether the value is a boolean, rune, integer, floating-point, complex,
-		// or string constant."
+		// on whether the value is a boolean, rune, integer, floating-point,
+		// complex, or string constant."
 		if x.isNil() {
 			if T == nil {
 				check.errorf(x, "use of untyped nil in %s", context)
@@ -44,10 +44,27 @@ func (check *Checker) assignment(x *operand, T Type, context string) {
 		} else if T == nil || IsInterface(T) {
 			target = Default(x.typ)
 		}
-		check.convertUntyped(x, target)
-		if x.mode == invalid {
+		newType, val, code := check.implicitTypeAndValue(x, target)
+		if code != 0 {
+			msg := check.sprintf("cannot use %s as %s value in %s", x, target, context)
+			switch code {
+			case _TruncatedFloat:
+				msg += " (truncated)"
+			case _NumericOverflow:
+				msg += " (overflows)"
+			}
+			check.error(x, msg)
+			x.mode = invalid
 			return
 		}
+		if val != nil {
+			x.val = val
+			check.updateExprVal(x.expr, val)
+		}
+		if newType != x.typ {
+			x.typ = newType
+			check.updateExprType(x.expr, newType, false)
+		}
 	}
 	// x.typ is typed
 
@@ -63,7 +80,8 @@ func (check *Checker) assignment(x *operand, T Type, context string) {
 		return
 	}
 
-	if reason := ""; !x.assignableTo(check, T, &reason) {
+	reason := ""
+	if ok, _ := x.assignableTo(check, T, &reason); !ok {
 		if check.conf.CompilerErrorMessages {
 			check.errorf(x, "incompatible type: cannot use %s as %s value", x, T)
 		} else {
diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go
index 55a9d69b30..f0fd216b13 100644
--- a/src/cmd/compile/internal/types2/builtins.go
+++ b/src/cmd/compile/internal/types2/builtins.go
@@ -95,23 +95,25 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 		// spec: "As a special case, append also accepts a first argument assignable
 		// to type []byte with a second argument of string type followed by ... .
 		// This form appends the bytes of the string.
-		if nargs == 2 && call.HasDots && x.assignableTo(check, NewSlice(universeByte), nil) {
-			arg(x, 1)
-			if x.mode == invalid {
-				return
-			}
-			if isString(x.typ) {
-				if check.Types != nil {
-					sig := makeSig(S, S, x.typ)
-					sig.variadic = true
-					check.recordBuiltinType(call.Fun, sig)
+		if nargs == 2 && call.HasDots {
+			if ok, _ := x.assignableTo(check, NewSlice(universeByte), nil); ok {
+				arg(x, 1)
+				if x.mode == invalid {
+					return
+				}
+				if isString(x.typ) {
+					if check.Types != nil {
+						sig := makeSig(S, S, x.typ)
+						sig.variadic = true
+						check.recordBuiltinType(call.Fun, sig)
+					}
+					x.mode = value
+					x.typ = S
+					break
 				}
-				x.mode = value
-				x.typ = S
-				break
+				alist = append(alist, *x)
+				// fallthrough
 			}
-			alist = append(alist, *x)
-			// fallthrough
 		}
 
 		// check general case by creating custom signature
diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index 2ee22c8a19..18737e45a0 100644
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -426,7 +426,7 @@ func (check *Checker) arguments(call *syntax.CallExpr, sig *Signature, args []*o
 
 	// check arguments
 	for i, a := range args {
-		check.assignment(a, sigParams.vars[i].typ, "argument")
+		check.assignment(a, sigParams.vars[i].typ, check.sprintf("argument to %s", call.Fun))
 	}
 
 	return
diff --git a/src/cmd/compile/internal/types2/conversions.go b/src/cmd/compile/internal/types2/conversions.go
index d04ccec411..eabed7ba9b 100644
--- a/src/cmd/compile/internal/types2/conversions.go
+++ b/src/cmd/compile/internal/types2/conversions.go
@@ -83,7 +83,7 @@ func (check *Checker) conversion(x *operand, T Type) {
 // exported API call, i.e., when all methods have been type-checked.
 func (x *operand) convertibleTo(check *Checker, T Type) bool {
 	// "x is assignable to T"
-	if x.assignableTo(check, T, nil) {
+	if ok, _ := x.assignableTo(check, T, nil); ok {
 		return true
 	}
 
diff --git a/src/cmd/compile/internal/types2/examples/methods.go2 b/src/cmd/compile/internal/types2/examples/methods.go2
index 7b6b13ddaa..b34baef457 100644
--- a/src/cmd/compile/internal/types2/examples/methods.go2
+++ b/src/cmd/compile/internal/types2/examples/methods.go2
@@ -40,7 +40,7 @@ func (t T1[[ /* ERROR must be an identifier */ ]int]) m2() {}
 // and usually should be avoided. There are some notable exceptions; e.g.,
 // sometimes it makes sense to use the identifier "copy" which happens to
 // also be the name of a predeclared built-in function.
-func (t T1[int]) m3() { var _ int = 42 /* ERROR cannot convert 42 .* to int */ }
+func (t T1[int]) m3() { var _ int = 42 /* ERROR cannot use 42 .* as int */ }
 
 // The names of the type parameters used in a parameterized receiver
 // type don't have to match the type parameter names in the declaration
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 4cdec84604..3706185817 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -145,11 +145,11 @@ func opName(e *syntax.Operation) string {
 	return ""
 }
 
-// Entries must be "" or end with a space.
 var op2str1 = [...]string{
 	syntax.Xor: "bitwise complement",
 }
 
+// This is only used for operations that may cause overflow.
 var op2str2 = [...]string{
 	syntax.Add: "addition",
 	syntax.Sub: "subtraction",
@@ -410,11 +410,51 @@ func representableConst(x constant.Value, check *Checker, typ *Basic, rounded *c
 	return false
 }
 
-// representable checks that a constant operand is representable in the given basic type.
+// An errorCode is a (constant) value uniquely identifing a specific error.
+type errorCode int
+
+// The following error codes are "borrowed" from go/types which codes for
+// all errors. Here we list the few codes currently needed by the various
+// conversion checking functions.
+// Eventually we will switch to reporting codes for all errors, using a
+// an error code table shared between types2 and go/types.
+const (
+	_ = errorCode(iota)
+	_TruncatedFloat
+	_NumericOverflow
+	_InvalidConstVal
+	_InvalidUntypedConversion
+
+	// The following error codes are only returned by operand.assignableTo
+	// and none of its callers use the error. Still, we keep returning the
+	// error codes to make the transition to reporting error codes all the
+	// time easier in the future.
+	_IncompatibleAssign
+	_InvalidIfaceAssign
+	_InvalidChanAssign
+)
+
+// representable checks that a constant operand is representable in the given
+// basic type.
 func (check *Checker) representable(x *operand, typ *Basic) {
+	v, code := check.representation(x, typ)
+	if code != 0 {
+		check.invalidConversion(code, x, typ)
+		x.mode = invalid
+		return
+	}
+	assert(v != nil)
+	x.val = v
+}
+
+// representation returns the representation of the constant operand x as the
+// basic type typ.
+//
+// If no such representation is possible, it returns a non-zero error code.
+func (check *Checker) representation(x *operand, typ *Basic) (constant.Value, errorCode) {
 	assert(x.mode == constant_)
-	if !representableConst(x.val, check, typ, &x.val) {
-		var msg string
+	v := x.val
+	if !representableConst(x.val, check, typ, &v) {
 		if isNumeric(x.typ) && isNumeric(typ) {
 			// numeric conversion : error msg
 			//
@@ -424,16 +464,25 @@ func (check *Checker) representable(x *operand, typ *Basic) {
 			// float   -> float   : overflows
 			//
 			if !isInteger(x.typ) && isInteger(typ) {
-				msg = "%s truncated to %s"
+				return nil, _TruncatedFloat
 			} else {
-				msg = "%s overflows %s"
+				return nil, _NumericOverflow
 			}
-		} else {
-			msg = "cannot convert %s to %s"
 		}
-		check.errorf(x, msg, x, typ)
-		x.mode = invalid
+		return nil, _InvalidConstVal
 	}
+	return v, 0
+}
+
+func (check *Checker) invalidConversion(code errorCode, x *operand, target Type) {
+	msg := "cannot convert %s to %s"
+	switch code {
+	case _TruncatedFloat:
+		msg = "%s truncated to %s"
+	case _NumericOverflow:
+		msg = "%s overflows %s"
+	}
+	check.errorf(x, msg, x, target)
 }
 
 // updateExprType updates the type of x to typ and invokes itself
@@ -592,13 +641,33 @@ func (check *Checker) updateExprVal(x syntax.Expr, val constant.Value) {
 
 // convertUntyped attempts to set the type of an untyped value to the target type.
 func (check *Checker) convertUntyped(x *operand, target Type) {
-	target = expand(target)
-	if x.mode == invalid || isTyped(x.typ) || target == Typ[Invalid] {
+	newType, val, code := check.implicitTypeAndValue(x, target)
+	if code != 0 {
+		check.invalidConversion(code, x, target.Underlying())
+		x.mode = invalid
 		return
 	}
+	if val != nil {
+		x.val = val
+		check.updateExprVal(x.expr, val)
+	}
+	if newType != x.typ {
+		x.typ = newType
+		check.updateExprType(x.expr, newType, false)
+	}
+}
 
-	// TODO(gri) Sloppy code - clean up. This function is central
-	//           to assignment and expression checking.
+// implicitTypeAndValue returns the implicit type of x when used in a context
+// where the target type is expected. If no such implicit conversion is
+// possible, it returns a nil Type and non-zero error code.
+//
+// If x is a constant operand, the returned constant.Value will be the
+// representation of x in this context.
+func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, constant.Value, errorCode) {
+	target = expand(target)
+	if x.mode == invalid || isTyped(x.typ) || target == Typ[Invalid] {
+		return x.typ, nil, 0
+	}
 
 	if isUntyped(target) {
 		// both x and target are untyped
@@ -606,129 +675,84 @@ func (check *Checker) convertUntyped(x *operand, target Type) {
 		tkind := target.(*Basic).kind
 		if isNumeric(x.typ) && isNumeric(target) {
 			if xkind < tkind {
-				x.typ = target
-				check.updateExprType(x.expr, target, false)
+				return target, nil, 0
 			}
 		} else if xkind != tkind {
-			goto Error
+			return nil, nil, _InvalidUntypedConversion
 		}
-		return
+		return x.typ, nil, 0
 	}
 
-	// In case of a type parameter, conversion must succeed against
-	// all types enumerated by the type parameter bound.
-	// TODO(gri) We should not need this because we have the code
-	// for Sum types in convertUntypedInternal. But at least one
-	// test fails. Investigate.
-	if t := asTypeParam(target); t != nil {
-		types := t.Bound().allTypes
-		if types == nil {
-			goto Error
-		}
-
-		for _, t := range unpack(types) {
-			x := *x // make a copy; convertUntypedInternal modifies x
-			check.convertUntypedInternal(&x, t, false)
-			if x.mode == invalid {
-				goto Error
-			}
-		}
-
-		x.typ = target
-		check.updateExprType(x.expr, target, true)
-		return
-	}
-
-	check.convertUntypedInternal(x, target, true)
-	return
-
-Error:
-	// TODO(gri) better error message (explain cause)
-	check.errorf(x, "cannot convert %s to %s", x, target)
-	x.mode = invalid
-}
-
-// convertUntypedInternal should only be called by convertUntyped.
-func (check *Checker) convertUntypedInternal(x *operand, target Type, update bool) {
-	assert(isTyped(target))
-
 	if x.isNil() {
 		assert(isUntyped(x.typ))
 		if hasNil(target) {
-			goto OK
+			return target, nil, 0
 		}
-		goto Error
+		return nil, nil, _InvalidUntypedConversion
 	}
 
-	// typed target
 	switch t := optype(target).(type) {
 	case *Basic:
 		if x.mode == constant_ {
-			check.representable(x, t)
-			if x.mode == invalid {
-				return
+			v, code := check.representation(x, t)
+			if code != 0 {
+				return nil, nil, code
 			}
-			// expression value may have been rounded - update if needed
-			if update {
-				check.updateExprVal(x.expr, x.val)
+			return target, v, code
+		}
+		// Non-constant untyped values may appear as the
+		// result of comparisons (untyped bool), intermediate
+		// (delayed-checked) rhs operands of shifts, and as
+		// the value nil.
+		switch x.typ.(*Basic).kind {
+		case UntypedBool:
+			if !isBoolean(target) {
+				return nil, nil, _InvalidUntypedConversion
 			}
-		} else {
-			// Non-constant untyped values may appear as the
-			// result of comparisons (untyped bool), intermediate
-			// (delayed-checked) rhs operands of shifts, and as
-			// the value nil. Nil was handled upfront.
-			switch x.typ.(*Basic).kind {
-			case UntypedBool:
-				if !isBoolean(target) {
-					goto Error
-				}
-			case UntypedInt, UntypedRune, UntypedFloat, UntypedComplex:
-				if !isNumeric(target) {
-					goto Error
-				}
-			case UntypedString:
-				// Non-constant untyped string values are not
-				// permitted by the spec and should not occur.
-				unreachable()
-			default:
-				goto Error
+		case UntypedInt, UntypedRune, UntypedFloat, UntypedComplex:
+			if !isNumeric(target) {
+				return nil, nil, _InvalidUntypedConversion
+			}
+		case UntypedString:
+			// Non-constant untyped string values are not permitted by the spec and
+			// should not occur during normal typechecking passes, but this path is
+			// reachable via the AssignableTo API.
+			if !isString(target) {
+				return nil, nil, _InvalidUntypedConversion
 			}
+		default:
+			return nil, nil, _InvalidUntypedConversion
 		}
 	case *Sum:
-		t.is(func(t Type) bool {
-			check.convertUntypedInternal(x, t, false)
-			return x.mode != invalid
+		ok := t.is(func(t Type) bool {
+			target, _, _ := check.implicitTypeAndValue(x, t)
+			return target != nil
 		})
+		if !ok {
+			return nil, nil, _InvalidUntypedConversion
+		}
 	case *Interface:
-		// Update operand types to the default type rather then the target
+		// Update operand types to the default type rather than the target
 		// (interface) type: values must have concrete dynamic types.
 		// Untyped nil was handled upfront.
 		check.completeInterface(nopos, t)
 		if !t.Empty() {
-			goto Error // cannot assign untyped values to non-empty interfaces
+			return nil, nil, _InvalidUntypedConversion // cannot assign untyped values to non-empty interfaces
 		}
-		target = Default(x.typ)
+		return Default(x.typ), nil, 0 // default type for nil is nil
 	default:
-		goto Error
-	}
-
-OK:
-	x.typ = target
-	if update {
-		check.updateExprType(x.expr, target, true)
+		return nil, nil, _InvalidUntypedConversion
 	}
-	return
-
-Error:
-	check.errorf(x, "cannot convert %s to %s", x, target)
-	x.mode = invalid
+	return target, nil, 0
 }
 
 func (check *Checker) comparison(x, y *operand, op syntax.Operator) {
 	// spec: "In any comparison, the first operand must be assignable
 	// to the type of the second operand, or vice versa."
 	err := ""
-	if x.assignableTo(check, y.typ, nil) || y.assignableTo(check, x.typ, nil) {
+	xok, _ := x.assignableTo(check, y.typ, nil)
+	yok, _ := y.assignableTo(check, x.typ, nil)
+	if xok || yok {
 		defined := false
 		switch op {
 		case syntax.Eql, syntax.Neq:
diff --git a/src/cmd/compile/internal/types2/operand.go b/src/cmd/compile/internal/types2/operand.go
index 001e905a7b..61ad0d00f8 100644
--- a/src/cmd/compile/internal/types2/operand.go
+++ b/src/cmd/compile/internal/types2/operand.go
@@ -236,65 +236,45 @@ func (x *operand) setConst(k syntax.LitKind, lit string) {
 // isNil reports whether x is a typed or the untyped nil value.
 func (x *operand) isNil() bool { return x.mode == nilvalue }
 
-// TODO(gri) The functions operand.assignableTo, checker.convertUntyped,
-//           checker.representable, and checker.assignment are
-//           overlapping in functionality. Need to simplify and clean up.
-
-// assignableTo reports whether x is assignable to a variable of type T.
-// If the result is false and a non-nil reason is provided, it may be set
-// to a more detailed explanation of the failure (result != "").
-// The check parameter may be nil if assignableTo is invoked through
-// an exported API call, i.e., when all methods have been type-checked.
-func (x *operand) assignableTo(check *Checker, T Type, reason *string) bool {
+// assignableTo reports whether x is assignable to a variable of type T. If the
+// result is false and a non-nil reason is provided, it may be set to a more
+// detailed explanation of the failure (result != ""). The returned error code
+// is only valid if the (first) result is false. The check parameter may be nil
+// if assignableTo is invoked through an exported API call, i.e., when all
+// methods have been type-checked.
+func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, errorCode) {
 	if x.mode == invalid || T == Typ[Invalid] {
-		return true // avoid spurious errors
+		return true, 0 // avoid spurious errors
 	}
 
 	V := x.typ
 
 	// x's type is identical to T
 	if check.identical(V, T) {
-		return true
+		return true, 0
 	}
 
 	Vu := optype(V)
 	Tu := optype(T)
 
-	// x is an untyped value representable by a value of type T
-	// TODO(gri) This is borrowing from checker.convertUntyped and
-	//           checker.representable. Need to clean up.
+	// x is an untyped value representable by a value of type T.
 	if isUntyped(Vu) {
-		switch t := Tu.(type) {
-		case *Basic:
-			if x.isNil() && t.kind == UnsafePointer {
-				return true
-			}
-			if x.mode == constant_ {
-				return representableConst(x.val, check, t, nil)
-			}
-			// The result of a comparison is an untyped boolean,
-			// but may not be a constant.
-			if Vb, _ := Vu.(*Basic); Vb != nil {
-				return Vb.kind == UntypedBool && isBoolean(Tu)
-			}
-		case *Sum:
+		if t, ok := Tu.(*Sum); ok {
 			return t.is(func(t Type) bool {
 				// TODO(gri) this could probably be more efficient
-				return x.assignableTo(check, t, reason)
-			})
-		case *Interface:
-			check.completeInterface(nopos, t)
-			return x.isNil() || t.Empty()
-		case *Pointer, *Signature, *Slice, *Map, *Chan:
-			return x.isNil()
+				ok, _ := x.assignableTo(check, t, reason)
+				return ok
+			}), _IncompatibleAssign
 		}
+		newType, _, _ := check.implicitTypeAndValue(x, Tu)
+		return newType != nil, _IncompatibleAssign
 	}
 	// Vu is typed
 
 	// x's type V and T have identical underlying types
 	// and at least one of V or T is not a named type
 	if check.identical(Vu, Tu) && (!isNamed(V) || !isNamed(T)) {
-		return true
+		return true, 0
 	}
 
 	// T is an interface type and x implements T
@@ -312,9 +292,9 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) bool {
 					*reason = "missing method " + m.Name()
 				}
 			}
-			return false
+			return false, _InvalidIfaceAssign
 		}
-		return true
+		return true, 0
 	}
 
 	// x is a bidirectional channel value, T is a channel
@@ -322,11 +302,11 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) bool {
 	// and at least one of V or T is not a named type
 	if Vc, ok := Vu.(*Chan); ok && Vc.dir == SendRecv {
 		if Tc, ok := Tu.(*Chan); ok && check.identical(Vc.elem, Tc.elem) {
-			return !isNamed(V) || !isNamed(T)
+			return !isNamed(V) || !isNamed(T), _InvalidChanAssign
 		}
 	}
 
-	return false
+	return false, _IncompatibleAssign
 }
 
 // kind2tok translates syntax.LitKinds into token.Tokens.
diff --git a/src/cmd/compile/internal/types2/testdata/builtins.src b/src/cmd/compile/internal/types2/testdata/builtins.src
index f866ef059f..6d1f47129b 100644
--- a/src/cmd/compile/internal/types2/testdata/builtins.src
+++ b/src/cmd/compile/internal/types2/testdata/builtins.src
@@ -35,9 +35,9 @@ func append1() {
 	type S []byte
 	type T string
 	var t T
-	_ = append(s, "foo" /* ERROR cannot convert */ )
+	_ = append(s, "foo" /* ERROR cannot use .* in argument to append */ )
 	_ = append(s, "foo"...)
-	_ = append(S(s), "foo" /* ERROR cannot convert */ )
+	_ = append(S(s), "foo" /* ERROR cannot use .* in argument to append */ )
 	_ = append(S(s), "foo"...)
 	_ = append(s, t /* ERROR cannot use t */ )
 	_ = append(s, t...)
@@ -283,7 +283,7 @@ func delete1() {
 	delete() // ERROR not enough arguments
 	delete(1) // ERROR not enough arguments
 	delete(1, 2, 3) // ERROR too many arguments
-	delete(m, 0 /* ERROR cannot convert */)
+	delete(m, 0 /* ERROR cannot use */)
 	delete(m, s)
 	_ = delete /* ERROR used as value */ (m, s)
 
diff --git a/src/cmd/compile/internal/types2/testdata/constdecl.src b/src/cmd/compile/internal/types2/testdata/constdecl.src
index 1a7ed003a4..cb155ab35d 100644
--- a/src/cmd/compile/internal/types2/testdata/constdecl.src
+++ b/src/cmd/compile/internal/types2/testdata/constdecl.src
@@ -111,13 +111,13 @@ func _() {
 const (
 	_ byte = 255 + iota
 	/* some gap */
-	_ // ERROR overflows byte
+	_ // ERROR overflows
 	/* some gap */
-	/* some gap */ _ /* ERROR overflows byte */; _ /* ERROR overflows byte */
+	/* some gap */ _ /* ERROR overflows */; _ /* ERROR overflows */
 	/* some gap */
 	_ = 255 + iota
-	_ = byte /* ERROR overflows byte */ (255) + iota
-	_ /* ERROR overflows byte */
+	_ = byte /* ERROR overflows */ (255) + iota
+	_ /* ERROR overflows */
 )
 
 // Test cases from issue.
diff --git a/src/cmd/compile/internal/types2/testdata/decls2/decls2b.src b/src/cmd/compile/internal/types2/testdata/decls2/decls2b.src
index 8e82c6dcde..7b3229cadc 100644
--- a/src/cmd/compile/internal/types2/testdata/decls2/decls2b.src
+++ b/src/cmd/compile/internal/types2/testdata/decls2/decls2b.src
@@ -40,17 +40,17 @@ func f_double /* ERROR "redeclared" */ () {}
 // Verify by checking that errors are reported.
 func (T /* ERROR "undeclared" */ ) _() {}
 func (T1) _(undeclared /* ERROR "undeclared" */ ) {}
-func (T1) _() int { return "foo" /* ERROR "cannot convert" */ }
+func (T1) _() int { return "foo" /* ERROR "cannot use .* in return statement" */ }
 
 // Methods with undeclared receiver type can still be checked.
 // Verify by checking that errors are reported.
 func (Foo /* ERROR "undeclared" */ ) m() {}
 func (Foo /* ERROR "undeclared" */ ) m(undeclared /* ERROR "undeclared" */ ) {}
-func (Foo /* ERROR "undeclared" */ ) m() int { return "foo" /* ERROR "cannot convert" */ }
+func (Foo /* ERROR "undeclared" */ ) m() int { return "foo" /* ERROR "cannot use .* in return statement" */ }
 
 func (Foo /* ERROR "undeclared" */ ) _() {}
 func (Foo /* ERROR "undeclared" */ ) _(undeclared /* ERROR "undeclared" */ ) {}
-func (Foo /* ERROR "undeclared" */ ) _() int { return "foo" /* ERROR "cannot convert" */ }
+func (Foo /* ERROR "undeclared" */ ) _() int { return "foo" /* ERROR "cannot use .* in return statement" */ }
 
 // Receiver declarations are regular parameter lists;
 // receiver types may use parentheses, and the list
diff --git a/src/cmd/compile/internal/types2/testdata/expr3.src b/src/cmd/compile/internal/types2/testdata/expr3.src
index 6d0ac6cd94..d1be806cfd 100644
--- a/src/cmd/compile/internal/types2/testdata/expr3.src
+++ b/src/cmd/compile/internal/types2/testdata/expr3.src
@@ -95,7 +95,7 @@ func indexes() {
 	_ = &s /* ERROR "cannot take address" */ [:10]
 
 	var m map[string]int
-	_ = m[0 /* ERROR "cannot convert" */ ]
+	_ = m[0 /* ERROR "cannot use .* in map index" */ ]
 	_ = m /* ERROR "cannot slice" */ ["foo" : "bar"]
 	_ = m["foo"]
 	// ok is of type bool
@@ -103,7 +103,7 @@ func indexes() {
 	var ok mybool
 	_, ok = m["bar"]
 	_ = ok
-	_ = m[0 /* ERROR "cannot convert 0" */ ] + "foo" // ERROR "cannot convert"
+	_ = m[0 /* ERROR "cannot use 0" */ ] + "foo" // ERROR "cannot convert"
 
 	var t string
 	_ = t[- /* ERROR "negative" */ 1]
@@ -186,7 +186,7 @@ func struct_literals() {
 	_ = T1{aa /* ERROR "unknown field" */ : 0}
 	_ = T1{1 /* ERROR "invalid field name" */ : 0}
 	_ = T1{a: 0, s: "foo", u: 0, a /* ERROR "duplicate field" */: 10}
-	_ = T1{a: "foo" /* ERROR "cannot convert" */ }
+	_ = T1{a: "foo" /* ERROR "cannot use .* in struct literal" */ }
 	_ = T1{c /* ERROR "unknown field" */ : 0}
 	_ = T1{T0: { /* ERROR "missing type" */ }} // struct literal element type may not be elided
 	_ = T1{T0: T0{}}
@@ -197,7 +197,7 @@ func struct_literals() {
 	_ = T0{1, b /* ERROR "mixture" */ : 2, 3}
 	_ = T0{1, 2} /* ERROR "too few values" */
 	_ = T0{1, 2, 3, 4  /* ERROR "too many values" */ }
-	_ = T0{1, "foo" /* ERROR "cannot convert" */, 3.4  /* ERROR "truncated" */}
+	_ = T0{1, "foo" /* ERROR "cannot use .* in struct literal" */, 3.4  /* ERROR "cannot use .*\(truncated\)" */}
 
 	// invalid type
 	type P *struct{
@@ -237,7 +237,7 @@ func array_literals() {
 	_ = A1{5: 5, 6, 7, 4: 4, 1 /* ERROR "overflows" */ <<100: 4}
 	_ = A1{2.0}
 	_ = A1{2.1 /* ERROR "truncated" */ }
-	_ = A1{"foo" /* ERROR "cannot convert" */ }
+	_ = A1{"foo" /* ERROR "cannot use .* in array or slice literal" */ }
 
 	// indices must be integer constants
 	i := 1
@@ -303,7 +303,7 @@ func slice_literals() {
 	_ = S0{5: 5, 6, 7, 4: 4, 1 /* ERROR "overflows" */ <<100: 4}
 	_ = S0{2.0}
 	_ = S0{2.1 /* ERROR "truncated" */ }
-	_ = S0{"foo" /* ERROR "cannot convert" */ }
+	_ = S0{"foo" /* ERROR "cannot use .* in array or slice literal" */ }
 
 	// indices must be resolved correctly
 	const index1 = 1
@@ -356,8 +356,8 @@ func map_literals() {
 
 	_ = M0{}
 	_ = M0{1 /* ERROR "missing key" */ }
-	_ = M0{1 /* ERROR "cannot convert" */ : 2}
-	_ = M0{"foo": "bar" /* ERROR "cannot convert" */ }
+	_ = M0{1 /* ERROR "cannot use .* in map literal" */ : 2}
+	_ = M0{"foo": "bar" /* ERROR "cannot use .* in map literal" */ }
 	_ = M0{"foo": 1, "bar": 2, "foo" /* ERROR "duplicate key" */ : 3 }
 
 	_ = map[interface{}]int{2: 1, 2 /* ERROR "duplicate key" */ : 1}
diff --git a/src/cmd/compile/internal/types2/testdata/issues.src b/src/cmd/compile/internal/types2/testdata/issues.src
index 1bfc7fec75..940d204084 100644
--- a/src/cmd/compile/internal/types2/testdata/issues.src
+++ b/src/cmd/compile/internal/types2/testdata/issues.src
@@ -354,10 +354,10 @@ func issue26234c() {
 
 func issue35895() {
 	// T is defined in this package, don't qualify its name with the package name.
-	var _ T = 0 // ERROR cannot convert 0 \(untyped int constant\) to T
+	var _ T = 0 // ERROR cannot use 0 \(untyped int constant\) as T
 
 	// There is only one package with name syntax imported, only use the (global) package name in error messages.
-	var _ *syn.File = 0 // ERROR cannot convert 0 \(untyped int constant\) to \*syntax.File
+	var _ *syn.File = 0 // ERROR cannot use 0 \(untyped int constant\) as \*syntax.File
 
 	// Because both t1 and t2 have the same global package name (template),
 	// qualify packages with full path name in this case.
diff --git a/src/cmd/compile/internal/types2/testdata/stmt0.src b/src/cmd/compile/internal/types2/testdata/stmt0.src
index 77d4ba1bfe..022883040b 100644
--- a/src/cmd/compile/internal/types2/testdata/stmt0.src
+++ b/src/cmd/compile/internal/types2/testdata/stmt0.src
@@ -69,10 +69,10 @@ func assignments1() {
 
 	// test cases for issue 5800
 	var (
-		_ int = nil /* ERROR "cannot convert untyped nil" */
-		_ [10]int = nil /* ERROR "cannot convert untyped nil" */
+		_ int = nil /* ERROR "untyped nil" */
+		_ [10]int = nil /* ERROR "untyped nil" */
 		_ []byte = nil
-		_ struct{} = nil /* ERROR "cannot convert untyped nil" */
+		_ struct{} = nil /* ERROR "untyped nil" */
 		_ func() = nil
 		_ map[int]string = nil
 		_ chan int = nil
@@ -182,7 +182,7 @@ func sends() {
 	var x int
 	x <- /* ERROR "cannot send" */ x
 	rch <- /* ERROR "cannot send" */ x
-	ch <- "foo" /* ERROR "cannot convert" */
+	ch <- "foo" /* ERROR "cannot use .* in send" */
 	ch <- x
 }
 
@@ -381,13 +381,13 @@ func returns0() {
 func returns1(x float64) (int, *float64) {
 	return 0, &x
 	return /* ERROR wrong number of return values */
-	return "foo" /* ERROR "cannot convert" */, x /* ERROR "cannot use .* in return statement" */
+	return "foo" /* ERROR "cannot .* in return statement" */, x /* ERROR "cannot use .* in return statement" */
 	return /* ERROR wrong number of return values */ 0, &x, 1
 }
 
 func returns2() (a, b int) {
 	return
-	return 1, "foo" /* ERROR cannot convert */
+	return 1, "foo" /* ERROR cannot use .* in return statement */
 	return /* ERROR wrong number of return values */ 1, 2, 3
 	{
 		type a int
@@ -609,7 +609,7 @@ func switches2() {
 	// untyped constants are converted to default types
 	switch 1<<63-1 {
 	}
-	switch 1 /* ERROR "overflows int" */ << 63 {
+	switch 1 /* ERROR "cannot use .* as int value.*\(overflows\)" */ << 63 {
 	}
 	var x int
 	switch 1.0 {
@@ -631,9 +631,9 @@ func switches2() {
 }
 
 func issue11667() {
-	switch 9223372036854775808 /* ERROR "overflows int" */ {
+	switch 9223372036854775808 /* ERROR "cannot use .* as int value.*\(overflows\)" */ {
 	}
-	switch 9223372036854775808 /* ERROR "overflows int" */ {
+	switch 9223372036854775808 /* ERROR "cannot use .* as int value.*\(overflows\)" */ {
 	case 9223372036854775808:
 	}
 	var x int
diff --git a/src/cmd/compile/internal/types2/testdata/typeparams.go2 b/src/cmd/compile/internal/types2/testdata/typeparams.go2
index 41306b6e23..badda01105 100644
--- a/src/cmd/compile/internal/types2/testdata/typeparams.go2
+++ b/src/cmd/compile/internal/types2/testdata/typeparams.go2
@@ -37,7 +37,7 @@ var _ = reverse /* ERROR cannot use generic function reverse */
 var _ = reverse[int, float32 /* ERROR got 2 type arguments */ ] ([]int{1, 2, 3})
 var _ = reverse[int]([ /* ERROR cannot use */ ]float32{1, 2, 3})
 var f = reverse[chan int]
-var _ = f(0 /* ERROR cannot convert 0 .* to \[\]chan int */ )
+var _ = f(0 /* ERROR cannot use 0 .* as \[\]chan int */ )
 
 func swap[A, B any](a A, b B) (B, A) { return b, a }
 
@@ -310,7 +310,7 @@ func (_ R1[A, B]) _[A /* ERROR redeclared */ any](B)
 func _() {
         var r R1[int, string]
         r.m1[rune](42, "foo", 'a')
-        r.m1[rune](42, "foo", 1.2 /* ERROR truncated to rune */)
+        r.m1[rune](42, "foo", 1.2 /* ERROR cannot use .* as rune .* \(truncated\) */)
         r.m1(42, "foo", 1.2) // using type inference
         var _ float64 = r.m1(42, "foo", 1.2)
 }
diff --git a/test/convlit.go b/test/convlit.go
index 9d2eee79c5..8bf9928c70 100644
--- a/test/convlit.go
+++ b/test/convlit.go
@@ -34,7 +34,7 @@ var bad4 = "a" + 1   // ERROR "literals|incompatible|convert|invalid"
 var bad5 = "a" + 'a' // ERROR "literals|incompatible|convert|invalid"
 
 var bad6 int = 1.5       // ERROR "convert|truncate"
-var bad7 int = 1e100     // ERROR "overflow|truncated to int"
+var bad7 int = 1e100     // ERROR "overflow|truncated to int|truncated"
 var bad8 float32 = 1e200 // ERROR "overflow"
 
 // but these implicit conversions are okay
diff --git a/test/fixedbugs/bug205.go b/test/fixedbugs/bug205.go
index 789696df0c..165020ea66 100644
--- a/test/fixedbugs/bug205.go
+++ b/test/fixedbugs/bug205.go
@@ -13,6 +13,6 @@ var m map[string]int;
 func main() {
 	println(t["hi"]); // ERROR "non-integer slice index|must be integer|cannot convert"
 	println(s["hi"]); // ERROR "non-integer string index|must be integer|cannot convert"
-	println(m[0]);    // ERROR "cannot use.*as type string|cannot convert"
+	println(m[0]);    // ERROR "cannot use.*as type string|cannot convert|cannot use"
 }
 
diff --git a/test/fixedbugs/bug397.go b/test/fixedbugs/bug397.go
index bf3a5fffc8..5f1476adf7 100644
--- a/test/fixedbugs/bug397.go
+++ b/test/fixedbugs/bug397.go
@@ -9,5 +9,5 @@ package main
 // Issue 2623
 var m = map[string]int{
 	"abc": 1,
-	1:     2, // ERROR "cannot use 1.*as type string in map key|incompatible type|cannot convert"
+	1:     2, // ERROR "cannot use 1.*as type string in map key|incompatible type|cannot convert|cannot use"
 }
diff --git a/test/fixedbugs/issue11326.go b/test/fixedbugs/issue11326.go
index 7f08e7fa3c..4ce25c5e8b 100644
--- a/test/fixedbugs/issue11326.go
+++ b/test/fixedbugs/issue11326.go
@@ -18,14 +18,14 @@ func main() {
 
 	// Any implementation must be able to handle these constants at
 	// compile time (even though they cannot be assigned to a float64).
-	var _ = 1e646456992  // ERROR "1e\+646456992 overflows float64|floating-point constant overflow|exponent too large|overflows float64"
-	var _ = 1e64645699   // ERROR "1e\+64645699 overflows float64|floating-point constant overflow|exponent too large|overflows float64"
-	var _ = 1e6464569    // ERROR "1e\+6464569 overflows float64|floating-point constant overflow|exponent too large|overflows float64"
-	var _ = 1e646456     // ERROR "1e\+646456 overflows float64|floating-point constant overflow|exponent too large|overflows float64"
-	var _ = 1e64645      // ERROR "1e\+64645 overflows float64|floating-point constant overflow|exponent too large|overflows float64"
-	var _ = 1e6464       // ERROR "1e\+6464 overflows float64|floating-point constant overflow|overflows float64"
-	var _ = 1e646        // ERROR "1e\+646 overflows float64|floating-point constant overflow|overflows float64"
-	var _ = 1e309        // ERROR "1e\+309 overflows float64|floating-point constant overflow|overflows float64"
+	var _ = 1e646456992  // ERROR "1e\+646456992 overflows float64|floating-point constant overflow|exponent too large|overflows float64|overflows"
+	var _ = 1e64645699   // ERROR "1e\+64645699 overflows float64|floating-point constant overflow|exponent too large|overflows float64|overflows"
+	var _ = 1e6464569    // ERROR "1e\+6464569 overflows float64|floating-point constant overflow|exponent too large|overflows float64|overflows"
+	var _ = 1e646456     // ERROR "1e\+646456 overflows float64|floating-point constant overflow|exponent too large|overflows float64|overflows"
+	var _ = 1e64645      // ERROR "1e\+64645 overflows float64|floating-point constant overflow|exponent too large|overflows float64|overflows"
+	var _ = 1e6464       // ERROR "1e\+6464 overflows float64|floating-point constant overflow|overflows float64|overflows"
+	var _ = 1e646        // ERROR "1e\+646 overflows float64|floating-point constant overflow|overflows float64|overflows"
+	var _ = 1e309        // ERROR "1e\+309 overflows float64|floating-point constant overflow|overflows float64|overflows"
 
 	var _ = 1e308
 }
diff --git a/test/fixedbugs/issue11371.go b/test/fixedbugs/issue11371.go
index 0965e88d74..bc10ca6627 100644
--- a/test/fixedbugs/issue11371.go
+++ b/test/fixedbugs/issue11371.go
@@ -9,9 +9,9 @@
 
 package issue11371
 
-const a int = 1.1        // ERROR "constant 1.1 truncated to integer|floating-point constant truncated to integer|truncated to int"
-const b int = 1e20       // ERROR "overflows int|integer constant overflow|truncated to int"
-const c int = 1 + 1e-70  // ERROR "constant truncated to integer|truncated to int"
-const d int = 1 - 1e-70  // ERROR "constant truncated to integer|truncated to int"
-const e int = 1.00000001 // ERROR "constant truncated to integer|truncated to int"
-const f int = 0.00000001 // ERROR "constant 1e-08 truncated to integer|floating-point constant truncated to integer|truncated to int"
+const a int = 1.1        // ERROR "constant 1.1 truncated to integer|floating-point constant truncated to integer|truncated to int|truncated"
+const b int = 1e20       // ERROR "overflows int|integer constant overflow|truncated to int|truncated"
+const c int = 1 + 1e-70  // ERROR "constant truncated to integer|truncated to int|truncated"
+const d int = 1 - 1e-70  // ERROR "constant truncated to integer|truncated to int|truncated"
+const e int = 1.00000001 // ERROR "constant truncated to integer|truncated to int|truncated"
+const f int = 0.00000001 // ERROR "constant 1e-08 truncated to integer|floating-point constant truncated to integer|truncated to int|truncated"
diff --git a/test/fixedbugs/issue13559.go b/test/fixedbugs/issue13559.go
index 07cf2ca211..cc139d58d2 100644
--- a/test/fixedbugs/issue13559.go
+++ b/test/fixedbugs/issue13559.go
@@ -10,80 +10,80 @@
 package p
 
 // failure case in issue
-const _ int64 = 1e-10000 // ERROR "1e\-10000 truncated|.* truncated to int64"
+const _ int64 = 1e-10000 // ERROR "1e\-10000 truncated|.* truncated to int64|truncated"
 
 const (
-	_ int64 = 1e10000000 // ERROR "integer too large|truncated to int64"
-	_ int64 = 1e1000000  // ERROR "integer too large|truncated to int64"
-	_ int64 = 1e100000   // ERROR "integer too large|truncated to int64"
-	_ int64 = 1e10000    // ERROR "integer too large|truncated to int64"
-	_ int64 = 1e1000     // ERROR "integer too large|truncated to int64"
-	_ int64 = 1e100      // ERROR "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 overflows|truncated to int64"
+	_ int64 = 1e10000000 // ERROR "integer too large|truncated to int64|truncated"
+	_ int64 = 1e1000000  // ERROR "integer too large|truncated to int64|truncated"
+	_ int64 = 1e100000   // ERROR "integer too large|truncated to int64|truncated"
+	_ int64 = 1e10000    // ERROR "integer too large|truncated to int64|truncated"
+	_ int64 = 1e1000     // ERROR "integer too large|truncated to int64|truncated"
+	_ int64 = 1e100      // ERROR "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 overflows|truncated to int64|truncated"
 	_ int64 = 1e10
 	_ int64 = 1e1
 	_ int64 = 1e0
-	_ int64 = 1e-1       // ERROR "0\.1 truncated|.* truncated to int64"
-	_ int64 = 1e-10      // ERROR "1e\-10 truncated|.* truncated to int64"
-	_ int64 = 1e-100     // ERROR "1e\-100 truncated|.* truncated to int64"
-	_ int64 = 1e-1000    // ERROR "1e\-1000 truncated|.* truncated to int64"
-	_ int64 = 1e-10000   // ERROR "1e\-10000 truncated|.* truncated to int64"
-	_ int64 = 1e-100000  // ERROR "1e\-100000 truncated|.* truncated to int64"
-	_ int64 = 1e-1000000 // ERROR "1e\-1000000 truncated|.* truncated to int64"
+	_ int64 = 1e-1       // ERROR "0\.1 truncated|.* truncated to int64|truncated"
+	_ int64 = 1e-10      // ERROR "1e\-10 truncated|.* truncated to int64|truncated"
+	_ int64 = 1e-100     // ERROR "1e\-100 truncated|.* truncated to int64|truncated"
+	_ int64 = 1e-1000    // ERROR "1e\-1000 truncated|.* truncated to int64|truncated"
+	_ int64 = 1e-10000   // ERROR "1e\-10000 truncated|.* truncated to int64|truncated"
+	_ int64 = 1e-100000  // ERROR "1e\-100000 truncated|.* truncated to int64|truncated"
+	_ int64 = 1e-1000000 // ERROR "1e\-1000000 truncated|.* truncated to int64|truncated"
 )
 
 const (
-	_ int64 = -1e10000000 // ERROR "integer too large|truncated to int64"
-	_ int64 = -1e1000000  // ERROR "integer too large|truncated to int64"
-	_ int64 = -1e100000   // ERROR "integer too large|truncated to int64"
-	_ int64 = -1e10000    // ERROR "integer too large|truncated to int64"
-	_ int64 = -1e1000     // ERROR "integer too large|truncated to int64"
-	_ int64 = -1e100      // ERROR "\-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 overflows|truncated to int64"
+	_ int64 = -1e10000000 // ERROR "integer too large|truncated to int64|truncated"
+	_ int64 = -1e1000000  // ERROR "integer too large|truncated to int64|truncated"
+	_ int64 = -1e100000   // ERROR "integer too large|truncated to int64|truncated"
+	_ int64 = -1e10000    // ERROR "integer too large|truncated to int64|truncated"
+	_ int64 = -1e1000     // ERROR "integer too large|truncated to int64|truncated"
+	_ int64 = -1e100      // ERROR "\-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 overflows|truncated to int64|truncated"
 	_ int64 = -1e10
 	_ int64 = -1e1
 	_ int64 = -1e0
-	_ int64 = -1e-1       // ERROR "\-0\.1 truncated|.* truncated to int64"
-	_ int64 = -1e-10      // ERROR "\-1e\-10 truncated|.* truncated to int64"
-	_ int64 = -1e-100     // ERROR "\-1e\-100 truncated|.* truncated to int64"
-	_ int64 = -1e-1000    // ERROR "\-1e\-1000 truncated|.* truncated to int64"
-	_ int64 = -1e-10000   // ERROR "\-1e\-10000 truncated|.* truncated to int64"
-	_ int64 = -1e-100000  // ERROR "\-1e\-100000 truncated|.* truncated to int64"
-	_ int64 = -1e-1000000 // ERROR "\-1e\-1000000 truncated|.* truncated to int64"
+	_ int64 = -1e-1       // ERROR "\-0\.1 truncated|.* truncated to int64|truncated"
+	_ int64 = -1e-10      // ERROR "\-1e\-10 truncated|.* truncated to int64|truncated"
+	_ int64 = -1e-100     // ERROR "\-1e\-100 truncated|.* truncated to int64|truncated"
+	_ int64 = -1e-1000    // ERROR "\-1e\-1000 truncated|.* truncated to int64|truncated"
+	_ int64 = -1e-10000   // ERROR "\-1e\-10000 truncated|.* truncated to int64|truncated"
+	_ int64 = -1e-100000  // ERROR "\-1e\-100000 truncated|.* truncated to int64|truncated"
+	_ int64 = -1e-1000000 // ERROR "\-1e\-1000000 truncated|.* truncated to int64|truncated"
 )
 
 const (
-	_ int64 = 1.23456789e10000000 // ERROR "integer too large|truncated to int64"
-	_ int64 = 1.23456789e1000000  // ERROR "integer too large|truncated to int64"
-	_ int64 = 1.23456789e100000   // ERROR "integer too large|truncated to int64"
-	_ int64 = 1.23456789e10000    // ERROR "integer too large|truncated to int64"
-	_ int64 = 1.23456789e1000     // ERROR "integer too large|truncated to int64"
-	_ int64 = 1.23456789e100      // ERROR "12345678900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 overflows|truncated to int64"
+	_ int64 = 1.23456789e10000000 // ERROR "integer too large|truncated to int64|truncated"
+	_ int64 = 1.23456789e1000000  // ERROR "integer too large|truncated to int64|truncated"
+	_ int64 = 1.23456789e100000   // ERROR "integer too large|truncated to int64|truncated"
+	_ int64 = 1.23456789e10000    // ERROR "integer too large|truncated to int64|truncated"
+	_ int64 = 1.23456789e1000     // ERROR "integer too large|truncated to int64|truncated"
+	_ int64 = 1.23456789e100      // ERROR "12345678900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 overflows|truncated to int64|truncated"
 	_ int64 = 1.23456789e10
-	_ int64 = 1.23456789e1        // ERROR "12\.3457 truncated|.* truncated to int64"
-	_ int64 = 1.23456789e0        // ERROR "1\.23457 truncated|.* truncated to int64"
-	_ int64 = 1.23456789e-1       // ERROR "0\.123457 truncated|.* truncated to int64"
-	_ int64 = 1.23456789e-10      // ERROR "1\.23457e\-10 truncated|.* truncated to int64"
-	_ int64 = 1.23456789e-100     // ERROR "1\.23457e\-100 truncated|.* truncated to int64"
-	_ int64 = 1.23456789e-1000    // ERROR "1\.23457e\-1000 truncated|.* truncated to int64"
-	_ int64 = 1.23456789e-10000   // ERROR "1\.23457e\-10000 truncated|.* truncated to int64"
-	_ int64 = 1.23456789e-100000  // ERROR "1\.23457e\-100000 truncated|.* truncated to int64"
-	_ int64 = 1.23456789e-1000000 // ERROR "1\.23457e\-1000000 truncated|.* truncated to int64"
+	_ int64 = 1.23456789e1        // ERROR "12\.3457 truncated|.* truncated to int64|truncated"
+	_ int64 = 1.23456789e0        // ERROR "1\.23457 truncated|.* truncated to int64|truncated"
+	_ int64 = 1.23456789e-1       // ERROR "0\.123457 truncated|.* truncated to int64|truncated"
+	_ int64 = 1.23456789e-10      // ERROR "1\.23457e\-10 truncated|.* truncated to int64|truncated"
+	_ int64 = 1.23456789e-100     // ERROR "1\.23457e\-100 truncated|.* truncated to int64|truncated"
+	_ int64 = 1.23456789e-1000    // ERROR "1\.23457e\-1000 truncated|.* truncated to int64|truncated"
+	_ int64 = 1.23456789e-10000   // ERROR "1\.23457e\-10000 truncated|.* truncated to int64|truncated"
+	_ int64 = 1.23456789e-100000  // ERROR "1\.23457e\-100000 truncated|.* truncated to int64|truncated"
+	_ int64 = 1.23456789e-1000000 // ERROR "1\.23457e\-1000000 truncated|.* truncated to int64|truncated"
 )
 
 const (
-	_ int64 = -1.23456789e10000000 // ERROR "integer too large|truncated to int64"
-	_ int64 = -1.23456789e1000000  // ERROR "integer too large|truncated to int64"
-	_ int64 = -1.23456789e100000   // ERROR "integer too large|truncated to int64"
-	_ int64 = -1.23456789e10000    // ERROR "integer too large|truncated to int64"
-	_ int64 = -1.23456789e1000     // ERROR "integer too large|truncated to int64"
-	_ int64 = -1.23456789e100      // ERROR "\-12345678900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 overflows|truncated to int64"
+	_ int64 = -1.23456789e10000000 // ERROR "integer too large|truncated to int64|truncated"
+	_ int64 = -1.23456789e1000000  // ERROR "integer too large|truncated to int64|truncated"
+	_ int64 = -1.23456789e100000   // ERROR "integer too large|truncated to int64|truncated"
+	_ int64 = -1.23456789e10000    // ERROR "integer too large|truncated to int64|truncated"
+	_ int64 = -1.23456789e1000     // ERROR "integer too large|truncated to int64|truncated"
+	_ int64 = -1.23456789e100      // ERROR "\-12345678900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 overflows|truncated to int64|truncated"
 	_ int64 = -1.23456789e10
-	_ int64 = -1.23456789e1        // ERROR "\-12\.3457 truncated|.* truncated to int64"
-	_ int64 = -1.23456789e0        // ERROR "\-1\.23457 truncated|.* truncated to int64"
-	_ int64 = -1.23456789e-1       // ERROR "\-0\.123457 truncated|.* truncated to int64"
-	_ int64 = -1.23456789e-10      // ERROR "\-1\.23457e\-10 truncated|.* truncated to int64"
-	_ int64 = -1.23456789e-100     // ERROR "\-1\.23457e\-100 truncated|.* truncated to int64"
-	_ int64 = -1.23456789e-1000    // ERROR "\-1\.23457e\-1000 truncated|.* truncated to int64"
-	_ int64 = -1.23456789e-10000   // ERROR "\-1\.23457e\-10000 truncated|.* truncated to int64"
-	_ int64 = -1.23456789e-100000  // ERROR "\-1\.23457e\-100000 truncated|.* truncated to int64"
-	_ int64 = -1.23456789e-1000000 // ERROR "\-1\.23457e\-1000000 truncated|.* truncated to int64"
+	_ int64 = -1.23456789e1        // ERROR "\-12\.3457 truncated|.* truncated to int64|truncated"
+	_ int64 = -1.23456789e0        // ERROR "\-1\.23457 truncated|.* truncated to int64|truncated"
+	_ int64 = -1.23456789e-1       // ERROR "\-0\.123457 truncated|.* truncated to int64|truncated"
+	_ int64 = -1.23456789e-10      // ERROR "\-1\.23457e\-10 truncated|.* truncated to int64|truncated"
+	_ int64 = -1.23456789e-100     // ERROR "\-1\.23457e\-100 truncated|.* truncated to int64|truncated"
+	_ int64 = -1.23456789e-1000    // ERROR "\-1\.23457e\-1000 truncated|.* truncated to int64|truncated"
+	_ int64 = -1.23456789e-10000   // ERROR "\-1\.23457e\-10000 truncated|.* truncated to int64|truncated"
+	_ int64 = -1.23456789e-100000  // ERROR "\-1\.23457e\-100000 truncated|.* truncated to int64|truncated"
+	_ int64 = -1.23456789e-1000000 // ERROR "\-1\.23457e\-1000000 truncated|.* truncated to int64|truncated"
 )
diff --git a/test/fixedbugs/issue6402.go b/test/fixedbugs/issue6402.go
index cd8fb218ac..39cb9ac3f0 100644
--- a/test/fixedbugs/issue6402.go
+++ b/test/fixedbugs/issue6402.go
@@ -9,5 +9,5 @@
 package p
 
 func f() uintptr {
-	return nil // ERROR "cannot use nil as type uintptr in return argument|incompatible type|cannot convert untyped nil"
+	return nil // ERROR "cannot use nil as type uintptr in return argument|incompatible type|cannot use untyped nil"
 }
diff --git a/test/fixedbugs/issue7153.go b/test/fixedbugs/issue7153.go
index 12cd62b653..0b29ec779b 100644
--- a/test/fixedbugs/issue7153.go
+++ b/test/fixedbugs/issue7153.go
@@ -8,4 +8,4 @@
 
 package p
 
-var _ = []int{a: true, true} // ERROR "undefined: a" "cannot use true \(type untyped bool\) as type int in slice literal|undefined name .*a|incompatible type|cannot convert"
+var _ = []int{a: true, true} // ERROR "undefined: a" "cannot use true \(type untyped bool\) as type int in slice literal|undefined name .*a|incompatible type|cannot use"
-- 
GitLab


From e7aa0f9f2834fb7eac1f435f834e6bbf461d55ac Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 18 Mar 2021 15:10:44 -0700
Subject: [PATCH 1195/2400] go/types, types2: add a test case for shifts that
 used to fail

For #42989.

Change-Id: Ic354edde23ed7bfb4cb3eec2794f7213ed862b47
Reviewed-on: https://go-review.googlesource.com/c/go/+/303090
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/testdata/issues.src | 6 ++++++
 src/go/types/testdata/issues.src                    | 6 ++++++
 2 files changed, 12 insertions(+)

diff --git a/src/cmd/compile/internal/types2/testdata/issues.src b/src/cmd/compile/internal/types2/testdata/issues.src
index 940d204084..21aa208cc7 100644
--- a/src/cmd/compile/internal/types2/testdata/issues.src
+++ b/src/cmd/compile/internal/types2/testdata/issues.src
@@ -363,3 +363,9 @@ func issue35895() {
 	// qualify packages with full path name in this case.
 	var _ t1.Template = t2 /* ERROR cannot use .* \(value of type "html/template".Template\) as "text/template".Template */ .Template{}
 }
+
+func issue42989(s uint) {
+	var m map[int]string
+	delete(m, 1<<s)
+	delete(m, 1.<<s)
+}
diff --git a/src/go/types/testdata/issues.src b/src/go/types/testdata/issues.src
index db415eadfb..e2ac06759b 100644
--- a/src/go/types/testdata/issues.src
+++ b/src/go/types/testdata/issues.src
@@ -363,3 +363,9 @@ func issue35895() {
 	// qualify packages with full path name in this case.
 	var _ t1.Template = t2 /* ERROR cannot use .* \(value of type "html/template".Template\) as "text/template".Template */ .Template{}
 }
+
+func issue42989(s uint) {
+	var m map[int]string
+	delete(m, 1<<s)
+	delete(m, 1.<<s)
+}
-- 
GitLab


From cd26192abab742cb2df24827226eab0e9f3683a9 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 18 Mar 2021 17:29:02 -0700
Subject: [PATCH 1196/2400] go/types: remove superfluous code for shift
 checking

Negative constant shift counts are already handled
earlier in the code. No need anymore for this extra
section.

With this change, the shift code matches types2
with respect to the function logic.

Change-Id: Ic8b7f382271c79ab66021e30955cd9bac092332b
Reviewed-on: https://go-review.googlesource.com/c/go/+/303093
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/go/types/expr.go | 16 +---------------
 1 file changed, 1 insertion(+), 15 deletions(-)

diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index e1b484c410..170761afb3 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -805,20 +805,6 @@ func (check *Checker) shift(x, y *operand, e ast.Expr, op token.Token) {
 		return
 	}
 
-	var yval constant.Value
-	if y.mode == constant_ {
-		// rhs must be an integer value
-		// (Either it was of an integer type already, or it was
-		// untyped and successfully converted to a uint above.)
-		yval = constant.ToInt(y.val)
-		assert(yval.Kind() == constant.Int)
-		if constant.Sign(yval) < 0 {
-			check.invalidOp(y, _InvalidShiftCount, "negative shift count %s", y)
-			x.mode = invalid
-			return
-		}
-	}
-
 	if x.mode == constant_ {
 		if y.mode == constant_ {
 			// if either x or y has an unknown value, the result is unknown
@@ -832,7 +818,7 @@ func (check *Checker) shift(x, y *operand, e ast.Expr, op token.Token) {
 			}
 			// rhs must be within reasonable bounds in constant shifts
 			const shiftBound = 1023 - 1 + 52 // so we can express smallestFloat64 (see issue #44057)
-			s, ok := constant.Uint64Val(yval)
+			s, ok := constant.Uint64Val(y.val)
 			if !ok || s > shiftBound {
 				check.invalidOp(y, _InvalidShiftCount, "invalid shift count %s", y)
 				x.mode = invalid
-- 
GitLab


From f4b918384d64dbd046f144012a60080fae16af86 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 18 Mar 2021 18:35:53 -0700
Subject: [PATCH 1197/2400] test: enable fixedbugs/bug193.go for -G compiler
 option

Temporarily disable a questionable test case in fixedbugs/bug193.go
and enable the test as a whole. See the issues below for details.

Updates #45114.
Updates #45117.

Change-Id: I1de6f8d79b592eeeec139cd92b6c9cac56a9a74b
Reviewed-on: https://go-review.googlesource.com/c/go/+/303094
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 test/fixedbugs/bug193.go | 4 +++-
 test/run.go              | 1 -
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/test/fixedbugs/bug193.go b/test/fixedbugs/bug193.go
index 64e06da897..36073220f9 100644
--- a/test/fixedbugs/bug193.go
+++ b/test/fixedbugs/bug193.go
@@ -11,6 +11,8 @@ func main() {
 	ss := 1 << s
 	y1 := float64(ss)
 	y2 := float64(1 << s) // ERROR "shift"
-	y3 := string(1 << s)  // ERROR "shift"
+	// see issues #45114, #45117
+	// y3 := string(1 << s)  // DISABLED "shift"
+	y3 := 0
 	_, _, _, _, _ = s, ss, y1, y2, y3
 }
diff --git a/test/run.go b/test/run.go
index 7d5a558f2d..d999f18790 100644
--- a/test/run.go
+++ b/test/run.go
@@ -1939,7 +1939,6 @@ var excluded = map[string]bool{
 	"writebarrier.go": true, // correct diagnostics, but different lines (probably irgen's fault)
 
 	"fixedbugs/bug176.go":    true, // types2 reports all errors (pref: types2)
-	"fixedbugs/bug193.go":    true, // types2 bug: shift error not reported (fixed in go/types)
 	"fixedbugs/bug195.go":    true, // types2 reports slightly different (but correct) bugs
 	"fixedbugs/bug228.go":    true, // types2 not run after syntax errors
 	"fixedbugs/bug231.go":    true, // types2 bug? (same error reported twice)
-- 
GitLab


From 53dd0d78098a43cbca26d6807fea3d58aec64ef7 Mon Sep 17 00:00:00 2001
From: Zhang Boyang <zhangboyang.id@gmail.com>
Date: Mon, 15 Mar 2021 15:27:51 +0000
Subject: [PATCH 1198/2400] net: make go resolver aware of network parameter

Currently, the go resolver always send two DNS queries (A and AAAA) even
if tcp4/udp4/ip4 or tcp6/udp6/ip6 is used. This can cause unwanted
latencies when making IPv4-only or IPv6-only connections.

This change make go resolver aware of network parameter. Now, only one A
query is sent when tcp4/udp4/ip4 is used, and vice versa for
tcp6/udp6/ip6.

Fixes #45024

Change-Id: I815f909e6df5f7242cfc900f7dfecca628c3a2c8
GitHub-Last-Rev: 3d30c486dedd0d211366b1989034480a22ef2ffc
GitHub-Pull-Request: golang/go#45016
Reviewed-on: https://go-review.googlesource.com/c/go/+/301709
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/net/dnsclient_unix.go      | 18 ++++++++++++------
 src/net/dnsclient_unix_test.go |  4 ++--
 src/net/lookup_unix.go         |  4 ++--
 src/net/netgo_unix_test.go     |  2 +-
 4 files changed, 17 insertions(+), 11 deletions(-)

diff --git a/src/net/dnsclient_unix.go b/src/net/dnsclient_unix.go
index 86f64335ea..50e9bb0f20 100644
--- a/src/net/dnsclient_unix.go
+++ b/src/net/dnsclient_unix.go
@@ -532,7 +532,7 @@ func (r *Resolver) goLookupHostOrder(ctx context.Context, name string, order hos
 			return
 		}
 	}
-	ips, _, err := r.goLookupIPCNAMEOrder(ctx, name, order)
+	ips, _, err := r.goLookupIPCNAMEOrder(ctx, "ip", name, order)
 	if err != nil {
 		return
 	}
@@ -558,13 +558,13 @@ func goLookupIPFiles(name string) (addrs []IPAddr) {
 
 // goLookupIP is the native Go implementation of LookupIP.
 // The libc versions are in cgo_*.go.
-func (r *Resolver) goLookupIP(ctx context.Context, host string) (addrs []IPAddr, err error) {
+func (r *Resolver) goLookupIP(ctx context.Context, network, host string) (addrs []IPAddr, err error) {
 	order := systemConf().hostLookupOrder(r, host)
-	addrs, _, err = r.goLookupIPCNAMEOrder(ctx, host, order)
+	addrs, _, err = r.goLookupIPCNAMEOrder(ctx, network, host, order)
 	return
 }
 
-func (r *Resolver) goLookupIPCNAMEOrder(ctx context.Context, name string, order hostLookupOrder) (addrs []IPAddr, cname dnsmessage.Name, err error) {
+func (r *Resolver) goLookupIPCNAMEOrder(ctx context.Context, network, name string, order hostLookupOrder) (addrs []IPAddr, cname dnsmessage.Name, err error) {
 	if order == hostLookupFilesDNS || order == hostLookupFiles {
 		addrs = goLookupIPFiles(name)
 		if len(addrs) > 0 || order == hostLookupFiles {
@@ -585,7 +585,13 @@ func (r *Resolver) goLookupIPCNAMEOrder(ctx context.Context, name string, order
 		error
 	}
 	lane := make(chan result, 1)
-	qtypes := [...]dnsmessage.Type{dnsmessage.TypeA, dnsmessage.TypeAAAA}
+	qtypes := []dnsmessage.Type{dnsmessage.TypeA, dnsmessage.TypeAAAA}
+	switch ipVersion(network) {
+	case '4':
+		qtypes = []dnsmessage.Type{dnsmessage.TypeA}
+	case '6':
+		qtypes = []dnsmessage.Type{dnsmessage.TypeAAAA}
+	}
 	var queryFn func(fqdn string, qtype dnsmessage.Type)
 	var responseFn func(fqdn string, qtype dnsmessage.Type) result
 	if conf.singleRequest {
@@ -730,7 +736,7 @@ func (r *Resolver) goLookupIPCNAMEOrder(ctx context.Context, name string, order
 // goLookupCNAME is the native Go (non-cgo) implementation of LookupCNAME.
 func (r *Resolver) goLookupCNAME(ctx context.Context, host string) (string, error) {
 	order := systemConf().hostLookupOrder(r, host)
-	_, cname, err := r.goLookupIPCNAMEOrder(ctx, host, order)
+	_, cname, err := r.goLookupIPCNAMEOrder(ctx, "ip", host, order)
 	return cname.String(), err
 }
 
diff --git a/src/net/dnsclient_unix_test.go b/src/net/dnsclient_unix_test.go
index b47b83af15..ec690a1c0c 100644
--- a/src/net/dnsclient_unix_test.go
+++ b/src/net/dnsclient_unix_test.go
@@ -601,14 +601,14 @@ func TestGoLookupIPOrderFallbackToFile(t *testing.T) {
 		name := fmt.Sprintf("order %v", order)
 
 		// First ensure that we get an error when contacting a non-existent host.
-		_, _, err := r.goLookupIPCNAMEOrder(context.Background(), "notarealhost", order)
+		_, _, err := r.goLookupIPCNAMEOrder(context.Background(), "ip", "notarealhost", order)
 		if err == nil {
 			t.Errorf("%s: expected error while looking up name not in hosts file", name)
 			continue
 		}
 
 		// Now check that we get an address when the name appears in the hosts file.
-		addrs, _, err := r.goLookupIPCNAMEOrder(context.Background(), "thor", order) // entry is in "testdata/hosts"
+		addrs, _, err := r.goLookupIPCNAMEOrder(context.Background(), "ip", "thor", order) // entry is in "testdata/hosts"
 		if err != nil {
 			t.Errorf("%s: expected to successfully lookup host entry", name)
 			continue
diff --git a/src/net/lookup_unix.go b/src/net/lookup_unix.go
index c09afb300f..8030e3d99e 100644
--- a/src/net/lookup_unix.go
+++ b/src/net/lookup_unix.go
@@ -90,7 +90,7 @@ func (r *Resolver) lookupHost(ctx context.Context, host string) (addrs []string,
 
 func (r *Resolver) lookupIP(ctx context.Context, network, host string) (addrs []IPAddr, err error) {
 	if r.preferGo() {
-		return r.goLookupIP(ctx, host)
+		return r.goLookupIP(ctx, network, host)
 	}
 	order := systemConf().hostLookupOrder(r, host)
 	if order == hostLookupCgo {
@@ -100,7 +100,7 @@ func (r *Resolver) lookupIP(ctx context.Context, network, host string) (addrs []
 		// cgo not available (or netgo); fall back to Go's DNS resolver
 		order = hostLookupFilesDNS
 	}
-	ips, _, err := r.goLookupIPCNAMEOrder(ctx, host, order)
+	ips, _, err := r.goLookupIPCNAMEOrder(ctx, network, host, order)
 	return ips, err
 }
 
diff --git a/src/net/netgo_unix_test.go b/src/net/netgo_unix_test.go
index 0dfd6c2cd7..5551e47de7 100644
--- a/src/net/netgo_unix_test.go
+++ b/src/net/netgo_unix_test.go
@@ -24,7 +24,7 @@ func TestGoLookupIP(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	}
-	if _, err := DefaultResolver.goLookupIP(ctx, host); err != nil {
+	if _, err := DefaultResolver.goLookupIP(ctx, "ip", host); err != nil {
 		t.Error(err)
 	}
 }
-- 
GitLab


From 9b78c68a15eb2cd8075ceeaaaca9c1e63c3a894c Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Fri, 19 Mar 2021 16:52:55 -0400
Subject: [PATCH 1199/2400] cmd/compile: remove AuxCall.results, cleanup
 ssagen/ssa.go

More cleanup to remove unnecessary parts of AuxCall.
Passed testing on arm64 (a link-register architecture)
in addition to amd64 so very likely okay.

(Gratuitously updated commit message to see if it will
correctly this time.)

Updates #40724

Change-Id: Iaece952ceb5066149a5d32aaa14b36755f26bb8e
Reviewed-on: https://go-review.googlesource.com/c/go/+/303433
Trust: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/expand_calls.go  |  6 +-
 .../compile/internal/ssa/loopreschedchecks.go |  2 +-
 src/cmd/compile/internal/ssa/op.go            | 50 +++++++--------
 src/cmd/compile/internal/ssa/rewrite.go       |  2 +-
 src/cmd/compile/internal/ssa/writebarrier.go  |  2 +-
 src/cmd/compile/internal/ssagen/ssa.go        | 63 +++++++------------
 6 files changed, 49 insertions(+), 76 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index 29a8f670b0..60eed37f1c 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -1058,14 +1058,14 @@ func expandCalls(f *Func) {
 			for j, a := range v.Args[:len(v.Args)-1] {
 				i := int64(j)
 				auxType := aux.TypeOfResult(i)
-				auxBase := b.NewValue2A(v.Pos, OpLocalAddr, types.NewPtr(auxType), aux.results[i].Name, x.sp, mem)
+				auxBase := b.NewValue2A(v.Pos, OpLocalAddr, types.NewPtr(auxType), aux.NameOfResult(i), x.sp, mem)
 				auxOffset := int64(0)
 				auxSize := aux.SizeOfResult(i)
 				aRegs := aux.RegsOfResult(int64(j))
 				if len(aRegs) == 0 && a.Op == OpDereference {
 					// Avoid a self-move, and if one is detected try to remove the already-inserted VarDef for the assignment that won't happen.
 					if dAddr, dMem := a.Args[0], a.Args[1]; dAddr.Op == OpLocalAddr && dAddr.Args[0].Op == OpSP &&
-						dAddr.Args[1] == dMem && dAddr.Aux == aux.results[i].Name {
+						dAddr.Args[1] == dMem && dAddr.Aux == aux.NameOfResult(i) {
 						if dMem.Op == OpVarDef && dMem.Aux == dAddr.Aux {
 							dMem.copyOf(dMem.MemoryArg()) // elide the VarDef
 						}
@@ -1075,7 +1075,7 @@ func expandCalls(f *Func) {
 				} else {
 					if a.Op == OpLoad && a.Args[0].Op == OpLocalAddr {
 						addr := a.Args[0] // This is a self-move. // TODO(register args) do what here for registers?
-						if addr.MemoryArg() == a.MemoryArg() && addr.Aux == aux.results[i].Name {
+						if addr.MemoryArg() == a.MemoryArg() && addr.Aux == aux.NameOfResult(i) {
 							continue
 						}
 					}
diff --git a/src/cmd/compile/internal/ssa/loopreschedchecks.go b/src/cmd/compile/internal/ssa/loopreschedchecks.go
index 2af6e8472c..738c62607a 100644
--- a/src/cmd/compile/internal/ssa/loopreschedchecks.go
+++ b/src/cmd/compile/internal/ssa/loopreschedchecks.go
@@ -247,7 +247,7 @@ func insertLoopReschedChecks(f *Func) {
 		//    goto header
 		resched := f.fe.Syslook("goschedguarded")
 		// TODO(register args) -- will need more details
-		mem1 := sched.NewValue1A(bb.Pos, OpStaticCall, types.TypeMem, StaticAuxCall(resched, nil, nil), mem0)
+		mem1 := sched.NewValue1A(bb.Pos, OpStaticCall, types.TypeMem, StaticAuxCall(resched, nil), mem0)
 		sched.AddEdgeTo(h)
 		headerMemPhi.AddArg(mem1)
 
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index 9e7e169137..e4721a1ba8 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -110,11 +110,9 @@ func (a *AuxNameOffset) String() string {
 }
 
 type AuxCall struct {
-	// TODO(register args) this information is largely redundant with ../abi information, needs cleanup once new ABI is in place.
 	Fn      *obj.LSym
-	results []Param
-	reg     *regInfo                // regInfo for this call // TODO for now nil means ignore
-	abiInfo *abi.ABIParamResultInfo // TODO remove fields above redundant with this information.
+	reg     *regInfo // regInfo for this call
+	abiInfo *abi.ABIParamResultInfo
 }
 
 // Reg returns the regInfo for a given call, combining the derived in/out register masks
@@ -229,6 +227,15 @@ func (a *AuxCall) RegsOfArg(which int64) []abi.RegIndex {
 	return a.abiInfo.InParam(int(which)).Registers
 }
 
+// NameOfResult returns the type of result which (indexed 0, 1, etc).
+func (a *AuxCall) NameOfResult(which int64) *ir.Name {
+	name := a.abiInfo.OutParam(int(which)).Name
+	if name == nil {
+		return nil
+	}
+	return name.(*ir.Name)
+}
+
 // TypeOfResult returns the type of result which (indexed 0, 1, etc).
 func (a *AuxCall) TypeOfResult(which int64) *types.Type {
 	return a.abiInfo.OutParam(int(which)).Type
@@ -272,10 +279,7 @@ func (a *AuxCall) NArgs() int64 {
 	return int64(len(a.abiInfo.InParams()))
 }
 
-// String returns
-// "AuxCall{<fn>(<args>)}"             if len(results) == 0;
-// "AuxCall{<fn>(<args>)<results[0]>}" if len(results) == 1;
-// "AuxCall{<fn>(<args>)(<results>)}"  otherwise.
+// String returns "AuxCall{<fn>}"
 func (a *AuxCall) String() string {
 	var fn string
 	if a.Fn == nil {
@@ -283,19 +287,7 @@ func (a *AuxCall) String() string {
 	} else {
 		fn = fmt.Sprintf("AuxCall{%v", a.Fn)
 	}
-
-	if len(a.results) > 0 { // usual is zero or one; only some RT calls have more than one.
-		if len(a.results) == 1 {
-			fn += fmt.Sprintf("[%v,%v]", a.results[0].Type, a.results[0].Offset)
-		} else {
-			s := "("
-			for _, result := range a.results {
-				fn += fmt.Sprintf("%s[%v,%v]", s, result.Type, result.Offset)
-				s = ","
-			}
-			fn += ")"
-		}
-	}
+	// TODO how much of the ABI should be printed?
 
 	return fn + "}"
 }
@@ -311,7 +303,7 @@ func ACParamsToTypes(ps []Param) (ts []*types.Type) {
 }
 
 // StaticAuxCall returns an AuxCall for a static call.
-func StaticAuxCall(sym *obj.LSym, results []Param, paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
+func StaticAuxCall(sym *obj.LSym, paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
 	if paramResultInfo == nil {
 		panic(fmt.Errorf("Nil paramResultInfo, sym=%v", sym))
 	}
@@ -319,37 +311,37 @@ func StaticAuxCall(sym *obj.LSym, results []Param, paramResultInfo *abi.ABIParam
 	if paramResultInfo.InRegistersUsed()+paramResultInfo.OutRegistersUsed() > 0 {
 		reg = &regInfo{}
 	}
-	return &AuxCall{Fn: sym, results: results, abiInfo: paramResultInfo, reg: reg}
+	return &AuxCall{Fn: sym, abiInfo: paramResultInfo, reg: reg}
 }
 
 // InterfaceAuxCall returns an AuxCall for an interface call.
-func InterfaceAuxCall(args []Param, results []Param, paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
+func InterfaceAuxCall(paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
 	var reg *regInfo
 	if paramResultInfo.InRegistersUsed()+paramResultInfo.OutRegistersUsed() > 0 {
 		reg = &regInfo{}
 	}
-	return &AuxCall{Fn: nil, results: results, abiInfo: paramResultInfo, reg: reg}
+	return &AuxCall{Fn: nil, abiInfo: paramResultInfo, reg: reg}
 }
 
 // ClosureAuxCall returns an AuxCall for a closure call.
-func ClosureAuxCall(args []Param, results []Param, paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
+func ClosureAuxCall(paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
 	var reg *regInfo
 	if paramResultInfo.InRegistersUsed()+paramResultInfo.OutRegistersUsed() > 0 {
 		reg = &regInfo{}
 	}
-	return &AuxCall{Fn: nil, results: results, abiInfo: paramResultInfo, reg: reg}
+	return &AuxCall{Fn: nil, abiInfo: paramResultInfo, reg: reg}
 }
 
 func (*AuxCall) CanBeAnSSAAux() {}
 
 // OwnAuxCall returns a function's own AuxCall
-func OwnAuxCall(fn *obj.LSym, args []Param, results []Param, paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
+func OwnAuxCall(fn *obj.LSym, paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
 	// TODO if this remains identical to ClosureAuxCall above after new ABI is done, should deduplicate.
 	var reg *regInfo
 	if paramResultInfo.InRegistersUsed()+paramResultInfo.OutRegistersUsed() > 0 {
 		reg = &regInfo{}
 	}
-	return &AuxCall{Fn: fn, results: results, abiInfo: paramResultInfo, reg: reg}
+	return &AuxCall{Fn: fn, abiInfo: paramResultInfo, reg: reg}
 }
 
 const (
diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go
index 9e67c3482c..f9ad980172 100644
--- a/src/cmd/compile/internal/ssa/rewrite.go
+++ b/src/cmd/compile/internal/ssa/rewrite.go
@@ -765,7 +765,7 @@ func devirt(v *Value, aux Aux, sym Sym, offset int64) *AuxCall {
 		return nil
 	}
 	va := aux.(*AuxCall)
-	return StaticAuxCall(lsym, va.results, va.abiInfo)
+	return StaticAuxCall(lsym, va.abiInfo)
 }
 
 // de-virtualize an InterLECall
diff --git a/src/cmd/compile/internal/ssa/writebarrier.go b/src/cmd/compile/internal/ssa/writebarrier.go
index 9b956a4577..ddcafe461c 100644
--- a/src/cmd/compile/internal/ssa/writebarrier.go
+++ b/src/cmd/compile/internal/ssa/writebarrier.go
@@ -516,7 +516,7 @@ func wbcall(pos src.XPos, b *Block, fn, typ *obj.LSym, ptr, val, mem, sp, sb *Va
 	off = round(off, config.PtrSize)
 
 	// issue call
-	mem = b.NewValue1A(pos, OpStaticCall, types.TypeResultMem, StaticAuxCall(fn, nil, b.Func.ABIDefault.ABIAnalyzeTypes(nil, argTypes, nil)), mem)
+	mem = b.NewValue1A(pos, OpStaticCall, types.TypeResultMem, StaticAuxCall(fn, b.Func.ABIDefault.ABIAnalyzeTypes(nil, argTypes, nil)), mem)
 	mem.AuxInt = off - config.ctxt.FixedFrameSize()
 	return b.NewValue1I(pos, OpSelectN, types.TypeMem, 0, mem)
 }
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index f142810cf3..45952482fb 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -566,7 +566,7 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 		results[i].Reg = r
 	}
 
-	s.f.OwnAux = ssa.OwnAuxCall(fn.LSym, args, results, params)
+	s.f.OwnAux = ssa.OwnAuxCall(fn.LSym, params)
 
 	// Populate SSAable arguments.
 	for _, n := range fn.Dcl {
@@ -4783,21 +4783,20 @@ func (s *state) openDeferExit() {
 		// Generate code to call the function call of the defer, using the
 		// closure/receiver/args that were stored in argtmps at the point
 		// of the defer statement.
-		argStart := base.Ctxt.FixedFrameSize()
 		fn := r.n.X
 		stksize := fn.Type().ArgWidth()
-		var ACArgs []ssa.Param
-		var ACResults []ssa.Param
+		var ACArgs []*types.Type
+		var ACResults []*types.Type
 		var callArgs []*ssa.Value
 		if r.rcvr != nil {
 			// rcvr in case of OCALLINTER
 			v := s.load(r.rcvr.Type.Elem(), r.rcvr)
-			ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(argStart)})
+			ACArgs = append(ACArgs, types.Types[types.TUINTPTR])
 			callArgs = append(callArgs, v)
 		}
 		for j, argAddrVal := range r.argVals {
 			f := getParam(r.n, j)
-			ACArgs = append(ACArgs, ssa.Param{Type: f.Type, Offset: int32(argStart + abi.FieldOffsetOf(f))})
+			ACArgs = append(ACArgs, f.Type)
 			var a *ssa.Value
 			if !TypeOK(f.Type) {
 				a = s.newValue2(ssa.OpDereference, f.Type, argAddrVal, s.mem())
@@ -4811,10 +4810,10 @@ func (s *state) openDeferExit() {
 			v := s.load(r.closure.Type.Elem(), r.closure)
 			s.maybeNilCheckClosure(v, callDefer)
 			codeptr := s.rawLoad(types.Types[types.TUINTPTR], v)
-			aux := ssa.ClosureAuxCall(ACArgs, ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
+			aux := ssa.ClosureAuxCall(s.f.ABIDefault.ABIAnalyzeTypes(nil, ACArgs, ACResults))
 			call = s.newValue2A(ssa.OpClosureLECall, aux.LateExpansionResultType(), aux, codeptr, v)
 		} else {
-			aux := ssa.StaticAuxCall(fn.(*ir.Name).Linksym(), ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
+			aux := ssa.StaticAuxCall(fn.(*ir.Name).Linksym(), s.f.ABIDefault.ABIAnalyzeTypes(nil, ACArgs, ACResults))
 			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 		}
 		callArgs = append(callArgs, s.mem())
@@ -4861,9 +4860,9 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 	var codeptr *ssa.Value // ptr to target code (if dynamic)
 	var rcvr *ssa.Value    // receiver to set
 	fn := n.X
-	var ACArgs []ssa.Param    // AuxCall args
-	var ACResults []ssa.Param // AuxCall results
-	var callArgs []*ssa.Value // For late-expansion, the args themselves (not stored, args to the call instead).
+	var ACArgs []*types.Type    // AuxCall args
+	var ACResults []*types.Type // AuxCall results
+	var callArgs []*ssa.Value   // For late-expansion, the args themselves (not stored, args to the call instead).
 	inRegisters := false
 
 	var magicFnNameSym *types.Sym
@@ -4932,14 +4931,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 	res := n.X.Type().Results()
 	if k == callNormal {
 		for _, p := range params.OutParams() {
-			r := p.Registers
-			var o int32
-			if len(r) == 0 {
-				o = p.Offset()
-			} else {
-				o = p.SpillOffset() + int32(params.SpillAreaOffset())
-			}
-			ACResults = append(ACResults, ssa.Param{Type: p.Type, Offset: o, Reg: r})
+			ACResults = append(ACResults, p.Type)
 		}
 	}
 
@@ -4993,8 +4985,8 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		}
 
 		// Call runtime.deferprocStack with pointer to _defer record.
-		ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(base.Ctxt.FixedFrameSize())})
-		aux := ssa.StaticAuxCall(ir.Syms.DeferprocStack, ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
+		ACArgs = append(ACArgs, types.Types[types.TUINTPTR])
+		aux := ssa.StaticAuxCall(ir.Syms.DeferprocStack, s.f.ABIDefault.ABIAnalyzeTypes(nil, ACArgs, ACResults))
 		callArgs = append(callArgs, addr, s.mem())
 		call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 		call.AddArgs(callArgs...)
@@ -5009,19 +5001,16 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		// Store arguments to stack, including defer/go arguments and receiver for method calls.
 		// These are written in SP-offset order.
 		argStart := base.Ctxt.FixedFrameSize()
-		// argExtra is for combining with ABI-derived offsets; argStart is for old ABI0 code (defer, go).
-		argExtra := int32(0) // TODO(register args) untangle this mess when fully transition to abiutils, defer/go sanitized.
 		// Defer/go args.
 		if k != callNormal {
 			// Write argsize and closure (args to newproc/deferproc).
 			argsize := s.constInt32(types.Types[types.TUINT32], int32(stksize))
-			ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINT32], Offset: int32(argStart)}) // not argExtra
+			ACArgs = append(ACArgs, types.Types[types.TUINT32]) // not argExtra
 			callArgs = append(callArgs, argsize)
-			ACArgs = append(ACArgs, ssa.Param{Type: types.Types[types.TUINTPTR], Offset: int32(argStart) + int32(types.PtrSize)})
+			ACArgs = append(ACArgs, types.Types[types.TUINTPTR])
 			callArgs = append(callArgs, closure)
 			stksize += 2 * int64(types.PtrSize)
 			argStart += 2 * int64(types.PtrSize)
-			argExtra = 2 * int32(types.PtrSize)
 		}
 
 		// Set receiver (for interface calls).
@@ -5037,15 +5026,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		}
 
 		for _, p := range params.InParams() { // includes receiver for interface calls
-			r := p.Registers
-			var o int32
-			if len(r) == 0 {
-				o = p.Offset()
-			} else {
-				o = p.SpillOffset() + int32(params.SpillAreaOffset())
-			}
-			ACArg := ssa.Param{Type: p.Type, Offset: argExtra + o, Reg: r} // o from ABI includes any architecture-dependent offsets.
-			ACArgs = append(ACArgs, ACArg)
+			ACArgs = append(ACArgs, p.Type)
 		}
 		for i, n := range args {
 			callArgs = append(callArgs, s.putArg(n, t.Params().Field(i).Type))
@@ -5056,10 +5037,10 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		// call target
 		switch {
 		case k == callDefer:
-			aux := ssa.StaticAuxCall(ir.Syms.Deferproc, ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults))) // TODO paramResultInfo for DeferProc
+			aux := ssa.StaticAuxCall(ir.Syms.Deferproc, s.f.ABIDefault.ABIAnalyzeTypes(nil, ACArgs, ACResults)) // TODO paramResultInfo for DeferProc
 			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 		case k == callGo:
-			aux := ssa.StaticAuxCall(ir.Syms.Newproc, ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
+			aux := ssa.StaticAuxCall(ir.Syms.Newproc, s.f.ABIDefault.ABIAnalyzeTypes(nil, ACArgs, ACResults))
 			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux) // TODO paramResultInfo for NewProc
 		case closure != nil:
 			// rawLoad because loading the code pointer from a
@@ -5068,14 +5049,14 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			// critical that we not clobber any arguments already
 			// stored onto the stack.
 			codeptr = s.rawLoad(types.Types[types.TUINTPTR], closure)
-			aux := ssa.ClosureAuxCall(ACArgs, ACResults, callABI.ABIAnalyzeTypes(nil, ssa.ACParamsToTypes(ACArgs), ssa.ACParamsToTypes(ACResults)))
+			aux := ssa.ClosureAuxCall(callABI.ABIAnalyzeTypes(nil, ACArgs, ACResults))
 			call = s.newValue2A(ssa.OpClosureLECall, aux.LateExpansionResultType(), aux, codeptr, closure)
 		case codeptr != nil:
 			// Note that the "receiver" parameter is nil because the actual receiver is the first input parameter.
-			aux := ssa.InterfaceAuxCall(ACArgs, ACResults, params)
+			aux := ssa.InterfaceAuxCall(params)
 			call = s.newValue1A(ssa.OpInterLECall, aux.LateExpansionResultType(), aux, codeptr)
 		case callee != nil:
-			aux := ssa.StaticAuxCall(callTargetLSym(callee, s.curfn.LSym), ACResults, params)
+			aux := ssa.StaticAuxCall(callTargetLSym(callee, s.curfn.LSym), params)
 			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 		default:
 			s.Fatalf("bad call type %v %v", n.Op(), n)
@@ -5542,7 +5523,7 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
 
 	// Issue call
 	var call *ssa.Value
-	aux := ssa.StaticAuxCall(fn, ACResults, s.f.ABIDefault.ABIAnalyzeTypes(nil, callArgTypes, results))
+	aux := ssa.StaticAuxCall(fn, s.f.ABIDefault.ABIAnalyzeTypes(nil, callArgTypes, results))
 	callArgs = append(callArgs, s.mem())
 	call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 	call.AddArgs(callArgs...)
-- 
GitLab


From 05250429ae0e43041c9976a8451426d3ad907e5a Mon Sep 17 00:00:00 2001
From: "Artur M. Wolff" <artur.m.wolff@gmail.com>
Date: Sun, 21 Mar 2021 01:18:21 +0100
Subject: [PATCH 1200/2400] net/http: treat MaxBytesReader's negative limits as
 equivalent to zero limit

Current MaxBytesReader behaviour differs from its documentation. It's
not similar enough to io.LimitReader. It panics when limit (n) < -1 and
returns [-1, <nil>] when limit (n) = -1. To fix that, we treat all
negative limits as equivalent to 0.

It would be possible to make MaxBytesReader analogically identical in
behaviour to io.LimitReader, but that would require to stop
maxBytesReader's Read from reading past the limit. Read always reads one
more byte (if possible) for non-negative limits and returns a non-EOF
error. This behaviour will now apply to all limits.

Fixes #45101

Change-Id: I25d1877dbff1eb4b195c8741fe5e4a025d01ebc0
Reviewed-on: https://go-review.googlesource.com/c/go/+/303171
Reviewed-by: Damien Neil <dneil@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Trust: Damien Neil <dneil@google.com>
Trust: Dmitri Shuralyov <dmitshur@golang.org>
Run-TryBot: Damien Neil <dneil@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/net/http/request.go      |  3 ++
 src/net/http/request_test.go | 86 ++++++++++++++++++++++++++++++++++++
 2 files changed, 89 insertions(+)

diff --git a/src/net/http/request.go b/src/net/http/request.go
index aca55b1ca7..ff21f19942 100644
--- a/src/net/http/request.go
+++ b/src/net/http/request.go
@@ -1124,6 +1124,9 @@ func readRequest(b *bufio.Reader, deleteHostHeader bool) (req *Request, err erro
 // MaxBytesReader prevents clients from accidentally or maliciously
 // sending a large request and wasting server resources.
 func MaxBytesReader(w ResponseWriter, r io.ReadCloser, n int64) io.ReadCloser {
+	if n < 0 { // Treat negative limits as equivalent to 0.
+		n = 0
+	}
 	return &maxBytesReader{w: w, r: r, n: n}
 }
 
diff --git a/src/net/http/request_test.go b/src/net/http/request_test.go
index 29297b0e7b..f09c63ed7e 100644
--- a/src/net/http/request_test.go
+++ b/src/net/http/request_test.go
@@ -850,6 +850,92 @@ func TestMaxBytesReaderStickyError(t *testing.T) {
 	}
 }
 
+// Issue 45101: maxBytesReader's Read panicked when n < -1. This test
+// also ensures that Read treats negative limits as equivalent to 0.
+func TestMaxBytesReaderDifferentLimits(t *testing.T) {
+	const testStr = "1234"
+	tests := [...]struct {
+		limit   int64
+		lenP    int
+		wantN   int
+		wantErr bool
+	}{
+		0: {
+			limit:   -123,
+			lenP:    0,
+			wantN:   0,
+			wantErr: false, // Ensure we won't return an error when the limit is negative, but we don't need to read.
+		},
+		1: {
+			limit:   -100,
+			lenP:    32 * 1024,
+			wantN:   0,
+			wantErr: true,
+		},
+		2: {
+			limit:   -2,
+			lenP:    1,
+			wantN:   0,
+			wantErr: true,
+		},
+		3: {
+			limit:   -1,
+			lenP:    2,
+			wantN:   0,
+			wantErr: true,
+		},
+		4: {
+			limit:   0,
+			lenP:    3,
+			wantN:   0,
+			wantErr: true,
+		},
+		5: {
+			limit:   1,
+			lenP:    4,
+			wantN:   1,
+			wantErr: true,
+		},
+		6: {
+			limit:   2,
+			lenP:    5,
+			wantN:   2,
+			wantErr: true,
+		},
+		7: {
+			limit:   3,
+			lenP:    2,
+			wantN:   2,
+			wantErr: false,
+		},
+		8: {
+			limit:   int64(len(testStr)),
+			lenP:    len(testStr),
+			wantN:   len(testStr),
+			wantErr: false,
+		},
+		9: {
+			limit:   100,
+			lenP:    6,
+			wantN:   len(testStr),
+			wantErr: false,
+		},
+	}
+	for i, tt := range tests {
+		rc := MaxBytesReader(nil, io.NopCloser(strings.NewReader(testStr)), tt.limit)
+
+		n, err := rc.Read(make([]byte, tt.lenP))
+
+		if n != tt.wantN {
+			t.Errorf("%d. n: %d, want n: %d", i, n, tt.wantN)
+		}
+
+		if (err != nil) != tt.wantErr {
+			t.Errorf("%d. error: %v", i, err)
+		}
+	}
+}
+
 func TestWithContextDeepCopiesURL(t *testing.T) {
 	req, err := NewRequest("POST", "https://golang.org/", nil)
 	if err != nil {
-- 
GitLab


From c59b17e5a2244f7a99c440a07a1c174344da0ad8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Daniel=20Mart=C3=AD?= <mvdan@mvdan.cc>
Date: Sat, 30 Jan 2021 11:41:29 +0000
Subject: [PATCH 1201/2400] cmd/go: make -coverpkg=all skip test-only packages
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Otherwise, the added test would fail in an unnecessary way:

	go build example.com/cov/onlytest: no non-test Go files ...

The test script is mimicking other cover_pkgall_*.txt scripts, so it
similarly tests both GOPATH and module modes.

Fixes #27333.

Change-Id: Ie60be569b31d49b173a78556c0669a87ada6799e
Reviewed-on: https://go-review.googlesource.com/c/go/+/288292
Trust: Daniel Martí <mvdan@mvdan.cc>
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/load/test.go              |  8 ++--
 src/cmd/go/internal/test/test.go              |  6 +++
 .../testdata/script/cover_pkgall_imports.txt  | 48 +++++++++++++++++++
 3 files changed, 59 insertions(+), 3 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/cover_pkgall_imports.txt

diff --git a/src/cmd/go/internal/load/test.go b/src/cmd/go/internal/load/test.go
index eb8aef3ee2..374a2f9a4f 100644
--- a/src/cmd/go/internal/load/test.go
+++ b/src/cmd/go/internal/load/test.go
@@ -290,10 +290,12 @@ func TestPackagesAndErrors(ctx context.Context, p *Package, cover *TestCover) (p
 			seen[p1] = true
 		}
 		for _, p1 := range cover.Pkgs {
-			if !seen[p1] {
-				seen[p1] = true
-				pmain.Internal.Imports = append(pmain.Internal.Imports, p1)
+			if seen[p1] {
+				// Don't add duplicate imports.
+				continue
 			}
+			seen[p1] = true
+			pmain.Internal.Imports = append(pmain.Internal.Imports, p1)
 		}
 	}
 
diff --git a/src/cmd/go/internal/test/test.go b/src/cmd/go/internal/test/test.go
index ea9dfbe4e8..230ea2d318 100644
--- a/src/cmd/go/internal/test/test.go
+++ b/src/cmd/go/internal/test/test.go
@@ -716,6 +716,12 @@ func runTest(ctx context.Context, cmd *base.Command, args []string) {
 				}
 			}
 
+			// A package which only has test files can't be imported
+			// as a dependency, nor can it be instrumented for coverage.
+			if len(p.GoFiles)+len(p.CgoFiles) == 0 {
+				continue
+			}
+
 			// Silently ignore attempts to run coverage on
 			// sync/atomic when using atomic coverage mode.
 			// Atomic coverage mode uses sync/atomic, so
diff --git a/src/cmd/go/testdata/script/cover_pkgall_imports.txt b/src/cmd/go/testdata/script/cover_pkgall_imports.txt
new file mode 100644
index 0000000000..4e51726b29
--- /dev/null
+++ b/src/cmd/go/testdata/script/cover_pkgall_imports.txt
@@ -0,0 +1,48 @@
+# This test checks that -coverpkg=all can be used
+# when the package pattern includes packages
+# which only have tests.
+# Verifies golang.org/issue/27333, golang.org/issue/43242.
+
+[short] skip
+cd $GOPATH/src/example.com/cov
+
+env GO111MODULE=on
+go test -coverpkg=all ./...
+
+env GO111MODULE=off
+go test -coverpkg=all ./...
+
+-- $GOPATH/src/example.com/cov/go.mod --
+module example.com/cov
+
+-- $GOPATH/src/example.com/cov/notest/notest.go --
+package notest
+
+func Foo() {}
+
+-- $GOPATH/src/example.com/cov/onlytest/onlytest_test.go --
+package onlytest_test
+
+import (
+	"testing"
+
+	"example.com/cov/notest"
+)
+
+func TestFoo(t *testing.T) {
+	notest.Foo()
+}
+
+-- $GOPATH/src/example.com/cov/withtest/withtest.go --
+package withtest
+
+func Bar() {}
+
+-- $GOPATH/src/example.com/cov/withtest/withtest_test.go --
+package withtest
+
+import "testing"
+
+func TestBar(t *testing.T) {
+	Bar()
+}
-- 
GitLab


From 2887ef499a0e01a3b6fe92bf874843f9f2d05167 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Tue, 26 Jan 2021 08:24:00 -0500
Subject: [PATCH 1202/2400] cmd/compile/internal/test: update abi tests for
 recent spec changes

The internal ABI spec was recently updated to include specific
language covering "past-the-end" pointers and structs containing
trailing zero-sized fields. Add a unit test that makes sure we do the
right thing in this case. Fix a couple comments in other unit tests.

Change-Id: I18d373d11e122aec74b316837843887272676c63
Reviewed-on: https://go-review.googlesource.com/c/go/+/303809
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
---
 .../compile/internal/test/abiutils_test.go    | 76 +++++++++++++++++--
 1 file changed, 71 insertions(+), 5 deletions(-)

diff --git a/src/cmd/compile/internal/test/abiutils_test.go b/src/cmd/compile/internal/test/abiutils_test.go
index f8d0af8d7a..daff99a799 100644
--- a/src/cmd/compile/internal/test/abiutils_test.go
+++ b/src/cmd/compile/internal/test/abiutils_test.go
@@ -55,7 +55,14 @@ func TestABIUtilsBasic1(t *testing.T) {
 }
 
 func TestABIUtilsBasic2(t *testing.T) {
-	// func(x int32, y float64) (int32, float64, float64)
+	// func(p1 int8, p2 int16, p3 int32, p4 int64,
+	//      p5 float32, p6 float32, p7 float64, p8 float64,
+	//      p9 int8, p10 int16, p11 int32, p12 int64,
+	//      p13 float32, p14 float32, p15 float64, p16 float64,
+	//      p17 complex128, p18 complex128, p19 complex12, p20 complex128,
+	//      p21 complex64, p22 int8, p23 in16, p24 int32, p25 int64,
+	//      p26 int8, p27 in16, p28 int32, p29 int64)
+	//        (r1 int32, r2 float64, r3 float64) {
 	i8 := types.Types[types.TINT8]
 	i16 := types.Types[types.TINT16]
 	i32 := types.Types[types.TINT32]
@@ -114,6 +121,8 @@ func TestABIUtilsBasic2(t *testing.T) {
 }
 
 func TestABIUtilsArrays(t *testing.T) {
+	// func(p1 [1]int32, p2 [0]int32, p3 [1][1]int32, p4 [2]int32)
+	//         (r1 [2]int32, r2 [1]int32, r3 [0]int32, r4 [1][1]int32) {
 	i32 := types.Types[types.TINT32]
 	ae := types.NewArray(i32, 0)
 	a1 := types.NewArray(i32, 1)
@@ -138,6 +147,9 @@ func TestABIUtilsArrays(t *testing.T) {
 }
 
 func TestABIUtilsStruct1(t *testing.T) {
+	// type s struct { f1 int8; f2 int8; f3 struct {}; f4 int8; f5 int16) }
+	// func(p1 int6, p2 s, p3 int64)
+	//   (r1 s, r2 int8, r3 int32) {
 	i8 := types.Types[types.TINT8]
 	i16 := types.Types[types.TINT16]
 	i32 := types.Types[types.TINT32]
@@ -160,6 +172,10 @@ func TestABIUtilsStruct1(t *testing.T) {
 }
 
 func TestABIUtilsStruct2(t *testing.T) {
+	// type s struct { f1 int64; f2 struct { } }
+	// type fs struct { f1 float64; f2 s; f3 struct { } }
+	// func(p1 s, p2 s, p3 fs)
+	//    (r1 fs, r2 fs)
 	f64 := types.Types[types.TFLOAT64]
 	i64 := types.Types[types.TINT64]
 	s := mkstruct([]*types.Type{i64, mkstruct([]*types.Type{})})
@@ -179,7 +195,53 @@ func TestABIUtilsStruct2(t *testing.T) {
 	abitest(t, ft, exp)
 }
 
+// TestABIUtilsEmptyFieldAtEndOfStruct is testing to make sure
+// the abi code is doing the right thing for struct types that have
+// a trailing zero-sized field (where the we need to add padding).
+func TestABIUtilsEmptyFieldAtEndOfStruct(t *testing.T) {
+	// type s struct { f1 [2]int64; f2 struct { } }
+	// type s2 struct { f1 [3]int16; f2 struct { } }
+	// type fs struct { f1 float64; f s; f3 struct { } }
+	// func(p1 s, p2 s, p3 fs)  (r1 fs, r2 fs)
+	f64 := types.Types[types.TFLOAT64]
+	i64 := types.Types[types.TINT64]
+	i16 := types.Types[types.TINT16]
+	tb := types.Types[types.TBOOL]
+	ab2 := types.NewArray(tb, 2)
+	a2 := types.NewArray(i64, 2)
+	a3 := types.NewArray(i16, 3)
+	s := mkstruct([]*types.Type{a2, mkstruct([]*types.Type{})})
+	s2 := mkstruct([]*types.Type{a3, mkstruct([]*types.Type{})})
+	fs := mkstruct([]*types.Type{f64, s, mkstruct([]*types.Type{})})
+	ft := mkFuncType(nil, []*types.Type{s, ab2, s2, fs, fs},
+		[]*types.Type{fs, ab2, fs})
+
+	exp := makeExpectedDump(`
+        IN 0: R{ } offset: 0 typ: struct { [2]int64; struct {} }
+        IN 1: R{ } offset: 24 typ: [2]bool
+        IN 2: R{ } offset: 26 typ: struct { [3]int16; struct {} }
+        IN 3: R{ } offset: 40 typ: struct { float64; struct { [2]int64; struct {} }; struct {} }
+        IN 4: R{ } offset: 80 typ: struct { float64; struct { [2]int64; struct {} }; struct {} }
+        OUT 0: R{ } offset: 120 typ: struct { float64; struct { [2]int64; struct {} }; struct {} }
+        OUT 1: R{ } offset: 160 typ: [2]bool
+        OUT 2: R{ } offset: 168 typ: struct { float64; struct { [2]int64; struct {} }; struct {} }
+        offsetToSpillArea: 208 spillAreaSize: 0
+`)
+
+	abitest(t, ft, exp)
+
+	// Check to make sure that NumParamRegs yields 2 and not 3
+	// for struct "s" (e.g. that it handles the padding properly).
+	nps := configAMD64.NumParamRegs(s)
+	if nps != 2 {
+		t.Errorf("NumParams(%v) returned %d expected %d\n",
+			s, nps, 2)
+	}
+}
+
 func TestABIUtilsSliceString(t *testing.T) {
+	// func(p1 []int32, p2 int8, p3 []int32, p4 int8, p5 string,
+	//      p6 int64, p6 []intr32) (r1 string, r2 int64, r3 string, r4 []int32)
 	i32 := types.Types[types.TINT32]
 	sli32 := types.NewSlice(i32)
 	str := types.New(types.TSTRING)
@@ -208,10 +270,12 @@ func TestABIUtilsSliceString(t *testing.T) {
 }
 
 func TestABIUtilsMethod(t *testing.T) {
+	// type s1 struct { f1 int16; f2 int16; f3 int16 }
+	// func(p1 *s1, p2 [7]*s1, p3 float64, p4 int16, p5 int16, p6 int16)
+	//   (r1 [7]*s1, r2 float64, r3 int64)
 	i16 := types.Types[types.TINT16]
 	i64 := types.Types[types.TINT64]
 	f64 := types.Types[types.TFLOAT64]
-
 	s1 := mkstruct([]*types.Type{i16, i16, i16})
 	ps1 := types.NewPtr(s1)
 	a7 := types.NewArray(ps1, 7)
@@ -236,18 +300,20 @@ func TestABIUtilsMethod(t *testing.T) {
 }
 
 func TestABIUtilsInterfaces(t *testing.T) {
+	// type s1 { f1 int16; f2 int16; f3 bool)
+	// type nei interface { ...() string }
+	// func(p1 s1, p2 interface{}, p3 interface{}, p4 nei,
+	//      p5 *interface{}, p6 nei, p7 int64)
+	//    (r1 interface{}, r2 nei, r3 bool)
 	ei := types.Types[types.TINTER] // interface{}
 	pei := types.NewPtr(ei)         // *interface{}
 	fldt := mkFuncType(types.FakeRecvType(), []*types.Type{},
 		[]*types.Type{types.UntypedString})
 	field := types.NewField(src.NoXPos, nil, fldt)
-	// interface{ ...() string }
 	nei := types.NewInterface(types.LocalPkg, []*types.Field{field})
-
 	i16 := types.Types[types.TINT16]
 	tb := types.Types[types.TBOOL]
 	s1 := mkstruct([]*types.Type{i16, i16, tb})
-
 	ft := mkFuncType(nil, []*types.Type{s1, ei, ei, nei, pei, nei, i16},
 		[]*types.Type{ei, nei, pei})
 
-- 
GitLab


From dc289d3dcb59f80b9e23c7e8f237628359d21d92 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Sim=C3=A3o=20Gomes=20Viana?= <simaogmv@gmail.com>
Date: Tue, 23 Mar 2021 21:50:41 +0000
Subject: [PATCH 1203/2400] io: fix spelling in documentation for io.Discard

In the process of refactoring ioutil.Discard to io.Discard in
CL 263141 "an" should have been changed to "a" but was likely
missed in the process.

This commit corrects the spelling of the documentation.

Change-Id: I0609c45878291f8f01560efc3f3e6fba191e095b
GitHub-Last-Rev: e3257ca272dff42ed7d07b6e6a5fc49493772653
GitHub-Pull-Request: golang/go#45190
Reviewed-on: https://go-review.googlesource.com/c/go/+/304209
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Griesemer <gri@golang.org>
---
 src/io/io.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/io/io.go b/src/io/io.go
index ffd3cedc25..2724321ed9 100644
--- a/src/io/io.go
+++ b/src/io/io.go
@@ -566,7 +566,7 @@ func (t *teeReader) Read(p []byte) (n int, err error) {
 	return
 }
 
-// Discard is an Writer on which all Write calls succeed
+// Discard is a Writer on which all Write calls succeed
 // without doing anything.
 var Discard Writer = discard{}
 
-- 
GitLab


From 4e27aa6cd2c3f579328e3b490780664ade34053d Mon Sep 17 00:00:00 2001
From: Shuhei Takahashi <nya@chromium.org>
Date: Mon, 22 Mar 2021 00:22:23 +0900
Subject: [PATCH 1204/2400] os/exec: simplify TestContextCancel

TestContextCancel is a test that ensures a process is killed soon after
canceling the context, even if Wait is not called (#16222). The test
checks whether the process exited without calling Wait by writing some
data to its stdin.

Currently the test involves two goroutines writing to stdin and reading
from stdout. However the reading goroutine is not very necessary to
detect the process exit.

This patch simplifies the test by connecting the process stdout to
/dev/null.

For #42061

Change-Id: I0447a1c024ee5abb050c627ec3766b731b02181a
Reviewed-on: https://go-review.googlesource.com/c/go/+/303352
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/os/exec/exec_test.go | 38 +++++---------------------------------
 1 file changed, 5 insertions(+), 33 deletions(-)

diff --git a/src/os/exec/exec_test.go b/src/os/exec/exec_test.go
index 05cf807583..c1d2a8f49c 100644
--- a/src/os/exec/exec_test.go
+++ b/src/os/exec/exec_test.go
@@ -1052,41 +1052,18 @@ func TestContextCancel(t *testing.T) {
 	defer cancel()
 	c := helperCommandContext(t, ctx, "cat")
 
-	r, w, err := os.Pipe()
-	if err != nil {
-		t.Fatal(err)
-	}
-	c.Stdin = r
-
-	stdout, err := c.StdoutPipe()
+	stdin, err := c.StdinPipe()
 	if err != nil {
 		t.Fatal(err)
 	}
-	readDone := make(chan struct{})
-	go func() {
-		defer close(readDone)
-		var a [1024]byte
-		for {
-			n, err := stdout.Read(a[:])
-			if err != nil {
-				if err != io.EOF {
-					t.Errorf("unexpected read error: %v", err)
-				}
-				return
-			}
-			t.Logf("%s", a[:n])
-		}
-	}()
+	defer stdin.Close()
 
 	if err := c.Start(); err != nil {
 		t.Fatal(err)
 	}
 
-	if err := r.Close(); err != nil {
-		t.Fatal(err)
-	}
-
-	if _, err := io.WriteString(w, "echo"); err != nil {
+	// At this point the process is alive. Ensure it by sending data to stdin.
+	if _, err := io.WriteString(stdin, "echo"); err != nil {
 		t.Fatal(err)
 	}
 
@@ -1096,7 +1073,7 @@ func TestContextCancel(t *testing.T) {
 	// should now fail.  Give the process a little while to die.
 	start := time.Now()
 	for {
-		if _, err := io.WriteString(w, "echo"); err != nil {
+		if _, err := io.WriteString(stdin, "echo"); err != nil {
 			break
 		}
 		if time.Since(start) > time.Minute {
@@ -1105,11 +1082,6 @@ func TestContextCancel(t *testing.T) {
 		time.Sleep(time.Millisecond)
 	}
 
-	if err := w.Close(); err != nil {
-		t.Errorf("error closing write end of pipe: %v", err)
-	}
-	<-readDone
-
 	if err := c.Wait(); err == nil {
 		t.Error("program unexpectedly exited successfully")
 	} else {
-- 
GitLab


From 769d4b68ef72125de068a060220c3dbd9ba65c43 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Wed, 24 Feb 2021 12:55:52 -0500
Subject: [PATCH 1205/2400] cmd/compile: wrap/desugar defer calls for register
 abi

Adds code to the compiler's "order" phase to rewrite go and defer
statements to always be argument-less. E.g.

 defer f(x,y)       =>     x1, y1 := x, y
			   defer func() { f(x1, y1) }

This transformation is not beneficial on its own, but it helps
simplify runtime defer handling for the new register ABI (when
invoking deferred functions on the panic path, the runtime doesn't
need to manage the complexity of determining which args to pass in
register vs memory).

This feature is currently enabled by default if GOEXPERIMENT=regabi or
GOEXPERIMENT=regabidefer is in effect.

Included in this CL are some workarounds in the runtime to insure that
"go" statement targets in the runtime are argument-less already (since
wrapping them can potentially introduce heap-allocated closures, which
are currently not allowed). The expectation is that these workarounds
will be temporary, and can go away once we either A) change the rules
about heap-allocated closures, or B) implement some other scheme for
handling go statements.

Change-Id: I01060d79a6b140c6f0838d6e6813f807ccdca319
Reviewed-on: https://go-review.googlesource.com/c/go/+/298669
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/ir/expr.go      |  13 +-
 src/cmd/compile/internal/walk/closure.go |   8 +
 src/cmd/compile/internal/walk/order.go   | 248 +++++++++++++++++++++++
 src/cmd/compile/internal/walk/stmt.go    |  26 ++-
 src/cmd/internal/objabi/util.go          |   2 +-
 src/runtime/export_test.go               |  20 +-
 src/runtime/mgc.go                       |  15 +-
 src/runtime/mgcscavenge.go               |   4 +-
 src/runtime/mgcsweep.go                  |   4 +-
 src/runtime/race/output_test.go          |  32 +--
 test/live.go                             |   3 +-
 test/run.go                              |  10 +
 12 files changed, 344 insertions(+), 41 deletions(-)

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 2d62b22d8c..49b9fa8e54 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -157,12 +157,13 @@ const (
 type CallExpr struct {
 	miniExpr
 	origNode
-	X         Node
-	Args      Nodes
-	KeepAlive []*Name // vars to be kept alive until call returns
-	IsDDD     bool
-	Use       CallUse
-	NoInline  bool
+	X               Node
+	Args            Nodes
+	KeepAlive       []*Name // vars to be kept alive until call returns
+	IsDDD           bool
+	Use             CallUse
+	NoInline        bool
+	PreserveClosure bool // disable directClosureCall for this call
 }
 
 func NewCallExpr(pos src.XPos, op Op, fun Node, args []Node) *CallExpr {
diff --git a/src/cmd/compile/internal/walk/closure.go b/src/cmd/compile/internal/walk/closure.go
index d7d6105816..2194e1c5b0 100644
--- a/src/cmd/compile/internal/walk/closure.go
+++ b/src/cmd/compile/internal/walk/closure.go
@@ -37,6 +37,14 @@ func directClosureCall(n *ir.CallExpr) {
 		return // leave for walkClosure to handle
 	}
 
+	// If wrapGoDefer() in the order phase has flagged this call,
+	// avoid eliminating the closure even if there is a direct call to
+	// (the closure is needed to simplify the register ABI). See
+	// wrapGoDefer for more details.
+	if n.PreserveClosure {
+		return
+	}
+
 	// We are going to insert captured variables before input args.
 	var params []*types.Field
 	var decls []*ir.Name
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index fe0b6a0eff..5a687d8e34 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -14,6 +14,7 @@ import (
 	"cmd/compile/internal/staticinit"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
+	"cmd/internal/objabi"
 	"cmd/internal/src"
 )
 
@@ -731,6 +732,9 @@ func (o *orderState) stmt(n ir.Node) {
 		t := o.markTemp()
 		o.init(n.Call)
 		o.call(n.Call)
+		if objabi.Experiment.RegabiDefer {
+			o.wrapGoDefer(n)
+		}
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
 
@@ -1435,3 +1439,247 @@ func (o *orderState) as2ok(n *ir.AssignListStmt) {
 	o.out = append(o.out, n)
 	o.stmt(typecheck.Stmt(as))
 }
+
+var wrapGoDefer_prgen int
+
+// wrapGoDefer wraps the target of a "go" or "defer" statement with a
+// new "function with no arguments" closure. Specifically, it converts
+//
+//   defer f(x, y)
+//
+// to
+//
+//   x1, y1 := x, y
+//   defer func() { f(x1, y1) }()
+//
+// This is primarily to enable a quicker bringup of defers under the
+// new register ABI; by doing this conversion, we can simplify the
+// code in the runtime that invokes defers on the panic path.
+func (o *orderState) wrapGoDefer(n *ir.GoDeferStmt) {
+	call := n.Call
+
+	var callX ir.Node      // thing being called
+	var callArgs []ir.Node // call arguments
+
+	// A helper to recreate the call within the closure.
+	var mkNewCall func(pos src.XPos, op ir.Op, fun ir.Node, args []ir.Node) ir.Node
+
+	// Defer calls come in many shapes and sizes; not all of them
+	// are ir.CallExpr's. Examine the type to see what we're dealing with.
+	switch x := call.(type) {
+	case *ir.CallExpr:
+		callX = x.X
+		callArgs = x.Args
+		mkNewCall = func(pos src.XPos, op ir.Op, fun ir.Node, args []ir.Node) ir.Node {
+			newcall := ir.NewCallExpr(pos, op, fun, args)
+			newcall.IsDDD = x.IsDDD
+			return ir.Node(newcall)
+		}
+	case *ir.UnaryExpr: // ex: OCLOSE
+		callArgs = []ir.Node{x.X}
+		mkNewCall = func(pos src.XPos, op ir.Op, fun ir.Node, args []ir.Node) ir.Node {
+			if len(args) != 1 {
+				panic("internal error, expecting single arg to close")
+			}
+			return ir.Node(ir.NewUnaryExpr(pos, op, args[0]))
+		}
+	case *ir.BinaryExpr: // ex: OCOPY
+		callArgs = []ir.Node{x.X, x.Y}
+		mkNewCall = func(pos src.XPos, op ir.Op, fun ir.Node, args []ir.Node) ir.Node {
+			if len(args) != 2 {
+				panic("internal error, expecting two args")
+			}
+			return ir.Node(ir.NewBinaryExpr(pos, op, args[0], args[1]))
+		}
+	default:
+		panic("unhandled op")
+	}
+
+	// No need to wrap if called func has no args. However in the case
+	// of "defer func() { ... }()" we need to protect against the
+	// possibility of directClosureCall rewriting things so that the
+	// call does have arguments.
+	if len(callArgs) == 0 {
+		if c, ok := call.(*ir.CallExpr); ok && callX != nil && callX.Op() == ir.OCLOSURE {
+			cloFunc := callX.(*ir.ClosureExpr).Func
+			cloFunc.SetClosureCalled(false)
+			c.PreserveClosure = true
+		}
+		return
+	}
+
+	if c, ok := call.(*ir.CallExpr); ok {
+		// To simplify things, turn f(a, b, []T{c, d, e}...) back
+		// into f(a, b, c, d, e) -- when the final call is run through the
+		// type checker below, it will rebuild the proper slice literal.
+		undoVariadic(c)
+		callX = c.X
+		callArgs = c.Args
+	}
+
+	// This is set to true if the closure we're generating escapes
+	// (needs heap allocation).
+	cloEscapes := func() bool {
+		if n.Op() == ir.OGO {
+			// For "go", assume that all closures escape (with an
+			// exception for the runtime, which doesn't permit
+			// heap-allocated closures).
+			return base.Ctxt.Pkgpath != "runtime"
+		}
+		// For defer, just use whatever result escape analysis
+		// has determined for the defer.
+		return n.Esc() != ir.EscNever
+	}()
+
+	// A helper for making a copy of an argument.
+	mkArgCopy := func(arg ir.Node) *ir.Name {
+		argCopy := o.copyExpr(arg)
+		// The value of 128 below is meant to be consistent with code
+		// in escape analysis that picks byval/byaddr based on size.
+		argCopy.SetByval(argCopy.Type().Size() <= 128 || cloEscapes)
+		return argCopy
+	}
+
+	unsafeArgs := make([]*ir.Name, len(callArgs))
+	origArgs := callArgs
+
+	// Copy the arguments to the function into temps.
+	pos := n.Pos()
+	outerfn := ir.CurFunc
+	var newNames []*ir.Name
+	for i := range callArgs {
+		arg := callArgs[i]
+		var argname *ir.Name
+		if arg.Op() == ir.OCONVNOP && arg.Type().IsUintptr() && arg.(*ir.ConvExpr).X.Type().IsUnsafePtr() {
+			// No need for copy here; orderState.call() above has already inserted one.
+			arg = arg.(*ir.ConvExpr).X
+			argname = arg.(*ir.Name)
+			unsafeArgs[i] = argname
+		} else {
+			argname = mkArgCopy(arg)
+		}
+		newNames = append(newNames, argname)
+	}
+
+	// Deal with cases where the function expression (what we're
+	// calling) is not a simple function symbol.
+	var fnExpr *ir.Name
+	var methSelectorExpr *ir.SelectorExpr
+	if callX != nil {
+		switch {
+		case callX.Op() == ir.ODOTMETH || callX.Op() == ir.ODOTINTER:
+			// Handle defer of a method call, e.g. "defer v.MyMethod(x, y)"
+			n := callX.(*ir.SelectorExpr)
+			n.X = mkArgCopy(n.X)
+			methSelectorExpr = n
+		case !(callX.Op() == ir.ONAME && callX.(*ir.Name).Class == ir.PFUNC):
+			// Deal with "defer returnsafunc()(x, y)" (for
+			// example) by copying the callee expression.
+			fnExpr = mkArgCopy(callX)
+			if callX.Op() == ir.OCLOSURE {
+				// For "defer func(...)", in addition to copying the
+				// closure into a temp, mark it as no longer directly
+				// called.
+				callX.(*ir.ClosureExpr).Func.SetClosureCalled(false)
+			}
+		}
+	}
+
+	// Create a new no-argument function that we'll hand off to defer.
+	var noFuncArgs []*ir.Field
+	noargst := ir.NewFuncType(base.Pos, nil, noFuncArgs, nil)
+	wrapGoDefer_prgen++
+	wrapname := fmt.Sprintf("%v·dwrap·%d", outerfn, wrapGoDefer_prgen)
+	sym := types.LocalPkg.Lookup(wrapname)
+	fn := typecheck.DeclFunc(sym, noargst)
+	fn.SetIsHiddenClosure(true)
+	fn.SetWrapper(true)
+
+	// helper for capturing reference to a var declared in an outer scope.
+	capName := func(pos src.XPos, fn *ir.Func, n *ir.Name) *ir.Name {
+		t := n.Type()
+		cv := ir.CaptureName(pos, fn, n)
+		cv.SetType(t)
+		return typecheck.Expr(cv).(*ir.Name)
+	}
+
+	// Call args (x1, y1) need to be captured as part of the newly
+	// created closure.
+	newCallArgs := []ir.Node{}
+	for i := range newNames {
+		var arg ir.Node
+		arg = capName(callArgs[i].Pos(), fn, newNames[i])
+		if unsafeArgs[i] != nil {
+			arg = ir.NewConvExpr(arg.Pos(), origArgs[i].Op(), origArgs[i].Type(), arg)
+		}
+		newCallArgs = append(newCallArgs, arg)
+	}
+	// Also capture the function or method expression (if needed) into
+	// the closure.
+	if fnExpr != nil {
+		callX = capName(callX.Pos(), fn, fnExpr)
+	}
+	if methSelectorExpr != nil {
+		methSelectorExpr.X = capName(callX.Pos(), fn, methSelectorExpr.X.(*ir.Name))
+	}
+	ir.FinishCaptureNames(pos, outerfn, fn)
+
+	// This flags a builtin as opposed to a regular call.
+	irregular := (call.Op() != ir.OCALLFUNC &&
+		call.Op() != ir.OCALLMETH &&
+		call.Op() != ir.OCALLINTER)
+
+	// Construct new function body:  f(x1, y1)
+	op := ir.OCALL
+	if irregular {
+		op = call.Op()
+	}
+	newcall := mkNewCall(call.Pos(), op, callX, newCallArgs)
+
+	// Type-check the result.
+	if !irregular {
+		typecheck.Call(newcall.(*ir.CallExpr))
+	} else {
+		typecheck.Stmt(newcall)
+	}
+
+	// Finalize body, register function on the main decls list.
+	fn.Body = []ir.Node{newcall}
+	typecheck.FinishFuncBody()
+	typecheck.Func(fn)
+	typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
+
+	// Create closure expr
+	clo := ir.NewClosureExpr(pos, fn)
+	fn.OClosure = clo
+	clo.SetType(fn.Type())
+
+	// Set escape properties for closure.
+	if n.Op() == ir.OGO {
+		// For "go", assume that the closure is going to escape
+		// (with an exception for the runtime, which doesn't
+		// permit heap-allocated closures).
+		if base.Ctxt.Pkgpath != "runtime" {
+			clo.SetEsc(ir.EscHeap)
+		}
+	} else {
+		// For defer, just use whatever result escape analysis
+		// has determined for the defer.
+		if n.Esc() == ir.EscNever {
+			clo.SetTransient(true)
+			clo.SetEsc(ir.EscNone)
+		}
+	}
+
+	// Create new top level call to closure over argless function.
+	topcall := ir.NewCallExpr(pos, ir.OCALL, clo, []ir.Node{})
+	typecheck.Call(topcall)
+
+	// Tag the call to insure that directClosureCall doesn't undo our work.
+	topcall.PreserveClosure = true
+
+	fn.SetClosureCalled(false)
+
+	// Finally, point the defer statement at the newly generated call.
+	n.Call = topcall
+}
diff --git a/src/cmd/compile/internal/walk/stmt.go b/src/cmd/compile/internal/walk/stmt.go
index 836ac6b6ab..773620bea6 100644
--- a/src/cmd/compile/internal/walk/stmt.go
+++ b/src/cmd/compile/internal/walk/stmt.go
@@ -263,12 +263,7 @@ func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 
 	// Turn f(a, b, []T{c, d, e}...) back into f(a, b, c, d, e).
 	if !isBuiltinCall && n.IsDDD {
-		last := len(n.Args) - 1
-		if va := n.Args[last]; va.Op() == ir.OSLICELIT {
-			va := va.(*ir.CompLitExpr)
-			n.Args = append(n.Args[:last], va.List...)
-			n.IsDDD = false
-		}
+		undoVariadic(n)
 	}
 
 	wrapArgs := n.Args
@@ -325,3 +320,22 @@ func wrapCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	call = ir.NewCallExpr(base.Pos, ir.OCALL, fn.Nname, wrapArgs)
 	return walkExpr(typecheck.Stmt(call), init)
 }
+
+// undoVariadic turns a call to a variadic function of the form
+//
+//      f(a, b, []T{c, d, e}...)
+//
+// back into
+//
+//      f(a, b, c, d, e)
+//
+func undoVariadic(call *ir.CallExpr) {
+	if call.IsDDD {
+		last := len(call.Args) - 1
+		if va := call.Args[last]; va.Op() == ir.OSLICELIT {
+			va := va.(*ir.CompLitExpr)
+			call.Args = append(call.Args[:last], va.List...)
+			call.IsDDD = false
+		}
+	}
+}
diff --git a/src/cmd/internal/objabi/util.go b/src/cmd/internal/objabi/util.go
index 2a33f0d84a..e066311cd1 100644
--- a/src/cmd/internal/objabi/util.go
+++ b/src/cmd/internal/objabi/util.go
@@ -158,8 +158,8 @@ func init() {
 		Experiment.RegabiWrappers = true
 		Experiment.RegabiG = true
 		Experiment.RegabiReflect = true
+		Experiment.RegabiDefer = true
 		// Not ready yet:
-		//Experiment.RegabiDefer = true
 		//Experiment.RegabiArgs = true
 	}
 	// Check regabi dependencies.
diff --git a/src/runtime/export_test.go b/src/runtime/export_test.go
index c03cf136f2..1650541fda 100644
--- a/src/runtime/export_test.go
+++ b/src/runtime/export_test.go
@@ -147,28 +147,40 @@ func RunSchedLocalQueueStealTest() {
 	}
 }
 
+// Temporary to enable register ABI bringup.
+// TODO(register args): convert back to local variables in RunSchedLocalQueueEmptyTest that
+// get passed to the "go" stmts there.
+var RunSchedLocalQueueEmptyState struct {
+	done  chan bool
+	ready *uint32
+	p     *p
+}
+
 func RunSchedLocalQueueEmptyTest(iters int) {
 	// Test that runq is not spuriously reported as empty.
 	// Runq emptiness affects scheduling decisions and spurious emptiness
 	// can lead to underutilization (both runnable Gs and idle Ps coexist
 	// for arbitrary long time).
 	done := make(chan bool, 1)
+	RunSchedLocalQueueEmptyState.done = done
 	p := new(p)
+	RunSchedLocalQueueEmptyState.p = p
 	gs := make([]g, 2)
 	ready := new(uint32)
+	RunSchedLocalQueueEmptyState.ready = ready
 	for i := 0; i < iters; i++ {
 		*ready = 0
 		next0 := (i & 1) == 0
 		next1 := (i & 2) == 0
 		runqput(p, &gs[0], next0)
 		go func() {
-			for atomic.Xadd(ready, 1); atomic.Load(ready) != 2; {
+			for atomic.Xadd(RunSchedLocalQueueEmptyState.ready, 1); atomic.Load(RunSchedLocalQueueEmptyState.ready) != 2; {
 			}
-			if runqempty(p) {
-				println("next:", next0, next1)
+			if runqempty(RunSchedLocalQueueEmptyState.p) {
+				//println("next:", next0, next1)
 				throw("queue is empty")
 			}
-			done <- true
+			RunSchedLocalQueueEmptyState.done <- true
 		}()
 		for atomic.Xadd(ready, 1); atomic.Load(ready) != 2; {
 		}
diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index 6927e90daa..4b99d755c4 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -207,17 +207,22 @@ func readgogc() int32 {
 	return 100
 }
 
+// Temporary in order to enable register ABI work.
+// TODO(register args): convert back to local chan in gcenabled, passed to "go" stmts.
+var gcenable_setup chan int
+
 // gcenable is called after the bulk of the runtime initialization,
 // just before we're about to start letting user code run.
 // It kicks off the background sweeper goroutine, the background
 // scavenger goroutine, and enables GC.
 func gcenable() {
 	// Kick off sweeping and scavenging.
-	c := make(chan int, 2)
-	go bgsweep(c)
-	go bgscavenge(c)
-	<-c
-	<-c
+	gcenable_setup = make(chan int, 2)
+	go bgsweep()
+	go bgscavenge()
+	<-gcenable_setup
+	<-gcenable_setup
+	gcenable_setup = nil
 	memstats.enablegc = true // now that runtime is initialized, GC is okay
 }
 
diff --git a/src/runtime/mgcscavenge.go b/src/runtime/mgcscavenge.go
index 46a40632bf..6632bed2b3 100644
--- a/src/runtime/mgcscavenge.go
+++ b/src/runtime/mgcscavenge.go
@@ -249,7 +249,7 @@ func scavengeSleep(ns int64) int64 {
 // The background scavenger maintains the RSS of the application below
 // the line described by the proportional scavenging statistics in
 // the mheap struct.
-func bgscavenge(c chan int) {
+func bgscavenge() {
 	scavenge.g = getg()
 
 	lockInit(&scavenge.lock, lockRankScavenge)
@@ -261,7 +261,7 @@ func bgscavenge(c chan int) {
 		wakeScavenger()
 	}
 
-	c <- 1
+	gcenable_setup <- 1
 	goparkunlock(&scavenge.lock, waitReasonGCScavengeWait, traceEvGoBlock, 1)
 
 	// Exponentially-weighted moving average of the fraction of time this
diff --git a/src/runtime/mgcsweep.go b/src/runtime/mgcsweep.go
index 76bc4246e5..f3d6c6caa4 100644
--- a/src/runtime/mgcsweep.go
+++ b/src/runtime/mgcsweep.go
@@ -153,13 +153,13 @@ func finishsweep_m() {
 	nextMarkBitArenaEpoch()
 }
 
-func bgsweep(c chan int) {
+func bgsweep() {
 	sweep.g = getg()
 
 	lockInit(&sweep.lock, lockRankSweep)
 	lock(&sweep.lock)
 	sweep.parked = true
-	c <- 1
+	gcenable_setup <- 1
 	goparkunlock(&sweep.lock, waitReasonGCSweepWait, traceEvGoBlock, 1)
 
 	for {
diff --git a/src/runtime/race/output_test.go b/src/runtime/race/output_test.go
index 4a959d9aba..2a2197ae26 100644
--- a/src/runtime/race/output_test.go
+++ b/src/runtime/race/output_test.go
@@ -106,6 +106,8 @@ var tests = []struct {
 	{"simple", "run", "", "atexit_sleep_ms=0", `
 package main
 import "time"
+var xptr *int
+var donechan chan bool
 func main() {
 	done := make(chan bool)
 	x := 0
@@ -117,32 +119,34 @@ func store(x *int, v int) {
 	*x = v
 }
 func startRacer(x *int, done chan bool) {
-	go racer(x, done)
+	xptr = x
+	donechan = done
+	go racer()
 }
-func racer(x *int, done chan bool) {
+func racer() {
 	time.Sleep(10*time.Millisecond)
-	store(x, 42)
-	done <- true
+	store(xptr, 42)
+	donechan <- true
 }
 `, []string{`==================
 WARNING: DATA RACE
 Write at 0x[0-9,a-f]+ by goroutine [0-9]:
   main\.store\(\)
-      .+/main\.go:12 \+0x[0-9,a-f]+
+      .+/main\.go:14 \+0x[0-9,a-f]+
   main\.racer\(\)
-      .+/main\.go:19 \+0x[0-9,a-f]+
+      .+/main\.go:23 \+0x[0-9,a-f]+
 
 Previous write at 0x[0-9,a-f]+ by main goroutine:
   main\.store\(\)
-      .+/main\.go:12 \+0x[0-9,a-f]+
+      .+/main\.go:14 \+0x[0-9,a-f]+
   main\.main\(\)
-      .+/main\.go:8 \+0x[0-9,a-f]+
+      .+/main\.go:10 \+0x[0-9,a-f]+
 
 Goroutine [0-9] \(running\) created at:
   main\.startRacer\(\)
-      .+/main\.go:15 \+0x[0-9,a-f]+
+      .+/main\.go:19 \+0x[0-9,a-f]+
   main\.main\(\)
-      .+/main\.go:7 \+0x[0-9,a-f]+
+      .+/main\.go:9 \+0x[0-9,a-f]+
 ==================
 Found 1 data race\(s\)
 exit status 66
@@ -239,15 +243,15 @@ func main() {
 package main
 
 var x int
-
+var c chan int
 func main() {
-	c := make(chan int)
-	go f(c)
+	c = make(chan int)
+	go f()
 	x = 1
 	<-c
 }
 
-func f(c chan int) {
+func f() {
 	g(c)
 }
 
diff --git a/test/live.go b/test/live.go
index d52ce7f007..6d1a475492 100644
--- a/test/live.go
+++ b/test/live.go
@@ -1,8 +1,9 @@
 // errorcheckwithauto -0 -l -live -wb=0 -d=ssa/insert_resched_checks/off
-// +build !ppc64,!ppc64le
+// +build !ppc64,!ppc64le,!goexperiment.regabi,!goexperiment.regabidefer
 
 // ppc64 needs a better tighten pass to make f18 pass
 // rescheduling checks need to be turned off because there are some live variables across the inserted check call
+// TODO(register args): temporarily disabled when GOEXPERIMENT=regabi due to additional temporaries live at "go" statements when regabi is in effect.
 
 // Copyright 2014 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/run.go b/test/run.go
index d999f18790..cc2fcf3518 100644
--- a/test/run.go
+++ b/test/run.go
@@ -438,6 +438,16 @@ func (ctxt *context) match(name string) bool {
 		}
 	}
 
+	exp := os.Getenv("GOEXPERIMENT")
+	if exp != "" {
+		experiments := strings.Split(exp, ",")
+		for _, e := range experiments {
+			if name == "goexperiment."+e {
+				return true
+			}
+		}
+	}
+
 	if name == ctxt.GOOS || name == ctxt.GOARCH || name == "gc" {
 		return true
 	}
-- 
GitLab


From 87a3ac5f5328ea0a6169cfc44bdb081014fcd3ec Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Tue, 23 Mar 2021 15:24:27 -0700
Subject: [PATCH 1206/2400] cmd/compile: don't let -race override explicit
 -d=checkptr=0

Change-Id: Icfa204761045b72a8ea173fd55eddf1f0e58d819
Reviewed-on: https://go-review.googlesource.com/c/go/+/304253
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/base/flag.go | 10 +++++++++-
 test/fixedbugs/bug513.go              | 20 ++++++++++++++++++++
 2 files changed, 29 insertions(+), 1 deletion(-)
 create mode 100644 test/fixedbugs/bug513.go

diff --git a/src/cmd/compile/internal/base/flag.go b/src/cmd/compile/internal/base/flag.go
index eb46ed99af..33c2c862b0 100644
--- a/src/cmd/compile/internal/base/flag.go
+++ b/src/cmd/compile/internal/base/flag.go
@@ -161,6 +161,8 @@ func ParseFlags() {
 	Flag.WB = true
 	Debug.InlFuncsWithClosures = 1
 
+	Debug.Checkptr = -1 // so we can tell whether it is set explicitly
+
 	Flag.Cfg.ImportMap = make(map[string]string)
 
 	objabi.AddVersionFlag() // -V
@@ -216,7 +218,9 @@ func ParseFlags() {
 	}
 	if Flag.Race || Flag.MSan {
 		// -race and -msan imply -d=checkptr for now.
-		Debug.Checkptr = 1
+		if Debug.Checkptr == -1 { // if not set explicitly
+			Debug.Checkptr = 1
+		}
 	}
 
 	if Flag.CompilingRuntime && Flag.N != 0 {
@@ -237,6 +241,10 @@ func ParseFlags() {
 		Debug.Libfuzzer = 0
 	}
 
+	if Debug.Checkptr == -1 { // if not set explicitly
+		Debug.Checkptr = 0
+	}
+
 	// set via a -d flag
 	Ctxt.Debugpcln = Debug.PCTab
 }
diff --git a/test/fixedbugs/bug513.go b/test/fixedbugs/bug513.go
new file mode 100644
index 0000000000..f7604f681c
--- /dev/null
+++ b/test/fixedbugs/bug513.go
@@ -0,0 +1,20 @@
+// run -race -gcflags=all=-d=checkptr=0
+// +build linux,amd64 linux,ppc64le darwin,amd64 freebsd,amd64 netbsd,amd64 windows,amd64
+
+// Copyright 2021 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.
+
+// Although -race turns on -d=checkptr, the explicit -d=checkptr=0
+// should override it.
+
+package main
+
+import "unsafe"
+
+var v1 = new([2]int16)
+var v2 *[3]int64
+
+func main() {
+	v2 = (*[3]int64)(unsafe.Pointer(uintptr(unsafe.Pointer(&(*v1)[0]))))
+}
-- 
GitLab


From 14ef2d8c0155b725226516bd2eeb804a70a95462 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Tue, 23 Mar 2021 19:55:17 -0400
Subject: [PATCH 1207/2400] cmd/compile: fix array case in types-for-register
 parameter

Corrected typo/thinko.

We should keep the test for this, but it doesn't run yet because of reflection
as far as I know (but I am not testing w/ GOEXPERIMENT).

See https://github.com/golang/go/issues/44816#issuecomment-805297295

Updates #40724
Updates #44816

Change-Id: Ia12d0d4db00a8ec7174e72de460173876bd17874
Reviewed-on: https://go-review.googlesource.com/c/go/+/304233
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/abi/abiutils.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index 8495ed7c51..549c11306a 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -168,7 +168,7 @@ func appendParamTypes(rts []*types.Type, t *types.Type) []*types.Type {
 		typ := t.Kind()
 		switch typ {
 		case types.TARRAY:
-			for i := int64(0); i < t.Size(); i++ { // 0 gets no registers, plus future-proofing.
+			for i := int64(0); i < t.NumElem(); i++ { // 0 gets no registers, plus future-proofing.
 				rts = appendParamTypes(rts, t.Elem())
 			}
 		case types.TSTRUCT:
-- 
GitLab


From 4357f71ca7ecd3869e2e0805ee4d6cd275a71a7c Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Tue, 23 Mar 2021 15:51:29 -0400
Subject: [PATCH 1208/2400] cmd/compile: remove more dead code and data
 structures

Remove more now-redundant code, methods, and types
associated with transition to register ABI.
Repaired some broken comments.

Tested on link-register architectures (arm64, ppc64le)

Updates #40724.

Change-Id: Ie8433f6d38ec4a1d9705f22dcb596f267d81f203
Reviewed-on: https://go-review.googlesource.com/c/go/+/304189
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/abi/abiutils.go     | 15 ++------
 src/cmd/compile/internal/ssa/op.go           | 19 +----------
 src/cmd/compile/internal/ssa/writebarrier.go |  4 ---
 src/cmd/compile/internal/ssagen/ssa.go       | 36 +-------------------
 4 files changed, 4 insertions(+), 70 deletions(-)

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index 549c11306a..feda2153f7 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -225,27 +225,16 @@ func appendParamOffsets(offsets []int64, at int64, t *types.Type) ([]int64, int6
 	return offsets, at
 }
 
-// SpillOffset returns the offset *within the spill area* for the parameter that "a" describes.
-// Registers will be spilled here; if a memory home is needed (for a pointer method e.g.)
-// then that will be the address.
-// This will panic if "a" describes a stack-allocated parameter.
-func (a *ABIParamAssignment) SpillOffset() int32 {
-	if len(a.Registers) == 0 {
-		panic("Stack-allocated parameters have no spill offset")
-	}
-	return a.offset
-}
-
 // FrameOffset returns the frame-pointer-relative location that a function
 // would spill its input or output parameter to, if such a spill slot exists.
+// If there is none defined (e.g., register-allocated outputs) it panics.
 // For register-allocated inputs that is their spill offset reserved for morestack;
 // for stack-allocated inputs and outputs, that is their location on the stack.
-// For register-allocated outputs, there is no defined spill area, so return -1.
 // (In a future version of the ABI, register-resident inputs may lose their defined
 // spill area to help reduce stack sizes.)
 func (a *ABIParamAssignment) FrameOffset(i *ABIParamResultInfo) int64 {
 	if a.offset == -1 {
-		return -1
+		panic("Function parameter has no ABI-defined frame-pointer offset")
 	}
 	if len(a.Registers) == 0 { // passed on stack
 		return int64(a.offset) - i.config.LocalsOffset()
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index e4721a1ba8..c406b3b223 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -92,13 +92,6 @@ func (r *regInfo) String() string {
 
 type auxType int8
 
-type Param struct {
-	Type   *types.Type
-	Offset int32 // Offset of Param if not in a register, spill offset if it is in a register input, types.BADWIDTH if it is a register output.
-	Reg    []abi.RegIndex
-	Name   *ir.Name // For OwnAux, need to prepend stores with Vardefs
-}
-
 type AuxNameOffset struct {
 	Name   *ir.Name
 	Offset int64
@@ -198,7 +191,7 @@ func (a *AuxCall) ArgWidth() int64 {
 	return a.abiInfo.ArgWidth()
 }
 
-// OffsetOfResult returns the SP offset of result which (indexed 0, 1, etc).
+// ParamAssignmentForResult returns the ABI Parameter assignment for result which (indexed 0, 1, etc).
 func (a *AuxCall) ParamAssignmentForResult(which int64) *abi.ABIParamAssignment {
 	return a.abiInfo.OutParam(int(which))
 }
@@ -292,16 +285,6 @@ func (a *AuxCall) String() string {
 	return fn + "}"
 }
 
-// ACParamsToTypes translates a slice of Param into a slice of *types.Type
-// This is a helper call for ssagen/ssa.go.
-// TODO remove this, as part of replacing fields of AuxCall with abi.ABIParamResultInfo.
-func ACParamsToTypes(ps []Param) (ts []*types.Type) {
-	for _, p := range ps {
-		ts = append(ts, p.Type)
-	}
-	return
-}
-
 // StaticAuxCall returns an AuxCall for a static call.
 func StaticAuxCall(sym *obj.LSym, paramResultInfo *abi.ABIParamResultInfo) *AuxCall {
 	if paramResultInfo == nil {
diff --git a/src/cmd/compile/internal/ssa/writebarrier.go b/src/cmd/compile/internal/ssa/writebarrier.go
index ddcafe461c..bbb5a7c148 100644
--- a/src/cmd/compile/internal/ssa/writebarrier.go
+++ b/src/cmd/compile/internal/ssa/writebarrier.go
@@ -486,14 +486,12 @@ func wbcall(pos src.XPos, b *Block, fn, typ *obj.LSym, ptr, val, mem, sp, sb *Va
 	// put arguments on stack
 	off := config.ctxt.FixedFrameSize()
 
-	var ACArgs []Param
 	var argTypes []*types.Type
 	if typ != nil { // for typedmemmove
 		taddr := b.NewValue1A(pos, OpAddr, b.Func.Config.Types.Uintptr, typ, sb)
 		off = round(off, taddr.Type.Alignment())
 		arg := b.NewValue1I(pos, OpOffPtr, taddr.Type.PtrTo(), off, sp)
 		mem = b.NewValue3A(pos, OpStore, types.TypeMem, ptr.Type, arg, taddr, mem)
-		ACArgs = append(ACArgs, Param{Type: b.Func.Config.Types.Uintptr, Offset: int32(off)})
 		argTypes = append(argTypes, b.Func.Config.Types.Uintptr)
 		off += taddr.Type.Size()
 	}
@@ -501,7 +499,6 @@ func wbcall(pos src.XPos, b *Block, fn, typ *obj.LSym, ptr, val, mem, sp, sb *Va
 	off = round(off, ptr.Type.Alignment())
 	arg := b.NewValue1I(pos, OpOffPtr, ptr.Type.PtrTo(), off, sp)
 	mem = b.NewValue3A(pos, OpStore, types.TypeMem, ptr.Type, arg, ptr, mem)
-	ACArgs = append(ACArgs, Param{Type: ptr.Type, Offset: int32(off)})
 	argTypes = append(argTypes, ptr.Type)
 	off += ptr.Type.Size()
 
@@ -509,7 +506,6 @@ func wbcall(pos src.XPos, b *Block, fn, typ *obj.LSym, ptr, val, mem, sp, sb *Va
 		off = round(off, val.Type.Alignment())
 		arg = b.NewValue1I(pos, OpOffPtr, val.Type.PtrTo(), off, sp)
 		mem = b.NewValue3A(pos, OpStore, types.TypeMem, val.Type, arg, val, mem)
-		ACArgs = append(ACArgs, Param{Type: val.Type, Offset: int32(off)})
 		argTypes = append(argTypes, val.Type)
 		off += val.Type.Size()
 	}
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 45952482fb..18363c1219 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -521,7 +521,6 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 
 	// Generate addresses of local declarations
 	s.decladdrs = map[*ir.Name]*ssa.Value{}
-	var results []ssa.Param
 	for _, n := range fn.Dcl {
 		switch n.Class {
 		case ir.PPARAM:
@@ -529,7 +528,6 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 			s.decladdrs[n] = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(n.Type()), n, s.sp, s.startmem)
 		case ir.PPARAMOUT:
 			s.decladdrs[n] = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(n.Type()), n, s.sp, s.startmem)
-			results = append(results, ssa.Param{Name: n})
 		case ir.PAUTO:
 			// processed at each use, to prevent Addr coming
 			// before the decl.
@@ -538,34 +536,6 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 		}
 	}
 
-	// TODO: figure out why base.Ctxt.FixedFrameSize() is not added to these offsets here (compare to calls).
-	// The input half is ignored unless a register ABI is used.
-	var args []ssa.Param
-	for _, p := range params.InParams() {
-		r := p.Registers
-		var o int32
-		if len(r) == 0 {
-			o = p.Offset()
-		} else {
-			o = p.SpillOffset() + int32(params.SpillAreaOffset())
-		}
-		args = append(args, ssa.Param{Type: p.Type, Offset: o, Reg: r})
-	}
-
-	// For now, need the ir.Name attached to these, so update those already created.
-	for i, p := range params.OutParams() {
-		r := p.Registers
-		var o int32
-		if len(r) == 0 {
-			o = p.Offset()
-		} else {
-			o = types.BADWIDTH
-		}
-		results[i].Type = p.Type
-		results[i].Offset = o
-		results[i].Reg = r
-	}
-
 	s.f.OwnAux = ssa.OwnAuxCall(fn.LSym, params)
 
 	// Populate SSAable arguments.
@@ -5497,8 +5467,6 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
 	s.prevCall = nil
 	// Write args to the stack
 	off := base.Ctxt.FixedFrameSize()
-	var ACArgs []ssa.Param
-	var ACResults []ssa.Param
 	var callArgs []*ssa.Value
 	var callArgTypes []*types.Type
 
@@ -5506,7 +5474,6 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
 		t := arg.Type
 		off = types.Rnd(off, t.Alignment())
 		size := t.Size()
-		ACArgs = append(ACArgs, ssa.Param{Type: t, Offset: int32(off)})
 		callArgs = append(callArgs, arg)
 		callArgTypes = append(callArgTypes, t)
 		off += size
@@ -5517,7 +5484,6 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
 	offR := off
 	for _, t := range results {
 		offR = types.Rnd(offR, t.Alignment())
-		ACResults = append(ACResults, ssa.Param{Type: t, Offset: int32(offR)})
 		offR += t.Size()
 	}
 
@@ -5527,7 +5493,7 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*types.Type, args .
 	callArgs = append(callArgs, s.mem())
 	call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 	call.AddArgs(callArgs...)
-	s.vars[memVar] = s.newValue1I(ssa.OpSelectN, types.TypeMem, int64(len(ACResults)), call)
+	s.vars[memVar] = s.newValue1I(ssa.OpSelectN, types.TypeMem, int64(len(results)), call)
 
 	if !returns {
 		// Finish block
-- 
GitLab


From 2e94401277128f9e08e3319903d1b78c09c4ab98 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Tue, 23 Mar 2021 11:59:34 +0100
Subject: [PATCH 1209/2400] os/exec: use testenv.SkipFlaky in
 TestExtraFilesFDShuffle

Change-Id: Icc1980ea0f6363c667bf91371404a8df6ed6b8ab
Reviewed-on: https://go-review.googlesource.com/c/go/+/303950
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/os/exec/exec_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/os/exec/exec_test.go b/src/os/exec/exec_test.go
index c1d2a8f49c..d854e0de84 100644
--- a/src/os/exec/exec_test.go
+++ b/src/os/exec/exec_test.go
@@ -488,7 +488,7 @@ func numOpenFDsAndroid(t *testing.T) (n int, lsof []byte) {
 }
 
 func TestExtraFilesFDShuffle(t *testing.T) {
-	t.Skip("flaky test; see https://golang.org/issue/5780")
+	testenv.SkipFlaky(t, 5780)
 	switch runtime.GOOS {
 	case "windows":
 		t.Skip("no operating system support; skipping")
-- 
GitLab


From d8960e65a2386c899d50d7f0c355080865225b94 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Tue, 23 Mar 2021 17:03:46 -0400
Subject: [PATCH 1210/2400] cmd/go: move psuedo-version and version sorting to
 x/mod

Fixes #44969

Change-Id: I01e7b1cf73f0f506aa805bbfe4a9ccaed3d44efe
Reviewed-on: https://go-review.googlesource.com/c/go/+/304229
Trust: Jay Conrod <jayconrod@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go.mod                                |   2 +-
 src/cmd/go.sum                                |   4 +-
 src/cmd/go/internal/modfetch/cache.go         |   4 +-
 src/cmd/go/internal/modfetch/coderepo.go      |  30 ++--
 src/cmd/go/internal/modfetch/proxy.go         |  10 +-
 src/cmd/go/internal/modfetch/pseudo_test.go   | 154 ------------------
 src/cmd/go/internal/modfetch/repo.go          |  14 +-
 src/cmd/go/internal/modload/import.go         |   6 +-
 src/cmd/go/internal/modload/query.go          |  20 +--
 src/cmd/go/proxy_test.go                      |   7 +-
 .../golang.org/x/mod/module}/pseudo.go        |  18 +-
 .../vendor/golang.org/x/mod/semver/semver.go  |  20 +++
 src/cmd/vendor/modules.txt                    |   2 +-
 13 files changed, 71 insertions(+), 220 deletions(-)
 delete mode 100644 src/cmd/go/internal/modfetch/pseudo_test.go
 rename src/cmd/{go/internal/modfetch => vendor/golang.org/x/mod/module}/pseudo.go (95%)

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index d78fabe196..9b08040433 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -6,7 +6,7 @@ require (
 	github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5
 	golang.org/x/arch v0.0.0-20210308155006-05f8f0431f72
 	golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83
-	golang.org/x/mod v0.4.3-0.20210310185834-19d50cac98aa
+	golang.org/x/mod v0.4.3-0.20210323215154-1cc8812c1740
 	golang.org/x/sys v0.0.0-20210309074719-68d13333faf2 // indirect
 	golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d // indirect
 	golang.org/x/tools v0.1.1-0.20210312185553-8e4f4c86593a
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 706230f4cf..391e99ca99 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -14,8 +14,8 @@ golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPh
 golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 h1:/ZScEX8SfEmUGRHs0gxpqteO5nfNW6axyZbBdw9A12g=
 golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
 golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.4.3-0.20210310185834-19d50cac98aa h1:++oSKjoJSsXNHyhUdK1BtBKMAaMHER+GWyKN3319OZA=
-golang.org/x/mod v0.4.3-0.20210310185834-19d50cac98aa/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.3-0.20210323215154-1cc8812c1740 h1:UYbWz0ISU1ccVf+FK/BRuwA4LGw2SzoambF9r5ozR/E=
+golang.org/x/mod v0.4.3-0.20210323215154-1cc8812c1740/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
diff --git a/src/cmd/go/internal/modfetch/cache.go b/src/cmd/go/internal/modfetch/cache.go
index 776def7cbc..c1303502e5 100644
--- a/src/cmd/go/internal/modfetch/cache.go
+++ b/src/cmd/go/internal/modfetch/cache.go
@@ -497,7 +497,7 @@ func readDiskStatByHash(path, rev string) (file string, info *RevInfo, err error
 	for _, name := range names {
 		if strings.HasSuffix(name, suffix) {
 			v := strings.TrimSuffix(name, ".info")
-			if IsPseudoVersion(v) && semver.Compare(v, maxVersion) > 0 {
+			if module.IsPseudoVersion(v) && semver.Compare(v, maxVersion) > 0 {
 				maxVersion = v
 				file, info, err = readDiskStat(path, strings.TrimSuffix(name, ".info"))
 			}
@@ -674,7 +674,7 @@ func rewriteVersionList(dir string) (err error) {
 			}
 		}
 	}
-	SortVersions(list)
+	semver.Sort(list)
 
 	var buf bytes.Buffer
 	for _, v := range list {
diff --git a/src/cmd/go/internal/modfetch/coderepo.go b/src/cmd/go/internal/modfetch/coderepo.go
index 2dcbb99b18..f817a04583 100644
--- a/src/cmd/go/internal/modfetch/coderepo.go
+++ b/src/cmd/go/internal/modfetch/coderepo.go
@@ -159,7 +159,7 @@ func (r *codeRepo) Versions(prefix string) ([]string, error) {
 		if r.codeDir != "" {
 			v = v[len(r.codeDir)+1:]
 		}
-		if v == "" || v != module.CanonicalVersion(v) || IsPseudoVersion(v) {
+		if v == "" || v != module.CanonicalVersion(v) || module.IsPseudoVersion(v) {
 			continue
 		}
 
@@ -172,8 +172,8 @@ func (r *codeRepo) Versions(prefix string) ([]string, error) {
 
 		list = append(list, v)
 	}
-	SortVersions(list)
-	SortVersions(incompatible)
+	semver.Sort(list)
+	semver.Sort(incompatible)
 
 	return r.appendIncompatibleVersions(list, incompatible)
 }
@@ -385,7 +385,7 @@ func (r *codeRepo) convert(info *codehost.RevInfo, statVers string) (*RevInfo, e
 	if statVers != "" && statVers == module.CanonicalVersion(statVers) {
 		info2.Version = statVers
 
-		if IsPseudoVersion(info2.Version) {
+		if module.IsPseudoVersion(info2.Version) {
 			if err := r.validatePseudoVersion(info, info2.Version); err != nil {
 				return nil, err
 			}
@@ -433,7 +433,7 @@ func (r *codeRepo) convert(info *codehost.RevInfo, statVers string) (*RevInfo, e
 		}
 		trimmed := tag[len(tagPrefix):]
 		// Tags that look like pseudo-versions would be confusing. Ignore them.
-		if IsPseudoVersion(tag) {
+		if module.IsPseudoVersion(tag) {
 			return "", false
 		}
 
@@ -531,7 +531,7 @@ func (r *codeRepo) convert(info *codehost.RevInfo, statVers string) (*RevInfo, e
 		pseudoBase, _ = tagToVersion(tag) // empty if the tag is invalid
 	}
 
-	info2.Version = PseudoVersion(r.pseudoMajor, pseudoBase, info.Time, info.Short)
+	info2.Version = module.PseudoVersion(r.pseudoMajor, pseudoBase, info.Time, info.Short)
 	return checkGoMod()
 }
 
@@ -560,7 +560,7 @@ func (r *codeRepo) validatePseudoVersion(info *codehost.RevInfo, version string)
 		return err
 	}
 
-	rev, err := PseudoVersionRev(version)
+	rev, err := module.PseudoVersionRev(version)
 	if err != nil {
 		return err
 	}
@@ -575,12 +575,12 @@ func (r *codeRepo) validatePseudoVersion(info *codehost.RevInfo, version string)
 		}
 	}
 
-	t, err := PseudoVersionTime(version)
+	t, err := module.PseudoVersionTime(version)
 	if err != nil {
 		return err
 	}
 	if !t.Equal(info.Time.Truncate(time.Second)) {
-		return fmt.Errorf("does not match version-control timestamp (expected %s)", info.Time.UTC().Format(pseudoVersionTimestampFormat))
+		return fmt.Errorf("does not match version-control timestamp (expected %s)", info.Time.UTC().Format(module.PseudoVersionTimestampFormat))
 	}
 
 	tagPrefix := ""
@@ -604,7 +604,7 @@ func (r *codeRepo) validatePseudoVersion(info *codehost.RevInfo, version string)
 	// not enforce that property when resolving existing pseudo-versions: we don't
 	// know when the parent tags were added, and the highest-tagged parent may not
 	// have existed when the pseudo-version was first resolved.
-	base, err := PseudoVersionBase(strings.TrimSuffix(version, "+incompatible"))
+	base, err := module.PseudoVersionBase(strings.TrimSuffix(version, "+incompatible"))
 	if err != nil {
 		return err
 	}
@@ -661,7 +661,7 @@ func (r *codeRepo) validatePseudoVersion(info *codehost.RevInfo, version string)
 		if err != nil {
 			return err
 		}
-		rev, err := PseudoVersionRev(version)
+		rev, err := module.PseudoVersionRev(version)
 		if err != nil {
 			return fmt.Errorf("not a descendent of preceding tag (%s)", lastTag)
 		}
@@ -672,8 +672,8 @@ func (r *codeRepo) validatePseudoVersion(info *codehost.RevInfo, version string)
 
 func (r *codeRepo) revToRev(rev string) string {
 	if semver.IsValid(rev) {
-		if IsPseudoVersion(rev) {
-			r, _ := PseudoVersionRev(rev)
+		if module.IsPseudoVersion(rev) {
+			r, _ := module.PseudoVersionRev(rev)
 			return r
 		}
 		if semver.Build(rev) == "+incompatible" {
@@ -843,7 +843,7 @@ func (r *codeRepo) GoMod(version string) (data []byte, err error) {
 		return nil, fmt.Errorf("version %s is not canonical", version)
 	}
 
-	if IsPseudoVersion(version) {
+	if module.IsPseudoVersion(version) {
 		// findDir ignores the metadata encoded in a pseudo-version,
 		// only using the revision at the end.
 		// Invoke Stat to verify the metadata explicitly so we don't return
@@ -942,7 +942,7 @@ func (r *codeRepo) Zip(dst io.Writer, version string) error {
 		return fmt.Errorf("version %s is not canonical", version)
 	}
 
-	if IsPseudoVersion(version) {
+	if module.IsPseudoVersion(version) {
 		// findDir ignores the metadata encoded in a pseudo-version,
 		// only using the revision at the end.
 		// Invoke Stat to verify the metadata explicitly so we don't return
diff --git a/src/cmd/go/internal/modfetch/proxy.go b/src/cmd/go/internal/modfetch/proxy.go
index 6c86d8d786..31d453c807 100644
--- a/src/cmd/go/internal/modfetch/proxy.go
+++ b/src/cmd/go/internal/modfetch/proxy.go
@@ -228,7 +228,7 @@ func (p *proxyRepo) versionError(version string, err error) error {
 			Path: p.path,
 			Err: &module.InvalidVersionError{
 				Version: version,
-				Pseudo:  IsPseudoVersion(version),
+				Pseudo:  module.IsPseudoVersion(version),
 				Err:     err,
 			},
 		}
@@ -276,11 +276,11 @@ func (p *proxyRepo) Versions(prefix string) ([]string, error) {
 	var list []string
 	for _, line := range strings.Split(string(data), "\n") {
 		f := strings.Fields(line)
-		if len(f) >= 1 && semver.IsValid(f[0]) && strings.HasPrefix(f[0], prefix) && !IsPseudoVersion(f[0]) {
+		if len(f) >= 1 && semver.IsValid(f[0]) && strings.HasPrefix(f[0], prefix) && !module.IsPseudoVersion(f[0]) {
 			list = append(list, f[0])
 		}
 	}
-	SortVersions(list)
+	semver.Sort(list)
 	return list, nil
 }
 
@@ -307,8 +307,8 @@ func (p *proxyRepo) latest() (*RevInfo, error) {
 			)
 			if len(f) >= 2 {
 				ft, _ = time.Parse(time.RFC3339, f[1])
-			} else if IsPseudoVersion(f[0]) {
-				ft, _ = PseudoVersionTime(f[0])
+			} else if module.IsPseudoVersion(f[0]) {
+				ft, _ = module.PseudoVersionTime(f[0])
 				ftIsFromPseudo = true
 			} else {
 				// Repo.Latest promises that this method is only called where there are
diff --git a/src/cmd/go/internal/modfetch/pseudo_test.go b/src/cmd/go/internal/modfetch/pseudo_test.go
deleted file mode 100644
index 4483f8e962..0000000000
--- a/src/cmd/go/internal/modfetch/pseudo_test.go
+++ /dev/null
@@ -1,154 +0,0 @@
-// Copyright 2018 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 modfetch
-
-import (
-	"testing"
-	"time"
-)
-
-var pseudoTests = []struct {
-	major   string
-	older   string
-	version string
-}{
-	{"", "", "v0.0.0-20060102150405-hash"},
-	{"v0", "", "v0.0.0-20060102150405-hash"},
-	{"v1", "", "v1.0.0-20060102150405-hash"},
-	{"v2", "", "v2.0.0-20060102150405-hash"},
-	{"unused", "v0.0.0", "v0.0.1-0.20060102150405-hash"},
-	{"unused", "v1.2.3", "v1.2.4-0.20060102150405-hash"},
-	{"unused", "v1.2.99999999999999999", "v1.2.100000000000000000-0.20060102150405-hash"},
-	{"unused", "v1.2.3-pre", "v1.2.3-pre.0.20060102150405-hash"},
-	{"unused", "v1.3.0-pre", "v1.3.0-pre.0.20060102150405-hash"},
-	{"unused", "v0.0.0--", "v0.0.0--.0.20060102150405-hash"},
-	{"unused", "v1.0.0+metadata", "v1.0.1-0.20060102150405-hash+metadata"},
-	{"unused", "v2.0.0+incompatible", "v2.0.1-0.20060102150405-hash+incompatible"},
-	{"unused", "v2.3.0-pre+incompatible", "v2.3.0-pre.0.20060102150405-hash+incompatible"},
-}
-
-var pseudoTime = time.Date(2006, 1, 2, 15, 4, 5, 0, time.UTC)
-
-func TestPseudoVersion(t *testing.T) {
-	for _, tt := range pseudoTests {
-		v := PseudoVersion(tt.major, tt.older, pseudoTime, "hash")
-		if v != tt.version {
-			t.Errorf("PseudoVersion(%q, %q, ...) = %v, want %v", tt.major, tt.older, v, tt.version)
-		}
-	}
-}
-
-func TestIsPseudoVersion(t *testing.T) {
-	for _, tt := range pseudoTests {
-		if !IsPseudoVersion(tt.version) {
-			t.Errorf("IsPseudoVersion(%q) = false, want true", tt.version)
-		}
-		if IsPseudoVersion(tt.older) {
-			t.Errorf("IsPseudoVersion(%q) = true, want false", tt.older)
-		}
-	}
-}
-
-func TestPseudoVersionTime(t *testing.T) {
-	for _, tt := range pseudoTests {
-		tm, err := PseudoVersionTime(tt.version)
-		if tm != pseudoTime || err != nil {
-			t.Errorf("PseudoVersionTime(%q) = %v, %v, want %v, nil", tt.version, tm.Format(time.RFC3339), err, pseudoTime.Format(time.RFC3339))
-		}
-		tm, err = PseudoVersionTime(tt.older)
-		if tm != (time.Time{}) || err == nil {
-			t.Errorf("PseudoVersionTime(%q) = %v, %v, want %v, error", tt.older, tm.Format(time.RFC3339), err, time.Time{}.Format(time.RFC3339))
-		}
-	}
-}
-
-func TestInvalidPseudoVersionTime(t *testing.T) {
-	const v = "---"
-	if _, err := PseudoVersionTime(v); err == nil {
-		t.Error("expected error, got nil instead")
-	}
-}
-
-func TestPseudoVersionRev(t *testing.T) {
-	for _, tt := range pseudoTests {
-		rev, err := PseudoVersionRev(tt.version)
-		if rev != "hash" || err != nil {
-			t.Errorf("PseudoVersionRev(%q) = %q, %v, want %q, nil", tt.older, rev, err, "hash")
-		}
-		rev, err = PseudoVersionRev(tt.older)
-		if rev != "" || err == nil {
-			t.Errorf("PseudoVersionRev(%q) = %q, %v, want %q, error", tt.older, rev, err, "")
-		}
-	}
-}
-
-func TestPseudoVersionBase(t *testing.T) {
-	for _, tt := range pseudoTests {
-		base, err := PseudoVersionBase(tt.version)
-		if err != nil {
-			t.Errorf("PseudoVersionBase(%q): %v", tt.version, err)
-		} else if base != tt.older {
-			t.Errorf("PseudoVersionBase(%q) = %q; want %q", tt.version, base, tt.older)
-		}
-	}
-}
-
-func TestInvalidPseudoVersionBase(t *testing.T) {
-	for _, in := range []string{
-		"v0.0.0",
-		"v0.0.0-",                                 // malformed: empty prerelease
-		"v0.0.0-0.20060102150405-hash",            // Z+1 == 0
-		"v0.1.0-0.20060102150405-hash",            // Z+1 == 0
-		"v1.0.0-0.20060102150405-hash",            // Z+1 == 0
-		"v0.0.0-20060102150405-hash+incompatible", // "+incompatible without base version
-		"v0.0.0-20060102150405-hash+metadata",     // other metadata without base version
-	} {
-		base, err := PseudoVersionBase(in)
-		if err == nil || base != "" {
-			t.Errorf(`PseudoVersionBase(%q) = %q, %v; want "", error`, in, base, err)
-		}
-	}
-}
-
-func TestIncDecimal(t *testing.T) {
-	cases := []struct {
-		in, want string
-	}{
-		{"0", "1"},
-		{"1", "2"},
-		{"99", "100"},
-		{"100", "101"},
-		{"101", "102"},
-	}
-
-	for _, tc := range cases {
-		got := incDecimal(tc.in)
-		if got != tc.want {
-			t.Fatalf("incDecimal(%q) = %q; want %q", tc.in, tc.want, got)
-		}
-	}
-}
-
-func TestDecDecimal(t *testing.T) {
-	cases := []struct {
-		in, want string
-	}{
-		{"", ""},
-		{"0", ""},
-		{"00", ""},
-		{"1", "0"},
-		{"2", "1"},
-		{"99", "98"},
-		{"100", "99"},
-		{"101", "100"},
-	}
-
-	for _, tc := range cases {
-		got := decDecimal(tc.in)
-		if got != tc.want {
-			t.Fatalf("decDecimal(%q) = %q; want %q", tc.in, tc.want, got)
-		}
-	}
-}
diff --git a/src/cmd/go/internal/modfetch/repo.go b/src/cmd/go/internal/modfetch/repo.go
index ed9a52267a..46923cb7dc 100644
--- a/src/cmd/go/internal/modfetch/repo.go
+++ b/src/cmd/go/internal/modfetch/repo.go
@@ -9,7 +9,6 @@ import (
 	"io"
 	"io/fs"
 	"os"
-	"sort"
 	"strconv"
 	"time"
 
@@ -20,7 +19,6 @@ import (
 	web "cmd/go/internal/web"
 
 	"golang.org/x/mod/module"
-	"golang.org/x/mod/semver"
 )
 
 const traceRepo = false // trace all repo actions, for debugging
@@ -35,7 +33,7 @@ type Repo interface {
 	// Pseudo-versions are not included.
 	//
 	// Versions should be returned sorted in semver order
-	// (implementations can use SortVersions).
+	// (implementations can use semver.Sort).
 	//
 	// Versions returns a non-nil error only if there was a problem
 	// fetching the list of versions: it may return an empty list
@@ -346,16 +344,6 @@ func ImportRepoRev(path, rev string) (Repo, *RevInfo, error) {
 	return repo, info, nil
 }
 
-func SortVersions(list []string) {
-	sort.Slice(list, func(i, j int) bool {
-		cmp := semver.Compare(list[i], list[j])
-		if cmp != 0 {
-			return cmp < 0
-		}
-		return list[i] < list[j]
-	})
-}
-
 // A loggingRepo is a wrapper around an underlying Repo
 // that prints a log message at the start and end of each call.
 // It can be inserted when debugging.
diff --git a/src/cmd/go/internal/modload/import.go b/src/cmd/go/internal/modload/import.go
index 995641c9f1..31eb0c4874 100644
--- a/src/cmd/go/internal/modload/import.go
+++ b/src/cmd/go/internal/modload/import.go
@@ -60,7 +60,7 @@ func (e *ImportMissingError) Error() string {
 
 		if e.replaced.Path != "" {
 			suggestArg := e.replaced.Path
-			if !modfetch.IsZeroPseudoVersion(e.replaced.Version) {
+			if !module.IsZeroPseudoVersion(e.replaced.Version) {
 				suggestArg = e.replaced.String()
 			}
 			return fmt.Sprintf("module %s provides package %s and is replaced but not required; to add it:\n\tgo get %s", e.replaced.Path, e.Path, suggestArg)
@@ -344,9 +344,9 @@ func queryImport(ctx context.Context, path string) (module.Version, error) {
 				// used from within some other module, the user will be able to upgrade
 				// the requirement to any real version they choose.
 				if _, pathMajor, ok := module.SplitPathVersion(mp); ok && len(pathMajor) > 0 {
-					mv = modfetch.ZeroPseudoVersion(pathMajor[1:])
+					mv = module.ZeroPseudoVersion(pathMajor[1:])
 				} else {
-					mv = modfetch.ZeroPseudoVersion("v0")
+					mv = module.ZeroPseudoVersion("v0")
 				}
 			}
 			mods = append(mods, module.Version{Path: mp, Version: mv})
diff --git a/src/cmd/go/internal/modload/query.go b/src/cmd/go/internal/modload/query.go
index 1707bd88ed..6f6c6e8c98 100644
--- a/src/cmd/go/internal/modload/query.go
+++ b/src/cmd/go/internal/modload/query.go
@@ -177,7 +177,7 @@ func queryProxy(ctx context.Context, proxy, path, query, current string, allowed
 			return nil, err
 		}
 
-		if (query == "upgrade" || query == "patch") && modfetch.IsPseudoVersion(current) && !rev.Time.IsZero() {
+		if (query == "upgrade" || query == "patch") && module.IsPseudoVersion(current) && !rev.Time.IsZero() {
 			// Don't allow "upgrade" or "patch" to move from a pseudo-version
 			// to a chronologically older version or pseudo-version.
 			//
@@ -196,7 +196,7 @@ func queryProxy(ctx context.Context, proxy, path, query, current string, allowed
 			// newer but v1.1.0 is still an “upgrade”; or v1.0.2 might be a revert of
 			// an unsuccessful fix in v1.0.1, in which case the v1.0.2 commit may be
 			// older than the v1.0.1 commit despite the tag itself being newer.)
-			currentTime, err := modfetch.PseudoVersionTime(current)
+			currentTime, err := module.PseudoVersionTime(current)
 			if err == nil && rev.Time.Before(currentTime) {
 				if err := allowed(ctx, module.Version{Path: path, Version: current}); errors.Is(err, ErrDisallowed) {
 					return nil, err
@@ -325,7 +325,7 @@ func newQueryMatcher(path string, query, current string, allowed AllowedFunc) (*
 		if current == "" || current == "none" {
 			qm.mayUseLatest = true
 		} else {
-			qm.mayUseLatest = modfetch.IsPseudoVersion(current)
+			qm.mayUseLatest = module.IsPseudoVersion(current)
 			qm.filter = func(mv string) bool { return semver.Compare(mv, current) >= 0 }
 		}
 
@@ -336,7 +336,7 @@ func newQueryMatcher(path string, query, current string, allowed AllowedFunc) (*
 		if current == "" {
 			qm.mayUseLatest = true
 		} else {
-			qm.mayUseLatest = modfetch.IsPseudoVersion(current)
+			qm.mayUseLatest = module.IsPseudoVersion(current)
 			qm.prefix = semver.MajorMinor(current) + "."
 			qm.filter = func(mv string) bool { return semver.Compare(mv, current) >= 0 }
 		}
@@ -1009,7 +1009,7 @@ func (rr *replacementRepo) Versions(prefix string) ([]string, error) {
 	if index != nil && len(index.replace) > 0 {
 		path := rr.ModulePath()
 		for m, _ := range index.replace {
-			if m.Path == path && strings.HasPrefix(m.Version, prefix) && m.Version != "" && !modfetch.IsPseudoVersion(m.Version) {
+			if m.Path == path && strings.HasPrefix(m.Version, prefix) && m.Version != "" && !module.IsPseudoVersion(m.Version) {
 				versions = append(versions, m.Version)
 			}
 		}
@@ -1066,9 +1066,9 @@ func (rr *replacementRepo) Latest() (*modfetch.RevInfo, error) {
 				// used from within some other module, the user will be able to upgrade
 				// the requirement to any real version they choose.
 				if _, pathMajor, ok := module.SplitPathVersion(path); ok && len(pathMajor) > 0 {
-					v = modfetch.PseudoVersion(pathMajor[1:], "", time.Time{}, "000000000000")
+					v = module.PseudoVersion(pathMajor[1:], "", time.Time{}, "000000000000")
 				} else {
-					v = modfetch.PseudoVersion("v0", "", time.Time{}, "000000000000")
+					v = module.PseudoVersion("v0", "", time.Time{}, "000000000000")
 				}
 			}
 
@@ -1083,9 +1083,9 @@ func (rr *replacementRepo) Latest() (*modfetch.RevInfo, error) {
 
 func (rr *replacementRepo) replacementStat(v string) (*modfetch.RevInfo, error) {
 	rev := &modfetch.RevInfo{Version: v}
-	if modfetch.IsPseudoVersion(v) {
-		rev.Time, _ = modfetch.PseudoVersionTime(v)
-		rev.Short, _ = modfetch.PseudoVersionRev(v)
+	if module.IsPseudoVersion(v) {
+		rev.Time, _ = module.PseudoVersionTime(v)
+		rev.Short, _ = module.PseudoVersionRev(v)
 	}
 	return rev, nil
 }
diff --git a/src/cmd/go/proxy_test.go b/src/cmd/go/proxy_test.go
index 7d8a97dd99..74bfecc08d 100644
--- a/src/cmd/go/proxy_test.go
+++ b/src/cmd/go/proxy_test.go
@@ -23,7 +23,6 @@ import (
 	"sync"
 	"testing"
 
-	"cmd/go/internal/modfetch"
 	"cmd/go/internal/modfetch/codehost"
 	"cmd/go/internal/par"
 	"cmd/go/internal/txtar"
@@ -229,7 +228,7 @@ func proxyHandler(w http.ResponseWriter, r *http.Request) {
 			if m.Path != modPath {
 				continue
 			}
-			if modfetch.IsPseudoVersion(m.Version) && (latestPseudo == "" || semver.Compare(latestPseudo, m.Version) > 0) {
+			if module.IsPseudoVersion(m.Version) && (latestPseudo == "" || semver.Compare(latestPseudo, m.Version) > 0) {
 				latestPseudo = m.Version
 			} else if semver.Prerelease(m.Version) != "" && (latestPrerelease == "" || semver.Compare(latestPrerelease, m.Version) > 0) {
 				latestPrerelease = m.Version
@@ -282,7 +281,7 @@ func proxyHandler(w http.ResponseWriter, r *http.Request) {
 				continue
 			}
 			found = true
-			if !modfetch.IsPseudoVersion(m.Version) {
+			if !module.IsPseudoVersion(m.Version) {
 				if err := module.Check(m.Path, m.Version); err == nil {
 					fmt.Fprintf(w, "%s\n", m.Version)
 				}
@@ -315,7 +314,7 @@ func proxyHandler(w http.ResponseWriter, r *http.Request) {
 		for _, m := range modList {
 			if m.Path == path && semver.Compare(best, m.Version) < 0 {
 				var hash string
-				if modfetch.IsPseudoVersion(m.Version) {
+				if module.IsPseudoVersion(m.Version) {
 					hash = m.Version[strings.LastIndex(m.Version, "-")+1:]
 				} else {
 					hash = findHash(m)
diff --git a/src/cmd/go/internal/modfetch/pseudo.go b/src/cmd/vendor/golang.org/x/mod/module/pseudo.go
similarity index 95%
rename from src/cmd/go/internal/modfetch/pseudo.go
rename to src/cmd/vendor/golang.org/x/mod/module/pseudo.go
index 93eb0fad96..f04ad37886 100644
--- a/src/cmd/go/internal/modfetch/pseudo.go
+++ b/src/cmd/vendor/golang.org/x/mod/module/pseudo.go
@@ -32,7 +32,7 @@
 // If the most recent tagged version before the target commit is vX.Y.Z-pre or vX.Y.Z-pre+incompatible,
 // then the pseudo-version uses form (4) or (5), making it a slightly later prerelease.
 
-package modfetch
+package module
 
 import (
 	"errors"
@@ -40,15 +40,13 @@ import (
 	"strings"
 	"time"
 
-	"internal/lazyregexp"
-
-	"golang.org/x/mod/module"
+	"golang.org/x/mod/internal/lazyregexp"
 	"golang.org/x/mod/semver"
 )
 
 var pseudoVersionRE = lazyregexp.New(`^v[0-9]+\.(0\.0-|\d+\.\d+-([^+]*\.)?0\.)\d{14}-[A-Za-z0-9]+(\+[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?$`)
 
-const pseudoVersionTimestampFormat = "20060102150405"
+const PseudoVersionTimestampFormat = "20060102150405"
 
 // PseudoVersion returns a pseudo-version for the given major version ("v1")
 // preexisting older tagged version ("" or "v1.2.3" or "v1.2.3-pre"), revision time,
@@ -57,7 +55,7 @@ func PseudoVersion(major, older string, t time.Time, rev string) string {
 	if major == "" {
 		major = "v0"
 	}
-	segment := fmt.Sprintf("%s-%s", t.UTC().Format(pseudoVersionTimestampFormat), rev)
+	segment := fmt.Sprintf("%s-%s", t.UTC().Format(PseudoVersionTimestampFormat), rev)
 	build := semver.Build(older)
 	older = semver.Canonical(older)
 	if older == "" {
@@ -142,7 +140,7 @@ func PseudoVersionTime(v string) (time.Time, error) {
 	}
 	t, err := time.Parse("20060102150405", timestamp)
 	if err != nil {
-		return time.Time{}, &module.InvalidVersionError{
+		return time.Time{}, &InvalidVersionError{
 			Version: v,
 			Pseudo:  true,
 			Err:     fmt.Errorf("malformed time %q", timestamp),
@@ -180,7 +178,7 @@ func PseudoVersionBase(v string) (string, error) {
 			//
 			// There are a few such entries in the index generated by proxy.golang.org,
 			// but we believe those entries were generated by the proxy itself.
-			return "", &module.InvalidVersionError{
+			return "", &InvalidVersionError{
 				Version: v,
 				Pseudo:  true,
 				Err:     fmt.Errorf("lacks base version, but has build metadata %q", build),
@@ -208,7 +206,7 @@ func PseudoVersionBase(v string) (string, error) {
 			// treat them as equivalent to vX.0.0 (especially since the invalid
 			// pseudo-versions have lower precedence than the real ones). For now, we
 			// reject them.
-			return "", &module.InvalidVersionError{
+			return "", &InvalidVersionError{
 				Version: v,
 				Pseudo:  true,
 				Err:     fmt.Errorf("version before %s would have negative patch number", base),
@@ -230,7 +228,7 @@ var errPseudoSyntax = errors.New("syntax error")
 
 func parsePseudoVersion(v string) (base, timestamp, rev, build string, err error) {
 	if !IsPseudoVersion(v) {
-		return "", "", "", "", &module.InvalidVersionError{
+		return "", "", "", "", &InvalidVersionError{
 			Version: v,
 			Pseudo:  true,
 			Err:     errPseudoSyntax,
diff --git a/src/cmd/vendor/golang.org/x/mod/semver/semver.go b/src/cmd/vendor/golang.org/x/mod/semver/semver.go
index 4338f35177..7be398f80d 100644
--- a/src/cmd/vendor/golang.org/x/mod/semver/semver.go
+++ b/src/cmd/vendor/golang.org/x/mod/semver/semver.go
@@ -22,6 +22,8 @@
 // as shorthands for vMAJOR.0.0 and vMAJOR.MINOR.0.
 package semver
 
+import "sort"
+
 // parsed returns the parsed form of a semantic version string.
 type parsed struct {
 	major      string
@@ -150,6 +152,24 @@ func Max(v, w string) string {
 	return w
 }
 
+// ByVersion implements sort.Interface for sorting semantic version strings.
+type ByVersion []string
+
+func (vs ByVersion) Len() int      { return len(vs) }
+func (vs ByVersion) Swap(i, j int) { vs[i], vs[j] = vs[j], vs[i] }
+func (vs ByVersion) Less(i, j int) bool {
+	cmp := Compare(vs[i], vs[j])
+	if cmp != 0 {
+		return cmp < 0
+	}
+	return vs[i] < vs[j]
+}
+
+// Sort sorts a list of semantic version strings using ByVersion.
+func Sort(list []string) {
+	sort.Sort(ByVersion(list))
+}
+
 func parse(v string) (p parsed, ok bool) {
 	if v == "" || v[0] != 'v' {
 		p.err = "missing v prefix"
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 3dd50ccddb..6960ff1c7e 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -28,7 +28,7 @@ golang.org/x/arch/x86/x86asm
 golang.org/x/crypto/ed25519
 golang.org/x/crypto/ed25519/internal/edwards25519
 golang.org/x/crypto/ssh/terminal
-# golang.org/x/mod v0.4.3-0.20210310185834-19d50cac98aa
+# golang.org/x/mod v0.4.3-0.20210323215154-1cc8812c1740
 ## explicit
 golang.org/x/mod/internal/lazyregexp
 golang.org/x/mod/modfile
-- 
GitLab


From 747f426944b1c0c3a26537ef78cb6c5bd4d05cde Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Tue, 9 Mar 2021 16:55:04 -0600
Subject: [PATCH 1211/2400] cmd/internal/obj: remove bogus load/store optab
 entries from ppc64

No valid operation should match those removed by this patch. They
kind of look as if they match X-form load/stores on ppc64, but the
second argument is always ignored when translating to machine code.

Similarly, it should be noted an X-form memory access encodes into
an Addr which is a classified as a ZOREG argument with a non-zero
index, and a register type Addr.

Change-Id: I1adbb020d1b2612b18949d0e7eda05dbb3e8a25c
Reviewed-on: https://go-review.googlesource.com/c/go/+/303329
Reviewed-by: Carlos Eduardo Seo <carlos.seo@linaro.org>
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
Run-TryBot: Paul Murphy <murp@ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Carlos Eduardo Seo <carlos.seo@linaro.org>
---
 src/cmd/internal/obj/ppc64/asm9.go | 18 ------------------
 1 file changed, 18 deletions(-)

diff --git a/src/cmd/internal/obj/ppc64/asm9.go b/src/cmd/internal/obj/ppc64/asm9.go
index 1a97dda715..1745409b4d 100644
--- a/src/cmd/internal/obj/ppc64/asm9.go
+++ b/src/cmd/internal/obj/ppc64/asm9.go
@@ -194,40 +194,31 @@ var optab = []Optab{
 	{as: AFMUL, a1: C_FREG, a6: C_FREG, type_: 32, size: 4},
 	{as: AFMUL, a1: C_FREG, a2: C_FREG, a6: C_FREG, type_: 32, size: 4},
 
-	{as: AMOVBU, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
 	{as: AMOVBU, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVBU, a1: C_SOREG, a6: C_REG, type_: 9, size: 8},
 	{as: AMOVBU, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 9, size: 8},
 
-	{as: AMOVBZU, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
 	{as: AMOVBZU, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVBZU, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
-	{as: AMOVBZU, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4},
 
-	{as: AMOVHBR, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 44, size: 4},
 	{as: AMOVHBR, a1: C_REG, a6: C_ZOREG, type_: 44, size: 4},
-	{as: AMOVHBR, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 45, size: 4},
 	{as: AMOVHBR, a1: C_ZOREG, a6: C_REG, type_: 45, size: 4},
 
 	{as: AMOVB, a1: C_ADDR, a6: C_REG, type_: 76, size: 12},
 	{as: AMOVB, a1: C_LOREG, a6: C_REG, type_: 37, size: 12},
-	{as: AMOVB, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
 	{as: AMOVB, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 	{as: AMOVB, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
 	{as: AMOVB, a1: C_REG, a6: C_REG, type_: 12, size: 4},
 	{as: AMOVB, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVB, a1: C_SOREG, a6: C_REG, type_: 9, size: 8},
-	{as: AMOVB, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 9, size: 8},
 
 	{as: AMOVBZ, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
 	{as: AMOVBZ, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
-	{as: AMOVBZ, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
 	{as: AMOVBZ, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 	{as: AMOVBZ, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
 	{as: AMOVBZ, a1: C_REG, a6: C_REG, type_: 13, size: 4},
 	{as: AMOVBZ, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVBZ, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
-	{as: AMOVBZ, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4},
 
 	{as: AMOVD, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4},
 	{as: AMOVD, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
@@ -240,7 +231,6 @@ var optab = []Optab{
 	{as: AMOVD, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
 	{as: AMOVD, a1: C_LR, a6: C_REG, type_: 66, size: 4},
 	{as: AMOVD, a1: C_MSR, a6: C_REG, type_: 54, size: 4}, /* mfmsr */
-	{as: AMOVD, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
 	{as: AMOVD, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 	{as: AMOVD, a1: C_REG, a6: C_CTR, type_: 66, size: 4},
 	{as: AMOVD, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
@@ -259,7 +249,6 @@ var optab = []Optab{
 	{as: AMOVD, a1: C_TOCADDR, a6: C_REG, type_: 95, size: 8},
 	{as: AMOVD, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
 	{as: AMOVD, a1: C_XER, a6: C_REG, type_: 66, size: 4},
-	{as: AMOVD, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4},
 
 	{as: AMOVW, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4},
 	{as: AMOVW, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
@@ -269,7 +258,6 @@ var optab = []Optab{
 	{as: AMOVW, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
 	{as: AMOVW, a1: C_LECON, a6: C_REG, type_: 26, size: 8},
 	{as: AMOVW, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
-	{as: AMOVW, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
 	{as: AMOVW, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 	{as: AMOVW, a1: C_REG, a6: C_CREG, type_: 69, size: 4},
 	{as: AMOVW, a1: C_REG, a6: C_CTR, type_: 66, size: 4},
@@ -284,7 +272,6 @@ var optab = []Optab{
 	{as: AMOVW, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
 	{as: AMOVW, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
 	{as: AMOVW, a1: C_XER, a6: C_REG, type_: 66, size: 4},
-	{as: AMOVW, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4},
 
 	{as: AMOVWZ, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4},
 	{as: AMOVWZ, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
@@ -294,7 +281,6 @@ var optab = []Optab{
 	{as: AMOVWZ, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
 	{as: AMOVWZ, a1: C_LECON, a6: C_REG, type_: 26, size: 8},
 	{as: AMOVWZ, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
-	{as: AMOVWZ, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 7, size: 4},
 	{as: AMOVWZ, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 	{as: AMOVWZ, a1: C_REG, a6: C_CREG, type_: 69, size: 4},
 	{as: AMOVWZ, a1: C_REG, a6: C_CTR, type_: 66, size: 4},
@@ -310,7 +296,6 @@ var optab = []Optab{
 	{as: AMOVWZ, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
 	{as: AMOVWZ, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
 	{as: AMOVWZ, a1: C_XER, a6: C_REG, type_: 66, size: 4},
-	{as: AMOVWZ, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 8, size: 4},
 
 	{as: AMOVFL, a1: C_CREG, a6: C_CREG, type_: 67, size: 4},
 	{as: AMOVFL, a1: C_FPSCR, a6: C_CREG, type_: 73, size: 4},
@@ -349,11 +334,8 @@ var optab = []Optab{
 	{as: AFMOVD, a1: C_FREG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AFMOVD, a1: C_FREG, a6: C_LOREG, type_: 35, size: 8},
 	{as: AFMOVD, a1: C_FREG, a6: C_ADDR, type_: 74, size: 8},
-	{as: AFMOVSX, a1: C_ZOREG, a2: C_REG, a6: C_FREG, type_: 45, size: 4},
 	{as: AFMOVSX, a1: C_ZOREG, a6: C_FREG, type_: 45, size: 4},
-	{as: AFMOVSX, a1: C_FREG, a2: C_REG, a6: C_ZOREG, type_: 44, size: 4},
 	{as: AFMOVSX, a1: C_FREG, a6: C_ZOREG, type_: 44, size: 4},
-	{as: AFMOVSZ, a1: C_ZOREG, a2: C_REG, a6: C_FREG, type_: 45, size: 4},
 	{as: AFMOVSZ, a1: C_ZOREG, a6: C_FREG, type_: 45, size: 4},
 	{as: ASYNC, type_: 46, size: 4},
 	{as: AWORD, a1: C_LCON, type_: 40, size: 4},
-- 
GitLab


From e8700f1ce6f4103207f470cce443f04377baa600 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Sun, 8 Nov 2020 15:18:35 -0500
Subject: [PATCH 1212/2400] cmd/compile, cmd/link: use weak reference in itab

When converting a type T to a non-empty interface I, we build the
itab which contains the code pointers of the methods. Currently,
this brings those methods live (if the itab is live), even if the
interface method is never used. This CL changes the itab to use
weak references, so the methods can be pruned if not otherwise
live.

Fixes #42421.

Change-Id: Iee5de2ba11d603c5a102a2ba60440d839a7f9702
Reviewed-on: https://go-review.googlesource.com/c/go/+/268479
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/objw/objw.go                      | 7 +++++++
 src/cmd/compile/internal/reflectdata/reflect.go            | 2 +-
 src/cmd/internal/obj/data.go                               | 7 +++++++
 src/cmd/internal/objabi/reloctype.go                       | 1 +
 src/cmd/link/internal/ld/data.go                           | 7 +++++++
 src/cmd/link/internal/ld/deadcode.go                       | 3 +++
 src/cmd/link/internal/ld/lib.go                            | 3 +++
 src/cmd/link/internal/ld/testdata/deadcode/ifacemethod4.go | 2 ++
 src/runtime/iface.go                                       | 7 +++++++
 src/runtime/type.go                                        | 2 +-
 10 files changed, 39 insertions(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/objw/objw.go b/src/cmd/compile/internal/objw/objw.go
index 50ce7b747d..ed5ad754d9 100644
--- a/src/cmd/compile/internal/objw/objw.go
+++ b/src/cmd/compile/internal/objw/objw.go
@@ -46,6 +46,13 @@ func SymPtr(s *obj.LSym, off int, x *obj.LSym, xoff int) int {
 	return off
 }
 
+func SymPtrWeak(s *obj.LSym, off int, x *obj.LSym, xoff int) int {
+	off = int(types.Rnd(int64(off), int64(types.PtrSize)))
+	s.WriteWeakAddr(base.Ctxt, int64(off), types.PtrSize, x, int64(xoff))
+	off += types.PtrSize
+	return off
+}
+
 func SymPtrOff(s *obj.LSym, off int, x *obj.LSym) int {
 	s.WriteOff(base.Ctxt, int64(off), x, 0)
 	off += 4
diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index 0e1de35887..4c974ea324 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -1338,7 +1338,7 @@ func WriteTabs() {
 		o = objw.Uint32(i.lsym, o, types.TypeHash(i.t)) // copy of type hash
 		o += 4                                          // skip unused field
 		for _, fn := range genfun(i.t, i.itype) {
-			o = objw.SymPtr(i.lsym, o, fn, 0) // method pointer for each method
+			o = objw.SymPtrWeak(i.lsym, o, fn, 0) // method pointer for each method
 		}
 		// Nothing writes static itabs, so they are read only.
 		objw.Global(i.lsym, int32(o), int16(obj.DUPOK|obj.RODATA))
diff --git a/src/cmd/internal/obj/data.go b/src/cmd/internal/obj/data.go
index f32e07acfe..bcba53c3a4 100644
--- a/src/cmd/internal/obj/data.go
+++ b/src/cmd/internal/obj/data.go
@@ -135,6 +135,13 @@ func (s *LSym) WriteAddr(ctxt *Link, off int64, siz int, rsym *LSym, roff int64)
 	s.writeAddr(ctxt, off, siz, rsym, roff, objabi.R_ADDR)
 }
 
+// WriteWeakAddr writes an address of size siz into s at offset off.
+// rsym and roff specify the relocation for the address.
+// This is a weak reference.
+func (s *LSym) WriteWeakAddr(ctxt *Link, off int64, siz int, rsym *LSym, roff int64) {
+	s.writeAddr(ctxt, off, siz, rsym, roff, objabi.R_WEAKADDR)
+}
+
 // WriteCURelativeAddr writes a pointer-sized address into s at offset off.
 // rsym and roff specify the relocation for the address which will be
 // resolved by the linker to an offset from the DW_AT_low_pc attribute of
diff --git a/src/cmd/internal/objabi/reloctype.go b/src/cmd/internal/objabi/reloctype.go
index 217d8565f2..b241127b4e 100644
--- a/src/cmd/internal/objabi/reloctype.go
+++ b/src/cmd/internal/objabi/reloctype.go
@@ -258,6 +258,7 @@ const (
 	// reachable.
 	R_WEAK = -1 << 15
 
+	R_WEAKADDR    = R_WEAK | R_ADDR
 	R_WEAKADDROFF = R_WEAK | R_ADDROFF
 )
 
diff --git a/src/cmd/link/internal/ld/data.go b/src/cmd/link/internal/ld/data.go
index 6de2d893ae..b909526de8 100644
--- a/src/cmd/link/internal/ld/data.go
+++ b/src/cmd/link/internal/ld/data.go
@@ -306,6 +306,10 @@ func (st *relocSymState) relocsym(s loader.Sym, P []byte) {
 				log.Fatalf("cannot handle R_TLS_IE (sym %s) when linking internally", ldr.SymName(s))
 			}
 		case objabi.R_ADDR:
+			if weak && !ldr.AttrReachable(rs) {
+				// Redirect it to runtime.unreachableMethod, which will throw if called.
+				rs = syms.unreachableMethod
+			}
 			if target.IsExternal() {
 				nExtReloc++
 
@@ -586,6 +590,9 @@ func extreloc(ctxt *Link, ldr *loader.Loader, s loader.Sym, r loader.Reloc) (loa
 	case objabi.R_ADDR:
 		// set up addend for eventual relocation via outer symbol.
 		rs := ldr.ResolveABIAlias(r.Sym())
+		if r.Weak() && !ldr.AttrReachable(rs) {
+			rs = ctxt.ArchSyms.unreachableMethod
+		}
 		rs, off := FoldSubSymbolOffset(ldr, rs)
 		rr.Xadd = r.Add() + off
 		rr.Xsym = rs
diff --git a/src/cmd/link/internal/ld/deadcode.go b/src/cmd/link/internal/ld/deadcode.go
index 33468b429c..9b04e2cddc 100644
--- a/src/cmd/link/internal/ld/deadcode.go
+++ b/src/cmd/link/internal/ld/deadcode.go
@@ -64,6 +64,9 @@ func (d *deadcodePass) init() {
 			}
 		}
 		names = append(names, *flagEntrySymbol)
+		// runtime.unreachableMethod is a function that will throw if called.
+		// We redirect unreachable methods to it.
+		names = append(names, "runtime.unreachableMethod")
 		if !d.ctxt.linkShared && d.ctxt.BuildMode != BuildModePlugin {
 			// runtime.buildVersion and runtime.modinfo are referenced in .go.buildinfo section
 			// (see function buildinfo in data.go). They should normally be reachable from the
diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index d136cbad80..c80c29a6a8 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -118,6 +118,8 @@ type ArchSyms struct {
 	Dynamic loader.Sym
 	DynSym  loader.Sym
 	DynStr  loader.Sym
+
+	unreachableMethod loader.Sym
 }
 
 // mkArchSym is a helper for setArchSyms, to set up a special symbol.
@@ -142,6 +144,7 @@ func (ctxt *Link) setArchSyms() {
 	ctxt.mkArchSym(".dynamic", 0, &ctxt.Dynamic)
 	ctxt.mkArchSym(".dynsym", 0, &ctxt.DynSym)
 	ctxt.mkArchSym(".dynstr", 0, &ctxt.DynStr)
+	ctxt.mkArchSym("runtime.unreachableMethod", sym.SymVerABIInternal, &ctxt.unreachableMethod)
 
 	if ctxt.IsPPC64() {
 		ctxt.mkArchSym("TOC", 0, &ctxt.TOC)
diff --git a/src/cmd/link/internal/ld/testdata/deadcode/ifacemethod4.go b/src/cmd/link/internal/ld/testdata/deadcode/ifacemethod4.go
index 52ee2e3d86..4af47ad1fa 100644
--- a/src/cmd/link/internal/ld/testdata/deadcode/ifacemethod4.go
+++ b/src/cmd/link/internal/ld/testdata/deadcode/ifacemethod4.go
@@ -10,6 +10,7 @@ package main
 
 type T int
 
+//go:noinline
 func (T) M() {}
 
 type I interface{ M() }
@@ -20,4 +21,5 @@ var pp *I
 func main() {
 	p = new(T)  // use type T
 	pp = new(I) // use type I
+	*pp = *p    // convert T to I, build itab
 }
diff --git a/src/runtime/iface.go b/src/runtime/iface.go
index 02b18dabff..cd5fead999 100644
--- a/src/runtime/iface.go
+++ b/src/runtime/iface.go
@@ -553,3 +553,10 @@ var staticuint64s = [...]uint64{
 	0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
 	0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
 }
+
+// The linker redirects a reference of a method that it determined
+// unreachable to a reference to this function, so it will throw if
+// ever called.
+func unreachableMethod() {
+	throw("unreachable method called. linker bug?")
+}
diff --git a/src/runtime/type.go b/src/runtime/type.go
index 18fc4bbfad..c0911b1dcb 100644
--- a/src/runtime/type.go
+++ b/src/runtime/type.go
@@ -262,7 +262,7 @@ func (t *_type) textOff(off textOff) unsafe.Pointer {
 	if off == -1 {
 		// -1 is the sentinel value for unreachable code.
 		// See cmd/link/internal/ld/data.go:relocsym.
-		return unsafe.Pointer(^uintptr(0))
+		return unsafe.Pointer(funcPC(unreachableMethod))
 	}
 	base := uintptr(unsafe.Pointer(t))
 	var md *moduledata
-- 
GitLab


From 975b097307621ad32217946f9732d17101d72aaf Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Tue, 23 Mar 2021 09:51:43 -0500
Subject: [PATCH 1213/2400] cmd/link: separate elf addend size from reloc size

The size of the field may be smaller than the addend,
such is the case with R_PPC64_TOC16_HA/LO and similar
relocations.

Add an extra return value to ldelf.relSize to account for
addend size which may be larger than the relocated field,
and fix the related ppc64 relocations.

Such relocs can be seen in large PIC blobs such
as the ppc64le race detector included with golang.

Change-Id: I457186fea5d0ec5572b9bbf79bb7fa21a36cc1b0
Reviewed-on: https://go-review.googlesource.com/c/go/+/303990
Run-TryBot: Paul Murphy <murp@ibm.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Lynn Boger <laboger@linux.vnet.ibm.com>
---
 src/cmd/link/internal/loadelf/ldelf.go | 47 ++++++++++++++------------
 1 file changed, 26 insertions(+), 21 deletions(-)

diff --git a/src/cmd/link/internal/loadelf/ldelf.go b/src/cmd/link/internal/loadelf/ldelf.go
index e373a6e0b4..28284e9de0 100644
--- a/src/cmd/link/internal/loadelf/ldelf.go
+++ b/src/cmd/link/internal/loadelf/ldelf.go
@@ -755,7 +755,7 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, f *bio.Reader,
 			}
 
 			rType := objabi.ElfRelocOffset + objabi.RelocType(relocType)
-			rSize, err := relSize(arch, pn, uint32(relocType))
+			rSize, addendSize, err := relSize(arch, pn, uint32(relocType))
 			if err != nil {
 				return nil, 0, err
 			}
@@ -772,10 +772,10 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, f *bio.Reader,
 				}
 			}
 
-			if rSize == 2 {
+			if addendSize == 2 {
 				rAdd = int64(int16(rAdd))
 			}
-			if rSize == 4 {
+			if addendSize == 4 {
 				rAdd = int64(int32(rAdd))
 			}
 
@@ -947,7 +947,10 @@ func readelfsym(newSym, lookup func(string, int) loader.Sym, l *loader.Loader, a
 	return nil
 }
 
-func relSize(arch *sys.Arch, pn string, elftype uint32) (uint8, error) {
+// Return the size of the relocated field, and the size of the addend as the first
+// and second values. Note, the addend may be larger than the relocation field in
+// some cases when a relocated value is split across multiple relocations.
+func relSize(arch *sys.Arch, pn string, elftype uint32) (uint8, uint8, error) {
 	// TODO(mdempsky): Replace this with a struct-valued switch statement
 	// once golang.org/issue/15164 is fixed or found to not impair cmd/link
 	// performance.
@@ -966,7 +969,7 @@ func relSize(arch *sys.Arch, pn string, elftype uint32) (uint8, error) {
 
 	switch uint32(arch.Family) | elftype<<16 {
 	default:
-		return 0, fmt.Errorf("%s: unknown relocation type %d; compiled without -fpic?", pn, elftype)
+		return 0, 0, fmt.Errorf("%s: unknown relocation type %d; compiled without -fpic?", pn, elftype)
 
 	case MIPS | uint32(elf.R_MIPS_HI16)<<16,
 		MIPS | uint32(elf.R_MIPS_LO16)<<16,
@@ -990,26 +993,18 @@ func relSize(arch *sys.Arch, pn string, elftype uint32) (uint8, error) {
 		MIPS64 | uint32(elf.R_MIPS_GPREL32)<<16,
 		MIPS64 | uint32(elf.R_MIPS_64)<<16,
 		MIPS64 | uint32(elf.R_MIPS_GOT_DISP)<<16:
-		return 4, nil
+		return 4, 4, nil
 
 	case S390X | uint32(elf.R_390_8)<<16:
-		return 1, nil
+		return 1, 1, nil
 
 	case PPC64 | uint32(elf.R_PPC64_TOC16)<<16,
-		PPC64 | uint32(elf.R_PPC64_TOC16_LO)<<16,
-		PPC64 | uint32(elf.R_PPC64_TOC16_HI)<<16,
-		PPC64 | uint32(elf.R_PPC64_TOC16_HA)<<16,
-		PPC64 | uint32(elf.R_PPC64_TOC16_DS)<<16,
-		PPC64 | uint32(elf.R_PPC64_TOC16_LO_DS)<<16,
-		PPC64 | uint32(elf.R_PPC64_REL16_LO)<<16,
-		PPC64 | uint32(elf.R_PPC64_REL16_HI)<<16,
-		PPC64 | uint32(elf.R_PPC64_REL16_HA)<<16,
 		S390X | uint32(elf.R_390_16)<<16,
 		S390X | uint32(elf.R_390_GOT16)<<16,
 		S390X | uint32(elf.R_390_PC16)<<16,
 		S390X | uint32(elf.R_390_PC16DBL)<<16,
 		S390X | uint32(elf.R_390_PLT16DBL)<<16:
-		return 2, nil
+		return 2, 2, nil
 
 	case ARM | uint32(elf.R_ARM_ABS32)<<16,
 		ARM | uint32(elf.R_ARM_GOT32)<<16,
@@ -1057,7 +1052,7 @@ func relSize(arch *sys.Arch, pn string, elftype uint32) (uint8, error) {
 		S390X | uint32(elf.R_390_PLT32DBL)<<16,
 		S390X | uint32(elf.R_390_GOTPCDBL)<<16,
 		S390X | uint32(elf.R_390_GOTENT)<<16:
-		return 4, nil
+		return 4, 4, nil
 
 	case AMD64 | uint32(elf.R_X86_64_64)<<16,
 		AMD64 | uint32(elf.R_X86_64_PC64)<<16,
@@ -1072,11 +1067,11 @@ func relSize(arch *sys.Arch, pn string, elftype uint32) (uint8, error) {
 		S390X | uint32(elf.R_390_PC64)<<16,
 		S390X | uint32(elf.R_390_GOT64)<<16,
 		S390X | uint32(elf.R_390_PLT64)<<16:
-		return 8, nil
+		return 8, 8, nil
 
 	case RISCV64 | uint32(elf.R_RISCV_RVC_BRANCH)<<16,
 		RISCV64 | uint32(elf.R_RISCV_RVC_JUMP)<<16:
-		return 2, nil
+		return 2, 2, nil
 
 	case RISCV64 | uint32(elf.R_RISCV_32)<<16,
 		RISCV64 | uint32(elf.R_RISCV_BRANCH)<<16,
@@ -1088,12 +1083,22 @@ func relSize(arch *sys.Arch, pn string, elftype uint32) (uint8, error) {
 		RISCV64 | uint32(elf.R_RISCV_PCREL_LO12_I)<<16,
 		RISCV64 | uint32(elf.R_RISCV_PCREL_LO12_S)<<16,
 		RISCV64 | uint32(elf.R_RISCV_RELAX)<<16:
-		return 4, nil
+		return 4, 4, nil
 
 	case RISCV64 | uint32(elf.R_RISCV_64)<<16,
 		RISCV64 | uint32(elf.R_RISCV_CALL)<<16,
 		RISCV64 | uint32(elf.R_RISCV_CALL_PLT)<<16:
-		return 8, nil
+		return 8, 8, nil
+
+	case PPC64 | uint32(elf.R_PPC64_TOC16_LO)<<16,
+		PPC64 | uint32(elf.R_PPC64_TOC16_HI)<<16,
+		PPC64 | uint32(elf.R_PPC64_TOC16_HA)<<16,
+		PPC64 | uint32(elf.R_PPC64_TOC16_DS)<<16,
+		PPC64 | uint32(elf.R_PPC64_TOC16_LO_DS)<<16,
+		PPC64 | uint32(elf.R_PPC64_REL16_LO)<<16,
+		PPC64 | uint32(elf.R_PPC64_REL16_HI)<<16,
+		PPC64 | uint32(elf.R_PPC64_REL16_HA)<<16:
+		return 2, 4, nil
 	}
 }
 
-- 
GitLab


From 0e31de280f8593dcee2bedb120eb929503785abf Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Wed, 24 Mar 2021 11:02:46 -0400
Subject: [PATCH 1214/2400] math/big: don't require runtime.(*Frame).Next
 symbol present

I don't know why the test requires runtime.(*Frame).Next symbol
present in the binary under test. I assume it is just some
sanity check? With CL 268479 runtime.(*Frame).Next can be pruned
by the linker. Replace it with runtime.main which should always
be present.

May fix the longtest builders.

Change-Id: Id3104c058b2786057ff58be41b1d35aeac2f3073
Reviewed-on: https://go-review.googlesource.com/c/go/+/304431
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/math/big/link_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/math/big/link_test.go b/src/math/big/link_test.go
index 42f9cefca0..6e33aa5e5e 100644
--- a/src/math/big/link_test.go
+++ b/src/math/big/link_test.go
@@ -42,7 +42,7 @@ func main() {}
 	if err != nil {
 		t.Fatalf("nm: %v, %s", err, nm)
 	}
-	const want = "runtime.(*Frames).Next"
+	const want = "runtime.main"
 	if !bytes.Contains(nm, []byte(want)) {
 		// Test the test.
 		t.Errorf("expected symbol %q not found", want)
-- 
GitLab


From 6f62f852efca58b99fc421fdbb405f2620a46e0f Mon Sep 17 00:00:00 2001
From: Damien Neil <dneil@google.com>
Date: Fri, 19 Mar 2021 22:01:10 -0700
Subject: [PATCH 1215/2400] net/http: fix request cancellation race

When a in-flight request is cancelled, (*Transport).cancelRequest is
called. The cancelRequest function looks up and invokes a cancel
function before returning. The function lookup happens with reqMu held,
but the cancel function is invoked after dropping the mutex.

If two calls to cancelRequest are made at the same time, it is possible
for one to return before the cancel function has been invoked.

This race causes flakiness in TestClientTimeoutCancel:
  - The test cancels a request while a read from the request body is
    pending.
  - One goroutine calls (*Transport).cancelRequest. This goroutine
    will eventually invoke the cancel function.
  - Another goroutine calls (*Transport).cancelRequest and closes the
    request body. The cancelRequest call returns without invoking
    the cancel function.
  - The read from the request body returns an error. The reader
    checks to see if the request has been canceled, but concludes
    that it has not (because the cancel function hasn't been invoked
    yet).

To avoid this race condition, call the cancel function with the
transport reqMu mutex held.

Calling the cancel function with the mutex held does not introduce any
deadlocks that I can see. The only non-noop request cancel functions
are:

A send to a buffered channel:
https://go.googlesource.com/go/+/refs/heads/master/src/net/http/transport.go#1362

The (*persistConn).cancelRequest function, which does not cancel any
other requests:
https://go.googlesource.com/go/+/refs/heads/master/src/net/http/transport.go#2526

Fixes #34658.

Change-Id: I1b83dce9b0b1d5cf7c7da7dbd03d0fc90c9f5038
Reviewed-on: https://go-review.googlesource.com/c/go/+/303489
Trust: Damien Neil <dneil@google.com>
Run-TryBot: Damien Neil <dneil@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/net/http/transport.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/net/http/transport.go b/src/net/http/transport.go
index 6358c3897e..f30ca881ac 100644
--- a/src/net/http/transport.go
+++ b/src/net/http/transport.go
@@ -786,10 +786,12 @@ func (t *Transport) CancelRequest(req *Request) {
 // Cancel an in-flight request, recording the error value.
 // Returns whether the request was canceled.
 func (t *Transport) cancelRequest(key cancelKey, err error) bool {
+	// This function must not return until the cancel func has completed.
+	// See: https://golang.org/issue/34658
 	t.reqMu.Lock()
+	defer t.reqMu.Unlock()
 	cancel := t.reqCanceler[key]
 	delete(t.reqCanceler, key)
-	t.reqMu.Unlock()
 	if cancel != nil {
 		cancel(err)
 	}
-- 
GitLab


From fd5e0bd385660275a8049a2499e0bbbffd465bc8 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Wed, 24 Mar 2021 11:19:19 -0400
Subject: [PATCH 1216/2400] cmd/link: mangle function names with ABI on PE

When ABI wrappers are used, we may end up with two functions
having the same name. On ELF we mangle the name with ABI. Do the
same for PE.

TODO: other platforms?

Change-Id: If89f214a6286bc28c062c1aa1bad78dc353a9231
Reviewed-on: https://go-review.googlesource.com/c/go/+/304432
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/ld/pe.go     |  2 +
 src/cmd/link/internal/ld/symtab.go | 71 ++++++++++++++++--------------
 2 files changed, 40 insertions(+), 33 deletions(-)

diff --git a/src/cmd/link/internal/ld/pe.go b/src/cmd/link/internal/ld/pe.go
index a0aba866dc..b590d5082d 100644
--- a/src/cmd/link/internal/ld/pe.go
+++ b/src/cmd/link/internal/ld/pe.go
@@ -694,6 +694,8 @@ func (f *peFile) writeSymbols(ctxt *Link) {
 			name = "_" + name
 		}
 
+		name = mangleABIName(ldr, s, name)
+
 		var peSymType uint16
 		if ctxt.IsExternal() {
 			peSymType = IMAGE_SYM_TYPE_NULL
diff --git a/src/cmd/link/internal/ld/symtab.go b/src/cmd/link/internal/ld/symtab.go
index f48822a72e..bd8e4cb4bd 100644
--- a/src/cmd/link/internal/ld/symtab.go
+++ b/src/cmd/link/internal/ld/symtab.go
@@ -104,39 +104,7 @@ func putelfsym(ctxt *Link, x loader.Sym, typ elf.SymType, curbind elf.SymBind) {
 	}
 
 	sname := ldr.SymExtname(x)
-
-	// For functions with ABI wrappers, we have to make sure that we
-	// don't wind up with two elf symbol table entries with the same
-	// name (since this will generated an error from the external
-	// linker). In the CgoExportStatic case, we want the ABI0 symbol
-	// to have the primary symbol table entry (since it's going to be
-	// called from C), so we rename the ABIInternal symbol. In all
-	// other cases, we rename the ABI0 symbol, since we want
-	// cross-load-module calls to target ABIInternal.
-	//
-	// TODO: generalize this for non-ELF (put the rename code in the
-	// loader, and store the rename result in SymExtname).
-	//
-	// TODO: avoid the ldr.Lookup calls below by instead using an aux
-	// sym or marker relocation to associate the wrapper with the
-	// wrapped function.
-	//
-	if objabi.Experiment.RegabiWrappers {
-		if !ldr.IsExternal(x) && ldr.SymType(x) == sym.STEXT {
-			// First case
-			if ldr.SymVersion(x) == sym.SymVerABIInternal {
-				if s2 := ldr.Lookup(sname, sym.SymVerABI0); s2 != 0 && ldr.AttrCgoExportStatic(s2) && ldr.SymType(s2) == sym.STEXT {
-					sname = sname + ".abiinternal"
-				}
-			}
-			// Second case
-			if ldr.SymVersion(x) == sym.SymVerABI0 && !ldr.AttrCgoExportStatic(x) {
-				if s2 := ldr.Lookup(sname, sym.SymVerABIInternal); s2 != 0 && ldr.SymType(s2) == sym.STEXT {
-					sname = sname + ".abi0"
-				}
-			}
-		}
-	}
+	sname = mangleABIName(ldr, x, sname)
 
 	// One pass for each binding: elf.STB_LOCAL, elf.STB_GLOBAL,
 	// maybe one day elf.STB_WEAK.
@@ -863,3 +831,40 @@ func setCarrierSize(typ sym.SymKind, sz int64) {
 func isStaticTmp(name string) bool {
 	return strings.Contains(name, "."+obj.StaticNamePref)
 }
+
+// Mangle function name with ABI information.
+func mangleABIName(ldr *loader.Loader, x loader.Sym, name string) string {
+	// For functions with ABI wrappers, we have to make sure that we
+	// don't wind up with two elf symbol table entries with the same
+	// name (since this will generated an error from the external
+	// linker). In the CgoExportStatic case, we want the ABI0 symbol
+	// to have the primary symbol table entry (since it's going to be
+	// called from C), so we rename the ABIInternal symbol. In all
+	// other cases, we rename the ABI0 symbol, since we want
+	// cross-load-module calls to target ABIInternal.
+	//
+	// TODO: this is currently only used on ELF and PE. Other platforms?
+	//
+	// TODO: avoid the ldr.Lookup calls below by instead using an aux
+	// sym or marker relocation to associate the wrapper with the
+	// wrapped function.
+	//
+	if !objabi.Experiment.RegabiWrappers {
+		return name
+	}
+	if !ldr.IsExternal(x) && ldr.SymType(x) == sym.STEXT {
+		// First case
+		if ldr.SymVersion(x) == sym.SymVerABIInternal {
+			if s2 := ldr.Lookup(name, sym.SymVerABI0); s2 != 0 && ldr.AttrCgoExportStatic(s2) && ldr.SymType(s2) == sym.STEXT {
+				name = name + ".abiinternal"
+			}
+		}
+		// Second case
+		if ldr.SymVersion(x) == sym.SymVerABI0 && !ldr.AttrCgoExportStatic(x) {
+			if s2 := ldr.Lookup(name, sym.SymVerABIInternal); s2 != 0 && ldr.SymType(s2) == sym.STEXT {
+				name = name + ".abi0"
+			}
+		}
+	}
+	return name
+}
-- 
GitLab


From 771c57e68ed5ef2bbb0eafc0d48419f59d143932 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Tue, 23 Mar 2021 14:48:47 -0700
Subject: [PATCH 1217/2400] cmd/compile: disable shortcircuit optimization for
 intertwined phi values

We need to be careful that when doing value graph surgery, we not
re-substitute a value that has already been substituted. That can lead
to confusing a previous iteration's value with the current iteration's
value.

The simple fix in this CL just aborts the optimization if it detects
intertwined phis (a phi which is the argument to another phi). It
might be possible to keep the optimization with a more complicated
CL, but:
  1) This CL is clearly safe to backport.
  2) There were no instances of this abort triggering in
     all.bash, prior to the test introduced in this CL.

Fixes #45175

Change-Id: I2411dca03948653c053291f6829a76bec0c32330
Reviewed-on: https://go-review.googlesource.com/c/go/+/304251
Trust: Keith Randall <khr@golang.org>
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>
---
 src/cmd/compile/internal/ssa/shortcircuit.go | 18 ++++++++++++
 test/fixedbugs/issue45175.go                 | 29 ++++++++++++++++++++
 2 files changed, 47 insertions(+)
 create mode 100644 test/fixedbugs/issue45175.go

diff --git a/src/cmd/compile/internal/ssa/shortcircuit.go b/src/cmd/compile/internal/ssa/shortcircuit.go
index c72c86a67e..29abf3c591 100644
--- a/src/cmd/compile/internal/ssa/shortcircuit.go
+++ b/src/cmd/compile/internal/ssa/shortcircuit.go
@@ -138,6 +138,24 @@ func shortcircuitBlock(b *Block) bool {
 	if len(b.Values) != nval+nOtherPhi {
 		return false
 	}
+	if nOtherPhi > 0 {
+		// Check for any phi which is the argument of another phi.
+		// These cases are tricky, as substitutions done by replaceUses
+		// are no longer trivial to do in any ordering. See issue 45175.
+		m := make(map[*Value]bool, 1+nOtherPhi)
+		for _, v := range b.Values {
+			if v.Op == OpPhi {
+				m[v] = true
+			}
+		}
+		for v := range m {
+			for _, a := range v.Args {
+				if a != v && m[a] {
+					return false
+				}
+			}
+		}
+	}
 
 	// Locate index of first const phi arg.
 	cidx := -1
diff --git a/test/fixedbugs/issue45175.go b/test/fixedbugs/issue45175.go
new file mode 100644
index 0000000000..02dfe8a0a9
--- /dev/null
+++ b/test/fixedbugs/issue45175.go
@@ -0,0 +1,29 @@
+// run
+
+// Copyright 2021 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
+
+//go:noinline
+func f(c bool) int {
+	b := true
+	x := 0
+	y := 1
+	for b {
+		b = false
+		y = x
+		x = 2
+		if c {
+			return 3
+		}
+	}
+	return y
+}
+
+func main() {
+	if got := f(false); got != 0 {
+		panic(got)
+	}
+}
-- 
GitLab


From fef5a153961fc314499f3c3208e001593f95a8e6 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Thu, 18 Mar 2021 17:03:50 +0000
Subject: [PATCH 1218/2400] runtime: bypass ABI wrapper when calling needm on
 Windows

On Windows, when calling into needm in cgocallback on a new thread that
is unknown to the Go runtime, we currently call through an ABI wrapper.
The ABI wrapper tries to restore the G register from TLS.

On other platforms, TLS is set up just enough that the wrapper will
simply load a nil g from TLS, but on Windows TLS isn't set up at all, so
there's nowhere for the wrapper to load from.

So, bypass the wrapper in the call to needm. needm takes no arguments
and returns no results so there are no special ABI considerations,
except that we must clear X15 which is used as a zero register in Go
code (a function normally performed by the ABI wrapper). needm is also
otherwise already special and carefully crafted to avoid doing anything
that would require a valid G or M, at least until it is able to create
one.

While we're here, this change simplifies setg so that it doesn't set up
TLS on Windows and instead provides an OS-specific osSetupTLS to do
that.

The result of this is that setg(nil) no longer clears the TLS space
pointer on Windows. There's exactly one place this is used (dropm) where
it doesn't matter anymore, and an empty TLS means that setg's wrapper
will crash on the return path. Another result is that the G slot in the
TLS will be properly cleared, however, which isn't true today.

For #40724.

Change-Id: I65c3d924a3b16abe667b06fd91d467d6d5da31d7
Reviewed-on: https://go-review.googlesource.com/c/go/+/303070
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/asm_amd64.s          | 33 ++++++++++++++++++++------------
 src/runtime/proc.go              |  4 ++++
 src/runtime/sys_windows_amd64.s  |  8 ++++++++
 src/runtime/tls_stub.go          | 11 +++++++++++
 src/runtime/tls_windows_amd64.go | 10 ++++++++++
 5 files changed, 54 insertions(+), 12 deletions(-)
 create mode 100644 src/runtime/tls_stub.go
 create mode 100644 src/runtime/tls_windows_amd64.go

diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index ab3f639929..b9efad0681 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -796,7 +796,18 @@ TEXT ·cgocallback(SB),NOSPLIT,$24-24
 	MOVQ	BX, savedm-8(SP)	// saved copy of oldm
 	JMP	havem
 needm:
-	MOVQ    $runtime·needm(SB), AX
+	// On some platforms (Windows) we cannot call needm through
+	// an ABI wrapper because there's no TLS set up, and the ABI
+	// wrapper will try to restore the G register (R14) from TLS.
+	// Clear X15 because Go expects it and we're not calling
+	// through a wrapper, but otherwise avoid setting the G
+	// register in the wrapper and call needm directly. It
+	// takes no arguments and doesn't return any values so
+	// there's no need to handle that. Clear R14 so that there's
+	// a bad value in there, in case needm tries to use it.
+	XORPS	X15, X15
+	XORQ    R14, R14
+	MOVQ	$runtime·needm<ABIInternal>(SB), AX
 	CALL	AX
 	MOVQ	$0, savedm-8(SP) // dropm on return
 	get_tls(CX)
@@ -890,9 +901,17 @@ havem:
 	// for the duration of the call. Since the call is over, return it with dropm.
 	MOVQ	savedm-8(SP), BX
 	CMPQ	BX, $0
-	JNE 3(PC)
+	JNE	done
 	MOVQ	$runtime·dropm(SB), AX
 	CALL	AX
+#ifdef GOOS_windows
+	// We need to clear the TLS pointer in case the next
+	// thread that comes into Go tries to reuse that space
+	// but uses the same M.
+	XORQ	DI, DI
+	CALL	runtime·settls(SB)
+#endif
+done:
 
 	// Done!
 	RET
@@ -901,16 +920,6 @@ havem:
 // set g. for use by needm.
 TEXT runtime·setg(SB), NOSPLIT, $0-8
 	MOVQ	gg+0(FP), BX
-#ifdef GOOS_windows
-	CMPQ	BX, $0
-	JNE	settls
-	MOVQ	$0, 0x28(GS)
-	RET
-settls:
-	MOVQ	g_m(BX), AX
-	LEAQ	m_tls(AX), AX
-	MOVQ	AX, 0x28(GS)
-#endif
 	get_tls(CX)
 	MOVQ	BX, g(CX)
 	RET
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index a666f86abc..35996b99d7 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -1883,6 +1883,10 @@ func needm() {
 	// Store the original signal mask for use by minit.
 	mp.sigmask = sigmask
 
+	// Install TLS on some platforms (previously setg
+	// would do this if necessary).
+	osSetupTLS(mp)
+
 	// Install g (= m->g0) and set the stack bounds
 	// to match the current stack. We don't actually know
 	// how big the stack is, like we don't know how big any
diff --git a/src/runtime/sys_windows_amd64.s b/src/runtime/sys_windows_amd64.s
index 574def1038..8a91741619 100644
--- a/src/runtime/sys_windows_amd64.s
+++ b/src/runtime/sys_windows_amd64.s
@@ -518,3 +518,11 @@ wall:
 useQPC:
 	JMP	runtime·nowQPC(SB)
 	RET
+
+// func osSetupTLS(mp *m)
+// Setup TLS. for use by needm on Windows.
+TEXT runtime·osSetupTLS(SB),NOSPLIT,$0-8
+	MOVQ	mp+0(FP), AX
+	LEAQ	m_tls(AX), DI
+	CALL	runtime·settls(SB)
+	RET
diff --git a/src/runtime/tls_stub.go b/src/runtime/tls_stub.go
new file mode 100644
index 0000000000..95dafd007c
--- /dev/null
+++ b/src/runtime/tls_stub.go
@@ -0,0 +1,11 @@
+// Copyright 2021 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.
+
+//go:build (windows && !amd64) || !windows
+// +build windows,!amd64 !windows
+
+package runtime
+
+//go:nosplit
+func osSetupTLS(mp *m) {}
diff --git a/src/runtime/tls_windows_amd64.go b/src/runtime/tls_windows_amd64.go
new file mode 100644
index 0000000000..cacaa84496
--- /dev/null
+++ b/src/runtime/tls_windows_amd64.go
@@ -0,0 +1,10 @@
+// Copyright 2021 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 runtime
+
+// osSetupTLS is called by needm to set up TLS for non-Go threads.
+//
+// Defined in assembly.
+func osSetupTLS(mp *m)
-- 
GitLab


From dade83a588feace6af9882500f2282c8a83f54d0 Mon Sep 17 00:00:00 2001
From: Dmitri Shuralyov <dmitshur@golang.org>
Date: Wed, 24 Mar 2021 12:10:22 -0400
Subject: [PATCH 1219/2400] cmd/internal/moddeps: fix false positive when
 $TMPDIR is symlinked

os.Getwd notes that if the current directory can be reached via
multiple paths (due to symbolic links), Getwd may return any one
of them. A way to ensure that the desired path is used is to set
the PWD environment variable pointing to it.

The go generate command has started to update the PWD environment
variable as of CL 287152, which was the missing link previously
resulting in mkwinsyscall misunderstanding whether it's inside
the std lib when symbolic links are involved (issue 44079).

Now all that's left is for us to also set the PWD environment
variable when invoking the go command in the test, so that it
too knows the intended working directory path to use.

Fixes #44080.
Updates #44079.
Updates #43862.

Change-Id: I65c9d19d0979f486800b9b328c9b45a1a3180e81
Reviewed-on: https://go-review.googlesource.com/c/go/+/304449
Trust: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/internal/moddeps/moddeps_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/internal/moddeps/moddeps_test.go b/src/cmd/internal/moddeps/moddeps_test.go
index 78c291e203..62687403ec 100644
--- a/src/cmd/internal/moddeps/moddeps_test.go
+++ b/src/cmd/internal/moddeps/moddeps_test.go
@@ -163,8 +163,8 @@ func TestAllDependencies(t *testing.T) {
 				Env: append(os.Environ(),
 					// Set GOROOT.
 					"GOROOT="+gorootCopyDir,
-					// Explicitly clear PWD and GOROOT_FINAL so that GOROOT=gorootCopyDir is definitely used.
-					"PWD=",
+					// Explicitly override PWD and clear GOROOT_FINAL so that GOROOT=gorootCopyDir is definitely used.
+					"PWD="+filepath.Join(gorootCopyDir, rel),
 					"GOROOT_FINAL=",
 					// Add GOROOTcopy/bin and bundleDir to front of PATH.
 					"PATH="+filepath.Join(gorootCopyDir, "bin")+string(filepath.ListSeparator)+
-- 
GitLab


From 63e9f6d5f022a1149a10ddfcc5801aa19ba33223 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Wed, 24 Mar 2021 13:16:42 -0700
Subject: [PATCH 1220/2400] test: recognize cgo build tag

This requires us to add a fake argument to issue36705.go so that the
test driver will build it with "go run" rather than "go tool compile".

Change-Id: Id08b97d898ee3e9d6c1fbb072a0a9317ed9faedd
Reviewed-on: https://go-review.googlesource.com/c/go/+/304569
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 test/fixedbugs/issue36705.go |  2 +-
 test/run.go                  | 23 +++++++++++++++++------
 2 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/test/fixedbugs/issue36705.go b/test/fixedbugs/issue36705.go
index 83e4136845..d5a0e7fade 100644
--- a/test/fixedbugs/issue36705.go
+++ b/test/fixedbugs/issue36705.go
@@ -1,5 +1,5 @@
 // +build cgo
-// run
+// run fake-arg-to-force-use-of-go-run
 
 // Copyright 2020 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/run.go b/test/run.go
index cc2fcf3518..48115ed18d 100644
--- a/test/run.go
+++ b/test/run.go
@@ -56,6 +56,7 @@ func defaultAllCodeGen() bool {
 
 var (
 	goos, goarch string
+	cgoEnabled   bool
 
 	// dirs are the directories to look for *.go files in.
 	// TODO(bradfitz): just use all directories?
@@ -82,6 +83,10 @@ func main() {
 
 	goos = getenv("GOOS", runtime.GOOS)
 	goarch = getenv("GOARCH", runtime.GOARCH)
+	cgoEnv, err := exec.Command(goTool(), "env", "CGO_ENABLED").Output()
+	if err == nil {
+		cgoEnabled, _ = strconv.ParseBool(strings.TrimSpace(string(cgoEnv)))
+	}
 
 	findExecCmd()
 
@@ -367,9 +372,10 @@ func goDirPackages(longdir string, singlefilepkgs bool) ([][]string, error) {
 }
 
 type context struct {
-	GOOS     string
-	GOARCH   string
-	noOptEnv bool
+	GOOS       string
+	GOARCH     string
+	cgoEnabled bool
+	noOptEnv   bool
 }
 
 // shouldTest looks for build tags in a source file and returns
@@ -391,9 +397,10 @@ func shouldTest(src string, goos, goarch string) (ok bool, whyNot string) {
 		}
 		gcFlags := os.Getenv("GO_GCFLAGS")
 		ctxt := &context{
-			GOOS:     goos,
-			GOARCH:   goarch,
-			noOptEnv: strings.Contains(gcFlags, "-N") || strings.Contains(gcFlags, "-l"),
+			GOOS:       goos,
+			GOARCH:     goarch,
+			cgoEnabled: cgoEnabled,
+			noOptEnv:   strings.Contains(gcFlags, "-N") || strings.Contains(gcFlags, "-l"),
 		}
 
 		words := strings.Fields(line)
@@ -448,6 +455,10 @@ func (ctxt *context) match(name string) bool {
 		}
 	}
 
+	if name == "cgo" && ctxt.cgoEnabled {
+		return true
+	}
+
 	if name == ctxt.GOOS || name == ctxt.GOARCH || name == "gc" {
 		return true
 	}
-- 
GitLab


From 179bcd787e4a5c4cfe475fd6fd33a41d77751113 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Wed, 24 Mar 2021 13:18:13 -0700
Subject: [PATCH 1221/2400] test: only run bug513.go if cgo is enabled

Change-Id: I868eeb79edaba9e3afc1407ae18b89daf7e67037
Reviewed-on: https://go-review.googlesource.com/c/go/+/304570
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 test/fixedbugs/bug513.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/fixedbugs/bug513.go b/test/fixedbugs/bug513.go
index f7604f681c..459a9c396a 100644
--- a/test/fixedbugs/bug513.go
+++ b/test/fixedbugs/bug513.go
@@ -1,5 +1,6 @@
 // run -race -gcflags=all=-d=checkptr=0
 // +build linux,amd64 linux,ppc64le darwin,amd64 freebsd,amd64 netbsd,amd64 windows,amd64
+// +build cgo
 
 // Copyright 2021 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
-- 
GitLab


From 29ed12d4c7e61f6b4cc38d5b3d5eb885294f7878 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Tue, 23 Mar 2021 15:44:46 -0700
Subject: [PATCH 1222/2400] testing: update permitted number of -race
 goroutines

The value 8128 appears to be correct as of 2021-03-23. The value is
determined by the value of kMaxTid currently at

https://github.com/llvm/llvm-project/blob/main/compiler-rt/lib/tsan/rtl/tsan_defs.h#L68

Fixes #45193

Change-Id: If4a30d7dbebd6775bede42f565dc8a741b8b036c
Reviewed-on: https://go-review.googlesource.com/c/go/+/304254
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Dmitry Vyukov <dvyukov@google.com>
---
 src/testing/testing.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/testing/testing.go b/src/testing/testing.go
index 0df6e45ec4..056a8d2879 100644
--- a/src/testing/testing.go
+++ b/src/testing/testing.go
@@ -190,7 +190,7 @@
 //         }
 //     }
 //
-// The race detector kills the program if it exceeds 8192 concurrent goroutines,
+// The race detector kills the program if it exceeds 8128 concurrent goroutines,
 // so use care when running parallel tests with the -race flag set.
 //
 // Run does not return until parallel subtests have completed, providing a way
-- 
GitLab


From e7e0995cba1f57622f593ebd27d4d1a651666c4b Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Tue, 23 Mar 2021 10:19:11 -0700
Subject: [PATCH 1223/2400] cmd/compile:  create/use noder2 transform functions
 for more node types

Pull out the transformation part of the typechecking functions for:
 - assignment statements
 - return statements
 - send statements
 - select statements
 - type conversions
 - normal function/method calls
 - index operations

The transform functions are like the original typechecking functions,
but with all code removed related to:
  - Detecting compile-time errors (already done by types2)
  - Setting the actual type of existing nodes (already done based on
    info from types2)
  - Dealing with untyped constants

Moved all the transformation functions to a separate file, transform.go.

Continuing with the same pattern, we delay transforming a node if it has
any type params in its args, marking it with a typecheck flag of 3, and
do the actual transformation during stenciling.

Assignment statements are tricky, since their transformation must be
delayed if any of the left or right-hands-sides are delayed.

Still to do are:
 - selector expressions (OXDOT)
 - composite literal expressions (OCOMPLIT)
 - builtin function calls

Change-Id: Ie608cadbbc69b40db0067a5536cf707dd974aacc
Reviewed-on: https://go-review.googlesource.com/c/go/+/304049
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/helpers.go   | 129 +----
 src/cmd/compile/internal/noder/stencil.go   |  62 ++-
 src/cmd/compile/internal/noder/stmt.go      |  77 ++-
 src/cmd/compile/internal/noder/transform.go | 523 ++++++++++++++++++++
 src/cmd/compile/internal/noder/validate.go  |  12 +-
 src/cmd/compile/internal/typecheck/expr.go  |   2 +-
 src/cmd/compile/internal/typecheck/subr.go  |   2 +-
 7 files changed, 650 insertions(+), 157 deletions(-)
 create mode 100644 src/cmd/compile/internal/noder/transform.go

diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
index e4a1a54fe8..82428daa4a 100644
--- a/src/cmd/compile/internal/noder/helpers.go
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -67,31 +67,6 @@ func Assert(pos src.XPos, x ir.Node, typ *types.Type) ir.Node {
 	return typed(typ, ir.NewTypeAssertExpr(pos, x, nil))
 }
 
-// transformAdd transforms an addition operation (currently just addition of
-// strings). Equivalent to the "binary operators" case in typecheck.typecheck1.
-func transformAdd(n *ir.BinaryExpr) ir.Node {
-	l := n.X
-	if l.Type().IsString() {
-		var add *ir.AddStringExpr
-		if l.Op() == ir.OADDSTR {
-			add = l.(*ir.AddStringExpr)
-			add.SetPos(n.Pos())
-		} else {
-			add = ir.NewAddStringExpr(n.Pos(), []ir.Node{l})
-		}
-		r := n.Y
-		if r.Op() == ir.OADDSTR {
-			r := r.(*ir.AddStringExpr)
-			add.List.Append(r.List.Take()...)
-		} else {
-			add.List.Append(r)
-		}
-		add.SetType(l.Type())
-		return add
-	}
-	return n
-}
-
 func Binary(pos src.XPos, op ir.Op, typ *types.Type, x, y ir.Node) ir.Node {
 	switch op {
 	case ir.OANDAND, ir.OOROR:
@@ -124,7 +99,9 @@ func Call(pos src.XPos, typ *types.Type, fun ir.Node, args []ir.Node, dots bool)
 			// the type.
 			return typed(typ, n)
 		}
-		return typecheck.Expr(n)
+		n1 := transformConvCall(n)
+		n1.SetTypecheck(1)
+		return n1
 	}
 
 	if fun, ok := fun.(*ir.Name); ok && fun.BuiltinOp != 0 {
@@ -181,6 +158,11 @@ func Call(pos src.XPos, typ *types.Type, fun ir.Node, args []ir.Node, dots bool)
 		}
 	}
 
+	n.Use = ir.CallUseExpr
+	if fun.Type().NumResults() == 0 {
+		n.Use = ir.CallUseStmt
+	}
+
 	if fun.Op() == ir.OXDOT {
 		if !fun.(*ir.SelectorExpr).X.Type().HasTParam() {
 			base.FatalfAt(pos, "Expecting type param receiver in %v", fun)
@@ -192,63 +174,18 @@ func Call(pos src.XPos, typ *types.Type, fun ir.Node, args []ir.Node, dots bool)
 		return n
 	}
 	if fun.Op() != ir.OFUNCINST {
-		// If no type params, do normal typechecking, since we're
-		// still missing some things done by tcCall (mainly
-		// typecheckaste/assignconvfn - implementing assignability of args
-		// to params).  This will convert OCALL to OCALLFUNC.
-		typecheck.Call(n)
+		// If no type params, do the normal call transformations. This
+		// will convert OCALL to OCALLFUNC.
+		transformCall(n)
+		typed(typ, n)
 		return n
 	}
 
 	// Leave the op as OCALL, which indicates the call still needs typechecking.
-	n.Use = ir.CallUseExpr
-	if fun.Type().NumResults() == 0 {
-		n.Use = ir.CallUseStmt
-	}
 	typed(typ, n)
 	return n
 }
 
-// transformCompare transforms a compare operation (currently just equals/not
-// equals). Equivalent to the "comparison operators" case in
-// typecheck.typecheck1, including tcArith.
-func transformCompare(n *ir.BinaryExpr) {
-	if (n.Op() == ir.OEQ || n.Op() == ir.ONE) && !types.Identical(n.X.Type(), n.Y.Type()) {
-		// Comparison is okay as long as one side is assignable to the
-		// other. The only allowed case where the conversion is not CONVNOP is
-		// "concrete == interface". In that case, check comparability of
-		// the concrete type. The conversion allocates, so only do it if
-		// the concrete type is huge.
-		l, r := n.X, n.Y
-		lt, rt := l.Type(), r.Type()
-		converted := false
-		if rt.Kind() != types.TBLANK {
-			aop, _ := typecheck.Assignop(lt, rt)
-			if aop != ir.OXXX {
-				types.CalcSize(lt)
-				if rt.IsInterface() == lt.IsInterface() || lt.Width >= 1<<16 {
-					l = ir.NewConvExpr(base.Pos, aop, rt, l)
-					l.SetTypecheck(1)
-				}
-
-				converted = true
-			}
-		}
-
-		if !converted && lt.Kind() != types.TBLANK {
-			aop, _ := typecheck.Assignop(rt, lt)
-			if aop != ir.OXXX {
-				types.CalcSize(rt)
-				if rt.IsInterface() == lt.IsInterface() || rt.Width >= 1<<16 {
-					r = ir.NewConvExpr(base.Pos, aop, lt, r)
-					r.SetTypecheck(1)
-				}
-			}
-		}
-		n.X, n.Y = l, r
-	}
-}
-
 func Compare(pos src.XPos, typ *types.Type, op ir.Op, x, y ir.Node) ir.Node {
 	n := ir.NewBinaryExpr(pos, op, x, y)
 	if x.Type().HasTParam() || y.Type().HasTParam() {
@@ -330,38 +267,16 @@ func method(typ *types.Type, index int) *types.Field {
 
 func Index(pos src.XPos, typ *types.Type, x, index ir.Node) ir.Node {
 	n := ir.NewIndexExpr(pos, x, index)
-	// TODO(danscales): Temporary fix. Need to separate out the
-	// transformations done by the old typechecker (in tcIndex()), to be
-	// called here or after stenciling.
-	if x.Type().HasTParam() && x.Type().Kind() != types.TMAP &&
-		x.Type().Kind() != types.TSLICE && x.Type().Kind() != types.TARRAY {
-		// Old typechecker will complain if arg is not obviously a slice/array/map.
-		typed(typ, n)
+	if x.Type().HasTParam() {
+		// transformIndex needs to know exact type
+		n.SetType(typ)
+		n.SetTypecheck(3)
 		return n
 	}
-	return typecheck.Expr(n)
-}
-
-// transformSlice transforms a slice operation.  Equivalent to typecheck.tcSlice.
-func transformSlice(n *ir.SliceExpr) {
-	l := n.X
-	if l.Type().IsArray() {
-		addr := typecheck.NodAddr(n.X)
-		addr.SetImplicit(true)
-		typed(types.NewPtr(n.X.Type()), addr)
-		n.X = addr
-		l = addr
-	}
-	t := l.Type()
-	if t.IsString() {
-		n.SetOp(ir.OSLICESTR)
-	} else if t.IsPtr() && t.Elem().IsArray() {
-		if n.Op().IsSlice3() {
-			n.SetOp(ir.OSLICE3ARR)
-		} else {
-			n.SetOp(ir.OSLICEARR)
-		}
-	}
+	typed(typ, n)
+	// transformIndex will modify n.Type() for OINDEXMAP.
+	transformIndex(n)
+	return n
 }
 
 func Slice(pos src.XPos, typ *types.Type, x, low, high, max ir.Node) ir.Node {
@@ -399,7 +314,7 @@ func Unary(pos src.XPos, op ir.Op, x ir.Node) ir.Node {
 
 var one = constant.MakeInt64(1)
 
-func IncDec(pos src.XPos, op ir.Op, x ir.Node) ir.Node {
-	x = typecheck.AssignExpr(x)
+func IncDec(pos src.XPos, op ir.Op, x ir.Node) *ir.AssignOpStmt {
+	assert(x.Type() != nil)
 	return ir.NewAssignOpStmt(pos, op, x, typecheck.DefaultLit(ir.NewBasicLit(pos, one), x.Type()))
 }
diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 1b76bb27c5..ba01f0424b 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -95,10 +95,9 @@ func (g *irgen) stencil() {
 				copy(withRecv[1:], call.Args)
 				call.Args = withRecv
 			}
-			// Do the typechecking of the Call now, which changes OCALL
+			// Transform the Call now, which changes OCALL
 			// to OCALLFUNC and does typecheckaste/assignconvfn.
-			call.SetTypecheck(0)
-			typecheck.Call(call)
+			transformCall(call)
 			modified = true
 		})
 
@@ -372,16 +371,36 @@ func (subst *subster) node(n ir.Node) ir.Node {
 			// their instantiated type was known.
 			if typecheck.IsCmp(x.Op()) {
 				transformCompare(m.(*ir.BinaryExpr))
-				m.SetTypecheck(1)
-			} else if x.Op() == ir.OSLICE || x.Op() == ir.OSLICE3 {
-				transformSlice(m.(*ir.SliceExpr))
-				m.SetTypecheck(1)
-			} else if x.Op() == ir.OADD {
-				m = transformAdd(m.(*ir.BinaryExpr))
-				m.SetTypecheck(1)
 			} else {
-				base.Fatalf("Unexpected node with Typecheck() == 3")
+				switch x.Op() {
+				case ir.OSLICE:
+				case ir.OSLICE3:
+					transformSlice(m.(*ir.SliceExpr))
+
+				case ir.OADD:
+					m = transformAdd(m.(*ir.BinaryExpr))
+
+				case ir.OINDEX:
+					transformIndex(m.(*ir.IndexExpr))
+
+				case ir.OAS2:
+					as2 := m.(*ir.AssignListStmt)
+					transformAssign(as2, as2.Lhs, as2.Rhs)
+
+				case ir.OAS:
+					as := m.(*ir.AssignStmt)
+					lhs, rhs := []ir.Node{as.X}, []ir.Node{as.Y}
+					transformAssign(as, lhs, rhs)
+
+				case ir.OASOP:
+					as := m.(*ir.AssignOpStmt)
+					transformCheckAssign(as, as.X)
+
+				default:
+					base.Fatalf("Unexpected node with Typecheck() == 3")
+				}
 			}
+			m.SetTypecheck(1)
 		}
 
 		switch x.Op() {
@@ -415,26 +434,25 @@ func (subst *subster) node(n ir.Node) ir.Node {
 		case ir.OCALL:
 			call := m.(*ir.CallExpr)
 			if call.X.Op() == ir.OTYPE {
-				// Do typechecking on a conversion, now that we
-				// know the type argument.
-				m.SetTypecheck(0)
-				m = typecheck.Expr(m)
+				// Transform the conversion, now that we know the
+				// type argument.
+				m = transformConvCall(m.(*ir.CallExpr))
+				m.SetTypecheck(1)
 			} else if call.X.Op() == ir.OCALLPART {
-				// Redo the typechecking, now that we know the method
-				// value is being called.
+				// Redo the typechecking of OXDOT, now that we
+				// know the method value is being called. Then
+				// transform the call.
 				call.X.(*ir.SelectorExpr).SetOp(ir.OXDOT)
 				call.X.SetTypecheck(0)
 				call.X.SetType(nil)
 				typecheck.Callee(call.X)
-				call.SetTypecheck(0)
-				typecheck.Call(call)
+				transformCall(call)
 			} else if call.X.Op() == ir.ODOT || call.X.Op() == ir.ODOTPTR {
 				// An OXDOT for a generic receiver was resolved to
 				// an access to a field which has a function
-				// value. Typecheck the call to that function, now
+				// value. Transform the call to that function, now
 				// that the OXDOT was resolved.
-				call.SetTypecheck(0)
-				typecheck.Call(call)
+				transformCall(call)
 			} else if name := call.X.Name(); name != nil {
 				switch name.BuiltinOp {
 				case ir.OMAKE, ir.OREAL, ir.OIMAG, ir.OLEN, ir.OCAP, ir.OAPPEND:
diff --git a/src/cmd/compile/internal/noder/stmt.go b/src/cmd/compile/internal/noder/stmt.go
index 31c6bfe5c8..f85496be40 100644
--- a/src/cmd/compile/internal/noder/stmt.go
+++ b/src/cmd/compile/internal/noder/stmt.go
@@ -27,15 +27,6 @@ func (g *irgen) stmts(stmts []syntax.Stmt) []ir.Node {
 }
 
 func (g *irgen) stmt(stmt syntax.Stmt) ir.Node {
-	// TODO(mdempsky): Remove dependency on typecheck.
-	n := g.stmt0(stmt)
-	if n != nil {
-		n.SetTypecheck(1)
-	}
-	return n
-}
-
-func (g *irgen) stmt0(stmt syntax.Stmt) ir.Node {
 	switch stmt := stmt.(type) {
 	case nil, *syntax.EmptyStmt:
 		return nil
@@ -51,35 +42,75 @@ func (g *irgen) stmt0(stmt syntax.Stmt) ir.Node {
 		return x
 	case *syntax.SendStmt:
 		n := ir.NewSendStmt(g.pos(stmt), g.expr(stmt.Chan), g.expr(stmt.Value))
-		// Need to do the AssignConv() in tcSend().
-		return typecheck.Stmt(n)
+		transformSend(n)
+		n.SetTypecheck(1)
+		return n
 	case *syntax.DeclStmt:
 		return ir.NewBlockStmt(g.pos(stmt), g.decls(stmt.DeclList))
 
 	case *syntax.AssignStmt:
 		if stmt.Op != 0 && stmt.Op != syntax.Def {
 			op := g.op(stmt.Op, binOps[:])
-			// May need to insert ConvExpr nodes on the args in tcArith
+			var n *ir.AssignOpStmt
 			if stmt.Rhs == nil {
-				return typecheck.Stmt(IncDec(g.pos(stmt), op, g.expr(stmt.Lhs)))
+				n = IncDec(g.pos(stmt), op, g.expr(stmt.Lhs))
+			} else {
+				n = ir.NewAssignOpStmt(g.pos(stmt), op, g.expr(stmt.Lhs), g.expr(stmt.Rhs))
 			}
-			return typecheck.Stmt(ir.NewAssignOpStmt(g.pos(stmt), op, g.expr(stmt.Lhs), g.expr(stmt.Rhs)))
+			if n.X.Typecheck() == 3 {
+				n.SetTypecheck(3)
+				return n
+			}
+			transformAsOp(n)
+			n.SetTypecheck(1)
+			return n
 		}
 
 		names, lhs := g.assignList(stmt.Lhs, stmt.Op == syntax.Def)
 		rhs := g.exprList(stmt.Rhs)
 
+		// We must delay transforming the assign statement if any of the
+		// lhs or rhs nodes are also delayed, since transformAssign needs
+		// to know the types of the left and right sides in various cases.
+		delay := false
+		for _, e := range lhs {
+			if e.Typecheck() == 3 {
+				delay = true
+				break
+			}
+		}
+		for _, e := range rhs {
+			if e.Typecheck() == 3 {
+				delay = true
+				break
+			}
+		}
+
 		if len(lhs) == 1 && len(rhs) == 1 {
 			n := ir.NewAssignStmt(g.pos(stmt), lhs[0], rhs[0])
 			n.Def = initDefn(n, names)
-			// Need to set Assigned in checkassign for maps
-			return typecheck.Stmt(n)
+
+			if delay {
+				n.SetTypecheck(3)
+				return n
+			}
+
+			lhs, rhs := []ir.Node{n.X}, []ir.Node{n.Y}
+			transformAssign(n, lhs, rhs)
+			n.X, n.Y = lhs[0], rhs[0]
+			n.SetTypecheck(1)
+			return n
 		}
 
 		n := ir.NewAssignListStmt(g.pos(stmt), ir.OAS2, lhs, rhs)
 		n.Def = initDefn(n, names)
-		// Need to do tcAssignList().
-		return typecheck.Stmt(n)
+		if delay {
+			n.SetTypecheck(3)
+			return n
+		}
+		transformAssign(n, n.Lhs, n.Rhs)
+		n.SetTypecheck(1)
+		return n
 
 	case *syntax.BranchStmt:
 		return ir.NewBranchStmt(g.pos(stmt), g.tokOp(int(stmt.Tok), branchOps[:]), g.name(stmt.Label))
@@ -87,16 +118,18 @@ func (g *irgen) stmt0(stmt syntax.Stmt) ir.Node {
 		return ir.NewGoDeferStmt(g.pos(stmt), g.tokOp(int(stmt.Tok), callOps[:]), g.expr(stmt.Call))
 	case *syntax.ReturnStmt:
 		n := ir.NewReturnStmt(g.pos(stmt), g.exprList(stmt.Results))
-		// Need to do typecheckaste() for multiple return values
-		return typecheck.Stmt(n)
+		transformReturn(n)
+		n.SetTypecheck(1)
+		return n
 	case *syntax.IfStmt:
 		return g.ifStmt(stmt)
 	case *syntax.ForStmt:
 		return g.forStmt(stmt)
 	case *syntax.SelectStmt:
 		n := g.selectStmt(stmt)
-		// Need to convert assignments to OSELRECV2 in tcSelect()
-		return typecheck.Stmt(n)
+		transformSelect(n.(*ir.SelectStmt))
+		n.SetTypecheck(1)
+		return n
 	case *syntax.SwitchStmt:
 		return g.switchStmt(stmt)
 
diff --git a/src/cmd/compile/internal/noder/transform.go b/src/cmd/compile/internal/noder/transform.go
new file mode 100644
index 0000000000..e90d374d0f
--- /dev/null
+++ b/src/cmd/compile/internal/noder/transform.go
@@ -0,0 +1,523 @@
+// Copyright 2021 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.
+
+// This file contains transformation functions on nodes, which are the
+// transformations that the typecheck package does that are distinct from the
+// typechecking functionality. These transform functions are pared-down copies of
+// the original typechecking functions, with all code removed that is related to:
+//
+//    - Detecting compile-time errors (already done by types2)
+//    - Setting the actual type of existing nodes (already done based on
+//      type info from types2)
+//    - Dealing with untyped constants (which types2 has already resolved)
+
+package noder
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
+	"cmd/compile/internal/types"
+	"go/constant"
+)
+
+// Transformation functions for expressions
+
+// transformAdd transforms an addition operation (currently just addition of
+// strings). Corresponds to the "binary operators" case in typecheck.typecheck1.
+func transformAdd(n *ir.BinaryExpr) ir.Node {
+	l := n.X
+	if l.Type().IsString() {
+		var add *ir.AddStringExpr
+		if l.Op() == ir.OADDSTR {
+			add = l.(*ir.AddStringExpr)
+			add.SetPos(n.Pos())
+		} else {
+			add = ir.NewAddStringExpr(n.Pos(), []ir.Node{l})
+		}
+		r := n.Y
+		if r.Op() == ir.OADDSTR {
+			r := r.(*ir.AddStringExpr)
+			add.List.Append(r.List.Take()...)
+		} else {
+			add.List.Append(r)
+		}
+		add.SetType(l.Type())
+		return add
+	}
+	return n
+}
+
+// Corresponds to typecheck.stringtoruneslit.
+func stringtoruneslit(n *ir.ConvExpr) ir.Node {
+	if n.X.Op() != ir.OLITERAL || n.X.Val().Kind() != constant.String {
+		base.Fatalf("stringtoarraylit %v", n)
+	}
+
+	var l []ir.Node
+	i := 0
+	for _, r := range ir.StringVal(n.X) {
+		l = append(l, ir.NewKeyExpr(base.Pos, ir.NewInt(int64(i)), ir.NewInt(int64(r))))
+		i++
+	}
+
+	nn := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(n.Type()), nil)
+	nn.List = l
+	// Need to transform the OCOMPLIT.
+	// TODO(danscales): update this when we have written transformCompLit()
+	return typecheck.Expr(nn)
+}
+
+// transformConv transforms an OCONV node as needed, based on the types involved,
+// etc.  Corresponds to typecheck.tcConv.
+func transformConv(n *ir.ConvExpr) ir.Node {
+	t := n.X.Type()
+	op, _ := typecheck.Convertop(n.X.Op() == ir.OLITERAL, t, n.Type())
+	assert(op != ir.OXXX)
+	n.SetOp(op)
+	switch n.Op() {
+	case ir.OCONVNOP:
+		if t.Kind() == n.Type().Kind() {
+			switch t.Kind() {
+			case types.TFLOAT32, types.TFLOAT64, types.TCOMPLEX64, types.TCOMPLEX128:
+				// Floating point casts imply rounding and
+				// so the conversion must be kept.
+				n.SetOp(ir.OCONV)
+			}
+		}
+
+	// Do not convert to []byte literal. See CL 125796.
+	// Generated code and compiler memory footprint is better without it.
+	case ir.OSTR2BYTES:
+		// ok
+
+	case ir.OSTR2RUNES:
+		if n.X.Op() == ir.OLITERAL {
+			return stringtoruneslit(n)
+		}
+	}
+	return n
+}
+
+// transformConvCall transforms a conversion call. Corresponds to the OTYPE part of
+// typecheck.tcCall.
+func transformConvCall(n *ir.CallExpr) ir.Node {
+	arg := n.Args[0]
+	n1 := ir.NewConvExpr(n.Pos(), ir.OCONV, nil, arg)
+	n1.SetType(n.X.Type())
+	return transformConv(n1)
+}
+
+// transformCall transforms a normal function/method call. Corresponds to last half
+// (non-conversion, non-builtin part) of typecheck.tcCall.
+func transformCall(n *ir.CallExpr) {
+	transformArgs(n)
+	l := n.X
+	t := l.Type()
+
+	switch l.Op() {
+	case ir.ODOTINTER:
+		n.SetOp(ir.OCALLINTER)
+
+	case ir.ODOTMETH:
+		l := l.(*ir.SelectorExpr)
+		n.SetOp(ir.OCALLMETH)
+
+		tp := t.Recv().Type
+
+		if l.X == nil || !types.Identical(l.X.Type(), tp) {
+			base.Fatalf("method receiver")
+		}
+
+	default:
+		n.SetOp(ir.OCALLFUNC)
+	}
+
+	typecheckaste(ir.OCALL, n.X, n.IsDDD, t.Params(), n.Args)
+	if t.NumResults() == 0 {
+		return
+	}
+	if t.NumResults() == 1 {
+		n.SetType(l.Type().Results().Field(0).Type)
+
+		if n.Op() == ir.OCALLFUNC && n.X.Op() == ir.ONAME {
+			if sym := n.X.(*ir.Name).Sym(); types.IsRuntimePkg(sym.Pkg) && sym.Name == "getg" {
+				// Emit code for runtime.getg() directly instead of calling function.
+				// Most such rewrites (for example the similar one for math.Sqrt) should be done in walk,
+				// so that the ordering pass can make sure to preserve the semantics of the original code
+				// (in particular, the exact time of the function call) by introducing temporaries.
+				// In this case, we know getg() always returns the same result within a given function
+				// and we want to avoid the temporaries, so we do the rewrite earlier than is typical.
+				n.SetOp(ir.OGETG)
+			}
+		}
+		return
+	}
+}
+
+// transformCompare transforms a compare operation (currently just equals/not
+// equals). Corresponds to the "comparison operators" case in
+// typecheck.typecheck1, including tcArith.
+func transformCompare(n *ir.BinaryExpr) {
+	if (n.Op() == ir.OEQ || n.Op() == ir.ONE) && !types.Identical(n.X.Type(), n.Y.Type()) {
+		// Comparison is okay as long as one side is assignable to the
+		// other. The only allowed case where the conversion is not CONVNOP is
+		// "concrete == interface". In that case, check comparability of
+		// the concrete type. The conversion allocates, so only do it if
+		// the concrete type is huge.
+		l, r := n.X, n.Y
+		lt, rt := l.Type(), r.Type()
+		converted := false
+		if rt.Kind() != types.TBLANK {
+			aop, _ := typecheck.Assignop(lt, rt)
+			if aop != ir.OXXX {
+				types.CalcSize(lt)
+				if rt.IsInterface() == lt.IsInterface() || lt.Width >= 1<<16 {
+					l = ir.NewConvExpr(base.Pos, aop, rt, l)
+					l.SetTypecheck(1)
+				}
+
+				converted = true
+			}
+		}
+
+		if !converted && lt.Kind() != types.TBLANK {
+			aop, _ := typecheck.Assignop(rt, lt)
+			if aop != ir.OXXX {
+				types.CalcSize(rt)
+				if rt.IsInterface() == lt.IsInterface() || rt.Width >= 1<<16 {
+					r = ir.NewConvExpr(base.Pos, aop, lt, r)
+					r.SetTypecheck(1)
+				}
+			}
+		}
+		n.X, n.Y = l, r
+	}
+}
+
+// Corresponds to typecheck.implicitstar.
+func implicitstar(n ir.Node) ir.Node {
+	// insert implicit * if needed for fixed array
+	t := n.Type()
+	if !t.IsPtr() {
+		return n
+	}
+	t = t.Elem()
+	if !t.IsArray() {
+		return n
+	}
+	star := ir.NewStarExpr(base.Pos, n)
+	star.SetImplicit(true)
+	return typed(t, star)
+}
+
+// transformIndex transforms an index operation.  Corresponds to typecheck.tcIndex.
+func transformIndex(n *ir.IndexExpr) {
+	n.X = implicitstar(n.X)
+	l := n.X
+	t := l.Type()
+	if t.Kind() == types.TMAP {
+		n.Index = typecheck.AssignConv(n.Index, t.Key(), "map index")
+		n.SetOp(ir.OINDEXMAP)
+		// Set type to just the map value, not (value, bool). This is
+		// different from types2, but fits the later stages of the
+		// compiler better.
+		n.SetType(t.Elem())
+		n.Assigned = false
+	}
+}
+
+// transformSlice transforms a slice operation.  Corresponds to typecheck.tcSlice.
+func transformSlice(n *ir.SliceExpr) {
+	l := n.X
+	if l.Type().IsArray() {
+		addr := typecheck.NodAddr(n.X)
+		addr.SetImplicit(true)
+		typed(types.NewPtr(n.X.Type()), addr)
+		n.X = addr
+		l = addr
+	}
+	t := l.Type()
+	if t.IsString() {
+		n.SetOp(ir.OSLICESTR)
+	} else if t.IsPtr() && t.Elem().IsArray() {
+		if n.Op().IsSlice3() {
+			n.SetOp(ir.OSLICE3ARR)
+		} else {
+			n.SetOp(ir.OSLICEARR)
+		}
+	}
+}
+
+// Transformation functions for statements
+
+// Corresponds to typecheck.checkassign.
+func transformCheckAssign(stmt ir.Node, n ir.Node) {
+	if n.Op() == ir.OINDEXMAP {
+		n := n.(*ir.IndexExpr)
+		n.Assigned = true
+		return
+	}
+}
+
+// Corresponds to typecheck.assign.
+func transformAssign(stmt ir.Node, lhs, rhs []ir.Node) {
+	checkLHS := func(i int, typ *types.Type) {
+		transformCheckAssign(stmt, lhs[i])
+	}
+
+	cr := len(rhs)
+	if len(rhs) == 1 {
+		if rtyp := rhs[0].Type(); rtyp != nil && rtyp.IsFuncArgStruct() {
+			cr = rtyp.NumFields()
+		}
+	}
+
+	// x, ok = y
+assignOK:
+	for len(lhs) == 2 && cr == 1 {
+		stmt := stmt.(*ir.AssignListStmt)
+		r := rhs[0]
+
+		switch r.Op() {
+		case ir.OINDEXMAP:
+			stmt.SetOp(ir.OAS2MAPR)
+		case ir.ORECV:
+			stmt.SetOp(ir.OAS2RECV)
+		case ir.ODOTTYPE:
+			r := r.(*ir.TypeAssertExpr)
+			stmt.SetOp(ir.OAS2DOTTYPE)
+			r.SetOp(ir.ODOTTYPE2)
+		default:
+			break assignOK
+		}
+		checkLHS(0, r.Type())
+		checkLHS(1, types.UntypedBool)
+		return
+	}
+
+	if len(lhs) != cr {
+		for i := range lhs {
+			checkLHS(i, nil)
+		}
+		return
+	}
+
+	// x,y,z = f()
+	if cr > len(rhs) {
+		stmt := stmt.(*ir.AssignListStmt)
+		stmt.SetOp(ir.OAS2FUNC)
+		r := rhs[0].(*ir.CallExpr)
+		r.Use = ir.CallUseList
+		rtyp := r.Type()
+
+		for i := range lhs {
+			checkLHS(i, rtyp.Field(i).Type)
+		}
+		return
+	}
+
+	for i, r := range rhs {
+		checkLHS(i, r.Type())
+		if lhs[i].Type() != nil {
+			rhs[i] = assignconvfn(r, lhs[i].Type())
+		}
+	}
+}
+
+// Corresponds to typecheck.typecheckargs.
+func transformArgs(n ir.InitNode) {
+	var list []ir.Node
+	switch n := n.(type) {
+	default:
+		base.Fatalf("typecheckargs %+v", n.Op())
+	case *ir.CallExpr:
+		list = n.Args
+		if n.IsDDD {
+			return
+		}
+	case *ir.ReturnStmt:
+		list = n.Results
+	}
+	if len(list) != 1 {
+		return
+	}
+
+	t := list[0].Type()
+	if t == nil || !t.IsFuncArgStruct() {
+		return
+	}
+
+	// Rewrite f(g()) into t1, t2, ... = g(); f(t1, t2, ...).
+
+	// Save n as n.Orig for fmt.go.
+	if ir.Orig(n) == n {
+		n.(ir.OrigNode).SetOrig(ir.SepCopy(n))
+	}
+
+	as := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
+	as.Rhs.Append(list...)
+
+	// If we're outside of function context, then this call will
+	// be executed during the generated init function. However,
+	// init.go hasn't yet created it. Instead, associate the
+	// temporary variables with  InitTodoFunc for now, and init.go
+	// will reassociate them later when it's appropriate.
+	static := ir.CurFunc == nil
+	if static {
+		ir.CurFunc = typecheck.InitTodoFunc
+	}
+	list = nil
+	for _, f := range t.FieldSlice() {
+		t := typecheck.Temp(f.Type)
+		as.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, t))
+		as.Lhs.Append(t)
+		list = append(list, t)
+	}
+	if static {
+		ir.CurFunc = nil
+	}
+
+	switch n := n.(type) {
+	case *ir.CallExpr:
+		n.Args = list
+	case *ir.ReturnStmt:
+		n.Results = list
+	}
+
+	transformAssign(as, as.Lhs, as.Rhs)
+	as.SetTypecheck(1)
+	n.PtrInit().Append(as)
+}
+
+// assignconvfn converts node n for assignment to type t. Corresponds to
+// typecheck.assignconvfn.
+func assignconvfn(n ir.Node, t *types.Type) ir.Node {
+	if t.Kind() == types.TBLANK {
+		return n
+	}
+
+	if types.Identical(n.Type(), t) {
+		return n
+	}
+
+	op, _ := typecheck.Assignop(n.Type(), t)
+
+	r := ir.NewConvExpr(base.Pos, op, t, n)
+	r.SetTypecheck(1)
+	r.SetImplicit(true)
+	return r
+}
+
+// Corresponds to typecheck.typecheckaste.
+func typecheckaste(op ir.Op, call ir.Node, isddd bool, tstruct *types.Type, nl ir.Nodes) {
+	var t *types.Type
+	var i int
+
+	lno := base.Pos
+	defer func() { base.Pos = lno }()
+
+	var n ir.Node
+	if len(nl) == 1 {
+		n = nl[0]
+	}
+
+	i = 0
+	for _, tl := range tstruct.Fields().Slice() {
+		t = tl.Type
+		if tl.IsDDD() {
+			if isddd {
+				n = nl[i]
+				ir.SetPos(n)
+				if n.Type() != nil {
+					nl[i] = assignconvfn(n, t)
+				}
+				return
+			}
+
+			// TODO(mdempsky): Make into ... call with implicit slice.
+			for ; i < len(nl); i++ {
+				n = nl[i]
+				ir.SetPos(n)
+				if n.Type() != nil {
+					nl[i] = assignconvfn(n, t.Elem())
+				}
+			}
+			return
+		}
+
+		n = nl[i]
+		ir.SetPos(n)
+		if n.Type() != nil {
+			nl[i] = assignconvfn(n, t)
+		}
+		i++
+	}
+}
+
+// transformSend transforms a send statement, converting the value to appropriate
+// type for the channel, as needed. Corresponds of typecheck.tcSend.
+func transformSend(n *ir.SendStmt) {
+	n.Value = assignconvfn(n.Value, n.Chan.Type().Elem())
+}
+
+// transformReturn transforms a return node, by doing the needed assignments and
+// any necessary conversions. Corresponds to typecheck.tcReturn()
+func transformReturn(rs *ir.ReturnStmt) {
+	transformArgs(rs)
+	nl := rs.Results
+	if ir.HasNamedResults(ir.CurFunc) && len(nl) == 0 {
+		return
+	}
+
+	typecheckaste(ir.ORETURN, nil, false, ir.CurFunc.Type().Results(), nl)
+}
+
+// transformSelect transforms a select node, creating an assignment list as needed
+// for each case. Corresponds to typecheck.tcSelect().
+func transformSelect(sel *ir.SelectStmt) {
+	for _, ncase := range sel.Cases {
+		if ncase.Comm != nil {
+			n := ncase.Comm
+			oselrecv2 := func(dst, recv ir.Node, def bool) {
+				n := ir.NewAssignListStmt(n.Pos(), ir.OSELRECV2, []ir.Node{dst, ir.BlankNode}, []ir.Node{recv})
+				n.Def = def
+				n.SetTypecheck(1)
+				ncase.Comm = n
+			}
+			switch n.Op() {
+			case ir.OAS:
+				// convert x = <-c into x, _ = <-c
+				// remove implicit conversions; the eventual assignment
+				// will reintroduce them.
+				n := n.(*ir.AssignStmt)
+				if r := n.Y; r.Op() == ir.OCONVNOP || r.Op() == ir.OCONVIFACE {
+					r := r.(*ir.ConvExpr)
+					if r.Implicit() {
+						n.Y = r.X
+					}
+				}
+				oselrecv2(n.X, n.Y, n.Def)
+
+			case ir.OAS2RECV:
+				n := n.(*ir.AssignListStmt)
+				n.SetOp(ir.OSELRECV2)
+
+			case ir.ORECV:
+				// convert <-c into _, _ = <-c
+				n := n.(*ir.UnaryExpr)
+				oselrecv2(ir.BlankNode, n, false)
+
+			case ir.OSEND:
+				break
+			}
+		}
+	}
+}
+
+// transformAsOp transforms an AssignOp statement. Corresponds to OASOP case in
+// typecheck1.
+func transformAsOp(n *ir.AssignOpStmt) {
+	transformCheckAssign(n, n.X)
+}
diff --git a/src/cmd/compile/internal/noder/validate.go b/src/cmd/compile/internal/noder/validate.go
index 3341de8e04..b926222c89 100644
--- a/src/cmd/compile/internal/noder/validate.go
+++ b/src/cmd/compile/internal/noder/validate.go
@@ -23,10 +23,14 @@ func (g *irgen) match(t1 *types.Type, t2 types2.Type, hasOK bool) bool {
 	}
 
 	if hasOK {
-		// For has-ok values, types2 represents the expression's type as
-		// a 2-element tuple, whereas ir just uses the first type and
-		// infers that the second type is boolean.
-		return tuple.Len() == 2 && types.Identical(t1, g.typ(tuple.At(0).Type()))
+		// For has-ok values, types2 represents the expression's type as a
+		// 2-element tuple, whereas ir just uses the first type and infers
+		// that the second type is boolean. Must match either, since we
+		// sometimes delay the transformation to the ir form.
+		if tuple.Len() == 2 && types.Identical(t1, g.typ(tuple.At(0).Type())) {
+			return true
+		}
+		return types.Identical(t1, g.typ(t2))
 	}
 
 	if t1 == nil || tuple == nil {
diff --git a/src/cmd/compile/internal/typecheck/expr.go b/src/cmd/compile/internal/typecheck/expr.go
index fb39709686..7ab1670a45 100644
--- a/src/cmd/compile/internal/typecheck/expr.go
+++ b/src/cmd/compile/internal/typecheck/expr.go
@@ -419,7 +419,7 @@ func tcConv(n *ir.ConvExpr) ir.Node {
 		n.SetType(nil)
 		return n
 	}
-	op, why := convertop(n.X.Op() == ir.OLITERAL, t, n.Type())
+	op, why := Convertop(n.X.Op() == ir.OLITERAL, t, n.Type())
 	if op == ir.OXXX {
 		if !n.Diag() && !n.Type().Broke() && !n.X.Diag() {
 			base.Errorf("cannot convert %L to type %v%s", n.X, n.Type(), why)
diff --git a/src/cmd/compile/internal/typecheck/subr.go b/src/cmd/compile/internal/typecheck/subr.go
index e58ef9fb05..daf5cd72a2 100644
--- a/src/cmd/compile/internal/typecheck/subr.go
+++ b/src/cmd/compile/internal/typecheck/subr.go
@@ -460,7 +460,7 @@ func Assignop(src, dst *types.Type) (ir.Op, string) {
 // If not, return OXXX. In this case, the string return parameter may
 // hold a reason why. In all other cases, it'll be the empty string.
 // srcConstant indicates whether the value of type src is a constant.
-func convertop(srcConstant bool, src, dst *types.Type) (ir.Op, string) {
+func Convertop(srcConstant bool, src, dst *types.Type) (ir.Op, string) {
 	if src == dst {
 		return ir.OCONVNOP, ""
 	}
-- 
GitLab


From 80157b5144191e88b18937eb9b6ee5b6046f3f20 Mon Sep 17 00:00:00 2001
From: Kevin Burke <kevin@burke.dev>
Date: Wed, 24 Mar 2021 16:02:24 -0700
Subject: [PATCH 1224/2400] crypto/x509: fix spelling error

Change-Id: Ieb1900531f42acf2c8b98ac89fceb8b87c8e5d0c
Reviewed-on: https://go-review.googlesource.com/c/go/+/304609
Reviewed-by: Roland Shoemaker <roland@golang.org>
Trust: Kevin Burke <kev@inburke.com>
---
 src/crypto/x509/verify.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/crypto/x509/verify.go b/src/crypto/x509/verify.go
index 46afb2698a..2432d9bb86 100644
--- a/src/crypto/x509/verify.go
+++ b/src/crypto/x509/verify.go
@@ -837,7 +837,7 @@ func appendToFreshChain(chain []*Certificate, cert *Certificate) []*Certificate
 }
 
 // maxChainSignatureChecks is the maximum number of CheckSignatureFrom calls
-// that an invocation of buildChains will (tranistively) make. Most chains are
+// that an invocation of buildChains will (transitively) make. Most chains are
 // less than 15 certificates long, so this leaves space for multiple chains and
 // for failed checks due to different intermediates having the same Subject.
 const maxChainSignatureChecks = 100
-- 
GitLab


From a95e2ae2804becdda6c265c6d589ae8184a34160 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Wed, 24 Mar 2021 21:51:44 -0400
Subject: [PATCH 1225/2400] test: skip fixedbugs/issue36705 on Windows
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This test is verifying that setting or unsetting an environment
variable in Go via the "os" package makes that change visible to the C
getenv function. The test has been failing on Windows since CL 304569;
it isn't clear to me whether it was running at all before that point.

On Windows the getenv and _putenv C functions are not thread-safe,
so Go's os.Setenv and os.Getenv use the SetEnvironmentVariable and
GetEnvironmentVariable system calls instead. That seems to work fine
in practice; however, changes via SetEnvironmentVariable are
empirically not visible to the C getenv function on certain versions
of Windows.

The MSDN getenv documentation¹ states that ‘getenv operates only on
the data structures accessible to the run-time library and not on the
environment “segment” created for the process by the operating system.
Therefore, programs that use the envp argument to main or wmain may
retrieve invalid information.’ That may be related to what we're
seeing here.

(https://github.com/curl/curl/issues/4774 describes this same behavior
observed in the curl project.)

¹https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/getenv-wgetenv?view=msvc-160#remarks

Updates #36705

Change-Id: I222792f75c650f32c5025b0fa3edab232ff66353
Reviewed-on: https://go-review.googlesource.com/c/go/+/304669
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 test/fixedbugs/issue36705.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/fixedbugs/issue36705.go b/test/fixedbugs/issue36705.go
index d5a0e7fade..b0485c6335 100644
--- a/test/fixedbugs/issue36705.go
+++ b/test/fixedbugs/issue36705.go
@@ -1,4 +1,4 @@
-// +build cgo
+// +build cgo,!windows
 // run fake-arg-to-force-use-of-go-run
 
 // Copyright 2020 The Go Authors. All rights reserved.
-- 
GitLab


From 954879d6d19175a5f0066c0ac0df0edda7f731b3 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Wed, 3 Mar 2021 10:27:19 -0500
Subject: [PATCH 1226/2400] cmd/go/internal/modload: replace the global
 buildList with structured requirements

This is intended to be a pure-refactoring change, with very little
observable change in the behavior of the 'go' command. A few error
messages have prefixes changed (by virtue of being attached to
packages or modules instead of the build list overall), and
'go list -m' (without arguments) no longer loads the complete module
graph in order to provide the name of the (local) main module.

The previous modload.buildList variable contained a flattened build
list, from which the go.mod file was reconstructed using various
heuristics and metadata cobbled together from the original go.mod
file, the package loader (which was occasionally constructed without
actually loading packages, for the sole purpose of populating
otherwise-unrelated metadata!), and the updated build list.

This change replaces that variable with a new package-level variable,
named "requirements". The new variable is structured to match the
structure of the go.mod file: it explicitly specifies the roots of the
module graph, from which the complete module graph and complete build
list can be reconstructed (and cached) on demand. Similarly, the
"direct" markings on the go.mod requirements are now stored alongside
the requirements themselves, rather than side-channeled through the
loader.

The requirements are now plumbed explicitly though the modload
package, with accesses to the package-level variable occurring only
within top-level exported functions. The structured requirements are
logically immutable, so a new copy of the requirements is constructed
whenever the requirements are changed, substantially reducing implicit
communication-by-sharing in the package.

For #36460
Updates #40775

Change-Id: I97bb0381708f9d3e42af385b5c88a7038e1f0556
Reviewed-on: https://go-review.googlesource.com/c/go/+/293689
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/list/list.go              |  12 +-
 src/cmd/go/internal/load/pkg.go               |  30 +-
 src/cmd/go/internal/load/test.go              |   2 +-
 src/cmd/go/internal/modcmd/download.go        |  12 +-
 src/cmd/go/internal/modcmd/graph.go           |  50 +-
 src/cmd/go/internal/modcmd/tidy.go            |  12 +-
 src/cmd/go/internal/modcmd/verify.go          |   2 +-
 src/cmd/go/internal/modcmd/why.go             |   7 +-
 src/cmd/go/internal/modget/get.go             |  14 +-
 src/cmd/go/internal/modload/build.go          |  67 +-
 src/cmd/go/internal/modload/buildlist.go      | 685 +++++++++++++++---
 src/cmd/go/internal/modload/import.go         | 104 ++-
 src/cmd/go/internal/modload/import_test.go    |   3 +-
 src/cmd/go/internal/modload/init.go           | 285 ++++----
 src/cmd/go/internal/modload/list.go           | 129 ++--
 src/cmd/go/internal/modload/load.go           | 226 ++++--
 src/cmd/go/internal/modload/modfile.go        |  24 +-
 src/cmd/go/internal/modload/search.go         |   2 +-
 .../script/mod_install_pkg_version.txt        |   2 +-
 .../testdata/script/mod_invalid_version.txt   |  30 +-
 .../go/testdata/script/mod_load_badchain.txt  |   2 +-
 .../script/mod_load_replace_mismatch.txt      |   2 +-
 .../testdata/script/mod_replace_gopkgin.txt   |   2 +-
 .../testdata/script/mod_require_exclude.txt   |   4 +-
 .../go/testdata/script/mod_sum_readonly.txt   |   6 +-
 25 files changed, 1191 insertions(+), 523 deletions(-)

diff --git a/src/cmd/go/internal/list/list.go b/src/cmd/go/internal/list/list.go
index b4d82d9f8c..bb48d2d2ea 100644
--- a/src/cmd/go/internal/list/list.go
+++ b/src/cmd/go/internal/list/list.go
@@ -423,7 +423,7 @@ func runList(ctx context.Context, cmd *base.Command, args []string) {
 			base.Fatalf("go list -m: not using modules")
 		}
 
-		modload.LoadModFile(ctx) // Parses go.mod and sets cfg.BuildMod.
+		modload.LoadModFile(ctx) // Sets cfg.BuildMod as a side-effect.
 		if cfg.BuildMod == "vendor" {
 			const actionDisabledFormat = "go list -m: can't %s using the vendor directory\n\t(Use -mod=mod or -mod=readonly to bypass.)"
 
@@ -447,13 +447,16 @@ func runList(ctx context.Context, cmd *base.Command, args []string) {
 			}
 		}
 
-		mods := modload.ListModules(ctx, args, *listU, *listVersions, *listRetracted)
+		mods, err := modload.ListModules(ctx, args, *listU, *listVersions, *listRetracted)
 		if !*listE {
 			for _, m := range mods {
 				if m.Error != nil {
 					base.Errorf("go list -m: %v", m.Error.Err)
 				}
 			}
+			if err != nil {
+				base.Errorf("go list -m: %v", err)
+			}
 			base.ExitIfErrors()
 		}
 		for _, m := range mods {
@@ -681,7 +684,10 @@ func runList(ctx context.Context, cmd *base.Command, args []string) {
 		if len(args) > 0 {
 			listU := false
 			listVersions := false
-			rmods := modload.ListModules(ctx, args, listU, listVersions, *listRetracted)
+			rmods, err := modload.ListModules(ctx, args, listU, listVersions, *listRetracted)
+			if err != nil && !*listE {
+				base.Errorf("go list -retracted: %v", err)
+			}
 			for i, arg := range args {
 				rmod := rmods[i]
 				for _, mod := range argToMods[arg] {
diff --git a/src/cmd/go/internal/load/pkg.go b/src/cmd/go/internal/load/pkg.go
index 61fde895f8..c9619f1b28 100644
--- a/src/cmd/go/internal/load/pkg.go
+++ b/src/cmd/go/internal/load/pkg.go
@@ -665,9 +665,9 @@ func loadImport(ctx context.Context, pre *preload, path, srcDir string, parent *
 		parentRoot = parent.Root
 		parentIsStd = parent.Standard
 	}
-	bp, loaded, err := loadPackageData(path, parentPath, srcDir, parentRoot, parentIsStd, mode)
+	bp, loaded, err := loadPackageData(ctx, path, parentPath, srcDir, parentRoot, parentIsStd, mode)
 	if loaded && pre != nil && !IgnoreImports {
-		pre.preloadImports(bp.Imports, bp)
+		pre.preloadImports(ctx, bp.Imports, bp)
 	}
 	if bp == nil {
 		if importErr, ok := err.(ImportPathError); !ok || importErr.ImportPath() != path {
@@ -714,7 +714,7 @@ func loadImport(ctx context.Context, pre *preload, path, srcDir string, parent *
 	}
 
 	// Checked on every import because the rules depend on the code doing the importing.
-	if perr := disallowInternal(srcDir, parent, parentPath, p, stk); perr != p {
+	if perr := disallowInternal(ctx, srcDir, parent, parentPath, p, stk); perr != p {
 		perr.Error.setPos(importPos)
 		return perr
 	}
@@ -763,7 +763,7 @@ func loadImport(ctx context.Context, pre *preload, path, srcDir string, parent *
 //
 // loadPackageData returns a boolean, loaded, which is true if this is the
 // first time the package was loaded. Callers may preload imports in this case.
-func loadPackageData(path, parentPath, parentDir, parentRoot string, parentIsStd bool, mode int) (bp *build.Package, loaded bool, err error) {
+func loadPackageData(ctx context.Context, path, parentPath, parentDir, parentRoot string, parentIsStd bool, mode int) (bp *build.Package, loaded bool, err error) {
 	if path == "" {
 		panic("loadPackageData called with empty package path")
 	}
@@ -836,7 +836,7 @@ func loadPackageData(path, parentPath, parentDir, parentRoot string, parentIsStd
 			}
 			data.p, data.err = cfg.BuildContext.ImportDir(r.dir, buildMode)
 			if data.p.Root == "" && cfg.ModulesEnabled {
-				if info := modload.PackageModuleInfo(path); info != nil {
+				if info := modload.PackageModuleInfo(ctx, path); info != nil {
 					data.p.Root = info.Dir
 				}
 			}
@@ -950,7 +950,7 @@ func newPreload() *preload {
 // preloadMatches loads data for package paths matched by patterns.
 // When preloadMatches returns, some packages may not be loaded yet, but
 // loadPackageData and loadImport are always safe to call.
-func (pre *preload) preloadMatches(matches []*search.Match) {
+func (pre *preload) preloadMatches(ctx context.Context, matches []*search.Match) {
 	for _, m := range matches {
 		for _, pkg := range m.Pkgs {
 			select {
@@ -959,10 +959,10 @@ func (pre *preload) preloadMatches(matches []*search.Match) {
 			case pre.sema <- struct{}{}:
 				go func(pkg string) {
 					mode := 0 // don't use vendoring or module import resolution
-					bp, loaded, err := loadPackageData(pkg, "", base.Cwd, "", false, mode)
+					bp, loaded, err := loadPackageData(ctx, pkg, "", base.Cwd, "", false, mode)
 					<-pre.sema
 					if bp != nil && loaded && err == nil && !IgnoreImports {
-						pre.preloadImports(bp.Imports, bp)
+						pre.preloadImports(ctx, bp.Imports, bp)
 					}
 				}(pkg)
 			}
@@ -973,7 +973,7 @@ func (pre *preload) preloadMatches(matches []*search.Match) {
 // preloadImports queues a list of imports for preloading.
 // When preloadImports returns, some packages may not be loaded yet,
 // but loadPackageData and loadImport are always safe to call.
-func (pre *preload) preloadImports(imports []string, parent *build.Package) {
+func (pre *preload) preloadImports(ctx context.Context, imports []string, parent *build.Package) {
 	parentIsStd := parent.Goroot && parent.ImportPath != "" && search.IsStandardImportPath(parent.ImportPath)
 	for _, path := range imports {
 		if path == "C" || path == "unsafe" {
@@ -984,10 +984,10 @@ func (pre *preload) preloadImports(imports []string, parent *build.Package) {
 			return
 		case pre.sema <- struct{}{}:
 			go func(path string) {
-				bp, loaded, err := loadPackageData(path, parent.ImportPath, parent.Dir, parent.Root, parentIsStd, ResolveImport)
+				bp, loaded, err := loadPackageData(ctx, path, parent.ImportPath, parent.Dir, parent.Root, parentIsStd, ResolveImport)
 				<-pre.sema
 				if bp != nil && loaded && err == nil && !IgnoreImports {
-					pre.preloadImports(bp.Imports, bp)
+					pre.preloadImports(ctx, bp.Imports, bp)
 				}
 			}(path)
 		}
@@ -1343,7 +1343,7 @@ func reusePackage(p *Package, stk *ImportStack) *Package {
 // is allowed to import p.
 // If the import is allowed, disallowInternal returns the original package p.
 // If not, it returns a new package containing just an appropriate error.
-func disallowInternal(srcDir string, importer *Package, importerPath string, p *Package, stk *ImportStack) *Package {
+func disallowInternal(ctx context.Context, srcDir string, importer *Package, importerPath string, p *Package, stk *ImportStack) *Package {
 	// golang.org/s/go14internal:
 	// An import of a path containing the element “internal”
 	// is disallowed if the importing code is outside the tree
@@ -1415,7 +1415,7 @@ func disallowInternal(srcDir string, importer *Package, importerPath string, p *
 			// directory containing them.
 			// If the directory is outside the main module, this will resolve to ".",
 			// which is not a prefix of any valid module.
-			importerPath = modload.DirImportPath(importer.Dir)
+			importerPath = modload.DirImportPath(ctx, importer.Dir)
 		}
 		parentOfInternal := p.ImportPath[:i]
 		if str.HasPathPrefix(importerPath, parentOfInternal) {
@@ -1918,7 +1918,7 @@ func (p *Package) load(ctx context.Context, path string, stk *ImportStack, impor
 		if p.Internal.CmdlineFiles {
 			mainPath = "command-line-arguments"
 		}
-		p.Module = modload.PackageModuleInfo(mainPath)
+		p.Module = modload.PackageModuleInfo(ctx, mainPath)
 		if p.Name == "main" && len(p.DepsErrors) == 0 {
 			p.Internal.BuildInfo = modload.PackageBuildInfo(mainPath, p.Deps)
 		}
@@ -2405,7 +2405,7 @@ func PackagesAndErrors(ctx context.Context, patterns []string) []*Package {
 
 	pre := newPreload()
 	defer pre.flush()
-	pre.preloadMatches(matches)
+	pre.preloadMatches(ctx, matches)
 
 	for _, m := range matches {
 		for _, pkg := range m.Pkgs {
diff --git a/src/cmd/go/internal/load/test.go b/src/cmd/go/internal/load/test.go
index 374a2f9a4f..7bc16abcb6 100644
--- a/src/cmd/go/internal/load/test.go
+++ b/src/cmd/go/internal/load/test.go
@@ -100,7 +100,7 @@ func TestPackagesAndErrors(ctx context.Context, p *Package, cover *TestCover) (p
 	defer pre.flush()
 	allImports := append([]string{}, p.TestImports...)
 	allImports = append(allImports, p.XTestImports...)
-	pre.preloadImports(allImports, p.Internal.Build)
+	pre.preloadImports(ctx, allImports, p.Internal.Build)
 
 	var ptestErr, pxtestErr *PackageError
 	var imports, ximports []*Package
diff --git a/src/cmd/go/internal/modcmd/download.go b/src/cmd/go/internal/modcmd/download.go
index e7d3d869cb..32c5b7f340 100644
--- a/src/cmd/go/internal/modcmd/download.go
+++ b/src/cmd/go/internal/modcmd/download.go
@@ -137,7 +137,8 @@ func runDownload(ctx context.Context, cmd *base.Command, args []string) {
 	listRetractions := false
 	type token struct{}
 	sem := make(chan token, runtime.GOMAXPROCS(0))
-	for _, info := range modload.ListModules(ctx, args, listU, listVersions, listRetractions) {
+	infos, infosErr := modload.ListModules(ctx, args, listU, listVersions, listRetractions)
+	for _, info := range infos {
 		if info.Replace != nil {
 			info = info.Replace
 		}
@@ -188,5 +189,12 @@ func runDownload(ctx context.Context, cmd *base.Command, args []string) {
 	}
 
 	// Update go.mod and especially go.sum if needed.
-	modload.WriteGoMod()
+	modload.WriteGoMod(ctx)
+
+	// If there was an error matching some of the requested packages, emit it now
+	// (after we've written the checksums for the modules that were downloaded
+	// successfully).
+	if infosErr != nil {
+		base.Errorf("go mod download: %v", infosErr)
+	}
 }
diff --git a/src/cmd/go/internal/modcmd/graph.go b/src/cmd/go/internal/modcmd/graph.go
index a88e9ef455..77853304e9 100644
--- a/src/cmd/go/internal/modcmd/graph.go
+++ b/src/cmd/go/internal/modcmd/graph.go
@@ -10,7 +10,6 @@ import (
 	"bufio"
 	"context"
 	"os"
-	"sort"
 
 	"cmd/go/internal/base"
 	"cmd/go/internal/modload"
@@ -42,43 +41,26 @@ func runGraph(ctx context.Context, cmd *base.Command, args []string) {
 	}
 	modload.ForceUseModules = true
 	modload.RootMode = modload.NeedRoot
-	modload.LoadAllModules(ctx)
+	mg := modload.LoadModGraph(ctx)
 
-	reqs := modload.MinReqs()
-	format := func(m module.Version) string {
-		if m.Version == "" {
-			return m.Path
-		}
-		return m.Path + "@" + m.Version
-	}
+	w := bufio.NewWriter(os.Stdout)
+	defer w.Flush()
 
-	var out []string
-	var deps int // index in out where deps start
-	seen := map[module.Version]bool{modload.Target: true}
-	queue := []module.Version{modload.Target}
-	for len(queue) > 0 {
-		var m module.Version
-		m, queue = queue[0], queue[1:]
-		list, _ := reqs.Required(m)
-		for _, r := range list {
-			if !seen[r] {
-				queue = append(queue, r)
-				seen[r] = true
-			}
-			out = append(out, format(m)+" "+format(r)+"\n")
-		}
-		if m == modload.Target {
-			deps = len(out)
+	format := func(m module.Version) {
+		w.WriteString(m.Path)
+		if m.Version != "" {
+			w.WriteString("@")
+			w.WriteString(m.Version)
 		}
 	}
 
-	sort.Slice(out[deps:], func(i, j int) bool {
-		return out[deps+i][0] < out[deps+j][0]
+	mg.WalkBreadthFirst(func(m module.Version) {
+		reqs, _ := mg.RequiredBy(m)
+		for _, r := range reqs {
+			format(m)
+			w.WriteByte(' ')
+			format(r)
+			w.WriteByte('\n')
+		}
 	})
-
-	w := bufio.NewWriter(os.Stdout)
-	for _, line := range out {
-		w.WriteString(line)
-	}
-	w.Flush()
 }
diff --git a/src/cmd/go/internal/modcmd/tidy.go b/src/cmd/go/internal/modcmd/tidy.go
index 33ecd80bcb..fc70cd3f22 100644
--- a/src/cmd/go/internal/modcmd/tidy.go
+++ b/src/cmd/go/internal/modcmd/tidy.go
@@ -71,9 +71,15 @@ func runTidy(ctx context.Context, cmd *base.Command, args []string) {
 		SilenceMissingStdImports: true,
 	}, "all")
 
-	modload.TidyBuildList()
-	modload.TrimGoSum()
+	modload.TidyBuildList(ctx)
+	modload.TrimGoSum(ctx)
 
 	modload.AllowWriteGoMod()
-	modload.WriteGoMod()
+
+	// TODO(#40775): Toggling global state via AllowWriteGoMod makes the
+	// invariants for go.mod cleanliness harder to reason about. Instead, either
+	// make DisallowWriteGoMod an explicit PackageOpts field, or add a Tidy
+	// argument to modload.LoadPackages so that Tidy is just one call into the
+	// module loader, or perhaps both.
+	modload.WriteGoMod(ctx)
 }
diff --git a/src/cmd/go/internal/modcmd/verify.go b/src/cmd/go/internal/modcmd/verify.go
index 8321429131..5c321c783a 100644
--- a/src/cmd/go/internal/modcmd/verify.go
+++ b/src/cmd/go/internal/modcmd/verify.go
@@ -54,7 +54,7 @@ func runVerify(ctx context.Context, cmd *base.Command, args []string) {
 	sem := make(chan token, runtime.GOMAXPROCS(0))
 
 	// Use a slice of result channels, so that the output is deterministic.
-	mods := modload.LoadAllModules(ctx)[1:]
+	mods := modload.LoadModGraph(ctx).BuildList()[1:]
 	errsChans := make([]<-chan []error, len(mods))
 
 	for i, mod := range mods {
diff --git a/src/cmd/go/internal/modcmd/why.go b/src/cmd/go/internal/modcmd/why.go
index 79d257d198..d67ac46210 100644
--- a/src/cmd/go/internal/modcmd/why.go
+++ b/src/cmd/go/internal/modcmd/why.go
@@ -84,7 +84,12 @@ func runWhy(ctx context.Context, cmd *base.Command, args []string) {
 				base.Fatalf("go mod why: module query not allowed")
 			}
 		}
-		mods := modload.ListModules(ctx, args, listU, listVersions, listRetractions)
+
+		mods, err := modload.ListModules(ctx, args, listU, listVersions, listRetractions)
+		if err != nil {
+			base.Fatalf("go mod why: %v", err)
+		}
+
 		byModule := make(map[module.Version][]string)
 		_, pkgs := modload.LoadPackages(ctx, loadOpts, "all")
 		for _, path := range pkgs {
diff --git a/src/cmd/go/internal/modget/get.go b/src/cmd/go/internal/modget/get.go
index 4892db8781..a9447f6c57 100644
--- a/src/cmd/go/internal/modget/get.go
+++ b/src/cmd/go/internal/modget/get.go
@@ -287,8 +287,6 @@ func runGet(ctx context.Context, cmd *base.Command, args []string) {
 	// 'go get' is expected to do this, unlike other commands.
 	modload.AllowMissingModuleImports()
 
-	modload.LoadModFile(ctx) // Initializes modload.Target.
-
 	queries := parseArgs(ctx, args)
 
 	r := newResolver(ctx, queries)
@@ -401,7 +399,7 @@ func runGet(ctx context.Context, cmd *base.Command, args []string) {
 	oldReqs := reqsFromGoMod(modload.ModFile())
 
 	modload.AllowWriteGoMod()
-	modload.WriteGoMod()
+	modload.WriteGoMod(ctx)
 	modload.DisallowWriteGoMod()
 
 	newReqs := reqsFromGoMod(modload.ModFile())
@@ -483,7 +481,11 @@ type versionReason struct {
 }
 
 func newResolver(ctx context.Context, queries []*query) *resolver {
-	buildList := modload.LoadAllModules(ctx)
+	// LoadModGraph also sets modload.Target, which is needed by various resolver
+	// methods.
+	mg := modload.LoadModGraph(ctx)
+
+	buildList := mg.BuildList()
 	initialVersion := make(map[string]string, len(buildList))
 	for _, m := range buildList {
 		initialVersion[m.Path] = m.Version
@@ -692,7 +694,7 @@ func (r *resolver) performLocalQueries(ctx context.Context) {
 
 			// Absolute paths like C:\foo and relative paths like ../foo... are
 			// restricted to matching packages in the main module.
-			pkgPattern := modload.DirImportPath(q.pattern)
+			pkgPattern := modload.DirImportPath(ctx, q.pattern)
 			if pkgPattern == "." {
 				return errSet(fmt.Errorf("%s%s is not within module rooted at %s", q.pattern, absDetail, modload.ModRoot()))
 			}
@@ -1675,7 +1677,7 @@ func (r *resolver) updateBuildList(ctx context.Context, additions []module.Versi
 		return false
 	}
 
-	r.buildList = modload.LoadAllModules(ctx)
+	r.buildList = modload.LoadModGraph(ctx).BuildList()
 	r.buildListVersion = make(map[string]string, len(r.buildList))
 	for _, m := range r.buildList {
 		r.buildListVersion[m.Path] = m.Version
diff --git a/src/cmd/go/internal/modload/build.go b/src/cmd/go/internal/modload/build.go
index 5f18a38e93..48d20bb5fa 100644
--- a/src/cmd/go/internal/modload/build.go
+++ b/src/cmd/go/internal/modload/build.go
@@ -50,17 +50,18 @@ func findStandardImportPath(path string) string {
 // a given package. If modules are not enabled or if the package is in the
 // standard library or if the package was not successfully loaded with
 // LoadPackages or ImportFromFiles, nil is returned.
-func PackageModuleInfo(pkgpath string) *modinfo.ModulePublic {
+func PackageModuleInfo(ctx context.Context, pkgpath string) *modinfo.ModulePublic {
 	if isStandardImportPath(pkgpath) || !Enabled() {
 		return nil
 	}
-	m, ok := findModule(pkgpath)
+	m, ok := findModule(loaded, pkgpath)
 	if !ok {
 		return nil
 	}
-	fromBuildList := true
+
+	rs := LoadModFile(ctx)
 	listRetracted := false
-	return moduleInfo(context.TODO(), m, fromBuildList, listRetracted)
+	return moduleInfo(ctx, rs, m, listRetracted)
 }
 
 func ModuleInfo(ctx context.Context, path string) *modinfo.ModulePublic {
@@ -71,23 +72,36 @@ func ModuleInfo(ctx context.Context, path string) *modinfo.ModulePublic {
 	listRetracted := false
 	if i := strings.Index(path, "@"); i >= 0 {
 		m := module.Version{Path: path[:i], Version: path[i+1:]}
-		fromBuildList := false
-		return moduleInfo(ctx, m, fromBuildList, listRetracted)
+		return moduleInfo(ctx, nil, m, listRetracted)
 	}
 
-	for _, m := range buildList {
-		if m.Path == path {
-			fromBuildList := true
-			return moduleInfo(ctx, m, fromBuildList, listRetracted)
+	rs := LoadModFile(ctx)
+
+	var (
+		v  string
+		ok bool
+	)
+	if go117LazyTODO {
+		v, ok = rs.rootSelected(path)
+	}
+	if !ok {
+		mg, err := rs.Graph(ctx)
+		if err != nil {
+			base.Fatalf("go: %v", err)
 		}
+		v = mg.Selected(path)
 	}
 
-	return &modinfo.ModulePublic{
-		Path: path,
-		Error: &modinfo.ModuleError{
-			Err: "module not in current build",
-		},
+	if v == "none" {
+		return &modinfo.ModulePublic{
+			Path: path,
+			Error: &modinfo.ModuleError{
+				Err: "module not in current build",
+			},
+		}
 	}
+
+	return moduleInfo(ctx, rs, module.Version{Path: path, Version: v}, listRetracted)
 }
 
 // addUpdate fills in m.Update if an updated version is available.
@@ -140,7 +154,10 @@ func addRetraction(ctx context.Context, m *modinfo.ModulePublic) {
 	}
 }
 
-func moduleInfo(ctx context.Context, m module.Version, fromBuildList, listRetracted bool) *modinfo.ModulePublic {
+// moduleInfo returns information about module m, loaded from the requirements
+// in rs (which may be nil to indicate that m was not loaded from a requirement
+// graph).
+func moduleInfo(ctx context.Context, rs *Requirements, m module.Version, listRetracted bool) *modinfo.ModulePublic {
 	if m == Target {
 		info := &modinfo.ModulePublic{
 			Path:    m.Path,
@@ -162,7 +179,7 @@ func moduleInfo(ctx context.Context, m module.Version, fromBuildList, listRetrac
 	info := &modinfo.ModulePublic{
 		Path:     m.Path,
 		Version:  m.Version,
-		Indirect: fromBuildList && loaded != nil && !loaded.direct[m.Path],
+		Indirect: rs != nil && !rs.direct[m.Path],
 	}
 	if v, ok := rawGoVersion.Load(m); ok {
 		info.GoVersion = v.(string)
@@ -171,7 +188,7 @@ func moduleInfo(ctx context.Context, m module.Version, fromBuildList, listRetrac
 	// completeFromModCache fills in the extra fields in m using the module cache.
 	completeFromModCache := func(m *modinfo.ModulePublic) {
 		checksumOk := func(suffix string) bool {
-			return !fromBuildList || m.Version == "" || cfg.BuildMod == "mod" ||
+			return rs == nil || m.Version == "" || cfg.BuildMod == "mod" ||
 				modfetch.HaveSum(module.Version{Path: m.Path, Version: m.Version + suffix})
 		}
 
@@ -215,7 +232,7 @@ func moduleInfo(ctx context.Context, m module.Version, fromBuildList, listRetrac
 		}
 	}
 
-	if !fromBuildList {
+	if rs == nil {
 		// If this was an explicitly-versioned argument to 'go mod download' or
 		// 'go list -m', report the actual requested version, not its replacement.
 		completeFromModCache(info) // Will set m.Error in vendor mode.
@@ -273,11 +290,11 @@ func PackageBuildInfo(path string, deps []string) string {
 		return ""
 	}
 
-	target := mustFindModule(path, path)
+	target := mustFindModule(loaded, path, path)
 	mdeps := make(map[module.Version]bool)
 	for _, dep := range deps {
 		if !isStandardImportPath(dep) {
-			mdeps[mustFindModule(path, dep)] = true
+			mdeps[mustFindModule(loaded, path, dep)] = true
 		}
 	}
 	var mods []module.Version
@@ -316,8 +333,8 @@ func PackageBuildInfo(path string, deps []string) string {
 //
 // TODO(jayconrod): remove this. Callers should use findModule and return
 // errors instead of relying on base.Fatalf.
-func mustFindModule(target, path string) module.Version {
-	pkg, ok := loaded.pkgCache.Get(path).(*loadPkg)
+func mustFindModule(ld *loader, target, path string) module.Version {
+	pkg, ok := ld.pkgCache.Get(path).(*loadPkg)
 	if ok {
 		if pkg.err != nil {
 			base.Fatalf("build %v: cannot load %v: %v", target, path, pkg.err)
@@ -336,8 +353,8 @@ func mustFindModule(target, path string) module.Version {
 // findModule searches for the module that contains the package at path.
 // If the package was loaded, its containing module and true are returned.
 // Otherwise, module.Version{} and false are returend.
-func findModule(path string) (module.Version, bool) {
-	if pkg, ok := loaded.pkgCache.Get(path).(*loadPkg); ok {
+func findModule(ld *loader, path string) (module.Version, bool) {
+	if pkg, ok := ld.pkgCache.Get(path).(*loadPkg); ok {
 		return pkg.mod, pkg.mod != module.Version{}
 	}
 	if path == "command-line-arguments" {
diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index 3412548efc..62e01d2fd4 100644
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -7,67 +7,401 @@ package modload
 import (
 	"cmd/go/internal/base"
 	"cmd/go/internal/cfg"
-	"cmd/go/internal/imports"
 	"cmd/go/internal/mvs"
+	"cmd/go/internal/par"
 	"context"
 	"fmt"
 	"os"
 	"reflect"
+	"runtime"
 	"strings"
+	"sync"
+	"sync/atomic"
 
 	"golang.org/x/mod/module"
 )
 
-// buildList is the list of modules to use for building packages.
-// It is initialized by calling LoadPackages or ImportFromFiles,
-// each of which uses loaded.load.
+// capVersionSlice returns s with its cap reduced to its length.
+func capVersionSlice(s []module.Version) []module.Version {
+	return s[:len(s):len(s)]
+}
+
+// A Requirements represents a logically-immutable set of root module requirements.
+type Requirements struct {
+	// rootModules is the set of module versions explicitly required by the main
+	// module, sorted and capped to length. It may contain duplicates, and may
+	// contain multiple versions for a given module path.
+	rootModules    []module.Version
+	maxRootVersion map[string]string
+
+	// direct is the set of module paths for which we believe the module provides
+	// a package directly imported by a package or test in the main module.
+	//
+	// The "direct" map controls which modules are annotated with "// indirect"
+	// comments in the go.mod file, and may impact which modules are listed as
+	// explicit roots (vs. indirect-only dependencies). However, it should not
+	// have a semantic effect on the build list overall.
+	//
+	// The initial direct map is populated from the existing "// indirect"
+	// comments (or lack thereof) in the go.mod file. It is updated by the
+	// package loader: dependencies may be promoted to direct if new
+	// direct imports are observed, and may be demoted to indirect during
+	// 'go mod tidy' or 'go mod vendor'.
+	//
+	// The direct map is keyed by module paths, not module versions. When a
+	// module's selected version changes, we assume that it remains direct if the
+	// previous version was a direct dependency. That assumption might not hold in
+	// rare cases (such as if a dependency splits out a nested module, or merges a
+	// nested module back into a parent module).
+	direct map[string]bool
+
+	graphOnce sync.Once    // guards writes to (but not reads from) graph
+	graph     atomic.Value // cachedGraph
+}
+
+// A cachedGraph is a non-nil *ModuleGraph, together with any error discovered
+// while loading that graph.
+type cachedGraph struct {
+	mg  *ModuleGraph
+	err error // If err is non-nil, mg may be incomplete (but must still be non-nil).
+}
+
+// requirements is the requirement graph for the main module.
 //
-// Ideally, exactly ONE of those functions would be called,
-// and exactly once. Most of the time, that's true.
-// During "go get" it may not be. TODO(rsc): Figure out if
-// that restriction can be established, or else document why not.
+// It is always non-nil if the main module's go.mod file has been loaded.
 //
-var buildList []module.Version
+// This variable should only be read from the LoadModFile function,
+// and should only be written in the writeGoMod function.
+// All other functions that need or produce a *Requirements should
+// accept and/or return an explicit parameter.
+var requirements *Requirements
 
-// additionalExplicitRequirements is a list of modules paths for which
-// WriteGoMod should record explicit requirements, even if they would be
-// selected without those requirements. Each path must also appear in buildList.
-var additionalExplicitRequirements []string
+// newRequirements returns a new requirement set with the given root modules.
+// The dependencies of the roots will be loaded lazily at the first call to the
+// Graph method.
+//
+// The caller must not modify the rootModules slice or direct map after passing
+// them to newRequirements.
+//
+// If vendoring is in effect, the caller must invoke initVendor on the returned
+// *Requirements before any other method.
+func newRequirements(rootModules []module.Version, direct map[string]bool) *Requirements {
+	for i, m := range rootModules {
+		if m == Target {
+			panic(fmt.Sprintf("newRequirements called with untrimmed build list: rootModules[%v] is Target", i))
+		}
+		if m.Path == "" || m.Version == "" {
+			panic(fmt.Sprintf("bad requirement: rootModules[%v] = %v", i, m))
+		}
+	}
 
-// capVersionSlice returns s with its cap reduced to its length.
-func capVersionSlice(s []module.Version) []module.Version {
-	return s[:len(s):len(s)]
+	rs := &Requirements{
+		rootModules:    rootModules,
+		maxRootVersion: make(map[string]string, len(rootModules)),
+		direct:         direct,
+	}
+	rootModules = capVersionSlice(rootModules)
+
+	for _, m := range rootModules {
+		if v, ok := rs.maxRootVersion[m.Path]; ok && cmpVersion(v, m.Version) >= 0 {
+			continue
+		}
+		rs.maxRootVersion[m.Path] = m.Version
+	}
+	return rs
+}
+
+// initVendor initializes rs.graph from the given list of vendored module
+// dependencies, overriding the graph that would normally be loaded from module
+// requirements.
+func (rs *Requirements) initVendor(vendorList []module.Version) {
+	rs.graphOnce.Do(func() {
+		mg := &ModuleGraph{
+			g: mvs.NewGraph(cmpVersion, []module.Version{Target}),
+		}
+
+		if go117LazyTODO {
+			// The roots of a lazy module should already include every module in the
+			// vendor list, because the vendored modules are the same as those
+			// maintained as roots by the lazy loading “import invariant”.
+			//
+			// TODO: Double-check here that that invariant holds.
+
+			// So we can just treat the rest of the module graph as effectively
+			// “pruned out”, like a more aggressive version of lazy loading:
+			// the root requirements *are* the complete module graph.
+			mg.g.Require(Target, rs.rootModules)
+		} else {
+			// The transitive requirements of the main module are not in general available
+			// from the vendor directory, and we don't actually know how we got from
+			// the roots to the final build list.
+			//
+			// Instead, we'll inject a fake "vendor/modules.txt" module that provides
+			// those transitive dependencies, and mark it as a dependency of the main
+			// module. That allows us to elide the actual structure of the module
+			// graph, but still distinguishes between direct and indirect
+			// dependencies.
+			vendorMod := module.Version{Path: "vendor/modules.txt", Version: ""}
+			mg.g.Require(Target, append(rs.rootModules, vendorMod))
+			mg.g.Require(vendorMod, vendorList)
+		}
+
+		rs.graph.Store(cachedGraph{mg, nil})
+	})
 }
 
-// LoadAllModules loads and returns the list of modules matching the "all"
-// module pattern, starting with the Target module and in a deterministic
-// (stable) order, without loading any packages.
+// rootSelected returns the version of the root dependency with the given module
+// path, or the zero module.Version and ok=false if the module is not a root
+// dependency.
+func (rs *Requirements) rootSelected(path string) (version string, ok bool) {
+	if path == Target.Path {
+		return Target.Version, true
+	}
+	if v, ok := rs.maxRootVersion[path]; ok {
+		return v, true
+	}
+	return "", false
+}
+
+// Graph returns the graph of module requirements loaded from the current
+// root modules (as reported by RootModules).
+//
+// Graph always makes a best effort to load the requirement graph despite any
+// errors, and always returns a non-nil *ModuleGraph.
+//
+// If the requirements of any relevant module fail to load, Graph also
+// returns a non-nil error of type *mvs.BuildListError.
+func (rs *Requirements) Graph(ctx context.Context) (*ModuleGraph, error) {
+	rs.graphOnce.Do(func() {
+		mg, mgErr := readModGraph(ctx, rs.rootModules)
+		rs.graph.Store(cachedGraph{mg, mgErr})
+	})
+	cached := rs.graph.Load().(cachedGraph)
+	return cached.mg, cached.err
+}
+
+// A ModuleGraph represents the complete graph of module dependencies
+// of a main module.
+//
+// If the main module is lazily loaded, the graph does not include
+// transitive dependencies of non-root (implicit) dependencies.
+type ModuleGraph struct {
+	g         *mvs.Graph
+	loadCache par.Cache // module.Version → summaryError
+
+	buildListOnce sync.Once
+	buildList     []module.Version
+}
+
+// A summaryError is either a non-nil modFileSummary or a non-nil error
+// encountered while reading or parsing that summary.
+type summaryError struct {
+	summary *modFileSummary
+	err     error
+}
+
+// readModGraph reads and returns the module dependency graph starting at the
+// given roots.
+//
+// Unlike LoadModGraph, readModGraph does not attempt to diagnose or update
+// inconsistent roots.
+func readModGraph(ctx context.Context, roots []module.Version) (*ModuleGraph, error) {
+	var (
+		mu       sync.Mutex // guards mg.g and hasError during loading
+		hasError bool
+		mg       = &ModuleGraph{
+			g: mvs.NewGraph(cmpVersion, []module.Version{Target}),
+		}
+	)
+	mg.g.Require(Target, roots)
+
+	var (
+		loadQueue = par.NewQueue(runtime.GOMAXPROCS(0))
+		loading   sync.Map // module.Version → nil; the set of modules that have been or are being loaded
+	)
+
+	// loadOne synchronously loads the explicit requirements for module m.
+	// It does not load the transitive requirements of m even if the go version in
+	// m's go.mod file indicates eager loading.
+	loadOne := func(m module.Version) (*modFileSummary, error) {
+		cached := mg.loadCache.Do(m, func() interface{} {
+			summary, err := goModSummary(m)
+
+			mu.Lock()
+			if err == nil {
+				mg.g.Require(m, summary.require)
+			} else {
+				hasError = true
+			}
+			mu.Unlock()
+
+			return summaryError{summary, err}
+		}).(summaryError)
+
+		return cached.summary, cached.err
+	}
+
+	var enqueue func(m module.Version)
+	enqueue = func(m module.Version) {
+		if m.Version == "none" {
+			return
+		}
+
+		if _, dup := loading.LoadOrStore(m, nil); dup {
+			// m has already been enqueued for loading. Since the requirement graph
+			// may contain cycles, we need to return early to avoid making the load
+			// queue infinitely long.
+			return
+		}
+
+		loadQueue.Add(func() {
+			summary, err := loadOne(m)
+			if err != nil {
+				return // findError will report the error later.
+			}
+
+			// If the version in m's go.mod file implies eager loading, then we cannot
+			// assume that the explicit requirements of m (added by loadOne) are
+			// sufficient to build the packages it contains. We must load its full
+			// transitive dependency graph to be sure that we see all relevant
+			// dependencies.
+			if !go117LazyTODO {
+				for _, r := range summary.require {
+					enqueue(r)
+				}
+			}
+		})
+	}
+
+	for _, m := range roots {
+		enqueue(m)
+	}
+	<-loadQueue.Idle()
+
+	if hasError {
+		return mg, mg.findError()
+	}
+	return mg, nil
+}
+
+// RequiredBy returns the dependencies required by module m in the graph,
+// or ok=false if module m's dependencies are not relevant (such as if they
+// are pruned out by lazy loading).
+//
+// The caller must not modify the returned slice, but may safely append to it
+// and may rely on it not to be modified.
+func (mg *ModuleGraph) RequiredBy(m module.Version) (reqs []module.Version, ok bool) {
+	return mg.g.RequiredBy(m)
+}
+
+// Selected returns the selected version of the module with the given path.
+//
+// If no version is selected, Selected returns version "none".
+func (mg *ModuleGraph) Selected(path string) (version string) {
+	return mg.g.Selected(path)
+}
+
+// WalkBreadthFirst invokes f once, in breadth-first order, for each module
+// version other than "none" that appears in the graph, regardless of whether
+// that version is selected.
+func (mg *ModuleGraph) WalkBreadthFirst(f func(m module.Version)) {
+	mg.g.WalkBreadthFirst(f)
+}
+
+// BuildList returns the selected versions of all modules present in the graph,
+// beginning with Target.
+//
+// The order of the remaining elements in the list is deterministic
+// but arbitrary.
+//
+// The caller must not modify the returned list, but may safely append to it
+// and may rely on it not to be modified.
+func (mg *ModuleGraph) BuildList() []module.Version {
+	mg.buildListOnce.Do(func() {
+		mg.buildList = capVersionSlice(mg.g.BuildList())
+	})
+	return mg.buildList
+}
+
+func (mg *ModuleGraph) findError() error {
+	errStack := mg.g.FindPath(func(m module.Version) bool {
+		cached := mg.loadCache.Get(m)
+		return cached != nil && cached.(summaryError).err != nil
+	})
+	if len(errStack) > 0 {
+		err := mg.loadCache.Get(errStack[len(errStack)-1]).(summaryError).err
+		var noUpgrade func(from, to module.Version) bool
+		return mvs.NewBuildListError(err, errStack, noUpgrade)
+	}
+
+	return nil
+}
+
+func (mg *ModuleGraph) allRootsSelected() bool {
+	roots, _ := mg.g.RequiredBy(Target)
+	for _, m := range roots {
+		if mg.Selected(m.Path) != m.Version {
+			return false
+		}
+	}
+	return true
+}
+
+// LoadModGraph loads and returns the graph of module dependencies of the main module,
+// without loading any packages.
 //
 // Modules are loaded automatically (and lazily) in LoadPackages:
-// LoadAllModules need only be called if LoadPackages is not,
+// LoadModGraph need only be called if LoadPackages is not,
 // typically in commands that care about modules but no particular package.
-//
-// The caller must not modify the returned list, but may append to it.
-func LoadAllModules(ctx context.Context) []module.Version {
-	LoadModFile(ctx)
-	ReloadBuildList()
-	WriteGoMod()
-	return capVersionSlice(buildList)
+func LoadModGraph(ctx context.Context) *ModuleGraph {
+	rs, mg, err := expandGraph(ctx, LoadModFile(ctx))
+	if err != nil {
+		base.Fatalf("go: %v", err)
+	}
+
+	commitRequirements(ctx, rs)
+	return mg
 }
 
-// Selected returns the selected version of the module with the given path, or
-// the empty string if the given module has no selected version
-// (either because it is not required or because it is the Target module).
-func Selected(path string) (version string) {
-	if path == Target.Path {
-		return ""
+// expandGraph loads the complete module graph from rs.
+//
+// If the complete graph reveals that some root of rs is not actually the
+// selected version of its path, expandGraph computes a new set of roots that
+// are consistent. (When lazy loading is implemented, this may result in
+// upgrades to other modules due to requirements that were previously pruned
+// out.)
+//
+// expandGraph returns the updated roots, along with the module graph loaded
+// from those roots and any error encountered while loading that graph.
+// expandGraph returns non-nil requirements and a non-nil graph regardless of
+// errors. On error, the roots might not be updated to be consistent.
+func expandGraph(ctx context.Context, rs *Requirements) (*Requirements, *ModuleGraph, error) {
+	mg, mgErr := rs.Graph(ctx)
+	if mgErr != nil {
+		// Without the graph, we can't update the roots: we don't know which
+		// versions of transitive dependencies would be selected.
+		return rs, mg, mgErr
 	}
-	for _, m := range buildList {
-		if m.Path == path {
-			return m.Version
+
+	if !mg.allRootsSelected() {
+		// The roots of rs are not consistent with the rest of the graph. Update
+		// them. In an eager module this is a no-op for the build list as a whole —
+		// it just promotes what were previously transitive requirements to be
+		// roots — but in a lazy module it may pull in previously-irrelevant
+		// transitive dependencies.
+
+		newRS, rsErr := updateRoots(ctx, rs.direct, nil, rs)
+		if rsErr != nil {
+			// Failed to update roots, perhaps because of an error in a transitive
+			// dependency needed for the update. Return the original Requirements
+			// instead.
+			return rs, mg, rsErr
 		}
+		rs = newRS
+		mg, mgErr = rs.Graph(ctx)
 	}
-	return ""
+
+	return rs, mg, mgErr
 }
 
 // EditBuildList edits the global build list by first adding every module in add
@@ -82,12 +416,29 @@ func Selected(path string) (version string) {
 // If the versions listed in mustSelect are mutually incompatible (due to one of
 // the listed modules requiring a higher version of another), EditBuildList
 // returns a *ConstraintError and leaves the build list in its previous state.
+//
+// On success, EditBuildList reports whether the selected version of any module
+// in the build list may have been changed (possibly to or from "none") as a
+// result.
 func EditBuildList(ctx context.Context, add, mustSelect []module.Version) (changed bool, err error) {
-	LoadModFile(ctx)
+	rs, changed, err := editRequirements(ctx, LoadModFile(ctx), add, mustSelect)
+	if err != nil {
+		return false, err
+	}
+	commitRequirements(ctx, rs)
+	return changed, err
+}
+
+func editRequirements(ctx context.Context, rs *Requirements, add, mustSelect []module.Version) (edited *Requirements, changed bool, err error) {
+	mg, err := rs.Graph(ctx)
+	if err != nil {
+		return nil, false, err
+	}
+	buildList := mg.BuildList()
 
 	final, err := editBuildList(ctx, buildList, add, mustSelect)
 	if err != nil {
-		return false, err
+		return nil, false, err
 	}
 
 	selected := make(map[string]module.Version, len(final))
@@ -107,18 +458,58 @@ func EditBuildList(ctx context.Context, add, mustSelect []module.Version) (chang
 	}
 
 	if !inconsistent {
-		additionalExplicitRequirements = make([]string, 0, len(mustSelect))
+		changed := false
+		if !reflect.DeepEqual(final, buildList) {
+			changed = true
+		} else if len(mustSelect) == 0 {
+			// No change to the build list and no explicit roots to promote, so we're done.
+			return rs, false, nil
+		}
+
+		var rootPaths []string
 		for _, m := range mustSelect {
-			if m.Version != "none" {
-				additionalExplicitRequirements = append(additionalExplicitRequirements, m.Path)
+			if m.Version != "none" && m.Path != Target.Path {
+				rootPaths = append(rootPaths, m.Path)
 			}
 		}
-		changed := false
-		if !reflect.DeepEqual(buildList, final) {
-			buildList = final
-			changed = true
+		for _, m := range final[1:] {
+			if v, ok := rs.rootSelected(m.Path); ok && (v == m.Version || rs.direct[m.Path]) {
+				// m.Path was formerly a root, and either its version hasn't changed or
+				// we believe that it provides a package directly imported by a package
+				// or test in the main module. For now we'll assume that it is still
+				// relevant. If we actually load all of the packages and tests in the
+				// main module (which we are not doing here), we can revise the explicit
+				// roots at that point.
+				rootPaths = append(rootPaths, m.Path)
+			}
 		}
-		return changed, nil
+
+		if go117LazyTODO {
+			// mvs.Req is not lazy, and in a lazily-loaded module we don't want
+			// to minimize the roots anyway. (Instead, we want to retain explicit
+			// root paths so that they remain explicit: only 'go mod tidy' should
+			// remove roots.)
+		}
+
+		min, err := mvs.Req(Target, rootPaths, &mvsReqs{buildList: final})
+		if err != nil {
+			return nil, false, err
+		}
+
+		// A module that is not even in the build list necessarily cannot provide
+		// any imported packages. Mark as direct only the direct modules that are
+		// still in the build list.
+		//
+		// TODO(bcmills): Would it make more sense to leave the direct map as-is
+		// but allow it to refer to modules that are no longer in the build list?
+		// That might complicate updateRoots, but it may be cleaner in other ways.
+		direct := make(map[string]bool, len(rs.direct))
+		for _, m := range final {
+			if rs.direct[m.Path] {
+				direct[m.Path] = true
+			}
+		}
+		return newRequirements(min, direct), changed, nil
 	}
 
 	// We overshot one or more of the modules in mustSelect, which means that
@@ -141,7 +532,7 @@ func EditBuildList(ctx context.Context, add, mustSelect []module.Version) (chang
 		m, queue = queue[0], queue[1:]
 		required, err := reqs.Required(m)
 		if err != nil {
-			return false, err
+			return nil, false, err
 		}
 		for _, r := range required {
 			if _, ok := reason[r]; !ok {
@@ -169,7 +560,7 @@ func EditBuildList(ctx context.Context, add, mustSelect []module.Version) (chang
 		}
 	}
 
-	return false, &ConstraintError{
+	return nil, false, &ConstraintError{
 		Conflicts: conflicts,
 	}
 }
@@ -199,61 +590,181 @@ type Conflict struct {
 	Constraint module.Version
 }
 
-// ReloadBuildList resets the state of loaded packages, then loads and returns
-// the build list set by EditBuildList.
-func ReloadBuildList() []module.Version {
-	loaded = loadFromRoots(loaderParams{
-		PackageOpts: PackageOpts{
-			Tags: imports.Tags(),
-		},
-		listRoots:          func() []string { return nil },
-		allClosesOverTests: index.allPatternClosesOverTests(), // but doesn't matter because the root list is empty.
-	})
-	return capVersionSlice(buildList)
-}
-
 // TidyBuildList trims the build list to the minimal requirements needed to
 // retain the same versions of all packages from the preceding call to
 // LoadPackages.
-func TidyBuildList() {
-	used := map[module.Version]bool{Target: true}
-	for _, pkg := range loaded.pkgs {
-		used[pkg.mod] = true
-	}
-
-	keep := []module.Version{Target}
-	var direct []string
-	for _, m := range buildList[1:] {
-		if used[m] {
-			keep = append(keep, m)
-			if loaded.direct[m.Path] {
-				direct = append(direct, m.Path)
-			}
-		} else if cfg.BuildV {
-			if _, ok := index.require[m]; ok {
+func TidyBuildList(ctx context.Context) {
+	if loaded == nil {
+		panic("internal error: TidyBuildList called when no packages have been loaded")
+	}
+
+	if go117LazyTODO {
+		// Tidy needs to maintain the lazy-loading invariants for lazy modules.
+		// The implementation for eager modules should be factored out into a function.
+	}
+
+	tidy, err := updateRoots(ctx, loaded.requirements.direct, loaded.pkgs, nil)
+	if err != nil {
+		base.Fatalf("go: %v", err)
+	}
+
+	if cfg.BuildV {
+		mg, _ := tidy.Graph(ctx)
+
+		for _, m := range LoadModFile(ctx).rootModules {
+			if mg.Selected(m.Path) == "none" {
 				fmt.Fprintf(os.Stderr, "unused %s\n", m.Path)
+			} else if go117LazyTODO {
+				// If the main module is lazy and we demote a root to a non-root
+				// (because it is not actually relevant), should we log that too?
 			}
 		}
 	}
 
-	min, err := mvs.Req(Target, direct, &mvsReqs{buildList: keep})
+	commitRequirements(ctx, tidy)
+}
+
+// updateRoots returns a set of root requirements that includes the selected
+// version of every module path in direct as a root, and maintains the selected
+// versions of every module selected in the graph of rs (if rs is non-nil), or
+// every module that provides any package in pkgs (otherwise).
+//
+// If pkgs is non-empty and rs is non-nil, the packages are assumed to be loaded
+// from the modules selected in the graph of rs.
+//
+// The roots are updated such that:
+//
+// 	1. The selected version of every module path in direct is included as a root
+// 	   (if it is not "none").
+// 	2. Each root is the selected version of its path. (We say that such a root
+// 	   set is “consistent”.)
+// 	3. The selected version of the module providing each package in pkgs remains
+// 	   selected.
+// 	4. If rs is non-nil, every version selected in the graph of rs remains selected.
+func updateRoots(ctx context.Context, direct map[string]bool, pkgs []*loadPkg, rs *Requirements) (*Requirements, error) {
+	var (
+		rootPaths   []string // module paths that should be included as roots
+		inRootPaths = map[string]bool{}
+	)
+
+	var keep []module.Version
+	if rs != nil {
+		mg, err := rs.Graph(ctx)
+		if err != nil {
+			// We can't ignore errors in the module graph even if the user passed the -e
+			// flag to try to push past them. If we can't load the complete module
+			// dependencies, then we can't reliably compute a minimal subset of them.
+			return rs, err
+		}
+		keep = mg.BuildList()
+
+		for _, root := range rs.rootModules {
+			// If the selected version of the root is the same as what was already
+			// listed in the go.mod file, retain it as a root (even if redundant) to
+			// avoid unnecessary churn. (See https://golang.org/issue/34822.)
+			//
+			// We do this even for indirect requirements, since we don't know why they
+			// were added and they could become direct at any time.
+			if !inRootPaths[root.Path] && mg.Selected(root.Path) == root.Version {
+				rootPaths = append(rootPaths, root.Path)
+				inRootPaths[root.Path] = true
+			}
+		}
+	} else {
+		keep = append(keep, Target)
+		kept := map[module.Version]bool{Target: true}
+		for _, pkg := range pkgs {
+			if pkg.mod.Path != "" && !kept[pkg.mod] {
+				keep = append(keep, pkg.mod)
+				kept[pkg.mod] = true
+			}
+		}
+	}
+
+	// “The selected version of every module path in direct is included as a root.”
+	//
+	// This is only for convenience and clarity for end users: the choice of
+	// explicit vs. implicit dependency has no impact on MVS selection (for itself
+	// or any other module).
+	if go117LazyTODO {
+		// Update the above comment to reflect lazy loading once implemented.
+	}
+	for _, m := range keep {
+		if direct[m.Path] && !inRootPaths[m.Path] {
+			rootPaths = append(rootPaths, m.Path)
+			inRootPaths[m.Path] = true
+		}
+	}
+
+	if cfg.BuildMod != "mod" {
+		// Instead of actually updating the requirements, just check that no updates
+		// are needed.
+		if rs == nil {
+			// We're being asked to reconstruct the requirements from scratch,
+			// but we aren't even allowed to modify them.
+			return rs, errGoModDirty
+		}
+		for _, mPath := range rootPaths {
+			if _, ok := rs.rootSelected(mPath); !ok {
+				// Module m is supposed to be listed explicitly, but isn't.
+				//
+				// Note that this condition is also detected (and logged with more
+				// detail) earlier during package loading, so it shouldn't actually be
+				// possible at this point — this is just a defense in depth.
+				return rs, errGoModDirty
+			}
+		}
+		for _, m := range keep {
+			if v, ok := rs.rootSelected(m.Path); ok && v != m.Version {
+				// The root version v is misleading: the actual selected version is
+				// m.Version.
+				return rs, errGoModDirty
+			}
+		}
+		for _, m := range rs.rootModules {
+			if v, ok := rs.rootSelected(m.Path); ok && v != m.Version {
+				// The roots list both m.Version and some higher version of m.Path.
+				// The root for m.Version is misleading: the actual selected version is
+				// *at least* v.
+				return rs, errGoModDirty
+			}
+		}
+
+		// No explicit roots are missing and all roots are already at the versions
+		// we want to keep. Any other changes we would make are purely cosmetic,
+		// such as pruning redundant indirect dependencies. Per issue #34822, we
+		// ignore cosmetic changes when we cannot update the go.mod file.
+		return rs, nil
+	}
+
+	min, err := mvs.Req(Target, rootPaths, &mvsReqs{buildList: keep})
 	if err != nil {
-		base.Fatalf("go: %v", err)
+		return rs, err
 	}
-	buildList = append([]module.Version{Target}, min...)
+
+	// Note: if it turns out that we spend a lot of time reconstructing module
+	// graphs after this point, we could make some effort here to detect whether
+	// the root set is the same as the original root set in rs and recycle its
+	// module graph and build list, if they have already been loaded.
+
+	return newRequirements(min, direct), nil
 }
 
 // checkMultiplePaths verifies that a given module path is used as itself
 // or as a replacement for another module, but not both at the same time.
 //
 // (See https://golang.org/issue/26607 and https://golang.org/issue/34650.)
-func checkMultiplePaths() {
-	firstPath := make(map[module.Version]string, len(buildList))
-	for _, mod := range buildList {
-		src := mod
-		if rep := Replacement(mod); rep.Path != "" {
-			src = rep
+func checkMultiplePaths(rs *Requirements) {
+	mods := rs.rootModules
+	if cached := rs.graph.Load(); cached != nil {
+		if mg := cached.(cachedGraph).mg; mg != nil {
+			mods = mg.BuildList()
 		}
+	}
+
+	firstPath := map[module.Version]string{}
+	for _, mod := range mods {
+		src := resolveReplacement(mod)
 		if prev, ok := firstPath[src]; !ok {
 			firstPath[src] = mod.Path
 		} else if prev != mod.Path {
diff --git a/src/cmd/go/internal/modload/import.go b/src/cmd/go/internal/modload/import.go
index 31eb0c4874..508db2f247 100644
--- a/src/cmd/go/internal/modload/import.go
+++ b/src/cmd/go/internal/modload/import.go
@@ -12,6 +12,7 @@ import (
 	"internal/goroot"
 	"io/fs"
 	"os"
+	pathpkg "path"
 	"path/filepath"
 	"sort"
 	"strings"
@@ -202,20 +203,20 @@ func (e *invalidImportError) Unwrap() error {
 	return e.err
 }
 
-// importFromBuildList finds the module and directory in the build list
+// importFromModules finds the module and directory in the build list
 // containing the package with the given import path. The answer must be unique:
-// importFromBuildList returns an error if multiple modules attempt to provide
+// importFromModules returns an error if multiple modules attempt to provide
 // the same package.
 //
-// importFromBuildList can return a module with an empty m.Path, for packages in
+// importFromModules can return a module with an empty m.Path, for packages in
 // the standard library.
 //
-// importFromBuildList can return an empty directory string, for fake packages
+// importFromModules can return an empty directory string, for fake packages
 // like "C" and "unsafe".
 //
-// If the package cannot be found in buildList,
-// importFromBuildList returns an *ImportMissingError.
-func importFromBuildList(ctx context.Context, path string, buildList []module.Version) (m module.Version, dir string, err error) {
+// If the package is not present in any module selected from the requirement
+// graph, importFromModules returns an *ImportMissingError.
+func importFromModules(ctx context.Context, path string, rs *Requirements) (m module.Version, dir string, err error) {
 	if strings.Contains(path, "@") {
 		return module.Version{}, "", fmt.Errorf("import path should not have @version")
 	}
@@ -269,12 +270,34 @@ func importFromBuildList(ctx context.Context, path string, buildList []module.Ve
 	// Check each module on the build list.
 	var dirs []string
 	var mods []module.Version
+
+	// Iterate over possible modules for the path, not all selected modules.
+	// Iterating over selected modules would make the overall loading time
+	// O(M × P) for M modules providing P imported packages, whereas iterating
+	// over path prefixes is only O(P × k) with maximum path depth k. For
+	// large projects both M and P may be very large (note that M ≤ P), but k
+	// will tend to remain smallish (if for no other reason than filesystem
+	// path limitations).
+	var mg *ModuleGraph
+	if go117LazyTODO {
+		// Pull the prefix-matching loop below into another (new) loop.
+		// If the main module is lazy, try it once with mg == nil, and then load mg
+		// and try again.
+	} else {
+		mg, err = rs.Graph(ctx)
+		if err != nil {
+			return module.Version{}, "", &ImportMissingError{Path: path, QueryErr: err}
+		}
+	}
+
 	var sumErrMods []module.Version
-	for _, m := range buildList {
-		if !maybeInModule(path, m.Path) {
-			// Avoid possibly downloading irrelevant modules.
+	for prefix := path; prefix != "."; prefix = pathpkg.Dir(prefix) {
+		v := mg.Selected(prefix)
+		if v == "none" {
 			continue
 		}
+		m := module.Version{Path: prefix, Version: v}
+
 		needSum := true
 		root, isLocal, err := fetch(ctx, m, needSum)
 		if err != nil {
@@ -283,7 +306,7 @@ func importFromBuildList(ctx context.Context, path string, buildList []module.Ve
 				// We can't verify that the package is unique, and we may not find
 				// the package at all. Keep checking other modules to decide which
 				// error to report. Multiple sums may be missing if we need to look in
-				// multiple nested modules to resolve the import.
+				// multiple nested modules to resolve the import; we'll report them all.
 				sumErrMods = append(sumErrMods, m)
 				continue
 			}
@@ -302,20 +325,37 @@ func importFromBuildList(ctx context.Context, path string, buildList []module.Ve
 			dirs = append(dirs, dir)
 		}
 	}
+
 	if len(mods) > 1 {
+		// We produce the list of directories from longest to shortest candidate
+		// module path, but the AmbiguousImportError should report them from
+		// shortest to longest. Reverse them now.
+		for i := 0; i < len(mods)/2; i++ {
+			j := len(mods) - 1 - i
+			mods[i], mods[j] = mods[j], mods[i]
+			dirs[i], dirs[j] = dirs[j], dirs[i]
+		}
 		return module.Version{}, "", &AmbiguousImportError{importPath: path, Dirs: dirs, Modules: mods}
 	}
+
 	if len(sumErrMods) > 0 {
+		for i := 0; i < len(sumErrMods)/2; i++ {
+			j := len(sumErrMods) - 1 - i
+			sumErrMods[i], sumErrMods[j] = sumErrMods[j], sumErrMods[i]
+		}
 		return module.Version{}, "", &ImportMissingSumError{
 			importPath: path,
 			mods:       sumErrMods,
 			found:      len(mods) > 0,
 		}
 	}
+
 	if len(mods) == 1 {
 		return mods[0], dirs[0], nil
 	}
 
+	// We checked the full module graph and still didn't find the
+	// requested package.
 	var queryErr error
 	if !HasModRoot() {
 		queryErr = ErrNoModRoot
@@ -328,7 +368,7 @@ func importFromBuildList(ctx context.Context, path string, buildList []module.Ve
 //
 // Unlike QueryPattern, queryImport prefers to add a replaced version of a
 // module *before* checking the proxies for a version to add.
-func queryImport(ctx context.Context, path string) (module.Version, error) {
+func queryImport(ctx context.Context, path string, rs *Requirements) (module.Version, error) {
 	// To avoid spurious remote fetches, try the latest replacement for each
 	// module (golang.org/issue/26241).
 	if index != nil {
@@ -417,7 +457,12 @@ func queryImport(ctx context.Context, path string) (module.Version, error) {
 	// and return m, dir, ImpportMissingError.
 	fmt.Fprintf(os.Stderr, "go: finding module for package %s\n", path)
 
-	candidates, err := QueryPackages(ctx, path, "latest", Selected, CheckAllowed)
+	mg, err := rs.Graph(ctx)
+	if err != nil {
+		return module.Version{}, err
+	}
+
+	candidates, err := QueryPackages(ctx, path, "latest", mg.Selected, CheckAllowed)
 	if err != nil {
 		if errors.Is(err, fs.ErrNotExist) {
 			// Return "cannot find module providing package […]" instead of whatever
@@ -430,28 +475,21 @@ func queryImport(ctx context.Context, path string) (module.Version, error) {
 
 	candidate0MissingVersion := ""
 	for i, c := range candidates {
-		cm := c.Mod
-		canAdd := true
-		for _, bm := range buildList {
-			if bm.Path == cm.Path && semver.Compare(bm.Version, cm.Version) > 0 {
-				// QueryPattern proposed that we add module cm to provide the package,
-				// but we already depend on a newer version of that module (and we don't
-				// have the package).
-				//
-				// This typically happens when a package is present at the "@latest"
-				// version (e.g., v1.0.0) of a module, but we have a newer version
-				// of the same module in the build list (e.g., v1.0.1-beta), and
-				// the package is not present there.
-				canAdd = false
-				if i == 0 {
-					candidate0MissingVersion = bm.Version
-				}
-				break
+		if v := mg.Selected(c.Mod.Path); semver.Compare(v, c.Mod.Version) > 0 {
+			// QueryPattern proposed that we add module c.Mod to provide the package,
+			// but we already depend on a newer version of that module (and that
+			// version doesn't have the package).
+			//
+			// This typically happens when a package is present at the "@latest"
+			// version (e.g., v1.0.0) of a module, but we have a newer version
+			// of the same module in the build list (e.g., v1.0.1-beta), and
+			// the package is not present there.
+			if i == 0 {
+				candidate0MissingVersion = v
 			}
+			continue
 		}
-		if canAdd {
-			return cm, nil
-		}
+		return c.Mod, nil
 	}
 	return module.Version{}, &ImportMissingError{
 		Path:              path,
diff --git a/src/cmd/go/internal/modload/import_test.go b/src/cmd/go/internal/modload/import_test.go
index 9420dc5646..e52a7fa66b 100644
--- a/src/cmd/go/internal/modload/import_test.go
+++ b/src/cmd/go/internal/modload/import_test.go
@@ -69,11 +69,12 @@ func TestQueryImport(t *testing.T) {
 	RootMode = NoRoot
 
 	ctx := context.Background()
+	rs := newRequirements(nil, nil)
 
 	for _, tt := range importTests {
 		t.Run(strings.ReplaceAll(tt.path, "/", "_"), func(t *testing.T) {
 			// Note that there is no build list, so Import should always fail.
-			m, err := queryImport(ctx, tt.path)
+			m, err := queryImport(ctx, tt.path, rs)
 
 			if tt.err == "" {
 				if err != nil {
diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index dd97a6bfb9..d385af0ba3 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -15,10 +15,8 @@ import (
 	"os"
 	"path"
 	"path/filepath"
-	"sort"
 	"strconv"
 	"strings"
-	"sync"
 
 	"cmd/go/internal/base"
 	"cmd/go/internal/cfg"
@@ -26,9 +24,7 @@ import (
 	"cmd/go/internal/lockedfile"
 	"cmd/go/internal/modconv"
 	"cmd/go/internal/modfetch"
-	"cmd/go/internal/mvs"
 	"cmd/go/internal/search"
-	"cmd/go/internal/str"
 
 	"golang.org/x/mod/modfile"
 	"golang.org/x/mod/module"
@@ -90,7 +86,7 @@ const (
 
 // ModFile returns the parsed go.mod file.
 //
-// Note that after calling LoadPackages or LoadAllModules,
+// Note that after calling LoadPackages or LoadModGraph,
 // the require statements in the modfile.File are no longer
 // the source of truth and will be ignored: edits made directly
 // will be lost at the next call to WriteGoMod.
@@ -351,6 +347,20 @@ func die() {
 
 var ErrNoModRoot = errors.New("go.mod file not found in current directory or any parent directory; see 'go help modules'")
 
+type goModDirtyError struct{}
+
+func (goModDirtyError) Error() string {
+	if cfg.BuildModExplicit {
+		return fmt.Sprintf("updates to go.mod needed, disabled by -mod=%v; to update it:\n\tgo mod tidy", cfg.BuildMod)
+	}
+	if cfg.BuildModReason != "" {
+		return fmt.Sprintf("updates to go.mod needed, disabled by -mod=%s\n\t(%s)\n\tto update it:\n\t", cfg.BuildMod, cfg.BuildModReason)
+	}
+	return "updates to go.mod needed; to update it:\n\tgo mod tidy"
+}
+
+var errGoModDirty error = goModDirtyError{}
+
 // LoadModFile sets Target and, if there is a main module, parses the initial
 // build list from its go.mod file.
 //
@@ -360,18 +370,26 @@ var ErrNoModRoot = errors.New("go.mod file not found in current directory or any
 //
 // As a side-effect, LoadModFile may change cfg.BuildMod to "vendor" if
 // -mod wasn't set explicitly and automatic vendoring should be enabled.
-func LoadModFile(ctx context.Context) {
-	if len(buildList) > 0 {
-		return
+//
+// If LoadModFile or CreateModFile has already been called, LoadModFile returns
+// the existing in-memory requirements (rather than re-reading them from disk).
+//
+// LoadModFile checks the roots of the module graph for consistency with each
+// other, but unlike LoadModGraph does not load the full module graph or check
+// it for global consistency. Most callers outside of the modload package should
+// use LoadModGraph instead.
+func LoadModFile(ctx context.Context) *Requirements {
+	if requirements != nil {
+		return requirements
 	}
 
 	Init()
 	if modRoot == "" {
 		Target = module.Version{Path: "command-line-arguments"}
 		targetPrefix = "command-line-arguments"
-		buildList = []module.Version{Target}
 		rawGoVersion.Store(Target, latestGoVersion())
-		return
+		commitRequirements(ctx, newRequirements(nil, nil))
+		return requirements
 	}
 
 	gomod := ModFilePath()
@@ -400,10 +418,12 @@ func LoadModFile(ctx context.Context) {
 	}
 
 	setDefaultBuildMod() // possibly enable automatic vendoring
-	buildList = modFileToBuildList(modFile)
+	rs := requirementsFromModFile(ctx, f)
+
 	if cfg.BuildMod == "vendor" {
 		readVendorList()
 		checkVendorConsistency()
+		rs.initVendor(vendorList)
 	}
 	if index.goVersionV == "" {
 		// The main module necessarily has a go.mod file, and that file lacks a
@@ -428,7 +448,6 @@ func LoadModFile(ctx context.Context) {
 			// If we are running 'go mod tidy' in particular, we will have enough
 			// information to upgrade the 'go' version after loading is complete.
 			addGoStmt(latestGoVersion())
-			WriteGoMod()
 		} else {
 			// Reproducibility requires that if we change the semantics of a module,
 			// we write some explicit change to its go.mod file. We cannot write to
@@ -438,6 +457,10 @@ func LoadModFile(ctx context.Context) {
 			rawGoVersion.Store(Target, "1.11")
 		}
 	}
+
+	// Fix up roots if inconsistent.
+	commitRequirements(ctx, rs)
+	return requirements
 }
 
 // CreateModFile initializes a new module by creating a go.mod file.
@@ -481,8 +504,7 @@ func CreateModFile(ctx context.Context, modPath string) {
 		base.Fatalf("go: %v", err)
 	}
 
-	buildList = modFileToBuildList(modFile)
-	WriteGoMod()
+	commitRequirements(ctx, requirementsFromModFile(ctx, modFile))
 
 	// Suggest running 'go mod tidy' unless the project is empty. Even if we
 	// imported all the correct requirements above, we're probably missing
@@ -628,9 +650,11 @@ func initTarget(m module.Version) {
 	}
 }
 
-// modFileToBuildList returns the list of non-excluded requirements from f.
-func modFileToBuildList(f *modfile.File) []module.Version {
-	list := []module.Version{Target}
+// requirementsFromModFile returns the set of non-excluded requirements from f.
+func requirementsFromModFile(ctx context.Context, f *modfile.File) *Requirements {
+	roots := make([]module.Version, 0, len(f.Require))
+	mPathCount := map[string]int{Target.Path: 1}
+	direct := map[string]bool{}
 	for _, r := range f.Require {
 		if index != nil && index.exclude[r.Mod] {
 			if cfg.BuildMod == "mod" {
@@ -638,11 +662,33 @@ func modFileToBuildList(f *modfile.File) []module.Version {
 			} else {
 				fmt.Fprintf(os.Stderr, "go: ignoring requirement on excluded version %s %s\n", r.Mod.Path, r.Mod.Version)
 			}
-		} else {
-			list = append(list, r.Mod)
+			continue
+		}
+
+		roots = append(roots, r.Mod)
+		mPathCount[r.Mod.Path]++
+		if !r.Indirect {
+			direct[r.Mod.Path] = true
+		}
+	}
+	module.Sort(roots)
+	rs := newRequirements(roots, direct)
+
+	// If any module path appears more than once in the roots, we know that the
+	// go.mod file needs to be updated even though we have not yet loaded any
+	// transitive dependencies.
+	for _, n := range mPathCount {
+		if n > 1 {
+			var err error
+			rs, err = updateRoots(ctx, rs.direct, nil, rs)
+			if err != nil {
+				base.Fatalf("go: %v", err)
+			}
+			break
 		}
 	}
-	return list
+
+	return rs
 }
 
 // setDefaultBuildMod sets a default value for cfg.BuildMod if the -mod flag
@@ -911,67 +957,44 @@ func AllowWriteGoMod() {
 	allowWriteGoMod = true
 }
 
-// MinReqs returns a Reqs with minimal additional dependencies of Target,
-// as will be written to go.mod.
-func MinReqs() mvs.Reqs {
-	retain := append([]string{}, additionalExplicitRequirements...)
-	for _, m := range buildList[1:] {
-		_, explicit := index.require[m]
-		if explicit || loaded.direct[m.Path] {
-			retain = append(retain, m.Path)
-		}
-	}
-	sort.Strings(retain)
-	str.Uniq(&retain)
-	min, err := mvs.Req(Target, retain, &mvsReqs{buildList: buildList})
-	if err != nil {
-		base.Fatalf("go: %v", err)
+// WriteGoMod writes the current build list back to go.mod.
+func WriteGoMod(ctx context.Context) {
+	if !allowWriteGoMod {
+		panic("WriteGoMod called while disallowed")
 	}
-	return &mvsReqs{buildList: append([]module.Version{Target}, min...)}
+	commitRequirements(ctx, LoadModFile(ctx))
 }
 
-// WriteGoMod writes the current build list back to go.mod.
-func WriteGoMod() {
-	// If we're using -mod=vendor we basically ignored
-	// go.mod, so definitely don't try to write back our
-	// incomplete view of the world.
-	if !allowWriteGoMod || cfg.BuildMod == "vendor" {
+// commitRequirements writes sets the global requirements variable to rs and
+// writes its contents back to the go.mod file on disk.
+func commitRequirements(ctx context.Context, rs *Requirements) {
+	requirements = rs
+
+	if !allowWriteGoMod {
+		// Some package outside of modload promised to update the go.mod file later.
 		return
 	}
 
-	// If we aren't in a module, we don't have anywhere to write a go.mod file.
 	if modRoot == "" {
+		// We aren't in a module, so we don't have anywhere to write a go.mod file.
 		return
 	}
 
-	if loaded != nil {
-		reqs := MinReqs()
-		min, err := reqs.Required(Target)
-		if err != nil {
-			base.Fatalf("go: %v", err)
-		}
-		var list []*modfile.Require
-		for _, m := range min {
-			list = append(list, &modfile.Require{
-				Mod:      m,
-				Indirect: !loaded.direct[m.Path],
-			})
-		}
-		modFile.SetRequire(list)
+	var list []*modfile.Require
+	for _, m := range rs.rootModules {
+		list = append(list, &modfile.Require{
+			Mod:      m,
+			Indirect: !rs.direct[m.Path],
+		})
 	}
+	modFile.SetRequire(list)
 	modFile.Cleanup()
 
 	dirty := index.modFileIsDirty(modFile)
-	if dirty && cfg.BuildMod == "readonly" {
+	if dirty && cfg.BuildMod != "mod" {
 		// If we're about to fail due to -mod=readonly,
 		// prefer to report a dirty go.mod over a dirty go.sum
-		if cfg.BuildModExplicit {
-			base.Fatalf("go: updates to go.mod needed, disabled by -mod=readonly")
-		} else if cfg.BuildModReason != "" {
-			base.Fatalf("go: updates to go.mod needed, disabled by -mod=readonly\n\t(%s)", cfg.BuildModReason)
-		} else {
-			base.Fatalf("go: updates to go.mod needed; to update it:\n\tgo mod tidy")
-		}
+		base.Fatalf("go: %v", errGoModDirty)
 	}
 
 	if !dirty && cfg.CmdName != "mod tidy" {
@@ -980,7 +1003,7 @@ func WriteGoMod() {
 		// Don't write go.mod, but write go.sum in case we added or trimmed sums.
 		// 'go mod init' shouldn't write go.sum, since it will be incomplete.
 		if cfg.CmdName != "mod init" {
-			modfetch.WriteGoSum(keepSums(true))
+			modfetch.WriteGoSum(keepSums(ctx, loaded, rs, addBuildListZipSums))
 		}
 		return
 	}
@@ -996,7 +1019,7 @@ func WriteGoMod() {
 		// Update go.sum after releasing the side lock and refreshing the index.
 		// 'go mod init' shouldn't write go.sum, since it will be incomplete.
 		if cfg.CmdName != "mod init" {
-			modfetch.WriteGoSum(keepSums(true))
+			modfetch.WriteGoSum(keepSums(ctx, loaded, rs, addBuildListZipSums))
 		}
 	}()
 
@@ -1033,105 +1056,75 @@ func WriteGoMod() {
 	}
 }
 
-// keepSums returns a set of module sums to preserve in go.sum. The set
-// includes entries for all modules used to load packages (according to
-// the last load function such as LoadPackages or ImportFromFiles).
-// It also contains entries for go.mod files needed for MVS (the version
-// of these entries ends with "/go.mod").
-//
-// If keepBuildListZips is true, the set also includes sums for zip files for
-// all modules in the build list with replacements applied. 'go get' and
-// 'go mod download' may add sums to this set when adding a requirement on a
-// module without a root package or when downloading a direct or indirect
-// dependency.
-func keepSums(keepBuildListZips bool) map[module.Version]bool {
-	// Re-derive the build list using the current list of direct requirements.
-	// Keep the sum for the go.mod of each visited module version (or its
-	// replacement).
-	modkey := func(m module.Version) module.Version {
-		return module.Version{Path: m.Path, Version: m.Version + "/go.mod"}
-	}
+// keepSums returns the set of modules (and go.mod file entries) for which
+// checksums would be needed in order to reload the same set of packages
+// loaded by the most recent call to LoadPackages or ImportFromFiles,
+// including any go.mod files needed to reconstruct the MVS result,
+// in addition to the checksums for every module in keepMods.
+func keepSums(ctx context.Context, ld *loader, rs *Requirements, which whichSums) map[module.Version]bool {
+	// Every module in the full module graph contributes its requirements,
+	// so in order to ensure that the build list itself is reproducible,
+	// we need sums for every go.mod in the graph (regardless of whether
+	// that version is selected).
 	keep := make(map[module.Version]bool)
-	var mu sync.Mutex
-	reqs := &keepSumReqs{
-		Reqs: &mvsReqs{buildList: buildList},
-		visit: func(m module.Version) {
-			// If we build using a replacement module, keep the sum for the replacement,
-			// since that's the code we'll actually use during a build.
-			mu.Lock()
-			r := Replacement(m)
-			if r.Path == "" {
-				keep[modkey(m)] = true
-			} else {
-				keep[modkey(r)] = true
-			}
-			mu.Unlock()
-		},
-	}
-	buildList, err := mvs.BuildList(Target, reqs)
-	if err != nil {
-		// This call to mvs.BuildList should not fail if we have already read the
-		// complete build list. However, the initial “build list” initialized by
-		// modFileToBuildList is not complete: it contains only the explicit
-		// dependencies of the main module. So this call can fair if this is the
-		// first time we have actually loaded the real build list.
-		base.Fatalf("go: %v", err)
+
+	if go117LazyTODO {
+		// If the main module is lazy, avoid loading the module graph if it hasn't
+		// already been loaded.
 	}
 
-	actualMods := make(map[string]module.Version)
-	for _, m := range buildList[1:] {
-		if r := Replacement(m); r.Path != "" {
-			actualMods[m.Path] = r
-		} else {
-			actualMods[m.Path] = m
+	mg, _ := rs.Graph(ctx)
+	mg.WalkBreadthFirst(func(m module.Version) {
+		if _, ok := mg.RequiredBy(m); ok {
+			// The requirements from m's go.mod file are present in the module graph,
+			// so they are relevant to the MVS result regardless of whether m was
+			// actually selected.
+			keep[modkey(resolveReplacement(m))] = true
+		}
+	})
+
+	if which == addBuildListZipSums {
+		for _, m := range mg.BuildList() {
+			keep[resolveReplacement(m)] = true
 		}
 	}
 
 	// Add entries for modules in the build list with paths that are prefixes of
-	// paths of loaded packages. We need to retain sums for modules needed to
-	// report ambiguous import errors. We use our re-derived build list,
-	// since the global build list may have been tidied.
-	if loaded != nil {
-		for _, pkg := range loaded.pkgs {
+	// paths of loaded packages. We need to retain sums for all of these modules —
+	// not just the modules containing the actual packages — in order to rule out
+	// ambiguous import errors the next time we load the package.
+	if ld != nil {
+		for _, pkg := range ld.pkgs {
 			if pkg.testOf != nil || pkg.inStd || module.CheckImportPath(pkg.path) != nil {
 				continue
 			}
+
 			for prefix := pkg.path; prefix != "."; prefix = path.Dir(prefix) {
-				if m, ok := actualMods[prefix]; ok {
-					keep[m] = true
+				if v := mg.Selected(prefix); v != "none" {
+					m := module.Version{Path: prefix, Version: v}
+					keep[resolveReplacement(m)] = true
 				}
 			}
 		}
 	}
 
-	// Add entries for the zip of each module in the build list.
-	// We might not need all of these (tidy does not add them), but they may be
-	// added by a specific 'go get' or 'go mod download' command to resolve
-	// missing import sum errors.
-	if keepBuildListZips {
-		for _, m := range actualMods {
-			keep[m] = true
-		}
-	}
-
 	return keep
 }
 
-// keepSumReqs embeds another Reqs implementation. The Required method
-// calls visit for each version in the module graph.
-type keepSumReqs struct {
-	mvs.Reqs
-	visit func(module.Version)
-}
+type whichSums int8
+
+const (
+	loadedZipSumsOnly = whichSums(iota)
+	addBuildListZipSums
+)
 
-func (r *keepSumReqs) Required(m module.Version) ([]module.Version, error) {
-	r.visit(m)
-	return r.Reqs.Required(m)
+// modKey returns the module.Version under which the checksum for m's go.mod
+// file is stored in the go.sum file.
+func modkey(m module.Version) module.Version {
+	return module.Version{Path: m.Path, Version: m.Version + "/go.mod"}
 }
 
-func TrimGoSum() {
-	// Don't retain sums for the zip file of every module in the build list.
-	// We may not need them all to build the main module's packages.
-	keepBuildListZips := false
-	modfetch.TrimGoSum(keepSums(keepBuildListZips))
+func TrimGoSum(ctx context.Context) {
+	rs := LoadModFile(ctx)
+	modfetch.TrimGoSum(keepSums(ctx, loaded, rs, loadedZipSumsOnly))
 }
diff --git a/src/cmd/go/internal/modload/list.go b/src/cmd/go/internal/modload/list.go
index 44803e960b..065d6efda6 100644
--- a/src/cmd/go/internal/modload/list.go
+++ b/src/cmd/go/internal/modload/list.go
@@ -20,8 +20,12 @@ import (
 	"golang.org/x/mod/module"
 )
 
-func ListModules(ctx context.Context, args []string, listU, listVersions, listRetracted bool) []*modinfo.ModulePublic {
-	mods := listModules(ctx, args, listVersions, listRetracted)
+// ListModules returns a description of the modules matching args, if known,
+// along with any error preventing additional matches from being identified.
+//
+// The returned slice can be nonempty even if the error is non-nil.
+func ListModules(ctx context.Context, args []string, listU, listVersions, listRetracted bool) ([]*modinfo.ModulePublic, error) {
+	rs, mods, err := listModules(ctx, LoadModFile(ctx), args, listVersions, listRetracted)
 
 	type token struct{}
 	sem := make(chan token, runtime.GOMAXPROCS(0))
@@ -54,17 +58,30 @@ func ListModules(ctx context.Context, args []string, listU, listVersions, listRe
 		sem <- token{}
 	}
 
-	return mods
+	if err == nil {
+		commitRequirements(ctx, rs)
+	}
+	return mods, err
 }
 
-func listModules(ctx context.Context, args []string, listVersions, listRetracted bool) []*modinfo.ModulePublic {
-	LoadAllModules(ctx)
+func listModules(ctx context.Context, rs *Requirements, args []string, listVersions, listRetracted bool) (_ *Requirements, mods []*modinfo.ModulePublic, mgErr error) {
+	var mg *ModuleGraph
+	if go117LazyTODO {
+		// Pull the args-loop below into another (new) loop.
+		// If the main module is lazy, try it once with mg == nil, and then load mg
+		// and try again.
+	} else {
+		// TODO(#41297): Don't bother loading or expanding the graph if all
+		// arguments are explicit version queries (including if no arguments are
+		// present at all).
+		rs, mg, mgErr = expandGraph(ctx, rs)
+	}
+
 	if len(args) == 0 {
-		return []*modinfo.ModulePublic{moduleInfo(ctx, buildList[0], true, listRetracted)}
+		return rs, []*modinfo.ModulePublic{moduleInfo(ctx, rs, Target, listRetracted)}, mgErr
 	}
 
-	var mods []*modinfo.ModulePublic
-	matchedBuildList := make([]bool, len(buildList))
+	matchedModule := map[module.Version]bool{}
 	for _, arg := range args {
 		if strings.Contains(arg, `\`) {
 			base.Fatalf("go: module paths never use backslash")
@@ -83,11 +100,14 @@ func listModules(ctx context.Context, args []string, listVersions, listRetracted
 		if i := strings.Index(arg, "@"); i >= 0 {
 			path := arg[:i]
 			vers := arg[i+1:]
-			current := "none"
-			for _, m := range buildList {
-				if m.Path == path {
-					current = m.Version
-					break
+
+			current := mg.Selected(path)
+			if current == "none" && mgErr != nil {
+				if vers == "upgrade" || vers == "patch" {
+					// The module graph is incomplete, so we don't know what version we're
+					// actually upgrading from.
+					// mgErr is already set, so just skip this module.
+					continue
 				}
 			}
 
@@ -106,67 +126,72 @@ func listModules(ctx context.Context, args []string, listVersions, listRetracted
 				})
 				continue
 			}
-			mod := moduleInfo(ctx, module.Version{Path: path, Version: info.Version}, false, listRetracted)
+
+			// Indicate that m was resolved from outside of rs by passing a nil
+			// *Requirements instead.
+			var noRS *Requirements
+
+			mod := moduleInfo(ctx, noRS, module.Version{Path: path, Version: info.Version}, listRetracted)
 			mods = append(mods, mod)
 			continue
 		}
 
+		if go117LazyTODO {
+			ModRoot() // Unversioned paths require that we be inside a module.
+		}
+
 		// Module path or pattern.
 		var match func(string) bool
-		var literal bool
 		if arg == "all" {
 			match = func(string) bool { return true }
 		} else if strings.Contains(arg, "...") {
 			match = search.MatchPattern(arg)
 		} else {
-			match = func(p string) bool { return arg == p }
-			literal = true
-		}
-		matched := false
-		for i, m := range buildList {
-			if i == 0 && !HasModRoot() {
-				// The root module doesn't actually exist: omit it.
+			v := mg.Selected(arg)
+			if v == "none" && mgErr != nil {
+				// mgErr is already set, so just skip this module.
 				continue
 			}
+			if v != "none" {
+				mods = append(mods, moduleInfo(ctx, rs, module.Version{Path: arg, Version: v}, listRetracted))
+			} else if cfg.BuildMod == "vendor" {
+				// In vendor mode, we can't determine whether a missing module is “a
+				// known dependency” because the module graph is incomplete.
+				// Give a more explicit error message.
+				mods = append(mods, &modinfo.ModulePublic{
+					Path:  arg,
+					Error: modinfoError(arg, "", errors.New("can't resolve module using the vendor directory\n\t(Use -mod=mod or -mod=readonly to bypass.)")),
+				})
+			} else if listVersions {
+				// Don't make the user provide an explicit '@latest' when they're
+				// explicitly asking what the available versions are. Instead, return a
+				// module with version "none", to which we can add the requested list.
+				mods = append(mods, &modinfo.ModulePublic{Path: arg})
+			} else {
+				mods = append(mods, &modinfo.ModulePublic{
+					Path:  arg,
+					Error: modinfoError(arg, "", errors.New("not a known dependency")),
+				})
+			}
+			continue
+		}
+
+		matched := false
+		for _, m := range mg.BuildList() {
 			if match(m.Path) {
 				matched = true
-				if !matchedBuildList[i] {
-					matchedBuildList[i] = true
-					mods = append(mods, moduleInfo(ctx, m, true, listRetracted))
+				if !matchedModule[m] {
+					matchedModule[m] = true
+					mods = append(mods, moduleInfo(ctx, rs, m, listRetracted))
 				}
 			}
 		}
 		if !matched {
-			if literal {
-				if listVersions {
-					// Don't make the user provide an explicit '@latest' when they're
-					// explicitly asking what the available versions are.
-					// Instead, return a modinfo without a version,
-					// to which we can attach the requested version list.
-					mods = append(mods, &modinfo.ModulePublic{Path: arg})
-					continue
-				}
-				if cfg.BuildMod == "vendor" {
-					// In vendor mode, we can't determine whether a missing module is “a
-					// known dependency” because the module graph is incomplete.
-					// Give a more explicit error message.
-					mods = append(mods, &modinfo.ModulePublic{
-						Path:  arg,
-						Error: modinfoError(arg, "", errors.New("can't resolve module using the vendor directory\n\t(Use -mod=mod or -mod=readonly to bypass.)")),
-					})
-				} else {
-					mods = append(mods, &modinfo.ModulePublic{
-						Path:  arg,
-						Error: modinfoError(arg, "", errors.New("not a known dependency")),
-					})
-				}
-			} else {
-				fmt.Fprintf(os.Stderr, "warning: pattern %q matched no module dependencies\n", arg)
-			}
+			fmt.Fprintf(os.Stderr, "warning: pattern %q matched no module dependencies\n", arg)
 		}
 	}
 
-	return mods
+	return rs, mods, mgErr
 }
 
 // modinfoError wraps an error to create an error message in
diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index 1be6a71bbf..d89dc67028 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -125,6 +125,10 @@ import (
 
 // loaded is the most recently-used package loader.
 // It holds details about individual packages.
+//
+// This variable should only be accessed directly in top-level exported
+// functions. All other functions that require or produce a *loader should pass
+// or return it as an explicit parameter.
 var loaded *loader
 
 // PackageOpts control the behavior of the LoadPackages function.
@@ -198,7 +202,8 @@ type PackageOpts struct {
 // LoadPackages identifies the set of packages matching the given patterns and
 // loads the packages in the import graph rooted at that set.
 func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (matches []*search.Match, loadedPackages []string) {
-	LoadModFile(ctx)
+	rs := LoadModFile(ctx)
+
 	if opts.Tags == nil {
 		opts.Tags = imports.Tags()
 	}
@@ -219,7 +224,7 @@ func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (ma
 			case m.IsLocal():
 				// Evaluate list of file system directories on first iteration.
 				if m.Dirs == nil {
-					matchLocalDirs(m)
+					matchLocalDirs(ctx, m, rs)
 				}
 
 				// Make a copy of the directory list and translate to import paths.
@@ -230,7 +235,7 @@ func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (ma
 				// the loader iterations.
 				m.Pkgs = m.Pkgs[:0]
 				for _, dir := range m.Dirs {
-					pkg, err := resolveLocalPackage(dir)
+					pkg, err := resolveLocalPackage(ctx, dir, rs)
 					if err != nil {
 						if !m.IsLiteral() && (err == errPkgIsBuiltin || err == errPkgIsGorootSrc) {
 							continue // Don't include "builtin" or GOROOT/src in wildcard patterns.
@@ -253,7 +258,17 @@ func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (ma
 
 			case strings.Contains(m.Pattern(), "..."):
 				m.Errs = m.Errs[:0]
-				matchPackages(ctx, m, opts.Tags, includeStd, buildList)
+				mg, err := rs.Graph(ctx)
+				if err != nil {
+					// The module graph is (or may be) incomplete — perhaps we failed to
+					// load the requirements of some module. This is an error in matching
+					// the patterns to packages, because we may be missing some packages
+					// or we may erroneously match packages in the wrong versions of
+					// modules. However, for cases like 'go list -e', the error should not
+					// necessarily prevent us from loading the packages we could find.
+					m.Errs = append(m.Errs, err)
+				}
+				matchPackages(ctx, m, opts.Tags, includeStd, mg.BuildList())
 
 			case m.Pattern() == "all":
 				if ld == nil {
@@ -278,8 +293,9 @@ func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (ma
 		}
 	}
 
-	loaded = loadFromRoots(loaderParams{
-		PackageOpts: opts,
+	ld := loadFromRoots(ctx, loaderParams{
+		PackageOpts:  opts,
+		requirements: rs,
 
 		allClosesOverTests: index.allPatternClosesOverTests() && !opts.UseVendorAll,
 		allPatternIsRoot:   allPatternIsRoot,
@@ -294,11 +310,11 @@ func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (ma
 	})
 
 	// One last pass to finalize wildcards.
-	updateMatches(loaded)
+	updateMatches(ld)
 
 	// Report errors, if any.
-	checkMultiplePaths()
-	for _, pkg := range loaded.pkgs {
+	checkMultiplePaths(ld.requirements)
+	for _, pkg := range ld.pkgs {
 		if !pkg.isTest() {
 			loadedPackages = append(loadedPackages, pkg.path)
 		}
@@ -350,14 +366,15 @@ func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (ma
 	}
 
 	// Success! Update go.mod (if needed) and return the results.
-	WriteGoMod()
+	loaded = ld
+	commitRequirements(ctx, loaded.requirements)
 	sort.Strings(loadedPackages)
 	return matches, loadedPackages
 }
 
 // matchLocalDirs is like m.MatchDirs, but tries to avoid scanning directories
 // outside of the standard library and active modules.
-func matchLocalDirs(m *search.Match) {
+func matchLocalDirs(ctx context.Context, m *search.Match, rs *Requirements) {
 	if !m.IsLocal() {
 		panic(fmt.Sprintf("internal error: resolveLocalDirs on non-local pattern %s", m.Pattern()))
 	}
@@ -373,7 +390,7 @@ func matchLocalDirs(m *search.Match) {
 		if !filepath.IsAbs(dir) {
 			absDir = filepath.Join(base.Cwd, dir)
 		}
-		if search.InDir(absDir, cfg.GOROOTsrc) == "" && search.InDir(absDir, ModRoot()) == "" && pathInModuleCache(absDir) == "" {
+		if search.InDir(absDir, cfg.GOROOTsrc) == "" && search.InDir(absDir, ModRoot()) == "" && pathInModuleCache(ctx, absDir, rs) == "" {
 			m.Dirs = []string{}
 			m.AddError(fmt.Errorf("directory prefix %s outside available modules", base.ShortPath(absDir)))
 			return
@@ -384,7 +401,7 @@ func matchLocalDirs(m *search.Match) {
 }
 
 // resolveLocalPackage resolves a filesystem path to a package path.
-func resolveLocalPackage(dir string) (string, error) {
+func resolveLocalPackage(ctx context.Context, dir string, rs *Requirements) (string, error) {
 	var absDir string
 	if filepath.IsAbs(dir) {
 		absDir = filepath.Clean(dir)
@@ -475,7 +492,7 @@ func resolveLocalPackage(dir string) (string, error) {
 		return pkg, nil
 	}
 
-	pkg := pathInModuleCache(absDir)
+	pkg := pathInModuleCache(ctx, absDir, rs)
 	if pkg == "" {
 		return "", fmt.Errorf("directory %s outside available modules", base.ShortPath(absDir))
 	}
@@ -490,7 +507,7 @@ var (
 
 // pathInModuleCache returns the import path of the directory dir,
 // if dir is in the module cache copy of a module in our build list.
-func pathInModuleCache(dir string) string {
+func pathInModuleCache(ctx context.Context, dir string, rs *Requirements) string {
 	tryMod := func(m module.Version) (string, bool) {
 		var root string
 		var err error
@@ -520,20 +537,43 @@ func pathInModuleCache(dir string) string {
 		return path.Join(m.Path, filepath.ToSlash(sub)), true
 	}
 
-	for _, m := range buildList[1:] {
-		if importPath, ok := tryMod(m); ok {
-			// checkMultiplePaths ensures that a module can be used for at most one
-			// requirement, so this must be it.
-			return importPath
+	if go117LazyTODO {
+		for _, m := range rs.rootModules {
+			if v, _ := rs.rootSelected(m.Path); v != m.Version {
+				continue // m is a root, but we have a higher root for the same path.
+			}
+			if importPath, ok := tryMod(m); ok {
+				// checkMultiplePaths ensures that a module can be used for at most one
+				// requirement, so this must be it.
+				return importPath
+			}
 		}
 	}
-	return ""
+
+	// None of the roots contained dir, or we're in eager mode and have already
+	// loaded the full module graph. Either way, check the full graph to see if
+	// the directory is a non-root dependency.
+	//
+	// If the roots are not consistent with the full module graph, the selected
+	// versions of root modules may differ from what we already checked above.
+	// Re-check those paths too.
+
+	mg, _ := rs.Graph(ctx)
+	var importPath string
+	for _, m := range mg.BuildList() {
+		var found bool
+		importPath, found = tryMod(m)
+		if found {
+			break
+		}
+	}
+	return importPath
 }
 
 // ImportFromFiles adds modules to the build list as needed
 // to satisfy the imports in the named Go source files.
 func ImportFromFiles(ctx context.Context, gofiles []string) {
-	LoadModFile(ctx)
+	rs := LoadModFile(ctx)
 
 	tags := imports.Tags()
 	imports, testImports, err := imports.ScanFiles(gofiles, tags)
@@ -541,11 +581,12 @@ func ImportFromFiles(ctx context.Context, gofiles []string) {
 		base.Fatalf("go: %v", err)
 	}
 
-	loaded = loadFromRoots(loaderParams{
+	loaded = loadFromRoots(ctx, loaderParams{
 		PackageOpts: PackageOpts{
 			Tags:                  tags,
 			ResolveMissingImports: true,
 		},
+		requirements:       rs,
 		allClosesOverTests: index.allPatternClosesOverTests(),
 		listRoots: func() (roots []string) {
 			roots = append(roots, imports...)
@@ -553,16 +594,16 @@ func ImportFromFiles(ctx context.Context, gofiles []string) {
 			return roots
 		},
 	})
-	WriteGoMod()
+	commitRequirements(ctx, loaded.requirements)
 }
 
 // DirImportPath returns the effective import path for dir,
 // provided it is within the main module, or else returns ".".
-func DirImportPath(dir string) string {
+func DirImportPath(ctx context.Context, dir string) string {
 	if !HasModRoot() {
 		return "."
 	}
-	LoadModFile(context.TODO())
+	LoadModFile(ctx) // Sets targetPrefix.
 
 	if !filepath.IsAbs(dir) {
 		dir = filepath.Join(base.Cwd, dir)
@@ -589,8 +630,8 @@ func DirImportPath(dir string) string {
 func TargetPackages(ctx context.Context, pattern string) *search.Match {
 	// TargetPackages is relative to the main module, so ensure that the main
 	// module is a thing that can contain packages.
-	LoadModFile(ctx)
-	ModRoot()
+	LoadModFile(ctx) // Sets Target.
+	ModRoot()        // Emits an error if Target cannot contain packages.
 
 	m := search.NewMatch(pattern)
 	matchPackages(ctx, m, imports.AnyTags(), omitStd, []module.Version{Target})
@@ -695,15 +736,13 @@ type loader struct {
 	roots    []*loadPkg
 	pkgCache *par.Cache // package path (string) → *loadPkg
 	pkgs     []*loadPkg // transitive closure of loaded packages and tests; populated in buildStacks
-
-	// computed at end of iterations
-	direct map[string]bool // imported directly by main module
 }
 
 // loaderParams configure the packages loaded by, and the properties reported
 // by, a loader instance.
 type loaderParams struct {
 	PackageOpts
+	requirements *Requirements
 
 	allClosesOverTests bool // Does the "all" pattern include the transitive closure of tests of packages in "all"?
 	allPatternIsRoot   bool // Is the "all" pattern an additional root?
@@ -823,19 +862,12 @@ var errMissing = errors.New("cannot find package")
 // The set of root packages is returned by the params.listRoots function, and
 // expanded to the full set of packages by tracing imports (and possibly tests)
 // as needed.
-func loadFromRoots(params loaderParams) *loader {
+func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 	ld := &loader{
 		loaderParams: params,
 		work:         par.NewQueue(runtime.GOMAXPROCS(0)),
 	}
 
-	var err error
-	reqs := &mvsReqs{buildList: buildList}
-	buildList, err = mvs.BuildList(Target, reqs)
-	if err != nil {
-		base.Fatalf("go: %v", err)
-	}
-
 	addedModuleFor := make(map[string]bool)
 	for {
 		ld.reset()
@@ -844,9 +876,20 @@ func loadFromRoots(params loaderParams) *loader {
 		// Note: the returned roots can change on each iteration,
 		// since the expansion of package patterns depends on the
 		// build list we're using.
+		rootPkgs := ld.listRoots()
+
+		if go117LazyTODO {
+			// Before we start loading transitive imports of packages, locate all of
+			// the root packages and promote their containing modules to root modules
+			// dependencies. If their go.mod files are tidy (the common case) and the
+			// set of root packages does not change then we can select the correct
+			// versions of all transitive imports on the first try and complete
+			// loading in a single iteration.
+		}
+
 		inRoots := map[*loadPkg]bool{}
-		for _, path := range ld.listRoots() {
-			root := ld.pkg(path, pkgIsRoot)
+		for _, path := range rootPkgs {
+			root := ld.pkg(ctx, path, pkgIsRoot)
 			if !inRoots[root] {
 				ld.roots = append(ld.roots, root)
 				inRoots[root] = true
@@ -866,14 +909,18 @@ func loadFromRoots(params loaderParams) *loader {
 			// We've loaded as much as we can without resolving missing imports.
 			break
 		}
-		modAddedBy := ld.resolveMissingImports(addedModuleFor)
+		modAddedBy := ld.resolveMissingImports(ctx, addedModuleFor)
 		if len(modAddedBy) == 0 {
 			break
 		}
 
-		// Recompute buildList with all our additions.
-		reqs = &mvsReqs{buildList: buildList}
-		buildList, err = mvs.BuildList(Target, reqs)
+		toAdd := make([]module.Version, 0, len(modAddedBy))
+		for m, _ := range modAddedBy {
+			toAdd = append(toAdd, m)
+		}
+		module.Sort(toAdd) // to make errors deterministic
+
+		rs, changed, err := editRequirements(ctx, ld.requirements, toAdd, nil)
 		if err != nil {
 			// If an error was found in a newly added module, report the package
 			// import stack instead of the module requirement stack. Packages
@@ -885,11 +932,16 @@ func loadFromRoots(params loaderParams) *loader {
 			}
 			base.Fatalf("go: %v", err)
 		}
+		ld.requirements = rs
+
+		if !changed {
+			break
+		}
 	}
-	base.ExitIfErrors()
+	base.ExitIfErrors() // TODO(bcmills): Is this actually needed?
 
 	// Compute directly referenced dependency modules.
-	ld.direct = make(map[string]bool)
+	direct := make(map[string]bool)
 	for _, pkg := range ld.pkgs {
 		if pkg.mod == Target {
 			for _, dep := range pkg.imports {
@@ -902,7 +954,7 @@ func loadFromRoots(params loaderParams) *loader {
 						// would fail with a less clear message.
 						base.Errorf("go: %[1]s: package %[2]s imported from implicitly required module; to add missing requirements, run:\n\tgo get %[2]s@%[3]s", pkg.path, dep.path, dep.mod.Version)
 					}
-					ld.direct[dep.mod.Path] = true
+					direct[dep.mod.Path] = true
 				}
 			}
 		}
@@ -912,26 +964,41 @@ func loadFromRoots(params loaderParams) *loader {
 	// If we didn't scan all of the imports from the main module, or didn't use
 	// imports.AnyTags, then we didn't necessarily load every package that
 	// contributes “direct” imports — so we can't safely mark existing
-	// dependencies as indirect-only.
-	// Conservatively mark those dependencies as direct.
-	if modFile != nil && (!ld.allPatternIsRoot || !reflect.DeepEqual(ld.Tags, imports.AnyTags())) {
-		for _, r := range modFile.Require {
-			if !r.Indirect {
-				ld.direct[r.Mod.Path] = true
-			}
+	// direct dependencies in ld.requirements as indirect-only. Propagate them as direct.
+	rs := ld.requirements
+	if !ld.loadedDirect() {
+		for mPath := range rs.direct {
+			direct[mPath] = true
 		}
 	}
 
+	var err error
+	ld.requirements, err = updateRoots(ctx, direct, ld.pkgs, ld.requirements)
+	if err != nil {
+		base.Errorf("go: %v", err)
+	}
+
+	if go117LazyTODO {
+		// Promoting a root can pull in previously-irrelevant requirements,
+		// changing the build list. Iterate until the roots are stable.
+	}
+
 	return ld
 }
 
-// resolveMissingImports adds module dependencies to the global build list
-// in order to resolve missing packages from pkgs.
+// loadedDirect reports whether ld loaded all of the packages that are directly
+// imported by any package or test in the main module.
+func (ld *loader) loadedDirect() bool {
+	return ld.allPatternIsRoot && reflect.DeepEqual(ld.Tags, imports.AnyTags())
+}
+
+// resolveMissingImports returns a set of modules that could be added as
+// dependencies in order to resolve missing packages from pkgs.
 //
 // The newly-resolved packages are added to the addedModuleFor map, and
-// resolveMissingImports returns a map from each newly-added module version to
-// the first package for which that module was added.
-func (ld *loader) resolveMissingImports(addedModuleFor map[string]bool) (modAddedBy map[module.Version]*loadPkg) {
+// resolveMissingImports returns a map from each new module version to
+// the first missing package that module would resolve.
+func (ld *loader) resolveMissingImports(ctx context.Context, addedModuleFor map[string]bool) (modAddedBy map[module.Version]*loadPkg) {
 	var needPkgs []*loadPkg
 	for _, pkg := range ld.pkgs {
 		if pkg.err == nil {
@@ -951,7 +1018,7 @@ func (ld *loader) resolveMissingImports(addedModuleFor map[string]bool) (modAdde
 
 		pkg := pkg
 		ld.work.Add(func() {
-			pkg.mod, pkg.err = queryImport(context.TODO(), pkg.path)
+			pkg.mod, pkg.err = queryImport(ctx, pkg.path, ld.requirements)
 		})
 	}
 	<-ld.work.Idle()
@@ -970,7 +1037,6 @@ func (ld *loader) resolveMissingImports(addedModuleFor map[string]bool) (modAdde
 		}
 		if modAddedBy[pkg.mod] == nil {
 			modAddedBy[pkg.mod] = pkg
-			buildList = append(buildList, pkg.mod)
 		}
 	}
 
@@ -984,7 +1050,7 @@ func (ld *loader) resolveMissingImports(addedModuleFor map[string]bool) (modAdde
 // ld.work queue, and its test (if requested) will also be populated once
 // imports have been resolved. When ld.work goes idle, all transitive imports of
 // the requested package (and its test, if requested) will have been loaded.
-func (ld *loader) pkg(path string, flags loadPkgFlags) *loadPkg {
+func (ld *loader) pkg(ctx context.Context, path string, flags loadPkgFlags) *loadPkg {
 	if flags.has(pkgImportsLoaded) {
 		panic("internal error: (*loader).pkg called with pkgImportsLoaded flag set")
 	}
@@ -993,20 +1059,20 @@ func (ld *loader) pkg(path string, flags loadPkgFlags) *loadPkg {
 		pkg := &loadPkg{
 			path: path,
 		}
-		ld.applyPkgFlags(pkg, flags)
+		ld.applyPkgFlags(ctx, pkg, flags)
 
-		ld.work.Add(func() { ld.load(pkg) })
+		ld.work.Add(func() { ld.load(ctx, pkg) })
 		return pkg
 	}).(*loadPkg)
 
-	ld.applyPkgFlags(pkg, flags)
+	ld.applyPkgFlags(ctx, pkg, flags)
 	return pkg
 }
 
 // applyPkgFlags updates pkg.flags to set the given flags and propagate the
 // (transitive) effects of those flags, possibly loading or enqueueing further
 // packages as a result.
-func (ld *loader) applyPkgFlags(pkg *loadPkg, flags loadPkgFlags) {
+func (ld *loader) applyPkgFlags(ctx context.Context, pkg *loadPkg, flags loadPkgFlags) {
 	if flags == 0 {
 		return
 	}
@@ -1058,7 +1124,7 @@ func (ld *loader) applyPkgFlags(pkg *loadPkg, flags loadPkgFlags) {
 				// of packages in "all" if "all" closes over test dependencies.
 				testFlags |= pkgInAll
 			}
-			ld.pkgTest(pkg, testFlags)
+			ld.pkgTest(ctx, pkg, testFlags)
 		}
 	}
 
@@ -1066,13 +1132,13 @@ func (ld *loader) applyPkgFlags(pkg *loadPkg, flags loadPkgFlags) {
 		// We have just marked pkg with pkgInAll, or we have just loaded its
 		// imports, or both. Now is the time to propagate pkgInAll to the imports.
 		for _, dep := range pkg.imports {
-			ld.applyPkgFlags(dep, pkgInAll)
+			ld.applyPkgFlags(ctx, dep, pkgInAll)
 		}
 	}
 }
 
 // load loads an individual package.
-func (ld *loader) load(pkg *loadPkg) {
+func (ld *loader) load(ctx context.Context, pkg *loadPkg) {
 	if strings.Contains(pkg.path, "@") {
 		// Leave for error during load.
 		return
@@ -1091,7 +1157,7 @@ func (ld *loader) load(pkg *loadPkg) {
 		return
 	}
 
-	pkg.mod, pkg.dir, pkg.err = importFromBuildList(context.TODO(), pkg.path, buildList)
+	pkg.mod, pkg.dir, pkg.err = importFromModules(ctx, pkg.path, ld.requirements)
 	if pkg.dir == "" {
 		return
 	}
@@ -1105,10 +1171,10 @@ func (ld *loader) load(pkg *loadPkg) {
 		// about (by reducing churn on the flag bits of dependencies), and costs
 		// essentially nothing (these atomic flag ops are essentially free compared
 		// to scanning source code for imports).
-		ld.applyPkgFlags(pkg, pkgInAll)
+		ld.applyPkgFlags(ctx, pkg, pkgInAll)
 	}
 	if ld.AllowPackage != nil {
-		if err := ld.AllowPackage(context.TODO(), pkg.path, pkg.mod); err != nil {
+		if err := ld.AllowPackage(ctx, pkg.path, pkg.mod); err != nil {
 			pkg.err = err
 		}
 	}
@@ -1139,11 +1205,11 @@ func (ld *loader) load(pkg *loadPkg) {
 			// GOROOT/src/vendor even when "std" is not the main module.
 			path = ld.stdVendor(pkg.path, path)
 		}
-		pkg.imports = append(pkg.imports, ld.pkg(path, importFlags))
+		pkg.imports = append(pkg.imports, ld.pkg(ctx, path, importFlags))
 	}
 	pkg.testImports = testImports
 
-	ld.applyPkgFlags(pkg, pkgImportsLoaded)
+	ld.applyPkgFlags(ctx, pkg, pkgImportsLoaded)
 }
 
 // pkgTest locates the test of pkg, creating it if needed, and updates its state
@@ -1151,7 +1217,7 @@ func (ld *loader) load(pkg *loadPkg) {
 //
 // pkgTest requires that the imports of pkg have already been loaded (flagged
 // with pkgImportsLoaded).
-func (ld *loader) pkgTest(pkg *loadPkg, testFlags loadPkgFlags) *loadPkg {
+func (ld *loader) pkgTest(ctx context.Context, pkg *loadPkg, testFlags loadPkgFlags) *loadPkg {
 	if pkg.isTest() {
 		panic("pkgTest called on a test package")
 	}
@@ -1166,7 +1232,7 @@ func (ld *loader) pkgTest(pkg *loadPkg, testFlags loadPkgFlags) *loadPkg {
 			err:    pkg.err,
 			inStd:  pkg.inStd,
 		}
-		ld.applyPkgFlags(pkg.test, testFlags)
+		ld.applyPkgFlags(ctx, pkg.test, testFlags)
 		createdTest = true
 	})
 
@@ -1181,12 +1247,12 @@ func (ld *loader) pkgTest(pkg *loadPkg, testFlags loadPkgFlags) *loadPkg {
 			if pkg.inStd {
 				path = ld.stdVendor(test.path, path)
 			}
-			test.imports = append(test.imports, ld.pkg(path, importFlags))
+			test.imports = append(test.imports, ld.pkg(ctx, path, importFlags))
 		}
 		pkg.testImports = nil
-		ld.applyPkgFlags(test, pkgImportsLoaded)
+		ld.applyPkgFlags(ctx, test, pkgImportsLoaded)
 	} else {
-		ld.applyPkgFlags(test, testFlags)
+		ld.applyPkgFlags(ctx, test, testFlags)
 	}
 
 	return test
diff --git a/src/cmd/go/internal/modload/modfile.go b/src/cmd/go/internal/modload/modfile.go
index 6cbad46c4d..53a7895c4d 100644
--- a/src/cmd/go/internal/modload/modfile.go
+++ b/src/cmd/go/internal/modload/modfile.go
@@ -30,6 +30,11 @@ import (
 // tests outside of the main module.
 const narrowAllVersionV = "v1.16"
 
+// go1117LazyTODO is a constant that exists only until lazy loading is
+// implemented. Its use indicates a condition that will need to change if the
+// main module is lazy.
+const go117LazyTODO = false
+
 var modFile *modfile.File
 
 // A modFileIndex is an index of data corresponding to a modFile
@@ -133,10 +138,7 @@ func CheckRetractions(ctx context.Context, m module.Version) error {
 		// We load the raw file here: the go.mod file may have a different module
 		// path that we expect if the module or its repository was renamed.
 		// We still want to apply retractions to other aliases of the module.
-		rm := module.Version{Path: path, Version: rev.Version}
-		if repl := Replacement(rm); repl.Path != "" {
-			rm = repl
-		}
+		rm := resolveReplacement(module.Version{Path: path, Version: rev.Version})
 		summary, err := rawGoModSummary(rm)
 		if err != nil {
 			return &entry{nil, err}
@@ -242,6 +244,15 @@ func Replacement(mod module.Version) module.Version {
 	return module.Version{}
 }
 
+// resolveReplacement returns the module actually used to load the source code
+// for m: either m itself, or the replacement for m (iff m is replaced).
+func resolveReplacement(m module.Version) module.Version {
+	if r := Replacement(m); r.Path != "" {
+		return r
+	}
+	return m
+}
+
 // indexModFile rebuilds the index of modFile.
 // If modFile has been changed since it was first read,
 // modFile.Cleanup must be called before indexModFile.
@@ -441,10 +452,7 @@ func goModSummary(m module.Version) (*modFileSummary, error) {
 		return summary, nil
 	}
 
-	actual := Replacement(m)
-	if actual.Path == "" {
-		actual = m
-	}
+	actual := resolveReplacement(m)
 	if HasModRoot() && cfg.BuildMod == "readonly" && actual.Version != "" {
 		key := module.Version{Path: actual.Path, Version: actual.Version + "/go.mod"}
 		if !modfetch.HaveSum(key) {
diff --git a/src/cmd/go/internal/modload/search.go b/src/cmd/go/internal/modload/search.go
index 1fe742dc97..c34f745a24 100644
--- a/src/cmd/go/internal/modload/search.go
+++ b/src/cmd/go/internal/modload/search.go
@@ -187,7 +187,7 @@ func MatchInModule(ctx context.Context, pattern string, m module.Version, tags m
 		matchPackages(ctx, match, tags, includeStd, nil)
 	}
 
-	LoadModFile(ctx)
+	LoadModFile(ctx) // Sets Target, needed by fetch and matchPackages.
 
 	if !match.IsLiteral() {
 		matchPackages(ctx, match, tags, omitStd, []module.Version{m})
diff --git a/src/cmd/go/testdata/script/mod_install_pkg_version.txt b/src/cmd/go/testdata/script/mod_install_pkg_version.txt
index 6ed600ff71..c14085c4fd 100644
--- a/src/cmd/go/testdata/script/mod_install_pkg_version.txt
+++ b/src/cmd/go/testdata/script/mod_install_pkg_version.txt
@@ -16,7 +16,7 @@ env GO111MODULE=auto
 cd m
 cp go.mod go.mod.orig
 ! go list -m all
-stderr '^go: example.com/cmd@v1.1.0-doesnotexist: missing go.sum entry; to add it:\n\tgo mod download example.com/cmd$'
+stderr '^go list -m: example.com/cmd@v1.1.0-doesnotexist: missing go.sum entry; to add it:\n\tgo mod download example.com/cmd$'
 go install example.com/cmd/a@latest
 cmp go.mod go.mod.orig
 exists $GOPATH/bin/a$GOEXE
diff --git a/src/cmd/go/testdata/script/mod_invalid_version.txt b/src/cmd/go/testdata/script/mod_invalid_version.txt
index 43b9564356..34d9c47674 100644
--- a/src/cmd/go/testdata/script/mod_invalid_version.txt
+++ b/src/cmd/go/testdata/script/mod_invalid_version.txt
@@ -19,7 +19,7 @@ cp go.mod.orig go.mod
 go mod edit -require golang.org/x/text@14c0d48ead0c
 cd outside
 ! go list -m golang.org/x/text
-stderr 'go: example.com@v0.0.0 \(replaced by \./\..\): parsing ../go.mod: '$WORK'/gopath/src/go.mod:5: require golang.org/x/text: version "14c0d48ead0c" invalid: must be of the form v1.2.3'
+stderr 'go list -m: example.com@v0.0.0 \(replaced by \./\..\): parsing ../go.mod: '$WORK'/gopath/src/go.mod:5: require golang.org/x/text: version "14c0d48ead0c" invalid: must be of the form v1.2.3'
 cd ..
 go list -m golang.org/x/text
 stdout 'golang.org/x/text v0.1.1-0.20170915032832-14c0d48ead0c'
@@ -30,7 +30,7 @@ cp go.mod.orig go.mod
 go mod edit -require golang.org/x/text/unicode@v0.0.0-20170915032832-14c0d48ead0c
 cd outside
 ! go list -m golang.org/x/text
-stderr 'go: example.com@v0.0.0 requires\n\tgolang.org/x/text/unicode@v0.0.0-20170915032832-14c0d48ead0c: invalid version: missing golang.org/x/text/unicode/go.mod at revision 14c0d48ead0c'
+stderr 'go list -m: example.com@v0.0.0 requires\n\tgolang.org/x/text/unicode@v0.0.0-20170915032832-14c0d48ead0c: invalid version: missing golang.org/x/text/unicode/go.mod at revision 14c0d48ead0c'
 cd ..
 ! go list -m golang.org/x/text
 stderr 'golang.org/x/text/unicode@v0.0.0-20170915032832-14c0d48ead0c: invalid version: missing golang.org/x/text/unicode/go.mod at revision 14c0d48ead0c'
@@ -47,7 +47,7 @@ cp go.mod.orig go.mod
 go mod edit -require golang.org/x/text@v2.1.1-0.20170915032832-14c0d48ead0c
 cd outside
 ! go list -m golang.org/x/text
-stderr 'go: example.com@v0.0.0 \(replaced by \./\.\.\): parsing ../go.mod: '$WORK'/gopath/src/go.mod:5: require golang.org/x/text: version "v2.1.1-0.20170915032832-14c0d48ead0c" invalid: should be v0 or v1, not v2'
+stderr 'go list -m: example.com@v0.0.0 \(replaced by \./\.\.\): parsing ../go.mod: '$WORK'/gopath/src/go.mod:5: require golang.org/x/text: version "v2.1.1-0.20170915032832-14c0d48ead0c" invalid: should be v0 or v1, not v2'
 cd ..
 ! go list -m golang.org/x/text
 stderr $WORK'/gopath/src/go.mod:5: require golang.org/x/text: version "v2.1.1-0.20170915032832-14c0d48ead0c" invalid: should be v0 or v1, not v2'
@@ -57,7 +57,7 @@ cp go.mod.orig go.mod
 go mod edit -require golang.org/x/text@v0.1.1-0.20170915032832-14c0d48ead0
 cd outside
 ! go list -m golang.org/x/text
-stderr 'go: example.com@v0.0.0 requires\n\tgolang.org/x/text@v0.1.1-0.20170915032832-14c0d48ead0: invalid pseudo-version: revision is shorter than canonical \(14c0d48ead0c\)'
+stderr 'go list -m: example.com@v0.0.0 requires\n\tgolang.org/x/text@v0.1.1-0.20170915032832-14c0d48ead0: invalid pseudo-version: revision is shorter than canonical \(14c0d48ead0c\)'
 cd ..
 ! go list -m golang.org/x/text
 stderr 'golang.org/x/text@v0.1.1-0.20170915032832-14c0d48ead0: invalid pseudo-version: revision is shorter than canonical \(14c0d48ead0c\)'
@@ -67,7 +67,7 @@ cp go.mod.orig go.mod
 go mod edit -require golang.org/x/text@v0.1.1-0.20170915032832-14c0d48ead0cd47e3104ada247d91be04afc7a5a
 cd outside
 ! go list -m golang.org/x/text
-stderr 'go: example.com@v0.0.0 requires\n\tgolang.org/x/text@v0.1.1-0.20170915032832-14c0d48ead0cd47e3104ada247d91be04afc7a5a: invalid pseudo-version: revision is longer than canonical \(14c0d48ead0c\)'
+stderr 'go list -m: example.com@v0.0.0 requires\n\tgolang.org/x/text@v0.1.1-0.20170915032832-14c0d48ead0cd47e3104ada247d91be04afc7a5a: invalid pseudo-version: revision is longer than canonical \(14c0d48ead0c\)'
 cd ..
 ! go list -m golang.org/x/text
 stderr 'golang.org/x/text@v0.1.1-0.20170915032832-14c0d48ead0cd47e3104ada247d91be04afc7a5a: invalid pseudo-version: revision is longer than canonical \(14c0d48ead0c\)'
@@ -77,7 +77,7 @@ cp go.mod.orig go.mod
 go mod edit -require golang.org/x/text@v0.1.1-0.20190915032832-14c0d48ead0c
 cd outside
 ! go list -m golang.org/x/text
-stderr 'go: example.com@v0.0.0 requires\n\tgolang.org/x/text@v0.1.1-0.20190915032832-14c0d48ead0c: invalid pseudo-version: does not match version-control timestamp \(expected 20170915032832\)'
+stderr 'go list -m: example.com@v0.0.0 requires\n\tgolang.org/x/text@v0.1.1-0.20190915032832-14c0d48ead0c: invalid pseudo-version: does not match version-control timestamp \(expected 20170915032832\)'
 cd ..
 ! go list -m golang.org/x/text
 stderr 'golang.org/x/text@v0.1.1-0.20190915032832-14c0d48ead0c: invalid pseudo-version: does not match version-control timestamp \(expected 20170915032832\)'
@@ -87,7 +87,7 @@ stderr 'golang.org/x/text@v0.1.1-0.20190915032832-14c0d48ead0c: invalid pseudo-v
 go mod edit -replace golang.org/x/text@v0.1.1-0.20190915032832-14c0d48ead0c=golang.org/x/text@14c0d48ead0c
 cd outside
 ! go list -m golang.org/x/text
-stderr 'go: example.com@v0.0.0 requires\n\tgolang.org/x/text@v0.1.1-0.20190915032832-14c0d48ead0c: invalid pseudo-version: does not match version-control timestamp \(expected 20170915032832\)'
+stderr 'go list -m: example.com@v0.0.0 requires\n\tgolang.org/x/text@v0.1.1-0.20190915032832-14c0d48ead0c: invalid pseudo-version: does not match version-control timestamp \(expected 20170915032832\)'
 cd ..
 go list -m golang.org/x/text
 stdout 'golang.org/x/text v0.1.1-0.20190915032832-14c0d48ead0c => golang.org/x/text v0.1.1-0.20170915032832-14c0d48ead0c'
@@ -97,7 +97,7 @@ cp go.mod.orig go.mod
 go mod edit -require golang.org/x/text@v1.999.999-0.20170915032832-14c0d48ead0c
 cd outside
 ! go list -m golang.org/x/text
-stderr 'go: example.com@v0.0.0 requires\n\tgolang.org/x/text@v1.999.999-0.20170915032832-14c0d48ead0c: invalid pseudo-version: preceding tag \(v1.999.998\) not found'
+stderr 'go list -m: example.com@v0.0.0 requires\n\tgolang.org/x/text@v1.999.999-0.20170915032832-14c0d48ead0c: invalid pseudo-version: preceding tag \(v1.999.998\) not found'
 cd ..
 ! go list -m golang.org/x/text
 stderr 'golang.org/x/text@v1.999.999-0.20170915032832-14c0d48ead0c: invalid pseudo-version: preceding tag \(v1.999.998\) not found'
@@ -109,7 +109,7 @@ cp go.mod.orig go.mod
 go mod edit -require golang.org/x/text@v1.0.0-20170915032832-14c0d48ead0c
 cd outside
 ! go list -m golang.org/x/text
-stderr 'go: example.com@v0.0.0 requires\n\tgolang.org/x/text@v1.0.0-20170915032832-14c0d48ead0c: invalid pseudo-version: major version without preceding tag must be v0, not v1'
+stderr 'go list -m: example.com@v0.0.0 requires\n\tgolang.org/x/text@v1.0.0-20170915032832-14c0d48ead0c: invalid pseudo-version: major version without preceding tag must be v0, not v1'
 cd ..
 ! go list -m golang.org/x/text
 stderr 'golang.org/x/text@v1.0.0-20170915032832-14c0d48ead0c: invalid pseudo-version: major version without preceding tag must be v0, not v1'
@@ -120,7 +120,7 @@ cp go.mod.orig go.mod
 go mod edit -require golang.org/x/text@v0.0.0-0.20170915032832-14c0d48ead0c
 cd outside
 ! go list -m golang.org/x/text
-stderr 'go: example.com@v0.0.0 requires\n\tgolang.org/x/text@v0.0.0-0.20170915032832-14c0d48ead0c: invalid pseudo-version: version before v0.0.0 would have negative patch number'
+stderr 'go list -m: example.com@v0.0.0 requires\n\tgolang.org/x/text@v0.0.0-0.20170915032832-14c0d48ead0c: invalid pseudo-version: version before v0.0.0 would have negative patch number'
 cd ..
 ! go list -m golang.org/x/text
 stderr 'golang.org/x/text@v0.0.0-0.20170915032832-14c0d48ead0c: invalid pseudo-version: version before v0.0.0 would have negative patch number'
@@ -130,7 +130,7 @@ stderr 'golang.org/x/text@v0.0.0-0.20170915032832-14c0d48ead0c: invalid pseudo-v
 go mod edit -replace golang.org/x/text@v0.0.0-0.20170915032832-14c0d48ead0c=golang.org/x/text@v0.0.0-20170915032832-14c0d48ead0c
 cd outside
 ! go list -m golang.org/x/text
-stderr 'go: example.com@v0.0.0 requires\n\tgolang.org/x/text@v0.0.0-0.20170915032832-14c0d48ead0c: invalid pseudo-version: version before v0.0.0 would have negative patch number'
+stderr 'go list -m: example.com@v0.0.0 requires\n\tgolang.org/x/text@v0.0.0-0.20170915032832-14c0d48ead0c: invalid pseudo-version: version before v0.0.0 would have negative patch number'
 cd ..
 go list -m golang.org/x/text
 stdout 'golang.org/x/text v0.0.0-0.20170915032832-14c0d48ead0c => golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c'
@@ -153,7 +153,7 @@ cp go.mod.orig go.mod
 go mod edit -require golang.org/x/text@v0.2.1-0.20170915032832-14c0d48ead0c
 cd outside
 ! go list -m golang.org/x/text
-stderr 'go: example.com@v0.0.0 requires\n\tgolang.org/x/text@v0.2.1-0.20170915032832-14c0d48ead0c: invalid pseudo-version: revision 14c0d48ead0c is not a descendent of preceding tag \(v0.2.0\)'
+stderr 'go list -m: example.com@v0.0.0 requires\n\tgolang.org/x/text@v0.2.1-0.20170915032832-14c0d48ead0c: invalid pseudo-version: revision 14c0d48ead0c is not a descendent of preceding tag \(v0.2.0\)'
 cd ..
 ! go list -m golang.org/x/text
 stderr 'golang.org/x/text@v0.2.1-0.20170915032832-14c0d48ead0c: invalid pseudo-version: revision 14c0d48ead0c is not a descendent of preceding tag \(v0.2.0\)'
@@ -163,7 +163,7 @@ cp go.mod.orig go.mod
 go mod edit -require golang.org/x/text@v0.2.1-0.20171213102548-c4d099d611ac
 cd outside
 ! go list -m golang.org/x/text
-stderr 'go: example.com@v0.0.0 requires\n\tgolang.org/x/text@v0.2.1-0.20171213102548-c4d099d611ac: invalid pseudo-version: tag \(v0.2.0\) found on revision c4d099d611ac is already canonical, so should not be replaced with a pseudo-version derived from that tag'
+stderr 'go list -m: example.com@v0.0.0 requires\n\tgolang.org/x/text@v0.2.1-0.20171213102548-c4d099d611ac: invalid pseudo-version: tag \(v0.2.0\) found on revision c4d099d611ac is already canonical, so should not be replaced with a pseudo-version derived from that tag'
 cd ..
 ! go list -m golang.org/x/text
 stderr 'golang.org/x/text@v0.2.1-0.20171213102548-c4d099d611ac: invalid pseudo-version: tag \(v0.2.0\) found on revision c4d099d611ac is already canonical, so should not be replaced with a pseudo-version derived from that tag'
@@ -173,7 +173,7 @@ cp go.mod.orig go.mod
 go mod edit -require golang.org/x/text@v0.1.1-0.20170915032832-14c0d48ead0c+incompatible
 cd outside
 ! go list -m golang.org/x/text
-stderr 'go: example.com@v0.0.0 requires\n\tgolang.org/x/text@v0.1.1-0.20170915032832-14c0d48ead0c\+incompatible: invalid version: \+incompatible suffix not allowed: major version v0 is compatible'
+stderr 'go list -m: example.com@v0.0.0 requires\n\tgolang.org/x/text@v0.1.1-0.20170915032832-14c0d48ead0c\+incompatible: invalid version: \+incompatible suffix not allowed: major version v0 is compatible'
 cd ..
 ! go list -m golang.org/x/text
 stderr 'golang.org/x/text@v0.1.1-0.20170915032832-14c0d48ead0c\+incompatible: invalid version: \+incompatible suffix not allowed: major version v0 is compatible'
@@ -194,7 +194,7 @@ cp go.mod.orig go.mod
 go mod edit -require github.com/pierrec/lz4@v2.0.9-0.20190209155647-9a39efadad3d+incompatible
 cd outside
 ! go list -m github.com/pierrec/lz4
-stderr 'go: example.com@v0.0.0 requires\n\tgithub.com/pierrec/lz4@v2.0.9-0.20190209155647-9a39efadad3d\+incompatible: invalid version: \+incompatible suffix not allowed: module contains a go.mod file, so semantic import versioning is required'
+stderr 'go list -m: example.com@v0.0.0 requires\n\tgithub.com/pierrec/lz4@v2.0.9-0.20190209155647-9a39efadad3d\+incompatible: invalid version: \+incompatible suffix not allowed: module contains a go.mod file, so semantic import versioning is required'
 cd ..
 ! go list -m github.com/pierrec/lz4
 stderr 'github.com/pierrec/lz4@v2.0.9-0.20190209155647-9a39efadad3d\+incompatible: invalid version: \+incompatible suffix not allowed: module contains a go.mod file, so semantic import versioning is required'
diff --git a/src/cmd/go/testdata/script/mod_load_badchain.txt b/src/cmd/go/testdata/script/mod_load_badchain.txt
index 32d9fb24d1..9e28b2d9a4 100644
--- a/src/cmd/go/testdata/script/mod_load_badchain.txt
+++ b/src/cmd/go/testdata/script/mod_load_badchain.txt
@@ -80,7 +80,7 @@ go get: example.com/badchain/a@v1.1.0 requires
 	module declares its path as: badchain.example.com/c
 	        but was required as: example.com/badchain/c
 -- list-expected --
-go: example.com/badchain/a@v1.1.0 requires
+go list -m: example.com/badchain/a@v1.1.0 requires
 	example.com/badchain/b@v1.1.0 requires
 	example.com/badchain/c@v1.1.0: parsing go.mod:
 	module declares its path as: badchain.example.com/c
diff --git a/src/cmd/go/testdata/script/mod_load_replace_mismatch.txt b/src/cmd/go/testdata/script/mod_load_replace_mismatch.txt
index 2ca8b3cace..dd386f1628 100644
--- a/src/cmd/go/testdata/script/mod_load_replace_mismatch.txt
+++ b/src/cmd/go/testdata/script/mod_load_replace_mismatch.txt
@@ -18,6 +18,6 @@ package use
 import _ "rsc.io/quote"
 
 -- want --
-go: rsc.io/quote@v1.5.2 (replaced by example.com/quote@v1.5.2): parsing go.mod:
+go mod download: rsc.io/quote@v1.5.2 (replaced by example.com/quote@v1.5.2): parsing go.mod:
 	module declares its path as: rsc.io/Quote
 	        but was required as: rsc.io/quote
diff --git a/src/cmd/go/testdata/script/mod_replace_gopkgin.txt b/src/cmd/go/testdata/script/mod_replace_gopkgin.txt
index df752d9716..d24f37b788 100644
--- a/src/cmd/go/testdata/script/mod_replace_gopkgin.txt
+++ b/src/cmd/go/testdata/script/mod_replace_gopkgin.txt
@@ -35,7 +35,7 @@ go list -m gopkg.in/src-d/go-git.v4
 # A mismatched gopkg.in path should not be able to replace a different major version.
 cd ../3-to-gomod-4
 ! go list -m gopkg.in/src-d/go-git.v3
-stderr '^go: gopkg\.in/src-d/go-git\.v3@v3\.2\.0 \(replaced by gopkg\.in/src-d/go-git\.v3@v3\.0\.0-20190801152248-0d1a009cbb60\): version "v3\.0\.0-20190801152248-0d1a009cbb60" invalid: go\.mod has non-\.\.\.\.v3 module path "gopkg\.in/src-d/go-git\.v4" at revision 0d1a009cbb60$'
+stderr '^go list -m: gopkg\.in/src-d/go-git\.v3@v3\.2\.0 \(replaced by gopkg\.in/src-d/go-git\.v3@v3\.0\.0-20190801152248-0d1a009cbb60\): version "v3\.0\.0-20190801152248-0d1a009cbb60" invalid: go\.mod has non-\.\.\.\.v3 module path "gopkg\.in/src-d/go-git\.v4" at revision 0d1a009cbb60$'
 
 -- 4-to-4/go.mod --
 module golang.org/issue/34254
diff --git a/src/cmd/go/testdata/script/mod_require_exclude.txt b/src/cmd/go/testdata/script/mod_require_exclude.txt
index 9156d4ce5d..5b6143da42 100644
--- a/src/cmd/go/testdata/script/mod_require_exclude.txt
+++ b/src/cmd/go/testdata/script/mod_require_exclude.txt
@@ -7,13 +7,13 @@ cp go.mod go.mod.orig
 
 ! go list -mod=readonly -m all
 stderr '^go: ignoring requirement on excluded version rsc.io/sampler v1\.99\.99$'
-stderr '^go: updates to go.mod needed, disabled by -mod=readonly$'
+stderr '^go: updates to go.mod needed, disabled by -mod=readonly; to update it:\n\tgo mod tidy$'
 ! stdout '^rsc.io/sampler v1.99.99'
 cmp go.mod go.mod.orig
 
 ! go list -mod=vendor -m rsc.io/sampler
 stderr '^go: ignoring requirement on excluded version rsc.io/sampler v1\.99\.99$'
-stderr '^go list -m: module rsc.io/sampler: can''t resolve module using the vendor directory\n\t\(Use -mod=mod or -mod=readonly to bypass\.\)$'
+stderr '^go: updates to go.mod needed, disabled by -mod=vendor; to update it:\n\tgo mod tidy$'
 ! stdout '^rsc.io/sampler v1.99.99'
 cmp go.mod go.mod.orig
 
diff --git a/src/cmd/go/testdata/script/mod_sum_readonly.txt b/src/cmd/go/testdata/script/mod_sum_readonly.txt
index 57c5bbeefd..113f13ea39 100644
--- a/src/cmd/go/testdata/script/mod_sum_readonly.txt
+++ b/src/cmd/go/testdata/script/mod_sum_readonly.txt
@@ -4,7 +4,7 @@ env GO111MODULE=on
 # When a sum is needed to load the build list, we get an error for the
 # specific module. The .mod file is not downloaded, and go.sum is not written.
 ! go list -m all
-stderr '^go: rsc.io/quote@v1.5.2: missing go.sum entry; to add it:\n\tgo mod download rsc.io/quote$'
+stderr '^go list -m: rsc.io/quote@v1.5.2: missing go.sum entry; to add it:\n\tgo mod download rsc.io/quote$'
 ! exists $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.5.2.mod
 ! exists go.sum
 
@@ -12,7 +12,7 @@ stderr '^go: rsc.io/quote@v1.5.2: missing go.sum entry; to add it:\n\tgo mod dow
 # we should see the same error.
 cp go.sum.h2only go.sum
 ! go list -m all
-stderr '^go: rsc.io/quote@v1.5.2: missing go.sum entry; to add it:\n\tgo mod download rsc.io/quote$'
+stderr '^go list -m: rsc.io/quote@v1.5.2: missing go.sum entry; to add it:\n\tgo mod download rsc.io/quote$'
 ! exists $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.5.2.mod
 cmp go.sum go.sum.h2only
 rm go.sum
@@ -21,7 +21,7 @@ rm go.sum
 cp go.mod go.mod.orig
 go mod edit -replace rsc.io/quote@v1.5.2=rsc.io/quote@v1.5.1
 ! go list -m all
-stderr '^go: rsc.io/quote@v1.5.2 \(replaced by rsc.io/quote@v1.5.1\): missing go.sum entry; to add it:\n\tgo mod download rsc.io/quote$'
+stderr '^go list -m: rsc.io/quote@v1.5.2 \(replaced by rsc.io/quote@v1.5.1\): missing go.sum entry; to add it:\n\tgo mod download rsc.io/quote$'
 ! exists $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.5.1.mod
 ! exists go.sum
 cp go.mod.orig go.mod
-- 
GitLab


From adb037d67ad46491bb0e9c2a09b56e89dd8a3617 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Tue, 23 Mar 2021 00:26:39 -0400
Subject: [PATCH 1227/2400] cmd/go: attribute direct imports from indirect
 dependencies to the importing package

For #36460
Updates #40775

Change-Id: I833ee8ee733151aafcff508bf91d0e6e37c50032
Reviewed-on: https://go-review.googlesource.com/c/go/+/303869
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/load/pkg.go               | 25 +++++++++++
 src/cmd/go/internal/modload/import.go         | 17 +++++++
 src/cmd/go/internal/modload/load.go           | 45 +++++++++++++------
 .../script/mod_get_promote_implicit.txt       |  2 +-
 4 files changed, 75 insertions(+), 14 deletions(-)

diff --git a/src/cmd/go/internal/load/pkg.go b/src/cmd/go/internal/load/pkg.go
index c9619f1b28..66b6d0dc46 100644
--- a/src/cmd/go/internal/load/pkg.go
+++ b/src/cmd/go/internal/load/pkg.go
@@ -29,6 +29,7 @@ import (
 	"cmd/go/internal/base"
 	"cmd/go/internal/cfg"
 	"cmd/go/internal/fsys"
+	"cmd/go/internal/imports"
 	"cmd/go/internal/modinfo"
 	"cmd/go/internal/modload"
 	"cmd/go/internal/par"
@@ -478,6 +479,7 @@ var (
 	_ ImportPathError = (*importError)(nil)
 	_ ImportPathError = (*modload.ImportMissingError)(nil)
 	_ ImportPathError = (*modload.ImportMissingSumError)(nil)
+	_ ImportPathError = (*modload.DirectImportFromImplicitDependencyError)(nil)
 )
 
 type importError struct {
@@ -675,6 +677,8 @@ func loadImport(ctx context.Context, pre *preload, path, srcDir string, parent *
 			stk.Push(path)
 			defer stk.Pop()
 		}
+		// TODO(bcmills): Why are we constructing Error inline here instead of
+		// calling setLoadPackageDataError?
 		return &Package{
 			PackagePublic: PackagePublic{
 				ImportPath: path,
@@ -840,6 +844,27 @@ func loadPackageData(ctx context.Context, path, parentPath, parentDir, parentRoo
 					data.p.Root = info.Dir
 				}
 			}
+			if r.err != nil {
+				if data.err != nil {
+					// ImportDir gave us one error, and the module loader gave us another.
+					// We arbitrarily choose to keep the error from ImportDir because
+					// that's what our tests already expect, and it seems to provide a bit
+					// more detail in most cases.
+				} else if errors.Is(r.err, imports.ErrNoGo) {
+					// ImportDir said there were files in the package, but the module
+					// loader said there weren't. Which one is right?
+					// Without this special-case hack, the TestScript/test_vet case fails
+					// on the vetfail/p1 package (added in CL 83955).
+					// Apparently, imports.ShouldBuild biases toward rejecting files
+					// with invalid build constraints, whereas ImportDir biases toward
+					// accepting them.
+					//
+					// TODO(#41410: Figure out how this actually ought to work and fix
+					// this mess.
+				} else {
+					data.err = r.err
+				}
+			}
 		} else if r.err != nil {
 			data.p = new(build.Package)
 			data.err = r.err
diff --git a/src/cmd/go/internal/modload/import.go b/src/cmd/go/internal/modload/import.go
index 508db2f247..1d321bb24b 100644
--- a/src/cmd/go/internal/modload/import.go
+++ b/src/cmd/go/internal/modload/import.go
@@ -128,6 +128,23 @@ func (e *AmbiguousImportError) Error() string {
 	return buf.String()
 }
 
+// A DirectImportFromImplicitDependencyError indicates a package directly
+// imported by a package or test in the main module that is satisfied by a
+// dependency that is not explicit in the main module's go.mod file.
+type DirectImportFromImplicitDependencyError struct {
+	ImporterPath string
+	ImportedPath string
+	Module       module.Version
+}
+
+func (e *DirectImportFromImplicitDependencyError) Error() string {
+	return fmt.Sprintf("package %s imports %s from implicitly required module; to add missing requirements, run:\n\tgo get %s@%s", e.ImporterPath, e.ImportedPath, e.Module.Path, e.Module.Version)
+}
+
+func (e *DirectImportFromImplicitDependencyError) ImportPath() string {
+	return e.ImporterPath
+}
+
 // ImportMissingSumError is reported in readonly mode when we need to check
 // if a module contains a package, but we don't have a sum for its .zip file.
 // We might need sums for multiple modules to verify the package is unique.
diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index d89dc67028..386b53938c 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -940,32 +940,51 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 	}
 	base.ExitIfErrors() // TODO(bcmills): Is this actually needed?
 
+	rs := ld.requirements
+
 	// Compute directly referenced dependency modules.
 	direct := make(map[string]bool)
 	for _, pkg := range ld.pkgs {
-		if pkg.mod == Target {
-			for _, dep := range pkg.imports {
-				if dep.mod.Path != "" && dep.mod.Path != Target.Path && index != nil {
-					_, explicit := index.require[dep.mod]
-					if allowWriteGoMod && cfg.BuildMod == "readonly" && !explicit {
-						// TODO(#40775): attach error to package instead of using
-						// base.Errorf. Ideally, 'go list' should not fail because of this,
-						// but today, LoadPackages calls WriteGoMod unconditionally, which
-						// would fail with a less clear message.
-						base.Errorf("go: %[1]s: package %[2]s imported from implicitly required module; to add missing requirements, run:\n\tgo get %[2]s@%[3]s", pkg.path, dep.path, dep.mod.Version)
+		if pkg.mod != Target {
+			continue
+		}
+		for _, dep := range pkg.imports {
+			if dep.mod.Path == "" || dep.mod.Path == Target.Path {
+				continue
+			}
+
+			if pkg.err == nil && cfg.BuildMod != "mod" {
+				if v, ok := rs.rootSelected(dep.mod.Path); !ok || v != dep.mod.Version {
+					// dep.mod is not an explicit dependency, but needs to be.
+					// Because we are not in "mod" mod, we will not be able to update it.
+					// Instead, mark the importing package with an error.
+					//
+					// TODO(#41688): The resulting error message fails to include the file
+					// position of the erroneous import (because that information is not
+					// tracked by the module loader). Figure out how to plumb the import
+					// position through.
+					pkg.err = &DirectImportFromImplicitDependencyError{
+						ImporterPath: pkg.path,
+						ImportedPath: dep.path,
+						Module:       dep.mod,
 					}
-					direct[dep.mod.Path] = true
+					// cfg.BuildMod does not allow us to change dep.mod to be a direct
+					// dependency, so don't mark it as such.
+					continue
 				}
 			}
+
+			// dep is a package directly imported by a package or test in the main
+			// module and loaded from some other module (not the standard library).
+			// Mark its module as a direct dependency.
+			direct[dep.mod.Path] = true
 		}
 	}
-	base.ExitIfErrors()
 
 	// If we didn't scan all of the imports from the main module, or didn't use
 	// imports.AnyTags, then we didn't necessarily load every package that
 	// contributes “direct” imports — so we can't safely mark existing
 	// direct dependencies in ld.requirements as indirect-only. Propagate them as direct.
-	rs := ld.requirements
 	if !ld.loadedDirect() {
 		for mPath := range rs.direct {
 			direct[mPath] = true
diff --git a/src/cmd/go/testdata/script/mod_get_promote_implicit.txt b/src/cmd/go/testdata/script/mod_get_promote_implicit.txt
index 10ca6594e4..9eec201321 100644
--- a/src/cmd/go/testdata/script/mod_get_promote_implicit.txt
+++ b/src/cmd/go/testdata/script/mod_get_promote_implicit.txt
@@ -6,7 +6,7 @@ cp go.mod.orig go.mod
 go list -m indirect-with-pkg
 stdout '^indirect-with-pkg v1.0.0 => ./indirect-with-pkg$'
 ! go list ./use-indirect
-stderr '^go: m/use-indirect: package indirect-with-pkg imported from implicitly required module; to add missing requirements, run:\n\tgo get indirect-with-pkg@v1.0.0$'
+stderr '^package m/use-indirect imports indirect-with-pkg from implicitly required module; to add missing requirements, run:\n\tgo get indirect-with-pkg@v1.0.0$'
 
 # We can promote the implicit requirement by getting the importing package.
 # NOTE: the hint recommends getting the imported package (tested below) since
-- 
GitLab


From 4889afe8f82433599a38b74808eb572f972d4ff9 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Tue, 23 Mar 2021 11:57:36 -0400
Subject: [PATCH 1228/2400] cmd/go/internal/load: use setLoadPackageDataError
 in loadImport

This makes the error handling in loadImport somewhat more uniform,
with no discernable effect on reported errors.

Noticed in CL 303869.

Updates #36087
Updates #38034

This somewhat simplifies the code, with no discernable effect on

Change-Id: I30521f658f264d6f99d1844d6701269bbb372246
Reviewed-on: https://go-review.googlesource.com/c/go/+/304069
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/load/pkg.go | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/src/cmd/go/internal/load/pkg.go b/src/cmd/go/internal/load/pkg.go
index 66b6d0dc46..a6d730d0d8 100644
--- a/src/cmd/go/internal/load/pkg.go
+++ b/src/cmd/go/internal/load/pkg.go
@@ -672,22 +672,25 @@ func loadImport(ctx context.Context, pre *preload, path, srcDir string, parent *
 		pre.preloadImports(ctx, bp.Imports, bp)
 	}
 	if bp == nil {
-		if importErr, ok := err.(ImportPathError); !ok || importErr.ImportPath() != path {
-			// Only add path to the error's import stack if it's not already present on the error.
-			stk.Push(path)
-			defer stk.Pop()
-		}
-		// TODO(bcmills): Why are we constructing Error inline here instead of
-		// calling setLoadPackageDataError?
-		return &Package{
+		p := &Package{
 			PackagePublic: PackagePublic{
 				ImportPath: path,
-				Error: &PackageError{
-					ImportStack: stk.Copy(),
-					Err:         err,
-				},
+				Incomplete: true,
 			},
 		}
+		if importErr, ok := err.(ImportPathError); !ok || importErr.ImportPath() != path {
+			// Only add path to the error's import stack if it's not already present
+			// in the error.
+			//
+			// TODO(bcmills): setLoadPackageDataError itself has a similar Push / Pop
+			// sequence that empirically doesn't trigger for these errors, guarded by
+			// a somewhat complex condition. Figure out how to generalize that
+			// condition and eliminate the explicit calls here.
+			stk.Push(path)
+			defer stk.Pop()
+		}
+		p.setLoadPackageDataError(err, path, stk, nil)
+		return p
 	}
 
 	importPath := bp.ImportPath
-- 
GitLab


From c69515c9fd19d9cca5f509cedd3de0aafd2d487f Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 18 Mar 2021 17:15:05 -0700
Subject: [PATCH 1229/2400] cmd/compile/internal/types2: review of expr.go

The changes between (equivalent, and reviewed) go/types/expr.go
and expr.go can be seen by comparing patchset 1 and 2. The actual
changes are removing the "// UNREVIEWED" marker.

The primary differences to go/types/expr.go are:
- use of package syntax rather than ast
- no reporting of error codes in errors
- implicit conversions of untyped nil lead to a typed nil
  (in go/types, nil remains untyped)

Change-Id: I1e235b20ebda597eb7ce597d1749f26431addde2
Reviewed-on: https://go-review.googlesource.com/c/go/+/303092
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/expr.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 3706185817..2eb4ded465 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2012 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.
-- 
GitLab


From 607f99904e3f5565517eee452d9153a634a66369 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 23 Mar 2021 11:55:16 -0700
Subject: [PATCH 1230/2400] cmd/compile/internal/types2: review of api.go

The changes between (equivalent, and reviewed) go/types/api.go
and api.go can be seen by comparing patchset 1 and 2. The actual
changes are removing the "// UNREVIEWED" marker.

The primary differences to go/types/api.go are:
- use of syntax instead of go/ast package
- use of simpler Error type (for now)
- additional exported Config flags
- different handling of nil values (we can't use Typ[UntypedNil]
  to represent an untyped nil because types2 gives such nil values
  context-dependent types)

Change-Id: I7d46b29d460c656d7a36fe70108a370383266373
Reviewed-on: https://go-review.googlesource.com/c/go/+/304050
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/api.go | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/cmd/compile/internal/types2/api.go b/src/cmd/compile/internal/types2/api.go
index acb196a336..19adaba578 100644
--- a/src/cmd/compile/internal/types2/api.go
+++ b/src/cmd/compile/internal/types2/api.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2012 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.
@@ -23,8 +22,6 @@
 // and checks for compliance with the language specification.
 // Use Info.Types[expr].Type for the results of type inference.
 //
-// For a tutorial, see https://golang.org/s/types-tutorial.
-//
 package types2
 
 import (
-- 
GitLab


From ddcdbb417b47e50fc7006c9438104c5b8b5f75e4 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 23 Mar 2021 12:03:51 -0700
Subject: [PATCH 1231/2400] cmd/compile/internal/types2: review of
 assignments.go

The changes between (equivalent, and reviewed) go/types/assignments.go
and assignments.go can be seen by comparing patchset 1 and 2. The actual
changes are removing the "// UNREVIEWED" marker.

The primary differences to go/types/assignments.go are:
- use of syntax instead of go/ast package
- no reporting of error codes (for now)
- different handling of nil values (we can't use Typ[UntypedNil]
  to represent an untyped nil because types2 gives such nil values
  context-dependent types)

Change-Id: I5d8a58f43ca8ed2daa060c46842a6ebc11b3cb35
Reviewed-on: https://go-review.googlesource.com/c/go/+/304051
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/assignments.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/assignments.go b/src/cmd/compile/internal/types2/assignments.go
index 272e2fee6e..b8cf46c364 100644
--- a/src/cmd/compile/internal/types2/assignments.go
+++ b/src/cmd/compile/internal/types2/assignments.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2013 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.
@@ -131,6 +130,8 @@ func (check *Checker) initVar(lhs *Var, x *operand, context string) Type {
 		if lhs.typ == nil {
 			lhs.typ = Typ[Invalid]
 		}
+		// Note: This was reverted in go/types (https://golang.org/cl/292751).
+		// TODO(gri): decide what to do (also affects test/run.go exclusion list)
 		lhs.used = true // avoid follow-on "declared but not used" errors
 		return nil
 	}
-- 
GitLab


From dec3d00b28657ce9e2fe725c858a46c3dd3fd594 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 23 Mar 2021 12:30:18 -0700
Subject: [PATCH 1232/2400] cmd/compile/internal/types2: review of
 stdlib_test.go

The changes between (equivalent, and reviewed) go/types/stdlib_test.go
and stdlib_test.go can be seen by comparing patchset 1 and 2. The actual
changes are removing the "// UNREVIEWED" marker, using the os package
instead of ioutil, and some comment adjustments. Also, bug251.go passes
because of recent changes.

The primary difference is in the firstComment function which
doesn't have access to a scanner and instead uses the syntax
package's CommentsDu function.

Change-Id: I946ffadc97e87c692f76f369a1b16cceee528477
Reviewed-on: https://go-review.googlesource.com/c/go/+/304130
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 .../compile/internal/types2/stdlib_test.go    | 33 +++++++++----------
 1 file changed, 15 insertions(+), 18 deletions(-)

diff --git a/src/cmd/compile/internal/types2/stdlib_test.go b/src/cmd/compile/internal/types2/stdlib_test.go
index 34925687e3..6853bd23b0 100644
--- a/src/cmd/compile/internal/types2/stdlib_test.go
+++ b/src/cmd/compile/internal/types2/stdlib_test.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2013 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.
@@ -14,7 +13,6 @@ import (
 	"fmt"
 	"go/build"
 	"internal/testenv"
-	"io/ioutil"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -91,7 +89,7 @@ func firstComment(filename string) (first string) {
 }
 
 func testTestDir(t *testing.T, path string, ignore ...string) {
-	files, err := ioutil.ReadDir(path)
+	files, err := os.ReadDir(path)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -184,17 +182,16 @@ func TestStdFixed(t *testing.T) {
 		"bug248.go", "bug302.go", "bug369.go", // complex test instructions - ignore
 		"issue6889.go",   // gc-specific test
 		"issue11362.go",  // canonical import path check
-		"issue16369.go",  // go/types handles this correctly - not an issue
-		"issue18459.go",  // go/types doesn't check validity of //go:xxx directives
-		"issue18882.go",  // go/types doesn't check validity of //go:xxx directives
-		"issue20529.go",  // go/types does not have constraints on stack size
-		"issue22200.go",  // go/types does not have constraints on stack size
-		"issue22200b.go", // go/types does not have constraints on stack size
-		"issue25507.go",  // go/types does not have constraints on stack size
-		"issue20780.go",  // go/types does not have constraints on stack size
-		"issue42058a.go", // go/types does not have constraints on channel element size
-		"issue42058b.go", // go/types does not have constraints on channel element size
-		"bug251.go",      // issue #34333 which was exposed with fix for #34151
+		"issue16369.go",  // types2 handles this correctly - not an issue
+		"issue18459.go",  // types2 doesn't check validity of //go:xxx directives
+		"issue18882.go",  // types2 doesn't check validity of //go:xxx directives
+		"issue20529.go",  // types2 does not have constraints on stack size
+		"issue22200.go",  // types2 does not have constraints on stack size
+		"issue22200b.go", // types2 does not have constraints on stack size
+		"issue25507.go",  // types2 does not have constraints on stack size
+		"issue20780.go",  // types2 does not have constraints on stack size
+		"issue42058a.go", // types2 does not have constraints on channel element size
+		"issue42058b.go", // types2 does not have constraints on channel element size
 	)
 }
 
@@ -298,7 +295,7 @@ func (w *walker) walk(dir string) {
 		return
 	}
 
-	fis, err := ioutil.ReadDir(dir)
+	files, err := os.ReadDir(dir)
 	if err != nil {
 		w.errh(err)
 		return
@@ -318,9 +315,9 @@ func (w *walker) walk(dir string) {
 	}
 
 	// traverse subdirectories, but don't walk into testdata
-	for _, fi := range fis {
-		if fi.IsDir() && fi.Name() != "testdata" {
-			w.walk(filepath.Join(dir, fi.Name()))
+	for _, f := range files {
+		if f.IsDir() && f.Name() != "testdata" {
+			w.walk(filepath.Join(dir, f.Name()))
 		}
 	}
 }
-- 
GitLab


From 402d784b8fc0a7914955eb168ea288338e2025ff Mon Sep 17 00:00:00 2001
From: Aman Gupta <aman@tmm1.net>
Date: Fri, 4 Sep 2020 16:07:12 -0700
Subject: [PATCH 1233/2400] path/filepath: make Rel handle Windows UNC share

Fixes #41230

Change-Id: Iea15e4ae6d56328333fd22de5d78dfcad78ef1bc
Reviewed-on: https://go-review.googlesource.com/c/go/+/253197
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
Trust: Alex Brainman <alex.brainman@gmail.com>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Alex Brainman <alex.brainman@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/path/filepath/path.go      | 4 ++++
 src/path/filepath/path_test.go | 1 +
 2 files changed, 5 insertions(+)

diff --git a/src/path/filepath/path.go b/src/path/filepath/path.go
index 2e7b439355..28b30b1ae7 100644
--- a/src/path/filepath/path.go
+++ b/src/path/filepath/path.go
@@ -275,7 +275,11 @@ func Rel(basepath, targpath string) (string, error) {
 	targ = targ[len(targVol):]
 	if base == "." {
 		base = ""
+	} else if base == "" && volumeNameLen(baseVol) > 2 /* isUNC */ {
+		// Treat any targetpath matching `\\host\share` basepath as absolute path.
+		base = string(Separator)
 	}
+
 	// Can't use IsAbs - `\a` and `a` are both relative in Windows.
 	baseSlashed := len(base) > 0 && base[0] == Separator
 	targSlashed := len(targ) > 0 && targ[0] == Separator
diff --git a/src/path/filepath/path_test.go b/src/path/filepath/path_test.go
index 8616256ac0..1d9889d320 100644
--- a/src/path/filepath/path_test.go
+++ b/src/path/filepath/path_test.go
@@ -1227,6 +1227,7 @@ var winreltests = []RelTests{
 	{`C:\Projects`, `c:\projects\src`, `src`},
 	{`C:\Projects`, `c:\projects`, `.`},
 	{`C:\Projects\a\..`, `c:\projects`, `.`},
+	{`\\host\share`, `\\host\share\file.txt`, `file.txt`},
 }
 
 func TestRel(t *testing.T) {
-- 
GitLab


From 9f4d5c94b0cafc4d888b7f02e4ff12c2ff39eedc Mon Sep 17 00:00:00 2001
From: Ayan George <ayan@ayan.net>
Date: Tue, 2 Mar 2021 17:44:22 -0500
Subject: [PATCH 1234/2400] cmd/go: emit error when listing with -f and -json

Fixes #44738
Change-Id: Ie57ddcbe87408c9644313ec2a9ea347b4d6de76b
Reviewed-on: https://go-review.googlesource.com/c/go/+/298029
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Trust: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/list/list.go              |  4 ++++
 .../go/testdata/script/list_json_with_f.txt   | 20 +++++++++++++++++++
 2 files changed, 24 insertions(+)
 create mode 100644 src/cmd/go/testdata/script/list_json_with_f.txt

diff --git a/src/cmd/go/internal/list/list.go b/src/cmd/go/internal/list/list.go
index bb48d2d2ea..1e1c6495bf 100644
--- a/src/cmd/go/internal/list/list.go
+++ b/src/cmd/go/internal/list/list.go
@@ -335,6 +335,10 @@ var (
 var nl = []byte{'\n'}
 
 func runList(ctx context.Context, cmd *base.Command, args []string) {
+	if *listFmt != "" && *listJson == true {
+		base.Fatalf("go list -f cannot be used with -json")
+	}
+
 	load.ModResolveTests = *listTest
 	work.BuildInit()
 	out := newTrackingWriter(os.Stdout)
diff --git a/src/cmd/go/testdata/script/list_json_with_f.txt b/src/cmd/go/testdata/script/list_json_with_f.txt
new file mode 100644
index 0000000000..2011a6e808
--- /dev/null
+++ b/src/cmd/go/testdata/script/list_json_with_f.txt
@@ -0,0 +1,20 @@
+[short] skip
+
+# list -json should generate output on stdout
+go list -json ./...
+stdout .
+# list -f should generate output on stdout
+go list -f '{{.}}' ./...
+stdout .
+
+# test passing first -json then -f
+! go list -json -f '{{.}}' ./...
+stderr '^go list -f cannot be used with -json$'
+
+# test passing first -f then -json
+! go list -f '{{.}}' -json ./...
+stderr '^go list -f cannot be used with -json$'
+-- go.mod --
+module m
+-- list_test.go --
+package list_test
-- 
GitLab


From 53941b6150a1f9ca01c02316c8db51024294a4c9 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Thu, 25 Mar 2021 08:30:19 -0400
Subject: [PATCH 1235/2400] cmd/compile: fix defer desugar keepalive arg
 handling buglet

Fix a bug in the go/defer desugar handling of keepalive arguments. The
go/defer wrapping code has special handling for calls whose arguments
are pointers that have been cast to "uintptr", so as to insure that
call "keepalive" machinery for such calls continues to work. This
patch fixes a bug in the special case code to insure that it doesn't
kick in for other situations where you have an unsafe.Pointer ->
uintptr argument (outside the keepalive context).

Fixes make.bat on windows with GOEXPERIMENT=regabidefer in effect.

Change-Id: I9db89c4c73f0db1235901a4fae57f62f88c94ac3
Reviewed-on: https://go-review.googlesource.com/c/go/+/304457
Trust: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/walk/order.go | 59 ++++++++++++++++++++------
 1 file changed, 45 insertions(+), 14 deletions(-)

diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index 5a687d8e34..95d245d0d7 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -1458,8 +1458,9 @@ var wrapGoDefer_prgen int
 func (o *orderState) wrapGoDefer(n *ir.GoDeferStmt) {
 	call := n.Call
 
-	var callX ir.Node      // thing being called
-	var callArgs []ir.Node // call arguments
+	var callX ir.Node        // thing being called
+	var callArgs []ir.Node   // call arguments
+	var keepAlive []*ir.Name // KeepAlive list from call, if present
 
 	// A helper to recreate the call within the closure.
 	var mkNewCall func(pos src.XPos, op ir.Op, fun ir.Node, args []ir.Node) ir.Node
@@ -1470,6 +1471,7 @@ func (o *orderState) wrapGoDefer(n *ir.GoDeferStmt) {
 	case *ir.CallExpr:
 		callX = x.X
 		callArgs = x.Args
+		keepAlive = x.KeepAlive
 		mkNewCall = func(pos src.XPos, op ir.Op, fun ir.Node, args []ir.Node) ir.Node {
 			newcall := ir.NewCallExpr(pos, op, fun, args)
 			newcall.IsDDD = x.IsDDD
@@ -1540,21 +1542,49 @@ func (o *orderState) wrapGoDefer(n *ir.GoDeferStmt) {
 		return argCopy
 	}
 
-	unsafeArgs := make([]*ir.Name, len(callArgs))
-	origArgs := callArgs
+	// getUnsafeArg looks for an unsafe.Pointer arg that has been
+	// previously captured into the call's keepalive list, returning
+	// the name node for it if found.
+	getUnsafeArg := func(arg ir.Node) *ir.Name {
+		// Look for uintptr(unsafe.Pointer(name))
+		if arg.Op() != ir.OCONVNOP {
+			return nil
+		}
+		if !arg.Type().IsUintptr() {
+			return nil
+		}
+		if !arg.(*ir.ConvExpr).X.Type().IsUnsafePtr() {
+			return nil
+		}
+		arg = arg.(*ir.ConvExpr).X
+		argname, ok := arg.(*ir.Name)
+		if !ok {
+			return nil
+		}
+		for i := range keepAlive {
+			if argname == keepAlive[i] {
+				return argname
+			}
+		}
+		return nil
+	}
 
 	// Copy the arguments to the function into temps.
-	pos := n.Pos()
-	outerfn := ir.CurFunc
+	//
+	// For calls with uintptr(unsafe.Pointer(...)) args that are being
+	// kept alive (see code in (*orderState).call that does this), use
+	// the existing arg copy instead of creating a new copy.
+	unsafeArgs := make([]*ir.Name, len(callArgs))
+	origArgs := callArgs
 	var newNames []*ir.Name
 	for i := range callArgs {
 		arg := callArgs[i]
 		var argname *ir.Name
-		if arg.Op() == ir.OCONVNOP && arg.Type().IsUintptr() && arg.(*ir.ConvExpr).X.Type().IsUnsafePtr() {
-			// No need for copy here; orderState.call() above has already inserted one.
-			arg = arg.(*ir.ConvExpr).X
-			argname = arg.(*ir.Name)
-			unsafeArgs[i] = argname
+		unsafeArgName := getUnsafeArg(arg)
+		if unsafeArgName != nil {
+			// arg has been copied already, use keepalive copy
+			argname = unsafeArgName
+			unsafeArgs[i] = unsafeArgName
 		} else {
 			argname = mkArgCopy(arg)
 		}
@@ -1589,6 +1619,7 @@ func (o *orderState) wrapGoDefer(n *ir.GoDeferStmt) {
 	var noFuncArgs []*ir.Field
 	noargst := ir.NewFuncType(base.Pos, nil, noFuncArgs, nil)
 	wrapGoDefer_prgen++
+	outerfn := ir.CurFunc
 	wrapname := fmt.Sprintf("%v·dwrap·%d", outerfn, wrapGoDefer_prgen)
 	sym := types.LocalPkg.Lookup(wrapname)
 	fn := typecheck.DeclFunc(sym, noargst)
@@ -1622,7 +1653,7 @@ func (o *orderState) wrapGoDefer(n *ir.GoDeferStmt) {
 	if methSelectorExpr != nil {
 		methSelectorExpr.X = capName(callX.Pos(), fn, methSelectorExpr.X.(*ir.Name))
 	}
-	ir.FinishCaptureNames(pos, outerfn, fn)
+	ir.FinishCaptureNames(n.Pos(), outerfn, fn)
 
 	// This flags a builtin as opposed to a regular call.
 	irregular := (call.Op() != ir.OCALLFUNC &&
@@ -1650,7 +1681,7 @@ func (o *orderState) wrapGoDefer(n *ir.GoDeferStmt) {
 	typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
 
 	// Create closure expr
-	clo := ir.NewClosureExpr(pos, fn)
+	clo := ir.NewClosureExpr(n.Pos(), fn)
 	fn.OClosure = clo
 	clo.SetType(fn.Type())
 
@@ -1672,7 +1703,7 @@ func (o *orderState) wrapGoDefer(n *ir.GoDeferStmt) {
 	}
 
 	// Create new top level call to closure over argless function.
-	topcall := ir.NewCallExpr(pos, ir.OCALL, clo, []ir.Node{})
+	topcall := ir.NewCallExpr(n.Pos(), ir.OCALL, clo, []ir.Node{})
 	typecheck.Call(topcall)
 
 	// Tag the call to insure that directClosureCall doesn't undo our work.
-- 
GitLab


From 4d66d77cd22812de4526e3973bc3314040a939a5 Mon Sep 17 00:00:00 2001
From: Elias506 <56119080+Elias506@users.noreply.github.com>
Date: Thu, 25 Mar 2021 14:46:15 +0000
Subject: [PATCH 1236/2400] database/sql: remove unnecessary types in composite
 literals

Change-Id: I30c576f826c82cbc62ce28ea7f4886702bd6605d
GitHub-Last-Rev: 2fead200dba13ec74d81e842d8bae97d1e67fcc4
GitHub-Pull-Request: golang/go#42618
Reviewed-on: https://go-review.googlesource.com/c/go/+/270000
Reviewed-by: Daniel Theophanes <kardianos@gmail.com>
Trust: Cherry Zhang <cherryyz@google.com>
---
 src/database/sql/fakedb_test.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/database/sql/fakedb_test.go b/src/database/sql/fakedb_test.go
index 1bfd1118aa..72e16e05b1 100644
--- a/src/database/sql/fakedb_test.go
+++ b/src/database/sql/fakedb_test.go
@@ -915,7 +915,7 @@ func (s *fakeStmt) QueryContext(ctx context.Context, args []driver.NamedValue) (
 				parentMem: s.c,
 				posRow:    -1,
 				rows: [][]*row{
-					[]*row{
+					{
 						{
 							cols: []interface{}{
 								txStatus,
@@ -924,12 +924,12 @@ func (s *fakeStmt) QueryContext(ctx context.Context, args []driver.NamedValue) (
 					},
 				},
 				cols: [][]string{
-					[]string{
+					{
 						"tx_status",
 					},
 				},
 				colType: [][]string{
-					[]string{
+					{
 						"string",
 					},
 				},
-- 
GitLab


From 82a1e0f9d3e47ae7792cb857e950abc7103e9f39 Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Tue, 23 Mar 2021 15:40:54 -0500
Subject: [PATCH 1237/2400] cmd/link: make symbol data writable before toc
 fixup

On ppc64le, we need to insert a load to restore the toc
pointer in R2 after calling into plt stubs. Sometimes the
symbol data is loaded into readonly memory. This is the
case when linking with the race detector code.

Likewise, add extra checks to ensure we can, and are
replacing a nop.

Change-Id: Iea9d9ee7a5ba0f4ce285f4d0422823de1c037cb7
Reviewed-on: https://go-review.googlesource.com/c/go/+/304430
Run-TryBot: Paul Murphy <murp@ibm.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Lynn Boger <laboger@linux.vnet.ibm.com>
---
 src/cmd/link/internal/ppc64/asm.go | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/src/cmd/link/internal/ppc64/asm.go b/src/cmd/link/internal/ppc64/asm.go
index aa2532ad37..e8e258a1f3 100644
--- a/src/cmd/link/internal/ppc64/asm.go
+++ b/src/cmd/link/internal/ppc64/asm.go
@@ -121,16 +121,21 @@ func genplt(ctxt *ld.Link, ldr *loader.Loader) {
 			// Update the relocation to use the call stub
 			r.SetSym(stub.Sym())
 
-			// make sure the data is writeable
-			if ldr.AttrReadOnly(s) {
-				panic("can't write to read-only sym data")
+			// Make the symbol writeable so we can fixup toc.
+			su := ldr.MakeSymbolUpdater(s)
+			su.MakeWritable()
+			p := su.Data()
+
+			// Check for toc restore slot (a nop), and replace with toc restore.
+			var nop uint32
+			if len(p) >= int(r.Off()+8) {
+				nop = ctxt.Arch.ByteOrder.Uint32(p[r.Off()+4:])
+			}
+			if nop != 0x60000000 {
+				ldr.Errorf(s, "Symbol %s is missing toc restoration slot at offset %d", ldr.SymName(s), r.Off()+4)
 			}
-
-			// Restore TOC after bl. The compiler put a
-			// nop here for us to overwrite.
-			sp := ldr.Data(s)
 			const o1 = 0xe8410018 // ld r2,24(r1)
-			ctxt.Arch.ByteOrder.PutUint32(sp[r.Off()+4:], o1)
+			ctxt.Arch.ByteOrder.PutUint32(p[r.Off()+4:], o1)
 		}
 	}
 	// Put call stubs at the beginning (instead of the end).
-- 
GitLab


From 74fe516c3549e8177aa5326e6ce17efd529e3383 Mon Sep 17 00:00:00 2001
From: Johan Jansson <johan.jansson@iki.fi>
Date: Wed, 24 Mar 2021 17:14:29 +0200
Subject: [PATCH 1238/2400] cmd/go: add -benchtime to cacheable test flags

Add -benchtime to the list of flags that allow caching test results.

If -benchtime is set without -bench, no benchmarks are run. The cache
does not need to be invalidated in this case.

If -benchtime is set with -bench, benchmarks are run. The cache is
invalidated due to the -bench flag in this case.

Fixes #44555

Change-Id: I2eb5c9f389a587d150fb984590d145251d0fa2dc
Reviewed-on: https://go-review.googlesource.com/c/go/+/304689
Reviewed-by: Jay Conrod <jayconrod@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/alldocs.go                            |  4 ++--
 src/cmd/go/internal/test/test.go                 |  7 ++++---
 src/cmd/go/testdata/script/test_cache_inputs.txt | 13 +++++++++++++
 3 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index 9aac344a3f..b15b77fac8 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -1408,8 +1408,8 @@
 //
 // The rule for a match in the cache is that the run involves the same
 // test binary and the flags on the command line come entirely from a
-// restricted set of 'cacheable' test flags, defined as -cpu, -list,
-// -parallel, -run, -short, and -v. If a run of go test has any test
+// restricted set of 'cacheable' test flags, defined as -benchtime, -cpu,
+// -list, -parallel, -run, -short, and -v. If a run of go test has any test
 // or non-test flags outside this set, the result is not cached. To
 // disable test caching, use any test flag or argument other than the
 // cacheable flags. The idiomatic way to disable test caching explicitly
diff --git a/src/cmd/go/internal/test/test.go b/src/cmd/go/internal/test/test.go
index 230ea2d318..ebe13205f7 100644
--- a/src/cmd/go/internal/test/test.go
+++ b/src/cmd/go/internal/test/test.go
@@ -118,8 +118,8 @@ elapsed time in the summary line.
 
 The rule for a match in the cache is that the run involves the same
 test binary and the flags on the command line come entirely from a
-restricted set of 'cacheable' test flags, defined as -cpu, -list,
--parallel, -run, -short, and -v. If a run of go test has any test
+restricted set of 'cacheable' test flags, defined as -benchtime, -cpu,
+-list, -parallel, -run, -short, and -v. If a run of go test has any test
 or non-test flags outside this set, the result is not cached. To
 disable test caching, use any test flag or argument other than the
 cacheable flags. The idiomatic way to disable test caching explicitly
@@ -1333,7 +1333,8 @@ func (c *runCache) tryCacheWithID(b *work.Builder, a *work.Action, id string) bo
 			return false
 		}
 		switch arg[:i] {
-		case "-test.cpu",
+		case "-test.benchtime",
+			"-test.cpu",
 			"-test.list",
 			"-test.parallel",
 			"-test.run",
diff --git a/src/cmd/go/testdata/script/test_cache_inputs.txt b/src/cmd/go/testdata/script/test_cache_inputs.txt
index 50486e1909..d694a30994 100644
--- a/src/cmd/go/testdata/script/test_cache_inputs.txt
+++ b/src/cmd/go/testdata/script/test_cache_inputs.txt
@@ -99,6 +99,15 @@ rm $WORK/external.txt
 go test testcache -run=ExternalFile
 stdout '\(cached\)'
 
+# The -benchtime flag without -bench should not affect caching.
+go test testcache -run=Benchtime -benchtime=1x
+go test testcache -run=Benchtime -benchtime=1x
+stdout '\(cached\)'
+
+go test testcache -run=Benchtime -bench=Benchtime -benchtime=1x
+go test testcache -run=Benchtime -bench=Benchtime -benchtime=1x
+! stdout '\(cached\)'
+
 # Executables within GOROOT and GOPATH should affect caching,
 # even if the test does not stat them explicitly.
 
@@ -228,6 +237,10 @@ func TestExternalFile(t *testing.T) {
 func TestOSArgs(t *testing.T) {
 	t.Log(os.Args)
 }
+
+func TestBenchtime(t *testing.T) {
+}
+
 -- mkold.go --
 package main
 
-- 
GitLab


From 0fc595ec9999df08f25c2a981b8c9bf006079939 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 23 Mar 2021 12:11:26 -0700
Subject: [PATCH 1239/2400] cmd/compile/internal/types2: review of check.go

The changes between (equivalent, and reviewed) go/types/check.go
and check.go can be seen by comparing patchset 1 and 2. The actual
changes are removing the "// UNREVIEWED" marker.

The primary differences to go/types/check.go are:
- use of syntax instead of go/ast package
- tracing is controlled via flag not the "trace" constant

Change-Id: I1c9998afb3e0b7e29f5b169d3a4054cf22841490
Reviewed-on: https://go-review.googlesource.com/c/go/+/304109
Reviewed-by: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/types2/check.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/types2/check.go b/src/cmd/compile/internal/types2/check.go
index c65666e802..7d499eb13d 100644
--- a/src/cmd/compile/internal/types2/check.go
+++ b/src/cmd/compile/internal/types2/check.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2011 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.
@@ -17,7 +16,7 @@ import (
 var nopos syntax.Pos
 
 // debugging/development support
-const debug = true // leave on during development
+const debug = false // leave on during development
 
 // If forceStrict is set, the type-checker enforces additional
 // rules not specified by the Go 1 spec, but which will
-- 
GitLab


From 34ef294b76cc129411a572dc1df18a44eaa5768e Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 23 Mar 2021 12:19:50 -0700
Subject: [PATCH 1240/2400] cmd/compile/internal/types2: review of lookup.go

The changes between (equivalent, and reviewed) go/types/lookup.go
and lookup.go can be seen by comparing patchset 1 and 2. The actual
changes are removing the "// UNREVIEWED" marker.

Note: The function ptrRecv in types2/lookup.go is found in
      methodset.go in go/types (methodset.go doesn't exist
      in types2).

Change-Id: I48cfd3df0947becb4c3b5e55b89263917bcfbf16
Reviewed-on: https://go-review.googlesource.com/c/go/+/304129
Reviewed-by: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/types2/lookup.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go
index 34d18acdfc..a62def4183 100644
--- a/src/cmd/compile/internal/types2/lookup.go
+++ b/src/cmd/compile/internal/types2/lookup.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2013 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.
@@ -141,7 +140,7 @@ func (check *Checker) rawLookupFieldOrMethod(T Type, addressable bool, pkg *Pack
 
 				// continue with underlying type, but only if it's not a type parameter
 				// TODO(gri) is this what we want to do for type parameters? (spec question)
-				typ = under(named)
+				typ = named.under()
 				if asTypeParam(typ) != nil {
 					continue
 				}
-- 
GitLab


From ffa9983b998cd9667dec0cc5eeb102b14696e28b Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 23 Mar 2021 12:44:17 -0700
Subject: [PATCH 1241/2400] cmd/compile/internal/types2: review of api_test.go

The changes between (equivalent, and reviewed) go/types/api_test.go
and api_test.go can be seen by comparing patchset 1 and 2. The actual
changes are removing the "// UNREVIEWED" marker, the addition of the
TestConvertibleTo and TestAssignableTo tests, and adjustments to test
prefixes (genericPkg, brokenPkg to be in line with go/types).

There are several differences to go/types/api_test.go:
- use of syntax rather than go/ast package
- use of the parseSrc helper function
- TestTypesInfo test entries reflect different handling of untyped nil
- TestInferredInfo is (for go1.17) in another file controlled by a build
  constraint in go/types
- TestSelection test is currently skipped (types2 position information
  is not accurate enough)
- TestScopeLookupParent doesn't have access to a scanner and instead
  relies on syntax.CommentsDo.
- Broken packages are assumed to contain generic code for the tests.

Change-Id: Ic14e6fb9d6bef5416df39e465b5994de76f84097
Reviewed-on: https://go-review.googlesource.com/c/go/+/304131
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/api_test.go   | 150 ++++++++++++------
 .../internal/types2/typestring_test.go        |   4 +-
 2 files changed, 103 insertions(+), 51 deletions(-)

diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go
index a06a073f97..42135df1f6 100644
--- a/src/cmd/compile/internal/types2/api_test.go
+++ b/src/cmd/compile/internal/types2/api_test.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2013 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.
@@ -22,9 +21,21 @@ func unimplemented() {
 	panic("unimplemented")
 }
 
+// genericPkg is a source prefix for packages that contain generic code.
+const genericPkg = "package generic_"
+
+// brokenPkg is a source prefix for packages that are not expected to parse
+// or type-check cleanly. They are always parsed assuming that they contain
+// generic code.
+const brokenPkg = "package broken_"
+
 func parseSrc(path, src string) (*syntax.File, error) {
+	var mode syntax.Mode
+	if strings.HasPrefix(src, genericPkg) || strings.HasPrefix(src, brokenPkg) {
+		mode = syntax.AllowGenerics
+	}
 	errh := func(error) {} // dummy error handler so that parsing continues in presence of errors
-	return syntax.Parse(syntax.NewFileBase(path), strings.NewReader(src), errh, nil, syntax.AllowGenerics)
+	return syntax.Parse(syntax.NewFileBase(path), strings.NewReader(src), errh, nil, mode)
 }
 
 func pkgFor(path, source string, info *Info) (*Package, error) {
@@ -182,9 +193,6 @@ func TestValuesInfo(t *testing.T) {
 }
 
 func TestTypesInfo(t *testing.T) {
-	// Test sources that are not expected to typecheck must start with the broken prefix.
-	const broken = "package broken_"
-
 	var tests = []struct {
 		src  string
 		expr string // expression
@@ -315,37 +323,37 @@ func TestTypesInfo(t *testing.T) {
 		},
 
 		// tests for broken code that doesn't parse or type-check
-		{broken + `x0; func _() { var x struct {f string}; x.f := 0 }`, `x.f`, `string`},
-		{broken + `x1; func _() { var z string; type x struct {f string}; y := &x{q: z}}`, `z`, `string`},
-		{broken + `x2; func _() { var a, b string; type x struct {f string}; z := &x{f: a, f: b,}}`, `b`, `string`},
-		{broken + `x3; var x = panic("");`, `panic`, `func(interface{})`},
+		{brokenPkg + `x0; func _() { var x struct {f string}; x.f := 0 }`, `x.f`, `string`},
+		{brokenPkg + `x1; func _() { var z string; type x struct {f string}; y := &x{q: z}}`, `z`, `string`},
+		{brokenPkg + `x2; func _() { var a, b string; type x struct {f string}; z := &x{f: a, f: b,}}`, `b`, `string`},
+		{brokenPkg + `x3; var x = panic("");`, `panic`, `func(interface{})`},
 		{`package x4; func _() { panic("") }`, `panic`, `func(interface{})`},
-		{broken + `x5; func _() { var x map[string][...]int; x = map[string][...]int{"": {1,2,3}} }`, `x`, `map[string][-1]int`},
+		{brokenPkg + `x5; func _() { var x map[string][...]int; x = map[string][...]int{"": {1,2,3}} }`, `x`, `map[string][-1]int`},
 
 		// parameterized functions
-		{`package p0; func f[T any](T); var _ = f[int]`, `f`, `func[T₁ interface{}](T₁)`},
-		{`package p1; func f[T any](T); var _ = f[int]`, `f[int]`, `func(int)`},
-		{`package p2; func f[T any](T); func _() { f(42) }`, `f`, `func[T₁ interface{}](T₁)`},
-		{`package p3; func f[T any](T); func _() { f(42) }`, `f(42)`, `()`},
+		{genericPkg + `p0; func f[T any](T); var _ = f[int]`, `f`, `func[T₁ interface{}](T₁)`},
+		{genericPkg + `p1; func f[T any](T); var _ = f[int]`, `f[int]`, `func(int)`},
+		{genericPkg + `p2; func f[T any](T); func _() { f(42) }`, `f`, `func[T₁ interface{}](T₁)`},
+		{genericPkg + `p3; func f[T any](T); func _() { f(42) }`, `f(42)`, `()`},
 
 		// type parameters
-		{`package t0; type t[] int; var _ t`, `t`, `t0.t`}, // t[] is a syntax error that is ignored in this test in favor of t
-		{`package t1; type t[P any] int; var _ t[int]`, `t`, `t1.t[P₁ interface{}]`},
-		{`package t2; type t[P interface{}] int; var _ t[int]`, `t`, `t2.t[P₁ interface{}]`},
-		{`package t3; type t[P, Q interface{}] int; var _ t[int, int]`, `t`, `t3.t[P₁, Q₂ interface{}]`},
-		{broken + `t4; type t[P, Q interface{ m() }] int; var _ t[int, int]`, `t`, `broken_t4.t[P₁, Q₂ interface{m()}]`},
+		{genericPkg + `t0; type t[] int; var _ t`, `t`, `generic_t0.t`}, // t[] is a syntax error that is ignored in this test in favor of t
+		{genericPkg + `t1; type t[P any] int; var _ t[int]`, `t`, `generic_t1.t[P₁ interface{}]`},
+		{genericPkg + `t2; type t[P interface{}] int; var _ t[int]`, `t`, `generic_t2.t[P₁ interface{}]`},
+		{genericPkg + `t3; type t[P, Q interface{}] int; var _ t[int, int]`, `t`, `generic_t3.t[P₁, Q₂ interface{}]`},
+		{brokenPkg + `t4; type t[P, Q interface{ m() }] int; var _ t[int, int]`, `t`, `broken_t4.t[P₁, Q₂ interface{m()}]`},
 
 		// instantiated types must be sanitized
-		{`package g0; type t[P any] int; var x struct{ f t[int] }; var _ = x.f`, `x.f`, `g0.t[int]`},
+		{genericPkg + `g0; type t[P any] int; var x struct{ f t[int] }; var _ = x.f`, `x.f`, `generic_g0.t[int]`},
 
 		// issue 45096
-		{`package issue45096; func _[T interface{ type int8, int16, int32  }](x T) { _ = x < 0 }`, `0`, `T₁`},
+		{genericPkg + `issue45096; func _[T interface{ type int8, int16, int32  }](x T) { _ = x < 0 }`, `0`, `T₁`},
 	}
 
 	for _, test := range tests {
 		info := Info{Types: make(map[syntax.Expr]TypeAndValue)}
 		var name string
-		if strings.HasPrefix(test.src, broken) {
+		if strings.HasPrefix(test.src, brokenPkg) {
 			var err error
 			name, err = mayTypecheck(t, "TypesInfo", test.src, &info)
 			if err == nil {
@@ -383,103 +391,103 @@ func TestInferredInfo(t *testing.T) {
 		targs []string
 		sig   string
 	}{
-		{`package p0; func f[T any](T); func _() { f(42) }`,
+		{genericPkg + `p0; func f[T any](T); func _() { f(42) }`,
 			`f`,
 			[]string{`int`},
 			`func(int)`,
 		},
-		{`package p1; func f[T any](T) T; func _() { f('@') }`,
+		{genericPkg + `p1; func f[T any](T) T; func _() { f('@') }`,
 			`f`,
 			[]string{`rune`},
 			`func(rune) rune`,
 		},
-		{`package p2; func f[T any](...T) T; func _() { f(0i) }`,
+		{genericPkg + `p2; func f[T any](...T) T; func _() { f(0i) }`,
 			`f`,
 			[]string{`complex128`},
 			`func(...complex128) complex128`,
 		},
-		{`package p3; func f[A, B, C any](A, *B, []C); func _() { f(1.2, new(string), []byte{}) }`,
+		{genericPkg + `p3; func f[A, B, C any](A, *B, []C); func _() { f(1.2, new(string), []byte{}) }`,
 			`f`,
 			[]string{`float64`, `string`, `byte`},
 			`func(float64, *string, []byte)`,
 		},
-		{`package p4; func f[A, B any](A, *B, ...[]B); func _() { f(1.2, new(byte)) }`,
+		{genericPkg + `p4; func f[A, B any](A, *B, ...[]B); func _() { f(1.2, new(byte)) }`,
 			`f`,
 			[]string{`float64`, `byte`},
 			`func(float64, *byte, ...[]byte)`,
 		},
 
 		// we don't know how to translate these but we can type-check them
-		{`package q0; type T struct{}; func (T) m[P any](P); func _(x T) { x.m(42) }`,
+		{genericPkg + `q0; type T struct{}; func (T) m[P any](P); func _(x T) { x.m(42) }`,
 			`x.m`,
 			[]string{`int`},
 			`func(int)`,
 		},
-		{`package q1; type T struct{}; func (T) m[P any](P) P; func _(x T) { x.m(42) }`,
+		{genericPkg + `q1; type T struct{}; func (T) m[P any](P) P; func _(x T) { x.m(42) }`,
 			`x.m`,
 			[]string{`int`},
 			`func(int) int`,
 		},
-		{`package q2; type T struct{}; func (T) m[P any](...P) P; func _(x T) { x.m(42) }`,
+		{genericPkg + `q2; type T struct{}; func (T) m[P any](...P) P; func _(x T) { x.m(42) }`,
 			`x.m`,
 			[]string{`int`},
 			`func(...int) int`,
 		},
-		{`package q3; type T struct{}; func (T) m[A, B, C any](A, *B, []C); func _(x T) { x.m(1.2, new(string), []byte{}) }`,
+		{genericPkg + `q3; type T struct{}; func (T) m[A, B, C any](A, *B, []C); func _(x T) { x.m(1.2, new(string), []byte{}) }`,
 			`x.m`,
 			[]string{`float64`, `string`, `byte`},
 			`func(float64, *string, []byte)`,
 		},
-		{`package q4; type T struct{}; func (T) m[A, B any](A, *B, ...[]B); func _(x T) { x.m(1.2, new(byte)) }`,
+		{genericPkg + `q4; type T struct{}; func (T) m[A, B any](A, *B, ...[]B); func _(x T) { x.m(1.2, new(byte)) }`,
 			`x.m`,
 			[]string{`float64`, `byte`},
 			`func(float64, *byte, ...[]byte)`,
 		},
 
-		{`package r0; type T[P any] struct{}; func (_ T[P]) m[Q any](Q); func _[P any](x T[P]) { x.m(42) }`,
+		{genericPkg + `r0; type T[P any] struct{}; func (_ T[P]) m[Q any](Q); func _[P any](x T[P]) { x.m(42) }`,
 			`x.m`,
 			[]string{`int`},
 			`func(int)`,
 		},
 		// TODO(gri) record method type parameters in syntax.FuncType so we can check this
-		// {`package r1; type T interface{ m[P any](P) }; func _(x T) { x.m(4.2) }`,
+		// {genericPkg + `r1; type T interface{ m[P any](P) }; func _(x T) { x.m(4.2) }`,
 		// 	`x.m`,
 		// 	[]string{`float64`},
 		// 	`func(float64)`,
 		// },
 
-		{`package s1; func f[T any, P interface{type *T}](x T); func _(x string) { f(x) }`,
+		{genericPkg + `s1; func f[T any, P interface{type *T}](x T); func _(x string) { f(x) }`,
 			`f`,
 			[]string{`string`, `*string`},
 			`func(x string)`,
 		},
-		{`package s2; func f[T any, P interface{type *T}](x []T); func _(x []int) { f(x) }`,
+		{genericPkg + `s2; func f[T any, P interface{type *T}](x []T); func _(x []int) { f(x) }`,
 			`f`,
 			[]string{`int`, `*int`},
 			`func(x []int)`,
 		},
-		{`package s3; type C[T any] interface{type chan<- T}; func f[T any, P C[T]](x []T); func _(x []int) { f(x) }`,
+		{genericPkg + `s3; type C[T any] interface{type chan<- T}; func f[T any, P C[T]](x []T); func _(x []int) { f(x) }`,
 			`f`,
 			[]string{`int`, `chan<- int`},
 			`func(x []int)`,
 		},
-		{`package s4; type C[T any] interface{type chan<- T}; func f[T any, P C[T], Q C[[]*P]](x []T); func _(x []int) { f(x) }`,
+		{genericPkg + `s4; type C[T any] interface{type chan<- T}; func f[T any, P C[T], Q C[[]*P]](x []T); func _(x []int) { f(x) }`,
 			`f`,
 			[]string{`int`, `chan<- int`, `chan<- []*chan<- int`},
 			`func(x []int)`,
 		},
 
-		{`package t1; func f[T any, P interface{type *T}]() T; func _() { _ = f[string] }`,
+		{genericPkg + `t1; func f[T any, P interface{type *T}]() T; func _() { _ = f[string] }`,
 			`f`,
 			[]string{`string`, `*string`},
 			`func() string`,
 		},
-		{`package t2; type C[T any] interface{type chan<- T}; func f[T any, P C[T]]() []T; func _() { _ = f[int] }`,
+		{genericPkg + `t2; type C[T any] interface{type chan<- T}; func f[T any, P C[T]]() []T; func _() { _ = f[int] }`,
 			`f`,
 			[]string{`int`, `chan<- int`},
 			`func() []int`,
 		},
-		{`package t3; type C[T any] interface{type chan<- T}; func f[T any, P C[T], Q C[[]*P]]() []T; func _() { _ = f[int] }`,
+		{genericPkg + `t3; type C[T any] interface{type chan<- T}; func f[T any, P C[T], Q C[[]*P]]() []T; func _() { _ = f[int] }`,
 			`f`,
 			[]string{`int`, `chan<- int`, `chan<- []*chan<- int`},
 			`func() []int`,
@@ -551,10 +559,10 @@ func TestDefsInfo(t *testing.T) {
 
 		// generic types must be sanitized
 		// (need to use sufficiently nested types to provoke unexpanded types)
-		{`package g0; type t[P any] P; const x = t[int](42)`, `x`, `const g0.x g0.t[int]`},
-		{`package g1; type t[P any] P; var x = t[int](42)`, `x`, `var g1.x g1.t[int]`},
-		{`package g2; type t[P any] P; type x struct{ f t[int] }`, `x`, `type g2.x struct{f g2.t[int]}`},
-		{`package g3; type t[P any] P; func f(x struct{ f t[string] }); var g = f`, `g`, `var g3.g func(x struct{f g3.t[string]})`},
+		{genericPkg + `g0; type t[P any] P; const x = t[int](42)`, `x`, `const generic_g0.x generic_g0.t[int]`},
+		{genericPkg + `g1; type t[P any] P; var x = t[int](42)`, `x`, `var generic_g1.x generic_g1.t[int]`},
+		{genericPkg + `g2; type t[P any] P; type x struct{ f t[int] }`, `x`, `type generic_g2.x struct{f generic_g2.t[int]}`},
+		{genericPkg + `g3; type t[P any] P; func f(x struct{ f t[string] }); var g = f`, `g`, `var generic_g3.g func(x struct{f generic_g3.t[string]})`},
 	}
 
 	for _, test := range tests {
@@ -596,10 +604,10 @@ func TestUsesInfo(t *testing.T) {
 
 		// generic types must be sanitized
 		// (need to use sufficiently nested types to provoke unexpanded types)
-		{`package g0; func _() { _ = x }; type t[P any] P; const x = t[int](42)`, `x`, `const g0.x g0.t[int]`},
-		{`package g1; func _() { _ = x }; type t[P any] P; var x = t[int](42)`, `x`, `var g1.x g1.t[int]`},
-		{`package g2; func _() { type _ x }; type t[P any] P; type x struct{ f t[int] }`, `x`, `type g2.x struct{f g2.t[int]}`},
-		{`package g3; func _() { _ = f }; type t[P any] P; func f(x struct{ f t[string] })`, `f`, `func g3.f(x struct{f g3.t[string]})`},
+		{genericPkg + `g0; func _() { _ = x }; type t[P any] P; const x = t[int](42)`, `x`, `const generic_g0.x generic_g0.t[int]`},
+		{genericPkg + `g1; func _() { _ = x }; type t[P any] P; var x = t[int](42)`, `x`, `var generic_g1.x generic_g1.t[int]`},
+		{genericPkg + `g2; func _() { type _ x }; type t[P any] P; type x struct{ f t[int] }`, `x`, `type generic_g2.x struct{f generic_g2.t[int]}`},
+		{genericPkg + `g3; func _() { _ = f }; type t[P any] P; func f(x struct{ f t[string] })`, `f`, `func generic_g3.f(x struct{f generic_g3.t[string]})`},
 	}
 
 	for _, test := range tests {
@@ -1560,6 +1568,50 @@ func F(){
 	}
 }
 
+func TestConvertibleTo(t *testing.T) {
+	for _, test := range []struct {
+		v, t Type
+		want bool
+	}{
+		{Typ[Int], Typ[Int], true},
+		{Typ[Int], Typ[Float32], true},
+		{newDefined(Typ[Int]), Typ[Int], true},
+		{newDefined(new(Struct)), new(Struct), true},
+		{newDefined(Typ[Int]), new(Struct), false},
+		{Typ[UntypedInt], Typ[Int], true},
+		// Untyped string values are not permitted by the spec, so the below
+		// behavior is undefined.
+		{Typ[UntypedString], Typ[String], true},
+	} {
+		if got := ConvertibleTo(test.v, test.t); got != test.want {
+			t.Errorf("ConvertibleTo(%v, %v) = %t, want %t", test.v, test.t, got, test.want)
+		}
+	}
+}
+
+func TestAssignableTo(t *testing.T) {
+	for _, test := range []struct {
+		v, t Type
+		want bool
+	}{
+		{Typ[Int], Typ[Int], true},
+		{Typ[Int], Typ[Float32], false},
+		{newDefined(Typ[Int]), Typ[Int], false},
+		{newDefined(new(Struct)), new(Struct), true},
+		{Typ[UntypedBool], Typ[Bool], true},
+		{Typ[UntypedString], Typ[Bool], false},
+		// Neither untyped string nor untyped numeric assignments arise during
+		// normal type checking, so the below behavior is technically undefined by
+		// the spec.
+		{Typ[UntypedString], Typ[String], true},
+		{Typ[UntypedInt], Typ[Int], true},
+	} {
+		if got := AssignableTo(test.v, test.t); got != test.want {
+			t.Errorf("AssignableTo(%v, %v) = %t, want %t", test.v, test.t, got, test.want)
+		}
+	}
+}
+
 func TestIdentical_issue15173(t *testing.T) {
 	// Identical should allow nil arguments and be symmetric.
 	for _, test := range []struct {
diff --git a/src/cmd/compile/internal/types2/typestring_test.go b/src/cmd/compile/internal/types2/typestring_test.go
index 97a4fdf73d..d98e9a5ade 100644
--- a/src/cmd/compile/internal/types2/typestring_test.go
+++ b/src/cmd/compile/internal/types2/typestring_test.go
@@ -111,7 +111,7 @@ var dependentTestTypes = []testEntry{
 	// interfaces
 	dup(`interface{io.Reader; io.Writer}`),
 	dup(`interface{m() int; io.Writer}`),
-	{`interface{m() interface{T}}`, `interface{m() interface{p.T}}`},
+	{`interface{m() interface{T}}`, `interface{m() interface{generic_p.T}}`},
 }
 
 func TestTypeString(t *testing.T) {
@@ -122,7 +122,7 @@ func TestTypeString(t *testing.T) {
 	tests = append(tests, dependentTestTypes...)
 
 	for _, test := range tests {
-		src := `package p; import "io"; type _ io.Writer; type T ` + test.src
+		src := `package generic_p; import "io"; type _ io.Writer; type T ` + test.src
 		pkg, err := makePkg(src)
 		if err != nil {
 			t.Errorf("%s: %s", src, err)
-- 
GitLab


From 2c8692d45f80f902a243732dda95f6561b72a49a Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 23 Mar 2021 14:30:57 -0700
Subject: [PATCH 1242/2400] cmd/compile/internal/types2: review of
 example_test.go

The changes between (equivalent, and reviewed) go/types/example_test.go
and example_test.go can be seen by comparing patchset 1 and 2. The actual
changes are removing the "// UNREVIEWED" marker.

The primary differences to go/types/example_test.go are:
- use of syntax instead of go/ast package
- no ExampleMethodSet test (types2 doesn't have MethodSet)
- some code in ExampleInfo is disabled due to less precise
  position information provided by the syntax tree

Change-Id: I035284357acc8ecb7849022b5a9d873ae2235987
Reviewed-on: https://go-review.googlesource.com/c/go/+/304249
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/example_test.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/example_test.go b/src/cmd/compile/internal/types2/example_test.go
index 974acb82ef..714bf77821 100644
--- a/src/cmd/compile/internal/types2/example_test.go
+++ b/src/cmd/compile/internal/types2/example_test.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2015 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.
-- 
GitLab


From ada77d23ae001a8c3feac28a44dec0be578a1c48 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 23 Mar 2021 14:54:19 -0700
Subject: [PATCH 1243/2400] cmd/compile/internal/types2: review of examples
 test

The only changes between (equivalent, and reviewed) go/types/examples directory
are in examples/types.go2. The go/types/examples/types.go2 file should be updated
accordingly.

$ f=examples/types.go2; diff $f $HOME/goroot/src/go/types/$f
1d0
< // UNREVIEWED
109c108
< var _ (T /* ERROR cannot use generic type T */ )[ /* ERROR unexpected \[ */ int]
---
> var _ (T /* ERROR cannot use generic type T */ )[ /* ERROR expected ';' */ int]
147a147,154
> // We accept parenthesized embedded struct fields so we can distinguish between
> // a named field with a parenthesized type foo (T) and an embedded parameterized
> // type (foo(T)), similarly to interface embedding.
> // They still need to be valid embedded types after the parentheses are stripped
> // (i.e., in contrast to interfaces, we cannot embed a struct literal). The name
> // of the embedded field is derived as before, after stripping parentheses.
> // (7/14/2020: See comment above. We probably will revert this generalized ability
> // if we go with [] for type parameters.)
149,152c156,158
< 	( /* ERROR cannot parenthesize */ int8)
< 	( /* ERROR cannot parenthesize */ *int16)
< 	*( /* ERROR cannot parenthesize */ int32)
< 	List[int]
---
> 	int8
> 	*int16
> 	*List[int]
155,156c161
< 	* /* ERROR int16 redeclared */ int16
< 	List /* ERROR List redeclared */ [int]
---
> 	* /* ERROR List redeclared */ List[int]
280a286
>

The actual changes are removing the "// UNREVIEWED" markers.

Change-Id: I8a80fa11f3c84f9a403c690b537973a53e1adc2c
Reviewed-on: https://go-review.googlesource.com/c/go/+/304250
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/examples/functions.go2 | 1 -
 src/cmd/compile/internal/types2/examples/methods.go2   | 1 -
 src/cmd/compile/internal/types2/examples/types.go2     | 1 -
 3 files changed, 3 deletions(-)

diff --git a/src/cmd/compile/internal/types2/examples/functions.go2 b/src/cmd/compile/internal/types2/examples/functions.go2
index ab4c192c00..0c2a408f02 100644
--- a/src/cmd/compile/internal/types2/examples/functions.go2
+++ b/src/cmd/compile/internal/types2/examples/functions.go2
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2019 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.
diff --git a/src/cmd/compile/internal/types2/examples/methods.go2 b/src/cmd/compile/internal/types2/examples/methods.go2
index b34baef457..76c6539e1b 100644
--- a/src/cmd/compile/internal/types2/examples/methods.go2
+++ b/src/cmd/compile/internal/types2/examples/methods.go2
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2019 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.
diff --git a/src/cmd/compile/internal/types2/examples/types.go2 b/src/cmd/compile/internal/types2/examples/types.go2
index a081f61c01..a7825ed2d9 100644
--- a/src/cmd/compile/internal/types2/examples/types.go2
+++ b/src/cmd/compile/internal/types2/examples/types.go2
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2019 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.
-- 
GitLab


From 569c86d23b829726db1030d75dd49008c22a0ffd Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 23 Mar 2021 15:07:32 -0700
Subject: [PATCH 1244/2400] cmd/compile/internal/types2: review of
 importer_test.go

This is a small helper file that provides a default importer
for the type checker tests. There is no go/types equivalent.

The actual change is removing the "// UNREVIEWED" marker.

Change-Id: Ic1f9858bdd9b818d9ddad754e072d9d14d8fb9b3
Reviewed-on: https://go-review.googlesource.com/c/go/+/304252
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/importer_test.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/importer_test.go b/src/cmd/compile/internal/types2/importer_test.go
index 90476c4269..6b9b500918 100644
--- a/src/cmd/compile/internal/types2/importer_test.go
+++ b/src/cmd/compile/internal/types2/importer_test.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2020 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.
-- 
GitLab


From 7ce361737fad30a78e47f2d12bd797efcc056b1c Mon Sep 17 00:00:00 2001
From: Josh Rickmar <jrick@companyzero.com>
Date: Thu, 25 Mar 2021 14:37:48 +0000
Subject: [PATCH 1245/2400] net: only perform IPv4 map check for AF_INET6
 sockets

This change avoids executing syscalls testing if IPv4 address mapping
is possible unless the socket being opened belongs to the AF_INET6
family.

In a pledged OpenBSD process, this test is only allowed when the
"inet" pledge is granted; however this check was also being performed
for AF_UNIX sockets (separately permitted under the "unix" pledge),
and would cause the process to be killed by the kernel.  By avoiding
the IPv4 address mapping check until the socket is checked to be
AF_INET6, a pledged OpenBSD process using AF_UNIX sockets without the
"inet" pledge won't be killed for this misbehavior.

The OpenBSD kernel is not currently ready to support using UNIX domain
sockets with only the "unix" pledge (and without "inet"), but this is
one change necessary to support this.

Change-Id: If6962a7ad999b71bcfc9fd8e10d9c4067fa3f338
GitHub-Last-Rev: 3c5541b334fad54606a3d14dfe1b63b28b33a0d1
GitHub-Pull-Request: golang/go#45155
Reviewed-on: https://go-review.googlesource.com/c/go/+/303276
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Aaron Bieber <deftly@gmail.com>
Trust: Ian Lance Taylor <iant@golang.org>
---
 src/net/sockopt_bsd.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/net/sockopt_bsd.go b/src/net/sockopt_bsd.go
index 216e5d52f1..ee1f98b834 100644
--- a/src/net/sockopt_bsd.go
+++ b/src/net/sockopt_bsd.go
@@ -26,7 +26,7 @@ func setDefaultSockopts(s, family, sotype int, ipv6only bool) error {
 			syscall.SetsockoptInt(s, syscall.IPPROTO_IPV6, syscall.IPV6_PORTRANGE, syscall.IPV6_PORTRANGE_HIGH)
 		}
 	}
-	if supportsIPv4map() && family == syscall.AF_INET6 && sotype != syscall.SOCK_RAW {
+	if family == syscall.AF_INET6 && sotype != syscall.SOCK_RAW && supportsIPv4map() {
 		// Allow both IP versions even if the OS default
 		// is otherwise. Note that some operating systems
 		// never admit this option.
-- 
GitLab


From 5cec8b85e5dc75ef21b62efb6bd93f9007385e34 Mon Sep 17 00:00:00 2001
From: Damien Neil <dneil@google.com>
Date: Thu, 25 Mar 2021 11:11:03 -0700
Subject: [PATCH 1246/2400] net/http/httptest: wait for user ConnState hooks

Ensure that user ConnState callbacks have completed before returning
from (*httptest.Server).Close.

Fixes: #37510
Fixes: #37505
Fixes: #45237
Change-Id: I8fe7baa089fbe4f3836bf6ae9767c7b1270d1331
Reviewed-on: https://go-review.googlesource.com/c/go/+/304829
Trust: Damien Neil <dneil@google.com>
Run-TryBot: Damien Neil <dneil@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/net/http/httptest/server.go | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/net/http/httptest/server.go b/src/net/http/httptest/server.go
index 65165d9eb3..a02a6d64c3 100644
--- a/src/net/http/httptest/server.go
+++ b/src/net/http/httptest/server.go
@@ -316,6 +316,13 @@ func (s *Server) wrap() {
 	s.Config.ConnState = func(c net.Conn, cs http.ConnState) {
 		s.mu.Lock()
 		defer s.mu.Unlock()
+
+		// Keep Close from returning until the user's ConnState hook
+		// (if any) finishes. Without this, the call to forgetConn
+		// below might send the count to 0 before we run the hook.
+		s.wg.Add(1)
+		defer s.wg.Done()
+
 		switch cs {
 		case http.StateNew:
 			s.wg.Add(1)
-- 
GitLab


From 691db3737c989ba07ec4565c16628d35cb08418c Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Thu, 25 Mar 2021 20:48:27 +0100
Subject: [PATCH 1247/2400] cmd/cover: use golang.org/x/tools/cover directly

As suggested by Bryan in CL 249759, remove the forwarding aliases in
cmd/cover and use the symbols from golang.org/x/tools directly.

cmd/cover is not an importable package, so it is fine to remove these
exported symbols.

Change-Id: I887c5e9349f2dbe4c90be57f708412b844e18081
Reviewed-on: https://go-review.googlesource.com/c/go/+/304690
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/cover/func.go    |  8 +++++---
 src/cmd/cover/html.go    |  8 +++++---
 src/cmd/cover/profile.go | 30 ------------------------------
 3 files changed, 10 insertions(+), 36 deletions(-)
 delete mode 100644 src/cmd/cover/profile.go

diff --git a/src/cmd/cover/func.go b/src/cmd/cover/func.go
index ce7c771ac9..76a16b3fc4 100644
--- a/src/cmd/cover/func.go
+++ b/src/cmd/cover/func.go
@@ -23,6 +23,8 @@ import (
 	"runtime"
 	"strings"
 	"text/tabwriter"
+
+	"golang.org/x/tools/cover"
 )
 
 // funcOutput takes two file names as arguments, a coverage profile to read as input and an output
@@ -38,7 +40,7 @@ import (
 //	total:		(statements)			91.9%
 
 func funcOutput(profile, outputFile string) error {
-	profiles, err := ParseProfiles(profile)
+	profiles, err := cover.ParseProfiles(profile)
 	if err != nil {
 		return err
 	}
@@ -144,7 +146,7 @@ func (v *FuncVisitor) Visit(node ast.Node) ast.Visitor {
 }
 
 // coverage returns the fraction of the statements in the function that were covered, as a numerator and denominator.
-func (f *FuncExtent) coverage(profile *Profile) (num, den int64) {
+func (f *FuncExtent) coverage(profile *cover.Profile) (num, den int64) {
 	// We could avoid making this n^2 overall by doing a single scan and annotating the functions,
 	// but the sizes of the data structures is never very large and the scan is almost instantaneous.
 	var covered, total int64
@@ -175,7 +177,7 @@ type Pkg struct {
 	}
 }
 
-func findPkgs(profiles []*Profile) (map[string]*Pkg, error) {
+func findPkgs(profiles []*cover.Profile) (map[string]*Pkg, error) {
 	// Run go list to find the location of every package we care about.
 	pkgs := make(map[string]*Pkg)
 	var list []string
diff --git a/src/cmd/cover/html.go b/src/cmd/cover/html.go
index b2865c427c..3c1d17e7b9 100644
--- a/src/cmd/cover/html.go
+++ b/src/cmd/cover/html.go
@@ -15,13 +15,15 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+
+	"golang.org/x/tools/cover"
 )
 
 // htmlOutput reads the profile data from profile and generates an HTML
 // coverage report, writing it to outfile. If outfile is empty,
 // it writes the report to a temporary file and opens it in a web browser.
 func htmlOutput(profile, outfile string) error {
-	profiles, err := ParseProfiles(profile)
+	profiles, err := cover.ParseProfiles(profile)
 	if err != nil {
 		return err
 	}
@@ -92,7 +94,7 @@ func htmlOutput(profile, outfile string) error {
 // percentCovered returns, as a percentage, the fraction of the statements in
 // the profile covered by the test run.
 // In effect, it reports the coverage of a given source file.
-func percentCovered(p *Profile) float64 {
+func percentCovered(p *cover.Profile) float64 {
 	var total, covered int64
 	for _, b := range p.Blocks {
 		total += int64(b.NumStmt)
@@ -108,7 +110,7 @@ func percentCovered(p *Profile) float64 {
 
 // htmlGen generates an HTML coverage report with the provided filename,
 // source code, and tokens, and writes it to the given Writer.
-func htmlGen(w io.Writer, src []byte, boundaries []Boundary) error {
+func htmlGen(w io.Writer, src []byte, boundaries []cover.Boundary) error {
 	dst := bufio.NewWriter(w)
 	for i := range src {
 		for len(boundaries) > 0 && boundaries[0].Offset == i {
diff --git a/src/cmd/cover/profile.go b/src/cmd/cover/profile.go
deleted file mode 100644
index 839444edb7..0000000000
--- a/src/cmd/cover/profile.go
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright 2013 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.
-
-// This file provides support for parsing coverage profiles
-// generated by "go test -coverprofile=cover.out".
-// It is a alias of golang.org/x/tools/cover/profile.go.
-
-package main
-
-import (
-	"golang.org/x/tools/cover"
-)
-
-// Profile represents the profiling data for a specific file.
-type Profile = cover.Profile
-
-// ProfileBlock represents a single block of profiling data.
-type ProfileBlock = cover.ProfileBlock
-
-// ParseProfiles parses profile data in the specified file and returns a
-// Profile for each source file described therein.
-func ParseProfiles(fileName string) ([]*Profile, error) {
-	return cover.ParseProfiles(fileName)
-}
-
-// Boundary represents the position in a source file of the beginning or end of a
-// block as reported by the coverage profile. In HTML mode, it will correspond to
-// the opening or closing of a <span> tag and will be used to colorize the source
-type Boundary = cover.Boundary
-- 
GitLab


From 5834ce1dd770c848342ec357a8317a4eb2d88aca Mon Sep 17 00:00:00 2001
From: cui <cuiweixie@gmail.com>
Date: Sun, 10 Jan 2021 06:52:16 +0000
Subject: [PATCH 1248/2400] cmd/compile/internal/ssa: unnecessary loop break

Change-Id: I32860a36b4acf5412c20bac2e8ebbb3965b796fe
GitHub-Last-Rev: c0076390168b2425a1e2c30ea2e9ac32fb4c3365
GitHub-Pull-Request: golang/go#43617
Reviewed-on: https://go-review.googlesource.com/c/go/+/282832
Reviewed-by: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
Trust: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/likelyadjust.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/cmd/compile/internal/ssa/likelyadjust.go b/src/cmd/compile/internal/ssa/likelyadjust.go
index 49898a1322..f462bf29a6 100644
--- a/src/cmd/compile/internal/ssa/likelyadjust.go
+++ b/src/cmd/compile/internal/ssa/likelyadjust.go
@@ -222,6 +222,7 @@ func likelyadjust(f *Func) {
 				if opcodeTable[v.Op].call {
 					local[b.ID] = blCALL
 					certain[b.ID] = max8(blCALL, certain[b.Succs[0].b.ID])
+					break
 				}
 			}
 		}
-- 
GitLab


From 11b4aee05bfe83513cf08f83091e5aef8b33e766 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Fri, 28 Jun 2019 09:30:36 -0400
Subject: [PATCH 1249/2400] cmd/compile: mark R16, R17 clobbered for
 non-standard calls on ARM64

On ARM64, (external) linker generated trampoline may clobber R16
and R17. In CL 183842 we change Duff's devices not to use those
registers. However, this is not enough. The register allocator
also needs to know that these registers may be clobbered in any
calls that don't follow the standard Go calling convention. This
include Duff's devices and the write barrier.

Fixes #32773, second attempt.

Change-Id: Ia52a891d9bbb8515c927617dd53aee5af5bd9aa4
Reviewed-on: https://go-review.googlesource.com/c/go/+/184437
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Meng Zhuo <mzh@golangcn.org>
Reviewed-by: Keith Randall <khr@golang.org>
Trust: Meng Zhuo <mzh@golangcn.org>
---
 src/cmd/compile/internal/ssa/gen/ARM64Ops.go |  9 ++--
 src/cmd/compile/internal/ssa/opGen.go        |  6 +--
 src/runtime/asm_arm64.s                      | 47 +++++++++-----------
 3 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/gen/ARM64Ops.go b/src/cmd/compile/internal/ssa/gen/ARM64Ops.go
index 148843cd8d..65e54202bf 100644
--- a/src/cmd/compile/internal/ssa/gen/ARM64Ops.go
+++ b/src/cmd/compile/internal/ssa/gen/ARM64Ops.go
@@ -512,13 +512,14 @@ func init() {
 		// auxint = offset into duffzero code to start executing
 		// returns mem
 		// R20 changed as side effect
+		// R16 and R17 may be clobbered by linker trampoline.
 		{
 			name:      "DUFFZERO",
 			aux:       "Int64",
 			argLength: 2,
 			reg: regInfo{
 				inputs:   []regMask{buildReg("R20")},
-				clobbers: buildReg("R20 R30"),
+				clobbers: buildReg("R16 R17 R20 R30"),
 			},
 			faultOnNilArg0: true,
 			unsafePoint:    true, // FP maintenance around DUFFZERO can be clobbered by interrupts
@@ -552,13 +553,14 @@ func init() {
 		// auxint = offset into duffcopy code to start executing
 		// returns mem
 		// R20, R21 changed as side effect
+		// R16 and R17 may be clobbered by linker trampoline.
 		{
 			name:      "DUFFCOPY",
 			aux:       "Int64",
 			argLength: 3,
 			reg: regInfo{
 				inputs:   []regMask{buildReg("R21"), buildReg("R20")},
-				clobbers: buildReg("R20 R21 R26 R30"),
+				clobbers: buildReg("R16 R17 R20 R21 R26 R30"),
 			},
 			faultOnNilArg0: true,
 			faultOnNilArg1: true,
@@ -717,7 +719,8 @@ func init() {
 		// LoweredWB invokes runtime.gcWriteBarrier. arg0=destptr, arg1=srcptr, arg2=mem, aux=runtime.gcWriteBarrier
 		// It saves all GP registers if necessary,
 		// but clobbers R30 (LR) because it's a call.
-		{name: "LoweredWB", argLength: 3, reg: regInfo{inputs: []regMask{buildReg("R2"), buildReg("R3")}, clobbers: (callerSave &^ gpg) | buildReg("R30")}, clobberFlags: true, aux: "Sym", symEffect: "None"},
+		// R16 and R17 may be clobbered by linker trampoline.
+		{name: "LoweredWB", argLength: 3, reg: regInfo{inputs: []regMask{buildReg("R2"), buildReg("R3")}, clobbers: (callerSave &^ gpg) | buildReg("R16 R17 R30")}, clobberFlags: true, aux: "Sym", symEffect: "None"},
 
 		// There are three of these functions so that they can have three different register inputs.
 		// When we check 0 <= c <= cap (A), then 0 <= b <= c (B), then 0 <= a <= b (C), we want the
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index 3f84a09289..8c753ea2a3 100644
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -21066,7 +21066,7 @@ var opcodeTable = [...]opInfo{
 			inputs: []inputInfo{
 				{0, 1048576}, // R20
 			},
-			clobbers: 537919488, // R20 R30
+			clobbers: 538116096, // R16 R17 R20 R30
 		},
 	},
 	{
@@ -21094,7 +21094,7 @@ var opcodeTable = [...]opInfo{
 				{0, 2097152}, // R21
 				{1, 1048576}, // R20
 			},
-			clobbers: 607125504, // R20 R21 R26 R30
+			clobbers: 607322112, // R16 R17 R20 R21 R26 R30
 		},
 	},
 	{
@@ -21591,7 +21591,7 @@ var opcodeTable = [...]opInfo{
 				{0, 4}, // R2
 				{1, 8}, // R3
 			},
-			clobbers: 9223372035244163072, // R30 F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
+			clobbers: 9223372035244359680, // R16 R17 R30 F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
 		},
 	},
 	{
diff --git a/src/runtime/asm_arm64.s b/src/runtime/asm_arm64.s
index 3709f1d95e..2e120dcf1e 100644
--- a/src/runtime/asm_arm64.s
+++ b/src/runtime/asm_arm64.s
@@ -1158,10 +1158,10 @@ TEXT ·checkASM(SB),NOSPLIT,$0-1
 // It does not clobber any general-purpose registers,
 // but may clobber others (e.g., floating point registers)
 // The act of CALLing gcWriteBarrier will clobber R30 (LR).
-TEXT runtime·gcWriteBarrier(SB),NOSPLIT,$216
+TEXT runtime·gcWriteBarrier(SB),NOSPLIT,$200
 	// Save the registers clobbered by the fast path.
-	MOVD	R0, 200(RSP)
-	MOVD	R1, 208(RSP)
+	MOVD	R0, 184(RSP)
+	MOVD	R1, 192(RSP)
 	MOVD	g_m(g), R0
 	MOVD	m_p(R0), R0
 	MOVD	(p_wbBuf+wbBuf_next)(R0), R1
@@ -1177,8 +1177,8 @@ TEXT runtime·gcWriteBarrier(SB),NOSPLIT,$216
 	// Is the buffer full? (flags set in CMP above)
 	BEQ	flush
 ret:
-	MOVD	200(RSP), R0
-	MOVD	208(RSP), R1
+	MOVD	184(RSP), R0
+	MOVD	192(RSP), R1
 	// Do the write.
 	MOVD	R3, (R2)
 	RET
@@ -1202,17 +1202,16 @@ flush:
 	MOVD	R13, 96(RSP)
 	MOVD	R14, 104(RSP)
 	MOVD	R15, 112(RSP)
-	MOVD	R16, 120(RSP)
-	MOVD	R17, 128(RSP)
+	// R16, R17 may be clobbered by linker trampoline
 	// R18 is unused.
-	MOVD	R19, 136(RSP)
-	MOVD	R20, 144(RSP)
-	MOVD	R21, 152(RSP)
-	MOVD	R22, 160(RSP)
-	MOVD	R23, 168(RSP)
-	MOVD	R24, 176(RSP)
-	MOVD	R25, 184(RSP)
-	MOVD	R26, 192(RSP)
+	MOVD	R19, 120(RSP)
+	MOVD	R20, 128(RSP)
+	MOVD	R21, 136(RSP)
+	MOVD	R22, 144(RSP)
+	MOVD	R23, 152(RSP)
+	MOVD	R24, 160(RSP)
+	MOVD	R25, 168(RSP)
+	MOVD	R26, 176(RSP)
 	// R27 is temp register.
 	// R28 is g.
 	// R29 is frame pointer (unused).
@@ -1236,16 +1235,14 @@ flush:
 	MOVD	96(RSP), R13
 	MOVD	104(RSP), R14
 	MOVD	112(RSP), R15
-	MOVD	120(RSP), R16
-	MOVD	128(RSP), R17
-	MOVD	136(RSP), R19
-	MOVD	144(RSP), R20
-	MOVD	152(RSP), R21
-	MOVD	160(RSP), R22
-	MOVD	168(RSP), R23
-	MOVD	176(RSP), R24
-	MOVD	184(RSP), R25
-	MOVD	192(RSP), R26
+	MOVD	120(RSP), R19
+	MOVD	128(RSP), R20
+	MOVD	136(RSP), R21
+	MOVD	144(RSP), R22
+	MOVD	152(RSP), R23
+	MOVD	160(RSP), R24
+	MOVD	168(RSP), R25
+	MOVD	176(RSP), R26
 	JMP	ret
 
 // Note: these functions use a special calling convention to save generated code space.
-- 
GitLab


From 374b1904750931ed09d342e3c4c6e01fdb2802aa Mon Sep 17 00:00:00 2001
From: Michel Levieux <mlevieux42@gmail.com>
Date: Thu, 18 Feb 2021 15:53:46 +0100
Subject: [PATCH 1250/2400] io/fs: implement FileInfoToDirEntry

Implements FileInfoToDirEntry which converts an fs.FileInfo to fs.DirEntry.

Fixes #42387.

Change-Id: Ie723b6ed583c6c5ecf22bbe64e3b6496f5114254
Reviewed-on: https://go-review.googlesource.com/c/go/+/293649
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/io/fs/readdir.go      | 30 +++++++++++++++++++++++
 src/io/fs/readdir_test.go | 50 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 80 insertions(+)

diff --git a/src/io/fs/readdir.go b/src/io/fs/readdir.go
index 3a5aa6d86a..2b10ddb0a3 100644
--- a/src/io/fs/readdir.go
+++ b/src/io/fs/readdir.go
@@ -45,3 +45,33 @@ func ReadDir(fsys FS, name string) ([]DirEntry, error) {
 	sort.Slice(list, func(i, j int) bool { return list[i].Name() < list[j].Name() })
 	return list, err
 }
+
+// dirInfo is a DirEntry based on a FileInfo.
+type dirInfo struct {
+	fileInfo FileInfo
+}
+
+func (di dirInfo) IsDir() bool {
+	return di.fileInfo.IsDir()
+}
+
+func (di dirInfo) Type() FileMode {
+	return di.fileInfo.Mode().Type()
+}
+
+func (di dirInfo) Info() (FileInfo, error) {
+	return di.fileInfo, nil
+}
+
+func (di dirInfo) Name() string {
+	return di.fileInfo.Name()
+}
+
+// FileInfoToDirEntry returns a DirEntry that returns information from info.
+// If info is nil, FileInfoToDirEntry returns nil.
+func FileInfoToDirEntry(info FileInfo) DirEntry {
+	if info == nil {
+		return nil
+	}
+	return dirInfo{fileInfo: info}
+}
diff --git a/src/io/fs/readdir_test.go b/src/io/fs/readdir_test.go
index 405bfa67ca..a2b2c121ff 100644
--- a/src/io/fs/readdir_test.go
+++ b/src/io/fs/readdir_test.go
@@ -6,7 +6,10 @@ package fs_test
 
 import (
 	. "io/fs"
+	"os"
 	"testing"
+	"testing/fstest"
+	"time"
 )
 
 type readDirOnly struct{ ReadDirFS }
@@ -41,3 +44,50 @@ func TestReadDir(t *testing.T) {
 	dirs, err = ReadDir(sub, ".")
 	check("sub(.)", dirs, err)
 }
+
+func TestFileInfoToDirEntry(t *testing.T) {
+	testFs := fstest.MapFS{
+		"notadir.txt": {
+			Data:    []byte("hello, world"),
+			Mode:    0,
+			ModTime: time.Now(),
+			Sys:     &sysValue,
+		},
+		"adir": {
+			Data:    nil,
+			Mode:    os.ModeDir,
+			ModTime: time.Now(),
+			Sys:     &sysValue,
+		},
+	}
+
+	tests := []struct {
+		path     string
+		wantMode FileMode
+		wantDir  bool
+	}{
+		{path: "notadir.txt", wantMode: 0, wantDir: false},
+		{path: "adir", wantMode: os.ModeDir, wantDir: true},
+	}
+
+	for _, test := range tests {
+		test := test
+		t.Run(test.path, func(t *testing.T) {
+			fi, err := Stat(testFs, test.path)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			dirEntry := FileInfoToDirEntry(fi)
+			if g, w := dirEntry.Type(), test.wantMode; g != w {
+				t.Errorf("FileMode mismatch: got=%v, want=%v", g, w)
+			}
+			if g, w := dirEntry.Name(), test.path; g != w {
+				t.Errorf("Name mismatch: got=%v, want=%v", g, w)
+			}
+			if g, w := dirEntry.IsDir(), test.wantDir; g != w {
+				t.Errorf("IsDir mismatch: got=%v, want=%v", g, w)
+			}
+		})
+	}
+}
-- 
GitLab


From b587b050ca55661120912b5a1d6071a1922ad0ea Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Wed, 24 Mar 2021 14:50:02 -0700
Subject: [PATCH 1251/2400] cmd/compile: add transform functions for OXDOT and
 builtins

Pull out the tranformation part of the typechecking functions for:
 - selector expressions (OXDOT)
 - calls to builtin functions (which go through the typechecker loop
   twice, once for the call and once for each different kind of
   builtin).

Some of the transformation functions create new nodes that should have
the same type as the original node. For consistency, now each of the
transformation functions requires that the node passed in has its type
and typecheck flag set. If the transformation function replaces or adds
new nodes, it will set the type and typecheck flag for those new nodes.

As usual, passes all the gotests, even with -G=3 enabled.

Change-Id: Ic48b0ce5f58425f4a358afa78315bfc7c28066c4
Reviewed-on: https://go-review.googlesource.com/c/go/+/304729
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/helpers.go     |  25 +-
 src/cmd/compile/internal/noder/stencil.go     |  41 ++-
 src/cmd/compile/internal/noder/transform.go   | 293 +++++++++++++++++-
 src/cmd/compile/internal/typecheck/expr.go    |  10 +-
 .../compile/internal/typecheck/typecheck.go   |  24 +-
 5 files changed, 342 insertions(+), 51 deletions(-)

diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
index 82428daa4a..9ebf17aae6 100644
--- a/src/cmd/compile/internal/noder/helpers.go
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -81,8 +81,8 @@ func Binary(pos src.XPos, op ir.Op, typ *types.Type, x, y ir.Node) ir.Node {
 			n.SetTypecheck(3)
 			return n
 		}
-		n1 := transformAdd(n)
-		return typed(typ, n1)
+		typed(typ, n)
+		return transformAdd(n)
 	default:
 		return typed(x.Type(), ir.NewBinaryExpr(pos, op, x, y))
 	}
@@ -99,9 +99,8 @@ func Call(pos src.XPos, typ *types.Type, fun ir.Node, args []ir.Node, dots bool)
 			// the type.
 			return typed(typ, n)
 		}
-		n1 := transformConvCall(n)
-		n1.SetTypecheck(1)
-		return n1
+		typed(typ, n)
+		return transformConvCall(n)
 	}
 
 	if fun, ok := fun.(*ir.Name); ok && fun.BuiltinOp != 0 {
@@ -133,12 +132,8 @@ func Call(pos src.XPos, typ *types.Type, fun ir.Node, args []ir.Node, dots bool)
 			}
 		}
 
-		switch fun.BuiltinOp {
-		case ir.OCLOSE, ir.ODELETE, ir.OPANIC, ir.OPRINT, ir.OPRINTN:
-			return typecheck.Stmt(n)
-		default:
-			return typecheck.Expr(n)
-		}
+		typed(typ, n)
+		return transformBuiltin(n)
 	}
 
 	// Add information, now that we know that fun is actually being called.
@@ -176,8 +171,8 @@ func Call(pos src.XPos, typ *types.Type, fun ir.Node, args []ir.Node, dots bool)
 	if fun.Op() != ir.OFUNCINST {
 		// If no type params, do the normal call transformations. This
 		// will convert OCALL to OCALLFUNC.
-		transformCall(n)
 		typed(typ, n)
+		transformCall(n)
 		return n
 	}
 
@@ -195,8 +190,9 @@ func Compare(pos src.XPos, typ *types.Type, op ir.Op, x, y ir.Node) ir.Node {
 		n.SetTypecheck(3)
 		return n
 	}
+	typed(typ, n)
 	transformCompare(n)
-	return typed(typ, n)
+	return n
 }
 
 func Deref(pos src.XPos, x ir.Node) *ir.StarExpr {
@@ -291,8 +287,9 @@ func Slice(pos src.XPos, typ *types.Type, x, low, high, max ir.Node) ir.Node {
 		n.SetTypecheck(3)
 		return n
 	}
+	typed(typ, n)
 	transformSlice(n)
-	return typed(typ, n)
+	return n
 }
 
 func Unary(pos src.XPos, op ir.Op, x ir.Node) ir.Node {
diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index ba01f0424b..45864763d4 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -369,12 +369,12 @@ func (subst *subster) node(n ir.Node) ir.Node {
 		if x.Typecheck() == 3 {
 			// These are nodes whose transforms were delayed until
 			// their instantiated type was known.
+			m.SetTypecheck(1)
 			if typecheck.IsCmp(x.Op()) {
 				transformCompare(m.(*ir.BinaryExpr))
 			} else {
 				switch x.Op() {
-				case ir.OSLICE:
-				case ir.OSLICE3:
+				case ir.OSLICE, ir.OSLICE3:
 					transformSlice(m.(*ir.SliceExpr))
 
 				case ir.OADD:
@@ -400,7 +400,6 @@ func (subst *subster) node(n ir.Node) ir.Node {
 					base.Fatalf("Unexpected node with Typecheck() == 3")
 				}
 			}
-			m.SetTypecheck(1)
 		}
 
 		switch x.Op() {
@@ -421,15 +420,18 @@ func (subst *subster) node(n ir.Node) ir.Node {
 			}
 
 		case ir.OXDOT:
-			// A method value/call via a type param will have been left as an
-			// OXDOT. When we see this during stenciling, finish the
-			// typechecking, now that we have the instantiated receiver type.
-			// We need to do this now, since the access/selection to the
-			// method for the real type is very different from the selection
-			// for the type param.
-			m.SetTypecheck(0)
-			// m will transform to an OCALLPART
-			typecheck.Expr(m)
+			// A method value/call via a type param will have been
+			// left as an OXDOT. When we see this during stenciling,
+			// finish the transformation, now that we have the
+			// instantiated receiver type. We need to do this now,
+			// since the access/selection to the method for the real
+			// type is very different from the selection for the type
+			// param. m will be transformed to an OCALLPART node. It
+			// will be transformed to an ODOTMETH or ODOTINTER node if
+			// we find in the OCALL case below that the method value
+			// is actually called.
+			transformDot(m.(*ir.SelectorExpr), false)
+			m.SetTypecheck(1)
 
 		case ir.OCALL:
 			call := m.(*ir.CallExpr)
@@ -437,15 +439,12 @@ func (subst *subster) node(n ir.Node) ir.Node {
 				// Transform the conversion, now that we know the
 				// type argument.
 				m = transformConvCall(m.(*ir.CallExpr))
-				m.SetTypecheck(1)
 			} else if call.X.Op() == ir.OCALLPART {
-				// Redo the typechecking of OXDOT, now that we
+				// Redo the transformation of OXDOT, now that we
 				// know the method value is being called. Then
 				// transform the call.
 				call.X.(*ir.SelectorExpr).SetOp(ir.OXDOT)
-				call.X.SetTypecheck(0)
-				call.X.SetType(nil)
-				typecheck.Callee(call.X)
+				transformDot(call.X.(*ir.SelectorExpr), true)
 				transformCall(call)
 			} else if call.X.Op() == ir.ODOT || call.X.Op() == ir.ODOTPTR {
 				// An OXDOT for a generic receiver was resolved to
@@ -456,11 +455,9 @@ func (subst *subster) node(n ir.Node) ir.Node {
 			} else if name := call.X.Name(); name != nil {
 				switch name.BuiltinOp {
 				case ir.OMAKE, ir.OREAL, ir.OIMAG, ir.OLEN, ir.OCAP, ir.OAPPEND:
-					// Call old typechecker (to do any
-					// transformations) now that we know the
-					// type of the args.
-					m.SetTypecheck(0)
-					m = typecheck.Expr(m)
+					// Transform these builtins now that we
+					// know the type of the args.
+					m = transformBuiltin(call)
 				default:
 					base.FatalfAt(call.Pos(), "Unexpected builtin op")
 				}
diff --git a/src/cmd/compile/internal/noder/transform.go b/src/cmd/compile/internal/noder/transform.go
index e90d374d0f..489a535231 100644
--- a/src/cmd/compile/internal/noder/transform.go
+++ b/src/cmd/compile/internal/noder/transform.go
@@ -11,6 +11,10 @@
 //    - Setting the actual type of existing nodes (already done based on
 //      type info from types2)
 //    - Dealing with untyped constants (which types2 has already resolved)
+//
+// Each of the transformation functions requires that node passed in has its type
+// and typecheck flag set. If the transformation function replaces or adds new
+// nodes, it will set the type and typecheck flag for those new nodes.
 
 package noder
 
@@ -19,6 +23,7 @@ import (
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
+	"fmt"
 	"go/constant"
 )
 
@@ -27,6 +32,7 @@ import (
 // transformAdd transforms an addition operation (currently just addition of
 // strings). Corresponds to the "binary operators" case in typecheck.typecheck1.
 func transformAdd(n *ir.BinaryExpr) ir.Node {
+	assert(n.Type() != nil && n.Typecheck() == 1)
 	l := n.X
 	if l.Type().IsString() {
 		var add *ir.AddStringExpr
@@ -43,7 +49,7 @@ func transformAdd(n *ir.BinaryExpr) ir.Node {
 		} else {
 			add.List.Append(r)
 		}
-		add.SetType(l.Type())
+		typed(l.Type(), add)
 		return add
 	}
 	return n
@@ -74,7 +80,6 @@ func stringtoruneslit(n *ir.ConvExpr) ir.Node {
 func transformConv(n *ir.ConvExpr) ir.Node {
 	t := n.X.Type()
 	op, _ := typecheck.Convertop(n.X.Op() == ir.OLITERAL, t, n.Type())
-	assert(op != ir.OXXX)
 	n.SetOp(op)
 	switch n.Op() {
 	case ir.OCONVNOP:
@@ -103,15 +108,18 @@ func transformConv(n *ir.ConvExpr) ir.Node {
 // transformConvCall transforms a conversion call. Corresponds to the OTYPE part of
 // typecheck.tcCall.
 func transformConvCall(n *ir.CallExpr) ir.Node {
+	assert(n.Type() != nil && n.Typecheck() == 1)
 	arg := n.Args[0]
 	n1 := ir.NewConvExpr(n.Pos(), ir.OCONV, nil, arg)
-	n1.SetType(n.X.Type())
+	typed(n.X.Type(), n1)
 	return transformConv(n1)
 }
 
 // transformCall transforms a normal function/method call. Corresponds to last half
 // (non-conversion, non-builtin part) of typecheck.tcCall.
 func transformCall(n *ir.CallExpr) {
+	// n.Type() can be nil for calls with no return value
+	assert(n.Typecheck() == 1)
 	transformArgs(n)
 	l := n.X
 	t := l.Type()
@@ -160,6 +168,7 @@ func transformCall(n *ir.CallExpr) {
 // equals). Corresponds to the "comparison operators" case in
 // typecheck.typecheck1, including tcArith.
 func transformCompare(n *ir.BinaryExpr) {
+	assert(n.Type() != nil && n.Typecheck() == 1)
 	if (n.Op() == ir.OEQ || n.Op() == ir.ONE) && !types.Identical(n.X.Type(), n.Y.Type()) {
 		// Comparison is okay as long as one side is assignable to the
 		// other. The only allowed case where the conversion is not CONVNOP is
@@ -214,6 +223,7 @@ func implicitstar(n ir.Node) ir.Node {
 
 // transformIndex transforms an index operation.  Corresponds to typecheck.tcIndex.
 func transformIndex(n *ir.IndexExpr) {
+	assert(n.Type() != nil && n.Typecheck() == 1)
 	n.X = implicitstar(n.X)
 	l := n.X
 	t := l.Type()
@@ -230,6 +240,7 @@ func transformIndex(n *ir.IndexExpr) {
 
 // transformSlice transforms a slice operation.  Corresponds to typecheck.tcSlice.
 func transformSlice(n *ir.SliceExpr) {
+	assert(n.Type() != nil && n.Typecheck() == 1)
 	l := n.X
 	if l.Type().IsArray() {
 		addr := typecheck.NodAddr(n.X)
@@ -521,3 +532,279 @@ func transformSelect(sel *ir.SelectStmt) {
 func transformAsOp(n *ir.AssignOpStmt) {
 	transformCheckAssign(n, n.X)
 }
+
+// transformDot transforms an OXDOT (or ODOT) or ODOT, ODOTPTR, ODOTMETH,
+// ODOTINTER, or OCALLPART, as appropriate. It adds in extra nodes as needed to
+// access embedded fields. Corresponds to typecheck.tcDot.
+func transformDot(n *ir.SelectorExpr, isCall bool) ir.Node {
+	assert(n.Type() != nil && n.Typecheck() == 1)
+	if n.Op() == ir.OXDOT {
+		n = typecheck.AddImplicitDots(n)
+		n.SetOp(ir.ODOT)
+	}
+
+	t := n.X.Type()
+
+	if n.X.Op() == ir.OTYPE {
+		return transformMethodExpr(n)
+	}
+
+	if t.IsPtr() && !t.Elem().IsInterface() {
+		t = t.Elem()
+		n.SetOp(ir.ODOTPTR)
+	}
+
+	f := typecheck.Lookdot(n, t, 0)
+	assert(f != nil)
+
+	if (n.Op() == ir.ODOTINTER || n.Op() == ir.ODOTMETH) && !isCall {
+		n.SetOp(ir.OCALLPART)
+		n.SetType(typecheck.MethodValueWrapper(n).Type())
+	}
+	return n
+}
+
+// Corresponds to typecheck.typecheckMethodExpr.
+func transformMethodExpr(n *ir.SelectorExpr) (res ir.Node) {
+	t := n.X.Type()
+
+	// Compute the method set for t.
+	var ms *types.Fields
+	if t.IsInterface() {
+		ms = t.Fields()
+	} else {
+		mt := types.ReceiverBaseType(t)
+		typecheck.CalcMethods(mt)
+		ms = mt.AllMethods()
+
+		// The method expression T.m requires a wrapper when T
+		// is different from m's declared receiver type. We
+		// normally generate these wrappers while writing out
+		// runtime type descriptors, which is always done for
+		// types declared at package scope. However, we need
+		// to make sure to generate wrappers for anonymous
+		// receiver types too.
+		if mt.Sym() == nil {
+			typecheck.NeedRuntimeType(t)
+		}
+	}
+
+	s := n.Sel
+	m := typecheck.Lookdot1(n, s, t, ms, 0)
+	assert(m != nil)
+
+	n.SetOp(ir.OMETHEXPR)
+	n.Selection = m
+	n.SetType(typecheck.NewMethodType(m.Type, n.X.Type()))
+	return n
+}
+
+// Corresponds to typecheck.tcAppend.
+func transformAppend(n *ir.CallExpr) ir.Node {
+	transformArgs(n)
+	args := n.Args
+	t := args[0].Type()
+	assert(t.IsSlice())
+
+	if n.IsDDD {
+		if t.Elem().IsKind(types.TUINT8) && args[1].Type().IsString() {
+			return n
+		}
+
+		args[1] = assignconvfn(args[1], t.Underlying())
+		return n
+	}
+
+	as := args[1:]
+	for i, n := range as {
+		assert(n.Type() != nil)
+		as[i] = assignconvfn(n, t.Elem())
+	}
+	return n
+}
+
+// Corresponds to typecheck.tcComplex.
+func transformComplex(n *ir.BinaryExpr) ir.Node {
+	l := n.X
+	r := n.Y
+
+	assert(types.Identical(l.Type(), r.Type()))
+
+	var t *types.Type
+	switch l.Type().Kind() {
+	case types.TFLOAT32:
+		t = types.Types[types.TCOMPLEX64]
+	case types.TFLOAT64:
+		t = types.Types[types.TCOMPLEX128]
+	default:
+		panic(fmt.Sprintf("transformComplex: unexpected type %v", l.Type()))
+	}
+
+	// Must set the type here for generics, because this can't be determined
+	// by substitution of the generic types.
+	typed(t, n)
+	return n
+}
+
+// Corresponds to typecheck.tcDelete.
+func transformDelete(n *ir.CallExpr) ir.Node {
+	transformArgs(n)
+	args := n.Args
+	assert(len(args) == 2)
+
+	l := args[0]
+	r := args[1]
+
+	args[1] = assignconvfn(r, l.Type().Key())
+	return n
+}
+
+// Corresponds to typecheck.tcMake.
+func transformMake(n *ir.CallExpr) ir.Node {
+	args := n.Args
+
+	n.Args = nil
+	l := args[0]
+	t := l.Type()
+	assert(t != nil)
+
+	i := 1
+	var nn ir.Node
+	switch t.Kind() {
+	case types.TSLICE:
+		l = args[i]
+		i++
+		var r ir.Node
+		if i < len(args) {
+			r = args[i]
+			i++
+		}
+		nn = ir.NewMakeExpr(n.Pos(), ir.OMAKESLICE, l, r)
+
+	case types.TMAP:
+		if i < len(args) {
+			l = args[i]
+			i++
+		} else {
+			l = ir.NewInt(0)
+		}
+		nn = ir.NewMakeExpr(n.Pos(), ir.OMAKEMAP, l, nil)
+		nn.SetEsc(n.Esc())
+
+	case types.TCHAN:
+		l = nil
+		if i < len(args) {
+			l = args[i]
+			i++
+		} else {
+			l = ir.NewInt(0)
+		}
+		nn = ir.NewMakeExpr(n.Pos(), ir.OMAKECHAN, l, nil)
+	default:
+		panic(fmt.Sprintf("transformMake: unexpected type %v", t))
+	}
+
+	assert(i == len(args))
+	typed(n.Type(), nn)
+	return nn
+}
+
+// Corresponds to typecheck.tcPanic.
+func transformPanic(n *ir.UnaryExpr) ir.Node {
+	n.X = assignconvfn(n.X, types.Types[types.TINTER])
+	return n
+}
+
+// Corresponds to typecheck.tcPrint.
+func transformPrint(n *ir.CallExpr) ir.Node {
+	transformArgs(n)
+	return n
+}
+
+// Corresponds to typecheck.tcRealImag.
+func transformRealImag(n *ir.UnaryExpr) ir.Node {
+	l := n.X
+	var t *types.Type
+
+	// Determine result type.
+	switch l.Type().Kind() {
+	case types.TCOMPLEX64:
+		t = types.Types[types.TFLOAT32]
+	case types.TCOMPLEX128:
+		t = types.Types[types.TFLOAT64]
+	default:
+		panic(fmt.Sprintf("transformRealImag: unexpected type %v", l.Type()))
+	}
+
+	// Must set the type here for generics, because this can't be determined
+	// by substitution of the generic types.
+	typed(t, n)
+	return n
+}
+
+// Corresponds to typecheck.tcLenCap.
+func transformLenCap(n *ir.UnaryExpr) ir.Node {
+	n.X = implicitstar(n.X)
+	return n
+}
+
+// Corresponds to Builtin part of tcCall.
+func transformBuiltin(n *ir.CallExpr) ir.Node {
+	// n.Type() can be nil for builtins with no return value
+	assert(n.Typecheck() == 1)
+	fun := n.X.(*ir.Name)
+	op := fun.BuiltinOp
+
+	switch op {
+	case ir.OAPPEND, ir.ODELETE, ir.OMAKE, ir.OPRINT, ir.OPRINTN, ir.ORECOVER:
+		n.SetOp(op)
+		n.X = nil
+		switch op {
+		case ir.OAPPEND:
+			return transformAppend(n)
+		case ir.ODELETE:
+			return transformDelete(n)
+		case ir.OMAKE:
+			return transformMake(n)
+		case ir.OPRINT, ir.OPRINTN:
+			return transformPrint(n)
+		case ir.ORECOVER:
+			// nothing more to do
+			return n
+		}
+
+	case ir.OCAP, ir.OCLOSE, ir.OIMAG, ir.OLEN, ir.OPANIC, ir.OREAL:
+		transformArgs(n)
+		fallthrough
+
+	case ir.ONEW, ir.OALIGNOF, ir.OOFFSETOF, ir.OSIZEOF:
+		u := ir.NewUnaryExpr(n.Pos(), op, n.Args[0])
+		u1 := typed(n.Type(), ir.InitExpr(n.Init(), u)) // typecheckargs can add to old.Init
+		switch op {
+		case ir.OCAP, ir.OLEN:
+			return transformLenCap(u1.(*ir.UnaryExpr))
+		case ir.OREAL, ir.OIMAG:
+			return transformRealImag(u1.(*ir.UnaryExpr))
+		case ir.OPANIC:
+			return transformPanic(u1.(*ir.UnaryExpr))
+		case ir.OCLOSE, ir.ONEW, ir.OALIGNOF, ir.OOFFSETOF, ir.OSIZEOF:
+			// nothing more to do
+			return u1
+		}
+
+	case ir.OCOMPLEX, ir.OCOPY:
+		transformArgs(n)
+		b := ir.NewBinaryExpr(n.Pos(), op, n.Args[0], n.Args[1])
+		n1 := typed(n.Type(), ir.InitExpr(n.Init(), b))
+		if op == ir.OCOPY {
+			// nothing more to do
+			return n1
+		}
+		return transformComplex(n1.(*ir.BinaryExpr))
+
+	default:
+		panic(fmt.Sprintf("transformBuiltin: unexpected op %v", op))
+	}
+
+	return n
+}
diff --git a/src/cmd/compile/internal/typecheck/expr.go b/src/cmd/compile/internal/typecheck/expr.go
index 7ab1670a45..24d141e8a2 100644
--- a/src/cmd/compile/internal/typecheck/expr.go
+++ b/src/cmd/compile/internal/typecheck/expr.go
@@ -366,9 +366,9 @@ func tcCompLit(n *ir.CompLitExpr) (res ir.Node) {
 				}
 				l := l.(*ir.StructKeyExpr)
 
-				f := lookdot1(nil, l.Field, t, t.Fields(), 0)
+				f := Lookdot1(nil, l.Field, t, t.Fields(), 0)
 				if f == nil {
-					if ci := lookdot1(nil, l.Field, t, t.Fields(), 2); ci != nil { // Case-insensitive lookup.
+					if ci := Lookdot1(nil, l.Field, t, t.Fields(), 2); ci != nil { // Case-insensitive lookup.
 						if visible(ci.Sym) {
 							base.Errorf("unknown field '%v' in struct literal of type %v (but does have %v)", l.Field, t, ci.Sym)
 						} else if nonexported(l.Field) && l.Field.Name == ci.Sym.Name { // Ensure exactness before the suggestion.
@@ -496,7 +496,7 @@ func tcDot(n *ir.SelectorExpr, top int) ir.Node {
 		return n
 	}
 
-	if lookdot(n, t, 0) == nil {
+	if Lookdot(n, t, 0) == nil {
 		// Legitimate field or method lookup failed, try to explain the error
 		switch {
 		case t.IsEmptyInterface():
@@ -506,12 +506,12 @@ func tcDot(n *ir.SelectorExpr, top int) ir.Node {
 			// Pointer to interface is almost always a mistake.
 			base.Errorf("%v undefined (type %v is pointer to interface, not interface)", n, n.X.Type())
 
-		case lookdot(n, t, 1) != nil:
+		case Lookdot(n, t, 1) != nil:
 			// Field or method matches by name, but it is not exported.
 			base.Errorf("%v undefined (cannot refer to unexported field or method %v)", n, n.Sel)
 
 		default:
-			if mt := lookdot(n, t, 2); mt != nil && visible(mt.Sym) { // Case-insensitive lookup.
+			if mt := Lookdot(n, t, 2); mt != nil && visible(mt.Sym) { // Case-insensitive lookup.
 				base.Errorf("%v undefined (type %v has no field or method %v, but does have %v)", n, n.X.Type(), n.Sel, mt.Sym)
 			} else {
 				base.Errorf("%v undefined (type %v has no field or method %v)", n, n.X.Type(), n.Sel)
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index f06a8623d0..54f7cd9efa 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -1058,7 +1058,11 @@ func needTwoArgs(n *ir.CallExpr) (ir.Node, ir.Node, bool) {
 	return n.Args[0], n.Args[1], true
 }
 
-func lookdot1(errnode ir.Node, s *types.Sym, t *types.Type, fs *types.Fields, dostrcmp int) *types.Field {
+// Lookdot1 looks up the specified method s in the list fs of methods, returning
+// the matching field or nil. If dostrcmp is 0, it matches the symbols. If
+// dostrcmp is 1, it matches by name exactly. If dostrcmp is 2, it matches names
+// with case folding.
+func Lookdot1(errnode ir.Node, s *types.Sym, t *types.Type, fs *types.Fields, dostrcmp int) *types.Field {
 	var r *types.Field
 	for _, f := range fs.Slice() {
 		if dostrcmp != 0 && f.Sym.Name == s.Name {
@@ -1123,9 +1127,9 @@ func typecheckMethodExpr(n *ir.SelectorExpr) (res ir.Node) {
 	}
 
 	s := n.Sel
-	m := lookdot1(n, s, t, ms, 0)
+	m := Lookdot1(n, s, t, ms, 0)
 	if m == nil {
-		if lookdot1(n, s, t, ms, 1) != nil {
+		if Lookdot1(n, s, t, ms, 1) != nil {
 			base.Errorf("%v undefined (cannot refer to unexported method %v)", n, s)
 		} else if _, ambig := dotpath(s, t, nil, false); ambig {
 			base.Errorf("%v undefined (ambiguous selector)", n) // method or field
@@ -1155,20 +1159,26 @@ func derefall(t *types.Type) *types.Type {
 	return t
 }
 
-func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
+// Lookdot looks up field or method n.Sel in the type t and returns the matching
+// field. It transforms the op of node n to ODOTINTER or ODOTMETH, if appropriate.
+// It also may add a StarExpr node to n.X as needed for access to non-pointer
+// methods. If dostrcmp is 0, it matches the field/method with the exact symbol
+// as n.Sel (appropriate for exported fields). If dostrcmp is 1, it matches by name
+// exactly. If dostrcmp is 2, it matches names with case folding.
+func Lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 	s := n.Sel
 
 	types.CalcSize(t)
 	var f1 *types.Field
 	if t.IsStruct() || t.IsInterface() {
-		f1 = lookdot1(n, s, t, t.Fields(), dostrcmp)
+		f1 = Lookdot1(n, s, t, t.Fields(), dostrcmp)
 	}
 
 	var f2 *types.Field
 	if n.X.Type() == t || n.X.Type().Sym() == nil {
 		mt := types.ReceiverBaseType(t)
 		if mt != nil {
-			f2 = lookdot1(n, s, mt, mt.Methods(), dostrcmp)
+			f2 = Lookdot1(n, s, mt, mt.Methods(), dostrcmp)
 		}
 	}
 
@@ -1181,7 +1191,7 @@ func lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 			base.Errorf("%v is both field and method", n.Sel)
 		}
 		if f1.Offset == types.BADWIDTH {
-			base.Fatalf("lookdot badwidth t=%v, f1=%v@%p", t, f1, f1)
+			base.Fatalf("Lookdot badwidth t=%v, f1=%v@%p", t, f1, f1)
 		}
 		n.Selection = f1
 		n.SetType(f1.Type)
-- 
GitLab


From 3a0061822e0bfa79f2a464807e12970f588e3e94 Mon Sep 17 00:00:00 2001
From: fanzha02 <fannie.zhang@arm.com>
Date: Tue, 23 Mar 2021 15:35:30 +0800
Subject: [PATCH 1252/2400] cmd/compile: add arm64 rules to optimize go codes
 to constant 0

Optimize the following codes to constant 0.

  function shift (x uint32) uint64 {
    return uint64(x) >> 32
  }

Change-Id: Ida6b39d713cc119ad5a2f01fd54bfd252cf2c975
Reviewed-on: https://go-review.googlesource.com/c/go/+/303830
Trust: fannie zhang <Fannie.Zhang@arm.com>
Run-TryBot: fannie zhang <Fannie.Zhang@arm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/gen/ARM64.rules | 10 +++
 src/cmd/compile/internal/ssa/rewriteARM64.go | 90 ++++++++++++++++++++
 test/codegen/bitfield.go                     | 11 +++
 3 files changed, 111 insertions(+)

diff --git a/src/cmd/compile/internal/ssa/gen/ARM64.rules b/src/cmd/compile/internal/ssa/gen/ARM64.rules
index 1d2efdabe0..cb997776db 100644
--- a/src/cmd/compile/internal/ssa/gen/ARM64.rules
+++ b/src/cmd/compile/internal/ssa/gen/ARM64.rules
@@ -1801,6 +1801,16 @@
 // Special case setting bit as 1. An example is math.Copysign(c,-1)
 (ORconst [c1] (ANDconst [c2] x)) && c2|c1 == ^0  => (ORconst [c1] x)
 
+// If the shift amount is larger than the datasize(32, 16, 8), we can optimize to constant 0.
+(MOVWUreg (SLLconst [lc] x)) && lc >= 32 => (MOVDconst [0])
+(MOVHUreg (SLLconst [lc] x)) && lc >= 16 => (MOVDconst [0])
+(MOVBUreg (SLLconst [lc] x)) && lc >= 8 => (MOVDconst [0])
+
+// After zero extension, the upper (64-datasize(32|16|8)) bits are zero, we can optimiza to constant 0.
+(SRLconst [rc] (MOVWUreg x)) && rc >= 32 => (MOVDconst [0])
+(SRLconst [rc] (MOVHUreg x)) && rc >= 16 => (MOVDconst [0])
+(SRLconst [rc] (MOVBUreg x)) && rc >= 8 => (MOVDconst [0])
+
 // bitfield ops
 
 // sbfiz
diff --git a/src/cmd/compile/internal/ssa/rewriteARM64.go b/src/cmd/compile/internal/ssa/rewriteARM64.go
index c961310018..cdc246205c 100644
--- a/src/cmd/compile/internal/ssa/rewriteARM64.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM64.go
@@ -7028,6 +7028,21 @@ func rewriteValueARM64_OpARM64MOVBUreg(v *Value) bool {
 		v.AddArg(x)
 		return true
 	}
+	// match: (MOVBUreg (SLLconst [lc] x))
+	// cond: lc >= 8
+	// result: (MOVDconst [0])
+	for {
+		if v_0.Op != OpARM64SLLconst {
+			break
+		}
+		lc := auxIntToInt64(v_0.AuxInt)
+		if !(lc >= 8) {
+			break
+		}
+		v.reset(OpARM64MOVDconst)
+		v.AuxInt = int64ToAuxInt(0)
+		return true
+	}
 	// match: (MOVBUreg (SLLconst [sc] x))
 	// cond: isARM64BFMask(sc, 1<<8-1, sc)
 	// result: (UBFIZ [armBFAuxInt(sc, arm64BFWidth(1<<8-1, sc))] x)
@@ -10525,6 +10540,21 @@ func rewriteValueARM64_OpARM64MOVHUreg(v *Value) bool {
 		v.AuxInt = int64ToAuxInt(int64(uint16(c)))
 		return true
 	}
+	// match: (MOVHUreg (SLLconst [lc] x))
+	// cond: lc >= 16
+	// result: (MOVDconst [0])
+	for {
+		if v_0.Op != OpARM64SLLconst {
+			break
+		}
+		lc := auxIntToInt64(v_0.AuxInt)
+		if !(lc >= 16) {
+			break
+		}
+		v.reset(OpARM64MOVDconst)
+		v.AuxInt = int64ToAuxInt(0)
+		return true
+	}
 	// match: (MOVHUreg (SLLconst [sc] x))
 	// cond: isARM64BFMask(sc, 1<<16-1, sc)
 	// result: (UBFIZ [armBFAuxInt(sc, arm64BFWidth(1<<16-1, sc))] x)
@@ -12622,6 +12652,21 @@ func rewriteValueARM64_OpARM64MOVWUreg(v *Value) bool {
 		v.AuxInt = int64ToAuxInt(int64(uint32(c)))
 		return true
 	}
+	// match: (MOVWUreg (SLLconst [lc] x))
+	// cond: lc >= 32
+	// result: (MOVDconst [0])
+	for {
+		if v_0.Op != OpARM64SLLconst {
+			break
+		}
+		lc := auxIntToInt64(v_0.AuxInt)
+		if !(lc >= 32) {
+			break
+		}
+		v.reset(OpARM64MOVDconst)
+		v.AuxInt = int64ToAuxInt(0)
+		return true
+	}
 	// match: (MOVWUreg (SLLconst [sc] x))
 	// cond: isARM64BFMask(sc, 1<<32-1, sc)
 	// result: (UBFIZ [armBFAuxInt(sc, arm64BFWidth(1<<32-1, sc))] x)
@@ -20125,6 +20170,51 @@ func rewriteValueARM64_OpARM64SRLconst(v *Value) bool {
 		v.AddArg(x)
 		return true
 	}
+	// match: (SRLconst [rc] (MOVWUreg x))
+	// cond: rc >= 32
+	// result: (MOVDconst [0])
+	for {
+		rc := auxIntToInt64(v.AuxInt)
+		if v_0.Op != OpARM64MOVWUreg {
+			break
+		}
+		if !(rc >= 32) {
+			break
+		}
+		v.reset(OpARM64MOVDconst)
+		v.AuxInt = int64ToAuxInt(0)
+		return true
+	}
+	// match: (SRLconst [rc] (MOVHUreg x))
+	// cond: rc >= 16
+	// result: (MOVDconst [0])
+	for {
+		rc := auxIntToInt64(v.AuxInt)
+		if v_0.Op != OpARM64MOVHUreg {
+			break
+		}
+		if !(rc >= 16) {
+			break
+		}
+		v.reset(OpARM64MOVDconst)
+		v.AuxInt = int64ToAuxInt(0)
+		return true
+	}
+	// match: (SRLconst [rc] (MOVBUreg x))
+	// cond: rc >= 8
+	// result: (MOVDconst [0])
+	for {
+		rc := auxIntToInt64(v.AuxInt)
+		if v_0.Op != OpARM64MOVBUreg {
+			break
+		}
+		if !(rc >= 8) {
+			break
+		}
+		v.reset(OpARM64MOVDconst)
+		v.AuxInt = int64ToAuxInt(0)
+		return true
+	}
 	// match: (SRLconst [rc] (SLLconst [lc] x))
 	// cond: lc > rc
 	// result: (UBFIZ [armBFAuxInt(lc-rc, 64-lc)] x)
diff --git a/test/codegen/bitfield.go b/test/codegen/bitfield.go
index 8acefbd027..0fe6799ec1 100644
--- a/test/codegen/bitfield.go
+++ b/test/codegen/bitfield.go
@@ -264,3 +264,14 @@ func rev16w(c uint32) (uint32, uint32, uint32) {
 	b3 := ((c & 0xff00ff00) >> 8) ^ ((c & 0x00ff00ff) << 8)
 	return b1, b2, b3
 }
+
+func shift(x uint32, y uint16, z uint8) uint64 {
+	// arm64:-`MOVWU`,-`LSR\t[$]32`
+	a := uint64(x) >> 32
+	// arm64:-`MOVHU
+	b := uint64(y) >> 16
+	// arm64:-`MOVBU`
+	c := uint64(z) >> 8
+	// arm64:`MOVD\tZR`,-`ADD\tR[0-9]+>>16`,-`ADD\tR[0-9]+>>8`,
+	return a + b + c
+}
-- 
GitLab


From 98a902323f6406d39c068d60253a0872364041ac Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Thu, 25 Mar 2021 21:26:18 +0100
Subject: [PATCH 1253/2400] cmd/vendor, cmd/pprof: use golang.org/x/term
 directly

The cmd/pprof package currently uses golang.org/x/crypto/ssh/terminal
which - as of CL 258003 - is merely a wrapper around golang.org/x/term.

Thus, drop the dependency on golang.org/x/crypto/ssh/terminal and use
golang.org/x/term directly.

Change-Id: Ib15f1f110c338b9dba4a91a873171948ae6298a4
Reviewed-on: https://go-review.googlesource.com/c/go/+/304691
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go.mod                                |  4 +-
 src/cmd/pprof/readlineui.go                   | 20 ++---
 .../x/crypto/ssh/terminal/terminal.go         | 76 -------------------
 src/cmd/vendor/modules.txt                    |  1 -
 4 files changed, 12 insertions(+), 89 deletions(-)
 delete mode 100644 src/cmd/vendor/golang.org/x/crypto/ssh/terminal/terminal.go

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index 9b08040433..5fbcf642f4 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -5,9 +5,9 @@ go 1.17
 require (
 	github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5
 	golang.org/x/arch v0.0.0-20210308155006-05f8f0431f72
-	golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83
+	golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 // indirect
 	golang.org/x/mod v0.4.3-0.20210323215154-1cc8812c1740
 	golang.org/x/sys v0.0.0-20210309074719-68d13333faf2 // indirect
-	golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d // indirect
+	golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d
 	golang.org/x/tools v0.1.1-0.20210312185553-8e4f4c86593a
 )
diff --git a/src/cmd/pprof/readlineui.go b/src/cmd/pprof/readlineui.go
index dbbb9c2787..f46e934e0f 100644
--- a/src/cmd/pprof/readlineui.go
+++ b/src/cmd/pprof/readlineui.go
@@ -19,7 +19,7 @@ import (
 	"strings"
 
 	"github.com/google/pprof/driver"
-	"golang.org/x/crypto/ssh/terminal"
+	"golang.org/x/term"
 )
 
 func init() {
@@ -27,11 +27,11 @@ func init() {
 }
 
 // readlineUI implements driver.UI interface using the
-// golang.org/x/crypto/ssh/terminal package.
+// golang.org/x/term package.
 // The upstream pprof command implements the same functionality
 // using the github.com/chzyer/readline package.
 type readlineUI struct {
-	term *terminal.Terminal
+	term *term.Terminal
 }
 
 func newReadlineUI() driver.UI {
@@ -39,19 +39,19 @@ func newReadlineUI() driver.UI {
 	if v := strings.ToLower(os.Getenv("TERM")); v == "" || v == "dumb" {
 		return nil
 	}
-	// test if we can use terminal.ReadLine
+	// test if we can use term.ReadLine
 	// that assumes operation in the raw mode.
-	oldState, err := terminal.MakeRaw(0)
+	oldState, err := term.MakeRaw(0)
 	if err != nil {
 		return nil
 	}
-	terminal.Restore(0, oldState)
+	term.Restore(0, oldState)
 
 	rw := struct {
 		io.Reader
 		io.Writer
 	}{os.Stdin, os.Stderr}
-	return &readlineUI{term: terminal.NewTerminal(rw, "")}
+	return &readlineUI{term: term.NewTerminal(rw, "")}
 }
 
 // Read returns a line of text (a command) read from the user.
@@ -61,8 +61,8 @@ func (r *readlineUI) ReadLine(prompt string) (string, error) {
 
 	// skip error checking because we tested it
 	// when creating this readlineUI initially.
-	oldState, _ := terminal.MakeRaw(0)
-	defer terminal.Restore(0, oldState)
+	oldState, _ := term.MakeRaw(0)
+	defer term.Restore(0, oldState)
 
 	s, err := r.term.ReadLine()
 	return s, err
@@ -106,7 +106,7 @@ func colorize(msg string) string {
 // interactive terminal (as opposed to being redirected to a file).
 func (r *readlineUI) IsTerminal() bool {
 	const stdout = 1
-	return terminal.IsTerminal(stdout)
+	return term.IsTerminal(stdout)
 }
 
 // WantBrowser indicates whether browser should be opened with the -http option.
diff --git a/src/cmd/vendor/golang.org/x/crypto/ssh/terminal/terminal.go b/src/cmd/vendor/golang.org/x/crypto/ssh/terminal/terminal.go
deleted file mode 100644
index a4d1919a9e..0000000000
--- a/src/cmd/vendor/golang.org/x/crypto/ssh/terminal/terminal.go
+++ /dev/null
@@ -1,76 +0,0 @@
-// Copyright 2011 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 terminal provides support functions for dealing with terminals, as
-// commonly found on UNIX systems.
-//
-// Deprecated: this package moved to golang.org/x/term.
-package terminal
-
-import (
-	"io"
-
-	"golang.org/x/term"
-)
-
-// EscapeCodes contains escape sequences that can be written to the terminal in
-// order to achieve different styles of text.
-type EscapeCodes = term.EscapeCodes
-
-// Terminal contains the state for running a VT100 terminal that is capable of
-// reading lines of input.
-type Terminal = term.Terminal
-
-// NewTerminal runs a VT100 terminal on the given ReadWriter. If the ReadWriter is
-// a local terminal, that terminal must first have been put into raw mode.
-// prompt is a string that is written at the start of each input line (i.e.
-// "> ").
-func NewTerminal(c io.ReadWriter, prompt string) *Terminal {
-	return term.NewTerminal(c, prompt)
-}
-
-// ErrPasteIndicator may be returned from ReadLine as the error, in addition
-// to valid line data. It indicates that bracketed paste mode is enabled and
-// that the returned line consists only of pasted data. Programs may wish to
-// interpret pasted data more literally than typed data.
-var ErrPasteIndicator = term.ErrPasteIndicator
-
-// State contains the state of a terminal.
-type State = term.State
-
-// IsTerminal returns whether the given file descriptor is a terminal.
-func IsTerminal(fd int) bool {
-	return term.IsTerminal(fd)
-}
-
-// ReadPassword reads a line of input from a terminal without local echo.  This
-// is commonly used for inputting passwords and other sensitive data. The slice
-// returned does not include the \n.
-func ReadPassword(fd int) ([]byte, error) {
-	return term.ReadPassword(fd)
-}
-
-// MakeRaw puts the terminal connected to the given file descriptor into raw
-// mode and returns the previous state of the terminal so that it can be
-// restored.
-func MakeRaw(fd int) (*State, error) {
-	return term.MakeRaw(fd)
-}
-
-// Restore restores the terminal connected to the given file descriptor to a
-// previous state.
-func Restore(fd int, oldState *State) error {
-	return term.Restore(fd, oldState)
-}
-
-// GetState returns the current state of a terminal which may be useful to
-// restore the terminal after a signal.
-func GetState(fd int) (*State, error) {
-	return term.GetState(fd)
-}
-
-// GetSize returns the dimensions of the given terminal.
-func GetSize(fd int) (width, height int, err error) {
-	return term.GetSize(fd)
-}
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 6960ff1c7e..4a128c7933 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -27,7 +27,6 @@ golang.org/x/arch/x86/x86asm
 ## explicit
 golang.org/x/crypto/ed25519
 golang.org/x/crypto/ed25519/internal/edwards25519
-golang.org/x/crypto/ssh/terminal
 # golang.org/x/mod v0.4.3-0.20210323215154-1cc8812c1740
 ## explicit
 golang.org/x/mod/internal/lazyregexp
-- 
GitLab


From 359f44910f470578b2aed43f057b6fa8b4b41bcc Mon Sep 17 00:00:00 2001
From: Pat Gavlin <pgavlin@gmail.com>
Date: Fri, 26 Mar 2021 17:48:42 +0000
Subject: [PATCH 1254/2400] cmd/compile: fix long RMW bit operations on AMD64
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Under certain circumstances, the existing rules for bit operations can
produce code that writes beyond its intended bounds. For example,
consider the following code:

    func repro(b []byte, addr, bit int32) {
	    _ = b[3]
	    v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 | 1<<(bit&31)
	    b[0] = byte(v)
	    b[1] = byte(v >> 8)
	    b[2] = byte(v >> 16)
	    b[3] = byte(v >> 24)
    }

Roughly speaking:

1. The expression `1 << (bit & 31)` is rewritten into `(SHLL 1 bit)`
2. The expression `uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 |
   uint32(b[3])<<24` is rewritten into `(MOVLload &b[0])`
3. The statements `b[0] = byte(v) ... b[3] = byte(v >> 24)` are
   rewritten into `(MOVLstore &b[0], v)`
4. `(ORL (SHLL 1, bit) (MOVLload &b[0]))` is rewritten into
   `(BTSL (MOVLload &b[0]) bit)`. This is a valid transformation because
   the destination is a register: in this case, the bit offset is masked
   by the number of bits in the destination register. This is identical
   to the masking performed by `SHL`.
5. `(MOVLstore &b[0] (BTSL (MOVLload &b[0]) bit))` is rewritten into
   `(BTSLmodify &b[0] bit)`. This is an invalid transformation because
   the destination is memory: in this case, the bit offset is not
   masked, and the chosen instruction may write outside its intended
   32-bit location.

These changes fix the invalid rewrite performed in step (5) by
explicitly maksing the bit offset operand to `BT(S|R|C)(L|Q)modify`. In
the example above, the adjusted rules produce
`(BTSLmodify &b[0] (ANDLconst [31] bit))` in step (5).

These changes also add several new rules to rewrite bit sets, toggles,
and clears that are rooted at `(OR|XOR|AND)(L|Q)modify` operators into
appropriate `BT(S|R|C)(L|Q)modify` operators. These rules catch cases
where `MOV(L|Q)store ((OR|XOR|AND)(L|Q) ...)` is rewritten to
`(OR|XOR|AND)(L|Q)modify` before the `(OR|XOR|AND)(L|Q) ...` can be
rewritten to `BT(S|R|C)(L|Q) ...`.

Overall, compilecmp reports small improvements in code size on
darwin/amd64 when the changes to the compiler itself are exlcuded:

file                               before   after    Δ       %
runtime.s                          536464   536412   -52     -0.010%
bytes.s                            32629    32593    -36     -0.110%
strings.s                          44565    44529    -36     -0.081%
os/signal.s                        7967     7959     -8      -0.100%
cmd/vendor/golang.org/x/sys/unix.s 81686    81678    -8      -0.010%
math/big.s                         188235   188253   +18     +0.010%
cmd/link/internal/loader.s         89295    89056    -239    -0.268%
cmd/link/internal/ld.s             633551   633232   -319    -0.050%
cmd/link/internal/arm.s            18934    18928    -6      -0.032%
cmd/link/internal/arm64.s          31814    31801    -13     -0.041%
cmd/link/internal/riscv64.s        7347     7345     -2      -0.027%
cmd/compile/internal/ssa.s         4029173  4033066  +3893   +0.097%
total                              21298280 21301472 +3192   +0.015%

Change-Id: I2e560548b515865129e1724e150e30540e9d29ce
GitHub-Last-Rev: 9a42bd29a55b3917651aecab6932074df96535ae
GitHub-Pull-Request: golang/go#45242
Reviewed-on: https://go-review.googlesource.com/c/go/+/304869
Reviewed-by: Keith Randall <khr@golang.org>
Trust: Josh Bleecher Snyder <josharian@gmail.com>
---
 src/cmd/compile/internal/ssa/gen/AMD64.rules |  24 +-
 src/cmd/compile/internal/ssa/gen/AMD64Ops.go |   5 +
 src/cmd/compile/internal/ssa/rewriteAMD64.go | 229 +++++++++++++++++--
 test/codegen/bits.go                         |  10 +-
 test/fixedbugs/issue45242.go                 |  28 +++
 5 files changed, 272 insertions(+), 24 deletions(-)
 create mode 100644 test/fixedbugs/issue45242.go

diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules
index 7dc381bd81..98cd865182 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64.rules
+++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules
@@ -624,6 +624,14 @@
 // Recognize bit setting (a |= 1<<b) and toggling (a ^= 1<<b)
 (OR(Q|L) (SHL(Q|L) (MOV(Q|L)const [1]) y) x) => (BTS(Q|L) x y)
 (XOR(Q|L) (SHL(Q|L) (MOV(Q|L)const [1]) y) x) => (BTC(Q|L) x y)
+(ORLmodify [off] {sym} ptr s:(SHLL (MOVLconst [1]) <t> x) mem) =>
+	(BTSLmodify [off] {sym} ptr (ANDLconst <t> [31] x) mem)
+(ORQmodify [off] {sym} ptr s:(SHLQ (MOVQconst [1]) <t> x) mem) =>
+	(BTSQmodify [off] {sym} ptr (ANDQconst <t> [63] x) mem)
+(XORLmodify [off] {sym} ptr s:(SHLL (MOVLconst [1]) <t> x) mem) =>
+	(BTCLmodify [off] {sym} ptr (ANDLconst <t> [31] x) mem)
+(XORQmodify [off] {sym} ptr s:(SHLQ (MOVQconst [1]) <t> x) mem) =>
+	(BTCQmodify [off] {sym} ptr (ANDQconst <t> [63] x) mem)
 
 // Convert ORconst into BTS, if the code gets smaller, with boundary being
 // (ORL $40,AX is 3 bytes, ORL $80,AX is 6 bytes).
@@ -646,6 +654,10 @@
     => (BTRQconst [int8(log64(^c))] x)
 (ANDL (MOVLconst [c]) x) && isUint32PowerOfTwo(int64(^c)) && uint64(^c) >= 128
     => (BTRLconst [int8(log32(^c))] x)
+(ANDLmodify [off] {sym} ptr (NOTL s:(SHLL (MOVLconst [1]) <t> x)) mem) =>
+	(BTRLmodify [off] {sym} ptr (ANDLconst <t> [31] x) mem)
+(ANDQmodify [off] {sym} ptr (NOTQ s:(SHLQ (MOVQconst [1]) <t> x)) mem) =>
+	(BTRQmodify [off] {sym} ptr (ANDQconst <t> [63] x) mem)
 
 // Special-case bit patterns on first/last bit.
 // generic.rules changes ANDs of high-part/low-part masks into a couple of shifts,
@@ -2064,11 +2076,15 @@
 ((ADD|SUB|MUL|DIV)SD x l:(MOVSDload [off] {sym} ptr mem)) && canMergeLoadClobber(v, l, x) && clobber(l) => ((ADD|SUB|MUL|DIV)SDload x [off] {sym} ptr mem)
 ((ADD|SUB|MUL|DIV)SS x l:(MOVSSload [off] {sym} ptr mem)) && canMergeLoadClobber(v, l, x) && clobber(l) => ((ADD|SUB|MUL|DIV)SSload x [off] {sym} ptr mem)
 (MOVLstore {sym} [off] ptr y:((ADD|AND|OR|XOR)Lload x [off] {sym} ptr mem) mem) && y.Uses==1 && clobber(y) => ((ADD|AND|OR|XOR)Lmodify [off] {sym} ptr x mem)
-(MOVLstore {sym} [off] ptr y:((ADD|SUB|AND|OR|XOR|BTC|BTR|BTS)L l:(MOVLload [off] {sym} ptr mem) x) mem) && y.Uses==1 && l.Uses==1 && clobber(y, l) =>
-	((ADD|SUB|AND|OR|XOR|BTC|BTR|BTS)Lmodify [off] {sym} ptr x mem)
+(MOVLstore {sym} [off] ptr y:((ADD|SUB|AND|OR|XOR)L l:(MOVLload [off] {sym} ptr mem) x) mem) && y.Uses==1 && l.Uses==1 && clobber(y, l) =>
+	((ADD|SUB|AND|OR|XOR)Lmodify [off] {sym} ptr x mem)
+(MOVLstore {sym} [off] ptr y:((BTC|BTR|BTS)L l:(MOVLload [off] {sym} ptr mem) <t> x) mem) && y.Uses==1 && l.Uses==1 && clobber(y, l) =>
+	((BTC|BTR|BTS)Lmodify [off] {sym} ptr (ANDLconst <t> [31] x) mem)
 (MOVQstore {sym} [off] ptr y:((ADD|AND|OR|XOR)Qload x [off] {sym} ptr mem) mem) && y.Uses==1 && clobber(y) => ((ADD|AND|OR|XOR)Qmodify [off] {sym} ptr x mem)
-(MOVQstore {sym} [off] ptr y:((ADD|SUB|AND|OR|XOR|BTC|BTR|BTS)Q l:(MOVQload [off] {sym} ptr mem) x) mem) && y.Uses==1 && l.Uses==1 && clobber(y, l) =>
-	((ADD|SUB|AND|OR|XOR|BTC|BTR|BTS)Qmodify [off] {sym} ptr x mem)
+(MOVQstore {sym} [off] ptr y:((ADD|SUB|AND|OR|XOR)Q l:(MOVQload [off] {sym} ptr mem) x) mem) && y.Uses==1 && l.Uses==1 && clobber(y, l) =>
+	((ADD|SUB|AND|OR|XOR)Qmodify [off] {sym} ptr x mem)
+(MOVQstore {sym} [off] ptr y:((BTC|BTR|BTS)Q l:(MOVQload [off] {sym} ptr mem) <t> x) mem) && y.Uses==1 && l.Uses==1 && clobber(y, l) =>
+	((BTC|BTR|BTS)Qmodify [off] {sym} ptr (ANDQconst <t> [63] x) mem)
 
 // Merge ADDQconst and LEAQ into atomic loads.
 (MOV(Q|L|B)atomicload [off1] {sym} (ADDQconst [off2] ptr) mem) && is32Bit(int64(off1)+int64(off2)) =>
diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
index 6c3fe1d192..af53cc4f9d 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
+++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
@@ -363,6 +363,11 @@ func init() {
 		{name: "BTSQconst", argLength: 1, reg: gp11, asm: "BTSQ", resultInArg0: true, clobberFlags: true, aux: "Int8"}, // set bit auxint in arg0, 0 <= auxint < 64
 
 		// direct bit operation on memory operand
+		//
+		// Note that these operations do not mask the bit offset (arg1), and will write beyond their expected
+		// bounds if that argument is larger than 64/32 (for BT*Q and BT*L, respectively). If the compiler
+		// cannot prove that arg1 is in range, it must be explicitly masked (see e.g. the patterns that produce
+		// BT*modify from (MOVstore (BT* (MOVLload ptr mem) x) mem)).
 		{name: "BTCQmodify", argLength: 3, reg: gpstore, asm: "BTCQ", aux: "SymOff", typ: "Mem", clobberFlags: true, faultOnNilArg0: true, symEffect: "Read,Write"},     // complement bit arg1 in 64-bit arg0+auxint+aux, arg2=mem
 		{name: "BTCLmodify", argLength: 3, reg: gpstore, asm: "BTCL", aux: "SymOff", typ: "Mem", clobberFlags: true, faultOnNilArg0: true, symEffect: "Read,Write"},     // complement bit arg1 in 32-bit arg0+auxint+aux, arg2=mem
 		{name: "BTSQmodify", argLength: 3, reg: gpstore, asm: "BTSQ", aux: "SymOff", typ: "Mem", clobberFlags: true, faultOnNilArg0: true, symEffect: "Read,Write"},     // set bit arg1 in 64-bit arg0+auxint+aux, arg2=mem
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index 36f872d0c4..ce94fdb952 100644
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -3001,6 +3001,36 @@ func rewriteValueAMD64_OpAMD64ANDLmodify(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
+	b := v.Block
+	// match: (ANDLmodify [off] {sym} ptr (NOTL s:(SHLL (MOVLconst [1]) <t> x)) mem)
+	// result: (BTRLmodify [off] {sym} ptr (ANDLconst <t> [31] x) mem)
+	for {
+		off := auxIntToInt32(v.AuxInt)
+		sym := auxToSym(v.Aux)
+		ptr := v_0
+		if v_1.Op != OpAMD64NOTL {
+			break
+		}
+		s := v_1.Args[0]
+		if s.Op != OpAMD64SHLL {
+			break
+		}
+		t := s.Type
+		x := s.Args[1]
+		s_0 := s.Args[0]
+		if s_0.Op != OpAMD64MOVLconst || auxIntToInt32(s_0.AuxInt) != 1 {
+			break
+		}
+		mem := v_2
+		v.reset(OpAMD64BTRLmodify)
+		v.AuxInt = int32ToAuxInt(off)
+		v.Aux = symToAux(sym)
+		v0 := b.NewValue0(v.Pos, OpAMD64ANDLconst, t)
+		v0.AuxInt = int32ToAuxInt(31)
+		v0.AddArg(x)
+		v.AddArg3(ptr, v0, mem)
+		return true
+	}
 	// match: (ANDLmodify [off1] {sym} (ADDQconst [off2] base) val mem)
 	// cond: is32Bit(int64(off1)+int64(off2))
 	// result: (ANDLmodify [off1+off2] {sym} base val mem)
@@ -3380,6 +3410,36 @@ func rewriteValueAMD64_OpAMD64ANDQmodify(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
+	b := v.Block
+	// match: (ANDQmodify [off] {sym} ptr (NOTQ s:(SHLQ (MOVQconst [1]) <t> x)) mem)
+	// result: (BTRQmodify [off] {sym} ptr (ANDQconst <t> [63] x) mem)
+	for {
+		off := auxIntToInt32(v.AuxInt)
+		sym := auxToSym(v.Aux)
+		ptr := v_0
+		if v_1.Op != OpAMD64NOTQ {
+			break
+		}
+		s := v_1.Args[0]
+		if s.Op != OpAMD64SHLQ {
+			break
+		}
+		t := s.Type
+		x := s.Args[1]
+		s_0 := s.Args[0]
+		if s_0.Op != OpAMD64MOVQconst || auxIntToInt64(s_0.AuxInt) != 1 {
+			break
+		}
+		mem := v_2
+		v.reset(OpAMD64BTRQmodify)
+		v.AuxInt = int32ToAuxInt(off)
+		v.Aux = symToAux(sym)
+		v0 := b.NewValue0(v.Pos, OpAMD64ANDQconst, t)
+		v0.AuxInt = int32ToAuxInt(63)
+		v0.AddArg(x)
+		v.AddArg3(ptr, v0, mem)
+		return true
+	}
 	// match: (ANDQmodify [off1] {sym} (ADDQconst [off2] base) val mem)
 	// cond: is32Bit(int64(off1)+int64(off2))
 	// result: (ANDQmodify [off1+off2] {sym} base val mem)
@@ -12750,9 +12810,9 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
 		}
 		break
 	}
-	// match: (MOVLstore {sym} [off] ptr y:(BTCL l:(MOVLload [off] {sym} ptr mem) x) mem)
+	// match: (MOVLstore {sym} [off] ptr y:(BTCL l:(MOVLload [off] {sym} ptr mem) <t> x) mem)
 	// cond: y.Uses==1 && l.Uses==1 && clobber(y, l)
-	// result: (BTCLmodify [off] {sym} ptr x mem)
+	// result: (BTCLmodify [off] {sym} ptr (ANDLconst <t> [31] x) mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -12761,6 +12821,7 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
 		if y.Op != OpAMD64BTCL {
 			break
 		}
+		t := y.Type
 		x := y.Args[1]
 		l := y.Args[0]
 		if l.Op != OpAMD64MOVLload || auxIntToInt32(l.AuxInt) != off || auxToSym(l.Aux) != sym {
@@ -12773,12 +12834,15 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
 		v.reset(OpAMD64BTCLmodify)
 		v.AuxInt = int32ToAuxInt(off)
 		v.Aux = symToAux(sym)
-		v.AddArg3(ptr, x, mem)
+		v0 := b.NewValue0(l.Pos, OpAMD64ANDLconst, t)
+		v0.AuxInt = int32ToAuxInt(31)
+		v0.AddArg(x)
+		v.AddArg3(ptr, v0, mem)
 		return true
 	}
-	// match: (MOVLstore {sym} [off] ptr y:(BTRL l:(MOVLload [off] {sym} ptr mem) x) mem)
+	// match: (MOVLstore {sym} [off] ptr y:(BTRL l:(MOVLload [off] {sym} ptr mem) <t> x) mem)
 	// cond: y.Uses==1 && l.Uses==1 && clobber(y, l)
-	// result: (BTRLmodify [off] {sym} ptr x mem)
+	// result: (BTRLmodify [off] {sym} ptr (ANDLconst <t> [31] x) mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -12787,6 +12851,7 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
 		if y.Op != OpAMD64BTRL {
 			break
 		}
+		t := y.Type
 		x := y.Args[1]
 		l := y.Args[0]
 		if l.Op != OpAMD64MOVLload || auxIntToInt32(l.AuxInt) != off || auxToSym(l.Aux) != sym {
@@ -12799,12 +12864,15 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
 		v.reset(OpAMD64BTRLmodify)
 		v.AuxInt = int32ToAuxInt(off)
 		v.Aux = symToAux(sym)
-		v.AddArg3(ptr, x, mem)
+		v0 := b.NewValue0(l.Pos, OpAMD64ANDLconst, t)
+		v0.AuxInt = int32ToAuxInt(31)
+		v0.AddArg(x)
+		v.AddArg3(ptr, v0, mem)
 		return true
 	}
-	// match: (MOVLstore {sym} [off] ptr y:(BTSL l:(MOVLload [off] {sym} ptr mem) x) mem)
+	// match: (MOVLstore {sym} [off] ptr y:(BTSL l:(MOVLload [off] {sym} ptr mem) <t> x) mem)
 	// cond: y.Uses==1 && l.Uses==1 && clobber(y, l)
-	// result: (BTSLmodify [off] {sym} ptr x mem)
+	// result: (BTSLmodify [off] {sym} ptr (ANDLconst <t> [31] x) mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -12813,6 +12881,7 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
 		if y.Op != OpAMD64BTSL {
 			break
 		}
+		t := y.Type
 		x := y.Args[1]
 		l := y.Args[0]
 		if l.Op != OpAMD64MOVLload || auxIntToInt32(l.AuxInt) != off || auxToSym(l.Aux) != sym {
@@ -12825,7 +12894,10 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
 		v.reset(OpAMD64BTSLmodify)
 		v.AuxInt = int32ToAuxInt(off)
 		v.Aux = symToAux(sym)
-		v.AddArg3(ptr, x, mem)
+		v0 := b.NewValue0(l.Pos, OpAMD64ANDLconst, t)
+		v0.AuxInt = int32ToAuxInt(31)
+		v0.AddArg(x)
+		v.AddArg3(ptr, v0, mem)
 		return true
 	}
 	// match: (MOVLstore [off] {sym} ptr a:(ADDLconst [c] l:(MOVLload [off] {sym} ptr2 mem)) mem)
@@ -13566,6 +13638,7 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
+	b := v.Block
 	// match: (MOVQstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
 	// cond: is32Bit(int64(off1)+int64(off2))
 	// result: (MOVQstore [off1+off2] {sym} ptr val mem)
@@ -13931,9 +14004,9 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
 		}
 		break
 	}
-	// match: (MOVQstore {sym} [off] ptr y:(BTCQ l:(MOVQload [off] {sym} ptr mem) x) mem)
+	// match: (MOVQstore {sym} [off] ptr y:(BTCQ l:(MOVQload [off] {sym} ptr mem) <t> x) mem)
 	// cond: y.Uses==1 && l.Uses==1 && clobber(y, l)
-	// result: (BTCQmodify [off] {sym} ptr x mem)
+	// result: (BTCQmodify [off] {sym} ptr (ANDQconst <t> [63] x) mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -13942,6 +14015,7 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
 		if y.Op != OpAMD64BTCQ {
 			break
 		}
+		t := y.Type
 		x := y.Args[1]
 		l := y.Args[0]
 		if l.Op != OpAMD64MOVQload || auxIntToInt32(l.AuxInt) != off || auxToSym(l.Aux) != sym {
@@ -13954,12 +14028,15 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
 		v.reset(OpAMD64BTCQmodify)
 		v.AuxInt = int32ToAuxInt(off)
 		v.Aux = symToAux(sym)
-		v.AddArg3(ptr, x, mem)
+		v0 := b.NewValue0(l.Pos, OpAMD64ANDQconst, t)
+		v0.AuxInt = int32ToAuxInt(63)
+		v0.AddArg(x)
+		v.AddArg3(ptr, v0, mem)
 		return true
 	}
-	// match: (MOVQstore {sym} [off] ptr y:(BTRQ l:(MOVQload [off] {sym} ptr mem) x) mem)
+	// match: (MOVQstore {sym} [off] ptr y:(BTRQ l:(MOVQload [off] {sym} ptr mem) <t> x) mem)
 	// cond: y.Uses==1 && l.Uses==1 && clobber(y, l)
-	// result: (BTRQmodify [off] {sym} ptr x mem)
+	// result: (BTRQmodify [off] {sym} ptr (ANDQconst <t> [63] x) mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -13968,6 +14045,7 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
 		if y.Op != OpAMD64BTRQ {
 			break
 		}
+		t := y.Type
 		x := y.Args[1]
 		l := y.Args[0]
 		if l.Op != OpAMD64MOVQload || auxIntToInt32(l.AuxInt) != off || auxToSym(l.Aux) != sym {
@@ -13980,12 +14058,15 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
 		v.reset(OpAMD64BTRQmodify)
 		v.AuxInt = int32ToAuxInt(off)
 		v.Aux = symToAux(sym)
-		v.AddArg3(ptr, x, mem)
+		v0 := b.NewValue0(l.Pos, OpAMD64ANDQconst, t)
+		v0.AuxInt = int32ToAuxInt(63)
+		v0.AddArg(x)
+		v.AddArg3(ptr, v0, mem)
 		return true
 	}
-	// match: (MOVQstore {sym} [off] ptr y:(BTSQ l:(MOVQload [off] {sym} ptr mem) x) mem)
+	// match: (MOVQstore {sym} [off] ptr y:(BTSQ l:(MOVQload [off] {sym} ptr mem) <t> x) mem)
 	// cond: y.Uses==1 && l.Uses==1 && clobber(y, l)
-	// result: (BTSQmodify [off] {sym} ptr x mem)
+	// result: (BTSQmodify [off] {sym} ptr (ANDQconst <t> [63] x) mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
@@ -13994,6 +14075,7 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
 		if y.Op != OpAMD64BTSQ {
 			break
 		}
+		t := y.Type
 		x := y.Args[1]
 		l := y.Args[0]
 		if l.Op != OpAMD64MOVQload || auxIntToInt32(l.AuxInt) != off || auxToSym(l.Aux) != sym {
@@ -14006,7 +14088,10 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
 		v.reset(OpAMD64BTSQmodify)
 		v.AuxInt = int32ToAuxInt(off)
 		v.Aux = symToAux(sym)
-		v.AddArg3(ptr, x, mem)
+		v0 := b.NewValue0(l.Pos, OpAMD64ANDQconst, t)
+		v0.AuxInt = int32ToAuxInt(63)
+		v0.AddArg(x)
+		v.AddArg3(ptr, v0, mem)
 		return true
 	}
 	// match: (MOVQstore [off] {sym} ptr a:(ADDQconst [c] l:(MOVQload [off] {sym} ptr2 mem)) mem)
@@ -18391,6 +18476,33 @@ func rewriteValueAMD64_OpAMD64ORLmodify(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
+	b := v.Block
+	// match: (ORLmodify [off] {sym} ptr s:(SHLL (MOVLconst [1]) <t> x) mem)
+	// result: (BTSLmodify [off] {sym} ptr (ANDLconst <t> [31] x) mem)
+	for {
+		off := auxIntToInt32(v.AuxInt)
+		sym := auxToSym(v.Aux)
+		ptr := v_0
+		s := v_1
+		if s.Op != OpAMD64SHLL {
+			break
+		}
+		t := s.Type
+		x := s.Args[1]
+		s_0 := s.Args[0]
+		if s_0.Op != OpAMD64MOVLconst || auxIntToInt32(s_0.AuxInt) != 1 {
+			break
+		}
+		mem := v_2
+		v.reset(OpAMD64BTSLmodify)
+		v.AuxInt = int32ToAuxInt(off)
+		v.Aux = symToAux(sym)
+		v0 := b.NewValue0(v.Pos, OpAMD64ANDLconst, t)
+		v0.AuxInt = int32ToAuxInt(31)
+		v0.AddArg(x)
+		v.AddArg3(ptr, v0, mem)
+		return true
+	}
 	// match: (ORLmodify [off1] {sym} (ADDQconst [off2] base) val mem)
 	// cond: is32Bit(int64(off1)+int64(off2))
 	// result: (ORLmodify [off1+off2] {sym} base val mem)
@@ -20066,6 +20178,33 @@ func rewriteValueAMD64_OpAMD64ORQmodify(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
+	b := v.Block
+	// match: (ORQmodify [off] {sym} ptr s:(SHLQ (MOVQconst [1]) <t> x) mem)
+	// result: (BTSQmodify [off] {sym} ptr (ANDQconst <t> [63] x) mem)
+	for {
+		off := auxIntToInt32(v.AuxInt)
+		sym := auxToSym(v.Aux)
+		ptr := v_0
+		s := v_1
+		if s.Op != OpAMD64SHLQ {
+			break
+		}
+		t := s.Type
+		x := s.Args[1]
+		s_0 := s.Args[0]
+		if s_0.Op != OpAMD64MOVQconst || auxIntToInt64(s_0.AuxInt) != 1 {
+			break
+		}
+		mem := v_2
+		v.reset(OpAMD64BTSQmodify)
+		v.AuxInt = int32ToAuxInt(off)
+		v.Aux = symToAux(sym)
+		v0 := b.NewValue0(v.Pos, OpAMD64ANDQconst, t)
+		v0.AuxInt = int32ToAuxInt(63)
+		v0.AddArg(x)
+		v.AddArg3(ptr, v0, mem)
+		return true
+	}
 	// match: (ORQmodify [off1] {sym} (ADDQconst [off2] base) val mem)
 	// cond: is32Bit(int64(off1)+int64(off2))
 	// result: (ORQmodify [off1+off2] {sym} base val mem)
@@ -28155,6 +28294,33 @@ func rewriteValueAMD64_OpAMD64XORLmodify(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
+	b := v.Block
+	// match: (XORLmodify [off] {sym} ptr s:(SHLL (MOVLconst [1]) <t> x) mem)
+	// result: (BTCLmodify [off] {sym} ptr (ANDLconst <t> [31] x) mem)
+	for {
+		off := auxIntToInt32(v.AuxInt)
+		sym := auxToSym(v.Aux)
+		ptr := v_0
+		s := v_1
+		if s.Op != OpAMD64SHLL {
+			break
+		}
+		t := s.Type
+		x := s.Args[1]
+		s_0 := s.Args[0]
+		if s_0.Op != OpAMD64MOVLconst || auxIntToInt32(s_0.AuxInt) != 1 {
+			break
+		}
+		mem := v_2
+		v.reset(OpAMD64BTCLmodify)
+		v.AuxInt = int32ToAuxInt(off)
+		v.Aux = symToAux(sym)
+		v0 := b.NewValue0(v.Pos, OpAMD64ANDLconst, t)
+		v0.AuxInt = int32ToAuxInt(31)
+		v0.AddArg(x)
+		v.AddArg3(ptr, v0, mem)
+		return true
+	}
 	// match: (XORLmodify [off1] {sym} (ADDQconst [off2] base) val mem)
 	// cond: is32Bit(int64(off1)+int64(off2))
 	// result: (XORLmodify [off1+off2] {sym} base val mem)
@@ -28523,6 +28689,33 @@ func rewriteValueAMD64_OpAMD64XORQmodify(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
+	b := v.Block
+	// match: (XORQmodify [off] {sym} ptr s:(SHLQ (MOVQconst [1]) <t> x) mem)
+	// result: (BTCQmodify [off] {sym} ptr (ANDQconst <t> [63] x) mem)
+	for {
+		off := auxIntToInt32(v.AuxInt)
+		sym := auxToSym(v.Aux)
+		ptr := v_0
+		s := v_1
+		if s.Op != OpAMD64SHLQ {
+			break
+		}
+		t := s.Type
+		x := s.Args[1]
+		s_0 := s.Args[0]
+		if s_0.Op != OpAMD64MOVQconst || auxIntToInt64(s_0.AuxInt) != 1 {
+			break
+		}
+		mem := v_2
+		v.reset(OpAMD64BTCQmodify)
+		v.AuxInt = int32ToAuxInt(off)
+		v.Aux = symToAux(sym)
+		v0 := b.NewValue0(v.Pos, OpAMD64ANDQconst, t)
+		v0.AuxInt = int32ToAuxInt(63)
+		v0.AddArg(x)
+		v.AddArg3(ptr, v0, mem)
+		return true
+	}
 	// match: (XORQmodify [off1] {sym} (ADDQconst [off2] base) val mem)
 	// cond: is32Bit(int64(off1)+int64(off2))
 	// result: (XORQmodify [off1+off2] {sym} base val mem)
diff --git a/test/codegen/bits.go b/test/codegen/bits.go
index 806dad13c8..d41383f42c 100644
--- a/test/codegen/bits.go
+++ b/test/codegen/bits.go
@@ -262,8 +262,8 @@ func bitcompl32(a, b uint32) (n uint32) {
 	return n
 }
 
-// check direct operation on memory with constant source
-func bitOpOnMem(a []uint32) {
+// check direct operation on memory with constant and shifted constant sources
+func bitOpOnMem(a []uint32, b, c, d uint32) {
 	// amd64:`ANDL\s[$]200,\s\([A-Z]+\)`
 	a[0] &= 200
 	// amd64:`ORL\s[$]220,\s4\([A-Z]+\)`
@@ -276,6 +276,12 @@ func bitOpOnMem(a []uint32) {
 	a[4] |= 0x4000
 	// amd64:`BTCL\s[$]13,\s20\([A-Z]+\)`,-`XORL`
 	a[5] ^= 0x2000
+	// amd64:`BTRL\s[A-Z]+,\s24\([A-Z]+\)`
+	a[6] &^= 1 << (b & 31)
+	// amd64:`BTSL\s[A-Z]+,\s28\([A-Z]+\)`
+	a[7] |= 1 << (c & 31)
+	// amd64:`BTCL\s[A-Z]+,\s32\([A-Z]+\)`
+	a[8] ^= 1 << (d & 31)
 }
 
 func bitcheckMostNegative(b uint8) bool {
diff --git a/test/fixedbugs/issue45242.go b/test/fixedbugs/issue45242.go
new file mode 100644
index 0000000000..b99722120d
--- /dev/null
+++ b/test/fixedbugs/issue45242.go
@@ -0,0 +1,28 @@
+// run
+
+// Copyright 2021 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 "fmt"
+
+//go:noinline
+func repro(b []byte, bit int32) {
+	_ = b[3]
+	v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 | 1<<(bit&31)
+	b[0] = byte(v)
+	b[1] = byte(v >> 8)
+	b[2] = byte(v >> 16)
+	b[3] = byte(v >> 24)
+}
+
+func main() {
+	var b [8]byte
+	repro(b[:], 32)
+	want := [8]byte{1, 0, 0, 0, 0, 0, 0, 0}
+	if b != want {
+		panic(fmt.Sprintf("got %v, want %v\n", b, want))
+	}
+}
-- 
GitLab


From 2de1f428570855bd59083a705f832e8bddc0eb51 Mon Sep 17 00:00:00 2001
From: Baokun Lee <bk@golangcn.org>
Date: Tue, 23 Mar 2021 11:18:50 +0800
Subject: [PATCH 1255/2400] net: clear completed Buffers to permit earlier
 collection

Fixes #45163

Change-Id: Ie034145e3818930bb19371d73ec6960cbdc55aa7
Reviewed-on: https://go-review.googlesource.com/c/go/+/303829
Run-TryBot: Baokun Lee <bk@golangcn.org>
Trust: Baokun Lee <bk@golangcn.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/net/net.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/net/net.go b/src/net/net.go
index 4b4ed129cc..7e172b708e 100644
--- a/src/net/net.go
+++ b/src/net/net.go
@@ -733,6 +733,7 @@ func (v *Buffers) consume(n int64) {
 			return
 		}
 		n -= ln0
+		(*v)[0] = nil
 		*v = (*v)[1:]
 	}
 }
-- 
GitLab


From 49dccf141f5e315739c5517b24572fff7cb13734 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Wed, 17 Feb 2021 14:13:01 -0800
Subject: [PATCH 1256/2400] time: add Time.Unix{Milli,Micro} and to-Time
 helpers UnixMicro, UnixMilli

Adds helper functions for users working with other systems which
represent time in milliseconds or microseconds since the Unix epoch.

Fixes #44196

Change-Id: Ibc4490b52ddec94ebd0c692cb7b52a33e4536759
Reviewed-on: https://go-review.googlesource.com/c/go/+/293349
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/time/time.go      | 30 ++++++++++++++++++++++++++++++
 src/time/time_test.go | 38 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 68 insertions(+)

diff --git a/src/time/time.go b/src/time/time.go
index 841f989293..cd756bbf5f 100644
--- a/src/time/time.go
+++ b/src/time/time.go
@@ -1135,6 +1135,24 @@ func (t Time) Unix() int64 {
 	return t.unixSec()
 }
 
+// UnixMilli returns t as a Unix time, the number of milliseconds elapsed since
+// January 1, 1970 UTC. The result is undefined if the Unix time in
+// milliseconds cannot be represented by an int64 (a date more than 292 million
+// years before or after 1970). The result does not depend on the
+// location associated with t.
+func (t Time) UnixMilli() int64 {
+	return t.unixSec()*1e3 + int64(t.nsec())/1e6
+}
+
+// UnixMicro returns t as a Unix time, the number of microseconds elapsed since
+// January 1, 1970 UTC. The result is undefined if the Unix time in
+// microseconds cannot be represented by an int64 (a date before year -290307 or
+// after year 294246). The result does not depend on the location associated
+// with t.
+func (t Time) UnixMicro() int64 {
+	return t.unixSec()*1e6 + int64(t.nsec())/1e3
+}
+
 // UnixNano returns t as a Unix time, the number of nanoseconds elapsed
 // since January 1, 1970 UTC. The result is undefined if the Unix time
 // in nanoseconds cannot be represented by an int64 (a date before the year
@@ -1309,6 +1327,18 @@ func Unix(sec int64, nsec int64) Time {
 	return unixTime(sec, int32(nsec))
 }
 
+// UnixMilli returns the local Time corresponding to the given Unix time,
+// msec milliseconds since January 1, 1970 UTC.
+func UnixMilli(msec int64) Time {
+	return Unix(msec/1e3, (msec%1e3)*1e6)
+}
+
+// UnixMicro returns the local Time corresponding to the given Unix time,
+// usec milliseconds since January 1, 1970 UTC.
+func UnixMicro(usec int64) Time {
+	return Unix(usec/1e6, (usec%1e6)*1e3)
+}
+
 // IsDST reports whether the time in the configured location is in Daylight Savings Time.
 func (t *Time) IsDST() bool {
 	_, _, _, _, isDST := t.loc.lookup(t.Unix())
diff --git a/src/time/time_test.go b/src/time/time_test.go
index 3a58bfe4e9..f272bbd558 100644
--- a/src/time/time_test.go
+++ b/src/time/time_test.go
@@ -202,6 +202,28 @@ func TestNanosecondsToUTCAndBack(t *testing.T) {
 	}
 }
 
+func TestUnixMilli(t *testing.T) {
+	f := func(msec int64) bool {
+		t := UnixMilli(msec)
+		return t.UnixMilli() == msec
+	}
+	cfg := &quick.Config{MaxCount: 10000}
+	if err := quick.Check(f, cfg); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestUnixMicro(t *testing.T) {
+	f := func(usec int64) bool {
+		t := UnixMicro(usec)
+		return t.UnixMicro() == usec
+	}
+	cfg := &quick.Config{MaxCount: 10000}
+	if err := quick.Check(f, cfg); err != nil {
+		t.Fatal(err)
+	}
+}
+
 // The time routines provide no way to get absolute time
 // (seconds since zero), but we need it to compute the right
 // answer for bizarre roundings like "to the nearest 3 ns".
@@ -959,6 +981,8 @@ var mallocTest = []struct {
 }{
 	{0, `time.Now()`, func() { t = Now() }},
 	{0, `time.Now().UnixNano()`, func() { u = Now().UnixNano() }},
+	{0, `time.Now().UnixMilli()`, func() { u = Now().UnixMilli() }},
+	{0, `time.Now().UnixMicro()`, func() { u = Now().UnixMicro() }},
 }
 
 func TestCountMallocs(t *testing.T) {
@@ -1249,6 +1273,8 @@ var defaultLocTests = []struct {
 
 	{"Unix", func(t1, t2 Time) bool { return t1.Unix() == t2.Unix() }},
 	{"UnixNano", func(t1, t2 Time) bool { return t1.UnixNano() == t2.UnixNano() }},
+	{"UnixMilli", func(t1, t2 Time) bool { return t1.UnixMilli() == t2.UnixMilli() }},
+	{"UnixMicro", func(t1, t2 Time) bool { return t1.UnixMicro() == t2.UnixMicro() }},
 
 	{"MarshalBinary", func(t1, t2 Time) bool {
 		a1, b1 := t1.MarshalBinary()
@@ -1301,6 +1327,18 @@ func BenchmarkNowUnixNano(b *testing.B) {
 	}
 }
 
+func BenchmarkNowUnixMilli(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		u = Now().UnixMilli()
+	}
+}
+
+func BenchmarkNowUnixMicro(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		u = Now().UnixMicro()
+	}
+}
+
 func BenchmarkFormat(b *testing.B) {
 	t := Unix(1265346057, 0)
 	for i := 0; i < b.N; i++ {
-- 
GitLab


From 23ffb5b9ae9e6e313df648d8bf6ab7b8f5ff0cf1 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Fri, 26 Mar 2021 23:29:25 +0700
Subject: [PATCH 1257/2400] runtime: overwrite existing keys for
 mapassign_faststr variant

Fixes #45045

Change-Id: Ifcc7bd31591870446ce3e5127489a0b887d413f1
Reviewed-on: https://go-review.googlesource.com/c/go/+/305089
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/runtime/map_faststr.go   |  3 +++
 test/fixedbugs/issue45045.go | 51 ++++++++++++++++++++++++++++++++++++
 2 files changed, 54 insertions(+)
 create mode 100644 test/fixedbugs/issue45045.go

diff --git a/src/runtime/map_faststr.go b/src/runtime/map_faststr.go
index 2d1ac762a8..0673dd39c8 100644
--- a/src/runtime/map_faststr.go
+++ b/src/runtime/map_faststr.go
@@ -255,6 +255,9 @@ bucketloop:
 			// already have a mapping for key. Update it.
 			inserti = i
 			insertb = b
+			// Overwrite existing key, so it can be garbage collected.
+			// The size is already guaranteed to be set correctly.
+			k.str = key.str
 			goto done
 		}
 		ovf := b.overflow(t)
diff --git a/test/fixedbugs/issue45045.go b/test/fixedbugs/issue45045.go
new file mode 100644
index 0000000000..6e6db64839
--- /dev/null
+++ b/test/fixedbugs/issue45045.go
@@ -0,0 +1,51 @@
+// run
+
+// Copyright 2021 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 (
+	"reflect"
+	"runtime"
+	"unsafe"
+)
+
+func k(c chan string, val string) string {
+	b := make([]byte, 1000)
+	runtime.SetFinalizer(&b[0], func(*byte) {
+		c <- val
+	})
+	var s string
+	h := (*reflect.StringHeader)(unsafe.Pointer(&s))
+	h.Data = uintptr(unsafe.Pointer(&b[0]))
+	h.Len = len(b)
+	return s
+}
+
+func main() {
+	{
+		c := make(chan string, 2)
+		m := make(map[string]int)
+		m[k(c, "first")] = 0
+		m[k(c, "second")] = 0
+		runtime.GC()
+		if s := <-c; s != "first" {
+			panic("map[string], second key did not retain.")
+		}
+		runtime.KeepAlive(m)
+	}
+
+	{
+		c := make(chan string, 2)
+		m := make(map[[2]string]int)
+		m[[2]string{k(c, "first")}] = 0
+		m[[2]string{k(c, "second")}] = 0
+		runtime.GC()
+		if s := <-c; s != "first" {
+			panic("map[[2]string], second key did not retain.")
+		}
+		runtime.KeepAlive(m)
+	}
+}
-- 
GitLab


From ba6bd967d2445c4322ef6e37b3144d630109cdfc Mon Sep 17 00:00:00 2001
From: fanzha02 <fannie.zhang@arm.com>
Date: Tue, 28 Jul 2020 10:29:06 +0800
Subject: [PATCH 1258/2400] cmd/compile/internal/ssa: strengthen phiopt pass

The current phiopt pass just transforms the following code
  x := false
  if b { x = true}
into
  x = b

But we find code in runtime.atoi like this:
  neg := false
  if s[0] == '-' {
    neg = true
    s = s[1:]
  }

The current phiopt pass does not covert it into code like:
  neg := s[0] == '-'
  if neg { s = s[1:] }

Therefore, this patch strengthens the phiopt pass so that the
boolean Phi value "neg" can be replaced with a copy of control
value "s[0] == '-'", thereby using "cmp+cset" instead of a branch.

But in some cases even replacing the boolean Phis cannot eliminate
this branch. In the following case, this patch replaces "d" with a
copy of "a<0", but the regalloc pass will insert the "Load {c}"
value into an empty block to split the live ranges, which causes
the branch to not be eliminated.

For example:
  func test(a, b, c int) (bool, int) {
    d := false
    if (a<0) {
      if (b<0) {
        c = c+1
      }
      d = true
    }
    return d, c
  }

The optimized assembly code:
  MOVD "".a(FP), R0
  TBZ $63, R0, 48
  MOVD "".c+16(FP), R1
  ADD $1, R1, R2
  MOVD "".b+8(FP), R3
  CMP ZR, R3
  CSEL LT, R2, R1, R1
  CMP ZR, R0
  CSET LT, R0
  MOVB R0, "".~r3+24(FP)
  MOVD R1, "".~r4+32(FP)
  RET (R30)
  MOVD "".c+16(FP), R1
  JMP 28

The benchmark:

name          old time/op            new time/op            delta
pkg:cmd/compile/internal/ssa goos:linux goarch:arm64
PhioptPass  117783.250000ns +- 1%  117219.111111ns +- 1%   ~  (p=0.074  n=8+9)

Statistical data from compilecmp tool:

compilecmp local/master -> HEAD
local/master (a826f7dc45): debug/dwarf: support DW_FORM_rnglistx aka formRnglistx
HEAD (e57e003c10): cmd/compile/internal/ssa: strengthen phiopt pass

benchstat -geomean  /tmp/2516644532 /tmp/1075915815
completed 50 of 50, estimated time remaining 0s (ETA 7:10PM)
name                      old time/op       new time/op       delta
Template                        554ms _ 3%        553ms _ 3%    ~     (p=0.986 n=49+48)
Unicode                         252ms _ 4%        249ms _ 4%  -1.33%  (p=0.002 n=47+49)
GoTypes                         3.16s _ 3%        3.18s _ 3%  +0.77%  (p=0.022 n=44+48)
Compiler                        257ms _ 4%        258ms _ 4%    ~     (p=0.121 n=50+49)
SSA                             24.2s _ 4%        24.2s _ 5%    ~     (p=0.694 n=49+50)
Flate                           338ms _ 4%        338ms _ 4%    ~     (p=0.592 n=43+46)
GoParser                        506ms _ 3%        507ms _ 3%    ~     (p=0.942 n=49+50)
Reflect                         1.37s _ 4%        1.37s _ 5%    ~     (p=0.408 n=50+50)
Tar                             486ms _ 3%        487ms _ 4%    ~     (p=0.911 n=47+50)
XML                             619ms _ 2%        619ms _ 3%    ~     (p=0.368 n=46+48)
LinkCompiler                    1.29s _31%        1.32s _23%    ~     (p=0.306 n=49+44)
ExternalLinkCompiler            3.39s _10%        3.36s _ 6%    ~     (p=0.311 n=48+46)
LinkWithoutDebugCompiler        846ms _37%        793ms _24%  -6.29%  (p=0.040 n=50+49)
[Geo mean]                      974ms             971ms       -0.36%

name                      old user-time/op  new user-time/op  delta
Template                        910ms _12%        893ms _13%    ~     (p=0.098 n=49+49)
Unicode                         495ms _28%        492ms _18%    ~     (p=0.562 n=50+46)
GoTypes                         4.42s _15%        4.39s _13%    ~     (p=0.684 n=49+50)
Compiler                        419ms _22%        422ms _16%    ~     (p=0.579 n=48+50)
SSA                             36.5s _ 7%        36.6s _ 8%    ~     (p=0.465 n=50+47)
Flate                           521ms _21%        523ms _16%    ~     (p=0.889 n=50+47)
GoParser                        810ms _12%        792ms _15%    ~     (p=0.149 n=50+50)
Reflect                         1.98s _13%        2.02s _13%    ~     (p=0.144 n=47+50)
Tar                             826ms _15%        806ms _19%    ~     (p=0.115 n=49+49)
XML                             988ms _14%       1003ms _14%    ~     (p=0.179 n=50+50)
LinkCompiler                    1.79s _ 8%        1.84s _11%  +2.81%  (p=0.001 n=49+49)
ExternalLinkCompiler            3.69s _ 4%        3.71s _ 3%    ~     (p=0.261 n=50+50)
LinkWithoutDebugCompiler        838ms _10%        827ms _11%    ~     (p=0.323 n=50+48)
[Geo mean]                      1.44s             1.44s       -0.05%

name                      old alloc/op      new alloc/op      delta
Template                       39.0MB _ 1%       39.0MB _ 1%    ~     (p=0.445 n=50+49)
Unicode                        28.5MB _ 0%       28.5MB _ 0%    ~     (p=0.460 n=50+50)
GoTypes                         169MB _ 1%        169MB _ 1%    ~     (p=0.092 n=48+50)
Compiler                       23.4MB _ 1%       23.4MB _ 1%  -0.19%  (p=0.032 n=50+49)
SSA                            1.54GB _ 0%       1.55GB _ 1%  +0.14%  (p=0.001 n=50+50)
Flate                          23.8MB _ 1%       23.8MB _ 2%    ~     (p=0.702 n=49+49)
GoParser                       35.4MB _ 1%       35.4MB _ 1%    ~     (p=0.786 n=50+50)
Reflect                        85.3MB _ 1%       85.3MB _ 1%    ~     (p=0.298 n=50+50)
Tar                            34.6MB _ 2%       34.6MB _ 2%    ~     (p=0.683 n=50+50)
XML                            44.5MB _ 3%       44.0MB _ 2%  -1.05%  (p=0.000 n=50+46)
LinkCompiler                    136MB _ 0%        136MB _ 0%  +0.01%  (p=0.005 n=50+50)
ExternalLinkCompiler            128MB _ 0%        128MB _ 0%    ~     (p=0.179 n=50+50)
LinkWithoutDebugCompiler       84.3MB _ 0%       84.3MB _ 0%  +0.01%  (p=0.006 n=50+50)
[Geo mean]                     70.7MB            70.6MB       -0.07%

name                      old allocs/op     new allocs/op     delta
Template                         410k _ 0%         410k _ 0%    ~     (p=0.606 n=48+49)
Unicode                          310k _ 0%         310k _ 0%    ~     (p=0.674 n=50+50)
GoTypes                         1.81M _ 0%        1.81M _ 0%    ~     (p=0.674 n=50+50)
Compiler                         202k _ 0%         202k _ 0%  +0.02%  (p=0.046 n=50+50)
SSA                             16.3M _ 0%        16.3M _ 0%  +0.10%  (p=0.000 n=50+50)
Flate                            244k _ 0%         244k _ 0%    ~     (p=0.834 n=49+50)
GoParser                         380k _ 0%         380k _ 0%    ~     (p=0.410 n=50+50)
Reflect                         1.08M _ 0%        1.08M _ 0%    ~     (p=0.782 n=48+50)
Tar                              368k _ 0%         368k _ 0%    ~     (p=0.585 n=50+49)
XML                              453k _ 0%         453k _ 0%  -0.01%  (p=0.025 n=49+49)
LinkCompiler                     713k _ 0%         713k _ 0%  +0.01%  (p=0.044 n=50+50)
ExternalLinkCompiler             794k _ 0%         794k _ 0%  +0.01%  (p=0.000 n=50+49)
LinkWithoutDebugCompiler         251k _ 0%         251k _ 0%    ~     (p=0.092 n=47+50)
[Geo mean]                       615k              615k       +0.01%

name                      old maxRSS/op     new maxRSS/op     delta
Template                        37.0M _ 4%        37.2M _ 3%    ~     (p=0.062 n=48+48)
Unicode                         36.9M _ 5%        37.3M _ 4%  +1.10%  (p=0.021 n=50+47)
GoTypes                         94.3M _ 3%        94.9M _ 4%  +0.69%  (p=0.022 n=45+46)
Compiler                        33.4M _ 3%        33.4M _ 5%    ~     (p=0.964 n=49+50)
SSA                              741M _ 3%         738M _ 3%    ~     (p=0.164 n=50+50)
Flate                           28.5M _ 6%        28.8M _ 4%  +1.07%  (p=0.009 n=50+49)
GoParser                        35.0M _ 3%        35.3M _ 4%  +0.83%  (p=0.010 n=50+48)
Reflect                         57.2M _ 6%        57.1M _ 4%    ~     (p=0.815 n=50+49)
Tar                             34.9M _ 3%        35.0M _ 3%    ~     (p=0.134 n=49+48)
XML                             39.5M _ 5%        40.0M _ 3%  +1.35%  (p=0.001 n=50+48)
LinkCompiler                     220M _ 2%         220M _ 2%    ~     (p=0.547 n=49+48)
ExternalLinkCompiler             235M _ 2%         236M _ 2%    ~     (p=0.538 n=47+44)
LinkWithoutDebugCompiler         179M _ 1%         179M _ 1%    ~     (p=0.775 n=50+50)
[Geo mean]                      74.9M             75.2M       +0.43%

name                      old text-bytes    new text-bytes    delta
HelloSize                       784kB _ 0%        784kB _ 0%  +0.01%  (p=0.000 n=50+50)

name                      old data-bytes    new data-bytes    delta
HelloSize                      13.1kB _ 0%       13.1kB _ 0%    ~     (all equal)

name                      old bss-bytes     new bss-bytes     delta
HelloSize                       206kB _ 0%        206kB _ 0%    ~     (all equal)

name                      old exe-bytes     new exe-bytes     delta
HelloSize                      1.28MB _ 0%       1.28MB _ 0%  +0.00%  (p=0.000 n=50+50)

file      before    after     _       %
addr2line 4006300   4004484   -1816   -0.045%
api       5029956   5029324   -632    -0.013%
asm       4936311   4939423   +3112   +0.063%
buildid   2595059   2595291   +232    +0.009%
cgo       4401029   4397333   -3696   -0.084%
compile   22246677  22246863  +186    +0.001%
cover     4443825   4443065   -760    -0.017%
dist      3366078   3365838   -240    -0.007%
doc       3776391   3776615   +224    +0.006%
fix       3218800   3218648   -152    -0.005%
link      6365321   6365345   +24     +0.000%
nm        3923625   3923857   +232    +0.006%
objdump   4295569   4295041   -528    -0.012%
pack      2390745   2389217   -1528   -0.064%
pprof     12870094  12866942  -3152   -0.024%
test2json 2587265   2587073   -192    -0.007%
trace     9612629   9613981   +1352   +0.014%
vet       6791008   6792072   +1064   +0.016%
total     106856682 106850412 -6270   -0.006%

Update #37608

Change-Id: Ic6206b22fd1faf570be9fd3c2511aa6c4ce38cdb
Reviewed-on: https://go-review.googlesource.com/c/go/+/252937
Trust: fannie zhang <Fannie.Zhang@arm.com>
Run-TryBot: fannie zhang <Fannie.Zhang@arm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/ssa/bench_test.go |  32 +++++
 src/cmd/compile/internal/ssa/phiopt.go     | 149 ++++++++++++++++++++-
 src/cmd/compile/internal/ssa/sparsetree.go |   6 +
 test/phiopt.go                             |  26 +++-
 4 files changed, 211 insertions(+), 2 deletions(-)
 create mode 100644 src/cmd/compile/internal/ssa/bench_test.go

diff --git a/src/cmd/compile/internal/ssa/bench_test.go b/src/cmd/compile/internal/ssa/bench_test.go
new file mode 100644
index 0000000000..0971667507
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/bench_test.go
@@ -0,0 +1,32 @@
+// Copyright 2020 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 ssa
+
+import (
+	"math/rand"
+	"testing"
+)
+
+var d int
+
+//go:noinline
+func fn(a, b int) bool {
+	c := false
+	if a > 0 {
+		if b < 0 {
+			d = d + 1
+		}
+		c = true
+	}
+	return c
+}
+
+func BenchmarkPhioptPass(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		a := rand.Perm(i/10 + 10)
+		for i := 1; i < len(a)/2; i++ {
+			fn(a[i]-a[i-1], a[i+len(a)/2-2]-a[i+len(a)/2-1])
+		}
+	}
+}
diff --git a/src/cmd/compile/internal/ssa/phiopt.go b/src/cmd/compile/internal/ssa/phiopt.go
index db7b02275c..ee583d0225 100644
--- a/src/cmd/compile/internal/ssa/phiopt.go
+++ b/src/cmd/compile/internal/ssa/phiopt.go
@@ -46,7 +46,6 @@ func phiopt(f *Func) {
 			continue
 		}
 		// b0 is the if block giving the boolean value.
-
 		// reverse is the predecessor from which the truth value comes.
 		var reverse int
 		if b0.Succs[0].b == pb0 && b0.Succs[1].b == pb1 {
@@ -120,6 +119,141 @@ func phiopt(f *Func) {
 			}
 		}
 	}
+	// strengthen phi optimization.
+	// Main use case is to transform:
+	//   x := false
+	//   if c {
+	//     x = true
+	//     ...
+	//   }
+	// into
+	//   x := c
+	//   if x { ... }
+	//
+	// For example, in SSA code a case appears as
+	// b0
+	//   If c -> b, sb0
+	// sb0
+	//   If d -> sd0, sd1
+	// sd1
+	//   ...
+	// sd0
+	//   Plain -> b
+	// b
+	//   x = (OpPhi (ConstBool [true]) (ConstBool [false]))
+	//
+	// In this case we can also replace x with a copy of c.
+	//
+	// The optimization idea:
+	// 1. block b has a phi value x, x = OpPhi (ConstBool [true]) (ConstBool [false]),
+	//    and len(b.Preds) is equal to 2.
+	// 2. find the common dominator(b0) of the predecessors(pb0, pb1) of block b, and the
+	//    dominator(b0) is a If block.
+	//    Special case: one of the predecessors(pb0 or pb1) is the dominator(b0).
+	// 3. the successors(sb0, sb1) of the dominator need to dominate the predecessors(pb0, pb1)
+	//    of block b respectively.
+	// 4. replace this boolean Phi based on dominator block.
+	//
+	//     b0(pb0)            b0(pb1)          b0
+	//    |  \               /  |             /  \
+	//    |  sb1           sb0  |           sb0  sb1
+	//    |  ...           ...  |           ...   ...
+	//    |  pb1           pb0  |           pb0  pb1
+	//    |  /               \  |            \   /
+	//     b                   b               b
+	//
+	var lca *lcaRange
+	for _, b := range f.Blocks {
+		if len(b.Preds) != 2 || len(b.Values) == 0 {
+			// TODO: handle more than 2 predecessors, e.g. a || b || c.
+			continue
+		}
+
+		for _, v := range b.Values {
+			// find a phi value v = OpPhi (ConstBool [true]) (ConstBool [false]).
+			// TODO: v = OpPhi (ConstBool [true]) (Arg <bool> {value})
+			if v.Op != OpPhi {
+				continue
+			}
+			if v.Args[0].Op != OpConstBool || v.Args[1].Op != OpConstBool {
+				continue
+			}
+			if v.Args[0].AuxInt == v.Args[1].AuxInt {
+				continue
+			}
+
+			pb0 := b.Preds[0].b
+			pb1 := b.Preds[1].b
+			if pb0.Kind == BlockIf && pb0 == sdom.Parent(b) {
+				// special case: pb0 is the dominator block b0.
+				//     b0(pb0)
+				//    |  \
+				//    |  sb1
+				//    |  ...
+				//    |  pb1
+				//    |  /
+				//     b
+				// if another successor sb1 of b0(pb0) dominates pb1, do replace.
+				ei := b.Preds[0].i
+				sb1 := pb0.Succs[1-ei].b
+				if sdom.IsAncestorEq(sb1, pb1) {
+					convertPhi(pb0, v, ei)
+					break
+				}
+			} else if pb1.Kind == BlockIf && pb1 == sdom.Parent(b) {
+				// special case: pb1 is the dominator block b0.
+				//       b0(pb1)
+				//     /   |
+				//    sb0  |
+				//    ...  |
+				//    pb0  |
+				//      \  |
+				//        b
+				// if another successor sb0 of b0(pb0) dominates pb0, do replace.
+				ei := b.Preds[1].i
+				sb0 := pb1.Succs[1-ei].b
+				if sdom.IsAncestorEq(sb0, pb0) {
+					convertPhi(pb1, v, ei-1)
+					break
+				}
+			} else {
+				//      b0
+				//     /   \
+				//    sb0  sb1
+				//    ...  ...
+				//    pb0  pb1
+				//      \   /
+				//        b
+				//
+				// Build data structure for fast least-common-ancestor queries.
+				if lca == nil {
+					lca = makeLCArange(f)
+				}
+				b0 := lca.find(pb0, pb1)
+				if b0.Kind != BlockIf {
+					break
+				}
+				sb0 := b0.Succs[0].b
+				sb1 := b0.Succs[1].b
+				var reverse int
+				if sdom.IsAncestorEq(sb0, pb0) && sdom.IsAncestorEq(sb1, pb1) {
+					reverse = 0
+				} else if sdom.IsAncestorEq(sb1, pb0) && sdom.IsAncestorEq(sb0, pb1) {
+					reverse = 1
+				} else {
+					break
+				}
+				if len(sb0.Preds) != 1 || len(sb1.Preds) != 1 {
+					// we can not replace phi value x in the following case.
+					//   if gp == nil || sp < lo { x = true}
+					//   if a || b { x = true }
+					// so the if statement can only have one condition.
+					break
+				}
+				convertPhi(b0, v, reverse)
+			}
+		}
+	}
 }
 
 func phioptint(v *Value, b0 *Block, reverse int) {
@@ -174,3 +308,16 @@ func phioptint(v *Value, b0 *Block, reverse int) {
 		f.Warnl(v.Block.Pos, "converted OpPhi bool -> int%d", v.Type.Size()*8)
 	}
 }
+
+// b is the If block giving the boolean value.
+// v is the phi value v = (OpPhi (ConstBool [true]) (ConstBool [false])).
+// reverse is the predecessor from which the truth value comes.
+func convertPhi(b *Block, v *Value, reverse int) {
+	f := b.Func
+	ops := [2]Op{OpNot, OpCopy}
+	v.reset(ops[v.Args[reverse].AuxInt])
+	v.AddArg(b.Controls[0])
+	if f.pass.debug > 0 {
+		f.Warnl(b.Pos, "converted OpPhi to %v", v.Op)
+	}
+}
diff --git a/src/cmd/compile/internal/ssa/sparsetree.go b/src/cmd/compile/internal/ssa/sparsetree.go
index 1be20b2cda..be914c8644 100644
--- a/src/cmd/compile/internal/ssa/sparsetree.go
+++ b/src/cmd/compile/internal/ssa/sparsetree.go
@@ -178,6 +178,12 @@ func (t SparseTree) Child(x *Block) *Block {
 	return t[x.ID].child
 }
 
+// Parent returns the parent of x in the dominator tree, or
+// nil if x is the function's entry.
+func (t SparseTree) Parent(x *Block) *Block {
+	return t[x.ID].parent
+}
+
 // isAncestorEq reports whether x is an ancestor of or equal to y.
 func (t SparseTree) IsAncestorEq(x, y *Block) bool {
 	if x == y {
diff --git a/test/phiopt.go b/test/phiopt.go
index 98a7b75d10..e04373eb72 100644
--- a/test/phiopt.go
+++ b/test/phiopt.go
@@ -1,4 +1,4 @@
-// +build amd64 s390x
+// +build amd64 s390x arm64
 // errorcheck -0 -d=ssa/phiopt/debug=3
 
 // Copyright 2016 The Go Authors. All rights reserved.
@@ -104,5 +104,29 @@ func f7and(a bool, b bool) bool {
 	return a && b // ERROR "converted OpPhi to AndB$"
 }
 
+//go:noinline
+func f8(s string) (string, bool) {
+	neg := false
+	if s[0] == '-' {    // ERROR "converted OpPhi to Copy$"
+		neg = true
+		s = s[1:]
+	}
+	return s, neg
+}
+
+var d int
+
+//go:noinline
+func f9(a, b int) bool {
+	c := false
+	if a < 0 {          // ERROR "converted OpPhi to Copy$"
+		if b < 0 {
+			d = d + 1
+		}
+		c = true
+	}
+	return c
+}
+
 func main() {
 }
-- 
GitLab


From d10241fcf63826d51e8d9c914ab0ad2ef9173151 Mon Sep 17 00:00:00 2001
From: qcrao <qcrao91@gmail.com>
Date: Sun, 28 Mar 2021 12:17:35 +0000
Subject: [PATCH 1259/2400] runtime: fix some typos

Change-Id: I18b9508904f19d5aa68355c937c30b5fdf35442c
Reviewed-on: https://go-review.googlesource.com/c/go/+/305249
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/proc.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 35996b99d7..89d36321a6 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -5316,7 +5316,7 @@ func preemptall() bool {
 
 // Tell the goroutine running on processor P to stop.
 // This function is purely best-effort. It can incorrectly fail to inform the
-// goroutine. It can send inform the wrong goroutine. Even if it informs the
+// goroutine. It can inform the wrong goroutine. Even if it informs the
 // correct goroutine, that goroutine might ignore the request if it is
 // simultaneously executing newstack.
 // No lock needs to be held.
@@ -5336,7 +5336,7 @@ func preemptone(_p_ *p) bool {
 
 	gp.preempt = true
 
-	// Every call in a go routine checks for stack overflow by
+	// Every call in a goroutine checks for stack overflow by
 	// comparing the current stack pointer to gp->stackguard0.
 	// Setting gp->stackguard0 to StackPreempt folds
 	// preemption into the normal stack overflow check.
@@ -6186,7 +6186,7 @@ var inittrace tracestat
 
 type tracestat struct {
 	active bool   // init tracing activation status
-	id     int64  // init go routine id
+	id     int64  // init goroutine id
 	allocs uint64 // heap allocations
 	bytes  uint64 // heap allocated bytes
 }
@@ -6218,7 +6218,7 @@ func doInit(t *initTask) {
 
 		if inittrace.active {
 			start = nanotime()
-			// Load stats non-atomically since tracinit is updated only by this init go routine.
+			// Load stats non-atomically since tracinit is updated only by this init goroutine.
 			before = inittrace
 		}
 
-- 
GitLab


From 6f90ee36e90cb6a6adfd29ee51f0ef8f7e507003 Mon Sep 17 00:00:00 2001
From: smasher164 <aindurti@gmail.com>
Date: Thu, 6 Aug 2020 18:37:10 -0400
Subject: [PATCH 1260/2400] math: simplify comparison in FMA when swapping p
 and z

Discovered by Junchen Li on CL 246858, the comparison before p and z are
swapped can be simplified from

    pe < ze || (pe == ze && (pm1 < zm1 || (pm1 == zm1 && pm2 < zm2)))

to

    pe < ze || pe == ze && pm1 < zm1

because zm2 is initialized to 0 before the branch.

Change-Id: Iee92d570038df2b0f8941ef6e422a022654ab2d6
Reviewed-on: https://go-review.googlesource.com/c/go/+/247241
Run-TryBot: Akhil Indurti <aindurti@gmail.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/math/fma.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/math/fma.go b/src/math/fma.go
index db78dfa5e1..ca0bf99f21 100644
--- a/src/math/fma.go
+++ b/src/math/fma.go
@@ -128,7 +128,7 @@ func FMA(x, y, z float64) float64 {
 	pe -= int32(is62zero)
 
 	// Swap addition operands so |p| >= |z|
-	if pe < ze || (pe == ze && (pm1 < zm1 || (pm1 == zm1 && pm2 < zm2))) {
+	if pe < ze || pe == ze && pm1 < zm1 {
 		ps, pe, pm1, pm2, zs, ze, zm1, zm2 = zs, ze, zm1, zm2, ps, pe, pm1, pm2
 	}
 
-- 
GitLab


From 565e70fcefd63c1f57989a0f794bf7c8bb4cf5ec Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Fri, 26 Mar 2021 11:00:40 +0100
Subject: [PATCH 1261/2400] cmd/link/internal/ld: use linkerFlagSupported to
 check -Qunused-arguments

Rather than checking the linker name or its path for the string "clang",
use linkerFlagSupported to determine whether the -Qunused-arguments flag
may be passed to the linker.

Fixes #45241

Change-Id: I4c1e4d4ecba4cf5823e8f39cfda5d20404ebf513
Reviewed-on: https://go-review.googlesource.com/c/go/+/304692
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/ld/lib.go | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index c80c29a6a8..85d0eedecf 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -1475,8 +1475,9 @@ func (ctxt *Link) hostlink() {
 		argv = append(argv, "-Wl,-bE:"+fileName)
 	}
 
-	if strings.Contains(argv[0], "clang") {
-		argv = append(argv, "-Qunused-arguments")
+	const unusedArguments = "-Qunused-arguments"
+	if linkerFlagSupported(ctxt.Arch, argv[0], altLinker, unusedArguments) {
+		argv = append(argv, unusedArguments)
 	}
 
 	const compressDWARF = "-Wl,--compress-debug-sections=zlib-gnu"
-- 
GitLab


From 8f676144ad7b7c91adb0c6e1ec89aaa6283c6807 Mon Sep 17 00:00:00 2001
From: Himanshu Kishna Srivastava <28himanshu@gmail.com>
Date: Tue, 16 Mar 2021 22:37:46 +0530
Subject: [PATCH 1262/2400] crypto/rsa: fix salt length calculation with
 PSSSaltLengthAuto

When PSSSaltLength is set, the maximum salt length must equal:

    (modulus_key_size - 1 + 7)/8 - hash_length - 2
and for example, with a 4096 bit modulus key, and a SHA-1 hash,
it should be:

     (4096 -1 + 7)/8 - 20 - 2 = 490
Previously we'd encounter this error:

     crypto/rsa: key size too small for PSS signature

Fixes #42741

Change-Id: I18bb82c41c511d564b3f4c443f4b3a38ab010ac5
Reviewed-on: https://go-review.googlesource.com/c/go/+/302230
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/crypto/rsa/pss.go      |  2 +-
 src/crypto/rsa/pss_test.go | 20 +++++++++++++++++++-
 2 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/src/crypto/rsa/pss.go b/src/crypto/rsa/pss.go
index b2adbedb28..814522de81 100644
--- a/src/crypto/rsa/pss.go
+++ b/src/crypto/rsa/pss.go
@@ -269,7 +269,7 @@ func SignPSS(rand io.Reader, priv *PrivateKey, hash crypto.Hash, digest []byte,
 	saltLength := opts.saltLength()
 	switch saltLength {
 	case PSSSaltLengthAuto:
-		saltLength = priv.Size() - 2 - hash.Size()
+		saltLength = (priv.N.BitLen()-1+7)/8 - 2 - hash.Size()
 	case PSSSaltLengthEqualsHash:
 		saltLength = hash.Size()
 	}
diff --git a/src/crypto/rsa/pss_test.go b/src/crypto/rsa/pss_test.go
index dfa8d8bb5a..c3a6d46849 100644
--- a/src/crypto/rsa/pss_test.go
+++ b/src/crypto/rsa/pss_test.go
@@ -12,7 +12,7 @@ import (
 	_ "crypto/md5"
 	"crypto/rand"
 	"crypto/sha1"
-	_ "crypto/sha256"
+	"crypto/sha256"
 	"encoding/hex"
 	"math/big"
 	"os"
@@ -233,6 +233,24 @@ func TestPSSSigning(t *testing.T) {
 	}
 }
 
+func TestSignWithPSSSaltLengthAuto(t *testing.T) {
+	key, err := GenerateKey(rand.Reader, 513)
+	if err != nil {
+		t.Fatal(err)
+	}
+	digest := sha256.Sum256([]byte("message"))
+	signature, err := key.Sign(rand.Reader, digest[:], &PSSOptions{
+		SaltLength: PSSSaltLengthAuto,
+		Hash:       crypto.SHA256,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(signature) == 0 {
+		t.Fatal("empty signature returned")
+	}
+}
+
 func bigFromHex(hex string) *big.Int {
 	n, ok := new(big.Int).SetString(hex, 16)
 	if !ok {
-- 
GitLab


From 2abf280a282a24486a819b0a916dd77c50b48d22 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 25 Mar 2021 12:31:25 -0700
Subject: [PATCH 1263/2400] cmd/compile/internal/types2: remove 'strict'
 argument from several methods

The value is always 'false'. Brings the code closer in line with go/types.
Follow-up on https://golang.org/cl/304129.

Change-Id: I8bea550033f3187b44e9a54258e0cf642c11c369
Reviewed-on: https://go-review.googlesource.com/c/go/+/304849
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/api.go    | 2 +-
 src/cmd/compile/internal/types2/expr.go   | 6 +++---
 src/cmd/compile/internal/types2/lookup.go | 8 ++++----
 src/cmd/compile/internal/types2/stmt.go   | 6 +++---
 4 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/cmd/compile/internal/types2/api.go b/src/cmd/compile/internal/types2/api.go
index 19adaba578..d356978d5e 100644
--- a/src/cmd/compile/internal/types2/api.go
+++ b/src/cmd/compile/internal/types2/api.go
@@ -405,7 +405,7 @@ func (conf *Config) Check(path string, files []*syntax.File, info *Info) (*Packa
 
 // AssertableTo reports whether a value of type V can be asserted to have type T.
 func AssertableTo(V *Interface, T Type) bool {
-	m, _ := (*Checker)(nil).assertableTo(V, T, false)
+	m, _ := (*Checker)(nil).assertableTo(V, T)
 	return m == nil
 }
 
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 2eb4ded465..b5ffdf34c2 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -1790,7 +1790,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 		if T == Typ[Invalid] {
 			goto Error
 		}
-		check.typeAssertion(posFor(x), x, xtyp, T, false)
+		check.typeAssertion(posFor(x), x, xtyp, T)
 		x.mode = commaok
 		x.typ = T
 
@@ -1916,8 +1916,8 @@ func keyVal(x constant.Value) interface{} {
 }
 
 // typeAssertion checks that x.(T) is legal; xtyp must be the type of x.
-func (check *Checker) typeAssertion(pos syntax.Pos, x *operand, xtyp *Interface, T Type, strict bool) {
-	method, wrongType := check.assertableTo(xtyp, T, strict)
+func (check *Checker) typeAssertion(pos syntax.Pos, x *operand, xtyp *Interface, T Type) {
+	method, wrongType := check.assertableTo(xtyp, T)
 	if method == nil {
 		return
 	}
diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go
index a62def4183..cadaf05ca8 100644
--- a/src/cmd/compile/internal/types2/lookup.go
+++ b/src/cmd/compile/internal/types2/lookup.go
@@ -427,13 +427,13 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
 // method required by V and whether it is missing or just has the wrong type.
 // The receiver may be nil if assertableTo is invoked through an exported API call
 // (such as AssertableTo), i.e., when all methods have been type-checked.
-// If strict (or the global constant forceStrict) is set, assertions that
-// are known to fail are not permitted.
-func (check *Checker) assertableTo(V *Interface, T Type, strict bool) (method, wrongType *Func) {
+// If the global constant forceStrict is set, assertions that are known to fail
+// are not permitted.
+func (check *Checker) assertableTo(V *Interface, T Type) (method, wrongType *Func) {
 	// no static check is required if T is an interface
 	// spec: "If T is an interface type, x.(T) asserts that the
 	//        dynamic type of x implements the interface T."
-	if asInterface(T) != nil && !(strict || forceStrict) {
+	if asInterface(T) != nil && !forceStrict {
 		return
 	}
 	return check.missingMethod(T, V, false)
diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go
index bf3c9dfa5f..367146b528 100644
--- a/src/cmd/compile/internal/types2/stmt.go
+++ b/src/cmd/compile/internal/types2/stmt.go
@@ -265,7 +265,7 @@ L:
 	}
 }
 
-func (check *Checker) caseTypes(x *operand, xtyp *Interface, types []syntax.Expr, seen map[Type]syntax.Pos, strict bool) (T Type) {
+func (check *Checker) caseTypes(x *operand, xtyp *Interface, types []syntax.Expr, seen map[Type]syntax.Pos) (T Type) {
 L:
 	for _, e := range types {
 		T = check.typOrNil(e)
@@ -293,7 +293,7 @@ L:
 		}
 		seen[T] = e.Pos()
 		if T != nil {
-			check.typeAssertion(e.Pos(), x, xtyp, T, strict)
+			check.typeAssertion(e.Pos(), x, xtyp, T)
 		}
 	}
 	return
@@ -708,7 +708,7 @@ func (check *Checker) typeSwitchStmt(inner stmtContext, s *syntax.SwitchStmt, gu
 		}
 		// Check each type in this type switch case.
 		cases := unpackExpr(clause.Cases)
-		T := check.caseTypes(&x, xtyp, cases, seen, false)
+		T := check.caseTypes(&x, xtyp, cases, seen)
 		check.openScopeUntil(clause, end, "case")
 		// If lhs exists, declare a corresponding variable in the case-local scope.
 		if lhs != nil {
-- 
GitLab


From 1a7d921aa545bb888e06ec7af364c86e919e399f Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Thu, 25 Mar 2021 12:23:44 -0700
Subject: [PATCH 1264/2400] cmd/compile: remove typechecker calls in varDecl()

We can now use transformAssign.

The only remaining typechecker calls in the noder2 pass are for
CompLitExpr nodes (OCOMPLIT).

Change-Id: I25671c79cc30749767bb16f84e9f151b943eccd1
Reviewed-on: https://go-review.googlesource.com/c/go/+/305509
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/noder/decl.go    | 17 +++++++++++++++--
 src/cmd/compile/internal/noder/expr.go    |  1 -
 src/cmd/compile/internal/noder/helpers.go |  4 ----
 3 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/src/cmd/compile/internal/noder/decl.go b/src/cmd/compile/internal/noder/decl.go
index f0cdcbfc2e..4ca2eb4740 100644
--- a/src/cmd/compile/internal/noder/decl.go
+++ b/src/cmd/compile/internal/noder/decl.go
@@ -211,11 +211,24 @@ func (g *irgen) varDecl(out *ir.Nodes, decl *syntax.VarDecl) {
 			} else if ir.CurFunc == nil {
 				name.Defn = as
 			}
-			out.Append(typecheck.Stmt(as))
+			lhs := []ir.Node{as.X}
+			rhs := []ir.Node{}
+			if as.Y != nil {
+				rhs = []ir.Node{as.Y}
+			}
+			transformAssign(as, lhs, rhs)
+			as.X = lhs[0]
+			if as.Y != nil {
+				as.Y = rhs[0]
+			}
+			as.SetTypecheck(1)
+			out.Append(as)
 		}
 	}
 	if as2 != nil {
-		out.Append(typecheck.Stmt(as2))
+		transformAssign(as2, as2.Lhs, as2.Rhs)
+		as2.SetTypecheck(1)
+		out.Append(as2)
 	}
 }
 
diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index effc63c09a..9db03a9005 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -15,7 +15,6 @@ import (
 )
 
 func (g *irgen) expr(expr syntax.Expr) ir.Node {
-	// TODO(mdempsky): Change callers to not call on nil?
 	if expr == nil {
 		return nil
 	}
diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
index 9ebf17aae6..cb8052c0cb 100644
--- a/src/cmd/compile/internal/noder/helpers.go
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -18,10 +18,6 @@ import (
 //
 // TODO(mdempsky): Move into their own package so they can be easily
 // reused by iimport and frontend optimizations.
-//
-// TODO(mdempsky): Update to consistently return already typechecked
-// results, rather than leaving the caller responsible for using
-// typecheck.Expr or typecheck.Stmt.
 
 type ImplicitNode interface {
 	ir.Node
-- 
GitLab


From 24764496c7f7f58867a46aec7192b9425a3fea08 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 29 Mar 2021 11:32:50 -0700
Subject: [PATCH 1265/2400] go/types: remove outdated comment

dev.typeparams is not used anymore for active development.

Change-Id: Ic773cbc70e3532375d75b6c6caa31f55f7c733b0
Reviewed-on: https://go-review.googlesource.com/c/go/+/305569
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/go/types/errorcodes.go | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/go/types/errorcodes.go b/src/go/types/errorcodes.go
index 4d9db18f9c..257fc4eff4 100644
--- a/src/go/types/errorcodes.go
+++ b/src/go/types/errorcodes.go
@@ -6,9 +6,6 @@ package types
 
 type errorCode int
 
-// TODO(rFindley): ensure that existing error codes do not change in the
-//                 dev.typeparams branch.
-
 // This file defines the error codes that can be produced during type-checking.
 // Collectively, these codes provide an identifier that may be used to
 // implement special handling for certain types of errors.
-- 
GitLab


From 2ba296da47fe4b3c70be0aea291e307cdb2c7dbe Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Fri, 19 Mar 2021 14:55:23 -0400
Subject: [PATCH 1266/2400] cmd/compile: update a few stale comments

CL 64811 removed dcopy. Update the comment in types.Sym.

The Russquake moved iexport.go. Update the path to it.

WRAPPER is now also used by ABI wrappers, so update the comment since
it's now more general than method wrappers.

Change-Id: Ie0df61dcef7168f6720838cd5c9a66adf546a44f
Reviewed-on: https://go-review.googlesource.com/c/go/+/305269
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/importer/iimport.go | 2 +-
 src/cmd/compile/internal/ir/func.go          | 2 +-
 src/cmd/compile/internal/types/sym.go        | 2 +-
 src/cmd/internal/obj/textflag.go             | 3 ++-
 4 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/importer/iimport.go b/src/cmd/compile/internal/importer/iimport.go
index 33c46a0f90..8ab0b7b989 100644
--- a/src/cmd/compile/internal/importer/iimport.go
+++ b/src/cmd/compile/internal/importer/iimport.go
@@ -4,7 +4,7 @@
 // license that can be found in the LICENSE file.
 
 // Indexed package import.
-// See cmd/compile/internal/gc/iexport.go for the export data format.
+// See cmd/compile/internal/typecheck/iexport.go for the export data format.
 
 package importer
 
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 0a9db92d96..c17425a4da 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -162,7 +162,7 @@ type ScopeID int32
 
 const (
 	funcDupok         = 1 << iota // duplicate definitions ok
-	funcWrapper                   // is method wrapper
+	funcWrapper                   // hide frame from users (elide in tracebacks, don't count as a frame for recover())
 	funcNeedctxt                  // function uses context register (has closure variables)
 	funcReflectMethod             // function calls reflect.Type.Method or MethodByName
 	// true if closure inside a function; false if a simple function or a
diff --git a/src/cmd/compile/internal/types/sym.go b/src/cmd/compile/internal/types/sym.go
index 0e66ed348b..c689304b34 100644
--- a/src/cmd/compile/internal/types/sym.go
+++ b/src/cmd/compile/internal/types/sym.go
@@ -32,7 +32,7 @@ type Sym struct {
 	Pkg  *Pkg
 	Name string // object name
 
-	// saved and restored by dcopy
+	// saved and restored by Pushdcl/Popdcl
 	Def        Object   // definition: ONAME OTYPE OPACK or OLITERAL
 	Block      int32    // blocknumber to catch redeclaration
 	Lastlineno src.XPos // last declaration for diagnostic
diff --git a/src/cmd/internal/obj/textflag.go b/src/cmd/internal/obj/textflag.go
index 2f55793285..881e192203 100644
--- a/src/cmd/internal/obj/textflag.go
+++ b/src/cmd/internal/obj/textflag.go
@@ -27,7 +27,8 @@ const (
 	// This data contains no pointers.
 	NOPTR = 16
 
-	// This is a wrapper function and should not count as disabling 'recover'.
+	// This is a wrapper function and should not count as
+	// disabling 'recover' or appear in tracebacks by default.
 	WRAPPER = 32
 
 	// This function uses its incoming context register.
-- 
GitLab


From 33b4ffc3573eb81854591d39f1029dabacbdec72 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Wed, 24 Mar 2021 14:28:18 -0400
Subject: [PATCH 1267/2400] cmd/compile: track funcsyms by ir.Name instead of
 types.Sym

This is a cleanup to bring funcsym tracking a little closer to the
ir.Func. (I thought I needed this for a later change. That turned out
not to be the case, but it's a nice cleanup.)

Change-Id: I53e692f5d7ba4be56d42d8e0aefc06284cea0661
Reviewed-on: https://go-review.googlesource.com/c/go/+/305270
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssagen/abi.go      |  2 +-
 src/cmd/compile/internal/staticdata/data.go | 35 +++++++++++----------
 2 files changed, 19 insertions(+), 18 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/abi.go b/src/cmd/compile/internal/ssagen/abi.go
index 6d391ed9f7..b6137756d4 100644
--- a/src/cmd/compile/internal/ssagen/abi.go
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -143,7 +143,7 @@ func InitLSym(f *ir.Func, hasBody bool) {
 	if f.LSym != nil && objabi.Experiment.RegabiWrappers {
 		return
 	}
-	staticdata.NeedFuncSym(f.Sym())
+	staticdata.NeedFuncSym(f)
 	selectLSym(f, hasBody)
 	if hasBody {
 		setupTextLSym(f, 0)
diff --git a/src/cmd/compile/internal/staticdata/data.go b/src/cmd/compile/internal/staticdata/data.go
index b06fd7aa4b..fca2a63eb4 100644
--- a/src/cmd/compile/internal/staticdata/data.go
+++ b/src/cmd/compile/internal/staticdata/data.go
@@ -214,11 +214,16 @@ func dstringdata(s *obj.LSym, off int, t string, pos src.XPos, what string) int
 
 var (
 	funcsymsmu sync.Mutex // protects funcsyms and associated package lookups (see func funcsym)
-	funcsyms   []*types.Sym
+	funcsyms   []*ir.Name // functions that need function value symbols
 )
 
-// FuncSym returns s·f.
-func FuncSym(s *types.Sym) *types.Sym {
+// FuncLinksym returns n·f, the function value symbol for n.
+func FuncLinksym(n *ir.Name) *obj.LSym {
+	if n.Op() != ir.ONAME || n.Class != ir.PFUNC {
+		base.Fatalf("expected func name: %v", n)
+	}
+	s := n.Sym()
+
 	// funcsymsmu here serves to protect not just mutations of funcsyms (below),
 	// but also the package lookup of the func sym name,
 	// since this function gets called concurrently from the backend.
@@ -235,17 +240,11 @@ func FuncSym(s *types.Sym) *types.Sym {
 	// symbols will be created explicitly with NeedFuncSym.
 	// See the NeedFuncSym comment for details.
 	if !base.Ctxt.Flag_dynlink && !existed {
-		funcsyms = append(funcsyms, s)
+		funcsyms = append(funcsyms, n)
 	}
 	funcsymsmu.Unlock()
-	return sf
-}
 
-func FuncLinksym(n *ir.Name) *obj.LSym {
-	if n.Op() != ir.ONAME || n.Class != ir.PFUNC {
-		base.Fatalf("expected func name: %v", n)
-	}
-	return FuncSym(n.Sym()).Linksym()
+	return sf.Linksym()
 }
 
 func GlobalLinksym(n *ir.Name) *obj.LSym {
@@ -255,16 +254,16 @@ func GlobalLinksym(n *ir.Name) *obj.LSym {
 	return n.Linksym()
 }
 
-// NeedFuncSym ensures that s·f is exported, if needed.
+// NeedFuncSym ensures that fn·f is exported, if needed.
 // It is only used with -dynlink.
 // When not compiling for dynamic linking,
 // the funcsyms are created as needed by
 // the packages that use them.
-// Normally we emit the s·f stubs as DUPOK syms,
+// Normally we emit the fn·f stubs as DUPOK syms,
 // but DUPOK doesn't work across shared library boundaries.
 // So instead, when dynamic linking, we only create
-// the s·f stubs in s's package.
-func NeedFuncSym(s *types.Sym) {
+// the fn·f stubs in fn's package.
+func NeedFuncSym(fn *ir.Func) {
 	if base.Ctxt.InParallel {
 		// The append below probably just needs to lock
 		// funcsymsmu, like in FuncSym.
@@ -273,6 +272,7 @@ func NeedFuncSym(s *types.Sym) {
 	if !base.Ctxt.Flag_dynlink {
 		return
 	}
+	s := fn.Nname.Sym()
 	if s.IsBlank() {
 		return
 	}
@@ -282,14 +282,15 @@ func NeedFuncSym(s *types.Sym) {
 		// get funcsyms.
 		return
 	}
-	funcsyms = append(funcsyms, s)
+	funcsyms = append(funcsyms, fn.Nname)
 }
 
 func WriteFuncSyms() {
 	sort.Slice(funcsyms, func(i, j int) bool {
 		return funcsyms[i].Linksym().Name < funcsyms[j].Linksym().Name
 	})
-	for _, s := range funcsyms {
+	for _, nam := range funcsyms {
+		s := nam.Sym()
 		sf := s.Pkg.Lookup(ir.FuncSymName(s)).Linksym()
 		objw.SymPtr(sf, 0, s.Linksym(), 0)
 		objw.Global(sf, int32(types.PtrSize), obj.DUPOK|obj.RODATA)
-- 
GitLab


From 0d1423583b9106d398740862bca4ad5661fd67ad Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Sat, 27 Mar 2021 10:14:30 -0400
Subject: [PATCH 1268/2400] cmd/compile: set ir.Name.Func in more cases

ir.Name.Func is non-nil for *almost* all function names. This CL fixes
a few more major cases that leave it nil, though there are still a few
cases left: interface method values, and algorithms generated by
eqFor, hashfor, and hashmem.

We'll need this for mapping from ir.Names to function ABIs shortly.
The remaining cases would be nice to fix, but they're all guaranteed
to be ABIInternal, so we can at least work around them.

For #40724.

Change-Id: Ifcfa781c78899ccea0bf155d80f8cfc27f30351e
Reviewed-on: https://go-review.googlesource.com/c/go/+/305271
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ir/expr.go             | 7 +++++++
 src/cmd/compile/internal/ir/name.go             | 2 +-
 src/cmd/compile/internal/reflectdata/alg.go     | 2 ++
 src/cmd/compile/internal/reflectdata/reflect.go | 3 +++
 src/cmd/compile/internal/typecheck/syms.go      | 1 +
 src/cmd/compile/internal/walk/compare.go        | 1 +
 6 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 49b9fa8e54..c95ea36909 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -528,6 +528,13 @@ func (n *SelectorExpr) FuncName() *Name {
 	fn := NewNameAt(n.Selection.Pos, MethodSym(n.X.Type(), n.Sel))
 	fn.Class = PFUNC
 	fn.SetType(n.Type())
+	if n.Selection.Nname != nil {
+		// TODO(austin): Nname is nil for interface method
+		// expressions (I.M), so we can't attach a Func to
+		// those here. reflectdata.methodWrapper generates the
+		// Func.
+		fn.Func = n.Selection.Nname.(*Name).Func
+	}
 	return fn
 }
 
diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 5738aa1f3f..5697213eac 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -41,7 +41,7 @@ type Name struct {
 	pragma    PragmaFlag // int16
 	flags     bitset16
 	sym       *types.Sym
-	Func      *Func
+	Func      *Func // TODO(austin): nil for I.M, eqFor, hashfor, and hashmem
 	Offset_   int64
 	val       constant.Value
 	Opt       interface{} // for use by escape analysis
diff --git a/src/cmd/compile/internal/reflectdata/alg.go b/src/cmd/compile/internal/reflectdata/alg.go
index faa431a9d1..9f2efbc3a0 100644
--- a/src/cmd/compile/internal/reflectdata/alg.go
+++ b/src/cmd/compile/internal/reflectdata/alg.go
@@ -287,6 +287,7 @@ func hashfor(t *types.Type) ir.Node {
 		sym = TypeSymPrefix(".hash", t)
 	}
 
+	// TODO(austin): This creates an ir.Name with a nil Func.
 	n := typecheck.NewName(sym)
 	ir.MarkFunc(n)
 	n.SetType(types.NewSignature(types.NoPkg, nil, nil, []*types.Field{
@@ -775,6 +776,7 @@ func memrun(t *types.Type, start int) (size int64, next int) {
 func hashmem(t *types.Type) ir.Node {
 	sym := ir.Pkgs.Runtime.Lookup("memhash")
 
+	// TODO(austin): This creates an ir.Name with a nil Func.
 	n := typecheck.NewName(sym)
 	ir.MarkFunc(n)
 	n.SetType(types.NewSignature(types.NoPkg, nil, nil, []*types.Field{
diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index 4c974ea324..c1cded826c 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -1741,6 +1741,9 @@ func methodWrapper(rcvr *types.Type, method *types.Field) *obj.LSym {
 		typecheck.NewFuncParams(method.Type.Params(), true),
 		typecheck.NewFuncParams(method.Type.Results(), false))
 
+	// TODO(austin): SelectorExpr may have created one or more
+	// ir.Names for these already with a nil Func field. We should
+	// consolidate these and always attach a Func to the Name.
 	fn := typecheck.DeclFunc(newnam, tfn)
 	fn.SetDupok(true)
 
diff --git a/src/cmd/compile/internal/typecheck/syms.go b/src/cmd/compile/internal/typecheck/syms.go
index 202a932e6c..f29af82db2 100644
--- a/src/cmd/compile/internal/typecheck/syms.go
+++ b/src/cmd/compile/internal/typecheck/syms.go
@@ -32,6 +32,7 @@ func SubstArgTypes(old *ir.Name, types_ ...*types.Type) *ir.Name {
 	n := ir.NewNameAt(old.Pos(), old.Sym())
 	n.Class = old.Class
 	n.SetType(types.SubstAny(old.Type(), &types_))
+	n.Func = old.Func
 	if len(types_) > 0 {
 		base.Fatalf("SubstArgTypes: too many argument types")
 	}
diff --git a/src/cmd/compile/internal/walk/compare.go b/src/cmd/compile/internal/walk/compare.go
index f4b5387c06..b18615f61a 100644
--- a/src/cmd/compile/internal/walk/compare.go
+++ b/src/cmd/compile/internal/walk/compare.go
@@ -426,6 +426,7 @@ func eqFor(t *types.Type) (n ir.Node, needsize bool) {
 		return n, true
 	case types.ASPECIAL:
 		sym := reflectdata.TypeSymPrefix(".eq", t)
+		// TODO(austin): This creates an ir.Name with a nil Func.
 		n := typecheck.NewName(sym)
 		ir.MarkFunc(n)
 		n.SetType(types.NewSignature(types.NoPkg, nil, nil, []*types.Field{
-- 
GitLab


From 1e8fff0f7b4577dcb7192928e2db4af7a11e9c0e Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Wed, 24 Mar 2021 10:32:13 -0400
Subject: [PATCH 1269/2400] cmd/compile: assert that function values reference
 ABIInternal

Function values must always point to the ABIInternal entry point of a
function. It wasn't entirely obvious to me we were getting this right,
so this CL adds checks for this.

Updates #40724.

Change-Id: Idd854e996d63d9151c28ec5c9251b690453b1024
Reviewed-on: https://go-review.googlesource.com/c/go/+/305272
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssagen/ssa.go      | 5 +++++
 src/cmd/compile/internal/staticdata/data.go | 8 +++++++-
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 18363c1219..42f7887a00 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -2360,6 +2360,11 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 	case ir.OCFUNC:
 		n := n.(*ir.UnaryExpr)
 		aux := n.X.(*ir.Name).Linksym()
+		// OCFUNC is used to build function values, which must
+		// always reference ABIInternal entry points.
+		if aux.ABI() != obj.ABIInternal {
+			s.Fatalf("expected ABIInternal: %v", aux.ABI())
+		}
 		return s.entryNewValue1A(ssa.OpAddr, n.Type(), aux, s.sb)
 	case ir.ONAME:
 		n := n.(*ir.Name)
diff --git a/src/cmd/compile/internal/staticdata/data.go b/src/cmd/compile/internal/staticdata/data.go
index fca2a63eb4..cde4c50026 100644
--- a/src/cmd/compile/internal/staticdata/data.go
+++ b/src/cmd/compile/internal/staticdata/data.go
@@ -292,7 +292,13 @@ func WriteFuncSyms() {
 	for _, nam := range funcsyms {
 		s := nam.Sym()
 		sf := s.Pkg.Lookup(ir.FuncSymName(s)).Linksym()
-		objw.SymPtr(sf, 0, s.Linksym(), 0)
+		// Function values must always reference ABIInternal
+		// entry points.
+		target := s.Linksym()
+		if target.ABI() != obj.ABIInternal {
+			base.Fatalf("expected ABIInternal: %v has %v", target, target.ABI())
+		}
+		objw.SymPtr(sf, 0, target, 0)
 		objw.Global(sf, int32(types.PtrSize), obj.DUPOK|obj.RODATA)
 	}
 }
-- 
GitLab


From feb844f1ead183b911ede1224638fbf55bcde7b8 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Wed, 24 Mar 2021 13:55:31 -0400
Subject: [PATCH 1270/2400] cmd/compile: eliminate -abiwraplimit

We haven't needed this debugging flag in a while and it's going to
complicate a change to how to generate wrappers. Eliminate it in favor
of just using the objabi.Experiment.RegabiWrappers global toggle.

Updates #40724.

Change-Id: Ieda660ea7a0167ae4e881b396ef556d7c962fe4c
Reviewed-on: https://go-review.googlesource.com/c/go/+/305273
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/base/flag.go  |  1 -
 src/cmd/compile/internal/ssagen/abi.go | 25 +------------------------
 2 files changed, 1 insertion(+), 25 deletions(-)

diff --git a/src/cmd/compile/internal/base/flag.go b/src/cmd/compile/internal/base/flag.go
index 33c2c862b0..4b7ef155a1 100644
--- a/src/cmd/compile/internal/base/flag.go
+++ b/src/cmd/compile/internal/base/flag.go
@@ -82,7 +82,6 @@ type CmdFlags struct {
 	CompilingRuntime bool "flag:\"+\" help:\"compiling runtime\""
 
 	// Longer names
-	ABIWrapLimit       int          "help:\"emit at most N ABI wrappers (for debugging)\""
 	AsmHdr             string       "help:\"write assembly header to `file`\""
 	Bench              string       "help:\"append benchmark times to `file`\""
 	BlockProfile       string       "help:\"write block profile to `file`\""
diff --git a/src/cmd/compile/internal/ssagen/abi.go b/src/cmd/compile/internal/ssagen/abi.go
index b6137756d4..2f8678060d 100644
--- a/src/cmd/compile/internal/ssagen/abi.go
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -21,29 +21,6 @@ import (
 	"cmd/internal/objabi"
 )
 
-// useNewABIWrapGen returns TRUE if the compiler should generate an
-// ABI wrapper for the function 'f'.
-func useABIWrapGen(f *ir.Func) bool {
-	if !objabi.Experiment.RegabiWrappers {
-		return false
-	}
-
-	// Support limit option for bisecting.
-	if base.Flag.ABIWrapLimit == 1 {
-		return false
-	}
-	if base.Flag.ABIWrapLimit < 1 {
-		return true
-	}
-	base.Flag.ABIWrapLimit--
-	if base.Debug.ABIWrap != 0 && base.Flag.ABIWrapLimit == 1 {
-		fmt.Fprintf(os.Stderr, "=-= limit reached after new wrapper for %s\n",
-			f.LSym.Name)
-	}
-
-	return true
-}
-
 // symabiDefs and symabiRefs record the defined and referenced ABIs of
 // symbols required by non-Go code. These are keyed by link symbol
 // name, where the local package prefix is always `"".`
@@ -199,7 +176,7 @@ func selectLSym(f *ir.Func, hasBody bool) {
 		}
 
 		if needABIWrapper {
-			if !useABIWrapGen(f) {
+			if !objabi.Experiment.RegabiWrappers {
 				// Fallback: use alias instead. FIXME.
 
 				// These LSyms have the same name as the
-- 
GitLab


From 67d565d2815f33887cfb448bd4c1928318324c78 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Thu, 25 Mar 2021 19:50:08 -0400
Subject: [PATCH 1271/2400] cmd/compile: restructure ABI wrapper generation,
 export ABI
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This CL restructures how we track function ABIs and generate ABI
wrappers in the compiler and adds import/export of ABIs across package
boundaries.

Currently, we start by tracking definition and referencing ABIs in two
global maps and eventually move some of this information into the
LSyms for functions. This complicates a lot of the existing code for
handling wrappers and makes it particularly hard to export ABI
information across packages. This change is built around instead
recording this information on the ir.Func.

First, this change replaces the global ABI def/ref maps with a type,
which makes the data flow and lifetime of this information clear in
gc.Main. These are populated during flag parsing.

Then, early in the front-end, we loop over all ir.Funcs to 1. attach
ABI def/ref information to the ir.Funcs and 2. create new ir.Funcs for
ABI wrappers. Step 1 is slightly subtle because the information is
keyed by linker symbol names, so we can't simply look things up in the
compiler's regular symbol table.

By generating ABI wrappers early in the front-end, we decouple this
step from LSym creation, which makes LSym creation much simpler (like
it was before ABI wrappers). In particular, LSyms for wrappers are now
created at the same time as all other functions instead of by
makeABIWrapper, which means we're back to the simpler, old situation
where InitLSym was the only thing responsible for constructing
function LSyms. Hence, we can restore the check that InitLSym is
called exactly once per function.

Attaching the ABI information to the ir.Func has several follow-on
benefits:

1. It's now easy to include in the export info. This enables direct
cross-package cross-ABI calls, which are important for the performance
of calling various hot assembly functions (e.g., internal/bytealg.*).
This was really the point of this whole change.

2. Since all Funcs, including wrappers, now record their definition
ABI, callTargetLSym no longer needs to distinguish wrappers from
non-wrappers, so it's now nearly trivial (it would be completely
trivial except that it has to work around a handful of cases where
ir.Name.Func is nil).

The simplification of callTargetLSym has one desirable but potentially
surprising side-effect: the compiler will now generate direct calls to
the definition ABI even when ABI wrappers are turned off. This is
almost completely unnoticeable except that cmd/internal/obj/wasm looks
for the call from runtime.deferreturn (defined in Go) to
runtime.jmpdefer (defined in assembly) to compile is specially. That
now looks like a direct call to ABI0 rather than going through the
ABIInternal alias.

While we're in here, we also set up the structures to support more
than just ABI0 and ABIInternal and add various additional consistency
checks all around.

Performance-wise, this reduces the overhead induced by wrappers from
1.24% geomean (on Sweet) to 0.52% geomean, and reduces the number of
benchmarks impacts >2% from 5 to 3. It has no impact on compiler speed.

Impact of wrappers before this change:

name                                old time/op  new time/op  delta
BiogoIgor                            15.8s ± 2%   15.8s ± 1%    ~     (p=0.863 n=25+25)
BiogoKrishna                         18.3s ± 6%   18.1s ± 7%  -1.39%  (p=0.015 n=25+25)
BleveIndexBatch100                   5.88s ± 3%   6.04s ± 6%  +2.72%  (p=0.000 n=25+25)
BleveQuery                           6.42s ± 1%   6.76s ± 1%  +5.31%  (p=0.000 n=24+24)
CompileTemplate                      245ms ± 3%   250ms ± 6%    ~     (p=0.068 n=22+25)
CompileUnicode                      93.6ms ± 2%  93.9ms ± 5%    ~     (p=0.958 n=22+25)
CompileGoTypes                       1.60s ± 2%   1.59s ± 2%    ~     (p=0.115 n=24+24)
CompileCompiler                      104ms ± 4%   104ms ± 3%    ~     (p=0.453 n=22+25)
CompileSSA                           11.0s ± 2%   11.0s ± 1%    ~     (p=0.789 n=24+25)
CompileFlate                         153ms ± 2%   153ms ± 1%    ~     (p=0.055 n=21+20)
CompileGoParser                      229ms ± 2%   230ms ± 2%    ~     (p=0.305 n=21+22)
CompileReflect                       585ms ± 5%   582ms ± 3%    ~     (p=0.365 n=25+25)
CompileTar                           211ms ± 1%   211ms ± 3%    ~     (p=0.592 n=20+22)
CompileXML                           282ms ± 3%   281ms ± 2%    ~     (p=0.937 n=22+23)
CompileStdCmd                        13.7s ± 3%   13.6s ± 2%    ~     (p=0.700 n=25+25)
FoglemanFauxGLRenderRotateBoat       8.67s ± 1%   8.78s ± 1%  +1.30%  (p=0.000 n=25+25)
FoglemanPathTraceRenderGopherIter1   20.5s ± 2%   20.9s ± 2%  +1.85%  (p=0.000 n=25+25)
GopherLuaKNucleotide                 30.1s ± 2%   31.1s ± 2%  +3.38%  (p=0.000 n=25+25)
MarkdownRenderXHTML                  246ms ± 5%   250ms ± 1%  +1.42%  (p=0.002 n=25+23)
Tile38WithinCircle100kmRequest       828µs ± 6%   885µs ± 6%  +6.85%  (p=0.000 n=23+25)
Tile38IntersectsCircle100kmRequest  1.04ms ± 5%  1.10ms ± 7%  +5.63%  (p=0.000 n=25+25)
Tile38KNearestLimit100Request        974µs ± 4%   972µs ± 4%    ~     (p=0.356 n=25+24)
[Geo mean]                           588ms        595ms       +1.24%

(https://perf.golang.org/search?q=upload:20210328.5)

And after this change:

name                                old time/op  new time/op  delta
BiogoIgor                            15.9s ± 1%   15.8s ± 1%  -0.48%  (p=0.008 n=22+25)
BiogoKrishna                         18.4s ± 6%   17.8s ± 6%  -3.55%  (p=0.008 n=25+25)
BleveIndexBatch100                   5.86s ± 3%   5.97s ± 4%  +1.88%  (p=0.001 n=25+25)
BleveQuery                           6.42s ± 1%   6.75s ± 1%  +5.14%  (p=0.000 n=25+25)
CompileTemplate                      246ms ± 5%   245ms ± 2%    ~     (p=0.472 n=23+23)
CompileUnicode                      93.7ms ± 3%  93.5ms ± 2%    ~     (p=0.813 n=22+23)
CompileGoTypes                       1.60s ± 2%   1.60s ± 2%    ~     (p=0.108 n=25+23)
CompileCompiler                      104ms ± 3%   104ms ± 2%    ~     (p=0.845 n=23+23)
CompileSSA                           11.0s ± 2%   11.0s ± 2%    ~     (p=0.525 n=25+25)
CompileFlate                         152ms ± 1%   153ms ± 2%    ~     (p=0.408 n=22+22)
CompileGoParser                      230ms ± 1%   230ms ± 1%    ~     (p=0.363 n=21+23)
CompileReflect                       582ms ± 3%   584ms ± 4%    ~     (p=0.658 n=25+25)
CompileTar                           212ms ± 2%   211ms ± 2%    ~     (p=0.315 n=23+24)
CompileXML                           282ms ± 1%   282ms ± 1%    ~     (p=0.991 n=23+22)
CompileStdCmd                        13.6s ± 2%   13.6s ± 2%    ~     (p=0.699 n=25+24)
FoglemanFauxGLRenderRotateBoat       8.66s ± 1%   8.69s ± 1%  +0.28%  (p=0.002 n=25+24)
FoglemanPathTraceRenderGopherIter1   20.5s ± 3%   20.5s ± 2%    ~     (p=0.407 n=25+25)
GopherLuaKNucleotide                 30.1s ± 2%   31.2s ± 2%  +3.82%  (p=0.000 n=25+25)
MarkdownRenderXHTML                  246ms ± 3%   245ms ± 1%    ~     (p=0.478 n=23+22)
Tile38WithinCircle100kmRequest       820µs ± 4%   856µs ± 5%  +4.39%  (p=0.000 n=24+25)
Tile38IntersectsCircle100kmRequest  1.05ms ± 6%  1.07ms ± 6%  +1.91%  (p=0.014 n=25+25)
Tile38KNearestLimit100Request        970µs ± 4%   970µs ± 3%    ~     (p=0.819 n=22+24)
[Geo mean]                           588ms        591ms       +0.52%

(https://perf.golang.org/search?q=upload:20210328.6)

For #40724.

Change-Id: I1c374e32d4bbc88efed062a1b360017d3642140d
Reviewed-on: https://go-review.googlesource.com/c/go/+/305274
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/gc/main.go           |   8 +-
 src/cmd/compile/internal/ir/func.go           |  25 +-
 src/cmd/compile/internal/ir/sizeof_test.go    |   2 +-
 src/cmd/compile/internal/ssagen/abi.go        | 298 ++++++++++--------
 src/cmd/compile/internal/ssagen/nowb.go       |   6 +
 src/cmd/compile/internal/ssagen/ssa.go        |  49 +--
 src/cmd/compile/internal/staticdata/data.go   |  16 +-
 src/cmd/compile/internal/typecheck/iexport.go |   6 +-
 src/cmd/compile/internal/typecheck/iimport.go |   3 +-
 src/cmd/compile/internal/types/sym.go         |   2 +-
 src/cmd/internal/obj/link.go                  |  42 +++
 src/cmd/internal/obj/wasm/wasmobj.go          |   8 +-
 12 files changed, 287 insertions(+), 178 deletions(-)

diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index c46989edb4..9199db830c 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -139,8 +139,9 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 
 	types.ParseLangFlag()
 
+	symABIs := ssagen.NewSymABIs(base.Ctxt.Pkgpath)
 	if base.Flag.SymABIs != "" {
-		ssagen.ReadSymABIs(base.Flag.SymABIs, base.Ctxt.Pkgpath)
+		symABIs.ReadSymABIs(base.Flag.SymABIs)
 	}
 
 	if base.Compiling(base.NoInstrumentPkgs) {
@@ -187,7 +188,6 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	noder.LoadPackage(flag.Args())
 
 	dwarfgen.RecordPackageName()
-	ssagen.CgoSymABIs()
 
 	// Build init task.
 	if initTask := pkginit.Task(); initTask != nil {
@@ -233,6 +233,10 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	}
 	ir.CurFunc = nil
 
+	// Generate ABI wrappers. Must happen before escape analysis
+	// and doesn't benefit from dead-coding or inlining.
+	symABIs.GenABIWrappers()
+
 	// Escape analysis.
 	// Required for moving heap allocations onto stack,
 	// which in turn is required by the closure implementation,
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index c17425a4da..bcedfe138c 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -93,7 +93,7 @@ type Func struct {
 
 	FieldTrack map[*obj.LSym]struct{}
 	DebugInfo  interface{}
-	LSym       *obj.LSym
+	LSym       *obj.LSym // Linker object in this function's native ABI (Func.ABI)
 
 	Inl *Inline
 
@@ -109,7 +109,22 @@ type Func struct {
 
 	Pragma PragmaFlag // go:xxx function annotations
 
-	flags      bitset16
+	flags bitset16
+
+	// ABI is a function's "definition" ABI. This is the ABI that
+	// this function's generated code is expecting to be called by.
+	//
+	// For most functions, this will be obj.ABIInternal. It may be
+	// a different ABI for functions defined in assembly or ABI wrappers.
+	//
+	// This is included in the export data and tracked across packages.
+	ABI obj.ABI
+	// ABIRefs is the set of ABIs by which this function is referenced.
+	// For ABIs other than this function's definition ABI, the
+	// compiler generates ABI wrapper functions. This is only tracked
+	// within a package.
+	ABIRefs obj.ABISet
+
 	NumDefers  int32 // number of defer calls in the function
 	NumReturns int32 // number of explicit returns in the function
 
@@ -124,6 +139,9 @@ func NewFunc(pos src.XPos) *Func {
 	f.pos = pos
 	f.op = ODCLFUNC
 	f.Iota = -1
+	// Most functions are ABIInternal. The importer or symabis
+	// pass may override this.
+	f.ABI = obj.ABIInternal
 	return f
 }
 
@@ -163,6 +181,7 @@ type ScopeID int32
 const (
 	funcDupok         = 1 << iota // duplicate definitions ok
 	funcWrapper                   // hide frame from users (elide in tracebacks, don't count as a frame for recover())
+	funcABIWrapper                // is an ABI wrapper (also set flagWrapper)
 	funcNeedctxt                  // function uses context register (has closure variables)
 	funcReflectMethod             // function calls reflect.Type.Method or MethodByName
 	// true if closure inside a function; false if a simple function or a
@@ -184,6 +203,7 @@ type SymAndPos struct {
 
 func (f *Func) Dupok() bool                    { return f.flags&funcDupok != 0 }
 func (f *Func) Wrapper() bool                  { return f.flags&funcWrapper != 0 }
+func (f *Func) ABIWrapper() bool               { return f.flags&funcABIWrapper != 0 }
 func (f *Func) Needctxt() bool                 { return f.flags&funcNeedctxt != 0 }
 func (f *Func) ReflectMethod() bool            { return f.flags&funcReflectMethod != 0 }
 func (f *Func) IsHiddenClosure() bool          { return f.flags&funcIsHiddenClosure != 0 }
@@ -197,6 +217,7 @@ func (f *Func) ClosureCalled() bool            { return f.flags&funcClosureCalle
 
 func (f *Func) SetDupok(b bool)                    { f.flags.set(funcDupok, b) }
 func (f *Func) SetWrapper(b bool)                  { f.flags.set(funcWrapper, b) }
+func (f *Func) SetABIWrapper(b bool)               { f.flags.set(funcABIWrapper, b) }
 func (f *Func) SetNeedctxt(b bool)                 { f.flags.set(funcNeedctxt, b) }
 func (f *Func) SetReflectMethod(b bool)            { f.flags.set(funcReflectMethod, b) }
 func (f *Func) SetIsHiddenClosure(b bool)          { f.flags.set(funcIsHiddenClosure, b) }
diff --git a/src/cmd/compile/internal/ir/sizeof_test.go b/src/cmd/compile/internal/ir/sizeof_test.go
index d8c1518b90..a4421fcf53 100644
--- a/src/cmd/compile/internal/ir/sizeof_test.go
+++ b/src/cmd/compile/internal/ir/sizeof_test.go
@@ -20,7 +20,7 @@ func TestSizeof(t *testing.T) {
 		_32bit uintptr     // size on 32bit platforms
 		_64bit uintptr     // size on 64bit platforms
 	}{
-		{Func{}, 188, 328},
+		{Func{}, 192, 328},
 		{Name{}, 112, 200},
 	}
 
diff --git a/src/cmd/compile/internal/ssagen/abi.go b/src/cmd/compile/internal/ssagen/abi.go
index 2f8678060d..9c203838a5 100644
--- a/src/cmd/compile/internal/ssagen/abi.go
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -12,7 +12,6 @@ import (
 	"strings"
 
 	"cmd/compile/internal/base"
-	"cmd/compile/internal/escape"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/staticdata"
 	"cmd/compile/internal/typecheck"
@@ -21,23 +20,40 @@ import (
 	"cmd/internal/objabi"
 )
 
-// symabiDefs and symabiRefs record the defined and referenced ABIs of
-// symbols required by non-Go code. These are keyed by link symbol
-// name, where the local package prefix is always `"".`
-var symabiDefs, symabiRefs map[string]obj.ABI
+// SymABIs records information provided by the assembler about symbol
+// definition ABIs and reference ABIs.
+type SymABIs struct {
+	defs map[string]obj.ABI
+	refs map[string]obj.ABISet
 
-func CgoSymABIs() {
-	// The linker expects an ABI0 wrapper for all cgo-exported
-	// functions.
-	for _, prag := range typecheck.Target.CgoPragmas {
-		switch prag[0] {
-		case "cgo_export_static", "cgo_export_dynamic":
-			if symabiRefs == nil {
-				symabiRefs = make(map[string]obj.ABI)
-			}
-			symabiRefs[prag[1]] = obj.ABI0
-		}
+	localPrefix string
+}
+
+func NewSymABIs(myimportpath string) *SymABIs {
+	var localPrefix string
+	if myimportpath != "" {
+		localPrefix = objabi.PathToPrefix(myimportpath) + "."
 	}
+
+	return &SymABIs{
+		defs:        make(map[string]obj.ABI),
+		refs:        make(map[string]obj.ABISet),
+		localPrefix: localPrefix,
+	}
+}
+
+// canonicalize returns the canonical name used for a linker symbol in
+// s's maps. Symbols in this package may be written either as "".X or
+// with the package's import path already in the symbol. This rewrites
+// both to `"".`, which matches compiler-generated linker symbol names.
+func (s *SymABIs) canonicalize(linksym string) string {
+	// If the symbol is already prefixed with localPrefix,
+	// rewrite it to start with "" so it matches the
+	// compiler's internal symbol names.
+	if s.localPrefix != "" && strings.HasPrefix(linksym, s.localPrefix) {
+		return `"".` + linksym[len(s.localPrefix):]
+	}
+	return linksym
 }
 
 // ReadSymABIs reads a symabis file that specifies definitions and
@@ -49,23 +65,12 @@ func CgoSymABIs() {
 // symbol using an ABI. For both "def" and "ref", the second field is
 // the symbol name and the third field is the ABI name, as one of the
 // named cmd/internal/obj.ABI constants.
-func ReadSymABIs(file, myimportpath string) {
+func (s *SymABIs) ReadSymABIs(file string) {
 	data, err := ioutil.ReadFile(file)
 	if err != nil {
 		log.Fatalf("-symabis: %v", err)
 	}
 
-	symabiDefs = make(map[string]obj.ABI)
-	symabiRefs = make(map[string]obj.ABI)
-
-	localPrefix := ""
-	if myimportpath != "" {
-		// Symbols in this package may be written either as
-		// "".X or with the package's import path already in
-		// the symbol.
-		localPrefix = objabi.PathToPrefix(myimportpath) + "."
-	}
-
 	for lineNum, line := range strings.Split(string(data), "\n") {
 		lineNum++ // 1-based
 		line = strings.TrimSpace(line)
@@ -86,19 +91,13 @@ func ReadSymABIs(file, myimportpath string) {
 				log.Fatalf(`%s:%d: invalid symabi: unknown abi "%s"`, file, lineNum, abistr)
 			}
 
-			// If the symbol is already prefixed with
-			// myimportpath, rewrite it to start with ""
-			// so it matches the compiler's internal
-			// symbol names.
-			if localPrefix != "" && strings.HasPrefix(sym, localPrefix) {
-				sym = `"".` + sym[len(localPrefix):]
-			}
+			sym = s.canonicalize(sym)
 
 			// Record for later.
 			if parts[0] == "def" {
-				symabiDefs[sym] = abi
+				s.defs[sym] = abi
 			} else {
-				symabiRefs[sym] = abi
+				s.refs[sym] |= obj.ABISetOf(abi)
 			}
 		default:
 			log.Fatalf(`%s:%d: invalid symabi type "%s"`, file, lineNum, parts[0])
@@ -106,6 +105,78 @@ func ReadSymABIs(file, myimportpath string) {
 	}
 }
 
+// GenABIWrappers applies ABI information to Funcs and generates ABI
+// wrapper functions where necessary.
+func (s *SymABIs) GenABIWrappers() {
+	// The linker expects an ABI0 wrapper for all cgo-exported
+	// functions.
+	for _, prag := range typecheck.Target.CgoPragmas {
+		switch prag[0] {
+		case "cgo_export_static", "cgo_export_dynamic":
+			s.refs[s.canonicalize(prag[1])] |= obj.ABISetOf(obj.ABI0)
+		}
+	}
+
+	// Apply ABI defs and refs to Funcs and generate wrappers.
+	//
+	// This may generate new decls for the wrappers, but we
+	// specifically *don't* want to visit those, lest we create
+	// wrappers for wrappers.
+	for _, fn := range typecheck.Target.Decls {
+		if fn.Op() != ir.ODCLFUNC {
+			continue
+		}
+		fn := fn.(*ir.Func)
+		nam := fn.Nname
+		if ir.IsBlank(nam) {
+			continue
+		}
+		sym := nam.Sym()
+		var symName string
+		if sym.Linkname != "" {
+			symName = s.canonicalize(sym.Linkname)
+		} else {
+			// These names will already be canonical.
+			symName = sym.Pkg.Prefix + "." + sym.Name
+		}
+
+		// Apply definitions.
+		defABI, hasDefABI := s.defs[symName]
+		if hasDefABI {
+			fn.ABI = defABI
+		}
+
+		// Apply references.
+		if abis, ok := s.refs[symName]; ok {
+			fn.ABIRefs |= abis
+		}
+		// Assume all functions are referenced at least as
+		// ABIInternal, since they may be referenced from
+		// other packages.
+		fn.ABIRefs.Set(obj.ABIInternal, true)
+
+		// If a symbol is defined in this package (either in
+		// Go or assembly) and given a linkname, it may be
+		// referenced from another package, so make it
+		// callable via any ABI. It's important that we know
+		// it's defined in this package since other packages
+		// may "pull" symbols using linkname and we don't want
+		// to create duplicate ABI wrappers.
+		hasBody := len(fn.Body) != 0
+		if sym.Linkname != "" && (hasBody || hasDefABI) {
+			fn.ABIRefs |= obj.ABISetCallable
+		}
+
+		if !objabi.Experiment.RegabiWrappers {
+			// We'll generate ABI aliases instead of
+			// wrappers once we have LSyms in InitLSym.
+			continue
+		}
+
+		forEachWrapperABI(fn, makeABIWrapper)
+	}
+}
+
 // InitLSym defines f's obj.LSym and initializes it based on the
 // properties of f. This includes setting the symbol flags and ABI and
 // creating and initializing related DWARF symbols.
@@ -115,96 +186,73 @@ func ReadSymABIs(file, myimportpath string) {
 // For body-less functions, we only create the LSym; for functions
 // with bodies call a helper to setup up / populate the LSym.
 func InitLSym(f *ir.Func, hasBody bool) {
-	// FIXME: for new-style ABI wrappers, we set up the lsym at the
-	// point the wrapper is created.
-	if f.LSym != nil && objabi.Experiment.RegabiWrappers {
-		return
-	}
-	staticdata.NeedFuncSym(f)
-	selectLSym(f, hasBody)
-	if hasBody {
-		setupTextLSym(f, 0)
-	}
-}
-
-// selectLSym sets up the LSym for a given function, and
-// makes calls to helpers to create ABI wrappers if needed.
-func selectLSym(f *ir.Func, hasBody bool) {
 	if f.LSym != nil {
 		base.FatalfAt(f.Pos(), "InitLSym called twice on %v", f)
 	}
 
 	if nam := f.Nname; !ir.IsBlank(nam) {
-
-		var wrapperABI obj.ABI
-		needABIWrapper := false
-		defABI, hasDefABI := symabiDefs[nam.Linksym().Name]
-		if hasDefABI && defABI == obj.ABI0 {
-			// Symbol is defined as ABI0. Create an
-			// Internal -> ABI0 wrapper.
-			f.LSym = nam.LinksymABI(obj.ABI0)
-			needABIWrapper, wrapperABI = true, obj.ABIInternal
-		} else {
-			f.LSym = nam.Linksym()
-			// No ABI override. Check that the symbol is
-			// using the expected ABI.
-			want := obj.ABIInternal
-			if f.LSym.ABI() != want {
-				base.Fatalf("function symbol %s has the wrong ABI %v, expected %v", f.LSym.Name, f.LSym.ABI(), want)
-			}
-		}
+		f.LSym = nam.LinksymABI(f.ABI)
 		if f.Pragma&ir.Systemstack != 0 {
 			f.LSym.Set(obj.AttrCFunc, true)
 		}
-
-		isLinknameExported := nam.Sym().Linkname != "" && (hasBody || hasDefABI)
-		if abi, ok := symabiRefs[f.LSym.Name]; (ok && abi == obj.ABI0) || isLinknameExported {
-			// Either 1) this symbol is definitely
-			// referenced as ABI0 from this package; or 2)
-			// this symbol is defined in this package but
-			// given a linkname, indicating that it may be
-			// referenced from another package. Create an
-			// ABI0 -> Internal wrapper so it can be
-			// called as ABI0. In case 2, it's important
-			// that we know it's defined in this package
-			// since other packages may "pull" symbols
-			// using linkname and we don't want to create
-			// duplicate ABI wrappers.
-			if f.LSym.ABI() != obj.ABI0 {
-				needABIWrapper, wrapperABI = true, obj.ABI0
-			}
+		if f.ABI == obj.ABIInternal || !objabi.Experiment.RegabiWrappers {
+			// Function values can only point to
+			// ABIInternal entry points. This will create
+			// the funcsym for either the defining
+			// function or its wrapper as appropriate.
+			//
+			// If we're using ABI aliases instead of
+			// wrappers, we only InitLSym for the defining
+			// ABI of a function, so we make the funcsym
+			// when we see that.
+			staticdata.NeedFuncSym(f)
+		}
+		if !objabi.Experiment.RegabiWrappers {
+			// Create ABI aliases instead of wrappers.
+			forEachWrapperABI(f, makeABIAlias)
 		}
+	}
+	if hasBody {
+		setupTextLSym(f, 0)
+	}
+}
 
-		if needABIWrapper {
-			if !objabi.Experiment.RegabiWrappers {
-				// Fallback: use alias instead. FIXME.
-
-				// These LSyms have the same name as the
-				// native function, so we create them directly
-				// rather than looking them up. The uniqueness
-				// of f.lsym ensures uniqueness of asym.
-				asym := &obj.LSym{
-					Name: f.LSym.Name,
-					Type: objabi.SABIALIAS,
-					R:    []obj.Reloc{{Sym: f.LSym}}, // 0 size, so "informational"
-				}
-				asym.SetABI(wrapperABI)
-				asym.Set(obj.AttrDuplicateOK, true)
-				base.Ctxt.ABIAliases = append(base.Ctxt.ABIAliases, asym)
-			} else {
-				if base.Debug.ABIWrap != 0 {
-					fmt.Fprintf(os.Stderr, "=-= %v to %v wrapper for %s.%s\n",
-						wrapperABI, 1-wrapperABI, types.LocalPkg.Path, f.LSym.Name)
-				}
-				makeABIWrapper(f, wrapperABI)
-			}
+func forEachWrapperABI(fn *ir.Func, cb func(fn *ir.Func, wrapperABI obj.ABI)) {
+	need := fn.ABIRefs &^ obj.ABISetOf(fn.ABI)
+	if need == 0 {
+		return
+	}
+
+	for wrapperABI := obj.ABI(0); wrapperABI < obj.ABICount; wrapperABI++ {
+		if !need.Get(wrapperABI) {
+			continue
 		}
+		cb(fn, wrapperABI)
 	}
 }
 
-// makeABIWrapper creates a new function that wraps a cross-ABI call
-// to "f".  The wrapper is marked as an ABIWRAPPER.
+// makeABIAlias creates a new ABI alias so calls to f via wrapperABI
+// will be resolved directly to f's ABI by the linker.
+func makeABIAlias(f *ir.Func, wrapperABI obj.ABI) {
+	// These LSyms have the same name as the native function, so
+	// we create them directly rather than looking them up.
+	// The uniqueness of f.lsym ensures uniqueness of asym.
+	asym := &obj.LSym{
+		Name: f.LSym.Name,
+		Type: objabi.SABIALIAS,
+		R:    []obj.Reloc{{Sym: f.LSym}}, // 0 size, so "informational"
+	}
+	asym.SetABI(wrapperABI)
+	asym.Set(obj.AttrDuplicateOK, true)
+	base.Ctxt.ABIAliases = append(base.Ctxt.ABIAliases, asym)
+}
+
+// makeABIWrapper creates a new function that will be called with
+// wrapperABI and calls "f" using f.ABI.
 func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
+	if base.Debug.ABIWrap != 0 {
+		fmt.Fprintf(os.Stderr, "=-= %v to %v wrapper for %v\n", wrapperABI, f.ABI, f)
+	}
 
 	// Q: is this needed?
 	savepos := base.Pos
@@ -230,16 +278,17 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 
 	// Reuse f's types.Sym to create a new ODCLFUNC/function.
 	fn := typecheck.DeclFunc(f.Nname.Sym(), tfn)
-	fn.SetDupok(true)
-	fn.SetWrapper(true) // ignore frame for panic+recover matching
+	fn.ABI = wrapperABI
 
-	// Select LSYM now.
-	asym := base.Ctxt.LookupABI(f.LSym.Name, wrapperABI)
-	asym.Type = objabi.STEXT
-	if fn.LSym != nil {
-		panic("unexpected")
-	}
-	fn.LSym = asym
+	fn.SetABIWrapper(true)
+	fn.SetDupok(true)
+	// Set this as a wrapper so it doesn't appear in tracebacks.
+	// Having both ABIWrapper and Wrapper set suppresses obj's
+	// usual panic+recover handling for wrappers; that's okay
+	// because we're never going to defer a wrapper for a function
+	// that then recovers, so that's would just be unnecessary
+	// code in the ABI wrapper.
+	fn.SetWrapper(true)
 
 	// ABI0-to-ABIInternal wrappers will be mainly loading params from
 	// stack into registers (and/or storing stack locations back to
@@ -266,7 +315,7 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 	// into trouble here.
 	// FIXME: at the moment all.bash does not pass when I leave out
 	// NOSPLIT for these wrappers, so all are currently tagged with NOSPLIT.
-	setupTextLSym(fn, obj.NOSPLIT|obj.ABIWRAPPER)
+	fn.Pragma |= ir.Nosplit
 
 	// Generate call. Use tail call if no params and no returns,
 	// but a regular call otherwise.
@@ -314,8 +363,6 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 	ir.CurFunc = fn
 	typecheck.Stmts(fn.Body)
 
-	escape.Batch([]*ir.Func{fn}, false)
-
 	typecheck.Target.Decls = append(typecheck.Target.Decls, fn)
 
 	// Restore previous context.
@@ -332,6 +379,9 @@ func setupTextLSym(f *ir.Func, flag int) {
 	if f.Wrapper() {
 		flag |= obj.WRAPPER
 	}
+	if f.ABIWrapper() {
+		flag |= obj.ABIWRAPPER
+	}
 	if f.Needctxt() {
 		flag |= obj.NEEDCTXT
 	}
diff --git a/src/cmd/compile/internal/ssagen/nowb.go b/src/cmd/compile/internal/ssagen/nowb.go
index a2434366a0..1fbc6a847d 100644
--- a/src/cmd/compile/internal/ssagen/nowb.go
+++ b/src/cmd/compile/internal/ssagen/nowb.go
@@ -61,6 +61,12 @@ func newNowritebarrierrecChecker() *nowritebarrierrecChecker {
 			continue
 		}
 		c.curfn = n.(*ir.Func)
+		if c.curfn.ABIWrapper() {
+			// We only want "real" calls to these
+			// functions, not the generated ones within
+			// their own ABI wrappers.
+			continue
+		}
 		ir.Visit(n, c.findExtraCalls)
 	}
 	c.curfn = nil
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 42f7887a00..a1f6d89814 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -1687,7 +1687,7 @@ func (s *state) stmt(n ir.Node) {
 		n := n.(*ir.TailCallStmt)
 		b := s.exit()
 		b.Kind = ssa.BlockRetJmp // override BlockRet
-		b.Aux = callTargetLSym(n.Target, s.curfn.LSym)
+		b.Aux = callTargetLSym(n.Target)
 
 	case ir.OCONTINUE, ir.OBREAK:
 		n := n.(*ir.BranchStmt)
@@ -5031,7 +5031,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			aux := ssa.InterfaceAuxCall(params)
 			call = s.newValue1A(ssa.OpInterLECall, aux.LateExpansionResultType(), aux, codeptr)
 		case callee != nil:
-			aux := ssa.StaticAuxCall(callTargetLSym(callee, s.curfn.LSym), params)
+			aux := ssa.StaticAuxCall(callTargetLSym(callee), params)
 			call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
 		default:
 			s.Fatalf("bad call type %v %v", n.Op(), n)
@@ -7378,44 +7378,17 @@ func clobberBase(n ir.Node) ir.Node {
 	return n
 }
 
-// callTargetLSym determines the correct LSym for 'callee' when called
-// from function 'caller'. There are a couple of different scenarios
-// to contend with here:
-//
-// 1. if 'caller' is an ABI wrapper, then we always want to use the
-//    LSym from the Func for the callee.
-//
-// 2. if 'caller' is not an ABI wrapper, then we looked at the callee
-//    to see if it corresponds to a "known" ABI0 symbol (e.g. assembly
-//    routine defined in the current package); if so, we want the call to
-//    directly target the ABI0 symbol (effectively bypassing the
-//    ABIInternal->ABI0 wrapper for 'callee').
-//
-// 3. in all other cases, want the regular ABIInternal linksym
-//
-func callTargetLSym(callee *ir.Name, callerLSym *obj.LSym) *obj.LSym {
-	lsym := callee.Linksym()
-	if !objabi.Experiment.RegabiWrappers {
-		return lsym
-	}
-	fn := callee.Func
-	if fn == nil {
-		return lsym
+// callTargetLSym returns the correct LSym to call 'callee' using its ABI.
+func callTargetLSym(callee *ir.Name) *obj.LSym {
+	if callee.Func == nil {
+		// TODO(austin): This happens in a few cases of
+		// compiler-generated functions. These are all
+		// ABIInternal. It would be better if callee.Func was
+		// never nil and we didn't need this case.
+		return callee.Linksym()
 	}
 
-	// check for case 1 above
-	if callerLSym.ABIWrapper() {
-		if nlsym := fn.LSym; nlsym != nil {
-			lsym = nlsym
-		}
-	} else {
-		// check for case 2 above
-		defABI, hasDefABI := symabiDefs[lsym.Name]
-		if hasDefABI && defABI == obj.ABI0 {
-			lsym = callee.LinksymABI(obj.ABI0)
-		}
-	}
-	return lsym
+	return callee.LinksymABI(callee.Func.ABI)
 }
 
 func min8(a, b int8) int8 {
diff --git a/src/cmd/compile/internal/staticdata/data.go b/src/cmd/compile/internal/staticdata/data.go
index cde4c50026..7ca05d3bf4 100644
--- a/src/cmd/compile/internal/staticdata/data.go
+++ b/src/cmd/compile/internal/staticdata/data.go
@@ -269,13 +269,23 @@ func NeedFuncSym(fn *ir.Func) {
 		// funcsymsmu, like in FuncSym.
 		base.Fatalf("NeedFuncSym must be called in serial")
 	}
+	if fn.ABI != obj.ABIInternal && objabi.Experiment.RegabiWrappers {
+		// Function values must always reference ABIInternal
+		// entry points, so it doesn't make sense to create a
+		// funcsym for other ABIs.
+		//
+		// (If we're using ABI aliases, it doesn't matter.)
+		base.Fatalf("expected ABIInternal: %v has %v", fn.Nname, fn.ABI)
+	}
+	if ir.IsBlank(fn.Nname) {
+		// Blank functions aren't unique, so we can't make a
+		// funcsym for them.
+		base.Fatalf("NeedFuncSym called for _")
+	}
 	if !base.Ctxt.Flag_dynlink {
 		return
 	}
 	s := fn.Nname.Sym()
-	if s.IsBlank() {
-		return
-	}
 	if base.Flag.CompilingRuntime && (s.Name == "getg" || s.Name == "getclosureptr" || s.Name == "getcallerpc" || s.Name == "getcallersp") {
 		// runtime.getg(), getclosureptr(), getcallerpc(), and
 		// getcallersp() are not real functions and so do not
diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index fa16357066..43cc4e4a25 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -1055,7 +1055,11 @@ func (w *exportWriter) funcExt(n *ir.Name) {
 	w.linkname(n.Sym())
 	w.symIdx(n.Sym())
 
-	// TODO(register args) remove after register abi is working.
+	// Record definition ABI so cross-ABI calls can be direct.
+	// This is important for the performance of calling some
+	// common functions implemented in assembly (e.g., bytealg).
+	w.uint64(uint64(n.Func.ABI))
+
 	w.uint64(uint64(n.Func.Pragma))
 
 	// Escape analysis.
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 91bb215a29..35a1a0083a 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -694,7 +694,8 @@ func (r *importReader) funcExt(n *ir.Name) {
 	r.linkname(n.Sym())
 	r.symIdx(n.Sym())
 
-	// TODO(register args) remove after register abi is working
+	n.Func.ABI = obj.ABI(r.uint64())
+
 	n.SetPragma(ir.PragmaFlag(r.uint64()))
 
 	// Escape analysis.
diff --git a/src/cmd/compile/internal/types/sym.go b/src/cmd/compile/internal/types/sym.go
index c689304b34..9a32a01a1a 100644
--- a/src/cmd/compile/internal/types/sym.go
+++ b/src/cmd/compile/internal/types/sym.go
@@ -45,7 +45,7 @@ const (
 	symUniq
 	symSiggen // type symbol has been generated
 	symAsm    // on asmlist, for writing to -asmhdr
-	symFunc   // function symbol; uses internal ABI
+	symFunc   // function symbol
 )
 
 func (sym *Sym) OnExportList() bool { return sym.flags&symOnExportList != 0 }
diff --git a/src/cmd/internal/obj/link.go b/src/cmd/internal/obj/link.go
index c34a769a82..7530690185 100644
--- a/src/cmd/internal/obj/link.go
+++ b/src/cmd/internal/obj/link.go
@@ -603,6 +603,48 @@ func ParseABI(abistr string) (ABI, bool) {
 	}
 }
 
+// ABISet is a bit set of ABI values.
+type ABISet uint8
+
+const (
+	// ABISetCallable is the set of all ABIs any function could
+	// potentially be called using.
+	ABISetCallable ABISet = (1 << ABI0) | (1 << ABIInternal)
+)
+
+// Ensure ABISet is big enough to hold all ABIs.
+var _ ABISet = 1 << (ABICount - 1)
+
+func ABISetOf(abi ABI) ABISet {
+	return 1 << abi
+}
+
+func (a *ABISet) Set(abi ABI, value bool) {
+	if value {
+		*a |= 1 << abi
+	} else {
+		*a &^= 1 << abi
+	}
+}
+
+func (a *ABISet) Get(abi ABI) bool {
+	return (*a>>abi)&1 != 0
+}
+
+func (a ABISet) String() string {
+	s := "{"
+	for i := ABI(0); a != 0; i++ {
+		if a&(1<<i) != 0 {
+			if s != "{" {
+				s += ","
+			}
+			s += i.String()
+			a &^= 1 << i
+		}
+	}
+	return s + "}"
+}
+
 // Attribute is a set of symbol attributes.
 type Attribute uint32
 
diff --git a/src/cmd/internal/obj/wasm/wasmobj.go b/src/cmd/internal/obj/wasm/wasmobj.go
index 2e9890d86c..ceeae7a257 100644
--- a/src/cmd/internal/obj/wasm/wasmobj.go
+++ b/src/cmd/internal/obj/wasm/wasmobj.go
@@ -144,11 +144,9 @@ func instinit(ctxt *obj.Link) {
 	gcWriteBarrier = ctxt.LookupABI("runtime.gcWriteBarrier", obj.ABIInternal)
 	sigpanic = ctxt.LookupABI("runtime.sigpanic", obj.ABIInternal)
 	deferreturn = ctxt.LookupABI("runtime.deferreturn", obj.ABIInternal)
-	// jmpdefer is defined in assembly as ABI0, but what we're
-	// looking for is the *call* to jmpdefer from the Go function
-	// deferreturn, so we're looking for the ABIInternal version
-	// of jmpdefer that's called by Go.
-	jmpdefer = ctxt.LookupABI(`"".jmpdefer`, obj.ABIInternal)
+	// jmpdefer is defined in assembly as ABI0. The compiler will
+	// generate a direct ABI0 call from Go, so look for that.
+	jmpdefer = ctxt.LookupABI(`"".jmpdefer`, obj.ABI0)
 }
 
 func preprocess(ctxt *obj.Link, s *obj.LSym, newprog obj.ProgAlloc) {
-- 
GitLab


From 9fbd0f64d86d616d9ce1a2636afac43001b22b7c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BE=90=E5=BF=97=E4=BC=9F?= <juwan.xu@qq.com>
Date: Mon, 29 Mar 2021 18:22:15 +0000
Subject: [PATCH 1272/2400] runtime: fix some typos

Change-Id: I31f2081eb7c30a9583f479f9194e636fe721b9b3
GitHub-Last-Rev: d09f5fbdc5785dc3963b22ad75309740e0de258e
GitHub-Pull-Request: golang/go#45278
Reviewed-on: https://go-review.googlesource.com/c/go/+/305231
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/mgcwork.go        | 2 +-
 src/runtime/proc.go           | 2 +-
 src/runtime/sys_windows_arm.s | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/runtime/mgcwork.go b/src/runtime/mgcwork.go
index b3a068661e..667c7afa97 100644
--- a/src/runtime/mgcwork.go
+++ b/src/runtime/mgcwork.go
@@ -398,7 +398,7 @@ func getempty() *workbuf {
 }
 
 // putempty puts a workbuf onto the work.empty list.
-// Upon entry this go routine owns b. The lfstack.push relinquishes ownership.
+// Upon entry this goroutine owns b. The lfstack.push relinquishes ownership.
 //go:nowritebarrier
 func putempty(b *workbuf) {
 	b.checkempty()
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 89d36321a6..c2edb40948 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -6231,7 +6231,7 @@ func doInit(t *initTask) {
 
 		if inittrace.active {
 			end := nanotime()
-			// Load stats non-atomically since tracinit is updated only by this init go routine.
+			// Load stats non-atomically since tracinit is updated only by this init goroutine.
 			after := inittrace
 
 			pkg := funcpkgpath(findfunc(funcPC(firstFunc)))
diff --git a/src/runtime/sys_windows_arm.s b/src/runtime/sys_windows_arm.s
index 275b827fcb..22c6d63bdd 100644
--- a/src/runtime/sys_windows_arm.s
+++ b/src/runtime/sys_windows_arm.s
@@ -157,7 +157,7 @@ g0:
 	MOVW	R2, 4(R13)	// Move arg0 (ExceptionRecord) into position
 	MOVW	R3, 8(R13)	// Move arg1 (ContextRecord) into position
 	MOVW	R5, 12(R13)	// Move arg2 (original g) into position
-	BL	(R7)		// Call the go routine
+	BL	(R7)		// Call the goroutine
 	MOVW	16(R13), R4	// Fetch return value from stack
 
 	// Save system stack pointer for sigresume setup below.
-- 
GitLab


From 164a6265e761335bb909ddfbd47d5f3fc3673582 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 29 Mar 2021 13:31:14 -0700
Subject: [PATCH 1273/2400] go/types: remove use of ioutil (cleanup)

Change-Id: I0f9437953cb994c6802efee92167702daacf000a
Reviewed-on: https://go-review.googlesource.com/c/go/+/305575
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/go/types/check_test.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/go/types/check_test.go b/src/go/types/check_test.go
index 9812b3808b..327fb4c5f1 100644
--- a/src/go/types/check_test.go
+++ b/src/go/types/check_test.go
@@ -34,7 +34,6 @@ import (
 	"go/scanner"
 	"go/token"
 	"internal/testenv"
-	"io/ioutil"
 	"os"
 	"path/filepath"
 	"regexp"
@@ -332,7 +331,7 @@ func testDir(t *testing.T, dir string) {
 		// if fi is a directory, its files make up a single package
 		var filenames []string
 		if fi.IsDir() {
-			fis, err := ioutil.ReadDir(path)
+			fis, err := os.ReadDir(path)
 			if err != nil {
 				t.Error(err)
 				continue
-- 
GitLab


From 4e16422da0b444794b45396519d45eec800a540e Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Wed, 24 Mar 2021 15:50:54 -0500
Subject: [PATCH 1274/2400] cmd/internal/obj/ppc64: remove bogus MOVBU optab
 entry

This was missed in https://golang.org/cl/303329 . It is another
impossible usage of MOVBU as a load like "MOVBU 0(rX), rY, rZ" or
"MOVBU rX(rB), rY, rZ".

Change-Id: Ib3dd984b6424907498ed65b798649f0b990d50a7
Reviewed-on: https://go-review.googlesource.com/c/go/+/304471
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/internal/obj/ppc64/asm9.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/internal/obj/ppc64/asm9.go b/src/cmd/internal/obj/ppc64/asm9.go
index 1745409b4d..47e67a32f3 100644
--- a/src/cmd/internal/obj/ppc64/asm9.go
+++ b/src/cmd/internal/obj/ppc64/asm9.go
@@ -196,7 +196,6 @@ var optab = []Optab{
 
 	{as: AMOVBU, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVBU, a1: C_SOREG, a6: C_REG, type_: 9, size: 8},
-	{as: AMOVBU, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 9, size: 8},
 
 	{as: AMOVBZU, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVBZU, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
-- 
GitLab


From 1ef114d12c39e8467d3e905d0a050bd7ce03123a Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Mon, 22 Mar 2021 15:00:22 -0400
Subject: [PATCH 1275/2400] runtime: abstract specials list iteration

The specials processing loop in mspan.sweep is about to get more
complicated and I'm too allergic to list manipulation to open code
more of it there.

Change-Id: I767a0889739da85fb2878fc06a5c55b73bf2ba7d
Reviewed-on: https://go-review.googlesource.com/c/go/+/305551
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
---
 src/runtime/mgcsweep.go | 25 ++++++++++---------------
 src/runtime/mheap.go    | 34 +++++++++++++++++++++++++++++++---
 2 files changed, 41 insertions(+), 18 deletions(-)

diff --git a/src/runtime/mgcsweep.go b/src/runtime/mgcsweep.go
index f3d6c6caa4..723217caa9 100644
--- a/src/runtime/mgcsweep.go
+++ b/src/runtime/mgcsweep.go
@@ -356,11 +356,10 @@ func (s *mspan) sweep(preserve bool) bool {
 	//    If such object is not marked, we need to queue all finalizers at once.
 	// Both 1 and 2 are possible at the same time.
 	hadSpecials := s.specials != nil
-	specialp := &s.specials
-	special := *specialp
-	for special != nil {
+	siter := newSpecialsIter(s)
+	for siter.valid() {
 		// A finalizer can be set for an inner byte of an object, find object beginning.
-		objIndex := uintptr(special.offset) / size
+		objIndex := uintptr(siter.s.offset) / size
 		p := s.base() + objIndex*size
 		mbits := s.markBitsForIndex(objIndex)
 		if !mbits.isMarked() {
@@ -368,7 +367,7 @@ func (s *mspan) sweep(preserve bool) bool {
 			// Pass 1: see if it has at least one finalizer.
 			hasFin := false
 			endOffset := p - s.base() + size
-			for tmp := special; tmp != nil && uintptr(tmp.offset) < endOffset; tmp = tmp.next {
+			for tmp := siter.s; tmp != nil && uintptr(tmp.offset) < endOffset; tmp = tmp.next {
 				if tmp.kind == _KindSpecialFinalizer {
 					// Stop freeing of object if it has a finalizer.
 					mbits.setMarkedNonAtomic()
@@ -377,27 +376,23 @@ func (s *mspan) sweep(preserve bool) bool {
 				}
 			}
 			// Pass 2: queue all finalizers _or_ handle profile record.
-			for special != nil && uintptr(special.offset) < endOffset {
+			for siter.valid() && uintptr(siter.s.offset) < endOffset {
 				// Find the exact byte for which the special was setup
 				// (as opposed to object beginning).
+				special := siter.s
 				p := s.base() + uintptr(special.offset)
 				if special.kind == _KindSpecialFinalizer || !hasFin {
-					// Splice out special record.
-					y := special
-					special = special.next
-					*specialp = special
-					freespecial(y, unsafe.Pointer(p), size)
+					siter.unlinkAndNext()
+					freeSpecial(special, unsafe.Pointer(p), size)
 				} else {
 					// This is profile record, but the object has finalizers (so kept alive).
 					// Keep special record.
-					specialp = &special.next
-					special = *specialp
+					siter.next()
 				}
 			}
 		} else {
 			// object is still live: keep special record
-			specialp = &special.next
-			special = *specialp
+			siter.next()
 		}
 	}
 	if hadSpecials && s.specials == nil {
diff --git a/src/runtime/mheap.go b/src/runtime/mheap.go
index 13ea337735..d7f6a88cc9 100644
--- a/src/runtime/mheap.go
+++ b/src/runtime/mheap.go
@@ -1854,9 +1854,37 @@ func setprofilebucket(p unsafe.Pointer, b *bucket) {
 	}
 }
 
-// Do whatever cleanup needs to be done to deallocate s. It has
-// already been unlinked from the mspan specials list.
-func freespecial(s *special, p unsafe.Pointer, size uintptr) {
+// specialsIter helps iterate over specials lists.
+type specialsIter struct {
+	pprev **special
+	s     *special
+}
+
+func newSpecialsIter(span *mspan) specialsIter {
+	return specialsIter{&span.specials, span.specials}
+}
+
+func (i *specialsIter) valid() bool {
+	return i.s != nil
+}
+
+func (i *specialsIter) next() {
+	i.pprev = &i.s.next
+	i.s = *i.pprev
+}
+
+// unlinkAndNext removes the current special from the list and moves
+// the iterator to the next special. It returns the unlinked special.
+func (i *specialsIter) unlinkAndNext() *special {
+	cur := i.s
+	i.s = cur.next
+	*i.pprev = i.s
+	return cur
+}
+
+// freeSpecial performs any cleanup on special s and deallocates it.
+// s must already be unlinked from the specials list.
+func freeSpecial(s *special, p unsafe.Pointer, size uintptr) {
 	switch s.kind {
 	case _KindSpecialFinalizer:
 		sf := (*specialfinalizer)(unsafe.Pointer(s))
-- 
GitLab


From 4e1bf8ed3840632b4781d3c4abb4704dca468dd4 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Wed, 24 Mar 2021 10:45:20 -0400
Subject: [PATCH 1276/2400] runtime: add GC testing helpers for regabi
 signature fuzzer

This CL adds a set of helper functions for testing GC interactions.
These are intended for use in the regabi signature fuzzer, but are
generally useful for GC tests, so we make them generally available to
runtime tests.

These provide:

1. An easy way to force stack movement, for testing stack copying.

2. A simple and robust way to check the reachability of a set of
pointers.

3. A way to check what general category of memory a pointer points to,
mostly so tests can make sure they're testing what they mean to.

For #40724, but generally useful.

Change-Id: I15d33ccb3f5a792c0472a19c2cc9a8b4a9356a66
Reviewed-on: https://go-review.googlesource.com/c/go/+/305330
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/runtime/export_test.go | 21 +++++++++
 src/runtime/gc_test.go     | 75 +++++++++++++++++++++++++++++
 src/runtime/mgc.go         | 96 ++++++++++++++++++++++++++++++++++++++
 src/runtime/mgcsweep.go    | 16 +++++--
 src/runtime/mheap.go       | 17 +++++++
 5 files changed, 221 insertions(+), 4 deletions(-)

diff --git a/src/runtime/export_test.go b/src/runtime/export_test.go
index 1650541fda..961c1c1a26 100644
--- a/src/runtime/export_test.go
+++ b/src/runtime/export_test.go
@@ -1244,3 +1244,24 @@ func FinalizerGAsleep() bool {
 	unlock(&finlock)
 	return result
 }
+
+// For GCTestMoveStackOnNextCall, it's important not to introduce an
+// extra layer of call, since then there's a return before the "real"
+// next call.
+var GCTestMoveStackOnNextCall = gcTestMoveStackOnNextCall
+
+// For GCTestIsReachable, it's important that we do this as a call so
+// escape analysis can see through it.
+func GCTestIsReachable(ptrs ...unsafe.Pointer) (mask uint64) {
+	return gcTestIsReachable(ptrs...)
+}
+
+// For GCTestPointerClass, it's important that we do this as a call so
+// escape analysis can see through it.
+//
+// This is nosplit because gcTestPointerClass is.
+//
+//go:nosplit
+func GCTestPointerClass(p unsafe.Pointer) string {
+	return gcTestPointerClass(p)
+}
diff --git a/src/runtime/gc_test.go b/src/runtime/gc_test.go
index 7870f31ae9..1ea1c2c745 100644
--- a/src/runtime/gc_test.go
+++ b/src/runtime/gc_test.go
@@ -202,6 +202,81 @@ func TestGcZombieReporting(t *testing.T) {
 	}
 }
 
+func TestGCTestMoveStackOnNextCall(t *testing.T) {
+	t.Parallel()
+	var onStack int
+	runtime.GCTestMoveStackOnNextCall()
+	moveStackCheck(t, &onStack, uintptr(unsafe.Pointer(&onStack)))
+}
+
+// This must not be inlined because the point is to force a stack
+// growth check and move the stack.
+//
+//go:noinline
+func moveStackCheck(t *testing.T, new *int, old uintptr) {
+	// new should have been updated by the stack move;
+	// old should not have.
+
+	// Capture new's value before doing anything that could
+	// further move the stack.
+	new2 := uintptr(unsafe.Pointer(new))
+
+	t.Logf("old stack pointer %x, new stack pointer %x", old, new2)
+	if new2 == old {
+		// Check that we didn't screw up the test's escape analysis.
+		if cls := runtime.GCTestPointerClass(unsafe.Pointer(new)); cls != "stack" {
+			t.Fatalf("test bug: new (%#x) should be a stack pointer, not %s", new2, cls)
+		}
+		// This was a real failure.
+		t.Fatal("stack did not move")
+	}
+}
+
+func TestGCTestIsReachable(t *testing.T) {
+	var all, half []unsafe.Pointer
+	var want uint64
+	for i := 0; i < 16; i++ {
+		// The tiny allocator muddies things, so we use a
+		// scannable type.
+		p := unsafe.Pointer(new(*int))
+		all = append(all, p)
+		if i%2 == 0 {
+			half = append(half, p)
+			want |= 1 << i
+		}
+	}
+
+	got := runtime.GCTestIsReachable(all...)
+	if want != got {
+		t.Fatalf("did not get expected reachable set; want %b, got %b", want, got)
+	}
+	runtime.KeepAlive(half)
+}
+
+var pointerClassSink *int
+var pointerClassData = 42
+
+func TestGCTestPointerClass(t *testing.T) {
+	t.Parallel()
+	check := func(p unsafe.Pointer, want string) {
+		t.Helper()
+		got := runtime.GCTestPointerClass(p)
+		if got != want {
+			// Convert the pointer to a uintptr to avoid
+			// escaping it.
+			t.Errorf("for %#x, want class %s, got %s", uintptr(p), want, got)
+		}
+	}
+	var onStack int
+	var notOnStack int
+	pointerClassSink = &notOnStack
+	check(unsafe.Pointer(&onStack), "stack")
+	check(unsafe.Pointer(&notOnStack), "heap")
+	check(unsafe.Pointer(&pointerClassSink), "bss")
+	check(unsafe.Pointer(&pointerClassData), "data")
+	check(nil, "other")
+}
+
 func BenchmarkSetTypePtr(b *testing.B) {
 	benchSetType(b, new(*byte))
 }
diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index 4b99d755c4..ecac354d83 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -2339,3 +2339,99 @@ func fmtNSAsMS(buf []byte, ns uint64) []byte {
 	}
 	return itoaDiv(buf, x, dec)
 }
+
+// Helpers for testing GC.
+
+// gcTestMoveStackOnNextCall causes the stack to be moved on a call
+// immediately following the call to this. It may not work correctly
+// if any other work appears after this call (such as returning).
+// Typically the following call should be marked go:noinline so it
+// performs a stack check.
+func gcTestMoveStackOnNextCall() {
+	gp := getg()
+	gp.stackguard0 = getcallersp()
+}
+
+// gcTestIsReachable performs a GC and returns a bit set where bit i
+// is set if ptrs[i] is reachable.
+func gcTestIsReachable(ptrs ...unsafe.Pointer) (mask uint64) {
+	// This takes the pointers as unsafe.Pointers in order to keep
+	// them live long enough for us to attach specials. After
+	// that, we drop our references to them.
+
+	if len(ptrs) > 64 {
+		panic("too many pointers for uint64 mask")
+	}
+
+	// Block GC while we attach specials and drop our references
+	// to ptrs. Otherwise, if a GC is in progress, it could mark
+	// them reachable via this function before we have a chance to
+	// drop them.
+	semacquire(&gcsema)
+
+	// Create reachability specials for ptrs.
+	specials := make([]*specialReachable, len(ptrs))
+	for i, p := range ptrs {
+		lock(&mheap_.speciallock)
+		s := (*specialReachable)(mheap_.specialReachableAlloc.alloc())
+		unlock(&mheap_.speciallock)
+		s.special.kind = _KindSpecialReachable
+		if !addspecial(p, &s.special) {
+			throw("already have a reachable special (duplicate pointer?)")
+		}
+		specials[i] = s
+		// Make sure we don't retain ptrs.
+		ptrs[i] = nil
+	}
+
+	semrelease(&gcsema)
+
+	// Force a full GC and sweep.
+	GC()
+
+	// Process specials.
+	for i, s := range specials {
+		if !s.done {
+			printlock()
+			println("runtime: object", i, "was not swept")
+			throw("IsReachable failed")
+		}
+		if s.reachable {
+			mask |= 1 << i
+		}
+		lock(&mheap_.speciallock)
+		mheap_.specialReachableAlloc.free(unsafe.Pointer(s))
+		unlock(&mheap_.speciallock)
+	}
+
+	return mask
+}
+
+// gcTestPointerClass returns the category of what p points to, one of:
+// "heap", "stack", "data", "bss", "other". This is useful for checking
+// that a test is doing what it's intended to do.
+//
+// This is nosplit simply to avoid extra pointer shuffling that may
+// complicate a test.
+//
+//go:nosplit
+func gcTestPointerClass(p unsafe.Pointer) string {
+	p2 := uintptr(noescape(p))
+	gp := getg()
+	if gp.stack.lo <= p2 && p2 < gp.stack.hi {
+		return "stack"
+	}
+	if base, _, _ := findObject(p2, 0, 0); base != 0 {
+		return "heap"
+	}
+	for _, datap := range activeModules() {
+		if datap.data <= p2 && p2 < datap.edata || datap.noptrdata <= p2 && p2 < datap.enoptrdata {
+			return "data"
+		}
+		if datap.bss <= p2 && p2 < datap.ebss || datap.noptrbss <= p2 && p2 <= datap.enoptrbss {
+			return "bss"
+		}
+	}
+	KeepAlive(p)
+	return "other"
+}
diff --git a/src/runtime/mgcsweep.go b/src/runtime/mgcsweep.go
index 723217caa9..8d254702ed 100644
--- a/src/runtime/mgcsweep.go
+++ b/src/runtime/mgcsweep.go
@@ -385,14 +385,22 @@ func (s *mspan) sweep(preserve bool) bool {
 					siter.unlinkAndNext()
 					freeSpecial(special, unsafe.Pointer(p), size)
 				} else {
-					// This is profile record, but the object has finalizers (so kept alive).
-					// Keep special record.
+					// The object has finalizers, so we're keeping it alive.
+					// All other specials only apply when an object is freed,
+					// so just keep the special record.
 					siter.next()
 				}
 			}
 		} else {
-			// object is still live: keep special record
-			siter.next()
+			// object is still live
+			if siter.s.kind == _KindSpecialReachable {
+				special := siter.unlinkAndNext()
+				(*specialReachable)(unsafe.Pointer(special)).reachable = true
+				freeSpecial(special, unsafe.Pointer(p), size)
+			} else {
+				// keep special record
+				siter.next()
+			}
 		}
 	}
 	if hadSpecials && s.specials == nil {
diff --git a/src/runtime/mheap.go b/src/runtime/mheap.go
index d7f6a88cc9..da3772cdb6 100644
--- a/src/runtime/mheap.go
+++ b/src/runtime/mheap.go
@@ -212,6 +212,7 @@ type mheap struct {
 	cachealloc            fixalloc // allocator for mcache*
 	specialfinalizeralloc fixalloc // allocator for specialfinalizer*
 	specialprofilealloc   fixalloc // allocator for specialprofile*
+	specialReachableAlloc fixalloc // allocator for specialReachable
 	speciallock           mutex    // lock for special record allocators.
 	arenaHintAlloc        fixalloc // allocator for arenaHints
 
@@ -703,6 +704,7 @@ func (h *mheap) init() {
 	h.cachealloc.init(unsafe.Sizeof(mcache{}), nil, nil, &memstats.mcache_sys)
 	h.specialfinalizeralloc.init(unsafe.Sizeof(specialfinalizer{}), nil, nil, &memstats.other_sys)
 	h.specialprofilealloc.init(unsafe.Sizeof(specialprofile{}), nil, nil, &memstats.other_sys)
+	h.specialReachableAlloc.init(unsafe.Sizeof(specialReachable{}), nil, nil, &memstats.other_sys)
 	h.arenaHintAlloc.init(unsafe.Sizeof(arenaHint{}), nil, nil, &memstats.other_sys)
 
 	// Don't zero mspan allocations. Background sweeping can
@@ -1649,6 +1651,9 @@ func (list *mSpanList) takeAll(other *mSpanList) {
 const (
 	_KindSpecialFinalizer = 1
 	_KindSpecialProfile   = 2
+	// _KindSpecialReachable is a special used for tracking
+	// reachability during testing.
+	_KindSpecialReachable = 3
 	// Note: The finalizer special must be first because if we're freeing
 	// an object, a finalizer special will cause the freeing operation
 	// to abort, and we want to keep the other special records around
@@ -1854,6 +1859,14 @@ func setprofilebucket(p unsafe.Pointer, b *bucket) {
 	}
 }
 
+// specialReachable tracks whether an object is reachable on the next
+// GC cycle. This is used by testing.
+type specialReachable struct {
+	special   special
+	done      bool
+	reachable bool
+}
+
 // specialsIter helps iterate over specials lists.
 type specialsIter struct {
 	pprev **special
@@ -1898,6 +1911,10 @@ func freeSpecial(s *special, p unsafe.Pointer, size uintptr) {
 		lock(&mheap_.speciallock)
 		mheap_.specialprofilealloc.free(unsafe.Pointer(sp))
 		unlock(&mheap_.speciallock)
+	case _KindSpecialReachable:
+		sp := (*specialReachable)(unsafe.Pointer(s))
+		sp.done = true
+		// The creator frees these.
 	default:
 		throw("bad special kind")
 		panic("not reached")
-- 
GitLab


From bd6628e62dd5ef1e389d6551a83ef4f2baabebb5 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Mon, 29 Mar 2021 13:44:08 -0400
Subject: [PATCH 1277/2400] cmd/compile: check deferred nil interface call
 before wrapping it

Currently, for "defer i.M()" if i is nil it panics at the point of
defer statement, not when deferred function is called. We need to
do the nil check before wrapping it.

Updates #40724.

Change-Id: I62c669264668991f71999e2cf4610a9066247f9d
Reviewed-on: https://go-review.googlesource.com/c/go/+/305549
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/walk/order.go | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index 95d245d0d7..9e6c58054d 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -1602,6 +1602,17 @@ func (o *orderState) wrapGoDefer(n *ir.GoDeferStmt) {
 			n := callX.(*ir.SelectorExpr)
 			n.X = mkArgCopy(n.X)
 			methSelectorExpr = n
+			if callX.Op() == ir.ODOTINTER {
+				// Currently for "defer i.M()" if i is nil it panics at the
+				// point of defer statement, not when deferred function is called.
+				// (I think there is an issue discussing what is the intended
+				// behavior but I cannot find it.)
+				// We need to do the nil check outside of the wrapper.
+				tab := typecheck.Expr(ir.NewUnaryExpr(base.Pos, ir.OITAB, n.X))
+				c := ir.NewUnaryExpr(n.Pos(), ir.OCHECKNIL, tab)
+				c.SetTypecheck(1)
+				o.append(c)
+			}
 		case !(callX.Op() == ir.ONAME && callX.(*ir.Name).Class == ir.PFUNC):
 			// Deal with "defer returnsafunc()(x, y)" (for
 			// example) by copying the callee expression.
-- 
GitLab


From e27f3966bbb95d0f3330a60202eabe8dff57a311 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 25 Mar 2021 13:24:16 -0400
Subject: [PATCH 1278/2400] cmd/compile: be sure to wrap defer/go calls with
 arguments

CL 298669 implemented wrapping for defer/go calls so the function
being called with defer or go statement has no arguments. This
simplifies the compiler and the runtime, especially with the
new ABI.

If the called function does not have any argument, we don't need
to wrap. But the code missed the cases of method receiver, as
well as some apparent argumentless builtin calls which may later
be rewritten to having arguments (e.g. recover). This CL makes
sure to wrap those cases. Also add a check to ensure that go and
defer calls are indeed argumentless.

Handle "defer recover()" specially, as recover() is lowered to
runtime.gorecover(FP) where FP is the frame's FP. FP needs to be
evaluated before wrapping.

Updates #40724.

Change-Id: I2758b6c69ab6aa02dd588441a457fe28ddd0d5a5
Reviewed-on: https://go-review.googlesource.com/c/go/+/304771
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/ssagen/ssa.go   |  8 ++++++++
 src/cmd/compile/internal/walk/builtin.go | 12 ++++++++++++
 src/cmd/compile/internal/walk/expr.go    | 10 +---------
 src/cmd/compile/internal/walk/order.go   | 25 ++++++++++++++++++------
 4 files changed, 40 insertions(+), 15 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index a1f6d89814..92bddd59da 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -4608,6 +4608,10 @@ func (s *state) openDeferRecord(n *ir.CallExpr) {
 	var args []*ssa.Value
 	var argNodes []*ir.Name
 
+	if objabi.Experiment.RegabiDefer && (len(n.Args) != 0 || n.Op() == ir.OCALLINTER) {
+		s.Fatalf("defer call with arguments: %v", n)
+	}
+
 	opendefer := &openDeferInfo{
 		n: n,
 	}
@@ -4856,6 +4860,10 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		}
 	}
 
+	if objabi.Experiment.RegabiDefer && k != callNormal && (len(n.Args) != 0 || n.Op() == ir.OCALLINTER) {
+		s.Fatalf("go/defer call with arguments: %v", n)
+	}
+
 	switch n.Op() {
 	case ir.OCALLFUNC:
 		if k == callNormal && fn.Op() == ir.ONAME && fn.(*ir.Name).Class == ir.PFUNC {
diff --git a/src/cmd/compile/internal/walk/builtin.go b/src/cmd/compile/internal/walk/builtin.go
index 97f9de9c1d..b5b24b26ca 100644
--- a/src/cmd/compile/internal/walk/builtin.go
+++ b/src/cmd/compile/internal/walk/builtin.go
@@ -653,6 +653,18 @@ func walkPrint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 	return walkStmt(typecheck.Stmt(r))
 }
 
+// walkRecover walks an ORECOVER node.
+func walkRecover(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
+	// Call gorecover with the FP of this frame.
+	// FP is equal to caller's SP plus FixedFrameSize().
+	var fp ir.Node = mkcall("getcallersp", types.Types[types.TUINTPTR], init)
+	if off := base.Ctxt.FixedFrameSize(); off != 0 {
+		fp = ir.NewBinaryExpr(fp.Pos(), ir.OADD, fp, ir.NewInt(off))
+	}
+	fp = ir.NewConvExpr(fp.Pos(), ir.OCONVNOP, types.NewPtr(types.Types[types.TINT32]), fp)
+	return mkcall("gorecover", nn.Type(), init, fp)
+}
+
 func badtype(op ir.Op, tl, tr *types.Type) {
 	var s string
 	if tl != nil {
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 4cc5b65d3e..0bf531e29d 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -157,15 +157,7 @@ func walkExpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		return mkcall("gopanic", nil, init, n.X)
 
 	case ir.ORECOVER:
-		n := n.(*ir.CallExpr)
-		// Call gorecover with the FP of this frame.
-		// FP is equal to caller's SP plus FixedFrameSize().
-		var fp ir.Node = mkcall("getcallersp", types.Types[types.TUINTPTR], init)
-		if off := base.Ctxt.FixedFrameSize(); off != 0 {
-			fp = ir.NewBinaryExpr(fp.Pos(), ir.OADD, fp, ir.NewInt(off))
-		}
-		fp = ir.NewConvExpr(fp.Pos(), ir.OCONVNOP, types.NewPtr(types.Types[types.TINT32]), fp)
-		return mkcall("gorecover", n.Type(), init, fp)
+		return walkRecover(n.(*ir.CallExpr), init)
 
 	case ir.OCFUNC:
 		return n
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index 9e6c58054d..6e3acc624c 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -732,6 +732,13 @@ func (o *orderState) stmt(n ir.Node) {
 		t := o.markTemp()
 		o.init(n.Call)
 		o.call(n.Call)
+		if n.Call.Op() == ir.ORECOVER {
+			// Special handling of "defer recover()". We need to evaluate the FP
+			// argument before wrapping.
+			var init ir.Nodes
+			n.Call = walkRecover(n.Call.(*ir.CallExpr), &init)
+			o.stmtList(init)
+		}
 		if objabi.Experiment.RegabiDefer {
 			o.wrapGoDefer(n)
 		}
@@ -1481,7 +1488,7 @@ func (o *orderState) wrapGoDefer(n *ir.GoDeferStmt) {
 		callArgs = []ir.Node{x.X}
 		mkNewCall = func(pos src.XPos, op ir.Op, fun ir.Node, args []ir.Node) ir.Node {
 			if len(args) != 1 {
-				panic("internal error, expecting single arg to close")
+				panic("internal error, expecting single arg")
 			}
 			return ir.Node(ir.NewUnaryExpr(pos, op, args[0]))
 		}
@@ -1497,11 +1504,17 @@ func (o *orderState) wrapGoDefer(n *ir.GoDeferStmt) {
 		panic("unhandled op")
 	}
 
-	// No need to wrap if called func has no args. However in the case
-	// of "defer func() { ... }()" we need to protect against the
-	// possibility of directClosureCall rewriting things so that the
-	// call does have arguments.
-	if len(callArgs) == 0 {
+	// No need to wrap if called func has no args and no receiver.
+	// However in the case of "defer func() { ... }()" we need to
+	// protect against the possibility of directClosureCall rewriting
+	// things so that the call does have arguments.
+	//
+	// Do wrap method calls (OCALLMETH, OCALLINTER), because it has
+	// a receiver.
+	//
+	// Also do wrap builtin functions, because they may be expanded to
+	// calls with arguments (e.g. ORECOVER).
+	if len(callArgs) == 0 && call.Op() == ir.OCALLFUNC {
 		if c, ok := call.(*ir.CallExpr); ok && callX != nil && callX.Op() == ir.OCLOSURE {
 			cloFunc := callX.(*ir.ClosureExpr).Func
 			cloFunc.SetClosureCalled(false)
-- 
GitLab


From 06ad41642c6e06ddb6faa8575fcc3cfafa6a13d1 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Mon, 29 Mar 2021 14:17:18 -0400
Subject: [PATCH 1279/2400] cmd/compile: wrap defer/go call with results

CL 298669 implemented wrapping for defer/go calls so the function
being called with defer or go statement has no arguments. This
simplifies the compiler and the runtime, especially with the
new ABI.

Currently, it does not wrap functions that has no arguments but
only results. For defer/go calls, the results are not used. But
the runtime needs to allocate stack space for the callee to store
the results. Wrapping functions with results makes the runtime
simpler.

TODO: maybe not wrap if all results are in registers.

Updates #40724.

Change-Id: I74d2f4db1cbf9979afbcd846facb30d11d72ab23
Reviewed-on: https://go-review.googlesource.com/c/go/+/305550
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/ssagen/ssa.go | 6 +++---
 src/cmd/compile/internal/walk/order.go | 7 +++++--
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 92bddd59da..0062cc5fc7 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -4608,8 +4608,8 @@ func (s *state) openDeferRecord(n *ir.CallExpr) {
 	var args []*ssa.Value
 	var argNodes []*ir.Name
 
-	if objabi.Experiment.RegabiDefer && (len(n.Args) != 0 || n.Op() == ir.OCALLINTER) {
-		s.Fatalf("defer call with arguments: %v", n)
+	if objabi.Experiment.RegabiDefer && (len(n.Args) != 0 || n.Op() == ir.OCALLINTER || n.X.Type().NumResults() != 0) {
+		s.Fatalf("defer call with arguments or results: %v", n)
 	}
 
 	opendefer := &openDeferInfo{
@@ -4860,7 +4860,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		}
 	}
 
-	if objabi.Experiment.RegabiDefer && k != callNormal && (len(n.Args) != 0 || n.Op() == ir.OCALLINTER) {
+	if objabi.Experiment.RegabiDefer && k != callNormal && (len(n.Args) != 0 || n.Op() == ir.OCALLINTER || n.X.Type().NumResults() != 0) {
 		s.Fatalf("go/defer call with arguments: %v", n)
 	}
 
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index 6e3acc624c..bee3dc3e07 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -1504,7 +1504,7 @@ func (o *orderState) wrapGoDefer(n *ir.GoDeferStmt) {
 		panic("unhandled op")
 	}
 
-	// No need to wrap if called func has no args and no receiver.
+	// No need to wrap if called func has no args, no receiver, and no results.
 	// However in the case of "defer func() { ... }()" we need to
 	// protect against the possibility of directClosureCall rewriting
 	// things so that the call does have arguments.
@@ -1514,7 +1514,10 @@ func (o *orderState) wrapGoDefer(n *ir.GoDeferStmt) {
 	//
 	// Also do wrap builtin functions, because they may be expanded to
 	// calls with arguments (e.g. ORECOVER).
-	if len(callArgs) == 0 && call.Op() == ir.OCALLFUNC {
+	//
+	// TODO: maybe not wrap if the called function has no arguments and
+	// only in-register results?
+	if len(callArgs) == 0 && call.Op() == ir.OCALLFUNC && callX.Type().NumResults() == 0 {
 		if c, ok := call.(*ir.CallExpr); ok && callX != nil && callX.Op() == ir.OCLOSURE {
 			cloFunc := callX.(*ir.ClosureExpr).Func
 			cloFunc.SetClosureCalled(false)
-- 
GitLab


From a95454b6f31a982f064d262987199fba19f085e9 Mon Sep 17 00:00:00 2001
From: Meng Zhuo <mzh@golangcn.org>
Date: Mon, 29 Mar 2021 15:10:50 +0800
Subject: [PATCH 1280/2400] runtime: init plan9 hashkey by time

Maphash requires non-zero integer for initial hashkey

Fixes #45090

Change-Id: Ie567f648c19e81cddc8e72a1c64809fbf52df188
Reviewed-on: https://go-review.googlesource.com/c/go/+/303969
Trust: Meng Zhuo <mzh@golangcn.org>
Run-TryBot: Meng Zhuo <mzh@golangcn.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Richard Miller <millerresearch@gmail.com>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/runtime/os_plan9.go | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/src/runtime/os_plan9.go b/src/runtime/os_plan9.go
index 77665f461a..4d428346f0 100644
--- a/src/runtime/os_plan9.go
+++ b/src/runtime/os_plan9.go
@@ -325,7 +325,23 @@ func crash() {
 
 //go:nosplit
 func getRandomData(r []byte) {
-	extendRandom(r, 0)
+	// inspired by wyrand see hash32.go for detail
+	t := nanotime()
+	v := getg().m.procid ^ uint64(t)
+
+	for len(r) > 0 {
+		v ^= 0xa0761d6478bd642f
+		v *= 0xe7037ed1a0b428db
+		size := 8
+		if len(r) < 8 {
+			size = len(r)
+		}
+		for i := 0; i < size; i++ {
+			r[i] = byte(v >> (8 * i))
+		}
+		r = r[size:]
+		v = v>>32 | v<<32
+	}
 }
 
 func initsig(preinit bool) {
-- 
GitLab


From eeadfa2d3810c252f86a88ddd282b48be5abc6df Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Mon, 29 Mar 2021 08:28:01 -0700
Subject: [PATCH 1281/2400] cmd/compile: fix various small bugs related to type
 lists

Fix various small bugs related to delaying transformations due to type
params. Most of these relate to the need to delay a transformation when
an argument of an expression or statement has a type parameter that has
a structural constraint. The structural constraint implies the operation
should work, but the transformation can't happen until the actual value
of the type parameter is known.

 - delay transformations for send statements and return statements if
   any args/values have type params.

 - similarly, delay transformation of a call where the function arg has
   type parameters. This is mainly important for the case where the
   function arg is a pure type parameter, but has a structural
   constraint that requires it to be a function. Move the setting of
   n.Use to transformCall(), since we may not know how many return
   values there are until then, if the function arg is a type parameter.

 - set the type of unary expressions from the type2 type (as we do with
   most other expressions), since that works better with expressions
   with type params.

 - deal with these delayed transformations in subster.node() and convert
   the CALL checks to a switch statement.

 - make sure ir.CurFunc is set properly during stenciling, including
   closures (needed for transforming return statements during
   stenciling).

New test file typelist.go with tests for these cases.

Change-Id: I1b82f949d8cec47d906429209e846f4ebc8ec85e
Reviewed-on: https://go-review.googlesource.com/c/go/+/305729
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/expr.go      |  4 +-
 src/cmd/compile/internal/noder/helpers.go   | 27 ++++++---
 src/cmd/compile/internal/noder/stencil.go   | 67 +++++++++++++++------
 src/cmd/compile/internal/noder/stmt.go      | 14 +++++
 src/cmd/compile/internal/noder/transform.go |  2 +
 test/typeparam/typelist.go                  | 64 ++++++++++++++++++++
 6 files changed, 150 insertions(+), 28 deletions(-)
 create mode 100644 test/typeparam/typelist.go

diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index 9db03a9005..ecdc7c74b1 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -164,7 +164,7 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 
 	case *syntax.Operation:
 		if expr.Y == nil {
-			return Unary(pos, g.op(expr.Op, unOps[:]), g.expr(expr.X))
+			return Unary(pos, g.typ(typ), g.op(expr.Op, unOps[:]), g.expr(expr.X))
 		}
 		switch op := g.op(expr.Op, binOps[:]); op {
 		case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
@@ -236,7 +236,7 @@ func (g *irgen) selectorExpr(pos src.XPos, typ types2.Type, expr *syntax.Selecto
 
 			if havePtr != wantPtr {
 				if havePtr {
-					x = Implicit(Deref(pos, x))
+					x = Implicit(Deref(pos, x.Type().Elem(), x))
 				} else {
 					x = Implicit(Addr(pos, x))
 				}
diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
index cb8052c0cb..e5a6dbcb01 100644
--- a/src/cmd/compile/internal/noder/helpers.go
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -149,9 +149,13 @@ func Call(pos src.XPos, typ *types.Type, fun ir.Node, args []ir.Node, dots bool)
 		}
 	}
 
-	n.Use = ir.CallUseExpr
-	if fun.Type().NumResults() == 0 {
-		n.Use = ir.CallUseStmt
+	if fun.Type().HasTParam() {
+		// If the fun arg is or has a type param, don't do any extra
+		// transformations, since we may not have needed properties yet
+		// (e.g. number of return values, etc). The type param is probably
+		// described by a structural constraint that requires it to be a
+		// certain function type, etc., but we don't want to analyze that.
+		return typed(typ, n)
 	}
 
 	if fun.Op() == ir.OXDOT {
@@ -191,9 +195,9 @@ func Compare(pos src.XPos, typ *types.Type, op ir.Op, x, y ir.Node) ir.Node {
 	return n
 }
 
-func Deref(pos src.XPos, x ir.Node) *ir.StarExpr {
+func Deref(pos src.XPos, typ *types.Type, x ir.Node) *ir.StarExpr {
 	n := ir.NewStarExpr(pos, x)
-	typed(x.Type().Elem(), n)
+	typed(typ, n)
 	return n
 }
 
@@ -288,17 +292,22 @@ func Slice(pos src.XPos, typ *types.Type, x, low, high, max ir.Node) ir.Node {
 	return n
 }
 
-func Unary(pos src.XPos, op ir.Op, x ir.Node) ir.Node {
+func Unary(pos src.XPos, typ *types.Type, op ir.Op, x ir.Node) ir.Node {
 	switch op {
 	case ir.OADDR:
 		return Addr(pos, x)
 	case ir.ODEREF:
-		return Deref(pos, x)
+		return Deref(pos, typ, x)
 	}
 
-	typ := x.Type()
 	if op == ir.ORECV {
-		typ = typ.Elem()
+		if typ.IsFuncArgStruct() && typ.NumFields() == 2 {
+			// Remove the second boolean type (if provided by type2),
+			// since that works better with the rest of the compiler
+			// (which will add it back in later).
+			assert(typ.Field(1).Type.Kind() == types.TBOOL)
+			typ = typ.Field(0).Type
+		}
 	}
 	return typed(typ, ir.NewUnaryExpr(pos, op, x))
 }
diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 45864763d4..8dcc9d811e 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -270,6 +270,7 @@ func (g *irgen) genericSubst(newsym *types.Sym, nameNode *ir.Name, targs []ir.No
 	newf.Nname.Func = newf
 	newf.Nname.Defn = newf
 	newsym.Def = newf.Nname
+	ir.CurFunc = newf
 
 	assert(len(tparams) == len(targs))
 
@@ -286,7 +287,6 @@ func (g *irgen) genericSubst(newsym *types.Sym, nameNode *ir.Name, targs []ir.No
 	for i, n := range gf.Dcl {
 		newf.Dcl[i] = subst.node(n).(*ir.Name)
 	}
-	newf.Body = subst.list(gf.Body)
 
 	// Ugly: we have to insert the Name nodes of the parameters/results into
 	// the function type. The current function type has no Nname fields set,
@@ -305,6 +305,11 @@ func (g *irgen) genericSubst(newsym *types.Sym, nameNode *ir.Name, targs []ir.No
 	newf.Nname.SetTypecheck(1)
 	// TODO(danscales) - remove later, but avoid confusion for now.
 	newf.Pragma = ir.Noinline
+
+	// Make sure name/type of newf is set before substituting the body.
+	newf.Body = subst.list(gf.Body)
+	ir.CurFunc = nil
+
 	return newf
 }
 
@@ -396,6 +401,12 @@ func (subst *subster) node(n ir.Node) ir.Node {
 					as := m.(*ir.AssignOpStmt)
 					transformCheckAssign(as, as.X)
 
+				case ir.ORETURN:
+					transformReturn(m.(*ir.ReturnStmt))
+
+				case ir.OSEND:
+					transformSend(m.(*ir.SendStmt))
+
 				default:
 					base.Fatalf("Unexpected node with Typecheck() == 3")
 				}
@@ -435,38 +446,55 @@ func (subst *subster) node(n ir.Node) ir.Node {
 
 		case ir.OCALL:
 			call := m.(*ir.CallExpr)
-			if call.X.Op() == ir.OTYPE {
+			switch call.X.Op() {
+			case ir.OTYPE:
 				// Transform the conversion, now that we know the
 				// type argument.
 				m = transformConvCall(m.(*ir.CallExpr))
-			} else if call.X.Op() == ir.OCALLPART {
+
+			case ir.OCALLPART:
 				// Redo the transformation of OXDOT, now that we
 				// know the method value is being called. Then
 				// transform the call.
 				call.X.(*ir.SelectorExpr).SetOp(ir.OXDOT)
 				transformDot(call.X.(*ir.SelectorExpr), true)
 				transformCall(call)
-			} else if call.X.Op() == ir.ODOT || call.X.Op() == ir.ODOTPTR {
+
+			case ir.ODOT, ir.ODOTPTR:
 				// An OXDOT for a generic receiver was resolved to
 				// an access to a field which has a function
 				// value. Transform the call to that function, now
 				// that the OXDOT was resolved.
 				transformCall(call)
-			} else if name := call.X.Name(); name != nil {
-				switch name.BuiltinOp {
-				case ir.OMAKE, ir.OREAL, ir.OIMAG, ir.OLEN, ir.OCAP, ir.OAPPEND:
-					// Transform these builtins now that we
-					// know the type of the args.
-					m = transformBuiltin(call)
-				default:
-					base.FatalfAt(call.Pos(), "Unexpected builtin op")
+
+			case ir.ONAME:
+				name := call.X.Name()
+				if name.BuiltinOp != ir.OXXX {
+					switch name.BuiltinOp {
+					case ir.OMAKE, ir.OREAL, ir.OIMAG, ir.OLEN, ir.OCAP, ir.OAPPEND:
+						// Transform these builtins now that we
+						// know the type of the args.
+						m = transformBuiltin(call)
+					default:
+						base.FatalfAt(call.Pos(), "Unexpected builtin op")
+					}
+				} else {
+					// This is the case of a function value that was a
+					// type parameter (implied to be a function via a
+					// structural constraint) which is now resolved.
+					transformCall(call)
 				}
 
-			} else if call.X.Op() != ir.OFUNCINST {
-				// A call with an OFUNCINST will get typechecked
+			case ir.OCLOSURE:
+				transformCall(call)
+
+			case ir.OFUNCINST:
+				// A call with an OFUNCINST will get transformed
 				// in stencil() once we have created & attached the
 				// instantiation to be called.
-				base.FatalfAt(call.Pos(), "Expecting OCALLPART or OTYPE or OFUNCINST or builtin with CALL")
+
+			default:
+				base.FatalfAt(call.Pos(), fmt.Sprintf("Unexpected op with CALL during stenciling: %v", call.X.Op()))
 			}
 
 		case ir.OCLOSURE:
@@ -491,17 +519,22 @@ func (subst *subster) node(n ir.Node) ir.Node {
 			newfn.OClosure = m.(*ir.ClosureExpr)
 
 			saveNewf := subst.newf
+			ir.CurFunc = newfn
 			subst.newf = newfn
 			newfn.Dcl = subst.namelist(oldfn.Dcl)
 			newfn.ClosureVars = subst.namelist(oldfn.ClosureVars)
-			newfn.Body = subst.list(oldfn.Body)
-			subst.newf = saveNewf
 
 			// Set Ntype for now to be compatible with later parts of compiler
 			newfn.Nname.Ntype = subst.node(oldfn.Nname.Ntype).(ir.Ntype)
 			typed(subst.typ(oldfn.Nname.Type()), newfn.Nname)
 			typed(newfn.Nname.Type(), m)
 			newfn.SetTypecheck(1)
+
+			// Make sure type of closure function is set before doing body.
+			newfn.Body = subst.list(oldfn.Body)
+			subst.newf = saveNewf
+			ir.CurFunc = saveNewf
+
 			subst.g.target.Decls = append(subst.g.target.Decls, newfn)
 		}
 		return m
diff --git a/src/cmd/compile/internal/noder/stmt.go b/src/cmd/compile/internal/noder/stmt.go
index f85496be40..32a1483b4a 100644
--- a/src/cmd/compile/internal/noder/stmt.go
+++ b/src/cmd/compile/internal/noder/stmt.go
@@ -42,6 +42,12 @@ func (g *irgen) stmt(stmt syntax.Stmt) ir.Node {
 		return x
 	case *syntax.SendStmt:
 		n := ir.NewSendStmt(g.pos(stmt), g.expr(stmt.Chan), g.expr(stmt.Value))
+		if n.Chan.Type().HasTParam() || n.Value.Type().HasTParam() {
+			// Delay transforming the send if the channel or value
+			// have a type param.
+			n.SetTypecheck(3)
+			return n
+		}
 		transformSend(n)
 		n.SetTypecheck(1)
 		return n
@@ -118,6 +124,14 @@ func (g *irgen) stmt(stmt syntax.Stmt) ir.Node {
 		return ir.NewGoDeferStmt(g.pos(stmt), g.tokOp(int(stmt.Tok), callOps[:]), g.expr(stmt.Call))
 	case *syntax.ReturnStmt:
 		n := ir.NewReturnStmt(g.pos(stmt), g.exprList(stmt.Results))
+		for _, e := range n.Results {
+			if e.Type().HasTParam() {
+				// Delay transforming the return statement if any of the
+				// return values have a type param.
+				n.SetTypecheck(3)
+				return n
+			}
+		}
 		transformReturn(n)
 		n.SetTypecheck(1)
 		return n
diff --git a/src/cmd/compile/internal/noder/transform.go b/src/cmd/compile/internal/noder/transform.go
index 489a535231..7f926dc70a 100644
--- a/src/cmd/compile/internal/noder/transform.go
+++ b/src/cmd/compile/internal/noder/transform.go
@@ -144,8 +144,10 @@ func transformCall(n *ir.CallExpr) {
 
 	typecheckaste(ir.OCALL, n.X, n.IsDDD, t.Params(), n.Args)
 	if t.NumResults() == 0 {
+		n.Use = ir.CallUseStmt
 		return
 	}
+	n.Use = ir.CallUseExpr
 	if t.NumResults() == 1 {
 		n.SetType(l.Type().Results().Field(0).Type)
 
diff --git a/test/typeparam/typelist.go b/test/typeparam/typelist.go
new file mode 100644
index 0000000000..4ff3ce2f34
--- /dev/null
+++ b/test/typeparam/typelist.go
@@ -0,0 +1,64 @@
+// compile -G=3
+
+// Copyright 2021 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.
+
+// This file tests type lists & structural constraints.
+
+package p
+
+// Assignability of an unnamed pointer type to a type parameter that
+// has a matching underlying type.
+func _[T interface{}, PT interface{type *T}] (x T) PT {
+    return &x
+}
+
+// Indexing of generic types containing type parameters in their type list:
+func at[T interface{ type []E }, E any](x T, i int) E {
+        return x[i]
+}
+
+// A generic type inside a function acts like a named type. Its underlying
+// type is itself, its "operational type" is defined by the type list in
+// the tybe bound, if any.
+func _[T interface{type int}](x T) {
+	type myint int
+	var _ int = int(x)
+	var _ T = 42
+	var _ T = T(myint(42))
+}
+
+// Indexing a generic type which has a structural contraints to be an array.
+func _[T interface { type [10]int }](x T) {
+	_ = x[9] // ok
+}
+
+// Dereference of a generic type which has a structural contraint to be a pointer.
+func _[T interface{ type *int }](p T) int {
+	return *p
+}
+
+// Channel send and receive on a generic type which has a structural constraint to
+// be a channel.
+func _[T interface{ type chan int }](ch T) int {
+	// This would deadlock if executed (but ok for a compile test)
+	ch <- 0
+	return <- ch
+}
+
+// Calling of a generic type which has a structural constraint to be a function.
+func _[T interface{ type func() }](f T) {
+	f()
+	go f()
+}
+
+// Same, but function has a parameter and return value.
+func _[T interface{ type func(string) int }](f T) int {
+	return f("hello")
+}
+
+// Map access of a generic type which has a structural constraint to be a map.
+func _[V any, T interface { type map[string]V }](p T) V {
+	return p["test"]
+}
-- 
GitLab


From 33945869c12ce92933714426471ce4f5c4ec7b6b Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Wed, 24 Mar 2021 14:20:12 -0400
Subject: [PATCH 1282/2400] cmd/compile: update default ABI choices for calls
 and bodyless fn stack maps

After recent discussion about bodyless functions, their wrappers,
their stack maps, nosplit, and callbacks, I was inspired to go and
be sure that more defaults were sensible.  This may not be all --
currently rtcall is "ABIDefault" which I think is correct, but I
am not 100% certain.

Updates #40724.

Change-Id: I95b14ee0e5952fa53e7fea9f6f5192358aa24f23
Reviewed-on: https://go-review.googlesource.com/c/go/+/304549
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/gc/compile.go |  2 +-
 src/cmd/compile/internal/ssagen/ssa.go | 37 ++++++++++++++------------
 2 files changed, 21 insertions(+), 18 deletions(-)

diff --git a/src/cmd/compile/internal/gc/compile.go b/src/cmd/compile/internal/gc/compile.go
index e066d3345e..6db37919fa 100644
--- a/src/cmd/compile/internal/gc/compile.go
+++ b/src/cmd/compile/internal/gc/compile.go
@@ -44,7 +44,7 @@ func enqueueFunc(fn *ir.Func) {
 		// Initialize ABI wrappers if necessary.
 		ssagen.InitLSym(fn, false)
 		types.CalcSize(fn.Type()) // TODO register args; remove this once all is done by abiutils
-		a := ssagen.AbiForFunc(fn)
+		a := ssagen.AbiForBodylessFuncStackMap(fn)
 		abiInfo := a.ABIAnalyze(fn.Type(), true) // will set parameter spill/home locations correctly
 		liveness.WriteFuncMap(fn, abiInfo)
 		return
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 0062cc5fc7..57099371e6 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -209,12 +209,15 @@ func InitConfig() {
 	ir.Syms.SigPanic = typecheck.LookupRuntimeFunc("sigpanic")
 }
 
-// AbiForFunc returns the ABI for a function, used to figure out arg/result mapping for rtcall and bodyless functions.
-// This follows policy for GOEXPERIMENT=regabi, //go:registerparams, and currently defined ABIInternal.
-// Policy is subject to change....
+// AbiForBodylessFuncStackMap returns the ABI for a bodyless function's stack map.
+// This is not necessarily the ABI used to call it.
+// Currently (1.17 dev) such a stack map is always ABI0;
+// any ABI wrapper that is present is nosplit, hence a precise
+// stack map is not needed there (the parameters survive only long
+// enough to call the wrapped assembly function).
 // This always returns a freshly copied ABI.
-func AbiForFunc(fn *ir.Func) *abi.ABIConfig {
-	return abiForFunc(fn, ssaConfig.ABI0, ssaConfig.ABI1).Copy() // No idea what races will result, be safe
+func AbiForBodylessFuncStackMap(fn *ir.Func) *abi.ABIConfig {
+	return ssaConfig.ABI0.Copy() // No idea what races will result, be safe
 }
 
 // TODO (NLT 2021-04-15) This must be changed to a name that cannot match; it may be helpful to other register ABI work to keep the trigger-logic
@@ -4839,24 +4842,24 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 	var codeptr *ssa.Value // ptr to target code (if dynamic)
 	var rcvr *ssa.Value    // receiver to set
 	fn := n.X
-	var ACArgs []*types.Type    // AuxCall args
-	var ACResults []*types.Type // AuxCall results
-	var callArgs []*ssa.Value   // For late-expansion, the args themselves (not stored, args to the call instead).
-	inRegisters := false
+	var ACArgs []*types.Type       // AuxCall args
+	var ACResults []*types.Type    // AuxCall results
+	var callArgs []*ssa.Value      // For late-expansion, the args themselves (not stored, args to the call instead).
+	inRegistersForTesting := false // If a call uses register ABI for one of the testing reasons, pragma, magic types, magic names
 
 	var magicFnNameSym *types.Sym
 	if fn.Name() != nil {
 		magicFnNameSym = fn.Name().Sym()
 		ss := magicFnNameSym.Name
 		if strings.HasSuffix(ss, magicNameDotSuffix) {
-			inRegisters = true
+			inRegistersForTesting = true
 		}
 	}
 	if magicFnNameSym == nil && n.Op() == ir.OCALLINTER {
 		magicFnNameSym = fn.(*ir.SelectorExpr).Sym()
 		ss := magicFnNameSym.Name
 		if strings.HasSuffix(ss, magicNameDotSuffix[1:]) {
-			inRegisters = true
+			inRegistersForTesting = true
 		}
 	}
 
@@ -4872,7 +4875,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 			// TODO(register args) remove after register abi is working
 			inRegistersImported := fn.Pragma()&ir.RegisterParams != 0
 			inRegistersSamePackage := fn.Func != nil && fn.Func.Pragma&ir.RegisterParams != 0
-			inRegisters = inRegisters || inRegistersImported || inRegistersSamePackage
+			inRegistersForTesting = inRegistersForTesting || inRegistersImported || inRegistersSamePackage
 			break
 		}
 		closure = s.expr(fn)
@@ -4898,13 +4901,13 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 	}
 
 	if regAbiForFuncType(n.X.Type().FuncType()) {
-		// fmt.Printf("Saw magic last type in call %v\n", n)
-		inRegisters = true
+		// Magic last type in input args to call
+		inRegistersForTesting = true
 	}
 
-	callABI := s.f.ABI1
-	if !inRegisters {
-		callABI = s.f.ABI0
+	callABI := s.f.ABIDefault
+	if inRegistersForTesting {
+		callABI = s.f.ABI1
 	}
 
 	params := callABI.ABIAnalyze(n.X.Type(), false /* Do not set (register) nNames from caller side -- can cause races. */)
-- 
GitLab


From bb2fc21c3b818c45fad23fdf5f8bd83bbc074dce Mon Sep 17 00:00:00 2001
From: Lizzzcai <lizzzcai1@gmail.com>
Date: Mon, 29 Mar 2021 18:51:06 +0800
Subject: [PATCH 1283/2400] runtime: fix typos in comments

Change-Id: Ia70e8bdc6d2cf1195d7a3b5d33f180ae2db73e29
Reviewed-on: https://go-review.googlesource.com/c/go/+/305369
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Ben Shi <powerman1st@163.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/malloc.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/runtime/malloc.go b/src/runtime/malloc.go
index 8435f96532..5e4974d40e 100644
--- a/src/runtime/malloc.go
+++ b/src/runtime/malloc.go
@@ -933,7 +933,7 @@ func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 		}
 
 		if inittrace.active && inittrace.id == getg().goid {
-			// Init functions are executed sequentially in a single Go routine.
+			// Init functions are executed sequentially in a single goroutine.
 			inittrace.allocs += 1
 		}
 	}
@@ -1137,7 +1137,7 @@ func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 		}
 
 		if inittrace.active && inittrace.id == getg().goid {
-			// Init functions are executed sequentially in a single Go routine.
+			// Init functions are executed sequentially in a single goroutine.
 			inittrace.bytes += uint64(size)
 		}
 	}
-- 
GitLab


From 032ef4bbfc5b976085c561eb4a134b780625f410 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Wed, 10 Mar 2021 15:25:21 -0800
Subject: [PATCH 1284/2400] cmd/compile: fix creation of named generic types
 (setting of t.nod)

The correct setting of t.nod is needed when exporting types. Make sure
we create instantiated named types correctly so t.nod is set.

New test file interfacearg.go that tests this (by instantiating a type
with an interface). Also has tests for various kinds of method
expressions.

Change-Id: Ia7fd9debd495336b73788af9e35d72331bb7d2b5
Reviewed-on: https://go-review.googlesource.com/c/go/+/305730
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/stencil.go | 20 +++++++----
 src/cmd/compile/internal/noder/types.go   |  4 +--
 src/cmd/compile/internal/types/type.go    |  9 ++---
 test/typeparam/interfacearg.go            | 44 +++++++++++++++++++++++
 4 files changed, 64 insertions(+), 13 deletions(-)
 create mode 100644 test/typeparam/interfacearg.go

diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 8dcc9d811e..78e701eaf8 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -715,12 +715,10 @@ func (subst *subster) typ(t *types.Type) *types.Type {
 			return newsym.Def.Type()
 		}
 
-		// In order to deal with recursive generic types, create a TFORW type
-		// initially and set its Def field, so it can be found if this type
-		// appears recursively within the type.
-		forw = types.New(types.TFORW)
-		forw.SetSym(newsym)
-		newsym.Def = ir.TypeNode(forw)
+		// In order to deal with recursive generic types, create a TFORW
+		// type initially and set the Def field of its sym, so it can be
+		// found if this type appears recursively within the type.
+		forw = newNamedTypeWithSym(t.Pos(), newsym)
 		//println("Creating new type by sub", newsym.Name, forw.HasTParam())
 		forw.SetRParams(neededTargs)
 	}
@@ -894,3 +892,13 @@ func deref(t *types.Type) *types.Type {
 	}
 	return t
 }
+
+// newNamedTypeWithSym returns a TFORW type t with name specified by sym, such
+// that t.nod and sym.Def are set correctly.
+func newNamedTypeWithSym(pos src.XPos, sym *types.Sym) *types.Type {
+	name := ir.NewDeclNameAt(pos, ir.OTYPE, sym)
+	forw := types.NewNamed(name)
+	name.SetType(forw)
+	sym.Def = name
+	return forw
+}
diff --git a/src/cmd/compile/internal/noder/types.go b/src/cmd/compile/internal/noder/types.go
index b196cb5945..06c584714e 100644
--- a/src/cmd/compile/internal/noder/types.go
+++ b/src/cmd/compile/internal/noder/types.go
@@ -120,10 +120,8 @@ func (g *irgen) typ0(typ types2.Type) *types.Type {
 			// which may set HasTParam) before translating the
 			// underlying type itself, so we handle recursion
 			// correctly, including via method signatures.
-			ntyp := types.New(types.TFORW)
+			ntyp := newNamedTypeWithSym(g.pos(typ.Obj().Pos()), s)
 			g.typs[typ] = ntyp
-			ntyp.SetSym(s)
-			s.Def = ir.TypeNode(ntyp)
 
 			// If ntyp still has type params, then we must be
 			// referencing something like 'value[T2]', as when
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 7bf63764b8..31a99781d1 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -160,8 +160,9 @@ type Type struct {
 	methods    Fields
 	allMethods Fields
 
-	nod        Object // canonical OTYPE node
-	underlying *Type  // original type (type literal or predefined type)
+	// canonical OTYPE node for a named type (should be an ir.Name node with same sym)
+	nod        Object
+	underlying *Type // original type (type literal or predefined type)
 
 	// Cache of composite types, with this type being the element type.
 	cache struct {
@@ -1642,7 +1643,7 @@ var (
 	TypeResultMem = newResults([]*Type{TypeMem})
 )
 
-// NewNamed returns a new named type for the given type name.
+// NewNamed returns a new named type for the given type name. obj should be an ir.Name.
 func NewNamed(obj Object) *Type {
 	t := New(TFORW)
 	t.sym = obj.Sym()
@@ -1650,7 +1651,7 @@ func NewNamed(obj Object) *Type {
 	return t
 }
 
-// Obj returns the type name for the named type t.
+// Obj returns the canonical type name node for a named type t, nil for an unnamed type.
 func (t *Type) Obj() Object {
 	if t.sym != nil {
 		return t.nod
diff --git a/test/typeparam/interfacearg.go b/test/typeparam/interfacearg.go
new file mode 100644
index 0000000000..e2d85e3647
--- /dev/null
+++ b/test/typeparam/interfacearg.go
@@ -0,0 +1,44 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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
+
+type I interface{}
+
+type _S[T any] struct {
+	*T
+}
+
+// F is a non-generic function, but has a type _S[I] which is instantiated from a
+// generic type. Test that _S[I] is successfully exported.
+func F() {
+	v := _S[I]{}
+	if v.T != nil {
+		panic(v)
+	}
+}
+
+// Testing the various combinations of method expressions.
+type S1 struct{}
+func (*S1) M() {}
+
+type S2 struct{}
+func (S2) M() {}
+
+func _F1[T interface{ M() }](t T) {
+	_ = T.M
+}
+
+func F2() {
+        _F1(&S1{})
+        _F1(S2{})
+        _F1(&S2{})
+}
+
+func main() {
+	F()
+	F2()
+}
-- 
GitLab


From a81b5e4d0a843e6ef28c8b933904a03fd8666f3e Mon Sep 17 00:00:00 2001
From: chenjie <chenjie@chenjie.info>
Date: Tue, 30 Mar 2021 07:23:53 +0000
Subject: [PATCH 1285/2400] crypto/elliptic: fix some typos

Change-Id: I1c2900d4e1c0b6108f13c4060d994d966f3e18f3
GitHub-Last-Rev: 3fde453686ab3fdeb77d2f73c09e4a679056adf3
GitHub-Pull-Request: golang/go#45295
Reviewed-on: https://go-review.googlesource.com/c/go/+/305773
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Ben Shi <powerman1st@163.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/crypto/elliptic/p256.go            | 2 +-
 src/crypto/elliptic/p256_asm_ppc64le.s | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/crypto/elliptic/p256.go b/src/crypto/elliptic/p256.go
index 3bb7bb70b6..b2b12c8f13 100644
--- a/src/crypto/elliptic/p256.go
+++ b/src/crypto/elliptic/p256.go
@@ -327,7 +327,7 @@ func p256ReduceDegree(out *[p256Limbs]uint32, tmp [17]uint64) {
 	var tmp2 [18]uint32
 	var carry, x, xMask uint32
 
-	// tmp contains 64-bit words with the same 29,28,29-bit positions as an
+	// tmp contains 64-bit words with the same 29,28,29-bit positions as a
 	// field element. So the top of an element of tmp might overlap with
 	// another element two positions down. The following loop eliminates
 	// this overlap.
diff --git a/src/crypto/elliptic/p256_asm_ppc64le.s b/src/crypto/elliptic/p256_asm_ppc64le.s
index 924e365c6c..69e96e2696 100644
--- a/src/crypto/elliptic/p256_asm_ppc64le.s
+++ b/src/crypto/elliptic/p256_asm_ppc64le.s
@@ -870,7 +870,7 @@ TEXT ·p256FromMont(SB), NOSPLIT, $0-48
  *                                                                *Mi obra de arte de siglo XXI @vpaprots
  *
  *
- * First group is special, doesnt get the two inputs:
+ * First group is special, doesn't get the two inputs:
  *                                             +--------+--------+<-+
  *                                     +-------|  ADD2  |  ADD1  |--|-----+
  *                                     |       +--------+--------+  |     |
-- 
GitLab


From e4a4161f1f3157550846e1b6bd4fe83aae15778e Mon Sep 17 00:00:00 2001
From: Michael Pratt <mpratt@google.com>
Date: Thu, 11 Mar 2021 12:28:45 -0500
Subject: [PATCH 1286/2400] runtime: non-strict InlTreeIndex lookup in
 Frames.Next

When using cgo, some of the frames can be provided by cgoTraceback, a
cgo-provided function to generate C tracebacks. Unlike Go tracebacks,
cgoTraceback has no particular guarantees that it produces valid
tracebacks.

If one of the (invalid) frames happens to put the PC in the alignment
region at the end of a function (filled with int 3's on amd64), then
Frames.Next will find a valid funcInfo for the PC, but pcdatavalue will
panic because PCDATA doesn't cover this PC.

Tolerate this case by doing a non-strict PCDATA lookup. We'll still show
a bogus frame, but at least avoid throwing.

Fixes #44971

Change-Id: I9eed728470d6f264179a7615bd19845c941db78c
Reviewed-on: https://go-review.googlesource.com/c/go/+/301369
Trust: Michael Pratt <mpratt@google.com>
Run-TryBot: Michael Pratt <mpratt@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/symtab.go      |  4 +-
 src/runtime/symtab_test.go | 85 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 88 insertions(+), 1 deletion(-)

diff --git a/src/runtime/symtab.go b/src/runtime/symtab.go
index 00f802aaa7..8430ca87ec 100644
--- a/src/runtime/symtab.go
+++ b/src/runtime/symtab.go
@@ -102,7 +102,9 @@ func (ci *Frames) Next() (frame Frame, more bool) {
 		name := funcname(funcInfo)
 		if inldata := funcdata(funcInfo, _FUNCDATA_InlTree); inldata != nil {
 			inltree := (*[1 << 20]inlinedCall)(inldata)
-			ix := pcdatavalue(funcInfo, _PCDATA_InlTreeIndex, pc, nil)
+			// Non-strict as cgoTraceback may have added bogus PCs
+			// with a valid funcInfo but invalid PCDATA.
+			ix := pcdatavalue1(funcInfo, _PCDATA_InlTreeIndex, pc, nil, false)
 			if ix >= 0 {
 				// Note: entry is not modified. It always refers to a real frame, not an inlined one.
 				f = nil
diff --git a/src/runtime/symtab_test.go b/src/runtime/symtab_test.go
index 01e5002659..ffa07c7f3a 100644
--- a/src/runtime/symtab_test.go
+++ b/src/runtime/symtab_test.go
@@ -8,6 +8,7 @@ import (
 	"runtime"
 	"strings"
 	"testing"
+	"unsafe"
 )
 
 func TestCaller(t *testing.T) {
@@ -165,3 +166,87 @@ func TestNilName(t *testing.T) {
 		t.Errorf("Name() = %q, want %q", got, "")
 	}
 }
+
+var dummy int
+
+func inlined() {
+	// Side effect to prevent elimination of this entire function.
+	dummy = 42
+}
+
+// A function with an InlTree. Returns a PC within the function body.
+//
+// No inline to ensure this complete function appears in output.
+//
+//go:noinline
+func tracebackFunc(t *testing.T) uintptr {
+	// This body must be more complex than a single call to inlined to get
+	// an inline tree.
+	inlined()
+	inlined()
+
+	// Acquire a PC in this function.
+	pc, _, _, ok := runtime.Caller(0)
+	if !ok {
+		t.Fatalf("Caller(0) got ok false, want true")
+	}
+
+	return pc
+}
+
+// Test that CallersFrames handles PCs in the alignment region between
+// functions (int 3 on amd64) without crashing.
+//
+// Go will never generate a stack trace containing such an address, as it is
+// not a valid call site. However, the cgo traceback function passed to
+// runtime.SetCgoTraceback may not be completely accurate and may incorrect
+// provide PCs in Go code or the alignement region between functions.
+//
+// Go obviously doesn't easily expose the problematic PCs to running programs,
+// so this test is a bit fragile. Some details:
+//
+// * tracebackFunc is our target function. We want to get a PC in the
+//   alignment region following this function. This function also has other
+//   functions inlined into it to ensure it has an InlTree (this was the source
+//   of the bug in issue 44971).
+//
+// * We acquire a PC in tracebackFunc, walking forwards until FuncForPC says
+//   we're in a new function. The last PC of the function according to FuncForPC
+//   should be in the alignment region (assuming the function isn't already
+//   perfectly aligned).
+//
+// This is a regression test for issue 44971.
+func TestFunctionAlignmentTraceback(t *testing.T) {
+	pc := tracebackFunc(t)
+
+	// Double-check we got the right PC.
+	f := runtime.FuncForPC(pc)
+	if !strings.HasSuffix(f.Name(), "tracebackFunc") {
+		t.Fatalf("Caller(0) = %+v, want tracebackFunc", f)
+	}
+
+	// Iterate forward until we find a different function. Back up one
+	// instruction is (hopefully) an alignment instruction.
+	for runtime.FuncForPC(pc) == f {
+		pc++
+	}
+	pc--
+
+	// Is this an alignment region filler instruction? We only check this
+	// on amd64 for simplicity. If this function has no filler, then we may
+	// get a false negative, but will never get a false positive.
+	if runtime.GOARCH == "amd64" {
+		code := *(*uint8)(unsafe.Pointer(pc))
+		if code != 0xcc { // INT $3
+			t.Errorf("PC %v code got %#x want 0xcc", pc, code)
+		}
+	}
+
+	// Finally ensure that Frames.Next doesn't crash when processing this
+	// PC.
+	frames := runtime.CallersFrames([]uintptr{pc})
+	frame, _ := frames.Next()
+	if frame.Func != f {
+		t.Errorf("frames.Next() got %+v want %+v", frame.Func, f)
+	}
+}
-- 
GitLab


From c274a7c03be7b69d54d3307b954f6a0eb298c860 Mon Sep 17 00:00:00 2001
From: hqpko <whaibin01@hotmail.com>
Date: Tue, 30 Mar 2021 14:53:24 +0000
Subject: [PATCH 1287/2400] cmd/compile/internal/noder: limit the number of
 goroutine

Change-Id: I7f05108fea351a4895dde6090bf86beb822f2c28
GitHub-Last-Rev: e4a2d3a11aa258f2ddf5e39ab4769883f94e3dab
GitHub-Pull-Request: golang/go#45289
Reviewed-on: https://go-review.googlesource.com/c/go/+/305869
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/noder/noder.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 4c7c9fc322..2c021cc570 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -46,8 +46,8 @@ func LoadPackage(filenames []string) {
 		noders[i] = &p
 
 		filename := filename
+		sem <- struct{}{}
 		go func() {
-			sem <- struct{}{}
 			defer func() { <-sem }()
 			defer close(p.err)
 			fbase := syntax.NewFileBase(filename)
-- 
GitLab


From 89b141c06e1f97e7ccd84aa820ea0b64291ac3f8 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Mon, 29 Mar 2021 18:46:37 -0400
Subject: [PATCH 1288/2400] cmd/compile: emit writebarriers in specified ABI

old code was always ABI0, new code tracks the default
this may cause some write barrier removals to fail to fire

Updates #40724.

Change-Id: I656bdd5511c5bd6ee6e021999e30d842a6b9f0a5
Reviewed-on: https://go-review.googlesource.com/c/go/+/305671
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/writebarrier.go | 48 ++++++++++++++------
 1 file changed, 33 insertions(+), 15 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/writebarrier.go b/src/cmd/compile/internal/ssa/writebarrier.go
index bbb5a7c148..f0eceb7abe 100644
--- a/src/cmd/compile/internal/ssa/writebarrier.go
+++ b/src/cmd/compile/internal/ssa/writebarrier.go
@@ -483,38 +483,56 @@ func (f *Func) computeZeroMap() map[ID]ZeroRegion {
 func wbcall(pos src.XPos, b *Block, fn, typ *obj.LSym, ptr, val, mem, sp, sb *Value) *Value {
 	config := b.Func.Config
 
+	var wbargs []*Value
+	// TODO (register args) this is a bit of a hack.
+	inRegs := b.Func.ABIDefault == b.Func.ABI1 && len(config.intParamRegs) >= 3
+
 	// put arguments on stack
 	off := config.ctxt.FixedFrameSize()
 
 	var argTypes []*types.Type
 	if typ != nil { // for typedmemmove
 		taddr := b.NewValue1A(pos, OpAddr, b.Func.Config.Types.Uintptr, typ, sb)
-		off = round(off, taddr.Type.Alignment())
-		arg := b.NewValue1I(pos, OpOffPtr, taddr.Type.PtrTo(), off, sp)
-		mem = b.NewValue3A(pos, OpStore, types.TypeMem, ptr.Type, arg, taddr, mem)
 		argTypes = append(argTypes, b.Func.Config.Types.Uintptr)
-		off += taddr.Type.Size()
+		if inRegs {
+			wbargs = append(wbargs, taddr)
+		} else {
+			off = round(off, taddr.Type.Alignment())
+			arg := b.NewValue1I(pos, OpOffPtr, taddr.Type.PtrTo(), off, sp)
+			mem = b.NewValue3A(pos, OpStore, types.TypeMem, ptr.Type, arg, taddr, mem)
+			off += taddr.Type.Size()
+		}
 	}
 
-	off = round(off, ptr.Type.Alignment())
-	arg := b.NewValue1I(pos, OpOffPtr, ptr.Type.PtrTo(), off, sp)
-	mem = b.NewValue3A(pos, OpStore, types.TypeMem, ptr.Type, arg, ptr, mem)
 	argTypes = append(argTypes, ptr.Type)
-	off += ptr.Type.Size()
+	if inRegs {
+		wbargs = append(wbargs, ptr)
+	} else {
+		off = round(off, ptr.Type.Alignment())
+		arg := b.NewValue1I(pos, OpOffPtr, ptr.Type.PtrTo(), off, sp)
+		mem = b.NewValue3A(pos, OpStore, types.TypeMem, ptr.Type, arg, ptr, mem)
+		off += ptr.Type.Size()
+	}
 
 	if val != nil {
-		off = round(off, val.Type.Alignment())
-		arg = b.NewValue1I(pos, OpOffPtr, val.Type.PtrTo(), off, sp)
-		mem = b.NewValue3A(pos, OpStore, types.TypeMem, val.Type, arg, val, mem)
 		argTypes = append(argTypes, val.Type)
-		off += val.Type.Size()
+		if inRegs {
+			wbargs = append(wbargs, val)
+		} else {
+			off = round(off, val.Type.Alignment())
+			arg := b.NewValue1I(pos, OpOffPtr, val.Type.PtrTo(), off, sp)
+			mem = b.NewValue3A(pos, OpStore, types.TypeMem, val.Type, arg, val, mem)
+			off += val.Type.Size()
+		}
 	}
 	off = round(off, config.PtrSize)
+	wbargs = append(wbargs, mem)
 
 	// issue call
-	mem = b.NewValue1A(pos, OpStaticCall, types.TypeResultMem, StaticAuxCall(fn, b.Func.ABIDefault.ABIAnalyzeTypes(nil, argTypes, nil)), mem)
-	mem.AuxInt = off - config.ctxt.FixedFrameSize()
-	return b.NewValue1I(pos, OpSelectN, types.TypeMem, 0, mem)
+	call := b.NewValue0A(pos, OpStaticCall, types.TypeResultMem, StaticAuxCall(fn, b.Func.ABIDefault.ABIAnalyzeTypes(nil, argTypes, nil)))
+	call.AddArgs(wbargs...)
+	call.AuxInt = off - config.ctxt.FixedFrameSize()
+	return b.NewValue1I(pos, OpSelectN, types.TypeMem, 0, call)
 }
 
 // round to a multiple of r, r is a power of 2
-- 
GitLab


From 43afb1a22016ec537915ed8ade0039ad8c6559ce Mon Sep 17 00:00:00 2001
From: Shulhan <m.shulhan@gmail.com>
Date: Sun, 28 Mar 2021 23:04:33 +0700
Subject: [PATCH 1289/2400] cmd/go: fix documentation on how to create new
 go.mod file
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The correct command to create new go.mod file should be 'go mod init',
not 'go help init'.

Change-Id: I1150621987d989997f8b75e6a13fe96423a11cf3
Reviewed-on: https://go-review.googlesource.com/c/go/+/305289
Reviewed-by: Jay Conrod <jayconrod@google.com>
Reviewed-by: Daniel Martí <mvdan@mvdan.cc>
Trust: Jay Conrod <jayconrod@google.com>
Trust: Daniel Martí <mvdan@mvdan.cc>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/alldocs.go               | 2 +-
 src/cmd/go/internal/modload/help.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index b15b77fac8..3fece365e8 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -1952,7 +1952,7 @@
 // The go.mod file format is described in detail at
 // https://golang.org/ref/mod#go-mod-file.
 //
-// To create a new go.mod file, use 'go help init'. For details see
+// To create a new go.mod file, use 'go mod init'. For details see
 // 'go help mod init' or https://golang.org/ref/mod#go-mod-init.
 //
 // To add missing module requirements or remove unneeded requirements,
diff --git a/src/cmd/go/internal/modload/help.go b/src/cmd/go/internal/modload/help.go
index fd39ddd94e..886ad62bd9 100644
--- a/src/cmd/go/internal/modload/help.go
+++ b/src/cmd/go/internal/modload/help.go
@@ -46,7 +46,7 @@ marking the root of the main (current) module.
 The go.mod file format is described in detail at
 https://golang.org/ref/mod#go-mod-file.
 
-To create a new go.mod file, use 'go help init'. For details see
+To create a new go.mod file, use 'go mod init'. For details see
 'go help mod init' or https://golang.org/ref/mod#go-mod-init.
 
 To add missing module requirements or remove unneeded requirements,
-- 
GitLab


From 6cadfe2fee9b063651f163aaa4734979944e7a9f Mon Sep 17 00:00:00 2001
From: Ignacio Hagopian <jsign.uy@gmail.com>
Date: Tue, 30 Mar 2021 17:18:06 +0000
Subject: [PATCH 1290/2400] reflect: cache IsVariadic calls in Call
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

These calls are cacheable, so do that to avoid doing extra work.

This opportunity was discovered while taking a look at a CPU profile
while investigating #7818.

I added a BenchmarkCallMethod, which is similar to BechmarkCall but
for a method receiver.

Benchmark results, including the new BenchmarkCallMethod:

	name                       old time/op    new time/op    delta
	Call-16                      22.0ns ±19%    20.2ns ±17%  -8.08%  (p=0.000 n=40+40)
	CallMethod-16                 100ns ± 3%      91ns ± 2%  -9.13%  (p=0.000 n=40+39)
	CallArgCopy/size=128-16      15.7ns ± 1%    14.3ns ± 4%  -8.98%  (p=0.000 n=38+37)
	CallArgCopy/size=256-16      15.9ns ± 3%    15.0ns ± 5%  -6.12%  (p=0.000 n=39+39)
	CallArgCopy/size=1024-16     18.8ns ± 6%    17.1ns ± 6%  -9.03%  (p=0.000 n=38+38)
	CallArgCopy/size=4096-16     26.6ns ± 3%    25.2ns ± 4%  -5.19%  (p=0.000 n=39+40)
	CallArgCopy/size=65536-16     379ns ± 3%     371ns ± 5%  -2.11%  (p=0.000 n=39+40)

	name                       old alloc/op   new alloc/op   delta
	Call-16                       0.00B          0.00B         ~     (all equal)
	CallMethod-16                 0.00B          0.00B         ~     (all equal)

	name                       old allocs/op  new allocs/op  delta
	Call-16                        0.00           0.00         ~     (all equal)
	CallMethod-16                  0.00           0.00         ~     (all equal)

	name                       old speed      new speed      delta
	CallArgCopy/size=128-16    8.13GB/s ± 1%  8.92GB/s ± 4%  +9.77%  (p=0.000 n=38+38)
	CallArgCopy/size=256-16    16.1GB/s ± 3%  17.1GB/s ± 5%  +6.56%  (p=0.000 n=39+39)
	CallArgCopy/size=1024-16   54.6GB/s ± 6%  60.1GB/s ± 5%  +9.93%  (p=0.000 n=38+38)
	CallArgCopy/size=4096-16    154GB/s ± 5%   163GB/s ± 4%  +5.63%  (p=0.000 n=40+40)
	CallArgCopy/size=65536-16   173GB/s ± 3%   177GB/s ± 5%  +2.18%  (p=0.000 n=39+40)

Updates #7818.

Change-Id: I94f88811ea9faf3dc2543984a13b360b5db66a4b
GitHub-Last-Rev: 9bbaa1854aa32cade905eddb05737e6224c372a1
GitHub-Pull-Request: golang/go#43475
Reviewed-on: https://go-review.googlesource.com/c/go/+/281252
Reviewed-by: Daniel Martí <mvdan@mvdan.cc>
Reviewed-by: Keith Randall <khr@golang.org>
Trust: Daniel Martí <mvdan@mvdan.cc>
Trust: Brad Fitzpatrick <bradfitz@golang.org>
Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/reflect/all_test.go | 16 ++++++++++++++++
 src/reflect/value.go    |  9 +++++----
 2 files changed, 21 insertions(+), 4 deletions(-)

diff --git a/src/reflect/all_test.go b/src/reflect/all_test.go
index accda7fa74..e4b74f72d9 100644
--- a/src/reflect/all_test.go
+++ b/src/reflect/all_test.go
@@ -1942,6 +1942,22 @@ func BenchmarkCall(b *testing.B) {
 	})
 }
 
+type myint int64
+
+func (i *myint) inc() {
+	*i = *i + 1
+}
+
+func BenchmarkCallMethod(b *testing.B) {
+	b.ReportAllocs()
+	z := new(myint)
+
+	v := ValueOf(z.inc)
+	for i := 0; i < b.N; i++ {
+		v.Call(nil)
+	}
+}
+
 func BenchmarkCallArgCopy(b *testing.B) {
 	byteArray := func(n int) Value {
 		return Zero(ArrayOf(n, TypeOf(byte(0))))
diff --git a/src/reflect/value.go b/src/reflect/value.go
index eae1b9bf29..52639d5aad 100644
--- a/src/reflect/value.go
+++ b/src/reflect/value.go
@@ -378,8 +378,9 @@ func (v Value) call(op string, in []Value) []Value {
 
 	isSlice := op == "CallSlice"
 	n := t.NumIn()
+	isVariadic := t.IsVariadic()
 	if isSlice {
-		if !t.IsVariadic() {
+		if !isVariadic {
 			panic("reflect: CallSlice of non-variadic function")
 		}
 		if len(in) < n {
@@ -389,13 +390,13 @@ func (v Value) call(op string, in []Value) []Value {
 			panic("reflect: CallSlice with too many input arguments")
 		}
 	} else {
-		if t.IsVariadic() {
+		if isVariadic {
 			n--
 		}
 		if len(in) < n {
 			panic("reflect: Call with too few input arguments")
 		}
-		if !t.IsVariadic() && len(in) > n {
+		if !isVariadic && len(in) > n {
 			panic("reflect: Call with too many input arguments")
 		}
 	}
@@ -409,7 +410,7 @@ func (v Value) call(op string, in []Value) []Value {
 			panic("reflect: " + op + " using " + xt.String() + " as type " + targ.String())
 		}
 	}
-	if !isSlice && t.IsVariadic() {
+	if !isSlice && isVariadic {
 		// prepare slice for remaining values
 		m := len(in) - n
 		slice := MakeSlice(t.In(n), m, m)
-- 
GitLab


From c40dc677be05e2774c7805bf55002a960cb4dec5 Mon Sep 17 00:00:00 2001
From: "Norman B. Lancaster" <qbradq@gmail.com>
Date: Tue, 30 Mar 2021 17:30:45 +0000
Subject: [PATCH 1291/2400] go/doc: avoid panic on references to functions with
 no body
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This change guards a call to ast.Inspect with a nil check on the first
argument. This avoids a panic when inspecting a reference to a function
with a nil body. This can only happen when a function body is defined outside Go.

Fixes #42706

Change-Id: I91bc607b24b6224920c24cfd07e76ce7737a98d4
GitHub-Last-Rev: 08072b9ce5c1fd4ee77eba6f1acc0a84e838ad7b
GitHub-Pull-Request: golang/go#43011
Reviewed-on: https://go-review.googlesource.com/c/go/+/275516
Reviewed-by: Daniel Martí <mvdan@mvdan.cc>
Trust: Daniel Martí <mvdan@mvdan.cc>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/go/doc/example.go      |  5 ++++-
 src/go/doc/example_test.go | 25 +++++++++++++++++++++++++
 2 files changed, 29 insertions(+), 1 deletion(-)

diff --git a/src/go/doc/example.go b/src/go/doc/example.go
index 125fd530b1..274000cecb 100644
--- a/src/go/doc/example.go
+++ b/src/go/doc/example.go
@@ -237,7 +237,10 @@ func playExample(file *ast.File, f *ast.FuncDecl) *ast.File {
 				}
 			}
 
-			ast.Inspect(d.Body, inspectFunc)
+			// Functions might not have a body. See #42706.
+			if d.Body != nil {
+				ast.Inspect(d.Body, inspectFunc)
+			}
 		case *ast.GenDecl:
 			for _, spec := range d.Specs {
 				switch s := spec.(type) {
diff --git a/src/go/doc/example_test.go b/src/go/doc/example_test.go
index 7c96f0300a..cf1b702549 100644
--- a/src/go/doc/example_test.go
+++ b/src/go/doc/example_test.go
@@ -352,6 +352,25 @@ func main() {
 }
 `
 
+const exampleWholeFileExternalFunction = `package foo_test
+
+func foo(int)
+
+func Example() {
+	foo(42)
+	// Output:
+}
+`
+
+const exampleWholeFileExternalFunctionOutput = `package main
+
+func foo(int)
+
+func main() {
+	foo(42)
+}
+`
+
 var exampleWholeFileTestCases = []struct {
 	Title, Source, Play, Output string
 }{
@@ -367,6 +386,12 @@ var exampleWholeFileTestCases = []struct {
 		exampleWholeFileFunctionOutput,
 		"Hello, world!\n",
 	},
+	{
+		"ExternalFunction",
+		exampleWholeFileExternalFunction,
+		exampleWholeFileExternalFunctionOutput,
+		"",
+	},
 }
 
 func TestExamplesWholeFile(t *testing.T) {
-- 
GitLab


From 3300390ec70c6b8e2392e4ab32342d426e2d3532 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Tue, 30 Mar 2021 08:49:42 -0400
Subject: [PATCH 1292/2400] cmd/compile: make amd64 version of zerorange
 regabi-friendly

Change the amd64 version of 'zerorange' to avoid using RAX/RDI, since
it can be called in a context when one of these registers is live
(contains an incoming parameter).

Updates #40724.

Change-Id: Ibfa2b4e156b876354d4f8bd04eb8773c7056d948
Reviewed-on: https://go-review.googlesource.com/c/go/+/305829
Trust: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/amd64/ggen.go | 32 +++++++++++++++-----------
 1 file changed, 19 insertions(+), 13 deletions(-)

diff --git a/src/cmd/compile/internal/amd64/ggen.go b/src/cmd/compile/internal/amd64/ggen.go
index 259a083f75..e56ec90dc8 100644
--- a/src/cmd/compile/internal/amd64/ggen.go
+++ b/src/cmd/compile/internal/amd64/ggen.go
@@ -56,7 +56,7 @@ func dzDI(b int64) int64 {
 
 func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.Prog {
 	const (
-		ax  = 1 << iota // if AX is already zeroed.
+		r13 = 1 << iota // if R13 is already zeroed.
 		x15             // if X15 is already zeroed. Note: in new ABI, X15 is always zero.
 	)
 
@@ -69,21 +69,21 @@ func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.
 		if cnt%int64(types.PtrSize) != 0 {
 			base.Fatalf("zerorange count not a multiple of widthptr %d", cnt)
 		}
-		if *state&ax == 0 {
-			p = pp.Append(p, x86.AMOVQ, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
-			*state |= ax
+		if *state&r13 == 0 {
+			p = pp.Append(p, x86.AMOVQ, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_R13, 0)
+			*state |= r13
 		}
-		p = pp.Append(p, x86.AMOVL, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_MEM, x86.REG_SP, off)
+		p = pp.Append(p, x86.AMOVL, obj.TYPE_REG, x86.REG_R13, 0, obj.TYPE_MEM, x86.REG_SP, off)
 		off += int64(types.PtrSize)
 		cnt -= int64(types.PtrSize)
 	}
 
 	if cnt == 8 {
-		if *state&ax == 0 {
-			p = pp.Append(p, x86.AMOVQ, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
-			*state |= ax
+		if *state&r13 == 0 {
+			p = pp.Append(p, x86.AMOVQ, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_R13, 0)
+			*state |= r13
 		}
-		p = pp.Append(p, x86.AMOVQ, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_MEM, x86.REG_SP, off)
+		p = pp.Append(p, x86.AMOVQ, obj.TYPE_REG, x86.REG_R13, 0, obj.TYPE_MEM, x86.REG_SP, off)
 	} else if !isPlan9 && cnt <= int64(8*types.RegSize) {
 		if !objabi.Experiment.RegabiG && *state&x15 == 0 {
 			p = pp.Append(p, x86.AXORPS, obj.TYPE_REG, x86.REG_X15, 0, obj.TYPE_REG, x86.REG_X15, 0)
@@ -102,17 +102,23 @@ func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.
 			p = pp.Append(p, x86.AXORPS, obj.TYPE_REG, x86.REG_X15, 0, obj.TYPE_REG, x86.REG_X15, 0)
 			*state |= x15
 		}
+		// Save DI to r12. With the amd64 Go register abi, DI can contain
+		// an incoming parameter, whereas R12 is always scratch.
+		p = pp.Append(p, x86.AMOVQ, obj.TYPE_REG, x86.REG_DI, 0, obj.TYPE_REG, x86.REG_R12, 0)
+		// Emit duffzero call
 		p = pp.Append(p, leaptr, obj.TYPE_MEM, x86.REG_SP, off+dzDI(cnt), obj.TYPE_REG, x86.REG_DI, 0)
 		p = pp.Append(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_ADDR, 0, dzOff(cnt))
 		p.To.Sym = ir.Syms.Duffzero
-
 		if cnt%16 != 0 {
 			p = pp.Append(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X15, 0, obj.TYPE_MEM, x86.REG_DI, -int64(8))
 		}
+		// Restore DI from r12
+		p = pp.Append(p, x86.AMOVQ, obj.TYPE_REG, x86.REG_R12, 0, obj.TYPE_REG, x86.REG_DI, 0)
+
 	} else {
-		if *state&ax == 0 {
-			p = pp.Append(p, x86.AMOVQ, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
-			*state |= ax
+		if *state&r13 == 0 {
+			p = pp.Append(p, x86.AMOVQ, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_R13, 0)
+			*state |= r13
 		}
 
 		p = pp.Append(p, x86.AMOVQ, obj.TYPE_CONST, 0, cnt/int64(types.RegSize), obj.TYPE_REG, x86.REG_CX, 0)
-- 
GitLab


From 1318fb4a32371311688c6b868c3041f0501b6aeb Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Mon, 29 Mar 2021 16:07:18 -0700
Subject: [PATCH 1293/2400] cmd/compile: handle partial type inference that
 doesn't require function args

Handle the case where types can be partially inferred for an
instantiated function that is not immediately called. The key for the
Inferred map is the CallExpr (if inferring types required the function
arguments) or the IndexExpr (if types could be inferred without the
function arguments).

Added new tests for the case where the function isn't immediately called
to typelist.go.

Change-Id: I60f503ad67cd192da2f2002060229efd4930dc39
Reviewed-on: https://go-review.googlesource.com/c/go/+/305909
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Dan Scales <danscales@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/noder/expr.go | 32 ++++++++------
 test/typeparam/typelist.go             | 58 ++++++++++++++++++++++++++
 2 files changed, 77 insertions(+), 13 deletions(-)

diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index ecdc7c74b1..eee39ecadb 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -94,16 +94,12 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 	case *syntax.CallExpr:
 		fun := g.expr(expr.Fun)
 
-		// The key for the Inferred map is usually the expr.
-		key := syntax.Expr(expr)
-		if _, ok := expr.Fun.(*syntax.IndexExpr); ok {
-			// If the Fun is an IndexExpr, then this may be a
-			// partial type inference case. In this case, we look up
-			// the IndexExpr in the Inferred map.
-			// TODO(gri): should types2 always record the callExpr as the key?
-			key = syntax.Expr(expr.Fun)
-		}
-		if inferred, ok := g.info.Inferred[key]; ok && len(inferred.Targs) > 0 {
+		// The key for the Inferred map is the CallExpr (if inferring
+		// types required the function arguments) or the IndexExpr below
+		// (if types could be inferred without the function arguments).
+		if inferred, ok := g.info.Inferred[expr]; ok && len(inferred.Targs) > 0 {
+			// This is the case where inferring types required the
+			// types of the function arguments.
 			targs := make([]ir.Node, len(inferred.Targs))
 			for i, targ := range inferred.Targs {
 				targs[i] = ir.TypeNode(g.typ(targ))
@@ -126,7 +122,16 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 
 	case *syntax.IndexExpr:
 		var targs []ir.Node
-		if _, ok := expr.Index.(*syntax.ListExpr); ok {
+
+		if inferred, ok := g.info.Inferred[expr]; ok && len(inferred.Targs) > 0 {
+			// This is the partial type inference case where the types
+			// can be inferred from other type arguments without using
+			// the types of the function arguments.
+			targs = make([]ir.Node, len(inferred.Targs))
+			for i, targ := range inferred.Targs {
+				targs[i] = ir.TypeNode(g.typ(targ))
+			}
+		} else if _, ok := expr.Index.(*syntax.ListExpr); ok {
 			targs = g.exprList(expr.Index)
 		} else {
 			index := g.expr(expr.Index)
@@ -137,12 +142,13 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 			// This is generic function instantiation with a single type
 			targs = []ir.Node{index}
 		}
-		// This is a generic function instantiation (e.g. min[int])
+		// This is a generic function instantiation (e.g. min[int]).
+		// Generic type instantiation is handled in the type
+		// section of expr() above (using g.typ).
 		x := g.expr(expr.X)
 		if x.Op() != ir.ONAME || x.Type().Kind() != types.TFUNC {
 			panic("Incorrect argument for generic func instantiation")
 		}
-		// This could also be an OTYPEINST once we can handle those examples.
 		n := ir.NewInstExpr(pos, ir.OFUNCINST, x, targs)
 		typed(g.typ(typ), n)
 		return n
diff --git a/test/typeparam/typelist.go b/test/typeparam/typelist.go
index 4ff3ce2f34..dd674cc889 100644
--- a/test/typeparam/typelist.go
+++ b/test/typeparam/typelist.go
@@ -62,3 +62,61 @@ func _[T interface{ type func(string) int }](f T) int {
 func _[V any, T interface { type map[string]V }](p T) V {
 	return p["test"]
 }
+
+
+// Testing partial and full type inference, including the case where the types can
+// be inferred without needing the types of the function arguments.
+
+func f0[A any, B interface{type C}, C interface{type D}, D interface{type A}](a A, b B, c C, d D)
+func _() {
+        f := f0[string]
+        f("a", "b", "c", "d")
+        f0("a", "b", "c", "d")
+}
+
+func f1[A any, B interface{type A}](a A, b B)
+func _() {
+        f := f1[int]
+        f(int(0), int(0))
+        f1(int(0), int(0))
+        f(0, 0)
+        f1(0, 0)
+}
+
+func f2[A any, B interface{type []A}](a A, b B)
+func _() {
+	f := f2[byte]
+	f(byte(0), []byte{})
+	f2(byte(0), []byte{})
+	f(0, []byte{})
+	// f2(0, []byte{}) - this one doesn't work
+}
+
+func f3[A any, B interface{type C}, C interface{type *A}](a A, b B, c C)
+func _() {
+	f := f3[int]
+	var x int
+	f(x, &x, &x)
+	f3(x, &x, &x)
+}
+
+func f4[A any, B interface{type []C}, C interface{type *A}](a A, b B, c C)
+func _() {
+	f := f4[int]
+	var x int
+	f(x, []*int{}, &x)
+	f4(x, []*int{}, &x)
+}
+
+func f5[A interface{type struct{b B; c C}}, B any, C interface{type *B}](x B) A
+func _() {
+	x := f5(1.2)
+	var _ float64 = x.b
+	var _ float64 = *x.c
+}
+
+func f6[A any, B interface{type struct{f []A}}](B) A
+func _() {
+	x := f6(struct{f []string}{})
+	var _ string = x
+}
-- 
GitLab


From e0ce0af6ef5232352852fa027fe51fa3fd01198e Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Tue, 30 Mar 2021 14:45:00 -0400
Subject: [PATCH 1294/2400] runtime: check that defer/go frames are empty

With GOEXPERIMENT=regabidefer, these frames should always be empty.
Check that.

For #40724.

Change-Id: Id8e418a9e06b4f94543cb16b868a7e10e013c2d9
Reviewed-on: https://go-review.googlesource.com/c/go/+/306009
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/panic.go           | 11 +++++++++++
 src/runtime/proc.go            |  6 ++++++
 src/runtime/regabidefer_off.go | 10 ++++++++++
 src/runtime/regabidefer_on.go  | 10 ++++++++++
 4 files changed, 37 insertions(+)
 create mode 100644 src/runtime/regabidefer_off.go
 create mode 100644 src/runtime/regabidefer_on.go

diff --git a/src/runtime/panic.go b/src/runtime/panic.go
index b5133fa5b4..c265a5af79 100644
--- a/src/runtime/panic.go
+++ b/src/runtime/panic.go
@@ -228,6 +228,11 @@ func deferproc(siz int32, fn *funcval) { // arguments of fn follow fn
 		throw("defer on system stack")
 	}
 
+	if experimentRegabiDefer && siz != 0 {
+		// TODO: Make deferproc just take a func().
+		throw("defer with non-empty frame")
+	}
+
 	// the arguments of fn are in a perilous state. The stack map
 	// for deferproc does not describe them. So we can't let garbage
 	// collection or stack copying trigger until we've copied them out
@@ -280,6 +285,9 @@ func deferprocStack(d *_defer) {
 		// go code on the system stack can't defer
 		throw("defer on system stack")
 	}
+	if experimentRegabiDefer && d.siz != 0 {
+		throw("defer with non-empty frame")
+	}
 	// siz and fn are already set.
 	// The other fields are junk on entry to deferprocStack and
 	// are initialized here.
@@ -824,6 +832,9 @@ func runOpenDeferFrame(gp *g, d *_defer) bool {
 		argWidth, fd = readvarintUnsafe(fd)
 		closureOffset, fd = readvarintUnsafe(fd)
 		nArgs, fd = readvarintUnsafe(fd)
+		if experimentRegabiDefer && argWidth != 0 {
+			throw("defer with non-empty frame")
+		}
 		if deferBits&(1<<i) == 0 {
 			for j := uint32(0); j < nArgs; j++ {
 				_, fd = readvarintUnsafe(fd)
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index c2edb40948..d868c596bf 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -4019,6 +4019,12 @@ func malg(stacksize int32) *g {
 //
 //go:nosplit
 func newproc(siz int32, fn *funcval) {
+	if experimentRegabiDefer && siz != 0 {
+		// TODO: When we commit to experimentRegabiDefer,
+		// rewrite newproc's comment, since it will no longer
+		// have a funny stack layout or need to be nosplit.
+		throw("go with non-empty frame")
+	}
 	argp := add(unsafe.Pointer(&fn), sys.PtrSize)
 	gp := getg()
 	pc := getcallerpc()
diff --git a/src/runtime/regabidefer_off.go b/src/runtime/regabidefer_off.go
new file mode 100644
index 0000000000..72e3cf9c50
--- /dev/null
+++ b/src/runtime/regabidefer_off.go
@@ -0,0 +1,10 @@
+// Copyright 2021 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.
+
+//go:build !goexperiment.regabidefer
+// +build !goexperiment.regabidefer
+
+package runtime
+
+const experimentRegabiDefer = false
diff --git a/src/runtime/regabidefer_on.go b/src/runtime/regabidefer_on.go
new file mode 100644
index 0000000000..281694b061
--- /dev/null
+++ b/src/runtime/regabidefer_on.go
@@ -0,0 +1,10 @@
+// Copyright 2021 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.
+
+//go:build goexperiment.regabidefer
+// +build goexperiment.regabidefer
+
+package runtime
+
+const experimentRegabiDefer = true
-- 
GitLab


From 4b1a24f3cd9d49ecbe4c30b6a5ecade70f9dd04f Mon Sep 17 00:00:00 2001
From: Michael Pratt <mpratt@google.com>
Date: Thu, 11 Feb 2021 10:44:34 -0500
Subject: [PATCH 1295/2400] runtime: fix G passed to schedEnabled and cleanup

exitsyscall0 contains two G variables: _g_ and gp. _g_ is the active G,
g0, while gp is the G to run (which just exited from a syscall).

It is passing _g_ to schedEnabled, which is incorrect; we are about to
execute gp, so that is what we should be checking the schedulability of.

While this is incorrect and should be fixed, I don't think it has ever
caused a problem in practice:

 * g0 does not have g.startpc set, so schedEnabled simplifies to
   just !sched.disable.user.
 * This is correct provided gp is never a system goroutine.
 * As far as I know, system goroutines never use entersyscall /
   exitsyscall.

As far I can tell, this was a simple copy/paste error from exitsyscall,
where variable _g_ is the G to run.

While we are here, eliminate _g_ entirely, as the one other use is
identical to using gp.

Change-Id: I5df98a34569238b89ab13ff7012cd756fefb10dc
Reviewed-on: https://go-review.googlesource.com/c/go/+/291329
Trust: Michael Pratt <mpratt@google.com>
Run-TryBot: Michael Pratt <mpratt@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/proc.go | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index d868c596bf..2a7a766b25 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -3856,15 +3856,15 @@ func exitsyscallfast_pidle() bool {
 // exitsyscall slow path on g0.
 // Failed to acquire P, enqueue gp as runnable.
 //
+// Called via mcall, so gp is the calling g from this M.
+//
 //go:nowritebarrierrec
 func exitsyscall0(gp *g) {
-	_g_ := getg()
-
 	casgstatus(gp, _Gsyscall, _Grunnable)
 	dropg()
 	lock(&sched.lock)
 	var _p_ *p
-	if schedEnabled(_g_) {
+	if schedEnabled(gp) {
 		_p_ = pidleget()
 	}
 	if _p_ == nil {
@@ -3878,8 +3878,11 @@ func exitsyscall0(gp *g) {
 		acquirep(_p_)
 		execute(gp, false) // Never returns.
 	}
-	if _g_.m.lockedg != 0 {
+	if gp.lockedm != 0 {
 		// Wait until another thread schedules gp and so m again.
+		//
+		// N.B. lockedm must be this M, as this g was running on this M
+		// before entersyscall.
 		stoplockedm()
 		execute(gp, false) // Never returns.
 	}
-- 
GitLab


From 64ca7e2cb3af6135a46c9602b7650cad1381456a Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 30 Mar 2021 16:28:48 -0400
Subject: [PATCH 1296/2400] cmd/compile: avoid generating duplicated
 in-register Arg

In expand_calls, when rewriting OpArg to OpArgIntReg/OpArgFloatReg,
avoid generating duplicates. Otherwise it will confuse the
register allocator: it would think the second occurance clobbers
the first's register, causing it to generate copies, which may
clobber other args.

Change-Id: I4f1dc0519afb77500eae1c0e6ac8745e51f7aa4e
Reviewed-on: https://go-review.googlesource.com/c/go/+/306029
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/ssa/expand_calls.go | 16 +++++++++++
 test/abi/store_reg_args.go                   | 29 ++++++++++++++++++++
 2 files changed, 45 insertions(+)
 create mode 100644 test/abi/store_reg_args.go

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index 60eed37f1c..3444097ae3 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -1378,6 +1378,11 @@ func expandCalls(f *Func) {
 // rewriteArgToMemOrRegs converts OpArg v in-place into the register version of v,
 // if that is appropriate.
 func (x *expandState) rewriteArgToMemOrRegs(v *Value) *Value {
+	if x.debug {
+		x.indent(3)
+		defer x.indent(-3)
+		x.Printf("rewriteArgToMemOrRegs(%s)\n", v.LongString())
+	}
 	pa := x.prAssignForArg(v)
 	switch len(pa.Registers) {
 	case 0:
@@ -1387,15 +1392,26 @@ func (x *expandState) rewriteArgToMemOrRegs(v *Value) *Value {
 				pa.Offset(), frameOff, v.LongString()))
 		}
 	case 1:
+		t := v.Type
+		key := selKey{v, 0, t.Width, t}
+		w := x.commonArgs[key]
+		if w != nil {
+			v.copyOf(w)
+			break
+		}
 		r := pa.Registers[0]
 		var i int64
 		v.Op, i = ArgOpAndRegisterFor(r, x.f.ABISelf)
 		v.Aux = &AuxNameOffset{v.Aux.(*ir.Name), 0}
 		v.AuxInt = i
+		x.commonArgs[key] = v
 
 	default:
 		panic(badVal("Saw unexpanded OpArg", v))
 	}
+	if x.debug {
+		x.Printf("-->%s\n", v.LongString())
+	}
 	return v
 }
 
diff --git a/test/abi/store_reg_args.go b/test/abi/store_reg_args.go
new file mode 100644
index 0000000000..df5e4e167c
--- /dev/null
+++ b/test/abi/store_reg_args.go
@@ -0,0 +1,29 @@
+// run
+
+// Copyright 2021 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.
+
+// When the function Store an Arg and also use it in another place,
+// be sure not to generate duplicated OpArgXXXReg values, which confuses
+// the register allocator.
+
+package main
+
+//go:noinline
+//go:registerparams
+func F(x, y float32) {
+	if x < 0 {
+		panic("FAIL")
+	}
+	g = [4]float32{x, y, x, y}
+}
+
+var g [4]float32
+
+func main() {
+	F(1, 2)
+	if g[0] != 1 || g[1] != 2 || g[2] != 1 || g[3] != 2 {
+		panic("FAIL")
+	}
+}
-- 
GitLab


From 0fdd371e6b310bcf1f93d226dca61591630afe12 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Mon, 22 Mar 2021 22:10:13 -0400
Subject: [PATCH 1297/2400] go/parser: add data-driven tests for object
 resolution

Add new tests for object resolution driven by source files with
declarations and uses marked via special comments. This made it easier
to add test coverage while refactoring object resolution for #45104.

Tests are added to a new resolver_test.go file. In a subsequent CL the
resolver.go file will be added, making this choice of file name more
sensible.

For #45104
For #45136
For #45160

Change-Id: I240fccc0de95aa8f2d03e39c77146d4c61f1ef9e
Reviewed-on: https://go-review.googlesource.com/c/go/+/304450
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/go/parser/resolver_test.go                | 170 ++++++++++++++++++
 .../parser/testdata/resolution/issue45136.src |  29 +++
 .../parser/testdata/resolution/issue45160.src |  25 +++
 .../parser/testdata/resolution/resolution.src |  50 ++++++
 4 files changed, 274 insertions(+)
 create mode 100644 src/go/parser/resolver_test.go
 create mode 100644 src/go/parser/testdata/resolution/issue45136.src
 create mode 100644 src/go/parser/testdata/resolution/issue45160.src
 create mode 100644 src/go/parser/testdata/resolution/resolution.src

diff --git a/src/go/parser/resolver_test.go b/src/go/parser/resolver_test.go
new file mode 100644
index 0000000000..018214e437
--- /dev/null
+++ b/src/go/parser/resolver_test.go
@@ -0,0 +1,170 @@
+// Copyright 2021 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 parser
+
+import (
+	"fmt"
+	"go/ast"
+	"go/scanner"
+	"go/token"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// TestResolution checks that identifiers are resolved to the declarations
+// annotated in the source, by comparing the positions of the resulting
+// Ident.Obj.Decl to positions marked in the source via special comments.
+//
+// In the test source, any comment prefixed with '=' or '@' (or both) marks the
+// previous token position as the declaration ('=') or a use ('@') of an
+// identifier. The text following '=' and '@' in the comment string is the
+// label to use for the location.  Declaration labels must be unique within the
+// file, and use labels must refer to an existing declaration label. It's OK
+// for a comment to denote both the declaration and use of a label (e.g.
+// '=@foo'). Leading and trailing whitespace is ignored. Any comment not
+// beginning with '=' or '@' is ignored.
+func TestResolution(t *testing.T) {
+	dir := filepath.Join("testdata", "resolution")
+	fis, err := os.ReadDir(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for _, fi := range fis {
+		t.Run(fi.Name(), func(t *testing.T) {
+			fset := token.NewFileSet()
+			path := filepath.Join(dir, fi.Name())
+			src := readFile(path) // panics on failure
+			file, err := ParseFile(fset, path, src, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			// Compare the positions of objects resolved during parsing (fromParser)
+			// to those annotated in source comments (fromComments).
+
+			handle := fset.File(file.Package)
+			fromParser := declsFromParser(file)
+			fromComments := declsFromComments(handle, src)
+
+			pos := func(pos token.Pos) token.Position {
+				p := handle.Position(pos)
+				// The file name is implied by the subtest, so remove it to avoid
+				// clutter in error messages.
+				p.Filename = ""
+				return p
+			}
+			for k, want := range fromComments {
+				if got := fromParser[k]; got != want {
+					t.Errorf("%s resolved to %s, want %s", pos(k), pos(got), pos(want))
+				}
+				delete(fromParser, k)
+			}
+			// What remains in fromParser are unexpected resolutions.
+			for k, got := range fromParser {
+				t.Errorf("%s resolved to %s, want no object", pos(k), pos(got))
+			}
+		})
+	}
+}
+
+// declsFromParser walks the file and collects the map associating an
+// identifier position with its declaration position.
+func declsFromParser(file *ast.File) map[token.Pos]token.Pos {
+	objmap := map[token.Pos]token.Pos{}
+	ast.Inspect(file, func(node ast.Node) bool {
+		if ident, _ := node.(*ast.Ident); ident != nil && ident.Obj != nil {
+			objmap[ident.Pos()] = ident.Obj.Pos()
+		}
+		return true
+	})
+	return objmap
+}
+
+// declsFromComments looks at comments annotating uses and declarations, and
+// maps each identifier use to its corresponding declaration. See the
+// description of these annotations in the documentation for TestResolution.
+func declsFromComments(handle *token.File, src []byte) map[token.Pos]token.Pos {
+	decls, uses := positionMarkers(handle, src)
+
+	objmap := make(map[token.Pos]token.Pos)
+	// Join decls and uses on name, to build the map of use->decl.
+	for name, posns := range uses {
+		declpos, ok := decls[name]
+		if !ok {
+			panic(fmt.Sprintf("missing declaration for %s", name))
+		}
+		for _, pos := range posns {
+			objmap[pos] = declpos
+		}
+	}
+	return objmap
+}
+
+// positionMarkers extracts named positions from the source denoted by comments
+// prefixed with '=' (declarations) and '@' (uses): for example '@foo' or
+// '=@bar'. It returns a map of name->position for declarations, and
+// name->position(s) for uses.
+func positionMarkers(handle *token.File, src []byte) (decls map[string]token.Pos, uses map[string][]token.Pos) {
+	var s scanner.Scanner
+	s.Init(handle, src, nil, scanner.ScanComments)
+	decls = make(map[string]token.Pos)
+	uses = make(map[string][]token.Pos)
+	var prev token.Pos // position of last non-comment, non-semicolon token
+
+scanFile:
+	for {
+		pos, tok, lit := s.Scan()
+		switch tok {
+		case token.EOF:
+			break scanFile
+		case token.COMMENT:
+			name, decl, use := annotatedObj(lit)
+			if len(name) > 0 {
+				if decl {
+					if _, ok := decls[name]; ok {
+						panic(fmt.Sprintf("duplicate declaration markers for %s", name))
+					}
+					decls[name] = prev
+				}
+				if use {
+					uses[name] = append(uses[name], prev)
+				}
+			}
+		case token.SEMICOLON:
+			// ignore automatically inserted semicolon
+			if lit == "\n" {
+				continue scanFile
+			}
+			fallthrough
+		default:
+			prev = pos
+		}
+	}
+	return decls, uses
+}
+
+func annotatedObj(lit string) (name string, decl, use bool) {
+	if lit[1] == '*' {
+		lit = lit[:len(lit)-2] // strip trailing */
+	}
+	lit = strings.TrimSpace(lit[2:])
+
+scanLit:
+	for idx, r := range lit {
+		switch r {
+		case '=':
+			decl = true
+		case '@':
+			use = true
+		default:
+			name = lit[idx:]
+			break scanLit
+		}
+	}
+	return
+}
diff --git a/src/go/parser/testdata/resolution/issue45136.src b/src/go/parser/testdata/resolution/issue45136.src
new file mode 100644
index 0000000000..5e507fabe5
--- /dev/null
+++ b/src/go/parser/testdata/resolution/issue45136.src
@@ -0,0 +1,29 @@
+// Copyright 2021 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 issue45136
+
+type obj /* =@obj */ struct {
+	name /*=@name */ string
+}
+
+func _ /* =@blank */ () {
+	var foo /* =@foo */ = "foo"
+	obj /* @obj */ ["foo"]
+	obj /* @obj */ .run()
+
+	// TODO(#45136): the next two statements are missing objects.
+	obj{
+		name: foo /* @foo */,
+	}
+	obj{
+		name: "bar",
+	}.run()
+
+	var _ /* @=blank4 */ = File{key: obj /* @obj */{}}
+	var _ /* @=blank3 */ = File{obj{}}
+
+	[]obj /* @obj */ {foo /* @foo */}
+	x /* =@x1 */ := obj /* @obj */{}
+}
diff --git a/src/go/parser/testdata/resolution/issue45160.src b/src/go/parser/testdata/resolution/issue45160.src
new file mode 100644
index 0000000000..77cf0fa9c0
--- /dev/null
+++ b/src/go/parser/testdata/resolution/issue45160.src
@@ -0,0 +1,25 @@
+// Copyright 2021 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 issue45160
+
+func mklink1 /* =@mklink1func */() {}
+
+func _ /* =@blank */ () {
+	var tests /* =@tests */ = []dirLinkTest /* @dirLinkTest */ {
+		{
+			mklink1 /* @mklink1func */: func() {},
+			mklink2: func(link /* =@link */, target /* =@target */ string) error {
+				return nil
+			},
+		},
+	}
+}
+
+type dirLinkTest /* =@dirLinkTest */ struct {
+	mklink1 /* =@mklink1field */ func(string, string) error
+	mklink2 /* =@mklink2field */ func(string, string) error
+}
+
+func mklink2 /* =@mklink2func */() {}
diff --git a/src/go/parser/testdata/resolution/resolution.src b/src/go/parser/testdata/resolution/resolution.src
new file mode 100644
index 0000000000..e1ecdb5393
--- /dev/null
+++ b/src/go/parser/testdata/resolution/resolution.src
@@ -0,0 +1,50 @@
+// Copyright 2021 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 resolution
+
+func f /* =@fdecl */(n /* =@narg */ ast.Node) bool {
+		if n /* =@ninit */, ok /* =@ok */ := n /* @narg */ .(*ast.SelectorExpr); ok /* @ok */ {
+			sel = n /* @ninit */
+	}
+}
+
+type c /* =@cdecl */ map[token.Pos]resolvedObj
+
+func (v /* =@vdecl */ c /* @cdecl */) Visit(node /* =@nodearg */ ast.Node) (w /* =@w */ ast.Visitor) {}
+
+const (
+	basic /* =@basic */ = iota
+	labelOk // =@labelOk
+)
+
+func _ /* =@blankFunc */ () {
+	x /* =@x1 */ := c /* @cdecl */{}
+	switch x /* =@x2 */ := x /* @x1 */; x /* =@x3 */ := x /* @x2 */.(type) {
+	case c /* @cdecl */:
+	default:
+	}
+loop /* =@loop */:
+	for {
+		if true {
+			break loop /* @loop */
+		}
+	}
+	select {
+	case err /* =@err1 */ := <-_:
+		return err /* @err1 */
+	case err /* =@err2 */ := <-_:
+		return err /* @err2 */
+	}
+}
+
+var cycle /* =@cycle */ = cycle /* @cycle */ + 1
+
+type chain /* =@chain */ struct {
+	next /* =@next */ *chain /* @chain */
+}
+
+func recursive /* =@recursive */() {
+	recursive /* @recursive */ ()
+}
-- 
GitLab


From c3ec79bca953627a51e5eb32adb5039d1e488997 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Mon, 22 Mar 2021 22:27:25 -0400
Subject: [PATCH 1298/2400] go/parser: resolve the type name when parsing a
 composite lit value

parsePrimaryExpr has to be careful to resolve identifiers used in
composite expressions when parsing in LHS mode. It missed the literal
type name.

Fixes #45136

Change-Id: I3e12f91e3ef5fdb43faa436cdf1240eb3293fe1a
Reviewed-on: https://go-review.googlesource.com/c/go/+/304451
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/parser/parser.go                          |  5 +++++
 src/go/parser/testdata/resolution/issue45136.src | 10 ++++------
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/src/go/parser/parser.go b/src/go/parser/parser.go
index b86d6bad46..be87d3f9ee 100644
--- a/src/go/parser/parser.go
+++ b/src/go/parser/parser.go
@@ -1804,6 +1804,11 @@ func (p *parser) parsePrimaryExpr(lhs bool) (x ast.Expr) {
 				p.error(t.Pos(), "cannot parenthesize type in composite literal")
 				// already progressed, no need to advance
 			}
+			if lhs {
+				// An error has already been reported above, but try to resolve the 'T'
+				// in (T){...} anyway.
+				p.resolve(t)
+			}
 			x = p.parseLiteralValue(x)
 		default:
 			return
diff --git a/src/go/parser/testdata/resolution/issue45136.src b/src/go/parser/testdata/resolution/issue45136.src
index 5e507fabe5..671001f5a3 100644
--- a/src/go/parser/testdata/resolution/issue45136.src
+++ b/src/go/parser/testdata/resolution/issue45136.src
@@ -12,17 +12,15 @@ func _ /* =@blank */ () {
 	var foo /* =@foo */ = "foo"
 	obj /* @obj */ ["foo"]
 	obj /* @obj */ .run()
-
-	// TODO(#45136): the next two statements are missing objects.
-	obj{
+	obj /* @obj */ {
 		name: foo /* @foo */,
 	}
-	obj{
+	obj /* @obj */ {
 		name: "bar",
 	}.run()
 
-	var _ /* @=blank4 */ = File{key: obj /* @obj */{}}
-	var _ /* @=blank3 */ = File{obj{}}
+	var _ /* @=blank4 */ = File{key: obj /* @obj */ {}}
+	var _ /* @=blank3 */ = File{obj /* @obj */ {}}
 
 	[]obj /* @obj */ {foo /* @foo */}
 	x /* =@x1 */ := obj /* @obj */{}
-- 
GitLab


From 606e0aba74eda01e15a8c9697ccd82b802bb3501 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 24 Mar 2021 08:51:44 -0400
Subject: [PATCH 1299/2400] go/ast: add missing handling for ListExpr in Walk

Change-Id: I96170f1ca481b5fe21c85f99e877fa090e4dccc2
Reviewed-on: https://go-review.googlesource.com/c/go/+/304452
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/ast/walk.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/go/ast/walk.go b/src/go/ast/walk.go
index f909c00b4b..a57ff25ac5 100644
--- a/src/go/ast/walk.go
+++ b/src/go/ast/walk.go
@@ -116,6 +116,9 @@ func Walk(v Visitor, node Node) {
 		Walk(v, n.X)
 		Walk(v, n.Index)
 
+	case *ListExpr:
+		walkExprList(v, n.ElemList)
+
 	case *SliceExpr:
 		Walk(v, n.X)
 		if n.Low != nil {
-- 
GitLab


From f2717b31b5cf235457631fea1afd6d9df578737c Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Tue, 30 Mar 2021 13:42:14 -0700
Subject: [PATCH 1300/2400] cmd/compile: deal correctly with unnamed function
 params during stenciling

During substitution of the function type during stenciling, we must set
the Name nodes of the param/result fields of the func type. We get those
name nodes from the substituted Dcl nodes of the PPARAMS and PPARAMOUTs.
But we must check that the names match with the Dcl nodes, so that we
skip any param fields that correspond to unnamed (in) parameters.

Added a few tests to typelist.go by removing a variety of unneeded
function parameter names.

Change-Id: If786961b64549da6f18eeeb5060ea58fab874eb9
Reviewed-on: https://go-review.googlesource.com/c/go/+/305912
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/stencil.go | 15 ++++++++++-----
 test/typeparam/typelist.go                | 10 +++++-----
 2 files changed, 15 insertions(+), 10 deletions(-)

diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 78e701eaf8..1dff4e294c 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -862,11 +862,9 @@ func (subst *subster) typ(t *types.Type) *types.Type {
 // on the corresponding in/out parameters in dcl. It depends on the in and out
 // parameters being in order in dcl.
 func (subst *subster) fields(class ir.Class, oldfields []*types.Field, dcl []*ir.Name) []*types.Field {
-	newfields := make([]*types.Field, len(oldfields))
-	var i int
-
 	// Find the starting index in dcl of declarations of the class (either
 	// PPARAM or PPARAMOUT).
+	var i int
 	for i = range dcl {
 		if dcl[i].Class == class {
 			break
@@ -876,11 +874,18 @@ func (subst *subster) fields(class ir.Class, oldfields []*types.Field, dcl []*ir
 	// Create newfields nodes that are copies of the oldfields nodes, but
 	// with substitution for any type params, and with Nname set to be the node in
 	// Dcl for the corresponding PPARAM or PPARAMOUT.
+	newfields := make([]*types.Field, len(oldfields))
 	for j := range oldfields {
 		newfields[j] = oldfields[j].Copy()
 		newfields[j].Type = subst.typ(oldfields[j].Type)
-		newfields[j].Nname = dcl[i]
-		i++
+		// A param field will be missing from dcl if its name is
+		// unspecified or specified as "_". So, we compare the dcl sym
+		// with the field sym. If they don't match, this dcl (if there is
+		// one left) must apply to a later field.
+		if i < len(dcl) && dcl[i].Sym() == oldfields[j].Sym {
+			newfields[j].Nname = dcl[i]
+			i++
+		}
 	}
 	return newfields
 }
diff --git a/test/typeparam/typelist.go b/test/typeparam/typelist.go
index dd674cc889..bd90d86fcf 100644
--- a/test/typeparam/typelist.go
+++ b/test/typeparam/typelist.go
@@ -67,14 +67,14 @@ func _[V any, T interface { type map[string]V }](p T) V {
 // Testing partial and full type inference, including the case where the types can
 // be inferred without needing the types of the function arguments.
 
-func f0[A any, B interface{type C}, C interface{type D}, D interface{type A}](a A, b B, c C, d D)
+func f0[A any, B interface{type C}, C interface{type D}, D interface{type A}](A, B, C, D)
 func _() {
         f := f0[string]
         f("a", "b", "c", "d")
         f0("a", "b", "c", "d")
 }
 
-func f1[A any, B interface{type A}](a A, b B)
+func f1[A any, B interface{type A}](A, B)
 func _() {
         f := f1[int]
         f(int(0), int(0))
@@ -83,7 +83,7 @@ func _() {
         f1(0, 0)
 }
 
-func f2[A any, B interface{type []A}](a A, b B)
+func f2[A any, B interface{type []A}](_ A, _ B)
 func _() {
 	f := f2[byte]
 	f(byte(0), []byte{})
@@ -92,7 +92,7 @@ func _() {
 	// f2(0, []byte{}) - this one doesn't work
 }
 
-func f3[A any, B interface{type C}, C interface{type *A}](a A, b B, c C)
+func f3[A any, B interface{type C}, C interface{type *A}](a A, _ B, c C)
 func _() {
 	f := f3[int]
 	var x int
@@ -100,7 +100,7 @@ func _() {
 	f3(x, &x, &x)
 }
 
-func f4[A any, B interface{type []C}, C interface{type *A}](a A, b B, c C)
+func f4[A any, B interface{type []C}, C interface{type *A}](_ A, _ B, c C)
 func _() {
 	f := f4[int]
 	var x int
-- 
GitLab


From 6d2a557a4d09b6f60e2522fb740b5d7d1d8dc8e2 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Tue, 30 Mar 2021 16:03:26 -0700
Subject: [PATCH 1301/2400] cmd/compile: deal with call.Use correctly for
 noder2, allow inlining of stenciled functions

The setting of n.Use for a call node in transformCall() (and previously
in Call()), was not corrrect, since it was trying to use the number of
results of the call, rather than whether the call result was actually
used. We are already setting n.Use to ir.CallUseStmt if the call node is
directly a statement, so we just need to initialize n.Use to
ir.CallExprStmt in Call(), which will get changed to ir.CallUseStmt at
the statement level if it's used as a statement.

Enable inlining of stenciled functions (just disabled for testing,
easier debugging). The above n.Use fix was required for the inlining
to work for two cases.

Change-Id: Ie4ef6cd53fd4b20a4f3be31e629280909a545b7d
Reviewed-on: https://go-review.googlesource.com/c/go/+/305913
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/helpers.go   | 3 +++
 src/cmd/compile/internal/noder/stencil.go   | 2 --
 src/cmd/compile/internal/noder/transform.go | 5 -----
 3 files changed, 3 insertions(+), 7 deletions(-)

diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
index e5a6dbcb01..6320b30e50 100644
--- a/src/cmd/compile/internal/noder/helpers.go
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -87,6 +87,9 @@ func Binary(pos src.XPos, op ir.Op, typ *types.Type, x, y ir.Node) ir.Node {
 func Call(pos src.XPos, typ *types.Type, fun ir.Node, args []ir.Node, dots bool) ir.Node {
 	n := ir.NewCallExpr(pos, ir.OCALL, fun, args)
 	n.IsDDD = dots
+	// n.Use will be changed to ir.CallUseStmt in g.stmt() if this call is
+	// just a statement (any return values are ignored).
+	n.Use = ir.CallUseExpr
 
 	if fun.Op() == ir.OTYPE {
 		// Actually a type conversion, not a function call.
diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 1dff4e294c..350f8f8c2a 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -303,8 +303,6 @@ func (g *irgen) genericSubst(newsym *types.Sym, nameNode *ir.Name, targs []ir.No
 	ir.MarkFunc(newf.Nname)
 	newf.SetTypecheck(1)
 	newf.Nname.SetTypecheck(1)
-	// TODO(danscales) - remove later, but avoid confusion for now.
-	newf.Pragma = ir.Noinline
 
 	// Make sure name/type of newf is set before substituting the body.
 	newf.Body = subst.list(gf.Body)
diff --git a/src/cmd/compile/internal/noder/transform.go b/src/cmd/compile/internal/noder/transform.go
index 7f926dc70a..021d3a9fa7 100644
--- a/src/cmd/compile/internal/noder/transform.go
+++ b/src/cmd/compile/internal/noder/transform.go
@@ -143,11 +143,6 @@ func transformCall(n *ir.CallExpr) {
 	}
 
 	typecheckaste(ir.OCALL, n.X, n.IsDDD, t.Params(), n.Args)
-	if t.NumResults() == 0 {
-		n.Use = ir.CallUseStmt
-		return
-	}
-	n.Use = ir.CallUseExpr
 	if t.NumResults() == 1 {
 		n.SetType(l.Type().Results().Field(0).Type)
 
-- 
GitLab


From 152ca79b73f5f8fc1e66277c9422f442f19a7f0c Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 24 Mar 2021 17:36:40 -0400
Subject: [PATCH 1302/2400] go/parser: add resolution tests for type params

For #45104
For #45221

Change-Id: I8966555f4e8844d5b6766d00d48f7a81868ccf40
Reviewed-on: https://go-review.googlesource.com/c/go/+/304453
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/parser/resolver_test.go                |  6 ++++-
 .../parser/testdata/resolution/resolution.src |  4 +++-
 .../parser/testdata/resolution/typeparams.go2 | 24 +++++++++++++++++++
 3 files changed, 32 insertions(+), 2 deletions(-)
 create mode 100644 src/go/parser/testdata/resolution/typeparams.go2

diff --git a/src/go/parser/resolver_test.go b/src/go/parser/resolver_test.go
index 018214e437..9ae2844d73 100644
--- a/src/go/parser/resolver_test.go
+++ b/src/go/parser/resolver_test.go
@@ -39,7 +39,11 @@ func TestResolution(t *testing.T) {
 			fset := token.NewFileSet()
 			path := filepath.Join(dir, fi.Name())
 			src := readFile(path) // panics on failure
-			file, err := ParseFile(fset, path, src, 0)
+			var mode Mode
+			if strings.HasSuffix(path, ".go2") {
+				mode = parseTypeParams
+			}
+			file, err := ParseFile(fset, path, src, mode)
 			if err != nil {
 				t.Fatal(err)
 			}
diff --git a/src/go/parser/testdata/resolution/resolution.src b/src/go/parser/testdata/resolution/resolution.src
index e1ecdb5393..d76a83d9ed 100644
--- a/src/go/parser/testdata/resolution/resolution.src
+++ b/src/go/parser/testdata/resolution/resolution.src
@@ -19,7 +19,9 @@ const (
 	labelOk // =@labelOk
 )
 
-func _ /* =@blankFunc */ () {
+type T /* =@T */ int
+
+func _ /* =@blankFunc */ (count /* =@count */ T /* @T */) {
 	x /* =@x1 */ := c /* @cdecl */{}
 	switch x /* =@x2 */ := x /* @x1 */; x /* =@x3 */ := x /* @x2 */.(type) {
 	case c /* @cdecl */:
diff --git a/src/go/parser/testdata/resolution/typeparams.go2 b/src/go/parser/testdata/resolution/typeparams.go2
new file mode 100644
index 0000000000..922f7790f5
--- /dev/null
+++ b/src/go/parser/testdata/resolution/typeparams.go2
@@ -0,0 +1,24 @@
+// Copyright 2021 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 resolution
+
+type List /* =@List */ [E /* =@E */ any] []E // @E
+
+type Pair /* =@Pair */ [L /* =@L */, R /* =@R */ any] struct {
+	Left /* =@Left */ L // @L
+	Right /* =@Right */ R // @R
+}
+
+var _ /* =@blank */ = Pair /* @Pair */ [int, string]{}
+
+type Addable /* =@Addable */ interface {
+	type int64, float64
+}
+
+// TODO (#45221): resolve references to T in the signature below.
+func Add /* =@AddDecl */[T /* =@T */ Addable /* @Addable */](l /* =@l */, r /* =@r */ T) T {
+	var t /* =@t */ T /* @T */
+	return l /* @l */ + r /* @r */ + t /* @t */
+}
-- 
GitLab


From 1d8abb3417af401ff6938c557ce30a8234bd2ce5 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Mon, 22 Mar 2021 22:31:28 -0400
Subject: [PATCH 1303/2400] go/parser: remove redundant list argument to
 Parser.shortVarDecl

Change-Id: I75d089a7c1c3cdd50e5d2dafdb3386620efff4c9
Reviewed-on: https://go-review.googlesource.com/c/go/+/304454
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/parser/parser.go | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/go/parser/parser.go b/src/go/parser/parser.go
index be87d3f9ee..0a69515be1 100644
--- a/src/go/parser/parser.go
+++ b/src/go/parser/parser.go
@@ -137,12 +137,12 @@ func (p *parser) declare(decl, data interface{}, scope *ast.Scope, kind ast.ObjK
 	}
 }
 
-func (p *parser) shortVarDecl(decl *ast.AssignStmt, list []ast.Expr) {
+func (p *parser) shortVarDecl(decl *ast.AssignStmt) {
 	// Go spec: A short variable declaration may redeclare variables
 	// provided they were originally declared in the same block with
 	// the same type, and at least one of the non-blank variables is new.
 	n := 0 // number of new variables
-	for _, x := range list {
+	for _, x := range decl.Lhs {
 		if ident, isIdent := x.(*ast.Ident); isIdent {
 			assert(ident.Obj == nil, "identifier already declared or resolved")
 			obj := ast.NewObj(ast.Var, ident.Name)
@@ -161,7 +161,7 @@ func (p *parser) shortVarDecl(decl *ast.AssignStmt, list []ast.Expr) {
 		}
 	}
 	if n == 0 && p.mode&DeclarationErrors != 0 {
-		p.error(list[0].Pos(), "no new variables on left side of :=")
+		p.error(decl.Lhs[0].Pos(), "no new variables on left side of :=")
 	}
 }
 
@@ -1987,7 +1987,7 @@ func (p *parser) parseSimpleStmt(mode int) (ast.Stmt, bool) {
 		}
 		as := &ast.AssignStmt{Lhs: x, TokPos: pos, Tok: tok, Rhs: y}
 		if tok == token.DEFINE {
-			p.shortVarDecl(as, x)
+			p.shortVarDecl(as)
 		}
 		return as, isRange
 	}
@@ -2382,7 +2382,7 @@ func (p *parser) parseCommClause() *ast.CommClause {
 				rhs := p.parseRhs()
 				as := &ast.AssignStmt{Lhs: lhs, TokPos: pos, Tok: tok, Rhs: []ast.Expr{rhs}}
 				if tok == token.DEFINE {
-					p.shortVarDecl(as, lhs)
+					p.shortVarDecl(as)
 				}
 				comm = as
 			} else {
-- 
GitLab


From c93cd8614965c6c114671fabf82b69fbd952f52f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BE=90=E5=BF=97=E4=BC=9F?= <juwan.xu@qq.com>
Date: Tue, 30 Mar 2021 23:25:56 +0000
Subject: [PATCH 1304/2400] net/http: use consistent case in URL in names

Change-Id: Iff5074713e1a4484c04b8628fb2611b6d4e154c7
GitHub-Last-Rev: bb0861bbbe31bc2bbda667c05402b5ef886a762b
GitHub-Pull-Request: golang/go#45294
Reviewed-on: https://go-review.googlesource.com/c/go/+/305772
Reviewed-by: Ben Shi <powerman1st@163.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ben Shi <powerman1st@163.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/net/http/client_test.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/net/http/client_test.go b/src/net/http/client_test.go
index d90b4841c6..3b3d98ff9a 100644
--- a/src/net/http/client_test.go
+++ b/src/net/http/client_test.go
@@ -257,12 +257,12 @@ func TestClientRedirects(t *testing.T) {
 		t.Fatalf("Get error: %v", err)
 	}
 	res.Body.Close()
-	finalUrl := res.Request.URL.String()
+	finalURL := res.Request.URL.String()
 	if e, g := "<nil>", fmt.Sprintf("%v", err); e != g {
 		t.Errorf("with custom client, expected error %q, got %q", e, g)
 	}
-	if !strings.HasSuffix(finalUrl, "/?n=15") {
-		t.Errorf("expected final url to end in /?n=15; got url %q", finalUrl)
+	if !strings.HasSuffix(finalURL, "/?n=15") {
+		t.Errorf("expected final url to end in /?n=15; got url %q", finalURL)
 	}
 	if e, g := 15, len(lastVia); e != g {
 		t.Errorf("expected lastVia to have contained %d elements; got %d", e, g)
-- 
GitLab


From 0e8a72b62efa44fa01eccb94d47a051366cb6d17 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Tue, 30 Mar 2021 12:21:20 -0700
Subject: [PATCH 1305/2400] runtime: check for sysAlloc failures in pageAlloc

Change-Id: I78c5744bb01988f1f599569703d83fd21542ac7a
Reviewed-on: https://go-review.googlesource.com/c/go/+/305911
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/mpagealloc.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/runtime/mpagealloc.go b/src/runtime/mpagealloc.go
index dac1f39969..071f1fc274 100644
--- a/src/runtime/mpagealloc.go
+++ b/src/runtime/mpagealloc.go
@@ -395,6 +395,9 @@ func (p *pageAlloc) grow(base, size uintptr) {
 			// Store it atomically to avoid races with readers which
 			// don't acquire the heap lock.
 			r := sysAlloc(unsafe.Sizeof(*p.chunks[0]), p.sysStat)
+			if r == nil {
+				throw("pageAlloc: out of memory")
+			}
 			atomic.StorepNoWB(unsafe.Pointer(&p.chunks[c.l1()]), r)
 		}
 		p.chunkOf(c).scavenged.setRange(0, pallocChunkPages)
-- 
GitLab


From 34fb2b2ed5687ec85aa8c1db1481bb4f31b35b29 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 29 Mar 2021 11:36:44 -0700
Subject: [PATCH 1306/2400] cmd/compile/internal/types2: review of decl.go

The changes between (equivalent, and reviewed) go/types/decl.go
and decl.go can be seen by comparing patchset 1 and 2. The actual
changes are removing the "// UNREVIEWED" marker and a minor comment
update.

The primary differences to go/types/decl.go are:
- use of syntax rather than go/ast package
- use of error_ objects to collect follow-on error info
- use of check.conf.Trace rather than global trace flag
- more aggressively marking variables as used in the presence errors
- not using a walkDecl abstraction for const/var/type declarations

Change-Id: I5cf26779c9939b686a3dbaa4d38fdd0c154a92ca
Reviewed-on: https://go-review.googlesource.com/c/go/+/305570
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/decl.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index 07a22e8aad..9d8c39ddbe 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2014 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.
@@ -325,7 +324,7 @@ func (check *Checker) validType(typ Type, path []Object) typeInfo {
 		}
 
 		// don't report a 2nd error if we already know the type is invalid
-		// (e.g., if a cycle was detected earlier, via Checker.underlying).
+		// (e.g., if a cycle was detected earlier, via under).
 		if t.underlying == Typ[Invalid] {
 			t.info = invalid
 			return invalid
-- 
GitLab


From 135c9f45ecaec719bcc297ec9f9f19042bc9adf6 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 29 Mar 2021 12:14:58 -0700
Subject: [PATCH 1307/2400] cmd/compile/internal/types2: review of operand.go

The changes between (equivalent, and reviewed) go/types/operand.go
and operand.go can be seen by comparing patchset 1 and 2. The actual
changes are removing the "// UNREVIEWED" marker.

The primary differences compared to go/types are:
- use of syntax rather than go/ast package
- explicit mode for untyped nil (rather than relying on the type)

Change-Id: I0c9c1c6153c55cb0550096bd966c9f0f1c766734
Reviewed-on: https://go-review.googlesource.com/c/go/+/305571
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/operand.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/operand.go b/src/cmd/compile/internal/types2/operand.go
index 61ad0d00f8..455d8b5dd1 100644
--- a/src/cmd/compile/internal/types2/operand.go
+++ b/src/cmd/compile/internal/types2/operand.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2012 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.
-- 
GitLab


From c847932804467f511b0e123cf29b72dd0d509306 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Tue, 30 Mar 2021 17:55:22 -0400
Subject: [PATCH 1308/2400] runtime: replace reflectcall of defers with direct
 call

With GOEXPERIMENT=regabidefer, all deferred functions take no
arguments and have no results (their signature is always func()).
Since the signature is fixed, we can replace all of the reflectcalls
in the defer code with direct closure calls.

For #40724.

Change-Id: I3acd6742fe665610608a004c675f473b9d0e65ee
Reviewed-on: https://go-review.googlesource.com/c/go/+/306010
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/internal/objabi/funcid.go |  1 +
 src/runtime/panic.go              | 83 +++++++++++++++++++++++++------
 2 files changed, 70 insertions(+), 14 deletions(-)

diff --git a/src/cmd/internal/objabi/funcid.go b/src/cmd/internal/objabi/funcid.go
index 6e188e31bb..fa28609e4d 100644
--- a/src/cmd/internal/objabi/funcid.go
+++ b/src/cmd/internal/objabi/funcid.go
@@ -75,6 +75,7 @@ var funcIDs = map[string]FuncID{
 	"deferreturn":       FuncID_wrapper,
 	"runOpenDeferFrame": FuncID_wrapper,
 	"reflectcallSave":   FuncID_wrapper,
+	"deferCallSave":     FuncID_wrapper,
 }
 
 // Get the function ID for the named function in the named file.
diff --git a/src/runtime/panic.go b/src/runtime/panic.go
index c265a5af79..bbf3ea473a 100644
--- a/src/runtime/panic.go
+++ b/src/runtime/panic.go
@@ -382,6 +382,19 @@ func deferArgs(d *_defer) unsafe.Pointer {
 	return add(unsafe.Pointer(d), unsafe.Sizeof(*d))
 }
 
+// deferFunc returns d's deferred function. This is temporary while we
+// support both modes of GOEXPERIMENT=regabidefer. Once we commit to
+// that experiment, we should change the type of d.fn.
+//go:nosplit
+func deferFunc(d *_defer) func() {
+	if !experimentRegabiDefer {
+		throw("requires experimentRegabiDefer")
+	}
+	var fn func()
+	*(**funcval)(unsafe.Pointer(&fn)) = d.fn
+	return fn
+}
+
 var deferType *_type // type of _defer struct
 
 func init() {
@@ -635,10 +648,15 @@ func Goexit() {
 				addOneOpenDeferFrame(gp, 0, nil)
 			}
 		} else {
-
-			// Save the pc/sp in reflectcallSave(), so we can "recover" back to this
-			// loop if necessary.
-			reflectcallSave(&p, unsafe.Pointer(d.fn), deferArgs(d), uint32(d.siz))
+			if experimentRegabiDefer {
+				// Save the pc/sp in deferCallSave(), so we can "recover" back to this
+				// loop if necessary.
+				deferCallSave(&p, deferFunc(d))
+			} else {
+				// Save the pc/sp in reflectcallSave(), so we can "recover" back to this
+				// loop if necessary.
+				reflectcallSave(&p, unsafe.Pointer(d.fn), deferArgs(d), uint32(d.siz))
+			}
 		}
 		if p.aborted {
 			// We had a recursive panic in the defer d we started, and
@@ -860,7 +878,11 @@ func runOpenDeferFrame(gp *g, d *_defer) bool {
 		deferBits = deferBits &^ (1 << i)
 		*(*uint8)(unsafe.Pointer(d.varp - uintptr(deferBitsOffset))) = deferBits
 		p := d._panic
-		reflectcallSave(p, unsafe.Pointer(closure), deferArgs, argWidth)
+		if experimentRegabiDefer {
+			deferCallSave(p, deferFunc(d))
+		} else {
+			reflectcallSave(p, unsafe.Pointer(closure), deferArgs, argWidth)
+		}
 		if p != nil && p.aborted {
 			break
 		}
@@ -880,17 +902,20 @@ func runOpenDeferFrame(gp *g, d *_defer) bool {
 // panic record. This allows the runtime to return to the Goexit defer processing
 // loop, in the unusual case where the Goexit may be bypassed by a successful
 // recover.
+//
+// This is marked as a wrapper by the compiler so it doesn't appear in
+// tracebacks.
 func reflectcallSave(p *_panic, fn, arg unsafe.Pointer, argsize uint32) {
+	if experimentRegabiDefer {
+		throw("not allowed with experimentRegabiDefer")
+	}
 	if p != nil {
 		p.argp = unsafe.Pointer(getargp(0))
 		p.pc = getcallerpc()
 		p.sp = unsafe.Pointer(getcallersp())
 	}
-	// Pass a dummy RegArgs for now since no function actually implements
-	// the register-based ABI.
-	//
-	// TODO(mknyszek): Implement this properly, setting up arguments in
-	// registers as necessary in the caller.
+	// Pass a dummy RegArgs since we'll only take this path if
+	// we're not using the register ABI.
 	var regs abi.RegArgs
 	reflectcall(nil, fn, arg, argsize, argsize, argsize, &regs)
 	if p != nil {
@@ -899,6 +924,29 @@ func reflectcallSave(p *_panic, fn, arg unsafe.Pointer, argsize uint32) {
 	}
 }
 
+// deferCallSave calls fn() after saving the caller's pc and sp in the
+// panic record. This allows the runtime to return to the Goexit defer
+// processing loop, in the unusual case where the Goexit may be
+// bypassed by a successful recover.
+//
+// This is marked as a wrapper by the compiler so it doesn't appear in
+// tracebacks.
+func deferCallSave(p *_panic, fn func()) {
+	if !experimentRegabiDefer {
+		throw("only allowed with experimentRegabiDefer")
+	}
+	if p != nil {
+		p.argp = unsafe.Pointer(getargp(0))
+		p.pc = getcallerpc()
+		p.sp = unsafe.Pointer(getcallersp())
+	}
+	fn()
+	if p != nil {
+		p.pc = 0
+		p.sp = unsafe.Pointer(nil)
+	}
+}
+
 // The implementation of the predeclared function panic.
 func gopanic(e interface{}) {
 	gp := getg()
@@ -970,7 +1018,7 @@ func gopanic(e interface{}) {
 
 		// Mark defer as started, but keep on list, so that traceback
 		// can find and update the defer's argument frame if stack growth
-		// or a garbage collection happens before reflectcall starts executing d.fn.
+		// or a garbage collection happens before executing d.fn.
 		d.started = true
 
 		// Record the panic that is running the defer.
@@ -987,12 +1035,19 @@ func gopanic(e interface{}) {
 		} else {
 			p.argp = unsafe.Pointer(getargp(0))
 
-			var regs abi.RegArgs
-			reflectcall(nil, unsafe.Pointer(d.fn), deferArgs(d), uint32(d.siz), uint32(d.siz), uint32(d.siz), &regs)
+			if experimentRegabiDefer {
+				fn := deferFunc(d)
+				fn()
+			} else {
+				// Pass a dummy RegArgs since we'll only take this path if
+				// we're not using the register ABI.
+				var regs abi.RegArgs
+				reflectcall(nil, unsafe.Pointer(d.fn), deferArgs(d), uint32(d.siz), uint32(d.siz), uint32(d.siz), &regs)
+			}
 		}
 		p.argp = nil
 
-		// reflectcall did not panic. Remove d.
+		// Deferred function did not panic. Remove d.
 		if gp._defer != d {
 			throw("bad defer entry in panic")
 		}
-- 
GitLab


From ca3aefc4a96f2e26c7bed549a6c90b6f12c1ecea Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Mon, 29 Mar 2021 20:14:51 -0400
Subject: [PATCH 1309/2400] cmd/compile: make expandCalls preserve types of
 pointer stores

This is accomplished by checking for simple stores of pointer types
and leaving them alone.  The failure case was when a *mspan
(not in heap) stored type was replaced by unsafe.Pointer.

Updates #40724.

Change-Id: I529e1705bf58fb0e64e60d48fd550b3a407e57e7
Reviewed-on: https://go-review.googlesource.com/c/go/+/305672
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/expand_calls.go | 5 ++++-
 src/cmd/compile/internal/ssa/value.go        | 3 +++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index 3444097ae3..b6aba0ed16 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -1114,6 +1114,9 @@ func expandCalls(f *Func) {
 		for _, v := range b.Values {
 			if v.Op == OpStore {
 				t := v.Aux.(*types.Type)
+				if t.IsPtrShaped() { // Everything already fits, and this ensures pointer type properties aren't discarded (e.g, notinheap)
+					continue
+				}
 				source := v.Args[1]
 				tSrc := source.Type
 				iAEATt := x.isAlreadyExpandedAggregateType(t)
@@ -1422,7 +1425,7 @@ func (x *expandState) newArgToMemOrRegs(baseArg, toReplace *Value, offset int64,
 	if x.debug {
 		x.indent(3)
 		defer x.indent(-3)
-		x.Printf("newArgToMemOrRegs(base=%s; toReplace=%s; t=%s; memOff=%d; regOff=%d)\n", baseArg.String(), toReplace.LongString(), t, offset, regOffset)
+		x.Printf("newArgToMemOrRegs(base=%s; toReplace=%s; t=%s; memOff=%d; regOff=%d)\n", baseArg.String(), toReplace.LongString(), t.String(), offset, regOffset)
 	}
 	key := selKey{baseArg, offset, t.Width, t}
 	w := x.commonArgs[key]
diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go
index 5a9779dd1e..ba7f8c0300 100644
--- a/src/cmd/compile/internal/ssa/value.go
+++ b/src/cmd/compile/internal/ssa/value.go
@@ -139,6 +139,9 @@ func (v *Value) AuxArm64BitField() arm64BitField {
 
 // long form print.  v# = opcode <type> [aux] args [: reg] (names)
 func (v *Value) LongString() string {
+	if v == nil {
+		return "<NIL VALUE>"
+	}
 	s := fmt.Sprintf("v%d = %s", v.ID, v.Op)
 	s += " <" + v.Type.String() + ">"
 	s += v.auxString()
-- 
GitLab


From 46fa8afca61cf60c64f006685cd6cbb94e080118 Mon Sep 17 00:00:00 2001
From: Kevin Herro <kevin109104@gmail.com>
Date: Fri, 26 Mar 2021 08:58:11 -0700
Subject: [PATCH 1310/2400] cmd/go/internal/load/test: parse overlay files for
 test functions

The existing implementation implicitly reads from the filesystem
instead of using the overlay file data (due to src == nil), so
pass in the overlaid source if we have an overlay for this file.

Fixes #44946

Change-Id: I61ce09d10c5edac1b47332583efdcd3c1241f58a
Reviewed-on: https://go-review.googlesource.com/c/go/+/305071
Reviewed-by: Jay Conrod <jayconrod@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/internal/load/test.go            |  9 +++++++-
 src/cmd/go/testdata/script/test_overlay.txt | 24 +++++++++++++++++++++
 2 files changed, 32 insertions(+), 1 deletion(-)
 create mode 100644 src/cmd/go/testdata/script/test_overlay.txt

diff --git a/src/cmd/go/internal/load/test.go b/src/cmd/go/internal/load/test.go
index 7bc16abcb6..fc89bd0250 100644
--- a/src/cmd/go/internal/load/test.go
+++ b/src/cmd/go/internal/load/test.go
@@ -21,6 +21,7 @@ import (
 	"unicode"
 	"unicode/utf8"
 
+	"cmd/go/internal/fsys"
 	"cmd/go/internal/str"
 	"cmd/go/internal/trace"
 )
@@ -578,7 +579,13 @@ type testFunc struct {
 var testFileSet = token.NewFileSet()
 
 func (t *testFuncs) load(filename, pkg string, doImport, seen *bool) error {
-	f, err := parser.ParseFile(testFileSet, filename, nil, parser.ParseComments)
+	// Pass in the overlaid source if we have an overlay for this file.
+	src, err := fsys.Open(filename)
+	if err != nil {
+		return err
+	}
+	defer src.Close()
+	f, err := parser.ParseFile(testFileSet, filename, src, parser.ParseComments)
 	if err != nil {
 		return err
 	}
diff --git a/src/cmd/go/testdata/script/test_overlay.txt b/src/cmd/go/testdata/script/test_overlay.txt
new file mode 100644
index 0000000000..b6bdc116e6
--- /dev/null
+++ b/src/cmd/go/testdata/script/test_overlay.txt
@@ -0,0 +1,24 @@
+[short] skip
+
+cd $WORK/gopath/src/foo
+go test -list=. -overlay=overlay.json .
+stdout 'TestBar'
+
+-- go.mod --
+module test.pkg
+-- foo/foo_test.go --
+package foo
+
+import "testing"
+
+func TestFoo(t *testing.T) { }
+-- tmp/bar_test.go --
+package foo
+
+import "testing"
+
+func TestBar(t *testing.T) {
+	t.Fatal("dummy failure")
+}
+-- foo/overlay.json --
+{"Replace": {"foo_test.go": "../tmp/bar_test.go"}}
-- 
GitLab


From cb42e3e979830ccaac72d02512f522a820c6a5e7 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Wed, 31 Mar 2021 10:27:06 -0400
Subject: [PATCH 1311/2400] cmd/compile: schedule in-register OpArg first

OpArgXXXReg values must be scheduled at the very top, as their
registers need to be live at the beginning before any other use
of the register.

Change-Id: Ic76768bb74da402adbe61db3b2d174ecd3f9fffc
Reviewed-on: https://go-review.googlesource.com/c/go/+/306329
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/ssa/schedule.go | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ssa/schedule.go b/src/cmd/compile/internal/ssa/schedule.go
index c987647131..4e3e5e75e3 100644
--- a/src/cmd/compile/internal/ssa/schedule.go
+++ b/src/cmd/compile/internal/ssa/schedule.go
@@ -137,7 +137,14 @@ func schedule(f *Func) {
 			case v.Op == OpVarDef:
 				// We want all the vardefs next.
 				score[v.ID] = ScoreVarDef
-			case v.Op == OpArg || v.Op == OpArgIntReg || v.Op == OpArgFloatReg:
+			case v.Op == OpArgIntReg || v.Op == OpArgFloatReg:
+				// In-register args must be scheduled as early as possible to ensure that the
+				// context register is not stomped. They should only appear in the entry block.
+				if b != f.Entry {
+					f.Fatalf("%s appeared outside of entry block, b=%s", v.Op, b.String())
+				}
+				score[v.ID] = ScorePhi
+			case v.Op == OpArg:
 				// We want all the args as early as possible, for better debugging.
 				score[v.ID] = ScoreArg
 			case v.Type.IsMemory():
-- 
GitLab


From 44dd06670f522e66e7ebfa0bffe14d2b44c93ff8 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Tue, 9 Mar 2021 21:13:34 +0000
Subject: [PATCH 1312/2400] runtime: support register ABI Go functions from
 Windows callbacks

This change modifies the system that allows Go functions to be set as
callbacks in various Windows systems to support the new register ABI.

For #40724.

Change-Id: Ie067f9e8a76c96d56177d7aa88f89cbe7223e12e
Reviewed-on: https://go-review.googlesource.com/c/go/+/300113
Reviewed-by: Austin Clements <austin@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/export_test.go          |   4 +-
 src/runtime/syscall_windows.go      | 277 ++++++++++++++++++++--------
 src/runtime/syscall_windows_test.go | 105 ++++++++++-
 3 files changed, 305 insertions(+), 81 deletions(-)

diff --git a/src/runtime/export_test.go b/src/runtime/export_test.go
index 961c1c1a26..81200da915 100644
--- a/src/runtime/export_test.go
+++ b/src/runtime/export_test.go
@@ -1233,7 +1233,9 @@ func (th *TimeHistogram) Record(duration int64) {
 func SetIntArgRegs(a int) int {
 	lock(&finlock)
 	old := intArgRegs
-	intArgRegs = a
+	if a >= 0 {
+		intArgRegs = a
+	}
 	unlock(&finlock)
 	return old
 }
diff --git a/src/runtime/syscall_windows.go b/src/runtime/syscall_windows.go
index 191892f047..6521bb2c41 100644
--- a/src/runtime/syscall_windows.go
+++ b/src/runtime/syscall_windows.go
@@ -22,32 +22,180 @@ var cbs struct {
 type winCallback struct {
 	fn     *funcval // Go function
 	retPop uintptr  // For 386 cdecl, how many bytes to pop on return
-
-	// abiMap specifies how to translate from a C frame to a Go
-	// frame. This does not specify how to translate back because
-	// the result is always a uintptr. If the C ABI is fastcall,
-	// this assumes the four fastcall registers were first spilled
-	// to the shadow space.
-	abiMap []abiPart
-	// retOffset is the offset of the uintptr-sized result in the Go
-	// frame.
-	retOffset uintptr
+	abiMap abiDesc
 }
 
+// abiPartKind is the action an abiPart should take.
+type abiPartKind int
+
+const (
+	abiPartBad   abiPartKind = iota
+	abiPartStack             // Move a value from memory to the stack.
+	abiPartReg               // Move a value from memory to a register.
+)
+
 // abiPart encodes a step in translating between calling ABIs.
 type abiPart struct {
-	src, dst uintptr
-	len      uintptr
+	kind           abiPartKind
+	srcStackOffset uintptr
+	dstStackOffset uintptr // used if kind == abiPartStack
+	dstRegister    int     // used if kind == abiPartReg
+	len            uintptr
 }
 
 func (a *abiPart) tryMerge(b abiPart) bool {
-	if a.src+a.len == b.src && a.dst+a.len == b.dst {
+	if a.kind != abiPartStack || b.kind != abiPartStack {
+		return false
+	}
+	if a.srcStackOffset+a.len == b.srcStackOffset && a.dstStackOffset+a.len == b.dstStackOffset {
 		a.len += b.len
 		return true
 	}
 	return false
 }
 
+// abiDesc specifies how to translate from a C frame to a Go
+// frame. This does not specify how to translate back because
+// the result is always a uintptr. If the C ABI is fastcall,
+// this assumes the four fastcall registers were first spilled
+// to the shadow space.
+type abiDesc struct {
+	parts []abiPart
+
+	srcStackSize uintptr // stdcall/fastcall stack space tracking
+	dstStackSize uintptr // Go stack space used
+	dstRegisters int     // Go ABI int argument registers used
+
+	// retOffset is the offset of the uintptr-sized result in the Go
+	// frame.
+	retOffset uintptr
+}
+
+func (p *abiDesc) assignArg(t *_type) {
+	if t.size > sys.PtrSize {
+		// We don't support this right now. In
+		// stdcall/cdecl, 64-bit ints and doubles are
+		// passed as two words (little endian); and
+		// structs are pushed on the stack. In
+		// fastcall, arguments larger than the word
+		// size are passed by reference. On arm,
+		// 8-byte aligned arguments round up to the
+		// next even register and can be split across
+		// registers and the stack.
+		panic("compileCallback: argument size is larger than uintptr")
+	}
+	if k := t.kind & kindMask; GOARCH != "386" && (k == kindFloat32 || k == kindFloat64) {
+		// In fastcall, floating-point arguments in
+		// the first four positions are passed in
+		// floating-point registers, which we don't
+		// currently spill. arm passes floating-point
+		// arguments in VFP registers, which we also
+		// don't support.
+		// So basically we only support 386.
+		panic("compileCallback: float arguments not supported")
+	}
+
+	if t.size == 0 {
+		// The Go ABI aligns for zero-sized types.
+		p.dstStackSize = alignUp(p.dstStackSize, uintptr(t.align))
+		return
+	}
+
+	// In the C ABI, we're already on a word boundary.
+	// Also, sub-word-sized fastcall register arguments
+	// are stored to the least-significant bytes of the
+	// argument word and all supported Windows
+	// architectures are little endian, so srcStackOffset
+	// is already pointing to the right place for smaller
+	// arguments. The same is true on arm.
+
+	oldParts := p.parts
+	if !p.tryRegAssignArg(t, 0) {
+		// Register assignment failed.
+		// Undo the work and stack assign.
+		p.parts = oldParts
+
+		// The Go ABI aligns arguments.
+		p.dstStackSize = alignUp(p.dstStackSize, uintptr(t.align))
+
+		// Copy just the size of the argument. Note that this
+		// could be a small by-value struct, but C and Go
+		// struct layouts are compatible, so we can copy these
+		// directly, too.
+		part := abiPart{
+			kind:           abiPartStack,
+			srcStackOffset: p.srcStackSize,
+			dstStackOffset: p.dstStackSize,
+			len:            t.size,
+		}
+		// Add this step to the adapter.
+		if len(p.parts) == 0 || !p.parts[len(p.parts)-1].tryMerge(part) {
+			p.parts = append(p.parts, part)
+		}
+		// The Go ABI packs arguments.
+		p.dstStackSize += t.size
+	}
+
+	// cdecl, stdcall, fastcall, and arm pad arguments to word size.
+	// TODO(rsc): On arm and arm64 do we need to skip the caller's saved LR?
+	p.srcStackSize += sys.PtrSize
+}
+
+// tryRegAssignArg tries to register-assign a value of type t.
+// If this type is nested in an aggregate type, then offset is the
+// offset of this type within its parent type.
+// Assumes t.size <= sys.PtrSize and t.size != 0.
+//
+// Returns whether the assignment succeeded.
+func (p *abiDesc) tryRegAssignArg(t *_type, offset uintptr) bool {
+	switch k := t.kind & kindMask; k {
+	case kindBool, kindInt, kindInt8, kindInt16, kindInt32, kindUint, kindUint8, kindUint16, kindUint32, kindUintptr, kindPtr, kindUnsafePointer:
+		// Assign a register for all these types.
+		return p.assignReg(t.size, offset)
+	case kindInt64, kindUint64:
+		// Only register-assign if the registers are big enough.
+		if sys.PtrSize == 8 {
+			return p.assignReg(t.size, offset)
+		}
+	case kindArray:
+		at := (*arraytype)(unsafe.Pointer(t))
+		if at.len == 1 {
+			return p.tryRegAssignArg(at.elem, offset)
+		}
+	case kindStruct:
+		st := (*structtype)(unsafe.Pointer(t))
+		for i := range st.fields {
+			f := &st.fields[i]
+			if !p.tryRegAssignArg(f.typ, offset+f.offset()) {
+				return false
+			}
+		}
+		return true
+	}
+	// Pointer-sized types such as maps and channels are currently
+	// not supported.
+	panic("compileCallabck: type " + t.string() + " is currently not supported for use in system callbacks")
+}
+
+// assignReg attempts to assign a single register for an
+// argument with the given size, at the given offset into the
+// value in the C ABI space.
+//
+// Returns whether the assignment was successful.
+func (p *abiDesc) assignReg(size, offset uintptr) bool {
+	if p.dstRegisters >= intArgRegs {
+		return false
+	}
+	p.parts = append(p.parts, abiPart{
+		kind:           abiPartReg,
+		srcStackOffset: p.srcStackSize + offset,
+		dstRegister:    p.dstRegisters,
+		len:            size,
+	})
+	p.dstRegisters++
+	return true
+}
+
 type winCallbackKey struct {
 	fn    *funcval
 	cdecl bool
@@ -101,62 +249,14 @@ func compileCallback(fn eface, cdecl bool) (code uintptr) {
 	ft := (*functype)(unsafe.Pointer(fn._type))
 
 	// Check arguments and construct ABI translation.
-	var abiMap []abiPart
-	var src, dst uintptr
+	var abiMap abiDesc
 	for _, t := range ft.in() {
-		if t.size > sys.PtrSize {
-			// We don't support this right now. In
-			// stdcall/cdecl, 64-bit ints and doubles are
-			// passed as two words (little endian); and
-			// structs are pushed on the stack. In
-			// fastcall, arguments larger than the word
-			// size are passed by reference. On arm,
-			// 8-byte aligned arguments round up to the
-			// next even register and can be split across
-			// registers and the stack.
-			panic("compileCallback: argument size is larger than uintptr")
-		}
-		if k := t.kind & kindMask; GOARCH != "386" && (k == kindFloat32 || k == kindFloat64) {
-			// In fastcall, floating-point arguments in
-			// the first four positions are passed in
-			// floating-point registers, which we don't
-			// currently spill. arm passes floating-point
-			// arguments in VFP registers, which we also
-			// don't support.
-			// So basically we only support 386.
-			panic("compileCallback: float arguments not supported")
-		}
-
-		// The Go ABI aligns arguments.
-		dst = alignUp(dst, uintptr(t.align))
-		// In the C ABI, we're already on a word boundary.
-		// Also, sub-word-sized fastcall register arguments
-		// are stored to the least-significant bytes of the
-		// argument word and all supported Windows
-		// architectures are little endian, so src is already
-		// pointing to the right place for smaller arguments.
-		// The same is true on arm.
-
-		// Copy just the size of the argument. Note that this
-		// could be a small by-value struct, but C and Go
-		// struct layouts are compatible, so we can copy these
-		// directly, too.
-		part := abiPart{src, dst, t.size}
-		// Add this step to the adapter.
-		if len(abiMap) == 0 || !abiMap[len(abiMap)-1].tryMerge(part) {
-			abiMap = append(abiMap, part)
-		}
-
-		// cdecl, stdcall, fastcall, and arm pad arguments to word size.
-		// TODO(rsc): On arm and arm64 do we need to skip the caller's saved LR?
-		src += sys.PtrSize
-		// The Go ABI packs arguments.
-		dst += t.size
+		abiMap.assignArg(t)
 	}
 	// The Go ABI aligns the result to the word size. src is
 	// already aligned.
-	dst = alignUp(dst, sys.PtrSize)
-	retOffset := dst
+	abiMap.dstStackSize = alignUp(abiMap.dstStackSize, sys.PtrSize)
+	abiMap.retOffset = abiMap.dstStackSize
 
 	if len(ft.out()) != 1 {
 		panic("compileCallback: expected function with one uintptr-sized result")
@@ -170,10 +270,14 @@ func compileCallback(fn eface, cdecl bool) (code uintptr) {
 		// Either way, it's not AX.
 		panic("compileCallback: float results not supported")
 	}
-	// Make room for the uintptr-sized result.
-	dst += sys.PtrSize
+	if intArgRegs == 0 {
+		// Make room for the uintptr-sized result.
+		// If there are argument registers, the return value will
+		// be passed in the first register.
+		abiMap.dstStackSize += sys.PtrSize
+	}
 
-	if dst > callbackMaxFrame {
+	if abiMap.dstStackSize > callbackMaxFrame {
 		panic("compileCallback: function argument frame too large")
 	}
 
@@ -181,7 +285,7 @@ func compileCallback(fn eface, cdecl bool) (code uintptr) {
 	// arguments from the C stack.
 	var retPop uintptr
 	if cdecl {
-		retPop = src
+		retPop = abiMap.srcStackSize
 	}
 
 	key := winCallbackKey{(*funcval)(fn.data), cdecl}
@@ -203,7 +307,7 @@ func compileCallback(fn eface, cdecl bool) (code uintptr) {
 		unlock(&cbs.lock)
 		throw("too many callback functions")
 	}
-	c := winCallback{key.fn, retPop, abiMap, retOffset}
+	c := winCallback{key.fn, retPop, abiMap}
 	cbs.ctxt[n] = c
 	cbs.index[key] = n
 	cbs.n++
@@ -237,22 +341,39 @@ func callbackWrap(a *callbackArgs) {
 	a.retPop = c.retPop
 
 	// Convert from C to Go ABI.
+	var regs abi.RegArgs
 	var frame [callbackMaxFrame]byte
 	goArgs := unsafe.Pointer(&frame)
-	for _, part := range c.abiMap {
-		memmove(add(goArgs, part.dst), add(a.args, part.src), part.len)
+	for _, part := range c.abiMap.parts {
+		switch part.kind {
+		case abiPartStack:
+			memmove(add(goArgs, part.dstStackOffset), add(a.args, part.srcStackOffset), part.len)
+		case abiPartReg:
+			goReg := unsafe.Pointer(&regs.Ints[part.dstRegister])
+			memmove(goReg, add(a.args, part.srcStackOffset), part.len)
+		default:
+			panic("bad ABI description")
+		}
 	}
 
 	// Even though this is copying back results, we can pass a nil
 	// type because those results must not require write barriers.
-	//
-	// Pass a dummy RegArgs for now.
-	// TODO(mknyszek): Pass arguments in registers.
-	var regs abi.RegArgs
-	reflectcall(nil, unsafe.Pointer(c.fn), noescape(goArgs), uint32(c.retOffset)+sys.PtrSize, uint32(c.retOffset), uint32(c.retOffset)+sys.PtrSize, &regs)
+	reflectcall(nil, unsafe.Pointer(c.fn), noescape(goArgs), uint32(c.abiMap.dstStackSize), uint32(c.abiMap.retOffset), uint32(c.abiMap.dstStackSize), &regs)
 
 	// Extract the result.
-	a.result = *(*uintptr)(unsafe.Pointer(&frame[c.retOffset]))
+	//
+	// There's always exactly one return value, one pointer in size.
+	// If it's on the stack, then we will have reserved space for it
+	// at the end of the frame, otherwise it was passed in a register.
+	if c.abiMap.dstStackSize != c.abiMap.retOffset {
+		a.result = *(*uintptr)(unsafe.Pointer(&frame[c.abiMap.retOffset]))
+	} else {
+		var zero int
+		// On architectures with no registers, Ints[0] would be a compile error,
+		// so we use a dynamic index. These architectures will never take this
+		// branch, so this won't cause a runtime panic.
+		a.result = regs.Ints[zero]
+	}
 }
 
 const _LOAD_LIBRARY_SEARCH_SYSTEM32 = 0x00000800
diff --git a/src/runtime/syscall_windows_test.go b/src/runtime/syscall_windows_test.go
index fb215b3c31..65ecb4fbf2 100644
--- a/src/runtime/syscall_windows_test.go
+++ b/src/runtime/syscall_windows_test.go
@@ -7,6 +7,7 @@ package runtime_test
 import (
 	"bytes"
 	"fmt"
+	"internal/abi"
 	"internal/syscall/windows/sysdll"
 	"internal/testenv"
 	"io"
@@ -390,6 +391,103 @@ var cbFuncs = []cbFunc{
 	}},
 }
 
+//go:registerparams
+func sum2(i1, i2 uintptr) uintptr {
+	return i1 + i2
+}
+
+//go:registerparams
+func sum3(i1, i2, i3 uintptr) uintptr {
+	return i1 + i2 + i3
+}
+
+//go:registerparams
+func sum4(i1, i2, i3, i4 uintptr) uintptr {
+	return i1 + i2 + i3 + i4
+}
+
+//go:registerparams
+func sum5(i1, i2, i3, i4, i5 uintptr) uintptr {
+	return i1 + i2 + i3 + i4 + i5
+}
+
+//go:registerparams
+func sum6(i1, i2, i3, i4, i5, i6 uintptr) uintptr {
+	return i1 + i2 + i3 + i4 + i5 + i6
+}
+
+//go:registerparams
+func sum7(i1, i2, i3, i4, i5, i6, i7 uintptr) uintptr {
+	return i1 + i2 + i3 + i4 + i5 + i6 + i7
+}
+
+//go:registerparams
+func sum8(i1, i2, i3, i4, i5, i6, i7, i8 uintptr) uintptr {
+	return i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8
+}
+
+//go:registerparams
+func sum9(i1, i2, i3, i4, i5, i6, i7, i8, i9 uintptr) uintptr {
+	return i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9
+}
+
+//go:registerparams
+func sum10(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10 uintptr) uintptr {
+	return i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9 + i10
+}
+
+//go:registerparams
+func sum9uint8(i1, i2, i3, i4, i5, i6, i7, i8, i9 uint8) uintptr {
+	return uintptr(i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9)
+}
+
+//go:registerparams
+func sum9uint16(i1, i2, i3, i4, i5, i6, i7, i8, i9 uint16) uintptr {
+	return uintptr(i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9)
+}
+
+//go:registerparams
+func sum9int8(i1, i2, i3, i4, i5, i6, i7, i8, i9 int8) uintptr {
+	return uintptr(i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9)
+}
+
+//go:registerparams
+func sum5mix(i1 int8, i2 int16, i3 int32, i4, i5 uintptr) uintptr {
+	return uintptr(i1) + uintptr(i2) + uintptr(i3) + i4 + i5
+}
+
+//go:registerparams
+func sum5andPair(i1, i2, i3, i4, i5 uint8Pair) uintptr {
+	return uintptr(i1.x + i1.y + i2.x + i2.y + i3.x + i3.y + i4.x + i4.y + i5.x + i5.y)
+}
+
+// TODO(register args): Remove this once we switch to using the register
+// calling convention by default, since this is redundant with the existing
+// tests.
+var cbFuncsRegABI = []cbFunc{
+	{sum2},
+	{sum3},
+	{sum4},
+	{sum5},
+	{sum6},
+	{sum7},
+	{sum8},
+	{sum9},
+	{sum10},
+	{sum9uint8},
+	{sum9uint16},
+	{sum9int8},
+	{sum5mix},
+	{sum5andPair},
+}
+
+func getCallbackTestFuncs() []cbFunc {
+	if regs := runtime.SetIntArgRegs(-1); regs > 0 {
+		return cbFuncsRegABI
+	}
+	return cbFuncs
+}
+
 type cbDLL struct {
 	name      string
 	buildArgs func(out, src string) []string
@@ -406,7 +504,7 @@ func (d *cbDLL) makeSrc(t *testing.T, path string) {
 #include <stdint.h>
 typedef struct { uint8_t x, y; } uint8Pair_t;
 `)
-	for _, cbf := range cbFuncs {
+	for _, cbf := range getCallbackTestFuncs() {
 		cbf.cSrc(f, false)
 		cbf.cSrc(f, true)
 	}
@@ -451,12 +549,15 @@ func TestStdcallAndCDeclCallbacks(t *testing.T) {
 	}
 	defer os.RemoveAll(tmp)
 
+	oldRegs := runtime.SetIntArgRegs(abi.IntArgRegs)
+	defer runtime.SetIntArgRegs(oldRegs)
+
 	for _, dll := range cbDLLs {
 		t.Run(dll.name, func(t *testing.T) {
 			dllPath := dll.build(t, tmp)
 			dll := syscall.MustLoadDLL(dllPath)
 			defer dll.Release()
-			for _, cbf := range cbFuncs {
+			for _, cbf := range getCallbackTestFuncs() {
 				t.Run(cbf.cName(false), func(t *testing.T) {
 					stdcall := syscall.NewCallback(cbf.goFunc)
 					cbf.testOne(t, dll, false, stdcall)
-- 
GitLab


From 4acefa07b1499b063e1ff63c9d4cab7b7f8d49a2 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 24 Mar 2021 09:36:04 -0400
Subject: [PATCH 1313/2400] go/parser: switch to resolving objects as a
 post-processing pass

Coupling object resolution to parsing complicates the parsing code, and
is a barrier to improvement. It requires passing around context such as
'lhs' or 'keyOk', and even then sometimes requires guess-work, such as
whether to resolve the key in a composite literal.

In this CL we delay object resolution to a separate pass after the file
parse completes. This makes it easier to see logic of scoping, and
removes state from the parsing code. This can enable subsequent
improvements such as optionally skipping object resolution, aligning the
parser with cmd/compile/internal/syntax, and allowing alternative
parsers to reuse object resolution.

The additional AST traversal appears to slow down parsing by around 4%.
That seems small enough not to worry about, especially since performance
sensitive users may eventually be able to disable object resolution
entirely, saving around 18% off the previous baseline. I'll also mail a
speculative CL showing how we can significantly mitigate the cost of
object resolution by transposing scopes.

For #45104

Change-Id: I98d9143fd77ae29e84ec7c3ae2fdb1139510da37
Reviewed-on: https://go-review.googlesource.com/c/go/+/304455
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/parser/interface.go |   8 -
 src/go/parser/parser.go    | 477 +++++++----------------------------
 src/go/parser/resolver.go  | 505 +++++++++++++++++++++++++++++++++++++
 3 files changed, 595 insertions(+), 395 deletions(-)
 create mode 100644 src/go/parser/resolver.go

diff --git a/src/go/parser/interface.go b/src/go/parser/interface.go
index 123faaee77..8f306adaab 100644
--- a/src/go/parser/interface.go
+++ b/src/go/parser/interface.go
@@ -215,15 +215,7 @@ func ParseExprFrom(fset *token.FileSet, filename string, src interface{}, mode M
 
 	// parse expr
 	p.init(fset, filename, text, mode)
-	// Set up pkg-level scopes to avoid nil-pointer errors.
-	// This is not needed for a correct expression x as the
-	// parser will be ok with a nil topScope, but be cautious
-	// in case of an erroneous x.
-	p.openScope()
-	p.pkgScope = p.topScope
 	expr = p.parseRhsOrType()
-	p.closeScope()
-	assert(p.topScope == nil, "unbalanced scopes")
 
 	// If a semicolon was inserted, consume it;
 	// report an error if there's more tokens.
diff --git a/src/go/parser/parser.go b/src/go/parser/parser.go
index 0a69515be1..93ab4a4600 100644
--- a/src/go/parser/parser.go
+++ b/src/go/parser/parser.go
@@ -58,16 +58,7 @@ type parser struct {
 	exprLev int  // < 0: in control clause, >= 0: in expression
 	inRhs   bool // if set, the parser is parsing a rhs expression
 
-	// Ordinary identifier scopes
-	pkgScope   *ast.Scope        // pkgScope.Outer == nil
-	topScope   *ast.Scope        // top-most scope; may be pkgScope
-	unresolved []*ast.Ident      // unresolved identifiers
-	imports    []*ast.ImportSpec // list of imports
-
-	// Label scopes
-	// (maintained by open/close LabelScope)
-	labelScope  *ast.Scope     // label scope for current function
-	targetStack [][]*ast.Ident // stack of unresolved labels
+	imports []*ast.ImportSpec // list of imports
 }
 
 func (p *parser) init(fset *token.FileSet, filename string, src []byte, mode Mode) {
@@ -81,134 +72,9 @@ func (p *parser) init(fset *token.FileSet, filename string, src []byte, mode Mod
 
 	p.mode = mode
 	p.trace = mode&Trace != 0 // for convenience (p.trace is used frequently)
-
 	p.next()
 }
 
-// ----------------------------------------------------------------------------
-// Scoping support
-
-func (p *parser) openScope() {
-	p.topScope = ast.NewScope(p.topScope)
-}
-
-func (p *parser) closeScope() {
-	p.topScope = p.topScope.Outer
-}
-
-func (p *parser) openLabelScope() {
-	p.labelScope = ast.NewScope(p.labelScope)
-	p.targetStack = append(p.targetStack, nil)
-}
-
-func (p *parser) closeLabelScope() {
-	// resolve labels
-	n := len(p.targetStack) - 1
-	scope := p.labelScope
-	for _, ident := range p.targetStack[n] {
-		ident.Obj = scope.Lookup(ident.Name)
-		if ident.Obj == nil && p.mode&DeclarationErrors != 0 {
-			p.error(ident.Pos(), fmt.Sprintf("label %s undefined", ident.Name))
-		}
-	}
-	// pop label scope
-	p.targetStack = p.targetStack[0:n]
-	p.labelScope = p.labelScope.Outer
-}
-
-func (p *parser) declare(decl, data interface{}, scope *ast.Scope, kind ast.ObjKind, idents ...*ast.Ident) {
-	for _, ident := range idents {
-		assert(ident.Obj == nil, "identifier already declared or resolved")
-		obj := ast.NewObj(kind, ident.Name)
-		// remember the corresponding declaration for redeclaration
-		// errors and global variable resolution/typechecking phase
-		obj.Decl = decl
-		obj.Data = data
-		ident.Obj = obj
-		if ident.Name != "_" {
-			if alt := scope.Insert(obj); alt != nil && p.mode&DeclarationErrors != 0 {
-				prevDecl := ""
-				if pos := alt.Pos(); pos.IsValid() {
-					prevDecl = fmt.Sprintf("\n\tprevious declaration at %s", p.file.Position(pos))
-				}
-				p.error(ident.Pos(), fmt.Sprintf("%s redeclared in this block%s", ident.Name, prevDecl))
-			}
-		}
-	}
-}
-
-func (p *parser) shortVarDecl(decl *ast.AssignStmt) {
-	// Go spec: A short variable declaration may redeclare variables
-	// provided they were originally declared in the same block with
-	// the same type, and at least one of the non-blank variables is new.
-	n := 0 // number of new variables
-	for _, x := range decl.Lhs {
-		if ident, isIdent := x.(*ast.Ident); isIdent {
-			assert(ident.Obj == nil, "identifier already declared or resolved")
-			obj := ast.NewObj(ast.Var, ident.Name)
-			// remember corresponding assignment for other tools
-			obj.Decl = decl
-			ident.Obj = obj
-			if ident.Name != "_" {
-				if alt := p.topScope.Insert(obj); alt != nil {
-					ident.Obj = alt // redeclaration
-				} else {
-					n++ // new declaration
-				}
-			}
-		} else {
-			p.errorExpected(x.Pos(), "identifier on left side of :=")
-		}
-	}
-	if n == 0 && p.mode&DeclarationErrors != 0 {
-		p.error(decl.Lhs[0].Pos(), "no new variables on left side of :=")
-	}
-}
-
-// The unresolved object is a sentinel to mark identifiers that have been added
-// to the list of unresolved identifiers. The sentinel is only used for verifying
-// internal consistency.
-var unresolved = new(ast.Object)
-
-// If x is an identifier, tryResolve attempts to resolve x by looking up
-// the object it denotes. If no object is found and collectUnresolved is
-// set, x is marked as unresolved and collected in the list of unresolved
-// identifiers.
-//
-func (p *parser) tryResolve(x ast.Expr, collectUnresolved bool) {
-	// nothing to do if x is not an identifier or the blank identifier
-	ident, _ := x.(*ast.Ident)
-	if ident == nil {
-		return
-	}
-	// Don't use assert here, to avoid needless formatting of the message below.
-	if ident.Obj != nil {
-		panic(fmt.Sprintf("identifier %s already declared or resolved", ident.Name))
-	}
-	if ident.Name == "_" {
-		return
-	}
-	// try to resolve the identifier
-	for s := p.topScope; s != nil; s = s.Outer {
-		if obj := s.Lookup(ident.Name); obj != nil {
-			ident.Obj = obj
-			return
-		}
-	}
-	// all local scopes are known, so any unresolved identifier
-	// must be found either in the file scope, package scope
-	// (perhaps in another file), or universe scope --- collect
-	// them so that they can be resolved later
-	if collectUnresolved {
-		ident.Obj = unresolved
-		p.unresolved = append(p.unresolved, ident)
-	}
-}
-
-func (p *parser) resolve(x ast.Expr) {
-	p.tryResolve(x, true)
-}
-
 // ----------------------------------------------------------------------------
 // Parsing support
 
@@ -580,50 +446,24 @@ func (p *parser) parseIdentList() (list []*ast.Ident) {
 // Common productions
 
 // If lhs is set, result list elements which are identifiers are not resolved.
-func (p *parser) parseExprList(lhs bool) (list []ast.Expr) {
+func (p *parser) parseExprList() (list []ast.Expr) {
 	if p.trace {
 		defer un(trace(p, "ExpressionList"))
 	}
 
-	list = append(list, p.checkExpr(p.parseExpr(lhs)))
+	list = append(list, p.checkExpr(p.parseExpr()))
 	for p.tok == token.COMMA {
 		p.next()
-		list = append(list, p.checkExpr(p.parseExpr(lhs)))
+		list = append(list, p.checkExpr(p.parseExpr()))
 	}
 
 	return
 }
 
-func (p *parser) parseLhsList() []ast.Expr {
+func (p *parser) parseList(inRhs bool) []ast.Expr {
 	old := p.inRhs
-	p.inRhs = false
-	list := p.parseExprList(true)
-	switch p.tok {
-	case token.DEFINE:
-		// lhs of a short variable declaration
-		// but doesn't enter scope until later.
-	case token.COLON:
-		// lhs of a label declaration or a communication clause of a select
-		// statement (parseLhsList is not called when parsing the case clause
-		// of a switch statement):
-		// - labels are declared by the caller of parseLhsList
-		// - for communication clauses, if there is a stand-alone identifier
-		//   followed by a colon, we have a syntax error; there is no need
-		//   to resolve the identifier in that case
-	default:
-		// identifiers must be declared elsewhere
-		for _, x := range list {
-			p.resolve(x)
-		}
-	}
-	p.inRhs = old
-	return list
-}
-
-func (p *parser) parseRhsList() []ast.Expr {
-	old := p.inRhs
-	p.inRhs = true
-	list := p.parseExprList(false)
+	p.inRhs = inRhs
+	list := p.parseExprList()
 	p.inRhs = old
 	return list
 }
@@ -636,7 +476,7 @@ func (p *parser) parseType() ast.Expr {
 		defer un(trace(p, "Type"))
 	}
 
-	typ := p.tryType()
+	typ := p.tryIdentOrType()
 
 	if typ == nil {
 		pos := p.pos
@@ -669,13 +509,11 @@ func (p *parser) parseTypeName(ident *ast.Ident) ast.Expr {
 
 	if ident == nil {
 		ident = p.parseIdent()
-		// don't resolve ident yet - it may be a parameter or field name
 	}
 
 	if p.tok == token.PERIOD {
 		// ident is a package name
 		p.next()
-		p.resolve(ident)
 		sel := p.parseIdent()
 		return &ast.SelectorExpr{X: ident, Sel: sel}
 	}
@@ -740,7 +578,7 @@ func (p *parser) parseArrayFieldOrTypeInstance(x *ast.Ident) (*ast.Ident, ast.Ex
 
 	// x [P]E or x[P]
 	if len(args) == 1 {
-		elt := p.tryType()
+		elt := p.tryIdentOrType()
 		if elt != nil {
 			// x [P]E
 			return x, &ast.ArrayType{Lbrack: lbrack, Len: args[0], Elt: elt}
@@ -760,7 +598,7 @@ func (p *parser) parseArrayFieldOrTypeInstance(x *ast.Ident) (*ast.Ident, ast.Ex
 	return nil, &ast.IndexExpr{X: x, Lbrack: lbrack, Index: &ast.ListExpr{ElemList: args}, Rbrack: rbrack}
 }
 
-func (p *parser) parseFieldDecl(scope *ast.Scope) *ast.Field {
+func (p *parser) parseFieldDecl() *ast.Field {
 	if p.trace {
 		defer un(trace(p, "FieldDecl"))
 	}
@@ -776,8 +614,6 @@ func (p *parser) parseFieldDecl(scope *ast.Scope) *ast.Field {
 			typ = name
 			if p.tok == token.PERIOD {
 				typ = p.parseQualifiedIdent(name)
-			} else {
-				p.resolve(typ)
 			}
 		} else {
 			// name1, name2, ... T
@@ -814,7 +650,6 @@ func (p *parser) parseFieldDecl(scope *ast.Scope) *ast.Field {
 	p.expectSemi() // call before accessing p.linecomment
 
 	field := &ast.Field{Doc: doc, Names: names, Type: typ, Tag: tag, Comment: p.lineComment}
-	p.declare(field, nil, scope, ast.Var, names...)
 	return field
 }
 
@@ -825,13 +660,12 @@ func (p *parser) parseStructType() *ast.StructType {
 
 	pos := p.expect(token.STRUCT)
 	lbrace := p.expect(token.LBRACE)
-	scope := ast.NewScope(nil) // struct scope
 	var list []*ast.Field
 	for p.tok == token.IDENT || p.tok == token.MUL || p.tok == token.LPAREN {
 		// a field declaration cannot start with a '(' but we accept
 		// it here for more robust parsing and better error messages
 		// (parseFieldDecl will check and complain if necessary)
-		list = append(list, p.parseFieldDecl(scope))
+		list = append(list, p.parseFieldDecl())
 	}
 	rbrace := p.expect(token.RBRACE)
 
@@ -927,7 +761,7 @@ func (p *parser) parseParamDecl(name *ast.Ident) (f field) {
 	return
 }
 
-func (p *parser) parseParameterList(scope *ast.Scope, name0 *ast.Ident, closing token.Token, parseParamDecl func(*ast.Ident) field, tparams bool) (params []*ast.Field) {
+func (p *parser) parseParameterList(name0 *ast.Ident, closing token.Token, parseParamDecl func(*ast.Ident) field, tparams bool) (params []*ast.Field) {
 	if p.trace {
 		defer un(trace(p, "ParameterList"))
 	}
@@ -968,7 +802,6 @@ func (p *parser) parseParameterList(scope *ast.Scope, name0 *ast.Ident, closing
 		for i := 0; i < len(list); i++ {
 			par := &list[i]
 			if typ := par.name; typ != nil {
-				p.resolve(typ)
 				par.typ = typ
 				par.name = nil
 			}
@@ -1022,9 +855,6 @@ func (p *parser) parseParameterList(scope *ast.Scope, name0 *ast.Ident, closing
 	addParams := func() {
 		assert(typ != nil, "nil type in named parameter list")
 		field := &ast.Field{Names: names, Type: typ}
-		// Go spec: The scope of an identifier denoting a function
-		// parameter or result variable is the function body.
-		p.declare(field, nil, scope, ast.Var, names...)
 		params = append(params, field)
 		names = nil
 	}
@@ -1043,7 +873,7 @@ func (p *parser) parseParameterList(scope *ast.Scope, name0 *ast.Ident, closing
 	return
 }
 
-func (p *parser) parseParameters(scope *ast.Scope, acceptTParams bool) (tparams, params *ast.FieldList) {
+func (p *parser) parseParameters(acceptTParams bool) (tparams, params *ast.FieldList) {
 	if p.trace {
 		defer un(trace(p, "Parameters"))
 	}
@@ -1052,7 +882,7 @@ func (p *parser) parseParameters(scope *ast.Scope, acceptTParams bool) (tparams,
 		opening := p.pos
 		p.next()
 		// [T any](params) syntax
-		list := p.parseParameterList(scope, nil, token.RBRACK, p.parseParamDecl, true)
+		list := p.parseParameterList(nil, token.RBRACK, p.parseParamDecl, true)
 		rbrack := p.expect(token.RBRACK)
 		tparams = &ast.FieldList{Opening: opening, List: list, Closing: rbrack}
 		// Type parameter lists must not be empty.
@@ -1066,7 +896,7 @@ func (p *parser) parseParameters(scope *ast.Scope, acceptTParams bool) (tparams,
 
 	var fields []*ast.Field
 	if p.tok != token.RPAREN {
-		fields = p.parseParameterList(scope, nil, token.RPAREN, p.parseParamDecl, false)
+		fields = p.parseParameterList(nil, token.RPAREN, p.parseParamDecl, false)
 	}
 
 	rparen := p.expect(token.RPAREN)
@@ -1075,17 +905,17 @@ func (p *parser) parseParameters(scope *ast.Scope, acceptTParams bool) (tparams,
 	return
 }
 
-func (p *parser) parseResult(scope *ast.Scope) *ast.FieldList {
+func (p *parser) parseResult() *ast.FieldList {
 	if p.trace {
 		defer un(trace(p, "Result"))
 	}
 
 	if p.tok == token.LPAREN {
-		_, results := p.parseParameters(scope, false)
+		_, results := p.parseParameters(false)
 		return results
 	}
 
-	typ := p.tryType()
+	typ := p.tryIdentOrType()
 	if typ != nil {
 		list := make([]*ast.Field, 1)
 		list[0] = &ast.Field{Type: typ}
@@ -1095,23 +925,22 @@ func (p *parser) parseResult(scope *ast.Scope) *ast.FieldList {
 	return nil
 }
 
-func (p *parser) parseFuncType() (*ast.FuncType, *ast.Scope) {
+func (p *parser) parseFuncType() *ast.FuncType {
 	if p.trace {
 		defer un(trace(p, "FuncType"))
 	}
 
 	pos := p.expect(token.FUNC)
-	scope := ast.NewScope(p.topScope) // function scope
-	tparams, params := p.parseParameters(scope, true)
+	tparams, params := p.parseParameters(true)
 	if tparams != nil {
 		p.error(tparams.Pos(), "function type cannot have type parameters")
 	}
-	results := p.parseResult(scope)
+	results := p.parseResult()
 
-	return &ast.FuncType{Func: pos, Params: params, Results: results}, scope
+	return &ast.FuncType{Func: pos, Params: params, Results: results}
 }
 
-func (p *parser) parseMethodSpec(scope *ast.Scope) *ast.Field {
+func (p *parser) parseMethodSpec() *ast.Field {
 	if p.trace {
 		defer un(trace(p, "MethodSpec"))
 	}
@@ -1127,17 +956,16 @@ func (p *parser) parseMethodSpec(scope *ast.Scope) *ast.Field {
 			lbrack := p.pos
 			p.next()
 			p.exprLev++
-			x := p.parseExpr(true) // we don't know yet if we're a lhs or rhs expr
+			x := p.parseExpr()
 			p.exprLev--
 			if name0, _ := x.(*ast.Ident); name0 != nil && p.tok != token.COMMA && p.tok != token.RBRACK {
 				// generic method m[T any]
-				scope := ast.NewScope(nil) // method scope
-				list := p.parseParameterList(scope, name0, token.RBRACK, p.parseParamDecl, true)
+				list := p.parseParameterList(name0, token.RBRACK, p.parseParamDecl, true)
 				rbrack := p.expect(token.RBRACK)
 				tparams := &ast.FieldList{Opening: lbrack, List: list, Closing: rbrack}
 				// TODO(rfindley) refactor to share code with parseFuncType.
-				_, params := p.parseParameters(scope, false)
-				results := p.parseResult(scope)
+				_, params := p.parseParameters(false)
+				results := p.parseResult()
 				idents = []*ast.Ident{ident}
 				typ = &ast.FuncType{Func: token.NoPos, TParams: tparams, Params: params, Results: results}
 			} else {
@@ -1161,15 +989,13 @@ func (p *parser) parseMethodSpec(scope *ast.Scope) *ast.Field {
 		case p.tok == token.LPAREN:
 			// ordinary method
 			// TODO(rfindley) refactor to share code with parseFuncType.
-			scope := ast.NewScope(nil) // method scope
-			_, params := p.parseParameters(scope, false)
-			results := p.parseResult(scope)
+			_, params := p.parseParameters(false)
+			results := p.parseResult()
 			idents = []*ast.Ident{ident}
 			typ = &ast.FuncType{Func: token.NoPos, Params: params, Results: results}
 		default:
 			// embedded type
 			typ = x
-			p.resolve(typ)
 		}
 	} else {
 		// embedded, possibly instantiated type
@@ -1182,7 +1008,6 @@ func (p *parser) parseMethodSpec(scope *ast.Scope) *ast.Field {
 	p.expectSemi() // call before accessing p.linecomment
 
 	spec := &ast.Field{Doc: doc, Names: idents, Type: typ, Comment: p.lineComment}
-	p.declare(spec, nil, scope, ast.Fun, idents...)
 
 	return spec
 }
@@ -1194,11 +1019,10 @@ func (p *parser) parseInterfaceType() *ast.InterfaceType {
 
 	pos := p.expect(token.INTERFACE)
 	lbrace := p.expect(token.LBRACE)
-	scope := ast.NewScope(nil) // interface scope
 	var list []*ast.Field
 	for p.tok == token.IDENT || p.mode&parseTypeParams != 0 && p.tok == token.TYPE {
 		if p.tok == token.IDENT {
-			list = append(list, p.parseMethodSpec(scope))
+			list = append(list, p.parseMethodSpec())
 		} else {
 			// all types in a type list share the same field name "type"
 			// (since type is a keyword, a Go program cannot have that field name)
@@ -1287,7 +1111,6 @@ func (p *parser) parseTypeInstance(typ ast.Expr) ast.Expr {
 	return &ast.IndexExpr{X: typ, Lbrack: opening, Index: &ast.ListExpr{ElemList: list}, Rbrack: closing}
 }
 
-// If the result is an identifier, it is not resolved.
 func (p *parser) tryIdentOrType() ast.Expr {
 	switch p.tok {
 	case token.IDENT:
@@ -1307,7 +1130,7 @@ func (p *parser) tryIdentOrType() ast.Expr {
 	case token.MUL:
 		return p.parsePointerType()
 	case token.FUNC:
-		typ, _ := p.parseFuncType()
+		typ := p.parseFuncType()
 		return typ
 	case token.INTERFACE:
 		return p.parseInterfaceType()
@@ -1327,14 +1150,6 @@ func (p *parser) tryIdentOrType() ast.Expr {
 	return nil
 }
 
-func (p *parser) tryType() ast.Expr {
-	typ := p.tryIdentOrType()
-	if typ != nil {
-		p.resolve(typ)
-	}
-	return typ
-}
-
 // ----------------------------------------------------------------------------
 // Blocks
 
@@ -1350,17 +1165,13 @@ func (p *parser) parseStmtList() (list []ast.Stmt) {
 	return
 }
 
-func (p *parser) parseBody(scope *ast.Scope) *ast.BlockStmt {
+func (p *parser) parseBody() *ast.BlockStmt {
 	if p.trace {
 		defer un(trace(p, "Body"))
 	}
 
 	lbrace := p.expect(token.LBRACE)
-	p.topScope = scope // open function scope
-	p.openLabelScope()
 	list := p.parseStmtList()
-	p.closeLabelScope()
-	p.closeScope()
 	rbrace := p.expect2(token.RBRACE)
 
 	return &ast.BlockStmt{Lbrace: lbrace, List: list, Rbrace: rbrace}
@@ -1372,9 +1183,7 @@ func (p *parser) parseBlockStmt() *ast.BlockStmt {
 	}
 
 	lbrace := p.expect(token.LBRACE)
-	p.openScope()
 	list := p.parseStmtList()
-	p.closeScope()
 	rbrace := p.expect2(token.RBRACE)
 
 	return &ast.BlockStmt{Lbrace: lbrace, List: list, Rbrace: rbrace}
@@ -1388,14 +1197,14 @@ func (p *parser) parseFuncTypeOrLit() ast.Expr {
 		defer un(trace(p, "FuncTypeOrLit"))
 	}
 
-	typ, scope := p.parseFuncType()
+	typ := p.parseFuncType()
 	if p.tok != token.LBRACE {
 		// function type only
 		return typ
 	}
 
 	p.exprLev++
-	body := p.parseBody(scope)
+	body := p.parseBody()
 	p.exprLev--
 
 	return &ast.FuncLit{Type: typ, Body: body}
@@ -1403,9 +1212,8 @@ func (p *parser) parseFuncTypeOrLit() ast.Expr {
 
 // parseOperand may return an expression or a raw type (incl. array
 // types of the form [...]T. Callers must verify the result.
-// If lhs is set and the result is an identifier, it is not resolved.
 //
-func (p *parser) parseOperand(lhs bool) ast.Expr {
+func (p *parser) parseOperand() ast.Expr {
 	if p.trace {
 		defer un(trace(p, "Operand"))
 	}
@@ -1413,9 +1221,6 @@ func (p *parser) parseOperand(lhs bool) ast.Expr {
 	switch p.tok {
 	case token.IDENT:
 		x := p.parseIdent()
-		if !lhs {
-			p.resolve(x)
-		}
 		return x
 
 	case token.INT, token.FLOAT, token.IMAG, token.CHAR, token.STRING:
@@ -1590,7 +1395,7 @@ func (p *parser) parseCallOrConversion(fun ast.Expr) *ast.CallExpr {
 	return &ast.CallExpr{Fun: fun, Lparen: lparen, Args: list, Ellipsis: ellipsis, Rparen: rparen}
 }
 
-func (p *parser) parseValue(keyOk bool) ast.Expr {
+func (p *parser) parseValue() ast.Expr {
 	if p.trace {
 		defer un(trace(p, "Element"))
 	}
@@ -1599,35 +1404,7 @@ func (p *parser) parseValue(keyOk bool) ast.Expr {
 		return p.parseLiteralValue(nil)
 	}
 
-	// Because the parser doesn't know the composite literal type, it cannot
-	// know if a key that's an identifier is a struct field name or a name
-	// denoting a value. The former is not resolved by the parser or the
-	// resolver.
-	//
-	// Instead, _try_ to resolve such a key if possible. If it resolves,
-	// it a) has correctly resolved, or b) incorrectly resolved because
-	// the key is a struct field with a name matching another identifier.
-	// In the former case we are done, and in the latter case we don't
-	// care because the type checker will do a separate field lookup.
-	//
-	// If the key does not resolve, it a) must be defined at the top
-	// level in another file of the same package, the universe scope, or be
-	// undeclared; or b) it is a struct field. In the former case, the type
-	// checker can do a top-level lookup, and in the latter case it will do
-	// a separate field lookup.
-	x := p.checkExpr(p.parseExpr(keyOk))
-	if keyOk {
-		if p.tok == token.COLON {
-			// Try to resolve the key but don't collect it
-			// as unresolved identifier if it fails so that
-			// we don't get (possibly false) errors about
-			// undeclared names.
-			p.tryResolve(x, false)
-		} else {
-			// not a key
-			p.resolve(x)
-		}
-	}
+	x := p.checkExpr(p.parseExpr())
 
 	return x
 }
@@ -1637,11 +1414,11 @@ func (p *parser) parseElement() ast.Expr {
 		defer un(trace(p, "Element"))
 	}
 
-	x := p.parseValue(true)
+	x := p.parseValue()
 	if p.tok == token.COLON {
 		colon := p.pos
 		p.next()
-		x = &ast.KeyValueExpr{Key: x, Colon: colon, Value: p.parseValue(false)}
+		x = &ast.KeyValueExpr{Key: x, Colon: colon, Value: p.parseValue()}
 	}
 
 	return x
@@ -1736,20 +1513,16 @@ func (p *parser) checkExprOrType(x ast.Expr) ast.Expr {
 	return x
 }
 
-// If lhs is set and the result is an identifier, it is not resolved.
-func (p *parser) parsePrimaryExpr(lhs bool) (x ast.Expr) {
+func (p *parser) parsePrimaryExpr() (x ast.Expr) {
 	if p.trace {
 		defer un(trace(p, "PrimaryExpr"))
 	}
 
-	x = p.parseOperand(lhs)
+	x = p.parseOperand()
 	for {
 		switch p.tok {
 		case token.PERIOD:
 			p.next()
-			if lhs {
-				p.resolve(x)
-			}
 			switch p.tok {
 			case token.IDENT:
 				x = p.parseSelector(p.checkExprOrType(x))
@@ -1770,14 +1543,8 @@ func (p *parser) parsePrimaryExpr(lhs bool) (x ast.Expr) {
 				x = &ast.SelectorExpr{X: x, Sel: sel}
 			}
 		case token.LBRACK:
-			if lhs {
-				p.resolve(x)
-			}
 			x = p.parseIndexOrSliceOrInstance(p.checkExpr(x))
 		case token.LPAREN:
-			if lhs {
-				p.resolve(x)
-			}
 			x = p.parseCallOrConversion(p.checkExprOrType(x))
 		case token.LBRACE:
 			// operand may have returned a parenthesized complit
@@ -1804,21 +1571,14 @@ func (p *parser) parsePrimaryExpr(lhs bool) (x ast.Expr) {
 				p.error(t.Pos(), "cannot parenthesize type in composite literal")
 				// already progressed, no need to advance
 			}
-			if lhs {
-				// An error has already been reported above, but try to resolve the 'T'
-				// in (T){...} anyway.
-				p.resolve(t)
-			}
 			x = p.parseLiteralValue(x)
 		default:
 			return
 		}
-		lhs = false // no need to try to resolve again
 	}
 }
 
-// If lhs is set and the result is an identifier, it is not resolved.
-func (p *parser) parseUnaryExpr(lhs bool) ast.Expr {
+func (p *parser) parseUnaryExpr() ast.Expr {
 	if p.trace {
 		defer un(trace(p, "UnaryExpr"))
 	}
@@ -1827,7 +1587,7 @@ func (p *parser) parseUnaryExpr(lhs bool) ast.Expr {
 	case token.ADD, token.SUB, token.NOT, token.XOR, token.AND:
 		pos, op := p.pos, p.tok
 		p.next()
-		x := p.parseUnaryExpr(false)
+		x := p.parseUnaryExpr()
 		return &ast.UnaryExpr{OpPos: pos, Op: op, X: p.checkExpr(x)}
 
 	case token.ARROW:
@@ -1849,7 +1609,7 @@ func (p *parser) parseUnaryExpr(lhs bool) ast.Expr {
 		//   <- (chan type)    =>  (<-chan type)
 		//   <- (chan<- type)  =>  (<-chan (<-type))
 
-		x := p.parseUnaryExpr(false)
+		x := p.parseUnaryExpr()
 
 		// determine which case we have
 		if typ, ok := x.(*ast.ChanType); ok {
@@ -1880,11 +1640,11 @@ func (p *parser) parseUnaryExpr(lhs bool) ast.Expr {
 		// pointer type or unary "*" expression
 		pos := p.pos
 		p.next()
-		x := p.parseUnaryExpr(false)
+		x := p.parseUnaryExpr()
 		return &ast.StarExpr{Star: pos, X: p.checkExprOrType(x)}
 	}
 
-	return p.parsePrimaryExpr(lhs)
+	return p.parsePrimaryExpr()
 }
 
 func (p *parser) tokPrec() (token.Token, int) {
@@ -1895,44 +1655,38 @@ func (p *parser) tokPrec() (token.Token, int) {
 	return tok, tok.Precedence()
 }
 
-// If lhs is set and the result is an identifier, it is not resolved.
-func (p *parser) parseBinaryExpr(lhs bool, prec1 int) ast.Expr {
+func (p *parser) parseBinaryExpr(prec1 int) ast.Expr {
 	if p.trace {
 		defer un(trace(p, "BinaryExpr"))
 	}
 
-	x := p.parseUnaryExpr(lhs)
+	x := p.parseUnaryExpr()
 	for {
 		op, oprec := p.tokPrec()
 		if oprec < prec1 {
 			return x
 		}
 		pos := p.expect(op)
-		if lhs {
-			p.resolve(x)
-			lhs = false
-		}
-		y := p.parseBinaryExpr(false, oprec+1)
+		y := p.parseBinaryExpr(oprec + 1)
 		x = &ast.BinaryExpr{X: p.checkExpr(x), OpPos: pos, Op: op, Y: p.checkExpr(y)}
 	}
 }
 
-// If lhs is set and the result is an identifier, it is not resolved.
 // The result may be a type or even a raw type ([...]int). Callers must
 // check the result (using checkExpr or checkExprOrType), depending on
 // context.
-func (p *parser) parseExpr(lhs bool) ast.Expr {
+func (p *parser) parseExpr() ast.Expr {
 	if p.trace {
 		defer un(trace(p, "Expression"))
 	}
 
-	return p.parseBinaryExpr(lhs, token.LowestPrec+1)
+	return p.parseBinaryExpr(token.LowestPrec + 1)
 }
 
 func (p *parser) parseRhs() ast.Expr {
 	old := p.inRhs
 	p.inRhs = true
-	x := p.checkExpr(p.parseExpr(false))
+	x := p.checkExpr(p.parseExpr())
 	p.inRhs = old
 	return x
 }
@@ -1940,7 +1694,7 @@ func (p *parser) parseRhs() ast.Expr {
 func (p *parser) parseRhsOrType() ast.Expr {
 	old := p.inRhs
 	p.inRhs = true
-	x := p.checkExprOrType(p.parseExpr(false))
+	x := p.checkExprOrType(p.parseExpr())
 	p.inRhs = old
 	return x
 }
@@ -1964,7 +1718,7 @@ func (p *parser) parseSimpleStmt(mode int) (ast.Stmt, bool) {
 		defer un(trace(p, "SimpleStmt"))
 	}
 
-	x := p.parseLhsList()
+	x := p.parseList(false)
 
 	switch p.tok {
 	case
@@ -1983,11 +1737,11 @@ func (p *parser) parseSimpleStmt(mode int) (ast.Stmt, bool) {
 			y = []ast.Expr{&ast.UnaryExpr{OpPos: pos, Op: token.RANGE, X: p.parseRhs()}}
 			isRange = true
 		} else {
-			y = p.parseRhsList()
+			y = p.parseList(true)
 		}
 		as := &ast.AssignStmt{Lhs: x, TokPos: pos, Tok: tok, Rhs: y}
 		if tok == token.DEFINE {
-			p.shortVarDecl(as)
+			p.checkAssignStmt(as)
 		}
 		return as, isRange
 	}
@@ -2007,7 +1761,6 @@ func (p *parser) parseSimpleStmt(mode int) (ast.Stmt, bool) {
 			// in which it is declared and excludes the body of any nested
 			// function.
 			stmt := &ast.LabeledStmt{Label: label, Colon: colon, Stmt: p.parseStmt()}
-			p.declare(stmt, nil, p.labelScope, ast.Lbl, label)
 			return stmt, false
 		}
 		// The label declaration typically starts at x[0].Pos(), but the label
@@ -2037,6 +1790,14 @@ func (p *parser) parseSimpleStmt(mode int) (ast.Stmt, bool) {
 	return &ast.ExprStmt{X: x[0]}, false
 }
 
+func (p *parser) checkAssignStmt(as *ast.AssignStmt) {
+	for _, x := range as.Lhs {
+		if _, isIdent := x.(*ast.Ident); !isIdent {
+			p.errorExpected(x.Pos(), "identifier on left side of :=")
+		}
+	}
+}
+
 func (p *parser) parseCallExpr(callType string) *ast.CallExpr {
 	x := p.parseRhsOrType() // could be a conversion: (some type)(x)
 	if call, isCall := x.(*ast.CallExpr); isCall {
@@ -2088,7 +1849,7 @@ func (p *parser) parseReturnStmt() *ast.ReturnStmt {
 	p.expect(token.RETURN)
 	var x []ast.Expr
 	if p.tok != token.SEMICOLON && p.tok != token.RBRACE {
-		x = p.parseRhsList()
+		x = p.parseList(true)
 	}
 	p.expectSemi()
 
@@ -2104,9 +1865,6 @@ func (p *parser) parseBranchStmt(tok token.Token) *ast.BranchStmt {
 	var label *ast.Ident
 	if tok != token.FALLTHROUGH && p.tok == token.IDENT {
 		label = p.parseIdent()
-		// add to list of unresolved targets
-		n := len(p.targetStack) - 1
-		p.targetStack[n] = append(p.targetStack[n], label)
 	}
 	p.expectSemi()
 
@@ -2197,8 +1955,6 @@ func (p *parser) parseIfStmt() *ast.IfStmt {
 	}
 
 	pos := p.expect(token.IF)
-	p.openScope()
-	defer p.closeScope()
 
 	init, cond := p.parseIfHeader()
 	body := p.parseBlockStmt()
@@ -2249,16 +2005,14 @@ func (p *parser) parseCaseClause(typeSwitch bool) *ast.CaseClause {
 		if typeSwitch {
 			list = p.parseTypeList()
 		} else {
-			list = p.parseRhsList()
+			list = p.parseList(true)
 		}
 	} else {
 		p.expect(token.DEFAULT)
 	}
 
 	colon := p.expect(token.COLON)
-	p.openScope()
 	body := p.parseStmtList()
-	p.closeScope()
 
 	return &ast.CaseClause{Case: pos, List: list, Colon: colon, Body: body}
 }
@@ -2295,8 +2049,6 @@ func (p *parser) parseSwitchStmt() ast.Stmt {
 	}
 
 	pos := p.expect(token.SWITCH)
-	p.openScope()
-	defer p.closeScope()
 
 	var s1, s2 ast.Stmt
 	if p.tok != token.LBRACE {
@@ -2322,8 +2074,6 @@ func (p *parser) parseSwitchStmt() ast.Stmt {
 				//
 				// If we don't have a type switch, s2 must be an expression.
 				// Having the extra nested but empty scope won't affect it.
-				p.openScope()
-				defer p.closeScope()
 				s2, _ = p.parseSimpleStmt(basic)
 			}
 		}
@@ -2352,12 +2102,11 @@ func (p *parser) parseCommClause() *ast.CommClause {
 		defer un(trace(p, "CommClause"))
 	}
 
-	p.openScope()
 	pos := p.pos
 	var comm ast.Stmt
 	if p.tok == token.CASE {
 		p.next()
-		lhs := p.parseLhsList()
+		lhs := p.parseList(false)
 		if p.tok == token.ARROW {
 			// SendStmt
 			if len(lhs) > 1 {
@@ -2382,7 +2131,7 @@ func (p *parser) parseCommClause() *ast.CommClause {
 				rhs := p.parseRhs()
 				as := &ast.AssignStmt{Lhs: lhs, TokPos: pos, Tok: tok, Rhs: []ast.Expr{rhs}}
 				if tok == token.DEFINE {
-					p.shortVarDecl(as)
+					p.checkAssignStmt(as)
 				}
 				comm = as
 			} else {
@@ -2400,7 +2149,6 @@ func (p *parser) parseCommClause() *ast.CommClause {
 
 	colon := p.expect(token.COLON)
 	body := p.parseStmtList()
-	p.closeScope()
 
 	return &ast.CommClause{Case: pos, Comm: comm, Colon: colon, Body: body}
 }
@@ -2429,8 +2177,6 @@ func (p *parser) parseForStmt() ast.Stmt {
 	}
 
 	pos := p.expect(token.FOR)
-	p.openScope()
-	defer p.closeScope()
 
 	var s1, s2, s3 ast.Stmt
 	var isRange bool
@@ -2627,12 +2373,12 @@ func (p *parser) parseValueSpec(doc *ast.CommentGroup, _ token.Pos, keyword toke
 
 	pos := p.pos
 	idents := p.parseIdentList()
-	typ := p.tryType()
+	typ := p.tryIdentOrType()
 	var values []ast.Expr
 	// always permit optional initialization for more tolerant parsing
 	if p.tok == token.ASSIGN {
 		p.next()
-		values = p.parseRhsList()
+		values = p.parseList(true)
 	}
 	p.expectSemi() // call before accessing p.linecomment
 
@@ -2647,10 +2393,6 @@ func (p *parser) parseValueSpec(doc *ast.CommentGroup, _ token.Pos, keyword toke
 		}
 	}
 
-	// Go spec: The scope of a constant or variable identifier declared inside
-	// a function begins at the end of the ConstSpec or VarSpec and ends at
-	// the end of the innermost containing block.
-	// (Global identifiers are resolved in a separate phase after parsing.)
 	spec := &ast.ValueSpec{
 		Doc:     doc,
 		Names:   idents,
@@ -2658,18 +2400,11 @@ func (p *parser) parseValueSpec(doc *ast.CommentGroup, _ token.Pos, keyword toke
 		Values:  values,
 		Comment: p.lineComment,
 	}
-	kind := ast.Con
-	if keyword == token.VAR {
-		kind = ast.Var
-	}
-	p.declare(spec, iota, p.topScope, kind, idents...)
-
 	return spec
 }
 
 func (p *parser) parseGenericType(spec *ast.TypeSpec, openPos token.Pos, name0 *ast.Ident, closeTok token.Token) {
-	p.openScope()
-	list := p.parseParameterList(p.topScope, name0, closeTok, p.parseParamDecl, true)
+	list := p.parseParameterList(name0, closeTok, p.parseParamDecl, true)
 	closePos := p.expect(closeTok)
 	spec.TParams = &ast.FieldList{Opening: openPos, List: list, Closing: closePos}
 	// Type alias cannot have type parameters. Accept them for robustness but complain.
@@ -2678,7 +2413,6 @@ func (p *parser) parseGenericType(spec *ast.TypeSpec, openPos token.Pos, name0 *
 		p.next()
 	}
 	spec.Type = p.parseType()
-	p.closeScope()
 }
 
 func (p *parser) parseTypeSpec(doc *ast.CommentGroup, _ token.Pos, _ token.Token, _ int) ast.Spec {
@@ -2687,13 +2421,7 @@ func (p *parser) parseTypeSpec(doc *ast.CommentGroup, _ token.Pos, _ token.Token
 	}
 
 	ident := p.parseIdent()
-
-	// Go spec: The scope of a type identifier declared inside a function begins
-	// at the identifier in the TypeSpec and ends at the end of the innermost
-	// containing block.
-	// (Global identifiers are resolved in a separate phase after parsing.)
 	spec := &ast.TypeSpec{Doc: doc, Name: ident}
-	p.declare(spec, nil, p.topScope, ast.Typ, ident)
 
 	switch p.tok {
 	case token.LBRACK:
@@ -2702,7 +2430,7 @@ func (p *parser) parseTypeSpec(doc *ast.CommentGroup, _ token.Pos, _ token.Token
 		if p.tok == token.IDENT {
 			// array type or generic type [T any]
 			p.exprLev++
-			x := p.parseExpr(true) // we don't know yet if we're a lhs or rhs expr
+			x := p.parseExpr()
 			p.exprLev--
 			if name0, _ := x.(*ast.Ident); p.mode&parseTypeParams != 0 && name0 != nil && p.tok != token.RBRACK {
 				// generic type [T any];
@@ -2776,28 +2504,27 @@ func (p *parser) parseFuncDecl() *ast.FuncDecl {
 
 	doc := p.leadComment
 	pos := p.expect(token.FUNC)
-	scope := ast.NewScope(p.topScope) // function scope
 
 	var recv *ast.FieldList
 	if p.tok == token.LPAREN {
-		_, recv = p.parseParameters(scope, false)
+		_, recv = p.parseParameters(false)
 	}
 
 	ident := p.parseIdent()
 
-	tparams, params := p.parseParameters(scope, true)
-	results := p.parseResult(scope)
+	tparams, params := p.parseParameters(true)
+	results := p.parseResult()
 
 	var body *ast.BlockStmt
 	if p.tok == token.LBRACE {
-		body = p.parseBody(scope)
+		body = p.parseBody()
 		p.expectSemi()
 	} else if p.tok == token.SEMICOLON {
 		p.next()
 		if p.tok == token.LBRACE {
 			// opening { of function declaration on next line
 			p.error(p.pos, "unexpected semicolon or newline before {")
-			body = p.parseBody(scope)
+			body = p.parseBody()
 			p.expectSemi()
 		}
 	} else {
@@ -2816,18 +2543,6 @@ func (p *parser) parseFuncDecl() *ast.FuncDecl {
 		},
 		Body: body,
 	}
-	if recv == nil {
-		// Go spec: The scope of an identifier denoting a constant, type,
-		// variable, or function (but not method) declared at top level
-		// (outside any function) is the package block.
-		//
-		// init() functions cannot be referred to and there may
-		// be more than one - don't put them in the pkgScope
-		if ident.Name != "init" {
-			p.declare(decl, nil, p.pkgScope, ast.Fun, ident)
-		}
-	}
-
 	return decl
 }
 
@@ -2888,8 +2603,6 @@ func (p *parser) parseFile() *ast.File {
 		return nil
 	}
 
-	p.openScope()
-	p.pkgScope = p.topScope
 	var decls []ast.Decl
 	if p.mode&PackageClauseOnly == 0 {
 		// import decls
@@ -2904,30 +2617,20 @@ func (p *parser) parseFile() *ast.File {
 			}
 		}
 	}
-	p.closeScope()
-	assert(p.topScope == nil, "unbalanced scopes")
-	assert(p.labelScope == nil, "unbalanced label scopes")
 
-	// resolve global identifiers within the same file
-	i := 0
-	for _, ident := range p.unresolved {
-		// i <= index for current ident
-		assert(ident.Obj == unresolved, "object already resolved")
-		ident.Obj = p.pkgScope.Lookup(ident.Name) // also removes unresolved sentinel
-		if ident.Obj == nil {
-			p.unresolved[i] = ident
-			i++
-		}
+	f := &ast.File{
+		Doc:      doc,
+		Package:  pos,
+		Name:     ident,
+		Decls:    decls,
+		Imports:  p.imports,
+		Comments: p.comments,
 	}
-
-	return &ast.File{
-		Doc:        doc,
-		Package:    pos,
-		Name:       ident,
-		Decls:      decls,
-		Scope:      p.pkgScope,
-		Imports:    p.imports,
-		Unresolved: p.unresolved[0:i],
-		Comments:   p.comments,
+	var declErr func(token.Pos, string)
+	if p.mode&DeclarationErrors != 0 {
+		declErr = p.error
 	}
+	resolveFile(f, p.file, declErr)
+
+	return f
 }
diff --git a/src/go/parser/resolver.go b/src/go/parser/resolver.go
new file mode 100644
index 0000000000..dd77b685e3
--- /dev/null
+++ b/src/go/parser/resolver.go
@@ -0,0 +1,505 @@
+// Copyright 2021 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 parser
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+)
+
+const debugResolve = false
+
+// resolveFile walks the given file to resolve identifiers within the file
+// scope, updating ast.Ident.Obj fields with declaration information.
+//
+// If declErr is non-nil, it is used to report declaration errors during
+// resolution. tok is used to format position in error messages.
+func resolveFile(file *ast.File, handle *token.File, declErr func(token.Pos, string)) {
+	topScope := ast.NewScope(nil)
+	r := &resolver{
+		handle:   handle,
+		declErr:  declErr,
+		topScope: topScope,
+		pkgScope: topScope,
+	}
+
+	for _, decl := range file.Decls {
+		ast.Walk(r, decl)
+	}
+
+	r.closeScope()
+	assert(r.topScope == nil, "unbalanced scopes")
+	assert(r.labelScope == nil, "unbalanced label scopes")
+
+	// resolve global identifiers within the same file
+	i := 0
+	for _, ident := range r.unresolved {
+		// i <= index for current ident
+		assert(ident.Obj == unresolved, "object already resolved")
+		ident.Obj = r.pkgScope.Lookup(ident.Name) // also removes unresolved sentinel
+		if ident.Obj == nil {
+			r.unresolved[i] = ident
+			i++
+		} else if debugResolve {
+			pos := ident.Obj.Decl.(interface{ Pos() token.Pos }).Pos()
+			r.dump("resolved %s@%v to package object %v", ident.Name, ident.Pos(), pos)
+		}
+	}
+	file.Scope = r.pkgScope
+	file.Unresolved = r.unresolved[0:i]
+}
+
+type resolver struct {
+	handle  *token.File
+	declErr func(token.Pos, string)
+
+	// Ordinary identifier scopes
+	pkgScope   *ast.Scope   // pkgScope.Outer == nil
+	topScope   *ast.Scope   // top-most scope; may be pkgScope
+	unresolved []*ast.Ident // unresolved identifiers
+
+	// Label scopes
+	// (maintained by open/close LabelScope)
+	labelScope  *ast.Scope     // label scope for current function
+	targetStack [][]*ast.Ident // stack of unresolved labels
+}
+
+func (r *resolver) dump(format string, args ...interface{}) {
+	fmt.Println(">>> " + r.sprintf(format, args...))
+}
+
+func (r *resolver) sprintf(format string, args ...interface{}) string {
+	for i, arg := range args {
+		switch arg := arg.(type) {
+		case token.Pos:
+			args[i] = r.handle.Position(arg)
+		}
+	}
+	return fmt.Sprintf(format, args...)
+}
+
+func (r *resolver) openScope(pos token.Pos) {
+	if debugResolve {
+		r.dump("opening scope @%v", pos)
+	}
+	r.topScope = ast.NewScope(r.topScope)
+}
+
+func (r *resolver) closeScope() {
+	if debugResolve {
+		r.dump("closing scope")
+	}
+	r.topScope = r.topScope.Outer
+}
+
+func (r *resolver) openLabelScope() {
+	r.labelScope = ast.NewScope(r.labelScope)
+	r.targetStack = append(r.targetStack, nil)
+}
+
+func (r *resolver) closeLabelScope() {
+	// resolve labels
+	n := len(r.targetStack) - 1
+	scope := r.labelScope
+	for _, ident := range r.targetStack[n] {
+		ident.Obj = scope.Lookup(ident.Name)
+		if ident.Obj == nil && r.declErr != nil {
+			r.declErr(ident.Pos(), fmt.Sprintf("label %s undefined", ident.Name))
+		}
+	}
+	// pop label scope
+	r.targetStack = r.targetStack[0:n]
+	r.labelScope = r.labelScope.Outer
+}
+
+func (r *resolver) declare(decl, data interface{}, scope *ast.Scope, kind ast.ObjKind, idents ...*ast.Ident) {
+	for _, ident := range idents {
+		// "type" is used for type lists in interfaces, and is otherwise an invalid
+		// identifier. The 'type' identifier is also artificially duplicated in the
+		// type list, so could cause panics below if we were to proceed.
+		if ident.Name == "type" {
+			continue
+		}
+		assert(ident.Obj == nil, "identifier already declared or resolved")
+		obj := ast.NewObj(kind, ident.Name)
+		// remember the corresponding declaration for redeclaration
+		// errors and global variable resolution/typechecking phase
+		obj.Decl = decl
+		obj.Data = data
+		ident.Obj = obj
+		if ident.Name != "_" {
+			if debugResolve {
+				r.dump("declaring %s@%v", ident.Name, ident.Pos())
+			}
+			if alt := scope.Insert(obj); alt != nil && r.declErr != nil {
+				prevDecl := ""
+				if pos := alt.Pos(); pos.IsValid() {
+					prevDecl = fmt.Sprintf("\n\tprevious declaration at %s", r.handle.Position(pos))
+				}
+				r.declErr(ident.Pos(), fmt.Sprintf("%s redeclared in this block%s", ident.Name, prevDecl))
+			}
+		}
+	}
+}
+
+func (r *resolver) shortVarDecl(decl *ast.AssignStmt) {
+	// Go spec: A short variable declaration may redeclare variables
+	// provided they were originally declared in the same block with
+	// the same type, and at least one of the non-blank variables is new.
+	n := 0 // number of new variables
+	for _, x := range decl.Lhs {
+		if ident, isIdent := x.(*ast.Ident); isIdent {
+			assert(ident.Obj == nil, "identifier already declared or resolved")
+			obj := ast.NewObj(ast.Var, ident.Name)
+			// remember corresponding assignment for other tools
+			obj.Decl = decl
+			ident.Obj = obj
+			if ident.Name != "_" {
+				if debugResolve {
+					r.dump("declaring %s@%v", ident.Name, ident.Pos())
+				}
+				if alt := r.topScope.Insert(obj); alt != nil {
+					ident.Obj = alt // redeclaration
+				} else {
+					n++ // new declaration
+				}
+			}
+		}
+	}
+	if n == 0 && r.declErr != nil {
+		r.declErr(decl.Lhs[0].Pos(), "no new variables on left side of :=")
+	}
+}
+
+// The unresolved object is a sentinel to mark identifiers that have been added
+// to the list of unresolved identifiers. The sentinel is only used for verifying
+// internal consistency.
+var unresolved = new(ast.Object)
+
+// If x is an identifier, resolve attempts to resolve x by looking up
+// the object it denotes. If no object is found and collectUnresolved is
+// set, x is marked as unresolved and collected in the list of unresolved
+// identifiers.
+//
+func (r *resolver) resolve(ident *ast.Ident, collectUnresolved bool) {
+	if ident.Obj != nil {
+		panic(fmt.Sprintf("%s: identifier %s already declared or resolved", r.handle.Position(ident.Pos()), ident.Name))
+	}
+	// '_' and 'type' should never refer to existing declarations: '_' because it
+	// has special handling in the spec, and 'type' because it is a keyword, and
+	// only valid in an interface type list.
+	if ident.Name == "_" || ident.Name == "type" {
+		return
+	}
+	for s := r.topScope; s != nil; s = s.Outer {
+		if obj := s.Lookup(ident.Name); obj != nil {
+			assert(obj.Name != "", "obj with no name")
+			ident.Obj = obj
+			return
+		}
+	}
+	// all local scopes are known, so any unresolved identifier
+	// must be found either in the file scope, package scope
+	// (perhaps in another file), or universe scope --- collect
+	// them so that they can be resolved later
+	if collectUnresolved {
+		ident.Obj = unresolved
+		r.unresolved = append(r.unresolved, ident)
+	}
+}
+
+func (r *resolver) walkExprs(list []ast.Expr) {
+	for _, node := range list {
+		ast.Walk(r, node)
+	}
+}
+
+func (r *resolver) walkLHS(list []ast.Expr) {
+	for _, expr := range list {
+		expr := unparen(expr)
+		if _, ok := expr.(*ast.Ident); !ok && expr != nil {
+			ast.Walk(r, expr)
+		}
+	}
+}
+
+func (r *resolver) walkStmts(list []ast.Stmt) {
+	for _, stmt := range list {
+		ast.Walk(r, stmt)
+	}
+}
+
+func (r *resolver) Visit(node ast.Node) ast.Visitor {
+	if debugResolve && node != nil {
+		r.dump("node %T@%v", node, node.Pos())
+	}
+
+	switch n := node.(type) {
+
+	// Expressions.
+	case *ast.Ident:
+		r.resolve(n, true)
+
+	case *ast.FuncLit:
+		functionScope := ast.NewScope(r.topScope)
+		r.walkFuncType(functionScope, n.Type)
+		r.walkBody(functionScope, n.Body)
+
+	case *ast.SelectorExpr:
+		ast.Walk(r, n.X)
+		// Note: don't try to resolve n.Sel, as we don't support qualified
+		// resolution.
+
+	case *ast.StructType:
+		scope := ast.NewScope(nil)
+		r.walkFieldList(scope, n.Fields, ast.Var)
+
+	case *ast.FuncType:
+		scope := ast.NewScope(r.topScope)
+		r.walkFuncType(scope, n)
+
+	case *ast.CompositeLit:
+		if n.Type != nil {
+			ast.Walk(r, n.Type)
+		}
+		for _, e := range n.Elts {
+			if kv, _ := e.(*ast.KeyValueExpr); kv != nil {
+				// See issue #45160: try to resolve composite lit keys, but don't
+				// collect them as unresolved if resolution failed. This replicates
+				// existing behavior when resolving during parsing.
+				if ident, _ := kv.Key.(*ast.Ident); ident != nil {
+					r.resolve(ident, false)
+				} else {
+					ast.Walk(r, kv.Key)
+				}
+				ast.Walk(r, kv.Value)
+			} else {
+				ast.Walk(r, e)
+			}
+		}
+
+	case *ast.InterfaceType:
+		scope := ast.NewScope(nil)
+		r.walkFieldList(scope, n.Methods, ast.Fun)
+
+	// Statements
+	case *ast.LabeledStmt:
+		r.declare(n, nil, r.labelScope, ast.Lbl, n.Label)
+		ast.Walk(r, n.Stmt)
+
+	case *ast.AssignStmt:
+		r.walkExprs(n.Rhs)
+		if n.Tok == token.DEFINE {
+			r.shortVarDecl(n)
+		} else {
+			r.walkExprs(n.Lhs)
+		}
+
+	case *ast.BranchStmt:
+		// add to list of unresolved targets
+		if n.Tok != token.FALLTHROUGH && n.Label != nil {
+			depth := len(r.targetStack) - 1
+			r.targetStack[depth] = append(r.targetStack[depth], n.Label)
+		}
+
+	case *ast.BlockStmt:
+		r.openScope(n.Pos())
+		defer r.closeScope()
+		r.walkStmts(n.List)
+
+	case *ast.IfStmt:
+		r.openScope(n.Pos())
+		defer r.closeScope()
+		if n.Init != nil {
+			ast.Walk(r, n.Init)
+		}
+		ast.Walk(r, n.Cond)
+		ast.Walk(r, n.Body)
+		if n.Else != nil {
+			ast.Walk(r, n.Else)
+		}
+
+	case *ast.CaseClause:
+		r.walkExprs(n.List)
+		r.openScope(n.Pos())
+		defer r.closeScope()
+		r.walkStmts(n.Body)
+
+	case *ast.SwitchStmt:
+		r.openScope(n.Pos())
+		defer r.closeScope()
+		if n.Init != nil {
+			ast.Walk(r, n.Init)
+		}
+		if n.Tag != nil {
+			// The scope below reproduces some unnecessary behavior of the parser,
+			// opening an extra scope in case this is a type switch. It's not needed
+			// for expression switches.
+			// TODO: remove this once we've matched the parser resolution exactly.
+			if n.Init != nil {
+				r.openScope(n.Tag.Pos())
+				defer r.closeScope()
+			}
+			ast.Walk(r, n.Tag)
+		}
+		if n.Body != nil {
+			r.walkStmts(n.Body.List)
+		}
+
+	case *ast.TypeSwitchStmt:
+		if n.Init != nil {
+			r.openScope(n.Pos())
+			defer r.closeScope()
+			ast.Walk(r, n.Init)
+		}
+		r.openScope(n.Assign.Pos())
+		defer r.closeScope()
+		ast.Walk(r, n.Assign)
+		// s.Body consists only of case clauses, so does not get its own
+		// scope.
+		if n.Body != nil {
+			r.walkStmts(n.Body.List)
+		}
+
+	case *ast.CommClause:
+		r.openScope(n.Pos())
+		defer r.closeScope()
+		if n.Comm != nil {
+			ast.Walk(r, n.Comm)
+		}
+		r.walkStmts(n.Body)
+
+	case *ast.SelectStmt:
+		// as for switch statements, select statement bodies don't get their own
+		// scope.
+		if n.Body != nil {
+			r.walkStmts(n.Body.List)
+		}
+
+	case *ast.ForStmt:
+		r.openScope(n.Pos())
+		defer r.closeScope()
+		if n.Init != nil {
+			ast.Walk(r, n.Init)
+		}
+		if n.Cond != nil {
+			ast.Walk(r, n.Cond)
+		}
+		if n.Post != nil {
+			ast.Walk(r, n.Post)
+		}
+		ast.Walk(r, n.Body)
+
+	case *ast.RangeStmt:
+		r.openScope(n.Pos())
+		defer r.closeScope()
+		ast.Walk(r, n.X)
+		var lhs []ast.Expr
+		if n.Key != nil {
+			lhs = append(lhs, n.Key)
+		}
+		if n.Value != nil {
+			lhs = append(lhs, n.Value)
+		}
+		if len(lhs) > 0 {
+			if n.Tok == token.DEFINE {
+				// Note: we can't exactly match the behavior of object resolution
+				// during the parsing pass here, as it uses the position of the RANGE
+				// token for the RHS OpPos. That information is not contained within
+				// the AST.
+				as := &ast.AssignStmt{
+					Lhs:    lhs,
+					Tok:    token.DEFINE,
+					TokPos: n.TokPos,
+					Rhs:    []ast.Expr{&ast.UnaryExpr{Op: token.RANGE, X: n.X}},
+				}
+				// TODO(rFindley): this walkLHS reproduced the parser resolution, but
+				// is it necessary? By comparison, for a normal AssignStmt we don't
+				// walk the LHS in case there is an invalid identifier list.
+				r.walkLHS(lhs)
+				r.shortVarDecl(as)
+			} else {
+				r.walkExprs(lhs)
+			}
+		}
+		ast.Walk(r, n.Body)
+
+	// Declarations
+	case *ast.GenDecl:
+		switch n.Tok {
+		case token.CONST, token.VAR:
+			for i, spec := range n.Specs {
+				spec := spec.(*ast.ValueSpec)
+				kind := ast.Con
+				if n.Tok == token.VAR {
+					kind = ast.Var
+				}
+				r.walkExprs(spec.Values)
+				if spec.Type != nil {
+					ast.Walk(r, spec.Type)
+				}
+				r.declare(spec, i, r.topScope, kind, spec.Names...)
+			}
+		case token.TYPE:
+			for _, spec := range n.Specs {
+				spec := spec.(*ast.TypeSpec)
+				// Go spec: The scope of a type identifier declared inside a function begins
+				// at the identifier in the TypeSpec and ends at the end of the innermost
+				// containing block.
+				r.declare(spec, nil, r.topScope, ast.Typ, spec.Name)
+				if spec.TParams != nil {
+					r.openScope(spec.Pos())
+					defer r.closeScope()
+					r.walkFieldList(r.topScope, spec.TParams, ast.Typ)
+				}
+				ast.Walk(r, spec.Type)
+			}
+		}
+
+	case *ast.FuncDecl:
+		scope := ast.NewScope(r.topScope)
+		r.walkFieldList(scope, n.Recv, ast.Var)
+		r.walkFuncType(scope, n.Type)
+		r.walkBody(scope, n.Body)
+		if n.Recv == nil && n.Name.Name != "init" {
+			r.declare(n, nil, r.pkgScope, ast.Fun, n.Name)
+		}
+
+	default:
+		return r
+	}
+
+	return nil
+}
+
+func (r *resolver) walkFuncType(scope *ast.Scope, typ *ast.FuncType) {
+	r.walkFieldList(scope, typ.TParams, ast.Typ)
+	r.walkFieldList(scope, typ.Params, ast.Var)
+	r.walkFieldList(scope, typ.Results, ast.Var)
+}
+
+func (r *resolver) walkFieldList(scope *ast.Scope, list *ast.FieldList, kind ast.ObjKind) {
+	if list == nil {
+		return
+	}
+	for _, f := range list.List {
+		if f.Type != nil {
+			ast.Walk(r, f.Type)
+		}
+		r.declare(f, nil, scope, kind, f.Names...)
+	}
+}
+
+func (r *resolver) walkBody(scope *ast.Scope, body *ast.BlockStmt) {
+	if body == nil {
+		return
+	}
+	r.topScope = scope // open function scope
+	defer r.closeScope()
+	r.openLabelScope()
+	defer r.closeLabelScope()
+	r.walkStmts(body.List)
+}
-- 
GitLab


From 5d6581d74796ac748441c94e84eefdaf338d266c Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Wed, 31 Mar 2021 12:41:20 -0400
Subject: [PATCH 1314/2400] cmd/compile: deduplicate OpArg's across types

For in-register arguments, it must have only a single copy of it
present in the function. If there are multiple copies, it confuses
the register allocator, as they are in the same register.

Change-Id: I55cb06746f08aa7c9168026d0f411bce0a9f93f4
Reviewed-on: https://go-review.googlesource.com/c/go/+/306330
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/ssa/expand_calls.go | 37 ++++++++++++++-
 test/abi/defer_aggregate.go                  | 48 ++++++++++++++++++++
 2 files changed, 84 insertions(+), 1 deletion(-)
 create mode 100644 test/abi/defer_aggregate.go

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index b6aba0ed16..2935236473 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -1359,7 +1359,42 @@ func expandCalls(f *Func) {
 		}
 	}
 
-	// Step 5: elide any copies introduced.
+	// Step 5: dedup OpArgXXXReg values. Mostly it is already dedup'd by commonArgs,
+	// but there are cases that we have same OpArgXXXReg values with different types.
+	// E.g. string is sometimes decomposed as { *int8, int }, sometimes as { unsafe.Pointer, uintptr }.
+	// (Can we avoid that?)
+	var IArg, FArg [32]*Value
+	for _, v := range f.Entry.Values {
+		switch v.Op {
+		case OpArgIntReg:
+			i := v.AuxInt
+			if w := IArg[i]; w != nil {
+				if w.Type.Width != v.Type.Width {
+					f.Fatalf("incompatible OpArgIntReg [%d]: %v and %v", i, v, w)
+				}
+				if w.Type.IsUnsafePtr() && !v.Type.IsUnsafePtr() {
+					// Update unsafe.Pointer type if we know the actual pointer type.
+					w.Type = v.Type
+				}
+				// TODO: don't dedup pointer and scalar? Rewrite to OpConvert? Can it happen?
+				v.copyOf(w)
+			} else {
+				IArg[i] = v
+			}
+		case OpArgFloatReg:
+			i := v.AuxInt
+			if w := FArg[i]; w != nil {
+				if w.Type.Width != v.Type.Width {
+					f.Fatalf("incompatible OpArgFloatReg [%d]: %v and %v", i, v, w)
+				}
+				v.copyOf(w)
+			} else {
+				FArg[i] = v
+			}
+		}
+	}
+
+	// Step 6: elide any copies introduced.
 	for _, b := range f.Blocks {
 		for _, v := range b.Values {
 			for i, a := range v.Args {
diff --git a/test/abi/defer_aggregate.go b/test/abi/defer_aggregate.go
new file mode 100644
index 0000000000..6dd82828c1
--- /dev/null
+++ b/test/abi/defer_aggregate.go
@@ -0,0 +1,48 @@
+// run
+
+// Copyright 2021 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
+
+const p0exp = "foo"
+const p1exp = 10101
+const p2exp = 3030303
+const p3exp = 505050505
+const p4exp = 70707070707
+
+//go:noinline
+//go:registerparams
+func callee(p0 string, p1 uint64, p2 uint64, p3 uint64, p4 uint64) {
+	if p0 != p0exp {
+		panic("bad p0")
+	}
+	if p1 != p1exp {
+		panic("bad p1")
+	}
+	if p2 != p2exp {
+		panic("bad p2")
+	}
+	if p3 != p3exp {
+		panic("bad p3")
+	}
+	if p4 != p4exp {
+		panic("bad p4")
+	}
+	defer func(p0 string, p2 uint64) {
+		if p0 != p0exp {
+			panic("defer bad p0")
+		}
+		if p1 != p1exp {
+			panic("defer bad p1")
+		}
+		if p2 != p2exp {
+			panic("defer bad p2")
+		}
+	}(p0, p2)
+}
+
+func main() {
+	callee(p0exp, p1exp, p2exp, p3exp, p4exp)
+}
-- 
GitLab


From 87c6fa4f473f178f7d931ddadd10c76444f8dc7b Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Fri, 19 Mar 2021 20:04:38 +0000
Subject: [PATCH 1315/2400] cmd/internal/obj/x86: use ABI scratch registers for
 WRAPPER prologue

Currently the prologue generated for WRAPPER assembly functions uses BX
and DI, but these are argument registers in the register-based calling
convention. Thus, these end up being clobbered when we want to have an
ABIInternal assembly function.

Define REGENTRYTMP0 and REGENTRYTMP1, aliases for the dedicated function
entry scratch registers R12 and R13, and use those instead.

For #40724.

Change-Id: Ica78c4ccc67a757359900a66b56ef28c83d88b3e
Reviewed-on: https://go-review.googlesource.com/c/go/+/303314
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Austin Clements <austin@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/internal/obj/x86/a.out.go | 36 +++++++++++++++-------------
 src/cmd/internal/obj/x86/obj6.go  | 40 ++++++++++++++++++-------------
 2 files changed, 42 insertions(+), 34 deletions(-)

diff --git a/src/cmd/internal/obj/x86/a.out.go b/src/cmd/internal/obj/x86/a.out.go
index 3be4b59da4..b121f6df7b 100644
--- a/src/cmd/internal/obj/x86/a.out.go
+++ b/src/cmd/internal/obj/x86/a.out.go
@@ -258,23 +258,25 @@ const (
 	REG_DR = REG_DR0
 	REG_TR = REG_TR0
 
-	REGARG   = -1
-	REGRET   = REG_AX
-	FREGRET  = REG_X0
-	REGSP    = REG_SP
-	REGCTXT  = REG_DX
-	REGG     = REG_R14     // g register in ABIInternal
-	REGEXT   = REG_R15     // compiler allocates external registers R15 down
-	FREGMIN  = REG_X0 + 5  // first register variable
-	FREGEXT  = REG_X0 + 15 // first external register
-	T_TYPE   = 1 << 0
-	T_INDEX  = 1 << 1
-	T_OFFSET = 1 << 2
-	T_FCONST = 1 << 3
-	T_SYM    = 1 << 4
-	T_SCONST = 1 << 5
-	T_64     = 1 << 6
-	T_GOTYPE = 1 << 7
+	REGARG       = -1
+	REGRET       = REG_AX
+	FREGRET      = REG_X0
+	REGSP        = REG_SP
+	REGCTXT      = REG_DX
+	REGENTRYTMP0 = REG_R12     // scratch register available at function entry in ABIInternal
+	REGENTRYTMP1 = REG_R13     // scratch register available at function entry in ABIInternal
+	REGG         = REG_R14     // g register in ABIInternal
+	REGEXT       = REG_R15     // compiler allocates external registers R15 down
+	FREGMIN      = REG_X0 + 5  // first register variable
+	FREGEXT      = REG_X0 + 15 // first external register
+	T_TYPE       = 1 << 0
+	T_INDEX      = 1 << 1
+	T_OFFSET     = 1 << 2
+	T_FCONST     = 1 << 3
+	T_SYM        = 1 << 4
+	T_SCONST     = 1 << 5
+	T_64         = 1 << 6
+	T_GOTYPE     = 1 << 7
 )
 
 // https://www.uclibc.org/docs/psABI-x86_64.pdf, figure 3.36
diff --git a/src/cmd/internal/obj/x86/obj6.go b/src/cmd/internal/obj/x86/obj6.go
index 2fbeaad572..a314583e49 100644
--- a/src/cmd/internal/obj/x86/obj6.go
+++ b/src/cmd/internal/obj/x86/obj6.go
@@ -658,6 +658,12 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 			p = load_g(ctxt, p, newprog, regg) // load g into regg
 		}
 	}
+	var regEntryTmp0, regEntryTmp1 int16
+	if ctxt.Arch.Family == sys.AMD64 {
+		regEntryTmp0, regEntryTmp1 = REGENTRYTMP0, REGENTRYTMP1
+	} else {
+		regEntryTmp0, regEntryTmp1 = REG_BX, REG_DI
+	}
 
 	if !cursym.Func().Text.From.Sym.NoSplit() {
 		p = stacksplit(ctxt, cursym, p, newprog, autoffset, int32(textarg), regg) // emit split check
@@ -712,17 +718,17 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 		//   g._panic.argp = bottom-of-frame
 		// }
 		//
-		//	MOVQ g_panic(g), BX
-		//	TESTQ BX, BX
+		//	MOVQ g_panic(g), regEntryTmp0
+		//	TESTQ regEntryTmp0, regEntryTmp0
 		//	JNE checkargp
 		// end:
 		//	NOP
 		//  ... rest of function ...
 		// checkargp:
-		//	LEAQ (autoffset+8)(SP), DI
-		//	CMPQ panic_argp(BX), DI
+		//	LEAQ (autoffset+8)(SP), regEntryTmp1
+		//	CMPQ panic_argp(regEntryTmp0), regEntryTmp1
 		//	JNE end
-		//  MOVQ SP, panic_argp(BX)
+		//  MOVQ SP, panic_argp(regEntryTmp0)
 		//  JMP end
 		//
 		// The NOP is needed to give the jumps somewhere to land.
@@ -731,25 +737,25 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 		// The layout is chosen to help static branch prediction:
 		// Both conditional jumps are unlikely, so they are arranged to be forward jumps.
 
-		// MOVQ g_panic(CX), BX
+		// MOVQ g_panic(g), regEntryTmp0
 		p = obj.Appendp(p, newprog)
 		p.As = AMOVQ
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = regg
 		p.From.Offset = 4 * int64(ctxt.Arch.PtrSize) // g_panic
 		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_BX
+		p.To.Reg = regEntryTmp0
 		if ctxt.Arch.Family == sys.I386 {
 			p.As = AMOVL
 		}
 
-		// TESTQ BX, BX
+		// TESTQ regEntryTmp0, regEntryTmp0
 		p = obj.Appendp(p, newprog)
 		p.As = ATESTQ
 		p.From.Type = obj.TYPE_REG
-		p.From.Reg = REG_BX
+		p.From.Reg = regEntryTmp0
 		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_BX
+		p.To.Reg = regEntryTmp0
 		if ctxt.Arch.Family == sys.I386 {
 			p.As = ATESTL
 		}
@@ -769,14 +775,14 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 		for last = end; last.Link != nil; last = last.Link {
 		}
 
-		// LEAQ (autoffset+8)(SP), DI
+		// LEAQ (autoffset+8)(SP), regEntryTmp1
 		p = obj.Appendp(last, newprog)
 		p.As = ALEAQ
 		p.From.Type = obj.TYPE_MEM
 		p.From.Reg = REG_SP
 		p.From.Offset = int64(autoffset) + int64(ctxt.Arch.RegSize)
 		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_DI
+		p.To.Reg = regEntryTmp1
 		if ctxt.Arch.Family == sys.I386 {
 			p.As = ALEAL
 		}
@@ -784,14 +790,14 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 		// Set jne branch target.
 		jne.To.SetTarget(p)
 
-		// CMPQ panic_argp(BX), DI
+		// CMPQ panic_argp(regEntryTmp0), regEntryTmp1
 		p = obj.Appendp(p, newprog)
 		p.As = ACMPQ
 		p.From.Type = obj.TYPE_MEM
-		p.From.Reg = REG_BX
+		p.From.Reg = regEntryTmp0
 		p.From.Offset = 0 // Panic.argp
 		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_DI
+		p.To.Reg = regEntryTmp1
 		if ctxt.Arch.Family == sys.I386 {
 			p.As = ACMPL
 		}
@@ -802,13 +808,13 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 		p.To.Type = obj.TYPE_BRANCH
 		p.To.SetTarget(end)
 
-		// MOVQ SP, panic_argp(BX)
+		// MOVQ SP, panic_argp(regEntryTmp0)
 		p = obj.Appendp(p, newprog)
 		p.As = AMOVQ
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = REG_SP
 		p.To.Type = obj.TYPE_MEM
-		p.To.Reg = REG_BX
+		p.To.Reg = regEntryTmp0
 		p.To.Offset = 0 // Panic.argp
 		if ctxt.Arch.Family == sys.I386 {
 			p.As = AMOVL
-- 
GitLab


From 3304b2235af0a88ba0bb21edaf2c60df47b6e0a8 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Wed, 31 Mar 2021 16:40:52 -0400
Subject: [PATCH 1316/2400] cmd/compile: fix incoming ABI with
 GOEXPERIMENT=regabiargs

When regabiargs is enabled, a function's incoming ABI should be
determined solely by the function's own definition ABI (which is
usually ABIInternal, but can be ABI0 for ABI wrappers).

For example, the current code miscompiles ABI0 -> ABIInternal wrappers
when the experiment is enabled because it treats the wrapper itself as
being called as ABIInternal. This causes it to assume the incoming
arguments are already in registers, so usually the wrapper doesn't do
anything with the arguments because it thinks they're already in the
right place. With this fix, these wrappers now correctly load the
arguments from the stack and put them in registers.

For #40724.

Change-Id: Iec784e88ebc55d9e95e830ed7533aa336f3b1ca2
Reviewed-on: https://go-review.googlesource.com/c/go/+/306409
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssagen/ssa.go | 25 +++++++++++++++++--------
 1 file changed, 17 insertions(+), 8 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 57099371e6..aaea732057 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -225,13 +225,26 @@ const magicNameDotSuffix = ".MagicMethodNameForTestingRegisterABI"
 const magicLastTypeName = "MagicLastTypeNameForTestingRegisterABI"
 
 // abiForFunc implements ABI policy for a function, but does not return a copy of the ABI.
-// Passing a nil function returns ABIInternal.
+// Passing a nil function returns the default ABI based on experiment configuration.
 func abiForFunc(fn *ir.Func, abi0, abi1 *abi.ABIConfig) *abi.ABIConfig {
-	a := abi1
-	if !regabiEnabledForAllCompilation() {
-		a = abi0
+	if objabi.Experiment.RegabiArgs {
+		// Select the ABI based on the function's defining ABI.
+		if fn == nil {
+			return abi1
+		}
+		switch fn.ABI {
+		case obj.ABI0:
+			return abi0
+		case obj.ABIInternal:
+			// TODO(austin): Clean up the nomenclature here.
+			// It's not clear that "abi1" is ABIInternal.
+			return abi1
+		}
+		base.Fatalf("function %v has unknown ABI %v", fn, fn.ABI)
+		panic("not reachable")
 	}
 
+	a := abi0
 	if fn != nil {
 		name := ir.FuncName(fn)
 		magicName := strings.HasSuffix(name, magicNameDotSuffix)
@@ -263,10 +276,6 @@ func regAbiForFuncType(ft *types.Func) bool {
 	return np > 0 && strings.Contains(ft.Params.FieldType(np-1).String(), magicLastTypeName)
 }
 
-func regabiEnabledForAllCompilation() bool {
-	return objabi.Experiment.RegabiArgs
-}
-
 // getParam returns the Field of ith param of node n (which is a
 // function/method/interface call), where the receiver of a method call is
 // considered as the 0th parameter. This does not include the receiver of an
-- 
GitLab


From 1f29e69bad3673aa4f9d1c4d1016170b9ced634a Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Wed, 31 Mar 2021 17:41:07 -0400
Subject: [PATCH 1317/2400] cmd/compile: fix outgoing calls with
 GOEXPERIMENT=regabiargs

The logic for constructing calls in (*state).call is based around
targeted experiments with register-based calls. However, when the
register ABI is turned on everywhere, it currently doesn't account for
direct calls to non-ABIInternal functions. This CL adds a much simpler
path to (*state).call when regabiargs is turned on that looks at the
ABI of the target function.

For #40724.

Change-Id: I7f4f5fed8a5ec131bcf1ce5b9d94d45672a304cb
Reviewed-on: https://go-review.googlesource.com/c/go/+/306410
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssagen/ssa.go | 69 +++++++++++++++-----------
 1 file changed, 41 insertions(+), 28 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index aaea732057..9c1c493233 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -4851,24 +4851,27 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 	var codeptr *ssa.Value // ptr to target code (if dynamic)
 	var rcvr *ssa.Value    // receiver to set
 	fn := n.X
-	var ACArgs []*types.Type       // AuxCall args
-	var ACResults []*types.Type    // AuxCall results
-	var callArgs []*ssa.Value      // For late-expansion, the args themselves (not stored, args to the call instead).
-	inRegistersForTesting := false // If a call uses register ABI for one of the testing reasons, pragma, magic types, magic names
+	var ACArgs []*types.Type    // AuxCall args
+	var ACResults []*types.Type // AuxCall results
+	var callArgs []*ssa.Value   // For late-expansion, the args themselves (not stored, args to the call instead).
 
-	var magicFnNameSym *types.Sym
-	if fn.Name() != nil {
-		magicFnNameSym = fn.Name().Sym()
-		ss := magicFnNameSym.Name
-		if strings.HasSuffix(ss, magicNameDotSuffix) {
-			inRegistersForTesting = true
+	callABI := s.f.ABIDefault
+
+	if !objabi.Experiment.RegabiArgs {
+		var magicFnNameSym *types.Sym
+		if fn.Name() != nil {
+			magicFnNameSym = fn.Name().Sym()
+			ss := magicFnNameSym.Name
+			if strings.HasSuffix(ss, magicNameDotSuffix) {
+				callABI = s.f.ABI1
+			}
 		}
-	}
-	if magicFnNameSym == nil && n.Op() == ir.OCALLINTER {
-		magicFnNameSym = fn.(*ir.SelectorExpr).Sym()
-		ss := magicFnNameSym.Name
-		if strings.HasSuffix(ss, magicNameDotSuffix[1:]) {
-			inRegistersForTesting = true
+		if magicFnNameSym == nil && n.Op() == ir.OCALLINTER {
+			magicFnNameSym = fn.(*ir.SelectorExpr).Sym()
+			ss := magicFnNameSym.Name
+			if strings.HasSuffix(ss, magicNameDotSuffix[1:]) {
+				callABI = s.f.ABI1
+			}
 		}
 	}
 
@@ -4881,10 +4884,23 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		if k == callNormal && fn.Op() == ir.ONAME && fn.(*ir.Name).Class == ir.PFUNC {
 			fn := fn.(*ir.Name)
 			callee = fn
-			// TODO(register args) remove after register abi is working
-			inRegistersImported := fn.Pragma()&ir.RegisterParams != 0
-			inRegistersSamePackage := fn.Func != nil && fn.Func.Pragma&ir.RegisterParams != 0
-			inRegistersForTesting = inRegistersForTesting || inRegistersImported || inRegistersSamePackage
+			if objabi.Experiment.RegabiArgs {
+				// This is a static call, so it may be
+				// a direct call to a non-ABIInternal
+				// function. fn.Func may be nil for
+				// some compiler-generated functions,
+				// but those are all ABIInternal.
+				if fn.Func != nil {
+					callABI = abiForFunc(fn.Func, s.f.ABI0, s.f.ABI1)
+				}
+			} else {
+				// TODO(register args) remove after register abi is working
+				inRegistersImported := fn.Pragma()&ir.RegisterParams != 0
+				inRegistersSamePackage := fn.Func != nil && fn.Func.Pragma&ir.RegisterParams != 0
+				if inRegistersImported || inRegistersSamePackage {
+					callABI = s.f.ABI1
+				}
+			}
 			break
 		}
 		closure = s.expr(fn)
@@ -4909,14 +4925,11 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		}
 	}
 
-	if regAbiForFuncType(n.X.Type().FuncType()) {
-		// Magic last type in input args to call
-		inRegistersForTesting = true
-	}
-
-	callABI := s.f.ABIDefault
-	if inRegistersForTesting {
-		callABI = s.f.ABI1
+	if !objabi.Experiment.RegabiArgs {
+		if regAbiForFuncType(n.X.Type().FuncType()) {
+			// Magic last type in input args to call
+			callABI = s.f.ABI1
+		}
 	}
 
 	params := callABI.ABIAnalyze(n.X.Type(), false /* Do not set (register) nNames from caller side -- can cause races. */)
-- 
GitLab


From ec721d92bf35cd47543acf6792acd474fdd39446 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Mon, 29 Mar 2021 17:38:20 -0400
Subject: [PATCH 1318/2400] runtime: fix uses of ABIInternal PCs in assembly

The covers three kinds of uses:

1. Calls of closures from assembly. These are always ABIInternal calls
without wrappers. I went through every indirect call in the runtime
and I think mcall is the only case of assembly calling a Go closure in
a way that's affected by ABIInternal. systemstack also calls a
closure, but it takes no arguments.

2. Calls of Go functions that expect raw ABIInternal pointers. I also
only found one of these: callbackasm1 -> cgocallback on Windows. These
are trickier to find, though.

3. Finally, I found one case on NetBSD where new OS threads were
directly calling the Go runtime entry-point from assembly via a PC,
rather than going through a wrapper. This meant new threads may not
have special registers set up. In this case, a change on all other
OSes had already forced new thread entry to go through an ABI wrapper,
so I just caught NetBSD up with that change.

With this change, I'm able to run a "hello world" with
GOEXPERIMENT=regabi,regabiargs.

For #40724.

Change-Id: I2a6d0e530c4fd4edf13484d923891c6160d683aa
Reviewed-on: https://go-review.googlesource.com/c/go/+/305669
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/internal/objabi/util.go | 10 +++++++---
 src/runtime/asm_amd64.s         | 29 +++++++++++++++++++++++++++++
 src/runtime/cgocall.go          |  2 +-
 src/runtime/os_netbsd.go        | 10 +++++++---
 src/runtime/proc.go             |  2 +-
 src/runtime/sys_linux_amd64.s   |  2 +-
 src/runtime/sys_netbsd_386.s    |  4 ++++
 src/runtime/sys_netbsd_amd64.s  |  6 +++++-
 src/runtime/sys_netbsd_arm.s    |  4 ++++
 src/runtime/sys_netbsd_arm64.s  |  4 ++++
 src/runtime/sys_windows_amd64.s |  2 +-
 11 files changed, 64 insertions(+), 11 deletions(-)

diff --git a/src/cmd/internal/objabi/util.go b/src/cmd/internal/objabi/util.go
index e066311cd1..ae03aac31a 100644
--- a/src/cmd/internal/objabi/util.go
+++ b/src/cmd/internal/objabi/util.go
@@ -166,8 +166,8 @@ func init() {
 	if Experiment.RegabiG && !Experiment.RegabiWrappers {
 		panic("GOEXPERIMENT regabig requires regabiwrappers")
 	}
-	if Experiment.RegabiArgs && !(Experiment.RegabiWrappers && Experiment.RegabiReflect && Experiment.RegabiDefer) {
-		panic("GOEXPERIMENT regabiargs requires regabiwrappers,regabireflect,regabidefer")
+	if Experiment.RegabiArgs && !(Experiment.RegabiWrappers && Experiment.RegabiG && Experiment.RegabiReflect && Experiment.RegabiDefer) {
+		panic("GOEXPERIMENT regabiargs requires regabiwrappers,regabig,regabireflect,regabidefer")
 	}
 
 	// Set GOEXPERIMENT to the parsed and canonicalized set of experiments.
@@ -242,7 +242,11 @@ type ExpFlags struct {
 	// RegabiArgs enables register arguments/results in all
 	// compiled Go functions.
 	//
-	// Requires wrappers, reflect, defer.
+	// Requires wrappers (to do ABI translation), g (because
+	// runtime assembly that's been ported to ABIInternal uses the
+	// G register), reflect (so reflection calls use registers),
+	// and defer (because the runtime doesn't support passing
+	// register arguments to defer/go).
 	RegabiArgs bool
 }
 
diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index b9efad0681..193d8f00bb 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -285,6 +285,34 @@ TEXT gogo<>(SB), NOSPLIT, $0
 // Switch to m->g0's stack, call fn(g).
 // Fn must never return. It should gogo(&g->sched)
 // to keep running g.
+#ifdef GOEXPERIMENT_REGABI_ARGS
+TEXT runtime·mcall<ABIInternal>(SB), NOSPLIT, $0-8
+	MOVQ	AX, DX	// DX = fn
+
+	// save state in g->sched
+	MOVQ	0(SP), BX	// caller's PC
+	MOVQ	BX, (g_sched+gobuf_pc)(R14)
+	LEAQ	fn+0(FP), BX	// caller's SP
+	MOVQ	BX, (g_sched+gobuf_sp)(R14)
+	MOVQ	BP, (g_sched+gobuf_bp)(R14)
+
+	// switch to m->g0 & its stack, call fn
+	MOVQ	g_m(R14), BX
+	MOVQ	m_g0(BX), SI	// SI = g.m.g0
+	CMPQ	SI, R14	// if g == m->g0 call badmcall
+	JNE	goodm
+	JMP	runtime·badmcall(SB)
+goodm:
+	MOVQ	R14, AX		// AX (and arg 0) = g
+	MOVQ	SI, R14		// g = g.m.g0
+	get_tls(CX)		// Set G in TLS
+	MOVQ	R14, g(CX)
+	MOVQ	(g_sched+gobuf_sp)(R14), SP	// sp = g0.sched.sp
+	MOVQ	0(DX), R12
+	CALL	R12		// fn(g)
+	JMP	runtime·badmcall2(SB)
+	RET
+#else
 TEXT runtime·mcall(SB), NOSPLIT, $0-8
 	MOVQ	fn+0(FP), DI
 
@@ -315,6 +343,7 @@ TEXT runtime·mcall(SB), NOSPLIT, $0-8
 	MOVQ	$runtime·badmcall2(SB), AX
 	JMP	AX
 	RET
+#endif
 
 // systemstack_switch is a dummy routine that systemstack leaves at the bottom
 // of the G stack. We need to distinguish the routine that
diff --git a/src/runtime/cgocall.go b/src/runtime/cgocall.go
index 534a2c4295..0e287d0b8e 100644
--- a/src/runtime/cgocall.go
+++ b/src/runtime/cgocall.go
@@ -195,7 +195,7 @@ func cgocall(fn, arg unsafe.Pointer) int32 {
 	return errno
 }
 
-// Call from C back to Go.
+// Call from C back to Go. fn must point to an ABIInternal Go entry-point.
 //go:nosplit
 func cgocallbackg(fn, frame unsafe.Pointer, ctxt uintptr) {
 	gp := getg()
diff --git a/src/runtime/os_netbsd.go b/src/runtime/os_netbsd.go
index 0328fa57ae..6fbb3aa694 100644
--- a/src/runtime/os_netbsd.go
+++ b/src/runtime/os_netbsd.go
@@ -228,7 +228,11 @@ func newosproc(mp *m) {
 	}
 }
 
-// netbsdMStart is the function call that starts executing a newly
+// mstart is the entry-point for new Ms.
+// It is written in assembly, uses ABI0, is marked TOPFRAME, and calls netbsdMstart0.
+func netbsdMstart()
+
+// netbsdMStart0 is the function call that starts executing a newly
 // created thread. On NetBSD, a new thread inherits the signal stack
 // of the creating thread. That confuses minit, so we remove that
 // signal stack here before calling the regular mstart. It's a bit
@@ -236,10 +240,10 @@ func newosproc(mp *m) {
 // it's a simple change that keeps NetBSD working like other OS's.
 // At this point all signals are blocked, so there is no race.
 //go:nosplit
-func netbsdMstart() {
+func netbsdMstart0() {
 	st := stackt{ss_flags: _SS_DISABLE}
 	sigaltstack(&st, nil)
-	mstart()
+	mstart0()
 }
 
 func osinit() {
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 2a7a766b25..a256b6e04a 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -1258,7 +1258,7 @@ func mStackIsSystemAllocated() bool {
 }
 
 // mstart is the entry-point for new Ms.
-// It is written in assembly, marked TOPFRAME, and calls mstart0.
+// It is written in assembly, uses ABI0, is marked TOPFRAME, and calls mstart0.
 func mstart()
 
 // mstart0 is the Go entry-point for new Ms.
diff --git a/src/runtime/sys_linux_amd64.s b/src/runtime/sys_linux_amd64.s
index 584f2c5b1e..7b538c3e2f 100644
--- a/src/runtime/sys_linux_amd64.s
+++ b/src/runtime/sys_linux_amd64.s
@@ -652,7 +652,7 @@ nog1:
 	CALL	runtime·stackcheck(SB)
 
 nog2:
-	// Call fn
+	// Call fn. This is the PC of an ABI0 function.
 	CALL	R12
 
 	// It shouldn't return. If it does, exit that thread.
diff --git a/src/runtime/sys_netbsd_386.s b/src/runtime/sys_netbsd_386.s
index d0c470c457..d3f22454a4 100644
--- a/src/runtime/sys_netbsd_386.s
+++ b/src/runtime/sys_netbsd_386.s
@@ -376,6 +376,10 @@ TEXT runtime·lwp_tramp(SB),NOSPLIT,$0
 	MOVL	$0x1234, 0x1005
 	RET
 
+TEXT ·netbsdMstart(SB),NOSPLIT|TOPFRAME,$0
+	CALL	·netbsdMstart0(SB)
+	RET // not reached
+
 TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
 	MOVL	$SYS___sigaltstack14, AX
 	MOVL	new+0(FP), BX
diff --git a/src/runtime/sys_netbsd_amd64.s b/src/runtime/sys_netbsd_amd64.s
index dc9bd127d2..addd98cd27 100644
--- a/src/runtime/sys_netbsd_amd64.s
+++ b/src/runtime/sys_netbsd_amd64.s
@@ -70,7 +70,7 @@ TEXT runtime·lwp_tramp(SB),NOSPLIT,$0
 	MOVQ	R9, g(CX)
 	CALL	runtime·stackcheck(SB)
 
-	// Call fn
+	// Call fn. This is an ABI0 PC.
 	CALL	R12
 
 	// It shouldn't return. If it does, exit.
@@ -78,6 +78,10 @@ TEXT runtime·lwp_tramp(SB),NOSPLIT,$0
 	SYSCALL
 	JMP	-3(PC)			// keep exiting
 
+TEXT ·netbsdMstart(SB),NOSPLIT|TOPFRAME,$0
+	CALL	·netbsdMstart0(SB)
+	RET // not reached
+
 TEXT runtime·osyield(SB),NOSPLIT,$0
 	MOVL	$SYS_sched_yield, AX
 	SYSCALL
diff --git a/src/runtime/sys_netbsd_arm.s b/src/runtime/sys_netbsd_arm.s
index 678dea57c6..82f9d2161e 100644
--- a/src/runtime/sys_netbsd_arm.s
+++ b/src/runtime/sys_netbsd_arm.s
@@ -177,6 +177,10 @@ TEXT runtime·lwp_tramp(SB),NOSPLIT,$0
 	MOVW R8, (R8)
 	RET
 
+TEXT ·netbsdMstart(SB),NOSPLIT|TOPFRAME,$0
+	BL ·netbsdMstart0(SB)
+	RET // not reached
+
 TEXT runtime·usleep(SB),NOSPLIT,$16
 	MOVW usec+0(FP), R0
 	CALL runtime·usplitR0(SB)
diff --git a/src/runtime/sys_netbsd_arm64.s b/src/runtime/sys_netbsd_arm64.s
index 4d9b05478f..1446a27f4c 100644
--- a/src/runtime/sys_netbsd_arm64.s
+++ b/src/runtime/sys_netbsd_arm64.s
@@ -76,6 +76,10 @@ nog:
 	MOVD	$0, R0  // crash (not reached)
 	MOVD	R0, (R8)
 
+TEXT ·netbsdMstart(SB),NOSPLIT|TOPFRAME,$0
+	CALL	·netbsdMstart0(SB)
+	RET // not reached
+
 TEXT runtime·osyield(SB),NOSPLIT,$0
 	SVC	$SYS_sched_yield
 	RET
diff --git a/src/runtime/sys_windows_amd64.s b/src/runtime/sys_windows_amd64.s
index 8a91741619..099894efe7 100644
--- a/src/runtime/sys_windows_amd64.s
+++ b/src/runtime/sys_windows_amd64.s
@@ -320,7 +320,7 @@ TEXT runtime·callbackasm1(SB),NOSPLIT,$0
 	// Call cgocallback, which will call callbackWrap(frame).
 	MOVQ	$0, 16(SP)	// context
 	MOVQ	AX, 8(SP)	// frame (address of callbackArgs)
-	LEAQ	·callbackWrap(SB), BX
+	LEAQ	·callbackWrap<ABIInternal>(SB), BX	// cgocallback takes an ABIInternal entry-point
 	MOVQ	BX, 0(SP)	// PC of function value to call (callbackWrap)
 	CALL	·cgocallback(SB)
 	// Get callback result.
-- 
GitLab


From 5f646f0a984d43a2e9e99a1338145a862fef425e Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Wed, 31 Mar 2021 20:02:26 -0400
Subject: [PATCH 1319/2400] cmd/compile: fix parameter offset calculation

For struct like { { a int64; b int16 }; c int32 }, on 64-bit
machines the offset of c is 16, as the inner struct takes 16
bytes because we round up type size to its alignment. Update the
abi package's offset calculation to include this.

We only need to do this for struct type, because for all other
types its size is naturally aligned.

TODO: add a test.

Change-Id: I0c661768cb1ed3cb409b20a88b7e23e059f8e3e1
Reviewed-on: https://go-review.googlesource.com/c/go/+/306449
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/abi/abiutils.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index feda2153f7..56e008830f 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -214,6 +214,7 @@ func appendParamOffsets(offsets []int64, at int64, t *types.Type) ([]int64, int6
 			for _, f := range t.FieldSlice() {
 				offsets, at = appendParamOffsets(offsets, at, f.Type)
 			}
+			at = align(at, t) // type size is rounded up to its alignment
 		case types.TSLICE:
 			return appendParamOffsets(offsets, at, synthSlice)
 		case types.TSTRING:
-- 
GitLab


From e6ac2df2b198f583780277a7cf96e3b0b61fe0a1 Mon Sep 17 00:00:00 2001
From: Cluas <Cluas@live.cn>
Date: Thu, 1 Apr 2021 05:25:23 +0000
Subject: [PATCH 1320/2400] net/url: use camelCase names

Change-Id: I191b98b846c9de58b1892e695058c727402b5400
GitHub-Last-Rev: f241ddd96b4e847ee3608133a41e1b2bb553982d
GitHub-Pull-Request: golang/go#45291
Reviewed-on: https://go-review.googlesource.com/c/go/+/305770
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/net/url/url.go | 58 +++++++++++++++++++++++-----------------------
 1 file changed, 29 insertions(+), 29 deletions(-)

diff --git a/src/net/url/url.go b/src/net/url/url.go
index d90f5f06b5..e138082d22 100644
--- a/src/net/url/url.go
+++ b/src/net/url/url.go
@@ -425,31 +425,31 @@ func (u *Userinfo) String() string {
 	return s
 }
 
-// Maybe rawurl is of the form scheme:path.
+// Maybe rawURL is of the form scheme:path.
 // (Scheme must be [a-zA-Z][a-zA-Z0-9+-.]*)
-// If so, return scheme, path; else return "", rawurl.
-func getscheme(rawurl string) (scheme, path string, err error) {
-	for i := 0; i < len(rawurl); i++ {
-		c := rawurl[i]
+// If so, return scheme, path; else return "", rawURL.
+func getScheme(rawURL string) (scheme, path string, err error) {
+	for i := 0; i < len(rawURL); i++ {
+		c := rawURL[i]
 		switch {
 		case 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z':
 		// do nothing
 		case '0' <= c && c <= '9' || c == '+' || c == '-' || c == '.':
 			if i == 0 {
-				return "", rawurl, nil
+				return "", rawURL, nil
 			}
 		case c == ':':
 			if i == 0 {
 				return "", "", errors.New("missing protocol scheme")
 			}
-			return rawurl[:i], rawurl[i+1:], nil
+			return rawURL[:i], rawURL[i+1:], nil
 		default:
 			// we have encountered an invalid character,
 			// so there is no valid scheme
-			return "", rawurl, nil
+			return "", rawURL, nil
 		}
 	}
-	return "", rawurl, nil
+	return "", rawURL, nil
 }
 
 // split slices s into two substrings separated by the first occurrence of
@@ -466,15 +466,15 @@ func split(s string, sep byte, cutc bool) (string, string) {
 	return s[:i], s[i:]
 }
 
-// Parse parses rawurl into a URL structure.
+// Parse parses a raw url into a URL structure.
 //
-// The rawurl may be relative (a path, without a host) or absolute
+// The url may be relative (a path, without a host) or absolute
 // (starting with a scheme). Trying to parse a hostname and path
 // without a scheme is invalid but may not necessarily return an
 // error, due to parsing ambiguities.
-func Parse(rawurl string) (*URL, error) {
+func Parse(rawURL string) (*URL, error) {
 	// Cut off #frag
-	u, frag := split(rawurl, '#', true)
+	u, frag := split(rawURL, '#', true)
 	url, err := parse(u, false)
 	if err != nil {
 		return nil, &Error{"parse", u, err}
@@ -483,20 +483,20 @@ func Parse(rawurl string) (*URL, error) {
 		return url, nil
 	}
 	if err = url.setFragment(frag); err != nil {
-		return nil, &Error{"parse", rawurl, err}
+		return nil, &Error{"parse", rawURL, err}
 	}
 	return url, nil
 }
 
-// ParseRequestURI parses rawurl into a URL structure. It assumes that
-// rawurl was received in an HTTP request, so the rawurl is interpreted
+// ParseRequestURI parses a raw url into a URL structure. It assumes that
+// url was received in an HTTP request, so the url is interpreted
 // only as an absolute URI or an absolute path.
-// The string rawurl is assumed not to have a #fragment suffix.
+// The string url is assumed not to have a #fragment suffix.
 // (Web browsers strip #fragment before sending the URL to a web server.)
-func ParseRequestURI(rawurl string) (*URL, error) {
-	url, err := parse(rawurl, true)
+func ParseRequestURI(rawURL string) (*URL, error) {
+	url, err := parse(rawURL, true)
 	if err != nil {
-		return nil, &Error{"parse", rawurl, err}
+		return nil, &Error{"parse", rawURL, err}
 	}
 	return url, nil
 }
@@ -505,27 +505,27 @@ func ParseRequestURI(rawurl string) (*URL, error) {
 // viaRequest is true, the URL is assumed to have arrived via an HTTP request,
 // in which case only absolute URLs or path-absolute relative URLs are allowed.
 // If viaRequest is false, all forms of relative URLs are allowed.
-func parse(rawurl string, viaRequest bool) (*URL, error) {
+func parse(rawURL string, viaRequest bool) (*URL, error) {
 	var rest string
 	var err error
 
-	if stringContainsCTLByte(rawurl) {
+	if stringContainsCTLByte(rawURL) {
 		return nil, errors.New("net/url: invalid control character in URL")
 	}
 
-	if rawurl == "" && viaRequest {
+	if rawURL == "" && viaRequest {
 		return nil, errors.New("empty url")
 	}
 	url := new(URL)
 
-	if rawurl == "*" {
+	if rawURL == "*" {
 		url.Path = "*"
 		return url, nil
 	}
 
 	// Split off possible leading "http:", "mailto:", etc.
 	// Cannot contain escaped characters.
-	if url.Scheme, rest, err = getscheme(rawurl); err != nil {
+	if url.Scheme, rest, err = getScheme(rawURL); err != nil {
 		return nil, err
 	}
 	url.Scheme = strings.ToLower(url.Scheme)
@@ -1058,11 +1058,11 @@ func (u *URL) IsAbs() bool {
 // may be relative or absolute. Parse returns nil, err on parse
 // failure, otherwise its return value is the same as ResolveReference.
 func (u *URL) Parse(ref string) (*URL, error) {
-	refurl, err := Parse(ref)
+	refURL, err := Parse(ref)
 	if err != nil {
 		return nil, err
 	}
-	return u.ResolveReference(refurl), nil
+	return u.ResolveReference(refURL), nil
 }
 
 // ResolveReference resolves a URI reference to an absolute URI from
@@ -1151,8 +1151,8 @@ func (u *URL) Port() string {
 // splitHostPort separates host and port. If the port is not valid, it returns
 // the entire input as host, and it doesn't check the validity of the host.
 // Unlike net.SplitHostPort, but per RFC 3986, it requires ports to be numeric.
-func splitHostPort(hostport string) (host, port string) {
-	host = hostport
+func splitHostPort(hostPort string) (host, port string) {
+	host = hostPort
 
 	colon := strings.LastIndexByte(host, ':')
 	if colon != -1 && validOptionalPort(host[colon:]) {
-- 
GitLab


From 45ca9ef5c1235a80ceffca459cbf1bd47032b35f Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Wed, 31 Mar 2021 22:51:44 -0400
Subject: [PATCH 1321/2400] cmd/compile: fix register/offset calculation for
 trailing empty field case.

Includes test.
Long term, need to make the offending code be more in terms
of official types package offsets, instead of duplicating that
logic.

For #40724.

Change-Id: Id33a153f10aed3289cc48d1f99a8e0f6ece9474d
Reviewed-on: https://go-review.googlesource.com/c/go/+/306469
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/abi/abiutils.go |  5 ++-
 test/abi/fuzz_trailing_zero_field.go     | 39 ++++++++++++++++++++++++
 2 files changed, 43 insertions(+), 1 deletion(-)
 create mode 100644 test/abi/fuzz_trailing_zero_field.go

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index 56e008830f..50a818c025 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -211,8 +211,11 @@ func appendParamOffsets(offsets []int64, at int64, t *types.Type) ([]int64, int6
 				offsets, at = appendParamOffsets(offsets, at, t.Elem())
 			}
 		case types.TSTRUCT:
-			for _, f := range t.FieldSlice() {
+			for i, f := range t.FieldSlice() {
 				offsets, at = appendParamOffsets(offsets, at, f.Type)
+				if f.Type.Width == 0 && i == t.NumFields()-1 {
+					at++ // last field has zero width
+				}
 			}
 			at = align(at, t) // type size is rounded up to its alignment
 		case types.TSLICE:
diff --git a/test/abi/fuzz_trailing_zero_field.go b/test/abi/fuzz_trailing_zero_field.go
new file mode 100644
index 0000000000..ae7ad32aa2
--- /dev/null
+++ b/test/abi/fuzz_trailing_zero_field.go
@@ -0,0 +1,39 @@
+// run
+
+// Copyright 2021 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
+
+var p0exp = S1{
+	F1: complex(float64(2.3640607624715027), float64(-0.2717825524109192)),
+	F2: S2{F1: 9},
+	F3: 103050709,
+}
+
+type S1 struct {
+	F1 complex128
+	F2 S2
+	F3 uint64
+}
+
+type S2 struct {
+	F1 uint64
+	F2 empty
+}
+
+type empty struct {
+}
+
+//go:noinline
+//go:registerparams
+func callee(p0 S1) {
+	if p0 != p0exp {
+		panic("bad p0")
+	}
+}
+
+func main() {
+	callee(p0exp)
+}
-- 
GitLab


From 51cd074c59c770484e7db4788d968c408a278607 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Tue, 30 Mar 2021 22:33:28 +0000
Subject: [PATCH 1322/2400] reflect: undo register count increments on register
 assignment failure

Currently when register assignment fails we roll back all the abiParts
that were generated in the process. However, the total number of
registers also increases, but does not get rolled back. The result is
a very incorrect register assignment.

For #40724.
For #44816.

Change-Id: I1934ea5f95f7608ff2067166255099dbc9135e8c
Reviewed-on: https://go-review.googlesource.com/c/go/+/306109
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Austin Clements <austin@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/reflect/abi.go      | 8 +++++++-
 src/reflect/abi_test.go | 9 +++++++++
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/src/reflect/abi.go b/src/reflect/abi.go
index 50e6312172..002e4598b9 100644
--- a/src/reflect/abi.go
+++ b/src/reflect/abi.go
@@ -121,6 +121,7 @@ func (a *abiSeq) stepsForValue(i int) []abiStep {
 // If the value was stack-assigned, returns the single
 // abiStep describing that translation, and nil otherwise.
 func (a *abiSeq) addArg(t *rtype) *abiStep {
+	// We'll always be adding a new value, so do that first.
 	pStart := len(a.steps)
 	a.valueStart = append(a.valueStart, pStart)
 	if t.size == 0 {
@@ -141,8 +142,13 @@ func (a *abiSeq) addArg(t *rtype) *abiStep {
 		a.stackBytes = align(a.stackBytes, uintptr(t.align))
 		return nil
 	}
+	// Hold a copy of "a" so that we can roll back if
+	// register assignment fails.
+	aOld := *a
 	if !a.regAssign(t, 0) {
-		a.steps = a.steps[:pStart]
+		// Register assignment failed. Roll back any changes
+		// and stack-assign.
+		*a = aOld
 		a.stackAssign(t.size, uintptr(t.align))
 		return &a.steps[len(a.steps)-1]
 	}
diff --git a/src/reflect/abi_test.go b/src/reflect/abi_test.go
index 418896ee87..d658a0f6d3 100644
--- a/src/reflect/abi_test.go
+++ b/src/reflect/abi_test.go
@@ -85,6 +85,7 @@ func TestReflectValueCallABI(t *testing.T) {
 		passStruct13,
 		pass2Struct1,
 		passEmptyStruct,
+		passStruct10AndSmall,
 	} {
 		fn := reflect.ValueOf(fn)
 		t.Run(runtime.FuncForPC(fn.Pointer()).Name(), func(t *testing.T) {
@@ -339,6 +340,14 @@ func passEmptyStruct(a int, b struct{}, c float64) (int, struct{}, float64) {
 	return a, b, c
 }
 
+// This test case forces a large argument to the stack followed by more
+// in-register arguments.
+//go:registerparams
+//go:noinline
+func passStruct10AndSmall(a Struct10, b byte, c uint) (Struct10, byte, uint) {
+	return a, b, c
+}
+
 // Struct1 is a simple integer-only aggregate struct.
 type Struct1 struct {
 	A, B, C uint
-- 
GitLab


From 27d306281c54a89ff00e3dad6f4cea790a2f2f2d Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Thu, 1 Apr 2021 15:02:11 +0000
Subject: [PATCH 1323/2400] reflect,runtime: assume register ABI with
 GOEXPERIMENT=regabiargs

This change causes finalizers, reflect calls, and Windows syscall
callbacks to assume the register ABI when GOEXPERIMENT=regabiargs is
set. That is, when all Go functions are using the new ABI by default,
these features should assume the new ABI too.

For #40724.

Change-Id: Ie4ee66b8085b692e1ff675f01134c9a4703ae1b9
Reviewed-on: https://go-review.googlesource.com/c/go/+/306571
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Austin Clements <austin@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/reflect/abi.go            |  6 +++---
 src/reflect/regabiargs_off.go | 10 ++++++++++
 src/reflect/regabiargs_on.go  | 10 ++++++++++
 src/runtime/regabiargs_off.go | 10 ++++++++++
 src/runtime/regabiargs_on.go  | 10 ++++++++++
 src/runtime/stubs.go          |  2 +-
 6 files changed, 44 insertions(+), 4 deletions(-)
 create mode 100644 src/reflect/regabiargs_off.go
 create mode 100644 src/reflect/regabiargs_on.go
 create mode 100644 src/runtime/regabiargs_off.go
 create mode 100644 src/runtime/regabiargs_on.go

diff --git a/src/reflect/abi.go b/src/reflect/abi.go
index 002e4598b9..ab19695edc 100644
--- a/src/reflect/abi.go
+++ b/src/reflect/abi.go
@@ -28,9 +28,9 @@ import (
 // commented out there should be the actual values once
 // we're ready to use the register ABI everywhere.
 var (
-	intArgRegs   = 0          // abi.IntArgRegs
-	floatArgRegs = 0          // abi.FloatArgRegs
-	floatRegSize = uintptr(0) // uintptr(abi.EffectiveFloatRegSize)
+	intArgRegs   = abi.IntArgRegs * experimentRegabiArgs
+	floatArgRegs = abi.FloatArgRegs * experimentRegabiArgs
+	floatRegSize = uintptr(abi.EffectiveFloatRegSize * experimentRegabiArgs)
 )
 
 // abiStep represents an ABI "instruction." Each instruction
diff --git a/src/reflect/regabiargs_off.go b/src/reflect/regabiargs_off.go
new file mode 100644
index 0000000000..655e955474
--- /dev/null
+++ b/src/reflect/regabiargs_off.go
@@ -0,0 +1,10 @@
+// Copyright 2021 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.
+
+//go:build !goexperiment.regabiargs
+// +build !goexperiment.regabiargs
+
+package reflect
+
+const experimentRegabiArgs = 0
diff --git a/src/reflect/regabiargs_on.go b/src/reflect/regabiargs_on.go
new file mode 100644
index 0000000000..0f33b22ff9
--- /dev/null
+++ b/src/reflect/regabiargs_on.go
@@ -0,0 +1,10 @@
+// Copyright 2021 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.
+
+//go:build goexperiment.regabiargs
+// +build goexperiment.regabiargs
+
+package reflect
+
+const experimentRegabiArgs = 1
diff --git a/src/runtime/regabiargs_off.go b/src/runtime/regabiargs_off.go
new file mode 100644
index 0000000000..49d7bcc28d
--- /dev/null
+++ b/src/runtime/regabiargs_off.go
@@ -0,0 +1,10 @@
+// Copyright 2021 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.
+
+//go:build !goexperiment.regabiargs
+// +build !goexperiment.regabiargs
+
+package runtime
+
+const experimentRegabiArgs = 0
diff --git a/src/runtime/regabiargs_on.go b/src/runtime/regabiargs_on.go
new file mode 100644
index 0000000000..935d3ec24b
--- /dev/null
+++ b/src/runtime/regabiargs_on.go
@@ -0,0 +1,10 @@
+// Copyright 2021 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.
+
+//go:build goexperiment.regabiargs
+// +build goexperiment.regabiargs
+
+package runtime
+
+const experimentRegabiArgs = 1
diff --git a/src/runtime/stubs.go b/src/runtime/stubs.go
index a2e04a64a5..e2d4f0da3b 100644
--- a/src/runtime/stubs.go
+++ b/src/runtime/stubs.go
@@ -423,4 +423,4 @@ func sigpanic0()
 // everywhere.
 //
 // Protected by finlock.
-var intArgRegs = 0 // abi.IntArgRegs
+var intArgRegs = abi.IntArgRegs * experimentRegabiArgs
-- 
GitLab


From 5579ee169f12815660eb9ee66afd5f2abc77864f Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 1 Apr 2021 14:21:12 -0400
Subject: [PATCH 1324/2400] cmd/compile: in expand calls, preserve pointer
 store type but decompose aggregate args

In CL 305672 we preserve the pointer type of a store by just not
decomposing it. But this can be problematic when the source of
the store is a direct interface aggregate type (e.g.
struct { x map[int]int }.

In this CL we take a different approach: we preserve the store
type when generating the new store, but also decompose the source.

Fixes #45344.

Change-Id: If5dd496458dee95aa649c6d106b96a6cdcf3e60d
Reviewed-on: https://go-review.googlesource.com/c/go/+/306669
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/ssa/expand_calls.go | 11 ++++++++---
 test/fixedbugs/issue45344.go                 | 20 ++++++++++++++++++++
 2 files changed, 28 insertions(+), 3 deletions(-)
 create mode 100644 test/fixedbugs/issue45344.go

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index 2935236473..a5fe6f4d29 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -589,6 +589,14 @@ func (x *expandState) decomposeArg(pos src.XPos, b *Block, source, mem *Value, t
 			if w == nil {
 				w = x.newArgToMemOrRegs(source, w, off, i, rt, pos)
 			}
+			if t.IsPtrShaped() {
+				// Preserve the original store type. This ensures pointer type
+				// properties aren't discarded (e.g, notinheap).
+				if rt.Width != t.Width || len(pa.Registers) != 1 || i != loadRegOffset {
+					b.Func.Fatalf("incompatible store type %v and %v, i=%d", t, rt, i)
+				}
+				rt = t
+			}
 			mem = x.storeArgOrLoad(pos, b, w, mem, rt, storeOffset+off, i, storeRc.next(rt))
 		}
 		return mem
@@ -1114,9 +1122,6 @@ func expandCalls(f *Func) {
 		for _, v := range b.Values {
 			if v.Op == OpStore {
 				t := v.Aux.(*types.Type)
-				if t.IsPtrShaped() { // Everything already fits, and this ensures pointer type properties aren't discarded (e.g, notinheap)
-					continue
-				}
 				source := v.Args[1]
 				tSrc := source.Type
 				iAEATt := x.isAlreadyExpandedAggregateType(t)
diff --git a/test/fixedbugs/issue45344.go b/test/fixedbugs/issue45344.go
new file mode 100644
index 0000000000..70c3d8970d
--- /dev/null
+++ b/test/fixedbugs/issue45344.go
@@ -0,0 +1,20 @@
+// compile
+
+// Copyright 2021 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.
+
+// Issue 45344: expand_calls does not handle direct interface
+// typed argument well.
+
+package p
+
+type T struct {
+	a map[int]int
+}
+
+func F(t T) {
+	G(t)
+}
+
+func G(...interface{})
-- 
GitLab


From 41e8a9f1cf78933ebdaf9fa29694df5129f1862c Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Wed, 31 Mar 2021 12:13:58 -0400
Subject: [PATCH 1325/2400] runtime: fix TestGCTestMoveStackOnNextCall flakes

gcTestMoveStackOnNextCall can fail to move the stack in very rare
cases if there's an unfortunately timed preemption that clobbers the
stack guard. This won't happen multiple times in quick succession, so
make the test just retry a few times.

Change-Id: I247dc0551514e269e7132cee7945291429b0e865
Reviewed-on: https://go-review.googlesource.com/c/go/+/306671
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/gc_test.go | 18 ++++++++++++++----
 src/runtime/mgc.go     |  3 +++
 2 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/src/runtime/gc_test.go b/src/runtime/gc_test.go
index 1ea1c2c745..273f399864 100644
--- a/src/runtime/gc_test.go
+++ b/src/runtime/gc_test.go
@@ -205,15 +205,24 @@ func TestGcZombieReporting(t *testing.T) {
 func TestGCTestMoveStackOnNextCall(t *testing.T) {
 	t.Parallel()
 	var onStack int
-	runtime.GCTestMoveStackOnNextCall()
-	moveStackCheck(t, &onStack, uintptr(unsafe.Pointer(&onStack)))
+	// GCTestMoveStackOnNextCall can fail in rare cases if there's
+	// a preemption. This won't happen many times in quick
+	// succession, so just retry a few times.
+	for retry := 0; retry < 5; retry++ {
+		runtime.GCTestMoveStackOnNextCall()
+		if moveStackCheck(t, &onStack, uintptr(unsafe.Pointer(&onStack))) {
+			// Passed.
+			return
+		}
+	}
+	t.Fatal("stack did not move")
 }
 
 // This must not be inlined because the point is to force a stack
 // growth check and move the stack.
 //
 //go:noinline
-func moveStackCheck(t *testing.T, new *int, old uintptr) {
+func moveStackCheck(t *testing.T, new *int, old uintptr) bool {
 	// new should have been updated by the stack move;
 	// old should not have.
 
@@ -228,8 +237,9 @@ func moveStackCheck(t *testing.T, new *int, old uintptr) {
 			t.Fatalf("test bug: new (%#x) should be a stack pointer, not %s", new2, cls)
 		}
 		// This was a real failure.
-		t.Fatal("stack did not move")
+		return false
 	}
+	return true
 }
 
 func TestGCTestIsReachable(t *testing.T) {
diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index ecac354d83..f0c03b5102 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -2347,6 +2347,9 @@ func fmtNSAsMS(buf []byte, ns uint64) []byte {
 // if any other work appears after this call (such as returning).
 // Typically the following call should be marked go:noinline so it
 // performs a stack check.
+//
+// In rare cases this may not cause the stack to move, specifically if
+// there's a preemption between this call and the next.
 func gcTestMoveStackOnNextCall() {
 	gp := getg()
 	gp.stackguard0 = getcallersp()
-- 
GitLab


From 97b3ce430bb64fb6c8dfb244d400468932f2e984 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Thu, 1 Apr 2021 16:50:53 -0400
Subject: [PATCH 1326/2400] runtime: make gcTestMoveStackOnNextCall not double
 the stack

Currently, gcTestMoveStackOnNextCall doubles the stack allocation on
each call because stack movement always doubles the stack. That's
rather unfortunate if you're doing a bunch of stack movement tests in
a row that don't actually have to grow the stack because you'll
quickly hit the stack size limit even though you're hardly using any
of the stack.

Fix this by adding a special stack poison value for
gcTestMoveStackOnNextCall that newstack recognizes and inhibits the
allocation doubling.

Change-Id: Iace7055a0f33cb48dc97b8f4b46e45304bee832c
Reviewed-on: https://go-review.googlesource.com/c/go/+/306672
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/gc_test.go | 17 +++++++++++++++++
 src/runtime/mgc.go     |  2 +-
 src/runtime/stack.go   | 13 ++++++++++++-
 3 files changed, 30 insertions(+), 2 deletions(-)

diff --git a/src/runtime/gc_test.go b/src/runtime/gc_test.go
index 273f399864..5e7c6c574f 100644
--- a/src/runtime/gc_test.go
+++ b/src/runtime/gc_test.go
@@ -242,6 +242,23 @@ func moveStackCheck(t *testing.T, new *int, old uintptr) bool {
 	return true
 }
 
+func TestGCTestMoveStackRepeatedly(t *testing.T) {
+	// Move the stack repeatedly to make sure we're not doubling
+	// it each time.
+	for i := 0; i < 100; i++ {
+		runtime.GCTestMoveStackOnNextCall()
+		moveStack1(false)
+	}
+}
+
+//go:noinline
+func moveStack1(x bool) {
+	// Make sure this function doesn't get auto-nosplit.
+	if x {
+		println("x")
+	}
+}
+
 func TestGCTestIsReachable(t *testing.T) {
 	var all, half []unsafe.Pointer
 	var want uint64
diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index f0c03b5102..4895fa5ef6 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -2352,7 +2352,7 @@ func fmtNSAsMS(buf []byte, ns uint64) []byte {
 // there's a preemption between this call and the next.
 func gcTestMoveStackOnNextCall() {
 	gp := getg()
-	gp.stackguard0 = getcallersp()
+	gp.stackguard0 = stackForceMove
 }
 
 // gcTestIsReachable performs a GC and returns a bit set where bit i
diff --git a/src/runtime/stack.go b/src/runtime/stack.go
index d971e5e26f..5c7fadc2d2 100644
--- a/src/runtime/stack.go
+++ b/src/runtime/stack.go
@@ -132,6 +132,10 @@ const (
 	// Stored into g->stackguard0 to cause split stack check failure.
 	// Must be greater than any real sp.
 	stackFork = uintptrMask & -1234
+
+	// Force a stack movement. Used for debugging.
+	// 0xfffffeed in hex.
+	stackForceMove = uintptrMask & -275
 )
 
 // Global pool of spans that have free stacks.
@@ -1054,11 +1058,18 @@ func newstack() {
 	// recheck the bounds on return.)
 	if f := findfunc(gp.sched.pc); f.valid() {
 		max := uintptr(funcMaxSPDelta(f))
-		for newsize-oldsize < max+_StackGuard {
+		for newsize-gp.sched.sp < max+_StackGuard {
 			newsize *= 2
 		}
 	}
 
+	if gp.stackguard0 == stackForceMove {
+		// Forced stack movement used for debugging.
+		// Don't double the stack (or we may quickly run out
+		// if this is done repeatedly).
+		newsize = oldsize
+	}
+
 	if newsize > maxstacksize || newsize > maxstackceiling {
 		if maxstacksize < maxstackceiling {
 			print("runtime: goroutine stack exceeds ", maxstacksize, "-byte limit\n")
-- 
GitLab


From aebc0b473e364daa0fad3b45e4dc77366408f3cd Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Wed, 31 Mar 2021 23:58:54 -0700
Subject: [PATCH 1327/2400] cmd/compile: fix bug in phiopt pass

The math to invert the input index was wrong.

Fixes #45323

Change-Id: I7c68cac280e8f01a9c806ecb0f195f169267437e
Reviewed-on: https://go-review.googlesource.com/c/go/+/306431
Trust: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: fannie zhang <Fannie.Zhang@arm.com>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/ssa/phiopt.go |  2 +-
 test/fixedbugs/issue45323.go           | 24 ++++++++++++++++++++++++
 2 files changed, 25 insertions(+), 1 deletion(-)
 create mode 100644 test/fixedbugs/issue45323.go

diff --git a/src/cmd/compile/internal/ssa/phiopt.go b/src/cmd/compile/internal/ssa/phiopt.go
index ee583d0225..745c61cb86 100644
--- a/src/cmd/compile/internal/ssa/phiopt.go
+++ b/src/cmd/compile/internal/ssa/phiopt.go
@@ -213,7 +213,7 @@ func phiopt(f *Func) {
 				ei := b.Preds[1].i
 				sb0 := pb1.Succs[1-ei].b
 				if sdom.IsAncestorEq(sb0, pb0) {
-					convertPhi(pb1, v, ei-1)
+					convertPhi(pb1, v, 1-ei)
 					break
 				}
 			} else {
diff --git a/test/fixedbugs/issue45323.go b/test/fixedbugs/issue45323.go
new file mode 100644
index 0000000000..870d1a27f7
--- /dev/null
+++ b/test/fixedbugs/issue45323.go
@@ -0,0 +1,24 @@
+// compile
+
+// Copyright 2021 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
+
+func g() bool
+
+func f(y int) bool {
+	b, ok := true, false
+	if y > 1 {
+		ok = g()
+	}
+	if !ok {
+		ok = g()
+		b = false
+	}
+	if !ok {
+		return false
+	}
+	return b
+}
-- 
GitLab


From a78b12aea7d18a402cecbaa4eca4c8ba09cc05ca Mon Sep 17 00:00:00 2001
From: Tao Qingyun <qingyunha@gmail.com>
Date: Fri, 2 Apr 2021 12:02:17 +0000
Subject: [PATCH 1328/2400] cmd/link: remove unnecessary attrReachable test

Change-Id: I5a6fde3ce57be1760cc8c92910fe77beb8b9c655
GitHub-Last-Rev: 0b2f3cb3a81336d94d288afe7c324a5a54114ebb
GitHub-Pull-Request: golang/go#45259
Reviewed-on: https://go-review.googlesource.com/c/go/+/305169
Reviewed-by: Than McIntosh <thanm@google.com>
Trust: David Chase <drchase@google.com>
---
 src/cmd/link/internal/loader/loader.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/link/internal/loader/loader.go b/src/cmd/link/internal/loader/loader.go
index 668e698cbf..adc8195ace 100644
--- a/src/cmd/link/internal/loader/loader.go
+++ b/src/cmd/link/internal/loader/loader.go
@@ -2538,7 +2538,7 @@ func (l *Loader) AssignTextSymbolOrder(libs []*sym.Library, intlibs []bool, exts
 			for i, list := range lists {
 				for _, s := range list {
 					sym := Sym(s)
-					if l.attrReachable.Has(sym) && !assignedToUnit.Has(sym) {
+					if !assignedToUnit.Has(sym) {
 						textp = append(textp, sym)
 						unit := l.SymUnit(sym)
 						if unit != nil {
-- 
GitLab


From b1650858366c2a1eaa53d32fe90022941aa556f2 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Fri, 2 Apr 2021 06:58:13 -0400
Subject: [PATCH 1329/2400] cmd/link: remove an unused function from linker
 dwarf gen

Remove a no-longer-used function.

Change-Id: Iad383a9d158d31d4c8b65dd39b71849b44c6b52e
Reviewed-on: https://go-review.googlesource.com/c/go/+/306829
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
---
 src/cmd/link/internal/ld/dwarf.go | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/src/cmd/link/internal/ld/dwarf.go b/src/cmd/link/internal/ld/dwarf.go
index 3c3f0e5b85..2f19c3eaa2 100644
--- a/src/cmd/link/internal/ld/dwarf.go
+++ b/src/cmd/link/internal/ld/dwarf.go
@@ -2290,12 +2290,6 @@ func getDwsectCUSize(sname string, pkgname string) uint64 {
 	return dwsectCUSize[sname+"."+pkgname]
 }
 
-func saveDwsectCUSize(sname string, pkgname string, size uint64) {
-	dwsectCUSizeMu.Lock()
-	defer dwsectCUSizeMu.Unlock()
-	dwsectCUSize[sname+"."+pkgname] = size
-}
-
 func addDwsectCUSize(sname string, pkgname string, size uint64) {
 	dwsectCUSizeMu.Lock()
 	defer dwsectCUSizeMu.Unlock()
-- 
GitLab


From 3651eff74efcd80519372d58eb06a0fe3f3f2808 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 1 Apr 2021 20:08:32 -0400
Subject: [PATCH 1330/2400] cmd/link: delete CompilationUnit.Pkg field

It is never used. It is actually CompilationUnit.Lib.Pkg that
contains the package path.

Change-Id: I18189644ea080080868d144e81dfee02f4549133
Reviewed-on: https://go-review.googlesource.com/c/go/+/306710
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/sym/compilation_unit.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/link/internal/sym/compilation_unit.go b/src/cmd/link/internal/sym/compilation_unit.go
index 926cbc3d20..3bad5bf3f4 100644
--- a/src/cmd/link/internal/sym/compilation_unit.go
+++ b/src/cmd/link/internal/sym/compilation_unit.go
@@ -20,7 +20,6 @@ type LoaderSym int
 //
 // These are used for both DWARF and pclntab generation.
 type CompilationUnit struct {
-	Pkg       string        // The package name, eg ("fmt", or "runtime")
 	Lib       *Library      // Our library
 	PclnIndex int           // Index of this CU in pclntab
 	PCs       []dwarf.Range // PC ranges, relative to Textp[0]
-- 
GitLab


From 2d88f8f21e71f73dc3aa846cdc8c413f1bb584b8 Mon Sep 17 00:00:00 2001
From: Himanshu Kishna Srivastava <28himanshu@gmail.com>
Date: Wed, 31 Mar 2021 21:22:49 +0530
Subject: [PATCH 1331/2400] go/src/cmd/go/internal/work: compile "internal/abi"
 with "-+"

"internal/abi" package depends on runtime package and are supposed to
compile with "-+" option.Added internal/abi in the known list of package
that runtime depends on,so that "internal/abi" compiles with "-+".

Fixes #45144

Change-Id: Iad9e2589f2fbd014260cb8ef9f943d2126015fe1
Reviewed-on: https://go-review.googlesource.com/c/go/+/306289
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/internal/work/gc.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/go/internal/work/gc.go b/src/cmd/go/internal/work/gc.go
index c71196469b..7ccba4a561 100644
--- a/src/cmd/go/internal/work/gc.go
+++ b/src/cmd/go/internal/work/gc.go
@@ -89,7 +89,7 @@ func (gcToolchain) gc(b *Builder, a *Action, archive string, importcfg, embedcfg
 	}
 	compilingRuntime := p.Standard && (p.ImportPath == "runtime" || strings.HasPrefix(p.ImportPath, "runtime/internal"))
 	// The runtime package imports a couple of general internal packages.
-	if p.Standard && (p.ImportPath == "internal/cpu" || p.ImportPath == "internal/bytealg") {
+	if p.Standard && (p.ImportPath == "internal/cpu" || p.ImportPath == "internal/bytealg" || p.ImportPath == "internal/abi") {
 		compilingRuntime = true
 	}
 	if compilingRuntime {
-- 
GitLab


From 759116b3ace07f431103d65a7ce6cf4f314203bf Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 1 Apr 2021 19:22:12 -0400
Subject: [PATCH 1332/2400] syscall: delete asm_windows.s

asm_windows.s contains dummy references of syscall.loadlibrary
and syscall.getprocaddress, to trigger ABI wrapper/alias
generation to get ABI0 symbols for them. The comment says they
are called from assembly in other packages, but I couldn't find
where. They are defined in Go and only referenced in Go.

CL 179862 removed dummy references in the runtime. This CL
is similar, for the syscall package.

Also, with CL 306609, they will have ABI0 definitions anyway.

Change-Id: I5c7b0efb9762e4ad9c94f0beea8d053d8c8b2cd1
Reviewed-on: https://go-review.googlesource.com/c/go/+/306709
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Austin Clements <austin@google.com>
---
 src/syscall/asm_windows.s | 11 -----------
 1 file changed, 11 deletions(-)
 delete mode 100644 src/syscall/asm_windows.s

diff --git a/src/syscall/asm_windows.s b/src/syscall/asm_windows.s
deleted file mode 100644
index e965914330..0000000000
--- a/src/syscall/asm_windows.s
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright 2018 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.
-
-#include "textflag.h"
-
-// abi0Syms is a dummy symbol that creates ABI0 wrappers for Go
-// functions called from assembly in other packages.
-TEXT abi0Syms<>(SB),NOSPLIT,$0-0
-	CALL ·getprocaddress(SB)
-	CALL ·loadlibrary(SB)
-- 
GitLab


From 6996bae5d1d34ea9e2ab6399f70adb402697ed94 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 1 Apr 2021 11:11:04 -0400
Subject: [PATCH 1333/2400] cmd/compile: use ABI0 for cgo_unsafe_args functions

cgo_unsafe_args paragma indicates that the function (or its
callee) uses address and offsets to dispatch arguments, which
currently using ABI0 frame layout. Pin them to ABI0.

With this, "GOEXPERIMENT=regabi,regabiargs go run hello.go" works
on Darwin/AMD64.

Change-Id: I3eadd5a3646a9de8fa681fa0a7f46e7cdc217d24
Reviewed-on: https://go-review.googlesource.com/c/go/+/306609
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Austin Clements <austin@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/amd64/ssa.go        | 14 ++++----------
 src/cmd/compile/internal/ssa/gen/AMD64.rules |  2 +-
 src/cmd/compile/internal/ssa/rewriteAMD64.go |  5 +++--
 src/cmd/compile/internal/ssagen/abi.go       |  7 +++++++
 4 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index 2c767d36d7..8142ba7984 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -824,10 +824,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Reg = v.Args[0].Reg()
 		ssagen.AddAux2(&p.To, v, sc.Off64())
 	case ssa.OpAMD64MOVOstorezero:
-		if s.ABI != obj.ABIInternal {
-			v.Fatalf("MOVOstorezero can be only used in ABIInternal functions")
-		}
-		if !objabi.Experiment.RegabiG {
+		if !objabi.Experiment.RegabiG || s.ABI != obj.ABIInternal {
 			// zero X15 manually
 			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
 		}
@@ -918,10 +915,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.OpAMD64DUFFZERO:
-		if s.ABI != obj.ABIInternal {
-			v.Fatalf("MOVOconst can be only used in ABIInternal functions")
-		}
-		if !objabi.Experiment.RegabiG {
+		if !objabi.Experiment.RegabiG || s.ABI != obj.ABIInternal {
 			// zero X15 manually
 			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
 		}
@@ -1004,8 +998,8 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		// Closure pointer is DX.
 		ssagen.CheckLoweredGetClosurePtr(v)
 	case ssa.OpAMD64LoweredGetG:
-		if objabi.Experiment.RegabiG {
-			v.Fatalf("LoweredGetG should not appear in new ABI")
+		if objabi.Experiment.RegabiG && s.ABI == obj.ABIInternal {
+			v.Fatalf("LoweredGetG should not appear in ABIInternal")
 		}
 		r := v.Reg()
 		getgFromTLS(s, r)
diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules
index 98cd865182..839d4a330e 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64.rules
+++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules
@@ -460,7 +460,7 @@
 (IsInBounds idx len) => (SETB (CMPQ idx len))
 (IsSliceInBounds idx len) => (SETBE (CMPQ idx len))
 (NilCheck ...) => (LoweredNilCheck ...)
-(GetG mem) && !objabi.Experiment.RegabiG => (LoweredGetG mem) // only lower in old ABI. in new ABI we have a G register.
+(GetG mem) && !(objabi.Experiment.RegabiG && v.Block.Func.OwnAux.Fn.ABI() == obj.ABIInternal) => (LoweredGetG mem) // only lower in old ABI. in new ABI we have a G register.
 (GetClosurePtr ...) => (LoweredGetClosurePtr ...)
 (GetCallerPC ...) => (LoweredGetCallerPC ...)
 (GetCallerSP ...) => (LoweredGetCallerSP ...)
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index ce94fdb952..1f56b70816 100644
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -4,6 +4,7 @@
 package ssa
 
 import "math"
+import "cmd/internal/obj"
 import "cmd/internal/objabi"
 import "cmd/compile/internal/types"
 
@@ -30465,11 +30466,11 @@ func rewriteValueAMD64_OpFloor(v *Value) bool {
 func rewriteValueAMD64_OpGetG(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (GetG mem)
-	// cond: !objabi.Experiment.RegabiG
+	// cond: !(objabi.Experiment.RegabiG && v.Block.Func.OwnAux.Fn.ABI() == obj.ABIInternal)
 	// result: (LoweredGetG mem)
 	for {
 		mem := v_0
-		if !(!objabi.Experiment.RegabiG) {
+		if !(!(objabi.Experiment.RegabiG && v.Block.Func.OwnAux.Fn.ABI() == obj.ABIInternal)) {
 			break
 		}
 		v.reset(OpAMD64LoweredGetG)
diff --git a/src/cmd/compile/internal/ssagen/abi.go b/src/cmd/compile/internal/ssagen/abi.go
index 9c203838a5..61d065cea8 100644
--- a/src/cmd/compile/internal/ssagen/abi.go
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -146,6 +146,13 @@ func (s *SymABIs) GenABIWrappers() {
 			fn.ABI = defABI
 		}
 
+		if fn.Pragma&ir.CgoUnsafeArgs != 0 {
+			// CgoUnsafeArgs indicates the function (or its callee) uses
+			// offsets to dispatch arguments, which currently using ABI0
+			// frame layout. Pin it to ABI0.
+			fn.ABI = obj.ABI0
+		}
+
 		// Apply references.
 		if abis, ok := s.refs[symName]; ok {
 			fn.ABIRefs |= abis
-- 
GitLab


From 28c5fed5576483cc696db233d7f6fffecd2833a2 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Thu, 28 Jan 2021 15:23:05 +0000
Subject: [PATCH 1334/2400] reflect: add register ABI support for makeFuncStub
 and methodValueCall

This change finishes off functionality register ABI for the reflect
package.

Specifically, it implements a call on a MakeFunc'd value by performing
the reverse process that reflect.Value.Call does, using the same ABI
steps. It implements a call on a method value created by reflect by
translating between the method value's ABI to the method's ABI.

Tests are added for both cases.

For #40724.

Change-Id: I302820b61fc0a8f94c5525a002bc02776aef41af
Reviewed-on: https://go-review.googlesource.com/c/go/+/298670
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/reflect/abi.go         |  27 +-
 src/reflect/abi_test.go    | 559 +++++++++++++++++++++++++++++++++----
 src/reflect/asm_386.s      |  14 +-
 src/reflect/asm_amd64.s    |  49 +++-
 src/reflect/asm_arm.s      |  16 +-
 src/reflect/asm_arm64.s    |  10 +-
 src/reflect/asm_mips64x.s  |  12 +-
 src/reflect/asm_mipsx.s    |  14 +-
 src/reflect/asm_ppc64x.s   |  14 +-
 src/reflect/asm_riscv64.s  |  14 +-
 src/reflect/asm_s390x.s    |  14 +-
 src/reflect/asm_wasm.s     |  14 +-
 src/reflect/makefunc.go    |  68 ++++-
 src/reflect/value.go       | 310 +++++++++++++++-----
 src/runtime/asm_amd64.s    |  12 +-
 src/runtime/stack.go       |  42 ++-
 src/runtime/stubs_amd64.go |   7 +
 src/runtime/traceback.go   |   2 +-
 18 files changed, 991 insertions(+), 207 deletions(-)

diff --git a/src/reflect/abi.go b/src/reflect/abi.go
index ab19695edc..8b1aaa56b3 100644
--- a/src/reflect/abi.go
+++ b/src/reflect/abi.go
@@ -355,11 +355,15 @@ type abiDesc struct {
 	// passed to reflectcall.
 	stackPtrs *bitVector
 
-	// outRegPtrs is a bitmap whose i'th bit indicates
-	// whether the i'th integer result register contains
-	// a pointer. Used by reflectcall to make result
-	// pointers visible to the GC.
-	outRegPtrs abi.IntArgRegBitmap
+	// inRegPtrs is a bitmap whose i'th bit indicates
+	// whether the i'th integer argument register contains
+	// a pointer. Used by makeFuncStub and methodValueCall
+	// to make result pointers visible to the GC.
+	//
+	// outRegPtrs is the same, but for result values.
+	// Used by reflectcall to make result pointers visible
+	// to the GC.
+	inRegPtrs, outRegPtrs abi.IntArgRegBitmap
 }
 
 func (a *abiDesc) dump() {
@@ -387,6 +391,10 @@ func newAbiDesc(t *funcType, rcvr *rtype) abiDesc {
 	// Compute gc program & stack bitmap for stack arguments
 	stackPtrs := new(bitVector)
 
+	// Compute the stack frame pointer bitmap and register
+	// pointer bitmap for arguments.
+	inRegPtrs := abi.IntArgRegBitmap{}
+
 	// Compute abiSeq for input parameters.
 	var in abiSeq
 	if rcvr != nil {
@@ -401,13 +409,18 @@ func newAbiDesc(t *funcType, rcvr *rtype) abiDesc {
 			spill += ptrSize
 		}
 	}
-	for _, arg := range t.in() {
+	for i, arg := range t.in() {
 		stkStep := in.addArg(arg)
 		if stkStep != nil {
 			addTypeBits(stackPtrs, stkStep.stkOff, arg)
 		} else {
 			spill = align(spill, uintptr(arg.align))
 			spill += arg.size
+			for _, st := range in.stepsForValue(i) {
+				if st.kind == abiStepPointer {
+					inRegPtrs.Set(st.ireg)
+				}
+			}
 		}
 	}
 	spill = align(spill, ptrSize)
@@ -444,5 +457,5 @@ func newAbiDesc(t *funcType, rcvr *rtype) abiDesc {
 	// Undo the faking from earlier so that stackBytes
 	// is accurate.
 	out.stackBytes -= retOffset
-	return abiDesc{in, out, stackCallArgsSize, retOffset, spill, stackPtrs, outRegPtrs}
+	return abiDesc{in, out, stackCallArgsSize, retOffset, spill, stackPtrs, inRegPtrs, outRegPtrs}
 }
diff --git a/src/reflect/abi_test.go b/src/reflect/abi_test.go
index d658a0f6d3..998faee0de 100644
--- a/src/reflect/abi_test.go
+++ b/src/reflect/abi_test.go
@@ -16,7 +16,116 @@ import (
 	"testing/quick"
 )
 
-func TestReflectValueCallABI(t *testing.T) {
+type MagicLastTypeNameForTestingRegisterABI struct{}
+
+func TestMethodValueCallABI(t *testing.T) {
+	// Enable register-based reflect.Call and ensure we don't
+	// use potentially incorrect cached versions by clearing
+	// the cache before we start and after we're done.
+	var oldRegs struct {
+		ints, floats int
+		floatSize    uintptr
+	}
+	oldRegs.ints = *reflect.IntArgRegs
+	oldRegs.floats = *reflect.FloatArgRegs
+	oldRegs.floatSize = *reflect.FloatRegSize
+	*reflect.IntArgRegs = abi.IntArgRegs
+	*reflect.FloatArgRegs = abi.FloatArgRegs
+	*reflect.FloatRegSize = uintptr(abi.EffectiveFloatRegSize)
+	reflect.ClearLayoutCache()
+	defer func() {
+		*reflect.IntArgRegs = oldRegs.ints
+		*reflect.FloatArgRegs = oldRegs.floats
+		*reflect.FloatRegSize = oldRegs.floatSize
+		reflect.ClearLayoutCache()
+	}()
+
+	// This test is simple. Calling a method value involves
+	// pretty much just plumbing whatever arguments in whichever
+	// location through to reflectcall. They're already set up
+	// for us, so there isn't a whole lot to do. Let's just
+	// make sure that we can pass register and stack arguments
+	// through. The exact combination is not super important.
+	makeMethodValue := func(method string) (*StructWithMethods, interface{}) {
+		s := new(StructWithMethods)
+		v := reflect.ValueOf(s).MethodByName(method)
+		return s, v.Interface()
+	}
+
+	a0 := StructFewRegs{
+		10, 11, 12, 13,
+		20.0, 21.0, 22.0, 23.0,
+	}
+	a1 := [4]uint64{100, 101, 102, 103}
+	a2 := StructFillRegs{
+		1, 2, 3, 4, 5, 6, 7, 8, 9,
+		1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0,
+	}
+
+	s, i := makeMethodValue("AllRegsCall")
+	f0 := i.(func(StructFewRegs, MagicLastTypeNameForTestingRegisterABI) StructFewRegs)
+	r0 := f0(a0, MagicLastTypeNameForTestingRegisterABI{})
+	if r0 != a0 {
+		t.Errorf("bad method value call: got %#v, want %#v", r0, a0)
+	}
+	if s.Value != 1 {
+		t.Errorf("bad method value call: failed to set s.Value: got %d, want %d", s.Value, 1)
+	}
+
+	s, i = makeMethodValue("RegsAndStackCall")
+	f1 := i.(func(StructFewRegs, [4]uint64, MagicLastTypeNameForTestingRegisterABI) (StructFewRegs, [4]uint64))
+	r0, r1 := f1(a0, a1, MagicLastTypeNameForTestingRegisterABI{})
+	if r0 != a0 {
+		t.Errorf("bad method value call: got %#v, want %#v", r0, a0)
+	}
+	if r1 != a1 {
+		t.Errorf("bad method value call: got %#v, want %#v", r1, a1)
+	}
+	if s.Value != 2 {
+		t.Errorf("bad method value call: failed to set s.Value: got %d, want %d", s.Value, 2)
+	}
+
+	s, i = makeMethodValue("SpillStructCall")
+	f2 := i.(func(StructFillRegs, MagicLastTypeNameForTestingRegisterABI) StructFillRegs)
+	r2 := f2(a2, MagicLastTypeNameForTestingRegisterABI{})
+	if r2 != a2 {
+		t.Errorf("bad method value call: got %#v, want %#v", r2, a2)
+	}
+	if s.Value != 3 {
+		t.Errorf("bad method value call: failed to set s.Value: got %d, want %d", s.Value, 1)
+	}
+}
+
+type StructWithMethods struct {
+	Value int
+}
+
+type StructFewRegs struct {
+	a0, a1, a2, a3 int
+	f0, f1, f2, f3 float64
+}
+
+type StructFillRegs struct {
+	a0, a1, a2, a3, a4, a5, a6, a7, a8                              int
+	f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14 float64
+}
+
+func (m *StructWithMethods) AllRegsCall(s StructFewRegs, _ MagicLastTypeNameForTestingRegisterABI) StructFewRegs {
+	m.Value = 1
+	return s
+}
+
+func (m *StructWithMethods) RegsAndStackCall(s StructFewRegs, a [4]uint64, _ MagicLastTypeNameForTestingRegisterABI) (StructFewRegs, [4]uint64) {
+	m.Value = 2
+	return s, a
+}
+
+func (m *StructWithMethods) SpillStructCall(s StructFillRegs, _ MagicLastTypeNameForTestingRegisterABI) StructFillRegs {
+	m.Value = 3
+	return s
+}
+
+func TestReflectCallABI(t *testing.T) {
 	// Enable register-based reflect.Call and ensure we don't
 	// use potentially incorrect cached versions by clearing
 	// the cache before we start and after we're done.
@@ -43,50 +152,7 @@ func TestReflectValueCallABI(t *testing.T) {
 	// to return values. The purpose is to test the call boundary
 	// and make sure it works.
 	r := rand.New(rand.NewSource(genValueRandSeed))
-	for _, fn := range []interface{}{
-		passNone,
-		passInt,
-		passInt8,
-		passInt16,
-		passInt32,
-		passInt64,
-		passUint,
-		passUint8,
-		passUint16,
-		passUint32,
-		passUint64,
-		passFloat32,
-		passFloat64,
-		passComplex64,
-		passComplex128,
-		passManyInt,
-		passManyFloat64,
-		passArray1,
-		passArray,
-		passArray1Mix,
-		passString,
-		// TODO(mknyszek): Test passing interface values.
-		passSlice,
-		passPointer,
-		passStruct1,
-		passStruct2,
-		passStruct3,
-		passStruct4,
-		passStruct5,
-		passStruct6,
-		passStruct7,
-		passStruct8,
-		passStruct9,
-		passStruct10,
-		// TODO(mknyszek): Test passing unsafe.Pointer values.
-		// TODO(mknyszek): Test passing chan values.
-		passStruct11,
-		passStruct12,
-		passStruct13,
-		pass2Struct1,
-		passEmptyStruct,
-		passStruct10AndSmall,
-	} {
+	for _, fn := range abiCallTestCases {
 		fn := reflect.ValueOf(fn)
 		t.Run(runtime.FuncForPC(fn.Pointer()).Name(), func(t *testing.T) {
 			typ := fn.Type()
@@ -106,13 +172,140 @@ func TestReflectValueCallABI(t *testing.T) {
 				if reflect.DeepEqual(x, y) {
 					continue
 				}
-				t.Errorf("arg and result %d differ: got %+v, want %+v", i, x, y)
+				t.Errorf("arg and result %d differ: got %+v, want %+v", i, y, x)
 			}
 		})
 	}
 }
 
-// Functions for testing reflect.Value.Call.
+func TestReflectMakeFuncCallABI(t *testing.T) {
+	// Enable register-based reflect.MakeFunc and ensure we don't
+	// use potentially incorrect cached versions by clearing
+	// the cache before we start and after we're done.
+	var oldRegs struct {
+		ints, floats int
+		floatSize    uintptr
+	}
+	oldRegs.ints = *reflect.IntArgRegs
+	oldRegs.floats = *reflect.FloatArgRegs
+	oldRegs.floatSize = *reflect.FloatRegSize
+	*reflect.IntArgRegs = abi.IntArgRegs
+	*reflect.FloatArgRegs = abi.FloatArgRegs
+	*reflect.FloatRegSize = uintptr(abi.EffectiveFloatRegSize)
+	reflect.ClearLayoutCache()
+	defer func() {
+		*reflect.IntArgRegs = oldRegs.ints
+		*reflect.FloatArgRegs = oldRegs.floats
+		*reflect.FloatRegSize = oldRegs.floatSize
+		reflect.ClearLayoutCache()
+	}()
+
+	// Execute the functions defined below which all have the
+	// same form and perform the same function: pass all arguments
+	// to return values. The purpose is to test the call boundary
+	// and make sure it works.
+	r := rand.New(rand.NewSource(genValueRandSeed))
+	makeFuncHandler := func(args []reflect.Value) []reflect.Value {
+		if len(args) == 0 {
+			return []reflect.Value{}
+		}
+		return args[:len(args)-1] // The last Value is an empty magic value.
+	}
+	for _, callFn := range abiMakeFuncTestCases {
+		fnTyp := reflect.TypeOf(callFn).In(0)
+		fn := reflect.MakeFunc(fnTyp, makeFuncHandler)
+		callFn := reflect.ValueOf(callFn)
+		t.Run(runtime.FuncForPC(callFn.Pointer()).Name(), func(t *testing.T) {
+			args := []reflect.Value{fn}
+			for i := 0; i < fnTyp.NumIn()-1; /* last one is magic type */ i++ {
+				args = append(args, genValue(t, fnTyp.In(i), r))
+			}
+			results := callFn.Call(args)
+			for i := range results {
+				x, y := args[i+1].Interface(), results[i].Interface()
+				if reflect.DeepEqual(x, y) {
+					continue
+				}
+				t.Errorf("arg and result %d differ: got %+v, want %+v", i, y, x)
+			}
+		})
+	}
+	t.Run("OnlyPointerInRegisterGC", func(t *testing.T) {
+		// This test attempts to induce a failure wherein
+		// the last pointer to an object is passed via registers.
+		// If makeFuncStub doesn't successfully store the pointer
+		// to a location visible to the GC, the object should be
+		// freed and then the next GC should notice that an object
+		// was inexplicably revived.
+		var f func(b *uint64, _ MagicLastTypeNameForTestingRegisterABI) *uint64
+		mkfn := reflect.MakeFunc(reflect.TypeOf(f), func(args []reflect.Value) []reflect.Value {
+			*(args[0].Interface().(*uint64)) = 5
+			return args[:1]
+		})
+		fn := mkfn.Interface().(func(*uint64, MagicLastTypeNameForTestingRegisterABI) *uint64)
+
+		// Call the MakeFunc'd function while trying pass the only pointer
+		// to a new heap-allocated uint64.
+		*reflect.CallGC = true
+		x := fn(new(uint64), MagicLastTypeNameForTestingRegisterABI{})
+		*reflect.CallGC = false
+
+		// Check for bad pointers (which should be x if things went wrong).
+		runtime.GC()
+
+		// Sanity check x.
+		if *x != 5 {
+			t.Fatalf("failed to set value in object")
+		}
+	})
+}
+
+var abiCallTestCases = []interface{}{
+	passNone,
+	passInt,
+	passInt8,
+	passInt16,
+	passInt32,
+	passInt64,
+	passUint,
+	passUint8,
+	passUint16,
+	passUint32,
+	passUint64,
+	passFloat32,
+	passFloat64,
+	passComplex64,
+	passComplex128,
+	passManyInt,
+	passManyFloat64,
+	passArray1,
+	passArray,
+	passArray1Mix,
+	passString,
+	// TODO(mknyszek): Test passing interface values.
+	passSlice,
+	passPointer,
+	passStruct1,
+	passStruct2,
+	passStruct3,
+	passStruct4,
+	passStruct5,
+	passStruct6,
+	passStruct7,
+	passStruct8,
+	passStruct9,
+	passStruct10,
+	// TODO(mknyszek): Test passing unsafe.Pointer values.
+	// TODO(mknyszek): Test passing chan values.
+	passStruct11,
+	passStruct12,
+	passStruct13,
+	pass2Struct1,
+	passEmptyStruct,
+	passStruct10AndSmall,
+}
+
+// Functions for testing reflect function call functionality.
 
 //go:registerparams
 //go:noinline
@@ -348,6 +541,278 @@ func passStruct10AndSmall(a Struct10, b byte, c uint) (Struct10, byte, uint) {
 	return a, b, c
 }
 
+var abiMakeFuncTestCases = []interface{}{
+	callArgsNone,
+	callArgsInt,
+	callArgsInt8,
+	callArgsInt16,
+	callArgsInt32,
+	callArgsInt64,
+	callArgsUint,
+	callArgsUint8,
+	callArgsUint16,
+	callArgsUint32,
+	callArgsUint64,
+	callArgsFloat32,
+	callArgsFloat64,
+	callArgsComplex64,
+	callArgsComplex128,
+	callArgsManyInt,
+	callArgsManyFloat64,
+	callArgsArray1,
+	callArgsArray,
+	callArgsArray1Mix,
+	callArgsString,
+	// TODO(mknyszek): Test callArgsing interface values.
+	callArgsSlice,
+	callArgsPointer,
+	callArgsStruct1,
+	callArgsStruct2,
+	callArgsStruct3,
+	callArgsStruct4,
+	callArgsStruct5,
+	callArgsStruct6,
+	callArgsStruct7,
+	callArgsStruct8,
+	callArgsStruct9,
+	callArgsStruct10,
+	// TODO(mknyszek): Test callArgsing unsafe.Pointer values.
+	// TODO(mknyszek): Test callArgsing chan values.
+	callArgsStruct11,
+	callArgsStruct12,
+	callArgsStruct13,
+	callArgs2Struct1,
+	callArgsEmptyStruct,
+}
+
+//go:registerparams
+//go:noinline
+func callArgsNone(f func(MagicLastTypeNameForTestingRegisterABI)) {
+	f(MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsInt(f func(int, MagicLastTypeNameForTestingRegisterABI) int, a0 int) int {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsInt8(f func(int8, MagicLastTypeNameForTestingRegisterABI) int8, a0 int8) int8 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsInt16(f func(int16, MagicLastTypeNameForTestingRegisterABI) int16, a0 int16) int16 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsInt32(f func(int32, MagicLastTypeNameForTestingRegisterABI) int32, a0 int32) int32 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsInt64(f func(int64, MagicLastTypeNameForTestingRegisterABI) int64, a0 int64) int64 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsUint(f func(uint, MagicLastTypeNameForTestingRegisterABI) uint, a0 uint) uint {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsUint8(f func(uint8, MagicLastTypeNameForTestingRegisterABI) uint8, a0 uint8) uint8 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsUint16(f func(uint16, MagicLastTypeNameForTestingRegisterABI) uint16, a0 uint16) uint16 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsUint32(f func(uint32, MagicLastTypeNameForTestingRegisterABI) uint32, a0 uint32) uint32 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsUint64(f func(uint64, MagicLastTypeNameForTestingRegisterABI) uint64, a0 uint64) uint64 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsFloat32(f func(float32, MagicLastTypeNameForTestingRegisterABI) float32, a0 float32) float32 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsFloat64(f func(float64, MagicLastTypeNameForTestingRegisterABI) float64, a0 float64) float64 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsComplex64(f func(complex64, MagicLastTypeNameForTestingRegisterABI) complex64, a0 complex64) complex64 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsComplex128(f func(complex128, MagicLastTypeNameForTestingRegisterABI) complex128, a0 complex128) complex128 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsArray1(f func([1]uint32, MagicLastTypeNameForTestingRegisterABI) [1]uint32, a0 [1]uint32) [1]uint32 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsArray(f func([2]uintptr, MagicLastTypeNameForTestingRegisterABI) [2]uintptr, a0 [2]uintptr) [2]uintptr {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsArray1Mix(f func(int, [1]uint32, float64, MagicLastTypeNameForTestingRegisterABI) (int, [1]uint32, float64), a0 int, a1 [1]uint32, a2 float64) (int, [1]uint32, float64) {
+	return f(a0, a1, a2, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsString(f func(string, MagicLastTypeNameForTestingRegisterABI) string, a0 string) string {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsSlice(f func([]byte, MagicLastTypeNameForTestingRegisterABI) []byte, a0 []byte) []byte {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsPointer(f func(*byte, MagicLastTypeNameForTestingRegisterABI) *byte, a0 *byte) *byte {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsManyInt(f func(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9 int, x MagicLastTypeNameForTestingRegisterABI) (r0, r1, r2, r3, r4, r5, r6, r7, r8, r9 int), a0, a1, a2, a3, a4, a5, a6, a7, a8, a9 int) (int, int, int, int, int, int, int, int, int, int) {
+	return f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsManyFloat64(f func(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18 float64, x MagicLastTypeNameForTestingRegisterABI) (r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18 float64), a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18 float64) (r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18 float64) {
+	return f(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsStruct1(f func(Struct1, MagicLastTypeNameForTestingRegisterABI) Struct1, a0 Struct1) Struct1 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsStruct2(f func(Struct2, MagicLastTypeNameForTestingRegisterABI) Struct2, a0 Struct2) Struct2 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsStruct3(f func(Struct3, MagicLastTypeNameForTestingRegisterABI) Struct3, a0 Struct3) Struct3 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsStruct4(f func(Struct4, MagicLastTypeNameForTestingRegisterABI) Struct4, a0 Struct4) Struct4 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsStruct5(f func(Struct5, MagicLastTypeNameForTestingRegisterABI) Struct5, a0 Struct5) Struct5 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsStruct6(f func(Struct6, MagicLastTypeNameForTestingRegisterABI) Struct6, a0 Struct6) Struct6 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsStruct7(f func(Struct7, MagicLastTypeNameForTestingRegisterABI) Struct7, a0 Struct7) Struct7 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsStruct8(f func(Struct8, MagicLastTypeNameForTestingRegisterABI) Struct8, a0 Struct8) Struct8 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsStruct9(f func(Struct9, MagicLastTypeNameForTestingRegisterABI) Struct9, a0 Struct9) Struct9 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsStruct10(f func(Struct10, MagicLastTypeNameForTestingRegisterABI) Struct10, a0 Struct10) Struct10 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsStruct11(f func(Struct11, MagicLastTypeNameForTestingRegisterABI) Struct11, a0 Struct11) Struct11 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsStruct12(f func(Struct12, MagicLastTypeNameForTestingRegisterABI) Struct12, a0 Struct12) Struct12 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsStruct13(f func(Struct13, MagicLastTypeNameForTestingRegisterABI) Struct13, a0 Struct13) Struct13 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgs2Struct1(f func(Struct1, Struct1, MagicLastTypeNameForTestingRegisterABI) (Struct1, Struct1), a0, a1 Struct1) (r0, r1 Struct1) {
+	return f(a0, a1, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsEmptyStruct(f func(int, struct{}, float64, MagicLastTypeNameForTestingRegisterABI) (int, struct{}, float64), a0 int, a1 struct{}, a2 float64) (int, struct{}, float64) {
+	return f(a0, a1, a2, MagicLastTypeNameForTestingRegisterABI{})
+}
+
 // Struct1 is a simple integer-only aggregate struct.
 type Struct1 struct {
 	A, B, C uint
diff --git a/src/reflect/asm_386.s b/src/reflect/asm_386.s
index e79beb6dc9..5bedea5807 100644
--- a/src/reflect/asm_386.s
+++ b/src/reflect/asm_386.s
@@ -9,14 +9,15 @@
 // See the comment on the declaration of makeFuncStub in makefunc.go
 // for more details.
 // No argsize here, gc generates argsize info at call site.
-TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$16
+TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$20
 	NO_LOCAL_POINTERS
 	MOVL	DX, 0(SP)
 	LEAL	argframe+0(FP), CX
 	MOVL	CX, 4(SP)
-	MOVB	$0, 12(SP)
-	LEAL	12(SP), AX
+	MOVB	$0, 16(SP)
+	LEAL	16(SP), AX
 	MOVL	AX, 8(SP)
+	MOVL	$0, 12(SP)
 	CALL	·callReflect(SB)
 	RET
 
@@ -24,13 +25,14 @@ TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$16
 // See the comment on the declaration of methodValueCall in makefunc.go
 // for more details.
 // No argsize here, gc generates argsize info at call site.
-TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$16
+TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$20
 	NO_LOCAL_POINTERS
 	MOVL	DX, 0(SP)
 	LEAL	argframe+0(FP), CX
 	MOVL	CX, 4(SP)
-	MOVB	$0, 12(SP)
-	LEAL	12(SP), AX
+	MOVB	$0, 16(SP)
+	LEAL	16(SP), AX
 	MOVL	AX, 8(SP)
+	MOVL	$0, 12(SP)
 	CALL	·callMethod(SB)
 	RET
diff --git a/src/reflect/asm_amd64.s b/src/reflect/asm_amd64.s
index 5c8e56558c..29693042b6 100644
--- a/src/reflect/asm_amd64.s
+++ b/src/reflect/asm_amd64.s
@@ -4,6 +4,21 @@
 
 #include "textflag.h"
 #include "funcdata.h"
+#include "go_asm.h"
+
+// The frames of each of the two functions below contain two locals, at offsets
+// that are known to the runtime.
+//
+// The first local is a bool called retValid with a whole pointer-word reserved
+// for it on the stack. The purpose of this word is so that the runtime knows
+// whether the stack-allocated return space contains valid values for stack
+// scanning.
+//
+// The second local is an abi.RegArgs value whose offset is also known to the
+// runtime, so that a stack map for it can be constructed, since it contains
+// pointers visible to the GC.
+#define LOCAL_RETVALID 32
+#define LOCAL_REGARGS 40
 
 // makeFuncStub is the code half of the function returned by MakeFunc.
 // See the comment on the declaration of makeFuncStub in makefunc.go
@@ -11,15 +26,26 @@
 // No arg size here; runtime pulls arg map out of the func value.
 // makeFuncStub must be ABIInternal because it is placed directly
 // in function values.
-TEXT ·makeFuncStub<ABIInternal>(SB),(NOSPLIT|WRAPPER),$32
+// This frame contains two locals. See the comment above LOCAL_RETVALID.
+TEXT ·makeFuncStub<ABIInternal>(SB),(NOSPLIT|WRAPPER),$312
 	NO_LOCAL_POINTERS
+	// NO_LOCAL_POINTERS is a lie. The stack map for the two locals in this
+	// frame is specially handled in the runtime. See the comment above LOCAL_RETVALID.
+	LEAQ	LOCAL_REGARGS(SP), R12
+	CALL	runtime·spillArgs<ABIInternal>(SB)
 	MOVQ	DX, 0(SP)
+	MOVQ	R12, 8(SP)
+	CALL	·moveMakeFuncArgPtrs(SB)
 	LEAQ	argframe+0(FP), CX
 	MOVQ	CX, 8(SP)
-	MOVB	$0, 24(SP)
-	LEAQ	24(SP), AX
+	MOVB	$0, LOCAL_RETVALID(SP)
+	LEAQ	LOCAL_RETVALID(SP), AX
 	MOVQ	AX, 16(SP)
+	LEAQ	LOCAL_REGARGS(SP), AX
+	MOVQ	AX, 24(SP)
 	CALL	·callReflect<ABIInternal>(SB)
+	LEAQ	LOCAL_REGARGS(SP), R12
+	CALL	runtime·unspillArgs<ABIInternal>(SB)
 	RET
 
 // methodValueCall is the code half of the function returned by makeMethodValue.
@@ -28,13 +54,24 @@ TEXT ·makeFuncStub<ABIInternal>(SB),(NOSPLIT|WRAPPER),$32
 // No arg size here; runtime pulls arg map out of the func value.
 // methodValueCall must be ABIInternal because it is placed directly
 // in function values.
-TEXT ·methodValueCall<ABIInternal>(SB),(NOSPLIT|WRAPPER),$32
+// This frame contains two locals. See the comment above LOCAL_RETVALID.
+TEXT ·methodValueCall<ABIInternal>(SB),(NOSPLIT|WRAPPER),$312
 	NO_LOCAL_POINTERS
+	// NO_LOCAL_POINTERS is a lie. The stack map for the two locals in this
+	// frame is specially handled in the runtime. See the comment above LOCAL_RETVALID.
+	LEAQ	LOCAL_REGARGS(SP), R12
+	CALL	runtime·spillArgs<ABIInternal>(SB)
 	MOVQ	DX, 0(SP)
+	MOVQ	R12, 8(SP)
+	CALL	·moveMakeFuncArgPtrs(SB)
 	LEAQ	argframe+0(FP), CX
 	MOVQ	CX, 8(SP)
-	MOVB	$0, 24(SP)
-	LEAQ	24(SP), AX
+	MOVB	$0, LOCAL_RETVALID(SP)
+	LEAQ	LOCAL_RETVALID(SP), AX
 	MOVQ	AX, 16(SP)
+	LEAQ	LOCAL_REGARGS(SP), AX
+	MOVQ	AX, 24(SP)
 	CALL	·callMethod<ABIInternal>(SB)
+	LEAQ	LOCAL_REGARGS(SP), R12
+	CALL	runtime·unspillArgs<ABIInternal>(SB)
 	RET
diff --git a/src/reflect/asm_arm.s b/src/reflect/asm_arm.s
index cd50d33918..057c941f59 100644
--- a/src/reflect/asm_arm.s
+++ b/src/reflect/asm_arm.s
@@ -9,15 +9,17 @@
 // See the comment on the declaration of makeFuncStub in makefunc.go
 // for more details.
 // No argsize here, gc generates argsize info at call site.
-TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$16
+TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$20
 	NO_LOCAL_POINTERS
 	MOVW	R7, 4(R13)
 	MOVW	$argframe+0(FP), R1
 	MOVW	R1, 8(R13)
 	MOVW	$0, R1
-	MOVB	R1, 16(R13)
-	ADD	$16, R13, R1
+	MOVB	R1, 20(R13)
+	ADD	$20, R13, R1
 	MOVW	R1, 12(R13)
+	MOVW	$0, R1
+	MOVW	R1, 16(R13)
 	BL	·callReflect(SB)
 	RET
 
@@ -25,14 +27,16 @@ TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$16
 // See the comment on the declaration of methodValueCall in makefunc.go
 // for more details.
 // No argsize here, gc generates argsize info at call site.
-TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$16
+TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$20
 	NO_LOCAL_POINTERS
 	MOVW	R7, 4(R13)
 	MOVW	$argframe+0(FP), R1
 	MOVW	R1, 8(R13)
 	MOVW	$0, R1
-	MOVB	R1, 16(R13)
-	ADD	$16, R13, R1
+	MOVB	R1, 20(R13)
+	ADD	$20, R13, R1
 	MOVW	R1, 12(R13)
+	MOVW	$0, R1
+	MOVW	R1, 16(R13)
 	BL	·callMethod(SB)
 	RET
diff --git a/src/reflect/asm_arm64.s b/src/reflect/asm_arm64.s
index 28bb86c2a4..5fe88e27e4 100644
--- a/src/reflect/asm_arm64.s
+++ b/src/reflect/asm_arm64.s
@@ -14,9 +14,10 @@ TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$40
 	MOVD	R26, 8(RSP)
 	MOVD	$argframe+0(FP), R3
 	MOVD	R3, 16(RSP)
-	MOVB	$0, 32(RSP)
-	ADD	$32, RSP, R3
+	MOVB	$0, 40(RSP)
+	ADD	$40, RSP, R3
 	MOVD	R3, 24(RSP)
+	MOVD	$0, 32(RSP)
 	BL	·callReflect(SB)
 	RET
 
@@ -29,8 +30,9 @@ TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$40
 	MOVD	R26, 8(RSP)
 	MOVD	$argframe+0(FP), R3
 	MOVD	R3, 16(RSP)
-	MOVB	$0, 32(RSP)
-	ADD	$32, RSP, R3
+	MOVB	$0, 40(RSP)
+	ADD	$40, RSP, R3
 	MOVD	R3, 24(RSP)
+	MOVD	$0, 32(RSP)
 	BL	·callMethod(SB)
 	RET
diff --git a/src/reflect/asm_mips64x.s b/src/reflect/asm_mips64x.s
index 6f76685567..0a660a5a60 100644
--- a/src/reflect/asm_mips64x.s
+++ b/src/reflect/asm_mips64x.s
@@ -13,14 +13,15 @@
 // See the comment on the declaration of makeFuncStub in makefunc.go
 // for more details.
 // No arg size here, runtime pulls arg map out of the func value.
-TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$32
+TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$40
 	NO_LOCAL_POINTERS
 	MOVV	REGCTXT, 8(R29)
 	MOVV	$argframe+0(FP), R1
 	MOVV	R1, 16(R29)
-	MOVB	R0, 32(R29)
-	ADDV	$32, R29, R1
+	MOVB	R0, 40(R29)
+	ADDV	$40, R29, R1
 	MOVV	R1, 24(R29)
+	MOVV	R0, 32(R29)
 	JAL	·callReflect(SB)
 	RET
 
@@ -33,8 +34,9 @@ TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$32
 	MOVV	REGCTXT, 8(R29)
 	MOVV	$argframe+0(FP), R1
 	MOVV	R1, 16(R29)
-	MOVB	R0, 32(R29)
-	ADDV	$32, R29, R1
+	MOVB	R0, 40(R29)
+	ADDV	$40, R29, R1
 	MOVV	R1, 24(R29)
+	MOVV	R0, 32(R29)
 	JAL	·callMethod(SB)
 	RET
diff --git a/src/reflect/asm_mipsx.s b/src/reflect/asm_mipsx.s
index 5a5c53ef9f..47fef844a1 100644
--- a/src/reflect/asm_mipsx.s
+++ b/src/reflect/asm_mipsx.s
@@ -13,14 +13,15 @@
 // See the comment on the declaration of makeFuncStub in makefunc.go
 // for more details.
 // No arg size here, runtime pulls arg map out of the func value.
-TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$16
+TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$20
 	NO_LOCAL_POINTERS
 	MOVW	REGCTXT, 4(R29)
 	MOVW	$argframe+0(FP), R1
 	MOVW	R1, 8(R29)
-	MOVB	R0, 16(R29)
-	ADD	$16, R29, R1
+	MOVB	R0, 20(R29)
+	ADD	$20, R29, R1
 	MOVW	R1, 12(R29)
+	MOVW	R0, 16(R29)
 	JAL	·callReflect(SB)
 	RET
 
@@ -28,13 +29,14 @@ TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$16
 // See the comment on the declaration of methodValueCall in makefunc.go
 // for more details.
 // No arg size here; runtime pulls arg map out of the func value.
-TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$16
+TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$20
 	NO_LOCAL_POINTERS
 	MOVW	REGCTXT, 4(R29)
 	MOVW	$argframe+0(FP), R1
 	MOVW	R1, 8(R29)
-	MOVB	R0, 16(R29)
-	ADD	$16, R29, R1
+	MOVB	R0, 20(R29)
+	ADD	$20, R29, R1
 	MOVW	R1, 12(R29)
+	MOVW	R0, 16(R29)
 	JAL	·callMethod(SB)
 	RET
diff --git a/src/reflect/asm_ppc64x.s b/src/reflect/asm_ppc64x.s
index 4609f6bb75..010811c31a 100644
--- a/src/reflect/asm_ppc64x.s
+++ b/src/reflect/asm_ppc64x.s
@@ -12,14 +12,15 @@
 // See the comment on the declaration of makeFuncStub in makefunc.go
 // for more details.
 // No arg size here, runtime pulls arg map out of the func value.
-TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$32
+TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$40
 	NO_LOCAL_POINTERS
 	MOVD	R11, FIXED_FRAME+0(R1)
 	MOVD	$argframe+0(FP), R3
 	MOVD	R3, FIXED_FRAME+8(R1)
-	MOVB	R0, FIXED_FRAME+24(R1)
-	ADD	$FIXED_FRAME+24, R1, R3
+	MOVB	R0, FIXED_FRAME+32(R1)
+	ADD	$FIXED_FRAME+32, R1, R3
 	MOVD	R3, FIXED_FRAME+16(R1)
+	MOVD	R0, FIXED_FRAME+24(R1)
 	BL	·callReflect(SB)
 	RET
 
@@ -27,13 +28,14 @@ TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$32
 // See the comment on the declaration of methodValueCall in makefunc.go
 // for more details.
 // No arg size here; runtime pulls arg map out of the func value.
-TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$32
+TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$40
 	NO_LOCAL_POINTERS
 	MOVD	R11, FIXED_FRAME+0(R1)
 	MOVD	$argframe+0(FP), R3
 	MOVD	R3, FIXED_FRAME+8(R1)
-	MOVB	R0, FIXED_FRAME+24(R1)
-	ADD	$FIXED_FRAME+24, R1, R3
+	MOVB	R0, FIXED_FRAME+32(R1)
+	ADD	$FIXED_FRAME+32, R1, R3
 	MOVD	R3, FIXED_FRAME+16(R1)
+	MOVD	R0, FIXED_FRAME+24(R1)
 	BL	·callMethod(SB)
 	RET
diff --git a/src/reflect/asm_riscv64.s b/src/reflect/asm_riscv64.s
index e6fab39874..e707112277 100644
--- a/src/reflect/asm_riscv64.s
+++ b/src/reflect/asm_riscv64.s
@@ -9,14 +9,15 @@
 // See the comment on the declaration of makeFuncStub in makefunc.go
 // for more details.
 // No arg size here, runtime pulls arg map out of the func value.
-TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$32
+TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$40
 	NO_LOCAL_POINTERS
 	MOV	CTXT, 8(SP)
 	MOV	$argframe+0(FP), T0
 	MOV	T0, 16(SP)
-	ADD	$32, SP, T1
+	ADD	$40, SP, T1
 	MOV	T1, 24(SP)
-	MOVB	ZERO, 32(SP)
+	MOV	ZERO, 32(SP)
+	MOVB	ZERO, 40(SP)
 	CALL	·callReflect(SB)
 	RET
 
@@ -24,13 +25,14 @@ TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$32
 // See the comment on the declaration of methodValueCall in makefunc.go
 // for more details.
 // No arg size here; runtime pulls arg map out of the func value.
-TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$32
+TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$40
 	NO_LOCAL_POINTERS
 	MOV	CTXT, 8(SP)
 	MOV	$argframe+0(FP), T0
 	MOV	T0, 16(SP)
-	ADD	$32, SP, T1
+	ADD	$40, SP, T1
 	MOV	T1, 24(SP)
-	MOVB	ZERO, 32(SP)
+	MOV	ZERO, 32(SP)
+	MOVB	ZERO, 40(SP)
 	CALL	·callMethod(SB)
 	RET
diff --git a/src/reflect/asm_s390x.s b/src/reflect/asm_s390x.s
index cb7954c900..4bd6613004 100644
--- a/src/reflect/asm_s390x.s
+++ b/src/reflect/asm_s390x.s
@@ -9,14 +9,15 @@
 // See the comment on the declaration of makeFuncStub in makefunc.go
 // for more details.
 // No arg size here, runtime pulls arg map out of the func value.
-TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$32
+TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$40
 	NO_LOCAL_POINTERS
 	MOVD	R12, 8(R15)
 	MOVD	$argframe+0(FP), R3
 	MOVD	R3, 16(R15)
-	MOVB	$0, 32(R15)
-	ADD	$32, R15, R3
+	MOVB	$0, 40(R15)
+	ADD	$40, R15, R3
 	MOVD	R3, 24(R15)
+	MOVD	$0, 32(R15)
 	BL	·callReflect(SB)
 	RET
 
@@ -24,13 +25,14 @@ TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$32
 // See the comment on the declaration of methodValueCall in makefunc.go
 // for more details.
 // No arg size here; runtime pulls arg map out of the func value.
-TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$32
+TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$40
 	NO_LOCAL_POINTERS
 	MOVD	R12, 8(R15)
 	MOVD	$argframe+0(FP), R3
 	MOVD	R3, 16(R15)
-	MOVB	$0, 32(R15)
-	ADD	$32, R15, R3
+	MOVB	$0, 40(R15)
+	ADD	$40, R15, R3
 	MOVD	R3, 24(R15)
+	MOVD	$0, 32(R15)
 	BL	·callMethod(SB)
 	RET
diff --git a/src/reflect/asm_wasm.s b/src/reflect/asm_wasm.s
index 63b4d94fca..71abe6700e 100644
--- a/src/reflect/asm_wasm.s
+++ b/src/reflect/asm_wasm.s
@@ -9,7 +9,7 @@
 // See the comment on the declaration of makeFuncStub in makefunc.go
 // for more details.
 // No arg size here; runtime pulls arg map out of the func value.
-TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$32
+TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$40
 	NO_LOCAL_POINTERS
 
 	MOVD CTXT, 0(SP)
@@ -21,8 +21,9 @@ TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$32
 	I64Add
 	I64Store $8
 
-	MOVB $0, 24(SP)
-	MOVD $24(SP), 16(SP)
+	MOVB $0, 32(SP)
+	MOVD $32(SP), 16(SP)
+	MOVD $0, 24(SP)
 
 	CALL ·callReflect(SB)
 	RET
@@ -31,7 +32,7 @@ TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$32
 // See the comment on the declaration of methodValueCall in makefunc.go
 // for more details.
 // No arg size here; runtime pulls arg map out of the func value.
-TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$32
+TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$40
 	NO_LOCAL_POINTERS
 
 	MOVD CTXT, 0(SP)
@@ -43,8 +44,9 @@ TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$32
 	I64Add
 	I64Store $8
 
-	MOVB $0, 24(SP)
-	MOVD $24(SP), 16(SP)
+	MOVB $0, 32(SP)
+	MOVD $32(SP), 16(SP)
+	MOVD $0, 24(SP)
 
 	CALL ·callMethod(SB)
 	RET
diff --git a/src/reflect/makefunc.go b/src/reflect/makefunc.go
index e17d4ea758..d53e68a359 100644
--- a/src/reflect/makefunc.go
+++ b/src/reflect/makefunc.go
@@ -7,6 +7,7 @@
 package reflect
 
 import (
+	"internal/abi"
 	"unsafe"
 )
 
@@ -16,11 +17,9 @@ import (
 // methodValue and runtime.reflectMethodValue.
 // Any changes should be reflected in all three.
 type makeFuncImpl struct {
-	code   uintptr
-	stack  *bitVector // ptrmap for both args and results
-	argLen uintptr    // just args
-	ftyp   *funcType
-	fn     func([]Value) []Value
+	makeFuncCtxt
+	ftyp *funcType
+	fn   func([]Value) []Value
 }
 
 // MakeFunc returns a new function of the given Type
@@ -62,7 +61,16 @@ func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value {
 	// makeFuncImpl contains a stack map for use by the runtime
 	_, _, abi := funcLayout(ftyp, nil)
 
-	impl := &makeFuncImpl{code: code, stack: abi.stackPtrs, argLen: abi.stackCallArgsSize, ftyp: ftyp, fn: fn}
+	impl := &makeFuncImpl{
+		makeFuncCtxt: makeFuncCtxt{
+			fn:      code,
+			stack:   abi.stackPtrs,
+			argLen:  abi.stackCallArgsSize,
+			regPtrs: abi.inRegPtrs,
+		},
+		ftyp: ftyp,
+		fn:   fn,
+	}
 
 	return Value{t, unsafe.Pointer(impl), flag(Func)}
 }
@@ -78,9 +86,7 @@ func makeFuncStub()
 // makeFuncImpl and runtime.reflectMethodValue.
 // Any changes should be reflected in all three.
 type methodValue struct {
-	fn     uintptr
-	stack  *bitVector // ptrmap for both args and results
-	argLen uintptr    // just args
+	makeFuncCtxt
 	method int
 	rcvr   Value
 }
@@ -113,11 +119,13 @@ func makeMethodValue(op string, v Value) Value {
 
 	// methodValue contains a stack map for use by the runtime
 	_, _, abi := funcLayout(ftyp, nil)
-
 	fv := &methodValue{
-		fn:     code,
-		stack:  abi.stackPtrs,
-		argLen: abi.stackCallArgsSize,
+		makeFuncCtxt: makeFuncCtxt{
+			fn:      code,
+			stack:   abi.stackPtrs,
+			argLen:  abi.stackCallArgsSize,
+			regPtrs: abi.inRegPtrs,
+		},
 		method: int(v.flag) >> flagMethodShift,
 		rcvr:   rcvr,
 	}
@@ -136,3 +144,37 @@ func makeMethodValue(op string, v Value) Value {
 // where ctxt is the context register and frame is a pointer to the first
 // word in the passed-in argument frame.
 func methodValueCall()
+
+// This structure must be kept in sync with runtime.reflectMethodValue.
+// Any changes should be reflected in all both.
+type makeFuncCtxt struct {
+	fn      uintptr
+	stack   *bitVector // ptrmap for both stack args and results
+	argLen  uintptr    // just args
+	regPtrs abi.IntArgRegBitmap
+}
+
+// moveMakeFuncArgPtrs uses ctxt.regPtrs to copy integer pointer arguments
+// in args.Ints to args.Ptrs where the GC can see them.
+//
+// This is similar to what reflectcallmove does in the runtime, except
+// that happens on the return path, whereas this happens on the call path.
+//
+// nosplit because pointers are being held in uintptr slots in args, so
+// having our stack scanned now could lead to accidentally freeing
+// memory.
+//go:nosplit
+func moveMakeFuncArgPtrs(ctxt *makeFuncCtxt, args *abi.RegArgs) {
+	for i, arg := range args.Ints {
+		// Avoid write barriers! Because our write barrier enqueues what
+		// was there before, we might enqueue garbage.
+		if ctxt.regPtrs.Get(i) {
+			*(*uintptr)(unsafe.Pointer(&args.Ptrs[i])) = arg
+		} else {
+			// We *must* zero this space ourselves because it's defined in
+			// assembly code and the GC will scan these pointers. Otherwise,
+			// there will be garbage here.
+			*(*uintptr)(unsafe.Pointer(&args.Ptrs[i])) = 0
+		}
+	}
+}
diff --git a/src/reflect/value.go b/src/reflect/value.go
index 52639d5aad..8afb1cc141 100644
--- a/src/reflect/value.go
+++ b/src/reflect/value.go
@@ -647,32 +647,81 @@ func (v Value) call(op string, in []Value) []Value {
 // frame is a pointer to the arguments to that closure on the stack.
 // retValid points to a boolean which should be set when the results
 // section of frame is set.
-func callReflect(ctxt *makeFuncImpl, frame unsafe.Pointer, retValid *bool) {
+//
+// regs contains the argument values passed in registers and will contain
+// the values returned from ctxt.fn in registers.
+func callReflect(ctxt *makeFuncImpl, frame unsafe.Pointer, retValid *bool, regs *abi.RegArgs) {
+	if callGC {
+		// Call GC upon entry during testing.
+		// Getting our stack scanned here is the biggest hazard, because
+		// our caller (makeFuncStub) could have failed to place the last
+		// pointer to a value in regs' pointer space, in which case it
+		// won't be visible to the GC.
+		runtime.GC()
+	}
 	ftyp := ctxt.ftyp
 	f := ctxt.fn
 
-	// Copy argument frame into Values.
+	_, _, abi := funcLayout(ftyp, nil)
+
+	// Copy arguments into Values.
 	ptr := frame
-	off := uintptr(0)
 	in := make([]Value, 0, int(ftyp.inCount))
-	for _, typ := range ftyp.in() {
-		off += -off & uintptr(typ.align-1)
+	for i, typ := range ftyp.in() {
+		if typ.Size() == 0 {
+			in = append(in, Zero(typ))
+			continue
+		}
 		v := Value{typ, nil, flag(typ.Kind())}
-		if ifaceIndir(typ) {
-			// value cannot be inlined in interface data.
-			// Must make a copy, because f might keep a reference to it,
-			// and we cannot let f keep a reference to the stack frame
-			// after this function returns, not even a read-only reference.
-			v.ptr = unsafe_New(typ)
-			if typ.size > 0 {
-				typedmemmove(typ, v.ptr, add(ptr, off, "typ.size > 0"))
+		steps := abi.call.stepsForValue(i)
+		if st := steps[0]; st.kind == abiStepStack {
+			if ifaceIndir(typ) {
+				// value cannot be inlined in interface data.
+				// Must make a copy, because f might keep a reference to it,
+				// and we cannot let f keep a reference to the stack frame
+				// after this function returns, not even a read-only reference.
+				v.ptr = unsafe_New(typ)
+				if typ.size > 0 {
+					typedmemmove(typ, v.ptr, add(ptr, st.stkOff, "typ.size > 0"))
+				}
+				v.flag |= flagIndir
+			} else {
+				v.ptr = *(*unsafe.Pointer)(add(ptr, st.stkOff, "1-ptr"))
 			}
-			v.flag |= flagIndir
 		} else {
-			v.ptr = *(*unsafe.Pointer)(add(ptr, off, "1-ptr"))
+			if ifaceIndir(typ) {
+				// All that's left is values passed in registers that we need to
+				// create space for the values.
+				v.flag |= flagIndir
+				v.ptr = unsafe_New(typ)
+				for _, st := range steps {
+					switch st.kind {
+					case abiStepIntReg:
+						offset := add(v.ptr, st.offset, "precomputed value offset")
+						memmove(offset, unsafe.Pointer(&regs.Ints[st.ireg]), st.size)
+					case abiStepPointer:
+						s := add(v.ptr, st.offset, "precomputed value offset")
+						*((*unsafe.Pointer)(s)) = regs.Ptrs[st.ireg]
+					case abiStepFloatReg:
+						offset := add(v.ptr, st.offset, "precomputed value offset")
+						memmove(offset, unsafe.Pointer(&regs.Floats[st.freg]), st.size)
+					case abiStepStack:
+						panic("register-based return value has stack component")
+					default:
+						panic("unknown ABI part kind")
+					}
+				}
+			} else {
+				// Pointer-valued data gets put directly
+				// into v.ptr.
+				if steps[0].kind != abiStepPointer {
+					print("kind=", steps[0].kind, ", type=", typ.String(), "\n")
+					panic("mismatch between ABI description and types")
+				}
+				v.ptr = regs.Ptrs[steps[0].ireg]
+			}
 		}
 		in = append(in, v)
-		off += typ.size
 	}
 
 	// Call underlying function.
@@ -682,9 +731,8 @@ func callReflect(ctxt *makeFuncImpl, frame unsafe.Pointer, retValid *bool) {
 		panic("reflect: wrong return count from function created by MakeFunc")
 	}
 
-	// Copy results back into argument frame.
+	// Copy results back into argument frame and register space.
 	if numOut > 0 {
-		off += -off & (ptrSize - 1)
 		for i, typ := range ftyp.out() {
 			v := out[i]
 			if v.typ == nil {
@@ -695,31 +743,67 @@ func callReflect(ctxt *makeFuncImpl, frame unsafe.Pointer, retValid *bool) {
 				panic("reflect: function created by MakeFunc using " + funcName(f) +
 					" returned value obtained from unexported field")
 			}
-			off += -off & uintptr(typ.align-1)
 			if typ.size == 0 {
 				continue
 			}
-			addr := add(ptr, off, "typ.size > 0")
 
 			// Convert v to type typ if v is assignable to a variable
 			// of type t in the language spec.
 			// See issue 28761.
-			if typ.Kind() == Interface {
-				// We must clear the destination before calling assignTo,
-				// in case assignTo writes (with memory barriers) to the
-				// target location used as scratch space. See issue 39541.
-				*(*uintptr)(addr) = 0
-				*(*uintptr)(add(addr, ptrSize, "typ.size == 2*ptrSize")) = 0
-			}
-			v = v.assignTo("reflect.MakeFunc", typ, addr)
-
-			// We are writing to stack. No write barrier.
-			if v.flag&flagIndir != 0 {
-				memmove(addr, v.ptr, typ.size)
-			} else {
-				*(*uintptr)(addr) = uintptr(v.ptr)
+			//
+			//
+			// TODO(mknyszek): In the switch to the register ABI we lost
+			// the scratch space here for the register cases (and
+			// temporarily for all the cases).
+			//
+			// If/when this happens, take note of the following:
+			//
+			// We must clear the destination before calling assignTo,
+			// in case assignTo writes (with memory barriers) to the
+			// target location used as scratch space. See issue 39541.
+			v = v.assignTo("reflect.MakeFunc", typ, nil)
+		stepsLoop:
+			for _, st := range abi.ret.stepsForValue(i) {
+				switch st.kind {
+				case abiStepStack:
+					// Copy values to the "stack."
+					addr := add(ptr, st.stkOff, "precomputed stack arg offset")
+					// Do not use write barriers. The stack space used
+					// for this call is not adequately zeroed, and we
+					// are careful to keep the arguments alive until we
+					// return to makeFuncStub's caller.
+					if v.flag&flagIndir != 0 {
+						memmove(addr, v.ptr, st.size)
+					} else {
+						// This case must be a pointer type.
+						*(*uintptr)(addr) = uintptr(v.ptr)
+					}
+					// There's only one step for a stack-allocated value.
+					break stepsLoop
+				case abiStepIntReg, abiStepPointer:
+					// Copy values to "integer registers."
+					if v.flag&flagIndir != 0 {
+						offset := add(v.ptr, st.offset, "precomputed value offset")
+						memmove(unsafe.Pointer(&regs.Ints[st.ireg]), offset, st.size)
+					} else {
+						// Only populate the Ints space on the return path.
+						// This is safe because out is kept alive until the
+						// end of this function, and the return path through
+						// makeFuncStub has no preemption, so these pointers
+						// are always visible to the GC.
+						regs.Ints[st.ireg] = uintptr(v.ptr)
+					}
+				case abiStepFloatReg:
+					// Copy values to "float registers."
+					if v.flag&flagIndir == 0 {
+						panic("attempted to copy pointer to FP register")
+					}
+					offset := add(v.ptr, st.offset, "precomputed value offset")
+					memmove(unsafe.Pointer(&regs.Floats[st.freg]), offset, st.size)
+				default:
+					panic("unknown ABI part kind")
+				}
 			}
-			off += typ.size
 		}
 	}
 
@@ -820,51 +904,147 @@ func align(x, n uintptr) uintptr {
 // frame is a pointer to the arguments to that closure on the stack.
 // retValid points to a boolean which should be set when the results
 // section of frame is set.
-func callMethod(ctxt *methodValue, frame unsafe.Pointer, retValid *bool) {
+//
+// regs contains the argument values passed in registers and will contain
+// the values returned from ctxt.fn in registers.
+func callMethod(ctxt *methodValue, frame unsafe.Pointer, retValid *bool, regs *abi.RegArgs) {
 	rcvr := ctxt.rcvr
-	rcvrtype, t, fn := methodReceiver("call", rcvr, ctxt.method)
-	frametype, framePool, abid := funcLayout(t, rcvrtype)
-	argSize, retOffset := abid.stackCallArgsSize, abid.retOffset
+	rcvrType, valueFuncType, methodFn := methodReceiver("call", rcvr, ctxt.method)
+
+	// There are two ABIs at play here.
+	//
+	// methodValueCall was invoked with the ABI assuming there was no
+	// receiver ("value ABI") and that's what frame and regs are holding.
+	//
+	// Meanwhile, we need to actually call the method with a receiver, which
+	// has its own ABI ("method ABI"). Everything that follows is a translation
+	// between the two.
+	_, _, valueABI := funcLayout(valueFuncType, nil)
+	valueFrame, valueRegs := frame, regs
+	methodFrameType, methodFramePool, methodABI := funcLayout(valueFuncType, rcvrType)
 
 	// Make a new frame that is one word bigger so we can store the receiver.
 	// This space is used for both arguments and return values.
-	scratch := framePool.Get().(unsafe.Pointer)
-
-	// Copy in receiver and rest of args.
-	storeRcvr(rcvr, scratch)
-	// Align the first arg. The alignment can't be larger than ptrSize.
-	argOffset := uintptr(ptrSize)
-	if len(t.in()) > 0 {
-		argOffset = align(argOffset, uintptr(t.in()[0].align))
+	methodFrame := methodFramePool.Get().(unsafe.Pointer)
+	var methodRegs abi.RegArgs
+
+	// Deal with the receiver. It's guaranteed to only be one word in size.
+	if st := methodABI.call.steps[0]; st.kind == abiStepStack {
+		// Only copy the reciever to the stack if the ABI says so.
+		// Otherwise, it'll be in a register already.
+		storeRcvr(rcvr, methodFrame)
+	} else {
+		// Put the receiver in a register.
+		storeRcvr(rcvr, unsafe.Pointer(&methodRegs.Ints))
 	}
-	// Avoid constructing out-of-bounds pointers if there are no args.
-	if argSize-argOffset > 0 {
-		typedmemmovepartial(frametype, add(scratch, argOffset, "argSize > argOffset"), frame, argOffset, argSize-argOffset)
+
+	// Translate the rest of the arguments.
+	for i, t := range valueFuncType.in() {
+		valueSteps := valueABI.call.stepsForValue(i)
+		methodSteps := methodABI.call.stepsForValue(i + 1)
+
+		// Zero-sized types are trivial: nothing to do.
+		if len(valueSteps) == 0 {
+			if len(methodSteps) != 0 {
+				panic("method ABI and value ABI do not align")
+			}
+			continue
+		}
+
+		// There are three cases to handle in translating each
+		// argument:
+		// 1. Stack -> stack translation.
+		// 2. Registers -> stack translation.
+		// 3. Registers -> registers translation.
+		// The fourth cases can't happen, because a method value
+		// call uses strictly fewer registers than a method call.
+
+		// If the value ABI passes the value on the stack,
+		// then the method ABI does too, because it has strictly
+		// fewer arguments. Simply copy between the two.
+		if vStep := valueSteps[0]; vStep.kind == abiStepStack {
+			mStep := methodSteps[0]
+			if mStep.kind != abiStepStack || vStep.size != mStep.size {
+				panic("method ABI and value ABI do not align")
+			}
+			typedmemmove(t,
+				add(methodFrame, mStep.stkOff, "precomputed stack offset"),
+				add(valueFrame, vStep.stkOff, "precomputed stack offset"))
+			continue
+		}
+		// Handle register -> stack translation.
+		if mStep := methodSteps[0]; mStep.kind == abiStepStack {
+			for _, vStep := range valueSteps {
+				to := add(methodFrame, mStep.stkOff+vStep.offset, "precomputed stack offset")
+				switch vStep.kind {
+				case abiStepPointer:
+					// Do the pointer copy directly so we get a write barrier.
+					*(*unsafe.Pointer)(to) = valueRegs.Ptrs[vStep.ireg]
+				case abiStepIntReg:
+					memmove(to, unsafe.Pointer(&valueRegs.Ints[vStep.ireg]), vStep.size)
+				case abiStepFloatReg:
+					memmove(to, unsafe.Pointer(&valueRegs.Floats[vStep.freg]), vStep.size)
+				default:
+					panic("unexpected value step")
+				}
+			}
+			continue
+		}
+		// Handle register -> register translation.
+		if len(valueSteps) != len(methodSteps) {
+			// Because it's the same type for the value, and it's assigned
+			// to registers both times, it should always take up the same
+			// number of registers for each ABI.
+			panic("method ABI and value ABI don't align")
+		}
+		for i, vStep := range valueSteps {
+			mStep := methodSteps[i]
+			if mStep.kind != vStep.kind {
+				panic("method ABI and value ABI don't align")
+			}
+			switch vStep.kind {
+			case abiStepPointer:
+				// Copy this too, so we get a write barrier.
+				methodRegs.Ptrs[mStep.ireg] = valueRegs.Ptrs[vStep.ireg]
+				fallthrough
+			case abiStepIntReg:
+				methodRegs.Ints[mStep.ireg] = valueRegs.Ints[vStep.ireg]
+			case abiStepFloatReg:
+				methodRegs.Floats[mStep.freg] = valueRegs.Floats[vStep.freg]
+			default:
+				panic("unexpected value step")
+			}
+		}
 	}
 
-	frameSize := frametype.size
+	methodFrameSize := methodFrameType.size
 	// TODO(mknyszek): Remove this when we no longer have
 	// caller reserved spill space.
-	frameSize = align(frameSize, ptrSize)
-	frameSize += abid.spill
+	methodFrameSize = align(methodFrameSize, ptrSize)
+	methodFrameSize += methodABI.spill
 
 	// Call.
 	// Call copies the arguments from scratch to the stack, calls fn,
 	// and then copies the results back into scratch.
-	//
-	// TODO(mknyszek): Have this actually support the register-based ABI.
-	var regs abi.RegArgs
-	call(frametype, fn, scratch, uint32(frametype.size), uint32(retOffset), uint32(frameSize), &regs)
+	call(methodFrameType, methodFn, methodFrame, uint32(methodFrameType.size), uint32(methodABI.retOffset), uint32(methodFrameSize), &methodRegs)
 
 	// Copy return values.
-	// Ignore any changes to args and just copy return values.
+	//
+	// This is somewhat simpler because both ABIs have an identical
+	// return value ABI (the types are identical). As a result, register
+	// results can simply be copied over. Stack-allocated values are laid
+	// out the same, but are at different offsets from the start of the frame
+	// Ignore any changes to args.
 	// Avoid constructing out-of-bounds pointers if there are no return values.
-	if frametype.size-retOffset > 0 {
-		callerRetOffset := retOffset - argOffset
+	// because the arguments may be laid out differently.
+	if valueRegs != nil {
+		*valueRegs = methodRegs
+	}
+	if retSize := methodFrameType.size - methodABI.retOffset; retSize > 0 {
+		valueRet := add(valueFrame, valueABI.retOffset, "valueFrame's size > retOffset")
+		methodRet := add(methodFrame, methodABI.retOffset, "methodFrame's size > retOffset")
 		// This copies to the stack. Write barriers are not needed.
-		memmove(add(frame, callerRetOffset, "frametype.size > retOffset"),
-			add(scratch, retOffset, "frametype.size > retOffset"),
-			frametype.size-retOffset)
+		memmove(valueRet, methodRet, retSize)
 	}
 
 	// Tell the runtime it can now depend on the return values
@@ -874,8 +1054,8 @@ func callMethod(ctxt *methodValue, frame unsafe.Pointer, retValid *bool) {
 	// Clear the scratch space and put it back in the pool.
 	// This must happen after the statement above, so that the return
 	// values will always be scanned by someone.
-	typedmemclr(frametype, scratch)
-	framePool.Put(scratch)
+	typedmemclr(methodFrameType, methodFrame)
+	methodFramePool.Put(methodFrame)
 
 	// See the comment in callReflect.
 	runtime.KeepAlive(ctxt)
diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index 193d8f00bb..dbe7f7f381 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -473,7 +473,7 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0
 
 #ifdef GOEXPERIMENT_REGABI_REFLECT
 // spillArgs stores return values from registers to a *internal/abi.RegArgs in R12.
-TEXT spillArgs<>(SB),NOSPLIT,$0-0
+TEXT ·spillArgs<ABIInternal>(SB),NOSPLIT,$0-0
 	MOVQ AX, 0(R12)
 	MOVQ BX, 8(R12)
 	MOVQ CX, 16(R12)
@@ -501,7 +501,7 @@ TEXT spillArgs<>(SB),NOSPLIT,$0-0
 	RET
 
 // unspillArgs loads args into registers from a *internal/abi.RegArgs in R12.
-TEXT unspillArgs<>(SB),NOSPLIT,$0-0
+TEXT ·unspillArgs<ABIInternal>(SB),NOSPLIT,$0-0
 	MOVQ 0(R12), AX
 	MOVQ 8(R12), BX
 	MOVQ 16(R12), CX
@@ -529,11 +529,11 @@ TEXT unspillArgs<>(SB),NOSPLIT,$0-0
 	RET
 #else
 // spillArgs stores return values from registers to a pointer in R12.
-TEXT spillArgs<>(SB),NOSPLIT,$0-0
+TEXT ·spillArgs<ABIInternal>(SB),NOSPLIT,$0-0
 	RET
 
 // unspillArgs loads args into registers from a pointer in R12.
-TEXT unspillArgs<>(SB),NOSPLIT,$0-0
+TEXT ·unspillArgs<ABIInternal>(SB),NOSPLIT,$0-0
 	RET
 #endif
 
@@ -592,7 +592,7 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-48;		\
 	REP;MOVSB;				\
 	/* set up argument registers */		\
 	MOVQ    regArgs+40(FP), R12;		\
-	CALL    unspillArgs<>(SB);		\
+	CALL    ·unspillArgs<ABIInternal>(SB);		\
 	/* call function */			\
 	MOVQ	f+8(FP), DX;			\
 	PCDATA  $PCDATA_StackMapIndex, $0;	\
@@ -600,7 +600,7 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-48;		\
 	CALL	R12;				\
 	/* copy register return values back */		\
 	MOVQ    regArgs+40(FP), R12;		\
-	CALL    spillArgs<>(SB);		\
+	CALL    ·spillArgs<ABIInternal>(SB);		\
 	MOVLQZX	stackArgsSize+24(FP), CX;		\
 	MOVLQZX	stackRetOffset+28(FP), BX;		\
 	MOVQ	stackArgs+16(FP), DI;		\
diff --git a/src/runtime/stack.go b/src/runtime/stack.go
index 5c7fadc2d2..cdccdcc2c5 100644
--- a/src/runtime/stack.go
+++ b/src/runtime/stack.go
@@ -5,6 +5,7 @@
 package runtime
 
 import (
+	"internal/abi"
 	"internal/cpu"
 	"runtime/internal/atomic"
 	"runtime/internal/sys"
@@ -1312,23 +1313,42 @@ func getStackMap(frame *stkframe, cache *pcvalueCache, debug bool) (locals, args
 	}
 
 	// stack objects.
-	p := funcdata(f, _FUNCDATA_StackObjects)
-	if p != nil {
-		n := *(*uintptr)(p)
-		p = add(p, sys.PtrSize)
-		*(*slice)(unsafe.Pointer(&objs)) = slice{array: noescape(p), len: int(n), cap: int(n)}
-		// Note: the noescape above is needed to keep
-		// getStackMap from "leaking param content:
-		// frame".  That leak propagates up to getgcmask, then
-		// GCMask, then verifyGCInfo, which converts the stack
-		// gcinfo tests into heap gcinfo tests :(
+	if GOARCH == "amd64" && unsafe.Sizeof(abi.RegArgs{}) > 0 && frame.argmap != nil {
+		// argmap is set when the function is reflect.makeFuncStub or reflect.methodValueCall.
+		// We don't actually use argmap in this case, but we need to fake the stack object
+		// record for these frames which contain an internal/abi.RegArgs at a hard-coded offset
+		// on amd64.
+		objs = methodValueCallFrameObjs
+	} else {
+		p := funcdata(f, _FUNCDATA_StackObjects)
+		if p != nil {
+			n := *(*uintptr)(p)
+			p = add(p, sys.PtrSize)
+			*(*slice)(unsafe.Pointer(&objs)) = slice{array: noescape(p), len: int(n), cap: int(n)}
+			// Note: the noescape above is needed to keep
+			// getStackMap from "leaking param content:
+			// frame".  That leak propagates up to getgcmask, then
+			// GCMask, then verifyGCInfo, which converts the stack
+			// gcinfo tests into heap gcinfo tests :(
+		}
 	}
 
 	return
 }
 
+var (
+	abiRegArgsEface          interface{} = abi.RegArgs{}
+	abiRegArgsType           *_type      = efaceOf(&abiRegArgsEface)._type
+	methodValueCallFrameObjs             = []stackObjectRecord{
+		{
+			off: -int(alignUp(abiRegArgsType.size, 8)), // It's always the highest address local.
+			typ: abiRegArgsType,
+		},
+	}
+)
+
 // A stackObjectRecord is generated by the compiler for each stack object in a stack frame.
-// This record must match the generator code in cmd/compile/internal/gc/ssa.go:emitStackObjects.
+// This record must match the generator code in cmd/compile/internal/liveness/plive.go:emitStackObjects.
 type stackObjectRecord struct {
 	// offset in frame
 	// if negative, offset from varp
diff --git a/src/runtime/stubs_amd64.go b/src/runtime/stubs_amd64.go
index bf98493e9d..687a506cdd 100644
--- a/src/runtime/stubs_amd64.go
+++ b/src/runtime/stubs_amd64.go
@@ -40,3 +40,10 @@ func retpolineR15()
 
 //go:noescape
 func asmcgocall_no_g(fn, arg unsafe.Pointer)
+
+// Used by reflectcall and the reflect package.
+//
+// Spills/loads arguments in registers to/from an internal/abi.RegArgs
+// respectively. Does not follow the Go ABI.
+func spillArgs()
+func unspillArgs()
diff --git a/src/runtime/traceback.go b/src/runtime/traceback.go
index f8cda83098..0969af1a21 100644
--- a/src/runtime/traceback.go
+++ b/src/runtime/traceback.go
@@ -630,7 +630,7 @@ func getArgInfo(frame *stkframe, f funcInfo, needArgMap bool, ctxt *funcval) (ar
 				// Figure out whether the return values are valid.
 				// Reflect will update this value after it copies
 				// in the return values.
-				retValid = *(*bool)(unsafe.Pointer(arg0 + 3*sys.PtrSize))
+				retValid = *(*bool)(unsafe.Pointer(arg0 + 4*sys.PtrSize))
 			}
 			if mv.fn != f.entry {
 				print("runtime: confused by ", funcname(f), "\n")
-- 
GitLab


From 254948a50e12aac1059816a1575ccef1b3892723 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Fri, 2 Apr 2021 12:33:23 -0400
Subject: [PATCH 1335/2400] cmd/compile: mark unused values as invalid to
 prevent problems in expandCalls

Leftover values that have been replaced can cause problems in later
passes (within expandCalls).  For example, a struct select that
itself yields a struct will have a problematic rewrite, if the chance
is presented.

Updates #40724.

Change-Id: I1b445c47c301c3705f7fc0a9d39f1f5c84f4e190
Reviewed-on: https://go-review.googlesource.com/c/go/+/306869
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/ssa/expand_calls.go | 25 +++++++++++++-
 test/abi/zombie_struct_select.go             | 36 ++++++++++++++++++++
 2 files changed, 60 insertions(+), 1 deletion(-)
 create mode 100644 test/abi/zombie_struct_select.go

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index a5fe6f4d29..b6683d076d 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -941,6 +941,11 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, source, mem *Value,
 // stores (or later, register movement).  Extra args for interface and closure calls are ignored,
 // but removed.
 func (x *expandState) rewriteArgs(v *Value, firstArg int) (*Value, []*Value) {
+	if x.debug {
+		x.indent(3)
+		defer x.indent(-3)
+		x.Printf("rewriteArgs(%s; %d)\n", v.LongString(), firstArg)
+	}
 	// Thread the stores on the memory arg
 	aux := v.Aux.(*AuxCall)
 	pos := v.Pos.WithNotStmt()
@@ -969,7 +974,7 @@ func (x *expandState) rewriteArgs(v *Value, firstArg int) (*Value, []*Value) {
 				aOffset = aux.OffsetOfArg(auxI)
 			}
 			if x.debug {
-				x.Printf("storeArg %s, %v, %d\n", a.LongString(), aType, aOffset)
+				x.Printf("...storeArg %s, %v, %d\n", a.LongString(), aType, aOffset)
 			}
 			rc.init(aRegs, aux.abiInfo, result, x.sp)
 			mem = x.storeArgOrLoad(pos, v.Block, a, mem, aType, aOffset, 0, rc)
@@ -1056,6 +1061,7 @@ func expandCalls(f *Func) {
 			}
 		}
 		if isBlockMultiValueExit(b) {
+			x.indent(3)
 			// Very similar to code in rewriteArgs, but results instead of args.
 			v := b.Controls[0]
 			m0 := v.MemoryArg()
@@ -1063,7 +1069,12 @@ func expandCalls(f *Func) {
 			aux := f.OwnAux
 			pos := v.Pos.WithNotStmt()
 			allResults := []*Value{}
+			if x.debug {
+				x.Printf("multiValueExit rewriting %s\n", v.LongString())
+			}
+			var oldArgs []*Value
 			for j, a := range v.Args[:len(v.Args)-1] {
+				oldArgs = append(oldArgs, a)
 				i := int64(j)
 				auxType := aux.TypeOfResult(i)
 				auxBase := b.NewValue2A(v.Pos, OpLocalAddr, types.NewPtr(auxType), aux.NameOfResult(i), x.sp, mem)
@@ -1101,6 +1112,18 @@ func expandCalls(f *Func) {
 			v.AddArg(mem)
 			v.Type = types.NewResults(append(abi.RegisterTypes(aux.abiInfo.OutParams()), types.TypeMem))
 			b.SetControl(v)
+			for _, a := range oldArgs {
+				if a.Uses == 0 {
+					if x.debug {
+						x.Printf("...marking %v unused\n", a.LongString())
+					}
+					a.reset(OpInvalid)
+				}
+			}
+			if x.debug {
+				x.Printf("...multiValueExit new result %s\n", v.LongString())
+			}
+			x.indent(-3)
 		}
 	}
 
diff --git a/test/abi/zombie_struct_select.go b/test/abi/zombie_struct_select.go
new file mode 100644
index 0000000000..d0cab98182
--- /dev/null
+++ b/test/abi/zombie_struct_select.go
@@ -0,0 +1,36 @@
+// run
+
+// Copyright 2021 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
+
+type patchlist struct {
+	head, tail uint32
+}
+
+type frag struct {
+	i   uint32
+	out patchlist
+}
+
+//go:noinline
+//go:registerparams
+func patch(l patchlist, i uint32) {
+}
+
+//go:noinline
+//go:registerparams
+func badbad(f1, f2 frag) frag {
+	// concat of failure is failure
+	if f1.i == 0 || f2.i == 0 { // internal compiler error: 'badbad': incompatible OpArgIntReg [4]: v42 and v26
+		return frag{}
+	}
+	patch(f1.out, f2.i)
+	return frag{f1.i, f2.out}
+}
+
+func main() {
+	badbad(frag{i: 2}, frag{i: 3})
+}
-- 
GitLab


From 34b87b4a1ab7562858baf74f2320ab881214229e Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Fri, 2 Apr 2021 18:58:56 +0000
Subject: [PATCH 1336/2400] reflect: remove short-circuits for zero-sized types
 in ABI algorithm

This change removes two short-circuits for zero-sized types (zero-sized
structs and zero-sized struct fields) in the recursive cases of the ABI
algorithm, because this does not match the spec's algorithm, nor the
compiler's algorithm.

The failing case here is a struct with a field that is an array of
non-zero length but whose element type is zero-sized. This struct must
be stack-assigned because of the array, according to the algorithm.
The reflect package was register-assigning it.

Because there were two short-circuits, this can also appear if a struct
has a field that is a zero-sized struct but contains such an array,
also.

This change adds regression tests for both of these cases.

For #44816.
For #40724.

Change-Id: I956804170962448197a1c9853826e3436fc8b1ea
Reviewed-on: https://go-review.googlesource.com/c/go/+/306929
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/reflect/abi.go      | 10 ---------
 src/reflect/abi_test.go | 47 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 47 insertions(+), 10 deletions(-)

diff --git a/src/reflect/abi.go b/src/reflect/abi.go
index 8b1aaa56b3..6a422d06d1 100644
--- a/src/reflect/abi.go
+++ b/src/reflect/abi.go
@@ -233,19 +233,9 @@ func (a *abiSeq) regAssign(t *rtype, offset uintptr) bool {
 			return false
 		}
 	case Struct:
-		if t.size == 0 {
-			// There's nothing to assign, so don't modify
-			// a.steps but succeed so the caller doesn't
-			// try to stack-assign this value.
-			return true
-		}
 		st := (*structType)(unsafe.Pointer(t))
 		for i := range st.fields {
 			f := &st.fields[i]
-			if f.typ.Size() == 0 {
-				// Ignore zero-sized fields.
-				continue
-			}
 			if !a.regAssign(f.typ, offset+f.offset()) {
 				return false
 			}
diff --git a/src/reflect/abi_test.go b/src/reflect/abi_test.go
index 998faee0de..62f6bd2e3e 100644
--- a/src/reflect/abi_test.go
+++ b/src/reflect/abi_test.go
@@ -300,6 +300,8 @@ var abiCallTestCases = []interface{}{
 	passStruct11,
 	passStruct12,
 	passStruct13,
+	passStruct14,
+	passStruct15,
 	pass2Struct1,
 	passEmptyStruct,
 	passStruct10AndSmall,
@@ -521,6 +523,18 @@ func passStruct13(a Struct13) Struct13 {
 	return a
 }
 
+//go:registerparams
+//go:noinline
+func passStruct14(a Struct14) Struct14 {
+	return a
+}
+
+//go:registerparams
+//go:noinline
+func passStruct15(a Struct15) Struct15 {
+	return a
+}
+
 //go:registerparams
 //go:noinline
 func pass2Struct1(a, b Struct1) (x, y Struct1) {
@@ -581,6 +595,8 @@ var abiMakeFuncTestCases = []interface{}{
 	callArgsStruct11,
 	callArgsStruct12,
 	callArgsStruct13,
+	callArgsStruct14,
+	callArgsStruct15,
 	callArgs2Struct1,
 	callArgsEmptyStruct,
 }
@@ -801,6 +817,18 @@ func callArgsStruct13(f func(Struct13, MagicLastTypeNameForTestingRegisterABI) S
 	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
 }
 
+//go:registerparams
+//go:noinline
+func callArgsStruct14(f func(Struct14, MagicLastTypeNameForTestingRegisterABI) Struct14, a0 Struct14) Struct14 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
+//go:registerparams
+//go:noinline
+func callArgsStruct15(f func(Struct15, MagicLastTypeNameForTestingRegisterABI) Struct15, a0 Struct15) Struct15 {
+	return f(a0, MagicLastTypeNameForTestingRegisterABI{})
+}
+
 //go:registerparams
 //go:noinline
 func callArgs2Struct1(f func(Struct1, Struct1, MagicLastTypeNameForTestingRegisterABI) (Struct1, Struct1), a0, a1 Struct1) (r0, r1 Struct1) {
@@ -904,6 +932,25 @@ type Struct13 struct {
 	B int
 }
 
+// Struct14 tests a non-zero-sized (and otherwise register-assignable)
+// struct with a field that is a non-zero length array with zero-sized members.
+type Struct14 struct {
+	A uintptr
+	X [3]struct{}
+	B float64
+}
+
+// Struct15 tests a non-zero-sized (and otherwise register-assignable)
+// struct with a struct field that is zero-sized but contains a
+// non-zero length array with zero-sized members.
+type Struct15 struct {
+	A uintptr
+	X struct {
+		Y [3]struct{}
+	}
+	B float64
+}
+
 const genValueRandSeed = 0
 
 // genValue generates a pseudorandom reflect.Value with type t.
-- 
GitLab


From 41cf18eda79be6fa8142ab2e99dc756d4b08369b Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Fri, 2 Apr 2021 19:06:33 +0000
Subject: [PATCH 1337/2400] reflect: fix methodValueCall frame size on mips64

Fixes a mistake from golang.org/cl/298670.

Change-Id: I2f789f9fe003c856a993f7d462a2e84936743a1a
Reviewed-on: https://go-review.googlesource.com/c/go/+/306930
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
Trust: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/reflect/asm_mips64x.s | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/reflect/asm_mips64x.s b/src/reflect/asm_mips64x.s
index 0a660a5a60..ae661262cb 100644
--- a/src/reflect/asm_mips64x.s
+++ b/src/reflect/asm_mips64x.s
@@ -29,7 +29,7 @@ TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$40
 // See the comment on the declaration of methodValueCall in makefunc.go
 // for more details.
 // No arg size here; runtime pulls arg map out of the func value.
-TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$32
+TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$40
 	NO_LOCAL_POINTERS
 	MOVV	REGCTXT, 8(R29)
 	MOVV	$argframe+0(FP), R1
-- 
GitLab


From 35a8bbc9eaf876ee625d33401081f74a7c4e08f8 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Fri, 2 Apr 2021 15:51:45 -0400
Subject: [PATCH 1338/2400] runtime: make concatstring{2,3,4,5} consistent w/
 compiler's use

Internally the compiler uses a0,a1,a3 string, not [3]string,
and this lead to different parameter passing (memory, versus registers)
which of course did not work.

Updates #40724.

Change-Id: I1dbf479b88134559ba54b4b00a042b9a0fd128b8
Reviewed-on: https://go-review.googlesource.com/c/go/+/306910
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/runtime/string.go | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/runtime/string.go b/src/runtime/string.go
index 9a601f0094..d6030a1dca 100644
--- a/src/runtime/string.go
+++ b/src/runtime/string.go
@@ -55,20 +55,20 @@ func concatstrings(buf *tmpBuf, a []string) string {
 	return s
 }
 
-func concatstring2(buf *tmpBuf, a [2]string) string {
-	return concatstrings(buf, a[:])
+func concatstring2(buf *tmpBuf, a0, a1 string) string {
+	return concatstrings(buf, []string{a0, a1})
 }
 
-func concatstring3(buf *tmpBuf, a [3]string) string {
-	return concatstrings(buf, a[:])
+func concatstring3(buf *tmpBuf, a0, a1, a2 string) string {
+	return concatstrings(buf, []string{a0, a1, a2})
 }
 
-func concatstring4(buf *tmpBuf, a [4]string) string {
-	return concatstrings(buf, a[:])
+func concatstring4(buf *tmpBuf, a0, a1, a2, a3 string) string {
+	return concatstrings(buf, []string{a0, a1, a2, a3})
 }
 
-func concatstring5(buf *tmpBuf, a [5]string) string {
-	return concatstrings(buf, a[:])
+func concatstring5(buf *tmpBuf, a0, a1, a2, a3, a4 string) string {
+	return concatstrings(buf, []string{a0, a1, a2, a3, a4})
 }
 
 // slicebytetostring converts a byte slice to a string.
-- 
GitLab


From f25d78f8e216f5558885ffd2cea39b3ff1a3ff43 Mon Sep 17 00:00:00 2001
From: Carlo Alberto Ferraris <cafxx@strayorange.com>
Date: Fri, 2 Apr 2021 17:36:54 +0900
Subject: [PATCH 1339/2400] testing: clarify when Cleanup is called

Change-Id: I2ed394fccec83aac09a49673554cbf504787965b
Reviewed-on: https://go-review.googlesource.com/c/go/+/306810
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Dmitri Shuralyov <dmitshur@golang.org>
---
 src/testing/testing.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/testing/testing.go b/src/testing/testing.go
index 056a8d2879..851b118df4 100644
--- a/src/testing/testing.go
+++ b/src/testing/testing.go
@@ -876,7 +876,7 @@ func (c *common) Helper() {
 	}
 }
 
-// Cleanup registers a function to be called when the test and all its
+// Cleanup registers a function to be called when the test (or subtest) and all its
 // subtests complete. Cleanup functions will be called in last added,
 // first called order.
 func (c *common) Cleanup(f func()) {
-- 
GitLab


From 2ebe77a2fda1ee9ff6fd9a3e08933ad1ebaea039 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Fri, 2 Apr 2021 13:32:08 -0400
Subject: [PATCH 1340/2400] cmd/internal/obj: use REGENTRYTMP* in a few more
 places

There are a few remaining places in obj6 where we hard-code
safe-on-entry registers. Fix those to use the consts.

For #40724.

Change-Id: Ie640521aa67d6c99bc057553dc122160049c6edc
Reviewed-on: https://go-review.googlesource.com/c/go/+/307009
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/internal/obj/x86/obj6.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/cmd/internal/obj/x86/obj6.go b/src/cmd/internal/obj/x86/obj6.go
index a314583e49..785e6f5bd3 100644
--- a/src/cmd/internal/obj/x86/obj6.go
+++ b/src/cmd/internal/obj/x86/obj6.go
@@ -1046,7 +1046,7 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
 		tmp := int16(REG_AX) // use AX for 32-bit
 		if ctxt.Arch.Family == sys.AMD64 {
 			// for 64-bit, stay away from register ABI parameter registers, even w/o GOEXPERIMENT=regabi
-			tmp = int16(REG_R13)
+			tmp = int16(REGENTRYTMP0)
 		}
 		// large stack: SP-framesize <= stackguard-StackSmall
 		//	LEAQ -xxx(SP), tmp
@@ -1076,8 +1076,8 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
 		tmp1 := int16(REG_SI)
 		tmp2 := int16(REG_AX)
 		if ctxt.Arch.Family == sys.AMD64 {
-			tmp1 = int16(REG_R13) // register ABI uses REG_SI and REG_AX for parameters.
-			tmp2 = int16(REG_R12)
+			tmp1 = int16(REGENTRYTMP0) // register ABI uses REG_SI and REG_AX for parameters.
+			tmp2 = int16(REGENTRYTMP1)
 		}
 		// Such a large stack we need to protect against wraparound.
 		// If SP is close to zero:
-- 
GitLab


From 6454b2720ff4854ce92567d22fc7c6c7d497e6a2 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 29 Mar 2021 12:22:01 -0700
Subject: [PATCH 1341/2400] cmd/compile/internal/types2: review of resolver.go

The changes between (equivalent, and reviewed) go/types/resolver.go
and resolver.go can be seen by comparing patchset 1 and 2. The actual
changes are removing the "// UNREVIEWED" marker.

The primary differences compared to go/types are:
- use of syntax rather than go/ast package
- not using a walkDecl abstraction for const/var/type declarations

Change-Id: Id8d7b069813149ca4eadbb61d1124b22c56a91b1
Reviewed-on: https://go-review.googlesource.com/c/go/+/305572
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/resolver.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/resolver.go b/src/cmd/compile/internal/types2/resolver.go
index 79938964c1..3aca2bcb3c 100644
--- a/src/cmd/compile/internal/types2/resolver.go
+++ b/src/cmd/compile/internal/types2/resolver.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2013 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.
-- 
GitLab


From a1e4657d5a89d683a2bc0c5c8d6c5d2698bb081a Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 29 Mar 2021 12:33:45 -0700
Subject: [PATCH 1342/2400] cmd/compile/internal/types2: review of
 check_test.go

The changes between (equivalent, and reviewed) go/types/check_test.go
and check_test.go can be seen by comparing patchset 1 and 2. The actual
changes are removing the "// UNREVIEWED" marker, and minor adjustments
to get the code slightly closer to go/types/check_test.go.

The primary differences compared to go/types are:
- use of syntax rather than go/ast package
- re-implemented mechanism for error matching and elimination
  based on the syntax.ErrorMap mechanism (there's no exported
  access to the syntax scanner)
- error matching permits for column tolerances because types2
  column information doesn't match go/types column information

Change-Id: I8ae6bc93dfa2b517673b642064a1f09166755286
Reviewed-on: https://go-review.googlesource.com/c/go/+/305573
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/check_test.go | 62 ++++++++-----------
 1 file changed, 27 insertions(+), 35 deletions(-)

diff --git a/src/cmd/compile/internal/types2/check_test.go b/src/cmd/compile/internal/types2/check_test.go
index fc6f46b4b8..ac21c3458e 100644
--- a/src/cmd/compile/internal/types2/check_test.go
+++ b/src/cmd/compile/internal/types2/check_test.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2011 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.
@@ -29,9 +28,7 @@ package types2_test
 import (
 	"cmd/compile/internal/syntax"
 	"flag"
-	"fmt"
 	"internal/testenv"
-	"io/ioutil"
 	"os"
 	"path/filepath"
 	"regexp"
@@ -73,6 +70,7 @@ func unpackError(err error) syntax.Error {
 	}
 }
 
+// delta returns the absolute difference between x and y.
 func delta(x, y uint) uint {
 	switch {
 	case x < y:
@@ -98,17 +96,17 @@ func asGoVersion(s string) string {
 	return ""
 }
 
-func checkFiles(t *testing.T, sources []string, goVersion string, colDelta uint, trace bool) {
-	if len(sources) == 0 {
+func checkFiles(t *testing.T, filenames []string, goVersion string, colDelta uint, trace bool) {
+	if len(filenames) == 0 {
 		t.Fatal("no source files")
 	}
 
 	var mode syntax.Mode
-	if strings.HasSuffix(sources[0], ".go2") {
+	if strings.HasSuffix(filenames[0], ".go2") {
 		mode |= syntax.AllowGenerics
 	}
 	// parse files and collect parser errors
-	files, errlist := parseFiles(t, sources, mode)
+	files, errlist := parseFiles(t, filenames, mode)
 
 	pkgName := "<no package>"
 	if len(files) > 0 {
@@ -133,7 +131,7 @@ func checkFiles(t *testing.T, sources []string, goVersion string, colDelta uint,
 	conf.AcceptMethodTypeParams = true
 	conf.InferFromConstraints = true
 	// special case for importC.src
-	if len(sources) == 1 && strings.HasSuffix(sources[0], "importC.src") {
+	if len(filenames) == 1 && strings.HasSuffix(filenames[0], "importC.src") {
 		conf.FakeImportC = true
 	}
 	conf.Trace = trace
@@ -156,7 +154,7 @@ func checkFiles(t *testing.T, sources []string, goVersion string, colDelta uint,
 
 	// collect expected errors
 	errmap := make(map[string]map[uint][]syntax.Error)
-	for _, filename := range sources {
+	for _, filename := range filenames {
 		f, err := os.Open(filename)
 		if err != nil {
 			t.Error(err)
@@ -169,16 +167,16 @@ func checkFiles(t *testing.T, sources []string, goVersion string, colDelta uint,
 	}
 
 	// match against found errors
+	// TODO(gri) sort err list to avoid mismatched when having multiple errors
 	for _, err := range errlist {
 		got := unpackError(err)
 
 		// find list of errors for the respective error line
 		filename := got.Pos.Base().Filename()
 		filemap := errmap[filename]
-		var line uint
+		line := got.Pos.Line()
 		var list []syntax.Error
 		if filemap != nil {
-			line = got.Pos.Line()
 			list = filemap[line]
 		}
 		// list may be nil
@@ -210,6 +208,7 @@ func checkFiles(t *testing.T, sources []string, goVersion string, colDelta uint,
 		// eliminate from list
 		if n := len(list) - 1; n > 0 {
 			// not the last entry - swap in last element and shorten list by 1
+			// TODO(gri) avoid changing the order of entries
 			list[index] = list[n]
 			filemap[line] = list[:n]
 		} else {
@@ -247,48 +246,41 @@ func TestCheck(t *testing.T) {
 	checkFiles(t, strings.Split(*testFiles, ","), *goVersion, 0, testing.Verbose())
 }
 
-func TestTestdata(t *testing.T)  { DefPredeclaredTestFuncs(); testDir(t, 75, "testdata") } // TODO(gri) narrow column tolerance
-func TestExamples(t *testing.T)  { testDir(t, 0, "examples") }
-func TestFixedbugs(t *testing.T) { testDir(t, 0, "fixedbugs") }
+// TODO(gri) go/types has an extra TestLongConstants test
+
+func TestTestdata(t *testing.T)  { DefPredeclaredTestFuncs(); testDir(t, "testdata", 75) } // TODO(gri) narrow column tolerance
+func TestExamples(t *testing.T)  { testDir(t, "examples", 0) }
+func TestFixedbugs(t *testing.T) { testDir(t, "fixedbugs", 0) }
 
-func testDir(t *testing.T, colDelta uint, dir string) {
+func testDir(t *testing.T, dir string, colDelta uint) {
 	testenv.MustHaveGoBuild(t)
 
-	fis, err := ioutil.ReadDir(dir)
+	fis, err := os.ReadDir(dir)
 	if err != nil {
 		t.Error(err)
 		return
 	}
 
-	for count, fi := range fis {
+	for _, fi := range fis {
 		path := filepath.Join(dir, fi.Name())
 
 		// if fi is a directory, its files make up a single package
+		var filenames []string
 		if fi.IsDir() {
-			if testing.Verbose() {
-				fmt.Printf("%3d %s\n", count, path)
-			}
-			fis, err := ioutil.ReadDir(path)
+			fis, err := os.ReadDir(path)
 			if err != nil {
 				t.Error(err)
 				continue
 			}
-			files := make([]string, len(fis))
-			for i, fi := range fis {
-				// if fi is a directory, checkFiles below will complain
-				files[i] = filepath.Join(path, fi.Name())
-				if testing.Verbose() {
-					fmt.Printf("\t%s\n", files[i])
-				}
+			for _, fi := range fis {
+				filenames = append(filenames, filepath.Join(path, fi.Name()))
 			}
-			checkFiles(t, files, "", colDelta, false)
-			continue
+		} else {
+			filenames = []string{path}
 		}
 
-		// otherwise, fi is a stand-alone file
-		if testing.Verbose() {
-			fmt.Printf("%3d %s\n", count, path)
-		}
-		checkFiles(t, []string{path}, "", colDelta, false)
+		t.Run(filepath.Base(path), func(t *testing.T) {
+			checkFiles(t, filenames, *goVersion, colDelta, false)
+		})
 	}
 }
-- 
GitLab


From 93dcaba1192bac57409602a2f767f9b2f70b5f3a Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 29 Mar 2021 13:36:53 -0700
Subject: [PATCH 1343/2400] cmd/compile/internal/types2: review of stmt.go

The changes between (equivalent, and reviewed) go/types/stmt.go
and stmt.go can be seen by comparing patchset 1 and 2. The actual
changes are removing the "// UNREVIEWED" marker, and minor adjustments
to get the code slightly closer to go/types/stmt.go.

The primary differences compared to go/types are:
- use of syntax rather than go/ast package, with significant
  differences in the representation of switch and select statements,
  range clauses of for statements, and inc/dec statements.
- no reporting of error codes
- use or error_ for collecting addition error information

Change-Id: I4409f62ecafd0653e4c8ef087c2580d8f0544efc
Reviewed-on: https://go-review.googlesource.com/c/go/+/305576
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/stmt.go | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go
index 367146b528..319354bea2 100644
--- a/src/cmd/compile/internal/types2/stmt.go
+++ b/src/cmd/compile/internal/types2/stmt.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2012 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.
@@ -265,7 +264,7 @@ L:
 	}
 }
 
-func (check *Checker) caseTypes(x *operand, xtyp *Interface, types []syntax.Expr, seen map[Type]syntax.Pos) (T Type) {
+func (check *Checker) caseTypes(x *operand, xtyp *Interface, types []syntax.Expr, seen map[Type]syntax.Expr) (T Type) {
 L:
 	for _, e := range types {
 		T = check.typOrNil(e)
@@ -277,7 +276,7 @@ L:
 		}
 		// look for duplicate types
 		// (quadratic algorithm, but type switches tend to be reasonably small)
-		for t, pos := range seen {
+		for t, other := range seen {
 			if T == nil && t == nil || T != nil && t != nil && check.identical(T, t) {
 				// talk about "case" rather than "type" because of nil case
 				Ts := "nil"
@@ -286,12 +285,12 @@ L:
 				}
 				var err error_
 				err.errorf(e, "duplicate case %s in type switch", Ts)
-				err.errorf(pos, "previous case")
+				err.errorf(other, "previous case")
 				check.report(&err)
 				continue L
 			}
 		}
-		seen[T] = e.Pos()
+		seen[T] = e
 		if T != nil {
 			check.typeAssertion(e.Pos(), x, xtyp, T)
 		}
@@ -409,11 +408,6 @@ func (check *Checker) stmt(ctxt stmtContext, s syntax.Stmt) {
 		check.binary(&x, nil, lhs[0], rhs[0], s.Op)
 		check.assignVar(lhs[0], &x)
 
-	// case *syntax.GoStmt:
-	// 	check.suspendedCall("go", s.Call)
-
-	// case *syntax.DeferStmt:
-	// 	check.suspendedCall("defer", s.Call)
 	case *syntax.CallStmt:
 		// TODO(gri) get rid of this conversion to string
 		kind := "go"
@@ -686,6 +680,10 @@ func (check *Checker) typeSwitchStmt(inner stmtContext, s *syntax.SwitchStmt, gu
 	if x.mode == invalid {
 		return
 	}
+	// Caution: We're not using asInterface here because we don't want
+	//          to switch on a suitably constrained type parameter (for
+	//          now).
+	// TODO(gri) Need to revisit this.
 	xtyp, _ := under(x.typ).(*Interface)
 	if xtyp == nil {
 		check.errorf(&x, "%s is not an interface type", &x)
@@ -695,8 +693,8 @@ func (check *Checker) typeSwitchStmt(inner stmtContext, s *syntax.SwitchStmt, gu
 
 	check.multipleSwitchDefaults(s.Body)
 
-	var lhsVars []*Var                // list of implicitly declared lhs variables
-	seen := make(map[Type]syntax.Pos) // map of seen types to positions
+	var lhsVars []*Var                 // list of implicitly declared lhs variables
+	seen := make(map[Type]syntax.Expr) // map of seen types to positions
 	for i, clause := range s.Body {
 		if clause == nil {
 			check.error(s, invalidAST+"incorrect type switch case")
@@ -739,6 +737,9 @@ func (check *Checker) typeSwitchStmt(inner stmtContext, s *syntax.SwitchStmt, gu
 	}
 
 	// If lhs exists, we must have at least one lhs variable that was used.
+	// (We can't use check.usage because that only looks at one scope; and
+	// we don't want to use the same variable for all scopes and change the
+	// variable type underfoot.)
 	if lhs != nil {
 		var used bool
 		for _, v := range lhsVars {
-- 
GitLab


From 01821137c24750ddc7a58d3469bfd8c5e9d6bd47 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 29 Mar 2021 14:59:39 -0700
Subject: [PATCH 1344/2400] cmd/compile/internal/types2: review of errors.go

The changes between (equivalent, and reviewed) go/types/errors.go
and errors.go can be seen by comparing patchset 1 and 2. The actual
changes are removing the "// UNREVIEWED" marker.

The go/types version is significantly different as it handles
error codes but doesn't have some of the types2 changes.

Change-Id: I48f79ce31490db938c830df7d38e247d55d54f2d
Reviewed-on: https://go-review.googlesource.com/c/go/+/305577
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/errors.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/errors.go b/src/cmd/compile/internal/types2/errors.go
index 79fedc91e1..88ea72f593 100644
--- a/src/cmd/compile/internal/types2/errors.go
+++ b/src/cmd/compile/internal/types2/errors.go
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2012 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.
-- 
GitLab


From fe587ce856d1dee97829fe0ed090ba7e068335cb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Daniel=20Mart=C3=AD?= <mvdan@mvdan.cc>
Date: Mon, 26 Oct 2020 09:42:54 +0000
Subject: [PATCH 1345/2400] cmd/dist: include "go1.x-" in devel go version
 strings
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This way, "go version" will report the "base version" or major version
that the tool corresponds to. This is the same version number that is
matched against build tags such as "go1.14" or "!go1.16".

Obtaining this version being built is non-trivial, since we can't just
import a package or query git. The added comments document the chosen
mechanism, based on a regular expression. It was chosen over AST parsing
as it would add a significant amount of code without much gain, given
how simple the goversion.go file is.

For #41116.

Change-Id: I653ae935e27c13267f23898f89c84020dcd6e194
Reviewed-on: https://go-review.googlesource.com/c/go/+/264938
Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
Trust: Daniel Martí <mvdan@mvdan.cc>
Trust: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/dist/build.go | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/src/cmd/dist/build.go b/src/cmd/dist/build.go
index acf38e3785..8accb6db8f 100644
--- a/src/cmd/dist/build.go
+++ b/src/cmd/dist/build.go
@@ -14,6 +14,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
 	"sort"
 	"strings"
 	"sync"
@@ -405,8 +406,22 @@ func findgoversion() string {
 	}
 
 	if !precise {
-		// Tag does not point at HEAD; add hash and date to version.
-		tag += chomp(run(goroot, CheckExit, "git", "log", "-n", "1", "--format=format: +%h %cd", "HEAD"))
+		// Tag does not point at HEAD; add 1.x base version, hash, and date to version.
+		//
+		// Note that we lightly parse internal/goversion/goversion.go to
+		// obtain the base version. We can't just import the package,
+		// because cmd/dist is built with a bootstrap GOROOT which could
+		// be an entirely different version of Go, like 1.4. We assume
+		// that the file contains "const Version = <Integer>".
+
+		goversionSource := readfile(pathf("%s/src/internal/goversion/goversion.go", goroot))
+		m := regexp.MustCompile(`(?m)^const Version = (\d+)`).FindStringSubmatch(goversionSource)
+		if m == nil {
+			fatalf("internal/goversion/goversion.go does not contain 'const Version = ...'")
+		}
+		tag += fmt.Sprintf(" go1.%s-", m[1])
+
+		tag += chomp(run(goroot, CheckExit, "git", "log", "-n", "1", "--format=format:%h %cd", "HEAD"))
 	}
 
 	// Cache version.
-- 
GitLab


From 6986c02d72db6806a46406ef398aa10f26018c20 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Fri, 2 Apr 2021 14:31:15 -0700
Subject: [PATCH 1346/2400] cmd/compile: rename newNamedTypeWithSym, add some
 commemnts

Renamed newNamedTypeWithSym to newIncompleteNamedType. Added some extra
comments to types.NewNamed and types.SetUnderlying.

Change-Id: Idc5a6379991c26b429d91bae9fe1adef8457a75c
Reviewed-on: https://go-review.googlesource.com/c/go/+/307029
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Reviewed-by: Ingo Oeser <nightlyone@googlemail.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/noder/stencil.go | 6 +++---
 src/cmd/compile/internal/noder/types.go   | 2 +-
 src/cmd/compile/internal/types/type.go    | 8 ++++++--
 3 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 350f8f8c2a..4db688571e 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -716,7 +716,7 @@ func (subst *subster) typ(t *types.Type) *types.Type {
 		// In order to deal with recursive generic types, create a TFORW
 		// type initially and set the Def field of its sym, so it can be
 		// found if this type appears recursively within the type.
-		forw = newNamedTypeWithSym(t.Pos(), newsym)
+		forw = newIncompleteNamedType(t.Pos(), newsym)
 		//println("Creating new type by sub", newsym.Name, forw.HasTParam())
 		forw.SetRParams(neededTargs)
 	}
@@ -896,9 +896,9 @@ func deref(t *types.Type) *types.Type {
 	return t
 }
 
-// newNamedTypeWithSym returns a TFORW type t with name specified by sym, such
+// newIncompleteNamedType returns a TFORW type t with name specified by sym, such
 // that t.nod and sym.Def are set correctly.
-func newNamedTypeWithSym(pos src.XPos, sym *types.Sym) *types.Type {
+func newIncompleteNamedType(pos src.XPos, sym *types.Sym) *types.Type {
 	name := ir.NewDeclNameAt(pos, ir.OTYPE, sym)
 	forw := types.NewNamed(name)
 	name.SetType(forw)
diff --git a/src/cmd/compile/internal/noder/types.go b/src/cmd/compile/internal/noder/types.go
index 06c584714e..8680559a41 100644
--- a/src/cmd/compile/internal/noder/types.go
+++ b/src/cmd/compile/internal/noder/types.go
@@ -120,7 +120,7 @@ func (g *irgen) typ0(typ types2.Type) *types.Type {
 			// which may set HasTParam) before translating the
 			// underlying type itself, so we handle recursion
 			// correctly, including via method signatures.
-			ntyp := newNamedTypeWithSym(g.pos(typ.Obj().Pos()), s)
+			ntyp := newIncompleteNamedType(g.pos(typ.Obj().Pos()), s)
 			g.typs[typ] = ntyp
 
 			// If ntyp still has type params, then we must be
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 31a99781d1..762cdd3258 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -1643,7 +1643,10 @@ var (
 	TypeResultMem = newResults([]*Type{TypeMem})
 )
 
-// NewNamed returns a new named type for the given type name. obj should be an ir.Name.
+// NewNamed returns a new named type for the given type name. obj should be an
+// ir.Name. The new type is incomplete, and the underlying type should be set
+// later via SetUnderlying(). References to the type are maintained until the type
+// is filled in, so those references can be updated when the type is complete.
 func NewNamed(obj Object) *Type {
 	t := New(TFORW)
 	t.sym = obj.Sym()
@@ -1659,7 +1662,8 @@ func (t *Type) Obj() Object {
 	return nil
 }
 
-// SetUnderlying sets the underlying type.
+// SetUnderlying sets the underlying type. SetUnderlying automatically updates any
+// types that were waiting for this type to be completed.
 func (t *Type) SetUnderlying(underlying *Type) {
 	if underlying.kind == TFORW {
 		// This type isn't computed yet; when it is, update n.
-- 
GitLab


From 971c7154b04d8dd00da932a26ecb6bb8d8fc133d Mon Sep 17 00:00:00 2001
From: Drew Richardson <drewrichardson@gmail.com>
Date: Thu, 1 Apr 2021 17:05:24 -0700
Subject: [PATCH 1347/2400] io/fs: implement subFS.Sub

Calling fs.Sub with the result of fs.Sub multiple times creates a deep
call stack for Open and other methods. Enhance the fs.FS returned by
fs.Sub to implement fs.SubFS and reduce the call stack.

Fixes #45349

Change-Id: I10e10501e030176e10e2ae5ad260212e5c784bed
Reviewed-on: https://go-review.googlesource.com/c/go/+/306769
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/io/fs/sub.go | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/io/fs/sub.go b/src/io/fs/sub.go
index d689b9e2bc..7822e555ea 100644
--- a/src/io/fs/sub.go
+++ b/src/io/fs/sub.go
@@ -125,3 +125,14 @@ func (f *subFS) Glob(pattern string) ([]string, error) {
 	}
 	return list, f.fixErr(err)
 }
+
+func (f *subFS) Sub(dir string) (FS, error) {
+	if dir == "." {
+		return f, nil
+	}
+	full, err := f.fullName("sub", dir)
+	if err != nil {
+		return nil, err
+	}
+	return &subFS{f.fsys, full}, nil
+}
-- 
GitLab


From dac136f87b9d5fdda9b5c33dfa0f94dc8c9880c7 Mon Sep 17 00:00:00 2001
From: Tom Thorogood <me+google@tomthorogood.co.uk>
Date: Sat, 13 Mar 2021 00:27:30 +1030
Subject: [PATCH 1348/2400] archive/zip: fix character device handling in
 fileModeToUnixMode

The switch case for fs.ModeDevice can only be reached for block devices
while character devices match fs.ModeDevice | fs.ModeCharDevice. This
would cause character devices to wrongly be reported as regular files.

This bug has existed since the switch was first introduced in CL 5624048.

Change-Id: Icdbedb015e5376b385b3115d2e4574daa052f796
Reviewed-on: https://go-review.googlesource.com/c/go/+/300891
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/archive/zip/struct.go      |  8 +++-----
 src/archive/zip/writer_test.go | 12 ++++++++++++
 2 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/src/archive/zip/struct.go b/src/archive/zip/struct.go
index 4dd29f35fa..3dc0c50122 100644
--- a/src/archive/zip/struct.go
+++ b/src/archive/zip/struct.go
@@ -341,11 +341,9 @@ func fileModeToUnixMode(mode fs.FileMode) uint32 {
 	case fs.ModeSocket:
 		m = s_IFSOCK
 	case fs.ModeDevice:
-		if mode&fs.ModeCharDevice != 0 {
-			m = s_IFCHR
-		} else {
-			m = s_IFBLK
-		}
+		m = s_IFBLK
+	case fs.ModeDevice | fs.ModeCharDevice:
+		m = s_IFCHR
 	}
 	if mode&fs.ModeSetuid != 0 {
 		m |= s_ISUID
diff --git a/src/archive/zip/writer_test.go b/src/archive/zip/writer_test.go
index 5985144e5c..3fa8bef055 100644
--- a/src/archive/zip/writer_test.go
+++ b/src/archive/zip/writer_test.go
@@ -57,6 +57,18 @@ var writeTests = []WriteTest{
 		Method: Deflate,
 		Mode:   0755 | fs.ModeSymlink,
 	},
+	{
+		Name:   "device",
+		Data:   []byte("device file"),
+		Method: Deflate,
+		Mode:   0755 | fs.ModeDevice,
+	},
+	{
+		Name:   "chardevice",
+		Data:   []byte("char device file"),
+		Method: Deflate,
+		Mode:   0755 | fs.ModeDevice | fs.ModeCharDevice,
+	},
 }
 
 func TestWriter(t *testing.T) {
-- 
GitLab


From 9e7bc80b31088dc62faf4776ffdb1a2e27afa94e Mon Sep 17 00:00:00 2001
From: Tom Thorogood <me+google@tomthorogood.co.uk>
Date: Tue, 16 Mar 2021 12:35:35 +1030
Subject: [PATCH 1349/2400] os: reuse readdir buffers on unix with a sync.Pool
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

(*File).readdir allocates a fixed-size 8KiB buffer on unix systems that
cannot be reused. While it accounts for just a single allocation, it's
more than large enough to show up in profiles and make things quite a
bit slower.

Instead of allocating so often, use a sync.Pool to allow these buffers to
be reused. This has a large impact on readdir heavy workloads.

Package os benchmarks:

name            old time/op    new time/op    delta
Readdirname-12    35.6µs ± 5%    18.1µs ± 4%  -49.00%  (p=0.000 n=10+10)
Readdir-12         142µs ± 1%     121µs ± 0%  -14.87%  (p=0.000 n=10+9)
ReadDir-12        44.0µs ± 6%    28.4µs ± 8%  -35.58%  (p=0.000 n=9+10)

name            old alloc/op   new alloc/op   delta
Readdirname-12    14.4kB ± 0%     6.2kB ± 0%  -57.08%  (p=0.000 n=10+10)
Readdir-12        41.6kB ± 0%    33.4kB ± 0%  -19.77%  (p=0.000 n=10+9)
ReadDir-12        21.9kB ± 0%    13.7kB ± 0%  -37.39%  (p=0.000 n=10+10)

name            old allocs/op  new allocs/op  delta
Readdirname-12       131 ± 0%       130 ± 0%   -0.76%  (p=0.000 n=10+10)
Readdir-12           367 ± 0%       366 ± 0%   -0.27%  (p=0.000 n=10+10)
ReadDir-12           249 ± 0%       248 ± 0%   -0.40%  (p=0.000 n=10+10)

A clunky benchmark I threw together that calls filepath.WalkDir on $GOMODCACHE:

name        old time/op    new time/op    delta
WalkDir-12    91.2ms ±19%    48.7ms ± 0%  -46.54%  (p=0.000 n=10+10)

name        old alloc/op   new alloc/op   delta
WalkDir-12    54.0MB ± 0%     7.6MB ± 0%  -85.92%  (p=0.000 n=8+9)

name        old allocs/op  new allocs/op  delta
WalkDir-12      136k ± 0%      130k ± 0%   -4.15%  (p=0.000 n=8+8)

Change-Id: I00e4d48726da0e46c528ab205409afd03127b844
Reviewed-on: https://go-review.googlesource.com/c/go/+/302169
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/os/dir_unix.go  | 29 +++++++++++++++++++++--------
 src/os/file_unix.go |  1 +
 2 files changed, 22 insertions(+), 8 deletions(-)

diff --git a/src/os/dir_unix.go b/src/os/dir_unix.go
index ef5c00aee0..5589c9c682 100644
--- a/src/os/dir_unix.go
+++ b/src/os/dir_unix.go
@@ -10,15 +10,16 @@ package os
 import (
 	"io"
 	"runtime"
+	"sync"
 	"syscall"
 	"unsafe"
 )
 
 // Auxiliary information if the File describes a directory
 type dirInfo struct {
-	buf  []byte // buffer for directory I/O
-	nbuf int    // length of buf; return value from Getdirentries
-	bufp int    // location of next record in buf.
+	buf  *[]byte // buffer for directory I/O
+	nbuf int     // length of buf; return value from Getdirentries
+	bufp int     // location of next record in buf.
 }
 
 const (
@@ -26,14 +27,26 @@ const (
 	blockSize = 8192
 )
 
-func (d *dirInfo) close() {}
+var dirBufPool = sync.Pool{
+	New: func() interface{} {
+		// The buffer must be at least a block long.
+		buf := make([]byte, blockSize)
+		return &buf
+	},
+}
+
+func (d *dirInfo) close() {
+	if d.buf != nil {
+		dirBufPool.Put(d.buf)
+		d.buf = nil
+	}
+}
 
 func (f *File) readdir(n int, mode readdirMode) (names []string, dirents []DirEntry, infos []FileInfo, err error) {
 	// If this file has no dirinfo, create one.
 	if f.dirinfo == nil {
 		f.dirinfo = new(dirInfo)
-		// The buffer must be at least a block long.
-		f.dirinfo.buf = make([]byte, blockSize)
+		f.dirinfo.buf = dirBufPool.Get().(*[]byte)
 	}
 	d := f.dirinfo
 
@@ -55,7 +68,7 @@ func (f *File) readdir(n int, mode readdirMode) (names []string, dirents []DirEn
 		if d.bufp >= d.nbuf {
 			d.bufp = 0
 			var errno error
-			d.nbuf, errno = f.pfd.ReadDirent(d.buf)
+			d.nbuf, errno = f.pfd.ReadDirent(*d.buf)
 			runtime.KeepAlive(f)
 			if errno != nil {
 				return names, dirents, infos, &PathError{Op: "readdirent", Path: f.name, Err: errno}
@@ -66,7 +79,7 @@ func (f *File) readdir(n int, mode readdirMode) (names []string, dirents []DirEn
 		}
 
 		// Drain the buffer
-		buf := d.buf[d.bufp:d.nbuf]
+		buf := (*d.buf)[d.bufp:d.nbuf]
 		reclen, ok := direntReclen(buf)
 		if !ok || reclen > uint64(len(buf)) {
 			break
diff --git a/src/os/file_unix.go b/src/os/file_unix.go
index e8b286c9ee..b5d87fcb73 100644
--- a/src/os/file_unix.go
+++ b/src/os/file_unix.go
@@ -247,6 +247,7 @@ func (file *file) close() error {
 	}
 	if file.dirinfo != nil {
 		file.dirinfo.close()
+		file.dirinfo = nil
 	}
 	var err error
 	if e := file.pfd.Close(); e != nil {
-- 
GitLab


From 776d8d387c262d3dd159f7868b3c04fb0f617865 Mon Sep 17 00:00:00 2001
From: ianwoolf <btw515wolf2@gmail.com>
Date: Thu, 1 Apr 2021 01:27:29 +0800
Subject: [PATCH 1350/2400] os, path/filepath: use T.Cleanup to restore the
 original working directory

Updates #45182

Change-Id: Iaf3bdcc345c72fa9669fdc99908ada4e89904edd
Reviewed-on: https://go-review.googlesource.com/c/go/+/306290
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/os/os_windows_test.go      | 54 ++++------------------------------
 src/os/removeall_test.go       | 35 ++++++++++++----------
 src/path/filepath/path_test.go | 30 ++++++++++++-------
 3 files changed, 45 insertions(+), 74 deletions(-)

diff --git a/src/os/os_windows_test.go b/src/os/os_windows_test.go
index b0929b4f30..b4339c3f7e 100644
--- a/src/os/os_windows_test.go
+++ b/src/os/os_windows_test.go
@@ -35,16 +35,7 @@ func TestSameWindowsFile(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer os.RemoveAll(temp)
-
-	wd, err := os.Getwd()
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = os.Chdir(temp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.Chdir(wd)
+	chdir(t, temp)
 
 	f, err := os.Create("a")
 	if err != nil {
@@ -94,16 +85,7 @@ func testDirLinks(t *testing.T, tests []dirLinkTest) {
 		t.Fatal(err)
 	}
 	defer os.RemoveAll(tmpdir)
-
-	oldwd, err := os.Getwd()
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = os.Chdir(tmpdir)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.Chdir(oldwd)
+	chdir(t, tmpdir)
 
 	dir := filepath.Join(tmpdir, "dir")
 	err = os.Mkdir(dir, 0777)
@@ -444,15 +426,7 @@ func TestNetworkSymbolicLink(t *testing.T) {
 	}
 	defer os.RemoveAll(dir)
 
-	oldwd, err := os.Getwd()
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = os.Chdir(dir)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.Chdir(oldwd)
+	chdir(t, dir)
 
 	shareName := "GoSymbolicLinkTestShare" // hope no conflictions
 	sharePath := filepath.Join(dir, shareName)
@@ -604,16 +578,7 @@ func TestOpenVolumeName(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer os.RemoveAll(tmpdir)
-
-	wd, err := os.Getwd()
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = os.Chdir(tmpdir)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.Chdir(wd)
+	chdir(t, tmpdir)
 
 	want := []string{"file1", "file2", "file3", "gopher.txt"}
 	sort.Strings(want)
@@ -1226,16 +1191,7 @@ func TestWindowsReadlink(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-
-	wd, err := os.Getwd()
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = os.Chdir(tmpdir)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.Chdir(wd)
+	chdir(t, tmpdir)
 
 	vol := filepath.VolumeName(tmpdir)
 	output, err := osexec.Command("cmd", "/c", "mountvol", vol, "/L").CombinedOutput()
diff --git a/src/os/removeall_test.go b/src/os/removeall_test.go
index 3a2f6e3759..45a85792ce 100644
--- a/src/os/removeall_test.go
+++ b/src/os/removeall_test.go
@@ -156,6 +156,25 @@ func TestRemoveAllLarge(t *testing.T) {
 	}
 }
 
+// chdir changes the current working directory to the named directory,
+// and then restore the original working directory at the end of the test.
+func chdir(t *testing.T, dir string) {
+	olddir, err := os.Getwd()
+	if err != nil {
+		t.Fatalf("chdir: %v", err)
+	}
+	if err := os.Chdir(dir); err != nil {
+		t.Fatalf("chdir %s: %v", dir, err)
+	}
+
+	t.Cleanup(func() {
+		if err := os.Chdir(olddir); err != nil {
+			t.Errorf("chdir to original working directory %s: %v", olddir, err)
+			os.Exit(1)
+		}
+	})
+}
+
 func TestRemoveAllLongPath(t *testing.T) {
 	switch runtime.GOOS {
 	case "aix", "darwin", "ios", "dragonfly", "freebsd", "linux", "netbsd", "openbsd", "illumos", "solaris":
@@ -164,21 +183,12 @@ func TestRemoveAllLongPath(t *testing.T) {
 		t.Skip("skipping for not implemented platforms")
 	}
 
-	prevDir, err := Getwd()
-	if err != nil {
-		t.Fatalf("Could not get wd: %s", err)
-	}
-
 	startPath, err := os.MkdirTemp("", "TestRemoveAllLongPath-")
 	if err != nil {
 		t.Fatalf("Could not create TempDir: %s", err)
 	}
 	defer RemoveAll(startPath)
-
-	err = Chdir(startPath)
-	if err != nil {
-		t.Fatalf("Could not chdir %s: %s", startPath, err)
-	}
+	chdir(t, startPath)
 
 	// Removing paths with over 4096 chars commonly fails
 	for i := 0; i < 41; i++ {
@@ -195,11 +205,6 @@ func TestRemoveAllLongPath(t *testing.T) {
 		}
 	}
 
-	err = Chdir(prevDir)
-	if err != nil {
-		t.Fatalf("Could not chdir %s: %s", prevDir, err)
-	}
-
 	err = RemoveAll(startPath)
 	if err != nil {
 		t.Errorf("RemoveAll could not remove long file path %s: %s", startPath, err)
diff --git a/src/path/filepath/path_test.go b/src/path/filepath/path_test.go
index 1d9889d320..51eca49e4c 100644
--- a/src/path/filepath/path_test.go
+++ b/src/path/filepath/path_test.go
@@ -410,6 +410,25 @@ func mark(d fs.DirEntry, err error, errors *[]error, clear bool) error {
 	return nil
 }
 
+// chdir changes the current working directory to the named directory,
+// and then restore the original working directory at the end of the test.
+func chdir(t *testing.T, dir string) {
+	olddir, err := os.Getwd()
+	if err != nil {
+		t.Fatalf("getwd %s: %v", dir, err)
+	}
+	if err := os.Chdir(dir); err != nil {
+		t.Fatalf("chdir %s: %v", dir, err)
+	}
+
+	t.Cleanup(func() {
+		if err := os.Chdir(olddir); err != nil {
+			t.Errorf("restore original working directory %s: %v", olddir, err)
+			os.Exit(1)
+		}
+	})
+}
+
 func chtmpdir(t *testing.T) (restore func()) {
 	oldwd, err := os.Getwd()
 	if err != nil {
@@ -1496,16 +1515,7 @@ func TestEvalSymlinksAboveRootChdir(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer os.RemoveAll(tmpDir)
-
-	wd, err := os.Getwd()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.Chdir(wd)
-
-	if err := os.Chdir(tmpDir); err != nil {
-		t.Fatal(err)
-	}
+	chdir(t, tmpDir)
 
 	subdir := filepath.Join("a", "b")
 	if err := os.MkdirAll(subdir, 0777); err != nil {
-- 
GitLab


From 7bfd681c2f11918c6245ad2906b2efc12eda2914 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Chigot?= <chigot.c@gmail.com>
Date: Thu, 1 Apr 2021 10:06:05 +0200
Subject: [PATCH 1351/2400] runtime/pprof: skip tests for AIX

Most of the time, the pprof tests are passing, except
for the builder. The reason is still unknown but I'd rather release
the builder to avoid missing other more important bugs.

Updates #45170

Change-Id: I667543ee1ae309b7319c5b3676a0901b4d0ecf2e
Reviewed-on: https://go-review.googlesource.com/c/go/+/306489
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: Lynn Boger <laboger@linux.vnet.ibm.com>
---
 src/runtime/pprof/pprof_test.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go
index 1b86dbff5b..e6b4d0044d 100644
--- a/src/runtime/pprof/pprof_test.go
+++ b/src/runtime/pprof/pprof_test.go
@@ -276,7 +276,8 @@ func testCPUProfile(t *testing.T, matches matchFunc, need []string, avoid []stri
 
 	broken := false
 	switch runtime.GOOS {
-	case "ios", "dragonfly", "netbsd", "illumos", "solaris":
+	// See https://golang.org/issue/45170 for AIX.
+	case "ios", "dragonfly", "netbsd", "illumos", "solaris", "aix":
 		broken = true
 	case "openbsd":
 		if runtime.GOARCH == "arm" || runtime.GOARCH == "arm64" {
-- 
GitLab


From 4230a6ebdd88f3f9202e1a55f993f6ac62f8f8e7 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Sun, 4 Apr 2021 13:44:21 +0200
Subject: [PATCH 1352/2400] os: don't use T.Cleanup in TestRemoveAllLongPath

Revert CL 306290 changes to TestRemoveAllLongPath. This breaks the test
on aix, illumos and solaris. We need to chdir out of startPath before
attempting to remove it.

Updates #45182

Change-Id: Ic14fa1962d6f2cc83238f6fc2c6932fd9a6e52a1
Reviewed-on: https://go-review.googlesource.com/c/go/+/307189
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/os/os_windows_test.go | 19 +++++++++++++++++++
 src/os/removeall_test.go  | 35 +++++++++++++++--------------------
 2 files changed, 34 insertions(+), 20 deletions(-)

diff --git a/src/os/os_windows_test.go b/src/os/os_windows_test.go
index b4339c3f7e..f310a75f39 100644
--- a/src/os/os_windows_test.go
+++ b/src/os/os_windows_test.go
@@ -29,6 +29,25 @@ import (
 // For TestRawConnReadWrite.
 type syscallDescriptor = syscall.Handle
 
+// chdir changes the current working directory to the named directory,
+// and then restore the original working directory at the end of the test.
+func chdir(t *testing.T, dir string) {
+	olddir, err := os.Getwd()
+	if err != nil {
+		t.Fatalf("chdir: %v", err)
+	}
+	if err := os.Chdir(dir); err != nil {
+		t.Fatalf("chdir %s: %v", dir, err)
+	}
+
+	t.Cleanup(func() {
+		if err := os.Chdir(olddir); err != nil {
+			t.Errorf("chdir to original working directory %s: %v", olddir, err)
+			os.Exit(1)
+		}
+	})
+}
+
 func TestSameWindowsFile(t *testing.T) {
 	temp, err := os.MkdirTemp("", "TestSameWindowsFile")
 	if err != nil {
diff --git a/src/os/removeall_test.go b/src/os/removeall_test.go
index 45a85792ce..3a2f6e3759 100644
--- a/src/os/removeall_test.go
+++ b/src/os/removeall_test.go
@@ -156,25 +156,6 @@ func TestRemoveAllLarge(t *testing.T) {
 	}
 }
 
-// chdir changes the current working directory to the named directory,
-// and then restore the original working directory at the end of the test.
-func chdir(t *testing.T, dir string) {
-	olddir, err := os.Getwd()
-	if err != nil {
-		t.Fatalf("chdir: %v", err)
-	}
-	if err := os.Chdir(dir); err != nil {
-		t.Fatalf("chdir %s: %v", dir, err)
-	}
-
-	t.Cleanup(func() {
-		if err := os.Chdir(olddir); err != nil {
-			t.Errorf("chdir to original working directory %s: %v", olddir, err)
-			os.Exit(1)
-		}
-	})
-}
-
 func TestRemoveAllLongPath(t *testing.T) {
 	switch runtime.GOOS {
 	case "aix", "darwin", "ios", "dragonfly", "freebsd", "linux", "netbsd", "openbsd", "illumos", "solaris":
@@ -183,12 +164,21 @@ func TestRemoveAllLongPath(t *testing.T) {
 		t.Skip("skipping for not implemented platforms")
 	}
 
+	prevDir, err := Getwd()
+	if err != nil {
+		t.Fatalf("Could not get wd: %s", err)
+	}
+
 	startPath, err := os.MkdirTemp("", "TestRemoveAllLongPath-")
 	if err != nil {
 		t.Fatalf("Could not create TempDir: %s", err)
 	}
 	defer RemoveAll(startPath)
-	chdir(t, startPath)
+
+	err = Chdir(startPath)
+	if err != nil {
+		t.Fatalf("Could not chdir %s: %s", startPath, err)
+	}
 
 	// Removing paths with over 4096 chars commonly fails
 	for i := 0; i < 41; i++ {
@@ -205,6 +195,11 @@ func TestRemoveAllLongPath(t *testing.T) {
 		}
 	}
 
+	err = Chdir(prevDir)
+	if err != nil {
+		t.Fatalf("Could not chdir %s: %s", prevDir, err)
+	}
+
 	err = RemoveAll(startPath)
 	if err != nil {
 		t.Errorf("RemoveAll could not remove long file path %s: %s", startPath, err)
-- 
GitLab


From ee51e3d89520221fb572b54851f6c642df3bd4da Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Wed, 31 Mar 2021 14:19:41 -0400
Subject: [PATCH 1353/2400] cmd/go: refactor modload.ListModules to accept bit
 flags

Instead of accepting bool flags, ListModules now accepts ListMode, a
set of bit flags.

Four flags are defined. listRetracted is split into ListRetracted and
ListRetractedVersion to avoid ambiguity with -u, -retracted, and
-versions.

For #40357

Change-Id: Ibbbe44dc1e285ed17f27a6581f3392679f2124fb
Reviewed-on: https://go-review.googlesource.com/c/go/+/306331
Trust: Jay Conrod <jayconrod@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/list/list.go       | 23 ++++++++++++---
 src/cmd/go/internal/modcmd/download.go |  5 +---
 src/cmd/go/internal/modcmd/why.go      |  5 +---
 src/cmd/go/internal/modload/build.go   | 12 ++++----
 src/cmd/go/internal/modload/list.go    | 39 ++++++++++++++++----------
 5 files changed, 50 insertions(+), 34 deletions(-)

diff --git a/src/cmd/go/internal/list/list.go b/src/cmd/go/internal/list/list.go
index 1e1c6495bf..898a39ea24 100644
--- a/src/cmd/go/internal/list/list.go
+++ b/src/cmd/go/internal/list/list.go
@@ -451,7 +451,20 @@ func runList(ctx context.Context, cmd *base.Command, args []string) {
 			}
 		}
 
-		mods, err := modload.ListModules(ctx, args, *listU, *listVersions, *listRetracted)
+		var mode modload.ListMode
+		if *listU {
+			mode |= modload.ListU | modload.ListRetracted
+		}
+		if *listRetracted {
+			mode |= modload.ListRetracted
+		}
+		if *listVersions {
+			mode |= modload.ListVersions
+			if *listRetracted {
+				mode |= modload.ListRetractedVersions
+			}
+		}
+		mods, err := modload.ListModules(ctx, args, mode)
 		if !*listE {
 			for _, m := range mods {
 				if m.Error != nil {
@@ -686,9 +699,11 @@ func runList(ctx context.Context, cmd *base.Command, args []string) {
 		}
 
 		if len(args) > 0 {
-			listU := false
-			listVersions := false
-			rmods, err := modload.ListModules(ctx, args, listU, listVersions, *listRetracted)
+			var mode modload.ListMode
+			if *listRetracted {
+				mode |= modload.ListRetracted
+			}
+			rmods, err := modload.ListModules(ctx, args, mode)
 			if err != nil && !*listE {
 				base.Errorf("go list -retracted: %v", err)
 			}
diff --git a/src/cmd/go/internal/modcmd/download.go b/src/cmd/go/internal/modcmd/download.go
index 32c5b7f340..a6c6d914e1 100644
--- a/src/cmd/go/internal/modcmd/download.go
+++ b/src/cmd/go/internal/modcmd/download.go
@@ -132,12 +132,9 @@ func runDownload(ctx context.Context, cmd *base.Command, args []string) {
 	}
 
 	var mods []*moduleJSON
-	listU := false
-	listVersions := false
-	listRetractions := false
 	type token struct{}
 	sem := make(chan token, runtime.GOMAXPROCS(0))
-	infos, infosErr := modload.ListModules(ctx, args, listU, listVersions, listRetractions)
+	infos, infosErr := modload.ListModules(ctx, args, 0)
 	for _, info := range infos {
 		if info.Replace != nil {
 			info = info.Replace
diff --git a/src/cmd/go/internal/modcmd/why.go b/src/cmd/go/internal/modcmd/why.go
index d67ac46210..db4a396be1 100644
--- a/src/cmd/go/internal/modcmd/why.go
+++ b/src/cmd/go/internal/modcmd/why.go
@@ -76,16 +76,13 @@ func runWhy(ctx context.Context, cmd *base.Command, args []string) {
 	}
 
 	if *whyM {
-		listU := false
-		listVersions := false
-		listRetractions := false
 		for _, arg := range args {
 			if strings.Contains(arg, "@") {
 				base.Fatalf("go mod why: module query not allowed")
 			}
 		}
 
-		mods, err := modload.ListModules(ctx, args, listU, listVersions, listRetractions)
+		mods, err := modload.ListModules(ctx, args, 0)
 		if err != nil {
 			base.Fatalf("go mod why: %v", err)
 		}
diff --git a/src/cmd/go/internal/modload/build.go b/src/cmd/go/internal/modload/build.go
index 48d20bb5fa..804bd5ecfd 100644
--- a/src/cmd/go/internal/modload/build.go
+++ b/src/cmd/go/internal/modload/build.go
@@ -60,8 +60,7 @@ func PackageModuleInfo(ctx context.Context, pkgpath string) *modinfo.ModulePubli
 	}
 
 	rs := LoadModFile(ctx)
-	listRetracted := false
-	return moduleInfo(ctx, rs, m, listRetracted)
+	return moduleInfo(ctx, rs, m, 0)
 }
 
 func ModuleInfo(ctx context.Context, path string) *modinfo.ModulePublic {
@@ -69,10 +68,9 @@ func ModuleInfo(ctx context.Context, path string) *modinfo.ModulePublic {
 		return nil
 	}
 
-	listRetracted := false
 	if i := strings.Index(path, "@"); i >= 0 {
 		m := module.Version{Path: path[:i], Version: path[i+1:]}
-		return moduleInfo(ctx, nil, m, listRetracted)
+		return moduleInfo(ctx, nil, m, 0)
 	}
 
 	rs := LoadModFile(ctx)
@@ -101,7 +99,7 @@ func ModuleInfo(ctx context.Context, path string) *modinfo.ModulePublic {
 		}
 	}
 
-	return moduleInfo(ctx, rs, module.Version{Path: path, Version: v}, listRetracted)
+	return moduleInfo(ctx, rs, module.Version{Path: path, Version: v}, 0)
 }
 
 // addUpdate fills in m.Update if an updated version is available.
@@ -157,7 +155,7 @@ func addRetraction(ctx context.Context, m *modinfo.ModulePublic) {
 // moduleInfo returns information about module m, loaded from the requirements
 // in rs (which may be nil to indicate that m was not loaded from a requirement
 // graph).
-func moduleInfo(ctx context.Context, rs *Requirements, m module.Version, listRetracted bool) *modinfo.ModulePublic {
+func moduleInfo(ctx context.Context, rs *Requirements, m module.Version, mode ListMode) *modinfo.ModulePublic {
 	if m == Target {
 		info := &modinfo.ModulePublic{
 			Path:    m.Path,
@@ -226,7 +224,7 @@ func moduleInfo(ctx context.Context, rs *Requirements, m module.Version, listRet
 				}
 			}
 
-			if listRetracted {
+			if mode&ListRetracted != 0 {
 				addRetraction(ctx, m)
 			}
 		}
diff --git a/src/cmd/go/internal/modload/list.go b/src/cmd/go/internal/modload/list.go
index 065d6efda6..6082bd5be8 100644
--- a/src/cmd/go/internal/modload/list.go
+++ b/src/cmd/go/internal/modload/list.go
@@ -20,27 +20,36 @@ import (
 	"golang.org/x/mod/module"
 )
 
+type ListMode int
+
+const (
+	ListU ListMode = 1 << iota
+	ListRetracted
+	ListVersions
+	ListRetractedVersions
+)
+
 // ListModules returns a description of the modules matching args, if known,
 // along with any error preventing additional matches from being identified.
 //
 // The returned slice can be nonempty even if the error is non-nil.
-func ListModules(ctx context.Context, args []string, listU, listVersions, listRetracted bool) ([]*modinfo.ModulePublic, error) {
-	rs, mods, err := listModules(ctx, LoadModFile(ctx), args, listVersions, listRetracted)
+func ListModules(ctx context.Context, args []string, mode ListMode) ([]*modinfo.ModulePublic, error) {
+	rs, mods, err := listModules(ctx, LoadModFile(ctx), args, mode)
 
 	type token struct{}
 	sem := make(chan token, runtime.GOMAXPROCS(0))
-	if listU || listVersions || listRetracted {
+	if mode != 0 {
 		for _, m := range mods {
 			add := func(m *modinfo.ModulePublic) {
 				sem <- token{}
 				go func() {
-					if listU {
+					if mode&ListU != 0 {
 						addUpdate(ctx, m)
 					}
-					if listVersions {
-						addVersions(ctx, m, listRetracted)
+					if mode&ListVersions != 0 {
+						addVersions(ctx, m, mode&ListRetractedVersions != 0)
 					}
-					if listRetracted || listU {
+					if mode&ListRetracted != 0 {
 						addRetraction(ctx, m)
 					}
 					<-sem
@@ -64,7 +73,7 @@ func ListModules(ctx context.Context, args []string, listU, listVersions, listRe
 	return mods, err
 }
 
-func listModules(ctx context.Context, rs *Requirements, args []string, listVersions, listRetracted bool) (_ *Requirements, mods []*modinfo.ModulePublic, mgErr error) {
+func listModules(ctx context.Context, rs *Requirements, args []string, mode ListMode) (_ *Requirements, mods []*modinfo.ModulePublic, mgErr error) {
 	var mg *ModuleGraph
 	if go117LazyTODO {
 		// Pull the args-loop below into another (new) loop.
@@ -78,7 +87,7 @@ func listModules(ctx context.Context, rs *Requirements, args []string, listVersi
 	}
 
 	if len(args) == 0 {
-		return rs, []*modinfo.ModulePublic{moduleInfo(ctx, rs, Target, listRetracted)}, mgErr
+		return rs, []*modinfo.ModulePublic{moduleInfo(ctx, rs, Target, mode)}, mgErr
 	}
 
 	matchedModule := map[module.Version]bool{}
@@ -93,7 +102,7 @@ func listModules(ctx context.Context, rs *Requirements, args []string, listVersi
 			if arg == "all" || strings.Contains(arg, "...") {
 				base.Fatalf("go: cannot match %q: %v", arg, ErrNoModRoot)
 			}
-			if !listVersions && !strings.Contains(arg, "@") {
+			if mode&ListVersions == 0 && !strings.Contains(arg, "@") {
 				base.Fatalf("go: cannot match %q without -versions or an explicit version: %v", arg, ErrNoModRoot)
 			}
 		}
@@ -112,7 +121,7 @@ func listModules(ctx context.Context, rs *Requirements, args []string, listVersi
 			}
 
 			allowed := CheckAllowed
-			if IsRevisionQuery(vers) || listRetracted {
+			if IsRevisionQuery(vers) || mode&ListRetracted != 0 {
 				// Allow excluded and retracted versions if the user asked for a
 				// specific revision or used 'go list -retracted'.
 				allowed = nil
@@ -131,7 +140,7 @@ func listModules(ctx context.Context, rs *Requirements, args []string, listVersi
 			// *Requirements instead.
 			var noRS *Requirements
 
-			mod := moduleInfo(ctx, noRS, module.Version{Path: path, Version: info.Version}, listRetracted)
+			mod := moduleInfo(ctx, noRS, module.Version{Path: path, Version: info.Version}, mode)
 			mods = append(mods, mod)
 			continue
 		}
@@ -153,7 +162,7 @@ func listModules(ctx context.Context, rs *Requirements, args []string, listVersi
 				continue
 			}
 			if v != "none" {
-				mods = append(mods, moduleInfo(ctx, rs, module.Version{Path: arg, Version: v}, listRetracted))
+				mods = append(mods, moduleInfo(ctx, rs, module.Version{Path: arg, Version: v}, mode))
 			} else if cfg.BuildMod == "vendor" {
 				// In vendor mode, we can't determine whether a missing module is “a
 				// known dependency” because the module graph is incomplete.
@@ -162,7 +171,7 @@ func listModules(ctx context.Context, rs *Requirements, args []string, listVersi
 					Path:  arg,
 					Error: modinfoError(arg, "", errors.New("can't resolve module using the vendor directory\n\t(Use -mod=mod or -mod=readonly to bypass.)")),
 				})
-			} else if listVersions {
+			} else if mode&ListVersions != 0 {
 				// Don't make the user provide an explicit '@latest' when they're
 				// explicitly asking what the available versions are. Instead, return a
 				// module with version "none", to which we can add the requested list.
@@ -182,7 +191,7 @@ func listModules(ctx context.Context, rs *Requirements, args []string, listVersi
 				matched = true
 				if !matchedModule[m] {
 					matchedModule[m] = true
-					mods = append(mods, moduleInfo(ctx, rs, m, listRetracted))
+					mods = append(mods, moduleInfo(ctx, rs, m, mode))
 				}
 			}
 		}
-- 
GitLab


From 6ed045b365731e59fcae48de48f1aea7a6304eb3 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Wed, 31 Mar 2021 14:25:33 -0400
Subject: [PATCH 1354/2400] cmd/go: refactor modload.CheckRetractions

Extract queryLatestVersionIgnoringRetractions, which returns the
version we should load retractions and deprecations from. This will be
shared with CheckDeprecations.

Rename ShortRetractionRationale to ShortMessage. This will be used to
shorten deprecation warnings as well.

For #40357

Change-Id: Ic1e0c670396bdb3bd87c7a97cf2b14ca58ea1d80
Reviewed-on: https://go-review.googlesource.com/c/go/+/306332
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modload/modfile.go        | 179 ++++++++++--------
 .../testdata/script/mod_retract_rationale.txt |   4 +-
 2 files changed, 104 insertions(+), 79 deletions(-)

diff --git a/src/cmd/go/internal/modload/modfile.go b/src/cmd/go/internal/modload/modfile.go
index 53a7895c4d..6351871844 100644
--- a/src/cmd/go/internal/modload/modfile.go
+++ b/src/cmd/go/internal/modload/modfile.go
@@ -92,73 +92,53 @@ func (e *excludedError) Is(err error) bool { return err == ErrDisallowed }
 
 // CheckRetractions returns an error if module m has been retracted by
 // its author.
-func CheckRetractions(ctx context.Context, m module.Version) error {
+func CheckRetractions(ctx context.Context, m module.Version) (err error) {
+	defer func() {
+		if retractErr := (*ModuleRetractedError)(nil); err == nil || errors.As(err, &retractErr) {
+			return
+		}
+		// Attribute the error to the version being checked, not the version from
+		// which the retractions were to be loaded.
+		if mErr := (*module.ModuleError)(nil); errors.As(err, &mErr) {
+			err = mErr.Err
+		}
+		err = &retractionLoadingError{m: m, err: err}
+	}()
+
 	if m.Version == "" {
 		// Main module, standard library, or file replacement module.
 		// Cannot be retracted.
 		return nil
 	}
-
-	// Look up retraction information from the latest available version of
-	// the module. Cache retraction information so we don't parse the go.mod
-	// file repeatedly.
-	type entry struct {
-		retract []retraction
-		err     error
+	if repl := Replacement(module.Version{Path: m.Path}); repl.Path != "" {
+		// All versions of the module were replaced.
+		// Don't load retractions, since we'd just load the replacement.
+		return nil
 	}
-	path := m.Path
-	e := retractCache.Do(path, func() (v interface{}) {
-		ctx, span := trace.StartSpan(ctx, "checkRetractions "+path)
-		defer span.Done()
-
-		if repl := Replacement(module.Version{Path: m.Path}); repl.Path != "" {
-			// All versions of the module were replaced with a local directory.
-			// Don't load retractions.
-			return &entry{nil, nil}
-		}
 
-		// Find the latest version of the module.
-		// Ignore exclusions from the main module's go.mod.
-		const ignoreSelected = ""
-		var allowAll AllowedFunc
-		rev, err := Query(ctx, path, "latest", ignoreSelected, allowAll)
-		if err != nil {
-			return &entry{nil, err}
-		}
-
-		// Load go.mod for that version.
-		// If the version is replaced, we'll load retractions from the replacement.
-		//
-		// If there's an error loading the go.mod, we'll return it here.
-		// These errors should generally be ignored by callers of checkRetractions,
-		// since they happen frequently when we're offline. These errors are not
-		// equivalent to ErrDisallowed, so they may be distinguished from
-		// retraction errors.
-		//
-		// We load the raw file here: the go.mod file may have a different module
-		// path that we expect if the module or its repository was renamed.
-		// We still want to apply retractions to other aliases of the module.
-		rm := resolveReplacement(module.Version{Path: path, Version: rev.Version})
-		summary, err := rawGoModSummary(rm)
-		if err != nil {
-			return &entry{nil, err}
-		}
-		return &entry{summary.retract, nil}
-	}).(*entry)
-
-	if err := e.err; err != nil {
-		// Attribute the error to the version being checked, not the version from
-		// which the retractions were to be loaded.
-		var mErr *module.ModuleError
-		if errors.As(err, &mErr) {
-			err = mErr.Err
-		}
-		return &retractionLoadingError{m: m, err: err}
+	// Find the latest available version of the module, and load its go.mod. If
+	// the latest version is replaced, we'll load the replacement.
+	//
+	// If there's an error loading the go.mod, we'll return it here. These errors
+	// should generally be ignored by callers since they happen frequently when
+	// we're offline. These errors are not equivalent to ErrDisallowed, so they
+	// may be distinguished from retraction errors.
+	//
+	// We load the raw file here: the go.mod file may have a different module
+	// path that we expect if the module or its repository was renamed.
+	// We still want to apply retractions to other aliases of the module.
+	rm, err := queryLatestVersionIgnoringRetractions(ctx, m.Path)
+	if err != nil {
+		return err
+	}
+	summary, err := rawGoModSummary(rm)
+	if err != nil {
+		return err
 	}
 
 	var rationale []string
 	isRetracted := false
-	for _, r := range e.retract {
+	for _, r := range summary.retract {
 		if semver.Compare(r.Low, m.Version) <= 0 && semver.Compare(m.Version, r.High) <= 0 {
 			isRetracted = true
 			if r.Rationale != "" {
@@ -172,8 +152,6 @@ func CheckRetractions(ctx context.Context, m module.Version) error {
 	return nil
 }
 
-var retractCache par.Cache
-
 type ModuleRetractedError struct {
 	Rationale []string
 }
@@ -183,7 +161,7 @@ func (e *ModuleRetractedError) Error() string {
 	if len(e.Rationale) > 0 {
 		// This is meant to be a short error printed on a terminal, so just
 		// print the first rationale.
-		msg += ": " + ShortRetractionRationale(e.Rationale[0])
+		msg += ": " + ShortMessage(e.Rationale[0], "retracted by module author")
 	}
 	return msg
 }
@@ -205,28 +183,31 @@ func (e *retractionLoadingError) Unwrap() error {
 	return e.err
 }
 
-// ShortRetractionRationale returns a retraction rationale string that is safe
-// to print in a terminal. It returns hard-coded strings if the rationale
-// is empty, too long, or contains non-printable characters.
-func ShortRetractionRationale(rationale string) string {
-	const maxRationaleBytes = 500
-	if i := strings.Index(rationale, "\n"); i >= 0 {
-		rationale = rationale[:i]
-	}
-	rationale = strings.TrimSpace(rationale)
-	if rationale == "" {
-		return "retracted by module author"
-	}
-	if len(rationale) > maxRationaleBytes {
-		return "(rationale omitted: too long)"
-	}
-	for _, r := range rationale {
+// ShortMessage returns a string from go.mod (for example, a retraction
+// rationale or deprecation message) that is safe to print in a terminal.
+//
+// If the given string is empty, ShortMessage returns the given default. If the
+// given string is too long or contains non-printable characters, ShortMessage
+// returns a hard-coded string.
+func ShortMessage(message, emptyDefault string) string {
+	const maxLen = 500
+	if i := strings.Index(message, "\n"); i >= 0 {
+		message = message[:i]
+	}
+	message = strings.TrimSpace(message)
+	if message == "" {
+		return emptyDefault
+	}
+	if len(message) > maxLen {
+		return "(message omitted: too long)"
+	}
+	for _, r := range message {
 		if !unicode.IsGraphic(r) && !unicode.IsSpace(r) {
-			return "(rationale omitted: contains non-printable characters)"
+			return "(message omitted: contains non-printable characters)"
 		}
 	}
 	// NOTE: the go.mod parser rejects invalid UTF-8, so we don't check that here.
-	return rationale
+	return message
 }
 
 // Replacement returns the replacement for mod, if any, from go.mod.
@@ -596,3 +577,47 @@ func rawGoModSummary(m module.Version) (*modFileSummary, error) {
 }
 
 var rawGoModSummaryCache par.Cache // module.Version → rawGoModSummary result
+
+// queryLatestVersionIgnoringRetractions looks up the latest version of the
+// module with the given path without considering retracted or excluded
+// versions.
+//
+// If all versions of the module are replaced,
+// queryLatestVersionIgnoringRetractions returns the replacement without making
+// a query.
+//
+// If the queried latest version is replaced,
+// queryLatestVersionIgnoringRetractions returns the replacement.
+func queryLatestVersionIgnoringRetractions(ctx context.Context, path string) (latest module.Version, err error) {
+	type entry struct {
+		latest module.Version
+		err    error
+	}
+	e := latestVersionIgnoringRetractionsCache.Do(path, func() interface{} {
+		ctx, span := trace.StartSpan(ctx, "queryLatestVersionIgnoringRetractions "+path)
+		defer span.Done()
+
+		if repl := Replacement(module.Version{Path: path}); repl.Path != "" {
+			// All versions of the module were replaced.
+			// No need to query.
+			return &entry{latest: repl}
+		}
+
+		// Find the latest version of the module.
+		// Ignore exclusions from the main module's go.mod.
+		const ignoreSelected = ""
+		var allowAll AllowedFunc
+		rev, err := Query(ctx, path, "latest", ignoreSelected, allowAll)
+		if err != nil {
+			return &entry{err: err}
+		}
+		latest := module.Version{Path: path, Version: rev.Version}
+		if repl := resolveReplacement(latest); repl.Path != "" {
+			latest = repl
+		}
+		return &entry{latest: latest}
+	}).(*entry)
+	return e.latest, e.err
+}
+
+var latestVersionIgnoringRetractionsCache par.Cache // path → queryLatestVersionIgnoringRetractions result
diff --git a/src/cmd/go/testdata/script/mod_retract_rationale.txt b/src/cmd/go/testdata/script/mod_retract_rationale.txt
index 4d3a3d67c6..823c384e48 100644
--- a/src/cmd/go/testdata/script/mod_retract_rationale.txt
+++ b/src/cmd/go/testdata/script/mod_retract_rationale.txt
@@ -29,7 +29,7 @@ cmp stdout multiline
 
 # 'go get' should omit long messages.
 go get -d example.com/retract/rationale@v1.0.0-long
-stderr '^go: warning: example.com/retract/rationale@v1.0.0-long: retracted by module author: \(rationale omitted: too long\)'
+stderr '^go: warning: example.com/retract/rationale@v1.0.0-long: retracted by module author: \(message omitted: too long\)'
 
 # 'go list' should show the full message.
 go list -m -retracted -f '{{.Retracted}}' example.com/retract/rationale
@@ -38,7 +38,7 @@ stdout '^\[lo{500}ng\]$'
 
 # 'go get' should omit messages with unprintable characters.
 go get -d example.com/retract/rationale@v1.0.0-unprintable
-stderr '^go: warning: example.com/retract/rationale@v1.0.0-unprintable: retracted by module author: \(rationale omitted: contains non-printable characters\)'
+stderr '^go: warning: example.com/retract/rationale@v1.0.0-unprintable: retracted by module author: \(message omitted: contains non-printable characters\)'
 
 # 'go list' should show the full message.
 go list -m -retracted -f '{{.Retracted}}' example.com/retract/rationale
-- 
GitLab


From a4b8241d97fb180e1b9cb41c4828345c931d1aaf Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Fri, 2 Apr 2021 16:52:58 -0700
Subject: [PATCH 1355/2400] cmd/compile: get rid of Fields in types.Interface,
 use allMethods in types.Type instead

Confusingly, the set of all methods of an interface is currently set in
Fields field of types.Interface. This is true, even though there is
already an allMethods field (and AllMethods method) of types.Type.
Change so the set of all methods of an interface are stored in
Type.allMethods, and Interface.Fields is removed. Update the comments
for Methods and AllMethods.

Change-Id: Ibc32bafae86831cba62606b079a855690612c759
Reviewed-on: https://go-review.googlesource.com/c/go/+/307209
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/export.go         |  2 +-
 src/cmd/compile/internal/noder/helpers.go     |  2 +-
 src/cmd/compile/internal/noder/stencil.go     |  4 +-
 src/cmd/compile/internal/noder/transform.go   |  2 +-
 .../compile/internal/reflectdata/reflect.go   |  2 +-
 src/cmd/compile/internal/typecheck/subr.go    | 34 ++++++++++---
 .../compile/internal/typecheck/typecheck.go   |  6 ++-
 src/cmd/compile/internal/types/fmt.go         |  4 +-
 src/cmd/compile/internal/types/identity.go    |  6 +--
 src/cmd/compile/internal/types/size.go        |  6 +--
 src/cmd/compile/internal/types/sizeof_test.go |  2 +-
 src/cmd/compile/internal/types/type.go        | 49 +++++++++++--------
 12 files changed, 73 insertions(+), 46 deletions(-)

diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index 4d8221f53b..2137f1d196 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -152,7 +152,7 @@ func (p *exporter) markType(t *types.Type) {
 		}
 
 	case types.TINTER:
-		for _, f := range t.FieldSlice() {
+		for _, f := range t.AllMethods().Slice() {
 			if types.IsExported(f.Sym.Name) {
 				p.markType(f.Type)
 			}
diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
index 6320b30e50..9da0e49300 100644
--- a/src/cmd/compile/internal/noder/helpers.go
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -259,7 +259,7 @@ func dot(pos src.XPos, typ *types.Type, op ir.Op, x ir.Node, selection *types.Fi
 // TODO(mdempsky): Move to package types.
 func method(typ *types.Type, index int) *types.Field {
 	if typ.IsInterface() {
-		return typ.Field(index)
+		return typ.AllMethods().Index(index)
 	}
 	return types.ReceiverBaseType(typ).Methods().Index(index)
 }
diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 4db688571e..0d84db9993 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -625,9 +625,9 @@ func (subst *subster) tinter(t *types.Type) *types.Type {
 	for i, f := range t.Methods().Slice() {
 		t2 := subst.typ(f.Type)
 		if (t2 != f.Type || f.Nname != nil) && newfields == nil {
-			newfields = make([]*types.Field, t.NumFields())
+			newfields = make([]*types.Field, t.Methods().Len())
 			for j := 0; j < i; j++ {
-				newfields[j] = t.Methods().Slice()[j]
+				newfields[j] = t.Methods().Index(j)
 			}
 		}
 		if newfields != nil {
diff --git a/src/cmd/compile/internal/noder/transform.go b/src/cmd/compile/internal/noder/transform.go
index 021d3a9fa7..ffe35d5874 100644
--- a/src/cmd/compile/internal/noder/transform.go
+++ b/src/cmd/compile/internal/noder/transform.go
@@ -568,7 +568,7 @@ func transformMethodExpr(n *ir.SelectorExpr) (res ir.Node) {
 	// Compute the method set for t.
 	var ms *types.Fields
 	if t.IsInterface() {
-		ms = t.Fields()
+		ms = t.AllMethods()
 	} else {
 		mt := types.ReceiverBaseType(t)
 		typecheck.CalcMethods(mt)
diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index c1cded826c..3a31e3c951 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -364,7 +364,7 @@ func methods(t *types.Type) []*typeSig {
 // imethods returns the methods of the interface type t, sorted by name.
 func imethods(t *types.Type) []*typeSig {
 	var methods []*typeSig
-	for _, f := range t.Fields().Slice() {
+	for _, f := range t.AllMethods().Slice() {
 		if f.Type.Kind() != types.TFUNC || f.Sym == nil {
 			continue
 		}
diff --git a/src/cmd/compile/internal/typecheck/subr.go b/src/cmd/compile/internal/typecheck/subr.go
index daf5cd72a2..76c565ebee 100644
--- a/src/cmd/compile/internal/typecheck/subr.go
+++ b/src/cmd/compile/internal/typecheck/subr.go
@@ -221,7 +221,7 @@ func CalcMethods(t *types.Type) {
 
 	ms = append(ms, t.Methods().Slice()...)
 	sort.Sort(types.MethodsByName(ms))
-	t.AllMethods().Set(ms)
+	t.SetAllMethods(ms)
 }
 
 // adddot1 returns the number of fields or methods named s at depth d in Type t.
@@ -257,7 +257,13 @@ func adddot1(s *types.Sym, t *types.Type, d int, save **types.Field, ignorecase
 		return c, false
 	}
 
-	for _, f := range u.Fields().Slice() {
+	var fields *types.Fields
+	if u.IsStruct() {
+		fields = u.Fields()
+	} else {
+		fields = u.AllMethods()
+	}
+	for _, f := range fields.Slice() {
 		if f.Embedded == 0 || f.Sym == nil {
 			continue
 		}
@@ -619,7 +625,7 @@ func expand0(t *types.Type) {
 	}
 
 	if u.IsInterface() {
-		for _, f := range u.Fields().Slice() {
+		for _, f := range u.AllMethods().Slice() {
 			if f.Sym.Uniq() {
 				continue
 			}
@@ -658,7 +664,13 @@ func expand1(t *types.Type, top bool) {
 	}
 
 	if u.IsStruct() || u.IsInterface() {
-		for _, f := range u.Fields().Slice() {
+		var fields *types.Fields
+		if u.IsStruct() {
+			fields = u.Fields()
+		} else {
+			fields = u.AllMethods()
+		}
+		for _, f := range fields.Slice() {
 			if f.Embedded == 0 {
 				continue
 			}
@@ -708,8 +720,8 @@ func implements(t, iface *types.Type, m, samename **types.Field, ptr *int) bool
 
 	if t.IsInterface() {
 		i := 0
-		tms := t.Fields().Slice()
-		for _, im := range iface.Fields().Slice() {
+		tms := t.AllMethods().Slice()
+		for _, im := range iface.AllMethods().Slice() {
 			for i < len(tms) && tms[i].Sym != im.Sym {
 				i++
 			}
@@ -738,7 +750,7 @@ func implements(t, iface *types.Type, m, samename **types.Field, ptr *int) bool
 		tms = t.AllMethods().Slice()
 	}
 	i := 0
-	for _, im := range iface.Fields().Slice() {
+	for _, im := range iface.AllMethods().Slice() {
 		if im.Broke() {
 			continue
 		}
@@ -806,7 +818,13 @@ func lookdot0(s *types.Sym, t *types.Type, save **types.Field, ignorecase bool)
 
 	c := 0
 	if u.IsStruct() || u.IsInterface() {
-		for _, f := range u.Fields().Slice() {
+		var fields *types.Fields
+		if u.IsStruct() {
+			fields = u.Fields()
+		} else {
+			fields = u.AllMethods()
+		}
+		for _, f := range fields.Slice() {
 			if f.Sym == s || (ignorecase && f.IsMethod() && strings.EqualFold(f.Sym.Name, s.Name)) {
 				if save != nil {
 					*save = f
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 54f7cd9efa..ab493e0caa 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -1103,7 +1103,7 @@ func typecheckMethodExpr(n *ir.SelectorExpr) (res ir.Node) {
 	// Compute the method set for t.
 	var ms *types.Fields
 	if t.IsInterface() {
-		ms = t.Fields()
+		ms = t.AllMethods()
 	} else {
 		mt := types.ReceiverBaseType(t)
 		if mt == nil {
@@ -1170,8 +1170,10 @@ func Lookdot(n *ir.SelectorExpr, t *types.Type, dostrcmp int) *types.Field {
 
 	types.CalcSize(t)
 	var f1 *types.Field
-	if t.IsStruct() || t.IsInterface() {
+	if t.IsStruct() {
 		f1 = Lookdot1(n, s, t, t.Fields(), dostrcmp)
+	} else if t.IsInterface() {
+		f1 = Lookdot1(n, s, t, t.AllMethods(), dostrcmp)
 	}
 
 	var f2 *types.Field
diff --git a/src/cmd/compile/internal/types/fmt.go b/src/cmd/compile/internal/types/fmt.go
index e29c826bb7..b538ea8054 100644
--- a/src/cmd/compile/internal/types/fmt.go
+++ b/src/cmd/compile/internal/types/fmt.go
@@ -442,7 +442,7 @@ func tconv2(b *bytes.Buffer, t *Type, verb rune, mode fmtMode, visited map[*Type
 			break
 		}
 		b.WriteString("interface {")
-		for i, f := range t.Fields().Slice() {
+		for i, f := range t.AllMethods().Slice() {
 			if i != 0 {
 				b.WriteByte(';')
 			}
@@ -462,7 +462,7 @@ func tconv2(b *bytes.Buffer, t *Type, verb rune, mode fmtMode, visited map[*Type
 			}
 			tconv2(b, f.Type, 'S', mode, visited)
 		}
-		if t.NumFields() != 0 {
+		if t.AllMethods().Len() != 0 {
 			b.WriteByte(' ')
 		}
 		b.WriteByte('}')
diff --git a/src/cmd/compile/internal/types/identity.go b/src/cmd/compile/internal/types/identity.go
index 9bc636d7ff..dde9f51856 100644
--- a/src/cmd/compile/internal/types/identity.go
+++ b/src/cmd/compile/internal/types/identity.go
@@ -61,11 +61,11 @@ func identical(t1, t2 *Type, cmpTags bool, assumedEqual map[typePair]struct{}) b
 		return true
 
 	case TINTER:
-		if t1.NumFields() != t2.NumFields() {
+		if t1.AllMethods().Len() != t2.AllMethods().Len() {
 			return false
 		}
-		for i, f1 := range t1.FieldSlice() {
-			f2 := t2.Field(i)
+		for i, f1 := range t1.AllMethods().Slice() {
+			f2 := t2.AllMethods().Index(i)
 			if f1.Sym != f2.Sym || !identical(f1.Type, f2.Type, cmpTags, assumedEqual) {
 				return false
 			}
diff --git a/src/cmd/compile/internal/types/size.go b/src/cmd/compile/internal/types/size.go
index a75429f0ab..f0e695ab96 100644
--- a/src/cmd/compile/internal/types/size.go
+++ b/src/cmd/compile/internal/types/size.go
@@ -119,7 +119,7 @@ func expandiface(t *Type) {
 		// Embedded interface: duplicate all methods
 		// (including broken ones, if any) and add to t's
 		// method set.
-		for _, t1 := range m.Type.Fields().Slice() {
+		for _, t1 := range m.Type.AllMethods().Slice() {
 			// Use m.Pos rather than t1.Pos to preserve embedding position.
 			f := NewField(m.Pos, t1.Sym, t1.Type)
 			addMethod(f, false)
@@ -135,9 +135,7 @@ func expandiface(t *Type) {
 		m.Offset = int64(i) * int64(PtrSize)
 	}
 
-	// Access fields directly to avoid recursively calling CalcSize
-	// within Type.Fields().
-	t.Extra.(*Interface).Fields.Set(methods)
+	t.SetAllMethods(methods)
 }
 
 func calcStructOffset(errtype *Type, t *Type, o int64, flag int) int64 {
diff --git a/src/cmd/compile/internal/types/sizeof_test.go b/src/cmd/compile/internal/types/sizeof_test.go
index f80de937be..4c3ef69346 100644
--- a/src/cmd/compile/internal/types/sizeof_test.go
+++ b/src/cmd/compile/internal/types/sizeof_test.go
@@ -26,7 +26,7 @@ func TestSizeof(t *testing.T) {
 		{Forward{}, 20, 32},
 		{Func{}, 28, 48},
 		{Struct{}, 16, 32},
-		{Interface{}, 8, 16},
+		{Interface{}, 4, 8},
 		{Chan{}, 8, 16},
 		{Array{}, 12, 16},
 		{FuncArgs{}, 4, 8},
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 762cdd3258..969195b850 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -368,8 +368,7 @@ func (t *Type) StructType() *Struct {
 
 // Interface contains Type fields specific to interface types.
 type Interface struct {
-	Fields Fields
-	pkg    *Pkg
+	pkg *Pkg
 }
 
 // Ptr contains Type fields specific to pointer types.
@@ -922,40 +921,49 @@ func (t *Type) IsFuncArgStruct() bool {
 	return t.kind == TSTRUCT && t.Extra.(*Struct).Funarg != FunargNone
 }
 
+// Methods returns a pointer to the base methods (excluding embedding) for type t.
+// These can either be concrete methods (for non-interface types) or interface
+// methods (for interface types).
 func (t *Type) Methods() *Fields {
-	// TODO(mdempsky): Validate t?
 	return &t.methods
 }
 
+// AllMethods returns a pointer to all the methods (including embedding) for type t.
+// For an interface type, this is the set of methods that are typically iterated over.
 func (t *Type) AllMethods() *Fields {
-	// TODO(mdempsky): Validate t?
+	if t.kind == TINTER {
+		// Calculate the full method set of an interface type on the fly
+		// now, if not done yet.
+		CalcSize(t)
+	}
 	return &t.allMethods
 }
 
+// SetAllMethods sets the set of all methods (including embedding) for type t.
+// Use this method instead of t.AllMethods().Set(), which might call CalcSize() on
+// an uninitialized interface type.
+func (t *Type) SetAllMethods(fs []*Field) {
+	t.allMethods.Set(fs)
+}
+
+// Fields returns the fields of struct type t.
 func (t *Type) Fields() *Fields {
-	switch t.kind {
-	case TSTRUCT:
-		return &t.Extra.(*Struct).fields
-	case TINTER:
-		CalcSize(t)
-		return &t.Extra.(*Interface).Fields
-	}
-	base.Fatalf("Fields: type %v does not have fields", t)
-	return nil
+	t.wantEtype(TSTRUCT)
+	return &t.Extra.(*Struct).fields
 }
 
-// Field returns the i'th field/method of struct/interface type t.
+// Field returns the i'th field of struct type t.
 func (t *Type) Field(i int) *Field {
 	return t.Fields().Slice()[i]
 }
 
-// FieldSlice returns a slice of containing all fields/methods of
-// struct/interface type t.
+// FieldSlice returns a slice of containing all fields of
+// a struct type t.
 func (t *Type) FieldSlice() []*Field {
 	return t.Fields().Slice()
 }
 
-// SetFields sets struct/interface type t's fields/methods to fields.
+// SetFields sets struct type t's fields to fields.
 func (t *Type) SetFields(fields []*Field) {
 	// If we've calculated the width of t before,
 	// then some other type such as a function signature
@@ -981,6 +989,7 @@ func (t *Type) SetFields(fields []*Field) {
 	t.Fields().Set(fields)
 }
 
+// SetInterface sets the base methods of an interface type t.
 func (t *Type) SetInterface(methods []*Field) {
 	t.wantEtype(TINTER)
 	t.Methods().Set(methods)
@@ -1231,8 +1240,8 @@ func (t *Type) cmp(x *Type) Cmp {
 		return CMPeq
 
 	case TINTER:
-		tfs := t.FieldSlice()
-		xfs := x.FieldSlice()
+		tfs := t.AllMethods().Slice()
+		xfs := x.AllMethods().Slice()
 		for i := 0; i < len(tfs) && i < len(xfs); i++ {
 			t1, x1 := tfs[i], xfs[i]
 			if c := t1.Sym.cmpsym(x1.Sym); c != CMPeq {
@@ -1420,7 +1429,7 @@ func (t *Type) IsInterface() bool {
 
 // IsEmptyInterface reports whether t is an empty interface type.
 func (t *Type) IsEmptyInterface() bool {
-	return t.IsInterface() && t.NumFields() == 0
+	return t.IsInterface() && t.AllMethods().Len() == 0
 }
 
 // IsScalar reports whether 't' is a scalar Go type, e.g.
-- 
GitLab


From af1789a61c02fa769fcd4ab8addcbb9a160b987b Mon Sep 17 00:00:00 2001
From: Ruslan Andreev <ruslan.andreev@huawei.com>
Date: Wed, 13 Jan 2021 22:36:19 +0800
Subject: [PATCH 1356/2400] runtime: extend internal atomics to comply with
 sync/atomic

The CV add changes according to TODO in Go source-code.
Internal atomic set does not comply with sync/atomic library and has shortage
operations for signed integers.
This patch extend internal atomic set by Int32 and Int64 operations. It's
implemented new aliases and asm versions of operations. As a result Cas64 was
replaced by Casint64 in findRunnableGCWorker without type casting.
Another purpose is unified structure of internal atomics' source code. Before,
assembly impementations for different archs were in different files. For
example, filename for AMD64 was asm_amd64.s, but filename for RISC-V was
atomic_riscv64.s. Some arches have both files without any meaning. So, assembly
files were merged and renamed to atomic_{$ARCH}.s filenames.

Change-Id: I29a05a7cbf5f4a9cc146e8315536c038af545677
Reviewed-on: https://go-review.googlesource.com/c/go/+/289152
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ssagen/ssa.go        |  23 +-
 src/runtime/internal/atomic/asm_amd64.s       | 187 -----------
 src/runtime/internal/atomic/asm_arm64.s       |  61 ----
 src/runtime/internal/atomic/asm_mips64x.s     | 271 ---------------
 src/runtime/internal/atomic/asm_mipsx.s       | 200 -----------
 src/runtime/internal/atomic/asm_ppc64x.s      | 253 --------------
 .../atomic/{asm_386.s => atomic_386.s}        |  28 +-
 src/runtime/internal/atomic/atomic_amd64.s    | 225 +++++++++++++
 .../atomic/{asm_arm.s => atomic_arm.s}        |  33 +-
 src/runtime/internal/atomic/atomic_arm64.s    | 139 ++++++--
 src/runtime/internal/atomic/atomic_mips64x.s  | 316 +++++++++++++++++-
 src/runtime/internal/atomic/atomic_mipsx.s    | 233 +++++++++++++
 src/runtime/internal/atomic/atomic_ppc64x.s   | 295 +++++++++++++++-
 src/runtime/internal/atomic/atomic_riscv64.s  |  29 +-
 .../atomic/{asm_s390x.s => atomic_s390x.s}    |  32 ++
 src/runtime/internal/atomic/atomic_wasm.go    |  72 ++++
 .../atomic/{asm_wasm.s => atomic_wasm.s}      |   2 +-
 src/runtime/internal/atomic/stubs.go          |  24 ++
 src/runtime/internal/atomic/sys_linux_arm.s   |   2 +-
 src/runtime/mgc.go                            |   3 +-
 20 files changed, 1401 insertions(+), 1027 deletions(-)
 delete mode 100644 src/runtime/internal/atomic/asm_amd64.s
 delete mode 100644 src/runtime/internal/atomic/asm_arm64.s
 delete mode 100644 src/runtime/internal/atomic/asm_mips64x.s
 delete mode 100644 src/runtime/internal/atomic/asm_mipsx.s
 delete mode 100644 src/runtime/internal/atomic/asm_ppc64x.s
 rename src/runtime/internal/atomic/{asm_386.s => atomic_386.s} (90%)
 create mode 100644 src/runtime/internal/atomic/atomic_amd64.s
 rename src/runtime/internal/atomic/{asm_arm.s => atomic_arm.s} (91%)
 rename src/runtime/internal/atomic/{asm_s390x.s => atomic_s390x.s} (86%)
 rename src/runtime/internal/atomic/{asm_wasm.s => atomic_wasm.s} (78%)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 9c1c493233..67c9e9c198 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -4042,18 +4042,23 @@ func InitTables() {
 		makeAtomicGuardedIntrinsicARM64(ssa.OpAtomicOr32, ssa.OpAtomicOr32Variant, types.TNIL, types.TNIL, atomicAndOrEmitterARM64),
 		sys.ARM64)
 
+	// Aliases for atomic load operations
+	alias("runtime/internal/atomic", "Loadint32", "runtime/internal/atomic", "Load", all...)
 	alias("runtime/internal/atomic", "Loadint64", "runtime/internal/atomic", "Load64", all...)
-	alias("runtime/internal/atomic", "Xaddint64", "runtime/internal/atomic", "Xadd64", all...)
-	alias("runtime/internal/atomic", "Loaduint", "runtime/internal/atomic", "Load", p4...)
-	alias("runtime/internal/atomic", "Loaduint", "runtime/internal/atomic", "Load64", p8...)
 	alias("runtime/internal/atomic", "Loaduintptr", "runtime/internal/atomic", "Load", p4...)
 	alias("runtime/internal/atomic", "Loaduintptr", "runtime/internal/atomic", "Load64", p8...)
+	alias("runtime/internal/atomic", "Loaduint", "runtime/internal/atomic", "Load", p4...)
+	alias("runtime/internal/atomic", "Loaduint", "runtime/internal/atomic", "Load64", p8...)
 	alias("runtime/internal/atomic", "LoadAcq", "runtime/internal/atomic", "Load", lwatomics...)
 	alias("runtime/internal/atomic", "LoadAcq64", "runtime/internal/atomic", "Load64", lwatomics...)
 	alias("runtime/internal/atomic", "LoadAcquintptr", "runtime/internal/atomic", "LoadAcq", p4...)
 	alias("sync", "runtime_LoadAcquintptr", "runtime/internal/atomic", "LoadAcq", p4...) // linknamed
 	alias("runtime/internal/atomic", "LoadAcquintptr", "runtime/internal/atomic", "LoadAcq64", p8...)
 	alias("sync", "runtime_LoadAcquintptr", "runtime/internal/atomic", "LoadAcq64", p8...) // linknamed
+
+	// Aliases for atomic store operations
+	alias("runtime/internal/atomic", "Storeint32", "runtime/internal/atomic", "Store", all...)
+	alias("runtime/internal/atomic", "Storeint64", "runtime/internal/atomic", "Store64", all...)
 	alias("runtime/internal/atomic", "Storeuintptr", "runtime/internal/atomic", "Store", p4...)
 	alias("runtime/internal/atomic", "Storeuintptr", "runtime/internal/atomic", "Store64", p8...)
 	alias("runtime/internal/atomic", "StoreRel", "runtime/internal/atomic", "Store", lwatomics...)
@@ -4062,10 +4067,22 @@ func InitTables() {
 	alias("sync", "runtime_StoreReluintptr", "runtime/internal/atomic", "StoreRel", p4...) // linknamed
 	alias("runtime/internal/atomic", "StoreReluintptr", "runtime/internal/atomic", "StoreRel64", p8...)
 	alias("sync", "runtime_StoreReluintptr", "runtime/internal/atomic", "StoreRel64", p8...) // linknamed
+
+	// Aliases for atomic swap operations
+	alias("runtime/internal/atomic", "Xchgint32", "runtime/internal/atomic", "Xchg", all...)
+	alias("runtime/internal/atomic", "Xchgint64", "runtime/internal/atomic", "Xchg64", all...)
 	alias("runtime/internal/atomic", "Xchguintptr", "runtime/internal/atomic", "Xchg", p4...)
 	alias("runtime/internal/atomic", "Xchguintptr", "runtime/internal/atomic", "Xchg64", p8...)
+
+	// Aliases for atomic add operations
+	alias("runtime/internal/atomic", "Xaddint32", "runtime/internal/atomic", "Xadd", all...)
+	alias("runtime/internal/atomic", "Xaddint64", "runtime/internal/atomic", "Xadd64", all...)
 	alias("runtime/internal/atomic", "Xadduintptr", "runtime/internal/atomic", "Xadd", p4...)
 	alias("runtime/internal/atomic", "Xadduintptr", "runtime/internal/atomic", "Xadd64", p8...)
+
+	// Aliases for atomic CAS operations
+	alias("runtime/internal/atomic", "Casint32", "runtime/internal/atomic", "Cas", all...)
+	alias("runtime/internal/atomic", "Casint64", "runtime/internal/atomic", "Cas64", all...)
 	alias("runtime/internal/atomic", "Casuintptr", "runtime/internal/atomic", "Cas", p4...)
 	alias("runtime/internal/atomic", "Casuintptr", "runtime/internal/atomic", "Cas64", p8...)
 	alias("runtime/internal/atomic", "Casp1", "runtime/internal/atomic", "Cas", p4...)
diff --git a/src/runtime/internal/atomic/asm_amd64.s b/src/runtime/internal/atomic/asm_amd64.s
deleted file mode 100644
index 2cf7c55870..0000000000
--- a/src/runtime/internal/atomic/asm_amd64.s
+++ /dev/null
@@ -1,187 +0,0 @@
-// Copyright 2015 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.
-
-// Note: some of these functions are semantically inlined
-// by the compiler (in src/cmd/compile/internal/gc/ssa.go).
-
-#include "textflag.h"
-
-// bool Cas(int32 *val, int32 old, int32 new)
-// Atomically:
-//	if(*val == old){
-//		*val = new;
-//		return 1;
-//	} else
-//		return 0;
-TEXT runtime∕internal∕atomic·Cas(SB),NOSPLIT,$0-17
-	MOVQ	ptr+0(FP), BX
-	MOVL	old+8(FP), AX
-	MOVL	new+12(FP), CX
-	LOCK
-	CMPXCHGL	CX, 0(BX)
-	SETEQ	ret+16(FP)
-	RET
-
-// bool	runtime∕internal∕atomic·Cas64(uint64 *val, uint64 old, uint64 new)
-// Atomically:
-//	if(*val == *old){
-//		*val = new;
-//		return 1;
-//	} else {
-//		return 0;
-//	}
-TEXT runtime∕internal∕atomic·Cas64(SB), NOSPLIT, $0-25
-	MOVQ	ptr+0(FP), BX
-	MOVQ	old+8(FP), AX
-	MOVQ	new+16(FP), CX
-	LOCK
-	CMPXCHGQ	CX, 0(BX)
-	SETEQ	ret+24(FP)
-	RET
-
-TEXT runtime∕internal∕atomic·Casuintptr(SB), NOSPLIT, $0-25
-	JMP	runtime∕internal∕atomic·Cas64(SB)
-
-TEXT runtime∕internal∕atomic·CasRel(SB), NOSPLIT, $0-17
-	JMP	runtime∕internal∕atomic·Cas(SB)
-
-TEXT runtime∕internal∕atomic·Loaduintptr(SB), NOSPLIT, $0-16
-	JMP	runtime∕internal∕atomic·Load64(SB)
-
-TEXT runtime∕internal∕atomic·Loaduint(SB), NOSPLIT, $0-16
-	JMP	runtime∕internal∕atomic·Load64(SB)
-
-TEXT runtime∕internal∕atomic·Storeuintptr(SB), NOSPLIT, $0-16
-	JMP	runtime∕internal∕atomic·Store64(SB)
-
-TEXT runtime∕internal∕atomic·Loadint64(SB), NOSPLIT, $0-16
-	JMP	runtime∕internal∕atomic·Load64(SB)
-
-TEXT runtime∕internal∕atomic·Xaddint64(SB), NOSPLIT, $0-24
-	JMP	runtime∕internal∕atomic·Xadd64(SB)
-
-// bool Casp1(void **val, void *old, void *new)
-// Atomically:
-//	if(*val == old){
-//		*val = new;
-//		return 1;
-//	} else
-//		return 0;
-TEXT runtime∕internal∕atomic·Casp1(SB), NOSPLIT, $0-25
-	MOVQ	ptr+0(FP), BX
-	MOVQ	old+8(FP), AX
-	MOVQ	new+16(FP), CX
-	LOCK
-	CMPXCHGQ	CX, 0(BX)
-	SETEQ	ret+24(FP)
-	RET
-
-// uint32 Xadd(uint32 volatile *val, int32 delta)
-// Atomically:
-//	*val += delta;
-//	return *val;
-TEXT runtime∕internal∕atomic·Xadd(SB), NOSPLIT, $0-20
-	MOVQ	ptr+0(FP), BX
-	MOVL	delta+8(FP), AX
-	MOVL	AX, CX
-	LOCK
-	XADDL	AX, 0(BX)
-	ADDL	CX, AX
-	MOVL	AX, ret+16(FP)
-	RET
-
-TEXT runtime∕internal∕atomic·Xadd64(SB), NOSPLIT, $0-24
-	MOVQ	ptr+0(FP), BX
-	MOVQ	delta+8(FP), AX
-	MOVQ	AX, CX
-	LOCK
-	XADDQ	AX, 0(BX)
-	ADDQ	CX, AX
-	MOVQ	AX, ret+16(FP)
-	RET
-
-TEXT runtime∕internal∕atomic·Xadduintptr(SB), NOSPLIT, $0-24
-	JMP	runtime∕internal∕atomic·Xadd64(SB)
-
-TEXT runtime∕internal∕atomic·Xchg(SB), NOSPLIT, $0-20
-	MOVQ	ptr+0(FP), BX
-	MOVL	new+8(FP), AX
-	XCHGL	AX, 0(BX)
-	MOVL	AX, ret+16(FP)
-	RET
-
-TEXT runtime∕internal∕atomic·Xchg64(SB), NOSPLIT, $0-24
-	MOVQ	ptr+0(FP), BX
-	MOVQ	new+8(FP), AX
-	XCHGQ	AX, 0(BX)
-	MOVQ	AX, ret+16(FP)
-	RET
-
-TEXT runtime∕internal∕atomic·Xchguintptr(SB), NOSPLIT, $0-24
-	JMP	runtime∕internal∕atomic·Xchg64(SB)
-
-TEXT runtime∕internal∕atomic·StorepNoWB(SB), NOSPLIT, $0-16
-	MOVQ	ptr+0(FP), BX
-	MOVQ	val+8(FP), AX
-	XCHGQ	AX, 0(BX)
-	RET
-
-TEXT runtime∕internal∕atomic·Store(SB), NOSPLIT, $0-12
-	MOVQ	ptr+0(FP), BX
-	MOVL	val+8(FP), AX
-	XCHGL	AX, 0(BX)
-	RET
-
-TEXT runtime∕internal∕atomic·StoreRel(SB), NOSPLIT, $0-12
-	JMP	runtime∕internal∕atomic·Store(SB)
-
-TEXT runtime∕internal∕atomic·StoreRel64(SB), NOSPLIT, $0-16
-	JMP	runtime∕internal∕atomic·Store64(SB)
-
-TEXT runtime∕internal∕atomic·StoreReluintptr(SB), NOSPLIT, $0-16
-	JMP	runtime∕internal∕atomic·Store64(SB)
-
-TEXT runtime∕internal∕atomic·Store8(SB), NOSPLIT, $0-9
-	MOVQ	ptr+0(FP), BX
-	MOVB	val+8(FP), AX
-	XCHGB	AX, 0(BX)
-	RET
-
-TEXT runtime∕internal∕atomic·Store64(SB), NOSPLIT, $0-16
-	MOVQ	ptr+0(FP), BX
-	MOVQ	val+8(FP), AX
-	XCHGQ	AX, 0(BX)
-	RET
-
-// void	runtime∕internal∕atomic·Or8(byte volatile*, byte);
-TEXT runtime∕internal∕atomic·Or8(SB), NOSPLIT, $0-9
-	MOVQ	ptr+0(FP), AX
-	MOVB	val+8(FP), BX
-	LOCK
-	ORB	BX, (AX)
-	RET
-
-// void	runtime∕internal∕atomic·And8(byte volatile*, byte);
-TEXT runtime∕internal∕atomic·And8(SB), NOSPLIT, $0-9
-	MOVQ	ptr+0(FP), AX
-	MOVB	val+8(FP), BX
-	LOCK
-	ANDB	BX, (AX)
-	RET
-
-// func Or(addr *uint32, v uint32)
-TEXT runtime∕internal∕atomic·Or(SB), NOSPLIT, $0-12
-	MOVQ	ptr+0(FP), AX
-	MOVL	val+8(FP), BX
-	LOCK
-	ORL	BX, (AX)
-	RET
-
-// func And(addr *uint32, v uint32)
-TEXT runtime∕internal∕atomic·And(SB), NOSPLIT, $0-12
-	MOVQ	ptr+0(FP), AX
-	MOVL	val+8(FP), BX
-	LOCK
-	ANDL	BX, (AX)
-	RET
diff --git a/src/runtime/internal/atomic/asm_arm64.s b/src/runtime/internal/atomic/asm_arm64.s
deleted file mode 100644
index 8336a859ad..0000000000
--- a/src/runtime/internal/atomic/asm_arm64.s
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright 2015 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.
-
-#include "textflag.h"
-
-// bool Cas(uint32 *ptr, uint32 old, uint32 new)
-// Atomically:
-//	if(*val == old){
-//		*val = new;
-//		return 1;
-//	} else
-//		return 0;
-TEXT runtime∕internal∕atomic·Cas(SB), NOSPLIT, $0-17
-	MOVD	ptr+0(FP), R0
-	MOVW	old+8(FP), R1
-	MOVW	new+12(FP), R2
-again:
-	LDAXRW	(R0), R3
-	CMPW	R1, R3
-	BNE	ok
-	STLXRW	R2, (R0), R3
-	CBNZ	R3, again
-ok:
-	CSET	EQ, R0
-	MOVB	R0, ret+16(FP)
-	RET
-
-TEXT runtime∕internal∕atomic·Casuintptr(SB), NOSPLIT, $0-25
-	B	runtime∕internal∕atomic·Cas64(SB)
-
-TEXT runtime∕internal∕atomic·CasRel(SB), NOSPLIT, $0-17
-	B	runtime∕internal∕atomic·Cas(SB)
-
-TEXT runtime∕internal∕atomic·Loaduintptr(SB), NOSPLIT, $0-16
-	B	runtime∕internal∕atomic·Load64(SB)
-
-TEXT runtime∕internal∕atomic·Loaduint(SB), NOSPLIT, $0-16
-	B	runtime∕internal∕atomic·Load64(SB)
-
-TEXT runtime∕internal∕atomic·Storeuintptr(SB), NOSPLIT, $0-16
-	B	runtime∕internal∕atomic·Store64(SB)
-
-TEXT runtime∕internal∕atomic·Xadduintptr(SB), NOSPLIT, $0-24
-	B	runtime∕internal∕atomic·Xadd64(SB)
-
-TEXT runtime∕internal∕atomic·Loadint64(SB), NOSPLIT, $0-16
-	B	runtime∕internal∕atomic·Load64(SB)
-
-TEXT runtime∕internal∕atomic·Xaddint64(SB), NOSPLIT, $0-24
-	B	runtime∕internal∕atomic·Xadd64(SB)
-
-// bool Casp1(void **val, void *old, void *new)
-// Atomically:
-//	if(*val == old){
-//		*val = new;
-//		return 1;
-//	} else
-//		return 0;
-TEXT runtime∕internal∕atomic·Casp1(SB), NOSPLIT, $0-25
-	B runtime∕internal∕atomic·Cas64(SB)
diff --git a/src/runtime/internal/atomic/asm_mips64x.s b/src/runtime/internal/atomic/asm_mips64x.s
deleted file mode 100644
index a515683ebb..0000000000
--- a/src/runtime/internal/atomic/asm_mips64x.s
+++ /dev/null
@@ -1,271 +0,0 @@
-// Copyright 2015 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.
-
-// +build mips64 mips64le
-
-#include "textflag.h"
-
-// bool cas(uint32 *ptr, uint32 old, uint32 new)
-// Atomically:
-//	if(*val == old){
-//		*val = new;
-//		return 1;
-//	} else
-//		return 0;
-TEXT ·Cas(SB), NOSPLIT, $0-17
-	MOVV	ptr+0(FP), R1
-	MOVW	old+8(FP), R2
-	MOVW	new+12(FP), R5
-	SYNC
-cas_again:
-	MOVV	R5, R3
-	LL	(R1), R4
-	BNE	R2, R4, cas_fail
-	SC	R3, (R1)
-	BEQ	R3, cas_again
-	MOVV	$1, R1
-	MOVB	R1, ret+16(FP)
-	SYNC
-	RET
-cas_fail:
-	MOVV	$0, R1
-	JMP	-4(PC)
-
-// bool	cas64(uint64 *ptr, uint64 old, uint64 new)
-// Atomically:
-//	if(*val == *old){
-//		*val = new;
-//		return 1;
-//	} else {
-//		return 0;
-//	}
-TEXT ·Cas64(SB), NOSPLIT, $0-25
-	MOVV	ptr+0(FP), R1
-	MOVV	old+8(FP), R2
-	MOVV	new+16(FP), R5
-	SYNC
-cas64_again:
-	MOVV	R5, R3
-	LLV	(R1), R4
-	BNE	R2, R4, cas64_fail
-	SCV	R3, (R1)
-	BEQ	R3, cas64_again
-	MOVV	$1, R1
-	MOVB	R1, ret+24(FP)
-	SYNC
-	RET
-cas64_fail:
-	MOVV	$0, R1
-	JMP	-4(PC)
-
-TEXT ·Casuintptr(SB), NOSPLIT, $0-25
-	JMP	·Cas64(SB)
-
-TEXT ·CasRel(SB), NOSPLIT, $0-17
-	JMP	·Cas(SB)
-
-TEXT ·Loaduintptr(SB),  NOSPLIT|NOFRAME, $0-16
-	JMP	·Load64(SB)
-
-TEXT ·Loaduint(SB), NOSPLIT|NOFRAME, $0-16
-	JMP	·Load64(SB)
-
-TEXT ·Storeuintptr(SB), NOSPLIT, $0-16
-	JMP	·Store64(SB)
-
-TEXT ·Xadduintptr(SB), NOSPLIT, $0-24
-	JMP	·Xadd64(SB)
-
-TEXT ·Loadint64(SB), NOSPLIT, $0-16
-	JMP	·Load64(SB)
-
-TEXT ·Xaddint64(SB), NOSPLIT, $0-24
-	JMP	·Xadd64(SB)
-
-// bool casp(void **val, void *old, void *new)
-// Atomically:
-//	if(*val == old){
-//		*val = new;
-//		return 1;
-//	} else
-//		return 0;
-TEXT ·Casp1(SB), NOSPLIT, $0-25
-	JMP runtime∕internal∕atomic·Cas64(SB)
-
-// uint32 xadd(uint32 volatile *ptr, int32 delta)
-// Atomically:
-//	*val += delta;
-//	return *val;
-TEXT ·Xadd(SB), NOSPLIT, $0-20
-	MOVV	ptr+0(FP), R2
-	MOVW	delta+8(FP), R3
-	SYNC
-	LL	(R2), R1
-	ADDU	R1, R3, R4
-	MOVV	R4, R1
-	SC	R4, (R2)
-	BEQ	R4, -4(PC)
-	MOVW	R1, ret+16(FP)
-	SYNC
-	RET
-
-TEXT ·Xadd64(SB), NOSPLIT, $0-24
-	MOVV	ptr+0(FP), R2
-	MOVV	delta+8(FP), R3
-	SYNC
-	LLV	(R2), R1
-	ADDVU	R1, R3, R4
-	MOVV	R4, R1
-	SCV	R4, (R2)
-	BEQ	R4, -4(PC)
-	MOVV	R1, ret+16(FP)
-	SYNC
-	RET
-
-TEXT ·Xchg(SB), NOSPLIT, $0-20
-	MOVV	ptr+0(FP), R2
-	MOVW	new+8(FP), R5
-
-	SYNC
-	MOVV	R5, R3
-	LL	(R2), R1
-	SC	R3, (R2)
-	BEQ	R3, -3(PC)
-	MOVW	R1, ret+16(FP)
-	SYNC
-	RET
-
-TEXT ·Xchg64(SB), NOSPLIT, $0-24
-	MOVV	ptr+0(FP), R2
-	MOVV	new+8(FP), R5
-
-	SYNC
-	MOVV	R5, R3
-	LLV	(R2), R1
-	SCV	R3, (R2)
-	BEQ	R3, -3(PC)
-	MOVV	R1, ret+16(FP)
-	SYNC
-	RET
-
-TEXT ·Xchguintptr(SB), NOSPLIT, $0-24
-	JMP	·Xchg64(SB)
-
-TEXT ·StorepNoWB(SB), NOSPLIT, $0-16
-	JMP	·Store64(SB)
-
-TEXT ·StoreRel(SB), NOSPLIT, $0-12
-	JMP	·Store(SB)
-
-TEXT ·StoreRel64(SB), NOSPLIT, $0-16
-	JMP	·Store64(SB)
-
-TEXT ·StoreReluintptr(SB), NOSPLIT, $0-16
-	JMP	·Store64(SB)
-
-TEXT ·Store(SB), NOSPLIT, $0-12
-	MOVV	ptr+0(FP), R1
-	MOVW	val+8(FP), R2
-	SYNC
-	MOVW	R2, 0(R1)
-	SYNC
-	RET
-
-TEXT ·Store8(SB), NOSPLIT, $0-9
-	MOVV	ptr+0(FP), R1
-	MOVB	val+8(FP), R2
-	SYNC
-	MOVB	R2, 0(R1)
-	SYNC
-	RET
-
-TEXT ·Store64(SB), NOSPLIT, $0-16
-	MOVV	ptr+0(FP), R1
-	MOVV	val+8(FP), R2
-	SYNC
-	MOVV	R2, 0(R1)
-	SYNC
-	RET
-
-// void	Or8(byte volatile*, byte);
-TEXT ·Or8(SB), NOSPLIT, $0-9
-	MOVV	ptr+0(FP), R1
-	MOVBU	val+8(FP), R2
-	// Align ptr down to 4 bytes so we can use 32-bit load/store.
-	MOVV	$~3, R3
-	AND	R1, R3
-	// Compute val shift.
-#ifdef GOARCH_mips64
-	// Big endian.  ptr = ptr ^ 3
-	XOR	$3, R1
-#endif
-	// R4 = ((ptr & 3) * 8)
-	AND	$3, R1, R4
-	SLLV	$3, R4
-	// Shift val for aligned ptr. R2 = val << R4
-	SLLV	R4, R2
-
-	SYNC
-	LL	(R3), R4
-	OR	R2, R4
-	SC	R4, (R3)
-	BEQ	R4, -4(PC)
-	SYNC
-	RET
-
-// void	And8(byte volatile*, byte);
-TEXT ·And8(SB), NOSPLIT, $0-9
-	MOVV	ptr+0(FP), R1
-	MOVBU	val+8(FP), R2
-	// Align ptr down to 4 bytes so we can use 32-bit load/store.
-	MOVV	$~3, R3
-	AND	R1, R3
-	// Compute val shift.
-#ifdef GOARCH_mips64
-	// Big endian.  ptr = ptr ^ 3
-	XOR	$3, R1
-#endif
-	// R4 = ((ptr & 3) * 8)
-	AND	$3, R1, R4
-	SLLV	$3, R4
-	// Shift val for aligned ptr. R2 = val << R4 | ^(0xFF << R4)
-	MOVV	$0xFF, R5
-	SLLV	R4, R2
-	SLLV	R4, R5
-	NOR	R0, R5
-	OR	R5, R2
-
-	SYNC
-	LL	(R3), R4
-	AND	R2, R4
-	SC	R4, (R3)
-	BEQ	R4, -4(PC)
-	SYNC
-	RET
-
-// func Or(addr *uint32, v uint32)
-TEXT ·Or(SB), NOSPLIT, $0-12
-	MOVV	ptr+0(FP), R1
-	MOVW	val+8(FP), R2
-
-	SYNC
-	LL	(R1), R3
-	OR	R2, R3
-	SC	R3, (R1)
-	BEQ	R3, -4(PC)
-	SYNC
-	RET
-
-// func And(addr *uint32, v uint32)
-TEXT ·And(SB), NOSPLIT, $0-12
-	MOVV	ptr+0(FP), R1
-	MOVW	val+8(FP), R2
-
-	SYNC
-	LL	(R1), R3
-	AND	R2, R3
-	SC	R3, (R1)
-	BEQ	R3, -4(PC)
-	SYNC
-	RET
diff --git a/src/runtime/internal/atomic/asm_mipsx.s b/src/runtime/internal/atomic/asm_mipsx.s
deleted file mode 100644
index 2b2cfabe08..0000000000
--- a/src/runtime/internal/atomic/asm_mipsx.s
+++ /dev/null
@@ -1,200 +0,0 @@
-// Copyright 2016 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.
-
-// +build mips mipsle
-
-#include "textflag.h"
-
-TEXT ·Cas(SB),NOSPLIT,$0-13
-	MOVW	ptr+0(FP), R1
-	MOVW	old+4(FP), R2
-	MOVW	new+8(FP), R5
-	SYNC
-try_cas:
-	MOVW	R5, R3
-	LL	(R1), R4	// R4 = *R1
-	BNE	R2, R4, cas_fail
-	SC	R3, (R1)	// *R1 = R3
-	BEQ	R3, try_cas
-	SYNC
-	MOVB	R3, ret+12(FP)
-	RET
-cas_fail:
-	MOVB	R0, ret+12(FP)
-	RET
-
-TEXT ·Store(SB),NOSPLIT,$0-8
-	MOVW	ptr+0(FP), R1
-	MOVW	val+4(FP), R2
-	SYNC
-	MOVW	R2, 0(R1)
-	SYNC
-	RET
-
-TEXT ·Store8(SB),NOSPLIT,$0-5
-	MOVW	ptr+0(FP), R1
-	MOVB	val+4(FP), R2
-	SYNC
-	MOVB	R2, 0(R1)
-	SYNC
-	RET
-
-TEXT ·Load(SB),NOSPLIT,$0-8
-	MOVW	ptr+0(FP), R1
-	SYNC
-	MOVW	0(R1), R1
-	SYNC
-	MOVW	R1, ret+4(FP)
-	RET
-
-TEXT ·Load8(SB),NOSPLIT,$0-5
-	MOVW	ptr+0(FP), R1
-	SYNC
-	MOVB	0(R1), R1
-	SYNC
-	MOVB	R1, ret+4(FP)
-	RET
-
-TEXT ·Xadd(SB),NOSPLIT,$0-12
-	MOVW	ptr+0(FP), R2
-	MOVW	delta+4(FP), R3
-	SYNC
-try_xadd:
-	LL	(R2), R1	// R1 = *R2
-	ADDU	R1, R3, R4
-	MOVW	R4, R1
-	SC	R4, (R2)	// *R2 = R4
-	BEQ	R4, try_xadd
-	SYNC
-	MOVW	R1, ret+8(FP)
-	RET
-
-TEXT ·Xchg(SB),NOSPLIT,$0-12
-	MOVW	ptr+0(FP), R2
-	MOVW	new+4(FP), R5
-	SYNC
-try_xchg:
-	MOVW	R5, R3
-	LL	(R2), R1	// R1 = *R2
-	SC	R3, (R2)	// *R2 = R3
-	BEQ	R3, try_xchg
-	SYNC
-	MOVW	R1, ret+8(FP)
-	RET
-
-TEXT ·Casuintptr(SB),NOSPLIT,$0-13
-	JMP	·Cas(SB)
-
-TEXT ·CasRel(SB),NOSPLIT,$0-13
-	JMP	·Cas(SB)
-
-TEXT ·Loaduintptr(SB),NOSPLIT,$0-8
-	JMP	·Load(SB)
-
-TEXT ·Loaduint(SB),NOSPLIT,$0-8
-	JMP	·Load(SB)
-
-TEXT ·Loadp(SB),NOSPLIT,$-0-8
-	JMP	·Load(SB)
-
-TEXT ·Storeuintptr(SB),NOSPLIT,$0-8
-	JMP	·Store(SB)
-
-TEXT ·Xadduintptr(SB),NOSPLIT,$0-12
-	JMP	·Xadd(SB)
-
-TEXT ·Loadint64(SB),NOSPLIT,$0-12
-	JMP	·Load64(SB)
-
-TEXT ·Xaddint64(SB),NOSPLIT,$0-20
-	JMP	·Xadd64(SB)
-
-TEXT ·Casp1(SB),NOSPLIT,$0-13
-	JMP	·Cas(SB)
-
-TEXT ·Xchguintptr(SB),NOSPLIT,$0-12
-	JMP	·Xchg(SB)
-
-TEXT ·StorepNoWB(SB),NOSPLIT,$0-8
-	JMP	·Store(SB)
-
-TEXT ·StoreRel(SB),NOSPLIT,$0-8
-	JMP	·Store(SB)
-
-TEXT ·StoreReluintptr(SB),NOSPLIT,$0-8
-	JMP	·Store(SB)
-
-// void	Or8(byte volatile*, byte);
-TEXT ·Or8(SB),NOSPLIT,$0-5
-	MOVW	ptr+0(FP), R1
-	MOVBU	val+4(FP), R2
-	MOVW	$~3, R3	// Align ptr down to 4 bytes so we can use 32-bit load/store.
-	AND	R1, R3
-#ifdef GOARCH_mips
-	// Big endian.  ptr = ptr ^ 3
-	XOR	$3, R1
-#endif
-	AND	$3, R1, R4	// R4 = ((ptr & 3) * 8)
-	SLL	$3, R4
-	SLL	R4, R2, R2	// Shift val for aligned ptr. R2 = val << R4
-	SYNC
-try_or8:
-	LL	(R3), R4	// R4 = *R3
-	OR	R2, R4
-	SC	R4, (R3)	// *R3 = R4
-	BEQ	R4, try_or8
-	SYNC
-	RET
-
-// void	And8(byte volatile*, byte);
-TEXT ·And8(SB),NOSPLIT,$0-5
-	MOVW	ptr+0(FP), R1
-	MOVBU	val+4(FP), R2
-	MOVW	$~3, R3
-	AND	R1, R3
-#ifdef GOARCH_mips
-	// Big endian.  ptr = ptr ^ 3
-	XOR	$3, R1
-#endif
-	AND	$3, R1, R4	// R4 = ((ptr & 3) * 8)
-	SLL	$3, R4
-	MOVW	$0xFF, R5
-	SLL	R4, R2
-	SLL	R4, R5
-	NOR	R0, R5
-	OR	R5, R2	// Shift val for aligned ptr. R2 = val << R4 | ^(0xFF << R4)
-	SYNC
-try_and8:
-	LL	(R3), R4	// R4 = *R3
-	AND	R2, R4
-	SC	R4, (R3)	// *R3 = R4
-	BEQ	R4, try_and8
-	SYNC
-	RET
-
-// func Or(addr *uint32, v uint32)
-TEXT ·Or(SB), NOSPLIT, $0-8
-	MOVW	ptr+0(FP), R1
-	MOVW	val+4(FP), R2
-
-	SYNC
-	LL	(R1), R3
-	OR	R2, R3
-	SC	R3, (R1)
-	BEQ	R3, -4(PC)
-	SYNC
-	RET
-
-// func And(addr *uint32, v uint32)
-TEXT ·And(SB), NOSPLIT, $0-8
-	MOVW	ptr+0(FP), R1
-	MOVW	val+4(FP), R2
-
-	SYNC
-	LL	(R1), R3
-	AND	R2, R3
-	SC	R3, (R1)
-	BEQ	R3, -4(PC)
-	SYNC
-	RET
diff --git a/src/runtime/internal/atomic/asm_ppc64x.s b/src/runtime/internal/atomic/asm_ppc64x.s
deleted file mode 100644
index bb009ab34d..0000000000
--- a/src/runtime/internal/atomic/asm_ppc64x.s
+++ /dev/null
@@ -1,253 +0,0 @@
-// Copyright 2015 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.
-
-// +build ppc64 ppc64le
-
-#include "textflag.h"
-
-// bool cas(uint32 *ptr, uint32 old, uint32 new)
-// Atomically:
-//	if(*val == old){
-//		*val = new;
-//		return 1;
-//	} else
-//		return 0;
-TEXT runtime∕internal∕atomic·Cas(SB), NOSPLIT, $0-17
-	MOVD	ptr+0(FP), R3
-	MOVWZ	old+8(FP), R4
-	MOVWZ	new+12(FP), R5
-	LWSYNC
-cas_again:
-	LWAR	(R3), R6
-	CMPW	R6, R4
-	BNE	cas_fail
-	STWCCC	R5, (R3)
-	BNE	cas_again
-	MOVD	$1, R3
-	LWSYNC
-	MOVB	R3, ret+16(FP)
-	RET
-cas_fail:
-	MOVB	R0, ret+16(FP)
-	RET
-
-// bool	runtime∕internal∕atomic·Cas64(uint64 *ptr, uint64 old, uint64 new)
-// Atomically:
-//	if(*val == *old){
-//		*val = new;
-//		return 1;
-//	} else {
-//		return 0;
-//	}
-TEXT runtime∕internal∕atomic·Cas64(SB), NOSPLIT, $0-25
-	MOVD	ptr+0(FP), R3
-	MOVD	old+8(FP), R4
-	MOVD	new+16(FP), R5
-	LWSYNC
-cas64_again:
-	LDAR	(R3), R6
-	CMP	R6, R4
-	BNE	cas64_fail
-	STDCCC	R5, (R3)
-	BNE	cas64_again
-	MOVD	$1, R3
-	LWSYNC
-	MOVB	R3, ret+24(FP)
-	RET
-cas64_fail:
-	MOVB	R0, ret+24(FP)
-	RET
-
-TEXT runtime∕internal∕atomic·CasRel(SB), NOSPLIT, $0-17
-	MOVD    ptr+0(FP), R3
-	MOVWZ   old+8(FP), R4
-	MOVWZ   new+12(FP), R5
-	LWSYNC
-cas_again:
-	LWAR    (R3), $0, R6        // 0 = Mutex release hint
-	CMPW    R6, R4
-	BNE     cas_fail
-	STWCCC  R5, (R3)
-	BNE     cas_again
-	MOVD    $1, R3
-	MOVB    R3, ret+16(FP)
-	RET
-cas_fail:
-	MOVB    R0, ret+16(FP)
-	RET
-
-TEXT runtime∕internal∕atomic·Casuintptr(SB), NOSPLIT, $0-25
-	BR	runtime∕internal∕atomic·Cas64(SB)
-
-TEXT runtime∕internal∕atomic·Loaduintptr(SB),  NOSPLIT|NOFRAME, $0-16
-	BR	runtime∕internal∕atomic·Load64(SB)
-
-TEXT runtime∕internal∕atomic·LoadAcquintptr(SB),  NOSPLIT|NOFRAME, $0-16
-	BR	runtime∕internal∕atomic·LoadAcq64(SB)
-
-TEXT runtime∕internal∕atomic·Loaduint(SB), NOSPLIT|NOFRAME, $0-16
-	BR	runtime∕internal∕atomic·Load64(SB)
-
-TEXT runtime∕internal∕atomic·Storeuintptr(SB), NOSPLIT, $0-16
-	BR	runtime∕internal∕atomic·Store64(SB)
-
-TEXT runtime∕internal∕atomic·StoreReluintptr(SB), NOSPLIT, $0-16
-	BR	runtime∕internal∕atomic·StoreRel64(SB)
-
-TEXT runtime∕internal∕atomic·Xadduintptr(SB), NOSPLIT, $0-24
-	BR	runtime∕internal∕atomic·Xadd64(SB)
-
-TEXT runtime∕internal∕atomic·Loadint64(SB), NOSPLIT, $0-16
-	BR	runtime∕internal∕atomic·Load64(SB)
-
-TEXT runtime∕internal∕atomic·Xaddint64(SB), NOSPLIT, $0-24
-	BR	runtime∕internal∕atomic·Xadd64(SB)
-
-// bool casp(void **val, void *old, void *new)
-// Atomically:
-//	if(*val == old){
-//		*val = new;
-//		return 1;
-//	} else
-//		return 0;
-TEXT runtime∕internal∕atomic·Casp1(SB), NOSPLIT, $0-25
-	BR runtime∕internal∕atomic·Cas64(SB)
-
-// uint32 xadd(uint32 volatile *ptr, int32 delta)
-// Atomically:
-//	*val += delta;
-//	return *val;
-TEXT runtime∕internal∕atomic·Xadd(SB), NOSPLIT, $0-20
-	MOVD	ptr+0(FP), R4
-	MOVW	delta+8(FP), R5
-	LWSYNC
-	LWAR	(R4), R3
-	ADD	R5, R3
-	STWCCC	R3, (R4)
-	BNE	-3(PC)
-	MOVW	R3, ret+16(FP)
-	RET
-
-TEXT runtime∕internal∕atomic·Xadd64(SB), NOSPLIT, $0-24
-	MOVD	ptr+0(FP), R4
-	MOVD	delta+8(FP), R5
-	LWSYNC
-	LDAR	(R4), R3
-	ADD	R5, R3
-	STDCCC	R3, (R4)
-	BNE	-3(PC)
-	MOVD	R3, ret+16(FP)
-	RET
-
-TEXT runtime∕internal∕atomic·Xchg(SB), NOSPLIT, $0-20
-	MOVD	ptr+0(FP), R4
-	MOVW	new+8(FP), R5
-	LWSYNC
-	LWAR	(R4), R3
-	STWCCC	R5, (R4)
-	BNE	-2(PC)
-	ISYNC
-	MOVW	R3, ret+16(FP)
-	RET
-
-TEXT runtime∕internal∕atomic·Xchg64(SB), NOSPLIT, $0-24
-	MOVD	ptr+0(FP), R4
-	MOVD	new+8(FP), R5
-	LWSYNC
-	LDAR	(R4), R3
-	STDCCC	R5, (R4)
-	BNE	-2(PC)
-	ISYNC
-	MOVD	R3, ret+16(FP)
-	RET
-
-TEXT runtime∕internal∕atomic·Xchguintptr(SB), NOSPLIT, $0-24
-	BR	runtime∕internal∕atomic·Xchg64(SB)
-
-
-TEXT runtime∕internal∕atomic·StorepNoWB(SB), NOSPLIT, $0-16
-	BR	runtime∕internal∕atomic·Store64(SB)
-
-TEXT runtime∕internal∕atomic·Store(SB), NOSPLIT, $0-12
-	MOVD	ptr+0(FP), R3
-	MOVW	val+8(FP), R4
-	SYNC
-	MOVW	R4, 0(R3)
-	RET
-
-TEXT runtime∕internal∕atomic·Store8(SB), NOSPLIT, $0-9
-	MOVD	ptr+0(FP), R3
-	MOVB	val+8(FP), R4
-	SYNC
-	MOVB	R4, 0(R3)
-	RET
-
-TEXT runtime∕internal∕atomic·Store64(SB), NOSPLIT, $0-16
-	MOVD	ptr+0(FP), R3
-	MOVD	val+8(FP), R4
-	SYNC
-	MOVD	R4, 0(R3)
-	RET
-
-TEXT runtime∕internal∕atomic·StoreRel(SB), NOSPLIT, $0-12
-	MOVD	ptr+0(FP), R3
-	MOVW	val+8(FP), R4
-	LWSYNC
-	MOVW	R4, 0(R3)
-	RET
-
-TEXT runtime∕internal∕atomic·StoreRel64(SB), NOSPLIT, $0-16
-	MOVD	ptr+0(FP), R3
-	MOVD	val+8(FP), R4
-	LWSYNC
-	MOVD	R4, 0(R3)
-	RET
-
-// void runtime∕internal∕atomic·Or8(byte volatile*, byte);
-TEXT runtime∕internal∕atomic·Or8(SB), NOSPLIT, $0-9
-	MOVD	ptr+0(FP), R3
-	MOVBZ	val+8(FP), R4
-	LWSYNC
-again:
-	LBAR	(R3), R6
-	OR	R4, R6
-	STBCCC	R6, (R3)
-	BNE	again
-	RET
-
-// void runtime∕internal∕atomic·And8(byte volatile*, byte);
-TEXT runtime∕internal∕atomic·And8(SB), NOSPLIT, $0-9
-	MOVD	ptr+0(FP), R3
-	MOVBZ	val+8(FP), R4
-	LWSYNC
-again:
-	LBAR	(R3), R6
-	AND	R4, R6
-	STBCCC	R6, (R3)
-	BNE	again
-	RET
-
-// func Or(addr *uint32, v uint32)
-TEXT runtime∕internal∕atomic·Or(SB), NOSPLIT, $0-12
-	MOVD	ptr+0(FP), R3
-	MOVW	val+8(FP), R4
-	LWSYNC
-again:
-	LWAR	(R3), R6
-	OR	R4, R6
-	STWCCC	R6, (R3)
-	BNE	again
-	RET
-
-// func And(addr *uint32, v uint32)
-TEXT runtime∕internal∕atomic·And(SB), NOSPLIT, $0-12
-	MOVD	ptr+0(FP), R3
-	MOVW	val+8(FP), R4
-	LWSYNC
-again:
-	LWAR	(R3),R6
-	AND	R4, R6
-	STWCCC	R6, (R3)
-	BNE	again
-	RET
diff --git a/src/runtime/internal/atomic/asm_386.s b/src/runtime/internal/atomic/atomic_386.s
similarity index 90%
rename from src/runtime/internal/atomic/asm_386.s
rename to src/runtime/internal/atomic/atomic_386.s
index d82faef1f0..37318e0ad7 100644
--- a/src/runtime/internal/atomic/asm_386.s
+++ b/src/runtime/internal/atomic/atomic_386.s
@@ -21,6 +21,12 @@ TEXT ·Cas(SB), NOSPLIT, $0-13
 	SETEQ	ret+12(FP)
 	RET
 
+TEXT ·Casint32(SB), NOSPLIT, $0-13
+	JMP	·Cas(SB)
+
+TEXT ·Casint64(SB), NOSPLIT, $0-21
+	JMP	·Cas64(SB)
+
 TEXT ·Casuintptr(SB), NOSPLIT, $0-13
 	JMP	·Cas(SB)
 
@@ -33,15 +39,27 @@ TEXT ·Loaduintptr(SB), NOSPLIT, $0-8
 TEXT ·Loaduint(SB), NOSPLIT, $0-8
 	JMP	·Load(SB)
 
+TEXT ·Storeint32(SB), NOSPLIT, $0-8
+	JMP	·Store(SB)
+
+TEXT ·Storeint64(SB), NOSPLIT, $0-12
+	JMP	·Store64(SB)
+
 TEXT ·Storeuintptr(SB), NOSPLIT, $0-8
 	JMP	·Store(SB)
 
 TEXT ·Xadduintptr(SB), NOSPLIT, $0-12
 	JMP	·Xadd(SB)
 
+TEXT ·Loadint32(SB), NOSPLIT, $0-8
+	JMP	·Load(SB)
+
 TEXT ·Loadint64(SB), NOSPLIT, $0-12
 	JMP	·Load64(SB)
 
+TEXT ·Xaddint32(SB), NOSPLIT, $0-12
+	JMP	·Xadd(SB)
+
 TEXT ·Xaddint64(SB), NOSPLIT, $0-20
 	JMP	·Xadd64(SB)
 
@@ -142,6 +160,12 @@ TEXT ·Xchg(SB), NOSPLIT, $0-12
 	MOVL	AX, ret+8(FP)
 	RET
 
+TEXT ·Xchgint32(SB), NOSPLIT, $0-12
+	JMP	·Xchg(SB)
+
+TEXT ·Xchgint64(SB), NOSPLIT, $0-20
+	JMP	·Xchg64(SB)
+
 TEXT ·Xchguintptr(SB), NOSPLIT, $0-12
 	JMP	·Xchg(SB)
 
@@ -189,8 +213,8 @@ TEXT ·Store(SB), NOSPLIT, $0-8
 TEXT ·StoreRel(SB), NOSPLIT, $0-8
 	JMP	·Store(SB)
 
-TEXT runtime∕internal∕atomic·StoreReluintptr(SB), NOSPLIT, $0-8
-	JMP	runtime∕internal∕atomic·Store(SB)
+TEXT ·StoreReluintptr(SB), NOSPLIT, $0-8
+	JMP	·Store(SB)
 
 // uint64 atomicload64(uint64 volatile* addr);
 TEXT ·Load64(SB), NOSPLIT, $0-12
diff --git a/src/runtime/internal/atomic/atomic_amd64.s b/src/runtime/internal/atomic/atomic_amd64.s
new file mode 100644
index 0000000000..57cd59dd8c
--- /dev/null
+++ b/src/runtime/internal/atomic/atomic_amd64.s
@@ -0,0 +1,225 @@
+// Copyright 2015 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.
+
+// Note: some of these functions are semantically inlined
+// by the compiler (in src/cmd/compile/internal/gc/ssa.go).
+
+#include "textflag.h"
+
+TEXT ·Loaduintptr(SB), NOSPLIT, $0-16
+	JMP	·Load64(SB)
+
+TEXT ·Loaduint(SB), NOSPLIT, $0-16
+	JMP	·Load64(SB)
+
+TEXT ·Loadint32(SB), NOSPLIT, $0-12
+	JMP	·Load(SB)
+
+TEXT ·Loadint64(SB), NOSPLIT, $0-16
+	JMP	·Load64(SB)
+
+// bool Cas(int32 *val, int32 old, int32 new)
+// Atomically:
+//	if(*val == old){
+//		*val = new;
+//		return 1;
+//	} else
+//		return 0;
+TEXT ·Cas(SB),NOSPLIT,$0-17
+	MOVQ	ptr+0(FP), BX
+	MOVL	old+8(FP), AX
+	MOVL	new+12(FP), CX
+	LOCK
+	CMPXCHGL	CX, 0(BX)
+	SETEQ	ret+16(FP)
+	RET
+
+// bool	·Cas64(uint64 *val, uint64 old, uint64 new)
+// Atomically:
+//	if(*val == *old){
+//		*val = new;
+//		return 1;
+//	} else {
+//		return 0;
+//	}
+TEXT ·Cas64(SB), NOSPLIT, $0-25
+	MOVQ	ptr+0(FP), BX
+	MOVQ	old+8(FP), AX
+	MOVQ	new+16(FP), CX
+	LOCK
+	CMPXCHGQ	CX, 0(BX)
+	SETEQ	ret+24(FP)
+	RET
+
+// bool Casp1(void **val, void *old, void *new)
+// Atomically:
+//	if(*val == old){
+//		*val = new;
+//		return 1;
+//	} else
+//		return 0;
+TEXT ·Casp1(SB), NOSPLIT, $0-25
+	MOVQ	ptr+0(FP), BX
+	MOVQ	old+8(FP), AX
+	MOVQ	new+16(FP), CX
+	LOCK
+	CMPXCHGQ	CX, 0(BX)
+	SETEQ	ret+24(FP)
+	RET
+
+TEXT ·Casint32(SB), NOSPLIT, $0-17
+	JMP	·Cas(SB)
+
+TEXT ·Casint64(SB), NOSPLIT, $0-25
+	JMP	·Cas64(SB)
+
+TEXT ·Casuintptr(SB), NOSPLIT, $0-25
+	JMP	·Cas64(SB)
+
+TEXT ·CasRel(SB), NOSPLIT, $0-17
+	JMP	·Cas(SB)
+
+// uint32 Xadd(uint32 volatile *val, int32 delta)
+// Atomically:
+//	*val += delta;
+//	return *val;
+TEXT ·Xadd(SB), NOSPLIT, $0-20
+	MOVQ	ptr+0(FP), BX
+	MOVL	delta+8(FP), AX
+	MOVL	AX, CX
+	LOCK
+	XADDL	AX, 0(BX)
+	ADDL	CX, AX
+	MOVL	AX, ret+16(FP)
+	RET
+
+// uint64 Xadd64(uint64 volatile *val, int64 delta)
+// Atomically:
+//	*val += delta;
+//	return *val;
+TEXT ·Xadd64(SB), NOSPLIT, $0-24
+	MOVQ	ptr+0(FP), BX
+	MOVQ	delta+8(FP), AX
+	MOVQ	AX, CX
+	LOCK
+	XADDQ	AX, 0(BX)
+	ADDQ	CX, AX
+	MOVQ	AX, ret+16(FP)
+	RET
+
+TEXT ·Xaddint32(SB), NOSPLIT, $0-20
+	JMP	·Xadd(SB)
+
+TEXT ·Xaddint64(SB), NOSPLIT, $0-24
+	JMP	·Xadd64(SB)
+
+TEXT ·Xadduintptr(SB), NOSPLIT, $0-24
+	JMP	·Xadd64(SB)
+
+// uint32 Xchg(ptr *uint32, new uint32)
+// Atomically:
+//	old := *ptr;
+//	*ptr = new;
+//	return old;
+TEXT ·Xchg(SB), NOSPLIT, $0-20
+	MOVQ	ptr+0(FP), BX
+	MOVL	new+8(FP), AX
+	XCHGL	AX, 0(BX)
+	MOVL	AX, ret+16(FP)
+	RET
+
+// uint64 Xchg64(ptr *uint64, new uint64)
+// Atomically:
+//	old := *ptr;
+//	*ptr = new;
+//	return old;
+TEXT ·Xchg64(SB), NOSPLIT, $0-24
+	MOVQ	ptr+0(FP), BX
+	MOVQ	new+8(FP), AX
+	XCHGQ	AX, 0(BX)
+	MOVQ	AX, ret+16(FP)
+	RET
+
+TEXT ·Xchgint32(SB), NOSPLIT, $0-20
+	JMP	·Xchg(SB)
+
+TEXT ·Xchgint64(SB), NOSPLIT, $0-24
+	JMP	·Xchg64(SB)
+
+TEXT ·Xchguintptr(SB), NOSPLIT, $0-24
+	JMP	·Xchg64(SB)
+
+TEXT ·StorepNoWB(SB), NOSPLIT, $0-16
+	MOVQ	ptr+0(FP), BX
+	MOVQ	val+8(FP), AX
+	XCHGQ	AX, 0(BX)
+	RET
+
+TEXT ·Store(SB), NOSPLIT, $0-12
+	MOVQ	ptr+0(FP), BX
+	MOVL	val+8(FP), AX
+	XCHGL	AX, 0(BX)
+	RET
+
+TEXT ·Store8(SB), NOSPLIT, $0-9
+	MOVQ	ptr+0(FP), BX
+	MOVB	val+8(FP), AX
+	XCHGB	AX, 0(BX)
+	RET
+
+TEXT ·Store64(SB), NOSPLIT, $0-16
+	MOVQ	ptr+0(FP), BX
+	MOVQ	val+8(FP), AX
+	XCHGQ	AX, 0(BX)
+	RET
+
+TEXT ·Storeint32(SB), NOSPLIT, $0-12
+	JMP	·Store(SB)
+
+TEXT ·Storeint64(SB), NOSPLIT, $0-16
+	JMP	·Store64(SB)
+
+TEXT ·Storeuintptr(SB), NOSPLIT, $0-16
+	JMP	·Store64(SB)
+
+TEXT ·StoreRel(SB), NOSPLIT, $0-12
+	JMP	·Store(SB)
+
+TEXT ·StoreRel64(SB), NOSPLIT, $0-16
+	JMP	·Store64(SB)
+
+TEXT ·StoreReluintptr(SB), NOSPLIT, $0-16
+	JMP	·Store64(SB)
+
+// void	·Or8(byte volatile*, byte);
+TEXT ·Or8(SB), NOSPLIT, $0-9
+	MOVQ	ptr+0(FP), AX
+	MOVB	val+8(FP), BX
+	LOCK
+	ORB	BX, (AX)
+	RET
+
+// void	·And8(byte volatile*, byte);
+TEXT ·And8(SB), NOSPLIT, $0-9
+	MOVQ	ptr+0(FP), AX
+	MOVB	val+8(FP), BX
+	LOCK
+	ANDB	BX, (AX)
+	RET
+
+// func Or(addr *uint32, v uint32)
+TEXT ·Or(SB), NOSPLIT, $0-12
+	MOVQ	ptr+0(FP), AX
+	MOVL	val+8(FP), BX
+	LOCK
+	ORL	BX, (AX)
+	RET
+
+// func And(addr *uint32, v uint32)
+TEXT ·And(SB), NOSPLIT, $0-12
+	MOVQ	ptr+0(FP), AX
+	MOVL	val+8(FP), BX
+	LOCK
+	ANDL	BX, (AX)
+	RET
diff --git a/src/runtime/internal/atomic/asm_arm.s b/src/runtime/internal/atomic/atomic_arm.s
similarity index 91%
rename from src/runtime/internal/atomic/asm_arm.s
rename to src/runtime/internal/atomic/atomic_arm.s
index 274925ed60..be3fd3a395 100644
--- a/src/runtime/internal/atomic/asm_arm.s
+++ b/src/runtime/internal/atomic/atomic_arm.s
@@ -60,6 +60,12 @@ TEXT ·LoadAcq(SB),NOSPLIT|NOFRAME,$0-8
 TEXT ·LoadAcquintptr(SB),NOSPLIT|NOFRAME,$0-8
 	B 	·Load(SB)
 
+TEXT ·Casint32(SB),NOSPLIT,$0-13
+	B	·Cas(SB)
+
+TEXT ·Casint64(SB),NOSPLIT,$-4-21
+	B	·Cas64(SB)
+
 TEXT ·Casuintptr(SB),NOSPLIT,$0-13
 	B	·Cas(SB)
 
@@ -69,12 +75,24 @@ TEXT ·Casp1(SB),NOSPLIT,$0-13
 TEXT ·CasRel(SB),NOSPLIT,$0-13
 	B	·Cas(SB)
 
+TEXT ·Loadint32(SB),NOSPLIT,$0-8
+	B	·Load(SB)
+
+TEXT ·Loadint64(SB),NOSPLIT,$-4-12
+	B	·Load64(SB)
+
 TEXT ·Loaduintptr(SB),NOSPLIT,$0-8
 	B	·Load(SB)
 
 TEXT ·Loaduint(SB),NOSPLIT,$0-8
 	B	·Load(SB)
 
+TEXT ·Storeint32(SB),NOSPLIT,$0-8
+	B	·Store(SB)
+
+TEXT ·Storeint64(SB),NOSPLIT,$0-12
+	B	·Store64(SB)
+
 TEXT ·Storeuintptr(SB),NOSPLIT,$0-8
 	B	·Store(SB)
 
@@ -87,21 +105,26 @@ TEXT ·StoreRel(SB),NOSPLIT,$0-8
 TEXT ·StoreReluintptr(SB),NOSPLIT,$0-8
 	B	·Store(SB)
 
+TEXT ·Xaddint32(SB),NOSPLIT,$0-12
+	B	·Xadd(SB)
+
+TEXT ·Xaddint64(SB),NOSPLIT,$-4-20
+	B	·Xadd64(SB)
+
 TEXT ·Xadduintptr(SB),NOSPLIT,$0-12
 	B	·Xadd(SB)
 
-TEXT ·Loadint64(SB),NOSPLIT,$0-12
-	B	·Load64(SB)
+TEXT ·Xchgint32(SB),NOSPLIT,$0-12
+	B	·Xchg(SB)
 
-TEXT ·Xaddint64(SB),NOSPLIT,$0-20
-	B	·Xadd64(SB)
+TEXT ·Xchgint64(SB),NOSPLIT,$-4-20
+	B	·Xchg64(SB)
 
 // 64-bit atomics
 // The native ARM implementations use LDREXD/STREXD, which are
 // available on ARMv6k or later. We use them only on ARMv7.
 // On older ARM, we use Go implementations which simulate 64-bit
 // atomics with locks.
-
 TEXT armCas64<>(SB),NOSPLIT,$0-21
 	// addr is already in R1
 	MOVW	old_lo+4(FP), R2
diff --git a/src/runtime/internal/atomic/atomic_arm64.s b/src/runtime/internal/atomic/atomic_arm64.s
index 0cf3c40223..587e7f05e2 100644
--- a/src/runtime/internal/atomic/atomic_arm64.s
+++ b/src/runtime/internal/atomic/atomic_arm64.s
@@ -4,77 +4,127 @@
 
 #include "textflag.h"
 
-// uint32 runtime∕internal∕atomic·Load(uint32 volatile* addr)
+TEXT ·Casint32(SB), NOSPLIT, $0-17
+	B	·Cas(SB)
+
+TEXT ·Casint64(SB), NOSPLIT, $0-25
+	B	·Cas64(SB)
+
+TEXT ·Casuintptr(SB), NOSPLIT, $0-25
+	B	·Cas64(SB)
+
+TEXT ·CasRel(SB), NOSPLIT, $0-17
+	B	·Cas(SB)
+
+TEXT ·Loadint32(SB), NOSPLIT, $0-12
+	B	·Load(SB)
+
+TEXT ·Loadint64(SB), NOSPLIT, $0-16
+	B	·Load64(SB)
+
+TEXT ·Loaduintptr(SB), NOSPLIT, $0-16
+	B	·Load64(SB)
+
+TEXT ·Loaduint(SB), NOSPLIT, $0-16
+	B	·Load64(SB)
+
+TEXT ·Storeint32(SB), NOSPLIT, $0-12
+	B	·Store(SB)
+
+TEXT ·Storeint64(SB), NOSPLIT, $0-16
+	B	·Store64(SB)
+
+TEXT ·Storeuintptr(SB), NOSPLIT, $0-16
+	B	·Store64(SB)
+
+TEXT ·Xaddint32(SB), NOSPLIT, $0-20
+	B	·Xadd(SB)
+
+TEXT ·Xaddint64(SB), NOSPLIT, $0-24
+	B	·Xadd64(SB)
+
+TEXT ·Xadduintptr(SB), NOSPLIT, $0-24
+	B	·Xadd64(SB)
+
+TEXT ·Casp1(SB), NOSPLIT, $0-25
+	B ·Cas64(SB)
+
+// uint32 ·Load(uint32 volatile* addr)
 TEXT ·Load(SB),NOSPLIT,$0-12
 	MOVD	ptr+0(FP), R0
 	LDARW	(R0), R0
 	MOVW	R0, ret+8(FP)
 	RET
 
-// uint8 runtime∕internal∕atomic·Load8(uint8 volatile* addr)
+// uint8 ·Load8(uint8 volatile* addr)
 TEXT ·Load8(SB),NOSPLIT,$0-9
 	MOVD	ptr+0(FP), R0
 	LDARB	(R0), R0
 	MOVB	R0, ret+8(FP)
 	RET
 
-// uint64 runtime∕internal∕atomic·Load64(uint64 volatile* addr)
+// uint64 ·Load64(uint64 volatile* addr)
 TEXT ·Load64(SB),NOSPLIT,$0-16
 	MOVD	ptr+0(FP), R0
 	LDAR	(R0), R0
 	MOVD	R0, ret+8(FP)
 	RET
 
-// void *runtime∕internal∕atomic·Loadp(void *volatile *addr)
+// void *·Loadp(void *volatile *addr)
 TEXT ·Loadp(SB),NOSPLIT,$0-16
 	MOVD	ptr+0(FP), R0
 	LDAR	(R0), R0
 	MOVD	R0, ret+8(FP)
 	RET
 
-// uint32 runtime∕internal∕atomic·LoadAcq(uint32 volatile* addr)
+// uint32 ·LoadAcq(uint32 volatile* addr)
 TEXT ·LoadAcq(SB),NOSPLIT,$0-12
 	B	·Load(SB)
 
-// uint64 runtime∕internal∕atomic·LoadAcquintptr(uint64 volatile* addr)
+// uint64 ·LoadAcquintptr(uint64 volatile* addr)
 TEXT ·LoadAcq64(SB),NOSPLIT,$0-16
 	B	·Load64(SB)
 
-// uintptr runtime∕internal∕atomic·LoadAcq64(uintptr volatile* addr)
+// uintptr ·LoadAcq64(uintptr volatile* addr)
 TEXT ·LoadAcquintptr(SB),NOSPLIT,$0-16
 	B	·Load64(SB)
 
-TEXT runtime∕internal∕atomic·StorepNoWB(SB), NOSPLIT, $0-16
-	B	runtime∕internal∕atomic·Store64(SB)
+TEXT ·StorepNoWB(SB), NOSPLIT, $0-16
+	B	·Store64(SB)
 
-TEXT runtime∕internal∕atomic·StoreRel(SB), NOSPLIT, $0-12
-	B	runtime∕internal∕atomic·Store(SB)
+TEXT ·StoreRel(SB), NOSPLIT, $0-12
+	B	·Store(SB)
 
-TEXT runtime∕internal∕atomic·StoreRel64(SB), NOSPLIT, $0-16
-	B	runtime∕internal∕atomic·Store64(SB)
+TEXT ·StoreRel64(SB), NOSPLIT, $0-16
+	B	·Store64(SB)
 
-TEXT runtime∕internal∕atomic·StoreReluintptr(SB), NOSPLIT, $0-16
-	B	runtime∕internal∕atomic·Store64(SB)
+TEXT ·StoreReluintptr(SB), NOSPLIT, $0-16
+	B	·Store64(SB)
 
-TEXT runtime∕internal∕atomic·Store(SB), NOSPLIT, $0-12
+TEXT ·Store(SB), NOSPLIT, $0-12
 	MOVD	ptr+0(FP), R0
 	MOVW	val+8(FP), R1
 	STLRW	R1, (R0)
 	RET
 
-TEXT runtime∕internal∕atomic·Store8(SB), NOSPLIT, $0-9
+TEXT ·Store8(SB), NOSPLIT, $0-9
 	MOVD	ptr+0(FP), R0
 	MOVB	val+8(FP), R1
 	STLRB	R1, (R0)
 	RET
 
-TEXT runtime∕internal∕atomic·Store64(SB), NOSPLIT, $0-16
+TEXT ·Store64(SB), NOSPLIT, $0-16
 	MOVD	ptr+0(FP), R0
 	MOVD	val+8(FP), R1
 	STLR	R1, (R0)
 	RET
 
-TEXT runtime∕internal∕atomic·Xchg(SB), NOSPLIT, $0-20
+// uint32 Xchg(ptr *uint32, new uint32)
+// Atomically:
+//	old := *ptr;
+//	*ptr = new;
+//	return old;
+TEXT ·Xchg(SB), NOSPLIT, $0-20
 	MOVD	ptr+0(FP), R0
 	MOVW	new+8(FP), R1
 again:
@@ -84,7 +134,12 @@ again:
 	MOVW	R2, ret+16(FP)
 	RET
 
-TEXT runtime∕internal∕atomic·Xchg64(SB), NOSPLIT, $0-24
+// uint64 Xchg64(ptr *uint64, new uint64)
+// Atomically:
+//	old := *ptr;
+//	*ptr = new;
+//	return old;
+TEXT ·Xchg64(SB), NOSPLIT, $0-24
 	MOVD	ptr+0(FP), R0
 	MOVD	new+8(FP), R1
 again:
@@ -94,7 +149,29 @@ again:
 	MOVD	R2, ret+16(FP)
 	RET
 
-// bool runtime∕internal∕atomic·Cas64(uint64 *ptr, uint64 old, uint64 new)
+// bool Cas(uint32 *ptr, uint32 old, uint32 new)
+// Atomically:
+//	if(*val == old){
+//		*val = new;
+//		return 1;
+//	} else
+//		return 0;
+TEXT ·Cas(SB), NOSPLIT, $0-17
+	MOVD	ptr+0(FP), R0
+	MOVW	old+8(FP), R1
+	MOVW	new+12(FP), R2
+again:
+	LDAXRW	(R0), R3
+	CMPW	R1, R3
+	BNE	ok
+	STLXRW	R2, (R0), R3
+	CBNZ	R3, again
+ok:
+	CSET	EQ, R0
+	MOVB	R0, ret+16(FP)
+	RET
+
+// bool ·Cas64(uint64 *ptr, uint64 old, uint64 new)
 // Atomically:
 //      if(*val == *old){
 //              *val = new;
@@ -102,7 +179,7 @@ again:
 //      } else {
 //              return 0;
 //      }
-TEXT runtime∕internal∕atomic·Cas64(SB), NOSPLIT, $0-25
+TEXT ·Cas64(SB), NOSPLIT, $0-25
 	MOVD	ptr+0(FP), R0
 	MOVD	old+8(FP), R1
 	MOVD	new+16(FP), R2
@@ -121,7 +198,7 @@ ok:
 // Atomically:
 //      *val += delta;
 //      return *val;
-TEXT runtime∕internal∕atomic·Xadd(SB), NOSPLIT, $0-20
+TEXT ·Xadd(SB), NOSPLIT, $0-20
 	MOVD	ptr+0(FP), R0
 	MOVW	delta+8(FP), R1
 again:
@@ -132,7 +209,11 @@ again:
 	MOVW	R2, ret+16(FP)
 	RET
 
-TEXT runtime∕internal∕atomic·Xadd64(SB), NOSPLIT, $0-24
+// uint64 Xadd64(uint64 volatile *ptr, int64 delta)
+// Atomically:
+//      *val += delta;
+//      return *val;
+TEXT ·Xadd64(SB), NOSPLIT, $0-24
 	MOVD	ptr+0(FP), R0
 	MOVD	delta+8(FP), R1
 again:
@@ -143,8 +224,14 @@ again:
 	MOVD	R2, ret+16(FP)
 	RET
 
-TEXT runtime∕internal∕atomic·Xchguintptr(SB), NOSPLIT, $0-24
-	B	runtime∕internal∕atomic·Xchg64(SB)
+TEXT ·Xchgint32(SB), NOSPLIT, $0-20
+	B	·Xchg(SB)
+
+TEXT ·Xchgint64(SB), NOSPLIT, $0-24
+	B	·Xchg64(SB)
+
+TEXT ·Xchguintptr(SB), NOSPLIT, $0-24
+	B	·Xchg64(SB)
 
 TEXT ·And8(SB), NOSPLIT, $0-9
 	MOVD	ptr+0(FP), R0
diff --git a/src/runtime/internal/atomic/atomic_mips64x.s b/src/runtime/internal/atomic/atomic_mips64x.s
index 125c0c221c..2751c6f808 100644
--- a/src/runtime/internal/atomic/atomic_mips64x.s
+++ b/src/runtime/internal/atomic/atomic_mips64x.s
@@ -8,7 +8,309 @@
 
 #define SYNC	WORD $0xf
 
-// uint32 runtime∕internal∕atomic·Load(uint32 volatile* ptr)
+// bool cas(uint32 *ptr, uint32 old, uint32 new)
+// Atomically:
+//	if(*val == old){
+//		*val = new;
+//		return 1;
+//	} else
+//		return 0;
+TEXT ·Cas(SB), NOSPLIT, $0-17
+	MOVV	ptr+0(FP), R1
+	MOVW	old+8(FP), R2
+	MOVW	new+12(FP), R5
+	SYNC
+cas_again:
+	MOVV	R5, R3
+	LL	(R1), R4
+	BNE	R2, R4, cas_fail
+	SC	R3, (R1)
+	BEQ	R3, cas_again
+	MOVV	$1, R1
+	MOVB	R1, ret+16(FP)
+	SYNC
+	RET
+cas_fail:
+	MOVV	$0, R1
+	JMP	-4(PC)
+
+// bool	cas64(uint64 *ptr, uint64 old, uint64 new)
+// Atomically:
+//	if(*val == *old){
+//		*val = new;
+//		return 1;
+//	} else {
+//		return 0;
+//	}
+TEXT ·Cas64(SB), NOSPLIT, $0-25
+	MOVV	ptr+0(FP), R1
+	MOVV	old+8(FP), R2
+	MOVV	new+16(FP), R5
+	SYNC
+cas64_again:
+	MOVV	R5, R3
+	LLV	(R1), R4
+	BNE	R2, R4, cas64_fail
+	SCV	R3, (R1)
+	BEQ	R3, cas64_again
+	MOVV	$1, R1
+	MOVB	R1, ret+24(FP)
+	SYNC
+	RET
+cas64_fail:
+	MOVV	$0, R1
+	JMP	-4(PC)
+
+TEXT ·Casint32(SB), NOSPLIT, $0-17
+	JMP	·Cas(SB)
+
+TEXT ·Casint64(SB), NOSPLIT, $0-25
+	JMP	·Cas64(SB)
+
+TEXT ·Casuintptr(SB), NOSPLIT, $0-25
+	JMP	·Cas64(SB)
+
+TEXT ·CasRel(SB), NOSPLIT, $0-17
+	JMP	·Cas(SB)
+
+TEXT ·Loaduintptr(SB),  NOSPLIT|NOFRAME, $0-16
+	JMP	·Load64(SB)
+
+TEXT ·Loaduint(SB), NOSPLIT|NOFRAME, $0-16
+	JMP	·Load64(SB)
+
+TEXT ·Storeint32(SB), NOSPLIT, $0-12
+	JMP	·Store(SB)
+
+TEXT ·Storeint64(SB), NOSPLIT, $0-16
+	JMP	·Store64(SB)
+
+TEXT ·Storeuintptr(SB), NOSPLIT, $0-16
+	JMP	·Store64(SB)
+
+TEXT ·Xadduintptr(SB), NOSPLIT, $0-24
+	JMP	·Xadd64(SB)
+
+TEXT ·Loadint32(SB), NOSPLIT, $0-12
+	JMP	·Load(SB)
+
+TEXT ·Loadint64(SB), NOSPLIT, $0-16
+	JMP	·Load64(SB)
+
+TEXT ·Xaddint32(SB), NOSPLIT, $0-20
+	JMP	·Xadd(SB)
+
+TEXT ·Xaddint64(SB), NOSPLIT, $0-24
+	JMP	·Xadd64(SB)
+
+// bool casp(void **val, void *old, void *new)
+// Atomically:
+//	if(*val == old){
+//		*val = new;
+//		return 1;
+//	} else
+//		return 0;
+TEXT ·Casp1(SB), NOSPLIT, $0-25
+	JMP ·Cas64(SB)
+
+// uint32 xadd(uint32 volatile *ptr, int32 delta)
+// Atomically:
+//	*val += delta;
+//	return *val;
+TEXT ·Xadd(SB), NOSPLIT, $0-20
+	MOVV	ptr+0(FP), R2
+	MOVW	delta+8(FP), R3
+	SYNC
+	LL	(R2), R1
+	ADDU	R1, R3, R4
+	MOVV	R4, R1
+	SC	R4, (R2)
+	BEQ	R4, -4(PC)
+	MOVW	R1, ret+16(FP)
+	SYNC
+	RET
+
+// uint64 Xadd64(uint64 volatile *ptr, int64 delta)
+// Atomically:
+//	*val += delta;
+//	return *val;
+TEXT ·Xadd64(SB), NOSPLIT, $0-24
+	MOVV	ptr+0(FP), R2
+	MOVV	delta+8(FP), R3
+	SYNC
+	LLV	(R2), R1
+	ADDVU	R1, R3, R4
+	MOVV	R4, R1
+	SCV	R4, (R2)
+	BEQ	R4, -4(PC)
+	MOVV	R1, ret+16(FP)
+	SYNC
+	RET
+
+// uint32 Xchg(ptr *uint32, new uint32)
+// Atomically:
+//	old := *ptr;
+//	*ptr = new;
+//	return old;
+TEXT ·Xchg(SB), NOSPLIT, $0-20
+	MOVV	ptr+0(FP), R2
+	MOVW	new+8(FP), R5
+
+	SYNC
+	MOVV	R5, R3
+	LL	(R2), R1
+	SC	R3, (R2)
+	BEQ	R3, -3(PC)
+	MOVW	R1, ret+16(FP)
+	SYNC
+	RET
+
+// uint64 Xchg64(ptr *uint64, new uint64)
+// Atomically:
+//	old := *ptr;
+//	*ptr = new;
+//	return old;
+TEXT ·Xchg64(SB), NOSPLIT, $0-24
+	MOVV	ptr+0(FP), R2
+	MOVV	new+8(FP), R5
+
+	SYNC
+	MOVV	R5, R3
+	LLV	(R2), R1
+	SCV	R3, (R2)
+	BEQ	R3, -3(PC)
+	MOVV	R1, ret+16(FP)
+	SYNC
+	RET
+
+TEXT ·Xchgint32(SB), NOSPLIT, $0-20
+	JMP	·Xchg(SB)
+
+TEXT ·Xchgint64(SB), NOSPLIT, $0-24
+	JMP	·Xchg64(SB)
+
+TEXT ·Xchguintptr(SB), NOSPLIT, $0-24
+	JMP	·Xchg64(SB)
+
+TEXT ·StorepNoWB(SB), NOSPLIT, $0-16
+	JMP	·Store64(SB)
+
+TEXT ·StoreRel(SB), NOSPLIT, $0-12
+	JMP	·Store(SB)
+
+TEXT ·StoreRel64(SB), NOSPLIT, $0-16
+	JMP	·Store64(SB)
+
+TEXT ·StoreReluintptr(SB), NOSPLIT, $0-16
+	JMP	·Store64(SB)
+
+TEXT ·Store(SB), NOSPLIT, $0-12
+	MOVV	ptr+0(FP), R1
+	MOVW	val+8(FP), R2
+	SYNC
+	MOVW	R2, 0(R1)
+	SYNC
+	RET
+
+TEXT ·Store8(SB), NOSPLIT, $0-9
+	MOVV	ptr+0(FP), R1
+	MOVB	val+8(FP), R2
+	SYNC
+	MOVB	R2, 0(R1)
+	SYNC
+	RET
+
+TEXT ·Store64(SB), NOSPLIT, $0-16
+	MOVV	ptr+0(FP), R1
+	MOVV	val+8(FP), R2
+	SYNC
+	MOVV	R2, 0(R1)
+	SYNC
+	RET
+
+// void	Or8(byte volatile*, byte);
+TEXT ·Or8(SB), NOSPLIT, $0-9
+	MOVV	ptr+0(FP), R1
+	MOVBU	val+8(FP), R2
+	// Align ptr down to 4 bytes so we can use 32-bit load/store.
+	MOVV	$~3, R3
+	AND	R1, R3
+	// Compute val shift.
+#ifdef GOARCH_mips64
+	// Big endian.  ptr = ptr ^ 3
+	XOR	$3, R1
+#endif
+	// R4 = ((ptr & 3) * 8)
+	AND	$3, R1, R4
+	SLLV	$3, R4
+	// Shift val for aligned ptr. R2 = val << R4
+	SLLV	R4, R2
+
+	SYNC
+	LL	(R3), R4
+	OR	R2, R4
+	SC	R4, (R3)
+	BEQ	R4, -4(PC)
+	SYNC
+	RET
+
+// void	And8(byte volatile*, byte);
+TEXT ·And8(SB), NOSPLIT, $0-9
+	MOVV	ptr+0(FP), R1
+	MOVBU	val+8(FP), R2
+	// Align ptr down to 4 bytes so we can use 32-bit load/store.
+	MOVV	$~3, R3
+	AND	R1, R3
+	// Compute val shift.
+#ifdef GOARCH_mips64
+	// Big endian.  ptr = ptr ^ 3
+	XOR	$3, R1
+#endif
+	// R4 = ((ptr & 3) * 8)
+	AND	$3, R1, R4
+	SLLV	$3, R4
+	// Shift val for aligned ptr. R2 = val << R4 | ^(0xFF << R4)
+	MOVV	$0xFF, R5
+	SLLV	R4, R2
+	SLLV	R4, R5
+	NOR	R0, R5
+	OR	R5, R2
+
+	SYNC
+	LL	(R3), R4
+	AND	R2, R4
+	SC	R4, (R3)
+	BEQ	R4, -4(PC)
+	SYNC
+	RET
+
+// func Or(addr *uint32, v uint32)
+TEXT ·Or(SB), NOSPLIT, $0-12
+	MOVV	ptr+0(FP), R1
+	MOVW	val+8(FP), R2
+
+	SYNC
+	LL	(R1), R3
+	OR	R2, R3
+	SC	R3, (R1)
+	BEQ	R3, -4(PC)
+	SYNC
+	RET
+
+// func And(addr *uint32, v uint32)
+TEXT ·And(SB), NOSPLIT, $0-12
+	MOVV	ptr+0(FP), R1
+	MOVW	val+8(FP), R2
+
+	SYNC
+	LL	(R1), R3
+	AND	R2, R3
+	SC	R3, (R1)
+	BEQ	R3, -4(PC)
+	SYNC
+	RET
+
+// uint32 ·Load(uint32 volatile* ptr)
 TEXT ·Load(SB),NOSPLIT|NOFRAME,$0-12
 	MOVV	ptr+0(FP), R1
 	SYNC
@@ -17,7 +319,7 @@ TEXT ·Load(SB),NOSPLIT|NOFRAME,$0-12
 	MOVW	R1, ret+8(FP)
 	RET
 
-// uint8 runtime∕internal∕atomic·Load8(uint8 volatile* ptr)
+// uint8 ·Load8(uint8 volatile* ptr)
 TEXT ·Load8(SB),NOSPLIT|NOFRAME,$0-9
 	MOVV	ptr+0(FP), R1
 	SYNC
@@ -26,7 +328,7 @@ TEXT ·Load8(SB),NOSPLIT|NOFRAME,$0-9
 	MOVB	R1, ret+8(FP)
 	RET
 
-// uint64 runtime∕internal∕atomic·Load64(uint64 volatile* ptr)
+// uint64 ·Load64(uint64 volatile* ptr)
 TEXT ·Load64(SB),NOSPLIT|NOFRAME,$0-16
 	MOVV	ptr+0(FP), R1
 	SYNC
@@ -35,7 +337,7 @@ TEXT ·Load64(SB),NOSPLIT|NOFRAME,$0-16
 	MOVV	R1, ret+8(FP)
 	RET
 
-// void *runtime∕internal∕atomic·Loadp(void *volatile *ptr)
+// void *·Loadp(void *volatile *ptr)
 TEXT ·Loadp(SB),NOSPLIT|NOFRAME,$0-16
 	MOVV	ptr+0(FP), R1
 	SYNC
@@ -44,14 +346,14 @@ TEXT ·Loadp(SB),NOSPLIT|NOFRAME,$0-16
 	MOVV	R1, ret+8(FP)
 	RET
 
-// uint32 runtime∕internal∕atomic·LoadAcq(uint32 volatile* ptr)
+// uint32 ·LoadAcq(uint32 volatile* ptr)
 TEXT ·LoadAcq(SB),NOSPLIT|NOFRAME,$0-12
 	JMP	atomic·Load(SB)
 
-// uint64 runtime∕internal∕atomic·LoadAcq64(uint64 volatile* ptr)
+// uint64 ·LoadAcq64(uint64 volatile* ptr)
 TEXT ·LoadAcq64(SB),NOSPLIT|NOFRAME,$0-16
 	JMP	atomic·Load64(SB)
 
-// uintptr runtime∕internal∕atomic·LoadAcquintptr(uintptr volatile* ptr)
+// uintptr ·LoadAcquintptr(uintptr volatile* ptr)
 TEXT ·LoadAcquintptr(SB),NOSPLIT|NOFRAME,$0-16
 	JMP	atomic·Load64(SB)
diff --git a/src/runtime/internal/atomic/atomic_mipsx.s b/src/runtime/internal/atomic/atomic_mipsx.s
index aeebc8f2ff..3f61321450 100644
--- a/src/runtime/internal/atomic/atomic_mipsx.s
+++ b/src/runtime/internal/atomic/atomic_mipsx.s
@@ -6,6 +6,239 @@
 
 #include "textflag.h"
 
+// bool Cas(int32 *val, int32 old, int32 new)
+// Atomically:
+//	if(*val == old){
+//		*val = new;
+//		return 1;
+//	} else
+//		return 0;
+TEXT ·Cas(SB),NOSPLIT,$0-13
+	MOVW	ptr+0(FP), R1
+	MOVW	old+4(FP), R2
+	MOVW	new+8(FP), R5
+	SYNC
+try_cas:
+	MOVW	R5, R3
+	LL	(R1), R4	// R4 = *R1
+	BNE	R2, R4, cas_fail
+	SC	R3, (R1)	// *R1 = R3
+	BEQ	R3, try_cas
+	SYNC
+	MOVB	R3, ret+12(FP)
+	RET
+cas_fail:
+	MOVB	R0, ret+12(FP)
+	RET
+
+TEXT ·Store(SB),NOSPLIT,$0-8
+	MOVW	ptr+0(FP), R1
+	MOVW	val+4(FP), R2
+	SYNC
+	MOVW	R2, 0(R1)
+	SYNC
+	RET
+
+TEXT ·Store8(SB),NOSPLIT,$0-5
+	MOVW	ptr+0(FP), R1
+	MOVB	val+4(FP), R2
+	SYNC
+	MOVB	R2, 0(R1)
+	SYNC
+	RET
+
+TEXT ·Load(SB),NOSPLIT,$0-8
+	MOVW	ptr+0(FP), R1
+	SYNC
+	MOVW	0(R1), R1
+	SYNC
+	MOVW	R1, ret+4(FP)
+	RET
+
+TEXT ·Load8(SB),NOSPLIT,$0-5
+	MOVW	ptr+0(FP), R1
+	SYNC
+	MOVB	0(R1), R1
+	SYNC
+	MOVB	R1, ret+4(FP)
+	RET
+
+// uint32 Xadd(uint32 volatile *val, int32 delta)
+// Atomically:
+//	*val += delta;
+//	return *val;
+TEXT ·Xadd(SB),NOSPLIT,$0-12
+	MOVW	ptr+0(FP), R2
+	MOVW	delta+4(FP), R3
+	SYNC
+try_xadd:
+	LL	(R2), R1	// R1 = *R2
+	ADDU	R1, R3, R4
+	MOVW	R4, R1
+	SC	R4, (R2)	// *R2 = R4
+	BEQ	R4, try_xadd
+	SYNC
+	MOVW	R1, ret+8(FP)
+	RET
+
+// uint32 Xchg(ptr *uint32, new uint32)
+// Atomically:
+//	old := *ptr;
+//	*ptr = new;
+//	return old;
+TEXT ·Xchg(SB),NOSPLIT,$0-12
+	MOVW	ptr+0(FP), R2
+	MOVW	new+4(FP), R5
+	SYNC
+try_xchg:
+	MOVW	R5, R3
+	LL	(R2), R1	// R1 = *R2
+	SC	R3, (R2)	// *R2 = R3
+	BEQ	R3, try_xchg
+	SYNC
+	MOVW	R1, ret+8(FP)
+	RET
+
+TEXT ·Casint32(SB),NOSPLIT,$0-13
+	JMP	·Cas(SB)
+
+TEXT ·Casint64(SB),NOSPLIT,$0-21
+	JMP	·Cas64(SB)
+
+TEXT ·Casuintptr(SB),NOSPLIT,$0-13
+	JMP	·Cas(SB)
+
+TEXT ·CasRel(SB),NOSPLIT,$0-13
+	JMP	·Cas(SB)
+
+TEXT ·Loaduintptr(SB),NOSPLIT,$0-8
+	JMP	·Load(SB)
+
+TEXT ·Loaduint(SB),NOSPLIT,$0-8
+	JMP	·Load(SB)
+
+TEXT ·Loadp(SB),NOSPLIT,$-0-8
+	JMP	·Load(SB)
+
+TEXT ·Storeint32(SB),NOSPLIT,$0-8
+	JMP	·Store(SB)
+
+TEXT ·Storeint64(SB),NOSPLIT,$0-12
+	JMP	·Store64(SB)
+
+TEXT ·Storeuintptr(SB),NOSPLIT,$0-8
+	JMP	·Store(SB)
+
+TEXT ·Xadduintptr(SB),NOSPLIT,$0-12
+	JMP	·Xadd(SB)
+
+TEXT ·Loadint32(SB),NOSPLIT,$0-8
+	JMP	·Load(SB)
+
+TEXT ·Loadint64(SB),NOSPLIT,$0-12
+	JMP	·Load64(SB)
+
+TEXT ·Xaddint32(SB),NOSPLIT,$0-12
+	JMP	·Xadd(SB)
+
+TEXT ·Xaddint64(SB),NOSPLIT,$0-20
+	JMP	·Xadd64(SB)
+
+TEXT ·Casp1(SB),NOSPLIT,$0-13
+	JMP	·Cas(SB)
+
+TEXT ·Xchgint32(SB),NOSPLIT,$0-12
+	JMP	·Xchg(SB)
+
+TEXT ·Xchgint64(SB),NOSPLIT,$0-20
+	JMP	·Xchg64(SB)
+
+TEXT ·Xchguintptr(SB),NOSPLIT,$0-12
+	JMP	·Xchg(SB)
+
+TEXT ·StorepNoWB(SB),NOSPLIT,$0-8
+	JMP	·Store(SB)
+
+TEXT ·StoreRel(SB),NOSPLIT,$0-8
+	JMP	·Store(SB)
+
+TEXT ·StoreReluintptr(SB),NOSPLIT,$0-8
+	JMP	·Store(SB)
+
+// void	Or8(byte volatile*, byte);
+TEXT ·Or8(SB),NOSPLIT,$0-5
+	MOVW	ptr+0(FP), R1
+	MOVBU	val+4(FP), R2
+	MOVW	$~3, R3	// Align ptr down to 4 bytes so we can use 32-bit load/store.
+	AND	R1, R3
+#ifdef GOARCH_mips
+	// Big endian.  ptr = ptr ^ 3
+	XOR	$3, R1
+#endif
+	AND	$3, R1, R4	// R4 = ((ptr & 3) * 8)
+	SLL	$3, R4
+	SLL	R4, R2, R2	// Shift val for aligned ptr. R2 = val << R4
+	SYNC
+try_or8:
+	LL	(R3), R4	// R4 = *R3
+	OR	R2, R4
+	SC	R4, (R3)	// *R3 = R4
+	BEQ	R4, try_or8
+	SYNC
+	RET
+
+// void	And8(byte volatile*, byte);
+TEXT ·And8(SB),NOSPLIT,$0-5
+	MOVW	ptr+0(FP), R1
+	MOVBU	val+4(FP), R2
+	MOVW	$~3, R3
+	AND	R1, R3
+#ifdef GOARCH_mips
+	// Big endian.  ptr = ptr ^ 3
+	XOR	$3, R1
+#endif
+	AND	$3, R1, R4	// R4 = ((ptr & 3) * 8)
+	SLL	$3, R4
+	MOVW	$0xFF, R5
+	SLL	R4, R2
+	SLL	R4, R5
+	NOR	R0, R5
+	OR	R5, R2	// Shift val for aligned ptr. R2 = val << R4 | ^(0xFF << R4)
+	SYNC
+try_and8:
+	LL	(R3), R4	// R4 = *R3
+	AND	R2, R4
+	SC	R4, (R3)	// *R3 = R4
+	BEQ	R4, try_and8
+	SYNC
+	RET
+
+// func Or(addr *uint32, v uint32)
+TEXT ·Or(SB), NOSPLIT, $0-8
+	MOVW	ptr+0(FP), R1
+	MOVW	val+4(FP), R2
+
+	SYNC
+	LL	(R1), R3
+	OR	R2, R3
+	SC	R3, (R1)
+	BEQ	R3, -4(PC)
+	SYNC
+	RET
+
+// func And(addr *uint32, v uint32)
+TEXT ·And(SB), NOSPLIT, $0-8
+	MOVW	ptr+0(FP), R1
+	MOVW	val+4(FP), R2
+
+	SYNC
+	LL	(R1), R3
+	AND	R2, R3
+	SC	R3, (R1)
+	BEQ	R3, -4(PC)
+	SYNC
+	RET
+
 TEXT ·spinLock(SB),NOSPLIT,$0-4
 	MOVW	state+0(FP), R1
 	MOVW	$1, R2
diff --git a/src/runtime/internal/atomic/atomic_ppc64x.s b/src/runtime/internal/atomic/atomic_ppc64x.s
index b79cdbca34..37c8515d37 100644
--- a/src/runtime/internal/atomic/atomic_ppc64x.s
+++ b/src/runtime/internal/atomic/atomic_ppc64x.s
@@ -15,7 +15,7 @@
 //
 // http://www.rdrop.com/users/paulmck/scalability/paper/N2745r.2011.03.04a.html
 
-// uint32 runtime∕internal∕atomic·Load(uint32 volatile* ptr)
+// uint32 ·Load(uint32 volatile* ptr)
 TEXT ·Load(SB),NOSPLIT|NOFRAME,$-8-12
 	MOVD	ptr+0(FP), R3
 	SYNC
@@ -26,7 +26,7 @@ TEXT ·Load(SB),NOSPLIT|NOFRAME,$-8-12
 	MOVW	R3, ret+8(FP)
 	RET
 
-// uint8 runtime∕internal∕atomic·Load8(uint8 volatile* ptr)
+// uint8 ·Load8(uint8 volatile* ptr)
 TEXT ·Load8(SB),NOSPLIT|NOFRAME,$-8-9
 	MOVD	ptr+0(FP), R3
 	SYNC
@@ -37,7 +37,7 @@ TEXT ·Load8(SB),NOSPLIT|NOFRAME,$-8-9
 	MOVB	R3, ret+8(FP)
 	RET
 
-// uint64 runtime∕internal∕atomic·Load64(uint64 volatile* ptr)
+// uint64 ·Load64(uint64 volatile* ptr)
 TEXT ·Load64(SB),NOSPLIT|NOFRAME,$-8-16
 	MOVD	ptr+0(FP), R3
 	SYNC
@@ -48,7 +48,7 @@ TEXT ·Load64(SB),NOSPLIT|NOFRAME,$-8-16
 	MOVD	R3, ret+8(FP)
 	RET
 
-// void *runtime∕internal∕atomic·Loadp(void *volatile *ptr)
+// void *·Loadp(void *volatile *ptr)
 TEXT ·Loadp(SB),NOSPLIT|NOFRAME,$-8-16
 	MOVD	ptr+0(FP), R3
 	SYNC
@@ -59,7 +59,7 @@ TEXT ·Loadp(SB),NOSPLIT|NOFRAME,$-8-16
 	MOVD	R3, ret+8(FP)
 	RET
 
-// uint32 runtime∕internal∕atomic·LoadAcq(uint32 volatile* ptr)
+// uint32 ·LoadAcq(uint32 volatile* ptr)
 TEXT ·LoadAcq(SB),NOSPLIT|NOFRAME,$-8-12
 	MOVD   ptr+0(FP), R3
 	MOVWZ  0(R3), R3
@@ -69,7 +69,7 @@ TEXT ·LoadAcq(SB),NOSPLIT|NOFRAME,$-8-12
 	MOVW   R3, ret+8(FP)
 	RET
 
-// uint64 runtime∕internal∕atomic·LoadAcq64(uint64 volatile* ptr)
+// uint64 ·LoadAcq64(uint64 volatile* ptr)
 TEXT ·LoadAcq64(SB),NOSPLIT|NOFRAME,$-8-16
 	MOVD   ptr+0(FP), R3
 	MOVD   0(R3), R3
@@ -78,3 +78,286 @@ TEXT ·LoadAcq64(SB),NOSPLIT|NOFRAME,$-8-16
 	ISYNC
 	MOVD   R3, ret+8(FP)
 	RET
+
+// bool cas(uint32 *ptr, uint32 old, uint32 new)
+// Atomically:
+//	if(*val == old){
+//		*val = new;
+//		return 1;
+//	} else
+//		return 0;
+TEXT ·Cas(SB), NOSPLIT, $0-17
+	MOVD	ptr+0(FP), R3
+	MOVWZ	old+8(FP), R4
+	MOVWZ	new+12(FP), R5
+	LWSYNC
+cas_again:
+	LWAR	(R3), R6
+	CMPW	R6, R4
+	BNE	cas_fail
+	STWCCC	R5, (R3)
+	BNE	cas_again
+	MOVD	$1, R3
+	LWSYNC
+	MOVB	R3, ret+16(FP)
+	RET
+cas_fail:
+	MOVB	R0, ret+16(FP)
+	RET
+
+// bool	·Cas64(uint64 *ptr, uint64 old, uint64 new)
+// Atomically:
+//	if(*val == *old){
+//		*val = new;
+//		return 1;
+//	} else {
+//		return 0;
+//	}
+TEXT ·Cas64(SB), NOSPLIT, $0-25
+	MOVD	ptr+0(FP), R3
+	MOVD	old+8(FP), R4
+	MOVD	new+16(FP), R5
+	LWSYNC
+cas64_again:
+	LDAR	(R3), R6
+	CMP	R6, R4
+	BNE	cas64_fail
+	STDCCC	R5, (R3)
+	BNE	cas64_again
+	MOVD	$1, R3
+	LWSYNC
+	MOVB	R3, ret+24(FP)
+	RET
+cas64_fail:
+	MOVB	R0, ret+24(FP)
+	RET
+
+TEXT ·CasRel(SB), NOSPLIT, $0-17
+	MOVD    ptr+0(FP), R3
+	MOVWZ   old+8(FP), R4
+	MOVWZ   new+12(FP), R5
+	LWSYNC
+cas_again:
+	LWAR    (R3), $0, R6        // 0 = Mutex release hint
+	CMPW    R6, R4
+	BNE     cas_fail
+	STWCCC  R5, (R3)
+	BNE     cas_again
+	MOVD    $1, R3
+	MOVB    R3, ret+16(FP)
+	RET
+cas_fail:
+	MOVB    R0, ret+16(FP)
+	RET
+
+TEXT ·Casint32(SB), NOSPLIT, $0-17
+	BR	·Cas(SB)
+
+TEXT ·Casint64(SB), NOSPLIT, $0-25
+	BR	·Cas64(SB)
+
+TEXT ·Casuintptr(SB), NOSPLIT, $0-25
+	BR	·Cas64(SB)
+
+TEXT ·Loaduintptr(SB),  NOSPLIT|NOFRAME, $0-16
+	BR	·Load64(SB)
+
+TEXT ·LoadAcquintptr(SB),  NOSPLIT|NOFRAME, $0-16
+	BR	·LoadAcq64(SB)
+
+TEXT ·Loaduint(SB), NOSPLIT|NOFRAME, $0-16
+	BR	·Load64(SB)
+
+TEXT ·Storeint32(SB), NOSPLIT, $0-12
+	BR	·Store(SB)
+
+TEXT ·Storeint64(SB), NOSPLIT, $0-16
+	BR	·Store64(SB)
+
+TEXT ·Storeuintptr(SB), NOSPLIT, $0-16
+	BR	·Store64(SB)
+
+TEXT ·StoreReluintptr(SB), NOSPLIT, $0-16
+	BR	·StoreRel64(SB)
+
+TEXT ·Xadduintptr(SB), NOSPLIT, $0-24
+	BR	·Xadd64(SB)
+
+TEXT ·Loadint32(SB), NOSPLIT, $0-12
+	BR	·Load(SB)
+
+TEXT ·Loadint64(SB), NOSPLIT, $0-16
+	BR	·Load64(SB)
+
+TEXT ·Xaddint32(SB), NOSPLIT, $0-20
+	BR	·Xadd(SB)
+
+TEXT ·Xaddint64(SB), NOSPLIT, $0-24
+	BR	·Xadd64(SB)
+
+// bool casp(void **val, void *old, void *new)
+// Atomically:
+//	if(*val == old){
+//		*val = new;
+//		return 1;
+//	} else
+//		return 0;
+TEXT ·Casp1(SB), NOSPLIT, $0-25
+	BR ·Cas64(SB)
+
+// uint32 xadd(uint32 volatile *ptr, int32 delta)
+// Atomically:
+//	*val += delta;
+//	return *val;
+TEXT ·Xadd(SB), NOSPLIT, $0-20
+	MOVD	ptr+0(FP), R4
+	MOVW	delta+8(FP), R5
+	LWSYNC
+	LWAR	(R4), R3
+	ADD	R5, R3
+	STWCCC	R3, (R4)
+	BNE	-3(PC)
+	MOVW	R3, ret+16(FP)
+	RET
+
+// uint64 Xadd64(uint64 volatile *val, int64 delta)
+// Atomically:
+//	*val += delta;
+//	return *val;
+TEXT ·Xadd64(SB), NOSPLIT, $0-24
+	MOVD	ptr+0(FP), R4
+	MOVD	delta+8(FP), R5
+	LWSYNC
+	LDAR	(R4), R3
+	ADD	R5, R3
+	STDCCC	R3, (R4)
+	BNE	-3(PC)
+	MOVD	R3, ret+16(FP)
+	RET
+
+// uint32 Xchg(ptr *uint32, new uint32)
+// Atomically:
+//	old := *ptr;
+//	*ptr = new;
+//	return old;
+TEXT ·Xchg(SB), NOSPLIT, $0-20
+	MOVD	ptr+0(FP), R4
+	MOVW	new+8(FP), R5
+	LWSYNC
+	LWAR	(R4), R3
+	STWCCC	R5, (R4)
+	BNE	-2(PC)
+	ISYNC
+	MOVW	R3, ret+16(FP)
+	RET
+
+// uint64 Xchg64(ptr *uint64, new uint64)
+// Atomically:
+//	old := *ptr;
+//	*ptr = new;
+//	return old;
+TEXT ·Xchg64(SB), NOSPLIT, $0-24
+	MOVD	ptr+0(FP), R4
+	MOVD	new+8(FP), R5
+	LWSYNC
+	LDAR	(R4), R3
+	STDCCC	R5, (R4)
+	BNE	-2(PC)
+	ISYNC
+	MOVD	R3, ret+16(FP)
+	RET
+
+TEXT ·Xchgint32(SB), NOSPLIT, $0-20
+	BR	·Xchg(SB)
+
+TEXT ·Xchgint64(SB), NOSPLIT, $0-24
+	BR	·Xchg64(SB)
+
+TEXT ·Xchguintptr(SB), NOSPLIT, $0-24
+	BR	·Xchg64(SB)
+
+TEXT ·StorepNoWB(SB), NOSPLIT, $0-16
+	BR	·Store64(SB)
+
+TEXT ·Store(SB), NOSPLIT, $0-12
+	MOVD	ptr+0(FP), R3
+	MOVW	val+8(FP), R4
+	SYNC
+	MOVW	R4, 0(R3)
+	RET
+
+TEXT ·Store8(SB), NOSPLIT, $0-9
+	MOVD	ptr+0(FP), R3
+	MOVB	val+8(FP), R4
+	SYNC
+	MOVB	R4, 0(R3)
+	RET
+
+TEXT ·Store64(SB), NOSPLIT, $0-16
+	MOVD	ptr+0(FP), R3
+	MOVD	val+8(FP), R4
+	SYNC
+	MOVD	R4, 0(R3)
+	RET
+
+TEXT ·StoreRel(SB), NOSPLIT, $0-12
+	MOVD	ptr+0(FP), R3
+	MOVW	val+8(FP), R4
+	LWSYNC
+	MOVW	R4, 0(R3)
+	RET
+
+TEXT ·StoreRel64(SB), NOSPLIT, $0-16
+	MOVD	ptr+0(FP), R3
+	MOVD	val+8(FP), R4
+	LWSYNC
+	MOVD	R4, 0(R3)
+	RET
+
+// void ·Or8(byte volatile*, byte);
+TEXT ·Or8(SB), NOSPLIT, $0-9
+	MOVD	ptr+0(FP), R3
+	MOVBZ	val+8(FP), R4
+	LWSYNC
+again:
+	LBAR	(R3), R6
+	OR	R4, R6
+	STBCCC	R6, (R3)
+	BNE	again
+	RET
+
+// void ·And8(byte volatile*, byte);
+TEXT ·And8(SB), NOSPLIT, $0-9
+	MOVD	ptr+0(FP), R3
+	MOVBZ	val+8(FP), R4
+	LWSYNC
+again:
+	LBAR	(R3), R6
+	AND	R4, R6
+	STBCCC	R6, (R3)
+	BNE	again
+	RET
+
+// func Or(addr *uint32, v uint32)
+TEXT ·Or(SB), NOSPLIT, $0-12
+	MOVD	ptr+0(FP), R3
+	MOVW	val+8(FP), R4
+	LWSYNC
+again:
+	LWAR	(R3), R6
+	OR	R4, R6
+	STWCCC	R6, (R3)
+	BNE	again
+	RET
+
+// func And(addr *uint32, v uint32)
+TEXT ·And(SB), NOSPLIT, $0-12
+	MOVD	ptr+0(FP), R3
+	MOVW	val+8(FP), R4
+	LWSYNC
+again:
+	LWAR	(R3),R6
+	AND	R4, R6
+	STWCCC	R6, (R3)
+	BNE	again
+	RET
diff --git a/src/runtime/internal/atomic/atomic_riscv64.s b/src/runtime/internal/atomic/atomic_riscv64.s
index 74c896cea6..ec05302a78 100644
--- a/src/runtime/internal/atomic/atomic_riscv64.s
+++ b/src/runtime/internal/atomic/atomic_riscv64.s
@@ -37,7 +37,6 @@
 //      } else {
 //              return 0;
 //      }
-
 TEXT ·Cas(SB), NOSPLIT, $0-17
 	MOV	ptr+0(FP), A0
 	MOVW	old+8(FP), A1
@@ -121,6 +120,12 @@ TEXT ·Store64(SB), NOSPLIT, $0-16
 TEXT ·Casp1(SB), NOSPLIT, $0-25
 	JMP	·Cas64(SB)
 
+TEXT ·Casint32(SB),NOSPLIT,$0-17
+	JMP	·Cas(SB)
+
+TEXT ·Casint64(SB),NOSPLIT,$0-25
+	JMP	·Cas64(SB)
+
 TEXT ·Casuintptr(SB),NOSPLIT,$0-25
 	JMP	·Cas64(SB)
 
@@ -130,14 +135,26 @@ TEXT ·CasRel(SB), NOSPLIT, $0-17
 TEXT ·Loaduintptr(SB),NOSPLIT,$0-16
 	JMP	·Load64(SB)
 
+TEXT ·Storeint32(SB),NOSPLIT,$0-12
+	JMP	·Store(SB)
+
+TEXT ·Storeint64(SB),NOSPLIT,$0-16
+	JMP	·Store64(SB)
+
 TEXT ·Storeuintptr(SB),NOSPLIT,$0-16
 	JMP	·Store64(SB)
 
 TEXT ·Loaduint(SB),NOSPLIT,$0-16
 	JMP ·Loaduintptr(SB)
 
+TEXT ·Loadint32(SB),NOSPLIT,$0-12
+	JMP ·Load(SB)
+
 TEXT ·Loadint64(SB),NOSPLIT,$0-16
-	JMP ·Loaduintptr(SB)
+	JMP ·Load64(SB)
+
+TEXT ·Xaddint32(SB),NOSPLIT,$0-20
+	JMP ·Xadd(SB)
 
 TEXT ·Xaddint64(SB),NOSPLIT,$0-24
 	MOV	ptr+0(FP), A0
@@ -215,6 +232,14 @@ TEXT ·Xadd64(SB), NOSPLIT, $0-24
 TEXT ·Xadduintptr(SB), NOSPLIT, $0-24
 	JMP	·Xadd64(SB)
 
+// func Xchgint32(ptr *int32, new int32) int32
+TEXT ·Xchgint32(SB), NOSPLIT, $0-20
+	JMP	·Xchg(SB)
+
+// func Xchgint64(ptr *int64, new int64) int64
+TEXT ·Xchgint64(SB), NOSPLIT, $0-24
+	JMP	·Xchg64(SB)
+
 // func Xchguintptr(ptr *uintptr, new uintptr) uintptr
 TEXT ·Xchguintptr(SB), NOSPLIT, $0-24
 	JMP	·Xchg64(SB)
diff --git a/src/runtime/internal/atomic/asm_s390x.s b/src/runtime/internal/atomic/atomic_s390x.s
similarity index 86%
rename from src/runtime/internal/atomic/asm_s390x.s
rename to src/runtime/internal/atomic/atomic_s390x.s
index daf1f3cc9f..a0c204b0e1 100644
--- a/src/runtime/internal/atomic/asm_s390x.s
+++ b/src/runtime/internal/atomic/atomic_s390x.s
@@ -76,6 +76,14 @@ cas64_fail:
 	MOVB	$0, ret+24(FP)
 	RET
 
+// func Casint32(ptr *int32, old, new int32) bool
+TEXT ·Casint32(SB), NOSPLIT, $0-17
+	BR	·Cas(SB)
+
+// func Casint64(ptr *int64, old, new int64) bool
+TEXT ·Casint64(SB), NOSPLIT, $0-25
+	BR	·Cas64(SB)
+
 // func Casuintptr(ptr *uintptr, old, new uintptr) bool
 TEXT ·Casuintptr(SB), NOSPLIT, $0-25
 	BR	·Cas64(SB)
@@ -92,10 +100,22 @@ TEXT ·Loaduintptr(SB), NOSPLIT, $0-16
 TEXT ·Loaduint(SB), NOSPLIT, $0-16
 	BR	·Load64(SB)
 
+// func Storeint32(ptr *int32, new int32)
+TEXT ·Storeint32(SB), NOSPLIT, $0-12
+	BR	·Store(SB)
+
+// func Storeint64(ptr *int64, new int64)
+TEXT ·Storeint64(SB), NOSPLIT, $0-16
+	BR	·Store64(SB)
+
 // func Storeuintptr(ptr *uintptr, new uintptr)
 TEXT ·Storeuintptr(SB), NOSPLIT, $0-16
 	BR	·Store64(SB)
 
+// func Loadint32(ptr *int32) int32
+TEXT ·Loadint32(SB), NOSPLIT, $0-12
+	BR	·Load(SB)
+
 // func Loadint64(ptr *int64) int64
 TEXT ·Loadint64(SB), NOSPLIT, $0-16
 	BR	·Load64(SB)
@@ -104,6 +124,10 @@ TEXT ·Loadint64(SB), NOSPLIT, $0-16
 TEXT ·Xadduintptr(SB), NOSPLIT, $0-24
 	BR	·Xadd64(SB)
 
+// func Xaddint32(ptr *int32, delta int32) int32
+TEXT ·Xaddint32(SB), NOSPLIT, $0-20
+	BR	·Xadd(SB)
+
 // func Xaddint64(ptr *int64, delta int64) int64
 TEXT ·Xaddint64(SB), NOSPLIT, $0-24
 	BR	·Xadd64(SB)
@@ -168,6 +192,14 @@ repeat:
 	MOVD	R6, ret+16(FP)
 	RET
 
+// func Xchgint32(ptr *int32, new int32) int32
+TEXT ·Xchgint32(SB), NOSPLIT, $0-20
+	BR	·Xchg(SB)
+
+// func Xchgint64(ptr *int64, new int64) int64
+TEXT ·Xchgint64(SB), NOSPLIT, $0-24
+	BR	·Xchg64(SB)
+
 // func Xchguintptr(ptr *uintptr, new uintptr) uintptr
 TEXT ·Xchguintptr(SB), NOSPLIT, $0-24
 	BR	·Xchg64(SB)
diff --git a/src/runtime/internal/atomic/atomic_wasm.go b/src/runtime/internal/atomic/atomic_wasm.go
index b05d98ed51..3f77f16b4e 100644
--- a/src/runtime/internal/atomic/atomic_wasm.go
+++ b/src/runtime/internal/atomic/atomic_wasm.go
@@ -9,18 +9,28 @@
 //go:linkname Load
 //go:linkname Loadp
 //go:linkname Load64
+//go:linkname Loadint32
+//go:linkname Loadint64
 //go:linkname Loaduintptr
 //go:linkname Xadd
+//go:linkname Xaddint32
+//go:linkname Xaddint64
 //go:linkname Xadd64
 //go:linkname Xadduintptr
 //go:linkname Xchg
 //go:linkname Xchg64
+//go:linkname Xchgint32
+//go:linkname Xchgint64
 //go:linkname Xchguintptr
 //go:linkname Cas
 //go:linkname Cas64
+//go:linkname Casint32
+//go:linkname Casint64
 //go:linkname Casuintptr
 //go:linkname Store
 //go:linkname Store64
+//go:linkname Storeint32
+//go:linkname Storeint64
 //go:linkname Storeuintptr
 
 package atomic
@@ -109,6 +119,22 @@ func Xchg64(ptr *uint64, new uint64) uint64 {
 	return old
 }
 
+//go:nosplit
+//go:noinline
+func Xchgint32(ptr *int32, new int32) int32 {
+	old := *ptr
+	*ptr = new
+	return old
+}
+
+//go:nosplit
+//go:noinline
+func Xchgint64(ptr *int64, new int64) int64 {
+	old := *ptr
+	*ptr = new
+	return old
+}
+
 //go:nosplit
 //go:noinline
 func Xchguintptr(ptr *uintptr, new uintptr) uintptr {
@@ -195,6 +221,26 @@ func Store64(ptr *uint64, val uint64) {
 // NO go:noescape annotation; see atomic_pointer.go.
 func StorepNoWB(ptr unsafe.Pointer, val unsafe.Pointer)
 
+//go:nosplit
+//go:noinline
+func Casint32(ptr *int32, old, new int32) bool {
+	if *ptr == old {
+		*ptr = new
+		return true
+	}
+	return false
+}
+
+//go:nosplit
+//go:noinline
+func Casint64(ptr *int64, old, new int64) bool {
+	if *ptr == old {
+		*ptr = new
+		return true
+	}
+	return false
+}
+
 //go:nosplit
 //go:noinline
 func Cas(ptr *uint32, old, new uint32) bool {
@@ -235,6 +281,18 @@ func CasRel(ptr *uint32, old, new uint32) bool {
 	return false
 }
 
+//go:nosplit
+//go:noinline
+func Storeint32(ptr *int32, new int32) {
+	*ptr = new
+}
+
+//go:nosplit
+//go:noinline
+func Storeint64(ptr *int64, new int64) {
+	*ptr = new
+}
+
 //go:nosplit
 //go:noinline
 func Storeuintptr(ptr *uintptr, new uintptr) {
@@ -253,12 +311,26 @@ func Loaduint(ptr *uint) uint {
 	return *ptr
 }
 
+//go:nosplit
+//go:noinline
+func Loadint32(ptr *int32) int32 {
+	return *ptr
+}
+
 //go:nosplit
 //go:noinline
 func Loadint64(ptr *int64) int64 {
 	return *ptr
 }
 
+//go:nosplit
+//go:noinline
+func Xaddint32(ptr *int32, delta int32) int32 {
+	new := *ptr + delta
+	*ptr = new
+	return new
+}
+
 //go:nosplit
 //go:noinline
 func Xaddint64(ptr *int64, delta int64) int64 {
diff --git a/src/runtime/internal/atomic/asm_wasm.s b/src/runtime/internal/atomic/atomic_wasm.s
similarity index 78%
rename from src/runtime/internal/atomic/asm_wasm.s
rename to src/runtime/internal/atomic/atomic_wasm.s
index 7c33cb1ee9..1c2d1ce5e1 100644
--- a/src/runtime/internal/atomic/asm_wasm.s
+++ b/src/runtime/internal/atomic/atomic_wasm.s
@@ -4,7 +4,7 @@
 
 #include "textflag.h"
 
-TEXT runtime∕internal∕atomic·StorepNoWB(SB), NOSPLIT, $0-16
+TEXT ·StorepNoWB(SB), NOSPLIT, $0-16
 	MOVD ptr+0(FP), R0
 	MOVD val+8(FP), 0(R0)
 	RET
diff --git a/src/runtime/internal/atomic/stubs.go b/src/runtime/internal/atomic/stubs.go
index 1275884b2f..e7544ba448 100644
--- a/src/runtime/internal/atomic/stubs.go
+++ b/src/runtime/internal/atomic/stubs.go
@@ -15,9 +15,21 @@ func Cas(ptr *uint32, old, new uint32) bool
 // NO go:noescape annotation; see atomic_pointer.go.
 func Casp1(ptr *unsafe.Pointer, old, new unsafe.Pointer) bool
 
+//go:noescape
+func Casint32(ptr *int32, old, new int32) bool
+
+//go:noescape
+func Casint64(ptr *int64, old, new int64) bool
+
 //go:noescape
 func Casuintptr(ptr *uintptr, old, new uintptr) bool
 
+//go:noescape
+func Storeint32(ptr *int32, new int32)
+
+//go:noescape
+func Storeint64(ptr *int64, new int64)
+
 //go:noescape
 func Storeuintptr(ptr *uintptr, new uintptr)
 
@@ -29,8 +41,20 @@ func Loaduint(ptr *uint) uint
 
 // TODO(matloob): Should these functions have the go:noescape annotation?
 
+//go:noescape
+func Loadint32(ptr *int32) int32
+
 //go:noescape
 func Loadint64(ptr *int64) int64
 
+//go:noescape
+func Xaddint32(ptr *int32, delta int32) int32
+
 //go:noescape
 func Xaddint64(ptr *int64, delta int64) int64
+
+//go:noescape
+func Xchgint32(ptr *int32, new int32) int32
+
+//go:noescape
+func Xchgint64(ptr *int64, new int64) int64
diff --git a/src/runtime/internal/atomic/sys_linux_arm.s b/src/runtime/internal/atomic/sys_linux_arm.s
index 192be4b64f..0cc7fa73d1 100644
--- a/src/runtime/internal/atomic/sys_linux_arm.s
+++ b/src/runtime/internal/atomic/sys_linux_arm.s
@@ -24,7 +24,7 @@
 TEXT cas<>(SB),NOSPLIT,$0
 	MOVW	$0xffff0fc0, R15 // R15 is hardware PC.
 
-TEXT runtime∕internal∕atomic·Cas(SB),NOSPLIT|NOFRAME,$0
+TEXT ·Cas(SB),NOSPLIT|NOFRAME,$0
 	MOVB	runtime·goarm(SB), R11
 	CMP	$7, R11
 	BLT	2(PC)
diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index 4895fa5ef6..4c165ddcdb 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -759,8 +759,7 @@ func (c *gcControllerState) findRunnableGCWorker(_p_ *p) *g {
 				return false
 			}
 
-			// TODO: having atomic.Casint64 would be more pleasant.
-			if atomic.Cas64((*uint64)(unsafe.Pointer(ptr)), uint64(v), uint64(v-1)) {
+			if atomic.Casint64(ptr, v, v-1) {
 				return true
 			}
 		}
-- 
GitLab


From ef3122e909f8c14a6bddcd77092d36710e16989f Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Fri, 2 Apr 2021 15:57:46 -0400
Subject: [PATCH 1357/2400] cmd/internal/obj/x86: simplify huge frame prologue

For stack frames larger than StackBig, the stack split prologue needs
to guard against potential wraparound. Currently, it carefully
arranges to avoid underflow, but this is complicated and requires a
special check for StackPreempt. StackPreempt is no longer the only
stack poison value, so this check will incorrectly succeed if the
stack bound is poisoned with any other value.

This CL simplifies the logic of the check, reduces its length, and
accounts for any possible poison value by directly checking for
underflow.

Change-Id: I917a313102d6a21895ef7c4b0f304fb84b292c81
Reviewed-on: https://go-review.googlesource.com/c/go/+/307010
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/internal/obj/x86/obj6.go | 91 ++++++++++++--------------------
 src/runtime/stack.go             | 15 ++++--
 2 files changed, 43 insertions(+), 63 deletions(-)

diff --git a/src/cmd/internal/obj/x86/obj6.go b/src/cmd/internal/obj/x86/obj6.go
index 785e6f5bd3..e81e38ad25 100644
--- a/src/cmd/internal/obj/x86/obj6.go
+++ b/src/cmd/internal/obj/x86/obj6.go
@@ -1021,6 +1021,12 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
 		sub = ASUBL
 	}
 
+	tmp := int16(REG_AX) // use AX for 32-bit
+	if ctxt.Arch.Family == sys.AMD64 {
+		// Avoid register parameters.
+		tmp = int16(REGENTRYTMP0)
+	}
+
 	var q1 *obj.Prog
 	if framesize <= objabi.StackSmall {
 		// small stack: SP <= stackguard
@@ -1043,11 +1049,6 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
 		// unnecessarily. See issue #35470.
 		p = ctxt.StartUnsafePoint(p, newprog)
 	} else if framesize <= objabi.StackBig {
-		tmp := int16(REG_AX) // use AX for 32-bit
-		if ctxt.Arch.Family == sys.AMD64 {
-			// for 64-bit, stay away from register ABI parameter registers, even w/o GOEXPERIMENT=regabi
-			tmp = int16(REGENTRYTMP0)
-		}
 		// large stack: SP-framesize <= stackguard-StackSmall
 		//	LEAQ -xxx(SP), tmp
 		//	CMPQ tmp, stackguard
@@ -1073,77 +1074,51 @@ func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgA
 
 		p = ctxt.StartUnsafePoint(p, newprog) // see the comment above
 	} else {
-		tmp1 := int16(REG_SI)
-		tmp2 := int16(REG_AX)
-		if ctxt.Arch.Family == sys.AMD64 {
-			tmp1 = int16(REGENTRYTMP0) // register ABI uses REG_SI and REG_AX for parameters.
-			tmp2 = int16(REGENTRYTMP1)
-		}
-		// Such a large stack we need to protect against wraparound.
-		// If SP is close to zero:
-		//	SP-stackguard+StackGuard <= framesize + (StackGuard-StackSmall)
-		// The +StackGuard on both sides is required to keep the left side positive:
-		// SP is allowed to be slightly below stackguard. See stack.h.
+		// Such a large stack we need to protect against underflow.
+		// The runtime guarantees SP > objabi.StackBig, but
+		// framesize is large enough that SP-framesize may
+		// underflow, causing a direct comparison with the
+		// stack guard to incorrectly succeed. We explicitly
+		// guard against underflow.
 		//
-		// Preemption sets stackguard to StackPreempt, a very large value.
-		// That breaks the math above, so we have to check for that explicitly.
-		//	MOVQ	stackguard, tmp1
-		//	CMPQ	SI, $StackPreempt
-		//	JEQ	label-of-call-to-morestack
-		//	LEAQ	StackGuard(SP), tmp2
-		//	SUBQ	tmp1, tmp2
-		//	CMPQ	tmp2, $(framesize+(StackGuard-StackSmall))
+		//	MOVQ	SP, tmp
+		//	SUBQ	$(framesize - StackSmall), tmp
+		//	// If subtraction wrapped (carry set), morestack.
+		//	JCS	label-of-call-to-morestack
+		//	CMPQ	tmp, stackguard
 
 		p = obj.Appendp(p, newprog)
 
 		p.As = mov
-		p.From.Type = obj.TYPE_MEM
-		p.From.Reg = rg
-		p.From.Offset = 2 * int64(ctxt.Arch.PtrSize) // G.stackguard0
-		if cursym.CFunc() {
-			p.From.Offset = 3 * int64(ctxt.Arch.PtrSize) // G.stackguard1
-		}
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_SP
 		p.To.Type = obj.TYPE_REG
-		p.To.Reg = tmp1
+		p.To.Reg = tmp
 
 		p = ctxt.StartUnsafePoint(p, newprog) // see the comment above
 
 		p = obj.Appendp(p, newprog)
-		p.As = cmp
-		p.From.Type = obj.TYPE_REG
-		p.From.Reg = tmp1
-		p.To.Type = obj.TYPE_CONST
-		p.To.Offset = objabi.StackPreempt
-		if ctxt.Arch.Family == sys.I386 {
-			p.To.Offset = int64(uint32(objabi.StackPreempt & (1<<32 - 1)))
-		}
+		p.As = sub
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = int64(framesize) - objabi.StackSmall
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = tmp
 
 		p = obj.Appendp(p, newprog)
-		p.As = AJEQ
+		p.As = AJCS
 		p.To.Type = obj.TYPE_BRANCH
 		q1 = p
 
-		p = obj.Appendp(p, newprog)
-		p.As = lea
-		p.From.Type = obj.TYPE_MEM
-		p.From.Reg = REG_SP
-		p.From.Offset = int64(objabi.StackGuard)
-		p.To.Type = obj.TYPE_REG
-		p.To.Reg = tmp2
-
-		p = obj.Appendp(p, newprog)
-		p.As = sub
-		p.From.Type = obj.TYPE_REG
-		p.From.Reg = tmp1
-		p.To.Type = obj.TYPE_REG
-		p.To.Reg = tmp2
-
 		p = obj.Appendp(p, newprog)
 		p.As = cmp
 		p.From.Type = obj.TYPE_REG
-		p.From.Reg = tmp2
-		p.To.Type = obj.TYPE_CONST
-		p.To.Offset = int64(framesize) + (int64(objabi.StackGuard) - objabi.StackSmall)
+		p.From.Reg = tmp
+		p.To.Type = obj.TYPE_MEM
+		p.To.Reg = rg
+		p.To.Offset = 2 * int64(ctxt.Arch.PtrSize) // G.stackguard0
+		if cursym.CFunc() {
+			p.To.Offset = 3 * int64(ctxt.Arch.PtrSize) // G.stackguard1
+		}
 	}
 
 	// common
diff --git a/src/runtime/stack.go b/src/runtime/stack.go
index cdccdcc2c5..babfdfccf0 100644
--- a/src/runtime/stack.go
+++ b/src/runtime/stack.go
@@ -92,6 +92,10 @@ const (
 
 	// The stack guard is a pointer this many bytes above the
 	// bottom of the stack.
+	//
+	// The guard leaves enough room for one _StackSmall frame plus
+	// a _StackLimit chain of NOSPLIT calls plus _StackSystem
+	// bytes for the OS.
 	_StackGuard = 928*sys.StackGuardMultiplier + _StackSystem
 
 	// After a stack split check the SP is allowed to be this
@@ -123,15 +127,16 @@ const (
 const (
 	uintptrMask = 1<<(8*sys.PtrSize) - 1
 
+	// The values below can be stored to g.stackguard0 to force
+	// the next stack check to fail.
+	// These are all larger than any real SP.
+
 	// Goroutine preemption request.
-	// Stored into g->stackguard0 to cause split stack check failure.
-	// Must be greater than any real sp.
 	// 0xfffffade in hex.
 	stackPreempt = uintptrMask & -1314
 
-	// Thread is forking.
-	// Stored into g->stackguard0 to cause split stack check failure.
-	// Must be greater than any real sp.
+	// Thread is forking. Causes a split stack check failure.
+	// 0xfffffb2e in hex.
 	stackFork = uintptrMask & -1234
 
 	// Force a stack movement. Used for debugging.
-- 
GitLab


From 24dd8cfe23b2ffc0641611dd6299c037cb459807 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Fri, 2 Apr 2021 16:59:22 -0400
Subject: [PATCH 1358/2400] cmd/internal/obj/arm: simplify huge frame prologue

CL 307010 for arm.

Change-Id: I14d939eb8aa6f594927054a2595f8c270a0b607f
Reviewed-on: https://go-review.googlesource.com/c/go/+/307049
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/internal/obj/arm/a.out.go |  4 +--
 src/cmd/internal/obj/arm/obj5.go  | 58 ++++++++++---------------------
 2 files changed, 21 insertions(+), 41 deletions(-)

diff --git a/src/cmd/internal/obj/arm/a.out.go b/src/cmd/internal/obj/arm/a.out.go
index a1d9e28b96..fd695ad0c9 100644
--- a/src/cmd/internal/obj/arm/a.out.go
+++ b/src/cmd/internal/obj/arm/a.out.go
@@ -163,8 +163,8 @@ const (
 	C_SFCON
 	C_LFCON
 
-	C_RACON
-	C_LACON
+	C_RACON /* <=0xff rotated constant offset from auto */
+	C_LACON /* Large Auto CONstant, i.e. large offset from SP */
 
 	C_SBRA
 	C_LBRA
diff --git a/src/cmd/internal/obj/arm/obj5.go b/src/cmd/internal/obj/arm/obj5.go
index 7de04302d9..edb384806b 100644
--- a/src/cmd/internal/obj/arm/obj5.go
+++ b/src/cmd/internal/obj/arm/obj5.go
@@ -680,57 +680,37 @@ func (c *ctxt5) stacksplit(p *obj.Prog, framesize int32) *obj.Prog {
 		p.From.Reg = REG_R1
 		p.Reg = REG_R2
 	} else {
-		// Such a large stack we need to protect against wraparound
-		// if SP is close to zero.
-		//	SP-stackguard+StackGuard < framesize + (StackGuard-StackSmall)
-		// The +StackGuard on both sides is required to keep the left side positive:
-		// SP is allowed to be slightly below stackguard. See stack.h.
-		//	CMP     $StackPreempt, R1
-		//	MOVW.NE $StackGuard(SP), R2
-		//	SUB.NE  R1, R2
-		//	MOVW.NE $(framesize+(StackGuard-StackSmall)), R3
-		//	CMP.NE  R3, R2
-		p = obj.Appendp(p, c.newprog)
-
-		p.As = ACMP
-		p.From.Type = obj.TYPE_CONST
-		p.From.Offset = int64(uint32(objabi.StackPreempt & (1<<32 - 1)))
-		p.Reg = REG_R1
-
-		p = obj.Appendp(p, c.newprog)
-		p.As = AMOVW
-		p.From.Type = obj.TYPE_ADDR
-		p.From.Reg = REGSP
-		p.From.Offset = int64(objabi.StackGuard)
-		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_R2
-		p.Scond = C_SCOND_NE
+		// Such a large stack we need to protect against underflow.
+		// The runtime guarantees SP > objabi.StackBig, but
+		// framesize is large enough that SP-framesize may
+		// underflow, causing a direct comparison with the
+		// stack guard to incorrectly succeed. We explicitly
+		// guard against underflow.
+		//
+		//	// Try subtracting from SP and check for underflow.
+		//	// If this underflows, it sets C to 0.
+		//	SUB.S $(framesize-StackSmall), SP, R2
+		//	// If C is 1 (unsigned >=), compare with guard.
+		//	CMP.HS stackguard, R2
 
 		p = obj.Appendp(p, c.newprog)
 		p.As = ASUB
-		p.From.Type = obj.TYPE_REG
-		p.From.Reg = REG_R1
+		p.Scond = C_SBIT
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = int64(framesize) - objabi.StackSmall
+		p.Reg = REGSP
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = REG_R2
-		p.Scond = C_SCOND_NE
-
-		p = obj.Appendp(p, c.newprog)
-		p.As = AMOVW
-		p.From.Type = obj.TYPE_ADDR
-		p.From.Offset = int64(framesize) + (int64(objabi.StackGuard) - objabi.StackSmall)
-		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_R3
-		p.Scond = C_SCOND_NE
 
 		p = obj.Appendp(p, c.newprog)
 		p.As = ACMP
+		p.Scond = C_SCOND_HS
 		p.From.Type = obj.TYPE_REG
-		p.From.Reg = REG_R3
+		p.From.Reg = REG_R1
 		p.Reg = REG_R2
-		p.Scond = C_SCOND_NE
 	}
 
-	// BLS call-to-morestack
+	// BLS call-to-morestack (C is 0 or Z is 1)
 	bls := obj.Appendp(p, c.newprog)
 	bls.As = ABLS
 	bls.To.Type = obj.TYPE_BRANCH
-- 
GitLab


From 4702dd67a7dcf1eac2309218807287bcd48d4e09 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Fri, 2 Apr 2021 17:20:15 -0400
Subject: [PATCH 1359/2400] cmd/internal/obj/arm64: simplify huge frame
 prologue

CL 307010 for arm64.

Change-Id: I6c6e1bd6065df059e50c3632a9eb669b64fce899
Reviewed-on: https://go-review.googlesource.com/c/go/+/307050
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/internal/obj/arm64/obj7.go | 54 ++++++++++--------------------
 1 file changed, 17 insertions(+), 37 deletions(-)

diff --git a/src/cmd/internal/obj/arm64/obj7.go b/src/cmd/internal/obj/arm64/obj7.go
index bed21dbe53..514991e340 100644
--- a/src/cmd/internal/obj/arm64/obj7.go
+++ b/src/cmd/internal/obj/arm64/obj7.go
@@ -107,55 +107,35 @@ func (c *ctxt7) stacksplit(p *obj.Prog, framesize int32) *obj.Prog {
 		p.From.Reg = REG_R1
 		p.Reg = REG_R2
 	} else {
-		// Such a large stack we need to protect against wraparound
-		// if SP is close to zero.
-		//	SP-stackguard+StackGuard < framesize + (StackGuard-StackSmall)
-		// The +StackGuard on both sides is required to keep the left side positive:
-		// SP is allowed to be slightly below stackguard. See stack.h.
-		//	CMP	$StackPreempt, R1
-		//	BEQ	label_of_call_to_morestack
-		//	ADD	$StackGuard, SP, R2
-		//	SUB	R1, R2
-		//	MOV	$(framesize+(StackGuard-StackSmall)), R3
-		//	CMP	R3, R2
-		p = obj.Appendp(p, c.newprog)
-
-		p.As = ACMP
-		p.From.Type = obj.TYPE_CONST
-		p.From.Offset = objabi.StackPreempt
-		p.Reg = REG_R1
-
-		p = obj.Appendp(p, c.newprog)
-		q = p
-		p.As = ABEQ
-		p.To.Type = obj.TYPE_BRANCH
+		// Such a large stack we need to protect against underflow.
+		// The runtime guarantees SP > objabi.StackBig, but
+		// framesize is large enough that SP-framesize may
+		// underflow, causing a direct comparison with the
+		// stack guard to incorrectly succeed. We explicitly
+		// guard against underflow.
+		//
+		//	SUBS	$(framesize-StackSmall), SP, R2
+		//	// On underflow, jump to morestack
+		//	BLO	label_of_call_to_morestack
+		//	CMP	stackguard, R2
 
 		p = obj.Appendp(p, c.newprog)
-		p.As = AADD
+		p.As = ASUBS
 		p.From.Type = obj.TYPE_CONST
-		p.From.Offset = int64(objabi.StackGuard)
+		p.From.Offset = int64(framesize) - objabi.StackSmall
 		p.Reg = REGSP
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = REG_R2
 
 		p = obj.Appendp(p, c.newprog)
-		p.As = ASUB
-		p.From.Type = obj.TYPE_REG
-		p.From.Reg = REG_R1
-		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_R2
-
-		p = obj.Appendp(p, c.newprog)
-		p.As = AMOVD
-		p.From.Type = obj.TYPE_CONST
-		p.From.Offset = int64(framesize) + (int64(objabi.StackGuard) - objabi.StackSmall)
-		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_R3
+		q = p
+		p.As = ABLO
+		p.To.Type = obj.TYPE_BRANCH
 
 		p = obj.Appendp(p, c.newprog)
 		p.As = ACMP
 		p.From.Type = obj.TYPE_REG
-		p.From.Reg = REG_R3
+		p.From.Reg = REG_R1
 		p.Reg = REG_R2
 	}
 
-- 
GitLab


From 2b63404ddb04abec5279f0fa574cc06dcef242cf Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Fri, 2 Apr 2021 17:20:15 -0400
Subject: [PATCH 1360/2400] cmd/internal/obj/mips: simplify huge frame prologue

CL 307010 for mips.

Change-Id: Ie9addea728548315fdbb8e46f75da4010a9796bb
Reviewed-on: https://go-review.googlesource.com/c/go/+/307051
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/internal/obj/mips/obj0.go | 100 ++++++++++--------------------
 1 file changed, 33 insertions(+), 67 deletions(-)

diff --git a/src/cmd/internal/obj/mips/obj0.go b/src/cmd/internal/obj/mips/obj0.go
index 91bba90d41..1f31d0c4cd 100644
--- a/src/cmd/internal/obj/mips/obj0.go
+++ b/src/cmd/internal/obj/mips/obj0.go
@@ -648,16 +648,14 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 }
 
 func (c *ctxt0) stacksplit(p *obj.Prog, framesize int32) *obj.Prog {
-	var mov, add, sub obj.As
+	var mov, add obj.As
 
 	if c.ctxt.Arch.Family == sys.MIPS64 {
 		add = AADDV
 		mov = AMOVV
-		sub = ASUBVU
 	} else {
 		add = AADDU
 		mov = AMOVW
-		sub = ASUBU
 	}
 
 	// MOV	g_stackguard(g), R1
@@ -691,81 +689,49 @@ func (c *ctxt0) stacksplit(p *obj.Prog, framesize int32) *obj.Prog {
 		p.Reg = REG_R1
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = REG_R1
-	} else if framesize <= objabi.StackBig {
-		// large stack: SP-framesize < stackguard-StackSmall
-		//	ADD	$-(framesize-StackSmall), SP, R2
-		//	SGTU	R2, stackguard, R1
-		p = obj.Appendp(p, c.newprog)
-
-		p.As = add
-		p.From.Type = obj.TYPE_CONST
-		p.From.Offset = -(int64(framesize) - objabi.StackSmall)
-		p.Reg = REGSP
-		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_R2
-
-		p = obj.Appendp(p, c.newprog)
-		p.As = ASGTU
-		p.From.Type = obj.TYPE_REG
-		p.From.Reg = REG_R2
-		p.Reg = REG_R1
-		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_R1
 	} else {
-		// Such a large stack we need to protect against wraparound.
-		// If SP is close to zero:
-		//	SP-stackguard+StackGuard <= framesize + (StackGuard-StackSmall)
-		// The +StackGuard on both sides is required to keep the left side positive:
-		// SP is allowed to be slightly below stackguard. See stack.h.
-		//
-		// Preemption sets stackguard to StackPreempt, a very large value.
-		// That breaks the math above, so we have to check for that explicitly.
-		//	// stackguard is R1
-		//	MOV	$StackPreempt, R2
-		//	BEQ	R1, R2, label-of-call-to-morestack
-		//	ADD	$StackGuard, SP, R2
-		//	SUB	R1, R2
-		//	MOV	$(framesize+(StackGuard-StackSmall)), R1
-		//	SGTU	R2, R1, R1
-		p = obj.Appendp(p, c.newprog)
+		// large stack: SP-framesize < stackguard-StackSmall
+		offset := int64(framesize) - objabi.StackSmall
+		if framesize > objabi.StackBig {
+			// Such a large stack we need to protect against underflow.
+			// The runtime guarantees SP > objabi.StackBig, but
+			// framesize is large enough that SP-framesize may
+			// underflow, causing a direct comparison with the
+			// stack guard to incorrectly succeed. We explicitly
+			// guard against underflow.
+			//
+			//	SGTU	$(framesize-StackSmall), SP, R2
+			//	BNE	R2, label-of-call-to-morestack
+
+			p = obj.Appendp(p, c.newprog)
+			p.As = ASGTU
+			p.From.Type = obj.TYPE_CONST
+			p.From.Offset = offset
+			p.Reg = REGSP
+			p.To.Type = obj.TYPE_REG
+			p.To.Reg = REG_R2
 
-		p.As = mov
-		p.From.Type = obj.TYPE_CONST
-		p.From.Offset = objabi.StackPreempt
-		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_R2
+			p = obj.Appendp(p, c.newprog)
+			q = p
+			p.As = ABNE
+			p.From.Type = obj.TYPE_REG
+			p.From.Reg = REG_R2
+			p.To.Type = obj.TYPE_BRANCH
+			p.Mark |= BRANCH
+		}
 
+		// Check against the stack guard. We've ensured this won't underflow.
+		//	ADD	$-(framesize-StackSmall), SP, R2
+		//	SGTU	R2, stackguard, R1
 		p = obj.Appendp(p, c.newprog)
-		q = p
-		p.As = ABEQ
-		p.From.Type = obj.TYPE_REG
-		p.From.Reg = REG_R1
-		p.Reg = REG_R2
-		p.To.Type = obj.TYPE_BRANCH
-		p.Mark |= BRANCH
 
-		p = obj.Appendp(p, c.newprog)
 		p.As = add
 		p.From.Type = obj.TYPE_CONST
-		p.From.Offset = int64(objabi.StackGuard)
+		p.From.Offset = -offset
 		p.Reg = REGSP
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = REG_R2
 
-		p = obj.Appendp(p, c.newprog)
-		p.As = sub
-		p.From.Type = obj.TYPE_REG
-		p.From.Reg = REG_R1
-		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_R2
-
-		p = obj.Appendp(p, c.newprog)
-		p.As = mov
-		p.From.Type = obj.TYPE_CONST
-		p.From.Offset = int64(framesize) + int64(objabi.StackGuard) - objabi.StackSmall
-		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_R1
-
 		p = obj.Appendp(p, c.newprog)
 		p.As = ASGTU
 		p.From.Type = obj.TYPE_REG
-- 
GitLab


From a06b08e7d1837df636d24f945fe9b3b2a369b450 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Fri, 2 Apr 2021 17:20:15 -0400
Subject: [PATCH 1361/2400] cmd/internal/obj/ppc64: simplify huge frame
 prologue

CL 307010 for ppc64.

I spent a long time trying to figure out how to use the carry bit from
ADDCCC to further simplify this (like what we do on arm64), but gave
up after I couldn't figure out how to access the carry bit without
just adding more instructions.

Change-Id: I6cad51b93616865b203cb16554f16121375aabbc
Reviewed-on: https://go-review.googlesource.com/c/go/+/307149
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/internal/obj/ppc64/obj9.go | 103 ++++++++++++-----------------
 1 file changed, 44 insertions(+), 59 deletions(-)

diff --git a/src/cmd/internal/obj/ppc64/obj9.go b/src/cmd/internal/obj/ppc64/obj9.go
index a77be29cf0..c2722b0afb 100644
--- a/src/cmd/internal/obj/ppc64/obj9.go
+++ b/src/cmd/internal/obj/ppc64/obj9.go
@@ -1081,80 +1081,65 @@ func (c *ctxt9) stacksplit(p *obj.Prog, framesize int32) *obj.Prog {
 		p.From.Reg = REG_R3
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = REGSP
-	} else if framesize <= objabi.StackBig {
+	} else {
 		// large stack: SP-framesize < stackguard-StackSmall
-		//	ADD $-(framesize-StackSmall), SP, R4
-		//	CMP stackguard, R4
-		p = obj.Appendp(p, c.newprog)
-
-		p.As = AADD
-		p.From.Type = obj.TYPE_CONST
-		p.From.Offset = -(int64(framesize) - objabi.StackSmall)
-		p.Reg = REGSP
-		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_R4
+		offset := int64(framesize) - objabi.StackSmall
+		if framesize > objabi.StackBig {
+			// Such a large stack we need to protect against underflow.
+			// The runtime guarantees SP > objabi.StackBig, but
+			// framesize is large enough that SP-framesize may
+			// underflow, causing a direct comparison with the
+			// stack guard to incorrectly succeed. We explicitly
+			// guard against underflow.
+			//
+			//	CMPU	SP, $(framesize-StackSmall)
+			//	BLT	label-of-call-to-morestack
+			if offset <= 0xffff {
+				p = obj.Appendp(p, c.newprog)
+				p.As = ACMPU
+				p.From.Type = obj.TYPE_REG
+				p.From.Reg = REGSP
+				p.To.Type = obj.TYPE_CONST
+				p.To.Offset = offset
+			} else {
+				// Constant is too big for CMPU.
+				p = obj.Appendp(p, c.newprog)
+				p.As = AMOVD
+				p.From.Type = obj.TYPE_CONST
+				p.From.Offset = offset
+				p.To.Type = obj.TYPE_REG
+				p.To.Reg = REG_R4
 
-		p = obj.Appendp(p, c.newprog)
-		p.As = ACMPU
-		p.From.Type = obj.TYPE_REG
-		p.From.Reg = REG_R3
-		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_R4
-	} else {
-		// Such a large stack we need to protect against wraparound.
-		// If SP is close to zero:
-		//	SP-stackguard+StackGuard <= framesize + (StackGuard-StackSmall)
-		// The +StackGuard on both sides is required to keep the left side positive:
-		// SP is allowed to be slightly below stackguard. See stack.h.
-		//
-		// Preemption sets stackguard to StackPreempt, a very large value.
-		// That breaks the math above, so we have to check for that explicitly.
-		//	// stackguard is R3
-		//	CMP	R3, $StackPreempt
-		//	BEQ	label-of-call-to-morestack
-		//	ADD	$StackGuard, SP, R4
-		//	SUB	R3, R4
-		//	MOVD	$(framesize+(StackGuard-StackSmall)), R31
-		//	CMPU	R31, R4
-		p = obj.Appendp(p, c.newprog)
+				p = obj.Appendp(p, c.newprog)
+				p.As = ACMPU
+				p.From.Type = obj.TYPE_REG
+				p.From.Reg = REGSP
+				p.To.Type = obj.TYPE_REG
+				p.To.Reg = REG_R4
+			}
 
-		p.As = ACMP
-		p.From.Type = obj.TYPE_REG
-		p.From.Reg = REG_R3
-		p.To.Type = obj.TYPE_CONST
-		p.To.Offset = objabi.StackPreempt
+			p = obj.Appendp(p, c.newprog)
+			q = p
+			p.As = ABLT
+			p.To.Type = obj.TYPE_BRANCH
+		}
 
+		// Check against the stack guard. We've ensured this won't underflow.
+		//	ADD  $-(framesize-StackSmall), SP, R4
+		//	CMPU stackguard, R4
 		p = obj.Appendp(p, c.newprog)
-		q = p
-		p.As = ABEQ
-		p.To.Type = obj.TYPE_BRANCH
 
-		p = obj.Appendp(p, c.newprog)
 		p.As = AADD
 		p.From.Type = obj.TYPE_CONST
-		p.From.Offset = int64(objabi.StackGuard)
+		p.From.Offset = -offset
 		p.Reg = REGSP
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = REG_R4
 
-		p = obj.Appendp(p, c.newprog)
-		p.As = ASUB
-		p.From.Type = obj.TYPE_REG
-		p.From.Reg = REG_R3
-		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_R4
-
-		p = obj.Appendp(p, c.newprog)
-		p.As = AMOVD
-		p.From.Type = obj.TYPE_CONST
-		p.From.Offset = int64(framesize) + int64(objabi.StackGuard) - objabi.StackSmall
-		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REGTMP
-
 		p = obj.Appendp(p, c.newprog)
 		p.As = ACMPU
 		p.From.Type = obj.TYPE_REG
-		p.From.Reg = REGTMP
+		p.From.Reg = REG_R3
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = REG_R4
 	}
-- 
GitLab


From 042f4cbb6fbd7f9e6a6587fb3bee2d1716184f9a Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Fri, 2 Apr 2021 17:20:15 -0400
Subject: [PATCH 1362/2400] cmd/internal/obj/riscv: simplify huge frame
 prologue

CL 307010 for riscv64.

Some of the comments on the other prologue paths were wrong, so this
CL also fixes them up.

Change-Id: Icdca1ade3a47ae6e2467af832690d40689dbe1b6
Reviewed-on: https://go-review.googlesource.com/c/go/+/307150
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/internal/obj/riscv/obj.go | 99 +++++++++++--------------------
 1 file changed, 34 insertions(+), 65 deletions(-)

diff --git a/src/cmd/internal/obj/riscv/obj.go b/src/cmd/internal/obj/riscv/obj.go
index ee6fb0909b..a305edab4b 100644
--- a/src/cmd/internal/obj/riscv/obj.go
+++ b/src/cmd/internal/obj/riscv/obj.go
@@ -984,8 +984,9 @@ func stacksplit(ctxt *obj.Link, p *obj.Prog, cursym *obj.LSym, newprog obj.ProgA
 	var to_done, to_more *obj.Prog
 
 	if framesize <= objabi.StackSmall {
-		// small stack: SP < stackguard
-		//	BLTU	SP, stackguard, done
+		// small stack
+		//	// if SP > stackguard { goto done }
+		//	BLTU	stackguard, SP, done
 		p = obj.Appendp(p, newprog)
 		p.As = ABLTU
 		p.From.Type = obj.TYPE_REG
@@ -993,80 +994,48 @@ func stacksplit(ctxt *obj.Link, p *obj.Prog, cursym *obj.LSym, newprog obj.ProgA
 		p.Reg = REG_SP
 		p.To.Type = obj.TYPE_BRANCH
 		to_done = p
-	} else if framesize <= objabi.StackBig {
+	} else {
 		// large stack: SP-framesize < stackguard-StackSmall
-		//	ADD	$-(framesize-StackSmall), SP, X11
-		//	BLTU	X11, stackguard, done
-		p = obj.Appendp(p, newprog)
-		// TODO(sorear): logic inconsistent with comment, but both match all non-x86 arches
-		p.As = AADDI
-		p.From.Type = obj.TYPE_CONST
-		p.From.Offset = -(int64(framesize) - objabi.StackSmall)
-		p.Reg = REG_SP
-		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_X11
+		offset := int64(framesize) - objabi.StackSmall
+		if framesize > objabi.StackBig {
+			// Such a large stack we need to protect against underflow.
+			// The runtime guarantees SP > objabi.StackBig, but
+			// framesize is large enough that SP-framesize may
+			// underflow, causing a direct comparison with the
+			// stack guard to incorrectly succeed. We explicitly
+			// guard against underflow.
+			//
+			//	MOV	$(framesize-StackSmall), X11
+			//	BLTU	SP, X11, label-of-call-to-morestack
 
-		p = obj.Appendp(p, newprog)
-		p.As = ABLTU
-		p.From.Type = obj.TYPE_REG
-		p.From.Reg = REG_X10
-		p.Reg = REG_X11
-		p.To.Type = obj.TYPE_BRANCH
-		to_done = p
-	} else {
-		// Such a large stack we need to protect against wraparound.
-		// If SP is close to zero:
-		//	SP-stackguard+StackGuard <= framesize + (StackGuard-StackSmall)
-		// The +StackGuard on both sides is required to keep the left side positive:
-		// SP is allowed to be slightly below stackguard. See stack.h.
-		//
-		// Preemption sets stackguard to StackPreempt, a very large value.
-		// That breaks the math above, so we have to check for that explicitly.
-		//	// stackguard is X10
-		//	MOV	$StackPreempt, X11
-		//	BEQ	X10, X11, more
-		//	ADD	$StackGuard, SP, X11
-		//	SUB	X10, X11
-		//	MOV	$(framesize+(StackGuard-StackSmall)), X10
-		//	BGTU	X11, X10, done
-		p = obj.Appendp(p, newprog)
-		p.As = AMOV
-		p.From.Type = obj.TYPE_CONST
-		p.From.Offset = objabi.StackPreempt
-		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_X11
+			p = obj.Appendp(p, newprog)
+			p.As = AMOV
+			p.From.Type = obj.TYPE_CONST
+			p.From.Offset = offset
+			p.To.Type = obj.TYPE_REG
+			p.To.Reg = REG_X11
 
-		p = obj.Appendp(p, newprog)
-		to_more = p
-		p.As = ABEQ
-		p.From.Type = obj.TYPE_REG
-		p.From.Reg = REG_X10
-		p.Reg = REG_X11
-		p.To.Type = obj.TYPE_BRANCH
+			p = obj.Appendp(p, newprog)
+			p.As = ABLTU
+			p.From.Type = obj.TYPE_REG
+			p.From.Reg = REG_SP
+			p.Reg = REG_X11
+			p.To.Type = obj.TYPE_BRANCH
+			to_more = p
+		}
 
+		// Check against the stack guard. We've ensured this won't underflow.
+		//	ADD	$-(framesize-StackSmall), SP, X11
+		//	// if X11 > stackguard { goto done }
+		//	BLTU	stackguard, X11, done
 		p = obj.Appendp(p, newprog)
 		p.As = AADDI
 		p.From.Type = obj.TYPE_CONST
-		p.From.Offset = int64(objabi.StackGuard)
+		p.From.Offset = -offset
 		p.Reg = REG_SP
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = REG_X11
 
-		p = obj.Appendp(p, newprog)
-		p.As = ASUB
-		p.From.Type = obj.TYPE_REG
-		p.From.Reg = REG_X10
-		p.Reg = REG_X11
-		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_X11
-
-		p = obj.Appendp(p, newprog)
-		p.As = AMOV
-		p.From.Type = obj.TYPE_CONST
-		p.From.Offset = int64(framesize) + int64(objabi.StackGuard) - objabi.StackSmall
-		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_X10
-
 		p = obj.Appendp(p, newprog)
 		p.As = ABLTU
 		p.From.Type = obj.TYPE_REG
-- 
GitLab


From 191167c2b20c87acbc9b8033dac900b8811b146a Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Fri, 2 Apr 2021 17:20:15 -0400
Subject: [PATCH 1363/2400] cmd/internal/obj/s390x: simplify huge frame
 prologue

CL 307010 for s390x.

Change-Id: I43e1f93dd01c814417f8ef7480aa82c05b2b6b66
Reviewed-on: https://go-review.googlesource.com/c/go/+/307151
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/internal/obj/s390x/objz.go | 104 ++++++++++-------------------
 1 file changed, 37 insertions(+), 67 deletions(-)

diff --git a/src/cmd/internal/obj/s390x/objz.go b/src/cmd/internal/obj/s390x/objz.go
index a02c4fc17f..201163b015 100644
--- a/src/cmd/internal/obj/s390x/objz.go
+++ b/src/cmd/internal/obj/s390x/objz.go
@@ -568,7 +568,6 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 }
 
 func (c *ctxtz) stacksplitPre(p *obj.Prog, framesize int32) (*obj.Prog, *obj.Prog) {
-	var q *obj.Prog
 
 	// MOVD	g_stackguard(g), R3
 	p = obj.Appendp(p, c.newprog)
@@ -589,98 +588,69 @@ func (c *ctxtz) stacksplitPre(p *obj.Prog, framesize int32) (*obj.Prog, *obj.Pro
 	// unnecessarily. See issue #35470.
 	p = c.ctxt.StartUnsafePoint(p, c.newprog)
 
-	q = nil
 	if framesize <= objabi.StackSmall {
 		// small stack: SP < stackguard
 		//	CMPUBGE	stackguard, SP, label-of-call-to-morestack
 
 		p = obj.Appendp(p, c.newprog)
-		//q1 = p
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = REG_R3
 		p.Reg = REGSP
 		p.As = ACMPUBGE
 		p.To.Type = obj.TYPE_BRANCH
 
-	} else if framesize <= objabi.StackBig {
-		// large stack: SP-framesize < stackguard-StackSmall
-		//	ADD $-(framesize-StackSmall), SP, R4
-		//	CMPUBGE stackguard, R4, label-of-call-to-morestack
-		p = obj.Appendp(p, c.newprog)
+		return p, nil
+	}
 
-		p.As = AADD
-		p.From.Type = obj.TYPE_CONST
-		p.From.Offset = -(int64(framesize) - objabi.StackSmall)
-		p.Reg = REGSP
-		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_R4
+	// large stack: SP-framesize < stackguard-StackSmall
 
-		p = obj.Appendp(p, c.newprog)
-		p.From.Type = obj.TYPE_REG
-		p.From.Reg = REG_R3
-		p.Reg = REG_R4
-		p.As = ACMPUBGE
-		p.To.Type = obj.TYPE_BRANCH
-
-	} else {
-		// Such a large stack we need to protect against wraparound.
-		// If SP is close to zero:
-		//	SP-stackguard+StackGuard <= framesize + (StackGuard-StackSmall)
-		// The +StackGuard on both sides is required to keep the left side positive:
-		// SP is allowed to be slightly below stackguard. See stack.h.
+	var q *obj.Prog
+	offset := int64(framesize) - objabi.StackSmall
+	if framesize > objabi.StackBig {
+		// Such a large stack we need to protect against underflow.
+		// The runtime guarantees SP > objabi.StackBig, but
+		// framesize is large enough that SP-framesize may
+		// underflow, causing a direct comparison with the
+		// stack guard to incorrectly succeed. We explicitly
+		// guard against underflow.
 		//
-		// Preemption sets stackguard to StackPreempt, a very large value.
-		// That breaks the math above, so we have to check for that explicitly.
-		//	// stackguard is R3
-		//	CMP	R3, $StackPreempt
-		//	BEQ	label-of-call-to-morestack
-		//	ADD	$StackGuard, SP, R4
-		//	SUB	R3, R4
-		//	MOVD	$(framesize+(StackGuard-StackSmall)), TEMP
-		//	CMPUBGE	TEMP, R4, label-of-call-to-morestack
-		p = obj.Appendp(p, c.newprog)
-
-		p.As = ACMP
-		p.From.Type = obj.TYPE_REG
-		p.From.Reg = REG_R3
-		p.To.Type = obj.TYPE_CONST
-		p.To.Offset = objabi.StackPreempt
-
-		p = obj.Appendp(p, c.newprog)
-		q = p
-		p.As = ABEQ
-		p.To.Type = obj.TYPE_BRANCH
-
-		p = obj.Appendp(p, c.newprog)
-		p.As = AADD
-		p.From.Type = obj.TYPE_CONST
-		p.From.Offset = int64(objabi.StackGuard)
-		p.Reg = REGSP
-		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_R4
-
-		p = obj.Appendp(p, c.newprog)
-		p.As = ASUB
-		p.From.Type = obj.TYPE_REG
-		p.From.Reg = REG_R3
-		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REG_R4
+		//	MOVD	$(framesize-StackSmall), R4
+		//	CMPUBLT	SP, R4, label-of-call-to-morestack
 
 		p = obj.Appendp(p, c.newprog)
 		p.As = AMOVD
 		p.From.Type = obj.TYPE_CONST
-		p.From.Offset = int64(framesize) + int64(objabi.StackGuard) - objabi.StackSmall
+		p.From.Offset = offset
 		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REGTMP
+		p.To.Reg = REG_R4
 
 		p = obj.Appendp(p, c.newprog)
+		q = p
+		p.As = ACMPUBLT
 		p.From.Type = obj.TYPE_REG
-		p.From.Reg = REGTMP
+		p.From.Reg = REGSP
 		p.Reg = REG_R4
-		p.As = ACMPUBGE
 		p.To.Type = obj.TYPE_BRANCH
 	}
 
+	// Check against the stack guard. We've ensured this won't underflow.
+	//	ADD $-(framesize-StackSmall), SP, R4
+	//	CMPUBGE stackguard, R4, label-of-call-to-morestack
+	p = obj.Appendp(p, c.newprog)
+	p.As = AADD
+	p.From.Type = obj.TYPE_CONST
+	p.From.Offset = -offset
+	p.Reg = REGSP
+	p.To.Type = obj.TYPE_REG
+	p.To.Reg = REG_R4
+
+	p = obj.Appendp(p, c.newprog)
+	p.From.Type = obj.TYPE_REG
+	p.From.Reg = REG_R3
+	p.Reg = REG_R4
+	p.As = ACMPUBGE
+	p.To.Type = obj.TYPE_BRANCH
+
 	return p, q
 }
 
-- 
GitLab


From 9e3328e7407ab7cd24f48d27ba69d265c57d5805 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Sat, 3 Apr 2021 16:29:34 -0400
Subject: [PATCH 1364/2400] cmd/internal/objabi: remove StackPreempt

None of the stack check prologues depend on this constant at this
point (and, indeed, they shouldn't).

Change-Id: Iaa40d9c47285b26952f02a7bdde574e8385ffe95
Reviewed-on: https://go-review.googlesource.com/c/go/+/307152
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/internal/objabi/stack.go | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/cmd/internal/objabi/stack.go b/src/cmd/internal/objabi/stack.go
index 05a1d4a4b5..1f531176cc 100644
--- a/src/cmd/internal/objabi/stack.go
+++ b/src/cmd/internal/objabi/stack.go
@@ -13,10 +13,6 @@ const (
 	StackSmall  = 128
 )
 
-const (
-	StackPreempt = -1314 // 0xfff...fade
-)
-
 // Initialize StackGuard and StackLimit according to target system.
 var StackGuard = 928*stackGuardMultiplier() + StackSystem
 var StackLimit = StackGuard - StackSystem - StackSmall
-- 
GitLab


From dcf85b30ba422c50e6e96893a3ed930aea5b6b4a Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Fri, 2 Apr 2021 21:04:31 -0400
Subject: [PATCH 1365/2400] cmd/link: mangle function name with ABI on Mach-O

This is not strictly necessary. But as we already do this on
ELF and PE, do it here as well.

Updates #40724.

Change-Id: Ie6e5211aba116634bc9ed82eb8d22a7fed3b7776
Reviewed-on: https://go-review.googlesource.com/c/go/+/307229
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Austin Clements <austin@google.com>
---
 src/cmd/link/internal/ld/macho.go | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/cmd/link/internal/ld/macho.go b/src/cmd/link/internal/ld/macho.go
index 3630e67c25..872144e723 100644
--- a/src/cmd/link/internal/ld/macho.go
+++ b/src/cmd/link/internal/ld/macho.go
@@ -1022,7 +1022,10 @@ func machosymtab(ctxt *Link) {
 		symstr.AddUint8('_')
 
 		// replace "·" as ".", because DTrace cannot handle it.
-		symstr.Addstring(strings.Replace(ldr.SymExtname(s), "·", ".", -1))
+		name := strings.Replace(ldr.SymExtname(s), "·", ".", -1)
+
+		name = mangleABIName(ldr, s, name)
+		symstr.Addstring(name)
 
 		if t := ldr.SymType(s); t == sym.SDYNIMPORT || t == sym.SHOSTOBJ || t == sym.SUNDEFEXT {
 			symtab.AddUint8(0x01)                             // type N_EXT, external symbol
-- 
GitLab


From e617b2b0dd14faddad82599f31f64bce3ff2ca2f Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Fri, 2 Apr 2021 21:48:00 -0400
Subject: [PATCH 1366/2400] cmd/compile: add a debug flag to enable/disable
 open-coded defers

For debugging.

Change-Id: I831947376569cd2285b713ad304329951adf60ab
Reviewed-on: https://go-review.googlesource.com/c/go/+/307230
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Austin Clements <austin@google.com>
---
 src/cmd/compile/internal/base/debug.go | 1 +
 src/cmd/compile/internal/ssagen/ssa.go | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/src/cmd/compile/internal/base/debug.go b/src/cmd/compile/internal/base/debug.go
index 7590dc1bfa..71712ab1a5 100644
--- a/src/cmd/compile/internal/base/debug.go
+++ b/src/cmd/compile/internal/base/debug.go
@@ -39,6 +39,7 @@ type DebugFlags struct {
 	Libfuzzer            int    `help:"enable coverage instrumentation for libfuzzer"`
 	LocationLists        int    `help:"print information about DWARF location list creation"`
 	Nil                  int    `help:"print information about nil checks"`
+	NoOpenDefer          int    `help:"disable open-coded defers"`
 	PCTab                string `help:"print named pc-value table"`
 	Panic                int    `help:"show all compiler panics"`
 	Slice                int    `help:"print information about slice compilation"`
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 67c9e9c198..0a49ca214d 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -470,6 +470,8 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 
 	s.hasOpenDefers = base.Flag.N == 0 && s.hasdefer && !s.curfn.OpenCodedDeferDisallowed()
 	switch {
+	case base.Debug.NoOpenDefer != 0:
+		s.hasOpenDefers = false
 	case s.hasOpenDefers && (base.Ctxt.Flag_shared || base.Ctxt.Flag_dynlink) && base.Ctxt.Arch.Name == "386":
 		// Don't support open-coded defers for 386 ONLY when using shared
 		// libraries, because there is extra code (added by rewriteToUseGot())
-- 
GitLab


From 411860251eb91b284efb901264a9c46d26b588e3 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Sun, 4 Apr 2021 12:15:13 -0400
Subject: [PATCH 1367/2400] cmd/compile: reference ABIInternal memequal_varlen

memequal_varlen is put into a closure and is called in internal
ABI in the runtime. Emit an ABIInternal reference.

Updates #40724.

Change-Id: I914555f8188561882625e008b595389e50a3a167
Reviewed-on: https://go-review.googlesource.com/c/go/+/307233
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Austin Clements <austin@google.com>
---
 src/cmd/compile/internal/reflectdata/alg.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/reflectdata/alg.go b/src/cmd/compile/internal/reflectdata/alg.go
index 9f2efbc3a0..d12d9ca0a7 100644
--- a/src/cmd/compile/internal/reflectdata/alg.go
+++ b/src/cmd/compile/internal/reflectdata/alg.go
@@ -353,7 +353,7 @@ func geneq(t *types.Type) *obj.LSym {
 			return closure
 		}
 		if memequalvarlen == nil {
-			memequalvarlen = typecheck.LookupRuntimeVar("memequal_varlen") // asm func
+			memequalvarlen = typecheck.LookupRuntimeFunc("memequal_varlen")
 		}
 		ot := 0
 		ot = objw.SymPtr(closure, ot, memequalvarlen, 0)
-- 
GitLab


From 45e87cd3ecfe5e579a06493ef8cd43ce9947262c Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Sun, 4 Apr 2021 12:20:35 -0400
Subject: [PATCH 1368/2400] cmd/compile: disable tail call for method wrappers
 when RegabiArgs is enabled

Currently, the IR of tailcall does not connect the arguments with
the OTAILCALL node, so the arguments are not marshaled correctly.
Disable tail call for now.

Updates #40724.

Change-Id: I39de3ea8e19a23eb63768ab7282d2f870e9c266e
Reviewed-on: https://go-review.googlesource.com/c/go/+/307234
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Austin Clements <austin@google.com>
---
 src/cmd/compile/internal/reflectdata/reflect.go | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index 3a31e3c951..379735e86b 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -1770,7 +1770,11 @@ func methodWrapper(rcvr *types.Type, method *types.Field) *obj.LSym {
 	// the TOC to the appropriate value for that module. But if it returns
 	// directly to the wrapper's caller, nothing will reset it to the correct
 	// value for that function.
-	if !base.Flag.Cfg.Instrumenting && rcvr.IsPtr() && methodrcvr.IsPtr() && method.Embedded != 0 && !types.IsInterfaceMethod(method.Type) && !(base.Ctxt.Arch.Name == "ppc64le" && base.Ctxt.Flag_dynlink) {
+	//
+	// Disable tailcall for RegabiArgs for now. The IR does not connect the
+	// arguments with the OTAILCALL node, and the arguments are not marshaled
+	// correctly.
+	if !base.Flag.Cfg.Instrumenting && rcvr.IsPtr() && methodrcvr.IsPtr() && method.Embedded != 0 && !types.IsInterfaceMethod(method.Type) && !(base.Ctxt.Arch.Name == "ppc64le" && base.Ctxt.Flag_dynlink) && !objabi.Experiment.RegabiArgs {
 		// generate tail call: adjust pointer receiver and jump to embedded method.
 		left := dot.X // skip final .M
 		if !left.Type().IsPtr() {
-- 
GitLab


From 5cc5576a9cff098e6e47397ee32cb250de43d814 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Sun, 4 Apr 2021 12:46:21 -0400
Subject: [PATCH 1369/2400] cmd/compile: untangle Wrapper and ABIWrapper flags

Currently, there are Wrapper and ABIWrapper attributes. Wrapper
is set when compiler generates an wrapper function (e.g. method
wrapper). ABIWrapper is set when compiler generates an ABI
wrapper. It also sets Wrapper flag for ABI wrappers.

Currently, they have the following meanings:
- Wrapper flag hides the frame from (normal) traceback.
- Wrapper flag enables special panic+recover adjustment, so it
  can correctly recover when a wrapper function is deferred.
- ABIWrapper flag disables the panic+recover adjustment, because
  we never defer an ABI wrapper that can recover.

This CL changes them to:
- Both Wrapper and ABIWrapper flags hide the frame from (normal)
  traceback. (Setting one is enough.)
- Wrapper flag enables special panic+recover adjustment.
  ABIWrapper flag no longer has effect on this.

This makes it clearer if we do want an ABI wrapper that also does
the panic+recover adjustment. In the old mechanism we'd have to
unset ABIWrapper flag, even if the function is actually an ABI
wrapper. In the new mechanism we just need to set both ABIWrapper
and Wrapper flags.

Updates #40724.

Change-Id: I7fbc83f85d23676dc94db51dfda63dcacdf1fc19
Reviewed-on: https://go-review.googlesource.com/c/go/+/307235
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Austin Clements <austin@google.com>
---
 src/cmd/compile/internal/ssagen/abi.go | 7 -------
 src/cmd/internal/obj/plist.go          | 2 +-
 src/cmd/internal/obj/x86/obj6.go       | 4 ++--
 3 files changed, 3 insertions(+), 10 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/abi.go b/src/cmd/compile/internal/ssagen/abi.go
index 61d065cea8..ecd6a32eb3 100644
--- a/src/cmd/compile/internal/ssagen/abi.go
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -289,13 +289,6 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 
 	fn.SetABIWrapper(true)
 	fn.SetDupok(true)
-	// Set this as a wrapper so it doesn't appear in tracebacks.
-	// Having both ABIWrapper and Wrapper set suppresses obj's
-	// usual panic+recover handling for wrappers; that's okay
-	// because we're never going to defer a wrapper for a function
-	// that then recovers, so that's would just be unnecessary
-	// code in the ABI wrapper.
-	fn.SetWrapper(true)
 
 	// ABI0-to-ABIInternal wrappers will be mainly loading params from
 	// stack into registers (and/or storing stack locations back to
diff --git a/src/cmd/internal/obj/plist.go b/src/cmd/internal/obj/plist.go
index b2f2bdcaed..9dbad20589 100644
--- a/src/cmd/internal/obj/plist.go
+++ b/src/cmd/internal/obj/plist.go
@@ -136,7 +136,7 @@ func (ctxt *Link) InitTextSym(s *LSym, flag int) {
 		ctxt.Diag("symbol %s listed multiple times", s.Name)
 	}
 	name := strings.Replace(s.Name, "\"\"", ctxt.Pkgpath, -1)
-	s.Func().FuncID = objabi.GetFuncID(name, flag&WRAPPER != 0)
+	s.Func().FuncID = objabi.GetFuncID(name, flag&WRAPPER != 0 || flag&ABIWRAPPER != 0)
 	s.Func().FuncFlag = toFuncFlag(flag)
 	s.Set(AttrOnList, true)
 	s.Set(AttrDuplicateOK, flag&DUPOK != 0)
diff --git a/src/cmd/internal/obj/x86/obj6.go b/src/cmd/internal/obj/x86/obj6.go
index e81e38ad25..b8c7ad7d1b 100644
--- a/src/cmd/internal/obj/x86/obj6.go
+++ b/src/cmd/internal/obj/x86/obj6.go
@@ -645,7 +645,7 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 	}
 
 	var regg int16
-	if !p.From.Sym.NoSplit() || (p.From.Sym.Wrapper() && !p.From.Sym.ABIWrapper()) {
+	if !p.From.Sym.NoSplit() || p.From.Sym.Wrapper() {
 		if ctxt.Arch.Family == sys.AMD64 && objabi.Experiment.RegabiG && cursym.ABI() == obj.ABIInternal {
 			regg = REGG // use the g register directly in ABIInternal
 		} else {
@@ -713,7 +713,7 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 		p.To.Reg = REG_BP
 	}
 
-	if cursym.Func().Text.From.Sym.Wrapper() && !cursym.Func().Text.From.Sym.ABIWrapper() {
+	if cursym.Func().Text.From.Sym.Wrapper() {
 		// if g._panic != nil && g._panic.argp == FP {
 		//   g._panic.argp = bottom-of-frame
 		// }
-- 
GitLab


From 9abedf482752cac0a29c56804f7d34698aa044f2 Mon Sep 17 00:00:00 2001
From: cui <cuiweixie@gmail.com>
Date: Mon, 5 Apr 2021 12:38:12 +0000
Subject: [PATCH 1370/2400] cmd/compile/internal/ssagen: conditon not need

 n.Op() == ir.OFOR so n.Op() != ir.OFORUNTIL is always true

Change-Id: I97191783c1fb31ef76e0601f626b45af1e8d316e
GitHub-Last-Rev: f68f9fecfb7adf37af060afb77d6615839aabc6e
GitHub-Pull-Request: golang/go#45389
Reviewed-on: https://go-review.googlesource.com/c/go/+/307251
Reviewed-by: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Josh Bleecher Snyder <josharian@gmail.com>
---
 src/cmd/compile/internal/ssagen/ssa.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 0a49ca214d..8275d2ec9c 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -1803,7 +1803,7 @@ func (s *state) stmt(n ir.Node) {
 				b.AddEdgeTo(bCond)
 				// It can happen that bIncr ends in a block containing only VARKILL,
 				// and that muddles the debugging experience.
-				if n.Op() != ir.OFORUNTIL && b.Pos == src.NoXPos {
+				if b.Pos == src.NoXPos {
 					b.Pos = bCond.Pos
 				}
 			}
-- 
GitLab


From a040ebeb980d1a712509fa3d8073cf6ae16cbe78 Mon Sep 17 00:00:00 2001
From: KimMachineGun <geon0250@gmail.com>
Date: Sat, 3 Apr 2021 08:10:47 +0000
Subject: [PATCH 1371/2400] all: update references to symbols moved from
 io/ioutil to io

Update references missed in CL 263142.

For #41190

Change-Id: I778760a6a69bd0440fec0848bdef539c9ccb4ee1
GitHub-Last-Rev: dda42b09fff36dc08ec1cdec50cc19e3da5058e5
GitHub-Pull-Request: golang/go#42874
Reviewed-on: https://go-review.googlesource.com/c/go/+/273946
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Cherry Zhang <cherryyz@google.com>
---
 misc/android/go_android_exec.go                 |  5 ++---
 misc/cgo/errors/badsym_test.go                  |  7 +++----
 misc/cgo/errors/errors_test.go                  |  5 ++---
 misc/cgo/errors/ptr_test.go                     |  9 ++++-----
 misc/cgo/life/life_test.go                      |  5 ++---
 misc/cgo/stdio/stdio_test.go                    |  5 ++---
 misc/cgo/test/issue1435.go                      |  6 +++---
 misc/cgo/test/pkg_test.go                       |  5 ++---
 misc/cgo/testcarchive/carchive_test.go          | 11 +++++------
 .../cgo/testcarchive/testdata/libgo6/sigprof.go |  4 ++--
 misc/cgo/testcshared/cshared_test.go            | 17 ++++++++---------
 misc/cgo/testgodefs/testgodefs_test.go          | 11 +++++------
 misc/cgo/testplugin/plugin_test.go              |  9 ++++-----
 misc/cgo/testsanitizers/cc_test.go              |  9 ++++-----
 misc/cgo/testsanitizers/cshared_test.go         |  4 ++--
 misc/cgo/testsanitizers/testdata/tsan9.go       |  4 ++--
 misc/cgo/testshared/shared_test.go              | 13 ++++++-------
 misc/cgo/testso/so_test.go                      |  5 ++---
 misc/cgo/testsovar/so_test.go                   |  5 ++---
 misc/ios/detect.go                              |  3 +--
 misc/ios/go_ios_exec.go                         |  9 ++++-----
 misc/linkcheck/linkcheck.go                     |  4 ++--
 misc/reboot/experiment_toolid_test.go           |  7 +++----
 misc/reboot/reboot_test.go                      |  5 ++---
 src/go/build/build.go                           |  1 +
 src/internal/execabs/execabs_test.go            |  5 ++---
 src/net/http/fs_test.go                         |  3 +--
 src/syscall/exec_windows_test.go                |  3 +--
 src/testing/fstest/testfs.go                    |  3 +--
 test/bench/go1/gob_test.go                      |  4 ++--
 test/bench/go1/gzip_test.go                     |  5 ++---
 test/bench/go1/http_test.go                     |  4 ++--
 test/bench/go1/json_test.go                     |  3 +--
 test/bench/go1/parser_test.go                   |  3 +--
 test/bench/go1/revcomp_test.go                  |  4 ++--
 test/bench/go1/template_test.go                 |  4 ++--
 test/stress/runstress.go                        |  3 +--
 37 files changed, 93 insertions(+), 119 deletions(-)

diff --git a/misc/android/go_android_exec.go b/misc/android/go_android_exec.go
index 7aa7fe56fc..3af2bee583 100644
--- a/misc/android/go_android_exec.go
+++ b/misc/android/go_android_exec.go
@@ -14,7 +14,6 @@ import (
 	"fmt"
 	"go/build"
 	"io"
-	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
@@ -276,7 +275,7 @@ func adbCopyGoroot() error {
 	if err := syscall.Flock(int(stat.Fd()), syscall.LOCK_EX); err != nil {
 		return err
 	}
-	s, err := ioutil.ReadAll(stat)
+	s, err := io.ReadAll(stat)
 	if err != nil {
 		return err
 	}
@@ -294,7 +293,7 @@ func adbCopyGoroot() error {
 	goroot := runtime.GOROOT()
 	// Build go for android.
 	goCmd := filepath.Join(goroot, "bin", "go")
-	tmpGo, err := ioutil.TempFile("", "go_android_exec-cmd-go-*")
+	tmpGo, err := os.CreateTemp("", "go_android_exec-cmd-go-*")
 	if err != nil {
 		return err
 	}
diff --git a/misc/cgo/errors/badsym_test.go b/misc/cgo/errors/badsym_test.go
index b2701bf922..fc687567bf 100644
--- a/misc/cgo/errors/badsym_test.go
+++ b/misc/cgo/errors/badsym_test.go
@@ -6,7 +6,6 @@ package errorstest
 
 import (
 	"bytes"
-	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -55,7 +54,7 @@ func TestBadSymbol(t *testing.T) {
 
 	makeFile := func(mdir, base, source string) string {
 		ret := filepath.Join(mdir, base)
-		if err := ioutil.WriteFile(ret, []byte(source), 0644); err != nil {
+		if err := os.WriteFile(ret, []byte(source), 0644); err != nil {
 			t.Fatal(err)
 		}
 		return ret
@@ -100,7 +99,7 @@ func TestBadSymbol(t *testing.T) {
 	// _cgo_import.go.
 
 	rewrite := func(from, to string) {
-		obj, err := ioutil.ReadFile(from)
+		obj, err := os.ReadFile(from)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -115,7 +114,7 @@ func TestBadSymbol(t *testing.T) {
 
 		obj = bytes.ReplaceAll(obj, []byte(magicInput), []byte(magicReplace))
 
-		if err := ioutil.WriteFile(to, obj, 0644); err != nil {
+		if err := os.WriteFile(to, obj, 0644); err != nil {
 			t.Fatal(err)
 		}
 	}
diff --git a/misc/cgo/errors/errors_test.go b/misc/cgo/errors/errors_test.go
index 1bdf843451..a077b59478 100644
--- a/misc/cgo/errors/errors_test.go
+++ b/misc/cgo/errors/errors_test.go
@@ -7,7 +7,6 @@ package errorstest
 import (
 	"bytes"
 	"fmt"
-	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -25,7 +24,7 @@ func check(t *testing.T, file string) {
 	t.Run(file, func(t *testing.T) {
 		t.Parallel()
 
-		contents, err := ioutil.ReadFile(path(file))
+		contents, err := os.ReadFile(path(file))
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -56,7 +55,7 @@ func check(t *testing.T, file string) {
 }
 
 func expect(t *testing.T, file string, errors []*regexp.Regexp) {
-	dir, err := ioutil.TempDir("", filepath.Base(t.Name()))
+	dir, err := os.MkdirTemp("", filepath.Base(t.Name()))
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/misc/cgo/errors/ptr_test.go b/misc/cgo/errors/ptr_test.go
index 4a46b6023b..0f39dc8e54 100644
--- a/misc/cgo/errors/ptr_test.go
+++ b/misc/cgo/errors/ptr_test.go
@@ -10,7 +10,6 @@ import (
 	"bytes"
 	"flag"
 	"fmt"
-	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -463,7 +462,7 @@ func buildPtrTests(t *testing.T) (dir, exe string) {
 		gopath = *tmp
 		dir = ""
 	} else {
-		d, err := ioutil.TempDir("", filepath.Base(t.Name()))
+		d, err := os.MkdirTemp("", filepath.Base(t.Name()))
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -475,7 +474,7 @@ func buildPtrTests(t *testing.T) (dir, exe string) {
 	if err := os.MkdirAll(src, 0777); err != nil {
 		t.Fatal(err)
 	}
-	if err := ioutil.WriteFile(filepath.Join(src, "go.mod"), []byte("module ptrtest"), 0666); err != nil {
+	if err := os.WriteFile(filepath.Join(src, "go.mod"), []byte("module ptrtest"), 0666); err != nil {
 		t.Fatal(err)
 	}
 
@@ -535,10 +534,10 @@ func buildPtrTests(t *testing.T) (dir, exe string) {
 	fmt.Fprintf(&cgo1, "}\n\n")
 	fmt.Fprintf(&cgo1, "%s\n", ptrTestMain)
 
-	if err := ioutil.WriteFile(filepath.Join(src, "cgo1.go"), cgo1.Bytes(), 0666); err != nil {
+	if err := os.WriteFile(filepath.Join(src, "cgo1.go"), cgo1.Bytes(), 0666); err != nil {
 		t.Fatal(err)
 	}
-	if err := ioutil.WriteFile(filepath.Join(src, "cgo2.go"), cgo2.Bytes(), 0666); err != nil {
+	if err := os.WriteFile(filepath.Join(src, "cgo2.go"), cgo2.Bytes(), 0666); err != nil {
 		t.Fatal(err)
 	}
 
diff --git a/misc/cgo/life/life_test.go b/misc/cgo/life/life_test.go
index 3c95d87d8a..0becb262b4 100644
--- a/misc/cgo/life/life_test.go
+++ b/misc/cgo/life/life_test.go
@@ -6,7 +6,6 @@ package life_test
 
 import (
 	"bytes"
-	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
@@ -21,7 +20,7 @@ func TestMain(m *testing.M) {
 }
 
 func testMain(m *testing.M) int {
-	GOPATH, err := ioutil.TempDir("", "cgolife")
+	GOPATH, err := os.MkdirTemp("", "cgolife")
 	if err != nil {
 		log.Panic(err)
 	}
@@ -38,7 +37,7 @@ func testMain(m *testing.M) int {
 		log.Panic(err)
 	}
 	os.Setenv("PWD", modRoot)
-	if err := ioutil.WriteFile("go.mod", []byte("module cgolife\n"), 0666); err != nil {
+	if err := os.WriteFile("go.mod", []byte("module cgolife\n"), 0666); err != nil {
 		log.Panic(err)
 	}
 
diff --git a/misc/cgo/stdio/stdio_test.go b/misc/cgo/stdio/stdio_test.go
index ab5d328f67..675418f98d 100644
--- a/misc/cgo/stdio/stdio_test.go
+++ b/misc/cgo/stdio/stdio_test.go
@@ -6,7 +6,6 @@ package stdio_test
 
 import (
 	"bytes"
-	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
@@ -21,7 +20,7 @@ func TestMain(m *testing.M) {
 }
 
 func testMain(m *testing.M) int {
-	GOPATH, err := ioutil.TempDir("", "cgostdio")
+	GOPATH, err := os.MkdirTemp("", "cgostdio")
 	if err != nil {
 		log.Panic(err)
 	}
@@ -38,7 +37,7 @@ func testMain(m *testing.M) int {
 		log.Panic(err)
 	}
 	os.Setenv("PWD", modRoot)
-	if err := ioutil.WriteFile("go.mod", []byte("module cgostdio\n"), 0666); err != nil {
+	if err := os.WriteFile("go.mod", []byte("module cgostdio\n"), 0666); err != nil {
 		log.Panic(err)
 	}
 
diff --git a/misc/cgo/test/issue1435.go b/misc/cgo/test/issue1435.go
index a1c7cacde7..cf34ce8db6 100644
--- a/misc/cgo/test/issue1435.go
+++ b/misc/cgo/test/issue1435.go
@@ -8,7 +8,7 @@ package cgotest
 
 import (
 	"fmt"
-	"io/ioutil"
+	"os"
 	"strings"
 	"syscall"
 	"testing"
@@ -64,7 +64,7 @@ import "C"
 func compareStatus(filter, expect string) error {
 	expected := filter + expect
 	pid := syscall.Getpid()
-	fs, err := ioutil.ReadDir(fmt.Sprintf("/proc/%d/task", pid))
+	fs, err := os.ReadDir(fmt.Sprintf("/proc/%d/task", pid))
 	if err != nil {
 		return fmt.Errorf("unable to find %d tasks: %v", pid, err)
 	}
@@ -72,7 +72,7 @@ func compareStatus(filter, expect string) error {
 	foundAThread := false
 	for _, f := range fs {
 		tf := fmt.Sprintf("/proc/%s/status", f.Name())
-		d, err := ioutil.ReadFile(tf)
+		d, err := os.ReadFile(tf)
 		if err != nil {
 			// There are a surprising number of ways this
 			// can error out on linux.  We've seen all of
diff --git a/misc/cgo/test/pkg_test.go b/misc/cgo/test/pkg_test.go
index 94abaa03e8..14013a4cd9 100644
--- a/misc/cgo/test/pkg_test.go
+++ b/misc/cgo/test/pkg_test.go
@@ -5,7 +5,6 @@
 package cgotest
 
 import (
-	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -37,7 +36,7 @@ func TestCrossPackageTests(t *testing.T) {
 		}
 	}
 
-	GOPATH, err := ioutil.TempDir("", "cgotest")
+	GOPATH, err := os.MkdirTemp("", "cgotest")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -47,7 +46,7 @@ func TestCrossPackageTests(t *testing.T) {
 	if err := overlayDir(modRoot, "testdata"); err != nil {
 		t.Fatal(err)
 	}
-	if err := ioutil.WriteFile(filepath.Join(modRoot, "go.mod"), []byte("module cgotest\n"), 0666); err != nil {
+	if err := os.WriteFile(filepath.Join(modRoot, "go.mod"), []byte("module cgotest\n"), 0666); err != nil {
 		t.Fatal(err)
 	}
 
diff --git a/misc/cgo/testcarchive/carchive_test.go b/misc/cgo/testcarchive/carchive_test.go
index 6a5adf79ca..ec717c4f8b 100644
--- a/misc/cgo/testcarchive/carchive_test.go
+++ b/misc/cgo/testcarchive/carchive_test.go
@@ -10,7 +10,6 @@ import (
 	"debug/elf"
 	"flag"
 	"fmt"
-	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
@@ -53,7 +52,7 @@ func testMain(m *testing.M) int {
 	// We need a writable GOPATH in which to run the tests.
 	// Construct one in a temporary directory.
 	var err error
-	GOPATH, err = ioutil.TempDir("", "carchive_test")
+	GOPATH, err = os.MkdirTemp("", "carchive_test")
 	if err != nil {
 		log.Panic(err)
 	}
@@ -74,7 +73,7 @@ func testMain(m *testing.M) int {
 		log.Panic(err)
 	}
 	os.Setenv("PWD", modRoot)
-	if err := ioutil.WriteFile("go.mod", []byte("module testcarchive\n"), 0666); err != nil {
+	if err := os.WriteFile("go.mod", []byte("module testcarchive\n"), 0666); err != nil {
 		log.Panic(err)
 	}
 
@@ -176,7 +175,7 @@ func genHeader(t *testing.T, header, dir string) {
 	// The 'cgo' command generates a number of additional artifacts,
 	// but we're only interested in the header.
 	// Shunt the rest of the outputs to a temporary directory.
-	objDir, err := ioutil.TempDir(GOPATH, "_obj")
+	objDir, err := os.MkdirTemp(GOPATH, "_obj")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -252,7 +251,7 @@ var badLineRegexp = regexp.MustCompile(`(?m)^#line [0-9]+ "/.*$`)
 // the user and make the files change based on details of the location
 // of GOPATH.
 func checkLineComments(t *testing.T, hdrname string) {
-	hdr, err := ioutil.ReadFile(hdrname)
+	hdr, err := os.ReadFile(hdrname)
 	if err != nil {
 		if !os.IsNotExist(err) {
 			t.Error(err)
@@ -618,7 +617,7 @@ func TestExtar(t *testing.T) {
 		t.Fatal(err)
 	}
 	s := strings.Replace(testar, "PWD", dir, 1)
-	if err := ioutil.WriteFile("testar", []byte(s), 0777); err != nil {
+	if err := os.WriteFile("testar", []byte(s), 0777); err != nil {
 		t.Fatal(err)
 	}
 
diff --git a/misc/cgo/testcarchive/testdata/libgo6/sigprof.go b/misc/cgo/testcarchive/testdata/libgo6/sigprof.go
index 4cb05dc617..31527c59af 100644
--- a/misc/cgo/testcarchive/testdata/libgo6/sigprof.go
+++ b/misc/cgo/testcarchive/testdata/libgo6/sigprof.go
@@ -5,7 +5,7 @@
 package main
 
 import (
-	"io/ioutil"
+	"io"
 	"runtime/pprof"
 )
 
@@ -13,7 +13,7 @@ import "C"
 
 //export go_start_profile
 func go_start_profile() {
-	pprof.StartCPUProfile(ioutil.Discard)
+	pprof.StartCPUProfile(io.Discard)
 }
 
 //export go_stop_profile
diff --git a/misc/cgo/testcshared/cshared_test.go b/misc/cgo/testcshared/cshared_test.go
index 3a4886cf30..90d8c365e6 100644
--- a/misc/cgo/testcshared/cshared_test.go
+++ b/misc/cgo/testcshared/cshared_test.go
@@ -11,7 +11,6 @@ import (
 	"encoding/binary"
 	"flag"
 	"fmt"
-	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
@@ -125,7 +124,7 @@ func testMain(m *testing.M) int {
 	// Copy testdata into GOPATH/src/testcshared, along with a go.mod file
 	// declaring the same path.
 
-	GOPATH, err := ioutil.TempDir("", "cshared_test")
+	GOPATH, err := os.MkdirTemp("", "cshared_test")
 	if err != nil {
 		log.Panic(err)
 	}
@@ -140,7 +139,7 @@ func testMain(m *testing.M) int {
 		log.Panic(err)
 	}
 	os.Setenv("PWD", modRoot)
-	if err := ioutil.WriteFile("go.mod", []byte("module testcshared\n"), 0666); err != nil {
+	if err := os.WriteFile("go.mod", []byte("module testcshared\n"), 0666); err != nil {
 		log.Panic(err)
 	}
 
@@ -260,7 +259,7 @@ func createHeaders() error {
 	// The 'cgo' command generates a number of additional artifacts,
 	// but we're only interested in the header.
 	// Shunt the rest of the outputs to a temporary directory.
-	objDir, err := ioutil.TempDir("", "testcshared_obj")
+	objDir, err := os.MkdirTemp("", "testcshared_obj")
 	if err != nil {
 		return err
 	}
@@ -381,7 +380,7 @@ func main() {
 
 	srcfile := filepath.Join(tmpdir, "test.go")
 	objfile := filepath.Join(tmpdir, "test.dll")
-	if err := ioutil.WriteFile(srcfile, []byte(prog), 0666); err != nil {
+	if err := os.WriteFile(srcfile, []byte(prog), 0666); err != nil {
 		t.Fatal(err)
 	}
 	argv := []string{"build", "-buildmode=c-shared"}
@@ -643,7 +642,7 @@ func TestPIE(t *testing.T) {
 
 // Test that installing a second time recreates the header file.
 func TestCachedInstall(t *testing.T) {
-	tmpdir, err := ioutil.TempDir("", "cshared")
+	tmpdir, err := os.MkdirTemp("", "cshared")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -719,14 +718,14 @@ func TestCachedInstall(t *testing.T) {
 // copyFile copies src to dst.
 func copyFile(t *testing.T, dst, src string) {
 	t.Helper()
-	data, err := ioutil.ReadFile(src)
+	data, err := os.ReadFile(src)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if err := os.MkdirAll(filepath.Dir(dst), 0777); err != nil {
 		t.Fatal(err)
 	}
-	if err := ioutil.WriteFile(dst, data, 0666); err != nil {
+	if err := os.WriteFile(dst, data, 0666); err != nil {
 		t.Fatal(err)
 	}
 }
@@ -743,7 +742,7 @@ func TestGo2C2Go(t *testing.T) {
 
 	t.Parallel()
 
-	tmpdir, err := ioutil.TempDir("", "cshared-TestGo2C2Go")
+	tmpdir, err := os.MkdirTemp("", "cshared-TestGo2C2Go")
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/misc/cgo/testgodefs/testgodefs_test.go b/misc/cgo/testgodefs/testgodefs_test.go
index 4c2312c1c8..aae3404360 100644
--- a/misc/cgo/testgodefs/testgodefs_test.go
+++ b/misc/cgo/testgodefs/testgodefs_test.go
@@ -6,7 +6,6 @@ package testgodefs
 
 import (
 	"bytes"
-	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -34,7 +33,7 @@ func TestGoDefs(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	gopath, err := ioutil.TempDir("", "testgodefs-gopath")
+	gopath, err := os.MkdirTemp("", "testgodefs-gopath")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -58,20 +57,20 @@ func TestGoDefs(t *testing.T) {
 			t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, cmd.Stderr)
 		}
 
-		if err := ioutil.WriteFile(filepath.Join(dir, fp+"_defs.go"), out, 0644); err != nil {
+		if err := os.WriteFile(filepath.Join(dir, fp+"_defs.go"), out, 0644); err != nil {
 			t.Fatal(err)
 		}
 	}
 
-	main, err := ioutil.ReadFile(filepath.Join("testdata", "main.go"))
+	main, err := os.ReadFile(filepath.Join("testdata", "main.go"))
 	if err != nil {
 		t.Fatal(err)
 	}
-	if err := ioutil.WriteFile(filepath.Join(dir, "main.go"), main, 0644); err != nil {
+	if err := os.WriteFile(filepath.Join(dir, "main.go"), main, 0644); err != nil {
 		t.Fatal(err)
 	}
 
-	if err := ioutil.WriteFile(filepath.Join(dir, "go.mod"), []byte("module testgodefs\ngo 1.14\n"), 0644); err != nil {
+	if err := os.WriteFile(filepath.Join(dir, "go.mod"), []byte("module testgodefs\ngo 1.14\n"), 0644); err != nil {
 		t.Fatal(err)
 	}
 
diff --git a/misc/cgo/testplugin/plugin_test.go b/misc/cgo/testplugin/plugin_test.go
index 8869528015..b894e8d30d 100644
--- a/misc/cgo/testplugin/plugin_test.go
+++ b/misc/cgo/testplugin/plugin_test.go
@@ -9,7 +9,6 @@ import (
 	"context"
 	"flag"
 	"fmt"
-	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
@@ -35,7 +34,7 @@ func testMain(m *testing.M) int {
 	// Copy testdata into GOPATH/src/testplugin, along with a go.mod file
 	// declaring the same path.
 
-	GOPATH, err := ioutil.TempDir("", "plugin_test")
+	GOPATH, err := os.MkdirTemp("", "plugin_test")
 	if err != nil {
 		log.Panic(err)
 	}
@@ -50,7 +49,7 @@ func testMain(m *testing.M) int {
 		if err := overlayDir(dstRoot, srcRoot); err != nil {
 			log.Panic(err)
 		}
-		if err := ioutil.WriteFile(filepath.Join(dstRoot, "go.mod"), []byte("module testplugin\n"), 0666); err != nil {
+		if err := os.WriteFile(filepath.Join(dstRoot, "go.mod"), []byte("module testplugin\n"), 0666); err != nil {
 			log.Panic(err)
 		}
 	}
@@ -72,11 +71,11 @@ func testMain(m *testing.M) int {
 
 	goCmd(nil, "build", "-buildmode=plugin", "./plugin1")
 	goCmd(nil, "build", "-buildmode=plugin", "./plugin2")
-	so, err := ioutil.ReadFile("plugin2.so")
+	so, err := os.ReadFile("plugin2.so")
 	if err != nil {
 		log.Panic(err)
 	}
-	if err := ioutil.WriteFile("plugin2-dup.so", so, 0444); err != nil {
+	if err := os.WriteFile("plugin2-dup.so", so, 0444); err != nil {
 		log.Panic(err)
 	}
 
diff --git a/misc/cgo/testsanitizers/cc_test.go b/misc/cgo/testsanitizers/cc_test.go
index dab13364b8..384b6250e1 100644
--- a/misc/cgo/testsanitizers/cc_test.go
+++ b/misc/cgo/testsanitizers/cc_test.go
@@ -11,7 +11,6 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -36,7 +35,7 @@ func requireOvercommit(t *testing.T) {
 
 	overcommit.Once.Do(func() {
 		var out []byte
-		out, overcommit.err = ioutil.ReadFile("/proc/sys/vm/overcommit_memory")
+		out, overcommit.err = os.ReadFile("/proc/sys/vm/overcommit_memory")
 		if overcommit.err != nil {
 			return
 		}
@@ -313,14 +312,14 @@ int main() {
 `)
 
 func (c *config) checkCSanitizer() (skip bool, err error) {
-	dir, err := ioutil.TempDir("", c.sanitizer)
+	dir, err := os.MkdirTemp("", c.sanitizer)
 	if err != nil {
 		return false, fmt.Errorf("failed to create temp directory: %v", err)
 	}
 	defer os.RemoveAll(dir)
 
 	src := filepath.Join(dir, "return0.c")
-	if err := ioutil.WriteFile(src, cMain, 0600); err != nil {
+	if err := os.WriteFile(src, cMain, 0600); err != nil {
 		return false, fmt.Errorf("failed to write C source file: %v", err)
 	}
 
@@ -418,7 +417,7 @@ func (d *tempDir) Join(name string) string {
 
 func newTempDir(t *testing.T) *tempDir {
 	t.Helper()
-	dir, err := ioutil.TempDir("", filepath.Dir(t.Name()))
+	dir, err := os.MkdirTemp("", filepath.Dir(t.Name()))
 	if err != nil {
 		t.Fatalf("Failed to create temp dir: %v", err)
 	}
diff --git a/misc/cgo/testsanitizers/cshared_test.go b/misc/cgo/testsanitizers/cshared_test.go
index b98360c4ae..8fd03715a1 100644
--- a/misc/cgo/testsanitizers/cshared_test.go
+++ b/misc/cgo/testsanitizers/cshared_test.go
@@ -6,7 +6,7 @@ package sanitizers_test
 
 import (
 	"fmt"
-	"io/ioutil"
+	"os"
 	"strings"
 	"testing"
 )
@@ -64,7 +64,7 @@ func TestShared(t *testing.T) {
 			mustRun(t, config.goCmd("build", "-buildmode=c-shared", "-o", lib, srcPath(tc.src)))
 
 			cSrc := dir.Join("main.c")
-			if err := ioutil.WriteFile(cSrc, cMain, 0600); err != nil {
+			if err := os.WriteFile(cSrc, cMain, 0600); err != nil {
 				t.Fatalf("failed to write C source file: %v", err)
 			}
 
diff --git a/misc/cgo/testsanitizers/testdata/tsan9.go b/misc/cgo/testsanitizers/testdata/tsan9.go
index f166d8b495..06304be751 100644
--- a/misc/cgo/testsanitizers/testdata/tsan9.go
+++ b/misc/cgo/testsanitizers/testdata/tsan9.go
@@ -44,7 +44,7 @@ void spin() {
 import "C"
 
 import (
-	"io/ioutil"
+	"io"
 	"runtime/pprof"
 	"time"
 )
@@ -60,7 +60,7 @@ func goSpin() {
 }
 
 func main() {
-	pprof.StartCPUProfile(ioutil.Discard)
+	pprof.StartCPUProfile(io.Discard)
 	go C.spin()
 	goSpin()
 	pprof.StopCPUProfile()
diff --git a/misc/cgo/testshared/shared_test.go b/misc/cgo/testshared/shared_test.go
index f52391c6f6..e77f848915 100644
--- a/misc/cgo/testshared/shared_test.go
+++ b/misc/cgo/testshared/shared_test.go
@@ -13,7 +13,6 @@ import (
 	"fmt"
 	"go/build"
 	"io"
-	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
@@ -90,7 +89,7 @@ func goCmd(t *testing.T, args ...string) string {
 
 // TestMain calls testMain so that the latter can use defer (TestMain exits with os.Exit).
 func testMain(m *testing.M) (int, error) {
-	workDir, err := ioutil.TempDir("", "shared_test")
+	workDir, err := os.MkdirTemp("", "shared_test")
 	if err != nil {
 		return 0, err
 	}
@@ -177,7 +176,7 @@ func cloneTestdataModule(gopath string) (string, error) {
 	if err := overlayDir(modRoot, "testdata"); err != nil {
 		return "", err
 	}
-	if err := ioutil.WriteFile(filepath.Join(modRoot, "go.mod"), []byte("module testshared\n"), 0644); err != nil {
+	if err := os.WriteFile(filepath.Join(modRoot, "go.mod"), []byte("module testshared\n"), 0644); err != nil {
 		return "", err
 	}
 	return modRoot, nil
@@ -318,7 +317,7 @@ func TestShlibnameFiles(t *testing.T) {
 	}
 	for _, pkg := range pkgs {
 		shlibnamefile := filepath.Join(gorootInstallDir, pkg+".shlibname")
-		contentsb, err := ioutil.ReadFile(shlibnamefile)
+		contentsb, err := os.ReadFile(shlibnamefile)
 		if err != nil {
 			t.Errorf("error reading shlibnamefile for %s: %v", pkg, err)
 			continue
@@ -791,7 +790,7 @@ func resetFileStamps() {
 // It also sets the time of the file, so that we can see if it is rewritten.
 func touch(t *testing.T, path string) (cleanup func()) {
 	t.Helper()
-	data, err := ioutil.ReadFile(path)
+	data, err := os.ReadFile(path)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -837,14 +836,14 @@ func touch(t *testing.T, path string) (cleanup func()) {
 	// user-writable.
 	perm := fi.Mode().Perm() | 0200
 
-	if err := ioutil.WriteFile(path, data, perm); err != nil {
+	if err := os.WriteFile(path, data, perm); err != nil {
 		t.Fatal(err)
 	}
 	if err := os.Chtimes(path, nearlyNew, nearlyNew); err != nil {
 		t.Fatal(err)
 	}
 	return func() {
-		if err := ioutil.WriteFile(path, old, perm); err != nil {
+		if err := os.WriteFile(path, old, perm); err != nil {
 			t.Fatal(err)
 		}
 	}
diff --git a/misc/cgo/testso/so_test.go b/misc/cgo/testso/so_test.go
index 57f0fd34f7..1c97ae9bcb 100644
--- a/misc/cgo/testso/so_test.go
+++ b/misc/cgo/testso/so_test.go
@@ -7,7 +7,6 @@
 package so_test
 
 import (
-	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
@@ -37,7 +36,7 @@ func requireTestSOSupported(t *testing.T) {
 func TestSO(t *testing.T) {
 	requireTestSOSupported(t)
 
-	GOPATH, err := ioutil.TempDir("", "cgosotest")
+	GOPATH, err := os.MkdirTemp("", "cgosotest")
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -47,7 +46,7 @@ func TestSO(t *testing.T) {
 	if err := overlayDir(modRoot, "testdata"); err != nil {
 		log.Panic(err)
 	}
-	if err := ioutil.WriteFile(filepath.Join(modRoot, "go.mod"), []byte("module cgosotest\n"), 0666); err != nil {
+	if err := os.WriteFile(filepath.Join(modRoot, "go.mod"), []byte("module cgosotest\n"), 0666); err != nil {
 		log.Panic(err)
 	}
 
diff --git a/misc/cgo/testsovar/so_test.go b/misc/cgo/testsovar/so_test.go
index 57f0fd34f7..1c97ae9bcb 100644
--- a/misc/cgo/testsovar/so_test.go
+++ b/misc/cgo/testsovar/so_test.go
@@ -7,7 +7,6 @@
 package so_test
 
 import (
-	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
@@ -37,7 +36,7 @@ func requireTestSOSupported(t *testing.T) {
 func TestSO(t *testing.T) {
 	requireTestSOSupported(t)
 
-	GOPATH, err := ioutil.TempDir("", "cgosotest")
+	GOPATH, err := os.MkdirTemp("", "cgosotest")
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -47,7 +46,7 @@ func TestSO(t *testing.T) {
 	if err := overlayDir(modRoot, "testdata"); err != nil {
 		log.Panic(err)
 	}
-	if err := ioutil.WriteFile(filepath.Join(modRoot, "go.mod"), []byte("module cgosotest\n"), 0666); err != nil {
+	if err := os.WriteFile(filepath.Join(modRoot, "go.mod"), []byte("module cgosotest\n"), 0666); err != nil {
 		log.Panic(err)
 	}
 
diff --git a/misc/ios/detect.go b/misc/ios/detect.go
index d32bcc3202..cde5723892 100644
--- a/misc/ios/detect.go
+++ b/misc/ios/detect.go
@@ -16,7 +16,6 @@ import (
 	"bytes"
 	"crypto/x509"
 	"fmt"
-	"io/ioutil"
 	"os"
 	"os/exec"
 	"strings"
@@ -38,7 +37,7 @@ func main() {
 	fmt.Println("# will be overwritten when running Go programs.")
 	for _, mp := range mps {
 		fmt.Println()
-		f, err := ioutil.TempFile("", "go_ios_detect_")
+		f, err := os.CreateTemp("", "go_ios_detect_")
 		check(err)
 		fname := f.Name()
 		defer os.Remove(fname)
diff --git a/misc/ios/go_ios_exec.go b/misc/ios/go_ios_exec.go
index 0acf1b259c..9e63717d92 100644
--- a/misc/ios/go_ios_exec.go
+++ b/misc/ios/go_ios_exec.go
@@ -26,7 +26,6 @@ import (
 	"fmt"
 	"go/build"
 	"io"
-	"io/ioutil"
 	"log"
 	"net"
 	"os"
@@ -79,7 +78,7 @@ func main() {
 
 func runMain() (int, error) {
 	var err error
-	tmpdir, err = ioutil.TempDir("", "go_ios_exec_")
+	tmpdir, err = os.MkdirTemp("", "go_ios_exec_")
 	if err != nil {
 		return 1, err
 	}
@@ -205,13 +204,13 @@ func assembleApp(appdir, bin string) error {
 	}
 
 	entitlementsPath := filepath.Join(tmpdir, "Entitlements.plist")
-	if err := ioutil.WriteFile(entitlementsPath, []byte(entitlementsPlist()), 0744); err != nil {
+	if err := os.WriteFile(entitlementsPath, []byte(entitlementsPlist()), 0744); err != nil {
 		return err
 	}
-	if err := ioutil.WriteFile(filepath.Join(appdir, "Info.plist"), []byte(infoPlist(pkgpath)), 0744); err != nil {
+	if err := os.WriteFile(filepath.Join(appdir, "Info.plist"), []byte(infoPlist(pkgpath)), 0744); err != nil {
 		return err
 	}
-	if err := ioutil.WriteFile(filepath.Join(appdir, "ResourceRules.plist"), []byte(resourceRules), 0744); err != nil {
+	if err := os.WriteFile(filepath.Join(appdir, "ResourceRules.plist"), []byte(resourceRules), 0744); err != nil {
 		return err
 	}
 	return nil
diff --git a/misc/linkcheck/linkcheck.go b/misc/linkcheck/linkcheck.go
index d9bfd2f767..570b430da4 100644
--- a/misc/linkcheck/linkcheck.go
+++ b/misc/linkcheck/linkcheck.go
@@ -11,7 +11,7 @@ import (
 	"errors"
 	"flag"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"log"
 	"net/http"
 	"os"
@@ -144,7 +144,7 @@ func doCrawl(url string) error {
 	if res.StatusCode != 200 {
 		return errors.New(res.Status)
 	}
-	slurp, err := ioutil.ReadAll(res.Body)
+	slurp, err := io.ReadAll(res.Body)
 	res.Body.Close()
 	if err != nil {
 		log.Fatalf("Error reading %s body: %v", url, err)
diff --git a/misc/reboot/experiment_toolid_test.go b/misc/reboot/experiment_toolid_test.go
index eabf06b19e..4f40284d80 100644
--- a/misc/reboot/experiment_toolid_test.go
+++ b/misc/reboot/experiment_toolid_test.go
@@ -13,7 +13,6 @@ package reboot_test
 
 import (
 	"bytes"
-	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -23,7 +22,7 @@ import (
 
 func TestExperimentToolID(t *testing.T) {
 	// Set up GOROOT
-	goroot, err := ioutil.TempDir("", "experiment-goroot")
+	goroot, err := os.MkdirTemp("", "experiment-goroot")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -34,13 +33,13 @@ func TestExperimentToolID(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if err := ioutil.WriteFile(filepath.Join(goroot, "VERSION"), []byte("go1.999"), 0666); err != nil {
+	if err := os.WriteFile(filepath.Join(goroot, "VERSION"), []byte("go1.999"), 0666); err != nil {
 		t.Fatal(err)
 	}
 	env := append(os.Environ(), "GOROOT=", "GOROOT_BOOTSTRAP="+runtime.GOROOT())
 
 	// Use a clean cache.
-	gocache, err := ioutil.TempDir("", "experiment-gocache")
+	gocache, err := os.MkdirTemp("", "experiment-gocache")
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/misc/reboot/reboot_test.go b/misc/reboot/reboot_test.go
index 717c0fb709..6bafc608b5 100644
--- a/misc/reboot/reboot_test.go
+++ b/misc/reboot/reboot_test.go
@@ -7,7 +7,6 @@
 package reboot_test
 
 import (
-	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -16,7 +15,7 @@ import (
 )
 
 func TestRepeatBootstrap(t *testing.T) {
-	goroot, err := ioutil.TempDir("", "reboot-goroot")
+	goroot, err := os.MkdirTemp("", "reboot-goroot")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -27,7 +26,7 @@ func TestRepeatBootstrap(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if err := ioutil.WriteFile(filepath.Join(goroot, "VERSION"), []byte(runtime.Version()), 0666); err != nil {
+	if err := os.WriteFile(filepath.Join(goroot, "VERSION"), []byte(runtime.Version()), 0666); err != nil {
 		t.Fatal(err)
 	}
 
diff --git a/src/go/build/build.go b/src/go/build/build.go
index 0732f6aa19..501ce2e8dd 100644
--- a/src/go/build/build.go
+++ b/src/go/build/build.go
@@ -188,6 +188,7 @@ func (ctxt *Context) readDir(path string) ([]fs.FileInfo, error) {
 	if f := ctxt.ReadDir; f != nil {
 		return f(path)
 	}
+	// TODO: use os.ReadDir
 	return ioutil.ReadDir(path)
 }
 
diff --git a/src/internal/execabs/execabs_test.go b/src/internal/execabs/execabs_test.go
index b71458587c..7609b2106a 100644
--- a/src/internal/execabs/execabs_test.go
+++ b/src/internal/execabs/execabs_test.go
@@ -8,7 +8,6 @@ import (
 	"context"
 	"fmt"
 	"internal/testenv"
-	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -42,7 +41,7 @@ func TestCommand(t *testing.T) {
 		if runtime.GOOS == "windows" {
 			executable += ".exe"
 		}
-		if err := ioutil.WriteFile(filepath.Join(tmpDir, executable), []byte{1, 2, 3}, 0111); err != nil {
+		if err := os.WriteFile(filepath.Join(tmpDir, executable), []byte{1, 2, 3}, 0111); err != nil {
 			t.Fatalf("ioutil.WriteFile failed: %s", err)
 		}
 		cwd, err := os.Getwd()
@@ -77,7 +76,7 @@ func TestLookPath(t *testing.T) {
 	if runtime.GOOS == "windows" {
 		executable += ".exe"
 	}
-	if err := ioutil.WriteFile(filepath.Join(tmpDir, executable), []byte{1, 2, 3}, 0111); err != nil {
+	if err := os.WriteFile(filepath.Join(tmpDir, executable), []byte{1, 2, 3}, 0111); err != nil {
 		t.Fatalf("ioutil.WriteFile failed: %s", err)
 	}
 	cwd, err := os.Getwd()
diff --git a/src/net/http/fs_test.go b/src/net/http/fs_test.go
index 2499051625..0ebb511b5c 100644
--- a/src/net/http/fs_test.go
+++ b/src/net/http/fs_test.go
@@ -11,7 +11,6 @@ import (
 	"fmt"
 	"io"
 	"io/fs"
-	"io/ioutil"
 	"mime"
 	"mime/multipart"
 	"net"
@@ -593,7 +592,7 @@ func TestServeIndexHtml(t *testing.T) {
 				if err != nil {
 					t.Fatal(err)
 				}
-				b, err := ioutil.ReadAll(res.Body)
+				b, err := io.ReadAll(res.Body)
 				if err != nil {
 					t.Fatal("reading Body:", err)
 				}
diff --git a/src/syscall/exec_windows_test.go b/src/syscall/exec_windows_test.go
index aeafb564b3..8b8f330e99 100644
--- a/src/syscall/exec_windows_test.go
+++ b/src/syscall/exec_windows_test.go
@@ -6,7 +6,6 @@ package syscall_test
 
 import (
 	"fmt"
-	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -106,7 +105,7 @@ func TestChangingProcessParent(t *testing.T) {
 	if err != nil {
 		t.Errorf("child failed: %v: %v", err, string(childOutput))
 	}
-	childOutput, err = ioutil.ReadFile(childDumpPath)
+	childOutput, err = os.ReadFile(childDumpPath)
 	if err != nil {
 		t.Fatalf("reading child output failed: %v", err)
 	}
diff --git a/src/testing/fstest/testfs.go b/src/testing/fstest/testfs.go
index e0ad60a17b..80ca0e9a1d 100644
--- a/src/testing/fstest/testfs.go
+++ b/src/testing/fstest/testfs.go
@@ -10,7 +10,6 @@ import (
 	"fmt"
 	"io"
 	"io/fs"
-	"io/ioutil"
 	"path"
 	"reflect"
 	"sort"
@@ -514,7 +513,7 @@ func (t *fsTester) checkFile(file string) {
 		return
 	}
 
-	data, err := ioutil.ReadAll(f)
+	data, err := io.ReadAll(f)
 	if err != nil {
 		f.Close()
 		t.errorf("%s: Open+ReadAll: %v", file, err)
diff --git a/test/bench/go1/gob_test.go b/test/bench/go1/gob_test.go
index 224beff680..f289fcca7c 100644
--- a/test/bench/go1/gob_test.go
+++ b/test/bench/go1/gob_test.go
@@ -10,7 +10,7 @@ import (
 	"bytes"
 	"encoding/gob"
 	"encoding/json"
-	"io/ioutil"
+	"io"
 	"log"
 	"reflect"
 	"testing"
@@ -73,7 +73,7 @@ func gobdec() {
 }
 
 func gobenc() {
-	if err := gob.NewEncoder(ioutil.Discard).Encode(&gobdata); err != nil {
+	if err := gob.NewEncoder(io.Discard).Encode(&gobdata); err != nil {
 		panic(err)
 	}
 }
diff --git a/test/bench/go1/gzip_test.go b/test/bench/go1/gzip_test.go
index 648eec5d45..d3f98da11d 100644
--- a/test/bench/go1/gzip_test.go
+++ b/test/bench/go1/gzip_test.go
@@ -10,7 +10,6 @@ import (
 	"bytes"
 	gz "compress/gzip"
 	"io"
-	"io/ioutil"
 	"testing"
 )
 
@@ -28,7 +27,7 @@ func init() {
 }
 
 func gzip() {
-	c := gz.NewWriter(ioutil.Discard)
+	c := gz.NewWriter(io.Discard)
 	if _, err := c.Write(jsongunz); err != nil {
 		panic(err)
 	}
@@ -42,7 +41,7 @@ func gunzip() {
 	if err != nil {
 		panic(err)
 	}
-	if _, err := io.Copy(ioutil.Discard, r); err != nil {
+	if _, err := io.Copy(io.Discard, r); err != nil {
 		panic(err)
 	}
 	r.Close()
diff --git a/test/bench/go1/http_test.go b/test/bench/go1/http_test.go
index 7ece9b2ac5..08583d635d 100644
--- a/test/bench/go1/http_test.go
+++ b/test/bench/go1/http_test.go
@@ -6,7 +6,7 @@ package go1
 
 import (
 	"bytes"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -34,7 +34,7 @@ func BenchmarkHTTPClientServer(b *testing.B) {
 		if err != nil {
 			b.Fatal("Get:", err)
 		}
-		all, err := ioutil.ReadAll(res.Body)
+		all, err := io.ReadAll(res.Body)
 		if err != nil {
 			b.Fatal("ReadAll:", err)
 		}
diff --git a/test/bench/go1/json_test.go b/test/bench/go1/json_test.go
index 5ff1f8b650..782ef7674c 100644
--- a/test/bench/go1/json_test.go
+++ b/test/bench/go1/json_test.go
@@ -12,7 +12,6 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"io"
-	"io/ioutil"
 	"testing"
 )
 
@@ -26,7 +25,7 @@ func makeJsonBytes() []byte {
 	r = bytes.NewReader(bytes.Replace(jsonbz2_base64, []byte{'\n'}, nil, -1))
 	r = base64.NewDecoder(base64.StdEncoding, r)
 	r = bzip2.NewReader(r)
-	b, err := ioutil.ReadAll(r)
+	b, err := io.ReadAll(r)
 	if err != nil {
 		panic(err)
 	}
diff --git a/test/bench/go1/parser_test.go b/test/bench/go1/parser_test.go
index 7848cadd22..8b7baa3479 100644
--- a/test/bench/go1/parser_test.go
+++ b/test/bench/go1/parser_test.go
@@ -12,7 +12,6 @@ import (
 	"go/parser"
 	"go/token"
 	"io"
-	"io/ioutil"
 	"strings"
 	"testing"
 )
@@ -26,7 +25,7 @@ func makeParserBytes() []byte {
 	r = strings.NewReader(parserbz2_base64)
 	r = base64.NewDecoder(base64.StdEncoding, r)
 	r = bzip2.NewReader(r)
-	b, err := ioutil.ReadAll(r)
+	b, err := io.ReadAll(r)
 	if err != nil {
 		panic(err)
 	}
diff --git a/test/bench/go1/revcomp_test.go b/test/bench/go1/revcomp_test.go
index 7d57bd607b..c2e2c39baf 100644
--- a/test/bench/go1/revcomp_test.go
+++ b/test/bench/go1/revcomp_test.go
@@ -10,7 +10,7 @@ package go1
 import (
 	"bufio"
 	"bytes"
-	"io/ioutil"
+	"io"
 	"testing"
 )
 
@@ -35,7 +35,7 @@ var revCompTable = [256]uint8{
 
 func revcomp(data []byte) {
 	in := bufio.NewReader(bytes.NewBuffer(data))
-	out := ioutil.Discard
+	out := io.Discard
 	buf := make([]byte, 1024*1024)
 	line, err := in.ReadSlice('\n')
 	for err == nil {
diff --git a/test/bench/go1/template_test.go b/test/bench/go1/template_test.go
index 10dacaa35f..b7e98d5c20 100644
--- a/test/bench/go1/template_test.go
+++ b/test/bench/go1/template_test.go
@@ -9,7 +9,7 @@ package go1
 
 import (
 	"bytes"
-	"io/ioutil"
+	"io"
 	"strings"
 	"testing"
 	"text/template"
@@ -63,7 +63,7 @@ func init() {
 }
 
 func tmplexec() {
-	if err := tmpl.Execute(ioutil.Discard, &jsondata); err != nil {
+	if err := tmpl.Execute(io.Discard, &jsondata); err != nil {
 		panic(err)
 	}
 }
diff --git a/test/stress/runstress.go b/test/stress/runstress.go
index 3f16fc9fb3..b752fa8dbb 100644
--- a/test/stress/runstress.go
+++ b/test/stress/runstress.go
@@ -12,7 +12,6 @@ import (
 	"flag"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"log"
 	"math/rand"
 	"net"
@@ -70,7 +69,7 @@ func stressNet() {
 		if res.StatusCode != 200 {
 			log.Fatalf("stressNet: Status code = %d", res.StatusCode)
 		}
-		n, err := io.Copy(ioutil.Discard, res.Body)
+		n, err := io.Copy(io.Discard, res.Body)
 		if err != nil {
 			log.Fatalf("stressNet: io.Copy: %v", err)
 		}
-- 
GitLab


From cf148f3d468f4d0648e7fc6d2858d2afdc37f70d Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Sat, 3 Apr 2021 20:49:03 -0400
Subject: [PATCH 1372/2400] cmd/compile, runtime: use ABI-aware function
 converting float to interface

Currently, when converting a float (say float64), we use convT64
function. In the runtime convT64 expects a uint64 argument. In
the compiler, convT64 is defined as taking an "any" argument (so
it works with also uint64-like types such as [1]uint64). The "any"
type is instantiated with the concrete type in walk. So the
backend will see instances such as convT64([1]uint64).

Currently, float64 is treated as uint64-like. So the backend will
see convT64(float64). With a memory-based calling convention this
is fine. With a register-based calling convention, however, it
will pass the argument in a floating point register, whereas the
runtime expects the argument in an integer register (as it is
declared as uint64).

To fix this, this CL introduces runtime functions convT32F and
convT64F. They behave the same as convT32/convT64, but with a
float argument. In the compiler, use convT32F/convT64F to convert
float-like type to interface.

With this, "GOEXPERIMENT=regabi,regabiargs go test math fmt"
works.

Updates #40724.

Change-Id: I8b2e232096a95e4a7c4ab81795d77ef224ffaab3
Reviewed-on: https://go-review.googlesource.com/c/go/+/307232
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Austin Clements <austin@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/typecheck/builtin.go |  2 ++
 .../internal/typecheck/builtin/runtime.go     |  2 ++
 src/cmd/compile/internal/walk/convert.go      | 23 +++++++++++++++++++
 src/runtime/iface.go                          |  8 +++++++
 4 files changed, 35 insertions(+)

diff --git a/src/cmd/compile/internal/typecheck/builtin.go b/src/cmd/compile/internal/typecheck/builtin.go
index 3421c44588..225dd682f0 100644
--- a/src/cmd/compile/internal/typecheck/builtin.go
+++ b/src/cmd/compile/internal/typecheck/builtin.go
@@ -73,7 +73,9 @@ var runtimeDecls = [...]struct {
 	{"convI2I", funcTag, 57},
 	{"convT16", funcTag, 58},
 	{"convT32", funcTag, 58},
+	{"convT32F", funcTag, 58},
 	{"convT64", funcTag, 58},
+	{"convT64F", funcTag, 58},
 	{"convTstring", funcTag, 58},
 	{"convTslice", funcTag, 58},
 	{"convT2E", funcTag, 59},
diff --git a/src/cmd/compile/internal/typecheck/builtin/runtime.go b/src/cmd/compile/internal/typecheck/builtin/runtime.go
index 614bd46177..7c9599b54e 100644
--- a/src/cmd/compile/internal/typecheck/builtin/runtime.go
+++ b/src/cmd/compile/internal/typecheck/builtin/runtime.go
@@ -89,7 +89,9 @@ func convI2I(typ *byte, elem any) (ret any)
 // These return only a data pointer.
 func convT16(val any) unsafe.Pointer     // val must be uint16-like (same size and alignment as a uint16)
 func convT32(val any) unsafe.Pointer     // val must be uint32-like (same size and alignment as a uint32)
+func convT32F(val any) unsafe.Pointer    // val must be float32-like
 func convT64(val any) unsafe.Pointer     // val must be uint64-like (same size and alignment as a uint64 and contains no pointers)
+func convT64F(val any) unsafe.Pointer    // val must be float64-like
 func convTstring(val any) unsafe.Pointer // val must be a string
 func convTslice(val any) unsafe.Pointer  // val must be a slice
 
diff --git a/src/cmd/compile/internal/walk/convert.go b/src/cmd/compile/internal/walk/convert.go
index fa8e2c0bb8..168f42ee48 100644
--- a/src/cmd/compile/internal/walk/convert.go
+++ b/src/cmd/compile/internal/walk/convert.go
@@ -297,6 +297,25 @@ func walkStringToRunes(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 // It also reports whether the function expects the data by address.
 // Not all names are possible. For example, we never generate convE2E or convE2I.
 func convFuncName(from, to *types.Type) (fnname string, needsaddr bool) {
+	// With register-based ABI, float32 and uint32 are passed in different
+	// registers, so we cannot use convT32 for float32.
+	// isFloatLike returns whether t is a float-like type (float32, float64,
+	// single-element array/struct with a float-like element), for which
+	// the argument is passed in a floating point register under register-
+	// based ABI.
+	var isFloatLike func(t *types.Type) bool
+	isFloatLike = func(t *types.Type) bool {
+		switch t.Kind() {
+		case types.TFLOAT32, types.TFLOAT64:
+			return true
+		case types.TARRAY:
+			return t.NumElem() == 1 && isFloatLike(t.Elem())
+		case types.TSTRUCT:
+			return t.NumFields() == 1 && isFloatLike(t.Field(0).Type)
+		}
+		return false
+	}
+
 	tkind := to.Tie()
 	switch from.Tie() {
 	case 'I':
@@ -307,8 +326,12 @@ func convFuncName(from, to *types.Type) (fnname string, needsaddr bool) {
 		switch {
 		case from.Size() == 2 && from.Align == 2:
 			return "convT16", false
+		case from.Size() == 4 && isFloatLike(from):
+			return "convT32F", false
 		case from.Size() == 4 && from.Align == 4 && !from.HasPointers():
 			return "convT32", false
+		case from.Size() == 8 && isFloatLike(from):
+			return "convT64F", false
 		case from.Size() == 8 && from.Align == types.Types[types.TUINT64].Align && !from.HasPointers():
 			return "convT64", false
 		}
diff --git a/src/runtime/iface.go b/src/runtime/iface.go
index cd5fead999..f5ac627d39 100644
--- a/src/runtime/iface.go
+++ b/src/runtime/iface.go
@@ -357,6 +357,10 @@ func convT32(val uint32) (x unsafe.Pointer) {
 	return
 }
 
+func convT32F(val float32) (x unsafe.Pointer) {
+	return convT32(*(*uint32)(unsafe.Pointer(&val)))
+}
+
 func convT64(val uint64) (x unsafe.Pointer) {
 	if val < uint64(len(staticuint64s)) {
 		x = unsafe.Pointer(&staticuint64s[val])
@@ -367,6 +371,10 @@ func convT64(val uint64) (x unsafe.Pointer) {
 	return
 }
 
+func convT64F(val float64) (x unsafe.Pointer) {
+	return convT64(*(*uint64)(unsafe.Pointer(&val)))
+}
+
 func convTstring(val string) (x unsafe.Pointer) {
 	if val == "" {
 		x = unsafe.Pointer(&zeroVal[0])
-- 
GitLab


From a11244e95e1298ae6cd66a64d944dbcbbce3ca49 Mon Sep 17 00:00:00 2001
From: Martin Sucha <anty.sk+git@gmail.com>
Date: Sun, 4 Apr 2021 19:20:47 +0200
Subject: [PATCH 1373/2400] time: use offset and isDST when caching zone from
 extend string

If the current time is computed from extend string
and the zone file contains multiple zones with the
same name, the lookup by name might find incorrect
zone.

This happens for example with the slim Europe/Dublin
time zone file in the embedded zip. This zone file
has last transition in 1996 and rest is covered by
extend string.
tzset returns IST as the zone name to use, but there
are two records with IST name. Lookup by name finds
the wrong one. We need to check offset and isDST too.

In case we can't find an existing zone, we allocate
a new zone so that we use correct offset and isDST.

I have renamed zone variable to zones as it shadowed
the zone type that we need to allocate the cached zone.

Fixes #45370

Change-Id: I79102e4873b6de20d8a65f8a3057519ff5fae608
Reviewed-on: https://go-review.googlesource.com/c/go/+/307190
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/time/zoneinfo_read.go | 44 ++++++++++++++++++++++++---------------
 src/time/zoneinfo_test.go | 14 ++++++++++++-
 2 files changed, 40 insertions(+), 18 deletions(-)

diff --git a/src/time/zoneinfo_read.go b/src/time/zoneinfo_read.go
index 7ac25b1e62..b9830265e1 100644
--- a/src/time/zoneinfo_read.go
+++ b/src/time/zoneinfo_read.go
@@ -247,8 +247,8 @@ func LoadLocationFromTZData(name string, data []byte) (*Location, error) {
 		// This also avoids a panic later when we add and then use a fake transition (golang.org/issue/29437).
 		return nil, badData
 	}
-	zone := make([]zone, nzone)
-	for i := range zone {
+	zones := make([]zone, nzone)
+	for i := range zones {
 		var ok bool
 		var n uint32
 		if n, ok = zonedata.big4(); !ok {
@@ -257,22 +257,22 @@ func LoadLocationFromTZData(name string, data []byte) (*Location, error) {
 		if uint32(int(n)) != n {
 			return nil, badData
 		}
-		zone[i].offset = int(int32(n))
+		zones[i].offset = int(int32(n))
 		var b byte
 		if b, ok = zonedata.byte(); !ok {
 			return nil, badData
 		}
-		zone[i].isDST = b != 0
+		zones[i].isDST = b != 0
 		if b, ok = zonedata.byte(); !ok || int(b) >= len(abbrev) {
 			return nil, badData
 		}
-		zone[i].name = byteString(abbrev[b:])
+		zones[i].name = byteString(abbrev[b:])
 		if runtime.GOOS == "aix" && len(name) > 8 && (name[:8] == "Etc/GMT+" || name[:8] == "Etc/GMT-") {
 			// There is a bug with AIX 7.2 TL 0 with files in Etc,
 			// GMT+1 will return GMT-1 instead of GMT+1 or -01.
 			if name != "Etc/GMT+0" {
 				// GMT+0 is OK
-				zone[i].name = name[4:]
+				zones[i].name = name[4:]
 			}
 		}
 	}
@@ -295,7 +295,7 @@ func LoadLocationFromTZData(name string, data []byte) (*Location, error) {
 			}
 		}
 		tx[i].when = n
-		if int(txzones[i]) >= len(zone) {
+		if int(txzones[i]) >= len(zones) {
 			return nil, badData
 		}
 		tx[i].index = txzones[i]
@@ -314,7 +314,7 @@ func LoadLocationFromTZData(name string, data []byte) (*Location, error) {
 	}
 
 	// Committed to succeed.
-	l := &Location{zone: zone, tx: tx, name: name, extend: extend}
+	l := &Location{zone: zones, tx: tx, name: name, extend: extend}
 
 	// Fill in the cache with information about right now,
 	// since that will be the most common lookup.
@@ -323,26 +323,27 @@ func LoadLocationFromTZData(name string, data []byte) (*Location, error) {
 		if tx[i].when <= sec && (i+1 == len(tx) || sec < tx[i+1].when) {
 			l.cacheStart = tx[i].when
 			l.cacheEnd = omega
-			zoneIdx := tx[i].index
+			l.cacheZone = &l.zone[tx[i].index]
 			if i+1 < len(tx) {
 				l.cacheEnd = tx[i+1].when
 			} else if l.extend != "" {
 				// If we're at the end of the known zone transitions,
 				// try the extend string.
-				if name, _, estart, eend, _, ok := tzset(l.extend, l.cacheEnd, sec); ok {
+				if name, offset, estart, eend, isDST, ok := tzset(l.extend, l.cacheEnd, sec); ok {
 					l.cacheStart = estart
 					l.cacheEnd = eend
-					// Find the zone that is returned by tzset,
-					// the last transition is not always the correct zone.
-					for i, z := range l.zone {
-						if z.name == name {
-							zoneIdx = uint8(i)
-							break
+					// Find the zone that is returned by tzset to avoid allocation if possible.
+					if zoneIdx := findZone(l.zone, name, offset, isDST); zoneIdx != -1 {
+						l.cacheZone = &l.zone[zoneIdx]
+					} else {
+						l.cacheZone = &zone{
+							name:   name,
+							offset: offset,
+							isDST:  isDST,
 						}
 					}
 				}
 			}
-			l.cacheZone = &l.zone[zoneIdx]
 			break
 		}
 	}
@@ -350,6 +351,15 @@ func LoadLocationFromTZData(name string, data []byte) (*Location, error) {
 	return l, nil
 }
 
+func findZone(zones []zone, name string, offset int, isDST bool) int {
+	for i, z := range zones {
+		if z.name == name && z.offset == offset && z.isDST == isDST {
+			return i
+		}
+	}
+	return -1
+}
+
 // loadTzinfoFromDirOrZip returns the contents of the file with the given name
 // in dir. dir can either be an uncompressed zip file, or a directory.
 func loadTzinfoFromDirOrZip(dir, name string) ([]byte, error) {
diff --git a/src/time/zoneinfo_test.go b/src/time/zoneinfo_test.go
index a3f41d0356..7ba1229741 100644
--- a/src/time/zoneinfo_test.go
+++ b/src/time/zoneinfo_test.go
@@ -186,6 +186,7 @@ func TestMalformedTZData(t *testing.T) {
 var slimTests = []struct {
 	zoneName   string
 	tzData     string
+	date       func(*time.Location) time.Time
 	wantName   string
 	wantOffset int
 }{
@@ -193,6 +194,7 @@ var slimTests = []struct {
 		// 2020b slim tzdata for Europe/Berlin.
 		zoneName:   "Europe/Berlin",
 		tzData:     "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00<\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xffo\xa2a\xf8\xff\xff\xff\xff\x9b\f\x17`\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9cٮ\x90\xff\xff\xff\xff\x9d\xa4\xb5\x90\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\xc8\tq\x90\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xffѶ\x96\x00\xff\xff\xff\xff\xd2X\xbe\x80\xff\xff\xff\xffҡO\x10\xff\xff\xff\xff\xd3c\x1b\x90\xff\xff\xff\xff\xd4K#\x90\xff\xff\xff\xff\xd59\xd1 \xff\xff\xff\xff\xd5g\xe7\x90\xff\xff\xff\xffըs\x00\xff\xff\xff\xff\xd6)\xb4\x10\xff\xff\xff\xff\xd7,\x1a\x10\xff\xff\xff\xff\xd8\t\x96\x10\xff\xff\xff\xff\xd9\x02\xc1\x90\xff\xff\xff\xff\xd9\xe9x\x10\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x01\x02\x01\x02\x01\x03\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00\f\x88\x00\x00\x00\x00\x1c \x01\x04\x00\x00\x0e\x10\x00\t\x00\x00*0\x01\rLMT\x00CEST\x00CET\x00CEMT\x00\nCET-1CEST,M3.5.0,M10.5.0/3\n",
+		date:       func(loc *time.Location) time.Time { return time.Date(2020, time.October, 29, 15, 30, 0, 0, loc) },
 		wantName:   "CET",
 		wantOffset: 3600,
 	},
@@ -200,6 +202,7 @@ var slimTests = []struct {
 		// 2021a slim tzdata for America/Nuuk.
 		zoneName:   "America/Nuuk",
 		tzData:     "TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\"\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x9b\x80h\x00\x00\x00\x00\x00\x13M|P\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xffπ\x00\x00\xff\xff\xd5\xd0\x00\x04\xff\xff\xe3\xe0\x01\bLMT\x00-03\x00-02\x00\n<-03>3<-02>,M3.5.0/-2,M10.5.0/-1\n",
+		date:       func(loc *time.Location) time.Time { return time.Date(2020, time.October, 29, 15, 30, 0, 0, loc) },
 		wantName:   "-03",
 		wantOffset: -10800,
 	},
@@ -207,9 +210,18 @@ var slimTests = []struct {
 		// 2021a slim tzdata for Asia/Gaza.
 		zoneName:   "Asia/Gaza",
 		tzData:     "TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00s\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xff}\xbdJ\xb0\xff\xff\xff\xff\xc8Y\xcf\x00\xff\xff\xff\xff\xc8\xfa\xa6\x00\xff\xff\xff\xff\xc98\x9c\x80\xff\xff\xff\xff\xcc\xe5\xeb\x80\xff\xff\xff\xffͬ\xfe\x00\xff\xff\xff\xff\xce\xc7\x1f\x00\xff\xff\xff\xffϏ\x83\x00\xff\xff\xff\xffЩ\xa4\x00\xff\xff\xff\xffф}\x00\xff\xff\xff\xffҊ׀\xff\xff\xff\xff\xd3e\xb0\x80\xff\xff\xff\xff\xd4l\v\x00\xff\xff\xff\xff\xe86c`\xff\xff\xff\xff\xe8\xf4-P\xff\xff\xff\xff\xea\v\xb9`\xff\xff\xff\xff\xea\xd5`\xd0\xff\xff\xff\xff\xeb\xec\xfa\xf0\xff\xff\xff\xff\xec\xb5m\x00\xff\xff\xff\xff\xed\xcf\u007f\xf0\xff\xff\xff\xff\xee\x97\xf2\x00\xff\xff\xff\xffﰳp\xff\xff\xff\xff\xf0y%\x80\xff\xff\xff\xff\xf1\x91\xe6\xf0\xff\xff\xff\xff\xf2ZY\x00\xff\xff\xff\xff\xf3s\x1ap\xff\xff\xff\xff\xf4;\x8c\x80\xff\xff\xff\xff\xf5U\x9fp\xff\xff\xff\xff\xf6\x1e\x11\x80\xff\xff\xff\xff\xf76\xd2\xf0\xff\xff\xff\xff\xf7\xffE\x00\xff\xff\xff\xff\xf9\x18\x06p\xff\xff\xff\xff\xf9\xe1\xca\x00\xff\xff\xff\xff\xfa\xf99\xf0\xff\xff\xff\xff\xfb'BP\x00\x00\x00\x00\b|\x8b\xe0\x00\x00\x00\x00\b\xfd\xb0\xd0\x00\x00\x00\x00\t\xf6\xea`\x00\x00\x00\x00\n\xa63\xd0\x00\x00\x00\x00\x13\xe9\xfc`\x00\x00\x00\x00\x14![`\x00\x00\x00\x00\x1a\xfa\xc6`\x00\x00\x00\x00\x1b\x8en`\x00\x00\x00\x00\x1c\xbe\xf8\xe0\x00\x00\x00\x00\x1dw|\xd0\x00\x00\x00\x00\x1e\xcc\xff`\x00\x00\x00\x00\x1f`\x99P\x00\x00\x00\x00 \x82\xb1`\x00\x00\x00\x00!I\xb5\xd0\x00\x00\x00\x00\"^\x9e\xe0\x00\x00\x00\x00# ]P\x00\x00\x00\x00$Z0`\x00\x00\x00\x00%\x00?P\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00&\xd6\xe6\xd0\x00\x00\x00\x00'\xeb\xcf\xe0\x00\x00\x00\x00(\xc0\x03P\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xa9\x1f\xd0\x00\x00\x00\x00+\xbbe\xe0\x00\x00\x00\x00,\x89\x01\xd0\x00\x00\x00\x00-\x9bG\xe0\x00\x00\x00\x00._\xa9P\x00\x00\x00\x00/{)\xe0\x00\x00\x00\x000H\xc5\xd0\x00\x00\x00\x000\xe7\a\xe0\x00\x00\x00\x001dF`\x00\x00\x00\x002A\xc2`\x00\x00\x00\x003D(`\x00\x00\x00\x004!\xa4`\x00\x00\x00\x005$\n`\x00\x00\x00\x006\x01\x86`\x00\x00\x00\x007\x16a`\x00\x00\x00\x008\x06DP\x00\x00\x00\x008\xff}\xe0\x00\x00\x00\x009\xef`\xd0\x00\x00\x00\x00:\xdf_\xe0\x00\x00\x00\x00;\xcfB\xd0\x00\x00\x00\x00<\xbfA\xe0\x00\x00\x00\x00=\xaf$\xd0\x00\x00\x00\x00>\x9f#\xe0\x00\x00\x00\x00?\x8f\x06\xd0\x00\x00\x00\x00@\u007f\x05\xe0\x00\x00\x00\x00A\\\x81\xe0\x00\x00\x00\x00B^\xe7\xe0\x00\x00\x00\x00CA\xb7\xf0\x00\x00\x00\x00D-\xa6`\x00\x00\x00\x00E\x12\xfdP\x00\x00\x00\x00F\x0e\xd9\xe0\x00\x00\x00\x00F\xe8op\x00\x00\x00\x00G\xec\x18\xe0\x00\x00\x00\x00H\xb7\x11\xd0\x00\x00\x00\x00I\xcb\xfa\xe0\x00\x00\x00\x00J\xa0<`\x00\x00\x00\x00K\xad.\x9c\x00\x00\x00\x00La\xbd\xd0\x00\x00\x00\x00M\x94\xf9\x9c\x00\x00\x00\x00N5\xc2P\x00\x00\x00\x00Ot\xdb`\x00\x00\x00\x00P[\x91\xe0\x00\x00\x00\x00QT\xbd`\x00\x00\x00\x00RD\xa0P\x00\x00\x00\x00S4\x9f`\x00\x00\x00\x00TIlP\x00\x00\x00\x00U\x15\xd2\xe0\x00\x00\x00\x00V)\\`\x00\x00\x00\x00V\xf5\xc2\xf0\x00\x00\x00\x00X\x13\xca`\x00\x00\x00\x00Xդ\xf0\x00\x00\x00\x00Y\xf3\xac`\x00\x00\x00\x00Z\xb5\x86\xf0\x00\x00\x00\x00[ӎ`\x00\x00\x00\x00\\\x9dC\xe0\x00\x00\x00\x00]\xb3bP\x00\x00\x00\x00^~w`\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00 P\x00\x00\x00\x00*0\x01\x04\x00\x00\x1c \x00\t\x00\x00*0\x01\r\x00\x00\x1c \x00\x11LMT\x00EEST\x00EET\x00IDT\x00IST\x00\nEET-2EEST,M3.4.4/48,M10.4.4/49\n",
+		date:       func(loc *time.Location) time.Time { return time.Date(2020, time.October, 29, 15, 30, 0, 0, loc) },
 		wantName:   "EET",
 		wantOffset: 7200,
 	},
+	{
+		// 2021a slim tzdata for Europe/Dublin.
+		zoneName:   "Europe/Dublin",
+		tzData:     "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x91\x00\x00\x00\x08\x00\x00\x00\x14\xff\xff\xff\xffW\xd1\n\xdc\xff\xff\xff\xff\x9b&\xb3\x91\xff\xff\xff\xff\x9b\xd6\x0b\x11\xff\xff\xff\xff\x9c\xcf0\xa0\xff\xff\xff\xff\x9d\xa4\xc3\xa0\xff\xff\xff\xff\x9e\x9c\x9d\xa0\xff\xff\xff\xff\x9f\x97\x1a\xa0\xff\xff\xff\xff\xa0\x85\xba\x20\xff\xff\xff\xff\xa1v\xfc\xa0\xff\xff\xff\xff\xa2e\x9c\x20\xff\xff\xff\xff\xa3{\xc8\xa0\xff\xff\xff\xff\xa4N\xb8\xa0\xff\xff\xff\xff\xa5?\xfb\x20\xff\xff\xff\xff\xa6%`\x20\xff\xff\xff\xff\xa7'\xc6\x20\xff\xff\xff\xff\xa8*,\x20\xff\xff\xff\xff\xa8\xeb\xf8\xa0\xff\xff\xff\xff\xaa\x00\xd3\xa0\xff\xff\xff\xff\xaa\xd5\x15\x20\xff\xff\xff\xff\xab\xe9\xf0\x20\xff\xff\xff\xff\xac\xc7l\x20\xff\xff\xff\xff\xad\xc9\xd2\x20\xff\xff\xff\xff\xae\xa7N\x20\xff\xff\xff\xff\xaf\xa0y\xa0\xff\xff\xff\xff\xb0\x870\x20\xff\xff\xff\xff\xb1\x92\xd0\xa0\xff\xff\xff\xff\xb2pL\xa0\xff\xff\xff\xff\xb3r\xb2\xa0\xff\xff\xff\xff\xb4P.\xa0\xff\xff\xff\xff\xb5IZ\x20\xff\xff\xff\xff\xb60\x10\xa0\xff\xff\xff\xff\xb72v\xa0\xff\xff\xff\xff\xb8\x0f\xf2\xa0\xff\xff\xff\xff\xb9\x12X\xa0\xff\xff\xff\xff\xb9\xef\xd4\xa0\xff\xff\xff\xff\xba\xe9\x00\x20\xff\xff\xff\xff\xbb\xd8\xf1\x20\xff\xff\xff\xff\xbc\xdbW\x20\xff\xff\xff\xff\xbd\xb8\xd3\x20\xff\xff\xff\xff\xbe\xb1\xfe\xa0\xff\xff\xff\xff\xbf\x98\xb5\x20\xff\xff\xff\xff\xc0\x9b\x1b\x20\xff\xff\xff\xff\xc1x\x97\x20\xff\xff\xff\xff\xc2z\xfd\x20\xff\xff\xff\xff\xc3Xy\x20\xff\xff\xff\xff\xc4Q\xa4\xa0\xff\xff\xff\xff\xc58[\x20\xff\xff\xff\xff\xc6:\xc1\x20\xff\xff\xff\xff\xc7X\xd6\xa0\xff\xff\xff\xff\xc7\xda\x09\xa0\xff\xff\xff\xff\xd4I\xe0\x20\xff\xff\xff\xff\xd5\x1e!\xa0\xff\xff\xff\xff\xd6N\xac\x20\xff\xff\xff\xff\xd7,(\x20\xff\xff\xff\xff\xd8.\x8e\x20\xff\xff\xff\xff\xd8\xf9\x95\x20\xff\xff\xff\xff\xda\x0ep\x20\xff\xff\xff\xff\xda\xeb\xec\x20\xff\xff\xff\xff\xdb\xe5\x17\xa0\xff\xff\xff\xff\xdc\xcb\xce\x20\xff\xff\xff\xff\xdd\xc4\xf9\xa0\xff\xff\xff\xff\xde\xb4\xea\xa0\xff\xff\xff\xff\xdf\xae\x16\x20\xff\xff\xff\xff\xe0\x94\xcc\xa0\xff\xff\xff\xff\xe1rH\xa0\xff\xff\xff\xff\xe2kt\x20\xff\xff\xff\xff\xe3R*\xa0\xff\xff\xff\xff\xe4T\x90\xa0\xff\xff\xff\xff\xe52\x0c\xa0\xff\xff\xff\xff\xe6=\xad\x20\xff\xff\xff\xff\xe7\x1b)\x20\xff\xff\xff\xff\xe8\x14T\xa0\xff\xff\xff\xff\xe8\xfb\x0b\x20\xff\xff\xff\xff\xe9\xfdq\x20\xff\xff\xff\xff\xea\xda\xed\x20\xff\xff\xff\xff\xeb\xddS\x20\xff\xff\xff\xff\xec\xba\xcf\x20\xff\xff\xff\xff\xed\xb3\xfa\xa0\xff\xff\xff\xff\xee\x9a\xb1\x20\xff\xff\xff\xff\xef\x81g\xa0\xff\xff\xff\xff\xf0\x9f}\x20\xff\xff\xff\xff\xf1aI\xa0\xff\xff\xff\xff\xf2\x7f_\x20\xff\xff\xff\xff\xf3Jf\x20\xff\xff\xff\xff\xf4_A\x20\xff\xff\xff\xff\xf5!\x0d\xa0\xff\xff\xff\xff\xf6?#\x20\xff\xff\xff\xff\xf7\x00\xef\xa0\xff\xff\xff\xff\xf8\x1f\x05\x20\xff\xff\xff\xff\xf8\xe0\xd1\xa0\xff\xff\xff\xff\xf9\xfe\xe7\x20\xff\xff\xff\xff\xfa\xc0\xb3\xa0\xff\xff\xff\xff\xfb\xe8\x03\xa0\xff\xff\xff\xff\xfc{\xab\xa0\xff\xff\xff\xff\xfd\xc7\xbbp\x00\x00\x00\x00\x03p\xc6\x20\x00\x00\x00\x00\x04)X\x20\x00\x00\x00\x00\x05P\xa8\x20\x00\x00\x00\x00\x06\x09:\x20\x00\x00\x00\x00\x070\x8a\x20\x00\x00\x00\x00\x07\xe9\x1c\x20\x00\x00\x00\x00\x09\x10l\x20\x00\x00\x00\x00\x09\xc8\xfe\x20\x00\x00\x00\x00\n\xf0N\x20\x00\x00\x00\x00\x0b\xb2\x1a\xa0\x00\x00\x00\x00\x0c\xd00\x20\x00\x00\x00\x00\x0d\x91\xfc\xa0\x00\x00\x00\x00\x0e\xb0\x12\x20\x00\x00\x00\x00\x0fq\xde\xa0\x00\x00\x00\x00\x10\x99.\xa0\x00\x00\x00\x00\x11Q\xc0\xa0\x00\x00\x00\x00\x12y\x10\xa0\x00\x00\x00\x00\x131\xa2\xa0\x00\x00\x00\x00\x14X\xf2\xa0\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x168\xc6\x90\x00\x00\x00\x00\x17\x03\xcd\x90\x00\x00\x00\x00\x18\x18\xa8\x90\x00\x00\x00\x00\x18\xe3\xaf\x90\x00\x00\x00\x00\x19\xf8\x8a\x90\x00\x00\x00\x00\x1a\xc3\x91\x90\x00\x00\x00\x00\x1b\xe1\xa7\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\xc1\x89\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f\xa1k\x10\x00\x00\x00\x00\x20lr\x10\x00\x00\x00\x00!\x81M\x10\x00\x00\x00\x00\x22LT\x10\x00\x00\x00\x00#a/\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%JK\x90\x00\x00\x00\x00&\x0c\x18\x10\x00\x00\x00\x00'*-\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00)\n\x0f\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xe9\xf1\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xc9\xd3\x90\x00\x00\x00\x00-\x94\xda\x90\x00\x00\x00\x00.\xa9\xb5\x90\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000\x89\x97\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\xff\xff\xfa$\x00\x00\xff\xff\xfa\x0f\x00\x04\x00\x00\x08\x1f\x01\x08\x00\x00\x0e\x10\x01\x0c\x00\x00\x00\x00\x00\x10\x00\x00\x0e\x10\x01\x08\x00\x00\x00\x00\x01\x10\x00\x00\x0e\x10\x00\x08LMT\x00DMT\x00IST\x00BST\x00GMT\x00\nIST-1GMT0,M10.5.0,M3.5.0/1\n",
+		date:       func(loc *time.Location) time.Time { return time.Date(2021, time.April, 2, 11, 12, 13, 0, loc) },
+		wantName:   "IST",
+		wantOffset: 3600,
+	},
 }
 
 func TestLoadLocationFromTZDataSlim(t *testing.T) {
@@ -219,7 +231,7 @@ func TestLoadLocationFromTZDataSlim(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		d := time.Date(2020, time.October, 29, 15, 30, 0, 0, reference)
+		d := test.date(reference)
 		tzName, tzOffset := d.Zone()
 		if tzName != test.wantName {
 			t.Errorf("Zone name == %s, want %s", tzName, test.wantName)
-- 
GitLab


From a1a45afd4a0586cea2d238bfa9dd8e584645a562 Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Tue, 9 Mar 2021 16:55:06 -0600
Subject: [PATCH 1374/2400] cmd/internal/obj: remove duplicate ppc64 spr MOV*
 optab entries

The matching rules will match C_SPR for the commonly used SPR
entries (xer, lr, ctr).

Change-Id: I93759c1ce2891f6825661b99c5cbb89250b64ab7
Reviewed-on: https://go-review.googlesource.com/c/go/+/304429
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
Reviewed-by: Carlos Eduardo Seo <carlos.seo@linaro.org>
Trust: Carlos Eduardo Seo <carlos.seo@linaro.org>
---
 src/cmd/internal/obj/ppc64/asm9.go | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/src/cmd/internal/obj/ppc64/asm9.go b/src/cmd/internal/obj/ppc64/asm9.go
index 47e67a32f3..f169c326d8 100644
--- a/src/cmd/internal/obj/ppc64/asm9.go
+++ b/src/cmd/internal/obj/ppc64/asm9.go
@@ -222,23 +222,18 @@ var optab = []Optab{
 	{as: AMOVD, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4},
 	{as: AMOVD, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
 	{as: AMOVD, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVD, a1: C_CTR, a6: C_REG, type_: 66, size: 4},
 	{as: AMOVD, a1: C_GOTADDR, a6: C_REG, type_: 81, size: 8},
 	{as: AMOVD, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
 	{as: AMOVD, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
 	{as: AMOVD, a1: C_LECON, a6: C_REG, type_: 26, size: 8},
 	{as: AMOVD, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
-	{as: AMOVD, a1: C_LR, a6: C_REG, type_: 66, size: 4},
 	{as: AMOVD, a1: C_MSR, a6: C_REG, type_: 54, size: 4}, /* mfmsr */
 	{as: AMOVD, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
-	{as: AMOVD, a1: C_REG, a6: C_CTR, type_: 66, size: 4},
 	{as: AMOVD, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
-	{as: AMOVD, a1: C_REG, a6: C_LR, type_: 66, size: 4},
 	{as: AMOVD, a1: C_REG, a6: C_MSR, type_: 54, size: 4}, /* mtmsrd */
 	{as: AMOVD, a1: C_REG, a6: C_REG, type_: 1, size: 4},
 	{as: AMOVD, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVD, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
-	{as: AMOVD, a1: C_REG, a6: C_XER, type_: 66, size: 4},
 	{as: AMOVD, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
 	{as: AMOVD, a1: C_SECON, a6: C_REG, type_: 3, size: 4},
 	{as: AMOVD, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
@@ -247,7 +242,6 @@ var optab = []Optab{
 	{as: AMOVD, a1: C_TLS_LE, a6: C_REG, type_: 79, size: 4},
 	{as: AMOVD, a1: C_TOCADDR, a6: C_REG, type_: 95, size: 8},
 	{as: AMOVD, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVD, a1: C_XER, a6: C_REG, type_: 66, size: 4},
 
 	{as: AMOVW, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4},
 	{as: AMOVW, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
@@ -259,18 +253,15 @@ var optab = []Optab{
 	{as: AMOVW, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
 	{as: AMOVW, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 	{as: AMOVW, a1: C_REG, a6: C_CREG, type_: 69, size: 4},
-	{as: AMOVW, a1: C_REG, a6: C_CTR, type_: 66, size: 4},
 	{as: AMOVW, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
 	{as: AMOVW, a1: C_REG, a6: C_REG, type_: 12, size: 4},
 	{as: AMOVW, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVW, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
-	{as: AMOVW, a1: C_REG, a6: C_XER, type_: 66, size: 4},
 	{as: AMOVW, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
 	{as: AMOVW, a1: C_SECON, a6: C_REG, type_: 3, size: 4}, /* TO DO: check */
 	{as: AMOVW, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
 	{as: AMOVW, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
 	{as: AMOVW, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVW, a1: C_XER, a6: C_REG, type_: 66, size: 4},
 
 	{as: AMOVWZ, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4},
 	{as: AMOVWZ, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
@@ -282,19 +273,16 @@ var optab = []Optab{
 	{as: AMOVWZ, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
 	{as: AMOVWZ, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 	{as: AMOVWZ, a1: C_REG, a6: C_CREG, type_: 69, size: 4},
-	{as: AMOVWZ, a1: C_REG, a6: C_CTR, type_: 66, size: 4},
 	{as: AMOVWZ, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
 	{as: AMOVWZ, a1: C_REG, a6: C_MSR, type_: 54, size: 4}, /* mtmsr */
 	{as: AMOVWZ, a1: C_REG, a6: C_REG, type_: 13, size: 4},
 	{as: AMOVWZ, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVWZ, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
-	{as: AMOVWZ, a1: C_REG, a6: C_XER, type_: 66, size: 4},
 	{as: AMOVWZ, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
 	{as: AMOVWZ, a1: C_SECON, a6: C_REG, type_: 3, size: 4}, /* TO DO: check */
 	{as: AMOVWZ, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
 	{as: AMOVWZ, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
 	{as: AMOVWZ, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVWZ, a1: C_XER, a6: C_REG, type_: 66, size: 4},
 
 	{as: AMOVFL, a1: C_CREG, a6: C_CREG, type_: 67, size: 4},
 	{as: AMOVFL, a1: C_FPSCR, a6: C_CREG, type_: 73, size: 4},
-- 
GitLab


From e985245cd520cabe4bd3d99058d1089aac50cf45 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Fri, 2 Apr 2021 14:36:36 -0700
Subject: [PATCH 1375/2400] net: make ErrClosed and ParseError implement
 net.Error

Fixes #45357

Change-Id: Iafd41fff232a89be4c88d4b1d66bc3c04d888bcc
Reviewed-on: https://go-review.googlesource.com/c/go/+/307030
Trust: Ian Lance Taylor <iant@golang.org>
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>
---
 src/internal/poll/fd.go | 19 +++++++++++++++----
 src/net/net.go          |  5 ++++-
 src/net/net_test.go     | 20 ++++++++++++++++++++
 3 files changed, 39 insertions(+), 5 deletions(-)

diff --git a/src/internal/poll/fd.go b/src/internal/poll/fd.go
index b72ea3d55c..69a90054d3 100644
--- a/src/internal/poll/fd.go
+++ b/src/internal/poll/fd.go
@@ -13,11 +13,22 @@ import (
 	"errors"
 )
 
-// ErrNetClosing is returned when a network descriptor is used after
-// it has been closed. Keep this string consistent because of issue
-// #4373: since historically programs have not been able to detect
+// errNetClosing is the type of the variable ErrNetClosing.
+// This is used to implement the net.Error interface.
+type errNetClosing struct{}
+
+// Error returns the error message for ErrNetClosing.
+// Keep this string consistent because of issue #4373:
+// since historically programs have not been able to detect
 // this error, they look for the string.
-var ErrNetClosing = errors.New("use of closed network connection")
+func (e errNetClosing) Error() string { return "use of closed network connection" }
+
+func (e errNetClosing) Timeout() bool   { return false }
+func (e errNetClosing) Temporary() bool { return false }
+
+// ErrNetClosing is returned when a network descriptor is used after
+// it has been closed.
+var ErrNetClosing = errNetClosing{}
 
 // ErrFileClosing is returned when a file descriptor is used after it
 // has been closed.
diff --git a/src/net/net.go b/src/net/net.go
index 7e172b708e..a7c65fff79 100644
--- a/src/net/net.go
+++ b/src/net/net.go
@@ -539,6 +539,9 @@ type ParseError struct {
 
 func (e *ParseError) Error() string { return "invalid " + e.Type + ": " + e.Text }
 
+func (e *ParseError) Timeout() bool   { return false }
+func (e *ParseError) Temporary() bool { return false }
+
 type AddrError struct {
 	Err  string
 	Addr string
@@ -642,7 +645,7 @@ var errClosed = poll.ErrNetClosing
 // another goroutine before the I/O is completed. This may be wrapped
 // in another error, and should normally be tested using
 // errors.Is(err, net.ErrClosed).
-var ErrClosed = errClosed
+var ErrClosed error = errClosed
 
 type writerOnly struct {
 	io.Writer
diff --git a/src/net/net_test.go b/src/net/net_test.go
index 6d6299e74a..6e7be4db23 100644
--- a/src/net/net_test.go
+++ b/src/net/net_test.go
@@ -588,3 +588,23 @@ func TestNotTemporaryRead(t *testing.T) {
 	}
 	withTCPConnPair(t, client, server)
 }
+
+// The various errors should implement the Error interface.
+func TestErrors(t *testing.T) {
+	var (
+		_ Error = &OpError{}
+		_ Error = &ParseError{}
+		_ Error = &AddrError{}
+		_ Error = UnknownNetworkError("")
+		_ Error = InvalidAddrError("")
+		_ Error = &timeoutError{}
+		_ Error = &DNSConfigError{}
+		_ Error = &DNSError{}
+	)
+
+	// ErrClosed was introduced as type error, so we can't check
+	// it using a declaration.
+	if _, ok := ErrClosed.(Error); !ok {
+		t.Fatal("ErrClosed does not implement Error")
+	}
+}
-- 
GitLab


From d5b9dc1317e3d898650fcb6e417f03b00e69270b Mon Sep 17 00:00:00 2001
From: wolf1996 <ksgiv37@gmail.com>
Date: Fri, 13 Nov 2020 14:30:15 +0300
Subject: [PATCH 1376/2400] cmd/cgo: pass end position info for C function
 arguments.

Pass information about original end position for c function arguments
processed in pointer checking generated code.

Fixes #42580

Change-Id: Ic8a578168362f0ca6055064dbbea092ad37477a6
Reviewed-on: https://go-review.googlesource.com/c/go/+/269760
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dmitri Shuralyov <dmitshur@golang.org>
---
 misc/cgo/errors/argposition_test.go    | 134 +++++++++++++++++++++++++
 misc/cgo/errors/testdata/issue42580.go |  44 ++++++++
 src/cmd/cgo/gcc.go                     |  34 +++++--
 3 files changed, 203 insertions(+), 9 deletions(-)
 create mode 100644 misc/cgo/errors/argposition_test.go
 create mode 100644 misc/cgo/errors/testdata/issue42580.go

diff --git a/misc/cgo/errors/argposition_test.go b/misc/cgo/errors/argposition_test.go
new file mode 100644
index 0000000000..331095f747
--- /dev/null
+++ b/misc/cgo/errors/argposition_test.go
@@ -0,0 +1,134 @@
+// Copyright 2021 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.
+
+// Issue 42580: cmd/cgo: shifting identifier position in ast
+
+package errorstest
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+type ShortPosition struct {
+	Line    int
+	Column  int
+	Visited bool
+}
+
+type IdentPositionInfo map[string][]ShortPosition
+
+type Visitor struct {
+	identPosInfo IdentPositionInfo
+	fset         *token.FileSet
+	t            *testing.T
+}
+
+func (v *Visitor) Visit(node ast.Node) ast.Visitor {
+	if ident, ok := node.(*ast.Ident); ok {
+		if expectedPositions, ok := v.identPosInfo[ident.Name]; ok {
+			gotMatch := false
+			var errorMessage strings.Builder
+			for caseIndex, expectedPos := range expectedPositions {
+				actualPosition := v.fset.PositionFor(ident.Pos(), true)
+				errorOccured := false
+				if expectedPos.Line != actualPosition.Line {
+					fmt.Fprintf(&errorMessage, "wrong line number for ident %s: expected: %d got: %d\n", ident.Name, expectedPos.Line, actualPosition.Line)
+					errorOccured = true
+				}
+				if expectedPos.Column != actualPosition.Column {
+					fmt.Fprintf(&errorMessage, "wrong column number for ident %s: expected: %d got: %d\n", ident.Name, expectedPos.Column, actualPosition.Column)
+					errorOccured = true
+				}
+				if errorOccured {
+					continue
+				}
+				gotMatch = true
+				expectedPositions[caseIndex].Visited = true
+			}
+
+			if !gotMatch {
+				v.t.Errorf(errorMessage.String())
+			}
+		}
+	}
+	return v
+}
+
+func TestArgumentsPositions(t *testing.T) {
+	testdata, err := filepath.Abs("testdata")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	tmpPath := t.TempDir()
+
+	dir := filepath.Join(tmpPath, "src", "testpositions")
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		t.Fatal(err)
+	}
+
+	cmd := exec.Command("go", "tool", "cgo",
+		"-srcdir", testdata,
+		"-objdir", dir,
+		"issue42580.go")
+	cmd.Stderr = new(bytes.Buffer)
+
+	err = cmd.Run()
+	if err != nil {
+		t.Fatalf("%s: %v\n%s", cmd, err, cmd.Stderr)
+	}
+	mainProcessed, err := ioutil.ReadFile(filepath.Join(dir, "issue42580.cgo1.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	fset := token.NewFileSet()
+	f, err := parser.ParseFile(fset, "", mainProcessed, parser.AllErrors)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	expectation := IdentPositionInfo{
+		"checkedPointer": []ShortPosition{
+			ShortPosition{
+				Line:   32,
+				Column: 56,
+			},
+		},
+		"singleInnerPointerChecked": []ShortPosition{
+			ShortPosition{
+				Line:   37,
+				Column: 91,
+			},
+		},
+		"doublePointerChecked": []ShortPosition{
+			ShortPosition{
+				Line:   42,
+				Column: 91,
+			},
+		},
+	}
+	for _, decl := range f.Decls {
+		if fdecl, ok := decl.(*ast.FuncDecl); ok {
+			ast.Walk(&Visitor{expectation, fset, t}, fdecl.Body)
+		}
+	}
+	for ident, positions := range expectation {
+		for _, position := range positions {
+			if !position.Visited {
+				t.Errorf("Position %d:%d missed for %s ident", position.Line, position.Column, ident)
+			}
+		}
+	}
+}
diff --git a/misc/cgo/errors/testdata/issue42580.go b/misc/cgo/errors/testdata/issue42580.go
new file mode 100644
index 0000000000..aba80dfeba
--- /dev/null
+++ b/misc/cgo/errors/testdata/issue42580.go
@@ -0,0 +1,44 @@
+// Copyright 2021 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.
+
+// Issue 42580: cmd/cgo: shifting identifier position in ast
+
+package cgotest
+
+// typedef int (*intFunc) ();
+//
+// char* strarg = "";
+//
+// int func_with_char(char* arg, void* dummy)
+// {return 5;}
+//
+// int* get_arr(char* arg, void* dummy)
+// {return NULL;}
+import "C"
+import "unsafe"
+
+// Test variables
+var (
+	checkedPointer            = []byte{1}
+	doublePointerChecked      = []byte{1}
+	singleInnerPointerChecked = []byte{1}
+)
+
+// This test checks the positions of variable identifiers.
+// Changing the positions of the test variables idents after this point will break the test.
+
+func TestSingleArgumentCast() C.int {
+	retcode := C.func_with_char((*C.char)(unsafe.Pointer(&checkedPointer[0])), unsafe.Pointer(C.strarg))
+	return retcode
+}
+
+func TestSingleArgumentCastRecFuncAsSimpleArg() C.int {
+	retcode := C.func_with_char((*C.char)(unsafe.Pointer(C.get_arr((*C.char)(unsafe.Pointer(&singleInnerPointerChecked[0])), unsafe.Pointer(C.strarg)))), nil)
+	return retcode
+}
+
+func TestSingleArgumentCastRecFunc() C.int {
+	retcode := C.func_with_char((*C.char)(unsafe.Pointer(C.get_arr((*C.char)(unsafe.Pointer(&doublePointerChecked[0])), unsafe.Pointer(C.strarg)))), unsafe.Pointer(C.strarg))
+	return retcode
+}
diff --git a/src/cmd/cgo/gcc.go b/src/cmd/cgo/gcc.go
index 775f20b09f..ae61725bc7 100644
--- a/src/cmd/cgo/gcc.go
+++ b/src/cmd/cgo/gcc.go
@@ -909,7 +909,7 @@ func (p *Package) rewriteCall(f *File, call *Call) (string, bool) {
 	var sbCheck bytes.Buffer
 	for i, param := range params {
 		origArg := args[i]
-		arg, nu := p.mangle(f, &args[i])
+		arg, nu := p.mangle(f, &args[i], true)
 		if nu {
 			needsUnsafe = true
 		}
@@ -952,7 +952,7 @@ func (p *Package) rewriteCall(f *File, call *Call) (string, bool) {
 		sb.WriteString("return ")
 	}
 
-	m, nu := p.mangle(f, &call.Call.Fun)
+	m, nu := p.mangle(f, &call.Call.Fun, false)
 	if nu {
 		needsUnsafe = true
 	}
@@ -1086,7 +1086,8 @@ func (p *Package) hasPointer(f *File, t ast.Expr, top bool) bool {
 // rewriting calls when it finds them.
 // It removes the corresponding references in f.Ref and f.Calls, so that we
 // don't try to do the replacement again in rewriteRef or rewriteCall.
-func (p *Package) mangle(f *File, arg *ast.Expr) (ast.Expr, bool) {
+// If addPosition is true, add position info to the idents of C names in arg.
+func (p *Package) mangle(f *File, arg *ast.Expr, addPosition bool) (ast.Expr, bool) {
 	needsUnsafe := false
 	f.walk(arg, ctxExpr, func(f *File, arg interface{}, context astContext) {
 		px, ok := arg.(*ast.Expr)
@@ -1101,7 +1102,7 @@ func (p *Package) mangle(f *File, arg *ast.Expr) (ast.Expr, bool) {
 
 			for _, r := range f.Ref {
 				if r.Expr == px {
-					*px = p.rewriteName(f, r)
+					*px = p.rewriteName(f, r, addPosition)
 					r.Done = true
 					break
 				}
@@ -1361,7 +1362,7 @@ func (p *Package) rewriteRef(f *File) {
 			}
 		}
 
-		expr := p.rewriteName(f, r)
+		expr := p.rewriteName(f, r, false)
 
 		if *godefs {
 			// Substitute definition for mangled type name.
@@ -1424,8 +1425,23 @@ func (p *Package) rewriteRef(f *File) {
 }
 
 // rewriteName returns the expression used to rewrite a reference.
-func (p *Package) rewriteName(f *File, r *Ref) ast.Expr {
-	var expr ast.Expr = ast.NewIdent(r.Name.Mangle) // default
+// If addPosition is true, add position info in the ident name.
+func (p *Package) rewriteName(f *File, r *Ref, addPosition bool) ast.Expr {
+	getNewIdent := ast.NewIdent
+	if addPosition {
+		getNewIdent = func(newName string) *ast.Ident {
+			mangledIdent := ast.NewIdent(newName)
+			if len(newName) == len(r.Name.Go) {
+				return mangledIdent
+			}
+			p := fset.Position((*r.Expr).End())
+			if p.Column == 0 {
+				return mangledIdent
+			}
+			return ast.NewIdent(fmt.Sprintf("%s /*line :%d:%d*/", newName, p.Line, p.Column))
+		}
+	}
+	var expr ast.Expr = getNewIdent(r.Name.Mangle) // default
 	switch r.Context {
 	case ctxCall, ctxCall2:
 		if r.Name.Kind != "func" {
@@ -1453,7 +1469,7 @@ func (p *Package) rewriteName(f *File, r *Ref) ast.Expr {
 				n.Mangle = "_C2func_" + n.Go
 				f.Name["2"+r.Name.Go] = n
 			}
-			expr = ast.NewIdent(n.Mangle)
+			expr = getNewIdent(n.Mangle)
 			r.Name = n
 			break
 		}
@@ -1484,7 +1500,7 @@ func (p *Package) rewriteName(f *File, r *Ref) ast.Expr {
 			// issue 7757.
 			expr = &ast.CallExpr{
 				Fun:  &ast.Ident{NamePos: (*r.Expr).Pos(), Name: "_Cgo_ptr"},
-				Args: []ast.Expr{ast.NewIdent(name.Mangle)},
+				Args: []ast.Expr{getNewIdent(name.Mangle)},
 			}
 		case "type":
 			// Okay - might be new(T)
-- 
GitLab


From 254fb85c12aa631b5d1596aaf13f6e8666d65d15 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Mon, 29 Mar 2021 17:00:15 -0400
Subject: [PATCH 1377/2400] cmd/go: print deprecation notice for 'go get cmd'

The notice is shown when 'go get' is invoked with the -d flag, and
the arguments match at least one main package.

This reverts CL 274552.

For #43684

Change-Id: I42e6731455f22988bf72dde1d5a76d197e9e3954
Reviewed-on: https://go-review.googlesource.com/c/go/+/305670
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modget/get.go             | 28 +++++++++++++++++--
 .../script/mod_get_deprecate_install.txt      | 22 +++++++++++++++
 2 files changed, 47 insertions(+), 3 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/mod_get_deprecate_install.txt

diff --git a/src/cmd/go/internal/modget/get.go b/src/cmd/go/internal/modget/get.go
index a9447f6c57..c6e380b197 100644
--- a/src/cmd/go/internal/modget/get.go
+++ b/src/cmd/go/internal/modget/get.go
@@ -385,10 +385,32 @@ func runGet(ctx context.Context, cmd *base.Command, args []string) {
 			pkgs = append(pkgs, pkg)
 		}
 		load.CheckPackageErrors(pkgs)
+
+		haveExe := false
+		for _, pkg := range pkgs {
+			if pkg.Name == "main" {
+				haveExe = true
+				break
+			}
+		}
+		if haveExe {
+			fmt.Fprint(os.Stderr, "go get: installing executables with 'go get' in module mode is deprecated.")
+			var altMsg string
+			if modload.HasModRoot() {
+				altMsg = `
+	To adjust and download dependencies of the current module, use 'go get -d'.
+	To install using requirements of the current module, use 'go install'.
+	To install ignoring the current module, use 'go install' with a version,
+	like 'go install example.com/cmd@latest'.
+`
+			} else {
+				altMsg = "\n\tUse 'go install pkg@version' instead.\n"
+			}
+			fmt.Fprint(os.Stderr, altMsg)
+			fmt.Fprintf(os.Stderr, "\tFor more information, see https://golang.org/doc/go-get-install-deprecation\n\tor run 'go help get' or 'go help install'.\n")
+		}
+
 		work.InstallPackages(ctx, pkgPatterns, pkgs)
-		// TODO(#40276): After Go 1.16, print a deprecation notice when building and
-		// installing main packages. 'go install pkg' or 'go install pkg@version'
-		// should be used instead. Give the specific argument to use if possible.
 	}
 
 	if !modload.HasModRoot() {
diff --git a/src/cmd/go/testdata/script/mod_get_deprecate_install.txt b/src/cmd/go/testdata/script/mod_get_deprecate_install.txt
new file mode 100644
index 0000000000..d832b5f2e8
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_get_deprecate_install.txt
@@ -0,0 +1,22 @@
+[short] skip
+
+env GO111MODULE=on
+
+# 'go get' outside a module with an executable prints a deprecation message.
+go get example.com/cmd/a
+stderr '^go get: installing executables with ''go get'' in module mode is deprecated.$'
+stderr 'Use ''go install pkg@version'' instead.'
+
+
+go mod init m
+
+# 'go get' inside a module with a non-main package does not print a message.
+# This will stop building in the future, but it's the command we want to use.
+go get rsc.io/quote
+! stderr deprecated
+
+# 'go get' inside a module with an executable prints a different
+# deprecation message.
+go get example.com/cmd/a
+stderr '^go get: installing executables with ''go get'' in module mode is deprecated.$'
+stderr 'To adjust and download dependencies of the current module, use ''go get -d'''
-- 
GitLab


From ee40bb666bed55e7232c50a980e238aed7a32e0c Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Mon, 5 Apr 2021 09:47:22 -0400
Subject: [PATCH 1378/2400] cmd/compile: add "surprised by IData of Arg" case
 for register args

This fixes a compile crash for
GOEXPERIMENT=regabi,regabiargs go test -c  go/constant

Updates #40724.

Change-Id: I238cef436e045647815326fc8fdb025c30ba1f5c
Reviewed-on: https://go-review.googlesource.com/c/go/+/307309
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/expand_calls.go |  9 ++
 test/abi/idata.go                            | 97 ++++++++++++++++++++
 test/abi/idata.out                           |  1 +
 3 files changed, 107 insertions(+)
 create mode 100644 test/abi/idata.go
 create mode 100644 test/abi/idata.out

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index b6683d076d..6a6517deb8 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -317,6 +317,15 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64,
 		}
 	}
 	switch selector.Op {
+	case OpArgIntReg, OpArgFloatReg:
+		if leafType == selector.Type { // OpIData leads us here, sometimes.
+			leaf.copyOf(selector)
+		} else {
+			x.f.Fatalf("Unexpected %s type, selector=%s, leaf=%s\n", selector.Op.String(), selector.LongString(), leaf.LongString())
+		}
+		if x.debug {
+			x.Printf("---%s, break\n", selector.Op.String())
+		}
 	case OpArg:
 		if !x.isAlreadyExpandedAggregateType(selector.Type) {
 			if leafType == selector.Type { // OpIData leads us here, sometimes.
diff --git a/test/abi/idata.go b/test/abi/idata.go
new file mode 100644
index 0000000000..af2b87b9d6
--- /dev/null
+++ b/test/abi/idata.go
@@ -0,0 +1,97 @@
+// run
+
+// Copyright 2021 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.
+
+// Excerpted from go/constant/value.go to capture a bug from there.
+
+package main
+
+import (
+	"fmt"
+	"math"
+	"math/big"
+)
+
+type (
+	unknownVal struct{}
+	intVal     struct{ val *big.Int }   // Int values not representable as an int64
+	ratVal     struct{ val *big.Rat }   // Float values representable as a fraction
+	floatVal   struct{ val *big.Float } // Float values not representable as a fraction
+	complexVal struct{ re, im Value }
+)
+
+const prec = 512
+
+func (unknownVal) String() string { return "unknown" }
+
+func (x intVal) String() string   { return x.val.String() }
+func (x ratVal) String() string   { return rtof(x).String() }
+
+func (x floatVal) String() string {
+	f := x.val
+
+	// Use exact fmt formatting if in float64 range (common case):
+	// proceed if f doesn't underflow to 0 or overflow to inf.
+	if x, _ := f.Float64(); f.Sign() == 0 == (x == 0) && !math.IsInf(x, 0) {
+		return fmt.Sprintf("%.6g", x)
+	}
+
+	return "OOPS"
+}
+
+func (x complexVal) String() string { return fmt.Sprintf("(%s + %si)", x.re, x.im) }
+
+func newFloat() *big.Float { return new(big.Float).SetPrec(prec) }
+
+//go:noinline
+//go:registerparams
+func itor(x intVal) ratVal       { return ratVal{nil} }
+
+//go:noinline
+//go:registerparams
+func itof(x intVal) floatVal     { return floatVal{nil} }
+func rtof(x ratVal) floatVal     { return floatVal{newFloat().SetRat(x.val)} }
+
+type Value interface {
+	String() string
+}
+
+//go:noinline
+//go:registerparams
+func ToFloat(x Value) Value {
+	switch x := x.(type) {
+	case intVal:
+		if smallInt(x.val) {
+			return itor(x)
+		}
+		return itof(x)
+	case ratVal, floatVal:
+		return x
+	case complexVal:
+		if Sign(x.im) == 0 {
+			return ToFloat(x.re)
+		}
+	}
+	return unknownVal{}
+}
+
+//go:noinline
+//go:registerparams
+func smallInt(x *big.Int) bool {
+	return false
+}
+
+//go:noinline
+//go:registerparams
+func Sign(x Value) int {
+	return 0
+}
+
+
+func main() {
+	v := ratVal{big.NewRat(22,7)}
+	s := ToFloat(v).String()
+	fmt.Printf("s=%s\n", s)
+}
diff --git a/test/abi/idata.out b/test/abi/idata.out
new file mode 100644
index 0000000000..98190c2755
--- /dev/null
+++ b/test/abi/idata.out
@@ -0,0 +1 @@
+s=3.14286
-- 
GitLab


From 27015152ec769aeed2ab92533772b97c0ef96b11 Mon Sep 17 00:00:00 2001
From: James Fennell <jpfennell@google.com>
Date: Mon, 5 Apr 2021 18:21:59 +0000
Subject: [PATCH 1379/2400] flag: use strings.Builder instead of concatenating
 strings

There is a single function in the flag package whose implementation
uses string concatenation instead of the recommended strings.Builder.
The function was last touched before strings.Builder was introduced
in Go 1.10, which explains the old style code. This PR updates
the implementation.

Fixes #45392

Change-Id: Id2d8f1788765a0c4faaeb1e6870914f72b3c8442
GitHub-Last-Rev: 0e12fe304593afc627fc4f1597670efd354809b0
GitHub-Pull-Request: golang/go#45393
Reviewed-on: https://go-review.googlesource.com/c/go/+/307329
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Josh Bleecher Snyder <josharian@gmail.com>
---
 src/flag/flag.go | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/src/flag/flag.go b/src/flag/flag.go
index f7598a6758..885a4c8369 100644
--- a/src/flag/flag.go
+++ b/src/flag/flag.go
@@ -508,31 +508,33 @@ func UnquoteUsage(flag *Flag) (name string, usage string) {
 // documentation for the global function PrintDefaults for more information.
 func (f *FlagSet) PrintDefaults() {
 	f.VisitAll(func(flag *Flag) {
-		s := fmt.Sprintf("  -%s", flag.Name) // Two spaces before -; see next two comments.
+		var b strings.Builder
+		fmt.Fprintf(&b, "  -%s", flag.Name) // Two spaces before -; see next two comments.
 		name, usage := UnquoteUsage(flag)
 		if len(name) > 0 {
-			s += " " + name
+			b.WriteString(" ")
+			b.WriteString(name)
 		}
 		// Boolean flags of one ASCII letter are so common we
 		// treat them specially, putting their usage on the same line.
-		if len(s) <= 4 { // space, space, '-', 'x'.
-			s += "\t"
+		if b.Len() <= 4 { // space, space, '-', 'x'.
+			b.WriteString("\t")
 		} else {
 			// Four spaces before the tab triggers good alignment
 			// for both 4- and 8-space tab stops.
-			s += "\n    \t"
+			b.WriteString("\n    \t")
 		}
-		s += strings.ReplaceAll(usage, "\n", "\n    \t")
+		b.WriteString(strings.ReplaceAll(usage, "\n", "\n    \t"))
 
 		if !isZeroValue(flag, flag.DefValue) {
 			if _, ok := flag.Value.(*stringValue); ok {
 				// put quotes on the value
-				s += fmt.Sprintf(" (default %q)", flag.DefValue)
+				fmt.Fprintf(&b, " (default %q)", flag.DefValue)
 			} else {
-				s += fmt.Sprintf(" (default %v)", flag.DefValue)
+				fmt.Fprintf(&b, " (default %v)", flag.DefValue)
 			}
 		}
-		fmt.Fprint(f.Output(), s, "\n")
+		fmt.Fprint(f.Output(), b.String(), "\n")
 	})
 }
 
-- 
GitLab


From 79b2e14b1a08d5c5a6a6153c5fa85b6cab0fcbf4 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Wed, 24 Mar 2021 14:41:25 +0100
Subject: [PATCH 1380/2400] crypto/ed25519: add comprehensive edge-case test
 vectors

This will allow us to make changes to the internals confidently, without
risking causing issues in consensus applications. It will also prevent
architecture-specific divergence, like #40475.

Fixes #40478

Change-Id: I8c2b31406ca88add6941f14d8df8cecb96379cde
Reviewed-on: https://go-review.googlesource.com/c/go/+/304349
Run-TryBot: Filippo Valsorda <filippo@golang.org>
Reviewed-by: Roland Shoemaker <roland@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Filippo Valsorda <filippo@golang.org>
Trust: Katie Hockman <katie@golang.org>
---
 src/crypto/ed25519/ed25519vectors_test.go | 109 ++++++++++++++++++++++
 1 file changed, 109 insertions(+)
 create mode 100644 src/crypto/ed25519/ed25519vectors_test.go

diff --git a/src/crypto/ed25519/ed25519vectors_test.go b/src/crypto/ed25519/ed25519vectors_test.go
new file mode 100644
index 0000000000..74fcdcdf4e
--- /dev/null
+++ b/src/crypto/ed25519/ed25519vectors_test.go
@@ -0,0 +1,109 @@
+// Copyright 2021 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 ed25519_test
+
+import (
+	"crypto/ed25519"
+	"encoding/hex"
+	"encoding/json"
+	"internal/testenv"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+)
+
+// TestEd25519Vectors runs a very large set of test vectors that exercise all
+// combinations of low-order points, low-order components, and non-canonical
+// encodings. These vectors lock in unspecified and spec-divergent behaviors in
+// edge cases that are not security relevant in most contexts, but that can
+// cause issues in consensus applications if changed.
+//
+// Our behavior matches the "classic" unwritten verification rules of the
+// "ref10" reference implementation.
+//
+// Note that although we test for these edge cases, they are not covered by the
+// Go 1 Compatibility Promise. Applications that need stable verification rules
+// should use github.com/hdevalence/ed25519consensus.
+//
+// See https://hdevalence.ca/blog/2020-10-04-its-25519am for more details.
+func TestEd25519Vectors(t *testing.T) {
+	jsonVectors := downloadEd25519Vectors(t)
+	var vectors []struct {
+		A, R, S, M string
+		Flags      []string
+	}
+	if err := json.Unmarshal(jsonVectors, &vectors); err != nil {
+		t.Fatal(err)
+	}
+	for i, v := range vectors {
+		expectedToVerify := true
+		for _, f := range v.Flags {
+			switch f {
+			// We use the simplified verification formula that doesn't multiply
+			// by the cofactor, so any low order residue will cause the
+			// signature not to verify.
+			//
+			// This is allowed, but not required, by RFC 8032.
+			case "LowOrderResidue":
+				expectedToVerify = false
+			// Our point decoding allows non-canonical encodings (in violation
+			// of RFC 8032) but R is not decoded: instead, R is recomputed and
+			// compared bytewise against the canonical encoding.
+			case "NonCanonicalR":
+				expectedToVerify = false
+			}
+		}
+
+		publicKey := decodeHex(t, v.A)
+		signature := append(decodeHex(t, v.R), decodeHex(t, v.S)...)
+		message := []byte(v.M)
+
+		didVerify := ed25519.Verify(publicKey, message, signature)
+		if didVerify && !expectedToVerify {
+			t.Errorf("#%d: vector with flags %s unexpectedly verified", i, v.Flags)
+		}
+		if !didVerify && expectedToVerify {
+			t.Errorf("#%d: vector with flags %s unexpectedly rejected", i, v.Flags)
+		}
+	}
+}
+
+func downloadEd25519Vectors(t *testing.T) []byte {
+	testenv.MustHaveExternalNetwork(t)
+
+	// Download the JSON test file from the GOPROXY with `go mod download`,
+	// pinning the version so test and module caching works as expected.
+	goTool := testenv.GoToolPath(t)
+	path := "filippo.io/mostly-harmless/ed25519vectors@v0.0.0-20210322192420-30a2d7243a94"
+	cmd := exec.Command(goTool, "mod", "download", "-json", path)
+	// TODO: enable the sumdb once the TryBots proxy supports it.
+	cmd.Env = append(os.Environ(), "GONOSUMDB=*")
+	output, err := cmd.Output()
+	if err != nil {
+		t.Fatalf("failed to run `go mod download -json %s`, output: %s", path, output)
+	}
+	var dm struct {
+		Dir string // absolute path to cached source root directory
+	}
+	if err := json.Unmarshal(output, &dm); err != nil {
+		t.Fatal(err)
+	}
+
+	jsonVectors, err := os.ReadFile(filepath.Join(dm.Dir, "ed25519vectors.json"))
+	if err != nil {
+		t.Fatalf("failed to read ed25519vectors.json: %v", err)
+	}
+	return jsonVectors
+}
+
+func decodeHex(t *testing.T, s string) []byte {
+	t.Helper()
+	b, err := hex.DecodeString(s)
+	if err != nil {
+		t.Errorf("invalid hex: %v", err)
+	}
+	return b
+}
-- 
GitLab


From 0723f062ff906902c44086476f95016e50164c53 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Sun, 4 Apr 2021 12:59:49 -0400
Subject: [PATCH 1381/2400] cmd/compile: enable panic+recover adjustment for
 some ABI wrappers

For most ABI wrappers we don't need it because we're never going
to defer an ABI wrapper for a function that then recovers, so
that's would just be unnecessary code in the ABI wrapper.

However, for functions that could be on the path of invoking a
deferred function that can recover (runtime.reflectcall,
reflect.callReflect, and reflect.callMethod), we do want the
panic+recover adjustment. Set the Wrapper flag for them.

Currently, those functions are defined as ABIInternal to avoid
the ABI wrappers. But the assembly code still follows ABI0
calling convention, which would not work with the register-based
calling convention. In particlar, it is not possible to make
runtime.reflectcall ABIInternal, because it tail calls
runtime.callNN functions, which are splittable. Later CLs will
make them ABI0 and use the wrappers.

Updates #40724.

Change-Id: Ic7a45bbc6f726d29b5cb4932951a9d71578dcaf6
Reviewed-on: https://go-review.googlesource.com/c/go/+/307236
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Austin Clements <austin@google.com>
---
 src/cmd/compile/internal/ssagen/abi.go | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/abi.go b/src/cmd/compile/internal/ssagen/abi.go
index ecd6a32eb3..9229d0212c 100644
--- a/src/cmd/compile/internal/ssagen/abi.go
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -393,10 +393,20 @@ func setupTextLSym(f *ir.Func, flag int) {
 	}
 
 	// Clumsy but important.
+	// For functions that could be on the path of invoking a deferred
+	// function that can recover (runtime.reflectcall, reflect.callReflect,
+	// and reflect.callMethod), we want the panic+recover special handling.
 	// See test/recover.go for test cases and src/reflect/value.go
 	// for the actual functions being considered.
-	if base.Ctxt.Pkgpath == "reflect" {
-		switch f.Sym().Name {
+	//
+	// runtime.reflectcall is an assembly function which tailcalls
+	// WRAPPER functions (runtime.callNN). Its ABI wrapper needs WRAPPER
+	// flag as well.
+	fnname := f.Sym().Name
+	if base.Ctxt.Pkgpath == "runtime" && fnname == "reflectcall" {
+		flag |= obj.WRAPPER
+	} else if base.Ctxt.Pkgpath == "reflect" {
+		switch fnname {
 		case "callReflect", "callMethod":
 			flag |= obj.WRAPPER
 		}
-- 
GitLab


From d446cb7cff024412c0a80c3971dac3049db9f18c Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Sun, 4 Apr 2021 12:10:32 -0400
Subject: [PATCH 1382/2400] reflect: call ABI0 callReflect/callMethod

Currently the assembly code marshals arguments in ABI0 layout.
Call the ABI0 functions. We may want to move to ABIInternal at
some point (maybe when register args is always enabled).

Updates #40724.

Change-Id: I23bb3073f3f6420a8d0c119b65ae3e577578aadb
Reviewed-on: https://go-review.googlesource.com/c/go/+/307237
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Austin Clements <austin@google.com>
---
 src/reflect/asm_amd64.s | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/reflect/asm_amd64.s b/src/reflect/asm_amd64.s
index 29693042b6..22d95f2a7e 100644
--- a/src/reflect/asm_amd64.s
+++ b/src/reflect/asm_amd64.s
@@ -43,7 +43,7 @@ TEXT ·makeFuncStub<ABIInternal>(SB),(NOSPLIT|WRAPPER),$312
 	MOVQ	AX, 16(SP)
 	LEAQ	LOCAL_REGARGS(SP), AX
 	MOVQ	AX, 24(SP)
-	CALL	·callReflect<ABIInternal>(SB)
+	CALL	·callReflect(SB)
 	LEAQ	LOCAL_REGARGS(SP), R12
 	CALL	runtime·unspillArgs<ABIInternal>(SB)
 	RET
@@ -71,7 +71,7 @@ TEXT ·methodValueCall<ABIInternal>(SB),(NOSPLIT|WRAPPER),$312
 	MOVQ	AX, 16(SP)
 	LEAQ	LOCAL_REGARGS(SP), AX
 	MOVQ	AX, 24(SP)
-	CALL	·callMethod<ABIInternal>(SB)
+	CALL	·callMethod(SB)
 	LEAQ	LOCAL_REGARGS(SP), R12
 	CALL	runtime·unspillArgs<ABIInternal>(SB)
 	RET
-- 
GitLab


From b2389ad3ce7254784db5f4005805714e87ffab85 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Mon, 5 Apr 2021 16:50:38 -0400
Subject: [PATCH 1383/2400] cmd/compile: fix for zerorange on plan9-amd64

In CL 305829 a problematic change was made to the compiler's
amd64-specific "zerorange" function. In zerorange the compiler uses
different sets of strategies depending on the size of the stack frame
it needs to zero; turns out that only on plan9-amd64 was it hitting
the final fallback strategy, which is a REPSTOSQ instruction. REPSTOSQ
takes RAX as an input, hence the changes made in CL 305829 (switching
to R13) were incorrect.

This patch restores the zerorange REPSTOSQ sequence (back to use RAX).
This is going to be an interim solution, since long term we need to
avoid touching RAX in the function prolog (since if the new register
ABI is in effect, it will hold a live value).

Fixes #45372.

Change-Id: Ic89a6a2a76d6e03b9fbda99275101e96b70fdf5d
Reviewed-on: https://go-review.googlesource.com/c/go/+/307469
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David du Colombier <0intro@gmail.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/amd64/ggen.go | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/amd64/ggen.go b/src/cmd/compile/internal/amd64/ggen.go
index e56ec90dc8..f065bb4dd4 100644
--- a/src/cmd/compile/internal/amd64/ggen.go
+++ b/src/cmd/compile/internal/amd64/ggen.go
@@ -58,6 +58,7 @@ func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.
 	const (
 		r13 = 1 << iota // if R13 is already zeroed.
 		x15             // if X15 is already zeroed. Note: in new ABI, X15 is always zero.
+		rax             // if RAX is already zeroed.
 	)
 
 	if cnt == 0 {
@@ -116,9 +117,12 @@ func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.
 		p = pp.Append(p, x86.AMOVQ, obj.TYPE_REG, x86.REG_R12, 0, obj.TYPE_REG, x86.REG_DI, 0)
 
 	} else {
-		if *state&r13 == 0 {
-			p = pp.Append(p, x86.AMOVQ, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_R13, 0)
-			*state |= r13
+		// Note: here we have to use RAX since it is an implicit input
+		// for the REPSTOSQ below. This is going to be problematic when
+		// regabi is in effect; this will be fixed in a forthcoming CL.
+		if *state&rax == 0 {
+			p = pp.Append(p, x86.AMOVQ, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
+			*state |= rax
 		}
 
 		p = pp.Append(p, x86.AMOVQ, obj.TYPE_CONST, 0, cnt/int64(types.RegSize), obj.TYPE_REG, x86.REG_CX, 0)
-- 
GitLab


From 298975c634758ee464dc0629402107bfc33c4b41 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Mon, 5 Apr 2021 19:13:34 +0000
Subject: [PATCH 1384/2400] runtime: use funcID to identify abort in isAbortPC

This change eliminates the use of funcPC to determine if an PC is in
abort. Using funcPC for this purpose is problematic when using plugins
because symbols no longer have unique PCs. funcPC also grabs the wrapper
for runtime.abort which isn't what we want for the new register ABI, so
rather than mark runtime.abort as ABIInternal, use funcID.

For #40724.

Change-Id: I2730e99fe6f326d22d64a10384828b94f04d101a
Reviewed-on: https://go-review.googlesource.com/c/go/+/307391
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Austin Clements <austin@google.com>
---
 src/cmd/internal/objabi/funcid.go |  2 ++
 src/runtime/panic.go              |  6 +++++-
 src/runtime/symtab.go             | 13 +++++++++++++
 3 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/src/cmd/internal/objabi/funcid.go b/src/cmd/internal/objabi/funcid.go
index fa28609e4d..4229ae2c02 100644
--- a/src/cmd/internal/objabi/funcid.go
+++ b/src/cmd/internal/objabi/funcid.go
@@ -24,6 +24,7 @@ type FuncID uint8
 // Note: this list must match the list in runtime/symtab.go.
 const (
 	FuncID_normal FuncID = iota // not a special function
+	FuncID_abort
 	FuncID_asmcgocall
 	FuncID_asyncPreempt
 	FuncID_cgocallback
@@ -49,6 +50,7 @@ const (
 )
 
 var funcIDs = map[string]FuncID{
+	"abort":                 FuncID_abort,
 	"asmcgocall":            FuncID_asmcgocall,
 	"asyncPreempt":          FuncID_asyncPreempt,
 	"cgocallback":           FuncID_cgocallback,
diff --git a/src/runtime/panic.go b/src/runtime/panic.go
index bbf3ea473a..d33441a0d8 100644
--- a/src/runtime/panic.go
+++ b/src/runtime/panic.go
@@ -1484,5 +1484,9 @@ func shouldPushSigpanic(gp *g, pc, lr uintptr) bool {
 //
 //go:nosplit
 func isAbortPC(pc uintptr) bool {
-	return pc == funcPC(abort) || ((GOARCH == "arm" || GOARCH == "arm64") && pc == funcPC(abort)+sys.PCQuantum)
+	f := findfunc(pc)
+	if !f.valid() {
+		return false
+	}
+	return f.funcID == funcID_abort
 }
diff --git a/src/runtime/symtab.go b/src/runtime/symtab.go
index 8430ca87ec..3d1f6126a6 100644
--- a/src/runtime/symtab.go
+++ b/src/runtime/symtab.go
@@ -310,6 +310,7 @@ type funcID uint8
 
 const (
 	funcID_normal funcID = iota // not a special function
+	funcID_abort
 	funcID_asmcgocall
 	funcID_asyncPreempt
 	funcID_cgocallback
@@ -669,6 +670,12 @@ func (f *Func) FileLine(pc uintptr) (file string, line int) {
 	return file, int(line32)
 }
 
+// findmoduledatap looks up the moduledata for a PC.
+//
+// It is nosplit because it's part of the isgoexception
+// implementation.
+//
+//go:nosplit
 func findmoduledatap(pc uintptr) *moduledata {
 	for datap := &firstmoduledata; datap != nil; datap = datap.next {
 		if datap.minpc <= pc && pc < datap.maxpc {
@@ -691,6 +698,12 @@ func (f funcInfo) _Func() *Func {
 	return (*Func)(unsafe.Pointer(f._func))
 }
 
+// findfunc looks up function metadata for a PC.
+//
+// It is nosplit because it's part of the isgoexception
+// implementation.
+//
+//go:nosplit
 func findfunc(pc uintptr) funcInfo {
 	datap := findmoduledatap(pc)
 	if datap == nil {
-- 
GitLab


From d8306ee1f9a3221b2a70663a3d127d72c17df05e Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Fri, 2 Apr 2021 20:46:35 +0000
Subject: [PATCH 1385/2400] runtime: make reflectcall ABI0 on amd64

reflectcall expects the ABI0 calling convention, but it's marked as
ABIInternal. When it gets called this way, naturally it doesn't work
very well.

For #40724.

Change-Id: Ic76237420cd8c72f5df1c1ac7972ad6f989f8402
Reviewed-on: https://go-review.googlesource.com/c/go/+/306931
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/asm_amd64.s | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index dbe7f7f381..c245fce7ef 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -550,7 +550,7 @@ TEXT ·unspillArgs<ABIInternal>(SB),NOSPLIT,$0-0
 	JMP	AX
 // Note: can't just "JMP NAME(SB)" - bad inlining results.
 
-TEXT ·reflectcall<ABIInternal>(SB), NOSPLIT, $0-48
+TEXT ·reflectcall(SB), NOSPLIT, $0-48
 	MOVLQZX frameSize+32(FP), CX
 	DISPATCH(runtime·call16, 16)
 	DISPATCH(runtime·call32, 32)
-- 
GitLab


From a25c58462992704dbb6819769f530b6cc6a8ebe3 Mon Sep 17 00:00:00 2001
From: Charlie Moog <moogcharlie@gmail.com>
Date: Wed, 24 Mar 2021 19:17:03 -0500
Subject: [PATCH 1386/2400] os: implement fs.StatFS for os.DirFS

Change-Id: I1d7382bf522aeda7148431b348f6ab9a162be097
Reviewed-on: https://go-review.googlesource.com/c/go/+/304531
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Robert Griesemer <gri@golang.org>
---
 src/os/file.go | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/os/file.go b/src/os/file.go
index ebeb0d0ac9..e717f171e7 100644
--- a/src/os/file.go
+++ b/src/os/file.go
@@ -651,6 +651,17 @@ func (dir dirFS) Open(name string) (fs.File, error) {
 	return f, nil
 }
 
+func (dir dirFS) Stat(name string) (fs.FileInfo, error) {
+	if !fs.ValidPath(name) || runtime.GOOS == "windows" && containsAny(name, `\:`) {
+		return nil, &PathError{Op: "stat", Path: name, Err: ErrInvalid}
+	}
+	f, err := Stat(string(dir) + "/" + name)
+	if err != nil {
+		return nil, err
+	}
+	return f, nil
+}
+
 // ReadFile reads the named file and returns the contents.
 // A successful call returns err == nil, not err == EOF.
 // Because ReadFile reads the whole file, it does not treat an EOF from Read
-- 
GitLab


From 84162b88324aa7993fe4a8580a2b65c6a7055f88 Mon Sep 17 00:00:00 2001
From: cui <cuiweixie@gmail.com>
Date: Tue, 6 Apr 2021 03:26:35 +0000
Subject: [PATCH 1387/2400] cmd/compile/internal/typecheck: call tcConv
 directly

Change-Id: I9f71acfa93c47cff620b006918872ecd90bbebe9
GitHub-Last-Rev: 2fed2e23054d75f7a743f9c5a6e5574a545e3080
GitHub-Pull-Request: golang/go#45366
Reviewed-on: https://go-review.googlesource.com/c/go/+/307109
Reviewed-by: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/cmd/compile/internal/typecheck/func.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index 86058a0c73..bc31284a85 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -459,7 +459,7 @@ func tcCall(n *ir.CallExpr, top int) ir.Node {
 
 		n := ir.NewConvExpr(n.Pos(), ir.OCONV, nil, arg)
 		n.SetType(l.Type())
-		return typecheck1(n, top)
+		return tcConv(n)
 	}
 
 	typecheckargs(n)
-- 
GitLab


From 5cd8a344954cc29be9bce6d67b3f4293ed72aa9f Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Mon, 5 Apr 2021 20:03:02 -0700
Subject: [PATCH 1388/2400] cmd/compile: fix gcSizes.Sizeof for a zero-sized
 struct

(*gcSizes).Sizeof was requiring the last field of a zero-sized struct to
be at least one byte. But that rule (fix for #9401, see logic in
calcStructOffset) only applies to a struct that has some non-zero sized
fields. Fix (*gcSizes).Sizeof to have the logic like calcStructOffset.

Fixes running the gotests with -G=3 enabled.

Fixes #45390

Change-Id: I011f40e3de3a327392bbbb791b9422be75336313
Reviewed-on: https://go-review.googlesource.com/c/go/+/307549
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/noder/sizes.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/noder/sizes.go b/src/cmd/compile/internal/noder/sizes.go
index 7cda6da9a6..23f2062675 100644
--- a/src/cmd/compile/internal/noder/sizes.go
+++ b/src/cmd/compile/internal/noder/sizes.go
@@ -115,10 +115,10 @@ func (s *gcSizes) Sizeof(T types2.Type) int64 {
 		}
 		offsets := s.Offsetsof(fields)
 
-		// gc: The last field of a struct is not allowed to
+		// gc: The last field of a non-zero-sized struct is not allowed to
 		// have size 0.
 		last := s.Sizeof(fields[n-1].Type())
-		if last == 0 {
+		if last == 0 && offsets[n-1] > 0 {
 			last = 1
 		}
 
-- 
GitLab


From 939b561a6e36d9b3854d860a80c24dc80f01f6be Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Tue, 9 Mar 2021 16:55:08 -0600
Subject: [PATCH 1389/2400] cmd/internal/obj: reorg ppc64 MOV* optab entries
 and remove unused classes

C_LECON and C_SECON classifications are not generated on ppc64, however
there are many optab entries which match against them. Remove them to
resolve their related TODOs.

Likewise, reorder the optab entries for better readability.

Change-Id: I894a209a148014e5aa438b7303e7fbdda4727c4e
Reviewed-on: https://go-review.googlesource.com/c/go/+/307429
Run-TryBot: Paul Murphy <murp@ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Carlos Eduardo Seo <carlos.seo@linaro.org>
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
Trust: Carlos Eduardo Seo <carlos.seo@linaro.org>
---
 src/cmd/internal/obj/ppc64/a.out.go   |  6 +-
 src/cmd/internal/obj/ppc64/anames9.go |  2 -
 src/cmd/internal/obj/ppc64/asm9.go    | 97 +++++++++++++--------------
 3 files changed, 48 insertions(+), 57 deletions(-)

diff --git a/src/cmd/internal/obj/ppc64/a.out.go b/src/cmd/internal/obj/ppc64/a.out.go
index 59777803be..2ae3a21e05 100644
--- a/src/cmd/internal/obj/ppc64/a.out.go
+++ b/src/cmd/internal/obj/ppc64/a.out.go
@@ -368,10 +368,8 @@ const (
 	C_LCON   /* other 32 */
 	C_DCON   /* other 64 (could subdivide further) */
 	C_SACON  /* $n(REG) where n <= int16 */
-	C_SECON
-	C_LACON /* $n(REG) where int16 < n <= int32 */
-	C_LECON
-	C_DACON /* $n(REG) where int32 < n */
+	C_LACON  /* $n(REG) where int16 < n <= int32 */
+	C_DACON  /* $n(REG) where int32 < n */
 	C_SBRA
 	C_LBRA
 	C_LBRAPIC
diff --git a/src/cmd/internal/obj/ppc64/anames9.go b/src/cmd/internal/obj/ppc64/anames9.go
index 7e93e6a15a..8b9b708458 100644
--- a/src/cmd/internal/obj/ppc64/anames9.go
+++ b/src/cmd/internal/obj/ppc64/anames9.go
@@ -20,9 +20,7 @@ var cnames9 = []string{
 	"LCON",
 	"DCON",
 	"SACON",
-	"SECON",
 	"LACON",
-	"LECON",
 	"DACON",
 	"SBRA",
 	"LBRA",
diff --git a/src/cmd/internal/obj/ppc64/asm9.go b/src/cmd/internal/obj/ppc64/asm9.go
index f169c326d8..b83489a5a6 100644
--- a/src/cmd/internal/obj/ppc64/asm9.go
+++ b/src/cmd/internal/obj/ppc64/asm9.go
@@ -205,84 +205,93 @@ var optab = []Optab{
 
 	{as: AMOVB, a1: C_ADDR, a6: C_REG, type_: 76, size: 12},
 	{as: AMOVB, a1: C_LOREG, a6: C_REG, type_: 37, size: 12},
+	{as: AMOVB, a1: C_SOREG, a6: C_REG, type_: 9, size: 8},
 	{as: AMOVB, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
+	{as: AMOVB, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVB, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
 	{as: AMOVB, a1: C_REG, a6: C_REG, type_: 12, size: 4},
-	{as: AMOVB, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
-	{as: AMOVB, a1: C_SOREG, a6: C_REG, type_: 9, size: 8},
 
 	{as: AMOVBZ, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
 	{as: AMOVBZ, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
+	{as: AMOVBZ, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
 	{as: AMOVBZ, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
+	{as: AMOVBZ, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVBZ, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
 	{as: AMOVBZ, a1: C_REG, a6: C_REG, type_: 13, size: 4},
-	{as: AMOVBZ, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
-	{as: AMOVBZ, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
 
 	{as: AMOVD, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVD, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
 	{as: AMOVD, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVD, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVD, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVD, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
+	{as: AMOVD, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
 	{as: AMOVD, a1: C_GOTADDR, a6: C_REG, type_: 81, size: 8},
 	{as: AMOVD, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
-	{as: AMOVD, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
-	{as: AMOVD, a1: C_LECON, a6: C_REG, type_: 26, size: 8},
+	{as: AMOVD, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
 	{as: AMOVD, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
+	{as: AMOVD, a1: C_TLS_LE, a6: C_REG, type_: 79, size: 4},
+	{as: AMOVD, a1: C_TLS_IE, a6: C_REG, type_: 80, size: 8},
+	{as: AMOVD, a1: C_TOCADDR, a6: C_REG, type_: 95, size: 8},
+	{as: AMOVD, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
 	{as: AMOVD, a1: C_MSR, a6: C_REG, type_: 54, size: 4}, /* mfmsr */
 	{as: AMOVD, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
+	{as: AMOVD, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVD, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
 	{as: AMOVD, a1: C_REG, a6: C_MSR, type_: 54, size: 4}, /* mtmsrd */
-	{as: AMOVD, a1: C_REG, a6: C_REG, type_: 1, size: 4},
-	{as: AMOVD, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVD, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
-	{as: AMOVD, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVD, a1: C_SECON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVD, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
-	{as: AMOVD, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
-	{as: AMOVD, a1: C_TLS_IE, a6: C_REG, type_: 80, size: 8},
-	{as: AMOVD, a1: C_TLS_LE, a6: C_REG, type_: 79, size: 4},
-	{as: AMOVD, a1: C_TOCADDR, a6: C_REG, type_: 95, size: 8},
-	{as: AMOVD, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVD, a1: C_REG, a6: C_REG, type_: 1, size: 4},
 
 	{as: AMOVW, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVW, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
 	{as: AMOVW, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVW, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVW, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVW, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
+	{as: AMOVW, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
 	{as: AMOVW, a1: C_CREG, a6: C_REG, type_: 68, size: 4},
 	{as: AMOVW, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
-	{as: AMOVW, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
-	{as: AMOVW, a1: C_LECON, a6: C_REG, type_: 26, size: 8},
+	{as: AMOVW, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
 	{as: AMOVW, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
+	{as: AMOVW, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
 	{as: AMOVW, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 	{as: AMOVW, a1: C_REG, a6: C_CREG, type_: 69, size: 4},
-	{as: AMOVW, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
-	{as: AMOVW, a1: C_REG, a6: C_REG, type_: 12, size: 4},
 	{as: AMOVW, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
+	{as: AMOVW, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
 	{as: AMOVW, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
-	{as: AMOVW, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVW, a1: C_SECON, a6: C_REG, type_: 3, size: 4}, /* TO DO: check */
-	{as: AMOVW, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
-	{as: AMOVW, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
-	{as: AMOVW, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVW, a1: C_REG, a6: C_REG, type_: 12, size: 4},
 
 	{as: AMOVWZ, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVWZ, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
 	{as: AMOVWZ, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVWZ, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVWZ, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVWZ, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
+	{as: AMOVWZ, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
 	{as: AMOVWZ, a1: C_CREG, a6: C_REG, type_: 68, size: 4},
 	{as: AMOVWZ, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
-	{as: AMOVWZ, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
-	{as: AMOVWZ, a1: C_LECON, a6: C_REG, type_: 26, size: 8},
+	{as: AMOVWZ, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
 	{as: AMOVWZ, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
+	{as: AMOVWZ, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
 	{as: AMOVWZ, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 	{as: AMOVWZ, a1: C_REG, a6: C_CREG, type_: 69, size: 4},
+	{as: AMOVWZ, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVWZ, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
 	{as: AMOVWZ, a1: C_REG, a6: C_MSR, type_: 54, size: 4}, /* mtmsr */
-	{as: AMOVWZ, a1: C_REG, a6: C_REG, type_: 13, size: 4},
-	{as: AMOVWZ, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVWZ, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
-	{as: AMOVWZ, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVWZ, a1: C_SECON, a6: C_REG, type_: 3, size: 4}, /* TO DO: check */
-	{as: AMOVWZ, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
-	{as: AMOVWZ, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
-	{as: AMOVWZ, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVWZ, a1: C_REG, a6: C_REG, type_: 13, size: 4},
+
+	{as: AFMOVD, a1: C_ADDCON, a6: C_FREG, type_: 24, size: 8},
+	{as: AFMOVD, a1: C_SOREG, a6: C_FREG, type_: 8, size: 4},
+	{as: AFMOVD, a1: C_LOREG, a6: C_FREG, type_: 36, size: 8},
+	{as: AFMOVD, a1: C_ZCON, a6: C_FREG, type_: 24, size: 4},
+	{as: AFMOVD, a1: C_ADDR, a6: C_FREG, type_: 75, size: 8},
+	{as: AFMOVD, a1: C_FREG, a6: C_FREG, type_: 33, size: 4},
+	{as: AFMOVD, a1: C_FREG, a6: C_SOREG, type_: 7, size: 4},
+	{as: AFMOVD, a1: C_FREG, a6: C_LOREG, type_: 35, size: 8},
+	{as: AFMOVD, a1: C_FREG, a6: C_ADDR, type_: 74, size: 8},
+
+	{as: AFMOVSX, a1: C_ZOREG, a6: C_FREG, type_: 45, size: 4},
+	{as: AFMOVSX, a1: C_FREG, a6: C_ZOREG, type_: 44, size: 4},
+
+	{as: AFMOVSZ, a1: C_ZOREG, a6: C_FREG, type_: 45, size: 4},
 
 	{as: AMOVFL, a1: C_CREG, a6: C_CREG, type_: 67, size: 4},
 	{as: AMOVFL, a1: C_FPSCR, a6: C_CREG, type_: 73, size: 4},
@@ -312,18 +321,6 @@ var optab = []Optab{
 	{as: ABC, a1: C_SCON, a2: C_REG, a6: C_LR, type_: 18, size: 4},
 	{as: ABC, a1: C_SCON, a2: C_REG, a6: C_CTR, type_: 18, size: 4},
 	{as: ABC, a6: C_ZOREG, type_: 15, size: 8},
-	{as: AFMOVD, a1: C_FREG, a6: C_FREG, type_: 33, size: 4},
-	{as: AFMOVD, a1: C_SOREG, a6: C_FREG, type_: 8, size: 4},
-	{as: AFMOVD, a1: C_LOREG, a6: C_FREG, type_: 36, size: 8},
-	{as: AFMOVD, a1: C_ZCON, a6: C_FREG, type_: 24, size: 4},
-	{as: AFMOVD, a1: C_ADDCON, a6: C_FREG, type_: 24, size: 8},
-	{as: AFMOVD, a1: C_ADDR, a6: C_FREG, type_: 75, size: 8},
-	{as: AFMOVD, a1: C_FREG, a6: C_SOREG, type_: 7, size: 4},
-	{as: AFMOVD, a1: C_FREG, a6: C_LOREG, type_: 35, size: 8},
-	{as: AFMOVD, a1: C_FREG, a6: C_ADDR, type_: 74, size: 8},
-	{as: AFMOVSX, a1: C_ZOREG, a6: C_FREG, type_: 45, size: 4},
-	{as: AFMOVSX, a1: C_FREG, a6: C_ZOREG, type_: 44, size: 4},
-	{as: AFMOVSZ, a1: C_ZOREG, a6: C_FREG, type_: 45, size: 4},
 	{as: ASYNC, type_: 46, size: 4},
 	{as: AWORD, a1: C_LCON, type_: 40, size: 4},
 	{as: ADWORD, a1: C_LCON, type_: 31, size: 8},
@@ -604,8 +601,6 @@ func (c *ctxt9) getimpliedreg(a *obj.Addr, p *obj.Prog) int {
 	switch oclass(a) {
 	case C_ADDCON, C_ANDCON, C_UCON, C_LCON, C_SCON, C_ZCON:
 		return REGZERO
-	case C_SECON, C_LECON:
-		return REGSB
 	case C_SACON, C_LACON:
 		return REGSP
 	case C_LOREG, C_SOREG, C_ZOREG:
-- 
GitLab


From b345a306a0258085b65081cf2dadc238dc7e26ee Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Mon, 5 Apr 2021 20:41:56 -0400
Subject: [PATCH 1390/2400] cmd/compile: when GOSSAFUNC is set, dump the
 current pass on crash

When an SSA pass ICEs, it calls f.Fatalf, which terminates the
compiler. When GOSSAFUNC is set, the current pass is not written
to ssa.html. This CL makes it write ssa.html when it calls Fatalf,
for the ease of debugging.

Change-Id: I5d55e4258f0693d89c48c0a84984f2f893b0811d
Reviewed-on: https://go-review.googlesource.com/c/go/+/307509
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/ssa/func.go | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go
index ebbcea598b..819d7573d6 100644
--- a/src/cmd/compile/internal/ssa/func.go
+++ b/src/cmd/compile/internal/ssa/func.go
@@ -653,7 +653,19 @@ func (f *Func) Frontend() Frontend                                  { return f.f
 func (f *Func) Warnl(pos src.XPos, msg string, args ...interface{}) { f.fe.Warnl(pos, msg, args...) }
 func (f *Func) Logf(msg string, args ...interface{})                { f.fe.Logf(msg, args...) }
 func (f *Func) Log() bool                                           { return f.fe.Log() }
-func (f *Func) Fatalf(msg string, args ...interface{})              { f.fe.Fatalf(f.Entry.Pos, msg, args...) }
+
+func (f *Func) Fatalf(msg string, args ...interface{}) {
+	stats := "crashed"
+	if f.Log() {
+		f.Logf("  pass %s end %s\n", f.pass.name, stats)
+		printFunc(f)
+	}
+	if f.HTMLWriter != nil {
+		f.HTMLWriter.WritePhase(f.pass.name, fmt.Sprintf("%s <span class=\"stats\">%s</span>", f.pass.name, stats))
+		f.HTMLWriter.flushPhases()
+	}
+	f.fe.Fatalf(f.Entry.Pos, msg, args...)
+}
 
 // postorder returns the reachable blocks in f in a postorder traversal.
 func (f *Func) postorder() []*Block {
-- 
GitLab


From 55bac87bd690d5812b3e6640977a0568f14c0715 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 6 Apr 2021 10:23:48 -0400
Subject: [PATCH 1391/2400] runtime/pprof: deflake TestMorestack

In TestMorestack, on macOS, for some reason it got most of the
samples in synchronization (e.g. pthread_cond_signal and
pthread_cond_wait) and sometimes in other "syscalls" (usleep,
nanotime1), and very few samples in stack copying, sometimes 0,
which causes the test to fail. Maybe synchronization is slower on
macOS? (It doesn't seem so to me.) Or it is the OS's accounting
problem, where it is more likely to trigger a profiling signal
at a syscall (or certain kinds of syscalls)?

As the test is really about whether it can connect stack copying
with the function that grows the stack, this CL makes it spend
more time in copying stack than synchronization. Now it's getting
~100 samples for stack copying on a 5 second interval on my
machine, and the test passes reliably.

Fixes #44418.

Change-Id: I3a462c8c39766f2d67d697598f8641bbe64f16ad
Reviewed-on: https://go-review.googlesource.com/c/go/+/307730
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
---
 src/runtime/pprof/pprof_test.go | 24 +++++++-----------------
 1 file changed, 7 insertions(+), 17 deletions(-)

diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go
index e6b4d0044d..3423f8dc3d 100644
--- a/src/runtime/pprof/pprof_test.go
+++ b/src/runtime/pprof/pprof_test.go
@@ -12,7 +12,6 @@ import (
 	"context"
 	"fmt"
 	"internal/profile"
-	"internal/race"
 	"internal/testenv"
 	"io"
 	"math/big"
@@ -586,18 +585,6 @@ func stackContainsAll(spec string, count uintptr, stk []*profile.Location, label
 }
 
 func TestMorestack(t *testing.T) {
-	if runtime.GOOS == "darwin" && race.Enabled {
-		// For whatever reason, using the race detector on macOS keeps us
-		// from finding the newstack/growstack calls in the profile.
-		// Not worth worrying about.
-		// https://build.golang.org/log/280d387327806e17c8aabeb38b9503dbbd942ed1
-		t.Skip("skipping on darwin race detector")
-	}
-	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
-		// For whatever reason, darwin/arm64 also doesn't work.
-		// https://build.golang.org/log/c45e82cc25f152642e6fb90d882ef5a8cd130ce5
-		t.Skip("skipping on darwin/arm64")
-	}
 	testCPUProfile(t, stackContainsAll, []string{"runtime.newstack,runtime/pprof.growstack"}, avoidFunctions(), func(duration time.Duration) {
 		t := time.After(duration)
 		c := make(chan bool)
@@ -617,17 +604,20 @@ func TestMorestack(t *testing.T) {
 
 //go:noinline
 func growstack1() {
-	growstack()
+	growstack(10)
 }
 
 //go:noinline
-func growstack() {
-	var buf [8 << 10]byte
+func growstack(n int) {
+	var buf [8 << 16]byte
 	use(buf)
+	if n > 0 {
+		growstack(n - 1)
+	}
 }
 
 //go:noinline
-func use(x [8 << 10]byte) {}
+func use(x [8 << 16]byte) {}
 
 func TestBlockProfile(t *testing.T) {
 	type TestCase struct {
-- 
GitLab


From d57189e92b9b4cd6909aefbcee02e9cb6fc05cff Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 6 Apr 2021 11:36:36 -0700
Subject: [PATCH 1392/2400] test/syntax: remove interface.go

The exact same test case covered by this file is also in
fixedbugs/bug121.go. No need for duplication.

Also, the actual syntax error tested (multiple method names
with a single signature) is an unlikely syntax error, and
only here for historical reasons (in the very beginning, this
was actually possible to write). Now, virtually nobody is making
this mistake.

Change-Id: I9d68e0aee2a63025f44e6338647f8250ecc3077a
Reviewed-on: https://go-review.googlesource.com/c/go/+/307789
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 test/syntax/interface.go | 14 --------------
 1 file changed, 14 deletions(-)
 delete mode 100644 test/syntax/interface.go

diff --git a/test/syntax/interface.go b/test/syntax/interface.go
deleted file mode 100644
index 010d3ce578..0000000000
--- a/test/syntax/interface.go
+++ /dev/null
@@ -1,14 +0,0 @@
-// errorcheck
-
-// Copyright 2010 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
-
-type T interface {
-	f, g ()	// ERROR "name list not allowed in interface type"
-}
-
-
-
-- 
GitLab


From 93466cc1b697836200e73bb103522324d38e894f Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 29 Mar 2021 15:15:56 -0700
Subject: [PATCH 1393/2400] cmd/compile/internal/types2: review of pos.go and
 move into syntax package

This moves the two helper functions startPos and endPos into
the syntax package where they belong. Export the functions and
adjust dependent code.

Change-Id: I8170faeadd7cfa8f53009f81fcffd50ec0fc6a98
Reviewed-on: https://go-review.googlesource.com/c/go/+/305578
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 .../{types2/pos.go => syntax/positions.go}    | 230 +++++++++---------
 .../compile/internal/types2/assignments.go    |   2 +-
 src/cmd/compile/internal/types2/decl.go       |   4 +-
 src/cmd/compile/internal/types2/errors.go     |   4 +-
 src/cmd/compile/internal/types2/expr.go       |   2 +-
 src/cmd/compile/internal/types2/labels.go     |   2 +-
 src/cmd/compile/internal/types2/resolver.go   |   2 +-
 src/cmd/compile/internal/types2/stmt.go       |  10 +-
 src/cmd/compile/internal/types2/typexpr.go    |   4 +-
 9 files changed, 128 insertions(+), 132 deletions(-)
 rename src/cmd/compile/internal/{types2/pos.go => syntax/positions.go} (52%)

diff --git a/src/cmd/compile/internal/types2/pos.go b/src/cmd/compile/internal/syntax/positions.go
similarity index 52%
rename from src/cmd/compile/internal/types2/pos.go
rename to src/cmd/compile/internal/syntax/positions.go
index 955bb2ad08..b00f86c67c 100644
--- a/src/cmd/compile/internal/types2/pos.go
+++ b/src/cmd/compile/internal/syntax/positions.go
@@ -1,16 +1,13 @@
-// UNREVIEWED
-// Copyright 2012 The Go Authors. All rights reserved.
+// Copyright 2020 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.
 
 // This file implements helper functions for scope position computations.
 
-package types2
+package syntax
 
-import "cmd/compile/internal/syntax"
-
-// startPos returns the start position of n.
-func startPos(n syntax.Node) syntax.Pos {
+// StartPos returns the start position of n.
+func StartPos(n Node) Pos {
 	// Cases for nodes which don't need a correction are commented out.
 	for m := n; ; {
 		switch n := m.(type) {
@@ -18,95 +15,95 @@ func startPos(n syntax.Node) syntax.Pos {
 			panic("internal error: nil")
 
 		// packages
-		case *syntax.File:
+		case *File:
 			// file block starts at the beginning of the file
-			return syntax.MakePos(n.Pos().Base(), 1, 1)
+			return MakePos(n.Pos().Base(), 1, 1)
 
 		// declarations
-		// case *syntax.ImportDecl:
-		// case *syntax.ConstDecl:
-		// case *syntax.TypeDecl:
-		// case *syntax.VarDecl:
-		// case *syntax.FuncDecl:
+		// case *ImportDecl:
+		// case *ConstDecl:
+		// case *TypeDecl:
+		// case *VarDecl:
+		// case *FuncDecl:
 
 		// expressions
-		// case *syntax.BadExpr:
-		// case *syntax.Name:
-		// case *syntax.BasicLit:
-		case *syntax.CompositeLit:
+		// case *BadExpr:
+		// case *Name:
+		// case *BasicLit:
+		case *CompositeLit:
 			if n.Type != nil {
 				m = n.Type
 				continue
 			}
 			return n.Pos()
-		// case *syntax.KeyValueExpr:
-		// case *syntax.FuncLit:
-		// case *syntax.ParenExpr:
-		case *syntax.SelectorExpr:
+		// case *KeyValueExpr:
+		// case *FuncLit:
+		// case *ParenExpr:
+		case *SelectorExpr:
 			m = n.X
-		case *syntax.IndexExpr:
+		case *IndexExpr:
 			m = n.X
-		// case *syntax.SliceExpr:
-		case *syntax.AssertExpr:
+		// case *SliceExpr:
+		case *AssertExpr:
 			m = n.X
-		case *syntax.TypeSwitchGuard:
+		case *TypeSwitchGuard:
 			if n.Lhs != nil {
 				m = n.Lhs
 				continue
 			}
 			m = n.X
-		case *syntax.Operation:
+		case *Operation:
 			if n.Y != nil {
 				m = n.X
 				continue
 			}
 			return n.Pos()
-		case *syntax.CallExpr:
+		case *CallExpr:
 			m = n.Fun
-		case *syntax.ListExpr:
+		case *ListExpr:
 			if len(n.ElemList) > 0 {
 				m = n.ElemList[0]
 				continue
 			}
 			return n.Pos()
 		// types
-		// case *syntax.ArrayType:
-		// case *syntax.SliceType:
-		// case *syntax.DotsType:
-		// case *syntax.StructType:
-		// case *syntax.Field:
-		// case *syntax.InterfaceType:
-		// case *syntax.FuncType:
-		// case *syntax.MapType:
-		// case *syntax.ChanType:
+		// case *ArrayType:
+		// case *SliceType:
+		// case *DotsType:
+		// case *StructType:
+		// case *Field:
+		// case *InterfaceType:
+		// case *FuncType:
+		// case *MapType:
+		// case *ChanType:
 
 		// statements
-		// case *syntax.EmptyStmt:
-		// case *syntax.LabeledStmt:
-		// case *syntax.BlockStmt:
-		// case *syntax.ExprStmt:
-		case *syntax.SendStmt:
+		// case *EmptyStmt:
+		// case *LabeledStmt:
+		// case *BlockStmt:
+		// case *ExprStmt:
+		case *SendStmt:
 			m = n.Chan
-		// case *syntax.DeclStmt:
-		case *syntax.AssignStmt:
+		// case *DeclStmt:
+		case *AssignStmt:
 			m = n.Lhs
-		// case *syntax.BranchStmt:
-		// case *syntax.CallStmt:
-		// case *syntax.ReturnStmt:
-		// case *syntax.IfStmt:
-		// case *syntax.ForStmt:
-		// case *syntax.SwitchStmt:
-		// case *syntax.SelectStmt:
+		// case *BranchStmt:
+		// case *CallStmt:
+		// case *ReturnStmt:
+		// case *IfStmt:
+		// case *ForStmt:
+		// case *SwitchStmt:
+		// case *SelectStmt:
 
 		// helper nodes
-		case *syntax.RangeClause:
+		case *RangeClause:
 			if n.Lhs != nil {
 				m = n.Lhs
 				continue
 			}
 			m = n.X
-		// case *syntax.CaseClause:
-		// case *syntax.CommClause:
+		// case *CaseClause:
+		// case *CommClause:
 
 		default:
 			return n.Pos()
@@ -114,30 +111,29 @@ func startPos(n syntax.Node) syntax.Pos {
 	}
 }
 
-// endPos returns the approximate end position of n in the source.
-// For some nodes (*syntax.Name, *syntax.BasicLit) it returns
-// the position immediately following the node; for others
-// (*syntax.BlockStmt, *syntax.SwitchStmt, etc.) it returns
-// the position of the closing '}'; and for some (*syntax.ParenExpr)
+// EndPos returns the approximate end position of n in the source.
+// For some nodes (*Name, *BasicLit) it returns the position immediately
+// following the node; for others (*BlockStmt, *SwitchStmt, etc.) it
+// returns the position of the closing '}'; and for some (*ParenExpr)
 // the returned position is the end position of the last enclosed
 // expression.
-// Thus, endPos should not be used for exact demarcation of the
+// Thus, EndPos should not be used for exact demarcation of the
 // end of a node in the source; it is mostly useful to determine
 // scope ranges where there is some leeway.
-func endPos(n syntax.Node) syntax.Pos {
+func EndPos(n Node) Pos {
 	for m := n; ; {
 		switch n := m.(type) {
 		case nil:
 			panic("internal error: nil")
 
 		// packages
-		case *syntax.File:
+		case *File:
 			return n.EOF
 
 		// declarations
-		case *syntax.ImportDecl:
+		case *ImportDecl:
 			m = n.Path
-		case *syntax.ConstDecl:
+		case *ConstDecl:
 			if n.Values != nil {
 				m = n.Values
 				continue
@@ -151,9 +147,9 @@ func endPos(n syntax.Node) syntax.Pos {
 				continue
 			}
 			return n.Pos()
-		case *syntax.TypeDecl:
+		case *TypeDecl:
 			m = n.Type
-		case *syntax.VarDecl:
+		case *VarDecl:
 			if n.Values != nil {
 				m = n.Values
 				continue
@@ -167,7 +163,7 @@ func endPos(n syntax.Node) syntax.Pos {
 				continue
 			}
 			return n.Pos()
-		case *syntax.FuncDecl:
+		case *FuncDecl:
 			if n.Body != nil {
 				m = n.Body
 				continue
@@ -175,27 +171,27 @@ func endPos(n syntax.Node) syntax.Pos {
 			m = n.Type
 
 		// expressions
-		case *syntax.BadExpr:
+		case *BadExpr:
 			return n.Pos()
-		case *syntax.Name:
+		case *Name:
 			p := n.Pos()
-			return syntax.MakePos(p.Base(), p.Line(), p.Col()+uint(len(n.Value)))
-		case *syntax.BasicLit:
+			return MakePos(p.Base(), p.Line(), p.Col()+uint(len(n.Value)))
+		case *BasicLit:
 			p := n.Pos()
-			return syntax.MakePos(p.Base(), p.Line(), p.Col()+uint(len(n.Value)))
-		case *syntax.CompositeLit:
+			return MakePos(p.Base(), p.Line(), p.Col()+uint(len(n.Value)))
+		case *CompositeLit:
 			return n.Rbrace
-		case *syntax.KeyValueExpr:
+		case *KeyValueExpr:
 			m = n.Value
-		case *syntax.FuncLit:
+		case *FuncLit:
 			m = n.Body
-		case *syntax.ParenExpr:
+		case *ParenExpr:
 			m = n.X
-		case *syntax.SelectorExpr:
+		case *SelectorExpr:
 			m = n.Sel
-		case *syntax.IndexExpr:
+		case *IndexExpr:
 			m = n.Index
-		case *syntax.SliceExpr:
+		case *SliceExpr:
 			for i := len(n.Index) - 1; i >= 0; i-- {
 				if x := n.Index[i]; x != nil {
 					m = x
@@ -203,23 +199,23 @@ func endPos(n syntax.Node) syntax.Pos {
 				}
 			}
 			m = n.X
-		case *syntax.AssertExpr:
+		case *AssertExpr:
 			m = n.Type
-		case *syntax.TypeSwitchGuard:
+		case *TypeSwitchGuard:
 			m = n.X
-		case *syntax.Operation:
+		case *Operation:
 			if n.Y != nil {
 				m = n.Y
 				continue
 			}
 			m = n.X
-		case *syntax.CallExpr:
+		case *CallExpr:
 			if l := lastExpr(n.ArgList); l != nil {
 				m = l
 				continue
 			}
 			m = n.Fun
-		case *syntax.ListExpr:
+		case *ListExpr:
 			if l := lastExpr(n.ElemList); l != nil {
 				m = l
 				continue
@@ -227,32 +223,32 @@ func endPos(n syntax.Node) syntax.Pos {
 			return n.Pos()
 
 		// types
-		case *syntax.ArrayType:
+		case *ArrayType:
 			m = n.Elem
-		case *syntax.SliceType:
+		case *SliceType:
 			m = n.Elem
-		case *syntax.DotsType:
+		case *DotsType:
 			m = n.Elem
-		case *syntax.StructType:
+		case *StructType:
 			if l := lastField(n.FieldList); l != nil {
 				m = l
 				continue
 			}
 			return n.Pos()
 			// TODO(gri) need to take TagList into account
-		case *syntax.Field:
+		case *Field:
 			if n.Type != nil {
 				m = n.Type
 				continue
 			}
 			m = n.Name
-		case *syntax.InterfaceType:
+		case *InterfaceType:
 			if l := lastField(n.MethodList); l != nil {
 				m = l
 				continue
 			}
 			return n.Pos()
-		case *syntax.FuncType:
+		case *FuncType:
 			if l := lastField(n.ResultList); l != nil {
 				m = l
 				continue
@@ -262,71 +258,71 @@ func endPos(n syntax.Node) syntax.Pos {
 				continue
 			}
 			return n.Pos()
-		case *syntax.MapType:
+		case *MapType:
 			m = n.Value
-		case *syntax.ChanType:
+		case *ChanType:
 			m = n.Elem
 
 		// statements
-		case *syntax.EmptyStmt:
+		case *EmptyStmt:
 			return n.Pos()
-		case *syntax.LabeledStmt:
+		case *LabeledStmt:
 			m = n.Stmt
-		case *syntax.BlockStmt:
+		case *BlockStmt:
 			return n.Rbrace
-		case *syntax.ExprStmt:
+		case *ExprStmt:
 			m = n.X
-		case *syntax.SendStmt:
+		case *SendStmt:
 			m = n.Value
-		case *syntax.DeclStmt:
+		case *DeclStmt:
 			if l := lastDecl(n.DeclList); l != nil {
 				m = l
 				continue
 			}
 			return n.Pos()
-		case *syntax.AssignStmt:
+		case *AssignStmt:
 			m = n.Rhs
 			if m == nil {
-				p := endPos(n.Lhs)
-				return syntax.MakePos(p.Base(), p.Line(), p.Col()+2)
+				p := EndPos(n.Lhs)
+				return MakePos(p.Base(), p.Line(), p.Col()+2)
 			}
-		case *syntax.BranchStmt:
+		case *BranchStmt:
 			if n.Label != nil {
 				m = n.Label
 				continue
 			}
 			return n.Pos()
-		case *syntax.CallStmt:
+		case *CallStmt:
 			m = n.Call
-		case *syntax.ReturnStmt:
+		case *ReturnStmt:
 			if n.Results != nil {
 				m = n.Results
 				continue
 			}
 			return n.Pos()
-		case *syntax.IfStmt:
+		case *IfStmt:
 			if n.Else != nil {
 				m = n.Else
 				continue
 			}
 			m = n.Then
-		case *syntax.ForStmt:
+		case *ForStmt:
 			m = n.Body
-		case *syntax.SwitchStmt:
+		case *SwitchStmt:
 			return n.Rbrace
-		case *syntax.SelectStmt:
+		case *SelectStmt:
 			return n.Rbrace
 
 		// helper nodes
-		case *syntax.RangeClause:
+		case *RangeClause:
 			m = n.X
-		case *syntax.CaseClause:
+		case *CaseClause:
 			if l := lastStmt(n.Body); l != nil {
 				m = l
 				continue
 			}
 			return n.Colon
-		case *syntax.CommClause:
+		case *CommClause:
 			if l := lastStmt(n.Body); l != nil {
 				m = l
 				continue
@@ -339,28 +335,28 @@ func endPos(n syntax.Node) syntax.Pos {
 	}
 }
 
-func lastDecl(list []syntax.Decl) syntax.Decl {
+func lastDecl(list []Decl) Decl {
 	if l := len(list); l > 0 {
 		return list[l-1]
 	}
 	return nil
 }
 
-func lastExpr(list []syntax.Expr) syntax.Expr {
+func lastExpr(list []Expr) Expr {
 	if l := len(list); l > 0 {
 		return list[l-1]
 	}
 	return nil
 }
 
-func lastStmt(list []syntax.Stmt) syntax.Stmt {
+func lastStmt(list []Stmt) Stmt {
 	if l := len(list); l > 0 {
 		return list[l-1]
 	}
 	return nil
 }
 
-func lastField(list []*syntax.Field) *syntax.Field {
+func lastField(list []*Field) *Field {
 	if l := len(list); l > 0 {
 		return list[l-1]
 	}
diff --git a/src/cmd/compile/internal/types2/assignments.go b/src/cmd/compile/internal/types2/assignments.go
index b8cf46c364..ddcb5e00b3 100644
--- a/src/cmd/compile/internal/types2/assignments.go
+++ b/src/cmd/compile/internal/types2/assignments.go
@@ -377,7 +377,7 @@ func (check *Checker) shortVarDecl(pos syntax.Pos, lhs, rhs []syntax.Expr) {
 		// a function begins at the end of the ConstSpec or VarSpec (ShortVarDecl
 		// for short variable declarations) and ends at the end of the innermost
 		// containing block."
-		scopePos := endPos(rhs[len(rhs)-1])
+		scopePos := syntax.EndPos(rhs[len(rhs)-1])
 		for _, obj := range newVars {
 			check.declare(scope, nil, obj, scopePos) // recordObject already called
 		}
diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index 9d8c39ddbe..fe79b00152 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -901,7 +901,7 @@ func (check *Checker) declStmt(list []syntax.Decl) {
 			// inside a function begins at the end of the ConstSpec or VarSpec
 			// (ShortVarDecl for short variable declarations) and ends at the
 			// end of the innermost containing block."
-			scopePos := endPos(s)
+			scopePos := syntax.EndPos(s)
 			for i, name := range s.NameList {
 				check.declare(check.scope, name, lhs[i], scopePos)
 			}
@@ -958,7 +958,7 @@ func (check *Checker) declStmt(list []syntax.Decl) {
 
 			// declare all variables
 			// (only at this point are the variable scopes (parents) set)
-			scopePos := endPos(s) // see constant declarations
+			scopePos := syntax.EndPos(s) // see constant declarations
 			for i, name := range s.NameList {
 				// see constant declarations
 				check.declare(check.scope, name, lhs0[i], scopePos)
diff --git a/src/cmd/compile/internal/types2/errors.go b/src/cmd/compile/internal/types2/errors.go
index 88ea72f593..d66528a8fd 100644
--- a/src/cmd/compile/internal/types2/errors.go
+++ b/src/cmd/compile/internal/types2/errors.go
@@ -207,10 +207,10 @@ func posFor(at poser) syntax.Pos {
 	switch x := at.(type) {
 	case *operand:
 		if x.expr != nil {
-			return startPos(x.expr)
+			return syntax.StartPos(x.expr)
 		}
 	case syntax.Node:
-		return startPos(x)
+		return syntax.StartPos(x)
 	}
 	return at.Pos()
 }
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index b5ffdf34c2..085c2f058c 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -96,7 +96,7 @@ func (check *Checker) overflow(x *operand) {
 	// If the corresponding expression is an operation, use the
 	// operator position rather than the start of the expression
 	// as error position.
-	pos := startPos(x.expr)
+	pos := syntax.StartPos(x.expr)
 	what := "" // operator description, if any
 	if op, _ := x.expr.(*syntax.Operation); op != nil {
 		pos = op.Pos()
diff --git a/src/cmd/compile/internal/types2/labels.go b/src/cmd/compile/internal/types2/labels.go
index d5878692f5..d3206988b5 100644
--- a/src/cmd/compile/internal/types2/labels.go
+++ b/src/cmd/compile/internal/types2/labels.go
@@ -11,7 +11,7 @@ import (
 // labels checks correct label use in body.
 func (check *Checker) labels(body *syntax.BlockStmt) {
 	// set of all labels in this body
-	all := NewScope(nil, body.Pos(), endPos(body), "label")
+	all := NewScope(nil, body.Pos(), syntax.EndPos(body), "label")
 
 	fwdJumps := check.blockBranches(all, nil, nil, body.List)
 
diff --git a/src/cmd/compile/internal/types2/resolver.go b/src/cmd/compile/internal/types2/resolver.go
index 3aca2bcb3c..35bb72ee55 100644
--- a/src/cmd/compile/internal/types2/resolver.go
+++ b/src/cmd/compile/internal/types2/resolver.go
@@ -216,7 +216,7 @@ func (check *Checker) collectObjects() {
 		// but there is no corresponding package object.
 		check.recordDef(file.PkgName, nil)
 
-		fileScope := NewScope(check.pkg.scope, startPos(file), endPos(file), check.filename(fileNo))
+		fileScope := NewScope(check.pkg.scope, syntax.StartPos(file), syntax.EndPos(file), check.filename(fileNo))
 		fileScopes = append(fileScopes, fileScope)
 		check.recordScope(file, fileScope)
 
diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go
index 319354bea2..8447fa5de2 100644
--- a/src/cmd/compile/internal/types2/stmt.go
+++ b/src/cmd/compile/internal/types2/stmt.go
@@ -16,13 +16,13 @@ func (check *Checker) funcBody(decl *declInfo, name string, sig *Signature, body
 	if check.conf.Trace {
 		check.trace(body.Pos(), "--- %s: %s", name, sig)
 		defer func() {
-			check.trace(endPos(body), "--- <end>")
+			check.trace(syntax.EndPos(body), "--- <end>")
 		}()
 	}
 
 	// set function scope extent
 	sig.scope.pos = body.Pos()
-	sig.scope.end = endPos(body)
+	sig.scope.end = syntax.EndPos(body)
 
 	// save/restore current context and setup function context
 	// (and use 0 indentation at function start)
@@ -154,7 +154,7 @@ func (check *Checker) multipleSelectDefaults(list []*syntax.CommClause) {
 }
 
 func (check *Checker) openScope(node syntax.Node, comment string) {
-	check.openScopeUntil(node, endPos(node), comment)
+	check.openScopeUntil(node, syntax.EndPos(node), comment)
 }
 
 func (check *Checker) openScopeUntil(node syntax.Node, end syntax.Pos, comment string) {
@@ -723,7 +723,7 @@ func (check *Checker) typeSwitchStmt(inner stmtContext, s *syntax.SwitchStmt, gu
 			// "at the end of the TypeSwitchCase" in #16794 instead?
 			scopePos := clause.Pos() // for default clause (len(List) == 0)
 			if n := len(cases); n > 0 {
-				scopePos = endPos(cases[n-1])
+				scopePos = syntax.EndPos(cases[n-1])
 			}
 			check.declare(check.scope, nil, obj, scopePos)
 			check.recordImplicit(clause, obj)
@@ -840,7 +840,7 @@ func (check *Checker) rangeStmt(inner stmtContext, s *syntax.ForStmt, rclause *s
 
 		// declare variables
 		if len(vars) > 0 {
-			scopePos := endPos(rclause.X) // TODO(gri) should this just be s.Body.Pos (spec clarification)?
+			scopePos := syntax.EndPos(rclause.X) // TODO(gri) should this just be s.Body.Pos (spec clarification)?
 			for _, obj := range vars {
 				// spec: "The scope of a constant or variable identifier declared inside
 				// a function begins at the end of the ConstSpec or VarSpec (ShortVarDecl
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 7675ce6376..f116461403 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -131,7 +131,7 @@ func (check *Checker) typ(e syntax.Expr) Type {
 // (see ordinaryType).
 func (check *Checker) varType(e syntax.Expr) Type {
 	typ := check.definedType(e, nil)
-	check.ordinaryType(startPos(e), typ)
+	check.ordinaryType(syntax.StartPos(e), typ)
 	return typ
 }
 
@@ -1154,7 +1154,7 @@ func (check *Checker) structType(styp *Struct, e *syntax.StructType) {
 			// spec: "An embedded type must be specified as a type name T or as a
 			// pointer to a non-interface type name *T, and T itself may not be a
 			// pointer type."
-			pos := startPos(f.Type)
+			pos := syntax.StartPos(f.Type)
 			name := embeddedFieldIdent(f.Type)
 			if name == nil {
 				check.errorf(pos, "invalid embedded field type %s", f.Type)
-- 
GitLab


From 3a30381b2110f15de85514609965b7cafd90aec0 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 30 Mar 2021 22:07:26 -0700
Subject: [PATCH 1394/2400] cmd/compile/internal/types2: simplify
 Checker.funcInst

Now that we use square brackets for instantiations, we
can tell type arguments from ordinary arguments without
"guessing" which permits a simpler implementation.

While at it, also fix a minor position error for type
instantiations (now matching the code for function
instantiations).

Change-Id: I20eca51c5b06259703767b5906e89197d6cd595a
Reviewed-on: https://go-review.googlesource.com/c/go/+/306169
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/call.go    | 36 ++++++----------------
 src/cmd/compile/internal/types2/typexpr.go |  2 +-
 2 files changed, 10 insertions(+), 28 deletions(-)

diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index 18737e45a0..38e9015248 100644
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -15,39 +15,29 @@ import (
 // funcInst type-checks a function instantiaton inst and returns the result in x.
 // The operand x must be the evaluation of inst.X and its type must be a signature.
 func (check *Checker) funcInst(x *operand, inst *syntax.IndexExpr) {
-	args, ok := check.exprOrTypeList(unpackExpr(inst.Index))
-	if !ok {
+	xlist := unpackExpr(inst.Index)
+	targs := check.typeList(xlist)
+	if targs == nil {
 		x.mode = invalid
 		x.expr = inst
 		return
 	}
-	if len(args) > 0 && args[0].mode != typexpr {
-		check.errorf(args[0], "%s is not a type", args[0])
-		ok = false
-	}
+	assert(len(targs) == len(xlist))
 
 	// check number of type arguments
-	n := len(args)
+	n := len(targs)
 	sig := x.typ.(*Signature)
 	if !check.conf.InferFromConstraints && n != len(sig.tparams) || n > len(sig.tparams) {
-		check.errorf(args[n-1], "got %d type arguments but want %d", n, len(sig.tparams))
+		check.errorf(xlist[n-1], "got %d type arguments but want %d", n, len(sig.tparams))
 		x.mode = invalid
 		x.expr = inst
 		return
 	}
 
-	// collect types
-	targs := make([]Type, n)
+	// determine argument positions (for error reporting)
 	poslist := make([]syntax.Pos, n)
-	for i, a := range args {
-		if a.mode != typexpr {
-			// error was reported earlier
-			x.mode = invalid
-			x.expr = inst
-			return
-		}
-		targs[i] = a.typ
-		poslist[i] = a.Pos()
+	for i, x := range xlist {
+		poslist[i] = syntax.StartPos(x)
 	}
 
 	// if we don't have enough type arguments, use constraint type inference
@@ -82,14 +72,6 @@ func (check *Checker) funcInst(x *operand, inst *syntax.IndexExpr) {
 	assert(n == len(sig.tparams))
 
 	// instantiate function signature
-	for i, typ := range targs {
-		// some positions may be missing if types are inferred
-		var pos syntax.Pos
-		if i < len(poslist) {
-			pos = poslist[i]
-		}
-		check.ordinaryType(pos, typ)
-	}
 	res := check.instantiate(x.Pos(), sig, targs, poslist).(*Signature)
 	assert(res.tparams == nil) // signature is not generic anymore
 	if inferred {
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index f116461403..ce2fd7797b 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -671,7 +671,7 @@ func (check *Checker) instantiatedType(x syntax.Expr, targs []syntax.Expr, def *
 	// determine argument positions (for error reporting)
 	typ.poslist = make([]syntax.Pos, len(targs))
 	for i, arg := range targs {
-		typ.poslist[i] = arg.Pos()
+		typ.poslist[i] = syntax.StartPos(arg)
 	}
 
 	// make sure we check instantiation works at least once
-- 
GitLab


From d6a90d06d2883c6ae4bbd9bff2aafc338cc8f339 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 30 Mar 2021 23:12:48 -0700
Subject: [PATCH 1395/2400] cmd/compile/internal/types2: simplify Checker.Call

Now that we use square brackets for instantiations, we
can tell type arguments from ordinary arguments without
"guessing" which permits a simpler implementation.

Specifically, replace use of Checker.exprOrTypeList with
Checker.exprList, and delete Checker.exprOrTypeList and
Checker.multiExprOrType.

Disable a test for an (esoteric) failure due to an
unrelated problem with error matching when running
the test.

Change-Id: I17f18fffc32f03fa90d93a68ebf56e5f2fcc9dab
Reviewed-on: https://go-review.googlesource.com/c/go/+/306171
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/call.go       | 62 +------------------
 src/cmd/compile/internal/types2/expr.go       |  6 --
 .../internal/types2/fixedbugs/issue39634.go2  |  3 +-
 3 files changed, 3 insertions(+), 68 deletions(-)

diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index 38e9015248..20649bed99 100644
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -146,13 +146,7 @@ func (check *Checker) call(x *operand, call *syntax.CallExpr) exprKind {
 		}
 
 		// evaluate arguments
-		args, ok := check.exprOrTypeList(call.ArgList)
-		if !ok {
-			x.mode = invalid
-			x.expr = call
-			return expression
-		}
-
+		args, _ := check.exprList(call.ArgList, false)
 		sig = check.arguments(call, sig, args)
 
 		// determine result
@@ -183,60 +177,6 @@ func (check *Checker) call(x *operand, call *syntax.CallExpr) exprKind {
 	}
 }
 
-// exprOrTypeList returns a list of operands and reports an error if the
-// list contains a mix of values and types (ignoring invalid operands).
-// TODO(gri) Now we can split this into exprList and typeList.
-func (check *Checker) exprOrTypeList(elist []syntax.Expr) (xlist []*operand, ok bool) {
-	ok = true
-
-	switch len(elist) {
-	case 0:
-		// nothing to do
-
-	case 1:
-		// single (possibly comma-ok) value or type, or function returning multiple values
-		e := elist[0]
-		var x operand
-		check.multiExprOrType(&x, e)
-		if t, ok := x.typ.(*Tuple); ok && x.mode != invalid && x.mode != typexpr {
-			// multiple values
-			xlist = make([]*operand, t.Len())
-			for i, v := range t.vars {
-				xlist[i] = &operand{mode: value, expr: e, typ: v.typ}
-			}
-			break
-		}
-
-		check.instantiatedOperand(&x)
-
-		// exactly one (possibly invalid or comma-ok) value or type
-		xlist = []*operand{&x}
-
-	default:
-		// multiple (possibly invalid) values or types
-		xlist = make([]*operand, len(elist))
-		ntypes := 0
-		for i, e := range elist {
-			var x operand
-			check.exprOrType(&x, e)
-			xlist[i] = &x
-			switch x.mode {
-			case invalid:
-				ntypes = len(xlist) // make 'if' condition fail below (no additional error in this case)
-			case typexpr:
-				ntypes++
-				check.instantiatedOperand(&x)
-			}
-		}
-		if 0 < ntypes && ntypes < len(xlist) {
-			check.error(xlist[0], "mix of value and type expressions")
-			ok = false
-		}
-	}
-
-	return
-}
-
 func (check *Checker) exprList(elist []syntax.Expr, allowCommaOk bool) (xlist []*operand, commaOk bool) {
 	switch len(elist) {
 	case 0:
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 085c2f058c..7d2240d41e 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -1954,12 +1954,6 @@ func (check *Checker) multiExpr(x *operand, e syntax.Expr) {
 	check.exclude(x, 1<<novalue|1<<builtin|1<<typexpr)
 }
 
-// multiExprOrType is like multiExpr but the result may also be a type.
-func (check *Checker) multiExprOrType(x *operand, e syntax.Expr) {
-	check.rawExpr(x, e, nil)
-	check.exclude(x, 1<<novalue|1<<builtin)
-}
-
 // exprWithHint typechecks expression e and initializes x with the expression value;
 // hint is the type of a composite literal element.
 // If an error occurred, x.mode is set to invalid.
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39634.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39634.go2
index f37930d0e8..c99903f399 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue39634.go2
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39634.go2
@@ -41,7 +41,8 @@ type foo9[A any] interface { type foo9 /* ERROR interface contains type constrai
 func _() { var _ = new(foo9 /* ERROR interface contains type constraints */ [int]) }
 
 // crash 12
-var u /* ERROR cycle */ , i [func /* ERROR used as value */ /* ERROR used as value */ (u, c /* ERROR undeclared */ /* ERROR undeclared */ ) {}(0, len)]c /* ERROR undeclared */ /* ERROR undeclared */
+// TODO(gri) temporarily disabled due to an error check issue
+// var u /* ERROR cycle */ , i [func /* ERROR used as value */ /* ERROR used as value */ (u, c /* ERROR undeclared */ /* ERROR undeclared */ ) {}(0, len)]c /* ERROR undeclared */ /* ERROR undeclared */
 
 // crash 15
 func y15() { var a /* ERROR declared but not used */ interface{ p() } = G15[string]{} }
-- 
GitLab


From 2e6f39beb0d2423beb544cf491fd9460d0959634 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Wed, 24 Mar 2021 23:31:32 -0400
Subject: [PATCH 1396/2400] cmd/go/internal/modload: factor out a method to
 update loader requirements

For #36460

Change-Id: Idb0b333a28d2470bc9482fe1829ccb6ddf8abd34
Reviewed-on: https://go-review.googlesource.com/c/go/+/304909
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modload/load.go | 60 ++++++++++++++++++-----------
 1 file changed, 38 insertions(+), 22 deletions(-)

diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index 386b53938c..5bff17e579 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -940,6 +940,34 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 	}
 	base.ExitIfErrors() // TODO(bcmills): Is this actually needed?
 
+	if err := ld.updateRequirements(ctx); err != nil {
+		base.Fatalf("go: %v", err)
+	}
+
+	if go117LazyTODO {
+		// Promoting a root can pull in previously-irrelevant requirements,
+		// changing the build list. Iterate until the roots are stable.
+	}
+
+	return ld
+}
+
+// updateRequirements ensures that ld.requirements is consistent with
+// the information gained from ld.pkgs.
+//
+// In particular:
+//
+// 	- Modules that provide packages directly imported from the main module are
+// 	  marked as direct, and are promoted to explicit roots. If a needed root
+// 	  cannot be promoted due to -mod=readonly or -mod=vendor, the importing
+// 	  package is marked with an error.
+//
+// 	- If ld scanned the "all" pattern independent of build constraints, it is
+// 	  guaranteed to have seen every direct import. Module dependencies that did
+// 	  not provide any directly-imported package are then marked as indirect.
+//
+// 	- Root dependencies are updated to their selected versions.
+func (ld *loader) updateRequirements(ctx context.Context) error {
 	rs := ld.requirements
 
 	// Compute directly referenced dependency modules.
@@ -956,11 +984,11 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 			if pkg.err == nil && cfg.BuildMod != "mod" {
 				if v, ok := rs.rootSelected(dep.mod.Path); !ok || v != dep.mod.Version {
 					// dep.mod is not an explicit dependency, but needs to be.
-					// Because we are not in "mod" mod, we will not be able to update it.
+					// Because we are not in "mod" mode, we will not be able to update it.
 					// Instead, mark the importing package with an error.
 					//
 					// TODO(#41688): The resulting error message fails to include the file
-					// position of the erroneous import (because that information is not
+					// position of the import statement (because that information is not
 					// tracked by the module loader). Figure out how to plumb the import
 					// position through.
 					pkg.err = &DirectImportFromImplicitDependencyError{
@@ -983,32 +1011,20 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 
 	// If we didn't scan all of the imports from the main module, or didn't use
 	// imports.AnyTags, then we didn't necessarily load every package that
-	// contributes “direct” imports — so we can't safely mark existing
-	// direct dependencies in ld.requirements as indirect-only. Propagate them as direct.
-	if !ld.loadedDirect() {
+	// contributes “direct” imports — so we can't safely mark existing direct
+	// dependencies in ld.requirements as indirect-only. Propagate them as direct.
+	loadedDirect := ld.allPatternIsRoot && reflect.DeepEqual(ld.Tags, imports.AnyTags())
+	if !loadedDirect {
 		for mPath := range rs.direct {
 			direct[mPath] = true
 		}
 	}
 
-	var err error
-	ld.requirements, err = updateRoots(ctx, direct, ld.pkgs, ld.requirements)
-	if err != nil {
-		base.Errorf("go: %v", err)
-	}
-
-	if go117LazyTODO {
-		// Promoting a root can pull in previously-irrelevant requirements,
-		// changing the build list. Iterate until the roots are stable.
+	rs, err := updateRoots(ctx, direct, ld.pkgs, rs)
+	if err == nil {
+		ld.requirements = rs
 	}
-
-	return ld
-}
-
-// loadedDirect reports whether ld loaded all of the packages that are directly
-// imported by any package or test in the main module.
-func (ld *loader) loadedDirect() bool {
-	return ld.allPatternIsRoot && reflect.DeepEqual(ld.Tags, imports.AnyTags())
+	return err
 }
 
 // resolveMissingImports returns a set of modules that could be added as
-- 
GitLab


From 1271e9a9ccfdb0906ecf69d2047ad3b470eeca02 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ahmet=20Akt=C3=BCrk?= <aakturk000@gmail.com>
Date: Mon, 5 Apr 2021 22:05:05 +0300
Subject: [PATCH 1397/2400] time: properly quote strings containing quotes and
 backslashes

Fixes #45391

Change-Id: I43ea597f6a9596a621ae7b63eb05440d5b9e2d8f
Reviewed-on: https://go-review.googlesource.com/c/go/+/307192
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/time/export_test.go |  2 ++
 src/time/format.go      | 11 ++++++++++-
 src/time/format_test.go | 22 ++++++++++++++++++++++
 3 files changed, 34 insertions(+), 1 deletion(-)

diff --git a/src/time/export_test.go b/src/time/export_test.go
index 0f2d21053a..9baad60a92 100644
--- a/src/time/export_test.go
+++ b/src/time/export_test.go
@@ -129,3 +129,5 @@ var StdChunkNames = map[int]string{
 	stdFracSecond9 | 8<<stdArgShift: ".99999999",
 	stdFracSecond9 | 9<<stdArgShift: ".999999999",
 }
+
+var Quote = quote
diff --git a/src/time/format.go b/src/time/format.go
index 7586035872..9624752fb4 100644
--- a/src/time/format.go
+++ b/src/time/format.go
@@ -689,7 +689,16 @@ type ParseError struct {
 }
 
 func quote(s string) string {
-	return "\"" + s + "\""
+	buf := make([]byte, 0, len(s)+2) // +2 for surrounding quotes
+	buf = append(buf, '"')
+	for _, c := range s {
+		if c == '"' || c == '\\' {
+			buf = append(buf, '\\')
+		}
+		buf = append(buf, string(c)...)
+	}
+	buf = append(buf, '"')
+	return string(buf)
 }
 
 // Error returns the string representation of a ParseError.
diff --git a/src/time/format_test.go b/src/time/format_test.go
index 9e96d4a295..09d3f842e3 100644
--- a/src/time/format_test.go
+++ b/src/time/format_test.go
@@ -563,6 +563,10 @@ var parseErrorTests = []ParseErrorTest{
 	// invalid or mismatched day-of-year
 	{"Jan _2 002 2006", "Feb  4 034 2006", "day-of-year does not match day"},
 	{"Jan _2 002 2006", "Feb  4 004 2006", "day-of-year does not match month"},
+
+	// issue 45391.
+	{`"2006-01-02T15:04:05Z07:00"`, "0", `parsing time "0" as "\"2006-01-02T15:04:05Z07:00\"": cannot parse "0" as "\""`},
+	{RFC3339, "\"", `parsing time "\"" as "2006-01-02T15:04:05Z07:00": cannot parse "\"" as "2006"`},
 }
 
 func TestParseErrors(t *testing.T) {
@@ -782,3 +786,21 @@ func TestParseYday(t *testing.T) {
 		}
 	}
 }
+
+// Issue 45391.
+func TestQuote(t *testing.T) {
+	tests := []struct {
+		s, want string
+	}{
+		{`"`, `"\""`},
+		{`abc"xyz"`, `"abc\"xyz\""`},
+		{"", `""`},
+		{"abc", `"abc"`},
+	}
+	for _, tt := range tests {
+		if q := Quote(tt.s); q != tt.want {
+			t.Errorf("Quote(%q) = %q, want %q", tt.s, q, tt.want)
+		}
+	}
+
+}
-- 
GitLab


From bcc4422ee1bdb8051a6c870cf00e837814614a0f Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Tue, 6 Apr 2021 14:55:46 -0400
Subject: [PATCH 1398/2400] runtime: deflake TestGCTestIsReachable

This is a simple workaround for a bug where runtime.GC() can return
before finishing a full sweep, causing gcTestIsReachable to throw. The
right thing is to fix runtime.GC(), but this should get this test
passing reliably in the meantime.

Updates #45315.

Change-Id: Iae141e6dbb26a9c2649497c1feedd4aaeaf540c7
Reviewed-on: https://go-review.googlesource.com/c/go/+/307809
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/mgc.go | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index 4c165ddcdb..ef3436d1f4 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -2391,6 +2391,11 @@ func gcTestIsReachable(ptrs ...unsafe.Pointer) (mask uint64) {
 	// Force a full GC and sweep.
 	GC()
 
+	// TODO(austin): Work around issue #45315. One GC() can return
+	// without finishing the sweep. Do a second to force the sweep
+	// through.
+	GC()
+
 	// Process specials.
 	for i, s := range specials {
 		if !s.done {
-- 
GitLab


From f5efa5a313cbfdbd86aa342f8bc2a4cc66f51a6e Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Sat, 3 Apr 2021 20:09:15 -0400
Subject: [PATCH 1399/2400] cmd/compile: load results into registers on open
 defer return path

When a function panics then recovers, it needs to return to the
caller with named results having the correct values. For
in-register results, we need to load them into registers at the
defer return path.

For non-open-coded defers, we already generate correct code, as
the defer return path is part of the SSA CFG and contains the
instructions that are the same as an ordinary return statement,
including putting the results to the right places.

For open-coded defers, we have a special code generation that
emits a disconnected block that currently contains only the
deferreturn call and a RET instruction. It leaves the result
registers unset. This CL adds instructions that load the result
registers on that path.

Updates #40724.

Change-Id: I1f60514da644fd5fb4b4871a1153c62f42927282
Reviewed-on: https://go-review.googlesource.com/c/go/+/307231
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Austin Clements <austin@google.com>
---
 src/cmd/compile/internal/amd64/galign.go |  1 +
 src/cmd/compile/internal/amd64/ssa.go    | 16 +++++++++++
 src/cmd/compile/internal/ssa/op.go       | 12 ++++++++
 src/cmd/compile/internal/ssagen/arch.go  |  5 ++++
 src/cmd/compile/internal/ssagen/ssa.go   | 28 +++++++++---------
 test/abi/defer_recover_results.go        | 36 ++++++++++++++++++++++++
 6 files changed, 85 insertions(+), 13 deletions(-)
 create mode 100644 test/abi/defer_recover_results.go

diff --git a/src/cmd/compile/internal/amd64/galign.go b/src/cmd/compile/internal/amd64/galign.go
index ce1c402902..7845395538 100644
--- a/src/cmd/compile/internal/amd64/galign.go
+++ b/src/cmd/compile/internal/amd64/galign.go
@@ -23,4 +23,5 @@ func Init(arch *ssagen.ArchInfo) {
 	arch.SSAMarkMoves = ssaMarkMoves
 	arch.SSAGenValue = ssaGenValue
 	arch.SSAGenBlock = ssaGenBlock
+	arch.LoadRegResults = loadRegResults
 }
diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index 8142ba7984..e7b4fae016 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -1348,3 +1348,19 @@ func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
 		b.Fatalf("branch not implemented: %s", b.LongString())
 	}
 }
+
+func loadRegResults(s *ssagen.State, f *ssa.Func) {
+	for _, o := range f.OwnAux.ABIInfo().OutParams() {
+		n := o.Name.(*ir.Name)
+		rts, offs := o.RegisterTypesAndOffsets()
+		for i := range o.Registers {
+			p := s.Prog(loadByType(rts[i]))
+			p.From.Type = obj.TYPE_MEM
+			p.From.Name = obj.NAME_AUTO
+			p.From.Sym = n.Linksym()
+			p.From.Offset = n.FrameOffset() + offs[i]
+			p.To.Type = obj.TYPE_REG
+			p.To.Reg = ssa.ObjRegForAbiReg(o.Registers[i], f.Config)
+		}
+	}
+}
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index c406b3b223..b99a7a6646 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -153,6 +153,9 @@ func (a *AuxCall) Reg(i *regInfo, c *Config) *regInfo {
 func (a *AuxCall) ABI() *abi.ABIConfig {
 	return a.abiInfo.Config()
 }
+func (a *AuxCall) ABIInfo() *abi.ABIParamResultInfo {
+	return a.abiInfo
+}
 func (a *AuxCall) ResultReg(c *Config) *regInfo {
 	if a.abiInfo.OutRegistersUsed() == 0 {
 		return a.reg
@@ -171,6 +174,8 @@ func (a *AuxCall) ResultReg(c *Config) *regInfo {
 	return a.reg
 }
 
+// For ABI register index r, returns the (dense) register number used in
+// SSA backend.
 func archRegForAbiReg(r abi.RegIndex, c *Config) uint8 {
 	var m int8
 	if int(r) < len(c.intParamRegs) {
@@ -181,6 +186,13 @@ func archRegForAbiReg(r abi.RegIndex, c *Config) uint8 {
 	return uint8(m)
 }
 
+// For ABI register index r, returns the register number used in the obj
+// package (assembler).
+func ObjRegForAbiReg(r abi.RegIndex, c *Config) int16 {
+	m := archRegForAbiReg(r, c)
+	return c.registers[m].objNum
+}
+
 // ArgWidth returns the amount of stack needed for all the inputs
 // and outputs of a function or method, including ABI-defined parameter
 // slots and ABI-defined spill slots for register-resident parameters.
diff --git a/src/cmd/compile/internal/ssagen/arch.go b/src/cmd/compile/internal/ssagen/arch.go
index cc50ab36b5..cfa0f1db5b 100644
--- a/src/cmd/compile/internal/ssagen/arch.go
+++ b/src/cmd/compile/internal/ssagen/arch.go
@@ -39,4 +39,9 @@ type ArchInfo struct {
 	// SSAGenBlock emits end-of-block Progs. SSAGenValue should be called
 	// for all values in the block before SSAGenBlock.
 	SSAGenBlock func(s *State, b, next *ssa.Block)
+
+	// LoadRegResults emits instructions that loads register-assigned results
+	// into registers. They are already in memory (PPARAMOUT nodes).
+	// Used in open-coded defer return path.
+	LoadRegResults func(s *State, f *ssa.Func)
 }
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 8275d2ec9c..48102e5398 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -475,8 +475,7 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 	case s.hasOpenDefers && (base.Ctxt.Flag_shared || base.Ctxt.Flag_dynlink) && base.Ctxt.Arch.Name == "386":
 		// Don't support open-coded defers for 386 ONLY when using shared
 		// libraries, because there is extra code (added by rewriteToUseGot())
-		// preceding the deferreturn/ret code that is generated by gencallret()
-		// that we don't track correctly.
+		// preceding the deferreturn/ret code that we don't track correctly.
 		s.hasOpenDefers = false
 	}
 	if s.hasOpenDefers && len(s.curfn.Exit) > 0 {
@@ -6409,16 +6408,6 @@ func (s *state) addNamedValue(n *ir.Name, v *ssa.Value) {
 	s.f.NamedValues[loc] = append(values, v)
 }
 
-// Generate a disconnected call to a runtime routine and a return.
-func gencallret(pp *objw.Progs, sym *obj.LSym) *obj.Prog {
-	p := pp.Prog(obj.ACALL)
-	p.To.Type = obj.TYPE_MEM
-	p.To.Name = obj.NAME_EXTERN
-	p.To.Sym = sym
-	p = pp.Prog(obj.ARET)
-	return p
-}
-
 // Branch is an unresolved branch.
 type Branch struct {
 	P *obj.Prog  // branch instruction
@@ -6707,7 +6696,20 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 		// deferreturn and a return. This will be used to during panic
 		// recovery to unwind the stack and return back to the runtime.
 		s.pp.NextLive = s.livenessMap.DeferReturn
-		gencallret(pp, ir.Syms.Deferreturn)
+		p := pp.Prog(obj.ACALL)
+		p.To.Type = obj.TYPE_MEM
+		p.To.Name = obj.NAME_EXTERN
+		p.To.Sym = ir.Syms.Deferreturn
+
+		// Load results into registers. So when a deferred function
+		// recovers a panic, it will return to caller with right results.
+		// The results are already in memory, because they are not SSA'd
+		// when the function has defers (see canSSAName).
+		if f.OwnAux.ABIInfo().OutRegistersUsed() != 0 {
+			Arch.LoadRegResults(&s, f)
+		}
+
+		pp.Prog(obj.ARET)
 	}
 
 	if inlMarks != nil {
diff --git a/test/abi/defer_recover_results.go b/test/abi/defer_recover_results.go
new file mode 100644
index 0000000000..7787f26f4c
--- /dev/null
+++ b/test/abi/defer_recover_results.go
@@ -0,0 +1,36 @@
+// run
+
+// Copyright 2021 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.
+
+// Test that when a function recovers from a panic, it
+// returns the correct results to the caller (in particular,
+// setting the result registers correctly).
+
+package main
+
+type S struct {
+	x uint8
+	y uint16
+	z uint32
+	w float64
+}
+
+var a0, b0, c0, d0 = 10, "hello", S{1, 2, 3, 4}, [2]int{111, 222}
+
+//go:noinline
+//go:registerparams
+func F() (a int, b string, _ int, c S, d [2]int) {
+	a, b, c, d = a0, b0, c0, d0
+	defer func() { recover() }()
+	panic("XXX")
+	return
+}
+
+func main() {
+	a1, b1, zero, c1, d1 := F()
+	if a1 != a0 || b1 != b0 || c1 != c0 || d1 != d0 || zero != 0 { // unnamed result gets zero value
+		panic("FAIL")
+	}
+}
-- 
GitLab


From b56177a3037a035ee7f74e619838b6d853697100 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Mon, 5 Apr 2021 22:20:41 -0400
Subject: [PATCH 1400/2400] cmd/compile: check for unused OpArg* and mark
 invalid (again)

This caused a problem with

GOEXPERIMENT=regabi,regabiargs go test -c  crypto/x509

Updates #40724.

Change-Id: Ia3cdbe9968816c77836cb3e3ba89642aafd1b18d
Reviewed-on: https://go-review.googlesource.com/c/go/+/307529
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/expand_calls.go | 63 ++++++++++----------
 1 file changed, 32 insertions(+), 31 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index 6a6517deb8..36b6dcab9b 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -946,10 +946,11 @@ func (x *expandState) storeArgOrLoad(pos src.XPos, b *Block, source, mem *Value,
 	return s
 }
 
-// rewriteArgs removes all the Args from a call and converts the call args into appropriate
-// stores (or later, register movement).  Extra args for interface and closure calls are ignored,
-// but removed.
-func (x *expandState) rewriteArgs(v *Value, firstArg int) (*Value, []*Value) {
+// rewriteArgs replaces all the call-parameter Args to a call with their register translation (if any).
+// Preceding parameters (code pointers, closure pointer) are preserved, and the memory input is modified
+// to account for any parameter stores required.
+// Any of the old Args that have their use count fall to zero are marked OpInvalid.
+func (x *expandState) rewriteArgs(v *Value, firstArg int) {
 	if x.debug {
 		x.indent(3)
 		defer x.indent(-3)
@@ -960,8 +961,10 @@ func (x *expandState) rewriteArgs(v *Value, firstArg int) (*Value, []*Value) {
 	pos := v.Pos.WithNotStmt()
 	m0 := v.MemoryArg()
 	mem := m0
-	allResults := []*Value{}
+	newArgs := []*Value{}
+	oldArgs := []*Value{}
 	for i, a := range v.Args[firstArg : len(v.Args)-1] { // skip leading non-parameter SSA Args and trailing mem SSA Arg.
+		oldArgs = append(oldArgs, a)
 		auxI := int64(i)
 		aRegs := aux.RegsOfArg(auxI)
 		aType := aux.TypeOfArg(auxI)
@@ -978,7 +981,7 @@ func (x *expandState) rewriteArgs(v *Value, firstArg int) (*Value, []*Value) {
 			var result *[]*Value
 			var aOffset int64
 			if len(aRegs) > 0 {
-				result = &allResults
+				result = &newArgs
 			} else {
 				aOffset = aux.OffsetOfArg(auxI)
 			}
@@ -989,8 +992,22 @@ func (x *expandState) rewriteArgs(v *Value, firstArg int) (*Value, []*Value) {
 			mem = x.storeArgOrLoad(pos, v.Block, a, mem, aType, aOffset, 0, rc)
 		}
 	}
+	var preArgStore [2]*Value
+	preArgs := append(preArgStore[:0], v.Args[0:firstArg]...)
 	v.resetArgs()
-	return mem, allResults
+	v.AddArgs(preArgs...)
+	v.AddArgs(newArgs...)
+	v.AddArg(mem)
+	for _, a := range oldArgs {
+		if a.Uses == 0 {
+			if x.debug {
+				x.Printf("...marking %v unused\n", a.LongString())
+			}
+			a.reset(OpInvalid)
+		}
+	}
+
+	return
 }
 
 // expandCalls converts LE (Late Expansion) calls that act like they receive value args into a lower-level form
@@ -1041,33 +1058,17 @@ func expandCalls(f *Func) {
 	// Step 0: rewrite the calls to convert args to calls into stores/register movement.
 	for _, b := range f.Blocks {
 		for _, v := range b.Values {
+			firstArg := 0
 			switch v.Op {
 			case OpStaticLECall:
-				mem, results := x.rewriteArgs(v, 0)
-				v.AddArgs(results...)
-				v.AddArg(mem)
-			case OpClosureLECall:
-				code := v.Args[0]
-				context := v.Args[1]
-				mem, results := x.rewriteArgs(v, 2)
-				if len(results) == 0 {
-					v.SetArgs3(code, context, mem)
-				} else {
-					v.SetArgs2(code, context)
-					v.AddArgs(results...)
-					v.AddArg(mem)
-				}
 			case OpInterLECall:
-				code := v.Args[0]
-				mem, results := x.rewriteArgs(v, 1)
-				if len(results) == 0 {
-					v.SetArgs2(code, mem)
-				} else {
-					v.SetArgs1(code)
-					v.AddArgs(results...)
-					v.AddArg(mem)
-				}
+				firstArg = 1
+			case OpClosureLECall:
+				firstArg = 2
+			default:
+				continue
 			}
+			x.rewriteArgs(v, firstArg)
 		}
 		if isBlockMultiValueExit(b) {
 			x.indent(3)
@@ -1407,7 +1408,7 @@ func expandCalls(f *Func) {
 			i := v.AuxInt
 			if w := IArg[i]; w != nil {
 				if w.Type.Width != v.Type.Width {
-					f.Fatalf("incompatible OpArgIntReg [%d]: %v and %v", i, v, w)
+					f.Fatalf("incompatible OpArgIntReg [%d]: %s and %s", i, v.LongString(), w.LongString())
 				}
 				if w.Type.IsUnsafePtr() && !v.Type.IsUnsafePtr() {
 					// Update unsafe.Pointer type if we know the actual pointer type.
-- 
GitLab


From 0bc4605eadc53f19e75b232422c7af0ad707d6c6 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 26 Mar 2021 00:44:30 -0400
Subject: [PATCH 1401/2400] cmd/go/internal/modload: track conflicts in
 versionLimiter

This significantly simplifies the implementation of editRequirements
in preparation for making it lazy. It should have no effect on which
version combinations are rejected by 'go get', nor on which solutions
are found if downgrades are needed.

This change results in a small but observable change in error logging.
Before, we were reporting an error line for each argument that would
have exceeded its specified version, attributing it to one arbitrary
cause. Now, we are reporting an error line for each argument that
would cause any other argument to exceed its specified version. As a
result, if one argument would cause two others to exceed their
versions, we will now report one line instead of two; if two arguments
would independently cause one other to exceed its version, we will now
report two lines instead of one.

This change may result in a small performance improvement. Because we
are now scanning and rejecting incompatible requirements earlier, we
may waste less time computing upgrades and downgrades that ultimately
won't matter due to conflicting constraints.

For #36460

Change-Id: I125aa09b4be749dc5bacef23a859333991960e85
Reviewed-on: https://go-review.googlesource.com/c/go/+/305009
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modload/buildlist.go      | 149 +++++-------------
 src/cmd/go/internal/modload/edit.go           | 106 ++++++++-----
 .../go/testdata/script/mod_get_downgrade.txt  |   2 +-
 3 files changed, 105 insertions(+), 152 deletions(-)

diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index 62e01d2fd4..551e817cd2 100644
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -441,128 +441,57 @@ func editRequirements(ctx context.Context, rs *Requirements, add, mustSelect []m
 		return nil, false, err
 	}
 
-	selected := make(map[string]module.Version, len(final))
-	for _, m := range final {
-		selected[m.Path] = m
+	if !reflect.DeepEqual(final, buildList) {
+		changed = true
+	} else if len(mustSelect) == 0 {
+		// No change to the build list and no explicit roots to promote, so we're done.
+		return rs, false, nil
 	}
-	inconsistent := false
+
+	var rootPaths []string
 	for _, m := range mustSelect {
-		s, ok := selected[m.Path]
-		if !ok && m.Version == "none" {
-			continue
-		}
-		if s.Version != m.Version {
-			inconsistent = true
-			break
+		if m.Version != "none" && m.Path != Target.Path {
+			rootPaths = append(rootPaths, m.Path)
 		}
 	}
-
-	if !inconsistent {
-		changed := false
-		if !reflect.DeepEqual(final, buildList) {
-			changed = true
-		} else if len(mustSelect) == 0 {
-			// No change to the build list and no explicit roots to promote, so we're done.
-			return rs, false, nil
-		}
-
-		var rootPaths []string
-		for _, m := range mustSelect {
-			if m.Version != "none" && m.Path != Target.Path {
-				rootPaths = append(rootPaths, m.Path)
-			}
-		}
-		for _, m := range final[1:] {
-			if v, ok := rs.rootSelected(m.Path); ok && (v == m.Version || rs.direct[m.Path]) {
-				// m.Path was formerly a root, and either its version hasn't changed or
-				// we believe that it provides a package directly imported by a package
-				// or test in the main module. For now we'll assume that it is still
-				// relevant. If we actually load all of the packages and tests in the
-				// main module (which we are not doing here), we can revise the explicit
-				// roots at that point.
-				rootPaths = append(rootPaths, m.Path)
-			}
-		}
-
-		if go117LazyTODO {
-			// mvs.Req is not lazy, and in a lazily-loaded module we don't want
-			// to minimize the roots anyway. (Instead, we want to retain explicit
-			// root paths so that they remain explicit: only 'go mod tidy' should
-			// remove roots.)
-		}
-
-		min, err := mvs.Req(Target, rootPaths, &mvsReqs{buildList: final})
-		if err != nil {
-			return nil, false, err
-		}
-
-		// A module that is not even in the build list necessarily cannot provide
-		// any imported packages. Mark as direct only the direct modules that are
-		// still in the build list.
-		//
-		// TODO(bcmills): Would it make more sense to leave the direct map as-is
-		// but allow it to refer to modules that are no longer in the build list?
-		// That might complicate updateRoots, but it may be cleaner in other ways.
-		direct := make(map[string]bool, len(rs.direct))
-		for _, m := range final {
-			if rs.direct[m.Path] {
-				direct[m.Path] = true
-			}
+	for _, m := range final[1:] {
+		if v, ok := rs.rootSelected(m.Path); ok && (v == m.Version || rs.direct[m.Path]) {
+			// m.Path was formerly a root, and either its version hasn't changed or
+			// we believe that it provides a package directly imported by a package
+			// or test in the main module. For now we'll assume that it is still
+			// relevant. If we actually load all of the packages and tests in the
+			// main module (which we are not doing here), we can revise the explicit
+			// roots at that point.
+			rootPaths = append(rootPaths, m.Path)
 		}
-		return newRequirements(min, direct), changed, nil
 	}
 
-	// We overshot one or more of the modules in mustSelect, which means that
-	// Downgrade removed something in mustSelect because it conflicted with
-	// something else in mustSelect.
-	//
-	// Walk the requirement graph to find the conflict.
-	//
-	// TODO(bcmills): Ideally, mvs.Downgrade (or a replacement for it) would do
-	// this directly.
-
-	reqs := &mvsReqs{buildList: final}
-	reason := map[module.Version]module.Version{}
-	for _, m := range mustSelect {
-		reason[m] = m
-	}
-	queue := mustSelect[:len(mustSelect):len(mustSelect)]
-	for len(queue) > 0 {
-		var m module.Version
-		m, queue = queue[0], queue[1:]
-		required, err := reqs.Required(m)
-		if err != nil {
-			return nil, false, err
-		}
-		for _, r := range required {
-			if _, ok := reason[r]; !ok {
-				reason[r] = reason[m]
-				queue = append(queue, r)
-			}
-		}
+	if go117LazyTODO {
+		// mvs.Req is not lazy, and in a lazily-loaded module we don't want
+		// to minimize the roots anyway. (Instead, we want to retain explicit
+		// root paths so that they remain explicit: only 'go mod tidy' should
+		// remove roots.)
 	}
 
-	var conflicts []Conflict
-	for _, m := range mustSelect {
-		s, ok := selected[m.Path]
-		if !ok {
-			if m.Version != "none" {
-				panic(fmt.Sprintf("internal error: editBuildList lost %v", m))
-			}
-			continue
-		}
-		if s.Version != m.Version {
-			conflicts = append(conflicts, Conflict{
-				Source:     reason[s],
-				Dep:        s,
-				Constraint: m,
-			})
-		}
+	min, err := mvs.Req(Target, rootPaths, &mvsReqs{buildList: final})
+	if err != nil {
+		return nil, false, err
 	}
 
-	return nil, false, &ConstraintError{
-		Conflicts: conflicts,
+	// A module that is not even in the build list necessarily cannot provide
+	// any imported packages. Mark as direct only the direct modules that are
+	// still in the build list.
+	//
+	// TODO(bcmills): Would it make more sense to leave the direct map as-is
+	// but allow it to refer to modules that are no longer in the build list?
+	// That might complicate updateRoots, but it may be cleaner in other ways.
+	direct := make(map[string]bool, len(rs.direct))
+	for _, m := range final {
+		if rs.direct[m.Path] {
+			direct[m.Path] = true
+		}
 	}
+	return newRequirements(min, direct), changed, nil
 }
 
 // A ConstraintError describes inconsistent constraints in EditBuildList
diff --git a/src/cmd/go/internal/modload/edit.go b/src/cmd/go/internal/modload/edit.go
index 4d1f3c7826..0d7811a3cd 100644
--- a/src/cmd/go/internal/modload/edit.go
+++ b/src/cmd/go/internal/modload/edit.go
@@ -16,8 +16,7 @@ import (
 
 // editBuildList returns an edited version of initial such that:
 //
-// 	1. Each module version in mustSelect is selected, unless it is upgraded
-// 	   by the transitive requirements of another version in mustSelect.
+// 	1. Each module version in mustSelect is selected.
 //
 // 	2. Each module version in tryUpgrade is upgraded toward the indicated
 // 	   version as far as can be done without violating (1).
@@ -66,13 +65,27 @@ func editBuildList(ctx context.Context, initial, tryUpgrade, mustSelect []module
 
 	limiter := newVersionLimiter(max)
 
-	// Force the selected versions in mustSelect, even if they conflict.
-	//
-	// TODO(bcmills): Instead of forcing these versions, record conflicts
-	// so that the caller doesn't have to recompute them.
+	var conflicts []Conflict
 	for _, m := range mustSelect {
+		dq := limiter.check(m)
+		switch {
+		case dq.err != nil:
+			return nil, err
+		case dq.conflict != module.Version{}:
+			conflicts = append(conflicts, Conflict{
+				Source: m,
+				Dep:    dq.conflict,
+				Constraint: module.Version{
+					Path:    dq.conflict.Path,
+					Version: limiter.max[dq.conflict.Path],
+				},
+			})
+		}
 		limiter.selected[m.Path] = m.Version
 	}
+	if len(conflicts) > 0 {
+		return nil, &ConstraintError{Conflicts: conflicts}
+	}
 
 	// For each module, we want to get as close as we can to either the upgrade
 	// version or the previously-selected version in the build list, whichever is
@@ -145,24 +158,37 @@ type versionLimiter struct {
 	// version, so paths at version "none" are omitted.
 	selected map[string]string
 
-	// disqualified maps each encountered version to either true (if that version
-	// is known to be disqualified due to a conflict with a max version) or false
-	// (if that version is not known to be disqualified, either because it is ok
-	// or because we are currently traversing a cycle that includes it).
-	disqualified map[module.Version]bool
+	// dqReason records whether and why each each encountered version is
+	// disqualified.
+	dqReason map[module.Version]dqState
 
-	// requiredBy maps each not-yet-disqualified module version to the versions
+	// requiring maps each not-yet-disqualified module version to the versions
 	// that directly require it. If that version becomes disqualified, the
 	// disqualification will be propagated to all of the versions in the list.
-	requiredBy map[module.Version][]module.Version
+	requiring map[module.Version][]module.Version
+}
+
+// A dqState indicates whether and why a module version is “disqualified” from
+// being used in a way that would incorporate its requirements.
+//
+// The zero dqState indicates that the module version is not known to be
+// disqualified, either because it is ok or because we are currently traversing
+// a cycle that includes it.
+type dqState struct {
+	err      error          // if non-nil, disqualified because the requirements of the module could not be read
+	conflict module.Version // disqualified because the module (transitively) requires dep, which exceeds the maximum version constraint for its path
+}
+
+func (dq dqState) isDisqualified() bool {
+	return dq != dqState{}
 }
 
 func newVersionLimiter(max map[string]string) *versionLimiter {
 	return &versionLimiter{
-		selected:     map[string]string{Target.Path: Target.Version},
-		max:          max,
-		disqualified: map[module.Version]bool{Target: false},
-		requiredBy:   map[module.Version][]module.Version{},
+		selected:  map[string]string{Target.Path: Target.Version},
+		max:       max,
+		dqReason:  map[module.Version]dqState{},
+		requiring: map[module.Version][]module.Version{},
 	}
 }
 
@@ -179,7 +205,7 @@ func (l *versionLimiter) upgradeToward(ctx context.Context, m module.Version) er
 		selected = "none"
 	}
 
-	if l.isDisqualified(m) {
+	if l.check(m).isDisqualified() {
 		candidates, err := versions(ctx, m.Path, CheckAllowed)
 		if err != nil {
 			// This is likely a transient error reaching the repository,
@@ -196,7 +222,7 @@ func (l *versionLimiter) upgradeToward(ctx context.Context, m module.Version) er
 		})
 		candidates = candidates[:i]
 
-		for l.isDisqualified(m) {
+		for l.check(m).isDisqualified() {
 			n := len(candidates)
 			if n == 0 || cmpVersion(selected, candidates[n-1]) >= 0 {
 				// We couldn't find a suitable candidate above the already-selected version.
@@ -211,23 +237,22 @@ func (l *versionLimiter) upgradeToward(ctx context.Context, m module.Version) er
 	return nil
 }
 
-// isDisqualified reports whether m (or its transitive dependencies) would
-// violate l's maximum version limits if added to the module requirement graph.
-func (l *versionLimiter) isDisqualified(m module.Version) bool {
+// check determines whether m (or its transitive dependencies) would violate l's
+// maximum version limits if added to the module requirement graph.
+func (l *versionLimiter) check(m module.Version) dqState {
 	if m.Version == "none" || m == Target {
 		// version "none" has no requirements, and the dependencies of Target are
 		// tautological.
-		return false
+		return dqState{}
 	}
 
-	if dq, seen := l.disqualified[m]; seen {
+	if dq, seen := l.dqReason[m]; seen {
 		return dq
 	}
-	l.disqualified[m] = false
+	l.dqReason[m] = dqState{}
 
 	if max, ok := l.max[m.Path]; ok && cmpVersion(m.Version, max) > 0 {
-		l.disqualify(m)
-		return true
+		return l.disqualify(m, dqState{conflict: m})
 	}
 
 	summary, err := goModSummary(m)
@@ -242,14 +267,12 @@ func (l *versionLimiter) isDisqualified(m module.Version) bool {
 		// TODO(golang.org/issue/31730, golang.org/issue/30134): if the error
 		// is transient (we couldn't download go.mod), return the error from
 		// Downgrade. Currently, we can't tell what kind of error it is.
-		l.disqualify(m)
-		return true
+		return l.disqualify(m, dqState{err: err})
 	}
 
 	for _, r := range summary.require {
-		if l.isDisqualified(r) {
-			l.disqualify(m)
-			return true
+		if dq := l.check(r); dq.isDisqualified() {
+			return l.disqualify(m, dq)
 		}
 
 		// r and its dependencies are (perhaps provisionally) ok.
@@ -258,24 +281,25 @@ func (l *versionLimiter) isDisqualified(m module.Version) bool {
 		// checked a portion of the requirement graph so far, and r (and thus m) may
 		// yet be disqualified by some path we have not yet visited. Remember this edge
 		// so that we can disqualify m and its dependents if that occurs.
-		l.requiredBy[r] = append(l.requiredBy[r], m)
+		l.requiring[r] = append(l.requiring[r], m)
 	}
 
-	return false
+	return dqState{}
 }
 
 // disqualify records that m (or one of its transitive dependencies)
 // violates l's maximum version limits.
-func (l *versionLimiter) disqualify(m module.Version) {
-	if l.disqualified[m] {
-		return
+func (l *versionLimiter) disqualify(m module.Version, dq dqState) dqState {
+	if dq := l.dqReason[m]; dq.isDisqualified() {
+		return dq
 	}
-	l.disqualified[m] = true
+	l.dqReason[m] = dq
 
-	for _, p := range l.requiredBy[m] {
-		l.disqualify(p)
+	for _, p := range l.requiring[m] {
+		l.disqualify(p, dqState{conflict: m})
 	}
 	// Now that we have disqualified the modules that depend on m, we can forget
 	// about them — we won't need to disqualify them again.
-	delete(l.requiredBy, m)
+	delete(l.requiring, m)
+	return dq
 }
diff --git a/src/cmd/go/testdata/script/mod_get_downgrade.txt b/src/cmd/go/testdata/script/mod_get_downgrade.txt
index a954c10344..c26c5e1c21 100644
--- a/src/cmd/go/testdata/script/mod_get_downgrade.txt
+++ b/src/cmd/go/testdata/script/mod_get_downgrade.txt
@@ -20,8 +20,8 @@ stdout 'rsc.io/quote v1.5.1'
 stdout 'rsc.io/sampler v1.3.0'
 
 ! go get -d rsc.io/sampler@v1.0.0 rsc.io/quote@v1.5.2 golang.org/x/text@none
+stderr -count=1 '^go get:'
 stderr '^go get: rsc.io/quote@v1.5.2 requires rsc.io/sampler@v1.3.0, not rsc.io/sampler@v1.0.0$'
-stderr '^go get: rsc.io/quote@v1.5.2 requires golang.org/x/text@v0.0.0-20170915032832-14c0d48ead0c, not golang.org/x/text@none$'
 
 go list -m all
 stdout 'rsc.io/quote v1.5.1'
-- 
GitLab


From 7da8490cbb8659e3a9727b15e42def6e961e8fdf Mon Sep 17 00:00:00 2001
From: ianwoolf <btw515wolf2@gmail.com>
Date: Tue, 6 Apr 2021 22:05:45 +0800
Subject: [PATCH 1402/2400] path/filepath: replace os.MkdirTemp with T.TempDir

Change-Id: I6d78e0e742cb0e7f5ea3f430e9cec0f5d1ee03e9
Reviewed-on: https://go-review.googlesource.com/c/go/+/307652
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/path/filepath/path_test.go | 70 ++++++++--------------------------
 1 file changed, 15 insertions(+), 55 deletions(-)

diff --git a/src/path/filepath/path_test.go b/src/path/filepath/path_test.go
index 51eca49e4c..bb6bc0dd87 100644
--- a/src/path/filepath/path_test.go
+++ b/src/path/filepath/path_test.go
@@ -477,11 +477,7 @@ func testWalk(t *testing.T, walk func(string, fs.WalkDirFunc) error, errVisit in
 		defer restore()
 	}
 
-	tmpDir, err := os.MkdirTemp("", "TestWalk")
-	if err != nil {
-		t.Fatal("creating temp dir:", err)
-	}
-	defer os.RemoveAll(tmpDir)
+	tmpDir := t.TempDir()
 
 	origDir, err := os.Getwd()
 	if err != nil {
@@ -581,11 +577,7 @@ func touch(t *testing.T, name string) {
 }
 
 func TestWalkSkipDirOnFile(t *testing.T) {
-	td, err := os.MkdirTemp("", "walktest")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(td)
+	td := t.TempDir()
 
 	if err := os.MkdirAll(filepath.Join(td, "dir"), 0755); err != nil {
 		t.Fatal(err)
@@ -609,7 +601,7 @@ func TestWalkSkipDirOnFile(t *testing.T) {
 	check := func(t *testing.T, walk func(root string) error, root string) {
 		t.Helper()
 		sawFoo2 = false
-		err = walk(root)
+		err := walk(root)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -631,11 +623,7 @@ func TestWalkSkipDirOnFile(t *testing.T) {
 }
 
 func TestWalkFileError(t *testing.T) {
-	td, err := os.MkdirTemp("", "walktest")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(td)
+	td := t.TempDir()
 
 	touch(t, filepath.Join(td, "foo"))
 	touch(t, filepath.Join(td, "bar"))
@@ -656,7 +644,7 @@ func TestWalkFileError(t *testing.T) {
 		return os.Lstat(path)
 	}
 	got := map[string]error{}
-	err = filepath.Walk(td, func(path string, fi fs.FileInfo, err error) error {
+	err := filepath.Walk(td, func(path string, fi fs.FileInfo, err error) error {
 		rel, _ := filepath.Rel(td, path)
 		got[filepath.ToSlash(rel)] = err
 		return nil
@@ -910,14 +898,11 @@ func testEvalSymlinksAfterChdir(t *testing.T, wd, path, want string) {
 func TestEvalSymlinks(t *testing.T) {
 	testenv.MustHaveSymlink(t)
 
-	tmpDir, err := os.MkdirTemp("", "evalsymlink")
-	if err != nil {
-		t.Fatal("creating temp dir:", err)
-	}
-	defer os.RemoveAll(tmpDir)
+	tmpDir := t.TempDir()
 
 	// /tmp may itself be a symlink! Avoid the confusion, although
 	// it means trusting the thing we're testing.
+	var err error
 	tmpDir, err = filepath.EvalSymlinks(tmpDir)
 	if err != nil {
 		t.Fatal("eval symlink for tmp dir:", err)
@@ -996,14 +981,10 @@ func TestEvalSymlinksIsNotExist(t *testing.T) {
 func TestIssue13582(t *testing.T) {
 	testenv.MustHaveSymlink(t)
 
-	tmpDir, err := os.MkdirTemp("", "issue13582")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpDir)
+	tmpDir := t.TempDir()
 
 	dir := filepath.Join(tmpDir, "dir")
-	err = os.Mkdir(dir, 0755)
+	err := os.Mkdir(dir, 0755)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1083,12 +1064,7 @@ var absTests = []string{
 }
 
 func TestAbs(t *testing.T) {
-	root, err := os.MkdirTemp("", "TestAbs")
-	if err != nil {
-		t.Fatal("TempDir failed: ", err)
-	}
-	defer os.RemoveAll(root)
-
+	root := t.TempDir()
 	wd, err := os.Getwd()
 	if err != nil {
 		t.Fatal("getwd failed: ", err)
@@ -1154,11 +1130,7 @@ func TestAbs(t *testing.T) {
 // We test it separately from all other absTests because the empty string is not
 // a valid path, so it can't be used with os.Stat.
 func TestAbsEmptyString(t *testing.T) {
-	root, err := os.MkdirTemp("", "TestAbsEmptyString")
-	if err != nil {
-		t.Fatal("TempDir failed: ", err)
-	}
-	defer os.RemoveAll(root)
+	root := t.TempDir()
 
 	wd, err := os.Getwd()
 	if err != nil {
@@ -1376,11 +1348,7 @@ func TestBug3486(t *testing.T) { // https://golang.org/issue/3486
 }
 
 func testWalkSymlink(t *testing.T, mklink func(target, link string) error) {
-	tmpdir, err := os.MkdirTemp("", "testWalkSymlink")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	wd, err := os.Getwd()
 	if err != nil {
@@ -1426,14 +1394,10 @@ func TestWalkSymlink(t *testing.T) {
 }
 
 func TestIssue29372(t *testing.T) {
-	tmpDir, err := os.MkdirTemp("", "TestIssue29372")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpDir)
+	tmpDir := t.TempDir()
 
 	path := filepath.Join(tmpDir, "file.txt")
-	err = os.WriteFile(path, nil, 0644)
+	err := os.WriteFile(path, nil, 0644)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1462,11 +1426,7 @@ func TestEvalSymlinksAboveRoot(t *testing.T) {
 
 	t.Parallel()
 
-	tmpDir, err := os.MkdirTemp("", "TestEvalSymlinksAboveRoot")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpDir)
+	tmpDir := t.TempDir()
 
 	evalTmpDir, err := filepath.EvalSymlinks(tmpDir)
 	if err != nil {
-- 
GitLab


From 0a510478b0294744894385c6c6f5ded6829b6524 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Mon, 5 Apr 2021 20:26:11 -0400
Subject: [PATCH 1403/2400] runtime: use register ABI for race detector
 functions

runtime.raceread/racewrite/racewriterange are functions that are
called from compiler instrumented code, follwoing ABIInternal.
They are assembly functions defined as ABIInternal in the runtime,
in order to avoid wrappers because they need to get the caller's
PC. This CL makes them to use the actual internal ABI.

Change-Id: Id91d73cf257f7b11a858958d85c38c4aa904d9c3
Reviewed-on: https://go-review.googlesource.com/c/go/+/307812
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/race_amd64.s | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/runtime/race_amd64.s b/src/runtime/race_amd64.s
index 5f6b86a1fe..426777b8bf 100644
--- a/src/runtime/race_amd64.s
+++ b/src/runtime/race_amd64.s
@@ -44,7 +44,11 @@
 // Defined as ABIInternal so as to avoid introducing a wrapper,
 // which would render runtime.getcallerpc ineffective.
 TEXT	runtime·raceread<ABIInternal>(SB), NOSPLIT, $0-8
+#ifdef GOEXPERIMENT_REGABI_ARGS
+	MOVQ	AX, RARG1
+#else
 	MOVQ	addr+0(FP), RARG1
+#endif
 	MOVQ	(SP), RARG2
 	// void __tsan_read(ThreadState *thr, void *addr, void *pc);
 	MOVQ	$__tsan_read(SB), AX
@@ -70,7 +74,11 @@ TEXT	runtime·racereadpc(SB), NOSPLIT, $0-24
 // Defined as ABIInternal so as to avoid introducing a wrapper,
 // which would render runtime.getcallerpc ineffective.
 TEXT	runtime·racewrite<ABIInternal>(SB), NOSPLIT, $0-8
+#ifdef GOEXPERIMENT_REGABI_ARGS
+	MOVQ	AX, RARG1
+#else
 	MOVQ	addr+0(FP), RARG1
+#endif
 	MOVQ	(SP), RARG2
 	// void __tsan_write(ThreadState *thr, void *addr, void *pc);
 	MOVQ	$__tsan_write(SB), AX
@@ -121,8 +129,13 @@ TEXT	runtime·racereadrangepc1(SB), NOSPLIT, $0-24
 // Defined as ABIInternal so as to avoid introducing a wrapper,
 // which would render runtime.getcallerpc ineffective.
 TEXT	runtime·racewriterange<ABIInternal>(SB), NOSPLIT, $0-16
+#ifdef GOEXPERIMENT_REGABI_ARGS
+	MOVQ	AX, RARG1
+	MOVQ	BX, RARG2
+#else
 	MOVQ	addr+0(FP), RARG1
 	MOVQ	size+8(FP), RARG2
+#endif
 	MOVQ	(SP), RARG3
 	// void __tsan_write_range(ThreadState *thr, void *addr, uintptr size, void *pc);
 	MOVQ	$__tsan_write_range(SB), AX
-- 
GitLab


From b084073b53bfc4236d95819a3cc34dcbb4f15392 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Tue, 6 Apr 2021 21:55:19 +0000
Subject: [PATCH 1404/2400] reflect: refactor funcLayout tests

This change refactors the existing funcLayout tests and sets them up to
support the new register ABI by explicitly setting the register counts
to zero. This allows the test to pass if GOEXPERIMENT=regabiargs is set.

A follow-up change will add tests for a non-zero register count.

For #40724.

Change-Id: Ibbe061b4ed4fd70566eb38b9e6182dca32b81127
Reviewed-on: https://go-review.googlesource.com/c/go/+/307869
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/reflect/abi_test.go    |  54 +--------
 src/reflect/all_test.go    | 235 ++++++++++++++++++-------------------
 src/reflect/export_test.go |  57 ++++++---
 3 files changed, 158 insertions(+), 188 deletions(-)

diff --git a/src/reflect/abi_test.go b/src/reflect/abi_test.go
index 62f6bd2e3e..224143c9bf 100644
--- a/src/reflect/abi_test.go
+++ b/src/reflect/abi_test.go
@@ -22,23 +22,7 @@ func TestMethodValueCallABI(t *testing.T) {
 	// Enable register-based reflect.Call and ensure we don't
 	// use potentially incorrect cached versions by clearing
 	// the cache before we start and after we're done.
-	var oldRegs struct {
-		ints, floats int
-		floatSize    uintptr
-	}
-	oldRegs.ints = *reflect.IntArgRegs
-	oldRegs.floats = *reflect.FloatArgRegs
-	oldRegs.floatSize = *reflect.FloatRegSize
-	*reflect.IntArgRegs = abi.IntArgRegs
-	*reflect.FloatArgRegs = abi.FloatArgRegs
-	*reflect.FloatRegSize = uintptr(abi.EffectiveFloatRegSize)
-	reflect.ClearLayoutCache()
-	defer func() {
-		*reflect.IntArgRegs = oldRegs.ints
-		*reflect.FloatArgRegs = oldRegs.floats
-		*reflect.FloatRegSize = oldRegs.floatSize
-		reflect.ClearLayoutCache()
-	}()
+	defer reflect.SetArgRegs(reflect.SetArgRegs(abi.IntArgRegs, abi.FloatArgRegs, abi.EffectiveFloatRegSize))
 
 	// This test is simple. Calling a method value involves
 	// pretty much just plumbing whatever arguments in whichever
@@ -129,23 +113,7 @@ func TestReflectCallABI(t *testing.T) {
 	// Enable register-based reflect.Call and ensure we don't
 	// use potentially incorrect cached versions by clearing
 	// the cache before we start and after we're done.
-	var oldRegs struct {
-		ints, floats int
-		floatSize    uintptr
-	}
-	oldRegs.ints = *reflect.IntArgRegs
-	oldRegs.floats = *reflect.FloatArgRegs
-	oldRegs.floatSize = *reflect.FloatRegSize
-	*reflect.IntArgRegs = abi.IntArgRegs
-	*reflect.FloatArgRegs = abi.FloatArgRegs
-	*reflect.FloatRegSize = uintptr(abi.EffectiveFloatRegSize)
-	reflect.ClearLayoutCache()
-	defer func() {
-		*reflect.IntArgRegs = oldRegs.ints
-		*reflect.FloatArgRegs = oldRegs.floats
-		*reflect.FloatRegSize = oldRegs.floatSize
-		reflect.ClearLayoutCache()
-	}()
+	defer reflect.SetArgRegs(reflect.SetArgRegs(abi.IntArgRegs, abi.FloatArgRegs, abi.EffectiveFloatRegSize))
 
 	// Execute the functions defined below which all have the
 	// same form and perform the same function: pass all arguments
@@ -182,23 +150,7 @@ func TestReflectMakeFuncCallABI(t *testing.T) {
 	// Enable register-based reflect.MakeFunc and ensure we don't
 	// use potentially incorrect cached versions by clearing
 	// the cache before we start and after we're done.
-	var oldRegs struct {
-		ints, floats int
-		floatSize    uintptr
-	}
-	oldRegs.ints = *reflect.IntArgRegs
-	oldRegs.floats = *reflect.FloatArgRegs
-	oldRegs.floatSize = *reflect.FloatRegSize
-	*reflect.IntArgRegs = abi.IntArgRegs
-	*reflect.FloatArgRegs = abi.FloatArgRegs
-	*reflect.FloatRegSize = uintptr(abi.EffectiveFloatRegSize)
-	reflect.ClearLayoutCache()
-	defer func() {
-		*reflect.IntArgRegs = oldRegs.ints
-		*reflect.FloatArgRegs = oldRegs.floats
-		*reflect.FloatRegSize = oldRegs.floatSize
-		reflect.ClearLayoutCache()
-	}()
+	defer reflect.SetArgRegs(reflect.SetArgRegs(abi.IntArgRegs, abi.FloatArgRegs, abi.EffectiveFloatRegSize))
 
 	// Execute the functions defined below which all have the
 	// same form and perform the same function: pass all arguments
diff --git a/src/reflect/all_test.go b/src/reflect/all_test.go
index e4b74f72d9..241f6b0b5a 100644
--- a/src/reflect/all_test.go
+++ b/src/reflect/all_test.go
@@ -6396,144 +6396,135 @@ func clobber() {
 	runtime.GC()
 }
 
-type funcLayoutTest struct {
-	rcvr, t                  Type
-	size, argsize, retOffset uintptr
-	stack                    []byte // pointer bitmap: 1 is pointer, 0 is scalar
-	gc                       []byte
-}
-
-var funcLayoutTests []funcLayoutTest
-
-func init() {
-	var argAlign uintptr = PtrSize
-	roundup := func(x uintptr, a uintptr) uintptr {
-		return (x + a - 1) / a * a
-	}
-
-	funcLayoutTests = append(funcLayoutTests,
-		funcLayoutTest{
-			nil,
-			ValueOf(func(a, b string) string { return "" }).Type(),
-			6 * PtrSize,
-			4 * PtrSize,
-			4 * PtrSize,
-			[]byte{1, 0, 1, 0, 1},
-			[]byte{1, 0, 1, 0, 1},
-		})
-
+func TestFuncLayout(t *testing.T) {
+	align := func(x uintptr) uintptr {
+		return (x + PtrSize - 1) &^ (PtrSize - 1)
+	}
 	var r []byte
 	if PtrSize == 4 {
 		r = []byte{0, 0, 0, 1}
 	} else {
 		r = []byte{0, 0, 1}
 	}
-	funcLayoutTests = append(funcLayoutTests,
-		funcLayoutTest{
-			nil,
-			ValueOf(func(a, b, c uint32, p *byte, d uint16) {}).Type(),
-			roundup(roundup(3*4, PtrSize)+PtrSize+2, argAlign),
-			roundup(3*4, PtrSize) + PtrSize + 2,
-			roundup(roundup(3*4, PtrSize)+PtrSize+2, argAlign),
-			r,
-			r,
-		})
-
-	funcLayoutTests = append(funcLayoutTests,
-		funcLayoutTest{
-			nil,
-			ValueOf(func(a map[int]int, b uintptr, c interface{}) {}).Type(),
-			4 * PtrSize,
-			4 * PtrSize,
-			4 * PtrSize,
-			[]byte{1, 0, 1, 1},
-			[]byte{1, 0, 1, 1},
-		})
 
 	type S struct {
 		a, b uintptr
 		c, d *byte
 	}
-	funcLayoutTests = append(funcLayoutTests,
-		funcLayoutTest{
-			nil,
-			ValueOf(func(a S) {}).Type(),
-			4 * PtrSize,
-			4 * PtrSize,
-			4 * PtrSize,
-			[]byte{0, 0, 1, 1},
-			[]byte{0, 0, 1, 1},
-		})
-
-	funcLayoutTests = append(funcLayoutTests,
-		funcLayoutTest{
-			ValueOf((*byte)(nil)).Type(),
-			ValueOf(func(a uintptr, b *int) {}).Type(),
-			roundup(3*PtrSize, argAlign),
-			3 * PtrSize,
-			roundup(3*PtrSize, argAlign),
-			[]byte{1, 0, 1},
-			[]byte{1, 0, 1},
-		})
 
-	funcLayoutTests = append(funcLayoutTests,
-		funcLayoutTest{
-			nil,
-			ValueOf(func(a uintptr) {}).Type(),
-			roundup(PtrSize, argAlign),
-			PtrSize,
-			roundup(PtrSize, argAlign),
-			[]byte{},
-			[]byte{},
-		})
-
-	funcLayoutTests = append(funcLayoutTests,
-		funcLayoutTest{
-			nil,
-			ValueOf(func() uintptr { return 0 }).Type(),
-			PtrSize,
-			0,
-			0,
-			[]byte{},
-			[]byte{},
-		})
-
-	funcLayoutTests = append(funcLayoutTests,
-		funcLayoutTest{
-			ValueOf(uintptr(0)).Type(),
-			ValueOf(func(a uintptr) {}).Type(),
-			2 * PtrSize,
-			2 * PtrSize,
-			2 * PtrSize,
-			[]byte{1},
-			[]byte{1},
+	type test struct {
+		rcvr, typ                  Type
+		size, argsize, retOffset   uintptr
+		stack, gc, inRegs, outRegs []byte // pointer bitmap: 1 is pointer, 0 is scalar
+		intRegs, floatRegs         int
+		floatRegSize               uintptr
+	}
+	tests := []test{
+		{
+			typ:       ValueOf(func(a, b string) string { return "" }).Type(),
+			size:      6 * PtrSize,
+			argsize:   4 * PtrSize,
+			retOffset: 4 * PtrSize,
+			stack:     []byte{1, 0, 1, 0, 1},
+			gc:        []byte{1, 0, 1, 0, 1},
+		},
+		{
+			typ:       ValueOf(func(a, b, c uint32, p *byte, d uint16) {}).Type(),
+			size:      align(align(3*4) + PtrSize + 2),
+			argsize:   align(3*4) + PtrSize + 2,
+			retOffset: align(align(3*4) + PtrSize + 2),
+			stack:     r,
+			gc:        r,
+		},
+		{
+			typ:       ValueOf(func(a map[int]int, b uintptr, c interface{}) {}).Type(),
+			size:      4 * PtrSize,
+			argsize:   4 * PtrSize,
+			retOffset: 4 * PtrSize,
+			stack:     []byte{1, 0, 1, 1},
+			gc:        []byte{1, 0, 1, 1},
+		},
+		{
+			typ:       ValueOf(func(a S) {}).Type(),
+			size:      4 * PtrSize,
+			argsize:   4 * PtrSize,
+			retOffset: 4 * PtrSize,
+			stack:     []byte{0, 0, 1, 1},
+			gc:        []byte{0, 0, 1, 1},
+		},
+		{
+			rcvr:      ValueOf((*byte)(nil)).Type(),
+			typ:       ValueOf(func(a uintptr, b *int) {}).Type(),
+			size:      3 * PtrSize,
+			argsize:   3 * PtrSize,
+			retOffset: 3 * PtrSize,
+			stack:     []byte{1, 0, 1},
+			gc:        []byte{1, 0, 1},
+		},
+		{
+			typ:       ValueOf(func(a uintptr) {}).Type(),
+			size:      PtrSize,
+			argsize:   PtrSize,
+			retOffset: PtrSize,
+			stack:     []byte{},
+			gc:        []byte{},
+		},
+		{
+			typ:       ValueOf(func() uintptr { return 0 }).Type(),
+			size:      PtrSize,
+			argsize:   0,
+			retOffset: 0,
+			stack:     []byte{},
+			gc:        []byte{},
+		},
+		{
+			rcvr:      ValueOf(uintptr(0)).Type(),
+			typ:       ValueOf(func(a uintptr) {}).Type(),
+			size:      2 * PtrSize,
+			argsize:   2 * PtrSize,
+			retOffset: 2 * PtrSize,
+			stack:     []byte{1},
+			gc:        []byte{1},
 			// Note: this one is tricky, as the receiver is not a pointer. But we
 			// pass the receiver by reference to the autogenerated pointer-receiver
 			// version of the function.
-		})
-}
-
-func TestFuncLayout(t *testing.T) {
-	for _, lt := range funcLayoutTests {
-		typ, argsize, retOffset, stack, gc, ptrs := FuncLayout(lt.t, lt.rcvr)
-		if typ.Size() != lt.size {
-			t.Errorf("funcLayout(%v, %v).size=%d, want %d", lt.t, lt.rcvr, typ.Size(), lt.size)
-		}
-		if argsize != lt.argsize {
-			t.Errorf("funcLayout(%v, %v).argsize=%d, want %d", lt.t, lt.rcvr, argsize, lt.argsize)
-		}
-		if retOffset != lt.retOffset {
-			t.Errorf("funcLayout(%v, %v).retOffset=%d, want %d", lt.t, lt.rcvr, retOffset, lt.retOffset)
-		}
-		if !bytes.Equal(stack, lt.stack) {
-			t.Errorf("funcLayout(%v, %v).stack=%v, want %v", lt.t, lt.rcvr, stack, lt.stack)
-		}
-		if !bytes.Equal(gc, lt.gc) {
-			t.Errorf("funcLayout(%v, %v).gc=%v, want %v", lt.t, lt.rcvr, gc, lt.gc)
-		}
-		if ptrs && len(stack) == 0 || !ptrs && len(stack) > 0 {
-			t.Errorf("funcLayout(%v, %v) pointers flag=%v, want %v", lt.t, lt.rcvr, ptrs, !ptrs)
+		},
+		// TODO(mknyszek): Add tests for non-zero register count.
+	}
+	for _, lt := range tests {
+		name := lt.typ.String()
+		if lt.rcvr != nil {
+			name = lt.rcvr.String() + "." + name
 		}
+		t.Run(name, func(t *testing.T) {
+			defer SetArgRegs(SetArgRegs(lt.intRegs, lt.floatRegs, lt.floatRegSize))
+
+			typ, argsize, retOffset, stack, gc, inRegs, outRegs, ptrs := FuncLayout(lt.typ, lt.rcvr)
+			if typ.Size() != lt.size {
+				t.Errorf("funcLayout(%v, %v).size=%d, want %d", lt.typ, lt.rcvr, typ.Size(), lt.size)
+			}
+			if argsize != lt.argsize {
+				t.Errorf("funcLayout(%v, %v).argsize=%d, want %d", lt.typ, lt.rcvr, argsize, lt.argsize)
+			}
+			if retOffset != lt.retOffset {
+				t.Errorf("funcLayout(%v, %v).retOffset=%d, want %d", lt.typ, lt.rcvr, retOffset, lt.retOffset)
+			}
+			if !bytes.Equal(stack, lt.stack) {
+				t.Errorf("funcLayout(%v, %v).stack=%v, want %v", lt.typ, lt.rcvr, stack, lt.stack)
+			}
+			if !bytes.Equal(gc, lt.gc) {
+				t.Errorf("funcLayout(%v, %v).gc=%v, want %v", lt.typ, lt.rcvr, gc, lt.gc)
+			}
+			if !bytes.Equal(inRegs, lt.inRegs) {
+				t.Errorf("funcLayout(%v, %v).inRegs=%v, want %v", lt.typ, lt.rcvr, inRegs, lt.inRegs)
+			}
+			if !bytes.Equal(outRegs, lt.outRegs) {
+				t.Errorf("funcLayout(%v, %v).outRegs=%v, want %v", lt.typ, lt.rcvr, outRegs, lt.outRegs)
+			}
+			if ptrs && len(stack) == 0 || !ptrs && len(stack) > 0 {
+				t.Errorf("funcLayout(%v, %v) pointers flag=%v, want %v", lt.typ, lt.rcvr, ptrs, !ptrs)
+			}
+		})
 	}
 }
 
diff --git a/src/reflect/export_test.go b/src/reflect/export_test.go
index 3a5ed5af3c..b6830a9802 100644
--- a/src/reflect/export_test.go
+++ b/src/reflect/export_test.go
@@ -20,33 +20,49 @@ func IsRO(v Value) bool {
 	return v.flag&flagStickyRO != 0
 }
 
-var (
-	IntArgRegs   = &intArgRegs
-	FloatArgRegs = &floatArgRegs
-	FloatRegSize = &floatRegSize
-)
-
 var CallGC = &callGC
 
 const PtrSize = ptrSize
 
-func FuncLayout(t Type, rcvr Type) (frametype Type, argSize, retOffset uintptr, stack []byte, gc []byte, ptrs bool) {
+// FuncLayout calls funcLayout and returns a subset of the results for testing.
+//
+// Bitmaps like stack, gc, inReg, and outReg are expanded such that each bit
+// takes up one byte, so that writing out test cases is a little clearer.
+// If ptrs is false, gc will be nil.
+func FuncLayout(t Type, rcvr Type) (frametype Type, argSize, retOffset uintptr, stack, gc, inReg, outReg []byte, ptrs bool) {
 	var ft *rtype
-	var abi abiDesc
+	var abid abiDesc
 	if rcvr != nil {
-		ft, _, abi = funcLayout((*funcType)(unsafe.Pointer(t.(*rtype))), rcvr.(*rtype))
+		ft, _, abid = funcLayout((*funcType)(unsafe.Pointer(t.(*rtype))), rcvr.(*rtype))
 	} else {
-		ft, _, abi = funcLayout((*funcType)(unsafe.Pointer(t.(*rtype))), nil)
+		ft, _, abid = funcLayout((*funcType)(unsafe.Pointer(t.(*rtype))), nil)
 	}
-	argSize = abi.stackCallArgsSize
-	retOffset = abi.retOffset
+	// Extract size information.
+	argSize = abid.stackCallArgsSize
+	retOffset = abid.retOffset
 	frametype = ft
-	for i := uint32(0); i < abi.stackPtrs.n; i++ {
-		stack = append(stack, abi.stackPtrs.data[i/8]>>(i%8)&1)
+
+	// Expand stack pointer bitmap into byte-map.
+	for i := uint32(0); i < abid.stackPtrs.n; i++ {
+		stack = append(stack, abid.stackPtrs.data[i/8]>>(i%8)&1)
+	}
+
+	// Expand register pointer bitmaps into byte-maps.
+	bool2byte := func(b bool) byte {
+		if b {
+			return 1
+		}
+		return 0
+	}
+	for i := 0; i < intArgRegs; i++ {
+		inReg = append(inReg, bool2byte(abid.inRegPtrs.Get(i)))
+		outReg = append(outReg, bool2byte(abid.outRegPtrs.Get(i)))
 	}
 	if ft.kind&kindGCProg != 0 {
 		panic("can't handle gc programs")
 	}
+
+	// Expand frame type's GC bitmap into byte-map.
 	ptrs = ft.ptrdata != 0
 	if ptrs {
 		nptrs := ft.ptrdata / ptrSize
@@ -132,6 +148,17 @@ type Buffer struct {
 	buf []byte
 }
 
-func ClearLayoutCache() {
+func clearLayoutCache() {
 	layoutCache = sync.Map{}
 }
+
+func SetArgRegs(ints, floats int, floatSize uintptr) (oldInts, oldFloats int, oldFloatSize uintptr) {
+	oldInts = intArgRegs
+	oldFloats = floatArgRegs
+	oldFloatSize = floatRegSize
+	intArgRegs = ints
+	floatArgRegs = floats
+	floatRegSize = floatSize
+	clearLayoutCache()
+	return
+}
-- 
GitLab


From 972e8839254d59dc04a1193c4c9633a74595a2e7 Mon Sep 17 00:00:00 2001
From: Changkun Ou <hi@changkun.de>
Date: Tue, 23 Feb 2021 09:58:14 +0100
Subject: [PATCH 1405/2400] runtime/cgo: add Handle for managing (c)go pointers
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A non-trivial Cgo program may need to use callbacks and interact with
go objects per goroutine. Because of the rules for passing pointers
between Go and C, such a program needs to store handles to associated
Go values. This often causes much extra effort to figure out a way to
correctly deal with: 1) map collision; 2) identifying leaks and 3)
concurrency.

This CL implements a Handle representation in runtime/cgo package, and
related methods such as Value, Delete, etc. which allows Go users can
use a standard way to handle the above difficulties.

In addition, the CL allows a Go value to have multiple handles, and the
NewHandle always returns a different handle compare to the previously
returned handles. In comparison, CL 294670 implements a different
behavior of NewHandle that returns a unique handle when the Go value is
referring to the same object.

Benchmark:
name                      time/op
Handle/non-concurrent-16  487ns ± 1%
Handle/concurrent-16      674ns ± 1%

Fixes #37033

Change-Id: I0eadb9d44332fffef8fb567c745246a49dd6d4c1
Reviewed-on: https://go-review.googlesource.com/c/go/+/295369
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Cherry Zhang <cherryyz@google.com>
---
 doc/go1.17.html                 |   9 +++
 misc/cgo/test/cgo_test.go       |   1 +
 misc/cgo/test/test.go           |  22 +++++++
 misc/cgo/test/testx.go          |  12 ++++
 src/cmd/cgo/doc.go              |   3 +
 src/cmd/link/internal/ld/lib.go |   7 ++-
 src/runtime/cgo/handle.go       | 103 ++++++++++++++++++++++++++++++++
 src/runtime/cgo/handle_test.go  | 103 ++++++++++++++++++++++++++++++++
 8 files changed, 259 insertions(+), 1 deletion(-)
 create mode 100644 src/runtime/cgo/handle.go
 create mode 100644 src/runtime/cgo/handle_test.go

diff --git a/doc/go1.17.html b/doc/go1.17.html
index cd61dd8cef..66078b12a9 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -120,6 +120,15 @@ Do not send CLs removing the interior tags from such phrases.
   has no effect.
 </p>
 
+<h3 id="runtime/cgo"><a href="/pkg/runtime/cgo">Cgo</a></h3>
+
+<p>
+The <a href="/pkg/runtime/cgo">runtime/cgo</a> package now provides a
+new facility that allows to turn any Go values to a safe representation
+that can be used to pass values between C and Go safely. See
+<a href="/pkg/runtime/cgo#Handle">runtime/cgo.Handle</a> for more information.
+</p>
+
 <h3 id="minor_library_changes">Minor changes to the library</h3>
 
 <p>
diff --git a/misc/cgo/test/cgo_test.go b/misc/cgo/test/cgo_test.go
index f7a76d047b..837307263a 100644
--- a/misc/cgo/test/cgo_test.go
+++ b/misc/cgo/test/cgo_test.go
@@ -80,6 +80,7 @@ func TestNamedEnum(t *testing.T)             { testNamedEnum(t) }
 func TestCastToEnum(t *testing.T)            { testCastToEnum(t) }
 func TestErrno(t *testing.T)                 { testErrno(t) }
 func TestFpVar(t *testing.T)                 { testFpVar(t) }
+func TestHandle(t *testing.T)                { testHandle(t) }
 func TestHelpers(t *testing.T)               { testHelpers(t) }
 func TestLibgcc(t *testing.T)                { testLibgcc(t) }
 func TestMultipleAssign(t *testing.T)        { testMultipleAssign(t) }
diff --git a/misc/cgo/test/test.go b/misc/cgo/test/test.go
index 65823b1ca0..76afa524c3 100644
--- a/misc/cgo/test/test.go
+++ b/misc/cgo/test/test.go
@@ -899,6 +899,10 @@ static uint16_t issue31093F(uint16_t v) { return v; }
 // issue 32579
 typedef struct S32579 { unsigned char data[1]; } S32579;
 
+// issue 37033, cgo.Handle
+extern void GoFunc37033(uintptr_t handle);
+void cFunc37033(uintptr_t handle) { GoFunc37033(handle); }
+
 // issue 38649
 // Test that #define'd type aliases work.
 #define netbsd_gid unsigned int
@@ -920,6 +924,7 @@ import (
 	"os/signal"
 	"reflect"
 	"runtime"
+	"runtime/cgo"
 	"sync"
 	"syscall"
 	"testing"
@@ -2230,6 +2235,23 @@ func test32579(t *testing.T) {
 	}
 }
 
+// issue 37033, check if cgo.Handle works properly
+
+func testHandle(t *testing.T) {
+	ch := make(chan int)
+
+	for i := 0; i < 42; i++ {
+		h := cgo.NewHandle(ch)
+		go func() {
+			C.cFunc37033(C.uintptr_t(h))
+		}()
+		if v := <-ch; issue37033 != v {
+			t.Fatalf("unexpected receiving value: got %d, want %d", v, issue37033)
+		}
+		h.Delete()
+	}
+}
+
 // issue 38649
 
 var issue38649 C.netbsd_gid = 42
diff --git a/misc/cgo/test/testx.go b/misc/cgo/test/testx.go
index 2b2e69ec00..044c5bceff 100644
--- a/misc/cgo/test/testx.go
+++ b/misc/cgo/test/testx.go
@@ -12,6 +12,7 @@ package cgotest
 
 import (
 	"runtime"
+	"runtime/cgo"
 	"runtime/debug"
 	"strings"
 	"sync"
@@ -558,6 +559,17 @@ func test31891(t *testing.T) {
 	C.callIssue31891()
 }
 
+// issue 37033, check if cgo.Handle works properly
+
+var issue37033 = 42
+
+//export GoFunc37033
+func GoFunc37033(handle C.uintptr_t) {
+	h := cgo.Handle(handle)
+	ch := h.Value().(chan int)
+	ch <- issue37033
+}
+
 // issue 38408
 // A typedef pointer can be used as the element type.
 // No runtime test; just make sure it compiles.
diff --git a/src/cmd/cgo/doc.go b/src/cmd/cgo/doc.go
index e782c866ac..a6787f6405 100644
--- a/src/cmd/cgo/doc.go
+++ b/src/cmd/cgo/doc.go
@@ -387,6 +387,9 @@ and of course there is nothing stopping the C code from doing anything
 it likes. However, programs that break these rules are likely to fail
 in unexpected and unpredictable ways.
 
+The runtime/cgo.Handle type can be used to safely pass Go values
+between Go and C. See the runtime/cgo package documentation for details.
+
 Note: the current implementation has a bug. While Go code is permitted
 to write nil or a C pointer (but not a Go pointer) to C memory, the
 current implementation may sometimes cause a runtime error if the
diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index 85d0eedecf..4d5be30d82 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -556,7 +556,12 @@ func (ctxt *Link) loadlib() {
 			if ctxt.BuildMode == BuildModeShared || ctxt.linkShared {
 				Exitf("cannot implicitly include runtime/cgo in a shared library")
 			}
-			loadobjfile(ctxt, lib)
+			for ; i < len(ctxt.Library); i++ {
+				lib := ctxt.Library[i]
+				if lib.Shlib == "" {
+					loadobjfile(ctxt, lib)
+				}
+			}
 		}
 	}
 
diff --git a/src/runtime/cgo/handle.go b/src/runtime/cgo/handle.go
new file mode 100644
index 0000000000..a798ba9064
--- /dev/null
+++ b/src/runtime/cgo/handle.go
@@ -0,0 +1,103 @@
+// Copyright 2021 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 cgo
+
+import (
+	"sync"
+	"sync/atomic"
+)
+
+// Handle provides a safe representation of Go values to pass between
+// Go and C. The zero value of a handle is not a valid handle, and thus
+// is safe to use as a sentinel in C APIs.
+//
+// The underlying type of Handle is guaranteed to fit in an integer type
+// that is large enough to hold the bit pattern of any pointer.
+// For instance, on the Go side:
+//
+// 	package main
+//
+// 	/*
+// 	#include <stdint.h> // for uintptr_t
+//
+// 	extern void MyGoPrint(uintptr_t handle);
+// 	void myprint(uintptr_t handle);
+// 	*/
+// 	import "C"
+// 	import "runtime/cgo"
+//
+// 	//export MyGoPrint
+// 	func MyGoPrint(handle C.uintptr_t) {
+// 		h := cgo.Handle(handle)
+// 		val := h.Value().(int)
+// 		println(val)
+// 		h.Delete()
+// 	}
+//
+// 	func main() {
+// 		val := 42
+// 		C.myprint(C.uintptr_t(cgo.NewHandle(val)))
+// 		// Output: 42
+// 	}
+//
+// and on the C side:
+//
+// 	#include <stdint.h> // for uintptr_t
+//
+// 	// A Go function
+// 	extern void MyGoPrint(uintptr_t handle);
+//
+// 	// A C function
+// 	void myprint(uintptr_t handle) {
+// 	    MyGoPrint(handle);
+// 	}
+type Handle uintptr
+
+// NewHandle returns a handle for a given value.
+//
+// The handle is valid until the program calls Delete on it. The handle
+// uses resources, and this package assumes that C code may hold on to
+// the handle, so a program must explicitly call Delete when the handle
+// is no longer needed.
+//
+// The intended use is to pass the returned handle to C code, which
+// passes it back to Go, which calls Value.
+func NewHandle(v interface{}) Handle {
+	h := atomic.AddUintptr(&handleIdx, 1)
+	if h == 0 {
+		panic("runtime/cgo: ran out of handle space")
+	}
+
+	handles.Store(h, v)
+	return Handle(h)
+}
+
+// Value returns the associated Go value for a valid handle.
+//
+// The method panics if the handle is invalid.
+func (h Handle) Value() interface{} {
+	v, ok := handles.Load(uintptr(h))
+	if !ok {
+		panic("runtime/cgo: misuse of an invalid Handle")
+	}
+	return v
+}
+
+// Delete invalidates a handle. This method should only be called once
+// the program no longer needs to pass the handle to C and the C code
+// no longer has a copy of the handle value.
+//
+// The method panics if the handle is invalid.
+func (h Handle) Delete() {
+	_, ok := handles.LoadAndDelete(uintptr(h))
+	if !ok {
+		panic("runtime/cgo: misuse of an invalid Handle")
+	}
+}
+
+var (
+	handles   = sync.Map{} // map[Handle]interface{}
+	handleIdx uintptr      // atomic
+)
diff --git a/src/runtime/cgo/handle_test.go b/src/runtime/cgo/handle_test.go
new file mode 100644
index 0000000000..738051a0ea
--- /dev/null
+++ b/src/runtime/cgo/handle_test.go
@@ -0,0 +1,103 @@
+// Copyright 2021 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 cgo
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestHandle(t *testing.T) {
+	v := 42
+
+	tests := []struct {
+		v1 interface{}
+		v2 interface{}
+	}{
+		{v1: v, v2: v},
+		{v1: &v, v2: &v},
+		{v1: nil, v2: nil},
+	}
+
+	for _, tt := range tests {
+		h1 := NewHandle(tt.v1)
+		h2 := NewHandle(tt.v2)
+
+		if uintptr(h1) == 0 || uintptr(h2) == 0 {
+			t.Fatalf("NewHandle returns zero")
+		}
+
+		if uintptr(h1) == uintptr(h2) {
+			t.Fatalf("Duplicated Go values should have different handles, but got equal")
+		}
+
+		h1v := h1.Value()
+		h2v := h2.Value()
+		if !reflect.DeepEqual(h1v, h2v) || !reflect.DeepEqual(h1v, tt.v1) {
+			t.Fatalf("Value of a Handle got wrong, got %+v %+v, want %+v", h1v, h2v, tt.v1)
+		}
+
+		h1.Delete()
+		h2.Delete()
+	}
+
+	siz := 0
+	handles.Range(func(k, v interface{}) bool {
+		siz++
+		return true
+	})
+	if siz != 0 {
+		t.Fatalf("handles are not cleared, got %d, want %d", siz, 0)
+	}
+}
+
+func TestInvalidHandle(t *testing.T) {
+	t.Run("zero", func(t *testing.T) {
+		h := Handle(0)
+
+		defer func() {
+			if r := recover(); r != nil {
+				return
+			}
+			t.Fatalf("Delete of zero handle did not trigger a panic")
+		}()
+
+		h.Delete()
+	})
+
+	t.Run("invalid", func(t *testing.T) {
+		h := NewHandle(42)
+
+		defer func() {
+			if r := recover(); r != nil {
+				h.Delete()
+				return
+			}
+			t.Fatalf("Invalid handle did not trigger a panic")
+		}()
+
+		Handle(h + 1).Delete()
+	})
+}
+
+func BenchmarkHandle(b *testing.B) {
+	b.Run("non-concurrent", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			h := NewHandle(i)
+			_ = h.Value()
+			h.Delete()
+		}
+	})
+	b.Run("concurrent", func(b *testing.B) {
+		b.RunParallel(func(pb *testing.PB) {
+			var v int
+			for pb.Next() {
+				h := NewHandle(v)
+				_ = h.Value()
+				h.Delete()
+			}
+		})
+	})
+}
-- 
GitLab


From 8d77e45064fc808460843e741c46e3b6b737ae03 Mon Sep 17 00:00:00 2001
From: eric fang <eric.fang@arm.com>
Date: Tue, 6 Apr 2021 07:23:38 +0000
Subject: [PATCH 1406/2400] cmd/compile: fix bug of conditional instructions on
 arm64

CL 302231 added some optimization rules with instructions CSETM, CSINC,
CSINV, and CSNEG, but did not deal with the situation where flag is
constant, resulting in some cases that could be more optimized cannot
be optimized, and the FlagConstant value is passed to codegen pass. This
CL adds these missing rules.

Fixes #45359

Change-Id: I700608cfb9a6a768a18d1fd5d374d7e92aa6f838
Reviewed-on: https://go-review.googlesource.com/c/go/+/307650
Reviewed-by: eric fang <eric.fang@arm.com>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Alberto Donizetti <alb.donizetti@gmail.com>
Run-TryBot: eric fang <eric.fang@arm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: eric fang <eric.fang@arm.com>
Trust: Alberto Donizetti <alb.donizetti@gmail.com>
---
 src/cmd/compile/internal/ssa/gen/ARM64.rules |   8 ++
 src/cmd/compile/internal/ssa/rewriteARM64.go | 108 +++++++++++++++++++
 test/fixedbugs/issue45359.go                 |  20 ++++
 3 files changed, 136 insertions(+)
 create mode 100644 test/fixedbugs/issue45359.go

diff --git a/src/cmd/compile/internal/ssa/gen/ARM64.rules b/src/cmd/compile/internal/ssa/gen/ARM64.rules
index cb997776db..3d2759493e 100644
--- a/src/cmd/compile/internal/ssa/gen/ARM64.rules
+++ b/src/cmd/compile/internal/ssa/gen/ARM64.rules
@@ -1570,6 +1570,14 @@
 (CSEL [cc] _ y flag) && ccARM64Eval(cc, flag) < 0 => y
 (CSEL0 [cc] x flag) && ccARM64Eval(cc, flag) > 0 => x
 (CSEL0 [cc] _ flag) && ccARM64Eval(cc, flag) < 0 => (MOVDconst [0])
+(CSNEG [cc] x _ flag) && ccARM64Eval(cc, flag) > 0 => x
+(CSNEG [cc] _ y flag) && ccARM64Eval(cc, flag) < 0 => (NEG y)
+(CSINV [cc] x _ flag) && ccARM64Eval(cc, flag) > 0 => x
+(CSINV [cc] _ y flag) && ccARM64Eval(cc, flag) < 0 => (Not y)
+(CSINC [cc] x _ flag) && ccARM64Eval(cc, flag) > 0 => x
+(CSINC [cc] _ y flag) && ccARM64Eval(cc, flag) < 0 => (ADDconst [1] y)
+(CSETM [cc] flag) && ccARM64Eval(cc, flag) > 0 => (MOVDconst [-1])
+(CSETM [cc] flag) && ccARM64Eval(cc, flag) < 0 => (MOVDconst [0])
 
 // absorb flags back into boolean CSEL
 (CSEL [cc] x y (CMPWconst [0] boolval)) && cc == OpARM64NotEqual && flagArg(boolval) != nil =>
diff --git a/src/cmd/compile/internal/ssa/rewriteARM64.go b/src/cmd/compile/internal/ssa/rewriteARM64.go
index cdc246205c..0ba3951df5 100644
--- a/src/cmd/compile/internal/ssa/rewriteARM64.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM64.go
@@ -3619,6 +3619,32 @@ func rewriteValueARM64_OpARM64CSETM(v *Value) bool {
 		v.AddArg(cmp)
 		return true
 	}
+	// match: (CSETM [cc] flag)
+	// cond: ccARM64Eval(cc, flag) > 0
+	// result: (MOVDconst [-1])
+	for {
+		cc := auxIntToOp(v.AuxInt)
+		flag := v_0
+		if !(ccARM64Eval(cc, flag) > 0) {
+			break
+		}
+		v.reset(OpARM64MOVDconst)
+		v.AuxInt = int64ToAuxInt(-1)
+		return true
+	}
+	// match: (CSETM [cc] flag)
+	// cond: ccARM64Eval(cc, flag) < 0
+	// result: (MOVDconst [0])
+	for {
+		cc := auxIntToOp(v.AuxInt)
+		flag := v_0
+		if !(ccARM64Eval(cc, flag) < 0) {
+			break
+		}
+		v.reset(OpARM64MOVDconst)
+		v.AuxInt = int64ToAuxInt(0)
+		return true
+	}
 	return false
 }
 func rewriteValueARM64_OpARM64CSINC(v *Value) bool {
@@ -3640,6 +3666,34 @@ func rewriteValueARM64_OpARM64CSINC(v *Value) bool {
 		v.AddArg3(x, y, cmp)
 		return true
 	}
+	// match: (CSINC [cc] x _ flag)
+	// cond: ccARM64Eval(cc, flag) > 0
+	// result: x
+	for {
+		cc := auxIntToOp(v.AuxInt)
+		x := v_0
+		flag := v_2
+		if !(ccARM64Eval(cc, flag) > 0) {
+			break
+		}
+		v.copyOf(x)
+		return true
+	}
+	// match: (CSINC [cc] _ y flag)
+	// cond: ccARM64Eval(cc, flag) < 0
+	// result: (ADDconst [1] y)
+	for {
+		cc := auxIntToOp(v.AuxInt)
+		y := v_1
+		flag := v_2
+		if !(ccARM64Eval(cc, flag) < 0) {
+			break
+		}
+		v.reset(OpARM64ADDconst)
+		v.AuxInt = int64ToAuxInt(1)
+		v.AddArg(y)
+		return true
+	}
 	return false
 }
 func rewriteValueARM64_OpARM64CSINV(v *Value) bool {
@@ -3661,6 +3715,33 @@ func rewriteValueARM64_OpARM64CSINV(v *Value) bool {
 		v.AddArg3(x, y, cmp)
 		return true
 	}
+	// match: (CSINV [cc] x _ flag)
+	// cond: ccARM64Eval(cc, flag) > 0
+	// result: x
+	for {
+		cc := auxIntToOp(v.AuxInt)
+		x := v_0
+		flag := v_2
+		if !(ccARM64Eval(cc, flag) > 0) {
+			break
+		}
+		v.copyOf(x)
+		return true
+	}
+	// match: (CSINV [cc] _ y flag)
+	// cond: ccARM64Eval(cc, flag) < 0
+	// result: (Not y)
+	for {
+		cc := auxIntToOp(v.AuxInt)
+		y := v_1
+		flag := v_2
+		if !(ccARM64Eval(cc, flag) < 0) {
+			break
+		}
+		v.reset(OpNot)
+		v.AddArg(y)
+		return true
+	}
 	return false
 }
 func rewriteValueARM64_OpARM64CSNEG(v *Value) bool {
@@ -3682,6 +3763,33 @@ func rewriteValueARM64_OpARM64CSNEG(v *Value) bool {
 		v.AddArg3(x, y, cmp)
 		return true
 	}
+	// match: (CSNEG [cc] x _ flag)
+	// cond: ccARM64Eval(cc, flag) > 0
+	// result: x
+	for {
+		cc := auxIntToOp(v.AuxInt)
+		x := v_0
+		flag := v_2
+		if !(ccARM64Eval(cc, flag) > 0) {
+			break
+		}
+		v.copyOf(x)
+		return true
+	}
+	// match: (CSNEG [cc] _ y flag)
+	// cond: ccARM64Eval(cc, flag) < 0
+	// result: (NEG y)
+	for {
+		cc := auxIntToOp(v.AuxInt)
+		y := v_1
+		flag := v_2
+		if !(ccARM64Eval(cc, flag) < 0) {
+			break
+		}
+		v.reset(OpARM64NEG)
+		v.AddArg(y)
+		return true
+	}
 	return false
 }
 func rewriteValueARM64_OpARM64DIV(v *Value) bool {
diff --git a/test/fixedbugs/issue45359.go b/test/fixedbugs/issue45359.go
new file mode 100644
index 0000000000..5448556768
--- /dev/null
+++ b/test/fixedbugs/issue45359.go
@@ -0,0 +1,20 @@
+// compile
+
+// Copyright 2021 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
+
+func f() {
+	var i, j int
+	var b bool
+	i = -(i &^ i)
+	for 1>>uint(i) == 0 {
+		_ = func() {
+			i, b = 0, true
+		}
+		_ = b
+		i %= j
+	}
+}
-- 
GitLab


From 8462169b5a6c37e024ca5d49a823d4ce95e90e23 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Tue, 6 Apr 2021 18:39:15 -0400
Subject: [PATCH 1407/2400] cmd/compile: pre-spill pointers in aggregate-typed
 register args

There's a problem in liveness, where liveness of any
part of an aggregate keeps the whole aggregate alive,
but the not-live parts don't get spilled.  The GC
can observe those live-but-not-spilled slots, which
can contain junk.

A better fix is to change liveness to work
pointer-by-pointer, but that is also a riskier,
trickier fix.

To avoid this, in the case of

(1) an aggregate input parameter
(2) containing pointers
(3) passed in registers

pre-spill the pointers.

Updates #40724.

Change-Id: I6beb8e0a353b1ae3c68c16072f56698061922c04
Reviewed-on: https://go-review.googlesource.com/c/go/+/307909
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssagen/ssa.go | 14 +++++--
 test/abi/part_live.go                  | 48 +++++++++++++++++++++++
 test/abi/part_live_2.go                | 53 ++++++++++++++++++++++++++
 3 files changed, 111 insertions(+), 4 deletions(-)
 create mode 100644 test/abi/part_live.go
 create mode 100644 test/abi/part_live_2.go

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 48102e5398..97b970012d 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -558,6 +558,11 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 				v := s.newValue0A(ssa.OpArg, n.Type(), n)
 				s.vars[n] = v
 				s.addNamedValue(n, v) // This helps with debugging information, not needed for compilation itself.
+				// TODO(register args) Make liveness more fine-grained to that partial spilling is okay.
+				paramAssignment := ssa.ParamAssignmentForArgName(s.f, n)
+				if len(paramAssignment.Registers) > 1 && n.Type().HasPointers() { // 1 cannot be partially live
+					s.storeParameterRegsToStack(s.f.ABISelf, paramAssignment, n, s.decladdrs[n], true)
+				}
 			} else { // address was taken AND/OR too large for SSA
 				paramAssignment := ssa.ParamAssignmentForArgName(s.f, n)
 				if len(paramAssignment.Registers) > 0 {
@@ -567,9 +572,7 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 					} else { // Too big for SSA.
 						// Brute force, and early, do a bunch of stores from registers
 						// TODO fix the nasty storeArgOrLoad recursion in ssa/expand_calls.go so this Just Works with store of a big Arg.
-						abi := s.f.ABISelf
-						addr := s.decladdrs[n]
-						s.storeParameterRegsToStack(abi, paramAssignment, n, addr)
+						s.storeParameterRegsToStack(s.f.ABISelf, paramAssignment, n, s.decladdrs[n], false)
 					}
 				}
 			}
@@ -645,9 +648,12 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 	return s.f
 }
 
-func (s *state) storeParameterRegsToStack(abi *abi.ABIConfig, paramAssignment *abi.ABIParamAssignment, n *ir.Name, addr *ssa.Value) {
+func (s *state) storeParameterRegsToStack(abi *abi.ABIConfig, paramAssignment *abi.ABIParamAssignment, n *ir.Name, addr *ssa.Value, pointersOnly bool) {
 	typs, offs := paramAssignment.RegisterTypesAndOffsets()
 	for i, t := range typs {
+		if pointersOnly && !t.IsPtrShaped() {
+			continue
+		}
 		r := paramAssignment.Registers[i]
 		o := offs[i]
 		op, reg := ssa.ArgOpAndRegisterFor(r, abi)
diff --git a/test/abi/part_live.go b/test/abi/part_live.go
new file mode 100644
index 0000000000..592b6b3a07
--- /dev/null
+++ b/test/abi/part_live.go
@@ -0,0 +1,48 @@
+// run
+
+// Copyright 2021 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.
+
+// A test for partial liveness / partial spilling / compiler-induced GC failure
+
+package main
+
+import "runtime"
+import "unsafe"
+
+//go:registerparams
+func F(s []int) {
+	for i, x := range s {
+		G(i, x)
+	}
+	GC()
+	G(len(s), cap(s))
+	GC()
+}
+
+//go:noinline
+//go:registerparams
+func G(int, int) {}
+
+//go:registerparams
+func GC() { runtime.GC(); runtime.GC() }
+
+func main() {
+	s := make([]int, 3)
+	escape(s)
+	p := int(uintptr(unsafe.Pointer(&s[2])) + 42) // likely point to unallocated memory
+	poison([3]int{p, p, p})
+	F(s)
+}
+
+//go:noinline
+//go:registerparams
+func poison([3]int) {}
+
+//go:noinline
+//go:registerparams
+func escape(s []int) {
+	g = s
+}
+var g []int
diff --git a/test/abi/part_live_2.go b/test/abi/part_live_2.go
new file mode 100644
index 0000000000..f9d7b01bce
--- /dev/null
+++ b/test/abi/part_live_2.go
@@ -0,0 +1,53 @@
+// run
+
+// Copyright 2021 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.
+
+// A test for partial liveness / partial spilling / compiler-induced GC failure
+
+package main
+
+import "runtime"
+import "unsafe"
+
+//go:registerparams
+func F(s []int) {
+	for i, x := range s {
+		G(i, x)
+	}
+	GC()
+	H(&s[0]) // It's possible that this will make the spill redundant, but there's a bug in spill slot allocation.
+	G(len(s), cap(s))
+	GC()
+}
+
+//go:noinline
+//go:registerparams
+func G(int, int) {}
+
+//go:noinline
+//go:registerparams
+func H(*int) {}
+
+//go:registerparams
+func GC() { runtime.GC(); runtime.GC() }
+
+func main() {
+	s := make([]int, 3)
+	escape(s)
+	p := int(uintptr(unsafe.Pointer(&s[2])) + 42) // likely point to unallocated memory
+	poison([3]int{p, p, p})
+	F(s)
+}
+
+//go:noinline
+//go:registerparams
+func poison([3]int) {}
+
+//go:noinline
+//go:registerparams
+func escape(s []int) {
+	g = s
+}
+var g []int
-- 
GitLab


From bce85b701153f7671f0e362288ad5c8fdad15093 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 30 Mar 2021 17:16:53 -0700
Subject: [PATCH 1408/2400] cmd/compile/internal/types2: combine all type
 inference in a single function

Rather than splitting up type inference into function argument
and constraint type inference, provide a single Checker.infer
that accepts type parameters, type arguments, value parameters,
and value arguments, if any. Checker.infer returns the completed
list of type arguments, or nil.

Updated (and simplified) call sites.

Change-Id: I9200a44b9c4ab7f2d21eed824abfffaab68ff766
Reviewed-on: https://go-review.googlesource.com/c/go/+/306170
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/call.go  |  85 +++--------
 src/cmd/compile/internal/types2/infer.go | 184 +++++++++++++++++++----
 2 files changed, 174 insertions(+), 95 deletions(-)

diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index 20649bed99..3ffc8c1bef 100644
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -24,52 +24,36 @@ func (check *Checker) funcInst(x *operand, inst *syntax.IndexExpr) {
 	}
 	assert(len(targs) == len(xlist))
 
-	// check number of type arguments
-	n := len(targs)
+	// check number of type arguments (got) vs number of type parameters (want)
 	sig := x.typ.(*Signature)
-	if !check.conf.InferFromConstraints && n != len(sig.tparams) || n > len(sig.tparams) {
-		check.errorf(xlist[n-1], "got %d type arguments but want %d", n, len(sig.tparams))
+	got, want := len(targs), len(sig.tparams)
+	if !check.conf.InferFromConstraints && got != want || got > want {
+		check.errorf(xlist[got-1], "got %d type arguments but want %d", got, want)
 		x.mode = invalid
 		x.expr = inst
 		return
 	}
 
-	// determine argument positions (for error reporting)
-	poslist := make([]syntax.Pos, n)
-	for i, x := range xlist {
-		poslist[i] = syntax.StartPos(x)
-	}
-
-	// if we don't have enough type arguments, use constraint type inference
-	var inferred bool
-	if n < len(sig.tparams) {
-		var failed int
-		targs, failed = check.inferB(sig.tparams, targs)
+	// if we don't have enough type arguments, try type inference
+	inferred := false
+	if got < want {
+		targs = check.infer(inst.Pos(), sig.tparams, targs, nil, nil, true)
 		if targs == nil {
 			// error was already reported
 			x.mode = invalid
 			x.expr = inst
 			return
 		}
-		if failed >= 0 {
-			// at least one type argument couldn't be inferred
-			assert(targs[failed] == nil)
-			tpar := sig.tparams[failed]
-			check.errorf(inst, "cannot infer %s (%s) (%s)", tpar.name, tpar.pos, targs)
-			x.mode = invalid
-			x.expr = inst
-			return
-		}
-		// all type arguments were inferred successfully
-		if debug {
-			for _, targ := range targs {
-				assert(targ != nil)
-			}
-		}
-		n = len(targs)
+		got = len(targs)
 		inferred = true
 	}
-	assert(n == len(sig.tparams))
+	assert(got == want)
+
+	// determine argument positions (for error reporting)
+	poslist := make([]syntax.Pos, len(xlist))
+	for i, x := range xlist {
+		poslist[i] = syntax.StartPos(x)
+	}
 
 	// instantiate function signature
 	res := check.instantiate(x.Pos(), sig, targs, poslist).(*Signature)
@@ -301,35 +285,10 @@ func (check *Checker) arguments(call *syntax.CallExpr, sig *Signature, args []*o
 	if len(sig.tparams) > 0 {
 		// TODO(gri) provide position information for targs so we can feed
 		//           it to the instantiate call for better error reporting
-		targs, failed := check.infer(sig.tparams, sigParams, args)
+		targs := check.infer(call.Pos(), sig.tparams, nil, sigParams, args, true)
 		if targs == nil {
 			return // error already reported
 		}
-		if failed >= 0 {
-			// Some type arguments couldn't be inferred. Use
-			// bounds type inference to try to make progress.
-			if check.conf.InferFromConstraints {
-				targs, failed = check.inferB(sig.tparams, targs)
-				if targs == nil {
-					return // error already reported
-				}
-			}
-			if failed >= 0 {
-				// at least one type argument couldn't be inferred
-				assert(targs[failed] == nil)
-				tpar := sig.tparams[failed]
-				// TODO(gri) here we'd like to use the position of the call's ')'
-				check.errorf(call.Pos(), "cannot infer %s (%s) (%s)", tpar.name, tpar.pos, targs)
-				return
-			}
-		}
-		// all type arguments were inferred successfully
-		if debug {
-			for _, targ := range targs {
-				assert(targ != nil)
-			}
-		}
-		//check.dump("### inferred targs = %s", targs)
 
 		// compute result signature
 		rsig = check.instantiate(call.Pos(), sig, targs, nil).(*Signature)
@@ -548,14 +507,14 @@ func (check *Checker) selector(x *operand, e *syntax.SelectorExpr) {
 					recv = recv.(*Pointer).base
 				}
 			}
+			// Disable reporting of errors during inference below. If we're unable to infer
+			// the receiver type arguments here, the receiver must be be otherwise invalid
+			// and an error has been reported elsewhere.
 			arg := operand{mode: variable, expr: x.expr, typ: recv}
-			targs, failed := check.infer(sig.rparams, NewTuple(sig.recv), []*operand{&arg})
+			targs := check.infer(m.pos, sig.rparams, nil, NewTuple(sig.recv), []*operand{&arg}, false /* no error reporting */)
 			//check.dump("### inferred targs = %s", targs)
-			if failed >= 0 {
+			if targs == nil {
 				// We may reach here if there were other errors (see issue #40056).
-				// check.infer will report a follow-up error.
-				// TODO(gri) avoid the follow-up error as it is confusing
-				//           (there's no inference in the source code)
 				goto Error
 			}
 			// Don't modify m. Instead - for now - make a copy of m and use that instead.
diff --git a/src/cmd/compile/internal/types2/infer.go b/src/cmd/compile/internal/types2/infer.go
index 061b919239..d267787816 100644
--- a/src/cmd/compile/internal/types2/infer.go
+++ b/src/cmd/compile/internal/types2/infer.go
@@ -2,29 +2,113 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// This file implements type parameter inference given
-// a list of concrete arguments and a parameter list.
+// This file implements type parameter inference.
 
 package types2
 
-import "bytes"
+import (
+	"bytes"
+	"cmd/compile/internal/syntax"
+)
+
+// infer attempts to infer the complete set of type arguments for generic function instantiation/call
+// based on the given type parameters tparams, type arguments targs, function parameters params, and
+// function arguments args, if any. There must be at least one type parameter, no more type arguments
+// than type parameters, and params and args must match in number (incl. zero).
+// If successful, infer returns the complete list of type arguments, one for each type parameter.
+// Otherwise the result is nil and appropriate errors will be reported unless report is set to false.
+//
+// Inference proceeds in 3 steps:
+//
+//   1) Start with given type arguments.
+//   2) Infer type arguments from typed function arguments.
+//   3) Infer type arguments from untyped function arguments.
+//
+// Constraint type inference is used after each step to expand the set of type arguments.
+//
+func (check *Checker) infer(pos syntax.Pos, tparams []*TypeName, targs []Type, params *Tuple, args []*operand, report bool) (result []Type) {
+	if debug {
+		defer func() {
+			assert(result == nil || len(result) == len(tparams))
+			for _, targ := range result {
+				assert(targ != nil)
+			}
+			//check.dump("### inferred targs = %s", result)
+		}()
+	}
 
-// infer returns the list of actual type arguments for the given list of type parameters tparams
-// by inferring them from the actual arguments args for the parameters params. If type inference
-// is impossible because unification fails, an error is reported and the resulting types list is
-// nil, and index is 0. Otherwise, types is the list of inferred type arguments, and index is
-// the index of the first type argument in that list that couldn't be inferred (and thus is nil).
-// If all type arguments were inferred successfully, index is < 0.
-func (check *Checker) infer(tparams []*TypeName, params *Tuple, args []*operand) (types []Type, index int) {
+	// There must be at least one type parameter, and no more type arguments than type parameters.
+	n := len(tparams)
+	assert(n > 0 && len(targs) <= n)
+
+	// Function parameters and arguments must match in number.
 	assert(params.Len() == len(args))
 
+	// --- 0 ---
+	// If we already have all type arguments, we're done.
+	if len(targs) == n {
+		return targs
+	}
+	// len(targs) < n
+
+	// --- 1 ---
+	// Explicitly provided type arguments take precedence over any inferred types;
+	// and types inferred via constraint type inference take precedence over types
+	// inferred from function arguments.
+	// If we have type arguments, see how far we get with constraint type inference.
+	if len(targs) > 0 && check.conf.InferFromConstraints {
+		var index int
+		targs, index = check.inferB(tparams, targs, report)
+		if targs == nil || index < 0 {
+			return targs
+		}
+	}
+
+	// Continue with the type arguments we have now. Avoid matching generic
+	// parameters that already have type arguments against function arguments:
+	// It may fail because matching uses type identity while parameter passing
+	// uses assignment rules. Instantiate the parameter list with the type
+	// arguments we have, and continue with that parameter list.
+
+	// First, make sure we have a "full" list of type arguments, so of which
+	// may be nil (unknown).
+	if len(targs) < n {
+		targs2 := make([]Type, n)
+		copy(targs2, targs)
+		targs = targs2
+	}
+	// len(targs) == n
+
+	// Substitute type arguments for their respective type parameters in params,
+	// if any. Note that nil targs entries are ignored by check.subst.
+	// TODO(gri) Can we avoid this (we're setting known type argumemts below,
+	//           but that doesn't impact the isParameterized check for now).
+	if params.Len() > 0 {
+		smap := makeSubstMap(tparams, targs)
+		params = check.subst(nopos, params, smap).(*Tuple)
+	}
+
+	// --- 2 ---
+	// Unify parameter and argument types for generic parameters with typed arguments
+	// and collect the indices of generic parameters with untyped arguments.
+	// Terminology: generic parameter = function parameter with a type-parameterized type
 	u := newUnifier(check, false)
 	u.x.init(tparams)
 
+	// Set the type arguments which we know already.
+	for i, targ := range targs {
+		if targ != nil {
+			u.x.set(i, targ)
+		}
+	}
+
 	errorf := func(kind string, tpar, targ Type, arg *operand) {
+		if !report {
+			return
+		}
 		// provide a better error message if we can
-		targs, failed := u.x.types()
-		if failed == 0 {
+		targs, index := u.x.types()
+		if index == 0 {
 			// The first type parameter couldn't be inferred.
 			// If none of them could be inferred, don't try
 			// to provide the inferred type in the error msg.
@@ -49,16 +133,13 @@ func (check *Checker) infer(tparams []*TypeName, params *Tuple, args []*operand)
 		}
 	}
 
-	// Terminology: generic parameter = function parameter with a type-parameterized type
-
-	// 1st pass: Unify parameter and argument types for generic parameters with typed arguments
-	//           and collect the indices of generic parameters with untyped arguments.
+	// indices of the generic parameters with untyped arguments - save for later
 	var indices []int
 	for i, arg := range args {
 		par := params.At(i)
 		// If we permit bidirectional unification, this conditional code needs to be
 		// executed even if par.typ is not parameterized since the argument may be a
-		// generic function (for which we want to infer // its type arguments).
+		// generic function (for which we want to infer its type arguments).
 		if isParameterized(tparams, par.typ) {
 			if arg.mode == invalid {
 				// An error was reported earlier. Ignore this targ
@@ -72,7 +153,7 @@ func (check *Checker) infer(tparams []*TypeName, params *Tuple, args []*operand)
 				// the respective type parameters of targ.
 				if !u.unify(par.typ, targ) {
 					errorf("type", par.typ, targ, arg)
-					return nil, 0
+					return nil
 				}
 			} else {
 				indices = append(indices, i)
@@ -80,12 +161,27 @@ func (check *Checker) infer(tparams []*TypeName, params *Tuple, args []*operand)
 		}
 	}
 
-	// Some generic parameters with untyped arguments may have been given a type
-	// indirectly through another generic parameter with a typed argument; we can
-	// ignore those now. (This only means that we know the types for those generic
-	// parameters; it doesn't mean untyped arguments can be passed safely. We still
-	// need to verify that assignment of those arguments is valid when we check
-	// function parameter passing external to infer.)
+	// If we've got all type arguments, we're done.
+	var index int
+	targs, index = u.x.types()
+	if index < 0 {
+		return targs
+	}
+
+	// See how far we get with constraint type inference.
+	// Note that even if we don't have any type arguments, constraint type inference
+	// may produce results for constraints that explicitly specify a type.
+	if check.conf.InferFromConstraints {
+		targs, index = check.inferB(tparams, targs, report)
+		if targs == nil || index < 0 {
+			return targs
+		}
+	}
+
+	// --- 3 ---
+	// Use any untyped arguments to infer additional type arguments.
+	// Some generic parameters with untyped arguments may have been given
+	// a type by now, we can ignore them.
 	j := 0
 	for _, i := range indices {
 		par := params.At(i)
@@ -94,14 +190,15 @@ func (check *Checker) infer(tparams []*TypeName, params *Tuple, args []*operand)
 		// only parameter type it can possibly match against is a *TypeParam.
 		// Thus, only keep the indices of generic parameters that are not of
 		// composite types and which don't have a type inferred yet.
-		if tpar, _ := par.typ.(*TypeParam); tpar != nil && u.x.at(tpar.index) == nil {
+		if tpar, _ := par.typ.(*TypeParam); tpar != nil && targs[tpar.index] == nil {
 			indices[j] = i
 			j++
 		}
 	}
 	indices = indices[:j]
 
-	// 2nd pass: Unify parameter and default argument types for remaining generic parameters.
+	// Unify parameter and default argument types for remaining generic parameters.
+	// TODO(gri) Rather than iterating again, combine this code with the loop above.
 	for _, i := range indices {
 		par := params.At(i)
 		arg := args[i]
@@ -111,11 +208,31 @@ func (check *Checker) infer(tparams []*TypeName, params *Tuple, args []*operand)
 		// nil by making sure all default argument types are typed.
 		if isTyped(targ) && !u.unify(par.typ, targ) {
 			errorf("default type", par.typ, targ, arg)
-			return nil, 0
+			return nil
 		}
 	}
 
-	return u.x.types()
+	// If we've got all type arguments, we're done.
+	targs, index = u.x.types()
+	if index < 0 {
+		return targs
+	}
+
+	// Again, follow up with constraint type inference.
+	if check.conf.InferFromConstraints {
+		targs, index = check.inferB(tparams, targs, report)
+		if targs == nil || index < 0 {
+			return targs
+		}
+	}
+
+	// At least one type argument couldn't be inferred.
+	assert(targs != nil && index >= 0 && targs[index] == nil)
+	tpar := tparams[index]
+	if report {
+		check.errorf(pos, "cannot infer %s (%s) (%s)", tpar.name, tpar.pos, targs)
+	}
+	return nil
 }
 
 // typeNamesString produces a string containing all the
@@ -265,12 +382,13 @@ func (w *tpWalker) isParameterizedList(list []Type) bool {
 
 // inferB returns the list of actual type arguments inferred from the type parameters'
 // bounds and an initial set of type arguments. If type inference is impossible because
-// unification fails, an error is reported, the resulting types list is nil, and index is 0.
+// unification fails, an error is reported if report is set to true, the resulting types
+// list is nil, and index is 0.
 // Otherwise, types is the list of inferred type arguments, and index is the index of the
 // first type argument in that list that couldn't be inferred (and thus is nil). If all
-// type arguments where inferred successfully, index is < 0. The number of type arguments
+// type arguments were inferred successfully, index is < 0. The number of type arguments
 // provided may be less than the number of type parameters, but there must be at least one.
-func (check *Checker) inferB(tparams []*TypeName, targs []Type) (types []Type, index int) {
+func (check *Checker) inferB(tparams []*TypeName, targs []Type, report bool) (types []Type, index int) {
 	assert(len(tparams) >= len(targs) && len(targs) > 0)
 
 	// Setup bidirectional unification between those structural bounds
@@ -292,7 +410,9 @@ func (check *Checker) inferB(tparams []*TypeName, targs []Type) (types []Type, i
 		sbound := check.structuralType(typ.bound)
 		if sbound != nil {
 			if !u.unify(typ, sbound) {
-				check.errorf(tpar.pos, "%s does not match %s", tpar, sbound)
+				if report {
+					check.errorf(tpar, "%s does not match %s", tpar, sbound)
+				}
 				return nil, 0
 			}
 		}
-- 
GitLab


From 7d5c54eee4718ccc1790fa9ab92bf091e9d56ef7 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 1 Apr 2021 18:39:39 -0700
Subject: [PATCH 1409/2400] cmd/compile/internal/types2: remove
 Config.InferFromConstraints flag

Constraint type inference is part of the proposed language.
Use an internal flag to control the feayure for debugging.

Change-Id: I7a9eaee92b5ffc23c25d9e68a729acc0d705e879
Reviewed-on: https://go-review.googlesource.com/c/go/+/306770
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/noder/irgen.go       | 1 -
 src/cmd/compile/internal/types2/api.go        | 4 ----
 src/cmd/compile/internal/types2/api_test.go   | 1 -
 src/cmd/compile/internal/types2/call.go       | 2 +-
 src/cmd/compile/internal/types2/check_test.go | 1 -
 src/cmd/compile/internal/types2/infer.go      | 8 +++++---
 6 files changed, 6 insertions(+), 11 deletions(-)

diff --git a/src/cmd/compile/internal/noder/irgen.go b/src/cmd/compile/internal/noder/irgen.go
index 2de8c3fa60..3e0d3285ab 100644
--- a/src/cmd/compile/internal/noder/irgen.go
+++ b/src/cmd/compile/internal/noder/irgen.go
@@ -36,7 +36,6 @@ func check2(noders []*noder) {
 	// typechecking
 	conf := types2.Config{
 		GoVersion:             base.Flag.Lang,
-		InferFromConstraints:  true,
 		IgnoreLabels:          true, // parser already checked via syntax.CheckBranches mode
 		CompilerErrorMessages: true, // use error strings matching existing compiler errors
 		Error: func(err error) {
diff --git a/src/cmd/compile/internal/types2/api.go b/src/cmd/compile/internal/types2/api.go
index d356978d5e..63008711bf 100644
--- a/src/cmd/compile/internal/types2/api.go
+++ b/src/cmd/compile/internal/types2/api.go
@@ -110,10 +110,6 @@ type Config struct {
 	// If AcceptMethodTypeParams is set, methods may have type parameters.
 	AcceptMethodTypeParams bool
 
-	// If InferFromConstraints is set, constraint type inference is used
-	// if some function type arguments are missing.
-	InferFromConstraints bool
-
 	// If FakeImportC is set, `import "C"` (for packages requiring Cgo)
 	// declares an empty "C" package and errors are omitted for qualified
 	// identifiers referring to package C (which won't find an object).
diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go
index 42135df1f6..b5990e5d46 100644
--- a/src/cmd/compile/internal/types2/api_test.go
+++ b/src/cmd/compile/internal/types2/api_test.go
@@ -66,7 +66,6 @@ func mayTypecheck(t *testing.T, path, source string, info *Info) (string, error)
 	}
 	conf := Config{
 		AcceptMethodTypeParams: true,
-		InferFromConstraints:   true,
 		Error:                  func(err error) {},
 		Importer:               defaultImporter(),
 	}
diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index 3ffc8c1bef..5ad8ea9f87 100644
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -27,7 +27,7 @@ func (check *Checker) funcInst(x *operand, inst *syntax.IndexExpr) {
 	// check number of type arguments (got) vs number of type parameters (want)
 	sig := x.typ.(*Signature)
 	got, want := len(targs), len(sig.tparams)
-	if !check.conf.InferFromConstraints && got != want || got > want {
+	if !useConstraintTypeInference && got != want || got > want {
 		check.errorf(xlist[got-1], "got %d type arguments but want %d", got, want)
 		x.mode = invalid
 		x.expr = inst
diff --git a/src/cmd/compile/internal/types2/check_test.go b/src/cmd/compile/internal/types2/check_test.go
index ac21c3458e..a6baa71b2a 100644
--- a/src/cmd/compile/internal/types2/check_test.go
+++ b/src/cmd/compile/internal/types2/check_test.go
@@ -129,7 +129,6 @@ func checkFiles(t *testing.T, filenames []string, goVersion string, colDelta uin
 	var conf Config
 	conf.GoVersion = goVersion
 	conf.AcceptMethodTypeParams = true
-	conf.InferFromConstraints = true
 	// special case for importC.src
 	if len(filenames) == 1 && strings.HasSuffix(filenames[0], "importC.src") {
 		conf.FakeImportC = true
diff --git a/src/cmd/compile/internal/types2/infer.go b/src/cmd/compile/internal/types2/infer.go
index d267787816..995ebd7ea0 100644
--- a/src/cmd/compile/internal/types2/infer.go
+++ b/src/cmd/compile/internal/types2/infer.go
@@ -11,6 +11,8 @@ import (
 	"cmd/compile/internal/syntax"
 )
 
+const useConstraintTypeInference = true
+
 // infer attempts to infer the complete set of type arguments for generic function instantiation/call
 // based on the given type parameters tparams, type arguments targs, function parameters params, and
 // function arguments args, if any. There must be at least one type parameter, no more type arguments
@@ -56,7 +58,7 @@ func (check *Checker) infer(pos syntax.Pos, tparams []*TypeName, targs []Type, p
 	// and types inferred via constraint type inference take precedence over types
 	// inferred from function arguments.
 	// If we have type arguments, see how far we get with constraint type inference.
-	if len(targs) > 0 && check.conf.InferFromConstraints {
+	if len(targs) > 0 && useConstraintTypeInference {
 		var index int
 		targs, index = check.inferB(tparams, targs, report)
 		if targs == nil || index < 0 {
@@ -171,7 +173,7 @@ func (check *Checker) infer(pos syntax.Pos, tparams []*TypeName, targs []Type, p
 	// See how far we get with constraint type inference.
 	// Note that even if we don't have any type arguments, constraint type inference
 	// may produce results for constraints that explicitly specify a type.
-	if check.conf.InferFromConstraints {
+	if useConstraintTypeInference {
 		targs, index = check.inferB(tparams, targs, report)
 		if targs == nil || index < 0 {
 			return targs
@@ -219,7 +221,7 @@ func (check *Checker) infer(pos syntax.Pos, tparams []*TypeName, targs []Type, p
 	}
 
 	// Again, follow up with constraint type inference.
-	if check.conf.InferFromConstraints {
+	if useConstraintTypeInference {
 		targs, index = check.inferB(tparams, targs, report)
 		if targs == nil || index < 0 {
 			return targs
-- 
GitLab


From 1395432f2330498c8e5661c14652996894f0cc7d Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 5 Apr 2021 14:30:03 -0700
Subject: [PATCH 1410/2400] cmd/compile/internal/types2: remove
 Config.AcceptMethodTypeParams flag

Type parameters for methods are not part of the accepted language,
but maintaining the code for type-checking them ensures regularity
of the type checker implementation. For now, keep the flag internally,
disabled by default. The flag is set when running tests.

Change-Id: Ic99934bd00bd2608dc1178e4131f46dd1507f0f5
Reviewed-on: https://go-review.googlesource.com/c/go/+/307214
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/api.go        | 3 ---
 src/cmd/compile/internal/types2/api_test.go   | 5 ++---
 src/cmd/compile/internal/types2/check.go      | 5 -----
 src/cmd/compile/internal/types2/check_test.go | 1 -
 src/cmd/compile/internal/types2/resolver.go   | 2 +-
 src/cmd/compile/internal/types2/types_test.go | 9 +++++++++
 src/cmd/compile/internal/types2/typexpr.go    | 7 +++++--
 7 files changed, 17 insertions(+), 15 deletions(-)
 create mode 100644 src/cmd/compile/internal/types2/types_test.go

diff --git a/src/cmd/compile/internal/types2/api.go b/src/cmd/compile/internal/types2/api.go
index 63008711bf..2939dcc0bd 100644
--- a/src/cmd/compile/internal/types2/api.go
+++ b/src/cmd/compile/internal/types2/api.go
@@ -107,9 +107,6 @@ type Config struct {
 	// type-checked.
 	IgnoreFuncBodies bool
 
-	// If AcceptMethodTypeParams is set, methods may have type parameters.
-	AcceptMethodTypeParams bool
-
 	// If FakeImportC is set, `import "C"` (for packages requiring Cgo)
 	// declares an empty "C" package and errors are omitted for qualified
 	// identifiers referring to package C (which won't find an object).
diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go
index b5990e5d46..9d31fef69b 100644
--- a/src/cmd/compile/internal/types2/api_test.go
+++ b/src/cmd/compile/internal/types2/api_test.go
@@ -65,9 +65,8 @@ func mayTypecheck(t *testing.T, path, source string, info *Info) (string, error)
 		t.Fatalf("%s: unable to parse: %s", path, err)
 	}
 	conf := Config{
-		AcceptMethodTypeParams: true,
-		Error:                  func(err error) {},
-		Importer:               defaultImporter(),
+		Error:    func(err error) {},
+		Importer: defaultImporter(),
 	}
 	pkg, err := conf.Check(f.PkgName.Value, []*syntax.File{f}, info)
 	return pkg.Name(), err
diff --git a/src/cmd/compile/internal/types2/check.go b/src/cmd/compile/internal/types2/check.go
index 7d499eb13d..2edcefd4c8 100644
--- a/src/cmd/compile/internal/types2/check.go
+++ b/src/cmd/compile/internal/types2/check.go
@@ -31,11 +31,6 @@ const debug = false // leave on during development
 //
 const forceStrict = false
 
-// If methodTypeParamsOk is set, type parameters are
-// permitted in method declarations (in interfaces, too).
-// Generalization and experimental feature.
-const methodTypeParamsOk = true
-
 // exprInfo stores information about an untyped expression.
 type exprInfo struct {
 	isLhs bool // expression is lhs operand of a shift with delayed type-check
diff --git a/src/cmd/compile/internal/types2/check_test.go b/src/cmd/compile/internal/types2/check_test.go
index a6baa71b2a..2418c29a2f 100644
--- a/src/cmd/compile/internal/types2/check_test.go
+++ b/src/cmd/compile/internal/types2/check_test.go
@@ -128,7 +128,6 @@ func checkFiles(t *testing.T, filenames []string, goVersion string, colDelta uin
 	// typecheck and collect typechecker errors
 	var conf Config
 	conf.GoVersion = goVersion
-	conf.AcceptMethodTypeParams = true
 	// special case for importC.src
 	if len(filenames) == 1 && strings.HasSuffix(filenames[0], "importC.src") {
 		conf.FakeImportC = true
diff --git a/src/cmd/compile/internal/types2/resolver.go b/src/cmd/compile/internal/types2/resolver.go
index 35bb72ee55..86eeb72b21 100644
--- a/src/cmd/compile/internal/types2/resolver.go
+++ b/src/cmd/compile/internal/types2/resolver.go
@@ -426,7 +426,7 @@ func (check *Checker) collectObjects() {
 				} else {
 					// method
 					// d.Recv != nil
-					if !methodTypeParamsOk && len(d.TParamList) != 0 {
+					if !acceptMethodTypeParams && len(d.TParamList) != 0 {
 						//check.error(d.TParamList.Pos(), invalidAST + "method must have no type parameters")
 						check.error(d, invalidAST+"method must have no type parameters")
 					}
diff --git a/src/cmd/compile/internal/types2/types_test.go b/src/cmd/compile/internal/types2/types_test.go
new file mode 100644
index 0000000000..11dca0b53d
--- /dev/null
+++ b/src/cmd/compile/internal/types2/types_test.go
@@ -0,0 +1,9 @@
+// Copyright 2021 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 types2
+
+func init() {
+	acceptMethodTypeParams = true
+}
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index ce2fd7797b..e7d24949a4 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -15,6 +15,9 @@ import (
 	"strings"
 )
 
+// Disabled by default, but enabled when running tests (via types_test.go).
+var acceptMethodTypeParams bool
+
 // ident type-checks identifier e and initializes x with the value or type of e.
 // If an error occurred, x.mode is set to invalid.
 // For the meaning of def, see Checker.definedType, below.
@@ -336,7 +339,7 @@ func (check *Checker) funcType(sig *Signature, recvPar *syntax.Field, tparams []
 		// Always type-check method type parameters but complain if they are not enabled.
 		// (A separate check is needed when type-checking interface method signatures because
 		// they don't have a receiver specification.)
-		if recvPar != nil && !check.conf.AcceptMethodTypeParams {
+		if recvPar != nil && !acceptMethodTypeParams {
 			check.error(ftyp, "methods cannot have type parameters")
 		}
 	}
@@ -848,7 +851,7 @@ func (check *Checker) interfaceType(ityp *Interface, iface *syntax.InterfaceType
 			// Always type-check method type parameters but complain if they are not enabled.
 			// (This extra check is needed here because interface method signatures don't have
 			// a receiver specification.)
-			if sig.tparams != nil && !check.conf.AcceptMethodTypeParams {
+			if sig.tparams != nil && !acceptMethodTypeParams {
 				check.error(f.Type, "methods cannot have type parameters")
 			}
 
-- 
GitLab


From 8f1099b5850747cf61738606f6a3d1386f4458c6 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 5 Apr 2021 15:48:32 -0700
Subject: [PATCH 1411/2400] cmd/compile/internal/syntax, types2: move cmpPos to
 pos.Cmp

Make position comparison generally available.

Change-Id: I94b6f658fa19a15b30574dbb2181879115c131a8
Reviewed-on: https://go-review.googlesource.com/c/go/+/307215
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/syntax/pos.go     | 39 ++++++++++++++++++++++
 src/cmd/compile/internal/syntax/testing.go |  8 ++---
 src/cmd/compile/internal/types2/decl.go    | 35 +------------------
 src/cmd/compile/internal/types2/scope.go   |  4 +--
 src/cmd/compile/internal/types2/stmt.go    |  2 +-
 5 files changed, 47 insertions(+), 41 deletions(-)

diff --git a/src/cmd/compile/internal/syntax/pos.go b/src/cmd/compile/internal/syntax/pos.go
index 99734d42d8..baebcc995c 100644
--- a/src/cmd/compile/internal/syntax/pos.go
+++ b/src/cmd/compile/internal/syntax/pos.go
@@ -59,6 +59,45 @@ func (pos Pos) RelCol() uint {
 	return pos.Col()
 }
 
+// Cmp compares the positions p and q and returns a result r as follows:
+//
+//	r <  0: p is before q
+//	r == 0: p and q are the same position (but may not be identical)
+//	r >  0: p is after q
+//
+// If p and q are in different files, p is before q if the filename
+// of p sorts lexicographically before the filename of q.
+func (p Pos) Cmp(q Pos) int {
+	pname := p.RelFilename()
+	qname := q.RelFilename()
+	switch {
+	case pname < qname:
+		return -1
+	case pname > qname:
+		return +1
+	}
+
+	pline := p.Line()
+	qline := q.Line()
+	switch {
+	case pline < qline:
+		return -1
+	case pline > qline:
+		return +1
+	}
+
+	pcol := p.Col()
+	qcol := q.Col()
+	switch {
+	case pcol < qcol:
+		return -1
+	case pcol > qcol:
+		return +1
+	}
+
+	return 0
+}
+
 func (pos Pos) String() string {
 	rel := position_{pos.RelFilename(), pos.RelLine(), pos.RelCol()}
 	abs := position_{pos.Base().Pos().RelFilename(), pos.Line(), pos.Col()}
diff --git a/src/cmd/compile/internal/syntax/testing.go b/src/cmd/compile/internal/syntax/testing.go
index 3e02dc1c5d..6a97dc0c2a 100644
--- a/src/cmd/compile/internal/syntax/testing.go
+++ b/src/cmd/compile/internal/syntax/testing.go
@@ -33,10 +33,10 @@ var errRx = regexp.MustCompile(`^ *ERROR *"?([^"]*)"?`)
 // for each Error is the position of the token immediately preceding
 // the comment, the Error message is the message msg extracted from
 // the comment, with all errors that are on the same line collected
-// in a slice. If there is no preceding token (the `ERROR` comment
-// appears in the beginning of the file), then the recorded position
-// is unknown (line, col = 0, 0). If there are no ERROR comments, the
-// result is nil.
+// in a slice, in source order. If there is no preceding token (the
+// `ERROR` comment appears in the beginning of the file), then the
+// recorded position is unknown (line, col = 0, 0). If there are no
+// ERROR comments, the result is nil.
 func ErrorMap(src io.Reader) (errmap map[uint][]Error) {
 	// position of previous token
 	var base *PosBase
diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index fe79b00152..f8559a43bb 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -383,45 +383,12 @@ func (check *Checker) cycleError(cycle []Object) {
 	check.report(&err)
 }
 
-// TODO(gri) This functionality should probably be with the Pos implementation.
-func cmpPos(p, q syntax.Pos) int {
-	// TODO(gri) is RelFilename correct here?
-	pname := p.RelFilename()
-	qname := q.RelFilename()
-	switch {
-	case pname < qname:
-		return -1
-	case pname > qname:
-		return +1
-	}
-
-	pline := p.Line()
-	qline := q.Line()
-	switch {
-	case pline < qline:
-		return -1
-	case pline > qline:
-		return +1
-	}
-
-	pcol := p.Col()
-	qcol := q.Col()
-	switch {
-	case pcol < qcol:
-		return -1
-	case pcol > qcol:
-		return +1
-	}
-
-	return 0
-}
-
 // firstInSrc reports the index of the object with the "smallest"
 // source position in path. path must not be empty.
 func firstInSrc(path []Object) int {
 	fst, pos := 0, path[0].Pos()
 	for i, t := range path[1:] {
-		if cmpPos(t.Pos(), pos) < 0 {
+		if t.Pos().Cmp(pos) < 0 {
 			fst, pos = i+1, t.Pos()
 		}
 	}
diff --git a/src/cmd/compile/internal/types2/scope.go b/src/cmd/compile/internal/types2/scope.go
index fd0b6241f5..ade0a79b31 100644
--- a/src/cmd/compile/internal/types2/scope.go
+++ b/src/cmd/compile/internal/types2/scope.go
@@ -81,7 +81,7 @@ func (s *Scope) Lookup(name string) Object {
 // whose scope is the scope of the package that exported them.
 func (s *Scope) LookupParent(name string, pos syntax.Pos) (*Scope, Object) {
 	for ; s != nil; s = s.parent {
-		if obj := s.elems[name]; obj != nil && (!pos.IsKnown() || cmpPos(obj.scopePos(), pos) <= 0) {
+		if obj := s.elems[name]; obj != nil && (!pos.IsKnown() || obj.scopePos().Cmp(pos) <= 0) {
 			return s, obj
 		}
 	}
@@ -153,7 +153,7 @@ func (s *Scope) End() syntax.Pos { return s.end }
 // The result is guaranteed to be valid only if the type-checked
 // AST has complete position information.
 func (s *Scope) Contains(pos syntax.Pos) bool {
-	return cmpPos(s.pos, pos) <= 0 && cmpPos(pos, s.end) < 0
+	return s.pos.Cmp(pos) <= 0 && pos.Cmp(s.end) < 0
 }
 
 // Innermost returns the innermost (child) scope containing
diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go
index 8447fa5de2..9e3a45b6a8 100644
--- a/src/cmd/compile/internal/types2/stmt.go
+++ b/src/cmd/compile/internal/types2/stmt.go
@@ -66,7 +66,7 @@ func (check *Checker) usage(scope *Scope) {
 		}
 	}
 	sort.Slice(unused, func(i, j int) bool {
-		return cmpPos(unused[i].pos, unused[j].pos) < 0
+		return unused[i].pos.Cmp(unused[j].pos) < 0
 	})
 	for _, v := range unused {
 		check.softErrorf(v.pos, "%s declared but not used", v.name)
-- 
GitLab


From 836356bdaad92d525d65ce01e08305dfbeb7c1e6 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 5 Apr 2021 16:06:18 -0700
Subject: [PATCH 1412/2400] cmd/compile/internal/types2: process errors in src
 order during testing

Follow-up on https://golang.org/cl/305573.
As a consequence, re-enable test case that caused problems with that CL.

Change-Id: Ibffee3f016f4885a55b8e527a5680dd437322209
Reviewed-on: https://go-review.googlesource.com/c/go/+/307216
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/check_test.go      | 14 ++++++++++----
 .../internal/types2/fixedbugs/issue39634.go2       |  3 +--
 2 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/src/cmd/compile/internal/types2/check_test.go b/src/cmd/compile/internal/types2/check_test.go
index 2418c29a2f..331f0c7105 100644
--- a/src/cmd/compile/internal/types2/check_test.go
+++ b/src/cmd/compile/internal/types2/check_test.go
@@ -32,6 +32,7 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
+	"sort"
 	"strings"
 	"testing"
 
@@ -150,6 +151,13 @@ func checkFiles(t *testing.T, filenames []string, goVersion string, colDelta uin
 		return
 	}
 
+	// sort errlist in source order
+	sort.Slice(errlist, func(i, j int) bool {
+		pi := unpackError(errlist[i]).Pos
+		pj := unpackError(errlist[j]).Pos
+		return pi.Cmp(pj) < 0
+	})
+
 	// collect expected errors
 	errmap := make(map[string]map[uint][]syntax.Error)
 	for _, filename := range filenames {
@@ -165,7 +173,6 @@ func checkFiles(t *testing.T, filenames []string, goVersion string, colDelta uin
 	}
 
 	// match against found errors
-	// TODO(gri) sort err list to avoid mismatched when having multiple errors
 	for _, err := range errlist {
 		got := unpackError(err)
 
@@ -205,9 +212,8 @@ func checkFiles(t *testing.T, filenames []string, goVersion string, colDelta uin
 
 		// eliminate from list
 		if n := len(list) - 1; n > 0 {
-			// not the last entry - swap in last element and shorten list by 1
-			// TODO(gri) avoid changing the order of entries
-			list[index] = list[n]
+			// not the last entry - slide entries down (don't reorder)
+			copy(list[index:], list[index+1:])
 			filemap[line] = list[:n]
 		} else {
 			// last entry - remove list from filemap
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39634.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39634.go2
index c99903f399..36ad1ba08a 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue39634.go2
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39634.go2
@@ -41,8 +41,7 @@ type foo9[A any] interface { type foo9 /* ERROR interface contains type constrai
 func _() { var _ = new(foo9 /* ERROR interface contains type constraints */ [int]) }
 
 // crash 12
-// TODO(gri) temporarily disabled due to an error check issue
-// var u /* ERROR cycle */ , i [func /* ERROR used as value */ /* ERROR used as value */ (u, c /* ERROR undeclared */ /* ERROR undeclared */ ) {}(0, len)]c /* ERROR undeclared */ /* ERROR undeclared */
+var u /* ERROR cycle */ , i [func /* ERROR used as value */ /* ERROR used as value */ (u, c /* ERROR undeclared */ /* ERROR undeclared */ ) {}(0, len /* ERROR must be called */ /* ERROR must be called */ )]c /* ERROR undeclared */ /* ERROR undeclared */
 
 // crash 15
 func y15() { var a /* ERROR declared but not used */ interface{ p() } = G15[string]{} }
-- 
GitLab


From 4bbe046aad2ca27f25d3811b061fb8f7926b8695 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 5 Apr 2021 16:52:25 -0700
Subject: [PATCH 1413/2400] cmd/compile/internal/syntax: add "~" operator

Change-Id: I7991103d97b97260d9615b7f5baf7ec75ad87d1f
Reviewed-on: https://go-review.googlesource.com/c/go/+/307370
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 .../internal/syntax/operator_string.go        | 43 ++++++++++---------
 src/cmd/compile/internal/syntax/scanner.go    |  5 +++
 .../compile/internal/syntax/scanner_test.go   |  5 ++-
 src/cmd/compile/internal/syntax/tokens.go     |  7 +--
 test/fixedbugs/issue23587.go                  |  9 ++--
 5 files changed, 41 insertions(+), 28 deletions(-)

diff --git a/src/cmd/compile/internal/syntax/operator_string.go b/src/cmd/compile/internal/syntax/operator_string.go
index a7cd40fb13..f045d8c552 100644
--- a/src/cmd/compile/internal/syntax/operator_string.go
+++ b/src/cmd/compile/internal/syntax/operator_string.go
@@ -11,30 +11,31 @@ func _() {
 	_ = x[Def-1]
 	_ = x[Not-2]
 	_ = x[Recv-3]
-	_ = x[OrOr-4]
-	_ = x[AndAnd-5]
-	_ = x[Eql-6]
-	_ = x[Neq-7]
-	_ = x[Lss-8]
-	_ = x[Leq-9]
-	_ = x[Gtr-10]
-	_ = x[Geq-11]
-	_ = x[Add-12]
-	_ = x[Sub-13]
-	_ = x[Or-14]
-	_ = x[Xor-15]
-	_ = x[Mul-16]
-	_ = x[Div-17]
-	_ = x[Rem-18]
-	_ = x[And-19]
-	_ = x[AndNot-20]
-	_ = x[Shl-21]
-	_ = x[Shr-22]
+	_ = x[Tilde-4]
+	_ = x[OrOr-5]
+	_ = x[AndAnd-6]
+	_ = x[Eql-7]
+	_ = x[Neq-8]
+	_ = x[Lss-9]
+	_ = x[Leq-10]
+	_ = x[Gtr-11]
+	_ = x[Geq-12]
+	_ = x[Add-13]
+	_ = x[Sub-14]
+	_ = x[Or-15]
+	_ = x[Xor-16]
+	_ = x[Mul-17]
+	_ = x[Div-18]
+	_ = x[Rem-19]
+	_ = x[And-20]
+	_ = x[AndNot-21]
+	_ = x[Shl-22]
+	_ = x[Shr-23]
 }
 
-const _Operator_name = ":!<-||&&==!=<<=>>=+-|^*/%&&^<<>>"
+const _Operator_name = ":!<-~||&&==!=<<=>>=+-|^*/%&&^<<>>"
 
-var _Operator_index = [...]uint8{0, 1, 2, 4, 6, 8, 10, 12, 13, 15, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 28, 30, 32}
+var _Operator_index = [...]uint8{0, 1, 2, 4, 5, 7, 9, 11, 13, 14, 16, 17, 19, 20, 21, 22, 23, 24, 25, 26, 27, 29, 31, 33}
 
 func (i Operator) String() string {
 	i -= 1
diff --git a/src/cmd/compile/internal/syntax/scanner.go b/src/cmd/compile/internal/syntax/scanner.go
index 9fe4965984..218bc24e61 100644
--- a/src/cmd/compile/internal/syntax/scanner.go
+++ b/src/cmd/compile/internal/syntax/scanner.go
@@ -343,6 +343,11 @@ redo:
 		s.op, s.prec = Not, 0
 		s.tok = _Operator
 
+	case '~':
+		s.nextch()
+		s.op, s.prec = Tilde, 0
+		s.tok = _Operator
+
 	default:
 		s.errorf("invalid character %#U", s.ch)
 		s.nextch()
diff --git a/src/cmd/compile/internal/syntax/scanner_test.go b/src/cmd/compile/internal/syntax/scanner_test.go
index fbe7b71163..2deb3bbf84 100644
--- a/src/cmd/compile/internal/syntax/scanner_test.go
+++ b/src/cmd/compile/internal/syntax/scanner_test.go
@@ -232,6 +232,9 @@ var sampleTokens = [...]struct {
 	{_Literal, "`\r`", 0, 0},
 
 	// operators
+	{_Operator, "!", Not, 0},
+	{_Operator, "~", Tilde, 0},
+
 	{_Operator, "||", OrOr, precOrOr},
 
 	{_Operator, "&&", AndAnd, precAndAnd},
@@ -601,7 +604,7 @@ func TestScanErrors(t *testing.T) {
 		{"\U0001d7d8" /* 𝟘 */, "identifier cannot begin with digit U+1D7D8 '𝟘'", 0, 0},
 		{"foo\U0001d7d8_½" /* foo𝟘_½ */, "invalid character U+00BD '½' in identifier", 0, 8 /* byte offset */},
 
-		{"x + ~y", "invalid character U+007E '~'", 0, 4},
+		{"x + #y", "invalid character U+0023 '#'", 0, 4},
 		{"foo$bar = 0", "invalid character U+0024 '$'", 0, 3},
 		{"0123456789", "invalid digit '8' in octal literal", 0, 8},
 		{"0123456789. /* foobar", "comment not terminated", 0, 12},   // valid float constant
diff --git a/src/cmd/compile/internal/syntax/tokens.go b/src/cmd/compile/internal/syntax/tokens.go
index 2936b6576b..60eae36ec9 100644
--- a/src/cmd/compile/internal/syntax/tokens.go
+++ b/src/cmd/compile/internal/syntax/tokens.go
@@ -111,9 +111,10 @@ const (
 	_ Operator = iota
 
 	// Def is the : in :=
-	Def  // :
-	Not  // !
-	Recv // <-
+	Def   // :
+	Not   // !
+	Recv  // <-
+	Tilde // ~
 
 	// precOrOr
 	OrOr // ||
diff --git a/test/fixedbugs/issue23587.go b/test/fixedbugs/issue23587.go
index bd5df27755..2308992347 100644
--- a/test/fixedbugs/issue23587.go
+++ b/test/fixedbugs/issue23587.go
@@ -6,7 +6,10 @@
 
 package p
 
-func f(x int) {
-	_ = ~x    // ERROR "invalid character"
-	_ = x ~ x // ERROR "invalid character" "unexpected x at end of statement"
+func _(x int) {
+	_ = ~x    // ERROR "unexpected ~"
+}
+
+func _(x int) {
+	_ = x ~ x // ERROR "unexpected ~ at end of statement"
 }
-- 
GitLab


From 5d5f779db40528faa82e16c361691864dc80975b Mon Sep 17 00:00:00 2001
From: ianwoolf <btw515wolf2@gmail.com>
Date: Wed, 7 Apr 2021 13:42:22 +0800
Subject: [PATCH 1414/2400] net/http: replace os.MkdirTemp with T.TempDir

Updates: #45402
Change-Id: Ia61f422d058bf57fc3688abc25597d6cc1692c51
Reviewed-on: https://go-review.googlesource.com/c/go/+/307653
Run-TryBot: Dave Cheney <dave@cheney.net>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dave Cheney <dave@cheney.net>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/net/http/filetransport_test.go | 6 ++----
 src/net/http/fs_test.go            | 6 +-----
 2 files changed, 3 insertions(+), 9 deletions(-)

diff --git a/src/net/http/filetransport_test.go b/src/net/http/filetransport_test.go
index b58888dcb1..77fc8eeccf 100644
--- a/src/net/http/filetransport_test.go
+++ b/src/net/http/filetransport_test.go
@@ -23,12 +23,10 @@ func checker(t *testing.T) func(string, error) {
 func TestFileTransport(t *testing.T) {
 	check := checker(t)
 
-	dname, err := os.MkdirTemp("", "")
-	check("TempDir", err)
+	dname := t.TempDir()
 	fname := filepath.Join(dname, "foo.txt")
-	err = os.WriteFile(fname, []byte("Bar"), 0644)
+	err := os.WriteFile(fname, []byte("Bar"), 0644)
 	check("WriteFile", err)
-	defer os.Remove(dname)
 	defer os.Remove(fname)
 
 	tr := &Transport{}
diff --git a/src/net/http/fs_test.go b/src/net/http/fs_test.go
index 0ebb511b5c..1bf207e0f7 100644
--- a/src/net/http/fs_test.go
+++ b/src/net/http/fs_test.go
@@ -378,11 +378,7 @@ func mustRemoveAll(dir string) {
 
 func TestFileServerImplicitLeadingSlash(t *testing.T) {
 	defer afterTest(t)
-	tempDir, err := os.MkdirTemp("", "")
-	if err != nil {
-		t.Fatalf("TempDir: %v", err)
-	}
-	defer mustRemoveAll(tempDir)
+	tempDir := t.TempDir()
 	if err := os.WriteFile(filepath.Join(tempDir, "foo.txt"), []byte("Hello world"), 0644); err != nil {
 		t.Fatalf("WriteFile: %v", err)
 	}
-- 
GitLab


From d6aa162f30d63f21f5f4db75e302dbb90595bbe2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BE=90=E5=BF=97=E4=BC=9F?= <juwan.xu@qq.com>
Date: Tue, 6 Apr 2021 04:56:32 +0000
Subject: [PATCH 1415/2400] embed, testing/fstest: small optimization for
 ReadDir

Change-Id: If8dc6d917b55119b5662ce5b0b87328d220d684d
GitHub-Last-Rev: cc9a1d5a7e2599ee7f98c61d35b2450b9b6a92c3
GitHub-Pull-Request: golang/go#45388
Reviewed-on: https://go-review.googlesource.com/c/go/+/307250
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/embed/embed.go          | 6 +++---
 src/testing/fstest/mapfs.go | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/embed/embed.go b/src/embed/embed.go
index 7f2719d2a7..851cc216fc 100644
--- a/src/embed/embed.go
+++ b/src/embed/embed.go
@@ -386,15 +386,15 @@ func (d *openDir) Read([]byte) (int, error) {
 
 func (d *openDir) ReadDir(count int) ([]fs.DirEntry, error) {
 	n := len(d.files) - d.offset
-	if count > 0 && n > count {
-		n = count
-	}
 	if n == 0 {
 		if count <= 0 {
 			return nil, nil
 		}
 		return nil, io.EOF
 	}
+	if count > 0 && n > count {
+		n = count
+	}
 	list := make([]fs.DirEntry, n)
 	for i := range list {
 		list[i] = &d.files[d.offset+i]
diff --git a/src/testing/fstest/mapfs.go b/src/testing/fstest/mapfs.go
index a5d4a23fac..9fef2f4696 100644
--- a/src/testing/fstest/mapfs.go
+++ b/src/testing/fstest/mapfs.go
@@ -223,12 +223,12 @@ func (d *mapDir) Read(b []byte) (int, error) {
 
 func (d *mapDir) ReadDir(count int) ([]fs.DirEntry, error) {
 	n := len(d.entry) - d.offset
-	if count > 0 && n > count {
-		n = count
-	}
 	if n == 0 && count > 0 {
 		return nil, io.EOF
 	}
+	if count > 0 && n > count {
+		n = count
+	}
 	list := make([]fs.DirEntry, n)
 	for i := range list {
 		list[i] = &d.entry[d.offset+i]
-- 
GitLab


From b55d90052918024caf331b35b209e434e3b7d176 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Wed, 7 Apr 2021 00:06:06 -0400
Subject: [PATCH 1416/2400] cmd/compile: correct argument area size for
 typedmemmove/typedmemclr

When the write barrier pass emits typedmemmove/typedmemclr calls,
even the arguments are in registers, we still need to leave space
for the spill slots. Count that space. Otherwise when the callee
spills arguments it may clobber locals on the caller's frame.

Change-Id: I5326943427feaf66cab7658a5bef55b3baf5d345
Reviewed-on: https://go-review.googlesource.com/c/go/+/307824
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/ssa/writebarrier.go | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/writebarrier.go b/src/cmd/compile/internal/ssa/writebarrier.go
index f0eceb7abe..d6af3578d0 100644
--- a/src/cmd/compile/internal/ssa/writebarrier.go
+++ b/src/cmd/compile/internal/ssa/writebarrier.go
@@ -494,36 +494,36 @@ func wbcall(pos src.XPos, b *Block, fn, typ *obj.LSym, ptr, val, mem, sp, sb *Va
 	if typ != nil { // for typedmemmove
 		taddr := b.NewValue1A(pos, OpAddr, b.Func.Config.Types.Uintptr, typ, sb)
 		argTypes = append(argTypes, b.Func.Config.Types.Uintptr)
+		off = round(off, taddr.Type.Alignment())
 		if inRegs {
 			wbargs = append(wbargs, taddr)
 		} else {
-			off = round(off, taddr.Type.Alignment())
 			arg := b.NewValue1I(pos, OpOffPtr, taddr.Type.PtrTo(), off, sp)
 			mem = b.NewValue3A(pos, OpStore, types.TypeMem, ptr.Type, arg, taddr, mem)
-			off += taddr.Type.Size()
 		}
+		off += taddr.Type.Size()
 	}
 
 	argTypes = append(argTypes, ptr.Type)
+	off = round(off, ptr.Type.Alignment())
 	if inRegs {
 		wbargs = append(wbargs, ptr)
 	} else {
-		off = round(off, ptr.Type.Alignment())
 		arg := b.NewValue1I(pos, OpOffPtr, ptr.Type.PtrTo(), off, sp)
 		mem = b.NewValue3A(pos, OpStore, types.TypeMem, ptr.Type, arg, ptr, mem)
-		off += ptr.Type.Size()
 	}
+	off += ptr.Type.Size()
 
 	if val != nil {
 		argTypes = append(argTypes, val.Type)
+		off = round(off, val.Type.Alignment())
 		if inRegs {
 			wbargs = append(wbargs, val)
 		} else {
-			off = round(off, val.Type.Alignment())
 			arg := b.NewValue1I(pos, OpOffPtr, val.Type.PtrTo(), off, sp)
 			mem = b.NewValue3A(pos, OpStore, types.TypeMem, val.Type, arg, val, mem)
-			off += val.Type.Size()
 		}
+		off += val.Type.Size()
 	}
 	off = round(off, config.PtrSize)
 	wbargs = append(wbargs, mem)
-- 
GitLab


From 4520da486b6d236090b1d98ce4707c5bcd19cb70 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Wed, 7 Apr 2021 11:48:53 +0200
Subject: [PATCH 1417/2400] cmd/pack: use testing.T.TempDir in tests

Change-Id: I7371259cf5d64f04698ae1477c3de1255664178d
Reviewed-on: https://go-review.googlesource.com/c/go/+/307969
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Dave Cheney <dave@cheney.net>
Reviewed-by: Than McIntosh <thanm@google.com>
Trust: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/pack/pack_test.go | 36 +++++++++---------------------------
 1 file changed, 9 insertions(+), 27 deletions(-)

diff --git a/src/cmd/pack/pack_test.go b/src/cmd/pack/pack_test.go
index 118376f9df..7842b562dc 100644
--- a/src/cmd/pack/pack_test.go
+++ b/src/cmd/pack/pack_test.go
@@ -19,15 +19,6 @@ import (
 	"time"
 )
 
-// tmpDir creates a temporary directory and returns its name.
-func tmpDir(t *testing.T) string {
-	name, err := os.MkdirTemp("", "pack")
-	if err != nil {
-		t.Fatal(err)
-	}
-	return name
-}
-
 // testCreate creates an archive in the specified directory.
 func testCreate(t *testing.T, dir string) {
 	name := filepath.Join(dir, "pack.a")
@@ -57,15 +48,13 @@ func testCreate(t *testing.T, dir string) {
 // Test that we can create an archive, write to it, and get the same contents back.
 // Tests the rv and then the pv command on a new archive.
 func TestCreate(t *testing.T) {
-	dir := tmpDir(t)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 	testCreate(t, dir)
 }
 
 // Test that we can create an archive twice with the same name (Issue 8369).
 func TestCreateTwice(t *testing.T) {
-	dir := tmpDir(t)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 	testCreate(t, dir)
 	testCreate(t, dir)
 }
@@ -73,8 +62,7 @@ func TestCreateTwice(t *testing.T) {
 // Test that we can create an archive, put some files in it, and get back a correct listing.
 // Tests the tv command.
 func TestTableOfContents(t *testing.T) {
-	dir := tmpDir(t)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 	name := filepath.Join(dir, "pack.a")
 	ar := openArchive(name, os.O_RDWR|os.O_CREATE, nil)
 
@@ -131,8 +119,7 @@ func TestTableOfContents(t *testing.T) {
 // Test that we can create an archive, put some files in it, and get back a file.
 // Tests the x command.
 func TestExtract(t *testing.T) {
-	dir := tmpDir(t)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 	name := filepath.Join(dir, "pack.a")
 	ar := openArchive(name, os.O_RDWR|os.O_CREATE, nil)
 	// Add some entries by hand.
@@ -173,8 +160,7 @@ func TestExtract(t *testing.T) {
 func TestHello(t *testing.T) {
 	testenv.MustHaveGoBuild(t)
 
-	dir := tmpDir(t)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 	hello := filepath.Join(dir, "hello.go")
 	prog := `
 		package main
@@ -209,8 +195,7 @@ func TestLargeDefs(t *testing.T) {
 	}
 	testenv.MustHaveGoBuild(t)
 
-	dir := tmpDir(t)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 	large := filepath.Join(dir, "large.go")
 	f, err := os.Create(large)
 	if err != nil {
@@ -276,8 +261,7 @@ func TestLargeDefs(t *testing.T) {
 func TestIssue21703(t *testing.T) {
 	testenv.MustHaveGoBuild(t)
 
-	dir := tmpDir(t)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	const aSrc = `package a; const X = "\n!\n"`
 	err := os.WriteFile(filepath.Join(dir, "a.go"), []byte(aSrc), 0666)
@@ -307,8 +291,7 @@ func TestIssue21703(t *testing.T) {
 func TestCreateWithCompilerObj(t *testing.T) {
 	testenv.MustHaveGoBuild(t)
 
-	dir := tmpDir(t)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 	src := filepath.Join(dir, "p.go")
 	prog := "package p; var X = 42\n"
 	err := os.WriteFile(src, []byte(prog), 0666)
@@ -372,8 +355,7 @@ func TestCreateWithCompilerObj(t *testing.T) {
 func TestRWithNonexistentFile(t *testing.T) {
 	testenv.MustHaveGoBuild(t)
 
-	dir := tmpDir(t)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 	src := filepath.Join(dir, "p.go")
 	prog := "package p; var X = 42\n"
 	err := os.WriteFile(src, []byte(prog), 0666)
-- 
GitLab


From b3064b66d0699618cae07e97068f653410b71abc Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 6 Apr 2021 22:46:57 -0700
Subject: [PATCH 1418/2400] cmd/compile/internal/types2: combine two loops
 (cleanup of TODO)

Follow-up on https://golang.org/cl/306170.

Change-Id: I71b451382b6780101a0c94174ebe579e8a0684c2
Reviewed-on: https://go-review.googlesource.com/c/go/+/307949
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/infer.go | 32 ++++++++----------------
 1 file changed, 11 insertions(+), 21 deletions(-)

diff --git a/src/cmd/compile/internal/types2/infer.go b/src/cmd/compile/internal/types2/infer.go
index 995ebd7ea0..13a9ccda0c 100644
--- a/src/cmd/compile/internal/types2/infer.go
+++ b/src/cmd/compile/internal/types2/infer.go
@@ -184,33 +184,23 @@ func (check *Checker) infer(pos syntax.Pos, tparams []*TypeName, targs []Type, p
 	// Use any untyped arguments to infer additional type arguments.
 	// Some generic parameters with untyped arguments may have been given
 	// a type by now, we can ignore them.
-	j := 0
 	for _, i := range indices {
 		par := params.At(i)
 		// Since untyped types are all basic (i.e., non-composite) types, an
 		// untyped argument will never match a composite parameter type; the
 		// only parameter type it can possibly match against is a *TypeParam.
-		// Thus, only keep the indices of generic parameters that are not of
-		// composite types and which don't have a type inferred yet.
+		// Thus, only consider untyped arguments for generic parameters that
+		// are not of composite types and which don't have a type inferred yet.
 		if tpar, _ := par.typ.(*TypeParam); tpar != nil && targs[tpar.index] == nil {
-			indices[j] = i
-			j++
-		}
-	}
-	indices = indices[:j]
-
-	// Unify parameter and default argument types for remaining generic parameters.
-	// TODO(gri) Rather than iterating again, combine this code with the loop above.
-	for _, i := range indices {
-		par := params.At(i)
-		arg := args[i]
-		targ := Default(arg.typ)
-		// The default type for an untyped nil is untyped nil. We must not
-		// infer an untyped nil type as type parameter type. Ignore untyped
-		// nil by making sure all default argument types are typed.
-		if isTyped(targ) && !u.unify(par.typ, targ) {
-			errorf("default type", par.typ, targ, arg)
-			return nil
+			arg := args[i]
+			targ := Default(arg.typ)
+			// The default type for an untyped nil is untyped nil. We must not
+			// infer an untyped nil type as type parameter type. Ignore untyped
+			// nil by making sure all default argument types are typed.
+			if isTyped(targ) && !u.unify(par.typ, targ) {
+				errorf("default type", par.typ, targ, arg)
+				return nil
+			}
 		}
 	}
 
-- 
GitLab


From e306d0606379cc9330302f97f237ca3ef55fee98 Mon Sep 17 00:00:00 2001
From: Makdon <makdon@makdon.me>
Date: Wed, 7 Apr 2021 15:24:46 +0000
Subject: [PATCH 1419/2400] runtime/map: update comment for gc/reflect

update comment cause gc/reflect.go has been moved to reflectdata/reflect.go

In the commit (attach below), gc/reflect.go is moved to reflectdata/reflect.go
So the  comment referring gc/reflect.go should be updated to reflectdata/reflect.go

There maybe other places that refers gc/reflect.go that should be updated.
I would work around it soon.

commit:
https://github.com/golang/go/commit/de65151e507e7b3c8e46d74f223d7c562177bedc
https://github.com/golang/go/commit/e4895ab4c0eb44de6ddc5dc8d860a827b20d2781

Change-Id: Ieed5c48049ffe6889c08e164972fc7825653ac05
GitHub-Last-Rev: eec9c2328d0be40842c3994f26f26f03fa650a91
GitHub-Pull-Request: golang/go#45421
Reviewed-on: https://go-review.googlesource.com/c/go/+/307930
Reviewed-by: Keith Randall <khr@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/cmd/compile/internal/walk/range.go |  4 +++-
 src/runtime/map.go                     | 10 +++++-----
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/src/cmd/compile/internal/walk/range.go b/src/cmd/compile/internal/walk/range.go
index 5ab24b2188..80bd8750fa 100644
--- a/src/cmd/compile/internal/walk/range.go
+++ b/src/cmd/compile/internal/walk/range.go
@@ -168,7 +168,9 @@ func walkRange(nrange *ir.RangeStmt) ir.Node {
 
 		hit := nrange.Prealloc
 		th := hit.Type()
-		keysym := th.Field(0).Sym  // depends on layout of iterator struct.  See reflect.go:MapIterType
+		// depends on layout of iterator struct.
+		// See cmd/compile/internal/reflectdata/reflect.go:MapIterType
+		keysym := th.Field(0).Sym  
 		elemsym := th.Field(1).Sym // ditto
 
 		fn := typecheck.LookupRuntime("mapiterinit")
diff --git a/src/runtime/map.go b/src/runtime/map.go
index 0beff57a1a..40e19c9294 100644
--- a/src/runtime/map.go
+++ b/src/runtime/map.go
@@ -113,7 +113,7 @@ func isEmpty(x uint8) bool {
 
 // A header for a Go map.
 type hmap struct {
-	// Note: the format of the hmap is also encoded in cmd/compile/internal/gc/reflect.go.
+	// Note: the format of the hmap is also encoded in cmd/compile/internal/reflectdata/reflect.go.
 	// Make sure this stays in sync with the compiler's definition.
 	count     int // # live cells == size of map.  Must be first (used by len() builtin)
 	flags     uint8
@@ -159,11 +159,11 @@ type bmap struct {
 }
 
 // A hash iteration structure.
-// If you modify hiter, also change cmd/compile/internal/gc/reflect.go to indicate
+// If you modify hiter, also change cmd/compile/internal/reflectdata/reflect.go to indicate
 // the layout of this structure.
 type hiter struct {
-	key         unsafe.Pointer // Must be in first position.  Write nil to indicate iteration end (see cmd/compile/internal/gc/range.go).
-	elem        unsafe.Pointer // Must be in second position (see cmd/compile/internal/gc/range.go).
+	key         unsafe.Pointer // Must be in first position.  Write nil to indicate iteration end (see cmd/compile/internal/walk/range.go).
+	elem        unsafe.Pointer // Must be in second position (see cmd/compile/internal/walk/range.go).
 	t           *maptype
 	h           *hmap
 	buckets     unsafe.Pointer // bucket ptr at hash_iter initialization time
@@ -810,7 +810,7 @@ func mapiterinit(t *maptype, h *hmap, it *hiter) {
 	}
 
 	if unsafe.Sizeof(hiter{})/sys.PtrSize != 12 {
-		throw("hash_iter size incorrect") // see cmd/compile/internal/gc/reflect.go
+		throw("hash_iter size incorrect") // see cmd/compile/internal/reflectdata/reflect.go
 	}
 	it.t = t
 	it.h = h
-- 
GitLab


From fca51ba24a829233ca133455fd3f161ffc9d7c55 Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Tue, 9 Mar 2021 16:55:09 -0600
Subject: [PATCH 1420/2400] cmd/internal/obj: remove ppc64 msr support from
 MOV* insns

These are privileged instructions, and thus will never work with
usermode code. I don't think there is a case where this isn't
true.  The motivation is to simplify handling of MOV* opcodes.

Assembler support for recognizing the MSR as a register is
retained.

Change-Id: Ic33f021a20057b64e69df8ea125e23dd8937e38d
Reviewed-on: https://go-review.googlesource.com/c/go/+/307814
Run-TryBot: Paul Murphy <murp@ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Carlos Eduardo Seo <carlos.seo@linaro.org>
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
Trust: Carlos Eduardo Seo <carlos.seo@linaro.org>
---
 src/cmd/internal/obj/ppc64/a.out.go   |  1 -
 src/cmd/internal/obj/ppc64/anames9.go |  1 -
 src/cmd/internal/obj/ppc64/asm9.go    | 20 --------------------
 3 files changed, 22 deletions(-)

diff --git a/src/cmd/internal/obj/ppc64/a.out.go b/src/cmd/internal/obj/ppc64/a.out.go
index 2ae3a21e05..d1b662cad9 100644
--- a/src/cmd/internal/obj/ppc64/a.out.go
+++ b/src/cmd/internal/obj/ppc64/a.out.go
@@ -377,7 +377,6 @@ const (
 	C_SOREG // D/DS form memory operation
 	C_LOREG // 32 bit addis + D/DS-form memory operation
 	C_FPSCR
-	C_MSR
 	C_XER
 	C_LR
 	C_CTR
diff --git a/src/cmd/internal/obj/ppc64/anames9.go b/src/cmd/internal/obj/ppc64/anames9.go
index 8b9b708458..7ef00dc34e 100644
--- a/src/cmd/internal/obj/ppc64/anames9.go
+++ b/src/cmd/internal/obj/ppc64/anames9.go
@@ -29,7 +29,6 @@ var cnames9 = []string{
 	"SOREG",
 	"LOREG",
 	"FPSCR",
-	"MSR",
 	"XER",
 	"LR",
 	"CTR",
diff --git a/src/cmd/internal/obj/ppc64/asm9.go b/src/cmd/internal/obj/ppc64/asm9.go
index b83489a5a6..ea76543963 100644
--- a/src/cmd/internal/obj/ppc64/asm9.go
+++ b/src/cmd/internal/obj/ppc64/asm9.go
@@ -233,11 +233,9 @@ var optab = []Optab{
 	{as: AMOVD, a1: C_TLS_IE, a6: C_REG, type_: 80, size: 8},
 	{as: AMOVD, a1: C_TOCADDR, a6: C_REG, type_: 95, size: 8},
 	{as: AMOVD, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
-	{as: AMOVD, a1: C_MSR, a6: C_REG, type_: 54, size: 4}, /* mfmsr */
 	{as: AMOVD, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 	{as: AMOVD, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVD, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
-	{as: AMOVD, a1: C_REG, a6: C_MSR, type_: 54, size: 4}, /* mtmsrd */
 	{as: AMOVD, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
 	{as: AMOVD, a1: C_REG, a6: C_REG, type_: 1, size: 4},
 
@@ -274,7 +272,6 @@ var optab = []Optab{
 	{as: AMOVWZ, a1: C_REG, a6: C_CREG, type_: 69, size: 4},
 	{as: AMOVWZ, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVWZ, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
-	{as: AMOVWZ, a1: C_REG, a6: C_MSR, type_: 54, size: 4}, /* mtmsr */
 	{as: AMOVWZ, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
 	{as: AMOVWZ, a1: C_REG, a6: C_REG, type_: 13, size: 4},
 
@@ -807,9 +804,6 @@ func (c *ctxt9) aclass(a *obj.Addr) int {
 		if a.Reg == REG_FPSCR {
 			return C_FPSCR
 		}
-		if a.Reg == REG_MSR {
-			return C_MSR
-		}
 		return C_GOK
 
 	case obj.TYPE_MEM:
@@ -2166,15 +2160,12 @@ const (
 	OP_MCRXR    = 31<<26 | 512<<1 | 0<<10 | 0
 	OP_MFCR     = 31<<26 | 19<<1 | 0<<10 | 0
 	OP_MFFS     = 63<<26 | 583<<1 | 0<<10 | 0
-	OP_MFMSR    = 31<<26 | 83<<1 | 0<<10 | 0
 	OP_MFSPR    = 31<<26 | 339<<1 | 0<<10 | 0
 	OP_MFSR     = 31<<26 | 595<<1 | 0<<10 | 0
 	OP_MFSRIN   = 31<<26 | 659<<1 | 0<<10 | 0
 	OP_MTCRF    = 31<<26 | 144<<1 | 0<<10 | 0
 	OP_MTFSF    = 63<<26 | 711<<1 | 0<<10 | 0
 	OP_MTFSFI   = 63<<26 | 134<<1 | 0<<10 | 0
-	OP_MTMSR    = 31<<26 | 146<<1 | 0<<10 | 0
-	OP_MTMSRD   = 31<<26 | 178<<1 | 0<<10 | 0
 	OP_MTSPR    = 31<<26 | 467<<1 | 0<<10 | 0
 	OP_MTSR     = 31<<26 | 210<<1 | 0<<10 | 0
 	OP_MTSRIN   = 31<<26 | 242<<1 | 0<<10 | 0
@@ -3251,17 +3242,6 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 	case 53: /* mffsX ,fr1 */
 		o1 = AOP_RRR(OP_MFFS, uint32(p.To.Reg), 0, 0)
 
-	case 54: /* mov msr,r1; mov r1, msr*/
-		if oclass(&p.From) == C_REG {
-			if p.As == AMOVD {
-				o1 = AOP_RRR(OP_MTMSRD, uint32(p.From.Reg), 0, 0)
-			} else {
-				o1 = AOP_RRR(OP_MTMSR, uint32(p.From.Reg), 0, 0)
-			}
-		} else {
-			o1 = AOP_RRR(OP_MFMSR, uint32(p.To.Reg), 0, 0)
-		}
-
 	case 55: /* op Rb, Rd */
 		o1 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), 0, uint32(p.From.Reg))
 
-- 
GitLab


From f60aa7a18cedd8f09dabbef9840893442fd2bda4 Mon Sep 17 00:00:00 2001
From: ianwoolf <btw515wolf2@gmail.com>
Date: Wed, 7 Apr 2021 22:32:56 +0800
Subject: [PATCH 1421/2400] syscall: replace os.MkdirTemp with T.TempDir

Updates #45402

Change-Id: I573133d6b987e8ac23e3e2018652612af684c755
Reviewed-on: https://go-review.googlesource.com/c/go/+/307990
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/syscall/dirent_test.go          | 16 ++++------------
 src/syscall/getdirentries_test.go   |  6 +-----
 src/syscall/syscall_unix_test.go    | 12 ++----------
 src/syscall/syscall_windows_test.go |  6 +-----
 4 files changed, 8 insertions(+), 32 deletions(-)

diff --git a/src/syscall/dirent_test.go b/src/syscall/dirent_test.go
index 8ed3caa9d4..71b445ba9b 100644
--- a/src/syscall/dirent_test.go
+++ b/src/syscall/dirent_test.go
@@ -27,16 +27,12 @@ func TestDirent(t *testing.T) {
 		filenameMinSize = 11
 	)
 
-	d, err := os.MkdirTemp("", "dirent-test")
-	if err != nil {
-		t.Fatalf("tempdir: %v", err)
-	}
-	defer os.RemoveAll(d)
+	d := t.TempDir()
 	t.Logf("tmpdir: %s", d)
 
 	for i, c := range []byte("0123456789") {
 		name := string(bytes.Repeat([]byte{c}, filenameMinSize+i))
-		err = os.WriteFile(filepath.Join(d, name), nil, 0644)
+		err := os.WriteFile(filepath.Join(d, name), nil, 0644)
 		if err != nil {
 			t.Fatalf("writefile: %v", err)
 		}
@@ -93,18 +89,14 @@ func TestDirentRepeat(t *testing.T) {
 	}
 
 	// Make a directory containing N files
-	d, err := os.MkdirTemp("", "direntRepeat-test")
-	if err != nil {
-		t.Fatalf("tempdir: %v", err)
-	}
-	defer os.RemoveAll(d)
+	d := t.TempDir()
 
 	var files []string
 	for i := 0; i < N; i++ {
 		files = append(files, fmt.Sprintf("file%d", i))
 	}
 	for _, file := range files {
-		err = os.WriteFile(filepath.Join(d, file), []byte("contents"), 0644)
+		err := os.WriteFile(filepath.Join(d, file), []byte("contents"), 0644)
 		if err != nil {
 			t.Fatalf("writefile: %v", err)
 		}
diff --git a/src/syscall/getdirentries_test.go b/src/syscall/getdirentries_test.go
index 936c8a163a..814e656649 100644
--- a/src/syscall/getdirentries_test.go
+++ b/src/syscall/getdirentries_test.go
@@ -29,11 +29,7 @@ func testGetdirentries(t *testing.T, count int) {
 	if count > 100 && testing.Short() && os.Getenv("GO_BUILDER_NAME") == "" {
 		t.Skip("skipping in -short mode")
 	}
-	d, err := os.MkdirTemp("", "getdirentries-test")
-	if err != nil {
-		t.Fatalf("Tempdir: %v", err)
-	}
-	defer os.RemoveAll(d)
+	d := t.TempDir()
 	var names []string
 	for i := 0; i < count; i++ {
 		names = append(names, fmt.Sprintf("file%03d", i))
diff --git a/src/syscall/syscall_unix_test.go b/src/syscall/syscall_unix_test.go
index a05fff5136..ce56c21ff2 100644
--- a/src/syscall/syscall_unix_test.go
+++ b/src/syscall/syscall_unix_test.go
@@ -79,16 +79,12 @@ func TestFcntlFlock(t *testing.T) {
 	}
 	if os.Getenv("GO_WANT_HELPER_PROCESS") == "" {
 		// parent
-		tempDir, err := os.MkdirTemp("", "TestFcntlFlock")
-		if err != nil {
-			t.Fatalf("Failed to create temp dir: %v", err)
-		}
+		tempDir := t.TempDir()
 		name := filepath.Join(tempDir, "TestFcntlFlock")
 		fd, err := syscall.Open(name, syscall.O_CREAT|syscall.O_RDWR|syscall.O_CLOEXEC, 0)
 		if err != nil {
 			t.Fatalf("Open failed: %v", err)
 		}
-		defer os.RemoveAll(tempDir)
 		defer syscall.Close(fd)
 		if err := syscall.Ftruncate(fd, 1<<20); err != nil {
 			t.Fatalf("Ftruncate(1<<20) failed: %v", err)
@@ -157,11 +153,7 @@ func TestPassFD(t *testing.T) {
 
 	}
 
-	tempDir, err := os.MkdirTemp("", "TestPassFD")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tempDir)
+	tempDir := t.TempDir()
 
 	fds, err := syscall.Socketpair(syscall.AF_LOCAL, syscall.SOCK_STREAM, 0)
 	if err != nil {
diff --git a/src/syscall/syscall_windows_test.go b/src/syscall/syscall_windows_test.go
index a9ae54752b..b8ec6bee39 100644
--- a/src/syscall/syscall_windows_test.go
+++ b/src/syscall/syscall_windows_test.go
@@ -12,11 +12,7 @@ import (
 )
 
 func TestWin32finddata(t *testing.T) {
-	dir, err := os.MkdirTemp("", "go-build")
-	if err != nil {
-		t.Fatalf("failed to create temp directory: %v", err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	path := filepath.Join(dir, "long_name.and_extension")
 	f, err := os.Create(path)
-- 
GitLab


From aeaa4519b584747b57d780c31134be8f6bb36251 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Tue, 6 Apr 2021 08:28:17 -0400
Subject: [PATCH 1422/2400] runtime: drop haveexperiment, sys.GOEXPERIMENT

We have ways to statically access experiments now, so we don't need a
relatively clunky string-parsing dynamic way to do it.

Change-Id: I5d75480916eef4bde2c30d5fe30593180da77ff2
Reviewed-on: https://go-review.googlesource.com/c/go/+/307815
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/internal/objabi/util.go  |  1 -
 src/cmd/link/internal/ld/main.go |  2 --
 src/runtime/heapdump.go          |  2 +-
 src/runtime/internal/sys/arch.go |  2 --
 src/runtime/proc.go              | 21 ---------------------
 5 files changed, 1 insertion(+), 27 deletions(-)

diff --git a/src/cmd/internal/objabi/util.go b/src/cmd/internal/objabi/util.go
index ae03aac31a..ca3d3fc1a3 100644
--- a/src/cmd/internal/objabi/util.go
+++ b/src/cmd/internal/objabi/util.go
@@ -171,7 +171,6 @@ func init() {
 	}
 
 	// Set GOEXPERIMENT to the parsed and canonicalized set of experiments.
-	// This format must be parseable by runtime.haveexperiment.
 	GOEXPERIMENT = expList()
 }
 
diff --git a/src/cmd/link/internal/ld/main.go b/src/cmd/link/internal/ld/main.go
index 78df50ee2d..95c89f813b 100644
--- a/src/cmd/link/internal/ld/main.go
+++ b/src/cmd/link/internal/ld/main.go
@@ -118,8 +118,6 @@ func Main(arch *sys.Arch, theArch Arch) {
 	addstrdata1(ctxt, "runtime.defaultGOROOT="+final)
 	addstrdata1(ctxt, "cmd/internal/objabi.defaultGOROOT="+final)
 
-	addstrdata1(ctxt, "runtime/internal/sys.GOEXPERIMENT="+objabi.GOEXPERIMENT)
-
 	// TODO(matloob): define these above and then check flag values here
 	if ctxt.Arch.Family == sys.AMD64 && objabi.GOOS == "plan9" {
 		flag.BoolVar(&flag8, "8", false, "use 64-bit addresses in symbol table")
diff --git a/src/runtime/heapdump.go b/src/runtime/heapdump.go
index e0913162a4..934e55f495 100644
--- a/src/runtime/heapdump.go
+++ b/src/runtime/heapdump.go
@@ -532,7 +532,7 @@ func dumpparams() {
 	dumpint(uint64(arenaStart))
 	dumpint(uint64(arenaEnd))
 	dumpstr(sys.GOARCH)
-	dumpstr(sys.GOEXPERIMENT)
+	dumpstr(buildVersion)
 	dumpint(uint64(ncpu))
 }
 
diff --git a/src/runtime/internal/sys/arch.go b/src/runtime/internal/sys/arch.go
index f00c55913f..3c99a2f7da 100644
--- a/src/runtime/internal/sys/arch.go
+++ b/src/runtime/internal/sys/arch.go
@@ -52,5 +52,3 @@ const MinFrameSize = _MinFrameSize
 // StackAlign is the required alignment of the SP register.
 // The stack must be at least word aligned, but some architectures require more.
 const StackAlign = _StackAlign
-
-var GOEXPERIMENT string // set by cmd/link
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index a256b6e04a..583ed73d84 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -5,7 +5,6 @@
 package runtime
 
 import (
-	"internal/bytealg"
 	"internal/cpu"
 	"runtime/internal/atomic"
 	"runtime/internal/sys"
@@ -6039,26 +6038,6 @@ func setMaxThreads(in int) (out int) {
 	return
 }
 
-func haveexperiment(name string) bool {
-	// GOEXPERIMENT is a comma-separated list of enabled
-	// experiments. It's not the raw environment variable, but a
-	// pre-processed list from cmd/internal/objabi.
-	x := sys.GOEXPERIMENT
-	for x != "" {
-		xname := ""
-		i := bytealg.IndexByteString(x, ',')
-		if i < 0 {
-			xname, x = x, ""
-		} else {
-			xname, x = x[:i], x[i+1:]
-		}
-		if xname == name {
-			return true
-		}
-	}
-	return false
-}
-
 //go:nosplit
 func procPin() int {
 	_g_ := getg()
-- 
GitLab


From 0c4a08cb74abe026260a224a2b553c1f77a1172a Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Tue, 6 Apr 2021 10:17:28 -0400
Subject: [PATCH 1423/2400] cmd/asm,runtime: reduce spellings of GOEXPERIMENTs

Currently, the objabi.Experiment fields use Go-standard CamelCase, the
GOEXPERIMENT environment variable flags and build tags use all
lowercase, and the asm macros use upper-case with underscores.

This CL makes asm use the lowercase names for macros so there is one
less spelling, e.g., GOEXPERIMENT_regabiargs. This also makes them
consistent with the GOOS_* and GOARCH_* macros, which also use lower
case.

Change-Id: I305cd89af5e8cd1a89cc148746c034bcfd76db3c
Reviewed-on: https://go-review.googlesource.com/c/go/+/307816
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/asm/internal/lex/input.go | 10 +++++-----
 src/runtime/asm_amd64.s           | 10 +++++-----
 src/runtime/race_amd64.s          | 18 +++++++++---------
 src/runtime/sys_linux_amd64.s     |  8 ++++----
 4 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/src/cmd/asm/internal/lex/input.go b/src/cmd/asm/internal/lex/input.go
index d3ad328954..8aa6becf55 100644
--- a/src/cmd/asm/internal/lex/input.go
+++ b/src/cmd/asm/internal/lex/input.go
@@ -57,19 +57,19 @@ func predefine(defines flags.MultiFlag) map[string]*Macro {
 			}
 		}
 		if objabi.Experiment.RegabiWrappers {
-			set("GOEXPERIMENT_REGABI_WRAPPERS")
+			set("GOEXPERIMENT_regabiwrappers")
 		}
 		if objabi.Experiment.RegabiG {
-			set("GOEXPERIMENT_REGABI_G")
+			set("GOEXPERIMENT_regabig")
 		}
 		if objabi.Experiment.RegabiReflect {
-			set("GOEXPERIMENT_REGABI_REFLECT")
+			set("GOEXPERIMENT_regabireflect")
 		}
 		if objabi.Experiment.RegabiDefer {
-			set("GOEXPERIMENT_REGABI_DEFER")
+			set("GOEXPERIMENT_regabidefer")
 		}
 		if objabi.Experiment.RegabiArgs {
-			set("GOEXPERIMENT_REGABI_ARGS")
+			set("GOEXPERIMENT_regabiargs")
 		}
 	}
 
diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index c245fce7ef..c0bfcb7ade 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -285,7 +285,7 @@ TEXT gogo<>(SB), NOSPLIT, $0
 // Switch to m->g0's stack, call fn(g).
 // Fn must never return. It should gogo(&g->sched)
 // to keep running g.
-#ifdef GOEXPERIMENT_REGABI_ARGS
+#ifdef GOEXPERIMENT_regabiargs
 TEXT runtime·mcall<ABIInternal>(SB), NOSPLIT, $0-8
 	MOVQ	AX, DX	// DX = fn
 
@@ -471,7 +471,7 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0
 	MOVL	$0, DX
 	JMP	runtime·morestack(SB)
 
-#ifdef GOEXPERIMENT_REGABI_REFLECT
+#ifdef GOEXPERIMENT_regabireflect
 // spillArgs stores return values from registers to a *internal/abi.RegArgs in R12.
 TEXT ·spillArgs<ABIInternal>(SB),NOSPLIT,$0-0
 	MOVQ AX, 0(R12)
@@ -689,7 +689,7 @@ TEXT runtime·jmpdefer(SB), NOSPLIT, $0-16
 // or else unwinding from systemstack_switch is incorrect.
 // Smashes R9.
 TEXT gosave_systemstack_switch<>(SB),NOSPLIT,$0
-#ifndef GOEXPERIMENT_REGABI_G
+#ifndef GOEXPERIMENT_regabig
 	get_tls(R14)
 	MOVQ	g(R14), R14
 #endif
@@ -1499,7 +1499,7 @@ TEXT runtime·addmoduledata(SB),NOSPLIT,$0-0
 // signals. It is quite painful to set X15 in the signal context,
 // so we do it here.
 TEXT ·sigpanic0<ABIInternal>(SB),NOSPLIT,$0-0
-#ifdef GOEXPERIMENT_REGABI_G
+#ifdef GOEXPERIMENT_regabig
 	get_tls(R14)
 	MOVQ	g(R14), R14
 	XORPS	X15, X15
@@ -1521,7 +1521,7 @@ TEXT runtime·gcWriteBarrier<ABIInternal>(SB),NOSPLIT,$112
 	MOVQ	R13, 104(SP)
 	// TODO: Consider passing g.m.p in as an argument so they can be shared
 	// across a sequence of write barriers.
-#ifdef GOEXPERIMENT_REGABI_G
+#ifdef GOEXPERIMENT_regabig
 	MOVQ	g_m(R14), R13
 #else
 	get_tls(R13)
diff --git a/src/runtime/race_amd64.s b/src/runtime/race_amd64.s
index 426777b8bf..bb3afeb6ee 100644
--- a/src/runtime/race_amd64.s
+++ b/src/runtime/race_amd64.s
@@ -44,7 +44,7 @@
 // Defined as ABIInternal so as to avoid introducing a wrapper,
 // which would render runtime.getcallerpc ineffective.
 TEXT	runtime·raceread<ABIInternal>(SB), NOSPLIT, $0-8
-#ifdef GOEXPERIMENT_REGABI_ARGS
+#ifdef GOEXPERIMENT_regabiargs
 	MOVQ	AX, RARG1
 #else
 	MOVQ	addr+0(FP), RARG1
@@ -74,7 +74,7 @@ TEXT	runtime·racereadpc(SB), NOSPLIT, $0-24
 // Defined as ABIInternal so as to avoid introducing a wrapper,
 // which would render runtime.getcallerpc ineffective.
 TEXT	runtime·racewrite<ABIInternal>(SB), NOSPLIT, $0-8
-#ifdef GOEXPERIMENT_REGABI_ARGS
+#ifdef GOEXPERIMENT_regabiargs
 	MOVQ	AX, RARG1
 #else
 	MOVQ	addr+0(FP), RARG1
@@ -129,7 +129,7 @@ TEXT	runtime·racereadrangepc1(SB), NOSPLIT, $0-24
 // Defined as ABIInternal so as to avoid introducing a wrapper,
 // which would render runtime.getcallerpc ineffective.
 TEXT	runtime·racewriterange<ABIInternal>(SB), NOSPLIT, $0-16
-#ifdef GOEXPERIMENT_REGABI_ARGS
+#ifdef GOEXPERIMENT_regabiargs
 	MOVQ	AX, RARG1
 	MOVQ	BX, RARG2
 #else
@@ -159,7 +159,7 @@ TEXT	runtime·racewriterangepc1(SB), NOSPLIT, $0-24
 // If addr (RARG1) is out of range, do nothing.
 // Otherwise, setup goroutine context and invoke racecall. Other arguments already set.
 TEXT	racecalladdr<>(SB), NOSPLIT, $0-0
-#ifndef GOEXPERIMENT_REGABI_G
+#ifndef GOEXPERIMENT_regabig
 	get_tls(R12)
 	MOVQ	g(R12), R14
 #endif
@@ -190,7 +190,7 @@ TEXT	runtime·racefuncenter(SB), NOSPLIT, $0-8
 // R11 = caller's return address
 TEXT	racefuncenter<>(SB), NOSPLIT, $0-0
 	MOVQ	DX, BX		// save function entry context (for closures)
-#ifndef GOEXPERIMENT_REGABI_G
+#ifndef GOEXPERIMENT_regabig
 	get_tls(R12)
 	MOVQ	g(R12), R14
 #endif
@@ -206,7 +206,7 @@ TEXT	racefuncenter<>(SB), NOSPLIT, $0-0
 // func runtime·racefuncexit()
 // Called from instrumented code.
 TEXT	runtime·racefuncexit(SB), NOSPLIT, $0-0
-#ifndef GOEXPERIMENT_REGABI_G
+#ifndef GOEXPERIMENT_regabig
 	get_tls(R12)
 	MOVQ	g(R12), R14
 #endif
@@ -368,7 +368,7 @@ racecallatomic_data:
 	JAE	racecallatomic_ignore
 racecallatomic_ok:
 	// Addr is within the good range, call the atomic function.
-#ifndef GOEXPERIMENT_REGABI_G
+#ifndef GOEXPERIMENT_regabig
 	get_tls(R12)
 	MOVQ	g(R12), R14
 #endif
@@ -383,7 +383,7 @@ racecallatomic_ignore:
 	// An attempt to synchronize on the address would cause crash.
 	MOVQ	AX, BX	// remember the original function
 	MOVQ	$__tsan_go_ignore_sync_begin(SB), AX
-#ifndef GOEXPERIMENT_REGABI_G
+#ifndef GOEXPERIMENT_regabig
 	get_tls(R12)
 	MOVQ	g(R12), R14
 #endif
@@ -414,7 +414,7 @@ TEXT	runtime·racecall(SB), NOSPLIT, $0-0
 
 // Switches SP to g0 stack and calls (AX). Arguments already set.
 TEXT	racecall<>(SB), NOSPLIT, $0-0
-#ifndef GOEXPERIMENT_REGABI_G
+#ifndef GOEXPERIMENT_regabig
 	get_tls(R12)
 	MOVQ	g(R12), R14
 #endif
diff --git a/src/runtime/sys_linux_amd64.s b/src/runtime/sys_linux_amd64.s
index 7b538c3e2f..215277a9cf 100644
--- a/src/runtime/sys_linux_amd64.s
+++ b/src/runtime/sys_linux_amd64.s
@@ -215,7 +215,7 @@ TEXT runtime·walltime1(SB),NOSPLIT,$16-12
 
 	MOVQ	SP, R12	// Save old SP; R12 unchanged by C code.
 
-#ifdef GOEXPERIMENT_REGABI_G
+#ifdef GOEXPERIMENT_regabig
 	MOVQ	g_m(R14), BX // BX unchanged by C code.
 #else
 	get_tls(CX)
@@ -236,7 +236,7 @@ TEXT runtime·walltime1(SB),NOSPLIT,$16-12
 	MOVQ	CX, m_vdsoPC(BX)
 	MOVQ	DX, m_vdsoSP(BX)
 
-#ifdef GOEXPERIMENT_REGABI_G
+#ifdef GOEXPERIMENT_regabig
 	CMPQ	R14, m_curg(BX)	// Only switch if on curg.
 #else
 	CMPQ	AX, m_curg(BX)	// Only switch if on curg.
@@ -283,7 +283,7 @@ TEXT runtime·nanotime1(SB),NOSPLIT,$16-8
 
 	MOVQ	SP, R12	// Save old SP; R12 unchanged by C code.
 
-#ifdef GOEXPERIMENT_REGABI_G
+#ifdef GOEXPERIMENT_regabig
 	MOVQ	g_m(R14), BX // BX unchanged by C code.
 #else
 	get_tls(CX)
@@ -304,7 +304,7 @@ TEXT runtime·nanotime1(SB),NOSPLIT,$16-8
 	MOVQ	CX, m_vdsoPC(BX)
 	MOVQ	DX, m_vdsoSP(BX)
 
-#ifdef GOEXPERIMENT_REGABI_G
+#ifdef GOEXPERIMENT_regabig
 	CMPQ	R14, m_curg(BX)	// Only switch if on curg.
 #else
 	CMPQ	AX, m_curg(BX)	// Only switch if on curg.
-- 
GitLab


From 6304b401e4bcfc1d61dd687bb5b7df13fd71033b Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Tue, 6 Apr 2021 08:25:01 -0400
Subject: [PATCH 1424/2400] internal/goexperiment,cmd: consolidate
 GOEXPERIMENTs into a new package

Currently there's knowledge about the list of GOEXPERIMENTs in a few
different places. This CL introduces a new package and consolidates
the list into one place: the internal/goexperiment.Flags struct type.

This package gives us a central place to document the experiments as
well as the GOEXPERIMENT environment variable itself. It will also
give us a place to put built-time constants derived from the enabled
experiments.

Now the objabi package constructs experiment names by reflecting over
this struct type rather than having a separate list of these names
(this is similar to how the compiler handles command-line flags and
debug options). We also expose a better-typed API to the toolchain for
propagating enabled experiments.

Change-Id: I06e026712b59fe2bd7cd11a869aedb48ffe5a4b7
Reviewed-on: https://go-review.googlesource.com/c/go/+/307817
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/asm/internal/lex/input.go  |  23 +---
 src/cmd/dist/buildtool.go          |   1 +
 src/cmd/go/internal/work/exec.go   |   8 +-
 src/cmd/go/internal/work/init.go   |   3 +-
 src/cmd/internal/objabi/exp.go     | 132 +++++++++++++++++++++
 src/cmd/internal/objabi/util.go    | 179 -----------------------------
 src/internal/goexperiment/flags.go |  72 ++++++++++++
 7 files changed, 215 insertions(+), 203 deletions(-)
 create mode 100644 src/cmd/internal/objabi/exp.go
 create mode 100644 src/internal/goexperiment/flags.go

diff --git a/src/cmd/asm/internal/lex/input.go b/src/cmd/asm/internal/lex/input.go
index 8aa6becf55..aa03759c7d 100644
--- a/src/cmd/asm/internal/lex/input.go
+++ b/src/cmd/asm/internal/lex/input.go
@@ -46,31 +46,18 @@ func NewInput(name string) *Input {
 func predefine(defines flags.MultiFlag) map[string]*Macro {
 	macros := make(map[string]*Macro)
 
-	// Set macros for various GOEXPERIMENTs so we can easily
-	// switch runtime assembly code based on them.
+	// Set macros for GOEXPERIMENTs so we can easily switch
+	// runtime assembly code based on them.
 	if *flags.CompilingRuntime {
-		set := func(name string) {
+		for _, exp := range objabi.EnabledExperiments() {
+			// Define macro.
+			name := "GOEXPERIMENT_" + exp
 			macros[name] = &Macro{
 				name:   name,
 				args:   nil,
 				tokens: Tokenize("1"),
 			}
 		}
-		if objabi.Experiment.RegabiWrappers {
-			set("GOEXPERIMENT_regabiwrappers")
-		}
-		if objabi.Experiment.RegabiG {
-			set("GOEXPERIMENT_regabig")
-		}
-		if objabi.Experiment.RegabiReflect {
-			set("GOEXPERIMENT_regabireflect")
-		}
-		if objabi.Experiment.RegabiDefer {
-			set("GOEXPERIMENT_regabidefer")
-		}
-		if objabi.Experiment.RegabiArgs {
-			set("GOEXPERIMENT_regabiargs")
-		}
 	}
 
 	for _, name := range defines {
diff --git a/src/cmd/dist/buildtool.go b/src/cmd/dist/buildtool.go
index 7520b0ef18..44b1886968 100644
--- a/src/cmd/dist/buildtool.go
+++ b/src/cmd/dist/buildtool.go
@@ -58,6 +58,7 @@ var bootstrapDirs = []string{
 	"debug/macho",
 	"debug/pe",
 	"go/constant",
+	"internal/goexperiment",
 	"internal/goversion",
 	"internal/race",
 	"internal/unsafeheader",
diff --git a/src/cmd/go/internal/work/exec.go b/src/cmd/go/internal/work/exec.go
index 11b7360d26..f692f386f5 100644
--- a/src/cmd/go/internal/work/exec.go
+++ b/src/cmd/go/internal/work/exec.go
@@ -277,8 +277,8 @@ func (b *Builder) buildActionID(a *Action) cache.ActionID {
 		key, val := cfg.GetArchEnv()
 		fmt.Fprintf(h, "%s=%s\n", key, val)
 
-		if objabi.GOEXPERIMENT != "" {
-			fmt.Fprintf(h, "GOEXPERIMENT=%q\n", objabi.GOEXPERIMENT)
+		if goexperiment := objabi.GOEXPERIMENT(); goexperiment != "" {
+			fmt.Fprintf(h, "GOEXPERIMENT=%q\n", goexperiment)
 		}
 
 		// TODO(rsc): Convince compiler team not to add more magic environment variables,
@@ -1251,8 +1251,8 @@ func (b *Builder) printLinkerConfig(h io.Writer, p *load.Package) {
 		key, val := cfg.GetArchEnv()
 		fmt.Fprintf(h, "%s=%s\n", key, val)
 
-		if objabi.GOEXPERIMENT != "" {
-			fmt.Fprintf(h, "GOEXPERIMENT=%q\n", objabi.GOEXPERIMENT)
+		if goexperiment := objabi.GOEXPERIMENT(); goexperiment != "" {
+			fmt.Fprintf(h, "GOEXPERIMENT=%q\n", goexperiment)
 		}
 
 		// The linker writes source file paths that say GOROOT_FINAL, but
diff --git a/src/cmd/go/internal/work/init.go b/src/cmd/go/internal/work/init.go
index 30c9a2b7cc..1e1494998a 100644
--- a/src/cmd/go/internal/work/init.go
+++ b/src/cmd/go/internal/work/init.go
@@ -18,7 +18,6 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
-	"strings"
 )
 
 func BuildInit() {
@@ -53,7 +52,7 @@ func BuildInit() {
 	// used for compiling alternative files for the experiment. This allows
 	// changes for the experiment, like extra struct fields in the runtime,
 	// without affecting the base non-experiment code at all.
-	for _, expt := range strings.Split(objabi.GOEXPERIMENT, ",") {
+	for _, expt := range objabi.EnabledExperiments() {
 		cfg.BuildContext.BuildTags = append(cfg.BuildContext.BuildTags, "goexperiment."+expt)
 	}
 }
diff --git a/src/cmd/internal/objabi/exp.go b/src/cmd/internal/objabi/exp.go
new file mode 100644
index 0000000000..21a70d5dfe
--- /dev/null
+++ b/src/cmd/internal/objabi/exp.go
@@ -0,0 +1,132 @@
+// Copyright 2021 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 objabi
+
+import (
+	"fmt"
+	"os"
+	"reflect"
+	"strings"
+
+	"internal/goexperiment"
+)
+
+// Experiment contains the toolchain experiments enabled for the
+// current build.
+//
+// (This is not necessarily the set of experiments the compiler itself
+// was built with.)
+var Experiment goexperiment.Flags
+
+var defaultExpstring string // Set by package init
+
+// FramePointerEnabled enables the use of platform conventions for
+// saving frame pointers.
+//
+// This used to be an experiment, but now it's always enabled on
+// platforms that support it.
+//
+// Note: must agree with runtime.framepointer_enabled.
+var FramePointerEnabled = GOARCH == "amd64" || GOARCH == "arm64"
+
+func init() {
+	// Capture "default" experiments.
+	defaultExpstring = Expstring()
+
+	goexperiment := envOr("GOEXPERIMENT", defaultGOEXPERIMENT)
+
+	// GOEXPERIMENT=none overrides all experiments enabled at dist time.
+	if goexperiment != "none" {
+		// Create a map of known experiment names.
+		names := make(map[string]reflect.Value)
+		rv := reflect.ValueOf(&Experiment).Elem()
+		rt := rv.Type()
+		for i := 0; i < rt.NumField(); i++ {
+			field := rv.Field(i)
+			names[strings.ToLower(rt.Field(i).Name)] = field
+		}
+
+		// Parse names.
+		for _, f := range strings.Split(goexperiment, ",") {
+			if f == "" {
+				continue
+			}
+			val := true
+			if strings.HasPrefix(f, "no") {
+				f, val = f[2:], false
+			}
+			field, ok := names[f]
+			if !ok {
+				fmt.Printf("unknown experiment %s\n", f)
+				os.Exit(2)
+			}
+			field.SetBool(val)
+		}
+	}
+
+	// regabi is only supported on amd64.
+	if GOARCH != "amd64" {
+		Experiment.Regabi = false
+		Experiment.RegabiWrappers = false
+		Experiment.RegabiG = false
+		Experiment.RegabiReflect = false
+		Experiment.RegabiDefer = false
+		Experiment.RegabiArgs = false
+	}
+	// Setting regabi sets working sub-experiments.
+	if Experiment.Regabi {
+		Experiment.RegabiWrappers = true
+		Experiment.RegabiG = true
+		Experiment.RegabiReflect = true
+		Experiment.RegabiDefer = true
+		// Not ready yet:
+		//Experiment.RegabiArgs = true
+	}
+	// Check regabi dependencies.
+	if Experiment.RegabiG && !Experiment.RegabiWrappers {
+		panic("GOEXPERIMENT regabig requires regabiwrappers")
+	}
+	if Experiment.RegabiArgs && !(Experiment.RegabiWrappers && Experiment.RegabiG && Experiment.RegabiReflect && Experiment.RegabiDefer) {
+		panic("GOEXPERIMENT regabiargs requires regabiwrappers,regabig,regabireflect,regabidefer")
+	}
+}
+
+// expList returns the list of enabled GOEXPERIMENTs names.
+func expList(flags *goexperiment.Flags) []string {
+	var list []string
+	rv := reflect.ValueOf(&Experiment).Elem()
+	rt := rv.Type()
+	for i := 0; i < rt.NumField(); i++ {
+		val := rv.Field(i).Bool()
+		if val {
+			field := rt.Field(i)
+			list = append(list, strings.ToLower(field.Name))
+		}
+	}
+	return list
+}
+
+// Expstring returns the GOEXPERIMENT string that should appear in Go
+// version signatures. This always starts with "X:".
+func Expstring() string {
+	list := expList(&Experiment)
+	if len(list) == 0 {
+		return "X:none"
+	}
+	return "X:" + strings.Join(list, ",")
+}
+
+// GOEXPERIMENT returns a comma-separated list of enabled experiments.
+// This is derived from the GOEXPERIMENT environment variable if set,
+// or the value of GOEXPERIMENT when make.bash was run if not.
+func GOEXPERIMENT() string {
+	return strings.Join(expList(&Experiment), ",")
+}
+
+// EnabledExperiments returns a list of enabled experiments, as
+// lower-cased experiment names.
+func EnabledExperiments() []string {
+	return expList(&Experiment)
+}
diff --git a/src/cmd/internal/objabi/util.go b/src/cmd/internal/objabi/util.go
index ca3d3fc1a3..76c56dab27 100644
--- a/src/cmd/internal/objabi/util.go
+++ b/src/cmd/internal/objabi/util.go
@@ -5,7 +5,6 @@
 package objabi
 
 import (
-	"fmt"
 	"log"
 	"os"
 	"strings"
@@ -32,12 +31,6 @@ var (
 	GOWASM   = gowasm()
 	GO_LDSO  = defaultGO_LDSO
 	Version  = version
-
-	// GOEXPERIMENT is a comma-separated list of enabled
-	// experiments. This is derived from the GOEXPERIMENT
-	// environment variable if set, or the value of GOEXPERIMENT
-	// when make.bash was run if not.
-	GOEXPERIMENT string // Set by package init
 )
 
 const (
@@ -128,175 +121,3 @@ func gowasm() (f gowasmFeatures) {
 func Getgoextlinkenabled() string {
 	return envOr("GO_EXTLINK_ENABLED", defaultGO_EXTLINK_ENABLED)
 }
-
-func init() {
-	// Capture "default" experiments.
-	defaultExpstring = Expstring()
-
-	goexperiment := envOr("GOEXPERIMENT", defaultGOEXPERIMENT)
-
-	// GOEXPERIMENT=none overrides all experiments enabled at dist time.
-	if goexperiment != "none" {
-		for _, f := range strings.Split(goexperiment, ",") {
-			if f != "" {
-				addexp(f)
-			}
-		}
-	}
-
-	// regabi is only supported on amd64.
-	if GOARCH != "amd64" {
-		Experiment.regabi = false
-		Experiment.RegabiWrappers = false
-		Experiment.RegabiG = false
-		Experiment.RegabiReflect = false
-		Experiment.RegabiDefer = false
-		Experiment.RegabiArgs = false
-	}
-	// Setting regabi sets working sub-experiments.
-	if Experiment.regabi {
-		Experiment.RegabiWrappers = true
-		Experiment.RegabiG = true
-		Experiment.RegabiReflect = true
-		Experiment.RegabiDefer = true
-		// Not ready yet:
-		//Experiment.RegabiArgs = true
-	}
-	// Check regabi dependencies.
-	if Experiment.RegabiG && !Experiment.RegabiWrappers {
-		panic("GOEXPERIMENT regabig requires regabiwrappers")
-	}
-	if Experiment.RegabiArgs && !(Experiment.RegabiWrappers && Experiment.RegabiG && Experiment.RegabiReflect && Experiment.RegabiDefer) {
-		panic("GOEXPERIMENT regabiargs requires regabiwrappers,regabig,regabireflect,regabidefer")
-	}
-
-	// Set GOEXPERIMENT to the parsed and canonicalized set of experiments.
-	GOEXPERIMENT = expList()
-}
-
-// FramePointerEnabled enables the use of platform conventions for
-// saving frame pointers.
-//
-// This used to be an experiment, but now it's always enabled on
-// platforms that support it.
-//
-// Note: must agree with runtime.framepointer_enabled.
-var FramePointerEnabled = GOARCH == "amd64" || GOARCH == "arm64"
-
-func addexp(s string) {
-	// We could do general integer parsing here, but there's no need yet.
-	v, vb := 1, true
-	name := s
-	if len(name) > 2 && name[:2] == "no" {
-		v, vb = 0, false
-		name = name[2:]
-	}
-	for i := 0; i < len(exper); i++ {
-		if exper[i].name == name {
-			switch val := exper[i].val.(type) {
-			case *int:
-				*val = v
-			case *bool:
-				*val = vb
-			default:
-				panic("bad GOEXPERIMENT type for " + s)
-			}
-			return
-		}
-	}
-
-	fmt.Printf("unknown experiment %s\n", s)
-	os.Exit(2)
-}
-
-// Experiment contains flags for GOEXPERIMENTs.
-var Experiment = ExpFlags{}
-
-type ExpFlags struct {
-	FieldTrack        bool
-	PreemptibleLoops  bool
-	StaticLockRanking bool
-
-	// regabi is split into several sub-experiments that can be
-	// enabled individually. GOEXPERIMENT=regabi implies the
-	// subset that are currently "working". Not all combinations work.
-	regabi bool
-	// RegabiWrappers enables ABI wrappers for calling between
-	// ABI0 and ABIInternal functions. Without this, the ABIs are
-	// assumed to be identical so cross-ABI calls are direct.
-	RegabiWrappers bool
-	// RegabiG enables dedicated G and zero registers in
-	// ABIInternal.
-	//
-	// Requires wrappers because it makes the ABIs incompatible.
-	RegabiG bool
-	// RegabiReflect enables the register-passing paths in
-	// reflection calls. This is also gated by intArgRegs in
-	// reflect and runtime (which are disabled by default) so it
-	// can be used in targeted tests.
-	RegabiReflect bool
-	// RegabiDefer enables desugaring defer and go calls
-	// into argument-less closures.
-	RegabiDefer bool
-	// RegabiArgs enables register arguments/results in all
-	// compiled Go functions.
-	//
-	// Requires wrappers (to do ABI translation), g (because
-	// runtime assembly that's been ported to ABIInternal uses the
-	// G register), reflect (so reflection calls use registers),
-	// and defer (because the runtime doesn't support passing
-	// register arguments to defer/go).
-	RegabiArgs bool
-}
-
-// Toolchain experiments.
-// These are controlled by the GOEXPERIMENT environment
-// variable recorded when the toolchain is built.
-var exper = []struct {
-	name string
-	val  interface{} // Must be *int or *bool
-}{
-	{"fieldtrack", &Experiment.FieldTrack},
-	{"preemptibleloops", &Experiment.PreemptibleLoops},
-	{"staticlockranking", &Experiment.StaticLockRanking},
-	{"regabi", &Experiment.regabi},
-	{"regabiwrappers", &Experiment.RegabiWrappers},
-	{"regabig", &Experiment.RegabiG},
-	{"regabireflect", &Experiment.RegabiReflect},
-	{"regabidefer", &Experiment.RegabiDefer},
-	{"regabiargs", &Experiment.RegabiArgs},
-}
-
-var defaultExpstring string
-
-// expList returns the list of enabled GOEXPERIMENTS as a
-// commas-separated list.
-func expList() string {
-	buf := ""
-	for i := range exper {
-		switch val := exper[i].val.(type) {
-		case *int:
-			if *val != 0 {
-				buf += "," + exper[i].name
-			}
-		case *bool:
-			if *val {
-				buf += "," + exper[i].name
-			}
-		}
-	}
-	if len(buf) == 0 {
-		return ""
-	}
-	return buf[1:]
-}
-
-// Expstring returns the GOEXPERIMENT string that should appear in Go
-// version signatures. This always starts with "X:".
-func Expstring() string {
-	list := expList()
-	if list == "" {
-		return "X:none"
-	}
-	return "X:" + list
-}
diff --git a/src/internal/goexperiment/flags.go b/src/internal/goexperiment/flags.go
new file mode 100644
index 0000000000..46800b4e0f
--- /dev/null
+++ b/src/internal/goexperiment/flags.go
@@ -0,0 +1,72 @@
+// Copyright 2021 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 goexperiment implements support for toolchain experiments.
+//
+// Toolchain experiments are controlled by the GOEXPERIMENT
+// environment variable. GOEXPERIMENT is a comma-separated list of
+// experiment names. GOEXPERIMENT can be set at make.bash time, which
+// sets the default experiments for binaries built with the tool
+// chain; or it can be set at build time. GOEXPERIMENT can also be set
+// to "none", which disables any experiments that were enabled at
+// make.bash time.
+//
+// Experiments are exposed to the build in the following ways:
+//
+// - Build tag goexperiment.x is set if experiment x (lower case) is
+// enabled.
+//
+// - In runtime assembly, the macro GOEXPERIMENT_x is defined if
+// experiment x (lower case) is enabled.
+//
+// - TODO(austin): More to come.
+//
+// In the toolchain, the set of experiments enabled for the current
+// build should be accessed via objabi.Experiment.
+//
+// For the set of experiments supported by the current toolchain, see
+// go doc internal/experiment.Flags.
+package goexperiment
+
+// Flags is the set of experiments that can be enabled or disabled in
+// the current toolchain.
+//
+// When specified in the GOEXPERIMENT environment variable or as build
+// tags, experiments use the strings.ToLower of their field name.
+type Flags struct {
+	FieldTrack        bool
+	PreemptibleLoops  bool
+	StaticLockRanking bool
+
+	// Regabi is split into several sub-experiments that can be
+	// enabled individually. GOEXPERIMENT=regabi implies the
+	// subset that are currently "working". Not all combinations work.
+	Regabi bool
+	// RegabiWrappers enables ABI wrappers for calling between
+	// ABI0 and ABIInternal functions. Without this, the ABIs are
+	// assumed to be identical so cross-ABI calls are direct.
+	RegabiWrappers bool
+	// RegabiG enables dedicated G and zero registers in
+	// ABIInternal.
+	//
+	// Requires wrappers because it makes the ABIs incompatible.
+	RegabiG bool
+	// RegabiReflect enables the register-passing paths in
+	// reflection calls. This is also gated by intArgRegs in
+	// reflect and runtime (which are disabled by default) so it
+	// can be used in targeted tests.
+	RegabiReflect bool
+	// RegabiDefer enables desugaring defer and go calls
+	// into argument-less closures.
+	RegabiDefer bool
+	// RegabiArgs enables register arguments/results in all
+	// compiled Go functions.
+	//
+	// Requires wrappers (to do ABI translation), g (because
+	// runtime assembly that's been ported to ABIInternal uses the
+	// G register), reflect (so reflection calls use registers),
+	// and defer (because the runtime doesn't support passing
+	// register arguments to defer/go).
+	RegabiArgs bool
+}
-- 
GitLab


From b675e52e9592ba3db1a3cf2dc9c4bc02c89e03a8 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Tue, 6 Apr 2021 13:35:48 -0400
Subject: [PATCH 1425/2400] internal/goexperiment: consolidate
 experiment-enabled constants

Currently, we have boolean and integral constants for GOEXPERIMENTs in
various places. Consolidate these into automatically generated
constants in the internal/goexperiment package.

Change-Id: I42a49aba2a3b4c722fedea23a613162cd8a67bee
Reviewed-on: https://go-review.googlesource.com/c/go/+/307818
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/go/build/deps_test.go                     |  4 +-
 .../goexperiment/exp_fieldtrack_off.go        |  9 +++
 .../goexperiment/exp_fieldtrack_on.go         |  9 +++
 .../goexperiment/exp_preemptibleloops_off.go  |  9 +++
 .../goexperiment/exp_preemptibleloops_on.go   |  9 +++
 src/internal/goexperiment/exp_regabi_off.go   |  9 +++
 src/internal/goexperiment/exp_regabi_on.go    |  9 +++
 .../goexperiment/exp_regabiargs_off.go        |  9 +++
 .../goexperiment/exp_regabiargs_on.go         |  9 +++
 .../goexperiment/exp_regabidefer_off.go       |  9 +++
 .../goexperiment/exp_regabidefer_on.go        |  9 +++
 src/internal/goexperiment/exp_regabig_off.go  |  9 +++
 src/internal/goexperiment/exp_regabig_on.go   |  9 +++
 .../goexperiment/exp_regabireflect_off.go     |  9 +++
 .../goexperiment/exp_regabireflect_on.go      |  9 +++
 .../goexperiment/exp_regabiwrappers_off.go    |  9 +++
 .../goexperiment/exp_regabiwrappers_on.go     |  9 +++
 .../goexperiment/exp_staticlockranking_off.go |  9 +++
 .../goexperiment/exp_staticlockranking_on.go  |  9 +++
 src/internal/goexperiment/flags.go            |  9 ++-
 src/internal/goexperiment/mkconsts.go         | 74 +++++++++++++++++++
 src/reflect/abi.go                            |  7 +-
 src/reflect/regabiargs_off.go                 | 10 ---
 src/reflect/regabiargs_on.go                  | 10 ---
 src/runtime/panic.go                          | 25 ++++---
 src/runtime/proc.go                           |  5 +-
 src/runtime/regabiargs_off.go                 | 10 ---
 src/runtime/regabiargs_on.go                  | 10 ---
 src/runtime/regabidefer_off.go                | 10 ---
 src/runtime/regabidefer_on.go                 | 10 ---
 src/runtime/stubs.go                          |  3 +-
 31 files changed, 267 insertions(+), 82 deletions(-)
 create mode 100644 src/internal/goexperiment/exp_fieldtrack_off.go
 create mode 100644 src/internal/goexperiment/exp_fieldtrack_on.go
 create mode 100644 src/internal/goexperiment/exp_preemptibleloops_off.go
 create mode 100644 src/internal/goexperiment/exp_preemptibleloops_on.go
 create mode 100644 src/internal/goexperiment/exp_regabi_off.go
 create mode 100644 src/internal/goexperiment/exp_regabi_on.go
 create mode 100644 src/internal/goexperiment/exp_regabiargs_off.go
 create mode 100644 src/internal/goexperiment/exp_regabiargs_on.go
 create mode 100644 src/internal/goexperiment/exp_regabidefer_off.go
 create mode 100644 src/internal/goexperiment/exp_regabidefer_on.go
 create mode 100644 src/internal/goexperiment/exp_regabig_off.go
 create mode 100644 src/internal/goexperiment/exp_regabig_on.go
 create mode 100644 src/internal/goexperiment/exp_regabireflect_off.go
 create mode 100644 src/internal/goexperiment/exp_regabireflect_on.go
 create mode 100644 src/internal/goexperiment/exp_regabiwrappers_off.go
 create mode 100644 src/internal/goexperiment/exp_regabiwrappers_on.go
 create mode 100644 src/internal/goexperiment/exp_staticlockranking_off.go
 create mode 100644 src/internal/goexperiment/exp_staticlockranking_on.go
 create mode 100644 src/internal/goexperiment/mkconsts.go
 delete mode 100644 src/reflect/regabiargs_off.go
 delete mode 100644 src/reflect/regabiargs_on.go
 delete mode 100644 src/runtime/regabiargs_off.go
 delete mode 100644 src/runtime/regabiargs_on.go
 delete mode 100644 src/runtime/regabidefer_off.go
 delete mode 100644 src/runtime/regabidefer_on.go

diff --git a/src/go/build/deps_test.go b/src/go/build/deps_test.go
index 63ef2428b1..a1a4324331 100644
--- a/src/go/build/deps_test.go
+++ b/src/go/build/deps_test.go
@@ -71,7 +71,7 @@ var depsRules = `
 	# No dependencies allowed for any of these packages.
 	NONE
 	< container/list, container/ring,
-	  internal/cfg, internal/cpu,
+	  internal/cfg, internal/cpu, internal/goexperiment,
 	  internal/goversion, internal/nettrace,
 	  unicode/utf8, unicode/utf16, unicode,
 	  unsafe;
@@ -81,7 +81,7 @@ var depsRules = `
 	< internal/abi;
 
 	# RUNTIME is the core runtime group of packages, all of them very light-weight.
-	internal/abi, internal/cpu, unsafe
+	internal/abi, internal/cpu, internal/goexperiment, unsafe
 	< internal/bytealg
 	< internal/itoa
 	< internal/unsafeheader
diff --git a/src/internal/goexperiment/exp_fieldtrack_off.go b/src/internal/goexperiment/exp_fieldtrack_off.go
new file mode 100644
index 0000000000..e5e132660e
--- /dev/null
+++ b/src/internal/goexperiment/exp_fieldtrack_off.go
@@ -0,0 +1,9 @@
+// Code generated by mkconsts.go. DO NOT EDIT.
+
+//go:build !goexperiment.fieldtrack
+// +build !goexperiment.fieldtrack
+
+package goexperiment
+
+const FieldTrack = false
+const FieldTrackInt = 0
diff --git a/src/internal/goexperiment/exp_fieldtrack_on.go b/src/internal/goexperiment/exp_fieldtrack_on.go
new file mode 100644
index 0000000000..0d8c447246
--- /dev/null
+++ b/src/internal/goexperiment/exp_fieldtrack_on.go
@@ -0,0 +1,9 @@
+// Code generated by mkconsts.go. DO NOT EDIT.
+
+//go:build goexperiment.fieldtrack
+// +build goexperiment.fieldtrack
+
+package goexperiment
+
+const FieldTrack = true
+const FieldTrackInt = 1
diff --git a/src/internal/goexperiment/exp_preemptibleloops_off.go b/src/internal/goexperiment/exp_preemptibleloops_off.go
new file mode 100644
index 0000000000..7a26088e80
--- /dev/null
+++ b/src/internal/goexperiment/exp_preemptibleloops_off.go
@@ -0,0 +1,9 @@
+// Code generated by mkconsts.go. DO NOT EDIT.
+
+//go:build !goexperiment.preemptibleloops
+// +build !goexperiment.preemptibleloops
+
+package goexperiment
+
+const PreemptibleLoops = false
+const PreemptibleLoopsInt = 0
diff --git a/src/internal/goexperiment/exp_preemptibleloops_on.go b/src/internal/goexperiment/exp_preemptibleloops_on.go
new file mode 100644
index 0000000000..a9ca28c57c
--- /dev/null
+++ b/src/internal/goexperiment/exp_preemptibleloops_on.go
@@ -0,0 +1,9 @@
+// Code generated by mkconsts.go. DO NOT EDIT.
+
+//go:build goexperiment.preemptibleloops
+// +build goexperiment.preemptibleloops
+
+package goexperiment
+
+const PreemptibleLoops = true
+const PreemptibleLoopsInt = 1
diff --git a/src/internal/goexperiment/exp_regabi_off.go b/src/internal/goexperiment/exp_regabi_off.go
new file mode 100644
index 0000000000..5d8823843d
--- /dev/null
+++ b/src/internal/goexperiment/exp_regabi_off.go
@@ -0,0 +1,9 @@
+// Code generated by mkconsts.go. DO NOT EDIT.
+
+//go:build !goexperiment.regabi
+// +build !goexperiment.regabi
+
+package goexperiment
+
+const Regabi = false
+const RegabiInt = 0
diff --git a/src/internal/goexperiment/exp_regabi_on.go b/src/internal/goexperiment/exp_regabi_on.go
new file mode 100644
index 0000000000..c08d58e9b2
--- /dev/null
+++ b/src/internal/goexperiment/exp_regabi_on.go
@@ -0,0 +1,9 @@
+// Code generated by mkconsts.go. DO NOT EDIT.
+
+//go:build goexperiment.regabi
+// +build goexperiment.regabi
+
+package goexperiment
+
+const Regabi = true
+const RegabiInt = 1
diff --git a/src/internal/goexperiment/exp_regabiargs_off.go b/src/internal/goexperiment/exp_regabiargs_off.go
new file mode 100644
index 0000000000..31a139bbf1
--- /dev/null
+++ b/src/internal/goexperiment/exp_regabiargs_off.go
@@ -0,0 +1,9 @@
+// Code generated by mkconsts.go. DO NOT EDIT.
+
+//go:build !goexperiment.regabiargs
+// +build !goexperiment.regabiargs
+
+package goexperiment
+
+const RegabiArgs = false
+const RegabiArgsInt = 0
diff --git a/src/internal/goexperiment/exp_regabiargs_on.go b/src/internal/goexperiment/exp_regabiargs_on.go
new file mode 100644
index 0000000000..9b26f3c9cb
--- /dev/null
+++ b/src/internal/goexperiment/exp_regabiargs_on.go
@@ -0,0 +1,9 @@
+// Code generated by mkconsts.go. DO NOT EDIT.
+
+//go:build goexperiment.regabiargs
+// +build goexperiment.regabiargs
+
+package goexperiment
+
+const RegabiArgs = true
+const RegabiArgsInt = 1
diff --git a/src/internal/goexperiment/exp_regabidefer_off.go b/src/internal/goexperiment/exp_regabidefer_off.go
new file mode 100644
index 0000000000..b47c0c2cf5
--- /dev/null
+++ b/src/internal/goexperiment/exp_regabidefer_off.go
@@ -0,0 +1,9 @@
+// Code generated by mkconsts.go. DO NOT EDIT.
+
+//go:build !goexperiment.regabidefer
+// +build !goexperiment.regabidefer
+
+package goexperiment
+
+const RegabiDefer = false
+const RegabiDeferInt = 0
diff --git a/src/internal/goexperiment/exp_regabidefer_on.go b/src/internal/goexperiment/exp_regabidefer_on.go
new file mode 100644
index 0000000000..bbf2f6c69b
--- /dev/null
+++ b/src/internal/goexperiment/exp_regabidefer_on.go
@@ -0,0 +1,9 @@
+// Code generated by mkconsts.go. DO NOT EDIT.
+
+//go:build goexperiment.regabidefer
+// +build goexperiment.regabidefer
+
+package goexperiment
+
+const RegabiDefer = true
+const RegabiDeferInt = 1
diff --git a/src/internal/goexperiment/exp_regabig_off.go b/src/internal/goexperiment/exp_regabig_off.go
new file mode 100644
index 0000000000..1b37d45186
--- /dev/null
+++ b/src/internal/goexperiment/exp_regabig_off.go
@@ -0,0 +1,9 @@
+// Code generated by mkconsts.go. DO NOT EDIT.
+
+//go:build !goexperiment.regabig
+// +build !goexperiment.regabig
+
+package goexperiment
+
+const RegabiG = false
+const RegabiGInt = 0
diff --git a/src/internal/goexperiment/exp_regabig_on.go b/src/internal/goexperiment/exp_regabig_on.go
new file mode 100644
index 0000000000..7e5b162e0b
--- /dev/null
+++ b/src/internal/goexperiment/exp_regabig_on.go
@@ -0,0 +1,9 @@
+// Code generated by mkconsts.go. DO NOT EDIT.
+
+//go:build goexperiment.regabig
+// +build goexperiment.regabig
+
+package goexperiment
+
+const RegabiG = true
+const RegabiGInt = 1
diff --git a/src/internal/goexperiment/exp_regabireflect_off.go b/src/internal/goexperiment/exp_regabireflect_off.go
new file mode 100644
index 0000000000..515f4a53e6
--- /dev/null
+++ b/src/internal/goexperiment/exp_regabireflect_off.go
@@ -0,0 +1,9 @@
+// Code generated by mkconsts.go. DO NOT EDIT.
+
+//go:build !goexperiment.regabireflect
+// +build !goexperiment.regabireflect
+
+package goexperiment
+
+const RegabiReflect = false
+const RegabiReflectInt = 0
diff --git a/src/internal/goexperiment/exp_regabireflect_on.go b/src/internal/goexperiment/exp_regabireflect_on.go
new file mode 100644
index 0000000000..e8a3e9c06a
--- /dev/null
+++ b/src/internal/goexperiment/exp_regabireflect_on.go
@@ -0,0 +1,9 @@
+// Code generated by mkconsts.go. DO NOT EDIT.
+
+//go:build goexperiment.regabireflect
+// +build goexperiment.regabireflect
+
+package goexperiment
+
+const RegabiReflect = true
+const RegabiReflectInt = 1
diff --git a/src/internal/goexperiment/exp_regabiwrappers_off.go b/src/internal/goexperiment/exp_regabiwrappers_off.go
new file mode 100644
index 0000000000..bfa0fa3779
--- /dev/null
+++ b/src/internal/goexperiment/exp_regabiwrappers_off.go
@@ -0,0 +1,9 @@
+// Code generated by mkconsts.go. DO NOT EDIT.
+
+//go:build !goexperiment.regabiwrappers
+// +build !goexperiment.regabiwrappers
+
+package goexperiment
+
+const RegabiWrappers = false
+const RegabiWrappersInt = 0
diff --git a/src/internal/goexperiment/exp_regabiwrappers_on.go b/src/internal/goexperiment/exp_regabiwrappers_on.go
new file mode 100644
index 0000000000..11ffffbbff
--- /dev/null
+++ b/src/internal/goexperiment/exp_regabiwrappers_on.go
@@ -0,0 +1,9 @@
+// Code generated by mkconsts.go. DO NOT EDIT.
+
+//go:build goexperiment.regabiwrappers
+// +build goexperiment.regabiwrappers
+
+package goexperiment
+
+const RegabiWrappers = true
+const RegabiWrappersInt = 1
diff --git a/src/internal/goexperiment/exp_staticlockranking_off.go b/src/internal/goexperiment/exp_staticlockranking_off.go
new file mode 100644
index 0000000000..3d546c04b4
--- /dev/null
+++ b/src/internal/goexperiment/exp_staticlockranking_off.go
@@ -0,0 +1,9 @@
+// Code generated by mkconsts.go. DO NOT EDIT.
+
+//go:build !goexperiment.staticlockranking
+// +build !goexperiment.staticlockranking
+
+package goexperiment
+
+const StaticLockRanking = false
+const StaticLockRankingInt = 0
diff --git a/src/internal/goexperiment/exp_staticlockranking_on.go b/src/internal/goexperiment/exp_staticlockranking_on.go
new file mode 100644
index 0000000000..78188fb810
--- /dev/null
+++ b/src/internal/goexperiment/exp_staticlockranking_on.go
@@ -0,0 +1,9 @@
+// Code generated by mkconsts.go. DO NOT EDIT.
+
+//go:build goexperiment.staticlockranking
+// +build goexperiment.staticlockranking
+
+package goexperiment
+
+const StaticLockRanking = true
+const StaticLockRankingInt = 1
diff --git a/src/internal/goexperiment/flags.go b/src/internal/goexperiment/flags.go
index 46800b4e0f..c5e3d2c91a 100644
--- a/src/internal/goexperiment/flags.go
+++ b/src/internal/goexperiment/flags.go
@@ -17,11 +17,12 @@
 // - Build tag goexperiment.x is set if experiment x (lower case) is
 // enabled.
 //
+// - For each experiment x (in camel case), this package contains a
+// boolean constant x and an integer constant xInt.
+//
 // - In runtime assembly, the macro GOEXPERIMENT_x is defined if
 // experiment x (lower case) is enabled.
 //
-// - TODO(austin): More to come.
-//
 // In the toolchain, the set of experiments enabled for the current
 // build should be accessed via objabi.Experiment.
 //
@@ -29,11 +30,15 @@
 // go doc internal/experiment.Flags.
 package goexperiment
 
+//go:generate go run mkconsts.go
+
 // Flags is the set of experiments that can be enabled or disabled in
 // the current toolchain.
 //
 // When specified in the GOEXPERIMENT environment variable or as build
 // tags, experiments use the strings.ToLower of their field name.
+//
+// If you change this struct definition, run "go generate".
 type Flags struct {
 	FieldTrack        bool
 	PreemptibleLoops  bool
diff --git a/src/internal/goexperiment/mkconsts.go b/src/internal/goexperiment/mkconsts.go
new file mode 100644
index 0000000000..204ca9d9aa
--- /dev/null
+++ b/src/internal/goexperiment/mkconsts.go
@@ -0,0 +1,74 @@
+// Copyright 2021 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.
+
+//go:build ignore
+// +build ignore
+
+// mkconsts generates const definition files for each GOEXPERIMENT.
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"internal/goexperiment"
+	"log"
+	"os"
+	"reflect"
+	"strings"
+)
+
+func main() {
+	// Delete existing experiment constant files.
+	ents, err := os.ReadDir(".")
+	if err != nil {
+		log.Fatal(err)
+	}
+	for _, ent := range ents {
+		name := ent.Name()
+		if !strings.HasPrefix(name, "exp_") {
+			continue
+		}
+		// Check that this is definitely a generated file.
+		data, err := os.ReadFile(name)
+		if err != nil {
+			log.Fatalf("reading %s: %v", name, err)
+		}
+		if !bytes.Contains(data, []byte("Code generated by mkconsts")) {
+			log.Fatalf("%s: expected generated file", name)
+		}
+		if err := os.Remove(name); err != nil {
+			log.Fatal(err)
+		}
+	}
+
+	// Generate new experiment constant files.
+	rt := reflect.TypeOf(&goexperiment.Flags{}).Elem()
+	for i := 0; i < rt.NumField(); i++ {
+		f := rt.Field(i).Name
+		buildTag := "goexperiment." + strings.ToLower(f)
+		for _, val := range []bool{false, true} {
+			name := fmt.Sprintf("exp_%s_%s.go", strings.ToLower(f), pick(val, "off", "on"))
+			data := fmt.Sprintf(`// Code generated by mkconsts.go. DO NOT EDIT.
+
+//go:build %s%s
+// +build %s%s
+
+package goexperiment
+
+const %s = %v
+const %sInt = %s
+`, pick(val, "!", ""), buildTag, pick(val, "!", ""), buildTag, f, val, f, pick(val, "0", "1"))
+			if err := os.WriteFile(name, []byte(data), 0666); err != nil {
+				log.Fatalf("writing %s: %v", name, err)
+			}
+		}
+	}
+}
+
+func pick(v bool, f, t string) string {
+	if v {
+		return t
+	}
+	return f
+}
diff --git a/src/reflect/abi.go b/src/reflect/abi.go
index 6a422d06d1..caa770fcb0 100644
--- a/src/reflect/abi.go
+++ b/src/reflect/abi.go
@@ -6,6 +6,7 @@ package reflect
 
 import (
 	"internal/abi"
+	"internal/goexperiment"
 	"unsafe"
 )
 
@@ -28,9 +29,9 @@ import (
 // commented out there should be the actual values once
 // we're ready to use the register ABI everywhere.
 var (
-	intArgRegs   = abi.IntArgRegs * experimentRegabiArgs
-	floatArgRegs = abi.FloatArgRegs * experimentRegabiArgs
-	floatRegSize = uintptr(abi.EffectiveFloatRegSize * experimentRegabiArgs)
+	intArgRegs   = abi.IntArgRegs * goexperiment.RegabiArgsInt
+	floatArgRegs = abi.FloatArgRegs * goexperiment.RegabiArgsInt
+	floatRegSize = uintptr(abi.EffectiveFloatRegSize * goexperiment.RegabiArgsInt)
 )
 
 // abiStep represents an ABI "instruction." Each instruction
diff --git a/src/reflect/regabiargs_off.go b/src/reflect/regabiargs_off.go
deleted file mode 100644
index 655e955474..0000000000
--- a/src/reflect/regabiargs_off.go
+++ /dev/null
@@ -1,10 +0,0 @@
-// Copyright 2021 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.
-
-//go:build !goexperiment.regabiargs
-// +build !goexperiment.regabiargs
-
-package reflect
-
-const experimentRegabiArgs = 0
diff --git a/src/reflect/regabiargs_on.go b/src/reflect/regabiargs_on.go
deleted file mode 100644
index 0f33b22ff9..0000000000
--- a/src/reflect/regabiargs_on.go
+++ /dev/null
@@ -1,10 +0,0 @@
-// Copyright 2021 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.
-
-//go:build goexperiment.regabiargs
-// +build goexperiment.regabiargs
-
-package reflect
-
-const experimentRegabiArgs = 1
diff --git a/src/runtime/panic.go b/src/runtime/panic.go
index d33441a0d8..c437553012 100644
--- a/src/runtime/panic.go
+++ b/src/runtime/panic.go
@@ -6,6 +6,7 @@ package runtime
 
 import (
 	"internal/abi"
+	"internal/goexperiment"
 	"runtime/internal/atomic"
 	"runtime/internal/sys"
 	"unsafe"
@@ -228,7 +229,7 @@ func deferproc(siz int32, fn *funcval) { // arguments of fn follow fn
 		throw("defer on system stack")
 	}
 
-	if experimentRegabiDefer && siz != 0 {
+	if goexperiment.RegabiDefer && siz != 0 {
 		// TODO: Make deferproc just take a func().
 		throw("defer with non-empty frame")
 	}
@@ -285,7 +286,7 @@ func deferprocStack(d *_defer) {
 		// go code on the system stack can't defer
 		throw("defer on system stack")
 	}
-	if experimentRegabiDefer && d.siz != 0 {
+	if goexperiment.RegabiDefer && d.siz != 0 {
 		throw("defer with non-empty frame")
 	}
 	// siz and fn are already set.
@@ -387,8 +388,8 @@ func deferArgs(d *_defer) unsafe.Pointer {
 // that experiment, we should change the type of d.fn.
 //go:nosplit
 func deferFunc(d *_defer) func() {
-	if !experimentRegabiDefer {
-		throw("requires experimentRegabiDefer")
+	if !goexperiment.RegabiDefer {
+		throw("requires GOEXPERIMENT=regabidefer")
 	}
 	var fn func()
 	*(**funcval)(unsafe.Pointer(&fn)) = d.fn
@@ -648,7 +649,7 @@ func Goexit() {
 				addOneOpenDeferFrame(gp, 0, nil)
 			}
 		} else {
-			if experimentRegabiDefer {
+			if goexperiment.RegabiDefer {
 				// Save the pc/sp in deferCallSave(), so we can "recover" back to this
 				// loop if necessary.
 				deferCallSave(&p, deferFunc(d))
@@ -850,7 +851,7 @@ func runOpenDeferFrame(gp *g, d *_defer) bool {
 		argWidth, fd = readvarintUnsafe(fd)
 		closureOffset, fd = readvarintUnsafe(fd)
 		nArgs, fd = readvarintUnsafe(fd)
-		if experimentRegabiDefer && argWidth != 0 {
+		if goexperiment.RegabiDefer && argWidth != 0 {
 			throw("defer with non-empty frame")
 		}
 		if deferBits&(1<<i) == 0 {
@@ -878,7 +879,7 @@ func runOpenDeferFrame(gp *g, d *_defer) bool {
 		deferBits = deferBits &^ (1 << i)
 		*(*uint8)(unsafe.Pointer(d.varp - uintptr(deferBitsOffset))) = deferBits
 		p := d._panic
-		if experimentRegabiDefer {
+		if goexperiment.RegabiDefer {
 			deferCallSave(p, deferFunc(d))
 		} else {
 			reflectcallSave(p, unsafe.Pointer(closure), deferArgs, argWidth)
@@ -906,8 +907,8 @@ func runOpenDeferFrame(gp *g, d *_defer) bool {
 // This is marked as a wrapper by the compiler so it doesn't appear in
 // tracebacks.
 func reflectcallSave(p *_panic, fn, arg unsafe.Pointer, argsize uint32) {
-	if experimentRegabiDefer {
-		throw("not allowed with experimentRegabiDefer")
+	if goexperiment.RegabiDefer {
+		throw("not allowed with GOEXPERIMENT=regabidefer")
 	}
 	if p != nil {
 		p.argp = unsafe.Pointer(getargp(0))
@@ -932,8 +933,8 @@ func reflectcallSave(p *_panic, fn, arg unsafe.Pointer, argsize uint32) {
 // This is marked as a wrapper by the compiler so it doesn't appear in
 // tracebacks.
 func deferCallSave(p *_panic, fn func()) {
-	if !experimentRegabiDefer {
-		throw("only allowed with experimentRegabiDefer")
+	if !goexperiment.RegabiDefer {
+		throw("only allowed with GOEXPERIMENT=regabidefer")
 	}
 	if p != nil {
 		p.argp = unsafe.Pointer(getargp(0))
@@ -1035,7 +1036,7 @@ func gopanic(e interface{}) {
 		} else {
 			p.argp = unsafe.Pointer(getargp(0))
 
-			if experimentRegabiDefer {
+			if goexperiment.RegabiDefer {
 				fn := deferFunc(d)
 				fn()
 			} else {
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 583ed73d84..35a3f9ca19 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -6,6 +6,7 @@ package runtime
 
 import (
 	"internal/cpu"
+	"internal/goexperiment"
 	"runtime/internal/atomic"
 	"runtime/internal/sys"
 	"unsafe"
@@ -4021,8 +4022,8 @@ func malg(stacksize int32) *g {
 //
 //go:nosplit
 func newproc(siz int32, fn *funcval) {
-	if experimentRegabiDefer && siz != 0 {
-		// TODO: When we commit to experimentRegabiDefer,
+	if goexperiment.RegabiDefer && siz != 0 {
+		// TODO: When we commit to GOEXPERIMENT=regabidefer,
 		// rewrite newproc's comment, since it will no longer
 		// have a funny stack layout or need to be nosplit.
 		throw("go with non-empty frame")
diff --git a/src/runtime/regabiargs_off.go b/src/runtime/regabiargs_off.go
deleted file mode 100644
index 49d7bcc28d..0000000000
--- a/src/runtime/regabiargs_off.go
+++ /dev/null
@@ -1,10 +0,0 @@
-// Copyright 2021 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.
-
-//go:build !goexperiment.regabiargs
-// +build !goexperiment.regabiargs
-
-package runtime
-
-const experimentRegabiArgs = 0
diff --git a/src/runtime/regabiargs_on.go b/src/runtime/regabiargs_on.go
deleted file mode 100644
index 935d3ec24b..0000000000
--- a/src/runtime/regabiargs_on.go
+++ /dev/null
@@ -1,10 +0,0 @@
-// Copyright 2021 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.
-
-//go:build goexperiment.regabiargs
-// +build goexperiment.regabiargs
-
-package runtime
-
-const experimentRegabiArgs = 1
diff --git a/src/runtime/regabidefer_off.go b/src/runtime/regabidefer_off.go
deleted file mode 100644
index 72e3cf9c50..0000000000
--- a/src/runtime/regabidefer_off.go
+++ /dev/null
@@ -1,10 +0,0 @@
-// Copyright 2021 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.
-
-//go:build !goexperiment.regabidefer
-// +build !goexperiment.regabidefer
-
-package runtime
-
-const experimentRegabiDefer = false
diff --git a/src/runtime/regabidefer_on.go b/src/runtime/regabidefer_on.go
deleted file mode 100644
index 281694b061..0000000000
--- a/src/runtime/regabidefer_on.go
+++ /dev/null
@@ -1,10 +0,0 @@
-// Copyright 2021 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.
-
-//go:build goexperiment.regabidefer
-// +build goexperiment.regabidefer
-
-package runtime
-
-const experimentRegabiDefer = true
diff --git a/src/runtime/stubs.go b/src/runtime/stubs.go
index e2d4f0da3b..f11ec539df 100644
--- a/src/runtime/stubs.go
+++ b/src/runtime/stubs.go
@@ -6,6 +6,7 @@ package runtime
 
 import (
 	"internal/abi"
+	"internal/goexperiment"
 	"unsafe"
 )
 
@@ -423,4 +424,4 @@ func sigpanic0()
 // everywhere.
 //
 // Protected by finlock.
-var intArgRegs = abi.IntArgRegs * experimentRegabiArgs
+var intArgRegs = abi.IntArgRegs * goexperiment.RegabiArgsInt
-- 
GitLab


From 89ca1ce9a8fbb70800fe24cc13aa267c3c90aadb Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Wed, 7 Apr 2021 09:27:11 -0400
Subject: [PATCH 1426/2400] cmd/compile,cmd/internal/objabi: abstract out
 object header string

Change-Id: Idbbb4cb7127b93afa34a8aa18bbdaad1f206ab6a
Reviewed-on: https://go-review.googlesource.com/c/go/+/308090
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/gc/obj.go       | 2 +-
 src/cmd/compile/internal/noder/import.go | 6 +++---
 src/cmd/internal/objabi/util.go          | 9 +++++++++
 3 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index d18011a9e5..f87a3c6b48 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -70,7 +70,7 @@ func dumpobj1(outfile string, mode int) {
 }
 
 func printObjHeader(bout *bio.Writer) {
-	fmt.Fprintf(bout, "go object %s %s %s %s\n", objabi.GOOS, objabi.GOARCH, objabi.Version, objabi.Expstring())
+	bout.WriteString(objabi.HeaderString())
 	if base.Flag.BuildID != "" {
 		fmt.Fprintf(bout, "build id %q\n", base.Flag.BuildID)
 	}
diff --git a/src/cmd/compile/internal/noder/import.go b/src/cmd/compile/internal/noder/import.go
index 89a2598833..e6e3fe1834 100644
--- a/src/cmd/compile/internal/noder/import.go
+++ b/src/cmd/compile/internal/noder/import.go
@@ -243,9 +243,9 @@ func importfile(decl *syntax.ImportDecl) *types.Pkg {
 		base.Errorf("import %s: not a go object file: %s", file, p)
 		base.ErrorExit()
 	}
-	q := fmt.Sprintf("%s %s %s %s\n", objabi.GOOS, objabi.GOARCH, objabi.Version, objabi.Expstring())
-	if p[10:] != q {
-		base.Errorf("import %s: object is [%s] expected [%s]", file, p[10:], q)
+	q := objabi.HeaderString()
+	if p != q {
+		base.Errorf("import %s: object is [%s] expected [%s]", file, p, q)
 		base.ErrorExit()
 	}
 
diff --git a/src/cmd/internal/objabi/util.go b/src/cmd/internal/objabi/util.go
index 76c56dab27..c2c05bd1b2 100644
--- a/src/cmd/internal/objabi/util.go
+++ b/src/cmd/internal/objabi/util.go
@@ -5,6 +5,7 @@
 package objabi
 
 import (
+	"fmt"
 	"log"
 	"os"
 	"strings"
@@ -121,3 +122,11 @@ func gowasm() (f gowasmFeatures) {
 func Getgoextlinkenabled() string {
 	return envOr("GO_EXTLINK_ENABLED", defaultGO_EXTLINK_ENABLED)
 }
+
+// HeaderString returns the toolchain configuration string written in
+// Go object headers. This string ensures we don't attempt to import
+// or link object files that are incompatible with each other. This
+// string always starts with "go object ".
+func HeaderString() string {
+	return fmt.Sprintf("go object %s %s %s %s\n", GOOS, GOARCH, Version, Expstring())
+}
-- 
GitLab


From a8e55538af40905961c263d980760b76e9c43593 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Tue, 6 Apr 2021 16:11:17 -0400
Subject: [PATCH 1427/2400] cmd/internal/objabi: make GOEXPERIMENT be a diff
 from default experiments

Right now the rules around handling default-on experiments are
complicated and a bit inconsistent. Notably, objabi.GOEXPERIMENT is
set to a comma-separated list of enabled experiments, but this may not
be the string a user should set the GOEXPERIMENT environment variable
to get that list of experiments: if an experiment is enabled by
default but gets turned off by GOEXPERIMENT, then the string we report
needs to include "no"+experiment to capture that default override.

This complication also seeps into the version string we print for "go
tool compile -V", etc. This logic is further complicated by the fact
that it only wants to include an experiment string if the set of
experiments varies from the default.

This CL rethinks how we handle default-on experiments. Now that
experiment state is all captured in a struct, we can simplify a lot of
this logic. objabi.GOEXPERIMENT will be set based on the delta from
the default set of experiments, which reflects what a user would
actually need to pass on the command line. Likewise, we include this
delta in the "-V" output, which simplifies this logic because if
there's nothing to show in the version string, the delta will be
empty.

Change-Id: I7ed307329541fc2c9f90edd463fbaf8e0cc9e8ee
Reviewed-on: https://go-review.googlesource.com/c/go/+/307819
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/go/script_test.go                     |  2 +-
 src/cmd/go/testdata/script/README             |  2 +-
 .../script/build_tag_goexperiment.txt         | 16 ++---
 src/cmd/internal/objabi/exp.go                | 69 +++++++++++--------
 src/cmd/internal/objabi/flag.go               | 18 ++---
 src/cmd/internal/objabi/util.go               |  2 +-
 src/internal/goexperiment/flags.go            |  5 ++
 7 files changed, 62 insertions(+), 52 deletions(-)

diff --git a/src/cmd/go/script_test.go b/src/cmd/go/script_test.go
index 1f38be8ee4..c353a9cb01 100644
--- a/src/cmd/go/script_test.go
+++ b/src/cmd/go/script_test.go
@@ -165,7 +165,7 @@ func (ts *testScript) setup() {
 		"GOCACHE=" + testGOCACHE,
 		"GODEBUG=" + os.Getenv("GODEBUG"),
 		"GOEXE=" + cfg.ExeSuffix,
-		"GOEXPSTRING=" + objabi.Expstring()[2:],
+		"GOEXPERIMENT=" + objabi.GOEXPERIMENT(),
 		"GOOS=" + runtime.GOOS,
 		"GOPATH=" + filepath.Join(ts.workdir, "gopath"),
 		"GOPROXY=" + proxyURL,
diff --git a/src/cmd/go/testdata/script/README b/src/cmd/go/testdata/script/README
index d658cebfce..b4dcb1f5a2 100644
--- a/src/cmd/go/testdata/script/README
+++ b/src/cmd/go/testdata/script/README
@@ -29,7 +29,7 @@ Scripts also have access to these other environment variables:
 	GOARCH=<target GOARCH>
 	GOCACHE=<actual GOCACHE being used outside the test>
 	GOEXE=<executable file suffix: .exe on Windows, empty on other systems>
-	GOEXPSTRING=<value of objabi.Expstring(), from GOEXPERIMENT when toolchain built>
+	GOEXPERIMENT=<value of objabi.GOEXPERIMENT>
 	GOOS=<target GOOS>
 	GOPATH=$WORK/gopath
 	GOPROXY=<local module proxy serving from cmd/go/testdata/mod>
diff --git a/src/cmd/go/testdata/script/build_tag_goexperiment.txt b/src/cmd/go/testdata/script/build_tag_goexperiment.txt
index 26ad029845..dfda3d2629 100644
--- a/src/cmd/go/testdata/script/build_tag_goexperiment.txt
+++ b/src/cmd/go/testdata/script/build_tag_goexperiment.txt
@@ -1,6 +1,6 @@
 # compile_ext will fail if the buildtags that are enabled (or not enabled) for the
 # framepointer and fieldtrack experiments are not consistent with the value of
-# GOEXPSTRING (which comes from objabi.Expstring()).
+# objabi.GOEXPERIMENT.
 
 [short] skip
 go run m
@@ -19,10 +19,8 @@ func main() {
 }
 
 func hasExpEntry(s string) bool {
-	// script_test.go defines GOEXPSTRING to be the value of
-	// objabi.Expstring(), which gives the enabled experiments baked into the
-	// toolchain.
-	g := os.Getenv("GOEXPSTRING")
+	// script_test.go defines GOEXPERIMENT to be the enabled experiments.
+	g := os.Getenv("GOEXPERIMENT")
 	for _, f := range strings.Split(g, ",") {
 		if f == s {
 			return true
@@ -43,7 +41,7 @@ import (
 
 func fp() {
 	if hasExpEntry("framepointer") {
-		fmt.Println("in !framepointer build, but objabi.Expstring() has 'framepointer'")
+		fmt.Println("in !framepointer build, but objabi.GOEXPERIMENT has 'framepointer'")
 		os.Exit(1)
 	}
 }
@@ -60,7 +58,7 @@ import (
 
 func fp() {
 	if !hasExpEntry("framepointer") {
-		fmt.Println("in framepointer build, but objabi.Expstring() does not have 'framepointer', is", os.Getenv("GOEXPSTRING"))
+		fmt.Println("in framepointer build, but objabi.GOEXPERIMENT does not have 'framepointer', is", os.Getenv("GOEXPERIMENT"))
 		os.Exit(1)
 	}
 }
@@ -77,7 +75,7 @@ import (
 
 func ft() {
 	if hasExpEntry("fieldtrack") {
-		fmt.Println("in !fieldtrack build, but objabi.Expstring() has 'fieldtrack'")
+		fmt.Println("in !fieldtrack build, but objabi.GOEXPERIMENT has 'fieldtrack'")
 		os.Exit(1)
 	}
 }
@@ -94,7 +92,7 @@ import (
 
 func ft() {
 	if !hasExpEntry("fieldtrack") {
-		fmt.Println("in fieldtrack build, but objabi.Expstring() does not have 'fieldtrack', is", os.Getenv("GOEXPSTRING"))
+		fmt.Println("in fieldtrack build, but objabi.GOEXPERIMENT does not have 'fieldtrack', is", os.Getenv("GOEXPERIMENT"))
 		os.Exit(1)
 	}
 }
diff --git a/src/cmd/internal/objabi/exp.go b/src/cmd/internal/objabi/exp.go
index 21a70d5dfe..eaa8620807 100644
--- a/src/cmd/internal/objabi/exp.go
+++ b/src/cmd/internal/objabi/exp.go
@@ -20,8 +20,6 @@ import (
 // was built with.)
 var Experiment goexperiment.Flags
 
-var defaultExpstring string // Set by package init
-
 // FramePointerEnabled enables the use of platform conventions for
 // saving frame pointers.
 //
@@ -32,13 +30,15 @@ var defaultExpstring string // Set by package init
 var FramePointerEnabled = GOARCH == "amd64" || GOARCH == "arm64"
 
 func init() {
-	// Capture "default" experiments.
-	defaultExpstring = Expstring()
+	// Start with the baseline configuration.
+	Experiment = goexperiment.BaselineFlags
 
-	goexperiment := envOr("GOEXPERIMENT", defaultGOEXPERIMENT)
+	// Pick up any changes to the baseline configuration from the
+	// GOEXPERIMENT environment. This can be set at make.bash time
+	// and overridden at build time.
+	env := envOr("GOEXPERIMENT", defaultGOEXPERIMENT)
 
-	// GOEXPERIMENT=none overrides all experiments enabled at dist time.
-	if goexperiment != "none" {
+	if env != "" {
 		// Create a map of known experiment names.
 		names := make(map[string]reflect.Value)
 		rv := reflect.ValueOf(&Experiment).Elem()
@@ -49,10 +49,16 @@ func init() {
 		}
 
 		// Parse names.
-		for _, f := range strings.Split(goexperiment, ",") {
+		for _, f := range strings.Split(env, ",") {
 			if f == "" {
 				continue
 			}
+			if f == "none" {
+				// GOEXPERIMENT=none restores the baseline configuration.
+				// (This is useful for overriding make.bash-time settings.)
+				Experiment = goexperiment.BaselineFlags
+				continue
+			}
 			val := true
 			if strings.HasPrefix(f, "no") {
 				f, val = f[2:], false
@@ -93,40 +99,45 @@ func init() {
 	}
 }
 
-// expList returns the list of enabled GOEXPERIMENTs names.
-func expList(flags *goexperiment.Flags) []string {
+// expList returns the list of lower-cased experiment names for
+// experiments that differ from base. base may be nil to indicate no
+// experiments.
+func expList(exp, base *goexperiment.Flags) []string {
 	var list []string
-	rv := reflect.ValueOf(&Experiment).Elem()
+	rv := reflect.ValueOf(exp).Elem()
+	var rBase reflect.Value
+	if base != nil {
+		rBase = reflect.ValueOf(base).Elem()
+	}
 	rt := rv.Type()
 	for i := 0; i < rt.NumField(); i++ {
+		name := strings.ToLower(rt.Field(i).Name)
 		val := rv.Field(i).Bool()
-		if val {
-			field := rt.Field(i)
-			list = append(list, strings.ToLower(field.Name))
+		baseVal := false
+		if base != nil {
+			baseVal = rBase.Field(i).Bool()
+		}
+		if val != baseVal {
+			if val {
+				list = append(list, name)
+			} else {
+				list = append(list, "no"+name)
+			}
 		}
 	}
 	return list
 }
 
-// Expstring returns the GOEXPERIMENT string that should appear in Go
-// version signatures. This always starts with "X:".
-func Expstring() string {
-	list := expList(&Experiment)
-	if len(list) == 0 {
-		return "X:none"
-	}
-	return "X:" + strings.Join(list, ",")
-}
-
-// GOEXPERIMENT returns a comma-separated list of enabled experiments.
-// This is derived from the GOEXPERIMENT environment variable if set,
-// or the value of GOEXPERIMENT when make.bash was run if not.
+// GOEXPERIMENT is a comma-separated list of enabled or disabled
+// experiments that differ from the baseline experiment configuration.
+// GOEXPERIMENT is exactly what a user would set on the command line
+// to get the set of enabled experiments.
 func GOEXPERIMENT() string {
-	return strings.Join(expList(&Experiment), ",")
+	return strings.Join(expList(&Experiment, &goexperiment.BaselineFlags), ",")
 }
 
 // EnabledExperiments returns a list of enabled experiments, as
 // lower-cased experiment names.
 func EnabledExperiments() []string {
-	return expList(&Experiment)
+	return expList(&Experiment, nil)
 }
diff --git a/src/cmd/internal/objabi/flag.go b/src/cmd/internal/objabi/flag.go
index 25b0185f64..6a8a69116d 100644
--- a/src/cmd/internal/objabi/flag.go
+++ b/src/cmd/internal/objabi/flag.go
@@ -91,16 +91,12 @@ func (versionFlag) Set(s string) error {
 	name = name[strings.LastIndex(name, `\`)+1:]
 	name = strings.TrimSuffix(name, ".exe")
 
-	// If there's an active experiment, include that,
-	// to distinguish go1.10.2 with an experiment
-	// from go1.10.2 without an experiment.
-	p := Expstring()
-	if p == defaultExpstring {
-		p = ""
-	}
-	sep := ""
-	if p != "" {
-		sep = " "
+	p := ""
+
+	// If the enabled experiments differ from the defaults,
+	// include that difference.
+	if goexperiment := GOEXPERIMENT(); goexperiment != "" {
+		p = " X:" + goexperiment
 	}
 
 	// The go command invokes -V=full to get a unique identifier
@@ -114,7 +110,7 @@ func (versionFlag) Set(s string) error {
 		}
 	}
 
-	fmt.Printf("%s version %s%s%s\n", name, Version, sep, p)
+	fmt.Printf("%s version %s%s\n", name, Version, p)
 	os.Exit(0)
 	return nil
 }
diff --git a/src/cmd/internal/objabi/util.go b/src/cmd/internal/objabi/util.go
index c2c05bd1b2..5a7a74cfde 100644
--- a/src/cmd/internal/objabi/util.go
+++ b/src/cmd/internal/objabi/util.go
@@ -128,5 +128,5 @@ func Getgoextlinkenabled() string {
 // or link object files that are incompatible with each other. This
 // string always starts with "go object ".
 func HeaderString() string {
-	return fmt.Sprintf("go object %s %s %s %s\n", GOOS, GOARCH, Version, Expstring())
+	return fmt.Sprintf("go object %s %s %s X:%s\n", GOOS, GOARCH, Version, strings.Join(EnabledExperiments(), ","))
 }
diff --git a/src/internal/goexperiment/flags.go b/src/internal/goexperiment/flags.go
index c5e3d2c91a..1c513d5a70 100644
--- a/src/internal/goexperiment/flags.go
+++ b/src/internal/goexperiment/flags.go
@@ -75,3 +75,8 @@ type Flags struct {
 	// register arguments to defer/go).
 	RegabiArgs bool
 }
+
+// BaselineFlags specifies the experiment flags that are enabled by
+// default in the current toolchain. This is, in effect, the "control"
+// configuration and any variation from this is an experiment.
+var BaselineFlags = Flags{}
-- 
GitLab


From 5159c836410535fad0ae0b23329ef91347c1b133 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Tue, 6 Apr 2021 17:04:52 -0400
Subject: [PATCH 1428/2400] runtime,cmd/link: include GOEXPERIMENTs in
 runtime.Version(), "go version X"

This adds the set of GOEXPERIMENTs to the build version if it differs
from the default set of experiments. This exposes the experiment
settings via runtime.Version() and "go version <binary>".

Change-Id: I143dbbc50f66a4cf175469199974e18848075af6
Reviewed-on: https://go-review.googlesource.com/c/go/+/307820
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/dist/buildruntime.go                     |  2 --
 .../go/testdata/script/version_goexperiment.txt  | 16 ++++++++++++++++
 src/cmd/link/internal/ld/main.go                 |  6 ++++++
 src/internal/goexperiment/flags.go               |  3 +++
 src/runtime/extern.go                            | 12 +++++++++++-
 src/runtime/proc.go                              |  2 --
 6 files changed, 36 insertions(+), 5 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/version_goexperiment.txt

diff --git a/src/cmd/dist/buildruntime.go b/src/cmd/dist/buildruntime.go
index e0a101a353..3ef551e187 100644
--- a/src/cmd/dist/buildruntime.go
+++ b/src/cmd/dist/buildruntime.go
@@ -19,7 +19,6 @@ import (
 //
 //	package sys
 //
-//	const TheVersion = <version>
 //	const StackGuardMultiplier = <multiplier value>
 //
 func mkzversion(dir, file string) {
@@ -28,7 +27,6 @@ func mkzversion(dir, file string) {
 	fmt.Fprintln(&buf)
 	fmt.Fprintf(&buf, "package sys\n")
 	fmt.Fprintln(&buf)
-	fmt.Fprintf(&buf, "const TheVersion = `%s`\n", findgoversion())
 	fmt.Fprintf(&buf, "const StackGuardMultiplierDefault = %d\n", stackGuardMultiplierDefault())
 
 	writefile(buf.String(), file, writeSkipSame)
diff --git a/src/cmd/go/testdata/script/version_goexperiment.txt b/src/cmd/go/testdata/script/version_goexperiment.txt
new file mode 100644
index 0000000000..4b165eb605
--- /dev/null
+++ b/src/cmd/go/testdata/script/version_goexperiment.txt
@@ -0,0 +1,16 @@
+# Test that experiments appear in "go version <binary>"
+
+# This test requires rebuilding the runtime, which takes a while.
+[short] skip
+
+env GOEXPERIMENT=fieldtrack
+go build -o main$GOEXE version.go
+go version main$GOEXE
+stdout 'X:fieldtrack$'
+exec ./main$GOEXE
+stderr 'X:fieldtrack$'
+
+-- version.go --
+package main
+import "runtime"
+func main() { println(runtime.Version()) }
diff --git a/src/cmd/link/internal/ld/main.go b/src/cmd/link/internal/ld/main.go
index 95c89f813b..8631cf2939 100644
--- a/src/cmd/link/internal/ld/main.go
+++ b/src/cmd/link/internal/ld/main.go
@@ -118,6 +118,12 @@ func Main(arch *sys.Arch, theArch Arch) {
 	addstrdata1(ctxt, "runtime.defaultGOROOT="+final)
 	addstrdata1(ctxt, "cmd/internal/objabi.defaultGOROOT="+final)
 
+	buildVersion := objabi.Version
+	if goexperiment := objabi.GOEXPERIMENT(); goexperiment != "" {
+		buildVersion += " X:" + goexperiment
+	}
+	addstrdata1(ctxt, "runtime.buildVersion="+buildVersion)
+
 	// TODO(matloob): define these above and then check flag values here
 	if ctxt.Arch.Family == sys.AMD64 && objabi.GOOS == "plan9" {
 		flag.BoolVar(&flag8, "8", false, "use 64-bit addresses in symbol table")
diff --git a/src/internal/goexperiment/flags.go b/src/internal/goexperiment/flags.go
index 1c513d5a70..4803fabe28 100644
--- a/src/internal/goexperiment/flags.go
+++ b/src/internal/goexperiment/flags.go
@@ -26,6 +26,9 @@
 // In the toolchain, the set of experiments enabled for the current
 // build should be accessed via objabi.Experiment.
 //
+// The set of experiments is included in the output of runtime.Version()
+// and "go version <binary>" if it differs from the default experiments.
+//
 // For the set of experiments supported by the current toolchain, see
 // go doc internal/experiment.Flags.
 package goexperiment
diff --git a/src/runtime/extern.go b/src/runtime/extern.go
index b73d68428f..48e1e6603b 100644
--- a/src/runtime/extern.go
+++ b/src/runtime/extern.go
@@ -240,11 +240,21 @@ func GOROOT() string {
 	return defaultGOROOT
 }
 
+// buildVersion is the Go tree's version string at build time.
+//
+// If any GOEXPERIMENTs are set to non-default values, it will include
+// "X:<GOEXPERIMENT>".
+//
+// This is set by the linker.
+//
+// This is accessed by "go version <binary>".
+var buildVersion string
+
 // Version returns the Go tree's version string.
 // It is either the commit hash and date at the time of the build or,
 // when possible, a release tag like "go1.3".
 func Version() string {
-	return sys.TheVersion
+	return buildVersion
 }
 
 // GOOS is the running program's operating system target:
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 35a3f9ca19..d545a143a0 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -12,8 +12,6 @@ import (
 	"unsafe"
 )
 
-var buildVersion = sys.TheVersion
-
 // set using cmd/go/internal/modload.ModInfoProg
 var modinfo string
 
-- 
GitLab


From 8752454ece0c4516769e1260a14763cf9fe86770 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Tue, 6 Apr 2021 16:31:40 -0400
Subject: [PATCH 1429/2400] cmd/internal/objabi: clarify initialization of
 Experiments

Currently objabi.Experiments is set via side-effect from an init
function, which makes their initialization process somewhat unclear
(indeed, I've messed this up before) and opens the possibility of
accessing them from another init function before it's initialized.

Originally, this init function set several variables, but at this
point it sets only objabi.Experiments, so switch to just using a
variable initializer to make the initialization process clear.

Change-Id: Id0d2ac76ae463824bbf37a9305e8643a275f1365
Reviewed-on: https://go-review.googlesource.com/c/go/+/307821
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/internal/objabi/exp.go | 41 +++++++++++++++++-----------------
 1 file changed, 21 insertions(+), 20 deletions(-)

diff --git a/src/cmd/internal/objabi/exp.go b/src/cmd/internal/objabi/exp.go
index eaa8620807..48201ae5ea 100644
--- a/src/cmd/internal/objabi/exp.go
+++ b/src/cmd/internal/objabi/exp.go
@@ -18,7 +18,7 @@ import (
 //
 // (This is not necessarily the set of experiments the compiler itself
 // was built with.)
-var Experiment goexperiment.Flags
+var Experiment goexperiment.Flags = parseExperiments()
 
 // FramePointerEnabled enables the use of platform conventions for
 // saving frame pointers.
@@ -29,9 +29,9 @@ var Experiment goexperiment.Flags
 // Note: must agree with runtime.framepointer_enabled.
 var FramePointerEnabled = GOARCH == "amd64" || GOARCH == "arm64"
 
-func init() {
-	// Start with the baseline configuration.
-	Experiment = goexperiment.BaselineFlags
+func parseExperiments() goexperiment.Flags {
+	// Start with the statically enabled set of experiments.
+	flags := goexperiment.BaselineFlags
 
 	// Pick up any changes to the baseline configuration from the
 	// GOEXPERIMENT environment. This can be set at make.bash time
@@ -41,7 +41,7 @@ func init() {
 	if env != "" {
 		// Create a map of known experiment names.
 		names := make(map[string]reflect.Value)
-		rv := reflect.ValueOf(&Experiment).Elem()
+		rv := reflect.ValueOf(&flags).Elem()
 		rt := rv.Type()
 		for i := 0; i < rt.NumField(); i++ {
 			field := rv.Field(i)
@@ -56,7 +56,7 @@ func init() {
 			if f == "none" {
 				// GOEXPERIMENT=none restores the baseline configuration.
 				// (This is useful for overriding make.bash-time settings.)
-				Experiment = goexperiment.BaselineFlags
+				flags = goexperiment.BaselineFlags
 				continue
 			}
 			val := true
@@ -74,29 +74,30 @@ func init() {
 
 	// regabi is only supported on amd64.
 	if GOARCH != "amd64" {
-		Experiment.Regabi = false
-		Experiment.RegabiWrappers = false
-		Experiment.RegabiG = false
-		Experiment.RegabiReflect = false
-		Experiment.RegabiDefer = false
-		Experiment.RegabiArgs = false
+		flags.Regabi = false
+		flags.RegabiWrappers = false
+		flags.RegabiG = false
+		flags.RegabiReflect = false
+		flags.RegabiDefer = false
+		flags.RegabiArgs = false
 	}
 	// Setting regabi sets working sub-experiments.
-	if Experiment.Regabi {
-		Experiment.RegabiWrappers = true
-		Experiment.RegabiG = true
-		Experiment.RegabiReflect = true
-		Experiment.RegabiDefer = true
+	if flags.Regabi {
+		flags.RegabiWrappers = true
+		flags.RegabiG = true
+		flags.RegabiReflect = true
+		flags.RegabiDefer = true
 		// Not ready yet:
-		//Experiment.RegabiArgs = true
+		//flags.RegabiArgs = true
 	}
 	// Check regabi dependencies.
-	if Experiment.RegabiG && !Experiment.RegabiWrappers {
+	if flags.RegabiG && !flags.RegabiWrappers {
 		panic("GOEXPERIMENT regabig requires regabiwrappers")
 	}
-	if Experiment.RegabiArgs && !(Experiment.RegabiWrappers && Experiment.RegabiG && Experiment.RegabiReflect && Experiment.RegabiDefer) {
+	if flags.RegabiArgs && !(flags.RegabiWrappers && flags.RegabiG && flags.RegabiReflect && flags.RegabiDefer) {
 		panic("GOEXPERIMENT regabiargs requires regabiwrappers,regabig,regabireflect,regabidefer")
 	}
+	return flags
 }
 
 // expList returns the list of lower-cased experiment names for
-- 
GitLab


From 2123dfba651e3522ed039d1b38fde91ededf47a3 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 8 Apr 2021 05:48:34 +0000
Subject: [PATCH 1430/2400] Revert "cmd/compile/internal/noder: limit the
 number of goroutine"

This reverts commit c274a7c03be7b69d54d3307b954f6a0eb298c860.

Reason for revert: this can cause a compiler deadlock, and there's
no demonstrable benefit to making the change.

Change-Id: I42325ddea68d37db16fd0061c5baaee112b755b7
Reviewed-on: https://go-review.googlesource.com/c/go/+/308369
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/noder/noder.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 2c021cc570..4c7c9fc322 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -46,8 +46,8 @@ func LoadPackage(filenames []string) {
 		noders[i] = &p
 
 		filename := filename
-		sem <- struct{}{}
 		go func() {
+			sem <- struct{}{}
 			defer func() { <-sem }()
 			defer close(p.err)
 			fbase := syntax.NewFileBase(filename)
-- 
GitLab


From a7e16abb22f1b249d2691b32a5d20206282898f2 Mon Sep 17 00:00:00 2001
From: ianwoolf <btw515wolf2@gmail.com>
Date: Wed, 7 Apr 2021 20:16:58 +0800
Subject: [PATCH 1431/2400] runtime: replace os.MkdirTemp with T.TempDir

Updates #45402

Change-Id: I3aa82fc2486b4de49b45388bbab24f5ffe558f91
Reviewed-on: https://go-review.googlesource.com/c/go/+/307989
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/runtime/crash_unix_test.go       |  6 +--
 src/runtime/race/output_test.go      | 12 +-----
 src/runtime/race/testdata/io_test.go |  2 +-
 src/runtime/runtime-gdb_test.go      | 48 ++++++------------------
 src/runtime/runtime-lldb_test.go     |  8 +---
 src/runtime/signal_windows_test.go   | 13 +------
 src/runtime/syscall_windows_test.go  | 55 ++++++----------------------
 7 files changed, 31 insertions(+), 113 deletions(-)

diff --git a/src/runtime/crash_unix_test.go b/src/runtime/crash_unix_test.go
index 341c35ca56..b5cc910ad1 100644
--- a/src/runtime/crash_unix_test.go
+++ b/src/runtime/crash_unix_test.go
@@ -85,11 +85,7 @@ func TestCrashDumpsAllThreads(t *testing.T) {
 
 	t.Parallel()
 
-	dir, err := os.MkdirTemp("", "go-build")
-	if err != nil {
-		t.Fatalf("failed to create temp directory: %v", err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	if err := os.WriteFile(filepath.Join(dir, "main.go"), []byte(crashDumpsAllThreadsSource), 0666); err != nil {
 		t.Fatalf("failed to create Go file: %v", err)
diff --git a/src/runtime/race/output_test.go b/src/runtime/race/output_test.go
index 2a2197ae26..99052071d0 100644
--- a/src/runtime/race/output_test.go
+++ b/src/runtime/race/output_test.go
@@ -20,11 +20,7 @@ import (
 )
 
 func TestOutput(t *testing.T) {
-	pkgdir, err := os.MkdirTemp("", "go-build-race-output")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(pkgdir)
+	pkgdir := t.TempDir()
 	out, err := exec.Command(testenv.GoToolPath(t), "install", "-race", "-pkgdir="+pkgdir, "testing").CombinedOutput()
 	if err != nil {
 		t.Fatalf("go install -race: %v\n%s", err, out)
@@ -35,11 +31,7 @@ func TestOutput(t *testing.T) {
 			t.Logf("test %v runs only on %v, skipping: ", test.name, test.goos)
 			continue
 		}
-		dir, err := os.MkdirTemp("", "go-build")
-		if err != nil {
-			t.Fatalf("failed to create temp directory: %v", err)
-		}
-		defer os.RemoveAll(dir)
+		dir := t.TempDir()
 		source := "main.go"
 		if test.run == "test" {
 			source = "main_test.go"
diff --git a/src/runtime/race/testdata/io_test.go b/src/runtime/race/testdata/io_test.go
index c5055f7837..3303cb0717 100644
--- a/src/runtime/race/testdata/io_test.go
+++ b/src/runtime/race/testdata/io_test.go
@@ -17,7 +17,7 @@ import (
 
 func TestNoRaceIOFile(t *testing.T) {
 	x := 0
-	path, _ := os.MkdirTemp("", "race_test")
+	path := t.TempDir()
 	fname := filepath.Join(path, "data")
 	go func() {
 		x = 42
diff --git a/src/runtime/runtime-gdb_test.go b/src/runtime/runtime-gdb_test.go
index 5df8c3c745..8c76a9123c 100644
--- a/src/runtime/runtime-gdb_test.go
+++ b/src/runtime/runtime-gdb_test.go
@@ -169,11 +169,7 @@ func testGdbPython(t *testing.T, cgo bool) {
 	checkGdbVersion(t)
 	checkGdbPython(t)
 
-	dir, err := os.MkdirTemp("", "go-build")
-	if err != nil {
-		t.Fatalf("failed to create temp directory: %v", err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	var buf bytes.Buffer
 	buf.WriteString("package main\n")
@@ -194,7 +190,7 @@ func testGdbPython(t *testing.T, cgo bool) {
 		}
 	}
 
-	err = os.WriteFile(filepath.Join(dir, "main.go"), src, 0644)
+	err := os.WriteFile(filepath.Join(dir, "main.go"), src, 0644)
 	if err != nil {
 		t.Fatalf("failed to create file: %v", err)
 	}
@@ -403,15 +399,11 @@ func TestGdbBacktrace(t *testing.T) {
 	t.Parallel()
 	checkGdbVersion(t)
 
-	dir, err := os.MkdirTemp("", "go-build")
-	if err != nil {
-		t.Fatalf("failed to create temp directory: %v", err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	// Build the source code.
 	src := filepath.Join(dir, "main.go")
-	err = os.WriteFile(src, []byte(backtraceSource), 0644)
+	err := os.WriteFile(src, []byte(backtraceSource), 0644)
 	if err != nil {
 		t.Fatalf("failed to create file: %v", err)
 	}
@@ -481,15 +473,11 @@ func TestGdbAutotmpTypes(t *testing.T) {
 		t.Skip("TestGdbAutotmpTypes is too slow on aix/ppc64")
 	}
 
-	dir, err := os.MkdirTemp("", "go-build")
-	if err != nil {
-		t.Fatalf("failed to create temp directory: %v", err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	// Build the source code.
 	src := filepath.Join(dir, "main.go")
-	err = os.WriteFile(src, []byte(autotmpTypeSource), 0644)
+	err := os.WriteFile(src, []byte(autotmpTypeSource), 0644)
 	if err != nil {
 		t.Fatalf("failed to create file: %v", err)
 	}
@@ -550,15 +538,11 @@ func TestGdbConst(t *testing.T) {
 	t.Parallel()
 	checkGdbVersion(t)
 
-	dir, err := os.MkdirTemp("", "go-build")
-	if err != nil {
-		t.Fatalf("failed to create temp directory: %v", err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	// Build the source code.
 	src := filepath.Join(dir, "main.go")
-	err = os.WriteFile(src, []byte(constsSource), 0644)
+	err := os.WriteFile(src, []byte(constsSource), 0644)
 	if err != nil {
 		t.Fatalf("failed to create file: %v", err)
 	}
@@ -617,15 +601,11 @@ func TestGdbPanic(t *testing.T) {
 	t.Parallel()
 	checkGdbVersion(t)
 
-	dir, err := os.MkdirTemp("", "go-build")
-	if err != nil {
-		t.Fatalf("failed to create temp directory: %v", err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	// Build the source code.
 	src := filepath.Join(dir, "main.go")
-	err = os.WriteFile(src, []byte(panicSource), 0644)
+	err := os.WriteFile(src, []byte(panicSource), 0644)
 	if err != nil {
 		t.Fatalf("failed to create file: %v", err)
 	}
@@ -695,15 +675,11 @@ func TestGdbInfCallstack(t *testing.T) {
 	t.Parallel()
 	checkGdbVersion(t)
 
-	dir, err := os.MkdirTemp("", "go-build")
-	if err != nil {
-		t.Fatalf("failed to create temp directory: %v", err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	// Build the source code.
 	src := filepath.Join(dir, "main.go")
-	err = os.WriteFile(src, []byte(InfCallstackSource), 0644)
+	err := os.WriteFile(src, []byte(InfCallstackSource), 0644)
 	if err != nil {
 		t.Fatalf("failed to create file: %v", err)
 	}
diff --git a/src/runtime/runtime-lldb_test.go b/src/runtime/runtime-lldb_test.go
index c923b872aa..19a6cc6f8d 100644
--- a/src/runtime/runtime-lldb_test.go
+++ b/src/runtime/runtime-lldb_test.go
@@ -142,14 +142,10 @@ func TestLldbPython(t *testing.T) {
 
 	checkLldbPython(t)
 
-	dir, err := os.MkdirTemp("", "go-build")
-	if err != nil {
-		t.Fatalf("failed to create temp directory: %v", err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	src := filepath.Join(dir, "main.go")
-	err = os.WriteFile(src, []byte(lldbHelloSource), 0644)
+	err := os.WriteFile(src, []byte(lldbHelloSource), 0644)
 	if err != nil {
 		t.Fatalf("failed to create src file: %v", err)
 	}
diff --git a/src/runtime/signal_windows_test.go b/src/runtime/signal_windows_test.go
index 05bc6f8e71..d0f61fb6c2 100644
--- a/src/runtime/signal_windows_test.go
+++ b/src/runtime/signal_windows_test.go
@@ -8,7 +8,6 @@ import (
 	"bytes"
 	"fmt"
 	"internal/testenv"
-	"os"
 	"os/exec"
 	"path/filepath"
 	"runtime"
@@ -29,11 +28,7 @@ func TestVectoredHandlerDontCrashOnLibrary(t *testing.T) {
 	testenv.MustHaveExecPath(t, "gcc")
 	testprog.Lock()
 	defer testprog.Unlock()
-	dir, err := os.MkdirTemp("", "go-build")
-	if err != nil {
-		t.Fatalf("failed to create temp directory: %v", err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	// build go dll
 	dll := filepath.Join(dir, "testwinlib.dll")
@@ -157,11 +152,7 @@ func TestLibraryCtrlHandler(t *testing.T) {
 	testenv.MustHaveExecPath(t, "gcc")
 	testprog.Lock()
 	defer testprog.Unlock()
-	dir, err := os.MkdirTemp("", "go-build")
-	if err != nil {
-		t.Fatalf("failed to create temp directory: %v", err)
-	}
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	// build go dll
 	dll := filepath.Join(dir, "dummy.dll")
diff --git a/src/runtime/syscall_windows_test.go b/src/runtime/syscall_windows_test.go
index 65ecb4fbf2..98e426a3d5 100644
--- a/src/runtime/syscall_windows_test.go
+++ b/src/runtime/syscall_windows_test.go
@@ -543,11 +543,7 @@ func TestStdcallAndCDeclCallbacks(t *testing.T) {
 	if _, err := exec.LookPath("gcc"); err != nil {
 		t.Skip("skipping test: gcc is missing")
 	}
-	tmp, err := os.MkdirTemp("", "TestCDeclCallback")
-	if err != nil {
-		t.Fatal("TempDir failed: ", err)
-	}
-	defer os.RemoveAll(tmp)
+	tmp := t.TempDir()
 
 	oldRegs := runtime.SetIntArgRegs(abi.IntArgRegs)
 	defer runtime.SetIntArgRegs(oldRegs)
@@ -702,14 +698,10 @@ uintptr_t cfunc(callback f, uintptr_t n) {
    return r;
 }
 `
-	tmpdir, err := os.MkdirTemp("", "TestReturnAfterStackGrowInCallback")
-	if err != nil {
-		t.Fatal("TempDir failed: ", err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	srcname := "mydll.c"
-	err = os.WriteFile(filepath.Join(tmpdir, srcname), []byte(src), 0)
+	err := os.WriteFile(filepath.Join(tmpdir, srcname), []byte(src), 0)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -771,14 +763,10 @@ uintptr_t cfunc(uintptr_t a, double b, float c, double d) {
 	return 0;
 }
 `
-	tmpdir, err := os.MkdirTemp("", "TestFloatArgs")
-	if err != nil {
-		t.Fatal("TempDir failed: ", err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	srcname := "mydll.c"
-	err = os.WriteFile(filepath.Join(tmpdir, srcname), []byte(src), 0)
+	err := os.WriteFile(filepath.Join(tmpdir, srcname), []byte(src), 0)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -833,14 +821,10 @@ double cfuncDouble(uintptr_t a, double b, float c, double d) {
 	return 0;
 }
 `
-	tmpdir, err := os.MkdirTemp("", "TestFloatReturn")
-	if err != nil {
-		t.Fatal("TempDir failed: ", err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	srcname := "mydll.c"
-	err = os.WriteFile(filepath.Join(tmpdir, srcname), []byte(src), 0)
+	err := os.WriteFile(filepath.Join(tmpdir, srcname), []byte(src), 0)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1048,16 +1032,7 @@ func TestDLLPreloadMitigation(t *testing.T) {
 		t.Skip("skipping test: gcc is missing")
 	}
 
-	tmpdir, err := os.MkdirTemp("", "TestDLLPreloadMitigation")
-	if err != nil {
-		t.Fatal("TempDir failed: ", err)
-	}
-	defer func() {
-		err := os.RemoveAll(tmpdir)
-		if err != nil {
-			t.Error(err)
-		}
-	}()
+	tmpdir := t.TempDir()
 
 	dir0, err := os.Getwd()
 	if err != nil {
@@ -1135,11 +1110,7 @@ func TestBigStackCallbackSyscall(t *testing.T) {
 		t.Fatal("Abs failed: ", err)
 	}
 
-	tmpdir, err := os.MkdirTemp("", "TestBigStackCallback")
-	if err != nil {
-		t.Fatal("TempDir failed: ", err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	outname := "mydll.dll"
 	cmd := exec.Command("gcc", "-shared", "-s", "-Werror", "-o", outname, srcname)
@@ -1284,14 +1255,10 @@ func BenchmarkOsYield(b *testing.B) {
 }
 
 func BenchmarkRunningGoProgram(b *testing.B) {
-	tmpdir, err := os.MkdirTemp("", "BenchmarkRunningGoProgram")
-	if err != nil {
-		b.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := b.TempDir()
 
 	src := filepath.Join(tmpdir, "main.go")
-	err = os.WriteFile(src, []byte(benchmarkRunningGoProgram), 0666)
+	err := os.WriteFile(src, []byte(benchmarkRunningGoProgram), 0666)
 	if err != nil {
 		b.Fatal(err)
 	}
-- 
GitLab


From 1749f3915e55b473bcc281095f41598357d6b70f Mon Sep 17 00:00:00 2001
From: panchenglong01 <1004907659@qq.com>
Date: Thu, 8 Apr 2021 09:21:05 +0000
Subject: [PATCH 1432/2400] sync: update misleading comment in map.go about
 entry type

As discussed in: https://github.com/golang/go/issues/45429,  about entry
type comments, it is possible for p == nil when m.dirty != nil, so
update the commemt about it.

Fixes #45429

Change-Id: I7ef96ee5b6948df9ac736481d177a59ab66d7d4d
GitHub-Last-Rev: 202c598a0ab98f4634cb56fe2486e8e82f9d991f
GitHub-Pull-Request: golang/go#45443
Reviewed-on: https://go-review.googlesource.com/c/go/+/308292
Reviewed-by: Changkun Ou <euryugasaki@gmail.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Trust: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/sync/map.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/sync/map.go b/src/sync/map.go
index 9ad25353ff..dfb62dd3e8 100644
--- a/src/sync/map.go
+++ b/src/sync/map.go
@@ -73,7 +73,8 @@ var expunged = unsafe.Pointer(new(interface{}))
 type entry struct {
 	// p points to the interface{} value stored for the entry.
 	//
-	// If p == nil, the entry has been deleted and m.dirty == nil.
+	// If p == nil, the entry has been deleted, and either m.dirty == nil or
+	// m.dirty[key] is e.
 	//
 	// If p == expunged, the entry has been deleted, m.dirty != nil, and the entry
 	// is missing from m.dirty.
-- 
GitLab


From 912c4e29d3cdabe11db70ed168ddaa4bcc515772 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Wed, 7 Apr 2021 17:03:46 -0400
Subject: [PATCH 1433/2400] reflect: fix typo in result-in-registers case

t is the type of the function that was called
tv is the type of the result

This fixes the failures for
GOEXPERIMENT=regabi,regabiargs go test go test text/template
GOEXPERIMENT=regabi,regabiargs go test go test html/template

Updates #40724.

Change-Id: Ic9b02d72d18ff48c9de1209987cc39da619c2241
Reviewed-on: https://go-review.googlesource.com/c/go/+/308189
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Austin Clements <austin@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/reflect/value.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/reflect/value.go b/src/reflect/value.go
index 8afb1cc141..9670d4656b 100644
--- a/src/reflect/value.go
+++ b/src/reflect/value.go
@@ -592,7 +592,7 @@ func (v Value) call(op string, in []Value) []Value {
 					print("kind=", steps[0].kind, ", type=", tv.String(), "\n")
 					panic("mismatch between ABI description and types")
 				}
-				ret[i] = Value{tv.common(), regArgs.Ptrs[steps[0].ireg], flag(t.Kind())}
+				ret[i] = Value{tv.common(), regArgs.Ptrs[steps[0].ireg], flag(tv.Kind())}
 				continue
 			}
 
-- 
GitLab


From 1be8be4accf8bc9a625ec96e7655d814c3d5bed1 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Thu, 8 Apr 2021 10:14:25 -0400
Subject: [PATCH 1434/2400] cmd/go: fix
 TestNewReleaseRebuildsStalePackagesInGOPATH

CL 307818 added a package that the runtime depends on, but didn't
update the list of runtime dependencies in this test.

This should fix the longtest builder failures.

Change-Id: I5f3be31b069652e05ac3db9b1ce84dd5dfe0f66f
Reviewed-on: https://go-review.googlesource.com/c/go/+/308469
Trust: Austin Clements <austin@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/go/go_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/cmd/go/go_test.go b/src/cmd/go/go_test.go
index d14b2328bf..5a657bcfca 100644
--- a/src/cmd/go/go_test.go
+++ b/src/cmd/go/go_test.go
@@ -814,6 +814,7 @@ func TestNewReleaseRebuildsStalePackagesInGOPATH(t *testing.T) {
 		"src/internal/abi",
 		"src/internal/bytealg",
 		"src/internal/cpu",
+		"src/internal/goexperiment",
 		"src/math/bits",
 		"src/unsafe",
 		filepath.Join("pkg", runtime.GOOS+"_"+runtime.GOARCH),
-- 
GitLab


From 283b02063b470a0f5df7ba99c9fc801d020763ab Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Wed, 7 Apr 2021 22:21:35 -0400
Subject: [PATCH 1435/2400] cmd/compile: sanitize before/after expansion
 OpSelectN references

In expand_calls, OpSelectN occurs both before and after the rewriting.
Attempting to rewrite a post-expansion OpSelectN is bad.
(The only ones rewritten in place are the ones returning mem;
others are synthesized to replace other selection chains with
register references.)

Updates #40724.
Updates #44816#issuecomment-815258897.

Change-Id: I7b6022cfb47f808d3ce6cc796c067245f36047f3
Reviewed-on: https://go-review.googlesource.com/c/go/+/308309
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/ssa/expand_calls.go  |  75 ++++++----
 .../genCaller42/genCaller42.go                |  71 +++++++++
 .../genChecker42/genChecker42.go              | 135 ++++++++++++++++++
 test/abi/bad_select_crash.dir/genMain.go      |  17 +++
 .../bad_select_crash.dir/genUtils/genUtils.go |  61 ++++++++
 test/abi/bad_select_crash.dir/go.mod          |   2 +
 test/abi/bad_select_crash.go                  |   2 +
 7 files changed, 332 insertions(+), 31 deletions(-)
 create mode 100644 test/abi/bad_select_crash.dir/genCaller42/genCaller42.go
 create mode 100644 test/abi/bad_select_crash.dir/genChecker42/genChecker42.go
 create mode 100644 test/abi/bad_select_crash.dir/genMain.go
 create mode 100644 test/abi/bad_select_crash.dir/genUtils/genUtils.go
 create mode 100644 test/abi/bad_select_crash.dir/go.mod
 create mode 100644 test/abi/bad_select_crash.go

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index 36b6dcab9b..ede713f22a 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -173,24 +173,25 @@ func (c *registerCursor) hasRegs() bool {
 }
 
 type expandState struct {
-	f               *Func
-	abi1            *abi.ABIConfig
-	debug           bool
-	canSSAType      func(*types.Type) bool
-	regSize         int64
-	sp              *Value
-	typs            *Types
-	ptrSize         int64
-	hiOffset        int64
-	lowOffset       int64
-	hiRo            Abi1RO
-	loRo            Abi1RO
-	namedSelects    map[*Value][]namedVal
-	sdom            SparseTree
-	commonSelectors map[selKey]*Value // used to de-dupe selectors
-	commonArgs      map[selKey]*Value // used to de-dupe OpArg/OpArgIntReg/OpArgFloatReg
-	memForCall      map[ID]*Value     // For a call, need to know the unique selector that gets the mem.
-	indentLevel     int               // Indentation for debugging recursion
+	f                  *Func
+	abi1               *abi.ABIConfig
+	debug              bool
+	canSSAType         func(*types.Type) bool
+	regSize            int64
+	sp                 *Value
+	typs               *Types
+	ptrSize            int64
+	hiOffset           int64
+	lowOffset          int64
+	hiRo               Abi1RO
+	loRo               Abi1RO
+	namedSelects       map[*Value][]namedVal
+	sdom               SparseTree
+	commonSelectors    map[selKey]*Value // used to de-dupe selectors
+	commonArgs         map[selKey]*Value // used to de-dupe OpArg/OpArgIntReg/OpArgFloatReg
+	memForCall         map[ID]*Value     // For a call, need to know the unique selector that gets the mem.
+	transformedSelects map[ID]bool       // OpSelectN after rewriting, either created or renumbered.
+	indentLevel        int               // Indentation for debugging recursion
 }
 
 // intPairTypes returns the pair of 32-bit int types needed to encode a 64-bit integer type on a target
@@ -393,10 +394,17 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64,
 		call0 := call
 		aux := call.Aux.(*AuxCall)
 		which := selector.AuxInt
+		if x.transformedSelects[selector.ID] {
+			// This is a minor hack.  Either this select has had its operand adjusted (mem) or
+			// it is some other intermediate node that was rewritten to reference a register (not a generic arg).
+			// This can occur with chains of selection/indexing from single field/element aggregates.
+			leaf.copyOf(selector)
+			break
+		}
 		if which == aux.NResults() { // mem is after the results.
 			// rewrite v as a Copy of call -- the replacement call will produce a mem.
 			if leaf != selector {
-				panic("Unexpected selector of memory")
+				panic(fmt.Errorf("Unexpected selector of memory, selector=%s, call=%s, leaf=%s", selector.LongString(), call.LongString(), leaf.LongString()))
 			}
 			if aux.abiInfo == nil {
 				panic(badVal("aux.abiInfo nil for call", call))
@@ -404,6 +412,7 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64,
 			if existing := x.memForCall[call.ID]; existing == nil {
 				selector.AuxInt = int64(aux.abiInfo.OutRegistersUsed())
 				x.memForCall[call.ID] = selector
+				x.transformedSelects[selector.ID] = true // operand adjusted
 			} else {
 				selector.copyOf(existing)
 			}
@@ -421,6 +430,7 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64,
 					call = mem
 				} else {
 					mem = call.Block.NewValue1I(call.Pos.WithNotStmt(), OpSelectN, types.TypeMem, int64(aux.abiInfo.OutRegistersUsed()), call)
+					x.transformedSelects[mem.ID] = true // select uses post-expansion indexing
 					x.memForCall[call.ID] = mem
 					call = mem
 				}
@@ -436,8 +446,10 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64,
 						leaf.SetArgs1(call0)
 						leaf.Type = leafType
 						leaf.AuxInt = reg
+						x.transformedSelects[leaf.ID] = true // leaf, rewritten to use post-expansion indexing.
 					} else {
 						w := call.Block.NewValue1I(leaf.Pos, OpSelectN, leafType, reg, call0)
+						x.transformedSelects[w.ID] = true // select, using post-expansion indexing.
 						leaf.copyOf(w)
 					}
 				} else {
@@ -1026,18 +1038,19 @@ func expandCalls(f *Func) {
 	// memory output as their input.
 	sp, _ := f.spSb()
 	x := &expandState{
-		f:            f,
-		abi1:         f.ABI1,
-		debug:        f.pass.debug > 0,
-		canSSAType:   f.fe.CanSSA,
-		regSize:      f.Config.RegSize,
-		sp:           sp,
-		typs:         &f.Config.Types,
-		ptrSize:      f.Config.PtrSize,
-		namedSelects: make(map[*Value][]namedVal),
-		sdom:         f.Sdom(),
-		commonArgs:   make(map[selKey]*Value),
-		memForCall:   make(map[ID]*Value),
+		f:                  f,
+		abi1:               f.ABI1,
+		debug:              f.pass.debug > 0,
+		canSSAType:         f.fe.CanSSA,
+		regSize:            f.Config.RegSize,
+		sp:                 sp,
+		typs:               &f.Config.Types,
+		ptrSize:            f.Config.PtrSize,
+		namedSelects:       make(map[*Value][]namedVal),
+		sdom:               f.Sdom(),
+		commonArgs:         make(map[selKey]*Value),
+		memForCall:         make(map[ID]*Value),
+		transformedSelects: make(map[ID]bool),
 	}
 
 	// For 32-bit, need to deal with decomposition of 64-bit integers, which depends on endianness.
diff --git a/test/abi/bad_select_crash.dir/genCaller42/genCaller42.go b/test/abi/bad_select_crash.dir/genCaller42/genCaller42.go
new file mode 100644
index 0000000000..d3fedff7c5
--- /dev/null
+++ b/test/abi/bad_select_crash.dir/genCaller42/genCaller42.go
@@ -0,0 +1,71 @@
+package genCaller42
+
+import "bad_select_crash.dir/genChecker42"
+import "bad_select_crash.dir/genUtils"
+import "reflect"
+
+
+func Caller2() {
+  genUtils.BeginFcn()
+  c0 := genChecker42.StructF2S0{F0: genChecker42.ArrayF2S1E1{genChecker42.New_3(float64(-0.4418990509835844))}}
+  c1 := genChecker42.ArrayF2S2E1{genChecker42.StructF2S1{/* _: "񊶿(z̽|" */F1: "􂊇񊶿"}}
+  c2 := int16(4162)
+  c3 := float32(-7.667096e+37)
+  c4 := int64(3202175648847048679)
+  var p0 genChecker42.ArrayF2S0E0
+  p0 = genChecker42.ArrayF2S0E0{}
+  var p1 uint8
+  p1 = uint8(57)
+  var p2 uint16
+  p2 = uint16(10920)
+  var p3 float64
+  p3 = float64(-1.597256501942112)
+  genUtils.Mode = ""
+  // 5 returns 4 params
+  r0, r1, r2, r3, r4 := genChecker42.Test2(p0, p1, p2, p3)
+  if !genChecker42.EqualStructF2S0(r0, c0) {
+    genUtils.NoteFailure(9, 42, 2, "genChecker42", "return", 0, true, uint64(0))
+  }
+  if r1 != c1 {
+    genUtils.NoteFailure(9, 42, 2, "genChecker42", "return", 1, true, uint64(0))
+  }
+  if r2 != c2 {
+    genUtils.NoteFailure(9, 42, 2, "genChecker42", "return", 2, true, uint64(0))
+  }
+  if r3 != c3 {
+    genUtils.NoteFailure(9, 42, 2, "genChecker42", "return", 3, true, uint64(0))
+  }
+  if r4 != c4 {
+    genUtils.NoteFailure(9, 42, 2, "genChecker42", "return", 4, true, uint64(0))
+  }
+  // same call via reflection
+  genUtils.Mode = "reflect"
+  rc := reflect.ValueOf(genChecker42.Test2)
+  rvslice :=   rc.Call([]reflect.Value{reflect.ValueOf(p0), reflect.ValueOf(p1), reflect.ValueOf(p2), reflect.ValueOf(p3)})
+  rr0i := rvslice[0].Interface()
+  rr0v:= rr0i.( genChecker42.StructF2S0)
+  if !genChecker42.EqualStructF2S0(rr0v, c0) {
+    genUtils.NoteFailure(9, 42, 2, "genChecker42", "return", 0, true, uint64(0))
+  }
+  rr1i := rvslice[1].Interface()
+  rr1v:= rr1i.( genChecker42.ArrayF2S2E1)
+  if rr1v != c1 {
+    genUtils.NoteFailure(9, 42, 2, "genChecker42", "return", 1, true, uint64(0))
+  }
+  rr2i := rvslice[2].Interface()
+  rr2v:= rr2i.( int16)
+  if rr2v != c2 {
+    genUtils.NoteFailure(9, 42, 2, "genChecker42", "return", 2, true, uint64(0))
+  }
+  rr3i := rvslice[3].Interface()
+  rr3v:= rr3i.( float32)
+  if rr3v != c3 {
+    genUtils.NoteFailure(9, 42, 2, "genChecker42", "return", 3, true, uint64(0))
+  }
+  rr4i := rvslice[4].Interface()
+  rr4v:= rr4i.( int64)
+  if rr4v != c4 {
+    genUtils.NoteFailure(9, 42, 2, "genChecker42", "return", 4, true, uint64(0))
+  }
+  genUtils.EndFcn()
+}
diff --git a/test/abi/bad_select_crash.dir/genChecker42/genChecker42.go b/test/abi/bad_select_crash.dir/genChecker42/genChecker42.go
new file mode 100644
index 0000000000..90adf8e27a
--- /dev/null
+++ b/test/abi/bad_select_crash.dir/genChecker42/genChecker42.go
@@ -0,0 +1,135 @@
+package genChecker42
+
+import "bad_select_crash.dir/genUtils"
+
+type StructF0S0 struct {
+}
+
+type ArrayF0S0E2 [2]int16
+
+type ArrayF0S1E1 [1]StructF0S0
+
+type StructF1S0 struct {
+F0 StructF1S1
+_ ArrayF1S0E4
+}
+
+type StructF1S1 struct {
+}
+
+type StructF1S2 struct {
+F0 uint32
+F1 uint8
+F2 string
+F3 string
+F4 ArrayF1S1E1
+}
+
+type StructF1S3 struct {
+F0 float64
+}
+
+type StructF1S4 struct {
+_ int32
+F1 float32
+}
+
+type StructF1S5 struct {
+F0 uint16
+}
+
+type StructF1S6 struct {
+F0 uint8
+F1 uint32
+}
+
+type ArrayF1S0E4 [4]float64
+
+type ArrayF1S1E1 [1]StructF1S3
+
+type ArrayF1S2E2 [2]StructF1S4
+
+type ArrayF1S3E2 [2]StructF1S5
+
+type ArrayF1S4E4 [4]ArrayF1S5E3
+
+type ArrayF1S5E3 [3]string
+
+type ArrayF1S6E1 [1]float64
+
+type StructF2S0 struct {
+F0 ArrayF2S1E1
+}
+
+// equal func for StructF2S0
+//go:noinline
+func EqualStructF2S0(left StructF2S0, right StructF2S0) bool {
+  return   EqualArrayF2S1E1(left.F0, right.F0)
+}
+
+type StructF2S1 struct {
+_ string
+F1 string
+}
+
+type ArrayF2S0E0 [0]int8
+
+type ArrayF2S1E1 [1]*float64
+
+// equal func for ArrayF2S1E1
+//go:noinline
+func EqualArrayF2S1E1(left ArrayF2S1E1, right ArrayF2S1E1) bool {
+  return *left[0] == *right[0]
+}
+
+type ArrayF2S2E1 [1]StructF2S1
+
+// 5 returns 4 params
+//go:registerparams
+//go:noinline
+func Test2(p0 ArrayF2S0E0, p1 uint8, _ uint16, p3 float64) (r0 StructF2S0, r1 ArrayF2S2E1, r2 int16, r3 float32, r4 int64) {
+  // consume some stack space, so as to trigger morestack
+  var pad [16]uint64
+  pad[genUtils.FailCount&0x1]++
+  rc0 := StructF2S0{F0: ArrayF2S1E1{New_3(float64(-0.4418990509835844))}}
+  rc1 := ArrayF2S2E1{StructF2S1{/* _: "񊶿(z̽|" */F1: "􂊇񊶿"}}
+  rc2 := int16(4162)
+  rc3 := float32(-7.667096e+37)
+  rc4 := int64(3202175648847048679)
+  p1f0c := uint8(57)
+  if p1 != p1f0c {
+    genUtils.NoteFailureElem(9, 42, 2, "genChecker42", "parm", 1, 0, false, pad[0])
+    return
+  }
+  _ = uint16(10920)
+  p3f0c := float64(-1.597256501942112)
+  if p3 != p3f0c {
+    genUtils.NoteFailureElem(9, 42, 2, "genChecker42", "parm", 3, 0, false, pad[0])
+    return
+  }
+  defer func(p0 ArrayF2S0E0, p1 uint8) {
+  // check parm passed
+  // check parm passed
+  if p1 != p1f0c {
+    genUtils.NoteFailureElem(9, 42, 2, "genChecker42", "parm", 1, 0, false, pad[0])
+    return
+  }
+  // check parm captured
+  if p3 != p3f0c {
+    genUtils.NoteFailureElem(9, 42, 2, "genChecker42", "parm", 3, 0, false, pad[0])
+    return
+  }
+  } (p0, p1)
+
+  return rc0, rc1, rc2, rc3, rc4
+  // 0 addr-taken params, 0 addr-taken returns
+}
+
+
+//go:noinline
+func New_3(i float64)  *float64 {
+  x := new( float64)
+  *x = i
+  return x
+}
+
diff --git a/test/abi/bad_select_crash.dir/genMain.go b/test/abi/bad_select_crash.dir/genMain.go
new file mode 100644
index 0000000000..2075e9b126
--- /dev/null
+++ b/test/abi/bad_select_crash.dir/genMain.go
@@ -0,0 +1,17 @@
+package main
+
+import (
+	"bad_select_crash.dir/genCaller42"
+	"bad_select_crash.dir/genUtils"
+	"fmt"
+	"os"
+)
+
+func main() {
+	// Only print if there is a problem
+	genCaller42.Caller2()
+	if genUtils.FailCount != 0 {
+		fmt.Fprintf(os.Stderr, "FAILURES: %d\n", genUtils.FailCount)
+		os.Exit(2)
+	}
+}
diff --git a/test/abi/bad_select_crash.dir/genUtils/genUtils.go b/test/abi/bad_select_crash.dir/genUtils/genUtils.go
new file mode 100644
index 0000000000..90ed8d827e
--- /dev/null
+++ b/test/abi/bad_select_crash.dir/genUtils/genUtils.go
@@ -0,0 +1,61 @@
+package genUtils
+
+
+import "fmt"
+import "os"
+
+var ParamFailCount int
+
+var ReturnFailCount int
+
+var FailCount int
+
+var Mode string
+
+type UtilsType int
+
+//go:noinline
+func NoteFailure(cm int, pidx int, fidx int, pkg string, pref string, parmNo int, isret bool,_ uint64) {
+  if isret {
+    if ParamFailCount != 0 {
+      return
+    }
+    ReturnFailCount++
+  } else {
+    ParamFailCount++
+  }
+  fmt.Fprintf(os.Stderr, "Error: fail %s |%d|%d|%d| =%s.Test%d= %s %d\n", Mode, cm, pidx, fidx, pkg, fidx, pref, parmNo)
+
+  if (ParamFailCount + FailCount + ReturnFailCount > 9999) {
+    os.Exit(1)
+  }
+}
+
+//go:noinline
+func NoteFailureElem(cm int, pidx int, fidx int, pkg string, pref string, parmNo int, elem int, isret bool, _ uint64) {
+
+  if isret {
+    if ParamFailCount != 0 {
+      return
+    }
+    ReturnFailCount++
+  } else {
+    ParamFailCount++
+  }
+  fmt.Fprintf(os.Stderr, "Error: fail %s |%d|%d|%d| =%s.Test%d= %s %d elem %d\n", Mode, cm, pidx, fidx, pkg, fidx, pref, parmNo, elem)
+
+  if (ParamFailCount + FailCount + ReturnFailCount > 9999) {
+    os.Exit(1)
+  }
+}
+
+func BeginFcn() {
+  ParamFailCount = 0
+  ReturnFailCount = 0
+}
+
+func EndFcn() {
+  FailCount += ParamFailCount
+  FailCount += ReturnFailCount
+}
+
diff --git a/test/abi/bad_select_crash.dir/go.mod b/test/abi/bad_select_crash.dir/go.mod
new file mode 100644
index 0000000000..1831ff9f32
--- /dev/null
+++ b/test/abi/bad_select_crash.dir/go.mod
@@ -0,0 +1,2 @@
+module bad_select_crash.dir
+go 1.14
diff --git a/test/abi/bad_select_crash.go b/test/abi/bad_select_crash.go
new file mode 100644
index 0000000000..69b48e9a4c
--- /dev/null
+++ b/test/abi/bad_select_crash.go
@@ -0,0 +1,2 @@
+// runindir -goexperiment regabi,regabiargs
+
-- 
GitLab


From 31d2556273795ae10709d3bc157ec5d3f0e070a2 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Wed, 7 Apr 2021 19:58:01 +0000
Subject: [PATCH 1436/2400] runtime: set up read-only dummy TLS space for needm
 on Windows

On Windows, TLS is uninitialized for C threads calling into Go code.
In this path, before calling into user Go code, we call into needm which
runs without an m, but whose purpose is to pick one up. While in Go
code, we may occasionally restore the G register from TLS for a number
of reasons. Rather than try to flag all these cases, given that needm
(and its callees) are already somewhat special, just set up a dummy TLS
space for it that's read-only. If it ever actually tries to write to
this space (it shouldn't), it will fail loudly. Otherwise, code that
restores the G register will simply load a zero value, but that's OK
since needm is careful never to require the G at any point, because it
doesn't yet have a valid G. Furthermore, by the time needm returns, it
will have set up TLS properly for a Windows C thread, so there's no need
to do anything extra afterwards.

For #40724.

Change-Id: I34e8095059817e4ee663505e89cda8785b634b98
Reviewed-on: https://go-review.googlesource.com/c/go/+/307872
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/asm_amd64.s | 17 +++++++++++++++++
 src/runtime/runtime2.go | 17 ++++++++++++-----
 2 files changed, 29 insertions(+), 5 deletions(-)

diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index c0bfcb7ade..cc31e5c657 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -802,6 +802,14 @@ nosave:
 	MOVL	AX, ret+16(FP)
 	RET
 
+#ifdef GOOS_windows
+// Dummy TLS that's used on Windows so that we don't crash trying
+// to restore the G register in needm. needm and its callees are
+// very careful never to actually use the G, the TLS just can't be
+// unset since we're in Go code.
+GLOBL zeroTLS<>(SB),RODATA,$const_tlsSize
+#endif
+
 // func cgocallback(fn, frame unsafe.Pointer, ctxt uintptr)
 // See cgocall.go for more details.
 TEXT ·cgocallback(SB),NOSPLIT,$24-24
@@ -825,6 +833,15 @@ TEXT ·cgocallback(SB),NOSPLIT,$24-24
 	MOVQ	BX, savedm-8(SP)	// saved copy of oldm
 	JMP	havem
 needm:
+#ifdef GOOS_windows
+	// Set up a dummy TLS value. needm is careful not to use it,
+	// but it needs to be there to prevent autogenerated code from
+	// crashing when it loads from it.
+	// We don't need to clear it or anything later because needm
+	// will set up TLS properly.
+	MOVQ	$zeroTLS<>(SB), DI
+	CALL	runtime·settls(SB)
+#endif
 	// On some platforms (Windows) we cannot call needm through
 	// an ABI wrapper because there's no TLS set up, and the ABI
 	// wrapper will try to restore the G register (R14) from TLS.
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index e5f948ec86..402d49ac82 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -482,17 +482,24 @@ type g struct {
 	gcAssistBytes int64
 }
 
+const (
+	// tlsSlots is the number of pointer-sized slots reserved for TLS on some platforms,
+	// like Windows.
+	tlsSlots = 6
+	tlsSize  = tlsSlots * sys.PtrSize
+)
+
 type m struct {
 	g0      *g     // goroutine with scheduling stack
 	morebuf gobuf  // gobuf arg to morestack
 	divmod  uint32 // div/mod denominator for arm - known to liblink
 
 	// Fields not known to debuggers.
-	procid        uint64       // for debuggers, but offset not hard-coded
-	gsignal       *g           // signal-handling g
-	goSigStack    gsignalStack // Go-allocated signal handling stack
-	sigmask       sigset       // storage for saved signal mask
-	tls           [6]uintptr   // thread-local storage (for x86 extern register)
+	procid        uint64            // for debuggers, but offset not hard-coded
+	gsignal       *g                // signal-handling g
+	goSigStack    gsignalStack      // Go-allocated signal handling stack
+	sigmask       sigset            // storage for saved signal mask
+	tls           [tlsSlots]uintptr // thread-local storage (for x86 extern register)
 	mstartfn      func()
 	curg          *g       // current running goroutine
 	caughtsig     guintptr // goroutine running during fatal signal
-- 
GitLab


From 0e09e4143e3d55ac8cbcbf53f1da98b817fc5a58 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Wed, 7 Apr 2021 16:17:08 -0400
Subject: [PATCH 1437/2400] cmd/go: assume Go 1.16 semantics uniformly for
 unversioned modules

However, still only trigger -mod=vendor automatically (and only apply
the more stringent Go 1.14 vendor consistency checks) if the 'go'
version is explicit. This provides maximal compatibility with Go 1.16
and earlier: Go 1.11 modules will continue not to fail vendor
consistency checks, but scripts that assume semantics up to Go 1.16
for unversioned modules will continue to work unmodified.

Fixes #44976
For #36460

Change-Id: Idb05ca320023f57249c71fc8079218e8991d1ff9
Reviewed-on: https://go-review.googlesource.com/c/go/+/308509
Trust: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modload/init.go           | 32 ++++------
 src/cmd/go/internal/modload/modfile.go        |  2 +-
 .../script/mod_go_version_missing.txt         | 60 +++++++++----------
 src/cmd/go/testdata/script/mod_retention.txt  |  6 +-
 4 files changed, 45 insertions(+), 55 deletions(-)

diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index d385af0ba3..fdfb83646e 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -431,30 +431,22 @@ func LoadModFile(ctx context.Context) *Requirements {
 		// automatically since Go 1.12, so this module either dates to Go 1.11 or
 		// has been erroneously hand-edited.
 		//
+		// The semantics of the go.mod file are more-or-less the same from Go 1.11
+		// through Go 1.16, changing at 1.17 for lazy loading. So even though a
+		// go.mod file without a 'go' directive is theoretically a Go 1.11 file,
+		// scripts may assume that it ends up as a Go 1.16 module. We can't go
+		// higher than that, because we don't know which semantics the user intends.
+		//
+		// (Note that 'go mod init' always adds the latest version, so scripts that
+		// use 'go mod init' will result in current-version modules instead of Go
+		// 1.16 modules.)
+		//
 		// If we are able to modify the go.mod file, we will add a 'go' directive
 		// to at least make the situation explicit going forward.
 		if cfg.BuildMod == "mod" {
-			// TODO(#44976): If we implicitly upgrade to the latest Go version once
-			// lazy loading is implemented, we could accidentally prune out
-			// dependencies from what was formerly a Go 1.11 module, resulting in
-			// downgrades (if only lower requirements on that module remain) and/or
-			// upgrades (if no requirement remains and we end up re-resolving to
-			// latest).
-			//
-			// We should probably instead load the dependencies using Go 1.11
-			// semantics to ensure that we capture everything that is relevant, or
-			// perhaps error out and let the user tell us which version they intend.
-			//
-			// If we are running 'go mod tidy' in particular, we will have enough
-			// information to upgrade the 'go' version after loading is complete.
-			addGoStmt(latestGoVersion())
+			addGoStmt("1.16")
 		} else {
-			// Reproducibility requires that if we change the semantics of a module,
-			// we write some explicit change to its go.mod file. We cannot write to
-			// the go.mod file (because we are in readonly or vendor mode), so we must
-			// not change its semantics either. The go.mod file looks as if it were
-			// created by Go 1.11, so assume Go 1.11 semantics.
-			rawGoVersion.Store(Target, "1.11")
+			rawGoVersion.Store(Target, "1.16")
 		}
 	}
 
diff --git a/src/cmd/go/internal/modload/modfile.go b/src/cmd/go/internal/modload/modfile.go
index 6351871844..3e4772f217 100644
--- a/src/cmd/go/internal/modload/modfile.go
+++ b/src/cmd/go/internal/modload/modfile.go
@@ -291,7 +291,7 @@ func indexModFile(data []byte, modFile *modfile.File, needsFix bool) *modFileInd
 // (Otherwise — as in Go 1.16+ — the "all" pattern includes only the packages
 // transitively *imported by* the packages and tests in the main module.)
 func (i *modFileIndex) allPatternClosesOverTests() bool {
-	if i != nil && semver.Compare(i.goVersionV, narrowAllVersionV) < 0 {
+	if i != nil && i.goVersionV != "" && semver.Compare(i.goVersionV, narrowAllVersionV) < 0 {
 		// The module explicitly predates the change in "all" for lazy loading, so
 		// continue to use the older interpretation. (If i == nil, we not in any
 		// module at all and should use the latest semantics.)
diff --git a/src/cmd/go/testdata/script/mod_go_version_missing.txt b/src/cmd/go/testdata/script/mod_go_version_missing.txt
index 43ddea7954..ea5050ca3d 100644
--- a/src/cmd/go/testdata/script/mod_go_version_missing.txt
+++ b/src/cmd/go/testdata/script/mod_go_version_missing.txt
@@ -1,50 +1,48 @@
 cp go.mod go.mod.orig
 
-# With -mod=readonly, we should not update the go version in use.
-#
-# We started adding the go version automatically in Go 1.12, so a module without
-# one encountered in the wild (such as in the module cache) should assume Go
-# 1.11 semantics.
+# For modules whose go.mod file does not include a 'go' directive,
+# we assume the language and dependency semantics of Go 1.16,
+# but do not trigger “automatic vendoring” mode (-mod=vendor),
+# which was added in Go 1.14 and was not triggered
+# under the same conditions in Go 1.16 (which would instead
+# default to -mod=readonly when no 'go' directive is present).
 
-# For Go 1.11 modules, 'all' should include dependencies of tests.
-# (They are pruned out as of Go 1.16.)
+# For Go 1.16 modules, 'all' should prune out dependencies of tests,
+# even if the 'go' directive is missing.
 
 go list -mod=readonly all
 stdout '^example.com/dep$'
-stdout '^example.com/testdep$'
+! stdout '^example.com/testdep$'
 cp stdout list-1.txt
 cmp go.mod go.mod.orig
 
-# For Go 1.11 modules, automatic vendoring should not take effect.
-# (That behavior was added in Go 1.14.)
+# We should only default to -mod=vendor if the 'go' directive is explicit in the
+# go.mod file. Otherwise, we don't actually know whether the module was written
+# against Go 1.11 or 1.16. We would have to update the go.mod file to clarify,
+# and as of Go 1.16 we don't update the go.mod file by default.
+#
+# If we set -mod=vendor explicitly, we shouldn't apply the Go 1.14
+# consistency check, because — again — we don't know whether we're in a 1.11
+# module or a bad-script-edited 1.16 module.
 
-go list all  # should default to -mod=readonly, not -mod=vendor.
-cmp stdout list-1.txt
+! go list -mod=vendor all
+! stderr '^go: inconsistent vendoring'
+stderr 'cannot find package "\." in:\n\t.*[/\\]vendor[/\\]example.com[/\\]badedit$'
 
 # When we set -mod=mod, the go version should be updated immediately,
-# narrowing the "all" pattern reported by that command.
+# to Go 1.16 (not the current version).
 
 go list -mod=mod all
 ! stdout '^example.com/testdep$'
-cp stdout list-2.txt
-cmpenv go.mod go.mod.want
-
-go list -mod=mod all
-cmp stdout list-2.txt
+cmp stdout list-1.txt
+cmp go.mod go.mod.want
 
-# The updated version should have been written back to go.mod, so
-# automatic vendoring should come into effect (and fail).
+# The updated version should have been written back to go.mod, so now the 'go'
+# directive is explicit. -mod=vendor should trigger by default, and the stronger
+# Go 1.14 consistency check should apply.
 ! go list all
 stderr '^go: inconsistent vendoring'
-
-cp go.mod.orig go.mod
-
-# In readonly or vendor mode (not -mod=mod), the inferred Go version is 1.11.
-# For Go 1.11 modules, Go 1.13 features should not be enabled.
-
-! go build -mod=readonly .
-stderr '^# example\.com/m\n\.[/\\]m\.go:5:11: underscores in numeric literals requires go1\.13 or later \(-lang was set to go1\.11; check go\.mod\)$'
-cmp go.mod go.mod.orig
+! stderr badedit
 
 
 -- go.mod --
@@ -59,7 +57,7 @@ replace (
 -- go.mod.want --
 module example.com/m
 
-go $goversion
+go 1.16
 
 require example.com/dep v0.1.0
 
@@ -69,7 +67,7 @@ replace (
 )
 -- vendor/example.com/dep/dep.go --
 package dep
-import _ "example.com/bananas"
+import _ "example.com/badedit"
 -- vendor/modules.txt --
 HAHAHA this is broken.
 
diff --git a/src/cmd/go/testdata/script/mod_retention.txt b/src/cmd/go/testdata/script/mod_retention.txt
index a4441c4b3c..711d28b10f 100644
--- a/src/cmd/go/testdata/script/mod_retention.txt
+++ b/src/cmd/go/testdata/script/mod_retention.txt
@@ -64,7 +64,7 @@ cmp go.mod go.mod.tidy
 # However, that should not remove other redundant requirements.
 cp go.mod.nogo go.mod
 go list -mod=mod all
-cmpenv go.mod go.mod.currentgo
+cmpenv go.mod go.mod.addedgo
 
 
 -- go.mod.tidy --
@@ -133,10 +133,10 @@ require (
 	rsc.io/sampler v1.3.0 // indirect
 	rsc.io/testonly v1.0.0 // indirect
 )
--- go.mod.currentgo --
+-- go.mod.addedgo --
 module m
 
-go $goversion
+go 1.16
 
 require (
 	rsc.io/quote v1.5.2
-- 
GitLab


From 23e1d36a87f55b7e37d969ba3de3a8e1b8147f49 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Thu, 1 Apr 2021 11:01:19 -0400
Subject: [PATCH 1438/2400] cmd/go: in 'go list -m', ignore "not found" errors
 loading updates

"Not found" and "no matching version" errors usually indicate the user
is offline or the proxy doesn't have a version of go.mod that could
provide retractions. 'go list -m -u' should still succeed.

We should still report unclassified errors though. Previously, we
reported most errors loading retractions but did not report errors
loading updates. This change makes those operations more consistent.

Fixes #45305

Change-Id: I2f23a566c9481bc7ff229a177f39d78f6a8aae77
Reviewed-on: https://go-review.googlesource.com/c/go/+/306572
Trust: Jay Conrod <jayconrod@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modload/build.go          | 44 +++++++++++++--
 .../go/testdata/script/mod_list_retract.txt   | 12 ++--
 .../script/mod_list_update_nolatest.txt       | 55 +++++++++++++++++++
 .../testdata/script/mod_retract_replace.txt   |  6 +-
 4 files changed, 103 insertions(+), 14 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/mod_list_update_nolatest.txt

diff --git a/src/cmd/go/internal/modload/build.go b/src/cmd/go/internal/modload/build.go
index 804bd5ecfd..b8825408d7 100644
--- a/src/cmd/go/internal/modload/build.go
+++ b/src/cmd/go/internal/modload/build.go
@@ -11,6 +11,7 @@ import (
 	"errors"
 	"fmt"
 	"internal/goroot"
+	"io/fs"
 	"os"
 	"path/filepath"
 	"strings"
@@ -108,7 +109,26 @@ func addUpdate(ctx context.Context, m *modinfo.ModulePublic) {
 		return
 	}
 
-	if info, err := Query(ctx, m.Path, "upgrade", m.Version, CheckAllowed); err == nil && semver.Compare(info.Version, m.Version) > 0 {
+	info, err := Query(ctx, m.Path, "upgrade", m.Version, CheckAllowed)
+	var noVersionErr *NoMatchingVersionError
+	if errors.Is(err, fs.ErrNotExist) || errors.As(err, &noVersionErr) {
+		// Ignore "not found" and "no matching version" errors. This usually means
+		// the user is offline or the proxy doesn't have a matching version.
+		//
+		// We should report other errors though. An attacker that controls the
+		// network shouldn't be able to hide versions by interfering with
+		// the HTTPS connection. An attacker that controls the proxy may still
+		// hide versions, since the "list" and "latest" endpoints are not
+		// authenticated.
+		return
+	} else if err != nil {
+		if m.Error == nil {
+			m.Error = &modinfo.ModuleError{Err: err.Error()}
+		}
+		return
+	}
+
+	if semver.Compare(info.Version, m.Version) > 0 {
 		m.Update = &modinfo.ModulePublic{
 			Path:    m.Path,
 			Version: info.Version,
@@ -140,14 +160,26 @@ func addRetraction(ctx context.Context, m *modinfo.ModulePublic) {
 	}
 
 	err := CheckRetractions(ctx, module.Version{Path: m.Path, Version: m.Version})
-	var rerr *ModuleRetractedError
-	if errors.As(err, &rerr) {
-		if len(rerr.Rationale) == 0 {
+	var noVersionErr *NoMatchingVersionError
+	var retractErr *ModuleRetractedError
+	if err == nil || errors.Is(err, fs.ErrNotExist) || errors.As(err, &noVersionErr) {
+		// Ignore "not found" and "no matching version" errors. This usually means
+		// the user is offline or the proxy doesn't have a go.mod file that could
+		// contain retractions.
+		//
+		// We should report other errors though. An attacker that controls the
+		// network shouldn't be able to hide versions by interfering with
+		// the HTTPS connection. An attacker that controls the proxy may still
+		// hide versions, since the "list" and "latest" endpoints are not
+		// authenticated.
+		return
+	} else if errors.As(err, &retractErr) {
+		if len(retractErr.Rationale) == 0 {
 			m.Retracted = []string{"retracted by module author"}
 		} else {
-			m.Retracted = rerr.Rationale
+			m.Retracted = retractErr.Rationale
 		}
-	} else if err != nil && m.Error == nil {
+	} else if m.Error == nil {
 		m.Error = &modinfo.ModuleError{Err: err.Error()}
 	}
 }
diff --git a/src/cmd/go/testdata/script/mod_list_retract.txt b/src/cmd/go/testdata/script/mod_list_retract.txt
index 3ba53bc596..4b13348515 100644
--- a/src/cmd/go/testdata/script/mod_list_retract.txt
+++ b/src/cmd/go/testdata/script/mod_list_retract.txt
@@ -29,12 +29,12 @@ go list -m -retracted -f '{{with .Retracted}}retracted{{end}}' example.com/retra
 go list -m -f '{{with .Retracted}}retracted{{end}}' example.com/retract@v1.0.0-unused
 ! stdout .
 
-# 'go list -m -retracted mod@version' shows an error if the go.mod that should
-# contain the retractions is not available.
-! go list -m -retracted example.com/retract/missingmod@v1.0.0
-stderr '^go list -m: loading module retractions for example.com/retract/missingmod@v1.0.0: .*404 Not Found$'
-go list -e -m -retracted -f '{{.Error.Err}}' example.com/retract/missingmod@v1.0.0
-stdout '^loading module retractions for example.com/retract/missingmod@v1.0.0: .*404 Not Found$'
+# 'go list -m -retracted mod@version' does not show an error if the module
+# that would contain the retraction is unavailable. See #45305.
+go list -m -retracted -f '{{.Path}} {{.Version}} {{.Error}}' example.com/retract/missingmod@v1.0.0
+stdout '^example.com/retract/missingmod v1.0.0 <nil>$'
+exists $GOPATH/pkg/mod/cache/download/example.com/retract/missingmod/@v/v1.9.0.info
+! exists $GOPATH/pkg/mod/cache/download/example.com/retract/missingmod/@v/v1.9.0.mod
 
 # 'go list -m -retracted mod@version' shows retractions.
 go list -m -retracted example.com/retract@v1.0.0-unused
diff --git a/src/cmd/go/testdata/script/mod_list_update_nolatest.txt b/src/cmd/go/testdata/script/mod_list_update_nolatest.txt
new file mode 100644
index 0000000000..6d00f8ce1e
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_list_update_nolatest.txt
@@ -0,0 +1,55 @@
+# Check that if a proxy does not have a version of a module that could be
+# an upgrade, 'go list -m -u' still succeeds.
+# We use a local file proxy, since our test proxy doesn't have the behavior
+# we want to test, and we don't want it to be too clever.
+# Verifies #45305, where proxy.golang.org serves an empty /@v/list (200)
+# but has no /@latest (410) because the go.mod at the tip of the default
+# branch has a different major version suffix.
+env testproxy=$GOPROXY
+env GOPROXY=file://$WORK/proxy
+env GOSUMDB=off
+
+# If the proxy does not return a list of versions (404/410)
+# or a latest version (404/410), we should see no error.
+go list -m example.com/noversion
+stdout '^example.com/noversion v0.0.0$'
+go list -m -u example.com/noversion
+stdout '^example.com/noversion v0.0.0$'
+
+# If the proxy returns an empty list of versions (200, not 404/410)
+# but does not have a latest version (404/410), we should see no error.
+go list -m example.com/nolatest
+stdout '^example.com/nolatest v0.0.0$'
+go list -m -u example.com/nolatest
+stdout '^example.com/nolatest v0.0.0$'
+
+# If proxy returns an invalid response, we should see an error.
+env GOPROXY=$testproxy/invalid
+! go list -m -u example.com/nolatest
+stderr '^go list -m: loading module retractions for example.com/nolatest@v0.0.0: invalid response from proxy "[^"]*": invalid character ''i'' looking for beginning of value$'
+
+-- go.mod --
+module m
+
+go 1.17
+
+require (
+	example.com/nolatest v0.0.0
+	example.com/noversion v0.0.0
+)
+-- go.sum --
+example.com/nolatest v0.0.0/go.mod h1:HnLrCt6SJga5tCtJ7IzG9dOOCniY3G5C0VT7jfMdS0M=
+example.com/noversion v0.0.0/go.mod h1:2RUfWiCYsygSXPM2Igxx0FD3Kq33OnVdxm34eDDhXbQ=
+-- $WORK/proxy/example.com/nolatest/@v/list --
+-- $WORK/proxy/example.com/nolatest/@v/v0.0.0.info --
+{"Version":"v0.0.0"}
+-- $WORK/proxy/example.com/nolatest/@v/v0.0.0.mod --
+module example.com/nolatest
+
+go 1.17
+-- $WORK/proxy/example.com/noversion/@v/v0.0.0.info --
+{"Version":"v0.0.0"}
+-- $WORK/proxy/example.com/noversion/@v/v0.0.0.mod --
+module example.com/noversion
+
+go 1.17
diff --git a/src/cmd/go/testdata/script/mod_retract_replace.txt b/src/cmd/go/testdata/script/mod_retract_replace.txt
index 770aea41a5..9cd714739a 100644
--- a/src/cmd/go/testdata/script/mod_retract_replace.txt
+++ b/src/cmd/go/testdata/script/mod_retract_replace.txt
@@ -5,8 +5,10 @@
 go get -d
 
 # The latest version, v1.9.0, is not available on the proxy.
-! go list -m -retracted example.com/retract/missingmod
-stderr '^go list -m: loading module retractions for example.com/retract/missingmod@v1.0.0: .*404 Not Found$'
+go list -m -retracted example.com/retract/missingmod
+stdout '^example.com/retract/missingmod v1.0.0$'
+exists $GOPATH/pkg/mod/cache/download/example.com/retract/missingmod/@v/v1.9.0.info
+! exists $GOPATH/pkg/mod/cache/download/example.com/retract/missingmod/@v/v1.9.0.mod
 
 # If we replace that version, we should see retractions.
 go mod edit -replace=example.com/retract/missingmod@v1.9.0=./missingmod-v1.9.0
-- 
GitLab


From d474b6c824249dcdd6cddfb6bf43366e092df022 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Thu, 8 Apr 2021 13:09:21 -0400
Subject: [PATCH 1439/2400] test/abi: clean up test to fix builders

go.mod file was not tidy, made builders sad.

Updates #40724.

Change-Id: I28371a1093108f9ec473eb20bb4d185e35dee67d
Reviewed-on: https://go-review.googlesource.com/c/go/+/308590
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 .../genCaller42/genCaller42.go                |  71 -----
 .../genChecker42/genChecker42.go              | 135 ---------
 test/abi/bad_select_crash.dir/genMain.go      |  17 --
 .../bad_select_crash.dir/genUtils/genUtils.go |  61 ----
 test/abi/bad_select_crash.dir/go.mod          |   2 -
 test/abi/bad_select_crash.go                  | 272 +++++++++++++++++-
 6 files changed, 271 insertions(+), 287 deletions(-)
 delete mode 100644 test/abi/bad_select_crash.dir/genCaller42/genCaller42.go
 delete mode 100644 test/abi/bad_select_crash.dir/genChecker42/genChecker42.go
 delete mode 100644 test/abi/bad_select_crash.dir/genMain.go
 delete mode 100644 test/abi/bad_select_crash.dir/genUtils/genUtils.go
 delete mode 100644 test/abi/bad_select_crash.dir/go.mod

diff --git a/test/abi/bad_select_crash.dir/genCaller42/genCaller42.go b/test/abi/bad_select_crash.dir/genCaller42/genCaller42.go
deleted file mode 100644
index d3fedff7c5..0000000000
--- a/test/abi/bad_select_crash.dir/genCaller42/genCaller42.go
+++ /dev/null
@@ -1,71 +0,0 @@
-package genCaller42
-
-import "bad_select_crash.dir/genChecker42"
-import "bad_select_crash.dir/genUtils"
-import "reflect"
-
-
-func Caller2() {
-  genUtils.BeginFcn()
-  c0 := genChecker42.StructF2S0{F0: genChecker42.ArrayF2S1E1{genChecker42.New_3(float64(-0.4418990509835844))}}
-  c1 := genChecker42.ArrayF2S2E1{genChecker42.StructF2S1{/* _: "񊶿(z̽|" */F1: "􂊇񊶿"}}
-  c2 := int16(4162)
-  c3 := float32(-7.667096e+37)
-  c4 := int64(3202175648847048679)
-  var p0 genChecker42.ArrayF2S0E0
-  p0 = genChecker42.ArrayF2S0E0{}
-  var p1 uint8
-  p1 = uint8(57)
-  var p2 uint16
-  p2 = uint16(10920)
-  var p3 float64
-  p3 = float64(-1.597256501942112)
-  genUtils.Mode = ""
-  // 5 returns 4 params
-  r0, r1, r2, r3, r4 := genChecker42.Test2(p0, p1, p2, p3)
-  if !genChecker42.EqualStructF2S0(r0, c0) {
-    genUtils.NoteFailure(9, 42, 2, "genChecker42", "return", 0, true, uint64(0))
-  }
-  if r1 != c1 {
-    genUtils.NoteFailure(9, 42, 2, "genChecker42", "return", 1, true, uint64(0))
-  }
-  if r2 != c2 {
-    genUtils.NoteFailure(9, 42, 2, "genChecker42", "return", 2, true, uint64(0))
-  }
-  if r3 != c3 {
-    genUtils.NoteFailure(9, 42, 2, "genChecker42", "return", 3, true, uint64(0))
-  }
-  if r4 != c4 {
-    genUtils.NoteFailure(9, 42, 2, "genChecker42", "return", 4, true, uint64(0))
-  }
-  // same call via reflection
-  genUtils.Mode = "reflect"
-  rc := reflect.ValueOf(genChecker42.Test2)
-  rvslice :=   rc.Call([]reflect.Value{reflect.ValueOf(p0), reflect.ValueOf(p1), reflect.ValueOf(p2), reflect.ValueOf(p3)})
-  rr0i := rvslice[0].Interface()
-  rr0v:= rr0i.( genChecker42.StructF2S0)
-  if !genChecker42.EqualStructF2S0(rr0v, c0) {
-    genUtils.NoteFailure(9, 42, 2, "genChecker42", "return", 0, true, uint64(0))
-  }
-  rr1i := rvslice[1].Interface()
-  rr1v:= rr1i.( genChecker42.ArrayF2S2E1)
-  if rr1v != c1 {
-    genUtils.NoteFailure(9, 42, 2, "genChecker42", "return", 1, true, uint64(0))
-  }
-  rr2i := rvslice[2].Interface()
-  rr2v:= rr2i.( int16)
-  if rr2v != c2 {
-    genUtils.NoteFailure(9, 42, 2, "genChecker42", "return", 2, true, uint64(0))
-  }
-  rr3i := rvslice[3].Interface()
-  rr3v:= rr3i.( float32)
-  if rr3v != c3 {
-    genUtils.NoteFailure(9, 42, 2, "genChecker42", "return", 3, true, uint64(0))
-  }
-  rr4i := rvslice[4].Interface()
-  rr4v:= rr4i.( int64)
-  if rr4v != c4 {
-    genUtils.NoteFailure(9, 42, 2, "genChecker42", "return", 4, true, uint64(0))
-  }
-  genUtils.EndFcn()
-}
diff --git a/test/abi/bad_select_crash.dir/genChecker42/genChecker42.go b/test/abi/bad_select_crash.dir/genChecker42/genChecker42.go
deleted file mode 100644
index 90adf8e27a..0000000000
--- a/test/abi/bad_select_crash.dir/genChecker42/genChecker42.go
+++ /dev/null
@@ -1,135 +0,0 @@
-package genChecker42
-
-import "bad_select_crash.dir/genUtils"
-
-type StructF0S0 struct {
-}
-
-type ArrayF0S0E2 [2]int16
-
-type ArrayF0S1E1 [1]StructF0S0
-
-type StructF1S0 struct {
-F0 StructF1S1
-_ ArrayF1S0E4
-}
-
-type StructF1S1 struct {
-}
-
-type StructF1S2 struct {
-F0 uint32
-F1 uint8
-F2 string
-F3 string
-F4 ArrayF1S1E1
-}
-
-type StructF1S3 struct {
-F0 float64
-}
-
-type StructF1S4 struct {
-_ int32
-F1 float32
-}
-
-type StructF1S5 struct {
-F0 uint16
-}
-
-type StructF1S6 struct {
-F0 uint8
-F1 uint32
-}
-
-type ArrayF1S0E4 [4]float64
-
-type ArrayF1S1E1 [1]StructF1S3
-
-type ArrayF1S2E2 [2]StructF1S4
-
-type ArrayF1S3E2 [2]StructF1S5
-
-type ArrayF1S4E4 [4]ArrayF1S5E3
-
-type ArrayF1S5E3 [3]string
-
-type ArrayF1S6E1 [1]float64
-
-type StructF2S0 struct {
-F0 ArrayF2S1E1
-}
-
-// equal func for StructF2S0
-//go:noinline
-func EqualStructF2S0(left StructF2S0, right StructF2S0) bool {
-  return   EqualArrayF2S1E1(left.F0, right.F0)
-}
-
-type StructF2S1 struct {
-_ string
-F1 string
-}
-
-type ArrayF2S0E0 [0]int8
-
-type ArrayF2S1E1 [1]*float64
-
-// equal func for ArrayF2S1E1
-//go:noinline
-func EqualArrayF2S1E1(left ArrayF2S1E1, right ArrayF2S1E1) bool {
-  return *left[0] == *right[0]
-}
-
-type ArrayF2S2E1 [1]StructF2S1
-
-// 5 returns 4 params
-//go:registerparams
-//go:noinline
-func Test2(p0 ArrayF2S0E0, p1 uint8, _ uint16, p3 float64) (r0 StructF2S0, r1 ArrayF2S2E1, r2 int16, r3 float32, r4 int64) {
-  // consume some stack space, so as to trigger morestack
-  var pad [16]uint64
-  pad[genUtils.FailCount&0x1]++
-  rc0 := StructF2S0{F0: ArrayF2S1E1{New_3(float64(-0.4418990509835844))}}
-  rc1 := ArrayF2S2E1{StructF2S1{/* _: "񊶿(z̽|" */F1: "􂊇񊶿"}}
-  rc2 := int16(4162)
-  rc3 := float32(-7.667096e+37)
-  rc4 := int64(3202175648847048679)
-  p1f0c := uint8(57)
-  if p1 != p1f0c {
-    genUtils.NoteFailureElem(9, 42, 2, "genChecker42", "parm", 1, 0, false, pad[0])
-    return
-  }
-  _ = uint16(10920)
-  p3f0c := float64(-1.597256501942112)
-  if p3 != p3f0c {
-    genUtils.NoteFailureElem(9, 42, 2, "genChecker42", "parm", 3, 0, false, pad[0])
-    return
-  }
-  defer func(p0 ArrayF2S0E0, p1 uint8) {
-  // check parm passed
-  // check parm passed
-  if p1 != p1f0c {
-    genUtils.NoteFailureElem(9, 42, 2, "genChecker42", "parm", 1, 0, false, pad[0])
-    return
-  }
-  // check parm captured
-  if p3 != p3f0c {
-    genUtils.NoteFailureElem(9, 42, 2, "genChecker42", "parm", 3, 0, false, pad[0])
-    return
-  }
-  } (p0, p1)
-
-  return rc0, rc1, rc2, rc3, rc4
-  // 0 addr-taken params, 0 addr-taken returns
-}
-
-
-//go:noinline
-func New_3(i float64)  *float64 {
-  x := new( float64)
-  *x = i
-  return x
-}
-
diff --git a/test/abi/bad_select_crash.dir/genMain.go b/test/abi/bad_select_crash.dir/genMain.go
deleted file mode 100644
index 2075e9b126..0000000000
--- a/test/abi/bad_select_crash.dir/genMain.go
+++ /dev/null
@@ -1,17 +0,0 @@
-package main
-
-import (
-	"bad_select_crash.dir/genCaller42"
-	"bad_select_crash.dir/genUtils"
-	"fmt"
-	"os"
-)
-
-func main() {
-	// Only print if there is a problem
-	genCaller42.Caller2()
-	if genUtils.FailCount != 0 {
-		fmt.Fprintf(os.Stderr, "FAILURES: %d\n", genUtils.FailCount)
-		os.Exit(2)
-	}
-}
diff --git a/test/abi/bad_select_crash.dir/genUtils/genUtils.go b/test/abi/bad_select_crash.dir/genUtils/genUtils.go
deleted file mode 100644
index 90ed8d827e..0000000000
--- a/test/abi/bad_select_crash.dir/genUtils/genUtils.go
+++ /dev/null
@@ -1,61 +0,0 @@
-package genUtils
-
-
-import "fmt"
-import "os"
-
-var ParamFailCount int
-
-var ReturnFailCount int
-
-var FailCount int
-
-var Mode string
-
-type UtilsType int
-
-//go:noinline
-func NoteFailure(cm int, pidx int, fidx int, pkg string, pref string, parmNo int, isret bool,_ uint64) {
-  if isret {
-    if ParamFailCount != 0 {
-      return
-    }
-    ReturnFailCount++
-  } else {
-    ParamFailCount++
-  }
-  fmt.Fprintf(os.Stderr, "Error: fail %s |%d|%d|%d| =%s.Test%d= %s %d\n", Mode, cm, pidx, fidx, pkg, fidx, pref, parmNo)
-
-  if (ParamFailCount + FailCount + ReturnFailCount > 9999) {
-    os.Exit(1)
-  }
-}
-
-//go:noinline
-func NoteFailureElem(cm int, pidx int, fidx int, pkg string, pref string, parmNo int, elem int, isret bool, _ uint64) {
-
-  if isret {
-    if ParamFailCount != 0 {
-      return
-    }
-    ReturnFailCount++
-  } else {
-    ParamFailCount++
-  }
-  fmt.Fprintf(os.Stderr, "Error: fail %s |%d|%d|%d| =%s.Test%d= %s %d elem %d\n", Mode, cm, pidx, fidx, pkg, fidx, pref, parmNo, elem)
-
-  if (ParamFailCount + FailCount + ReturnFailCount > 9999) {
-    os.Exit(1)
-  }
-}
-
-func BeginFcn() {
-  ParamFailCount = 0
-  ReturnFailCount = 0
-}
-
-func EndFcn() {
-  FailCount += ParamFailCount
-  FailCount += ReturnFailCount
-}
-
diff --git a/test/abi/bad_select_crash.dir/go.mod b/test/abi/bad_select_crash.dir/go.mod
deleted file mode 100644
index 1831ff9f32..0000000000
--- a/test/abi/bad_select_crash.dir/go.mod
+++ /dev/null
@@ -1,2 +0,0 @@
-module bad_select_crash.dir
-go 1.14
diff --git a/test/abi/bad_select_crash.go b/test/abi/bad_select_crash.go
index 69b48e9a4c..58ca463cb8 100644
--- a/test/abi/bad_select_crash.go
+++ b/test/abi/bad_select_crash.go
@@ -1,2 +1,272 @@
-// runindir -goexperiment regabi,regabiargs
+// build -goexperiment regabi,regabiargs
 
+// Copyright 2021 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 (
+	"fmt"
+	"os"
+	"reflect"
+)
+
+func main() {
+	// Only print if there is a problem
+	Caller2()
+	if FailCount != 0 {
+		fmt.Fprintf(os.Stderr, "FAILURES: %d\n", FailCount)
+		os.Exit(2)
+	}
+}
+
+var ParamFailCount int
+
+var ReturnFailCount int
+
+var FailCount int
+
+var Mode string
+
+type UtilsType int
+
+//go:noinline
+func NoteFailure(cm int, pidx int, fidx int, pkg string, pref string, parmNo int, isret bool, _ uint64) {
+	if isret {
+		if ParamFailCount != 0 {
+			return
+		}
+		ReturnFailCount++
+	} else {
+		ParamFailCount++
+	}
+	fmt.Fprintf(os.Stderr, "Error: fail %s |%d|%d|%d| =%s.Test%d= %s %d\n", Mode, cm, pidx, fidx, pkg, fidx, pref, parmNo)
+
+	if ParamFailCount+FailCount+ReturnFailCount > 9999 {
+		os.Exit(1)
+	}
+}
+
+//go:noinline
+func NoteFailureElem(cm int, pidx int, fidx int, pkg string, pref string, parmNo int, elem int, isret bool, _ uint64) {
+
+	if isret {
+		if ParamFailCount != 0 {
+			return
+		}
+		ReturnFailCount++
+	} else {
+		ParamFailCount++
+	}
+	fmt.Fprintf(os.Stderr, "Error: fail %s |%d|%d|%d| =%s.Test%d= %s %d elem %d\n", Mode, cm, pidx, fidx, pkg, fidx, pref, parmNo, elem)
+
+	if ParamFailCount+FailCount+ReturnFailCount > 9999 {
+		os.Exit(1)
+	}
+}
+
+func BeginFcn() {
+	ParamFailCount = 0
+	ReturnFailCount = 0
+}
+
+func EndFcn() {
+	FailCount += ParamFailCount
+	FailCount += ReturnFailCount
+}
+
+func Caller2() {
+	BeginFcn()
+	c0 := StructF2S0{F0: ArrayF2S1E1{New_3(float64(-0.4418990509835844))}}
+	c1 := ArrayF2S2E1{StructF2S1{ /* _: "񊶿(z̽|" */ F1: "􂊇񊶿"}}
+	c2 := int16(4162)
+	c3 := float32(-7.667096e+37)
+	c4 := int64(3202175648847048679)
+	var p0 ArrayF2S0E0
+	p0 = ArrayF2S0E0{}
+	var p1 uint8
+	p1 = uint8(57)
+	var p2 uint16
+	p2 = uint16(10920)
+	var p3 float64
+	p3 = float64(-1.597256501942112)
+	Mode = ""
+	// 5 returns 4 params
+	r0, r1, r2, r3, r4 := Test2(p0, p1, p2, p3)
+	if !EqualStructF2S0(r0, c0) {
+		NoteFailure(9, 42, 2, "genChecker42", "return", 0, true, uint64(0))
+	}
+	if r1 != c1 {
+		NoteFailure(9, 42, 2, "genChecker42", "return", 1, true, uint64(0))
+	}
+	if r2 != c2 {
+		NoteFailure(9, 42, 2, "genChecker42", "return", 2, true, uint64(0))
+	}
+	if r3 != c3 {
+		NoteFailure(9, 42, 2, "genChecker42", "return", 3, true, uint64(0))
+	}
+	if r4 != c4 {
+		NoteFailure(9, 42, 2, "genChecker42", "return", 4, true, uint64(0))
+	}
+	// same call via reflection
+	Mode = "reflect"
+	rc := reflect.ValueOf(Test2)
+	rvslice := rc.Call([]reflect.Value{reflect.ValueOf(p0), reflect.ValueOf(p1), reflect.ValueOf(p2), reflect.ValueOf(p3)})
+	rr0i := rvslice[0].Interface()
+	rr0v := rr0i.(StructF2S0)
+	if !EqualStructF2S0(rr0v, c0) {
+		NoteFailure(9, 42, 2, "genChecker42", "return", 0, true, uint64(0))
+	}
+	rr1i := rvslice[1].Interface()
+	rr1v := rr1i.(ArrayF2S2E1)
+	if rr1v != c1 {
+		NoteFailure(9, 42, 2, "genChecker42", "return", 1, true, uint64(0))
+	}
+	rr2i := rvslice[2].Interface()
+	rr2v := rr2i.(int16)
+	if rr2v != c2 {
+		NoteFailure(9, 42, 2, "genChecker42", "return", 2, true, uint64(0))
+	}
+	rr3i := rvslice[3].Interface()
+	rr3v := rr3i.(float32)
+	if rr3v != c3 {
+		NoteFailure(9, 42, 2, "genChecker42", "return", 3, true, uint64(0))
+	}
+	rr4i := rvslice[4].Interface()
+	rr4v := rr4i.(int64)
+	if rr4v != c4 {
+		NoteFailure(9, 42, 2, "genChecker42", "return", 4, true, uint64(0))
+	}
+	EndFcn()
+}
+
+type StructF0S0 struct {
+}
+
+type ArrayF0S0E2 [2]int16
+
+type ArrayF0S1E1 [1]StructF0S0
+
+type StructF1S0 struct {
+	F0 StructF1S1
+	_  ArrayF1S0E4
+}
+
+type StructF1S1 struct {
+}
+
+type StructF1S2 struct {
+	F0 uint32
+	F1 uint8
+	F2 string
+	F3 string
+	F4 ArrayF1S1E1
+}
+
+type StructF1S3 struct {
+	F0 float64
+}
+
+type StructF1S4 struct {
+	_  int32
+	F1 float32
+}
+
+type StructF1S5 struct {
+	F0 uint16
+}
+
+type StructF1S6 struct {
+	F0 uint8
+	F1 uint32
+}
+
+type ArrayF1S0E4 [4]float64
+
+type ArrayF1S1E1 [1]StructF1S3
+
+type ArrayF1S2E2 [2]StructF1S4
+
+type ArrayF1S3E2 [2]StructF1S5
+
+type ArrayF1S4E4 [4]ArrayF1S5E3
+
+type ArrayF1S5E3 [3]string
+
+type ArrayF1S6E1 [1]float64
+
+type StructF2S0 struct {
+	F0 ArrayF2S1E1
+}
+
+// equal func for StructF2S0
+//go:noinline
+func EqualStructF2S0(left StructF2S0, right StructF2S0) bool {
+	return EqualArrayF2S1E1(left.F0, right.F0)
+}
+
+type StructF2S1 struct {
+	_  string
+	F1 string
+}
+
+type ArrayF2S0E0 [0]int8
+
+type ArrayF2S1E1 [1]*float64
+
+// equal func for ArrayF2S1E1
+//go:noinline
+func EqualArrayF2S1E1(left ArrayF2S1E1, right ArrayF2S1E1) bool {
+	return *left[0] == *right[0]
+}
+
+type ArrayF2S2E1 [1]StructF2S1
+
+// 5 returns 4 params
+//go:registerparams
+//go:noinline
+func Test2(p0 ArrayF2S0E0, p1 uint8, _ uint16, p3 float64) (r0 StructF2S0, r1 ArrayF2S2E1, r2 int16, r3 float32, r4 int64) {
+	// consume some stack space, so as to trigger morestack
+	var pad [16]uint64
+	pad[FailCount&0x1]++
+	rc0 := StructF2S0{F0: ArrayF2S1E1{New_3(float64(-0.4418990509835844))}}
+	rc1 := ArrayF2S2E1{StructF2S1{ /* _: "񊶿(z̽|" */ F1: "􂊇񊶿"}}
+	rc2 := int16(4162)
+	rc3 := float32(-7.667096e+37)
+	rc4 := int64(3202175648847048679)
+	p1f0c := uint8(57)
+	if p1 != p1f0c {
+		NoteFailureElem(9, 42, 2, "genChecker42", "parm", 1, 0, false, pad[0])
+		return
+	}
+	_ = uint16(10920)
+	p3f0c := float64(-1.597256501942112)
+	if p3 != p3f0c {
+		NoteFailureElem(9, 42, 2, "genChecker42", "parm", 3, 0, false, pad[0])
+		return
+	}
+	defer func(p0 ArrayF2S0E0, p1 uint8) {
+		// check parm passed
+		// check parm passed
+		if p1 != p1f0c {
+			NoteFailureElem(9, 42, 2, "genChecker42", "parm", 1, 0, false, pad[0])
+			return
+		}
+		// check parm captured
+		if p3 != p3f0c {
+			NoteFailureElem(9, 42, 2, "genChecker42", "parm", 3, 0, false, pad[0])
+			return
+		}
+	}(p0, p1)
+
+	return rc0, rc1, rc2, rc3, rc4
+	// 0 addr-taken params, 0 addr-taken returns
+}
+
+//go:noinline
+func New_3(i float64) *float64 {
+	x := new(float64)
+	*x = i
+	return x
+}
-- 
GitLab


From ca8540affd43580772589263951fd01e04f6ad07 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Wed, 7 Apr 2021 12:56:43 -0400
Subject: [PATCH 1440/2400] cmd/compile: fix buglet in walk convert phase
 relating to convT64

The function runtime.convT64 accepts a single uint64 argument, but the
compiler's rules in the walk phase for determining whether is it ok to
pass a value of type T to a call to runtime.convT64 were slightly off.
In particular the test was allowing a type T with size less than eight
bytes but with more than one internal element (e.g. a struct). This
patch tightens up the rules somewhat to prevent this from happening.

Updates #40724.

Change-Id: I3b909267534db59429b0aa73a3d73333e1bd6432
Reviewed-on: https://go-review.googlesource.com/c/go/+/308069
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/walk/convert.go | 11 ++++++++++-
 test/abi/convT64_criteria.go             | 25 ++++++++++++++++++++++++
 test/abi/convT64_criteria.out            |  1 +
 3 files changed, 36 insertions(+), 1 deletion(-)
 create mode 100644 test/abi/convT64_criteria.go
 create mode 100644 test/abi/convT64_criteria.out

diff --git a/src/cmd/compile/internal/walk/convert.go b/src/cmd/compile/internal/walk/convert.go
index 168f42ee48..3d30aefd5f 100644
--- a/src/cmd/compile/internal/walk/convert.go
+++ b/src/cmd/compile/internal/walk/convert.go
@@ -14,6 +14,7 @@ import (
 	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
+	"cmd/internal/objabi"
 	"cmd/internal/sys"
 )
 
@@ -316,6 +317,14 @@ func convFuncName(from, to *types.Type) (fnname string, needsaddr bool) {
 		return false
 	}
 
+	// Helper to determine whether a given type (when passed to a
+	// function) will fit into a single integer register, assuming
+	// that the reg abi is in effect. This is somewhat ad-hoc, there
+	// may be a cleaner way to do this.
+	fitsInSingleIntReg := func(t *types.Type) bool {
+		return from.IsScalar() || types.IsDirectIface(from)
+	}
+
 	tkind := to.Tie()
 	switch from.Tie() {
 	case 'I':
@@ -332,7 +341,7 @@ func convFuncName(from, to *types.Type) (fnname string, needsaddr bool) {
 			return "convT32", false
 		case from.Size() == 8 && isFloatLike(from):
 			return "convT64F", false
-		case from.Size() == 8 && from.Align == types.Types[types.TUINT64].Align && !from.HasPointers():
+		case from.Size() == 8 && from.Align == types.Types[types.TUINT64].Align && !from.HasPointers() && (!objabi.Experiment.RegabiArgs || fitsInSingleIntReg(from)):
 			return "convT64", false
 		}
 		if sc := from.SoleComponent(); sc != nil {
diff --git a/test/abi/convT64_criteria.go b/test/abi/convT64_criteria.go
new file mode 100644
index 0000000000..165bdfabde
--- /dev/null
+++ b/test/abi/convT64_criteria.go
@@ -0,0 +1,25 @@
+// run
+
+// Copyright 2021 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 (
+	"fmt"
+)
+
+type MyStruct struct {
+	F0 [0]float64
+	F1 byte
+	F2 int16
+	_  struct {
+		F0 uint32
+	}
+}
+
+func main() {
+	p0 := MyStruct{F0: [0]float64{}, F1: byte(27), F2: int16(9887)}
+	fmt.Println(p0)
+}
diff --git a/test/abi/convT64_criteria.out b/test/abi/convT64_criteria.out
new file mode 100644
index 0000000000..8ac8571456
--- /dev/null
+++ b/test/abi/convT64_criteria.out
@@ -0,0 +1 @@
+{[] 27 9887 {0}}
-- 
GitLab


From 96a67450887314cedbd9e8634ad92b76a0443779 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 8 Apr 2021 12:13:58 -0400
Subject: [PATCH 1441/2400] runtime: use register ABI in panicIndex/Slice
 functions

runtime.panicIndex*/panicSlice* functions move the arguments in
the right place then tail calls goPanicIndex*/Slice* using
internal ABI. (It uses internal ABI to avoid wrappers, because
the callee needs to get the caller's PC, to know whether it panics
in the runtime.) This CL makes it to use the register ABI if it
is enabled.

Change-Id: Id2ebb51b4bfb3e9aa7cb66d0a9aee63fccee5ecd
Reviewed-on: https://go-review.googlesource.com/c/go/+/308649
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/asm_amd64.s | 70 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 70 insertions(+)

diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index cc31e5c657..77f4939b30 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -1874,68 +1874,138 @@ TEXT runtime·debugCallPanicked(SB),NOSPLIT,$16-16
 // The tail call makes these stubs disappear in backtraces.
 // Defined as ABIInternal since they do not use the stack-based Go ABI.
 TEXT runtime·panicIndex<ABIInternal>(SB),NOSPLIT,$0-16
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	CX, BX
+#else
 	MOVQ	AX, x+0(FP)
 	MOVQ	CX, y+8(FP)
+#endif
 	JMP	runtime·goPanicIndex<ABIInternal>(SB)
 TEXT runtime·panicIndexU<ABIInternal>(SB),NOSPLIT,$0-16
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	CX, BX
+#else
 	MOVQ	AX, x+0(FP)
 	MOVQ	CX, y+8(FP)
+#endif
 	JMP	runtime·goPanicIndexU<ABIInternal>(SB)
 TEXT runtime·panicSliceAlen<ABIInternal>(SB),NOSPLIT,$0-16
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	CX, AX
+	MOVQ	DX, BX
+#else
 	MOVQ	CX, x+0(FP)
 	MOVQ	DX, y+8(FP)
+#endif
 	JMP	runtime·goPanicSliceAlen<ABIInternal>(SB)
 TEXT runtime·panicSliceAlenU<ABIInternal>(SB),NOSPLIT,$0-16
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	CX, AX
+	MOVQ	DX, BX
+#else
 	MOVQ	CX, x+0(FP)
 	MOVQ	DX, y+8(FP)
+#endif
 	JMP	runtime·goPanicSliceAlenU<ABIInternal>(SB)
 TEXT runtime·panicSliceAcap<ABIInternal>(SB),NOSPLIT,$0-16
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	CX, AX
+	MOVQ	DX, BX
+#else
 	MOVQ	CX, x+0(FP)
 	MOVQ	DX, y+8(FP)
+#endif
 	JMP	runtime·goPanicSliceAcap<ABIInternal>(SB)
 TEXT runtime·panicSliceAcapU<ABIInternal>(SB),NOSPLIT,$0-16
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	CX, AX
+	MOVQ	DX, BX
+#else
 	MOVQ	CX, x+0(FP)
 	MOVQ	DX, y+8(FP)
+#endif
 	JMP	runtime·goPanicSliceAcapU<ABIInternal>(SB)
 TEXT runtime·panicSliceB<ABIInternal>(SB),NOSPLIT,$0-16
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	CX, BX
+#else
 	MOVQ	AX, x+0(FP)
 	MOVQ	CX, y+8(FP)
+#endif
 	JMP	runtime·goPanicSliceB<ABIInternal>(SB)
 TEXT runtime·panicSliceBU<ABIInternal>(SB),NOSPLIT,$0-16
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	CX, BX
+#else
 	MOVQ	AX, x+0(FP)
 	MOVQ	CX, y+8(FP)
+#endif
 	JMP	runtime·goPanicSliceBU<ABIInternal>(SB)
 TEXT runtime·panicSlice3Alen<ABIInternal>(SB),NOSPLIT,$0-16
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	DX, AX
+#else
 	MOVQ	DX, x+0(FP)
 	MOVQ	BX, y+8(FP)
+#endif
 	JMP	runtime·goPanicSlice3Alen<ABIInternal>(SB)
 TEXT runtime·panicSlice3AlenU<ABIInternal>(SB),NOSPLIT,$0-16
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	DX, AX
+#else
 	MOVQ	DX, x+0(FP)
 	MOVQ	BX, y+8(FP)
+#endif
 	JMP	runtime·goPanicSlice3AlenU<ABIInternal>(SB)
 TEXT runtime·panicSlice3Acap<ABIInternal>(SB),NOSPLIT,$0-16
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	DX, AX
+#else
 	MOVQ	DX, x+0(FP)
 	MOVQ	BX, y+8(FP)
+#endif
 	JMP	runtime·goPanicSlice3Acap<ABIInternal>(SB)
 TEXT runtime·panicSlice3AcapU<ABIInternal>(SB),NOSPLIT,$0-16
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	DX, AX
+#else
 	MOVQ	DX, x+0(FP)
 	MOVQ	BX, y+8(FP)
+#endif
 	JMP	runtime·goPanicSlice3AcapU<ABIInternal>(SB)
 TEXT runtime·panicSlice3B<ABIInternal>(SB),NOSPLIT,$0-16
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	CX, AX
+	MOVQ	DX, BX
+#else
 	MOVQ	CX, x+0(FP)
 	MOVQ	DX, y+8(FP)
+#endif
 	JMP	runtime·goPanicSlice3B<ABIInternal>(SB)
 TEXT runtime·panicSlice3BU<ABIInternal>(SB),NOSPLIT,$0-16
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	CX, AX
+	MOVQ	DX, BX
+#else
 	MOVQ	CX, x+0(FP)
 	MOVQ	DX, y+8(FP)
+#endif
 	JMP	runtime·goPanicSlice3BU<ABIInternal>(SB)
 TEXT runtime·panicSlice3C<ABIInternal>(SB),NOSPLIT,$0-16
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	CX, BX
+#else
 	MOVQ	AX, x+0(FP)
 	MOVQ	CX, y+8(FP)
+#endif
 	JMP	runtime·goPanicSlice3C<ABIInternal>(SB)
 TEXT runtime·panicSlice3CU<ABIInternal>(SB),NOSPLIT,$0-16
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	CX, BX
+#else
 	MOVQ	AX, x+0(FP)
 	MOVQ	CX, y+8(FP)
+#endif
 	JMP	runtime·goPanicSlice3CU<ABIInternal>(SB)
 
 #ifdef GOOS_android
-- 
GitLab


From ecca94a7d1fb4f00101af9831fcb395ed08b6948 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Wed, 7 Apr 2021 14:10:46 -0400
Subject: [PATCH 1442/2400] cmd/go/internal/modload: add a dormant depth type

This change adds the depth constants 'lazy' and 'eager', but leaves
the go117EnableLazyLoading constant set to false so that the depth in
effect is still always 'eager'.

The go117EnableLazyLoading constant can be toggled to true once the
module loader has been updated to maintain the lazy-loading invariants
in the go.mod file. In the meantime, this will allow me to
progressively replace uses of go117LazyTODO with real conditions and
locally toggle lazy-mode on to see which tests are still failing
(or which behaviors are missing test coverage).

For #36460

Change-Id: Ifd358265a3903a5000003c2072f28171f336e15c
Reviewed-on: https://go-review.googlesource.com/c/go/+/308515
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modload/build.go       |  2 +-
 src/cmd/go/internal/modload/buildlist.go   | 64 ++++++++++++++--------
 src/cmd/go/internal/modload/import_test.go |  2 +-
 src/cmd/go/internal/modload/init.go        |  6 +-
 src/cmd/go/internal/modload/load.go        | 10 ++--
 src/cmd/go/internal/modload/modfile.go     | 64 +++++++++++++++++++---
 6 files changed, 107 insertions(+), 41 deletions(-)

diff --git a/src/cmd/go/internal/modload/build.go b/src/cmd/go/internal/modload/build.go
index b8825408d7..c3cac4d491 100644
--- a/src/cmd/go/internal/modload/build.go
+++ b/src/cmd/go/internal/modload/build.go
@@ -80,7 +80,7 @@ func ModuleInfo(ctx context.Context, path string) *modinfo.ModulePublic {
 		v  string
 		ok bool
 	)
-	if go117LazyTODO {
+	if rs.depth == lazy {
 		v, ok = rs.rootSelected(path)
 	}
 	if !ok {
diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index 551e817cd2..24b2585a55 100644
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -28,6 +28,15 @@ func capVersionSlice(s []module.Version) []module.Version {
 
 // A Requirements represents a logically-immutable set of root module requirements.
 type Requirements struct {
+	// depth is the depth at which the requirement graph is computed.
+	//
+	// If eager, the graph includes all transitive requirements regardless of depth.
+	//
+	// If lazy, the graph includes only the root modules, the explicit
+	// requirements of those root modules, and the transitive requirements of only
+	// the *non-lazy* root modules.
+	depth modDepth
+
 	// rootModules is the set of module versions explicitly required by the main
 	// module, sorted and capped to length. It may contain duplicates, and may
 	// contain multiple versions for a given module path.
@@ -85,7 +94,7 @@ var requirements *Requirements
 //
 // If vendoring is in effect, the caller must invoke initVendor on the returned
 // *Requirements before any other method.
-func newRequirements(rootModules []module.Version, direct map[string]bool) *Requirements {
+func newRequirements(depth modDepth, rootModules []module.Version, direct map[string]bool) *Requirements {
 	for i, m := range rootModules {
 		if m == Target {
 			panic(fmt.Sprintf("newRequirements called with untrimmed build list: rootModules[%v] is Target", i))
@@ -120,12 +129,13 @@ func (rs *Requirements) initVendor(vendorList []module.Version) {
 			g: mvs.NewGraph(cmpVersion, []module.Version{Target}),
 		}
 
-		if go117LazyTODO {
+		if rs.depth == lazy {
 			// The roots of a lazy module should already include every module in the
 			// vendor list, because the vendored modules are the same as those
 			// maintained as roots by the lazy loading “import invariant”.
-			//
-			// TODO: Double-check here that that invariant holds.
+			if go117LazyTODO {
+				// Double-check here that that invariant holds.
+			}
 
 			// So we can just treat the rest of the module graph as effectively
 			// “pruned out”, like a more aggressive version of lazy loading:
@@ -173,7 +183,7 @@ func (rs *Requirements) rootSelected(path string) (version string, ok bool) {
 // returns a non-nil error of type *mvs.BuildListError.
 func (rs *Requirements) Graph(ctx context.Context) (*ModuleGraph, error) {
 	rs.graphOnce.Do(func() {
-		mg, mgErr := readModGraph(ctx, rs.rootModules)
+		mg, mgErr := readModGraph(ctx, rs.depth, rs.rootModules)
 		rs.graph.Store(cachedGraph{mg, mgErr})
 	})
 	cached := rs.graph.Load().(cachedGraph)
@@ -205,7 +215,7 @@ type summaryError struct {
 //
 // Unlike LoadModGraph, readModGraph does not attempt to diagnose or update
 // inconsistent roots.
-func readModGraph(ctx context.Context, roots []module.Version) (*ModuleGraph, error) {
+func readModGraph(ctx context.Context, depth modDepth, roots []module.Version) (*ModuleGraph, error) {
 	var (
 		mu       sync.Mutex // guards mg.g and hasError during loading
 		hasError bool
@@ -216,8 +226,8 @@ func readModGraph(ctx context.Context, roots []module.Version) (*ModuleGraph, er
 	mg.g.Require(Target, roots)
 
 	var (
-		loadQueue = par.NewQueue(runtime.GOMAXPROCS(0))
-		loading   sync.Map // module.Version → nil; the set of modules that have been or are being loaded
+		loadQueue    = par.NewQueue(runtime.GOMAXPROCS(0))
+		loadingEager sync.Map // module.Version → nil; the set of modules that have been or are being loaded via eager roots
 	)
 
 	// loadOne synchronously loads the explicit requirements for module m.
@@ -241,17 +251,19 @@ func readModGraph(ctx context.Context, roots []module.Version) (*ModuleGraph, er
 		return cached.summary, cached.err
 	}
 
-	var enqueue func(m module.Version)
-	enqueue = func(m module.Version) {
+	var enqueue func(m module.Version, depth modDepth)
+	enqueue = func(m module.Version, depth modDepth) {
 		if m.Version == "none" {
 			return
 		}
 
-		if _, dup := loading.LoadOrStore(m, nil); dup {
-			// m has already been enqueued for loading. Since the requirement graph
-			// may contain cycles, we need to return early to avoid making the load
-			// queue infinitely long.
-			return
+		if depth == eager {
+			if _, dup := loadingEager.LoadOrStore(m, nil); dup {
+				// m has already been enqueued for loading. Since eager loading may
+				// follow cycles in the the requirement graph, we need to return early
+				// to avoid making the load queue infinitely long.
+				return
+			}
 		}
 
 		loadQueue.Add(func() {
@@ -265,16 +277,16 @@ func readModGraph(ctx context.Context, roots []module.Version) (*ModuleGraph, er
 			// sufficient to build the packages it contains. We must load its full
 			// transitive dependency graph to be sure that we see all relevant
 			// dependencies.
-			if !go117LazyTODO {
+			if depth == eager || summary.depth() == eager {
 				for _, r := range summary.require {
-					enqueue(r)
+					enqueue(r, eager)
 				}
 			}
 		})
 	}
 
 	for _, m := range roots {
-		enqueue(m)
+		enqueue(m, depth)
 	}
 	<-loadQueue.Idle()
 
@@ -390,7 +402,7 @@ func expandGraph(ctx context.Context, rs *Requirements) (*Requirements, *ModuleG
 		// roots — but in a lazy module it may pull in previously-irrelevant
 		// transitive dependencies.
 
-		newRS, rsErr := updateRoots(ctx, rs.direct, nil, rs)
+		newRS, rsErr := updateRoots(ctx, rs.depth, rs.direct, nil, rs)
 		if rsErr != nil {
 			// Failed to update roots, perhaps because of an error in a transitive
 			// dependency needed for the update. Return the original Requirements
@@ -491,7 +503,7 @@ func editRequirements(ctx context.Context, rs *Requirements, add, mustSelect []m
 			direct[m.Path] = true
 		}
 	}
-	return newRequirements(min, direct), changed, nil
+	return newRequirements(rs.depth, min, direct), changed, nil
 }
 
 // A ConstraintError describes inconsistent constraints in EditBuildList
@@ -532,7 +544,13 @@ func TidyBuildList(ctx context.Context) {
 		// The implementation for eager modules should be factored out into a function.
 	}
 
-	tidy, err := updateRoots(ctx, loaded.requirements.direct, loaded.pkgs, nil)
+	depth := index.depth()
+	if go117LazyTODO {
+		// TODO(#45094): add a -go flag to 'go mod tidy' to allow the depth to be
+		// changed after loading packages.
+	}
+
+	tidy, err := updateRoots(ctx, depth, loaded.requirements.direct, loaded.pkgs, nil)
 	if err != nil {
 		base.Fatalf("go: %v", err)
 	}
@@ -570,7 +588,7 @@ func TidyBuildList(ctx context.Context) {
 // 	3. The selected version of the module providing each package in pkgs remains
 // 	   selected.
 // 	4. If rs is non-nil, every version selected in the graph of rs remains selected.
-func updateRoots(ctx context.Context, direct map[string]bool, pkgs []*loadPkg, rs *Requirements) (*Requirements, error) {
+func updateRoots(ctx context.Context, depth modDepth, direct map[string]bool, pkgs []*loadPkg, rs *Requirements) (*Requirements, error) {
 	var (
 		rootPaths   []string // module paths that should be included as roots
 		inRootPaths = map[string]bool{}
@@ -676,7 +694,7 @@ func updateRoots(ctx context.Context, direct map[string]bool, pkgs []*loadPkg, r
 	// the root set is the same as the original root set in rs and recycle its
 	// module graph and build list, if they have already been loaded.
 
-	return newRequirements(min, direct), nil
+	return newRequirements(depth, min, direct), nil
 }
 
 // checkMultiplePaths verifies that a given module path is used as itself
diff --git a/src/cmd/go/internal/modload/import_test.go b/src/cmd/go/internal/modload/import_test.go
index e52a7fa66b..98145887e9 100644
--- a/src/cmd/go/internal/modload/import_test.go
+++ b/src/cmd/go/internal/modload/import_test.go
@@ -69,7 +69,7 @@ func TestQueryImport(t *testing.T) {
 	RootMode = NoRoot
 
 	ctx := context.Background()
-	rs := newRequirements(nil, nil)
+	rs := newRequirements(eager, nil, nil)
 
 	for _, tt := range importTests {
 		t.Run(strings.ReplaceAll(tt.path, "/", "_"), func(t *testing.T) {
diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index fdfb83646e..777b63841f 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -388,7 +388,7 @@ func LoadModFile(ctx context.Context) *Requirements {
 		Target = module.Version{Path: "command-line-arguments"}
 		targetPrefix = "command-line-arguments"
 		rawGoVersion.Store(Target, latestGoVersion())
-		commitRequirements(ctx, newRequirements(nil, nil))
+		commitRequirements(ctx, newRequirements(index.depth(), nil, nil))
 		return requirements
 	}
 
@@ -664,7 +664,7 @@ func requirementsFromModFile(ctx context.Context, f *modfile.File) *Requirements
 		}
 	}
 	module.Sort(roots)
-	rs := newRequirements(roots, direct)
+	rs := newRequirements(index.depth(), roots, direct)
 
 	// If any module path appears more than once in the roots, we know that the
 	// go.mod file needs to be updated even though we have not yet loaded any
@@ -672,7 +672,7 @@ func requirementsFromModFile(ctx context.Context, f *modfile.File) *Requirements
 	for _, n := range mPathCount {
 		if n > 1 {
 			var err error
-			rs, err = updateRoots(ctx, rs.direct, nil, rs)
+			rs, err = updateRoots(ctx, rs.depth, rs.direct, nil, rs)
 			if err != nil {
 				base.Fatalf("go: %v", err)
 			}
diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index 5bff17e579..5de26c15e7 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -537,7 +537,7 @@ func pathInModuleCache(ctx context.Context, dir string, rs *Requirements) string
 		return path.Join(m.Path, filepath.ToSlash(sub)), true
 	}
 
-	if go117LazyTODO {
+	if rs.depth == lazy {
 		for _, m := range rs.rootModules {
 			if v, _ := rs.rootSelected(m.Path); v != m.Version {
 				continue // m is a root, but we have a higher root for the same path.
@@ -550,9 +550,9 @@ func pathInModuleCache(ctx context.Context, dir string, rs *Requirements) string
 		}
 	}
 
-	// None of the roots contained dir, or we're in eager mode and have already
-	// loaded the full module graph. Either way, check the full graph to see if
-	// the directory is a non-root dependency.
+	// None of the roots contained dir, or we're in eager mode and want to load
+	// the full module graph more aggressively. Either way, check the full graph
+	// to see if the directory is a non-root dependency.
 	//
 	// If the roots are not consistent with the full module graph, the selected
 	// versions of root modules may differ from what we already checked above.
@@ -1020,7 +1020,7 @@ func (ld *loader) updateRequirements(ctx context.Context) error {
 		}
 	}
 
-	rs, err := updateRoots(ctx, direct, ld.pkgs, rs)
+	rs, err := updateRoots(ctx, rs.depth, direct, ld.pkgs, rs)
 	if err == nil {
 		ld.requirements = rs
 	}
diff --git a/src/cmd/go/internal/modload/modfile.go b/src/cmd/go/internal/modload/modfile.go
index 3e4772f217..3b01afa13f 100644
--- a/src/cmd/go/internal/modload/modfile.go
+++ b/src/cmd/go/internal/modload/modfile.go
@@ -25,15 +25,29 @@ import (
 	"golang.org/x/mod/semver"
 )
 
-// narrowAllVersionV is the Go version (plus leading "v") at which the
-// module-module "all" pattern no longer closes over the dependencies of
-// tests outside of the main module.
-const narrowAllVersionV = "v1.16"
+const (
+	// narrowAllVersionV is the Go version (plus leading "v") at which the
+	// module-module "all" pattern no longer closes over the dependencies of
+	// tests outside of the main module.
+	narrowAllVersionV = "v1.16"
+
+	// lazyLoadingVersionV is the Go version (plus leading "v") at which a
+	// module's go.mod file is expected to list explicit requirements on every
+	// module that provides any package transitively imported by that module.
+	lazyLoadingVersionV = "v1.17"
+)
+
+const (
+	// go117EnableLazyLoading toggles whether lazy-loading code paths should be
+	// active. It will be removed once the lazy loading implementation is stable
+	// and well-tested.
+	go117EnableLazyLoading = false
 
-// go1117LazyTODO is a constant that exists only until lazy loading is
-// implemented. Its use indicates a condition that will need to change if the
-// main module is lazy.
-const go117LazyTODO = false
+	// go1117LazyTODO is a constant that exists only until lazy loading is
+	// implemented. Its use indicates a condition that will need to change if the
+	// main module is lazy.
+	go117LazyTODO = false
+)
 
 var modFile *modfile.File
 
@@ -57,6 +71,14 @@ type requireMeta struct {
 	indirect bool
 }
 
+// A modDepth indicates which dependencies should be loaded for a go.mod file.
+type modDepth uint8
+
+const (
+	lazy  modDepth = iota // load dependencies only as needed
+	eager                 // load all transitive dependencies eagerly
+)
+
 // CheckAllowed returns an error equivalent to ErrDisallowed if m is excluded by
 // the main module's go.mod or retracted by its author. Most version queries use
 // this to filter out versions that should not be used.
@@ -300,6 +322,18 @@ func (i *modFileIndex) allPatternClosesOverTests() bool {
 	return false
 }
 
+// depth reports the modDepth indicated by the indexed go.mod file,
+// or lazy if the go.mod file has not been indexed.
+func (i *modFileIndex) depth() modDepth {
+	if !go117EnableLazyLoading {
+		return eager
+	}
+	if i != nil && semver.Compare(i.goVersionV, lazyLoadingVersionV) < 0 {
+		return eager
+	}
+	return lazy
+}
+
 // modFileIsDirty reports whether the go.mod file differs meaningfully
 // from what was indexed.
 // If modFile has been changed (even cosmetically) since it was first read,
@@ -394,6 +428,20 @@ type retraction struct {
 	Rationale string
 }
 
+func (s *modFileSummary) depth() modDepth {
+	if !go117EnableLazyLoading {
+		return eager
+	}
+	// The 'go' command fills in the 'go' directive automatically, so an empty
+	// goVersionV in a dependency implies either Go 1.11 (eager loading) or no
+	// explicit go.mod file at all (no difference between eager and lazy because
+	// the module doesn't specify any requirements at all).
+	if s.goVersionV == "" || semver.Compare(s.goVersionV, lazyLoadingVersionV) < 0 {
+		return eager
+	}
+	return lazy
+}
+
 // goModSummary returns a summary of the go.mod file for module m,
 // taking into account any replacements for m, exclusions of its dependencies,
 // and/or vendoring.
-- 
GitLab


From 46ffbec1d6715f62c724a7180aec12ffd8acf57f Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Wed, 7 Apr 2021 07:58:10 -0700
Subject: [PATCH 1443/2400] cmd/compile: break out transformations of tcCompLit
 into transformCompLit

Create transformCompLit, which does the transformations done by
tcCompLit without the typechecking. This removes the final use of the
old typechecker in the noder2 pass.

Other changes:

 - Used the transformCompLit in stringstorunelit(), which creates an
   OCOMPLIT that needs transformation as well.

 - Fixed one place in transformIndex where we were still using
   typecheck.AssignConv, when we should be using its equivalent
   noder.assignconvfn.

The go/test tests always run with -G=3, and I also tested that the "go
test" tests continue to run correctly with -G=3.

Change-Id: I4a976534ab7311cf2a5f43841026dbf7401e62b6
Reviewed-on: https://go-review.googlesource.com/c/go/+/308529
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Dan Scales <danscales@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/noder/expr.go      |   5 +-
 src/cmd/compile/internal/noder/transform.go | 166 +++++++++++++++++++-
 2 files changed, 163 insertions(+), 8 deletions(-)

diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index eee39ecadb..fc97df7197 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -346,8 +346,9 @@ func (g *irgen) compLit(typ types2.Type, lit *syntax.CompositeLit) ir.Node {
 		}
 	}
 
-	// TODO(mdempsky): Remove dependency on typecheck.Expr.
-	return typecheck.Expr(ir.NewCompLitExpr(g.pos(lit), ir.OCOMPLIT, ir.TypeNode(g.typ(typ)), exprs))
+	n := ir.NewCompLitExpr(g.pos(lit), ir.OCOMPLIT, nil, exprs)
+	typed(g.typ(typ), n)
+	return transformCompLit(n)
 }
 
 func (g *irgen) funcLit(typ2 types2.Type, expr *syntax.FuncLit) ir.Node {
diff --git a/src/cmd/compile/internal/noder/transform.go b/src/cmd/compile/internal/noder/transform.go
index ffe35d5874..31f8d1d61b 100644
--- a/src/cmd/compile/internal/noder/transform.go
+++ b/src/cmd/compile/internal/noder/transform.go
@@ -61,18 +61,24 @@ func stringtoruneslit(n *ir.ConvExpr) ir.Node {
 		base.Fatalf("stringtoarraylit %v", n)
 	}
 
-	var l []ir.Node
+	var list []ir.Node
 	i := 0
+	eltType := n.Type().Elem()
 	for _, r := range ir.StringVal(n.X) {
-		l = append(l, ir.NewKeyExpr(base.Pos, ir.NewInt(int64(i)), ir.NewInt(int64(r))))
+		elt := ir.NewKeyExpr(base.Pos, ir.NewInt(int64(i)), ir.NewInt(int64(r)))
+		// Change from untyped int to the actual element type determined
+		// by types2.  No need to change elt.Key, since the array indexes
+		// are just used for setting up the element ordering.
+		elt.Value.SetType(eltType)
+		list = append(list, elt)
 		i++
 	}
 
 	nn := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(n.Type()), nil)
-	nn.List = l
+	nn.List = list
+	typed(n.Type(), nn)
 	// Need to transform the OCOMPLIT.
-	// TODO(danscales): update this when we have written transformCompLit()
-	return typecheck.Expr(nn)
+	return transformCompLit(nn)
 }
 
 // transformConv transforms an OCONV node as needed, based on the types involved,
@@ -225,7 +231,7 @@ func transformIndex(n *ir.IndexExpr) {
 	l := n.X
 	t := l.Type()
 	if t.Kind() == types.TMAP {
-		n.Index = typecheck.AssignConv(n.Index, t.Key(), "map index")
+		n.Index = assignconvfn(n.Index, t.Key())
 		n.SetOp(ir.OINDEXMAP)
 		// Set type to just the map value, not (value, bool). This is
 		// different from types2, but fits the later stages of the
@@ -805,3 +811,151 @@ func transformBuiltin(n *ir.CallExpr) ir.Node {
 
 	return n
 }
+
+func hasKeys(l ir.Nodes) bool {
+	for _, n := range l {
+		if n.Op() == ir.OKEY || n.Op() == ir.OSTRUCTKEY {
+			return true
+		}
+	}
+	return false
+}
+
+// transformArrayLit runs assignconvfn on each array element and returns the
+// length of the slice/array that is needed to hold all the array keys/indexes
+// (one more than the highest index). Corresponds to typecheck.typecheckarraylit.
+func transformArrayLit(elemType *types.Type, bound int64, elts []ir.Node) int64 {
+	var key, length int64
+	for i, elt := range elts {
+		ir.SetPos(elt)
+		r := elts[i]
+		var kv *ir.KeyExpr
+		if elt.Op() == ir.OKEY {
+			elt := elt.(*ir.KeyExpr)
+			key = typecheck.IndexConst(elt.Key)
+			assert(key >= 0)
+			kv = elt
+			r = elt.Value
+		}
+
+		r = assignconvfn(r, elemType)
+		if kv != nil {
+			kv.Value = r
+		} else {
+			elts[i] = r
+		}
+
+		key++
+		if key > length {
+			length = key
+		}
+	}
+
+	return length
+}
+
+// transformCompLit transforms n to an OARRAYLIT, OSLICELIT, OMAPLIT, or
+// OSTRUCTLIT node, with any needed conversions. Corresponds to
+// typecheck.tcCompLit.
+func transformCompLit(n *ir.CompLitExpr) (res ir.Node) {
+	assert(n.Type() != nil && n.Typecheck() == 1)
+	lno := base.Pos
+	defer func() {
+		base.Pos = lno
+	}()
+
+	// Save original node (including n.Right)
+	n.SetOrig(ir.Copy(n))
+
+	ir.SetPos(n)
+
+	t := n.Type()
+
+	switch t.Kind() {
+	default:
+		base.Fatalf("transformCompLit %v", t.Kind())
+
+	case types.TARRAY:
+		transformArrayLit(t.Elem(), t.NumElem(), n.List)
+		n.SetOp(ir.OARRAYLIT)
+
+	case types.TSLICE:
+		length := transformArrayLit(t.Elem(), -1, n.List)
+		n.SetOp(ir.OSLICELIT)
+		n.Len = length
+
+	case types.TMAP:
+		for _, l := range n.List {
+			ir.SetPos(l)
+			assert(l.Op() == ir.OKEY)
+			l := l.(*ir.KeyExpr)
+
+			r := l.Key
+			l.Key = assignconvfn(r, t.Key())
+
+			r = l.Value
+			l.Value = assignconvfn(r, t.Elem())
+		}
+
+		n.SetOp(ir.OMAPLIT)
+
+	case types.TSTRUCT:
+		// Need valid field offsets for Xoffset below.
+		types.CalcSize(t)
+
+		if len(n.List) != 0 && !hasKeys(n.List) {
+			// simple list of values
+			ls := n.List
+			for i, n1 := range ls {
+				ir.SetPos(n1)
+
+				f := t.Field(i)
+				n1 = assignconvfn(n1, f.Type)
+				sk := ir.NewStructKeyExpr(base.Pos, f.Sym, n1)
+				sk.Offset = f.Offset
+				ls[i] = sk
+			}
+			assert(len(ls) >= t.NumFields())
+		} else {
+			// keyed list
+			ls := n.List
+			for i, l := range ls {
+				ir.SetPos(l)
+
+				if l.Op() == ir.OKEY {
+					kv := l.(*ir.KeyExpr)
+					key := kv.Key
+
+					// Sym might have resolved to name in other top-level
+					// package, because of import dot. Redirect to correct sym
+					// before we do the lookup.
+					s := key.Sym()
+					if id, ok := key.(*ir.Ident); ok && typecheck.DotImportRefs[id] != nil {
+						s = typecheck.Lookup(s.Name)
+					}
+
+					// An OXDOT uses the Sym field to hold
+					// the field to the right of the dot,
+					// so s will be non-nil, but an OXDOT
+					// is never a valid struct literal key.
+					assert(!(s == nil || s.Pkg != types.LocalPkg || key.Op() == ir.OXDOT || s.IsBlank()))
+
+					l = ir.NewStructKeyExpr(l.Pos(), s, kv.Value)
+					ls[i] = l
+				}
+
+				assert(l.Op() == ir.OSTRUCTKEY)
+				l := l.(*ir.StructKeyExpr)
+
+				f := typecheck.Lookdot1(nil, l.Field, t, t.Fields(), 0)
+				l.Offset = f.Offset
+
+				l.Value = assignconvfn(l.Value, f.Type)
+			}
+		}
+
+		n.SetOp(ir.OSTRUCTLIT)
+	}
+
+	return n
+}
-- 
GitLab


From 98dd205fa4f125c8ba8099c3d84d95189666068e Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Sun, 28 Feb 2021 12:24:02 +0100
Subject: [PATCH 1444/2400] runtime: see whether gp==nil before checking
 preemption state

Recent we changed from using gFromTLS to using gFromSP, which apparently
sometimes returns nil. This causes crashes when dereferenced. Fix that
by not checking for preemption in the case that gFromSP returns nil.

Fixes #44679.

Change-Id: I0199ebe7cd113379c5fa35c27932d913df79092a
Reviewed-on: https://go-review.googlesource.com/c/go/+/297390
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/runtime/os_windows.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/os_windows.go b/src/runtime/os_windows.go
index 707c9054b5..705b42c61c 100644
--- a/src/runtime/os_windows.go
+++ b/src/runtime/os_windows.go
@@ -1380,7 +1380,7 @@ func preemptM(mp *m) {
 
 	// Does it want a preemption and is it safe to preempt?
 	gp := gFromSP(mp, c.sp())
-	if wantAsyncPreempt(gp) {
+	if gp != nil && wantAsyncPreempt(gp) {
 		if ok, newpc := isAsyncSafePoint(gp, c.ip(), c.sp(), c.lr()); ok {
 			// Inject call to asyncPreempt
 			targetPC := funcPC(asyncPreempt)
-- 
GitLab


From 793844207d81bdc41212bc300195469c65c39766 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Thu, 8 Apr 2021 12:50:39 -0400
Subject: [PATCH 1445/2400] cmd/go: strip GOEXPERIMENT from hash salt

The go command salts cache hashes using runtime.Version() (the Go
version the go command was built with) in order to separate objects
built with different versions of Go.

CL 307820 added the active GOEXPERIMENTs to the result of
runtime.Version, which affected cmd/go's hash salt. Since dist builds
go_bootstrap with all GOEXPERIMENTs disabled, but then go_bootstrap
builds the final go binary with the GOEXPERIMENTs passed to make.bash,
if any GOEXPERIMENTs were passed, go_bootstrap and the final go binary
produce different cache hashes. At the very end of dist, it uses the
final go binary to check the hashes of all packages, but these hashes
were produced by go_bootstrap, so it concludes everything is stale.

This should fix the builders that enable GOEXPERIMENTs, including the
regabi and staticlockranking builders.

Change-Id: Ie389929dff6f7b6eff2b19a2f43507e72be5f32e
Reviewed-on: https://go-review.googlesource.com/c/go/+/308591
Trust: Austin Clements <austin@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/dist/build.go             |  2 +-
 src/cmd/go/internal/cache/hash.go | 17 ++++++++++++++++-
 2 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/src/cmd/dist/build.go b/src/cmd/dist/build.go
index 8accb6db8f..f8f8003ff7 100644
--- a/src/cmd/dist/build.go
+++ b/src/cmd/dist/build.go
@@ -1541,7 +1541,7 @@ func checkNotStale(goBinary string, targets ...string) {
 				break
 			}
 		}
-		fatalf("unexpected stale targets reported by %s list -gcflags=\"%s\" -ldflags=\"%s\" for %v:\n%s", goBinary, gogcflags, goldflags, targets, out)
+		fatalf("unexpected stale targets reported by %s list -gcflags=\"%s\" -ldflags=\"%s\" for %v (consider rerunning with GOMAXPROCS=1 GODEBUG=gocachehash=1):\n%s", goBinary, gogcflags, goldflags, targets, out)
 	}
 }
 
diff --git a/src/cmd/go/internal/cache/hash.go b/src/cmd/go/internal/cache/hash.go
index e4bb2a34bb..f16215428a 100644
--- a/src/cmd/go/internal/cache/hash.go
+++ b/src/cmd/go/internal/cache/hash.go
@@ -12,6 +12,7 @@ import (
 	"io"
 	"os"
 	"runtime"
+	"strings"
 	"sync"
 )
 
@@ -36,7 +37,21 @@ type Hash struct {
 // of other versions. This salt will result in additional ActionID files
 // in the cache, but not additional copies of the large output files,
 // which are still addressed by unsalted SHA256.
-var hashSalt = []byte(runtime.Version())
+//
+// We strip any GOEXPERIMENTs the go tool was built with from this
+// version string on the assumption that they shouldn't affect go tool
+// execution. This also allows bootstrapping to converge faster
+// because dist builds go_bootstrap without any experiments.
+var hashSalt = []byte(stripExperiment(runtime.Version()))
+
+// stripExperiment strips any GOEXPERIMENT configuration from the Go
+// version string.
+func stripExperiment(version string) string {
+	if i := strings.Index(version, " X:"); i >= 0 {
+		return version[:i]
+	}
+	return version
+}
 
 // Subkey returns an action ID corresponding to mixing a parent
 // action ID with a string description of the subkey.
-- 
GitLab


From bb76193a7f0b04c6c25696ed28dd5516ae23d83c Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Thu, 8 Apr 2021 15:30:03 -0400
Subject: [PATCH 1446/2400] cmd/compile: fix buglet in walk convert phase
 relating to convF32/64

The helper function used by the compiler's walk phase to determine
whether a param can be passed in a single float register wasn't quite
correct (didn't allow for the possibility of struct with two fields,
first zero size and second float). Fix up the helper to take this
case into account.

Updates #40724.

Change-Id: I55b42a1b17ea86de1d696788f029ad3aae4a179c
Reviewed-on: https://go-review.googlesource.com/c/go/+/308689
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/walk/convert.go | 17 ++++++++++++++-
 test/abi/convF_criteria.go               | 27 ++++++++++++++++++++++++
 test/abi/convF_criteria.out              |  2 ++
 3 files changed, 45 insertions(+), 1 deletion(-)
 create mode 100644 test/abi/convF_criteria.go
 create mode 100644 test/abi/convF_criteria.out

diff --git a/src/cmd/compile/internal/walk/convert.go b/src/cmd/compile/internal/walk/convert.go
index 3d30aefd5f..547e08dcab 100644
--- a/src/cmd/compile/internal/walk/convert.go
+++ b/src/cmd/compile/internal/walk/convert.go
@@ -312,7 +312,22 @@ func convFuncName(from, to *types.Type) (fnname string, needsaddr bool) {
 		case types.TARRAY:
 			return t.NumElem() == 1 && isFloatLike(t.Elem())
 		case types.TSTRUCT:
-			return t.NumFields() == 1 && isFloatLike(t.Field(0).Type)
+			// allow for the possibility that we have a series of
+			// leading fields that are zero size before a float field.
+			// in addition, if we find a float field, it needs to be
+			// the last item in the struct (a trailing zero length
+			// field would introduce padding).
+			fsl := t.FieldSlice()
+			for idx, f := range fsl {
+				if f.Type.Width == 0 {
+					continue
+				}
+				if isFloatLike(f.Type) && idx == len(fsl)-1 {
+					return true
+				}
+				return false
+			}
+			return false
 		}
 		return false
 	}
diff --git a/test/abi/convF_criteria.go b/test/abi/convF_criteria.go
new file mode 100644
index 0000000000..77ed56d4a4
--- /dev/null
+++ b/test/abi/convF_criteria.go
@@ -0,0 +1,27 @@
+// run
+
+// Copyright 2021 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 "fmt"
+
+type myStruct struct {
+	F0 [0]struct{}
+	F1 float32
+}
+
+type myStruct2 struct {
+	F0 [0]struct{}
+	F1 float32
+	F2 [0]struct{}
+}
+
+func main() {
+	x := myStruct{F1: -1.25}
+	fmt.Println(x)
+	x2 := myStruct2{F1: -7.97}
+	fmt.Println(x2)
+}
diff --git a/test/abi/convF_criteria.out b/test/abi/convF_criteria.out
new file mode 100644
index 0000000000..457f0defc9
--- /dev/null
+++ b/test/abi/convF_criteria.out
@@ -0,0 +1,2 @@
+{[] -1.25}
+{[] -7.97 []}
-- 
GitLab


From 7e583806d8135a59866ff329cc19a0bc4425aa80 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Wed, 7 Apr 2021 15:22:53 -0700
Subject: [PATCH 1447/2400] runtime/cgo: clarify Handle documentation

Fixes #45427

Change-Id: Ic67630a5f39d8789a4a30c6b4ee30946bc50382e
Reviewed-on: https://go-review.googlesource.com/c/go/+/308230
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Ainar Garipov <gugl.zadolbal@gmail.com>
Reviewed-by: Changkun Ou <euryugasaki@gmail.com>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/runtime/cgo/handle.go | 68 +++++++++++++++++++++------------------
 1 file changed, 37 insertions(+), 31 deletions(-)

diff --git a/src/runtime/cgo/handle.go b/src/runtime/cgo/handle.go
index a798ba9064..720acca802 100644
--- a/src/runtime/cgo/handle.go
+++ b/src/runtime/cgo/handle.go
@@ -9,50 +9,56 @@ import (
 	"sync/atomic"
 )
 
-// Handle provides a safe representation of Go values to pass between
-// Go and C. The zero value of a handle is not a valid handle, and thus
-// is safe to use as a sentinel in C APIs.
+// Handle provides a way to pass values that contain Go pointers
+// (pointers to memory allocated by Go) between Go and C without
+// breaking the cgo pointer passing rules. A Handle is an integer
+// value that can represent any Go value. A Handle can be passed
+// through C and back to Go, and Go code can use the Handle to
+// retrieve the original Go value.
 //
 // The underlying type of Handle is guaranteed to fit in an integer type
-// that is large enough to hold the bit pattern of any pointer.
+// that is large enough to hold the bit pattern of any pointer. The zero
+// value of a Handle is not valid, and thus is safe to use as a sentinel
+// in C APIs.
+//
 // For instance, on the Go side:
 //
-// 	package main
+//	package main
 //
-// 	/*
-// 	#include <stdint.h> // for uintptr_t
+//	/*
+//	#include <stdint.h> // for uintptr_t
 //
-// 	extern void MyGoPrint(uintptr_t handle);
-// 	void myprint(uintptr_t handle);
-// 	*/
-// 	import "C"
-// 	import "runtime/cgo"
+//	extern void MyGoPrint(uintptr_t handle);
+//	void myprint(uintptr_t handle);
+//	*/
+//	import "C"
+//	import "runtime/cgo"
 //
-// 	//export MyGoPrint
-// 	func MyGoPrint(handle C.uintptr_t) {
-// 		h := cgo.Handle(handle)
-// 		val := h.Value().(int)
-// 		println(val)
-// 		h.Delete()
-// 	}
+//	//export MyGoPrint
+//	func MyGoPrint(handle C.uintptr_t) {
+//		h := cgo.Handle(handle)
+//		val := h.Value().(string)
+//		println(val)
+//		h.Delete()
+//	}
 //
-// 	func main() {
-// 		val := 42
-// 		C.myprint(C.uintptr_t(cgo.NewHandle(val)))
-// 		// Output: 42
-// 	}
+//	func main() {
+//		val := "hello Go"
+//		C.myprint(C.uintptr_t(cgo.NewHandle(val)))
+//		// Output: hello Go
+//	}
 //
 // and on the C side:
 //
-// 	#include <stdint.h> // for uintptr_t
+//	#include <stdint.h> // for uintptr_t
 //
-// 	// A Go function
-// 	extern void MyGoPrint(uintptr_t handle);
+//	// A Go function
+//	extern void MyGoPrint(uintptr_t handle);
 //
-// 	// A C function
-// 	void myprint(uintptr_t handle) {
-// 	    MyGoPrint(handle);
-// 	}
+//	// A C function
+//	void myprint(uintptr_t handle) {
+//	    MyGoPrint(handle);
+//	}
 type Handle uintptr
 
 // NewHandle returns a handle for a given value.
-- 
GitLab


From a9e475a15a7211c356157d1d0e5dc7cef7dd970e Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Thu, 8 Apr 2021 12:44:05 -0400
Subject: [PATCH 1448/2400] cmd/compile: add recursive-invalidate Value method,
 use in expand_calls

This removes more unused values during transformation.
Leaving them in the tree can create type conflicts in OpArg* references.

Updates #40724.
Updates #44816.
Fixes #45417.

Change-Id: I07dcb7b4b2bf8d79e22e0543cb2fb52c2ececb96
Reviewed-on: https://go-review.googlesource.com/c/go/+/308589
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/ssa/expand_calls.go | 11 +++++---
 src/cmd/compile/internal/ssa/value.go        | 29 ++++++++++++++++++++
 2 files changed, 36 insertions(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index ede713f22a..cb8b2eeec8 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -1015,7 +1015,7 @@ func (x *expandState) rewriteArgs(v *Value, firstArg int) {
 			if x.debug {
 				x.Printf("...marking %v unused\n", a.LongString())
 			}
-			a.reset(OpInvalid)
+			a.invalidateRecursively()
 		}
 	}
 
@@ -1140,7 +1140,7 @@ func expandCalls(f *Func) {
 					if x.debug {
 						x.Printf("...marking %v unused\n", a.LongString())
 					}
-					a.reset(OpInvalid)
+					a.invalidateRecursively()
 				}
 			}
 			if x.debug {
@@ -1343,6 +1343,9 @@ func expandCalls(f *Func) {
 		if dupe == nil {
 			x.commonSelectors[sk] = v
 		} else if x.sdom.IsAncestorEq(dupe.Block, v.Block) {
+			if x.debug {
+				x.Printf("Duplicate, make %s copy of %s\n", v, dupe)
+			}
 			v.copyOf(dupe)
 		} else {
 			// Because values are processed in dominator order, the old common[s] will never dominate after a miss is seen.
@@ -1361,7 +1364,7 @@ func expandCalls(f *Func) {
 			x.Printf("allOrdered[%d] = b%d, %s, uses=%d\n", i, b.ID, v.LongString(), v.Uses)
 		}
 		if v.Uses == 0 {
-			v.reset(OpInvalid)
+			v.invalidateRecursively()
 			continue
 		}
 		if v.Op == OpCopy {
@@ -1456,7 +1459,7 @@ func expandCalls(f *Func) {
 				v.SetArg(i, aa)
 				for a.Uses == 0 {
 					b := a.Args[0]
-					a.reset(OpInvalid)
+					a.invalidateRecursively()
 					a = b
 				}
 			}
diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go
index ba7f8c0300..630e4814b9 100644
--- a/src/cmd/compile/internal/ssa/value.go
+++ b/src/cmd/compile/internal/ssa/value.go
@@ -348,6 +348,35 @@ func (v *Value) reset(op Op) {
 	v.Aux = nil
 }
 
+// invalidateRecursively marks a value as invalid (unused)
+// and after decrementing reference counts on its Args,
+// also recursively invalidates any of those whose use
+// count goes to zero.
+//
+// BEWARE of doing this *before* you've applied intended
+// updates to SSA.
+func (v *Value) invalidateRecursively() {
+	if v.InCache {
+		v.Block.Func.unCache(v)
+	}
+	v.Op = OpInvalid
+
+	for _, a := range v.Args {
+		a.Uses--
+		if a.Uses == 0 {
+			a.invalidateRecursively()
+		}
+	}
+
+	v.argstorage[0] = nil
+	v.argstorage[1] = nil
+	v.argstorage[2] = nil
+	v.Args = v.argstorage[:0]
+
+	v.AuxInt = 0
+	v.Aux = nil
+}
+
 // copyOf is called from rewrite rules.
 // It modifies v to be (Copy a).
 //go:noinline
-- 
GitLab


From 6c98ecda100c2e3f8325d0b958f53aeaeb92c101 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 8 Apr 2021 14:41:44 -0400
Subject: [PATCH 1449/2400] cmd/compile: don't use fast32/64 map functions for
 aggregates

Under register ABI, aggregates like [2]uint32 is passed
differently than a uint64. For now, don't use the fast version
of the map functions for non-trivial aggregates.

GOEXPERIMENT=regabi,regabiargs can now pass make.bash, modulo
staleness checks.

TODO: maybe find some way to use the fast functions. Maybe
unsafe-cast to uint32/64 then call the map function. But need to
make the type checker happy.

Change-Id: If42717280dde12636fb970798cf1ca8fb29a3d06
Reviewed-on: https://go-review.googlesource.com/c/go/+/308650
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/walk/walk.go | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index d889786c72..1f0b777263 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -14,6 +14,7 @@ import (
 	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
+	"cmd/internal/objabi"
 	"cmd/internal/src"
 )
 
@@ -203,6 +204,13 @@ func mapfast(t *types.Type) int {
 	}
 	switch reflectdata.AlgType(t.Key()) {
 	case types.AMEM32:
+		if objabi.Experiment.RegabiArgs && t.Key().NumComponents(types.CountBlankFields) != 1 {
+			// If key has multiple components, under register ABI it will
+			// be passed differently than uint32.
+			// TODO: maybe unsafe-case to uint32. But needs to make the type
+			// checker happy.
+			return mapslow
+		}
 		if !t.Key().HasPointers() {
 			return mapfast32
 		}
@@ -211,6 +219,10 @@ func mapfast(t *types.Type) int {
 		}
 		base.Fatalf("small pointer %v", t.Key())
 	case types.AMEM64:
+		if objabi.Experiment.RegabiArgs && t.Key().NumComponents(types.CountBlankFields) != 1 {
+			// See above.
+			return mapslow
+		}
 		if !t.Key().HasPointers() {
 			return mapfast64
 		}
-- 
GitLab


From ec367e5b05becab0cfb371fdf10ba55319301e9d Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 8 Apr 2021 15:24:08 -0400
Subject: [PATCH 1450/2400] cmd/compile: adjust interface conversion function
 selection with 0-sized fields

0-sized fields do not affect how arguments are passed under the
register ABI. But it does affect the size and alignment of the
type, and may affect the choice of interface conversion function.
Specifically, struct { a [0]int32; b [4]byte } should be passed in
memory, therefore should not use convT32.

Change-Id: Idfa21af79b81c196b50253b0be1fa4edecd12b45
Reviewed-on: https://go-review.googlesource.com/c/go/+/308651
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/walk/convert.go | 17 ++---------------
 1 file changed, 2 insertions(+), 15 deletions(-)

diff --git a/src/cmd/compile/internal/walk/convert.go b/src/cmd/compile/internal/walk/convert.go
index 547e08dcab..dfdd9540e7 100644
--- a/src/cmd/compile/internal/walk/convert.go
+++ b/src/cmd/compile/internal/walk/convert.go
@@ -312,11 +312,6 @@ func convFuncName(from, to *types.Type) (fnname string, needsaddr bool) {
 		case types.TARRAY:
 			return t.NumElem() == 1 && isFloatLike(t.Elem())
 		case types.TSTRUCT:
-			// allow for the possibility that we have a series of
-			// leading fields that are zero size before a float field.
-			// in addition, if we find a float field, it needs to be
-			// the last item in the struct (a trailing zero length
-			// field would introduce padding).
 			fsl := t.FieldSlice()
 			for idx, f := range fsl {
 				if f.Type.Width == 0 {
@@ -332,14 +327,6 @@ func convFuncName(from, to *types.Type) (fnname string, needsaddr bool) {
 		return false
 	}
 
-	// Helper to determine whether a given type (when passed to a
-	// function) will fit into a single integer register, assuming
-	// that the reg abi is in effect. This is somewhat ad-hoc, there
-	// may be a cleaner way to do this.
-	fitsInSingleIntReg := func(t *types.Type) bool {
-		return from.IsScalar() || types.IsDirectIface(from)
-	}
-
 	tkind := to.Tie()
 	switch from.Tie() {
 	case 'I':
@@ -352,11 +339,11 @@ func convFuncName(from, to *types.Type) (fnname string, needsaddr bool) {
 			return "convT16", false
 		case from.Size() == 4 && isFloatLike(from):
 			return "convT32F", false
-		case from.Size() == 4 && from.Align == 4 && !from.HasPointers():
+		case from.Size() == 4 && from.Align == 4 && !from.HasPointers() && (!objabi.Experiment.RegabiArgs || from.NumComponents(types.CountBlankFields) == 1):
 			return "convT32", false
 		case from.Size() == 8 && isFloatLike(from):
 			return "convT64F", false
-		case from.Size() == 8 && from.Align == types.Types[types.TUINT64].Align && !from.HasPointers() && (!objabi.Experiment.RegabiArgs || fitsInSingleIntReg(from)):
+		case from.Size() == 8 && from.Align == types.Types[types.TUINT64].Align && !from.HasPointers() && (!objabi.Experiment.RegabiArgs || from.NumComponents(types.CountBlankFields) == 1):
 			return "convT64", false
 		}
 		if sc := from.SoleComponent(); sc != nil {
-- 
GitLab


From d67e7399898d819583cdcc377e9ff3c93002f57f Mon Sep 17 00:00:00 2001
From: Manlio Perillo <manlio.perillo@gmail.com>
Date: Wed, 7 Apr 2021 21:56:59 +0200
Subject: [PATCH 1451/2400] os/exec: replace os.MkdirTemp with T.TempDir

Updates #45402

Change-Id: Idbd8067759d58bc57c52ede4ddccc98ab0ae18fc
Reviewed-on: https://go-review.googlesource.com/c/go/+/308129
Run-TryBot: Dave Cheney <dave@cheney.net>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/os/exec/lp_windows_test.go | 14 ++------------
 1 file changed, 2 insertions(+), 12 deletions(-)

diff --git a/src/os/exec/lp_windows_test.go b/src/os/exec/lp_windows_test.go
index 56cb54f800..f834ffede0 100644
--- a/src/os/exec/lp_windows_test.go
+++ b/src/os/exec/lp_windows_test.go
@@ -306,12 +306,7 @@ var lookPathTests = []lookPathTest{
 }
 
 func TestLookPath(t *testing.T) {
-	tmp, err := os.MkdirTemp("", "TestLookPath")
-	if err != nil {
-		t.Fatal("TempDir failed: ", err)
-	}
-	defer os.RemoveAll(tmp)
-
+	tmp := t.TempDir()
 	printpathExe := buildPrintPathExe(t, tmp)
 
 	// Run all tests.
@@ -508,12 +503,7 @@ var commandTests = []commandTest{
 }
 
 func TestCommand(t *testing.T) {
-	tmp, err := os.MkdirTemp("", "TestCommand")
-	if err != nil {
-		t.Fatal("TempDir failed: ", err)
-	}
-	defer os.RemoveAll(tmp)
-
+	tmp := t.TempDir()
 	printpathExe := buildPrintPathExe(t, tmp)
 
 	// Run all tests.
-- 
GitLab


From 5811605df9011ae415b25be70045ed7a302a5e37 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Thu, 8 Apr 2021 17:03:18 -0400
Subject: [PATCH 1452/2400] cmd/go: fix mod_list_update_nolatest on windows

Fixes #45456

Change-Id: I7d313d7fbe29813f2abb062b6feec43280c2d283
Reviewed-on: https://go-review.googlesource.com/c/go/+/308653
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go/testdata/script/mod_list_update_nolatest.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/go/testdata/script/mod_list_update_nolatest.txt b/src/cmd/go/testdata/script/mod_list_update_nolatest.txt
index 6d00f8ce1e..c6bbbb04ec 100644
--- a/src/cmd/go/testdata/script/mod_list_update_nolatest.txt
+++ b/src/cmd/go/testdata/script/mod_list_update_nolatest.txt
@@ -6,7 +6,7 @@
 # but has no /@latest (410) because the go.mod at the tip of the default
 # branch has a different major version suffix.
 env testproxy=$GOPROXY
-env GOPROXY=file://$WORK/proxy
+env GOPROXY=file:///$WORK/proxy
 env GOSUMDB=off
 
 # If the proxy does not return a list of versions (404/410)
-- 
GitLab


From 19034fa855783d78cc4c40d3708bcc01a8900a1d Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 8 Apr 2021 16:47:13 -0400
Subject: [PATCH 1453/2400] cmd/objdump: update test with register ABI

With register ABI, the disassembly of the function may not
contain a "movq" instruction (which used to be e.g. storing
arguments to stack). Look for "jmp" instruction instead. This is
also in consistent with the test for Go assembly syntax.

Change-Id: Ifc9e48bbc4f85c4e4aace5981b3a0f8ae925f6d6
Reviewed-on: https://go-review.googlesource.com/c/go/+/308652
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/objdump/objdump_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/objdump/objdump_test.go b/src/cmd/objdump/objdump_test.go
index 1748e13a53..ac184441ea 100644
--- a/src/cmd/objdump/objdump_test.go
+++ b/src/cmd/objdump/objdump_test.go
@@ -64,13 +64,13 @@ var x86Need = []string{ // for both 386 and AMD64
 }
 
 var amd64GnuNeed = []string{
-	"movq",
+	"jmp",
 	"callq",
 	"cmpb",
 }
 
 var i386GnuNeed = []string{
-	"mov",
+	"jmp",
 	"call",
 	"cmp",
 }
-- 
GitLab


From d25c4fbe05e88580ce0a5cadc67e1c0ee27a2d1c Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 8 Apr 2021 18:32:00 -0400
Subject: [PATCH 1454/2400] test: do not run softfloat test with regabiargs

Softfloat mode with register ABI is not implemented yet. In
particular, we did not rewrite the float types in AuxCalls to
integer types, so arguments are still passed in floating point
registers, which do not exist in softfloat mode. To make it work
I think we may want to reorder softfloat pass with expand_calls
pass. We also need to rewrite the OpArgFloatRegs for the spilling
of non-SSA-able arguments, which may involve renumbering interger
arguments. Maybe in softfloat mode we want to just define the
ABI with 0 float registers. They are not fundamentally hard, but
may be not worth doing for the moment, as we don't use softfloat
mode on AMD64 anyway.

Run the test with noregabiargs. Also in the compiler reject
-d=softfloat if regabiargs is enabled.

Change-Id: I8cc0c2cfa88a138bc1338ed8710670245f1bd2cd
Reviewed-on: https://go-review.googlesource.com/c/go/+/308710
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/gc/main.go | 3 +++
 test/fixedbugs/issue28688.go        | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 9199db830c..68506c7a7b 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -158,6 +158,9 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 		dwarf.EnableLogging(base.Debug.DwarfInl != 0)
 	}
 	if base.Debug.SoftFloat != 0 {
+		if objabi.Experiment.RegabiArgs {
+			log.Fatalf("softfloat mode with GOEXPERIMENT=regabiargs not implemented ")
+		}
 		ssagen.Arch.SoftFloat = true
 	}
 
diff --git a/test/fixedbugs/issue28688.go b/test/fixedbugs/issue28688.go
index 0d2000e149..8ef0802812 100644
--- a/test/fixedbugs/issue28688.go
+++ b/test/fixedbugs/issue28688.go
@@ -1,4 +1,4 @@
-// run -gcflags=-d=softfloat
+// run -gcflags=-d=softfloat -goexperiment noregabiargs
 
 // Copyright 2018 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
-- 
GitLab


From 8518aac3147da163ac5accfacbf0c30f684177e2 Mon Sep 17 00:00:00 2001
From: ian woolf <btw515wolf2@gmail.com>
Date: Thu, 8 Apr 2021 20:42:47 +0800
Subject: [PATCH 1455/2400] crypto/x509: replace os.MkdirTemp with T.TempDir

Updates #45402

Change-Id: Ifb1fa5232a0fa1be62e886643cec9deaa3b312ad
Reviewed-on: https://go-review.googlesource.com/c/go/+/308409
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/crypto/x509/root_unix_test.go | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/crypto/x509/root_unix_test.go b/src/crypto/x509/root_unix_test.go
index 38038a65f3..7118f12d74 100644
--- a/src/crypto/x509/root_unix_test.go
+++ b/src/crypto/x509/root_unix_test.go
@@ -147,11 +147,7 @@ func TestLoadSystemCertsLoadColonSeparatedDirs(t *testing.T) {
 		os.Setenv(certFileEnv, origFile)
 	}()
 
-	tmpDir, err := os.MkdirTemp(os.TempDir(), "x509-issue35325")
-	if err != nil {
-		t.Fatalf("Failed to create temporary directory: %v", err)
-	}
-	defer os.RemoveAll(tmpDir)
+	tmpDir := t.TempDir()
 
 	rootPEMs := []string{
 		geoTrustRoot,
-- 
GitLab


From 4d7d7a4c50ea0d16879458a032f1a05db2c7ae4f Mon Sep 17 00:00:00 2001
From: Manlio Perillo <manlio.perillo@gmail.com>
Date: Wed, 7 Apr 2021 21:27:27 +0200
Subject: [PATCH 1456/2400] os: replace os.MkdirTemp with T.TempDir

Updates #45402

Change-Id: Ib8e62a13ddff884e4d34b3a0fdc9a10db2b68da6
Reviewed-on: https://go-review.googlesource.com/c/go/+/308109
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/os/error_test.go        |  8 +-----
 src/os/fifo_test.go         |  7 +----
 src/os/os_test.go           | 38 +++++---------------------
 src/os/os_windows_test.go   | 28 +++++---------------
 src/os/path_test.go         | 17 +++---------
 src/os/path_windows_test.go | 24 +++++------------
 src/os/removeall_test.go    | 53 +++++++------------------------------
 src/os/stat_test.go         | 45 ++++++++-----------------------
 8 files changed, 45 insertions(+), 175 deletions(-)

diff --git a/src/os/error_test.go b/src/os/error_test.go
index 6264ccc966..58b3f391d1 100644
--- a/src/os/error_test.go
+++ b/src/os/error_test.go
@@ -54,13 +54,7 @@ func testErrNotExist(name string) string {
 }
 
 func TestErrIsNotExist(t *testing.T) {
-	tmpDir, err := os.MkdirTemp("", "_Go_ErrIsNotExist")
-	if err != nil {
-		t.Fatalf("create ErrIsNotExist tempdir: %s", err)
-		return
-	}
-	defer os.RemoveAll(tmpDir)
-
+	tmpDir := t.TempDir()
 	name := filepath.Join(tmpDir, "NotExists")
 	if s := testErrNotExist(name); s != "" {
 		t.Fatal(s)
diff --git a/src/os/fifo_test.go b/src/os/fifo_test.go
index c3607344ec..9b262f8205 100644
--- a/src/os/fifo_test.go
+++ b/src/os/fifo_test.go
@@ -31,12 +31,7 @@ func TestFifoEOF(t *testing.T) {
 		t.Skip("skipping on OpenBSD; issue 25877")
 	}
 
-	dir, err := os.MkdirTemp("", "TestFifoEOF")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
-
+	dir := t.TempDir()
 	fifoName := filepath.Join(dir, "fifo")
 	if err := syscall.Mkfifo(fifoName, 0600); err != nil {
 		t.Fatal(err)
diff --git a/src/os/os_test.go b/src/os/os_test.go
index f27c796c05..506f1fb0ee 100644
--- a/src/os/os_test.go
+++ b/src/os/os_test.go
@@ -617,11 +617,7 @@ func TestReaddirNValues(t *testing.T) {
 	if testing.Short() {
 		t.Skip("test.short; skipping")
 	}
-	dir, err := os.MkdirTemp("", "")
-	if err != nil {
-		t.Fatalf("TempDir: %v", err)
-	}
-	defer RemoveAll(dir)
+	dir := t.TempDir()
 	for i := 1; i <= 105; i++ {
 		f, err := Create(filepath.Join(dir, fmt.Sprintf("%d", i)))
 		if err != nil {
@@ -716,11 +712,7 @@ func TestReaddirStatFailures(t *testing.T) {
 		// testing it wouldn't work.
 		t.Skipf("skipping test on %v", runtime.GOOS)
 	}
-	dir, err := os.MkdirTemp("", "")
-	if err != nil {
-		t.Fatalf("TempDir: %v", err)
-	}
-	defer RemoveAll(dir)
+	dir := t.TempDir()
 	touch(t, filepath.Join(dir, "good1"))
 	touch(t, filepath.Join(dir, "x")) // will disappear or have an error
 	touch(t, filepath.Join(dir, "good2"))
@@ -1949,22 +1941,16 @@ func TestAppend(t *testing.T) {
 
 func TestStatDirWithTrailingSlash(t *testing.T) {
 	// Create new temporary directory and arrange to clean it up.
-	path, err := os.MkdirTemp("", "_TestStatDirWithSlash_")
-	if err != nil {
-		t.Fatalf("TempDir: %s", err)
-	}
-	defer RemoveAll(path)
+	path := t.TempDir()
 
 	// Stat of path should succeed.
-	_, err = Stat(path)
-	if err != nil {
+	if _, err := Stat(path); err != nil {
 		t.Fatalf("stat %s failed: %s", path, err)
 	}
 
 	// Stat of path+"/" should succeed too.
 	path += "/"
-	_, err = Stat(path)
-	if err != nil {
+	if _, err := Stat(path); err != nil {
 		t.Fatalf("stat %s failed: %s", path, err)
 	}
 }
@@ -2091,12 +2077,7 @@ func TestLargeWriteToConsole(t *testing.T) {
 func TestStatDirModeExec(t *testing.T) {
 	const mode = 0111
 
-	path, err := os.MkdirTemp("", "go-build")
-	if err != nil {
-		t.Fatalf("Failed to create temp directory: %v", err)
-	}
-	defer RemoveAll(path)
-
+	path := t.TempDir()
 	if err := Chmod(path, 0777); err != nil {
 		t.Fatalf("Chmod %q 0777: %v", path, err)
 	}
@@ -2160,12 +2141,7 @@ func TestStatStdin(t *testing.T) {
 func TestStatRelativeSymlink(t *testing.T) {
 	testenv.MustHaveSymlink(t)
 
-	tmpdir, err := os.MkdirTemp("", "TestStatRelativeSymlink")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer RemoveAll(tmpdir)
-
+	tmpdir := t.TempDir()
 	target := filepath.Join(tmpdir, "target")
 	f, err := Create(target)
 	if err != nil {
diff --git a/src/os/os_windows_test.go b/src/os/os_windows_test.go
index f310a75f39..195c30f50e 100644
--- a/src/os/os_windows_test.go
+++ b/src/os/os_windows_test.go
@@ -626,11 +626,7 @@ func TestOpenVolumeName(t *testing.T) {
 }
 
 func TestDeleteReadOnly(t *testing.T) {
-	tmpdir, err := os.MkdirTemp("", "TestDeleteReadOnly")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 	p := filepath.Join(tmpdir, "a")
 	// This sets FILE_ATTRIBUTE_READONLY.
 	f, err := os.OpenFile(p, os.O_CREATE, 0400)
@@ -796,11 +792,7 @@ func compareCommandLineToArgvWithSyscall(t *testing.T, cmd string) {
 }
 
 func TestCmdArgs(t *testing.T) {
-	tmpdir, err := os.MkdirTemp("", "TestCmdArgs")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	const prog = `
 package main
@@ -815,8 +807,7 @@ func main() {
 }
 `
 	src := filepath.Join(tmpdir, "main.go")
-	err = os.WriteFile(src, []byte(prog), 0666)
-	if err != nil {
+	if err := os.WriteFile(src, []byte(prog), 0666); err != nil {
 		t.Fatal(err)
 	}
 
@@ -963,21 +954,14 @@ func TestSymlinkCreation(t *testing.T) {
 	}
 	t.Parallel()
 
-	temp, err := os.MkdirTemp("", "TestSymlinkCreation")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(temp)
-
+	temp := t.TempDir()
 	dummyFile := filepath.Join(temp, "file")
-	err = os.WriteFile(dummyFile, []byte(""), 0644)
-	if err != nil {
+	if err := os.WriteFile(dummyFile, []byte(""), 0644); err != nil {
 		t.Fatal(err)
 	}
 
 	linkFile := filepath.Join(temp, "link")
-	err = os.Symlink(dummyFile, linkFile)
-	if err != nil {
+	if err := os.Symlink(dummyFile, linkFile); err != nil {
 		t.Fatal(err)
 	}
 }
diff --git a/src/os/path_test.go b/src/os/path_test.go
index b79d958711..4535abbc52 100644
--- a/src/os/path_test.go
+++ b/src/os/path_test.go
@@ -6,7 +6,6 @@ package os_test
 
 import (
 	"internal/testenv"
-	"os"
 	. "os"
 	"path/filepath"
 	"runtime"
@@ -78,27 +77,19 @@ func TestMkdirAll(t *testing.T) {
 func TestMkdirAllWithSymlink(t *testing.T) {
 	testenv.MustHaveSymlink(t)
 
-	tmpDir, err := os.MkdirTemp("", "TestMkdirAllWithSymlink-")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer RemoveAll(tmpDir)
-
+	tmpDir := t.TempDir()
 	dir := tmpDir + "/dir"
-	err = Mkdir(dir, 0755)
-	if err != nil {
+	if err := Mkdir(dir, 0755); err != nil {
 		t.Fatalf("Mkdir %s: %s", dir, err)
 	}
 
 	link := tmpDir + "/link"
-	err = Symlink("dir", link)
-	if err != nil {
+	if err := Symlink("dir", link); err != nil {
 		t.Fatalf("Symlink %s: %s", link, err)
 	}
 
 	path := link + "/foo"
-	err = MkdirAll(path, 0755)
-	if err != nil {
+	if err := MkdirAll(path, 0755); err != nil {
 		t.Errorf("MkdirAll %q: %s", path, err)
 	}
 }
diff --git a/src/os/path_windows_test.go b/src/os/path_windows_test.go
index a23a079f77..e960bcb19c 100644
--- a/src/os/path_windows_test.go
+++ b/src/os/path_windows_test.go
@@ -50,31 +50,21 @@ func TestFixLongPath(t *testing.T) {
 }
 
 func TestMkdirAllLongPath(t *testing.T) {
-	tmpDir, err := os.MkdirTemp("", "TestMkdirAllLongPath")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpDir)
+	tmpDir := t.TempDir()
 	path := tmpDir
 	for i := 0; i < 100; i++ {
 		path += `\another-path-component`
 	}
-	err = os.MkdirAll(path, 0777)
-	if err != nil {
+	if err := os.MkdirAll(path, 0777); err != nil {
 		t.Fatalf("MkdirAll(%q) failed; %v", path, err)
 	}
-	err = os.RemoveAll(tmpDir)
-	if err != nil {
+	if err := os.RemoveAll(tmpDir); err != nil {
 		t.Fatalf("RemoveAll(%q) failed; %v", tmpDir, err)
 	}
 }
 
 func TestMkdirAllExtendedLength(t *testing.T) {
-	tmpDir, err := os.MkdirTemp("", "TestMkdirAllExtendedLength")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpDir)
+	tmpDir := t.TempDir()
 
 	const prefix = `\\?\`
 	if len(tmpDir) < 4 || tmpDir[:4] != prefix {
@@ -85,14 +75,12 @@ func TestMkdirAllExtendedLength(t *testing.T) {
 		tmpDir = prefix + fullPath
 	}
 	path := tmpDir + `\dir\`
-	err = os.MkdirAll(path, 0777)
-	if err != nil {
+	if err := os.MkdirAll(path, 0777); err != nil {
 		t.Fatalf("MkdirAll(%q) failed: %v", path, err)
 	}
 
 	path = path + `.\dir2`
-	err = os.MkdirAll(path, 0777)
-	if err == nil {
+	if err := os.MkdirAll(path, 0777); err == nil {
 		t.Fatalf("MkdirAll(%q) should have failed, but did not", path)
 	}
 }
diff --git a/src/os/removeall_test.go b/src/os/removeall_test.go
index 3a2f6e3759..08dfdd8ec0 100644
--- a/src/os/removeall_test.go
+++ b/src/os/removeall_test.go
@@ -15,12 +15,7 @@ import (
 )
 
 func TestRemoveAll(t *testing.T) {
-	tmpDir, err := os.MkdirTemp("", "TestRemoveAll-")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer RemoveAll(tmpDir)
-
+	tmpDir := t.TempDir()
 	if err := RemoveAll(""); err != nil {
 		t.Errorf("RemoveAll(\"\"): %v; want nil", err)
 	}
@@ -128,12 +123,7 @@ func TestRemoveAllLarge(t *testing.T) {
 		t.Skip("skipping in short mode")
 	}
 
-	tmpDir, err := os.MkdirTemp("", "TestRemoveAll-")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer RemoveAll(tmpDir)
-
+	tmpDir := t.TempDir()
 	path := filepath.Join(tmpDir, "_TestRemoveAllLarge_")
 
 	// Make directory with 1000 files and remove.
@@ -236,12 +226,7 @@ func TestRemoveAllDot(t *testing.T) {
 func TestRemoveAllDotDot(t *testing.T) {
 	t.Parallel()
 
-	tempDir, err := os.MkdirTemp("", "TestRemoveAllDotDot-")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer RemoveAll(tempDir)
-
+	tempDir := t.TempDir()
 	subdir := filepath.Join(tempDir, "x")
 	subsubdir := filepath.Join(subdir, "y")
 	if err := MkdirAll(subsubdir, 0777); err != nil {
@@ -261,12 +246,7 @@ func TestRemoveAllDotDot(t *testing.T) {
 func TestRemoveReadOnlyDir(t *testing.T) {
 	t.Parallel()
 
-	tempDir, err := os.MkdirTemp("", "TestRemoveReadOnlyDir-")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer RemoveAll(tempDir)
-
+	tempDir := t.TempDir()
 	subdir := filepath.Join(tempDir, "x")
 	if err := Mkdir(subdir, 0); err != nil {
 		t.Fatal(err)
@@ -298,12 +278,7 @@ func TestRemoveAllButReadOnlyAndPathError(t *testing.T) {
 
 	t.Parallel()
 
-	tempDir, err := os.MkdirTemp("", "TestRemoveAllButReadOnly-")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer RemoveAll(tempDir)
-
+	tempDir := t.TempDir()
 	dirs := []string{
 		"a",
 		"a/x",
@@ -347,7 +322,7 @@ func TestRemoveAllButReadOnlyAndPathError(t *testing.T) {
 		defer Chmod(d, 0777)
 	}
 
-	err = RemoveAll(tempDir)
+	err := RemoveAll(tempDir)
 	if err == nil {
 		t.Fatal("RemoveAll succeeded unexpectedly")
 	}
@@ -389,12 +364,7 @@ func TestRemoveUnreadableDir(t *testing.T) {
 
 	t.Parallel()
 
-	tempDir, err := os.MkdirTemp("", "TestRemoveAllButReadOnly-")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer RemoveAll(tempDir)
-
+	tempDir := t.TempDir()
 	target := filepath.Join(tempDir, "d0", "d1", "d2")
 	if err := MkdirAll(target, 0755); err != nil {
 		t.Fatal(err)
@@ -413,12 +383,7 @@ func TestRemoveAllWithMoreErrorThanReqSize(t *testing.T) {
 		t.Skip("skipping in short mode")
 	}
 
-	tmpDir, err := os.MkdirTemp("", "TestRemoveAll-")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer RemoveAll(tmpDir)
-
+	tmpDir := t.TempDir()
 	path := filepath.Join(tmpDir, "_TestRemoveAllWithMoreErrorThanReqSize_")
 
 	// Make directory with 1025 read-only files.
@@ -443,7 +408,7 @@ func TestRemoveAllWithMoreErrorThanReqSize(t *testing.T) {
 
 	// This call should not hang, even on a platform that disallows file deletion
 	// from read-only directories.
-	err = RemoveAll(path)
+	err := RemoveAll(path)
 
 	if Getuid() == 0 {
 		// On many platforms, root can remove files from read-only directories.
diff --git a/src/os/stat_test.go b/src/os/stat_test.go
index c409f0ff18..8d99f64609 100644
--- a/src/os/stat_test.go
+++ b/src/os/stat_test.go
@@ -185,30 +185,22 @@ func testSymlinkSameFile(t *testing.T, path, link string) {
 func TestDirAndSymlinkStats(t *testing.T) {
 	testenv.MustHaveSymlink(t)
 
-	tmpdir, err := os.MkdirTemp("", "TestDirAndSymlinkStats")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
-
+	tmpdir := t.TempDir()
 	dir := filepath.Join(tmpdir, "dir")
-	err = os.Mkdir(dir, 0777)
-	if err != nil {
+	if err := os.Mkdir(dir, 0777); err != nil {
 		t.Fatal(err)
 	}
 	testDirStats(t, dir)
 
 	dirlink := filepath.Join(tmpdir, "link")
-	err = os.Symlink(dir, dirlink)
-	if err != nil {
+	if err := os.Symlink(dir, dirlink); err != nil {
 		t.Fatal(err)
 	}
 	testSymlinkStats(t, dirlink, true)
 	testSymlinkSameFile(t, dir, dirlink)
 
 	linklink := filepath.Join(tmpdir, "linklink")
-	err = os.Symlink(dirlink, linklink)
-	if err != nil {
+	if err := os.Symlink(dirlink, linklink); err != nil {
 		t.Fatal(err)
 	}
 	testSymlinkStats(t, linklink, true)
@@ -218,30 +210,22 @@ func TestDirAndSymlinkStats(t *testing.T) {
 func TestFileAndSymlinkStats(t *testing.T) {
 	testenv.MustHaveSymlink(t)
 
-	tmpdir, err := os.MkdirTemp("", "TestFileAndSymlinkStats")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
-
+	tmpdir := t.TempDir()
 	file := filepath.Join(tmpdir, "file")
-	err = os.WriteFile(file, []byte(""), 0644)
-	if err != nil {
+	if err := os.WriteFile(file, []byte(""), 0644); err != nil {
 		t.Fatal(err)
 	}
 	testFileStats(t, file)
 
 	filelink := filepath.Join(tmpdir, "link")
-	err = os.Symlink(file, filelink)
-	if err != nil {
+	if err := os.Symlink(file, filelink); err != nil {
 		t.Fatal(err)
 	}
 	testSymlinkStats(t, filelink, false)
 	testSymlinkSameFile(t, file, filelink)
 
 	linklink := filepath.Join(tmpdir, "linklink")
-	err = os.Symlink(filelink, linklink)
-	if err != nil {
+	if err := os.Symlink(filelink, linklink); err != nil {
 		t.Fatal(err)
 	}
 	testSymlinkStats(t, linklink, false)
@@ -252,20 +236,13 @@ func TestFileAndSymlinkStats(t *testing.T) {
 func TestSymlinkWithTrailingSlash(t *testing.T) {
 	testenv.MustHaveSymlink(t)
 
-	tmpdir, err := os.MkdirTemp("", "TestSymlinkWithTrailingSlash")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
-
+	tmpdir := t.TempDir()
 	dir := filepath.Join(tmpdir, "dir")
-	err = os.Mkdir(dir, 0777)
-	if err != nil {
+	if err := os.Mkdir(dir, 0777); err != nil {
 		t.Fatal(err)
 	}
 	dirlink := filepath.Join(tmpdir, "link")
-	err = os.Symlink(dir, dirlink)
-	if err != nil {
+	if err := os.Symlink(dir, dirlink); err != nil {
 		t.Fatal(err)
 	}
 	dirlinkWithSlash := dirlink + string(os.PathSeparator)
-- 
GitLab


From 519f223aa2b55372b473d1a883435b64b9f77365 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Thu, 8 Apr 2021 13:02:21 -0700
Subject: [PATCH 1457/2400] cmd/compile: reduce overhead of RParams in
 types.Type

Changed RParams in types.Type to be a pointer to a slice, rather than a
slice itself, in order to reduce it from three words to one words, since
the large majority of types will not be generic or instantiated from a
generic type.

Additional cleanup: remove operation OTYPEINST, which we don't have need
of, since all type instantiations are either handled by types2 or happen
automatically during some form of stenciling.

Both of these are useful cleanups before the Go 1.17 freeze.

Change-Id: I61ad56b3c698b30d2cb5a2cdd12263202c54f49c
Reviewed-on: https://go-review.googlesource.com/c/go/+/308770
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/ir/node.go           |  1 -
 src/cmd/compile/internal/ir/op_string.go      | 51 +++++++++----------
 src/cmd/compile/internal/types/sizeof_test.go |  2 +-
 src/cmd/compile/internal/types/type.go        | 27 +++++-----
 4 files changed, 41 insertions(+), 40 deletions(-)

diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 7bce0e985c..b6be74296f 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -285,7 +285,6 @@ const (
 	//   Left is nil if there is no type-switch variable
 	OTYPESW
 	OFUNCINST // instantiation of a generic function
-	OTYPEINST // instantiation of a generic type
 
 	// types
 	OTCHAN   // chan int
diff --git a/src/cmd/compile/internal/ir/op_string.go b/src/cmd/compile/internal/ir/op_string.go
index 65456df356..cfd36c7b3d 100644
--- a/src/cmd/compile/internal/ir/op_string.go
+++ b/src/cmd/compile/internal/ir/op_string.go
@@ -138,35 +138,34 @@ func _() {
 	_ = x[OSWITCH-127]
 	_ = x[OTYPESW-128]
 	_ = x[OFUNCINST-129]
-	_ = x[OTYPEINST-130]
-	_ = x[OTCHAN-131]
-	_ = x[OTMAP-132]
-	_ = x[OTSTRUCT-133]
-	_ = x[OTINTER-134]
-	_ = x[OTFUNC-135]
-	_ = x[OTARRAY-136]
-	_ = x[OTSLICE-137]
-	_ = x[OINLCALL-138]
-	_ = x[OEFACE-139]
-	_ = x[OITAB-140]
-	_ = x[OIDATA-141]
-	_ = x[OSPTR-142]
-	_ = x[OCFUNC-143]
-	_ = x[OCHECKNIL-144]
-	_ = x[OVARDEF-145]
-	_ = x[OVARKILL-146]
-	_ = x[OVARLIVE-147]
-	_ = x[ORESULT-148]
-	_ = x[OINLMARK-149]
-	_ = x[OLINKSYMOFFSET-150]
-	_ = x[OTAILCALL-151]
-	_ = x[OGETG-152]
-	_ = x[OEND-153]
+	_ = x[OTCHAN-130]
+	_ = x[OTMAP-131]
+	_ = x[OTSTRUCT-132]
+	_ = x[OTINTER-133]
+	_ = x[OTFUNC-134]
+	_ = x[OTARRAY-135]
+	_ = x[OTSLICE-136]
+	_ = x[OINLCALL-137]
+	_ = x[OEFACE-138]
+	_ = x[OITAB-139]
+	_ = x[OIDATA-140]
+	_ = x[OSPTR-141]
+	_ = x[OCFUNC-142]
+	_ = x[OCHECKNIL-143]
+	_ = x[OVARDEF-144]
+	_ = x[OVARKILL-145]
+	_ = x[OVARLIVE-146]
+	_ = x[ORESULT-147]
+	_ = x[OINLMARK-148]
+	_ = x[OLINKSYMOFFSET-149]
+	_ = x[OTAILCALL-150]
+	_ = x[OGETG-151]
+	_ = x[OEND-152]
 }
 
-const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWFUNCINSTTYPEINSTTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKLINKSYMOFFSETTAILCALLGETGEND"
+const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWFUNCINSTTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKLINKSYMOFFSETTAILCALLGETGEND"
 
-var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 388, 391, 400, 403, 407, 415, 422, 431, 444, 447, 450, 453, 456, 459, 462, 468, 471, 474, 480, 484, 487, 491, 496, 501, 507, 512, 516, 521, 529, 537, 543, 552, 563, 570, 574, 581, 589, 593, 597, 601, 608, 615, 623, 629, 637, 645, 650, 655, 659, 667, 672, 676, 679, 687, 691, 693, 698, 700, 705, 711, 717, 723, 729, 737, 745, 750, 754, 761, 767, 772, 778, 784, 791, 796, 800, 805, 809, 814, 822, 828, 835, 842, 848, 855, 868, 876, 880, 883}
+var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 388, 391, 400, 403, 407, 415, 422, 431, 444, 447, 450, 453, 456, 459, 462, 468, 471, 474, 480, 484, 487, 491, 496, 501, 507, 512, 516, 521, 529, 537, 543, 552, 563, 570, 574, 581, 589, 593, 597, 601, 608, 615, 623, 629, 637, 645, 650, 655, 659, 667, 672, 676, 679, 687, 691, 693, 698, 700, 705, 711, 717, 723, 729, 737, 742, 746, 753, 759, 764, 770, 776, 783, 788, 792, 797, 801, 806, 814, 820, 827, 834, 840, 847, 860, 868, 872, 875}
 
 func (i Op) String() string {
 	if i >= Op(len(_Op_index)-1) {
diff --git a/src/cmd/compile/internal/types/sizeof_test.go b/src/cmd/compile/internal/types/sizeof_test.go
index 4c3ef69346..7028938742 100644
--- a/src/cmd/compile/internal/types/sizeof_test.go
+++ b/src/cmd/compile/internal/types/sizeof_test.go
@@ -21,7 +21,7 @@ func TestSizeof(t *testing.T) {
 		_64bit uintptr     // size on 64bit platforms
 	}{
 		{Sym{}, 44, 72},
-		{Type{}, 68, 120},
+		{Type{}, 60, 104},
 		{Map{}, 20, 40},
 		{Forward{}, 20, 32},
 		{Func{}, 28, 48},
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 969195b850..88fc409733 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -178,16 +178,13 @@ type Type struct {
 
 	flags bitset8
 
-	// For defined (named) generic types, the list of type params (in order)
-	// of this type that need to be instantiated. For fully-instantiated
-	// generic types, this is the targs used to instantiate them (which are
-	// used when generating the corresponding instantiated methods). rparams
-	// is only set for named types that are generic or are fully-instantiated
-	// from a generic type.
-
-	// TODO(danscales): for space reasons, should probably be a pointer to a
-	// slice, possibly change the name of this field.
-	rparams []*Type
+	// For defined (named) generic types, a pointer to the list of type params
+	// (in order) of this type that need to be instantiated. For
+	// fully-instantiated generic types, this is the targs used to instantiate
+	// them (which are used when generating the corresponding instantiated
+	// methods). rparams is only set for named types that are generic or are
+	// fully-instantiated from a generic type, and is otherwise set to nil.
+	rparams *[]*Type
 }
 
 func (*Type) CanBeAnSSAAux() {}
@@ -244,11 +241,17 @@ func (t *Type) Pos() src.XPos {
 }
 
 func (t *Type) RParams() []*Type {
-	return t.rparams
+	if t.rparams == nil {
+		return nil
+	}
+	return *t.rparams
 }
 
 func (t *Type) SetRParams(rparams []*Type) {
-	t.rparams = rparams
+	if len(rparams) == 0 {
+		base.Fatalf("Setting nil or zero-length rparams")
+	}
+	t.rparams = &rparams
 	if t.HasTParam() {
 		return
 	}
-- 
GitLab


From c432917061f6dc9e5e9bfa0745991f7291be794e Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Wed, 24 Feb 2021 16:47:58 +0100
Subject: [PATCH 1458/2400] cmd/link: link libgcc archive after mingw archives

When compiling with the race detector using modern mingw, this prevents:

    libgcc(.text): relocation target ___chkstk_ms not defined

Change-Id: I2095ad09a535505b54f9ff2d3075fd20ac85e515
Reviewed-on: https://go-review.googlesource.com/c/go/+/295910
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/link/internal/ld/lib.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index 4d5be30d82..46d238a318 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -603,9 +603,6 @@ func (ctxt *Link) loadlib() {
 				// errors - see if we can find libcompiler_rt.a instead.
 				*flagLibGCC = ctxt.findLibPathCmd("--print-file-name=libcompiler_rt.a", "libcompiler_rt")
 			}
-			if *flagLibGCC != "none" {
-				hostArchive(ctxt, *flagLibGCC)
-			}
 			if ctxt.HeadType == objabi.Hwindows {
 				if p := ctxt.findLibPath("libmingwex.a"); p != "none" {
 					hostArchive(ctxt, p)
@@ -627,6 +624,9 @@ func (ctxt *Link) loadlib() {
 					libmsvcrt.a libm.a
 				*/
 			}
+			if *flagLibGCC != "none" {
+				hostArchive(ctxt, *flagLibGCC)
+			}
 		}
 	}
 
-- 
GitLab


From dcc801ef815263eae7f0780a0bbc2f2e753599b0 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 9 Apr 2021 00:13:50 -0400
Subject: [PATCH 1459/2400] cmd/go/internal/modload: actually set the depth
 field passed to newRequirements

This was missed in CL 308515, and didn't show up in testing because so
few codepaths (and tests) actually depend on this behavior so far.

For #36460

Change-Id: I98b1962eb64d371884e15a3356c95f7ea80c7d21
Reviewed-on: https://go-review.googlesource.com/c/go/+/308810
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 src/cmd/go/internal/modload/buildlist.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index 24b2585a55..3fbe3c6700 100644
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -105,6 +105,7 @@ func newRequirements(depth modDepth, rootModules []module.Version, direct map[st
 	}
 
 	rs := &Requirements{
+		depth:          depth,
 		rootModules:    rootModules,
 		maxRootVersion: make(map[string]string, len(rootModules)),
 		direct:         direct,
-- 
GitLab


From d138ee2cfbd2be3edde22ad8a69da7657d0b0b7a Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Fri, 9 Apr 2021 09:49:15 -0400
Subject: [PATCH 1460/2400] test/abi: disable test on windows for now

This tickles some other bug, do this to clear builders.

Updates #40724.
Updates #45465.

Change-Id: Id51efbcf474865da231fcbc6216e5d604f99c296
Reviewed-on: https://go-review.googlesource.com/c/go/+/308889
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 test/abi/bad_select_crash.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/abi/bad_select_crash.go b/test/abi/bad_select_crash.go
index 58ca463cb8..7ad1d05a8c 100644
--- a/test/abi/bad_select_crash.go
+++ b/test/abi/bad_select_crash.go
@@ -1,5 +1,7 @@
 // build -goexperiment regabi,regabiargs
 
+//go:build !windows
+
 // Copyright 2021 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.
-- 
GitLab


From a690a5d75fee3b23e9ab80bd7b48cafb52ce4615 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Wed, 7 Apr 2021 09:58:02 -0400
Subject: [PATCH 1461/2400] cmd/compile: ensure spills of int/float reg args
 land in abi slots

We noticed a while ago that register argument spills were not always
landing where they should.

Updates #40724.

Change-Id: I0b7c3279a2f6270577481c252bae4568cbb6e796
Reviewed-on: https://go-review.googlesource.com/c/go/+/308510
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/stackalloc.go | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go
index 45058d4e72..025396f335 100644
--- a/src/cmd/compile/internal/ssa/stackalloc.go
+++ b/src/cmd/compile/internal/ssa/stackalloc.go
@@ -218,8 +218,15 @@ func (s *stackAllocState) stackalloc() {
 			// If this is a named value, try to use the name as
 			// the spill location.
 			var name LocalSlot
+			interfere := false
 			if v.Op == OpStoreReg {
-				name = names[v.Args[0].ID]
+				a := v.Args[0]
+				name = names[a.ID]
+				if name.N == nil && (a.Op == OpArgIntReg || a.Op == OpArgFloatReg) {
+					// Try harder to spill to the abi-provided spill slot, even if the names are messed up.
+					nameOff := a.Aux.(*AuxNameOffset)
+					name = LocalSlot{N: nameOff.Name, Type: v.Type, Off: nameOff.Offset}
+				}
 			} else {
 				name = names[v.ID]
 			}
@@ -230,6 +237,7 @@ func (s *stackAllocState) stackalloc() {
 						// A variable can interfere with itself.
 						// It is rare, but it can happen.
 						s.nSelfInterfere++
+						interfere = true
 						goto noname
 					}
 				}
@@ -271,7 +279,11 @@ func (s *stackAllocState) stackalloc() {
 			// Use the stack variable at that index for v.
 			loc := locs[i]
 			if f.pass.debug > stackDebug {
-				fmt.Printf("stackalloc %s to %s\n", v, loc)
+				reason := "noname"
+				if interfere {
+					reason = "interfere"
+				}
+				fmt.Printf("stackalloc (%s) %s to %s\n", reason, v, loc)
 			}
 			f.setHome(v, loc)
 			slots[v.ID] = i
-- 
GitLab


From 77b3269fb57d2f5c19a76a80f1d215dc801be3b7 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Thu, 8 Apr 2021 17:16:13 -0400
Subject: [PATCH 1462/2400] cmd/go: in TestScript, set GOTRACEBACK and use
 SIGQUIT to terminate hung subprocesses

This should produce more useful outputs if a cmd/go invocation hangs
during a test.

(In some cases the outputs will be very verbose, but verbose is still
better than uninformative.)

For #36460
For #38768

Change-Id: Ibaf2d0fbf7387dfab1aad8981140ecb11901fc4b
Reviewed-on: https://go-review.googlesource.com/c/go/+/308809
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/script_test.go     | 15 ++-------------
 src/cmd/go/stop_other_test.go | 33 +++++++++++++++++++++++++++++++++
 src/cmd/go/stop_unix_test.go  | 17 +++++++++++++++++
 3 files changed, 52 insertions(+), 13 deletions(-)
 create mode 100644 src/cmd/go/stop_other_test.go
 create mode 100644 src/cmd/go/stop_unix_test.go

diff --git a/src/cmd/go/script_test.go b/src/cmd/go/script_test.go
index c353a9cb01..20d0f956a7 100644
--- a/src/cmd/go/script_test.go
+++ b/src/cmd/go/script_test.go
@@ -172,6 +172,7 @@ func (ts *testScript) setup() {
 		"GOPRIVATE=",
 		"GOROOT=" + testGOROOT,
 		"GOROOT_FINAL=" + os.Getenv("GOROOT_FINAL"), // causes spurious rebuilds and breaks the "stale" built-in if not propagated
+		"GOTRACEBACK=all",
 		"TESTGO_GOROOT=" + testGOROOT,
 		"GOSUMDB=" + testSumDBVerifierKey,
 		"GONOPROXY=",
@@ -1120,24 +1121,12 @@ func (ts *testScript) startBackground(want simpleStatus, command string, args ..
 	}
 
 	go func() {
-		bg.err = waitOrStop(ts.ctx, cmd, stopSignal(), ts.gracePeriod)
+		bg.err = waitOrStop(ts.ctx, cmd, quitSignal(), ts.gracePeriod)
 		close(done)
 	}()
 	return bg, nil
 }
 
-// stopSignal returns the appropriate signal to use to request that a process
-// stop execution.
-func stopSignal() os.Signal {
-	if runtime.GOOS == "windows" {
-		// Per https://golang.org/pkg/os/#Signal, “Interrupt is not implemented on
-		// Windows; using it with os.Process.Signal will return an error.”
-		// Fall back to Kill instead.
-		return os.Kill
-	}
-	return os.Interrupt
-}
-
 // waitOrStop waits for the already-started command cmd by calling its Wait method.
 //
 // If cmd does not return before ctx is done, waitOrStop sends it the given interrupt signal.
diff --git a/src/cmd/go/stop_other_test.go b/src/cmd/go/stop_other_test.go
new file mode 100644
index 0000000000..e1cc6cf8ba
--- /dev/null
+++ b/src/cmd/go/stop_other_test.go
@@ -0,0 +1,33 @@
+// Copyright 2021 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.
+
+//go:build !(aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris)
+// +build !aix
+// +build !darwin
+// +build !dragonfly
+// +build !freebsd
+// +build !js !wasm
+// +build !linux
+// +build !netbsd
+// +build !openbsd
+// +build !solaris
+
+package main_test
+
+import (
+	"os"
+	"runtime"
+)
+
+// quitSignal returns the appropriate signal to use to request that a process
+// quit execution.
+func quitSignal() os.Signal {
+	if runtime.GOOS == "windows" {
+		// Per https://golang.org/pkg/os/#Signal, “Interrupt is not implemented on
+		// Windows; using it with os.Process.Signal will return an error.”
+		// Fall back to Kill instead.
+		return os.Kill
+	}
+	return os.Interrupt
+}
diff --git a/src/cmd/go/stop_unix_test.go b/src/cmd/go/stop_unix_test.go
new file mode 100644
index 0000000000..ac35b240f0
--- /dev/null
+++ b/src/cmd/go/stop_unix_test.go
@@ -0,0 +1,17 @@
+// Copyright 2021 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.
+
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
+// +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris
+
+package main_test
+
+import (
+	"os"
+	"syscall"
+)
+
+func quitSignal() os.Signal {
+	return syscall.SIGQUIT
+}
-- 
GitLab


From 6951da56b0ae2cd4250fc1b0350d090aed633ac1 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Fri, 9 Apr 2021 14:53:33 +0000
Subject: [PATCH 1463/2400] Revert "cmd/compile: ensure spills of int/float reg
 args land in abi slots"

This reverts CL 308510.

Reason for revert: It breaks "GOEXPERIMENT=regabi,regabiargs ./make.bash"

Change-Id: I553654690ec73120f8a6258dd80623853c430df0
Reviewed-on: https://go-review.googlesource.com/c/go/+/308932
Trust: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/stackalloc.go | 16 ++--------------
 1 file changed, 2 insertions(+), 14 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go
index 025396f335..45058d4e72 100644
--- a/src/cmd/compile/internal/ssa/stackalloc.go
+++ b/src/cmd/compile/internal/ssa/stackalloc.go
@@ -218,15 +218,8 @@ func (s *stackAllocState) stackalloc() {
 			// If this is a named value, try to use the name as
 			// the spill location.
 			var name LocalSlot
-			interfere := false
 			if v.Op == OpStoreReg {
-				a := v.Args[0]
-				name = names[a.ID]
-				if name.N == nil && (a.Op == OpArgIntReg || a.Op == OpArgFloatReg) {
-					// Try harder to spill to the abi-provided spill slot, even if the names are messed up.
-					nameOff := a.Aux.(*AuxNameOffset)
-					name = LocalSlot{N: nameOff.Name, Type: v.Type, Off: nameOff.Offset}
-				}
+				name = names[v.Args[0].ID]
 			} else {
 				name = names[v.ID]
 			}
@@ -237,7 +230,6 @@ func (s *stackAllocState) stackalloc() {
 						// A variable can interfere with itself.
 						// It is rare, but it can happen.
 						s.nSelfInterfere++
-						interfere = true
 						goto noname
 					}
 				}
@@ -279,11 +271,7 @@ func (s *stackAllocState) stackalloc() {
 			// Use the stack variable at that index for v.
 			loc := locs[i]
 			if f.pass.debug > stackDebug {
-				reason := "noname"
-				if interfere {
-					reason = "interfere"
-				}
-				fmt.Printf("stackalloc (%s) %s to %s\n", reason, v, loc)
+				fmt.Printf("stackalloc %s to %s\n", v, loc)
 			}
 			f.setHome(v, loc)
 			slots[v.ID] = i
-- 
GitLab


From d11968012c81e6eef3a1f3ff4c19a610222fc305 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Fri, 9 Apr 2021 12:53:27 -0400
Subject: [PATCH 1464/2400] test/abi: disable test with old-style build tag
 known to run.go

A quick check of the source to run.go suggests that it does not
look for the new-style build tags.

Updates #45465.

Change-Id: Ib4be040935d71e732f81d52c4a22c2b514195f40
Reviewed-on: https://go-review.googlesource.com/c/go/+/308934
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: David Chase <drchase@google.com>
---
 test/abi/bad_select_crash.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/abi/bad_select_crash.go b/test/abi/bad_select_crash.go
index 7ad1d05a8c..7786a56a02 100644
--- a/test/abi/bad_select_crash.go
+++ b/test/abi/bad_select_crash.go
@@ -1,5 +1,6 @@
 // build -goexperiment regabi,regabiargs
 
+// +build !windows
 //go:build !windows
 
 // Copyright 2021 The Go Authors. All rights reserved.
-- 
GitLab


From 2698be4905c9d54a0d6a7d7d6e90284a9d76b82a Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Thu, 8 Apr 2021 17:41:24 -0400
Subject: [PATCH 1465/2400] runtime: use sigpanic0 on all OSes

With the register ABI, it's important to inject sigpanic0 instead of
sigpanic so we can set up function entry registers. This was already
happening on most OSes. This CL gets the remaining ones.

Change-Id: I6bc4d912b6497e03ed54d0a9c1eae8fd099d2cea
Reviewed-on: https://go-review.googlesource.com/c/go/+/308930
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/os3_plan9.go      | 2 +-
 src/runtime/signal_windows.go | 2 +-
 src/runtime/stubs.go          | 6 ++++--
 3 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/runtime/os3_plan9.go b/src/runtime/os3_plan9.go
index b6ee98cab6..c5dc23de8b 100644
--- a/src/runtime/os3_plan9.go
+++ b/src/runtime/os3_plan9.go
@@ -100,7 +100,7 @@ func sighandler(_ureg *ureg, note *byte, gp *g) int {
 		if usesLR {
 			c.setpc(funcPC(sigpanictramp))
 		} else {
-			c.setpc(funcPC(sigpanic))
+			c.setpc(funcPC(sigpanic0))
 		}
 		return _NCONT
 	}
diff --git a/src/runtime/signal_windows.go b/src/runtime/signal_windows.go
index 63158f0bc4..f2ce24d735 100644
--- a/src/runtime/signal_windows.go
+++ b/src/runtime/signal_windows.go
@@ -145,7 +145,7 @@ func exceptionhandler(info *exceptionrecord, r *context, gp *g) int32 {
 			*((*uintptr)(sp)) = r.ip()
 		}
 	}
-	r.set_ip(funcPC(sigpanic))
+	r.set_ip(funcPC(sigpanic0))
 	return _EXCEPTION_CONTINUE_EXECUTION
 }
 
diff --git a/src/runtime/stubs.go b/src/runtime/stubs.go
index f11ec539df..f635d942e4 100644
--- a/src/runtime/stubs.go
+++ b/src/runtime/stubs.go
@@ -394,8 +394,10 @@ func duffcopy()
 // Called from linker-generated .initarray; declared for go vet; do NOT call from Go.
 func addmoduledata()
 
-// Injected by the signal handler for panicking signals. On many platforms it just
-// jumps to sigpanic.
+// Injected by the signal handler for panicking signals.
+// Initializes any registers that have fixed meaning at calls but
+// are scratch in bodies and calls sigpanic.
+// On many platforms it just jumps to sigpanic.
 func sigpanic0()
 
 // intArgRegs is used by the various register assignment
-- 
GitLab


From 0ad46889a140c3b2e72b8aa4a47ac242571c521f Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Thu, 8 Apr 2021 17:38:25 -0400
Subject: [PATCH 1466/2400] cmd/compile/abi-internal: declare X15 scratch in
 function bodies

X15 must be zero at function calls and returns, but can be used as
scratch in the middle of a function. This allows things like memmove
and the hashing functions to use X15 temporarily, as long as they set
it back to 0 before returning.

This CL also clarifies the distinction between register meanings on
function call versus function return, since some of them have fixed
meanings at both call and return, while others only have a fixed
meaning at calls.

Updates #40724.

Change-Id: I9dad3abde42cd4d2788e8435cde6d55073dd75a3
Reviewed-on: https://go-review.googlesource.com/c/go/+/308929
Trust: Austin Clements <austin@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/abi-internal.md | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/abi-internal.md b/src/cmd/compile/abi-internal.md
index b457f6ee74..aa61fcc544 100644
--- a/src/cmd/compile/abi-internal.md
+++ b/src/cmd/compile/abi-internal.md
@@ -401,16 +401,16 @@ without corrupting arguments or results.
 
 Special-purpose registers are as follows:
 
-| Register | Call meaning | Body meaning |
+| Register | Call meaning | Return meaning | Body meaning |
 | --- | --- | --- |
-| RSP | Stack pointer | Fixed |
-| RBP | Frame pointer | Fixed |
-| RDX | Closure context pointer | Scratch |
-| R12 | None | Scratch |
-| R13 | None | Scratch |
-| R14 | Current goroutine | Scratch |
-| R15 | GOT reference temporary | Fixed if dynlink |
-| X15 | Zero value | Fixed |
+| RSP | Stack pointer | Same | Same |
+| RBP | Frame pointer | Same | Same |
+| RDX | Closure context pointer | Scratch | Scratch |
+| R12 | Scratch | Scratch | Scratch |
+| R13 | Scratch | Scratch | Scratch |
+| R14 | Current goroutine | Same | Scratch |
+| R15 | GOT reference temporary if dynlink | Same | Same |
+| X15 | Zero value | Same | Scratch |
 
 *Rationale*: These register meanings are compatible with Go’s
 stack-based calling convention except for R14 and X15, which will have
@@ -428,6 +428,10 @@ single-byte registers available to be a net win.
 functions often have to bulk zero their stack frames, and this is more
 efficient with a designated zero register.
 
+*Implementation note*: Registers with fixed meaning at calls but not
+in function bodies must be initialized by "injected" calls such as
+signal-based panics.
+
 #### Stack layout
 
 The stack pointer, RSP, grows down and is always aligned to 8 bytes.
-- 
GitLab


From fcf8a6640b1bfb2444749b558f926321841922fa Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Fri, 9 Apr 2021 13:55:18 -0400
Subject: [PATCH 1467/2400] cmd/compile/abi-internal: declare R14 completely
 fixed

Currently, we allow R14, the current goroutine pointer, to be
clobbered in function bodies as long as the function restores it. This
is unnecessary complexity and could lead to confusing inconsistencies
with other architectures that can't simply restore it from TLS.

Updates #40724.

Change-Id: I4c052f0dd0b31d31afeb0c5aff05c314d7a852f3
Reviewed-on: https://go-review.googlesource.com/c/go/+/309009
Trust: Austin Clements <austin@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/abi-internal.md | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/abi-internal.md b/src/cmd/compile/abi-internal.md
index aa61fcc544..f901e707be 100644
--- a/src/cmd/compile/abi-internal.md
+++ b/src/cmd/compile/abi-internal.md
@@ -408,7 +408,7 @@ Special-purpose registers are as follows:
 | RDX | Closure context pointer | Scratch | Scratch |
 | R12 | Scratch | Scratch | Scratch |
 | R13 | Scratch | Scratch | Scratch |
-| R14 | Current goroutine | Same | Scratch |
+| R14 | Current goroutine | Same | Same |
 | R15 | GOT reference temporary if dynlink | Same | Same |
 | X15 | Zero value | Same | Scratch |
 
@@ -424,6 +424,13 @@ While this adds one byte to every function prologue, it is hardly ever
 accessed outside the function prologue and we expect making more
 single-byte registers available to be a net win.
 
+*Rationale*: We could allow R14 (the current goroutine pointer) to be
+a scratch register in function bodies because it can always be
+restored from TLS on amd64.
+However, we designate it as a fixed register for simplicity and for
+consistency with other architectures that may not have a copy of the
+current goroutine pointer in TLS.
+
 *Rationale*: We designate X15 as a fixed zero register because
 functions often have to bulk zero their stack frames, and this is more
 efficient with a designated zero register.
-- 
GitLab


From 952187af12485eb665ae122f6d0bdb36e4a11ed7 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Wed, 31 Mar 2021 14:29:13 -0400
Subject: [PATCH 1468/2400] cmd/go: upgrade and vendor golang.org/x/mod

To pull in CL 301089.

For #40357

Change-Id: I8aa9bc8d7a75f804adc7982adaaa1c926b43d0ef
Reviewed-on: https://go-review.googlesource.com/c/go/+/306333
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go.mod                                |  2 +-
 src/cmd/go.sum                                |  4 +-
 .../vendor/golang.org/x/mod/modfile/rule.go   | 51 +++++++++++++++----
 src/cmd/vendor/modules.txt                    |  2 +-
 4 files changed, 45 insertions(+), 14 deletions(-)

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index 5fbcf642f4..ad899ab4bd 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -6,7 +6,7 @@ require (
 	github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5
 	golang.org/x/arch v0.0.0-20210308155006-05f8f0431f72
 	golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 // indirect
-	golang.org/x/mod v0.4.3-0.20210323215154-1cc8812c1740
+	golang.org/x/mod v0.4.3-0.20210409134425-858fdbee9c24
 	golang.org/x/sys v0.0.0-20210309074719-68d13333faf2 // indirect
 	golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d
 	golang.org/x/tools v0.1.1-0.20210312185553-8e4f4c86593a
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 391e99ca99..84f42376a3 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -14,8 +14,8 @@ golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPh
 golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 h1:/ZScEX8SfEmUGRHs0gxpqteO5nfNW6axyZbBdw9A12g=
 golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
 golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.4.3-0.20210323215154-1cc8812c1740 h1:UYbWz0ISU1ccVf+FK/BRuwA4LGw2SzoambF9r5ozR/E=
-golang.org/x/mod v0.4.3-0.20210323215154-1cc8812c1740/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.3-0.20210409134425-858fdbee9c24 h1:XWBCOnD7qf8cYkORdr1AfVspwadsirSDgThkrje7nWs=
+golang.org/x/mod v0.4.3-0.20210409134425-858fdbee9c24/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
diff --git a/src/cmd/vendor/golang.org/x/mod/modfile/rule.go b/src/cmd/vendor/golang.org/x/mod/modfile/rule.go
index f8c9384985..3f603fa60f 100644
--- a/src/cmd/vendor/golang.org/x/mod/modfile/rule.go
+++ b/src/cmd/vendor/golang.org/x/mod/modfile/rule.go
@@ -47,8 +47,9 @@ type File struct {
 
 // A Module is the module statement.
 type Module struct {
-	Mod    module.Version
-	Syntax *Line
+	Mod        module.Version
+	Deprecated string
+	Syntax     *Line
 }
 
 // A Go is the go statement.
@@ -131,8 +132,15 @@ var dontFixRetract VersionFixer = func(_, vers string) (string, error) {
 	return vers, nil
 }
 
-// Parse parses the data, reported in errors as being from file,
-// into a File struct. It applies fix, if non-nil, to canonicalize all module versions found.
+// Parse parses and returns a go.mod file.
+//
+// file is the name of the file, used in positions and errors.
+//
+// data is the content of the file.
+//
+// fix is an optional function that canonicalizes module versions.
+// If fix is nil, all module versions must be canonical (module.CanonicalVersion
+// must return the same string).
 func Parse(file string, data []byte, fix VersionFixer) (*File, error) {
 	return parseToFile(file, data, fix, true)
 }
@@ -271,7 +279,11 @@ func (f *File) add(errs *ErrorList, block *LineBlock, line *Line, verb string, a
 			errorf("repeated module statement")
 			return
 		}
-		f.Module = &Module{Syntax: line}
+		deprecated := parseDeprecation(block, line)
+		f.Module = &Module{
+			Syntax:     line,
+			Deprecated: deprecated,
+		}
 		if len(args) != 1 {
 			errorf("usage: module module/path")
 			return
@@ -385,7 +397,7 @@ func (f *File) add(errs *ErrorList, block *LineBlock, line *Line, verb string, a
 		})
 
 	case "retract":
-		rationale := parseRetractRationale(block, line)
+		rationale := parseDirectiveComment(block, line)
 		vi, err := parseVersionInterval(verb, "", &args, dontFixRetract)
 		if err != nil {
 			if strict {
@@ -612,10 +624,29 @@ func parseString(s *string) (string, error) {
 	return t, nil
 }
 
-// parseRetractRationale extracts the rationale for a retract directive from the
-// surrounding comments. If the line does not have comments and is part of a
-// block that does have comments, the block's comments are used.
-func parseRetractRationale(block *LineBlock, line *Line) string {
+var deprecatedRE = lazyregexp.New(`(?s)(?:^|\n\n)Deprecated: *(.*?)(?:$|\n\n)`)
+
+// parseDeprecation extracts the text of comments on a "module" directive and
+// extracts a deprecation message from that.
+//
+// A deprecation message is contained in a paragraph within a block of comments
+// that starts with "Deprecated:" (case sensitive). The message runs until the
+// end of the paragraph and does not include the "Deprecated:" prefix. If the
+// comment block has multiple paragraphs that start with "Deprecated:",
+// parseDeprecation returns the message from the first.
+func parseDeprecation(block *LineBlock, line *Line) string {
+	text := parseDirectiveComment(block, line)
+	m := deprecatedRE.FindStringSubmatch(text)
+	if m == nil {
+		return ""
+	}
+	return m[1]
+}
+
+// parseDirectiveComment extracts the text of comments on a directive.
+// If the directive's line does not have comments and is part of a block that
+// does have comments, the block's comments are used.
+func parseDirectiveComment(block *LineBlock, line *Line) string {
 	comments := line.Comment()
 	if block != nil && len(comments.Before) == 0 && len(comments.Suffix) == 0 {
 		comments = block.Comment()
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 4a128c7933..80ccb2bf24 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -27,7 +27,7 @@ golang.org/x/arch/x86/x86asm
 ## explicit
 golang.org/x/crypto/ed25519
 golang.org/x/crypto/ed25519/internal/edwards25519
-# golang.org/x/mod v0.4.3-0.20210323215154-1cc8812c1740
+# golang.org/x/mod v0.4.3-0.20210409134425-858fdbee9c24
 ## explicit
 golang.org/x/mod/internal/lazyregexp
 golang.org/x/mod/modfile
-- 
GitLab


From 814c5ff13810e800aeb67fd0371e21984d4d2c64 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Wed, 31 Mar 2021 14:47:59 -0400
Subject: [PATCH 1469/2400] cmd/go: support module deprecation

A module is deprecated if its author adds a comment containing a
paragraph starting with "Deprecated:" to its go.mod file. The comment
must appear immediately before the "module" directive or as a suffix
on the same line. The deprecation message runs from just after
"Deprecated:" to the end of the paragraph. This is implemented in
CL 301089.

'go list -m -u' loads deprecation messages from the latest version of
each module, not considering retractions (i.e., deprecations and
retractions are loaded from the same version). By default, deprecated
modules are printed with a "(deprecated)" suffix. The full deprecation
message is available in the -f and -json output.

'go get' prints deprecation warnings for modules named on the command
line. It also prints warnings for modules needed to build packages
named on the command line if those modules are direct dependencies of
the main module.

For #40357

Change-Id: Id81fb2b24710681b025becd6cd74f746f4378e78
Reviewed-on: https://go-review.googlesource.com/c/go/+/306334
Trust: Jay Conrod <jayconrod@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/alldocs.go                         |   2 +-
 src/cmd/go/internal/list/list.go              |   4 +-
 src/cmd/go/internal/modcmd/edit.go            |  14 ++-
 src/cmd/go/internal/modget/get.go             | 113 +++++++++++++-----
 src/cmd/go/internal/modinfo/info.go           |  33 +++--
 src/cmd/go/internal/modload/build.go          |  34 +++++-
 src/cmd/go/internal/modload/buildlist.go      |   6 +
 src/cmd/go/internal/modload/list.go           |   4 +
 src/cmd/go/internal/modload/modfile.go        |  38 ++++++
 .../mod/example.com_deprecated_a_v1.0.0.txt   |  12 ++
 .../mod/example.com_deprecated_a_v1.9.0.txt   |  14 +++
 .../mod/example.com_deprecated_b_v1.0.0.txt   |  12 ++
 .../mod/example.com_deprecated_b_v1.9.0.txt   |  14 +++
 .../mod/example.com_undeprecated_v1.0.0.txt   |  14 +++
 .../mod/example.com_undeprecated_v1.0.1.txt   |  14 +++
 .../testdata/script/mod_deprecate_message.txt |  73 +++++++++++
 src/cmd/go/testdata/script/mod_edit.txt       |  18 +++
 .../go/testdata/script/mod_get_deprecated.txt |  66 ++++++++++
 .../testdata/script/mod_list_deprecated.txt   |  52 ++++++++
 .../script/mod_list_deprecated_replace.txt    |  68 +++++++++++
 20 files changed, 550 insertions(+), 55 deletions(-)
 create mode 100644 src/cmd/go/testdata/mod/example.com_deprecated_a_v1.0.0.txt
 create mode 100644 src/cmd/go/testdata/mod/example.com_deprecated_a_v1.9.0.txt
 create mode 100644 src/cmd/go/testdata/mod/example.com_deprecated_b_v1.0.0.txt
 create mode 100644 src/cmd/go/testdata/mod/example.com_deprecated_b_v1.9.0.txt
 create mode 100644 src/cmd/go/testdata/mod/example.com_undeprecated_v1.0.0.txt
 create mode 100644 src/cmd/go/testdata/mod/example.com_undeprecated_v1.0.1.txt
 create mode 100644 src/cmd/go/testdata/script/mod_deprecate_message.txt
 create mode 100644 src/cmd/go/testdata/script/mod_get_deprecated.txt
 create mode 100644 src/cmd/go/testdata/script/mod_list_deprecated.txt
 create mode 100644 src/cmd/go/testdata/script/mod_list_deprecated_replace.txt

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index 3fece365e8..a713428bc2 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -1135,7 +1135,7 @@
 //
 // 	type Module struct {
 // 		Path string
-// 		Version string
+// 		Deprecated string
 // 	}
 //
 // 	type GoMod struct {
diff --git a/src/cmd/go/internal/list/list.go b/src/cmd/go/internal/list/list.go
index 898a39ea24..9b78a64d5f 100644
--- a/src/cmd/go/internal/list/list.go
+++ b/src/cmd/go/internal/list/list.go
@@ -348,7 +348,7 @@ func runList(ctx context.Context, cmd *base.Command, args []string) {
 		if *listM {
 			*listFmt = "{{.String}}"
 			if *listVersions {
-				*listFmt = `{{.Path}}{{range .Versions}} {{.}}{{end}}`
+				*listFmt = `{{.Path}}{{range .Versions}} {{.}}{{end}}{{if .Deprecated}} (deprecated){{end}}`
 			}
 		} else {
 			*listFmt = "{{.ImportPath}}"
@@ -453,7 +453,7 @@ func runList(ctx context.Context, cmd *base.Command, args []string) {
 
 		var mode modload.ListMode
 		if *listU {
-			mode |= modload.ListU | modload.ListRetracted
+			mode |= modload.ListU | modload.ListRetracted | modload.ListDeprecated
 		}
 		if *listRetracted {
 			mode |= modload.ListRetracted
diff --git a/src/cmd/go/internal/modcmd/edit.go b/src/cmd/go/internal/modcmd/edit.go
index 1df104eb1d..e1ec088f55 100644
--- a/src/cmd/go/internal/modcmd/edit.go
+++ b/src/cmd/go/internal/modcmd/edit.go
@@ -86,7 +86,7 @@ writing it back to go.mod. The JSON output corresponds to these Go types:
 
 	type Module struct {
 		Path string
-		Version string
+		Deprecated string
 	}
 
 	type GoMod struct {
@@ -450,7 +450,7 @@ func flagDropRetract(arg string) {
 
 // fileJSON is the -json output data structure.
 type fileJSON struct {
-	Module  module.Version
+	Module  editModuleJSON
 	Go      string `json:",omitempty"`
 	Require []requireJSON
 	Exclude []module.Version
@@ -458,6 +458,11 @@ type fileJSON struct {
 	Retract []retractJSON
 }
 
+type editModuleJSON struct {
+	Path       string
+	Deprecated string `json:",omitempty"`
+}
+
 type requireJSON struct {
 	Path     string
 	Version  string `json:",omitempty"`
@@ -479,7 +484,10 @@ type retractJSON struct {
 func editPrintJSON(modFile *modfile.File) {
 	var f fileJSON
 	if modFile.Module != nil {
-		f.Module = modFile.Module.Mod
+		f.Module = editModuleJSON{
+			Path:       modFile.Module.Mod.Path,
+			Deprecated: modFile.Module.Deprecated,
+		}
 	}
 	if modFile.Go != nil {
 		f.Go = modFile.Go.Version
diff --git a/src/cmd/go/internal/modget/get.go b/src/cmd/go/internal/modget/get.go
index c6e380b197..876d8ab24d 100644
--- a/src/cmd/go/internal/modget/get.go
+++ b/src/cmd/go/internal/modget/get.go
@@ -354,7 +354,7 @@ func runGet(ctx context.Context, cmd *base.Command, args []string) {
 			pkgPatterns = append(pkgPatterns, q.pattern)
 		}
 	}
-	r.checkPackagesAndRetractions(ctx, pkgPatterns)
+	r.checkPackageProblems(ctx, pkgPatterns)
 
 	// We've already downloaded modules (and identified direct and indirect
 	// dependencies) by loading packages in findAndUpgradeImports.
@@ -1463,25 +1463,31 @@ func (r *resolver) chooseArbitrarily(cs pathSet) (isPackage bool, m module.Versi
 	return false, cs.mod
 }
 
-// checkPackagesAndRetractions reloads packages for the given patterns and
-// reports missing and ambiguous package errors. It also reports loads and
-// reports retractions for resolved modules and modules needed to build
-// named packages.
+// checkPackageProblems reloads packages for the given patterns and reports
+// missing and ambiguous package errors. It also reports retractions and
+// deprecations for resolved modules and modules needed to build named packages.
 //
 // We skip missing-package errors earlier in the process, since we want to
 // resolve pathSets ourselves, but at that point, we don't have enough context
 // to log the package-import chains leading to each error.
-func (r *resolver) checkPackagesAndRetractions(ctx context.Context, pkgPatterns []string) {
+func (r *resolver) checkPackageProblems(ctx context.Context, pkgPatterns []string) {
 	defer base.ExitIfErrors()
 
-	// Build a list of modules to load retractions for. Start with versions
-	// selected based on command line queries.
-	//
-	// This is a subset of the build list. If the main module has a lot of
-	// dependencies, loading retractions for the entire build list would be slow.
-	relevantMods := make(map[module.Version]struct{})
+	// Gather information about modules we might want to load retractions and
+	// deprecations for. Loading this metadata requires at least one version
+	// lookup per module, and we don't want to load information that's neither
+	// relevant nor actionable.
+	type modFlags int
+	const (
+		resolved modFlags = 1 << iota // version resolved by 'go get'
+		named                         // explicitly named on command line or provides a named package
+		hasPkg                        // needed to build named packages
+		direct                        // provides a direct dependency of the main module
+	)
+	relevantMods := make(map[module.Version]modFlags)
 	for path, reason := range r.resolvedVersion {
-		relevantMods[module.Version{Path: path, Version: reason.version}] = struct{}{}
+		m := module.Version{Path: path, Version: reason.version}
+		relevantMods[m] |= resolved
 	}
 
 	// Reload packages, reporting errors for missing and ambiguous imports.
@@ -1518,44 +1524,89 @@ func (r *resolver) checkPackagesAndRetractions(ctx context.Context, pkgPatterns
 				base.SetExitStatus(1)
 				if ambiguousErr := (*modload.AmbiguousImportError)(nil); errors.As(err, &ambiguousErr) {
 					for _, m := range ambiguousErr.Modules {
-						relevantMods[m] = struct{}{}
+						relevantMods[m] |= hasPkg
 					}
 				}
 			}
 			if m := modload.PackageModule(pkg); m.Path != "" {
-				relevantMods[m] = struct{}{}
+				relevantMods[m] |= hasPkg
+			}
+		}
+		for _, match := range matches {
+			for _, pkg := range match.Pkgs {
+				m := modload.PackageModule(pkg)
+				relevantMods[m] |= named
 			}
 		}
 	}
 
-	// Load and report retractions.
-	type retraction struct {
-		m   module.Version
-		err error
-	}
-	retractions := make([]retraction, 0, len(relevantMods))
+	reqs := modload.LoadModFile(ctx)
 	for m := range relevantMods {
-		retractions = append(retractions, retraction{m: m})
+		if reqs.IsDirect(m.Path) {
+			relevantMods[m] |= direct
+		}
 	}
-	sort.Slice(retractions, func(i, j int) bool {
-		return retractions[i].m.Path < retractions[j].m.Path
-	})
-	for i := 0; i < len(retractions); i++ {
+
+	// Load retractions for modules mentioned on the command line and modules
+	// needed to build named packages. We care about retractions of indirect
+	// dependencies, since we might be able to upgrade away from them.
+	type modMessage struct {
+		m       module.Version
+		message string
+	}
+	retractions := make([]modMessage, 0, len(relevantMods))
+	for m, flags := range relevantMods {
+		if flags&(resolved|named|hasPkg) != 0 {
+			retractions = append(retractions, modMessage{m: m})
+		}
+	}
+	sort.Slice(retractions, func(i, j int) bool { return retractions[i].m.Path < retractions[j].m.Path })
+	for i := range retractions {
 		i := i
 		r.work.Add(func() {
 			err := modload.CheckRetractions(ctx, retractions[i].m)
 			if retractErr := (*modload.ModuleRetractedError)(nil); errors.As(err, &retractErr) {
-				retractions[i].err = err
+				retractions[i].message = err.Error()
 			}
 		})
 	}
+
+	// Load deprecations for modules mentioned on the command line. Only load
+	// deprecations for indirect dependencies if they're also direct dependencies
+	// of the main module. Deprecations of purely indirect dependencies are
+	// not actionable.
+	deprecations := make([]modMessage, 0, len(relevantMods))
+	for m, flags := range relevantMods {
+		if flags&(resolved|named) != 0 || flags&(hasPkg|direct) == hasPkg|direct {
+			deprecations = append(deprecations, modMessage{m: m})
+		}
+	}
+	sort.Slice(deprecations, func(i, j int) bool { return deprecations[i].m.Path < deprecations[j].m.Path })
+	for i := range deprecations {
+		i := i
+		r.work.Add(func() {
+			deprecation, err := modload.CheckDeprecation(ctx, deprecations[i].m)
+			if err != nil || deprecation == "" {
+				return
+			}
+			deprecations[i].message = modload.ShortMessage(deprecation, "")
+		})
+	}
+
 	<-r.work.Idle()
+
+	// Report deprecations, then retractions.
+	for _, mm := range deprecations {
+		if mm.message != "" {
+			fmt.Fprintf(os.Stderr, "go: warning: module %s is deprecated: %s\n", mm.m.Path, mm.message)
+		}
+	}
 	var retractPath string
-	for _, r := range retractions {
-		if r.err != nil {
-			fmt.Fprintf(os.Stderr, "go: warning: %v\n", r.err)
+	for _, mm := range retractions {
+		if mm.message != "" {
+			fmt.Fprintf(os.Stderr, "go: warning: %v\n", mm.message)
 			if retractPath == "" {
-				retractPath = r.m.Path
+				retractPath = mm.m.Path
 			} else {
 				retractPath = "<module>"
 			}
diff --git a/src/cmd/go/internal/modinfo/info.go b/src/cmd/go/internal/modinfo/info.go
index 897be56397..19088352f0 100644
--- a/src/cmd/go/internal/modinfo/info.go
+++ b/src/cmd/go/internal/modinfo/info.go
@@ -10,19 +10,20 @@ import "time"
 // and the fields are documented in the help text in ../list/list.go
 
 type ModulePublic struct {
-	Path      string        `json:",omitempty"` // module path
-	Version   string        `json:",omitempty"` // module version
-	Versions  []string      `json:",omitempty"` // available module versions
-	Replace   *ModulePublic `json:",omitempty"` // replaced by this module
-	Time      *time.Time    `json:",omitempty"` // time version was created
-	Update    *ModulePublic `json:",omitempty"` // available update (with -u)
-	Main      bool          `json:",omitempty"` // is this the main module?
-	Indirect  bool          `json:",omitempty"` // module is only indirectly needed by main module
-	Dir       string        `json:",omitempty"` // directory holding local copy of files, if any
-	GoMod     string        `json:",omitempty"` // path to go.mod file describing module, if any
-	GoVersion string        `json:",omitempty"` // go version used in module
-	Retracted []string      `json:",omitempty"` // retraction information, if any (with -retracted or -u)
-	Error     *ModuleError  `json:",omitempty"` // error loading module
+	Path       string        `json:",omitempty"` // module path
+	Version    string        `json:",omitempty"` // module version
+	Versions   []string      `json:",omitempty"` // available module versions
+	Replace    *ModulePublic `json:",omitempty"` // replaced by this module
+	Time       *time.Time    `json:",omitempty"` // time version was created
+	Update     *ModulePublic `json:",omitempty"` // available update (with -u)
+	Main       bool          `json:",omitempty"` // is this the main module?
+	Indirect   bool          `json:",omitempty"` // module is only indirectly needed by main module
+	Dir        string        `json:",omitempty"` // directory holding local copy of files, if any
+	GoMod      string        `json:",omitempty"` // path to go.mod file describing module, if any
+	GoVersion  string        `json:",omitempty"` // go version used in module
+	Retracted  []string      `json:",omitempty"` // retraction information, if any (with -retracted or -u)
+	Deprecated string        `json:",omitempty"` // deprecation message, if any (with -u)
+	Error      *ModuleError  `json:",omitempty"` // error loading module
 }
 
 type ModuleError struct {
@@ -45,6 +46,9 @@ func (m *ModulePublic) String() string {
 			s += " [" + versionString(m.Update) + "]"
 		}
 	}
+	if m.Deprecated != "" {
+		s += " (deprecated)"
+	}
 	if m.Replace != nil {
 		s += " => " + m.Replace.Path
 		if m.Replace.Version != "" {
@@ -53,6 +57,9 @@ func (m *ModulePublic) String() string {
 				s += " [" + versionString(m.Replace.Update) + "]"
 			}
 		}
+		if m.Replace.Deprecated != "" {
+			s += " (deprecated)"
+		}
 	}
 	return s
 }
diff --git a/src/cmd/go/internal/modload/build.go b/src/cmd/go/internal/modload/build.go
index c3cac4d491..53771b2231 100644
--- a/src/cmd/go/internal/modload/build.go
+++ b/src/cmd/go/internal/modload/build.go
@@ -112,8 +112,8 @@ func addUpdate(ctx context.Context, m *modinfo.ModulePublic) {
 	info, err := Query(ctx, m.Path, "upgrade", m.Version, CheckAllowed)
 	var noVersionErr *NoMatchingVersionError
 	if errors.Is(err, fs.ErrNotExist) || errors.As(err, &noVersionErr) {
-		// Ignore "not found" and "no matching version" errors. This usually means
-		// the user is offline or the proxy doesn't have a matching version.
+		// Ignore "not found" and "no matching version" errors.
+		// This means the proxy has no matching version or no versions at all.
 		//
 		// We should report other errors though. An attacker that controls the
 		// network shouldn't be able to hide versions by interfering with
@@ -163,9 +163,8 @@ func addRetraction(ctx context.Context, m *modinfo.ModulePublic) {
 	var noVersionErr *NoMatchingVersionError
 	var retractErr *ModuleRetractedError
 	if err == nil || errors.Is(err, fs.ErrNotExist) || errors.As(err, &noVersionErr) {
-		// Ignore "not found" and "no matching version" errors. This usually means
-		// the user is offline or the proxy doesn't have a go.mod file that could
-		// contain retractions.
+		// Ignore "not found" and "no matching version" errors.
+		// This means the proxy has no matching version or no versions at all.
 		//
 		// We should report other errors though. An attacker that controls the
 		// network shouldn't be able to hide versions by interfering with
@@ -184,6 +183,31 @@ func addRetraction(ctx context.Context, m *modinfo.ModulePublic) {
 	}
 }
 
+// addDeprecation fills in m.Deprecated if the module was deprecated by its
+// author. m.Error is set if there's an error loading deprecation information.
+func addDeprecation(ctx context.Context, m *modinfo.ModulePublic) {
+	deprecation, err := CheckDeprecation(ctx, module.Version{Path: m.Path, Version: m.Version})
+	var noVersionErr *NoMatchingVersionError
+	if errors.Is(err, fs.ErrNotExist) || errors.As(err, &noVersionErr) {
+		// Ignore "not found" and "no matching version" errors.
+		// This means the proxy has no matching version or no versions at all.
+		//
+		// We should report other errors though. An attacker that controls the
+		// network shouldn't be able to hide versions by interfering with
+		// the HTTPS connection. An attacker that controls the proxy may still
+		// hide versions, since the "list" and "latest" endpoints are not
+		// authenticated.
+		return
+	}
+	if err != nil {
+		if m.Error == nil {
+			m.Error = &modinfo.ModuleError{Err: err.Error()}
+		}
+		return
+	}
+	m.Deprecated = deprecation
+}
+
 // moduleInfo returns information about module m, loaded from the requirements
 // in rs (which may be nil to indicate that m was not loaded from a requirement
 // graph).
diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index 3fbe3c6700..a1ac7b22b7 100644
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -191,6 +191,12 @@ func (rs *Requirements) Graph(ctx context.Context) (*ModuleGraph, error) {
 	return cached.mg, cached.err
 }
 
+// IsDirect returns whether the given module provides a package directly
+// imported by a package or test in the main module.
+func (rs *Requirements) IsDirect(path string) bool {
+	return rs.direct[path]
+}
+
 // A ModuleGraph represents the complete graph of module dependencies
 // of a main module.
 //
diff --git a/src/cmd/go/internal/modload/list.go b/src/cmd/go/internal/modload/list.go
index 6082bd5be8..e33078b53c 100644
--- a/src/cmd/go/internal/modload/list.go
+++ b/src/cmd/go/internal/modload/list.go
@@ -25,6 +25,7 @@ type ListMode int
 const (
 	ListU ListMode = 1 << iota
 	ListRetracted
+	ListDeprecated
 	ListVersions
 	ListRetractedVersions
 )
@@ -52,6 +53,9 @@ func ListModules(ctx context.Context, args []string, mode ListMode) ([]*modinfo.
 					if mode&ListRetracted != 0 {
 						addRetraction(ctx, m)
 					}
+					if mode&ListDeprecated != 0 {
+						addDeprecation(ctx, m)
+					}
 					<-sem
 				}()
 			}
diff --git a/src/cmd/go/internal/modload/modfile.go b/src/cmd/go/internal/modload/modfile.go
index 3b01afa13f..7b92a2b7ab 100644
--- a/src/cmd/go/internal/modload/modfile.go
+++ b/src/cmd/go/internal/modload/modfile.go
@@ -232,6 +232,42 @@ func ShortMessage(message, emptyDefault string) string {
 	return message
 }
 
+// CheckDeprecation returns a deprecation message from the go.mod file of the
+// latest version of the given module. Deprecation messages are comments
+// before or on the same line as the module directives that start with
+// "Deprecated:" and run until the end of the paragraph.
+//
+// CheckDeprecation returns an error if the message can't be loaded.
+// CheckDeprecation returns "", nil if there is no deprecation message.
+func CheckDeprecation(ctx context.Context, m module.Version) (deprecation string, err error) {
+	defer func() {
+		if err != nil {
+			err = fmt.Errorf("loading deprecation for %s: %w", m.Path, err)
+		}
+	}()
+
+	if m.Version == "" {
+		// Main module, standard library, or file replacement module.
+		// Don't look up deprecation.
+		return "", nil
+	}
+	if repl := Replacement(module.Version{Path: m.Path}); repl.Path != "" {
+		// All versions of the module were replaced.
+		// We'll look up deprecation separately for the replacement.
+		return "", nil
+	}
+
+	latest, err := queryLatestVersionIgnoringRetractions(ctx, m.Path)
+	if err != nil {
+		return "", err
+	}
+	summary, err := rawGoModSummary(latest)
+	if err != nil {
+		return "", err
+	}
+	return summary.deprecated, nil
+}
+
 // Replacement returns the replacement for mod, if any, from go.mod.
 // If there is no replacement for mod, Replacement returns
 // a module.Version with Path == "".
@@ -419,6 +455,7 @@ type modFileSummary struct {
 	goVersionV string // GoVersion with "v" prefix
 	require    []module.Version
 	retract    []retraction
+	deprecated string
 }
 
 // A retraction consists of a retracted version interval and rationale.
@@ -597,6 +634,7 @@ func rawGoModSummary(m module.Version) (*modFileSummary, error) {
 
 		if f.Module != nil {
 			summary.module = f.Module.Mod
+			summary.deprecated = f.Module.Deprecated
 		}
 		if f.Go != nil && f.Go.Version != "" {
 			rawGoVersion.LoadOrStore(m, f.Go.Version)
diff --git a/src/cmd/go/testdata/mod/example.com_deprecated_a_v1.0.0.txt b/src/cmd/go/testdata/mod/example.com_deprecated_a_v1.0.0.txt
new file mode 100644
index 0000000000..7c29621e83
--- /dev/null
+++ b/src/cmd/go/testdata/mod/example.com_deprecated_a_v1.0.0.txt
@@ -0,0 +1,12 @@
+-- .info --
+{"Version":"v1.0.0"}
+-- .mod --
+module example.com/deprecated/a
+
+go 1.17
+-- go.mod --
+module example.com/deprecated/a
+
+go 1.17
+-- a.go --
+package a
diff --git a/src/cmd/go/testdata/mod/example.com_deprecated_a_v1.9.0.txt b/src/cmd/go/testdata/mod/example.com_deprecated_a_v1.9.0.txt
new file mode 100644
index 0000000000..0613389d1f
--- /dev/null
+++ b/src/cmd/go/testdata/mod/example.com_deprecated_a_v1.9.0.txt
@@ -0,0 +1,14 @@
+-- .info --
+{"Version":"v1.9.0"}
+-- .mod --
+// Deprecated: in example.com/deprecated/a@v1.9.0
+module example.com/deprecated/a
+
+go 1.17
+-- go.mod --
+// Deprecated: in example.com/deprecated/a@v1.9.0
+module example.com/deprecated/a
+
+go 1.17
+-- a.go --
+package a
diff --git a/src/cmd/go/testdata/mod/example.com_deprecated_b_v1.0.0.txt b/src/cmd/go/testdata/mod/example.com_deprecated_b_v1.0.0.txt
new file mode 100644
index 0000000000..50006aefb5
--- /dev/null
+++ b/src/cmd/go/testdata/mod/example.com_deprecated_b_v1.0.0.txt
@@ -0,0 +1,12 @@
+-- .info --
+{"Version":"v1.0.0"}
+-- .mod --
+module example.com/deprecated/b
+
+go 1.17
+-- go.mod --
+module example.com/deprecated/b
+
+go 1.17
+-- b.go --
+package b
diff --git a/src/cmd/go/testdata/mod/example.com_deprecated_b_v1.9.0.txt b/src/cmd/go/testdata/mod/example.com_deprecated_b_v1.9.0.txt
new file mode 100644
index 0000000000..163d6b543e
--- /dev/null
+++ b/src/cmd/go/testdata/mod/example.com_deprecated_b_v1.9.0.txt
@@ -0,0 +1,14 @@
+-- .info --
+{"Version":"v1.9.0"}
+-- .mod --
+// Deprecated: in example.com/deprecated/b@v1.9.0
+module example.com/deprecated/b
+
+go 1.17
+-- go.mod --
+// Deprecated: in example.com/deprecated/b@v1.9.0
+module example.com/deprecated/b
+
+go 1.17
+-- b.go --
+package b
diff --git a/src/cmd/go/testdata/mod/example.com_undeprecated_v1.0.0.txt b/src/cmd/go/testdata/mod/example.com_undeprecated_v1.0.0.txt
new file mode 100644
index 0000000000..a68588eedb
--- /dev/null
+++ b/src/cmd/go/testdata/mod/example.com_undeprecated_v1.0.0.txt
@@ -0,0 +1,14 @@
+-- .info --
+{"Version":"v1.0.0"}
+-- .mod --
+// Deprecated: in v1.0.0
+module example.com/undeprecated
+
+go 1.17
+-- go.mod --
+// Deprecated: in v1.0.0
+module example.com/undeprecated
+
+go 1.17
+-- undeprecated.go --
+package undeprecated
diff --git a/src/cmd/go/testdata/mod/example.com_undeprecated_v1.0.1.txt b/src/cmd/go/testdata/mod/example.com_undeprecated_v1.0.1.txt
new file mode 100644
index 0000000000..ecabf322ec
--- /dev/null
+++ b/src/cmd/go/testdata/mod/example.com_undeprecated_v1.0.1.txt
@@ -0,0 +1,14 @@
+-- .info --
+{"Version":"v1.0.1"}
+-- .mod --
+// no longer deprecated
+module example.com/undeprecated
+
+go 1.17
+-- go.mod --
+// no longer deprecated
+module example.com/undeprecated
+
+go 1.17
+-- undeprecated.go --
+package undeprecated
diff --git a/src/cmd/go/testdata/script/mod_deprecate_message.txt b/src/cmd/go/testdata/script/mod_deprecate_message.txt
new file mode 100644
index 0000000000..4a0674b808
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_deprecate_message.txt
@@ -0,0 +1,73 @@
+# When there is a short single-line message, 'go get' should print it all.
+go get -d short
+stderr '^go: warning: module short is deprecated: short$'
+go list -m -u -f '{{.Deprecated}}' short
+stdout '^short$'
+
+# When there is a multi-line message, 'go get' should print the first line.
+go get -d multiline
+stderr '^go: warning: module multiline is deprecated: first line$'
+! stderr 'second line'
+go list -m -u -f '{{.Deprecated}}' multiline
+stdout '^first line\nsecond line.$'
+
+# When there is a long message, 'go get' should print a placeholder.
+go get -d long
+stderr '^go: warning: module long is deprecated: \(message omitted: too long\)$'
+go list -m -u -f '{{.Deprecated}}' long
+stdout '^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa$'
+
+# When a message contains unprintable chracters, 'go get' should say that
+# without printing the message.
+go get -d unprintable
+stderr '^go: warning: module unprintable is deprecated: \(message omitted: contains non-printable characters\)$'
+go list -m -u -f '{{.Deprecated}}' unprintable
+stdout '^message contains ASCII BEL\x07$'
+
+-- go.mod --
+module use
+
+go 1.16
+
+require (
+	short v0.0.0
+	multiline v0.0.0
+	long v0.0.0
+	unprintable v0.0.0
+)
+
+replace (
+	short v0.0.0 => ./short
+	multiline v0.0.0 => ./multiline
+	long v0.0.0 => ./long
+	unprintable v0.0.0 => ./unprintable
+)
+-- short/go.mod --
+// Deprecated: short
+module short
+
+go 1.16
+-- short/short.go --
+package short
+-- multiline/go.mod --
+// Deprecated: first line
+// second line.
+module multiline
+
+go 1.16
+-- multiline/multiline.go --
+package multiline
+-- long/go.mod --
+// Deprecated: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+module long
+
+go 1.16
+-- long/long.go --
+package long
+-- unprintable/go.mod --
+// Deprecated: message contains ASCII BEL
+module unprintable
+
+go 1.16
+-- unprintable/unprintable.go --
+package unprintable
diff --git a/src/cmd/go/testdata/script/mod_edit.txt b/src/cmd/go/testdata/script/mod_edit.txt
index 9da69306da..5aa5ca1ffc 100644
--- a/src/cmd/go/testdata/script/mod_edit.txt
+++ b/src/cmd/go/testdata/script/mod_edit.txt
@@ -46,6 +46,10 @@ cmpenv stdout $WORK/go.mod.json
 go mod edit -json $WORK/go.mod.retractrationale
 cmp stdout $WORK/go.mod.retractrationale.json
 
+# go mod edit -json (deprecation)
+go mod edit -json $WORK/go.mod.deprecation
+cmp stdout $WORK/go.mod.deprecation.json
+
 # go mod edit -json (empty mod file)
 go mod edit -json $WORK/go.mod.empty
 cmp stdout $WORK/go.mod.empty.json
@@ -290,6 +294,20 @@ retract (
 		}
 	]
 }
+-- $WORK/go.mod.deprecation --
+// Deprecated: and the new one is not ready yet
+module m
+-- $WORK/go.mod.deprecation.json --
+{
+	"Module": {
+		"Path": "m",
+		"Deprecated": "and the new one is not ready yet"
+	},
+	"Require": null,
+	"Exclude": null,
+	"Replace": null,
+	"Retract": null
+}
 -- $WORK/go.mod.empty --
 -- $WORK/go.mod.empty.json --
 {
diff --git a/src/cmd/go/testdata/script/mod_get_deprecated.txt b/src/cmd/go/testdata/script/mod_get_deprecated.txt
new file mode 100644
index 0000000000..4633009f69
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_get_deprecated.txt
@@ -0,0 +1,66 @@
+# 'go get pkg' should not show a deprecation message for an unrelated module.
+go get -d ./use/nothing
+! stderr 'module.*is deprecated'
+
+# 'go get pkg' should show a deprecation message for the module providing pkg.
+go get -d example.com/deprecated/a
+stderr '^go: warning: module example.com/deprecated/a is deprecated: in example.com/deprecated/a@v1.9.0$'
+go get -d example.com/deprecated/a@v1.0.0
+stderr '^go: warning: module example.com/deprecated/a is deprecated: in example.com/deprecated/a@v1.9.0$'
+
+# 'go get pkg' should show a deprecation message for a module providing
+# packages directly imported by pkg.
+go get -d ./use/a
+stderr '^go: warning: module example.com/deprecated/a is deprecated: in example.com/deprecated/a@v1.9.0$'
+
+# 'go get pkg' may show a deprecation message for an indirectly required module
+# if it provides a package named on the command line.
+go get -d ./use/b
+! stderr 'module.*is deprecated'
+go get -d local/use
+! stderr 'module.*is deprecated'
+go get -d example.com/deprecated/b
+stderr '^go: warning: module example.com/deprecated/b is deprecated: in example.com/deprecated/b@v1.9.0$'
+
+# 'go get pkg' does not show a deprecation message for a module providing a
+# directly imported package if the module is no longer deprecated in its
+# latest version, even if the module is deprecated in its current version.
+go get -d ./use/undeprecated
+! stderr 'module.*is deprecated'
+
+-- go.mod --
+module m
+
+go 1.17
+
+require (
+	example.com/deprecated/a v1.0.0
+	example.com/undeprecated v1.0.0
+	local v0.0.0
+)
+
+replace local v0.0.0 => ./local
+-- use/nothing/nothing.go --
+package nothing
+-- use/a/a.go --
+package a
+
+import _ "example.com/deprecated/a"
+-- use/b/b.go --
+package b
+
+import _ "local/use"
+-- use/undeprecated/undeprecated.go --
+package undeprecated
+
+import _ "example.com/undeprecated"
+-- local/go.mod --
+module local
+
+go 1.17
+
+require example.com/deprecated/b v1.0.0
+-- local/use/use.go --
+package use
+
+import _ "example.com/deprecated/b"
diff --git a/src/cmd/go/testdata/script/mod_list_deprecated.txt b/src/cmd/go/testdata/script/mod_list_deprecated.txt
new file mode 100644
index 0000000000..f0ecbba2ce
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_list_deprecated.txt
@@ -0,0 +1,52 @@
+# 'go list pkg' does not show deprecation.
+go list example.com/deprecated/a
+stdout '^example.com/deprecated/a$'
+
+# 'go list -m' does not show deprecation.
+go list -m example.com/deprecated/a
+stdout '^example.com/deprecated/a v1.9.0$'
+
+# 'go list -m -versions' does not show deprecation.
+go list -m -versions example.com/deprecated/a
+stdout '^example.com/deprecated/a v1.0.0 v1.9.0$'
+
+# 'go list -m -u' shows deprecation.
+go list -m -u example.com/deprecated/a
+stdout '^example.com/deprecated/a v1.9.0 \(deprecated\)$'
+
+# 'go list -m -u -f' exposes the deprecation message.
+go list -m -u -f {{.Deprecated}} example.com/deprecated/a
+stdout '^in example.com/deprecated/a@v1.9.0$'
+
+# This works even if we use an old version that does not have the deprecation
+# message in its go.mod file.
+go get -d example.com/deprecated/a@v1.0.0
+! grep Deprecated: $WORK/gopath/pkg/mod/cache/download/example.com/deprecated/a/@v/v1.0.0.mod
+go list -m -u -f {{.Deprecated}} example.com/deprecated/a
+stdout '^in example.com/deprecated/a@v1.9.0$'
+
+# 'go list -m -u' does not show deprecation for the main module.
+go list -m -u
+! stdout deprecated
+go list -m -u -f '{{if not .Deprecated}}ok{{end}}'
+stdout ok
+
+# 'go list -m -u' does not show a deprecation message for a module that is not
+# deprecated at the latest version, even if it is deprecated at the current
+# version.
+go list -m -u example.com/undeprecated
+stdout '^example.com/undeprecated v1.0.0 \[v1.0.1\]$'
+-- go.mod --
+// Deprecated: main module is deprecated, too!
+module example.com/use
+
+go 1.17
+
+require (
+	example.com/deprecated/a v1.9.0
+	example.com/undeprecated v1.0.0
+)
+-- go.sum --
+example.com/deprecated/a v1.9.0 h1:pRyvBIZheJpQVVnNW4Fdg8QuoqDgtkCreqZZbASV3BE=
+example.com/deprecated/a v1.9.0/go.mod h1:Z1uUVshSY9kh6l/2hZ8oA9SBviX2yfaeEpcLDz6AZwY=
+example.com/undeprecated v1.0.0/go.mod h1:1qiRbdA9VzJXDqlG26Y41O5Z7YyO+jAD9do8XCZQ+Gg=
diff --git a/src/cmd/go/testdata/script/mod_list_deprecated_replace.txt b/src/cmd/go/testdata/script/mod_list_deprecated_replace.txt
new file mode 100644
index 0000000000..48b991fc47
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_list_deprecated_replace.txt
@@ -0,0 +1,68 @@
+# When all versions are replaced, we should not look up a deprecation message.
+# We will still look up a deprecation message for the replacement.
+cp go.mod.allreplaced go.mod
+go list -m -u -f '{{.Path}}@{{.Version}} <{{.Deprecated}}>{{with .Replace}} => {{.Path}}@{{.Version}} <{{.Deprecated}}>{{end}}' all
+stdout '^example.com/deprecated/a@v1.0.0 <> => example.com/deprecated/b@v1.0.0 <in example.com/deprecated/b@v1.9.0>$'
+
+# When one version is replaced, we should see a deprecation message.
+cp go.mod.onereplaced go.mod
+go list -m -u -f '{{.Path}}@{{.Version}} <{{.Deprecated}}>{{with .Replace}} => {{.Path}}@{{.Version}} <{{.Deprecated}}>{{end}}' all
+stdout '^example.com/deprecated/a@v1.0.0 <in example.com/deprecated/a@v1.9.0> => example.com/deprecated/b@v1.0.0 <in example.com/deprecated/b@v1.9.0>$'
+
+# If the replacement is a directory, we won't look that up.
+cp go.mod.dirreplacement go.mod
+go list -m -u -f '{{.Path}}@{{.Version}} <{{.Deprecated}}>{{with .Replace}} => {{.Path}}@{{.Version}} <{{.Deprecated}}>{{end}}' all
+stdout '^example.com/deprecated/a@v1.0.0 <> => ./a@ <>$'
+
+# If the latest version of the replacement is replaced, we'll use the content
+# from that replacement.
+cp go.mod.latestreplaced go.mod
+go list -m -u -f '{{.Path}}@{{.Version}} <{{.Deprecated}}>{{with .Replace}} => {{.Path}}@{{.Version}} <{{.Deprecated}}>{{end}}' all
+stdout '^example.com/deprecated/a@v1.0.0 <> => example.com/deprecated/b@v1.0.0 <in ./b>$'
+
+-- go.mod.allreplaced --
+module m
+
+go 1.17
+
+require example.com/deprecated/a v1.0.0
+
+replace example.com/deprecated/a => example.com/deprecated/b v1.0.0
+-- go.mod.onereplaced --
+module m
+
+go 1.17
+
+require example.com/deprecated/a v1.0.0
+
+replace example.com/deprecated/a v1.0.0 => example.com/deprecated/b v1.0.0
+-- go.mod.dirreplacement --
+module m
+
+go 1.17
+
+require example.com/deprecated/a v1.0.0
+
+replace example.com/deprecated/a => ./a
+-- go.mod.latestreplaced --
+module m
+
+go 1.17
+
+require example.com/deprecated/a v1.0.0
+
+replace (
+	example.com/deprecated/a => example.com/deprecated/b v1.0.0
+	example.com/deprecated/b v1.9.0 => ./b
+)
+-- go.sum --
+example.com/deprecated/b v1.0.0/go.mod h1:b19J9ywRGviY7Nq4aJ1WBJ+A7qUlEY9ihp22yI4/F6M=
+-- a/go.mod --
+module example.com/deprecated/a
+
+go 1.17
+-- b/go.mod --
+// Deprecated: in ./b
+module example.com/deprecated/b
+
+go 1.17
-- 
GitLab


From c3faff7f2d62a81d612ed46204c2e6bd5f460f01 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 9 Apr 2021 00:39:25 -0400
Subject: [PATCH 1470/2400] cmd/go/internal/modload: change mvsReqs to store
 roots instead of a full build list

The mvsReqs implementation has always been a bit ambivalent about
whether the root requirements return the full build list, just the
direct requirements, or some hybrid of the two.

However, a full build list always requires the Target module as the
first entry, and it's easer to remove a redundant leading element from
a slice than to add one. Changing the mvsReqs field to contain
arbitrary roots instead of a full build list eliminates the need to
add redundant elements, at the cost of needing to remove redundant
elements in more places.

For #36460

Change-Id: Idd4c2d6bc7b66f67680037dab1fb9c2d1b40ab93
Reviewed-on: https://go-review.googlesource.com/c/go/+/308811
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/internal/modload/buildlist.go |  7 +++----
 src/cmd/go/internal/modload/edit.go      | 10 +++++-----
 src/cmd/go/internal/modload/mvs.go       |  4 ++--
 3 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index a1ac7b22b7..ad138887a0 100644
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -492,7 +492,7 @@ func editRequirements(ctx context.Context, rs *Requirements, add, mustSelect []m
 		// remove roots.)
 	}
 
-	min, err := mvs.Req(Target, rootPaths, &mvsReqs{buildList: final})
+	min, err := mvs.Req(Target, rootPaths, &mvsReqs{roots: final[1:]})
 	if err != nil {
 		return nil, false, err
 	}
@@ -610,7 +610,7 @@ func updateRoots(ctx context.Context, depth modDepth, direct map[string]bool, pk
 			// dependencies, then we can't reliably compute a minimal subset of them.
 			return rs, err
 		}
-		keep = mg.BuildList()
+		keep = mg.BuildList()[1:]
 
 		for _, root := range rs.rootModules {
 			// If the selected version of the root is the same as what was already
@@ -625,7 +625,6 @@ func updateRoots(ctx context.Context, depth modDepth, direct map[string]bool, pk
 			}
 		}
 	} else {
-		keep = append(keep, Target)
 		kept := map[module.Version]bool{Target: true}
 		for _, pkg := range pkgs {
 			if pkg.mod.Path != "" && !kept[pkg.mod] {
@@ -691,7 +690,7 @@ func updateRoots(ctx context.Context, depth modDepth, direct map[string]bool, pk
 		return rs, nil
 	}
 
-	min, err := mvs.Req(Target, rootPaths, &mvsReqs{buildList: keep})
+	min, err := mvs.Req(Target, rootPaths, &mvsReqs{roots: keep})
 	if err != nil {
 		return rs, err
 	}
diff --git a/src/cmd/go/internal/modload/edit.go b/src/cmd/go/internal/modload/edit.go
index 0d7811a3cd..858fec5dd5 100644
--- a/src/cmd/go/internal/modload/edit.go
+++ b/src/cmd/go/internal/modload/edit.go
@@ -49,7 +49,7 @@ func editBuildList(ctx context.Context, initial, tryUpgrade, mustSelect []module
 	// percieves as “downgrades” will not also result in upgrades.
 	max := make(map[string]string)
 	maxes, err := mvs.Upgrade(Target, &mvsReqs{
-		buildList: append(capVersionSlice(initial), mustSelect...),
+		roots: append(capVersionSlice(initial[1:]), mustSelect...),
 	}, tryUpgrade...)
 	if err != nil {
 		return nil, err
@@ -108,12 +108,12 @@ func editBuildList(ctx context.Context, initial, tryUpgrade, mustSelect []module
 	// another. The lower version may require extraneous dependencies that aren't
 	// actually relevant, so we need to compute the actual selected versions.
 	adjusted := make([]module.Version, 0, len(maxes))
-	for _, m := range maxes {
+	for _, m := range maxes[1:] {
 		if v, ok := limiter.selected[m.Path]; ok {
 			adjusted = append(adjusted, module.Version{Path: m.Path, Version: v})
 		}
 	}
-	consistent, err := mvs.BuildList(Target, &mvsReqs{buildList: adjusted})
+	consistent, err := mvs.BuildList(Target, &mvsReqs{roots: adjusted})
 	if err != nil {
 		return nil, err
 	}
@@ -122,7 +122,7 @@ func editBuildList(ctx context.Context, initial, tryUpgrade, mustSelect []module
 	// the actually-selected versions in order to eliminate extraneous
 	// dependencies from lower-than-selected ones.
 	compacted := consistent[:0]
-	for _, m := range consistent {
+	for _, m := range consistent[1:] {
 		if _, ok := limiter.selected[m.Path]; ok {
 			// The fact that the limiter has a version for m.Path indicates that we
 			// care about retaining that path, even if the version was upgraded for
@@ -131,7 +131,7 @@ func editBuildList(ctx context.Context, initial, tryUpgrade, mustSelect []module
 		}
 	}
 
-	return mvs.BuildList(Target, &mvsReqs{buildList: compacted})
+	return mvs.BuildList(Target, &mvsReqs{roots: compacted})
 }
 
 // A versionLimiter tracks the versions that may be selected for each module
diff --git a/src/cmd/go/internal/modload/mvs.go b/src/cmd/go/internal/modload/mvs.go
index 5f52017a74..87619b4ace 100644
--- a/src/cmd/go/internal/modload/mvs.go
+++ b/src/cmd/go/internal/modload/mvs.go
@@ -38,14 +38,14 @@ func cmpVersion(v1, v2 string) int {
 // mvsReqs implements mvs.Reqs for module semantic versions,
 // with any exclusions or replacements applied internally.
 type mvsReqs struct {
-	buildList []module.Version
+	roots []module.Version
 }
 
 func (r *mvsReqs) Required(mod module.Version) ([]module.Version, error) {
 	if mod == Target {
 		// Use the build list as it existed when r was constructed, not the current
 		// global build list.
-		return r.buildList[1:], nil
+		return r.roots, nil
 	}
 
 	if mod.Version == "none" {
-- 
GitLab


From 756e2b1529592ffbe1760932d14f8e6eae3fda06 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Fri, 9 Apr 2021 14:00:59 -0400
Subject: [PATCH 1471/2400] cmd/internal/objabi: make GOEXPERIMENT=none mean
 "no experiment flags"

CL 307819 made GOEXPERIMENT=none mean "restore baseline experiment
configuration". This is arguably what you want because any deviation
from the baseline configuration is an "experiment". However, cmd/dist
requires this to mean "disable all experiment flags", even if some
flags are enabled in the baseline configuration, because its build
system doesn't know how to deal with any enabled experiment flags.

Hence, make GOEXPERIMENT=none mean "disable all experiment flags"
again.

Change-Id: I1e282177c3f62a55eb9c36566c75672808dae9b6
Reviewed-on: https://go-review.googlesource.com/c/go/+/309010
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/internal/objabi/exp.go | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/cmd/internal/objabi/exp.go b/src/cmd/internal/objabi/exp.go
index 48201ae5ea..5ebbdac772 100644
--- a/src/cmd/internal/objabi/exp.go
+++ b/src/cmd/internal/objabi/exp.go
@@ -54,9 +54,10 @@ func parseExperiments() goexperiment.Flags {
 				continue
 			}
 			if f == "none" {
-				// GOEXPERIMENT=none restores the baseline configuration.
-				// (This is useful for overriding make.bash-time settings.)
-				flags = goexperiment.BaselineFlags
+				// GOEXPERIMENT=none disables all experiment flags.
+				// This is used by cmd/dist, which doesn't know how
+				// to build with any experiment flags.
+				flags = goexperiment.Flags{}
 				continue
 			}
 			val := true
-- 
GitLab


From 281d168e2debf7660f9ba5006ddbc1b4cda90ab7 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Fri, 9 Apr 2021 06:30:20 -0700
Subject: [PATCH 1472/2400] cmd/compile: don't set Ntype in noder2 anymore

Now that we are no longer calling the old typechecker at all during the
noder2 pass, we don't need to create and set an Ntype node ((which is
just a node representation of the type which we already know) for the
Name and Closure nodes. This should reduce memory usage a bit for -G=3.

Change-Id: I6b1345007ce067a89ee64955a53f25645c303f4d
Reviewed-on: https://go-review.googlesource.com/c/go/+/308909
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/inline/inl.go    | 10 ++++++++--
 src/cmd/compile/internal/noder/expr.go    |  2 --
 src/cmd/compile/internal/noder/object.go  |  3 ---
 src/cmd/compile/internal/noder/stencil.go |  6 +-----
 4 files changed, 9 insertions(+), 12 deletions(-)

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 1d049298d7..1941dc44bc 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -506,7 +506,10 @@ func inlcopy(n ir.Node) ir.Node {
 			newfn.Nname = ir.NewNameAt(oldfn.Nname.Pos(), oldfn.Nname.Sym())
 			// XXX OK to share fn.Type() ??
 			newfn.Nname.SetType(oldfn.Nname.Type())
-			newfn.Nname.Ntype = inlcopy(oldfn.Nname.Ntype).(ir.Ntype)
+			// Ntype can be nil for -G=3 mode.
+			if oldfn.Nname.Ntype != nil {
+				newfn.Nname.Ntype = inlcopy(oldfn.Nname.Ntype).(ir.Ntype)
+			}
 			newfn.Body = inlcopylist(oldfn.Body)
 			// Make shallow copy of the Dcl and ClosureVar slices
 			newfn.Dcl = append([]*ir.Name(nil), oldfn.Dcl...)
@@ -1213,7 +1216,10 @@ func (subst *inlsubst) closure(n *ir.ClosureExpr) ir.Node {
 	newfn.SetIsHiddenClosure(true)
 	newfn.Nname = ir.NewNameAt(n.Pos(), ir.BlankNode.Sym())
 	newfn.Nname.Func = newfn
-	newfn.Nname.Ntype = subst.node(oldfn.Nname.Ntype).(ir.Ntype)
+	// Ntype can be nil for -G=3 mode.
+	if oldfn.Nname.Ntype != nil {
+		newfn.Nname.Ntype = subst.node(oldfn.Nname.Ntype).(ir.Ntype)
+	}
 	newfn.Nname.Defn = newfn
 
 	m.(*ir.ClosureExpr).Func = newfn
diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index fc97df7197..b2c2616b35 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -360,8 +360,6 @@ func (g *irgen) funcLit(typ2 types2.Type, expr *syntax.FuncLit) ir.Node {
 	typ := g.typ(typ2)
 	fn.Nname.Func = fn
 	fn.Nname.Defn = fn
-	// Set Ntype for now to be compatible with later parts of compile, remove later.
-	fn.Nname.Ntype = ir.TypeNode(typ)
 	typed(typ, fn.Nname)
 	fn.SetTypecheck(1)
 
diff --git a/src/cmd/compile/internal/noder/object.go b/src/cmd/compile/internal/noder/object.go
index 6c8ed4af97..82cce1ace0 100644
--- a/src/cmd/compile/internal/noder/object.go
+++ b/src/cmd/compile/internal/noder/object.go
@@ -147,9 +147,6 @@ func (g *irgen) objFinish(name *ir.Name, class ir.Class, typ *types.Type) {
 		sym.SetFunc(true)
 	}
 
-	// We already know name's type, but typecheck is really eager to try
-	// recomputing it later. This appears to prevent that at least.
-	name.Ntype = ir.TypeNode(typ)
 	name.SetTypecheck(1)
 	name.SetWalkdef(1)
 
diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 0d84db9993..329c80098a 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -298,7 +298,6 @@ func (g *irgen) genericSubst(newsym *types.Sym, nameNode *ir.Name, targs []ir.No
 		subst.fields(ir.PPARAM, append(oldt.Recvs().FieldSlice(), oldt.Params().FieldSlice()...), newf.Dcl),
 		subst.fields(ir.PPARAMOUT, oldt.Results().FieldSlice(), newf.Dcl))
 
-	newf.Nname.Ntype = ir.TypeNode(newt)
 	newf.Nname.SetType(newt)
 	ir.MarkFunc(newf.Nname)
 	newf.SetTypecheck(1)
@@ -497,8 +496,7 @@ func (subst *subster) node(n ir.Node) ir.Node {
 
 		case ir.OCLOSURE:
 			x := x.(*ir.ClosureExpr)
-			// Need to save/duplicate x.Func.Nname,
-			// x.Func.Nname.Ntype, x.Func.Dcl, x.Func.ClosureVars, and
+			// Need to duplicate x.Func.Nname, x.Func.Dcl, x.Func.ClosureVars, and
 			// x.Func.Body.
 			oldfn := x.Func
 			newfn := ir.NewFunc(oldfn.Pos())
@@ -522,8 +520,6 @@ func (subst *subster) node(n ir.Node) ir.Node {
 			newfn.Dcl = subst.namelist(oldfn.Dcl)
 			newfn.ClosureVars = subst.namelist(oldfn.ClosureVars)
 
-			// Set Ntype for now to be compatible with later parts of compiler
-			newfn.Nname.Ntype = subst.node(oldfn.Nname.Ntype).(ir.Ntype)
 			typed(subst.typ(oldfn.Nname.Type()), newfn.Nname)
 			typed(newfn.Nname.Type(), m)
 			newfn.SetTypecheck(1)
-- 
GitLab


From 5305bdedb0be18c0636d2b4a707bf08228909c27 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Fri, 9 Apr 2021 19:00:42 -0400
Subject: [PATCH 1473/2400] test: do not run (another) softfloat test with
 regabiargs

I missed one in CL 308710.

Change-Id: Ia277eaba6982f4944992d1bee1e11775934b789f
Reviewed-on: https://go-review.googlesource.com/c/go/+/309151
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 test/fixedbugs/issue26163.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/fixedbugs/issue26163.go b/test/fixedbugs/issue26163.go
index 3f3d77859d..d141a2797d 100644
--- a/test/fixedbugs/issue26163.go
+++ b/test/fixedbugs/issue26163.go
@@ -1,4 +1,4 @@
-// compile -N -d=softfloat
+// compile -N -d=softfloat -goexperiment noregabiargs
 
 // Copyright 2018 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
-- 
GitLab


From 554d2c4f060ec42e30970dacff1e782250169323 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Fri, 9 Apr 2021 11:20:35 -0700
Subject: [PATCH 1474/2400] reflect: panic on New of go:notinheap type

For #42076
Fixes #45451

Change-Id: I69646226d3480d5403205412ddd13c0cfc2c8a53
Reviewed-on: https://go-review.googlesource.com/c/go/+/308970
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 misc/cgo/test/cgo_test.go |  1 +
 misc/cgo/test/test.go     | 19 +++++++++++++++++++
 src/reflect/value.go      |  7 ++++++-
 3 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/misc/cgo/test/cgo_test.go b/misc/cgo/test/cgo_test.go
index 837307263a..143f23f0e0 100644
--- a/misc/cgo/test/cgo_test.go
+++ b/misc/cgo/test/cgo_test.go
@@ -59,6 +59,7 @@ func Test28896(t *testing.T)                 { test28896(t) }
 func Test30065(t *testing.T)                 { test30065(t) }
 func Test32579(t *testing.T)                 { test32579(t) }
 func Test31891(t *testing.T)                 { test31891(t) }
+func Test45451(t *testing.T)                 { test45451(t) }
 func TestAlign(t *testing.T)                 { testAlign(t) }
 func TestAtol(t *testing.T)                  { testAtol(t) }
 func TestBlocking(t *testing.T)              { testBlocking(t) }
diff --git a/misc/cgo/test/test.go b/misc/cgo/test/test.go
index 76afa524c3..3b8f548b13 100644
--- a/misc/cgo/test/test.go
+++ b/misc/cgo/test/test.go
@@ -912,6 +912,9 @@ void cFunc37033(uintptr_t handle) { GoFunc37033(handle); }
 enum Enum40494 { X_40494 };
 union Union40494 { int x; };
 void issue40494(enum Enum40494 e, union Union40494* up) {}
+
+// Issue 45451, bad handling of go:notinheap types.
+typedef struct issue45451Undefined issue45451;
 */
 import "C"
 
@@ -2266,3 +2269,19 @@ var issue39877 *C.void = nil
 func Issue40494() {
 	C.issue40494(C.enum_Enum40494(C.X_40494), (*C.union_Union40494)(nil))
 }
+
+// Issue 45451.
+func test45451(t *testing.T) {
+	var u *C.issue45451
+	typ := reflect.ValueOf(u).Type().Elem()
+
+	// The type is undefined in C so allocating it should panic.
+	defer func() {
+		if r := recover(); r == nil {
+			t.Error("expected panic")
+		}
+	}()
+
+	_ = reflect.New(typ)
+	t.Errorf("reflect.New(%v) should have panicked", typ)
+}
diff --git a/src/reflect/value.go b/src/reflect/value.go
index 9670d4656b..7890c125d8 100644
--- a/src/reflect/value.go
+++ b/src/reflect/value.go
@@ -2702,9 +2702,14 @@ func New(typ Type) Value {
 		panic("reflect: New(nil)")
 	}
 	t := typ.(*rtype)
+	pt := t.ptrTo()
+	if ifaceIndir(pt) {
+		// This is a pointer to a go:notinheap type.
+		panic("reflect: New of type that may not be allocated in heap (possibly undefined cgo C type)")
+	}
 	ptr := unsafe_New(t)
 	fl := flag(Ptr)
-	return Value{t.ptrTo(), ptr, fl}
+	return Value{pt, ptr, fl}
 }
 
 // NewAt returns a Value representing a pointer to a value of the
-- 
GitLab


From 52bf14e0e8bdcd73f1ddfb0c4a1d0200097d3ba2 Mon Sep 17 00:00:00 2001
From: Naman Gera <namangera15@gmail.com>
Date: Fri, 9 Apr 2021 03:48:14 +0000
Subject: [PATCH 1475/2400] all: fix spellings

This follows the spelling choices that the Go project has made for English words.
https://github.com/golang/go/wiki/Spelling

Change-Id: Ie7c586d2cf23020cb492cfff58c0831d2d8d3a78
GitHub-Last-Rev: e16a32cd225a275f73d236bcb33703986d110ded
GitHub-Pull-Request: golang/go#45442
Reviewed-on: https://go-review.googlesource.com/c/go/+/308291
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 misc/cgo/test/issue6997_linux.go        | 8 +++++---
 src/context/context_test.go             | 4 ++--
 src/crypto/tls/handshake_server_test.go | 6 +++---
 src/database/sql/sql.go                 | 2 +-
 src/database/sql/sql_test.go            | 4 ++--
 src/net/http/client_test.go             | 2 +-
 src/net/http/httputil/dump_test.go      | 2 +-
 src/net/http/httputil/reverseproxy.go   | 2 +-
 src/net/http/pprof/pprof.go             | 2 +-
 src/net/http/transport.go               | 6 +++---
 10 files changed, 20 insertions(+), 18 deletions(-)

diff --git a/misc/cgo/test/issue6997_linux.go b/misc/cgo/test/issue6997_linux.go
index 0c98ea0794..f19afb8b7a 100644
--- a/misc/cgo/test/issue6997_linux.go
+++ b/misc/cgo/test/issue6997_linux.go
@@ -5,7 +5,7 @@
 // +build !android
 
 // Test that pthread_cancel works as expected
-// (NPTL uses SIGRTMIN to implement thread cancelation)
+// (NPTL uses SIGRTMIN to implement thread cancellation)
 // See https://golang.org/issue/6997
 package cgotest
 
@@ -17,8 +17,10 @@ extern int CancelThread();
 */
 import "C"
 
-import "testing"
-import "time"
+import (
+	"testing"
+	"time"
+)
 
 func test6997(t *testing.T) {
 	r := C.StartThread()
diff --git a/src/context/context_test.go b/src/context/context_test.go
index 84eef01da1..a2e2324a0e 100644
--- a/src/context/context_test.go
+++ b/src/context/context_test.go
@@ -661,7 +661,7 @@ func XTestWithCancelCanceledParent(t testingT) {
 		t.Errorf("child not done immediately upon construction")
 	}
 	if got, want := c.Err(), Canceled; got != want {
-		t.Errorf("child not cancelled; got = %v, want = %v", got, want)
+		t.Errorf("child not canceled; got = %v, want = %v", got, want)
 	}
 }
 
@@ -779,7 +779,7 @@ func XTestCustomContextGoroutines(t testingT) {
 	defer cancel6()
 	checkNoGoroutine()
 
-	// Check applied to cancelled context.
+	// Check applied to canceled context.
 	cancel6()
 	cancel1()
 	_, cancel7 := WithCancel(ctx5)
diff --git a/src/crypto/tls/handshake_server_test.go b/src/crypto/tls/handshake_server_test.go
index 432b4cfe35..756d288cb3 100644
--- a/src/crypto/tls/handshake_server_test.go
+++ b/src/crypto/tls/handshake_server_test.go
@@ -1989,7 +1989,7 @@ func TestServerHandshakeContextCancellation(t *testing.T) {
 // TestHandshakeContextHierarchy tests whether the contexts
 // available to GetClientCertificate and GetCertificate are
 // derived from the context provided to HandshakeContext, and
-// that those contexts are cancelled after HandshakeContext has
+// that those contexts are canceled after HandshakeContext has
 // returned.
 func TestHandshakeContextHierarchy(t *testing.T) {
 	c, s := localPipe(t)
@@ -2024,7 +2024,7 @@ func TestHandshakeContextHierarchy(t *testing.T) {
 		select {
 		case <-innerCtx.Done():
 		default:
-			t.Errorf("GetClientCertificate context was not cancelled after HandshakeContext returned.")
+			t.Errorf("GetClientCertificate context was not canceled after HandshakeContext returned.")
 		}
 	}()
 	var innerCtx context.Context
@@ -2048,7 +2048,7 @@ func TestHandshakeContextHierarchy(t *testing.T) {
 	select {
 	case <-innerCtx.Done():
 	default:
-		t.Errorf("GetCertificate context was not cancelled after HandshakeContext returned.")
+		t.Errorf("GetCertificate context was not canceled after HandshakeContext returned.")
 	}
 	if err := <-clientErr; err != nil {
 		t.Errorf("Unexpected client error: %v", err)
diff --git a/src/database/sql/sql.go b/src/database/sql/sql.go
index 12cc524c63..61b5018f0b 100644
--- a/src/database/sql/sql.go
+++ b/src/database/sql/sql.go
@@ -1795,7 +1795,7 @@ func (db *DB) beginDC(ctx context.Context, dc *driverConn, release func(error),
 		return nil, err
 	}
 
-	// Schedule the transaction to rollback when the context is cancelled.
+	// Schedule the transaction to rollback when the context is canceled.
 	// The cancel function in Tx will be called after done is set to true.
 	ctx, cancel := context.WithCancel(ctx)
 	tx = &Tx{
diff --git a/src/database/sql/sql_test.go b/src/database/sql/sql_test.go
index c06e565ea9..94af39c207 100644
--- a/src/database/sql/sql_test.go
+++ b/src/database/sql/sql_test.go
@@ -656,7 +656,7 @@ func TestPoolExhaustOnCancel(t *testing.T) {
 	db.SetMaxOpenConns(max)
 
 	// First saturate the connection pool.
-	// Then start new requests for a connection that is cancelled after it is requested.
+	// Then start new requests for a connection that is canceled after it is requested.
 
 	state = 1
 	for i := 0; i < max; i++ {
@@ -2784,7 +2784,7 @@ func TestTxCannotCommitAfterRollback(t *testing.T) {
 	// 3. Check if 2.A has committed in Tx (pass) or outside of Tx (fail).
 	sendQuery := make(chan struct{})
 	// The Tx status is returned through the row results, ensure
-	// that the rows results are not cancelled.
+	// that the rows results are not canceled.
 	bypassRowsAwaitDone = true
 	hookTxGrabConn = func() {
 		cancel()
diff --git a/src/net/http/client_test.go b/src/net/http/client_test.go
index 3b3d98ff9a..01d605c351 100644
--- a/src/net/http/client_test.go
+++ b/src/net/http/client_test.go
@@ -1945,7 +1945,7 @@ func TestClientDoCanceledVsTimeout_h2(t *testing.T) {
 }
 
 // Issue 33545: lock-in the behavior promised by Client.Do's
-// docs about request cancelation vs timing out.
+// docs about request cancellation vs timing out.
 func testClientDoCanceledVsTimeout(t *testing.T, h2 bool) {
 	defer afterTest(t)
 	cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
diff --git a/src/net/http/httputil/dump_test.go b/src/net/http/httputil/dump_test.go
index 8168b2ebc0..366cc8239a 100644
--- a/src/net/http/httputil/dump_test.go
+++ b/src/net/http/httputil/dump_test.go
@@ -478,7 +478,7 @@ func TestDumpResponse(t *testing.T) {
 	}
 }
 
-// Issue 38352: Check for deadlock on cancelled requests.
+// Issue 38352: Check for deadlock on canceled requests.
 func TestDumpRequestOutIssue38352(t *testing.T) {
 	if testing.Short() {
 		return
diff --git a/src/net/http/httputil/reverseproxy.go b/src/net/http/httputil/reverseproxy.go
index 4e369580ea..db42ac6ba5 100644
--- a/src/net/http/httputil/reverseproxy.go
+++ b/src/net/http/httputil/reverseproxy.go
@@ -562,7 +562,7 @@ func (p *ReverseProxy) handleUpgradeResponse(rw http.ResponseWriter, req *http.R
 
 	backConnCloseCh := make(chan bool)
 	go func() {
-		// Ensure that the cancelation of a request closes the backend.
+		// Ensure that the cancellation of a request closes the backend.
 		// See issue https://golang.org/issue/35559.
 		select {
 		case <-req.Context().Done():
diff --git a/src/net/http/pprof/pprof.go b/src/net/http/pprof/pprof.go
index a854fef5d3..888ea35c9a 100644
--- a/src/net/http/pprof/pprof.go
+++ b/src/net/http/pprof/pprof.go
@@ -287,7 +287,7 @@ func (name handler) serveDeltaProfile(w http.ResponseWriter, r *http.Request, p
 		err := r.Context().Err()
 		if err == context.DeadlineExceeded {
 			serveError(w, http.StatusRequestTimeout, err.Error())
-		} else { // TODO: what's a good status code for cancelled requests? 400?
+		} else { // TODO: what's a good status code for canceled requests? 400?
 			serveError(w, http.StatusInternalServerError, err.Error())
 		}
 		return
diff --git a/src/net/http/transport.go b/src/net/http/transport.go
index f30ca881ac..57018d2392 100644
--- a/src/net/http/transport.go
+++ b/src/net/http/transport.go
@@ -1187,7 +1187,7 @@ type wantConn struct {
 
 	// hooks for testing to know when dials are done
 	// beforeDial is called in the getConn goroutine when the dial is queued.
-	// afterDial is called when the dial is completed or cancelled.
+	// afterDial is called when the dial is completed or canceled.
 	beforeDial func()
 	afterDial  func()
 
@@ -1375,7 +1375,7 @@ func (t *Transport) getConn(treq *transportRequest, cm connectMethod) (pc *persi
 			trace.GotConn(httptrace.GotConnInfo{Conn: w.pc.conn, Reused: w.pc.isReused()})
 		}
 		if w.err != nil {
-			// If the request has been cancelled, that's probably
+			// If the request has been canceled, that's probably
 			// what caused w.err; if so, prefer to return the
 			// cancellation error (see golang.org/issue/16049).
 			select {
@@ -1437,7 +1437,7 @@ func (t *Transport) queueForDial(w *wantConn) {
 
 // dialConnFor dials on behalf of w and delivers the result to w.
 // dialConnFor has received permission to dial w.cm and is counted in t.connCount[w.cm.key()].
-// If the dial is cancelled or unsuccessful, dialConnFor decrements t.connCount[w.cm.key()].
+// If the dial is canceled or unsuccessful, dialConnFor decrements t.connCount[w.cm.key()].
 func (t *Transport) dialConnFor(w *wantConn) {
 	defer w.afterDial()
 
-- 
GitLab


From 6382ec1aba1b1c7380cb525217c1bd645c4fd41b Mon Sep 17 00:00:00 2001
From: Andy Pan <panjf2000@gmail.com>
Date: Thu, 8 Apr 2021 11:42:53 +0800
Subject: [PATCH 1476/2400] internal/poll: fix the intermittent build failures
 with pipe pool

Correlative CL 308089

Fixes #45059

Change-Id: I1ff9fbf64e6620d651f287ba2a28d40f964d78a3
Reviewed-on: https://go-review.googlesource.com/c/go/+/308329
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/internal/poll/splice_linux_test.go | 38 ++++++++++++++++----------
 1 file changed, 24 insertions(+), 14 deletions(-)

diff --git a/src/internal/poll/splice_linux_test.go b/src/internal/poll/splice_linux_test.go
index 9ea5197242..77ae912d54 100644
--- a/src/internal/poll/splice_linux_test.go
+++ b/src/internal/poll/splice_linux_test.go
@@ -6,6 +6,7 @@ package poll_test
 
 import (
 	"internal/poll"
+	"internal/syscall/unix"
 	"runtime"
 	"syscall"
 	"testing"
@@ -16,8 +17,8 @@ import (
 func checkPipes(fds []int) bool {
 	for _, fd := range fds {
 		// Check if each pipe fd has been closed.
-		err := syscall.FcntlFlock(uintptr(fd), syscall.F_GETFD, nil)
-		if err == nil {
+		_, _, errno := syscall.Syscall(unix.FcntlSyscall, uintptr(fd), syscall.F_GETPIPE_SZ, 0)
+		if errno == 0 {
 			return false
 		}
 	}
@@ -37,8 +38,8 @@ func TestSplicePipePool(t *testing.T) {
 		if err != nil {
 			t.Skip("failed to create pipe, skip this test")
 		}
-		prfd, pwfd := poll.GetPipeFds(p)
-		fds = append(fds, prfd, pwfd)
+		_, pwfd := poll.GetPipeFds(p)
+		fds = append(fds, pwfd)
 		ps = append(ps, p)
 	}
 	for _, p = range ps {
@@ -46,19 +47,28 @@ func TestSplicePipePool(t *testing.T) {
 	}
 	ps = nil
 
-	var ok bool
-	// Trigger garbage collection to free the pipes in sync.Pool and check whether or not
-	// those pipe buffers have been closed as we expected.
-	for i := 0; i < 5; i++ {
+	// Exploit the timeout of "go test" as a timer for the subsequent verification.
+	timeout := 5 * time.Minute
+	if deadline, ok := t.Deadline(); ok {
+		timeout = deadline.Sub(time.Now())
+		timeout -= timeout / 10 // Leave 10% headroom for cleanup.
+	}
+	expiredTime := time.NewTimer(timeout)
+	defer expiredTime.Stop()
+
+	// Trigger garbage collection repeatedly, waiting for all pipes in sync.Pool
+	// to either be deallocated and closed, or to time out.
+	for {
 		runtime.GC()
-		time.Sleep(time.Duration(i*100+10) * time.Millisecond)
-		if ok = checkPipes(fds); ok {
+		time.Sleep(10 * time.Millisecond)
+		if checkPipes(fds) {
 			break
 		}
-	}
-
-	if !ok {
-		t.Fatal("at least one pipe is still open")
+		select {
+		case <-expiredTime.C:
+			t.Fatal("at least one pipe is still open")
+		default:
+		}
 	}
 }
 
-- 
GitLab


From 11f159456b1dba3ec499da916852dd188d1e04a7 Mon Sep 17 00:00:00 2001
From: Manlio Perillo <manlio.perillo@gmail.com>
Date: Wed, 7 Apr 2021 16:48:41 +0200
Subject: [PATCH 1477/2400] path/filepath: replace os.MkdirTemp with T.TempDir

Add the tempDirCanonical function, for tests that need a temporary
directory that does not contain symlinks.

Updates #45402

Change-Id: I3d08ef32ef911331544acce3d7d013b4c3382960
Reviewed-on: https://go-review.googlesource.com/c/go/+/308011
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/path/filepath/match_test.go        | 29 ++--------
 src/path/filepath/path_test.go         | 13 +++++
 src/path/filepath/path_windows_test.go | 74 ++++----------------------
 3 files changed, 28 insertions(+), 88 deletions(-)

diff --git a/src/path/filepath/match_test.go b/src/path/filepath/match_test.go
index 48880ea439..375c41a7e9 100644
--- a/src/path/filepath/match_test.go
+++ b/src/path/filepath/match_test.go
@@ -181,12 +181,7 @@ var globSymlinkTests = []struct {
 func TestGlobSymlink(t *testing.T) {
 	testenv.MustHaveSymlink(t)
 
-	tmpDir, err := os.MkdirTemp("", "globsymlink")
-	if err != nil {
-		t.Fatal("creating temp dir:", err)
-	}
-	defer os.RemoveAll(tmpDir)
-
+	tmpDir := t.TempDir()
 	for _, tt := range globSymlinkTests {
 		path := Join(tmpDir, tt.path)
 		dest := Join(tmpDir, tt.dest)
@@ -267,18 +262,7 @@ func TestWindowsGlob(t *testing.T) {
 		t.Skipf("skipping windows specific test")
 	}
 
-	tmpDir, err := os.MkdirTemp("", "TestWindowsGlob")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpDir)
-
-	// /tmp may itself be a symlink
-	tmpDir, err = EvalSymlinks(tmpDir)
-	if err != nil {
-		t.Fatal("eval symlink for tmp dir:", err)
-	}
-
+	tmpDir := tempDirCanonical(t)
 	if len(tmpDir) < 3 {
 		t.Fatalf("tmpDir path %q is too short", tmpDir)
 	}
@@ -323,15 +307,13 @@ func TestWindowsGlob(t *testing.T) {
 	// test absolute paths
 	for _, test := range tests {
 		var p string
-		err = test.globAbs(tmpDir, tmpDir)
-		if err != nil {
+		if err := test.globAbs(tmpDir, tmpDir); err != nil {
 			t.Error(err)
 		}
 		// test C:\*Documents and Settings\...
 		p = tmpDir
 		p = strings.Replace(p, `:\`, `:\*`, 1)
-		err = test.globAbs(tmpDir, p)
-		if err != nil {
+		if err := test.globAbs(tmpDir, p); err != nil {
 			t.Error(err)
 		}
 		// test C:\Documents and Settings*\...
@@ -339,8 +321,7 @@ func TestWindowsGlob(t *testing.T) {
 		p = strings.Replace(p, `:\`, `:`, 1)
 		p = strings.Replace(p, `\`, `*\`, 1)
 		p = strings.Replace(p, `:`, `:\`, 1)
-		err = test.globAbs(tmpDir, p)
-		if err != nil {
+		if err := test.globAbs(tmpDir, p); err != nil {
 			t.Error(err)
 		}
 	}
diff --git a/src/path/filepath/path_test.go b/src/path/filepath/path_test.go
index bb6bc0dd87..cd107b6c85 100644
--- a/src/path/filepath/path_test.go
+++ b/src/path/filepath/path_test.go
@@ -449,6 +449,19 @@ func chtmpdir(t *testing.T) (restore func()) {
 	}
 }
 
+// tempDirCanonical returns a temporary directory for the test to use, ensuring
+// that the returned path does not contain symlinks.
+func tempDirCanonical(t *testing.T) string {
+	dir := t.TempDir()
+
+	cdir, err := filepath.EvalSymlinks(dir)
+	if err != nil {
+		t.Errorf("tempDirCanonical: %v", err)
+	}
+
+	return cdir
+}
+
 func TestWalk(t *testing.T) {
 	walk := func(root string, fn fs.WalkDirFunc) error {
 		return filepath.Walk(root, func(path string, info fs.FileInfo, err error) error {
diff --git a/src/path/filepath/path_windows_test.go b/src/path/filepath/path_windows_test.go
index 1c3d84c62d..76a459ac96 100644
--- a/src/path/filepath/path_windows_test.go
+++ b/src/path/filepath/path_windows_test.go
@@ -37,12 +37,7 @@ func testWinSplitListTestIsValid(t *testing.T, ti int, tt SplitListTest,
 		perm    fs.FileMode = 0700
 	)
 
-	tmp, err := os.MkdirTemp("", "testWinSplitListTestIsValid")
-	if err != nil {
-		t.Fatalf("TempDir failed: %v", err)
-	}
-	defer os.RemoveAll(tmp)
-
+	tmp := t.TempDir()
 	for i, d := range tt.result {
 		if d == "" {
 			continue
@@ -57,12 +52,12 @@ func testWinSplitListTestIsValid(t *testing.T, ti int, tt SplitListTest,
 			t.Errorf("%d,%d: %#q already exists", ti, i, d)
 			return
 		}
-		if err = os.MkdirAll(dd, perm); err != nil {
+		if err := os.MkdirAll(dd, perm); err != nil {
 			t.Errorf("%d,%d: MkdirAll(%#q) failed: %v", ti, i, dd, err)
 			return
 		}
 		fn, data := filepath.Join(dd, cmdfile), []byte("@echo "+d+"\r\n")
-		if err = os.WriteFile(fn, data, perm); err != nil {
+		if err := os.WriteFile(fn, data, perm); err != nil {
 			t.Errorf("%d,%d: WriteFile(%#q) failed: %v", ti, i, fn, err)
 			return
 		}
@@ -103,18 +98,7 @@ func testWinSplitListTestIsValid(t *testing.T, ti int, tt SplitListTest,
 func TestWindowsEvalSymlinks(t *testing.T) {
 	testenv.MustHaveSymlink(t)
 
-	tmpDir, err := os.MkdirTemp("", "TestWindowsEvalSymlinks")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpDir)
-
-	// /tmp may itself be a symlink! Avoid the confusion, although
-	// it means trusting the thing we're testing.
-	tmpDir, err = filepath.EvalSymlinks(tmpDir)
-	if err != nil {
-		t.Fatal(err)
-	}
+	tmpDir := tempDirCanonical(t)
 
 	if len(tmpDir) < 3 {
 		t.Fatalf("tmpDir path %q is too short", tmpDir)
@@ -161,18 +145,7 @@ func TestWindowsEvalSymlinks(t *testing.T) {
 // TestEvalSymlinksCanonicalNames verify that EvalSymlinks
 // returns "canonical" path names on windows.
 func TestEvalSymlinksCanonicalNames(t *testing.T) {
-	tmp, err := os.MkdirTemp("", "evalsymlinkcanonical")
-	if err != nil {
-		t.Fatal("creating temp dir:", err)
-	}
-	defer os.RemoveAll(tmp)
-
-	// os.MkdirTemp might return "non-canonical" name.
-	cTmpName, err := filepath.EvalSymlinks(tmp)
-	if err != nil {
-		t.Errorf("EvalSymlinks(%q) error: %v", tmp, err)
-	}
-
+	ctmp := tempDirCanonical(t)
 	dirs := []string{
 		"test",
 		"test/dir",
@@ -181,7 +154,7 @@ func TestEvalSymlinksCanonicalNames(t *testing.T) {
 	}
 
 	for _, d := range dirs {
-		dir := filepath.Join(cTmpName, d)
+		dir := filepath.Join(ctmp, d)
 		err := os.Mkdir(dir, 0755)
 		if err != nil {
 			t.Fatal(err)
@@ -417,25 +390,8 @@ func TestToNorm(t *testing.T) {
 		{".", `\\localhost\c$`, `\\localhost\c$`},
 	}
 
-	tmp, err := os.MkdirTemp("", "testToNorm")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer func() {
-		err := os.RemoveAll(tmp)
-		if err != nil {
-			t.Fatal(err)
-		}
-	}()
-
-	// os.MkdirTemp might return "non-canonical" name.
-	ctmp, err := filepath.EvalSymlinks(tmp)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = os.MkdirAll(strings.ReplaceAll(testPath, "{{tmp}}", ctmp), 0777)
-	if err != nil {
+	ctmp := tempDirCanonical(t)
+	if err := os.MkdirAll(strings.ReplaceAll(testPath, "{{tmp}}", ctmp), 0777); err != nil {
 		t.Fatal(err)
 	}
 
@@ -526,20 +482,10 @@ func TestNTNamespaceSymlink(t *testing.T) {
 		t.Skip("skipping test because mklink command does not support junctions")
 	}
 
-	tmpdir, err := os.MkdirTemp("", "TestNTNamespaceSymlink")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
-
-	// Make sure tmpdir is not a symlink, otherwise tests will fail.
-	tmpdir, err = filepath.EvalSymlinks(tmpdir)
-	if err != nil {
-		t.Fatal(err)
-	}
+	tmpdir := tempDirCanonical(t)
 
 	vol := filepath.VolumeName(tmpdir)
-	output, err = exec.Command("cmd", "/c", "mountvol", vol, "/L").CombinedOutput()
+	output, err := exec.Command("cmd", "/c", "mountvol", vol, "/L").CombinedOutput()
 	if err != nil {
 		t.Fatalf("failed to run mountvol %v /L: %v %q", vol, err, output)
 	}
-- 
GitLab


From 1129a60f1c1e64147ca1133857c4571ce9b87a35 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Fri, 12 Mar 2021 12:57:39 -0800
Subject: [PATCH 1478/2400] cmd/compile: include typecheck information in
 export/import

Include type information on exported function bodies, so that the
importer does not have to re-typecheck the body. This involves
including type information in the encoded output, as well as
avoiding some of the opcode rewriting and other changes that the
old exporter did assuming there would be a re-typechecking pass.

This CL could be considered a cleanup, but is more important than that
because it is an enabling change for generics. Without this CL, we'd
have to upgrade the current typechecker to understand generics. With
this CL, the current typechecker can mostly go away in favor of the
types2 typechecker.

For now, inlining of functions that contain closures is turned off.
We will hopefully resolve this before freeze.

Object files are only 0.07% bigger.

Change-Id: I85c9da09f66bfdc910dc3e26abb2613a1831634d
Reviewed-on: https://go-review.googlesource.com/c/go/+/301291
Trust: Keith Randall <khr@golang.org>
Trust: Dan Scales <danscales@google.com>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/escape/escape.go     |   2 +-
 src/cmd/compile/internal/inline/inl.go        |   6 +-
 src/cmd/compile/internal/typecheck/func.go    |  19 +-
 src/cmd/compile/internal/typecheck/iexport.go | 276 ++++++++++++-
 src/cmd/compile/internal/typecheck/iimport.go | 371 +++++++++++++++---
 test/closure3.dir/main.go                     |  44 +--
 test/inline.go                                |  22 +-
 7 files changed, 618 insertions(+), 122 deletions(-)

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index 213ef7832d..6bebe5422f 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -587,7 +587,7 @@ func (e *escape) exprSkipInit(k hole, n ir.Node) {
 
 	switch n.Op() {
 	default:
-		base.Fatalf("unexpected expr: %v", n)
+		base.Fatalf("unexpected expr: %s %v", n.Op().String(), n)
 
 	case ir.OLITERAL, ir.ONIL, ir.OGETG, ir.OTYPE, ir.OMETHEXPR, ir.OLINKSYMOFFSET:
 		// nop
diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 1941dc44bc..4470df1d2a 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -354,7 +354,7 @@ func (v *hairyVisitor) doNode(n ir.Node) bool {
 		return true
 
 	case ir.OCLOSURE:
-		if base.Debug.InlFuncsWithClosures == 0 {
+		if base.Debug.InlFuncsWithClosures == 0 || typecheck.Go117ExportTypes { // TODO: remove latter condition
 			v.reason = "not inlining functions with closures"
 			return true
 		}
@@ -1013,7 +1013,9 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 	lab := ir.NewLabelStmt(base.Pos, retlabel)
 	body = append(body, lab)
 
-	typecheck.Stmts(body)
+	if !typecheck.Go117ExportTypes {
+		typecheck.Stmts(body)
+	}
 
 	if base.Flag.GenDwarfInl > 0 {
 		for _, v := range inlfvars {
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index bc31284a85..eaae2a81fa 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -144,15 +144,18 @@ func ImportedBody(fn *ir.Func) {
 		fmt.Printf("typecheck import [%v] %L { %v }\n", fn.Sym(), fn, ir.Nodes(fn.Inl.Body))
 	}
 
-	savefn := ir.CurFunc
-	ir.CurFunc = fn
-	if inTypeCheckInl {
-		base.Fatalf("inTypeCheckInl should not be set recursively")
+	if !go117ExportTypes {
+		// If we didn't export & import types, typecheck the code here.
+		savefn := ir.CurFunc
+		ir.CurFunc = fn
+		if inTypeCheckInl {
+			base.Fatalf("inTypeCheckInl should not be set recursively")
+		}
+		inTypeCheckInl = true
+		Stmts(fn.Inl.Body)
+		inTypeCheckInl = false
+		ir.CurFunc = savefn
 	}
-	inTypeCheckInl = true
-	Stmts(fn.Inl.Body)
-	inTypeCheckInl = false
-	ir.CurFunc = savefn
 
 	base.Pos = lno
 }
diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index 43cc4e4a25..8f8931e495 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -633,6 +633,79 @@ func (w *exportWriter) selector(s *types.Sym) {
 	w.string(s.Name)
 }
 
+func (w *exportWriter) typ(t *types.Type) {
+	w.data.uint64(w.p.typOff(t))
+}
+
+// The "exotic" functions in this section encode a wider range of
+// items than the standard encoding functions above. These include
+// types that do not appear in declarations, only in code, such as
+// method types. These methods need to be separate from the standard
+// encoding functions because we don't want to modify the encoding
+// generated by the standard functions (because that exported
+// information is read by tools besides the compiler).
+
+// exoticType exports a type to the writer.
+func (w *exportWriter) exoticType(t *types.Type) {
+	switch {
+	case t == nil:
+		// Calls-as-statements have no type.
+		w.data.uint64(exoticTypeNil)
+	case t.IsStruct() && t.StructType().Funarg != types.FunargNone:
+		// These are weird structs for representing tuples of types returned
+		// by multi-return functions.
+		// They don't fit the standard struct type mold. For instance,
+		// they don't have any package info.
+		w.data.uint64(exoticTypeTuple)
+		w.uint64(uint64(t.StructType().Funarg))
+		w.uint64(uint64(t.NumFields()))
+		for _, f := range t.FieldSlice() {
+			w.pos(f.Pos)
+			s := f.Sym
+			if s == nil {
+				w.uint64(0)
+			} else if s.Pkg == nil {
+				w.uint64(exoticTypeSymNoPkg)
+				w.string(s.Name)
+			} else {
+				w.uint64(exoticTypeSymWithPkg)
+				w.pkg(s.Pkg)
+				w.string(s.Name)
+			}
+			w.typ(f.Type)
+			if f.Embedded != 0 || f.Note != "" {
+				panic("extra info in funarg struct field")
+			}
+		}
+	case t.Kind() == types.TFUNC && t.Recv() != nil:
+		w.data.uint64(exoticTypeRecv)
+		// interface method types have a fake receiver type.
+		isFakeRecv := t.Recv().Type == types.FakeRecvType()
+		w.bool(isFakeRecv)
+		if !isFakeRecv {
+			w.exoticParam(t.Recv())
+		}
+		w.exoticSignature(t)
+
+	default:
+		// A regular type.
+		w.data.uint64(exoticTypeRegular)
+		w.typ(t)
+	}
+}
+
+const (
+	exoticTypeNil = iota
+	exoticTypeTuple
+	exoticTypeRecv
+	exoticTypeRegular
+)
+const (
+	exoticTypeSymNil = iota
+	exoticTypeSymNoPkg
+	exoticTypeSymWithPkg
+)
+
 // Export a selector, but one whose package may not match
 // the package being compiled. This is a separate function
 // because the standard selector() serialization format is fixed
@@ -653,8 +726,42 @@ func (w *exportWriter) exoticSelector(s *types.Sym) {
 	}
 }
 
-func (w *exportWriter) typ(t *types.Type) {
-	w.data.uint64(w.p.typOff(t))
+func (w *exportWriter) exoticSignature(t *types.Type) {
+	hasPkg := t.Pkg() != nil
+	w.bool(hasPkg)
+	if hasPkg {
+		w.pkg(t.Pkg())
+	}
+	w.exoticParamList(t.Params().FieldSlice())
+	w.exoticParamList(t.Results().FieldSlice())
+}
+
+func (w *exportWriter) exoticParamList(fs []*types.Field) {
+	w.uint64(uint64(len(fs)))
+	for _, f := range fs {
+		w.exoticParam(f)
+	}
+
+}
+func (w *exportWriter) exoticParam(f *types.Field) {
+	w.pos(f.Pos)
+	w.exoticSym(f.Sym)
+	w.uint64(uint64(f.Offset))
+	w.exoticType(f.Type)
+	w.bool(f.IsDDD())
+}
+func (w *exportWriter) exoticSym(s *types.Sym) {
+	if s == nil {
+		w.string("")
+		return
+	}
+	if s.Name == "" {
+		base.Fatalf("empty symbol name")
+	}
+	w.string(s.Name)
+	if !types.IsExported(s.Name) {
+		w.pkg(s.Pkg)
+	}
 }
 
 func (p *iexporter) newWriter() *exportWriter {
@@ -1133,6 +1240,7 @@ func (w *exportWriter) writeNames(dcl []*ir.Name) {
 }
 
 func (w *exportWriter) funcBody(fn *ir.Func) {
+	//fmt.Printf("Exporting %s\n", fn.Nname.Sym().Name)
 	w.writeNames(fn.Inl.Dcl)
 
 	w.stmtList(fn.Inl.Body)
@@ -1208,7 +1316,11 @@ func (w *exportWriter) stmt(n ir.Node) {
 
 	case ir.OAS2, ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV:
 		n := n.(*ir.AssignListStmt)
-		w.op(ir.OAS2)
+		if go117ExportTypes {
+			w.op(n.Op())
+		} else {
+			w.op(ir.OAS2)
+		}
 		w.pos(n.Pos())
 		w.exprList(n.Lhs)
 		w.exprList(n.Rhs)
@@ -1220,7 +1332,7 @@ func (w *exportWriter) stmt(n ir.Node) {
 		w.exprList(n.Results)
 
 	// case ORETJMP:
-	// 	unreachable - generated by compiler for trampolin routines
+	// 	unreachable - generated by compiler for trampoline routines
 
 	case ir.OGO, ir.ODEFER:
 		n := n.(*ir.GoDeferStmt)
@@ -1357,10 +1469,15 @@ func (w *exportWriter) expr(n ir.Node) {
 		if (n.Class == ir.PEXTERN || n.Class == ir.PFUNC) && !ir.IsBlank(n) {
 			w.op(ir.ONONAME)
 			w.qualifiedIdent(n)
+			if go117ExportTypes {
+				w.typ(n.Type())
+			}
 			break
 		}
 
 		// Function scope name.
+		// We don't need a type here, as the type will be provided at the
+		// declaration of n.
 		w.op(ir.ONAME)
 		w.localName(n)
 
@@ -1418,9 +1535,16 @@ func (w *exportWriter) expr(n ir.Node) {
 
 	case ir.OPTRLIT:
 		n := n.(*ir.AddrExpr)
-		w.op(ir.OADDR)
+		if go117ExportTypes {
+			w.op(ir.OPTRLIT)
+		} else {
+			w.op(ir.OADDR)
+		}
 		w.pos(n.Pos())
 		w.expr(n.X)
+		if go117ExportTypes {
+			w.typ(n.Type())
+		}
 
 	case ir.OSTRUCTLIT:
 		n := n.(*ir.CompLitExpr)
@@ -1431,11 +1555,17 @@ func (w *exportWriter) expr(n ir.Node) {
 
 	case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT:
 		n := n.(*ir.CompLitExpr)
-		w.op(ir.OCOMPLIT)
+		if go117ExportTypes {
+			w.op(n.Op())
+		} else {
+			w.op(ir.OCOMPLIT)
+		}
 		w.pos(n.Pos())
 		w.typ(n.Type())
 		w.exprList(n.List)
-
+		if go117ExportTypes && n.Op() == ir.OSLICELIT {
+			w.uint64(uint64(n.Len))
+		}
 	case ir.OKEY:
 		n := n.(*ir.KeyExpr)
 		w.op(ir.OKEY)
@@ -1448,39 +1578,89 @@ func (w *exportWriter) expr(n ir.Node) {
 
 	case ir.OXDOT, ir.ODOT, ir.ODOTPTR, ir.ODOTINTER, ir.ODOTMETH, ir.OCALLPART, ir.OMETHEXPR:
 		n := n.(*ir.SelectorExpr)
-		w.op(ir.OXDOT)
+		if go117ExportTypes {
+			if n.Op() == ir.OXDOT {
+				base.Fatalf("shouldn't encounter XDOT  in new exporter")
+			}
+			w.op(n.Op())
+		} else {
+			w.op(ir.OXDOT)
+		}
 		w.pos(n.Pos())
 		w.expr(n.X)
 		w.exoticSelector(n.Sel)
+		if go117ExportTypes {
+			w.exoticType(n.Type())
+			if n.Op() == ir.ODOT || n.Op() == ir.ODOTPTR || n.Op() == ir.ODOTINTER || n.Op() == ir.OMETHEXPR {
+				w.exoticParam(n.Selection)
+				if n.Op() == ir.OMETHEXPR {
+					name := ir.MethodExprName(n)
+					w.bool(name != nil)
+					if name != nil {
+						w.exoticType(name.Type())
+					}
+				}
+			}
+			// n.Selection is not required for ODOTMETH and OCALLPART. It will
+			// be reconstructed during import.
+		}
 
 	case ir.ODOTTYPE, ir.ODOTTYPE2:
 		n := n.(*ir.TypeAssertExpr)
-		w.op(ir.ODOTTYPE)
+		if go117ExportTypes {
+			w.op(n.Op())
+		} else {
+			w.op(ir.ODOTTYPE)
+		}
 		w.pos(n.Pos())
 		w.expr(n.X)
 		w.typ(n.Type())
 
 	case ir.OINDEX, ir.OINDEXMAP:
 		n := n.(*ir.IndexExpr)
-		w.op(ir.OINDEX)
+		if go117ExportTypes {
+			w.op(n.Op())
+		} else {
+			w.op(ir.OINDEX)
+		}
 		w.pos(n.Pos())
 		w.expr(n.X)
 		w.expr(n.Index)
+		if go117ExportTypes {
+			w.typ(n.Type())
+			if n.Op() == ir.OINDEXMAP {
+				w.bool(n.Assigned)
+			}
+		}
 
 	case ir.OSLICE, ir.OSLICESTR, ir.OSLICEARR:
 		n := n.(*ir.SliceExpr)
-		w.op(ir.OSLICE)
+		if go117ExportTypes {
+			w.op(n.Op())
+		} else {
+			w.op(ir.OSLICE)
+		}
 		w.pos(n.Pos())
 		w.expr(n.X)
 		w.exprsOrNil(n.Low, n.High)
+		if go117ExportTypes {
+			w.typ(n.Type())
+		}
 
 	case ir.OSLICE3, ir.OSLICE3ARR:
 		n := n.(*ir.SliceExpr)
-		w.op(ir.OSLICE3)
+		if go117ExportTypes {
+			w.op(n.Op())
+		} else {
+			w.op(ir.OSLICE3)
+		}
 		w.pos(n.Pos())
 		w.expr(n.X)
 		w.exprsOrNil(n.Low, n.High)
 		w.expr(n.Max)
+		if go117ExportTypes {
+			w.typ(n.Type())
+		}
 
 	case ir.OCOPY, ir.OCOMPLEX:
 		// treated like other builtin calls (see e.g., OREAL)
@@ -1489,11 +1669,19 @@ func (w *exportWriter) expr(n ir.Node) {
 		w.pos(n.Pos())
 		w.expr(n.X)
 		w.expr(n.Y)
-		w.op(ir.OEND)
+		if go117ExportTypes {
+			w.typ(n.Type())
+		} else {
+			w.op(ir.OEND)
+		}
 
 	case ir.OCONV, ir.OCONVIFACE, ir.OCONVNOP, ir.OBYTES2STR, ir.ORUNES2STR, ir.OSTR2BYTES, ir.OSTR2RUNES, ir.ORUNESTR:
 		n := n.(*ir.ConvExpr)
-		w.op(ir.OCONV)
+		if go117ExportTypes {
+			w.op(n.Op())
+		} else {
+			w.op(ir.OCONV)
+		}
 		w.pos(n.Pos())
 		w.typ(n.Type())
 		w.expr(n.X)
@@ -1503,7 +1691,13 @@ func (w *exportWriter) expr(n ir.Node) {
 		w.op(n.Op())
 		w.pos(n.Pos())
 		w.expr(n.X)
-		w.op(ir.OEND)
+		if go117ExportTypes {
+			if n.Op() != ir.OPANIC {
+				w.typ(n.Type())
+			}
+		} else {
+			w.op(ir.OEND)
+		}
 
 	case ir.OAPPEND, ir.ODELETE, ir.ORECOVER, ir.OPRINT, ir.OPRINTN:
 		n := n.(*ir.CallExpr)
@@ -1516,15 +1710,28 @@ func (w *exportWriter) expr(n ir.Node) {
 		} else if n.IsDDD {
 			base.Fatalf("exporter: unexpected '...' with %v call", n.Op())
 		}
+		if go117ExportTypes {
+			if n.Op() != ir.ODELETE && n.Op() != ir.OPRINT && n.Op() != ir.OPRINTN {
+				w.typ(n.Type())
+			}
+		}
 
 	case ir.OCALL, ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER, ir.OGETG:
 		n := n.(*ir.CallExpr)
-		w.op(ir.OCALL)
+		if go117ExportTypes {
+			w.op(n.Op())
+		} else {
+			w.op(ir.OCALL)
+		}
 		w.pos(n.Pos())
 		w.stmtList(n.Init())
 		w.expr(n.X)
 		w.exprList(n.Args)
 		w.bool(n.IsDDD)
+		if go117ExportTypes {
+			w.exoticType(n.Type())
+			w.uint64(uint64(n.Use))
+		}
 
 	case ir.OMAKEMAP, ir.OMAKECHAN, ir.OMAKESLICE:
 		n := n.(*ir.MakeExpr)
@@ -1540,6 +1747,12 @@ func (w *exportWriter) expr(n ir.Node) {
 			w.expr(n.Cap)
 			w.op(ir.OEND)
 		case n.Len != nil && (n.Op() == ir.OMAKESLICE || !n.Len.Type().IsUntyped()):
+			// Note: the extra conditional exists because make(T) for
+			// T a map or chan type, gets an untyped zero added as
+			// an argument. Don't serialize that argument here.
+			w.expr(n.Len)
+			w.op(ir.OEND)
+		case n.Len != nil && go117ExportTypes:
 			w.expr(n.Len)
 			w.op(ir.OEND)
 		}
@@ -1550,18 +1763,27 @@ func (w *exportWriter) expr(n ir.Node) {
 		w.op(n.Op())
 		w.pos(n.Pos())
 		w.expr(n.X)
+		if go117ExportTypes {
+			w.typ(n.Type())
+		}
 
 	case ir.OADDR:
 		n := n.(*ir.AddrExpr)
 		w.op(n.Op())
 		w.pos(n.Pos())
 		w.expr(n.X)
+		if go117ExportTypes {
+			w.typ(n.Type())
+		}
 
 	case ir.ODEREF:
 		n := n.(*ir.StarExpr)
 		w.op(n.Op())
 		w.pos(n.Pos())
 		w.expr(n.X)
+		if go117ExportTypes {
+			w.typ(n.Type())
+		}
 
 	case ir.OSEND:
 		n := n.(*ir.SendStmt)
@@ -1578,6 +1800,9 @@ func (w *exportWriter) expr(n ir.Node) {
 		w.pos(n.Pos())
 		w.expr(n.X)
 		w.expr(n.Y)
+		if go117ExportTypes {
+			w.typ(n.Type())
+		}
 
 	case ir.OANDAND, ir.OOROR:
 		n := n.(*ir.LogicalExpr)
@@ -1585,12 +1810,18 @@ func (w *exportWriter) expr(n ir.Node) {
 		w.pos(n.Pos())
 		w.expr(n.X)
 		w.expr(n.Y)
+		if go117ExportTypes {
+			w.typ(n.Type())
+		}
 
 	case ir.OADDSTR:
 		n := n.(*ir.AddStringExpr)
 		w.op(ir.OADDSTR)
 		w.pos(n.Pos())
 		w.exprList(n.List)
+		if go117ExportTypes {
+			w.typ(n.Type())
+		}
 
 	case ir.ODCLCONST:
 		// if exporting, DCLCONST should just be removed as its usage
@@ -1633,6 +1864,9 @@ func (w *exportWriter) fieldList(list ir.Nodes) {
 		w.pos(n.Pos())
 		w.selector(n.Field)
 		w.expr(n.Value)
+		if go117ExportTypes {
+			w.uint64(uint64(n.Offset))
+		}
 	}
 }
 
@@ -1693,3 +1927,13 @@ func (w *intWriter) uint64(x uint64) {
 	n := binary.PutUvarint(buf[:], x)
 	w.Write(buf[:n])
 }
+
+// If go117ExportTypes is true, then we write type information when
+// exporting function bodies, so those function bodies don't need to
+// be re-typechecked on import.
+// This flag adds some other info to the serialized stream as well
+// which was previously recomputed during typechecking, like
+// specializing opcodes (e.g. OXDOT to ODOTPTR) and ancillary
+// information (e.g. length field for OSLICELIT).
+const go117ExportTypes = true
+const Go117ExportTypes = go117ExportTypes
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 35a1a0083a..0d5d892ef5 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -466,21 +466,6 @@ func (r *importReader) ident(selector bool) *types.Sym {
 func (r *importReader) localIdent() *types.Sym { return r.ident(false) }
 func (r *importReader) selector() *types.Sym   { return r.ident(true) }
 
-func (r *importReader) exoticSelector() *types.Sym {
-	name := r.string()
-	if name == "" {
-		return nil
-	}
-	pkg := r.currPkg
-	if types.IsExported(name) {
-		pkg = types.LocalPkg
-	}
-	if r.uint64() != 0 {
-		pkg = r.pkg()
-	}
-	return pkg.Lookup(name)
-}
-
 func (r *importReader) qualifiedIdent() *ir.Ident {
 	name := r.string()
 	pkg := r.pkg()
@@ -516,6 +501,114 @@ func (r *importReader) typ() *types.Type {
 	return r.p.typAt(r.uint64())
 }
 
+func (r *importReader) exoticType() *types.Type {
+	switch r.uint64() {
+	case exoticTypeNil:
+		return nil
+	case exoticTypeTuple:
+		funarg := types.Funarg(r.uint64())
+		n := r.uint64()
+		fs := make([]*types.Field, n)
+		for i := range fs {
+			pos := r.pos()
+			var sym *types.Sym
+			switch r.uint64() {
+			case exoticTypeSymNil:
+				sym = nil
+			case exoticTypeSymNoPkg:
+				sym = types.NoPkg.Lookup(r.string())
+			case exoticTypeSymWithPkg:
+				pkg := r.pkg()
+				sym = pkg.Lookup(r.string())
+			default:
+				base.Fatalf("unknown symbol kind")
+			}
+			typ := r.typ()
+			f := types.NewField(pos, sym, typ)
+			fs[i] = f
+		}
+		t := types.NewStruct(types.NoPkg, fs)
+		t.StructType().Funarg = funarg
+		return t
+	case exoticTypeRecv:
+		var rcvr *types.Field
+		if r.bool() { // isFakeRecv
+			rcvr = fakeRecvField()
+		} else {
+			rcvr = r.exoticParam()
+		}
+		return r.exoticSignature(rcvr)
+	case exoticTypeRegular:
+		return r.typ()
+	default:
+		base.Fatalf("bad kind of call type")
+		return nil
+	}
+}
+
+func (r *importReader) exoticSelector() *types.Sym {
+	name := r.string()
+	if name == "" {
+		return nil
+	}
+	pkg := r.currPkg
+	if types.IsExported(name) {
+		pkg = types.LocalPkg
+	}
+	if r.uint64() != 0 {
+		pkg = r.pkg()
+	}
+	return pkg.Lookup(name)
+}
+
+func (r *importReader) exoticSignature(recv *types.Field) *types.Type {
+	var pkg *types.Pkg
+	if r.bool() { // hasPkg
+		pkg = r.pkg()
+	}
+	params := r.exoticParamList()
+	results := r.exoticParamList()
+	return types.NewSignature(pkg, recv, nil, params, results)
+}
+
+func (r *importReader) exoticParamList() []*types.Field {
+	n := r.uint64()
+	fs := make([]*types.Field, n)
+	for i := range fs {
+		fs[i] = r.exoticParam()
+	}
+	return fs
+}
+
+func (r *importReader) exoticParam() *types.Field {
+	pos := r.pos()
+	sym := r.exoticSym()
+	off := r.uint64()
+	typ := r.exoticType()
+	ddd := r.bool()
+	f := types.NewField(pos, sym, typ)
+	f.Offset = int64(off)
+	if sym != nil {
+		f.Nname = ir.NewNameAt(pos, sym)
+	}
+	f.SetIsDDD(ddd)
+	return f
+}
+
+func (r *importReader) exoticSym() *types.Sym {
+	name := r.string()
+	if name == "" {
+		return nil
+	}
+	var pkg *types.Pkg
+	if types.IsExported(name) {
+		pkg = types.LocalPkg
+	} else {
+		pkg = r.pkg()
+	}
+	return pkg.Lookup(name)
+}
+
 func (p *iimporter) typAt(off uint64) *types.Type {
 	t, ok := p.typCache[off]
 	if !ok {
@@ -815,6 +908,11 @@ func (r *importReader) funcBody(fn *ir.Func) {
 		// functions).
 		body = []ir.Node{}
 	}
+	if go117ExportTypes {
+		ir.VisitList(body, func(n ir.Node) {
+			n.SetTypecheck(1)
+		})
+	}
 	fn.Inl.Body = body
 
 	r.curfn = outerfn
@@ -942,7 +1040,8 @@ func (r *importReader) expr() ir.Node {
 
 // TODO(gri) split into expr and stmt
 func (r *importReader) node() ir.Node {
-	switch op := r.op(); op {
+	op := r.op()
+	switch op {
 	// expressions
 	// case OPAREN:
 	// 	unreachable - unpacked by exporter
@@ -964,7 +1063,16 @@ func (r *importReader) node() ir.Node {
 		return n
 
 	case ir.ONONAME:
-		return r.qualifiedIdent()
+		n := r.qualifiedIdent()
+		if go117ExportTypes {
+			n2 := Resolve(n)
+			typ := r.typ()
+			if n2.Type() == nil {
+				n2.SetType(typ)
+			}
+			return n2
+		}
+		return n
 
 	case ir.ONAME:
 		return r.localName()
@@ -1028,64 +1136,145 @@ func (r *importReader) node() ir.Node {
 
 		return clo
 
-	// case OPTRLIT:
-	//	unreachable - mapped to case OADDR below by exporter
-
 	case ir.OSTRUCTLIT:
+		if go117ExportTypes {
+			pos := r.pos()
+			typ := r.typ()
+			list := r.fieldList()
+			n := ir.NewCompLitExpr(pos, ir.OSTRUCTLIT, nil, list)
+			n.SetType(typ)
+			return n
+		}
 		return ir.NewCompLitExpr(r.pos(), ir.OCOMPLIT, ir.TypeNode(r.typ()), r.fieldList())
 
-	// case OARRAYLIT, OSLICELIT, OMAPLIT:
-	// 	unreachable - mapped to case OCOMPLIT below by exporter
-
 	case ir.OCOMPLIT:
 		return ir.NewCompLitExpr(r.pos(), ir.OCOMPLIT, ir.TypeNode(r.typ()), r.exprList())
 
+	case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT:
+		if !go117ExportTypes {
+			// unreachable - mapped to OCOMPLIT by exporter
+			goto error
+		}
+		pos := r.pos()
+		typ := r.typ()
+		list := r.exprList()
+		n := ir.NewCompLitExpr(pos, op, ir.TypeNode(typ), list)
+		n.SetType(typ)
+		if op == ir.OSLICELIT {
+			n.Len = int64(r.uint64())
+		}
+		return n
+
 	case ir.OKEY:
 		return ir.NewKeyExpr(r.pos(), r.expr(), r.expr())
 
 	// case OSTRUCTKEY:
 	//	unreachable - handled in case OSTRUCTLIT by elemList
 
-	// case OCALLPART:
-	//	unreachable - mapped to case OXDOT below by exporter
-
-	// case OXDOT, ODOT, ODOTPTR, ODOTINTER, ODOTMETH:
-	// 	unreachable - mapped to case OXDOT below by exporter
-
 	case ir.OXDOT:
 		// see parser.new_dotname
+		if go117ExportTypes {
+			base.Fatalf("shouldn't encounter XDOT in new importer")
+		}
 		return ir.NewSelectorExpr(r.pos(), ir.OXDOT, r.expr(), r.exoticSelector())
 
-	// case ODOTTYPE, ODOTTYPE2:
-	// 	unreachable - mapped to case ODOTTYPE below by exporter
+	case ir.ODOT, ir.ODOTPTR, ir.ODOTINTER, ir.ODOTMETH, ir.OCALLPART, ir.OMETHEXPR:
+		if !go117ExportTypes {
+			// unreachable - mapped to case OXDOT by exporter
+			goto error
+		}
+		pos := r.pos()
+		expr := r.expr()
+		sel := r.exoticSelector()
+		n := ir.NewSelectorExpr(pos, ir.OXDOT, expr, sel)
+		n.SetOp(op)
+		n.SetType(r.exoticType())
+		switch op {
+		case ir.ODOT, ir.ODOTPTR, ir.ODOTINTER, ir.OMETHEXPR:
+			n.Selection = r.exoticParam()
+			if op == ir.OMETHEXPR {
+				if r.bool() { // has name
+					ir.MethodExprName(n).SetType(r.exoticType())
+				}
+			}
+		case ir.ODOTMETH, ir.OCALLPART:
+			// These require a Lookup to link to the correct declaration.
+			rcvrType := expr.Type()
+			typ := n.Type()
+			n.Selection = Lookdot(n, rcvrType, 1)
+			if op == ir.OCALLPART {
+				// Lookdot clobbers the opcode and type, undo that.
+				n.SetOp(op)
+				n.SetType(typ)
+			}
+		}
+		return n
 
-	case ir.ODOTTYPE:
+	case ir.ODOTTYPE, ir.ODOTTYPE2:
 		n := ir.NewTypeAssertExpr(r.pos(), r.expr(), nil)
 		n.SetType(r.typ())
+		if go117ExportTypes {
+			n.SetOp(op)
+		}
 		return n
 
-	// case OINDEX, OINDEXMAP, OSLICE, OSLICESTR, OSLICEARR, OSLICE3, OSLICE3ARR:
-	// 	unreachable - mapped to cases below by exporter
-
-	case ir.OINDEX:
-		return ir.NewIndexExpr(r.pos(), r.expr(), r.expr())
+	case ir.OINDEX, ir.OINDEXMAP:
+		n := ir.NewIndexExpr(r.pos(), r.expr(), r.expr())
+		if go117ExportTypes {
+			n.SetOp(op)
+			n.SetType(r.typ())
+			if op == ir.OINDEXMAP {
+				n.Assigned = r.bool()
+			}
+		}
+		return n
 
-	case ir.OSLICE, ir.OSLICE3:
+	case ir.OSLICE, ir.OSLICESTR, ir.OSLICEARR, ir.OSLICE3, ir.OSLICE3ARR:
 		pos, x := r.pos(), r.expr()
 		low, high := r.exprsOrNil()
 		var max ir.Node
 		if op.IsSlice3() {
 			max = r.expr()
 		}
-		return ir.NewSliceExpr(pos, op, x, low, high, max)
-
-	// case OCONV, OCONVIFACE, OCONVNOP, OBYTES2STR, ORUNES2STR, OSTR2BYTES, OSTR2RUNES, ORUNESTR:
-	// 	unreachable - mapped to OCONV case below by exporter
+		n := ir.NewSliceExpr(pos, op, x, low, high, max)
+		if go117ExportTypes {
+			n.SetType(r.typ())
+		}
+		return n
 
-	case ir.OCONV:
-		return ir.NewConvExpr(r.pos(), ir.OCONV, r.typ(), r.expr())
+	case ir.OCONV, ir.OCONVIFACE, ir.OCONVNOP, ir.OBYTES2STR, ir.ORUNES2STR, ir.OSTR2BYTES, ir.OSTR2RUNES, ir.ORUNESTR:
+		if !go117ExportTypes && op != ir.OCONV {
+			// 	unreachable - mapped to OCONV case by exporter
+			goto error
+		}
+		return ir.NewConvExpr(r.pos(), op, r.typ(), r.expr())
 
 	case ir.OCOPY, ir.OCOMPLEX, ir.OREAL, ir.OIMAG, ir.OAPPEND, ir.OCAP, ir.OCLOSE, ir.ODELETE, ir.OLEN, ir.OMAKE, ir.ONEW, ir.OPANIC, ir.ORECOVER, ir.OPRINT, ir.OPRINTN:
+		if go117ExportTypes {
+			switch op {
+			case ir.OCOPY, ir.OCOMPLEX:
+				n := ir.NewBinaryExpr(r.pos(), op, r.expr(), r.expr())
+				n.SetType(r.typ())
+				return n
+			case ir.OREAL, ir.OIMAG, ir.OCAP, ir.OCLOSE, ir.OLEN, ir.ONEW, ir.OPANIC:
+				n := ir.NewUnaryExpr(r.pos(), op, r.expr())
+				if op != ir.OPANIC {
+					n.SetType(r.typ())
+				}
+				return n
+			case ir.OAPPEND, ir.ODELETE, ir.ORECOVER, ir.OPRINT, ir.OPRINTN:
+				n := ir.NewCallExpr(r.pos(), op, nil, r.exprList())
+				if op == ir.OAPPEND {
+					n.IsDDD = r.bool()
+				}
+				if op == ir.OAPPEND || op == ir.ORECOVER {
+					n.SetType(r.typ())
+				}
+				return n
+			}
+			// ir.OMAKE
+			goto error
+		}
 		n := builtinCall(r.pos(), op)
 		n.Args = r.exprList()
 		if op == ir.OAPPEND {
@@ -1093,18 +1282,37 @@ func (r *importReader) node() ir.Node {
 		}
 		return n
 
-	// case OCALLFUNC, OCALLMETH, OCALLINTER, OGETG:
-	// 	unreachable - mapped to OCALL case below by exporter
-
-	case ir.OCALL:
+	case ir.OCALL, ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER, ir.OGETG:
 		pos := r.pos()
 		init := r.stmtList()
 		n := ir.NewCallExpr(pos, ir.OCALL, r.expr(), r.exprList())
+		if go117ExportTypes {
+			n.SetOp(op)
+		}
 		*n.PtrInit() = init
 		n.IsDDD = r.bool()
+		if go117ExportTypes {
+			n.SetType(r.exoticType())
+			n.Use = ir.CallUse(r.uint64())
+		}
 		return n
 
 	case ir.OMAKEMAP, ir.OMAKECHAN, ir.OMAKESLICE:
+		if go117ExportTypes {
+			pos := r.pos()
+			typ := r.typ()
+			list := r.exprList()
+			var len_, cap_ ir.Node
+			if len(list) > 0 {
+				len_ = list[0]
+			}
+			if len(list) > 1 {
+				cap_ = list[1]
+			}
+			n := ir.NewMakeExpr(pos, op, len_, cap_)
+			n.SetType(typ)
+			return n
+		}
 		n := builtinCall(r.pos(), ir.OMAKE)
 		n.Args.Append(ir.TypeNode(r.typ()))
 		n.Args.Append(r.exprList()...)
@@ -1112,21 +1320,42 @@ func (r *importReader) node() ir.Node {
 
 	// unary expressions
 	case ir.OPLUS, ir.ONEG, ir.OBITNOT, ir.ONOT, ir.ORECV:
-		return ir.NewUnaryExpr(r.pos(), op, r.expr())
+		n := ir.NewUnaryExpr(r.pos(), op, r.expr())
+		if go117ExportTypes {
+			n.SetType(r.typ())
+		}
+		return n
 
-	case ir.OADDR:
-		return NodAddrAt(r.pos(), r.expr())
+	case ir.OADDR, ir.OPTRLIT:
+		n := NodAddrAt(r.pos(), r.expr())
+		if go117ExportTypes {
+			n.SetOp(op)
+			n.SetType(r.typ())
+		}
+		return n
 
 	case ir.ODEREF:
-		return ir.NewStarExpr(r.pos(), r.expr())
+		n := ir.NewStarExpr(r.pos(), r.expr())
+		if go117ExportTypes {
+			n.SetType(r.typ())
+		}
+		return n
 
 	// binary expressions
 	case ir.OADD, ir.OAND, ir.OANDNOT, ir.ODIV, ir.OEQ, ir.OGE, ir.OGT, ir.OLE, ir.OLT,
 		ir.OLSH, ir.OMOD, ir.OMUL, ir.ONE, ir.OOR, ir.ORSH, ir.OSUB, ir.OXOR:
-		return ir.NewBinaryExpr(r.pos(), op, r.expr(), r.expr())
+		n := ir.NewBinaryExpr(r.pos(), op, r.expr(), r.expr())
+		if go117ExportTypes {
+			n.SetType(r.typ())
+		}
+		return n
 
 	case ir.OANDAND, ir.OOROR:
-		return ir.NewLogicalExpr(r.pos(), op, r.expr(), r.expr())
+		n := ir.NewLogicalExpr(r.pos(), op, r.expr(), r.expr())
+		if go117ExportTypes {
+			n.SetType(r.typ())
+		}
+		return n
 
 	case ir.OSEND:
 		return ir.NewSendStmt(r.pos(), r.expr(), r.expr())
@@ -1134,6 +1363,11 @@ func (r *importReader) node() ir.Node {
 	case ir.OADDSTR:
 		pos := r.pos()
 		list := r.exprList()
+		if go117ExportTypes {
+			n := ir.NewAddStringExpr(pos, list)
+			n.SetType(r.typ())
+			return n
+		}
 		x := list[0]
 		for _, y := range list[1:] {
 			x = ir.NewBinaryExpr(pos, ir.OADD, x, y)
@@ -1149,8 +1383,8 @@ func (r *importReader) node() ir.Node {
 		stmts.Append(ir.NewAssignStmt(n.Pos(), n, nil))
 		return ir.NewBlockStmt(n.Pos(), stmts)
 
-	// case OAS, OASWB:
-	// 	unreachable - mapped to OAS case below by exporter
+	// case OASWB:
+	// 	unreachable - never exported
 
 	case ir.OAS:
 		return ir.NewAssignStmt(r.pos(), r.expr(), r.expr())
@@ -1165,11 +1399,12 @@ func (r *importReader) node() ir.Node {
 		}
 		return n
 
-	// case OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV:
-	// 	unreachable - mapped to OAS2 case below by exporter
-
-	case ir.OAS2:
-		return ir.NewAssignListStmt(r.pos(), ir.OAS2, r.exprList(), r.exprList())
+	case ir.OAS2, ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV:
+		if !go117ExportTypes && op != ir.OAS2 {
+			// unreachable - mapped to case OAS2 by exporter
+			goto error
+		}
+		return ir.NewAssignListStmt(r.pos(), op, r.exprList(), r.exprList())
 
 	case ir.ORETURN:
 		return ir.NewReturnStmt(r.pos(), r.exprList())
@@ -1241,6 +1476,10 @@ func (r *importReader) node() ir.Node {
 			"\t==> please file an issue and assign to gri@", op, int(op))
 		panic("unreachable") // satisfy compiler
 	}
+error:
+	base.Fatalf("cannot import %v (%d) node\n"+
+		"\t==> please file an issue and assign to khr@", op, int(op))
+	panic("unreachable") // satisfy compiler
 }
 
 func (r *importReader) op() ir.Op {
@@ -1253,7 +1492,11 @@ func (r *importReader) op() ir.Op {
 func (r *importReader) fieldList() []ir.Node {
 	list := make([]ir.Node, r.uint64())
 	for i := range list {
-		list[i] = ir.NewStructKeyExpr(r.pos(), r.selector(), r.expr())
+		x := ir.NewStructKeyExpr(r.pos(), r.selector(), r.expr())
+		if go117ExportTypes {
+			x.Offset = int64(r.uint64())
+		}
+		list[i] = x
 	}
 	return list
 }
@@ -1270,5 +1513,9 @@ func (r *importReader) exprsOrNil() (a, b ir.Node) {
 }
 
 func builtinCall(pos src.XPos, op ir.Op) *ir.CallExpr {
+	if go117ExportTypes {
+		// These should all be encoded as direct ops, not OCALL.
+		base.Fatalf("builtinCall should not be invoked when types are included in inport/export")
+	}
 	return ir.NewCallExpr(pos, ir.OCALL, ir.NewIdent(base.Pos, types.BuiltinPkg.Lookup(ir.OpNames[op])), nil)
 }
diff --git a/test/closure3.dir/main.go b/test/closure3.dir/main.go
index 2fc33753ed..e8e1e99860 100644
--- a/test/closure3.dir/main.go
+++ b/test/closure3.dir/main.go
@@ -93,11 +93,11 @@ func main() {
 		y := func(x int) int { // ERROR "can inline main.func11" "func literal does not escape"
 			return x + 2
 		}
-		y, sink = func() (func(int) int, int) { // ERROR "can inline main.func12"
-			return func(x int) int { // ERROR "can inline main.func12"
+		y, sink = func() (func(int) int, int) { // ERROR "func literal does not escape"
+			return func(x int) int { // ERROR "can inline main.func12" "func literal escapes"
 				return x + 1
 			}, 42
-		}() // ERROR "func literal does not escape" "inlining call to main.func12"
+		}()
 		if y(40) != 41 {
 			ppanic("y(40) != 41")
 		}
@@ -105,14 +105,14 @@ func main() {
 
 	{
 		func() { // ERROR "func literal does not escape"
-			y := func(x int) int { // ERROR "func literal does not escape" "can inline main.func13.1"
+			y := func(x int) int { // ERROR "can inline main.func13.1" "func literal does not escape"
 				return x + 2
 			}
-			y, sink = func() (func(int) int, int) { // ERROR "can inline main.func13.2"
-				return func(x int) int { // ERROR "can inline main.func13.2"
+			y, sink = func() (func(int) int, int) { // ERROR "func literal does not escape"
+				return func(x int) int { // ERROR "can inline main.func13.2" "func literal escapes"
 					return x + 1
 				}, 42
-			}() // ERROR "inlining call to main.func13.2" "func literal does not escape"
+			}()
 			if y(40) != 41 {
 				ppanic("y(40) != 41")
 			}
@@ -187,29 +187,29 @@ func main() {
 
 	{
 		x := 42
-		if z := func(y int) int { // ERROR "can inline main.func22"
-			return func() int { // ERROR "can inline main.func22.1" "can inline main.func30"
+		if z := func(y int) int { // ERROR "func literal does not escape"
+			return func() int { // ERROR "can inline main.func22.1"
 				return x + y
 			}() // ERROR "inlining call to main.func22.1"
-		}(1); z != 43 { // ERROR "inlining call to main.func22" "inlining call to main.func30"
+		}(1); z != 43 {
 			ppanic("z != 43")
 		}
-		if z := func(y int) int { // ERROR "func literal does not escape" "can inline main.func23"
-			return func() int { // ERROR "can inline main.func23.1" "can inline main.func31"
+		if z := func(y int) int { // ERROR "func literal does not escape"
+			return func() int { // ERROR "can inline main.func23.1"
 				return x + y
 			}() // ERROR "inlining call to main.func23.1"
-		}; z(1) != 43 { // ERROR "inlining call to main.func23" "inlining call to main.func31"
+		}; z(1) != 43 {
 			ppanic("z(1) != 43")
 		}
 	}
 
 	{
 		a := 1
-		func() { // ERROR "can inline main.func24"
-			func() { // ERROR "can inline main.func24" "can inline main.func32"
+		func() { // ERROR "func literal does not escape"
+			func() { // ERROR "can inline main.func24"
 				a = 2
 			}() // ERROR "inlining call to main.func24"
-		}() // ERROR "inlining call to main.func24" "inlining call to main.func32"
+		}()
 		if a != 2 {
 			ppanic("a != 2")
 		}
@@ -250,12 +250,12 @@ func main() {
 		a := 2
 		if r := func(x int) int { // ERROR "func literal does not escape"
 			b := 3
-			return func(y int) int { // ERROR "can inline main.func27.1"
+			return func(y int) int { // ERROR "func literal does not escape"
 				c := 5
-				return func(z int) int { // ERROR "can inline main.func27.1.1" "can inline main.func27.2"
+				return func(z int) int { // ERROR "can inline main.func27.1.1"
 					return a*x + b*y + c*z
 				}(10) // ERROR "inlining call to main.func27.1.1"
-			}(100) // ERROR "inlining call to main.func27.1" "inlining call to main.func27.2"
+			}(100)
 		}(1000); r != 2350 {
 			ppanic("r != 2350")
 		}
@@ -265,15 +265,15 @@ func main() {
 		a := 2
 		if r := func(x int) int { // ERROR "func literal does not escape"
 			b := 3
-			return func(y int) int { // ERROR "can inline main.func28.1"
+			return func(y int) int { // ERROR "func literal does not escape"
 				c := 5
-				func(z int) { // ERROR "can inline main.func28.1.1" "can inline main.func28.2"
+				func(z int) { // ERROR "can inline main.func28.1.1"
 					a = a * x
 					b = b * y
 					c = c * z
 				}(10) // ERROR "inlining call to main.func28.1.1"
 				return a + c
-			}(100) + b // ERROR "inlining call to main.func28.1" "inlining call to main.func28.2"
+			}(100) + b
 		}(1000); r != 2350 {
 			ppanic("r != 2350")
 		}
diff --git a/test/inline.go b/test/inline.go
index bc23768d01..b0911056ca 100644
--- a/test/inline.go
+++ b/test/inline.go
@@ -58,7 +58,7 @@ func _() int { // ERROR "can inline _"
 var somethingWrong error
 
 // local closures can be inlined
-func l(x, y int) (int, int, error) { // ERROR "can inline l"
+func l(x, y int) (int, int, error) {
 	e := func(err error) (int, int, error) { // ERROR "can inline l.func1" "func literal does not escape" "leaking param: err to result"
 		return 0, 0, err
 	}
@@ -90,19 +90,19 @@ func n() int {
 // make sure assignment inside closure is detected
 func o() int {
 	foo := func() int { return 1 } // ERROR "can inline o.func1" "func literal does not escape"
-	func(x int) {                  // ERROR "can inline o.func2"
+	func(x int) {                  // ERROR "func literal does not escape"
 		if x > 10 {
-			foo = func() int { return 2 } // ERROR "can inline o.func2"
+			foo = func() int { return 2 } // ERROR "can inline o.func2" "func literal escapes"
 		}
-	}(11) // ERROR "func literal does not escape" "inlining call to o.func2"
+	}(11)
 	return foo()
 }
 
-func p() int { // ERROR "can inline p"
+func p() int {
 	return func() int { return 42 }() // ERROR "can inline p.func1" "inlining call to p.func1"
 }
 
-func q(x int) int { // ERROR "can inline q"
+func q(x int) int {
 	foo := func() int { return x * 2 } // ERROR "can inline q.func1" "func literal does not escape"
 	return foo()                       // ERROR "inlining call to q.func1"
 }
@@ -111,15 +111,15 @@ func r(z int) int {
 	foo := func(x int) int { // ERROR "can inline r.func1" "func literal does not escape"
 		return x + z
 	}
-	bar := func(x int) int { // ERROR "func literal does not escape" "can inline r.func2"
-		return x + func(y int) int { // ERROR "can inline r.func2.1" "can inline r.func3"
+	bar := func(x int) int { // ERROR "func literal does not escape"
+		return x + func(y int) int { // ERROR "can inline r.func2.1"
 			return 2*y + x*z
 		}(x) // ERROR "inlining call to r.func2.1"
 	}
-	return foo(42) + bar(42) // ERROR "inlining call to r.func1" "inlining call to r.func2" "inlining call to r.func3"
+	return foo(42) + bar(42) // ERROR "inlining call to r.func1"
 }
 
-func s0(x int) int { // ERROR "can inline s0"
+func s0(x int) int {
 	foo := func() { // ERROR "can inline s0.func1" "func literal does not escape"
 		x = x + 1
 	}
@@ -127,7 +127,7 @@ func s0(x int) int { // ERROR "can inline s0"
 	return x
 }
 
-func s1(x int) int { // ERROR "can inline s1"
+func s1(x int) int {
 	foo := func() int { // ERROR "can inline s1.func1" "func literal does not escape"
 		return x
 	}
-- 
GitLab


From 4638545d85d7e10e49132ee94ff9a6778db1c893 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 5 Apr 2021 19:10:22 -0700
Subject: [PATCH 1479/2400] cmd/compile/internal/syntax: accept "~" and "|"
 interface elements

Type lists continue to be accepted as before.

While at it, print missing filenames in error tests
(which uses an ad-hoc position representation).

Change-Id: I933b3acbc9cf1985ad8f70f6b206e3a1dbd64d1e
Reviewed-on: https://go-review.googlesource.com/c/go/+/307371
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/syntax/error_test.go |  4 +-
 src/cmd/compile/internal/syntax/parser.go     | 92 ++++++++++++++++---
 .../compile/internal/syntax/printer_test.go   |  9 ++
 .../internal/syntax/testdata/interface.go2    | 36 ++++++++
 4 files changed, 125 insertions(+), 16 deletions(-)
 create mode 100644 src/cmd/compile/internal/syntax/testdata/interface.go2

diff --git a/src/cmd/compile/internal/syntax/error_test.go b/src/cmd/compile/internal/syntax/error_test.go
index 919667f1d3..e4bedf54fd 100644
--- a/src/cmd/compile/internal/syntax/error_test.go
+++ b/src/cmd/compile/internal/syntax/error_test.go
@@ -164,7 +164,7 @@ func testSyntaxErrors(t *testing.T, filename string) {
 			// we have a match - eliminate this error
 			delete(declared, pos)
 		} else {
-			t.Errorf("%s: unexpected error: %s", orig, e.Msg)
+			t.Errorf("%s:%s: unexpected error: %s", filename, orig, e.Msg)
 		}
 	}, nil, mode)
 
@@ -175,7 +175,7 @@ func testSyntaxErrors(t *testing.T, filename string) {
 
 	// report expected but not reported errors
 	for pos, pattern := range declared {
-		t.Errorf("%s: missing error: %s", pos, pattern)
+		t.Errorf("%s:%s: missing error: %s", filename, pos, pattern)
 	}
 }
 
diff --git a/src/cmd/compile/internal/syntax/parser.go b/src/cmd/compile/internal/syntax/parser.go
index c4ccbb82cb..026297432d 100644
--- a/src/cmd/compile/internal/syntax/parser.go
+++ b/src/cmd/compile/internal/syntax/parser.go
@@ -735,9 +735,9 @@ func (p *parser) binaryExpr(prec int) Expr {
 		t := new(Operation)
 		t.pos = p.pos()
 		t.Op = p.op
-		t.X = x
 		tprec := p.prec
 		p.next()
+		t.X = x
 		t.Y = p.binaryExpr(tprec)
 		x = t
 	}
@@ -1381,7 +1381,9 @@ func (p *parser) structType() *StructType {
 	return typ
 }
 
-// InterfaceType = "interface" "{" { MethodSpec ";" } "}" .
+// InterfaceType = "interface" "{" { ( MethodDecl | EmbeddedElem | TypeList ) ";" } "}" .
+// TypeList      = "type" Type { "," Type } .
+// TODO(gri) remove TypeList syntax if we accept #45346
 func (p *parser) interfaceType() *InterfaceType {
 	if trace {
 		defer p.trace("interfaceType")()
@@ -1395,9 +1397,15 @@ func (p *parser) interfaceType() *InterfaceType {
 	p.list(_Semi, _Rbrace, func() bool {
 		switch p.tok {
 		case _Name:
-			typ.MethodList = append(typ.MethodList, p.methodDecl())
+			f := p.methodDecl()
+			if f.Name == nil && p.mode&AllowGenerics != 0 {
+				f = p.embeddedElem(f)
+			}
+			typ.MethodList = append(typ.MethodList, f)
+			return false
 
 		case _Lparen:
+			// TODO(gri) Need to decide how to adjust this restriction.
 			p.syntaxError("cannot parenthesize embedded type")
 			f := new(Field)
 			f.pos = p.pos()
@@ -1405,10 +1413,17 @@ func (p *parser) interfaceType() *InterfaceType {
 			f.Type = p.qualifiedName(nil)
 			p.want(_Rparen)
 			typ.MethodList = append(typ.MethodList, f)
+			return false
+
+		case _Operator:
+			if p.op == Tilde && p.mode&AllowGenerics != 0 {
+				typ.MethodList = append(typ.MethodList, p.embeddedElem(nil))
+				return false
+			}
 
 		case _Type:
+			// TODO(gri) remove TypeList syntax if we accept #45346
 			if p.mode&AllowGenerics != 0 {
-				// TODO(gri) factor this better
 				type_ := NewName(p.pos(), "type") // cannot have a method named "type"
 				p.next()
 				if p.tok != _Semi && p.tok != _Rbrace {
@@ -1427,19 +1442,18 @@ func (p *parser) interfaceType() *InterfaceType {
 				} else {
 					p.syntaxError("expecting type")
 				}
-				break
+				return false
 			}
-			fallthrough
+		}
 
-		default:
-			if p.mode&AllowGenerics != 0 {
-				p.syntaxError("expecting method, interface name, or type list")
-				p.advance(_Semi, _Rbrace, _Type)
-			} else {
-				p.syntaxError("expecting method or interface name")
-				p.advance(_Semi, _Rbrace)
-			}
+		if p.mode&AllowGenerics != 0 {
+			p.syntaxError("expecting method, type list, or embedded element")
+			p.advance(_Semi, _Rbrace, _Type) // TODO(gri) remove _Type if we don't accept it anymore
+			return false
 		}
+
+		p.syntaxError("expecting method or interface name")
+		p.advance(_Semi, _Rbrace)
 		return false
 	})
 
@@ -1732,6 +1746,56 @@ func (p *parser) methodDecl() *Field {
 	return f
 }
 
+// EmbeddedElem = MethodSpec | EmbeddedTerm { "|" EmbeddedTerm } .
+func (p *parser) embeddedElem(f *Field) *Field {
+	if trace {
+		defer p.trace("embeddedElem")()
+	}
+
+	if f == nil {
+		f = new(Field)
+		f.pos = p.pos()
+		f.Type = p.embeddedTerm()
+	}
+
+	for p.tok == _Operator && p.op == Or {
+		t := new(Operation)
+		t.pos = p.pos()
+		t.Op = Or
+		p.next()
+		t.X = f.Type
+		t.Y = p.embeddedTerm()
+		f.Type = t
+	}
+
+	return f
+}
+
+// EmbeddedTerm = [ "~" ] Type .
+func (p *parser) embeddedTerm() Expr {
+	if trace {
+		defer p.trace("embeddedTerm")()
+	}
+
+	if p.tok == _Operator && p.op == Tilde {
+		t := new(Operation)
+		t.pos = p.pos()
+		t.Op = Tilde
+		p.next()
+		t.X = p.type_()
+		return t
+	}
+
+	t := p.typeOrNil()
+	if t == nil {
+		t = p.badExpr()
+		p.syntaxError("expecting ~ term or type")
+		p.advance(_Operator, _Semi, _Rparen, _Rbrack, _Rbrace)
+	}
+
+	return t
+}
+
 // ParameterDecl = [ IdentifierList ] [ "..." ] Type .
 func (p *parser) paramDeclOrNil(name *Name) *Field {
 	if trace {
diff --git a/src/cmd/compile/internal/syntax/printer_test.go b/src/cmd/compile/internal/syntax/printer_test.go
index 4890327595..ec4b1de573 100644
--- a/src/cmd/compile/internal/syntax/printer_test.go
+++ b/src/cmd/compile/internal/syntax/printer_test.go
@@ -149,6 +149,15 @@ var exprTests = [][2]string{
 	dup("<-chan E"),
 	dup("chan<- E"),
 
+	// new interfaces
+	dup("interface{int}"),
+	dup("interface{~int}"),
+	dup("interface{~int}"),
+	dup("interface{int | string}"),
+	dup("interface{~int | ~string; float64; m()}"),
+	dup("interface{type a, b, c; ~int | ~string; float64; m()}"),
+	dup("interface{~T[int, string] | string}"),
+
 	// non-type expressions
 	dup("(x)"),
 	dup("x.f"),
diff --git a/src/cmd/compile/internal/syntax/testdata/interface.go2 b/src/cmd/compile/internal/syntax/testdata/interface.go2
new file mode 100644
index 0000000000..a817327a43
--- /dev/null
+++ b/src/cmd/compile/internal/syntax/testdata/interface.go2
@@ -0,0 +1,36 @@
+// Copyright 2021 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.
+
+// This file contains test cases for interfaces containing
+// constraint elements.
+//
+// For now, we accept both ordinary type lists and the
+// more complex constraint elements.
+
+package p
+
+type _ interface {
+	m()
+	type int
+	type int, string
+	E
+}
+
+type _ interface {
+	m()
+	~int
+	int | string
+	int | ~string
+	~int | ~string
+}
+
+
+type _ interface {
+	m()
+	~int
+	T[int, string] | string
+	int | ~T[string, struct{}]
+	~int | ~string
+	type bool, int, float64
+}
-- 
GitLab


From 36c5f902f9049b82da50ac66049371830e6de031 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 7 Apr 2021 17:47:14 -0700
Subject: [PATCH 1480/2400] cmd/compile/internal/types2: factor out index/slice
 expr handling

First step towards lightening the load of Checker.exprInternal by
factoring out the code for index and slice expressions; incl. moving
a couple of related methods (Checker.index, Checker.indexedElts).

The code for handling index/slice expressions is copied 1:1 but
occurrences of "goto Error" are replaced by "x.mode = invalid"
followed by a "return".

Change-Id: I44048dcc4851dc5e24f5f169c17f536a37a6a676
Reviewed-on: https://go-review.googlesource.com/c/go/+/308370
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/expr.go  | 376 +--------------------
 src/cmd/compile/internal/types2/index.go | 405 +++++++++++++++++++++++
 2 files changed, 407 insertions(+), 374 deletions(-)
 create mode 100644 src/cmd/compile/internal/types2/index.go

diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 7d2240d41e..4a2e658a63 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -1043,104 +1043,6 @@ func (check *Checker) binary(x *operand, e syntax.Expr, lhs, rhs syntax.Expr, op
 	// x.typ is unchanged
 }
 
-// index checks an index expression for validity.
-// If max >= 0, it is the upper bound for index.
-// If the result typ is != Typ[Invalid], index is valid and typ is its (possibly named) integer type.
-// If the result val >= 0, index is valid and val is its constant int value.
-func (check *Checker) index(index syntax.Expr, max int64) (typ Type, val int64) {
-	typ = Typ[Invalid]
-	val = -1
-
-	var x operand
-	check.expr(&x, index)
-	if x.mode == invalid {
-		return
-	}
-
-	// an untyped constant must be representable as Int
-	check.convertUntyped(&x, Typ[Int])
-	if x.mode == invalid {
-		return
-	}
-
-	// the index must be of integer type
-	if !isInteger(x.typ) {
-		check.errorf(&x, invalidArg+"index %s must be integer", &x)
-		return
-	}
-
-	if x.mode != constant_ {
-		return x.typ, -1
-	}
-
-	// a constant index i must be in bounds
-	if constant.Sign(x.val) < 0 {
-		check.errorf(&x, invalidArg+"index %s must not be negative", &x)
-		return
-	}
-
-	v, valid := constant.Int64Val(constant.ToInt(x.val))
-	if !valid || max >= 0 && v >= max {
-		if check.conf.CompilerErrorMessages {
-			check.errorf(&x, "array index %s out of bounds [0:%d]", x.val.String(), max)
-		} else {
-			check.errorf(&x, "index %s is out of bounds", &x)
-		}
-		return
-	}
-
-	// 0 <= v [ && v < max ]
-	return Typ[Int], v
-}
-
-// indexElts checks the elements (elts) of an array or slice composite literal
-// against the literal's element type (typ), and the element indices against
-// the literal length if known (length >= 0). It returns the length of the
-// literal (maximum index value + 1).
-//
-func (check *Checker) indexedElts(elts []syntax.Expr, typ Type, length int64) int64 {
-	visited := make(map[int64]bool, len(elts))
-	var index, max int64
-	for _, e := range elts {
-		// determine and check index
-		validIndex := false
-		eval := e
-		if kv, _ := e.(*syntax.KeyValueExpr); kv != nil {
-			if typ, i := check.index(kv.Key, length); typ != Typ[Invalid] {
-				if i >= 0 {
-					index = i
-					validIndex = true
-				} else {
-					check.errorf(e, "index %s must be integer constant", kv.Key)
-				}
-			}
-			eval = kv.Value
-		} else if length >= 0 && index >= length {
-			check.errorf(e, "index %d is out of bounds (>= %d)", index, length)
-		} else {
-			validIndex = true
-		}
-
-		// if we have a valid index, check for duplicate entries
-		if validIndex {
-			if visited[index] {
-				check.errorf(e, "duplicate index %d in array or slice literal", index)
-			}
-			visited[index] = true
-		}
-		index++
-		if index > max {
-			max = index
-		}
-
-		// check element against composite literal element type
-		var x operand
-		check.exprWithHint(&x, eval, typ)
-		check.assignment(&x, typ, "array or slice literal")
-	}
-	return max
-}
-
 // exprKind describes the kind of an expression; the kind
 // determines if an expression is valid in 'statement context'.
 type exprKind int
@@ -1485,291 +1387,17 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 		check.selector(x, e)
 
 	case *syntax.IndexExpr:
-		check.exprOrType(x, e.X)
+		check.indexExpr(x, e)
 		if x.mode == invalid {
-			check.use(e.Index)
-			goto Error
-		}
-
-		if x.mode == typexpr {
-			// type instantiation
-			x.mode = invalid
-			x.typ = check.varType(e)
-			if x.typ != Typ[Invalid] {
-				x.mode = typexpr
-			}
-			return expression
-		}
-
-		if x.mode == value {
-			if sig := asSignature(x.typ); sig != nil && len(sig.tparams) > 0 {
-				// function instantiation
-				check.funcInst(x, e)
-				return expression
-			}
-		}
-
-		// ordinary index expression
-		valid := false
-		length := int64(-1) // valid if >= 0
-		switch typ := optype(x.typ).(type) {
-		case *Basic:
-			if isString(typ) {
-				valid = true
-				if x.mode == constant_ {
-					length = int64(len(constant.StringVal(x.val)))
-				}
-				// an indexed string always yields a byte value
-				// (not a constant) even if the string and the
-				// index are constant
-				x.mode = value
-				x.typ = universeByte // use 'byte' name
-			}
-
-		case *Array:
-			valid = true
-			length = typ.len
-			if x.mode != variable {
-				x.mode = value
-			}
-			x.typ = typ.elem
-
-		case *Pointer:
-			if typ := asArray(typ.base); typ != nil {
-				valid = true
-				length = typ.len
-				x.mode = variable
-				x.typ = typ.elem
-			}
-
-		case *Slice:
-			valid = true
-			x.mode = variable
-			x.typ = typ.elem
-
-		case *Map:
-			var key operand
-			check.expr(&key, e.Index)
-			check.assignment(&key, typ.key, "map index")
-			// ok to continue even if indexing failed - map element type is known
-			x.mode = mapindex
-			x.typ = typ.elem
-			x.expr = e
-			return expression
-
-		case *Sum:
-			// A sum type can be indexed if all of the sum's types
-			// support indexing and have the same index and element
-			// type. Special rules apply for maps in the sum type.
-			var tkey, telem Type // key is for map types only
-			nmaps := 0           // number of map types in sum type
-			if typ.is(func(t Type) bool {
-				var e Type
-				switch t := under(t).(type) {
-				case *Basic:
-					if isString(t) {
-						e = universeByte
-					}
-				case *Array:
-					e = t.elem
-				case *Pointer:
-					if t := asArray(t.base); t != nil {
-						e = t.elem
-					}
-				case *Slice:
-					e = t.elem
-				case *Map:
-					// If there are multiple maps in the sum type,
-					// they must have identical key types.
-					// TODO(gri) We may be able to relax this rule
-					// but it becomes complicated very quickly.
-					if tkey != nil && !Identical(t.key, tkey) {
-						return false
-					}
-					tkey = t.key
-					e = t.elem
-					nmaps++
-				case *TypeParam:
-					check.errorf(x, "type of %s contains a type parameter - cannot index (implementation restriction)", x)
-				case *instance:
-					panic("unimplemented")
-				}
-				if e == nil || telem != nil && !Identical(e, telem) {
-					return false
-				}
-				telem = e
-				return true
-			}) {
-				// If there are maps, the index expression must be assignable
-				// to the map key type (as for simple map index expressions).
-				if nmaps > 0 {
-					var key operand
-					check.expr(&key, e.Index)
-					check.assignment(&key, tkey, "map index")
-					// ok to continue even if indexing failed - map element type is known
-
-					// If there are only maps, we are done.
-					if nmaps == len(typ.types) {
-						x.mode = mapindex
-						x.typ = telem
-						x.expr = e
-						return expression
-					}
-
-					// Otherwise we have mix of maps and other types. For
-					// now we require that the map key be an integer type.
-					// TODO(gri) This is probably not good enough.
-					valid = isInteger(tkey)
-					// avoid 2nd indexing error if indexing failed above
-					if !valid && key.mode == invalid {
-						goto Error
-					}
-					x.mode = value // map index expressions are not addressable
-				} else {
-					// no maps
-					valid = true
-					x.mode = variable
-				}
-				x.typ = telem
-			}
-		}
-
-		if !valid {
-			check.errorf(x, invalidOp+"cannot index %s", x)
-			goto Error
-		}
-
-		if e.Index == nil {
-			check.errorf(e, invalidAST+"missing index for %s", x)
 			goto Error
 		}
 
-		index := e.Index
-		if l, _ := index.(*syntax.ListExpr); l != nil {
-			if n := len(l.ElemList); n <= 1 {
-				check.errorf(e, invalidAST+"invalid use of ListExpr for index expression %v with %d indices", e, n)
-				goto Error
-			}
-			// len(l.ElemList) > 1
-			check.error(l.ElemList[1], invalidOp+"more than one index")
-			index = l.ElemList[0] // continue with first index
-		}
-
-		// In pathological (invalid) cases (e.g.: type T1 [][[]T1{}[0][0]]T0)
-		// the element type may be accessed before it's set. Make sure we have
-		// a valid type.
-		if x.typ == nil {
-			x.typ = Typ[Invalid]
-		}
-
-		check.index(index, length)
-		// ok to continue
-
 	case *syntax.SliceExpr:
-		check.expr(x, e.X)
+		check.sliceExpr(x, e)
 		if x.mode == invalid {
-			check.use(e.Index[:]...)
-			goto Error
-		}
-
-		valid := false
-		length := int64(-1) // valid if >= 0
-		switch typ := optype(x.typ).(type) {
-		case *Basic:
-			if isString(typ) {
-				if e.Full {
-					check.error(x, invalidOp+"3-index slice of string")
-					goto Error
-				}
-				valid = true
-				if x.mode == constant_ {
-					length = int64(len(constant.StringVal(x.val)))
-				}
-				// spec: "For untyped string operands the result
-				// is a non-constant value of type string."
-				if typ.kind == UntypedString {
-					x.typ = Typ[String]
-				}
-			}
-
-		case *Array:
-			valid = true
-			length = typ.len
-			if x.mode != variable {
-				check.errorf(x, invalidOp+"%s (slice of unaddressable value)", x)
-				goto Error
-			}
-			x.typ = &Slice{elem: typ.elem}
-
-		case *Pointer:
-			if typ := asArray(typ.base); typ != nil {
-				valid = true
-				length = typ.len
-				x.typ = &Slice{elem: typ.elem}
-			}
-
-		case *Slice:
-			valid = true
-			// x.typ doesn't change
-
-		case *Sum, *TypeParam:
-			check.error(x, "generic slice expressions not yet implemented")
-			goto Error
-		}
-
-		if !valid {
-			check.errorf(x, invalidOp+"cannot slice %s", x)
 			goto Error
 		}
 
-		x.mode = value
-
-		// spec: "Only the first index may be omitted; it defaults to 0."
-		if e.Full && (e.Index[1] == nil || e.Index[2] == nil) {
-			check.error(e, invalidAST+"2nd and 3rd index required in 3-index slice")
-			goto Error
-		}
-
-		// check indices
-		var ind [3]int64
-		for i, expr := range e.Index {
-			x := int64(-1)
-			switch {
-			case expr != nil:
-				// The "capacity" is only known statically for strings, arrays,
-				// and pointers to arrays, and it is the same as the length for
-				// those types.
-				max := int64(-1)
-				if length >= 0 {
-					max = length + 1
-				}
-				if _, v := check.index(expr, max); v >= 0 {
-					x = v
-				}
-			case i == 0:
-				// default is 0 for the first index
-				x = 0
-			case length >= 0:
-				// default is length (== capacity) otherwise
-				x = length
-			}
-			ind[i] = x
-		}
-
-		// constant indices must be in range
-		// (check.index already checks that existing indices >= 0)
-	L:
-		for i, x := range ind[:len(ind)-1] {
-			if x > 0 {
-				for _, y := range ind[i+1:] {
-					if y >= 0 && x > y {
-						check.errorf(e, "invalid slice indices: %d > %d", x, y)
-						break L // only report one error, ok to continue
-					}
-				}
-			}
-		}
-
 	case *syntax.AssertExpr:
 		check.expr(x, e.X)
 		if x.mode == invalid {
diff --git a/src/cmd/compile/internal/types2/index.go b/src/cmd/compile/internal/types2/index.go
new file mode 100644
index 0000000000..0f4adab237
--- /dev/null
+++ b/src/cmd/compile/internal/types2/index.go
@@ -0,0 +1,405 @@
+// Copyright 2021 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.
+
+// This file implements typechecking of index/slice expressions.
+
+package types2
+
+import (
+	"cmd/compile/internal/syntax"
+	"go/constant"
+)
+
+func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) {
+	check.exprOrType(x, e.X)
+	if x.mode == invalid {
+		check.use(e.Index)
+		return
+	}
+
+	if x.mode == typexpr {
+		// type instantiation
+		x.mode = invalid
+		x.typ = check.varType(e)
+		if x.typ != Typ[Invalid] {
+			x.mode = typexpr
+		}
+		return
+	}
+
+	if x.mode == value {
+		if sig := asSignature(x.typ); sig != nil && len(sig.tparams) > 0 {
+			// function instantiation
+			check.funcInst(x, e)
+			return
+		}
+	}
+
+	// ordinary index expression
+	valid := false
+	length := int64(-1) // valid if >= 0
+	switch typ := optype(x.typ).(type) {
+	case *Basic:
+		if isString(typ) {
+			valid = true
+			if x.mode == constant_ {
+				length = int64(len(constant.StringVal(x.val)))
+			}
+			// an indexed string always yields a byte value
+			// (not a constant) even if the string and the
+			// index are constant
+			x.mode = value
+			x.typ = universeByte // use 'byte' name
+		}
+
+	case *Array:
+		valid = true
+		length = typ.len
+		if x.mode != variable {
+			x.mode = value
+		}
+		x.typ = typ.elem
+
+	case *Pointer:
+		if typ := asArray(typ.base); typ != nil {
+			valid = true
+			length = typ.len
+			x.mode = variable
+			x.typ = typ.elem
+		}
+
+	case *Slice:
+		valid = true
+		x.mode = variable
+		x.typ = typ.elem
+
+	case *Map:
+		var key operand
+		check.expr(&key, e.Index)
+		check.assignment(&key, typ.key, "map index")
+		// ok to continue even if indexing failed - map element type is known
+		x.mode = mapindex
+		x.typ = typ.elem
+		x.expr = e
+		return
+
+	case *Sum:
+		// A sum type can be indexed if all of the sum's types
+		// support indexing and have the same index and element
+		// type. Special rules apply for maps in the sum type.
+		var tkey, telem Type // key is for map types only
+		nmaps := 0           // number of map types in sum type
+		if typ.is(func(t Type) bool {
+			var e Type
+			switch t := under(t).(type) {
+			case *Basic:
+				if isString(t) {
+					e = universeByte
+				}
+			case *Array:
+				e = t.elem
+			case *Pointer:
+				if t := asArray(t.base); t != nil {
+					e = t.elem
+				}
+			case *Slice:
+				e = t.elem
+			case *Map:
+				// If there are multiple maps in the sum type,
+				// they must have identical key types.
+				// TODO(gri) We may be able to relax this rule
+				// but it becomes complicated very quickly.
+				if tkey != nil && !Identical(t.key, tkey) {
+					return false
+				}
+				tkey = t.key
+				e = t.elem
+				nmaps++
+			case *TypeParam:
+				check.errorf(x, "type of %s contains a type parameter - cannot index (implementation restriction)", x)
+			case *instance:
+				panic("unimplemented")
+			}
+			if e == nil || telem != nil && !Identical(e, telem) {
+				return false
+			}
+			telem = e
+			return true
+		}) {
+			// If there are maps, the index expression must be assignable
+			// to the map key type (as for simple map index expressions).
+			if nmaps > 0 {
+				var key operand
+				check.expr(&key, e.Index)
+				check.assignment(&key, tkey, "map index")
+				// ok to continue even if indexing failed - map element type is known
+
+				// If there are only maps, we are done.
+				if nmaps == len(typ.types) {
+					x.mode = mapindex
+					x.typ = telem
+					x.expr = e
+					return
+				}
+
+				// Otherwise we have mix of maps and other types. For
+				// now we require that the map key be an integer type.
+				// TODO(gri) This is probably not good enough.
+				valid = isInteger(tkey)
+				// avoid 2nd indexing error if indexing failed above
+				if !valid && key.mode == invalid {
+					x.mode = invalid
+					return
+				}
+				x.mode = value // map index expressions are not addressable
+			} else {
+				// no maps
+				valid = true
+				x.mode = variable
+			}
+			x.typ = telem
+		}
+	}
+
+	if !valid {
+		check.errorf(x, invalidOp+"cannot index %s", x)
+		x.mode = invalid
+		return
+	}
+
+	if e.Index == nil {
+		check.errorf(e, invalidAST+"missing index for %s", x)
+		x.mode = invalid
+		return
+	}
+
+	index := e.Index
+	if l, _ := index.(*syntax.ListExpr); l != nil {
+		if n := len(l.ElemList); n <= 1 {
+			check.errorf(e, invalidAST+"invalid use of ListExpr for index expression %v with %d indices", e, n)
+			x.mode = invalid
+			return
+		}
+		// len(l.ElemList) > 1
+		check.error(l.ElemList[1], invalidOp+"more than one index")
+		index = l.ElemList[0] // continue with first index
+	}
+
+	// In pathological (invalid) cases (e.g.: type T1 [][[]T1{}[0][0]]T0)
+	// the element type may be accessed before it's set. Make sure we have
+	// a valid type.
+	if x.typ == nil {
+		x.typ = Typ[Invalid]
+	}
+
+	check.index(index, length)
+}
+
+func (check *Checker) sliceExpr(x *operand, e *syntax.SliceExpr) {
+	check.expr(x, e.X)
+	if x.mode == invalid {
+		check.use(e.Index[:]...)
+		return
+	}
+
+	valid := false
+	length := int64(-1) // valid if >= 0
+	switch typ := optype(x.typ).(type) {
+	case *Basic:
+		if isString(typ) {
+			if e.Full {
+				check.error(x, invalidOp+"3-index slice of string")
+				x.mode = invalid
+				return
+			}
+			valid = true
+			if x.mode == constant_ {
+				length = int64(len(constant.StringVal(x.val)))
+			}
+			// spec: "For untyped string operands the result
+			// is a non-constant value of type string."
+			if typ.kind == UntypedString {
+				x.typ = Typ[String]
+			}
+		}
+
+	case *Array:
+		valid = true
+		length = typ.len
+		if x.mode != variable {
+			check.errorf(x, invalidOp+"%s (slice of unaddressable value)", x)
+			x.mode = invalid
+			return
+		}
+		x.typ = &Slice{elem: typ.elem}
+
+	case *Pointer:
+		if typ := asArray(typ.base); typ != nil {
+			valid = true
+			length = typ.len
+			x.typ = &Slice{elem: typ.elem}
+		}
+
+	case *Slice:
+		valid = true
+		// x.typ doesn't change
+
+	case *Sum, *TypeParam:
+		check.error(x, "generic slice expressions not yet implemented")
+		x.mode = invalid
+		return
+	}
+
+	if !valid {
+		check.errorf(x, invalidOp+"cannot slice %s", x)
+		x.mode = invalid
+		return
+	}
+
+	x.mode = value
+
+	// spec: "Only the first index may be omitted; it defaults to 0."
+	if e.Full && (e.Index[1] == nil || e.Index[2] == nil) {
+		check.error(e, invalidAST+"2nd and 3rd index required in 3-index slice")
+		x.mode = invalid
+		return
+	}
+
+	// check indices
+	var ind [3]int64
+	for i, expr := range e.Index {
+		x := int64(-1)
+		switch {
+		case expr != nil:
+			// The "capacity" is only known statically for strings, arrays,
+			// and pointers to arrays, and it is the same as the length for
+			// those types.
+			max := int64(-1)
+			if length >= 0 {
+				max = length + 1
+			}
+			if _, v := check.index(expr, max); v >= 0 {
+				x = v
+			}
+		case i == 0:
+			// default is 0 for the first index
+			x = 0
+		case length >= 0:
+			// default is length (== capacity) otherwise
+			x = length
+		}
+		ind[i] = x
+	}
+
+	// constant indices must be in range
+	// (check.index already checks that existing indices >= 0)
+L:
+	for i, x := range ind[:len(ind)-1] {
+		if x > 0 {
+			for _, y := range ind[i+1:] {
+				if y >= 0 && x > y {
+					check.errorf(e, "invalid slice indices: %d > %d", x, y)
+					break L // only report one error, ok to continue
+				}
+			}
+		}
+	}
+}
+
+// index checks an index expression for validity.
+// If max >= 0, it is the upper bound for index.
+// If the result typ is != Typ[Invalid], index is valid and typ is its (possibly named) integer type.
+// If the result val >= 0, index is valid and val is its constant int value.
+func (check *Checker) index(index syntax.Expr, max int64) (typ Type, val int64) {
+	typ = Typ[Invalid]
+	val = -1
+
+	var x operand
+	check.expr(&x, index)
+	if x.mode == invalid {
+		return
+	}
+
+	// an untyped constant must be representable as Int
+	check.convertUntyped(&x, Typ[Int])
+	if x.mode == invalid {
+		return
+	}
+
+	// the index must be of integer type
+	if !isInteger(x.typ) {
+		check.errorf(&x, invalidArg+"index %s must be integer", &x)
+		return
+	}
+
+	if x.mode != constant_ {
+		return x.typ, -1
+	}
+
+	// a constant index i must be in bounds
+	if constant.Sign(x.val) < 0 {
+		check.errorf(&x, invalidArg+"index %s must not be negative", &x)
+		return
+	}
+
+	v, valid := constant.Int64Val(constant.ToInt(x.val))
+	if !valid || max >= 0 && v >= max {
+		if check.conf.CompilerErrorMessages {
+			check.errorf(&x, "array index %s out of bounds [0:%d]", x.val.String(), max)
+		} else {
+			check.errorf(&x, "index %s is out of bounds", &x)
+		}
+		return
+	}
+
+	// 0 <= v [ && v < max ]
+	return Typ[Int], v
+}
+
+// indexElts checks the elements (elts) of an array or slice composite literal
+// against the literal's element type (typ), and the element indices against
+// the literal length if known (length >= 0). It returns the length of the
+// literal (maximum index value + 1).
+func (check *Checker) indexedElts(elts []syntax.Expr, typ Type, length int64) int64 {
+	visited := make(map[int64]bool, len(elts))
+	var index, max int64
+	for _, e := range elts {
+		// determine and check index
+		validIndex := false
+		eval := e
+		if kv, _ := e.(*syntax.KeyValueExpr); kv != nil {
+			if typ, i := check.index(kv.Key, length); typ != Typ[Invalid] {
+				if i >= 0 {
+					index = i
+					validIndex = true
+				} else {
+					check.errorf(e, "index %s must be integer constant", kv.Key)
+				}
+			}
+			eval = kv.Value
+		} else if length >= 0 && index >= length {
+			check.errorf(e, "index %d is out of bounds (>= %d)", index, length)
+		} else {
+			validIndex = true
+		}
+
+		// if we have a valid index, check for duplicate entries
+		if validIndex {
+			if visited[index] {
+				check.errorf(e, "duplicate index %d in array or slice literal", index)
+			}
+			visited[index] = true
+		}
+		index++
+		if index > max {
+			max = index
+		}
+
+		// check element against composite literal element type
+		var x operand
+		check.exprWithHint(&x, eval, typ)
+		check.assignment(&x, typ, "array or slice literal")
+	}
+	return max
+}
-- 
GitLab


From a6d95b4508cb65070fd8471ae8018b897da7fc83 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 7 Apr 2021 18:27:08 -0700
Subject: [PATCH 1481/2400] cmd/compile/internal/types2: split out function
 instantiation from index expr

Also, factor out recording of type/value information after
evaluating an expression into an operand, so that we can
use it when handling instantiation expressions manually.

Change-Id: I6776e6cc243558079d6a203f2fe0a6ae0ecc33de
Reviewed-on: https://go-review.googlesource.com/c/go/+/308371
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/call.go  | 83 +++++++++++++-----------
 src/cmd/compile/internal/types2/check.go | 27 ++++++++
 src/cmd/compile/internal/types2/expr.go  | 32 ++-------
 src/cmd/compile/internal/types2/index.go | 19 +++---
 4 files changed, 88 insertions(+), 73 deletions(-)

diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index 5ad8ea9f87..b340c52e74 100644
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -12,7 +12,7 @@ import (
 	"unicode"
 )
 
-// funcInst type-checks a function instantiaton inst and returns the result in x.
+// funcInst type-checks a function instantiation inst and returns the result in x.
 // The operand x must be the evaluation of inst.X and its type must be a signature.
 func (check *Checker) funcInst(x *operand, inst *syntax.IndexExpr) {
 	xlist := unpackExpr(inst.Index)
@@ -66,8 +66,16 @@ func (check *Checker) funcInst(x *operand, inst *syntax.IndexExpr) {
 	x.expr = inst
 }
 
-func (check *Checker) call(x *operand, call *syntax.CallExpr) exprKind {
-	check.exprOrType(x, call.Fun)
+func (check *Checker) callExpr(x *operand, call *syntax.CallExpr) exprKind {
+	if iexpr, _ := call.Fun.(*syntax.IndexExpr); iexpr != nil {
+		if check.indexExpr(x, iexpr) {
+			check.funcInst(x, iexpr)
+		}
+		x.expr = iexpr
+		check.record(x)
+	} else {
+		check.exprOrType(x, call.Fun)
+	}
 
 	switch x.mode {
 	case invalid:
@@ -116,49 +124,48 @@ func (check *Checker) call(x *operand, call *syntax.CallExpr) exprKind {
 			check.hasCallOrRecv = true
 		}
 		return predeclaredFuncs[id].kind
+	}
 
-	default:
-		// function/method call
-		cgocall := x.mode == cgofunc
+	// ordinary function/method call
+	cgocall := x.mode == cgofunc
 
-		sig := asSignature(x.typ)
-		if sig == nil {
-			check.errorf(x, invalidOp+"cannot call non-function %s", x)
-			x.mode = invalid
-			x.expr = call
-			return statement
-		}
+	sig := asSignature(x.typ)
+	if sig == nil {
+		check.errorf(x, invalidOp+"cannot call non-function %s", x)
+		x.mode = invalid
+		x.expr = call
+		return statement
+	}
 
-		// evaluate arguments
-		args, _ := check.exprList(call.ArgList, false)
-		sig = check.arguments(call, sig, args)
+	// evaluate arguments
+	args, _ := check.exprList(call.ArgList, false)
+	sig = check.arguments(call, sig, args)
 
-		// determine result
-		switch sig.results.Len() {
-		case 0:
-			x.mode = novalue
-		case 1:
-			if cgocall {
-				x.mode = commaerr
-			} else {
-				x.mode = value
-			}
-			x.typ = sig.results.vars[0].typ // unpack tuple
-		default:
+	// determine result
+	switch sig.results.Len() {
+	case 0:
+		x.mode = novalue
+	case 1:
+		if cgocall {
+			x.mode = commaerr
+		} else {
 			x.mode = value
-			x.typ = sig.results
-		}
-		x.expr = call
-		check.hasCallOrRecv = true
-
-		// if type inference failed, a parametrized result must be invalidated
-		// (operands cannot have a parametrized type)
-		if x.mode == value && len(sig.tparams) > 0 && isParameterized(sig.tparams, x.typ) {
-			x.mode = invalid
 		}
+		x.typ = sig.results.vars[0].typ // unpack tuple
+	default:
+		x.mode = value
+		x.typ = sig.results
+	}
+	x.expr = call
+	check.hasCallOrRecv = true
 
-		return statement
+	// if type inference failed, a parametrized result must be invalidated
+	// (operands cannot have a parametrized type)
+	if x.mode == value && len(sig.tparams) > 0 && isParameterized(sig.tparams, x.typ) {
+		x.mode = invalid
 	}
+
+	return statement
 }
 
 func (check *Checker) exprList(elist []syntax.Expr, allowCommaOk bool) (xlist []*operand, commaOk bool) {
diff --git a/src/cmd/compile/internal/types2/check.go b/src/cmd/compile/internal/types2/check.go
index 2edcefd4c8..7703d98fa6 100644
--- a/src/cmd/compile/internal/types2/check.go
+++ b/src/cmd/compile/internal/types2/check.go
@@ -307,6 +307,33 @@ func (check *Checker) processDelayed(top int) {
 	check.delayed = check.delayed[:top]
 }
 
+func (check *Checker) record(x *operand) {
+	// convert x into a user-friendly set of values
+	// TODO(gri) this code can be simplified
+	var typ Type
+	var val constant.Value
+	switch x.mode {
+	case invalid:
+		typ = Typ[Invalid]
+	case novalue:
+		typ = (*Tuple)(nil)
+	case constant_:
+		typ = x.typ
+		val = x.val
+	default:
+		typ = x.typ
+	}
+	assert(x.expr != nil && typ != nil)
+
+	if isUntyped(typ) {
+		// delay type and value recording until we know the type
+		// or until the end of type checking
+		check.rememberUntyped(x.expr, false, x.mode, typ.(*Basic), val)
+	} else {
+		check.recordTypeAndValue(x.expr, x.mode, typ, val)
+	}
+}
+
 func (check *Checker) recordUntyped() {
 	if !debug && check.Types == nil {
 		return // nothing to do
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 4a2e658a63..76c6e7a3b3 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -1068,31 +1068,7 @@ func (check *Checker) rawExpr(x *operand, e syntax.Expr, hint Type) exprKind {
 	}
 
 	kind := check.exprInternal(x, e, hint)
-
-	// convert x into a user-friendly set of values
-	// TODO(gri) this code can be simplified
-	var typ Type
-	var val constant.Value
-	switch x.mode {
-	case invalid:
-		typ = Typ[Invalid]
-	case novalue:
-		typ = (*Tuple)(nil)
-	case constant_:
-		typ = x.typ
-		val = x.val
-	default:
-		typ = x.typ
-	}
-	assert(x.expr != nil && typ != nil)
-
-	if isUntyped(typ) {
-		// delay type and value recording until we know the type
-		// or until the end of type checking
-		check.rememberUntyped(x.expr, false, x.mode, typ.(*Basic), val)
-	} else {
-		check.recordTypeAndValue(e, x.mode, typ, val)
-	}
+	check.record(x)
 
 	return kind
 }
@@ -1387,7 +1363,9 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 		check.selector(x, e)
 
 	case *syntax.IndexExpr:
-		check.indexExpr(x, e)
+		if check.indexExpr(x, e) {
+			check.funcInst(x, e)
+		}
 		if x.mode == invalid {
 			goto Error
 		}
@@ -1428,7 +1406,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 		goto Error
 
 	case *syntax.CallExpr:
-		return check.call(x, e)
+		return check.callExpr(x, e)
 
 	// case *syntax.UnaryExpr:
 	// 	check.expr(x, e.X)
diff --git a/src/cmd/compile/internal/types2/index.go b/src/cmd/compile/internal/types2/index.go
index 0f4adab237..b9b5b53226 100644
--- a/src/cmd/compile/internal/types2/index.go
+++ b/src/cmd/compile/internal/types2/index.go
@@ -11,14 +11,18 @@ import (
 	"go/constant"
 )
 
-func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) {
+// If e is a valid function instantiation, indexExpr returns true.
+// In that case x represents the uninstantiated function value and
+// it is the caller's responsibility to instantiate the function.
+func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) (isFuncInst bool) {
 	check.exprOrType(x, e.X)
-	if x.mode == invalid {
+
+	switch x.mode {
+	case invalid:
 		check.use(e.Index)
 		return
-	}
 
-	if x.mode == typexpr {
+	case typexpr:
 		// type instantiation
 		x.mode = invalid
 		x.typ = check.varType(e)
@@ -26,13 +30,11 @@ func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) {
 			x.mode = typexpr
 		}
 		return
-	}
 
-	if x.mode == value {
+	case value:
 		if sig := asSignature(x.typ); sig != nil && len(sig.tparams) > 0 {
 			// function instantiation
-			check.funcInst(x, e)
-			return
+			return true
 		}
 	}
 
@@ -194,6 +196,7 @@ func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) {
 	}
 
 	check.index(index, length)
+	return
 }
 
 func (check *Checker) sliceExpr(x *operand, e *syntax.SliceExpr) {
-- 
GitLab


From 3f4977bd5800beca059defb5de4dc64cd758cbb9 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 7 Apr 2021 22:36:15 -0700
Subject: [PATCH 1482/2400] cmd/compile/internal/types2: use combined type and
 ordinary args for type inference

Fixes #44799.

Change-Id: I51d5b6d6fdfcf47b87bf40b1f7e31c3284c2813f
Reviewed-on: https://go-review.googlesource.com/c/go/+/308372
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/builtins.go   |  2 +-
 src/cmd/compile/internal/types2/call.go       | 37 +++++++++++++++++--
 .../internal/types2/fixedbugs/issue39754.go2  |  6 ++-
 .../internal/types2/fixedbugs/issue44799.go2  | 19 ++++++++++
 4 files changed, 57 insertions(+), 7 deletions(-)
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue44799.go2

diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go
index f0fd216b13..25bfb24ef4 100644
--- a/src/cmd/compile/internal/types2/builtins.go
+++ b/src/cmd/compile/internal/types2/builtins.go
@@ -129,7 +129,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 			arg(&x, i)
 			xlist = append(xlist, &x)
 		}
-		check.arguments(call, sig, xlist) // discard result (we know the result type)
+		check.arguments(call, sig, nil, xlist) // discard result (we know the result type)
 		// ok to continue even if check.arguments reported errors
 
 		x.mode = value
diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index b340c52e74..6d149340b2 100644
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -67,9 +67,14 @@ func (check *Checker) funcInst(x *operand, inst *syntax.IndexExpr) {
 }
 
 func (check *Checker) callExpr(x *operand, call *syntax.CallExpr) exprKind {
+	var inst *syntax.IndexExpr // function instantiation, if any
 	if iexpr, _ := call.Fun.(*syntax.IndexExpr); iexpr != nil {
 		if check.indexExpr(x, iexpr) {
-			check.funcInst(x, iexpr)
+			// Delay function instantiation to argument checking,
+			// where we combine type and value arguments for type
+			// inference.
+			assert(x.mode == value)
+			inst = iexpr
 		}
 		x.expr = iexpr
 		check.record(x)
@@ -137,9 +142,33 @@ func (check *Checker) callExpr(x *operand, call *syntax.CallExpr) exprKind {
 		return statement
 	}
 
+	// evaluate type arguments, if any
+	var targs []Type
+	if inst != nil {
+		xlist := unpackExpr(inst.Index)
+		targs = check.typeList(xlist)
+		if targs == nil {
+			check.use(call.ArgList...)
+			x.mode = invalid
+			x.expr = call
+			return statement
+		}
+		assert(len(targs) == len(xlist))
+
+		// check number of type arguments (got) vs number of type parameters (want)
+		got, want := len(targs), len(sig.tparams)
+		if got > want {
+			check.errorf(xlist[want], "got %d type arguments but want %d", got, want)
+			check.use(call.ArgList...)
+			x.mode = invalid
+			x.expr = call
+			return statement
+		}
+	}
+
 	// evaluate arguments
 	args, _ := check.exprList(call.ArgList, false)
-	sig = check.arguments(call, sig, args)
+	sig = check.arguments(call, sig, targs, args)
 
 	// determine result
 	switch sig.results.Len() {
@@ -208,7 +237,7 @@ func (check *Checker) exprList(elist []syntax.Expr, allowCommaOk bool) (xlist []
 	return
 }
 
-func (check *Checker) arguments(call *syntax.CallExpr, sig *Signature, args []*operand) (rsig *Signature) {
+func (check *Checker) arguments(call *syntax.CallExpr, sig *Signature, targs []Type, args []*operand) (rsig *Signature) {
 	rsig = sig
 
 	// TODO(gri) try to eliminate this extra verification loop
@@ -292,7 +321,7 @@ func (check *Checker) arguments(call *syntax.CallExpr, sig *Signature, args []*o
 	if len(sig.tparams) > 0 {
 		// TODO(gri) provide position information for targs so we can feed
 		//           it to the instantiate call for better error reporting
-		targs := check.infer(call.Pos(), sig.tparams, nil, sigParams, args, true)
+		targs = check.infer(call.Pos(), sig.tparams, targs, sigParams, args, true)
 		if targs == nil {
 			return // error already reported
 		}
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39754.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39754.go2
index 36b774faaf..f70b8d0ce0 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue39754.go2
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39754.go2
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2020 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.
@@ -17,5 +16,8 @@ func f[V interface{}, A, B Box[V]]() {}
 
 func _() {
 	f[int, Optional[int], Optional[int]]()
-	f[int, Optional[int], Optional /* ERROR does not satisfy Box */ [string]]()
+	_ = f[int, Optional[int], Optional /* ERROR does not satisfy Box */ [string]]
+	// TODO(gri) Provide better position information here.
+	//           See TODO in call.go, Checker.arguments.
+	f[int, Optional[int], Optional[string]]( /* ERROR does not satisfy Box */ )
 }
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue44799.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue44799.go2
new file mode 100644
index 0000000000..9e528a7475
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue44799.go2
@@ -0,0 +1,19 @@
+// Copyright 2021 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
+
+func Map[F, T any](s []F, f func(F) T) []T { return nil }
+
+func Reduce[Elem1, Elem2 any](s []Elem1, initializer Elem2, f func(Elem2, Elem1) Elem2) Elem2 { var x Elem2; return x }
+
+func main() {
+	var s []int
+	var f1 func(int) float64
+	var f2 func(float64, int) float64
+	_ = Map[int](s, f1)
+	_ = Map(s, f1)
+	_ = Reduce[int](s, 0, f2)
+	_ = Reduce(s, 0, f2)
+}
-- 
GitLab


From 189c6946f598dc668946499e4179775c06295f9d Mon Sep 17 00:00:00 2001
From: 6543 <6543@obermui.de>
Date: Sun, 11 Apr 2021 04:37:47 +0000
Subject: [PATCH 1483/2400] net: reference the correct RFCs and sections for
 IP.IsPrivate

Properly cite RFC 1918 Section 3 for ipv4,
and RFC 4193 Section 8 for ipv6 comments.

Updates #29146

Change-Id: I8a2df0d7bef50444294bb3301fe09fb09f21ffaf
GitHub-Last-Rev: b0341791c0c4a2f47fcea65a7ab3877afbe2040a
GitHub-Pull-Request: golang/go#45500
Reviewed-on: https://go-review.googlesource.com/c/go/+/309249
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/net/ip.go | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/net/ip.go b/src/net/ip.go
index da51dab800..0477269761 100644
--- a/src/net/ip.go
+++ b/src/net/ip.go
@@ -132,9 +132,9 @@ func (ip IP) IsLoopback() bool {
 // RFC 1918 (IPv4 addresses) and RFC 4193 (IPv6 addresses).
 func (ip IP) IsPrivate() bool {
 	if ip4 := ip.To4(); ip4 != nil {
-		// Following RFC 4193, Section 3. Local IPv6 Unicast Addresses which says:
+		// Following RFC 1918, Section 3. Private Address Space which says:
 		//   The Internet Assigned Numbers Authority (IANA) has reserved the
-		//   following three blocks of the IPv4 address space for private internets:
+		//   following three blocks of the IP address space for private internets:
 		//     10.0.0.0        -   10.255.255.255  (10/8 prefix)
 		//     172.16.0.0      -   172.31.255.255  (172.16/12 prefix)
 		//     192.168.0.0     -   192.168.255.255 (192.168/16 prefix)
@@ -142,10 +142,8 @@ func (ip IP) IsPrivate() bool {
 			(ip4[0] == 172 && ip4[1]&0xf0 == 16) ||
 			(ip4[0] == 192 && ip4[1] == 168)
 	}
-	// Following RFC 4193, Section 3. Private Address Space which says:
-	//   The Internet Assigned Numbers Authority (IANA) has reserved the
-	//   following block of the IPv6 address space for local internets:
-	//     FC00::  -  FDFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF (FC00::/7 prefix)
+	// Following RFC 4193, Section 8. IANA Considerations which says:
+	//   The IANA has assigned the FC00::/7 prefix to "Unique Local Unicast".
 	return len(ip) == IPv6len && ip[0]&0xfe == 0xfc
 }
 
-- 
GitLab


From 352d329c44d99b5c6cb325940006ca52f88195f3 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Fri, 9 Apr 2021 16:08:28 -0400
Subject: [PATCH 1484/2400] runtime: move zero-sized frame check from newproc
 to newproc1

If GOEXPERIMENT=regabidefer is enabled, newproc currently checks that
the call frame for new goroutines is empty. But there's one place in
the runtime (debugCallWrap), where we call newproc1, and it happens to
pass a non-empty frame. The current check didn't catch that. Move the
empty call frame check from newproc to newproc1 to catch this.

Updates #40724.

Change-Id: I9998faf1e07e7b7af88e06a8177127f998c40252
Reviewed-on: https://go-review.googlesource.com/c/go/+/309034
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/debug_test.go |  8 ++++++--
 src/runtime/proc.go       | 14 ++++++++------
 2 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/src/runtime/debug_test.go b/src/runtime/debug_test.go
index c4c41f95f2..7f9e460303 100644
--- a/src/runtime/debug_test.go
+++ b/src/runtime/debug_test.go
@@ -9,8 +9,12 @@
 // spends all of its time in the race runtime, which isn't a safe
 // point.
 
-//go:build amd64 && linux && !race
-// +build amd64,linux,!race
+// TODO(register args): We skip this under GOEXPERIMENT=regabidefer
+// because debugCallWrap passes a non-empty frame to newproc1,
+// triggering a panic.
+
+//go:build amd64 && linux && !race && !goexperiment.regabidefer
+// +build amd64,linux,!race,!goexperiment.regabidefer
 
 package runtime_test
 
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index d545a143a0..6c1c5dd917 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -4020,12 +4020,6 @@ func malg(stacksize int32) *g {
 //
 //go:nosplit
 func newproc(siz int32, fn *funcval) {
-	if goexperiment.RegabiDefer && siz != 0 {
-		// TODO: When we commit to GOEXPERIMENT=regabidefer,
-		// rewrite newproc's comment, since it will no longer
-		// have a funny stack layout or need to be nosplit.
-		throw("go with non-empty frame")
-	}
 	argp := add(unsafe.Pointer(&fn), sys.PtrSize)
 	gp := getg()
 	pc := getcallerpc()
@@ -4051,6 +4045,14 @@ func newproc(siz int32, fn *funcval) {
 //
 //go:systemstack
 func newproc1(fn *funcval, argp unsafe.Pointer, narg int32, callergp *g, callerpc uintptr) *g {
+	if goexperiment.RegabiDefer && narg != 0 {
+		// TODO: When we commit to GOEXPERIMENT=regabidefer,
+		// rewrite the comments for newproc and newproc1.
+		// newproc will no longer have a funny stack layout or
+		// need to be nosplit.
+		throw("go with non-empty frame")
+	}
+
 	_g_ := getg()
 
 	if fn == nil {
-- 
GitLab


From 0da9eff5034521ccc51c32ebaad5fae20d8345fe Mon Sep 17 00:00:00 2001
From: Dan Kortschak <dan@kortschak.io>
Date: Sun, 11 Apr 2021 14:18:24 +0930
Subject: [PATCH 1485/2400] runtime: simplify syntax for pointer arithmetic in
 mapaccess functions

This harmonizes the syntax between mapaccess1 and mapaccess2, and
simplifies the code.

Change-Id: I6db25ffdc871018d399f9030259894b3994c5793
Reviewed-on: https://go-review.googlesource.com/c/go/+/308951
Reviewed-by: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/map.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/runtime/map.go b/src/runtime/map.go
index 40e19c9294..111db56b01 100644
--- a/src/runtime/map.go
+++ b/src/runtime/map.go
@@ -470,13 +470,13 @@ func mapaccess2(t *maptype, h *hmap, key unsafe.Pointer) (unsafe.Pointer, bool)
 	}
 	hash := t.hasher(key, uintptr(h.hash0))
 	m := bucketMask(h.B)
-	b := (*bmap)(unsafe.Pointer(uintptr(h.buckets) + (hash&m)*uintptr(t.bucketsize)))
+	b := (*bmap)(add(h.buckets, (hash&m)*uintptr(t.bucketsize)))
 	if c := h.oldbuckets; c != nil {
 		if !h.sameSizeGrow() {
 			// There used to be half as many buckets; mask down one more power of two.
 			m >>= 1
 		}
-		oldb := (*bmap)(unsafe.Pointer(uintptr(c) + (hash&m)*uintptr(t.bucketsize)))
+		oldb := (*bmap)(add(c, (hash&m)*uintptr(t.bucketsize)))
 		if !evacuated(oldb) {
 			b = oldb
 		}
@@ -514,13 +514,13 @@ func mapaccessK(t *maptype, h *hmap, key unsafe.Pointer) (unsafe.Pointer, unsafe
 	}
 	hash := t.hasher(key, uintptr(h.hash0))
 	m := bucketMask(h.B)
-	b := (*bmap)(unsafe.Pointer(uintptr(h.buckets) + (hash&m)*uintptr(t.bucketsize)))
+	b := (*bmap)(add(h.buckets, (hash&m)*uintptr(t.bucketsize)))
 	if c := h.oldbuckets; c != nil {
 		if !h.sameSizeGrow() {
 			// There used to be half as many buckets; mask down one more power of two.
 			m >>= 1
 		}
-		oldb := (*bmap)(unsafe.Pointer(uintptr(c) + (hash&m)*uintptr(t.bucketsize)))
+		oldb := (*bmap)(add(c, (hash&m)*uintptr(t.bucketsize)))
 		if !evacuated(oldb) {
 			b = oldb
 		}
-- 
GitLab


From 424abc8d3be8b2b90f0259465c21ef95dc70f866 Mon Sep 17 00:00:00 2001
From: Manlio Perillo <manlio.perillo@gmail.com>
Date: Sun, 11 Apr 2021 21:06:24 +0200
Subject: [PATCH 1486/2400] os/signal: replace os.MkdirTemp with T.TempDir

Updates #45402.

Change-Id: I6fe356b51bc825a907f979d9c44432a4d43d1f6e
Reviewed-on: https://go-review.googlesource.com/c/go/+/308996
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/os/signal/signal_windows_test.go | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/os/signal/signal_windows_test.go b/src/os/signal/signal_windows_test.go
index 4640428587..9b14551572 100644
--- a/src/os/signal/signal_windows_test.go
+++ b/src/os/signal/signal_windows_test.go
@@ -56,11 +56,7 @@ func main() {
 	}
 }
 `
-	tmp, err := os.MkdirTemp("", "TestCtrlBreak")
-	if err != nil {
-		t.Fatal("TempDir failed: ", err)
-	}
-	defer os.RemoveAll(tmp)
+	tmp := t.TempDir()
 
 	// write ctrlbreak.go
 	name := filepath.Join(tmp, "ctlbreak")
-- 
GitLab


From 7beb988a3b935a9db56b9e0544506491c4d5d06a Mon Sep 17 00:00:00 2001
From: Meng Zhuo <mzh@golangcn.org>
Date: Thu, 8 Apr 2021 16:08:55 +0800
Subject: [PATCH 1487/2400] runtime: using wyhash for memhashFallback on 64bit
 platform
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

wyhash is a general hash function that:

1. About 8-70% faster that internal maphash
2. Passed Smhasher, BigCrush and PractRand tests

name                  old time/op    new time/op    delta
Hash5                   28.9ns ± 0%    30.0ns ± 0%   +3.77%  (p=0.000 n=9+10)
Hash16                  32.4ns ± 0%    30.2ns ± 0%   -6.74%  (p=0.000 n=10+8)
Hash64                  52.4ns ± 0%    43.4ns ± 0%  -17.20%  (p=0.000 n=9+10)
Hash1024                 415ns ± 0%     258ns ± 2%  -37.89%  (p=0.000 n=10+10)
Hash65536               24.9µs ± 0%    14.6µs ± 0%  -41.22%  (p=0.000 n=9+9)
HashStringSpeed         50.2ns ± 4%    47.8ns ± 4%   -4.88%  (p=0.000 n=10+10)
HashBytesSpeed          90.1ns ± 7%    78.3ns ± 4%  -13.06%  (p=0.000 n=10+10)
HashInt32Speed          33.3ns ± 6%    33.6ns ± 4%     ~     (p=0.071 n=10+10)
HashInt64Speed          32.7ns ± 3%    34.0ns ± 3%   +4.05%  (p=0.000 n=9+10)
HashStringArraySpeed     131ns ± 2%     117ns ± 5%  -10.32%  (p=0.000 n=9+10)
FastrandHashiter        72.2ns ± 1%    75.7ns ±10%   +4.87%  (p=0.019 n=8+10)

name                  old speed      new speed      delta
Hash5                  173MB/s ± 0%   167MB/s ± 0%   -3.63%  (p=0.000 n=9+10)
Hash16                 494MB/s ± 0%   530MB/s ± 0%   +7.23%  (p=0.000 n=10+8)
Hash64                1.22GB/s ± 0%  1.48GB/s ± 0%  +20.77%  (p=0.000 n=9+10)
Hash1024              2.47GB/s ± 0%  3.97GB/s ± 2%  +61.01%  (p=0.000 n=8+10)
Hash65536             2.64GB/s ± 0%  4.48GB/s ± 0%  +70.13%  (p=0.000 n=9+9)

Change-Id: I76af4e2bc1995a18149d11983ea8a149c132865e
Reviewed-on: https://go-review.googlesource.com/c/go/+/279612
Trust: Meng Zhuo <mzh@golangcn.org>
Run-TryBot: Meng Zhuo <mzh@golangcn.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/ssagen/ssa.go    |   1 +
 src/cmd/compile/internal/test/inl_test.go |   4 +-
 src/runtime/hash64.go                     | 136 ++++++++++------------
 src/runtime/internal/math/math.go         |  21 ++++
 4 files changed, 84 insertions(+), 78 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 97b970012d..de60cbf390 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -4484,6 +4484,7 @@ func InitTables() {
 		},
 		sys.AMD64, sys.ARM64, sys.PPC64, sys.S390X, sys.MIPS64)
 	alias("math/bits", "Mul", "math/bits", "Mul64", sys.ArchAMD64, sys.ArchARM64, sys.ArchPPC64, sys.ArchS390X, sys.ArchMIPS64, sys.ArchMIPS64LE)
+	alias("runtime/internal/math", "Mul64", "math/bits", "Mul64", sys.ArchAMD64, sys.ArchARM64, sys.ArchPPC64, sys.ArchS390X, sys.ArchMIPS64, sys.ArchMIPS64LE)
 	addF("math/bits", "Add64",
 		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue3(ssa.OpAdd64carry, types.NewTuple(types.Types[types.TUINT64], types.Types[types.TUINT64]), args[0], args[1], args[2])
diff --git a/src/cmd/compile/internal/test/inl_test.go b/src/cmd/compile/internal/test/inl_test.go
index fb9942a8da..6f100033cf 100644
--- a/src/cmd/compile/internal/test/inl_test.go
+++ b/src/cmd/compile/internal/test/inl_test.go
@@ -175,8 +175,8 @@ func TestIntendedInlining(t *testing.T) {
 		want["runtime/internal/sys"] = append(want["runtime/internal/sys"], "Bswap32")
 	}
 	if bits.UintSize == 64 {
-		// rotl_31 is only defined on 64-bit architectures
-		want["runtime"] = append(want["runtime"], "rotl_31")
+		// mix is only defined on 64-bit architectures
+		want["runtime"] = append(want["runtime"], "mix")
 	}
 
 	switch runtime.GOARCH {
diff --git a/src/runtime/hash64.go b/src/runtime/hash64.go
index 1bee666bd7..5f7d00bf7f 100644
--- a/src/runtime/hash64.go
+++ b/src/runtime/hash64.go
@@ -3,107 +3,91 @@
 // license that can be found in the LICENSE file.
 
 // Hashing algorithm inspired by
-//   xxhash: https://code.google.com/p/xxhash/
-// cityhash: https://code.google.com/p/cityhash/
+// wyhash: https://github.com/wangyi-fudan/wyhash
 
 //go:build amd64 || arm64 || mips64 || mips64le || ppc64 || ppc64le || riscv64 || s390x || wasm
 // +build amd64 arm64 mips64 mips64le ppc64 ppc64le riscv64 s390x wasm
 
 package runtime
 
-import "unsafe"
+import (
+	"runtime/internal/math"
+	"unsafe"
+)
 
 const (
-	// Constants for multiplication: four random odd 64-bit numbers.
-	m1 = 16877499708836156737
-	m2 = 2820277070424839065
-	m3 = 9497967016996688599
-	m4 = 15839092249703872147
+	m1 = 0xa0761d6478bd642f
+	m2 = 0xe7037ed1a0b428db
+	m3 = 0x8ebc6af09c88c6e3
+	m4 = 0x589965cc75374cc3
+	m5 = 0x1d8e4e27c47d124f
 )
 
 func memhashFallback(p unsafe.Pointer, seed, s uintptr) uintptr {
-	h := uint64(seed + s*hashkey[0])
-tail:
+	var a, b uintptr
+	seed ^= hashkey[0] ^ m1
 	switch {
 	case s == 0:
+		return seed
 	case s < 4:
-		h ^= uint64(*(*byte)(p))
-		h ^= uint64(*(*byte)(add(p, s>>1))) << 8
-		h ^= uint64(*(*byte)(add(p, s-1))) << 16
-		h = rotl_31(h*m1) * m2
-	case s <= 8:
-		h ^= uint64(readUnaligned32(p))
-		h ^= uint64(readUnaligned32(add(p, s-4))) << 32
-		h = rotl_31(h*m1) * m2
+		a = uintptr(*(*byte)(p))
+		a |= uintptr(*(*byte)(add(p, s>>1))) << 8
+		a |= uintptr(*(*byte)(add(p, s-1))) << 16
+	case s == 4:
+		a = r4(p)
+		b = a
+	case s < 8:
+		a = r4(p)
+		b = r4(add(p, s-4))
+	case s == 8:
+		a = r8(p)
+		b = a
 	case s <= 16:
-		h ^= readUnaligned64(p)
-		h = rotl_31(h*m1) * m2
-		h ^= readUnaligned64(add(p, s-8))
-		h = rotl_31(h*m1) * m2
-	case s <= 32:
-		h ^= readUnaligned64(p)
-		h = rotl_31(h*m1) * m2
-		h ^= readUnaligned64(add(p, 8))
-		h = rotl_31(h*m1) * m2
-		h ^= readUnaligned64(add(p, s-16))
-		h = rotl_31(h*m1) * m2
-		h ^= readUnaligned64(add(p, s-8))
-		h = rotl_31(h*m1) * m2
+		a = r8(p)
+		b = r8(add(p, s-8))
 	default:
-		v1 := h
-		v2 := uint64(seed * hashkey[1])
-		v3 := uint64(seed * hashkey[2])
-		v4 := uint64(seed * hashkey[3])
-		for s >= 32 {
-			v1 ^= readUnaligned64(p)
-			v1 = rotl_31(v1*m1) * m2
-			p = add(p, 8)
-			v2 ^= readUnaligned64(p)
-			v2 = rotl_31(v2*m2) * m3
-			p = add(p, 8)
-			v3 ^= readUnaligned64(p)
-			v3 = rotl_31(v3*m3) * m4
-			p = add(p, 8)
-			v4 ^= readUnaligned64(p)
-			v4 = rotl_31(v4*m4) * m1
-			p = add(p, 8)
-			s -= 32
+		l := s
+		if l > 48 {
+			seed1 := seed
+			seed2 := seed
+			for ; l > 48; l -= 48 {
+				seed = mix(r8(p)^m2, r8(add(p, 8))^seed)
+				seed1 = mix(r8(add(p, 16))^m3, r8(add(p, 24))^seed1)
+				seed2 = mix(r8(add(p, 32))^m4, r8(add(p, 40))^seed2)
+				p = add(p, 48)
+			}
+			seed ^= seed1 ^ seed2
+		}
+		for ; l > 16; l -= 16 {
+			seed = mix(r8(p)^m2, r8(add(p, 8))^seed)
+			p = add(p, 16)
 		}
-		h = v1 ^ v2 ^ v3 ^ v4
-		goto tail
+		a = r8(add(p, l-16))
+		b = r8(add(p, l-8))
 	}
 
-	h ^= h >> 29
-	h *= m3
-	h ^= h >> 32
-	return uintptr(h)
+	return mix(m5^s, mix(a^m2, b^seed))
 }
 
 func memhash32Fallback(p unsafe.Pointer, seed uintptr) uintptr {
-	h := uint64(seed + 4*hashkey[0])
-	v := uint64(readUnaligned32(p))
-	h ^= v
-	h ^= v << 32
-	h = rotl_31(h*m1) * m2
-	h ^= h >> 29
-	h *= m3
-	h ^= h >> 32
-	return uintptr(h)
+	a := r4(p)
+	return mix(m5^4, mix(a^m2, a^seed^hashkey[0]^m1))
 }
 
 func memhash64Fallback(p unsafe.Pointer, seed uintptr) uintptr {
-	h := uint64(seed + 8*hashkey[0])
-	h ^= uint64(readUnaligned32(p)) | uint64(readUnaligned32(add(p, 4)))<<32
-	h = rotl_31(h*m1) * m2
-	h ^= h >> 29
-	h *= m3
-	h ^= h >> 32
-	return uintptr(h)
+	a := r8(p)
+	return mix(m5^8, mix(a^m2, a^seed^hashkey[0]^m1))
+}
+
+func mix(a, b uintptr) uintptr {
+	hi, lo := math.Mul64(uint64(a), uint64(b))
+	return uintptr(hi ^ lo)
+}
+
+func r4(p unsafe.Pointer) uintptr {
+	return uintptr(readUnaligned32(p))
 }
 
-// Note: in order to get the compiler to issue rotl instructions, we
-// need to constant fold the shift amount by hand.
-// TODO: convince the compiler to issue rotl instructions after inlining.
-func rotl_31(x uint64) uint64 {
-	return (x << 31) | (x >> (64 - 31))
+func r8(p unsafe.Pointer) uintptr {
+	return uintptr(readUnaligned64(p))
 }
diff --git a/src/runtime/internal/math/math.go b/src/runtime/internal/math/math.go
index 5385f5dd86..b6bd12d3e8 100644
--- a/src/runtime/internal/math/math.go
+++ b/src/runtime/internal/math/math.go
@@ -17,3 +17,24 @@ func MulUintptr(a, b uintptr) (uintptr, bool) {
 	overflow := b > MaxUintptr/a
 	return a * b, overflow
 }
+
+// Mul64 returns the 128-bit product of x and y: (hi, lo) = x * y
+// with the product bits' upper half returned in hi and the lower
+// half returned in lo.
+// This is a copy from math/bits.Mul64
+// On supported platforms this is an intrinsic lowered by the compiler.
+func Mul64(x, y uint64) (hi, lo uint64) {
+	const mask32 = 1<<32 - 1
+	x0 := x & mask32
+	x1 := x >> 32
+	y0 := y & mask32
+	y1 := y >> 32
+	w0 := x0 * y0
+	t := x1*y0 + w0>>32
+	w1 := t & mask32
+	w2 := t >> 32
+	w1 += x0 * y1
+	hi = x1*y1 + w2 + w1>>32
+	lo = x * y
+	return
+}
-- 
GitLab


From e12abe4bd63883b16a76f650222dd4617504e43f Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Sun, 11 Apr 2021 14:33:16 +0200
Subject: [PATCH 1488/2400] net: fix (*ipStackCapabilities).probe godoc

Change-Id: I2e5db6e7e9a7b3c84449d16b6bc32afe1d0ffee9
Reviewed-on: https://go-review.googlesource.com/c/go/+/308991
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/net/ipsock_plan9.go | 2 +-
 src/net/ipsock_posix.go | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/net/ipsock_plan9.go b/src/net/ipsock_plan9.go
index 8e984d5e5f..43287431c8 100644
--- a/src/net/ipsock_plan9.go
+++ b/src/net/ipsock_plan9.go
@@ -13,7 +13,7 @@ import (
 	"syscall"
 )
 
-// Probe probes IPv4, IPv6 and IPv4-mapped IPv6 communication
+// probe probes IPv4, IPv6 and IPv4-mapped IPv6 communication
 // capabilities.
 //
 // Plan 9 uses IPv6 natively, see ip(3).
diff --git a/src/net/ipsock_posix.go b/src/net/ipsock_posix.go
index 8d8a896501..c51c227401 100644
--- a/src/net/ipsock_posix.go
+++ b/src/net/ipsock_posix.go
@@ -14,13 +14,13 @@ import (
 	"syscall"
 )
 
-// Probe probes IPv4, IPv6 and IPv4-mapped IPv6 communication
+// probe probes IPv4, IPv6 and IPv4-mapped IPv6 communication
 // capabilities which are controlled by the IPV6_V6ONLY socket option
 // and kernel configuration.
 //
 // Should we try to use the IPv4 socket interface if we're only
 // dealing with IPv4 sockets? As long as the host system understands
-// IPv4-mapped IPv6, it's okay to pass IPv4-mapeed IPv6 addresses to
+// IPv4-mapped IPv6, it's okay to pass IPv4-mapped IPv6 addresses to
 // the IPv6 interface. That simplifies our code and is most
 // general. Unfortunately, we need to run on kernels built without
 // IPv6 support too. So probe the kernel to figure it out.
-- 
GitLab


From 954bd8203bfe3033b9794ad4ec2c82cfd6be1414 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Sun, 11 Apr 2021 14:53:18 +0200
Subject: [PATCH 1489/2400] cmd/cgo: use tabs to indent
 _cgoPREFIX_Cfunc__CMalloc function body

All other _cgoPREFIX_Cfunc_* functions are indented using tabs.

Change-Id: Ic5cfccd3000d34d0bbe08d035f18640af5e05473
Reviewed-on: https://go-review.googlesource.com/c/go/+/308993
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/cmd/cgo/out.go | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/cmd/cgo/out.go b/src/cmd/cgo/out.go
index 8e83f02202..d0a7369c94 100644
--- a/src/cmd/cgo/out.go
+++ b/src/cmd/cgo/out.go
@@ -1746,12 +1746,12 @@ Slice _cgoPREFIX_Cfunc_GoBytes(char *p, int32_t n) {
 
 extern void runtime_throw(const char *);
 void *_cgoPREFIX_Cfunc__CMalloc(size_t n) {
-        void *p = malloc(n);
-        if(p == NULL && n == 0)
-                p = malloc(1);
-        if(p == NULL)
-                runtime_throw("runtime: C malloc failed");
-        return p;
+	void *p = malloc(n);
+	if(p == NULL && n == 0)
+		p = malloc(1);
+	if(p == NULL)
+		runtime_throw("runtime: C malloc failed");
+	return p;
 }
 
 struct __go_type_descriptor;
-- 
GitLab


From 16cd770e0668a410a511680b2ac1412e554bd27b Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Sun, 11 Apr 2021 14:49:38 +0200
Subject: [PATCH 1490/2400] cmd/cgo: throw if C.malloc returns NULL in
 C.CString or C.CBytes

Change-Id: Iea07b7f3e64f5938cfb1cd1c07bdce4adf8e4470
Reviewed-on: https://go-review.googlesource.com/c/go/+/308992
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/cmd/cgo/out.go | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/cmd/cgo/out.go b/src/cmd/cgo/out.go
index d0a7369c94..2d8d692622 100644
--- a/src/cmd/cgo/out.go
+++ b/src/cmd/cgo/out.go
@@ -1717,8 +1717,12 @@ typedef struct __go_open_array {
 struct __go_string __go_byte_array_to_string(const void* p, intgo len);
 struct __go_open_array __go_string_to_byte_array (struct __go_string str);
 
+extern void runtime_throw(const char *);
+
 const char *_cgoPREFIX_Cfunc_CString(struct __go_string s) {
 	char *p = malloc(s.__length+1);
+	if(p == NULL)
+		runtime_throw("runtime: C malloc failed");
 	memmove(p, s.__data, s.__length);
 	p[s.__length] = 0;
 	return p;
@@ -1726,6 +1730,8 @@ const char *_cgoPREFIX_Cfunc_CString(struct __go_string s) {
 
 void *_cgoPREFIX_Cfunc_CBytes(struct __go_open_array b) {
 	char *p = malloc(b.__count);
+	if(p == NULL)
+		runtime_throw("runtime: C malloc failed");
 	memmove(p, b.__values, b.__count);
 	return p;
 }
@@ -1744,7 +1750,6 @@ Slice _cgoPREFIX_Cfunc_GoBytes(char *p, int32_t n) {
 	return __go_string_to_byte_array(s);
 }
 
-extern void runtime_throw(const char *);
 void *_cgoPREFIX_Cfunc__CMalloc(size_t n) {
 	void *p = malloc(n);
 	if(p == NULL && n == 0)
-- 
GitLab


From c26f954a540a99eafac6ee3bb3b996c750aad8a4 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Tue, 6 Apr 2021 16:18:50 -0400
Subject: [PATCH 1491/2400] cmd/compile/internal/amd64: follow-on regabi fix
 for amd64 zerorange

This patch provides a better long-term fix for the compiler's
zerorange() helper function to make it generate code friendly to the
register ABI.

CL 305829 did part of the work, but didn't properly handle the case
where the compiler emits a REP.STOSQ sequence; this patch changes the
REP code to make sure it doesn't clobber any incoming register
parameter values.

Also included is a test that is specifically written to trigger
the REP emit code in the compiler (prior to this, this code was
not being hit on linux/amd64 all.bash).

Updates #45372.
Updates #40724.

Change-Id: Iaf1c4e709e98eda45cd6f3aeebda0fe9160f1f42
Reviewed-on: https://go-review.googlesource.com/c/go/+/307829
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/amd64/ggen.go        | 30 ++++--
 .../compile/internal/test/zerorange_test.go   | 91 ++++++++++++++++++-
 2 files changed, 112 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/internal/amd64/ggen.go b/src/cmd/compile/internal/amd64/ggen.go
index f065bb4dd4..b5847d48b9 100644
--- a/src/cmd/compile/internal/amd64/ggen.go
+++ b/src/cmd/compile/internal/amd64/ggen.go
@@ -58,7 +58,6 @@ func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.
 	const (
 		r13 = 1 << iota // if R13 is already zeroed.
 		x15             // if X15 is already zeroed. Note: in new ABI, X15 is always zero.
-		rax             // if RAX is already zeroed.
 	)
 
 	if cnt == 0 {
@@ -117,18 +116,33 @@ func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.
 		p = pp.Append(p, x86.AMOVQ, obj.TYPE_REG, x86.REG_R12, 0, obj.TYPE_REG, x86.REG_DI, 0)
 
 	} else {
-		// Note: here we have to use RAX since it is an implicit input
-		// for the REPSTOSQ below. This is going to be problematic when
-		// regabi is in effect; this will be fixed in a forthcoming CL.
-		if *state&rax == 0 {
-			p = pp.Append(p, x86.AMOVQ, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
-			*state |= rax
-		}
+		// When the register ABI is in effect, at this point in the
+		// prolog we may have live values in all of RAX,RDI,RCX. Save
+		// them off to registers before the REPSTOSQ below, then
+		// restore. Note that R12 and R13 are always available as
+		// scratch regs; here we also use R15 (this is safe to do
+		// since there won't be any globals accessed in the prolog).
+		// See rewriteToUseGot() in obj6.go for more on r15 use.
+
+		// Save rax/rdi/rcx
+		p = pp.Append(p, x86.AMOVQ, obj.TYPE_REG, x86.REG_DI, 0, obj.TYPE_REG, x86.REG_R12, 0)
+		p = pp.Append(p, x86.AMOVQ, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_REG, x86.REG_R13, 0)
+		p = pp.Append(p, x86.AMOVQ, obj.TYPE_REG, x86.REG_CX, 0, obj.TYPE_REG, x86.REG_R15, 0)
 
+		// Set up the REPSTOSQ and kick it off.
+		p = pp.Append(p, x86.AMOVQ, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
 		p = pp.Append(p, x86.AMOVQ, obj.TYPE_CONST, 0, cnt/int64(types.RegSize), obj.TYPE_REG, x86.REG_CX, 0)
 		p = pp.Append(p, leaptr, obj.TYPE_MEM, x86.REG_SP, off, obj.TYPE_REG, x86.REG_DI, 0)
 		p = pp.Append(p, x86.AREP, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
 		p = pp.Append(p, x86.ASTOSQ, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
+
+		// Restore rax/rdi/rcx
+		p = pp.Append(p, x86.AMOVQ, obj.TYPE_REG, x86.REG_R12, 0, obj.TYPE_REG, x86.REG_DI, 0)
+		p = pp.Append(p, x86.AMOVQ, obj.TYPE_REG, x86.REG_R13, 0, obj.TYPE_REG, x86.REG_AX, 0)
+		p = pp.Append(p, x86.AMOVQ, obj.TYPE_REG, x86.REG_R15, 0, obj.TYPE_REG, x86.REG_CX, 0)
+
+		// Record the fact that r13 is no longer zero.
+		*state &= ^uint32(r13)
 	}
 
 	return p
diff --git a/src/cmd/compile/internal/test/zerorange_test.go b/src/cmd/compile/internal/test/zerorange_test.go
index cb1a6e04e4..ec87136157 100644
--- a/src/cmd/compile/internal/test/zerorange_test.go
+++ b/src/cmd/compile/internal/test/zerorange_test.go
@@ -4,7 +4,9 @@
 
 package test
 
-import "testing"
+import (
+	"testing"
+)
 
 var glob = 3
 var globp *int64
@@ -94,3 +96,90 @@ func testZeroRange136(t *testing.T) (r, s, t2, u, v, w, x, y, r1, s1, t1, u1, v1
 	globp = &z1
 	return
 }
+
+type S struct {
+	x [2]uint64
+	p *uint64
+	y [2]uint64
+	q uint64
+}
+
+type M struct {
+	x [8]uint64
+	p *uint64
+	y [8]uint64
+	q uint64
+}
+
+type L struct {
+	x [4096]uint64
+	p *uint64
+	y [4096]uint64
+	q uint64
+}
+
+//go:noinline
+func triggerZerorangeLarge(f, g, h uint64) (rv0 uint64) {
+	ll := L{p: &f}
+	da := f
+	rv0 = f + g + h
+	defer func(dl L, i uint64) {
+		rv0 += dl.q + i
+	}(ll, da)
+	return rv0
+}
+
+//go:noinline
+func triggerZerorangeMedium(f, g, h uint64) (rv0 uint64) {
+	ll := M{p: &f}
+	rv0 = f + g + h
+	defer func(dm M, i uint64) {
+		rv0 += dm.q + i
+	}(ll, f)
+	return rv0
+}
+
+//go:noinline
+func triggerZerorangeSmall(f, g, h uint64) (rv0 uint64) {
+	ll := S{p: &f}
+	rv0 = f + g + h
+	defer func(ds S, i uint64) {
+		rv0 += ds.q + i
+	}(ll, f)
+	return rv0
+}
+
+// This test was created as a follow up to issue #45372, to help
+// improve coverage of the compiler's arch-specific "zerorange"
+// function, which is invoked to zero out ambiguously live portions of
+// the stack frame in certain specific circumstances.
+//
+// In the current compiler implementation, for zerorange to be
+// invoked, we need to have an ambiguously live variable that needs
+// zeroing. One way to trigger this is to have a function with an
+// open-coded defer, where the opendefer function has an argument that
+// contains a pointer (this is what's used below).
+//
+// At the moment this test doesn't do any specific checking for
+// code sequence, or verification that things were properly set to zero,
+// this seems as though it would be too tricky and would result
+// in a "brittle" test.
+//
+// The small/medium/large scenarios below are inspired by the amd64
+// implementation of zerorange, which generates different code
+// depending on the size of the thing that needs to be zeroed out
+// (I've verified at the time of the writing of this test that it
+// exercises the various cases).
+//
+func TestZerorange45372(t *testing.T) {
+	if r := triggerZerorangeLarge(101, 303, 505); r != 1010 {
+		t.Errorf("large: wanted %d got %d", 1010, r)
+	}
+	if r := triggerZerorangeMedium(101, 303, 505); r != 1010 {
+		t.Errorf("medium: wanted %d got %d", 1010, r)
+	}
+	if r := triggerZerorangeSmall(101, 303, 505); r != 1010 {
+		t.Errorf("small: wanted %d got %d", 1010, r)
+	}
+
+}
-- 
GitLab


From 117b1c84d3678a586c168a5f7f2f0a750c27f0c2 Mon Sep 17 00:00:00 2001
From: Hajime Hoshi <hajimehoshi@gmail.com>
Date: Sat, 26 Dec 2020 02:25:13 +0900
Subject: [PATCH 1492/2400] cmd/go/internal/work: remove '_test' from import
 paths in stacktraces when -trimpath is specified

ExampleFrames with -trimpath failed since the content of Frame's File
changed when -trimpath is specified.

This CL fixes the issue by adding a new field OrigImportPath to
PackageInternal, which represents the original import path before adding
'_test' suffix for an external test package, and always using it to
create paths for the build tools.

Fixes golang/go#43380

Change-Id: Ibbc947eb3ae08a7ba81f13f03af67c8745b5c69f
Reviewed-on: https://go-review.googlesource.com/c/go/+/279440
Run-TryBot: Hajime Hoshi <hajimehoshi@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Hajime Hoshi <hajimehoshi@gmail.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go/internal/load/pkg.go               |  2 +
 src/cmd/go/internal/load/test.go              | 25 +++++----
 src/cmd/go/internal/work/gc.go                |  5 +-
 src/cmd/go/testdata/script/test_trimpath.txt  | 51 +++++++++++++++++++
 .../go/testdata/script/test_trimpath_main.txt | 38 ++++++++++++++
 .../script/test_trimpath_test_suffix.txt      | 40 +++++++++++++++
 6 files changed, 148 insertions(+), 13 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/test_trimpath.txt
 create mode 100644 src/cmd/go/testdata/script/test_trimpath_main.txt
 create mode 100644 src/cmd/go/testdata/script/test_trimpath_test_suffix.txt

diff --git a/src/cmd/go/internal/load/pkg.go b/src/cmd/go/internal/load/pkg.go
index a6d730d0d8..00c50bf38f 100644
--- a/src/cmd/go/internal/load/pkg.go
+++ b/src/cmd/go/internal/load/pkg.go
@@ -207,6 +207,7 @@ type PackageInternal struct {
 	BuildInfo         string               // add this info to package main
 	TestmainGo        *[]byte              // content for _testmain.go
 	Embed             map[string][]string  // //go:embed comment mapping
+	OrigImportPath    string               // original import path before adding '_test' suffix
 
 	Asmflags   []string // -asmflags for this package
 	Gcflags    []string // -gcflags for this package
@@ -402,6 +403,7 @@ func (p *Package) copyBuild(pp *build.Package) {
 	p.EmbedPatterns = pp.EmbedPatterns
 	p.TestEmbedPatterns = pp.TestEmbedPatterns
 	p.XTestEmbedPatterns = pp.XTestEmbedPatterns
+	p.Internal.OrigImportPath = pp.ImportPath
 }
 
 // A PackageError describes an error loading information about a package.
diff --git a/src/cmd/go/internal/load/test.go b/src/cmd/go/internal/load/test.go
index fc89bd0250..9385f41182 100644
--- a/src/cmd/go/internal/load/test.go
+++ b/src/cmd/go/internal/load/test.go
@@ -204,6 +204,7 @@ func TestPackagesAndErrors(ctx context.Context, p *Package, cover *TestCover) (p
 		}
 		ptest.Internal.Embed = testEmbed
 		ptest.EmbedFiles = str.StringList(p.EmbedFiles, p.TestEmbedFiles)
+		ptest.Internal.OrigImportPath = p.Internal.OrigImportPath
 		ptest.collectDeps()
 	} else {
 		ptest = p
@@ -233,11 +234,12 @@ func TestPackagesAndErrors(ctx context.Context, p *Package, cover *TestCover) (p
 				Imports:    ximports,
 				RawImports: rawXTestImports,
 
-				Asmflags:   p.Internal.Asmflags,
-				Gcflags:    p.Internal.Gcflags,
-				Ldflags:    p.Internal.Ldflags,
-				Gccgoflags: p.Internal.Gccgoflags,
-				Embed:      xtestEmbed,
+				Asmflags:       p.Internal.Asmflags,
+				Gcflags:        p.Internal.Gcflags,
+				Ldflags:        p.Internal.Ldflags,
+				Gccgoflags:     p.Internal.Gccgoflags,
+				Embed:          xtestEmbed,
+				OrigImportPath: p.Internal.OrigImportPath,
 			},
 		}
 		if pxtestNeedsPtest {
@@ -258,12 +260,13 @@ func TestPackagesAndErrors(ctx context.Context, p *Package, cover *TestCover) (p
 			Module:     p.Module,
 		},
 		Internal: PackageInternal{
-			Build:      &build.Package{Name: "main"},
-			BuildInfo:  p.Internal.BuildInfo,
-			Asmflags:   p.Internal.Asmflags,
-			Gcflags:    p.Internal.Gcflags,
-			Ldflags:    p.Internal.Ldflags,
-			Gccgoflags: p.Internal.Gccgoflags,
+			Build:          &build.Package{Name: "main"},
+			BuildInfo:      p.Internal.BuildInfo,
+			Asmflags:       p.Internal.Asmflags,
+			Gcflags:        p.Internal.Gcflags,
+			Ldflags:        p.Internal.Ldflags,
+			Gccgoflags:     p.Internal.Gccgoflags,
+			OrigImportPath: p.Internal.OrigImportPath,
 		},
 	}
 
diff --git a/src/cmd/go/internal/work/gc.go b/src/cmd/go/internal/work/gc.go
index 7ccba4a561..60d0b29a21 100644
--- a/src/cmd/go/internal/work/gc.go
+++ b/src/cmd/go/internal/work/gc.go
@@ -290,10 +290,11 @@ func (a *Action) trimpath() string {
 
 	rewriteDir := a.Package.Dir
 	if cfg.BuildTrimpath {
+		importPath := a.Package.Internal.OrigImportPath
 		if m := a.Package.Module; m != nil && m.Version != "" {
-			rewriteDir = m.Path + "@" + m.Version + strings.TrimPrefix(a.Package.ImportPath, m.Path)
+			rewriteDir = m.Path + "@" + m.Version + strings.TrimPrefix(importPath, m.Path)
 		} else {
-			rewriteDir = a.Package.ImportPath
+			rewriteDir = importPath
 		}
 		rewrite += a.Package.Dir + "=>" + rewriteDir + ";"
 	}
diff --git a/src/cmd/go/testdata/script/test_trimpath.txt b/src/cmd/go/testdata/script/test_trimpath.txt
new file mode 100644
index 0000000000..065f9ce4d1
--- /dev/null
+++ b/src/cmd/go/testdata/script/test_trimpath.txt
@@ -0,0 +1,51 @@
+[short] skip
+
+go test -trimpath -v .
+! stdout '[/\\]pkg_test[/\\]'
+stdout -count=3 '[/\\]pkg[/\\]'
+
+-- go.mod --
+module example.com/pkg
+
+go 1.17
+
+-- pkg.go --
+package pkg
+
+import "runtime"
+
+func PrintFile() {
+	_, file, _, _ := runtime.Caller(0)
+	println(file)
+}
+
+-- pkg_test.go --
+package pkg
+
+import "runtime"
+
+func PrintFileForTest() {
+	_, file, _, _ := runtime.Caller(0)
+	println(file)
+}
+
+-- pkg_x_test.go --
+package pkg_test
+
+import (
+	"runtime"
+	"testing"
+
+	"example.com/pkg"
+)
+
+func TestMain(m *testing.M) {
+	pkg.PrintFile()
+	pkg.PrintFileForTest()
+	PrintFileInXTest()
+}
+
+func PrintFileInXTest() {
+	_, file, _, _ := runtime.Caller(0)
+	println(file)
+}
diff --git a/src/cmd/go/testdata/script/test_trimpath_main.txt b/src/cmd/go/testdata/script/test_trimpath_main.txt
new file mode 100644
index 0000000000..c07621245f
--- /dev/null
+++ b/src/cmd/go/testdata/script/test_trimpath_main.txt
@@ -0,0 +1,38 @@
+[short] skip
+
+go test -trimpath -v .
+! stdout '[/\\]pkg_test[/\\]'
+stdout -count=2 '[/\\]pkg[/\\]'
+
+-- go.mod --
+module example.com/pkg
+
+go 1.17
+
+-- main.go --
+package main
+
+import "runtime"
+
+func PrintFile() {
+	_, file, _, _ := runtime.Caller(0)
+	println(file)
+}
+
+-- main_test.go --
+package main
+
+import (
+	"runtime"
+	"testing"
+)
+
+func PrintFileForTest() {
+	_, file, _, _ := runtime.Caller(0)
+	println(file)
+}
+
+func TestMain(m *testing.M) {
+	PrintFile()
+	PrintFileForTest()
+}
diff --git a/src/cmd/go/testdata/script/test_trimpath_test_suffix.txt b/src/cmd/go/testdata/script/test_trimpath_test_suffix.txt
new file mode 100644
index 0000000000..6cbad83bc7
--- /dev/null
+++ b/src/cmd/go/testdata/script/test_trimpath_test_suffix.txt
@@ -0,0 +1,40 @@
+[short] skip
+
+go test -trimpath -v .
+! stdout '[/\\]pkg_test_test[/\\]'
+stdout -count=2 '[/\\]pkg_test[/\\]'
+
+-- go.mod --
+module example.com/pkg_test
+
+go 1.17
+
+-- pkg.go --
+package pkg_test
+
+import "runtime"
+
+func PrintFile() {
+	_, file, _, _ := runtime.Caller(0)
+	println(file)
+}
+
+-- pkg_x_test.go --
+package pkg_test_test
+
+import (
+	"runtime"
+	"testing"
+
+	"example.com/pkg_test"
+)
+
+func PrintFileForTest() {
+	_, file, _, _ := runtime.Caller(0)
+	println(file)
+}
+
+func TestMain(m *testing.M) {
+	pkg_test.PrintFile()
+	PrintFileForTest()
+}
-- 
GitLab


From 51a47b7ff2934b6c28ece51f6a37dc30bd37a02d Mon Sep 17 00:00:00 2001
From: Julie Qiu <julie@golang.org>
Date: Wed, 24 Mar 2021 16:24:38 -0400
Subject: [PATCH 1493/2400] cmd/go: display helpful error when module cache
 can't be created

Previously when the module cache specified by GOMODCACHE could not be
created an unhelpful message would be printed multiple times.

This happened because we were fetching several things in parallel then
failing to write them because we can't create the module cache.

We now check if the module cache can be created before fetching.

If not, the following message is printed:

go: could not create module cache

Fixes #45113

Change-Id: Ic9cec787411335edc7f4d0614fde7eaa8a957fb5
Reviewed-on: https://go-review.googlesource.com/c/go/+/304571
Trust: Julie Qiu <julie@golang.org>
Run-TryBot: Julie Qiu <julie@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modfetch/cache.go         | 34 +++++++++++++++++--
 src/cmd/go/testdata/script/mod_gomodcache.txt |  7 ++++
 2 files changed, 39 insertions(+), 2 deletions(-)

diff --git a/src/cmd/go/internal/modfetch/cache.go b/src/cmd/go/internal/modfetch/cache.go
index c1303502e5..f3b58a172a 100644
--- a/src/cmd/go/internal/modfetch/cache.go
+++ b/src/cmd/go/internal/modfetch/cache.go
@@ -347,6 +347,9 @@ func GoMod(path, rev string) ([]byte, error) {
 		if _, info, err := readDiskStat(path, rev); err == nil {
 			rev = info.Version
 		} else {
+			if errors.Is(err, statCacheErr) {
+				return nil, err
+			}
 			err := TryProxies(func(proxy string) error {
 				info, err := Lookup(proxy, path).Stat(rev)
 				if err == nil {
@@ -706,15 +709,42 @@ func rewriteVersionList(dir string) (err error) {
 	return nil
 }
 
+var (
+	statCacheOnce sync.Once
+	statCacheErr  error
+)
+
+// checkCacheDir checks if the directory specified by GOMODCACHE exists. An
+// error is returned if it does not.
 func checkCacheDir() error {
 	if cfg.GOMODCACHE == "" {
 		// modload.Init exits if GOPATH[0] is empty, and cfg.GOMODCACHE
 		// is set to GOPATH[0]/pkg/mod if GOMODCACHE is empty, so this should never happen.
 		return fmt.Errorf("internal error: cfg.GOMODCACHE not set")
 	}
-
 	if !filepath.IsAbs(cfg.GOMODCACHE) {
 		return fmt.Errorf("GOMODCACHE entry is relative; must be absolute path: %q.\n", cfg.GOMODCACHE)
 	}
-	return nil
+
+	// os.Stat is slow on Windows, so we only call it once to prevent unnecessary
+	// I/O every time this function is called.
+	statCacheOnce.Do(func() {
+		fi, err := os.Stat(cfg.GOMODCACHE)
+		if err != nil {
+			if !os.IsNotExist(err) {
+				statCacheErr = fmt.Errorf("could not create module cache: %w", err)
+				return
+			}
+			if err := os.MkdirAll(cfg.GOMODCACHE, 0777); err != nil {
+				statCacheErr = fmt.Errorf("could not create module cache: %w", err)
+				return
+			}
+			return
+		}
+		if !fi.IsDir() {
+			statCacheErr = fmt.Errorf("could not create module cache: %q is not a directory", cfg.GOMODCACHE)
+			return
+		}
+	})
+	return statCacheErr
 }
diff --git a/src/cmd/go/testdata/script/mod_gomodcache.txt b/src/cmd/go/testdata/script/mod_gomodcache.txt
index b2143e2093..74a3c79622 100644
--- a/src/cmd/go/testdata/script/mod_gomodcache.txt
+++ b/src/cmd/go/testdata/script/mod_gomodcache.txt
@@ -47,6 +47,11 @@ env GOMODCACHE=$WORK/modcache
 go mod download rsc.io/quote@v1.0.0
 exists $WORK/modcache/cache/download/rsc.io/quote/@v/v1.0.0.info
 
+# Test error when cannot create GOMODCACHE directory
+env GOMODCACHE=$WORK/modcachefile
+! go install example.com/cmd/a@v1.0.0
+stderr 'go: could not create module cache'
+
 # Test that the following work even with GO111MODULE=off
 env GO111MODULE=off
 
@@ -58,3 +63,5 @@ go clean -modcache
 
 -- go.mod --
 module m
+
+-- $WORK/modcachefile --
-- 
GitLab


From 9ed0e320599bcd559565207bb6a9b0c49a5b36ee Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Sun, 11 Apr 2021 13:26:44 -0400
Subject: [PATCH 1494/2400] test: consider default GOEXPERIMENT when matching
 build tags

If GOEXPERIMENT environment variable is unset, use the default
value that is baked into the toolchain (instead of no
experiments).

Change-Id: I41f863e6f7439f2d53e3ebd25a7d9cf4a176e32e
Reviewed-on: https://go-review.googlesource.com/c/go/+/309333
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 test/run.go | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/test/run.go b/test/run.go
index 48115ed18d..feab88338c 100644
--- a/test/run.go
+++ b/test/run.go
@@ -446,6 +446,18 @@ func (ctxt *context) match(name string) bool {
 	}
 
 	exp := os.Getenv("GOEXPERIMENT")
+	if exp == "" {
+		// If GOEXPERIMENT environment variable is unset, get the default value
+		// that is baked into the toolchain.
+		cmd := exec.Command(goTool(), "tool", "compile", "-V")
+		out, err := cmd.CombinedOutput()
+		if err == nil {
+			i := bytes.Index(out, []byte("X:"))
+			if i != -1 {
+				exp = string(out[i+2:])
+			}
+		}
+	}
 	if exp != "" {
 		experiments := strings.Split(exp, ",")
 		for _, e := range experiments {
-- 
GitLab


From 585b52261c1b4e26b029616581ee0e891ad49183 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Sat, 10 Apr 2021 23:02:04 -0400
Subject: [PATCH 1495/2400] runtime: remove deferreturn dummy argument

deferreturn has a dummy argument, that is only used for getting
the caller's SP. When generating deferreturn calls, the compiler
does not pass an actual argument or reserve its stack space.
Also, the current code is written with the assumption about where
the argument's address is on the stack. Currently this is correct
for both ABI0 and the register ABI, but it may change in the
future (e.g. if we remove dedicated spill slots). Remove the
argument.

Also remove the argument for getargp.

Change-Id: I96d07efa79a9c1a53ef3fc5adbecc11877e99dc1
Reviewed-on: https://go-review.googlesource.com/c/go/+/309329
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/runtime/panic.go | 22 ++++++++++------------
 1 file changed, 10 insertions(+), 12 deletions(-)

diff --git a/src/runtime/panic.go b/src/runtime/panic.go
index c437553012..f8f2f39dbb 100644
--- a/src/runtime/panic.go
+++ b/src/runtime/panic.go
@@ -541,10 +541,8 @@ func freedeferfn() {
 // modifying the caller's frame in order to reuse the frame to call the deferred
 // function.
 //
-// The single argument isn't actually used - it just has its address
-// taken so it can be matched against pending defers.
 //go:nosplit
-func deferreturn(arg0 uintptr) {
+func deferreturn() {
 	gp := getg()
 	d := gp._defer
 	if d == nil {
@@ -570,13 +568,14 @@ func deferreturn(arg0 uintptr) {
 	// nosplit because the garbage collector won't know the form
 	// of the arguments until the jmpdefer can flip the PC over to
 	// fn.
+	argp := getcallersp() + sys.MinFrameSize
 	switch d.siz {
 	case 0:
 		// Do nothing.
 	case sys.PtrSize:
-		*(*uintptr)(unsafe.Pointer(&arg0)) = *(*uintptr)(deferArgs(d))
+		*(*uintptr)(unsafe.Pointer(argp)) = *(*uintptr)(deferArgs(d))
 	default:
-		memmove(unsafe.Pointer(&arg0), deferArgs(d), uintptr(d.siz))
+		memmove(unsafe.Pointer(argp), deferArgs(d), uintptr(d.siz))
 	}
 	fn := d.fn
 	d.fn = nil
@@ -588,7 +587,7 @@ func deferreturn(arg0 uintptr) {
 	// stack, because the stack trace can be incorrect in that case - see
 	// issue #8153).
 	_ = fn.fn
-	jmpdefer(fn, uintptr(unsafe.Pointer(&arg0)))
+	jmpdefer(fn, argp)
 }
 
 // Goexit terminates the goroutine that calls it. No other goroutine is affected.
@@ -911,7 +910,7 @@ func reflectcallSave(p *_panic, fn, arg unsafe.Pointer, argsize uint32) {
 		throw("not allowed with GOEXPERIMENT=regabidefer")
 	}
 	if p != nil {
-		p.argp = unsafe.Pointer(getargp(0))
+		p.argp = unsafe.Pointer(getargp())
 		p.pc = getcallerpc()
 		p.sp = unsafe.Pointer(getcallersp())
 	}
@@ -937,7 +936,7 @@ func deferCallSave(p *_panic, fn func()) {
 		throw("only allowed with GOEXPERIMENT=regabidefer")
 	}
 	if p != nil {
-		p.argp = unsafe.Pointer(getargp(0))
+		p.argp = unsafe.Pointer(getargp())
 		p.pc = getcallerpc()
 		p.sp = unsafe.Pointer(getcallersp())
 	}
@@ -1034,7 +1033,7 @@ func gopanic(e interface{}) {
 				addOneOpenDeferFrame(gp, 0, nil)
 			}
 		} else {
-			p.argp = unsafe.Pointer(getargp(0))
+			p.argp = unsafe.Pointer(getargp())
 
 			if goexperiment.RegabiDefer {
 				fn := deferFunc(d)
@@ -1146,9 +1145,8 @@ func gopanic(e interface{}) {
 // writes outgoing function call arguments.
 //go:nosplit
 //go:noinline
-func getargp(x int) uintptr {
-	// x is an argument mainly so that we can return its address.
-	return uintptr(noescape(unsafe.Pointer(&x)))
+func getargp() uintptr {
+	return getcallersp() + sys.MinFrameSize
 }
 
 // The implementation of the predeclared function recover.
-- 
GitLab


From 70ed28e5f763d08ee0d3be7bde14b35ce3d6322e Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Sun, 11 Apr 2021 14:33:28 -0400
Subject: [PATCH 1496/2400] cmd/compile: support memmove inlining with register
 args

The rule that inlines memmove expects SSA ops that calls memmove
with arguments in memory. This CL adds a version that matches
it with arguments in registers, so the optimization works for
both situations.

Change-Id: Ideb64f65b7521481ab2ca7c9975a6cf7b70d5966
Reviewed-on: https://go-review.googlesource.com/c/go/+/309332
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: David Chase <drchase@google.com>
---
 .../compile/internal/ssa/gen/generic.rules    | 22 +++++--
 src/cmd/compile/internal/ssa/rewrite.go       |  6 +-
 .../compile/internal/ssa/rewritegeneric.go    | 58 +++++++++++++++++++
 3 files changed, 77 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules
index 6b5fd99c7e..aad7600d79 100644
--- a/src/cmd/compile/internal/ssa/gen/generic.rules
+++ b/src/cmd/compile/internal/ssa/gen/generic.rules
@@ -2055,12 +2055,13 @@
 (IsNonNil (Addr _)) => (ConstBool [true])
 (IsNonNil (LocalAddr _ _)) => (ConstBool [true])
 
-// TODO REGISTER ARGS this will need revision.
-// Because expand calls runs after prove, constants useful to this pattern may not appear
-// In the future both versions need to exist; the memory and register variants.
-
 // Inline small or disjoint runtime.memmove calls with constant length.
 // See the comment in op Move in genericOps.go for discussion of the type.
+
+// Because expand calls runs after prove, constants useful to this pattern may not appear.
+// Both versions need to exist; the memory and register variants.
+//
+// Match post-expansion calls, memory version.
 (SelectN [0] call:(StaticCall {sym} s1:(Store _ (Const(64|32) [sz]) s2:(Store  _ src s3:(Store {t} _ dst mem)))))
 	&& sz >= 0
 	&& isSameCall(sym, "runtime.memmove")
@@ -2070,8 +2071,17 @@
 	&& clobber(s1, s2, s3, call)
 	=> (Move {t.Elem()} [int64(sz)] dst src mem)
 
-// Inline small or disjoint runtime.memmove calls with constant length.
-// See the comment in op Move in genericOps.go for discussion of the type.
+// Match post-expansion calls, register version.
+(SelectN [0] call:(StaticCall {sym} dst src (Const(64|32) [sz]) mem))
+	&& sz >= 0
+	&& call.Uses == 1 // this will exclude all calls with results
+	&& isSameCall(sym, "runtime.memmove")
+	&& dst.Type.IsPtr() // avoids TUINTPTR, see issue 30061
+	&& isInlinableMemmove(dst, src, int64(sz), config)
+	&& clobber(call)
+	=> (Move {dst.Type.Elem()} [int64(sz)] dst src mem)
+
+// Match pre-expansion calls.
 (SelectN [0] call:(StaticLECall {sym} dst src (Const(64|32) [sz]) mem))
 	&& sz >= 0
 	&& call.Uses == 1 // this will exclude all calls with results
diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go
index f9ad980172..b8a9062d83 100644
--- a/src/cmd/compile/internal/ssa/rewrite.go
+++ b/src/cmd/compile/internal/ssa/rewrite.go
@@ -859,13 +859,13 @@ func disjoint(p1 *Value, n1 int64, p2 *Value, n2 int64) bool {
 		if p2.Op == OpAddr || p2.Op == OpLocalAddr || p2.Op == OpSP {
 			return true
 		}
-		return p2.Op == OpArg && p1.Args[0].Op == OpSP
-	case OpArg:
+		return (p2.Op == OpArg || p2.Op == OpArgIntReg) && p1.Args[0].Op == OpSP
+	case OpArg, OpArgIntReg:
 		if p2.Op == OpSP || p2.Op == OpLocalAddr {
 			return true
 		}
 	case OpSP:
-		return p2.Op == OpAddr || p2.Op == OpLocalAddr || p2.Op == OpArg || p2.Op == OpSP
+		return p2.Op == OpAddr || p2.Op == OpLocalAddr || p2.Op == OpArg || p2.Op == OpArgIntReg || p2.Op == OpSP
 	}
 	return false
 }
diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go
index 535fc8916d..52258201ca 100644
--- a/src/cmd/compile/internal/ssa/rewritegeneric.go
+++ b/src/cmd/compile/internal/ssa/rewritegeneric.go
@@ -20796,6 +20796,64 @@ func rewriteValuegeneric_OpSelectN(v *Value) bool {
 		v.AddArg3(dst, src, mem)
 		return true
 	}
+	// match: (SelectN [0] call:(StaticCall {sym} dst src (Const64 [sz]) mem))
+	// cond: sz >= 0 && call.Uses == 1 && isSameCall(sym, "runtime.memmove") && dst.Type.IsPtr() && isInlinableMemmove(dst, src, int64(sz), config) && clobber(call)
+	// result: (Move {dst.Type.Elem()} [int64(sz)] dst src mem)
+	for {
+		if auxIntToInt64(v.AuxInt) != 0 {
+			break
+		}
+		call := v_0
+		if call.Op != OpStaticCall || len(call.Args) != 4 {
+			break
+		}
+		sym := auxToCall(call.Aux)
+		mem := call.Args[3]
+		dst := call.Args[0]
+		src := call.Args[1]
+		call_2 := call.Args[2]
+		if call_2.Op != OpConst64 {
+			break
+		}
+		sz := auxIntToInt64(call_2.AuxInt)
+		if !(sz >= 0 && call.Uses == 1 && isSameCall(sym, "runtime.memmove") && dst.Type.IsPtr() && isInlinableMemmove(dst, src, int64(sz), config) && clobber(call)) {
+			break
+		}
+		v.reset(OpMove)
+		v.AuxInt = int64ToAuxInt(int64(sz))
+		v.Aux = typeToAux(dst.Type.Elem())
+		v.AddArg3(dst, src, mem)
+		return true
+	}
+	// match: (SelectN [0] call:(StaticCall {sym} dst src (Const32 [sz]) mem))
+	// cond: sz >= 0 && call.Uses == 1 && isSameCall(sym, "runtime.memmove") && dst.Type.IsPtr() && isInlinableMemmove(dst, src, int64(sz), config) && clobber(call)
+	// result: (Move {dst.Type.Elem()} [int64(sz)] dst src mem)
+	for {
+		if auxIntToInt64(v.AuxInt) != 0 {
+			break
+		}
+		call := v_0
+		if call.Op != OpStaticCall || len(call.Args) != 4 {
+			break
+		}
+		sym := auxToCall(call.Aux)
+		mem := call.Args[3]
+		dst := call.Args[0]
+		src := call.Args[1]
+		call_2 := call.Args[2]
+		if call_2.Op != OpConst32 {
+			break
+		}
+		sz := auxIntToInt32(call_2.AuxInt)
+		if !(sz >= 0 && call.Uses == 1 && isSameCall(sym, "runtime.memmove") && dst.Type.IsPtr() && isInlinableMemmove(dst, src, int64(sz), config) && clobber(call)) {
+			break
+		}
+		v.reset(OpMove)
+		v.AuxInt = int64ToAuxInt(int64(sz))
+		v.Aux = typeToAux(dst.Type.Elem())
+		v.AddArg3(dst, src, mem)
+		return true
+	}
 	// match: (SelectN [0] call:(StaticLECall {sym} dst src (Const64 [sz]) mem))
 	// cond: sz >= 0 && call.Uses == 1 && isSameCall(sym, "runtime.memmove") && dst.Type.IsPtr() && isInlinableMemmove(dst, src, int64(sz), config) && clobber(call)
 	// result: (Move {dst.Type.Elem()} [int64(sz)] dst src mem)
-- 
GitLab


From 33d99905daee9fc847ceb9e2a7e9a26427b7b41d Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Sun, 11 Apr 2021 12:07:33 -0400
Subject: [PATCH 1497/2400] cmd/compile: preserve name association when eliding
 copies in expand_calls

If v is a Copy of x, we will rewrite v to x. If v has a name
associated to it, let the name associate to x.

Under register ABI, this helps associate in-register Arg values
to the parameters' names. (But does not address all cases.)

Change-Id: I47c779e56c9d0823a88890497e32326bc0290f82
Reviewed-on: https://go-review.googlesource.com/c/go/+/309330
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/ssa/expand_calls.go | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index cb8b2eeec8..d947443cb2 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -1449,6 +1449,19 @@ func expandCalls(f *Func) {
 	}
 
 	// Step 6: elide any copies introduced.
+	// Update named values.
+	for _, name := range f.Names {
+		values := f.NamedValues[name]
+		for i, v := range values {
+			if v.Op == OpCopy {
+				a := v.Args[0]
+				for a.Op == OpCopy {
+					a = a.Args[0]
+				}
+				values[i] = a
+			}
+		}
+	}
 	for _, b := range f.Blocks {
 		for _, v := range b.Values {
 			for i, a := range v.Args {
-- 
GitLab


From 5d80f8a82b1fc3261bb4279f1426a9767b654e92 Mon Sep 17 00:00:00 2001
From: Paschalis Tsilias <paschalis.tsilias@gmail.com>
Date: Sun, 11 Apr 2021 13:13:11 +0300
Subject: [PATCH 1498/2400] runtime: replace outdated documentation link in
 Windows' nanotime

Fixes #45498

Change-Id: I89365f3517bc84376f0f580c64a57f38aaba0cbb
Reviewed-on: https://go-review.googlesource.com/c/go/+/308997
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Alex Brainman <alex.brainman@gmail.com>
---
 src/runtime/sys_windows_386.s   | 4 +++-
 src/runtime/sys_windows_amd64.s | 4 +++-
 src/runtime/sys_windows_arm.s   | 4 +++-
 src/runtime/sys_windows_arm64.s | 4 +++-
 4 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/src/runtime/sys_windows_386.s b/src/runtime/sys_windows_386.s
index e3fd90e05f..be4268a9c0 100644
--- a/src/runtime/sys_windows_386.s
+++ b/src/runtime/sys_windows_386.s
@@ -400,7 +400,9 @@ TEXT runtime·switchtothread(SB),NOSPLIT,$0
 	MOVL	BP, SP
 	RET
 
-// See https://www.dcl.hpi.uni-potsdam.de/research/WRK/2007/08/getting-os-information-the-kuser_shared_data-structure/
+// See https://wrkhpi.wordpress.com/2007/08/09/getting-os-information-the-kuser_shared_data-structure/
+// Archived copy at:
+// http://web.archive.org/web/20210411000829/https://wrkhpi.wordpress.com/2007/08/09/getting-os-information-the-kuser_shared_data-structure/
 // Must read hi1, then lo, then hi2. The snapshot is valid if hi1 == hi2.
 #define _INTERRUPT_TIME 0x7ffe0008
 #define _SYSTEM_TIME 0x7ffe0014
diff --git a/src/runtime/sys_windows_amd64.s b/src/runtime/sys_windows_amd64.s
index 099894efe7..1fd8bf5c5c 100644
--- a/src/runtime/sys_windows_amd64.s
+++ b/src/runtime/sys_windows_amd64.s
@@ -440,7 +440,9 @@ TEXT runtime·switchtothread(SB),NOSPLIT|NOFRAME,$0
 	MOVQ	32(SP), SP
 	RET
 
-// See https://www.dcl.hpi.uni-potsdam.de/research/WRK/2007/08/getting-os-information-the-kuser_shared_data-structure/
+// See https://wrkhpi.wordpress.com/2007/08/09/getting-os-information-the-kuser_shared_data-structure/
+// Archived copy at:
+// http://web.archive.org/web/20210411000829/https://wrkhpi.wordpress.com/2007/08/09/getting-os-information-the-kuser_shared_data-structure/
 // Must read hi1, then lo, then hi2. The snapshot is valid if hi1 == hi2.
 #define _INTERRUPT_TIME 0x7ffe0008
 #define _SYSTEM_TIME 0x7ffe0014
diff --git a/src/runtime/sys_windows_arm.s b/src/runtime/sys_windows_arm.s
index 22c6d63bdd..72de89dc84 100644
--- a/src/runtime/sys_windows_arm.s
+++ b/src/runtime/sys_windows_arm.s
@@ -416,7 +416,9 @@ TEXT runtime·read_tls_fallback(SB),NOSPLIT|NOFRAME,$0
 	MOVW	R0, (R0)
 	RET
 
-// See http://www.dcl.hpi.uni-potsdam.de/research/WRK/2007/08/getting-os-information-the-kuser_shared_data-structure/
+// See https://wrkhpi.wordpress.com/2007/08/09/getting-os-information-the-kuser_shared_data-structure/
+// Archived copy at:
+// http://web.archive.org/web/20210411000829/https://wrkhpi.wordpress.com/2007/08/09/getting-os-information-the-kuser_shared_data-structure/
 // Must read hi1, then lo, then hi2. The snapshot is valid if hi1 == hi2.
 #define _INTERRUPT_TIME 0x7ffe0008
 #define _SYSTEM_TIME 0x7ffe0014
diff --git a/src/runtime/sys_windows_arm64.s b/src/runtime/sys_windows_arm64.s
index 0b77e6d048..f54c868b26 100644
--- a/src/runtime/sys_windows_arm64.s
+++ b/src/runtime/sys_windows_arm64.s
@@ -470,7 +470,9 @@ TEXT runtime·switchtothread(SB),NOSPLIT,$16-0
 	ADD	$16, RSP
 	RET
 
-// See http://www.dcl.hpi.uni-potsdam.de/research/WRK/2007/08/getting-os-information-the-kuser_shared_data-structure/
+// See https://wrkhpi.wordpress.com/2007/08/09/getting-os-information-the-kuser_shared_data-structure/
+// Archived copy at:
+// http://web.archive.org/web/20210411000829/https://wrkhpi.wordpress.com/2007/08/09/getting-os-information-the-kuser_shared_data-structure/
 // Must read hi1, then lo, then hi2. The snapshot is valid if hi1 == hi2.
 #define _INTERRUPT_TIME 0x7ffe0008
 #define _SYSTEM_TIME 0x7ffe0014
-- 
GitLab


From 2fa7163b06a1b483598eb0ee827c78ef0d32ba33 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 8 Apr 2021 17:46:21 -0400
Subject: [PATCH 1499/2400] cmd/compile: look for newobject in register ABI for
 write barrier elision

If we are assigning a global address to an object that is
immediately returned from runtime.newobject, we omit the write
barrier because we know that both the source (static address) and
the destination (zeroed memory) do not need to be tracked by the
GC. Currently, the code that matches runtime.newobject's result
is specific to ABI0 layout. Update the code to work with register
ABI as well.

Change-Id: I7ab0833c6f745329271881ee4169956928a3a948
Reviewed-on: https://go-review.googlesource.com/c/go/+/308709
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/ssa/writebarrier.go | 81 ++++++++++++--------
 1 file changed, 50 insertions(+), 31 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/writebarrier.go b/src/cmd/compile/internal/ssa/writebarrier.go
index d6af3578d0..419d91d0d3 100644
--- a/src/cmd/compile/internal/ssa/writebarrier.go
+++ b/src/cmd/compile/internal/ssa/writebarrier.go
@@ -38,9 +38,11 @@ func needwb(v *Value, zeroes map[ID]ZeroRegion) bool {
 	if IsStackAddr(v.Args[0]) {
 		return false // write on stack doesn't need write barrier
 	}
-	if v.Op == OpMove && IsReadOnlyGlobalAddr(v.Args[1]) && IsNewObject(v.Args[0], v.MemoryArg()) {
-		// Copying data from readonly memory into a fresh object doesn't need a write barrier.
-		return false
+	if v.Op == OpMove && IsReadOnlyGlobalAddr(v.Args[1]) {
+		if mem, ok := IsNewObject(v.Args[0]); ok && mem == v.MemoryArg() {
+			// Copying data from readonly memory into a fresh object doesn't need a write barrier.
+			return false
+		}
 	}
 	if v.Op == OpStore && IsGlobalAddr(v.Args[1]) {
 		// Storing pointers to non-heap locations into zeroed memory doesn't need a write barrier.
@@ -389,11 +391,7 @@ func (f *Func) computeZeroMap() map[ID]ZeroRegion {
 	// Find new objects.
 	for _, b := range f.Blocks {
 		for _, v := range b.Values {
-			if v.Op != OpLoad {
-				continue
-			}
-			mem := v.MemoryArg()
-			if IsNewObject(v, mem) {
+			if mem, ok := IsNewObject(v); ok {
 				nptr := v.Type.Elem().Size() / ptrSize
 				if nptr > 64 {
 					nptr = 64
@@ -578,39 +576,60 @@ func IsReadOnlyGlobalAddr(v *Value) bool {
 	return false
 }
 
-// IsNewObject reports whether v is a pointer to a freshly allocated & zeroed object at memory state mem.
-func IsNewObject(v *Value, mem *Value) bool {
-	// TODO this will need updating for register args; the OpLoad is wrong.
-	if v.Op != OpLoad {
-		return false
-	}
-	if v.MemoryArg() != mem {
-		return false
+// IsNewObject reports whether v is a pointer to a freshly allocated & zeroed object,
+// if so, also returns the memory state mem at which v is zero.
+func IsNewObject(v *Value) (mem *Value, ok bool) {
+	f := v.Block.Func
+	c := f.Config
+	if f.ABIDefault == f.ABI1 && len(c.intParamRegs) >= 1 {
+		if v.Op != OpSelectN || v.AuxInt != 0 {
+			return nil, false
+		}
+		// Find the memory
+		for _, w := range v.Block.Values {
+			if w.Op == OpSelectN && w.AuxInt == 1 && w.Args[0] == v.Args[0] {
+				mem = w
+				break
+			}
+		}
+		if mem == nil {
+			return nil, false
+		}
+	} else {
+		if v.Op != OpLoad {
+			return nil, false
+		}
+		mem = v.MemoryArg()
+		if mem.Op != OpSelectN {
+			return nil, false
+		}
+		if mem.Type != types.TypeMem {
+			return nil, false
+		} // assume it is the right selection if true
 	}
-	if mem.Op != OpSelectN {
-		return false
+	call := mem.Args[0]
+	if call.Op != OpStaticCall {
+		return nil, false
 	}
-	if mem.Type != types.TypeMem {
-		return false
-	} // assume it is the right selection if true
-	mem = mem.Args[0]
-	if mem.Op != OpStaticCall {
-		return false
+	if !isSameCall(call.Aux, "runtime.newobject") {
+		return nil, false
 	}
-	if !isSameCall(mem.Aux, "runtime.newobject") {
-		return false
+	if f.ABIDefault == f.ABI1 && len(c.intParamRegs) >= 1 {
+		if v.Args[0] == call {
+			return mem, true
+		}
+		return nil, false
 	}
 	if v.Args[0].Op != OpOffPtr {
-		return false
+		return nil, false
 	}
 	if v.Args[0].Args[0].Op != OpSP {
-		return false
+		return nil, false
 	}
-	c := v.Block.Func.Config
 	if v.Args[0].AuxInt != c.ctxt.FixedFrameSize()+c.RegSize { // offset of return value
-		return false
+		return nil, false
 	}
-	return true
+	return mem, true
 }
 
 // IsSanitizerSafeAddr reports whether v is known to be an address
-- 
GitLab


From 8b859be9c3fd1068b659afa1db76dadb210c63de Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Mon, 12 Apr 2021 10:02:37 -0700
Subject: [PATCH 1500/2400] internal/poll: ensure that newPoolPipe doesn't
 return a nil pointer

The function could occasionally return a nil pointer as a non-nil
interface, confusing the calling code.

Fixes #45520

Change-Id: Ifd35613728efa2cee9903177e85d369155074804
Reviewed-on: https://go-review.googlesource.com/c/go/+/309429
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Andy Pan <panjf2000@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/internal/poll/splice_linux.go      |  5 +++--
 src/internal/poll/splice_linux_test.go | 16 ++++++++++++++--
 2 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/src/internal/poll/splice_linux.go b/src/internal/poll/splice_linux.go
index 49350b1ddc..8062d98fae 100644
--- a/src/internal/poll/splice_linux.go
+++ b/src/internal/poll/splice_linux.go
@@ -169,9 +169,10 @@ func newPoolPipe() interface{} {
 	// Discard the error which occurred during the creation of pipe buffer,
 	// redirecting the data transmission to the conventional way utilizing read() + write() as a fallback.
 	p := newPipe()
-	if p != nil {
-		runtime.SetFinalizer(p, destroyPipe)
+	if p == nil {
+		return nil
 	}
+	runtime.SetFinalizer(p, destroyPipe)
 	return p
 }
 
diff --git a/src/internal/poll/splice_linux_test.go b/src/internal/poll/splice_linux_test.go
index 77ae912d54..3629ef1b20 100644
--- a/src/internal/poll/splice_linux_test.go
+++ b/src/internal/poll/splice_linux_test.go
@@ -75,13 +75,19 @@ func TestSplicePipePool(t *testing.T) {
 func BenchmarkSplicePipe(b *testing.B) {
 	b.Run("SplicePipeWithPool", func(b *testing.B) {
 		for i := 0; i < b.N; i++ {
-			p, _, _ := poll.GetPipe()
+			p, _, err := poll.GetPipe()
+			if err != nil {
+				continue
+			}
 			poll.PutPipe(p)
 		}
 	})
 	b.Run("SplicePipeWithoutPool", func(b *testing.B) {
 		for i := 0; i < b.N; i++ {
 			p := poll.NewPipe()
+			if p == nil {
+				b.Skip("newPipe returned nil")
+			}
 			poll.DestroyPipe(p)
 		}
 	})
@@ -90,7 +96,10 @@ func BenchmarkSplicePipe(b *testing.B) {
 func BenchmarkSplicePipePoolParallel(b *testing.B) {
 	b.RunParallel(func(pb *testing.PB) {
 		for pb.Next() {
-			p, _, _ := poll.GetPipe()
+			p, _, err := poll.GetPipe()
+			if err != nil {
+				continue
+			}
 			poll.PutPipe(p)
 		}
 	})
@@ -100,6 +109,9 @@ func BenchmarkSplicePipeNativeParallel(b *testing.B) {
 	b.RunParallel(func(pb *testing.PB) {
 		for pb.Next() {
 			p := poll.NewPipe()
+			if p == nil {
+				b.Skip("newPipe returned nil")
+			}
 			poll.DestroyPipe(p)
 		}
 	})
-- 
GitLab


From 865d2bc78e5b6170c8b773880dc5fa3405791dc2 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Fri, 9 Apr 2021 18:02:48 -0400
Subject: [PATCH 1501/2400] cmd/compile: do not allocate space for unspilled
 in-register results

For function results, if in register, we allocate spill slots
within the frame like locals. Currently, even if we never spill
to it the slot is still allocated. This CL makes it not allocate
the slot if it is never used.

Change-Id: Idbd4e3096cfac6d2bdfb501d8efde48ee2191d7b
Reviewed-on: https://go-review.googlesource.com/c/go/+/309150
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/ssagen/pgen.go | 25 +++++++++++++++++++------
 1 file changed, 19 insertions(+), 6 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/pgen.go b/src/cmd/compile/internal/ssagen/pgen.go
index 0cb506fb74..92f6f562f3 100644
--- a/src/cmd/compile/internal/ssagen/pgen.go
+++ b/src/cmd/compile/internal/ssagen/pgen.go
@@ -32,11 +32,11 @@ import (
 // the top of the stack and increasing in size.
 // Non-autos sort on offset.
 func cmpstackvarlt(a, b *ir.Name) bool {
-	if (a.Class == ir.PAUTO) != (b.Class == ir.PAUTO) {
-		return b.Class == ir.PAUTO
+	if needAlloc(a) != needAlloc(b) {
+		return needAlloc(b)
 	}
 
-	if a.Class != ir.PAUTO {
+	if !needAlloc(a) {
 		return a.FrameOffset() < b.FrameOffset()
 	}
 
@@ -70,6 +70,13 @@ func (s byStackVar) Len() int           { return len(s) }
 func (s byStackVar) Less(i, j int) bool { return cmpstackvarlt(s[i], s[j]) }
 func (s byStackVar) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 
+// needAlloc reports whether n is within the current frame, for which we need to
+// allocate space. In particular, it excludes arguments and results, which are in
+// the callers frame.
+func needAlloc(n *ir.Name) bool {
+	return n.Class == ir.PAUTO || n.Class == ir.PPARAMOUT && n.IsOutputParamInRegisters()
+}
+
 func (s *ssafn) AllocFrame(f *ssa.Func) {
 	s.stksize = 0
 	s.stkptrsize = 0
@@ -77,7 +84,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 
 	// Mark the PAUTO's unused.
 	for _, ln := range fn.Dcl {
-		if ln.Class == ir.PAUTO {
+		if needAlloc(ln) {
 			ln.SetUsed(false)
 		}
 	}
@@ -92,7 +99,14 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 		for _, v := range b.Values {
 			if n, ok := v.Aux.(*ir.Name); ok {
 				switch n.Class {
-				case ir.PPARAM, ir.PPARAMOUT, ir.PAUTO:
+				case ir.PPARAMOUT:
+					if n.IsOutputParamInRegisters() && v.Op == ssa.OpVarDef {
+						// ignore VarDef, look for "real" uses.
+						// TODO: maybe do this for PAUTO as well?
+						continue
+					}
+					fallthrough
+				case ir.PPARAM, ir.PAUTO:
 					n.SetUsed(true)
 				}
 			}
@@ -106,7 +120,6 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 	for i, n := range fn.Dcl {
 		if n.Op() != ir.ONAME || n.Class != ir.PAUTO && !(n.Class == ir.PPARAMOUT && n.IsOutputParamInRegisters()) {
 			// i.e., stack assign if AUTO, or if PARAMOUT in registers (which has no predefined spill locations)
-			// TODO figure out when we don't need to spill output params.
 			continue
 		}
 		if !n.Used() {
-- 
GitLab


From 849dba07a5392d2f137deeaa9e797f907c00d0bd Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Thu, 8 Apr 2021 17:43:51 -0400
Subject: [PATCH 1502/2400] runtime: port performance-critical functions to
 regabi
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This CL ports a few performance-critical runtime assembly functions to
use register arguments directly. While using the faster ABI is nice,
the real win here is that we avoid ABI wrappers: since these are
"builtin" functions in the compiler, it can generate calls to them
without knowing that their native implementation is ABI0. Hence, it
generates ABIInternal calls that go through ABI wrappers. By porting
them to use ABIInternal natively, we avoid the overhead of the ABI
wrapper.

This significantly improves performance on several benchmarks,
comparing regabiwrappers before and after this change:

name                                old time/op  new time/op  delta
BiogoIgor                            15.7s ± 2%   15.7s ± 2%    ~     (p=0.617 n=25+25)
BiogoKrishna                         18.5s ± 5%   17.7s ± 2%  -4.61%  (p=0.000 n=25+25)
BleveIndexBatch100                   5.91s ± 3%   5.82s ± 3%  -1.60%  (p=0.000 n=25+25)
BleveQuery                           6.76s ± 0%   6.60s ± 1%  -2.31%  (p=0.000 n=22+25)
CompileTemplate                      248ms ± 5%   245ms ± 1%    ~     (p=0.643 n=25+20)
CompileUnicode                      94.4ms ± 3%  93.9ms ± 2%    ~     (p=0.152 n=24+23)
CompileGoTypes                       1.60s ± 2%   1.59s ± 2%    ~     (p=0.059 n=24+24)
CompileCompiler                      104ms ± 3%   103ms ± 1%    ~     (p=0.056 n=25+22)
CompileSSA                           10.9s ± 1%   10.9s ± 1%    ~     (p=0.052 n=25+25)
CompileFlate                         156ms ± 8%   152ms ± 1%  -2.49%  (p=0.008 n=25+21)
CompileGoParser                      248ms ± 1%   249ms ± 2%    ~     (p=0.058 n=21+20)
CompileReflect                       595ms ± 3%   601ms ± 4%    ~     (p=0.182 n=25+25)
CompileTar                           211ms ± 2%   211ms ± 1%    ~     (p=0.663 n=23+23)
CompileXML                           282ms ± 2%   284ms ± 5%    ~     (p=0.456 n=21+23)
CompileStdCmd                        13.6s ± 2%   13.5s ± 2%    ~     (p=0.112 n=25+24)
FoglemanFauxGLRenderRotateBoat       8.69s ± 2%   8.67s ± 0%    ~     (p=0.094 n=22+25)
FoglemanPathTraceRenderGopherIter1   20.2s ± 2%   20.7s ± 3%  +2.53%  (p=0.000 n=24+24)
GopherLuaKNucleotide                 31.4s ± 1%   31.0s ± 1%  -1.28%  (p=0.000 n=25+24)
MarkdownRenderXHTML                  246ms ± 1%   244ms ± 1%  -0.79%  (p=0.000 n=20+21)
Tile38WithinCircle100kmRequest       843µs ± 4%   818µs ± 4%  -2.93%  (p=0.000 n=25+25)
Tile38IntersectsCircle100kmRequest  1.06ms ± 5%  1.05ms ± 3%  -1.19%  (p=0.021 n=24+25)
Tile38KNearestLimit100Request       1.01ms ± 1%  1.01ms ± 2%    ~     (p=0.335 n=22+25)
[Geo mean]                           596ms        592ms       -0.71%

(https://perf.golang.org/search?q=upload:20210411.5)

It also significantly reduces the performance penalty of enabling
regabiwrappers, though it doesn't yet fully close the gap on all
benchmarks:

name                                old time/op  new time/op  delta
BiogoIgor                            15.7s ± 1%   15.7s ± 2%    ~     (p=0.366 n=24+25)
BiogoKrishna                         17.7s ± 2%   17.7s ± 2%    ~     (p=0.315 n=23+25)
BleveIndexBatch100                   5.86s ± 4%   5.82s ± 3%    ~     (p=0.137 n=24+25)
BleveQuery                           6.55s ± 0%   6.60s ± 1%  +0.83%  (p=0.000 n=24+25)
CompileTemplate                      244ms ± 1%   245ms ± 1%    ~     (p=0.208 n=21+20)
CompileUnicode                      94.0ms ± 4%  93.9ms ± 2%    ~     (p=0.666 n=24+23)
CompileGoTypes                       1.60s ± 2%   1.59s ± 2%    ~     (p=0.154 n=25+24)
CompileCompiler                      103ms ± 1%   103ms ± 1%    ~     (p=0.905 n=24+22)
CompileSSA                           10.9s ± 2%   10.9s ± 1%    ~     (p=0.803 n=25+25)
CompileFlate                         153ms ± 1%   152ms ± 1%    ~     (p=0.182 n=23+21)
CompileGoParser                      250ms ± 2%   249ms ± 2%    ~     (p=0.843 n=24+20)
CompileReflect                       595ms ± 4%   601ms ± 4%    ~     (p=0.141 n=25+25)
CompileTar                           212ms ± 3%   211ms ± 1%    ~     (p=0.499 n=23+23)
CompileXML                           282ms ± 1%   284ms ± 5%    ~     (p=0.129 n=20+23)
CompileStdCmd                        13.5s ± 2%   13.5s ± 2%    ~     (p=0.480 n=24+24)
FoglemanFauxGLRenderRotateBoat       8.66s ± 1%   8.67s ± 0%    ~     (p=0.325 n=25+25)
FoglemanPathTraceRenderGopherIter1   20.6s ± 3%   20.7s ± 3%    ~     (p=0.137 n=25+24)
GopherLuaKNucleotide                 30.5s ± 2%   31.0s ± 1%  +1.68%  (p=0.000 n=23+24)
MarkdownRenderXHTML                  243ms ± 1%   244ms ± 1%  +0.51%  (p=0.000 n=23+21)
Tile38WithinCircle100kmRequest       801µs ± 2%   818µs ± 4%  +2.11%  (p=0.000 n=25+25)
Tile38IntersectsCircle100kmRequest  1.01ms ± 2%  1.05ms ± 3%  +4.34%  (p=0.000 n=24+25)
Tile38KNearestLimit100Request       1.00ms ± 1%  1.01ms ± 2%  +0.81%  (p=0.008 n=21+25)
[Geo mean]                           589ms        592ms       +0.50%

(https://perf.golang.org/search?q=upload:20210411.6)

Change-Id: I8f77f010b0abc658064df569a27a9c7a7b1c7bf9
Reviewed-on: https://go-review.googlesource.com/c/go/+/308931
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/asm_amd64.s     | 103 ++++++++++++++++++++++++++++++++---
 src/runtime/memclr_amd64.s  | 105 +++++++++++++++++++-----------------
 src/runtime/memmove_amd64.s |  21 +++++++-
 src/runtime/stubs.go        |   3 ++
 4 files changed, 174 insertions(+), 58 deletions(-)

diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index 77f4939b30..e883f20045 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -1011,34 +1011,62 @@ done:
 
 // func memhash(p unsafe.Pointer, h, s uintptr) uintptr
 // hash function using AES hardware instructions
-TEXT runtime·memhash(SB),NOSPLIT,$0-32
+TEXT runtime·memhash<ABIInternal>(SB),NOSPLIT,$0-32
+#ifdef GOEXPERIMENT_regabiargs
+	// AX = ptr to data
+	// BX = seed
+	// CX = size
+#endif
 	CMPB	runtime·useAeshash(SB), $0
 	JEQ	noaes
+#ifndef GOEXPERIMENT_regabiargs
 	MOVQ	p+0(FP), AX	// ptr to data
 	MOVQ	s+16(FP), CX	// size
 	LEAQ	ret+24(FP), DX
+#endif
 	JMP	aeshashbody<>(SB)
 noaes:
-	JMP	runtime·memhashFallback(SB)
+	JMP	runtime·memhashFallback<ABIInternal>(SB)
 
 // func strhash(p unsafe.Pointer, h uintptr) uintptr
-TEXT runtime·strhash(SB),NOSPLIT,$0-24
+TEXT runtime·strhash<ABIInternal>(SB),NOSPLIT,$0-24
+#ifdef GOEXPERIMENT_regabiargs
+	// AX = ptr to string struct
+	// BX = seed
+#endif
 	CMPB	runtime·useAeshash(SB), $0
 	JEQ	noaes
+#ifndef GOEXPERIMENT_regabiargs
 	MOVQ	p+0(FP), AX	// ptr to string struct
+#endif
 	MOVQ	8(AX), CX	// length of string
 	MOVQ	(AX), AX	// string data
+#ifndef GOEXPERIMENT_regabiargs
 	LEAQ	ret+16(FP), DX
+#endif
 	JMP	aeshashbody<>(SB)
 noaes:
-	JMP	runtime·strhashFallback(SB)
+	JMP	runtime·strhashFallback<ABIInternal>(SB)
 
 // AX: data
+#ifdef GOEXPERIMENT_regabiargs
+// BX: hash seed
+#else
+// h+8(FP): hash seed
+#endif
 // CX: length
+#ifdef GOEXPERIMENT_regabiargs
+// At return: AX = return value
+#else
 // DX: address to put return value
+#endif
 TEXT aeshashbody<>(SB),NOSPLIT,$0-0
 	// Fill an SSE register with our seeds.
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	BX, X0				// 64 bits of per-table hash seed
+#else
 	MOVQ	h+8(FP), X0			// 64 bits of per-table hash seed
+#endif
 	PINSRW	$4, CX, X0			// 16 bits of length
 	PSHUFHW $0, X0, X0			// repeat length 4 times total
 	MOVO	X0, X1				// save unscrambled seed
@@ -1075,7 +1103,11 @@ final1:
 	AESENC	X1, X1	// scramble combo 3 times
 	AESENC	X1, X1
 	AESENC	X1, X1
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	X1, AX	// return X1
+#else
 	MOVQ	X1, (DX)
+#endif
 	RET
 
 endofpage:
@@ -1091,7 +1123,11 @@ endofpage:
 aes0:
 	// Return scrambled input seed
 	AESENC	X0, X0
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	X0, AX	// return X0
+#else
 	MOVQ	X0, (DX)
+#endif
 	RET
 
 aes16:
@@ -1121,7 +1157,11 @@ aes17to32:
 
 	// combine results
 	PXOR	X3, X2
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	X2, AX	// return X2
+#else
 	MOVQ	X2, (DX)
+#endif
 	RET
 
 aes33to64:
@@ -1163,7 +1203,11 @@ aes33to64:
 	PXOR	X6, X4
 	PXOR	X7, X5
 	PXOR	X5, X4
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	X4, AX	// return X4
+#else
 	MOVQ	X4, (DX)
+#endif
 	RET
 
 aes65to128:
@@ -1245,7 +1289,15 @@ aes65to128:
 	PXOR	X10, X8
 	PXOR	X11, X9
 	PXOR	X9, X8
+#ifdef GOEXPERIMENT_regabig
+	// X15 must be zero on return
+	PXOR	X15, X15
+#endif
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	X8, AX	// return X8
+#else
 	MOVQ	X8, (DX)
+#endif
 	RET
 
 aes129plus:
@@ -1361,38 +1413,73 @@ aesloop:
 	PXOR	X10, X8
 	PXOR	X11, X9
 	PXOR	X9, X8
+#ifdef GOEXPERIMENT_regabig
+	// X15 must be zero on return
+	PXOR	X15, X15
+#endif
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	X8, AX	// return X8
+#else
 	MOVQ	X8, (DX)
+#endif
 	RET
 
 // func memhash32(p unsafe.Pointer, h uintptr) uintptr
-TEXT runtime·memhash32(SB),NOSPLIT,$0-24
+// ABIInternal for performance.
+TEXT runtime·memhash32<ABIInternal>(SB),NOSPLIT,$0-24
+#ifdef GOEXPERIMENT_regabiargs
+	// AX = ptr to data
+	// BX = seed
+#endif
 	CMPB	runtime·useAeshash(SB), $0
 	JEQ	noaes
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	BX, X0	// X0 = seed
+#else
 	MOVQ	p+0(FP), AX	// ptr to data
 	MOVQ	h+8(FP), X0	// seed
+#endif
 	PINSRD	$2, (AX), X0	// data
 	AESENC	runtime·aeskeysched+0(SB), X0
 	AESENC	runtime·aeskeysched+16(SB), X0
 	AESENC	runtime·aeskeysched+32(SB), X0
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	X0, AX	// return X0
+#else
 	MOVQ	X0, ret+16(FP)
+#endif
 	RET
 noaes:
-	JMP	runtime·memhash32Fallback(SB)
+	JMP	runtime·memhash32Fallback<ABIInternal>(SB)
 
 // func memhash64(p unsafe.Pointer, h uintptr) uintptr
-TEXT runtime·memhash64(SB),NOSPLIT,$0-24
+// ABIInternal for performance.
+TEXT runtime·memhash64<ABIInternal>(SB),NOSPLIT,$0-24
+#ifdef GOEXPERIMENT_regabiargs
+	// AX = ptr to data
+	// BX = seed
+#else
+#endif
 	CMPB	runtime·useAeshash(SB), $0
 	JEQ	noaes
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	BX, X0	// X0 = seed
+#else
 	MOVQ	p+0(FP), AX	// ptr to data
 	MOVQ	h+8(FP), X0	// seed
+#endif
 	PINSRQ	$1, (AX), X0	// data
 	AESENC	runtime·aeskeysched+0(SB), X0
 	AESENC	runtime·aeskeysched+16(SB), X0
 	AESENC	runtime·aeskeysched+32(SB), X0
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	X0, AX	// return X0
+#else
 	MOVQ	X0, ret+16(FP)
+#endif
 	RET
 noaes:
-	JMP	runtime·memhash64Fallback(SB)
+	JMP	runtime·memhash64Fallback<ABIInternal>(SB)
 
 // simple mask to get rid of data in the high part of the register.
 DATA masks<>+0x00(SB)/8, $0x0000000000000000
diff --git a/src/runtime/memclr_amd64.s b/src/runtime/memclr_amd64.s
index 37fe9745b1..b4bc9988ec 100644
--- a/src/runtime/memclr_amd64.s
+++ b/src/runtime/memclr_amd64.s
@@ -12,9 +12,16 @@
 // See memclrNoHeapPointers Go doc for important implementation constraints.
 
 // func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
-TEXT runtime·memclrNoHeapPointers(SB), NOSPLIT, $0-16
+// ABIInternal for performance.
+TEXT runtime·memclrNoHeapPointers<ABIInternal>(SB), NOSPLIT, $0-16
+#ifdef GOEXPERIMENT_regabiargs
+	// AX = ptr
+	// BX = n
+	MOVQ	AX, DI	// DI = ptr
+#else
 	MOVQ	ptr+0(FP), DI
 	MOVQ	n+8(FP), BX
+#endif
 	XORQ	AX, AX
 
 	// MOVOU seems always faster than REP STOSQ.
@@ -31,7 +38,9 @@ tail:
 	JE	_8
 	CMPQ	BX, $16
 	JBE	_9through16
-	PXOR	X0, X0
+#ifndef GOEXPERIMENT_regabig
+	PXOR	X15, X15
+#endif
 	CMPQ	BX, $32
 	JBE	_17through32
 	CMPQ	BX, $64
@@ -45,22 +54,22 @@ tail:
 	// TODO: for really big clears, use MOVNTDQ, even without AVX2.
 
 loop:
-	MOVOU	X0, 0(DI)
-	MOVOU	X0, 16(DI)
-	MOVOU	X0, 32(DI)
-	MOVOU	X0, 48(DI)
-	MOVOU	X0, 64(DI)
-	MOVOU	X0, 80(DI)
-	MOVOU	X0, 96(DI)
-	MOVOU	X0, 112(DI)
-	MOVOU	X0, 128(DI)
-	MOVOU	X0, 144(DI)
-	MOVOU	X0, 160(DI)
-	MOVOU	X0, 176(DI)
-	MOVOU	X0, 192(DI)
-	MOVOU	X0, 208(DI)
-	MOVOU	X0, 224(DI)
-	MOVOU	X0, 240(DI)
+	MOVOU	X15, 0(DI)
+	MOVOU	X15, 16(DI)
+	MOVOU	X15, 32(DI)
+	MOVOU	X15, 48(DI)
+	MOVOU	X15, 64(DI)
+	MOVOU	X15, 80(DI)
+	MOVOU	X15, 96(DI)
+	MOVOU	X15, 112(DI)
+	MOVOU	X15, 128(DI)
+	MOVOU	X15, 144(DI)
+	MOVOU	X15, 160(DI)
+	MOVOU	X15, 176(DI)
+	MOVOU	X15, 192(DI)
+	MOVOU	X15, 208(DI)
+	MOVOU	X15, 224(DI)
+	MOVOU	X15, 240(DI)
 	SUBQ	$256, BX
 	ADDQ	$256, DI
 	CMPQ	BX, $256
@@ -141,40 +150,40 @@ _9through16:
 	MOVQ	AX, -8(DI)(BX*1)
 	RET
 _17through32:
-	MOVOU	X0, (DI)
-	MOVOU	X0, -16(DI)(BX*1)
+	MOVOU	X15, (DI)
+	MOVOU	X15, -16(DI)(BX*1)
 	RET
 _33through64:
-	MOVOU	X0, (DI)
-	MOVOU	X0, 16(DI)
-	MOVOU	X0, -32(DI)(BX*1)
-	MOVOU	X0, -16(DI)(BX*1)
+	MOVOU	X15, (DI)
+	MOVOU	X15, 16(DI)
+	MOVOU	X15, -32(DI)(BX*1)
+	MOVOU	X15, -16(DI)(BX*1)
 	RET
 _65through128:
-	MOVOU	X0, (DI)
-	MOVOU	X0, 16(DI)
-	MOVOU	X0, 32(DI)
-	MOVOU	X0, 48(DI)
-	MOVOU	X0, -64(DI)(BX*1)
-	MOVOU	X0, -48(DI)(BX*1)
-	MOVOU	X0, -32(DI)(BX*1)
-	MOVOU	X0, -16(DI)(BX*1)
+	MOVOU	X15, (DI)
+	MOVOU	X15, 16(DI)
+	MOVOU	X15, 32(DI)
+	MOVOU	X15, 48(DI)
+	MOVOU	X15, -64(DI)(BX*1)
+	MOVOU	X15, -48(DI)(BX*1)
+	MOVOU	X15, -32(DI)(BX*1)
+	MOVOU	X15, -16(DI)(BX*1)
 	RET
 _129through256:
-	MOVOU	X0, (DI)
-	MOVOU	X0, 16(DI)
-	MOVOU	X0, 32(DI)
-	MOVOU	X0, 48(DI)
-	MOVOU	X0, 64(DI)
-	MOVOU	X0, 80(DI)
-	MOVOU	X0, 96(DI)
-	MOVOU	X0, 112(DI)
-	MOVOU	X0, -128(DI)(BX*1)
-	MOVOU	X0, -112(DI)(BX*1)
-	MOVOU	X0, -96(DI)(BX*1)
-	MOVOU	X0, -80(DI)(BX*1)
-	MOVOU	X0, -64(DI)(BX*1)
-	MOVOU	X0, -48(DI)(BX*1)
-	MOVOU	X0, -32(DI)(BX*1)
-	MOVOU	X0, -16(DI)(BX*1)
+	MOVOU	X15, (DI)
+	MOVOU	X15, 16(DI)
+	MOVOU	X15, 32(DI)
+	MOVOU	X15, 48(DI)
+	MOVOU	X15, 64(DI)
+	MOVOU	X15, 80(DI)
+	MOVOU	X15, 96(DI)
+	MOVOU	X15, 112(DI)
+	MOVOU	X15, -128(DI)(BX*1)
+	MOVOU	X15, -112(DI)(BX*1)
+	MOVOU	X15, -96(DI)(BX*1)
+	MOVOU	X15, -80(DI)(BX*1)
+	MOVOU	X15, -64(DI)(BX*1)
+	MOVOU	X15, -48(DI)(BX*1)
+	MOVOU	X15, -32(DI)(BX*1)
+	MOVOU	X15, -16(DI)(BX*1)
 	RET
diff --git a/src/runtime/memmove_amd64.s b/src/runtime/memmove_amd64.s
index d91641a8e8..f1e3403596 100644
--- a/src/runtime/memmove_amd64.s
+++ b/src/runtime/memmove_amd64.s
@@ -31,11 +31,20 @@
 // See memmove Go doc for important implementation constraints.
 
 // func memmove(to, from unsafe.Pointer, n uintptr)
-TEXT runtime·memmove(SB), NOSPLIT, $0-24
-
+// ABIInternal for performance.
+TEXT runtime·memmove<ABIInternal>(SB), NOSPLIT, $0-24
+#ifdef GOEXPERIMENT_regabiargs
+	// AX = to
+	// BX = from
+	// CX = n
+	MOVQ	AX, DI
+	MOVQ	BX, SI
+	MOVQ	CX, BX
+#else
 	MOVQ	to+0(FP), DI
 	MOVQ	from+8(FP), SI
 	MOVQ	n+16(FP), BX
+#endif
 
 	// REP instructions have a high startup cost, so we handle small sizes
 	// with some straightline code. The REP MOVSQ instruction is really fast
@@ -244,6 +253,10 @@ move_129through256:
 	MOVOU	X13, -48(DI)(BX*1)
 	MOVOU	X14, -32(DI)(BX*1)
 	MOVOU	X15, -16(DI)(BX*1)
+#ifdef GOEXPERIMENT_regabig
+	// X15 must be zero on return
+	PXOR	X15, X15
+#endif
 	RET
 move_256through2048:
 	SUBQ	$256, BX
@@ -283,6 +296,10 @@ move_256through2048:
 	LEAQ	256(SI), SI
 	LEAQ	256(DI), DI
 	JGE	move_256through2048
+#ifdef GOEXPERIMENT_regabig
+	// X15 must be zero on return
+	PXOR	X15, X15
+#endif
 	JMP	tail
 
 avxUnaligned:
diff --git a/src/runtime/stubs.go b/src/runtime/stubs.go
index f635d942e4..16d7583202 100644
--- a/src/runtime/stubs.go
+++ b/src/runtime/stubs.go
@@ -109,6 +109,9 @@ func reflect_memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr) {
 //go:noescape
 func memmove(to, from unsafe.Pointer, n uintptr)
 
+// Outside assembly calls memmove. Make sure it has ABI wrappers.
+//go:linkname memmove
+
 //go:linkname reflect_memmove reflect.memmove
 func reflect_memmove(to, from unsafe.Pointer, n uintptr) {
 	memmove(to, from, n)
-- 
GitLab


From 07b2fee4607aa6c710411a7ac404f18be4dff6f7 Mon Sep 17 00:00:00 2001
From: Lynn Boger <laboger@linux.vnet.ibm.com>
Date: Fri, 9 Apr 2021 10:41:27 -0500
Subject: [PATCH 1503/2400] cmd/link: fix TestLargeText

This test is not run in short mode so it was getting
failures that didn't happen with default testing. See
the issue for details on the failures.

Fixes #45406

Change-Id: I51d97cc4c910fe3ba2bc0a12742023a57d101f44
Reviewed-on: https://go-review.googlesource.com/c/go/+/308935
Run-TryBot: Lynn Boger <laboger@linux.vnet.ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Paul Murphy <murp@ibm.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: Lynn Boger <laboger@linux.vnet.ibm.com>
---
 src/cmd/link/linkbig_test.go | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/cmd/link/linkbig_test.go b/src/cmd/link/linkbig_test.go
index d5d77d6c72..917bd9e8a3 100644
--- a/src/cmd/link/linkbig_test.go
+++ b/src/cmd/link/linkbig_test.go
@@ -14,7 +14,6 @@ import (
 	"fmt"
 	"internal/testenv"
 	"io/ioutil"
-	"os"
 	"os/exec"
 	"testing"
 )
@@ -29,6 +28,10 @@ func TestLargeText(t *testing.T) {
 	const FN = 4
 	tmpdir := t.TempDir()
 
+	if err := ioutil.WriteFile(tmpdir+"/go.mod", []byte("module big_test\n"), 0666); err != nil {
+		t.Fatal(err)
+	}
+
 	// Generate the scenario where the total amount of text exceeds the
 	// limit for the jmp/call instruction, on RISC architectures like ppc64le,
 	// which is 2^26.  When that happens the call requires special trampolines or
@@ -80,26 +83,28 @@ func TestLargeText(t *testing.T) {
 	}
 
 	// Build and run with internal linking.
-	os.Chdir(tmpdir)
 	cmd := exec.Command(testenv.GoToolPath(t), "build", "-o", "bigtext")
+	cmd.Dir = tmpdir
 	out, err := cmd.CombinedOutput()
 	if err != nil {
 		t.Fatalf("Build failed for big text program with internal linking: %v, output: %s", err, out)
 	}
-	cmd = exec.Command(tmpdir + "/bigtext")
+	cmd = exec.Command("./bigtext")
+	cmd.Dir = tmpdir
 	out, err = cmd.CombinedOutput()
 	if err != nil {
 		t.Fatalf("Program built with internal linking failed to run with err %v, output: %s", err, out)
 	}
 
 	// Build and run with external linking
-	os.Chdir(tmpdir)
 	cmd = exec.Command(testenv.GoToolPath(t), "build", "-o", "bigtext", "-ldflags", "'-linkmode=external'")
+	cmd.Dir = tmpdir
 	out, err = cmd.CombinedOutput()
 	if err != nil {
 		t.Fatalf("Build failed for big text program with external linking: %v, output: %s", err, out)
 	}
-	cmd = exec.Command(tmpdir + "/bigtext")
+	cmd = exec.Command("./bigtext")
+	cmd.Dir = tmpdir
 	out, err = cmd.CombinedOutput()
 	if err != nil {
 		t.Fatalf("Program built with external linking failed to run with err %v, output: %s", err, out)
-- 
GitLab


From a25a77aed2d76b0aebff8892477f27283398a932 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Fri, 2 Apr 2021 15:54:24 -0400
Subject: [PATCH 1504/2400] runtime: block sweep completion on all sweep paths

The runtime currently has two different notions of sweep completion:

1. All spans are either swept or have begun sweeping.

2. The sweeper has *finished* sweeping all spans.

Most things depend on condition 1. Notably, GC correctness depends on
condition 1, but since all sweep operations a non-preemptible, the STW
at the beginning of GC forces condition 1 to become condition 2.

runtime.GC(), however, depends on condition 2, since the intent is to
complete a complete GC cycle, and also update the heap profile (which
can only be done after sweeping is complete).

However, the way we compute condition 2 is racy right now and may in
fact only indicate condition 1. Specifically, sweepone blocks
condition 2 until all sweepone calls are done, but there are many
other ways to enter the sweeper that don't block this. Hence, sweepone
may see that there are no more spans in the sweep list and see that
it's the last sweepone and declare sweeping done, while there's some
other sweeper still working on a span.

Fix this by making sure every entry to the sweeper participates in the
protocol that blocks condition 2. To make sure we get this right, this
CL introduces a type to track sweep blocking and (lightly) enforces
span sweep ownership via the type system. This has the nice
side-effect of abstracting the pattern of acquiring sweep ownership
that's currently repeated in many different places.

Fixes #45315.

Change-Id: I7fab30170c5ae14c8b2f10998628735b8be6d901
Reviewed-on: https://go-review.googlesource.com/c/go/+/307915
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/mcentral.go |  21 ++++--
 src/runtime/mgc.go      |  15 ++--
 src/runtime/mgcsweep.go | 153 +++++++++++++++++++++++++++++-----------
 src/runtime/mheap.go    |   5 +-
 4 files changed, 140 insertions(+), 54 deletions(-)

diff --git a/src/runtime/mcentral.go b/src/runtime/mcentral.go
index 8664ed48ab..4eeac3be88 100644
--- a/src/runtime/mcentral.go
+++ b/src/runtime/mcentral.go
@@ -81,8 +81,6 @@ func (c *mcentral) cacheSpan() *mspan {
 	spanBytes := uintptr(class_to_allocnpages[c.spanclass.sizeclass()]) * _PageSize
 	deductSweepCredit(spanBytes, 0)
 
-	sg := mheap_.sweepgen
-
 	traceDone := false
 	if trace.enabled {
 		traceGCSweepStart()
@@ -104,6 +102,8 @@ func (c *mcentral) cacheSpan() *mspan {
 	spanBudget := 100
 
 	var s *mspan
+	sl := newSweepLocker()
+	sg := sl.sweepGen
 
 	// Try partial swept spans first.
 	if s = c.partialSwept(sg).pop(); s != nil {
@@ -116,9 +116,10 @@ func (c *mcentral) cacheSpan() *mspan {
 		if s == nil {
 			break
 		}
-		if atomic.Load(&s.sweepgen) == sg-2 && atomic.Cas(&s.sweepgen, sg-2, sg-1) {
+		if s, ok := sl.tryAcquire(s); ok {
 			// We got ownership of the span, so let's sweep it and use it.
 			s.sweep(true)
+			sl.dispose()
 			goto havespan
 		}
 		// We failed to get ownership of the span, which means it's being or
@@ -135,20 +136,22 @@ func (c *mcentral) cacheSpan() *mspan {
 		if s == nil {
 			break
 		}
-		if atomic.Load(&s.sweepgen) == sg-2 && atomic.Cas(&s.sweepgen, sg-2, sg-1) {
+		if s, ok := sl.tryAcquire(s); ok {
 			// We got ownership of the span, so let's sweep it.
 			s.sweep(true)
 			// Check if there's any free space.
 			freeIndex := s.nextFreeIndex()
 			if freeIndex != s.nelems {
 				s.freeindex = freeIndex
+				sl.dispose()
 				goto havespan
 			}
 			// Add it to the swept list, because sweeping didn't give us any free space.
-			c.fullSwept(sg).push(s)
+			c.fullSwept(sg).push(s.mspan)
 		}
 		// See comment for partial unswept spans.
 	}
+	sl.dispose()
 	if trace.enabled {
 		traceGCSweepDone()
 		traceDone = true
@@ -211,7 +214,13 @@ func (c *mcentral) uncacheSpan(s *mspan) {
 	if stale {
 		// It's stale, so just sweep it. Sweeping will put it on
 		// the right list.
-		s.sweep(false)
+		//
+		// We don't use a sweepLocker here. Stale cached spans
+		// aren't in the global sweep lists, so mark termination
+		// itself holds up sweep completion until all mcaches
+		// have been swept.
+		ss := sweepLocked{s}
+		ss.sweep(false)
 	} else {
 		if int(s.nelems)-int(s.allocCount) > 0 {
 			// Put it back on the partial swept list.
diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index ef3436d1f4..8c1ff20936 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -1749,6 +1749,13 @@ func gcMarkTermination(nextTriggerRatio float64) {
 	// so events don't leak into the wrong cycle.
 	mProf_NextCycle()
 
+	// There may be stale spans in mcaches that need to be swept.
+	// Those aren't tracked in any sweep lists, so we need to
+	// count them against sweep completion until we ensure all
+	// those spans have been forced out.
+	sl := newSweepLocker()
+	sl.blockCompletion()
+
 	systemstack(func() { startTheWorldWithSema(true) })
 
 	// Flush the heap profile so we can start a new cycle next GC.
@@ -1772,6 +1779,9 @@ func gcMarkTermination(nextTriggerRatio float64) {
 			_p_.mcache.prepareForSweep()
 		})
 	})
+	// Now that we've swept stale spans in mcaches, they don't
+	// count against unswept spans.
+	sl.dispose()
 
 	// Print gctrace before dropping worldsema. As soon as we drop
 	// worldsema another cycle could start and smash the stats
@@ -2391,11 +2401,6 @@ func gcTestIsReachable(ptrs ...unsafe.Pointer) (mask uint64) {
 	// Force a full GC and sweep.
 	GC()
 
-	// TODO(austin): Work around issue #45315. One GC() can return
-	// without finishing the sweep. Do a second to force the sweep
-	// through.
-	GC()
-
 	// Process specials.
 	for i, s := range specials {
 		if !s.done {
diff --git a/src/runtime/mgcsweep.go b/src/runtime/mgcsweep.go
index 8d254702ed..ed2091bd2e 100644
--- a/src/runtime/mgcsweep.go
+++ b/src/runtime/mgcsweep.go
@@ -183,11 +183,76 @@ func bgsweep() {
 	}
 }
 
+// sweepLocker acquires sweep ownership of spans and blocks sweep
+// completion.
+type sweepLocker struct {
+	// sweepGen is the sweep generation of the heap.
+	sweepGen uint32
+	// blocking indicates that this tracker is blocking sweep
+	// completion, usually as a result of acquiring sweep
+	// ownership of at least one span.
+	blocking bool
+}
+
+// sweepLocked represents sweep ownership of a span.
+type sweepLocked struct {
+	*mspan
+}
+
+func newSweepLocker() sweepLocker {
+	return sweepLocker{
+		sweepGen: mheap_.sweepgen,
+	}
+}
+
+// tryAcquire attempts to acquire sweep ownership of span s. If it
+// successfully acquires ownership, it blocks sweep completion.
+func (l *sweepLocker) tryAcquire(s *mspan) (sweepLocked, bool) {
+	// Check before attempting to CAS.
+	if atomic.Load(&s.sweepgen) != l.sweepGen-2 {
+		return sweepLocked{}, false
+	}
+	// Add ourselves to sweepers before potentially taking
+	// ownership.
+	l.blockCompletion()
+	// Attempt to acquire sweep ownership of s.
+	if !atomic.Cas(&s.sweepgen, l.sweepGen-2, l.sweepGen-1) {
+		return sweepLocked{}, false
+	}
+	return sweepLocked{s}, true
+}
+
+// blockCompletion blocks sweep completion without acquiring any
+// specific spans.
+func (l *sweepLocker) blockCompletion() {
+	if !l.blocking {
+		atomic.Xadd(&mheap_.sweepers, +1)
+		l.blocking = true
+	}
+}
+
+func (l *sweepLocker) dispose() {
+	if !l.blocking {
+		return
+	}
+	// Decrement the number of active sweepers and if this is the
+	// last one, mark sweep as complete.
+	l.blocking = false
+	if atomic.Xadd(&mheap_.sweepers, -1) == 0 && atomic.Load(&mheap_.sweepdone) != 0 {
+		l.sweepIsDone()
+	}
+}
+
+func (l *sweepLocker) sweepIsDone() {
+	if debug.gcpacertrace > 0 {
+		print("pacer: sweep done at heap size ", memstats.heap_live>>20, "MB; allocated ", (memstats.heap_live-mheap_.sweepHeapLiveBasis)>>20, "MB during sweep; swept ", mheap_.pagesSwept, " pages at ", mheap_.sweepPagesPerByte, " pages/byte\n")
+	}
+}
+
 // sweepone sweeps some unswept heap span and returns the number of pages returned
 // to the heap, or ^uintptr(0) if there was nothing to sweep.
 func sweepone() uintptr {
 	_g_ := getg()
-	sweepRatio := mheap_.sweepPagesPerByte // For debugging
 
 	// increment locks to ensure that the goroutine is not preempted
 	// in the middle of sweep thus leaving the span in an inconsistent state for next GC
@@ -196,53 +261,55 @@ func sweepone() uintptr {
 		_g_.m.locks--
 		return ^uintptr(0)
 	}
-	atomic.Xadd(&mheap_.sweepers, +1)
+	// TODO(austin): sweepone is almost always called in a loop;
+	// lift the sweepLocker into its callers.
+	sl := newSweepLocker()
 
 	// Find a span to sweep.
-	var s *mspan
-	sg := mheap_.sweepgen
+	npages := ^uintptr(0)
+	var noMoreWork bool
 	for {
-		s = mheap_.nextSpanForSweep()
+		s := mheap_.nextSpanForSweep()
 		if s == nil {
-			atomic.Store(&mheap_.sweepdone, 1)
+			noMoreWork = atomic.Cas(&mheap_.sweepdone, 0, 1)
 			break
 		}
 		if state := s.state.get(); state != mSpanInUse {
 			// This can happen if direct sweeping already
 			// swept this span, but in that case the sweep
 			// generation should always be up-to-date.
-			if !(s.sweepgen == sg || s.sweepgen == sg+3) {
-				print("runtime: bad span s.state=", state, " s.sweepgen=", s.sweepgen, " sweepgen=", sg, "\n")
+			if !(s.sweepgen == sl.sweepGen || s.sweepgen == sl.sweepGen+3) {
+				print("runtime: bad span s.state=", state, " s.sweepgen=", s.sweepgen, " sweepgen=", sl.sweepGen, "\n")
 				throw("non in-use span in unswept list")
 			}
 			continue
 		}
-		if s.sweepgen == sg-2 && atomic.Cas(&s.sweepgen, sg-2, sg-1) {
+		if s, ok := sl.tryAcquire(s); ok {
+			// Sweep the span we found.
+			npages = s.npages
+			if s.sweep(false) {
+				// Whole span was freed. Count it toward the
+				// page reclaimer credit since these pages can
+				// now be used for span allocation.
+				atomic.Xadduintptr(&mheap_.reclaimCredit, npages)
+			} else {
+				// Span is still in-use, so this returned no
+				// pages to the heap and the span needs to
+				// move to the swept in-use list.
+				npages = 0
+			}
 			break
 		}
 	}
 
-	// Sweep the span we found.
-	npages := ^uintptr(0)
-	if s != nil {
-		npages = s.npages
-		if s.sweep(false) {
-			// Whole span was freed. Count it toward the
-			// page reclaimer credit since these pages can
-			// now be used for span allocation.
-			atomic.Xadduintptr(&mheap_.reclaimCredit, npages)
-		} else {
-			// Span is still in-use, so this returned no
-			// pages to the heap and the span needs to
-			// move to the swept in-use list.
-			npages = 0
-		}
-	}
+	sl.dispose()
 
-	// Decrement the number of active sweepers and if this is the
-	// last one print trace information.
-	if atomic.Xadd(&mheap_.sweepers, -1) == 0 && atomic.Load(&mheap_.sweepdone) != 0 {
-		// Since the sweeper is done, move the scavenge gen forward (signalling
+	if noMoreWork {
+		// The sweep list is empty. There may still be
+		// concurrent sweeps running, but we're at least very
+		// close to done sweeping.
+
+		// Move the scavenge gen forward (signalling
 		// that there's new work to do) and wake the scavenger.
 		//
 		// The scavenger is signaled by the last sweeper because once
@@ -262,11 +329,8 @@ func sweepone() uintptr {
 		// for us to wake the scavenger directly via wakeScavenger, since
 		// it could allocate. Ask sysmon to do it for us instead.
 		readyForScavenger()
-
-		if debug.gcpacertrace > 0 {
-			print("pacer: sweep done at heap size ", memstats.heap_live>>20, "MB; allocated ", (memstats.heap_live-mheap_.sweepHeapLiveBasis)>>20, "MB during sweep; swept ", mheap_.pagesSwept, " pages at ", sweepRatio, " pages/byte\n")
-		}
 	}
+
 	_g_.m.locks--
 	return npages
 }
@@ -292,20 +356,19 @@ func (s *mspan) ensureSwept() {
 		throw("mspan.ensureSwept: m is not locked")
 	}
 
-	sg := mheap_.sweepgen
-	spangen := atomic.Load(&s.sweepgen)
-	if spangen == sg || spangen == sg+3 {
-		return
-	}
+	sl := newSweepLocker()
 	// The caller must be sure that the span is a mSpanInUse span.
-	if atomic.Cas(&s.sweepgen, sg-2, sg-1) {
+	if s, ok := sl.tryAcquire(s); ok {
 		s.sweep(false)
+		sl.dispose()
 		return
 	}
+	sl.dispose()
+
 	// unfortunate condition, and we don't have efficient means to wait
 	for {
 		spangen := atomic.Load(&s.sweepgen)
-		if spangen == sg || spangen == sg+3 {
+		if spangen == sl.sweepGen || spangen == sl.sweepGen+3 {
 			break
 		}
 		osyield()
@@ -317,13 +380,21 @@ func (s *mspan) ensureSwept() {
 // Returns true if the span was returned to heap.
 // If preserve=true, don't return it to heap nor relink in mcentral lists;
 // caller takes care of it.
-func (s *mspan) sweep(preserve bool) bool {
+func (sl *sweepLocked) sweep(preserve bool) bool {
 	// It's critical that we enter this function with preemption disabled,
 	// GC must not start while we are in the middle of this function.
 	_g_ := getg()
 	if _g_.m.locks == 0 && _g_.m.mallocing == 0 && _g_ != _g_.m.g0 {
 		throw("mspan.sweep: m is not locked")
 	}
+
+	s := sl.mspan
+	if !preserve {
+		// We'll release ownership of this span. Nil it out to
+		// prevent the caller from accidentally using it.
+		sl.mspan = nil
+	}
+
 	sweepgen := mheap_.sweepgen
 	if state := s.state.get(); state != mSpanInUse || s.sweepgen != sweepgen-1 {
 		print("mspan.sweep: state=", state, " sweepgen=", s.sweepgen, " mheap.sweepgen=", sweepgen, "\n")
diff --git a/src/runtime/mheap.go b/src/runtime/mheap.go
index da3772cdb6..f438e789c9 100644
--- a/src/runtime/mheap.go
+++ b/src/runtime/mheap.go
@@ -817,7 +817,7 @@ func (h *mheap) reclaimChunk(arenas []arenaIdx, pageIdx, n uintptr) uintptr {
 
 	n0 := n
 	var nFreed uintptr
-	sg := h.sweepgen
+	sl := newSweepLocker()
 	for n > 0 {
 		ai := arenas[pageIdx/pagesPerArena]
 		ha := h.arenas[ai.l1()][ai.l2()]
@@ -842,7 +842,7 @@ func (h *mheap) reclaimChunk(arenas []arenaIdx, pageIdx, n uintptr) uintptr {
 			for j := uint(0); j < 8; j++ {
 				if inUseUnmarked&(1<<j) != 0 {
 					s := ha.spans[arenaPage+uint(i)*8+j]
-					if atomic.Load(&s.sweepgen) == sg-2 && atomic.Cas(&s.sweepgen, sg-2, sg-1) {
+					if s, ok := sl.tryAcquire(s); ok {
 						npages := s.npages
 						unlock(&h.lock)
 						if s.sweep(false) {
@@ -863,6 +863,7 @@ func (h *mheap) reclaimChunk(arenas []arenaIdx, pageIdx, n uintptr) uintptr {
 		pageIdx += uintptr(len(inUse) * 8)
 		n -= uintptr(len(inUse) * 8)
 	}
+	sl.dispose()
 	if trace.enabled {
 		unlock(&h.lock)
 		// Account for pages scanned but not reclaimed.
-- 
GitLab


From 1b736b3c19375f6ebd0d834c02316fb13700be27 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Tue, 6 Apr 2021 19:25:28 -0400
Subject: [PATCH 1505/2400] runtime: consolidate "is sweep done" conditions

The runtime currently has two different notions of sweep completion:

1. All spans are either swept or have begun sweeping.

2. The sweeper has *finished* sweeping all spans.

Having both is confusing (it doesn't help that the documentation is
often unclear or wrong). Condition 2 is stronger and the theoretical
slight optimization that condition 1 could impact is never actually
useful. Hence, this CL consolidates both conditions down to condition 2.

Updates #45315.

Change-Id: I55c84d767d74eb31a004a5619eaba2e351162332
Reviewed-on: https://go-review.googlesource.com/c/go/+/307916
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/mgc.go      |  6 +++---
 src/runtime/mgcsweep.go | 13 ++++++++-----
 src/runtime/mheap.go    | 13 +++++++------
 3 files changed, 18 insertions(+), 14 deletions(-)

diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index 8c1ff20936..25bf4a226b 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -175,7 +175,7 @@ func gcinit() {
 	}
 
 	// No sweep on the first cycle.
-	mheap_.sweepdone = 1
+	mheap_.sweepDrained = 1
 
 	// Set a reasonable initial GC trigger.
 	memstats.triggerRatio = 7 / 8.0
@@ -1187,7 +1187,7 @@ func GC() {
 	// First, wait for sweeping to finish. (We know there are no
 	// more spans on the sweep queue, but we may be concurrently
 	// sweeping spans, so we have to wait.)
-	for atomic.Load(&work.cycles) == n+1 && atomic.Load(&mheap_.sweepers) != 0 {
+	for atomic.Load(&work.cycles) == n+1 && !isSweepDone() {
 		Gosched()
 	}
 
@@ -2192,7 +2192,7 @@ func gcSweep(mode gcMode) {
 
 	lock(&mheap_.lock)
 	mheap_.sweepgen += 2
-	mheap_.sweepdone = 0
+	mheap_.sweepDrained = 0
 	mheap_.pagesSwept = 0
 	mheap_.sweepArenas = mheap_.allArenas
 	mheap_.reclaimIndex = 0
diff --git a/src/runtime/mgcsweep.go b/src/runtime/mgcsweep.go
index ed2091bd2e..ce1fd0ac85 100644
--- a/src/runtime/mgcsweep.go
+++ b/src/runtime/mgcsweep.go
@@ -238,7 +238,7 @@ func (l *sweepLocker) dispose() {
 	// Decrement the number of active sweepers and if this is the
 	// last one, mark sweep as complete.
 	l.blocking = false
-	if atomic.Xadd(&mheap_.sweepers, -1) == 0 && atomic.Load(&mheap_.sweepdone) != 0 {
+	if atomic.Xadd(&mheap_.sweepers, -1) == 0 && atomic.Load(&mheap_.sweepDrained) != 0 {
 		l.sweepIsDone()
 	}
 }
@@ -257,7 +257,7 @@ func sweepone() uintptr {
 	// increment locks to ensure that the goroutine is not preempted
 	// in the middle of sweep thus leaving the span in an inconsistent state for next GC
 	_g_.m.locks++
-	if atomic.Load(&mheap_.sweepdone) != 0 {
+	if atomic.Load(&mheap_.sweepDrained) != 0 {
 		_g_.m.locks--
 		return ^uintptr(0)
 	}
@@ -271,7 +271,7 @@ func sweepone() uintptr {
 	for {
 		s := mheap_.nextSpanForSweep()
 		if s == nil {
-			noMoreWork = atomic.Cas(&mheap_.sweepdone, 0, 1)
+			noMoreWork = atomic.Cas(&mheap_.sweepDrained, 0, 1)
 			break
 		}
 		if state := s.state.get(); state != mSpanInUse {
@@ -335,14 +335,17 @@ func sweepone() uintptr {
 	return npages
 }
 
-// isSweepDone reports whether all spans are swept or currently being swept.
+// isSweepDone reports whether all spans are swept.
 //
 // Note that this condition may transition from false to true at any
 // time as the sweeper runs. It may transition from true to false if a
 // GC runs; to prevent that the caller must be non-preemptible or must
 // somehow block GC progress.
 func isSweepDone() bool {
-	return mheap_.sweepdone != 0
+	// Check that all spans have at least begun sweeping and there
+	// are no active sweepers. If both are true, then all spans
+	// have finished sweeping.
+	return atomic.Load(&mheap_.sweepDrained) != 0 && atomic.Load(&mheap_.sweepers) == 0
 }
 
 // Returns only when span s has been swept.
diff --git a/src/runtime/mheap.go b/src/runtime/mheap.go
index f438e789c9..dfc25940d2 100644
--- a/src/runtime/mheap.go
+++ b/src/runtime/mheap.go
@@ -62,11 +62,12 @@ const (
 type mheap struct {
 	// lock must only be acquired on the system stack, otherwise a g
 	// could self-deadlock if its stack grows with the lock held.
-	lock      mutex
-	pages     pageAlloc // page allocation data structure
-	sweepgen  uint32    // sweep generation, see comment in mspan; written during STW
-	sweepdone uint32    // all spans are swept
-	sweepers  uint32    // number of active sweepone calls
+	lock  mutex
+	pages pageAlloc // page allocation data structure
+
+	sweepgen     uint32 // sweep generation, see comment in mspan; written during STW
+	sweepDrained uint32 // all spans are swept or are being swept
+	sweepers     uint32 // number of active sweepone calls
 
 	// allspans is a slice of all mspans ever created. Each mspan
 	// appears exactly once.
@@ -904,7 +905,7 @@ func (h *mheap) alloc(npages uintptr, spanclass spanClass, needzero bool) *mspan
 	systemstack(func() {
 		// To prevent excessive heap growth, before allocating n pages
 		// we need to sweep and reclaim at least n pages.
-		if h.sweepdone == 0 {
+		if !isSweepDone() {
 			h.reclaim(npages)
 		}
 		s = h.allocSpan(npages, spanAllocHeap, spanclass)
-- 
GitLab


From 3e8ba91275cdeb0af4c8b30f9cc788fd42cfbbd3 Mon Sep 17 00:00:00 2001
From: Jacalz <jacob.alzen@gmail.com>
Date: Fri, 9 Apr 2021 14:57:59 +0000
Subject: [PATCH 1506/2400] mime: support reading shared mime-info database on
 unix systems

This adds support for reading the FreeDesktop Shared MIME-info Database on Unix systems, if it exists.
It should make lookups work on systems where the mime.types files are not present and
should lead to better mimetype lookup in general. If the shared mimetype database does not exist,
we will fall back to reading mime.types files in common locations.

Related to a bug on Solus bugtracker: https://dev.getsol.us/T9394
This change makes the mime package work on Solus.

Change-Id: If330c22ffe523bf31f7f10807a54fc8858517055
GitHub-Last-Rev: d5fbe8c41a9d975029b35498183a0f5a40df8e6a
GitHub-Pull-Request: golang/go#45271
Reviewed-on: https://go-review.googlesource.com/c/go/+/305230
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/mime/testdata/test.types.globs2 |  8 ++++++
 src/mime/type_unix.go               | 41 +++++++++++++++++++++++++++++
 src/mime/type_unix_test.go          | 39 +++++++++++++++++++++++++++
 3 files changed, 88 insertions(+)
 create mode 100644 src/mime/testdata/test.types.globs2
 create mode 100644 src/mime/type_unix_test.go

diff --git a/src/mime/testdata/test.types.globs2 b/src/mime/testdata/test.types.globs2
new file mode 100644
index 0000000000..2e893262ea
--- /dev/null
+++ b/src/mime/testdata/test.types.globs2
@@ -0,0 +1,8 @@
+# Copyright 2021 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.
+
+
+# mime package test for globs2
+50:document/test:*.t3
+50:example/test:*.t4
diff --git a/src/mime/type_unix.go b/src/mime/type_unix.go
index 851d5a0fb0..59c99e2c86 100644
--- a/src/mime/type_unix.go
+++ b/src/mime/type_unix.go
@@ -17,6 +17,14 @@ func init() {
 	osInitMime = initMimeUnix
 }
 
+// See https://specifications.freedesktop.org/shared-mime-info-spec/shared-mime-info-spec-0.21.html
+// for the FreeDesktop Shared MIME-info Database specification.
+var mimeGlobs = []string{
+	"/usr/local/share/mime/globs2",
+	"/usr/share/mime/globs2",
+}
+
+// Common locations for mime.types files on unix.
 var typeFiles = []string{
 	"/etc/mime.types",
 	"/etc/apache2/mime.types",
@@ -24,6 +32,31 @@ var typeFiles = []string{
 	"/etc/httpd/conf/mime.types",
 }
 
+func loadMimeGlobsFile(filename string) error {
+	f, err := os.Open(filename)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	scanner := bufio.NewScanner(f)
+	for scanner.Scan() {
+		// Each line should be of format: weight:mimetype:*.ext
+		fields := strings.Split(scanner.Text(), ":")
+		if len(fields) < 3 || len(fields[0]) < 1 || len(fields[2]) < 2 {
+			continue
+		} else if fields[0][0] == '#' || fields[2][0] != '*' {
+			continue
+		}
+
+		setExtensionType(fields[2][1:], fields[1])
+	}
+	if err := scanner.Err(); err != nil {
+		panic(err)
+	}
+	return nil
+}
+
 func loadMimeFile(filename string) {
 	f, err := os.Open(filename)
 	if err != nil {
@@ -51,12 +84,20 @@ func loadMimeFile(filename string) {
 }
 
 func initMimeUnix() {
+	for _, filename := range mimeGlobs {
+		if err := loadMimeGlobsFile(filename); err == nil {
+			return // Stop checking more files if mimetype database is found.
+		}
+	}
+
+	// Fallback if no system-generated mimetype database exists.
 	for _, filename := range typeFiles {
 		loadMimeFile(filename)
 	}
 }
 
 func initMimeForTests() map[string]string {
+	mimeGlobs = []string{""}
 	typeFiles = []string{"testdata/test.types"}
 	return map[string]string{
 		".T1":  "application/test",
diff --git a/src/mime/type_unix_test.go b/src/mime/type_unix_test.go
new file mode 100644
index 0000000000..6e2988225c
--- /dev/null
+++ b/src/mime/type_unix_test.go
@@ -0,0 +1,39 @@
+// Copyright 2021 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.
+
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
+// +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris
+
+package mime
+
+import (
+	"testing"
+)
+
+func initMimeUnixTest(t *testing.T) {
+	err := loadMimeGlobsFile("testdata/test.types.globs2")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	loadMimeFile("testdata/test.types")
+}
+
+func TestTypeByExtensionUNIX(t *testing.T) {
+	initMimeUnixTest(t)
+	typeTests := map[string]string{
+		".T1":  "application/test",
+		".t2":  "text/test; charset=utf-8",
+		".t3":  "document/test",
+		".t4":  "example/test",
+		".png": "image/png",
+	}
+
+	for ext, want := range typeTests {
+		val := TypeByExtension(ext)
+		if val != want {
+			t.Errorf("TypeByExtension(%q) = %q, want %q", ext, val, want)
+		}
+	}
+}
-- 
GitLab


From 5c9b6e8e63e012513b1cb1a4a08ff23dec4137a1 Mon Sep 17 00:00:00 2001
From: Josh Rickmar <jrick@companyzero.com>
Date: Fri, 26 Mar 2021 13:17:36 +0000
Subject: [PATCH 1507/2400] net: never probe IPv4 map support on DragonFly BSD,
 OpenBSD

DragonFly BSD and OpenBSD do not implement mapping IPv4 addresses to
the IPv6 address space, and a runtime check can be avoided.

As the IP stack capabilities probe was only being called from
supportsIPv4map to check for this support, the OS-specific handling
can be added to this function rather than continuing to run the probe.

Change-Id: I5800c197b1be502a6efa79e3edd6356bde8637fb
GitHub-Last-Rev: 7eb67189cd955fb12382a6f2a05f324d2747dcc3
GitHub-Pull-Request: golang/go#45243
Reviewed-on: https://go-review.googlesource.com/c/go/+/304870
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/net/ipsock.go | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/net/ipsock.go b/src/net/ipsock.go
index 7d0684d176..0f5da2577c 100644
--- a/src/net/ipsock.go
+++ b/src/net/ipsock.go
@@ -7,6 +7,7 @@ package net
 import (
 	"context"
 	"internal/bytealg"
+	"runtime"
 	"sync"
 )
 
@@ -44,6 +45,13 @@ func supportsIPv6() bool {
 // IPv4 address inside an IPv6 address at transport layer
 // protocols. See RFC 4291, RFC 4038 and RFC 3493.
 func supportsIPv4map() bool {
+	// Some operating systems provide no support for mapping IPv4
+	// addresses to IPv6, and a runtime check is unnecessary.
+	switch runtime.GOOS {
+	case "dragonfly", "openbsd":
+		return false
+	}
+
 	ipStackCaps.Once.Do(ipStackCaps.probe)
 	return ipStackCaps.ipv4MappedIPv6Enabled
 }
-- 
GitLab


From aad13cbb749d1e6c085ff0556d306de1a2d5d063 Mon Sep 17 00:00:00 2001
From: Michael Pratt <mpratt@google.com>
Date: Fri, 9 Apr 2021 17:01:45 -0400
Subject: [PATCH 1508/2400] runtime: non-strict InlTreeIndex lookup in
 expandFinalInlineFrame

This is a follow-up to golang.org/cl/301369, which made the same change
in Frames.Next. The same logic applies here: a profile stack may have
been truncated at an invalid PC provided by cgoTraceback.
expandFinalInlineFrame will then try to lookup the inline tree and
crash.

The same fix applies as well: upon encountering a bad PC, simply leave
it as-is and move on.

Fixes #44971
Fixes #45480

Change-Id: I2823c67a1f3425466b05384cc6d30f5fc8ee6ddc
Reviewed-on: https://go-review.googlesource.com/c/go/+/309109
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Trust: Michael Pratt <mpratt@google.com>
---
 src/runtime/symtab.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/runtime/symtab.go b/src/runtime/symtab.go
index 3d1f6126a6..a382cf6002 100644
--- a/src/runtime/symtab.go
+++ b/src/runtime/symtab.go
@@ -185,7 +185,9 @@ func runtime_expandFinalInlineFrame(stk []uintptr) []uintptr {
 	var cache pcvalueCache
 	inltree := (*[1 << 20]inlinedCall)(inldata)
 	for {
-		ix := pcdatavalue(f, _PCDATA_InlTreeIndex, tracepc, &cache)
+		// Non-strict as cgoTraceback may have added bogus PCs
+		// with a valid funcInfo but invalid PCDATA.
+		ix := pcdatavalue1(f, _PCDATA_InlTreeIndex, tracepc, &cache, false)
 		if ix < 0 {
 			break
 		}
-- 
GitLab


From cccd3ba912ae903498e7fdc60fb47f5cb64c3570 Mon Sep 17 00:00:00 2001
From: Manlio Perillo <manlio.perillo@gmail.com>
Date: Mon, 12 Apr 2021 21:46:14 +0200
Subject: [PATCH 1509/2400] internal/execabs: replace ioutil.WriteFile with
 os.WriteFile

Fixes #45532.

Change-Id: I844acd50d6fa1ce918969bbb52f79dd7412d289f
Reviewed-on: https://go-review.googlesource.com/c/go/+/309350
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/internal/execabs/execabs_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/internal/execabs/execabs_test.go b/src/internal/execabs/execabs_test.go
index 7609b2106a..97a3f39b4a 100644
--- a/src/internal/execabs/execabs_test.go
+++ b/src/internal/execabs/execabs_test.go
@@ -42,7 +42,7 @@ func TestCommand(t *testing.T) {
 			executable += ".exe"
 		}
 		if err := os.WriteFile(filepath.Join(tmpDir, executable), []byte{1, 2, 3}, 0111); err != nil {
-			t.Fatalf("ioutil.WriteFile failed: %s", err)
+			t.Fatalf("os.WriteFile failed: %s", err)
 		}
 		cwd, err := os.Getwd()
 		if err != nil {
@@ -77,7 +77,7 @@ func TestLookPath(t *testing.T) {
 		executable += ".exe"
 	}
 	if err := os.WriteFile(filepath.Join(tmpDir, executable), []byte{1, 2, 3}, 0111); err != nil {
-		t.Fatalf("ioutil.WriteFile failed: %s", err)
+		t.Fatalf("os.WriteFile failed: %s", err)
 	}
 	cwd, err := os.Getwd()
 	if err != nil {
-- 
GitLab


From c27991bf5b5a0c8b7383650309d10913eb0497c4 Mon Sep 17 00:00:00 2001
From: Manlio Perillo <manlio.perillo@gmail.com>
Date: Mon, 12 Apr 2021 22:24:01 +0200
Subject: [PATCH 1510/2400] text/template: replace os.MkdirTemp with T.TempDir

Updates #45402

Change-Id: I9d55191c4021387b771550b5c93c91806f694aa6
Reviewed-on: https://go-review.googlesource.com/c/go/+/309351
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/text/template/link_test.go | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/text/template/link_test.go b/src/text/template/link_test.go
index 9dc70dfc0d..e1d3136abe 100644
--- a/src/text/template/link_test.go
+++ b/src/text/template/link_test.go
@@ -39,11 +39,7 @@ func main() {
 	t.Used()
 }
 `
-	td, err := os.MkdirTemp("", "text_template_TestDeadCodeElimination")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(td)
+	td := t.TempDir()
 
 	if err := os.WriteFile(filepath.Join(td, "x.go"), []byte(prog), 0644); err != nil {
 		t.Fatal(err)
-- 
GitLab


From 3d5e3a15f65f1dd622c87ffba58914c877c8112c Mon Sep 17 00:00:00 2001
From: Manlio Perillo <manlio.perillo@gmail.com>
Date: Mon, 12 Apr 2021 22:49:07 +0200
Subject: [PATCH 1511/2400] debug/pe: replace os.MkdirTemp with T.TempDir

Updates #45402

Change-Id: I3d83a66270ca38e82d6bb7f8a1367af3d5343a98
Reviewed-on: https://go-review.googlesource.com/c/go/+/309352
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/debug/pe/file_test.go | 21 ++++-----------------
 1 file changed, 4 insertions(+), 17 deletions(-)

diff --git a/src/debug/pe/file_test.go b/src/debug/pe/file_test.go
index 58deff1450..8964b4f847 100644
--- a/src/debug/pe/file_test.go
+++ b/src/debug/pe/file_test.go
@@ -353,11 +353,7 @@ func testDWARF(t *testing.T, linktype int) {
 	}
 	testenv.MustHaveGoRun(t)
 
-	tmpdir, err := os.MkdirTemp("", "TestDWARF")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	src := filepath.Join(tmpdir, "a.go")
 	file, err := os.Create(src)
@@ -472,11 +468,7 @@ func TestBSSHasZeros(t *testing.T) {
 		t.Skip("skipping test: gcc is missing")
 	}
 
-	tmpdir, err := os.MkdirTemp("", "TestBSSHasZeros")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	srcpath := filepath.Join(tmpdir, "a.c")
 	src := `
@@ -596,15 +588,10 @@ func TestBuildingWindowsGUI(t *testing.T) {
 	if runtime.GOOS != "windows" {
 		t.Skip("skipping windows only test")
 	}
-	tmpdir, err := os.MkdirTemp("", "TestBuildingWindowsGUI")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	src := filepath.Join(tmpdir, "a.go")
-	err = os.WriteFile(src, []byte(`package main; func main() {}`), 0644)
-	if err != nil {
+	if err := os.WriteFile(src, []byte(`package main; func main() {}`), 0644); err != nil {
 		t.Fatal(err)
 	}
 	exe := filepath.Join(tmpdir, "a.exe")
-- 
GitLab


From 263e13d1f7d2d13782c5a63799c9979b9bbfd853 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Mon, 12 Apr 2021 14:00:49 -0400
Subject: [PATCH 1512/2400] test: make codegen tests work with both ABIs

Some codegen tests were written with the assumption that
arguments and results are in memory, and with a specific stack
layout. With the register ABI, the assumption is no longer true.
Adjust the tests to work with both cases.

- For tests expecting in memory arguments/results, change to use
  global variables or memory-assigned argument/results.

- Allow more registers. E.g. some tests expecting register names
  contain only letters (e.g. AX), but  it can also contain numbers
  (e.g. R10).

- Some instruction selection changes when operate on register vs.
  memory, e.g. ADDQ vs. LEAQ, MOVB vs. MOVL. Accept both.

TODO: mathbits.go and memops.go still need fix.
Change-Id: Ic5932b4b5dd3f5d30ed078d296476b641420c4c5
Reviewed-on: https://go-review.googlesource.com/c/go/+/309335
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
---
 test/codegen/arithmetic.go     |  2 +-
 test/codegen/bits.go           | 18 +++++++++---------
 test/codegen/clobberdeadreg.go |  4 ++--
 test/codegen/comparisons.go    |  8 +++++---
 test/codegen/issue25378.go     |  8 ++++----
 test/codegen/maps.go           |  4 ++--
 test/codegen/math.go           |  4 ++--
 test/codegen/memcombine.go     | 12 ++++++------
 test/codegen/slices.go         |  2 +-
 test/codegen/stack.go          |  4 ++--
 test/codegen/zerosize.go       | 10 +++++-----
 11 files changed, 39 insertions(+), 37 deletions(-)

diff --git a/test/codegen/arithmetic.go b/test/codegen/arithmetic.go
index dea7e0ba61..a27a17f6e1 100644
--- a/test/codegen/arithmetic.go
+++ b/test/codegen/arithmetic.go
@@ -139,7 +139,7 @@ func MergeMuls1(n int) int {
 }
 
 func MergeMuls2(n int) int {
-	// amd64:"IMUL3Q\t[$]23","ADDQ\t[$]29"
+	// amd64:"IMUL3Q\t[$]23","(ADDQ\t[$]29)|(LEAQ\t29)"
 	// 386:"IMUL3L\t[$]23","ADDL\t[$]29"
 	return 5*n + 7*(n+1) + 11*(n+2) // 23n + 29
 }
diff --git a/test/codegen/bits.go b/test/codegen/bits.go
index d41383f42c..2bd92dd51b 100644
--- a/test/codegen/bits.go
+++ b/test/codegen/bits.go
@@ -264,23 +264,23 @@ func bitcompl32(a, b uint32) (n uint32) {
 
 // check direct operation on memory with constant and shifted constant sources
 func bitOpOnMem(a []uint32, b, c, d uint32) {
-	// amd64:`ANDL\s[$]200,\s\([A-Z]+\)`
+	// amd64:`ANDL\s[$]200,\s\([A-Z][A-Z0-9]+\)`
 	a[0] &= 200
-	// amd64:`ORL\s[$]220,\s4\([A-Z]+\)`
+	// amd64:`ORL\s[$]220,\s4\([A-Z][A-Z0-9]+\)`
 	a[1] |= 220
-	// amd64:`XORL\s[$]240,\s8\([A-Z]+\)`
+	// amd64:`XORL\s[$]240,\s8\([A-Z][A-Z0-9]+\)`
 	a[2] ^= 240
-	// amd64:`BTRL\s[$]15,\s12\([A-Z]+\)`,-`ANDL`
+	// amd64:`BTRL\s[$]15,\s12\([A-Z][A-Z0-9]+\)`,-`ANDL`
 	a[3] &= 0xffff7fff
-	// amd64:`BTSL\s[$]14,\s16\([A-Z]+\)`,-`ORL`
+	// amd64:`BTSL\s[$]14,\s16\([A-Z][A-Z0-9]+\)`,-`ORL`
 	a[4] |= 0x4000
-	// amd64:`BTCL\s[$]13,\s20\([A-Z]+\)`,-`XORL`
+	// amd64:`BTCL\s[$]13,\s20\([A-Z][A-Z0-9]+\)`,-`XORL`
 	a[5] ^= 0x2000
-	// amd64:`BTRL\s[A-Z]+,\s24\([A-Z]+\)`
+	// amd64:`BTRL\s[A-Z][A-Z0-9]+,\s24\([A-Z][A-Z0-9]+\)`
 	a[6] &^= 1 << (b & 31)
-	// amd64:`BTSL\s[A-Z]+,\s28\([A-Z]+\)`
+	// amd64:`BTSL\s[A-Z][A-Z0-9]+,\s28\([A-Z][A-Z0-9]+\)`
 	a[7] |= 1 << (c & 31)
-	// amd64:`BTCL\s[A-Z]+,\s32\([A-Z]+\)`
+	// amd64:`BTCL\s[A-Z][A-Z0-9]+,\s32\([A-Z][A-Z0-9]+\)`
 	a[8] ^= 1 << (d & 31)
 }
 
diff --git a/test/codegen/clobberdeadreg.go b/test/codegen/clobberdeadreg.go
index 026850afba..2a93c410f9 100644
--- a/test/codegen/clobberdeadreg.go
+++ b/test/codegen/clobberdeadreg.go
@@ -19,14 +19,14 @@ func F(a, b, c int, d S) {
 	// amd64:`MOVQ\t\$-2401018187971961171, R8`, `MOVQ\t\$-2401018187971961171, R9`, `MOVQ\t\$-2401018187971961171, R10`
 	// amd64:`MOVQ\t\$-2401018187971961171, R11`, `MOVQ\t\$-2401018187971961171, R12`, `MOVQ\t\$-2401018187971961171, R13`
 	// amd64:-`MOVQ\t\$-2401018187971961171, BP` // frame pointer is not clobbered
-	StackArgsCall(a, b, c, d)
+	StackArgsCall([10]int{a, b, c})
 	// amd64:`MOVQ\t\$-2401018187971961171, R12`, `MOVQ\t\$-2401018187971961171, R13`, `MOVQ\t\$-2401018187971961171, DX`
 	// amd64:-`MOVQ\t\$-2401018187971961171, AX`, -`MOVQ\t\$-2401018187971961171, R11` // register args are not clobbered
 	RegArgsCall(a, b, c, d)
 }
 
 //go:noinline
-func StackArgsCall(int, int, int, S) {}
+func StackArgsCall([10]int) {}
 
 //go:noinline
 //go:registerparams
diff --git a/test/codegen/comparisons.go b/test/codegen/comparisons.go
index 719063cdc3..17dcd94ae1 100644
--- a/test/codegen/comparisons.go
+++ b/test/codegen/comparisons.go
@@ -90,9 +90,11 @@ func CompareArray6(a, b unsafe.Pointer) bool {
 
 // Test that LEAQ/ADDQconst are folded into SETx ops
 
-func CmpFold(x uint32) bool {
-	// amd64:`SETHI\t.*\(SP\)`
-	return x > 4
+var r bool
+
+func CmpFold(x uint32) {
+	// amd64:`SETHI\t.*\(SB\)`
+	r = x > 4
 }
 
 // Test that direct comparisons with memory are generated when
diff --git a/test/codegen/issue25378.go b/test/codegen/issue25378.go
index 14aa2c30f2..810a022722 100644
--- a/test/codegen/issue25378.go
+++ b/test/codegen/issue25378.go
@@ -13,10 +13,10 @@ var wsp = [256]bool{
 	'\r': true,
 }
 
-func zeroExtArgByte(ch byte) bool {
-	return wsp[ch] // amd64:-"MOVBLZX\t..,.."
+func zeroExtArgByte(ch [2]byte) bool {
+	return wsp[ch[0]] // amd64:-"MOVBLZX\t..,.."
 }
 
-func zeroExtArgUint16(ch uint16) bool {
-	return wsp[ch] // amd64:-"MOVWLZX\t..,.."
+func zeroExtArgUint16(ch [2]uint16) bool {
+	return wsp[ch[0]] // amd64:-"MOVWLZX\t..,.."
 }
diff --git a/test/codegen/maps.go b/test/codegen/maps.go
index 8dd22ed5ca..dcb4a9381f 100644
--- a/test/codegen/maps.go
+++ b/test/codegen/maps.go
@@ -16,12 +16,12 @@ package codegen
 // Direct use of constants in fast map access calls (Issue #19015).
 
 func AccessInt1(m map[int]int) int {
-	// amd64:"MOVQ\t[$]5"
+	// amd64:"MOV[LQ]\t[$]5"
 	return m[5]
 }
 
 func AccessInt2(m map[int]int) bool {
-	// amd64:"MOVQ\t[$]5"
+	// amd64:"MOV[LQ]\t[$]5"
 	_, ok := m[5]
 	return ok
 }
diff --git a/test/codegen/math.go b/test/codegen/math.go
index 243ddb0494..04cb4e577d 100644
--- a/test/codegen/math.go
+++ b/test/codegen/math.go
@@ -160,13 +160,13 @@ func toFloat32(u32 uint32) float32 {
 // are evaluated at compile-time
 
 func constantCheck64() bool {
-	// amd64:"MOVB\t[$]0",-"FCMP",-"MOVB\t[$]1"
+	// amd64:"(MOVB\t[$]0)|(XORL\t[A-Z][A-Z0-9]+, [A-Z][A-Z0-9]+)",-"FCMP",-"MOVB\t[$]1"
 	// s390x:"MOV(B|BZ|D)\t[$]0,",-"FCMPU",-"MOV(B|BZ|D)\t[$]1,"
 	return 0.5 == float64(uint32(1)) || 1.5 > float64(uint64(1<<63))
 }
 
 func constantCheck32() bool {
-	// amd64:"MOVB\t[$]1",-"FCMP",-"MOVB\t[$]0"
+	// amd64:"MOV(B|L)\t[$]1",-"FCMP",-"MOV(B|L)\t[$]0"
 	// s390x:"MOV(B|BZ|D)\t[$]1,",-"FCMPU",-"MOV(B|BZ|D)\t[$]0,"
 	return float32(0.5) <= float32(int64(1)) && float32(1.5) >= float32(int32(-1<<31))
 }
diff --git a/test/codegen/memcombine.go b/test/codegen/memcombine.go
index 121f394f29..d74dae07f5 100644
--- a/test/codegen/memcombine.go
+++ b/test/codegen/memcombine.go
@@ -306,16 +306,16 @@ func load_be_byte8_uint64_idx8(s []byte, idx int) uint64 {
 
 // Check load combining across function calls.
 
-func fcall_byte(a, b byte) (byte, byte) {
-	return fcall_byte(fcall_byte(a, b)) // amd64:`MOVW`
+func fcall_byte(a [2]byte) [2]byte {
+	return fcall_byte(fcall_byte(a)) // amd64:`MOVW`
 }
 
-func fcall_uint16(a, b uint16) (uint16, uint16) {
-	return fcall_uint16(fcall_uint16(a, b)) // amd64:`MOVL`
+func fcall_uint16(a [2]uint16) [2]uint16 {
+	return fcall_uint16(fcall_uint16(a)) // amd64:`MOVL`
 }
 
-func fcall_uint32(a, b uint32) (uint32, uint32) {
-	return fcall_uint32(fcall_uint32(a, b)) // amd64:`MOVQ`
+func fcall_uint32(a [2]uint32) [2]uint32 {
+	return fcall_uint32(fcall_uint32(a)) // amd64:`MOVQ`
 }
 
 // We want to merge load+op in the first function, but not in the
diff --git a/test/codegen/slices.go b/test/codegen/slices.go
index 38e8a62f4b..d20aa9eddf 100644
--- a/test/codegen/slices.go
+++ b/test/codegen/slices.go
@@ -307,7 +307,7 @@ func InitSmallSliceLiteral() []int {
 }
 
 func InitNotSmallSliceLiteral() []int {
-	// amd64:`MOVQ\t.*autotmp_`
+	// amd64:`LEAQ\t.*stmp_`
 	return []int{
 		42,
 		42,
diff --git a/test/codegen/stack.go b/test/codegen/stack.go
index 7d70024cdd..f28b4a3320 100644
--- a/test/codegen/stack.go
+++ b/test/codegen/stack.go
@@ -92,11 +92,11 @@ func ArrayInit(i, j int) [4]int {
 // Check that assembly output has matching offset and base register
 // (issue #21064).
 
-func check_asmout(a, b int) int {
+func check_asmout(b [2]int) int {
 	runtime.GC() // use some frame
 	// amd64:`.*b\+24\(SP\)`
 	// arm:`.*b\+4\(FP\)`
-	return b
+	return b[1]
 }
 
 // Check that simple functions get promoted to nosplit, even when
diff --git a/test/codegen/zerosize.go b/test/codegen/zerosize.go
index cd0c83b6ef..292c5a018b 100644
--- a/test/codegen/zerosize.go
+++ b/test/codegen/zerosize.go
@@ -12,14 +12,14 @@ package codegen
 
 func zeroSize() {
 	c := make(chan struct{})
-	// amd64:`MOVQ\t\$0, ""\.s\+32\(SP\)`
+	// amd64:`MOVQ\t\$0, ""\.s\+56\(SP\)`
 	var s *int
-	g(&s) // force s to be a stack object
+	// force s to be a stack object, also use some (fixed) stack space
+	g(&s, 1, 2, 3, 4, 5)
 
-	// amd64:`LEAQ\t""\..*\+31\(SP\)`
+	// amd64:`LEAQ\t""\..*\+55\(SP\)`
 	c <- struct{}{}
 }
 
 //go:noinline
-func g(p **int) {
-}
+func g(**int, int, int, int, int, int) {}
-- 
GitLab


From 841bc142160aacde729a983243a0231c8612903d Mon Sep 17 00:00:00 2001
From: Grace Han <hgrace503@gmail.com>
Date: Fri, 9 Apr 2021 15:49:22 +1000
Subject: [PATCH 1513/2400] os: restore testErrNotExist's working directory on
 os.Chdir success

The existing implementation calls os.Chdir expecting the call not to
succeed. This change restores the original working directory in the
case that the call does succeed.

Fixes #45407

Change-Id: I61c57f6858b9a9058226e45e24276c7af8913048
Reviewed-on: https://go-review.googlesource.com/c/go/+/308849
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/os/error_test.go | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/src/os/error_test.go b/src/os/error_test.go
index 58b3f391d1..4ab6246d2e 100644
--- a/src/os/error_test.go
+++ b/src/os/error_test.go
@@ -33,7 +33,12 @@ func TestErrIsExist(t *testing.T) {
 	}
 }
 
-func testErrNotExist(name string) string {
+func testErrNotExist(t *testing.T, name string) string {
+	originalWD, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+
 	f, err := os.Open(name)
 	if err == nil {
 		f.Close()
@@ -45,7 +50,10 @@ func testErrNotExist(name string) string {
 
 	err = os.Chdir(name)
 	if err == nil {
-		return "Chdir should have failed"
+		if err := os.Chdir(originalWD); err != nil {
+			t.Fatalf("Chdir should have failed, failed to restore original working directory: %v", err)
+		}
+		return "Chdir should have failed, restored original working directory"
 	}
 	if s := checkErrorPredicate("os.IsNotExist", os.IsNotExist, err, fs.ErrNotExist); s != "" {
 		return s
@@ -56,13 +64,13 @@ func testErrNotExist(name string) string {
 func TestErrIsNotExist(t *testing.T) {
 	tmpDir := t.TempDir()
 	name := filepath.Join(tmpDir, "NotExists")
-	if s := testErrNotExist(name); s != "" {
+	if s := testErrNotExist(t, name); s != "" {
 		t.Fatal(s)
 		return
 	}
 
 	name = filepath.Join(name, "NotExists2")
-	if s := testErrNotExist(name); s != "" {
+	if s := testErrNotExist(t, name); s != "" {
 		t.Fatal(s)
 		return
 	}
-- 
GitLab


From 49e933fc57c2f858e19c26f4a2e56ba94fc54989 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Fri, 9 Apr 2021 14:40:28 -0400
Subject: [PATCH 1514/2400] cmd/compile: make interface conversion function
 selection ABI insensitive

Before register ABI, we always pass argument in memory, and the
compiler chooses interface conversion functions solely based on
the memory layout. As long as the two types have identical memory
layout, it is fine to mix and match, e.g. convT64 takes a uint64
argument, but it can be used for things like float64 or
struct { x [4]struct{}; y int64 }.

With register ABI, those types may be passed differently, e.g.
uint64 is passed in an integer register, float64 is passed in a
floating point register, the struct above is passed in memory.
I made a few attempts in the previous CLs to try to choose the
right function based on the argument type, but none of them is
really correct.

Instead, this CL changes it to always pass the argument in the
same type the runtime expects, and do conversion before the call
in the compiler. The conversion can be no-op (e.g. a named type
to its underlying type), direct (e.g. int64 to uint64), or
through memory (e.g. *(*uint64)(unsafe.Pointer(&arg))). This way,
the front end does not need to know the ABI. (It only needs to
know how to convert types, and it already does.)

TODO: do something similar for map functions.

Change-Id: I33fc780a47c3f332b765e09b5e527f52ea1d6b5c
Reviewed-on: https://go-review.googlesource.com/c/go/+/309029
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/typecheck/builtin.go | 393 +++++++++---------
 .../internal/typecheck/builtin/runtime.go     |  17 +-
 src/cmd/compile/internal/walk/convert.go      |  90 ++--
 src/cmd/compile/internal/walk/order.go        |   2 +-
 src/runtime/iface.go                          |   8 -
 5 files changed, 247 insertions(+), 263 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/builtin.go b/src/cmd/compile/internal/typecheck/builtin.go
index 225dd682f0..878239d378 100644
--- a/src/cmd/compile/internal/typecheck/builtin.go
+++ b/src/cmd/compile/internal/typecheck/builtin.go
@@ -71,135 +71,133 @@ var runtimeDecls = [...]struct {
 	{"decoderune", funcTag, 55},
 	{"countrunes", funcTag, 56},
 	{"convI2I", funcTag, 57},
-	{"convT16", funcTag, 58},
-	{"convT32", funcTag, 58},
-	{"convT32F", funcTag, 58},
-	{"convT64", funcTag, 58},
-	{"convT64F", funcTag, 58},
-	{"convTstring", funcTag, 58},
-	{"convTslice", funcTag, 58},
-	{"convT2E", funcTag, 59},
-	{"convT2Enoptr", funcTag, 59},
-	{"convT2I", funcTag, 59},
-	{"convT2Inoptr", funcTag, 59},
-	{"assertE2I", funcTag, 60},
+	{"convT16", funcTag, 59},
+	{"convT32", funcTag, 61},
+	{"convT64", funcTag, 62},
+	{"convTstring", funcTag, 63},
+	{"convTslice", funcTag, 66},
+	{"convT2E", funcTag, 67},
+	{"convT2Enoptr", funcTag, 67},
+	{"convT2I", funcTag, 67},
+	{"convT2Inoptr", funcTag, 67},
+	{"assertE2I", funcTag, 68},
 	{"assertE2I2", funcTag, 57},
-	{"assertI2I", funcTag, 60},
+	{"assertI2I", funcTag, 68},
 	{"assertI2I2", funcTag, 57},
-	{"panicdottypeE", funcTag, 61},
-	{"panicdottypeI", funcTag, 61},
-	{"panicnildottype", funcTag, 62},
-	{"ifaceeq", funcTag, 64},
-	{"efaceeq", funcTag, 64},
-	{"fastrand", funcTag, 66},
-	{"makemap64", funcTag, 68},
-	{"makemap", funcTag, 69},
-	{"makemap_small", funcTag, 70},
-	{"mapaccess1", funcTag, 71},
-	{"mapaccess1_fast32", funcTag, 72},
-	{"mapaccess1_fast64", funcTag, 72},
-	{"mapaccess1_faststr", funcTag, 72},
-	{"mapaccess1_fat", funcTag, 73},
-	{"mapaccess2", funcTag, 74},
-	{"mapaccess2_fast32", funcTag, 75},
-	{"mapaccess2_fast64", funcTag, 75},
-	{"mapaccess2_faststr", funcTag, 75},
-	{"mapaccess2_fat", funcTag, 76},
-	{"mapassign", funcTag, 71},
-	{"mapassign_fast32", funcTag, 72},
-	{"mapassign_fast32ptr", funcTag, 72},
-	{"mapassign_fast64", funcTag, 72},
-	{"mapassign_fast64ptr", funcTag, 72},
-	{"mapassign_faststr", funcTag, 72},
-	{"mapiterinit", funcTag, 77},
-	{"mapdelete", funcTag, 77},
-	{"mapdelete_fast32", funcTag, 78},
-	{"mapdelete_fast64", funcTag, 78},
-	{"mapdelete_faststr", funcTag, 78},
-	{"mapiternext", funcTag, 79},
-	{"mapclear", funcTag, 80},
-	{"makechan64", funcTag, 82},
-	{"makechan", funcTag, 83},
-	{"chanrecv1", funcTag, 85},
-	{"chanrecv2", funcTag, 86},
-	{"chansend1", funcTag, 88},
+	{"panicdottypeE", funcTag, 69},
+	{"panicdottypeI", funcTag, 69},
+	{"panicnildottype", funcTag, 70},
+	{"ifaceeq", funcTag, 72},
+	{"efaceeq", funcTag, 72},
+	{"fastrand", funcTag, 73},
+	{"makemap64", funcTag, 75},
+	{"makemap", funcTag, 76},
+	{"makemap_small", funcTag, 77},
+	{"mapaccess1", funcTag, 78},
+	{"mapaccess1_fast32", funcTag, 79},
+	{"mapaccess1_fast64", funcTag, 79},
+	{"mapaccess1_faststr", funcTag, 79},
+	{"mapaccess1_fat", funcTag, 80},
+	{"mapaccess2", funcTag, 81},
+	{"mapaccess2_fast32", funcTag, 82},
+	{"mapaccess2_fast64", funcTag, 82},
+	{"mapaccess2_faststr", funcTag, 82},
+	{"mapaccess2_fat", funcTag, 83},
+	{"mapassign", funcTag, 78},
+	{"mapassign_fast32", funcTag, 79},
+	{"mapassign_fast32ptr", funcTag, 79},
+	{"mapassign_fast64", funcTag, 79},
+	{"mapassign_fast64ptr", funcTag, 79},
+	{"mapassign_faststr", funcTag, 79},
+	{"mapiterinit", funcTag, 84},
+	{"mapdelete", funcTag, 84},
+	{"mapdelete_fast32", funcTag, 85},
+	{"mapdelete_fast64", funcTag, 85},
+	{"mapdelete_faststr", funcTag, 85},
+	{"mapiternext", funcTag, 86},
+	{"mapclear", funcTag, 87},
+	{"makechan64", funcTag, 89},
+	{"makechan", funcTag, 90},
+	{"chanrecv1", funcTag, 92},
+	{"chanrecv2", funcTag, 93},
+	{"chansend1", funcTag, 95},
 	{"closechan", funcTag, 30},
-	{"writeBarrier", varTag, 90},
-	{"typedmemmove", funcTag, 91},
-	{"typedmemclr", funcTag, 92},
-	{"typedslicecopy", funcTag, 93},
-	{"selectnbsend", funcTag, 94},
-	{"selectnbrecv", funcTag, 95},
-	{"selectsetpc", funcTag, 96},
-	{"selectgo", funcTag, 97},
+	{"writeBarrier", varTag, 97},
+	{"typedmemmove", funcTag, 98},
+	{"typedmemclr", funcTag, 99},
+	{"typedslicecopy", funcTag, 100},
+	{"selectnbsend", funcTag, 101},
+	{"selectnbrecv", funcTag, 102},
+	{"selectsetpc", funcTag, 103},
+	{"selectgo", funcTag, 104},
 	{"block", funcTag, 9},
-	{"makeslice", funcTag, 98},
-	{"makeslice64", funcTag, 99},
-	{"makeslicecopy", funcTag, 100},
-	{"growslice", funcTag, 102},
-	{"memmove", funcTag, 103},
-	{"memclrNoHeapPointers", funcTag, 104},
-	{"memclrHasPointers", funcTag, 104},
-	{"memequal", funcTag, 105},
-	{"memequal0", funcTag, 106},
-	{"memequal8", funcTag, 106},
-	{"memequal16", funcTag, 106},
-	{"memequal32", funcTag, 106},
-	{"memequal64", funcTag, 106},
-	{"memequal128", funcTag, 106},
-	{"f32equal", funcTag, 107},
-	{"f64equal", funcTag, 107},
-	{"c64equal", funcTag, 107},
-	{"c128equal", funcTag, 107},
-	{"strequal", funcTag, 107},
-	{"interequal", funcTag, 107},
-	{"nilinterequal", funcTag, 107},
-	{"memhash", funcTag, 108},
-	{"memhash0", funcTag, 109},
-	{"memhash8", funcTag, 109},
-	{"memhash16", funcTag, 109},
-	{"memhash32", funcTag, 109},
-	{"memhash64", funcTag, 109},
-	{"memhash128", funcTag, 109},
-	{"f32hash", funcTag, 109},
-	{"f64hash", funcTag, 109},
-	{"c64hash", funcTag, 109},
-	{"c128hash", funcTag, 109},
-	{"strhash", funcTag, 109},
-	{"interhash", funcTag, 109},
-	{"nilinterhash", funcTag, 109},
-	{"int64div", funcTag, 110},
-	{"uint64div", funcTag, 111},
-	{"int64mod", funcTag, 110},
-	{"uint64mod", funcTag, 111},
-	{"float64toint64", funcTag, 112},
-	{"float64touint64", funcTag, 113},
-	{"float64touint32", funcTag, 114},
-	{"int64tofloat64", funcTag, 115},
-	{"uint64tofloat64", funcTag, 116},
-	{"uint32tofloat64", funcTag, 117},
-	{"complex128div", funcTag, 118},
-	{"getcallerpc", funcTag, 119},
-	{"getcallersp", funcTag, 119},
+	{"makeslice", funcTag, 105},
+	{"makeslice64", funcTag, 106},
+	{"makeslicecopy", funcTag, 107},
+	{"growslice", funcTag, 109},
+	{"memmove", funcTag, 110},
+	{"memclrNoHeapPointers", funcTag, 111},
+	{"memclrHasPointers", funcTag, 111},
+	{"memequal", funcTag, 112},
+	{"memequal0", funcTag, 113},
+	{"memequal8", funcTag, 113},
+	{"memequal16", funcTag, 113},
+	{"memequal32", funcTag, 113},
+	{"memequal64", funcTag, 113},
+	{"memequal128", funcTag, 113},
+	{"f32equal", funcTag, 114},
+	{"f64equal", funcTag, 114},
+	{"c64equal", funcTag, 114},
+	{"c128equal", funcTag, 114},
+	{"strequal", funcTag, 114},
+	{"interequal", funcTag, 114},
+	{"nilinterequal", funcTag, 114},
+	{"memhash", funcTag, 115},
+	{"memhash0", funcTag, 116},
+	{"memhash8", funcTag, 116},
+	{"memhash16", funcTag, 116},
+	{"memhash32", funcTag, 116},
+	{"memhash64", funcTag, 116},
+	{"memhash128", funcTag, 116},
+	{"f32hash", funcTag, 116},
+	{"f64hash", funcTag, 116},
+	{"c64hash", funcTag, 116},
+	{"c128hash", funcTag, 116},
+	{"strhash", funcTag, 116},
+	{"interhash", funcTag, 116},
+	{"nilinterhash", funcTag, 116},
+	{"int64div", funcTag, 117},
+	{"uint64div", funcTag, 118},
+	{"int64mod", funcTag, 117},
+	{"uint64mod", funcTag, 118},
+	{"float64toint64", funcTag, 119},
+	{"float64touint64", funcTag, 120},
+	{"float64touint32", funcTag, 121},
+	{"int64tofloat64", funcTag, 122},
+	{"uint64tofloat64", funcTag, 123},
+	{"uint32tofloat64", funcTag, 124},
+	{"complex128div", funcTag, 125},
+	{"getcallerpc", funcTag, 126},
+	{"getcallersp", funcTag, 126},
 	{"racefuncenter", funcTag, 31},
 	{"racefuncexit", funcTag, 9},
 	{"raceread", funcTag, 31},
 	{"racewrite", funcTag, 31},
-	{"racereadrange", funcTag, 120},
-	{"racewriterange", funcTag, 120},
-	{"msanread", funcTag, 120},
-	{"msanwrite", funcTag, 120},
-	{"msanmove", funcTag, 121},
-	{"checkptrAlignment", funcTag, 122},
-	{"checkptrArithmetic", funcTag, 124},
-	{"libfuzzerTraceCmp1", funcTag, 126},
-	{"libfuzzerTraceCmp2", funcTag, 128},
-	{"libfuzzerTraceCmp4", funcTag, 129},
-	{"libfuzzerTraceCmp8", funcTag, 130},
-	{"libfuzzerTraceConstCmp1", funcTag, 126},
-	{"libfuzzerTraceConstCmp2", funcTag, 128},
-	{"libfuzzerTraceConstCmp4", funcTag, 129},
-	{"libfuzzerTraceConstCmp8", funcTag, 130},
+	{"racereadrange", funcTag, 127},
+	{"racewriterange", funcTag, 127},
+	{"msanread", funcTag, 127},
+	{"msanwrite", funcTag, 127},
+	{"msanmove", funcTag, 128},
+	{"checkptrAlignment", funcTag, 129},
+	{"checkptrArithmetic", funcTag, 131},
+	{"libfuzzerTraceCmp1", funcTag, 132},
+	{"libfuzzerTraceCmp2", funcTag, 133},
+	{"libfuzzerTraceCmp4", funcTag, 134},
+	{"libfuzzerTraceCmp8", funcTag, 135},
+	{"libfuzzerTraceConstCmp1", funcTag, 132},
+	{"libfuzzerTraceConstCmp2", funcTag, 133},
+	{"libfuzzerTraceConstCmp4", funcTag, 134},
+	{"libfuzzerTraceConstCmp8", funcTag, 135},
 	{"x86HasPOPCNT", varTag, 6},
 	{"x86HasSSE41", varTag, 6},
 	{"x86HasFMA", varTag, 6},
@@ -222,7 +220,7 @@ func params(tlist ...*types.Type) []*types.Field {
 }
 
 func runtimeTypes() []*types.Type {
-	var typs [131]*types.Type
+	var typs [136]*types.Type
 	typs[0] = types.ByteType
 	typs[1] = types.NewPtr(typs[0])
 	typs[2] = types.Types[types.TANY]
@@ -281,78 +279,83 @@ func runtimeTypes() []*types.Type {
 	typs[55] = newSig(params(typs[28], typs[15]), params(typs[46], typs[15]))
 	typs[56] = newSig(params(typs[28]), params(typs[15]))
 	typs[57] = newSig(params(typs[1], typs[2]), params(typs[2]))
-	typs[58] = newSig(params(typs[2]), params(typs[7]))
-	typs[59] = newSig(params(typs[1], typs[3]), params(typs[2]))
-	typs[60] = newSig(params(typs[1], typs[1]), params(typs[1]))
-	typs[61] = newSig(params(typs[1], typs[1], typs[1]), nil)
-	typs[62] = newSig(params(typs[1]), nil)
-	typs[63] = types.NewPtr(typs[5])
-	typs[64] = newSig(params(typs[63], typs[7], typs[7]), params(typs[6]))
-	typs[65] = types.Types[types.TUINT32]
-	typs[66] = newSig(nil, params(typs[65]))
-	typs[67] = types.NewMap(typs[2], typs[2])
-	typs[68] = newSig(params(typs[1], typs[22], typs[3]), params(typs[67]))
-	typs[69] = newSig(params(typs[1], typs[15], typs[3]), params(typs[67]))
-	typs[70] = newSig(nil, params(typs[67]))
-	typs[71] = newSig(params(typs[1], typs[67], typs[3]), params(typs[3]))
-	typs[72] = newSig(params(typs[1], typs[67], typs[2]), params(typs[3]))
-	typs[73] = newSig(params(typs[1], typs[67], typs[3], typs[1]), params(typs[3]))
-	typs[74] = newSig(params(typs[1], typs[67], typs[3]), params(typs[3], typs[6]))
-	typs[75] = newSig(params(typs[1], typs[67], typs[2]), params(typs[3], typs[6]))
-	typs[76] = newSig(params(typs[1], typs[67], typs[3], typs[1]), params(typs[3], typs[6]))
-	typs[77] = newSig(params(typs[1], typs[67], typs[3]), nil)
-	typs[78] = newSig(params(typs[1], typs[67], typs[2]), nil)
-	typs[79] = newSig(params(typs[3]), nil)
-	typs[80] = newSig(params(typs[1], typs[67]), nil)
-	typs[81] = types.NewChan(typs[2], types.Cboth)
-	typs[82] = newSig(params(typs[1], typs[22]), params(typs[81]))
-	typs[83] = newSig(params(typs[1], typs[15]), params(typs[81]))
-	typs[84] = types.NewChan(typs[2], types.Crecv)
-	typs[85] = newSig(params(typs[84], typs[3]), nil)
-	typs[86] = newSig(params(typs[84], typs[3]), params(typs[6]))
-	typs[87] = types.NewChan(typs[2], types.Csend)
-	typs[88] = newSig(params(typs[87], typs[3]), nil)
-	typs[89] = types.NewArray(typs[0], 3)
-	typs[90] = types.NewStruct(types.NoPkg, []*types.Field{types.NewField(src.NoXPos, Lookup("enabled"), typs[6]), types.NewField(src.NoXPos, Lookup("pad"), typs[89]), types.NewField(src.NoXPos, Lookup("needed"), typs[6]), types.NewField(src.NoXPos, Lookup("cgo"), typs[6]), types.NewField(src.NoXPos, Lookup("alignme"), typs[24])})
-	typs[91] = newSig(params(typs[1], typs[3], typs[3]), nil)
-	typs[92] = newSig(params(typs[1], typs[3]), nil)
-	typs[93] = newSig(params(typs[1], typs[3], typs[15], typs[3], typs[15]), params(typs[15]))
-	typs[94] = newSig(params(typs[87], typs[3]), params(typs[6]))
-	typs[95] = newSig(params(typs[3], typs[84]), params(typs[6], typs[6]))
-	typs[96] = newSig(params(typs[63]), nil)
-	typs[97] = newSig(params(typs[1], typs[1], typs[63], typs[15], typs[15], typs[6]), params(typs[15], typs[6]))
-	typs[98] = newSig(params(typs[1], typs[15], typs[15]), params(typs[7]))
-	typs[99] = newSig(params(typs[1], typs[22], typs[22]), params(typs[7]))
-	typs[100] = newSig(params(typs[1], typs[15], typs[15], typs[7]), params(typs[7]))
-	typs[101] = types.NewSlice(typs[2])
-	typs[102] = newSig(params(typs[1], typs[101], typs[15]), params(typs[101]))
-	typs[103] = newSig(params(typs[3], typs[3], typs[5]), nil)
-	typs[104] = newSig(params(typs[7], typs[5]), nil)
-	typs[105] = newSig(params(typs[3], typs[3], typs[5]), params(typs[6]))
-	typs[106] = newSig(params(typs[3], typs[3]), params(typs[6]))
-	typs[107] = newSig(params(typs[7], typs[7]), params(typs[6]))
-	typs[108] = newSig(params(typs[7], typs[5], typs[5]), params(typs[5]))
-	typs[109] = newSig(params(typs[7], typs[5]), params(typs[5]))
-	typs[110] = newSig(params(typs[22], typs[22]), params(typs[22]))
-	typs[111] = newSig(params(typs[24], typs[24]), params(typs[24]))
-	typs[112] = newSig(params(typs[20]), params(typs[22]))
-	typs[113] = newSig(params(typs[20]), params(typs[24]))
-	typs[114] = newSig(params(typs[20]), params(typs[65]))
-	typs[115] = newSig(params(typs[22]), params(typs[20]))
-	typs[116] = newSig(params(typs[24]), params(typs[20]))
-	typs[117] = newSig(params(typs[65]), params(typs[20]))
-	typs[118] = newSig(params(typs[26], typs[26]), params(typs[26]))
-	typs[119] = newSig(nil, params(typs[5]))
-	typs[120] = newSig(params(typs[5], typs[5]), nil)
-	typs[121] = newSig(params(typs[5], typs[5], typs[5]), nil)
-	typs[122] = newSig(params(typs[7], typs[1], typs[5]), nil)
-	typs[123] = types.NewSlice(typs[7])
-	typs[124] = newSig(params(typs[7], typs[123]), nil)
-	typs[125] = types.Types[types.TUINT8]
-	typs[126] = newSig(params(typs[125], typs[125]), nil)
-	typs[127] = types.Types[types.TUINT16]
-	typs[128] = newSig(params(typs[127], typs[127]), nil)
-	typs[129] = newSig(params(typs[65], typs[65]), nil)
-	typs[130] = newSig(params(typs[24], typs[24]), nil)
+	typs[58] = types.Types[types.TUINT16]
+	typs[59] = newSig(params(typs[58]), params(typs[7]))
+	typs[60] = types.Types[types.TUINT32]
+	typs[61] = newSig(params(typs[60]), params(typs[7]))
+	typs[62] = newSig(params(typs[24]), params(typs[7]))
+	typs[63] = newSig(params(typs[28]), params(typs[7]))
+	typs[64] = types.Types[types.TUINT8]
+	typs[65] = types.NewSlice(typs[64])
+	typs[66] = newSig(params(typs[65]), params(typs[7]))
+	typs[67] = newSig(params(typs[1], typs[3]), params(typs[2]))
+	typs[68] = newSig(params(typs[1], typs[1]), params(typs[1]))
+	typs[69] = newSig(params(typs[1], typs[1], typs[1]), nil)
+	typs[70] = newSig(params(typs[1]), nil)
+	typs[71] = types.NewPtr(typs[5])
+	typs[72] = newSig(params(typs[71], typs[7], typs[7]), params(typs[6]))
+	typs[73] = newSig(nil, params(typs[60]))
+	typs[74] = types.NewMap(typs[2], typs[2])
+	typs[75] = newSig(params(typs[1], typs[22], typs[3]), params(typs[74]))
+	typs[76] = newSig(params(typs[1], typs[15], typs[3]), params(typs[74]))
+	typs[77] = newSig(nil, params(typs[74]))
+	typs[78] = newSig(params(typs[1], typs[74], typs[3]), params(typs[3]))
+	typs[79] = newSig(params(typs[1], typs[74], typs[2]), params(typs[3]))
+	typs[80] = newSig(params(typs[1], typs[74], typs[3], typs[1]), params(typs[3]))
+	typs[81] = newSig(params(typs[1], typs[74], typs[3]), params(typs[3], typs[6]))
+	typs[82] = newSig(params(typs[1], typs[74], typs[2]), params(typs[3], typs[6]))
+	typs[83] = newSig(params(typs[1], typs[74], typs[3], typs[1]), params(typs[3], typs[6]))
+	typs[84] = newSig(params(typs[1], typs[74], typs[3]), nil)
+	typs[85] = newSig(params(typs[1], typs[74], typs[2]), nil)
+	typs[86] = newSig(params(typs[3]), nil)
+	typs[87] = newSig(params(typs[1], typs[74]), nil)
+	typs[88] = types.NewChan(typs[2], types.Cboth)
+	typs[89] = newSig(params(typs[1], typs[22]), params(typs[88]))
+	typs[90] = newSig(params(typs[1], typs[15]), params(typs[88]))
+	typs[91] = types.NewChan(typs[2], types.Crecv)
+	typs[92] = newSig(params(typs[91], typs[3]), nil)
+	typs[93] = newSig(params(typs[91], typs[3]), params(typs[6]))
+	typs[94] = types.NewChan(typs[2], types.Csend)
+	typs[95] = newSig(params(typs[94], typs[3]), nil)
+	typs[96] = types.NewArray(typs[0], 3)
+	typs[97] = types.NewStruct(types.NoPkg, []*types.Field{types.NewField(src.NoXPos, Lookup("enabled"), typs[6]), types.NewField(src.NoXPos, Lookup("pad"), typs[96]), types.NewField(src.NoXPos, Lookup("needed"), typs[6]), types.NewField(src.NoXPos, Lookup("cgo"), typs[6]), types.NewField(src.NoXPos, Lookup("alignme"), typs[24])})
+	typs[98] = newSig(params(typs[1], typs[3], typs[3]), nil)
+	typs[99] = newSig(params(typs[1], typs[3]), nil)
+	typs[100] = newSig(params(typs[1], typs[3], typs[15], typs[3], typs[15]), params(typs[15]))
+	typs[101] = newSig(params(typs[94], typs[3]), params(typs[6]))
+	typs[102] = newSig(params(typs[3], typs[91]), params(typs[6], typs[6]))
+	typs[103] = newSig(params(typs[71]), nil)
+	typs[104] = newSig(params(typs[1], typs[1], typs[71], typs[15], typs[15], typs[6]), params(typs[15], typs[6]))
+	typs[105] = newSig(params(typs[1], typs[15], typs[15]), params(typs[7]))
+	typs[106] = newSig(params(typs[1], typs[22], typs[22]), params(typs[7]))
+	typs[107] = newSig(params(typs[1], typs[15], typs[15], typs[7]), params(typs[7]))
+	typs[108] = types.NewSlice(typs[2])
+	typs[109] = newSig(params(typs[1], typs[108], typs[15]), params(typs[108]))
+	typs[110] = newSig(params(typs[3], typs[3], typs[5]), nil)
+	typs[111] = newSig(params(typs[7], typs[5]), nil)
+	typs[112] = newSig(params(typs[3], typs[3], typs[5]), params(typs[6]))
+	typs[113] = newSig(params(typs[3], typs[3]), params(typs[6]))
+	typs[114] = newSig(params(typs[7], typs[7]), params(typs[6]))
+	typs[115] = newSig(params(typs[7], typs[5], typs[5]), params(typs[5]))
+	typs[116] = newSig(params(typs[7], typs[5]), params(typs[5]))
+	typs[117] = newSig(params(typs[22], typs[22]), params(typs[22]))
+	typs[118] = newSig(params(typs[24], typs[24]), params(typs[24]))
+	typs[119] = newSig(params(typs[20]), params(typs[22]))
+	typs[120] = newSig(params(typs[20]), params(typs[24]))
+	typs[121] = newSig(params(typs[20]), params(typs[60]))
+	typs[122] = newSig(params(typs[22]), params(typs[20]))
+	typs[123] = newSig(params(typs[24]), params(typs[20]))
+	typs[124] = newSig(params(typs[60]), params(typs[20]))
+	typs[125] = newSig(params(typs[26], typs[26]), params(typs[26]))
+	typs[126] = newSig(nil, params(typs[5]))
+	typs[127] = newSig(params(typs[5], typs[5]), nil)
+	typs[128] = newSig(params(typs[5], typs[5], typs[5]), nil)
+	typs[129] = newSig(params(typs[7], typs[1], typs[5]), nil)
+	typs[130] = types.NewSlice(typs[7])
+	typs[131] = newSig(params(typs[7], typs[130]), nil)
+	typs[132] = newSig(params(typs[64], typs[64]), nil)
+	typs[133] = newSig(params(typs[58], typs[58]), nil)
+	typs[134] = newSig(params(typs[60], typs[60]), nil)
+	typs[135] = newSig(params(typs[24], typs[24]), nil)
 	return typs[:]
 }
diff --git a/src/cmd/compile/internal/typecheck/builtin/runtime.go b/src/cmd/compile/internal/typecheck/builtin/runtime.go
index 7c9599b54e..b7fb2e6044 100644
--- a/src/cmd/compile/internal/typecheck/builtin/runtime.go
+++ b/src/cmd/compile/internal/typecheck/builtin/runtime.go
@@ -87,13 +87,16 @@ func convI2I(typ *byte, elem any) (ret any)
 
 // Specialized type-to-interface conversion.
 // These return only a data pointer.
-func convT16(val any) unsafe.Pointer     // val must be uint16-like (same size and alignment as a uint16)
-func convT32(val any) unsafe.Pointer     // val must be uint32-like (same size and alignment as a uint32)
-func convT32F(val any) unsafe.Pointer    // val must be float32-like
-func convT64(val any) unsafe.Pointer     // val must be uint64-like (same size and alignment as a uint64 and contains no pointers)
-func convT64F(val any) unsafe.Pointer    // val must be float64-like
-func convTstring(val any) unsafe.Pointer // val must be a string
-func convTslice(val any) unsafe.Pointer  // val must be a slice
+// These functions take concrete types in the runtime. But they may
+// be used for a wider range of types, which have the same memory
+// layout as the parameter type. The compiler converts the
+// to-be-converted type to the parameter type before calling the
+// runtime function. This way, the call is ABI-insensitive.
+func convT16(val uint16) unsafe.Pointer
+func convT32(val uint32) unsafe.Pointer
+func convT64(val uint64) unsafe.Pointer
+func convTstring(val string) unsafe.Pointer
+func convTslice(val []uint8) unsafe.Pointer
 
 // Type to empty-interface conversion.
 func convT2E(typ *byte, elem *any) (ret any)
diff --git a/src/cmd/compile/internal/walk/convert.go b/src/cmd/compile/internal/walk/convert.go
index dfdd9540e7..26e17a126f 100644
--- a/src/cmd/compile/internal/walk/convert.go
+++ b/src/cmd/compile/internal/walk/convert.go
@@ -14,7 +14,6 @@ import (
 	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
-	"cmd/internal/objabi"
 	"cmd/internal/sys"
 )
 
@@ -136,7 +135,7 @@ func walkConvInterface(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 		return e
 	}
 
-	fnname, needsaddr := convFuncName(fromType, toType)
+	fnname, argType, needsaddr := convFuncName(fromType, toType)
 
 	if !needsaddr && !fromType.IsInterface() {
 		// Use a specialized conversion routine that only returns a data pointer.
@@ -144,10 +143,29 @@ func walkConvInterface(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 		// e = iface{typ/tab, ptr}
 		fn := typecheck.LookupRuntime(fnname)
 		types.CalcSize(fromType)
-		fn = typecheck.SubstArgTypes(fn, fromType)
-		types.CalcSize(fn.Type())
+
+		arg := n.X
+		switch {
+		case fromType == argType:
+			// already in the right type, nothing to do
+		case fromType.Kind() == argType.Kind(),
+			fromType.IsPtrShaped() && argType.IsPtrShaped():
+			// can directly convert (e.g. named type to underlying type, or one pointer to another)
+			arg = ir.NewConvExpr(n.Pos(), ir.OCONVNOP, argType, arg)
+		case fromType.IsInteger() && argType.IsInteger():
+			// can directly convert (e.g. int32 to uint32)
+			arg = ir.NewConvExpr(n.Pos(), ir.OCONV, argType, arg)
+		default:
+			// unsafe cast through memory
+			arg = copyExpr(arg, arg.Type(), init)
+			var addr ir.Node = typecheck.NodAddr(arg)
+			addr = ir.NewConvExpr(n.Pos(), ir.OCONVNOP, argType.PtrTo(), addr)
+			arg = ir.NewStarExpr(n.Pos(), addr)
+			arg.SetType(argType)
+		}
+
 		call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
-		call.Args = []ir.Node{n.X}
+		call.Args = []ir.Node{arg}
 		e := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), safeExpr(walkExpr(typecheck.Expr(call), init), init))
 		e.SetType(toType)
 		e.SetTypecheck(1)
@@ -295,77 +313,45 @@ func walkStringToRunes(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 }
 
 // convFuncName builds the runtime function name for interface conversion.
-// It also reports whether the function expects the data by address.
+// It also returns the argument type that the runtime function takes, and
+// whether the function expects the data by address.
 // Not all names are possible. For example, we never generate convE2E or convE2I.
-func convFuncName(from, to *types.Type) (fnname string, needsaddr bool) {
-	// With register-based ABI, float32 and uint32 are passed in different
-	// registers, so we cannot use convT32 for float32.
-	// isFloatLike returns whether t is a float-like type (float32, float64,
-	// single-element array/struct with a float-like element), for which
-	// the argument is passed in a floating point register under register-
-	// based ABI.
-	var isFloatLike func(t *types.Type) bool
-	isFloatLike = func(t *types.Type) bool {
-		switch t.Kind() {
-		case types.TFLOAT32, types.TFLOAT64:
-			return true
-		case types.TARRAY:
-			return t.NumElem() == 1 && isFloatLike(t.Elem())
-		case types.TSTRUCT:
-			fsl := t.FieldSlice()
-			for idx, f := range fsl {
-				if f.Type.Width == 0 {
-					continue
-				}
-				if isFloatLike(f.Type) && idx == len(fsl)-1 {
-					return true
-				}
-				return false
-			}
-			return false
-		}
-		return false
-	}
-
+func convFuncName(from, to *types.Type) (fnname string, argType *types.Type, needsaddr bool) {
 	tkind := to.Tie()
 	switch from.Tie() {
 	case 'I':
 		if tkind == 'I' {
-			return "convI2I", false
+			return "convI2I", types.Types[types.TINTER], false
 		}
 	case 'T':
 		switch {
 		case from.Size() == 2 && from.Align == 2:
-			return "convT16", false
-		case from.Size() == 4 && isFloatLike(from):
-			return "convT32F", false
-		case from.Size() == 4 && from.Align == 4 && !from.HasPointers() && (!objabi.Experiment.RegabiArgs || from.NumComponents(types.CountBlankFields) == 1):
-			return "convT32", false
-		case from.Size() == 8 && isFloatLike(from):
-			return "convT64F", false
-		case from.Size() == 8 && from.Align == types.Types[types.TUINT64].Align && !from.HasPointers() && (!objabi.Experiment.RegabiArgs || from.NumComponents(types.CountBlankFields) == 1):
-			return "convT64", false
+			return "convT16", types.Types[types.TUINT16], false
+		case from.Size() == 4 && from.Align == 4 && !from.HasPointers():
+			return "convT32", types.Types[types.TUINT32], false
+		case from.Size() == 8 && from.Align == types.Types[types.TUINT64].Align && !from.HasPointers():
+			return "convT64", types.Types[types.TUINT64], false
 		}
 		if sc := from.SoleComponent(); sc != nil {
 			switch {
 			case sc.IsString():
-				return "convTstring", false
+				return "convTstring", types.Types[types.TSTRING], false
 			case sc.IsSlice():
-				return "convTslice", false
+				return "convTslice", types.NewSlice(types.Types[types.TUINT8]), false // the element type doesn't matter
 			}
 		}
 
 		switch tkind {
 		case 'E':
 			if !from.HasPointers() {
-				return "convT2Enoptr", true
+				return "convT2Enoptr", types.Types[types.TUNSAFEPTR], true
 			}
-			return "convT2E", true
+			return "convT2E", types.Types[types.TUNSAFEPTR], true
 		case 'I':
 			if !from.HasPointers() {
-				return "convT2Inoptr", true
+				return "convT2Inoptr", types.Types[types.TUNSAFEPTR], true
 			}
-			return "convT2I", true
+			return "convT2I", types.Types[types.TUNSAFEPTR], true
 		}
 	}
 	base.Fatalf("unknown conv func %c2%c", from.Tie(), to.Tie())
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index bee3dc3e07..a9e0e5efe8 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -1147,7 +1147,7 @@ func (o *orderState) expr1(n, lhs ir.Node) ir.Node {
 		if n.X.Type().IsInterface() {
 			return n
 		}
-		if _, needsaddr := convFuncName(n.X.Type(), n.Type()); needsaddr || isStaticCompositeLiteral(n.X) {
+		if _, _, needsaddr := convFuncName(n.X.Type(), n.Type()); needsaddr || isStaticCompositeLiteral(n.X) {
 			// Need a temp if we need to pass the address to the conversion function.
 			// We also process static composite literal node here, making a named static global
 			// whose address we can put directly in an interface (see OCONVIFACE case in walk).
diff --git a/src/runtime/iface.go b/src/runtime/iface.go
index f5ac627d39..cd5fead999 100644
--- a/src/runtime/iface.go
+++ b/src/runtime/iface.go
@@ -357,10 +357,6 @@ func convT32(val uint32) (x unsafe.Pointer) {
 	return
 }
 
-func convT32F(val float32) (x unsafe.Pointer) {
-	return convT32(*(*uint32)(unsafe.Pointer(&val)))
-}
-
 func convT64(val uint64) (x unsafe.Pointer) {
 	if val < uint64(len(staticuint64s)) {
 		x = unsafe.Pointer(&staticuint64s[val])
@@ -371,10 +367,6 @@ func convT64(val uint64) (x unsafe.Pointer) {
 	return
 }
 
-func convT64F(val float64) (x unsafe.Pointer) {
-	return convT64(*(*uint64)(unsafe.Pointer(&val)))
-}
-
 func convTstring(val string) (x unsafe.Pointer) {
 	if val == "" {
 		x = unsafe.Pointer(&zeroVal[0])
-- 
GitLab


From d948b8633d4ae3d4501d0a5382b24431a96c0cba Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Mon, 12 Apr 2021 14:50:57 -0400
Subject: [PATCH 1515/2400] cmd/go: fix 'go help mod edit' JSON documentation

The object representing a module directive may have a "Deprecated"
field but not a "Version" field. Other objects representing module
versions have "Path" and "Version" fields but not "Deprecated".

For #40357

Change-Id: Iad8063dfa6f7ceea22981a8a8f99e65fa3b7ffa0
Reviewed-on: https://go-review.googlesource.com/c/go/+/309337
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go/alldocs.go              | 11 ++++++++---
 src/cmd/go/internal/modcmd/edit.go | 11 ++++++++---
 2 files changed, 16 insertions(+), 6 deletions(-)

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index a713428bc2..66e78bb1ac 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -1134,12 +1134,12 @@
 // writing it back to go.mod. The JSON output corresponds to these Go types:
 //
 // 	type Module struct {
-// 		Path string
-// 		Deprecated string
+// 		Path    string
+// 		Version string
 // 	}
 //
 // 	type GoMod struct {
-// 		Module  Module
+// 		Module  ModPath
 // 		Go      string
 // 		Require []Require
 // 		Exclude []Module
@@ -1147,6 +1147,11 @@
 // 		Retract []Retract
 // 	}
 //
+// 	type ModPath struct {
+// 		Path       string
+// 		Deprecated string
+// 	}
+//
 // 	type Require struct {
 // 		Path string
 // 		Version string
diff --git a/src/cmd/go/internal/modcmd/edit.go b/src/cmd/go/internal/modcmd/edit.go
index e1ec088f55..79a93ca44b 100644
--- a/src/cmd/go/internal/modcmd/edit.go
+++ b/src/cmd/go/internal/modcmd/edit.go
@@ -85,12 +85,12 @@ The -json flag prints the final go.mod file in JSON format instead of
 writing it back to go.mod. The JSON output corresponds to these Go types:
 
 	type Module struct {
-		Path string
-		Deprecated string
+		Path    string
+		Version string
 	}
 
 	type GoMod struct {
-		Module  Module
+		Module  ModPath
 		Go      string
 		Require []Require
 		Exclude []Module
@@ -98,6 +98,11 @@ writing it back to go.mod. The JSON output corresponds to these Go types:
 		Retract []Retract
 	}
 
+	type ModPath struct {
+		Path       string
+		Deprecated string
+	}
+
 	type Require struct {
 		Path string
 		Version string
-- 
GitLab


From 3e5bba0a44b880541fb72220a883e259d0f34a83 Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Mon, 15 Mar 2021 15:21:57 -0500
Subject: [PATCH 1516/2400] cmd/link: support 32b TLS_LE offsets on PPC64

When using the GCC thread sanitizer, it links in additional
code which uses TLS, which causes us to exceed the range of
the 16 bit TLS relocation used by statically compiled go
code.

Rewrite objabi.R_POWER_TLS_LE to handle 32b offsets when
linking internally or externally into an ELF binary. The
elf relocation translation is changed to generate a pair
of R_PPC64_TPREL16_HA/LO relocations instead of a single
R_PPC64_TPREL16.

Likewise, updating the above exposed some behavioral differences
in gnu ld which can rewrite TLS sequences. It expects the
sequence to generate a valid TLS address, not offset. This was
exposed when compiling PIC code. The proper fix is to generate
the full TLS address in the destination register of the
"MOVD tlsaddr, $Rx" pseudo-op. This removes the need to insert
special objabi.R_POWER_TLS relocations elsewhere.

Unfortunately, XCOFF (used by aix) doesn't appear to support 32
bit offsets, so we rewrite this back into a 16b relocation when
externally linking a static binary.

Fixes #45040

Change-Id: I1ee9afd0b427cd79888032aa1f60d3e265073e1d
Reviewed-on: https://go-review.googlesource.com/c/go/+/302209
Run-TryBot: Paul Murphy <murp@ibm.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/internal/obj/ppc64/asm9.go   | 34 +++++++-------------
 src/cmd/internal/objabi/reloctype.go | 14 ++++----
 src/cmd/link/internal/ppc64/asm.go   | 48 ++++++++++++++++++++++++----
 src/runtime/race_ppc64le.s           | 28 ++++++++--------
 src/runtime/tls_ppc64x.s             |  4 +--
 5 files changed, 76 insertions(+), 52 deletions(-)

diff --git a/src/cmd/internal/obj/ppc64/asm9.go b/src/cmd/internal/obj/ppc64/asm9.go
index ea76543963..0243dd4744 100644
--- a/src/cmd/internal/obj/ppc64/asm9.go
+++ b/src/cmd/internal/obj/ppc64/asm9.go
@@ -229,8 +229,8 @@ var optab = []Optab{
 	{as: AMOVD, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
 	{as: AMOVD, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
 	{as: AMOVD, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
-	{as: AMOVD, a1: C_TLS_LE, a6: C_REG, type_: 79, size: 4},
-	{as: AMOVD, a1: C_TLS_IE, a6: C_REG, type_: 80, size: 8},
+	{as: AMOVD, a1: C_TLS_LE, a6: C_REG, type_: 79, size: 8},
+	{as: AMOVD, a1: C_TLS_IE, a6: C_REG, type_: 80, size: 12},
 	{as: AMOVD, a1: C_TOCADDR, a6: C_REG, type_: 95, size: 8},
 	{as: AMOVD, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
 	{as: AMOVD, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
@@ -2500,18 +2500,6 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 			if v != 0 {
 				c.ctxt.Diag("illegal indexed instruction\n%v", p)
 			}
-			if c.ctxt.Flag_shared && r == REG_R13 {
-				rel := obj.Addrel(c.cursym)
-				rel.Off = int32(c.pc)
-				rel.Siz = 4
-				// This (and the matching part in the load case
-				// below) are the only places in the ppc64 toolchain
-				// that knows the name of the tls variable. Possibly
-				// we could add some assembly syntax so that the name
-				// of the variable does not have to be assumed.
-				rel.Sym = c.ctxt.Lookup("runtime.tls_g")
-				rel.Type = objabi.R_POWER_TLS
-			}
 			o1 = AOP_RRR(c.opstorex(p.As), uint32(p.From.Reg), uint32(p.To.Index), uint32(r))
 		} else {
 			if int32(int16(v)) != v {
@@ -2536,13 +2524,6 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 			if v != 0 {
 				c.ctxt.Diag("illegal indexed instruction\n%v", p)
 			}
-			if c.ctxt.Flag_shared && r == REG_R13 {
-				rel := obj.Addrel(c.cursym)
-				rel.Off = int32(c.pc)
-				rel.Siz = 4
-				rel.Sym = c.ctxt.Lookup("runtime.tls_g")
-				rel.Type = objabi.R_POWER_TLS
-			}
 			o1 = AOP_RRR(c.oploadx(p.As), uint32(p.To.Reg), uint32(p.From.Index), uint32(r))
 		} else {
 			if int32(int16(v)) != v {
@@ -3511,10 +3492,11 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		if p.From.Offset != 0 {
 			c.ctxt.Diag("invalid offset against tls var %v", p)
 		}
-		o1 = AOP_IRR(OP_ADDI, uint32(p.To.Reg), REGZERO, 0)
+		o1 = AOP_IRR(OP_ADDIS, uint32(p.To.Reg), REG_R13, 0)
+		o2 = AOP_IRR(OP_ADDI, uint32(p.To.Reg), uint32(p.To.Reg), 0)
 		rel := obj.Addrel(c.cursym)
 		rel.Off = int32(c.pc)
-		rel.Siz = 4
+		rel.Siz = 8
 		rel.Sym = p.From.Sym
 		rel.Type = objabi.R_POWER_TLS_LE
 
@@ -3524,11 +3506,17 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		}
 		o1 = AOP_IRR(OP_ADDIS, uint32(p.To.Reg), REG_R2, 0)
 		o2 = AOP_IRR(c.opload(AMOVD), uint32(p.To.Reg), uint32(p.To.Reg), 0)
+		o3 = AOP_RRR(OP_ADD, uint32(p.To.Reg), uint32(p.To.Reg), REG_R13)
 		rel := obj.Addrel(c.cursym)
 		rel.Off = int32(c.pc)
 		rel.Siz = 8
 		rel.Sym = p.From.Sym
 		rel.Type = objabi.R_POWER_TLS_IE
+		rel = obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc) + 8
+		rel.Siz = 4
+		rel.Sym = p.From.Sym
+		rel.Type = objabi.R_POWER_TLS
 
 	case 81:
 		v := c.vregoff(&p.To)
diff --git a/src/cmd/internal/objabi/reloctype.go b/src/cmd/internal/objabi/reloctype.go
index b241127b4e..ea55fa3b0a 100644
--- a/src/cmd/internal/objabi/reloctype.go
+++ b/src/cmd/internal/objabi/reloctype.go
@@ -167,8 +167,8 @@ const (
 
 	// R_POWER_TLS_LE is used to implement the "local exec" model for tls
 	// access. It resolves to the offset of the thread-local symbol from the
-	// thread pointer (R13) and inserts this value into the low 16 bits of an
-	// instruction word.
+	// thread pointer (R13) and is split against a pair of instructions to
+	// support a 32 bit displacement.
 	R_POWER_TLS_LE
 
 	// R_POWER_TLS_IE is used to implement the "initial exec" model for tls access. It
@@ -178,10 +178,12 @@ const (
 	// symbol from the thread pointer (R13)).
 	R_POWER_TLS_IE
 
-	// R_POWER_TLS marks an X-form instruction such as "MOVD 0(R13)(R31*1), g" as
-	// accessing a particular thread-local symbol. It does not affect code generation
-	// but is used by the system linker when relaxing "initial exec" model code to
-	// "local exec" model code.
+	// R_POWER_TLS marks an X-form instruction such as "ADD R3,R13,R4" as completing
+	// a sequence of GOT-relative relocations to compute a TLS address. This can be
+	// used by the system linker to to rewrite the GOT-relative TLS relocation into a
+	// simpler thread-pointer relative relocation. See table 3.26 and 3.28 in the
+	// ppc64 elfv2 1.4 ABI on this transformation.  Likewise, the second argument
+	// (usually called RB in X-form instructions) is assumed to be R13.
 	R_POWER_TLS
 
 	// R_ADDRPOWER_DS is similar to R_ADDRPOWER above, but assumes the second
diff --git a/src/cmd/link/internal/ppc64/asm.go b/src/cmd/link/internal/ppc64/asm.go
index e8e258a1f3..06385026d9 100644
--- a/src/cmd/link/internal/ppc64/asm.go
+++ b/src/cmd/link/internal/ppc64/asm.go
@@ -418,6 +418,7 @@ func xcoffreloc1(arch *sys.Arch, out *ld.OutBuf, ldr *loader.Loader, s loader.Sy
 		emitReloc(ld.XCOFF_R_TOCU|(0x0F<<8), 2)
 		emitReloc(ld.XCOFF_R_TOCL|(0x0F<<8), 6)
 	case objabi.R_POWER_TLS_LE:
+		// This only supports 16b relocations.  It is fixed up in archreloc.
 		emitReloc(ld.XCOFF_R_TLS_LE|0x0F<<8, 2)
 	case objabi.R_CALLPOWER:
 		if r.Size != 4 {
@@ -458,7 +459,10 @@ func elfreloc1(ctxt *ld.Link, out *ld.OutBuf, ldr *loader.Loader, s loader.Sym,
 	case objabi.R_POWER_TLS:
 		out.Write64(uint64(elf.R_PPC64_TLS) | uint64(elfsym)<<32)
 	case objabi.R_POWER_TLS_LE:
-		out.Write64(uint64(elf.R_PPC64_TPREL16) | uint64(elfsym)<<32)
+		out.Write64(uint64(elf.R_PPC64_TPREL16_HA) | uint64(elfsym)<<32)
+		out.Write64(uint64(r.Xadd))
+		out.Write64(uint64(sectoff + 4))
+		out.Write64(uint64(elf.R_PPC64_TPREL16_LO) | uint64(elfsym)<<32)
 	case objabi.R_POWER_TLS_IE:
 		out.Write64(uint64(elf.R_PPC64_GOT_TPREL16_HA) | uint64(elfsym)<<32)
 		out.Write64(uint64(r.Xadd))
@@ -797,11 +801,25 @@ func archreloc(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, r loade
 			if !target.IsAIX() {
 				return val, nExtReloc, false
 			}
-		case objabi.R_POWER_TLS, objabi.R_POWER_TLS_LE, objabi.R_POWER_TLS_IE:
-			// check Outer is nil, Type is TLSBSS?
+		case objabi.R_POWER_TLS:
 			nExtReloc = 1
-			if rt == objabi.R_POWER_TLS_IE {
-				nExtReloc = 2 // need two ELF relocations, see elfreloc1
+			return val, nExtReloc, true
+		case objabi.R_POWER_TLS_LE, objabi.R_POWER_TLS_IE:
+			if target.IsAIX() && rt == objabi.R_POWER_TLS_LE {
+				// Fixup val, an addis/addi pair of instructions, which generate a 32b displacement
+				// from the threadpointer (R13), into a 16b relocation. XCOFF only supports 16b
+				// TLS LE relocations. Likewise, verify this is an addis/addi sequence.
+				const expectedOpcodes = 0x3C00000038000000
+				const expectedOpmasks = 0xFC000000FC000000
+				if uint64(val)&expectedOpmasks != expectedOpcodes {
+					ldr.Errorf(s, "relocation for %s+%d is not an addis/addi pair: %16x", ldr.SymName(rs), r.Off(), uint64(val))
+				}
+				nval := (int64(uint32(0x380d0000)) | val&0x03e00000) << 32 // addi rX, r13, $0
+				nval |= int64(0x60000000)                                  // nop
+				val = nval
+				nExtReloc = 1
+			} else {
+				nExtReloc = 2
 			}
 			return val, nExtReloc, true
 		case objabi.R_ADDRPOWER,
@@ -855,10 +873,26 @@ func archreloc(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, r loade
 			// the TLS.
 			v -= 0x800
 		}
-		if int64(int16(v)) != v {
+
+		var o1, o2 uint32
+		if int64(int32(v)) != v {
 			ldr.Errorf(s, "TLS offset out of range %d", v)
 		}
-		return (val &^ 0xffff) | (v & 0xffff), nExtReloc, true
+		if target.IsBigEndian() {
+			o1 = uint32(val >> 32)
+			o2 = uint32(val)
+		} else {
+			o1 = uint32(val)
+			o2 = uint32(val >> 32)
+		}
+
+		o1 |= uint32(((v + 0x8000) >> 16) & 0xFFFF)
+		o2 |= uint32(v & 0xFFFF)
+
+		if target.IsBigEndian() {
+			return int64(o1)<<32 | int64(o2), nExtReloc, true
+		}
+		return int64(o2)<<32 | int64(o1), nExtReloc, true
 	}
 
 	return val, nExtReloc, false
diff --git a/src/runtime/race_ppc64le.s b/src/runtime/race_ppc64le.s
index b09f37031c..069e4d86dd 100644
--- a/src/runtime/race_ppc64le.s
+++ b/src/runtime/race_ppc64le.s
@@ -36,9 +36,9 @@
 // racecalladdr.
 //
 // The sequence used to get the race ctx:
-//    MOVD    runtime·tls_g(SB), R10	// offset to TLS
-//    MOVD    0(R13)(R10*1), g		// R13=TLS for this thread, g = R30
-//    MOVD    g_racectx(g), R3		// racectx == ThreadState
+//    MOVD    runtime·tls_g(SB), R10 // Address of TLS variable
+//    MOVD    0(R10), g              // g = R30
+//    MOVD    g_racectx(g), R3       // racectx == ThreadState
 
 // func runtime·RaceRead(addr uintptr)
 // Called from instrumented Go code
@@ -137,7 +137,7 @@ TEXT	runtime·racewriterangepc1(SB), NOSPLIT, $0-24
 // Otherwise, setup goroutine context and invoke racecall. Other arguments already set.
 TEXT	racecalladdr<>(SB), NOSPLIT, $0-0
 	MOVD    runtime·tls_g(SB), R10
-	MOVD	0(R13)(R10*1), g
+	MOVD	0(R10), g
 	MOVD	g_racectx(g), R3	// goroutine context
 	// Check that addr is within [arenastart, arenaend) or within [racedatastart, racedataend).
 	MOVD	runtime·racearenastart(SB), R9
@@ -173,7 +173,7 @@ TEXT	runtime·racefuncenter(SB), NOSPLIT, $0-8
 // R11 = caller's return address
 TEXT	racefuncenter<>(SB), NOSPLIT, $0-0
 	MOVD    runtime·tls_g(SB), R10
-	MOVD    0(R13)(R10*1), g
+	MOVD    0(R10), g
 	MOVD    g_racectx(g), R3        // goroutine racectx aka *ThreadState
 	MOVD	R8, R4			// caller pc set by caller in R8
 	// void __tsan_func_enter(ThreadState *thr, void *pc);
@@ -185,7 +185,7 @@ TEXT	racefuncenter<>(SB), NOSPLIT, $0-0
 // Called from Go instrumented code.
 TEXT	runtime·racefuncexit(SB), NOSPLIT, $0-0
 	MOVD    runtime·tls_g(SB), R10
-	MOVD    0(R13)(R10*1), g
+	MOVD    0(R10), g
 	MOVD    g_racectx(g), R3        // goroutine racectx aka *ThreadState
 	// void __tsan_func_exit(ThreadState *thr);
 	MOVD	$__tsan_func_exit(SB), R8
@@ -380,7 +380,7 @@ racecallatomic_data:
 racecallatomic_ok:
 	// Addr is within the good range, call the atomic function.
 	MOVD    runtime·tls_g(SB), R10
-	MOVD    0(R13)(R10*1), g
+	MOVD    0(R10), g
 	MOVD    g_racectx(g), R3        // goroutine racectx aka *ThreadState
 	MOVD	R8, R5			// pc is the function called
 	MOVD	(R1), R4		// caller pc from stack
@@ -394,7 +394,7 @@ racecallatomic_ignore:
 	MOVD	R6, R17 // save the original arg list addr
 	MOVD	$__tsan_go_ignore_sync_begin(SB), R8 // func addr to call
 	MOVD    runtime·tls_g(SB), R10
-	MOVD    0(R13)(R10*1), g
+	MOVD    0(R10), g
 	MOVD    g_racectx(g), R3        // goroutine context
 	BL	racecall<>(SB)
 	MOVD	R15, R8	// restore the original function
@@ -402,7 +402,7 @@ racecallatomic_ignore:
 	// Call the atomic function.
 	// racecall will call LLVM race code which might clobber r30 (g)
 	MOVD	runtime·tls_g(SB), R10
-	MOVD	0(R13)(R10*1), g
+	MOVD	0(R10), g
 
 	MOVD	g_racectx(g), R3
 	MOVD	R8, R4		// pc being called same TODO as above
@@ -434,7 +434,7 @@ TEXT	racecall<>(SB), NOSPLIT, $0-0
 	MOVD	R10, 16(R1)	// C ABI
 	// Get info from the current goroutine
 	MOVD    runtime·tls_g(SB), R10	// g offset in TLS
-	MOVD    0(R13)(R10*1), g	// R13 = current TLS
+	MOVD    0(R10), g
 	MOVD	g_m(g), R7		// m for g
 	MOVD	R1, R16			// callee-saved, preserved across C call
 	MOVD	m_g0(R7), R10		// g0 for m
@@ -448,7 +448,7 @@ call:
 	XOR     R0, R0			// clear R0 on return from Clang
 	MOVD	R16, R1			// restore R1; R16 nonvol in Clang
 	MOVD    runtime·tls_g(SB), R10	// find correct g
-	MOVD    0(R13)(R10*1), g
+	MOVD    0(R10), g
 	MOVD	16(R1), R10		// LR was saved away, restore for return
 	MOVD	R10, LR
 	RET
@@ -469,7 +469,7 @@ TEXT	runtime·racecallbackthunk(SB), NOSPLIT, $-8
 	// g0 TODO: Don't modify g here since R30 is nonvolatile
 	MOVD	g, R9
 	MOVD    runtime·tls_g(SB), R10
-	MOVD    0(R13)(R10*1), g
+	MOVD    0(R10), g
 	MOVD	g_m(g), R3
 	MOVD	m_p(R3), R3
 	MOVD	p_raceprocctx(R3), R3
@@ -527,7 +527,7 @@ rest:
 	MOVD	R4, FIXED_FRAME+8(R1)
 
 	MOVD    runtime·tls_g(SB), R10
-	MOVD    0(R13)(R10*1), g
+	MOVD    0(R10), g
 
 	MOVD	g_m(g), R7
 	MOVD	m_g0(R7), R8
@@ -540,7 +540,7 @@ rest:
 
 	// All registers are clobbered after Go code, reload.
 	MOVD    runtime·tls_g(SB), R10
-	MOVD    0(R13)(R10*1), g
+	MOVD    0(R10), g
 
 	MOVD	g_m(g), R7
 	MOVD	m_curg(R7), g // restore g = m->curg
diff --git a/src/runtime/tls_ppc64x.s b/src/runtime/tls_ppc64x.s
index c697449282..25d796fcc6 100644
--- a/src/runtime/tls_ppc64x.s
+++ b/src/runtime/tls_ppc64x.s
@@ -29,7 +29,7 @@ TEXT runtime·save_g(SB),NOSPLIT|NOFRAME,$0-0
 	BEQ	nocgo
 #endif
 	MOVD	runtime·tls_g(SB), R31
-	MOVD	g, 0(R13)(R31*1)
+	MOVD	g, 0(R31)
 
 nocgo:
 	RET
@@ -45,7 +45,7 @@ nocgo:
 // NOTE: _cgo_topofstack assumes this only clobbers g (R30), and R31.
 TEXT runtime·load_g(SB),NOSPLIT|NOFRAME,$0-0
 	MOVD	runtime·tls_g(SB), R31
-	MOVD	0(R13)(R31*1), g
+	MOVD	0(R31), g
 	RET
 
 GLOBL runtime·tls_g+0(SB), TLSBSS+DUPOK, $8
-- 
GitLab


From 13a4e8c41cd1d242a435d44e7f66f370e5306a8c Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Mon, 12 Apr 2021 19:05:01 -0700
Subject: [PATCH 1517/2400] all: simplify the spelling of Linux

The prefix didn't help clarify anything.

Change-Id: I897fd4022ce9df42a548b15714e4b592618ca547
Reviewed-on: https://go-review.googlesource.com/c/go/+/309573
Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
---
 misc/cgo/test/setgid_linux.go          | 2 +-
 misc/cgo/testcarchive/carchive_test.go | 2 +-
 src/debug/elf/elf.go                   | 4 ++--
 src/os/file_unix.go                    | 2 +-
 src/os/signal/doc.go                   | 4 ++--
 src/os/wait_waitid.go                  | 2 +-
 src/runtime/cgo/gcc_sigaction.c        | 2 +-
 src/runtime/os_linux_be64.go           | 2 +-
 8 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/misc/cgo/test/setgid_linux.go b/misc/cgo/test/setgid_linux.go
index 6773f94d3d..7c64946cb3 100644
--- a/misc/cgo/test/setgid_linux.go
+++ b/misc/cgo/test/setgid_linux.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Test that setgid does not hang on GNU/Linux.
+// Test that setgid does not hang on Linux.
 // See https://golang.org/issue/3871 for details.
 
 package cgotest
diff --git a/misc/cgo/testcarchive/carchive_test.go b/misc/cgo/testcarchive/carchive_test.go
index ec717c4f8b..55be3c5f70 100644
--- a/misc/cgo/testcarchive/carchive_test.go
+++ b/misc/cgo/testcarchive/carchive_test.go
@@ -775,7 +775,7 @@ func TestSIGPROF(t *testing.T) {
 // tool with -buildmode=c-archive, it passes -shared to the compiler,
 // so we override that. The go tool doesn't work this way, but Bazel
 // will likely do it in the future. And it ought to work. This test
-// was added because at one time it did not work on PPC GNU/Linux.
+// was added because at one time it did not work on PPC Linux.
 func TestCompileWithoutShared(t *testing.T) {
 	// For simplicity, reuse the signal forwarding test.
 	checkSignalForwardingTest(t)
diff --git a/src/debug/elf/elf.go b/src/debug/elf/elf.go
index b04d874019..9f8399d4d3 100644
--- a/src/debug/elf/elf.go
+++ b/src/debug/elf/elf.go
@@ -123,8 +123,8 @@ const (
 	ELFOSABI_NONE       OSABI = 0   /* UNIX System V ABI */
 	ELFOSABI_HPUX       OSABI = 1   /* HP-UX operating system */
 	ELFOSABI_NETBSD     OSABI = 2   /* NetBSD */
-	ELFOSABI_LINUX      OSABI = 3   /* GNU/Linux */
-	ELFOSABI_HURD       OSABI = 4   /* GNU/Hurd */
+	ELFOSABI_LINUX      OSABI = 3   /* Linux */
+	ELFOSABI_HURD       OSABI = 4   /* Hurd */
 	ELFOSABI_86OPEN     OSABI = 5   /* 86Open common IA32 ABI */
 	ELFOSABI_SOLARIS    OSABI = 6   /* Solaris */
 	ELFOSABI_AIX        OSABI = 7   /* AIX */
diff --git a/src/os/file_unix.go b/src/os/file_unix.go
index b5d87fcb73..deec41324b 100644
--- a/src/os/file_unix.go
+++ b/src/os/file_unix.go
@@ -174,7 +174,7 @@ func newFile(fd uintptr, name string, kind newFileKind) *File {
 		// with the netpoll system. That can happen for
 		// a file descriptor that is not supported by
 		// epoll/kqueue; for example, disk files on
-		// GNU/Linux systems. We assume that any real error
+		// Linux systems. We assume that any real error
 		// will show up in later I/O.
 	} else if pollable {
 		// We successfully registered with netpoll, so put
diff --git a/src/os/signal/doc.go b/src/os/signal/doc.go
index a210795849..7af61d2d81 100644
--- a/src/os/signal/doc.go
+++ b/src/os/signal/doc.go
@@ -50,7 +50,7 @@ If the Go program is started with either SIGHUP or SIGINT ignored
 If the Go program is started with a non-empty signal mask, that will
 generally be honored. However, some signals are explicitly unblocked:
 the synchronous signals, SIGILL, SIGTRAP, SIGSTKFLT, SIGCHLD, SIGPROF,
-and, on GNU/Linux, signals 32 (SIGCANCEL) and 33 (SIGSETXID)
+and, on Linux, signals 32 (SIGCANCEL) and 33 (SIGSETXID)
 (SIGCANCEL and SIGSETXID are used internally by glibc). Subprocesses
 started by os.Exec, or by the os/exec package, will inherit the
 modified signal mask.
@@ -176,7 +176,7 @@ will initialize signals at global constructor time.  For
 shared library is loaded.
 
 If the Go runtime sees an existing signal handler for the SIGCANCEL or
-SIGSETXID signals (which are used only on GNU/Linux), it will turn on
+SIGSETXID signals (which are used only on Linux), it will turn on
 the SA_ONSTACK flag and otherwise keep the signal handler.
 
 For the synchronous signals and SIGPIPE, the Go runtime will install a
diff --git a/src/os/wait_waitid.go b/src/os/wait_waitid.go
index 1f3cb1cfe2..44962c8534 100644
--- a/src/os/wait_waitid.go
+++ b/src/os/wait_waitid.go
@@ -23,7 +23,7 @@ const _P_PID = 1
 // It does not actually call p.Wait.
 func (p *Process) blockUntilWaitable() (bool, error) {
 	// The waitid system call expects a pointer to a siginfo_t,
-	// which is 128 bytes on all GNU/Linux systems.
+	// which is 128 bytes on all Linux systems.
 	// On darwin/amd64, it requires 104 bytes.
 	// We don't care about the values it returns.
 	var siginfo [16]uint64
diff --git a/src/runtime/cgo/gcc_sigaction.c b/src/runtime/cgo/gcc_sigaction.c
index e510e359fe..890008e327 100644
--- a/src/runtime/cgo/gcc_sigaction.c
+++ b/src/runtime/cgo/gcc_sigaction.c
@@ -23,7 +23,7 @@ typedef struct {
 } go_sigaction_t;
 
 // SA_RESTORER is part of the kernel interface.
-// This is GNU/Linux i386/amd64 specific.
+// This is Linux i386/amd64 specific.
 #ifndef SA_RESTORER
 #define SA_RESTORER 0x4000000
 #endif
diff --git a/src/runtime/os_linux_be64.go b/src/runtime/os_linux_be64.go
index 806d02fee8..498d7cec6d 100644
--- a/src/runtime/os_linux_be64.go
+++ b/src/runtime/os_linux_be64.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// The standard GNU/Linux sigset type on big-endian 64-bit machines.
+// The standard Linux sigset type on big-endian 64-bit machines.
 
 //go:build linux && (ppc64 || s390x)
 // +build linux
-- 
GitLab


From 444d28295b81c62dc40180a59aeb480bed43ca3a Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Mon, 12 Apr 2021 18:56:25 -0400
Subject: [PATCH 1518/2400] test: make codegen/memops.go work with both ABIs

Following CL 309335, this fixes memops.go.

Change-Id: Ia2458b5267deee9f906f76c50e70a021ea2fcb5b
Reviewed-on: https://go-review.googlesource.com/c/go/+/309552
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 test/codegen/memops.go | 52 +++++++++++++++---------------------------
 1 file changed, 18 insertions(+), 34 deletions(-)

diff --git a/test/codegen/memops.go b/test/codegen/memops.go
index 7f06a574fe..fb8208f984 100644
--- a/test/codegen/memops.go
+++ b/test/codegen/memops.go
@@ -36,50 +36,34 @@ func compMem1() int {
 	return 0
 }
 
-//go:noinline
-func f(x int) bool {
-	return false
+type T struct {
+	x   bool
+	x8  uint8
+	x16 uint16
+	x32 uint32
+	x64 uint64
+	a   [2]int // force it passed in memory
 }
 
-//go:noinline
-func f8(x int) int8 {
-	return 0
-}
-
-//go:noinline
-func f16(x int) int16 {
-	return 0
-}
-
-//go:noinline
-func f32(x int) int32 {
-	return 0
-}
-
-//go:noinline
-func f64(x int) int64 {
-	return 0
-}
-
-func compMem2() int {
-	// amd64:`CMPB\t8\(SP\), [$]0`
-	if f(3) {
+func compMem2(t T) int {
+	// amd64:`CMPB\t.*\(SP\), [$]0`
+	if t.x {
 		return 1
 	}
-	// amd64:`CMPB\t8\(SP\), [$]7`
-	if f8(3) == 7 {
+	// amd64:`CMPB\t.*\(SP\), [$]7`
+	if t.x8 == 7 {
 		return 1
 	}
-	// amd64:`CMPW\t8\(SP\), [$]7`
-	if f16(3) == 7 {
+	// amd64:`CMPW\t.*\(SP\), [$]7`
+	if t.x16 == 7 {
 		return 1
 	}
-	// amd64:`CMPL\t8\(SP\), [$]7`
-	if f32(3) == 7 {
+	// amd64:`CMPL\t.*\(SP\), [$]7`
+	if t.x32 == 7 {
 		return 1
 	}
-	// amd64:`CMPQ\t8\(SP\), [$]7`
-	if f64(3) == 7 {
+	// amd64:`CMPQ\t.*\(SP\), [$]7`
+	if t.x64 == 7 {
 		return 1
 	}
 	return 0
-- 
GitLab


From 4b00eb7af4f0dffbb0825e225dbcffd2e3e52865 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Mon, 12 Apr 2021 19:42:28 -0400
Subject: [PATCH 1519/2400] cmd/compile: allow OpArgXXXReg comes before
 LoweredGetClosurePtr

Both OpArgXXXReg and LoweredGetClosurePtr must come very early,
because they carry registers that are technically live on entry.
But no need to impose ordering requirement between them.

Change-Id: Iee1db6239a75e5b381e0ad25ba5503169333217b
Reviewed-on: https://go-review.googlesource.com/c/go/+/309629
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/ssagen/ssa.go | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index de60cbf390..60a849db23 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -7097,15 +7097,26 @@ func CheckLoweredPhi(v *ssa.Value) {
 	}
 }
 
-// CheckLoweredGetClosurePtr checks that v is the first instruction in the function's entry block.
+// CheckLoweredGetClosurePtr checks that v is the first instruction in the function's entry block,
+// except for incoming in-register arguments.
 // The output of LoweredGetClosurePtr is generally hardwired to the correct register.
 // That register contains the closure pointer on closure entry.
 func CheckLoweredGetClosurePtr(v *ssa.Value) {
 	entry := v.Block.Func.Entry
-	// TODO register args: not all the register-producing ops can come first.
-	if entry != v.Block || entry.Values[0] != v {
+	if entry != v.Block {
 		base.Fatalf("in %s, badly placed LoweredGetClosurePtr: %v %v", v.Block.Func.Name, v.Block, v)
 	}
+	for _, w := range entry.Values {
+		if w == v {
+			break
+		}
+		switch w.Op {
+		case ssa.OpArgIntReg, ssa.OpArgFloatReg:
+			// okay
+		default:
+			base.Fatalf("in %s, badly placed LoweredGetClosurePtr: %v %v", v.Block.Func.Name, v.Block, v)
+		}
+	}
 }
 
 // CheckArgReg ensures that v is in the function's entry block.
-- 
GitLab


From 39dd96ca5a60502d66494bff83257379df660eea Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Sat, 10 Apr 2021 18:26:01 -0700
Subject: [PATCH 1520/2400] cmd/compile/internal/types: add example test for
 type inference

Follow-up on https://golang.org/cl/308372.

For #44799.

Change-Id: I27d149241d465ee31e9c21d5f0935f31efcb5b60
Reviewed-on: https://go-review.googlesource.com/c/go/+/308973
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 .../internal/types2/examples/inference.go2    | 101 ++++++++++++++++++
 1 file changed, 101 insertions(+)
 create mode 100644 src/cmd/compile/internal/types2/examples/inference.go2

diff --git a/src/cmd/compile/internal/types2/examples/inference.go2 b/src/cmd/compile/internal/types2/examples/inference.go2
new file mode 100644
index 0000000000..b47ce75805
--- /dev/null
+++ b/src/cmd/compile/internal/types2/examples/inference.go2
@@ -0,0 +1,101 @@
+// Copyright 2021 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.
+
+// This file shows some examples of type inference.
+
+package p
+
+type Ordered interface {
+	type int, float64, string
+}
+
+func min[T Ordered](x, y T) T
+
+func _() {
+	// min can be called with explicit instantiation.
+	_ = min[int](1, 2)
+
+	// Alternatively, the type argument can be inferred from
+	// one of the arguments. Untyped arguments will be considered
+	// last.
+	var x int
+	_ = min(x, x)
+	_ = min(x, 1)
+	_ = min(x, 1.0)
+	_ = min(1, 2)
+	_ = min(1, 2.3 /* ERROR default type float64 .* does not match */ )
+
+	var y float64
+	_ = min(1, y)
+	_ = min(1.2, y)
+	_ = min(1.2, 3.4)
+	_ = min(1.2, 3 /* ERROR default type int .* does not match */ )
+
+	var s string
+	_ = min(s, "foo")
+	_ = min("foo", "bar")
+}
+
+func mixed[T1, T2, T3 any](T1, T2, T3)
+
+func _() {
+	// mixed can be called with explicit instantiation.
+	mixed[int, string, bool](0, "", false)
+
+	// Alternatively, partial type arguments may be provided
+	// (from left to right), and the other may be inferred.
+	mixed[int, string](0, "", false)
+	mixed[int](0, "", false)
+	mixed(0, "", false)
+
+	// Provided type arguments always take precedence over
+	// inferred types.
+	mixed[int, string](1.1 /* ERROR cannot use 1.1 */ , "", false)
+}
+
+func related1[Slice interface{type []Elem}, Elem any](s Slice, e Elem)
+
+func _() {
+	// related1 can be called with explicit instantiation.
+	var si []int
+	related1[[]int, int](si, 0)
+
+	// Alternatively, the 2nd type argument can be inferred
+	// from the first one through constraint type inference.
+	var ss []string
+	_ = related1[[]string]
+	related1[[]string](ss, "foo")
+
+	// A type argument inferred from another explicitly provided
+	// type argument overrides whatever value argument type is given.
+	related1[[]string](ss, 0 /* ERROR cannot use 0 */ )
+
+	// A type argument may be inferred from a value argument
+	// and then help infer another type argument via constraint
+	// type inference.
+	related1(si, 0)
+	related1(si, "foo" /* ERROR cannot use "foo" */ )
+}
+
+func related2[Elem any, Slice interface{type []Elem}](e Elem, s Slice)
+
+func _() {
+	// related2 can be called with explicit instantiation.
+	var si []int
+	related2[int, []int](0, si)
+
+	// Alternatively, the 2nd type argument can be inferred
+	// from the first one through constraint type inference.
+	var ss []string
+	_ = related2[string]
+	related2[string]("foo", ss)
+
+	// A type argument may be inferred from a value argument
+	// and then help infer another type argument via constraint
+	// type inference. Untyped arguments are always considered
+	// last.
+	related2(1.2, []float64{})
+	related2(1.0, []int{})
+	related2( /* ERROR does not satisfy */ float64(1.0), []int{}) // TODO(gri) fix error position
+}
-- 
GitLab


From 7b19fb1d560908a848e07e091fb5df61f4848389 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Mon, 12 Apr 2021 22:26:37 -0700
Subject: [PATCH 1521/2400] mime: in globs2 file only keep first time extension
 is seen

Fixes #45534

Change-Id: I9855607e845951f26ab85cb179ec6dea40d92156
Reviewed-on: https://go-review.googlesource.com/c/go/+/309574
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/mime/testdata/test.types.globs2 |  1 +
 src/mime/type_unix.go               | 10 +++++++++-
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/mime/testdata/test.types.globs2 b/src/mime/testdata/test.types.globs2
index 2e893262ea..cb5b7899b0 100644
--- a/src/mime/testdata/test.types.globs2
+++ b/src/mime/testdata/test.types.globs2
@@ -6,3 +6,4 @@
 # mime package test for globs2
 50:document/test:*.t3
 50:example/test:*.t4
+30:example/do-not-use:*.t4
diff --git a/src/mime/type_unix.go b/src/mime/type_unix.go
index 59c99e2c86..f954bc8a1f 100644
--- a/src/mime/type_unix.go
+++ b/src/mime/type_unix.go
@@ -49,7 +49,15 @@ func loadMimeGlobsFile(filename string) error {
 			continue
 		}
 
-		setExtensionType(fields[2][1:], fields[1])
+		extension := fields[2][1:]
+		if _, ok := mimeTypes.Load(extension); ok {
+			// We've already seen this extension.
+			// The file is in weight order, so we keep
+			// the first entry that we see.
+			continue
+		}
+
+		setExtensionType(extension, fields[1])
 	}
 	if err := scanner.Err(); err != nil {
 		panic(err)
-- 
GitLab


From 10f883deb7462baad0c889d93fe867782c023bbe Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Sun, 11 Apr 2021 17:19:59 -0400
Subject: [PATCH 1522/2400] cmd/cgo: document generated cgo directives

This took me a while to figure out. Save the next person some trouble.

Change-Id: Ifab2d426f67c21b08ef225c79125805a9008e578
Reviewed-on: https://go-review.googlesource.com/c/go/+/309336
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/cgo/out.go | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/src/cmd/cgo/out.go b/src/cmd/cgo/out.go
index 2d8d692622..8c31d5b794 100644
--- a/src/cmd/cgo/out.go
+++ b/src/cmd/cgo/out.go
@@ -1021,11 +1021,25 @@ func (p *Package) writeExports(fgo2, fm, fgcc, fgcch io.Writer) {
 		}
 		fmt.Fprintf(fgcc, "}\n")
 
-		// Build the wrapper function compiled by cmd/compile.
-		// This unpacks the argument struct above and calls the Go function.
+		// In internal linking mode, the Go linker sees both
+		// the C wrapper written above and the Go wrapper it
+		// references. Hence, export the C wrapper (e.g., for
+		// if we're building a shared object). The Go linker
+		// will resolve the C wrapper's reference to the Go
+		// wrapper without a separate export.
 		fmt.Fprintf(fgo2, "//go:cgo_export_dynamic %s\n", exp.ExpName)
+		// cgo_export_static refers to a symbol by its linker
+		// name, so set the linker name of the Go wrapper.
 		fmt.Fprintf(fgo2, "//go:linkname _cgoexp%s_%s _cgoexp%s_%s\n", cPrefix, exp.ExpName, cPrefix, exp.ExpName)
+		// In external linking mode, the Go linker sees the Go
+		// wrapper, but not the C wrapper. For this case,
+		// export the Go wrapper so the host linker can
+		// resolve the reference from the C wrapper to the Go
+		// wrapper.
 		fmt.Fprintf(fgo2, "//go:cgo_export_static _cgoexp%s_%s\n", cPrefix, exp.ExpName)
+
+		// Build the wrapper function compiled by cmd/compile.
+		// This unpacks the argument struct above and calls the Go function.
 		fmt.Fprintf(fgo2, "func _cgoexp%s_%s(a *%s) {\n", cPrefix, exp.ExpName, gotype)
 
 		fmt.Fprintf(fm, "int _cgoexp%s_%s;\n", cPrefix, exp.ExpName)
-- 
GitLab


From 6208b10d1e843e49a8cff42ed17f548530fc7452 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Sun, 11 Apr 2021 16:30:36 -0400
Subject: [PATCH 1523/2400] cmd/link: refactor setCgoAttr

setCgoAttr takes a lookup function, but there's only a single call and
setCgoAttr already has access to the lookup function passed at that
call. Simplify setCgoAttr by eliminating the lookup parameter and
calling the lookup function directly.

For #40724.

Change-Id: Ib27c0fa2b88c387e30423365f7757e3ba02cf7d5
Reviewed-on: https://go-review.googlesource.com/c/go/+/309338
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/link/internal/ld/go.go  | 10 +++++-----
 src/cmd/link/internal/ld/lib.go |  2 +-
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/cmd/link/internal/ld/go.go b/src/cmd/link/internal/ld/go.go
index fbc7a78d0e..8cbdd58b3a 100644
--- a/src/cmd/link/internal/ld/go.go
+++ b/src/cmd/link/internal/ld/go.go
@@ -130,7 +130,7 @@ func loadcgo(ctxt *Link, file string, pkg string, p string) {
 
 // Set symbol attributes or flags based on cgo directives.
 // Any newly discovered HOSTOBJ syms are added to 'hostObjSyms'.
-func setCgoAttr(ctxt *Link, lookup func(string, int) loader.Sym, file string, pkg string, directives [][]string, hostObjSyms map[loader.Sym]struct{}) {
+func setCgoAttr(ctxt *Link, file string, pkg string, directives [][]string, hostObjSyms map[loader.Sym]struct{}) {
 	l := ctxt.loader
 	for _, f := range directives {
 		switch f[0] {
@@ -173,7 +173,7 @@ func setCgoAttr(ctxt *Link, lookup func(string, int) loader.Sym, file string, pk
 			if i := strings.Index(remote, "#"); i >= 0 {
 				remote, q = remote[:i], remote[i+1:]
 			}
-			s := lookup(local, 0)
+			s := l.LookupOrCreateSym(local, 0)
 			st := l.SymType(s)
 			if st == 0 || st == sym.SXREF || st == sym.SBSS || st == sym.SNOPTRBSS || st == sym.SHOSTOBJ {
 				l.SetSymDynimplib(s, lib)
@@ -199,7 +199,7 @@ func setCgoAttr(ctxt *Link, lookup func(string, int) loader.Sym, file string, pk
 			}
 			local := f[1]
 
-			s := lookup(local, 0)
+			s := l.LookupOrCreateSym(local, 0)
 			su := l.MakeSymbolUpdater(s)
 			su.SetType(sym.SHOSTOBJ)
 			su.SetSize(0)
@@ -222,7 +222,7 @@ func setCgoAttr(ctxt *Link, lookup func(string, int) loader.Sym, file string, pk
 			// functions. Link.loadlib will resolve any
 			// ABI aliases we find here (since we may not
 			// yet know it's an alias).
-			s := lookup(local, 0)
+			s := l.LookupOrCreateSym(local, 0)
 
 			if l.SymType(s) == sym.SHOSTOBJ {
 				hostObjSyms[s] = struct{}{}
@@ -230,7 +230,7 @@ func setCgoAttr(ctxt *Link, lookup func(string, int) loader.Sym, file string, pk
 
 			switch ctxt.BuildMode {
 			case BuildModeCShared, BuildModeCArchive, BuildModePlugin:
-				if s == lookup("main", 0) {
+				if s == l.Lookup("main", 0) {
 					continue
 				}
 			}
diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index 46d238a318..520d57a72e 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -681,7 +681,7 @@ func (ctxt *Link) loadcgodirectives() {
 	l := ctxt.loader
 	hostObjSyms := make(map[loader.Sym]struct{})
 	for _, d := range ctxt.cgodata {
-		setCgoAttr(ctxt, ctxt.loader.LookupOrCreateSym, d.file, d.pkg, d.directives, hostObjSyms)
+		setCgoAttr(ctxt, d.file, d.pkg, d.directives, hostObjSyms)
 	}
 	ctxt.cgodata = nil
 
-- 
GitLab


From 007e247af1661e507efb702ffbf5b4e2bd2f0f0a Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Sun, 11 Apr 2021 17:29:17 -0400
Subject: [PATCH 1524/2400] cmd/link: move cgo export map from loadcgo to
 setCgoAttr

Currently, both loadcgo and setCgoAttr do some processing of
cgo_export_static and cgo_export_dynamic cgo directives, which means
they both have to parse them. There's no reason to do this in loadcgo,
so move all directive processing to setCgoAttr.

For #40724.

Change-Id: Icb3cdf7ef3517e866dd220e40a5f5dec7fd47e2b
Reviewed-on: https://go-review.googlesource.com/c/go/+/309339
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/link/internal/ld/go.go   | 28 +++++-----------------------
 src/cmd/link/internal/ld/util.go |  2 +-
 2 files changed, 6 insertions(+), 24 deletions(-)

diff --git a/src/cmd/link/internal/ld/go.go b/src/cmd/link/internal/ld/go.go
index 8cbdd58b3a..ec6ceb82ce 100644
--- a/src/cmd/link/internal/ld/go.go
+++ b/src/cmd/link/internal/ld/go.go
@@ -101,29 +101,6 @@ func loadcgo(ctxt *Link, file string, pkg string, p string) {
 		return
 	}
 
-	// Find cgo_export symbols. They are roots in the deadcode pass.
-	for _, f := range directives {
-		switch f[0] {
-		case "cgo_export_static", "cgo_export_dynamic":
-			if len(f) < 2 || len(f) > 3 {
-				continue
-			}
-			local := f[1]
-			switch ctxt.BuildMode {
-			case BuildModeCShared, BuildModeCArchive, BuildModePlugin:
-				if local == "main" {
-					continue
-				}
-			}
-			local = expandpkg(local, pkg)
-			if f[0] == "cgo_export_static" {
-				ctxt.cgo_export_static[local] = true
-			} else {
-				ctxt.cgo_export_dynamic[local] = true
-			}
-		}
-	}
-
 	// Record the directives. We'll process them later after Symbols are created.
 	ctxt.cgodata = append(ctxt.cgodata, cgodata{file, pkg, directives})
 }
@@ -254,11 +231,16 @@ func setCgoAttr(ctxt *Link, file string, pkg string, directives [][]string, host
 				return
 			}
 
+			// Mark exported symbols and also add them to
+			// the lists used for roots in the deadcode pass.
 			if f[0] == "cgo_export_static" {
 				l.SetAttrCgoExportStatic(s, true)
+				ctxt.cgo_export_static[local] = true
 			} else {
 				l.SetAttrCgoExportDynamic(s, true)
+				ctxt.cgo_export_dynamic[local] = true
 			}
+
 			continue
 
 		case "cgo_dynamic_linker":
diff --git a/src/cmd/link/internal/ld/util.go b/src/cmd/link/internal/ld/util.go
index 9228ed163d..779f4988b6 100644
--- a/src/cmd/link/internal/ld/util.go
+++ b/src/cmd/link/internal/ld/util.go
@@ -57,7 +57,7 @@ func afterErrorAction() {
 // Logging an error means that on exit cmd/link will delete any
 // output file and return a non-zero error code.
 //
-// TODO: remove. Use ctxt.Errof instead.
+// TODO: remove. Use ctxt.Errorf instead.
 // All remaining calls use nil as first arg.
 func Errorf(dummy *int, format string, args ...interface{}) {
 	format += "\n"
-- 
GitLab


From 48531da9e706a9f3cf5e08319202e97022fb6813 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Mon, 12 Apr 2021 13:21:55 -0400
Subject: [PATCH 1525/2400] cmd/link: build dynexp symbol list directly

Currently, setCgoAttr populates the cgo_export_{static,dynamic} maps
with symbol names of exported symbols, which are then re-looked-up by
deadcode and setupdynexp, which in turn puts the re-looked-up symbols
in ctxt.dynexp. setCgoAttr already looked up the Syms, so simplify all
of this by making setCgoAttr populate ctxt.dynexp directly and
eliminating the cgo_export_{static,dynamic} maps. Recording Syms
directly also sets us up to use correct symbol versions for these
exports, rather than just assuming version 0 for all lookups.

Since setupdynexp doesn't really do any "setting up" of dynexp any
more with this change, we fold the remaining logic from setupdynexp
directly into addexport, where it has better context anyway. This also
eliminates a sorting step, since we no longer do a non-deterministic
map iteration to build the dynexp slice.

For #40724.

Change-Id: I3e1a65165268da8c2bf50d7485f2624133433260
Reviewed-on: https://go-review.googlesource.com/c/go/+/309340
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/ld/deadcode.go | 16 +++++------
 src/cmd/link/internal/ld/go.go       | 33 +++++++++++++++++++---
 src/cmd/link/internal/ld/lib.go      | 41 ----------------------------
 src/cmd/link/internal/ld/link.go     |  3 --
 src/cmd/link/internal/ld/main.go     |  1 -
 5 files changed, 37 insertions(+), 57 deletions(-)

diff --git a/src/cmd/link/internal/ld/deadcode.go b/src/cmd/link/internal/ld/deadcode.go
index 9b04e2cddc..741a72cad8 100644
--- a/src/cmd/link/internal/ld/deadcode.go
+++ b/src/cmd/link/internal/ld/deadcode.go
@@ -88,14 +88,6 @@ func (d *deadcodePass) init() {
 		}
 	}
 
-	dynexpMap := d.ctxt.cgo_export_dynamic
-	if d.ctxt.LinkMode == LinkExternal {
-		dynexpMap = d.ctxt.cgo_export_static
-	}
-	for exp := range dynexpMap {
-		names = append(names, exp)
-	}
-
 	if d.ctxt.Debugvlog > 1 {
 		d.ctxt.Logf("deadcode start names: %v\n", names)
 	}
@@ -106,6 +98,14 @@ func (d *deadcodePass) init() {
 		// Also mark any Go functions (internal ABI).
 		d.mark(d.ldr.Lookup(name, sym.SymVerABIInternal), 0)
 	}
+
+	// All dynamic exports are roots.
+	for _, s := range d.ctxt.dynexp {
+		if d.ctxt.Debugvlog > 1 {
+			d.ctxt.Logf("deadcode start dynexp: %s<%d>\n", d.ldr.SymName(s), d.ldr.SymVersion(s))
+		}
+		d.mark(s, 0)
+	}
 }
 
 func (d *deadcodePass) flood() {
diff --git a/src/cmd/link/internal/ld/go.go b/src/cmd/link/internal/ld/go.go
index ec6ceb82ce..5dbf6c7153 100644
--- a/src/cmd/link/internal/ld/go.go
+++ b/src/cmd/link/internal/ld/go.go
@@ -234,11 +234,19 @@ func setCgoAttr(ctxt *Link, file string, pkg string, directives [][]string, host
 			// Mark exported symbols and also add them to
 			// the lists used for roots in the deadcode pass.
 			if f[0] == "cgo_export_static" {
+				if ctxt.LinkMode == LinkExternal && !l.AttrCgoExportStatic(s) {
+					// Static cgo exports appear
+					// in the exported symbol table.
+					ctxt.dynexp = append(ctxt.dynexp, s)
+				}
 				l.SetAttrCgoExportStatic(s, true)
-				ctxt.cgo_export_static[local] = true
 			} else {
+				if ctxt.LinkMode == LinkInternal && !l.AttrCgoExportDynamic(s) {
+					// Dynamic cgo exports appear
+					// in the exported symbol table.
+					ctxt.dynexp = append(ctxt.dynexp, s)
+				}
 				l.SetAttrCgoExportDynamic(s, true)
-				ctxt.cgo_export_dynamic[local] = true
 			}
 
 			continue
@@ -422,9 +430,26 @@ func (ctxt *Link) addexport() {
 		return
 	}
 
-	for _, exp := range ctxt.dynexp {
-		Adddynsym(ctxt.loader, &ctxt.Target, &ctxt.ArchSyms, exp)
+	// Add dynamic symbols.
+	for _, s := range ctxt.dynexp {
+		// Consistency check.
+		if !ctxt.loader.AttrReachable(s) {
+			panic("dynexp entry not reachable")
+		}
+
+		// Resolve ABI aliases in the list of cgo-exported functions.
+		// This is necessary because we load the ABI0 symbol for all
+		// cgo exports.
+		if ctxt.loader.SymType(s) == sym.SABIALIAS {
+			t := ctxt.loader.ResolveABIAlias(s)
+			ctxt.loader.CopyAttributes(s, t)
+			ctxt.loader.SetSymExtname(t, ctxt.loader.SymExtname(s))
+			s = t
+		}
+
+		Adddynsym(ctxt.loader, &ctxt.Target, &ctxt.ArchSyms, s)
 	}
+
 	for _, lib := range dedupLibraries(ctxt, dynlib) {
 		adddynlib(ctxt, lib)
 	}
diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index 520d57a72e..b709569103 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -56,7 +56,6 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
-	"sort"
 	"strings"
 	"sync"
 )
@@ -508,9 +507,6 @@ func (ctxt *Link) loadlib() {
 		return ctxt.loader.SymName(s)
 	}
 
-	ctxt.cgo_export_static = make(map[string]bool)
-	ctxt.cgo_export_dynamic = make(map[string]bool)
-
 	// ctxt.Library grows during the loop, so not a range loop.
 	i := 0
 	for ; i < len(ctxt.Library); i++ {
@@ -638,43 +634,6 @@ func (ctxt *Link) loadlib() {
 	strictDupMsgCount = ctxt.loader.NStrictDupMsgs()
 }
 
-// setupdynexp constructs ctxt.dynexp, a list of loader.Sym.
-func setupdynexp(ctxt *Link) {
-	dynexpMap := ctxt.cgo_export_dynamic
-	if ctxt.LinkMode == LinkExternal {
-		dynexpMap = ctxt.cgo_export_static
-	}
-	d := make([]loader.Sym, 0, len(dynexpMap))
-	for exp := range dynexpMap {
-		s := ctxt.loader.LookupOrCreateSym(exp, 0)
-		d = append(d, s)
-		// sanity check
-		if !ctxt.loader.AttrReachable(s) {
-			panic("dynexp entry not reachable")
-		}
-	}
-	sort.Slice(d, func(i, j int) bool {
-		return ctxt.loader.SymName(d[i]) < ctxt.loader.SymName(d[j])
-	})
-
-	// Resolve ABI aliases in the list of cgo-exported functions.
-	// This is necessary because we load the ABI0 symbol for all
-	// cgo exports.
-	for i, s := range d {
-		if ctxt.loader.SymType(s) != sym.SABIALIAS {
-			continue
-		}
-		t := ctxt.loader.ResolveABIAlias(s)
-		ctxt.loader.CopyAttributes(s, t)
-		ctxt.loader.SetSymExtname(t, ctxt.loader.SymExtname(s))
-		d[i] = t
-	}
-	ctxt.dynexp = d
-
-	ctxt.cgo_export_static = nil
-	ctxt.cgo_export_dynamic = nil
-}
-
 // loadcgodirectives reads the previously discovered cgo directives, creating
 // symbols in preparation for host object loading or use later in the link.
 func (ctxt *Link) loadcgodirectives() {
diff --git a/src/cmd/link/internal/ld/link.go b/src/cmd/link/internal/ld/link.go
index f26d051a49..13618beff9 100644
--- a/src/cmd/link/internal/ld/link.go
+++ b/src/cmd/link/internal/ld/link.go
@@ -84,9 +84,6 @@ type Link struct {
 	loader  *loader.Loader
 	cgodata []cgodata // cgo directives to load, three strings are args for loadcgo
 
-	cgo_export_static  map[string]bool
-	cgo_export_dynamic map[string]bool
-
 	datap  []loader.Sym
 	dynexp []loader.Sym
 
diff --git a/src/cmd/link/internal/ld/main.go b/src/cmd/link/internal/ld/main.go
index 8631cf2939..1e3c3bdff7 100644
--- a/src/cmd/link/internal/ld/main.go
+++ b/src/cmd/link/internal/ld/main.go
@@ -294,7 +294,6 @@ func Main(arch *sys.Arch, theArch Arch) {
 	bench.Start("textbuildid")
 	ctxt.textbuildid()
 	bench.Start("addexport")
-	setupdynexp(ctxt)
 	ctxt.setArchSyms()
 	ctxt.addexport()
 	bench.Start("Gentext")
-- 
GitLab


From 69262d48717771cedb1da86563eb3f1b094b4e92 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Sun, 11 Apr 2021 15:44:25 -0400
Subject: [PATCH 1526/2400] cmd/compile,cmd/link: resolve cgo symbols to the
 correct Go ABI

Currently, Go functions exported to cgo have some confusion around
ABIs that leads to crashes. The cmd/cgo-generated C code references an
exported Go wrapper function (which calls the underlying exported user
function). The linker resolves this reference to the ABI0 entry-point
to that Go wrapper function because all host object references are
currently assumed to be to version 0 of a symbol. This gets passed via
crosscall2 and winds its way to cgocallbackg1, which puts this ABI0
entry-point into a function value and calls it. Unfortunately,
function values always use the ABIInternal calling convention, so
calling this ABI0 entry-point goes poorly.

Fix this by threading definition ABIs through the cgo export mechanism
so the linker can resolve host object references (which have no
concept of multiple ABIs) to the correct Go symbol. This involves a
few pieces:

- The compiler extends the cgo_export_{static,dynamic} directives that
  get passed on to the linker with symbol definition ABIs.

- The linker parses the ABIs in the cgo_export_{static,dynamic}
  directives to look up the right symbol to apply export attributes to
  and put in the dynexp list.

- For internal linking, the linker's Loader structure tracks the right
  symbol (in particular the right ABI) to resolve host object
  references to, and we use this in all of the host object loaders.

- For external linking, we mangle only the non-ABIInternal symbols
  now, so the external linker is able to resolve the correct reference
  from host objects to Go symbols.

Updates #40724.

Change-Id: I70a0b1610596768c3f473745fa1a3e630afbf1a8
Reviewed-on: https://go-review.googlesource.com/c/go/+/309341
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/ssagen/abi.go     | 49 +++++++++++++++++++---
 src/cmd/link/internal/ld/go.go             | 40 ++++++++++--------
 src/cmd/link/internal/ld/macho.go          | 28 +++++++++++--
 src/cmd/link/internal/ld/symtab.go         | 27 ++++--------
 src/cmd/link/internal/loadelf/ldelf.go     |  4 +-
 src/cmd/link/internal/loader/loader.go     | 33 +++++++++++++++
 src/cmd/link/internal/loadmacho/ldmacho.go |  2 +-
 src/cmd/link/internal/loadpe/ldpe.go       | 13 +++---
 src/cmd/link/internal/loadxcoff/ldxcoff.go |  2 +-
 9 files changed, 139 insertions(+), 59 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/abi.go b/src/cmd/compile/internal/ssagen/abi.go
index 9229d0212c..8103b08ce5 100644
--- a/src/cmd/compile/internal/ssagen/abi.go
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -108,12 +108,20 @@ func (s *SymABIs) ReadSymABIs(file string) {
 // GenABIWrappers applies ABI information to Funcs and generates ABI
 // wrapper functions where necessary.
 func (s *SymABIs) GenABIWrappers() {
-	// The linker expects an ABI0 wrapper for all cgo-exported
-	// functions.
-	for _, prag := range typecheck.Target.CgoPragmas {
+	// For cgo exported symbols, we tell the linker to export the
+	// definition ABI to C. That also means that we don't want to
+	// create ABI wrappers even if there's a linkname.
+	//
+	// TODO(austin): Maybe we want to create the ABI wrappers, but
+	// ensure the linker exports the right ABI definition under
+	// the unmangled name?
+	cgoExports := make(map[string][]*[]string)
+	for i, prag := range typecheck.Target.CgoPragmas {
 		switch prag[0] {
 		case "cgo_export_static", "cgo_export_dynamic":
-			s.refs[s.canonicalize(prag[1])] |= obj.ABISetOf(obj.ABI0)
+			symName := s.canonicalize(prag[1])
+			pprag := &typecheck.Target.CgoPragmas[i]
+			cgoExports[symName] = append(cgoExports[symName], pprag)
 		}
 	}
 
@@ -153,6 +161,27 @@ func (s *SymABIs) GenABIWrappers() {
 			fn.ABI = obj.ABI0
 		}
 
+		// If cgo-exported, add the definition ABI to the cgo
+		// pragmas.
+		cgoExport := cgoExports[symName]
+		for _, pprag := range cgoExport {
+			// The export pragmas have the form:
+			//
+			//   cgo_export_* <local> [<remote>]
+			//
+			// If <remote> is omitted, it's the same as
+			// <local>.
+			//
+			// Expand to
+			//
+			//   cgo_export_* <local> <remote> <ABI>
+			if len(*pprag) == 2 {
+				*pprag = append(*pprag, (*pprag)[1])
+			}
+			// Add the ABI argument.
+			*pprag = append(*pprag, fn.ABI.String())
+		}
+
 		// Apply references.
 		if abis, ok := s.refs[symName]; ok {
 			fn.ABIRefs |= abis
@@ -169,11 +198,21 @@ func (s *SymABIs) GenABIWrappers() {
 		// it's defined in this package since other packages
 		// may "pull" symbols using linkname and we don't want
 		// to create duplicate ABI wrappers.
+		//
+		// However, if it's given a linkname for exporting to
+		// C, then we don't make ABI wrappers because the cgo
+		// tool wants the original definition.
 		hasBody := len(fn.Body) != 0
-		if sym.Linkname != "" && (hasBody || hasDefABI) {
+		if sym.Linkname != "" && (hasBody || hasDefABI) && len(cgoExport) == 0 {
 			fn.ABIRefs |= obj.ABISetCallable
 		}
 
+		// Double check that cgo-exported symbols don't get
+		// any wrappers.
+		if len(cgoExport) > 0 && fn.ABIRefs&^obj.ABISetOf(fn.ABI) != 0 {
+			base.Fatalf("cgo exported function %s cannot have ABI wrappers", fn)
+		}
+
 		if !objabi.Experiment.RegabiWrappers {
 			// We'll generate ABI aliases instead of
 			// wrappers once we have LSyms in InitLSym.
diff --git a/src/cmd/link/internal/ld/go.go b/src/cmd/link/internal/ld/go.go
index 5dbf6c7153..fc63b30c80 100644
--- a/src/cmd/link/internal/ld/go.go
+++ b/src/cmd/link/internal/ld/go.go
@@ -9,6 +9,7 @@ package ld
 import (
 	"bytes"
 	"cmd/internal/bio"
+	"cmd/internal/obj"
 	"cmd/internal/objabi"
 	"cmd/internal/sys"
 	"cmd/link/internal/loader"
@@ -184,7 +185,7 @@ func setCgoAttr(ctxt *Link, file string, pkg string, directives [][]string, host
 			continue
 
 		case "cgo_export_static", "cgo_export_dynamic":
-			if len(f) < 2 || len(f) > 3 {
+			if len(f) < 2 || len(f) > 4 {
 				break
 			}
 			local := f[1]
@@ -193,13 +194,20 @@ func setCgoAttr(ctxt *Link, file string, pkg string, directives [][]string, host
 				remote = f[2]
 			}
 			local = expandpkg(local, pkg)
+			// The compiler adds a fourth argument giving
+			// the definition ABI of function symbols.
+			abi := obj.ABI0
+			if len(f) > 3 {
+				var ok bool
+				abi, ok = obj.ParseABI(f[3])
+				if !ok {
+					fmt.Fprintf(os.Stderr, "%s: bad ABI in cgo_export directive %s\n", os.Args[0], f)
+					nerrors++
+					return
+				}
+			}
 
-			// The compiler arranges for an ABI0 wrapper
-			// to be available for all cgo-exported
-			// functions. Link.loadlib will resolve any
-			// ABI aliases we find here (since we may not
-			// yet know it's an alias).
-			s := l.LookupOrCreateSym(local, 0)
+			s := l.LookupOrCreateSym(local, sym.ABIToVersion(abi))
 
 			if l.SymType(s) == sym.SHOSTOBJ {
 				hostObjSyms[s] = struct{}{}
@@ -239,6 +247,14 @@ func setCgoAttr(ctxt *Link, file string, pkg string, directives [][]string, host
 					// in the exported symbol table.
 					ctxt.dynexp = append(ctxt.dynexp, s)
 				}
+				if ctxt.LinkMode == LinkInternal {
+					// For internal linking, we're
+					// responsible for resolving
+					// relocations from host objects.
+					// Record the right Go symbol
+					// version to use.
+					l.AddCgoExport(s)
+				}
 				l.SetAttrCgoExportStatic(s, true)
 			} else {
 				if ctxt.LinkMode == LinkInternal && !l.AttrCgoExportDynamic(s) {
@@ -437,16 +453,6 @@ func (ctxt *Link) addexport() {
 			panic("dynexp entry not reachable")
 		}
 
-		// Resolve ABI aliases in the list of cgo-exported functions.
-		// This is necessary because we load the ABI0 symbol for all
-		// cgo exports.
-		if ctxt.loader.SymType(s) == sym.SABIALIAS {
-			t := ctxt.loader.ResolveABIAlias(s)
-			ctxt.loader.CopyAttributes(s, t)
-			ctxt.loader.SetSymExtname(t, ctxt.loader.SymExtname(s))
-			s = t
-		}
-
 		Adddynsym(ctxt.loader, &ctxt.Target, &ctxt.ArchSyms, s)
 	}
 
diff --git a/src/cmd/link/internal/ld/macho.go b/src/cmd/link/internal/ld/macho.go
index 872144e723..4c55c5761f 100644
--- a/src/cmd/link/internal/ld/macho.go
+++ b/src/cmd/link/internal/ld/macho.go
@@ -7,6 +7,7 @@ package ld
 import (
 	"bytes"
 	"cmd/internal/codesign"
+	"cmd/internal/obj"
 	"cmd/internal/objabi"
 	"cmd/internal/sys"
 	"cmd/link/internal/loader"
@@ -535,12 +536,31 @@ func (ctxt *Link) domacho() {
 		sb.AddUint8(0)
 	}
 
-	// Do not export C symbols dynamically in plugins, as runtime C symbols like crosscall2
-	// are in pclntab and end up pointing at the host binary, breaking unwinding.
-	// See Issue #18190.
+	// Un-export runtime symbols from plugins. Since the runtime
+	// is included in both the main binary and each plugin, these
+	// symbols appear in both images. If we leave them exported in
+	// the plugin, then the dynamic linker will resolve
+	// relocations to these functions in the plugin's functab to
+	// point to the main image, causing the runtime to think the
+	// plugin's functab is corrupted. By unexporting them, these
+	// become static references, which are resolved to the
+	// plugin's text.
+	//
+	// It would be better to omit the runtime from plugins. (Using
+	// relative PCs in the functab instead of relocations would
+	// also address this.)
+	//
+	// See issue #18190.
 	if ctxt.BuildMode == BuildModePlugin {
 		for _, name := range []string{"_cgo_topofstack", "__cgo_topofstack", "_cgo_panic", "crosscall2"} {
-			s := ctxt.loader.Lookup(name, 0)
+			// Most of these are data symbols or C
+			// symbols, so they have symbol version 0.
+			ver := 0
+			// _cgo_panic is a Go function, so it uses ABIInternal.
+			if name == "_cgo_panic" {
+				ver = sym.ABIToVersion(obj.ABIInternal)
+			}
+			s := ctxt.loader.Lookup(name, ver)
 			if s != 0 {
 				ctxt.loader.SetAttrCgoExportDynamic(s, false)
 			}
diff --git a/src/cmd/link/internal/ld/symtab.go b/src/cmd/link/internal/ld/symtab.go
index bd8e4cb4bd..dcb9d7eb48 100644
--- a/src/cmd/link/internal/ld/symtab.go
+++ b/src/cmd/link/internal/ld/symtab.go
@@ -837,33 +837,20 @@ func mangleABIName(ldr *loader.Loader, x loader.Sym, name string) string {
 	// For functions with ABI wrappers, we have to make sure that we
 	// don't wind up with two elf symbol table entries with the same
 	// name (since this will generated an error from the external
-	// linker). In the CgoExportStatic case, we want the ABI0 symbol
-	// to have the primary symbol table entry (since it's going to be
-	// called from C), so we rename the ABIInternal symbol. In all
-	// other cases, we rename the ABI0 symbol, since we want
-	// cross-load-module calls to target ABIInternal.
-	//
-	// TODO: this is currently only used on ELF and PE. Other platforms?
+	// linker). If we have wrappers, keep the ABIInternal name
+	// unmangled since we want cross-load-module calls to target
+	// ABIInternal, and rename other symbols.
 	//
 	// TODO: avoid the ldr.Lookup calls below by instead using an aux
 	// sym or marker relocation to associate the wrapper with the
 	// wrapped function.
-	//
 	if !objabi.Experiment.RegabiWrappers {
 		return name
 	}
-	if !ldr.IsExternal(x) && ldr.SymType(x) == sym.STEXT {
-		// First case
-		if ldr.SymVersion(x) == sym.SymVerABIInternal {
-			if s2 := ldr.Lookup(name, sym.SymVerABI0); s2 != 0 && ldr.AttrCgoExportStatic(s2) && ldr.SymType(s2) == sym.STEXT {
-				name = name + ".abiinternal"
-			}
-		}
-		// Second case
-		if ldr.SymVersion(x) == sym.SymVerABI0 && !ldr.AttrCgoExportStatic(x) {
-			if s2 := ldr.Lookup(name, sym.SymVerABIInternal); s2 != 0 && ldr.SymType(s2) == sym.STEXT {
-				name = name + ".abi0"
-			}
+
+	if !ldr.IsExternal(x) && ldr.SymType(x) == sym.STEXT && ldr.SymVersion(x) != sym.SymVerABIInternal {
+		if s2 := ldr.Lookup(name, sym.SymVerABIInternal); s2 != 0 && ldr.SymType(s2) == sym.STEXT {
+			name = fmt.Sprintf("%s.abi%d", name, ldr.SymVersion(x))
 		}
 	}
 	return name
diff --git a/src/cmd/link/internal/loadelf/ldelf.go b/src/cmd/link/internal/loadelf/ldelf.go
index 28284e9de0..c6956297f6 100644
--- a/src/cmd/link/internal/loadelf/ldelf.go
+++ b/src/cmd/link/internal/loadelf/ldelf.go
@@ -245,9 +245,7 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, f *bio.Reader,
 	newSym := func(name string, version int) loader.Sym {
 		return l.CreateStaticSym(name)
 	}
-	lookup := func(name string, version int) loader.Sym {
-		return l.LookupOrCreateSym(name, version)
-	}
+	lookup := l.LookupOrCreateCgoExport
 	errorf := func(str string, args ...interface{}) ([]loader.Sym, uint32, error) {
 		return nil, 0, fmt.Errorf("loadelf: %s: %v", pn, fmt.Sprintf(str, args...))
 	}
diff --git a/src/cmd/link/internal/loader/loader.go b/src/cmd/link/internal/loader/loader.go
index adc8195ace..141dd0ac68 100644
--- a/src/cmd/link/internal/loader/loader.go
+++ b/src/cmd/link/internal/loader/loader.go
@@ -257,6 +257,9 @@ type Loader struct {
 	// the symbol that triggered the marking of symbol K as live.
 	Reachparent []Sym
 
+	// CgoExports records cgo-exported symbols by SymName.
+	CgoExports map[string]Sym
+
 	flags uint32
 
 	hasUnknownPkgPath bool // if any Go object has unknown package path
@@ -514,6 +517,36 @@ func (l *Loader) LookupOrCreateSym(name string, ver int) Sym {
 	return i
 }
 
+// AddCgoExport records a cgo-exported symbol in l.CgoExports.
+// This table is used to identify the correct Go symbol ABI to use
+// to resolve references from host objects (which don't have ABIs).
+func (l *Loader) AddCgoExport(s Sym) {
+	if l.CgoExports == nil {
+		l.CgoExports = make(map[string]Sym)
+	}
+	l.CgoExports[l.SymName(s)] = s
+}
+
+// LookupOrCreateCgoExport is like LookupOrCreateSym, but if ver
+// indicates a global symbol, it uses the CgoExport table to determine
+// the appropriate symbol version (ABI) to use. ver must be either 0
+// or a static symbol version.
+func (l *Loader) LookupOrCreateCgoExport(name string, ver int) Sym {
+	if ver >= sym.SymVerStatic {
+		return l.LookupOrCreateSym(name, ver)
+	}
+	if ver != 0 {
+		panic("ver must be 0 or a static version")
+	}
+	// Look for a cgo-exported symbol from Go.
+	if s, ok := l.CgoExports[name]; ok {
+		return s
+	}
+	// Otherwise, this must just be a symbol in the host object.
+	// Create a version 0 symbol for it.
+	return l.LookupOrCreateSym(name, 0)
+}
+
 func (l *Loader) IsExternal(i Sym) bool {
 	r, _ := l.toLocal(i)
 	return l.isExtReader(r)
diff --git a/src/cmd/link/internal/loadmacho/ldmacho.go b/src/cmd/link/internal/loadmacho/ldmacho.go
index 6d1d9bb29e..e7d9eebc33 100644
--- a/src/cmd/link/internal/loadmacho/ldmacho.go
+++ b/src/cmd/link/internal/loadmacho/ldmacho.go
@@ -607,7 +607,7 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, f *bio.Reader,
 		if machsym.type_&N_EXT == 0 {
 			v = localSymVersion
 		}
-		s := l.LookupOrCreateSym(name, v)
+		s := l.LookupOrCreateCgoExport(name, v)
 		if machsym.type_&N_EXT == 0 {
 			l.SetAttrDuplicateOK(s, true)
 		}
diff --git a/src/cmd/link/internal/loadpe/ldpe.go b/src/cmd/link/internal/loadpe/ldpe.go
index f474dfb276..9cc7effe1f 100644
--- a/src/cmd/link/internal/loadpe/ldpe.go
+++ b/src/cmd/link/internal/loadpe/ldpe.go
@@ -178,11 +178,7 @@ func makeUpdater(l *loader.Loader, bld *loader.SymbolBuilder, s loader.Sym) *loa
 // If an .rsrc section or set of .rsrc$xx sections is found, its symbols are
 // returned as rsrc.
 func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, input *bio.Reader, pkg string, length int64, pn string) (textp []loader.Sym, rsrc []loader.Sym, err error) {
-	lookup := func(name string, version int) (*loader.SymbolBuilder, loader.Sym) {
-		s := l.LookupOrCreateSym(name, version)
-		sb := l.MakeSymbolUpdater(s)
-		return sb, s
-	}
+	lookup := l.LookupOrCreateCgoExport
 	sectsyms := make(map[*pe.Section]loader.Sym)
 	sectdata := make(map[*pe.Section][]byte)
 
@@ -214,7 +210,8 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, input *bio.Read
 		}
 
 		name := fmt.Sprintf("%s(%s)", pkg, sect.Name)
-		bld, s := lookup(name, localSymVersion)
+		s := lookup(name, localSymVersion)
+		bld := l.MakeSymbolUpdater(s)
 
 		switch sect.Characteristics & (IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE) {
 		case IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ: //.rdata
@@ -272,7 +269,7 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, input *bio.Read
 				return nil, nil, fmt.Errorf("relocation number %d symbol index idx=%d cannot be large then number of symbols %d", j, r.SymbolTableIndex, len(f.COFFSymbols))
 			}
 			pesym := &f.COFFSymbols[r.SymbolTableIndex]
-			_, gosym, err := readpesym(l, arch, l.LookupOrCreateSym, f, pesym, sectsyms, localSymVersion)
+			_, gosym, err := readpesym(l, arch, lookup, f, pesym, sectsyms, localSymVersion)
 			if err != nil {
 				return nil, nil, err
 			}
@@ -414,7 +411,7 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, input *bio.Read
 			}
 		}
 
-		bld, s, err := readpesym(l, arch, l.LookupOrCreateSym, f, pesym, sectsyms, localSymVersion)
+		bld, s, err := readpesym(l, arch, lookup, f, pesym, sectsyms, localSymVersion)
 		if err != nil {
 			return nil, nil, err
 		}
diff --git a/src/cmd/link/internal/loadxcoff/ldxcoff.go b/src/cmd/link/internal/loadxcoff/ldxcoff.go
index a5744216d6..920e1c85fd 100644
--- a/src/cmd/link/internal/loadxcoff/ldxcoff.go
+++ b/src/cmd/link/internal/loadxcoff/ldxcoff.go
@@ -121,7 +121,7 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, input *bio.Read
 		}
 		sb := l.MakeSymbolUpdater(sect.sym)
 		for _, rx := range sect.Relocs {
-			rSym := l.LookupOrCreateSym(rx.Symbol.Name, 0)
+			rSym := l.LookupOrCreateCgoExport(rx.Symbol.Name, 0)
 			if uint64(int32(rx.VirtualAddress)) != rx.VirtualAddress {
 				return errorf("virtual address of a relocation is too big: 0x%x", rx.VirtualAddress)
 			}
-- 
GitLab


From 3bf645a6338d0699116f58f5ae5b0f2a0f0dca65 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Mon, 12 Apr 2021 17:30:36 -0700
Subject: [PATCH 1527/2400] cmd/link: force external linking for DragonFly cgo
 programs

Change-Id: Idce4eec2a4698a94aa7b40590dffb6bf9bd45342
Reviewed-on: https://go-review.googlesource.com/c/go/+/309571
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/cmd/link/internal/ld/config.go | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/cmd/link/internal/ld/config.go b/src/cmd/link/internal/ld/config.go
index 291b28e11c..9228962fb3 100644
--- a/src/cmd/link/internal/ld/config.go
+++ b/src/cmd/link/internal/ld/config.go
@@ -199,7 +199,10 @@ func mustLinkExternal(ctxt *Link) (res bool, reason string) {
 	if iscgo && ctxt.Arch.InFamily(sys.MIPS64, sys.MIPS, sys.PPC64, sys.RISCV64) {
 		return true, objabi.GOARCH + " does not support internal cgo"
 	}
-	if iscgo && objabi.GOOS == "android" {
+	if iscgo && (objabi.GOOS == "android" || objabi.GOOS == "dragonfly") {
+		// It seems that on Dragonfly thread local storage is
+		// set up by the dynamic linker, so internal cgo linking
+		// doesn't work. Test case is "go test runtime/cgo".
 		return true, objabi.GOOS + " does not support internal cgo"
 	}
 
-- 
GitLab


From 069983e5db99fa6b94401f971e9c19440615d233 Mon Sep 17 00:00:00 2001
From: Manlio Perillo <manlio.perillo@gmail.com>
Date: Tue, 13 Apr 2021 12:35:28 +0200
Subject: [PATCH 1528/2400] archive/tar: replace os.MkdirTemp with T.TempDir

Updates #45402

Change-Id: I296f8c676c68ed1e10b6ad1a17b5b23d2c395252
Reviewed-on: https://go-review.googlesource.com/c/go/+/309355
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Joe Tsai <thebrokentoaster@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/archive/tar/tar_test.go | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/src/archive/tar/tar_test.go b/src/archive/tar/tar_test.go
index 91b38401b6..e9fafc7cc7 100644
--- a/src/archive/tar/tar_test.go
+++ b/src/archive/tar/tar_test.go
@@ -262,16 +262,11 @@ func TestFileInfoHeaderDir(t *testing.T) {
 func TestFileInfoHeaderSymlink(t *testing.T) {
 	testenv.MustHaveSymlink(t)
 
-	tmpdir, err := os.MkdirTemp("", "TestFileInfoHeaderSymlink")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
+	tmpdir := t.TempDir()
 
 	link := filepath.Join(tmpdir, "link")
 	target := tmpdir
-	err = os.Symlink(target, link)
-	if err != nil {
+	if err := os.Symlink(target, link); err != nil {
 		t.Fatal(err)
 	}
 	fi, err := os.Lstat(link)
-- 
GitLab


From e512bc2cf0ce18342571fdbcdcd43d2bb13ef55b Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Tue, 13 Apr 2021 08:20:08 -0400
Subject: [PATCH 1529/2400] runtime: use compileCallback for ctrlhandler

This replaces the externalthreadhandler-based implementation of
ctrlhandler with one based on compileCallback. This is a step toward
eliminating externalthreadhandler.

For #45530.

Change-Id: I2de2f2f37777af292db67ccf8057b7566aab81f8
Reviewed-on: https://go-review.googlesource.com/c/go/+/309632
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/cmd/link/internal/ld/pe.go  |  4 ++--
 src/runtime/os_windows.go       | 15 +++++++--------
 src/runtime/sys_windows_386.s   |  9 ---------
 src/runtime/sys_windows_amd64.s |  7 -------
 src/runtime/sys_windows_arm.s   |  4 ----
 src/runtime/sys_windows_arm64.s |  4 ----
 6 files changed, 9 insertions(+), 34 deletions(-)

diff --git a/src/cmd/link/internal/ld/pe.go b/src/cmd/link/internal/ld/pe.go
index b590d5082d..dc1b53010a 100644
--- a/src/cmd/link/internal/ld/pe.go
+++ b/src/cmd/link/internal/ld/pe.go
@@ -947,8 +947,8 @@ func (f *peFile) writeOptionalHeader(ctxt *Link) {
 	// calls that may need more stack than we think.
 	//
 	// The default stack reserve size directly affects only the main
-	// thread, ctrlhandler thread, and profileloop thread. For
-	// these, it must be greater than the stack size assumed by
+	// thread and threads that enter in externalthreadhandler.
+	// For this, it must be greater than the stack size assumed by
 	// externalthreadhandler.
 	//
 	// For other threads, the runtime explicitly asks the kernel
diff --git a/src/runtime/os_windows.go b/src/runtime/os_windows.go
index 705b42c61c..77ad075be1 100644
--- a/src/runtime/os_windows.go
+++ b/src/runtime/os_windows.go
@@ -149,9 +149,6 @@ var (
 // to start new os thread.
 func tstart_stdcall(newm *m)
 
-// Called by OS using stdcall ABI.
-func ctrlhandler()
-
 // Init-time helper
 func wintls()
 
@@ -557,8 +554,6 @@ func osinit() {
 
 	initExceptionHandler()
 
-	stdcall2(_SetConsoleCtrlHandler, funcPC(ctrlhandler), 1)
-
 	initHighResTimer()
 	timeBeginPeriodRetValue = osRelax(false)
 
@@ -685,8 +680,12 @@ func goenvs() {
 
 	stdcall1(_FreeEnvironmentStringsW, uintptr(strings))
 
-	// We call this all the way here, late in init, so that malloc works
-	// for the callback function this generates.
+	// We call these all the way here, late in init, so that malloc works
+	// for the callback functions these generate.
+	var fn interface{} = ctrlHandler
+	ctrlHandlerPC := compileCallback(*efaceOf(&fn), true)
+	stdcall2(_SetConsoleCtrlHandler, ctrlHandlerPC, 1)
+
 	monitorSuspendResume()
 }
 
@@ -1176,7 +1175,7 @@ func usleep(us uint32) {
 	})
 }
 
-func ctrlhandler1(_type uint32) uint32 {
+func ctrlHandler(_type uint32) uintptr {
 	var s uint32
 
 	switch _type {
diff --git a/src/runtime/sys_windows_386.s b/src/runtime/sys_windows_386.s
index be4268a9c0..b1c27c40d9 100644
--- a/src/runtime/sys_windows_386.s
+++ b/src/runtime/sys_windows_386.s
@@ -156,15 +156,6 @@ TEXT runtime·lastcontinuetramp<ABIInternal>(SB),NOSPLIT,$0-0
 	MOVL	$runtime·lastcontinuehandler(SB), AX
 	JMP	sigtramp<>(SB)
 
-// Called by OS using stdcall ABI: bool ctrlhandler(uint32).
-TEXT runtime·ctrlhandler<ABIInternal>(SB),NOSPLIT,$0
-	PUSHL	$runtime·ctrlhandler1(SB)
-	NOP	SP	// tell vet SP changed - stop checking offsets
-	CALL	runtime·externalthreadhandler<ABIInternal>(SB)
-	MOVL	4(SP), CX
-	ADDL	$12, SP
-	JMP	CX
-
 // Called by OS using stdcall ABI: uint32 profileloop(void*).
 TEXT runtime·profileloop<ABIInternal>(SB),NOSPLIT,$0
 	PUSHL	$runtime·profileloop1(SB)
diff --git a/src/runtime/sys_windows_amd64.s b/src/runtime/sys_windows_amd64.s
index 1fd8bf5c5c..e9428c36db 100644
--- a/src/runtime/sys_windows_amd64.s
+++ b/src/runtime/sys_windows_amd64.s
@@ -202,13 +202,6 @@ TEXT runtime·lastcontinuetramp<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-0
 	MOVQ	$runtime·lastcontinuehandler(SB), AX
 	JMP	sigtramp<>(SB)
 
-TEXT runtime·ctrlhandler<ABIInternal>(SB),NOSPLIT|NOFRAME,$8
-	MOVQ	CX, 16(SP)		// spill
-	MOVQ	$runtime·ctrlhandler1(SB), CX
-	MOVQ	CX, 0(SP)
-	CALL	runtime·externalthreadhandler<ABIInternal>(SB)
-	RET
-
 TEXT runtime·profileloop<ABIInternal>(SB),NOSPLIT|NOFRAME,$8
 	MOVQ	$runtime·profileloop1(SB), CX
 	MOVQ	CX, 0(SP)
diff --git a/src/runtime/sys_windows_arm.s b/src/runtime/sys_windows_arm.s
index 72de89dc84..304bba22e0 100644
--- a/src/runtime/sys_windows_arm.s
+++ b/src/runtime/sys_windows_arm.s
@@ -233,10 +233,6 @@ TEXT runtime·lastcontinuetramp<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
 	MOVW	$runtime·lastcontinuehandler(SB), R1
 	B	sigtramp<>(SB)
 
-TEXT runtime·ctrlhandler<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
-	MOVW	$runtime·ctrlhandler1(SB), R1
-	B	runtime·externalthreadhandler<ABIInternal>(SB)
-
 TEXT runtime·profileloop<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
 	MOVW	$runtime·profileloop1(SB), R1
 	B	runtime·externalthreadhandler<ABIInternal>(SB)
diff --git a/src/runtime/sys_windows_arm64.s b/src/runtime/sys_windows_arm64.s
index f54c868b26..4512fbc8b0 100644
--- a/src/runtime/sys_windows_arm64.s
+++ b/src/runtime/sys_windows_arm64.s
@@ -299,10 +299,6 @@ TEXT runtime·lastcontinuetramp(SB),NOSPLIT|NOFRAME,$0
 	MOVD	$runtime·lastcontinuehandler<ABIInternal>(SB), R1
 	B	sigtramp<>(SB)
 
-TEXT runtime·ctrlhandler<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
-	MOVD	$runtime·ctrlhandler1(SB), R1
-	B	runtime·externalthreadhandler<ABIInternal>(SB)
-
 TEXT runtime·profileloop<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
 	MOVD	$runtime·profileloop1(SB), R1
 	B	runtime·externalthreadhandler<ABIInternal>(SB)
-- 
GitLab


From e69f02265c74529a368a2ff27fdce4aeb3483e8b Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Tue, 13 Apr 2021 08:32:21 -0400
Subject: [PATCH 1530/2400] runtime: use newm for profileloop

This replaces the externalthreadhandler-based implementation of
profileloop with one that uses newm to start a new thread. This is a
step toward eliminating externalthreadhandler.

For #45530.

Change-Id: Id8e5540423fe2d2004024b649afec6998f77b092
Reviewed-on: https://go-review.googlesource.com/c/go/+/309633
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/os_windows.go       | 18 +++++++++---------
 src/runtime/sys_windows_386.s   |  9 ---------
 src/runtime/sys_windows_amd64.s |  6 ------
 src/runtime/sys_windows_arm.s   |  4 ----
 src/runtime/sys_windows_arm64.s |  4 ----
 5 files changed, 9 insertions(+), 32 deletions(-)

diff --git a/src/runtime/os_windows.go b/src/runtime/os_windows.go
index 77ad075be1..5bff4b6646 100644
--- a/src/runtime/os_windows.go
+++ b/src/runtime/os_windows.go
@@ -1198,9 +1198,6 @@ func ctrlHandler(_type uint32) uintptr {
 	return 0
 }
 
-// in sys_windows_386.s and sys_windows_amd64.s
-func profileloop()
-
 // called from zcallback_windows_*.s to sys_windows_*.s
 func callbackasm1()
 
@@ -1233,13 +1230,18 @@ func gFromSP(mp *m, sp uintptr) *g {
 	return nil
 }
 
-func profileloop1(param uintptr) uint32 {
+func profileLoop() {
 	stdcall2(_SetThreadPriority, currentThread, _THREAD_PRIORITY_HIGHEST)
 
 	for {
 		stdcall2(_WaitForSingleObject, profiletimer, _INFINITE)
 		first := (*m)(atomic.Loadp(unsafe.Pointer(&allm)))
 		for mp := first; mp != nil; mp = mp.alllink {
+			if mp == getg().m {
+				// Don't profile ourselves.
+				continue
+			}
+
 			lock(&mp.threadLock)
 			// Do not profile threads blocked on Notes,
 			// this includes idle worker threads,
@@ -1251,8 +1253,8 @@ func profileloop1(param uintptr) uint32 {
 			// Acquire our own handle to the thread.
 			var thread uintptr
 			if stdcall7(_DuplicateHandle, currentProcess, mp.thread, currentProcess, uintptr(unsafe.Pointer(&thread)), 0, 0, _DUPLICATE_SAME_ACCESS) == 0 {
-				print("runtime.profileloop1: duplicatehandle failed; errno=", getlasterror(), "\n")
-				throw("runtime.profileloop1: duplicatehandle failed")
+				print("runtime: duplicatehandle failed; errno=", getlasterror(), "\n")
+				throw("duplicatehandle failed")
 			}
 			unlock(&mp.threadLock)
 
@@ -1280,9 +1282,7 @@ func setProcessCPUProfiler(hz int32) {
 	if profiletimer == 0 {
 		timer := stdcall3(_CreateWaitableTimerA, 0, 0, 0)
 		atomic.Storeuintptr(&profiletimer, timer)
-		thread := stdcall6(_CreateThread, 0, 0, funcPC(profileloop), 0, 0, 0)
-		stdcall2(_SetThreadPriority, thread, _THREAD_PRIORITY_HIGHEST)
-		stdcall1(_CloseHandle, thread)
+		newm(profileLoop, nil, -1)
 	}
 }
 
diff --git a/src/runtime/sys_windows_386.s b/src/runtime/sys_windows_386.s
index b1c27c40d9..c8839b9976 100644
--- a/src/runtime/sys_windows_386.s
+++ b/src/runtime/sys_windows_386.s
@@ -156,15 +156,6 @@ TEXT runtime·lastcontinuetramp<ABIInternal>(SB),NOSPLIT,$0-0
 	MOVL	$runtime·lastcontinuehandler(SB), AX
 	JMP	sigtramp<>(SB)
 
-// Called by OS using stdcall ABI: uint32 profileloop(void*).
-TEXT runtime·profileloop<ABIInternal>(SB),NOSPLIT,$0
-	PUSHL	$runtime·profileloop1(SB)
-	NOP	SP	// tell vet SP changed - stop checking offsets
-	CALL	runtime·externalthreadhandler(SB)
-	MOVL	4(SP), CX
-	ADDL	$12, SP
-	JMP	CX
-
 TEXT runtime·externalthreadhandler<ABIInternal>(SB),NOSPLIT|TOPFRAME,$0
 	PUSHL	BP
 	MOVL	SP, BP
diff --git a/src/runtime/sys_windows_amd64.s b/src/runtime/sys_windows_amd64.s
index e9428c36db..df1462b877 100644
--- a/src/runtime/sys_windows_amd64.s
+++ b/src/runtime/sys_windows_amd64.s
@@ -202,12 +202,6 @@ TEXT runtime·lastcontinuetramp<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-0
 	MOVQ	$runtime·lastcontinuehandler(SB), AX
 	JMP	sigtramp<>(SB)
 
-TEXT runtime·profileloop<ABIInternal>(SB),NOSPLIT|NOFRAME,$8
-	MOVQ	$runtime·profileloop1(SB), CX
-	MOVQ	CX, 0(SP)
-	CALL	runtime·externalthreadhandler<ABIInternal>(SB)
-	RET
-
 TEXT runtime·externalthreadhandler<ABIInternal>(SB),NOSPLIT|NOFRAME|TOPFRAME,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
diff --git a/src/runtime/sys_windows_arm.s b/src/runtime/sys_windows_arm.s
index 304bba22e0..8914a2688f 100644
--- a/src/runtime/sys_windows_arm.s
+++ b/src/runtime/sys_windows_arm.s
@@ -233,10 +233,6 @@ TEXT runtime·lastcontinuetramp<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
 	MOVW	$runtime·lastcontinuehandler(SB), R1
 	B	sigtramp<>(SB)
 
-TEXT runtime·profileloop<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
-	MOVW	$runtime·profileloop1(SB), R1
-	B	runtime·externalthreadhandler<ABIInternal>(SB)
-
 // int32 externalthreadhandler(uint32 arg, int (*func)(uint32))
 // stack layout:
 //   +----------------+
diff --git a/src/runtime/sys_windows_arm64.s b/src/runtime/sys_windows_arm64.s
index 4512fbc8b0..70f628c27d 100644
--- a/src/runtime/sys_windows_arm64.s
+++ b/src/runtime/sys_windows_arm64.s
@@ -299,10 +299,6 @@ TEXT runtime·lastcontinuetramp(SB),NOSPLIT|NOFRAME,$0
 	MOVD	$runtime·lastcontinuehandler<ABIInternal>(SB), R1
 	B	sigtramp<>(SB)
 
-TEXT runtime·profileloop<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
-	MOVD	$runtime·profileloop1(SB), R1
-	B	runtime·externalthreadhandler<ABIInternal>(SB)
-
 // externalthreadhander called with R0 = uint32 arg, R1 = Go function f.
 // Need to call f(arg), which returns a uint32, and return it in R0.
 TEXT runtime·externalthreadhandler<ABIInternal>(SB),NOSPLIT|TOPFRAME,$96-0
-- 
GitLab


From c19759aa487f7d6f479daa00e7462425f4efc481 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Tue, 13 Apr 2021 08:44:56 -0400
Subject: [PATCH 1531/2400] runtime: eliminate externalthreadhandler

This function is no longer used.

Eliminating this actually fixes several problems:

- It made assumptions about what registers memclrNoHeapPointers would
  preserve. Besides being an abstraction violation and lurking
  maintenance issue, this actively became a problem for regabi because
  the call to memclrNoHeapPointers now happens through an ABI wrapper,
  which is generated by the compiler and hence we can't easily control
  what registers it clobbers.

- The amd64 implementation (at least), does not interact with the host
  ABI correctly. Notably, it doesn't save many of the registers that
  are callee-save in the host ABI but caller-save in the Go ABI.

- It interacts strangely with the NOSPLIT checker because it allocates
  an entire M and G on its stack. It worked around this on arm64, and
  happened to do things the NOSPLIT checker couldn't track on 386 and
  amd64, and happened to be *4 bytes* below the limit on arm (so any
  addition to the m or g structs would cause a NOSPLIT failure). See
  CL 309031 for a more complete explanation.

Fixes #45530.
Updates #40724.

Change-Id: Ic70d4d7e1c17f1d796575b3377b8529449e93576
Reviewed-on: https://go-review.googlesource.com/c/go/+/309634
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/cmd/internal/objabi/funcid.go | 44 ++++++++++----------
 src/cmd/link/internal/ld/pe.go    |  4 +-
 src/runtime/memclr_386.s          |  2 -
 src/runtime/memclr_amd64.s        |  2 -
 src/runtime/os_windows.go         |  1 -
 src/runtime/symtab.go             |  1 -
 src/runtime/sys_windows_386.s     | 51 -----------------------
 src/runtime/sys_windows_amd64.s   | 51 -----------------------
 src/runtime/sys_windows_arm.s     | 67 -------------------------------
 src/runtime/sys_windows_arm64.s   | 60 ---------------------------
 10 files changed, 22 insertions(+), 261 deletions(-)

diff --git a/src/cmd/internal/objabi/funcid.go b/src/cmd/internal/objabi/funcid.go
index 4229ae2c02..2634106cdf 100644
--- a/src/cmd/internal/objabi/funcid.go
+++ b/src/cmd/internal/objabi/funcid.go
@@ -29,7 +29,6 @@ const (
 	FuncID_asyncPreempt
 	FuncID_cgocallback
 	FuncID_debugCallV1
-	FuncID_externalthreadhandler
 	FuncID_gcBgMarkWorker
 	FuncID_goexit
 	FuncID_gogo
@@ -50,28 +49,27 @@ const (
 )
 
 var funcIDs = map[string]FuncID{
-	"abort":                 FuncID_abort,
-	"asmcgocall":            FuncID_asmcgocall,
-	"asyncPreempt":          FuncID_asyncPreempt,
-	"cgocallback":           FuncID_cgocallback,
-	"debugCallV1":           FuncID_debugCallV1,
-	"externalthreadhandler": FuncID_externalthreadhandler,
-	"gcBgMarkWorker":        FuncID_gcBgMarkWorker,
-	"go":                    FuncID_rt0_go,
-	"goexit":                FuncID_goexit,
-	"gogo":                  FuncID_gogo,
-	"gopanic":               FuncID_gopanic,
-	"handleAsyncEvent":      FuncID_handleAsyncEvent,
-	"jmpdefer":              FuncID_jmpdefer,
-	"main":                  FuncID_runtime_main,
-	"mcall":                 FuncID_mcall,
-	"morestack":             FuncID_morestack,
-	"mstart":                FuncID_mstart,
-	"panicwrap":             FuncID_panicwrap,
-	"runfinq":               FuncID_runfinq,
-	"sigpanic":              FuncID_sigpanic,
-	"switch":                FuncID_systemstack_switch,
-	"systemstack":           FuncID_systemstack,
+	"abort":            FuncID_abort,
+	"asmcgocall":       FuncID_asmcgocall,
+	"asyncPreempt":     FuncID_asyncPreempt,
+	"cgocallback":      FuncID_cgocallback,
+	"debugCallV1":      FuncID_debugCallV1,
+	"gcBgMarkWorker":   FuncID_gcBgMarkWorker,
+	"go":               FuncID_rt0_go,
+	"goexit":           FuncID_goexit,
+	"gogo":             FuncID_gogo,
+	"gopanic":          FuncID_gopanic,
+	"handleAsyncEvent": FuncID_handleAsyncEvent,
+	"jmpdefer":         FuncID_jmpdefer,
+	"main":             FuncID_runtime_main,
+	"mcall":            FuncID_mcall,
+	"morestack":        FuncID_morestack,
+	"mstart":           FuncID_mstart,
+	"panicwrap":        FuncID_panicwrap,
+	"runfinq":          FuncID_runfinq,
+	"sigpanic":         FuncID_sigpanic,
+	"switch":           FuncID_systemstack_switch,
+	"systemstack":      FuncID_systemstack,
 
 	// Don't show in call stack but otherwise not special.
 	"deferreturn":       FuncID_wrapper,
diff --git a/src/cmd/link/internal/ld/pe.go b/src/cmd/link/internal/ld/pe.go
index dc1b53010a..3ed8943828 100644
--- a/src/cmd/link/internal/ld/pe.go
+++ b/src/cmd/link/internal/ld/pe.go
@@ -947,9 +947,7 @@ func (f *peFile) writeOptionalHeader(ctxt *Link) {
 	// calls that may need more stack than we think.
 	//
 	// The default stack reserve size directly affects only the main
-	// thread and threads that enter in externalthreadhandler.
-	// For this, it must be greater than the stack size assumed by
-	// externalthreadhandler.
+	// thread.
 	//
 	// For other threads, the runtime explicitly asks the kernel
 	// to use the default stack size so that all stacks are
diff --git a/src/runtime/memclr_386.s b/src/runtime/memclr_386.s
index 5e090ef09e..d2ef17f7ce 100644
--- a/src/runtime/memclr_386.s
+++ b/src/runtime/memclr_386.s
@@ -7,8 +7,6 @@
 #include "go_asm.h"
 #include "textflag.h"
 
-// NOTE: Windows externalthreadhandler expects memclr to preserve DX.
-
 // See memclrNoHeapPointers Go doc for important implementation constraints.
 
 // func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
diff --git a/src/runtime/memclr_amd64.s b/src/runtime/memclr_amd64.s
index b4bc9988ec..5d2bebb901 100644
--- a/src/runtime/memclr_amd64.s
+++ b/src/runtime/memclr_amd64.s
@@ -7,8 +7,6 @@
 #include "go_asm.h"
 #include "textflag.h"
 
-// NOTE: Windows externalthreadhandler expects memclr to preserve DX.
-
 // See memclrNoHeapPointers Go doc for important implementation constraints.
 
 // func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
diff --git a/src/runtime/os_windows.go b/src/runtime/os_windows.go
index 5bff4b6646..bc1240f8bb 100644
--- a/src/runtime/os_windows.go
+++ b/src/runtime/os_windows.go
@@ -386,7 +386,6 @@ const (
 )
 
 // in sys_windows_386.s and sys_windows_amd64.s:
-func externalthreadhandler()
 func getlasterror() uint32
 
 // When loading DLLs, we prefer to use LoadLibraryEx with
diff --git a/src/runtime/symtab.go b/src/runtime/symtab.go
index a382cf6002..c0630c874e 100644
--- a/src/runtime/symtab.go
+++ b/src/runtime/symtab.go
@@ -317,7 +317,6 @@ const (
 	funcID_asyncPreempt
 	funcID_cgocallback
 	funcID_debugCallV1
-	funcID_externalthreadhandler
 	funcID_gcBgMarkWorker
 	funcID_goexit
 	funcID_gogo
diff --git a/src/runtime/sys_windows_386.s b/src/runtime/sys_windows_386.s
index c8839b9976..d6b521ab65 100644
--- a/src/runtime/sys_windows_386.s
+++ b/src/runtime/sys_windows_386.s
@@ -156,57 +156,6 @@ TEXT runtime·lastcontinuetramp<ABIInternal>(SB),NOSPLIT,$0-0
 	MOVL	$runtime·lastcontinuehandler(SB), AX
 	JMP	sigtramp<>(SB)
 
-TEXT runtime·externalthreadhandler<ABIInternal>(SB),NOSPLIT|TOPFRAME,$0
-	PUSHL	BP
-	MOVL	SP, BP
-	PUSHL	BX
-	PUSHL	SI
-	PUSHL	DI
-	PUSHL	0x14(FS)
-	MOVL	SP, DX
-
-	// setup dummy m, g
-	SUBL	$m__size, SP		// space for M
-	MOVL	SP, 0(SP)
-	MOVL	$m__size, 4(SP)
-	CALL	runtime·memclrNoHeapPointers(SB)	// smashes AX,BX,CX
-
-	LEAL	m_tls(SP), CX
-	MOVL	CX, 0x14(FS)
-	MOVL	SP, BX
-	SUBL	$g__size, SP		// space for G
-	MOVL	SP, g(CX)
-	MOVL	SP, m_g0(BX)
-
-	MOVL	SP, 0(SP)
-	MOVL	$g__size, 4(SP)
-	CALL	runtime·memclrNoHeapPointers(SB)	// smashes AX,BX,CX
-	LEAL	g__size(SP), BX
-	MOVL	BX, g_m(SP)
-
-	LEAL	-32768(SP), CX		// must be less than SizeOfStackReserve set by linker
-	MOVL	CX, (g_stack+stack_lo)(SP)
-	ADDL	$const__StackGuard, CX
-	MOVL	CX, g_stackguard0(SP)
-	MOVL	CX, g_stackguard1(SP)
-	MOVL	DX, (g_stack+stack_hi)(SP)
-
-	PUSHL	AX			// room for return value
-	PUSHL	16(BP)			// arg for handler
-	CALL	8(BP)
-	POPL	CX
-	POPL	AX			// pass return value to Windows in AX
-
-	get_tls(CX)
-	MOVL	g(CX), CX
-	MOVL	(g_stack+stack_hi)(CX), SP
-	POPL	0x14(FS)
-	POPL	DI
-	POPL	SI
-	POPL	BX
-	POPL	BP
-	RET
-
 GLOBL runtime·cbctxts(SB), NOPTR, $4
 
 TEXT runtime·callbackasm1<ABIInternal>(SB),NOSPLIT,$0
diff --git a/src/runtime/sys_windows_amd64.s b/src/runtime/sys_windows_amd64.s
index df1462b877..f7250c65a8 100644
--- a/src/runtime/sys_windows_amd64.s
+++ b/src/runtime/sys_windows_amd64.s
@@ -202,57 +202,6 @@ TEXT runtime·lastcontinuetramp<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-0
 	MOVQ	$runtime·lastcontinuehandler(SB), AX
 	JMP	sigtramp<>(SB)
 
-TEXT runtime·externalthreadhandler<ABIInternal>(SB),NOSPLIT|NOFRAME|TOPFRAME,$0
-	PUSHQ	BP
-	MOVQ	SP, BP
-	PUSHQ	BX
-	PUSHQ	SI
-	PUSHQ	DI
-	PUSHQ	0x28(GS)
-	MOVQ	SP, DX
-
-	// setup dummy m, g
-	SUBQ	$m__size, SP		// space for M
-	MOVQ	SP, 0(SP)
-	MOVQ	$m__size, 8(SP)
-	CALL	runtime·memclrNoHeapPointers(SB)	// smashes AX,BX,CX, maybe BP
-
-	LEAQ	m_tls(SP), CX
-	MOVQ	CX, 0x28(GS)
-	MOVQ	SP, BX
-	SUBQ	$g__size, SP		// space for G
-	MOVQ	SP, g(CX)
-	MOVQ	SP, m_g0(BX)
-
-	MOVQ	SP, 0(SP)
-	MOVQ	$g__size, 8(SP)
-	CALL	runtime·memclrNoHeapPointers(SB)	// smashes AX,BX,CX, maybe BP
-	LEAQ	g__size(SP), BX
-	MOVQ	BX, g_m(SP)
-
-	LEAQ	-32768(SP), CX		// must be less than SizeOfStackReserve set by linker
-	MOVQ	CX, (g_stack+stack_lo)(SP)
-	ADDQ	$const__StackGuard, CX
-	MOVQ	CX, g_stackguard0(SP)
-	MOVQ	CX, g_stackguard1(SP)
-	MOVQ	DX, (g_stack+stack_hi)(SP)
-
-	PUSHQ	AX			// room for return value
-	PUSHQ	32(BP)			// arg for handler
-	CALL	16(BP)
-	POPQ	CX
-	POPQ	AX			// pass return value to Windows in AX
-
-	get_tls(CX)
-	MOVQ	g(CX), CX
-	MOVQ	(g_stack+stack_hi)(CX), SP
-	POPQ	0x28(GS)
-	POPQ	DI
-	POPQ	SI
-	POPQ	BX
-	POPQ	BP
-	RET
-
 GLOBL runtime·cbctxts(SB), NOPTR, $8
 
 TEXT runtime·callbackasm1(SB),NOSPLIT,$0
diff --git a/src/runtime/sys_windows_arm.s b/src/runtime/sys_windows_arm.s
index 8914a2688f..8073fc0198 100644
--- a/src/runtime/sys_windows_arm.s
+++ b/src/runtime/sys_windows_arm.s
@@ -233,73 +233,6 @@ TEXT runtime·lastcontinuetramp<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
 	MOVW	$runtime·lastcontinuehandler(SB), R1
 	B	sigtramp<>(SB)
 
-// int32 externalthreadhandler(uint32 arg, int (*func)(uint32))
-// stack layout:
-//   +----------------+
-//   | callee-save    |
-//   | registers      |
-//   +----------------+
-//   | m              |
-//   +----------------+
-// 20| g              |
-//   +----------------+
-// 16| func ptr (r1)  |
-//   +----------------+
-// 12| argument (r0)  |
-//---+----------------+
-// 8 | param1         | (also return value for called Go function)
-//   +----------------+
-// 4 | param0         |
-//   +----------------+
-// 0 | slot for LR    |
-//   +----------------+
-//
-TEXT runtime·externalthreadhandler<ABIInternal>(SB),NOSPLIT|NOFRAME|TOPFRAME,$0
-	MOVM.DB.W [R4-R11, R14], (R13)		// push {r4-r11, lr}
-	SUB	$(m__size + g__size + 20), R13	// space for locals
-	MOVW	R14, 0(R13)			// push LR again for anything unwinding the stack
-	MOVW	R0, 12(R13)
-	MOVW	R1, 16(R13)
-
-	// zero out m and g structures
-	ADD	$20, R13, R0			// compute pointer to g
-	MOVW	R0, 4(R13)
-	MOVW	$(m__size + g__size), R0
-	MOVW	R0, 8(R13)
-	BL	runtime·memclrNoHeapPointers(SB)
-
-	// initialize m and g structures
-	ADD	$20, R13, R2			// R2 = g
-	ADD	$(20 + g__size), R13, R3	// R3 = m
-	MOVW	R2, m_g0(R3)			// m->g0 = g
-	MOVW	R3, g_m(R2)			// g->m = m
-	MOVW	R2, m_curg(R3)			// m->curg = g
-
-	MOVW	R2, g
-	BL	runtime·save_g(SB)
-
-	// set up stackguard stuff
-	MOVW	R13, R0
-	MOVW	R0, g_stack+stack_hi(g)
-	SUB	$(32*1024), R0
-	MOVW	R0, (g_stack+stack_lo)(g)
-	MOVW	R0, g_stackguard0(g)
-	MOVW	R0, g_stackguard1(g)
-
-	// move argument into position and call function
-	MOVW	12(R13), R0
-	MOVW	R0, 4(R13)
-	MOVW	16(R13), R1
-	BL	(R1)
-
-	// clear g
-	MOVW	$0, g
-	BL	runtime·save_g(SB)
-
-	MOVW	8(R13), R0			// load return value
-	ADD	$(m__size + g__size + 20), R13	// free locals
-	MOVM.IA.W (R13), [R4-R11, R15]		// pop {r4-r11, pc}
-
 GLOBL runtime·cbctxts(SB), NOPTR, $4
 
 TEXT runtime·callbackasm1<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
diff --git a/src/runtime/sys_windows_arm64.s b/src/runtime/sys_windows_arm64.s
index 70f628c27d..6b28a0c2ef 100644
--- a/src/runtime/sys_windows_arm64.s
+++ b/src/runtime/sys_windows_arm64.s
@@ -299,66 +299,6 @@ TEXT runtime·lastcontinuetramp(SB),NOSPLIT|NOFRAME,$0
 	MOVD	$runtime·lastcontinuehandler<ABIInternal>(SB), R1
 	B	sigtramp<>(SB)
 
-// externalthreadhander called with R0 = uint32 arg, R1 = Go function f.
-// Need to call f(arg), which returns a uint32, and return it in R0.
-TEXT runtime·externalthreadhandler<ABIInternal>(SB),NOSPLIT|TOPFRAME,$96-0
-	NO_LOCAL_POINTERS
-
-	// Push C callee-save registers R19-R28. LR, FP already saved.
-	SAVE_R19_TO_R28(-10*8)
-
-	// Allocate space for args, saved R0+R1, g, and m structures.
-	// Hide from nosplit check.
-	#define extra ((64+g__size+m__size+15)&~15)
-	SUB	$extra, RSP, R2	// hide from nosplit overflow check
-	MOVD	R2, RSP
-
-	// Save R0 and R1 (our args).
-	MOVD	R0, 32(RSP)
-	MOVD	R1, 40(RSP)
-
-	// Zero out m and g structures.
-	MOVD	$64(RSP), R0
-	MOVD	R0, 8(RSP)
-	MOVD	$(m__size + g__size), R0
-	MOVD	R0, 16(RSP)
-	MOVD	$0, 0(RSP)	// not-saved LR
-	BL	runtime·memclrNoHeapPointers(SB)
-
-	// Initialize m and g structures.
-	MOVD	$64(RSP), g
-	MOVD	$g__size(g), R3		// m
-	MOVD	R3, g_m(g)		// g->m = m
-	MOVD	g, m_g0(R3)		// m->g0 = g
-	MOVD	g, m_curg(R3)		// m->curg = g
-	MOVD	RSP, R0
-	MOVD	R0, g_stack+stack_hi(g)
-	SUB	$(32*1024), R0
-	MOVD	R0, (g_stack+stack_lo)(g)
-	MOVD	R0, g_stackguard0(g)
-	MOVD	R0, g_stackguard1(g)
-	BL	runtime·save_g(SB)
-
-	// Call function.
-	MOVD	32(RSP), R0
-	MOVD	40(RSP), R1
-	MOVW	R0, 8(RSP)
-	BL	(R1)
-
-	// Clear g.
-	MOVD	$0, g
-	BL	runtime·save_g(SB)
-
-	// Load return value (save_g would have smashed)
-	MOVW	(2*8)(RSP), R0
-
-	ADD	$extra, RSP, R2
-	MOVD	R2, RSP
-	#undef extra
-
-	RESTORE_R19_TO_R28(-10*8)
-	RET
-
 GLOBL runtime·cbctxts(SB), NOPTR, $4
 
 TEXT runtime·callbackasm1<ABIInternal>(SB),NOSPLIT,$208-0
-- 
GitLab


From 9913f821e23e9e26b84ce2b96698140116ee342b Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Mon, 12 Apr 2021 16:12:20 -0400
Subject: [PATCH 1532/2400] cmd/compile: make map functions ABI insensitive

Following CL 309029, this CL does the same thing for map
functions (mapaccess, mapassign, mapdelete).

For simplicity, always wrap "defer delete(m, k)". With
regabidefers enabled, this call is wrapped in a closure and the
rewriting happens automatically. Without regabidefers, it may not
be wrapped for certain key types, and then we'd need special
handling of the delete (because earlier the order pass does not
handle it). And we will turn on defer wrapping by default anyway.

Change-Id: I30663b1aa8e1d6f98e1fb81bf8c0c0ce607ab80b
Reviewed-on: https://go-review.googlesource.com/c/go/+/309510
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/typecheck/builtin.go | 313 +++++++++---------
 .../internal/typecheck/builtin/runtime.go     |  28 +-
 src/cmd/compile/internal/walk/assign.go       |   4 +-
 src/cmd/compile/internal/walk/complit.go      |  10 +-
 src/cmd/compile/internal/walk/expr.go         |  12 +-
 src/cmd/compile/internal/walk/order.go        |  46 ++-
 src/cmd/compile/internal/walk/stmt.go         |   6 +-
 src/cmd/compile/internal/walk/walk.go         |  26 +-
 8 files changed, 248 insertions(+), 197 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/builtin.go b/src/cmd/compile/internal/typecheck/builtin.go
index 878239d378..d83791df8b 100644
--- a/src/cmd/compile/internal/typecheck/builtin.go
+++ b/src/cmd/compile/internal/typecheck/builtin.go
@@ -95,109 +95,109 @@ var runtimeDecls = [...]struct {
 	{"makemap_small", funcTag, 77},
 	{"mapaccess1", funcTag, 78},
 	{"mapaccess1_fast32", funcTag, 79},
-	{"mapaccess1_fast64", funcTag, 79},
-	{"mapaccess1_faststr", funcTag, 79},
-	{"mapaccess1_fat", funcTag, 80},
-	{"mapaccess2", funcTag, 81},
-	{"mapaccess2_fast32", funcTag, 82},
-	{"mapaccess2_fast64", funcTag, 82},
-	{"mapaccess2_faststr", funcTag, 82},
-	{"mapaccess2_fat", funcTag, 83},
+	{"mapaccess1_fast64", funcTag, 80},
+	{"mapaccess1_faststr", funcTag, 81},
+	{"mapaccess1_fat", funcTag, 82},
+	{"mapaccess2", funcTag, 83},
+	{"mapaccess2_fast32", funcTag, 84},
+	{"mapaccess2_fast64", funcTag, 85},
+	{"mapaccess2_faststr", funcTag, 86},
+	{"mapaccess2_fat", funcTag, 87},
 	{"mapassign", funcTag, 78},
 	{"mapassign_fast32", funcTag, 79},
-	{"mapassign_fast32ptr", funcTag, 79},
-	{"mapassign_fast64", funcTag, 79},
-	{"mapassign_fast64ptr", funcTag, 79},
-	{"mapassign_faststr", funcTag, 79},
-	{"mapiterinit", funcTag, 84},
-	{"mapdelete", funcTag, 84},
-	{"mapdelete_fast32", funcTag, 85},
-	{"mapdelete_fast64", funcTag, 85},
-	{"mapdelete_faststr", funcTag, 85},
-	{"mapiternext", funcTag, 86},
-	{"mapclear", funcTag, 87},
-	{"makechan64", funcTag, 89},
-	{"makechan", funcTag, 90},
-	{"chanrecv1", funcTag, 92},
-	{"chanrecv2", funcTag, 93},
-	{"chansend1", funcTag, 95},
+	{"mapassign_fast32ptr", funcTag, 88},
+	{"mapassign_fast64", funcTag, 80},
+	{"mapassign_fast64ptr", funcTag, 88},
+	{"mapassign_faststr", funcTag, 81},
+	{"mapiterinit", funcTag, 89},
+	{"mapdelete", funcTag, 89},
+	{"mapdelete_fast32", funcTag, 90},
+	{"mapdelete_fast64", funcTag, 91},
+	{"mapdelete_faststr", funcTag, 92},
+	{"mapiternext", funcTag, 93},
+	{"mapclear", funcTag, 94},
+	{"makechan64", funcTag, 96},
+	{"makechan", funcTag, 97},
+	{"chanrecv1", funcTag, 99},
+	{"chanrecv2", funcTag, 100},
+	{"chansend1", funcTag, 102},
 	{"closechan", funcTag, 30},
-	{"writeBarrier", varTag, 97},
-	{"typedmemmove", funcTag, 98},
-	{"typedmemclr", funcTag, 99},
-	{"typedslicecopy", funcTag, 100},
-	{"selectnbsend", funcTag, 101},
-	{"selectnbrecv", funcTag, 102},
-	{"selectsetpc", funcTag, 103},
-	{"selectgo", funcTag, 104},
+	{"writeBarrier", varTag, 104},
+	{"typedmemmove", funcTag, 105},
+	{"typedmemclr", funcTag, 106},
+	{"typedslicecopy", funcTag, 107},
+	{"selectnbsend", funcTag, 108},
+	{"selectnbrecv", funcTag, 109},
+	{"selectsetpc", funcTag, 110},
+	{"selectgo", funcTag, 111},
 	{"block", funcTag, 9},
-	{"makeslice", funcTag, 105},
-	{"makeslice64", funcTag, 106},
-	{"makeslicecopy", funcTag, 107},
-	{"growslice", funcTag, 109},
-	{"memmove", funcTag, 110},
-	{"memclrNoHeapPointers", funcTag, 111},
-	{"memclrHasPointers", funcTag, 111},
-	{"memequal", funcTag, 112},
-	{"memequal0", funcTag, 113},
-	{"memequal8", funcTag, 113},
-	{"memequal16", funcTag, 113},
-	{"memequal32", funcTag, 113},
-	{"memequal64", funcTag, 113},
-	{"memequal128", funcTag, 113},
-	{"f32equal", funcTag, 114},
-	{"f64equal", funcTag, 114},
-	{"c64equal", funcTag, 114},
-	{"c128equal", funcTag, 114},
-	{"strequal", funcTag, 114},
-	{"interequal", funcTag, 114},
-	{"nilinterequal", funcTag, 114},
-	{"memhash", funcTag, 115},
-	{"memhash0", funcTag, 116},
-	{"memhash8", funcTag, 116},
-	{"memhash16", funcTag, 116},
-	{"memhash32", funcTag, 116},
-	{"memhash64", funcTag, 116},
-	{"memhash128", funcTag, 116},
-	{"f32hash", funcTag, 116},
-	{"f64hash", funcTag, 116},
-	{"c64hash", funcTag, 116},
-	{"c128hash", funcTag, 116},
-	{"strhash", funcTag, 116},
-	{"interhash", funcTag, 116},
-	{"nilinterhash", funcTag, 116},
-	{"int64div", funcTag, 117},
-	{"uint64div", funcTag, 118},
-	{"int64mod", funcTag, 117},
-	{"uint64mod", funcTag, 118},
-	{"float64toint64", funcTag, 119},
-	{"float64touint64", funcTag, 120},
-	{"float64touint32", funcTag, 121},
-	{"int64tofloat64", funcTag, 122},
-	{"uint64tofloat64", funcTag, 123},
-	{"uint32tofloat64", funcTag, 124},
-	{"complex128div", funcTag, 125},
-	{"getcallerpc", funcTag, 126},
-	{"getcallersp", funcTag, 126},
+	{"makeslice", funcTag, 112},
+	{"makeslice64", funcTag, 113},
+	{"makeslicecopy", funcTag, 114},
+	{"growslice", funcTag, 116},
+	{"memmove", funcTag, 117},
+	{"memclrNoHeapPointers", funcTag, 118},
+	{"memclrHasPointers", funcTag, 118},
+	{"memequal", funcTag, 119},
+	{"memequal0", funcTag, 120},
+	{"memequal8", funcTag, 120},
+	{"memequal16", funcTag, 120},
+	{"memequal32", funcTag, 120},
+	{"memequal64", funcTag, 120},
+	{"memequal128", funcTag, 120},
+	{"f32equal", funcTag, 121},
+	{"f64equal", funcTag, 121},
+	{"c64equal", funcTag, 121},
+	{"c128equal", funcTag, 121},
+	{"strequal", funcTag, 121},
+	{"interequal", funcTag, 121},
+	{"nilinterequal", funcTag, 121},
+	{"memhash", funcTag, 122},
+	{"memhash0", funcTag, 123},
+	{"memhash8", funcTag, 123},
+	{"memhash16", funcTag, 123},
+	{"memhash32", funcTag, 123},
+	{"memhash64", funcTag, 123},
+	{"memhash128", funcTag, 123},
+	{"f32hash", funcTag, 123},
+	{"f64hash", funcTag, 123},
+	{"c64hash", funcTag, 123},
+	{"c128hash", funcTag, 123},
+	{"strhash", funcTag, 123},
+	{"interhash", funcTag, 123},
+	{"nilinterhash", funcTag, 123},
+	{"int64div", funcTag, 124},
+	{"uint64div", funcTag, 125},
+	{"int64mod", funcTag, 124},
+	{"uint64mod", funcTag, 125},
+	{"float64toint64", funcTag, 126},
+	{"float64touint64", funcTag, 127},
+	{"float64touint32", funcTag, 128},
+	{"int64tofloat64", funcTag, 129},
+	{"uint64tofloat64", funcTag, 130},
+	{"uint32tofloat64", funcTag, 131},
+	{"complex128div", funcTag, 132},
+	{"getcallerpc", funcTag, 133},
+	{"getcallersp", funcTag, 133},
 	{"racefuncenter", funcTag, 31},
 	{"racefuncexit", funcTag, 9},
 	{"raceread", funcTag, 31},
 	{"racewrite", funcTag, 31},
-	{"racereadrange", funcTag, 127},
-	{"racewriterange", funcTag, 127},
-	{"msanread", funcTag, 127},
-	{"msanwrite", funcTag, 127},
-	{"msanmove", funcTag, 128},
-	{"checkptrAlignment", funcTag, 129},
-	{"checkptrArithmetic", funcTag, 131},
-	{"libfuzzerTraceCmp1", funcTag, 132},
-	{"libfuzzerTraceCmp2", funcTag, 133},
-	{"libfuzzerTraceCmp4", funcTag, 134},
-	{"libfuzzerTraceCmp8", funcTag, 135},
-	{"libfuzzerTraceConstCmp1", funcTag, 132},
-	{"libfuzzerTraceConstCmp2", funcTag, 133},
-	{"libfuzzerTraceConstCmp4", funcTag, 134},
-	{"libfuzzerTraceConstCmp8", funcTag, 135},
+	{"racereadrange", funcTag, 134},
+	{"racewriterange", funcTag, 134},
+	{"msanread", funcTag, 134},
+	{"msanwrite", funcTag, 134},
+	{"msanmove", funcTag, 135},
+	{"checkptrAlignment", funcTag, 136},
+	{"checkptrArithmetic", funcTag, 138},
+	{"libfuzzerTraceCmp1", funcTag, 139},
+	{"libfuzzerTraceCmp2", funcTag, 140},
+	{"libfuzzerTraceCmp4", funcTag, 141},
+	{"libfuzzerTraceCmp8", funcTag, 142},
+	{"libfuzzerTraceConstCmp1", funcTag, 139},
+	{"libfuzzerTraceConstCmp2", funcTag, 140},
+	{"libfuzzerTraceConstCmp4", funcTag, 141},
+	{"libfuzzerTraceConstCmp8", funcTag, 142},
 	{"x86HasPOPCNT", varTag, 6},
 	{"x86HasSSE41", varTag, 6},
 	{"x86HasFMA", varTag, 6},
@@ -220,7 +220,7 @@ func params(tlist ...*types.Type) []*types.Field {
 }
 
 func runtimeTypes() []*types.Type {
-	var typs [136]*types.Type
+	var typs [143]*types.Type
 	typs[0] = types.ByteType
 	typs[1] = types.NewPtr(typs[0])
 	typs[2] = types.Types[types.TANY]
@@ -300,62 +300,69 @@ func runtimeTypes() []*types.Type {
 	typs[76] = newSig(params(typs[1], typs[15], typs[3]), params(typs[74]))
 	typs[77] = newSig(nil, params(typs[74]))
 	typs[78] = newSig(params(typs[1], typs[74], typs[3]), params(typs[3]))
-	typs[79] = newSig(params(typs[1], typs[74], typs[2]), params(typs[3]))
-	typs[80] = newSig(params(typs[1], typs[74], typs[3], typs[1]), params(typs[3]))
-	typs[81] = newSig(params(typs[1], typs[74], typs[3]), params(typs[3], typs[6]))
-	typs[82] = newSig(params(typs[1], typs[74], typs[2]), params(typs[3], typs[6]))
-	typs[83] = newSig(params(typs[1], typs[74], typs[3], typs[1]), params(typs[3], typs[6]))
-	typs[84] = newSig(params(typs[1], typs[74], typs[3]), nil)
-	typs[85] = newSig(params(typs[1], typs[74], typs[2]), nil)
-	typs[86] = newSig(params(typs[3]), nil)
-	typs[87] = newSig(params(typs[1], typs[74]), nil)
-	typs[88] = types.NewChan(typs[2], types.Cboth)
-	typs[89] = newSig(params(typs[1], typs[22]), params(typs[88]))
-	typs[90] = newSig(params(typs[1], typs[15]), params(typs[88]))
-	typs[91] = types.NewChan(typs[2], types.Crecv)
-	typs[92] = newSig(params(typs[91], typs[3]), nil)
-	typs[93] = newSig(params(typs[91], typs[3]), params(typs[6]))
-	typs[94] = types.NewChan(typs[2], types.Csend)
-	typs[95] = newSig(params(typs[94], typs[3]), nil)
-	typs[96] = types.NewArray(typs[0], 3)
-	typs[97] = types.NewStruct(types.NoPkg, []*types.Field{types.NewField(src.NoXPos, Lookup("enabled"), typs[6]), types.NewField(src.NoXPos, Lookup("pad"), typs[96]), types.NewField(src.NoXPos, Lookup("needed"), typs[6]), types.NewField(src.NoXPos, Lookup("cgo"), typs[6]), types.NewField(src.NoXPos, Lookup("alignme"), typs[24])})
-	typs[98] = newSig(params(typs[1], typs[3], typs[3]), nil)
-	typs[99] = newSig(params(typs[1], typs[3]), nil)
-	typs[100] = newSig(params(typs[1], typs[3], typs[15], typs[3], typs[15]), params(typs[15]))
-	typs[101] = newSig(params(typs[94], typs[3]), params(typs[6]))
-	typs[102] = newSig(params(typs[3], typs[91]), params(typs[6], typs[6]))
-	typs[103] = newSig(params(typs[71]), nil)
-	typs[104] = newSig(params(typs[1], typs[1], typs[71], typs[15], typs[15], typs[6]), params(typs[15], typs[6]))
-	typs[105] = newSig(params(typs[1], typs[15], typs[15]), params(typs[7]))
-	typs[106] = newSig(params(typs[1], typs[22], typs[22]), params(typs[7]))
-	typs[107] = newSig(params(typs[1], typs[15], typs[15], typs[7]), params(typs[7]))
-	typs[108] = types.NewSlice(typs[2])
-	typs[109] = newSig(params(typs[1], typs[108], typs[15]), params(typs[108]))
-	typs[110] = newSig(params(typs[3], typs[3], typs[5]), nil)
-	typs[111] = newSig(params(typs[7], typs[5]), nil)
-	typs[112] = newSig(params(typs[3], typs[3], typs[5]), params(typs[6]))
-	typs[113] = newSig(params(typs[3], typs[3]), params(typs[6]))
-	typs[114] = newSig(params(typs[7], typs[7]), params(typs[6]))
-	typs[115] = newSig(params(typs[7], typs[5], typs[5]), params(typs[5]))
-	typs[116] = newSig(params(typs[7], typs[5]), params(typs[5]))
-	typs[117] = newSig(params(typs[22], typs[22]), params(typs[22]))
-	typs[118] = newSig(params(typs[24], typs[24]), params(typs[24]))
-	typs[119] = newSig(params(typs[20]), params(typs[22]))
-	typs[120] = newSig(params(typs[20]), params(typs[24]))
-	typs[121] = newSig(params(typs[20]), params(typs[60]))
-	typs[122] = newSig(params(typs[22]), params(typs[20]))
-	typs[123] = newSig(params(typs[24]), params(typs[20]))
-	typs[124] = newSig(params(typs[60]), params(typs[20]))
-	typs[125] = newSig(params(typs[26], typs[26]), params(typs[26]))
-	typs[126] = newSig(nil, params(typs[5]))
-	typs[127] = newSig(params(typs[5], typs[5]), nil)
-	typs[128] = newSig(params(typs[5], typs[5], typs[5]), nil)
-	typs[129] = newSig(params(typs[7], typs[1], typs[5]), nil)
-	typs[130] = types.NewSlice(typs[7])
-	typs[131] = newSig(params(typs[7], typs[130]), nil)
-	typs[132] = newSig(params(typs[64], typs[64]), nil)
-	typs[133] = newSig(params(typs[58], typs[58]), nil)
-	typs[134] = newSig(params(typs[60], typs[60]), nil)
-	typs[135] = newSig(params(typs[24], typs[24]), nil)
+	typs[79] = newSig(params(typs[1], typs[74], typs[60]), params(typs[3]))
+	typs[80] = newSig(params(typs[1], typs[74], typs[24]), params(typs[3]))
+	typs[81] = newSig(params(typs[1], typs[74], typs[28]), params(typs[3]))
+	typs[82] = newSig(params(typs[1], typs[74], typs[3], typs[1]), params(typs[3]))
+	typs[83] = newSig(params(typs[1], typs[74], typs[3]), params(typs[3], typs[6]))
+	typs[84] = newSig(params(typs[1], typs[74], typs[60]), params(typs[3], typs[6]))
+	typs[85] = newSig(params(typs[1], typs[74], typs[24]), params(typs[3], typs[6]))
+	typs[86] = newSig(params(typs[1], typs[74], typs[28]), params(typs[3], typs[6]))
+	typs[87] = newSig(params(typs[1], typs[74], typs[3], typs[1]), params(typs[3], typs[6]))
+	typs[88] = newSig(params(typs[1], typs[74], typs[7]), params(typs[3]))
+	typs[89] = newSig(params(typs[1], typs[74], typs[3]), nil)
+	typs[90] = newSig(params(typs[1], typs[74], typs[60]), nil)
+	typs[91] = newSig(params(typs[1], typs[74], typs[24]), nil)
+	typs[92] = newSig(params(typs[1], typs[74], typs[28]), nil)
+	typs[93] = newSig(params(typs[3]), nil)
+	typs[94] = newSig(params(typs[1], typs[74]), nil)
+	typs[95] = types.NewChan(typs[2], types.Cboth)
+	typs[96] = newSig(params(typs[1], typs[22]), params(typs[95]))
+	typs[97] = newSig(params(typs[1], typs[15]), params(typs[95]))
+	typs[98] = types.NewChan(typs[2], types.Crecv)
+	typs[99] = newSig(params(typs[98], typs[3]), nil)
+	typs[100] = newSig(params(typs[98], typs[3]), params(typs[6]))
+	typs[101] = types.NewChan(typs[2], types.Csend)
+	typs[102] = newSig(params(typs[101], typs[3]), nil)
+	typs[103] = types.NewArray(typs[0], 3)
+	typs[104] = types.NewStruct(types.NoPkg, []*types.Field{types.NewField(src.NoXPos, Lookup("enabled"), typs[6]), types.NewField(src.NoXPos, Lookup("pad"), typs[103]), types.NewField(src.NoXPos, Lookup("needed"), typs[6]), types.NewField(src.NoXPos, Lookup("cgo"), typs[6]), types.NewField(src.NoXPos, Lookup("alignme"), typs[24])})
+	typs[105] = newSig(params(typs[1], typs[3], typs[3]), nil)
+	typs[106] = newSig(params(typs[1], typs[3]), nil)
+	typs[107] = newSig(params(typs[1], typs[3], typs[15], typs[3], typs[15]), params(typs[15]))
+	typs[108] = newSig(params(typs[101], typs[3]), params(typs[6]))
+	typs[109] = newSig(params(typs[3], typs[98]), params(typs[6], typs[6]))
+	typs[110] = newSig(params(typs[71]), nil)
+	typs[111] = newSig(params(typs[1], typs[1], typs[71], typs[15], typs[15], typs[6]), params(typs[15], typs[6]))
+	typs[112] = newSig(params(typs[1], typs[15], typs[15]), params(typs[7]))
+	typs[113] = newSig(params(typs[1], typs[22], typs[22]), params(typs[7]))
+	typs[114] = newSig(params(typs[1], typs[15], typs[15], typs[7]), params(typs[7]))
+	typs[115] = types.NewSlice(typs[2])
+	typs[116] = newSig(params(typs[1], typs[115], typs[15]), params(typs[115]))
+	typs[117] = newSig(params(typs[3], typs[3], typs[5]), nil)
+	typs[118] = newSig(params(typs[7], typs[5]), nil)
+	typs[119] = newSig(params(typs[3], typs[3], typs[5]), params(typs[6]))
+	typs[120] = newSig(params(typs[3], typs[3]), params(typs[6]))
+	typs[121] = newSig(params(typs[7], typs[7]), params(typs[6]))
+	typs[122] = newSig(params(typs[7], typs[5], typs[5]), params(typs[5]))
+	typs[123] = newSig(params(typs[7], typs[5]), params(typs[5]))
+	typs[124] = newSig(params(typs[22], typs[22]), params(typs[22]))
+	typs[125] = newSig(params(typs[24], typs[24]), params(typs[24]))
+	typs[126] = newSig(params(typs[20]), params(typs[22]))
+	typs[127] = newSig(params(typs[20]), params(typs[24]))
+	typs[128] = newSig(params(typs[20]), params(typs[60]))
+	typs[129] = newSig(params(typs[22]), params(typs[20]))
+	typs[130] = newSig(params(typs[24]), params(typs[20]))
+	typs[131] = newSig(params(typs[60]), params(typs[20]))
+	typs[132] = newSig(params(typs[26], typs[26]), params(typs[26]))
+	typs[133] = newSig(nil, params(typs[5]))
+	typs[134] = newSig(params(typs[5], typs[5]), nil)
+	typs[135] = newSig(params(typs[5], typs[5], typs[5]), nil)
+	typs[136] = newSig(params(typs[7], typs[1], typs[5]), nil)
+	typs[137] = types.NewSlice(typs[7])
+	typs[138] = newSig(params(typs[7], typs[137]), nil)
+	typs[139] = newSig(params(typs[64], typs[64]), nil)
+	typs[140] = newSig(params(typs[58], typs[58]), nil)
+	typs[141] = newSig(params(typs[60], typs[60]), nil)
+	typs[142] = newSig(params(typs[24], typs[24]), nil)
 	return typs[:]
 }
diff --git a/src/cmd/compile/internal/typecheck/builtin/runtime.go b/src/cmd/compile/internal/typecheck/builtin/runtime.go
index b7fb2e6044..183ae40456 100644
--- a/src/cmd/compile/internal/typecheck/builtin/runtime.go
+++ b/src/cmd/compile/internal/typecheck/builtin/runtime.go
@@ -127,26 +127,26 @@ func makemap64(mapType *byte, hint int64, mapbuf *any) (hmap map[any]any)
 func makemap(mapType *byte, hint int, mapbuf *any) (hmap map[any]any)
 func makemap_small() (hmap map[any]any)
 func mapaccess1(mapType *byte, hmap map[any]any, key *any) (val *any)
-func mapaccess1_fast32(mapType *byte, hmap map[any]any, key any) (val *any)
-func mapaccess1_fast64(mapType *byte, hmap map[any]any, key any) (val *any)
-func mapaccess1_faststr(mapType *byte, hmap map[any]any, key any) (val *any)
+func mapaccess1_fast32(mapType *byte, hmap map[any]any, key uint32) (val *any)
+func mapaccess1_fast64(mapType *byte, hmap map[any]any, key uint64) (val *any)
+func mapaccess1_faststr(mapType *byte, hmap map[any]any, key string) (val *any)
 func mapaccess1_fat(mapType *byte, hmap map[any]any, key *any, zero *byte) (val *any)
 func mapaccess2(mapType *byte, hmap map[any]any, key *any) (val *any, pres bool)
-func mapaccess2_fast32(mapType *byte, hmap map[any]any, key any) (val *any, pres bool)
-func mapaccess2_fast64(mapType *byte, hmap map[any]any, key any) (val *any, pres bool)
-func mapaccess2_faststr(mapType *byte, hmap map[any]any, key any) (val *any, pres bool)
+func mapaccess2_fast32(mapType *byte, hmap map[any]any, key uint32) (val *any, pres bool)
+func mapaccess2_fast64(mapType *byte, hmap map[any]any, key uint64) (val *any, pres bool)
+func mapaccess2_faststr(mapType *byte, hmap map[any]any, key string) (val *any, pres bool)
 func mapaccess2_fat(mapType *byte, hmap map[any]any, key *any, zero *byte) (val *any, pres bool)
 func mapassign(mapType *byte, hmap map[any]any, key *any) (val *any)
-func mapassign_fast32(mapType *byte, hmap map[any]any, key any) (val *any)
-func mapassign_fast32ptr(mapType *byte, hmap map[any]any, key any) (val *any)
-func mapassign_fast64(mapType *byte, hmap map[any]any, key any) (val *any)
-func mapassign_fast64ptr(mapType *byte, hmap map[any]any, key any) (val *any)
-func mapassign_faststr(mapType *byte, hmap map[any]any, key any) (val *any)
+func mapassign_fast32(mapType *byte, hmap map[any]any, key uint32) (val *any)
+func mapassign_fast32ptr(mapType *byte, hmap map[any]any, key unsafe.Pointer) (val *any)
+func mapassign_fast64(mapType *byte, hmap map[any]any, key uint64) (val *any)
+func mapassign_fast64ptr(mapType *byte, hmap map[any]any, key unsafe.Pointer) (val *any)
+func mapassign_faststr(mapType *byte, hmap map[any]any, key string) (val *any)
 func mapiterinit(mapType *byte, hmap map[any]any, hiter *any)
 func mapdelete(mapType *byte, hmap map[any]any, key *any)
-func mapdelete_fast32(mapType *byte, hmap map[any]any, key any)
-func mapdelete_fast64(mapType *byte, hmap map[any]any, key any)
-func mapdelete_faststr(mapType *byte, hmap map[any]any, key any)
+func mapdelete_fast32(mapType *byte, hmap map[any]any, key uint32)
+func mapdelete_fast64(mapType *byte, hmap map[any]any, key uint64)
+func mapdelete_faststr(mapType *byte, hmap map[any]any, key string)
 func mapiternext(hiter *any)
 func mapclear(mapType *byte, hmap map[any]any)
 
diff --git a/src/cmd/compile/internal/walk/assign.go b/src/cmd/compile/internal/walk/assign.go
index 44622c741d..8550cfb5c8 100644
--- a/src/cmd/compile/internal/walk/assign.go
+++ b/src/cmd/compile/internal/walk/assign.go
@@ -176,10 +176,10 @@ func walkAssignMapRead(init *ir.Nodes, n *ir.AssignListStmt) ir.Node {
 
 	var call *ir.CallExpr
 	if w := t.Elem().Width; w <= zeroValSize {
-		fn := mapfn(mapaccess2[fast], t)
+		fn := mapfn(mapaccess2[fast], t, false)
 		call = mkcall1(fn, fn.Type().Results(), init, reflectdata.TypePtr(t), r.X, key)
 	} else {
-		fn := mapfn("mapaccess2_fat", t)
+		fn := mapfn("mapaccess2_fat", t, true)
 		z := reflectdata.ZeroAddr(w)
 		call = mkcall1(fn, fn.Type().Results(), init, reflectdata.TypePtr(t), r.X, key, z)
 	}
diff --git a/src/cmd/compile/internal/walk/complit.go b/src/cmd/compile/internal/walk/complit.go
index 54f2c5fefe..abd920d646 100644
--- a/src/cmd/compile/internal/walk/complit.go
+++ b/src/cmd/compile/internal/walk/complit.go
@@ -475,7 +475,10 @@ func maplit(n *ir.CompLitExpr, m ir.Node, init *ir.Nodes) {
 		zero := ir.NewAssignStmt(base.Pos, i, ir.NewInt(0))
 		cond := ir.NewBinaryExpr(base.Pos, ir.OLT, i, ir.NewInt(tk.NumElem()))
 		incr := ir.NewAssignStmt(base.Pos, i, ir.NewBinaryExpr(base.Pos, ir.OADD, i, ir.NewInt(1)))
-		body := ir.NewAssignStmt(base.Pos, lhs, rhs)
+
+		var body ir.Node = ir.NewAssignStmt(base.Pos, lhs, rhs)
+		body = typecheck.Stmt(body) // typechecker rewrites OINDEX to OINDEXMAP
+		body = orderStmtInPlace(body, map[string][]*ir.Name{})
 
 		loop := ir.NewForStmt(base.Pos, nil, cond, incr, nil)
 		loop.Body = []ir.Node{body}
@@ -503,7 +506,10 @@ func maplit(n *ir.CompLitExpr, m ir.Node, init *ir.Nodes) {
 		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, tmpelem, elem))
 
 		ir.SetPos(tmpelem)
-		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, ir.NewIndexExpr(base.Pos, m, tmpkey), tmpelem))
+		var a ir.Node = ir.NewAssignStmt(base.Pos, ir.NewIndexExpr(base.Pos, m, tmpkey), tmpelem)
+		a = typecheck.Stmt(a) // typechecker rewrites OINDEX to OINDEXMAP
+		a = orderStmtInPlace(a, map[string][]*ir.Name{})
+		appendWalkStmt(init, a)
 	}
 
 	appendWalkStmt(init, ir.NewUnaryExpr(base.Pos, ir.OVARKILL, tmpkey))
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 0bf531e29d..0995c1314d 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -681,12 +681,16 @@ func walkIndexMap(n *ir.IndexExpr, init *ir.Nodes) ir.Node {
 	if n.Assigned {
 		// This m[k] expression is on the left-hand side of an assignment.
 		fast := mapfast(t)
-		if fast == mapslow {
+		switch fast {
+		case mapslow:
 			// standard version takes key by reference.
 			// order.expr made sure key is addressable.
 			key = typecheck.NodAddr(key)
+		case mapfast32ptr, mapfast64ptr:
+			// pointer version takes pointer key.
+			key = ir.NewConvExpr(n.Pos(), ir.OCONVNOP, types.Types[types.TUNSAFEPTR], key)
 		}
-		call = mkcall1(mapfn(mapassign[fast], t), nil, init, reflectdata.TypePtr(t), map_, key)
+		call = mkcall1(mapfn(mapassign[fast], t, false), nil, init, reflectdata.TypePtr(t), map_, key)
 	} else {
 		// m[k] is not the target of an assignment.
 		fast := mapfast(t)
@@ -697,10 +701,10 @@ func walkIndexMap(n *ir.IndexExpr, init *ir.Nodes) ir.Node {
 		}
 
 		if w := t.Elem().Width; w <= zeroValSize {
-			call = mkcall1(mapfn(mapaccess1[fast], t), types.NewPtr(t.Elem()), init, reflectdata.TypePtr(t), map_, key)
+			call = mkcall1(mapfn(mapaccess1[fast], t, false), types.NewPtr(t.Elem()), init, reflectdata.TypePtr(t), map_, key)
 		} else {
 			z := reflectdata.ZeroAddr(w)
-			call = mkcall1(mapfn("mapaccess1_fat", t), types.NewPtr(t.Elem()), init, reflectdata.TypePtr(t), map_, key, z)
+			call = mkcall1(mapfn("mapaccess1_fat", t, true), types.NewPtr(t.Elem()), init, reflectdata.TypePtr(t), map_, key, z)
 		}
 	}
 	call.SetType(types.NewPtr(t.Elem()))
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index a9e0e5efe8..8b30632665 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -6,6 +6,7 @@ package walk
 
 import (
 	"fmt"
+	"go/constant"
 
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/escape"
@@ -269,10 +270,51 @@ func (o *orderState) addrTemp(n ir.Node) ir.Node {
 func (o *orderState) mapKeyTemp(t *types.Type, n ir.Node) ir.Node {
 	// Most map calls need to take the address of the key.
 	// Exception: map*_fast* calls. See golang.org/issue/19015.
-	if mapfast(t) == mapslow {
+	alg := mapfast(t)
+	if alg == mapslow {
 		return o.addrTemp(n)
 	}
-	return n
+	var kt *types.Type
+	switch alg {
+	case mapfast32, mapfast32ptr:
+		kt = types.Types[types.TUINT32]
+	case mapfast64, mapfast64ptr:
+		kt = types.Types[types.TUINT64]
+	case mapfaststr:
+		kt = types.Types[types.TSTRING]
+	}
+	nt := n.Type()
+	switch {
+	case nt == kt:
+		return n
+	case nt.Kind() == kt.Kind():
+		// can directly convert (e.g. named type to underlying type)
+		return typecheck.Expr(ir.NewConvExpr(n.Pos(), ir.OCONVNOP, kt, n))
+	case nt.IsInteger() && kt.IsInteger():
+		// can directly convert (e.g. int32 to uint32)
+		if n.Op() == ir.OLITERAL && nt.IsSigned() {
+			// avoid constant overflow error
+			n = ir.NewConstExpr(constant.MakeUint64(uint64(ir.Int64Val(n))), n)
+			n.SetType(kt)
+			return n
+		}
+		return typecheck.Expr(ir.NewConvExpr(n.Pos(), ir.OCONV, kt, n))
+	default:
+		// Unsafe cast through memory.
+		// We'll need to do a load with type kt. Create a temporary of type kt to
+		// ensure sufficient alignment. nt may be under-aligned.
+		if kt.Align < nt.Align {
+			base.Fatalf("mapKeyTemp: key type is not sufficiently aligned, kt=%v nt=%v", kt, nt)
+		}
+		clear := base.Flag.Cfg.Instrumenting // clear tmp if instrumenting, as it may be live at an inserted race call
+		tmp := o.newTemp(kt, clear)
+		// *(*nt)(&tmp) = n
+		var e ir.Node = typecheck.NodAddr(tmp)
+		e = ir.NewConvExpr(n.Pos(), ir.OCONVNOP, nt.PtrTo(), e)
+		e = ir.NewStarExpr(n.Pos(), e)
+		o.append(ir.NewAssignStmt(base.Pos, e, n))
+		return tmp
+	}
 }
 
 // mapKeyReplaceStrConv replaces OBYTES2STR by OBYTES2STRTMP
diff --git a/src/cmd/compile/internal/walk/stmt.go b/src/cmd/compile/internal/walk/stmt.go
index 773620bea6..0bf76680c4 100644
--- a/src/cmd/compile/internal/walk/stmt.go
+++ b/src/cmd/compile/internal/walk/stmt.go
@@ -197,11 +197,7 @@ func walkGoDefer(n *ir.GoDeferStmt) ir.Node {
 
 	case ir.ODELETE:
 		call := call.(*ir.CallExpr)
-		if mapfast(call.Args[0].Type()) == mapslow {
-			n.Call = wrapCall(call, &init)
-		} else {
-			n.Call = walkExpr(call, &init)
-		}
+		n.Call = wrapCall(call, &init)
 
 	case ir.OCOPY:
 		call := call.(*ir.BinaryExpr)
diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index 1f0b777263..904587295a 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -14,7 +14,6 @@ import (
 	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
-	"cmd/internal/objabi"
 	"cmd/internal/src"
 )
 
@@ -158,12 +157,16 @@ func chanfn(name string, n int, t *types.Type) ir.Node {
 	return fn
 }
 
-func mapfn(name string, t *types.Type) ir.Node {
+func mapfn(name string, t *types.Type, isfat bool) ir.Node {
 	if !t.IsMap() {
 		base.Fatalf("mapfn %v", t)
 	}
 	fn := typecheck.LookupRuntime(name)
-	fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem(), t.Key(), t.Elem())
+	if mapfast(t) == mapslow || isfat {
+		fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem(), t.Key(), t.Elem())
+	} else {
+		fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem(), t.Elem())
+	}
 	return fn
 }
 
@@ -172,7 +175,11 @@ func mapfndel(name string, t *types.Type) ir.Node {
 		base.Fatalf("mapfn %v", t)
 	}
 	fn := typecheck.LookupRuntime(name)
-	fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem(), t.Key())
+	if mapfast(t) == mapslow {
+		fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem(), t.Key())
+	} else {
+		fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem())
+	}
 	return fn
 }
 
@@ -204,13 +211,6 @@ func mapfast(t *types.Type) int {
 	}
 	switch reflectdata.AlgType(t.Key()) {
 	case types.AMEM32:
-		if objabi.Experiment.RegabiArgs && t.Key().NumComponents(types.CountBlankFields) != 1 {
-			// If key has multiple components, under register ABI it will
-			// be passed differently than uint32.
-			// TODO: maybe unsafe-case to uint32. But needs to make the type
-			// checker happy.
-			return mapslow
-		}
 		if !t.Key().HasPointers() {
 			return mapfast32
 		}
@@ -219,10 +219,6 @@ func mapfast(t *types.Type) int {
 		}
 		base.Fatalf("small pointer %v", t.Key())
 	case types.AMEM64:
-		if objabi.Experiment.RegabiArgs && t.Key().NumComponents(types.CountBlankFields) != 1 {
-			// See above.
-			return mapslow
-		}
 		if !t.Key().HasPointers() {
 			return mapfast64
 		}
-- 
GitLab


From f5f76471074c4f475404fb2488846b38f57f9720 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Wed, 31 Mar 2021 21:47:41 +0000
Subject: [PATCH 1533/2400] runtime: break out GC pacer into its own file

This change breaks out the GC pacer into its own file so that it'll be
easier to see the full implementation and change it. It also suggests an
obvious place to put tests (mgcpacer_test.go).

This includes all of gcControllerState, gcSetTriggerRatio, anything
related to GOGC, and all related globals and constants.

This is almost a clean move, except that globals and constants are
formatted into blocks instead of having a separate "var" declaration for
each one.

For #44167.

Change-Id: I85aa84ce85c6cfbe0b33e8a3c91cbe9dc41de8cb
Reviewed-on: https://go-review.googlesource.com/c/go/+/306596
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
---
 src/runtime/mgc.go      | 720 ---------------------------------------
 src/runtime/mgcpacer.go | 735 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 735 insertions(+), 720 deletions(-)
 create mode 100644 src/runtime/mgcpacer.go

diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index 25bf4a226b..0c92b2e7b6 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -149,26 +149,6 @@ const (
 	sweepMinHeapDistance = 1024 * 1024
 )
 
-// heapminimum is the minimum heap size at which to trigger GC.
-// For small heaps, this overrides the usual GOGC*live set rule.
-//
-// When there is a very small live set but a lot of allocation, simply
-// collecting when the heap reaches GOGC*live results in many GC
-// cycles and high total per-GC overhead. This minimum amortizes this
-// per-GC overhead while keeping the heap reasonably small.
-//
-// During initialization this is set to 4MB*GOGC/100. In the case of
-// GOGC==0, this will set heapminimum to 0, resulting in constant
-// collection even when the heap size is small, which is useful for
-// debugging.
-var heapminimum uint64 = defaultHeapMinimum
-
-// defaultHeapMinimum is the value of heapminimum for GOGC==100.
-const defaultHeapMinimum = 4 << 20
-
-// Initialized from $GOGC.  GOGC=off means no GC.
-var gcpercent int32
-
 func gcinit() {
 	if unsafe.Sizeof(workbuf{}) != _WorkbufSize {
 		throw("size of Workbuf is suboptimal")
@@ -196,17 +176,6 @@ func gcinit() {
 	lockInit(&work.wbufSpans.lock, lockRankWbufSpans)
 }
 
-func readgogc() int32 {
-	p := gogetenv("GOGC")
-	if p == "off" {
-		return -1
-	}
-	if n, ok := atoi32(p); ok {
-		return n
-	}
-	return 100
-}
-
 // Temporary in order to enable register ABI work.
 // TODO(register args): convert back to local chan in gcenabled, passed to "go" stmts.
 var gcenable_setup chan int
@@ -226,31 +195,6 @@ func gcenable() {
 	memstats.enablegc = true // now that runtime is initialized, GC is okay
 }
 
-//go:linkname setGCPercent runtime/debug.setGCPercent
-func setGCPercent(in int32) (out int32) {
-	// Run on the system stack since we grab the heap lock.
-	systemstack(func() {
-		lock(&mheap_.lock)
-		out = gcpercent
-		if in < 0 {
-			in = -1
-		}
-		gcpercent = in
-		heapminimum = defaultHeapMinimum * uint64(gcpercent) / 100
-		// Update pacing in response to gcpercent change.
-		gcSetTriggerRatio(memstats.triggerRatio)
-		unlock(&mheap_.lock)
-	})
-
-	// If we just disabled GC, wait for any concurrent GC mark to
-	// finish so we always return with no GC running.
-	if in < 0 {
-		gcWaitOnMark(atomic.Load(&work.cycles))
-	}
-
-	return out
-}
-
 // Garbage collector phase.
 // Indicates to write barrier and synchronization task to perform.
 var gcphase uint32
@@ -330,473 +274,6 @@ var gcMarkWorkerModeStrings = [...]string{
 	"GC (idle)",
 }
 
-// gcController implements the GC pacing controller that determines
-// when to trigger concurrent garbage collection and how much marking
-// work to do in mutator assists and background marking.
-//
-// It uses a feedback control algorithm to adjust the memstats.gc_trigger
-// trigger based on the heap growth and GC CPU utilization each cycle.
-// This algorithm optimizes for heap growth to match GOGC and for CPU
-// utilization between assist and background marking to be 25% of
-// GOMAXPROCS. The high-level design of this algorithm is documented
-// at https://golang.org/s/go15gcpacing.
-//
-// All fields of gcController are used only during a single mark
-// cycle.
-var gcController gcControllerState
-
-type gcControllerState struct {
-	// scanWork is the total scan work performed this cycle. This
-	// is updated atomically during the cycle. Updates occur in
-	// bounded batches, since it is both written and read
-	// throughout the cycle. At the end of the cycle, this is how
-	// much of the retained heap is scannable.
-	//
-	// Currently this is the bytes of heap scanned. For most uses,
-	// this is an opaque unit of work, but for estimation the
-	// definition is important.
-	scanWork int64
-
-	// bgScanCredit is the scan work credit accumulated by the
-	// concurrent background scan. This credit is accumulated by
-	// the background scan and stolen by mutator assists. This is
-	// updated atomically. Updates occur in bounded batches, since
-	// it is both written and read throughout the cycle.
-	bgScanCredit int64
-
-	// assistTime is the nanoseconds spent in mutator assists
-	// during this cycle. This is updated atomically. Updates
-	// occur in bounded batches, since it is both written and read
-	// throughout the cycle.
-	assistTime int64
-
-	// dedicatedMarkTime is the nanoseconds spent in dedicated
-	// mark workers during this cycle. This is updated atomically
-	// at the end of the concurrent mark phase.
-	dedicatedMarkTime int64
-
-	// fractionalMarkTime is the nanoseconds spent in the
-	// fractional mark worker during this cycle. This is updated
-	// atomically throughout the cycle and will be up-to-date if
-	// the fractional mark worker is not currently running.
-	fractionalMarkTime int64
-
-	// idleMarkTime is the nanoseconds spent in idle marking
-	// during this cycle. This is updated atomically throughout
-	// the cycle.
-	idleMarkTime int64
-
-	// markStartTime is the absolute start time in nanoseconds
-	// that assists and background mark workers started.
-	markStartTime int64
-
-	// dedicatedMarkWorkersNeeded is the number of dedicated mark
-	// workers that need to be started. This is computed at the
-	// beginning of each cycle and decremented atomically as
-	// dedicated mark workers get started.
-	dedicatedMarkWorkersNeeded int64
-
-	// assistWorkPerByte is the ratio of scan work to allocated
-	// bytes that should be performed by mutator assists. This is
-	// computed at the beginning of each cycle and updated every
-	// time heap_scan is updated.
-	//
-	// Stored as a uint64, but it's actually a float64. Use
-	// float64frombits to get the value.
-	//
-	// Read and written atomically.
-	assistWorkPerByte uint64
-
-	// assistBytesPerWork is 1/assistWorkPerByte.
-	//
-	// Stored as a uint64, but it's actually a float64. Use
-	// float64frombits to get the value.
-	//
-	// Read and written atomically.
-	//
-	// Note that because this is read and written independently
-	// from assistWorkPerByte users may notice a skew between
-	// the two values, and such a state should be safe.
-	assistBytesPerWork uint64
-
-	// fractionalUtilizationGoal is the fraction of wall clock
-	// time that should be spent in the fractional mark worker on
-	// each P that isn't running a dedicated worker.
-	//
-	// For example, if the utilization goal is 25% and there are
-	// no dedicated workers, this will be 0.25. If the goal is
-	// 25%, there is one dedicated worker, and GOMAXPROCS is 5,
-	// this will be 0.05 to make up the missing 5%.
-	//
-	// If this is zero, no fractional workers are needed.
-	fractionalUtilizationGoal float64
-
-	_ cpu.CacheLinePad
-}
-
-// startCycle resets the GC controller's state and computes estimates
-// for a new GC cycle. The caller must hold worldsema and the world
-// must be stopped.
-func (c *gcControllerState) startCycle() {
-	c.scanWork = 0
-	c.bgScanCredit = 0
-	c.assistTime = 0
-	c.dedicatedMarkTime = 0
-	c.fractionalMarkTime = 0
-	c.idleMarkTime = 0
-
-	// Ensure that the heap goal is at least a little larger than
-	// the current live heap size. This may not be the case if GC
-	// start is delayed or if the allocation that pushed heap_live
-	// over gc_trigger is large or if the trigger is really close to
-	// GOGC. Assist is proportional to this distance, so enforce a
-	// minimum distance, even if it means going over the GOGC goal
-	// by a tiny bit.
-	if memstats.next_gc < memstats.heap_live+1024*1024 {
-		memstats.next_gc = memstats.heap_live + 1024*1024
-	}
-
-	// Compute the background mark utilization goal. In general,
-	// this may not come out exactly. We round the number of
-	// dedicated workers so that the utilization is closest to
-	// 25%. For small GOMAXPROCS, this would introduce too much
-	// error, so we add fractional workers in that case.
-	totalUtilizationGoal := float64(gomaxprocs) * gcBackgroundUtilization
-	c.dedicatedMarkWorkersNeeded = int64(totalUtilizationGoal + 0.5)
-	utilError := float64(c.dedicatedMarkWorkersNeeded)/totalUtilizationGoal - 1
-	const maxUtilError = 0.3
-	if utilError < -maxUtilError || utilError > maxUtilError {
-		// Rounding put us more than 30% off our goal. With
-		// gcBackgroundUtilization of 25%, this happens for
-		// GOMAXPROCS<=3 or GOMAXPROCS=6. Enable fractional
-		// workers to compensate.
-		if float64(c.dedicatedMarkWorkersNeeded) > totalUtilizationGoal {
-			// Too many dedicated workers.
-			c.dedicatedMarkWorkersNeeded--
-		}
-		c.fractionalUtilizationGoal = (totalUtilizationGoal - float64(c.dedicatedMarkWorkersNeeded)) / float64(gomaxprocs)
-	} else {
-		c.fractionalUtilizationGoal = 0
-	}
-
-	// In STW mode, we just want dedicated workers.
-	if debug.gcstoptheworld > 0 {
-		c.dedicatedMarkWorkersNeeded = int64(gomaxprocs)
-		c.fractionalUtilizationGoal = 0
-	}
-
-	// Clear per-P state
-	for _, p := range allp {
-		p.gcAssistTime = 0
-		p.gcFractionalMarkTime = 0
-	}
-
-	// Compute initial values for controls that are updated
-	// throughout the cycle.
-	c.revise()
-
-	if debug.gcpacertrace > 0 {
-		assistRatio := float64frombits(atomic.Load64(&c.assistWorkPerByte))
-		print("pacer: assist ratio=", assistRatio,
-			" (scan ", memstats.heap_scan>>20, " MB in ",
-			work.initialHeapLive>>20, "->",
-			memstats.next_gc>>20, " MB)",
-			" workers=", c.dedicatedMarkWorkersNeeded,
-			"+", c.fractionalUtilizationGoal, "\n")
-	}
-}
-
-// revise updates the assist ratio during the GC cycle to account for
-// improved estimates. This should be called whenever memstats.heap_scan,
-// memstats.heap_live, or memstats.next_gc is updated. It is safe to
-// call concurrently, but it may race with other calls to revise.
-//
-// The result of this race is that the two assist ratio values may not line
-// up or may be stale. In practice this is OK because the assist ratio
-// moves slowly throughout a GC cycle, and the assist ratio is a best-effort
-// heuristic anyway. Furthermore, no part of the heuristic depends on
-// the two assist ratio values being exact reciprocals of one another, since
-// the two values are used to convert values from different sources.
-//
-// The worst case result of this raciness is that we may miss a larger shift
-// in the ratio (say, if we decide to pace more aggressively against the
-// hard heap goal) but even this "hard goal" is best-effort (see #40460).
-// The dedicated GC should ensure we don't exceed the hard goal by too much
-// in the rare case we do exceed it.
-//
-// It should only be called when gcBlackenEnabled != 0 (because this
-// is when assists are enabled and the necessary statistics are
-// available).
-func (c *gcControllerState) revise() {
-	gcpercent := gcpercent
-	if gcpercent < 0 {
-		// If GC is disabled but we're running a forced GC,
-		// act like GOGC is huge for the below calculations.
-		gcpercent = 100000
-	}
-	live := atomic.Load64(&memstats.heap_live)
-	scan := atomic.Load64(&memstats.heap_scan)
-	work := atomic.Loadint64(&c.scanWork)
-
-	// Assume we're under the soft goal. Pace GC to complete at
-	// next_gc assuming the heap is in steady-state.
-	heapGoal := int64(atomic.Load64(&memstats.next_gc))
-
-	// Compute the expected scan work remaining.
-	//
-	// This is estimated based on the expected
-	// steady-state scannable heap. For example, with
-	// GOGC=100, only half of the scannable heap is
-	// expected to be live, so that's what we target.
-	//
-	// (This is a float calculation to avoid overflowing on
-	// 100*heap_scan.)
-	scanWorkExpected := int64(float64(scan) * 100 / float64(100+gcpercent))
-
-	if int64(live) > heapGoal || work > scanWorkExpected {
-		// We're past the soft goal, or we've already done more scan
-		// work than we expected. Pace GC so that in the worst case it
-		// will complete by the hard goal.
-		const maxOvershoot = 1.1
-		heapGoal = int64(float64(heapGoal) * maxOvershoot)
-
-		// Compute the upper bound on the scan work remaining.
-		scanWorkExpected = int64(scan)
-	}
-
-	// Compute the remaining scan work estimate.
-	//
-	// Note that we currently count allocations during GC as both
-	// scannable heap (heap_scan) and scan work completed
-	// (scanWork), so allocation will change this difference
-	// slowly in the soft regime and not at all in the hard
-	// regime.
-	scanWorkRemaining := scanWorkExpected - work
-	if scanWorkRemaining < 1000 {
-		// We set a somewhat arbitrary lower bound on
-		// remaining scan work since if we aim a little high,
-		// we can miss by a little.
-		//
-		// We *do* need to enforce that this is at least 1,
-		// since marking is racy and double-scanning objects
-		// may legitimately make the remaining scan work
-		// negative, even in the hard goal regime.
-		scanWorkRemaining = 1000
-	}
-
-	// Compute the heap distance remaining.
-	heapRemaining := heapGoal - int64(live)
-	if heapRemaining <= 0 {
-		// This shouldn't happen, but if it does, avoid
-		// dividing by zero or setting the assist negative.
-		heapRemaining = 1
-	}
-
-	// Compute the mutator assist ratio so by the time the mutator
-	// allocates the remaining heap bytes up to next_gc, it will
-	// have done (or stolen) the remaining amount of scan work.
-	// Note that the assist ratio values are updated atomically
-	// but not together. This means there may be some degree of
-	// skew between the two values. This is generally OK as the
-	// values shift relatively slowly over the course of a GC
-	// cycle.
-	assistWorkPerByte := float64(scanWorkRemaining) / float64(heapRemaining)
-	assistBytesPerWork := float64(heapRemaining) / float64(scanWorkRemaining)
-	atomic.Store64(&c.assistWorkPerByte, float64bits(assistWorkPerByte))
-	atomic.Store64(&c.assistBytesPerWork, float64bits(assistBytesPerWork))
-}
-
-// endCycle computes the trigger ratio for the next cycle.
-func (c *gcControllerState) endCycle() float64 {
-	if work.userForced {
-		// Forced GC means this cycle didn't start at the
-		// trigger, so where it finished isn't good
-		// information about how to adjust the trigger.
-		// Just leave it where it is.
-		return memstats.triggerRatio
-	}
-
-	// Proportional response gain for the trigger controller. Must
-	// be in [0, 1]. Lower values smooth out transient effects but
-	// take longer to respond to phase changes. Higher values
-	// react to phase changes quickly, but are more affected by
-	// transient changes. Values near 1 may be unstable.
-	const triggerGain = 0.5
-
-	// Compute next cycle trigger ratio. First, this computes the
-	// "error" for this cycle; that is, how far off the trigger
-	// was from what it should have been, accounting for both heap
-	// growth and GC CPU utilization. We compute the actual heap
-	// growth during this cycle and scale that by how far off from
-	// the goal CPU utilization we were (to estimate the heap
-	// growth if we had the desired CPU utilization). The
-	// difference between this estimate and the GOGC-based goal
-	// heap growth is the error.
-	goalGrowthRatio := gcEffectiveGrowthRatio()
-	actualGrowthRatio := float64(memstats.heap_live)/float64(memstats.heap_marked) - 1
-	assistDuration := nanotime() - c.markStartTime
-
-	// Assume background mark hit its utilization goal.
-	utilization := gcBackgroundUtilization
-	// Add assist utilization; avoid divide by zero.
-	if assistDuration > 0 {
-		utilization += float64(c.assistTime) / float64(assistDuration*int64(gomaxprocs))
-	}
-
-	triggerError := goalGrowthRatio - memstats.triggerRatio - utilization/gcGoalUtilization*(actualGrowthRatio-memstats.triggerRatio)
-
-	// Finally, we adjust the trigger for next time by this error,
-	// damped by the proportional gain.
-	triggerRatio := memstats.triggerRatio + triggerGain*triggerError
-
-	if debug.gcpacertrace > 0 {
-		// Print controller state in terms of the design
-		// document.
-		H_m_prev := memstats.heap_marked
-		h_t := memstats.triggerRatio
-		H_T := memstats.gc_trigger
-		h_a := actualGrowthRatio
-		H_a := memstats.heap_live
-		h_g := goalGrowthRatio
-		H_g := int64(float64(H_m_prev) * (1 + h_g))
-		u_a := utilization
-		u_g := gcGoalUtilization
-		W_a := c.scanWork
-		print("pacer: H_m_prev=", H_m_prev,
-			" h_t=", h_t, " H_T=", H_T,
-			" h_a=", h_a, " H_a=", H_a,
-			" h_g=", h_g, " H_g=", H_g,
-			" u_a=", u_a, " u_g=", u_g,
-			" W_a=", W_a,
-			" goalΔ=", goalGrowthRatio-h_t,
-			" actualΔ=", h_a-h_t,
-			" u_a/u_g=", u_a/u_g,
-			"\n")
-	}
-
-	return triggerRatio
-}
-
-// enlistWorker encourages another dedicated mark worker to start on
-// another P if there are spare worker slots. It is used by putfull
-// when more work is made available.
-//
-//go:nowritebarrier
-func (c *gcControllerState) enlistWorker() {
-	// If there are idle Ps, wake one so it will run an idle worker.
-	// NOTE: This is suspected of causing deadlocks. See golang.org/issue/19112.
-	//
-	//	if atomic.Load(&sched.npidle) != 0 && atomic.Load(&sched.nmspinning) == 0 {
-	//		wakep()
-	//		return
-	//	}
-
-	// There are no idle Ps. If we need more dedicated workers,
-	// try to preempt a running P so it will switch to a worker.
-	if c.dedicatedMarkWorkersNeeded <= 0 {
-		return
-	}
-	// Pick a random other P to preempt.
-	if gomaxprocs <= 1 {
-		return
-	}
-	gp := getg()
-	if gp == nil || gp.m == nil || gp.m.p == 0 {
-		return
-	}
-	myID := gp.m.p.ptr().id
-	for tries := 0; tries < 5; tries++ {
-		id := int32(fastrandn(uint32(gomaxprocs - 1)))
-		if id >= myID {
-			id++
-		}
-		p := allp[id]
-		if p.status != _Prunning {
-			continue
-		}
-		if preemptone(p) {
-			return
-		}
-	}
-}
-
-// findRunnableGCWorker returns a background mark worker for _p_ if it
-// should be run. This must only be called when gcBlackenEnabled != 0.
-func (c *gcControllerState) findRunnableGCWorker(_p_ *p) *g {
-	if gcBlackenEnabled == 0 {
-		throw("gcControllerState.findRunnable: blackening not enabled")
-	}
-
-	if !gcMarkWorkAvailable(_p_) {
-		// No work to be done right now. This can happen at
-		// the end of the mark phase when there are still
-		// assists tapering off. Don't bother running a worker
-		// now because it'll just return immediately.
-		return nil
-	}
-
-	// Grab a worker before we commit to running below.
-	node := (*gcBgMarkWorkerNode)(gcBgMarkWorkerPool.pop())
-	if node == nil {
-		// There is at least one worker per P, so normally there are
-		// enough workers to run on all Ps, if necessary. However, once
-		// a worker enters gcMarkDone it may park without rejoining the
-		// pool, thus freeing a P with no corresponding worker.
-		// gcMarkDone never depends on another worker doing work, so it
-		// is safe to simply do nothing here.
-		//
-		// If gcMarkDone bails out without completing the mark phase,
-		// it will always do so with queued global work. Thus, that P
-		// will be immediately eligible to re-run the worker G it was
-		// just using, ensuring work can complete.
-		return nil
-	}
-
-	decIfPositive := func(ptr *int64) bool {
-		for {
-			v := atomic.Loadint64(ptr)
-			if v <= 0 {
-				return false
-			}
-
-			if atomic.Casint64(ptr, v, v-1) {
-				return true
-			}
-		}
-	}
-
-	if decIfPositive(&c.dedicatedMarkWorkersNeeded) {
-		// This P is now dedicated to marking until the end of
-		// the concurrent mark phase.
-		_p_.gcMarkWorkerMode = gcMarkWorkerDedicatedMode
-	} else if c.fractionalUtilizationGoal == 0 {
-		// No need for fractional workers.
-		gcBgMarkWorkerPool.push(&node.node)
-		return nil
-	} else {
-		// Is this P behind on the fractional utilization
-		// goal?
-		//
-		// This should be kept in sync with pollFractionalWorkerExit.
-		delta := nanotime() - gcController.markStartTime
-		if delta > 0 && float64(_p_.gcFractionalMarkTime)/float64(delta) > c.fractionalUtilizationGoal {
-			// Nope. No need to run a fractional worker.
-			gcBgMarkWorkerPool.push(&node.node)
-			return nil
-		}
-		// Run a fractional worker.
-		_p_.gcMarkWorkerMode = gcMarkWorkerFractionalMode
-	}
-
-	// Run the background mark worker.
-	gp := node.gp.ptr()
-	casgstatus(gp, _Gwaiting, _Grunnable)
-	if trace.enabled {
-		traceGoUnpark(gp, 0)
-	}
-	return gp
-}
-
 // pollFractionalWorkerExit reports whether a fractional mark worker
 // should self-preempt. It assumes it is called from the fractional
 // worker.
@@ -815,203 +292,6 @@ func pollFractionalWorkerExit() bool {
 	return float64(selfTime)/float64(delta) > 1.2*gcController.fractionalUtilizationGoal
 }
 
-// gcSetTriggerRatio sets the trigger ratio and updates everything
-// derived from it: the absolute trigger, the heap goal, mark pacing,
-// and sweep pacing.
-//
-// This can be called any time. If GC is the in the middle of a
-// concurrent phase, it will adjust the pacing of that phase.
-//
-// This depends on gcpercent, memstats.heap_marked, and
-// memstats.heap_live. These must be up to date.
-//
-// mheap_.lock must be held or the world must be stopped.
-func gcSetTriggerRatio(triggerRatio float64) {
-	assertWorldStoppedOrLockHeld(&mheap_.lock)
-
-	// Compute the next GC goal, which is when the allocated heap
-	// has grown by GOGC/100 over the heap marked by the last
-	// cycle.
-	goal := ^uint64(0)
-	if gcpercent >= 0 {
-		goal = memstats.heap_marked + memstats.heap_marked*uint64(gcpercent)/100
-	}
-
-	// Set the trigger ratio, capped to reasonable bounds.
-	if gcpercent >= 0 {
-		scalingFactor := float64(gcpercent) / 100
-		// Ensure there's always a little margin so that the
-		// mutator assist ratio isn't infinity.
-		maxTriggerRatio := 0.95 * scalingFactor
-		if triggerRatio > maxTriggerRatio {
-			triggerRatio = maxTriggerRatio
-		}
-
-		// If we let triggerRatio go too low, then if the application
-		// is allocating very rapidly we might end up in a situation
-		// where we're allocating black during a nearly always-on GC.
-		// The result of this is a growing heap and ultimately an
-		// increase in RSS. By capping us at a point >0, we're essentially
-		// saying that we're OK using more CPU during the GC to prevent
-		// this growth in RSS.
-		//
-		// The current constant was chosen empirically: given a sufficiently
-		// fast/scalable allocator with 48 Ps that could drive the trigger ratio
-		// to <0.05, this constant causes applications to retain the same peak
-		// RSS compared to not having this allocator.
-		minTriggerRatio := 0.6 * scalingFactor
-		if triggerRatio < minTriggerRatio {
-			triggerRatio = minTriggerRatio
-		}
-	} else if triggerRatio < 0 {
-		// gcpercent < 0, so just make sure we're not getting a negative
-		// triggerRatio. This case isn't expected to happen in practice,
-		// and doesn't really matter because if gcpercent < 0 then we won't
-		// ever consume triggerRatio further on in this function, but let's
-		// just be defensive here; the triggerRatio being negative is almost
-		// certainly undesirable.
-		triggerRatio = 0
-	}
-	memstats.triggerRatio = triggerRatio
-
-	// Compute the absolute GC trigger from the trigger ratio.
-	//
-	// We trigger the next GC cycle when the allocated heap has
-	// grown by the trigger ratio over the marked heap size.
-	trigger := ^uint64(0)
-	if gcpercent >= 0 {
-		trigger = uint64(float64(memstats.heap_marked) * (1 + triggerRatio))
-		// Don't trigger below the minimum heap size.
-		minTrigger := heapminimum
-		if !isSweepDone() {
-			// Concurrent sweep happens in the heap growth
-			// from heap_live to gc_trigger, so ensure
-			// that concurrent sweep has some heap growth
-			// in which to perform sweeping before we
-			// start the next GC cycle.
-			sweepMin := atomic.Load64(&memstats.heap_live) + sweepMinHeapDistance
-			if sweepMin > minTrigger {
-				minTrigger = sweepMin
-			}
-		}
-		if trigger < minTrigger {
-			trigger = minTrigger
-		}
-		if int64(trigger) < 0 {
-			print("runtime: next_gc=", memstats.next_gc, " heap_marked=", memstats.heap_marked, " heap_live=", memstats.heap_live, " initialHeapLive=", work.initialHeapLive, "triggerRatio=", triggerRatio, " minTrigger=", minTrigger, "\n")
-			throw("gc_trigger underflow")
-		}
-		if trigger > goal {
-			// The trigger ratio is always less than GOGC/100, but
-			// other bounds on the trigger may have raised it.
-			// Push up the goal, too.
-			goal = trigger
-		}
-	}
-
-	// Commit to the trigger and goal.
-	memstats.gc_trigger = trigger
-	atomic.Store64(&memstats.next_gc, goal)
-	if trace.enabled {
-		traceNextGC()
-	}
-
-	// Update mark pacing.
-	if gcphase != _GCoff {
-		gcController.revise()
-	}
-
-	// Update sweep pacing.
-	if isSweepDone() {
-		mheap_.sweepPagesPerByte = 0
-	} else {
-		// Concurrent sweep needs to sweep all of the in-use
-		// pages by the time the allocated heap reaches the GC
-		// trigger. Compute the ratio of in-use pages to sweep
-		// per byte allocated, accounting for the fact that
-		// some might already be swept.
-		heapLiveBasis := atomic.Load64(&memstats.heap_live)
-		heapDistance := int64(trigger) - int64(heapLiveBasis)
-		// Add a little margin so rounding errors and
-		// concurrent sweep are less likely to leave pages
-		// unswept when GC starts.
-		heapDistance -= 1024 * 1024
-		if heapDistance < _PageSize {
-			// Avoid setting the sweep ratio extremely high
-			heapDistance = _PageSize
-		}
-		pagesSwept := atomic.Load64(&mheap_.pagesSwept)
-		pagesInUse := atomic.Load64(&mheap_.pagesInUse)
-		sweepDistancePages := int64(pagesInUse) - int64(pagesSwept)
-		if sweepDistancePages <= 0 {
-			mheap_.sweepPagesPerByte = 0
-		} else {
-			mheap_.sweepPagesPerByte = float64(sweepDistancePages) / float64(heapDistance)
-			mheap_.sweepHeapLiveBasis = heapLiveBasis
-			// Write pagesSweptBasis last, since this
-			// signals concurrent sweeps to recompute
-			// their debt.
-			atomic.Store64(&mheap_.pagesSweptBasis, pagesSwept)
-		}
-	}
-
-	gcPaceScavenger()
-}
-
-// gcEffectiveGrowthRatio returns the current effective heap growth
-// ratio (GOGC/100) based on heap_marked from the previous GC and
-// next_gc for the current GC.
-//
-// This may differ from gcpercent/100 because of various upper and
-// lower bounds on gcpercent. For example, if the heap is smaller than
-// heapminimum, this can be higher than gcpercent/100.
-//
-// mheap_.lock must be held or the world must be stopped.
-func gcEffectiveGrowthRatio() float64 {
-	assertWorldStoppedOrLockHeld(&mheap_.lock)
-
-	egogc := float64(atomic.Load64(&memstats.next_gc)-memstats.heap_marked) / float64(memstats.heap_marked)
-	if egogc < 0 {
-		// Shouldn't happen, but just in case.
-		egogc = 0
-	}
-	return egogc
-}
-
-// gcGoalUtilization is the goal CPU utilization for
-// marking as a fraction of GOMAXPROCS.
-const gcGoalUtilization = 0.30
-
-// gcBackgroundUtilization is the fixed CPU utilization for background
-// marking. It must be <= gcGoalUtilization. The difference between
-// gcGoalUtilization and gcBackgroundUtilization will be made up by
-// mark assists. The scheduler will aim to use within 50% of this
-// goal.
-//
-// Setting this to < gcGoalUtilization avoids saturating the trigger
-// feedback controller when there are no assists, which allows it to
-// better control CPU and heap growth. However, the larger the gap,
-// the more mutator assists are expected to happen, which impact
-// mutator latency.
-const gcBackgroundUtilization = 0.25
-
-// gcCreditSlack is the amount of scan work credit that can
-// accumulate locally before updating gcController.scanWork and,
-// optionally, gcController.bgScanCredit. Lower values give a more
-// accurate assist ratio and make it more likely that assists will
-// successfully steal background credit. Higher values reduce memory
-// contention.
-const gcCreditSlack = 2000
-
-// gcAssistTimeSlack is the nanoseconds of mutator assist time that
-// can accumulate on a P before updating gcController.assistTime.
-const gcAssistTimeSlack = 5000
-
-// gcOverAssistWork determines how many extra units of scan work a GC
-// assist does when an assist happens. This amortizes the cost of an
-// assist by pre-paying for this many bytes of future allocations.
-const gcOverAssistWork = 64 << 10
-
 var work struct {
 	full  lfstack          // lock-free list of full blocks workbuf
 	empty lfstack          // lock-free list of empty blocks workbuf
diff --git a/src/runtime/mgcpacer.go b/src/runtime/mgcpacer.go
new file mode 100644
index 0000000000..b5184b9182
--- /dev/null
+++ b/src/runtime/mgcpacer.go
@@ -0,0 +1,735 @@
+// Copyright 2021 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 runtime
+
+import (
+	"internal/cpu"
+	"runtime/internal/atomic"
+	_ "unsafe" // for linkname
+)
+
+const (
+	// gcGoalUtilization is the goal CPU utilization for
+	// marking as a fraction of GOMAXPROCS.
+	gcGoalUtilization = 0.30
+
+	// gcBackgroundUtilization is the fixed CPU utilization for background
+	// marking. It must be <= gcGoalUtilization. The difference between
+	// gcGoalUtilization and gcBackgroundUtilization will be made up by
+	// mark assists. The scheduler will aim to use within 50% of this
+	// goal.
+	//
+	// Setting this to < gcGoalUtilization avoids saturating the trigger
+	// feedback controller when there are no assists, which allows it to
+	// better control CPU and heap growth. However, the larger the gap,
+	// the more mutator assists are expected to happen, which impact
+	// mutator latency.
+	gcBackgroundUtilization = 0.25
+
+	// gcCreditSlack is the amount of scan work credit that can
+	// accumulate locally before updating gcController.scanWork and,
+	// optionally, gcController.bgScanCredit. Lower values give a more
+	// accurate assist ratio and make it more likely that assists will
+	// successfully steal background credit. Higher values reduce memory
+	// contention.
+	gcCreditSlack = 2000
+
+	// gcAssistTimeSlack is the nanoseconds of mutator assist time that
+	// can accumulate on a P before updating gcController.assistTime.
+	gcAssistTimeSlack = 5000
+
+	// gcOverAssistWork determines how many extra units of scan work a GC
+	// assist does when an assist happens. This amortizes the cost of an
+	// assist by pre-paying for this many bytes of future allocations.
+	gcOverAssistWork = 64 << 10
+
+	// defaultHeapMinimum is the value of heapminimum for GOGC==100.
+	defaultHeapMinimum = 4 << 20
+)
+
+var (
+	// heapminimum is the minimum heap size at which to trigger GC.
+	// For small heaps, this overrides the usual GOGC*live set rule.
+	//
+	// When there is a very small live set but a lot of allocation, simply
+	// collecting when the heap reaches GOGC*live results in many GC
+	// cycles and high total per-GC overhead. This minimum amortizes this
+	// per-GC overhead while keeping the heap reasonably small.
+	//
+	// During initialization this is set to 4MB*GOGC/100. In the case of
+	// GOGC==0, this will set heapminimum to 0, resulting in constant
+	// collection even when the heap size is small, which is useful for
+	// debugging.
+	heapminimum uint64 = defaultHeapMinimum
+
+	// Initialized from $GOGC.  GOGC=off means no GC.
+	gcpercent int32
+)
+
+// gcController implements the GC pacing controller that determines
+// when to trigger concurrent garbage collection and how much marking
+// work to do in mutator assists and background marking.
+//
+// It uses a feedback control algorithm to adjust the memstats.gc_trigger
+// trigger based on the heap growth and GC CPU utilization each cycle.
+// This algorithm optimizes for heap growth to match GOGC and for CPU
+// utilization between assist and background marking to be 25% of
+// GOMAXPROCS. The high-level design of this algorithm is documented
+// at https://golang.org/s/go15gcpacing.
+//
+// All fields of gcController are used only during a single mark
+// cycle.
+var gcController gcControllerState
+
+type gcControllerState struct {
+	// scanWork is the total scan work performed this cycle. This
+	// is updated atomically during the cycle. Updates occur in
+	// bounded batches, since it is both written and read
+	// throughout the cycle. At the end of the cycle, this is how
+	// much of the retained heap is scannable.
+	//
+	// Currently this is the bytes of heap scanned. For most uses,
+	// this is an opaque unit of work, but for estimation the
+	// definition is important.
+	scanWork int64
+
+	// bgScanCredit is the scan work credit accumulated by the
+	// concurrent background scan. This credit is accumulated by
+	// the background scan and stolen by mutator assists. This is
+	// updated atomically. Updates occur in bounded batches, since
+	// it is both written and read throughout the cycle.
+	bgScanCredit int64
+
+	// assistTime is the nanoseconds spent in mutator assists
+	// during this cycle. This is updated atomically. Updates
+	// occur in bounded batches, since it is both written and read
+	// throughout the cycle.
+	assistTime int64
+
+	// dedicatedMarkTime is the nanoseconds spent in dedicated
+	// mark workers during this cycle. This is updated atomically
+	// at the end of the concurrent mark phase.
+	dedicatedMarkTime int64
+
+	// fractionalMarkTime is the nanoseconds spent in the
+	// fractional mark worker during this cycle. This is updated
+	// atomically throughout the cycle and will be up-to-date if
+	// the fractional mark worker is not currently running.
+	fractionalMarkTime int64
+
+	// idleMarkTime is the nanoseconds spent in idle marking
+	// during this cycle. This is updated atomically throughout
+	// the cycle.
+	idleMarkTime int64
+
+	// markStartTime is the absolute start time in nanoseconds
+	// that assists and background mark workers started.
+	markStartTime int64
+
+	// dedicatedMarkWorkersNeeded is the number of dedicated mark
+	// workers that need to be started. This is computed at the
+	// beginning of each cycle and decremented atomically as
+	// dedicated mark workers get started.
+	dedicatedMarkWorkersNeeded int64
+
+	// assistWorkPerByte is the ratio of scan work to allocated
+	// bytes that should be performed by mutator assists. This is
+	// computed at the beginning of each cycle and updated every
+	// time heap_scan is updated.
+	//
+	// Stored as a uint64, but it's actually a float64. Use
+	// float64frombits to get the value.
+	//
+	// Read and written atomically.
+	assistWorkPerByte uint64
+
+	// assistBytesPerWork is 1/assistWorkPerByte.
+	//
+	// Stored as a uint64, but it's actually a float64. Use
+	// float64frombits to get the value.
+	//
+	// Read and written atomically.
+	//
+	// Note that because this is read and written independently
+	// from assistWorkPerByte users may notice a skew between
+	// the two values, and such a state should be safe.
+	assistBytesPerWork uint64
+
+	// fractionalUtilizationGoal is the fraction of wall clock
+	// time that should be spent in the fractional mark worker on
+	// each P that isn't running a dedicated worker.
+	//
+	// For example, if the utilization goal is 25% and there are
+	// no dedicated workers, this will be 0.25. If the goal is
+	// 25%, there is one dedicated worker, and GOMAXPROCS is 5,
+	// this will be 0.05 to make up the missing 5%.
+	//
+	// If this is zero, no fractional workers are needed.
+	fractionalUtilizationGoal float64
+
+	_ cpu.CacheLinePad
+}
+
+// startCycle resets the GC controller's state and computes estimates
+// for a new GC cycle. The caller must hold worldsema and the world
+// must be stopped.
+func (c *gcControllerState) startCycle() {
+	c.scanWork = 0
+	c.bgScanCredit = 0
+	c.assistTime = 0
+	c.dedicatedMarkTime = 0
+	c.fractionalMarkTime = 0
+	c.idleMarkTime = 0
+
+	// Ensure that the heap goal is at least a little larger than
+	// the current live heap size. This may not be the case if GC
+	// start is delayed or if the allocation that pushed heap_live
+	// over gc_trigger is large or if the trigger is really close to
+	// GOGC. Assist is proportional to this distance, so enforce a
+	// minimum distance, even if it means going over the GOGC goal
+	// by a tiny bit.
+	if memstats.next_gc < memstats.heap_live+1024*1024 {
+		memstats.next_gc = memstats.heap_live + 1024*1024
+	}
+
+	// Compute the background mark utilization goal. In general,
+	// this may not come out exactly. We round the number of
+	// dedicated workers so that the utilization is closest to
+	// 25%. For small GOMAXPROCS, this would introduce too much
+	// error, so we add fractional workers in that case.
+	totalUtilizationGoal := float64(gomaxprocs) * gcBackgroundUtilization
+	c.dedicatedMarkWorkersNeeded = int64(totalUtilizationGoal + 0.5)
+	utilError := float64(c.dedicatedMarkWorkersNeeded)/totalUtilizationGoal - 1
+	const maxUtilError = 0.3
+	if utilError < -maxUtilError || utilError > maxUtilError {
+		// Rounding put us more than 30% off our goal. With
+		// gcBackgroundUtilization of 25%, this happens for
+		// GOMAXPROCS<=3 or GOMAXPROCS=6. Enable fractional
+		// workers to compensate.
+		if float64(c.dedicatedMarkWorkersNeeded) > totalUtilizationGoal {
+			// Too many dedicated workers.
+			c.dedicatedMarkWorkersNeeded--
+		}
+		c.fractionalUtilizationGoal = (totalUtilizationGoal - float64(c.dedicatedMarkWorkersNeeded)) / float64(gomaxprocs)
+	} else {
+		c.fractionalUtilizationGoal = 0
+	}
+
+	// In STW mode, we just want dedicated workers.
+	if debug.gcstoptheworld > 0 {
+		c.dedicatedMarkWorkersNeeded = int64(gomaxprocs)
+		c.fractionalUtilizationGoal = 0
+	}
+
+	// Clear per-P state
+	for _, p := range allp {
+		p.gcAssistTime = 0
+		p.gcFractionalMarkTime = 0
+	}
+
+	// Compute initial values for controls that are updated
+	// throughout the cycle.
+	c.revise()
+
+	if debug.gcpacertrace > 0 {
+		assistRatio := float64frombits(atomic.Load64(&c.assistWorkPerByte))
+		print("pacer: assist ratio=", assistRatio,
+			" (scan ", memstats.heap_scan>>20, " MB in ",
+			work.initialHeapLive>>20, "->",
+			memstats.next_gc>>20, " MB)",
+			" workers=", c.dedicatedMarkWorkersNeeded,
+			"+", c.fractionalUtilizationGoal, "\n")
+	}
+}
+
+// revise updates the assist ratio during the GC cycle to account for
+// improved estimates. This should be called whenever memstats.heap_scan,
+// memstats.heap_live, or memstats.next_gc is updated. It is safe to
+// call concurrently, but it may race with other calls to revise.
+//
+// The result of this race is that the two assist ratio values may not line
+// up or may be stale. In practice this is OK because the assist ratio
+// moves slowly throughout a GC cycle, and the assist ratio is a best-effort
+// heuristic anyway. Furthermore, no part of the heuristic depends on
+// the two assist ratio values being exact reciprocals of one another, since
+// the two values are used to convert values from different sources.
+//
+// The worst case result of this raciness is that we may miss a larger shift
+// in the ratio (say, if we decide to pace more aggressively against the
+// hard heap goal) but even this "hard goal" is best-effort (see #40460).
+// The dedicated GC should ensure we don't exceed the hard goal by too much
+// in the rare case we do exceed it.
+//
+// It should only be called when gcBlackenEnabled != 0 (because this
+// is when assists are enabled and the necessary statistics are
+// available).
+func (c *gcControllerState) revise() {
+	gcpercent := gcpercent
+	if gcpercent < 0 {
+		// If GC is disabled but we're running a forced GC,
+		// act like GOGC is huge for the below calculations.
+		gcpercent = 100000
+	}
+	live := atomic.Load64(&memstats.heap_live)
+	scan := atomic.Load64(&memstats.heap_scan)
+	work := atomic.Loadint64(&c.scanWork)
+
+	// Assume we're under the soft goal. Pace GC to complete at
+	// next_gc assuming the heap is in steady-state.
+	heapGoal := int64(atomic.Load64(&memstats.next_gc))
+
+	// Compute the expected scan work remaining.
+	//
+	// This is estimated based on the expected
+	// steady-state scannable heap. For example, with
+	// GOGC=100, only half of the scannable heap is
+	// expected to be live, so that's what we target.
+	//
+	// (This is a float calculation to avoid overflowing on
+	// 100*heap_scan.)
+	scanWorkExpected := int64(float64(scan) * 100 / float64(100+gcpercent))
+
+	if int64(live) > heapGoal || work > scanWorkExpected {
+		// We're past the soft goal, or we've already done more scan
+		// work than we expected. Pace GC so that in the worst case it
+		// will complete by the hard goal.
+		const maxOvershoot = 1.1
+		heapGoal = int64(float64(heapGoal) * maxOvershoot)
+
+		// Compute the upper bound on the scan work remaining.
+		scanWorkExpected = int64(scan)
+	}
+
+	// Compute the remaining scan work estimate.
+	//
+	// Note that we currently count allocations during GC as both
+	// scannable heap (heap_scan) and scan work completed
+	// (scanWork), so allocation will change this difference
+	// slowly in the soft regime and not at all in the hard
+	// regime.
+	scanWorkRemaining := scanWorkExpected - work
+	if scanWorkRemaining < 1000 {
+		// We set a somewhat arbitrary lower bound on
+		// remaining scan work since if we aim a little high,
+		// we can miss by a little.
+		//
+		// We *do* need to enforce that this is at least 1,
+		// since marking is racy and double-scanning objects
+		// may legitimately make the remaining scan work
+		// negative, even in the hard goal regime.
+		scanWorkRemaining = 1000
+	}
+
+	// Compute the heap distance remaining.
+	heapRemaining := heapGoal - int64(live)
+	if heapRemaining <= 0 {
+		// This shouldn't happen, but if it does, avoid
+		// dividing by zero or setting the assist negative.
+		heapRemaining = 1
+	}
+
+	// Compute the mutator assist ratio so by the time the mutator
+	// allocates the remaining heap bytes up to next_gc, it will
+	// have done (or stolen) the remaining amount of scan work.
+	// Note that the assist ratio values are updated atomically
+	// but not together. This means there may be some degree of
+	// skew between the two values. This is generally OK as the
+	// values shift relatively slowly over the course of a GC
+	// cycle.
+	assistWorkPerByte := float64(scanWorkRemaining) / float64(heapRemaining)
+	assistBytesPerWork := float64(heapRemaining) / float64(scanWorkRemaining)
+	atomic.Store64(&c.assistWorkPerByte, float64bits(assistWorkPerByte))
+	atomic.Store64(&c.assistBytesPerWork, float64bits(assistBytesPerWork))
+}
+
+// endCycle computes the trigger ratio for the next cycle.
+func (c *gcControllerState) endCycle() float64 {
+	if work.userForced {
+		// Forced GC means this cycle didn't start at the
+		// trigger, so where it finished isn't good
+		// information about how to adjust the trigger.
+		// Just leave it where it is.
+		return memstats.triggerRatio
+	}
+
+	// Proportional response gain for the trigger controller. Must
+	// be in [0, 1]. Lower values smooth out transient effects but
+	// take longer to respond to phase changes. Higher values
+	// react to phase changes quickly, but are more affected by
+	// transient changes. Values near 1 may be unstable.
+	const triggerGain = 0.5
+
+	// Compute next cycle trigger ratio. First, this computes the
+	// "error" for this cycle; that is, how far off the trigger
+	// was from what it should have been, accounting for both heap
+	// growth and GC CPU utilization. We compute the actual heap
+	// growth during this cycle and scale that by how far off from
+	// the goal CPU utilization we were (to estimate the heap
+	// growth if we had the desired CPU utilization). The
+	// difference between this estimate and the GOGC-based goal
+	// heap growth is the error.
+	goalGrowthRatio := gcEffectiveGrowthRatio()
+	actualGrowthRatio := float64(memstats.heap_live)/float64(memstats.heap_marked) - 1
+	assistDuration := nanotime() - c.markStartTime
+
+	// Assume background mark hit its utilization goal.
+	utilization := gcBackgroundUtilization
+	// Add assist utilization; avoid divide by zero.
+	if assistDuration > 0 {
+		utilization += float64(c.assistTime) / float64(assistDuration*int64(gomaxprocs))
+	}
+
+	triggerError := goalGrowthRatio - memstats.triggerRatio - utilization/gcGoalUtilization*(actualGrowthRatio-memstats.triggerRatio)
+
+	// Finally, we adjust the trigger for next time by this error,
+	// damped by the proportional gain.
+	triggerRatio := memstats.triggerRatio + triggerGain*triggerError
+
+	if debug.gcpacertrace > 0 {
+		// Print controller state in terms of the design
+		// document.
+		H_m_prev := memstats.heap_marked
+		h_t := memstats.triggerRatio
+		H_T := memstats.gc_trigger
+		h_a := actualGrowthRatio
+		H_a := memstats.heap_live
+		h_g := goalGrowthRatio
+		H_g := int64(float64(H_m_prev) * (1 + h_g))
+		u_a := utilization
+		u_g := gcGoalUtilization
+		W_a := c.scanWork
+		print("pacer: H_m_prev=", H_m_prev,
+			" h_t=", h_t, " H_T=", H_T,
+			" h_a=", h_a, " H_a=", H_a,
+			" h_g=", h_g, " H_g=", H_g,
+			" u_a=", u_a, " u_g=", u_g,
+			" W_a=", W_a,
+			" goalΔ=", goalGrowthRatio-h_t,
+			" actualΔ=", h_a-h_t,
+			" u_a/u_g=", u_a/u_g,
+			"\n")
+	}
+
+	return triggerRatio
+}
+
+// enlistWorker encourages another dedicated mark worker to start on
+// another P if there are spare worker slots. It is used by putfull
+// when more work is made available.
+//
+//go:nowritebarrier
+func (c *gcControllerState) enlistWorker() {
+	// If there are idle Ps, wake one so it will run an idle worker.
+	// NOTE: This is suspected of causing deadlocks. See golang.org/issue/19112.
+	//
+	//	if atomic.Load(&sched.npidle) != 0 && atomic.Load(&sched.nmspinning) == 0 {
+	//		wakep()
+	//		return
+	//	}
+
+	// There are no idle Ps. If we need more dedicated workers,
+	// try to preempt a running P so it will switch to a worker.
+	if c.dedicatedMarkWorkersNeeded <= 0 {
+		return
+	}
+	// Pick a random other P to preempt.
+	if gomaxprocs <= 1 {
+		return
+	}
+	gp := getg()
+	if gp == nil || gp.m == nil || gp.m.p == 0 {
+		return
+	}
+	myID := gp.m.p.ptr().id
+	for tries := 0; tries < 5; tries++ {
+		id := int32(fastrandn(uint32(gomaxprocs - 1)))
+		if id >= myID {
+			id++
+		}
+		p := allp[id]
+		if p.status != _Prunning {
+			continue
+		}
+		if preemptone(p) {
+			return
+		}
+	}
+}
+
+// findRunnableGCWorker returns a background mark worker for _p_ if it
+// should be run. This must only be called when gcBlackenEnabled != 0.
+func (c *gcControllerState) findRunnableGCWorker(_p_ *p) *g {
+	if gcBlackenEnabled == 0 {
+		throw("gcControllerState.findRunnable: blackening not enabled")
+	}
+
+	if !gcMarkWorkAvailable(_p_) {
+		// No work to be done right now. This can happen at
+		// the end of the mark phase when there are still
+		// assists tapering off. Don't bother running a worker
+		// now because it'll just return immediately.
+		return nil
+	}
+
+	// Grab a worker before we commit to running below.
+	node := (*gcBgMarkWorkerNode)(gcBgMarkWorkerPool.pop())
+	if node == nil {
+		// There is at least one worker per P, so normally there are
+		// enough workers to run on all Ps, if necessary. However, once
+		// a worker enters gcMarkDone it may park without rejoining the
+		// pool, thus freeing a P with no corresponding worker.
+		// gcMarkDone never depends on another worker doing work, so it
+		// is safe to simply do nothing here.
+		//
+		// If gcMarkDone bails out without completing the mark phase,
+		// it will always do so with queued global work. Thus, that P
+		// will be immediately eligible to re-run the worker G it was
+		// just using, ensuring work can complete.
+		return nil
+	}
+
+	decIfPositive := func(ptr *int64) bool {
+		for {
+			v := atomic.Loadint64(ptr)
+			if v <= 0 {
+				return false
+			}
+
+			if atomic.Casint64(ptr, v, v-1) {
+				return true
+			}
+		}
+	}
+
+	if decIfPositive(&c.dedicatedMarkWorkersNeeded) {
+		// This P is now dedicated to marking until the end of
+		// the concurrent mark phase.
+		_p_.gcMarkWorkerMode = gcMarkWorkerDedicatedMode
+	} else if c.fractionalUtilizationGoal == 0 {
+		// No need for fractional workers.
+		gcBgMarkWorkerPool.push(&node.node)
+		return nil
+	} else {
+		// Is this P behind on the fractional utilization
+		// goal?
+		//
+		// This should be kept in sync with pollFractionalWorkerExit.
+		delta := nanotime() - gcController.markStartTime
+		if delta > 0 && float64(_p_.gcFractionalMarkTime)/float64(delta) > c.fractionalUtilizationGoal {
+			// Nope. No need to run a fractional worker.
+			gcBgMarkWorkerPool.push(&node.node)
+			return nil
+		}
+		// Run a fractional worker.
+		_p_.gcMarkWorkerMode = gcMarkWorkerFractionalMode
+	}
+
+	// Run the background mark worker.
+	gp := node.gp.ptr()
+	casgstatus(gp, _Gwaiting, _Grunnable)
+	if trace.enabled {
+		traceGoUnpark(gp, 0)
+	}
+	return gp
+}
+
+// gcSetTriggerRatio sets the trigger ratio and updates everything
+// derived from it: the absolute trigger, the heap goal, mark pacing,
+// and sweep pacing.
+//
+// This can be called any time. If GC is the in the middle of a
+// concurrent phase, it will adjust the pacing of that phase.
+//
+// This depends on gcpercent, memstats.heap_marked, and
+// memstats.heap_live. These must be up to date.
+//
+// mheap_.lock must be held or the world must be stopped.
+func gcSetTriggerRatio(triggerRatio float64) {
+	assertWorldStoppedOrLockHeld(&mheap_.lock)
+
+	// Compute the next GC goal, which is when the allocated heap
+	// has grown by GOGC/100 over the heap marked by the last
+	// cycle.
+	goal := ^uint64(0)
+	if gcpercent >= 0 {
+		goal = memstats.heap_marked + memstats.heap_marked*uint64(gcpercent)/100
+	}
+
+	// Set the trigger ratio, capped to reasonable bounds.
+	if gcpercent >= 0 {
+		scalingFactor := float64(gcpercent) / 100
+		// Ensure there's always a little margin so that the
+		// mutator assist ratio isn't infinity.
+		maxTriggerRatio := 0.95 * scalingFactor
+		if triggerRatio > maxTriggerRatio {
+			triggerRatio = maxTriggerRatio
+		}
+
+		// If we let triggerRatio go too low, then if the application
+		// is allocating very rapidly we might end up in a situation
+		// where we're allocating black during a nearly always-on GC.
+		// The result of this is a growing heap and ultimately an
+		// increase in RSS. By capping us at a point >0, we're essentially
+		// saying that we're OK using more CPU during the GC to prevent
+		// this growth in RSS.
+		//
+		// The current constant was chosen empirically: given a sufficiently
+		// fast/scalable allocator with 48 Ps that could drive the trigger ratio
+		// to <0.05, this constant causes applications to retain the same peak
+		// RSS compared to not having this allocator.
+		minTriggerRatio := 0.6 * scalingFactor
+		if triggerRatio < minTriggerRatio {
+			triggerRatio = minTriggerRatio
+		}
+	} else if triggerRatio < 0 {
+		// gcpercent < 0, so just make sure we're not getting a negative
+		// triggerRatio. This case isn't expected to happen in practice,
+		// and doesn't really matter because if gcpercent < 0 then we won't
+		// ever consume triggerRatio further on in this function, but let's
+		// just be defensive here; the triggerRatio being negative is almost
+		// certainly undesirable.
+		triggerRatio = 0
+	}
+	memstats.triggerRatio = triggerRatio
+
+	// Compute the absolute GC trigger from the trigger ratio.
+	//
+	// We trigger the next GC cycle when the allocated heap has
+	// grown by the trigger ratio over the marked heap size.
+	trigger := ^uint64(0)
+	if gcpercent >= 0 {
+		trigger = uint64(float64(memstats.heap_marked) * (1 + triggerRatio))
+		// Don't trigger below the minimum heap size.
+		minTrigger := heapminimum
+		if !isSweepDone() {
+			// Concurrent sweep happens in the heap growth
+			// from heap_live to gc_trigger, so ensure
+			// that concurrent sweep has some heap growth
+			// in which to perform sweeping before we
+			// start the next GC cycle.
+			sweepMin := atomic.Load64(&memstats.heap_live) + sweepMinHeapDistance
+			if sweepMin > minTrigger {
+				minTrigger = sweepMin
+			}
+		}
+		if trigger < minTrigger {
+			trigger = minTrigger
+		}
+		if int64(trigger) < 0 {
+			print("runtime: next_gc=", memstats.next_gc, " heap_marked=", memstats.heap_marked, " heap_live=", memstats.heap_live, " initialHeapLive=", work.initialHeapLive, "triggerRatio=", triggerRatio, " minTrigger=", minTrigger, "\n")
+			throw("gc_trigger underflow")
+		}
+		if trigger > goal {
+			// The trigger ratio is always less than GOGC/100, but
+			// other bounds on the trigger may have raised it.
+			// Push up the goal, too.
+			goal = trigger
+		}
+	}
+
+	// Commit to the trigger and goal.
+	memstats.gc_trigger = trigger
+	atomic.Store64(&memstats.next_gc, goal)
+	if trace.enabled {
+		traceNextGC()
+	}
+
+	// Update mark pacing.
+	if gcphase != _GCoff {
+		gcController.revise()
+	}
+
+	// Update sweep pacing.
+	if isSweepDone() {
+		mheap_.sweepPagesPerByte = 0
+	} else {
+		// Concurrent sweep needs to sweep all of the in-use
+		// pages by the time the allocated heap reaches the GC
+		// trigger. Compute the ratio of in-use pages to sweep
+		// per byte allocated, accounting for the fact that
+		// some might already be swept.
+		heapLiveBasis := atomic.Load64(&memstats.heap_live)
+		heapDistance := int64(trigger) - int64(heapLiveBasis)
+		// Add a little margin so rounding errors and
+		// concurrent sweep are less likely to leave pages
+		// unswept when GC starts.
+		heapDistance -= 1024 * 1024
+		if heapDistance < _PageSize {
+			// Avoid setting the sweep ratio extremely high
+			heapDistance = _PageSize
+		}
+		pagesSwept := atomic.Load64(&mheap_.pagesSwept)
+		pagesInUse := atomic.Load64(&mheap_.pagesInUse)
+		sweepDistancePages := int64(pagesInUse) - int64(pagesSwept)
+		if sweepDistancePages <= 0 {
+			mheap_.sweepPagesPerByte = 0
+		} else {
+			mheap_.sweepPagesPerByte = float64(sweepDistancePages) / float64(heapDistance)
+			mheap_.sweepHeapLiveBasis = heapLiveBasis
+			// Write pagesSweptBasis last, since this
+			// signals concurrent sweeps to recompute
+			// their debt.
+			atomic.Store64(&mheap_.pagesSweptBasis, pagesSwept)
+		}
+	}
+
+	gcPaceScavenger()
+}
+
+// gcEffectiveGrowthRatio returns the current effective heap growth
+// ratio (GOGC/100) based on heap_marked from the previous GC and
+// next_gc for the current GC.
+//
+// This may differ from gcpercent/100 because of various upper and
+// lower bounds on gcpercent. For example, if the heap is smaller than
+// heapminimum, this can be higher than gcpercent/100.
+//
+// mheap_.lock must be held or the world must be stopped.
+func gcEffectiveGrowthRatio() float64 {
+	assertWorldStoppedOrLockHeld(&mheap_.lock)
+
+	egogc := float64(atomic.Load64(&memstats.next_gc)-memstats.heap_marked) / float64(memstats.heap_marked)
+	if egogc < 0 {
+		// Shouldn't happen, but just in case.
+		egogc = 0
+	}
+	return egogc
+}
+
+//go:linkname setGCPercent runtime/debug.setGCPercent
+func setGCPercent(in int32) (out int32) {
+	// Run on the system stack since we grab the heap lock.
+	systemstack(func() {
+		lock(&mheap_.lock)
+		out = gcpercent
+		if in < 0 {
+			in = -1
+		}
+		gcpercent = in
+		heapminimum = defaultHeapMinimum * uint64(gcpercent) / 100
+		// Update pacing in response to gcpercent change.
+		gcSetTriggerRatio(memstats.triggerRatio)
+		unlock(&mheap_.lock)
+	})
+
+	// If we just disabled GC, wait for any concurrent GC mark to
+	// finish so we always return with no GC running.
+	if in < 0 {
+		gcWaitOnMark(atomic.Load(&work.cycles))
+	}
+
+	return out
+}
+
+func readgogc() int32 {
+	p := gogetenv("GOGC")
+	if p == "off" {
+		return -1
+	}
+	if n, ok := atoi32(p); ok {
+		return n
+	}
+	return 100
+}
-- 
GitLab


From 693859542e71fdd9186fff759bf121e9df197fed Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Wed, 31 Mar 2021 22:06:30 +0000
Subject: [PATCH 1534/2400] runtime: rename gcpercent, readgogc, and
 heapminimum to match Go style

Generated with:

rf 'mv gcpercent gcPercent'
rf 'mv readgogc readGOGC'
rf 'mv heapminimum heapMinimum'

After this, comments referencing these symbols were updated via a simple
sed command.

For #44167.

Change-Id: I6bb01597c2130686c01f967d0f106b06860ad2db
Reviewed-on: https://go-review.googlesource.com/c/go/+/306597
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
---
 src/runtime/mgc.go      | 10 ++++----
 src/runtime/mgcpacer.go | 52 ++++++++++++++++++++---------------------
 2 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index 0c92b2e7b6..8831e27554 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -161,13 +161,13 @@ func gcinit() {
 	memstats.triggerRatio = 7 / 8.0
 
 	// Fake a heap_marked value so it looks like a trigger at
-	// heapminimum is the appropriate growth from heap_marked.
+	// heapMinimum is the appropriate growth from heap_marked.
 	// This will go into computing the initial GC goal.
-	memstats.heap_marked = uint64(float64(heapminimum) / (1 + memstats.triggerRatio))
+	memstats.heap_marked = uint64(float64(heapMinimum) / (1 + memstats.triggerRatio))
 
-	// Set gcpercent from the environment. This will also compute
+	// Set gcPercent from the environment. This will also compute
 	// and set the GC trigger and goal.
-	_ = setGCPercent(readgogc())
+	_ = setGCPercent(readGOGC())
 
 	work.startSema = 1
 	work.markDoneSema = 1
@@ -557,7 +557,7 @@ func (t gcTrigger) test() bool {
 		// own write.
 		return memstats.heap_live >= memstats.gc_trigger
 	case gcTriggerTime:
-		if gcpercent < 0 {
+		if gcPercent < 0 {
 			return false
 		}
 		lastgc := int64(atomic.Load64(&memstats.last_gc_nanotime))
diff --git a/src/runtime/mgcpacer.go b/src/runtime/mgcpacer.go
index b5184b9182..441c397a45 100644
--- a/src/runtime/mgcpacer.go
+++ b/src/runtime/mgcpacer.go
@@ -45,12 +45,12 @@ const (
 	// assist by pre-paying for this many bytes of future allocations.
 	gcOverAssistWork = 64 << 10
 
-	// defaultHeapMinimum is the value of heapminimum for GOGC==100.
+	// defaultHeapMinimum is the value of heapMinimum for GOGC==100.
 	defaultHeapMinimum = 4 << 20
 )
 
 var (
-	// heapminimum is the minimum heap size at which to trigger GC.
+	// heapMinimum is the minimum heap size at which to trigger GC.
 	// For small heaps, this overrides the usual GOGC*live set rule.
 	//
 	// When there is a very small live set but a lot of allocation, simply
@@ -59,13 +59,13 @@ var (
 	// per-GC overhead while keeping the heap reasonably small.
 	//
 	// During initialization this is set to 4MB*GOGC/100. In the case of
-	// GOGC==0, this will set heapminimum to 0, resulting in constant
+	// GOGC==0, this will set heapMinimum to 0, resulting in constant
 	// collection even when the heap size is small, which is useful for
 	// debugging.
-	heapminimum uint64 = defaultHeapMinimum
+	heapMinimum uint64 = defaultHeapMinimum
 
 	// Initialized from $GOGC.  GOGC=off means no GC.
-	gcpercent int32
+	gcPercent int32
 )
 
 // gcController implements the GC pacing controller that determines
@@ -266,11 +266,11 @@ func (c *gcControllerState) startCycle() {
 // is when assists are enabled and the necessary statistics are
 // available).
 func (c *gcControllerState) revise() {
-	gcpercent := gcpercent
-	if gcpercent < 0 {
+	gcPercent := gcPercent
+	if gcPercent < 0 {
 		// If GC is disabled but we're running a forced GC,
 		// act like GOGC is huge for the below calculations.
-		gcpercent = 100000
+		gcPercent = 100000
 	}
 	live := atomic.Load64(&memstats.heap_live)
 	scan := atomic.Load64(&memstats.heap_scan)
@@ -289,7 +289,7 @@ func (c *gcControllerState) revise() {
 	//
 	// (This is a float calculation to avoid overflowing on
 	// 100*heap_scan.)
-	scanWorkExpected := int64(float64(scan) * 100 / float64(100+gcpercent))
+	scanWorkExpected := int64(float64(scan) * 100 / float64(100+gcPercent))
 
 	if int64(live) > heapGoal || work > scanWorkExpected {
 		// We're past the soft goal, or we've already done more scan
@@ -542,7 +542,7 @@ func (c *gcControllerState) findRunnableGCWorker(_p_ *p) *g {
 // This can be called any time. If GC is the in the middle of a
 // concurrent phase, it will adjust the pacing of that phase.
 //
-// This depends on gcpercent, memstats.heap_marked, and
+// This depends on gcPercent, memstats.heap_marked, and
 // memstats.heap_live. These must be up to date.
 //
 // mheap_.lock must be held or the world must be stopped.
@@ -553,13 +553,13 @@ func gcSetTriggerRatio(triggerRatio float64) {
 	// has grown by GOGC/100 over the heap marked by the last
 	// cycle.
 	goal := ^uint64(0)
-	if gcpercent >= 0 {
-		goal = memstats.heap_marked + memstats.heap_marked*uint64(gcpercent)/100
+	if gcPercent >= 0 {
+		goal = memstats.heap_marked + memstats.heap_marked*uint64(gcPercent)/100
 	}
 
 	// Set the trigger ratio, capped to reasonable bounds.
-	if gcpercent >= 0 {
-		scalingFactor := float64(gcpercent) / 100
+	if gcPercent >= 0 {
+		scalingFactor := float64(gcPercent) / 100
 		// Ensure there's always a little margin so that the
 		// mutator assist ratio isn't infinity.
 		maxTriggerRatio := 0.95 * scalingFactor
@@ -584,9 +584,9 @@ func gcSetTriggerRatio(triggerRatio float64) {
 			triggerRatio = minTriggerRatio
 		}
 	} else if triggerRatio < 0 {
-		// gcpercent < 0, so just make sure we're not getting a negative
+		// gcPercent < 0, so just make sure we're not getting a negative
 		// triggerRatio. This case isn't expected to happen in practice,
-		// and doesn't really matter because if gcpercent < 0 then we won't
+		// and doesn't really matter because if gcPercent < 0 then we won't
 		// ever consume triggerRatio further on in this function, but let's
 		// just be defensive here; the triggerRatio being negative is almost
 		// certainly undesirable.
@@ -599,10 +599,10 @@ func gcSetTriggerRatio(triggerRatio float64) {
 	// We trigger the next GC cycle when the allocated heap has
 	// grown by the trigger ratio over the marked heap size.
 	trigger := ^uint64(0)
-	if gcpercent >= 0 {
+	if gcPercent >= 0 {
 		trigger = uint64(float64(memstats.heap_marked) * (1 + triggerRatio))
 		// Don't trigger below the minimum heap size.
-		minTrigger := heapminimum
+		minTrigger := heapMinimum
 		if !isSweepDone() {
 			// Concurrent sweep happens in the heap growth
 			// from heap_live to gc_trigger, so ensure
@@ -682,9 +682,9 @@ func gcSetTriggerRatio(triggerRatio float64) {
 // ratio (GOGC/100) based on heap_marked from the previous GC and
 // next_gc for the current GC.
 //
-// This may differ from gcpercent/100 because of various upper and
-// lower bounds on gcpercent. For example, if the heap is smaller than
-// heapminimum, this can be higher than gcpercent/100.
+// This may differ from gcPercent/100 because of various upper and
+// lower bounds on gcPercent. For example, if the heap is smaller than
+// heapMinimum, this can be higher than gcPercent/100.
 //
 // mheap_.lock must be held or the world must be stopped.
 func gcEffectiveGrowthRatio() float64 {
@@ -703,13 +703,13 @@ func setGCPercent(in int32) (out int32) {
 	// Run on the system stack since we grab the heap lock.
 	systemstack(func() {
 		lock(&mheap_.lock)
-		out = gcpercent
+		out = gcPercent
 		if in < 0 {
 			in = -1
 		}
-		gcpercent = in
-		heapminimum = defaultHeapMinimum * uint64(gcpercent) / 100
-		// Update pacing in response to gcpercent change.
+		gcPercent = in
+		heapMinimum = defaultHeapMinimum * uint64(gcPercent) / 100
+		// Update pacing in response to gcPercent change.
 		gcSetTriggerRatio(memstats.triggerRatio)
 		unlock(&mheap_.lock)
 	})
@@ -723,7 +723,7 @@ func setGCPercent(in int32) (out int32) {
 	return out
 }
 
-func readgogc() int32 {
+func readGOGC() int32 {
 	p := gogetenv("GOGC")
 	if p == "off" {
 		return -1
-- 
GitLab


From efaf75a2166d397b2050cc0bb1b60b0c80698e2d Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Fri, 5 Mar 2021 10:57:48 -0500
Subject: [PATCH 1535/2400] go/*,cmd/gofmt: guard AST changes with the
 typeparams build tag

This CL changes our approach to guarding type parameter functionality
and API. Previously, we guarded type parameter functionality with the
parser.parseTypeParams parser mode, and were in the process of hiding
the type parameter API behind the go1.18 build constraint.

These mechanisms had several limitations:
 + Requiring the parser.parseTypeParams mode to be set meant that
   existing tooling would have to opt-in to type parameters in all
   places where it parses Go files.
 + The parseTypeParams mode value had to be copied in several places.
 + go1.18 is not specific to typeparams, making it difficult to set up
   the builders to run typeparams tests.

This CL addresses the above limitations, and completes the task of
hiding the AST API, by switching to a new 'typeparams' build constraint
and adding a new go/internal/typeparams helper package.

The typeparams build constraint is used to conditionally compile the new
AST changes. The typeparams package provides utilities for accessing and
writing the new AST data, so that we don't have to fragment our parser
or type checker logic across build constraints. The typeparams.Enabled
const is used to guard tests that require type parameter support.

The parseTypeParams parser mode is gone, replaced by a new
typeparams.DisableParsing mode with the opposite sense. Now, type
parameters are only parsed if go/parser is compiled with the typeparams
build constraint set AND typeparams.DisableParsing not set. This new
parser mode allows opting out of type parameter parsing for tests.

How exactly to run tests on builders is left to a follow-up CL.

Updates #44933

Change-Id: I3091e42a2e5e2f23e8b2ae584f415a784b9fbd65
Reviewed-on: https://go-review.googlesource.com/c/go/+/300649
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/gofmt/gofmt.go                        | 11 ----
 src/cmd/gofmt/gofmt_test.go                   |  9 ++-
 ...fmt_go1.18.go => gofmt_typeparams_test.go} |  6 +-
 src/go/ast/ast.go                             | 62 ++++---------------
 src/go/ast/ast_notypeparams.go                | 28 +++++++++
 src/go/ast/ast_typeparams.go                  | 51 +++++++++++++++
 src/go/ast/walk.go                            | 15 +----
 src/go/ast/walk_notypeparams.go               | 17 +++++
 src/go/ast/walk_typeparams.go                 | 30 +++++++++
 src/go/build/deps_test.go                     |  1 +
 src/go/internal/typeparams/common.go          | 13 ++++
 src/go/internal/typeparams/notypeparams.go    | 38 ++++++++++++
 src/go/internal/typeparams/typeparams.go      | 61 ++++++++++++++++++
 src/go/parser/error_test.go                   |  7 ++-
 src/go/parser/interface.go                    |  7 ---
 src/go/parser/parser.go                       | 42 +++++++------
 src/go/parser/resolver.go                     |  6 +-
 src/go/parser/resolver_test.go                |  7 ++-
 src/go/parser/short_test.go                   | 29 ++++++---
 src/go/printer/nodes.go                       | 19 ++++--
 src/go/printer/printer_test.go                | 18 +++---
 src/go/printer/testdata/declarations.golden   | 11 ----
 src/go/printer/testdata/declarations.input    |  9 ---
 src/go/printer/testdata/generics.golden       | 10 +++
 src/go/printer/testdata/generics.input        |  8 +++
 src/go/types/api_test.go                      | 14 ++++-
 .../{api_go1.18.go => api_typeparams.go}      |  4 +-
 ..._go1.18_test.go => api_typeparams_test.go} |  4 +-
 src/go/types/assignments.go                   | 14 -----
 src/go/types/call.go                          |  4 +-
 src/go/types/check_test.go                    | 11 ++--
 src/go/types/decl.go                          |  7 ++-
 src/go/types/exprstring.go                    |  9 ++-
 src/go/types/resolver.go                      |  7 ++-
 src/go/types/typexpr.go                       | 41 ++++++------
 35 files changed, 417 insertions(+), 213 deletions(-)
 rename src/cmd/gofmt/{gofmt_go1.18.go => gofmt_typeparams_test.go} (73%)
 create mode 100644 src/go/ast/ast_notypeparams.go
 create mode 100644 src/go/ast/ast_typeparams.go
 create mode 100644 src/go/ast/walk_notypeparams.go
 create mode 100644 src/go/ast/walk_typeparams.go
 create mode 100644 src/go/internal/typeparams/common.go
 create mode 100644 src/go/internal/typeparams/notypeparams.go
 create mode 100644 src/go/internal/typeparams/typeparams.go
 rename src/go/types/{api_go1.18.go => api_typeparams.go} (90%)
 rename src/go/types/{api_go1.18_test.go => api_typeparams_test.go} (98%)

diff --git a/src/cmd/gofmt/gofmt.go b/src/cmd/gofmt/gofmt.go
index cd867bba15..2793c2c2a4 100644
--- a/src/cmd/gofmt/gofmt.go
+++ b/src/cmd/gofmt/gofmt.go
@@ -33,10 +33,6 @@ var (
 	doDiff      = flag.Bool("d", false, "display diffs instead of rewriting files")
 	allErrors   = flag.Bool("e", false, "report all errors (not just the first 10 on different lines)")
 
-	// allowTypeParams controls whether type parameters are allowed in the code
-	// being formatted. It is enabled for go1.18 in gofmt_go1.18.go.
-	allowTypeParams = false
-
 	// debugging
 	cpuprofile = flag.String("cpuprofile", "", "write cpu profile to this file")
 )
@@ -53,10 +49,6 @@ const (
 	printerNormalizeNumbers = 1 << 30
 )
 
-// parseTypeParams tells go/parser to parse type parameters. Must be kept in
-// sync with go/parser/interface.go.
-const parseTypeParams parser.Mode = 1 << 30
-
 var (
 	fileSet    = token.NewFileSet() // per process FileSet
 	exitCode   = 0
@@ -79,9 +71,6 @@ func initParserMode() {
 	if *allErrors {
 		parserMode |= parser.AllErrors
 	}
-	if allowTypeParams {
-		parserMode |= parseTypeParams
-	}
 }
 
 func isGoFile(f fs.DirEntry) bool {
diff --git a/src/cmd/gofmt/gofmt_test.go b/src/cmd/gofmt/gofmt_test.go
index 9e2239a692..f0d3f8780f 100644
--- a/src/cmd/gofmt/gofmt_test.go
+++ b/src/cmd/gofmt/gofmt_test.go
@@ -49,12 +49,13 @@ func gofmtFlags(filename string, maxLines int) string {
 		case scanner.EOF:
 			return ""
 		}
-
 	}
 
 	return ""
 }
 
+var typeParamsEnabled = false
+
 func runTest(t *testing.T, in, out string) {
 	// process flags
 	*simplifyAST = false
@@ -78,8 +79,10 @@ func runTest(t *testing.T, in, out string) {
 			// fake flag - pretend input is from stdin
 			stdin = true
 		case "-G":
-			// fake flag - allow parsing type parameters
-			allowTypeParams = true
+			// fake flag - test is for generic code
+			if !typeParamsEnabled {
+				return
+			}
 		default:
 			t.Errorf("unrecognized flag name: %s", name)
 		}
diff --git a/src/cmd/gofmt/gofmt_go1.18.go b/src/cmd/gofmt/gofmt_typeparams_test.go
similarity index 73%
rename from src/cmd/gofmt/gofmt_go1.18.go
rename to src/cmd/gofmt/gofmt_typeparams_test.go
index be7b46b5ed..10641a77cb 100644
--- a/src/cmd/gofmt/gofmt_go1.18.go
+++ b/src/cmd/gofmt/gofmt_typeparams_test.go
@@ -2,11 +2,11 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build go1.18
-// +build go1.18
+//go:build typeparams
+// +build typeparams
 
 package main
 
 func init() {
-	allowTypeParams = true
+	typeParamsEnabled = true
 }
diff --git a/src/go/ast/ast.go b/src/go/ast/ast.go
index 6eb4d13f4d..c87529ec77 100644
--- a/src/go/ast/ast.go
+++ b/src/go/ast/ast.go
@@ -374,13 +374,6 @@ type (
 		Rparen   token.Pos // position of ")"
 	}
 
-	// A ListExpr node represents a list of expressions separated by commas.
-	// ListExpr nodes are used as index in IndexExpr nodes representing type
-	// or function instantiations with more than one type argument.
-	ListExpr struct {
-		ElemList []Expr
-	}
-
 	// A StarExpr node represents an expression of the form "*" Expression.
 	// Semantically it could be a unary "*" expression, or a pointer type.
 	//
@@ -447,14 +440,6 @@ type (
 
 	// Pointer types are represented via StarExpr nodes.
 
-	// A FuncType node represents a function type.
-	FuncType struct {
-		Func    token.Pos  // position of "func" keyword (token.NoPos if there is no "func")
-		TParams *FieldList // type parameters; or nil
-		Params  *FieldList // (incoming) parameters; non-nil
-		Results *FieldList // (outgoing) results; or nil
-	}
-
 	// An InterfaceType node represents an interface type.
 	InterfaceType struct {
 		Interface  token.Pos  // position of "interface" keyword
@@ -497,18 +482,12 @@ func (x *IndexExpr) Pos() token.Pos      { return x.X.Pos() }
 func (x *SliceExpr) Pos() token.Pos      { return x.X.Pos() }
 func (x *TypeAssertExpr) Pos() token.Pos { return x.X.Pos() }
 func (x *CallExpr) Pos() token.Pos       { return x.Fun.Pos() }
-func (x *ListExpr) Pos() token.Pos {
-	if len(x.ElemList) > 0 {
-		return x.ElemList[0].Pos()
-	}
-	return token.NoPos
-}
-func (x *StarExpr) Pos() token.Pos     { return x.Star }
-func (x *UnaryExpr) Pos() token.Pos    { return x.OpPos }
-func (x *BinaryExpr) Pos() token.Pos   { return x.X.Pos() }
-func (x *KeyValueExpr) Pos() token.Pos { return x.Key.Pos() }
-func (x *ArrayType) Pos() token.Pos    { return x.Lbrack }
-func (x *StructType) Pos() token.Pos   { return x.Struct }
+func (x *StarExpr) Pos() token.Pos       { return x.Star }
+func (x *UnaryExpr) Pos() token.Pos      { return x.OpPos }
+func (x *BinaryExpr) Pos() token.Pos     { return x.X.Pos() }
+func (x *KeyValueExpr) Pos() token.Pos   { return x.Key.Pos() }
+func (x *ArrayType) Pos() token.Pos      { return x.Lbrack }
+func (x *StructType) Pos() token.Pos     { return x.Struct }
 func (x *FuncType) Pos() token.Pos {
 	if x.Func.IsValid() || x.Params == nil { // see issue 3870
 		return x.Func
@@ -536,18 +515,12 @@ func (x *IndexExpr) End() token.Pos      { return x.Rbrack + 1 }
 func (x *SliceExpr) End() token.Pos      { return x.Rbrack + 1 }
 func (x *TypeAssertExpr) End() token.Pos { return x.Rparen + 1 }
 func (x *CallExpr) End() token.Pos       { return x.Rparen + 1 }
-func (x *ListExpr) End() token.Pos {
-	if len(x.ElemList) > 0 {
-		return x.ElemList[len(x.ElemList)-1].End()
-	}
-	return token.NoPos
-}
-func (x *StarExpr) End() token.Pos     { return x.X.End() }
-func (x *UnaryExpr) End() token.Pos    { return x.X.End() }
-func (x *BinaryExpr) End() token.Pos   { return x.Y.End() }
-func (x *KeyValueExpr) End() token.Pos { return x.Value.End() }
-func (x *ArrayType) End() token.Pos    { return x.Elt.End() }
-func (x *StructType) End() token.Pos   { return x.Fields.End() }
+func (x *StarExpr) End() token.Pos       { return x.X.End() }
+func (x *UnaryExpr) End() token.Pos      { return x.X.End() }
+func (x *BinaryExpr) End() token.Pos     { return x.Y.End() }
+func (x *KeyValueExpr) End() token.Pos   { return x.Value.End() }
+func (x *ArrayType) End() token.Pos      { return x.Elt.End() }
+func (x *StructType) End() token.Pos     { return x.Fields.End() }
 func (x *FuncType) End() token.Pos {
 	if x.Results != nil {
 		return x.Results.End()
@@ -573,7 +546,6 @@ func (*IndexExpr) exprNode()      {}
 func (*SliceExpr) exprNode()      {}
 func (*TypeAssertExpr) exprNode() {}
 func (*CallExpr) exprNode()       {}
-func (*ListExpr) exprNode()       {}
 func (*StarExpr) exprNode()       {}
 func (*UnaryExpr) exprNode()      {}
 func (*BinaryExpr) exprNode()     {}
@@ -920,16 +892,6 @@ type (
 		Values  []Expr        // initial values; or nil
 		Comment *CommentGroup // line comments; or nil
 	}
-
-	// A TypeSpec node represents a type declaration (TypeSpec production).
-	TypeSpec struct {
-		Doc     *CommentGroup // associated documentation; or nil
-		Name    *Ident        // type name
-		TParams *FieldList    // type parameters; or nil
-		Assign  token.Pos     // position of '=', if any
-		Type    Expr          // *Ident, *ParenExpr, *SelectorExpr, *StarExpr, or any of the *XxxTypes
-		Comment *CommentGroup // line comments; or nil
-	}
 )
 
 // Pos and End implementations for spec nodes.
diff --git a/src/go/ast/ast_notypeparams.go b/src/go/ast/ast_notypeparams.go
new file mode 100644
index 0000000000..fa132fba85
--- /dev/null
+++ b/src/go/ast/ast_notypeparams.go
@@ -0,0 +1,28 @@
+// Copyright 2021 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.
+
+//go:build !typeparams
+// +build !typeparams
+
+package ast
+
+import "go/token"
+
+type (
+	// A FuncType node represents a function type.
+	FuncType struct {
+		Func    token.Pos  // position of "func" keyword (token.NoPos if there is no "func")
+		Params  *FieldList // (incoming) parameters; non-nil
+		Results *FieldList // (outgoing) results; or nil
+	}
+
+	// A TypeSpec node represents a type declaration (TypeSpec production).
+	TypeSpec struct {
+		Doc     *CommentGroup // associated documentation; or nil
+		Name    *Ident        // type name
+		Assign  token.Pos     // position of '=', if any
+		Type    Expr          // *Ident, *ParenExpr, *SelectorExpr, *StarExpr, or any of the *XxxTypes
+		Comment *CommentGroup // line comments; or nil
+	}
+)
diff --git a/src/go/ast/ast_typeparams.go b/src/go/ast/ast_typeparams.go
new file mode 100644
index 0000000000..24fdc5f131
--- /dev/null
+++ b/src/go/ast/ast_typeparams.go
@@ -0,0 +1,51 @@
+// Copyright 2021 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.
+
+//go:build typeparams
+// +build typeparams
+
+package ast
+
+import "go/token"
+
+type (
+	// A FuncType node represents a function type.
+	FuncType struct {
+		Func    token.Pos  // position of "func" keyword (token.NoPos if there is no "func")
+		TParams *FieldList // type parameters; or nil
+		Params  *FieldList // (incoming) parameters; non-nil
+		Results *FieldList // (outgoing) results; or nil
+	}
+
+	// A TypeSpec node represents a type declaration (TypeSpec production).
+	TypeSpec struct {
+		Doc     *CommentGroup // associated documentation; or nil
+		Name    *Ident        // type name
+		TParams *FieldList    // type parameters; or nil
+		Assign  token.Pos     // position of '=', if any
+		Type    Expr          // *Ident, *ParenExpr, *SelectorExpr, *StarExpr, or any of the *XxxTypes
+		Comment *CommentGroup // line comments; or nil
+	}
+
+	// A ListExpr node represents a list of expressions separated by commas.
+	// ListExpr nodes are used as index in IndexExpr nodes representing type
+	// or function instantiations with more than one type argument.
+	ListExpr struct {
+		ElemList []Expr
+	}
+)
+
+func (*ListExpr) exprNode() {}
+func (x *ListExpr) Pos() token.Pos {
+	if len(x.ElemList) > 0 {
+		return x.ElemList[0].Pos()
+	}
+	return token.NoPos
+}
+func (x *ListExpr) End() token.Pos {
+	if len(x.ElemList) > 0 {
+		return x.ElemList[len(x.ElemList)-1].End()
+	}
+	return token.NoPos
+}
diff --git a/src/go/ast/walk.go b/src/go/ast/walk.go
index a57ff25ac5..9224264e29 100644
--- a/src/go/ast/walk.go
+++ b/src/go/ast/walk.go
@@ -4,8 +4,6 @@
 
 package ast
 
-import "fmt"
-
 // A Visitor's Visit method is invoked for each node encountered by Walk.
 // If the result visitor w is not nil, Walk visits each of the children
 // of node with the visitor w, followed by a call of w.Visit(nil).
@@ -116,9 +114,6 @@ func Walk(v Visitor, node Node) {
 		Walk(v, n.X)
 		Walk(v, n.Index)
 
-	case *ListExpr:
-		walkExprList(v, n.ElemList)
-
 	case *SliceExpr:
 		Walk(v, n.X)
 		if n.Low != nil {
@@ -166,9 +161,7 @@ func Walk(v Visitor, node Node) {
 		Walk(v, n.Fields)
 
 	case *FuncType:
-		if n.TParams != nil {
-			Walk(v, n.TParams)
-		}
+		walkFuncTypeParams(v, n)
 		if n.Params != nil {
 			Walk(v, n.Params)
 		}
@@ -323,9 +316,7 @@ func Walk(v Visitor, node Node) {
 			Walk(v, n.Doc)
 		}
 		Walk(v, n.Name)
-		if n.TParams != nil {
-			Walk(v, n.TParams)
-		}
+		walkTypeSpecParams(v, n)
 		Walk(v, n.Type)
 		if n.Comment != nil {
 			Walk(v, n.Comment)
@@ -372,7 +363,7 @@ func Walk(v Visitor, node Node) {
 		}
 
 	default:
-		panic(fmt.Sprintf("ast.Walk: unexpected node type %T", n))
+		walkOtherNodes(v, n)
 	}
 
 	v.Visit(nil)
diff --git a/src/go/ast/walk_notypeparams.go b/src/go/ast/walk_notypeparams.go
new file mode 100644
index 0000000000..d43e13dd11
--- /dev/null
+++ b/src/go/ast/walk_notypeparams.go
@@ -0,0 +1,17 @@
+// Copyright 2021 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.
+
+//go:build !typeparams
+// +build !typeparams
+
+package ast
+
+import "fmt"
+
+func walkFuncTypeParams(v Visitor, n *FuncType) {}
+func walkTypeSpecParams(v Visitor, n *TypeSpec) {}
+
+func walkOtherNodes(v Visitor, n Node) {
+	panic(fmt.Sprintf("ast.Walk: unexpected node type %T", n))
+}
diff --git a/src/go/ast/walk_typeparams.go b/src/go/ast/walk_typeparams.go
new file mode 100644
index 0000000000..77267a5b8c
--- /dev/null
+++ b/src/go/ast/walk_typeparams.go
@@ -0,0 +1,30 @@
+// Copyright 2021 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.
+
+//go:build typeparams
+// +build typeparams
+
+package ast
+
+func walkFuncTypeParams(v Visitor, n *FuncType) {
+	if n.TParams != nil {
+		Walk(v, n.TParams)
+	}
+}
+
+func walkTypeSpecParams(v Visitor, n *TypeSpec) {
+	if n.TParams != nil {
+		Walk(v, n.TParams)
+	}
+}
+
+func walkOtherNodes(v Visitor, n Node) {
+	if e, ok := n.(*ast.ListExpr); ok {
+		if e != nil {
+			Walk(v, e)
+		}
+	} else {
+		panic(fmt.Sprintf("ast.Walk: unexpected node type %T", n))
+	}
+}
diff --git a/src/go/build/deps_test.go b/src/go/build/deps_test.go
index a1a4324331..a1ed834c71 100644
--- a/src/go/build/deps_test.go
+++ b/src/go/build/deps_test.go
@@ -278,6 +278,7 @@ var depsRules = `
 	< go/token
 	< go/scanner
 	< go/ast
+	< go/internal/typeparams
 	< go/parser;
 
 	FMT
diff --git a/src/go/internal/typeparams/common.go b/src/go/internal/typeparams/common.go
new file mode 100644
index 0000000000..47b8f7cf02
--- /dev/null
+++ b/src/go/internal/typeparams/common.go
@@ -0,0 +1,13 @@
+// Copyright 2021 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 typeparams provides functions to work with type parameter data
+// stored in the AST, while these AST changes are guarded by a build
+// constraint.
+package typeparams
+
+// DisallowParsing is the numeric value of a parsing mode that disallows type
+// parameters. This only matters if the typeparams experiment is active, and
+// may be used for running tests that disallow generics.
+const DisallowParsing = 1 << 30
diff --git a/src/go/internal/typeparams/notypeparams.go b/src/go/internal/typeparams/notypeparams.go
new file mode 100644
index 0000000000..7bd62c9efe
--- /dev/null
+++ b/src/go/internal/typeparams/notypeparams.go
@@ -0,0 +1,38 @@
+// Copyright 2021 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.
+
+//go:build !typeparams
+// +build !typeparams
+
+package typeparams
+
+import (
+	"go/ast"
+)
+
+const Enabled = false
+
+func PackExpr(list []ast.Expr) ast.Expr {
+	switch len(list) {
+	case 0:
+		return nil
+	case 1:
+		return list[0]
+	default:
+		// The parser should not attempt to pack multiple expressions into an
+		// IndexExpr if type params are disabled.
+		panic("multiple index expressions are unsupported without type params")
+	}
+}
+
+func UnpackExpr(expr ast.Expr) []ast.Expr {
+	return []ast.Expr{expr}
+}
+
+func Get(ast.Node) *ast.FieldList {
+	return nil
+}
+
+func Set(node ast.Node, params *ast.FieldList) {
+}
diff --git a/src/go/internal/typeparams/typeparams.go b/src/go/internal/typeparams/typeparams.go
new file mode 100644
index 0000000000..0332b6b816
--- /dev/null
+++ b/src/go/internal/typeparams/typeparams.go
@@ -0,0 +1,61 @@
+// Copyright 2021 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.
+
+//go:build typeparams
+// +build typeparams
+
+package typeparams
+
+import (
+	"fmt"
+	"go/ast"
+)
+
+const Enabled = true
+
+func PackExpr(list []ast.Expr) ast.Expr {
+	switch len(list) {
+	case 0:
+		return nil
+	case 1:
+		return list[0]
+	default:
+		return &ast.ListExpr{ElemList: list}
+	}
+}
+
+// TODO(gri) Should find a more efficient solution that doesn't
+//           require introduction of a new slice for simple
+//           expressions.
+func UnpackExpr(x ast.Expr) []ast.Expr {
+	if x, _ := x.(*ast.ListExpr); x != nil {
+		return x.ElemList
+	}
+	if x != nil {
+		return []ast.Expr{x}
+	}
+	return nil
+}
+
+func Get(n ast.Node) *ast.FieldList {
+	switch n := n.(type) {
+	case *ast.TypeSpec:
+		return n.TParams
+	case *ast.FuncType:
+		return n.TParams
+	default:
+		panic(fmt.Sprintf("node type %T has no type parameters", n))
+	}
+}
+
+func Set(n ast.Node, params *ast.FieldList) {
+	switch n := n.(type) {
+	case *ast.TypeSpec:
+		n.TParams = params
+	case *ast.FuncType:
+		n.TParams = params
+	default:
+		panic(fmt.Sprintf("node type %T has no type parameters", n))
+	}
+}
diff --git a/src/go/parser/error_test.go b/src/go/parser/error_test.go
index 3caa3571e6..5d45a7b817 100644
--- a/src/go/parser/error_test.go
+++ b/src/go/parser/error_test.go
@@ -23,6 +23,7 @@
 package parser
 
 import (
+	"go/internal/typeparams"
 	"go/scanner"
 	"go/token"
 	"os"
@@ -188,7 +189,11 @@ func TestErrors(t *testing.T) {
 		if !d.IsDir() && !strings.HasPrefix(name, ".") && (strings.HasSuffix(name, ".src") || strings.HasSuffix(name, ".go2")) {
 			mode := DeclarationErrors | AllErrors
 			if strings.HasSuffix(name, ".go2") {
-				mode |= parseTypeParams
+				if !typeparams.Enabled {
+					continue
+				}
+			} else {
+				mode |= typeparams.DisallowParsing
 			}
 			checkErrors(t, filepath.Join(testdata, name), nil, mode, true)
 		}
diff --git a/src/go/parser/interface.go b/src/go/parser/interface.go
index 8f306adaab..dcc5fa6616 100644
--- a/src/go/parser/interface.go
+++ b/src/go/parser/interface.go
@@ -56,13 +56,6 @@ const (
 	DeclarationErrors                              // report declaration errors
 	SpuriousErrors                                 // same as AllErrors, for backward-compatibility
 	AllErrors         = SpuriousErrors             // report all errors (not just the first 10 on different lines)
-
-	// parseTypeParams controls the parsing of type parameters. Must be
-	// kept in sync with:
-	//  go/printer/printer_test.go
-	//  go/types/check_test.go
-	//  cmd/gofmt/gofmt.go
-	parseTypeParams = 1 << 30
 )
 
 // ParseFile parses the source code of a single Go source file and returns
diff --git a/src/go/parser/parser.go b/src/go/parser/parser.go
index 93ab4a4600..aff5838780 100644
--- a/src/go/parser/parser.go
+++ b/src/go/parser/parser.go
@@ -19,6 +19,7 @@ package parser
 import (
 	"fmt"
 	"go/ast"
+	"go/internal/typeparams"
 	"go/scanner"
 	"go/token"
 	"strconv"
@@ -75,6 +76,10 @@ func (p *parser) init(fset *token.FileSet, filename string, src []byte, mode Mod
 	p.next()
 }
 
+func (p *parser) parseTypeParams() bool {
+	return typeparams.Enabled && p.mode&typeparams.DisallowParsing == 0
+}
+
 // ----------------------------------------------------------------------------
 // Parsing support
 
@@ -494,7 +499,7 @@ func (p *parser) parseQualifiedIdent(ident *ast.Ident) ast.Expr {
 	}
 
 	typ := p.parseTypeName(ident)
-	if p.tok == token.LBRACK && p.mode&parseTypeParams != 0 {
+	if p.tok == token.LBRACK && p.parseTypeParams() {
 		typ = p.parseTypeInstance(typ)
 	}
 
@@ -553,7 +558,7 @@ func (p *parser) parseArrayFieldOrTypeInstance(x *ast.Ident) (*ast.Ident, ast.Ex
 	// TODO(rfindley): consider changing parseRhsOrType so that this function variable
 	// is not needed.
 	argparser := p.parseRhsOrType
-	if p.mode&parseTypeParams == 0 {
+	if !p.parseTypeParams() {
 		argparser = p.parseRhs
 	}
 	if p.tok != token.RBRACK {
@@ -583,19 +588,19 @@ func (p *parser) parseArrayFieldOrTypeInstance(x *ast.Ident) (*ast.Ident, ast.Ex
 			// x [P]E
 			return x, &ast.ArrayType{Lbrack: lbrack, Len: args[0], Elt: elt}
 		}
-		if p.mode&parseTypeParams == 0 {
+		if !p.parseTypeParams() {
 			p.error(rbrack, "missing element type in array type expression")
 			return nil, &ast.BadExpr{From: args[0].Pos(), To: args[0].End()}
 		}
 	}
 
-	if p.mode&parseTypeParams == 0 {
+	if !p.parseTypeParams() {
 		p.error(firstComma, "expected ']', found ','")
 		return x, &ast.BadExpr{From: args[0].Pos(), To: args[len(args)-1].End()}
 	}
 
 	// x[P], x[P1, P2], ...
-	return nil, &ast.IndexExpr{X: x, Lbrack: lbrack, Index: &ast.ListExpr{ElemList: args}, Rbrack: rbrack}
+	return nil, &ast.IndexExpr{X: x, Lbrack: lbrack, Index: typeparams.PackExpr(args), Rbrack: rbrack}
 }
 
 func (p *parser) parseFieldDecl() *ast.Field {
@@ -878,7 +883,7 @@ func (p *parser) parseParameters(acceptTParams bool) (tparams, params *ast.Field
 		defer un(trace(p, "Parameters"))
 	}
 
-	if p.mode&parseTypeParams != 0 && acceptTParams && p.tok == token.LBRACK {
+	if p.parseTypeParams() && acceptTParams && p.tok == token.LBRACK {
 		opening := p.pos
 		p.next()
 		// [T any](params) syntax
@@ -951,7 +956,7 @@ func (p *parser) parseMethodSpec() *ast.Field {
 	x := p.parseTypeName(nil)
 	if ident, _ := x.(*ast.Ident); ident != nil {
 		switch {
-		case p.tok == token.LBRACK && p.mode&parseTypeParams != 0:
+		case p.tok == token.LBRACK && p.parseTypeParams():
 			// generic method or embedded instantiated type
 			lbrack := p.pos
 			p.next()
@@ -967,7 +972,8 @@ func (p *parser) parseMethodSpec() *ast.Field {
 				_, params := p.parseParameters(false)
 				results := p.parseResult()
 				idents = []*ast.Ident{ident}
-				typ = &ast.FuncType{Func: token.NoPos, TParams: tparams, Params: params, Results: results}
+				typ = &ast.FuncType{Func: token.NoPos, Params: params, Results: results}
+				typeparams.Set(typ, tparams)
 			} else {
 				// embedded instantiated type
 				// TODO(rfindley) should resolve all identifiers in x.
@@ -984,7 +990,7 @@ func (p *parser) parseMethodSpec() *ast.Field {
 					p.exprLev--
 				}
 				rbrack := p.expectClosing(token.RBRACK, "type argument list")
-				typ = &ast.IndexExpr{X: ident, Lbrack: lbrack, Index: &ast.ListExpr{ElemList: list}, Rbrack: rbrack}
+				typ = &ast.IndexExpr{X: ident, Lbrack: lbrack, Index: typeparams.PackExpr(list), Rbrack: rbrack}
 			}
 		case p.tok == token.LPAREN:
 			// ordinary method
@@ -1000,7 +1006,7 @@ func (p *parser) parseMethodSpec() *ast.Field {
 	} else {
 		// embedded, possibly instantiated type
 		typ = x
-		if p.tok == token.LBRACK && p.mode&parseTypeParams != 0 {
+		if p.tok == token.LBRACK && p.parseTypeParams() {
 			// embedded instantiated interface
 			typ = p.parseTypeInstance(typ)
 		}
@@ -1020,7 +1026,7 @@ func (p *parser) parseInterfaceType() *ast.InterfaceType {
 	pos := p.expect(token.INTERFACE)
 	lbrace := p.expect(token.LBRACE)
 	var list []*ast.Field
-	for p.tok == token.IDENT || p.mode&parseTypeParams != 0 && p.tok == token.TYPE {
+	for p.tok == token.IDENT || p.parseTypeParams() && p.tok == token.TYPE {
 		if p.tok == token.IDENT {
 			list = append(list, p.parseMethodSpec())
 		} else {
@@ -1108,14 +1114,14 @@ func (p *parser) parseTypeInstance(typ ast.Expr) ast.Expr {
 
 	closing := p.expectClosing(token.RBRACK, "type argument list")
 
-	return &ast.IndexExpr{X: typ, Lbrack: opening, Index: &ast.ListExpr{ElemList: list}, Rbrack: closing}
+	return &ast.IndexExpr{X: typ, Lbrack: opening, Index: typeparams.PackExpr(list), Rbrack: closing}
 }
 
 func (p *parser) tryIdentOrType() ast.Expr {
 	switch p.tok {
 	case token.IDENT:
 		typ := p.parseTypeName(nil)
-		if p.tok == token.LBRACK && p.mode&parseTypeParams != 0 {
+		if p.tok == token.LBRACK && p.parseTypeParams() {
 			typ = p.parseTypeInstance(typ)
 		}
 		return typ
@@ -1360,13 +1366,13 @@ func (p *parser) parseIndexOrSliceOrInstance(x ast.Expr) ast.Expr {
 		return &ast.IndexExpr{X: x, Lbrack: lbrack, Index: index[0], Rbrack: rbrack}
 	}
 
-	if p.mode&parseTypeParams == 0 {
+	if !p.parseTypeParams() {
 		p.error(firstComma, "expected ']' or ':', found ','")
 		return &ast.BadExpr{From: args[0].Pos(), To: args[len(args)-1].End()}
 	}
 
 	// instance expression
-	return &ast.IndexExpr{X: x, Lbrack: lbrack, Index: &ast.ListExpr{ElemList: args}, Rbrack: rbrack}
+	return &ast.IndexExpr{X: x, Lbrack: lbrack, Index: typeparams.PackExpr(args), Rbrack: rbrack}
 }
 
 func (p *parser) parseCallOrConversion(fun ast.Expr) *ast.CallExpr {
@@ -2406,7 +2412,7 @@ func (p *parser) parseValueSpec(doc *ast.CommentGroup, _ token.Pos, keyword toke
 func (p *parser) parseGenericType(spec *ast.TypeSpec, openPos token.Pos, name0 *ast.Ident, closeTok token.Token) {
 	list := p.parseParameterList(name0, closeTok, p.parseParamDecl, true)
 	closePos := p.expect(closeTok)
-	spec.TParams = &ast.FieldList{Opening: openPos, List: list, Closing: closePos}
+	typeparams.Set(spec, &ast.FieldList{Opening: openPos, List: list, Closing: closePos})
 	// Type alias cannot have type parameters. Accept them for robustness but complain.
 	if p.tok == token.ASSIGN {
 		p.error(p.pos, "generic type cannot be alias")
@@ -2432,7 +2438,7 @@ func (p *parser) parseTypeSpec(doc *ast.CommentGroup, _ token.Pos, _ token.Token
 			p.exprLev++
 			x := p.parseExpr()
 			p.exprLev--
-			if name0, _ := x.(*ast.Ident); p.mode&parseTypeParams != 0 && name0 != nil && p.tok != token.RBRACK {
+			if name0, _ := x.(*ast.Ident); p.parseTypeParams() && name0 != nil && p.tok != token.RBRACK {
 				// generic type [T any];
 				p.parseGenericType(spec, lbrack, name0, token.RBRACK)
 			} else {
@@ -2537,12 +2543,12 @@ func (p *parser) parseFuncDecl() *ast.FuncDecl {
 		Name: ident,
 		Type: &ast.FuncType{
 			Func:    pos,
-			TParams: tparams,
 			Params:  params,
 			Results: results,
 		},
 		Body: body,
 	}
+	typeparams.Set(decl.Type, tparams)
 	return decl
 }
 
diff --git a/src/go/parser/resolver.go b/src/go/parser/resolver.go
index dd77b685e3..1e357e26df 100644
--- a/src/go/parser/resolver.go
+++ b/src/go/parser/resolver.go
@@ -7,6 +7,7 @@ package parser
 import (
 	"fmt"
 	"go/ast"
+	"go/internal/typeparams"
 	"go/token"
 )
 
@@ -450,10 +451,10 @@ func (r *resolver) Visit(node ast.Node) ast.Visitor {
 				// at the identifier in the TypeSpec and ends at the end of the innermost
 				// containing block.
 				r.declare(spec, nil, r.topScope, ast.Typ, spec.Name)
-				if spec.TParams != nil {
+				if tparams := typeparams.Get(spec); tparams != nil {
 					r.openScope(spec.Pos())
 					defer r.closeScope()
-					r.walkFieldList(r.topScope, spec.TParams, ast.Typ)
+					r.walkFieldList(r.topScope, tparams, ast.Typ)
 				}
 				ast.Walk(r, spec.Type)
 			}
@@ -476,7 +477,6 @@ func (r *resolver) Visit(node ast.Node) ast.Visitor {
 }
 
 func (r *resolver) walkFuncType(scope *ast.Scope, typ *ast.FuncType) {
-	r.walkFieldList(scope, typ.TParams, ast.Typ)
 	r.walkFieldList(scope, typ.Params, ast.Var)
 	r.walkFieldList(scope, typ.Results, ast.Var)
 }
diff --git a/src/go/parser/resolver_test.go b/src/go/parser/resolver_test.go
index 9ae2844d73..80a6638210 100644
--- a/src/go/parser/resolver_test.go
+++ b/src/go/parser/resolver_test.go
@@ -7,6 +7,7 @@ package parser
 import (
 	"fmt"
 	"go/ast"
+	"go/internal/typeparams"
 	"go/scanner"
 	"go/token"
 	"os"
@@ -41,7 +42,11 @@ func TestResolution(t *testing.T) {
 			src := readFile(path) // panics on failure
 			var mode Mode
 			if strings.HasSuffix(path, ".go2") {
-				mode = parseTypeParams
+				if !typeparams.Enabled {
+					t.Skip("type params are not enabled")
+				}
+			} else {
+				mode |= typeparams.DisallowParsing
 			}
 			file, err := ParseFile(fset, path, src, mode)
 			if err != nil {
diff --git a/src/go/parser/short_test.go b/src/go/parser/short_test.go
index b21dd0aa60..67fef15665 100644
--- a/src/go/parser/short_test.go
+++ b/src/go/parser/short_test.go
@@ -6,7 +6,10 @@
 
 package parser
 
-import "testing"
+import (
+	"go/internal/typeparams"
+	"testing"
+)
 
 var valids = []string{
 	"package p\n",
@@ -130,19 +133,22 @@ func TestValid(t *testing.T) {
 		}
 	})
 	t.Run("tparams", func(t *testing.T) {
+		if !typeparams.Enabled {
+			t.Skip("type params are not enabled")
+		}
 		for _, src := range valids {
-			checkErrors(t, src, src, DeclarationErrors|AllErrors|parseTypeParams, false)
+			checkErrors(t, src, src, DeclarationErrors|AllErrors, false)
 		}
 		for _, src := range validWithTParamsOnly {
-			checkErrors(t, src, src, DeclarationErrors|AllErrors|parseTypeParams, false)
+			checkErrors(t, src, src, DeclarationErrors|AllErrors, false)
 		}
 	})
 }
 
 // TestSingle is useful to track down a problem with a single short test program.
 func TestSingle(t *testing.T) {
-	const src = `package p; var _ = T[P]{}`
-	checkErrors(t, src, src, DeclarationErrors|AllErrors|parseTypeParams, true)
+	const src = `package p; var _ = T{}`
+	checkErrors(t, src, src, DeclarationErrors|AllErrors, true)
 }
 
 var invalids = []string{
@@ -250,21 +256,24 @@ var invalidTParamErrs = []string{
 func TestInvalid(t *testing.T) {
 	t.Run("no tparams", func(t *testing.T) {
 		for _, src := range invalids {
-			checkErrors(t, src, src, DeclarationErrors|AllErrors, true)
+			checkErrors(t, src, src, DeclarationErrors|AllErrors|typeparams.DisallowParsing, true)
 		}
 		for _, src := range validWithTParamsOnly {
-			checkErrors(t, src, src, DeclarationErrors|AllErrors, true)
+			checkErrors(t, src, src, DeclarationErrors|AllErrors|typeparams.DisallowParsing, true)
 		}
 		for _, src := range invalidNoTParamErrs {
-			checkErrors(t, src, src, DeclarationErrors|AllErrors, true)
+			checkErrors(t, src, src, DeclarationErrors|AllErrors|typeparams.DisallowParsing, true)
 		}
 	})
 	t.Run("tparams", func(t *testing.T) {
+		if !typeparams.Enabled {
+			t.Skip("type params are not enabled")
+		}
 		for _, src := range invalids {
-			checkErrors(t, src, src, DeclarationErrors|AllErrors|parseTypeParams, true)
+			checkErrors(t, src, src, DeclarationErrors|AllErrors, true)
 		}
 		for _, src := range invalidTParamErrs {
-			checkErrors(t, src, src, DeclarationErrors|AllErrors|parseTypeParams, true)
+			checkErrors(t, src, src, DeclarationErrors|AllErrors, true)
 		}
 	})
 }
diff --git a/src/go/printer/nodes.go b/src/go/printer/nodes.go
index 1c0a14ec15..913281ea6c 100644
--- a/src/go/printer/nodes.go
+++ b/src/go/printer/nodes.go
@@ -11,6 +11,7 @@ package printer
 import (
 	"bytes"
 	"go/ast"
+	"go/internal/typeparams"
 	"go/token"
 	"math"
 	"strconv"
@@ -382,8 +383,8 @@ func (p *printer) parameters(fields *ast.FieldList, isTypeParam bool) {
 }
 
 func (p *printer) signature(sig *ast.FuncType) {
-	if sig.TParams != nil {
-		p.parameters(sig.TParams, true)
+	if tparams := typeparams.Get(sig); tparams != nil {
+		p.parameters(tparams, true)
 	}
 	if sig.Params != nil {
 		p.parameters(sig.Params, false)
@@ -870,8 +871,14 @@ func (p *printer) expr1(expr ast.Expr, prec1, depth int) {
 		// TODO(gri): should treat[] like parentheses and undo one level of depth
 		p.expr1(x.X, token.HighestPrec, 1)
 		p.print(x.Lbrack, token.LBRACK)
-		if e, _ := x.Index.(*ast.ListExpr); e != nil {
-			p.exprList(x.Lbrack, e.ElemList, depth+1, commaTerm, x.Rbrack, false)
+		// Note: we're a bit defensive here to handle the case of a ListExpr of
+		// length 1.
+		if list := typeparams.UnpackExpr(x.Index); len(list) > 0 {
+			if len(list) > 1 {
+				p.exprList(x.Lbrack, list, depth+1, commaTerm, x.Rbrack, false)
+			} else {
+				p.expr0(list[0], depth+1)
+			}
 		} else {
 			p.expr0(x.Index, depth+1)
 		}
@@ -1628,8 +1635,8 @@ func (p *printer) spec(spec ast.Spec, n int, doIndent bool) {
 	case *ast.TypeSpec:
 		p.setComment(s.Doc)
 		p.expr(s.Name)
-		if s.TParams != nil {
-			p.parameters(s.TParams, true)
+		if tparams := typeparams.Get(s); tparams != nil {
+			p.parameters(tparams, true)
 		}
 		if n == 1 {
 			p.print(blank)
diff --git a/src/go/printer/printer_test.go b/src/go/printer/printer_test.go
index e03c2df063..20c97b8c08 100644
--- a/src/go/printer/printer_test.go
+++ b/src/go/printer/printer_test.go
@@ -10,6 +10,7 @@ import (
 	"flag"
 	"fmt"
 	"go/ast"
+	"go/internal/typeparams"
 	"go/parser"
 	"go/token"
 	"io"
@@ -19,10 +20,6 @@ import (
 	"time"
 )
 
-// parseTypeParams tells go/parser to parse type parameters. Must be kept in
-// sync with go/parser/interface.go.
-const parseTypeParams parser.Mode = 1 << 30
-
 const (
 	dataDir  = "testdata"
 	tabwidth = 8
@@ -47,11 +44,7 @@ const (
 // if any.
 func format(src []byte, mode checkMode) ([]byte, error) {
 	// parse src
-	parseMode := parser.ParseComments
-	if mode&allowTypeParams != 0 {
-		parseMode |= parseTypeParams
-	}
-	f, err := parser.ParseFile(fset, "", src, parseMode)
+	f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
 	if err != nil {
 		return nil, fmt.Errorf("parse: %s\n%s", err, src)
 	}
@@ -79,7 +72,7 @@ func format(src []byte, mode checkMode) ([]byte, error) {
 
 	// make sure formatted output is syntactically correct
 	res := buf.Bytes()
-	if _, err := parser.ParseFile(fset, "", res, parseTypeParams); err != nil {
+	if _, err := parser.ParseFile(fset, "", res, parser.ParseComments); err != nil {
 		return nil, fmt.Errorf("re-parse: %s\n%s", err, buf.Bytes())
 	}
 
@@ -210,7 +203,7 @@ var data = []entry{
 	{"linebreaks.input", "linebreaks.golden", idempotent},
 	{"expressions.input", "expressions.golden", idempotent},
 	{"expressions.input", "expressions.raw", rawFormat | idempotent},
-	{"declarations.input", "declarations.golden", allowTypeParams},
+	{"declarations.input", "declarations.golden", 0},
 	{"statements.input", "statements.golden", 0},
 	{"slow.input", "slow.golden", idempotent},
 	{"complit.input", "complit.x", export},
@@ -229,6 +222,9 @@ var data = []entry{
 func TestFiles(t *testing.T) {
 	t.Parallel()
 	for _, e := range data {
+		if !typeparams.Enabled && e.mode&allowTypeParams != 0 {
+			continue
+		}
 		source := filepath.Join(dataDir, e.source)
 		golden := filepath.Join(dataDir, e.golden)
 		mode := e.mode
diff --git a/src/go/printer/testdata/declarations.golden b/src/go/printer/testdata/declarations.golden
index 74ffce7d73..fe0f7838de 100644
--- a/src/go/printer/testdata/declarations.golden
+++ b/src/go/printer/testdata/declarations.golden
@@ -942,13 +942,6 @@ type _ interface {
 		x ...int)
 }
 
-// properly format one-line type lists
-type _ interface{ type a }
-
-type _ interface {
-	type a, b, c
-}
-
 // omit superfluous parentheses in parameter lists
 func _(int)
 func _(int)
@@ -999,10 +992,6 @@ func _(struct {
 	y	int
 })	// no extra comma between } and )
 
-// type parameters
-func _[A, B any](a A, b B) int	{}
-func _[T any](x, y T) T
-
 // alias declarations
 
 type c0 struct{}
diff --git a/src/go/printer/testdata/declarations.input b/src/go/printer/testdata/declarations.input
index ab2022142a..f34395b505 100644
--- a/src/go/printer/testdata/declarations.input
+++ b/src/go/printer/testdata/declarations.input
@@ -955,11 +955,6 @@ r string,
 		x ...int)
 }
 
-// properly format one-line type lists
-type _ interface { type a }
-
-type _ interface { type a,b,c }
-
 // omit superfluous parentheses in parameter lists
 func _((int))
 func _((((((int))))))
@@ -1010,10 +1005,6 @@ func _(struct {
 	y int
 }) // no extra comma between } and )
 
-// type parameters
-func _[A, B any](a A, b B) int {}
-func _[T any](x, y T) T
-
 // alias declarations
 
 type c0 struct{}
diff --git a/src/go/printer/testdata/generics.golden b/src/go/printer/testdata/generics.golden
index 88c461622e..cc7fbbe1d8 100644
--- a/src/go/printer/testdata/generics.golden
+++ b/src/go/printer/testdata/generics.golden
@@ -4,6 +4,9 @@
 
 package generics
 
+func _[A, B any](a A, b B) int	{}
+func _[T any](x, y T) T
+
 type T[P any] struct{}
 type T[P1, P2, P3 any] struct{}
 
@@ -31,3 +34,10 @@ func _() {
 	var _ []T[P]
 	_ = []T[P]{}
 }
+
+// properly format one-line type lists
+type _ interface{ type a }
+
+type _ interface {
+	type a, b, c
+}
diff --git a/src/go/printer/testdata/generics.input b/src/go/printer/testdata/generics.input
index 5fdf8cdb87..f4571ad336 100644
--- a/src/go/printer/testdata/generics.input
+++ b/src/go/printer/testdata/generics.input
@@ -4,6 +4,9 @@
 
 package generics
 
+func _[A, B any](a A, b B) int {}
+func _[T any](x, y T) T
+
 type T[P any] struct{}
 type T[P1, P2, P3 any] struct{}
 
@@ -28,3 +31,8 @@ func _() {
 	var _ []T[P]
 	_ = []T[P]{}
 }
+
+// properly format one-line type lists
+type _ interface { type a }
+
+type _ interface { type a,b,c }
diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go
index 427aa04e47..a8e29d3fda 100644
--- a/src/go/types/api_test.go
+++ b/src/go/types/api_test.go
@@ -9,6 +9,7 @@ import (
 	"fmt"
 	"go/ast"
 	"go/importer"
+	"go/internal/typeparams"
 	"go/parser"
 	"go/token"
 	"internal/testenv"
@@ -48,8 +49,8 @@ func mustTypecheck(t *testing.T, path, source string, info *Info) string {
 const genericPkg = "package generic_"
 
 func modeForSource(src string) parser.Mode {
-	if strings.HasPrefix(src, genericPkg) {
-		return parseTypeParams
+	if !strings.HasPrefix(src, genericPkg) {
+		return typeparams.DisallowParsing
 	}
 	return 0
 }
@@ -347,6 +348,9 @@ func TestTypesInfo(t *testing.T) {
 	}
 
 	for _, test := range tests {
+		if strings.HasPrefix(test.src, genericPkg) && !typeparams.Enabled {
+			continue
+		}
 		info := Info{Types: make(map[ast.Expr]TypeAndValue)}
 		var name string
 		if strings.HasPrefix(test.src, broken) {
@@ -401,6 +405,9 @@ func TestDefsInfo(t *testing.T) {
 	}
 
 	for _, test := range tests {
+		if strings.HasPrefix(test.src, genericPkg) && !typeparams.Enabled {
+			continue
+		}
 		info := Info{
 			Defs: make(map[*ast.Ident]Object),
 		}
@@ -446,6 +453,9 @@ func TestUsesInfo(t *testing.T) {
 	}
 
 	for _, test := range tests {
+		if strings.HasPrefix(test.src, genericPkg) && !typeparams.Enabled {
+			continue
+		}
 		info := Info{
 			Uses: make(map[*ast.Ident]Object),
 		}
diff --git a/src/go/types/api_go1.18.go b/src/go/types/api_typeparams.go
similarity index 90%
rename from src/go/types/api_go1.18.go
rename to src/go/types/api_typeparams.go
index d98f4ef0dc..108e526fbf 100644
--- a/src/go/types/api_go1.18.go
+++ b/src/go/types/api_typeparams.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build go1.18
-// +build go1.18
+//go:build typeparams
+// +build typeparams
 
 package types
 
diff --git a/src/go/types/api_go1.18_test.go b/src/go/types/api_typeparams_test.go
similarity index 98%
rename from src/go/types/api_go1.18_test.go
rename to src/go/types/api_typeparams_test.go
index e60fe23201..e6cccf8691 100644
--- a/src/go/types/api_go1.18_test.go
+++ b/src/go/types/api_typeparams_test.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build go1.18
-// +build go1.18
+//go:build typeparams
+// +build typeparams
 
 package types_test
 
diff --git a/src/go/types/assignments.go b/src/go/types/assignments.go
index f223cb7574..3aa06e8939 100644
--- a/src/go/types/assignments.go
+++ b/src/go/types/assignments.go
@@ -303,20 +303,6 @@ func (check *Checker) assignVars(lhs, origRHS []ast.Expr) {
 	}
 }
 
-// unpack unpacks an *ast.ListExpr into a list of ast.Expr.
-// TODO(gri) Should find a more efficient solution that doesn't
-//           require introduction of a new slice for simple
-//           expressions.
-func unpackExpr(x ast.Expr) []ast.Expr {
-	if x, _ := x.(*ast.ListExpr); x != nil {
-		return x.ElemList
-	}
-	if x != nil {
-		return []ast.Expr{x}
-	}
-	return nil
-}
-
 func (check *Checker) shortVarDecl(pos positioner, lhs, rhs []ast.Expr) {
 	top := len(check.delayed)
 	scope := check.scope
diff --git a/src/go/types/call.go b/src/go/types/call.go
index ae0a245b2b..642eb5e391 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -8,6 +8,7 @@ package types
 
 import (
 	"go/ast"
+	"go/internal/typeparams"
 	"go/token"
 	"strings"
 	"unicode"
@@ -16,7 +17,8 @@ import (
 // funcInst type-checks a function instantiaton inst and returns the result in x.
 // The operand x must be the evaluation of inst.X and its type must be a signature.
 func (check *Checker) funcInst(x *operand, inst *ast.IndexExpr) {
-	args, ok := check.exprOrTypeList(unpackExpr(inst.Index))
+	exprs := typeparams.UnpackExpr(inst.Index)
+	args, ok := check.exprOrTypeList(exprs)
 	if !ok {
 		x.mode = invalid
 		x.expr = inst
diff --git a/src/go/types/check_test.go b/src/go/types/check_test.go
index 327fb4c5f1..8a15841e37 100644
--- a/src/go/types/check_test.go
+++ b/src/go/types/check_test.go
@@ -30,6 +30,7 @@ import (
 	"fmt"
 	"go/ast"
 	"go/importer"
+	"go/internal/typeparams"
 	"go/parser"
 	"go/scanner"
 	"go/token"
@@ -43,10 +44,6 @@ import (
 	. "go/types"
 )
 
-// parseTypeParams tells go/parser to parse type parameters. Must be kept in
-// sync with go/parser/interface.go.
-const parseTypeParams parser.Mode = 1 << 30
-
 var (
 	haltOnError = flag.Bool("halt", false, "halt on error")
 	listErrors  = flag.Bool("errlist", false, "list errors")
@@ -213,7 +210,11 @@ func checkFiles(t *testing.T, goVersion string, filenames []string, srcs [][]byt
 
 	mode := parser.AllErrors
 	if strings.HasSuffix(filenames[0], ".go2") {
-		mode |= parseTypeParams
+		if !typeparams.Enabled {
+			t.Skip("type params are not enabled")
+		}
+	} else {
+		mode |= typeparams.DisallowParsing
 	}
 
 	// parse files and collect parser errors
diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index 2eb2c39745..b5b9d35b24 100644
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"go/ast"
 	"go/constant"
+	"go/internal/typeparams"
 	"go/token"
 )
 
@@ -645,7 +646,7 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *ast.TypeSpec, def *Named) {
 	})
 
 	alias := tdecl.Assign.IsValid()
-	if alias && tdecl.TParams != nil {
+	if alias && typeparams.Get(tdecl) != nil {
 		// The parser will ensure this but we may still get an invalid AST.
 		// Complain and continue as regular type definition.
 		check.error(atPos(tdecl.Assign), 0, "generic type cannot be alias")
@@ -668,10 +669,10 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *ast.TypeSpec, def *Named) {
 		def.setUnderlying(named)
 		obj.typ = named // make sure recursive type declarations terminate
 
-		if tdecl.TParams != nil {
+		if tparams := typeparams.Get(tdecl); tparams != nil {
 			check.openScope(tdecl, "type parameters")
 			defer check.closeScope()
-			named.tparams = check.collectTypeParams(tdecl.TParams)
+			named.tparams = check.collectTypeParams(tparams)
 		}
 
 		// determine underlying type of named
diff --git a/src/go/types/exprstring.go b/src/go/types/exprstring.go
index 9e073b1de0..f05e6424d4 100644
--- a/src/go/types/exprstring.go
+++ b/src/go/types/exprstring.go
@@ -10,6 +10,7 @@ import (
 	"bytes"
 	"fmt"
 	"go/ast"
+	"go/internal/typeparams"
 )
 
 // ExprString returns the (possibly shortened) string representation for x.
@@ -69,16 +70,14 @@ func WriteExpr(buf *bytes.Buffer, x ast.Expr) {
 	case *ast.IndexExpr:
 		WriteExpr(buf, x.X)
 		buf.WriteByte('[')
-		WriteExpr(buf, x.Index)
-		buf.WriteByte(']')
-
-	case *ast.ListExpr:
-		for i, e := range x.ElemList {
+		exprs := typeparams.UnpackExpr(x.Index)
+		for i, e := range exprs {
 			if i > 0 {
 				buf.WriteString(", ")
 			}
 			WriteExpr(buf, e)
 		}
+		buf.WriteByte(']')
 
 	case *ast.SliceExpr:
 		WriteExpr(buf, x.X)
diff --git a/src/go/types/resolver.go b/src/go/types/resolver.go
index 8e67237446..43d2c739a5 100644
--- a/src/go/types/resolver.go
+++ b/src/go/types/resolver.go
@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"go/ast"
 	"go/constant"
+	"go/internal/typeparams"
 	"go/token"
 	"sort"
 	"strconv"
@@ -389,8 +390,8 @@ func (check *Checker) collectObjects() {
 						if name == "main" {
 							code = _InvalidMainDecl
 						}
-						if d.decl.Type.TParams != nil {
-							check.softErrorf(d.decl.Type.TParams, code, "func %s must have no type parameters", name)
+						if tparams := typeparams.Get(d.decl.Type); tparams != nil {
+							check.softErrorf(tparams, code, "func %s must have no type parameters", name)
 						}
 						if t := d.decl.Type; t.Params.NumFields() != 0 || t.Results != nil {
 							// TODO(rFindley) Should this be a hard error?
@@ -497,7 +498,7 @@ L: // unpack receiver type
 	if ptyp, _ := rtyp.(*ast.IndexExpr); ptyp != nil {
 		rtyp = ptyp.X
 		if unpackParams {
-			for _, arg := range unpackExpr(ptyp.Index) {
+			for _, arg := range typeparams.UnpackExpr(ptyp.Index) {
 				var par *ast.Ident
 				switch arg := arg.(type) {
 				case *ast.Ident:
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index 60a42b0426..e6846545c6 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -10,6 +10,7 @@ import (
 	"fmt"
 	"go/ast"
 	"go/constant"
+	"go/internal/typeparams"
 	"go/token"
 	"sort"
 	"strconv"
@@ -209,27 +210,22 @@ func isubst(x ast.Expr, smap map[*ast.Ident]*ast.Ident) ast.Expr {
 			return &new
 		}
 	case *ast.IndexExpr:
-		index := isubst(n.Index, smap)
-		if index != n.Index {
-			new := *n
-			new.Index = index
-			return &new
-		}
-	case *ast.ListExpr:
-		var elems []ast.Expr
-		for i, elem := range n.ElemList {
+		elems := typeparams.UnpackExpr(n.Index)
+		var newElems []ast.Expr
+		for i, elem := range elems {
 			new := isubst(elem, smap)
 			if new != elem {
-				if elems == nil {
-					elems = make([]ast.Expr, len(n.ElemList))
-					copy(elems, n.ElemList)
+				if newElems == nil {
+					newElems = make([]ast.Expr, len(elems))
+					copy(newElems, elems)
 				}
-				elems[i] = new
+				newElems[i] = new
 			}
 		}
-		if elems != nil {
+		if newElems != nil {
+			index := typeparams.PackExpr(newElems)
 			new := *n
-			new.ElemList = elems
+			new.Index = index
 			return &new
 		}
 	case *ast.ParenExpr:
@@ -316,13 +312,13 @@ func (check *Checker) funcType(sig *Signature, recvPar *ast.FieldList, ftyp *ast
 		}
 	}
 
-	if ftyp.TParams != nil {
-		sig.tparams = check.collectTypeParams(ftyp.TParams)
+	if tparams := typeparams.Get(ftyp); tparams != nil {
+		sig.tparams = check.collectTypeParams(tparams)
 		// Always type-check method type parameters but complain that they are not allowed.
 		// (A separate check is needed when type-checking interface method signatures because
 		// they don't have a receiver specification.)
 		if recvPar != nil {
-			check.errorf(ftyp.TParams, _Todo, "methods cannot have type parameters")
+			check.errorf(tparams, _Todo, "methods cannot have type parameters")
 		}
 	}
 
@@ -467,7 +463,8 @@ func (check *Checker) typInternal(e0 ast.Expr, def *Named) (T Type) {
 		}
 
 	case *ast.IndexExpr:
-		return check.instantiatedType(e.X, unpackExpr(e.Index), def)
+		exprs := typeparams.UnpackExpr(e.Index)
+		return check.instantiatedType(e.X, exprs, def)
 
 	case *ast.ParenExpr:
 		// Generic types must be instantiated before they can be used in any form.
@@ -801,7 +798,11 @@ func (check *Checker) interfaceType(ityp *Interface, iface *ast.InterfaceType, d
 			// (This extra check is needed here because interface method signatures don't have
 			// a receiver specification.)
 			if sig.tparams != nil {
-				check.errorf(f.Type.(*ast.FuncType).TParams, _Todo, "methods cannot have type parameters")
+				var at positioner = f.Type
+				if tparams := typeparams.Get(f.Type); tparams != nil {
+					at = tparams
+				}
+				check.errorf(at, _Todo, "methods cannot have type parameters")
 			}
 
 			// use named receiver type if available (for better error messages)
-- 
GitLab


From b4881d930a653ffc72cfcdff2902a627ba3a205c Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Fri, 9 Apr 2021 18:05:57 -0400
Subject: [PATCH 1536/2400] cmd/compile: don't modify underlying type when
 creating bitmap for bodyless function

This fixes the build crash for
    GOEXPERIMENT=regabi,regabiargs GOOS=windows go build syscall

Updates #40724.

Change-Id: I4400f6ff2e83e7e7e93ad5e58c6063b327532504
Reviewed-on: https://go-review.googlesource.com/c/go/+/309110
Trust: David Chase <drchase@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/abi/abiutils.go   | 17 +++++++++++------
 src/cmd/compile/internal/gc/compile.go     |  4 ++--
 src/cmd/compile/internal/liveness/plive.go |  1 -
 3 files changed, 13 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index 50a818c025..e192adb5e1 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -5,6 +5,7 @@
 package abi
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
@@ -104,7 +105,7 @@ type ABIParamAssignment struct {
 // This will panic if "a" describes a register-allocated parameter.
 func (a *ABIParamAssignment) Offset() int32 {
 	if len(a.Registers) > 0 {
-		panic("Register allocated parameters have no offset")
+		base.Fatalf("register allocated parameters have no offset")
 	}
 	return a.offset
 }
@@ -238,7 +239,7 @@ func appendParamOffsets(offsets []int64, at int64, t *types.Type) ([]int64, int6
 // spill area to help reduce stack sizes.)
 func (a *ABIParamAssignment) FrameOffset(i *ABIParamResultInfo) int64 {
 	if a.offset == -1 {
-		panic("Function parameter has no ABI-defined frame-pointer offset")
+		base.Fatalf("function parameter has no ABI-defined frame-pointer offset")
 	}
 	if len(a.Registers) == 0 { // passed on stack
 		return int64(a.offset) - i.config.LocalsOffset()
@@ -429,6 +430,7 @@ func (config *ABIConfig) ABIAnalyzeFuncType(ft *types.Func) *ABIParamResultInfo
 func (config *ABIConfig) ABIAnalyze(t *types.Type, setNname bool) *ABIParamResultInfo {
 	ft := t.FuncType()
 	result := config.ABIAnalyzeFuncType(ft)
+
 	// Fill in the frame offsets for receiver, inputs, results
 	k := 0
 	if t.NumRecvs() != 0 {
@@ -472,7 +474,7 @@ func (config *ABIConfig) updateOffset(result *ABIParamResultInfo, f *types.Field
 				f.Nname.(*ir.Name).SetIsOutputParamInRegisters(false)
 			}
 		} else if fOffset != off {
-			panic(fmt.Errorf("Offset changed from %d to %d", fOffset, off))
+			base.Fatalf("offset for %s at %s changed from %d to %d", f.Sym.Name, base.FmtPos(f.Pos), fOffset, off)
 		}
 	} else {
 		if setNname && f.Nname != nil {
@@ -610,7 +612,8 @@ func (state *assignState) allocateRegs(regs []RegIndex, t *types.Type) []RegInde
 			return state.allocateRegs(regs, synthIface)
 		}
 	}
-	panic(fmt.Errorf("Was not expecting type %s", t))
+	base.Fatalf("was not expecting type %s", t)
+	panic("unreachable")
 }
 
 // regAllocate creates a register ABIParamAssignment object for a param
@@ -765,7 +768,8 @@ func (state *assignState) regassign(pt *types.Type) bool {
 	case types.TINTER:
 		return state.regassignStruct(synthIface)
 	default:
-		panic("not expected")
+		base.Fatalf("not expected")
+		panic("unreachable")
 	}
 }
 
@@ -776,7 +780,8 @@ func (state *assignState) regassign(pt *types.Type) bool {
 func (state *assignState) assignParamOrReturn(pt *types.Type, n types.Object, isReturn bool) ABIParamAssignment {
 	state.pUsed = RegAmounts{}
 	if pt.Width == types.BADWIDTH {
-		panic("should never happen")
+		base.Fatalf("should never happen")
+		panic("unreachable")
 	} else if pt.Width == 0 {
 		return state.stackAllocate(pt, n)
 	} else if state.regassign(pt) {
diff --git a/src/cmd/compile/internal/gc/compile.go b/src/cmd/compile/internal/gc/compile.go
index 6db37919fa..a71684a859 100644
--- a/src/cmd/compile/internal/gc/compile.go
+++ b/src/cmd/compile/internal/gc/compile.go
@@ -43,9 +43,9 @@ func enqueueFunc(fn *ir.Func) {
 	if len(fn.Body) == 0 {
 		// Initialize ABI wrappers if necessary.
 		ssagen.InitLSym(fn, false)
-		types.CalcSize(fn.Type()) // TODO register args; remove this once all is done by abiutils
+		types.CalcSize(fn.Type())
 		a := ssagen.AbiForBodylessFuncStackMap(fn)
-		abiInfo := a.ABIAnalyze(fn.Type(), true) // will set parameter spill/home locations correctly
+		abiInfo := a.ABIAnalyzeFuncType(fn.Type().FuncType()) // abiInfo has spill/home locations for wrapper
 		liveness.WriteFuncMap(fn, abiInfo)
 		return
 	}
diff --git a/src/cmd/compile/internal/liveness/plive.go b/src/cmd/compile/internal/liveness/plive.go
index 5d8e8b115d..4395aaeeb6 100644
--- a/src/cmd/compile/internal/liveness/plive.go
+++ b/src/cmd/compile/internal/liveness/plive.go
@@ -1457,7 +1457,6 @@ func WriteFuncMap(fn *ir.Func, abiInfo *abi.ABIParamResultInfo) {
 	if ir.FuncName(fn) == "_" || fn.Sym().Linkname != "" {
 		return
 	}
-	types.CalcSize(fn.Type())
 	nptr := int(abiInfo.ArgWidth() / int64(types.PtrSize))
 	bv := bitvec.New(int32(nptr) * 2)
 
-- 
GitLab


From 8c2a8b1771cd7ed2182f4d03b3c4bd09828315ce Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 13 Apr 2021 18:01:59 -0400
Subject: [PATCH 1537/2400] cmd/compile: always zero the temporary in
 mapKeyTemp

As we are taking its address, always zero it. In many cases the
temporary will be optimized out. But in case it does not (e.g. -N,
-race), this ensures it has the right liveness information.

May fix the noopt builder.

Change-Id: I3d5d617c276d2a1a1aaebff813b4cd60bc691592
Reviewed-on: https://go-review.googlesource.com/c/go/+/309771
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/walk/order.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index 8b30632665..42d9d58971 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -306,8 +306,7 @@ func (o *orderState) mapKeyTemp(t *types.Type, n ir.Node) ir.Node {
 		if kt.Align < nt.Align {
 			base.Fatalf("mapKeyTemp: key type is not sufficiently aligned, kt=%v nt=%v", kt, nt)
 		}
-		clear := base.Flag.Cfg.Instrumenting // clear tmp if instrumenting, as it may be live at an inserted race call
-		tmp := o.newTemp(kt, clear)
+		tmp := o.newTemp(kt, true)
 		// *(*nt)(&tmp) = n
 		var e ir.Node = typecheck.NodAddr(tmp)
 		e = ir.NewConvExpr(n.Pos(), ir.OCONVNOP, nt.PtrTo(), e)
-- 
GitLab


From f2d5bd1ad306e87804d600d92105dc37279af83f Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Wed, 31 Mar 2021 22:55:06 +0000
Subject: [PATCH 1538/2400] runtime: move internal GC statistics from memstats
 to gcController

This change moves certain important but internal-only GC statistics from
memstats into gcController. These statistics are mainly used in pacing
the GC, so it makes sense to keep them in the pacer's state.

This CL was mostly generated via

rf '
    ex . {
	memstats.gc_trigger -> gcController.trigger
	memstats.triggerRatio -> gcController.triggerRatio
	memstats.heap_marked -> gcController.heapMarked
	memstats.heap_live -> gcController.heapLive
	memstats.heap_scan -> gcController.heapScan
    }
'

except for a few special cases, like updating names in comments and when
these fields are used within gcControllerState methods (at which point
they're accessed through the reciever).

For #44167.

Change-Id: I6bd1602585aeeb80818ded24c07d8e6fec992b93
Reviewed-on: https://go-review.googlesource.com/c/go/+/306598
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
---
 src/runtime/mcache.go   |  26 +++----
 src/runtime/mgc.go      |  34 +++++-----
 src/runtime/mgcpacer.go | 145 ++++++++++++++++++++++++++++++----------
 src/runtime/mgcsweep.go |   4 +-
 src/runtime/mheap.go    |   8 +--
 src/runtime/mstats.go   |  65 +-----------------
 src/runtime/trace.go    |   2 +-
 7 files changed, 146 insertions(+), 138 deletions(-)

diff --git a/src/runtime/mcache.go b/src/runtime/mcache.go
index bb7475b6f3..2390be406f 100644
--- a/src/runtime/mcache.go
+++ b/src/runtime/mcache.go
@@ -178,9 +178,9 @@ func (c *mcache) refill(spc spanClass) {
 	atomic.Xadduintptr(&stats.smallAllocCount[spc.sizeclass()], uintptr(s.nelems)-uintptr(s.allocCount))
 	memstats.heapStats.release()
 
-	// Update heap_live with the same assumption.
+	// Update gcController.heapLive with the same assumption.
 	usedBytes := uintptr(s.allocCount) * s.elemsize
-	atomic.Xadd64(&memstats.heap_live, int64(s.npages*pageSize)-int64(usedBytes))
+	atomic.Xadd64(&gcController.heapLive, int64(s.npages*pageSize)-int64(usedBytes))
 
 	// Flush tinyAllocs.
 	if spc == tinySpanClass {
@@ -190,15 +190,15 @@ func (c *mcache) refill(spc spanClass) {
 
 	// While we're here, flush scanAlloc, since we have to call
 	// revise anyway.
-	atomic.Xadd64(&memstats.heap_scan, int64(c.scanAlloc))
+	atomic.Xadd64(&gcController.heapScan, int64(c.scanAlloc))
 	c.scanAlloc = 0
 
 	if trace.enabled {
-		// heap_live changed.
+		// gcController.heapLive changed.
 		traceHeapAlloc()
 	}
 	if gcBlackenEnabled != 0 {
-		// heap_live and heap_scan changed.
+		// gcController.heapLive and heapScan changed.
 		gcController.revise()
 	}
 
@@ -230,10 +230,10 @@ func (c *mcache) allocLarge(size uintptr, needzero bool, noscan bool) *mspan {
 	atomic.Xadduintptr(&stats.largeAllocCount, 1)
 	memstats.heapStats.release()
 
-	// Update heap_live and revise pacing if needed.
-	atomic.Xadd64(&memstats.heap_live, int64(npages*pageSize))
+	// Update gcController.heapLive and revise pacing if needed.
+	atomic.Xadd64(&gcController.heapLive, int64(npages*pageSize))
 	if trace.enabled {
-		// Trace that a heap alloc occurred because heap_live changed.
+		// Trace that a heap alloc occurred because gcController.heapLive changed.
 		traceHeapAlloc()
 	}
 	if gcBlackenEnabled != 0 {
@@ -250,7 +250,7 @@ func (c *mcache) allocLarge(size uintptr, needzero bool, noscan bool) *mspan {
 
 func (c *mcache) releaseAll() {
 	// Take this opportunity to flush scanAlloc.
-	atomic.Xadd64(&memstats.heap_scan, int64(c.scanAlloc))
+	atomic.Xadd64(&gcController.heapScan, int64(c.scanAlloc))
 	c.scanAlloc = 0
 
 	sg := mheap_.sweepgen
@@ -263,14 +263,14 @@ func (c *mcache) releaseAll() {
 			atomic.Xadduintptr(&stats.smallAllocCount[spanClass(i).sizeclass()], -n)
 			memstats.heapStats.release()
 			if s.sweepgen != sg+1 {
-				// refill conservatively counted unallocated slots in heap_live.
+				// refill conservatively counted unallocated slots in gcController.heapLive.
 				// Undo this.
 				//
 				// If this span was cached before sweep, then
-				// heap_live was totally recomputed since
+				// gcController.heapLive was totally recomputed since
 				// caching this span, so we don't do this for
 				// stale spans.
-				atomic.Xadd64(&memstats.heap_live, -int64(n)*int64(s.elemsize))
+				atomic.Xadd64(&gcController.heapLive, -int64(n)*int64(s.elemsize))
 			}
 			// Release the span to the mcentral.
 			mheap_.central[i].mcentral.uncacheSpan(s)
@@ -283,7 +283,7 @@ func (c *mcache) releaseAll() {
 	atomic.Xadd64(&memstats.tinyallocs, int64(c.tinyAllocs))
 	c.tinyAllocs = 0
 
-	// Updated heap_scan and possible heap_live.
+	// Updated heapScan and possible gcController.heapLive.
 	if gcBlackenEnabled != 0 {
 		gcController.revise()
 	}
diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index 8831e27554..ff0618a053 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -158,12 +158,12 @@ func gcinit() {
 	mheap_.sweepDrained = 1
 
 	// Set a reasonable initial GC trigger.
-	memstats.triggerRatio = 7 / 8.0
+	gcController.triggerRatio = 7 / 8.0
 
-	// Fake a heap_marked value so it looks like a trigger at
-	// heapMinimum is the appropriate growth from heap_marked.
+	// Fake a heapMarked value so it looks like a trigger at
+	// heapMinimum is the appropriate growth from heapMarked.
 	// This will go into computing the initial GC goal.
-	memstats.heap_marked = uint64(float64(heapMinimum) / (1 + memstats.triggerRatio))
+	gcController.heapMarked = uint64(float64(heapMinimum) / (1 + gcController.triggerRatio))
 
 	// Set gcPercent from the environment. This will also compute
 	// and set the GC trigger and goal.
@@ -370,7 +370,7 @@ var work struct {
 	// program started if debug.gctrace > 0.
 	totaltime int64
 
-	// initialHeapLive is the value of memstats.heap_live at the
+	// initialHeapLive is the value of gcController.heapLive at the
 	// beginning of this GC cycle.
 	initialHeapLive uint64
 
@@ -551,11 +551,11 @@ func (t gcTrigger) test() bool {
 	}
 	switch t.kind {
 	case gcTriggerHeap:
-		// Non-atomic access to heap_live for performance. If
+		// Non-atomic access to gcController.heapLive for performance. If
 		// we are going to trigger on this, this thread just
-		// atomically wrote heap_live anyway and we'll see our
+		// atomically wrote gcController.heapLive anyway and we'll see our
 		// own write.
-		return memstats.heap_live >= memstats.gc_trigger
+		return gcController.heapLive >= gcController.trigger
 	case gcTriggerTime:
 		if gcPercent < 0 {
 			return false
@@ -651,7 +651,7 @@ func gcStart(trigger gcTrigger) {
 		// so it can't be more than ncpu, even if GOMAXPROCS is.
 		work.stwprocs = ncpu
 	}
-	work.heap0 = atomic.Load64(&memstats.heap_live)
+	work.heap0 = atomic.Load64(&gcController.heapLive)
 	work.pauseNS = 0
 	work.mode = mode
 
@@ -915,7 +915,7 @@ func gcMarkTermination(nextTriggerRatio float64) {
 	// Start marktermination (write barrier remains enabled for now).
 	setGCPhase(_GCmarktermination)
 
-	work.heap1 = memstats.heap_live
+	work.heap1 = gcController.heapLive
 	startTime := nanotime()
 
 	mp := acquirem()
@@ -1432,25 +1432,25 @@ func gcMark(start_time int64) {
 	}
 
 	// Update the marked heap stat.
-	memstats.heap_marked = work.bytesMarked
+	gcController.heapMarked = work.bytesMarked
 
 	// Flush scanAlloc from each mcache since we're about to modify
-	// heap_scan directly. If we were to flush this later, then scanAlloc
+	// heapScan directly. If we were to flush this later, then scanAlloc
 	// might have incorrect information.
 	for _, p := range allp {
 		c := p.mcache
 		if c == nil {
 			continue
 		}
-		memstats.heap_scan += uint64(c.scanAlloc)
+		gcController.heapScan += uint64(c.scanAlloc)
 		c.scanAlloc = 0
 	}
 
 	// Update other GC heap size stats. This must happen after
 	// cachestats (which flushes local statistics to these) and
-	// flushallmcaches (which modifies heap_live).
-	memstats.heap_live = work.bytesMarked
-	memstats.heap_scan = uint64(gcController.scanWork)
+	// flushallmcaches (which modifies gcController.heapLive).
+	gcController.heapLive = work.bytesMarked
+	gcController.heapScan = uint64(gcController.scanWork)
 
 	if trace.enabled {
 		traceHeapAlloc()
@@ -1543,7 +1543,7 @@ func gcResetMarkState() {
 	}
 
 	work.bytesMarked = 0
-	work.initialHeapLive = atomic.Load64(&memstats.heap_live)
+	work.initialHeapLive = atomic.Load64(&gcController.heapLive)
 }
 
 // Hooks for other packages
diff --git a/src/runtime/mgcpacer.go b/src/runtime/mgcpacer.go
index 441c397a45..1239ba4bb8 100644
--- a/src/runtime/mgcpacer.go
+++ b/src/runtime/mgcpacer.go
@@ -7,7 +7,7 @@ package runtime
 import (
 	"internal/cpu"
 	"runtime/internal/atomic"
-	_ "unsafe" // for linkname
+	"unsafe"
 )
 
 const (
@@ -68,11 +68,18 @@ var (
 	gcPercent int32
 )
 
+func init() {
+	if offset := unsafe.Offsetof(gcController.heapLive); offset%8 != 0 {
+		println(offset)
+		throw("gcController.heapLive not aligned to 8 bytes")
+	}
+}
+
 // gcController implements the GC pacing controller that determines
 // when to trigger concurrent garbage collection and how much marking
 // work to do in mutator assists and background marking.
 //
-// It uses a feedback control algorithm to adjust the memstats.gc_trigger
+// It uses a feedback control algorithm to adjust the gcController.trigger
 // trigger based on the heap growth and GC CPU utilization each cycle.
 // This algorithm optimizes for heap growth to match GOGC and for CPU
 // utilization between assist and background marking to be 25% of
@@ -84,6 +91,70 @@ var (
 var gcController gcControllerState
 
 type gcControllerState struct {
+	// triggerRatio is the heap growth ratio that triggers marking.
+	//
+	// E.g., if this is 0.6, then GC should start when the live
+	// heap has reached 1.6 times the heap size marked by the
+	// previous cycle. This should be ≤ GOGC/100 so the trigger
+	// heap size is less than the goal heap size. This is set
+	// during mark termination for the next cycle's trigger.
+	//
+	// Protected by mheap_.lock or a STW.
+	triggerRatio float64
+
+	// trigger is the heap size that triggers marking.
+	//
+	// When heapLive ≥ trigger, the mark phase will start.
+	// This is also the heap size by which proportional sweeping
+	// must be complete.
+	//
+	// This is computed from triggerRatio during mark termination
+	// for the next cycle's trigger.
+	//
+	// Protected by mheap_.lock or a STW.
+	trigger uint64
+
+	// heapLive is the number of bytes considered live by the GC.
+	// That is: retained by the most recent GC plus allocated
+	// since then. heapLive ≤ memstats.heapAlloc, since heapAlloc includes
+	// unmarked objects that have not yet been swept (and hence goes up as we
+	// allocate and down as we sweep) while heapLive excludes these
+	// objects (and hence only goes up between GCs).
+	//
+	// This is updated atomically without locking. To reduce
+	// contention, this is updated only when obtaining a span from
+	// an mcentral and at this point it counts all of the
+	// unallocated slots in that span (which will be allocated
+	// before that mcache obtains another span from that
+	// mcentral). Hence, it slightly overestimates the "true" live
+	// heap size. It's better to overestimate than to
+	// underestimate because 1) this triggers the GC earlier than
+	// necessary rather than potentially too late and 2) this
+	// leads to a conservative GC rate rather than a GC rate that
+	// is potentially too low.
+	//
+	// Reads should likewise be atomic (or during STW).
+	//
+	// Whenever this is updated, call traceHeapAlloc() and
+	// this gcControllerState's revise() method.
+	heapLive uint64
+
+	// heapScan is the number of bytes of "scannable" heap. This
+	// is the live heap (as counted by heapLive), but omitting
+	// no-scan objects and no-scan tails of objects.
+	//
+	// Whenever this is updated, call this gcControllerState's
+	// revise() method.
+	//
+	// Read and written atomically or with the world stopped.
+	heapScan uint64
+
+	// heapMarked is the number of bytes marked by the previous
+	// GC. After mark termination, heapLive == heapMarked, but
+	// unlike heapLive, heapMarked does not change until the
+	// next mark termination.
+	heapMarked uint64
+
 	// scanWork is the total scan work performed this cycle. This
 	// is updated atomically during the cycle. Updates occur in
 	// bounded batches, since it is both written and read
@@ -137,7 +208,7 @@ type gcControllerState struct {
 	// assistWorkPerByte is the ratio of scan work to allocated
 	// bytes that should be performed by mutator assists. This is
 	// computed at the beginning of each cycle and updated every
-	// time heap_scan is updated.
+	// time heapScan is updated.
 	//
 	// Stored as a uint64, but it's actually a float64. Use
 	// float64frombits to get the value.
@@ -185,13 +256,13 @@ func (c *gcControllerState) startCycle() {
 
 	// Ensure that the heap goal is at least a little larger than
 	// the current live heap size. This may not be the case if GC
-	// start is delayed or if the allocation that pushed heap_live
-	// over gc_trigger is large or if the trigger is really close to
+	// start is delayed or if the allocation that pushed gcController.heapLive
+	// over trigger is large or if the trigger is really close to
 	// GOGC. Assist is proportional to this distance, so enforce a
 	// minimum distance, even if it means going over the GOGC goal
 	// by a tiny bit.
-	if memstats.next_gc < memstats.heap_live+1024*1024 {
-		memstats.next_gc = memstats.heap_live + 1024*1024
+	if memstats.next_gc < c.heapLive+1024*1024 {
+		memstats.next_gc = c.heapLive + 1024*1024
 	}
 
 	// Compute the background mark utilization goal. In general,
@@ -236,7 +307,7 @@ func (c *gcControllerState) startCycle() {
 	if debug.gcpacertrace > 0 {
 		assistRatio := float64frombits(atomic.Load64(&c.assistWorkPerByte))
 		print("pacer: assist ratio=", assistRatio,
-			" (scan ", memstats.heap_scan>>20, " MB in ",
+			" (scan ", gcController.heapScan>>20, " MB in ",
 			work.initialHeapLive>>20, "->",
 			memstats.next_gc>>20, " MB)",
 			" workers=", c.dedicatedMarkWorkersNeeded,
@@ -245,8 +316,8 @@ func (c *gcControllerState) startCycle() {
 }
 
 // revise updates the assist ratio during the GC cycle to account for
-// improved estimates. This should be called whenever memstats.heap_scan,
-// memstats.heap_live, or memstats.next_gc is updated. It is safe to
+// improved estimates. This should be called whenever gcController.heapScan,
+// gcController.heapLive, or memstats.next_gc is updated. It is safe to
 // call concurrently, but it may race with other calls to revise.
 //
 // The result of this race is that the two assist ratio values may not line
@@ -272,8 +343,8 @@ func (c *gcControllerState) revise() {
 		// act like GOGC is huge for the below calculations.
 		gcPercent = 100000
 	}
-	live := atomic.Load64(&memstats.heap_live)
-	scan := atomic.Load64(&memstats.heap_scan)
+	live := atomic.Load64(&c.heapLive)
+	scan := atomic.Load64(&c.heapScan)
 	work := atomic.Loadint64(&c.scanWork)
 
 	// Assume we're under the soft goal. Pace GC to complete at
@@ -288,7 +359,7 @@ func (c *gcControllerState) revise() {
 	// expected to be live, so that's what we target.
 	//
 	// (This is a float calculation to avoid overflowing on
-	// 100*heap_scan.)
+	// 100*heapScan.)
 	scanWorkExpected := int64(float64(scan) * 100 / float64(100+gcPercent))
 
 	if int64(live) > heapGoal || work > scanWorkExpected {
@@ -305,7 +376,7 @@ func (c *gcControllerState) revise() {
 	// Compute the remaining scan work estimate.
 	//
 	// Note that we currently count allocations during GC as both
-	// scannable heap (heap_scan) and scan work completed
+	// scannable heap (heapScan) and scan work completed
 	// (scanWork), so allocation will change this difference
 	// slowly in the soft regime and not at all in the hard
 	// regime.
@@ -351,7 +422,7 @@ func (c *gcControllerState) endCycle() float64 {
 		// trigger, so where it finished isn't good
 		// information about how to adjust the trigger.
 		// Just leave it where it is.
-		return memstats.triggerRatio
+		return c.triggerRatio
 	}
 
 	// Proportional response gain for the trigger controller. Must
@@ -371,7 +442,7 @@ func (c *gcControllerState) endCycle() float64 {
 	// difference between this estimate and the GOGC-based goal
 	// heap growth is the error.
 	goalGrowthRatio := gcEffectiveGrowthRatio()
-	actualGrowthRatio := float64(memstats.heap_live)/float64(memstats.heap_marked) - 1
+	actualGrowthRatio := float64(c.heapLive)/float64(c.heapMarked) - 1
 	assistDuration := nanotime() - c.markStartTime
 
 	// Assume background mark hit its utilization goal.
@@ -381,20 +452,20 @@ func (c *gcControllerState) endCycle() float64 {
 		utilization += float64(c.assistTime) / float64(assistDuration*int64(gomaxprocs))
 	}
 
-	triggerError := goalGrowthRatio - memstats.triggerRatio - utilization/gcGoalUtilization*(actualGrowthRatio-memstats.triggerRatio)
+	triggerError := goalGrowthRatio - c.triggerRatio - utilization/gcGoalUtilization*(actualGrowthRatio-c.triggerRatio)
 
 	// Finally, we adjust the trigger for next time by this error,
 	// damped by the proportional gain.
-	triggerRatio := memstats.triggerRatio + triggerGain*triggerError
+	triggerRatio := c.triggerRatio + triggerGain*triggerError
 
 	if debug.gcpacertrace > 0 {
 		// Print controller state in terms of the design
 		// document.
-		H_m_prev := memstats.heap_marked
-		h_t := memstats.triggerRatio
-		H_T := memstats.gc_trigger
+		H_m_prev := c.heapMarked
+		h_t := c.triggerRatio
+		H_T := c.trigger
 		h_a := actualGrowthRatio
-		H_a := memstats.heap_live
+		H_a := c.heapLive
 		h_g := goalGrowthRatio
 		H_g := int64(float64(H_m_prev) * (1 + h_g))
 		u_a := utilization
@@ -516,7 +587,7 @@ func (c *gcControllerState) findRunnableGCWorker(_p_ *p) *g {
 		// goal?
 		//
 		// This should be kept in sync with pollFractionalWorkerExit.
-		delta := nanotime() - gcController.markStartTime
+		delta := nanotime() - c.markStartTime
 		if delta > 0 && float64(_p_.gcFractionalMarkTime)/float64(delta) > c.fractionalUtilizationGoal {
 			// Nope. No need to run a fractional worker.
 			gcBgMarkWorkerPool.push(&node.node)
@@ -542,8 +613,8 @@ func (c *gcControllerState) findRunnableGCWorker(_p_ *p) *g {
 // This can be called any time. If GC is the in the middle of a
 // concurrent phase, it will adjust the pacing of that phase.
 //
-// This depends on gcPercent, memstats.heap_marked, and
-// memstats.heap_live. These must be up to date.
+// This depends on gcPercent, gcController.heapMarked, and
+// gcController.heapLive. These must be up to date.
 //
 // mheap_.lock must be held or the world must be stopped.
 func gcSetTriggerRatio(triggerRatio float64) {
@@ -554,7 +625,7 @@ func gcSetTriggerRatio(triggerRatio float64) {
 	// cycle.
 	goal := ^uint64(0)
 	if gcPercent >= 0 {
-		goal = memstats.heap_marked + memstats.heap_marked*uint64(gcPercent)/100
+		goal = gcController.heapMarked + gcController.heapMarked*uint64(gcPercent)/100
 	}
 
 	// Set the trigger ratio, capped to reasonable bounds.
@@ -592,7 +663,7 @@ func gcSetTriggerRatio(triggerRatio float64) {
 		// certainly undesirable.
 		triggerRatio = 0
 	}
-	memstats.triggerRatio = triggerRatio
+	gcController.triggerRatio = triggerRatio
 
 	// Compute the absolute GC trigger from the trigger ratio.
 	//
@@ -600,16 +671,16 @@ func gcSetTriggerRatio(triggerRatio float64) {
 	// grown by the trigger ratio over the marked heap size.
 	trigger := ^uint64(0)
 	if gcPercent >= 0 {
-		trigger = uint64(float64(memstats.heap_marked) * (1 + triggerRatio))
+		trigger = uint64(float64(gcController.heapMarked) * (1 + triggerRatio))
 		// Don't trigger below the minimum heap size.
 		minTrigger := heapMinimum
 		if !isSweepDone() {
 			// Concurrent sweep happens in the heap growth
-			// from heap_live to gc_trigger, so ensure
+			// from gcController.heapLive to trigger, so ensure
 			// that concurrent sweep has some heap growth
 			// in which to perform sweeping before we
 			// start the next GC cycle.
-			sweepMin := atomic.Load64(&memstats.heap_live) + sweepMinHeapDistance
+			sweepMin := atomic.Load64(&gcController.heapLive) + sweepMinHeapDistance
 			if sweepMin > minTrigger {
 				minTrigger = sweepMin
 			}
@@ -618,8 +689,8 @@ func gcSetTriggerRatio(triggerRatio float64) {
 			trigger = minTrigger
 		}
 		if int64(trigger) < 0 {
-			print("runtime: next_gc=", memstats.next_gc, " heap_marked=", memstats.heap_marked, " heap_live=", memstats.heap_live, " initialHeapLive=", work.initialHeapLive, "triggerRatio=", triggerRatio, " minTrigger=", minTrigger, "\n")
-			throw("gc_trigger underflow")
+			print("runtime: next_gc=", memstats.next_gc, " heapMarked=", gcController.heapMarked, " gcController.heapLive=", gcController.heapLive, " initialHeapLive=", work.initialHeapLive, "triggerRatio=", triggerRatio, " minTrigger=", minTrigger, "\n")
+			throw("trigger underflow")
 		}
 		if trigger > goal {
 			// The trigger ratio is always less than GOGC/100, but
@@ -630,7 +701,7 @@ func gcSetTriggerRatio(triggerRatio float64) {
 	}
 
 	// Commit to the trigger and goal.
-	memstats.gc_trigger = trigger
+	gcController.trigger = trigger
 	atomic.Store64(&memstats.next_gc, goal)
 	if trace.enabled {
 		traceNextGC()
@@ -650,7 +721,7 @@ func gcSetTriggerRatio(triggerRatio float64) {
 		// trigger. Compute the ratio of in-use pages to sweep
 		// per byte allocated, accounting for the fact that
 		// some might already be swept.
-		heapLiveBasis := atomic.Load64(&memstats.heap_live)
+		heapLiveBasis := atomic.Load64(&gcController.heapLive)
 		heapDistance := int64(trigger) - int64(heapLiveBasis)
 		// Add a little margin so rounding errors and
 		// concurrent sweep are less likely to leave pages
@@ -679,7 +750,7 @@ func gcSetTriggerRatio(triggerRatio float64) {
 }
 
 // gcEffectiveGrowthRatio returns the current effective heap growth
-// ratio (GOGC/100) based on heap_marked from the previous GC and
+// ratio (GOGC/100) based on heapMarked from the previous GC and
 // next_gc for the current GC.
 //
 // This may differ from gcPercent/100 because of various upper and
@@ -690,7 +761,7 @@ func gcSetTriggerRatio(triggerRatio float64) {
 func gcEffectiveGrowthRatio() float64 {
 	assertWorldStoppedOrLockHeld(&mheap_.lock)
 
-	egogc := float64(atomic.Load64(&memstats.next_gc)-memstats.heap_marked) / float64(memstats.heap_marked)
+	egogc := float64(atomic.Load64(&memstats.next_gc)-gcController.heapMarked) / float64(gcController.heapMarked)
 	if egogc < 0 {
 		// Shouldn't happen, but just in case.
 		egogc = 0
@@ -710,7 +781,7 @@ func setGCPercent(in int32) (out int32) {
 		gcPercent = in
 		heapMinimum = defaultHeapMinimum * uint64(gcPercent) / 100
 		// Update pacing in response to gcPercent change.
-		gcSetTriggerRatio(memstats.triggerRatio)
+		gcSetTriggerRatio(gcController.triggerRatio)
 		unlock(&mheap_.lock)
 	})
 
diff --git a/src/runtime/mgcsweep.go b/src/runtime/mgcsweep.go
index ce1fd0ac85..8fe3a65340 100644
--- a/src/runtime/mgcsweep.go
+++ b/src/runtime/mgcsweep.go
@@ -245,7 +245,7 @@ func (l *sweepLocker) dispose() {
 
 func (l *sweepLocker) sweepIsDone() {
 	if debug.gcpacertrace > 0 {
-		print("pacer: sweep done at heap size ", memstats.heap_live>>20, "MB; allocated ", (memstats.heap_live-mheap_.sweepHeapLiveBasis)>>20, "MB during sweep; swept ", mheap_.pagesSwept, " pages at ", mheap_.sweepPagesPerByte, " pages/byte\n")
+		print("pacer: sweep done at heap size ", gcController.heapLive>>20, "MB; allocated ", (gcController.heapLive-mheap_.sweepHeapLiveBasis)>>20, "MB during sweep; swept ", mheap_.pagesSwept, " pages at ", mheap_.sweepPagesPerByte, " pages/byte\n")
 	}
 }
 
@@ -722,7 +722,7 @@ retry:
 	sweptBasis := atomic.Load64(&mheap_.pagesSweptBasis)
 
 	// Fix debt if necessary.
-	newHeapLive := uintptr(atomic.Load64(&memstats.heap_live)-mheap_.sweepHeapLiveBasis) + spanBytes
+	newHeapLive := uintptr(atomic.Load64(&gcController.heapLive)-mheap_.sweepHeapLiveBasis) + spanBytes
 	pagesTarget := int64(mheap_.sweepPagesPerByte*float64(newHeapLive)) - int64(callerSweepPages)
 	for pagesTarget > int64(atomic.Load64(&mheap_.pagesSwept)-sweptBasis) {
 		if sweepone() == ^uintptr(0) {
diff --git a/src/runtime/mheap.go b/src/runtime/mheap.go
index dfc25940d2..a34bab42a4 100644
--- a/src/runtime/mheap.go
+++ b/src/runtime/mheap.go
@@ -86,14 +86,14 @@ type mheap struct {
 
 	// Proportional sweep
 	//
-	// These parameters represent a linear function from heap_live
+	// These parameters represent a linear function from gcController.heapLive
 	// to page sweep count. The proportional sweep system works to
 	// stay in the black by keeping the current page sweep count
-	// above this line at the current heap_live.
+	// above this line at the current gcController.heapLive.
 	//
 	// The line has slope sweepPagesPerByte and passes through a
 	// basis point at (sweepHeapLiveBasis, pagesSweptBasis). At
-	// any given time, the system is at (memstats.heap_live,
+	// any given time, the system is at (gcController.heapLive,
 	// pagesSwept) in this space.
 	//
 	// It's important that the line pass through a point we
@@ -105,7 +105,7 @@ type mheap struct {
 	pagesInUse         uint64  // pages of spans in stats mSpanInUse; updated atomically
 	pagesSwept         uint64  // pages swept this cycle; updated atomically
 	pagesSweptBasis    uint64  // pagesSwept to use as the origin of the sweep ratio; updated atomically
-	sweepHeapLiveBasis uint64  // value of heap_live to use as the origin of sweep ratio; written with lock, read without
+	sweepHeapLiveBasis uint64  // value of gcController.heapLive to use as the origin of sweep ratio; written with lock, read without
 	sweepPagesPerByte  float64 // proportional sweep ratio; written with lock, read without
 	// TODO(austin): pagesInUse should be a uintptr, but the 386
 	// compiler can't 8-byte align fields.
diff --git a/src/runtime/mstats.go b/src/runtime/mstats.go
index 6defaedabe..cd9359bc91 100644
--- a/src/runtime/mstats.go
+++ b/src/runtime/mstats.go
@@ -62,7 +62,7 @@ type mstats struct {
 
 	// Statistics about the garbage collector.
 
-	// next_gc is the goal heap_live for when next GC ends.
+	// next_gc is the goal gcController.heapLive for when next GC ends.
 	// Set to ^uint64(0) if disabled.
 	//
 	// Read and written atomically, unless the world is stopped.
@@ -96,65 +96,6 @@ type mstats struct {
 	last_next_gc     uint64 // next_gc for the previous GC
 	last_heap_inuse  uint64 // heap_inuse at mark termination of the previous GC
 
-	// triggerRatio is the heap growth ratio that triggers marking.
-	//
-	// E.g., if this is 0.6, then GC should start when the live
-	// heap has reached 1.6 times the heap size marked by the
-	// previous cycle. This should be ≤ GOGC/100 so the trigger
-	// heap size is less than the goal heap size. This is set
-	// during mark termination for the next cycle's trigger.
-	triggerRatio float64
-
-	// gc_trigger is the heap size that triggers marking.
-	//
-	// When heap_live ≥ gc_trigger, the mark phase will start.
-	// This is also the heap size by which proportional sweeping
-	// must be complete.
-	//
-	// This is computed from triggerRatio during mark termination
-	// for the next cycle's trigger.
-	gc_trigger uint64
-
-	// heap_live is the number of bytes considered live by the GC.
-	// That is: retained by the most recent GC plus allocated
-	// since then. heap_live <= alloc, since alloc includes unmarked
-	// objects that have not yet been swept (and hence goes up as we
-	// allocate and down as we sweep) while heap_live excludes these
-	// objects (and hence only goes up between GCs).
-	//
-	// This is updated atomically without locking. To reduce
-	// contention, this is updated only when obtaining a span from
-	// an mcentral and at this point it counts all of the
-	// unallocated slots in that span (which will be allocated
-	// before that mcache obtains another span from that
-	// mcentral). Hence, it slightly overestimates the "true" live
-	// heap size. It's better to overestimate than to
-	// underestimate because 1) this triggers the GC earlier than
-	// necessary rather than potentially too late and 2) this
-	// leads to a conservative GC rate rather than a GC rate that
-	// is potentially too low.
-	//
-	// Reads should likewise be atomic (or during STW).
-	//
-	// Whenever this is updated, call traceHeapAlloc() and
-	// gcController.revise().
-	heap_live uint64
-
-	// heap_scan is the number of bytes of "scannable" heap. This
-	// is the live heap (as counted by heap_live), but omitting
-	// no-scan objects and no-scan tails of objects.
-	//
-	// Whenever this is updated, call gcController.revise().
-	//
-	// Read and written atomically or with the world stopped.
-	heap_scan uint64
-
-	// heap_marked is the number of bytes marked by the previous
-	// GC. After mark termination, heap_live == heap_marked, but
-	// unlike heap_live, heap_marked does not change until the
-	// next mark termination.
-	heap_marked uint64
-
 	// heapStats is a set of statistics
 	heapStats consistentHeapStats
 
@@ -443,10 +384,6 @@ type MemStats struct {
 }
 
 func init() {
-	if offset := unsafe.Offsetof(memstats.heap_live); offset%8 != 0 {
-		println(offset)
-		throw("memstats.heap_live not aligned to 8 bytes")
-	}
 	if offset := unsafe.Offsetof(memstats.heapStats); offset%8 != 0 {
 		println(offset)
 		throw("memstats.heapStats not aligned to 8 bytes")
diff --git a/src/runtime/trace.go b/src/runtime/trace.go
index bfaa00ee58..ba8fbda028 100644
--- a/src/runtime/trace.go
+++ b/src/runtime/trace.go
@@ -1144,7 +1144,7 @@ func traceGoSysBlock(pp *p) {
 }
 
 func traceHeapAlloc() {
-	traceEvent(traceEvHeapAlloc, -1, memstats.heap_live)
+	traceEvent(traceEvHeapAlloc, -1, gcController.heapLive)
 }
 
 func traceNextGC() {
-- 
GitLab


From 34620364cb2ea52e0ebf400a9cda91f86cb38a25 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Tue, 13 Apr 2021 14:12:43 -0400
Subject: [PATCH 1539/2400] runtime, cgo/test: improve debugging output

tests that run commands should log their actions in a
shell-pasteable way.

Change-Id: Ifeee88397047ef5a76925c5f30c213e83e535038
Reviewed-on: https://go-review.googlesource.com/c/go/+/309770
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 misc/cgo/testplugin/plugin_test.go | 67 ++++++++++++++++++++++++++++++
 src/runtime/plugin.go              |  3 +-
 src/runtime/symtab.go              | 12 +++++-
 3 files changed, 79 insertions(+), 3 deletions(-)

diff --git a/misc/cgo/testplugin/plugin_test.go b/misc/cgo/testplugin/plugin_test.go
index b894e8d30d..28a8c669c0 100644
--- a/misc/cgo/testplugin/plugin_test.go
+++ b/misc/cgo/testplugin/plugin_test.go
@@ -30,6 +30,18 @@ func TestMain(m *testing.M) {
 	os.Exit(testMain(m))
 }
 
+// tmpDir is used to cleanup logged commands -- s/tmpDir/$TMPDIR/
+var tmpDir string
+
+// prettyPrintf prints lines with tmpDir sanitized.
+func prettyPrintf(format string, args ...interface{}) {
+	s := fmt.Sprintf(format, args...)
+	if tmpDir != "" {
+		s = strings.ReplaceAll(s, tmpDir, "$TMPDIR")
+	}
+	fmt.Print(s)
+}
+
 func testMain(m *testing.M) int {
 	// Copy testdata into GOPATH/src/testplugin, along with a go.mod file
 	// declaring the same path.
@@ -39,6 +51,7 @@ func testMain(m *testing.M) int {
 		log.Panic(err)
 	}
 	defer os.RemoveAll(GOPATH)
+	tmpDir = GOPATH
 
 	modRoot := filepath.Join(GOPATH, "src", "testplugin")
 	altRoot := filepath.Join(GOPATH, "alt", "src", "testplugin")
@@ -49,14 +62,20 @@ func testMain(m *testing.M) int {
 		if err := overlayDir(dstRoot, srcRoot); err != nil {
 			log.Panic(err)
 		}
+		prettyPrintf("mkdir -p %s\n", dstRoot)
+		prettyPrintf("rsync -a %s/ %s\n", srcRoot, dstRoot)
+
 		if err := os.WriteFile(filepath.Join(dstRoot, "go.mod"), []byte("module testplugin\n"), 0666); err != nil {
 			log.Panic(err)
 		}
+		prettyPrintf("echo 'module testplugin' > %s/go.mod\n", dstRoot)
 	}
 
 	os.Setenv("GOPATH", filepath.Join(GOPATH, "alt"))
 	if err := os.Chdir(altRoot); err != nil {
 		log.Panic(err)
+	} else {
+		prettyPrintf("cd %s\n", altRoot)
 	}
 	os.Setenv("PWD", altRoot)
 	goCmd(nil, "build", "-buildmode=plugin", "-o", filepath.Join(modRoot, "plugin-mismatch.so"), "./plugin-mismatch")
@@ -64,6 +83,8 @@ func testMain(m *testing.M) int {
 	os.Setenv("GOPATH", GOPATH)
 	if err := os.Chdir(modRoot); err != nil {
 		log.Panic(err)
+	} else {
+		prettyPrintf("cd %s\n", modRoot)
 	}
 	os.Setenv("PWD", modRoot)
 
@@ -78,6 +99,7 @@ func testMain(m *testing.M) int {
 	if err := os.WriteFile("plugin2-dup.so", so, 0444); err != nil {
 		log.Panic(err)
 	}
+	prettyPrintf("cp plugin2.so plugin2-dup.so\n")
 
 	goCmd(nil, "build", "-buildmode=plugin", "-o=sub/plugin1.so", "./sub/plugin1")
 	goCmd(nil, "build", "-buildmode=plugin", "-o=unnamed1.so", "./unnamed1/main.go")
@@ -94,8 +116,53 @@ func goCmd(t *testing.T, op string, args ...string) {
 	run(t, "go", append([]string{op, "-gcflags", gcflags}, args...)...)
 }
 
+// escape converts a string to something suitable for a shell command line.
+func escape(s string) string {
+	s = strings.Replace(s, "\\", "\\\\", -1)
+	s = strings.Replace(s, "'", "\\'", -1)
+	// Conservative guess at characters that will force quoting
+	if s == "" || strings.ContainsAny(s, "\\ ;#*&$~?!|[]()<>{}`") {
+		s = "'" + s + "'"
+	}
+	return s
+}
+
+// asCommandLine renders cmd as something that could be copy-and-pasted into a command line
+func asCommandLine(cwd string, cmd *exec.Cmd) string {
+	s := "("
+	if cmd.Dir != "" && cmd.Dir != cwd {
+		s += "cd" + escape(cmd.Dir) + ";"
+	}
+	for _, e := range cmd.Env {
+		if !strings.HasPrefix(e, "PATH=") &&
+			!strings.HasPrefix(e, "HOME=") &&
+			!strings.HasPrefix(e, "USER=") &&
+			!strings.HasPrefix(e, "SHELL=") {
+			s += " "
+			s += escape(e)
+		}
+	}
+	// These EVs are relevant to this test.
+	for _, e := range os.Environ() {
+		if strings.HasPrefix(e, "PWD=") ||
+			strings.HasPrefix(e, "GOPATH=") ||
+			strings.HasPrefix(e, "LD_LIBRARY_PATH=") {
+			s += " "
+			s += escape(e)
+		}
+	}
+	for _, a := range cmd.Args {
+		s += " "
+		s += escape(a)
+	}
+	s += " )"
+	return s
+}
+
 func run(t *testing.T, bin string, args ...string) string {
 	cmd := exec.Command(bin, args...)
+	cmdLine := asCommandLine(".", cmd)
+	prettyPrintf("%s\n", cmdLine)
 	cmd.Stderr = new(strings.Builder)
 	out, err := cmd.Output()
 	if err != nil {
diff --git a/src/runtime/plugin.go b/src/runtime/plugin.go
index 5e05be71ec..cd7fc5f848 100644
--- a/src/runtime/plugin.go
+++ b/src/runtime/plugin.go
@@ -115,7 +115,8 @@ func pluginftabverify(md *moduledata) {
 			entry2 = f2.entry
 		}
 		badtable = true
-		println("ftab entry outside pc range: ", hex(entry), "/", hex(entry2), ": ", name, "/", name2)
+		println("ftab entry", hex(entry), "/", hex(entry2), ": ",
+			name, "/", name2, "outside pc range:[", hex(md.minpc), ",", hex(md.maxpc), "], modulename=", md.modulename, ", pluginpath=", md.pluginpath)
 	}
 	if badtable {
 		throw("runtime: plugin has bad symbol table")
diff --git a/src/runtime/symtab.go b/src/runtime/symtab.go
index c0630c874e..cf759153e7 100644
--- a/src/runtime/symtab.go
+++ b/src/runtime/symtab.go
@@ -561,7 +561,11 @@ func moduledataverify1(datap *moduledata) {
 	// Check that the pclntab's format is valid.
 	hdr := datap.pcHeader
 	if hdr.magic != 0xfffffffa || hdr.pad1 != 0 || hdr.pad2 != 0 || hdr.minLC != sys.PCQuantum || hdr.ptrSize != sys.PtrSize {
-		println("runtime: function symbol table header:", hex(hdr.magic), hex(hdr.pad1), hex(hdr.pad2), hex(hdr.minLC), hex(hdr.ptrSize))
+		print("runtime: function symbol table header:", hex(hdr.magic), hex(hdr.pad1), hex(hdr.pad2), hex(hdr.minLC), hex(hdr.ptrSize))
+		if datap.pluginpath != "" {
+			print(", plugin:", datap.pluginpath)
+		}
+		println()
 		throw("invalid function symbol table\n")
 	}
 
@@ -576,7 +580,11 @@ func moduledataverify1(datap *moduledata) {
 			if i+1 < nftab {
 				f2name = funcname(f2)
 			}
-			println("function symbol table not sorted by program counter:", hex(datap.ftab[i].entry), funcname(f1), ">", hex(datap.ftab[i+1].entry), f2name)
+			print("function symbol table not sorted by program counter:", hex(datap.ftab[i].entry), funcname(f1), ">", hex(datap.ftab[i+1].entry), f2name)
+			if datap.pluginpath != "" {
+				print(", plugin:", datap.pluginpath)
+			}
+			println()
 			for j := 0; j <= i; j++ {
 				print("\t", hex(datap.ftab[j].entry), " ", funcname(funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[datap.ftab[j].funcoff])), datap}), "\n")
 			}
-- 
GitLab


From 8dcc071063c0a9f020f0aafd51b7e0a17f0a0746 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 13 Apr 2021 16:33:42 -0700
Subject: [PATCH 1540/2400] cmd/compile/internal/types2: use a global atomic
 counter for type parameter ids

This avoids a dependency on a *Checker when we create type parameters
outside the type checker proper, e.g. in an importer. There may be
better solutions but this does the trick for now.

Change-Id: Icf22c934970cb04c88c2729555ae6a79ef5a2245
Reviewed-on: https://go-review.googlesource.com/c/go/+/309830
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/api_test.go   |  1 +
 src/cmd/compile/internal/types2/check.go      |  2 --
 src/cmd/compile/internal/types2/type.go       | 13 +++++++++++--
 src/cmd/compile/internal/types2/types_test.go |  8 ++++++++
 4 files changed, 20 insertions(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go
index 9d31fef69b..b3b16131ce 100644
--- a/src/cmd/compile/internal/types2/api_test.go
+++ b/src/cmd/compile/internal/types2/api_test.go
@@ -349,6 +349,7 @@ func TestTypesInfo(t *testing.T) {
 	}
 
 	for _, test := range tests {
+		ResetId() // avoid renumbering of type parameter ids when adding tests
 		info := Info{Types: make(map[syntax.Expr]TypeAndValue)}
 		var name string
 		if strings.HasPrefix(test.src, brokenPkg) {
diff --git a/src/cmd/compile/internal/types2/check.go b/src/cmd/compile/internal/types2/check.go
index 7703d98fa6..66637459e7 100644
--- a/src/cmd/compile/internal/types2/check.go
+++ b/src/cmd/compile/internal/types2/check.go
@@ -83,7 +83,6 @@ type Checker struct {
 	pkg  *Package
 	*Info
 	version version                     // accepted language version
-	nextId  uint64                      // unique Id for type parameters (first valid Id is 1)
 	objMap  map[Object]*declInfo        // maps package-level objects and (non-interface) methods to declaration info
 	impMap  map[importKey]*Package      // maps (import path, source directory) to (complete or fake) package
 	posMap  map[*Interface][]syntax.Pos // maps interface types to lists of embedded interface positions
@@ -178,7 +177,6 @@ func NewChecker(conf *Config, pkg *Package, info *Info) *Checker {
 		pkg:     pkg,
 		Info:    info,
 		version: version,
-		nextId:  1,
 		objMap:  make(map[Object]*declInfo),
 		impMap:  make(map[importKey]*Package),
 		posMap:  make(map[*Interface][]syntax.Pos),
diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
index 277ed06026..daa00ddd3a 100644
--- a/src/cmd/compile/internal/types2/type.go
+++ b/src/cmd/compile/internal/types2/type.go
@@ -7,6 +7,7 @@ package types2
 import (
 	"cmd/compile/internal/syntax"
 	"fmt"
+	"sync/atomic"
 )
 
 // A Type represents a type of Go.
@@ -718,6 +719,15 @@ func (t *Named) AddMethod(m *Func) {
 	}
 }
 
+// Note: This is a uint32 rather than a uint64 because the
+// respective 64 bit atomic instructions are not available
+// on all platforms.
+var lastId uint32
+
+// nextId returns a value increasing monotonically by 1 with
+// each call, starting with 1. It may be called concurrently.
+func nextId() uint64 { return uint64(atomic.AddUint32(&lastId, 1)) }
+
 // A TypeParam represents a type parameter type.
 type TypeParam struct {
 	check *Checker  // for lazy type bound completion
@@ -733,8 +743,7 @@ func (t *TypeParam) Obj() *TypeName { return t.obj }
 // NewTypeParam returns a new TypeParam.
 func (check *Checker) NewTypeParam(obj *TypeName, index int, bound Type) *TypeParam {
 	assert(bound != nil)
-	typ := &TypeParam{check: check, id: check.nextId, obj: obj, index: index, bound: bound}
-	check.nextId++
+	typ := &TypeParam{check: check, id: nextId(), obj: obj, index: index, bound: bound}
 	if obj.typ == nil {
 		obj.typ = typ
 	}
diff --git a/src/cmd/compile/internal/types2/types_test.go b/src/cmd/compile/internal/types2/types_test.go
index 11dca0b53d..096402148d 100644
--- a/src/cmd/compile/internal/types2/types_test.go
+++ b/src/cmd/compile/internal/types2/types_test.go
@@ -4,6 +4,14 @@
 
 package types2
 
+import "sync/atomic"
+
 func init() {
 	acceptMethodTypeParams = true
 }
+
+// Upon calling ResetId, nextId starts with 1 again.
+// It may be called concurrently. This is only needed
+// for tests where we may want to have a consistent
+// numbering for each individual test case.
+func ResetId() { atomic.StoreUint32(&lastId, 0) }
-- 
GitLab


From eb433ed5a2ab13567cd5d7f0413308174750d5dd Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Sun, 11 Apr 2021 09:47:13 -0700
Subject: [PATCH 1541/2400] cmd/compile: set types properly for imported funcs
 with closures

For the new export/import of node types, we were just missing setting
the types of the closure variables (which have the same types as the
captured variables) and the OCLOSURE node itself (which has the same
type as the Func node).

Re-enabled inlining of functions with closures.

Change-Id: I687149b061f3ffeec3244ff02dc6e946659077a9
Reviewed-on: https://go-review.googlesource.com/c/go/+/308974
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/inline/inl.go        |  2 +-
 src/cmd/compile/internal/typecheck/iimport.go | 11 +++++
 test/closure3.dir/main.go                     | 44 +++++++++----------
 test/inline.go                                | 22 +++++-----
 4 files changed, 45 insertions(+), 34 deletions(-)

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 4470df1d2a..3cbe932d55 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -354,7 +354,7 @@ func (v *hairyVisitor) doNode(n ir.Node) bool {
 		return true
 
 	case ir.OCLOSURE:
-		if base.Debug.InlFuncsWithClosures == 0 || typecheck.Go117ExportTypes { // TODO: remove latter condition
+		if base.Debug.InlFuncsWithClosures == 0 {
 			v.reason = "not inlining functions with closures"
 			return true
 		}
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 0d5d892ef5..42c4619666 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -1112,6 +1112,14 @@ func (r *importReader) node() ir.Node {
 		cvars := make([]*ir.Name, r.int64())
 		for i := range cvars {
 			cvars[i] = ir.CaptureName(r.pos(), fn, r.localName().Canonical())
+			if go117ExportTypes {
+				if cvars[i].Type() != nil || cvars[i].Defn == nil {
+					base.Fatalf("bad import of closure variable")
+				}
+				// Closure variable should have Defn set, which is its captured
+				// variable, and it gets the same type as the captured variable.
+				cvars[i].SetType(cvars[i].Defn.Type())
+			}
 		}
 		fn.ClosureVars = cvars
 		r.allClosureVars = append(r.allClosureVars, cvars...)
@@ -1133,6 +1141,9 @@ func (r *importReader) node() ir.Node {
 
 		clo := ir.NewClosureExpr(pos, fn)
 		fn.OClosure = clo
+		if go117ExportTypes {
+			clo.SetType(typ)
+		}
 
 		return clo
 
diff --git a/test/closure3.dir/main.go b/test/closure3.dir/main.go
index e8e1e99860..2fc33753ed 100644
--- a/test/closure3.dir/main.go
+++ b/test/closure3.dir/main.go
@@ -93,11 +93,11 @@ func main() {
 		y := func(x int) int { // ERROR "can inline main.func11" "func literal does not escape"
 			return x + 2
 		}
-		y, sink = func() (func(int) int, int) { // ERROR "func literal does not escape"
-			return func(x int) int { // ERROR "can inline main.func12" "func literal escapes"
+		y, sink = func() (func(int) int, int) { // ERROR "can inline main.func12"
+			return func(x int) int { // ERROR "can inline main.func12"
 				return x + 1
 			}, 42
-		}()
+		}() // ERROR "func literal does not escape" "inlining call to main.func12"
 		if y(40) != 41 {
 			ppanic("y(40) != 41")
 		}
@@ -105,14 +105,14 @@ func main() {
 
 	{
 		func() { // ERROR "func literal does not escape"
-			y := func(x int) int { // ERROR "can inline main.func13.1" "func literal does not escape"
+			y := func(x int) int { // ERROR "func literal does not escape" "can inline main.func13.1"
 				return x + 2
 			}
-			y, sink = func() (func(int) int, int) { // ERROR "func literal does not escape"
-				return func(x int) int { // ERROR "can inline main.func13.2" "func literal escapes"
+			y, sink = func() (func(int) int, int) { // ERROR "can inline main.func13.2"
+				return func(x int) int { // ERROR "can inline main.func13.2"
 					return x + 1
 				}, 42
-			}()
+			}() // ERROR "inlining call to main.func13.2" "func literal does not escape"
 			if y(40) != 41 {
 				ppanic("y(40) != 41")
 			}
@@ -187,29 +187,29 @@ func main() {
 
 	{
 		x := 42
-		if z := func(y int) int { // ERROR "func literal does not escape"
-			return func() int { // ERROR "can inline main.func22.1"
+		if z := func(y int) int { // ERROR "can inline main.func22"
+			return func() int { // ERROR "can inline main.func22.1" "can inline main.func30"
 				return x + y
 			}() // ERROR "inlining call to main.func22.1"
-		}(1); z != 43 {
+		}(1); z != 43 { // ERROR "inlining call to main.func22" "inlining call to main.func30"
 			ppanic("z != 43")
 		}
-		if z := func(y int) int { // ERROR "func literal does not escape"
-			return func() int { // ERROR "can inline main.func23.1"
+		if z := func(y int) int { // ERROR "func literal does not escape" "can inline main.func23"
+			return func() int { // ERROR "can inline main.func23.1" "can inline main.func31"
 				return x + y
 			}() // ERROR "inlining call to main.func23.1"
-		}; z(1) != 43 {
+		}; z(1) != 43 { // ERROR "inlining call to main.func23" "inlining call to main.func31"
 			ppanic("z(1) != 43")
 		}
 	}
 
 	{
 		a := 1
-		func() { // ERROR "func literal does not escape"
-			func() { // ERROR "can inline main.func24"
+		func() { // ERROR "can inline main.func24"
+			func() { // ERROR "can inline main.func24" "can inline main.func32"
 				a = 2
 			}() // ERROR "inlining call to main.func24"
-		}()
+		}() // ERROR "inlining call to main.func24" "inlining call to main.func32"
 		if a != 2 {
 			ppanic("a != 2")
 		}
@@ -250,12 +250,12 @@ func main() {
 		a := 2
 		if r := func(x int) int { // ERROR "func literal does not escape"
 			b := 3
-			return func(y int) int { // ERROR "func literal does not escape"
+			return func(y int) int { // ERROR "can inline main.func27.1"
 				c := 5
-				return func(z int) int { // ERROR "can inline main.func27.1.1"
+				return func(z int) int { // ERROR "can inline main.func27.1.1" "can inline main.func27.2"
 					return a*x + b*y + c*z
 				}(10) // ERROR "inlining call to main.func27.1.1"
-			}(100)
+			}(100) // ERROR "inlining call to main.func27.1" "inlining call to main.func27.2"
 		}(1000); r != 2350 {
 			ppanic("r != 2350")
 		}
@@ -265,15 +265,15 @@ func main() {
 		a := 2
 		if r := func(x int) int { // ERROR "func literal does not escape"
 			b := 3
-			return func(y int) int { // ERROR "func literal does not escape"
+			return func(y int) int { // ERROR "can inline main.func28.1"
 				c := 5
-				func(z int) { // ERROR "can inline main.func28.1.1"
+				func(z int) { // ERROR "can inline main.func28.1.1" "can inline main.func28.2"
 					a = a * x
 					b = b * y
 					c = c * z
 				}(10) // ERROR "inlining call to main.func28.1.1"
 				return a + c
-			}(100) + b
+			}(100) + b // ERROR "inlining call to main.func28.1" "inlining call to main.func28.2"
 		}(1000); r != 2350 {
 			ppanic("r != 2350")
 		}
diff --git a/test/inline.go b/test/inline.go
index b0911056ca..bc23768d01 100644
--- a/test/inline.go
+++ b/test/inline.go
@@ -58,7 +58,7 @@ func _() int { // ERROR "can inline _"
 var somethingWrong error
 
 // local closures can be inlined
-func l(x, y int) (int, int, error) {
+func l(x, y int) (int, int, error) { // ERROR "can inline l"
 	e := func(err error) (int, int, error) { // ERROR "can inline l.func1" "func literal does not escape" "leaking param: err to result"
 		return 0, 0, err
 	}
@@ -90,19 +90,19 @@ func n() int {
 // make sure assignment inside closure is detected
 func o() int {
 	foo := func() int { return 1 } // ERROR "can inline o.func1" "func literal does not escape"
-	func(x int) {                  // ERROR "func literal does not escape"
+	func(x int) {                  // ERROR "can inline o.func2"
 		if x > 10 {
-			foo = func() int { return 2 } // ERROR "can inline o.func2" "func literal escapes"
+			foo = func() int { return 2 } // ERROR "can inline o.func2"
 		}
-	}(11)
+	}(11) // ERROR "func literal does not escape" "inlining call to o.func2"
 	return foo()
 }
 
-func p() int {
+func p() int { // ERROR "can inline p"
 	return func() int { return 42 }() // ERROR "can inline p.func1" "inlining call to p.func1"
 }
 
-func q(x int) int {
+func q(x int) int { // ERROR "can inline q"
 	foo := func() int { return x * 2 } // ERROR "can inline q.func1" "func literal does not escape"
 	return foo()                       // ERROR "inlining call to q.func1"
 }
@@ -111,15 +111,15 @@ func r(z int) int {
 	foo := func(x int) int { // ERROR "can inline r.func1" "func literal does not escape"
 		return x + z
 	}
-	bar := func(x int) int { // ERROR "func literal does not escape"
-		return x + func(y int) int { // ERROR "can inline r.func2.1"
+	bar := func(x int) int { // ERROR "func literal does not escape" "can inline r.func2"
+		return x + func(y int) int { // ERROR "can inline r.func2.1" "can inline r.func3"
 			return 2*y + x*z
 		}(x) // ERROR "inlining call to r.func2.1"
 	}
-	return foo(42) + bar(42) // ERROR "inlining call to r.func1"
+	return foo(42) + bar(42) // ERROR "inlining call to r.func1" "inlining call to r.func2" "inlining call to r.func3"
 }
 
-func s0(x int) int {
+func s0(x int) int { // ERROR "can inline s0"
 	foo := func() { // ERROR "can inline s0.func1" "func literal does not escape"
 		x = x + 1
 	}
@@ -127,7 +127,7 @@ func s0(x int) int {
 	return x
 }
 
-func s1(x int) int {
+func s1(x int) int { // ERROR "can inline s1"
 	foo := func() int { // ERROR "can inline s1.func1" "func literal does not escape"
 		return x
 	}
-- 
GitLab


From 728e3dc6f9c900654d94642135e0dcfe2f7bb645 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Thu, 1 Apr 2021 16:31:29 +0000
Subject: [PATCH 1542/2400] runtime: make gcSetTriggerRatio a method of
 gcControllerState

gcSetTriggerRatio's purpose is to set a bunch of downstream values when
we choose to commit to a new trigger ratio computed by the gcController.
Now that almost all the inputs it uses to compute the downstream values
are in gcControllerState anyway, make it a method of gcControllerState.

For #44167.

Change-Id: I1b7ea709e8378566f812ae3450ab169d7fb66aea
Reviewed-on: https://go-review.googlesource.com/c/go/+/306599
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
---
 src/runtime/mgc.go      |  2 +-
 src/runtime/mgcpacer.go | 22 +++++++++++-----------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index ff0618a053..f523d42812 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -982,7 +982,7 @@ func gcMarkTermination(nextTriggerRatio float64) {
 	memstats.last_heap_inuse = memstats.heap_inuse
 
 	// Update GC trigger and pacing for the next cycle.
-	gcSetTriggerRatio(nextTriggerRatio)
+	gcController.commit(nextTriggerRatio)
 
 	// Update timing memstats
 	now := nanotime()
diff --git a/src/runtime/mgcpacer.go b/src/runtime/mgcpacer.go
index 1239ba4bb8..51cb3bb1b9 100644
--- a/src/runtime/mgcpacer.go
+++ b/src/runtime/mgcpacer.go
@@ -606,7 +606,7 @@ func (c *gcControllerState) findRunnableGCWorker(_p_ *p) *g {
 	return gp
 }
 
-// gcSetTriggerRatio sets the trigger ratio and updates everything
+// commit sets the trigger ratio and updates everything
 // derived from it: the absolute trigger, the heap goal, mark pacing,
 // and sweep pacing.
 //
@@ -617,7 +617,7 @@ func (c *gcControllerState) findRunnableGCWorker(_p_ *p) *g {
 // gcController.heapLive. These must be up to date.
 //
 // mheap_.lock must be held or the world must be stopped.
-func gcSetTriggerRatio(triggerRatio float64) {
+func (c *gcControllerState) commit(triggerRatio float64) {
 	assertWorldStoppedOrLockHeld(&mheap_.lock)
 
 	// Compute the next GC goal, which is when the allocated heap
@@ -625,7 +625,7 @@ func gcSetTriggerRatio(triggerRatio float64) {
 	// cycle.
 	goal := ^uint64(0)
 	if gcPercent >= 0 {
-		goal = gcController.heapMarked + gcController.heapMarked*uint64(gcPercent)/100
+		goal = c.heapMarked + c.heapMarked*uint64(gcPercent)/100
 	}
 
 	// Set the trigger ratio, capped to reasonable bounds.
@@ -663,7 +663,7 @@ func gcSetTriggerRatio(triggerRatio float64) {
 		// certainly undesirable.
 		triggerRatio = 0
 	}
-	gcController.triggerRatio = triggerRatio
+	c.triggerRatio = triggerRatio
 
 	// Compute the absolute GC trigger from the trigger ratio.
 	//
@@ -671,7 +671,7 @@ func gcSetTriggerRatio(triggerRatio float64) {
 	// grown by the trigger ratio over the marked heap size.
 	trigger := ^uint64(0)
 	if gcPercent >= 0 {
-		trigger = uint64(float64(gcController.heapMarked) * (1 + triggerRatio))
+		trigger = uint64(float64(c.heapMarked) * (1 + triggerRatio))
 		// Don't trigger below the minimum heap size.
 		minTrigger := heapMinimum
 		if !isSweepDone() {
@@ -680,7 +680,7 @@ func gcSetTriggerRatio(triggerRatio float64) {
 			// that concurrent sweep has some heap growth
 			// in which to perform sweeping before we
 			// start the next GC cycle.
-			sweepMin := atomic.Load64(&gcController.heapLive) + sweepMinHeapDistance
+			sweepMin := atomic.Load64(&c.heapLive) + sweepMinHeapDistance
 			if sweepMin > minTrigger {
 				minTrigger = sweepMin
 			}
@@ -689,7 +689,7 @@ func gcSetTriggerRatio(triggerRatio float64) {
 			trigger = minTrigger
 		}
 		if int64(trigger) < 0 {
-			print("runtime: next_gc=", memstats.next_gc, " heapMarked=", gcController.heapMarked, " gcController.heapLive=", gcController.heapLive, " initialHeapLive=", work.initialHeapLive, "triggerRatio=", triggerRatio, " minTrigger=", minTrigger, "\n")
+			print("runtime: next_gc=", memstats.next_gc, " heapMarked=", c.heapMarked, " gcController.heapLive=", c.heapLive, " initialHeapLive=", work.initialHeapLive, "triggerRatio=", triggerRatio, " minTrigger=", minTrigger, "\n")
 			throw("trigger underflow")
 		}
 		if trigger > goal {
@@ -701,7 +701,7 @@ func gcSetTriggerRatio(triggerRatio float64) {
 	}
 
 	// Commit to the trigger and goal.
-	gcController.trigger = trigger
+	c.trigger = trigger
 	atomic.Store64(&memstats.next_gc, goal)
 	if trace.enabled {
 		traceNextGC()
@@ -709,7 +709,7 @@ func gcSetTriggerRatio(triggerRatio float64) {
 
 	// Update mark pacing.
 	if gcphase != _GCoff {
-		gcController.revise()
+		c.revise()
 	}
 
 	// Update sweep pacing.
@@ -721,7 +721,7 @@ func gcSetTriggerRatio(triggerRatio float64) {
 		// trigger. Compute the ratio of in-use pages to sweep
 		// per byte allocated, accounting for the fact that
 		// some might already be swept.
-		heapLiveBasis := atomic.Load64(&gcController.heapLive)
+		heapLiveBasis := atomic.Load64(&c.heapLive)
 		heapDistance := int64(trigger) - int64(heapLiveBasis)
 		// Add a little margin so rounding errors and
 		// concurrent sweep are less likely to leave pages
@@ -781,7 +781,7 @@ func setGCPercent(in int32) (out int32) {
 		gcPercent = in
 		heapMinimum = defaultHeapMinimum * uint64(gcPercent) / 100
 		// Update pacing in response to gcPercent change.
-		gcSetTriggerRatio(gcController.triggerRatio)
+		gcController.commit(gcController.triggerRatio)
 		unlock(&mheap_.lock)
 	})
 
-- 
GitLab


From 2d4ba2601b91e2e69712861c654e4ddaf4355f49 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Thu, 1 Apr 2021 17:56:32 +0000
Subject: [PATCH 1543/2400] runtime: move gcPercent and heapMinimum into
 gcControllerState

These variables are core to the pacer, and will be need to be non-global
for testing later.

Partially generated via

rf '
    ex . {
	gcPercent -> gcController.gcPercent
	heapMinimum -> gcController.heapMinimum
    }
'

The only exception to this generation is usage of these variables
in gcControllerState methods.

For #44167.

Change-Id: I8b620b3061114f3a3c4b65006f715fd977b180a8
Reviewed-on: https://go-review.googlesource.com/c/go/+/306600
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
---
 src/runtime/mgc.go      |  5 ++--
 src/runtime/mgcpacer.go | 58 ++++++++++++++++++++---------------------
 2 files changed, 32 insertions(+), 31 deletions(-)

diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index f523d42812..b0d46d0060 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -153,6 +153,7 @@ func gcinit() {
 	if unsafe.Sizeof(workbuf{}) != _WorkbufSize {
 		throw("size of Workbuf is suboptimal")
 	}
+	gcController.heapMinimum = defaultHeapMinimum
 
 	// No sweep on the first cycle.
 	mheap_.sweepDrained = 1
@@ -163,7 +164,7 @@ func gcinit() {
 	// Fake a heapMarked value so it looks like a trigger at
 	// heapMinimum is the appropriate growth from heapMarked.
 	// This will go into computing the initial GC goal.
-	gcController.heapMarked = uint64(float64(heapMinimum) / (1 + gcController.triggerRatio))
+	gcController.heapMarked = uint64(float64(gcController.heapMinimum) / (1 + gcController.triggerRatio))
 
 	// Set gcPercent from the environment. This will also compute
 	// and set the GC trigger and goal.
@@ -557,7 +558,7 @@ func (t gcTrigger) test() bool {
 		// own write.
 		return gcController.heapLive >= gcController.trigger
 	case gcTriggerTime:
-		if gcPercent < 0 {
+		if gcController.gcPercent < 0 {
 			return false
 		}
 		lastgc := int64(atomic.Load64(&memstats.last_gc_nanotime))
diff --git a/src/runtime/mgcpacer.go b/src/runtime/mgcpacer.go
index 51cb3bb1b9..e594dbdc06 100644
--- a/src/runtime/mgcpacer.go
+++ b/src/runtime/mgcpacer.go
@@ -49,25 +49,6 @@ const (
 	defaultHeapMinimum = 4 << 20
 )
 
-var (
-	// heapMinimum is the minimum heap size at which to trigger GC.
-	// For small heaps, this overrides the usual GOGC*live set rule.
-	//
-	// When there is a very small live set but a lot of allocation, simply
-	// collecting when the heap reaches GOGC*live results in many GC
-	// cycles and high total per-GC overhead. This minimum amortizes this
-	// per-GC overhead while keeping the heap reasonably small.
-	//
-	// During initialization this is set to 4MB*GOGC/100. In the case of
-	// GOGC==0, this will set heapMinimum to 0, resulting in constant
-	// collection even when the heap size is small, which is useful for
-	// debugging.
-	heapMinimum uint64 = defaultHeapMinimum
-
-	// Initialized from $GOGC.  GOGC=off means no GC.
-	gcPercent int32
-)
-
 func init() {
 	if offset := unsafe.Offsetof(gcController.heapLive); offset%8 != 0 {
 		println(offset)
@@ -91,6 +72,25 @@ func init() {
 var gcController gcControllerState
 
 type gcControllerState struct {
+	// Initialized from $GOGC. GOGC=off means no GC.
+	gcPercent int32
+
+	_ uint32 // padding so following 64-bit values are 8-byte aligned
+
+	// heapMinimum is the minimum heap size at which to trigger GC.
+	// For small heaps, this overrides the usual GOGC*live set rule.
+	//
+	// When there is a very small live set but a lot of allocation, simply
+	// collecting when the heap reaches GOGC*live results in many GC
+	// cycles and high total per-GC overhead. This minimum amortizes this
+	// per-GC overhead while keeping the heap reasonably small.
+	//
+	// During initialization this is set to 4MB*GOGC/100. In the case of
+	// GOGC==0, this will set heapMinimum to 0, resulting in constant
+	// collection even when the heap size is small, which is useful for
+	// debugging.
+	heapMinimum uint64
+
 	// triggerRatio is the heap growth ratio that triggers marking.
 	//
 	// E.g., if this is 0.6, then GC should start when the live
@@ -337,7 +337,7 @@ func (c *gcControllerState) startCycle() {
 // is when assists are enabled and the necessary statistics are
 // available).
 func (c *gcControllerState) revise() {
-	gcPercent := gcPercent
+	gcPercent := c.gcPercent
 	if gcPercent < 0 {
 		// If GC is disabled but we're running a forced GC,
 		// act like GOGC is huge for the below calculations.
@@ -624,13 +624,13 @@ func (c *gcControllerState) commit(triggerRatio float64) {
 	// has grown by GOGC/100 over the heap marked by the last
 	// cycle.
 	goal := ^uint64(0)
-	if gcPercent >= 0 {
-		goal = c.heapMarked + c.heapMarked*uint64(gcPercent)/100
+	if c.gcPercent >= 0 {
+		goal = c.heapMarked + c.heapMarked*uint64(c.gcPercent)/100
 	}
 
 	// Set the trigger ratio, capped to reasonable bounds.
-	if gcPercent >= 0 {
-		scalingFactor := float64(gcPercent) / 100
+	if c.gcPercent >= 0 {
+		scalingFactor := float64(c.gcPercent) / 100
 		// Ensure there's always a little margin so that the
 		// mutator assist ratio isn't infinity.
 		maxTriggerRatio := 0.95 * scalingFactor
@@ -670,10 +670,10 @@ func (c *gcControllerState) commit(triggerRatio float64) {
 	// We trigger the next GC cycle when the allocated heap has
 	// grown by the trigger ratio over the marked heap size.
 	trigger := ^uint64(0)
-	if gcPercent >= 0 {
+	if c.gcPercent >= 0 {
 		trigger = uint64(float64(c.heapMarked) * (1 + triggerRatio))
 		// Don't trigger below the minimum heap size.
-		minTrigger := heapMinimum
+		minTrigger := c.heapMinimum
 		if !isSweepDone() {
 			// Concurrent sweep happens in the heap growth
 			// from gcController.heapLive to trigger, so ensure
@@ -774,12 +774,12 @@ func setGCPercent(in int32) (out int32) {
 	// Run on the system stack since we grab the heap lock.
 	systemstack(func() {
 		lock(&mheap_.lock)
-		out = gcPercent
+		out = gcController.gcPercent
 		if in < 0 {
 			in = -1
 		}
-		gcPercent = in
-		heapMinimum = defaultHeapMinimum * uint64(gcPercent) / 100
+		gcController.gcPercent = in
+		gcController.heapMinimum = defaultHeapMinimum * uint64(gcController.gcPercent) / 100
 		// Update pacing in response to gcPercent change.
 		gcController.commit(gcController.triggerRatio)
 		unlock(&mheap_.lock)
-- 
GitLab


From 9bce7b70fde8572880e7a47bc2a4df8fb7b2c286 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Thu, 1 Apr 2021 18:01:46 +0000
Subject: [PATCH 1544/2400] runtime: create initializer for gcControllerState

Now that gcControllerState contains almost all of the pacer state,
create an initializer for it instead of haphazardly setting some fields.

For #44167.

Change-Id: I4ce1d5dd82003cb7c263fa46697851bb22a32544
Reviewed-on: https://go-review.googlesource.com/c/go/+/306601
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
---
 src/runtime/mgc.go      | 16 +++-------------
 src/runtime/mgcpacer.go | 15 +++++++++++++++
 2 files changed, 18 insertions(+), 13 deletions(-)

diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index b0d46d0060..f65402e94c 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -153,22 +153,12 @@ func gcinit() {
 	if unsafe.Sizeof(workbuf{}) != _WorkbufSize {
 		throw("size of Workbuf is suboptimal")
 	}
-	gcController.heapMinimum = defaultHeapMinimum
-
 	// No sweep on the first cycle.
 	mheap_.sweepDrained = 1
 
-	// Set a reasonable initial GC trigger.
-	gcController.triggerRatio = 7 / 8.0
-
-	// Fake a heapMarked value so it looks like a trigger at
-	// heapMinimum is the appropriate growth from heapMarked.
-	// This will go into computing the initial GC goal.
-	gcController.heapMarked = uint64(float64(gcController.heapMinimum) / (1 + gcController.triggerRatio))
-
-	// Set gcPercent from the environment. This will also compute
-	// and set the GC trigger and goal.
-	_ = setGCPercent(readGOGC())
+	// Initialize GC pacer state.
+	// Use the environment variable GOGC for the initial gcPercent value.
+	gcController.init(readGOGC())
 
 	work.startSema = 1
 	work.markDoneSema = 1
diff --git a/src/runtime/mgcpacer.go b/src/runtime/mgcpacer.go
index e594dbdc06..2366cdb84b 100644
--- a/src/runtime/mgcpacer.go
+++ b/src/runtime/mgcpacer.go
@@ -243,6 +243,21 @@ type gcControllerState struct {
 	_ cpu.CacheLinePad
 }
 
+func (c *gcControllerState) init(gcPercent int32) {
+	c.heapMinimum = defaultHeapMinimum
+
+	// Set a reasonable initial GC trigger.
+	c.triggerRatio = 7 / 8.0
+
+	// Fake a heapMarked value so it looks like a trigger at
+	// heapMinimum is the appropriate growth from heapMarked.
+	// This will go into computing the initial GC goal.
+	c.heapMarked = uint64(float64(c.heapMinimum) / (1 + c.triggerRatio))
+
+	// This will also compute and set the GC trigger and goal.
+	_ = setGCPercent(gcPercent)
+}
+
 // startCycle resets the GC controller's state and computes estimates
 // for a new GC cycle. The caller must hold worldsema and the world
 // must be stopped.
-- 
GitLab


From e7ab1a5ba83cd013af24b011d9d3a88dc5b05c07 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Thu, 1 Apr 2021 18:09:59 +0000
Subject: [PATCH 1545/2400] runtime: create setGCPercent method for
 gcControllerState

This change breaks out the computations done by setGCPercent into
a method on gcControllerState for easier testing later. It leaves behind
the global implementation details.

For #44167.

Change-Id: I3b0cf1475b032fcd4ebbd01cf4e80de0b55ce7b0
Reviewed-on: https://go-review.googlesource.com/c/go/+/306602
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
---
 src/runtime/mgcpacer.go | 30 +++++++++++++++++++++---------
 1 file changed, 21 insertions(+), 9 deletions(-)

diff --git a/src/runtime/mgcpacer.go b/src/runtime/mgcpacer.go
index 2366cdb84b..ea3b39f24d 100644
--- a/src/runtime/mgcpacer.go
+++ b/src/runtime/mgcpacer.go
@@ -255,7 +255,7 @@ func (c *gcControllerState) init(gcPercent int32) {
 	c.heapMarked = uint64(float64(c.heapMinimum) / (1 + c.triggerRatio))
 
 	// This will also compute and set the GC trigger and goal.
-	_ = setGCPercent(gcPercent)
+	c.setGCPercent(gcPercent)
 }
 
 // startCycle resets the GC controller's state and computes estimates
@@ -784,19 +784,31 @@ func gcEffectiveGrowthRatio() float64 {
 	return egogc
 }
 
+// setGCPercent updates gcPercent and all related pacer state.
+// Returns the old value of gcPercent.
+//
+// The world must be stopped, or mheap_.lock must be held.
+func (c *gcControllerState) setGCPercent(in int32) int32 {
+	assertWorldStoppedOrLockHeld(&mheap_.lock)
+
+	out := c.gcPercent
+	if in < 0 {
+		in = -1
+	}
+	c.gcPercent = in
+	c.heapMinimum = defaultHeapMinimum * uint64(c.gcPercent) / 100
+	// Update pacing in response to gcPercent change.
+	c.commit(c.triggerRatio)
+
+	return out
+}
+
 //go:linkname setGCPercent runtime/debug.setGCPercent
 func setGCPercent(in int32) (out int32) {
 	// Run on the system stack since we grab the heap lock.
 	systemstack(func() {
 		lock(&mheap_.lock)
-		out = gcController.gcPercent
-		if in < 0 {
-			in = -1
-		}
-		gcController.gcPercent = in
-		gcController.heapMinimum = defaultHeapMinimum * uint64(gcController.gcPercent) / 100
-		// Update pacing in response to gcPercent change.
-		gcController.commit(gcController.triggerRatio)
+		out = gcController.setGCPercent(in)
 		unlock(&mheap_.lock)
 	})
 
-- 
GitLab


From 6d8ba77896d05720e1cb1728c27db60926e672b5 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Tue, 13 Apr 2021 16:31:56 -0700
Subject: [PATCH 1546/2400] cmd/compile: fix importing of method expressions

For OMETHEXPR, the Name in the Selection needs to be properly
linked up to the method declaration. Use the same code we
already have for ODOTMETH and OCALLPART to do that.

Fixes #45503

Change-Id: I7d6f886d606bae6faad8c104f50c177f871d41c8
Reviewed-on: https://go-review.googlesource.com/c/go/+/309831
Trust: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/typecheck/iexport.go | 11 ++---------
 src/cmd/compile/internal/typecheck/iimport.go | 14 ++++----------
 test/fixedbugs/issue45503.dir/a.go            | 15 +++++++++++++++
 test/fixedbugs/issue45503.dir/b.go            | 12 ++++++++++++
 test/fixedbugs/issue45503.go                  | 10 ++++++++++
 5 files changed, 43 insertions(+), 19 deletions(-)
 create mode 100644 test/fixedbugs/issue45503.dir/a.go
 create mode 100644 test/fixedbugs/issue45503.dir/b.go
 create mode 100644 test/fixedbugs/issue45503.go

diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index 8f8931e495..911d758083 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -1591,17 +1591,10 @@ func (w *exportWriter) expr(n ir.Node) {
 		w.exoticSelector(n.Sel)
 		if go117ExportTypes {
 			w.exoticType(n.Type())
-			if n.Op() == ir.ODOT || n.Op() == ir.ODOTPTR || n.Op() == ir.ODOTINTER || n.Op() == ir.OMETHEXPR {
+			if n.Op() == ir.ODOT || n.Op() == ir.ODOTPTR || n.Op() == ir.ODOTINTER {
 				w.exoticParam(n.Selection)
-				if n.Op() == ir.OMETHEXPR {
-					name := ir.MethodExprName(n)
-					w.bool(name != nil)
-					if name != nil {
-						w.exoticType(name.Type())
-					}
-				}
 			}
-			// n.Selection is not required for ODOTMETH and OCALLPART. It will
+			// n.Selection is not required for OMETHEXPR, ODOTMETH, and OCALLPART. It will
 			// be reconstructed during import.
 		}
 
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 42c4619666..c55e3fbe2a 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -1197,23 +1197,17 @@ func (r *importReader) node() ir.Node {
 		pos := r.pos()
 		expr := r.expr()
 		sel := r.exoticSelector()
-		n := ir.NewSelectorExpr(pos, ir.OXDOT, expr, sel)
-		n.SetOp(op)
+		n := ir.NewSelectorExpr(pos, op, expr, sel)
 		n.SetType(r.exoticType())
 		switch op {
-		case ir.ODOT, ir.ODOTPTR, ir.ODOTINTER, ir.OMETHEXPR:
+		case ir.ODOT, ir.ODOTPTR, ir.ODOTINTER:
 			n.Selection = r.exoticParam()
-			if op == ir.OMETHEXPR {
-				if r.bool() { // has name
-					ir.MethodExprName(n).SetType(r.exoticType())
-				}
-			}
-		case ir.ODOTMETH, ir.OCALLPART:
+		case ir.ODOTMETH, ir.OCALLPART, ir.OMETHEXPR:
 			// These require a Lookup to link to the correct declaration.
 			rcvrType := expr.Type()
 			typ := n.Type()
 			n.Selection = Lookdot(n, rcvrType, 1)
-			if op == ir.OCALLPART {
+			if op == ir.OCALLPART || op == ir.OMETHEXPR {
 				// Lookdot clobbers the opcode and type, undo that.
 				n.SetOp(op)
 				n.SetType(typ)
diff --git a/test/fixedbugs/issue45503.dir/a.go b/test/fixedbugs/issue45503.dir/a.go
new file mode 100644
index 0000000000..b45835bd85
--- /dev/null
+++ b/test/fixedbugs/issue45503.dir/a.go
@@ -0,0 +1,15 @@
+// Copyright 2021 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 a
+
+type S struct{}
+
+func (s *S) M() {
+	s.m((*S).N)
+}
+
+func (s *S) N() {}
+
+func (s *S) m(func(*S)) {}
diff --git a/test/fixedbugs/issue45503.dir/b.go b/test/fixedbugs/issue45503.dir/b.go
new file mode 100644
index 0000000000..df4877a882
--- /dev/null
+++ b/test/fixedbugs/issue45503.dir/b.go
@@ -0,0 +1,12 @@
+// Copyright 2021 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 b
+
+import "a"
+
+func F() {
+	s := a.S{}
+	s.M()
+}
diff --git a/test/fixedbugs/issue45503.go b/test/fixedbugs/issue45503.go
new file mode 100644
index 0000000000..ab3b901145
--- /dev/null
+++ b/test/fixedbugs/issue45503.go
@@ -0,0 +1,10 @@
+// compiledir
+
+// Copyright 2021 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.
+
+// This test exercises exporting + importing method
+// expressions for use when inlining.
+
+package ignored
-- 
GitLab


From 58fdac04e4534e53fd9ca7df0455efb4f1ddb82b Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Tue, 13 Apr 2021 11:01:13 +0200
Subject: [PATCH 1547/2400] syscall: don't defer close raw Socketpair fds in
 tests

The raw fds are successively wrapped using os.NewFile and will be closed
by (*os.File).Close. Avoids a double close, in the worst case closing an
unrelated fd.

Change-Id: I86aabe5ed865eff43d264ddae1fb07c935868e97
Reviewed-on: https://go-review.googlesource.com/c/go/+/309353
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/syscall/creds_test.go        | 9 +++++----
 src/syscall/syscall_unix_test.go | 2 --
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/src/syscall/creds_test.go b/src/syscall/creds_test.go
index 463033d558..736b497bc4 100644
--- a/src/syscall/creds_test.go
+++ b/src/syscall/creds_test.go
@@ -38,16 +38,19 @@ func TestSCMCredentials(t *testing.T) {
 		if err != nil {
 			t.Fatalf("Socketpair: %v", err)
 		}
-		defer syscall.Close(fds[0])
-		defer syscall.Close(fds[1])
 
 		err = syscall.SetsockoptInt(fds[0], syscall.SOL_SOCKET, syscall.SO_PASSCRED, 1)
 		if err != nil {
+			syscall.Close(fds[0])
+			syscall.Close(fds[1])
 			t.Fatalf("SetsockoptInt: %v", err)
 		}
 
 		srvFile := os.NewFile(uintptr(fds[0]), "server")
+		cliFile := os.NewFile(uintptr(fds[1]), "client")
 		defer srvFile.Close()
+		defer cliFile.Close()
+
 		srv, err := net.FileConn(srvFile)
 		if err != nil {
 			t.Errorf("FileConn: %v", err)
@@ -55,8 +58,6 @@ func TestSCMCredentials(t *testing.T) {
 		}
 		defer srv.Close()
 
-		cliFile := os.NewFile(uintptr(fds[1]), "client")
-		defer cliFile.Close()
 		cli, err := net.FileConn(cliFile)
 		if err != nil {
 			t.Errorf("FileConn: %v", err)
diff --git a/src/syscall/syscall_unix_test.go b/src/syscall/syscall_unix_test.go
index ce56c21ff2..af0bc856ee 100644
--- a/src/syscall/syscall_unix_test.go
+++ b/src/syscall/syscall_unix_test.go
@@ -159,8 +159,6 @@ func TestPassFD(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Socketpair: %v", err)
 	}
-	defer syscall.Close(fds[0])
-	defer syscall.Close(fds[1])
 	writeFile := os.NewFile(uintptr(fds[0]), "child-writes")
 	readFile := os.NewFile(uintptr(fds[1]), "parent-reads")
 	defer writeFile.Close()
-- 
GitLab


From ab02cbd29f9b9c76d8f7af0d625ac56fcf8d4e75 Mon Sep 17 00:00:00 2001
From: El Mostafa Idrassi <el.mostafa.idrassi@gmail.com>
Date: Tue, 13 Apr 2021 20:08:46 +0000
Subject: [PATCH 1548/2400] runtime: increase maxargs to avoid syscall18 crash
 when called with more than 16 args

Fixes #45524

Change-Id: Id867f45ea98689b73d5b1b141c19317bc7608b05
GitHub-Last-Rev: e9b09fb557dda291fb6cf27c185063c26832a15b
GitHub-Pull-Request: golang/go#45531
Reviewed-on: https://go-review.googlesource.com/c/go/+/309390
Reviewed-by: El Mostafa Idrassi <el.mostafa.idrassi@gmail.com>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
Trust: Alex Brainman <alex.brainman@gmail.com>
Trust: Alberto Donizetti <alb.donizetti@gmail.com>
Run-TryBot: Alex Brainman <alex.brainman@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/sys_windows_amd64.s     |  2 +-
 src/runtime/syscall_windows_test.go | 45 +++++++++++++++++++++++++++++
 2 files changed, 46 insertions(+), 1 deletion(-)

diff --git a/src/runtime/sys_windows_amd64.s b/src/runtime/sys_windows_amd64.s
index f7250c65a8..6896331329 100644
--- a/src/runtime/sys_windows_amd64.s
+++ b/src/runtime/sys_windows_amd64.s
@@ -8,7 +8,7 @@
 
 // maxargs should be divisible by 2, as Windows stack
 // must be kept 16-byte aligned on syscall entry.
-#define maxargs 16
+#define maxargs 18
 
 // void runtime·asmstdcall(void *c);
 TEXT runtime·asmstdcall<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
diff --git a/src/runtime/syscall_windows_test.go b/src/runtime/syscall_windows_test.go
index 98e426a3d5..5e9694d444 100644
--- a/src/runtime/syscall_windows_test.go
+++ b/src/runtime/syscall_windows_test.go
@@ -744,6 +744,51 @@ uintptr_t cfunc(callback f, uintptr_t n) {
 	}
 }
 
+func TestSyscall18(t *testing.T) {
+	if _, err := exec.LookPath("gcc"); err != nil {
+		t.Skip("skipping test: gcc is missing")
+	}
+	if runtime.GOARCH != "amd64" {
+		t.Skipf("skipping test: GOARCH=%s", runtime.GOARCH)
+	}
+
+	const src = `
+#include <stdint.h>
+#include <windows.h>
+
+int cfunc(	int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9,
+			int a10, int a11, int a12, int a13, int a14, int a15, int a16, int a17, int a18) {
+	return 1;
+}
+`
+	tmpdir := t.TempDir()
+
+	srcname := "mydll.c"
+	err := os.WriteFile(filepath.Join(tmpdir, srcname), []byte(src), 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	outname := "mydll.dll"
+	cmd := exec.Command("gcc", "-shared", "-s", "-Werror", "-o", outname, srcname)
+	cmd.Dir = tmpdir
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("failed to build dll: %v - %v", err, string(out))
+	}
+	dllpath := filepath.Join(tmpdir, outname)
+
+	dll := syscall.MustLoadDLL(dllpath)
+	defer dll.Release()
+
+	proc := dll.MustFindProc("cfunc")
+
+	// proc.Call() will call Syscall18() internally.
+	r, _, err := proc.Call(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18)
+	if r != 1 {
+		t.Errorf("got %d want 1 (err=%v)", r, err)
+	}
+}
+
 func TestFloatArgs(t *testing.T) {
 	if _, err := exec.LookPath("gcc"); err != nil {
 		t.Skip("skipping test: gcc is missing")
-- 
GitLab


From 82e4a6310b78290cb55be6e6e5d0e274aa004faf Mon Sep 17 00:00:00 2001
From: Ruslan Andreev <ruslan.andreev@huawei.com>
Date: Tue, 22 Dec 2020 19:22:14 +0800
Subject: [PATCH 1549/2400] runtime: move roots' bases calculation to
 gcMarkRootPrepare

This patch provides changes according to Austin's TODO. It just moves
calculation of base indexes of each root type from markroot function
to gcMarkRootPrepare.

Change-Id: Ib231de34e7f81e922762fc3ee2b1830921c0c7cf
Reviewed-on: https://go-review.googlesource.com/c/go/+/279461
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Austin Clements <austin@google.com>
---
 src/runtime/mgc.go     |  4 ++++
 src/runtime/mgcmark.go | 37 ++++++++++++++++++-------------------
 2 files changed, 22 insertions(+), 19 deletions(-)

diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index f65402e94c..4750a74bc7 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -328,6 +328,10 @@ var work struct {
 	nFlushCacheRoots                               int
 	nDataRoots, nBSSRoots, nSpanRoots, nStackRoots int
 
+	// Base indexes of each root type. Set by gcMarkRootPrepare.
+	baseFlushCache                                    uint32
+	baseData, baseBSS, baseSpans, baseStacks, baseEnd uint32
+
 	// Each type of GC state transition is protected by a lock.
 	// Since multiple threads can simultaneously detect the state
 	// transition condition, any thread that detects a transition
diff --git a/src/runtime/mgcmark.go b/src/runtime/mgcmark.go
index b3c1e00ca5..45ccc806bd 100644
--- a/src/runtime/mgcmark.go
+++ b/src/runtime/mgcmark.go
@@ -106,6 +106,14 @@ func gcMarkRootPrepare() {
 
 	work.markrootNext = 0
 	work.markrootJobs = uint32(fixedRootCount + work.nFlushCacheRoots + work.nDataRoots + work.nBSSRoots + work.nSpanRoots + work.nStackRoots)
+
+	// Calculate base indexes of each root type
+	work.baseFlushCache = uint32(fixedRootCount)
+	work.baseData = work.baseFlushCache + uint32(work.nFlushCacheRoots)
+	work.baseBSS = work.baseData + uint32(work.nDataRoots)
+	work.baseSpans = work.baseBSS + uint32(work.nBSSRoots)
+	work.baseStacks = work.baseSpans + uint32(work.nSpanRoots)
+	work.baseEnd = work.baseStacks + uint32(work.nStackRoots)
 }
 
 // gcMarkRootCheck checks that all roots have been scanned. It is
@@ -149,28 +157,19 @@ var oneptrmask = [...]uint8{1}
 //
 //go:nowritebarrier
 func markroot(gcw *gcWork, i uint32) {
-	// TODO(austin): This is a bit ridiculous. Compute and store
-	// the bases in gcMarkRootPrepare instead of the counts.
-	baseFlushCache := uint32(fixedRootCount)
-	baseData := baseFlushCache + uint32(work.nFlushCacheRoots)
-	baseBSS := baseData + uint32(work.nDataRoots)
-	baseSpans := baseBSS + uint32(work.nBSSRoots)
-	baseStacks := baseSpans + uint32(work.nSpanRoots)
-	end := baseStacks + uint32(work.nStackRoots)
-
 	// Note: if you add a case here, please also update heapdump.go:dumproots.
 	switch {
-	case baseFlushCache <= i && i < baseData:
-		flushmcache(int(i - baseFlushCache))
+	case work.baseFlushCache <= i && i < work.baseData:
+		flushmcache(int(i - work.baseFlushCache))
 
-	case baseData <= i && i < baseBSS:
+	case work.baseData <= i && i < work.baseBSS:
 		for _, datap := range activeModules() {
-			markrootBlock(datap.data, datap.edata-datap.data, datap.gcdatamask.bytedata, gcw, int(i-baseData))
+			markrootBlock(datap.data, datap.edata-datap.data, datap.gcdatamask.bytedata, gcw, int(i-work.baseData))
 		}
 
-	case baseBSS <= i && i < baseSpans:
+	case work.baseBSS <= i && i < work.baseSpans:
 		for _, datap := range activeModules() {
-			markrootBlock(datap.bss, datap.ebss-datap.bss, datap.gcbssmask.bytedata, gcw, int(i-baseBSS))
+			markrootBlock(datap.bss, datap.ebss-datap.bss, datap.gcbssmask.bytedata, gcw, int(i-work.baseBSS))
 		}
 
 	case i == fixedRootFinalizers:
@@ -184,18 +183,18 @@ func markroot(gcw *gcWork, i uint32) {
 		// stackfree.
 		systemstack(markrootFreeGStacks)
 
-	case baseSpans <= i && i < baseStacks:
+	case work.baseSpans <= i && i < work.baseStacks:
 		// mark mspan.specials
-		markrootSpans(gcw, int(i-baseSpans))
+		markrootSpans(gcw, int(i-work.baseSpans))
 
 	default:
 		// the rest is scanning goroutine stacks
 		var gp *g
-		if baseStacks <= i && i < end {
+		if work.baseStacks <= i && i < work.baseEnd {
 			// N.B. Atomic read of allglen in gcMarkRootPrepare
 			// acts as a barrier to ensure that allgs must be large
 			// enough to contain all relevant Gs.
-			gp = allgs[i-baseStacks]
+			gp = allgs[i-work.baseStacks]
 		} else {
 			throw("markroot: bad index")
 		}
-- 
GitLab


From e224787fef3227587aceddbe21a792e3102d3cfb Mon Sep 17 00:00:00 2001
From: Leonard Wang <wangdeyu0907@gmail.com>
Date: Fri, 9 Apr 2021 23:56:44 +0800
Subject: [PATCH 1550/2400] runtime: fix formatting of gcMark

Change-Id: I08aed75f3aab0da705544665e532f332adfb075e
Reviewed-on: https://go-review.googlesource.com/c/go/+/308949
Reviewed-by: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
Trust: David Chase <drchase@google.com>
---
 src/runtime/mgc.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index 4750a74bc7..e68e9bb75b 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -1357,7 +1357,7 @@ func gcMarkWorkAvailable(p *p) bool {
 // gcMark runs the mark (or, for concurrent GC, mark termination)
 // All gcWork caches must be empty.
 // STW is in effect at this point.
-func gcMark(start_time int64) {
+func gcMark(startTime int64) {
 	if debug.allocfreetrace > 0 {
 		tracegc()
 	}
@@ -1365,7 +1365,7 @@ func gcMark(start_time int64) {
 	if gcphase != _GCmarktermination {
 		throw("in gcMark expecting to see gcphase as _GCmarktermination")
 	}
-	work.tstart = start_time
+	work.tstart = startTime
 
 	// Check that there's no marking work remaining.
 	if work.full != 0 || work.markrootNext < work.markrootJobs {
-- 
GitLab


From 3eaf75c13a2e86ff9f9ab8014caa7fc6b855f130 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Thu, 1 Apr 2021 18:38:14 +0000
Subject: [PATCH 1551/2400] runtime: move next_gc and last_next_gc into
 gcControllerState

This change moves next_gc and last_next_gc into gcControllerState under
the names heapGoal and lastHeapGoal respectively. These are
fundamentally GC pacer related values, and so it makes sense for them to
live here.

Partially generated by

rf '
    ex . {
	memstats.next_gc -> gcController.heapGoal
	memstats.last_next_gc -> gcController.lastHeapGoal
    }
'

except for updates to comments and gcControllerState methods, where
they're accessed through the receiver, and trace-related renames of
NextGC -> HeapGoal, while we're here.

For #44167.

Change-Id: I1e871ad78a57b01be8d9f71bd662530c84853bed
Reviewed-on: https://go-review.googlesource.com/c/go/+/306603
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
---
 src/cmd/trace/trace.go       |  2 +-
 src/internal/trace/parser.go |  6 +++---
 src/runtime/metrics.go       |  2 +-
 src/runtime/mgc.go           | 10 +++++-----
 src/runtime/mgcpacer.go      | 37 ++++++++++++++++++++++++------------
 src/runtime/mgcscavenge.go   |  8 ++++----
 src/runtime/mstats.go        |  9 +--------
 src/runtime/trace.go         | 12 ++++++------
 8 files changed, 46 insertions(+), 40 deletions(-)

diff --git a/src/cmd/trace/trace.go b/src/cmd/trace/trace.go
index 30c80f0e04..ca10736c32 100644
--- a/src/cmd/trace/trace.go
+++ b/src/cmd/trace/trace.go
@@ -627,7 +627,7 @@ func generateTrace(params *traceParams, consumer traceConsumer) error {
 			}
 		case trace.EvHeapAlloc:
 			ctx.heapStats.heapAlloc = ev.Args[0]
-		case trace.EvNextGC:
+		case trace.EvHeapGoal:
 			ctx.heapStats.nextGC = ev.Args[0]
 		}
 		if setGStateErr != nil {
diff --git a/src/internal/trace/parser.go b/src/internal/trace/parser.go
index c371ff3092..254f20137b 100644
--- a/src/internal/trace/parser.go
+++ b/src/internal/trace/parser.go
@@ -1042,8 +1042,8 @@ const (
 	EvGoSysBlock        = 30 // syscall blocks [timestamp]
 	EvGoWaiting         = 31 // denotes that goroutine is blocked when tracing starts [timestamp, goroutine id]
 	EvGoInSyscall       = 32 // denotes that goroutine is in syscall when tracing starts [timestamp, goroutine id]
-	EvHeapAlloc         = 33 // memstats.heap_live change [timestamp, heap_alloc]
-	EvNextGC            = 34 // memstats.next_gc change [timestamp, next_gc]
+	EvHeapAlloc         = 33 // gcController.heapLive change [timestamp, heap live bytes]
+	EvHeapGoal          = 34 // gcController.heapGoal change [timestamp, heap goal bytes]
 	EvTimerGoroutine    = 35 // denotes timer goroutine [timer goroutine id]
 	EvFutileWakeup      = 36 // denotes that the previous wakeup of this goroutine was futile [timestamp]
 	EvString            = 37 // string dictionary entry [ID, length, string]
@@ -1102,7 +1102,7 @@ var EventDescriptions = [EvCount]struct {
 	EvGoWaiting:         {"GoWaiting", 1005, false, []string{"g"}, nil},
 	EvGoInSyscall:       {"GoInSyscall", 1005, false, []string{"g"}, nil},
 	EvHeapAlloc:         {"HeapAlloc", 1005, false, []string{"mem"}, nil},
-	EvNextGC:            {"NextGC", 1005, false, []string{"mem"}, nil},
+	EvHeapGoal:          {"HeapGoal", 1005, false, []string{"mem"}, nil},
 	EvTimerGoroutine:    {"TimerGoroutine", 1005, false, []string{"g"}, nil}, // in 1.5 format it was {"g", "unused"}
 	EvFutileWakeup:      {"FutileWakeup", 1005, false, []string{}, nil},
 	EvString:            {"String", 1007, false, []string{}, nil},
diff --git a/src/runtime/metrics.go b/src/runtime/metrics.go
index ce3bac9d8f..e4343f9148 100644
--- a/src/runtime/metrics.go
+++ b/src/runtime/metrics.go
@@ -364,7 +364,7 @@ func (a *sysStatsAggregate) compute() {
 	a.buckHashSys = memstats.buckhash_sys.load()
 	a.gcMiscSys = memstats.gcMiscSys.load()
 	a.otherSys = memstats.other_sys.load()
-	a.heapGoal = atomic.Load64(&memstats.next_gc)
+	a.heapGoal = atomic.Load64(&gcController.heapGoal)
 	a.gcCyclesDone = uint64(memstats.numgc)
 	a.gcCyclesForced = uint64(memstats.numforcedgc)
 
diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index e68e9bb75b..bb98cf29bc 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -113,8 +113,8 @@
 // Next GC is after we've allocated an extra amount of memory proportional to
 // the amount already in use. The proportion is controlled by GOGC environment variable
 // (100 by default). If GOGC=100 and we're using 4M, we'll GC again when we get to 8M
-// (this mark is tracked in next_gc variable). This keeps the GC cost in linear
-// proportion to the allocation cost. Adjusting GOGC just changes the linear constant
+// (this mark is tracked in gcController.heapGoal variable). This keeps the GC cost in
+// linear proportion to the allocation cost. Adjusting GOGC just changes the linear constant
 // (and also the amount of extra memory used).
 
 // Oblets
@@ -669,7 +669,7 @@ func gcStart(trigger gcTrigger) {
 	work.cycles++
 
 	gcController.startCycle()
-	work.heapGoal = memstats.next_gc
+	work.heapGoal = gcController.heapGoal
 
 	// In STW mode, disable scheduling of user Gs. This may also
 	// disable scheduling of this goroutine, so it may block as
@@ -972,8 +972,8 @@ func gcMarkTermination(nextTriggerRatio float64) {
 		throw("gc done but gcphase != _GCoff")
 	}
 
-	// Record next_gc and heap_inuse for scavenger.
-	memstats.last_next_gc = memstats.next_gc
+	// Record heapGoal and heap_inuse for scavenger.
+	gcController.lastHeapGoal = gcController.heapGoal
 	memstats.last_heap_inuse = memstats.heap_inuse
 
 	// Update GC trigger and pacing for the next cycle.
diff --git a/src/runtime/mgcpacer.go b/src/runtime/mgcpacer.go
index ea3b39f24d..ba16c59052 100644
--- a/src/runtime/mgcpacer.go
+++ b/src/runtime/mgcpacer.go
@@ -114,6 +114,19 @@ type gcControllerState struct {
 	// Protected by mheap_.lock or a STW.
 	trigger uint64
 
+	// heapGoal is the goal heapLive for when next GC ends.
+	// Set to ^uint64(0) if disabled.
+	//
+	// Read and written atomically, unless the world is stopped.
+	heapGoal uint64
+
+	// lastHeapGoal is the value of heapGoal for the previous GC.
+	// Note that this is distinct from the last value heapGoal had,
+	// because it could change if e.g. gcPercent changes.
+	//
+	// Read and written with the world stopped or with mheap_.lock held.
+	lastHeapGoal uint64
+
 	// heapLive is the number of bytes considered live by the GC.
 	// That is: retained by the most recent GC plus allocated
 	// since then. heapLive ≤ memstats.heapAlloc, since heapAlloc includes
@@ -276,8 +289,8 @@ func (c *gcControllerState) startCycle() {
 	// GOGC. Assist is proportional to this distance, so enforce a
 	// minimum distance, even if it means going over the GOGC goal
 	// by a tiny bit.
-	if memstats.next_gc < c.heapLive+1024*1024 {
-		memstats.next_gc = c.heapLive + 1024*1024
+	if c.heapGoal < c.heapLive+1024*1024 {
+		c.heapGoal = c.heapLive + 1024*1024
 	}
 
 	// Compute the background mark utilization goal. In general,
@@ -324,7 +337,7 @@ func (c *gcControllerState) startCycle() {
 		print("pacer: assist ratio=", assistRatio,
 			" (scan ", gcController.heapScan>>20, " MB in ",
 			work.initialHeapLive>>20, "->",
-			memstats.next_gc>>20, " MB)",
+			c.heapGoal>>20, " MB)",
 			" workers=", c.dedicatedMarkWorkersNeeded,
 			"+", c.fractionalUtilizationGoal, "\n")
 	}
@@ -332,7 +345,7 @@ func (c *gcControllerState) startCycle() {
 
 // revise updates the assist ratio during the GC cycle to account for
 // improved estimates. This should be called whenever gcController.heapScan,
-// gcController.heapLive, or memstats.next_gc is updated. It is safe to
+// gcController.heapLive, or gcController.heapGoal is updated. It is safe to
 // call concurrently, but it may race with other calls to revise.
 //
 // The result of this race is that the two assist ratio values may not line
@@ -363,8 +376,8 @@ func (c *gcControllerState) revise() {
 	work := atomic.Loadint64(&c.scanWork)
 
 	// Assume we're under the soft goal. Pace GC to complete at
-	// next_gc assuming the heap is in steady-state.
-	heapGoal := int64(atomic.Load64(&memstats.next_gc))
+	// heapGoal assuming the heap is in steady-state.
+	heapGoal := int64(atomic.Load64(&c.heapGoal))
 
 	// Compute the expected scan work remaining.
 	//
@@ -417,7 +430,7 @@ func (c *gcControllerState) revise() {
 	}
 
 	// Compute the mutator assist ratio so by the time the mutator
-	// allocates the remaining heap bytes up to next_gc, it will
+	// allocates the remaining heap bytes up to heapGoal, it will
 	// have done (or stolen) the remaining amount of scan work.
 	// Note that the assist ratio values are updated atomically
 	// but not together. This means there may be some degree of
@@ -704,7 +717,7 @@ func (c *gcControllerState) commit(triggerRatio float64) {
 			trigger = minTrigger
 		}
 		if int64(trigger) < 0 {
-			print("runtime: next_gc=", memstats.next_gc, " heapMarked=", c.heapMarked, " gcController.heapLive=", c.heapLive, " initialHeapLive=", work.initialHeapLive, "triggerRatio=", triggerRatio, " minTrigger=", minTrigger, "\n")
+			print("runtime: heapGoal=", c.heapGoal, " heapMarked=", c.heapMarked, " gcController.heapLive=", c.heapLive, " initialHeapLive=", work.initialHeapLive, "triggerRatio=", triggerRatio, " minTrigger=", minTrigger, "\n")
 			throw("trigger underflow")
 		}
 		if trigger > goal {
@@ -717,9 +730,9 @@ func (c *gcControllerState) commit(triggerRatio float64) {
 
 	// Commit to the trigger and goal.
 	c.trigger = trigger
-	atomic.Store64(&memstats.next_gc, goal)
+	atomic.Store64(&c.heapGoal, goal)
 	if trace.enabled {
-		traceNextGC()
+		traceHeapGoal()
 	}
 
 	// Update mark pacing.
@@ -766,7 +779,7 @@ func (c *gcControllerState) commit(triggerRatio float64) {
 
 // gcEffectiveGrowthRatio returns the current effective heap growth
 // ratio (GOGC/100) based on heapMarked from the previous GC and
-// next_gc for the current GC.
+// heapGoal for the current GC.
 //
 // This may differ from gcPercent/100 because of various upper and
 // lower bounds on gcPercent. For example, if the heap is smaller than
@@ -776,7 +789,7 @@ func (c *gcControllerState) commit(triggerRatio float64) {
 func gcEffectiveGrowthRatio() float64 {
 	assertWorldStoppedOrLockHeld(&mheap_.lock)
 
-	egogc := float64(atomic.Load64(&memstats.next_gc)-gcController.heapMarked) / float64(gcController.heapMarked)
+	egogc := float64(atomic.Load64(&gcController.heapGoal)-gcController.heapMarked) / float64(gcController.heapMarked)
 	if egogc < 0 {
 		// Shouldn't happen, but just in case.
 		egogc = 0
diff --git a/src/runtime/mgcscavenge.go b/src/runtime/mgcscavenge.go
index 6632bed2b3..7e32348670 100644
--- a/src/runtime/mgcscavenge.go
+++ b/src/runtime/mgcscavenge.go
@@ -18,12 +18,12 @@
 // application down to a goal.
 //
 // That goal is defined as:
-//   (retainExtraPercent+100) / 100 * (next_gc / last_next_gc) * last_heap_inuse
+//   (retainExtraPercent+100) / 100 * (heapGoal / lastHeapGoal) * last_heap_inuse
 //
 // Essentially, we wish to have the application's RSS track the heap goal, but
 // the heap goal is defined in terms of bytes of objects, rather than pages like
 // RSS. As a result, we need to take into account for fragmentation internal to
-// spans. next_gc / last_next_gc defines the ratio between the current heap goal
+// spans. heapGoal / lastHeapGoal defines the ratio between the current heap goal
 // and the last heap goal, which tells us by how much the heap is growing and
 // shrinking. We estimate what the heap will grow to in terms of pages by taking
 // this ratio and multiplying it by heap_inuse at the end of the last GC, which
@@ -118,12 +118,12 @@ func gcPaceScavenger() {
 	// We never scavenge before the 2nd GC cycle anyway (we don't have enough
 	// information about the heap yet) so this is fine, and avoids a fault
 	// or garbage data later.
-	if memstats.last_next_gc == 0 {
+	if gcController.lastHeapGoal == 0 {
 		mheap_.scavengeGoal = ^uint64(0)
 		return
 	}
 	// Compute our scavenging goal.
-	goalRatio := float64(atomic.Load64(&memstats.next_gc)) / float64(memstats.last_next_gc)
+	goalRatio := float64(atomic.Load64(&gcController.heapGoal)) / float64(gcController.lastHeapGoal)
 	retainedGoal := uint64(float64(memstats.last_heap_inuse) * goalRatio)
 	// Add retainExtraPercent overhead to retainedGoal. This calculation
 	// looks strange but the purpose is to arrive at an integer division
diff --git a/src/runtime/mstats.go b/src/runtime/mstats.go
index cd9359bc91..c68cb2fcc3 100644
--- a/src/runtime/mstats.go
+++ b/src/runtime/mstats.go
@@ -62,12 +62,6 @@ type mstats struct {
 
 	// Statistics about the garbage collector.
 
-	// next_gc is the goal gcController.heapLive for when next GC ends.
-	// Set to ^uint64(0) if disabled.
-	//
-	// Read and written atomically, unless the world is stopped.
-	next_gc uint64
-
 	// Protected by mheap or stopping the world during GC.
 	last_gc_unix    uint64 // last gc (in unix time)
 	pause_total_ns  uint64
@@ -93,7 +87,6 @@ type mstats struct {
 
 	last_gc_nanotime uint64 // last gc (monotonic time)
 	tinyallocs       uint64 // number of tiny allocations that didn't cause actual allocation; not exported to go directly
-	last_next_gc     uint64 // next_gc for the previous GC
 	last_heap_inuse  uint64 // heap_inuse at mark termination of the previous GC
 
 	// heapStats is a set of statistics
@@ -460,7 +453,7 @@ func readmemstats_m(stats *MemStats) {
 	// at a more granular level in the runtime.
 	stats.GCSys = memstats.gcMiscSys.load() + memstats.gcWorkBufInUse + memstats.gcProgPtrScalarBitsInUse
 	stats.OtherSys = memstats.other_sys.load()
-	stats.NextGC = memstats.next_gc
+	stats.NextGC = gcController.heapGoal
 	stats.LastGC = memstats.last_gc_unix
 	stats.PauseTotalNs = memstats.pause_total_ns
 	stats.PauseNs = memstats.pause_ns
diff --git a/src/runtime/trace.go b/src/runtime/trace.go
index ba8fbda028..1530178c85 100644
--- a/src/runtime/trace.go
+++ b/src/runtime/trace.go
@@ -53,8 +53,8 @@ const (
 	traceEvGoSysBlock        = 30 // syscall blocks [timestamp]
 	traceEvGoWaiting         = 31 // denotes that goroutine is blocked when tracing starts [timestamp, goroutine id]
 	traceEvGoInSyscall       = 32 // denotes that goroutine is in syscall when tracing starts [timestamp, goroutine id]
-	traceEvHeapAlloc         = 33 // memstats.heap_live change [timestamp, heap_alloc]
-	traceEvNextGC            = 34 // memstats.next_gc change [timestamp, next_gc]
+	traceEvHeapAlloc         = 33 // gcController.heapLive change [timestamp, heap_alloc]
+	traceEvHeapGoal          = 34 // gcController.heapGoal (formerly next_gc) change [timestamp, heap goal in bytes]
 	traceEvTimerGoroutine    = 35 // not currently used; previously denoted timer goroutine [timer goroutine id]
 	traceEvFutileWakeup      = 36 // denotes that the previous wakeup of this goroutine was futile [timestamp]
 	traceEvString            = 37 // string dictionary entry [ID, length, string]
@@ -1147,12 +1147,12 @@ func traceHeapAlloc() {
 	traceEvent(traceEvHeapAlloc, -1, gcController.heapLive)
 }
 
-func traceNextGC() {
-	if nextGC := atomic.Load64(&memstats.next_gc); nextGC == ^uint64(0) {
+func traceHeapGoal() {
+	if heapGoal := atomic.Load64(&gcController.heapGoal); heapGoal == ^uint64(0) {
 		// Heap-based triggering is disabled.
-		traceEvent(traceEvNextGC, -1, 0)
+		traceEvent(traceEvHeapGoal, -1, 0)
 	} else {
-		traceEvent(traceEvNextGC, -1, nextGC)
+		traceEvent(traceEvHeapGoal, -1, heapGoal)
 	}
 }
 
-- 
GitLab


From e9cc31e736a6a1931ab010a2fda0e5d0ac4e5127 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Thu, 1 Apr 2021 19:09:40 +0000
Subject: [PATCH 1552/2400] runtime: pass work.userForced to
 gcController.endCycle explicitly

For #44167.

Change-Id: I15817006f1870d6237cd06dabad988da3f23a6d6
Reviewed-on: https://go-review.googlesource.com/c/go/+/306604
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
---
 src/runtime/mgc.go      | 2 +-
 src/runtime/mgcpacer.go | 6 ++++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index bb98cf29bc..e4bbf1f016 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -898,7 +898,7 @@ top:
 	// endCycle depends on all gcWork cache stats being flushed.
 	// The termination algorithm above ensured that up to
 	// allocations since the ragged barrier.
-	nextTriggerRatio := gcController.endCycle()
+	nextTriggerRatio := gcController.endCycle(work.userForced)
 
 	// Perform mark termination. This will restart the world.
 	gcMarkTermination(nextTriggerRatio)
diff --git a/src/runtime/mgcpacer.go b/src/runtime/mgcpacer.go
index ba16c59052..6bf3e3f278 100644
--- a/src/runtime/mgcpacer.go
+++ b/src/runtime/mgcpacer.go
@@ -444,8 +444,10 @@ func (c *gcControllerState) revise() {
 }
 
 // endCycle computes the trigger ratio for the next cycle.
-func (c *gcControllerState) endCycle() float64 {
-	if work.userForced {
+// userForced indicates whether the current GC cycle was forced
+// by the application.
+func (c *gcControllerState) endCycle(userForced bool) float64 {
+	if userForced {
 		// Forced GC means this cycle didn't start at the
 		// trigger, so where it finished isn't good
 		// information about how to adjust the trigger.
-- 
GitLab


From 7ec7a3cf33930e346e5f53fd41d2601b7c520056 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Thu, 1 Apr 2021 19:12:02 +0000
Subject: [PATCH 1553/2400] runtime: make gcEffectiveGrowthRatio a method on
 gcControllerState

For #44167.

Change-Id: Ie3cf8d2960c843a782ec85426fa73c279adaed64
Reviewed-on: https://go-review.googlesource.com/c/go/+/306605
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
---
 src/runtime/mgcpacer.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/runtime/mgcpacer.go b/src/runtime/mgcpacer.go
index 6bf3e3f278..9338359de7 100644
--- a/src/runtime/mgcpacer.go
+++ b/src/runtime/mgcpacer.go
@@ -471,7 +471,7 @@ func (c *gcControllerState) endCycle(userForced bool) float64 {
 	// growth if we had the desired CPU utilization). The
 	// difference between this estimate and the GOGC-based goal
 	// heap growth is the error.
-	goalGrowthRatio := gcEffectiveGrowthRatio()
+	goalGrowthRatio := c.effectiveGrowthRatio()
 	actualGrowthRatio := float64(c.heapLive)/float64(c.heapMarked) - 1
 	assistDuration := nanotime() - c.markStartTime
 
@@ -779,7 +779,7 @@ func (c *gcControllerState) commit(triggerRatio float64) {
 	gcPaceScavenger()
 }
 
-// gcEffectiveGrowthRatio returns the current effective heap growth
+// effectiveGrowthRatio returns the current effective heap growth
 // ratio (GOGC/100) based on heapMarked from the previous GC and
 // heapGoal for the current GC.
 //
@@ -788,10 +788,10 @@ func (c *gcControllerState) commit(triggerRatio float64) {
 // heapMinimum, this can be higher than gcPercent/100.
 //
 // mheap_.lock must be held or the world must be stopped.
-func gcEffectiveGrowthRatio() float64 {
+func (c *gcControllerState) effectiveGrowthRatio() float64 {
 	assertWorldStoppedOrLockHeld(&mheap_.lock)
 
-	egogc := float64(atomic.Load64(&gcController.heapGoal)-gcController.heapMarked) / float64(gcController.heapMarked)
+	egogc := float64(atomic.Load64(&c.heapGoal)-c.heapMarked) / float64(c.heapMarked)
 	if egogc < 0 {
 		// Shouldn't happen, but just in case.
 		egogc = 0
-- 
GitLab


From 72483de87a36969f0c4d6f01db19f769c8e16e82 Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Mon, 15 Mar 2021 16:15:23 -0700
Subject: [PATCH 1554/2400] runtime: incorporate hbits advancement in
 scanobject into loop

This makes it clearer that i and hbits advance together.
As a bonus, it generates slightly better code.

Change-Id: I24d51102535c39f962a59c1a4a7c5c894339aa18
Reviewed-on: https://go-review.googlesource.com/c/go/+/309569
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Austin Clements <austin@google.com>
---
 src/runtime/mgcmark.go | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/src/runtime/mgcmark.go b/src/runtime/mgcmark.go
index 45ccc806bd..cb73caf3bb 100644
--- a/src/runtime/mgcmark.go
+++ b/src/runtime/mgcmark.go
@@ -1257,12 +1257,7 @@ func scanobject(b uintptr, gcw *gcWork) {
 	}
 
 	var i uintptr
-	for i = 0; i < n; i += sys.PtrSize {
-		// Find bits for this word.
-		if i != 0 {
-			// Avoid needless hbits.next() on last iteration.
-			hbits = hbits.next()
-		}
+	for i = 0; i < n; i, hbits = i+sys.PtrSize, hbits.next() {
 		// Load bits once. See CL 22712 and issue 16973 for discussion.
 		bits := hbits.bits()
 		if bits&bitScan == 0 {
-- 
GitLab


From c98026c104dece6cf9aa6cf3f651dd16a0156cf2 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Wed, 14 Apr 2021 10:16:51 -0400
Subject: [PATCH 1555/2400] cmd/go/internal/modload: fix truncated error
 message from goModDirtyError

The 'go mod tidy' hint was truncated due to a typo in CL 293689,
and that particular case was not covered by any existing test.

Updates #36460
Updates #40775

Change-Id: Ib6fa872a9dfdafc4e9a112e8add2ff5aecd2dbd0
Reviewed-on: https://go-review.googlesource.com/c/go/+/310089
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Reviewed-by: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/internal/modload/init.go               |  2 +-
 .../go/testdata/script/mod_require_exclude.txt    | 15 +++++++++++++++
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index 777b63841f..120afef4ff 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -354,7 +354,7 @@ func (goModDirtyError) Error() string {
 		return fmt.Sprintf("updates to go.mod needed, disabled by -mod=%v; to update it:\n\tgo mod tidy", cfg.BuildMod)
 	}
 	if cfg.BuildModReason != "" {
-		return fmt.Sprintf("updates to go.mod needed, disabled by -mod=%s\n\t(%s)\n\tto update it:\n\t", cfg.BuildMod, cfg.BuildModReason)
+		return fmt.Sprintf("updates to go.mod needed, disabled by -mod=%s\n\t(%s)\n\tto update it:\n\tgo mod tidy", cfg.BuildMod, cfg.BuildModReason)
 	}
 	return "updates to go.mod needed; to update it:\n\tgo mod tidy"
 }
diff --git a/src/cmd/go/testdata/script/mod_require_exclude.txt b/src/cmd/go/testdata/script/mod_require_exclude.txt
index 5b6143da42..0946dbf0bb 100644
--- a/src/cmd/go/testdata/script/mod_require_exclude.txt
+++ b/src/cmd/go/testdata/script/mod_require_exclude.txt
@@ -17,6 +17,17 @@ stderr '^go: updates to go.mod needed, disabled by -mod=vendor; to update it:\n\
 ! stdout '^rsc.io/sampler v1.99.99'
 cmp go.mod go.mod.orig
 
+# The failure message should be clear when -mod=vendor is implicit.
+
+go mod edit -go=1.14
+! go list -m rsc.io/sampler
+stderr '^go: ignoring requirement on excluded version rsc.io/sampler v1\.99\.99$'
+stderr '^go: updates to go.mod needed, disabled by -mod=vendor\n\t\(Go version in go.mod is at least 1.14 and vendor directory exists\.\)\n\tto update it:\n\tgo mod tidy$'
+! stdout '^rsc.io/sampler v1.99.99'
+go mod edit -go=1.13
+cmp go.mod go.mod.orig
+
+
 # With the selected version excluded, commands that load only modules should
 # drop the excluded module.
 
@@ -58,7 +69,11 @@ module x
 go 1.13
 
 exclude rsc.io/sampler v1.99.99
+
 require rsc.io/sampler v1.99.99
+-- vendor/modules.txt --
+# rsc.io/sampler v1.99.99
+## explicit
 -- go.moddrop --
 module x
 
-- 
GitLab


From ad44dfb0fda522df08e133d1f909bfe535c4b4be Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Wed, 14 Apr 2021 11:33:46 -0400
Subject: [PATCH 1556/2400] cmd/go: clarify comment on HashSeed

Change-Id: I3c8769f52b86ca82611af373b0a493a937dda9d5
Reviewed-on: https://go-review.googlesource.com/c/go/+/310090
Trust: Austin Clements <austin@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go/internal/cache/hash.go | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/cmd/go/internal/cache/hash.go b/src/cmd/go/internal/cache/hash.go
index f16215428a..4f79c31500 100644
--- a/src/cmd/go/internal/cache/hash.go
+++ b/src/cmd/go/internal/cache/hash.go
@@ -40,8 +40,9 @@ type Hash struct {
 //
 // We strip any GOEXPERIMENTs the go tool was built with from this
 // version string on the assumption that they shouldn't affect go tool
-// execution. This also allows bootstrapping to converge faster
-// because dist builds go_bootstrap without any experiments.
+// execution. This allows bootstrapping to converge faster: dist builds
+// go_bootstrap without any experiments, so by stripping experiments
+// go_bootstrap and the final go binary will use the same salt.
 var hashSalt = []byte(stripExperiment(runtime.Version()))
 
 // stripExperiment strips any GOEXPERIMENT configuration from the Go
-- 
GitLab


From ef36e4fd0eec3283a43d03bc6bff7da4e5e03c06 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 13 Apr 2021 23:41:45 -0400
Subject: [PATCH 1557/2400] reflect: keep pointer register results alive in
 callMethod

When callMethod calls the underlying method, after reflectcall
it gets the result registers in "Ints" slots but not in "Ptrs"
slots. If the GC runs at this point, it may lose track of those
pointers and free the memory they point to.

To make sure the GC sees the pointer results, copy "Ints" to
"Ptrs", and keep them alive until we return to the caller.

This fixes test/fixedbugs/issue27695.go with register ABI.

Change-Id: I4092c91bcbd6954683740a12d91d689900446875
Reviewed-on: https://go-review.googlesource.com/c/go/+/309909
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/reflect/abi.go   | 16 ++++++++++++++++
 src/reflect/value.go |  8 ++++++++
 2 files changed, 24 insertions(+)

diff --git a/src/reflect/abi.go b/src/reflect/abi.go
index caa770fcb0..17b79a8394 100644
--- a/src/reflect/abi.go
+++ b/src/reflect/abi.go
@@ -366,6 +366,22 @@ func (a *abiDesc) dump() {
 	println("stackCallArgsSize", a.stackCallArgsSize)
 	println("retOffset", a.retOffset)
 	println("spill", a.spill)
+	print("inRegPtrs:")
+	dumpPtrBitMap(a.inRegPtrs)
+	println()
+	print("outRegPtrs:")
+	dumpPtrBitMap(a.outRegPtrs)
+	println()
+}
+
+func dumpPtrBitMap(b abi.IntArgRegBitmap) {
+	for i := 0; i < intArgRegs; i++ {
+		x := 0
+		if b.Get(i) {
+			x = 1
+		}
+		print(" ", x)
+	}
 }
 
 func newAbiDesc(t *funcType, rcvr *rtype) abiDesc {
diff --git a/src/reflect/value.go b/src/reflect/value.go
index 7890c125d8..6f1a3c02d6 100644
--- a/src/reflect/value.go
+++ b/src/reflect/value.go
@@ -1023,6 +1023,9 @@ func callMethod(ctxt *methodValue, frame unsafe.Pointer, retValid *bool, regs *a
 	methodFrameSize = align(methodFrameSize, ptrSize)
 	methodFrameSize += methodABI.spill
 
+	// Mark pointers in registers for the return path.
+	methodRegs.ReturnIsPtr = methodABI.outRegPtrs
+
 	// Call.
 	// Call copies the arguments from scratch to the stack, calls fn,
 	// and then copies the results back into scratch.
@@ -1059,6 +1062,11 @@ func callMethod(ctxt *methodValue, frame unsafe.Pointer, retValid *bool, regs *a
 
 	// See the comment in callReflect.
 	runtime.KeepAlive(ctxt)
+
+	// Keep valueRegs alive because it may hold live pointer results.
+	// The caller (methodValueCall) has it as a stack object, which is only
+	// scanned when there is a reference to it.
+	runtime.KeepAlive(valueRegs)
 }
 
 // funcName returns the name of f, for use in error messages.
-- 
GitLab


From 25b25a9ed7fe8a543fd6c1f79c6a43d33f8eae68 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Tue, 13 Apr 2021 13:46:52 -0400
Subject: [PATCH 1558/2400] cmd/asm: require NOSPLIT for ABIInternal asm
 functions

Change the assembler to enforce the requirement that ABIInternal
functions need to be NOSPLIT. At the moment all of the assembly
routines in the runtime that are defined as ABIInternal also
happen to be NOSPLIT, but this CL makes it mandatory.

Updates #40724.

Change-Id: Ief80d22de1782edb44b798fcde9aab8a93548722
Reviewed-on: https://go-review.googlesource.com/c/go/+/309789
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Austin Clements <austin@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/asm/internal/asm/asm.go         |  8 +++++
 src/cmd/asm/internal/asm/pseudo_test.go | 47 ++++++++++++++++++-------
 2 files changed, 43 insertions(+), 12 deletions(-)

diff --git a/src/cmd/asm/internal/asm/asm.go b/src/cmd/asm/internal/asm/asm.go
index 340f188924..cf0d1550f9 100644
--- a/src/cmd/asm/internal/asm/asm.go
+++ b/src/cmd/asm/internal/asm/asm.go
@@ -134,6 +134,14 @@ func (p *Parser) asmText(operands [][]lex.Token) {
 		next++
 	}
 
+	// Issue an error if we see a function defined as ABIInternal
+	// without NOSPLIT. In ABIInternal, obj needs to know the function
+	// signature in order to construct the morestack path, so this
+	// currently isn't supported for asm functions.
+	if nameAddr.Sym.ABI() == obj.ABIInternal && flag&obj.NOSPLIT == 0 {
+		p.errorf("TEXT %q: ABIInternal requires NOSPLIT", name)
+	}
+
 	// Next operand is the frame and arg size.
 	// Bizarre syntax: $frameSize-argSize is two words, not subtraction.
 	// Both frameSize and argSize must be simple integers; only frameSize
diff --git a/src/cmd/asm/internal/asm/pseudo_test.go b/src/cmd/asm/internal/asm/pseudo_test.go
index 622ee25ce7..fe6ffa6074 100644
--- a/src/cmd/asm/internal/asm/pseudo_test.go
+++ b/src/cmd/asm/internal/asm/pseudo_test.go
@@ -25,11 +25,13 @@ func tokenize(s string) [][]lex.Token {
 
 func TestErroneous(t *testing.T) {
 
-	tests := []struct {
+	type errtest struct {
 		pseudo   string
 		operands string
 		expected string
-	}{
+	}
+
+	nonRuntimeTests := []errtest{
 		{"TEXT", "", "expect two or three operands for TEXT"},
 		{"TEXT", "%", "expect two or three operands for TEXT"},
 		{"TEXT", "1, 1", "TEXT symbol \"<erroneous symbol>\" must be a symbol(SB)"},
@@ -58,23 +60,44 @@ func TestErroneous(t *testing.T) {
 		{"PCDATA", "1", "expect two operands for PCDATA"},
 	}
 
+	runtimeTests := []errtest{
+		{"TEXT", "foo<ABIInternal>(SB),0", "TEXT \"foo\": ABIInternal requires NOSPLIT"},
+	}
+
+	testcats := []struct {
+		compilingRuntime bool
+		tests            []errtest
+	}{
+		{
+			compilingRuntime: false,
+			tests:            nonRuntimeTests,
+		},
+		{
+			compilingRuntime: true,
+			tests:            runtimeTests,
+		},
+	}
+
 	// Note these errors should be independent of the architecture.
 	// Just run the test with amd64.
 	parser := newParser("amd64")
 	var buf bytes.Buffer
 	parser.errorWriter = &buf
 
-	for _, test := range tests {
-		parser.errorCount = 0
-		parser.lineNum++
-		if !parser.pseudo(test.pseudo, tokenize(test.operands)) {
-			t.Fatalf("Wrong pseudo-instruction: %s", test.pseudo)
-		}
-		errorLine := buf.String()
-		if test.expected != errorLine {
-			t.Errorf("Unexpected error %q; expected %q", errorLine, test.expected)
+	for _, cat := range testcats {
+		for _, test := range cat.tests {
+			parser.compilingRuntime = cat.compilingRuntime
+			parser.errorCount = 0
+			parser.lineNum++
+			if !parser.pseudo(test.pseudo, tokenize(test.operands)) {
+				t.Fatalf("Wrong pseudo-instruction: %s", test.pseudo)
+			}
+			errorLine := buf.String()
+			if test.expected != errorLine {
+				t.Errorf("Unexpected error %q; expected %q", errorLine, test.expected)
+			}
+			buf.Reset()
 		}
-		buf.Reset()
 	}
 
 }
-- 
GitLab


From 4480c822ba37ea3795fa4dbb56d13578d7961d88 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Tue, 13 Apr 2021 13:49:55 -0400
Subject: [PATCH 1559/2400] cmd/internal/obj: don't emit args_stackmap for
 ABIInternal asm funcs

The compiler currently emits an "*.args_stackmap" symbol for all
bodyless functions, so that asm functions will have the proper stack
map. At the moment the code in the compiler that emits args_stackmap
assumes ABI0; to avoid misleading stackmaps, turn off args_stackmap
generation for non-ABI0 asm functions.

Updates #40724.

Change-Id: Ia5e3528d56da5fb107e799bd658e52496ba4a331
Reviewed-on: https://go-review.googlesource.com/c/go/+/309790
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Austin Clements <austin@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/internal/obj/plist.go | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/cmd/internal/obj/plist.go b/src/cmd/internal/obj/plist.go
index 9dbad20589..54b035bb96 100644
--- a/src/cmd/internal/obj/plist.go
+++ b/src/cmd/internal/obj/plist.go
@@ -85,6 +85,13 @@ func Flushplist(ctxt *Link, plist *Plist, newprog ProgAlloc, myimportpath string
 			// wrapper function
 			continue
 		}
+		// The current args_stackmap generation in the compiler assumes
+		// that the function in question is ABI0, so avoid introducing
+		// an args_stackmap reference if the func is not ABI0 (better to
+		// have no stackmap than an incorrect/lying stackmap).
+		if s.ABI() != ABI0 {
+			continue
+		}
 		found := false
 		for p := s.Func().Text; p != nil; p = p.Link {
 			if p.As == AFUNCDATA && p.From.Type == TYPE_CONST && p.From.Offset == objabi.FUNCDATA_ArgsPointerMaps {
@@ -92,7 +99,6 @@ func Flushplist(ctxt *Link, plist *Plist, newprog ProgAlloc, myimportpath string
 				break
 			}
 		}
-
 		if !found {
 			p := Appendp(s.Func().Text, newprog)
 			p.As = AFUNCDATA
-- 
GitLab


From 4df3d0e4df734283911cf3c428d9638c9dc5af4e Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Mon, 12 Apr 2021 20:53:03 -0400
Subject: [PATCH 1560/2400] cmd/compile: rescue stmt boundaries from
 OpArgXXXReg and OpSelectN.

Fixes this failure:
go test cmd/compile/internal/ssa -run TestStmtLines -v
=== RUN   TestStmtLines
    stmtlines_test.go:115: Saw too many (amd64, > 1%) lines without
    statement marks, total=88263, nostmt=1930
    ('-run TestStmtLines -v' lists failing lines)

The failure has two causes.

One is that the first-line adjuster in code generation was relocating
"first lines" to instructions that would either not have any code generated,
or would have the statment marker removed by a different believed-good heuristic.

The other was that statement boundaries were getting attached to register
values (that with the old ABI were loads from the stack, hence real instructions).
The register values disappear at code generation.

The fixes are to (1) note that certain instructions are not good choices for
"first value" and skip them, and (2) in an expandCalls post-pass, look for
register valued instructions and under appropriate conditions move their
statement marker to a compatible use.

Also updates TestStmtLines to always log the score, for easier comparison of
minor compiler changes.

Updates #40724.

Change-Id: I485573ce900e292d7c44574adb7629cdb4695c3f
Reviewed-on: https://go-review.googlesource.com/c/go/+/309649
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 .../compile/internal/dwarfgen/scope_test.go   |  8 +++---
 src/cmd/compile/internal/ssa/expand_calls.go  | 25 +++++++++++++++++++
 .../compile/internal/ssa/stmtlines_test.go    |  1 +
 src/cmd/compile/internal/ssagen/ssa.go        | 10 ++++----
 test/codegen/mathbits.go                      |  5 +---
 test/codegen/rotate.go                        |  8 +++---
 6 files changed, 40 insertions(+), 17 deletions(-)

diff --git a/src/cmd/compile/internal/dwarfgen/scope_test.go b/src/cmd/compile/internal/dwarfgen/scope_test.go
index fcfcf85f84..3df4c345c3 100644
--- a/src/cmd/compile/internal/dwarfgen/scope_test.go
+++ b/src/cmd/compile/internal/dwarfgen/scope_test.go
@@ -181,17 +181,17 @@ var testfile = []testline{
 	{line: "		fi(p)", scopes: []int{1}},
 	{line: "	}"},
 	{line: "}"},
-	{line: "func TestCaptureVar(flag bool) func() int {"},
-	{line: "	a := 1", vars: []string{"arg flag bool", "arg ~r1 func() int", "var a int"}},
+	{line: "var fglob func() int"},
+	{line: "func TestCaptureVar(flag bool) {"},
+	{line: "	a := 1", vars: []string{"arg flag bool", "var a int"}}, // TODO(register args) restore "arg ~r1 func() int",
 	{line: "	if flag {"},
 	{line: "		b := 2", scopes: []int{1}, vars: []string{"var b int", "var f func() int"}},
 	{line: "		f := func() int {", scopes: []int{1, 0}},
 	{line: "			return b + 1"},
 	{line: "		}"},
-	{line: "		return f", scopes: []int{1}},
+	{line: "		fglob = f", scopes: []int{1}},
 	{line: "	}"},
 	{line: "	f1(a)"},
-	{line: "	return nil"},
 	{line: "}"},
 	{line: "func main() {"},
 	{line: "	TestNestedFor()"},
diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index d947443cb2..b2b2b5d877 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -1478,6 +1478,31 @@ func expandCalls(f *Func) {
 			}
 		}
 	}
+
+	// Rewriting can attach lines to values that are unlikely to survive code generation, so move them to a use.
+	for _, b := range f.Blocks {
+		for _, v := range b.Values {
+			for _, a := range v.Args {
+				if a.Pos.IsStmt() != src.PosIsStmt {
+					continue
+				}
+				if a.Type.IsMemory() {
+					continue
+				}
+				if a.Pos.Line() != v.Pos.Line() {
+					continue
+				}
+				if !a.Pos.SameFile(v.Pos) {
+					continue
+				}
+				switch a.Op {
+				case OpArgIntReg, OpArgFloatReg, OpSelectN:
+					v.Pos = v.Pos.WithIsStmt()
+					a.Pos = a.Pos.WithDefaultStmt()
+				}
+			}
+		}
+	}
 }
 
 // rewriteArgToMemOrRegs converts OpArg v in-place into the register version of v,
diff --git a/src/cmd/compile/internal/ssa/stmtlines_test.go b/src/cmd/compile/internal/ssa/stmtlines_test.go
index f5ff3a5927..a510d0b3d0 100644
--- a/src/cmd/compile/internal/ssa/stmtlines_test.go
+++ b/src/cmd/compile/internal/ssa/stmtlines_test.go
@@ -117,6 +117,7 @@ func TestStmtLines(t *testing.T) {
 	} else if len(nonStmtLines)*100 > 2*len(lines) { // expect 98% elsewhere.
 		t.Errorf("Saw too many (not amd64, > 2%%) lines without statement marks, total=%d, nostmt=%d ('-run TestStmtLines -v' lists failing lines)\n", len(lines), len(nonStmtLines))
 	}
+	t.Logf("Saw %d out of %d lines without statement marks", len(nonStmtLines), len(lines))
 	if testing.Verbose() {
 		sort.Slice(nonStmtLines, func(i, j int) bool {
 			if nonStmtLines[i].File != nonStmtLines[j].File {
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 60a849db23..b970451624 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -6638,15 +6638,15 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 				inlMarksByPos[pos] = append(inlMarksByPos[pos], p)
 
 			default:
+				// Special case for first line in function; move it to the start (which cannot be a register-valued instruction)
+				if firstPos != src.NoXPos && v.Op != ssa.OpArgIntReg && v.Op != ssa.OpArgFloatReg && v.Op != ssa.OpLoadReg && v.Op != ssa.OpStoreReg {
+					s.SetPos(firstPos)
+					firstPos = src.NoXPos
+				}
 				// Attach this safe point to the next
 				// instruction.
 				s.pp.NextLive = s.livenessMap.Get(v)
 
-				// Special case for first line in function; move it to the start.
-				if firstPos != src.NoXPos {
-					s.SetPos(firstPos)
-					firstPos = src.NoXPos
-				}
 				// let the backend handle it
 				Arch.SSAGenValue(&s, v)
 			}
diff --git a/test/codegen/mathbits.go b/test/codegen/mathbits.go
index fff6639546..03012eff5d 100644
--- a/test/codegen/mathbits.go
+++ b/test/codegen/mathbits.go
@@ -118,7 +118,7 @@ func Len8(n uint8) int {
 //    bits.OnesCount    //
 // -------------------- //
 
-// amd64:".*x86HasPOPCNT"
+// TODO(register args) Restore a m d 6 4 :.*x86HasPOPCNT when only one ABI is tested.
 func OnesCount(n uint) int {
 	// amd64:"POPCNTQ"
 	// arm64:"VCNT","VUADDLV"
@@ -129,7 +129,6 @@ func OnesCount(n uint) int {
 	return bits.OnesCount(n)
 }
 
-// amd64:".*x86HasPOPCNT"
 func OnesCount64(n uint64) int {
 	// amd64:"POPCNTQ"
 	// arm64:"VCNT","VUADDLV"
@@ -140,7 +139,6 @@ func OnesCount64(n uint64) int {
 	return bits.OnesCount64(n)
 }
 
-// amd64:".*x86HasPOPCNT"
 func OnesCount32(n uint32) int {
 	// amd64:"POPCNTL"
 	// arm64:"VCNT","VUADDLV"
@@ -151,7 +149,6 @@ func OnesCount32(n uint32) int {
 	return bits.OnesCount32(n)
 }
 
-// amd64:".*x86HasPOPCNT"
 func OnesCount16(n uint16) int {
 	// amd64:"POPCNTL"
 	// arm64:"VCNT","VUADDLV"
diff --git a/test/codegen/rotate.go b/test/codegen/rotate.go
index bf4bcc4fc3..519cc83263 100644
--- a/test/codegen/rotate.go
+++ b/test/codegen/rotate.go
@@ -16,8 +16,6 @@ func rot64(x uint64) uint64 {
 	var a uint64
 
 	// amd64:"ROLQ\t[$]7"
-	// arm64:"ROR\t[$]57"
-	// s390x:"RISBGZ\t[$]0, [$]63, [$]7, "
 	// ppc64:"ROTL\t[$]7"
 	// ppc64le:"ROTL\t[$]7"
 	a += x<<7 | x>>57
@@ -36,6 +34,8 @@ func rot64(x uint64) uint64 {
 	// ppc64le:"ROTL\t[$]9"
 	a += x<<9 ^ x>>55
 
+	// s390x:"RISBGZ\t[$]0, [$]63, [$]7, "
+	// arm64:"ROR\t[$]57" // TODO this is not great line numbering, but then again, the instruction did appear
 	return a
 }
 
@@ -44,8 +44,6 @@ func rot32(x uint32) uint32 {
 
 	// amd64:"ROLL\t[$]7"
 	// arm:"MOVW\tR\\d+@>25"
-	// arm64:"RORW\t[$]25"
-	// s390x:"RLL\t[$]7"
 	// ppc64:"ROTLW\t[$]7"
 	// ppc64le:"ROTLW\t[$]7"
 	a += x<<7 | x>>25
@@ -66,6 +64,8 @@ func rot32(x uint32) uint32 {
 	// ppc64le:"ROTLW\t[$]9"
 	a += x<<9 ^ x>>23
 
+	// s390x:"RLL\t[$]7"
+	// arm64:"RORW\t[$]25" // TODO this is not great line numbering, but then again, the instruction did appear
 	return a
 }
 
-- 
GitLab


From 492faaeda8d1d673c4b5d7f3983f3fcd072608de Mon Sep 17 00:00:00 2001
From: Manlio Perillo <manlio.perillo@gmail.com>
Date: Wed, 14 Apr 2021 12:57:21 +0200
Subject: [PATCH 1561/2400] os/exec: replace os.Setenv with T.Setenv

Updates #45448

Change-Id: I570e9894c4976d0a875388ef9ea4a2aa31b78013
Reviewed-on: https://go-review.googlesource.com/c/go/+/310031
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/os/exec/lp_unix_test.go | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/src/os/exec/lp_unix_test.go b/src/os/exec/lp_unix_test.go
index 75bcdb1fdd..9fded0eb0a 100644
--- a/src/os/exec/lp_unix_test.go
+++ b/src/os/exec/lp_unix_test.go
@@ -37,13 +37,7 @@ func TestLookPathUnixEmptyPath(t *testing.T) {
 		t.Fatal("Close failed: ", err)
 	}
 
-	pathenv := os.Getenv("PATH")
-	defer os.Setenv("PATH", pathenv)
-
-	err = os.Setenv("PATH", "")
-	if err != nil {
-		t.Fatal("Setenv failed: ", err)
-	}
+	t.Setenv("PATH", "")
 
 	path, err := LookPath("exec_me")
 	if err == nil {
-- 
GitLab


From bcbde83c200a7abb2b23666b59992265f3cf3621 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 14 Apr 2021 09:34:28 -0400
Subject: [PATCH 1562/2400] go/ast: fix broken build with typeparams build
 constraint

My rebase of https://golang.org/cl/300649 before submitting broke the
build (and tests) when using the typeparams build constraint. In a
subsequent CL I add test coverage back to cmd/dist.

This time, I've tested by running:
 - go test -tags=typeparams go/...
 - go test -tags=typeparams cmd/gofmt

All tests pass except for the new TestResolution/typeparams.go2, which I
will fix in a follow-up CL.

For #44933

Change-Id: I439d387841604cf43a90e2ce41dbe6bbbdb0306d
Reviewed-on: https://go-review.googlesource.com/c/go/+/310070
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/ast/walk.go            |  6 +++++-
 src/go/ast/walk_typeparams.go | 10 ++++++++--
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/src/go/ast/walk.go b/src/go/ast/walk.go
index 9224264e29..ac1395fafd 100644
--- a/src/go/ast/walk.go
+++ b/src/go/ast/walk.go
@@ -112,7 +112,11 @@ func Walk(v Visitor, node Node) {
 
 	case *IndexExpr:
 		Walk(v, n.X)
-		Walk(v, n.Index)
+		// n.Index may be nil for invalid type instantiation expressions, e.g.
+		// var x T[].
+		if n.Index != nil {
+			Walk(v, n.Index)
+		}
 
 	case *SliceExpr:
 		Walk(v, n.X)
diff --git a/src/go/ast/walk_typeparams.go b/src/go/ast/walk_typeparams.go
index 77267a5b8c..b6621335b8 100644
--- a/src/go/ast/walk_typeparams.go
+++ b/src/go/ast/walk_typeparams.go
@@ -7,6 +7,10 @@
 
 package ast
 
+import (
+	"fmt"
+)
+
 func walkFuncTypeParams(v Visitor, n *FuncType) {
 	if n.TParams != nil {
 		Walk(v, n.TParams)
@@ -20,9 +24,11 @@ func walkTypeSpecParams(v Visitor, n *TypeSpec) {
 }
 
 func walkOtherNodes(v Visitor, n Node) {
-	if e, ok := n.(*ast.ListExpr); ok {
+	if e, ok := n.(*ListExpr); ok {
 		if e != nil {
-			Walk(v, e)
+			for _, elem := range e.ElemList {
+				Walk(v, elem)
+			}
 		}
 	} else {
 		panic(fmt.Sprintf("ast.Walk: unexpected node type %T", n))
-- 
GitLab


From 283f9fdbd340a5f3c1b27fd10730986b35e57c89 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 14 Apr 2021 10:52:30 -0400
Subject: [PATCH 1563/2400] cmd/dist: add tests using the typeparams build tag

Now that go/ast changes have been guarded behind the typeparams build
tag, we no longer have coverage for tests involving generic code.

Add a new testing step to cmd/dist to run go/... and cmd/gofmt tests
using -tags=typeparams.

Comment out parser object resolution assertions that currently fail, and
which will be fixed by CL 304456.

Fixes #44933

Change-Id: I481dd4246a016f410307865b6c6c2bb3c8e6e3bc
Reviewed-on: https://go-review.googlesource.com/c/go/+/310071
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/dist/test.go                             | 13 +++++++++++++
 src/go/parser/testdata/resolution/typeparams.go2 |  9 +++++----
 2 files changed, 18 insertions(+), 4 deletions(-)

diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go
index cbf3ec6d88..5ae0bf92cf 100644
--- a/src/cmd/dist/test.go
+++ b/src/cmd/dist/test.go
@@ -475,6 +475,19 @@ func (t *tester) registerTests() {
 		})
 	}
 
+	// Test go/... cmd/gofmt with type parameters enabled.
+	if !t.compileOnly {
+		t.tests = append(t.tests, distTest{
+			name:    "tyepparams",
+			heading: "go/... and cmd/gofmt tests with tag typeparams",
+			fn: func(dt *distTest) error {
+				t.addCmd(dt, "src", t.goTest(), t.timeout(300), "-tags=typeparams", "go/...")
+				t.addCmd(dt, "src", t.goTest(), t.timeout(300), "-tags=typeparams", "cmd/gofmt")
+				return nil
+			},
+		})
+	}
+
 	if t.iOS() && !t.compileOnly {
 		t.tests = append(t.tests, distTest{
 			name:    "x509omitbundledroots",
diff --git a/src/go/parser/testdata/resolution/typeparams.go2 b/src/go/parser/testdata/resolution/typeparams.go2
index 922f7790f5..c03a596203 100644
--- a/src/go/parser/testdata/resolution/typeparams.go2
+++ b/src/go/parser/testdata/resolution/typeparams.go2
@@ -18,7 +18,8 @@ type Addable /* =@Addable */ interface {
 }
 
 // TODO (#45221): resolve references to T in the signature below.
-func Add /* =@AddDecl */[T /* =@T */ Addable /* @Addable */](l /* =@l */, r /* =@r */ T) T {
-	var t /* =@t */ T /* @T */
-	return l /* @l */ + r /* @r */ + t /* @t */
-}
+// TODO(rFindley): re-enable these once type parameter resolution is fixed.
+// func Add /* =@AddDecl */[T /* =@T */ Addable /* @Addable */](l /* =@l */, r /* =@r */ T) T {
+	// var t /* =@t */ T /* @T */
+	// return l /* @l */ + r /* @r */ + t /* @t */
+// }
-- 
GitLab


From 892cad7a9b6632533f87bf89d98c43f21c749a80 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 13 Apr 2021 17:48:45 -0700
Subject: [PATCH 1564/2400] cmd/compile/internal/types2: add Named.SetTParams
 and Named.Orig methods

Named.SetTParams sets the type parameters for a named type.

Named.Orig returns the original generic type an instantiated
type is derived from. Added a new field orig for that purpose
and renamed the already existing orig field to fromRHS.

Finally, updated various comments.

Change-Id: Ic9d173e42740422d195713d8bdc62a54dc8c5f54
Reviewed-on: https://go-review.googlesource.com/c/go/+/309832
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/decl.go       |  9 ++--
 .../compile/internal/types2/issues_test.go    |  2 +-
 src/cmd/compile/internal/types2/sanitize.go   |  4 +-
 .../compile/internal/types2/stdlib_test.go    |  2 +-
 src/cmd/compile/internal/types2/subst.go      |  5 +--
 src/cmd/compile/internal/types2/type.go       | 42 ++++++++++++-------
 src/cmd/compile/internal/types2/typexpr.go    |  4 +-
 7 files changed, 38 insertions(+), 30 deletions(-)

diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index f8559a43bb..178bebe2ec 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -333,7 +333,7 @@ func (check *Checker) validType(typ Type, path []Object) typeInfo {
 		switch t.info {
 		case unknown:
 			t.info = marked
-			t.info = check.validType(t.orig, append(path, t.obj)) // only types of current package added to path
+			t.info = check.validType(t.fromRHS, append(path, t.obj)) // only types of current package added to path
 		case marked:
 			// cycle detected
 			for i, tn := range path {
@@ -611,9 +611,8 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *syntax.TypeDecl, def *Named
 	} else {
 		// defined type declaration
 
-		named := &Named{check: check, obj: obj}
+		named := check.newNamed(obj, nil, nil, nil, nil)
 		def.setUnderlying(named)
-		obj.typ = named // make sure recursive type declarations terminate
 
 		if tdecl.TParamList != nil {
 			check.openScope(tdecl, "type parameters")
@@ -622,7 +621,7 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *syntax.TypeDecl, def *Named
 		}
 
 		// determine underlying type of named
-		named.orig = check.definedType(tdecl.Type, named)
+		named.fromRHS = check.definedType(tdecl.Type, named)
 
 		// The underlying type of named may be itself a named type that is
 		// incomplete:
@@ -637,7 +636,7 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *syntax.TypeDecl, def *Named
 		// and which has as its underlying type the named type B.
 		// Determine the (final, unnamed) underlying type by resolving
 		// any forward chain.
-		// TODO(gri) Investigate if we can just use named.origin here
+		// TODO(gri) Investigate if we can just use named.fromRHS here
 		//           and rely on lazy computation of the underlying type.
 		named.underlying = under(named)
 	}
diff --git a/src/cmd/compile/internal/types2/issues_test.go b/src/cmd/compile/internal/types2/issues_test.go
index e1f5c92fc4..643d6789b5 100644
--- a/src/cmd/compile/internal/types2/issues_test.go
+++ b/src/cmd/compile/internal/types2/issues_test.go
@@ -195,7 +195,7 @@ L7 uses var z int`
 	}
 }
 
-// This tests that the package associated with the types.Object.Pkg method
+// This tests that the package associated with the types2.Object.Pkg method
 // is the type's package independent of the order in which the imports are
 // listed in the sources src1, src2 below.
 // The actual issue is in go/internal/gcimporter which has a corresponding
diff --git a/src/cmd/compile/internal/types2/sanitize.go b/src/cmd/compile/internal/types2/sanitize.go
index cd1719c8c0..8b8bc72d85 100644
--- a/src/cmd/compile/internal/types2/sanitize.go
+++ b/src/cmd/compile/internal/types2/sanitize.go
@@ -126,8 +126,8 @@ func (s sanitizer) typ(typ Type) Type {
 		}
 
 	case *Named:
-		if orig := s.typ(t.orig); orig != t.orig {
-			t.orig = orig
+		if orig := s.typ(t.fromRHS); orig != t.fromRHS {
+			t.fromRHS = orig
 		}
 		if under := s.typ(t.underlying); under != t.underlying {
 			t.underlying = under
diff --git a/src/cmd/compile/internal/types2/stdlib_test.go b/src/cmd/compile/internal/types2/stdlib_test.go
index 6853bd23b0..c04f5e1c46 100644
--- a/src/cmd/compile/internal/types2/stdlib_test.go
+++ b/src/cmd/compile/internal/types2/stdlib_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// This file tests types.Check by using it to
+// This file tests types2.Check by using it to
 // typecheck the standard library and tests.
 
 package types2_test
diff --git a/src/cmd/compile/internal/types2/subst.go b/src/cmd/compile/internal/types2/subst.go
index d730642831..d089317f7d 100644
--- a/src/cmd/compile/internal/types2/subst.go
+++ b/src/cmd/compile/internal/types2/subst.go
@@ -385,8 +385,7 @@ func (subst *subster) typ(typ Type) Type {
 
 		// create a new named type and populate caches to avoid endless recursion
 		tname := NewTypeName(subst.pos, t.obj.pkg, t.obj.name, nil)
-		named := subst.check.NewNamed(tname, t.underlying, t.methods) // method signatures are updated lazily
-		named.tparams = t.tparams                                     // new type is still parameterized
+		named := subst.check.newNamed(tname, t, t.underlying, t.tparams, t.methods) // method signatures are updated lazily
 		named.targs = new_targs
 		subst.check.typMap[h] = named
 		subst.cache[t] = named
@@ -394,7 +393,7 @@ func (subst *subster) typ(typ Type) Type {
 		// do the substitution
 		dump(">>> subst %s with %s (new: %s)", t.underlying, subst.smap, new_targs)
 		named.underlying = subst.typOrNil(t.underlying)
-		named.orig = named.underlying // for cycle detection (Checker.validType)
+		named.fromRHS = named.underlying // for cycle detection (Checker.validType)
 
 		return named
 
diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
index daa00ddd3a..e6c260ff67 100644
--- a/src/cmd/compile/internal/types2/type.go
+++ b/src/cmd/compile/internal/types2/type.go
@@ -224,10 +224,10 @@ func NewSignature(recv *Var, params, results *Tuple, variadic bool) *Signature {
 	if variadic {
 		n := params.Len()
 		if n == 0 {
-			panic("types.NewSignature: variadic function must have at least one parameter")
+			panic("types2.NewSignature: variadic function must have at least one parameter")
 		}
 		if _, ok := params.At(n - 1).typ.(*Slice); !ok {
-			panic("types.NewSignature: variadic parameter must be of unnamed slice type")
+			panic("types2.NewSignature: variadic parameter must be of unnamed slice type")
 		}
 	}
 	return &Signature{recv: recv, params: params, results: results, variadic: variadic}
@@ -645,12 +645,15 @@ func (c *Chan) Dir() ChanDir { return c.dir }
 // Elem returns the element type of channel c.
 func (c *Chan) Elem() Type { return c.elem }
 
+// TODO(gri) Clean up Named struct below; specifically the fromRHS field (can we use underlying?).
+
 // A Named represents a named (defined) type.
 type Named struct {
 	check      *Checker    // for Named.under implementation
 	info       typeInfo    // for cycle detection
 	obj        *TypeName   // corresponding declared object
-	orig       Type        // type (on RHS of declaration) this *Named type is derived of (for cycle reporting)
+	orig       *Named      // original, uninstantiated type
+	fromRHS    Type        // type (on RHS of declaration) this *Named type is derived from (for cycle reporting)
 	underlying Type        // possibly a *Named during setup; never a *Named once set up completely
 	tparams    []*TypeName // type parameters, or nil
 	targs      []Type      // type arguments (after instantiation), or nil
@@ -662,17 +665,17 @@ type Named struct {
 // The underlying type must not be a *Named.
 func NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named {
 	if _, ok := underlying.(*Named); ok {
-		panic("types.NewNamed: underlying type must not be *Named")
-	}
-	typ := &Named{obj: obj, orig: underlying, underlying: underlying, methods: methods}
-	if obj.typ == nil {
-		obj.typ = typ
+		panic("types2.NewNamed: underlying type must not be *Named")
 	}
-	return typ
+	return (*Checker)(nil).newNamed(obj, nil, underlying, nil, methods)
 }
 
-func (check *Checker) NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named {
-	typ := &Named{check: check, obj: obj, orig: underlying, underlying: underlying, methods: methods}
+// newNamed is like NewNamed but with a *Checker receiver and additional orig argument.
+func (check *Checker) newNamed(obj *TypeName, orig *Named, underlying Type, tparams []*TypeName, methods []*Func) *Named {
+	typ := &Named{check: check, obj: obj, orig: orig, fromRHS: underlying, underlying: underlying, tparams: tparams, methods: methods}
+	if typ.orig == nil {
+		typ.orig = typ
+	}
 	if obj.typ == nil {
 		obj.typ = typ
 	}
@@ -682,6 +685,10 @@ func (check *Checker) NewNamed(obj *TypeName, underlying Type, methods []*Func)
 // Obj returns the type name for the named type t.
 func (t *Named) Obj() *TypeName { return t.obj }
 
+// Orig returns the original generic type an instantiated type is derived from.
+// If t is not an instantiated type, the result is t.
+func (t *Named) Orig() *Named { return t.orig }
+
 // TODO(gri) Come up with a better representation and API to distinguish
 //           between parameterized instantiated and non-instantiated types.
 
@@ -689,10 +696,13 @@ func (t *Named) Obj() *TypeName { return t.obj }
 // The result is non-nil for an (originally) parameterized type even if it is instantiated.
 func (t *Named) TParams() []*TypeName { return t.tparams }
 
+// SetTParams sets the type parameters of the named type t.
+func (t *Named) SetTParams(tparams []*TypeName) { t.tparams = tparams }
+
 // TArgs returns the type arguments after instantiation of the named type t, or nil if not instantiated.
 func (t *Named) TArgs() []Type { return t.targs }
 
-// SetTArgs sets the type arguments of Named.
+// SetTArgs sets the type arguments of the named type t.
 func (t *Named) SetTArgs(args []Type) { t.targs = args }
 
 // NumMethods returns the number of explicit methods whose receiver is named type t.
@@ -704,10 +714,10 @@ func (t *Named) Method(i int) *Func { return t.methods[i] }
 // SetUnderlying sets the underlying type and marks t as complete.
 func (t *Named) SetUnderlying(underlying Type) {
 	if underlying == nil {
-		panic("types.Named.SetUnderlying: underlying type must not be nil")
+		panic("types2.Named.SetUnderlying: underlying type must not be nil")
 	}
 	if _, ok := underlying.(*Named); ok {
-		panic("types.Named.SetUnderlying: underlying type must not be *Named")
+		panic("types2.Named.SetUnderlying: underlying type must not be *Named")
 	}
 	t.underlying = underlying
 }
@@ -731,9 +741,9 @@ func nextId() uint64 { return uint64(atomic.AddUint32(&lastId, 1)) }
 // A TypeParam represents a type parameter type.
 type TypeParam struct {
 	check *Checker  // for lazy type bound completion
-	id    uint64    // unique id
+	id    uint64    // unique id, for debugging only
 	obj   *TypeName // corresponding type name
-	index int       // parameter index
+	index int       // type parameter index in source order, starting at 0
 	bound Type      // *Named or *Interface; underlying type is always *Interface
 }
 
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index e7d24949a4..61b290c075 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -431,9 +431,9 @@ func (check *Checker) funcType(sig *Signature, recvPar *syntax.Field, tparams []
 }
 
 // goTypeName returns the Go type name for typ and
-// removes any occurrences of "types." from that name.
+// removes any occurrences of "types2." from that name.
 func goTypeName(typ Type) string {
-	return strings.Replace(fmt.Sprintf("%T", typ), "types.", "", -1) // strings.ReplaceAll is not available in Go 1.4
+	return strings.Replace(fmt.Sprintf("%T", typ), "types2.", "", -1) // strings.ReplaceAll is not available in Go 1.4
 }
 
 // typInternal drives type checking of types.
-- 
GitLab


From b161b57c3fbb08cdfe28b91ed40b347b83569b48 Mon Sep 17 00:00:00 2001
From: Manlio Perillo <manlio.perillo@gmail.com>
Date: Tue, 13 Apr 2021 12:25:19 +0200
Subject: [PATCH 1565/2400] go/build: replace os.MkdirTemp with T.TempDir

Updates #45402

Change-Id: Ic2f696837034de17333a6a53127a4bfd301e96a4
Reviewed-on: https://go-review.googlesource.com/c/go/+/309354
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/go/build/build_test.go | 20 ++++----------------
 1 file changed, 4 insertions(+), 16 deletions(-)

diff --git a/src/go/build/build_test.go b/src/go/build/build_test.go
index 6529b6e47e..dcd8458252 100644
--- a/src/go/build/build_test.go
+++ b/src/go/build/build_test.go
@@ -486,11 +486,7 @@ func TestImportDirNotExist(t *testing.T) {
 	testenv.MustHaveGoBuild(t) // really must just have source
 	ctxt := Default
 
-	emptyDir, err := os.MkdirTemp("", t.Name())
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(emptyDir)
+	emptyDir := t.TempDir()
 
 	ctxt.GOPATH = emptyDir
 	ctxt.Dir = emptyDir
@@ -624,11 +620,7 @@ func TestImportPackageOutsideModule(t *testing.T) {
 
 	// Create a GOPATH in a temporary directory. We don't use testdata
 	// because it's in GOROOT, which interferes with the module heuristic.
-	gopath, err := os.MkdirTemp("", "gobuild-notmodule")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(gopath)
+	gopath := t.TempDir()
 	if err := os.MkdirAll(filepath.Join(gopath, "src/example.com/p"), 0777); err != nil {
 		t.Fatal(err)
 	}
@@ -688,11 +680,7 @@ func TestIssue23594(t *testing.T) {
 // Verifies golang.org/issue/34752.
 func TestMissingImportErrorRepetition(t *testing.T) {
 	testenv.MustHaveGoBuild(t) // need 'go list' internally
-	tmp, err := os.MkdirTemp("", "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmp)
+	tmp := t.TempDir()
 	if err := os.WriteFile(filepath.Join(tmp, "go.mod"), []byte("module m"), 0666); err != nil {
 		t.Fatal(err)
 	}
@@ -707,7 +695,7 @@ func TestMissingImportErrorRepetition(t *testing.T) {
 	ctxt.Dir = tmp
 
 	pkgPath := "example.com/hello"
-	_, err = ctxt.Import(pkgPath, tmp, FindOnly)
+	_, err := ctxt.Import(pkgPath, tmp, FindOnly)
 	if err == nil {
 		t.Fatal("unexpected success")
 	}
-- 
GitLab


From d1f8104b587838647e1ae0c600bff1621c7188f2 Mon Sep 17 00:00:00 2001
From: Martin Sucha <anty.sk+git@gmail.com>
Date: Mon, 12 Apr 2021 07:57:25 +0200
Subject: [PATCH 1566/2400] time: move slim test tzdata to testdata directory

The lines with tzdata are quite long.

It is easier to just copy a file than to encode it as
a string literal when adding a new test case.

Change-Id: Ibcaf347c3101a0f05b094e582b3473c7c35b685a
Reviewed-on: https://go-review.googlesource.com/c/go/+/308998
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/time/testdata/2020b_Europe_Berlin | Bin 0 -> 705 bytes
 src/time/testdata/2021a_America_Nuuk  | Bin 0 -> 465 bytes
 src/time/testdata/2021a_Asia_Gaza     | Bin 0 -> 1213 bytes
 src/time/testdata/2021a_Europe_Dublin | Bin 0 -> 1496 bytes
 src/time/zoneinfo_test.go             |  20 +++++++++++++-------
 5 files changed, 13 insertions(+), 7 deletions(-)
 create mode 100644 src/time/testdata/2020b_Europe_Berlin
 create mode 100644 src/time/testdata/2021a_America_Nuuk
 create mode 100644 src/time/testdata/2021a_Asia_Gaza
 create mode 100644 src/time/testdata/2021a_Europe_Dublin

diff --git a/src/time/testdata/2020b_Europe_Berlin b/src/time/testdata/2020b_Europe_Berlin
new file mode 100644
index 0000000000000000000000000000000000000000..465546bd396ae5eb75076f13ba9c29b0c926c835
GIT binary patch
literal 705
zcmWHE%1kq2AP5*47#Khpq>u<LHVh05EDQ_`LjV8&|DV4o@dt>W%_E)wrmx=m0HWvI
zTsHwk&t0+=OwZdn0Zh+tnGU8;a2A5;Gta#RK<dt}6bJLqEpi6)&rdP|(-)dl!Sux<
zF$leF8UslErHFkEV0xiHSp0IbG+6%?Z)Grj)$*bONd9X2a|nM$F<9R<%`IT{*L9@8
z^bO8wVEQK0L9n`;FDnE<;UMhm0;WZbe@y`KMU`KJX))nDU|O8{EQJ2N4@^ruUJs@v
zFE0SoQimskY3V(C!RE-USqG+N=gbGway=8kw0un?m{!Os0@I2y$zWQ^Cj?9@+qi;h
z6&*7$ttz7qrqy^Pz_dE6GuR&WuO?tx<Ebi`*1RePrnQc;gK6z8Kftukl9ymwcgig=
zt=DoIOzW5I0n-L4Yr(W(>`ehCMr6ng=0QkgaqMgc2A&R3xXCCmvM@042{3RnFlZSt
q^7{COFgUvgg9s4z4PoGNb`8-r1c~YR8ta+r8R+;L8h~hhV=e$VmE(s1

literal 0
HcmV?d00001

diff --git a/src/time/testdata/2021a_America_Nuuk b/src/time/testdata/2021a_America_Nuuk
new file mode 100644
index 0000000000000000000000000000000000000000..4ddc99d8b74c4b525263ca1337cb57d1a15692c0
GIT binary patch
literal 465
zcmWHE%1kq6AP5*47#Khpq>u<LN(>AP%nS?+Jpcdy|3AAS1Eh^X*taGC#1Jw5H33A6
zD!&HPV#0U8v^euw2>p2<n3j0F9!yJKUI3=04o?Kr(tGv_fb`3(SqG+N=gbGway=8k
zw0un?m{!Os0@I2y$zWQ^Cj?9@+qi;h6&*7$ttz7qrqy^Pz_dE6GuR&WuO?tx<Ebi`
z*1RePrnQc;gK6z8Kftukl9ymwcgig=t=DoIOzW5I0n-L4Yr(W(>`ehiCPMK4|MLwD
z4FCUMy}-co|Nr9$j2u3`Aq=_(#tga!Mhsjwx(3E}#x}YJMs_;B#(JiD2Ku^2I=+Sm
I5T+p)0Jw!t(*OVf

literal 0
HcmV?d00001

diff --git a/src/time/testdata/2021a_Asia_Gaza b/src/time/testdata/2021a_Asia_Gaza
new file mode 100644
index 0000000000000000000000000000000000000000..58e9fdf42d3df55f9a75e720d40908c1544ef2b0
GIT binary patch
literal 1213
zcmWHE%1kq6AP5*47#Khpq>u<L#S9D#tPBhcqW}N@|6jY;YXgWr5qX{gO#fO2rcYYT
zX#nxhJbewO&#w6g7C(1f9!#I_ZwAvBRxSb47h7t<^rf!rVD*<%H-PCYIox3J7iP%`
zAoE^)(G396uef)D`LC`fTmbQ3zxnk6M8DaZ3s(R3d_9=|Zu%!M|NVx|1t9qkm8xKK
zKTdoGmj4tL36}p{ECrVTV%-Cl{~9_U%>O1Q2<Cq`y98GM{l6<%{Z9!tu>8-5r@;JQ
zKP|!Xztx=rK;g(y)BONU|J`r_M00+7l>nl-mKlTj!Y}`T`67zZU|Q<eF)%INmj|Y0
z_Wc0smo2XWtCu_TA1p4PFcWOPLeoYtU(s_bSY9b^9$3AyLM&KbCCUISugYK#=BshP
z1<R{ldj?jo{`x$auW^7GEU$Ux4OqR_N_nun_U=@$yiO-0n6EqA9n9B@UkO&PU#$t|
z8+aTA%Nsmr2lEY6+`#4-IUWMj#x5FQ+C*^)m^M}60@G%UZD875ED=mwu(^QEwfJ8P
zHplXP0@z%u`|)7D^?4^S-)6rfm~XpY1<bdbuMFnf_p^cd4)v^HzGF-yn0AVL4yK(Q
zw|@YIzl-iNuzjvVf5G;-@!bT=yS>OS0Li<*kpS~OwhMyI^E~|v%=cPg1J>ugR&NeS
zoloLku)Ob-pJ2Y9=^?Or{w24;>H?xCg7pQ4>;?0KTo!=kgH7gx`5~S;V1B6RC9t|M
z%^0wF*w;f~cSZ=G0`nuTE&=l+Kd%Avqqeqz`O%mA!2FoG&S3qqo0Gui#nqK3FfkH>
zEX;TzA?=v*3=9fj>$MCRSr`~(6c{)e7_<x+dBJQ!AKwrLSJz+=5yIf<62jma9Kyim
c>KdYJ1QOQqHP$oHGtoD((D5}ifG{n&0AW^xX#fBK

literal 0
HcmV?d00001

diff --git a/src/time/testdata/2021a_Europe_Dublin b/src/time/testdata/2021a_Europe_Dublin
new file mode 100644
index 0000000000000000000000000000000000000000..4a45ea8f73f8e2a3f0b7a9ee4e387745fa859c3d
GIT binary patch
literal 1496
zcmWHE%1kq2AP5*47#Khpq>u<L6B!s7I2afhME?K(|3Ca9*BuZ&TW#}1Fnx_%5Jb;8
zZ?FJF&s}mDOwXG$7fjEeE(N9+wC+*>$uBJX1LiMEodf1Cu08?gFY(&}rkC3P28%CK
zO#su&)sKPc6<RtF`t=X6x>XF9A@o&Iu=whiAHejQ<2hh@?a51EdfjqAFui_3C0PB2
zb^|bf<D?5<{-y#SFul2G6PVr-pa-V6dPafOZ8H!6^S2w7f$1ImpTP7^p$G{5{tB4h
z^^yUse)o-!V0zE(a4@}h$7L|RZ{t6(y8Sb@g82t#OM~fy71P1=p{l=N`fx-gm_8D?
z1g!q3MKqXy%<3SRJ|1xmEPnhJCz!tC`2Z|_RZbDizvj0F%)hRq0j6*0^+D*LQ^E8t
zz5)pS`VE-A{Zt&R@6PFSVE)}BKf(NaTV8?b`|HHO;t!^r0rMXgd4TCh*(G4{$3a?P
z{*#aiVEU;M514*tyA~|}Tv`)MzYqxli@*5I4d%c6TL`9K-FgeAU*8P|({Fa22h(pi
z{{pLjH)|u9|GqID%>OXI7R>*c=n3Y3s*eZrKYOKt=`Zn)VEU^fFIfJYy)u~po#8#0
z|3jV?%>VJ=BAEa4-*Yhk*MZGo{_hveVERw>YB2rx`0fHwK4C66rU0T@G$X(?YrqOH
z&Bkd3rr8a;AoNQaFwH5D1EEj+1Jhg|{J=E#CaDD=b9gQofcd-=|A6^?8-&1o{=$1;
zzQ9a9FfAB(089&23V>;0!$n|PB;pg87FB*d0c4(-#W64~&U_Y3OGvDM(2v)HX~`d5
zU|Q<%L@+J=aJc|TpUj$dU|RNICzzJ&nE<Bc7iNQLg`6TVt=Q-brj>j`z_fCrKA2X~
zF$2@8Ufy7H)p#Vpe042dFkk(v37FR8;)l>z#lW=I%a34Md&>_nt#k4+nAV+g3ry>+
z+zO`kOZI?igU;z-+A#K}03#C%GaRzAP#LnbkqrO;|E0pf@c;iWeg+l>1`c^f4h9B3
z0Y)BB05b@H*`NZHff3AR;PCMcVQ}#cVekwNVQ>l#VQ}{iVc_x%4$(Dq_YE=7@ijEi
PGu1QD@ihif`i5Kplb)+e

literal 0
HcmV?d00001

diff --git a/src/time/zoneinfo_test.go b/src/time/zoneinfo_test.go
index 7ba1229741..03229d192c 100644
--- a/src/time/zoneinfo_test.go
+++ b/src/time/zoneinfo_test.go
@@ -185,7 +185,7 @@ func TestMalformedTZData(t *testing.T) {
 
 var slimTests = []struct {
 	zoneName   string
-	tzData     string
+	fileName   string
 	date       func(*time.Location) time.Time
 	wantName   string
 	wantOffset int
@@ -193,7 +193,7 @@ var slimTests = []struct {
 	{
 		// 2020b slim tzdata for Europe/Berlin.
 		zoneName:   "Europe/Berlin",
-		tzData:     "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00<\x00\x00\x00\x04\x00\x00\x00\x12\xff\xff\xff\xffo\xa2a\xf8\xff\xff\xff\xff\x9b\f\x17`\xff\xff\xff\xff\x9b\xd5\xda\xf0\xff\xff\xff\xff\x9cٮ\x90\xff\xff\xff\xff\x9d\xa4\xb5\x90\xff\xff\xff\xff\x9e\xb9\x90\x90\xff\xff\xff\xff\x9f\x84\x97\x90\xff\xff\xff\xff\xc8\tq\x90\xff\xff\xff\xff\xcc\xe7K\x10\xff\xff\xff\xffͩ\x17\x90\xff\xff\xff\xff\u03a2C\x10\xff\xff\xff\xffϒ4\x10\xff\xff\xff\xffЂ%\x10\xff\xff\xff\xff\xd1r\x16\x10\xff\xff\xff\xffѶ\x96\x00\xff\xff\xff\xff\xd2X\xbe\x80\xff\xff\xff\xffҡO\x10\xff\xff\xff\xff\xd3c\x1b\x90\xff\xff\xff\xff\xd4K#\x90\xff\xff\xff\xff\xd59\xd1 \xff\xff\xff\xff\xd5g\xe7\x90\xff\xff\xff\xffըs\x00\xff\xff\xff\xff\xd6)\xb4\x10\xff\xff\xff\xff\xd7,\x1a\x10\xff\xff\xff\xff\xd8\t\x96\x10\xff\xff\xff\xff\xd9\x02\xc1\x90\xff\xff\xff\xff\xd9\xe9x\x10\x00\x00\x00\x00\x13MD\x10\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x01\x02\x01\x02\x01\x03\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00\f\x88\x00\x00\x00\x00\x1c \x01\x04\x00\x00\x0e\x10\x00\t\x00\x00*0\x01\rLMT\x00CEST\x00CET\x00CEMT\x00\nCET-1CEST,M3.5.0,M10.5.0/3\n",
+		fileName:   "2020b_Europe_Berlin",
 		date:       func(loc *time.Location) time.Time { return time.Date(2020, time.October, 29, 15, 30, 0, 0, loc) },
 		wantName:   "CET",
 		wantOffset: 3600,
@@ -201,7 +201,7 @@ var slimTests = []struct {
 	{
 		// 2021a slim tzdata for America/Nuuk.
 		zoneName:   "America/Nuuk",
-		tzData:     "TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\"\x00\x00\x00\x03\x00\x00\x00\f\xff\xff\xff\xff\x9b\x80h\x00\x00\x00\x00\x00\x13M|P\x00\x00\x00\x00\x143\xfa\x90\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x16\x13ܐ\x00\x00\x00\x00\x17\x03͐\x00\x00\x00\x00\x17\xf3\xbe\x90\x00\x00\x00\x00\x18㯐\x00\x00\x00\x00\x19Ӡ\x90\x00\x00\x00\x00\x1aÑ\x90\x00\x00\x00\x00\x1b\xbc\xbd\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\x9c\x9f\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f|\x81\x10\x00\x00\x00\x00 lr\x10\x00\x00\x00\x00!\\c\x10\x00\x00\x00\x00\"LT\x10\x00\x00\x00\x00#<E\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%\x1c'\x10\x00\x00\x00\x00&\f\x18\x10\x00\x00\x00\x00'\x05C\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00(\xe5%\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xc5\a\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xa4\xe9\x90\x00\x00\x00\x00-\x94ڐ\x00\x00\x00\x00.\x84ː\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000d\xad\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xffπ\x00\x00\xff\xff\xd5\xd0\x00\x04\xff\xff\xe3\xe0\x01\bLMT\x00-03\x00-02\x00\n<-03>3<-02>,M3.5.0/-2,M10.5.0/-1\n",
+		fileName:   "2021a_America_Nuuk",
 		date:       func(loc *time.Location) time.Time { return time.Date(2020, time.October, 29, 15, 30, 0, 0, loc) },
 		wantName:   "-03",
 		wantOffset: -10800,
@@ -209,7 +209,7 @@ var slimTests = []struct {
 	{
 		// 2021a slim tzdata for Asia/Gaza.
 		zoneName:   "Asia/Gaza",
-		tzData:     "TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00s\x00\x00\x00\x05\x00\x00\x00\x15\xff\xff\xff\xff}\xbdJ\xb0\xff\xff\xff\xff\xc8Y\xcf\x00\xff\xff\xff\xff\xc8\xfa\xa6\x00\xff\xff\xff\xff\xc98\x9c\x80\xff\xff\xff\xff\xcc\xe5\xeb\x80\xff\xff\xff\xffͬ\xfe\x00\xff\xff\xff\xff\xce\xc7\x1f\x00\xff\xff\xff\xffϏ\x83\x00\xff\xff\xff\xffЩ\xa4\x00\xff\xff\xff\xffф}\x00\xff\xff\xff\xffҊ׀\xff\xff\xff\xff\xd3e\xb0\x80\xff\xff\xff\xff\xd4l\v\x00\xff\xff\xff\xff\xe86c`\xff\xff\xff\xff\xe8\xf4-P\xff\xff\xff\xff\xea\v\xb9`\xff\xff\xff\xff\xea\xd5`\xd0\xff\xff\xff\xff\xeb\xec\xfa\xf0\xff\xff\xff\xff\xec\xb5m\x00\xff\xff\xff\xff\xed\xcf\u007f\xf0\xff\xff\xff\xff\xee\x97\xf2\x00\xff\xff\xff\xffﰳp\xff\xff\xff\xff\xf0y%\x80\xff\xff\xff\xff\xf1\x91\xe6\xf0\xff\xff\xff\xff\xf2ZY\x00\xff\xff\xff\xff\xf3s\x1ap\xff\xff\xff\xff\xf4;\x8c\x80\xff\xff\xff\xff\xf5U\x9fp\xff\xff\xff\xff\xf6\x1e\x11\x80\xff\xff\xff\xff\xf76\xd2\xf0\xff\xff\xff\xff\xf7\xffE\x00\xff\xff\xff\xff\xf9\x18\x06p\xff\xff\xff\xff\xf9\xe1\xca\x00\xff\xff\xff\xff\xfa\xf99\xf0\xff\xff\xff\xff\xfb'BP\x00\x00\x00\x00\b|\x8b\xe0\x00\x00\x00\x00\b\xfd\xb0\xd0\x00\x00\x00\x00\t\xf6\xea`\x00\x00\x00\x00\n\xa63\xd0\x00\x00\x00\x00\x13\xe9\xfc`\x00\x00\x00\x00\x14![`\x00\x00\x00\x00\x1a\xfa\xc6`\x00\x00\x00\x00\x1b\x8en`\x00\x00\x00\x00\x1c\xbe\xf8\xe0\x00\x00\x00\x00\x1dw|\xd0\x00\x00\x00\x00\x1e\xcc\xff`\x00\x00\x00\x00\x1f`\x99P\x00\x00\x00\x00 \x82\xb1`\x00\x00\x00\x00!I\xb5\xd0\x00\x00\x00\x00\"^\x9e\xe0\x00\x00\x00\x00# ]P\x00\x00\x00\x00$Z0`\x00\x00\x00\x00%\x00?P\x00\x00\x00\x00&\v\xed\xe0\x00\x00\x00\x00&\xd6\xe6\xd0\x00\x00\x00\x00'\xeb\xcf\xe0\x00\x00\x00\x00(\xc0\x03P\x00\x00\x00\x00)\xd4\xec`\x00\x00\x00\x00*\xa9\x1f\xd0\x00\x00\x00\x00+\xbbe\xe0\x00\x00\x00\x00,\x89\x01\xd0\x00\x00\x00\x00-\x9bG\xe0\x00\x00\x00\x00._\xa9P\x00\x00\x00\x00/{)\xe0\x00\x00\x00\x000H\xc5\xd0\x00\x00\x00\x000\xe7\a\xe0\x00\x00\x00\x001dF`\x00\x00\x00\x002A\xc2`\x00\x00\x00\x003D(`\x00\x00\x00\x004!\xa4`\x00\x00\x00\x005$\n`\x00\x00\x00\x006\x01\x86`\x00\x00\x00\x007\x16a`\x00\x00\x00\x008\x06DP\x00\x00\x00\x008\xff}\xe0\x00\x00\x00\x009\xef`\xd0\x00\x00\x00\x00:\xdf_\xe0\x00\x00\x00\x00;\xcfB\xd0\x00\x00\x00\x00<\xbfA\xe0\x00\x00\x00\x00=\xaf$\xd0\x00\x00\x00\x00>\x9f#\xe0\x00\x00\x00\x00?\x8f\x06\xd0\x00\x00\x00\x00@\u007f\x05\xe0\x00\x00\x00\x00A\\\x81\xe0\x00\x00\x00\x00B^\xe7\xe0\x00\x00\x00\x00CA\xb7\xf0\x00\x00\x00\x00D-\xa6`\x00\x00\x00\x00E\x12\xfdP\x00\x00\x00\x00F\x0e\xd9\xe0\x00\x00\x00\x00F\xe8op\x00\x00\x00\x00G\xec\x18\xe0\x00\x00\x00\x00H\xb7\x11\xd0\x00\x00\x00\x00I\xcb\xfa\xe0\x00\x00\x00\x00J\xa0<`\x00\x00\x00\x00K\xad.\x9c\x00\x00\x00\x00La\xbd\xd0\x00\x00\x00\x00M\x94\xf9\x9c\x00\x00\x00\x00N5\xc2P\x00\x00\x00\x00Ot\xdb`\x00\x00\x00\x00P[\x91\xe0\x00\x00\x00\x00QT\xbd`\x00\x00\x00\x00RD\xa0P\x00\x00\x00\x00S4\x9f`\x00\x00\x00\x00TIlP\x00\x00\x00\x00U\x15\xd2\xe0\x00\x00\x00\x00V)\\`\x00\x00\x00\x00V\xf5\xc2\xf0\x00\x00\x00\x00X\x13\xca`\x00\x00\x00\x00Xդ\xf0\x00\x00\x00\x00Y\xf3\xac`\x00\x00\x00\x00Z\xb5\x86\xf0\x00\x00\x00\x00[ӎ`\x00\x00\x00\x00\\\x9dC\xe0\x00\x00\x00\x00]\xb3bP\x00\x00\x00\x00^~w`\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x00\x00 P\x00\x00\x00\x00*0\x01\x04\x00\x00\x1c \x00\t\x00\x00*0\x01\r\x00\x00\x1c \x00\x11LMT\x00EEST\x00EET\x00IDT\x00IST\x00\nEET-2EEST,M3.4.4/48,M10.4.4/49\n",
+		fileName:   "2021a_Asia_Gaza",
 		date:       func(loc *time.Location) time.Time { return time.Date(2020, time.October, 29, 15, 30, 0, 0, loc) },
 		wantName:   "EET",
 		wantOffset: 7200,
@@ -217,7 +217,7 @@ var slimTests = []struct {
 	{
 		// 2021a slim tzdata for Europe/Dublin.
 		zoneName:   "Europe/Dublin",
-		tzData:     "TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x91\x00\x00\x00\x08\x00\x00\x00\x14\xff\xff\xff\xffW\xd1\n\xdc\xff\xff\xff\xff\x9b&\xb3\x91\xff\xff\xff\xff\x9b\xd6\x0b\x11\xff\xff\xff\xff\x9c\xcf0\xa0\xff\xff\xff\xff\x9d\xa4\xc3\xa0\xff\xff\xff\xff\x9e\x9c\x9d\xa0\xff\xff\xff\xff\x9f\x97\x1a\xa0\xff\xff\xff\xff\xa0\x85\xba\x20\xff\xff\xff\xff\xa1v\xfc\xa0\xff\xff\xff\xff\xa2e\x9c\x20\xff\xff\xff\xff\xa3{\xc8\xa0\xff\xff\xff\xff\xa4N\xb8\xa0\xff\xff\xff\xff\xa5?\xfb\x20\xff\xff\xff\xff\xa6%`\x20\xff\xff\xff\xff\xa7'\xc6\x20\xff\xff\xff\xff\xa8*,\x20\xff\xff\xff\xff\xa8\xeb\xf8\xa0\xff\xff\xff\xff\xaa\x00\xd3\xa0\xff\xff\xff\xff\xaa\xd5\x15\x20\xff\xff\xff\xff\xab\xe9\xf0\x20\xff\xff\xff\xff\xac\xc7l\x20\xff\xff\xff\xff\xad\xc9\xd2\x20\xff\xff\xff\xff\xae\xa7N\x20\xff\xff\xff\xff\xaf\xa0y\xa0\xff\xff\xff\xff\xb0\x870\x20\xff\xff\xff\xff\xb1\x92\xd0\xa0\xff\xff\xff\xff\xb2pL\xa0\xff\xff\xff\xff\xb3r\xb2\xa0\xff\xff\xff\xff\xb4P.\xa0\xff\xff\xff\xff\xb5IZ\x20\xff\xff\xff\xff\xb60\x10\xa0\xff\xff\xff\xff\xb72v\xa0\xff\xff\xff\xff\xb8\x0f\xf2\xa0\xff\xff\xff\xff\xb9\x12X\xa0\xff\xff\xff\xff\xb9\xef\xd4\xa0\xff\xff\xff\xff\xba\xe9\x00\x20\xff\xff\xff\xff\xbb\xd8\xf1\x20\xff\xff\xff\xff\xbc\xdbW\x20\xff\xff\xff\xff\xbd\xb8\xd3\x20\xff\xff\xff\xff\xbe\xb1\xfe\xa0\xff\xff\xff\xff\xbf\x98\xb5\x20\xff\xff\xff\xff\xc0\x9b\x1b\x20\xff\xff\xff\xff\xc1x\x97\x20\xff\xff\xff\xff\xc2z\xfd\x20\xff\xff\xff\xff\xc3Xy\x20\xff\xff\xff\xff\xc4Q\xa4\xa0\xff\xff\xff\xff\xc58[\x20\xff\xff\xff\xff\xc6:\xc1\x20\xff\xff\xff\xff\xc7X\xd6\xa0\xff\xff\xff\xff\xc7\xda\x09\xa0\xff\xff\xff\xff\xd4I\xe0\x20\xff\xff\xff\xff\xd5\x1e!\xa0\xff\xff\xff\xff\xd6N\xac\x20\xff\xff\xff\xff\xd7,(\x20\xff\xff\xff\xff\xd8.\x8e\x20\xff\xff\xff\xff\xd8\xf9\x95\x20\xff\xff\xff\xff\xda\x0ep\x20\xff\xff\xff\xff\xda\xeb\xec\x20\xff\xff\xff\xff\xdb\xe5\x17\xa0\xff\xff\xff\xff\xdc\xcb\xce\x20\xff\xff\xff\xff\xdd\xc4\xf9\xa0\xff\xff\xff\xff\xde\xb4\xea\xa0\xff\xff\xff\xff\xdf\xae\x16\x20\xff\xff\xff\xff\xe0\x94\xcc\xa0\xff\xff\xff\xff\xe1rH\xa0\xff\xff\xff\xff\xe2kt\x20\xff\xff\xff\xff\xe3R*\xa0\xff\xff\xff\xff\xe4T\x90\xa0\xff\xff\xff\xff\xe52\x0c\xa0\xff\xff\xff\xff\xe6=\xad\x20\xff\xff\xff\xff\xe7\x1b)\x20\xff\xff\xff\xff\xe8\x14T\xa0\xff\xff\xff\xff\xe8\xfb\x0b\x20\xff\xff\xff\xff\xe9\xfdq\x20\xff\xff\xff\xff\xea\xda\xed\x20\xff\xff\xff\xff\xeb\xddS\x20\xff\xff\xff\xff\xec\xba\xcf\x20\xff\xff\xff\xff\xed\xb3\xfa\xa0\xff\xff\xff\xff\xee\x9a\xb1\x20\xff\xff\xff\xff\xef\x81g\xa0\xff\xff\xff\xff\xf0\x9f}\x20\xff\xff\xff\xff\xf1aI\xa0\xff\xff\xff\xff\xf2\x7f_\x20\xff\xff\xff\xff\xf3Jf\x20\xff\xff\xff\xff\xf4_A\x20\xff\xff\xff\xff\xf5!\x0d\xa0\xff\xff\xff\xff\xf6?#\x20\xff\xff\xff\xff\xf7\x00\xef\xa0\xff\xff\xff\xff\xf8\x1f\x05\x20\xff\xff\xff\xff\xf8\xe0\xd1\xa0\xff\xff\xff\xff\xf9\xfe\xe7\x20\xff\xff\xff\xff\xfa\xc0\xb3\xa0\xff\xff\xff\xff\xfb\xe8\x03\xa0\xff\xff\xff\xff\xfc{\xab\xa0\xff\xff\xff\xff\xfd\xc7\xbbp\x00\x00\x00\x00\x03p\xc6\x20\x00\x00\x00\x00\x04)X\x20\x00\x00\x00\x00\x05P\xa8\x20\x00\x00\x00\x00\x06\x09:\x20\x00\x00\x00\x00\x070\x8a\x20\x00\x00\x00\x00\x07\xe9\x1c\x20\x00\x00\x00\x00\x09\x10l\x20\x00\x00\x00\x00\x09\xc8\xfe\x20\x00\x00\x00\x00\n\xf0N\x20\x00\x00\x00\x00\x0b\xb2\x1a\xa0\x00\x00\x00\x00\x0c\xd00\x20\x00\x00\x00\x00\x0d\x91\xfc\xa0\x00\x00\x00\x00\x0e\xb0\x12\x20\x00\x00\x00\x00\x0fq\xde\xa0\x00\x00\x00\x00\x10\x99.\xa0\x00\x00\x00\x00\x11Q\xc0\xa0\x00\x00\x00\x00\x12y\x10\xa0\x00\x00\x00\x00\x131\xa2\xa0\x00\x00\x00\x00\x14X\xf2\xa0\x00\x00\x00\x00\x15#\xeb\x90\x00\x00\x00\x00\x168\xc6\x90\x00\x00\x00\x00\x17\x03\xcd\x90\x00\x00\x00\x00\x18\x18\xa8\x90\x00\x00\x00\x00\x18\xe3\xaf\x90\x00\x00\x00\x00\x19\xf8\x8a\x90\x00\x00\x00\x00\x1a\xc3\x91\x90\x00\x00\x00\x00\x1b\xe1\xa7\x10\x00\x00\x00\x00\x1c\xac\xae\x10\x00\x00\x00\x00\x1d\xc1\x89\x10\x00\x00\x00\x00\x1e\x8c\x90\x10\x00\x00\x00\x00\x1f\xa1k\x10\x00\x00\x00\x00\x20lr\x10\x00\x00\x00\x00!\x81M\x10\x00\x00\x00\x00\x22LT\x10\x00\x00\x00\x00#a/\x10\x00\x00\x00\x00$,6\x10\x00\x00\x00\x00%JK\x90\x00\x00\x00\x00&\x0c\x18\x10\x00\x00\x00\x00'*-\x90\x00\x00\x00\x00'\xf54\x90\x00\x00\x00\x00)\n\x0f\x90\x00\x00\x00\x00)\xd5\x16\x90\x00\x00\x00\x00*\xe9\xf1\x90\x00\x00\x00\x00+\xb4\xf8\x90\x00\x00\x00\x00,\xc9\xd3\x90\x00\x00\x00\x00-\x94\xda\x90\x00\x00\x00\x00.\xa9\xb5\x90\x00\x00\x00\x00/t\xbc\x90\x00\x00\x00\x000\x89\x97\x90\x00\x00\x00\x001]\xd9\x10\x01\x02\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x04\x05\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\x06\x07\xff\xff\xfa$\x00\x00\xff\xff\xfa\x0f\x00\x04\x00\x00\x08\x1f\x01\x08\x00\x00\x0e\x10\x01\x0c\x00\x00\x00\x00\x00\x10\x00\x00\x0e\x10\x01\x08\x00\x00\x00\x00\x01\x10\x00\x00\x0e\x10\x00\x08LMT\x00DMT\x00IST\x00BST\x00GMT\x00\nIST-1GMT0,M10.5.0,M3.5.0/1\n",
+		fileName:   "2021a_Europe_Dublin",
 		date:       func(loc *time.Location) time.Time { return time.Date(2021, time.April, 2, 11, 12, 13, 0, loc) },
 		wantName:   "IST",
 		wantOffset: 3600,
@@ -226,9 +226,15 @@ var slimTests = []struct {
 
 func TestLoadLocationFromTZDataSlim(t *testing.T) {
 	for _, test := range slimTests {
-		reference, err := time.LoadLocationFromTZData(test.zoneName, []byte(test.tzData))
+		tzData, err := os.ReadFile("testdata/" + test.fileName)
 		if err != nil {
-			t.Fatal(err)
+			t.Error(err)
+			continue
+		}
+		reference, err := time.LoadLocationFromTZData(test.zoneName, tzData)
+		if err != nil {
+			t.Error(err)
+			continue
 		}
 
 		d := test.date(reference)
-- 
GitLab


From de7a87ef066d726eddcc47a018a2bc8fbd3793af Mon Sep 17 00:00:00 2001
From: Manlio Perillo <manlio.perillo@gmail.com>
Date: Tue, 13 Apr 2021 12:52:35 +0200
Subject: [PATCH 1567/2400] go/internal/gccgoimporter: replace os.MkdirTemp
 with T.TempDir

Updates #45402

Change-Id: Ie84795ed456883c0558fa9b5e3f2186f5f2c0fd9
Reviewed-on: https://go-review.googlesource.com/c/go/+/309356
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/go/internal/gccgoimporter/importer_test.go | 14 ++------------
 1 file changed, 2 insertions(+), 12 deletions(-)

diff --git a/src/go/internal/gccgoimporter/importer_test.go b/src/go/internal/gccgoimporter/importer_test.go
index b3f39312be..8a7ee1aa4f 100644
--- a/src/go/internal/gccgoimporter/importer_test.go
+++ b/src/go/internal/gccgoimporter/importer_test.go
@@ -149,21 +149,11 @@ func TestObjImporter(t *testing.T) {
 	}
 	t.Logf("gccgo version %d.%d", major, minor)
 
-	tmpdir, err := os.MkdirTemp("", "TestObjImporter")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpdir)
-
+	tmpdir := t.TempDir()
 	initmap := make(map[*types.Package]InitData)
 	imp := GetImporter([]string{tmpdir}, initmap)
 
-	artmpdir, err := os.MkdirTemp("", "TestObjImporter")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(artmpdir)
-
+	artmpdir := t.TempDir()
 	arinitmap := make(map[*types.Package]InitData)
 	arimp := GetImporter([]string{artmpdir}, arinitmap)
 
-- 
GitLab


From a89ace106f820a4f3b129c81ba0bcf0c48b5b7cd Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Sat, 10 Apr 2021 00:05:07 +0000
Subject: [PATCH 1568/2400] runtime: update debug call protocol for register
 ABI

The debug call tests currently assume that the target Go function is
ABI0; this is clearly no longer true when we switch to the new ABI, so
make the tests set up argument register state in the debug call handler
and copy back results returned in registers.

A small snag in calling a Go function that follows the new ABI is that
the debug call protocol depends on the AX register being set to a
specific value as it bounces in and out of the handler, but this
register is part of the new register ABI, so results end up being
clobbered. Use R12 instead.

Next, the new desugaring behavior for "go" statements means that
newosproc1 must always call a function with no frame; if it takes any
arguments, it closes over them and they're passed in the context
register. Currently when debugCallWrap creates a new goroutine, it uses
newosproc1 directly and passes a non-zero-sized frame, so that needs to
be updated. To fix this, briefly use the g's param field which is
otherwise only used for channels to pass an explicitly allocated object
containing the "closed over" variables. While we could manually do the
desugaring ourselves (we cannot do so automatically because the Go
compiler prevents heap-allocated closures in the runtime), that bakes in
more ABI details in a place that really doesn't need to care about them.

Finally, there's an old bug here where the context register was set up
in CX, so technically closure calls never worked. Oops. It was otherwise
harmless for other types of calls before, but now CX is an argument
register, so now that interferes with regular calls, too.

For #40724.

Change-Id: I652c25ed56a25741bb04c24cfb603063c099edde
Reviewed-on: https://go-review.googlesource.com/c/go/+/309169
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Austin Clements <austin@google.com>
Reviewed-by: Alessandro Arzilli <alessandro.arzilli@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/internal/objabi/funcid.go             |  4 +-
 src/runtime/asm_amd64.s                       | 45 +++++++------
 src/runtime/debug_test.go                     | 67 +++++++++++++------
 src/runtime/debugcall.go                      | 32 ++++++---
 .../export_debug_regabiargs_off_test.go       | 17 +++++
 .../export_debug_regabiargs_on_test.go        | 47 +++++++++++++
 src/runtime/export_debug_test.go              | 38 +++++++----
 src/runtime/mgcmark.go                        |  2 +-
 src/runtime/runtime2.go                       | 27 +++++---
 src/runtime/symtab.go                         |  2 +-
 10 files changed, 203 insertions(+), 78 deletions(-)
 create mode 100644 src/runtime/export_debug_regabiargs_off_test.go
 create mode 100644 src/runtime/export_debug_regabiargs_on_test.go

diff --git a/src/cmd/internal/objabi/funcid.go b/src/cmd/internal/objabi/funcid.go
index 2634106cdf..93ebd7be94 100644
--- a/src/cmd/internal/objabi/funcid.go
+++ b/src/cmd/internal/objabi/funcid.go
@@ -28,7 +28,7 @@ const (
 	FuncID_asmcgocall
 	FuncID_asyncPreempt
 	FuncID_cgocallback
-	FuncID_debugCallV1
+	FuncID_debugCallV2
 	FuncID_gcBgMarkWorker
 	FuncID_goexit
 	FuncID_gogo
@@ -53,7 +53,7 @@ var funcIDs = map[string]FuncID{
 	"asmcgocall":       FuncID_asmcgocall,
 	"asyncPreempt":     FuncID_asyncPreempt,
 	"cgocallback":      FuncID_cgocallback,
-	"debugCallV1":      FuncID_debugCallV1,
+	"debugCallV2":      FuncID_debugCallV2,
 	"gcBgMarkWorker":   FuncID_gcBgMarkWorker,
 	"go":               FuncID_rt0_go,
 	"goexit":           FuncID_goexit,
diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index e883f20045..a88cd17e6b 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -231,9 +231,9 @@ ok:
 	CALL	runtime·abort(SB)	// mstart should never return
 	RET
 
-	// Prevent dead-code elimination of debugCallV1, which is
+	// Prevent dead-code elimination of debugCallV2, which is
 	// intended to be called by debuggers.
-	MOVQ	$runtime·debugCallV1<ABIInternal>(SB), AX
+	MOVQ	$runtime·debugCallV2<ABIInternal>(SB), AX
 	RET
 
 // mainPC is a function value for runtime.main, to be passed to newproc.
@@ -1763,7 +1763,7 @@ TEXT runtime·gcWriteBarrierR9<ABIInternal>(SB),NOSPLIT,$0
 DATA	debugCallFrameTooLarge<>+0x00(SB)/20, $"call frame too large"
 GLOBL	debugCallFrameTooLarge<>(SB), RODATA, $20	// Size duplicated below
 
-// debugCallV1 is the entry point for debugger-injected function
+// debugCallV2 is the entry point for debugger-injected function
 // calls on running goroutines. It informs the runtime that a
 // debug call has been injected and creates a call frame for the
 // debugger to fill in.
@@ -1776,7 +1776,7 @@ GLOBL	debugCallFrameTooLarge<>(SB), RODATA, $20	// Size duplicated below
 //    after step 2).
 // 4. Save all machine registers (including flags and XMM reigsters)
 //    so they can be restored later by the debugger.
-// 5. Set the PC to debugCallV1 and resume execution.
+// 5. Set the PC to debugCallV2 and resume execution.
 //
 // If the goroutine is in state _Grunnable, then it's not generally
 // safe to inject a call because it may return out via other runtime
@@ -1786,19 +1786,19 @@ GLOBL	debugCallFrameTooLarge<>(SB), RODATA, $20	// Size duplicated below
 //
 // If the goroutine is in any other state, it's not safe to inject a call.
 //
-// This function communicates back to the debugger by setting RAX and
+// This function communicates back to the debugger by setting R12 and
 // invoking INT3 to raise a breakpoint signal. See the comments in the
 // implementation for the protocol the debugger is expected to
 // follow. InjectDebugCall in the runtime tests demonstrates this protocol.
 //
 // The debugger must ensure that any pointers passed to the function
 // obey escape analysis requirements. Specifically, it must not pass
-// a stack pointer to an escaping argument. debugCallV1 cannot check
+// a stack pointer to an escaping argument. debugCallV2 cannot check
 // this invariant.
 //
 // This is ABIInternal because Go code injects its PC directly into new
 // goroutine stacks.
-TEXT runtime·debugCallV1<ABIInternal>(SB),NOSPLIT,$152-0
+TEXT runtime·debugCallV2<ABIInternal>(SB),NOSPLIT,$152-0
 	// Save all registers that may contain pointers so they can be
 	// conservatively scanned.
 	//
@@ -1838,10 +1838,10 @@ TEXT runtime·debugCallV1<ABIInternal>(SB),NOSPLIT,$152-0
 	MOVQ	AX, 0(SP)
 	MOVQ	16(SP), AX
 	MOVQ	AX, 8(SP)
-	// Set AX to 8 and invoke INT3. The debugger should get the
+	// Set R12 to 8 and invoke INT3. The debugger should get the
 	// reason a call can't be injected from the top of the stack
 	// and resume execution.
-	MOVQ	$8, AX
+	MOVQ	$8, R12
 	BYTE	$0xcc
 	JMP	restore
 
@@ -1849,17 +1849,18 @@ good:
 	// Registers are saved and it's safe to make a call.
 	// Open up a call frame, moving the stack if necessary.
 	//
-	// Once the frame is allocated, this will set AX to 0 and
+	// Once the frame is allocated, this will set R12 to 0 and
 	// invoke INT3. The debugger should write the argument
-	// frame for the call at SP, push the trapping PC on the
-	// stack, set the PC to the function to call, set RCX to point
-	// to the closure (if a closure call), and resume execution.
+	// frame for the call at SP, set up argument registers, push
+	// the trapping PC on the stack, set the PC to the function to
+	// call, set RDX to point to the closure (if a closure call),
+	// and resume execution.
 	//
-	// If the function returns, this will set AX to 1 and invoke
+	// If the function returns, this will set R12 to 1 and invoke
 	// INT3. The debugger can then inspect any return value saved
-	// on the stack at SP and resume execution again.
+	// on the stack at SP and in registers and resume execution again.
 	//
-	// If the function panics, this will set AX to 2 and invoke INT3.
+	// If the function panics, this will set R12 to 2 and invoke INT3.
 	// The interface{} value of the panic will be at SP. The debugger
 	// can inspect the panic value and resume execution again.
 #define DEBUG_CALL_DISPATCH(NAME,MAXSIZE)	\
@@ -1887,16 +1888,16 @@ good:
 	MOVQ	$debugCallFrameTooLarge<>(SB), AX
 	MOVQ	AX, 0(SP)
 	MOVQ	$20, 8(SP) // length of debugCallFrameTooLarge string
-	MOVQ	$8, AX
+	MOVQ	$8, R12
 	BYTE	$0xcc
 	JMP	restore
 
 restore:
 	// Calls and failures resume here.
 	//
-	// Set AX to 16 and invoke INT3. The debugger should restore
+	// Set R12 to 16 and invoke INT3. The debugger should restore
 	// all registers except RIP and RSP and resume execution.
-	MOVQ	$16, AX
+	MOVQ	$16, R12
 	BYTE	$0xcc
 	// We must not modify flags after this point.
 
@@ -1925,9 +1926,9 @@ restore:
 #define DEBUG_CALL_FN(NAME,MAXSIZE)		\
 TEXT NAME(SB),WRAPPER,$MAXSIZE-0;		\
 	NO_LOCAL_POINTERS;			\
-	MOVQ	$0, AX;				\
+	MOVQ	$0, R12;				\
 	BYTE	$0xcc;				\
-	MOVQ	$1, AX;				\
+	MOVQ	$1, R12;				\
 	BYTE	$0xcc;				\
 	RET
 DEBUG_CALL_FN(debugCall32<>, 32)
@@ -1950,7 +1951,7 @@ TEXT runtime·debugCallPanicked(SB),NOSPLIT,$16-16
 	MOVQ	AX, 0(SP)
 	MOVQ	val_data+8(FP), AX
 	MOVQ	AX, 8(SP)
-	MOVQ	$2, AX
+	MOVQ	$2, R12
 	BYTE	$0xcc
 	RET
 
diff --git a/src/runtime/debug_test.go b/src/runtime/debug_test.go
index 7f9e460303..f74383457f 100644
--- a/src/runtime/debug_test.go
+++ b/src/runtime/debug_test.go
@@ -9,17 +9,16 @@
 // spends all of its time in the race runtime, which isn't a safe
 // point.
 
-// TODO(register args): We skip this under GOEXPERIMENT=regabidefer
-// because debugCallWrap passes a non-empty frame to newproc1,
-// triggering a panic.
-
-//go:build amd64 && linux && !race && !goexperiment.regabidefer
-// +build amd64,linux,!race,!goexperiment.regabidefer
+//go:build amd64 && linux && !race
+// +build amd64,linux,!race
 
 package runtime_test
 
 import (
 	"fmt"
+	"internal/abi"
+	"internal/goexperiment"
+	"math"
 	"os"
 	"regexp"
 	"runtime"
@@ -119,21 +118,49 @@ func TestDebugCall(t *testing.T) {
 	g, after := startDebugCallWorker(t)
 	defer after()
 
+	type stackArgs struct {
+		x0    int
+		x1    float64
+		y0Ret int
+		y1Ret float64
+	}
+
 	// Inject a call into the debugCallWorker goroutine and test
 	// basic argument and result passing.
-	var args struct {
-		x    int
-		yRet int
+	fn := func(x int, y float64) (y0Ret int, y1Ret float64) {
+		return x + 1, y + 1.0
 	}
-	fn := func(x int) (yRet int) {
-		return x + 1
+	var args *stackArgs
+	var regs abi.RegArgs
+	intRegs := regs.Ints[:]
+	floatRegs := regs.Floats[:]
+	fval := float64(42.0)
+	if goexperiment.RegabiArgs {
+		intRegs[0] = 42
+		floatRegs[0] = math.Float64bits(fval)
+	} else {
+		args = &stackArgs{
+			x0: 42,
+			x1: 42.0,
+		}
 	}
-	args.x = 42
-	if _, err := runtime.InjectDebugCall(g, fn, &args, debugCallTKill, false); err != nil {
+	if _, err := runtime.InjectDebugCall(g, fn, &regs, args, debugCallTKill, false); err != nil {
 		t.Fatal(err)
 	}
-	if args.yRet != 43 {
-		t.Fatalf("want 43, got %d", args.yRet)
+	var result0 int
+	var result1 float64
+	if goexperiment.RegabiArgs {
+		result0 = int(intRegs[0])
+		result1 = math.Float64frombits(floatRegs[0])
+	} else {
+		result0 = args.y0Ret
+		result1 = args.y1Ret
+	}
+	if result0 != 43 {
+		t.Errorf("want 43, got %d", result0)
+	}
+	if result1 != fval+1 {
+		t.Errorf("want 43, got %f", result1)
 	}
 }
 
@@ -158,7 +185,7 @@ func TestDebugCallLarge(t *testing.T) {
 		args.in[i] = i
 		want[i] = i + 1
 	}
-	if _, err := runtime.InjectDebugCall(g, fn, &args, debugCallTKill, false); err != nil {
+	if _, err := runtime.InjectDebugCall(g, fn, nil, &args, debugCallTKill, false); err != nil {
 		t.Fatal(err)
 	}
 	if want != args.out {
@@ -171,7 +198,7 @@ func TestDebugCallGC(t *testing.T) {
 	defer after()
 
 	// Inject a call that performs a GC.
-	if _, err := runtime.InjectDebugCall(g, runtime.GC, nil, debugCallTKill, false); err != nil {
+	if _, err := runtime.InjectDebugCall(g, runtime.GC, nil, nil, debugCallTKill, false); err != nil {
 		t.Fatal(err)
 	}
 }
@@ -182,7 +209,7 @@ func TestDebugCallGrowStack(t *testing.T) {
 
 	// Inject a call that grows the stack. debugCallWorker checks
 	// for stack pointer breakage.
-	if _, err := runtime.InjectDebugCall(g, func() { growStack(nil) }, nil, debugCallTKill, false); err != nil {
+	if _, err := runtime.InjectDebugCall(g, func() { growStack(nil) }, nil, nil, debugCallTKill, false); err != nil {
 		t.Fatal(err)
 	}
 }
@@ -218,7 +245,7 @@ func TestDebugCallUnsafePoint(t *testing.T) {
 		runtime.Gosched()
 	}
 
-	_, err := runtime.InjectDebugCall(g, func() {}, nil, debugCallTKill, true)
+	_, err := runtime.InjectDebugCall(g, func() {}, nil, nil, debugCallTKill, true)
 	if msg := "call not at safe point"; err == nil || err.Error() != msg {
 		t.Fatalf("want %q, got %s", msg, err)
 	}
@@ -242,7 +269,7 @@ func TestDebugCallPanic(t *testing.T) {
 	}()
 	g := <-ready
 
-	p, err := runtime.InjectDebugCall(g, func() { panic("test") }, nil, debugCallTKill, false)
+	p, err := runtime.InjectDebugCall(g, func() { panic("test") }, nil, nil, debugCallTKill, false)
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/src/runtime/debugcall.go b/src/runtime/debugcall.go
index 2fe0b1d12f..faddf59eed 100644
--- a/src/runtime/debugcall.go
+++ b/src/runtime/debugcall.go
@@ -16,7 +16,7 @@ const (
 	debugCallUnsafePoint = "call not at safe point"
 )
 
-func debugCallV1()
+func debugCallV2()
 func debugCallPanicked(val interface{})
 
 // debugCallCheck checks whether it is safe to inject a debugger
@@ -96,7 +96,7 @@ func debugCallCheck(pc uintptr) string {
 // function at PC dispatch.
 //
 // This must be deeply nosplit because there are untyped values on the
-// stack from debugCallV1.
+// stack from debugCallV2.
 //
 //go:nosplit
 func debugCallWrap(dispatch uintptr) {
@@ -108,14 +108,16 @@ func debugCallWrap(dispatch uintptr) {
 	// Create a new goroutine to execute the call on. Run this on
 	// the system stack to avoid growing our stack.
 	systemstack(func() {
-		var args struct {
-			dispatch uintptr
-			callingG *g
-		}
-		args.dispatch = dispatch
-		args.callingG = gp
+		// TODO(mknyszek): It would be nice to wrap these arguments in an allocated
+		// closure and start the goroutine with that closure, but the compiler disallows
+		// implicit closure allocation in the runtime.
 		fn := debugCallWrap1
-		newg := newproc1(*(**funcval)(unsafe.Pointer(&fn)), unsafe.Pointer(&args), int32(unsafe.Sizeof(args)), gp, callerpc)
+		newg := newproc1(*(**funcval)(unsafe.Pointer(&fn)), nil, 0, gp, callerpc)
+		args := &debugCallWrapArgs{
+			dispatch: dispatch,
+			callingG: gp,
+		}
+		newg.param = unsafe.Pointer(args)
 
 		// If the current G is locked, then transfer that
 		// locked-ness to the new goroutine.
@@ -185,9 +187,19 @@ func debugCallWrap(dispatch uintptr) {
 	gp.asyncSafePoint = false
 }
 
+type debugCallWrapArgs struct {
+	dispatch uintptr
+	callingG *g
+}
+
 // debugCallWrap1 is the continuation of debugCallWrap on the callee
 // goroutine.
-func debugCallWrap1(dispatch uintptr, callingG *g) {
+func debugCallWrap1() {
+	gp := getg()
+	args := (*debugCallWrapArgs)(gp.param)
+	dispatch, callingG := args.dispatch, args.callingG
+	gp.param = nil
+
 	// Dispatch call and trap panics.
 	debugCallWrap2(dispatch)
 
diff --git a/src/runtime/export_debug_regabiargs_off_test.go b/src/runtime/export_debug_regabiargs_off_test.go
new file mode 100644
index 0000000000..fce37ab4d1
--- /dev/null
+++ b/src/runtime/export_debug_regabiargs_off_test.go
@@ -0,0 +1,17 @@
+// Copyright 2021 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.
+
+//go:build amd64 && linux && !goexperiment.regabiargs
+// +build amd64,linux
+// +build !goexperiment.regabiargs
+
+package runtime
+
+import "internal/abi"
+
+func storeRegArgs(dst *sigcontext, src *abi.RegArgs) {
+}
+
+func loadRegArgs(dst *abi.RegArgs, src *sigcontext) {
+}
diff --git a/src/runtime/export_debug_regabiargs_on_test.go b/src/runtime/export_debug_regabiargs_on_test.go
new file mode 100644
index 0000000000..3c65127e56
--- /dev/null
+++ b/src/runtime/export_debug_regabiargs_on_test.go
@@ -0,0 +1,47 @@
+// Copyright 2021 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.
+
+//go:build amd64 && linux && goexperiment.regabiargs
+// +build amd64,linux
+// +build goexperiment.regabiargs
+
+package runtime
+
+import "internal/abi"
+
+// storeRegArgs sets up argument registers in the signal
+// context state from an abi.RegArgs.
+//
+// Both src and dst must be non-nil.
+func storeRegArgs(dst *sigcontext, src *abi.RegArgs) {
+	dst.rax = uint64(src.Ints[0])
+	dst.rbx = uint64(src.Ints[1])
+	dst.rcx = uint64(src.Ints[2])
+	dst.rdi = uint64(src.Ints[3])
+	dst.rsi = uint64(src.Ints[4])
+	dst.r8 = uint64(src.Ints[5])
+	dst.r9 = uint64(src.Ints[6])
+	dst.r10 = uint64(src.Ints[7])
+	dst.r11 = uint64(src.Ints[8])
+	for i := range src.Floats {
+		dst.fpstate._xmm[i].element[0] = uint32(src.Floats[i] >> 0)
+		dst.fpstate._xmm[i].element[1] = uint32(src.Floats[i] >> 32)
+	}
+}
+
+func loadRegArgs(dst *abi.RegArgs, src *sigcontext) {
+	dst.Ints[0] = uintptr(src.rax)
+	dst.Ints[1] = uintptr(src.rbx)
+	dst.Ints[2] = uintptr(src.rcx)
+	dst.Ints[3] = uintptr(src.rdi)
+	dst.Ints[4] = uintptr(src.rsi)
+	dst.Ints[5] = uintptr(src.r8)
+	dst.Ints[6] = uintptr(src.r9)
+	dst.Ints[7] = uintptr(src.r10)
+	dst.Ints[8] = uintptr(src.r11)
+	for i := range dst.Floats {
+		dst.Floats[i] = uint64(src.fpstate._xmm[i].element[0]) << 0
+		dst.Floats[i] |= uint64(src.fpstate._xmm[i].element[1]) << 32
+	}
+}
diff --git a/src/runtime/export_debug_test.go b/src/runtime/export_debug_test.go
index 18ccecd5cd..fe4c9045c1 100644
--- a/src/runtime/export_debug_test.go
+++ b/src/runtime/export_debug_test.go
@@ -8,19 +8,22 @@
 package runtime
 
 import (
+	"internal/abi"
 	"runtime/internal/sys"
 	"unsafe"
 )
 
-// InjectDebugCall injects a debugger call to fn into g. args must be
-// a pointer to a valid call frame (including arguments and return
-// space) for fn, or nil. tkill must be a function that will send
-// SIGTRAP to thread ID tid. gp must be locked to its OS thread and
+// InjectDebugCall injects a debugger call to fn into g. regArgs must
+// contain any arguments to fn that are passed in registers, according
+// to the internal Go ABI. It may be nil if no arguments are passed in
+// registers to fn. args must be a pointer to a valid call frame (including
+// arguments and return space) for fn, or nil. tkill must be a function that
+// will send SIGTRAP to thread ID tid. gp must be locked to its OS thread and
 // running.
 //
 // On success, InjectDebugCall returns the panic value of fn or nil.
 // If fn did not panic, its results will be available in args.
-func InjectDebugCall(gp *g, fn, args interface{}, tkill func(tid int) error, returnOnUnsafePoint bool) (interface{}, error) {
+func InjectDebugCall(gp *g, fn interface{}, regArgs *abi.RegArgs, stackArgs interface{}, tkill func(tid int) error, returnOnUnsafePoint bool) (interface{}, error) {
 	if gp.lockedm == 0 {
 		return nil, plainError("goroutine not locked to thread")
 	}
@@ -36,7 +39,7 @@ func InjectDebugCall(gp *g, fn, args interface{}, tkill func(tid int) error, ret
 	}
 	fv := (*funcval)(f.data)
 
-	a := efaceOf(&args)
+	a := efaceOf(&stackArgs)
 	if a._type != nil && a._type.kind&kindMask != kindPtr {
 		return nil, plainError("args must be a pointer or nil")
 	}
@@ -51,7 +54,7 @@ func InjectDebugCall(gp *g, fn, args interface{}, tkill func(tid int) error, ret
 	// gp may not be running right now, but we can still get the M
 	// it will run on since it's locked.
 	h.mp = gp.lockedm.ptr()
-	h.fv, h.argp, h.argSize = fv, argp, argSize
+	h.fv, h.regArgs, h.argp, h.argSize = fv, regArgs, argp, argSize
 	h.handleF = h.handle // Avoid allocating closure during signal
 
 	defer func() { testSigtrap = nil }()
@@ -91,6 +94,7 @@ type debugCallHandler struct {
 	gp      *g
 	mp      *m
 	fv      *funcval
+	regArgs *abi.RegArgs
 	argp    unsafe.Pointer
 	argSize uintptr
 	panic   interface{}
@@ -120,8 +124,8 @@ func (h *debugCallHandler) inject(info *siginfo, ctxt *sigctxt, gp2 *g) bool {
 		h.savedRegs = *ctxt.regs()
 		h.savedFP = *h.savedRegs.fpstate
 		h.savedRegs.fpstate = nil
-		// Set PC to debugCallV1.
-		ctxt.set_rip(uint64(funcPC(debugCallV1)))
+		// Set PC to debugCallV2.
+		ctxt.set_rip(uint64(funcPC(debugCallV2)))
 		// Call injected. Switch to the debugCall protocol.
 		testSigtrap = h.handleF
 	case _Grunnable:
@@ -153,22 +157,28 @@ func (h *debugCallHandler) handle(info *siginfo, ctxt *sigctxt, gp2 *g) bool {
 		return false
 	}
 
-	switch status := ctxt.rax(); status {
+	switch status := ctxt.r12(); status {
 	case 0:
-		// Frame is ready. Copy the arguments to the frame.
+		// Frame is ready. Copy the arguments to the frame and to registers.
 		sp := ctxt.rsp()
 		memmove(unsafe.Pointer(uintptr(sp)), h.argp, h.argSize)
+		if h.regArgs != nil {
+			storeRegArgs(ctxt.regs(), h.regArgs)
+		}
 		// Push return PC.
 		sp -= sys.PtrSize
 		ctxt.set_rsp(sp)
 		*(*uint64)(unsafe.Pointer(uintptr(sp))) = ctxt.rip()
 		// Set PC to call and context register.
 		ctxt.set_rip(uint64(h.fv.fn))
-		ctxt.regs().rcx = uint64(uintptr(unsafe.Pointer(h.fv)))
+		ctxt.regs().rdx = uint64(uintptr(unsafe.Pointer(h.fv)))
 	case 1:
-		// Function returned. Copy frame back out.
+		// Function returned. Copy frame and result registers back out.
 		sp := ctxt.rsp()
 		memmove(h.argp, unsafe.Pointer(uintptr(sp)), h.argSize)
+		if h.regArgs != nil {
+			loadRegArgs(h.regArgs, ctxt.regs())
+		}
 	case 2:
 		// Function panicked. Copy panic out.
 		sp := ctxt.rsp()
@@ -191,7 +201,7 @@ func (h *debugCallHandler) handle(info *siginfo, ctxt *sigctxt, gp2 *g) bool {
 		// Done
 		notewakeup(&h.done)
 	default:
-		h.err = plainError("unexpected debugCallV1 status")
+		h.err = plainError("unexpected debugCallV2 status")
 		notewakeup(&h.done)
 	}
 	// Resume execution.
diff --git a/src/runtime/mgcmark.go b/src/runtime/mgcmark.go
index cb73caf3bb..061d2f5c9d 100644
--- a/src/runtime/mgcmark.go
+++ b/src/runtime/mgcmark.go
@@ -872,7 +872,7 @@ func scanframeworker(frame *stkframe, state *stackScanState, gcw *gcWork) {
 	}
 
 	isAsyncPreempt := frame.fn.valid() && frame.fn.funcID == funcID_asyncPreempt
-	isDebugCall := frame.fn.valid() && frame.fn.funcID == funcID_debugCallV1
+	isDebugCall := frame.fn.valid() && frame.fn.funcID == funcID_debugCallV2
 	if state.conservative || isAsyncPreempt || isDebugCall {
 		if debugScanConservative {
 			println("conservatively scanning function", funcname(frame.fn), "at PC", hex(frame.continpc))
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index 402d49ac82..9e547f8200 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -412,14 +412,25 @@ type g struct {
 	stackguard0 uintptr // offset known to liblink
 	stackguard1 uintptr // offset known to liblink
 
-	_panic       *_panic // innermost panic - offset known to liblink
-	_defer       *_defer // innermost defer
-	m            *m      // current m; offset known to arm liblink
-	sched        gobuf
-	syscallsp    uintptr        // if status==Gsyscall, syscallsp = sched.sp to use during gc
-	syscallpc    uintptr        // if status==Gsyscall, syscallpc = sched.pc to use during gc
-	stktopsp     uintptr        // expected sp at top of stack, to check in traceback
-	param        unsafe.Pointer // passed parameter on wakeup
+	_panic    *_panic // innermost panic - offset known to liblink
+	_defer    *_defer // innermost defer
+	m         *m      // current m; offset known to arm liblink
+	sched     gobuf
+	syscallsp uintptr // if status==Gsyscall, syscallsp = sched.sp to use during gc
+	syscallpc uintptr // if status==Gsyscall, syscallpc = sched.pc to use during gc
+	stktopsp  uintptr // expected sp at top of stack, to check in traceback
+	// param is a generic pointer parameter field used to pass
+	// values in particular contexts where other storage for the
+	// parameter would be difficult to find. It is currently used
+	// in three ways:
+	// 1. When a channel operation wakes up a blocked goroutine, it sets param to
+	//    point to the sudog of the completed blocking operation.
+	// 2. By gcAssistAlloc1 to signal back to its caller that the goroutine completed
+	//    the GC cycle. It is unsafe to do so in any other way, because the goroutine's
+	//    stack may have moved in the meantime.
+	// 3. By debugCallWrap to pass parameters to a new goroutine because allocating a
+	//    closure in the runtime is forbidden.
+	param        unsafe.Pointer
 	atomicstatus uint32
 	stackLock    uint32 // sigprof/scang lock; TODO: fold in to atomicstatus
 	goid         int64
diff --git a/src/runtime/symtab.go b/src/runtime/symtab.go
index cf759153e7..e8c7447f61 100644
--- a/src/runtime/symtab.go
+++ b/src/runtime/symtab.go
@@ -316,7 +316,7 @@ const (
 	funcID_asmcgocall
 	funcID_asyncPreempt
 	funcID_cgocallback
-	funcID_debugCallV1
+	funcID_debugCallV2
 	funcID_gcBgMarkWorker
 	funcID_goexit
 	funcID_gogo
-- 
GitLab


From 1a8f0a79619bee4b0040888a5703e38f8117d682 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Wed, 14 Apr 2021 15:40:01 -0400
Subject: [PATCH 1569/2400] runtime: fix data race in abi finalizer test

Fix a buglet in TestFinalizerRegisterABI that was causing problems
when run with GOEXPERIMENT=regabi.

Updates #40724.

Change-Id: I950c4aa3df69eada23e600f01e6804eb136ce806
Reviewed-on: https://go-review.googlesource.com/c/go/+/310077
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/abi_test.go | 37 +++++++++++++++++++++++++++----------
 1 file changed, 27 insertions(+), 10 deletions(-)

diff --git a/src/runtime/abi_test.go b/src/runtime/abi_test.go
index f50ed879d4..b82acfe325 100644
--- a/src/runtime/abi_test.go
+++ b/src/runtime/abi_test.go
@@ -17,21 +17,36 @@ import (
 	"os/exec"
 	"runtime"
 	"strings"
+	"sync"
 	"testing"
 	"time"
 )
 
-var regConfirmRun int
+var regConfirmRunIface int
+var regConfirmRunPtr int
+var regConfirmMU sync.Mutex
+
+func guardedRead(p *int) int {
+	regConfirmMU.Lock()
+	defer regConfirmMU.Unlock()
+	return *p
+}
+
+func guardedWrite(p *int, v int) {
+	regConfirmMU.Lock()
+	defer regConfirmMU.Unlock()
+	*p = v
+}
 
 //go:registerparams
 func regFinalizerPointer(v *Tint) (int, float32, [10]byte) {
-	regConfirmRun = *(*int)(v)
+	guardedWrite(&regConfirmRunPtr, *(*int)(v))
 	return 5151, 4.0, [10]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
 }
 
 //go:registerparams
 func regFinalizerIface(v Tinter) (int, float32, [10]byte) {
-	regConfirmRun = *(*int)(v.(*Tint))
+	guardedWrite(&regConfirmRunIface, *(*int)(v.(*Tint)))
 	return 5151, 4.0, [10]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
 }
 
@@ -81,14 +96,15 @@ func TestFinalizerRegisterABI(t *testing.T) {
 		name         string
 		fin          interface{}
 		confirmValue int
+		confirmRun   *int
 	}{
-		{"Pointer", regFinalizerPointer, -1},
-		{"Interface", regFinalizerIface, -2},
+		{"Pointer", regFinalizerPointer, -1, &regConfirmRunPtr},
+		{"Interface", regFinalizerIface, -2, &regConfirmRunIface},
 	}
 	for i := range tests {
 		test := &tests[i]
 		t.Run(test.name, func(t *testing.T) {
-			regConfirmRun = 0
+			guardedWrite(test.confirmRun, 0)
 
 			x := new(Tint)
 			*x = (Tint)(test.confirmValue)
@@ -102,14 +118,15 @@ func TestFinalizerRegisterABI(t *testing.T) {
 
 			for i := 0; i < 100; i++ {
 				time.Sleep(10 * time.Millisecond)
-				if regConfirmRun != 0 {
+				if guardedRead(test.confirmRun) != 0 {
 					break
 				}
 			}
-			if regConfirmRun == 0 {
+			v := guardedRead(test.confirmRun)
+			if v == 0 {
 				t.Fatal("finalizer failed to execute")
-			} else if regConfirmRun != test.confirmValue {
-				t.Fatalf("wrong finalizer executed? regConfirmRun = %d", regConfirmRun)
+			} else if v != test.confirmValue {
+				t.Fatalf("wrong finalizer executed? regConfirmRun = %d", v)
 			}
 		})
 	}
-- 
GitLab


From 23f8c203f026814ddc4ba4538f900d8151eb6840 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Sun, 11 Apr 2021 12:42:49 -0400
Subject: [PATCH 1570/2400] cmd/compile: rework/reduce partially lived argument
 spilling

In CL 307909 we generate code that spills pointer-typed argument
registers if it is part of an SSA-able aggregate. The current
code spill the register unconditionally. Sometimes it is
unnecessary, because it is already spilled, or it is never live.

This CL reworks the spill generation. We move it to the end of
compilation, after liveness analysis, so we have information about
if a spill is necessary, and only generate spills for the
necessary ones.

Change-Id: I8d60be9b2c47651aeda14f5e2d1bbd207c134b26
Reviewed-on: https://go-review.googlesource.com/c/go/+/309331
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/amd64/galign.go   |  1 +
 src/cmd/compile/internal/amd64/ssa.go      |  8 +++
 src/cmd/compile/internal/liveness/plive.go | 20 +++++--
 src/cmd/compile/internal/ssagen/arch.go    |  5 ++
 src/cmd/compile/internal/ssagen/ssa.go     | 63 +++++++++++++++++++---
 5 files changed, 87 insertions(+), 10 deletions(-)

diff --git a/src/cmd/compile/internal/amd64/galign.go b/src/cmd/compile/internal/amd64/galign.go
index 7845395538..2785aa0336 100644
--- a/src/cmd/compile/internal/amd64/galign.go
+++ b/src/cmd/compile/internal/amd64/galign.go
@@ -24,4 +24,5 @@ func Init(arch *ssagen.ArchInfo) {
 	arch.SSAGenValue = ssaGenValue
 	arch.SSAGenBlock = ssaGenBlock
 	arch.LoadRegResults = loadRegResults
+	arch.SpillArgReg = spillArgReg
 }
diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index e7b4fae016..fce3c6b820 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -11,6 +11,7 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
+	"cmd/compile/internal/objw"
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/types"
@@ -1364,3 +1365,10 @@ func loadRegResults(s *ssagen.State, f *ssa.Func) {
 		}
 	}
 }
+
+func spillArgReg(pp *objw.Progs, p *obj.Prog, f *ssa.Func, t *types.Type, reg int16, n *ir.Name, off int64) *obj.Prog {
+	p = pp.Append(p, storeByType(t), obj.TYPE_REG, reg, 0, obj.TYPE_MEM, 0, n.FrameOffset()+off)
+	p.To.Name = obj.NAME_PARAM
+	p.To.Sym = n.Linksym()
+	return p
+}
diff --git a/src/cmd/compile/internal/liveness/plive.go b/src/cmd/compile/internal/liveness/plive.go
index 4395aaeeb6..53feb6cc32 100644
--- a/src/cmd/compile/internal/liveness/plive.go
+++ b/src/cmd/compile/internal/liveness/plive.go
@@ -141,6 +141,11 @@ type liveness struct {
 
 	cache progeffectscache
 
+	// partLiveArgs includes input arguments (PPARAM) that may
+	// be partially live. That is, it is considered live because
+	// a part of it is used, but we may not initialize all parts.
+	partLiveArgs map[*ir.Name]bool
+
 	doClobber bool // Whether to clobber dead stack slots in this function.
 }
 
@@ -268,6 +273,12 @@ func (lv *liveness) valueEffects(v *ssa.Value) (int32, liveEffect) {
 		}
 	}
 
+	if n.Class == ir.PPARAM && !n.Addrtaken() && n.Type().Width > int64(types.PtrSize) {
+		// Only aggregate-typed arguments that are not address-taken can be
+		// partially live.
+		lv.partLiveArgs[n] = true
+	}
+
 	var effect liveEffect
 	// Read is a read, obviously.
 	//
@@ -394,6 +405,8 @@ func newliveness(fn *ir.Func, f *ssa.Func, vars []*ir.Name, idx map[*ir.Name]int
 
 	lv.markUnsafePoints()
 
+	lv.partLiveArgs = make(map[*ir.Name]bool)
+
 	lv.enableClobber()
 
 	return lv
@@ -1310,8 +1323,9 @@ func (lv *liveness) emit() (argsSym, liveSym *obj.LSym) {
 // Entry pointer for Compute analysis. Solves for the Compute of
 // pointer variables in the function and emits a runtime data
 // structure read by the garbage collector.
-// Returns a map from GC safe points to their corresponding stack map index.
-func Compute(curfn *ir.Func, f *ssa.Func, stkptrsize int64, pp *objw.Progs) Map {
+// Returns a map from GC safe points to their corresponding stack map index,
+// and a map that contains all input parameters that may be partially live.
+func Compute(curfn *ir.Func, f *ssa.Func, stkptrsize int64, pp *objw.Progs) (Map, map[*ir.Name]bool) {
 	// Construct the global liveness state.
 	vars, idx := getvariables(curfn)
 	lv := newliveness(curfn, f, vars, idx, stkptrsize)
@@ -1373,7 +1387,7 @@ func Compute(curfn *ir.Func, f *ssa.Func, stkptrsize int64, pp *objw.Progs) Map
 		p.To.Sym = x
 	}
 
-	return lv.livenessMap
+	return lv.livenessMap, lv.partLiveArgs
 }
 
 func (lv *liveness) emitStackObjects() *obj.LSym {
diff --git a/src/cmd/compile/internal/ssagen/arch.go b/src/cmd/compile/internal/ssagen/arch.go
index cfa0f1db5b..7215f42c05 100644
--- a/src/cmd/compile/internal/ssagen/arch.go
+++ b/src/cmd/compile/internal/ssagen/arch.go
@@ -5,8 +5,10 @@
 package ssagen
 
 import (
+	"cmd/compile/internal/ir"
 	"cmd/compile/internal/objw"
 	"cmd/compile/internal/ssa"
+	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 )
 
@@ -44,4 +46,7 @@ type ArchInfo struct {
 	// into registers. They are already in memory (PPARAMOUT nodes).
 	// Used in open-coded defer return path.
 	LoadRegResults func(s *State, f *ssa.Func)
+
+	// SpillArgReg emits instructions that spill reg to n+off.
+	SpillArgReg func(pp *objw.Progs, p *obj.Prog, f *ssa.Func, t *types.Type, reg int16, n *ir.Name, off int64) *obj.Prog
 }
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index b970451624..8f27777cfc 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -558,11 +558,6 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 				v := s.newValue0A(ssa.OpArg, n.Type(), n)
 				s.vars[n] = v
 				s.addNamedValue(n, v) // This helps with debugging information, not needed for compilation itself.
-				// TODO(register args) Make liveness more fine-grained to that partial spilling is okay.
-				paramAssignment := ssa.ParamAssignmentForArgName(s.f, n)
-				if len(paramAssignment.Registers) > 1 && n.Type().HasPointers() { // 1 cannot be partially live
-					s.storeParameterRegsToStack(s.f.ABISelf, paramAssignment, n, s.decladdrs[n], true)
-				}
 			} else { // address was taken AND/OR too large for SSA
 				paramAssignment := ssa.ParamAssignmentForArgName(s.f, n)
 				if len(paramAssignment.Registers) > 0 {
@@ -6440,6 +6435,10 @@ type State struct {
 	// liveness analysis.
 	livenessMap liveness.Map
 
+	// partLiveArgs includes arguments that may be partially live, for which we
+	// need to generate instructions that spill the argument registers.
+	partLiveArgs map[*ir.Name]bool
+
 	// lineRunStart records the beginning of the current run of instructions
 	// within a single block sharing the same line number
 	// Used to move statement marks to the beginning of such runs.
@@ -6525,7 +6524,7 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 
 	e := f.Frontend().(*ssafn)
 
-	s.livenessMap = liveness.Compute(e.curfn, f, e.stkptrsize, pp)
+	s.livenessMap, s.partLiveArgs = liveness.Compute(e.curfn, f, e.stkptrsize, pp)
 
 	openDeferInfo := e.curfn.LSym.Func().OpenCodedDeferInfo
 	if openDeferInfo != nil {
@@ -6867,10 +6866,60 @@ func defframe(s *State, e *ssafn, f *ssa.Func) {
 	pp.Text.To.Val = int32(types.Rnd(f.OwnAux.ArgWidth(), int64(types.RegSize)))
 	pp.Text.To.Offset = frame
 
+	p := pp.Text
+
+	// Insert code to spill argument registers if the named slot may be partially
+	// live. That is, the named slot is considered live by liveness analysis,
+	// (because a part of it is live), but we may not spill all parts into the
+	// slot. This can only happen with aggregate-typed arguments that are SSA-able
+	// and not address-taken (for non-SSA-able or address-taken arguments we always
+	// spill upfront).
+	// TODO(register args) Make liveness more fine-grained to that partial spilling is okay.
+	if objabi.Experiment.RegabiArgs {
+		// First, see if it is already spilled before it may be live. Look for a spill
+		// in the entry block up to the first safepoint.
+		type nameOff struct {
+			n   *ir.Name
+			off int64
+		}
+		partLiveArgsSpilled := make(map[nameOff]bool)
+		for _, v := range f.Entry.Values {
+			if v.Op.IsCall() {
+				break
+			}
+			if v.Op != ssa.OpStoreReg || v.Args[0].Op != ssa.OpArgIntReg {
+				continue
+			}
+			n, off := ssa.AutoVar(v)
+			if n.Class != ir.PPARAM || n.Addrtaken() || !TypeOK(n.Type()) || !s.partLiveArgs[n] {
+				continue
+			}
+			partLiveArgsSpilled[nameOff{n, off}] = true
+		}
+
+		// Then, insert code to spill registers if not already.
+		for _, a := range f.OwnAux.ABIInfo().InParams() {
+			n, ok := a.Name.(*ir.Name)
+			if !ok || n.Addrtaken() || !TypeOK(n.Type()) || !s.partLiveArgs[n] || len(a.Registers) <= 1 {
+				continue
+			}
+			rts, offs := a.RegisterTypesAndOffsets()
+			for i := range a.Registers {
+				if !rts[i].HasPointers() {
+					continue
+				}
+				if partLiveArgsSpilled[nameOff{n, offs[i]}] {
+					continue // already spilled
+				}
+				reg := ssa.ObjRegForAbiReg(a.Registers[i], f.Config)
+				p = Arch.SpillArgReg(pp, p, f, rts[i], reg, n, offs[i])
+			}
+		}
+	}
+
 	// Insert code to zero ambiguously live variables so that the
 	// garbage collector only sees initialized values when it
 	// looks for pointers.
-	p := pp.Text
 	var lo, hi int64
 
 	// Opaque state for backend to use. Current backends use it to
-- 
GitLab


From cbf9caaf22da04805f1e07277860324c7d9052b6 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Mon, 12 Apr 2021 10:41:56 -0400
Subject: [PATCH 1571/2400] cmd/go: add a Go source file in
 TestScript/mod_sumdb

This test expects 'go mod tidy' to fail if the existing module graph
has a bad checksum. However, there is no intrinsic reason why 'go mod
tidy' should fail in that case: the module contains no packages, and
thus no imports, so 'go mod tidy' can justifiably remove all
requirements without regard to any errors that may have already been
present in the module graph.

Adding a source file that imports a package from the module with the
bad checksum should guarantee that 'go mod tidy' reports the checksum
eror.

For #36460

Change-Id: I59734ac524031288bc03a11f58eed5abe2db76b3
Reviewed-on: https://go-review.googlesource.com/c/go/+/309334
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/testdata/script/mod_sumdb.txt | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/cmd/go/testdata/script/mod_sumdb.txt b/src/cmd/go/testdata/script/mod_sumdb.txt
index 9a688e1461..fa3483c5cb 100644
--- a/src/cmd/go/testdata/script/mod_sumdb.txt
+++ b/src/cmd/go/testdata/script/mod_sumdb.txt
@@ -37,3 +37,9 @@ go get -d rsc.io/fortune
 
 -- go.mod.orig --
 module m
+
+go 1.16
+-- m.go --
+package m
+
+import _ "rsc.io/quote"
-- 
GitLab


From c3931ab1b7bceddc56479d7ddbd7517d244bfe17 Mon Sep 17 00:00:00 2001
From: ian woolf <btw515wolf2@gmail.com>
Date: Sat, 10 Apr 2021 15:41:13 +0800
Subject: [PATCH 1572/2400] net/http/httptest: panic on non-3 digit (XXX)
 status code in Recorder.WriteHeader

This change conforms Recorder with net/http servers, to panic
when a handler writes a non-3 digit XXX status code.

Fixes #45353

Change-Id: Id5ed4af652e8c150ae86bf50402b800d935e2203
Reviewed-on: https://go-review.googlesource.com/c/go/+/308950
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Michael Knyszek <mknyszek@google.com>
---
 src/net/http/httptest/recorder.go      | 19 +++++++++++++++++++
 src/net/http/httptest/recorder_test.go | 25 +++++++++++++++++++++++++
 2 files changed, 44 insertions(+)

diff --git a/src/net/http/httptest/recorder.go b/src/net/http/httptest/recorder.go
index 2428482612..1b712ef2b0 100644
--- a/src/net/http/httptest/recorder.go
+++ b/src/net/http/httptest/recorder.go
@@ -122,11 +122,30 @@ func (rw *ResponseRecorder) WriteString(str string) (int, error) {
 	return len(str), nil
 }
 
+func checkWriteHeaderCode(code int) {
+	// Issue 22880: require valid WriteHeader status codes.
+	// For now we only enforce that it's three digits.
+	// In the future we might block things over 599 (600 and above aren't defined
+	// at https://httpwg.org/specs/rfc7231.html#status.codes)
+	// and we might block under 200 (once we have more mature 1xx support).
+	// But for now any three digits.
+	//
+	// We used to send "HTTP/1.1 000 0" on the wire in responses but there's
+	// no equivalent bogus thing we can realistically send in HTTP/2,
+	// so we'll consistently panic instead and help people find their bugs
+	// early. (We can't return an error from WriteHeader even if we wanted to.)
+	if code < 100 || code > 999 {
+		panic(fmt.Sprintf("invalid WriteHeader code %v", code))
+	}
+}
+
 // WriteHeader implements http.ResponseWriter.
 func (rw *ResponseRecorder) WriteHeader(code int) {
 	if rw.wroteHeader {
 		return
 	}
+
+	checkWriteHeaderCode(code)
 	rw.Code = code
 	rw.wroteHeader = true
 	if rw.HeaderMap == nil {
diff --git a/src/net/http/httptest/recorder_test.go b/src/net/http/httptest/recorder_test.go
index a865e878b9..8cb32dd740 100644
--- a/src/net/http/httptest/recorder_test.go
+++ b/src/net/http/httptest/recorder_test.go
@@ -345,3 +345,28 @@ func TestParseContentLength(t *testing.T) {
 		}
 	}
 }
+
+// Ensure that httptest.Recorder panics when given a non-3 digit (XXX)
+// status HTTP code. See https://golang.org/issues/45353
+func TestRecorderPanicsOnNonXXXStatusCode(t *testing.T) {
+	badCodes := []int{
+		-100, 0, 99, 1000, 20000,
+	}
+	for _, badCode := range badCodes {
+		badCode := badCode
+		t.Run(fmt.Sprintf("Code=%d", badCode), func(t *testing.T) {
+			defer func() {
+				if r := recover(); r == nil {
+					t.Fatal("Expected a panic")
+				}
+			}()
+
+			handler := func(rw http.ResponseWriter, _ *http.Request) {
+				rw.WriteHeader(badCode)
+			}
+			r, _ := http.NewRequest("GET", "http://example.org/", nil)
+			rw := NewRecorder()
+			handler(rw, r)
+		})
+	}
+}
-- 
GitLab


From f18715c18fb4e0e71f46dc8fc47262ebfbcbe514 Mon Sep 17 00:00:00 2001
From: Manlio Perillo <manlio.perillo@gmail.com>
Date: Wed, 14 Apr 2021 15:01:56 +0200
Subject: [PATCH 1573/2400] time: replace os.Setenv with T.Setenv

Updates #45448

Change-Id: Ic096fe1c58c124fb8d84ee15c9446e7ed060b24f
Reviewed-on: https://go-review.googlesource.com/c/go/+/310032
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Michael Knyszek <mknyszek@google.com>
---
 src/time/zoneinfo_test.go | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/src/time/zoneinfo_test.go b/src/time/zoneinfo_test.go
index 03229d192c..136bb7bb8a 100644
--- a/src/time/zoneinfo_test.go
+++ b/src/time/zoneinfo_test.go
@@ -7,7 +7,6 @@ package time_test
 import (
 	"errors"
 	"fmt"
-	"os"
 	"reflect"
 	"testing"
 	"time"
@@ -25,8 +24,7 @@ func TestEnvVarUsage(t *testing.T) {
 	const testZoneinfo = "foo.zip"
 	const env = "ZONEINFO"
 
-	defer os.Setenv(env, os.Getenv(env))
-	os.Setenv(env, testZoneinfo)
+	t.Setenv(env, testZoneinfo)
 
 	// Result isn't important, we're testing the side effect of this command
 	time.LoadLocation("Asia/Jerusalem")
@@ -50,8 +48,7 @@ func TestBadLocationErrMsg(t *testing.T) {
 func TestLoadLocationValidatesNames(t *testing.T) {
 	time.ResetZoneinfoForTesting()
 	const env = "ZONEINFO"
-	defer os.Setenv(env, os.Getenv(env))
-	os.Setenv(env, "")
+	t.Setenv(env, "")
 
 	bad := []string{
 		"/usr/foo/Foo",
-- 
GitLab


From d27bb8ba2ecf18b2d69d4eb72080a17ebff09f64 Mon Sep 17 00:00:00 2001
From: Manlio Perillo <manlio.perillo@gmail.com>
Date: Wed, 14 Apr 2021 12:45:42 +0200
Subject: [PATCH 1574/2400] go/build: replace os.Setenv with T.Setenv

Updates #45448

Change-Id: I4d8e5d7e57818355ef2bc33b57ddf9c8b8da3e62
Reviewed-on: https://go-review.googlesource.com/c/go/+/310030
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Michael Knyszek <mknyszek@google.com>
---
 src/go/build/build_test.go | 27 +++++++++------------------
 1 file changed, 9 insertions(+), 18 deletions(-)

diff --git a/src/go/build/build_test.go b/src/go/build/build_test.go
index dcd8458252..7e78568083 100644
--- a/src/go/build/build_test.go
+++ b/src/go/build/build_test.go
@@ -539,8 +539,7 @@ func TestImportDirNotExist(t *testing.T) {
 func TestImportVendor(t *testing.T) {
 	testenv.MustHaveGoBuild(t) // really must just have source
 
-	defer os.Setenv("GO111MODULE", os.Getenv("GO111MODULE"))
-	os.Setenv("GO111MODULE", "off")
+	t.Setenv("GO111MODULE", "off")
 
 	ctxt := Default
 	wd, err := os.Getwd()
@@ -561,8 +560,7 @@ func TestImportVendor(t *testing.T) {
 func TestImportVendorFailure(t *testing.T) {
 	testenv.MustHaveGoBuild(t) // really must just have source
 
-	defer os.Setenv("GO111MODULE", os.Getenv("GO111MODULE"))
-	os.Setenv("GO111MODULE", "off")
+	t.Setenv("GO111MODULE", "off")
 
 	ctxt := Default
 	wd, err := os.Getwd()
@@ -584,8 +582,7 @@ func TestImportVendorFailure(t *testing.T) {
 func TestImportVendorParentFailure(t *testing.T) {
 	testenv.MustHaveGoBuild(t) // really must just have source
 
-	defer os.Setenv("GO111MODULE", os.Getenv("GO111MODULE"))
-	os.Setenv("GO111MODULE", "off")
+	t.Setenv("GO111MODULE", "off")
 
 	ctxt := Default
 	wd, err := os.Getwd()
@@ -615,8 +612,7 @@ func TestImportPackageOutsideModule(t *testing.T) {
 
 	// Disable module fetching for this test so that 'go list' fails quickly
 	// without trying to find the latest version of a module.
-	defer os.Setenv("GOPROXY", os.Getenv("GOPROXY"))
-	os.Setenv("GOPROXY", "off")
+	t.Setenv("GOPROXY", "off")
 
 	// Create a GOPATH in a temporary directory. We don't use testdata
 	// because it's in GOROOT, which interferes with the module heuristic.
@@ -628,10 +624,8 @@ func TestImportPackageOutsideModule(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	defer os.Setenv("GO111MODULE", os.Getenv("GO111MODULE"))
-	os.Setenv("GO111MODULE", "on")
-	defer os.Setenv("GOPATH", os.Getenv("GOPATH"))
-	os.Setenv("GOPATH", gopath)
+	t.Setenv("GO111MODULE", "on")
+	t.Setenv("GOPATH", gopath)
 	ctxt := Default
 	ctxt.GOPATH = gopath
 	ctxt.Dir = filepath.Join(gopath, "src/example.com/p")
@@ -684,12 +678,9 @@ func TestMissingImportErrorRepetition(t *testing.T) {
 	if err := os.WriteFile(filepath.Join(tmp, "go.mod"), []byte("module m"), 0666); err != nil {
 		t.Fatal(err)
 	}
-	defer os.Setenv("GO111MODULE", os.Getenv("GO111MODULE"))
-	os.Setenv("GO111MODULE", "on")
-	defer os.Setenv("GOPROXY", os.Getenv("GOPROXY"))
-	os.Setenv("GOPROXY", "off")
-	defer os.Setenv("GONOPROXY", os.Getenv("GONOPROXY"))
-	os.Setenv("GONOPROXY", "none")
+	t.Setenv("GO111MODULE", "on")
+	t.Setenv("GOPROXY", "off")
+	t.Setenv("GONOPROXY", "none")
 
 	ctxt := Default
 	ctxt.Dir = tmp
-- 
GitLab


From 567a9322ad1980d22896efc3b642eedf997eb6d9 Mon Sep 17 00:00:00 2001
From: Amit Kumar <mittalmailbox@gmail.com>
Date: Tue, 22 Sep 2020 18:52:06 +0530
Subject: [PATCH 1575/2400] mime: add mime type for avif image file format

Fixes #44602

Change-Id: I28b6df5e2523fc2ece6fd8251fcabc83c7c38d89
Reviewed-on: https://go-review.googlesource.com/c/go/+/256478
Trust: Ian Lance Taylor <iant@golang.org>
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/mime/type.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/mime/type.go b/src/mime/type.go
index 6d2b89e405..a13aa04b5b 100644
--- a/src/mime/type.go
+++ b/src/mime/type.go
@@ -72,6 +72,7 @@ var builtinTypesLower = map[string]string{
 	".svg":  "image/svg+xml",
 	".wasm": "application/wasm",
 	".webp": "image/webp",
+	".avif": "image/avif",
 	".xml":  "text/xml; charset=utf-8",
 }
 
-- 
GitLab


From bf634c76b28a4a857c9d2a039c53982ffbdcceb7 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Wed, 14 Apr 2021 14:54:14 -0700
Subject: [PATCH 1576/2400] cmd/compile: look for function in instantiations in
 all global assignments

Add in some missing global assignment ops to the list of globals ops
that should be traversed to look for generic function instantiations.
The most common other one for global assigments (and the relevant one
for this bug) is OAS2FUNC, but also look at global assigments with
OAS2DOTTYPE, OAS2MAPR, OAS2RECV, and OASOP.

Bonus small fix: get rid of -G=3 case in ir.IsAddressable. Now that we
don't call the old typechecker from noder2, we don't need this -G-3
check anymore.

Fixes #45547.

Change-Id: I75fecec55ea0d6f62e1c2294d4d77447ed9be6ae
Reviewed-on: https://go-review.googlesource.com/c/go/+/310210
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/ir/expr.go       |  7 -------
 src/cmd/compile/internal/noder/stencil.go | 10 +++++++---
 test/typeparam/issue45547.go              | 20 ++++++++++++++++++++
 3 files changed, 27 insertions(+), 10 deletions(-)
 create mode 100644 test/typeparam/issue45547.go

diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index c95ea36909..112d3941ce 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -748,13 +748,6 @@ func IsAddressable(n Node) bool {
 	case ODEREF, ODOTPTR:
 		return true
 
-	case OXDOT:
-		// TODO(danscales): remove this case as we remove calls to the old
-		// typechecker in (*irgen).funcBody().
-		if base.Flag.G == 0 {
-			return false
-		}
-		fallthrough
 	case ODOT:
 		n := n.(*SelectorExpr)
 		return IsAddressable(n.X)
diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 329c80098a..2745016545 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -53,11 +53,15 @@ func (g *irgen) stencil() {
 				continue
 			}
 
-		case ir.OAS:
-
-		case ir.OAS2:
+		case ir.OAS, ir.OAS2, ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV, ir.OASOP:
+			// These are all the various kinds of global assignments,
+			// whose right-hand-sides might contain a function
+			// instantiation.
 
 		default:
+			// The other possible ops at the top level are ODCLCONST
+			// and ODCLTYPE, which don't have any function
+			// instantiations.
 			continue
 		}
 
diff --git a/test/typeparam/issue45547.go b/test/typeparam/issue45547.go
new file mode 100644
index 0000000000..0a08d66b70
--- /dev/null
+++ b/test/typeparam/issue45547.go
@@ -0,0 +1,20 @@
+// compile -G=3
+
+// Copyright 2021 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 p
+
+func f[T any]() (f, g T) { return f, g }
+
+// Tests for generic function instantiation on the right hande side of multi-value
+// assignments.
+
+func _() {
+	// Multi-value assignment within a function
+	var _, _ = f[int]()
+}
+
+// Multi-value assignment outside a function.
+var _, _ = f[int]()
-- 
GitLab


From 083a26c7d2faa8194782856c6f4efce47703df01 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Wed, 14 Apr 2021 16:18:58 -0700
Subject: [PATCH 1577/2400] cmd/compile: propagate pragmas from generic
 function to stenciled implementation

Change-Id: I28a1910890659aaa449ffd2a847cd4ced5a8600d
Reviewed-on: https://go-review.googlesource.com/c/go/+/310211
Trust: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/noder/stencil.go |  1 +
 test/typeparam/pragma.go                  | 19 +++++++++++++++++++
 2 files changed, 20 insertions(+)
 create mode 100644 test/typeparam/pragma.go

diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 2745016545..53ac617d12 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -270,6 +270,7 @@ func (g *irgen) genericSubst(newsym *types.Sym, nameNode *ir.Name, targs []ir.No
 	gf := nameNode.Func
 	// Pos of the instantiated function is same as the generic function
 	newf := ir.NewFunc(gf.Pos())
+	newf.Pragma = gf.Pragma // copy over pragmas from generic function to stenciled implementation.
 	newf.Nname = ir.NewNameAt(gf.Pos(), newsym)
 	newf.Nname.Func = newf
 	newf.Nname.Defn = newf
diff --git a/test/typeparam/pragma.go b/test/typeparam/pragma.go
new file mode 100644
index 0000000000..6743e24ff3
--- /dev/null
+++ b/test/typeparam/pragma.go
@@ -0,0 +1,19 @@
+// errorcheck -0 -m -G=3
+
+// Copyright 2021 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.
+
+// Make sure the go:noinline pragma makes it from a
+// generic function to any of its stenciled instances.
+
+package main
+
+//go:noinline
+func f[T any](x T) T {
+	return x
+}
+
+func main() { // ERROR "can inline main"
+	println(f(5))
+}
-- 
GitLab


From 566a87c16b055872cb469d46cbccc2404dba9bb7 Mon Sep 17 00:00:00 2001
From: Damien Neil <dneil@google.com>
Date: Wed, 14 Apr 2021 17:31:09 -0700
Subject: [PATCH 1578/2400] time: add missing "os" import to zoneinfo_test.go

Updates #45448

Change-Id: I2e79ae6b9cf43a481aa703578712619ea344e421
Reviewed-on: https://go-review.googlesource.com/c/go/+/310212
Trust: Damien Neil <dneil@google.com>
Run-TryBot: Damien Neil <dneil@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/time/zoneinfo_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/time/zoneinfo_test.go b/src/time/zoneinfo_test.go
index 136bb7bb8a..f032aa7924 100644
--- a/src/time/zoneinfo_test.go
+++ b/src/time/zoneinfo_test.go
@@ -7,6 +7,7 @@ package time_test
 import (
 	"errors"
 	"fmt"
+	"os"
 	"reflect"
 	"testing"
 	"time"
-- 
GitLab


From 48b7432e3f5318a026842fc4f39fb690e13f79f8 Mon Sep 17 00:00:00 2001
From: eric fang <eric.fang@arm.com>
Date: Tue, 13 Apr 2021 02:48:32 +0000
Subject: [PATCH 1579/2400] cmd/internal/obj/arm64: fix the wrong sp dst
 register of ADDS/SUBS instructions

According the armv8-a specification, the destination register of the ADDS/ADDSW/
SUBS/SUBSW instructions can not be RSP, the current implementation does not
check this and encodes this wrong instruction format as a CMN instruction. This
CL adds a check and test cases for this situation.

Change-Id: I92cc2f8e17dbda70f0dce8fddf1ca6d5d7730589
Reviewed-on: https://go-review.googlesource.com/c/go/+/309989
Reviewed-by: eric fang <eric.fang@arm.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: eric fang <eric.fang@arm.com>
Run-TryBot: eric fang <eric.fang@arm.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 .../asm/internal/asm/testdata/arm64error.s    | 20 +++++++++++++++++++
 src/cmd/internal/obj/arm64/asm7.go            | 20 +++++++++++++++++++
 2 files changed, 40 insertions(+)

diff --git a/src/cmd/asm/internal/asm/testdata/arm64error.s b/src/cmd/asm/internal/asm/testdata/arm64error.s
index 64bade2051..474ed556d0 100644
--- a/src/cmd/asm/internal/asm/testdata/arm64error.s
+++ b/src/cmd/asm/internal/asm/testdata/arm64error.s
@@ -8,6 +8,26 @@ TEXT errors(SB),$0
 	ADDSW	R7->32, R14, R13                                 // ERROR "shift amount out of range 0 to 31"
 	ADD	R1.UXTB<<5, R2, R3                               // ERROR "shift amount out of range 0 to 4"
 	ADDS	R1.UXTX<<7, R2, R3                               // ERROR "shift amount out of range 0 to 4"
+	ADDS	R5, R6, RSP                                      // ERROR "illegal destination register"
+	SUBS	R5, R6, RSP                                      // ERROR "illegal destination register"
+	ADDSW	R5, R6, RSP                                      // ERROR "illegal destination register"
+	SUBSW	R5, R6, RSP                                      // ERROR "illegal destination register"
+	ADDS	$0xff, R6, RSP                                   // ERROR "illegal destination register"
+	ADDS	$0xffff0, R6, RSP                                // ERROR "illegal destination register"
+	ADDS	$0x1000100010001000, R6, RSP                     // ERROR "illegal destination register"
+	ADDS	$0x10001000100011, R6, RSP                       // ERROR "illegal destination register"
+	ADDSW	$0xff, R6, RSP                                   // ERROR "illegal destination register"
+	ADDSW	$0xffff0, R6, RSP                                // ERROR "illegal destination register"
+	ADDSW	$0x1000100010001000, R6, RSP                     // ERROR "illegal destination register"
+	ADDSW	$0x10001000100011, R6, RSP                       // ERROR "illegal destination register"
+	SUBS	$0xff, R6, RSP                                   // ERROR "illegal destination register"
+	SUBS	$0xffff0, R6, RSP                                // ERROR "illegal destination register"
+	SUBS	$0x1000100010001000, R6, RSP                     // ERROR "illegal destination register"
+	SUBS	$0x10001000100011, R6, RSP                       // ERROR "illegal destination register"
+	SUBSW	$0xff, R6, RSP                                   // ERROR "illegal destination register"
+	SUBSW	$0xffff0, R6, RSP                                // ERROR "illegal destination register"
+	SUBSW	$0x1000100010001000, R6, RSP                     // ERROR "illegal destination register"
+	SUBSW	$0x10001000100011, R6, RSP                       // ERROR "illegal destination register"
 	AND	$0x22220000, R2, RSP                             // ERROR "illegal combination"
 	ANDS	$0x22220000, R2, RSP                             // ERROR "illegal combination"
 	ADD	R1, R2, R3, R4                                   // ERROR "illegal combination"
diff --git a/src/cmd/internal/obj/arm64/asm7.go b/src/cmd/internal/obj/arm64/asm7.go
index b0e29c26e8..2dbaea98b6 100644
--- a/src/cmd/internal/obj/arm64/asm7.go
+++ b/src/cmd/internal/obj/arm64/asm7.go
@@ -1347,6 +1347,14 @@ func isADDWop(op obj.As) bool {
 	return false
 }
 
+func isADDSop(op obj.As) bool {
+	switch op {
+	case AADDS, AADDSW, ASUBS, ASUBSW:
+		return true
+	}
+	return false
+}
+
 func isRegShiftOrExt(a *obj.Addr) bool {
 	return (a.Index-obj.RBaseARM64)&REG_EXT != 0 || (a.Index-obj.RBaseARM64)&REG_LSL != 0
 }
@@ -3215,6 +3223,9 @@ func (c *ctxt7) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		o1 |= (uint32(rf&31) << 16) | (uint32(r&31) << 5) | uint32(rt&31)
 
 	case 2: /* add/sub $(uimm12|uimm24)[,R],R; cmp $(uimm12|uimm24),R */
+		if p.To.Reg == REG_RSP && isADDSop(p.As) {
+			c.ctxt.Diag("illegal destination register: %v\n", p)
+		}
 		o1 = c.opirr(p, p.As)
 
 		rt := int(p.To.Reg)
@@ -3396,6 +3407,9 @@ func (c *ctxt7) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		o4 = os[3]
 
 	case 13: /* addop $vcon, [R], R (64 bit literal); cmp $lcon,R -> addop $lcon,R, ZR */
+		if p.To.Reg == REG_RSP && isADDSop(p.As) {
+			c.ctxt.Diag("illegal destination register: %v\n", p)
+		}
 		o := uint32(0)
 		num := uint8(0)
 		cls := oclass(&p.From)
@@ -3659,6 +3673,9 @@ func (c *ctxt7) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		o1 |= (REGZERO & 31 << 5) | uint32(rt&31)
 
 	case 27: /* op Rm<<n[,Rn],Rd (extended register) */
+		if p.To.Reg == REG_RSP && isADDSop(p.As) {
+			c.ctxt.Diag("illegal destination register: %v\n", p)
+		}
 		if (p.From.Reg-obj.RBaseARM64)&REG_EXT != 0 {
 			amount := (p.From.Reg >> 5) & 7
 			if amount > 4 {
@@ -4275,6 +4292,9 @@ func (c *ctxt7) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		if p.Reg == REGTMP {
 			c.ctxt.Diag("cannot use REGTMP as source: %v\n", p)
 		}
+		if p.To.Reg == REG_RSP && isADDSop(p.As) {
+			c.ctxt.Diag("illegal destination register: %v\n", p)
+		}
 		if isADDWop(p.As) || isANDWop(p.As) {
 			o1 = c.omovconst(AMOVW, p, &p.From, REGTMP)
 		} else {
-- 
GitLab


From 8f4c5068e07a03e16998b6d8d38a0482433fc7fe Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Wed, 14 Apr 2021 19:15:42 -0400
Subject: [PATCH 1580/2400] internal/bytealg: port more performance-critical
 functions to ABIInternal
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

CL 308931 ported several runtime assembly functions to ABIInternal so
that compiler-generated ABIInternal calls don't go through ABI
wrappers, but it missed the runtime assembly functions that are
actually defined in internal/bytealg.

This eliminates the cost of wrappers for the BleveQuery and
GopherLuaKNucleotide benchmarks, but there's still more to do for
Tile38.

                                      0-base                1-wrappers
                                     sec/op        sec/op            vs base
BleveQuery                          6.507 ± 0%    6.477 ± 0%  -0.46% (p=0.004 n=20)
GopherLuaKNucleotide                30.39 ± 1%    30.34 ± 0%       ~ (p=0.301 n=20)
Tile38IntersectsCircle100kmRequest 1.038m ± 1%   1.080m ± 2%  +4.03% (p=0.000 n=20)

For #40724.

Change-Id: I0b722443f684fcb997b1d70802c5ed4b8d8f9829
Reviewed-on: https://go-review.googlesource.com/c/go/+/310184
Trust: Austin Clements <austin@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/dist/build.go                |  7 ++-
 src/cmd/internal/objabi/path.go      |  4 ++
 src/internal/bytealg/compare_amd64.s | 38 ++++++++++++++-
 src/internal/bytealg/equal_amd64.s   | 70 +++++++++++++++++++++++++---
 4 files changed, 108 insertions(+), 11 deletions(-)

diff --git a/src/cmd/dist/build.go b/src/cmd/dist/build.go
index f8f8003ff7..63dd8005e3 100644
--- a/src/cmd/dist/build.go
+++ b/src/cmd/dist/build.go
@@ -1764,8 +1764,9 @@ func cmdlist() {
 // IsRuntimePackagePath examines 'pkgpath' and returns TRUE if it
 // belongs to the collection of "runtime-related" packages, including
 // "runtime" itself, "reflect", "syscall", and the
-// "runtime/internal/*" packages. See also the function of the same
-// name in cmd/internal/objabi/path.go.
+// "runtime/internal/*" packages.
+//
+// Keep in sync with cmd/internal/objabi/path.go:IsRuntimePackagePath.
 func IsRuntimePackagePath(pkgpath string) bool {
 	rval := false
 	switch pkgpath {
@@ -1777,6 +1778,8 @@ func IsRuntimePackagePath(pkgpath string) bool {
 		rval = true
 	case "crypto/x509/internal/macos": // libc function wrappers need to be ABIInternal
 		rval = true
+	case "internal/bytealg":
+		rval = true
 	default:
 		rval = strings.HasPrefix(pkgpath, "runtime/internal")
 	}
diff --git a/src/cmd/internal/objabi/path.go b/src/cmd/internal/objabi/path.go
index 1a0784cf7f..d49de141cc 100644
--- a/src/cmd/internal/objabi/path.go
+++ b/src/cmd/internal/objabi/path.go
@@ -47,6 +47,8 @@ func PathToPrefix(s string) string {
 // some cases need to be aware of when they are building such a
 // package, for example to enable features such as ABI selectors in
 // assembly sources.
+//
+// Keep in sync with cmd/dist/build.go:IsRuntimePackagePath.
 func IsRuntimePackagePath(pkgpath string) bool {
 	rval := false
 	switch pkgpath {
@@ -58,6 +60,8 @@ func IsRuntimePackagePath(pkgpath string) bool {
 		rval = true
 	case "crypto/x509/internal/macos": // libc function wrappers need to be ABIInternal
 		rval = true
+	case "internal/bytealg":
+		rval = true
 	default:
 		rval = strings.HasPrefix(pkgpath, "runtime/internal")
 	}
diff --git a/src/internal/bytealg/compare_amd64.s b/src/internal/bytealg/compare_amd64.s
index 900b92a21e..8295acb03a 100644
--- a/src/internal/bytealg/compare_amd64.s
+++ b/src/internal/bytealg/compare_amd64.s
@@ -5,20 +5,41 @@
 #include "go_asm.h"
 #include "textflag.h"
 
-TEXT ·Compare(SB),NOSPLIT,$0-56
+TEXT ·Compare<ABIInternal>(SB),NOSPLIT,$0-56
+#ifdef GOEXPERIMENT_regabiargs
+	// AX = a_base (want in SI)
+	// BX = a_len  (want in BX)
+	// CX = a_cap  (unused)
+	// DI = b_base (want in DI)
+	// SI = b_len  (want in DX)
+	// R8 = b_cap  (unused)
+	MOVQ	SI, DX
+	MOVQ	AX, SI
+#else
 	MOVQ	a_base+0(FP), SI
 	MOVQ	a_len+8(FP), BX
 	MOVQ	b_base+24(FP), DI
 	MOVQ	b_len+32(FP), DX
 	LEAQ	ret+48(FP), R9
+#endif
 	JMP	cmpbody<>(SB)
 
-TEXT runtime·cmpstring(SB),NOSPLIT,$0-40
+TEXT runtime·cmpstring<ABIInternal>(SB),NOSPLIT,$0-40
+#ifdef GOEXPERIMENT_regabiargs
+	// AX = a_base (want in SI)
+	// BX = a_len  (want in BX)
+	// CX = b_base (want in DI)
+	// DI = b_len  (want in DX)
+	MOVQ	AX, SI
+	MOVQ	DI, DX
+	MOVQ	CX, DI
+#else
 	MOVQ	a_base+0(FP), SI
 	MOVQ	a_len+8(FP), BX
 	MOVQ	b_base+16(FP), DI
 	MOVQ	b_len+24(FP), DX
 	LEAQ	ret+32(FP), R9
+#endif
 	JMP	cmpbody<>(SB)
 
 // input:
@@ -26,7 +47,12 @@ TEXT runtime·cmpstring(SB),NOSPLIT,$0-40
 //   DI = b
 //   BX = alen
 //   DX = blen
+#ifndef GOEXPERIMENT_regabiargs
 //   R9 = address of output word (stores -1/0/1 here)
+#else
+// output:
+//   AX = output (-1/0/1)
+#endif
 TEXT cmpbody<>(SB),NOSPLIT,$0-0
 	CMPQ	SI, DI
 	JEQ	allsame
@@ -74,7 +100,9 @@ diff16:
 	CMPB	CX, (DI)(BX*1)
 	SETHI	AX
 	LEAQ	-1(AX*2), AX	// convert 1/0 to +1/-1
+#ifndef GOEXPERIMENT_regabiargs
 	MOVQ	AX, (R9)
+#endif
 	RET
 
 	// 0 through 16 bytes left, alen>=8, blen>=8
@@ -100,7 +128,9 @@ diff8:
 	SHRQ	CX, AX	// move a's bit to bottom
 	ANDQ	$1, AX	// mask bit
 	LEAQ	-1(AX*2), AX // 1/0 => +1/-1
+#ifndef GOEXPERIMENT_regabiargs
 	MOVQ	AX, (R9)
+#endif
 	RET
 
 	// 0-7 bytes in common
@@ -139,7 +169,9 @@ di_finish:
 	SHRQ	CX, SI	// move a's bit to bottom
 	ANDQ	$1, SI	// mask bit
 	LEAQ	-1(SI*2), AX // 1/0 => +1/-1
+#ifndef GOEXPERIMENT_regabiargs
 	MOVQ	AX, (R9)
+#endif
 	RET
 
 allsame:
@@ -149,7 +181,9 @@ allsame:
 	SETGT	AX	// 1 if alen > blen
 	SETEQ	CX	// 1 if alen == blen
 	LEAQ	-1(CX)(AX*2), AX	// 1,0,-1 result
+#ifndef GOEXPERIMENT_regabiargs
 	MOVQ	AX, (R9)
+#endif
 	RET
 
 	// this works for >= 64 bytes of data.
diff --git a/src/internal/bytealg/equal_amd64.s b/src/internal/bytealg/equal_amd64.s
index c816409545..6f12d2a169 100644
--- a/src/internal/bytealg/equal_amd64.s
+++ b/src/internal/bytealg/equal_amd64.s
@@ -6,7 +6,21 @@
 #include "textflag.h"
 
 // memequal(a, b unsafe.Pointer, size uintptr) bool
-TEXT runtime·memequal(SB),NOSPLIT,$0-25
+TEXT runtime·memequal<ABIInternal>(SB),NOSPLIT,$0-25
+#ifdef GOEXPERIMENT_regabiargs
+	// AX = a    (want in SI)
+	// BX = b    (want in DI)
+	// CX = size (want in BX)
+	CMPQ	AX, BX
+	JNE	neq
+	MOVQ	$1, AX	// return 1
+	RET
+neq:
+	MOVQ	AX, SI
+	MOVQ	BX, DI
+	MOVQ	CX, BX
+	JMP	memeqbody<>(SB)
+#else
 	MOVQ	a+0(FP), SI
 	MOVQ	b+8(FP), DI
 	CMPQ	SI, DI
@@ -17,9 +31,24 @@ TEXT runtime·memequal(SB),NOSPLIT,$0-25
 eq:
 	MOVB	$1, ret+24(FP)
 	RET
+#endif
 
 // memequal_varlen(a, b unsafe.Pointer) bool
-TEXT runtime·memequal_varlen(SB),NOSPLIT,$0-17
+TEXT runtime·memequal_varlen<ABIInternal>(SB),NOSPLIT,$0-17
+#ifdef GOEXPERIMENT_regabiargs
+	// AX = a       (want in SI)
+	// BX = b       (want in DI)
+	// 8(DX) = size (want in BX)
+	CMPQ	AX, BX
+	JNE	neq
+	MOVQ	$1, AX	// return 1
+	RET
+neq:
+	MOVQ	AX, SI
+	MOVQ	BX, DI
+	MOVQ	8(DX), BX    // compiler stores size at offset 8 in the closure
+	JMP	memeqbody<>(SB)
+#else
 	MOVQ	a+0(FP), SI
 	MOVQ	b+8(FP), DI
 	CMPQ	SI, DI
@@ -30,11 +59,18 @@ TEXT runtime·memequal_varlen(SB),NOSPLIT,$0-17
 eq:
 	MOVB	$1, ret+16(FP)
 	RET
-
-// a in SI
-// b in DI
-// count in BX
-// address of result byte in AX
+#endif
+
+// Input:
+//   a in SI
+//   b in DI
+//   count in BX
+#ifndef GOEXPERIMENT_regabiargs
+//   address of result byte in AX
+#else
+// Output:
+//   result in AX
+#endif
 TEXT memeqbody<>(SB),NOSPLIT,$0-0
 	CMPQ	BX, $8
 	JB	small
@@ -68,7 +104,11 @@ hugeloop:
 	SUBQ	$64, BX
 	CMPL	DX, $0xffff
 	JEQ	hugeloop
+#ifdef GOEXPERIMENT_regabiargs
+	XORQ	AX, AX	// return 0
+#else
 	MOVB	$0, (AX)
+#endif
 	RET
 
 	// 64 bytes at a time using ymm registers
@@ -89,7 +129,11 @@ hugeloop_avx2:
 	CMPL	DX, $0xffffffff
 	JEQ	hugeloop_avx2
 	VZEROUPPER
+#ifdef GOEXPERIMENT_regabiargs
+	XORQ	AX, AX	// return 0
+#else
 	MOVB	$0, (AX)
+#endif
 	RET
 
 bigloop_avx2:
@@ -106,7 +150,11 @@ bigloop:
 	SUBQ	$8, BX
 	CMPQ	CX, DX
 	JEQ	bigloop
+#ifdef GOEXPERIMENT_regabiargs
+	XORQ	AX, AX	// return 0
+#else
 	MOVB	$0, (AX)
+#endif
 	RET
 
 	// remaining 0-8 bytes
@@ -114,7 +162,11 @@ leftover:
 	MOVQ	-8(SI)(BX*1), CX
 	MOVQ	-8(DI)(BX*1), DX
 	CMPQ	CX, DX
+#ifdef GOEXPERIMENT_regabiargs
+	SETEQ	AX
+#else
 	SETEQ	(AX)
+#endif
 	RET
 
 small:
@@ -149,6 +201,10 @@ di_finish:
 	SUBQ	SI, DI
 	SHLQ	CX, DI
 equal:
+#ifdef GOEXPERIMENT_regabiargs
+	SETEQ	AX
+#else
 	SETEQ	(AX)
+#endif
 	RET
 
-- 
GitLab


From 0184b445c04a0f30e34ce624298547f12630f3aa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9my=20Oudompheng?= <remyoudompheng@gmail.com>
Date: Sun, 24 Mar 2019 23:21:38 +0100
Subject: [PATCH 1581/2400] =?UTF-8?q?strconv:=20implement=20Ry=C5=AB-like?=
 =?UTF-8?q?=20algorithm=20for=20fixed=20precision=20ftoa?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This patch implements a simplified version of Ulf Adams,
"Ryū: Fast Float-to-String Conversion" (doi:10.1145/3192366.3192369)
for formatting floating-point numbers with a fixed number of decimal
digits.

It uses the same principles but does not need to handle
the complex task of finding a shortest representation.
This allows to handle a few more cases than Grisu3, notably
formatting with up to 18 significant digits.

name                         old time/op  new time/op  delta
AppendFloat/32Fixed8Hard-4   72.0ns ± 2%  56.0ns ± 2%  -22.28%  (p=0.000 n=10+10)
AppendFloat/32Fixed9Hard-4   74.8ns ± 0%  64.2ns ± 2%  -14.16%  (p=0.000 n=8+10)
AppendFloat/64Fixed1-4       60.4ns ± 1%  54.2ns ± 1%  -10.31%  (p=0.000 n=10+9)
AppendFloat/64Fixed2-4       66.3ns ± 1%  53.3ns ± 1%  -19.54%  (p=0.000 n=10+9)
AppendFloat/64Fixed3-4       61.0ns ± 1%  55.0ns ± 2%   -9.80%  (p=0.000 n=9+10)
AppendFloat/64Fixed4-4       66.9ns ± 0%  52.0ns ± 2%  -22.20%  (p=0.000 n=8+10)
AppendFloat/64Fixed12-4      95.5ns ± 1%  76.2ns ± 3%  -20.19%  (p=0.000 n=10+9)
AppendFloat/64Fixed16-4      1.62µs ± 0%  0.07µs ± 2%  -95.69%  (p=0.000 n=10+10)
AppendFloat/64Fixed12Hard-4  1.27µs ± 1%  0.07µs ± 1%  -94.83%  (p=0.000 n=9+9)
AppendFloat/64Fixed17Hard-4  3.68µs ± 1%  0.08µs ± 2%  -97.86%  (p=0.000 n=10+9)
AppendFloat/64Fixed18Hard-4  3.67µs ± 0%  3.72µs ± 1%   +1.44%  (p=0.000 n=9+10)

Updates #15672

Change-Id: I160963e141dd48287ad8cf57bcc3c686277788e8
Reviewed-on: https://go-review.googlesource.com/c/go/+/170079
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Trust: Nigel Tao <nigeltao@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/strconv/ftoa.go          |  13 +-
 src/strconv/ftoa_test.go     |  16 ++
 src/strconv/ftoaryu.go       | 311 +++++++++++++++++++++++++++++++++++
 src/strconv/ftoaryu_test.go  |  31 ++++
 src/strconv/internal_test.go |   8 +
 5 files changed, 374 insertions(+), 5 deletions(-)
 create mode 100644 src/strconv/ftoaryu.go
 create mode 100644 src/strconv/ftoaryu_test.go

diff --git a/src/strconv/ftoa.go b/src/strconv/ftoa.go
index 8ce6ef30b4..a3bff52bc8 100644
--- a/src/strconv/ftoa.go
+++ b/src/strconv/ftoa.go
@@ -143,12 +143,15 @@ func genericFtoa(dst []byte, val float64, fmt byte, prec, bitSize int) []byte {
 			}
 			digits = prec
 		}
-		if digits <= 15 {
-			// try fast algorithm when the number of digits is reasonable.
-			var buf [24]byte
+		var buf [24]byte
+		if bitSize == 32 && digits <= 9 {
 			digs.d = buf[:]
-			f := extFloat{mant, exp - int(flt.mantbits), neg}
-			ok = f.FixedDecimal(&digs, digits)
+			ryuFtoaFixed32(&digs, uint32(mant), exp-int(flt.mantbits), digits)
+			ok = true
+		} else if digits <= 18 {
+			digs.d = buf[:]
+			ryuFtoaFixed64(&digs, mant, exp-int(flt.mantbits), digits)
+			ok = true
 		}
 	}
 	if !ok {
diff --git a/src/strconv/ftoa_test.go b/src/strconv/ftoa_test.go
index 99cca17542..b1685aeb20 100644
--- a/src/strconv/ftoa_test.go
+++ b/src/strconv/ftoa_test.go
@@ -77,6 +77,14 @@ var ftoatests = []ftoaTest{
 	{1.2345e6, 'f', 5, "1234500.00000"},
 	{1.2345e6, 'g', 5, "1.2345e+06"},
 
+	// Round to even
+	{1.2345e6, 'e', 3, "1.234e+06"},
+	{1.2355e6, 'e', 3, "1.236e+06"},
+	{1.2345, 'f', 3, "1.234"},
+	{1.2355, 'f', 3, "1.236"},
+	{1234567890123456.5, 'e', 15, "1.234567890123456e+15"},
+	{1234567890123457.5, 'e', 15, "1.234567890123458e+15"},
+
 	{1e23, 'e', 17, "9.99999999999999916e+22"},
 	{1e23, 'f', 17, "99999999999999991611392.00000000000000000"},
 	{1e23, 'g', 17, "9.9999999999999992e+22"},
@@ -241,11 +249,19 @@ var ftoaBenches = []struct {
 	{"32Point", 339.7784, 'g', -1, 32},
 	{"32Exp", -5.09e25, 'g', -1, 32},
 	{"32NegExp", -5.11e-25, 'g', -1, 32},
+	{"32Fixed8Hard", math.Ldexp(15961084, -125), 'e', 8, 32},
+	{"32Fixed9Hard", math.Ldexp(14855922, -83), 'e', 9, 32},
 
 	{"64Fixed1", 123456, 'e', 3, 64},
 	{"64Fixed2", 123.456, 'e', 3, 64},
 	{"64Fixed3", 1.23456e+78, 'e', 3, 64},
 	{"64Fixed4", 1.23456e-78, 'e', 3, 64},
+	{"64Fixed12", 1.23456e-78, 'e', 12, 64},
+	{"64Fixed16", 1.23456e-78, 'e', 16, 64},
+	// From testdata/testfp.txt
+	{"64Fixed12Hard", math.Ldexp(6965949469487146, -249), 'e', 12, 64},
+	{"64Fixed17Hard", math.Ldexp(8887055249355788, 665), 'e', 17, 64},
+	{"64Fixed18Hard", math.Ldexp(6994187472632449, 690), 'e', 18, 64},
 
 	// Trigger slow path (see issue #15672).
 	{"Slowpath64", 622666234635.3213e-320, 'e', -1, 64},
diff --git a/src/strconv/ftoaryu.go b/src/strconv/ftoaryu.go
new file mode 100644
index 0000000000..44a55b1da9
--- /dev/null
+++ b/src/strconv/ftoaryu.go
@@ -0,0 +1,311 @@
+// Copyright 2021 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 strconv
+
+import (
+	"math/bits"
+)
+
+// binary to decimal conversion using the Ryū algorithm.
+//
+// See Ulf Adams, "Ryū: Fast Float-to-String Conversion" (doi:10.1145/3192366.3192369)
+//
+// Fixed precision formatting is a variant of the original paper's
+// algorithm, where a single multiplication by 10^k is required,
+// sharing the same rounding guarantees.
+
+// ryuFtoaFixed32 formats mant*(2^exp) with prec decimal digits.
+func ryuFtoaFixed32(d *decimalSlice, mant uint32, exp int, prec int) {
+	if prec < 0 {
+		panic("ryuFtoaFixed32 called with negative prec")
+	}
+	if prec > 9 {
+		panic("ryuFtoaFixed32 called with prec > 9")
+	}
+	// Zero input.
+	if mant == 0 {
+		d.nd, d.dp = 0, 0
+		return
+	}
+	// Renormalize to a 25-bit mantissa.
+	e2 := exp
+	if b := bits.Len32(mant); b < 25 {
+		mant <<= uint(25 - b)
+		e2 += int(b) - 25
+	}
+	// Choose an exponent such that rounded mant*(2^e2)*(10^q) has
+	// at least prec decimal digits, i.e
+	//     mant*(2^e2)*(10^q) >= 10^(prec-1)
+	// Because mant >= 2^24, it is enough to choose:
+	//     2^(e2+24) >= 10^(-q+prec-1)
+	// or q = -mulByLog2Log10(e2+24) + prec - 1
+	q := -mulByLog2Log10(e2+24) + prec - 1
+
+	// Now compute mant*(2^e2)*(10^q).
+	// Is it an exact computation?
+	// Only small positive powers of 10 are exact (5^28 has 66 bits).
+	exact := q <= 27 && q >= 0
+
+	di, dexp2, d0 := mult64bitPow10(mant, e2, q)
+	if dexp2 >= 0 {
+		panic("not enough significant bits after mult64bitPow10")
+	}
+	// As a special case, computation might still be exact, if exponent
+	// was negative and if it amounts to computing an exact division.
+	// In that case, we ignore all lower bits.
+	// Note that division by 10^11 cannot be exact as 5^11 has 26 bits.
+	if q < 0 && q >= -10 && divisibleByPower5(uint64(mant), -q) {
+		exact = true
+		d0 = true
+	}
+	// Remove extra lower bits and keep rounding info.
+	extra := uint(-dexp2)
+	extraMask := uint32(1<<extra - 1)
+
+	di, dfrac := di>>extra, di&extraMask
+	roundUp := false
+	if exact {
+		// If we computed an exact product, d + 1/2
+		// should round to d+1 if 'd' is odd.
+		roundUp = dfrac > 1<<(extra-1) ||
+			(dfrac == 1<<(extra-1) && !d0) ||
+			(dfrac == 1<<(extra-1) && d0 && di&1 == 1)
+	} else {
+		// otherwise, d+1/2 always rounds up because
+		// we truncated below.
+		roundUp = dfrac>>(extra-1) == 1
+	}
+	if dfrac != 0 {
+		d0 = false
+	}
+	// Proceed to the requested number of digits
+	formatDecimal(d, uint64(di), !d0, roundUp, prec)
+	// Adjust exponent
+	d.dp -= q
+}
+
+// ryuFtoaFixed64 formats mant*(2^exp) with prec decimal digits.
+func ryuFtoaFixed64(d *decimalSlice, mant uint64, exp int, prec int) {
+	if prec > 18 {
+		panic("ryuFtoaFixed64 called with prec > 18")
+	}
+	// Zero input.
+	if mant == 0 {
+		d.nd, d.dp = 0, 0
+		return
+	}
+	// Renormalize to a 55-bit mantissa.
+	e2 := exp
+	if b := bits.Len64(mant); b < 55 {
+		mant = mant << uint(55-b)
+		e2 += int(b) - 55
+	}
+	// Choose an exponent such that rounded mant*(2^e2)*(10^q) has
+	// at least prec decimal digits, i.e
+	//     mant*(2^e2)*(10^q) >= 10^(prec-1)
+	// Because mant >= 2^54, it is enough to choose:
+	//     2^(e2+54) >= 10^(-q+prec-1)
+	// or q = -mulByLog2Log10(e2+54) + prec - 1
+	//
+	// The minimal required exponent is -mulByLog2Log10(1025)+18 = -291
+	// The maximal required exponent is mulByLog2Log10(1074)+18 = 342
+	q := -mulByLog2Log10(e2+54) + prec - 1
+
+	// Now compute mant*(2^e2)*(10^q).
+	// Is it an exact computation?
+	// Only small positive powers of 10 are exact (5^55 has 128 bits).
+	exact := q <= 55 && q >= 0
+
+	di, dexp2, d0 := mult128bitPow10(mant, e2, q)
+	if dexp2 >= 0 {
+		panic("not enough significant bits after mult128bitPow10")
+	}
+	// As a special case, computation might still be exact, if exponent
+	// was negative and if it amounts to computing an exact division.
+	// In that case, we ignore all lower bits.
+	// Note that division by 10^23 cannot be exact as 5^23 has 54 bits.
+	if q < 0 && q >= -22 && divisibleByPower5(mant, -q) {
+		exact = true
+		d0 = true
+	}
+	// Remove extra lower bits and keep rounding info.
+	extra := uint(-dexp2)
+	extraMask := uint64(1<<extra - 1)
+
+	di, dfrac := di>>extra, di&extraMask
+	roundUp := false
+	if exact {
+		// If we computed an exact product, d + 1/2
+		// should round to d+1 if 'd' is odd.
+		roundUp = dfrac > 1<<(extra-1) ||
+			(dfrac == 1<<(extra-1) && !d0) ||
+			(dfrac == 1<<(extra-1) && d0 && di&1 == 1)
+	} else {
+		// otherwise, d+1/2 always rounds up because
+		// we truncated below.
+		roundUp = dfrac>>(extra-1) == 1
+	}
+	if dfrac != 0 {
+		d0 = false
+	}
+	// Proceed to the requested number of digits
+	formatDecimal(d, di, !d0, roundUp, prec)
+	// Adjust exponent
+	d.dp -= q
+}
+
+// formatDecimal fills d with at most prec decimal digits
+// of mantissa m. The boolean trunc indicates whether m
+// is truncated compared to the original number being formatted.
+func formatDecimal(d *decimalSlice, m uint64, trunc bool, roundUp bool, prec int) {
+	max := uint64pow10[prec]
+	trimmed := 0
+	for m >= max {
+		a, b := m/10, m%10
+		m = a
+		trimmed++
+		if b > 5 {
+			roundUp = true
+		} else if b < 5 {
+			roundUp = false
+		} else { // b == 5
+			// round up if there are trailing digits,
+			// or if the new value of m is odd (round-to-even convention)
+			roundUp = trunc || m&1 == 1
+		}
+		if b != 0 {
+			trunc = true
+		}
+	}
+	if roundUp {
+		m++
+	}
+	if m >= max {
+		// Happens if di was originally 99999....xx
+		m /= 10
+		trimmed++
+	}
+	// render digits (similar to formatBits)
+	n := uint(prec)
+	d.nd = int(prec)
+	v := m
+	for v >= 100 {
+		var v1, v2 uint64
+		if v>>32 == 0 {
+			v1, v2 = uint64(uint32(v)/100), uint64(uint32(v)%100)
+		} else {
+			v1, v2 = v/100, v%100
+		}
+		n -= 2
+		d.d[n+1] = smallsString[2*v2+1]
+		d.d[n+0] = smallsString[2*v2+0]
+		v = v1
+	}
+	if v > 0 {
+		n--
+		d.d[n] = smallsString[2*v+1]
+	}
+	if v >= 10 {
+		n--
+		d.d[n] = smallsString[2*v]
+	}
+	for d.d[d.nd-1] == '0' {
+		d.nd--
+		trimmed++
+	}
+	d.dp = d.nd + trimmed
+}
+
+// mulByLog2Log10 returns math.Floor(x * log(2)/log(10)) for an integer x in
+// the range -1600 <= x && x <= +1600.
+//
+// The range restriction lets us work in faster integer arithmetic instead of
+// slower floating point arithmetic. Correctness is verified by unit tests.
+func mulByLog2Log10(x int) int {
+	// log(2)/log(10) ≈ 0.30102999566 ≈ 78913 / 2^18
+	return (x * 78913) >> 18
+}
+
+// mulByLog10Log2 returns math.Floor(x * log(10)/log(2)) for an integer x in
+// the range -500 <= x && x <= +500.
+//
+// The range restriction lets us work in faster integer arithmetic instead of
+// slower floating point arithmetic. Correctness is verified by unit tests.
+func mulByLog10Log2(x int) int {
+	// log(10)/log(2) ≈ 3.32192809489 ≈ 108853 / 2^15
+	return (x * 108853) >> 15
+}
+
+// mult64bitPow10 takes a floating-point input with a 25-bit
+// mantissa and multiplies it with 10^q. The resulting mantissa
+// is m*P >> 57 where P is a 64-bit element of the detailedPowersOfTen tables.
+// It is typically 31 or 32-bit wide.
+// The returned boolean is true if all trimmed bits were zero.
+//
+// That is:
+//     m*2^e2 * round(10^q) = resM * 2^resE + ε
+//     exact = ε == 0
+func mult64bitPow10(m uint32, e2, q int) (resM uint32, resE int, exact bool) {
+	if q == 0 {
+		return m << 7, e2 - 7, true
+	}
+	if q < detailedPowersOfTenMinExp10 || detailedPowersOfTenMaxExp10 < q {
+		// This never happens due to the range of float32/float64 exponent
+		panic("mult64bitPow10: power of 10 is out of range")
+	}
+	pow := detailedPowersOfTen[q-detailedPowersOfTenMinExp10][1]
+	if q < 0 {
+		// Inverse powers of ten must be rounded up.
+		pow += 1
+	}
+	hi, lo := bits.Mul64(uint64(m), pow)
+	e2 += mulByLog10Log2(q) - 63 + 57
+	return uint32(hi<<7 | lo>>57), e2, lo<<7 == 0
+}
+
+// mult128bitPow10 takes a floating-point input with a 55-bit
+// mantissa and multiplies it with 10^q. The resulting mantissa
+// is m*P >> 119 where P is a 128-bit element of the detailedPowersOfTen tables.
+// It is typically 63 or 64-bit wide.
+// The returned boolean is true is all trimmed bits were zero.
+//
+// That is:
+//     m*2^e2 * round(10^q) = resM * 2^resE + ε
+//     exact = ε == 0
+func mult128bitPow10(m uint64, e2, q int) (resM uint64, resE int, exact bool) {
+	if q == 0 {
+		return m << 9, e2 - 9, true
+	}
+	if q < detailedPowersOfTenMinExp10 || detailedPowersOfTenMaxExp10 < q {
+		// This never happens due to the range of float32/float64 exponent
+		panic("mult128bitPow10: power of 10 is out of range")
+	}
+	pow := detailedPowersOfTen[q-detailedPowersOfTenMinExp10]
+	if q < 0 {
+		// Inverse powers of ten must be rounded up.
+		pow[0] += 1
+	}
+	e2 += mulByLog10Log2(q) - 127 + 119
+
+	// long multiplication
+	l1, l0 := bits.Mul64(m, pow[0])
+	h1, h0 := bits.Mul64(m, pow[1])
+	mid, carry := bits.Add64(l1, h0, 0)
+	h1 += carry
+	return h1<<9 | mid>>55, e2, mid<<9 == 0 && l0 == 0
+}
+
+func divisibleByPower5(m uint64, k int) bool {
+	if m == 0 {
+		return true
+	}
+	for i := 0; i < k; i++ {
+		if m%5 != 0 {
+			return false
+		}
+		m /= 5
+	}
+	return true
+}
diff --git a/src/strconv/ftoaryu_test.go b/src/strconv/ftoaryu_test.go
new file mode 100644
index 0000000000..9758619ad1
--- /dev/null
+++ b/src/strconv/ftoaryu_test.go
@@ -0,0 +1,31 @@
+// Copyright 2021 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 strconv_test
+
+import (
+	"math"
+	. "strconv"
+	"testing"
+)
+
+func TestMulByLog2Log10(t *testing.T) {
+	for x := -1600; x <= +1600; x++ {
+		iMath := MulByLog2Log10(x)
+		fMath := int(math.Floor(float64(x) * math.Ln2 / math.Ln10))
+		if iMath != fMath {
+			t.Errorf("mulByLog2Log10(%d) failed: %d vs %d\n", x, iMath, fMath)
+		}
+	}
+}
+
+func TestMulByLog10Log2(t *testing.T) {
+	for x := -500; x <= +500; x++ {
+		iMath := MulByLog10Log2(x)
+		fMath := int(math.Floor(float64(x) * math.Ln10 / math.Ln2))
+		if iMath != fMath {
+			t.Errorf("mulByLog10Log2(%d) failed: %d vs %d\n", x, iMath, fMath)
+		}
+	}
+}
diff --git a/src/strconv/internal_test.go b/src/strconv/internal_test.go
index bb4a418b30..f2cceff20e 100644
--- a/src/strconv/internal_test.go
+++ b/src/strconv/internal_test.go
@@ -21,3 +21,11 @@ func SetOptimize(b bool) bool {
 func ParseFloatPrefix(s string, bitSize int) (float64, int, error) {
 	return parseFloatPrefix(s, bitSize)
 }
+
+func MulByLog2Log10(x int) int {
+	return mulByLog2Log10(x)
+}
+
+func MulByLog10Log2(x int) int {
+	return mulByLog10Log2(x)
+}
-- 
GitLab


From 61a08fc6ce996ec403601f30c402ecfa3d588bda Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9my=20Oudompheng?= <remyoudompheng@gmail.com>
Date: Wed, 27 Mar 2019 06:55:52 +0100
Subject: [PATCH 1582/2400] =?UTF-8?q?strconv:=20Implement=20Ry=C5=AB=20alg?=
 =?UTF-8?q?orithm=20for=20ftoa=20shortest=20mode?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This patch implements the algorithm from Ulf Adams,
"Ryū: Fast Float-to-String Conversion" (doi:10.1145/3192366.3192369)
for formatting floating-point numbers with a fixed number of decimal
digits.

It is not a direct translation of the reference C implementation
but still follows the original paper. In particular, it uses full
128-bit powers of 10, which allows for more precision in the other
modes (fixed ftoa, atof).

name                              old time/op  new time/op   delta
AppendFloat/Decimal-4             49.6ns ± 3%   59.3ns ± 0%  +19.59%  (p=0.008 n=5+5)
AppendFloat/Float-4                122ns ± 1%     91ns ± 1%  -25.92%  (p=0.008 n=5+5)
AppendFloat/Exp-4                 89.3ns ± 1%  100.0ns ± 1%  +11.98%  (p=0.008 n=5+5)
AppendFloat/NegExp-4              88.3ns ± 2%   97.1ns ± 1%   +9.87%  (p=0.008 n=5+5)
AppendFloat/LongExp-4              143ns ± 2%    103ns ± 0%  -28.17%  (p=0.016 n=5+4)
AppendFloat/Big-4                  144ns ± 1%    110ns ± 1%  -23.26%  (p=0.008 n=5+5)
AppendFloat/BinaryExp-4           46.2ns ± 2%   46.0ns ± 1%     ~     (p=0.603 n=5+5)
AppendFloat/32Integer-4           49.1ns ± 1%   58.7ns ± 1%  +19.57%  (p=0.008 n=5+5)
AppendFloat/32ExactFraction-4     95.6ns ± 1%   88.6ns ± 1%   -7.30%  (p=0.008 n=5+5)
AppendFloat/32Point-4              122ns ± 1%     87ns ± 1%  -28.63%  (p=0.008 n=5+5)
AppendFloat/32Exp-4               88.6ns ± 2%   95.0ns ± 1%   +7.29%  (p=0.008 n=5+5)
AppendFloat/32NegExp-4            87.2ns ± 1%   91.3ns ± 1%   +4.63%  (p=0.008 n=5+5)
AppendFloat/32Shortest-4           107ns ± 1%     82ns ± 0%  -24.08%  (p=0.008 n=5+5)
AppendFloat/Slowpath64-4          1.00µs ± 1%   0.10µs ± 0%  -89.92%  (p=0.016 n=5+4)
AppendFloat/SlowpathDenormal64-4  34.1µs ± 3%    0.1µs ± 1%  -99.72%  (p=0.008 n=5+5)

Fixes #15672

Change-Id: Ib90dfa245f62490a6666671896013cf3f9a1fb22
Reviewed-on: https://go-review.googlesource.com/c/go/+/170080
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Trust: Nigel Tao <nigeltao@golang.org>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Nigel Tao <nigeltao@golang.org>
---
 src/strconv/ftoa.go      |  10 +-
 src/strconv/ftoa_test.go |  32 ++++-
 src/strconv/ftoaryu.go   | 255 ++++++++++++++++++++++++++++++++++++++-
 3 files changed, 287 insertions(+), 10 deletions(-)

diff --git a/src/strconv/ftoa.go b/src/strconv/ftoa.go
index a3bff52bc8..eca04b851c 100644
--- a/src/strconv/ftoa.go
+++ b/src/strconv/ftoa.go
@@ -113,15 +113,11 @@ func genericFtoa(dst []byte, val float64, fmt byte, prec, bitSize int) []byte {
 	// Negative precision means "only as much as needed to be exact."
 	shortest := prec < 0
 	if shortest {
-		// Try Grisu3 algorithm.
-		f := new(extFloat)
-		lower, upper := f.AssignComputeBounds(mant, exp, neg, flt)
+		// Use Ryu algorithm.
 		var buf [32]byte
 		digs.d = buf[:]
-		ok = f.ShortestDecimal(&digs, &lower, &upper)
-		if !ok {
-			return bigFtoa(dst, prec, fmt, neg, mant, exp, flt)
-		}
+		ryuFtoaShortest(&digs, mant, exp-int(flt.mantbits), flt)
+		ok = true
 		// Precision for shortest representation mode.
 		switch fmt {
 		case 'e', 'E':
diff --git a/src/strconv/ftoa_test.go b/src/strconv/ftoa_test.go
index b1685aeb20..73008b1c62 100644
--- a/src/strconv/ftoa_test.go
+++ b/src/strconv/ftoa_test.go
@@ -40,6 +40,7 @@ var ftoatests = []ftoaTest{
 	{200000, 'x', -1, "0x1.86ap+17"},
 	{200000, 'X', -1, "0X1.86AP+17"},
 	{2000000, 'g', -1, "2e+06"},
+	{1e10, 'g', -1, "1e+10"},
 
 	// g conversion and zero suppression
 	{400, 'g', 2, "4e+02"},
@@ -84,6 +85,7 @@ var ftoatests = []ftoaTest{
 	{1.2355, 'f', 3, "1.236"},
 	{1234567890123456.5, 'e', 15, "1.234567890123456e+15"},
 	{1234567890123457.5, 'e', 15, "1.234567890123458e+15"},
+	{108678236358137.625, 'g', -1, "1.0867823635813762e+14"},
 
 	{1e23, 'e', 17, "9.99999999999999916e+22"},
 	{1e23, 'f', 17, "99999999999999991611392.00000000000000000"},
@@ -191,6 +193,25 @@ func TestFtoa(t *testing.T) {
 	}
 }
 
+func TestFtoaPowersOfTwo(t *testing.T) {
+	for exp := -2048; exp <= 2048; exp++ {
+		f := math.Ldexp(1, exp)
+		if !math.IsInf(f, 0) {
+			s := FormatFloat(f, 'e', -1, 64)
+			if x, _ := ParseFloat(s, 64); x != f {
+				t.Errorf("failed roundtrip %v => %s => %v", f, s, x)
+			}
+		}
+		f32 := float32(f)
+		if !math.IsInf(float64(f32), 0) {
+			s := FormatFloat(float64(f32), 'e', -1, 32)
+			if x, _ := ParseFloat(s, 32); float32(x) != f32 {
+				t.Errorf("failed roundtrip %v => %s => %v", f32, s, float32(x))
+			}
+		}
+	}
+}
+
 func TestFtoaRandom(t *testing.T) {
 	N := int(1e4)
 	if testing.Short() {
@@ -240,6 +261,7 @@ var ftoaBenches = []struct {
 	{"Float", 339.7784, 'g', -1, 64},
 	{"Exp", -5.09e75, 'g', -1, 64},
 	{"NegExp", -5.11e-95, 'g', -1, 64},
+	{"LongExp", 1.234567890123456e-78, 'g', -1, 64},
 
 	{"Big", 123456789123456789123456789, 'g', -1, 64},
 	{"BinaryExp", -1, 'b', -1, 64},
@@ -249,6 +271,7 @@ var ftoaBenches = []struct {
 	{"32Point", 339.7784, 'g', -1, 32},
 	{"32Exp", -5.09e25, 'g', -1, 32},
 	{"32NegExp", -5.11e-25, 'g', -1, 32},
+	{"32Shortest", 1.234567e-8, 'g', -1, 32},
 	{"32Fixed8Hard", math.Ldexp(15961084, -125), 'e', 8, 32},
 	{"32Fixed9Hard", math.Ldexp(14855922, -83), 'e', 9, 32},
 
@@ -264,7 +287,14 @@ var ftoaBenches = []struct {
 	{"64Fixed18Hard", math.Ldexp(6994187472632449, 690), 'e', 18, 64},
 
 	// Trigger slow path (see issue #15672).
-	{"Slowpath64", 622666234635.3213e-320, 'e', -1, 64},
+	// The shortest is: 8.034137530808823e+43
+	{"Slowpath64", 8.03413753080882349e+43, 'e', -1, 64},
+	// This denormal is pathological because the lower/upper
+	// halfways to neighboring floats are:
+	// 622666234635.321003e-320 ~= 622666234635.321e-320
+	// 622666234635.321497e-320 ~= 622666234635.3215e-320
+	// making it hard to find the 3rd digit
+	{"SlowpathDenormal64", 622666234635.3213e-320, 'e', -1, 64},
 }
 
 func BenchmarkFormatFloat(b *testing.B) {
diff --git a/src/strconv/ftoaryu.go b/src/strconv/ftoaryu.go
index 44a55b1da9..e53de75667 100644
--- a/src/strconv/ftoaryu.go
+++ b/src/strconv/ftoaryu.go
@@ -218,6 +218,109 @@ func formatDecimal(d *decimalSlice, m uint64, trunc bool, roundUp bool, prec int
 	d.dp = d.nd + trimmed
 }
 
+// ryuFtoaShortest formats mant*2^exp with prec decimal digits.
+func ryuFtoaShortest(d *decimalSlice, mant uint64, exp int, flt *floatInfo) {
+	if mant == 0 {
+		d.nd, d.dp = 0, 0
+		return
+	}
+	// If input is an exact integer with fewer bits than the mantissa,
+	// the previous and next integer are not admissible representations.
+	if exp <= 0 && bits.TrailingZeros64(mant) >= -exp {
+		mant >>= uint(-exp)
+		ryuDigits(d, mant, mant, mant, true, false)
+		return
+	}
+	ml, mc, mu, e2 := computeBounds(mant, exp, flt)
+	if e2 == 0 {
+		ryuDigits(d, ml, mc, mu, true, false)
+		return
+	}
+	// Find 10^q *larger* than 2^-e2
+	q := mulByLog2Log10(-e2) + 1
+
+	// We are going to multiply by 10^q using 128-bit arithmetic.
+	// The exponent is the same for all 3 numbers.
+	var dl, dc, du uint64
+	var dl0, dc0, du0 bool
+	if flt == &float32info {
+		var dl32, dc32, du32 uint32
+		dl32, _, dl0 = mult64bitPow10(uint32(ml), e2, q)
+		dc32, _, dc0 = mult64bitPow10(uint32(mc), e2, q)
+		du32, e2, du0 = mult64bitPow10(uint32(mu), e2, q)
+		dl, dc, du = uint64(dl32), uint64(dc32), uint64(du32)
+	} else {
+		dl, _, dl0 = mult128bitPow10(ml, e2, q)
+		dc, _, dc0 = mult128bitPow10(mc, e2, q)
+		du, e2, du0 = mult128bitPow10(mu, e2, q)
+	}
+	if e2 >= 0 {
+		panic("not enough significant bits after mult128bitPow10")
+	}
+	// Is it an exact computation?
+	if q > 55 {
+		// Large positive powers of ten are not exact
+		dl0, dc0, du0 = false, false, false
+	}
+	if q < 0 && q >= -24 {
+		// Division by a power of ten may be exact.
+		// (note that 5^25 is a 59-bit number so division by 5^25 is never exact).
+		if divisibleByPower5(ml, -q) {
+			dl0 = true
+		}
+		if divisibleByPower5(mc, -q) {
+			dc0 = true
+		}
+		if divisibleByPower5(mu, -q) {
+			du0 = true
+		}
+	}
+	// Express the results (dl, dc, du)*2^e2 as integers.
+	// Extra bits must be removed and rounding hints computed.
+	extra := uint(-e2)
+	extraMask := uint64(1<<extra - 1)
+	// Now compute the floored, integral base 10 mantissas.
+	dl, fracl := dl>>extra, dl&extraMask
+	dc, fracc := dc>>extra, dc&extraMask
+	du, fracu := du>>extra, du&extraMask
+	// Is it allowed to use 'du' as a result?
+	// It is always allowed when it is truncated, but also
+	// if it is exact and the original binary mantissa is even
+	// When disallowed, we can substract 1.
+	uok := !du0 || fracu > 0
+	if du0 && fracu == 0 {
+		uok = mant&1 == 0
+	}
+	if !uok {
+		du--
+	}
+	// Is 'dc' the correctly rounded base 10 mantissa?
+	// The correct rounding might be dc+1
+	cup := false // don't round up.
+	if dc0 {
+		// If we computed an exact product, the half integer
+		// should round to next (even) integer if 'dc' is odd.
+		cup = fracc > 1<<(extra-1) ||
+			(fracc == 1<<(extra-1) && dc&1 == 1)
+	} else {
+		// otherwise, the result is a lower truncation of the ideal
+		// result.
+		cup = fracc>>(extra-1) == 1
+	}
+	// Is 'dl' an allowed representation?
+	// Only if it is an exact value, and if the original binary mantissa
+	// was even.
+	lok := dl0 && fracl == 0 && (mant&1 == 0)
+	if !lok {
+		dl++
+	}
+	// We need to remember whether the trimmed digits of 'dc' are zero.
+	c0 := dc0 && fracc == 0
+	// render digits
+	ryuDigits(d, dl, dc, du, c0, cup)
+	d.dp -= q
+}
+
 // mulByLog2Log10 returns math.Floor(x * log(2)/log(10)) for an integer x in
 // the range -1600 <= x && x <= +1600.
 //
@@ -238,6 +341,140 @@ func mulByLog10Log2(x int) int {
 	return (x * 108853) >> 15
 }
 
+// computeBounds returns a floating-point vector (l, c, u)×2^e2
+// where the mantissas are 55-bit (or 26-bit) integers, describing the interval
+// represented by the input float64 or float32.
+func computeBounds(mant uint64, exp int, flt *floatInfo) (lower, central, upper uint64, e2 int) {
+	if mant != 1<<flt.mantbits || exp == flt.bias+1-int(flt.mantbits) {
+		// regular case (or denormals)
+		lower, central, upper = 2*mant-1, 2*mant, 2*mant+1
+		e2 = exp - 1
+		return
+	} else {
+		// border of an exponent
+		lower, central, upper = 4*mant-1, 4*mant, 4*mant+2
+		e2 = exp - 2
+		return
+	}
+}
+
+func ryuDigits(d *decimalSlice, lower, central, upper uint64,
+	c0, cup bool) {
+	lhi, llo := divmod1e9(lower)
+	chi, clo := divmod1e9(central)
+	uhi, ulo := divmod1e9(upper)
+	if uhi == 0 {
+		// only low digits (for denormals)
+		ryuDigits32(d, llo, clo, ulo, c0, cup, 8)
+	} else if lhi < uhi {
+		// truncate 9 digits at once.
+		if llo != 0 {
+			lhi++
+		}
+		c0 = c0 && clo == 0
+		cup = (clo > 5e8) || (clo == 5e8 && cup)
+		ryuDigits32(d, lhi, chi, uhi, c0, cup, 8)
+		d.dp += 9
+	} else {
+		d.nd = 0
+		// emit high part
+		n := uint(9)
+		for v := chi; v > 0; {
+			v1, v2 := v/10, v%10
+			v = v1
+			n--
+			d.d[n] = byte(v2 + '0')
+		}
+		d.d = d.d[n:]
+		d.nd = int(9 - n)
+		// emit low part
+		ryuDigits32(d, llo, clo, ulo,
+			c0, cup, d.nd+8)
+	}
+	// trim trailing zeros
+	for d.nd > 0 && d.d[d.nd-1] == '0' {
+		d.nd--
+	}
+	// trim initial zeros
+	for d.nd > 0 && d.d[0] == '0' {
+		d.nd--
+		d.dp--
+		d.d = d.d[1:]
+	}
+}
+
+// ryuDigits32 emits decimal digits for a number less than 1e9.
+func ryuDigits32(d *decimalSlice, lower, central, upper uint32,
+	c0, cup bool, endindex int) {
+	if upper == 0 {
+		d.dp = endindex + 1
+		return
+	}
+	trimmed := 0
+	// Remember last trimmed digit to check for round-up.
+	// c0 will be used to remember zeroness of following digits.
+	cNextDigit := 0
+	for upper > 0 {
+		// Repeatedly compute:
+		// l = Ceil(lower / 10^k)
+		// c = Round(central / 10^k)
+		// u = Floor(upper / 10^k)
+		// and stop when c goes out of the (l, u) interval.
+		l := (lower + 9) / 10
+		c, cdigit := central/10, central%10
+		u := upper / 10
+		if l > u {
+			// don't trim the last digit as it is forbidden to go below l
+			// other, trim and exit now.
+			break
+		}
+		// Check that we didn't cross the lower boundary.
+		// The case where l < u but c == l-1 is essentially impossible,
+		// but may happen if:
+		//    lower   = ..11
+		//    central = ..19
+		//    upper   = ..31
+		// and means that 'central' is very close but less than
+		// an integer ending with many zeros, and usually
+		// the "round-up" logic hides the problem.
+		if l == c+1 && c < u {
+			c++
+			cdigit = 0
+			cup = false
+		}
+		trimmed++
+		// Remember trimmed digits of c
+		c0 = c0 && cNextDigit == 0
+		cNextDigit = int(cdigit)
+		lower, central, upper = l, c, u
+	}
+	// should we round up?
+	if trimmed > 0 {
+		cup = cNextDigit > 5 ||
+			(cNextDigit == 5 && !c0) ||
+			(cNextDigit == 5 && c0 && central&1 == 1)
+	}
+	if central < upper && cup {
+		central++
+	}
+	// We know where the number ends, fill directly
+	endindex -= trimmed
+	v := central
+	n := endindex
+	for n > d.nd {
+		v1, v2 := v/100, v%100
+		d.d[n] = smallsString[2*v2+1]
+		d.d[n-1] = smallsString[2*v2+0]
+		n -= 2
+		v = v1
+	}
+	if n == d.nd {
+		d.d[n] = byte(v + '0')
+	}
+	d.nd = endindex + 1
+	d.dp = d.nd + trimmed
+}
+
 // mult64bitPow10 takes a floating-point input with a 25-bit
 // mantissa and multiplies it with 10^q. The resulting mantissa
 // is m*P >> 57 where P is a 64-bit element of the detailedPowersOfTen tables.
@@ -249,7 +486,8 @@ func mulByLog10Log2(x int) int {
 //     exact = ε == 0
 func mult64bitPow10(m uint32, e2, q int) (resM uint32, resE int, exact bool) {
 	if q == 0 {
-		return m << 7, e2 - 7, true
+		// P == 1<<63
+		return m << 6, e2 - 6, true
 	}
 	if q < detailedPowersOfTenMinExp10 || detailedPowersOfTenMaxExp10 < q {
 		// This never happens due to the range of float32/float64 exponent
@@ -276,7 +514,8 @@ func mult64bitPow10(m uint32, e2, q int) (resM uint32, resE int, exact bool) {
 //     exact = ε == 0
 func mult128bitPow10(m uint64, e2, q int) (resM uint64, resE int, exact bool) {
 	if q == 0 {
-		return m << 9, e2 - 9, true
+		// P == 1<<127
+		return m << 8, e2 - 8, true
 	}
 	if q < detailedPowersOfTenMinExp10 || detailedPowersOfTenMaxExp10 < q {
 		// This never happens due to the range of float32/float64 exponent
@@ -309,3 +548,15 @@ func divisibleByPower5(m uint64, k int) bool {
 	}
 	return true
 }
+
+// divmod1e9 computes quotient and remainder of division by 1e9,
+// avoiding runtime uint64 division on 32-bit platforms.
+func divmod1e9(x uint64) (uint32, uint32) {
+	if !host32bit {
+		return uint32(x / 1e9), uint32(x % 1e9)
+	}
+	// Use the same sequence of operations as the amd64 compiler.
+	hi, _ := bits.Mul64(x>>1, 0x89705f4136b4a598) // binary digits of 1e-9
+	q := hi >> 28
+	return uint32(q), uint32(x - q*1e9)
+}
-- 
GitLab


From b1c4cc558958e564846eecb68ff0ee99c820d221 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Thu, 15 Apr 2021 10:48:12 +0200
Subject: [PATCH 1583/2400] mime: keep builtinTypesLower sorted alphabetically

Updates #44602

Change-Id: I2c32e388143e56928850821587f57d9729434220
Reviewed-on: https://go-review.googlesource.com/c/go/+/310034
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/mime/type.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/mime/type.go b/src/mime/type.go
index a13aa04b5b..9bbbf216a1 100644
--- a/src/mime/type.go
+++ b/src/mime/type.go
@@ -58,6 +58,7 @@ func setMimeTypes(lowerExt, mixExt map[string]string) {
 }
 
 var builtinTypesLower = map[string]string{
+	".avif": "image/avif",
 	".css":  "text/css; charset=utf-8",
 	".gif":  "image/gif",
 	".htm":  "text/html; charset=utf-8",
@@ -72,7 +73,6 @@ var builtinTypesLower = map[string]string{
 	".svg":  "image/svg+xml",
 	".wasm": "application/wasm",
 	".webp": "image/webp",
-	".avif": "image/avif",
 	".xml":  "text/xml; charset=utf-8",
 }
 
-- 
GitLab


From 3e0b1cdb5d92ac45a28c3c8224e1b6ab41bff99d Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Tue, 13 Apr 2021 23:46:18 -0400
Subject: [PATCH 1584/2400] runtime: minor refactoring of _rt0_amd64_lib

This function bounces between the C and Go ABIs a few times. This CL
narrows the scope of the Go -> C transition to just around the branch
that calls C. This lets us take advantage of C callee-save registers
to simplify the code a little.

Change-Id: I1ffa0b9e50325425c5ec66596978aeb6450a6b57
Reviewed-on: https://go-review.googlesource.com/c/go/+/309929
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/asm_amd64.s | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index a88cd17e6b..1c74d70d36 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -28,10 +28,7 @@ TEXT main(SB),NOSPLIT,$-8
 // c-archive) or when the shared library is loaded (for c-shared).
 // We expect argc and argv to be passed in the usual C ABI registers
 // DI and SI.
-TEXT _rt0_amd64_lib(SB),NOSPLIT,$0x50
-	// Align stack per ELF ABI requirements.
-	MOVQ	SP, AX
-	ANDQ	$~15, SP
+TEXT _rt0_amd64_lib(SB),NOSPLIT,$0x40
 	// Save C ABI callee-saved registers, as caller may need them.
 	MOVQ	BX, 0x10(SP)
 	MOVQ	BP, 0x18(SP)
@@ -39,7 +36,6 @@ TEXT _rt0_amd64_lib(SB),NOSPLIT,$0x50
 	MOVQ	R13, 0x28(SP)
 	MOVQ	R14, 0x30(SP)
 	MOVQ	R15, 0x38(SP)
-	MOVQ	AX, 0x40(SP)
 
 	MOVQ	DI, _rt0_amd64_lib_argc<>(SB)
 	MOVQ	SI, _rt0_amd64_lib_argv<>(SB)
@@ -51,9 +47,15 @@ TEXT _rt0_amd64_lib(SB),NOSPLIT,$0x50
 	MOVQ	_cgo_sys_thread_create(SB), AX
 	TESTQ	AX, AX
 	JZ	nocgo
+
+	// We're calling back to C.
+	// Align stack per ELF ABI requirements.
+	MOVQ	SP, BX  // Callee-save in C ABI
+	ANDQ	$~15, SP
 	MOVQ	$_rt0_amd64_lib_go(SB), DI
 	MOVQ	$0, SI
 	CALL	AX
+	MOVQ	BX, SP
 	JMP	restore
 
 nocgo:
@@ -69,7 +71,6 @@ restore:
 	MOVQ	0x28(SP), R13
 	MOVQ	0x30(SP), R14
 	MOVQ	0x38(SP), R15
-	MOVQ	0x40(SP), SP
 	RET
 
 // _rt0_amd64_lib_go initializes the Go runtime.
-- 
GitLab


From dba2eab8267599f5f59f1f586b47f31b6552938c Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Tue, 13 Apr 2021 09:06:50 -0400
Subject: [PATCH 1585/2400] runtime,runtime/cgo: save all necessary registers
 on entry to Go on Windows

There are several assembly functions that transition from the Windows
ABI to the Go ABI. These all need to save all registers that are
callee-save in the Windows ABI and caller-save in the Go ABI and
prepare the register state for Go. However, they all do this slightly
differently and most of them don't save the necessary XMM registers
for this transition (which could corrupt them in the C caller).
Furthermore, now that we have a carefully specified Go ABI, it's clear
that none of these actually get all of the details 100% right.

So, unify this code into two macros in a shared header in
runtime/cgo/abi_amd64.h that handle all necessary registers and setup
and use these macros everywhere on Windows that handles transitions
from C to Go.

Change-Id: I62f41345a507aad1ca383814ac8b7e2a9ffb821e
Reviewed-on: https://go-review.googlesource.com/c/go/+/309769
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/cmd/internal/obj/x86/obj6.go |  2 +-
 src/runtime/cgo/abi_amd64.h      | 69 ++++++++++++++++++++++++++
 src/runtime/cgo/asm_amd64.s      | 58 ++++++++--------------
 src/runtime/sys_windows_amd64.s  | 83 +++++++++-----------------------
 4 files changed, 113 insertions(+), 99 deletions(-)
 create mode 100644 src/runtime/cgo/abi_amd64.h

diff --git a/src/cmd/internal/obj/x86/obj6.go b/src/cmd/internal/obj/x86/obj6.go
index b8c7ad7d1b..06736d43bd 100644
--- a/src/cmd/internal/obj/x86/obj6.go
+++ b/src/cmd/internal/obj/x86/obj6.go
@@ -912,7 +912,7 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 		}
 
 		if autoffset != deltasp {
-			ctxt.Diag("unbalanced PUSH/POP")
+			ctxt.Diag("%s: unbalanced PUSH/POP", cursym)
 		}
 
 		if autoffset != 0 {
diff --git a/src/runtime/cgo/abi_amd64.h b/src/runtime/cgo/abi_amd64.h
new file mode 100644
index 0000000000..44cc0969da
--- /dev/null
+++ b/src/runtime/cgo/abi_amd64.h
@@ -0,0 +1,69 @@
+// Copyright 2021 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.
+
+// Macros for transitioning from the host ABI to Go ABI0.
+//
+// TODO(austin): Define these for ELF platforms as well.
+
+#ifdef GOOS_windows
+
+// REGS_HOST_TO_ABI0_STACK is the stack bytes used by
+// PUSH_REGS_HOST_TO_ABI0.
+#define REGS_HOST_TO_ABI0_STACK (28*8 + 8)
+
+// PUSH_REGS_HOST_TO_ABI0 prepares for transitioning from
+// the host ABI to Go ABI0 code. It saves all registers that are
+// callee-save in the host ABI and caller-save in Go ABI0 and prepares
+// for entry to Go.
+//
+// Save DI SI BP BX R12 R13 R14 R15 X6-X15 registers and the DF flag.
+// Clear the DF flag for the Go ABI.
+// MXCSR matches the Go ABI, so we don't have to set that,
+// and Go doesn't modify it, so we don't have to save it.
+#define PUSH_REGS_HOST_TO_ABI0()	\
+	PUSHFQ			\
+	CLD			\
+	ADJSP	$(REGS_HOST_TO_ABI0_STACK - 8)	\
+	MOVQ	DI, (0*0)(SP)	\
+	MOVQ	SI, (1*8)(SP)	\
+	MOVQ	BP, (2*8)(SP)	\
+	MOVQ	BX, (3*8)(SP)	\
+	MOVQ	R12, (4*8)(SP)	\
+	MOVQ	R13, (5*8)(SP)	\
+	MOVQ	R14, (6*8)(SP)	\
+	MOVQ	R15, (7*8)(SP)	\
+	MOVUPS	X6, (8*8)(SP)	\
+	MOVUPS	X7, (10*8)(SP)	\
+	MOVUPS	X8, (12*8)(SP)	\
+	MOVUPS	X9, (14*8)(SP)	\
+	MOVUPS	X10, (16*8)(SP)	\
+	MOVUPS	X11, (18*8)(SP)	\
+	MOVUPS	X12, (20*8)(SP)	\
+	MOVUPS	X13, (22*8)(SP)	\
+	MOVUPS	X14, (24*8)(SP)	\
+	MOVUPS	X15, (26*8)(SP)
+
+#define POP_REGS_HOST_TO_ABI0()	\
+	MOVQ	(0*0)(SP), DI	\
+	MOVQ	(1*8)(SP), SI	\
+	MOVQ	(2*8)(SP), BP	\
+	MOVQ	(3*8)(SP), BX	\
+	MOVQ	(4*8)(SP), R12	\
+	MOVQ	(5*8)(SP), R13	\
+	MOVQ	(6*8)(SP), R14	\
+	MOVQ	(7*8)(SP), R15	\
+	MOVUPS	(8*8)(SP), X6	\
+	MOVUPS	(10*8)(SP), X7	\
+	MOVUPS	(12*8)(SP), X8	\
+	MOVUPS	(14*8)(SP), X9	\
+	MOVUPS	(16*8)(SP), X10	\
+	MOVUPS	(18*8)(SP), X11	\
+	MOVUPS	(20*8)(SP), X12	\
+	MOVUPS	(22*8)(SP), X13	\
+	MOVUPS	(24*8)(SP), X14	\
+	MOVUPS	(26*8)(SP), X15	\
+	ADJSP	$-(REGS_HOST_TO_ABI0_STACK - 8)	\
+	POPFQ
+
+#endif
diff --git a/src/runtime/cgo/asm_amd64.s b/src/runtime/cgo/asm_amd64.s
index 5dc8e2d235..447ddb118d 100644
--- a/src/runtime/cgo/asm_amd64.s
+++ b/src/runtime/cgo/asm_amd64.s
@@ -3,6 +3,7 @@
 // license that can be found in the LICENSE file.
 
 #include "textflag.h"
+#include "abi_amd64.h"
 
 // Called by C code generated by cmd/cgo.
 // func crosscall2(fn, a unsafe.Pointer, n int32, ctxt uintptr)
@@ -11,57 +12,18 @@
 // This signature is known to SWIG, so we can't change it.
 #ifndef GOOS_windows
 TEXT crosscall2(SB),NOSPLIT,$0x50-0 /* keeps stack pointer 32-byte aligned */
-#else
-TEXT crosscall2(SB),NOSPLIT,$0x110-0 /* also need to save xmm6 - xmm15 */
-#endif
 	MOVQ	BX, 0x18(SP)
 	MOVQ	R12, 0x28(SP)
 	MOVQ	R13, 0x30(SP)
 	MOVQ	R14, 0x38(SP)
 	MOVQ	R15, 0x40(SP)
 
-#ifdef GOOS_windows
-	// Win64 save RBX, RBP, RDI, RSI, RSP, R12, R13, R14, R15 and XMM6 -- XMM15.
-	MOVQ	DI, 0x48(SP)
-	MOVQ	SI, 0x50(SP)
-	MOVUPS	X6, 0x60(SP)
-	MOVUPS	X7, 0x70(SP)
-	MOVUPS	X8, 0x80(SP)
-	MOVUPS	X9, 0x90(SP)
-	MOVUPS	X10, 0xa0(SP)
-	MOVUPS	X11, 0xb0(SP)
-	MOVUPS	X12, 0xc0(SP)
-	MOVUPS	X13, 0xd0(SP)
-	MOVUPS	X14, 0xe0(SP)
-	MOVUPS	X15, 0xf0(SP)
-
-	MOVQ	CX, 0x0(SP)	/* fn */
-	MOVQ	DX, 0x8(SP)	/* arg */
-	// Skip n in R8.
-	MOVQ	R9, 0x10(SP)	/* ctxt */
-
-	CALL	runtime·cgocallback(SB)
-
-	MOVQ	0x48(SP), DI
-	MOVQ	0x50(SP), SI
-	MOVUPS	0x60(SP), X6
-	MOVUPS	0x70(SP), X7
-	MOVUPS	0x80(SP), X8
-	MOVUPS	0x90(SP), X9
-	MOVUPS	0xa0(SP), X10
-	MOVUPS	0xb0(SP), X11
-	MOVUPS	0xc0(SP), X12
-	MOVUPS	0xd0(SP), X13
-	MOVUPS	0xe0(SP), X14
-	MOVUPS	0xf0(SP), X15
-#else
 	MOVQ	DI, 0x0(SP)	/* fn */
 	MOVQ	SI, 0x8(SP)	/* arg */
 	// Skip n in DX.
 	MOVQ	CX, 0x10(SP)	/* ctxt */
 
 	CALL	runtime·cgocallback(SB)
-#endif
 
 	MOVQ	0x18(SP), BX
 	MOVQ	0x28(SP), R12
@@ -70,3 +32,21 @@ TEXT crosscall2(SB),NOSPLIT,$0x110-0 /* also need to save xmm6 - xmm15 */
 	MOVQ	0x40(SP), R15
 
 	RET
+
+#else
+TEXT crosscall2(SB),NOSPLIT,$0-0
+	PUSH_REGS_HOST_TO_ABI0()
+
+	// Make room for arguments to cgocallback.
+	ADJSP	$0x18
+	MOVQ	CX, 0x0(SP)	/* fn */
+	MOVQ	DX, 0x8(SP)	/* arg */
+	// Skip n in R8.
+	MOVQ	R9, 0x10(SP)	/* ctxt */
+
+	CALL	runtime·cgocallback(SB)
+
+	ADJSP	$-0x18
+	POP_REGS_HOST_TO_ABI0()
+	RET
+#endif
diff --git a/src/runtime/sys_windows_amd64.s b/src/runtime/sys_windows_amd64.s
index 6896331329..a9a7dfdd49 100644
--- a/src/runtime/sys_windows_amd64.s
+++ b/src/runtime/sys_windows_amd64.s
@@ -5,6 +5,7 @@
 #include "go_asm.h"
 #include "go_tls.h"
 #include "textflag.h"
+#include "cgo/abi_amd64.h"
 
 // maxargs should be divisible by 2, as Windows stack
 // must be kept 16-byte aligned on syscall entry.
@@ -111,18 +112,10 @@ TEXT runtime·getlasterror(SB),NOSPLIT,$0
 TEXT sigtramp<>(SB),NOSPLIT|NOFRAME,$0-0
 	// CX: PEXCEPTION_POINTERS ExceptionInfo
 
-	// DI SI BP BX R12 R13 R14 R15 registers and DF flag are preserved
-	// as required by windows callback convention.
-	PUSHFQ
-	SUBQ	$112, SP
-	MOVQ	DI, 80(SP)
-	MOVQ	SI, 72(SP)
-	MOVQ	BP, 64(SP)
-	MOVQ	BX, 56(SP)
-	MOVQ	R12, 48(SP)
-	MOVQ	R13, 40(SP)
-	MOVQ	R14, 32(SP)
-	MOVQ	R15, 88(SP)
+	// Switch from the host ABI to the Go ABI.
+	PUSH_REGS_HOST_TO_ABI0()
+	// Make stack space for the rest of the function.
+	ADJSP	$48
 
 	MOVQ	AX, R15	// save handler address
 
@@ -138,8 +131,8 @@ TEXT sigtramp<>(SB),NOSPLIT|NOFRAME,$0-0
 	CALL	runtime·badsignal2(SB)
 
 	// save g and SP in case of stack switch
-	MOVQ	DX, 96(SP) // g
-	MOVQ	SP, 104(SP)
+	MOVQ	DX, 32(SP) // g
+	MOVQ	SP, 40(SP)
 
 	// do we need to switch to the g0 stack?
 	MOVQ	g_m(DX), BX
@@ -153,9 +146,11 @@ TEXT sigtramp<>(SB),NOSPLIT|NOFRAME,$0-0
 	MOVQ	(g_sched+gobuf_sp)(BX), DI
 	// make room for sighandler arguments
 	// and re-save old SP for restoring later.
-	// (note that the 104(DI) here must match the 104(SP) above.)
-	SUBQ	$120, DI
-	MOVQ	SP, 104(DI)
+	// Adjust g0 stack by the space we're using and
+	// save SP at the same place on the g0 stack.
+	// The 32(DI) here must match the 32(SP) above.
+	SUBQ	$(REGS_HOST_TO_ABI0_STACK + 48), DI
+	MOVQ	SP, 40(DI)
 	MOVQ	DI, SP
 
 g0:
@@ -170,23 +165,14 @@ g0:
 
 	// switch back to original stack and g
 	// no-op if we never left.
-	MOVQ	104(SP), SP
-	MOVQ	96(SP), DX
+	MOVQ	40(SP), SP
+	MOVQ	32(SP), DX
 	get_tls(BP)
 	MOVQ	DX, g(BP)
 
 done:
-	// restore registers as required for windows callback
-	MOVQ	88(SP), R15
-	MOVQ	32(SP), R14
-	MOVQ	40(SP), R13
-	MOVQ	48(SP), R12
-	MOVQ	56(SP), BX
-	MOVQ	64(SP), BP
-	MOVQ	72(SP), SI
-	MOVQ	80(SP), DI
-	ADDQ	$112, SP
-	POPFQ
+	ADJSP	$-48
+	POP_REGS_HOST_TO_ABI0()
 
 	RET
 
@@ -230,21 +216,8 @@ TEXT runtime·callbackasm1(SB),NOSPLIT,$0
 	DIVL	CX
 	SUBQ	$1, AX	// subtract 1 because return PC is to the next slot
 
-	// DI SI BP BX R12 R13 R14 R15 registers and DF flag are preserved
-	// as required by windows callback convention.
-	PUSHFQ
-	SUBQ	$64, SP
-	MOVQ	DI, 56(SP)
-	MOVQ	SI, 48(SP)
-	MOVQ	BP, 40(SP)
-	MOVQ	BX, 32(SP)
-	MOVQ	R12, 24(SP)
-	MOVQ	R13, 16(SP)
-	MOVQ	R14, 8(SP)
-	MOVQ	R15, 0(SP)
-
-	// Go ABI requires DF flag to be cleared.
-	CLD
+	// Switch from the host ABI to the Go ABI.
+	PUSH_REGS_HOST_TO_ABI0()
 
 	// Create a struct callbackArgs on our stack to be passed as
 	// the "frame" to cgocallback and on to callbackWrap.
@@ -263,23 +236,16 @@ TEXT runtime·callbackasm1(SB),NOSPLIT,$0
 	MOVQ	(24+callbackArgs_result)(SP), AX
 	ADDQ	$(24+callbackArgs__size), SP
 
-	// restore registers as required for windows callback
-	MOVQ	0(SP), R15
-	MOVQ	8(SP), R14
-	MOVQ	16(SP), R13
-	MOVQ	24(SP), R12
-	MOVQ	32(SP), BX
-	MOVQ	40(SP), BP
-	MOVQ	48(SP), SI
-	MOVQ	56(SP), DI
-	ADDQ	$64, SP
-	POPFQ
+	POP_REGS_HOST_TO_ABI0()
 
 	// The return value was placed in AX above.
 	RET
 
 // uint32 tstart_stdcall(M *newm);
 TEXT runtime·tstart_stdcall<ABIInternal>(SB),NOSPLIT,$0
+	// Switch from the host ABI to the Go ABI.
+	PUSH_REGS_HOST_TO_ABI0()
+
 	// CX contains first arg newm
 	MOVQ	m_g0(CX), DX		// g
 
@@ -298,12 +264,11 @@ TEXT runtime·tstart_stdcall<ABIInternal>(SB),NOSPLIT,$0
 	MOVQ	CX, g_m(DX)
 	MOVQ	DX, g(SI)
 
-	// Someday the convention will be D is always cleared.
-	CLD
-
 	CALL	runtime·stackcheck(SB)	// clobbers AX,CX
 	CALL	runtime·mstart(SB)
 
+	POP_REGS_HOST_TO_ABI0()
+
 	XORL	AX, AX			// return 0 == success
 	RET
 
-- 
GitLab


From 7ad496b6f5300131d6f1fbafe44ac882897889e4 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Tue, 13 Apr 2021 23:30:19 -0400
Subject: [PATCH 1586/2400] runtime: unify C->Go ABI transitions

The previous CL introduced macros for transitions from the Windows ABI
to the Go ABI. This CL does the same for SysV and uses them in almost
all places where we transition from the C ABI to the Go ABI.

Compared to Windows, this transition is much simpler and I didn't find
any places that were getting it wrong. But this does let us unify a
lot of code nicely and introduces some degree of abstraction around
these ABI transitions.

Change-Id: Ib6bdecafce587ce18fca4c8300fcf401284a2bcd
Reviewed-on: https://go-review.googlesource.com/c/go/+/309930
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/asm_amd64.s           | 21 ++++-------
 src/runtime/cgo/abi_amd64.h       | 32 +++++++++++++++-
 src/runtime/cgo/asm_amd64.s       | 30 +++------------
 src/runtime/os_linux.go           |  2 +-
 src/runtime/race_amd64.s          | 25 +++----------
 src/runtime/sys_darwin_amd64.s    | 59 ++++++++----------------------
 src/runtime/sys_dragonfly_amd64.s | 38 ++++++++-----------
 src/runtime/sys_freebsd_amd64.s   | 38 ++++++++-----------
 src/runtime/sys_linux_386.s       |  7 ++--
 src/runtime/sys_linux_amd64.s     | 39 ++++++++------------
 src/runtime/sys_netbsd_amd64.s    | 38 ++++++++-----------
 src/runtime/sys_openbsd_amd64.s   | 61 ++++++++++---------------------
 12 files changed, 152 insertions(+), 238 deletions(-)

diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index 1c74d70d36..ca6b1501d1 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -6,6 +6,7 @@
 #include "go_tls.h"
 #include "funcdata.h"
 #include "textflag.h"
+#include "cgo/abi_amd64.h"
 
 // _rt0_amd64 is common startup code for most amd64 systems when using
 // internal linking. This is the entry point for the program from the
@@ -28,14 +29,9 @@ TEXT main(SB),NOSPLIT,$-8
 // c-archive) or when the shared library is loaded (for c-shared).
 // We expect argc and argv to be passed in the usual C ABI registers
 // DI and SI.
-TEXT _rt0_amd64_lib(SB),NOSPLIT,$0x40
-	// Save C ABI callee-saved registers, as caller may need them.
-	MOVQ	BX, 0x10(SP)
-	MOVQ	BP, 0x18(SP)
-	MOVQ	R12, 0x20(SP)
-	MOVQ	R13, 0x28(SP)
-	MOVQ	R14, 0x30(SP)
-	MOVQ	R15, 0x38(SP)
+TEXT _rt0_amd64_lib(SB),NOSPLIT,$0
+	// Transition from C ABI to Go ABI.
+	PUSH_REGS_HOST_TO_ABI0()
 
 	MOVQ	DI, _rt0_amd64_lib_argc<>(SB)
 	MOVQ	SI, _rt0_amd64_lib_argv<>(SB)
@@ -59,18 +55,15 @@ TEXT _rt0_amd64_lib(SB),NOSPLIT,$0x40
 	JMP	restore
 
 nocgo:
+	ADJSP	$16
 	MOVQ	$0x800000, 0(SP)		// stacksize
 	MOVQ	$_rt0_amd64_lib_go(SB), AX
 	MOVQ	AX, 8(SP)			// fn
 	CALL	runtime·newosproc0(SB)
+	ADJSP	$-16
 
 restore:
-	MOVQ	0x10(SP), BX
-	MOVQ	0x18(SP), BP
-	MOVQ	0x20(SP), R12
-	MOVQ	0x28(SP), R13
-	MOVQ	0x30(SP), R14
-	MOVQ	0x38(SP), R15
+	POP_REGS_HOST_TO_ABI0()
 	RET
 
 // _rt0_amd64_lib_go initializes the Go runtime.
diff --git a/src/runtime/cgo/abi_amd64.h b/src/runtime/cgo/abi_amd64.h
index 44cc0969da..9949435fe9 100644
--- a/src/runtime/cgo/abi_amd64.h
+++ b/src/runtime/cgo/abi_amd64.h
@@ -4,7 +4,9 @@
 
 // Macros for transitioning from the host ABI to Go ABI0.
 //
-// TODO(austin): Define these for ELF platforms as well.
+// These save the frame pointer, so in general, functions that use
+// these should have zero frame size to suppress the automatic frame
+// pointer, though it's harmless to not do this.
 
 #ifdef GOOS_windows
 
@@ -66,4 +68,32 @@
 	ADJSP	$-(REGS_HOST_TO_ABI0_STACK - 8)	\
 	POPFQ
 
+#else
+// SysV ABI
+
+#define REGS_HOST_TO_ABI0_STACK (6*8)
+
+// SysV MXCSR matches the Go ABI, so we don't have to set that,
+// and Go doesn't modify it, so we don't have to save it.
+// Both SysV and Go require DF to be cleared, so that's already clear.
+// The SysV and Go frame pointer conventions are compatible.
+#define PUSH_REGS_HOST_TO_ABI0()	\
+	ADJSP	$(REGS_HOST_TO_ABI0_STACK)	\
+	MOVQ	BP, (5*8)(SP)	\
+	LEAQ	(5*8)(SP), BP	\
+	MOVQ	BX, (0*8)(SP)	\
+	MOVQ	R12, (1*8)(SP)	\
+	MOVQ	R13, (2*8)(SP)	\
+	MOVQ	R14, (3*8)(SP)	\
+	MOVQ	R15, (4*8)(SP)
+
+#define POP_REGS_HOST_TO_ABI0()	\
+	MOVQ	(0*8)(SP), BX	\
+	MOVQ	(1*8)(SP), R12	\
+	MOVQ	(2*8)(SP), R13	\
+	MOVQ	(3*8)(SP), R14	\
+	MOVQ	(4*8)(SP), R15	\
+	MOVQ	(5*8)(SP), BP	\
+	ADJSP	$-(REGS_HOST_TO_ABI0_STACK)
+
 #endif
diff --git a/src/runtime/cgo/asm_amd64.s b/src/runtime/cgo/asm_amd64.s
index 447ddb118d..386299c548 100644
--- a/src/runtime/cgo/asm_amd64.s
+++ b/src/runtime/cgo/asm_amd64.s
@@ -10,43 +10,25 @@
 // Saves C callee-saved registers and calls cgocallback with three arguments.
 // fn is the PC of a func(a unsafe.Pointer) function.
 // This signature is known to SWIG, so we can't change it.
-#ifndef GOOS_windows
-TEXT crosscall2(SB),NOSPLIT,$0x50-0 /* keeps stack pointer 32-byte aligned */
-	MOVQ	BX, 0x18(SP)
-	MOVQ	R12, 0x28(SP)
-	MOVQ	R13, 0x30(SP)
-	MOVQ	R14, 0x38(SP)
-	MOVQ	R15, 0x40(SP)
+TEXT crosscall2(SB),NOSPLIT,$0-0
+	PUSH_REGS_HOST_TO_ABI0()
 
+	// Make room for arguments to cgocallback.
+	ADJSP	$0x18
+#ifndef GOOS_windows
 	MOVQ	DI, 0x0(SP)	/* fn */
 	MOVQ	SI, 0x8(SP)	/* arg */
 	// Skip n in DX.
 	MOVQ	CX, 0x10(SP)	/* ctxt */
-
-	CALL	runtime·cgocallback(SB)
-
-	MOVQ	0x18(SP), BX
-	MOVQ	0x28(SP), R12
-	MOVQ	0x30(SP), R13
-	MOVQ	0x38(SP), R14
-	MOVQ	0x40(SP), R15
-
-	RET
-
 #else
-TEXT crosscall2(SB),NOSPLIT,$0-0
-	PUSH_REGS_HOST_TO_ABI0()
-
-	// Make room for arguments to cgocallback.
-	ADJSP	$0x18
 	MOVQ	CX, 0x0(SP)	/* fn */
 	MOVQ	DX, 0x8(SP)	/* arg */
 	// Skip n in R8.
 	MOVQ	R9, 0x10(SP)	/* ctxt */
+#endif
 
 	CALL	runtime·cgocallback(SB)
 
 	ADJSP	$-0x18
 	POP_REGS_HOST_TO_ABI0()
 	RET
-#endif
diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index 21d3ae653e..c8b29e396c 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -385,7 +385,7 @@ func mdestroy(mp *m) {
 //#endif
 
 func sigreturn()
-func sigtramp(sig uint32, info *siginfo, ctx unsafe.Pointer)
+func sigtramp() // Called via C ABI
 func cgoSigtramp()
 
 //go:noescape
diff --git a/src/runtime/race_amd64.s b/src/runtime/race_amd64.s
index bb3afeb6ee..58a919efe8 100644
--- a/src/runtime/race_amd64.s
+++ b/src/runtime/race_amd64.s
@@ -8,6 +8,7 @@
 #include "go_tls.h"
 #include "funcdata.h"
 #include "textflag.h"
+#include "cgo/abi_amd64.h"
 
 // The following thunks allow calling the gcc-compiled race runtime directly
 // from Go code without going all the way through cgo.
@@ -441,7 +442,7 @@ call:
 // See racecallback for command codes.
 // Defined as ABIInternal so as to avoid introducing a wrapper,
 // because its address is passed to C via funcPC.
-TEXT	runtime·racecallbackthunk<ABIInternal>(SB), NOSPLIT, $56-8
+TEXT	runtime·racecallbackthunk<ABIInternal>(SB), NOSPLIT, $0-0
 	// Handle command raceGetProcCmd (0) here.
 	// First, code below assumes that we are on curg, while raceGetProcCmd
 	// can be executed on g0. Second, it is called frequently, so will
@@ -457,16 +458,8 @@ TEXT	runtime·racecallbackthunk<ABIInternal>(SB), NOSPLIT, $56-8
 	RET
 
 rest:
-	// Save callee-saved registers (Go code won't respect that).
-	// This is superset of darwin/linux/windows registers.
-	PUSHQ	BX
-	PUSHQ	BP
-	PUSHQ	DI
-	PUSHQ	SI
-	PUSHQ	R12
-	PUSHQ	R13
-	PUSHQ	R14
-	PUSHQ	R15
+	// Transition from C ABI to Go ABI.
+	PUSH_REGS_HOST_TO_ABI0()
 	// Set g = g0.
 	get_tls(R12)
 	MOVQ	g(R12), R14
@@ -488,15 +481,7 @@ rest:
 	MOVQ	m_curg(R13), R14
 	MOVQ	R14, g(R12)	// g = m->curg
 ret:
-	// Restore callee-saved registers.
-	POPQ	R15
-	POPQ	R14
-	POPQ	R13
-	POPQ	R12
-	POPQ	SI
-	POPQ	DI
-	POPQ	BP
-	POPQ	BX
+	POP_REGS_HOST_TO_ABI0()
 	RET
 
 noswitch:
diff --git a/src/runtime/sys_darwin_amd64.s b/src/runtime/sys_darwin_amd64.s
index 3e9eccf19e..803d95bcca 100644
--- a/src/runtime/sys_darwin_amd64.s
+++ b/src/runtime/sys_darwin_amd64.s
@@ -11,6 +11,7 @@
 #include "go_asm.h"
 #include "go_tls.h"
 #include "textflag.h"
+#include "cgo/abi_amd64.h"
 
 #define CLOCK_REALTIME		0
 
@@ -214,36 +215,21 @@ TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
 
 // This is the function registered during sigaction and is invoked when
 // a signal is received. It just redirects to the Go function sigtrampgo.
+// Called using C ABI.
 TEXT runtime·sigtramp<ABIInternal>(SB),NOSPLIT,$0
-	// This runs on the signal stack, so we have lots of stack available.
-	// We allocate our own stack space, because if we tell the linker
-	// how much we're using, the NOSPLIT check fails.
-	PUSHQ	BP
-	MOVQ	SP, BP
-	SUBQ	$64, SP
-
-	// Save callee-save registers.
-	MOVQ	BX, 24(SP)
-	MOVQ	R12, 32(SP)
-	MOVQ	R13, 40(SP)
-	MOVQ	R14, 48(SP)
-	MOVQ	R15, 56(SP)
+	// Transition from C ABI to Go ABI.
+	PUSH_REGS_HOST_TO_ABI0()
 
 	// Call into the Go signal handler
-	MOVL	DI, 0(SP)  // sig
-	MOVQ	SI, 8(SP)  // info
-	MOVQ	DX, 16(SP) // ctx
-	CALL runtime·sigtrampgo(SB)
-
-	// Restore callee-save registers.
-	MOVQ	24(SP), BX
-	MOVQ	32(SP), R12
-	MOVQ	40(SP), R13
-	MOVQ	48(SP), R14
-	MOVQ	56(SP), R15
+	NOP	SP		// disable vet stack checking
+	ADJSP	$24
+	MOVL	DI, 0(SP)	// sig
+	MOVQ	SI, 8(SP)	// info
+	MOVQ	DX, 16(SP)	// ctx
+	CALL	·sigtrampgo(SB)
+	ADJSP	$-24
 
-	MOVQ	BP, SP
-	POPQ	BP
+	POP_REGS_HOST_TO_ABI0()
 	RET
 
 // Used instead of sigtramp in programs that use cgo.
@@ -438,13 +424,8 @@ TEXT runtime·mstart_stub<ABIInternal>(SB),NOSPLIT,$0
 	// DI points to the m.
 	// We are already on m's g0 stack.
 
-	// Save callee-save registers.
-	SUBQ	$40, SP
-	MOVQ	BX, 0(SP)
-	MOVQ	R12, 8(SP)
-	MOVQ	R13, 16(SP)
-	MOVQ	R14, 24(SP)
-	MOVQ	R15, 32(SP)
+	// Transition from C ABI to Go ABI.
+	PUSH_REGS_HOST_TO_ABI0()
 
 	MOVQ	m_g0(DI), DX // g
 
@@ -452,24 +433,14 @@ TEXT runtime·mstart_stub<ABIInternal>(SB),NOSPLIT,$0
 	// See cmd/link/internal/ld/sym.go:computeTLSOffset.
 	MOVQ	DX, 0x30(GS)
 
-	// Someday the convention will be D is always cleared.
-	CLD
-
 	CALL	runtime·mstart(SB)
 
-	// Restore callee-save registers.
-	MOVQ	0(SP), BX
-	MOVQ	8(SP), R12
-	MOVQ	16(SP), R13
-	MOVQ	24(SP), R14
-	MOVQ	32(SP), R15
+	POP_REGS_HOST_TO_ABI0()
 
 	// Go is all done with this OS thread.
 	// Tell pthread everything is ok (we never join with this thread, so
 	// the value here doesn't really matter).
 	XORL	AX, AX
-
-	ADDQ	$40, SP
 	RET
 
 // These trampolines help convert from Go calling convention to C calling convention.
diff --git a/src/runtime/sys_dragonfly_amd64.s b/src/runtime/sys_dragonfly_amd64.s
index 9cb268d740..43f864194d 100644
--- a/src/runtime/sys_dragonfly_amd64.s
+++ b/src/runtime/sys_dragonfly_amd64.s
@@ -9,6 +9,7 @@
 #include "go_asm.h"
 #include "go_tls.h"
 #include "textflag.h"
+#include "cgo/abi_amd64.h"
 
 TEXT runtime·sys_umtx_sleep(SB),NOSPLIT,$0
 	MOVQ addr+0(FP), DI		// arg 1 - ptr
@@ -235,28 +236,21 @@ TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
 	POPQ	BP
 	RET
 
-TEXT runtime·sigtramp(SB),NOSPLIT,$72
-	// Save callee-saved C registers, since the caller may be a C signal handler.
-	MOVQ	BX,  bx-8(SP)
-	MOVQ	BP,  bp-16(SP)  // save in case GOEXPERIMENT=noframepointer is set
-	MOVQ	R12, r12-24(SP)
-	MOVQ	R13, r13-32(SP)
-	MOVQ	R14, r14-40(SP)
-	MOVQ	R15, r15-48(SP)
-	// We don't save mxcsr or the x87 control word because sigtrampgo doesn't
-	// modify them.
-
-	MOVQ	DX, ctx-56(SP)
-	MOVQ	SI, info-64(SP)
-	MOVQ	DI, signum-72(SP)
-	CALL	runtime·sigtrampgo(SB)
-
-	MOVQ	r15-48(SP), R15
-	MOVQ	r14-40(SP), R14
-	MOVQ	r13-32(SP), R13
-	MOVQ	r12-24(SP), R12
-	MOVQ	bp-16(SP),  BP
-	MOVQ	bx-8(SP),   BX
+// Called using C ABI.
+TEXT runtime·sigtramp(SB),NOSPLIT,$0
+	// Transition from C ABI to Go ABI.
+	PUSH_REGS_HOST_TO_ABI0()
+
+	// Call into the Go signal handler
+	NOP	SP		// disable vet stack checking
+	ADJSP	$24
+	MOVQ	DI, 0(SP)	// sig
+	MOVQ	SI, 8(SP)	// info
+	MOVQ	DX, 16(SP)	// ctx
+	CALL	·sigtrampgo(SB)
+	ADJSP	$-24
+
+	POP_REGS_HOST_TO_ABI0()
 	RET
 
 TEXT runtime·mmap(SB),NOSPLIT,$0
diff --git a/src/runtime/sys_freebsd_amd64.s b/src/runtime/sys_freebsd_amd64.s
index 07734b0d7d..71a60cae65 100644
--- a/src/runtime/sys_freebsd_amd64.s
+++ b/src/runtime/sys_freebsd_amd64.s
@@ -9,6 +9,7 @@
 #include "go_asm.h"
 #include "go_tls.h"
 #include "textflag.h"
+#include "cgo/abi_amd64.h"
 
 TEXT runtime·sys_umtx_op(SB),NOSPLIT,$0
 	MOVQ addr+0(FP), DI
@@ -237,28 +238,21 @@ TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
 	POPQ	BP
 	RET
 
-TEXT runtime·sigtramp(SB),NOSPLIT,$72
-	// Save callee-saved C registers, since the caller may be a C signal handler.
-	MOVQ	BX, bx-8(SP)
-	MOVQ	BP, bp-16(SP)  // save in case GOEXPERIMENT=noframepointer is set
-	MOVQ	R12, r12-24(SP)
-	MOVQ	R13, r13-32(SP)
-	MOVQ	R14, r14-40(SP)
-	MOVQ	R15, r15-48(SP)
-	// We don't save mxcsr or the x87 control word because sigtrampgo doesn't
-	// modify them.
-
-	MOVQ	DX, ctx-56(SP)
-	MOVQ	SI, info-64(SP)
-	MOVQ	DI, signum-72(SP)
-	CALL	runtime·sigtrampgo(SB)
-
-	MOVQ	r15-48(SP), R15
-	MOVQ	r14-40(SP), R14
-	MOVQ	r13-32(SP), R13
-	MOVQ	r12-24(SP), R12
-	MOVQ	bp-16(SP),  BP
-	MOVQ	bx-8(SP),   BX
+// Called using C ABI.
+TEXT runtime·sigtramp(SB),NOSPLIT,$0
+	// Transition from C ABI to Go ABI.
+	PUSH_REGS_HOST_TO_ABI0()
+
+	// Call into the Go signal handler
+	NOP	SP		// disable vet stack checking
+        ADJSP   $24
+	MOVQ	DI, 0(SP)	// sig
+	MOVQ	SI, 8(SP)	// info
+	MOVQ	DX, 16(SP)	// ctx
+	CALL	·sigtrampgo(SB)
+	ADJSP	$-24
+
+        POP_REGS_HOST_TO_ABI0()
 	RET
 
 // Used instead of sigtramp in programs that use cgo.
diff --git a/src/runtime/sys_linux_386.s b/src/runtime/sys_linux_386.s
index 1e3a834812..6e7737e89f 100644
--- a/src/runtime/sys_linux_386.s
+++ b/src/runtime/sys_linux_386.s
@@ -412,6 +412,7 @@ TEXT runtime·sigfwd(SB),NOSPLIT,$12-16
 	MOVL	AX, SP
 	RET
 
+// Called using C ABI.
 TEXT runtime·sigtramp(SB),NOSPLIT,$28
 	// Save callee-saved C registers, since the caller may be a C signal handler.
 	MOVL	BX, bx-4(SP)
@@ -421,11 +422,11 @@ TEXT runtime·sigtramp(SB),NOSPLIT,$28
 	// We don't save mxcsr or the x87 control word because sigtrampgo doesn't
 	// modify them.
 
-	MOVL	sig+0(FP), BX
+	MOVL	(28+4)(SP), BX
 	MOVL	BX, 0(SP)
-	MOVL	info+4(FP), BX
+	MOVL	(28+8)(SP), BX
 	MOVL	BX, 4(SP)
-	MOVL	ctx+8(FP), BX
+	MOVL	(28+12)(SP), BX
 	MOVL	BX, 8(SP)
 	CALL	runtime·sigtrampgo(SB)
 
diff --git a/src/runtime/sys_linux_amd64.s b/src/runtime/sys_linux_amd64.s
index 215277a9cf..da8a1f7663 100644
--- a/src/runtime/sys_linux_amd64.s
+++ b/src/runtime/sys_linux_amd64.s
@@ -9,6 +9,7 @@
 #include "go_asm.h"
 #include "go_tls.h"
 #include "textflag.h"
+#include "cgo/abi_amd64.h"
 
 #define AT_FDCWD -100
 
@@ -397,29 +398,21 @@ TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
 	RET
 
 // Defined as ABIInternal since it does not use the stack-based Go ABI.
-TEXT runtime·sigtramp<ABIInternal>(SB),NOSPLIT,$72
-	// Save callee-saved C registers, since the caller may be a C signal handler.
-	MOVQ	BX,  bx-8(SP)
-	MOVQ	BP,  bp-16(SP)  // save in case GOEXPERIMENT=noframepointer is set
-	MOVQ	R12, r12-24(SP)
-	MOVQ	R13, r13-32(SP)
-	MOVQ	R14, r14-40(SP)
-	MOVQ	R15, r15-48(SP)
-	// We don't save mxcsr or the x87 control word because sigtrampgo doesn't
-	// modify them.
-
-	MOVQ	DX, ctx-56(SP)
-	MOVQ	SI, info-64(SP)
-	MOVQ	DI, signum-72(SP)
-	MOVQ	$runtime·sigtrampgo(SB), AX
-	CALL AX
-
-	MOVQ	r15-48(SP), R15
-	MOVQ	r14-40(SP), R14
-	MOVQ	r13-32(SP), R13
-	MOVQ	r12-24(SP), R12
-	MOVQ	bp-16(SP),  BP
-	MOVQ	bx-8(SP),   BX
+// Called using C ABI.
+TEXT runtime·sigtramp<ABIInternal>(SB),NOSPLIT,$0
+	// Transition from C ABI to Go ABI.
+	PUSH_REGS_HOST_TO_ABI0()
+
+	// Call into the Go signal handler
+	NOP	SP		// disable vet stack checking
+        ADJSP   $24
+	MOVQ	DI, 0(SP)	// sig
+	MOVQ	SI, 8(SP)	// info
+	MOVQ	DX, 16(SP)	// ctx
+	CALL	·sigtrampgo(SB)
+	ADJSP	$-24
+
+        POP_REGS_HOST_TO_ABI0()
 	RET
 
 // Used instead of sigtramp in programs that use cgo.
diff --git a/src/runtime/sys_netbsd_amd64.s b/src/runtime/sys_netbsd_amd64.s
index addd98cd27..db76e86d1d 100644
--- a/src/runtime/sys_netbsd_amd64.s
+++ b/src/runtime/sys_netbsd_amd64.s
@@ -9,6 +9,7 @@
 #include "go_asm.h"
 #include "go_tls.h"
 #include "textflag.h"
+#include "cgo/abi_amd64.h"
 
 #define CLOCK_REALTIME		0
 #define CLOCK_MONOTONIC		3
@@ -318,28 +319,21 @@ TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
 	POPQ	BP
 	RET
 
-TEXT runtime·sigtramp(SB),NOSPLIT,$72
-	// Save callee-saved C registers, since the caller may be a C signal handler.
-	MOVQ	BX,  bx-8(SP)
-	MOVQ	BP,  bp-16(SP)  // save in case GOEXPERIMENT=noframepointer is set
-	MOVQ	R12, r12-24(SP)
-	MOVQ	R13, r13-32(SP)
-	MOVQ	R14, r14-40(SP)
-	MOVQ	R15, r15-48(SP)
-	// We don't save mxcsr or the x87 control word because sigtrampgo doesn't
-	// modify them.
-
-	MOVQ	DX, ctx-56(SP)
-	MOVQ	SI, info-64(SP)
-	MOVQ	DI, signum-72(SP)
-	CALL	runtime·sigtrampgo(SB)
-
-	MOVQ	r15-48(SP), R15
-	MOVQ	r14-40(SP), R14
-	MOVQ	r13-32(SP), R13
-	MOVQ	r12-24(SP), R12
-	MOVQ	bp-16(SP),  BP
-	MOVQ	bx-8(SP),   BX
+// Called using C ABI.
+TEXT runtime·sigtramp(SB),NOSPLIT,$0
+	// Transition from C ABI to Go ABI.
+	PUSH_REGS_HOST_TO_ABI0()
+
+	// Call into the Go signal handler
+	NOP	SP		// disable vet stack checking
+        ADJSP   $24
+	MOVQ	DI, 0(SP)	// sig
+	MOVQ	SI, 8(SP)	// info
+	MOVQ	DX, 16(SP)	// ctx
+	CALL	·sigtrampgo(SB)
+	ADJSP	$-24
+
+        POP_REGS_HOST_TO_ABI0()
 	RET
 
 TEXT runtime·mmap(SB),NOSPLIT,$0
diff --git a/src/runtime/sys_openbsd_amd64.s b/src/runtime/sys_openbsd_amd64.s
index b3a76b57a3..522e98cf4f 100644
--- a/src/runtime/sys_openbsd_amd64.s
+++ b/src/runtime/sys_openbsd_amd64.s
@@ -11,6 +11,7 @@
 #include "go_asm.h"
 #include "go_tls.h"
 #include "textflag.h"
+#include "cgo/abi_amd64.h"
 
 #define CLOCK_MONOTONIC	$3
 
@@ -25,39 +26,22 @@ TEXT runtime·mstart_stub(SB),NOSPLIT,$0
 	// DI points to the m.
 	// We are already on m's g0 stack.
 
-	// Save callee-save registers.
-	SUBQ	$48, SP
-	MOVQ	BX, 0(SP)
-	MOVQ	BP, 8(SP)
-	MOVQ	R12, 16(SP)
-	MOVQ	R13, 24(SP)
-	MOVQ	R14, 32(SP)
-	MOVQ	R15, 40(SP)
+	// Transition from C ABI to Go ABI.
+	PUSH_REGS_HOST_TO_ABI0()
 
 	// Load g and save to TLS entry.
 	// See cmd/link/internal/ld/sym.go:computeTLSOffset.
 	MOVQ	m_g0(DI), DX // g
 	MOVQ	DX, -8(FS)
 
-	// Someday the convention will be D is always cleared.
-	CLD
-
 	CALL	runtime·mstart(SB)
 
-	// Restore callee-save registers.
-	MOVQ	0(SP), BX
-	MOVQ	8(SP), BP
-	MOVQ	16(SP), R12
-	MOVQ	24(SP), R13
-	MOVQ	32(SP), R14
-	MOVQ	40(SP), R15
+	POP_REGS_HOST_TO_ABI0()
 
 	// Go is all done with this OS thread.
 	// Tell pthread everything is ok (we never join with this thread, so
 	// the value here doesn't really matter).
 	XORL	AX, AX
-
-	ADDQ	$48, SP
 	RET
 
 TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
@@ -73,28 +57,21 @@ TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
 	POPQ	BP
 	RET
 
-TEXT runtime·sigtramp(SB),NOSPLIT,$72
-	// Save callee-saved C registers, since the caller may be a C signal handler.
-	MOVQ	BX,  bx-8(SP)
-	MOVQ	BP,  bp-16(SP)  // save in case GOEXPERIMENT=noframepointer is set
-	MOVQ	R12, r12-24(SP)
-	MOVQ	R13, r13-32(SP)
-	MOVQ	R14, r14-40(SP)
-	MOVQ	R15, r15-48(SP)
-	// We don't save mxcsr or the x87 control word because sigtrampgo doesn't
-	// modify them.
-
-	MOVQ	DX, ctx-56(SP)
-	MOVQ	SI, info-64(SP)
-	MOVQ	DI, signum-72(SP)
-	CALL	runtime·sigtrampgo(SB)
-
-	MOVQ	r15-48(SP), R15
-	MOVQ	r14-40(SP), R14
-	MOVQ	r13-32(SP), R13
-	MOVQ	r12-24(SP), R12
-	MOVQ	bp-16(SP),  BP
-	MOVQ	bx-8(SP),   BX
+// Called using C ABI.
+TEXT runtime·sigtramp<ABIInternal>(SB),NOSPLIT,$0
+	// Transition from C ABI to Go ABI.
+	PUSH_REGS_HOST_TO_ABI0()
+
+	// Call into the Go signal handler
+	NOP	SP		// disable vet stack checking
+        ADJSP   $24
+	MOVQ	DI, 0(SP)	// sig
+	MOVQ	SI, 8(SP)	// info
+	MOVQ	DX, 16(SP)	// ctx
+	CALL	·sigtrampgo(SB)
+	ADJSP	$-24
+
+        POP_REGS_HOST_TO_ABI0()
 	RET
 
 //
-- 
GitLab


From 31e12b953a2a8fa5f3c849da18ded575c5737532 Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Mon, 5 Apr 2021 13:36:13 -0500
Subject: [PATCH 1587/2400] cmd/link: issue error if elf header overruns

This is probably unlikely in practice, but when debugging alignment
related issues on ppc64 using very small text section splits, the elf
header could grow beyond the preallocated space and quietly stomp
on the first few text sections.

Change-Id: Ided58aa0b1e60f9da4b3cb277e4ebafcee4ec693
Reviewed-on: https://go-review.googlesource.com/c/go/+/307430
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Lynn Boger <laboger@linux.vnet.ibm.com>
---
 src/cmd/link/internal/ld/elf.go | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/cmd/link/internal/ld/elf.go b/src/cmd/link/internal/ld/elf.go
index b4af0931cc..3ba9f329ee 100644
--- a/src/cmd/link/internal/ld/elf.go
+++ b/src/cmd/link/internal/ld/elf.go
@@ -2194,6 +2194,12 @@ elfobj:
 	if a > elfreserve {
 		Errorf(nil, "ELFRESERVE too small: %d > %d with %d text sections", a, elfreserve, numtext)
 	}
+
+	// Verify the amount of space allocated for the elf header is sufficient.  The file offsets are
+	// already computed in layout, so we could spill into another section.
+	if a > int64(HEADR) {
+		Errorf(nil, "HEADR too small: %d > %d with %d text sections", a, HEADR, numtext)
+	}
 }
 
 func elfadddynsym(ldr *loader.Loader, target *Target, syms *ArchSyms, s loader.Sym) {
-- 
GitLab


From 1d20a362d0ca4898d77865e314ef6f73582daef0 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Wed, 14 Apr 2021 21:57:24 -0400
Subject: [PATCH 1588/2400] math: avoid assembly stubs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Currently almost all math functions have the following pattern:

func Sin(x float64) float64

func sin(x float64) float64 {
    // ... pure Go implementation ...
}

Architectures that implement a function in assembly provide the
assembly implementation directly as the exported function (e.g., Sin),
and architectures that don't implement it in assembly use a small stub
to jump back to the Go code, like:

TEXT ·Sin(SB), NOSPLIT, $0
	JMP ·sin(SB)

However, most functions are not implemented in assembly on most
architectures, so this jump through assembly is a waste. It defeats
compiler optimizations like inlining. And, with regabi, it actually
adds a small but non-trivial overhead because the jump from assembly
back to Go must go through an ABI0->ABIInternal bridge function.

Hence, this CL reorganizes this structure across the entire package.
It now leans on inlining to achieve peak performance, but allows the
compiler to see all the way through the pure Go implementation.

Now, functions follow this pattern:

func Sin(x float64) float64 {
	if haveArchSin {
		return archSin(x)
	}
	return sin(x)
}

func sin(x float64) float64 {
    // ... pure Go implementation ...
}

Architectures that have assembly implementations use build-tagged
files to set haveArchX to true an provide an archX implementation.
That implementation can also still call back into the Go
implementation (some of them do this).

Prior to this change, enabling ABI wrappers results in a geomean
slowdown of the math benchmarks of 8.77% (full results:
https://perf.golang.org/search?q=upload:20210415.6) and of the Tile38
benchmarks by ~4%. After this change, enabling ABI wrappers is
completely performance-neutral on Tile38 and all but one math
benchmark (full results:
https://perf.golang.org/search?q=upload:20210415.7). ABI wrappers slow
down SqrtIndirectLatency-12 by 2.09%, which makes sense because that
call must still go through an ABI wrapper.

With ABI wrappers disabled (which won't be an option on amd64 much
longer), on linux/amd64, this change is largely performance-neutral
and slightly improves the performance of a few benchmarks:

(Because there are so many benchmarks, I've applied the Šidák
correction to the alpha threshold. It makes relatively little
difference in which benchmarks are statistically significant.)

name                    old time/op  new time/op  delta
Acos-12                 22.3ns ± 0%  18.8ns ± 1%  -15.44%  (p=0.000 n=18+16)
Acosh-12                28.2ns ± 0%  28.2ns ± 0%     ~     (p=0.404 n=18+20)
Asin-12                 18.1ns ± 0%  18.2ns ± 0%   +0.20%  (p=0.000 n=18+16)
Asinh-12                32.8ns ± 0%  32.9ns ± 1%     ~     (p=0.891 n=18+20)
Atan-12                 9.92ns ± 0%  9.90ns ± 1%   -0.24%  (p=0.000 n=17+16)
Atanh-12                27.7ns ± 0%  27.5ns ± 0%   -0.72%  (p=0.000 n=16+20)
Atan2-12                18.5ns ± 0%  18.4ns ± 0%   -0.59%  (p=0.000 n=19+19)
Cbrt-12                 22.1ns ± 0%  22.1ns ± 0%     ~     (p=0.804 n=16+17)
Ceil-12                 0.84ns ± 0%  0.84ns ± 0%     ~     (p=0.663 n=18+16)
Copysign-12             0.84ns ± 0%  0.84ns ± 0%     ~     (p=0.762 n=16+19)
Cos-12                  12.7ns ± 0%  12.7ns ± 1%     ~     (p=0.145 n=19+18)
Cosh-12                 22.2ns ± 0%  22.5ns ± 0%   +1.60%  (p=0.000 n=17+19)
Erf-12                  11.1ns ± 1%  11.1ns ± 1%     ~     (p=0.010 n=19+19)
Erfc-12                 12.6ns ± 1%  12.7ns ± 0%     ~     (p=0.066 n=19+15)
Erfinv-12               16.1ns ± 0%  16.1ns ± 0%     ~     (p=0.462 n=17+20)
Erfcinv-12              16.0ns ± 1%  16.0ns ± 1%     ~     (p=0.015 n=17+16)
Exp-12                  16.3ns ± 0%  16.5ns ± 1%   +1.25%  (p=0.000 n=19+16)
ExpGo-12                36.2ns ± 1%  36.1ns ± 1%     ~     (p=0.242 n=20+18)
Expm1-12                18.6ns ± 0%  18.7ns ± 0%   +0.25%  (p=0.000 n=16+19)
Exp2-12                 34.7ns ± 0%  34.6ns ± 1%     ~     (p=0.010 n=19+18)
Exp2Go-12               34.8ns ± 1%  34.8ns ± 1%     ~     (p=0.372 n=19+19)
Abs-12                  0.56ns ± 0%  0.56ns ± 0%     ~     (p=0.766 n=18+16)
Dim-12                  0.84ns ± 1%  0.84ns ± 1%     ~     (p=0.167 n=17+19)
Floor-12                0.84ns ± 0%  0.84ns ± 0%     ~     (p=0.993 n=18+16)
Max-12                  3.35ns ± 0%  3.35ns ± 0%     ~     (p=0.894 n=17+19)
Min-12                  3.35ns ± 0%  3.36ns ± 1%     ~     (p=0.214 n=18+18)
Mod-12                  35.2ns ± 0%  34.7ns ± 0%   -1.45%  (p=0.000 n=18+17)
Frexp-12                5.31ns ± 0%  4.75ns ± 0%  -10.51%  (p=0.000 n=19+18)
Gamma-12                14.8ns ± 0%  16.2ns ± 1%   +9.21%  (p=0.000 n=20+19)
Hypot-12                6.16ns ± 0%  6.17ns ± 0%   +0.26%  (p=0.000 n=19+20)
HypotGo-12              7.79ns ± 1%  7.78ns ± 0%     ~     (p=0.497 n=18+17)
Ilogb-12                4.47ns ± 0%  4.47ns ± 0%     ~     (p=0.167 n=19+19)
J0-12                   76.0ns ± 0%  76.3ns ± 0%   +0.35%  (p=0.000 n=19+18)
J1-12                   76.8ns ± 1%  75.9ns ± 0%   -1.14%  (p=0.000 n=18+18)
Jn-12                    167ns ± 1%   168ns ± 1%     ~     (p=0.038 n=18+18)
Ldexp-12                6.98ns ± 0%  6.43ns ± 0%   -7.97%  (p=0.000 n=17+18)
Lgamma-12               15.9ns ± 0%  16.0ns ± 1%     ~     (p=0.011 n=20+17)
Log-12                  13.3ns ± 0%  13.4ns ± 1%   +0.37%  (p=0.000 n=15+18)
Logb-12                 4.75ns ± 0%  4.75ns ± 0%     ~     (p=0.831 n=16+18)
Log1p-12                19.5ns ± 0%  19.5ns ± 1%     ~     (p=0.851 n=18+17)
Log10-12                15.9ns ± 0%  14.0ns ± 0%  -11.92%  (p=0.000 n=17+16)
Log2-12                 7.88ns ± 1%  8.01ns ± 0%   +1.72%  (p=0.000 n=20+20)
Modf-12                 4.75ns ± 0%  4.34ns ± 0%   -8.66%  (p=0.000 n=19+17)
Nextafter32-12          5.31ns ± 0%  5.31ns ± 0%     ~     (p=0.389 n=17+18)
Nextafter64-12          5.03ns ± 1%  5.03ns ± 0%     ~     (p=0.774 n=17+18)
PowInt-12               29.9ns ± 0%  28.5ns ± 0%   -4.69%  (p=0.000 n=18+19)
PowFrac-12              91.0ns ± 0%  91.1ns ± 0%     ~     (p=0.029 n=19+19)
Pow10Pos-12             1.12ns ± 0%  1.12ns ± 0%     ~     (p=0.363 n=20+20)
Pow10Neg-12             3.90ns ± 0%  3.90ns ± 0%     ~     (p=0.921 n=17+18)
Round-12                2.31ns ± 0%  2.31ns ± 1%     ~     (p=0.390 n=18+18)
RoundToEven-12          0.84ns ± 0%  0.84ns ± 0%     ~     (p=0.280 n=18+19)
Remainder-12            31.6ns ± 0%  29.6ns ± 0%   -6.16%  (p=0.000 n=18+17)
Signbit-12              0.56ns ± 0%  0.56ns ± 0%     ~     (p=0.385 n=19+18)
Sin-12                  12.5ns ± 0%  12.5ns ± 0%     ~     (p=0.080 n=18+18)
Sincos-12               16.4ns ± 2%  16.4ns ± 2%     ~     (p=0.253 n=20+19)
Sinh-12                 26.1ns ± 0%  26.1ns ± 0%   +0.18%  (p=0.000 n=17+19)
SqrtIndirect-12         3.91ns ± 0%  3.90ns ± 0%     ~     (p=0.133 n=19+19)
SqrtLatency-12          2.79ns ± 0%  2.79ns ± 0%     ~     (p=0.226 n=16+19)
SqrtIndirectLatency-12  6.68ns ± 0%  6.37ns ± 2%   -4.66%  (p=0.000 n=17+20)
SqrtGoLatency-12        49.4ns ± 0%  49.4ns ± 0%     ~     (p=0.289 n=18+16)
SqrtPrime-12            3.18µs ± 0%  3.18µs ± 0%     ~     (p=0.084 n=17+18)
Tan-12                  13.8ns ± 0%  13.9ns ± 2%     ~     (p=0.292 n=19+20)
Tanh-12                 25.4ns ± 0%  25.4ns ± 0%     ~     (p=0.101 n=17+17)
Trunc-12                0.84ns ± 0%  0.84ns ± 0%     ~     (p=0.765 n=18+16)
Y0-12                   75.8ns ± 0%  75.9ns ± 1%     ~     (p=0.805 n=16+18)
Y1-12                   76.3ns ± 0%  75.3ns ± 1%   -1.34%  (p=0.000 n=19+17)
Yn-12                    164ns ± 0%   164ns ± 2%     ~     (p=0.356 n=18+20)
Float64bits-12          0.56ns ± 0%  0.56ns ± 0%     ~     (p=0.383 n=18+18)
Float64frombits-12      0.56ns ± 0%  0.56ns ± 0%     ~     (p=0.066 n=18+19)
Float32bits-12          0.56ns ± 0%  0.56ns ± 0%     ~     (p=0.889 n=16+19)
Float32frombits-12      0.56ns ± 0%  0.56ns ± 0%     ~     (p=0.007 n=18+19)
FMA-12                  23.9ns ± 0%  24.0ns ± 0%   +0.31%  (p=0.000 n=16+17)
[Geo mean]              9.86ns       9.77ns        -0.87%

(https://perf.golang.org/search?q=upload:20210415.5)

For #40724.

Change-Id: I44fbba2a17be930ec9daeb0a8222f55cd50555a0
Reviewed-on: https://go-review.googlesource.com/c/go/+/310331
Trust: Austin Clements <austin@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/math/acosh.go        |   7 +-
 src/math/arith_s390x.go  | 101 +++++++++++++++++++++++-
 src/math/asin.go         |  14 +++-
 src/math/asinh.go        |   7 +-
 src/math/atan.go         |   7 +-
 src/math/atan2.go        |   7 +-
 src/math/atanh.go        |   7 +-
 src/math/cbrt.go         |   7 +-
 src/math/dim.go          |  14 +++-
 src/math/dim_amd64.s     |   8 +-
 src/math/dim_arm64.s     |   8 +-
 src/math/dim_asm.go      |  16 ++++
 src/math/dim_noasm.go    |  20 +++++
 src/math/dim_riscv64.s   |   8 +-
 src/math/dim_s390x.s     |   6 +-
 src/math/erf.go          |  14 +++-
 src/math/exp.go          |  14 +++-
 src/math/exp2_asm.go     |  12 +++
 src/math/exp2_noasm.go   |  14 ++++
 src/math/exp_amd64.go    |  12 +++
 src/math/exp_amd64.s     |   2 +-
 src/math/exp_arm64.s     |   4 +-
 src/math/exp_asm.go      |  10 +--
 src/math/exp_noasm.go    |  14 ++++
 src/math/expm1.go        |   7 +-
 src/math/floor.go        |  21 ++++-
 src/math/floor_386.s     |  12 +--
 src/math/floor_amd64.s   |  12 +--
 src/math/floor_arm64.s   |  12 +--
 src/math/floor_asm.go    |  20 +++++
 src/math/floor_noasm.go  |  26 +++++++
 src/math/floor_ppc64x.s  |   6 +-
 src/math/floor_s390x.s   |  12 +--
 src/math/floor_wasm.s    |   6 +-
 src/math/frexp.go        |   7 +-
 src/math/hypot.go        |   7 +-
 src/math/hypot_386.s     |   4 +-
 src/math/hypot_amd64.s   |   4 +-
 src/math/hypot_asm.go    |  12 +++
 src/math/hypot_noasm.go  |  14 ++++
 src/math/ldexp.go        |   7 +-
 src/math/log.go          |   7 +-
 src/math/log10.go        |  14 +++-
 src/math/log1p.go        |   7 +-
 src/math/log_amd64.s     |   2 +-
 src/math/log_asm.go      |  12 +++
 src/math/log_stub.go     |  14 ++++
 src/math/mod.go          |   7 +-
 src/math/modf.go         |   7 +-
 src/math/modf_arm64.s    |   4 +-
 src/math/modf_asm.go     |  12 +++
 src/math/modf_noasm.go   |  14 ++++
 src/math/modf_ppc64x.s   |   4 +-
 src/math/pow.go          |   7 +-
 src/math/remainder.go    |   7 +-
 src/math/sin.go          |  14 +++-
 src/math/sinh.go         |  14 +++-
 src/math/sqrt.go         |   7 +-
 src/math/sqrt_386.s      |   4 +-
 src/math/sqrt_amd64.s    |   4 +-
 src/math/sqrt_arm.s      |   4 +-
 src/math/sqrt_arm64.s    |   4 +-
 src/math/sqrt_asm.go     |  12 +++
 src/math/sqrt_mipsx.s    |   4 +-
 src/math/sqrt_noasm.go   |  14 ++++
 src/math/sqrt_ppc64x.s   |   4 +-
 src/math/sqrt_riscv64.s  |   4 +-
 src/math/sqrt_s390x.s    |   4 +-
 src/math/sqrt_wasm.s     |   2 +-
 src/math/stubs.go        | 161 +++++++++++++++++++++++++++++++++++++++
 src/math/stubs_386.s     |  98 ------------------------
 src/math/stubs_amd64.s   |  86 ---------------------
 src/math/stubs_arm.s     | 110 --------------------------
 src/math/stubs_arm64.s   |  88 ---------------------
 src/math/stubs_mips64x.s | 115 ----------------------------
 src/math/stubs_mipsx.s   | 113 ---------------------------
 src/math/stubs_ppc64x.s  | 101 ------------------------
 src/math/stubs_riscv64.s | 104 -------------------------
 src/math/stubs_s390x.s   |  68 ++++++-----------
 src/math/stubs_wasm.s    | 101 ------------------------
 src/math/tan.go          |   7 +-
 src/math/tanh.go         |   7 +-
 82 files changed, 813 insertions(+), 1081 deletions(-)
 create mode 100644 src/math/dim_asm.go
 create mode 100644 src/math/dim_noasm.go
 create mode 100644 src/math/exp2_asm.go
 create mode 100644 src/math/exp2_noasm.go
 create mode 100644 src/math/exp_amd64.go
 create mode 100644 src/math/exp_noasm.go
 create mode 100644 src/math/floor_asm.go
 create mode 100644 src/math/floor_noasm.go
 create mode 100644 src/math/hypot_asm.go
 create mode 100644 src/math/hypot_noasm.go
 create mode 100644 src/math/log_asm.go
 create mode 100644 src/math/log_stub.go
 create mode 100644 src/math/modf_asm.go
 create mode 100644 src/math/modf_noasm.go
 create mode 100644 src/math/sqrt_asm.go
 create mode 100644 src/math/sqrt_noasm.go
 create mode 100644 src/math/stubs.go
 delete mode 100644 src/math/stubs_386.s
 delete mode 100644 src/math/stubs_amd64.s
 delete mode 100644 src/math/stubs_arm.s
 delete mode 100644 src/math/stubs_arm64.s
 delete mode 100644 src/math/stubs_mips64x.s
 delete mode 100644 src/math/stubs_mipsx.s
 delete mode 100644 src/math/stubs_ppc64x.s
 delete mode 100644 src/math/stubs_riscv64.s
 delete mode 100644 src/math/stubs_wasm.s

diff --git a/src/math/acosh.go b/src/math/acosh.go
index 41ca87123c..f74e0b62fb 100644
--- a/src/math/acosh.go
+++ b/src/math/acosh.go
@@ -39,7 +39,12 @@ package math
 //	Acosh(+Inf) = +Inf
 //	Acosh(x) = NaN if x < 1
 //	Acosh(NaN) = NaN
-func Acosh(x float64) float64
+func Acosh(x float64) float64 {
+	if haveArchAcosh {
+		return archAcosh(x)
+	}
+	return acosh(x)
+}
 
 func acosh(x float64) float64 {
 	const Large = 1 << 28 // 2**28
diff --git a/src/math/arith_s390x.go b/src/math/arith_s390x.go
index 90a7d4f710..129156a9f6 100644
--- a/src/math/arith_s390x.go
+++ b/src/math/arith_s390x.go
@@ -6,72 +6,165 @@ package math
 
 import "internal/cpu"
 
+func expTrampolineSetup(x float64) float64
+func expAsm(x float64) float64
+
+func logTrampolineSetup(x float64) float64
+func logAsm(x float64) float64
+
+// Below here all functions are grouped in stubs.go for other
+// architectures.
+
+const haveArchLog10 = true
+
+func archLog10(x float64) float64
 func log10TrampolineSetup(x float64) float64
 func log10Asm(x float64) float64
 
+const haveArchCos = true
+
+func archCos(x float64) float64
 func cosTrampolineSetup(x float64) float64
 func cosAsm(x float64) float64
 
+const haveArchCosh = true
+
+func archCosh(x float64) float64
 func coshTrampolineSetup(x float64) float64
 func coshAsm(x float64) float64
 
+const haveArchSin = true
+
+func archSin(x float64) float64
 func sinTrampolineSetup(x float64) float64
 func sinAsm(x float64) float64
 
+const haveArchSinh = true
+
+func archSinh(x float64) float64
 func sinhTrampolineSetup(x float64) float64
 func sinhAsm(x float64) float64
 
+const haveArchTanh = true
+
+func archTanh(x float64) float64
 func tanhTrampolineSetup(x float64) float64
 func tanhAsm(x float64) float64
 
+const haveArchLog1p = true
+
+func archLog1p(x float64) float64
 func log1pTrampolineSetup(x float64) float64
 func log1pAsm(x float64) float64
 
+const haveArchAtanh = true
+
+func archAtanh(x float64) float64
 func atanhTrampolineSetup(x float64) float64
 func atanhAsm(x float64) float64
 
+const haveArchAcos = true
+
+func archAcos(x float64) float64
 func acosTrampolineSetup(x float64) float64
 func acosAsm(x float64) float64
 
+const haveArchAcosh = true
+
+func archAcosh(x float64) float64
 func acoshTrampolineSetup(x float64) float64
 func acoshAsm(x float64) float64
 
+const haveArchAsin = true
+
+func archAsin(x float64) float64
 func asinTrampolineSetup(x float64) float64
 func asinAsm(x float64) float64
 
+const haveArchAsinh = true
+
+func archAsinh(x float64) float64
 func asinhTrampolineSetup(x float64) float64
 func asinhAsm(x float64) float64
 
+const haveArchErf = true
+
+func archErf(x float64) float64
 func erfTrampolineSetup(x float64) float64
 func erfAsm(x float64) float64
 
+const haveArchErfc = true
+
+func archErfc(x float64) float64
 func erfcTrampolineSetup(x float64) float64
 func erfcAsm(x float64) float64
 
+const haveArchAtan = true
+
+func archAtan(x float64) float64
 func atanTrampolineSetup(x float64) float64
 func atanAsm(x float64) float64
 
+const haveArchAtan2 = true
+
+func archAtan2(y, x float64) float64
 func atan2TrampolineSetup(x, y float64) float64
 func atan2Asm(x, y float64) float64
 
+const haveArchCbrt = true
+
+func archCbrt(x float64) float64
 func cbrtTrampolineSetup(x float64) float64
 func cbrtAsm(x float64) float64
 
-func logTrampolineSetup(x float64) float64
-func logAsm(x float64) float64
+const haveArchTan = true
 
+func archTan(x float64) float64
 func tanTrampolineSetup(x float64) float64
 func tanAsm(x float64) float64
 
-func expTrampolineSetup(x float64) float64
-func expAsm(x float64) float64
+const haveArchExpm1 = true
 
+func archExpm1(x float64) float64
 func expm1TrampolineSetup(x float64) float64
 func expm1Asm(x float64) float64
 
+const haveArchPow = true
+
+func archPow(x, y float64) float64
 func powTrampolineSetup(x, y float64) float64
 func powAsm(x, y float64) float64
 
+const haveArchFrexp = false
+
+func archFrexp(x float64) (float64, int) {
+	panic("not implemented")
+}
+
+const haveArchLdexp = false
+
+func archLdexp(frac float64, exp int) float64 {
+	panic("not implemented")
+}
+
+const haveArchLog2 = false
+
+func archLog2(x float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchMod = false
+
+func archMod(x, y float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchRemainder = false
+
+func archRemainder(x, y float64) float64 {
+	panic("not implemented")
+}
+
 // hasVX reports whether the machine has the z/Architecture
 // vector facility installed and enabled.
 var hasVX = cpu.S390X.HasVX
diff --git a/src/math/asin.go b/src/math/asin.go
index 88b851e550..989a74155b 100644
--- a/src/math/asin.go
+++ b/src/math/asin.go
@@ -16,7 +16,12 @@ package math
 // Special cases are:
 //	Asin(±0) = ±0
 //	Asin(x) = NaN if x < -1 or x > 1
-func Asin(x float64) float64
+func Asin(x float64) float64 {
+	if haveArchAsin {
+		return archAsin(x)
+	}
+	return asin(x)
+}
 
 func asin(x float64) float64 {
 	if x == 0 {
@@ -48,7 +53,12 @@ func asin(x float64) float64 {
 //
 // Special case is:
 //	Acos(x) = NaN if x < -1 or x > 1
-func Acos(x float64) float64
+func Acos(x float64) float64 {
+	if haveArchAcos {
+		return archAcos(x)
+	}
+	return acos(x)
+}
 
 func acos(x float64) float64 {
 	return Pi/2 - Asin(x)
diff --git a/src/math/asinh.go b/src/math/asinh.go
index 65ae4c652d..6dcb241c1f 100644
--- a/src/math/asinh.go
+++ b/src/math/asinh.go
@@ -36,7 +36,12 @@ package math
 //	Asinh(±0) = ±0
 //	Asinh(±Inf) = ±Inf
 //	Asinh(NaN) = NaN
-func Asinh(x float64) float64
+func Asinh(x float64) float64 {
+	if haveArchAsinh {
+		return archAsinh(x)
+	}
+	return asinh(x)
+}
 
 func asinh(x float64) float64 {
 	const (
diff --git a/src/math/atan.go b/src/math/atan.go
index 7fcc90b8b0..69af860161 100644
--- a/src/math/atan.go
+++ b/src/math/atan.go
@@ -92,7 +92,12 @@ func satan(x float64) float64 {
 // Special cases are:
 //      Atan(±0) = ±0
 //      Atan(±Inf) = ±Pi/2
-func Atan(x float64) float64
+func Atan(x float64) float64 {
+	if haveArchAtan {
+		return archAtan(x)
+	}
+	return atan(x)
+}
 
 func atan(x float64) float64 {
 	if x == 0 {
diff --git a/src/math/atan2.go b/src/math/atan2.go
index d84b332c99..11d7e81acd 100644
--- a/src/math/atan2.go
+++ b/src/math/atan2.go
@@ -26,7 +26,12 @@ package math
 //	Atan2(y<0, -Inf) = -Pi
 //	Atan2(+Inf, x) = +Pi/2
 //	Atan2(-Inf, x) = -Pi/2
-func Atan2(y, x float64) float64
+func Atan2(y, x float64) float64 {
+	if haveArchAtan2 {
+		return archAtan2(y, x)
+	}
+	return atan2(y, x)
+}
 
 func atan2(y, x float64) float64 {
 	// special cases
diff --git a/src/math/atanh.go b/src/math/atanh.go
index 8904bd6dd2..fe8bd6d8a4 100644
--- a/src/math/atanh.go
+++ b/src/math/atanh.go
@@ -44,7 +44,12 @@ package math
 //	Atanh(-1) = -Inf
 //	Atanh(x) = NaN if x < -1 or x > 1
 //	Atanh(NaN) = NaN
-func Atanh(x float64) float64
+func Atanh(x float64) float64 {
+	if haveArchAtanh {
+		return archAtanh(x)
+	}
+	return atanh(x)
+}
 
 func atanh(x float64) float64 {
 	const NearZero = 1.0 / (1 << 28) // 2**-28
diff --git a/src/math/cbrt.go b/src/math/cbrt.go
index 4afd4a8f30..45c8ecb3a8 100644
--- a/src/math/cbrt.go
+++ b/src/math/cbrt.go
@@ -22,7 +22,12 @@ package math
 //	Cbrt(±0) = ±0
 //	Cbrt(±Inf) = ±Inf
 //	Cbrt(NaN) = NaN
-func Cbrt(x float64) float64
+func Cbrt(x float64) float64 {
+	if haveArchCbrt {
+		return archCbrt(x)
+	}
+	return cbrt(x)
+}
 
 func cbrt(x float64) float64 {
 	const (
diff --git a/src/math/dim.go b/src/math/dim.go
index d2e5d47f5c..6a857bbe41 100644
--- a/src/math/dim.go
+++ b/src/math/dim.go
@@ -32,7 +32,12 @@ func Dim(x, y float64) float64 {
 //	Max(x, NaN) = Max(NaN, x) = NaN
 //	Max(+0, ±0) = Max(±0, +0) = +0
 //	Max(-0, -0) = -0
-func Max(x, y float64) float64
+func Max(x, y float64) float64 {
+	if haveArchMax {
+		return archMax(x, y)
+	}
+	return max(x, y)
+}
 
 func max(x, y float64) float64 {
 	// special cases
@@ -59,7 +64,12 @@ func max(x, y float64) float64 {
 //	Min(x, -Inf) = Min(-Inf, x) = -Inf
 //	Min(x, NaN) = Min(NaN, x) = NaN
 //	Min(-0, ±0) = Min(±0, -0) = -0
-func Min(x, y float64) float64
+func Min(x, y float64) float64 {
+	if haveArchMin {
+		return archMin(x, y)
+	}
+	return min(x, y)
+}
 
 func min(x, y float64) float64 {
 	// special cases
diff --git a/src/math/dim_amd64.s b/src/math/dim_amd64.s
index 85c02e6e52..253f03b97e 100644
--- a/src/math/dim_amd64.s
+++ b/src/math/dim_amd64.s
@@ -8,8 +8,8 @@
 #define NaN    0x7FF8000000000001
 #define NegInf 0xFFF0000000000000
 
-// func ·Max(x, y float64) float64
-TEXT ·Max(SB),NOSPLIT,$0
+// func ·archMax(x, y float64) float64
+TEXT ·archMax(SB),NOSPLIT,$0
 	// +Inf special cases
 	MOVQ    $PosInf, AX
 	MOVQ    x+0(FP), R8
@@ -52,8 +52,8 @@ isMaxZero:
 	MOVQ    R9, ret+16(FP) // return other 0
 	RET
 
-// func Min(x, y float64) float64
-TEXT ·Min(SB),NOSPLIT,$0
+// func archMin(x, y float64) float64
+TEXT ·archMin(SB),NOSPLIT,$0
 	// -Inf special cases
 	MOVQ    $NegInf, AX
 	MOVQ    x+0(FP), R8
diff --git a/src/math/dim_arm64.s b/src/math/dim_arm64.s
index 2cb866ff3e..f112003dc0 100644
--- a/src/math/dim_arm64.s
+++ b/src/math/dim_arm64.s
@@ -8,8 +8,8 @@
 #define NaN    0x7FF8000000000001
 #define NegInf 0xFFF0000000000000
 
-// func ·Max(x, y float64) float64
-TEXT ·Max(SB),NOSPLIT,$0
+// func ·archMax(x, y float64) float64
+TEXT ·archMax(SB),NOSPLIT,$0
 	// +Inf special cases
 	MOVD	$PosInf, R0
 	MOVD	x+0(FP), R1
@@ -28,8 +28,8 @@ isPosInf: // return +Inf
 	MOVD	R0, ret+16(FP)
 	RET
 
-// func Min(x, y float64) float64
-TEXT ·Min(SB),NOSPLIT,$0
+// func archMin(x, y float64) float64
+TEXT ·archMin(SB),NOSPLIT,$0
 	// -Inf special cases
 	MOVD	$NegInf, R0
 	MOVD	x+0(FP), R1
diff --git a/src/math/dim_asm.go b/src/math/dim_asm.go
new file mode 100644
index 0000000000..9ba742a407
--- /dev/null
+++ b/src/math/dim_asm.go
@@ -0,0 +1,16 @@
+// Copyright 2021 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.
+
+//go:build amd64 || arm64 || riscv64 || s390x
+// +build amd64 arm64 riscv64 s390x
+
+package math
+
+const haveArchMax = true
+
+func archMax(x, y float64) float64
+
+const haveArchMin = true
+
+func archMin(x, y float64) float64
diff --git a/src/math/dim_noasm.go b/src/math/dim_noasm.go
new file mode 100644
index 0000000000..ea46577d8d
--- /dev/null
+++ b/src/math/dim_noasm.go
@@ -0,0 +1,20 @@
+// Copyright 2021 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.
+
+//go:build !amd64 && !arm64 && !riscv64 && !s390x
+// +build !amd64,!arm64,!riscv64,!s390x
+
+package math
+
+const haveArchMax = false
+
+func archMax(x, y float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchMin = false
+
+func archMin(x, y float64) float64 {
+	panic("not implemented")
+}
diff --git a/src/math/dim_riscv64.s b/src/math/dim_riscv64.s
index 38f5fe7a91..5b2fd3d063 100644
--- a/src/math/dim_riscv64.s
+++ b/src/math/dim_riscv64.s
@@ -9,8 +9,8 @@
 #define	PosInf	0x080
 #define	NaN	0x200
 
-// func Max(x, y float64) float64
-TEXT ·Max(SB),NOSPLIT,$0
+// func archMax(x, y float64) float64
+TEXT ·archMax(SB),NOSPLIT,$0
 	MOVD	x+0(FP), F0
 	MOVD	y+8(FP), F1
 	FCLASSD	F0, X5
@@ -39,8 +39,8 @@ isMaxY: // return y
 	MOVD	F1, ret+16(FP)
 	RET
 
-// func Min(x, y float64) float64
-TEXT ·Min(SB),NOSPLIT,$0
+// func archMin(x, y float64) float64
+TEXT ·archMin(SB),NOSPLIT,$0
 	MOVD	x+0(FP), F0
 	MOVD	y+8(FP), F1
 	FCLASSD	F0, X5
diff --git a/src/math/dim_s390x.s b/src/math/dim_s390x.s
index 74fdd75b9c..12770261f2 100644
--- a/src/math/dim_s390x.s
+++ b/src/math/dim_s390x.s
@@ -11,7 +11,7 @@
 #define NegInf 0xFFF0000000000000
 
 // func ·Max(x, y float64) float64
-TEXT ·Max(SB),NOSPLIT,$0
+TEXT ·archMax(SB),NOSPLIT,$0
 	// +Inf special cases
 	MOVD    $PosInf, R4
 	MOVD    x+0(FP), R8
@@ -52,8 +52,8 @@ isMaxZero:
 	MOVD    R9, ret+16(FP) // return other 0
 	RET
 
-// func Min(x, y float64) float64
-TEXT ·Min(SB),NOSPLIT,$0
+// func archMin(x, y float64) float64
+TEXT ·archMin(SB),NOSPLIT,$0
 	// -Inf special cases
 	MOVD    $NegInf, R4
 	MOVD    x+0(FP), R8
diff --git a/src/math/erf.go b/src/math/erf.go
index 9b4048f687..4d6fe472f1 100644
--- a/src/math/erf.go
+++ b/src/math/erf.go
@@ -185,7 +185,12 @@ const (
 //	Erf(+Inf) = 1
 //	Erf(-Inf) = -1
 //	Erf(NaN) = NaN
-func Erf(x float64) float64
+func Erf(x float64) float64 {
+	if haveArchErf {
+		return archErf(x)
+	}
+	return erf(x)
+}
 
 func erf(x float64) float64 {
 	const (
@@ -264,7 +269,12 @@ func erf(x float64) float64 {
 //	Erfc(+Inf) = 0
 //	Erfc(-Inf) = 2
 //	Erfc(NaN) = NaN
-func Erfc(x float64) float64
+func Erfc(x float64) float64 {
+	if haveArchErfc {
+		return archErfc(x)
+	}
+	return erfc(x)
+}
 
 func erfc(x float64) float64 {
 	const Tiny = 1.0 / (1 << 56) // 2**-56
diff --git a/src/math/exp.go b/src/math/exp.go
index bd4c5c9b71..d05eb91fb0 100644
--- a/src/math/exp.go
+++ b/src/math/exp.go
@@ -11,7 +11,12 @@ package math
 //	Exp(NaN) = NaN
 // Very large values overflow to 0 or +Inf.
 // Very small values underflow to 1.
-func Exp(x float64) float64
+func Exp(x float64) float64 {
+	if haveArchExp {
+		return archExp(x)
+	}
+	return exp(x)
+}
 
 // The original C code, the long comment, and the constants
 // below are from FreeBSD's /usr/src/lib/msun/src/e_exp.c
@@ -132,7 +137,12 @@ func exp(x float64) float64 {
 // Exp2 returns 2**x, the base-2 exponential of x.
 //
 // Special cases are the same as Exp.
-func Exp2(x float64) float64
+func Exp2(x float64) float64 {
+	if haveArchExp2 {
+		return archExp2(x)
+	}
+	return exp2(x)
+}
 
 func exp2(x float64) float64 {
 	const (
diff --git a/src/math/exp2_asm.go b/src/math/exp2_asm.go
new file mode 100644
index 0000000000..76d258f125
--- /dev/null
+++ b/src/math/exp2_asm.go
@@ -0,0 +1,12 @@
+// Copyright 2021 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.
+
+//go:build arm64
+// +build arm64
+
+package math
+
+const haveArchExp2 = true
+
+func archExp2(x float64) float64
diff --git a/src/math/exp2_noasm.go b/src/math/exp2_noasm.go
new file mode 100644
index 0000000000..1b0ac87ebf
--- /dev/null
+++ b/src/math/exp2_noasm.go
@@ -0,0 +1,14 @@
+// Copyright 2021 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.
+
+//go:build !arm64
+// +build !arm64
+
+package math
+
+const haveArchExp2 = false
+
+func archExp2(x float64) float64 {
+	panic("not implemented")
+}
diff --git a/src/math/exp_amd64.go b/src/math/exp_amd64.go
new file mode 100644
index 0000000000..654ccce481
--- /dev/null
+++ b/src/math/exp_amd64.go
@@ -0,0 +1,12 @@
+// Copyright 2017 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.
+
+//go:build amd64
+// +build amd64
+
+package math
+
+import "internal/cpu"
+
+var useFMA = cpu.X86.HasAVX && cpu.X86.HasFMA
diff --git a/src/math/exp_amd64.s b/src/math/exp_amd64.s
index b3e1c22d04..02b71c81eb 100644
--- a/src/math/exp_amd64.s
+++ b/src/math/exp_amd64.s
@@ -37,7 +37,7 @@ DATA exprodata<>+64(SB)/8, $2.4801587301587301587e-5
 GLOBL exprodata<>+0(SB), RODATA, $72
 
 // func Exp(x float64) float64
-TEXT ·Exp(SB),NOSPLIT,$0
+TEXT ·archExp(SB),NOSPLIT,$0
 	// test bits for not-finite
 	MOVQ    x+0(FP), BX
 	MOVQ    $~(1<<63), AX // sign bit mask
diff --git a/src/math/exp_arm64.s b/src/math/exp_arm64.s
index 19736cbf44..44673abefe 100644
--- a/src/math/exp_arm64.s
+++ b/src/math/exp_arm64.s
@@ -23,7 +23,7 @@
 // This is an assembly implementation of the method used for function Exp in file exp.go.
 //
 // func Exp(x float64) float64
-TEXT ·Exp(SB),$0-16
+TEXT ·archExp(SB),$0-16
 	FMOVD	x+0(FP), F0	// F0 = x
 	FCMPD	F0, F0
 	BNE	isNaN		// x = NaN, return NaN
@@ -109,7 +109,7 @@ overflow:
 // This is an assembly implementation of the method used for function Exp2 in file exp.go.
 //
 // func Exp2(x float64) float64
-TEXT ·Exp2(SB),$0-16
+TEXT ·archExp2(SB),$0-16
 	FMOVD	x+0(FP), F0	// F0 = x
 	FCMPD	F0, F0
 	BNE	isNaN		// x = NaN, return NaN
diff --git a/src/math/exp_asm.go b/src/math/exp_asm.go
index 654ccce481..a1673ea1dd 100644
--- a/src/math/exp_asm.go
+++ b/src/math/exp_asm.go
@@ -1,12 +1,12 @@
-// Copyright 2017 The Go Authors. All rights reserved.
+// Copyright 2021 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.
 
-//go:build amd64
-// +build amd64
+//go:build amd64 || arm64 || s390x
+// +build amd64 arm64 s390x
 
 package math
 
-import "internal/cpu"
+const haveArchExp = true
 
-var useFMA = cpu.X86.HasAVX && cpu.X86.HasFMA
+func archExp(x float64) float64
diff --git a/src/math/exp_noasm.go b/src/math/exp_noasm.go
new file mode 100644
index 0000000000..b757e6e230
--- /dev/null
+++ b/src/math/exp_noasm.go
@@ -0,0 +1,14 @@
+// Copyright 2021 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.
+
+//go:build !amd64 && !arm64 && !s390x
+// +build !amd64,!arm64,!s390x
+
+package math
+
+const haveArchExp = false
+
+func archExp(x float64) float64 {
+	panic("not implemented")
+}
diff --git a/src/math/expm1.go b/src/math/expm1.go
index 8e77398adc..66d3421661 100644
--- a/src/math/expm1.go
+++ b/src/math/expm1.go
@@ -121,7 +121,12 @@ package math
 //	Expm1(-Inf) = -1
 //	Expm1(NaN) = NaN
 // Very large values overflow to -1 or +Inf.
-func Expm1(x float64) float64
+func Expm1(x float64) float64 {
+	if haveArchExpm1 {
+		return archExpm1(x)
+	}
+	return expm1(x)
+}
 
 func expm1(x float64) float64 {
 	const (
diff --git a/src/math/floor.go b/src/math/floor.go
index 18e89ef89f..7913a900e3 100644
--- a/src/math/floor.go
+++ b/src/math/floor.go
@@ -10,7 +10,12 @@ package math
 //	Floor(±0) = ±0
 //	Floor(±Inf) = ±Inf
 //	Floor(NaN) = NaN
-func Floor(x float64) float64
+func Floor(x float64) float64 {
+	if haveArchFloor {
+		return archFloor(x)
+	}
+	return floor(x)
+}
 
 func floor(x float64) float64 {
 	if x == 0 || IsNaN(x) || IsInf(x, 0) {
@@ -33,7 +38,12 @@ func floor(x float64) float64 {
 //	Ceil(±0) = ±0
 //	Ceil(±Inf) = ±Inf
 //	Ceil(NaN) = NaN
-func Ceil(x float64) float64
+func Ceil(x float64) float64 {
+	if haveArchCeil {
+		return archCeil(x)
+	}
+	return ceil(x)
+}
 
 func ceil(x float64) float64 {
 	return -Floor(-x)
@@ -45,7 +55,12 @@ func ceil(x float64) float64 {
 //	Trunc(±0) = ±0
 //	Trunc(±Inf) = ±Inf
 //	Trunc(NaN) = NaN
-func Trunc(x float64) float64
+func Trunc(x float64) float64 {
+	if haveArchTrunc {
+		return archTrunc(x)
+	}
+	return trunc(x)
+}
 
 func trunc(x float64) float64 {
 	if x == 0 || IsNaN(x) || IsInf(x, 0) {
diff --git a/src/math/floor_386.s b/src/math/floor_386.s
index 0960eecde2..1990cb0c8c 100644
--- a/src/math/floor_386.s
+++ b/src/math/floor_386.s
@@ -4,8 +4,8 @@
 
 #include "textflag.h"
 
-// func Ceil(x float64) float64
-TEXT ·Ceil(SB),NOSPLIT,$0
+// func archCeil(x float64) float64
+TEXT ·archCeil(SB),NOSPLIT,$0
 	FMOVD   x+0(FP), F0  // F0=x
 	FSTCW   -2(SP)       // save old Control Word
 	MOVW    -2(SP), AX
@@ -18,8 +18,8 @@ TEXT ·Ceil(SB),NOSPLIT,$0
 	FMOVDP  F0, ret+8(FP)
 	RET
 
-// func Floor(x float64) float64
-TEXT ·Floor(SB),NOSPLIT,$0
+// func archFloor(x float64) float64
+TEXT ·archFloor(SB),NOSPLIT,$0
 	FMOVD   x+0(FP), F0  // F0=x
 	FSTCW   -2(SP)       // save old Control Word
 	MOVW    -2(SP), AX
@@ -32,8 +32,8 @@ TEXT ·Floor(SB),NOSPLIT,$0
 	FMOVDP  F0, ret+8(FP)
 	RET
 
-// func Trunc(x float64) float64
-TEXT ·Trunc(SB),NOSPLIT,$0
+// func archTrunc(x float64) float64
+TEXT ·archTrunc(SB),NOSPLIT,$0
 	FMOVD   x+0(FP), F0  // F0=x
 	FSTCW   -2(SP)       // save old Control Word
 	MOVW    -2(SP), AX
diff --git a/src/math/floor_amd64.s b/src/math/floor_amd64.s
index 4ef02eb09a..088049958a 100644
--- a/src/math/floor_amd64.s
+++ b/src/math/floor_amd64.s
@@ -6,8 +6,8 @@
 
 #define Big		0x4330000000000000 // 2**52
 
-// func Floor(x float64) float64
-TEXT ·Floor(SB),NOSPLIT,$0
+// func archFloor(x float64) float64
+TEXT ·archFloor(SB),NOSPLIT,$0
 	MOVQ	x+0(FP), AX
 	MOVQ	$~(1<<63), DX // sign bit mask
 	ANDQ	AX,DX // DX = |x|
@@ -28,8 +28,8 @@ isBig_floor:
 	MOVQ    AX, ret+8(FP) // return x
 	RET
 
-// func Ceil(x float64) float64
-TEXT ·Ceil(SB),NOSPLIT,$0
+// func archCeil(x float64) float64
+TEXT ·archCeil(SB),NOSPLIT,$0
 	MOVQ	x+0(FP), AX
 	MOVQ	$~(1<<63), DX // sign bit mask
 	MOVQ	AX, BX // BX = copy of x
@@ -54,8 +54,8 @@ isBig_ceil:
 	MOVQ	AX, ret+8(FP)
 	RET
 
-// func Trunc(x float64) float64
-TEXT ·Trunc(SB),NOSPLIT,$0
+// func archTrunc(x float64) float64
+TEXT ·archTrunc(SB),NOSPLIT,$0
 	MOVQ	x+0(FP), AX
 	MOVQ	$~(1<<63), DX // sign bit mask
 	MOVQ	AX, BX // BX = copy of x
diff --git a/src/math/floor_arm64.s b/src/math/floor_arm64.s
index 6d240d4cd8..d9c5df7b24 100644
--- a/src/math/floor_arm64.s
+++ b/src/math/floor_arm64.s
@@ -4,22 +4,22 @@
 
 #include "textflag.h"
 
-// func Floor(x float64) float64
-TEXT ·Floor(SB),NOSPLIT,$0
+// func archFloor(x float64) float64
+TEXT ·archFloor(SB),NOSPLIT,$0
 	FMOVD	x+0(FP), F0
 	FRINTMD	F0, F0
 	FMOVD	F0, ret+8(FP)
 	RET
 
-// func Ceil(x float64) float64
-TEXT ·Ceil(SB),NOSPLIT,$0
+// func archCeil(x float64) float64
+TEXT ·archCeil(SB),NOSPLIT,$0
 	FMOVD	x+0(FP), F0
 	FRINTPD	F0, F0
 	FMOVD	F0, ret+8(FP)
 	RET
 
-// func Trunc(x float64) float64
-TEXT ·Trunc(SB),NOSPLIT,$0
+// func archTrunc(x float64) float64
+TEXT ·archTrunc(SB),NOSPLIT,$0
 	FMOVD	x+0(FP), F0
 	FRINTZD	F0, F0
 	FMOVD	F0, ret+8(FP)
diff --git a/src/math/floor_asm.go b/src/math/floor_asm.go
new file mode 100644
index 0000000000..1265e5171e
--- /dev/null
+++ b/src/math/floor_asm.go
@@ -0,0 +1,20 @@
+// Copyright 2021 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.
+
+//go:build 386 || amd64 || arm64 || ppc64 || ppc64le || s390x || wasm
+// +build 386 amd64 arm64 ppc64 ppc64le s390x wasm
+
+package math
+
+const haveArchFloor = true
+
+func archFloor(x float64) float64
+
+const haveArchCeil = true
+
+func archCeil(x float64) float64
+
+const haveArchTrunc = true
+
+func archTrunc(x float64) float64
diff --git a/src/math/floor_noasm.go b/src/math/floor_noasm.go
new file mode 100644
index 0000000000..821af21020
--- /dev/null
+++ b/src/math/floor_noasm.go
@@ -0,0 +1,26 @@
+// Copyright 2021 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.
+
+//go:build !386 && !amd64 && !arm64 && !ppc64 && !ppc64le && !s390x && !wasm
+// +build !386,!amd64,!arm64,!ppc64,!ppc64le,!s390x,!wasm
+
+package math
+
+const haveArchFloor = false
+
+func archFloor(x float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchCeil = false
+
+func archCeil(x float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchTrunc = false
+
+func archTrunc(x float64) float64 {
+	panic("not implemented")
+}
diff --git a/src/math/floor_ppc64x.s b/src/math/floor_ppc64x.s
index 2ab011d5b5..29b92a62c3 100644
--- a/src/math/floor_ppc64x.s
+++ b/src/math/floor_ppc64x.s
@@ -6,19 +6,19 @@
 
 #include "textflag.h"
 
-TEXT ·Floor(SB),NOSPLIT,$0
+TEXT ·archFloor(SB),NOSPLIT,$0
 	FMOVD   x+0(FP), F0
 	FRIM	F0, F0
 	FMOVD   F0, ret+8(FP)
 	RET
 
-TEXT ·Ceil(SB),NOSPLIT,$0
+TEXT ·archCeil(SB),NOSPLIT,$0
 	FMOVD   x+0(FP), F0
 	FRIP    F0, F0
 	FMOVD	F0, ret+8(FP)
 	RET
 
-TEXT ·Trunc(SB),NOSPLIT,$0
+TEXT ·archTrunc(SB),NOSPLIT,$0
 	FMOVD   x+0(FP), F0
 	FRIZ    F0, F0
 	FMOVD   F0, ret+8(FP)
diff --git a/src/math/floor_s390x.s b/src/math/floor_s390x.s
index 896e79b807..b5dd462e52 100644
--- a/src/math/floor_s390x.s
+++ b/src/math/floor_s390x.s
@@ -4,22 +4,22 @@
 
 #include "textflag.h"
 
-// func Floor(x float64) float64
-TEXT ·Floor(SB),NOSPLIT,$0
+// func archFloor(x float64) float64
+TEXT ·archFloor(SB),NOSPLIT,$0
 	FMOVD	x+0(FP), F0
 	FIDBR	$7, F0, F0
 	FMOVD	F0, ret+8(FP)
 	RET
 
-// func Ceil(x float64) float64
-TEXT ·Ceil(SB),NOSPLIT,$0
+// func archCeil(x float64) float64
+TEXT ·archCeil(SB),NOSPLIT,$0
 	FMOVD	x+0(FP), F0
 	FIDBR	$6, F0, F0
 	FMOVD	F0, ret+8(FP)
 	RET
 
-// func Trunc(x float64) float64
-TEXT ·Trunc(SB),NOSPLIT,$0
+// func archTrunc(x float64) float64
+TEXT ·archTrunc(SB),NOSPLIT,$0
 	FMOVD	x+0(FP), F0
 	FIDBR	$5, F0, F0
 	FMOVD	F0, ret+8(FP)
diff --git a/src/math/floor_wasm.s b/src/math/floor_wasm.s
index 4d8a0eb070..3751471574 100644
--- a/src/math/floor_wasm.s
+++ b/src/math/floor_wasm.s
@@ -4,21 +4,21 @@
 
 #include "textflag.h"
 
-TEXT ·Floor(SB),NOSPLIT,$0
+TEXT ·archFloor(SB),NOSPLIT,$0
 	Get SP
 	F64Load x+0(FP)
 	F64Floor
 	F64Store ret+8(FP)
 	RET
 
-TEXT ·Ceil(SB),NOSPLIT,$0
+TEXT ·archCeil(SB),NOSPLIT,$0
 	Get SP
 	F64Load x+0(FP)
 	F64Ceil
 	F64Store ret+8(FP)
 	RET
 
-TEXT ·Trunc(SB),NOSPLIT,$0
+TEXT ·archTrunc(SB),NOSPLIT,$0
 	Get SP
 	F64Load x+0(FP)
 	F64Trunc
diff --git a/src/math/frexp.go b/src/math/frexp.go
index 0e26feb666..3c8a909ed0 100644
--- a/src/math/frexp.go
+++ b/src/math/frexp.go
@@ -13,7 +13,12 @@ package math
 //	Frexp(±0) = ±0, 0
 //	Frexp(±Inf) = ±Inf, 0
 //	Frexp(NaN) = NaN, 0
-func Frexp(f float64) (frac float64, exp int)
+func Frexp(f float64) (frac float64, exp int) {
+	if haveArchFrexp {
+		return archFrexp(f)
+	}
+	return frexp(f)
+}
 
 func frexp(f float64) (frac float64, exp int) {
 	// special cases
diff --git a/src/math/hypot.go b/src/math/hypot.go
index c7f19d4d38..12af17766d 100644
--- a/src/math/hypot.go
+++ b/src/math/hypot.go
@@ -16,7 +16,12 @@ package math
 //	Hypot(p, ±Inf) = +Inf
 //	Hypot(NaN, q) = NaN
 //	Hypot(p, NaN) = NaN
-func Hypot(p, q float64) float64
+func Hypot(p, q float64) float64 {
+	if haveArchHypot {
+		return archHypot(p, q)
+	}
+	return hypot(p, q)
+}
 
 func hypot(p, q float64) float64 {
 	// special cases
diff --git a/src/math/hypot_386.s b/src/math/hypot_386.s
index a89cdf7c1b..80a8fd3fd0 100644
--- a/src/math/hypot_386.s
+++ b/src/math/hypot_386.s
@@ -4,8 +4,8 @@
 
 #include "textflag.h"
 
-// func Hypot(p, q float64) float64
-TEXT ·Hypot(SB),NOSPLIT,$0
+// func archHypot(p, q float64) float64
+TEXT ·archHypot(SB),NOSPLIT,$0
 // test bits for not-finite
 	MOVL    p_hi+4(FP), AX   // high word p
 	ANDL    $0x7ff00000, AX
diff --git a/src/math/hypot_amd64.s b/src/math/hypot_amd64.s
index d7983a7d7b..fe326c9281 100644
--- a/src/math/hypot_amd64.s
+++ b/src/math/hypot_amd64.s
@@ -7,8 +7,8 @@
 #define PosInf 0x7FF0000000000000
 #define NaN 0x7FF8000000000001
 
-// func Hypot(p, q float64) float64
-TEXT ·Hypot(SB),NOSPLIT,$0
+// func archHypot(p, q float64) float64
+TEXT ·archHypot(SB),NOSPLIT,$0
 	// test bits for special cases
 	MOVQ    p+0(FP), BX
 	MOVQ    $~(1<<63), AX
diff --git a/src/math/hypot_asm.go b/src/math/hypot_asm.go
new file mode 100644
index 0000000000..9435af41cf
--- /dev/null
+++ b/src/math/hypot_asm.go
@@ -0,0 +1,12 @@
+// Copyright 2021 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.
+
+//go:build 386 || amd64
+// +build 386 amd64
+
+package math
+
+const haveArchHypot = true
+
+func archHypot(p, q float64) float64
diff --git a/src/math/hypot_noasm.go b/src/math/hypot_noasm.go
new file mode 100644
index 0000000000..bc41b136e5
--- /dev/null
+++ b/src/math/hypot_noasm.go
@@ -0,0 +1,14 @@
+// Copyright 2021 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.
+
+//go:build !386 && !amd64
+// +build !386,!amd64
+
+package math
+
+const haveArchHypot = false
+
+func archHypot(p, q float64) float64 {
+	panic("not implemented")
+}
diff --git a/src/math/ldexp.go b/src/math/ldexp.go
index aa50a49ade..55c82f1e84 100644
--- a/src/math/ldexp.go
+++ b/src/math/ldexp.go
@@ -11,7 +11,12 @@ package math
 //	Ldexp(±0, exp) = ±0
 //	Ldexp(±Inf, exp) = ±Inf
 //	Ldexp(NaN, exp) = NaN
-func Ldexp(frac float64, exp int) float64
+func Ldexp(frac float64, exp int) float64 {
+	if haveArchLdexp {
+		return archLdexp(frac, exp)
+	}
+	return ldexp(frac, exp)
+}
 
 func ldexp(frac float64, exp int) float64 {
 	// special cases
diff --git a/src/math/log.go b/src/math/log.go
index e328348328..1b3e306adf 100644
--- a/src/math/log.go
+++ b/src/math/log.go
@@ -77,7 +77,12 @@ package math
 //	Log(0) = -Inf
 //	Log(x < 0) = NaN
 //	Log(NaN) = NaN
-func Log(x float64) float64
+func Log(x float64) float64 {
+	if haveArchLog {
+		return archLog(x)
+	}
+	return log(x)
+}
 
 func log(x float64) float64 {
 	const (
diff --git a/src/math/log10.go b/src/math/log10.go
index ccd079d891..e6916a53b6 100644
--- a/src/math/log10.go
+++ b/src/math/log10.go
@@ -6,7 +6,12 @@ package math
 
 // Log10 returns the decimal logarithm of x.
 // The special cases are the same as for Log.
-func Log10(x float64) float64
+func Log10(x float64) float64 {
+	if haveArchLog10 {
+		return archLog10(x)
+	}
+	return log10(x)
+}
 
 func log10(x float64) float64 {
 	return Log(x) * (1 / Ln10)
@@ -14,7 +19,12 @@ func log10(x float64) float64 {
 
 // Log2 returns the binary logarithm of x.
 // The special cases are the same as for Log.
-func Log2(x float64) float64
+func Log2(x float64) float64 {
+	if haveArchLog2 {
+		return archLog2(x)
+	}
+	return log2(x)
+}
 
 func log2(x float64) float64 {
 	frac, exp := Frexp(x)
diff --git a/src/math/log1p.go b/src/math/log1p.go
index e34e1ff4f2..c117f7245d 100644
--- a/src/math/log1p.go
+++ b/src/math/log1p.go
@@ -92,7 +92,12 @@ package math
 //	Log1p(-1) = -Inf
 //	Log1p(x < -1) = NaN
 //	Log1p(NaN) = NaN
-func Log1p(x float64) float64
+func Log1p(x float64) float64 {
+	if haveArchLog1p {
+		return archLog1p(x)
+	}
+	return log1p(x)
+}
 
 func log1p(x float64) float64 {
 	const (
diff --git a/src/math/log_amd64.s b/src/math/log_amd64.s
index 3d7638979f..d84091f23a 100644
--- a/src/math/log_amd64.s
+++ b/src/math/log_amd64.s
@@ -19,7 +19,7 @@
 #define PosInf 0x7FF0000000000000
 
 // func Log(x float64) float64
-TEXT ·Log(SB),NOSPLIT,$0
+TEXT ·archLog(SB),NOSPLIT,$0
 	// test bits for special cases
 	MOVQ    x+0(FP), BX
 	MOVQ    $~(1<<63), AX // sign bit mask
diff --git a/src/math/log_asm.go b/src/math/log_asm.go
new file mode 100644
index 0000000000..4d3b7ee065
--- /dev/null
+++ b/src/math/log_asm.go
@@ -0,0 +1,12 @@
+// Copyright 2021 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.
+
+//go:build amd64 || s390x
+// +build amd64 s390x
+
+package math
+
+const haveArchLog = true
+
+func archLog(x float64) float64
diff --git a/src/math/log_stub.go b/src/math/log_stub.go
new file mode 100644
index 0000000000..e169716436
--- /dev/null
+++ b/src/math/log_stub.go
@@ -0,0 +1,14 @@
+// Copyright 2021 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.
+
+//go:build !amd64 && !s390x
+// +build !amd64,!s390x
+
+package math
+
+const haveArchLog = false
+
+func archLog(x float64) float64 {
+	panic("not implemented")
+}
diff --git a/src/math/mod.go b/src/math/mod.go
index 7efc018a5d..6bc5f28832 100644
--- a/src/math/mod.go
+++ b/src/math/mod.go
@@ -18,7 +18,12 @@ package math
 //	Mod(x, 0) = NaN
 //	Mod(x, ±Inf) = x
 //	Mod(x, NaN) = NaN
-func Mod(x, y float64) float64
+func Mod(x, y float64) float64 {
+	if haveArchMod {
+		return archMod(x, y)
+	}
+	return mod(x, y)
+}
 
 func mod(x, y float64) float64 {
 	if y == 0 || IsInf(x, 0) || IsNaN(x) || IsNaN(y) {
diff --git a/src/math/modf.go b/src/math/modf.go
index c5bb89455f..bf08dc6556 100644
--- a/src/math/modf.go
+++ b/src/math/modf.go
@@ -10,7 +10,12 @@ package math
 // Special cases are:
 //	Modf(±Inf) = ±Inf, NaN
 //	Modf(NaN) = NaN, NaN
-func Modf(f float64) (int float64, frac float64)
+func Modf(f float64) (int float64, frac float64) {
+	if haveArchModf {
+		return archModf(f)
+	}
+	return modf(f)
+}
 
 func modf(f float64) (int float64, frac float64) {
 	if f < 1 {
diff --git a/src/math/modf_arm64.s b/src/math/modf_arm64.s
index 7c70ef33ac..1e4a329a4b 100644
--- a/src/math/modf_arm64.s
+++ b/src/math/modf_arm64.s
@@ -4,8 +4,8 @@
 
 #include "textflag.h"
 
-// func Modf(f float64) (int float64, frac float64)
-TEXT ·Modf(SB),NOSPLIT,$0
+// func archModf(f float64) (int float64, frac float64)
+TEXT ·archModf(SB),NOSPLIT,$0
 	MOVD	f+0(FP), R0
 	FMOVD	R0, F0
 	FRINTZD	F0, F1
diff --git a/src/math/modf_asm.go b/src/math/modf_asm.go
new file mode 100644
index 0000000000..ce431a9d8d
--- /dev/null
+++ b/src/math/modf_asm.go
@@ -0,0 +1,12 @@
+// Copyright 2021 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.
+
+//go:build arm64 || ppc64 || ppc64le
+// +build arm64 ppc64 ppc64le
+
+package math
+
+const haveArchModf = true
+
+func archModf(f float64) (int float64, frac float64)
diff --git a/src/math/modf_noasm.go b/src/math/modf_noasm.go
new file mode 100644
index 0000000000..9607a0894b
--- /dev/null
+++ b/src/math/modf_noasm.go
@@ -0,0 +1,14 @@
+// Copyright 2021 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.
+
+//go:build !arm64 && !ppc64 && !ppc64le
+// +build !arm64,!ppc64,!ppc64le
+
+package math
+
+const haveArchModf = false
+
+func archModf(f float64) (int float64, frac float64) {
+	panic("not implemented")
+}
diff --git a/src/math/modf_ppc64x.s b/src/math/modf_ppc64x.s
index da58653d69..caa435eef9 100644
--- a/src/math/modf_ppc64x.s
+++ b/src/math/modf_ppc64x.s
@@ -6,8 +6,8 @@
 
 #include "textflag.h"
 
-// func Modf(f float64) (int float64, frac float64)
-TEXT ·Modf(SB),NOSPLIT,$0
+// func archModf(f float64) (int float64, frac float64)
+TEXT ·archModf(SB),NOSPLIT,$0
 	FMOVD	f+0(FP), F0
 	FRIZ	F0, F1
 	FMOVD	F1, int+8(FP)
diff --git a/src/math/pow.go b/src/math/pow.go
index 2219a906b8..e45a044ae1 100644
--- a/src/math/pow.go
+++ b/src/math/pow.go
@@ -35,7 +35,12 @@ func isOddInt(x float64) bool {
 //	Pow(+Inf, y) = +0 for y < 0
 //	Pow(-Inf, y) = Pow(-0, -y)
 //	Pow(x, y) = NaN for finite x < 0 and finite non-integer y
-func Pow(x, y float64) float64
+func Pow(x, y float64) float64 {
+	if haveArchPow {
+		return archPow(x, y)
+	}
+	return pow(x, y)
+}
 
 func pow(x, y float64) float64 {
 	switch {
diff --git a/src/math/remainder.go b/src/math/remainder.go
index 7c77d6eb3b..bf8bfd5553 100644
--- a/src/math/remainder.go
+++ b/src/math/remainder.go
@@ -34,7 +34,12 @@ package math
 //	Remainder(x, 0) = NaN
 //	Remainder(x, ±Inf) = x
 //	Remainder(x, NaN) = NaN
-func Remainder(x, y float64) float64
+func Remainder(x, y float64) float64 {
+	if haveArchRemainder {
+		return archRemainder(x, y)
+	}
+	return remainder(x, y)
+}
 
 func remainder(x, y float64) float64 {
 	const (
diff --git a/src/math/sin.go b/src/math/sin.go
index 3b6dbe3397..d95bb548e8 100644
--- a/src/math/sin.go
+++ b/src/math/sin.go
@@ -114,7 +114,12 @@ var _cos = [...]float64{
 // Special cases are:
 //	Cos(±Inf) = NaN
 //	Cos(NaN) = NaN
-func Cos(x float64) float64
+func Cos(x float64) float64 {
+	if haveArchCos {
+		return archCos(x)
+	}
+	return cos(x)
+}
 
 func cos(x float64) float64 {
 	const (
@@ -175,7 +180,12 @@ func cos(x float64) float64 {
 //	Sin(±0) = ±0
 //	Sin(±Inf) = NaN
 //	Sin(NaN) = NaN
-func Sin(x float64) float64
+func Sin(x float64) float64 {
+	if haveArchSin {
+		return archSin(x)
+	}
+	return sin(x)
+}
 
 func sin(x float64) float64 {
 	const (
diff --git a/src/math/sinh.go b/src/math/sinh.go
index 573a37e35f..9fe9b4e17a 100644
--- a/src/math/sinh.go
+++ b/src/math/sinh.go
@@ -22,7 +22,12 @@ package math
 //	Sinh(±0) = ±0
 //	Sinh(±Inf) = ±Inf
 //	Sinh(NaN) = NaN
-func Sinh(x float64) float64
+func Sinh(x float64) float64 {
+	if haveArchSinh {
+		return archSinh(x)
+	}
+	return sinh(x)
+}
 
 func sinh(x float64) float64 {
 	// The coefficients are #2029 from Hart & Cheney. (20.36D)
@@ -69,7 +74,12 @@ func sinh(x float64) float64 {
 //	Cosh(±0) = 1
 //	Cosh(±Inf) = +Inf
 //	Cosh(NaN) = NaN
-func Cosh(x float64) float64
+func Cosh(x float64) float64 {
+	if haveArchCosh {
+		return archCosh(x)
+	}
+	return cosh(x)
+}
 
 func cosh(x float64) float64 {
 	x = Abs(x)
diff --git a/src/math/sqrt.go b/src/math/sqrt.go
index 1077a62897..903d57d5e0 100644
--- a/src/math/sqrt.go
+++ b/src/math/sqrt.go
@@ -89,7 +89,12 @@ package math
 //	Sqrt(±0) = ±0
 //	Sqrt(x < 0) = NaN
 //	Sqrt(NaN) = NaN
-func Sqrt(x float64) float64
+func Sqrt(x float64) float64 {
+	if haveArchSqrt {
+		return archSqrt(x)
+	}
+	return sqrt(x)
+}
 
 // Note: Sqrt is implemented in assembly on some systems.
 // Others have assembly stubs that jump to func sqrt below.
diff --git a/src/math/sqrt_386.s b/src/math/sqrt_386.s
index 5a5c33a79a..90aec13b8d 100644
--- a/src/math/sqrt_386.s
+++ b/src/math/sqrt_386.s
@@ -4,8 +4,8 @@
 
 #include "textflag.h"
 
-// func Sqrt(x float64) float64
-TEXT ·Sqrt(SB),NOSPLIT,$0
+// func archSqrt(x float64) float64
+TEXT ·archSqrt(SB),NOSPLIT,$0
 	FMOVD   x+0(FP),F0
 	FSQRT
 	FMOVDP  F0,ret+8(FP)
diff --git a/src/math/sqrt_amd64.s b/src/math/sqrt_amd64.s
index 1102903055..c3b110e7c0 100644
--- a/src/math/sqrt_amd64.s
+++ b/src/math/sqrt_amd64.s
@@ -4,8 +4,8 @@
 
 #include "textflag.h"
 
-// func Sqrt(x float64) float64
-TEXT ·Sqrt(SB), NOSPLIT, $0
+// func archSqrt(x float64) float64
+TEXT ·archSqrt(SB), NOSPLIT, $0
 	XORPS  X0, X0 // break dependency
 	SQRTSD x+0(FP), X0
 	MOVSD  X0, ret+8(FP)
diff --git a/src/math/sqrt_arm.s b/src/math/sqrt_arm.s
index ffc7d1026d..64792ecaf7 100644
--- a/src/math/sqrt_arm.s
+++ b/src/math/sqrt_arm.s
@@ -4,8 +4,8 @@
 
 #include "textflag.h"
 
-// func Sqrt(x float64) float64
-TEXT ·Sqrt(SB),NOSPLIT,$0
+// func archSqrt(x float64) float64
+TEXT ·archSqrt(SB),NOSPLIT,$0
 	MOVB	runtime·goarm(SB), R11
 	CMP	$5, R11
 	BEQ	arm5
diff --git a/src/math/sqrt_arm64.s b/src/math/sqrt_arm64.s
index 3041d25722..36ba41ab4a 100644
--- a/src/math/sqrt_arm64.s
+++ b/src/math/sqrt_arm64.s
@@ -4,8 +4,8 @@
 
 #include "textflag.h"
 
-// func Sqrt(x float64) float64
-TEXT ·Sqrt(SB),NOSPLIT,$0
+// func archSqrt(x float64) float64
+TEXT ·archSqrt(SB),NOSPLIT,$0
 	FMOVD	x+0(FP), F0
 	FSQRTD	F0, F0
 	FMOVD	F0, ret+8(FP)
diff --git a/src/math/sqrt_asm.go b/src/math/sqrt_asm.go
new file mode 100644
index 0000000000..b9102568ed
--- /dev/null
+++ b/src/math/sqrt_asm.go
@@ -0,0 +1,12 @@
+// Copyright 2021 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.
+
+//go:build 386 || amd64 || arm64 || arm || mips || mipsle || ppc64 || ppc64le || s390x || riscv64 || wasm
+// +build 386 amd64 arm64 arm mips mipsle ppc64 ppc64le s390x riscv64 wasm
+
+package math
+
+const haveArchSqrt = true
+
+func archSqrt(x float64) float64
diff --git a/src/math/sqrt_mipsx.s b/src/math/sqrt_mipsx.s
index a63ea9ec9f..c619c19ec2 100644
--- a/src/math/sqrt_mipsx.s
+++ b/src/math/sqrt_mipsx.s
@@ -6,8 +6,8 @@
 
 #include "textflag.h"
 
-// func Sqrt(x float64) float64
-TEXT ·Sqrt(SB),NOSPLIT,$0
+// func archSqrt(x float64) float64
+TEXT ·archSqrt(SB),NOSPLIT,$0
 #ifdef GOMIPS_softfloat
 	JMP ·sqrt(SB)
 #else
diff --git a/src/math/sqrt_noasm.go b/src/math/sqrt_noasm.go
new file mode 100644
index 0000000000..7b546b7e8c
--- /dev/null
+++ b/src/math/sqrt_noasm.go
@@ -0,0 +1,14 @@
+// Copyright 2021 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.
+
+//go:build !386 && !amd64 && !arm64 && !arm && !mips && !mipsle && !ppc64 && !ppc64le && !s390x && !riscv64 && !wasm
+// +build !386,!amd64,!arm64,!arm,!mips,!mipsle,!ppc64,!ppc64le,!s390x,!riscv64,!wasm
+
+package math
+
+const haveArchSqrt = false
+
+func archSqrt(x float64) float64 {
+	panic("not implemented")
+}
diff --git a/src/math/sqrt_ppc64x.s b/src/math/sqrt_ppc64x.s
index 0469f4d0e1..174b63e35a 100644
--- a/src/math/sqrt_ppc64x.s
+++ b/src/math/sqrt_ppc64x.s
@@ -6,8 +6,8 @@
 
 #include "textflag.h"
 
-// func Sqrt(x float64) float64
-TEXT ·Sqrt(SB),NOSPLIT,$0
+// func archSqrt(x float64) float64
+TEXT ·archSqrt(SB),NOSPLIT,$0
 	FMOVD	x+0(FP), F0
 	FSQRT	F0, F0
 	FMOVD	F0, ret+8(FP)
diff --git a/src/math/sqrt_riscv64.s b/src/math/sqrt_riscv64.s
index 048171b9fb..f223510c42 100644
--- a/src/math/sqrt_riscv64.s
+++ b/src/math/sqrt_riscv64.s
@@ -6,8 +6,8 @@
 
 #include "textflag.h"
 
-// func Sqrt(x float64) float64
-TEXT ·Sqrt(SB),NOSPLIT,$0
+// func archSqrt(x float64) float64
+TEXT ·archSqrt(SB),NOSPLIT,$0
 	MOVD	x+0(FP), F0
 	FSQRTD	F0, F0
 	MOVD	F0, ret+8(FP)
diff --git a/src/math/sqrt_s390x.s b/src/math/sqrt_s390x.s
index 37ca0bec91..fa31f75362 100644
--- a/src/math/sqrt_s390x.s
+++ b/src/math/sqrt_s390x.s
@@ -4,8 +4,8 @@
 
 #include "textflag.h"
 
-// func Sqrt(x float64) float64
-TEXT ·Sqrt(SB),NOSPLIT,$0
+// func archSqrt(x float64) float64
+TEXT ·archSqrt(SB),NOSPLIT,$0
 	FMOVD x+0(FP), F1
 	FSQRT F1, F1
 	FMOVD F1, ret+8(FP)
diff --git a/src/math/sqrt_wasm.s b/src/math/sqrt_wasm.s
index cbfe598a43..fa6799ddc6 100644
--- a/src/math/sqrt_wasm.s
+++ b/src/math/sqrt_wasm.s
@@ -4,7 +4,7 @@
 
 #include "textflag.h"
 
-TEXT ·Sqrt(SB),NOSPLIT,$0
+TEXT ·archSqrt(SB),NOSPLIT,$0
 	Get SP
 	F64Load x+0(FP)
 	F64Sqrt
diff --git a/src/math/stubs.go b/src/math/stubs.go
new file mode 100644
index 0000000000..e1345eb841
--- /dev/null
+++ b/src/math/stubs.go
@@ -0,0 +1,161 @@
+// Copyright 2021 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.
+
+//go:build !s390x
+// +build !s390x
+
+// This is a large group of functions that most architectures don't
+// implement in assembly.
+
+package math
+
+const haveArchAcos = false
+
+func archAcos(x float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchAcosh = false
+
+func archAcosh(x float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchAsin = false
+
+func archAsin(x float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchAsinh = false
+
+func archAsinh(x float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchAtan = false
+
+func archAtan(x float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchAtan2 = false
+
+func archAtan2(y, x float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchAtanh = false
+
+func archAtanh(x float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchCbrt = false
+
+func archCbrt(x float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchCos = false
+
+func archCos(x float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchCosh = false
+
+func archCosh(x float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchErf = false
+
+func archErf(x float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchErfc = false
+
+func archErfc(x float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchExpm1 = false
+
+func archExpm1(x float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchFrexp = false
+
+func archFrexp(x float64) (float64, int) {
+	panic("not implemented")
+}
+
+const haveArchLdexp = false
+
+func archLdexp(frac float64, exp int) float64 {
+	panic("not implemented")
+}
+
+const haveArchLog10 = false
+
+func archLog10(x float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchLog2 = false
+
+func archLog2(x float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchLog1p = false
+
+func archLog1p(x float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchMod = false
+
+func archMod(x, y float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchPow = false
+
+func archPow(x, y float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchRemainder = false
+
+func archRemainder(x, y float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchSin = false
+
+func archSin(x float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchSinh = false
+
+func archSinh(x float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchTan = false
+
+func archTan(x float64) float64 {
+	panic("not implemented")
+}
+
+const haveArchTanh = false
+
+func archTanh(x float64) float64 {
+	panic("not implemented")
+}
diff --git a/src/math/stubs_386.s b/src/math/stubs_386.s
deleted file mode 100644
index bccb3edd11..0000000000
--- a/src/math/stubs_386.s
+++ /dev/null
@@ -1,98 +0,0 @@
-// Copyright 2019 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.
-
-#include "textflag.h"
-
-TEXT ·Acos(SB), NOSPLIT, $0
-	JMP ·acos(SB)
-
-TEXT ·Acosh(SB), NOSPLIT, $0
-	JMP ·acosh(SB)
-
-TEXT ·Asin(SB), NOSPLIT, $0
-	JMP ·asin(SB)
-
-TEXT ·Asinh(SB), NOSPLIT, $0
-	JMP ·asinh(SB)
-
-TEXT ·Atan(SB), NOSPLIT, $0
-	JMP ·atan(SB)
-
-TEXT ·Atan2(SB), NOSPLIT, $0
-	JMP ·atan2(SB)
-
-TEXT ·Atanh(SB), NOSPLIT, $0
-	JMP ·atanh(SB)
-
-TEXT ·Cbrt(SB), NOSPLIT, $0
-	JMP ·cbrt(SB)
-
-TEXT ·Cos(SB), NOSPLIT, $0
-	JMP ·cos(SB)
-
-TEXT ·Cosh(SB), NOSPLIT, $0
-	JMP ·cosh(SB)
-
-TEXT ·Erf(SB), NOSPLIT, $0
-	JMP ·erf(SB)
-
-TEXT ·Erfc(SB), NOSPLIT, $0
-	JMP ·erfc(SB)
-
-TEXT ·Exp(SB), NOSPLIT, $0
-	JMP ·exp(SB)
-
-TEXT ·Exp2(SB), NOSPLIT, $0
-	JMP ·exp2(SB)
-
-TEXT ·Expm1(SB), NOSPLIT, $0
-	JMP ·expm1(SB)
-
-TEXT ·Frexp(SB), NOSPLIT, $0
-	JMP ·frexp(SB)
-
-TEXT ·Ldexp(SB), NOSPLIT, $0
-	JMP ·ldexp(SB)
-
-TEXT ·Log10(SB), NOSPLIT, $0
-	JMP ·log10(SB)
-
-TEXT ·Log2(SB), NOSPLIT, $0
-	JMP ·log2(SB)
-
-TEXT ·Log1p(SB), NOSPLIT, $0
-	JMP ·log1p(SB)
-
-TEXT ·Log(SB), NOSPLIT, $0
-	JMP ·log(SB)
-
-TEXT ·Max(SB), NOSPLIT, $0
-	JMP ·max(SB)
-
-TEXT ·Min(SB), NOSPLIT, $0
-	JMP ·min(SB)
-
-TEXT ·Mod(SB), NOSPLIT, $0
-	JMP ·mod(SB)
-
-TEXT ·Modf(SB), NOSPLIT, $0
-	JMP ·modf(SB)
-
-TEXT ·Pow(SB), NOSPLIT, $0
-	JMP ·pow(SB)
-
-TEXT ·Remainder(SB), NOSPLIT, $0
-	JMP ·remainder(SB)
-
-TEXT ·Sin(SB), NOSPLIT, $0
-	JMP ·sin(SB)
-
-TEXT ·Sinh(SB), NOSPLIT, $0
-	JMP ·sinh(SB)
-
-TEXT ·Tan(SB), NOSPLIT, $0
-	JMP ·tan(SB)
-
-TEXT ·Tanh(SB), NOSPLIT, $0
-	JMP ·tanh(SB)
diff --git a/src/math/stubs_amd64.s b/src/math/stubs_amd64.s
deleted file mode 100644
index 31e01fd266..0000000000
--- a/src/math/stubs_amd64.s
+++ /dev/null
@@ -1,86 +0,0 @@
-// Copyright 2019 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.
-
-#include "textflag.h"
-
-TEXT ·Acos(SB), NOSPLIT, $0
-	JMP ·acos(SB)
-
-TEXT ·Acosh(SB), NOSPLIT, $0
-	JMP ·acosh(SB)
-
-TEXT ·Asin(SB), NOSPLIT, $0
-	JMP ·asin(SB)
-
-TEXT ·Asinh(SB), NOSPLIT, $0
-	JMP ·asinh(SB)
-
-TEXT ·Atan(SB), NOSPLIT, $0
-	JMP ·atan(SB)
-
-TEXT ·Atan2(SB), NOSPLIT, $0
-	JMP ·atan2(SB)
-
-TEXT ·Atanh(SB), NOSPLIT, $0
-	JMP ·atanh(SB)
-
-TEXT ·Cbrt(SB), NOSPLIT, $0
-	JMP ·cbrt(SB)
-
-TEXT ·Cos(SB), NOSPLIT, $0
-	JMP ·cos(SB)
-
-TEXT ·Cosh(SB), NOSPLIT, $0
-	JMP ·cosh(SB)
-
-TEXT ·Erf(SB), NOSPLIT, $0
-	JMP ·erf(SB)
-
-TEXT ·Erfc(SB), NOSPLIT, $0
-	JMP ·erfc(SB)
-
-TEXT ·Exp2(SB), NOSPLIT, $0
-	JMP ·exp2(SB)
-
-TEXT ·Expm1(SB), NOSPLIT, $0
-	JMP ·expm1(SB)
-
-TEXT ·Frexp(SB), NOSPLIT, $0
-	JMP ·frexp(SB)
-
-TEXT ·Ldexp(SB), NOSPLIT, $0
-	JMP ·ldexp(SB)
-
-TEXT ·Log10(SB), NOSPLIT, $0
-	JMP ·log10(SB)
-
-TEXT ·Log2(SB), NOSPLIT, $0
-	JMP ·log2(SB)
-
-TEXT ·Log1p(SB), NOSPLIT, $0
-	JMP ·log1p(SB)
-
-TEXT ·Mod(SB), NOSPLIT, $0
-	JMP ·mod(SB)
-
-TEXT ·Modf(SB), NOSPLIT, $0
-	JMP ·modf(SB)
-
-TEXT ·Pow(SB), NOSPLIT, $0
-	JMP ·pow(SB)
-
-TEXT ·Remainder(SB), NOSPLIT, $0
-	JMP ·remainder(SB)
-
-TEXT ·Sin(SB), NOSPLIT, $0
-	JMP ·sin(SB)
-
-TEXT ·Sinh(SB), NOSPLIT, $0
-	JMP ·sinh(SB)
-
-TEXT ·Tan(SB), NOSPLIT, $0
-	JMP ·tan(SB)
-
-TEXT ·Tanh(SB), NOSPLIT, $0
-	JMP ·tanh(SB)
diff --git a/src/math/stubs_arm.s b/src/math/stubs_arm.s
deleted file mode 100644
index 31bf872e43..0000000000
--- a/src/math/stubs_arm.s
+++ /dev/null
@@ -1,110 +0,0 @@
-// Copyright 2019 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.
-
-#include "textflag.h"
-
-TEXT ·Acos(SB), NOSPLIT, $0
-	B ·acos(SB)
-
-TEXT ·Acosh(SB), NOSPLIT, $0
-	B ·acosh(SB)
-
-TEXT ·Asin(SB), NOSPLIT, $0
-	B ·asin(SB)
-
-TEXT ·Asinh(SB), NOSPLIT, $0
-	B ·asinh(SB)
-
-TEXT ·Atan(SB), NOSPLIT, $0
-	B ·atan(SB)
-
-TEXT ·Atan2(SB), NOSPLIT, $0
-	B ·atan2(SB)
-
-TEXT ·Atanh(SB), NOSPLIT, $0
-	B ·atanh(SB)
-
-TEXT ·Cbrt(SB), NOSPLIT, $0
-	B ·cbrt(SB)
-
-TEXT ·Cos(SB), NOSPLIT, $0
-	B ·cos(SB)
-
-TEXT ·Cosh(SB), NOSPLIT, $0
-	B ·cosh(SB)
-
-TEXT ·Erf(SB), NOSPLIT, $0
-	B ·erf(SB)
-
-TEXT ·Erfc(SB), NOSPLIT, $0
-	B ·erfc(SB)
-
-TEXT ·Exp2(SB), NOSPLIT, $0
-	B ·exp2(SB)
-
-TEXT ·Exp(SB), NOSPLIT, $0
-	B ·exp(SB)
-
-TEXT ·Expm1(SB), NOSPLIT, $0
-	B ·expm1(SB)
-
-TEXT ·Floor(SB), NOSPLIT, $0
-	B ·floor(SB)
-
-TEXT ·Ceil(SB), NOSPLIT, $0
-	B ·ceil(SB)
-
-TEXT ·Trunc(SB), NOSPLIT, $0
-	B ·trunc(SB)
-
-TEXT ·Frexp(SB), NOSPLIT, $0
-	B ·frexp(SB)
-
-TEXT ·Hypot(SB), NOSPLIT, $0
-	B ·hypot(SB)
-
-TEXT ·Ldexp(SB), NOSPLIT, $0
-	B ·ldexp(SB)
-
-TEXT ·Log10(SB), NOSPLIT, $0
-	B ·log10(SB)
-
-TEXT ·Log2(SB), NOSPLIT, $0
-	B ·log2(SB)
-
-TEXT ·Log1p(SB), NOSPLIT, $0
-	B ·log1p(SB)
-
-TEXT ·Log(SB), NOSPLIT, $0
-	B ·log(SB)
-
-TEXT ·Max(SB), NOSPLIT, $0
-	B ·max(SB)
-
-TEXT ·Min(SB), NOSPLIT, $0
-	B ·min(SB)
-
-TEXT ·Mod(SB), NOSPLIT, $0
-	B ·mod(SB)
-
-TEXT ·Modf(SB), NOSPLIT, $0
-	B ·modf(SB)
-
-TEXT ·Pow(SB), NOSPLIT, $0
-	JMP ·pow(SB)
-
-TEXT ·Remainder(SB), NOSPLIT, $0
-	B ·remainder(SB)
-
-TEXT ·Sin(SB), NOSPLIT, $0
-	B ·sin(SB)
-
-TEXT ·Sinh(SB), NOSPLIT, $0
-	B ·sinh(SB)
-
-TEXT ·Tan(SB), NOSPLIT, $0
-	B ·tan(SB)
-
-TEXT ·Tanh(SB), NOSPLIT, $0
-	B ·tanh(SB)
diff --git a/src/math/stubs_arm64.s b/src/math/stubs_arm64.s
deleted file mode 100644
index 24564d0c8e..0000000000
--- a/src/math/stubs_arm64.s
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright 2014 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.
-
-// +build arm64
-
-#include "textflag.h"
-
-TEXT ·Asin(SB), NOSPLIT, $0
-	B ·asin(SB)
-
-TEXT ·Acos(SB), NOSPLIT, $0
-	B ·acos(SB)
-
-TEXT ·Asinh(SB), NOSPLIT, $0
-	B ·asinh(SB)
-
-TEXT ·Acosh(SB), NOSPLIT, $0
-	B ·acosh(SB)
-
-TEXT ·Atan2(SB), NOSPLIT, $0
-	B ·atan2(SB)
-
-TEXT ·Atan(SB), NOSPLIT, $0
-	B ·atan(SB)
-
-TEXT ·Atanh(SB), NOSPLIT, $0
-	B ·atanh(SB)
-
-TEXT ·Erf(SB), NOSPLIT, $0
-	B ·erf(SB)
-
-TEXT ·Erfc(SB), NOSPLIT, $0
-	B ·erfc(SB)
-
-TEXT ·Cbrt(SB), NOSPLIT, $0
-	B ·cbrt(SB)
-
-TEXT ·Cosh(SB), NOSPLIT, $0
-	B ·cosh(SB)
-
-TEXT ·Expm1(SB), NOSPLIT, $0
-	B ·expm1(SB)
-
-TEXT ·Frexp(SB), NOSPLIT, $0
-	B ·frexp(SB)
-
-TEXT ·Hypot(SB), NOSPLIT, $0
-	B ·hypot(SB)
-
-TEXT ·Ldexp(SB), NOSPLIT, $0
-	B ·ldexp(SB)
-
-TEXT ·Log10(SB), NOSPLIT, $0
-	B ·log10(SB)
-
-TEXT ·Log2(SB), NOSPLIT, $0
-	B ·log2(SB)
-
-TEXT ·Log1p(SB), NOSPLIT, $0
-	B ·log1p(SB)
-
-TEXT ·Log(SB), NOSPLIT, $0
-	B ·log(SB)
-
-TEXT ·Mod(SB), NOSPLIT, $0
-	B ·mod(SB)
-
-TEXT ·Remainder(SB), NOSPLIT, $0
-	B ·remainder(SB)
-
-TEXT ·Sin(SB), NOSPLIT, $0
-	B ·sin(SB)
-
-TEXT ·Sinh(SB), NOSPLIT, $0
-	B ·sinh(SB)
-
-TEXT ·Cos(SB), NOSPLIT, $0
-	B ·cos(SB)
-
-TEXT ·Tan(SB), NOSPLIT, $0
-	B ·tan(SB)
-
-TEXT ·Tanh(SB), NOSPLIT, $0
-	B ·tanh(SB)
-
-TEXT ·Pow(SB), NOSPLIT, $0
-	B ·pow(SB)
diff --git a/src/math/stubs_mips64x.s b/src/math/stubs_mips64x.s
deleted file mode 100644
index 187b0699f6..0000000000
--- a/src/math/stubs_mips64x.s
+++ /dev/null
@@ -1,115 +0,0 @@
-// Copyright 2014 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.
-
-// +build mips64 mips64le
-
-#include "textflag.h"
-
-TEXT ·Asin(SB), NOSPLIT, $0
-	JMP ·asin(SB)
-
-TEXT ·Acos(SB), NOSPLIT, $0
-	JMP ·acos(SB)
-
-TEXT ·Asinh(SB), NOSPLIT, $0
-	JMP ·asinh(SB)
-
-TEXT ·Acosh(SB), NOSPLIT, $0
-	JMP ·acosh(SB)
-
-TEXT ·Atan2(SB), NOSPLIT, $0
-	JMP ·atan2(SB)
-
-TEXT ·Atan(SB), NOSPLIT, $0
-	JMP ·atan(SB)
-
-TEXT ·Atanh(SB), NOSPLIT, $0
-	JMP ·atanh(SB)
-
-TEXT ·Min(SB), NOSPLIT, $0
-	JMP ·min(SB)
-
-TEXT ·Max(SB), NOSPLIT, $0
-	JMP ·max(SB)
-
-TEXT ·Erf(SB), NOSPLIT, $0
-	JMP ·erf(SB)
-
-TEXT ·Erfc(SB), NOSPLIT, $0
-	JMP ·erfc(SB)
-
-TEXT ·Exp2(SB), NOSPLIT, $0
-	JMP ·exp2(SB)
-
-TEXT ·Expm1(SB), NOSPLIT, $0
-	JMP ·expm1(SB)
-
-TEXT ·Exp(SB), NOSPLIT, $0
-	JMP ·exp(SB)
-
-TEXT ·Floor(SB), NOSPLIT, $0
-	JMP ·floor(SB)
-
-TEXT ·Ceil(SB), NOSPLIT, $0
-	JMP ·ceil(SB)
-
-TEXT ·Trunc(SB), NOSPLIT, $0
-	JMP ·trunc(SB)
-
-TEXT ·Frexp(SB), NOSPLIT, $0
-	JMP ·frexp(SB)
-
-TEXT ·Hypot(SB), NOSPLIT, $0
-	JMP ·hypot(SB)
-
-TEXT ·Ldexp(SB), NOSPLIT, $0
-	JMP ·ldexp(SB)
-
-TEXT ·Log10(SB), NOSPLIT, $0
-	JMP ·log10(SB)
-
-TEXT ·Log2(SB), NOSPLIT, $0
-	JMP ·log2(SB)
-
-TEXT ·Log1p(SB), NOSPLIT, $0
-	JMP ·log1p(SB)
-
-TEXT ·Log(SB), NOSPLIT, $0
-	JMP ·log(SB)
-
-TEXT ·Modf(SB), NOSPLIT, $0
-	JMP ·modf(SB)
-
-TEXT ·Mod(SB), NOSPLIT, $0
-	JMP ·mod(SB)
-
-TEXT ·Remainder(SB), NOSPLIT, $0
-	JMP ·remainder(SB)
-
-TEXT ·Sin(SB), NOSPLIT, $0
-	JMP ·sin(SB)
-
-TEXT ·Sinh(SB), NOSPLIT, $0
-	JMP ·sinh(SB)
-
-TEXT ·Cos(SB), NOSPLIT, $0
-	JMP ·cos(SB)
-
-TEXT ·Cosh(SB), NOSPLIT, $0
-	JMP ·cosh(SB)
-
-TEXT ·Sqrt(SB), NOSPLIT, $0
-	JMP ·sqrt(SB)
-
-TEXT ·Tan(SB), NOSPLIT, $0
-	JMP ·tan(SB)
-
-TEXT ·Tanh(SB), NOSPLIT, $0
-	JMP ·tanh(SB)
-
-TEXT ·Cbrt(SB), NOSPLIT, $0
-	JMP ·cbrt(SB)
-
-TEXT ·Pow(SB), NOSPLIT, $0
-	JMP ·pow(SB)
diff --git a/src/math/stubs_mipsx.s b/src/math/stubs_mipsx.s
deleted file mode 100644
index 4b82449b14..0000000000
--- a/src/math/stubs_mipsx.s
+++ /dev/null
@@ -1,113 +0,0 @@
-// Copyright 2016 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.
-
-// +build mips mipsle
-
-#include "textflag.h"
-
-TEXT ·Asin(SB), NOSPLIT, $0
-	JMP ·asin(SB)
-
-TEXT ·Acos(SB), NOSPLIT, $0
-	JMP ·acos(SB)
-
-TEXT ·Asinh(SB), NOSPLIT, $0
-	JMP ·asinh(SB)
-
-TEXT ·Acosh(SB), NOSPLIT, $0
-	JMP ·acosh(SB)
-
-TEXT ·Atan2(SB), NOSPLIT, $0
-	JMP ·atan2(SB)
-
-TEXT ·Atan(SB), NOSPLIT, $0
-	JMP ·atan(SB)
-
-TEXT ·Atanh(SB), NOSPLIT, $0
-	JMP ·atanh(SB)
-
-TEXT ·Min(SB), NOSPLIT, $0
-	JMP ·min(SB)
-
-TEXT ·Max(SB), NOSPLIT, $0
-	JMP ·max(SB)
-
-TEXT ·Erf(SB), NOSPLIT, $0
-	JMP ·erf(SB)
-
-TEXT ·Erfc(SB), NOSPLIT, $0
-	JMP ·erfc(SB)
-
-TEXT ·Exp2(SB), NOSPLIT, $0
-	JMP ·exp2(SB)
-
-TEXT ·Expm1(SB), NOSPLIT, $0
-	JMP ·expm1(SB)
-
-TEXT ·Exp(SB), NOSPLIT, $0
-	JMP ·exp(SB)
-
-TEXT ·Floor(SB), NOSPLIT, $0
-	JMP ·floor(SB)
-
-TEXT ·Ceil(SB), NOSPLIT, $0
-	JMP ·ceil(SB)
-
-TEXT ·Trunc(SB), NOSPLIT, $0
-	JMP ·trunc(SB)
-
-TEXT ·Frexp(SB), NOSPLIT, $0
-	JMP ·frexp(SB)
-
-TEXT ·Hypot(SB), NOSPLIT, $0
-	JMP ·hypot(SB)
-
-TEXT ·Ldexp(SB), NOSPLIT, $0
-	JMP ·ldexp(SB)
-
-TEXT ·Log10(SB), NOSPLIT, $0
-	JMP ·log10(SB)
-
-TEXT ·Log2(SB), NOSPLIT, $0
-	JMP ·log2(SB)
-
-TEXT ·Log1p(SB), NOSPLIT, $0
-	JMP ·log1p(SB)
-
-TEXT ·Log(SB), NOSPLIT, $0
-	JMP ·log(SB)
-
-TEXT ·Modf(SB), NOSPLIT, $0
-	JMP ·modf(SB)
-
-TEXT ·Mod(SB), NOSPLIT, $0
-	JMP ·mod(SB)
-
-TEXT ·Remainder(SB), NOSPLIT, $0
-	JMP ·remainder(SB)
-
-TEXT ·Sin(SB), NOSPLIT, $0
-	JMP ·sin(SB)
-
-TEXT ·Sinh(SB), NOSPLIT, $0
-	JMP ·sinh(SB)
-
-TEXT ·Cos(SB), NOSPLIT, $0
-	JMP ·cos(SB)
-
-TEXT ·Cosh(SB), NOSPLIT, $0
-	JMP ·cosh(SB)
-
-TEXT ·Tan(SB), NOSPLIT, $0
-	JMP ·tan(SB)
-
-TEXT ·Tanh(SB), NOSPLIT, $0
-	JMP ·tanh(SB)
-
-TEXT ·Cbrt(SB), NOSPLIT, $0
-	JMP ·cbrt(SB)
-
-TEXT ·Pow(SB), NOSPLIT, $0
-	JMP ·pow(SB)
-
diff --git a/src/math/stubs_ppc64x.s b/src/math/stubs_ppc64x.s
deleted file mode 100644
index e7be07e8e3..0000000000
--- a/src/math/stubs_ppc64x.s
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright 2014 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.
-
-// +build ppc64 ppc64le
-
-#include "textflag.h"
-
-TEXT ·Asin(SB), NOSPLIT, $0
-	BR ·asin(SB)
-
-TEXT ·Acos(SB), NOSPLIT, $0
-	BR ·acos(SB)
-
-TEXT ·Asinh(SB), NOSPLIT, $0
-	BR ·asinh(SB)
-
-TEXT ·Acosh(SB), NOSPLIT, $0
-	BR ·acosh(SB)
-
-TEXT ·Atan2(SB), NOSPLIT, $0
-	BR ·atan2(SB)
-
-TEXT ·Atan(SB), NOSPLIT, $0
-	BR ·atan(SB)
-
-TEXT ·Atanh(SB), NOSPLIT, $0
-	BR ·atanh(SB)
-
-TEXT ·Min(SB), NOSPLIT, $0
-	BR ·min(SB)
-
-TEXT ·Max(SB), NOSPLIT, $0
-	BR ·max(SB)
-
-TEXT ·Erf(SB), NOSPLIT, $0
-	BR ·erf(SB)
-
-TEXT ·Erfc(SB), NOSPLIT, $0
-	BR ·erfc(SB)
-
-TEXT ·Exp2(SB), NOSPLIT, $0
-	BR ·exp2(SB)
-
-TEXT ·Expm1(SB), NOSPLIT, $0
-	BR ·expm1(SB)
-
-TEXT ·Exp(SB), NOSPLIT, $0
-	BR ·exp(SB)
-
-TEXT ·Frexp(SB), NOSPLIT, $0
-	BR ·frexp(SB)
-
-TEXT ·Hypot(SB), NOSPLIT, $0
-	BR ·hypot(SB)
-
-TEXT ·Ldexp(SB), NOSPLIT, $0
-	BR ·ldexp(SB)
-
-TEXT ·Log10(SB), NOSPLIT, $0
-	BR ·log10(SB)
-
-TEXT ·Log2(SB), NOSPLIT, $0
-	BR ·log2(SB)
-
-TEXT ·Log1p(SB), NOSPLIT, $0
-	BR ·log1p(SB)
-
-TEXT ·Log(SB), NOSPLIT, $0
-	BR ·log(SB)
-
-TEXT ·Mod(SB), NOSPLIT, $0
-	BR ·mod(SB)
-
-TEXT ·Remainder(SB), NOSPLIT, $0
-	BR ·remainder(SB)
-
-TEXT ·Sin(SB), NOSPLIT, $0
-	BR ·sin(SB)
-
-TEXT ·Sinh(SB), NOSPLIT, $0
-	BR ·sinh(SB)
-
-TEXT ·Cos(SB), NOSPLIT, $0
-	BR ·cos(SB)
-
-TEXT ·Cosh(SB), NOSPLIT, $0
-	BR ·cosh(SB)
-
-TEXT ·Tan(SB), NOSPLIT, $0
-	BR ·tan(SB)
-
-TEXT ·Tanh(SB), NOSPLIT, $0
-	BR ·tanh(SB)
-
-TEXT ·Cbrt(SB), NOSPLIT, $0
-	BR ·cbrt(SB)
-
-TEXT ·Pow(SB), NOSPLIT, $0
-	BR ·pow(SB)
-
diff --git a/src/math/stubs_riscv64.s b/src/math/stubs_riscv64.s
deleted file mode 100644
index b36efb8b35..0000000000
--- a/src/math/stubs_riscv64.s
+++ /dev/null
@@ -1,104 +0,0 @@
-// Copyright 2016 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.
-
-#include "textflag.h"
-
-TEXT ·Asin(SB),NOSPLIT,$0
-	JMP ·asin(SB)
-
-TEXT ·Acos(SB),NOSPLIT,$0
-	JMP ·acos(SB)
-
-TEXT ·Asinh(SB),NOSPLIT,$0
-        JMP ·asinh(SB)
-
-TEXT ·Acosh(SB),NOSPLIT,$0
-        JMP ·acosh(SB)
-
-TEXT ·Atan2(SB),NOSPLIT,$0
-	JMP ·atan2(SB)
-
-TEXT ·Atan(SB),NOSPLIT,$0
-	JMP ·atan(SB)
-
-TEXT ·Atanh(SB),NOSPLIT,$0
-	JMP ·atanh(SB)
-
-TEXT ·Erf(SB),NOSPLIT,$0
-	JMP ·erf(SB)
-
-TEXT ·Erfc(SB),NOSPLIT,$0
-	JMP ·erfc(SB)
-
-TEXT ·Exp2(SB),NOSPLIT,$0
-	JMP ·exp2(SB)
-
-TEXT ·Expm1(SB),NOSPLIT,$0
-	JMP ·expm1(SB)
-
-TEXT ·Exp(SB),NOSPLIT,$0
-	JMP ·exp(SB)
-
-TEXT ·Floor(SB),NOSPLIT,$0
-	JMP ·floor(SB)
-
-TEXT ·Ceil(SB),NOSPLIT,$0
-	JMP ·ceil(SB)
-
-TEXT ·Trunc(SB),NOSPLIT,$0
-	JMP ·trunc(SB)
-
-TEXT ·Frexp(SB),NOSPLIT,$0
-	JMP ·frexp(SB)
-
-TEXT ·Hypot(SB),NOSPLIT,$0
-	JMP ·hypot(SB)
-
-TEXT ·Ldexp(SB),NOSPLIT,$0
-	JMP ·ldexp(SB)
-
-TEXT ·Log10(SB),NOSPLIT,$0
-	JMP ·log10(SB)
-
-TEXT ·Log2(SB),NOSPLIT,$0
-	JMP ·log2(SB)
-
-TEXT ·Log1p(SB),NOSPLIT,$0
-	JMP ·log1p(SB)
-
-TEXT ·Log(SB),NOSPLIT,$0
-	JMP ·log(SB)
-
-TEXT ·Modf(SB),NOSPLIT,$0
-	JMP ·modf(SB)
-
-TEXT ·Mod(SB),NOSPLIT,$0
-	JMP ·mod(SB)
-
-TEXT ·Remainder(SB),NOSPLIT,$0
-	JMP ·remainder(SB)
-
-TEXT ·Sin(SB),NOSPLIT,$0
-	JMP ·sin(SB)
-
-TEXT ·Sinh(SB),NOSPLIT,$0
-	JMP ·sinh(SB)
-
-TEXT ·Cos(SB),NOSPLIT,$0
-	JMP ·cos(SB)
-
-TEXT ·Cosh(SB),NOSPLIT,$0
-	JMP ·cosh(SB)
-
-TEXT ·Tan(SB),NOSPLIT,$0
-	JMP ·tan(SB)
-
-TEXT ·Tanh(SB),NOSPLIT,$0
-	JMP ·tanh(SB)
-
-TEXT ·Cbrt(SB),NOSPLIT,$0
-	JMP ·cbrt(SB)
-
-TEXT ·Pow(SB),NOSPLIT,$0
-	JMP ·pow(SB)
diff --git a/src/math/stubs_s390x.s b/src/math/stubs_s390x.s
index d0087aba15..7400179195 100644
--- a/src/math/stubs_s390x.s
+++ b/src/math/stubs_s390x.s
@@ -4,31 +4,7 @@
 
 #include "textflag.h"
 
-TEXT ·Exp2(SB), NOSPLIT, $0
-	BR ·exp2(SB)
-
-TEXT ·Frexp(SB), NOSPLIT, $0
-	BR ·frexp(SB)
-
-TEXT ·Hypot(SB), NOSPLIT, $0
-	BR ·hypot(SB)
-
-TEXT ·Ldexp(SB), NOSPLIT, $0
-	BR ·ldexp(SB)
-
-TEXT ·Log2(SB), NOSPLIT, $0
-	BR ·log2(SB)
-
-TEXT ·Modf(SB), NOSPLIT, $0
-	BR ·modf(SB)
-
-TEXT ·Mod(SB), NOSPLIT, $0
-	BR ·mod(SB)
-
-TEXT ·Remainder(SB), NOSPLIT, $0
-	BR ·remainder(SB)
-
-TEXT ·Log10(SB), NOSPLIT, $0
+TEXT ·archLog10(SB), NOSPLIT, $0
 	MOVD ·log10vectorfacility+0x00(SB), R1
 	BR   (R1)
 
@@ -49,7 +25,7 @@ vectorimpl:
 GLOBL ·log10vectorfacility+0x00(SB), NOPTR, $8
 DATA ·log10vectorfacility+0x00(SB)/8, $·log10TrampolineSetup(SB)
 
-TEXT ·Cos(SB), NOSPLIT, $0
+TEXT ·archCos(SB), NOSPLIT, $0
 	MOVD ·cosvectorfacility+0x00(SB), R1
 	BR   (R1)
 
@@ -70,7 +46,7 @@ vectorimpl:
 GLOBL ·cosvectorfacility+0x00(SB), NOPTR, $8
 DATA ·cosvectorfacility+0x00(SB)/8, $·cosTrampolineSetup(SB)
 
-TEXT ·Cosh(SB), NOSPLIT, $0
+TEXT ·archCosh(SB), NOSPLIT, $0
 	MOVD ·coshvectorfacility+0x00(SB), R1
 	BR   (R1)
 
@@ -91,7 +67,7 @@ vectorimpl:
 GLOBL ·coshvectorfacility+0x00(SB), NOPTR, $8
 DATA ·coshvectorfacility+0x00(SB)/8, $·coshTrampolineSetup(SB)
 
-TEXT ·Sin(SB), NOSPLIT, $0
+TEXT ·archSin(SB), NOSPLIT, $0
 	MOVD ·sinvectorfacility+0x00(SB), R1
 	BR   (R1)
 
@@ -112,7 +88,7 @@ vectorimpl:
 GLOBL ·sinvectorfacility+0x00(SB), NOPTR, $8
 DATA ·sinvectorfacility+0x00(SB)/8, $·sinTrampolineSetup(SB)
 
-TEXT ·Sinh(SB), NOSPLIT, $0
+TEXT ·archSinh(SB), NOSPLIT, $0
 	MOVD ·sinhvectorfacility+0x00(SB), R1
 	BR   (R1)
 
@@ -133,7 +109,7 @@ vectorimpl:
 GLOBL ·sinhvectorfacility+0x00(SB), NOPTR, $8
 DATA ·sinhvectorfacility+0x00(SB)/8, $·sinhTrampolineSetup(SB)
 
-TEXT ·Tanh(SB), NOSPLIT, $0
+TEXT ·archTanh(SB), NOSPLIT, $0
 	MOVD ·tanhvectorfacility+0x00(SB), R1
 	BR   (R1)
 
@@ -154,7 +130,7 @@ vectorimpl:
 GLOBL ·tanhvectorfacility+0x00(SB), NOPTR, $8
 DATA ·tanhvectorfacility+0x00(SB)/8, $·tanhTrampolineSetup(SB)
 
-TEXT ·Log1p(SB), NOSPLIT, $0
+TEXT ·archLog1p(SB), NOSPLIT, $0
 	MOVD ·log1pvectorfacility+0x00(SB), R1
 	BR   (R1)
 
@@ -175,7 +151,7 @@ vectorimpl:
 GLOBL ·log1pvectorfacility+0x00(SB), NOPTR, $8
 DATA ·log1pvectorfacility+0x00(SB)/8, $·log1pTrampolineSetup(SB)
 
-TEXT ·Atanh(SB), NOSPLIT, $0
+TEXT ·archAtanh(SB), NOSPLIT, $0
 	MOVD ·atanhvectorfacility+0x00(SB), R1
 	BR   (R1)
 
@@ -196,7 +172,7 @@ vectorimpl:
 GLOBL ·atanhvectorfacility+0x00(SB), NOPTR, $8
 DATA ·atanhvectorfacility+0x00(SB)/8, $·atanhTrampolineSetup(SB)
 
-TEXT ·Acos(SB), NOSPLIT, $0
+TEXT ·archAcos(SB), NOSPLIT, $0
 	MOVD ·acosvectorfacility+0x00(SB), R1
 	BR   (R1)
 
@@ -217,7 +193,7 @@ vectorimpl:
 GLOBL ·acosvectorfacility+0x00(SB), NOPTR, $8
 DATA ·acosvectorfacility+0x00(SB)/8, $·acosTrampolineSetup(SB)
 
-TEXT ·Asin(SB), NOSPLIT, $0
+TEXT ·archAsin(SB), NOSPLIT, $0
 	MOVD ·asinvectorfacility+0x00(SB), R1
 	BR   (R1)
 
@@ -238,7 +214,7 @@ vectorimpl:
 GLOBL ·asinvectorfacility+0x00(SB), NOPTR, $8
 DATA ·asinvectorfacility+0x00(SB)/8, $·asinTrampolineSetup(SB)
 
-TEXT ·Asinh(SB), NOSPLIT, $0
+TEXT ·archAsinh(SB), NOSPLIT, $0
 	MOVD ·asinhvectorfacility+0x00(SB), R1
 	BR   (R1)
 
@@ -259,7 +235,7 @@ vectorimpl:
 GLOBL ·asinhvectorfacility+0x00(SB), NOPTR, $8
 DATA ·asinhvectorfacility+0x00(SB)/8, $·asinhTrampolineSetup(SB)
 
-TEXT ·Acosh(SB), NOSPLIT, $0
+TEXT ·archAcosh(SB), NOSPLIT, $0
 	MOVD ·acoshvectorfacility+0x00(SB), R1
 	BR   (R1)
 
@@ -280,7 +256,7 @@ vectorimpl:
 GLOBL ·acoshvectorfacility+0x00(SB), NOPTR, $8
 DATA ·acoshvectorfacility+0x00(SB)/8, $·acoshTrampolineSetup(SB)
 
-TEXT ·Erf(SB), NOSPLIT, $0
+TEXT ·archErf(SB), NOSPLIT, $0
 	MOVD ·erfvectorfacility+0x00(SB), R1
 	BR   (R1)
 
@@ -301,7 +277,7 @@ vectorimpl:
 GLOBL ·erfvectorfacility+0x00(SB), NOPTR, $8
 DATA ·erfvectorfacility+0x00(SB)/8, $·erfTrampolineSetup(SB)
 
-TEXT ·Erfc(SB), NOSPLIT, $0
+TEXT ·archErfc(SB), NOSPLIT, $0
 	MOVD ·erfcvectorfacility+0x00(SB), R1
 	BR   (R1)
 
@@ -322,7 +298,7 @@ vectorimpl:
 GLOBL ·erfcvectorfacility+0x00(SB), NOPTR, $8
 DATA ·erfcvectorfacility+0x00(SB)/8, $·erfcTrampolineSetup(SB)
 
-TEXT ·Atan(SB), NOSPLIT, $0
+TEXT ·archAtan(SB), NOSPLIT, $0
 	MOVD ·atanvectorfacility+0x00(SB), R1
 	BR   (R1)
 
@@ -343,7 +319,7 @@ vectorimpl:
 GLOBL ·atanvectorfacility+0x00(SB), NOPTR, $8
 DATA ·atanvectorfacility+0x00(SB)/8, $·atanTrampolineSetup(SB)
 
-TEXT ·Atan2(SB), NOSPLIT, $0
+TEXT ·archAtan2(SB), NOSPLIT, $0
 	MOVD ·atan2vectorfacility+0x00(SB), R1
 	BR   (R1)
 
@@ -364,7 +340,7 @@ vectorimpl:
 GLOBL ·atan2vectorfacility+0x00(SB), NOPTR, $8
 DATA ·atan2vectorfacility+0x00(SB)/8, $·atan2TrampolineSetup(SB)
 
-TEXT ·Cbrt(SB), NOSPLIT, $0
+TEXT ·archCbrt(SB), NOSPLIT, $0
 	MOVD ·cbrtvectorfacility+0x00(SB), R1
 	BR   (R1)
 
@@ -385,7 +361,7 @@ vectorimpl:
 GLOBL ·cbrtvectorfacility+0x00(SB), NOPTR, $8
 DATA ·cbrtvectorfacility+0x00(SB)/8, $·cbrtTrampolineSetup(SB)
 
-TEXT ·Log(SB), NOSPLIT, $0
+TEXT ·archLog(SB), NOSPLIT, $0
 	MOVD ·logvectorfacility+0x00(SB), R1
 	BR   (R1)
 
@@ -406,7 +382,7 @@ vectorimpl:
 GLOBL ·logvectorfacility+0x00(SB), NOPTR, $8
 DATA ·logvectorfacility+0x00(SB)/8, $·logTrampolineSetup(SB)
 
-TEXT ·Tan(SB), NOSPLIT, $0
+TEXT ·archTan(SB), NOSPLIT, $0
 	MOVD ·tanvectorfacility+0x00(SB), R1
 	BR   (R1)
 
@@ -427,7 +403,7 @@ vectorimpl:
 GLOBL ·tanvectorfacility+0x00(SB), NOPTR, $8
 DATA ·tanvectorfacility+0x00(SB)/8, $·tanTrampolineSetup(SB)
 
-TEXT ·Exp(SB), NOSPLIT, $0
+TEXT ·archExp(SB), NOSPLIT, $0
 	MOVD ·expvectorfacility+0x00(SB), R1
 	BR   (R1)
 
@@ -448,7 +424,7 @@ vectorimpl:
 GLOBL ·expvectorfacility+0x00(SB), NOPTR, $8
 DATA ·expvectorfacility+0x00(SB)/8, $·expTrampolineSetup(SB)
 
-TEXT ·Expm1(SB), NOSPLIT, $0
+TEXT ·archExpm1(SB), NOSPLIT, $0
 	MOVD ·expm1vectorfacility+0x00(SB), R1
 	BR   (R1)
 
@@ -469,7 +445,7 @@ vectorimpl:
 GLOBL ·expm1vectorfacility+0x00(SB), NOPTR, $8
 DATA ·expm1vectorfacility+0x00(SB)/8, $·expm1TrampolineSetup(SB)
 
-TEXT ·Pow(SB), NOSPLIT, $0
+TEXT ·archPow(SB), NOSPLIT, $0
 	MOVD ·powvectorfacility+0x00(SB), R1
 	BR   (R1)
 
diff --git a/src/math/stubs_wasm.s b/src/math/stubs_wasm.s
deleted file mode 100644
index c97a2d7dd5..0000000000
--- a/src/math/stubs_wasm.s
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright 2018 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.
-
-#include "textflag.h"
-
-TEXT ·Asin(SB), NOSPLIT, $0
-	JMP ·asin(SB)
-
-TEXT ·Asinh(SB), NOSPLIT, $0
-	JMP ·asinh(SB)
-
-TEXT ·Acos(SB), NOSPLIT, $0
-	JMP ·acos(SB)
-
-TEXT ·Acosh(SB), NOSPLIT, $0
-	JMP ·acosh(SB)
-
-TEXT ·Atan(SB), NOSPLIT, $0
-	JMP ·atan(SB)
-
-TEXT ·Atanh(SB), NOSPLIT, $0
-	JMP ·atanh(SB)
-
-TEXT ·Atan2(SB), NOSPLIT, $0
-	JMP ·atan2(SB)
-
-TEXT ·Cbrt(SB), NOSPLIT, $0
-	JMP ·cbrt(SB)
-
-TEXT ·Cos(SB), NOSPLIT, $0
-	JMP ·cos(SB)
-
-TEXT ·Cosh(SB), NOSPLIT, $0
-	JMP ·cosh(SB)
-
-TEXT ·Erf(SB), NOSPLIT, $0
-	JMP ·erf(SB)
-
-TEXT ·Erfc(SB), NOSPLIT, $0
-	JMP ·erfc(SB)
-
-TEXT ·Exp(SB), NOSPLIT, $0
-	JMP ·exp(SB)
-
-TEXT ·Expm1(SB), NOSPLIT, $0
-	JMP ·expm1(SB)
-
-TEXT ·Exp2(SB), NOSPLIT, $0
-	JMP ·exp2(SB)
-
-TEXT ·Frexp(SB), NOSPLIT, $0
-	JMP ·frexp(SB)
-
-TEXT ·Hypot(SB), NOSPLIT, $0
-	JMP ·hypot(SB)
-
-TEXT ·Ldexp(SB), NOSPLIT, $0
-	JMP ·ldexp(SB)
-
-TEXT ·Log(SB), NOSPLIT, $0
-	JMP ·log(SB)
-
-TEXT ·Log1p(SB), NOSPLIT, $0
-	JMP ·log1p(SB)
-
-TEXT ·Log10(SB), NOSPLIT, $0
-	JMP ·log10(SB)
-
-TEXT ·Log2(SB), NOSPLIT, $0
-	JMP ·log2(SB)
-
-TEXT ·Max(SB), NOSPLIT, $0
-	JMP ·max(SB)
-
-TEXT ·Min(SB), NOSPLIT, $0
-	JMP ·min(SB)
-
-TEXT ·Mod(SB), NOSPLIT, $0
-	JMP ·mod(SB)
-
-TEXT ·Modf(SB), NOSPLIT, $0
-	JMP ·modf(SB)
-
-TEXT ·Pow(SB), NOSPLIT, $0
-	JMP ·pow(SB)
-
-TEXT ·Remainder(SB), NOSPLIT, $0
-	JMP ·remainder(SB)
-
-TEXT ·Sin(SB), NOSPLIT, $0
-	JMP ·sin(SB)
-
-TEXT ·Sinh(SB), NOSPLIT, $0
-	JMP ·sinh(SB)
-
-TEXT ·Tan(SB), NOSPLIT, $0
-	JMP ·tan(SB)
-
-TEXT ·Tanh(SB), NOSPLIT, $0
-	JMP ·tanh(SB)
diff --git a/src/math/tan.go b/src/math/tan.go
index 49b1239208..a25417f527 100644
--- a/src/math/tan.go
+++ b/src/math/tan.go
@@ -79,7 +79,12 @@ var _tanQ = [...]float64{
 //	Tan(±0) = ±0
 //	Tan(±Inf) = NaN
 //	Tan(NaN) = NaN
-func Tan(x float64) float64
+func Tan(x float64) float64 {
+	if haveArchTan {
+		return archTan(x)
+	}
+	return tan(x)
+}
 
 func tan(x float64) float64 {
 	const (
diff --git a/src/math/tanh.go b/src/math/tanh.go
index 0b7fb7f854..a825678424 100644
--- a/src/math/tanh.go
+++ b/src/math/tanh.go
@@ -71,7 +71,12 @@ var tanhQ = [...]float64{
 //	Tanh(±0) = ±0
 //	Tanh(±Inf) = ±1
 //	Tanh(NaN) = NaN
-func Tanh(x float64) float64
+func Tanh(x float64) float64 {
+	if haveArchTanh {
+		return archTanh(x)
+	}
+	return tanh(x)
+}
 
 func tanh(x float64) float64 {
 	const MAXLOG = 8.8029691931113054295988e+01 // log(2**127)
-- 
GitLab


From 5631c4b3bfd71aae7cbdd7f35f63de7f89639d1e Mon Sep 17 00:00:00 2001
From: Michael Fraenkel <michael.fraenkel@gmail.com>
Date: Wed, 14 Apr 2021 18:35:49 -0600
Subject: [PATCH 1589/2400] net/http: allow multiple dials in
 TestTransportMaxConnsPerHost

If there is more than the expected single dial, the channel will block.
Allow at least one connection per client, and do the expected cleanup.

Updates #45570

Change-Id: Iaecd45298a7d7c591b7d7b1be13cea6e4a1e2e85
Reviewed-on: https://go-review.googlesource.com/c/go/+/310213
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Damien Neil <dneil@google.com>
Trust: Damien Neil <dneil@google.com>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/net/http/transport_test.go | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/net/http/transport_test.go b/src/net/http/transport_test.go
index 7f6e0938c2..5b6a5aa992 100644
--- a/src/net/http/transport_test.go
+++ b/src/net/http/transport_test.go
@@ -626,12 +626,15 @@ func TestTransportMaxConnsPerHost(t *testing.T) {
 			t.Fatalf("ExportHttp2ConfigureTransport: %v", err)
 		}
 
-		connCh := make(chan net.Conn, 1)
+		mu := sync.Mutex{}
+		var conns []net.Conn
 		var dialCnt, gotConnCnt, tlsHandshakeCnt int32
 		tr.Dial = func(network, addr string) (net.Conn, error) {
 			atomic.AddInt32(&dialCnt, 1)
 			c, err := net.Dial(network, addr)
-			connCh <- c
+			mu.Lock()
+			defer mu.Unlock()
+			conns = append(conns, c)
 			return c, err
 		}
 
@@ -685,7 +688,12 @@ func TestTransportMaxConnsPerHost(t *testing.T) {
 			t.FailNow()
 		}
 
-		(<-connCh).Close()
+		mu.Lock()
+		for _, c := range conns {
+			c.Close()
+		}
+		conns = nil
+		mu.Unlock()
 		tr.CloseIdleConnections()
 
 		doReq()
-- 
GitLab


From 8009a81f7a44235001ce373fbc39391a894c86df Mon Sep 17 00:00:00 2001
From: Lynn Boger <laboger@linux.vnet.ibm.com>
Date: Mon, 15 Mar 2021 16:36:47 -0500
Subject: [PATCH 1590/2400] bytes: add asm implementation for index on ppc64x
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This adds an asm implementation of index on ppc64le and
ppc64. It results in a significant improvement in some
of the benchmarks that use bytes.Index.

The implementation is based on a port of the s390x asm
implementation. Comments on the design are found
with the code.

The following improvements occurred on power8:

Index/10       70.7ns ± 0%    18.8ns ± 0%   -73.4
Index/32        165ns ± 0%      95ns ± 0%   -42.6
Index/4K       9.23µs ± 0%    4.91µs ± 0%   -46
Index/4M       9.52ms ± 0%    5.10ms ± 0%   -46.4
Index/64M       155ms ± 0%      85ms ± 0%   -45.1

Count/10       83.0ns ± 0%    32.1ns ± 0%   -61.3
Count/32        178ns ± 0%     109ns ± 0%   -38.8
Count/4K       9.24µs ± 0%    4.93µs ± 0%   -46
Count/4M       9.52ms ± 0%    5.10ms ± 0%   -46.4
Count/64M       155ms ± 0%      85ms ± 0%   -45.1

IndexHard1     2.36ms ± 0%    0.13ms ± 0%   -94.4
IndexHard2     2.36ms ± 0%    1.28ms ± 0%   -45.8
IndexHard3     2.36ms ± 0%    1.19ms ± 0%   -49.4
IndexHard4     2.36ms ± 0%    2.35ms ± 0%    -0.1

CountHard1     2.36ms ± 0%    0.13ms ± 0%   -94.4
CountHard2     2.36ms ± 0%    1.28ms ± 0%   -45.8
CountHard3     2.36ms ± 0%    1.19ms ± 0%   -49.4

IndexPeriodic/IndexPeriodic2  146µs ± 0%       8µs ± 0%   -94
IndexPeriodic/IndexPeriodic4  146µs ± 0%       8µs ± 0%   -94

Change-Id: I7dd2bb7e278726e27f51825ca8b2f8317d460e60
Reviewed-on: https://go-review.googlesource.com/c/go/+/309730
Run-TryBot: Lynn Boger <laboger@linux.vnet.ibm.com>
Reviewed-by: Paul Murphy <murp@ibm.com>
Reviewed-by: Carlos Eduardo Seo <carlos.seo@linaro.org>
Trust: Carlos Eduardo Seo <carlos.seo@linaro.org>
Trust: Lynn Boger <laboger@linux.vnet.ibm.com>
---
 src/internal/bytealg/index_generic.go |   5 +-
 src/internal/bytealg/index_native.go  |   5 +-
 src/internal/bytealg/index_ppc64x.go  |  24 ++
 src/internal/bytealg/index_ppc64x.s   | 422 ++++++++++++++++++++++++++
 4 files changed, 452 insertions(+), 4 deletions(-)
 create mode 100644 src/internal/bytealg/index_ppc64x.go
 create mode 100644 src/internal/bytealg/index_ppc64x.s

diff --git a/src/internal/bytealg/index_generic.go b/src/internal/bytealg/index_generic.go
index 2b8b139aeb..287bdba4c6 100644
--- a/src/internal/bytealg/index_generic.go
+++ b/src/internal/bytealg/index_generic.go
@@ -2,8 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build !amd64 && !arm64 && !s390x
-// +build !amd64,!arm64,!s390x
+// go:build !amd64 && !arm64 && !s390x && !ppc64le && !ppc64
+//go:build !amd64 && !arm64 && !s390x && !ppc64le && !ppc64
+// +build !amd64,!arm64,!s390x,!ppc64le,!ppc64
 
 package bytealg
 
diff --git a/src/internal/bytealg/index_native.go b/src/internal/bytealg/index_native.go
index af56d8a294..75aff4b3cb 100644
--- a/src/internal/bytealg/index_native.go
+++ b/src/internal/bytealg/index_native.go
@@ -2,8 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build amd64 || arm64 || s390x
-// +build amd64 arm64 s390x
+// go:build amd64 || arm64 || s390x || ppc64le || ppc64
+//go:build amd64 || arm64 || s390x || ppc64le || ppc64
+// +build amd64 arm64 s390x ppc64le ppc64
 
 package bytealg
 
diff --git a/src/internal/bytealg/index_ppc64x.go b/src/internal/bytealg/index_ppc64x.go
new file mode 100644
index 0000000000..e49872eead
--- /dev/null
+++ b/src/internal/bytealg/index_ppc64x.go
@@ -0,0 +1,24 @@
+// Copyright 2021 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.
+
+//go:build (aix || linux) && (ppc64 || ppc64le)
+// +build aix linux
+// +build ppc64 ppc64le
+
+package bytealg
+
+const MaxBruteForce = 16
+
+func init() {
+	MaxLen = 32
+}
+
+// Cutover reports the number of failures of IndexByte we should tolerate
+// before switching over to Index.
+// n is the number of bytes processed so far.
+// See the bytes.Index implementation for details.
+func Cutover(n int) int {
+	// 1 error per 8 characters, plus a few slop to start.
+	return (n + 16) / 8
+}
diff --git a/src/internal/bytealg/index_ppc64x.s b/src/internal/bytealg/index_ppc64x.s
new file mode 100644
index 0000000000..ed9f9fb3de
--- /dev/null
+++ b/src/internal/bytealg/index_ppc64x.s
@@ -0,0 +1,422 @@
+// Copyright 2021 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.
+
+// This is an implementation based on the s390x
+// implementation.
+
+// Find a separator with 2 <= len <= 32 within a string.
+// Separators with lengths of 2, 3 or 4 are handled
+// specially.
+
+// This works on power8 and above. The loads and
+// compares are done in big endian order
+// since that allows the used of VCLZD, and allows
+// the same implementation to work on big and little
+// endian platforms with minimal conditional changes.
+
+// NOTE: There is a power9 implementation that
+// improves performance by 10-15% on little
+// endian for some of the benchmarks, but
+// work is still needed for a big endian
+// implementation on power9.
+
+// +build ppc64 ppc64le
+
+#include "go_asm.h"
+#include "textflag.h"
+
+// Needed to swap LXVD2X loads to the correct
+// byte order to work on POWER8.
+
+#ifdef GOARCH_ppc64
+DATA byteswap<>+0(SB)/8, $0x0001020304050607
+DATA byteswap<>+8(SB)/8, $0x08090a0b0c0d0e0f
+#else
+DATA byteswap<>+0(SB)/8, $0x0706050403020100
+DATA byteswap<>+8(SB)/8, $0x0f0e0d0c0b0a0908
+#endif
+
+// Load bytes in big endian order. Address
+// alignment does not need checking.
+#define VLOADSWAP(base, index, vreg, vsreg) \
+	LXVD2X (base)(index), vsreg;  \
+	VPERM  vreg, vreg, SWAP, vreg
+
+GLOBL byteswap<>+0(SB), RODATA, $16
+
+TEXT ·Index(SB), NOSPLIT|NOFRAME, $0-56
+	MOVD a_base+0(FP), R3  // R3 = byte array pointer
+	MOVD a_len+8(FP), R4   // R4 = length
+	MOVD b_base+24(FP), R5 // R5 = separator pointer
+	MOVD b_len+32(FP), R6  // R6 = separator length
+	MOVD $ret+48(FP), R14  // R14 = &ret
+	BR   indexbody<>(SB)
+
+TEXT ·IndexString(SB), NOSPLIT|NOFRAME, $0-40
+	MOVD a_base+0(FP), R3  // R3 = string
+	MOVD a_len+8(FP), R4   // R4 = length
+	MOVD b_base+16(FP), R5 // R5 = separator pointer
+	MOVD b_len+24(FP), R6  // R6 = separator length
+	MOVD $ret+32(FP), R14  // R14 = &ret
+	BR   indexbody<>(SB)
+
+	// s: string we are searching
+	// sep: string to search for
+	// R3=&s[0], R4=len(s)
+	// R5=&sep[0], R6=len(sep)
+	// R14=&ret (index where sep found)
+	// R7=working addr of string
+	// R16=index value 16
+	// R17=index value 17
+	// R18=index value 18
+	// R19=index value 1
+	// R26=LASTBYTE of string
+	// R27=LASTSTR last start byte to compare with sep
+	// R8, R9 scratch
+	// V0=sep left justified zero fill
+	// CR4=sep length >= 16
+
+#define SEPMASK V17
+#define LASTBYTE R26
+#define LASTSTR R27
+#define ONES V20
+#define SWAP V21
+#define V0_ VS32
+#define V1_ VS33
+#define V2_ VS34
+#define V3_ VS35
+#define V4_ VS36
+#define V5_ VS37
+#define V6_ VS38
+#define V7_ VS39
+#define V8_ VS40
+#define V9_ VS41
+#define SWAP_ VS53
+TEXT indexbody<>(SB), NOSPLIT|NOFRAME, $0
+	CMP      R6, R4                 // Compare lengths
+	BGT      notfound               // If sep len is > string, notfound
+	ADD      R4, R3, LASTBYTE       // find last byte addr
+	SUB      R6, LASTBYTE, LASTSTR  // LAST=&s[len(s)-len(sep)] (last valid start index)
+	CMP      R6, $0                 // Check sep len
+	BEQ      notfound               // sep len 0 -- not found
+	MOVD     R3, R7                 // Copy of string addr
+	MOVD     $16, R16               // Index value 16
+	MOVD     $17, R17               // Index value 17
+	MOVD     $18, R18               // Index value 18
+	MOVD     $1, R19                // Index value 1
+	MOVD     $byteswap<>+00(SB), R8
+	VSPLTISB $0xFF, ONES            // splat all 1s
+	LXVD2X   (R8)(R0), SWAP_        // Set up swap string
+
+	CMP    R6, $16, CR4        // CR4 for len(sep) >= 16
+	VOR    ONES, ONES, SEPMASK // Set up full SEPMASK
+	BGE    CR4, loadge16       // Load for len(sep) >= 16
+	SUB    R6, R16, R9         // 16-len of sep
+	SLD    $3, R9              // Set up for VSLO
+	MTVSRD R9, V9_             // Set up for VSLO
+	VSLDOI $8, V9, V9, V9      // Set up for VSLO
+	VSLO   ONES, V9, SEPMASK   // Mask for separator len(sep) < 16
+
+loadge16:
+	ANDCC $15, R5, R9 // Find byte offset of sep
+	ADD   R9, R6, R10 // Add sep len
+	CMP   R10, $16    // Check if sep len+offset > 16
+	BGE   sepcross16  // Sep crosses 16 byte boundary
+
+	RLDICR $0, R5, $59, R8 // Adjust addr to 16 byte container
+	VLOADSWAP(R8, R0, V0, V0_)// Load 16 bytes @R8 into V0
+	SLD    $3, R9          // Set up shift count for VSLO
+	MTVSRD R9, V8_         // Set up shift count for VSLO
+	VSLDOI $8, V8, V8, V8
+	VSLO   V0, V8, V0      // Shift by start byte
+
+	VAND V0, SEPMASK, V0 // Mask separator (< 16)
+	BR   index2plus
+
+sepcross16:
+	VLOADSWAP(R5, R0, V0, V0_) // Load 16 bytes @R5 into V0
+
+	VAND V0, SEPMASK, V0 // mask out separator
+	BLE  CR4, index2to16
+	BR   index17plus     // Handle sep > 16
+
+index2plus:
+	CMP      R6, $2       // Check length of sep
+	BNE      index3plus   // If not 2, check for 3
+	ADD      $16, R7, R9  // Check if next 16 bytes past last
+	CMP      R9, LASTBYTE // compare with last
+	BGE      index2to16   // 2 <= len(string) <= 16
+	MOVD     $0xff00, R21 // Mask for later
+	MTVSRD   R21, V25     // Move to Vreg
+	VSPLTH   $3, V25, V31 // Splat mask
+	VSPLTH   $0, V0, V1   // Splat 1st 2 bytes of sep
+	VSPLTISB $0, V10      // Clear V10
+
+	// First case: 2 byte separator
+	// V1: 2 byte separator splatted
+	// V2: 16 bytes at addr
+	// V4: 16 bytes at addr+1
+	// Compare 2 byte separator at start
+	// and at start+1. Use VSEL to combine
+	// those results to find the first
+	// matching start byte, returning
+	// that value when found. Loop as
+	// long as len(string) > 16
+index2loop2:
+	VLOADSWAP(R7, R19, V3, V3_) // Load 16 bytes @R7+1 into V3
+
+index2loop:
+	VLOADSWAP(R7, R0, V2, V2_) // Load 16 bytes @R7 into V2
+	VCMPEQUH V1, V2, V5        // Search for sep
+	VCMPEQUH V1, V3, V6        // Search for sep offset by 1
+	VSEL     V6, V5, V31, V7   // merge even and odd indices
+	VCLZD    V7, V18           // find index of first match
+	MFVSRD   V18, R25          // get first value
+	CMP      R25, $64          // Found if < 64
+	BLT      foundR25          // Return byte index where found
+	VSLDOI   $8, V18, V18, V18 // Adjust 2nd value
+	MFVSRD   V18, R25          // get second value
+	CMP      R25, $64          // Found if < 64
+	ADD      $64, R25          // Update byte offset
+	BLT      foundR25          // Return value
+	ADD      $16, R7           // R7+=16 Update string pointer
+	ADD      $17, R7, R9       // R9=F7+17 since loop unrolled
+	CMP      R9, LASTBYTE      // Compare addr+17 against last byte
+	BLT      index2loop2       // If < last, continue loop
+	CMP      R7, LASTBYTE      // Compare addr+16 against last byte
+	BLT      index2to16        // If < 16 handle specially
+	VLOADSWAP(R7, R0, V3, V3_) // Load 16 bytes @R7 into V3
+	VSLDOI   $1, V3, V10, V3   // Shift left by 1 byte
+	BR       index2loop
+
+index3plus:
+	CMP    R6, $3       // Check if sep == 3
+	BNE    index4plus   // If not check larger
+	ADD    $19, R7, R9  // Find bytes for use in this loop
+	CMP    R9, LASTBYTE // Compare against last byte
+	BGE    index2to16   // Remaining string 2<=len<=16
+	MOVD   $0xff00, R21 // Set up mask for upcoming loop
+	MTVSRD R21, V25     // Move mask to Vreg
+	VSPLTH $3, V25, V31 // Splat mask
+	VSPLTH $0, V0, V1   // Splat 1st two bytes of sep
+	VSPLTB $2, V0, V8   // Splat 3rd byte of sep
+
+	// Loop to process 3 byte separator.
+	// string[0:16] is in V2
+	// string[2:18] is in V3
+	// sep[0:2] splatted in V1
+	// sec[3] splatted in v8
+	// Load vectors at string, string+1
+	// and string+2. Compare string, string+1
+	// against first 2 bytes of separator
+	// splatted, and string+2 against 3rd
+	// byte splatted. Merge the results with
+	// VSEL to find the first byte of a match.
+
+	// Special handling for last 16 bytes if the
+	// string fits in 16 byte multiple.
+index3loop2:
+	MOVD     $2, R21          // Set up index for 2
+	VSPLTISB $0, V10          // Clear V10
+	VLOADSWAP(R7, R21, V3, V3_)// Load 16 bytes @R7+2 into V3
+	VSLDOI   $14, V3, V10, V3 // Left justify next 2 bytes
+
+index3loop:
+	VLOADSWAP(R7, R0, V2, V2_) // Load with correct order
+	VSLDOI   $1, V2, V3, V4    // string[1:17]
+	VSLDOI   $2, V2, V3, V9    // string[2:18]
+	VCMPEQUH V1, V2, V5        // compare hw even indices
+	VCMPEQUH V1, V4, V6        // compare hw odd indices
+	VCMPEQUB V8, V9, V10       // compare 3rd to last byte
+	VSEL     V6, V5, V31, V7   // Find 1st matching byte using mask
+	VAND     V7, V10, V7       // AND matched bytes with matched 3rd byte
+	VCLZD    V7, V18           // Find first nonzero indexes
+	MFVSRD   V18, R25          // Move 1st doubleword
+	CMP      R25, $64          // If < 64 found
+	BLT      foundR25          // Return matching index
+	VSLDOI   $8, V18, V18, V18 // Move value
+	MFVSRD   V18, R25          // Move 2nd doubleword
+	CMP      R25, $64          // If < 64 found
+	ADD      $64, R25          // Update byte index
+	BLT      foundR25          // Return matching index
+	ADD      $16, R7           // R7+=16 string ptr
+	ADD      $19, R7, R9       // Number of string bytes for loop
+	CMP      R9, LASTBYTE      // Compare against last byte of string
+	BLT      index3loop2       // If within, continue this loop
+	CMP      R7, LASTSTR       // Compare against last start byte
+	BLT      index2to16        // Process remainder
+	VSPLTISB $0, V3            // Special case for last 16 bytes
+	BR       index3loop        // Continue this loop
+
+	// Loop to process 4 byte separator
+	// string[0:16] in V2
+	// string[3:16] in V3
+	// sep[0:4] splatted in V1
+	// Set up vectors with strings at offsets
+	// 0, 1, 2, 3 and compare against the 4 byte
+	// separator also splatted. Use VSEL with the
+	// compare results to find the first byte where
+	// a separator match is found.
+index4plus:
+	CMP  R6, $4       // Check if 4 byte separator
+	BNE  index5plus   // If not next higher
+	ADD  $20, R7, R9  // Check string size to load
+	CMP  R9, LASTBYTE // Verify string length
+	BGE  index2to16   // If not large enough, process remaining
+	MOVD $2, R15      // Set up index
+
+	// Set up masks for use with VSEL
+	MOVD   $0xff, R21        // Set up mask 0xff000000ff000000...
+	SLD    $24, R21
+	MTVSRD R21, V10
+	VSPLTW $1, V10, V29
+	VSLDOI $2, V29, V29, V30 // Mask 0x0000ff000000ff00...
+	MOVD   $0xffff, R21
+	SLD    $16, R21
+	MTVSRD R21, V10
+	VSPLTW $1, V10, V31      // Mask 0xffff0000ffff0000...
+	VSPLTW $0, V0, V1        // Splat 1st word of separator
+
+index4loop:
+	VLOADSWAP(R7, R0, V2, V2_) // Load 16 bytes @R7 into V2
+
+next4:
+	VSPLTISB $0, V10            // Clear
+	MOVD     $3, R9             // Number of bytes beyond 16
+	VLOADSWAP(R7, R9, V3, V3_)  // Load 16 bytes @R7+3 into V3
+	VSLDOI   $13, V3, V10, V3   // Shift left last 3 bytes
+	VSLDOI   $1, V2, V3, V4     // V4=(V2:V3)<<1
+	VSLDOI   $2, V2, V3, V9     // V9=(V2:V3)<<2
+	VSLDOI   $3, V2, V3, V10    // V10=(V2:v3)<<3
+	VCMPEQUW V1, V2, V5         // compare index 0, 4, ... with sep
+	VCMPEQUW V1, V4, V6         // compare index 1, 5, ... with sep
+	VCMPEQUW V1, V9, V11        // compare index 2, 6, ... with sep
+	VCMPEQUW V1, V10, V12       // compare index 3, 7, ... with sep
+	VSEL     V6, V5, V29, V13   // merge index 0, 1, 4, 5, using mask
+	VSEL     V12, V11, V30, V14 // merge index 2, 3, 6, 7, using mask
+	VSEL     V14, V13, V31, V7  // final merge
+	VCLZD    V7, V18            // Find first index for each half
+	MFVSRD   V18, R25           // Isolate value
+	CMP      R25, $64           // If < 64, found
+	BLT      foundR25           // Return found index
+	VSLDOI   $8, V18, V18, V18  // Move for MFVSRD
+	MFVSRD   V18, R25           // Isolate other value
+	CMP      R25, $64           // If < 64, found
+	ADD      $64, R25           // Update index for high doubleword
+	BLT      foundR25           // Return found index
+	ADD      $16, R7            // R7+=16 for next string
+	ADD      $20, R7, R9        // R+20 for all bytes to load
+	CMP      R9, LASTBYTE       // Past end? Maybe check for extra?
+	BLT      index4loop         // If not, continue loop
+	CMP      R7, LASTSTR        // Check remainder
+	BLE      index2to16         // Process remainder
+	BR       notfound           // Not found
+
+index5plus:
+	CMP R6, $16     // Check for sep > 16
+	BGT index17plus // Handle large sep
+
+	// Assumption is that the separator is smaller than the string at this point
+index2to16:
+	CMP R7, LASTSTR // Compare last start byte
+	BGT notfound    // last takes len(sep) into account
+
+	ADD $16, R7, R9    // Check for last byte of string
+	CMP R9, LASTBYTE
+	BGT index2to16tail
+
+	// At least 16 bytes of string left
+	// Mask the number of bytes in sep
+index2to16loop:
+	VLOADSWAP(R7, R0, V1, V1_) // Load 16 bytes @R7 into V1
+
+compare:
+	VAND       V1, SEPMASK, V2 // Mask out sep size
+	VCMPEQUBCC V0, V2, V3      // Compare masked string
+	BLT        CR6, found      // All equal
+	ADD        $1, R7          // Update ptr to next byte
+	CMP        R7, LASTSTR     // Still less than last start byte
+	BGT        notfound        // Not found
+	ADD        $16, R7, R9     // Verify remaining bytes
+	CMP        R9, LASTBYTE    // At least 16
+	BLT        index2to16loop  // Try again
+
+	// Less than 16 bytes remaining in string
+	// Separator >= 2
+index2to16tail:
+	ADD   R3, R4, R9     // End of string
+	SUB   R7, R9, R9     // Number of bytes left
+	ANDCC $15, R7, R10   // 16 byte offset
+	ADD   R10, R9, R11   // offset + len
+	CMP   R11, $16       // >= 16?
+	BLE   short          // Does not cross 16 bytes
+	VLOADSWAP(R7, R0, V1, V1_)// Load 16 bytes @R7 into V1
+	BR    index2to16next // Continue on
+
+short:
+	RLDICR   $0, R7, $59, R9 // Adjust addr to 16 byte container
+	VLOADSWAP(R9, R0, V1, V1_)// Load 16 bytes @R9 into V1
+	SLD      $3, R10         // Set up shift
+	MTVSRD   R10, V8_        // Set up shift
+	VSLDOI   $8, V8, V8, V8
+	VSLO     V1, V8, V1      // Shift by start byte
+	VSPLTISB $0, V25         // Clear for later use
+
+index2to16next:
+	VAND       V1, SEPMASK, V2 // Just compare size of sep
+	VCMPEQUBCC V0, V2, V3      // Compare sep and partial string
+	BLT        CR6, found      // Found
+	ADD        $1, R7          // Not found, try next partial string
+	CMP        R7, LASTSTR     // Check for end of string
+	BGT        notfound        // If at end, then not found
+	VSLDOI     $1, V1, V25, V1 // Shift string left by 1 byte
+	BR         index2to16next  // Check the next partial string
+
+index17plus:
+	CMP      R6, $32      // Check if 17 < len(sep) <= 32
+	BGT      index33plus
+	SUB      $16, R6, R9  // Extra > 16
+	SLD      $56, R9, R10 // Shift to use in VSLO
+	MTVSRD   R10, V9_     // Set up for VSLO
+	VLOADSWAP(R5, R9, V1, V1_)// Load 16 bytes @R5+R9 into V1
+	VSLO     V1, V9, V1   // Shift left
+	VSPLTISB $0xff, V7    // Splat 1s
+	VSPLTISB $0, V27      // Splat 0
+
+index17to32loop:
+	VLOADSWAP(R7, R0, V2, V2_) // Load 16 bytes @R7 into V2
+
+next17:
+	VLOADSWAP(R7, R9, V3, V3_) // Load 16 bytes @R7+R9 into V3
+	VSLO       V3, V9, V3      // Shift left
+	VCMPEQUB   V0, V2, V4      // Compare first 16 bytes
+	VCMPEQUB   V1, V3, V5      // Compare extra over 16 bytes
+	VAND       V4, V5, V6      // Check if both equal
+	VCMPEQUBCC V6, V7, V8      // All equal?
+	BLT        CR6, found      // Yes
+	ADD        $1, R7          // On to next byte
+	CMP        R7, LASTSTR     // Check if last start byte
+	BGT        notfound        // If too high, not found
+	BR         index17to32loop // Continue
+
+notfound:
+	MOVD $-1, R8   // Return -1 if not found
+	MOVD R8, (R14)
+	RET
+
+index33plus:
+	MOVD $0, (R0) // Case not implemented
+	RET           // Crash before return
+
+foundR25:
+	SRD  $3, R25   // Convert from bits to bytes
+	ADD  R25, R7   // Add to current string address
+	SUB  R3, R7    // Subtract from start of string
+	MOVD R7, (R14) // Return byte where found
+	RET
+
+found:
+	SUB  R3, R7    // Return byte where found
+	MOVD R7, (R14)
+	RET
-- 
GitLab


From ddd8d7c0a6859114f1f9bfbb3c56fb63f870badc Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Tue, 9 Mar 2021 16:55:11 -0600
Subject: [PATCH 1591/2400] cmd/internal/obj: consolidate AMOVW and AMOVWZ
 optab entries

This requires consolidating the register move operations into a
single case entry in asmout.  These moves are also used to
sign/zero-extend register values.

Combine the three asmout cases for register moves.  This allows
AMOVWZ and AMOVW to be handled with the same optab entries.

Likewise, remove the diagnostic error for non-zero constant
loads into R0 using the register move operations, it is not
possible to match this asmout case with a non-zero constant.

Finally, fix the load constant 0 via "MOV[BHW]{,Z} $0, Rx".
These now generate "li Rx, $0" instead of a zero/sign-extend
of the contents of R0.

Change-Id: Ia4a263661582f10feda27ee21cb121e05ea931dc
Reviewed-on: https://go-review.googlesource.com/c/go/+/308190
Run-TryBot: Paul Murphy <murp@ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
Reviewed-by: Carlos Eduardo Seo <carlos.seo@linaro.org>
Trust: Carlos Eduardo Seo <carlos.seo@linaro.org>
---
 src/cmd/asm/internal/asm/testdata/ppc64.s |  9 +++
 src/cmd/internal/obj/ppc64/asm9.go        | 85 +++++++----------------
 2 files changed, 36 insertions(+), 58 deletions(-)

diff --git a/src/cmd/asm/internal/asm/testdata/ppc64.s b/src/cmd/asm/internal/asm/testdata/ppc64.s
index a818c0e789..eaec24b8b7 100644
--- a/src/cmd/asm/internal/asm/testdata/ppc64.s
+++ b/src/cmd/asm/internal/asm/testdata/ppc64.s
@@ -77,6 +77,15 @@ TEXT asmtest(SB),DUPOK|NOSPLIT,$0
 	MOVBU R4, 1(R3)                 // 9c830001
 	MOVBU R5, (R3)(R4)              // 7ca419ee
 
+	MOVB $0, R4			// 38800000
+	MOVBZ $0, R4			// 38800000
+	MOVH $0, R4			// 38800000
+	MOVHZ $0, R4			// 38800000
+	MOVW $0, R4			// 38800000
+	MOVWZ $0, R4			// 38800000
+	MOVD $0, R4			// 38800000
+	MOVD $0, R0			// 38000000
+
 	ADD $1, R3                      // 38630001
 	ADD $1, R3, R4                  // 38830001
 	ADD $-1, R4                     // 3884ffff
diff --git a/src/cmd/internal/obj/ppc64/asm9.go b/src/cmd/internal/obj/ppc64/asm9.go
index 0243dd4744..373fbedec7 100644
--- a/src/cmd/internal/obj/ppc64/asm9.go
+++ b/src/cmd/internal/obj/ppc64/asm9.go
@@ -209,7 +209,7 @@ var optab = []Optab{
 	{as: AMOVB, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 	{as: AMOVB, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVB, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
-	{as: AMOVB, a1: C_REG, a6: C_REG, type_: 12, size: 4},
+	{as: AMOVB, a1: C_REG, a6: C_REG, type_: 13, size: 4},
 
 	{as: AMOVBZ, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
 	{as: AMOVBZ, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
@@ -237,7 +237,7 @@ var optab = []Optab{
 	{as: AMOVD, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVD, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
 	{as: AMOVD, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
-	{as: AMOVD, a1: C_REG, a6: C_REG, type_: 1, size: 4},
+	{as: AMOVD, a1: C_REG, a6: C_REG, type_: 13, size: 4},
 
 	{as: AMOVW, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4},
 	{as: AMOVW, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4},
@@ -255,25 +255,7 @@ var optab = []Optab{
 	{as: AMOVW, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVW, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
 	{as: AMOVW, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
-	{as: AMOVW, a1: C_REG, a6: C_REG, type_: 12, size: 4},
-
-	{as: AMOVWZ, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVWZ, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVWZ, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVWZ, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
-	{as: AMOVWZ, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
-	{as: AMOVWZ, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
-	{as: AMOVWZ, a1: C_CREG, a6: C_REG, type_: 68, size: 4},
-	{as: AMOVWZ, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
-	{as: AMOVWZ, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
-	{as: AMOVWZ, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
-	{as: AMOVWZ, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
-	{as: AMOVWZ, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
-	{as: AMOVWZ, a1: C_REG, a6: C_CREG, type_: 69, size: 4},
-	{as: AMOVWZ, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
-	{as: AMOVWZ, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
-	{as: AMOVWZ, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
-	{as: AMOVWZ, a1: C_REG, a6: C_REG, type_: 13, size: 4},
+	{as: AMOVW, a1: C_REG, a6: C_REG, type_: 13, size: 4},
 
 	{as: AFMOVD, a1: C_ADDCON, a6: C_FREG, type_: 24, size: 8},
 	{as: AFMOVD, a1: C_SOREG, a6: C_FREG, type_: 8, size: 4},
@@ -1925,6 +1907,9 @@ func buildop(ctxt *obj.Link) {
 		case AFTSQRT:
 			opset(AFTSQRT, r0)
 
+		case AMOVW: /* load/store/move word with sign extension; move 32-bit literals  */
+			opset(AMOVWZ, r0) /* Same as above, but zero extended */
+
 		case AADD,
 			AADDIS,
 			AANDCC, /* and. Rb,Rs,Ra; andi. $uimm,Rs,Ra */
@@ -1932,9 +1917,6 @@ func buildop(ctxt *obj.Link) {
 			AFMOVSX,
 			AFMOVSZ,
 			ALSW,
-			AMOVW,
-			/* load/store/move word with sign extension; special 32-bit move; move 32-bit literals */
-			AMOVWZ, /* load/store/move word with zero extension; move 32-bit literals  */
 			AMOVD,  /* load/store/move 64-bit values, including 32-bit literals with/without sign-extension */
 			AMOVB,  /* macro: move byte with sign extension */
 			AMOVBU, /* macro: move byte with sign extension & update */
@@ -2392,20 +2374,6 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 	case 0: /* pseudo ops */
 		break
 
-	case 1: /* mov r1,r2 ==> OR Rs,Rs,Ra */
-		if p.To.Reg == REGZERO && p.From.Type == obj.TYPE_CONST {
-			v := c.regoff(&p.From)
-			if r0iszero != 0 /*TypeKind(100016)*/ && v != 0 {
-				//nerrors--;
-				c.ctxt.Diag("literal operation on R0\n%v", p)
-			}
-
-			o1 = LOP_IRR(OP_ADDI, REGZERO, REGZERO, uint32(v))
-			break
-		}
-
-		o1 = LOP_RRR(OP_OR, uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.From.Reg))
-
 	case 2: /* int/cr/fp op Rb,[Ra],Rd */
 		r := int(p.Reg)
 
@@ -2594,34 +2562,35 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		}
 		o2 = 0x60000000 // nop, sometimes overwritten by ld r2, 24(r1) when dynamic linking
 
-	case 12: /* movb r,r (extsb); movw r,r (extsw) */
-		if p.To.Reg == REGZERO && p.From.Type == obj.TYPE_CONST {
-			v := c.regoff(&p.From)
-			if r0iszero != 0 /*TypeKind(100016)*/ && v != 0 {
-				c.ctxt.Diag("literal operation on R0\n%v", p)
-			}
-
-			o1 = LOP_IRR(OP_ADDI, REGZERO, REGZERO, uint32(v))
+	case 13: /* mov[bhwd]{z,} r,r */
+		// This needs to handle "MOV* $0, Rx".  This shows up because $0 also
+		// matches C_REG if r0iszero. This happens because C_REG sorts before C_ANDCON
+		// TODO: fix the above behavior and cleanup this exception.
+		if p.From.Type == obj.TYPE_CONST {
+			o1 = LOP_IRR(OP_ADDI, REGZERO, uint32(p.To.Reg), 0)
 			break
 		}
-
-		if p.As == AMOVW {
-			o1 = LOP_RRR(OP_EXTSW, uint32(p.To.Reg), uint32(p.From.Reg), 0)
-		} else {
-			o1 = LOP_RRR(OP_EXTSB, uint32(p.To.Reg), uint32(p.From.Reg), 0)
+		if p.To.Type == obj.TYPE_CONST {
+			c.ctxt.Diag("cannot move into constant 0\n%v", p)
 		}
 
-	case 13: /* mov[bhw]z r,r; uses rlwinm not andi. to avoid changing CC */
-		if p.As == AMOVBZ {
+		switch p.As {
+		case AMOVB:
+			o1 = LOP_RRR(OP_EXTSB, uint32(p.To.Reg), uint32(p.From.Reg), 0)
+		case AMOVBZ:
 			o1 = OP_RLW(OP_RLWINM, uint32(p.To.Reg), uint32(p.From.Reg), 0, 24, 31)
-		} else if p.As == AMOVH {
+		case AMOVH:
 			o1 = LOP_RRR(OP_EXTSH, uint32(p.To.Reg), uint32(p.From.Reg), 0)
-		} else if p.As == AMOVHZ {
+		case AMOVHZ:
 			o1 = OP_RLW(OP_RLWINM, uint32(p.To.Reg), uint32(p.From.Reg), 0, 16, 31)
-		} else if p.As == AMOVWZ {
+		case AMOVW:
+			o1 = LOP_RRR(OP_EXTSW, uint32(p.To.Reg), uint32(p.From.Reg), 0)
+		case AMOVWZ:
 			o1 = OP_RLW(OP_RLDIC, uint32(p.To.Reg), uint32(p.From.Reg), 0, 0, 0) | 1<<5 /* MB=32 */
-		} else {
-			c.ctxt.Diag("internal: bad mov[bhw]z\n%v", p)
+		case AMOVD:
+			o1 = LOP_RRR(OP_OR, uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.From.Reg))
+		default:
+			c.ctxt.Diag("internal: bad register move/truncation\n%v", p)
 		}
 
 	case 14: /* rldc[lr] Rb,Rs,$mask,Ra -- left, right give different masks */
-- 
GitLab


From a63ff398d541a1b3a3658e38693adebf370aadbb Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 14 Apr 2021 13:10:34 -0700
Subject: [PATCH 1592/2400] cmd/compile/internal/syntax: fix error message for
 ... without type

Only complain about missing type; leave it to type-checking
to decide whether "..." is permitted in the first place.

Fixes #43674.

Change-Id: Icbc8f084e364fe3ac16076406a134354219c08d0
Reviewed-on: https://go-review.googlesource.com/c/go/+/310209
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/syntax/parser.go           |  2 +-
 .../compile/internal/syntax/testdata/issue43674.src | 13 +++++++++++++
 test/fixedbugs/bug228.go                            |  2 +-
 3 files changed, 15 insertions(+), 2 deletions(-)
 create mode 100644 src/cmd/compile/internal/syntax/testdata/issue43674.src

diff --git a/src/cmd/compile/internal/syntax/parser.go b/src/cmd/compile/internal/syntax/parser.go
index 026297432d..80250212dd 100644
--- a/src/cmd/compile/internal/syntax/parser.go
+++ b/src/cmd/compile/internal/syntax/parser.go
@@ -1836,7 +1836,7 @@ func (p *parser) paramDeclOrNil(name *Name) *Field {
 		t.Elem = p.typeOrNil()
 		if t.Elem == nil {
 			t.Elem = p.badExpr()
-			p.syntaxError("final argument in variadic function missing type")
+			p.syntaxError("... is missing type")
 		}
 		f.Type = t
 		return f
diff --git a/src/cmd/compile/internal/syntax/testdata/issue43674.src b/src/cmd/compile/internal/syntax/testdata/issue43674.src
new file mode 100644
index 0000000000..51c692ae69
--- /dev/null
+++ b/src/cmd/compile/internal/syntax/testdata/issue43674.src
@@ -0,0 +1,13 @@
+// Copyright 2021 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 p
+
+func _(... /* ERROR [.][.][.] is missing type */ )
+func _(... /* ERROR [.][.][.] is missing type */ , int)
+
+func _(a, b ... /* ERROR [.][.][.] is missing type */ )
+func _(a, b ... /* ERROR [.][.][.] is missing type */ , x int)
+
+func _()(... /* ERROR [.][.][.] is missing type */ )
diff --git a/test/fixedbugs/bug228.go b/test/fixedbugs/bug228.go
index f7ac670689..50e895917f 100644
--- a/test/fixedbugs/bug228.go
+++ b/test/fixedbugs/bug228.go
@@ -8,7 +8,7 @@ package main
 
 func f(x int, y ...int)	// ok
 
-func g(x int, y float32) (...)	// ERROR "[.][.][.]" "final argument"
+func g(x int, y float32) (...)	// ERROR "[.][.][.]"
 
 func h(x, y ...int)		// ERROR "[.][.][.]"
 
-- 
GitLab


From 7ed6d1f2fb2e092f59ec56e0d16b1f9da33992a4 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 15 Apr 2021 12:18:08 -0700
Subject: [PATCH 1593/2400] cmd/compile/internal/types2: add sizeof test

Change-Id: I75d3c8546b7ad51d8c7369e7289036b697d6b913
Reviewed-on: https://go-review.googlesource.com/c/go/+/310530
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 .../compile/internal/types2/sizeof_test.go    | 65 +++++++++++++++++++
 1 file changed, 65 insertions(+)
 create mode 100644 src/cmd/compile/internal/types2/sizeof_test.go

diff --git a/src/cmd/compile/internal/types2/sizeof_test.go b/src/cmd/compile/internal/types2/sizeof_test.go
new file mode 100644
index 0000000000..236feb0404
--- /dev/null
+++ b/src/cmd/compile/internal/types2/sizeof_test.go
@@ -0,0 +1,65 @@
+// Copyright 2021 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 types2
+
+import (
+	"reflect"
+	"testing"
+)
+
+// Signal size changes of important structures.
+
+func TestSizeof(t *testing.T) {
+	const _64bit = ^uint(0)>>32 != 0
+
+	var tests = []struct {
+		val    interface{} // type as a value
+		_32bit uintptr     // size on 32bit platforms
+		_64bit uintptr     // size on 64bit platforms
+	}{
+		// Types
+		{Basic{}, 16, 32},
+		{Array{}, 16, 24},
+		{Slice{}, 8, 16},
+		{Struct{}, 24, 48},
+		{Pointer{}, 8, 16},
+		{Tuple{}, 12, 24},
+		{Signature{}, 44, 88},
+		{Sum{}, 12, 24},
+		{Interface{}, 60, 120},
+		{Map{}, 16, 32},
+		{Chan{}, 12, 24},
+		{Named{}, 68, 136},
+		{TypeParam{}, 28, 48},
+		{instance{}, 52, 96},
+		{bottom{}, 0, 0},
+		{top{}, 0, 0},
+
+		// Objects
+		{PkgName{}, 64, 104},
+		{Const{}, 64, 104},
+		{TypeName{}, 56, 88},
+		{Var{}, 60, 96},
+		{Func{}, 60, 96},
+		{Label{}, 60, 96},
+		{Builtin{}, 60, 96},
+		{Nil{}, 56, 88},
+
+		// Misc
+		{Scope{}, 56, 96},
+		{Package{}, 40, 80},
+	}
+
+	for _, test := range tests {
+		got := reflect.TypeOf(test.val).Size()
+		want := test._32bit
+		if _64bit {
+			want = test._64bit
+		}
+		if got != want {
+			t.Errorf("unsafe.Sizeof(%T) = %d, want %d", test.val, got, want)
+		}
+	}
+}
-- 
GitLab


From 699a7c0fe9c1b75340f2ef05949529ec4b43dc4e Mon Sep 17 00:00:00 2001
From: Aofei Sheng <aofei@aofeisheng.com>
Date: Fri, 2 Apr 2021 14:45:26 +0800
Subject: [PATCH 1594/2400] cmd/go/internal/modconv: involve GOPROXY in
 ConvertLegacyConfig

Fixes #33767

Change-Id: Ia2d6dd32bcb0e142f59346232b3b1aa3babb034a
Reviewed-on: https://go-review.googlesource.com/c/go/+/306809
Trust: Jay Conrod <jayconrod@google.com>
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Aofei Sheng <aofei@aofeisheng.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/internal/modconv/convert.go        |   9 +-
 src/cmd/go/internal/modconv/convert_test.go   | 189 ------------------
 src/cmd/go/internal/modfetch/repo.go          |  56 ------
 src/cmd/go/internal/modload/init.go           |  13 +-
 src/cmd/go/testdata/script/mod_convert.txt    |  64 ++++++
 .../script/mod_convert_tsv_insecure.txt       |   2 +
 src/cmd/go/testdata/script/mod_init_dep.txt   |   4 -
 src/cmd/go/testdata/script/mod_init_glide.txt |   1 +
 8 files changed, 82 insertions(+), 256 deletions(-)
 delete mode 100644 src/cmd/go/internal/modconv/convert_test.go
 create mode 100644 src/cmd/go/testdata/script/mod_convert.txt

diff --git a/src/cmd/go/internal/modconv/convert.go b/src/cmd/go/internal/modconv/convert.go
index 5d4165c944..9c861f8e99 100644
--- a/src/cmd/go/internal/modconv/convert.go
+++ b/src/cmd/go/internal/modconv/convert.go
@@ -12,7 +12,6 @@ import (
 	"strings"
 
 	"cmd/go/internal/base"
-	"cmd/go/internal/modfetch"
 
 	"golang.org/x/mod/modfile"
 	"golang.org/x/mod/module"
@@ -21,7 +20,7 @@ import (
 
 // ConvertLegacyConfig converts legacy config to modfile.
 // The file argument is slash-delimited.
-func ConvertLegacyConfig(f *modfile.File, file string, data []byte) error {
+func ConvertLegacyConfig(f *modfile.File, file string, data []byte, queryPackage func(path, rev string) (module.Version, error)) error {
 	i := strings.LastIndex(file, "/")
 	j := -2
 	if i >= 0 {
@@ -62,15 +61,13 @@ func ConvertLegacyConfig(f *modfile.File, file string, data []byte) error {
 		sem <- token{}
 		go func(i int, m module.Version) {
 			defer func() { <-sem }()
-			repo, info, err := modfetch.ImportRepoRev(m.Path, m.Version)
+			version, err := queryPackage(m.Path, m.Version)
 			if err != nil {
 				fmt.Fprintf(os.Stderr, "go: converting %s: stat %s@%s: %v\n", base.ShortPath(file), m.Path, m.Version, err)
 				return
 			}
 
-			path := repo.ModulePath()
-			versions[i].Path = path
-			versions[i].Version = info.Version
+			versions[i] = version
 		}(i, m)
 	}
 	// Fill semaphore channel to wait for all tasks to finish.
diff --git a/src/cmd/go/internal/modconv/convert_test.go b/src/cmd/go/internal/modconv/convert_test.go
deleted file mode 100644
index 66b9ff4f38..0000000000
--- a/src/cmd/go/internal/modconv/convert_test.go
+++ /dev/null
@@ -1,189 +0,0 @@
-// Copyright 2018 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 modconv
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"internal/testenv"
-	"log"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"cmd/go/internal/cfg"
-	"cmd/go/internal/modfetch"
-
-	"golang.org/x/mod/modfile"
-	"golang.org/x/mod/module"
-)
-
-func TestMain(m *testing.M) {
-	os.Exit(testMain(m))
-}
-
-func testMain(m *testing.M) int {
-	cfg.GOPROXY = "direct"
-
-	if _, err := exec.LookPath("git"); err != nil {
-		fmt.Fprintln(os.Stderr, "skipping because git binary not found")
-		fmt.Println("PASS")
-		return 0
-	}
-
-	dir, err := os.MkdirTemp("", "modconv-test-")
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
-	cfg.GOMODCACHE = filepath.Join(dir, "pkg/mod")
-
-	return m.Run()
-}
-
-func TestConvertLegacyConfig(t *testing.T) {
-	testenv.MustHaveExternalNetwork(t)
-
-	if testing.Verbose() {
-		old := cfg.BuildX
-		defer func() {
-			cfg.BuildX = old
-		}()
-		cfg.BuildX = true
-	}
-
-	var tests = []struct {
-		path  string
-		vers  string
-		gomod string
-	}{
-		/*
-			Different versions of git seem to find or not find
-			github.com/Masterminds/semver's a93e51b5a57e,
-			which is an unmerged pull request.
-			We'd rather not provide access to unmerged pull requests,
-			so the line is removed from the golden file here,
-			but some git commands still find it somehow.
-
-			{
-				// Gopkg.lock parsing.
-				"github.com/golang/dep", "v0.4.0",
-				`module github.com/golang/dep
-
-				require (
-					github.com/Masterminds/vcs v1.11.1
-					github.com/armon/go-radix v0.0.0-20160115234725-4239b77079c7
-					github.com/boltdb/bolt v1.3.1
-					github.com/go-yaml/yaml v0.0.0-20170407172122-cd8b52f8269e
-					github.com/golang/protobuf v0.0.0-20170901042739-5afd06f9d81a
-					github.com/jmank88/nuts v0.3.0
-					github.com/nightlyone/lockfile v0.0.0-20170707060451-e83dc5e7bba0
-					github.com/pelletier/go-toml v0.0.0-20171218135716-b8b5e7696574
-					github.com/pkg/errors v0.8.0
-					github.com/sdboyer/constext v0.0.0-20170321163424-836a14457353
-					golang.org/x/net v0.0.0-20170828231752-66aacef3dd8a
-					golang.org/x/sync v0.0.0-20170517211232-f52d1811a629
-					golang.org/x/sys v0.0.0-20170830134202-bb24a47a89ea
-				)`,
-			},
-		*/
-
-		// TODO: https://github.com/docker/distribution uses vendor.conf
-
-		{
-			// Godeps.json parsing.
-			// TODO: Should v2.0.0 work here too?
-			"github.com/docker/distribution", "v0.0.0-20150410205453-85de3967aa93",
-			`module github.com/docker/distribution
-
-			require (
-				github.com/AdRoll/goamz v0.0.0-20150130162828-d3664b76d905
-				github.com/MSOpenTech/azure-sdk-for-go v0.0.0-20150323223030-d90753bcad2e
-				github.com/Sirupsen/logrus v0.7.3
-				github.com/bugsnag/bugsnag-go v1.0.3-0.20141110184014-b1d153021fcd
-				github.com/bugsnag/osext v0.0.0-20130617224835-0dd3f918b21b
-				github.com/bugsnag/panicwrap v0.0.0-20141110184334-e5f9854865b9
-				github.com/codegangsta/cli v1.4.2-0.20150131031259-6086d7927ec3
-				github.com/docker/docker v1.4.2-0.20150204013315-165ea5c158cf
-				github.com/docker/libtrust v0.0.0-20150114040149-fa567046d9b1
-				github.com/garyburd/redigo v0.0.0-20150301180006-535138d7bcd7
-				github.com/gorilla/context v0.0.0-20140604161150-14f550f51af5
-				github.com/gorilla/handlers v0.0.0-20140825150757-0e84b7d810c1
-				github.com/gorilla/mux v0.0.0-20140926153814-e444e69cbd2e
-				github.com/jlhawn/go-crypto v0.0.0-20150401213827-cd738dde20f0
-				github.com/yvasiyarov/go-metrics v0.0.0-20140926110328-57bccd1ccd43
-				github.com/yvasiyarov/gorelic v0.0.7-0.20141212073537-a9bba5b9ab50
-				github.com/yvasiyarov/newrelic_platform_go v0.0.0-20140908184405-b21fdbd4370f
-				golang.org/x/net v0.0.0-20150202051010-1dfe7915deaf
-				gopkg.in/check.v1 v1.0.0-20141024133853-64131543e789
-				gopkg.in/yaml.v2 v2.0.0-20150116202057-bef53efd0c76
-			)`,
-		},
-
-		{
-			// golang.org/issue/24585 - confusion about v2.0.0 tag in legacy non-v2 module
-			"github.com/fishy/gcsbucket", "v0.0.0-20180217031846-618d60fe84e0",
-			`module github.com/fishy/gcsbucket
-
-			require (
-				cloud.google.com/go v0.18.0
-				github.com/fishy/fsdb v0.0.0-20180217030800-5527ded01371
-				github.com/golang/protobuf v1.0.0
-				github.com/googleapis/gax-go v2.0.0+incompatible
-				golang.org/x/net v0.0.0-20180216171745-136a25c244d3
-				golang.org/x/oauth2 v0.0.0-20180207181906-543e37812f10
-				golang.org/x/text v0.3.1-0.20180208041248-4e4a3210bb54
-				google.golang.org/api v0.0.0-20180217000815-c7a403bb5fe1
-				google.golang.org/appengine v1.0.0
-				google.golang.org/genproto v0.0.0-20180206005123-2b5a72b8730b
-				google.golang.org/grpc v1.10.0
-			)`,
-		},
-	}
-
-	ctx := context.Background()
-
-	for _, tt := range tests {
-		t.Run(strings.ReplaceAll(tt.path, "/", "_")+"_"+tt.vers, func(t *testing.T) {
-			f, err := modfile.Parse("golden", []byte(tt.gomod), nil)
-			if err != nil {
-				t.Fatal(err)
-			}
-			want, err := f.Format()
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			dir, err := modfetch.Download(ctx, module.Version{Path: tt.path, Version: tt.vers})
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			for name := range Converters {
-				file := filepath.Join(dir, name)
-				data, err := os.ReadFile(file)
-				if err == nil {
-					f := new(modfile.File)
-					f.AddModuleStmt(tt.path)
-					if err := ConvertLegacyConfig(f, filepath.ToSlash(file), data); err != nil {
-						t.Fatal(err)
-					}
-					out, err := f.Format()
-					if err != nil {
-						t.Fatalf("format after conversion: %v", err)
-					}
-					if !bytes.Equal(out, want) {
-						t.Fatalf("final go.mod:\n%s\n\nwant:\n%s", out, want)
-					}
-					return
-				}
-			}
-			t.Fatalf("no converter found for %s@%s", tt.path, tt.vers)
-		})
-	}
-}
diff --git a/src/cmd/go/internal/modfetch/repo.go b/src/cmd/go/internal/modfetch/repo.go
index 46923cb7dc..20469c5432 100644
--- a/src/cmd/go/internal/modfetch/repo.go
+++ b/src/cmd/go/internal/modfetch/repo.go
@@ -169,15 +169,6 @@ type RevInfo struct {
 // and it can check that the path can be resolved to a target repository.
 // To avoid version control access except when absolutely necessary,
 // Lookup does not attempt to connect to the repository itself.
-//
-// The ImportRepoRev function is a variant of Import which is limited
-// to code in a source code repository at a particular revision identifier
-// (usually a commit hash or source code repository tag, not necessarily
-// a module version).
-// ImportRepoRev is used when converting legacy dependency requirements
-// from older systems into go.mod files. Those older systems worked
-// at either package or repository granularity, and most of the time they
-// recorded commit hashes, not tagged versions.
 
 var lookupCache par.Cache
 
@@ -297,53 +288,6 @@ func lookupCodeRepo(rr *vcs.RepoRoot) (codehost.Repo, error) {
 	return code, nil
 }
 
-// ImportRepoRev returns the module and version to use to access
-// the given import path loaded from the source code repository that
-// the original "go get" would have used, at the specific repository revision
-// (typically a commit hash, but possibly also a source control tag).
-func ImportRepoRev(path, rev string) (Repo, *RevInfo, error) {
-	if cfg.BuildMod == "vendor" || cfg.BuildMod == "readonly" {
-		return nil, nil, fmt.Errorf("repo version lookup disabled by -mod=%s", cfg.BuildMod)
-	}
-
-	// Note: Because we are converting a code reference from a legacy
-	// version control system, we ignore meta tags about modules
-	// and use only direct source control entries (get.IgnoreMod).
-	security := web.SecureOnly
-	if module.MatchPrefixPatterns(cfg.GOINSECURE, path) {
-		security = web.Insecure
-	}
-	rr, err := vcs.RepoRootForImportPath(path, vcs.IgnoreMod, security)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	code, err := lookupCodeRepo(rr)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	revInfo, err := code.Stat(rev)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	// TODO: Look in repo to find path, check for go.mod files.
-	// For now we're just assuming rr.Root is the module path,
-	// which is true in the absence of go.mod files.
-
-	repo, err := newCodeRepo(code, rr.Root, rr.Root)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	info, err := repo.(*codeRepo).convert(revInfo, rev)
-	if err != nil {
-		return nil, nil, err
-	}
-	return repo, info, nil
-}
-
 // A loggingRepo is a wrapper around an underlying Repo
 // that prints a log message at the start and end of each call.
 // It can be inserted when debugging.
diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index 120afef4ff..45852edbd1 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -728,6 +728,17 @@ func setDefaultBuildMod() {
 // convertLegacyConfig imports module requirements from a legacy vendoring
 // configuration file, if one is present.
 func convertLegacyConfig(modPath string) (from string, err error) {
+	noneSelected := func(path string) (version string) { return "none" }
+	queryPackage := func(path, rev string) (module.Version, error) {
+		pkgMods, modOnly, err := QueryPattern(context.Background(), path, rev, noneSelected, nil)
+		if err != nil {
+			return module.Version{}, err
+		}
+		if len(pkgMods) > 0 {
+			return pkgMods[0].Mod, nil
+		}
+		return modOnly.Mod, nil
+	}
 	for _, name := range altConfigs {
 		cfg := filepath.Join(modRoot, name)
 		data, err := os.ReadFile(cfg)
@@ -737,7 +748,7 @@ func convertLegacyConfig(modPath string) (from string, err error) {
 				return "", nil
 			}
 			cfg = filepath.ToSlash(cfg)
-			err := modconv.ConvertLegacyConfig(modFile, cfg, data)
+			err := modconv.ConvertLegacyConfig(modFile, cfg, data, queryPackage)
 			return name, err
 		}
 	}
diff --git a/src/cmd/go/testdata/script/mod_convert.txt b/src/cmd/go/testdata/script/mod_convert.txt
new file mode 100644
index 0000000000..6e9b136356
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_convert.txt
@@ -0,0 +1,64 @@
+[short] skip
+
+env GO111MODULE=on
+env GOPROXY=
+env GOSUMDB=
+
+go mod download github.com/docker/distribution@v0.0.0-20150410205453-85de3967aa93
+mkdir x/Godeps
+cp $GOPATH/pkg/mod/github.com/docker/distribution@v0.0.0-20150410205453-85de3967aa93/Godeps/Godeps.json x/Godeps
+cd x
+go mod init github.com/docker/distribution
+cmpenv go.mod go.mod.want
+
+go mod download github.com/fishy/gcsbucket@v0.0.0-20180217031846-618d60fe84e0
+cp $GOPATH/pkg/mod/github.com/fishy/gcsbucket@v0.0.0-20180217031846-618d60fe84e0/Gopkg.lock ../y
+cd ../y
+go mod init github.com/fishy/gcsbucket
+cmpenv go.mod go.mod.want
+
+-- x/go.mod.want --
+module github.com/docker/distribution
+
+go $goversion
+
+require (
+	github.com/AdRoll/goamz v0.0.0-20150130162828-d3664b76d905
+	github.com/MSOpenTech/azure-sdk-for-go v0.0.0-20150323223030-d90753bcad2e
+	github.com/Sirupsen/logrus v0.7.3
+	github.com/bugsnag/bugsnag-go v1.0.3-0.20141110184014-b1d153021fcd
+	github.com/bugsnag/osext v0.0.0-20130617224835-0dd3f918b21b
+	github.com/bugsnag/panicwrap v0.0.0-20141110184334-e5f9854865b9
+	github.com/codegangsta/cli v1.4.2-0.20150131031259-6086d7927ec3
+	github.com/docker/docker v1.4.2-0.20150204013315-165ea5c158cf
+	github.com/docker/libtrust v0.0.0-20150114040149-fa567046d9b1
+	github.com/garyburd/redigo v0.0.0-20150301180006-535138d7bcd7
+	github.com/gorilla/context v0.0.0-20140604161150-14f550f51af5
+	github.com/gorilla/handlers v0.0.0-20140825150757-0e84b7d810c1
+	github.com/gorilla/mux v0.0.0-20140926153814-e444e69cbd2e
+	github.com/jlhawn/go-crypto v0.0.0-20150401213827-cd738dde20f0
+	github.com/yvasiyarov/go-metrics v0.0.0-20140926110328-57bccd1ccd43
+	github.com/yvasiyarov/gorelic v0.0.7-0.20141212073537-a9bba5b9ab50
+	github.com/yvasiyarov/newrelic_platform_go v0.0.0-20140908184405-b21fdbd4370f
+	golang.org/x/net v0.0.0-20150202051010-1dfe7915deaf
+	gopkg.in/check.v1 v1.0.0-20141024133853-64131543e789
+	gopkg.in/yaml.v2 v2.0.0-20150116202057-bef53efd0c76
+)
+-- y/go.mod.want --
+module github.com/fishy/gcsbucket
+
+go $goversion
+
+require (
+	cloud.google.com/go v0.18.0
+	github.com/fishy/fsdb v0.0.0-20180217030800-5527ded01371
+	github.com/golang/protobuf v1.0.0
+	github.com/googleapis/gax-go v2.0.0+incompatible
+	golang.org/x/net v0.0.0-20180216171745-136a25c244d3
+	golang.org/x/oauth2 v0.0.0-20180207181906-543e37812f10
+	golang.org/x/text v0.3.1-0.20180208041248-4e4a3210bb54
+	google.golang.org/api v0.0.0-20180217000815-c7a403bb5fe1
+	google.golang.org/appengine v1.0.0
+	google.golang.org/genproto v0.0.0-20180206005123-2b5a72b8730b
+	google.golang.org/grpc v1.10.0
+)
diff --git a/src/cmd/go/testdata/script/mod_convert_tsv_insecure.txt b/src/cmd/go/testdata/script/mod_convert_tsv_insecure.txt
index ddb0c08199..283e2d9936 100644
--- a/src/cmd/go/testdata/script/mod_convert_tsv_insecure.txt
+++ b/src/cmd/go/testdata/script/mod_convert_tsv_insecure.txt
@@ -1,4 +1,6 @@
 env GO111MODULE=on
+env GOPROXY=direct
+env GOSUMDB=off
 
 [!net] skip
 [!exec:git] skip
diff --git a/src/cmd/go/testdata/script/mod_init_dep.txt b/src/cmd/go/testdata/script/mod_init_dep.txt
index f8cf1d563a..76b4867860 100644
--- a/src/cmd/go/testdata/script/mod_init_dep.txt
+++ b/src/cmd/go/testdata/script/mod_init_dep.txt
@@ -1,10 +1,6 @@
 env GO111MODULE=on
 env GOFLAGS=-mod=mod
 
-# modconv uses git directly to examine what old 'go get' would
-[!net] skip
-[!exec:git] skip
-
 # go mod init should populate go.mod from Gopkg.lock
 go mod init x
 stderr 'copying requirements from Gopkg.lock'
diff --git a/src/cmd/go/testdata/script/mod_init_glide.txt b/src/cmd/go/testdata/script/mod_init_glide.txt
index a351a6ae4b..373810c768 100644
--- a/src/cmd/go/testdata/script/mod_init_glide.txt
+++ b/src/cmd/go/testdata/script/mod_init_glide.txt
@@ -3,6 +3,7 @@
 
 env GO111MODULE=on
 env GOPROXY=direct
+env GOSUMDB=
 
 # Regression test for golang.org/issue/32161:
 # 'go mod init' did not locate tags when resolving a commit to a pseudo-version.
-- 
GitLab


From c8fb0ec5a005289e9dd890b746e543b38bbd9528 Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Thu, 15 Apr 2021 13:41:01 -0500
Subject: [PATCH 1595/2400] cmd/compile: fix ANDI/SRWI merge on ppc64

The shift amount should be masked to avoid rotation values
beyond the numer of bits. In this case, if the shift amount
is 0, it should rotate 0, not 32.

Fixes #45589

Change-Id: I1e764497a39d0ec128e29af42352b70c70b2ecc5
Reviewed-on: https://go-review.googlesource.com/c/go/+/310569
Run-TryBot: Paul Murphy <murp@ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
Reviewed-by: Carlos Eduardo Seo <carlos.seo@linaro.org>
Trust: Carlos Eduardo Seo <carlos.seo@linaro.org>
---
 src/cmd/compile/internal/ssa/rewrite.go      | 2 +-
 src/cmd/compile/internal/ssa/rewrite_test.go | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go
index b8a9062d83..bdc4f799aa 100644
--- a/src/cmd/compile/internal/ssa/rewrite.go
+++ b/src/cmd/compile/internal/ssa/rewrite.go
@@ -1492,7 +1492,7 @@ func mergePPC64AndSrwi(m, s int64) int64 {
 	if !isPPC64WordRotateMask(mask) {
 		return 0
 	}
-	return encodePPC64RotateMask(32-s, mask, 32)
+	return encodePPC64RotateMask((32-s)&31, mask, 32)
 }
 
 // Test if a shift right feeding into a CLRLSLDI can be merged into RLWINM.
diff --git a/src/cmd/compile/internal/ssa/rewrite_test.go b/src/cmd/compile/internal/ssa/rewrite_test.go
index 272b080d88..357fe1183f 100644
--- a/src/cmd/compile/internal/ssa/rewrite_test.go
+++ b/src/cmd/compile/internal/ssa/rewrite_test.go
@@ -205,6 +205,7 @@ func TestMergePPC64AndSrwi(t *testing.T) {
 		{0x00000000, 4, false, 0, 0},
 		{0xF0000000, 4, false, 0, 0},
 		{0xF0000000, 32, false, 0, 0},
+		{0xFFFFFFFF, 0, true, 0, 0xFFFFFFFF},
 	}
 	for i, v := range tests {
 		result := mergePPC64AndSrwi(v.and, v.srw)
-- 
GitLab


From bdddfd10ec26e3d81639bcf8030c281aaf315615 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Thu, 15 Apr 2021 17:23:16 -0400
Subject: [PATCH 1596/2400] runtime: improve synchronization in
 TestFinalizerRegisterABI

Replace busy-wait with a channel.

Change-Id: I51ddfd5dbde15fff56c62c618570e66930902cbb
Reviewed-on: https://go-review.googlesource.com/c/go/+/310630
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/abi_test.go | 44 +++++++++++------------------------------
 1 file changed, 12 insertions(+), 32 deletions(-)

diff --git a/src/runtime/abi_test.go b/src/runtime/abi_test.go
index b82acfe325..f69d3a9d50 100644
--- a/src/runtime/abi_test.go
+++ b/src/runtime/abi_test.go
@@ -17,36 +17,21 @@ import (
 	"os/exec"
 	"runtime"
 	"strings"
-	"sync"
 	"testing"
 	"time"
 )
 
-var regConfirmRunIface int
-var regConfirmRunPtr int
-var regConfirmMU sync.Mutex
-
-func guardedRead(p *int) int {
-	regConfirmMU.Lock()
-	defer regConfirmMU.Unlock()
-	return *p
-}
-
-func guardedWrite(p *int, v int) {
-	regConfirmMU.Lock()
-	defer regConfirmMU.Unlock()
-	*p = v
-}
+var regConfirmRun chan int
 
 //go:registerparams
 func regFinalizerPointer(v *Tint) (int, float32, [10]byte) {
-	guardedWrite(&regConfirmRunPtr, *(*int)(v))
+	regConfirmRun <- *(*int)(v)
 	return 5151, 4.0, [10]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
 }
 
 //go:registerparams
 func regFinalizerIface(v Tinter) (int, float32, [10]byte) {
-	guardedWrite(&regConfirmRunIface, *(*int)(v.(*Tint)))
+	regConfirmRun <- *(*int)(v.(*Tint))
 	return 5151, 4.0, [10]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
 }
 
@@ -96,15 +81,14 @@ func TestFinalizerRegisterABI(t *testing.T) {
 		name         string
 		fin          interface{}
 		confirmValue int
-		confirmRun   *int
 	}{
-		{"Pointer", regFinalizerPointer, -1, &regConfirmRunPtr},
-		{"Interface", regFinalizerIface, -2, &regConfirmRunIface},
+		{"Pointer", regFinalizerPointer, -1},
+		{"Interface", regFinalizerIface, -2},
 	}
 	for i := range tests {
 		test := &tests[i]
 		t.Run(test.name, func(t *testing.T) {
-			guardedWrite(test.confirmRun, 0)
+			regConfirmRun = make(chan int)
 
 			x := new(Tint)
 			*x = (Tint)(test.confirmValue)
@@ -116,17 +100,13 @@ func TestFinalizerRegisterABI(t *testing.T) {
 			runtime.GC()
 			runtime.GC()
 
-			for i := 0; i < 100; i++ {
-				time.Sleep(10 * time.Millisecond)
-				if guardedRead(test.confirmRun) != 0 {
-					break
-				}
-			}
-			v := guardedRead(test.confirmRun)
-			if v == 0 {
+			select {
+			case <-time.After(time.Second):
 				t.Fatal("finalizer failed to execute")
-			} else if v != test.confirmValue {
-				t.Fatalf("wrong finalizer executed? regConfirmRun = %d", v)
+			case gotVal := <-regConfirmRun:
+				if gotVal != test.confirmValue {
+					t.Fatalf("wrong finalizer executed? got %d, want %d", gotVal, test.confirmValue)
+				}
 			}
 		})
 	}
-- 
GitLab


From f08c552dabf4a75739e0f198804ae14368d31105 Mon Sep 17 00:00:00 2001
From: Joshua Harshman <joshgreyhat@gmail.com>
Date: Wed, 27 May 2020 09:54:41 -0600
Subject: [PATCH 1597/2400] net/http: add to deadlines only when positive

The existing implementation allows read / write deadlines to exist
in the past. This updates conditionals to only add to the deadline
when the value is positive.

Fixes: #39177
Change-Id: I841c30ba2849a337e7bc98c8aa136c4527c314ed
Reviewed-on: https://go-review.googlesource.com/c/go/+/235437
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Damien Neil <dneil@google.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Damien Neil <dneil@google.com>
---
 src/net/http/server.go | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/src/net/http/server.go b/src/net/http/server.go
index f095b7edd2..d90418b56d 100644
--- a/src/net/http/server.go
+++ b/src/net/http/server.go
@@ -964,14 +964,14 @@ func (c *conn) readRequest(ctx context.Context) (w *response, err error) {
 		hdrDeadline      time.Time // or zero if none
 	)
 	t0 := time.Now()
-	if d := c.server.readHeaderTimeout(); d != 0 {
+	if d := c.server.readHeaderTimeout(); d > 0 {
 		hdrDeadline = t0.Add(d)
 	}
-	if d := c.server.ReadTimeout; d != 0 {
+	if d := c.server.ReadTimeout; d > 0 {
 		wholeReqDeadline = t0.Add(d)
 	}
 	c.rwc.SetReadDeadline(hdrDeadline)
-	if d := c.server.WriteTimeout; d != 0 {
+	if d := c.server.WriteTimeout; d > 0 {
 		defer func() {
 			c.rwc.SetWriteDeadline(time.Now().Add(d))
 		}()
@@ -1831,10 +1831,10 @@ func (c *conn) serve(ctx context.Context) {
 	}()
 
 	if tlsConn, ok := c.rwc.(*tls.Conn); ok {
-		if d := c.server.ReadTimeout; d != 0 {
+		if d := c.server.ReadTimeout; d > 0 {
 			c.rwc.SetReadDeadline(time.Now().Add(d))
 		}
-		if d := c.server.WriteTimeout; d != 0 {
+		if d := c.server.WriteTimeout; d > 0 {
 			c.rwc.SetWriteDeadline(time.Now().Add(d))
 		}
 		if err := tlsConn.HandshakeContext(ctx); err != nil {
@@ -2567,7 +2567,8 @@ type Server struct {
 	TLSConfig *tls.Config
 
 	// ReadTimeout is the maximum duration for reading the entire
-	// request, including the body.
+	// request, including the body. A zero or negative value means
+	// there will be no timeout.
 	//
 	// Because ReadTimeout does not let Handlers make per-request
 	// decisions on each request body's acceptable deadline or
@@ -2587,6 +2588,7 @@ type Server struct {
 	// writes of the response. It is reset whenever a new
 	// request's header is read. Like ReadTimeout, it does not
 	// let Handlers make decisions on a per-request basis.
+	// A zero or negative value means there will be no timeout.
 	WriteTimeout time.Duration
 
 	// IdleTimeout is the maximum amount of time to wait for the
-- 
GitLab


From cf2396c70e7213570c69ca155203c25c960cc10c Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Wed, 14 Apr 2021 12:35:00 -0400
Subject: [PATCH 1598/2400] internal/goexperiment: move baseline configuration
 to objabi

We need to adjust baseline experiment configuration based on the
configured GOOS and GOARCH, so it can't live in goexperiment. Move it
to objabi.

Change-Id: I65f4ce56902c6c1a82735050773c58f2d1320cc6
Reviewed-on: https://go-review.googlesource.com/c/go/+/310169
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/internal/objabi/exp.go     | 9 +++++++--
 src/internal/goexperiment/flags.go | 8 +++-----
 2 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/src/cmd/internal/objabi/exp.go b/src/cmd/internal/objabi/exp.go
index 5ebbdac772..9eb3e431b3 100644
--- a/src/cmd/internal/objabi/exp.go
+++ b/src/cmd/internal/objabi/exp.go
@@ -20,6 +20,11 @@ import (
 // was built with.)
 var Experiment goexperiment.Flags = parseExperiments()
 
+// experimentBaseline specifies the experiment flags that are enabled by
+// default in the current toolchain. This is, in effect, the "control"
+// configuration and any variation from this is an experiment.
+var experimentBaseline goexperiment.Flags
+
 // FramePointerEnabled enables the use of platform conventions for
 // saving frame pointers.
 //
@@ -31,7 +36,7 @@ var FramePointerEnabled = GOARCH == "amd64" || GOARCH == "arm64"
 
 func parseExperiments() goexperiment.Flags {
 	// Start with the statically enabled set of experiments.
-	flags := goexperiment.BaselineFlags
+	flags := experimentBaseline
 
 	// Pick up any changes to the baseline configuration from the
 	// GOEXPERIMENT environment. This can be set at make.bash time
@@ -135,7 +140,7 @@ func expList(exp, base *goexperiment.Flags) []string {
 // GOEXPERIMENT is exactly what a user would set on the command line
 // to get the set of enabled experiments.
 func GOEXPERIMENT() string {
-	return strings.Join(expList(&Experiment, &goexperiment.BaselineFlags), ",")
+	return strings.Join(expList(&Experiment, &experimentBaseline), ",")
 }
 
 // EnabledExperiments returns a list of enabled experiments, as
diff --git a/src/internal/goexperiment/flags.go b/src/internal/goexperiment/flags.go
index 4803fabe28..932df10ded 100644
--- a/src/internal/goexperiment/flags.go
+++ b/src/internal/goexperiment/flags.go
@@ -41,6 +41,9 @@ package goexperiment
 // When specified in the GOEXPERIMENT environment variable or as build
 // tags, experiments use the strings.ToLower of their field name.
 //
+// For the baseline experimental configuration, see
+// objabi.experimentBaseline.
+//
 // If you change this struct definition, run "go generate".
 type Flags struct {
 	FieldTrack        bool
@@ -78,8 +81,3 @@ type Flags struct {
 	// register arguments to defer/go).
 	RegabiArgs bool
 }
-
-// BaselineFlags specifies the experiment flags that are enabled by
-// default in the current toolchain. This is, in effect, the "control"
-// configuration and any variation from this is an experiment.
-var BaselineFlags = Flags{}
-- 
GitLab


From d26fc68aa10dc8eda5ccdcc80d790e7df2fd9823 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Wed, 14 Apr 2021 13:25:31 -0400
Subject: [PATCH 1599/2400] cmd/internal/objabi,test: use correct GOEXPERIMENT
 build tags in test/run.go

Currently, run.go sets GOEXPERIMENT build tags based on the
*difference* from the baseline experiment configuration, rather than
the absolute experiment configuration. This differs from cmd/go. As a
result, if we set a baseline configuration and don't override it with
a GOEXPERIMENT setting, run.go won't set any GOEXPERIMENT build tags,
instead of setting the tags corresponding to the baseline
configuration.

Fix this by making compile -V=goexperiment produce the full
GOEXPERIMENT configuration, which run.go can then use to set exactly
the right set of build tags.

For #40724.

Change-Id: Ieda6ea62f1a1fabbe8d749d6d09c198fd5ca8377
Reviewed-on: https://go-review.googlesource.com/c/go/+/310171
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/internal/objabi/exp.go  | 11 ++++++-----
 src/cmd/internal/objabi/flag.go | 14 +++++++++----
 test/run.go                     | 35 ++++++++++++++++++---------------
 3 files changed, 35 insertions(+), 25 deletions(-)

diff --git a/src/cmd/internal/objabi/exp.go b/src/cmd/internal/objabi/exp.go
index 9eb3e431b3..3371c6c8f8 100644
--- a/src/cmd/internal/objabi/exp.go
+++ b/src/cmd/internal/objabi/exp.go
@@ -108,8 +108,9 @@ func parseExperiments() goexperiment.Flags {
 
 // expList returns the list of lower-cased experiment names for
 // experiments that differ from base. base may be nil to indicate no
-// experiments.
-func expList(exp, base *goexperiment.Flags) []string {
+// experiments. If all is true, then include all experiment flags,
+// regardless of base.
+func expList(exp, base *goexperiment.Flags, all bool) []string {
 	var list []string
 	rv := reflect.ValueOf(exp).Elem()
 	var rBase reflect.Value
@@ -124,7 +125,7 @@ func expList(exp, base *goexperiment.Flags) []string {
 		if base != nil {
 			baseVal = rBase.Field(i).Bool()
 		}
-		if val != baseVal {
+		if all || val != baseVal {
 			if val {
 				list = append(list, name)
 			} else {
@@ -140,11 +141,11 @@ func expList(exp, base *goexperiment.Flags) []string {
 // GOEXPERIMENT is exactly what a user would set on the command line
 // to get the set of enabled experiments.
 func GOEXPERIMENT() string {
-	return strings.Join(expList(&Experiment, &experimentBaseline), ",")
+	return strings.Join(expList(&Experiment, &experimentBaseline, false), ",")
 }
 
 // EnabledExperiments returns a list of enabled experiments, as
 // lower-cased experiment names.
 func EnabledExperiments() []string {
-	return expList(&Experiment, nil)
+	return expList(&Experiment, nil, false)
 }
diff --git a/src/cmd/internal/objabi/flag.go b/src/cmd/internal/objabi/flag.go
index 6a8a69116d..9fcab4cc85 100644
--- a/src/cmd/internal/objabi/flag.go
+++ b/src/cmd/internal/objabi/flag.go
@@ -93,10 +93,16 @@ func (versionFlag) Set(s string) error {
 
 	p := ""
 
-	// If the enabled experiments differ from the defaults,
-	// include that difference.
-	if goexperiment := GOEXPERIMENT(); goexperiment != "" {
-		p = " X:" + goexperiment
+	if s == "goexperiment" {
+		// test/run.go uses this to discover the full set of
+		// experiment tags. Report everything.
+		p = " X:" + strings.Join(expList(&Experiment, nil, true), ",")
+	} else {
+		// If the enabled experiments differ from the defaults,
+		// include that difference.
+		if goexperiment := GOEXPERIMENT(); goexperiment != "" {
+			p = " X:" + goexperiment
+		}
 	}
 
 	// The go command invokes -V=full to get a unique identifier
diff --git a/test/run.go b/test/run.go
index feab88338c..feec2b50be 100644
--- a/test/run.go
+++ b/test/run.go
@@ -376,6 +376,7 @@ type context struct {
 	GOARCH     string
 	cgoEnabled bool
 	noOptEnv   bool
+	expTags    map[string]bool // Set lazily
 }
 
 // shouldTest looks for build tags in a source file and returns
@@ -445,26 +446,28 @@ func (ctxt *context) match(name string) bool {
 		}
 	}
 
-	exp := os.Getenv("GOEXPERIMENT")
-	if exp == "" {
-		// If GOEXPERIMENT environment variable is unset, get the default value
-		// that is baked into the toolchain.
-		cmd := exec.Command(goTool(), "tool", "compile", "-V")
-		out, err := cmd.CombinedOutput()
-		if err == nil {
+	if strings.HasPrefix(name, "goexperiment.") {
+		// Query goexperiment tags from the toolchain.
+		if ctxt.expTags == nil {
+			ctxt.expTags = make(map[string]bool)
+			cmd := exec.Command(goTool(), "tool", "compile", "-V=goexperiment")
+			out, err := cmd.CombinedOutput()
+			if err != nil {
+				log.Fatalf("failed to get GOEXPERIMENT configuration:\n%s", out)
+			}
 			i := bytes.Index(out, []byte("X:"))
 			if i != -1 {
-				exp = string(out[i+2:])
-			}
-		}
-	}
-	if exp != "" {
-		experiments := strings.Split(exp, ",")
-		for _, e := range experiments {
-			if name == "goexperiment."+e {
-				return true
+				for _, exp := range strings.Split(string(out[i+2:]), ",") {
+					v := true
+					if strings.HasPrefix(exp, "no") {
+						v, exp = false, exp[2:]
+					}
+					ctxt.expTags["goexperiment."+exp] = v
+				}
 			}
 		}
+
+		return ctxt.expTags[name]
 	}
 
 	if name == "cgo" && ctxt.cgoEnabled {
-- 
GitLab


From e1f4feb3d652d90834974608bb1e83d161e88325 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Fri, 16 Apr 2021 10:15:46 +0200
Subject: [PATCH 1600/2400] cmd/link/internal/ld: fix GOARCH in
 TestAbstractOriginSanityIssue25459

There is no x86 GOARCH, this should likely be 386.

Change-Id: I16f1cf5edb0cce156d42ecb621b2ae481c8f1789
Reviewed-on: https://go-review.googlesource.com/c/go/+/308995
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/ld/dwarf_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/link/internal/ld/dwarf_test.go b/src/cmd/link/internal/ld/dwarf_test.go
index 5e4151885a..e845a95359 100644
--- a/src/cmd/link/internal/ld/dwarf_test.go
+++ b/src/cmd/link/internal/ld/dwarf_test.go
@@ -868,8 +868,8 @@ func TestAbstractOriginSanityIssue25459(t *testing.T) {
 	if runtime.GOOS == "solaris" || runtime.GOOS == "illumos" || runtime.GOOS == "darwin" {
 		t.Skip("skipping on solaris, illumos, and darwin, pending resolution of issue #23168")
 	}
-	if runtime.GOARCH != "amd64" && runtime.GOARCH != "x86" {
-		t.Skip("skipping on not-amd64 not-x86; location lists not supported")
+	if runtime.GOARCH != "amd64" && runtime.GOARCH != "386" {
+		t.Skip("skipping on not-amd64 not-386; location lists not supported")
 	}
 
 	if wd, err := os.Getwd(); err == nil {
-- 
GitLab


From c692f752b5b78b919e11f3fccf158bc7dc17920b Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Fri, 16 Apr 2021 10:17:34 +0200
Subject: [PATCH 1601/2400] cmd/link/internal/ld: re-enable tests on darwin

It looks like these are fixed again for darwin on current tip after CL
111258 marked them to be skipped.

Updates #23168

Change-Id: I4abecee1152ccd4f2d44d76d1acdecb0d6140981
Reviewed-on: https://go-review.googlesource.com/c/go/+/308994
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/ld/dwarf_test.go | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/cmd/link/internal/ld/dwarf_test.go b/src/cmd/link/internal/ld/dwarf_test.go
index e845a95359..56dc4753b2 100644
--- a/src/cmd/link/internal/ld/dwarf_test.go
+++ b/src/cmd/link/internal/ld/dwarf_test.go
@@ -610,8 +610,8 @@ func TestInlinedRoutineRecords(t *testing.T) {
 	if runtime.GOOS == "plan9" {
 		t.Skip("skipping on plan9; no DWARF symbol table in executables")
 	}
-	if runtime.GOOS == "solaris" || runtime.GOOS == "illumos" || runtime.GOOS == "darwin" {
-		t.Skip("skipping on solaris, illumos, and darwin, pending resolution of issue #23168")
+	if runtime.GOOS == "solaris" || runtime.GOOS == "illumos" {
+		t.Skip("skipping on solaris, illumos, pending resolution of issue #23168")
 	}
 
 	t.Parallel()
@@ -847,8 +847,8 @@ func TestAbstractOriginSanity(t *testing.T) {
 	if runtime.GOOS == "plan9" {
 		t.Skip("skipping on plan9; no DWARF symbol table in executables")
 	}
-	if runtime.GOOS == "solaris" || runtime.GOOS == "illumos" || runtime.GOOS == "darwin" {
-		t.Skip("skipping on solaris, illumos, and darwin, pending resolution of issue #23168")
+	if runtime.GOOS == "solaris" || runtime.GOOS == "illumos" {
+		t.Skip("skipping on solaris, illumos, pending resolution of issue #23168")
 	}
 
 	if wd, err := os.Getwd(); err == nil {
@@ -865,8 +865,8 @@ func TestAbstractOriginSanityIssue25459(t *testing.T) {
 	if runtime.GOOS == "plan9" {
 		t.Skip("skipping on plan9; no DWARF symbol table in executables")
 	}
-	if runtime.GOOS == "solaris" || runtime.GOOS == "illumos" || runtime.GOOS == "darwin" {
-		t.Skip("skipping on solaris, illumos, and darwin, pending resolution of issue #23168")
+	if runtime.GOOS == "solaris" || runtime.GOOS == "illumos" {
+		t.Skip("skipping on solaris, illumos, pending resolution of issue #23168")
 	}
 	if runtime.GOARCH != "amd64" && runtime.GOARCH != "386" {
 		t.Skip("skipping on not-amd64 not-386; location lists not supported")
@@ -886,8 +886,8 @@ func TestAbstractOriginSanityIssue26237(t *testing.T) {
 	if runtime.GOOS == "plan9" {
 		t.Skip("skipping on plan9; no DWARF symbol table in executables")
 	}
-	if runtime.GOOS == "solaris" || runtime.GOOS == "illumos" || runtime.GOOS == "darwin" {
-		t.Skip("skipping on solaris, illumos, and darwin, pending resolution of issue #23168")
+	if runtime.GOOS == "solaris" || runtime.GOOS == "illumos" {
+		t.Skip("skipping on solaris, illumos, pending resolution of issue #23168")
 	}
 	if wd, err := os.Getwd(); err == nil {
 		gopathdir := filepath.Join(wd, "testdata", "issue26237")
-- 
GitLab


From 52df9291aa72c2db77f6a339b3a99c8a65875a47 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Thu, 15 Apr 2021 17:12:34 -0400
Subject: [PATCH 1602/2400] test/abi: reenable test on windows

Reverses CL 308889.
Fixes #45465.
Updates #40724.

Change-Id: I34b0d396dc34d0ec8c216e9b6a668de9dfce677c
Reviewed-on: https://go-review.googlesource.com/c/go/+/310649
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 test/abi/bad_select_crash.go | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/test/abi/bad_select_crash.go b/test/abi/bad_select_crash.go
index 7786a56a02..58ca463cb8 100644
--- a/test/abi/bad_select_crash.go
+++ b/test/abi/bad_select_crash.go
@@ -1,8 +1,5 @@
 // build -goexperiment regabi,regabiargs
 
-// +build !windows
-//go:build !windows
-
 // Copyright 2021 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.
-- 
GitLab


From cde92846e227425df8258cafade02497a60e421e Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Mon, 12 Apr 2021 16:37:31 -0400
Subject: [PATCH 1603/2400] doc: add release note for module deprecation

Fixes #40357

Change-Id: I876edd7364530b77343ebcdd4032390493f8d031
Reviewed-on: https://go-review.googlesource.com/c/go/+/309549
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 doc/go1.17.html | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 66078b12a9..ef4086d2a5 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -43,6 +43,21 @@ Do not send CLs removing the interior tags from such phrases.
 
 <h3 id="go-command">Go command</h3>
 
+<h4 id="modules">Modules</h4>
+
+<p><!-- golang.org/issue/40357 -->
+  Module authors may deprecate a module by adding a
+  <a href="/ref/mod#go-mod-file-module-deprecation"><code>// Deprecated:</code>
+  comment</a> to <code>go.mod</code>, then tagging a new version.
+  <code>go</code> <code>get</code> now prints a warning if a module needed to
+  build packages named on the command line is deprecated. <code>go</code>
+  <code>list</code> <code>-m</code> <code>-u</code> prints deprecations for all
+  dependencies (use <code>-f</code> or <code>-json</code> to show the full
+  message). The <code>go</code> command considers different major versions to
+  be distinct modules, so this mechanism may be used, for example, to provide
+  users with migration instructions for a new major version.
+</p>
+
 <h4 id="go-get"><code>go</code> <code>get</code></h4>
 
 <p><!-- golang.org/issue/37519 -->
-- 
GitLab


From dc76c4756599ac4bd9644e407aa2af9f9c8a3bdc Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Thu, 15 Apr 2021 18:06:45 -0400
Subject: [PATCH 1604/2400] cmd/go/internal/load: convert two global flags to
 an options struct

PackageOpts is a new struct type accepted by package loading
functions. It initially has two fields: IgnoreImports, and
ModResolveTests. Previously, these were global variables set by
clients. We'll add more to this in the future.

For #40775

Change-Id: I6956e56502de836d3815ce788bdf16fc5f3e5338
Reviewed-on: https://go-review.googlesource.com/c/go/+/310669
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go/internal/clean/clean.go       |  2 +-
 src/cmd/go/internal/fix/fix.go           |  2 +-
 src/cmd/go/internal/fmtcmd/fmt.go        |  2 +-
 src/cmd/go/internal/generate/generate.go |  5 +-
 src/cmd/go/internal/get/get.go           |  6 +-
 src/cmd/go/internal/list/list.go         | 12 ++--
 src/cmd/go/internal/load/pkg.go          | 88 ++++++++++++------------
 src/cmd/go/internal/load/test.go         | 14 ++--
 src/cmd/go/internal/modget/get.go        |  4 +-
 src/cmd/go/internal/run/run.go           |  4 +-
 src/cmd/go/internal/test/test.go         | 15 ++--
 src/cmd/go/internal/vet/vet.go           |  7 +-
 src/cmd/go/internal/work/build.go        |  6 +-
 src/cmd/go/internal/work/exec.go         |  2 +-
 14 files changed, 85 insertions(+), 84 deletions(-)

diff --git a/src/cmd/go/internal/clean/clean.go b/src/cmd/go/internal/clean/clean.go
index b1d40feb27..fd4cb20559 100644
--- a/src/cmd/go/internal/clean/clean.go
+++ b/src/cmd/go/internal/clean/clean.go
@@ -117,7 +117,7 @@ func runClean(ctx context.Context, cmd *base.Command, args []string) {
 	}
 
 	if cleanPkg {
-		for _, pkg := range load.PackagesAndErrors(ctx, args) {
+		for _, pkg := range load.PackagesAndErrors(ctx, load.PackageOpts{}, args) {
 			clean(pkg)
 		}
 	}
diff --git a/src/cmd/go/internal/fix/fix.go b/src/cmd/go/internal/fix/fix.go
index c7588c66d3..988d45e71c 100644
--- a/src/cmd/go/internal/fix/fix.go
+++ b/src/cmd/go/internal/fix/fix.go
@@ -33,7 +33,7 @@ See also: go fmt, go vet.
 }
 
 func runFix(ctx context.Context, cmd *base.Command, args []string) {
-	pkgs := load.PackagesAndErrors(ctx, args)
+	pkgs := load.PackagesAndErrors(ctx, load.PackageOpts{}, args)
 	w := 0
 	for _, pkg := range pkgs {
 		if pkg.Error != nil {
diff --git a/src/cmd/go/internal/fmtcmd/fmt.go b/src/cmd/go/internal/fmtcmd/fmt.go
index 6b98f0ccd3..8a04008753 100644
--- a/src/cmd/go/internal/fmtcmd/fmt.go
+++ b/src/cmd/go/internal/fmtcmd/fmt.go
@@ -65,7 +65,7 @@ func runFmt(ctx context.Context, cmd *base.Command, args []string) {
 			}
 		}()
 	}
-	for _, pkg := range load.PackagesAndErrors(ctx, args) {
+	for _, pkg := range load.PackagesAndErrors(ctx, load.PackageOpts{}, args) {
 		if modload.Enabled() && pkg.Module != nil && !pkg.Module.Main {
 			if !printed {
 				fmt.Fprintf(os.Stderr, "go: not formatting packages in dependency modules\n")
diff --git a/src/cmd/go/internal/generate/generate.go b/src/cmd/go/internal/generate/generate.go
index 97df229b31..80ea32b428 100644
--- a/src/cmd/go/internal/generate/generate.go
+++ b/src/cmd/go/internal/generate/generate.go
@@ -161,8 +161,6 @@ func init() {
 }
 
 func runGenerate(ctx context.Context, cmd *base.Command, args []string) {
-	load.IgnoreImports = true
-
 	if generateRunFlag != "" {
 		var err error
 		generateRunRE, err = regexp.Compile(generateRunFlag)
@@ -175,7 +173,8 @@ func runGenerate(ctx context.Context, cmd *base.Command, args []string) {
 
 	// Even if the arguments are .go files, this loop suffices.
 	printed := false
-	for _, pkg := range load.PackagesAndErrors(ctx, args) {
+	pkgOpts := load.PackageOpts{IgnoreImports: true}
+	for _, pkg := range load.PackagesAndErrors(ctx, pkgOpts, args) {
 		if modload.Enabled() && pkg.Module != nil && !pkg.Module.Main {
 			if !printed {
 				fmt.Fprintf(os.Stderr, "go: not generating in packages in dependency modules\n")
diff --git a/src/cmd/go/internal/get/get.go b/src/cmd/go/internal/get/get.go
index 10eda1275e..4c57ee3518 100644
--- a/src/cmd/go/internal/get/get.go
+++ b/src/cmd/go/internal/get/get.go
@@ -173,7 +173,7 @@ func runGet(ctx context.Context, cmd *base.Command, args []string) {
 	// everything.
 	load.ClearPackageCache()
 
-	pkgs := load.PackagesAndErrors(ctx, args)
+	pkgs := load.PackagesAndErrors(ctx, load.PackageOpts{}, args)
 	load.CheckPackageErrors(pkgs)
 
 	// Phase 3. Install.
@@ -248,9 +248,9 @@ func download(arg string, parent *load.Package, stk *load.ImportStack, mode int)
 	load1 := func(path string, mode int) *load.Package {
 		if parent == nil {
 			mode := 0 // don't do module or vendor resolution
-			return load.LoadImport(context.TODO(), path, base.Cwd, nil, stk, nil, mode)
+			return load.LoadImport(context.TODO(), load.PackageOpts{}, path, base.Cwd, nil, stk, nil, mode)
 		}
-		return load.LoadImport(context.TODO(), path, parent.Dir, parent, stk, nil, mode|load.ResolveModule)
+		return load.LoadImport(context.TODO(), load.PackageOpts{}, path, parent.Dir, parent, stk, nil, mode|load.ResolveModule)
 	}
 
 	p := load1(arg, mode)
diff --git a/src/cmd/go/internal/list/list.go b/src/cmd/go/internal/list/list.go
index 9b78a64d5f..221370bd19 100644
--- a/src/cmd/go/internal/list/list.go
+++ b/src/cmd/go/internal/list/list.go
@@ -339,7 +339,6 @@ func runList(ctx context.Context, cmd *base.Command, args []string) {
 		base.Fatalf("go list -f cannot be used with -json")
 	}
 
-	load.ModResolveTests = *listTest
 	work.BuildInit()
 	out := newTrackingWriter(os.Stdout)
 	defer out.w.Flush()
@@ -498,8 +497,11 @@ func runList(ctx context.Context, cmd *base.Command, args []string) {
 		base.Fatalf("go list -test cannot be used with -find")
 	}
 
-	load.IgnoreImports = *listFind
-	pkgs := load.PackagesAndErrors(ctx, args)
+	pkgOpts := load.PackageOpts{
+		IgnoreImports:   *listFind,
+		ModResolveTests: *listTest,
+	}
+	pkgs := load.PackagesAndErrors(ctx, pkgOpts, args)
 	if !*listE {
 		w := 0
 		for _, pkg := range pkgs {
@@ -536,9 +538,9 @@ func runList(ctx context.Context, cmd *base.Command, args []string) {
 				var pmain, ptest, pxtest *load.Package
 				var err error
 				if *listE {
-					pmain, ptest, pxtest = load.TestPackagesAndErrors(ctx, p, nil)
+					pmain, ptest, pxtest = load.TestPackagesAndErrors(ctx, pkgOpts, p, nil)
 				} else {
-					pmain, ptest, pxtest, err = load.TestPackagesFor(ctx, p, nil)
+					pmain, ptest, pxtest, err = load.TestPackagesFor(ctx, pkgOpts, p, nil)
 					if err != nil {
 						base.Errorf("can't load test package: %s", err)
 					}
diff --git a/src/cmd/go/internal/load/pkg.go b/src/cmd/go/internal/load/pkg.go
index 00c50bf38f..8a74930209 100644
--- a/src/cmd/go/internal/load/pkg.go
+++ b/src/cmd/go/internal/load/pkg.go
@@ -41,8 +41,6 @@ import (
 	"golang.org/x/mod/module"
 )
 
-var IgnoreImports bool // control whether we ignore imports in packages
-
 // A Package describes a single package found in a directory.
 type Package struct {
 	PackagePublic                 // visible in 'go list'
@@ -345,7 +343,7 @@ type CoverVar struct {
 	Var  string // name of count struct
 }
 
-func (p *Package) copyBuild(pp *build.Package) {
+func (p *Package) copyBuild(opts PackageOpts, pp *build.Package) {
 	p.Internal.Build = pp
 
 	if pp.PkgTargetRoot != "" && cfg.BuildPkgdir != "" {
@@ -394,7 +392,7 @@ func (p *Package) copyBuild(pp *build.Package) {
 	p.TestImports = pp.TestImports
 	p.XTestGoFiles = pp.XTestGoFiles
 	p.XTestImports = pp.XTestImports
-	if IgnoreImports {
+	if opts.IgnoreImports {
 		p.Imports = nil
 		p.Internal.RawImports = nil
 		p.TestImports = nil
@@ -601,7 +599,7 @@ func ReloadPackageNoFlags(arg string, stk *ImportStack) *Package {
 		})
 		packageDataCache.Delete(p.ImportPath)
 	}
-	return LoadImport(context.TODO(), arg, base.Cwd, nil, stk, nil, 0)
+	return LoadImport(context.TODO(), PackageOpts{}, arg, base.Cwd, nil, stk, nil, 0)
 }
 
 // dirToImportPath returns the pseudo-import path we use for a package
@@ -653,11 +651,11 @@ const (
 // LoadImport does not set tool flags and should only be used by
 // this package, as part of a bigger load operation, and by GOPATH-based "go get".
 // TODO(rsc): When GOPATH-based "go get" is removed, unexport this function.
-func LoadImport(ctx context.Context, path, srcDir string, parent *Package, stk *ImportStack, importPos []token.Position, mode int) *Package {
-	return loadImport(ctx, nil, path, srcDir, parent, stk, importPos, mode)
+func LoadImport(ctx context.Context, opts PackageOpts, path, srcDir string, parent *Package, stk *ImportStack, importPos []token.Position, mode int) *Package {
+	return loadImport(ctx, opts, nil, path, srcDir, parent, stk, importPos, mode)
 }
 
-func loadImport(ctx context.Context, pre *preload, path, srcDir string, parent *Package, stk *ImportStack, importPos []token.Position, mode int) *Package {
+func loadImport(ctx context.Context, opts PackageOpts, pre *preload, path, srcDir string, parent *Package, stk *ImportStack, importPos []token.Position, mode int) *Package {
 	if path == "" {
 		panic("LoadImport called with empty package path")
 	}
@@ -670,8 +668,8 @@ func loadImport(ctx context.Context, pre *preload, path, srcDir string, parent *
 		parentIsStd = parent.Standard
 	}
 	bp, loaded, err := loadPackageData(ctx, path, parentPath, srcDir, parentRoot, parentIsStd, mode)
-	if loaded && pre != nil && !IgnoreImports {
-		pre.preloadImports(ctx, bp.Imports, bp)
+	if loaded && pre != nil && !opts.IgnoreImports {
+		pre.preloadImports(ctx, opts, bp.Imports, bp)
 	}
 	if bp == nil {
 		p := &Package{
@@ -710,7 +708,7 @@ func loadImport(ctx context.Context, pre *preload, path, srcDir string, parent *
 		// Load package.
 		// loadPackageData may return bp != nil even if an error occurs,
 		// in order to return partial information.
-		p.load(ctx, path, stk, importPos, bp, err)
+		p.load(ctx, opts, path, stk, importPos, bp, err)
 
 		if !cfg.ModulesEnabled && path != cleanImport(path) {
 			p.Error = &PackageError{
@@ -980,7 +978,7 @@ func newPreload() *preload {
 // preloadMatches loads data for package paths matched by patterns.
 // When preloadMatches returns, some packages may not be loaded yet, but
 // loadPackageData and loadImport are always safe to call.
-func (pre *preload) preloadMatches(ctx context.Context, matches []*search.Match) {
+func (pre *preload) preloadMatches(ctx context.Context, opts PackageOpts, matches []*search.Match) {
 	for _, m := range matches {
 		for _, pkg := range m.Pkgs {
 			select {
@@ -991,8 +989,8 @@ func (pre *preload) preloadMatches(ctx context.Context, matches []*search.Match)
 					mode := 0 // don't use vendoring or module import resolution
 					bp, loaded, err := loadPackageData(ctx, pkg, "", base.Cwd, "", false, mode)
 					<-pre.sema
-					if bp != nil && loaded && err == nil && !IgnoreImports {
-						pre.preloadImports(ctx, bp.Imports, bp)
+					if bp != nil && loaded && err == nil && !opts.IgnoreImports {
+						pre.preloadImports(ctx, opts, bp.Imports, bp)
 					}
 				}(pkg)
 			}
@@ -1003,7 +1001,7 @@ func (pre *preload) preloadMatches(ctx context.Context, matches []*search.Match)
 // preloadImports queues a list of imports for preloading.
 // When preloadImports returns, some packages may not be loaded yet,
 // but loadPackageData and loadImport are always safe to call.
-func (pre *preload) preloadImports(ctx context.Context, imports []string, parent *build.Package) {
+func (pre *preload) preloadImports(ctx context.Context, opts PackageOpts, imports []string, parent *build.Package) {
 	parentIsStd := parent.Goroot && parent.ImportPath != "" && search.IsStandardImportPath(parent.ImportPath)
 	for _, path := range imports {
 		if path == "C" || path == "unsafe" {
@@ -1016,8 +1014,8 @@ func (pre *preload) preloadImports(ctx context.Context, imports []string, parent
 			go func(path string) {
 				bp, loaded, err := loadPackageData(ctx, path, parent.ImportPath, parent.Dir, parent.Root, parentIsStd, ResolveImport)
 				<-pre.sema
-				if bp != nil && loaded && err == nil && !IgnoreImports {
-					pre.preloadImports(ctx, bp.Imports, bp)
+				if bp != nil && loaded && err == nil && !opts.IgnoreImports {
+					pre.preloadImports(ctx, opts, bp.Imports, bp)
 				}
 			}(path)
 		}
@@ -1667,8 +1665,8 @@ func (p *Package) DefaultExecName() string {
 // load populates p using information from bp, err, which should
 // be the result of calling build.Context.Import.
 // stk contains the import stack, not including path itself.
-func (p *Package) load(ctx context.Context, path string, stk *ImportStack, importPos []token.Position, bp *build.Package, err error) {
-	p.copyBuild(bp)
+func (p *Package) load(ctx context.Context, opts PackageOpts, path string, stk *ImportStack, importPos []token.Position, bp *build.Package, err error) {
+	p.copyBuild(opts, bp)
 
 	// The localPrefix is the path we interpret ./ imports relative to.
 	// Synthesized main packages sometimes override this.
@@ -1887,7 +1885,7 @@ func (p *Package) load(ctx context.Context, path string, stk *ImportStack, impor
 		if path == "C" {
 			continue
 		}
-		p1 := LoadImport(ctx, path, p.Dir, p, stk, p.Internal.Build.ImportPos[path], ResolveImport)
+		p1 := LoadImport(ctx, opts, path, p.Dir, p, stk, p.Internal.Build.ImportPos[path], ResolveImport)
 
 		path = p1.ImportPath
 		importPaths[i] = path
@@ -2334,7 +2332,7 @@ func PackageList(roots []*Package) []*Package {
 // TestPackageList returns the list of packages in the dag rooted at roots
 // as visited in a depth-first post-order traversal, including the test
 // imports of the roots. This ignores errors in test packages.
-func TestPackageList(ctx context.Context, roots []*Package) []*Package {
+func TestPackageList(ctx context.Context, opts PackageOpts, roots []*Package) []*Package {
 	seen := map[*Package]bool{}
 	all := []*Package{}
 	var walk func(*Package)
@@ -2350,7 +2348,7 @@ func TestPackageList(ctx context.Context, roots []*Package) []*Package {
 	}
 	walkTest := func(root *Package, path string) {
 		var stk ImportStack
-		p1 := LoadImport(ctx, path, root.Dir, root, &stk, root.Internal.Build.TestImportPos[path], ResolveImport)
+		p1 := LoadImport(ctx, opts, path, root.Dir, root, &stk, root.Internal.Build.TestImportPos[path], ResolveImport)
 		if p1.Error == nil {
 			walk(p1)
 		}
@@ -2373,22 +2371,26 @@ func TestPackageList(ctx context.Context, roots []*Package) []*Package {
 // TODO(jayconrod): delete this function and set flags automatically
 // in LoadImport instead.
 func LoadImportWithFlags(path, srcDir string, parent *Package, stk *ImportStack, importPos []token.Position, mode int) *Package {
-	p := LoadImport(context.TODO(), path, srcDir, parent, stk, importPos, mode)
+	p := LoadImport(context.TODO(), PackageOpts{}, path, srcDir, parent, stk, importPos, mode)
 	setToolFlags(p)
 	return p
 }
 
-// ModResolveTests indicates whether calls to the module loader should also
-// resolve test dependencies of the requested packages.
-//
-// If ModResolveTests is true, then the module loader needs to resolve test
-// dependencies at the same time as packages; otherwise, the test dependencies
-// of those packages could be missing, and resolving those missing dependencies
-// could change the selected versions of modules that provide other packages.
-//
-// TODO(#40775): Change this from a global variable to an explicit function
-// argument where needed.
-var ModResolveTests bool
+// PackageOpts control the behavior of PackagesAndErrors and other package
+// loading functions.
+type PackageOpts struct {
+	// IgnoreImports controls whether we ignore imports when loading packages.
+	IgnoreImports bool
+
+	// ModResolveTests indicates whether calls to the module loader should also
+	// resolve test dependencies of the requested packages.
+	//
+	// If ModResolveTests is true, then the module loader needs to resolve test
+	// dependencies at the same time as packages; otherwise, the test dependencies
+	// of those packages could be missing, and resolving those missing dependencies
+	// could change the selected versions of modules that provide other packages.
+	ModResolveTests bool
+}
 
 // PackagesAndErrors returns the packages named by the command line arguments
 // 'patterns'. If a named package cannot be loaded, PackagesAndErrors returns
@@ -2398,7 +2400,7 @@ var ModResolveTests bool
 //
 // To obtain a flat list of packages, use PackageList.
 // To report errors loading packages, use ReportPackageErrors.
-func PackagesAndErrors(ctx context.Context, patterns []string) []*Package {
+func PackagesAndErrors(ctx context.Context, opts PackageOpts, patterns []string) []*Package {
 	ctx, span := trace.StartSpan(ctx, "load.PackagesAndErrors")
 	defer span.Done()
 
@@ -2410,19 +2412,19 @@ func PackagesAndErrors(ctx context.Context, patterns []string) []*Package {
 			// We need to test whether the path is an actual Go file and not a
 			// package path or pattern ending in '.go' (see golang.org/issue/34653).
 			if fi, err := fsys.Stat(p); err == nil && !fi.IsDir() {
-				return []*Package{GoFilesPackage(ctx, patterns)}
+				return []*Package{GoFilesPackage(ctx, opts, patterns)}
 			}
 		}
 	}
 
 	var matches []*search.Match
 	if modload.Init(); cfg.ModulesEnabled {
-		loadOpts := modload.PackageOpts{
+		modOpts := modload.PackageOpts{
 			ResolveMissingImports: true,
-			LoadTests:             ModResolveTests,
+			LoadTests:             opts.ModResolveTests,
 			SilenceErrors:         true,
 		}
-		matches, _ = modload.LoadPackages(ctx, loadOpts, patterns...)
+		matches, _ = modload.LoadPackages(ctx, modOpts, patterns...)
 	} else {
 		matches = search.ImportPaths(patterns)
 	}
@@ -2435,14 +2437,14 @@ func PackagesAndErrors(ctx context.Context, patterns []string) []*Package {
 
 	pre := newPreload()
 	defer pre.flush()
-	pre.preloadMatches(ctx, matches)
+	pre.preloadMatches(ctx, opts, matches)
 
 	for _, m := range matches {
 		for _, pkg := range m.Pkgs {
 			if pkg == "" {
 				panic(fmt.Sprintf("ImportPaths returned empty package for pattern %s", m.Pattern()))
 			}
-			p := loadImport(ctx, pre, pkg, base.Cwd, nil, &stk, nil, 0)
+			p := loadImport(ctx, opts, pre, pkg, base.Cwd, nil, &stk, nil, 0)
 			p.Match = append(p.Match, m.Pattern())
 			p.Internal.CmdlinePkg = true
 			if m.IsLiteral() {
@@ -2538,7 +2540,7 @@ func setToolFlags(pkgs ...*Package) {
 // GoFilesPackage creates a package for building a collection of Go files
 // (typically named on the command line). The target is named p.a for
 // package p or named after the first Go file for package main.
-func GoFilesPackage(ctx context.Context, gofiles []string) *Package {
+func GoFilesPackage(ctx context.Context, opts PackageOpts, gofiles []string) *Package {
 	modload.Init()
 
 	for _, f := range gofiles {
@@ -2602,7 +2604,7 @@ func GoFilesPackage(ctx context.Context, gofiles []string) *Package {
 	pkg := new(Package)
 	pkg.Internal.Local = true
 	pkg.Internal.CmdlineFiles = true
-	pkg.load(ctx, "command-line-arguments", &stk, nil, bp, err)
+	pkg.load(ctx, opts, "command-line-arguments", &stk, nil, bp, err)
 	pkg.Internal.LocalPrefix = dirToImportPath(dir)
 	pkg.ImportPath = "command-line-arguments"
 	pkg.Target = ""
diff --git a/src/cmd/go/internal/load/test.go b/src/cmd/go/internal/load/test.go
index 9385f41182..6baa1db14f 100644
--- a/src/cmd/go/internal/load/test.go
+++ b/src/cmd/go/internal/load/test.go
@@ -46,8 +46,8 @@ type TestCover struct {
 // TestPackagesFor is like TestPackagesAndErrors but it returns
 // an error if the test packages or their dependencies have errors.
 // Only test packages without errors are returned.
-func TestPackagesFor(ctx context.Context, p *Package, cover *TestCover) (pmain, ptest, pxtest *Package, err error) {
-	pmain, ptest, pxtest = TestPackagesAndErrors(ctx, p, cover)
+func TestPackagesFor(ctx context.Context, opts PackageOpts, p *Package, cover *TestCover) (pmain, ptest, pxtest *Package, err error) {
+	pmain, ptest, pxtest = TestPackagesAndErrors(ctx, opts, p, cover)
 	for _, p1 := range []*Package{ptest, pxtest, pmain} {
 		if p1 == nil {
 			// pxtest may be nil
@@ -93,7 +93,7 @@ func TestPackagesFor(ctx context.Context, p *Package, cover *TestCover) (pmain,
 //
 // The caller is expected to have checked that len(p.TestGoFiles)+len(p.XTestGoFiles) > 0,
 // or else there's no point in any of this.
-func TestPackagesAndErrors(ctx context.Context, p *Package, cover *TestCover) (pmain, ptest, pxtest *Package) {
+func TestPackagesAndErrors(ctx context.Context, opts PackageOpts, p *Package, cover *TestCover) (pmain, ptest, pxtest *Package) {
 	ctx, span := trace.StartSpan(ctx, "load.TestPackagesAndErrors")
 	defer span.Done()
 
@@ -101,7 +101,7 @@ func TestPackagesAndErrors(ctx context.Context, p *Package, cover *TestCover) (p
 	defer pre.flush()
 	allImports := append([]string{}, p.TestImports...)
 	allImports = append(allImports, p.XTestImports...)
-	pre.preloadImports(ctx, allImports, p.Internal.Build)
+	pre.preloadImports(ctx, opts, allImports, p.Internal.Build)
 
 	var ptestErr, pxtestErr *PackageError
 	var imports, ximports []*Package
@@ -110,7 +110,7 @@ func TestPackagesAndErrors(ctx context.Context, p *Package, cover *TestCover) (p
 	stk.Push(p.ImportPath + " (test)")
 	rawTestImports := str.StringList(p.TestImports)
 	for i, path := range p.TestImports {
-		p1 := loadImport(ctx, pre, path, p.Dir, p, &stk, p.Internal.Build.TestImportPos[path], ResolveImport)
+		p1 := loadImport(ctx, opts, pre, path, p.Dir, p, &stk, p.Internal.Build.TestImportPos[path], ResolveImport)
 		if str.Contains(p1.Deps, p.ImportPath) || p1.ImportPath == p.ImportPath {
 			// Same error that loadPackage returns (via reusePackage) in pkg.go.
 			// Can't change that code, because that code is only for loading the
@@ -140,7 +140,7 @@ func TestPackagesAndErrors(ctx context.Context, p *Package, cover *TestCover) (p
 	pxtestNeedsPtest := false
 	rawXTestImports := str.StringList(p.XTestImports)
 	for i, path := range p.XTestImports {
-		p1 := loadImport(ctx, pre, path, p.Dir, p, &stk, p.Internal.Build.XTestImportPos[path], ResolveImport)
+		p1 := loadImport(ctx, opts, pre, path, p.Dir, p, &stk, p.Internal.Build.XTestImportPos[path], ResolveImport)
 		if p1.ImportPath == p.ImportPath {
 			pxtestNeedsPtest = true
 		} else {
@@ -281,7 +281,7 @@ func TestPackagesAndErrors(ctx context.Context, p *Package, cover *TestCover) (p
 		if dep == ptest.ImportPath {
 			pmain.Internal.Imports = append(pmain.Internal.Imports, ptest)
 		} else {
-			p1 := loadImport(ctx, pre, dep, "", nil, &stk, nil, 0)
+			p1 := loadImport(ctx, opts, pre, dep, "", nil, &stk, nil, 0)
 			pmain.Internal.Imports = append(pmain.Internal.Imports, p1)
 		}
 	}
diff --git a/src/cmd/go/internal/modget/get.go b/src/cmd/go/internal/modget/get.go
index 876d8ab24d..7e6226b0be 100644
--- a/src/cmd/go/internal/modget/get.go
+++ b/src/cmd/go/internal/modget/get.go
@@ -276,7 +276,6 @@ func runGet(ctx context.Context, cmd *base.Command, args []string) {
 	if *getInsecure {
 		base.Fatalf("go get: -insecure flag is no longer supported; use GOINSECURE instead")
 	}
-	load.ModResolveTests = *getT
 
 	// Do not allow any updating of go.mod until we've applied
 	// all the requested changes and checked that the result matches
@@ -368,8 +367,9 @@ func runGet(ctx context.Context, cmd *base.Command, args []string) {
 	if !*getD && len(pkgPatterns) > 0 {
 		work.BuildInit()
 
+		pkgOpts := load.PackageOpts{ModResolveTests: *getT}
 		var pkgs []*load.Package
-		for _, pkg := range load.PackagesAndErrors(ctx, pkgPatterns) {
+		for _, pkg := range load.PackagesAndErrors(ctx, pkgOpts, pkgPatterns) {
 			if pkg.Error != nil {
 				var noGo *load.NoGoError
 				if errors.As(pkg.Error.Err, &noGo) {
diff --git a/src/cmd/go/internal/run/run.go b/src/cmd/go/internal/run/run.go
index 666b1a0e56..f0137c20c1 100644
--- a/src/cmd/go/internal/run/run.go
+++ b/src/cmd/go/internal/run/run.go
@@ -77,9 +77,9 @@ func runRun(ctx context.Context, cmd *base.Command, args []string) {
 				base.Fatalf("go run: cannot run *_test.go files (%s)", file)
 			}
 		}
-		p = load.GoFilesPackage(ctx, files)
+		p = load.GoFilesPackage(ctx, load.PackageOpts{}, files)
 	} else if len(args) > 0 && !strings.HasPrefix(args[0], "-") {
-		pkgs := load.PackagesAndErrors(ctx, args[:1])
+		pkgs := load.PackagesAndErrors(ctx, load.PackageOpts{}, args[:1])
 		if len(pkgs) == 0 {
 			base.Fatalf("go run: no packages loaded from %s", args[0])
 		}
diff --git a/src/cmd/go/internal/test/test.go b/src/cmd/go/internal/test/test.go
index ebe13205f7..847b9357b4 100644
--- a/src/cmd/go/internal/test/test.go
+++ b/src/cmd/go/internal/test/test.go
@@ -569,8 +569,6 @@ var defaultVetFlags = []string{
 }
 
 func runTest(ctx context.Context, cmd *base.Command, args []string) {
-	load.ModResolveTests = true
-
 	pkgArgs, testArgs = testFlags(args)
 
 	if cfg.DebugTrace != "" {
@@ -596,7 +594,8 @@ func runTest(ctx context.Context, cmd *base.Command, args []string) {
 	work.VetFlags = testVet.flags
 	work.VetExplicit = testVet.explicit
 
-	pkgs = load.PackagesAndErrors(ctx, pkgArgs)
+	pkgOpts := load.PackageOpts{ModResolveTests: true}
+	pkgs = load.PackagesAndErrors(ctx, pkgOpts, pkgArgs)
 	load.CheckPackageErrors(pkgs)
 	if len(pkgs) == 0 {
 		base.Fatalf("no packages to test")
@@ -680,7 +679,7 @@ func runTest(ctx context.Context, cmd *base.Command, args []string) {
 		sort.Strings(all)
 
 		a := &work.Action{Mode: "go test -i"}
-		pkgs := load.PackagesAndErrors(ctx, all)
+		pkgs := load.PackagesAndErrors(ctx, pkgOpts, all)
 		load.CheckPackageErrors(pkgs)
 		for _, p := range pkgs {
 			if cfg.BuildToolchainName == "gccgo" && p.Standard {
@@ -707,7 +706,7 @@ func runTest(ctx context.Context, cmd *base.Command, args []string) {
 		}
 
 		// Select for coverage all dependencies matching the testCoverPaths patterns.
-		for _, p := range load.TestPackageList(ctx, pkgs) {
+		for _, p := range load.TestPackageList(ctx, pkgOpts, pkgs) {
 			haveMatch := false
 			for i := range testCoverPaths {
 				if match[i](p) {
@@ -775,7 +774,7 @@ func runTest(ctx context.Context, cmd *base.Command, args []string) {
 			ensureImport(p, "sync/atomic")
 		}
 
-		buildTest, runTest, printTest, err := builderTest(&b, ctx, p)
+		buildTest, runTest, printTest, err := builderTest(&b, ctx, pkgOpts, p)
 		if err != nil {
 			str := err.Error()
 			str = strings.TrimPrefix(str, "\n")
@@ -842,7 +841,7 @@ var windowsBadWords = []string{
 	"update",
 }
 
-func builderTest(b *work.Builder, ctx context.Context, p *load.Package) (buildAction, runAction, printAction *work.Action, err error) {
+func builderTest(b *work.Builder, ctx context.Context, pkgOpts load.PackageOpts, p *load.Package) (buildAction, runAction, printAction *work.Action, err error) {
 	if len(p.TestGoFiles)+len(p.XTestGoFiles) == 0 {
 		build := b.CompileAction(work.ModeBuild, work.ModeBuild, p)
 		run := &work.Action{Mode: "test run", Package: p, Deps: []*work.Action{build}}
@@ -865,7 +864,7 @@ func builderTest(b *work.Builder, ctx context.Context, p *load.Package) (buildAc
 			DeclVars: declareCoverVars,
 		}
 	}
-	pmain, ptest, pxtest, err := load.TestPackagesFor(ctx, p, cover)
+	pmain, ptest, pxtest, err := load.TestPackagesFor(ctx, pkgOpts, p, cover)
 	if err != nil {
 		return nil, nil, nil, err
 	}
diff --git a/src/cmd/go/internal/vet/vet.go b/src/cmd/go/internal/vet/vet.go
index 4257c90c97..1d419dddb9 100644
--- a/src/cmd/go/internal/vet/vet.go
+++ b/src/cmd/go/internal/vet/vet.go
@@ -53,8 +53,6 @@ See also: go fmt, go fix.
 }
 
 func runVet(ctx context.Context, cmd *base.Command, args []string) {
-	load.ModResolveTests = true
-
 	vetFlags, pkgArgs := vetFlags(args)
 
 	if cfg.DebugTrace != "" {
@@ -87,7 +85,8 @@ func runVet(ctx context.Context, cmd *base.Command, args []string) {
 		}
 	}
 
-	pkgs := load.PackagesAndErrors(ctx, pkgArgs)
+	pkgOpts := load.PackageOpts{ModResolveTests: true}
+	pkgs := load.PackagesAndErrors(ctx, pkgOpts, pkgArgs)
 	load.CheckPackageErrors(pkgs)
 	if len(pkgs) == 0 {
 		base.Fatalf("no packages to vet")
@@ -98,7 +97,7 @@ func runVet(ctx context.Context, cmd *base.Command, args []string) {
 
 	root := &work.Action{Mode: "go vet"}
 	for _, p := range pkgs {
-		_, ptest, pxtest, err := load.TestPackagesFor(ctx, p, nil)
+		_, ptest, pxtest, err := load.TestPackagesFor(ctx, pkgOpts, p, nil)
 		if err != nil {
 			base.Errorf("%v", err)
 			continue
diff --git a/src/cmd/go/internal/work/build.go b/src/cmd/go/internal/work/build.go
index ad3a118510..dcb9e3785c 100644
--- a/src/cmd/go/internal/work/build.go
+++ b/src/cmd/go/internal/work/build.go
@@ -372,7 +372,7 @@ func runBuild(ctx context.Context, cmd *base.Command, args []string) {
 	var b Builder
 	b.Init()
 
-	pkgs := load.PackagesAndErrors(ctx, args)
+	pkgs := load.PackagesAndErrors(ctx, load.PackageOpts{}, args)
 	load.CheckPackageErrors(pkgs)
 
 	explicitO := len(cfg.BuildO) > 0
@@ -592,7 +592,7 @@ func runInstall(ctx context.Context, cmd *base.Command, args []string) {
 	}
 
 	BuildInit()
-	pkgs := load.PackagesAndErrors(ctx, args)
+	pkgs := load.PackagesAndErrors(ctx, load.PackageOpts{}, args)
 	if cfg.ModulesEnabled && !modload.HasModRoot() {
 		haveErrors := false
 		allMissingErrors := true
@@ -857,7 +857,7 @@ func installOutsideModule(ctx context.Context, args []string) {
 
 	// TODO(golang.org/issue/40276): don't report errors loading non-main packages
 	// matched by a pattern.
-	pkgs := load.PackagesAndErrors(ctx, patterns)
+	pkgs := load.PackagesAndErrors(ctx, load.PackageOpts{}, patterns)
 	load.CheckPackageErrors(pkgs)
 	mainPkgs := make([]*load.Package, 0, len(pkgs))
 	mainCount := make([]int, len(patterns))
diff --git a/src/cmd/go/internal/work/exec.go b/src/cmd/go/internal/work/exec.go
index f692f386f5..e1916007a6 100644
--- a/src/cmd/go/internal/work/exec.go
+++ b/src/cmd/go/internal/work/exec.go
@@ -3105,7 +3105,7 @@ func (b *Builder) swigDoIntSize(objdir string) (intsize string, err error) {
 	}
 	srcs := []string{src}
 
-	p := load.GoFilesPackage(context.TODO(), srcs)
+	p := load.GoFilesPackage(context.TODO(), load.PackageOpts{}, srcs)
 
 	if _, _, e := BuildToolchain.gc(b, &Action{Mode: "swigDoIntSize", Package: p, Objdir: objdir}, "", nil, nil, "", false, srcs); e != nil {
 		return "32", nil
-- 
GitLab


From 0613c748e8919536c360cfc9be4e63a0b55d4286 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Thu, 15 Apr 2021 11:36:23 -0400
Subject: [PATCH 1605/2400] cmd/go: move 'go install cmd@version' code into
 internal/load

'go run cmd@version' will use the same code.

This changes error messages a bit.

For #42088

Change-Id: Iaed3997a3d27f9fc0e868013ab765f1fb638a0b5
Reviewed-on: https://go-review.googlesource.com/c/go/+/310410
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go/internal/load/pkg.go               | 187 ++++++++++++++++++
 src/cmd/go/internal/work/build.go             | 144 +-------------
 .../script/mod_install_pkg_version.txt        |  26 +--
 3 files changed, 210 insertions(+), 147 deletions(-)

diff --git a/src/cmd/go/internal/load/pkg.go b/src/cmd/go/internal/load/pkg.go
index 8a74930209..98a695ca24 100644
--- a/src/cmd/go/internal/load/pkg.go
+++ b/src/cmd/go/internal/load/pkg.go
@@ -14,6 +14,7 @@ import (
 	"go/build"
 	"go/scanner"
 	"go/token"
+	"internal/goroot"
 	"io/fs"
 	"os"
 	"path"
@@ -30,6 +31,7 @@ import (
 	"cmd/go/internal/cfg"
 	"cmd/go/internal/fsys"
 	"cmd/go/internal/imports"
+	"cmd/go/internal/modfetch"
 	"cmd/go/internal/modinfo"
 	"cmd/go/internal/modload"
 	"cmd/go/internal/par"
@@ -38,6 +40,7 @@ import (
 	"cmd/go/internal/trace"
 	"cmd/internal/sys"
 
+	"golang.org/x/mod/modfile"
 	"golang.org/x/mod/module"
 )
 
@@ -2390,6 +2393,13 @@ type PackageOpts struct {
 	// of those packages could be missing, and resolving those missing dependencies
 	// could change the selected versions of modules that provide other packages.
 	ModResolveTests bool
+
+	// MainOnly is true if the caller only wants to load main packages.
+	// For a literal argument matching a non-main package, a stub may be returned
+	// with an error. For a non-literal argument (with "..."), non-main packages
+	// are not be matched, and their dependencies may not be loaded. A warning
+	// may be printed for non-literal arguments that match no main packages.
+	MainOnly bool
 }
 
 // PackagesAndErrors returns the packages named by the command line arguments
@@ -2480,6 +2490,10 @@ func PackagesAndErrors(ctx context.Context, opts PackageOpts, patterns []string)
 		}
 	}
 
+	if opts.MainOnly {
+		pkgs = mainPackagesOnly(pkgs, patterns)
+	}
+
 	// Now that CmdlinePkg is set correctly,
 	// compute the effective flags for all loaded packages
 	// (not just the ones matching the patterns but also
@@ -2528,6 +2542,51 @@ func CheckPackageErrors(pkgs []*Package) {
 	base.ExitIfErrors()
 }
 
+// mainPackagesOnly filters out non-main packages matched only by arguments
+// containing "..." and returns the remaining main packages.
+//
+// mainPackagesOnly sets a package's error if it is named by a literal argument.
+//
+// mainPackagesOnly prints warnings for non-literal arguments that only match
+// non-main packages.
+func mainPackagesOnly(pkgs []*Package, patterns []string) []*Package {
+	matchers := make([]func(string) bool, len(patterns))
+	for i, p := range patterns {
+		if strings.Contains(p, "...") {
+			matchers[i] = search.MatchPattern(p)
+		}
+	}
+
+	mainPkgs := make([]*Package, 0, len(pkgs))
+	mainCount := make([]int, len(patterns))
+	nonMainCount := make([]int, len(patterns))
+	for _, pkg := range pkgs {
+		if pkg.Name == "main" {
+			mainPkgs = append(mainPkgs, pkg)
+			for i := range patterns {
+				if matchers[i] != nil && matchers[i](pkg.ImportPath) {
+					mainCount[i]++
+				}
+			}
+		} else {
+			for i := range patterns {
+				if matchers[i] == nil && patterns[i] == pkg.ImportPath && pkg.Error == nil {
+					pkg.Error = &PackageError{Err: ImportErrorf(pkg.ImportPath, "package %s is not a main package", pkg.ImportPath)}
+				} else if matchers[i] != nil && matchers[i](pkg.ImportPath) {
+					nonMainCount[i]++
+				}
+			}
+		}
+	}
+	for i, p := range patterns {
+		if matchers[i] != nil && mainCount[i] == 0 && nonMainCount[i] > 0 {
+			fmt.Fprintf(os.Stderr, "go: warning: %q matched no main packages\n", p)
+		}
+	}
+
+	return mainPkgs
+}
+
 func setToolFlags(pkgs ...*Package) {
 	for _, p := range PackageList(pkgs) {
 		p.Internal.Asmflags = BuildAsmflags.For(p)
@@ -2624,3 +2683,131 @@ func GoFilesPackage(ctx context.Context, opts PackageOpts, gofiles []string) *Pa
 
 	return pkg
 }
+
+// PackagesAndErrorsOutsideModule is like PackagesAndErrors but runs in
+// module-aware mode and ignores the go.mod file in the current directory or any
+// parent directory, if there is one. This is used in the implementation of 'go
+// install pkg@version' and other commands that support similar forms.
+//
+// modload.ForceUseModules must be true, and modload.RootMode must be NoRoot
+// before calling this function.
+//
+// PackagesAndErrorsOutsideModule imposes several constraints to avoid
+// ambiguity. All arguments must have the same version suffix (not just a suffix
+// that resolves to the same version). They must refer to packages in the same
+// module, which must not be std or cmd. That module is not considered the main
+// module, but its go.mod file (if it has one) must not contain directives that
+// would cause it to be interpreted differently if it were the main module
+// (replace, exclude).
+func PackagesAndErrorsOutsideModule(ctx context.Context, opts PackageOpts, args []string) ([]*Package, error) {
+	if !modload.ForceUseModules {
+		panic("modload.ForceUseModules must be true")
+	}
+	if modload.RootMode != modload.NoRoot {
+		panic("modload.RootMode must be NoRoot")
+	}
+
+	// Check that the arguments satisfy syntactic constraints.
+	var version string
+	for _, arg := range args {
+		if i := strings.Index(arg, "@"); i >= 0 {
+			version = arg[i+1:]
+			if version == "" {
+				return nil, fmt.Errorf("%s: version must not be empty", arg)
+			}
+			break
+		}
+	}
+	patterns := make([]string, len(args))
+	for i, arg := range args {
+		if !strings.HasSuffix(arg, "@"+version) {
+			return nil, fmt.Errorf("%s: all arguments must have the same version (@%s)", arg, version)
+		}
+		p := arg[:len(arg)-len(version)-1]
+		switch {
+		case build.IsLocalImport(p):
+			return nil, fmt.Errorf("%s: argument must be a package path, not a relative path", arg)
+		case filepath.IsAbs(p):
+			return nil, fmt.Errorf("%s: argument must be a package path, not an absolute path", arg)
+		case search.IsMetaPackage(p):
+			return nil, fmt.Errorf("%s: argument must be a package path, not a meta-package", arg)
+		case path.Clean(p) != p:
+			return nil, fmt.Errorf("%s: argument must be a clean package path", arg)
+		case !strings.Contains(p, "...") && search.IsStandardImportPath(p) && goroot.IsStandardPackage(cfg.GOROOT, cfg.BuildContext.Compiler, p):
+			return nil, fmt.Errorf("%s: argument must not be a package in the standard library", arg)
+		default:
+			patterns[i] = p
+		}
+	}
+
+	// Query the module providing the first argument, load its go.mod file, and
+	// check that it doesn't contain directives that would cause it to be
+	// interpreted differently if it were the main module.
+	//
+	// If multiple modules match the first argument, accept the longest match
+	// (first result). It's possible this module won't provide packages named by
+	// later arguments, and other modules would. Let's not try to be too
+	// magical though.
+	allowed := modload.CheckAllowed
+	if modload.IsRevisionQuery(version) {
+		// Don't check for retractions if a specific revision is requested.
+		allowed = nil
+	}
+	noneSelected := func(path string) (version string) { return "none" }
+	qrs, err := modload.QueryPackages(ctx, patterns[0], version, noneSelected, allowed)
+	if err != nil {
+		return nil, fmt.Errorf("%s: %w", args[0], err)
+	}
+	rootMod := qrs[0].Mod
+	data, err := modfetch.GoMod(rootMod.Path, rootMod.Version)
+	if err != nil {
+		return nil, fmt.Errorf("%s: %w", args[0], err)
+	}
+	f, err := modfile.Parse("go.mod", data, nil)
+	if err != nil {
+		return nil, fmt.Errorf("%s (in %s): %w", args[0], rootMod, err)
+	}
+	directiveFmt := "%s (in %s):\n" +
+		"\tThe go.mod file for the module providing named packages contains one or\n" +
+		"\tmore %s directives. It must not contain directives that would cause\n" +
+		"\tit to be interpreted differently than if it were the main module."
+	if len(f.Replace) > 0 {
+		return nil, fmt.Errorf(directiveFmt, args[0], rootMod, "replace")
+	}
+	if len(f.Exclude) > 0 {
+		return nil, fmt.Errorf(directiveFmt, args[0], rootMod, "exclude")
+	}
+
+	// Since we are in NoRoot mode, the build list initially contains only
+	// the dummy command-line-arguments module. Add a requirement on the
+	// module that provides the packages named on the command line.
+	if _, err := modload.EditBuildList(ctx, nil, []module.Version{rootMod}); err != nil {
+		return nil, fmt.Errorf("%s: %w", args[0], err)
+	}
+
+	// Load packages for all arguments.
+	pkgs := PackagesAndErrors(ctx, opts, patterns)
+
+	// Check that named packages are all provided by the same module.
+	for _, pkg := range pkgs {
+		var pkgErr error
+		if pkg.Module == nil {
+			// Packages in std, cmd, and their vendored dependencies
+			// don't have this field set.
+			pkgErr = fmt.Errorf("package %s not provided by module %s", pkg.ImportPath, rootMod)
+		} else if pkg.Module.Path != rootMod.Path || pkg.Module.Version != rootMod.Version {
+			pkgErr = fmt.Errorf("package %s provided by module %s@%s\n\tAll packages must be provided by the same module (%s).", pkg.ImportPath, pkg.Module.Path, pkg.Module.Version, rootMod)
+		}
+		if pkgErr != nil && pkg.Error == nil {
+			pkg.Error = &PackageError{Err: pkgErr}
+		}
+	}
+
+	matchers := make([]func(string) bool, len(patterns))
+	for i, p := range patterns {
+		if strings.Contains(p, "...") {
+			matchers[i] = search.MatchPattern(p)
+		}
+	}
+	return pkgs, nil
+}
diff --git a/src/cmd/go/internal/work/build.go b/src/cmd/go/internal/work/build.go
index dcb9e3785c..a75ace7d4e 100644
--- a/src/cmd/go/internal/work/build.go
+++ b/src/cmd/go/internal/work/build.go
@@ -10,9 +10,7 @@ import (
 	"fmt"
 	"go/build"
 	exec "internal/execabs"
-	"internal/goroot"
 	"os"
-	"path"
 	"path/filepath"
 	"runtime"
 	"strings"
@@ -21,13 +19,9 @@ import (
 	"cmd/go/internal/cfg"
 	"cmd/go/internal/fsys"
 	"cmd/go/internal/load"
-	"cmd/go/internal/modfetch"
 	"cmd/go/internal/modload"
 	"cmd/go/internal/search"
 	"cmd/go/internal/trace"
-
-	"golang.org/x/mod/modfile"
-	"golang.org/x/mod/module"
 )
 
 var CmdBuild = &base.Command{
@@ -762,145 +756,27 @@ func installOutsideModule(ctx context.Context, args []string) {
 	modload.RootMode = modload.NoRoot
 	modload.AllowMissingModuleImports()
 	modload.Init()
-
-	// Check that the arguments satisfy syntactic constraints.
-	var version string
-	for _, arg := range args {
-		if i := strings.Index(arg, "@"); i >= 0 {
-			version = arg[i+1:]
-			if version == "" {
-				base.Fatalf("go install %s: version must not be empty", arg)
-			}
-			break
-		}
-	}
-	patterns := make([]string, len(args))
-	for i, arg := range args {
-		if !strings.HasSuffix(arg, "@"+version) {
-			base.Errorf("go install %s: all arguments must have the same version (@%s)", arg, version)
-			continue
-		}
-		p := arg[:len(arg)-len(version)-1]
-		switch {
-		case build.IsLocalImport(p):
-			base.Errorf("go install %s: argument must be a package path, not a relative path", arg)
-		case filepath.IsAbs(p):
-			base.Errorf("go install %s: argument must be a package path, not an absolute path", arg)
-		case search.IsMetaPackage(p):
-			base.Errorf("go install %s: argument must be a package path, not a meta-package", arg)
-		case path.Clean(p) != p:
-			base.Errorf("go install %s: argument must be a clean package path", arg)
-		case !strings.Contains(p, "...") && search.IsStandardImportPath(p) && goroot.IsStandardPackage(cfg.GOROOT, cfg.BuildContext.Compiler, p):
-			base.Errorf("go install %s: argument must not be a package in the standard library", arg)
-		default:
-			patterns[i] = p
-		}
-	}
-	base.ExitIfErrors()
 	BuildInit()
 
-	// Query the module providing the first argument, load its go.mod file, and
-	// check that it doesn't contain directives that would cause it to be
-	// interpreted differently if it were the main module.
-	//
-	// If multiple modules match the first argument, accept the longest match
-	// (first result). It's possible this module won't provide packages named by
-	// later arguments, and other modules would. Let's not try to be too
-	// magical though.
-	allowed := modload.CheckAllowed
-	if modload.IsRevisionQuery(version) {
-		// Don't check for retractions if a specific revision is requested.
-		allowed = nil
-	}
-	noneSelected := func(path string) (version string) { return "none" }
-	qrs, err := modload.QueryPackages(ctx, patterns[0], version, noneSelected, allowed)
-	if err != nil {
-		base.Fatalf("go install %s: %v", args[0], err)
-	}
-	installMod := qrs[0].Mod
-	data, err := modfetch.GoMod(installMod.Path, installMod.Version)
-	if err != nil {
-		base.Fatalf("go install %s: %v", args[0], err)
-	}
-	f, err := modfile.Parse("go.mod", data, nil)
-	if err != nil {
-		base.Fatalf("go install %s: %s: %v", args[0], installMod, err)
-	}
-	directiveFmt := "go install %s: %s\n" +
-		"\tThe go.mod file for the module providing named packages contains one or\n" +
-		"\tmore %s directives. It must not contain directives that would cause\n" +
-		"\tit to be interpreted differently than if it were the main module."
-	if len(f.Replace) > 0 {
-		base.Fatalf(directiveFmt, args[0], installMod, "replace")
-	}
-	if len(f.Exclude) > 0 {
-		base.Fatalf(directiveFmt, args[0], installMod, "exclude")
-	}
-
-	// Since we are in NoRoot mode, the build list initially contains only
-	// the dummy command-line-arguments module. Add a requirement on the
-	// module that provides the packages named on the command line.
-	if _, err := modload.EditBuildList(ctx, nil, []module.Version{installMod}); err != nil {
-		base.Fatalf("go install %s: %v", args[0], err)
-	}
-
-	// Load packages for all arguments. Ignore non-main packages.
+	// Load packages. Ignore non-main packages.
 	// Print a warning if an argument contains "..." and matches no main packages.
 	// PackagesAndErrors already prints warnings for patterns that don't match any
 	// packages, so be careful not to double print.
-	matchers := make([]func(string) bool, len(patterns))
-	for i, p := range patterns {
-		if strings.Contains(p, "...") {
-			matchers[i] = search.MatchPattern(p)
-		}
-	}
-
 	// TODO(golang.org/issue/40276): don't report errors loading non-main packages
 	// matched by a pattern.
-	pkgs := load.PackagesAndErrors(ctx, load.PackageOpts{}, patterns)
-	load.CheckPackageErrors(pkgs)
-	mainPkgs := make([]*load.Package, 0, len(pkgs))
-	mainCount := make([]int, len(patterns))
-	nonMainCount := make([]int, len(patterns))
-	for _, pkg := range pkgs {
-		if pkg.Name == "main" {
-			mainPkgs = append(mainPkgs, pkg)
-			for i := range patterns {
-				if matchers[i] != nil && matchers[i](pkg.ImportPath) {
-					mainCount[i]++
-				}
-			}
-		} else {
-			for i := range patterns {
-				if matchers[i] == nil && patterns[i] == pkg.ImportPath {
-					base.Errorf("go install: package %s is not a main package", pkg.ImportPath)
-				} else if matchers[i] != nil && matchers[i](pkg.ImportPath) {
-					nonMainCount[i]++
-				}
-			}
-		}
-	}
-	base.ExitIfErrors()
-	for i, p := range patterns {
-		if matchers[i] != nil && mainCount[i] == 0 && nonMainCount[i] > 0 {
-			fmt.Fprintf(os.Stderr, "go: warning: %q matched no main packages\n", p)
-		}
+	pkgOpts := load.PackageOpts{MainOnly: true}
+	pkgs, err := load.PackagesAndErrorsOutsideModule(ctx, pkgOpts, args)
+	if err != nil {
+		base.Fatalf("go install: %v", err)
 	}
-
-	// Check that named packages are all provided by the same module.
-	for _, pkg := range mainPkgs {
-		if pkg.Module == nil {
-			// Packages in std, cmd, and their vendored dependencies
-			// don't have this field set.
-			base.Errorf("go install: package %s not provided by module %s", pkg.ImportPath, installMod)
-		} else if pkg.Module.Path != installMod.Path || pkg.Module.Version != installMod.Version {
-			base.Errorf("go install: package %s provided by module %s@%s\n\tAll packages must be provided by the same module (%s).", pkg.ImportPath, pkg.Module.Path, pkg.Module.Version, installMod)
-		}
+	load.CheckPackageErrors(pkgs)
+	patterns := make([]string, len(args))
+	for i, arg := range args {
+		patterns[i] = arg[:strings.Index(arg, "@")]
 	}
-	base.ExitIfErrors()
 
 	// Build and install the packages.
-	InstallPackages(ctx, patterns, mainPkgs)
+	InstallPackages(ctx, patterns, pkgs)
 }
 
 // ExecCmd is the command to use to run user binaries.
diff --git a/src/cmd/go/testdata/script/mod_install_pkg_version.txt b/src/cmd/go/testdata/script/mod_install_pkg_version.txt
index c14085c4fd..3b387cd8b6 100644
--- a/src/cmd/go/testdata/script/mod_install_pkg_version.txt
+++ b/src/cmd/go/testdata/script/mod_install_pkg_version.txt
@@ -81,17 +81,17 @@ env GO111MODULE=auto
 # 'go install pkg@version' reports errors for meta packages, std packages,
 # and directories.
 ! go install std@v1.0.0
-stderr '^go install std@v1.0.0: argument must be a package path, not a meta-package$'
+stderr '^go install: std@v1.0.0: argument must be a package path, not a meta-package$'
 ! go install fmt@v1.0.0
-stderr '^go install fmt@v1.0.0: argument must not be a package in the standard library$'
+stderr '^go install: fmt@v1.0.0: argument must not be a package in the standard library$'
 ! go install example.com//cmd/a@v1.0.0
-stderr '^go install example.com//cmd/a@v1.0.0: argument must be a clean package path$'
+stderr '^go install: example.com//cmd/a@v1.0.0: argument must be a clean package path$'
 ! go install example.com/cmd/a@v1.0.0 ./x@v1.0.0
-stderr '^go install ./x@v1.0.0: argument must be a package path, not a relative path$'
+stderr '^go install: ./x@v1.0.0: argument must be a package path, not a relative path$'
 ! go install example.com/cmd/a@v1.0.0 $GOPATH/src/x@v1.0.0
-stderr '^go install '$WORK'[/\\]gopath/src/x@v1.0.0: argument must be a package path, not an absolute path$'
+stderr '^go install: '$WORK'[/\\]gopath/src/x@v1.0.0: argument must be a package path, not an absolute path$'
 ! go install example.com/cmd/a@v1.0.0 cmd/...@v1.0.0
-stderr '^go install: package cmd/go not provided by module example.com/cmd@v1.0.0$'
+stderr '^package cmd/go not provided by module example.com/cmd@v1.0.0$'
 
 # 'go install pkg@version' should accept multiple arguments but report an error
 # if the version suffixes are different, even if they refer to the same version.
@@ -106,19 +106,19 @@ stdout '^example.com/cmd v1.0.0$'
 env GO111MODULE=auto
 
 ! go install example.com/cmd/a@v1.0.0 example.com/cmd/b@latest
-stderr '^go install example.com/cmd/b@latest: all arguments must have the same version \(@v1.0.0\)$'
+stderr '^go install: example.com/cmd/b@latest: all arguments must have the same version \(@v1.0.0\)$'
 
 
 # 'go install pkg@version' should report an error if the arguments are in
 # different modules.
 ! go install example.com/cmd/a@v1.0.0 rsc.io/fortune@v1.0.0
-stderr '^go install: package rsc.io/fortune provided by module rsc.io/fortune@v1.0.0\n\tAll packages must be provided by the same module \(example.com/cmd@v1.0.0\).$'
+stderr '^package rsc.io/fortune provided by module rsc.io/fortune@v1.0.0\n\tAll packages must be provided by the same module \(example.com/cmd@v1.0.0\).$'
 
 
 # 'go install pkg@version' should report an error if an argument is not
 # a main package.
 ! go install example.com/cmd/a@v1.0.0 example.com/cmd/err@v1.0.0
-stderr '^go install: package example.com/cmd/err is not a main package$'
+stderr '^go: package example.com/cmd/err is not a main package$'
 
 # Wildcards should match only main packages. This module has a non-main package
 # with an error, so we'll know if that gets built.
@@ -137,7 +137,7 @@ rm $GOPATH/bin
 
 # If a wildcard matches no packages, we should see a warning.
 ! go install example.com/cmd/nomatch...@v1.0.0
-stderr '^go install example.com/cmd/nomatch\.\.\.@v1.0.0: module example.com/cmd@v1.0.0 found, but does not contain packages matching example.com/cmd/nomatch\.\.\.$'
+stderr '^go install: example.com/cmd/nomatch\.\.\.@v1.0.0: module example.com/cmd@v1.0.0 found, but does not contain packages matching example.com/cmd/nomatch\.\.\.$'
 go install example.com/cmd/a@v1.0.0 example.com/cmd/nomatch...@v1.0.0
 stderr '^go: warning: "example.com/cmd/nomatch\.\.\." matched no packages$'
 
@@ -159,7 +159,7 @@ cmp stderr exclude-err
 # 'go install pkg@version' should report an error if the module requires a
 # higher version of itself.
 ! go install example.com/cmd/a@v1.0.0-newerself
-stderr '^go install example.com/cmd/a@v1.0.0-newerself: version constraints conflict:\n\texample.com/cmd@v1.0.0-newerself requires example.com/cmd@v1.0.0, but example.com/cmd@v1.0.0-newerself is requested$'
+stderr '^go install: example.com/cmd/a@v1.0.0-newerself: version constraints conflict:\n\texample.com/cmd@v1.0.0-newerself requires example.com/cmd@v1.0.0, but example.com/cmd@v1.0.0-newerself is requested$'
 
 
 # 'go install pkg@version' will only match a retracted version if it's
@@ -192,12 +192,12 @@ package main
 
 func main() {}
 -- replace-err --
-go install example.com/cmd/a@v1.0.0-replace: example.com/cmd@v1.0.0-replace
+go install: example.com/cmd/a@v1.0.0-replace (in example.com/cmd@v1.0.0-replace):
 	The go.mod file for the module providing named packages contains one or
 	more replace directives. It must not contain directives that would cause
 	it to be interpreted differently than if it were the main module.
 -- exclude-err --
-go install example.com/cmd/a@v1.0.0-exclude: example.com/cmd@v1.0.0-exclude
+go install: example.com/cmd/a@v1.0.0-exclude (in example.com/cmd@v1.0.0-exclude):
 	The go.mod file for the module providing named packages contains one or
 	more exclude directives. It must not contain directives that would cause
 	it to be interpreted differently than if it were the main module.
-- 
GitLab


From 639cb1b629e575487af78bb3f60af24a7df7a3f7 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Fri, 16 Apr 2021 00:00:32 -0400
Subject: [PATCH 1606/2400] runtime: mark stdcallN functions cgo_unsafe_args

These functions take the address of an argument and expect to be able
to reach later arguments from that pointer. This means they must be
laid out sequentially in memory (using ABI0) and all arguments must be
live even though they don't all appear to be referenced. This is
exactly what go:cgo_unsafe_args does.

Without this, GOEXPERIMENT=regabi,regabiargs on windows/amd64 crashes
on runtime startup because the stdcall functions are called with their
arguments in registers, so taking the address of one of them has no
bearing on the memory locations of the following arguments.

With this, GOEXPERIMENT=regabi,regabiargs on windows/amd64 passes
all.bash.

For #40724.

Change-Id: I4a4d6a913f85799b43f61c234d21ebb113a9b527
Reviewed-on: https://go-review.googlesource.com/c/go/+/310733
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/os_windows.go | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/runtime/os_windows.go b/src/runtime/os_windows.go
index bc1240f8bb..36182f4e9a 100644
--- a/src/runtime/os_windows.go
+++ b/src/runtime/os_windows.go
@@ -1084,6 +1084,7 @@ func stdcall0(fn stdFunction) uintptr {
 }
 
 //go:nosplit
+//go:cgo_unsafe_args
 func stdcall1(fn stdFunction, a0 uintptr) uintptr {
 	mp := getg().m
 	mp.libcall.n = 1
@@ -1092,6 +1093,7 @@ func stdcall1(fn stdFunction, a0 uintptr) uintptr {
 }
 
 //go:nosplit
+//go:cgo_unsafe_args
 func stdcall2(fn stdFunction, a0, a1 uintptr) uintptr {
 	mp := getg().m
 	mp.libcall.n = 2
@@ -1100,6 +1102,7 @@ func stdcall2(fn stdFunction, a0, a1 uintptr) uintptr {
 }
 
 //go:nosplit
+//go:cgo_unsafe_args
 func stdcall3(fn stdFunction, a0, a1, a2 uintptr) uintptr {
 	mp := getg().m
 	mp.libcall.n = 3
@@ -1108,6 +1111,7 @@ func stdcall3(fn stdFunction, a0, a1, a2 uintptr) uintptr {
 }
 
 //go:nosplit
+//go:cgo_unsafe_args
 func stdcall4(fn stdFunction, a0, a1, a2, a3 uintptr) uintptr {
 	mp := getg().m
 	mp.libcall.n = 4
@@ -1116,6 +1120,7 @@ func stdcall4(fn stdFunction, a0, a1, a2, a3 uintptr) uintptr {
 }
 
 //go:nosplit
+//go:cgo_unsafe_args
 func stdcall5(fn stdFunction, a0, a1, a2, a3, a4 uintptr) uintptr {
 	mp := getg().m
 	mp.libcall.n = 5
@@ -1124,6 +1129,7 @@ func stdcall5(fn stdFunction, a0, a1, a2, a3, a4 uintptr) uintptr {
 }
 
 //go:nosplit
+//go:cgo_unsafe_args
 func stdcall6(fn stdFunction, a0, a1, a2, a3, a4, a5 uintptr) uintptr {
 	mp := getg().m
 	mp.libcall.n = 6
@@ -1132,6 +1138,7 @@ func stdcall6(fn stdFunction, a0, a1, a2, a3, a4, a5 uintptr) uintptr {
 }
 
 //go:nosplit
+//go:cgo_unsafe_args
 func stdcall7(fn stdFunction, a0, a1, a2, a3, a4, a5, a6 uintptr) uintptr {
 	mp := getg().m
 	mp.libcall.n = 7
-- 
GitLab


From 04e1176fd288f1ceba987d8d2fd9040e45157b38 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Tue, 13 Apr 2021 18:00:09 -0400
Subject: [PATCH 1607/2400] cmd/go: support 'go run cmd@version'

'go run' can now build a command at a specific version in module-aware
mode, ignoring the go.mod file in the current directory if there is one.

For #42088

Change-Id: I0bd9bcbe40c0442a268cd1cc315a8a2cbb5adeee
Reviewed-on: https://go-review.googlesource.com/c/go/+/310074
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go/alldocs.go                         | 15 ++-
 src/cmd/go/internal/run/run.go                | 74 ++++++++++++--
 .../testdata/mod/example.com_cmd_v1.0.0.txt   |  8 +-
 .../testdata/script/mod_run_pkg_version.txt   | 98 +++++++++++++++++++
 4 files changed, 184 insertions(+), 11 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/mod_run_pkg_version.txt

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index 66e78bb1ac..999fcf7e53 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -1315,10 +1315,21 @@
 // 	go run [build flags] [-exec xprog] package [arguments...]
 //
 // Run compiles and runs the named main Go package.
-// Typically the package is specified as a list of .go source files from a single directory,
-// but it may also be an import path, file system path, or pattern
+// Typically the package is specified as a list of .go source files from a single
+// directory, but it may also be an import path, file system path, or pattern
 // matching a single known package, as in 'go run .' or 'go run my/cmd'.
 //
+// If the package argument has a version suffix (like @latest or @v1.0.0),
+// "go run" builds the program in module-aware mode, ignoring the go.mod file in
+// the current directory or any parent directory, if there is one. This is useful
+// for running programs without affecting the dependencies of the main module.
+//
+// If the package argument doesn't have a version suffix, "go run" may run in
+// module-aware mode or GOPATH mode, depending on the GO111MODULE environment
+// variable and the presence of a go.mod file. See 'go help modules' for details.
+// If module-aware mode is enabled, "go run" runs in the context of the main
+// module.
+//
 // By default, 'go run' runs the compiled binary directly: 'a.out arguments...'.
 // If the -exec flag is given, 'go run' invokes the binary using xprog:
 // 	'xprog a.out arguments...'.
diff --git a/src/cmd/go/internal/run/run.go b/src/cmd/go/internal/run/run.go
index f0137c20c1..914e5edc6f 100644
--- a/src/cmd/go/internal/run/run.go
+++ b/src/cmd/go/internal/run/run.go
@@ -8,13 +8,16 @@ package run
 import (
 	"context"
 	"fmt"
+	"go/build"
 	"os"
 	"path"
+	"path/filepath"
 	"strings"
 
 	"cmd/go/internal/base"
 	"cmd/go/internal/cfg"
 	"cmd/go/internal/load"
+	"cmd/go/internal/modload"
 	"cmd/go/internal/str"
 	"cmd/go/internal/work"
 )
@@ -24,10 +27,21 @@ var CmdRun = &base.Command{
 	Short:     "compile and run Go program",
 	Long: `
 Run compiles and runs the named main Go package.
-Typically the package is specified as a list of .go source files from a single directory,
-but it may also be an import path, file system path, or pattern
+Typically the package is specified as a list of .go source files from a single
+directory, but it may also be an import path, file system path, or pattern
 matching a single known package, as in 'go run .' or 'go run my/cmd'.
 
+If the package argument has a version suffix (like @latest or @v1.0.0),
+"go run" builds the program in module-aware mode, ignoring the go.mod file in
+the current directory or any parent directory, if there is one. This is useful
+for running programs without affecting the dependencies of the main module.
+
+If the package argument doesn't have a version suffix, "go run" may run in
+module-aware mode or GOPATH mode, depending on the GO111MODULE environment
+variable and the presence of a go.mod file. See 'go help modules' for details.
+If module-aware mode is enabled, "go run" runs in the context of the main
+module.
+
 By default, 'go run' runs the compiled binary directly: 'a.out arguments...'.
 If the -exec flag is given, 'go run' invokes the binary using xprog:
 	'xprog a.out arguments...'.
@@ -59,10 +73,21 @@ func printStderr(args ...interface{}) (int, error) {
 }
 
 func runRun(ctx context.Context, cmd *base.Command, args []string) {
+	if shouldUseOutsideModuleMode(args) {
+		// Set global module flags for 'go run cmd@version'.
+		// This must be done before modload.Init, but we need to call work.BuildInit
+		// before loading packages, since it affects package locations, e.g.,
+		// for -race and -msan.
+		modload.ForceUseModules = true
+		modload.RootMode = modload.NoRoot
+		modload.AllowMissingModuleImports()
+		modload.Init()
+	}
 	work.BuildInit()
 	var b work.Builder
 	b.Init()
 	b.Print = printStderr
+
 	i := 0
 	for i < len(args) && strings.HasSuffix(args[i], ".go") {
 		i++
@@ -79,16 +104,28 @@ func runRun(ctx context.Context, cmd *base.Command, args []string) {
 		}
 		p = load.GoFilesPackage(ctx, load.PackageOpts{}, files)
 	} else if len(args) > 0 && !strings.HasPrefix(args[0], "-") {
-		pkgs := load.PackagesAndErrors(ctx, load.PackageOpts{}, args[:1])
+		arg := args[0]
+		pkgOpts := load.PackageOpts{MainOnly: true}
+		var pkgs []*load.Package
+		if strings.Contains(arg, "@") && !build.IsLocalImport(arg) && !filepath.IsAbs(arg) {
+			var err error
+			pkgs, err = load.PackagesAndErrorsOutsideModule(ctx, pkgOpts, args[:1])
+			if err != nil {
+				base.Fatalf("go run: %v", err)
+			}
+		} else {
+			pkgs = load.PackagesAndErrors(ctx, pkgOpts, args[:1])
+		}
+
 		if len(pkgs) == 0 {
-			base.Fatalf("go run: no packages loaded from %s", args[0])
+			base.Fatalf("go run: no packages loaded from %s", arg)
 		}
 		if len(pkgs) > 1 {
 			var names []string
 			for _, p := range pkgs {
 				names = append(names, p.ImportPath)
 			}
-			base.Fatalf("go run: pattern %s matches multiple packages:\n\t%s", args[0], strings.Join(names, "\n\t"))
+			base.Fatalf("go run: pattern %s matches multiple packages:\n\t%s", arg, strings.Join(names, "\n\t"))
 		}
 		p = pkgs[0]
 		i++
@@ -96,11 +133,11 @@ func runRun(ctx context.Context, cmd *base.Command, args []string) {
 		base.Fatalf("go run: no go files listed")
 	}
 	cmdArgs := args[i:]
-	load.CheckPackageErrors([]*load.Package{p})
-
 	if p.Name != "main" {
 		base.Fatalf("go run: cannot run non-main package")
 	}
+	load.CheckPackageErrors([]*load.Package{p})
+
 	p.Internal.OmitDebug = true
 	p.Target = "" // must build - not up to date
 	if p.Internal.CmdlineFiles {
@@ -123,11 +160,34 @@ func runRun(ctx context.Context, cmd *base.Command, args []string) {
 	} else {
 		p.Internal.ExeName = path.Base(p.ImportPath)
 	}
+
 	a1 := b.LinkAction(work.ModeBuild, work.ModeBuild, p)
 	a := &work.Action{Mode: "go run", Func: buildRunProgram, Args: cmdArgs, Deps: []*work.Action{a1}}
 	b.Do(ctx, a)
 }
 
+// shouldUseOutsideModuleMode returns whether 'go run' will load packages in
+// module-aware mode, ignoring the go.mod file in the current directory. It
+// returns true if the first argument contains "@", does not begin with "-"
+// (resembling a flag) or end with ".go" (a file). The argument must not be a
+// local or absolute file path.
+//
+// These rules are slightly different than other commands. Whether or not
+// 'go run' uses this mode, it interprets arguments ending with ".go" as files
+// and uses arguments up to the last ".go" argument to comprise the package.
+// If there are no ".go" arguments, only the first argument is interpreted
+// as a package path, since there can be only one package.
+func shouldUseOutsideModuleMode(args []string) bool {
+	// NOTE: "@" not allowed in import paths, but it is allowed in non-canonical
+	// versions.
+	return len(args) > 0 &&
+		!strings.HasSuffix(args[0], ".go") &&
+		!strings.HasPrefix(args[0], "-") &&
+		strings.Contains(args[0], "@") &&
+		!build.IsLocalImport(args[0]) &&
+		!filepath.IsAbs(args[0])
+}
+
 // buildRunProgram is the action for running a binary that has already
 // been compiled. We ignore exit status.
 func buildRunProgram(b *work.Builder, ctx context.Context, a *work.Action) error {
diff --git a/src/cmd/go/testdata/mod/example.com_cmd_v1.0.0.txt b/src/cmd/go/testdata/mod/example.com_cmd_v1.0.0.txt
index ee439384d2..c1981391a1 100644
--- a/src/cmd/go/testdata/mod/example.com_cmd_v1.0.0.txt
+++ b/src/cmd/go/testdata/mod/example.com_cmd_v1.0.0.txt
@@ -16,11 +16,15 @@ go 1.16
 -- a/a.go --
 package main
 
-func main() {}
+import "fmt"
+
+func main() { fmt.Println("a@v1.0.0") }
 -- b/b.go --
 package main
 
-func main() {}
+import "fmt"
+
+func main() { fmt.Println("b@v1.0.0") }
 -- err/err.go --
 package err
 
diff --git a/src/cmd/go/testdata/script/mod_run_pkg_version.txt b/src/cmd/go/testdata/script/mod_run_pkg_version.txt
new file mode 100644
index 0000000000..d96d3fc213
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_run_pkg_version.txt
@@ -0,0 +1,98 @@
+# This test checks the behavior of 'go run' with a 'cmd@version' argument.
+# Most of 'go run' is covered in other tests.
+# mod_install_pkg_version covers most of the package loading functionality.
+# This test focuses on 'go run' behavior specific to this mode.
+[short] skip
+
+# 'go run pkg@version' works outside a module.
+env GO111MODULE=auto
+go run example.com/cmd/a@v1.0.0
+stdout '^a@v1.0.0$'
+
+
+# 'go run pkg@version' reports an error if modules are disabled.
+env GO111MODULE=off
+! go run example.com/cmd/a@v1.0.0
+stderr '^go: modules disabled by GO111MODULE=off; see ''go help modules''$'
+env GO111MODULE=on
+
+
+# 'go run pkg@version' ignores go.mod in the current directory.
+cd m
+cp go.mod go.mod.orig
+! go list -m all
+stderr '^go list -m: example.com/cmd@v1.1.0-doesnotexist: missing go.sum entry; to add it:\n\tgo mod download example.com/cmd$'
+go run example.com/cmd/a@v1.0.0
+stdout '^a@v1.0.0$'
+cmp go.mod go.mod.orig
+cd ..
+
+
+# 'go install pkg@version' works on a module that doesn't have a go.mod file
+# and with a module whose go.mod file has missing requirements.
+# With a proxy, the two cases are indistinguishable.
+go run rsc.io/fortune@v1.0.0
+stderr '^go: found rsc.io/quote in rsc.io/quote v1.5.2$'
+stderr '^Hello, world.$'
+
+
+# 'go run pkg@version' should report errors if the module contains
+# replace or exclude directives.
+go mod download example.com/cmd@v1.0.0-replace
+! go run example.com/cmd/a@v1.0.0-replace
+cmp stderr replace-err
+
+go mod download example.com/cmd@v1.0.0-exclude
+! go run example.com/cmd/a@v1.0.0-exclude
+cmp stderr exclude-err
+
+
+# 'go run dir@version' works like a normal 'go run' command if
+# dir is a relative or absolute path.
+go mod download rsc.io/fortune@v1.0.0
+! go run $GOPATH/pkg/mod/rsc.io/fortune@v1.0.0
+stderr '^go: go\.mod file not found in current directory or any parent directory; see ''go help modules''$'
+! go run ../pkg/mod/rsc.io/fortune@v1.0.0
+stderr '^go: go\.mod file not found in current directory or any parent directory; see ''go help modules''$'
+mkdir tmp
+cd tmp
+go mod init tmp
+go mod edit -require=rsc.io/fortune@v1.0.0
+! go run -mod=readonly $GOPATH/pkg/mod/rsc.io/fortune@v1.0.0
+stderr '^go: rsc.io/fortune@v1.0.0: missing go.sum entry; to add it:\n\tgo mod download rsc.io/fortune$'
+! go run -mod=readonly ../../pkg/mod/rsc.io/fortune@v1.0.0
+stderr '^go: rsc.io/fortune@v1.0.0: missing go.sum entry; to add it:\n\tgo mod download rsc.io/fortune$'
+cd ..
+rm tmp
+
+
+# 'go run' does not interpret @version arguments after the first.
+go run example.com/cmd/a@v1.0.0 example.com/doesnotexist@v1.0.0
+stdout '^a@v1.0.0$'
+
+
+# 'go run pkg@version' succeeds when -mod=readonly is set explicitly.
+# Verifies #43278.
+go run -mod=readonly example.com/cmd/a@v1.0.0
+stdout '^a@v1.0.0$'
+
+-- m/go.mod --
+module m
+
+go 1.16
+
+require example.com/cmd v1.1.0-doesnotexist
+-- x/x.go --
+package main
+
+func main() {}
+-- replace-err --
+go run: example.com/cmd/a@v1.0.0-replace (in example.com/cmd@v1.0.0-replace):
+	The go.mod file for the module providing named packages contains one or
+	more replace directives. It must not contain directives that would cause
+	it to be interpreted differently than if it were the main module.
+-- exclude-err --
+go run: example.com/cmd/a@v1.0.0-exclude (in example.com/cmd@v1.0.0-exclude):
+	The go.mod file for the module providing named packages contains one or
+	more exclude directives. It must not contain directives that would cause
+	it to be interpreted differently than if it were the main module.
-- 
GitLab


From abbb82957d823f249dd39e38d448691e86c978bc Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 15 Apr 2021 15:43:22 -0400
Subject: [PATCH 1608/2400] cmd/compile: don't insert VarDef for
 already-initialized results

Currently, when we about to emit code that sets the function
results and returns, it emits a VarDef. But in some cases, the
result node is actually live and holding useful data. VarDef
means that we are about to (re)initialize it so all previous
data are dead, but that is not true. Don't insert that.

Also don't add VarDef for register results. We are not going to
store anything (currently it doesn't cause problem, just
unnecessary).

Change-Id: I9dd3b70b4a3f5035af028b143fde8fafa2f11fa0
Reviewed-on: https://go-review.googlesource.com/c/go/+/310589
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/ssagen/ssa.go | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 8f27777cfc..61f23a9c40 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -1941,16 +1941,22 @@ func (s *state) exit() *ssa.Block {
 	// Store SSAable and heap-escaped PPARAMOUT variables back to stack locations.
 	for i, f := range resultFields {
 		n := f.Nname.(*ir.Name)
-		s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
 		if s.canSSA(n) { // result is in some SSA variable
+			if !n.IsOutputParamInRegisters() {
+				// We are about to store to the result slot.
+				s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
+			}
 			results[i] = s.variable(n, n.Type())
 		} else if !n.OnStack() { // result is actually heap allocated
+			// We are about to copy the in-heap result to the result slot.
+			s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
 			ha := s.expr(n.Heapaddr)
 			s.instrumentFields(n.Type(), ha, instrumentRead)
 			results[i] = s.newValue2(ssa.OpDereference, n.Type(), ha, s.mem())
 		} else { // result is not SSA-able; not escaped, so not on heap, but too large for SSA.
 			// Before register ABI this ought to be a self-move, home=dest,
 			// With register ABI, it's still a self-move if parameter is on stack (i.e., too big or overflowed)
+			// No VarDef, as the result slot is already holding live value.
 			results[i] = s.newValue2(ssa.OpDereference, n.Type(), s.addr(n), s.mem())
 		}
 	}
-- 
GitLab


From 2f0e5bf907b16a8106ae68920edffe90362e16ce Mon Sep 17 00:00:00 2001
From: Peng Gao <peng.gao.dut@gmail.com>
Date: Wed, 31 Mar 2021 15:00:45 +0000
Subject: [PATCH 1609/2400] net/http: using errors.Is in fs error detection

Compare error by errors.Is to detect wrapped fs errors.

Fixes #44923

Change-Id: Idf32b96a661728278b7006c3b3bcc581b8588259
GitHub-Last-Rev: dba01ddae06947fb8c6047ddfba108acd650f446
GitHub-Pull-Request: golang/go#45314
Reviewed-on: https://go-review.googlesource.com/c/go/+/306051
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
Reviewed-by: Damien Neil <dneil@google.com>
Trust: Brad Fitzpatrick <bradfitz@golang.org>
Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/net/http/fs.go      |  6 +++---
 src/net/http/fs_test.go | 10 ++++++----
 2 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/src/net/http/fs.go b/src/net/http/fs.go
index a28ae85958..57e731e481 100644
--- a/src/net/http/fs.go
+++ b/src/net/http/fs.go
@@ -46,7 +46,7 @@ type Dir string
 // to a possibly better non-nil error. In particular, it turns OS-specific errors
 // about opening files in non-directories into fs.ErrNotExist. See Issue 18984.
 func mapDirOpenError(originalErr error, name string) error {
-	if os.IsNotExist(originalErr) || os.IsPermission(originalErr) {
+	if errors.Is(originalErr, fs.ErrNotExist) || errors.Is(originalErr, fs.ErrPermission) {
 		return originalErr
 	}
 
@@ -670,10 +670,10 @@ func serveFile(w ResponseWriter, r *Request, fs FileSystem, name string, redirec
 // and historically Go's ServeContent always returned just "404 Not Found" for
 // all errors. We don't want to start leaking information in error messages.
 func toHTTPError(err error) (msg string, httpStatus int) {
-	if os.IsNotExist(err) {
+	if errors.Is(err, fs.ErrNotExist) {
 		return "404 page not found", StatusNotFound
 	}
-	if os.IsPermission(err) {
+	if errors.Is(err, fs.ErrPermission) {
 		return "403 Forbidden", StatusForbidden
 	}
 	// Default:
diff --git a/src/net/http/fs_test.go b/src/net/http/fs_test.go
index 1bf207e0f7..b42ade1e8a 100644
--- a/src/net/http/fs_test.go
+++ b/src/net/http/fs_test.go
@@ -1265,16 +1265,18 @@ func TestFileServerNotDirError(t *testing.T) {
 			if err == nil {
 				t.Fatal("err == nil; want != nil")
 			}
-			if !os.IsNotExist(err) {
-				t.Errorf("err = %v; os.IsNotExist(err) = %v; want true", err, os.IsNotExist(err))
+			if !errors.Is(err, fs.ErrNotExist) {
+				t.Errorf("err = %v; errors.Is(err, fs.ErrNotExist) = %v; want true", err,
+					errors.Is(err, fs.ErrNotExist))
 			}
 
 			_, err = dir.Open("/index.html/not-a-dir/not-a-file")
 			if err == nil {
 				t.Fatal("err == nil; want != nil")
 			}
-			if !os.IsNotExist(err) {
-				t.Errorf("err = %v; os.IsNotExist(err) = %v; want true", err, os.IsNotExist(err))
+			if !errors.Is(err, fs.ErrNotExist) {
+				t.Errorf("err = %v; errors.Is(err, fs.ErrNotExist) = %v; want true", err,
+					errors.Is(err, fs.ErrNotExist))
 			}
 		})
 	}
-- 
GitLab


From acb189ea59d7f47e5db075e502dcce5eac6571dc Mon Sep 17 00:00:00 2001
From: ian woolf <btw515wolf2@gmail.com>
Date: Mon, 12 Apr 2021 17:19:03 +0800
Subject: [PATCH 1610/2400] net/http: make ReadRequest return an error when
 requests have multiple Host headers

Fixes #45513

Change-Id: I59e717a4bbd3e71320deff519e4f9587ee5c8756
Reviewed-on: https://go-review.googlesource.com/c/go/+/308952
Trust: Damien Neil <dneil@google.com>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
---
 src/net/http/request.go      | 22 +++++++++++-----------
 src/net/http/request_test.go |  4 ++++
 src/net/http/server.go       |  5 +----
 3 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/src/net/http/request.go b/src/net/http/request.go
index ff21f19942..4a07eb1c79 100644
--- a/src/net/http/request.go
+++ b/src/net/http/request.go
@@ -1010,16 +1010,16 @@ func putTextprotoReader(r *textproto.Reader) {
 // requests and handle them via the Handler interface. ReadRequest
 // only supports HTTP/1.x requests. For HTTP/2, use golang.org/x/net/http2.
 func ReadRequest(b *bufio.Reader) (*Request, error) {
-	return readRequest(b, deleteHostHeader)
-}
+	req, err := readRequest(b)
+	if err != nil {
+		return nil, err
+	}
 
-// Constants for readRequest's deleteHostHeader parameter.
-const (
-	deleteHostHeader = true
-	keepHostHeader   = false
-)
+	delete(req.Header, "Host")
+	return req, err
+}
 
-func readRequest(b *bufio.Reader, deleteHostHeader bool) (req *Request, err error) {
+func readRequest(b *bufio.Reader) (req *Request, err error) {
 	tp := newTextprotoReader(b)
 	req = new(Request)
 
@@ -1077,6 +1077,9 @@ func readRequest(b *bufio.Reader, deleteHostHeader bool) (req *Request, err erro
 		return nil, err
 	}
 	req.Header = Header(mimeHeader)
+	if len(req.Header["Host"]) > 1 {
+		return nil, fmt.Errorf("too many Host headers")
+	}
 
 	// RFC 7230, section 5.3: Must treat
 	//	GET /index.html HTTP/1.1
@@ -1089,9 +1092,6 @@ func readRequest(b *bufio.Reader, deleteHostHeader bool) (req *Request, err erro
 	if req.Host == "" {
 		req.Host = req.Header.get("Host")
 	}
-	if deleteHostHeader {
-		delete(req.Header, "Host")
-	}
 
 	fixPragmaCacheControl(req.Header)
 
diff --git a/src/net/http/request_test.go b/src/net/http/request_test.go
index f09c63ed7e..07b3d6a1c7 100644
--- a/src/net/http/request_test.go
+++ b/src/net/http/request_test.go
@@ -469,6 +469,10 @@ var readRequestErrorTests = []struct {
 		in:     "HEAD / HTTP/1.1\r\nContent-Length:0\r\nContent-Length: 0\r\n\r\n",
 		header: Header{"Content-Length": {"0"}},
 	},
+	11: {
+		in:  "HEAD / HTTP/1.1\r\nHost: foo\r\nHost: bar\r\n\r\n\r\n\r\n",
+		err: "too many Host headers",
+	},
 }
 
 func TestReadRequestErrors(t *testing.T) {
diff --git a/src/net/http/server.go b/src/net/http/server.go
index d90418b56d..e52a78e652 100644
--- a/src/net/http/server.go
+++ b/src/net/http/server.go
@@ -983,7 +983,7 @@ func (c *conn) readRequest(ctx context.Context) (w *response, err error) {
 		peek, _ := c.bufr.Peek(4) // ReadRequest will get err below
 		c.bufr.Discard(numLeadingCRorLF(peek))
 	}
-	req, err := readRequest(c.bufr, keepHostHeader)
+	req, err := readRequest(c.bufr)
 	if err != nil {
 		if c.r.hitReadLimit() {
 			return nil, errTooLarge
@@ -1003,9 +1003,6 @@ func (c *conn) readRequest(ctx context.Context) (w *response, err error) {
 	if req.ProtoAtLeast(1, 1) && (!haveHost || len(hosts) == 0) && !isH2Upgrade && req.Method != "CONNECT" {
 		return nil, badRequestError("missing required Host header")
 	}
-	if len(hosts) > 1 {
-		return nil, badRequestError("too many Host headers")
-	}
 	if len(hosts) == 1 && !httpguts.ValidHostHeader(hosts[0]) {
 		return nil, badRequestError("malformed Host header")
 	}
-- 
GitLab


From 60abe013217e224b200b6c3e6da344a6e5af431c Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Thu, 15 Apr 2021 22:27:37 -0400
Subject: [PATCH 1611/2400] cmd/link: fix file-local checks in xcoff

The xcoff writer has several "ldr.SymVersion(s) != 0" checks. The
intent of these is to check for file-local (or static) symbols. Prior
to the introduction of symbol ABIs, this was indeed equivalent since
only file-local symbols has non-zero versions, but ABIs also use the
symbol version space. This still happened to work until much more
recently because we were only ever cgo-exporting version 0 symbols,
but CL 309341 changed this, causing these checks to fail on symbols
that were okay to export.

Replace these checks with ldr.IsFileLocal(s).

This should fix the AIX builder.

(Originally based on CL 309772.)

Fixes #45553.
Updates #40724.

Change-Id: I0a3a7f621ad8f9fe078d34e667286275257691ea
Reviewed-on: https://go-review.googlesource.com/c/go/+/310729
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/link/internal/ld/xcoff.go | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/src/cmd/link/internal/ld/xcoff.go b/src/cmd/link/internal/ld/xcoff.go
index ba818eaa96..d412c6966b 100644
--- a/src/cmd/link/internal/ld/xcoff.go
+++ b/src/cmd/link/internal/ld/xcoff.go
@@ -825,7 +825,7 @@ func (f *xcoffFile) writeSymbolFunc(ctxt *Link, x loader.Sym) []xcoffSym {
 		Nnumaux: 2,
 	}
 
-	if ldr.SymVersion(x) != 0 || ldr.AttrVisibilityHidden(x) || ldr.AttrLocal(x) {
+	if ldr.IsFileLocal(x) || ldr.AttrVisibilityHidden(x) || ldr.AttrLocal(x) {
 		s.Nsclass = C_HIDEXT
 	}
 
@@ -914,7 +914,7 @@ func putaixsym(ctxt *Link, x loader.Sym, t SymbolType) {
 			Nnumaux: 1,
 		}
 
-		if ldr.SymVersion(x) != 0 || ldr.AttrVisibilityHidden(x) || ldr.AttrLocal(x) {
+		if ldr.IsFileLocal(x) || ldr.AttrVisibilityHidden(x) || ldr.AttrLocal(x) {
 			// There is more symbols in the case of a global data
 			// which are related to the assembly generated
 			// to access such symbols.
@@ -1318,19 +1318,14 @@ func (ctxt *Link) doxcoff() {
 			if !ldr.AttrCgoExport(s) {
 				continue
 			}
-			if ldr.SymVersion(s) != 0 { // sanity check
-				panic("cgo_export on non-version 0 symbol")
+			if ldr.IsFileLocal(s) {
+				panic("cgo_export on static symbol")
 			}
 
 			if ldr.SymType(s) == sym.STEXT || ldr.SymType(s) == sym.SABIALIAS {
 				// On AIX, a exported function must have two symbols:
 				// - a .text symbol which must start with a ".".
 				// - a .data symbol which is a function descriptor.
-				//
-				// CgoExport attribute should only be set on a version 0
-				// symbol, which can be TEXT or ABIALIAS.
-				// (before, setupdynexp copies the attribute from the
-				// alias to the aliased. Now we are before setupdynexp.)
 				name := ldr.SymExtname(s)
 				ldr.SetSymExtname(s, "."+name)
 
@@ -1787,8 +1782,8 @@ func xcoffCreateExportFile(ctxt *Link) (fname string) {
 		if !strings.HasPrefix(extname, "._cgoexp_") {
 			continue
 		}
-		if ldr.SymVersion(s) != 0 {
-			continue // Only export version 0 symbols. See the comment in doxcoff.
+		if ldr.IsFileLocal(s) {
+			continue // Only export non-static symbols
 		}
 
 		// Retrieve the name of the initial symbol
-- 
GitLab


From 492eb059f9ce08285fae8284e69b1103b63e879e Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Fri, 16 Apr 2021 13:34:37 -0400
Subject: [PATCH 1612/2400] cmd/go: fix mod_install_pkg_version

mainPackagesOnly now includes non-main packages matched by literal
arguments in the returned slice, since their errors must be reported.

GoFilesPackages attaches the same error to its package if
opts.MainOnly is true. This changes the error output of 'go run'
slightly, but it seems like an imporovement.

For #42088

Change-Id: I8f2942470383af5d4c9763022bc94338f5314b07
Reviewed-on: https://go-review.googlesource.com/c/go/+/310829
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/internal/load/pkg.go               | 32 +++++++++++++++----
 src/cmd/go/internal/run/run.go                |  7 ++--
 .../script/mod_install_pkg_version.txt        |  2 +-
 src/cmd/go/testdata/script/mod_outside.txt    |  4 ---
 .../testdata/script/mod_run_pkg_version.txt   |  5 +++
 5 files changed, 34 insertions(+), 16 deletions(-)

diff --git a/src/cmd/go/internal/load/pkg.go b/src/cmd/go/internal/load/pkg.go
index 98a695ca24..79c3a71f07 100644
--- a/src/cmd/go/internal/load/pkg.go
+++ b/src/cmd/go/internal/load/pkg.go
@@ -480,6 +480,7 @@ type ImportPathError interface {
 
 var (
 	_ ImportPathError = (*importError)(nil)
+	_ ImportPathError = (*mainPackageError)(nil)
 	_ ImportPathError = (*modload.ImportMissingError)(nil)
 	_ ImportPathError = (*modload.ImportMissingSumError)(nil)
 	_ ImportPathError = (*modload.DirectImportFromImplicitDependencyError)(nil)
@@ -2545,7 +2546,8 @@ func CheckPackageErrors(pkgs []*Package) {
 // mainPackagesOnly filters out non-main packages matched only by arguments
 // containing "..." and returns the remaining main packages.
 //
-// mainPackagesOnly sets a package's error if it is named by a literal argument.
+// mainPackagesOnly sets a non-main package's Error field and returns it if it
+// is named by a literal argument.
 //
 // mainPackagesOnly prints warnings for non-literal arguments that only match
 // non-main packages.
@@ -2557,12 +2559,12 @@ func mainPackagesOnly(pkgs []*Package, patterns []string) []*Package {
 		}
 	}
 
-	mainPkgs := make([]*Package, 0, len(pkgs))
+	matchedPkgs := make([]*Package, 0, len(pkgs))
 	mainCount := make([]int, len(patterns))
 	nonMainCount := make([]int, len(patterns))
 	for _, pkg := range pkgs {
 		if pkg.Name == "main" {
-			mainPkgs = append(mainPkgs, pkg)
+			matchedPkgs = append(matchedPkgs, pkg)
 			for i := range patterns {
 				if matchers[i] != nil && matchers[i](pkg.ImportPath) {
 					mainCount[i]++
@@ -2570,8 +2572,11 @@ func mainPackagesOnly(pkgs []*Package, patterns []string) []*Package {
 			}
 		} else {
 			for i := range patterns {
-				if matchers[i] == nil && patterns[i] == pkg.ImportPath && pkg.Error == nil {
-					pkg.Error = &PackageError{Err: ImportErrorf(pkg.ImportPath, "package %s is not a main package", pkg.ImportPath)}
+				if matchers[i] == nil && patterns[i] == pkg.ImportPath {
+					if pkg.Error == nil {
+						pkg.Error = &PackageError{Err: &mainPackageError{importPath: pkg.ImportPath}}
+					}
+					matchedPkgs = append(matchedPkgs, pkg)
 				} else if matchers[i] != nil && matchers[i](pkg.ImportPath) {
 					nonMainCount[i]++
 				}
@@ -2584,7 +2589,19 @@ func mainPackagesOnly(pkgs []*Package, patterns []string) []*Package {
 		}
 	}
 
-	return mainPkgs
+	return matchedPkgs
+}
+
+type mainPackageError struct {
+	importPath string
+}
+
+func (e *mainPackageError) Error() string {
+	return fmt.Sprintf("package %s is not a main package", e.importPath)
+}
+
+func (e *mainPackageError) ImportPath() string {
+	return e.importPath
 }
 
 func setToolFlags(pkgs ...*Package) {
@@ -2679,6 +2696,9 @@ func GoFilesPackage(ctx context.Context, opts PackageOpts, gofiles []string) *Pa
 		}
 	}
 
+	if opts.MainOnly && pkg.Name != "main" && pkg.Error == nil {
+		pkg.Error = &PackageError{Err: &mainPackageError{importPath: pkg.ImportPath}}
+	}
 	setToolFlags(pkg)
 
 	return pkg
diff --git a/src/cmd/go/internal/run/run.go b/src/cmd/go/internal/run/run.go
index 914e5edc6f..784f7162df 100644
--- a/src/cmd/go/internal/run/run.go
+++ b/src/cmd/go/internal/run/run.go
@@ -92,6 +92,7 @@ func runRun(ctx context.Context, cmd *base.Command, args []string) {
 	for i < len(args) && strings.HasSuffix(args[i], ".go") {
 		i++
 	}
+	pkgOpts := load.PackageOpts{MainOnly: true}
 	var p *load.Package
 	if i > 0 {
 		files := args[:i]
@@ -102,10 +103,9 @@ func runRun(ctx context.Context, cmd *base.Command, args []string) {
 				base.Fatalf("go run: cannot run *_test.go files (%s)", file)
 			}
 		}
-		p = load.GoFilesPackage(ctx, load.PackageOpts{}, files)
+		p = load.GoFilesPackage(ctx, pkgOpts, files)
 	} else if len(args) > 0 && !strings.HasPrefix(args[0], "-") {
 		arg := args[0]
-		pkgOpts := load.PackageOpts{MainOnly: true}
 		var pkgs []*load.Package
 		if strings.Contains(arg, "@") && !build.IsLocalImport(arg) && !filepath.IsAbs(arg) {
 			var err error
@@ -133,9 +133,6 @@ func runRun(ctx context.Context, cmd *base.Command, args []string) {
 		base.Fatalf("go run: no go files listed")
 	}
 	cmdArgs := args[i:]
-	if p.Name != "main" {
-		base.Fatalf("go run: cannot run non-main package")
-	}
 	load.CheckPackageErrors([]*load.Package{p})
 
 	p.Internal.OmitDebug = true
diff --git a/src/cmd/go/testdata/script/mod_install_pkg_version.txt b/src/cmd/go/testdata/script/mod_install_pkg_version.txt
index 3b387cd8b6..9a803c4218 100644
--- a/src/cmd/go/testdata/script/mod_install_pkg_version.txt
+++ b/src/cmd/go/testdata/script/mod_install_pkg_version.txt
@@ -118,7 +118,7 @@ stderr '^package rsc.io/fortune provided by module rsc.io/fortune@v1.0.0\n\tAll
 # 'go install pkg@version' should report an error if an argument is not
 # a main package.
 ! go install example.com/cmd/a@v1.0.0 example.com/cmd/err@v1.0.0
-stderr '^go: package example.com/cmd/err is not a main package$'
+stderr '^package example.com/cmd/err is not a main package$'
 
 # Wildcards should match only main packages. This module has a non-main package
 # with an error, so we'll know if that gets built.
diff --git a/src/cmd/go/testdata/script/mod_outside.txt b/src/cmd/go/testdata/script/mod_outside.txt
index 0b01492cde..33341f7d4b 100644
--- a/src/cmd/go/testdata/script/mod_outside.txt
+++ b/src/cmd/go/testdata/script/mod_outside.txt
@@ -207,10 +207,6 @@ stderr 'needmod[/\\]needmod.go:10:2: no required module provides package example
 go install cmd/addr2line
 ! stderr .
 
-# 'go run' with a version should fail due to syntax.
-! go run example.com/printversion@v1.0.0
-stderr 'can only use path@version syntax with'
-
 # 'go run' should fail if a package argument must be resolved to a module.
 ! go run example.com/printversion
 stderr '^no required module provides package example.com/printversion: go.mod file not found in current directory or any parent directory; see ''go help modules''$'
diff --git a/src/cmd/go/testdata/script/mod_run_pkg_version.txt b/src/cmd/go/testdata/script/mod_run_pkg_version.txt
index d96d3fc213..48462230b6 100644
--- a/src/cmd/go/testdata/script/mod_run_pkg_version.txt
+++ b/src/cmd/go/testdata/script/mod_run_pkg_version.txt
@@ -36,6 +36,11 @@ stderr '^go: found rsc.io/quote in rsc.io/quote v1.5.2$'
 stderr '^Hello, world.$'
 
 
+# 'go run pkg@version' should report an error if pkg is not a main package.
+! go run example.com/cmd/err@v1.0.0
+stderr '^package example.com/cmd/err is not a main package$'
+
+
 # 'go run pkg@version' should report errors if the module contains
 # replace or exclude directives.
 go mod download example.com/cmd@v1.0.0-replace
-- 
GitLab


From c1e8a9a8c6315f63b7fa0eee8a79589bb02f89fa Mon Sep 17 00:00:00 2001
From: HowJMay <vulxj0j8j8@gmail.com>
Date: Fri, 16 Apr 2021 17:36:22 +0000
Subject: [PATCH 1613/2400] net/http/cgi: Remove hard-coded ServeHTTP timeout

Close #43624

Change-Id: Ifaea3d8ec2aeabbd923abf5edd7497172dbf855a
GitHub-Last-Rev: ea3ef953a1dbbb07c4554e4062571af716e9505b
GitHub-Pull-Request: golang/go#43803
Reviewed-on: https://go-review.googlesource.com/c/go/+/284778
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Trust: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/net/http/cgi/integration_test.go | 29 +++-------------------------
 1 file changed, 3 insertions(+), 26 deletions(-)

diff --git a/src/net/http/cgi/integration_test.go b/src/net/http/cgi/integration_test.go
index 76cbca8e60..ef2eaf748b 100644
--- a/src/net/http/cgi/integration_test.go
+++ b/src/net/http/cgi/integration_test.go
@@ -95,12 +95,6 @@ func (w *limitWriter) Write(p []byte) (n int, err error) {
 func TestKillChildAfterCopyError(t *testing.T) {
 	testenv.MustHaveExec(t)
 
-	defer func() { testHookStartProcess = nil }()
-	proc := make(chan *os.Process, 1)
-	testHookStartProcess = func(p *os.Process) {
-		proc <- p
-	}
-
 	h := &Handler{
 		Path: os.Args[0],
 		Root: "/test.go",
@@ -112,26 +106,9 @@ func TestKillChildAfterCopyError(t *testing.T) {
 	const writeLen = 50 << 10
 	rw := &customWriterRecorder{&limitWriter{&out, writeLen}, rec}
 
-	donec := make(chan bool, 1)
-	go func() {
-		h.ServeHTTP(rw, req)
-		donec <- true
-	}()
-
-	select {
-	case <-donec:
-		if out.Len() != writeLen || out.Bytes()[0] != 'a' {
-			t.Errorf("unexpected output: %q", out.Bytes())
-		}
-	case <-time.After(5 * time.Second):
-		t.Errorf("timeout. ServeHTTP hung and didn't kill the child process?")
-		select {
-		case p := <-proc:
-			p.Kill()
-			t.Logf("killed process")
-		default:
-			t.Logf("didn't kill process")
-		}
+	h.ServeHTTP(rw, req)
+	if out.Len() != writeLen || out.Bytes()[0] != 'a' {
+		t.Errorf("unexpected output: %q", out.Bytes())
 	}
 }
 
-- 
GitLab


From 2fc0ebb623e2859094ad3f41e61325df0c2163f8 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 16 Apr 2021 12:17:27 -0400
Subject: [PATCH 1614/2400] cmd/go/internal/modload: when outside a module, set
 cfg.BuildMod based on allowMissingModuleImports

For #36460

Change-Id: I50c7018a6841bba1a8c6f8f8eca150df1f685526
Reviewed-on: https://go-review.googlesource.com/c/go/+/310789
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modload/init.go | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index 45852edbd1..35bbcc795e 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -617,7 +617,13 @@ func fixVersion(ctx context.Context, fixed *bool) modfile.VersionFixer {
 // when there is no module root. Normally, this is forbidden because it's slow
 // and there's no way to make the result reproducible, but some commands
 // like 'go get' are expected to do this.
+//
+// This function affects the default cfg.BuildMod when outside of a module,
+// so it can only be called prior to Init.
 func AllowMissingModuleImports() {
+	if initialized {
+		panic("AllowMissingModuleImports after Init")
+	}
 	allowMissingModuleImports = true
 }
 
@@ -699,7 +705,11 @@ func setDefaultBuildMod() {
 		return
 	}
 	if modRoot == "" {
-		cfg.BuildMod = "readonly"
+		if allowMissingModuleImports {
+			cfg.BuildMod = "mod"
+		} else {
+			cfg.BuildMod = "readonly"
+		}
 		return
 	}
 
-- 
GitLab


From 95ed5c3800a87ddf9b0ec3958eaaa1a969306293 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 15 Apr 2021 23:05:49 -0400
Subject: [PATCH 1615/2400] internal/buildcfg: move build configuration out of
 cmd/internal/objabi

The go/build package needs access to this configuration,
so move it into a new package available to the standard library.

Change-Id: I868a94148b52350c76116451f4ad9191246adcff
Reviewed-on: https://go-review.googlesource.com/c/go/+/310731
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Austin Clements <austin@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 .gitignore                                    |   1 +
 src/cmd/asm/internal/asm/endtoend_test.go     |   6 +-
 src/cmd/asm/internal/asm/operand_test.go      |   6 +-
 src/cmd/asm/internal/lex/input.go             |   3 +-
 src/cmd/asm/main.go                           |   7 +-
 src/cmd/cgo/main.go                           |   6 +-
 src/cmd/compile/internal/amd64/ggen.go        |   8 +-
 src/cmd/compile/internal/amd64/ssa.go         |  14 +-
 src/cmd/compile/internal/arm/galign.go        |   4 +-
 src/cmd/compile/internal/arm/ssa.go           |   6 +-
 src/cmd/compile/internal/arm64/ggen.go        |   4 +-
 src/cmd/compile/internal/base/flag.go         |  19 +--
 src/cmd/compile/internal/base/print.go        |   4 +-
 src/cmd/compile/internal/dwarfgen/dwarf.go    |   3 +-
 src/cmd/compile/internal/gc/main.go           |   5 +-
 src/cmd/compile/internal/logopt/log_opts.go   |   6 +-
 src/cmd/compile/internal/mips/galign.go       |   6 +-
 src/cmd/compile/internal/mips64/galign.go     |   6 +-
 src/cmd/compile/internal/noder/import.go      |   7 +-
 src/cmd/compile/internal/noder/lex.go         |   6 +-
 src/cmd/compile/internal/ppc64/galign.go      |   4 +-
 src/cmd/compile/internal/ppc64/ssa.go         |   4 +-
 .../compile/internal/reflectdata/reflect.go   |   3 +-
 src/cmd/compile/internal/ssa/compile.go       |   4 +-
 src/cmd/compile/internal/ssa/config.go        |   8 +-
 src/cmd/compile/internal/ssa/gen/AMD64.rules  |   2 +-
 src/cmd/compile/internal/ssa/gen/ARM.rules    |  58 ++++----
 src/cmd/compile/internal/ssa/gen/PPC64.rules  |  38 ++---
 src/cmd/compile/internal/ssa/gen/Wasm.rules   |   6 +-
 src/cmd/compile/internal/ssa/gen/rulegen.go   |   2 +-
 src/cmd/compile/internal/ssa/nilcheck.go      |   4 +-
 src/cmd/compile/internal/ssa/regalloc.go      |   4 +-
 src/cmd/compile/internal/ssa/rewrite386.go    |   6 +-
 src/cmd/compile/internal/ssa/rewriteAMD64.go  |  14 +-
 src/cmd/compile/internal/ssa/rewriteARM.go    | 130 ++++++++---------
 src/cmd/compile/internal/ssa/rewritePPC64.go  |  88 ++++++------
 .../compile/internal/ssa/rewriteRISCV64.go    |   6 +-
 src/cmd/compile/internal/ssa/rewriteS390X.go  |   8 +-
 src/cmd/compile/internal/ssa/rewriteWasm.go   |  32 +++--
 .../compile/internal/ssa/rewritegeneric.go    |   6 +-
 src/cmd/compile/internal/ssagen/abi.go        |   7 +-
 src/cmd/compile/internal/ssagen/pgen.go       |   5 +-
 src/cmd/compile/internal/ssagen/ssa.go        |  17 +--
 src/cmd/compile/internal/staticdata/data.go   |   3 +-
 src/cmd/compile/internal/walk/expr.go         |   4 +-
 src/cmd/compile/internal/walk/order.go        |   4 +-
 src/cmd/compile/internal/walk/range.go        |   2 +-
 src/cmd/compile/internal/wasm/ssa.go          |   6 +-
 src/cmd/compile/internal/x86/galign.go        |   4 +-
 src/cmd/compile/main.go                       |   7 +-
 src/cmd/dist/buildruntime.go                  |  37 +++--
 src/cmd/dist/buildtool.go                     |   4 +-
 src/cmd/go/internal/cfg/cfg.go                |  15 +-
 src/cmd/go/internal/work/exec.go              |   6 +-
 src/cmd/go/internal/work/gc.go                |   3 +-
 src/cmd/go/internal/work/init.go              |   4 +-
 src/cmd/go/main.go                            |   6 +
 src/cmd/go/script_test.go                     |   4 +-
 src/cmd/internal/dwarf/dwarf.go               |   6 +-
 src/cmd/internal/goobj/objfile_test.go        |   5 +-
 src/cmd/internal/obj/arm/asm5.go              |   7 +-
 src/cmd/internal/obj/arm/obj5.go              |   3 +-
 src/cmd/internal/obj/arm64/obj7.go            |   3 +-
 src/cmd/internal/obj/sym.go                   |   5 +-
 src/cmd/internal/obj/util.go                  |   7 +-
 src/cmd/internal/obj/x86/asm6.go              |   3 +-
 src/cmd/internal/obj/x86/obj6.go              |   5 +-
 src/cmd/internal/objabi/flag.go               |   9 +-
 src/cmd/internal/objabi/line.go               |   5 +-
 src/cmd/internal/objabi/stack.go              |   4 +-
 src/cmd/internal/objabi/util.go               | 111 +-------------
 src/cmd/link/internal/ld/ar.go                |   4 +-
 src/cmd/link/internal/ld/config.go            |  50 +++----
 src/cmd/link/internal/ld/data_test.go         |   7 +-
 src/cmd/link/internal/ld/deadcode.go          |   5 +-
 src/cmd/link/internal/ld/dwarf.go             |   3 +-
 src/cmd/link/internal/ld/elf.go               |  11 +-
 src/cmd/link/internal/ld/lib.go               |  43 +++---
 src/cmd/link/internal/ld/macho.go             |   5 +-
 src/cmd/link/internal/ld/main.go              |  11 +-
 src/cmd/link/internal/ld/pcln.go              |   3 +-
 src/cmd/link/internal/ld/pe.go                |  11 +-
 src/cmd/link/internal/ld/sym.go               |   5 +-
 src/cmd/link/internal/ld/symtab.go            |   3 +-
 src/cmd/link/internal/mips/obj.go             |   3 +-
 src/cmd/link/internal/mips64/obj.go           |   3 +-
 src/cmd/link/internal/ppc64/obj.go            |   3 +-
 src/cmd/link/internal/wasm/asm.go             |  11 +-
 src/cmd/link/linkbig_test.go                  |   8 +-
 src/cmd/link/main.go                          |   7 +-
 src/go/build/deps_test.go                     |   5 +-
 src/internal/buildcfg/cfg.go                  | 136 ++++++++++++++++++
 .../objabi => internal/buildcfg}/exp.go       |  10 +-
 src/internal/goexperiment/flags.go            |  11 +-
 94 files changed, 674 insertions(+), 549 deletions(-)
 create mode 100644 src/internal/buildcfg/cfg.go
 rename src/{cmd/internal/objabi => internal/buildcfg}/exp.go (94%)

diff --git a/.gitignore b/.gitignore
index 39723909c7..aa62a9fad7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -37,6 +37,7 @@ _testmain.go
 /src/cmd/internal/objabi/zbootstrap.go
 /src/go/build/zcgo.go
 /src/go/doc/headscan
+/src/internal/buildcfg/zbootstrap.go
 /src/runtime/internal/sys/zversion.go
 /src/unicode/maketables
 /test.out
diff --git a/src/cmd/asm/internal/asm/endtoend_test.go b/src/cmd/asm/internal/asm/endtoend_test.go
index ee2982df39..ead8b27b01 100644
--- a/src/cmd/asm/internal/asm/endtoend_test.go
+++ b/src/cmd/asm/internal/asm/endtoend_test.go
@@ -8,6 +8,7 @@ import (
 	"bufio"
 	"bytes"
 	"fmt"
+	"internal/buildcfg"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -19,7 +20,6 @@ import (
 
 	"cmd/asm/internal/lex"
 	"cmd/internal/obj"
-	"cmd/internal/objabi"
 )
 
 // An end-to-end test for the assembler: Do we print what we parse?
@@ -368,10 +368,10 @@ func Test386EndToEnd(t *testing.T) {
 }
 
 func TestARMEndToEnd(t *testing.T) {
-	defer func(old int) { objabi.GOARM = old }(objabi.GOARM)
+	defer func(old int) { buildcfg.GOARM = old }(buildcfg.GOARM)
 	for _, goarm := range []int{5, 6, 7} {
 		t.Logf("GOARM=%d", goarm)
-		objabi.GOARM = goarm
+		buildcfg.GOARM = goarm
 		testEndToEnd(t, "arm", "arm")
 		if goarm == 6 {
 			testEndToEnd(t, "arm", "armv6")
diff --git a/src/cmd/asm/internal/asm/operand_test.go b/src/cmd/asm/internal/asm/operand_test.go
index c6def15e20..8ef02b1a0e 100644
--- a/src/cmd/asm/internal/asm/operand_test.go
+++ b/src/cmd/asm/internal/asm/operand_test.go
@@ -5,20 +5,20 @@
 package asm
 
 import (
+	"internal/buildcfg"
 	"strings"
 	"testing"
 
 	"cmd/asm/internal/arch"
 	"cmd/asm/internal/lex"
 	"cmd/internal/obj"
-	"cmd/internal/objabi"
 )
 
 // A simple in-out test: Do we print what we parse?
 
 func setArch(goarch string) (*arch.Arch, *obj.Link) {
-	objabi.GOOS = "linux" // obj can handle this OS for all architectures.
-	objabi.GOARCH = goarch
+	buildcfg.GOOS = "linux" // obj can handle this OS for all architectures.
+	buildcfg.GOARCH = goarch
 	architecture := arch.Set(goarch)
 	if architecture == nil {
 		panic("asm: unrecognized architecture " + goarch)
diff --git a/src/cmd/asm/internal/lex/input.go b/src/cmd/asm/internal/lex/input.go
index aa03759c7d..e373ae817e 100644
--- a/src/cmd/asm/internal/lex/input.go
+++ b/src/cmd/asm/internal/lex/input.go
@@ -6,6 +6,7 @@ package lex
 
 import (
 	"fmt"
+	"internal/buildcfg"
 	"os"
 	"path/filepath"
 	"strconv"
@@ -49,7 +50,7 @@ func predefine(defines flags.MultiFlag) map[string]*Macro {
 	// Set macros for GOEXPERIMENTs so we can easily switch
 	// runtime assembly code based on them.
 	if *flags.CompilingRuntime {
-		for _, exp := range objabi.EnabledExperiments() {
+		for _, exp := range buildcfg.EnabledExperiments() {
 			// Define macro.
 			name := "GOEXPERIMENT_" + exp
 			macros[name] = &Macro{
diff --git a/src/cmd/asm/main.go b/src/cmd/asm/main.go
index 98618a67ef..e5a9ee565e 100644
--- a/src/cmd/asm/main.go
+++ b/src/cmd/asm/main.go
@@ -8,6 +8,7 @@ import (
 	"bufio"
 	"flag"
 	"fmt"
+	"internal/buildcfg"
 	"log"
 	"os"
 
@@ -18,14 +19,14 @@ import (
 
 	"cmd/internal/bio"
 	"cmd/internal/obj"
-	"cmd/internal/objabi"
 )
 
 func main() {
 	log.SetFlags(0)
 	log.SetPrefix("asm: ")
 
-	GOARCH := objabi.GOARCH
+	buildcfg.Check()
+	GOARCH := buildcfg.GOARCH
 
 	architecture := arch.Set(GOARCH)
 	if architecture == nil {
@@ -68,7 +69,7 @@ func main() {
 	defer buf.Close()
 
 	if !*flags.SymABIs {
-		fmt.Fprintf(buf, "go object %s %s %s\n", objabi.GOOS, objabi.GOARCH, objabi.Version)
+		fmt.Fprintf(buf, "go object %s %s %s\n", buildcfg.GOOS, buildcfg.GOARCH, buildcfg.Version)
 		fmt.Fprintf(buf, "!\n")
 	}
 
diff --git a/src/cmd/cgo/main.go b/src/cmd/cgo/main.go
index 77ac5e0d3a..03a662e689 100644
--- a/src/cmd/cgo/main.go
+++ b/src/cmd/cgo/main.go
@@ -17,6 +17,7 @@ import (
 	"go/ast"
 	"go/printer"
 	"go/token"
+	"internal/buildcfg"
 	"io"
 	"io/ioutil"
 	"os"
@@ -414,8 +415,9 @@ func newPackage(args []string) *Package {
 	if s := os.Getenv("GOOS"); s != "" {
 		goos = s
 	}
-	gomips = objabi.GOMIPS
-	gomips64 = objabi.GOMIPS64
+	buildcfg.Check()
+	gomips = buildcfg.GOMIPS
+	gomips64 = buildcfg.GOMIPS64
 	ptrSize := ptrSizeMap[goarch]
 	if ptrSize == 0 {
 		fatalf("unknown ptrSize for $GOARCH %q", goarch)
diff --git a/src/cmd/compile/internal/amd64/ggen.go b/src/cmd/compile/internal/amd64/ggen.go
index b5847d48b9..1484ad5404 100644
--- a/src/cmd/compile/internal/amd64/ggen.go
+++ b/src/cmd/compile/internal/amd64/ggen.go
@@ -11,11 +11,11 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/x86"
-	"cmd/internal/objabi"
+	"internal/buildcfg"
 )
 
 // no floating point in note handlers on Plan 9
-var isPlan9 = objabi.GOOS == "plan9"
+var isPlan9 = buildcfg.GOOS == "plan9"
 
 // DUFFZERO consists of repeated blocks of 4 MOVUPSs + LEAQ,
 // See runtime/mkduff.go.
@@ -85,7 +85,7 @@ func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.
 		}
 		p = pp.Append(p, x86.AMOVQ, obj.TYPE_REG, x86.REG_R13, 0, obj.TYPE_MEM, x86.REG_SP, off)
 	} else if !isPlan9 && cnt <= int64(8*types.RegSize) {
-		if !objabi.Experiment.RegabiG && *state&x15 == 0 {
+		if !buildcfg.Experiment.RegabiG && *state&x15 == 0 {
 			p = pp.Append(p, x86.AXORPS, obj.TYPE_REG, x86.REG_X15, 0, obj.TYPE_REG, x86.REG_X15, 0)
 			*state |= x15
 		}
@@ -98,7 +98,7 @@ func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, state *uint32) *obj.
 			p = pp.Append(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X15, 0, obj.TYPE_MEM, x86.REG_SP, off+cnt-int64(16))
 		}
 	} else if !isPlan9 && (cnt <= int64(128*types.RegSize)) {
-		if !objabi.Experiment.RegabiG && *state&x15 == 0 {
+		if !buildcfg.Experiment.RegabiG && *state&x15 == 0 {
 			p = pp.Append(p, x86.AXORPS, obj.TYPE_REG, x86.REG_X15, 0, obj.TYPE_REG, x86.REG_X15, 0)
 			*state |= x15
 		}
diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index fce3c6b820..42c12953f9 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -6,6 +6,7 @@ package amd64
 
 import (
 	"fmt"
+	"internal/buildcfg"
 	"math"
 
 	"cmd/compile/internal/base"
@@ -17,7 +18,6 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/x86"
-	"cmd/internal/objabi"
 )
 
 // markMoves marks any MOVXconst ops that need to avoid clobbering flags.
@@ -825,7 +825,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Reg = v.Args[0].Reg()
 		ssagen.AddAux2(&p.To, v, sc.Off64())
 	case ssa.OpAMD64MOVOstorezero:
-		if !objabi.Experiment.RegabiG || s.ABI != obj.ABIInternal {
+		if !buildcfg.Experiment.RegabiG || s.ABI != obj.ABIInternal {
 			// zero X15 manually
 			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
 		}
@@ -916,7 +916,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.OpAMD64DUFFZERO:
-		if !objabi.Experiment.RegabiG || s.ABI != obj.ABIInternal {
+		if !buildcfg.Experiment.RegabiG || s.ABI != obj.ABIInternal {
 			// zero X15 manually
 			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
 		}
@@ -999,20 +999,20 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		// Closure pointer is DX.
 		ssagen.CheckLoweredGetClosurePtr(v)
 	case ssa.OpAMD64LoweredGetG:
-		if objabi.Experiment.RegabiG && s.ABI == obj.ABIInternal {
+		if buildcfg.Experiment.RegabiG && s.ABI == obj.ABIInternal {
 			v.Fatalf("LoweredGetG should not appear in ABIInternal")
 		}
 		r := v.Reg()
 		getgFromTLS(s, r)
 	case ssa.OpAMD64CALLstatic:
-		if objabi.Experiment.RegabiG && s.ABI == obj.ABI0 && v.Aux.(*ssa.AuxCall).Fn.ABI() == obj.ABIInternal {
+		if buildcfg.Experiment.RegabiG && s.ABI == obj.ABI0 && v.Aux.(*ssa.AuxCall).Fn.ABI() == obj.ABIInternal {
 			// zeroing X15 when entering ABIInternal from ABI0
 			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
 			// set G register from TLS
 			getgFromTLS(s, x86.REG_R14)
 		}
 		s.Call(v)
-		if objabi.Experiment.RegabiG && s.ABI == obj.ABIInternal && v.Aux.(*ssa.AuxCall).Fn.ABI() == obj.ABI0 {
+		if buildcfg.Experiment.RegabiG && s.ABI == obj.ABIInternal && v.Aux.(*ssa.AuxCall).Fn.ABI() == obj.ABI0 {
 			// zeroing X15 when entering ABIInternal from ABI0
 			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
 			// set G register from TLS
@@ -1306,7 +1306,7 @@ func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
 	case ssa.BlockRet:
 		s.Prog(obj.ARET)
 	case ssa.BlockRetJmp:
-		if objabi.Experiment.RegabiG && s.ABI == obj.ABI0 && b.Aux.(*obj.LSym).ABI() == obj.ABIInternal {
+		if buildcfg.Experiment.RegabiG && s.ABI == obj.ABI0 && b.Aux.(*obj.LSym).ABI() == obj.ABIInternal {
 			// zeroing X15 when entering ABIInternal from ABI0
 			opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
 			// set G register from TLS
diff --git a/src/cmd/compile/internal/arm/galign.go b/src/cmd/compile/internal/arm/galign.go
index 81959ae0ab..d68500280d 100644
--- a/src/cmd/compile/internal/arm/galign.go
+++ b/src/cmd/compile/internal/arm/galign.go
@@ -8,14 +8,14 @@ import (
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/ssagen"
 	"cmd/internal/obj/arm"
-	"cmd/internal/objabi"
+	"internal/buildcfg"
 )
 
 func Init(arch *ssagen.ArchInfo) {
 	arch.LinkArch = &arm.Linkarm
 	arch.REGSP = arm.REGSP
 	arch.MAXWIDTH = (1 << 32) - 1
-	arch.SoftFloat = objabi.GOARM == 5
+	arch.SoftFloat = buildcfg.GOARM == 5
 	arch.ZeroRange = zerorange
 	arch.Ginsnop = ginsnop
 	arch.Ginsnopdefer = ginsnop
diff --git a/src/cmd/compile/internal/arm/ssa.go b/src/cmd/compile/internal/arm/ssa.go
index 832f940c26..4b083cec46 100644
--- a/src/cmd/compile/internal/arm/ssa.go
+++ b/src/cmd/compile/internal/arm/ssa.go
@@ -6,6 +6,7 @@ package arm
 
 import (
 	"fmt"
+	"internal/buildcfg"
 	"math"
 	"math/bits"
 
@@ -17,7 +18,6 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/arm"
-	"cmd/internal/objabi"
 )
 
 // loadByType returns the load instruction of the given type.
@@ -286,7 +286,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 	case ssa.OpARMANDconst, ssa.OpARMBICconst:
 		// try to optimize ANDconst and BICconst to BFC, which saves bytes and ticks
 		// BFC is only available on ARMv7, and its result and source are in the same register
-		if objabi.GOARM == 7 && v.Reg() == v.Args[0].Reg() {
+		if buildcfg.GOARM == 7 && v.Reg() == v.Args[0].Reg() {
 			var val uint32
 			if v.Op == ssa.OpARMANDconst {
 				val = ^uint32(v.AuxInt)
@@ -643,7 +643,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 			default:
 			}
 		}
-		if objabi.GOARM >= 6 {
+		if buildcfg.GOARM >= 6 {
 			// generate more efficient "MOVB/MOVBU/MOVH/MOVHU Reg@>0, Reg" on ARMv6 & ARMv7
 			genshift(s, v.Op.Asm(), 0, v.Args[0].Reg(), v.Reg(), arm.SHIFT_RR, 0)
 			return
diff --git a/src/cmd/compile/internal/arm64/ggen.go b/src/cmd/compile/internal/arm64/ggen.go
index 8364535f63..89be496461 100644
--- a/src/cmd/compile/internal/arm64/ggen.go
+++ b/src/cmd/compile/internal/arm64/ggen.go
@@ -10,10 +10,10 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/arm64"
-	"cmd/internal/objabi"
+	"internal/buildcfg"
 )
 
-var darwin = objabi.GOOS == "darwin" || objabi.GOOS == "ios"
+var darwin = buildcfg.GOOS == "darwin" || buildcfg.GOOS == "ios"
 
 func padframe(frame int64) int64 {
 	// arm64 requires that the frame size (not counting saved FP&LR)
diff --git a/src/cmd/compile/internal/base/flag.go b/src/cmd/compile/internal/base/flag.go
index 4b7ef155a1..42c0c1b94b 100644
--- a/src/cmd/compile/internal/base/flag.go
+++ b/src/cmd/compile/internal/base/flag.go
@@ -8,6 +8,7 @@ import (
 	"encoding/json"
 	"flag"
 	"fmt"
+	"internal/buildcfg"
 	"io/ioutil"
 	"log"
 	"os"
@@ -146,7 +147,7 @@ func ParseFlags() {
 	Flag.LowerP = &Ctxt.Pkgpath
 	Flag.LowerV = &Ctxt.Debugvlog
 
-	Flag.Dwarf = objabi.GOARCH != "wasm"
+	Flag.Dwarf = buildcfg.GOARCH != "wasm"
 	Flag.DwarfBASEntries = &Ctxt.UseBASEntries
 	Flag.DwarfLocationLists = &Ctxt.Flag_locationlists
 	*Flag.DwarfLocationLists = true
@@ -168,14 +169,14 @@ func ParseFlags() {
 	registerFlags()
 	objabi.Flagparse(usage)
 
-	if Flag.MSan && !sys.MSanSupported(objabi.GOOS, objabi.GOARCH) {
-		log.Fatalf("%s/%s does not support -msan", objabi.GOOS, objabi.GOARCH)
+	if Flag.MSan && !sys.MSanSupported(buildcfg.GOOS, buildcfg.GOARCH) {
+		log.Fatalf("%s/%s does not support -msan", buildcfg.GOOS, buildcfg.GOARCH)
 	}
-	if Flag.Race && !sys.RaceDetectorSupported(objabi.GOOS, objabi.GOARCH) {
-		log.Fatalf("%s/%s does not support -race", objabi.GOOS, objabi.GOARCH)
+	if Flag.Race && !sys.RaceDetectorSupported(buildcfg.GOOS, buildcfg.GOARCH) {
+		log.Fatalf("%s/%s does not support -race", buildcfg.GOOS, buildcfg.GOARCH)
 	}
 	if (*Flag.Shared || *Flag.Dynlink || *Flag.LinkShared) && !Ctxt.Arch.InFamily(sys.AMD64, sys.ARM, sys.ARM64, sys.I386, sys.PPC64, sys.RISCV64, sys.S390X) {
-		log.Fatalf("%s/%s does not support -shared", objabi.GOOS, objabi.GOARCH)
+		log.Fatalf("%s/%s does not support -shared", buildcfg.GOOS, buildcfg.GOARCH)
 	}
 	parseSpectre(Flag.Spectre) // left as string for RecordFlags
 
@@ -347,7 +348,7 @@ func concurrentBackendAllowed() bool {
 		return false
 	}
 	// TODO: Test and delete this condition.
-	if objabi.Experiment.FieldTrack {
+	if buildcfg.Experiment.FieldTrack {
 		return false
 	}
 	// TODO: fix races and enable the following flags
@@ -458,11 +459,11 @@ func parseSpectre(s string) {
 	}
 
 	if Flag.Cfg.SpectreIndex {
-		switch objabi.GOARCH {
+		switch buildcfg.GOARCH {
 		case "amd64":
 			// ok
 		default:
-			log.Fatalf("GOARCH=%s does not support -spectre=index", objabi.GOARCH)
+			log.Fatalf("GOARCH=%s does not support -spectre=index", buildcfg.GOARCH)
 		}
 	}
 }
diff --git a/src/cmd/compile/internal/base/print.go b/src/cmd/compile/internal/base/print.go
index 668c600d31..b095fd704d 100644
--- a/src/cmd/compile/internal/base/print.go
+++ b/src/cmd/compile/internal/base/print.go
@@ -6,12 +6,12 @@ package base
 
 import (
 	"fmt"
+	"internal/buildcfg"
 	"os"
 	"runtime/debug"
 	"sort"
 	"strings"
 
-	"cmd/internal/objabi"
 	"cmd/internal/src"
 )
 
@@ -217,7 +217,7 @@ func FatalfAt(pos src.XPos, format string, args ...interface{}) {
 		fmt.Printf("\n")
 
 		// If this is a released compiler version, ask for a bug report.
-		if strings.HasPrefix(objabi.Version, "go") {
+		if strings.HasPrefix(buildcfg.Version, "go") {
 			fmt.Printf("\n")
 			fmt.Printf("Please file a bug report including a short program that triggers the error.\n")
 			fmt.Printf("https://golang.org/issue/new\n")
diff --git a/src/cmd/compile/internal/dwarfgen/dwarf.go b/src/cmd/compile/internal/dwarfgen/dwarf.go
index 7b5863bbc6..0754a8810c 100644
--- a/src/cmd/compile/internal/dwarfgen/dwarf.go
+++ b/src/cmd/compile/internal/dwarfgen/dwarf.go
@@ -8,6 +8,7 @@ import (
 	"bytes"
 	"flag"
 	"fmt"
+	"internal/buildcfg"
 	"sort"
 
 	"cmd/compile/internal/base"
@@ -278,7 +279,7 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 		if base.Ctxt.FixedFrameSize() == 0 {
 			offs -= int64(types.PtrSize)
 		}
-		if objabi.FramePointerEnabled {
+		if buildcfg.FramePointerEnabled {
 			offs -= int64(types.PtrSize)
 		}
 
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 68506c7a7b..ce50cbb4c2 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -28,6 +28,7 @@ import (
 	"cmd/internal/src"
 	"flag"
 	"fmt"
+	"internal/buildcfg"
 	"log"
 	"os"
 	"runtime"
@@ -158,7 +159,7 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 		dwarf.EnableLogging(base.Debug.DwarfInl != 0)
 	}
 	if base.Debug.SoftFloat != 0 {
-		if objabi.Experiment.RegabiArgs {
+		if buildcfg.Experiment.RegabiArgs {
 			log.Fatalf("softfloat mode with GOEXPERIMENT=regabiargs not implemented ")
 		}
 		ssagen.Arch.SoftFloat = true
@@ -335,7 +336,7 @@ func writebench(filename string) error {
 	}
 
 	var buf bytes.Buffer
-	fmt.Fprintln(&buf, "commit:", objabi.Version)
+	fmt.Fprintln(&buf, "commit:", buildcfg.Version)
 	fmt.Fprintln(&buf, "goos:", runtime.GOOS)
 	fmt.Fprintln(&buf, "goarch:", runtime.GOARCH)
 	base.Timer.Write(&buf, "BenchmarkCompile:"+base.Ctxt.Pkgpath+":")
diff --git a/src/cmd/compile/internal/logopt/log_opts.go b/src/cmd/compile/internal/logopt/log_opts.go
index 37a049d640..97ebf56944 100644
--- a/src/cmd/compile/internal/logopt/log_opts.go
+++ b/src/cmd/compile/internal/logopt/log_opts.go
@@ -6,10 +6,10 @@ package logopt
 
 import (
 	"cmd/internal/obj"
-	"cmd/internal/objabi"
 	"cmd/internal/src"
 	"encoding/json"
 	"fmt"
+	"internal/buildcfg"
 	"io"
 	"log"
 	"net/url"
@@ -408,7 +408,7 @@ func uprootedPath(filename string) string {
 	if !strings.HasPrefix(filename, "$GOROOT/") {
 		return filename
 	}
-	return objabi.GOROOT + filename[len("$GOROOT"):]
+	return buildcfg.GOROOT + filename[len("$GOROOT"):]
 }
 
 // FlushLoggedOpts flushes all the accumulated optimization log entries.
@@ -448,7 +448,7 @@ func FlushLoggedOpts(ctxt *obj.Link, slashPkgPath string) {
 				currentFile = p0f
 				w = writerForLSP(subdirpath, currentFile)
 				encoder = json.NewEncoder(w)
-				encoder.Encode(VersionHeader{Version: 0, Package: slashPkgPath, Goos: objabi.GOOS, Goarch: objabi.GOARCH, GcVersion: objabi.Version, File: currentFile})
+				encoder.Encode(VersionHeader{Version: 0, Package: slashPkgPath, Goos: buildcfg.GOOS, Goarch: buildcfg.GOARCH, GcVersion: buildcfg.Version, File: currentFile})
 			}
 
 			// The first "target" is the most important one.
diff --git a/src/cmd/compile/internal/mips/galign.go b/src/cmd/compile/internal/mips/galign.go
index 599163550b..f892923ba0 100644
--- a/src/cmd/compile/internal/mips/galign.go
+++ b/src/cmd/compile/internal/mips/galign.go
@@ -8,17 +8,17 @@ import (
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/ssagen"
 	"cmd/internal/obj/mips"
-	"cmd/internal/objabi"
+	"internal/buildcfg"
 )
 
 func Init(arch *ssagen.ArchInfo) {
 	arch.LinkArch = &mips.Linkmips
-	if objabi.GOARCH == "mipsle" {
+	if buildcfg.GOARCH == "mipsle" {
 		arch.LinkArch = &mips.Linkmipsle
 	}
 	arch.REGSP = mips.REGSP
 	arch.MAXWIDTH = (1 << 31) - 1
-	arch.SoftFloat = (objabi.GOMIPS == "softfloat")
+	arch.SoftFloat = (buildcfg.GOMIPS == "softfloat")
 	arch.ZeroRange = zerorange
 	arch.Ginsnop = ginsnop
 	arch.Ginsnopdefer = ginsnop
diff --git a/src/cmd/compile/internal/mips64/galign.go b/src/cmd/compile/internal/mips64/galign.go
index fc0a34228c..af81366e51 100644
--- a/src/cmd/compile/internal/mips64/galign.go
+++ b/src/cmd/compile/internal/mips64/galign.go
@@ -8,17 +8,17 @@ import (
 	"cmd/compile/internal/ssa"
 	"cmd/compile/internal/ssagen"
 	"cmd/internal/obj/mips"
-	"cmd/internal/objabi"
+	"internal/buildcfg"
 )
 
 func Init(arch *ssagen.ArchInfo) {
 	arch.LinkArch = &mips.Linkmips64
-	if objabi.GOARCH == "mips64le" {
+	if buildcfg.GOARCH == "mips64le" {
 		arch.LinkArch = &mips.Linkmips64le
 	}
 	arch.REGSP = mips.REGSP
 	arch.MAXWIDTH = 1 << 50
-	arch.SoftFloat = objabi.GOMIPS64 == "softfloat"
+	arch.SoftFloat = buildcfg.GOMIPS64 == "softfloat"
 	arch.ZeroRange = zerorange
 	arch.Ginsnop = ginsnop
 	arch.Ginsnopdefer = ginsnop
diff --git a/src/cmd/compile/internal/noder/import.go b/src/cmd/compile/internal/noder/import.go
index e6e3fe1834..701e9001c8 100644
--- a/src/cmd/compile/internal/noder/import.go
+++ b/src/cmd/compile/internal/noder/import.go
@@ -7,6 +7,7 @@ package noder
 import (
 	"errors"
 	"fmt"
+	"internal/buildcfg"
 	"io"
 	"os"
 	pathpkg "path"
@@ -108,7 +109,7 @@ func openPackage(path string) (*os.File, error) {
 		}
 	}
 
-	if objabi.GOROOT != "" {
+	if buildcfg.GOROOT != "" {
 		suffix := ""
 		if base.Flag.InstallSuffix != "" {
 			suffix = "_" + base.Flag.InstallSuffix
@@ -118,10 +119,10 @@ func openPackage(path string) (*os.File, error) {
 			suffix = "_msan"
 		}
 
-		if file, err := os.Open(fmt.Sprintf("%s/pkg/%s_%s%s/%s.a", objabi.GOROOT, objabi.GOOS, objabi.GOARCH, suffix, path)); err == nil {
+		if file, err := os.Open(fmt.Sprintf("%s/pkg/%s_%s%s/%s.a", buildcfg.GOROOT, buildcfg.GOOS, buildcfg.GOARCH, suffix, path)); err == nil {
 			return file, nil
 		}
-		if file, err := os.Open(fmt.Sprintf("%s/pkg/%s_%s%s/%s.o", objabi.GOROOT, objabi.GOOS, objabi.GOARCH, suffix, path)); err == nil {
+		if file, err := os.Open(fmt.Sprintf("%s/pkg/%s_%s%s/%s.o", buildcfg.GOROOT, buildcfg.GOOS, buildcfg.GOARCH, suffix, path)); err == nil {
 			return file, nil
 		}
 	}
diff --git a/src/cmd/compile/internal/noder/lex.go b/src/cmd/compile/internal/noder/lex.go
index 60b724d154..66a56a50ec 100644
--- a/src/cmd/compile/internal/noder/lex.go
+++ b/src/cmd/compile/internal/noder/lex.go
@@ -6,11 +6,11 @@ package noder
 
 import (
 	"fmt"
+	"internal/buildcfg"
 	"strings"
 
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/syntax"
-	"cmd/internal/objabi"
 )
 
 func isSpace(c rune) bool {
@@ -44,7 +44,7 @@ func pragmaFlag(verb string) ir.PragmaFlag {
 	case "go:build":
 		return ir.GoBuildPragma
 	case "go:nointerface":
-		if objabi.Experiment.FieldTrack {
+		if buildcfg.Experiment.FieldTrack {
 			return ir.Nointerface
 		}
 	case "go:noescape":
@@ -110,7 +110,7 @@ func (p *noder) pragcgo(pos syntax.Pos, text string) {
 		case len(f) == 3 && !isQuoted(f[1]) && !isQuoted(f[2]):
 		case len(f) == 4 && !isQuoted(f[1]) && !isQuoted(f[2]) && isQuoted(f[3]):
 			f[3] = strings.Trim(f[3], `"`)
-			if objabi.GOOS == "aix" && f[3] != "" {
+			if buildcfg.GOOS == "aix" && f[3] != "" {
 				// On Aix, library pattern must be "lib.a/object.o"
 				// or "lib.a/libname.so.X"
 				n := strings.Split(f[3], "/")
diff --git a/src/cmd/compile/internal/ppc64/galign.go b/src/cmd/compile/internal/ppc64/galign.go
index c72d1aa834..590290fa37 100644
--- a/src/cmd/compile/internal/ppc64/galign.go
+++ b/src/cmd/compile/internal/ppc64/galign.go
@@ -7,12 +7,12 @@ package ppc64
 import (
 	"cmd/compile/internal/ssagen"
 	"cmd/internal/obj/ppc64"
-	"cmd/internal/objabi"
+	"internal/buildcfg"
 )
 
 func Init(arch *ssagen.ArchInfo) {
 	arch.LinkArch = &ppc64.Linkppc64
-	if objabi.GOARCH == "ppc64le" {
+	if buildcfg.GOARCH == "ppc64le" {
 		arch.LinkArch = &ppc64.Linkppc64le
 	}
 	arch.REGSP = ppc64.REGSP
diff --git a/src/cmd/compile/internal/ppc64/ssa.go b/src/cmd/compile/internal/ppc64/ssa.go
index a0ad69a68d..11226f65a0 100644
--- a/src/cmd/compile/internal/ppc64/ssa.go
+++ b/src/cmd/compile/internal/ppc64/ssa.go
@@ -13,7 +13,7 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/ppc64"
-	"cmd/internal/objabi"
+	"internal/buildcfg"
 	"math"
 	"strings"
 )
@@ -1873,7 +1873,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		s.UseArgs(16) // space used in callee args area by assembly stubs
 
 	case ssa.OpPPC64LoweredNilCheck:
-		if objabi.GOOS == "aix" {
+		if buildcfg.GOOS == "aix" {
 			// CMP Rarg0, R0
 			// BNE 2(PC)
 			// STW R0, 0(R0)
diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index 379735e86b..f0a60998a1 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -6,6 +6,7 @@ package reflectdata
 
 import (
 	"fmt"
+	"internal/buildcfg"
 	"os"
 	"sort"
 	"strings"
@@ -1774,7 +1775,7 @@ func methodWrapper(rcvr *types.Type, method *types.Field) *obj.LSym {
 	// Disable tailcall for RegabiArgs for now. The IR does not connect the
 	// arguments with the OTAILCALL node, and the arguments are not marshaled
 	// correctly.
-	if !base.Flag.Cfg.Instrumenting && rcvr.IsPtr() && methodrcvr.IsPtr() && method.Embedded != 0 && !types.IsInterfaceMethod(method.Type) && !(base.Ctxt.Arch.Name == "ppc64le" && base.Ctxt.Flag_dynlink) && !objabi.Experiment.RegabiArgs {
+	if !base.Flag.Cfg.Instrumenting && rcvr.IsPtr() && methodrcvr.IsPtr() && method.Embedded != 0 && !types.IsInterfaceMethod(method.Type) && !(base.Ctxt.Arch.Name == "ppc64le" && base.Ctxt.Flag_dynlink) && !buildcfg.Experiment.RegabiArgs {
 		// generate tail call: adjust pointer receiver and jump to embedded method.
 		left := dot.X // skip final .M
 		if !left.Type().IsPtr() {
diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go
index b1bcd4566e..8aae04f2ec 100644
--- a/src/cmd/compile/internal/ssa/compile.go
+++ b/src/cmd/compile/internal/ssa/compile.go
@@ -6,10 +6,10 @@ package ssa
 
 import (
 	"bytes"
-	"cmd/internal/objabi"
 	"cmd/internal/src"
 	"fmt"
 	"hash/crc32"
+	"internal/buildcfg"
 	"log"
 	"math/rand"
 	"os"
@@ -454,7 +454,7 @@ var passes = [...]pass{
 	{name: "dse", fn: dse},
 	{name: "writebarrier", fn: writebarrier, required: true}, // expand write barrier ops
 	{name: "insert resched checks", fn: insertLoopReschedChecks,
-		disabled: !objabi.Experiment.PreemptibleLoops}, // insert resched checks in loops.
+		disabled: !buildcfg.Experiment.PreemptibleLoops}, // insert resched checks in loops.
 	{name: "lower", fn: lower, required: true},
 	{name: "addressing modes", fn: addressingModes, required: false},
 	{name: "lowered deadcode for cse", fn: deadcode}, // deadcode immediately before CSE avoids CSE making dead values live again
diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go
index 75fa71ce35..4ffa047096 100644
--- a/src/cmd/compile/internal/ssa/config.go
+++ b/src/cmd/compile/internal/ssa/config.go
@@ -9,8 +9,8 @@ import (
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
-	"cmd/internal/objabi"
 	"cmd/internal/src"
+	"internal/buildcfg"
 )
 
 // A Config holds readonly compilation information.
@@ -203,7 +203,7 @@ func NewConfig(arch string, types Types, ctxt *obj.Link, optimize bool) *Config
 		c.floatParamRegs = paramFloatRegAMD64
 		c.FPReg = framepointerRegAMD64
 		c.LinkReg = linkRegAMD64
-		c.hasGReg = objabi.Experiment.RegabiG
+		c.hasGReg = buildcfg.Experiment.RegabiG
 	case "386":
 		c.PtrSize = 4
 		c.RegSize = 4
@@ -238,7 +238,7 @@ func NewConfig(arch string, types Types, ctxt *obj.Link, optimize bool) *Config
 		c.FPReg = framepointerRegARM64
 		c.LinkReg = linkRegARM64
 		c.hasGReg = true
-		c.noDuffDevice = objabi.GOOS == "darwin" || objabi.GOOS == "ios" // darwin linker cannot handle BR26 reloc with non-zero addend
+		c.noDuffDevice = buildcfg.GOOS == "darwin" || buildcfg.GOOS == "ios" // darwin linker cannot handle BR26 reloc with non-zero addend
 	case "ppc64":
 		c.BigEndian = true
 		fallthrough
@@ -336,7 +336,7 @@ func NewConfig(arch string, types Types, ctxt *obj.Link, optimize bool) *Config
 	c.ABI1 = abi.NewABIConfig(len(c.intParamRegs), len(c.floatParamRegs), ctxt.FixedFrameSize())
 
 	// On Plan 9, floating point operations are not allowed in note handler.
-	if objabi.GOOS == "plan9" {
+	if buildcfg.GOOS == "plan9" {
 		// Don't use FMA on Plan 9
 		c.UseFMA = false
 
diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules
index 839d4a330e..7a88a488c0 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64.rules
+++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules
@@ -460,7 +460,7 @@
 (IsInBounds idx len) => (SETB (CMPQ idx len))
 (IsSliceInBounds idx len) => (SETBE (CMPQ idx len))
 (NilCheck ...) => (LoweredNilCheck ...)
-(GetG mem) && !(objabi.Experiment.RegabiG && v.Block.Func.OwnAux.Fn.ABI() == obj.ABIInternal) => (LoweredGetG mem) // only lower in old ABI. in new ABI we have a G register.
+(GetG mem) && !(buildcfg.Experiment.RegabiG && v.Block.Func.OwnAux.Fn.ABI() == obj.ABIInternal) => (LoweredGetG mem) // only lower in old ABI. in new ABI we have a G register.
 (GetClosurePtr ...) => (LoweredGetClosurePtr ...)
 (GetCallerPC ...) => (LoweredGetCallerPC ...)
 (GetCallerSP ...) => (LoweredGetCallerSP ...)
diff --git a/src/cmd/compile/internal/ssa/gen/ARM.rules b/src/cmd/compile/internal/ssa/gen/ARM.rules
index 5c6438a986..bcacbafe3a 100644
--- a/src/cmd/compile/internal/ssa/gen/ARM.rules
+++ b/src/cmd/compile/internal/ssa/gen/ARM.rules
@@ -66,17 +66,17 @@
 
 // count trailing zero for ARMv5 and ARMv6
 // 32 - CLZ(x&-x - 1)
-(Ctz32 <t> x) && objabi.GOARM<=6 =>
+(Ctz32 <t> x) && buildcfg.GOARM<=6 =>
 	(RSBconst [32] (CLZ <t> (SUBconst <t> (AND <t> x (RSBconst <t> [0] x)) [1])))
-(Ctz16 <t> x) && objabi.GOARM<=6 =>
+(Ctz16 <t> x) && buildcfg.GOARM<=6 =>
 	(RSBconst [32] (CLZ <t> (SUBconst <typ.UInt32> (AND <typ.UInt32> (ORconst <typ.UInt32> [0x10000] x) (RSBconst <typ.UInt32> [0] (ORconst <typ.UInt32> [0x10000] x))) [1])))
-(Ctz8 <t> x) && objabi.GOARM<=6 =>
+(Ctz8 <t> x) && buildcfg.GOARM<=6 =>
 	(RSBconst [32] (CLZ <t> (SUBconst <typ.UInt32> (AND <typ.UInt32> (ORconst <typ.UInt32> [0x100] x) (RSBconst <typ.UInt32> [0] (ORconst <typ.UInt32> [0x100] x))) [1])))
 
 // count trailing zero for ARMv7
-(Ctz32 <t> x) && objabi.GOARM==7 => (CLZ <t> (RBIT <t> x))
-(Ctz16 <t> x) && objabi.GOARM==7 => (CLZ <t> (RBIT <typ.UInt32> (ORconst <typ.UInt32> [0x10000] x)))
-(Ctz8 <t> x) && objabi.GOARM==7 => (CLZ <t> (RBIT <typ.UInt32> (ORconst <typ.UInt32> [0x100] x)))
+(Ctz32 <t> x) && buildcfg.GOARM==7 => (CLZ <t> (RBIT <t> x))
+(Ctz16 <t> x) && buildcfg.GOARM==7 => (CLZ <t> (RBIT <typ.UInt32> (ORconst <typ.UInt32> [0x10000] x)))
+(Ctz8 <t> x) && buildcfg.GOARM==7 => (CLZ <t> (RBIT <typ.UInt32> (ORconst <typ.UInt32> [0x100] x)))
 
 // bit length
 (BitLen32 <t> x) => (RSBconst [32] (CLZ <t> x))
@@ -90,13 +90,13 @@
 // t5 = x right rotate 8 bits  -- (d,   a,   b,   c  )
 // result = t4 ^ t5            -- (d,   c,   b,   a  )
 // using shifted ops this can be done in 4 instructions.
-(Bswap32 <t> x) && objabi.GOARM==5 =>
+(Bswap32 <t> x) && buildcfg.GOARM==5 =>
 	(XOR <t>
 		(SRLconst <t> (BICconst <t> (XOR <t> x (SRRconst <t> [16] x)) [0xff0000]) [8])
 		(SRRconst <t> x [8]))
 
 // byte swap for ARMv6 and above
-(Bswap32 x) && objabi.GOARM>=6 => (REV x)
+(Bswap32 x) && buildcfg.GOARM>=6 => (REV x)
 
 // boolean ops -- booleans are represented with 0=false, 1=true
 (AndB ...) => (AND ...)
@@ -737,10 +737,10 @@
 (SUBconst [c] x) && !isARMImmRot(uint32(c)) && isARMImmRot(uint32(-c)) => (ADDconst [-c] x)
 (ANDconst [c] x) && !isARMImmRot(uint32(c)) && isARMImmRot(^uint32(c)) => (BICconst [int32(^uint32(c))] x)
 (BICconst [c] x) && !isARMImmRot(uint32(c)) && isARMImmRot(^uint32(c)) => (ANDconst [int32(^uint32(c))] x)
-(ADDconst [c] x) && objabi.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && uint32(-c)<=0xffff => (SUBconst [-c] x)
-(SUBconst [c] x) && objabi.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && uint32(-c)<=0xffff => (ADDconst [-c] x)
-(ANDconst [c] x) && objabi.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && ^uint32(c)<=0xffff => (BICconst [int32(^uint32(c))] x)
-(BICconst [c] x) && objabi.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && ^uint32(c)<=0xffff => (ANDconst [int32(^uint32(c))] x)
+(ADDconst [c] x) && buildcfg.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && uint32(-c)<=0xffff => (SUBconst [-c] x)
+(SUBconst [c] x) && buildcfg.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && uint32(-c)<=0xffff => (ADDconst [-c] x)
+(ANDconst [c] x) && buildcfg.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && ^uint32(c)<=0xffff => (BICconst [int32(^uint32(c))] x)
+(BICconst [c] x) && buildcfg.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && ^uint32(c)<=0xffff => (ANDconst [int32(^uint32(c))] x)
 (ADDconst [c] (MOVWconst [d])) => (MOVWconst [c+d])
 (ADDconst [c] (ADDconst [d] x)) => (ADDconst [c+d] x)
 (ADDconst [c] (SUBconst [d] x)) => (ADDconst [c-d] x)
@@ -1144,7 +1144,7 @@
 // UBFX instruction is supported by ARMv6T2, ARMv7 and above versions, REV16 is supported by
 // ARMv6 and above versions. So for ARMv6, we need to match SLLconst, SRLconst and ORshiftLL.
 ((ADDshiftLL|ORshiftLL|XORshiftLL) <typ.UInt16> [8] (BFXU <typ.UInt16> [int32(armBFAuxInt(8, 8))] x) x) => (REV16 x)
-((ADDshiftLL|ORshiftLL|XORshiftLL) <typ.UInt16> [8] (SRLconst <typ.UInt16> [24] (SLLconst [16] x)) x) && objabi.GOARM>=6 => (REV16 x)
+((ADDshiftLL|ORshiftLL|XORshiftLL) <typ.UInt16> [8] (SRLconst <typ.UInt16> [24] (SLLconst [16] x)) x) && buildcfg.GOARM>=6 => (REV16 x)
 
 // use indexed loads and stores
 (MOVWload [0] {sym} (ADD ptr idx) mem) && sym == nil => (MOVWloadidx ptr idx mem)
@@ -1214,25 +1214,25 @@
 (BIC x x) => (MOVWconst [0])
 
 (ADD (MUL x y) a) => (MULA x y a)
-(SUB a (MUL x y)) && objabi.GOARM == 7 => (MULS x y a)
-(RSB (MUL x y) a) && objabi.GOARM == 7 => (MULS x y a)
+(SUB a (MUL x y)) && buildcfg.GOARM == 7 => (MULS x y a)
+(RSB (MUL x y) a) && buildcfg.GOARM == 7 => (MULS x y a)
 
-(NEGF (MULF x y)) && objabi.GOARM >= 6 => (NMULF x y)
-(NEGD (MULD x y)) && objabi.GOARM >= 6 => (NMULD x y)
-(MULF (NEGF x) y) && objabi.GOARM >= 6 => (NMULF x y)
-(MULD (NEGD x) y) && objabi.GOARM >= 6 => (NMULD x y)
+(NEGF (MULF x y)) && buildcfg.GOARM >= 6 => (NMULF x y)
+(NEGD (MULD x y)) && buildcfg.GOARM >= 6 => (NMULD x y)
+(MULF (NEGF x) y) && buildcfg.GOARM >= 6 => (NMULF x y)
+(MULD (NEGD x) y) && buildcfg.GOARM >= 6 => (NMULD x y)
 (NMULF (NEGF x) y) => (MULF x y)
 (NMULD (NEGD x) y) => (MULD x y)
 
 // the result will overwrite the addend, since they are in the same register
-(ADDF a (MULF x y)) && a.Uses == 1 && objabi.GOARM >= 6 => (MULAF a x y)
-(ADDF a (NMULF x y)) && a.Uses == 1 && objabi.GOARM >= 6 => (MULSF a x y)
-(ADDD a (MULD x y)) && a.Uses == 1 && objabi.GOARM >= 6 => (MULAD a x y)
-(ADDD a (NMULD x y)) && a.Uses == 1 && objabi.GOARM >= 6 => (MULSD a x y)
-(SUBF a (MULF x y)) && a.Uses == 1 && objabi.GOARM >= 6 => (MULSF a x y)
-(SUBF a (NMULF x y)) && a.Uses == 1 && objabi.GOARM >= 6 => (MULAF a x y)
-(SUBD a (MULD x y)) && a.Uses == 1 && objabi.GOARM >= 6 => (MULSD a x y)
-(SUBD a (NMULD x y)) && a.Uses == 1 && objabi.GOARM >= 6 => (MULAD a x y)
+(ADDF a (MULF x y)) && a.Uses == 1 && buildcfg.GOARM >= 6 => (MULAF a x y)
+(ADDF a (NMULF x y)) && a.Uses == 1 && buildcfg.GOARM >= 6 => (MULSF a x y)
+(ADDD a (MULD x y)) && a.Uses == 1 && buildcfg.GOARM >= 6 => (MULAD a x y)
+(ADDD a (NMULD x y)) && a.Uses == 1 && buildcfg.GOARM >= 6 => (MULSD a x y)
+(SUBF a (MULF x y)) && a.Uses == 1 && buildcfg.GOARM >= 6 => (MULSF a x y)
+(SUBF a (NMULF x y)) && a.Uses == 1 && buildcfg.GOARM >= 6 => (MULAF a x y)
+(SUBD a (MULD x y)) && a.Uses == 1 && buildcfg.GOARM >= 6 => (MULSD a x y)
+(SUBD a (NMULD x y)) && a.Uses == 1 && buildcfg.GOARM >= 6 => (MULAD a x y)
 
 (AND x (MVN y)) => (BIC x y)
 
@@ -1264,8 +1264,8 @@
 (CMPD x (MOVDconst [0])) => (CMPD0 x)
 
 // bit extraction
-(SRAconst (SLLconst x [c]) [d]) && objabi.GOARM==7 && uint64(d)>=uint64(c) && uint64(d)<=31 => (BFX [(d-c)|(32-d)<<8] x)
-(SRLconst (SLLconst x [c]) [d]) && objabi.GOARM==7 && uint64(d)>=uint64(c) && uint64(d)<=31 => (BFXU [(d-c)|(32-d)<<8] x)
+(SRAconst (SLLconst x [c]) [d]) && buildcfg.GOARM==7 && uint64(d)>=uint64(c) && uint64(d)<=31 => (BFX [(d-c)|(32-d)<<8] x)
+(SRLconst (SLLconst x [c]) [d]) && buildcfg.GOARM==7 && uint64(d)>=uint64(c) && uint64(d)<=31 => (BFXU [(d-c)|(32-d)<<8] x)
 
 // comparison simplification
 ((LT|LE|EQ|NE|GE|GT) (CMP x (RSBconst [0] y))) => ((LT|LE|EQ|NE|GE|GT) (CMN x y)) // sense of carry bit not preserved
diff --git a/src/cmd/compile/internal/ssa/gen/PPC64.rules b/src/cmd/compile/internal/ssa/gen/PPC64.rules
index f83ff75761..ce4b324b5e 100644
--- a/src/cmd/compile/internal/ssa/gen/PPC64.rules
+++ b/src/cmd/compile/internal/ssa/gen/PPC64.rules
@@ -12,20 +12,20 @@
 (Sub64F ...) => (FSUB ...)
 
 // Combine 64 bit integer multiply and adds
-(ADD l:(MULLD x y) z) && objabi.GOPPC64 >= 9 && l.Uses == 1 && clobber(l) => (MADDLD x y z)
+(ADD l:(MULLD x y) z) && buildcfg.GOPPC64 >= 9 && l.Uses == 1 && clobber(l) => (MADDLD x y z)
 
 (Mod16 x y) => (Mod32 (SignExt16to32 x) (SignExt16to32 y))
 (Mod16u x y) => (Mod32u (ZeroExt16to32 x) (ZeroExt16to32 y))
 (Mod8 x y) => (Mod32 (SignExt8to32 x) (SignExt8to32 y))
 (Mod8u x y) => (Mod32u (ZeroExt8to32 x) (ZeroExt8to32 y))
-(Mod64 x y) && objabi.GOPPC64 >=9 => (MODSD x y)
-(Mod64 x y) && objabi.GOPPC64 <=8 => (SUB x (MULLD y (DIVD x y)))
-(Mod64u x y) && objabi.GOPPC64 >= 9 => (MODUD x y)
-(Mod64u x y) && objabi.GOPPC64 <= 8 => (SUB x (MULLD y (DIVDU x y)))
-(Mod32 x y) && objabi.GOPPC64 >= 9 => (MODSW x y)
-(Mod32 x y) && objabi.GOPPC64 <= 8 => (SUB x (MULLW y (DIVW x y)))
-(Mod32u x y) && objabi.GOPPC64 >= 9 => (MODUW x y)
-(Mod32u x y) && objabi.GOPPC64 <= 8 => (SUB x (MULLW y (DIVWU x y)))
+(Mod64 x y) && buildcfg.GOPPC64 >=9 => (MODSD x y)
+(Mod64 x y) && buildcfg.GOPPC64 <=8 => (SUB x (MULLD y (DIVD x y)))
+(Mod64u x y) && buildcfg.GOPPC64 >= 9 => (MODUD x y)
+(Mod64u x y) && buildcfg.GOPPC64 <= 8 => (SUB x (MULLD y (DIVDU x y)))
+(Mod32 x y) && buildcfg.GOPPC64 >= 9 => (MODSW x y)
+(Mod32 x y) && buildcfg.GOPPC64 <= 8 => (SUB x (MULLW y (DIVW x y)))
+(Mod32u x y) && buildcfg.GOPPC64 >= 9 => (MODUW x y)
+(Mod32u x y) && buildcfg.GOPPC64 <= 8 => (SUB x (MULLW y (DIVWU x y)))
 
 // (x + y) / 2 with x>=y => (x - y) / 2 + y
 (Avg64u <t> x y) => (ADD (SRDconst <t> (SUB <t> x y) [1]) y)
@@ -351,9 +351,9 @@
 (Ctz32NonZero ...) => (Ctz32 ...)
 (Ctz64NonZero ...) => (Ctz64 ...)
 
-(Ctz64 x) && objabi.GOPPC64<=8 => (POPCNTD (ANDN <typ.Int64> (ADDconst <typ.Int64> [-1] x) x))
+(Ctz64 x) && buildcfg.GOPPC64<=8 => (POPCNTD (ANDN <typ.Int64> (ADDconst <typ.Int64> [-1] x) x))
 (Ctz64 x) => (CNTTZD x)
-(Ctz32 x) && objabi.GOPPC64<=8 => (POPCNTW (MOVWZreg (ANDN <typ.Int> (ADDconst <typ.Int> [-1] x) x)))
+(Ctz32 x) && buildcfg.GOPPC64<=8 => (POPCNTW (MOVWZreg (ANDN <typ.Int> (ADDconst <typ.Int> [-1] x) x)))
 (Ctz32 x) => (CNTTZW (MOVWZreg x))
 (Ctz16 x) => (POPCNTW (MOVHZreg (ANDN <typ.Int16> (ADDconst <typ.Int16> [-1] x) x)))
 (Ctz8 x)  => (POPCNTB (MOVBZreg (ANDN <typ.UInt8> (ADDconst <typ.UInt8> [-1] x) x)))
@@ -627,10 +627,10 @@
 // Handle cases not handled above
 // Lowered Short cases do not generate loops, and as a result don't clobber
 // the address registers or flags.
-(Zero [s] ptr mem) && objabi.GOPPC64 <= 8 && s < 64 => (LoweredZeroShort [s] ptr mem)
-(Zero [s] ptr mem) && objabi.GOPPC64 <= 8 => (LoweredZero [s] ptr mem)
-(Zero [s] ptr mem) && s < 128 && objabi.GOPPC64 >= 9 => (LoweredQuadZeroShort [s] ptr mem)
-(Zero [s] ptr mem) && objabi.GOPPC64 >= 9 => (LoweredQuadZero [s] ptr mem)
+(Zero [s] ptr mem) && buildcfg.GOPPC64 <= 8 && s < 64 => (LoweredZeroShort [s] ptr mem)
+(Zero [s] ptr mem) && buildcfg.GOPPC64 <= 8 => (LoweredZero [s] ptr mem)
+(Zero [s] ptr mem) && s < 128 && buildcfg.GOPPC64 >= 9 => (LoweredQuadZeroShort [s] ptr mem)
+(Zero [s] ptr mem) && buildcfg.GOPPC64 >= 9 => (LoweredQuadZero [s] ptr mem)
 
 // moves
 (Move [0] _ _ mem) => mem
@@ -658,11 +658,11 @@
 
 // Large move uses a loop. Since the address is computed and the
 // offset is zero, any alignment can be used.
-(Move [s] dst src mem) && s > 8 && objabi.GOPPC64 <= 8 && logLargeCopy(v, s) =>
+(Move [s] dst src mem) && s > 8 && buildcfg.GOPPC64 <= 8 && logLargeCopy(v, s) =>
         (LoweredMove [s] dst src mem)
-(Move [s] dst src mem) && s > 8 && s <= 64 && objabi.GOPPC64 >= 9 =>
+(Move [s] dst src mem) && s > 8 && s <= 64 && buildcfg.GOPPC64 >= 9 =>
         (LoweredQuadMoveShort [s] dst src mem)
-(Move [s] dst src mem) && s > 8 && objabi.GOPPC64 >= 9 && logLargeCopy(v, s) =>
+(Move [s] dst src mem) && s > 8 && buildcfg.GOPPC64 >= 9 && logLargeCopy(v, s) =>
         (LoweredQuadMove [s] dst src mem)
 
 // Calls
@@ -1048,7 +1048,7 @@
 (SLWconst [c] z:(ANDconst [d] x)) && z.Uses == 1 && isPPC64ValidShiftMask(d) && c<=(32-getPPC64ShiftMaskLength(d)) => (CLRLSLWI [newPPC64ShiftAuxInt(c,32-getPPC64ShiftMaskLength(d),31,32)] x)
 (SLWconst [c] z:(AND (MOVDconst [d]) x)) && z.Uses == 1 && isPPC64ValidShiftMask(d) && c<=(32-getPPC64ShiftMaskLength(d)) => (CLRLSLWI [newPPC64ShiftAuxInt(c,32-getPPC64ShiftMaskLength(d),31,32)] x)
 // special case for power9
-(SL(W|D)const [c] z:(MOVWreg x)) && c < 32 && objabi.GOPPC64 >= 9 => (EXTSWSLconst [c] x)
+(SL(W|D)const [c] z:(MOVWreg x)) && c < 32 && buildcfg.GOPPC64 >= 9 => (EXTSWSLconst [c] x)
 
 // Lose widening ops fed to stores
 (MOVBstore [off] {sym} ptr (MOV(B|BZ|H|HZ|W|WZ)reg x) mem) => (MOVBstore [off] {sym} ptr x mem)
diff --git a/src/cmd/compile/internal/ssa/gen/Wasm.rules b/src/cmd/compile/internal/ssa/gen/Wasm.rules
index 7cda16b4b5..7ad3d1c72e 100644
--- a/src/cmd/compile/internal/ssa/gen/Wasm.rules
+++ b/src/cmd/compile/internal/ssa/gen/Wasm.rules
@@ -55,9 +55,9 @@
 (ZeroExt32to64        x:(I64Load32U _ _)) => x
 (ZeroExt16to(64|32)   x:(I64Load16U _ _)) => x
 (ZeroExt8to(64|32|16) x:(I64Load8U  _ _)) => x
-(SignExt32to64        x) && objabi.GOWASM.SignExt => (I64Extend32S x)
-(SignExt8to(64|32|16) x) && objabi.GOWASM.SignExt => (I64Extend8S x)
-(SignExt16to(64|32)   x) && objabi.GOWASM.SignExt => (I64Extend16S x)
+(SignExt32to64        x) && buildcfg.GOWASM.SignExt => (I64Extend32S x)
+(SignExt8to(64|32|16) x) && buildcfg.GOWASM.SignExt => (I64Extend8S x)
+(SignExt16to(64|32)   x) && buildcfg.GOWASM.SignExt => (I64Extend16S x)
 (SignExt32to64        x) => (I64ShrS (I64Shl x (I64Const [32])) (I64Const [32]))
 (SignExt16to(64|32)   x) => (I64ShrS (I64Shl x (I64Const [48])) (I64Const [48]))
 (SignExt8to(64|32|16) x) => (I64ShrS (I64Shl x (I64Const [56])) (I64Const [56]))
diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go
index fd672b2f74..fe8db4ed1f 100644
--- a/src/cmd/compile/internal/ssa/gen/rulegen.go
+++ b/src/cmd/compile/internal/ssa/gen/rulegen.go
@@ -584,9 +584,9 @@ func fprint(w io.Writer, n Node) {
 		fmt.Fprintf(w, "\npackage ssa\n")
 		for _, path := range append([]string{
 			"fmt",
+			"internal/buildcfg",
 			"math",
 			"cmd/internal/obj",
-			"cmd/internal/objabi",
 			"cmd/compile/internal/base",
 			"cmd/compile/internal/types",
 		}, n.Arch.imports...) {
diff --git a/src/cmd/compile/internal/ssa/nilcheck.go b/src/cmd/compile/internal/ssa/nilcheck.go
index bae50657c9..14f511a5f1 100644
--- a/src/cmd/compile/internal/ssa/nilcheck.go
+++ b/src/cmd/compile/internal/ssa/nilcheck.go
@@ -6,8 +6,8 @@ package ssa
 
 import (
 	"cmd/compile/internal/ir"
-	"cmd/internal/objabi"
 	"cmd/internal/src"
+	"internal/buildcfg"
 )
 
 // nilcheckelim eliminates unnecessary nil checks.
@@ -192,7 +192,7 @@ func nilcheckelim(f *Func) {
 const minZeroPage = 4096
 
 // faultOnLoad is true if a load to an address below minZeroPage will trigger a SIGSEGV.
-var faultOnLoad = objabi.GOOS != "aix"
+var faultOnLoad = buildcfg.GOOS != "aix"
 
 // nilcheckelim2 eliminates unnecessary nil checks.
 // Runs after lowering and scheduling.
diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go
index 1baff184b0..336cd3d737 100644
--- a/src/cmd/compile/internal/ssa/regalloc.go
+++ b/src/cmd/compile/internal/ssa/regalloc.go
@@ -117,10 +117,10 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
-	"cmd/internal/objabi"
 	"cmd/internal/src"
 	"cmd/internal/sys"
 	"fmt"
+	"internal/buildcfg"
 	"math/bits"
 	"unsafe"
 )
@@ -609,7 +609,7 @@ func (s *regAllocState) init(f *Func) {
 	if s.f.Config.hasGReg {
 		s.allocatable &^= 1 << s.GReg
 	}
-	if objabi.FramePointerEnabled && s.f.Config.FPReg >= 0 {
+	if buildcfg.FramePointerEnabled && s.f.Config.FPReg >= 0 {
 		s.allocatable &^= 1 << uint(s.f.Config.FPReg)
 	}
 	if s.f.Config.LinkReg != -1 {
diff --git a/src/cmd/compile/internal/ssa/rewrite386.go b/src/cmd/compile/internal/ssa/rewrite386.go
index 1ec2d26f75..93b258afac 100644
--- a/src/cmd/compile/internal/ssa/rewrite386.go
+++ b/src/cmd/compile/internal/ssa/rewrite386.go
@@ -3,8 +3,10 @@
 
 package ssa
 
-import "math"
-import "cmd/compile/internal/types"
+import (
+	"cmd/compile/internal/types"
+	"math"
+)
 
 func rewriteValue386(v *Value) bool {
 	switch v.Op {
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index 1f56b70816..dd92b41c20 100644
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -3,10 +3,12 @@
 
 package ssa
 
-import "math"
-import "cmd/internal/obj"
-import "cmd/internal/objabi"
-import "cmd/compile/internal/types"
+import (
+	"cmd/compile/internal/types"
+	"cmd/internal/obj"
+	"internal/buildcfg"
+	"math"
+)
 
 func rewriteValueAMD64(v *Value) bool {
 	switch v.Op {
@@ -30466,11 +30468,11 @@ func rewriteValueAMD64_OpFloor(v *Value) bool {
 func rewriteValueAMD64_OpGetG(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (GetG mem)
-	// cond: !(objabi.Experiment.RegabiG && v.Block.Func.OwnAux.Fn.ABI() == obj.ABIInternal)
+	// cond: !(buildcfg.Experiment.RegabiG && v.Block.Func.OwnAux.Fn.ABI() == obj.ABIInternal)
 	// result: (LoweredGetG mem)
 	for {
 		mem := v_0
-		if !(!(objabi.Experiment.RegabiG && v.Block.Func.OwnAux.Fn.ABI() == obj.ABIInternal)) {
+		if !(!(buildcfg.Experiment.RegabiG && v.Block.Func.OwnAux.Fn.ABI() == obj.ABIInternal)) {
 			break
 		}
 		v.reset(OpAMD64LoweredGetG)
diff --git a/src/cmd/compile/internal/ssa/rewriteARM.go b/src/cmd/compile/internal/ssa/rewriteARM.go
index 175bbc3e7e..25db5b9fba 100644
--- a/src/cmd/compile/internal/ssa/rewriteARM.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM.go
@@ -3,8 +3,10 @@
 
 package ssa
 
-import "cmd/internal/objabi"
-import "cmd/compile/internal/types"
+import (
+	"cmd/compile/internal/types"
+	"internal/buildcfg"
+)
 
 func rewriteValueARM(v *Value) bool {
 	switch v.Op {
@@ -1475,7 +1477,7 @@ func rewriteValueARM_OpARMADDD(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (ADDD a (MULD x y))
-	// cond: a.Uses == 1 && objabi.GOARM >= 6
+	// cond: a.Uses == 1 && buildcfg.GOARM >= 6
 	// result: (MULAD a x y)
 	for {
 		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
@@ -1485,7 +1487,7 @@ func rewriteValueARM_OpARMADDD(v *Value) bool {
 			}
 			y := v_1.Args[1]
 			x := v_1.Args[0]
-			if !(a.Uses == 1 && objabi.GOARM >= 6) {
+			if !(a.Uses == 1 && buildcfg.GOARM >= 6) {
 				continue
 			}
 			v.reset(OpARMMULAD)
@@ -1495,7 +1497,7 @@ func rewriteValueARM_OpARMADDD(v *Value) bool {
 		break
 	}
 	// match: (ADDD a (NMULD x y))
-	// cond: a.Uses == 1 && objabi.GOARM >= 6
+	// cond: a.Uses == 1 && buildcfg.GOARM >= 6
 	// result: (MULSD a x y)
 	for {
 		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
@@ -1505,7 +1507,7 @@ func rewriteValueARM_OpARMADDD(v *Value) bool {
 			}
 			y := v_1.Args[1]
 			x := v_1.Args[0]
-			if !(a.Uses == 1 && objabi.GOARM >= 6) {
+			if !(a.Uses == 1 && buildcfg.GOARM >= 6) {
 				continue
 			}
 			v.reset(OpARMMULSD)
@@ -1520,7 +1522,7 @@ func rewriteValueARM_OpARMADDF(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (ADDF a (MULF x y))
-	// cond: a.Uses == 1 && objabi.GOARM >= 6
+	// cond: a.Uses == 1 && buildcfg.GOARM >= 6
 	// result: (MULAF a x y)
 	for {
 		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
@@ -1530,7 +1532,7 @@ func rewriteValueARM_OpARMADDF(v *Value) bool {
 			}
 			y := v_1.Args[1]
 			x := v_1.Args[0]
-			if !(a.Uses == 1 && objabi.GOARM >= 6) {
+			if !(a.Uses == 1 && buildcfg.GOARM >= 6) {
 				continue
 			}
 			v.reset(OpARMMULAF)
@@ -1540,7 +1542,7 @@ func rewriteValueARM_OpARMADDF(v *Value) bool {
 		break
 	}
 	// match: (ADDF a (NMULF x y))
-	// cond: a.Uses == 1 && objabi.GOARM >= 6
+	// cond: a.Uses == 1 && buildcfg.GOARM >= 6
 	// result: (MULSF a x y)
 	for {
 		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
@@ -1550,7 +1552,7 @@ func rewriteValueARM_OpARMADDF(v *Value) bool {
 			}
 			y := v_1.Args[1]
 			x := v_1.Args[0]
-			if !(a.Uses == 1 && objabi.GOARM >= 6) {
+			if !(a.Uses == 1 && buildcfg.GOARM >= 6) {
 				continue
 			}
 			v.reset(OpARMMULSF)
@@ -1946,12 +1948,12 @@ func rewriteValueARM_OpARMADDconst(v *Value) bool {
 		return true
 	}
 	// match: (ADDconst [c] x)
-	// cond: objabi.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && uint32(-c)<=0xffff
+	// cond: buildcfg.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && uint32(-c)<=0xffff
 	// result: (SUBconst [-c] x)
 	for {
 		c := auxIntToInt32(v.AuxInt)
 		x := v_0
-		if !(objabi.GOARM == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && uint32(-c) <= 0xffff) {
+		if !(buildcfg.GOARM == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && uint32(-c) <= 0xffff) {
 			break
 		}
 		v.reset(OpARMSUBconst)
@@ -2082,7 +2084,7 @@ func rewriteValueARM_OpARMADDshiftLL(v *Value) bool {
 		return true
 	}
 	// match: (ADDshiftLL <typ.UInt16> [8] (SRLconst <typ.UInt16> [24] (SLLconst [16] x)) x)
-	// cond: objabi.GOARM>=6
+	// cond: buildcfg.GOARM>=6
 	// result: (REV16 x)
 	for {
 		if v.Type != typ.UInt16 || auxIntToInt32(v.AuxInt) != 8 || v_0.Op != OpARMSRLconst || v_0.Type != typ.UInt16 || auxIntToInt32(v_0.AuxInt) != 24 {
@@ -2093,7 +2095,7 @@ func rewriteValueARM_OpARMADDshiftLL(v *Value) bool {
 			break
 		}
 		x := v_0_0.Args[0]
-		if x != v_1 || !(objabi.GOARM >= 6) {
+		if x != v_1 || !(buildcfg.GOARM >= 6) {
 			break
 		}
 		v.reset(OpARMREV16)
@@ -2538,12 +2540,12 @@ func rewriteValueARM_OpARMANDconst(v *Value) bool {
 		return true
 	}
 	// match: (ANDconst [c] x)
-	// cond: objabi.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && ^uint32(c)<=0xffff
+	// cond: buildcfg.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && ^uint32(c)<=0xffff
 	// result: (BICconst [int32(^uint32(c))] x)
 	for {
 		c := auxIntToInt32(v.AuxInt)
 		x := v_0
-		if !(objabi.GOARM == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && ^uint32(c) <= 0xffff) {
+		if !(buildcfg.GOARM == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && ^uint32(c) <= 0xffff) {
 			break
 		}
 		v.reset(OpARMBICconst)
@@ -3033,12 +3035,12 @@ func rewriteValueARM_OpARMBICconst(v *Value) bool {
 		return true
 	}
 	// match: (BICconst [c] x)
-	// cond: objabi.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && ^uint32(c)<=0xffff
+	// cond: buildcfg.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && ^uint32(c)<=0xffff
 	// result: (ANDconst [int32(^uint32(c))] x)
 	for {
 		c := auxIntToInt32(v.AuxInt)
 		x := v_0
-		if !(objabi.GOARM == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && ^uint32(c) <= 0xffff) {
+		if !(buildcfg.GOARM == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && ^uint32(c) <= 0xffff) {
 			break
 		}
 		v.reset(OpARMANDconst)
@@ -7541,7 +7543,7 @@ func rewriteValueARM_OpARMMULD(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (MULD (NEGD x) y)
-	// cond: objabi.GOARM >= 6
+	// cond: buildcfg.GOARM >= 6
 	// result: (NMULD x y)
 	for {
 		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
@@ -7550,7 +7552,7 @@ func rewriteValueARM_OpARMMULD(v *Value) bool {
 			}
 			x := v_0.Args[0]
 			y := v_1
-			if !(objabi.GOARM >= 6) {
+			if !(buildcfg.GOARM >= 6) {
 				continue
 			}
 			v.reset(OpARMNMULD)
@@ -7565,7 +7567,7 @@ func rewriteValueARM_OpARMMULF(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (MULF (NEGF x) y)
-	// cond: objabi.GOARM >= 6
+	// cond: buildcfg.GOARM >= 6
 	// result: (NMULF x y)
 	for {
 		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
@@ -7574,7 +7576,7 @@ func rewriteValueARM_OpARMMULF(v *Value) bool {
 			}
 			x := v_0.Args[0]
 			y := v_1
-			if !(objabi.GOARM >= 6) {
+			if !(buildcfg.GOARM >= 6) {
 				continue
 			}
 			v.reset(OpARMNMULF)
@@ -8186,7 +8188,7 @@ func rewriteValueARM_OpARMMVNshiftRLreg(v *Value) bool {
 func rewriteValueARM_OpARMNEGD(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (NEGD (MULD x y))
-	// cond: objabi.GOARM >= 6
+	// cond: buildcfg.GOARM >= 6
 	// result: (NMULD x y)
 	for {
 		if v_0.Op != OpARMMULD {
@@ -8194,7 +8196,7 @@ func rewriteValueARM_OpARMNEGD(v *Value) bool {
 		}
 		y := v_0.Args[1]
 		x := v_0.Args[0]
-		if !(objabi.GOARM >= 6) {
+		if !(buildcfg.GOARM >= 6) {
 			break
 		}
 		v.reset(OpARMNMULD)
@@ -8206,7 +8208,7 @@ func rewriteValueARM_OpARMNEGD(v *Value) bool {
 func rewriteValueARM_OpARMNEGF(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (NEGF (MULF x y))
-	// cond: objabi.GOARM >= 6
+	// cond: buildcfg.GOARM >= 6
 	// result: (NMULF x y)
 	for {
 		if v_0.Op != OpARMMULF {
@@ -8214,7 +8216,7 @@ func rewriteValueARM_OpARMNEGF(v *Value) bool {
 		}
 		y := v_0.Args[1]
 		x := v_0.Args[0]
-		if !(objabi.GOARM >= 6) {
+		if !(buildcfg.GOARM >= 6) {
 			break
 		}
 		v.reset(OpARMNMULF)
@@ -8538,7 +8540,7 @@ func rewriteValueARM_OpARMORshiftLL(v *Value) bool {
 		return true
 	}
 	// match: (ORshiftLL <typ.UInt16> [8] (SRLconst <typ.UInt16> [24] (SLLconst [16] x)) x)
-	// cond: objabi.GOARM>=6
+	// cond: buildcfg.GOARM>=6
 	// result: (REV16 x)
 	for {
 		if v.Type != typ.UInt16 || auxIntToInt32(v.AuxInt) != 8 || v_0.Op != OpARMSRLconst || v_0.Type != typ.UInt16 || auxIntToInt32(v_0.AuxInt) != 24 {
@@ -8549,7 +8551,7 @@ func rewriteValueARM_OpARMORshiftLL(v *Value) bool {
 			break
 		}
 		x := v_0_0.Args[0]
-		if x != v_1 || !(objabi.GOARM >= 6) {
+		if x != v_1 || !(buildcfg.GOARM >= 6) {
 			break
 		}
 		v.reset(OpARMREV16)
@@ -9013,7 +9015,7 @@ func rewriteValueARM_OpARMRSB(v *Value) bool {
 		return true
 	}
 	// match: (RSB (MUL x y) a)
-	// cond: objabi.GOARM == 7
+	// cond: buildcfg.GOARM == 7
 	// result: (MULS x y a)
 	for {
 		if v_0.Op != OpARMMUL {
@@ -9022,7 +9024,7 @@ func rewriteValueARM_OpARMRSB(v *Value) bool {
 		y := v_0.Args[1]
 		x := v_0.Args[0]
 		a := v_1
-		if !(objabi.GOARM == 7) {
+		if !(buildcfg.GOARM == 7) {
 			break
 		}
 		v.reset(OpARMMULS)
@@ -10449,7 +10451,7 @@ func rewriteValueARM_OpARMSRAconst(v *Value) bool {
 		return true
 	}
 	// match: (SRAconst (SLLconst x [c]) [d])
-	// cond: objabi.GOARM==7 && uint64(d)>=uint64(c) && uint64(d)<=31
+	// cond: buildcfg.GOARM==7 && uint64(d)>=uint64(c) && uint64(d)<=31
 	// result: (BFX [(d-c)|(32-d)<<8] x)
 	for {
 		d := auxIntToInt32(v.AuxInt)
@@ -10458,7 +10460,7 @@ func rewriteValueARM_OpARMSRAconst(v *Value) bool {
 		}
 		c := auxIntToInt32(v_0.AuxInt)
 		x := v_0.Args[0]
-		if !(objabi.GOARM == 7 && uint64(d) >= uint64(c) && uint64(d) <= 31) {
+		if !(buildcfg.GOARM == 7 && uint64(d) >= uint64(c) && uint64(d) <= 31) {
 			break
 		}
 		v.reset(OpARMBFX)
@@ -10501,7 +10503,7 @@ func rewriteValueARM_OpARMSRLconst(v *Value) bool {
 		return true
 	}
 	// match: (SRLconst (SLLconst x [c]) [d])
-	// cond: objabi.GOARM==7 && uint64(d)>=uint64(c) && uint64(d)<=31
+	// cond: buildcfg.GOARM==7 && uint64(d)>=uint64(c) && uint64(d)<=31
 	// result: (BFXU [(d-c)|(32-d)<<8] x)
 	for {
 		d := auxIntToInt32(v.AuxInt)
@@ -10510,7 +10512,7 @@ func rewriteValueARM_OpARMSRLconst(v *Value) bool {
 		}
 		c := auxIntToInt32(v_0.AuxInt)
 		x := v_0.Args[0]
-		if !(objabi.GOARM == 7 && uint64(d) >= uint64(c) && uint64(d) <= 31) {
+		if !(buildcfg.GOARM == 7 && uint64(d) >= uint64(c) && uint64(d) <= 31) {
 			break
 		}
 		v.reset(OpARMBFXU)
@@ -10723,7 +10725,7 @@ func rewriteValueARM_OpARMSUB(v *Value) bool {
 		return true
 	}
 	// match: (SUB a (MUL x y))
-	// cond: objabi.GOARM == 7
+	// cond: buildcfg.GOARM == 7
 	// result: (MULS x y a)
 	for {
 		a := v_0
@@ -10732,7 +10734,7 @@ func rewriteValueARM_OpARMSUB(v *Value) bool {
 		}
 		y := v_1.Args[1]
 		x := v_1.Args[0]
-		if !(objabi.GOARM == 7) {
+		if !(buildcfg.GOARM == 7) {
 			break
 		}
 		v.reset(OpARMMULS)
@@ -10745,7 +10747,7 @@ func rewriteValueARM_OpARMSUBD(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (SUBD a (MULD x y))
-	// cond: a.Uses == 1 && objabi.GOARM >= 6
+	// cond: a.Uses == 1 && buildcfg.GOARM >= 6
 	// result: (MULSD a x y)
 	for {
 		a := v_0
@@ -10754,7 +10756,7 @@ func rewriteValueARM_OpARMSUBD(v *Value) bool {
 		}
 		y := v_1.Args[1]
 		x := v_1.Args[0]
-		if !(a.Uses == 1 && objabi.GOARM >= 6) {
+		if !(a.Uses == 1 && buildcfg.GOARM >= 6) {
 			break
 		}
 		v.reset(OpARMMULSD)
@@ -10762,7 +10764,7 @@ func rewriteValueARM_OpARMSUBD(v *Value) bool {
 		return true
 	}
 	// match: (SUBD a (NMULD x y))
-	// cond: a.Uses == 1 && objabi.GOARM >= 6
+	// cond: a.Uses == 1 && buildcfg.GOARM >= 6
 	// result: (MULAD a x y)
 	for {
 		a := v_0
@@ -10771,7 +10773,7 @@ func rewriteValueARM_OpARMSUBD(v *Value) bool {
 		}
 		y := v_1.Args[1]
 		x := v_1.Args[0]
-		if !(a.Uses == 1 && objabi.GOARM >= 6) {
+		if !(a.Uses == 1 && buildcfg.GOARM >= 6) {
 			break
 		}
 		v.reset(OpARMMULAD)
@@ -10784,7 +10786,7 @@ func rewriteValueARM_OpARMSUBF(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (SUBF a (MULF x y))
-	// cond: a.Uses == 1 && objabi.GOARM >= 6
+	// cond: a.Uses == 1 && buildcfg.GOARM >= 6
 	// result: (MULSF a x y)
 	for {
 		a := v_0
@@ -10793,7 +10795,7 @@ func rewriteValueARM_OpARMSUBF(v *Value) bool {
 		}
 		y := v_1.Args[1]
 		x := v_1.Args[0]
-		if !(a.Uses == 1 && objabi.GOARM >= 6) {
+		if !(a.Uses == 1 && buildcfg.GOARM >= 6) {
 			break
 		}
 		v.reset(OpARMMULSF)
@@ -10801,7 +10803,7 @@ func rewriteValueARM_OpARMSUBF(v *Value) bool {
 		return true
 	}
 	// match: (SUBF a (NMULF x y))
-	// cond: a.Uses == 1 && objabi.GOARM >= 6
+	// cond: a.Uses == 1 && buildcfg.GOARM >= 6
 	// result: (MULAF a x y)
 	for {
 		a := v_0
@@ -10810,7 +10812,7 @@ func rewriteValueARM_OpARMSUBF(v *Value) bool {
 		}
 		y := v_1.Args[1]
 		x := v_1.Args[0]
-		if !(a.Uses == 1 && objabi.GOARM >= 6) {
+		if !(a.Uses == 1 && buildcfg.GOARM >= 6) {
 			break
 		}
 		v.reset(OpARMMULAF)
@@ -11264,12 +11266,12 @@ func rewriteValueARM_OpARMSUBconst(v *Value) bool {
 		return true
 	}
 	// match: (SUBconst [c] x)
-	// cond: objabi.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && uint32(-c)<=0xffff
+	// cond: buildcfg.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && uint32(-c)<=0xffff
 	// result: (ADDconst [-c] x)
 	for {
 		c := auxIntToInt32(v.AuxInt)
 		x := v_0
-		if !(objabi.GOARM == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && uint32(-c) <= 0xffff) {
+		if !(buildcfg.GOARM == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && uint32(-c) <= 0xffff) {
 			break
 		}
 		v.reset(OpARMADDconst)
@@ -12577,7 +12579,7 @@ func rewriteValueARM_OpARMXORshiftLL(v *Value) bool {
 		return true
 	}
 	// match: (XORshiftLL <typ.UInt16> [8] (SRLconst <typ.UInt16> [24] (SLLconst [16] x)) x)
-	// cond: objabi.GOARM>=6
+	// cond: buildcfg.GOARM>=6
 	// result: (REV16 x)
 	for {
 		if v.Type != typ.UInt16 || auxIntToInt32(v.AuxInt) != 8 || v_0.Op != OpARMSRLconst || v_0.Type != typ.UInt16 || auxIntToInt32(v_0.AuxInt) != 24 {
@@ -12588,7 +12590,7 @@ func rewriteValueARM_OpARMXORshiftLL(v *Value) bool {
 			break
 		}
 		x := v_0_0.Args[0]
-		if x != v_1 || !(objabi.GOARM >= 6) {
+		if x != v_1 || !(buildcfg.GOARM >= 6) {
 			break
 		}
 		v.reset(OpARMREV16)
@@ -12939,12 +12941,12 @@ func rewriteValueARM_OpBswap32(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
 	// match: (Bswap32 <t> x)
-	// cond: objabi.GOARM==5
+	// cond: buildcfg.GOARM==5
 	// result: (XOR <t> (SRLconst <t> (BICconst <t> (XOR <t> x (SRRconst <t> [16] x)) [0xff0000]) [8]) (SRRconst <t> x [8]))
 	for {
 		t := v.Type
 		x := v_0
-		if !(objabi.GOARM == 5) {
+		if !(buildcfg.GOARM == 5) {
 			break
 		}
 		v.reset(OpARMXOR)
@@ -12967,11 +12969,11 @@ func rewriteValueARM_OpBswap32(v *Value) bool {
 		return true
 	}
 	// match: (Bswap32 x)
-	// cond: objabi.GOARM>=6
+	// cond: buildcfg.GOARM>=6
 	// result: (REV x)
 	for {
 		x := v_0
-		if !(objabi.GOARM >= 6) {
+		if !(buildcfg.GOARM >= 6) {
 			break
 		}
 		v.reset(OpARMREV)
@@ -13054,12 +13056,12 @@ func rewriteValueARM_OpCtz16(v *Value) bool {
 	b := v.Block
 	typ := &b.Func.Config.Types
 	// match: (Ctz16 <t> x)
-	// cond: objabi.GOARM<=6
+	// cond: buildcfg.GOARM<=6
 	// result: (RSBconst [32] (CLZ <t> (SUBconst <typ.UInt32> (AND <typ.UInt32> (ORconst <typ.UInt32> [0x10000] x) (RSBconst <typ.UInt32> [0] (ORconst <typ.UInt32> [0x10000] x))) [1])))
 	for {
 		t := v.Type
 		x := v_0
-		if !(objabi.GOARM <= 6) {
+		if !(buildcfg.GOARM <= 6) {
 			break
 		}
 		v.reset(OpARMRSBconst)
@@ -13081,12 +13083,12 @@ func rewriteValueARM_OpCtz16(v *Value) bool {
 		return true
 	}
 	// match: (Ctz16 <t> x)
-	// cond: objabi.GOARM==7
+	// cond: buildcfg.GOARM==7
 	// result: (CLZ <t> (RBIT <typ.UInt32> (ORconst <typ.UInt32> [0x10000] x)))
 	for {
 		t := v.Type
 		x := v_0
-		if !(objabi.GOARM == 7) {
+		if !(buildcfg.GOARM == 7) {
 			break
 		}
 		v.reset(OpARMCLZ)
@@ -13105,12 +13107,12 @@ func rewriteValueARM_OpCtz32(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
 	// match: (Ctz32 <t> x)
-	// cond: objabi.GOARM<=6
+	// cond: buildcfg.GOARM<=6
 	// result: (RSBconst [32] (CLZ <t> (SUBconst <t> (AND <t> x (RSBconst <t> [0] x)) [1])))
 	for {
 		t := v.Type
 		x := v_0
-		if !(objabi.GOARM <= 6) {
+		if !(buildcfg.GOARM <= 6) {
 			break
 		}
 		v.reset(OpARMRSBconst)
@@ -13129,12 +13131,12 @@ func rewriteValueARM_OpCtz32(v *Value) bool {
 		return true
 	}
 	// match: (Ctz32 <t> x)
-	// cond: objabi.GOARM==7
+	// cond: buildcfg.GOARM==7
 	// result: (CLZ <t> (RBIT <t> x))
 	for {
 		t := v.Type
 		x := v_0
-		if !(objabi.GOARM == 7) {
+		if !(buildcfg.GOARM == 7) {
 			break
 		}
 		v.reset(OpARMCLZ)
@@ -13151,12 +13153,12 @@ func rewriteValueARM_OpCtz8(v *Value) bool {
 	b := v.Block
 	typ := &b.Func.Config.Types
 	// match: (Ctz8 <t> x)
-	// cond: objabi.GOARM<=6
+	// cond: buildcfg.GOARM<=6
 	// result: (RSBconst [32] (CLZ <t> (SUBconst <typ.UInt32> (AND <typ.UInt32> (ORconst <typ.UInt32> [0x100] x) (RSBconst <typ.UInt32> [0] (ORconst <typ.UInt32> [0x100] x))) [1])))
 	for {
 		t := v.Type
 		x := v_0
-		if !(objabi.GOARM <= 6) {
+		if !(buildcfg.GOARM <= 6) {
 			break
 		}
 		v.reset(OpARMRSBconst)
@@ -13178,12 +13180,12 @@ func rewriteValueARM_OpCtz8(v *Value) bool {
 		return true
 	}
 	// match: (Ctz8 <t> x)
-	// cond: objabi.GOARM==7
+	// cond: buildcfg.GOARM==7
 	// result: (CLZ <t> (RBIT <typ.UInt32> (ORconst <typ.UInt32> [0x100] x)))
 	for {
 		t := v.Type
 		x := v_0
-		if !(objabi.GOARM == 7) {
+		if !(buildcfg.GOARM == 7) {
 			break
 		}
 		v.reset(OpARMCLZ)
diff --git a/src/cmd/compile/internal/ssa/rewritePPC64.go b/src/cmd/compile/internal/ssa/rewritePPC64.go
index f181d433cc..fe7620c218 100644
--- a/src/cmd/compile/internal/ssa/rewritePPC64.go
+++ b/src/cmd/compile/internal/ssa/rewritePPC64.go
@@ -3,9 +3,11 @@
 
 package ssa
 
-import "math"
-import "cmd/internal/objabi"
-import "cmd/compile/internal/types"
+import (
+	"cmd/compile/internal/types"
+	"internal/buildcfg"
+	"math"
+)
 
 func rewriteValuePPC64(v *Value) bool {
 	switch v.Op {
@@ -1290,11 +1292,11 @@ func rewriteValuePPC64_OpCtz32(v *Value) bool {
 	b := v.Block
 	typ := &b.Func.Config.Types
 	// match: (Ctz32 x)
-	// cond: objabi.GOPPC64<=8
+	// cond: buildcfg.GOPPC64<=8
 	// result: (POPCNTW (MOVWZreg (ANDN <typ.Int> (ADDconst <typ.Int> [-1] x) x)))
 	for {
 		x := v_0
-		if !(objabi.GOPPC64 <= 8) {
+		if !(buildcfg.GOPPC64 <= 8) {
 			break
 		}
 		v.reset(OpPPC64POPCNTW)
@@ -1324,11 +1326,11 @@ func rewriteValuePPC64_OpCtz64(v *Value) bool {
 	b := v.Block
 	typ := &b.Func.Config.Types
 	// match: (Ctz64 x)
-	// cond: objabi.GOPPC64<=8
+	// cond: buildcfg.GOPPC64<=8
 	// result: (POPCNTD (ANDN <typ.Int64> (ADDconst <typ.Int64> [-1] x) x))
 	for {
 		x := v_0
-		if !(objabi.GOPPC64 <= 8) {
+		if !(buildcfg.GOPPC64 <= 8) {
 			break
 		}
 		v.reset(OpPPC64POPCNTD)
@@ -3286,12 +3288,12 @@ func rewriteValuePPC64_OpMod32(v *Value) bool {
 	b := v.Block
 	typ := &b.Func.Config.Types
 	// match: (Mod32 x y)
-	// cond: objabi.GOPPC64 >= 9
+	// cond: buildcfg.GOPPC64 >= 9
 	// result: (MODSW x y)
 	for {
 		x := v_0
 		y := v_1
-		if !(objabi.GOPPC64 >= 9) {
+		if !(buildcfg.GOPPC64 >= 9) {
 			break
 		}
 		v.reset(OpPPC64MODSW)
@@ -3299,12 +3301,12 @@ func rewriteValuePPC64_OpMod32(v *Value) bool {
 		return true
 	}
 	// match: (Mod32 x y)
-	// cond: objabi.GOPPC64 <= 8
+	// cond: buildcfg.GOPPC64 <= 8
 	// result: (SUB x (MULLW y (DIVW x y)))
 	for {
 		x := v_0
 		y := v_1
-		if !(objabi.GOPPC64 <= 8) {
+		if !(buildcfg.GOPPC64 <= 8) {
 			break
 		}
 		v.reset(OpPPC64SUB)
@@ -3323,12 +3325,12 @@ func rewriteValuePPC64_OpMod32u(v *Value) bool {
 	b := v.Block
 	typ := &b.Func.Config.Types
 	// match: (Mod32u x y)
-	// cond: objabi.GOPPC64 >= 9
+	// cond: buildcfg.GOPPC64 >= 9
 	// result: (MODUW x y)
 	for {
 		x := v_0
 		y := v_1
-		if !(objabi.GOPPC64 >= 9) {
+		if !(buildcfg.GOPPC64 >= 9) {
 			break
 		}
 		v.reset(OpPPC64MODUW)
@@ -3336,12 +3338,12 @@ func rewriteValuePPC64_OpMod32u(v *Value) bool {
 		return true
 	}
 	// match: (Mod32u x y)
-	// cond: objabi.GOPPC64 <= 8
+	// cond: buildcfg.GOPPC64 <= 8
 	// result: (SUB x (MULLW y (DIVWU x y)))
 	for {
 		x := v_0
 		y := v_1
-		if !(objabi.GOPPC64 <= 8) {
+		if !(buildcfg.GOPPC64 <= 8) {
 			break
 		}
 		v.reset(OpPPC64SUB)
@@ -3360,12 +3362,12 @@ func rewriteValuePPC64_OpMod64(v *Value) bool {
 	b := v.Block
 	typ := &b.Func.Config.Types
 	// match: (Mod64 x y)
-	// cond: objabi.GOPPC64 >=9
+	// cond: buildcfg.GOPPC64 >=9
 	// result: (MODSD x y)
 	for {
 		x := v_0
 		y := v_1
-		if !(objabi.GOPPC64 >= 9) {
+		if !(buildcfg.GOPPC64 >= 9) {
 			break
 		}
 		v.reset(OpPPC64MODSD)
@@ -3373,12 +3375,12 @@ func rewriteValuePPC64_OpMod64(v *Value) bool {
 		return true
 	}
 	// match: (Mod64 x y)
-	// cond: objabi.GOPPC64 <=8
+	// cond: buildcfg.GOPPC64 <=8
 	// result: (SUB x (MULLD y (DIVD x y)))
 	for {
 		x := v_0
 		y := v_1
-		if !(objabi.GOPPC64 <= 8) {
+		if !(buildcfg.GOPPC64 <= 8) {
 			break
 		}
 		v.reset(OpPPC64SUB)
@@ -3397,12 +3399,12 @@ func rewriteValuePPC64_OpMod64u(v *Value) bool {
 	b := v.Block
 	typ := &b.Func.Config.Types
 	// match: (Mod64u x y)
-	// cond: objabi.GOPPC64 >= 9
+	// cond: buildcfg.GOPPC64 >= 9
 	// result: (MODUD x y)
 	for {
 		x := v_0
 		y := v_1
-		if !(objabi.GOPPC64 >= 9) {
+		if !(buildcfg.GOPPC64 >= 9) {
 			break
 		}
 		v.reset(OpPPC64MODUD)
@@ -3410,12 +3412,12 @@ func rewriteValuePPC64_OpMod64u(v *Value) bool {
 		return true
 	}
 	// match: (Mod64u x y)
-	// cond: objabi.GOPPC64 <= 8
+	// cond: buildcfg.GOPPC64 <= 8
 	// result: (SUB x (MULLD y (DIVDU x y)))
 	for {
 		x := v_0
 		y := v_1
-		if !(objabi.GOPPC64 <= 8) {
+		if !(buildcfg.GOPPC64 <= 8) {
 			break
 		}
 		v.reset(OpPPC64SUB)
@@ -3633,14 +3635,14 @@ func rewriteValuePPC64_OpMove(v *Value) bool {
 		return true
 	}
 	// match: (Move [s] dst src mem)
-	// cond: s > 8 && objabi.GOPPC64 <= 8 && logLargeCopy(v, s)
+	// cond: s > 8 && buildcfg.GOPPC64 <= 8 && logLargeCopy(v, s)
 	// result: (LoweredMove [s] dst src mem)
 	for {
 		s := auxIntToInt64(v.AuxInt)
 		dst := v_0
 		src := v_1
 		mem := v_2
-		if !(s > 8 && objabi.GOPPC64 <= 8 && logLargeCopy(v, s)) {
+		if !(s > 8 && buildcfg.GOPPC64 <= 8 && logLargeCopy(v, s)) {
 			break
 		}
 		v.reset(OpPPC64LoweredMove)
@@ -3649,14 +3651,14 @@ func rewriteValuePPC64_OpMove(v *Value) bool {
 		return true
 	}
 	// match: (Move [s] dst src mem)
-	// cond: s > 8 && s <= 64 && objabi.GOPPC64 >= 9
+	// cond: s > 8 && s <= 64 && buildcfg.GOPPC64 >= 9
 	// result: (LoweredQuadMoveShort [s] dst src mem)
 	for {
 		s := auxIntToInt64(v.AuxInt)
 		dst := v_0
 		src := v_1
 		mem := v_2
-		if !(s > 8 && s <= 64 && objabi.GOPPC64 >= 9) {
+		if !(s > 8 && s <= 64 && buildcfg.GOPPC64 >= 9) {
 			break
 		}
 		v.reset(OpPPC64LoweredQuadMoveShort)
@@ -3665,14 +3667,14 @@ func rewriteValuePPC64_OpMove(v *Value) bool {
 		return true
 	}
 	// match: (Move [s] dst src mem)
-	// cond: s > 8 && objabi.GOPPC64 >= 9 && logLargeCopy(v, s)
+	// cond: s > 8 && buildcfg.GOPPC64 >= 9 && logLargeCopy(v, s)
 	// result: (LoweredQuadMove [s] dst src mem)
 	for {
 		s := auxIntToInt64(v.AuxInt)
 		dst := v_0
 		src := v_1
 		mem := v_2
-		if !(s > 8 && objabi.GOPPC64 >= 9 && logLargeCopy(v, s)) {
+		if !(s > 8 && buildcfg.GOPPC64 >= 9 && logLargeCopy(v, s)) {
 			break
 		}
 		v.reset(OpPPC64LoweredQuadMove)
@@ -3882,7 +3884,7 @@ func rewriteValuePPC64_OpPPC64ADD(v *Value) bool {
 	b := v.Block
 	typ := &b.Func.Config.Types
 	// match: (ADD l:(MULLD x y) z)
-	// cond: objabi.GOPPC64 >= 9 && l.Uses == 1 && clobber(l)
+	// cond: buildcfg.GOPPC64 >= 9 && l.Uses == 1 && clobber(l)
 	// result: (MADDLD x y z)
 	for {
 		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
@@ -3893,7 +3895,7 @@ func rewriteValuePPC64_OpPPC64ADD(v *Value) bool {
 			y := l.Args[1]
 			x := l.Args[0]
 			z := v_1
-			if !(objabi.GOPPC64 >= 9 && l.Uses == 1 && clobber(l)) {
+			if !(buildcfg.GOPPC64 >= 9 && l.Uses == 1 && clobber(l)) {
 				continue
 			}
 			v.reset(OpPPC64MADDLD)
@@ -13241,7 +13243,7 @@ func rewriteValuePPC64_OpPPC64SLDconst(v *Value) bool {
 		break
 	}
 	// match: (SLDconst [c] z:(MOVWreg x))
-	// cond: c < 32 && objabi.GOPPC64 >= 9
+	// cond: c < 32 && buildcfg.GOPPC64 >= 9
 	// result: (EXTSWSLconst [c] x)
 	for {
 		c := auxIntToInt64(v.AuxInt)
@@ -13250,7 +13252,7 @@ func rewriteValuePPC64_OpPPC64SLDconst(v *Value) bool {
 			break
 		}
 		x := z.Args[0]
-		if !(c < 32 && objabi.GOPPC64 >= 9) {
+		if !(c < 32 && buildcfg.GOPPC64 >= 9) {
 			break
 		}
 		v.reset(OpPPC64EXTSWSLconst)
@@ -13364,7 +13366,7 @@ func rewriteValuePPC64_OpPPC64SLWconst(v *Value) bool {
 		break
 	}
 	// match: (SLWconst [c] z:(MOVWreg x))
-	// cond: c < 32 && objabi.GOPPC64 >= 9
+	// cond: c < 32 && buildcfg.GOPPC64 >= 9
 	// result: (EXTSWSLconst [c] x)
 	for {
 		c := auxIntToInt64(v.AuxInt)
@@ -13373,7 +13375,7 @@ func rewriteValuePPC64_OpPPC64SLWconst(v *Value) bool {
 			break
 		}
 		x := z.Args[0]
-		if !(c < 32 && objabi.GOPPC64 >= 9) {
+		if !(c < 32 && buildcfg.GOPPC64 >= 9) {
 			break
 		}
 		v.reset(OpPPC64EXTSWSLconst)
@@ -16906,13 +16908,13 @@ func rewriteValuePPC64_OpZero(v *Value) bool {
 		return true
 	}
 	// match: (Zero [s] ptr mem)
-	// cond: objabi.GOPPC64 <= 8 && s < 64
+	// cond: buildcfg.GOPPC64 <= 8 && s < 64
 	// result: (LoweredZeroShort [s] ptr mem)
 	for {
 		s := auxIntToInt64(v.AuxInt)
 		ptr := v_0
 		mem := v_1
-		if !(objabi.GOPPC64 <= 8 && s < 64) {
+		if !(buildcfg.GOPPC64 <= 8 && s < 64) {
 			break
 		}
 		v.reset(OpPPC64LoweredZeroShort)
@@ -16921,13 +16923,13 @@ func rewriteValuePPC64_OpZero(v *Value) bool {
 		return true
 	}
 	// match: (Zero [s] ptr mem)
-	// cond: objabi.GOPPC64 <= 8
+	// cond: buildcfg.GOPPC64 <= 8
 	// result: (LoweredZero [s] ptr mem)
 	for {
 		s := auxIntToInt64(v.AuxInt)
 		ptr := v_0
 		mem := v_1
-		if !(objabi.GOPPC64 <= 8) {
+		if !(buildcfg.GOPPC64 <= 8) {
 			break
 		}
 		v.reset(OpPPC64LoweredZero)
@@ -16936,13 +16938,13 @@ func rewriteValuePPC64_OpZero(v *Value) bool {
 		return true
 	}
 	// match: (Zero [s] ptr mem)
-	// cond: s < 128 && objabi.GOPPC64 >= 9
+	// cond: s < 128 && buildcfg.GOPPC64 >= 9
 	// result: (LoweredQuadZeroShort [s] ptr mem)
 	for {
 		s := auxIntToInt64(v.AuxInt)
 		ptr := v_0
 		mem := v_1
-		if !(s < 128 && objabi.GOPPC64 >= 9) {
+		if !(s < 128 && buildcfg.GOPPC64 >= 9) {
 			break
 		}
 		v.reset(OpPPC64LoweredQuadZeroShort)
@@ -16951,13 +16953,13 @@ func rewriteValuePPC64_OpZero(v *Value) bool {
 		return true
 	}
 	// match: (Zero [s] ptr mem)
-	// cond: objabi.GOPPC64 >= 9
+	// cond: buildcfg.GOPPC64 >= 9
 	// result: (LoweredQuadZero [s] ptr mem)
 	for {
 		s := auxIntToInt64(v.AuxInt)
 		ptr := v_0
 		mem := v_1
-		if !(objabi.GOPPC64 >= 9) {
+		if !(buildcfg.GOPPC64 >= 9) {
 			break
 		}
 		v.reset(OpPPC64LoweredQuadZero)
diff --git a/src/cmd/compile/internal/ssa/rewriteRISCV64.go b/src/cmd/compile/internal/ssa/rewriteRISCV64.go
index 431fb1aaf6..bc4b18e0cd 100644
--- a/src/cmd/compile/internal/ssa/rewriteRISCV64.go
+++ b/src/cmd/compile/internal/ssa/rewriteRISCV64.go
@@ -3,8 +3,10 @@
 
 package ssa
 
-import "math"
-import "cmd/compile/internal/types"
+import (
+	"cmd/compile/internal/types"
+	"math"
+)
 
 func rewriteValueRISCV64(v *Value) bool {
 	switch v.Op {
diff --git a/src/cmd/compile/internal/ssa/rewriteS390X.go b/src/cmd/compile/internal/ssa/rewriteS390X.go
index 8b41d62c31..49c5898704 100644
--- a/src/cmd/compile/internal/ssa/rewriteS390X.go
+++ b/src/cmd/compile/internal/ssa/rewriteS390X.go
@@ -3,9 +3,11 @@
 
 package ssa
 
-import "math"
-import "cmd/compile/internal/types"
-import "cmd/internal/obj/s390x"
+import (
+	"cmd/compile/internal/types"
+	"cmd/internal/obj/s390x"
+	"math"
+)
 
 func rewriteValueS390X(v *Value) bool {
 	switch v.Op {
diff --git a/src/cmd/compile/internal/ssa/rewriteWasm.go b/src/cmd/compile/internal/ssa/rewriteWasm.go
index 6efcdfe371..ed23ae032a 100644
--- a/src/cmd/compile/internal/ssa/rewriteWasm.go
+++ b/src/cmd/compile/internal/ssa/rewriteWasm.go
@@ -3,9 +3,11 @@
 
 package ssa
 
-import "math"
-import "cmd/internal/objabi"
-import "cmd/compile/internal/types"
+import (
+	"cmd/compile/internal/types"
+	"internal/buildcfg"
+	"math"
+)
 
 func rewriteValueWasm(v *Value) bool {
 	switch v.Op {
@@ -3193,11 +3195,11 @@ func rewriteValueWasm_OpSignExt16to32(v *Value) bool {
 		return true
 	}
 	// match: (SignExt16to32 x)
-	// cond: objabi.GOWASM.SignExt
+	// cond: buildcfg.GOWASM.SignExt
 	// result: (I64Extend16S x)
 	for {
 		x := v_0
-		if !(objabi.GOWASM.SignExt) {
+		if !(buildcfg.GOWASM.SignExt) {
 			break
 		}
 		v.reset(OpWasmI64Extend16S)
@@ -3232,11 +3234,11 @@ func rewriteValueWasm_OpSignExt16to64(v *Value) bool {
 		return true
 	}
 	// match: (SignExt16to64 x)
-	// cond: objabi.GOWASM.SignExt
+	// cond: buildcfg.GOWASM.SignExt
 	// result: (I64Extend16S x)
 	for {
 		x := v_0
-		if !(objabi.GOWASM.SignExt) {
+		if !(buildcfg.GOWASM.SignExt) {
 			break
 		}
 		v.reset(OpWasmI64Extend16S)
@@ -3271,11 +3273,11 @@ func rewriteValueWasm_OpSignExt32to64(v *Value) bool {
 		return true
 	}
 	// match: (SignExt32to64 x)
-	// cond: objabi.GOWASM.SignExt
+	// cond: buildcfg.GOWASM.SignExt
 	// result: (I64Extend32S x)
 	for {
 		x := v_0
-		if !(objabi.GOWASM.SignExt) {
+		if !(buildcfg.GOWASM.SignExt) {
 			break
 		}
 		v.reset(OpWasmI64Extend32S)
@@ -3310,11 +3312,11 @@ func rewriteValueWasm_OpSignExt8to16(v *Value) bool {
 		return true
 	}
 	// match: (SignExt8to16 x)
-	// cond: objabi.GOWASM.SignExt
+	// cond: buildcfg.GOWASM.SignExt
 	// result: (I64Extend8S x)
 	for {
 		x := v_0
-		if !(objabi.GOWASM.SignExt) {
+		if !(buildcfg.GOWASM.SignExt) {
 			break
 		}
 		v.reset(OpWasmI64Extend8S)
@@ -3349,11 +3351,11 @@ func rewriteValueWasm_OpSignExt8to32(v *Value) bool {
 		return true
 	}
 	// match: (SignExt8to32 x)
-	// cond: objabi.GOWASM.SignExt
+	// cond: buildcfg.GOWASM.SignExt
 	// result: (I64Extend8S x)
 	for {
 		x := v_0
-		if !(objabi.GOWASM.SignExt) {
+		if !(buildcfg.GOWASM.SignExt) {
 			break
 		}
 		v.reset(OpWasmI64Extend8S)
@@ -3388,11 +3390,11 @@ func rewriteValueWasm_OpSignExt8to64(v *Value) bool {
 		return true
 	}
 	// match: (SignExt8to64 x)
-	// cond: objabi.GOWASM.SignExt
+	// cond: buildcfg.GOWASM.SignExt
 	// result: (I64Extend8S x)
 	for {
 		x := v_0
-		if !(objabi.GOWASM.SignExt) {
+		if !(buildcfg.GOWASM.SignExt) {
 			break
 		}
 		v.reset(OpWasmI64Extend8S)
diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go
index 52258201ca..0e5f49491e 100644
--- a/src/cmd/compile/internal/ssa/rewritegeneric.go
+++ b/src/cmd/compile/internal/ssa/rewritegeneric.go
@@ -3,8 +3,10 @@
 
 package ssa
 
-import "math"
-import "cmd/compile/internal/types"
+import (
+	"cmd/compile/internal/types"
+	"math"
+)
 
 func rewriteValuegeneric(v *Value) bool {
 	switch v.Op {
diff --git a/src/cmd/compile/internal/ssagen/abi.go b/src/cmd/compile/internal/ssagen/abi.go
index 8103b08ce5..7d56362302 100644
--- a/src/cmd/compile/internal/ssagen/abi.go
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -6,6 +6,7 @@ package ssagen
 
 import (
 	"fmt"
+	"internal/buildcfg"
 	"io/ioutil"
 	"log"
 	"os"
@@ -213,7 +214,7 @@ func (s *SymABIs) GenABIWrappers() {
 			base.Fatalf("cgo exported function %s cannot have ABI wrappers", fn)
 		}
 
-		if !objabi.Experiment.RegabiWrappers {
+		if !buildcfg.Experiment.RegabiWrappers {
 			// We'll generate ABI aliases instead of
 			// wrappers once we have LSyms in InitLSym.
 			continue
@@ -241,7 +242,7 @@ func InitLSym(f *ir.Func, hasBody bool) {
 		if f.Pragma&ir.Systemstack != 0 {
 			f.LSym.Set(obj.AttrCFunc, true)
 		}
-		if f.ABI == obj.ABIInternal || !objabi.Experiment.RegabiWrappers {
+		if f.ABI == obj.ABIInternal || !buildcfg.Experiment.RegabiWrappers {
 			// Function values can only point to
 			// ABIInternal entry points. This will create
 			// the funcsym for either the defining
@@ -253,7 +254,7 @@ func InitLSym(f *ir.Func, hasBody bool) {
 			// when we see that.
 			staticdata.NeedFuncSym(f)
 		}
-		if !objabi.Experiment.RegabiWrappers {
+		if !buildcfg.Experiment.RegabiWrappers {
 			// Create ABI aliases instead of wrappers.
 			forEachWrapperABI(f, makeABIAlias)
 		}
diff --git a/src/cmd/compile/internal/ssagen/pgen.go b/src/cmd/compile/internal/ssagen/pgen.go
index 92f6f562f3..62567535d7 100644
--- a/src/cmd/compile/internal/ssagen/pgen.go
+++ b/src/cmd/compile/internal/ssagen/pgen.go
@@ -5,6 +5,7 @@
 package ssagen
 
 import (
+	"internal/buildcfg"
 	"internal/race"
 	"math/rand"
 	"sort"
@@ -215,7 +216,7 @@ func StackOffset(slot ssa.LocalSlot) int32 {
 		if base.Ctxt.FixedFrameSize() == 0 {
 			off -= int64(types.PtrSize)
 		}
-		if objabi.FramePointerEnabled {
+		if buildcfg.FramePointerEnabled {
 			off -= int64(types.PtrSize)
 		}
 	}
@@ -228,7 +229,7 @@ func fieldtrack(fnsym *obj.LSym, tracked map[*obj.LSym]struct{}) {
 	if fnsym == nil {
 		return
 	}
-	if !objabi.Experiment.FieldTrack || len(tracked) == 0 {
+	if !buildcfg.Experiment.FieldTrack || len(tracked) == 0 {
 		return
 	}
 
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 61f23a9c40..f0bce0756a 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -12,6 +12,7 @@ import (
 	"fmt"
 	"go/constant"
 	"html"
+	"internal/buildcfg"
 	"os"
 	"path/filepath"
 	"sort"
@@ -227,7 +228,7 @@ const magicLastTypeName = "MagicLastTypeNameForTestingRegisterABI"
 // abiForFunc implements ABI policy for a function, but does not return a copy of the ABI.
 // Passing a nil function returns the default ABI based on experiment configuration.
 func abiForFunc(fn *ir.Func, abi0, abi1 *abi.ABIConfig) *abi.ABIConfig {
-	if objabi.Experiment.RegabiArgs {
+	if buildcfg.Experiment.RegabiArgs {
 		// Select the ABI based on the function's defining ABI.
 		if fn == nil {
 			return abi1
@@ -4646,7 +4647,7 @@ func (s *state) openDeferRecord(n *ir.CallExpr) {
 	var args []*ssa.Value
 	var argNodes []*ir.Name
 
-	if objabi.Experiment.RegabiDefer && (len(n.Args) != 0 || n.Op() == ir.OCALLINTER || n.X.Type().NumResults() != 0) {
+	if buildcfg.Experiment.RegabiDefer && (len(n.Args) != 0 || n.Op() == ir.OCALLINTER || n.X.Type().NumResults() != 0) {
 		s.Fatalf("defer call with arguments or results: %v", n)
 	}
 
@@ -4883,7 +4884,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 
 	callABI := s.f.ABIDefault
 
-	if !objabi.Experiment.RegabiArgs {
+	if !buildcfg.Experiment.RegabiArgs {
 		var magicFnNameSym *types.Sym
 		if fn.Name() != nil {
 			magicFnNameSym = fn.Name().Sym()
@@ -4901,7 +4902,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		}
 	}
 
-	if objabi.Experiment.RegabiDefer && k != callNormal && (len(n.Args) != 0 || n.Op() == ir.OCALLINTER || n.X.Type().NumResults() != 0) {
+	if buildcfg.Experiment.RegabiDefer && k != callNormal && (len(n.Args) != 0 || n.Op() == ir.OCALLINTER || n.X.Type().NumResults() != 0) {
 		s.Fatalf("go/defer call with arguments: %v", n)
 	}
 
@@ -4910,7 +4911,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		if k == callNormal && fn.Op() == ir.ONAME && fn.(*ir.Name).Class == ir.PFUNC {
 			fn := fn.(*ir.Name)
 			callee = fn
-			if objabi.Experiment.RegabiArgs {
+			if buildcfg.Experiment.RegabiArgs {
 				// This is a static call, so it may be
 				// a direct call to a non-ABIInternal
 				// function. fn.Func may be nil for
@@ -4951,7 +4952,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		}
 	}
 
-	if !objabi.Experiment.RegabiArgs {
+	if !buildcfg.Experiment.RegabiArgs {
 		if regAbiForFuncType(n.X.Type().FuncType()) {
 			// Magic last type in input args to call
 			callABI = s.f.ABI1
@@ -5135,7 +5136,7 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 // maybeNilCheckClosure checks if a nil check of a closure is needed in some
 // architecture-dependent situations and, if so, emits the nil check.
 func (s *state) maybeNilCheckClosure(closure *ssa.Value, k callKind) {
-	if Arch.LinkArch.Family == sys.Wasm || objabi.GOOS == "aix" && k != callGo {
+	if Arch.LinkArch.Family == sys.Wasm || buildcfg.GOOS == "aix" && k != callGo {
 		// On AIX, the closure needs to be verified as fn can be nil, except if it's a call go. This needs to be handled by the runtime to have the "go of nil func value" error.
 		// TODO(neelance): On other architectures this should be eliminated by the optimization steps
 		s.nilCheck(closure)
@@ -6881,7 +6882,7 @@ func defframe(s *State, e *ssafn, f *ssa.Func) {
 	// and not address-taken (for non-SSA-able or address-taken arguments we always
 	// spill upfront).
 	// TODO(register args) Make liveness more fine-grained to that partial spilling is okay.
-	if objabi.Experiment.RegabiArgs {
+	if buildcfg.Experiment.RegabiArgs {
 		// First, see if it is already spilled before it may be live. Look for a spill
 		// in the entry block up to the first safepoint.
 		type nameOff struct {
diff --git a/src/cmd/compile/internal/staticdata/data.go b/src/cmd/compile/internal/staticdata/data.go
index 7ca05d3bf4..b5206c2442 100644
--- a/src/cmd/compile/internal/staticdata/data.go
+++ b/src/cmd/compile/internal/staticdata/data.go
@@ -8,6 +8,7 @@ import (
 	"crypto/sha256"
 	"fmt"
 	"go/constant"
+	"internal/buildcfg"
 	"io"
 	"io/ioutil"
 	"os"
@@ -269,7 +270,7 @@ func NeedFuncSym(fn *ir.Func) {
 		// funcsymsmu, like in FuncSym.
 		base.Fatalf("NeedFuncSym must be called in serial")
 	}
-	if fn.ABI != obj.ABIInternal && objabi.Experiment.RegabiWrappers {
+	if fn.ABI != obj.ABIInternal && buildcfg.Experiment.RegabiWrappers {
 		// Function values must always reference ABIInternal
 		// entry points, so it doesn't make sense to create a
 		// funcsym for other ABIs.
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 0995c1314d..d8160d971c 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -7,6 +7,7 @@ package walk
 import (
 	"fmt"
 	"go/constant"
+	"internal/buildcfg"
 	"strings"
 
 	"cmd/compile/internal/base"
@@ -16,7 +17,6 @@ import (
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
-	"cmd/internal/objabi"
 )
 
 // The result of walkExpr MUST be assigned back to n, e.g.
@@ -927,7 +927,7 @@ func usemethod(n *ir.CallExpr) {
 }
 
 func usefield(n *ir.SelectorExpr) {
-	if !objabi.Experiment.FieldTrack {
+	if !buildcfg.Experiment.FieldTrack {
 		return
 	}
 
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index 42d9d58971..7b69f34e85 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -7,6 +7,7 @@ package walk
 import (
 	"fmt"
 	"go/constant"
+	"internal/buildcfg"
 
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/escape"
@@ -15,7 +16,6 @@ import (
 	"cmd/compile/internal/staticinit"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
-	"cmd/internal/objabi"
 	"cmd/internal/src"
 )
 
@@ -780,7 +780,7 @@ func (o *orderState) stmt(n ir.Node) {
 			n.Call = walkRecover(n.Call.(*ir.CallExpr), &init)
 			o.stmtList(init)
 		}
-		if objabi.Experiment.RegabiDefer {
+		if buildcfg.Experiment.RegabiDefer {
 			o.wrapGoDefer(n)
 		}
 		o.out = append(o.out, n)
diff --git a/src/cmd/compile/internal/walk/range.go b/src/cmd/compile/internal/walk/range.go
index 80bd8750fa..3384bc826e 100644
--- a/src/cmd/compile/internal/walk/range.go
+++ b/src/cmd/compile/internal/walk/range.go
@@ -170,7 +170,7 @@ func walkRange(nrange *ir.RangeStmt) ir.Node {
 		th := hit.Type()
 		// depends on layout of iterator struct.
 		// See cmd/compile/internal/reflectdata/reflect.go:MapIterType
-		keysym := th.Field(0).Sym  
+		keysym := th.Field(0).Sym
 		elemsym := th.Field(1).Sym // ditto
 
 		fn := typecheck.LookupRuntime("mapiterinit")
diff --git a/src/cmd/compile/internal/wasm/ssa.go b/src/cmd/compile/internal/wasm/ssa.go
index 904871b15f..31b09016eb 100644
--- a/src/cmd/compile/internal/wasm/ssa.go
+++ b/src/cmd/compile/internal/wasm/ssa.go
@@ -14,7 +14,7 @@ import (
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/obj/wasm"
-	"cmd/internal/objabi"
+	"internal/buildcfg"
 )
 
 func Init(arch *ssagen.ArchInfo) {
@@ -325,7 +325,7 @@ func ssaGenValueOnStack(s *ssagen.State, v *ssa.Value, extend bool) {
 
 	case ssa.OpWasmI64TruncSatF32S, ssa.OpWasmI64TruncSatF64S:
 		getValue64(s, v.Args[0])
-		if objabi.GOWASM.SatConv {
+		if buildcfg.GOWASM.SatConv {
 			s.Prog(v.Op.Asm())
 		} else {
 			if v.Op == ssa.OpWasmI64TruncSatF32S {
@@ -337,7 +337,7 @@ func ssaGenValueOnStack(s *ssagen.State, v *ssa.Value, extend bool) {
 
 	case ssa.OpWasmI64TruncSatF32U, ssa.OpWasmI64TruncSatF64U:
 		getValue64(s, v.Args[0])
-		if objabi.GOWASM.SatConv {
+		if buildcfg.GOWASM.SatConv {
 			s.Prog(v.Op.Asm())
 		} else {
 			if v.Op == ssa.OpWasmI64TruncSatF32U {
diff --git a/src/cmd/compile/internal/x86/galign.go b/src/cmd/compile/internal/x86/galign.go
index fc806f9119..00a20e429f 100644
--- a/src/cmd/compile/internal/x86/galign.go
+++ b/src/cmd/compile/internal/x86/galign.go
@@ -8,8 +8,8 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ssagen"
 	"cmd/internal/obj/x86"
-	"cmd/internal/objabi"
 	"fmt"
+	"internal/buildcfg"
 	"os"
 )
 
@@ -19,7 +19,7 @@ func Init(arch *ssagen.ArchInfo) {
 	arch.SSAGenValue = ssaGenValue
 	arch.SSAGenBlock = ssaGenBlock
 	arch.MAXWIDTH = (1 << 32) - 1
-	switch v := objabi.GO386; v {
+	switch v := buildcfg.GO386; v {
 	case "sse2":
 	case "softfloat":
 		arch.SoftFloat = true
diff --git a/src/cmd/compile/main.go b/src/cmd/compile/main.go
index cb2f4e8cf4..3af1e1fafd 100644
--- a/src/cmd/compile/main.go
+++ b/src/cmd/compile/main.go
@@ -18,8 +18,8 @@ import (
 	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/wasm"
 	"cmd/compile/internal/x86"
-	"cmd/internal/objabi"
 	"fmt"
+	"internal/buildcfg"
 	"log"
 	"os"
 )
@@ -45,9 +45,10 @@ func main() {
 	log.SetFlags(0)
 	log.SetPrefix("compile: ")
 
-	archInit, ok := archInits[objabi.GOARCH]
+	buildcfg.Check()
+	archInit, ok := archInits[buildcfg.GOARCH]
 	if !ok {
-		fmt.Fprintf(os.Stderr, "compile: unknown architecture %q\n", objabi.GOARCH)
+		fmt.Fprintf(os.Stderr, "compile: unknown architecture %q\n", buildcfg.GOARCH)
 		os.Exit(2)
 	}
 
diff --git a/src/cmd/dist/buildruntime.go b/src/cmd/dist/buildruntime.go
index 3ef551e187..54e935ad3b 100644
--- a/src/cmd/dist/buildruntime.go
+++ b/src/cmd/dist/buildruntime.go
@@ -32,22 +32,15 @@ func mkzversion(dir, file string) {
 	writefile(buf.String(), file, writeSkipSame)
 }
 
-// mkzbootstrap writes cmd/internal/objabi/zbootstrap.go:
+// mkbuildcfg writes internal/buildcfg/zbootstrap.go:
 //
-//	package objabi
+//	package buildcfg
 //
 //	const defaultGOROOT = <goroot>
 //	const defaultGO386 = <go386>
-//	const defaultGOARM = <goarm>
-//	const defaultGOMIPS = <gomips>
-//	const defaultGOMIPS64 = <gomips64>
-//	const defaultGOPPC64 = <goppc64>
+//	...
 //	const defaultGOOS = runtime.GOOS
 //	const defaultGOARCH = runtime.GOARCH
-//	const defaultGOEXPERIMENT = <goexperiment>
-//	const defaultGO_EXTLINK_ENABLED = <goextlinkenabled>
-//	const version = <version>
-//	const stackGuardMultiplierDefault = <multiplier value>
 //
 // The use of runtime.GOOS and runtime.GOARCH makes sure that
 // a cross-compiled compiler expects to compile for its own target
@@ -58,11 +51,11 @@ func mkzversion(dir, file string) {
 // the resulting compiler will default to generating linux/ppc64 object files.
 // This is more useful than having it default to generating objects for the
 // original target (in this example, a Mac).
-func mkzbootstrap(file string) {
+func mkbuildcfg(file string) {
 	var buf bytes.Buffer
 	fmt.Fprintf(&buf, "// Code generated by go tool dist; DO NOT EDIT.\n")
 	fmt.Fprintln(&buf)
-	fmt.Fprintf(&buf, "package objabi\n")
+	fmt.Fprintf(&buf, "package buildcfg\n")
 	fmt.Fprintln(&buf)
 	fmt.Fprintf(&buf, "import \"runtime\"\n")
 	fmt.Fprintln(&buf)
@@ -71,12 +64,28 @@ func mkzbootstrap(file string) {
 	fmt.Fprintf(&buf, "const defaultGOMIPS = `%s`\n", gomips)
 	fmt.Fprintf(&buf, "const defaultGOMIPS64 = `%s`\n", gomips64)
 	fmt.Fprintf(&buf, "const defaultGOPPC64 = `%s`\n", goppc64)
-	fmt.Fprintf(&buf, "const defaultGOOS = runtime.GOOS\n")
-	fmt.Fprintf(&buf, "const defaultGOARCH = runtime.GOARCH\n")
 	fmt.Fprintf(&buf, "const defaultGOEXPERIMENT = `%s`\n", goexperiment)
 	fmt.Fprintf(&buf, "const defaultGO_EXTLINK_ENABLED = `%s`\n", goextlinkenabled)
 	fmt.Fprintf(&buf, "const defaultGO_LDSO = `%s`\n", defaultldso)
 	fmt.Fprintf(&buf, "const version = `%s`\n", findgoversion())
+	fmt.Fprintf(&buf, "const defaultGOOS = runtime.GOOS\n")
+	fmt.Fprintf(&buf, "const defaultGOARCH = runtime.GOARCH\n")
+
+	writefile(buf.String(), file, writeSkipSame)
+}
+
+// mkobjabi writes cmd/internal/objabi/zbootstrap.go:
+//
+//	package objabi
+//
+//	const stackGuardMultiplierDefault = <multiplier value>
+//
+func mkobjabi(file string) {
+	var buf bytes.Buffer
+	fmt.Fprintf(&buf, "// Code generated by go tool dist; DO NOT EDIT.\n")
+	fmt.Fprintln(&buf)
+	fmt.Fprintf(&buf, "package objabi\n")
+	fmt.Fprintln(&buf)
 	fmt.Fprintf(&buf, "const stackGuardMultiplierDefault = %d\n", stackGuardMultiplierDefault())
 
 	writefile(buf.String(), file, writeSkipSame)
diff --git a/src/cmd/dist/buildtool.go b/src/cmd/dist/buildtool.go
index 44b1886968..26b33e389f 100644
--- a/src/cmd/dist/buildtool.go
+++ b/src/cmd/dist/buildtool.go
@@ -58,6 +58,7 @@ var bootstrapDirs = []string{
 	"debug/macho",
 	"debug/pe",
 	"go/constant",
+	"internal/buildcfg",
 	"internal/goexperiment",
 	"internal/goversion",
 	"internal/race",
@@ -98,7 +99,8 @@ func bootstrapBuildTools() {
 	}
 	xprintf("Building Go toolchain1 using %s.\n", goroot_bootstrap)
 
-	mkzbootstrap(pathf("%s/src/cmd/internal/objabi/zbootstrap.go", goroot))
+	mkbuildcfg(pathf("%s/src/internal/buildcfg/zbootstrap.go", goroot))
+	mkobjabi(pathf("%s/src/cmd/internal/objabi/zbootstrap.go", goroot))
 
 	// Use $GOROOT/pkg/bootstrap as the bootstrap workspace root.
 	// We use a subdirectory of $GOROOT/pkg because that's the
diff --git a/src/cmd/go/internal/cfg/cfg.go b/src/cmd/go/internal/cfg/cfg.go
index 810189c15d..b47eb812b5 100644
--- a/src/cmd/go/internal/cfg/cfg.go
+++ b/src/cmd/go/internal/cfg/cfg.go
@@ -10,6 +10,7 @@ import (
 	"bytes"
 	"fmt"
 	"go/build"
+	"internal/buildcfg"
 	"internal/cfg"
 	"io"
 	"os"
@@ -19,8 +20,6 @@ import (
 	"sync"
 
 	"cmd/go/internal/fsys"
-
-	"cmd/internal/objabi"
 )
 
 // These are general "build flags" used by build and other commands.
@@ -252,12 +251,12 @@ var (
 	GOMODCACHE   = envOr("GOMODCACHE", gopathDir("pkg/mod"))
 
 	// Used in envcmd.MkEnv and build ID computations.
-	GOARM    = envOr("GOARM", fmt.Sprint(objabi.GOARM))
-	GO386    = envOr("GO386", objabi.GO386)
-	GOMIPS   = envOr("GOMIPS", objabi.GOMIPS)
-	GOMIPS64 = envOr("GOMIPS64", objabi.GOMIPS64)
-	GOPPC64  = envOr("GOPPC64", fmt.Sprintf("%s%d", "power", objabi.GOPPC64))
-	GOWASM   = envOr("GOWASM", fmt.Sprint(objabi.GOWASM))
+	GOARM    = envOr("GOARM", fmt.Sprint(buildcfg.GOARM))
+	GO386    = envOr("GO386", buildcfg.GO386)
+	GOMIPS   = envOr("GOMIPS", buildcfg.GOMIPS)
+	GOMIPS64 = envOr("GOMIPS64", buildcfg.GOMIPS64)
+	GOPPC64  = envOr("GOPPC64", fmt.Sprintf("%s%d", "power", buildcfg.GOPPC64))
+	GOWASM   = envOr("GOWASM", fmt.Sprint(buildcfg.GOWASM))
 
 	GOPROXY    = envOr("GOPROXY", "https://proxy.golang.org,direct")
 	GOSUMDB    = envOr("GOSUMDB", "sum.golang.org")
diff --git a/src/cmd/go/internal/work/exec.go b/src/cmd/go/internal/work/exec.go
index e1916007a6..a68bdd6d29 100644
--- a/src/cmd/go/internal/work/exec.go
+++ b/src/cmd/go/internal/work/exec.go
@@ -12,6 +12,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"internal/buildcfg"
 	exec "internal/execabs"
 	"internal/lazyregexp"
 	"io"
@@ -35,7 +36,6 @@ import (
 	"cmd/go/internal/modload"
 	"cmd/go/internal/str"
 	"cmd/go/internal/trace"
-	"cmd/internal/objabi"
 )
 
 // actionList returns the list of actions in the dag rooted at root
@@ -277,7 +277,7 @@ func (b *Builder) buildActionID(a *Action) cache.ActionID {
 		key, val := cfg.GetArchEnv()
 		fmt.Fprintf(h, "%s=%s\n", key, val)
 
-		if goexperiment := objabi.GOEXPERIMENT(); goexperiment != "" {
+		if goexperiment := buildcfg.GOEXPERIMENT(); goexperiment != "" {
 			fmt.Fprintf(h, "GOEXPERIMENT=%q\n", goexperiment)
 		}
 
@@ -1251,7 +1251,7 @@ func (b *Builder) printLinkerConfig(h io.Writer, p *load.Package) {
 		key, val := cfg.GetArchEnv()
 		fmt.Fprintf(h, "%s=%s\n", key, val)
 
-		if goexperiment := objabi.GOEXPERIMENT(); goexperiment != "" {
+		if goexperiment := buildcfg.GOEXPERIMENT(); goexperiment != "" {
 			fmt.Fprintf(h, "GOEXPERIMENT=%q\n", goexperiment)
 		}
 
diff --git a/src/cmd/go/internal/work/gc.go b/src/cmd/go/internal/work/gc.go
index 60d0b29a21..9adcf3035f 100644
--- a/src/cmd/go/internal/work/gc.go
+++ b/src/cmd/go/internal/work/gc.go
@@ -8,6 +8,7 @@ import (
 	"bufio"
 	"bytes"
 	"fmt"
+	"internal/buildcfg"
 	"io"
 	"log"
 	"os"
@@ -231,7 +232,7 @@ CheckFlags:
 	}
 
 	// TODO: Test and delete these conditions.
-	if objabi.Experiment.FieldTrack || objabi.Experiment.PreemptibleLoops {
+	if buildcfg.Experiment.FieldTrack || buildcfg.Experiment.PreemptibleLoops {
 		canDashC = false
 	}
 
diff --git a/src/cmd/go/internal/work/init.go b/src/cmd/go/internal/work/init.go
index 1e1494998a..66e1ca7d80 100644
--- a/src/cmd/go/internal/work/init.go
+++ b/src/cmd/go/internal/work/init.go
@@ -11,10 +11,10 @@ import (
 	"cmd/go/internal/cfg"
 	"cmd/go/internal/fsys"
 	"cmd/go/internal/modload"
-	"cmd/internal/objabi"
 	"cmd/internal/sys"
 	"flag"
 	"fmt"
+	"internal/buildcfg"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -52,7 +52,7 @@ func BuildInit() {
 	// used for compiling alternative files for the experiment. This allows
 	// changes for the experiment, like extra struct fields in the runtime,
 	// without affecting the base non-experiment code at all.
-	for _, expt := range objabi.EnabledExperiments() {
+	for _, expt := range buildcfg.EnabledExperiments() {
 		cfg.BuildContext.BuildTags = append(cfg.BuildContext.BuildTags, "goexperiment."+expt)
 	}
 }
diff --git a/src/cmd/go/main.go b/src/cmd/go/main.go
index 9cc44da84d..02174a56ff 100644
--- a/src/cmd/go/main.go
+++ b/src/cmd/go/main.go
@@ -10,6 +10,7 @@ import (
 	"context"
 	"flag"
 	"fmt"
+	"internal/buildcfg"
 	"log"
 	"os"
 	"path/filepath"
@@ -144,6 +145,11 @@ func main() {
 		os.Exit(2)
 	}
 
+	if err := buildcfg.Error; err != nil {
+		fmt.Fprintf(os.Stderr, "go: %v\n", buildcfg.Error)
+		os.Exit(2)
+	}
+
 	// Set environment (GOOS, GOARCH, etc) explicitly.
 	// In theory all the commands we invoke should have
 	// the same default computation of these as we do,
diff --git a/src/cmd/go/script_test.go b/src/cmd/go/script_test.go
index 20d0f956a7..87b5971aa7 100644
--- a/src/cmd/go/script_test.go
+++ b/src/cmd/go/script_test.go
@@ -13,6 +13,7 @@ import (
 	"errors"
 	"fmt"
 	"go/build"
+	"internal/buildcfg"
 	"internal/testenv"
 	"io/fs"
 	"os"
@@ -32,7 +33,6 @@ import (
 	"cmd/go/internal/robustio"
 	"cmd/go/internal/txtar"
 	"cmd/go/internal/work"
-	"cmd/internal/objabi"
 	"cmd/internal/sys"
 )
 
@@ -165,7 +165,7 @@ func (ts *testScript) setup() {
 		"GOCACHE=" + testGOCACHE,
 		"GODEBUG=" + os.Getenv("GODEBUG"),
 		"GOEXE=" + cfg.ExeSuffix,
-		"GOEXPERIMENT=" + objabi.GOEXPERIMENT(),
+		"GOEXPERIMENT=" + buildcfg.GOEXPERIMENT(),
 		"GOOS=" + runtime.GOOS,
 		"GOPATH=" + filepath.Join(ts.workdir, "gopath"),
 		"GOPROXY=" + proxyURL,
diff --git a/src/cmd/internal/dwarf/dwarf.go b/src/cmd/internal/dwarf/dwarf.go
index c48e1723c8..ec441c2bcb 100644
--- a/src/cmd/internal/dwarf/dwarf.go
+++ b/src/cmd/internal/dwarf/dwarf.go
@@ -9,13 +9,15 @@ package dwarf
 
 import (
 	"bytes"
-	"cmd/internal/objabi"
 	"errors"
 	"fmt"
+	"internal/buildcfg"
 	exec "internal/execabs"
 	"sort"
 	"strconv"
 	"strings"
+
+	"cmd/internal/objabi"
 )
 
 // InfoPrefix is the prefix for all the symbols containing DWARF info entries.
@@ -381,7 +383,7 @@ func expandPseudoForm(form uint8) uint8 {
 		return form
 	}
 	expandedForm := DW_FORM_udata
-	if objabi.GOOS == "darwin" || objabi.GOOS == "ios" {
+	if buildcfg.GOOS == "darwin" || buildcfg.GOOS == "ios" {
 		expandedForm = DW_FORM_data4
 	}
 	return uint8(expandedForm)
diff --git a/src/cmd/internal/goobj/objfile_test.go b/src/cmd/internal/goobj/objfile_test.go
index ad80ede0f3..ed942aa934 100644
--- a/src/cmd/internal/goobj/objfile_test.go
+++ b/src/cmd/internal/goobj/objfile_test.go
@@ -10,6 +10,7 @@ import (
 	"cmd/internal/bio"
 	"cmd/internal/objabi"
 	"fmt"
+	"internal/buildcfg"
 	"internal/testenv"
 	"io/ioutil"
 	"os"
@@ -91,8 +92,8 @@ func main() {
 `
 
 func TestIssue41621LargeNumberOfRelocations(t *testing.T) {
-	if testing.Short() || (objabi.GOARCH != "amd64") {
-		t.Skipf("Skipping large number of relocations test in short mode or on %s", objabi.GOARCH)
+	if testing.Short() || (buildcfg.GOARCH != "amd64") {
+		t.Skipf("Skipping large number of relocations test in short mode or on %s", buildcfg.GOARCH)
 	}
 	testenv.MustHaveGoBuild(t)
 
diff --git a/src/cmd/internal/obj/arm/asm5.go b/src/cmd/internal/obj/arm/asm5.go
index ebb98b4859..ccf5f9e7f8 100644
--- a/src/cmd/internal/obj/arm/asm5.go
+++ b/src/cmd/internal/obj/arm/asm5.go
@@ -34,6 +34,7 @@ import (
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
 	"fmt"
+	"internal/buildcfg"
 	"log"
 	"math"
 	"sort"
@@ -976,7 +977,7 @@ func (c *ctxt5) aclass(a *obj.Addr) int {
 			if immrot(^uint32(c.instoffset)) != 0 {
 				return C_NCON
 			}
-			if uint32(c.instoffset) <= 0xffff && objabi.GOARM == 7 {
+			if uint32(c.instoffset) <= 0xffff && buildcfg.GOARM == 7 {
 				return C_SCON
 			}
 			if x, y := immrot2a(uint32(c.instoffset)); x != 0 && y != 0 {
@@ -3044,7 +3045,7 @@ func (c *ctxt5) omvl(p *obj.Prog, a *obj.Addr, dr int) uint32 {
 
 func (c *ctxt5) chipzero5(e float64) int {
 	// We use GOARM=7 to gate the use of VFPv3 vmov (imm) instructions.
-	if objabi.GOARM < 7 || math.Float64bits(e) != 0 {
+	if buildcfg.GOARM < 7 || math.Float64bits(e) != 0 {
 		return -1
 	}
 	return 0
@@ -3052,7 +3053,7 @@ func (c *ctxt5) chipzero5(e float64) int {
 
 func (c *ctxt5) chipfloat5(e float64) int {
 	// We use GOARM=7 to gate the use of VFPv3 vmov (imm) instructions.
-	if objabi.GOARM < 7 {
+	if buildcfg.GOARM < 7 {
 		return -1
 	}
 
diff --git a/src/cmd/internal/obj/arm/obj5.go b/src/cmd/internal/obj/arm/obj5.go
index edb384806b..1454d8a7c9 100644
--- a/src/cmd/internal/obj/arm/obj5.go
+++ b/src/cmd/internal/obj/arm/obj5.go
@@ -34,6 +34,7 @@ import (
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
 	"cmd/internal/sys"
+	"internal/buildcfg"
 	"log"
 )
 
@@ -64,7 +65,7 @@ func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
 				ctxt.Diag("%v: TLS MRC instruction must write to R0 as it might get translated into a BL instruction", p.Line())
 			}
 
-			if objabi.GOARM < 7 {
+			if buildcfg.GOARM < 7 {
 				// Replace it with BL runtime.read_tls_fallback(SB) for ARM CPUs that lack the tls extension.
 				if progedit_tlsfallback == nil {
 					progedit_tlsfallback = ctxt.Lookup("runtime.read_tls_fallback")
diff --git a/src/cmd/internal/obj/arm64/obj7.go b/src/cmd/internal/obj/arm64/obj7.go
index 514991e340..e41fb3bb75 100644
--- a/src/cmd/internal/obj/arm64/obj7.go
+++ b/src/cmd/internal/obj/arm64/obj7.go
@@ -35,6 +35,7 @@ import (
 	"cmd/internal/objabi"
 	"cmd/internal/src"
 	"cmd/internal/sys"
+	"internal/buildcfg"
 	"log"
 	"math"
 )
@@ -576,7 +577,7 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 				q1.To.Reg = REGSP
 				q1.Spadj = c.autosize
 
-				if objabi.GOOS == "ios" {
+				if buildcfg.GOOS == "ios" {
 					// iOS does not support SA_ONSTACK. We will run the signal handler
 					// on the G stack. If we write below SP, it may be clobbered by
 					// the signal handler. So we save LR after decrementing SP.
diff --git a/src/cmd/internal/obj/sym.go b/src/cmd/internal/obj/sym.go
index 98c7364e2a..9e8b4dd790 100644
--- a/src/cmd/internal/obj/sym.go
+++ b/src/cmd/internal/obj/sym.go
@@ -35,6 +35,7 @@ import (
 	"cmd/internal/goobj"
 	"cmd/internal/objabi"
 	"fmt"
+	"internal/buildcfg"
 	"log"
 	"math"
 	"sort"
@@ -49,8 +50,8 @@ func Linknew(arch *LinkArch) *Link {
 	ctxt.Arch = arch
 	ctxt.Pathname = objabi.WorkingDir()
 
-	if err := ctxt.Headtype.Set(objabi.GOOS); err != nil {
-		log.Fatalf("unknown goos %s", objabi.GOOS)
+	if err := ctxt.Headtype.Set(buildcfg.GOOS); err != nil {
+		log.Fatalf("unknown goos %s", buildcfg.GOOS)
 	}
 
 	ctxt.Flag_optimize = true
diff --git a/src/cmd/internal/obj/util.go b/src/cmd/internal/obj/util.go
index 1c34b4e833..e8441a6969 100644
--- a/src/cmd/internal/obj/util.go
+++ b/src/cmd/internal/obj/util.go
@@ -8,6 +8,7 @@ import (
 	"bytes"
 	"cmd/internal/objabi"
 	"fmt"
+	"internal/buildcfg"
 	"io"
 	"strings"
 )
@@ -83,7 +84,7 @@ func CConv(s uint8) string {
 	}
 	for i := range opSuffixSpace {
 		sset := &opSuffixSpace[i]
-		if sset.arch == objabi.GOARCH {
+		if sset.arch == buildcfg.GOARCH {
 			return sset.cconv(s)
 		}
 	}
@@ -330,7 +331,7 @@ func writeDconv(w io.Writer, p *Prog, a *Addr, abiDetail bool) {
 	case TYPE_SHIFT:
 		v := int(a.Offset)
 		ops := "<<>>->@>"
-		switch objabi.GOARCH {
+		switch buildcfg.GOARCH {
 		case "arm":
 			op := ops[((v>>5)&3)<<1:]
 			if v&(1<<4) != 0 {
@@ -346,7 +347,7 @@ func writeDconv(w io.Writer, p *Prog, a *Addr, abiDetail bool) {
 			r := (v >> 16) & 31
 			fmt.Fprintf(w, "%s%c%c%d", Rconv(r+RBaseARM64), op[0], op[1], (v>>10)&63)
 		default:
-			panic("TYPE_SHIFT is not supported on " + objabi.GOARCH)
+			panic("TYPE_SHIFT is not supported on " + buildcfg.GOARCH)
 		}
 
 	case TYPE_REGREG:
diff --git a/src/cmd/internal/obj/x86/asm6.go b/src/cmd/internal/obj/x86/asm6.go
index 52ac567a36..17fa76727e 100644
--- a/src/cmd/internal/obj/x86/asm6.go
+++ b/src/cmd/internal/obj/x86/asm6.go
@@ -36,6 +36,7 @@ import (
 	"cmd/internal/sys"
 	"encoding/binary"
 	"fmt"
+	"internal/buildcfg"
 	"log"
 	"strings"
 )
@@ -2460,7 +2461,7 @@ func instinit(ctxt *obj.Link) {
 	}
 }
 
-var isAndroid = objabi.GOOS == "android"
+var isAndroid = buildcfg.GOOS == "android"
 
 func prefixof(ctxt *obj.Link, a *obj.Addr) int {
 	if a.Reg < REG_CS && a.Index < REG_CS { // fast path
diff --git a/src/cmd/internal/obj/x86/obj6.go b/src/cmd/internal/obj/x86/obj6.go
index 06736d43bd..e2732d53e3 100644
--- a/src/cmd/internal/obj/x86/obj6.go
+++ b/src/cmd/internal/obj/x86/obj6.go
@@ -35,6 +35,7 @@ import (
 	"cmd/internal/objabi"
 	"cmd/internal/src"
 	"cmd/internal/sys"
+	"internal/buildcfg"
 	"log"
 	"math"
 	"path"
@@ -646,13 +647,13 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 
 	var regg int16
 	if !p.From.Sym.NoSplit() || p.From.Sym.Wrapper() {
-		if ctxt.Arch.Family == sys.AMD64 && objabi.Experiment.RegabiG && cursym.ABI() == obj.ABIInternal {
+		if ctxt.Arch.Family == sys.AMD64 && buildcfg.Experiment.RegabiG && cursym.ABI() == obj.ABIInternal {
 			regg = REGG // use the g register directly in ABIInternal
 		} else {
 			p = obj.Appendp(p, newprog)
 			regg = REG_CX
 			if ctxt.Arch.Family == sys.AMD64 {
-				// Using this register means that stacksplit works w/ //go:registerparams even when !objabi.Experiment.RegabiG
+				// Using this register means that stacksplit works w/ //go:registerparams even when !buildcfg.Experiment.RegabiG
 				regg = REGG // == REG_R14
 			}
 			p = load_g(ctxt, p, newprog, regg) // load g into regg
diff --git a/src/cmd/internal/objabi/flag.go b/src/cmd/internal/objabi/flag.go
index 9fcab4cc85..e41fc570b0 100644
--- a/src/cmd/internal/objabi/flag.go
+++ b/src/cmd/internal/objabi/flag.go
@@ -8,6 +8,7 @@ import (
 	"bytes"
 	"flag"
 	"fmt"
+	"internal/buildcfg"
 	"io"
 	"io/ioutil"
 	"log"
@@ -96,11 +97,11 @@ func (versionFlag) Set(s string) error {
 	if s == "goexperiment" {
 		// test/run.go uses this to discover the full set of
 		// experiment tags. Report everything.
-		p = " X:" + strings.Join(expList(&Experiment, nil, true), ",")
+		p = " X:" + strings.Join(buildcfg.AllExperiments(), ",")
 	} else {
 		// If the enabled experiments differ from the defaults,
 		// include that difference.
-		if goexperiment := GOEXPERIMENT(); goexperiment != "" {
+		if goexperiment := buildcfg.GOEXPERIMENT(); goexperiment != "" {
 			p = " X:" + goexperiment
 		}
 	}
@@ -111,12 +112,12 @@ func (versionFlag) Set(s string) error {
 	// build ID of the binary, so that if the compiler is changed and
 	// rebuilt, we notice and rebuild all packages.
 	if s == "full" {
-		if strings.HasPrefix(Version, "devel") {
+		if strings.HasPrefix(buildcfg.Version, "devel") {
 			p += " buildID=" + buildID
 		}
 	}
 
-	fmt.Printf("%s version %s%s\n", name, Version, p)
+	fmt.Printf("%s version %s%s\n", name, buildcfg.Version, p)
 	os.Exit(0)
 	return nil
 }
diff --git a/src/cmd/internal/objabi/line.go b/src/cmd/internal/objabi/line.go
index 0733b65138..0b1e0bb181 100644
--- a/src/cmd/internal/objabi/line.go
+++ b/src/cmd/internal/objabi/line.go
@@ -5,6 +5,7 @@
 package objabi
 
 import (
+	"internal/buildcfg"
 	"os"
 	"path/filepath"
 	"strings"
@@ -38,8 +39,8 @@ func AbsFile(dir, file, rewrites string) string {
 	}
 
 	abs, rewritten := ApplyRewrites(abs, rewrites)
-	if !rewritten && hasPathPrefix(abs, GOROOT) {
-		abs = "$GOROOT" + abs[len(GOROOT):]
+	if !rewritten && hasPathPrefix(abs, buildcfg.GOROOT) {
+		abs = "$GOROOT" + abs[len(buildcfg.GOROOT):]
 	}
 
 	if abs == "" {
diff --git a/src/cmd/internal/objabi/stack.go b/src/cmd/internal/objabi/stack.go
index 1f531176cc..0c82a7c6dd 100644
--- a/src/cmd/internal/objabi/stack.go
+++ b/src/cmd/internal/objabi/stack.go
@@ -4,6 +4,8 @@
 
 package objabi
 
+import "internal/buildcfg"
+
 // For the linkers. Must match Go definitions.
 
 const (
@@ -22,7 +24,7 @@ var StackLimit = StackGuard - StackSystem - StackSmall
 // builds that have larger stack frames or for specific targets.
 func stackGuardMultiplier() int {
 	// On AIX, a larger stack is needed for syscalls.
-	if GOOS == "aix" {
+	if buildcfg.GOOS == "aix" {
 		return 2
 	}
 	return stackGuardMultiplierDefault
diff --git a/src/cmd/internal/objabi/util.go b/src/cmd/internal/objabi/util.go
index 5a7a74cfde..63640950d9 100644
--- a/src/cmd/internal/objabi/util.go
+++ b/src/cmd/internal/objabi/util.go
@@ -6,32 +6,9 @@ package objabi
 
 import (
 	"fmt"
-	"log"
-	"os"
 	"strings"
-)
-
-func envOr(key, value string) string {
-	if x := os.Getenv(key); x != "" {
-		return x
-	}
-	return value
-}
 
-var (
-	defaultGOROOT string // set by linker
-
-	GOROOT   = envOr("GOROOT", defaultGOROOT)
-	GOARCH   = envOr("GOARCH", defaultGOARCH)
-	GOOS     = envOr("GOOS", defaultGOOS)
-	GO386    = envOr("GO386", defaultGO386)
-	GOARM    = goarm()
-	GOMIPS   = gomips()
-	GOMIPS64 = gomips64()
-	GOPPC64  = goppc64()
-	GOWASM   = gowasm()
-	GO_LDSO  = defaultGO_LDSO
-	Version  = version
+	"internal/buildcfg"
 )
 
 const (
@@ -39,94 +16,10 @@ const (
 	MachoRelocOffset = 2048 // reserve enough space for ELF relocations
 )
 
-func goarm() int {
-	def := defaultGOARM
-	if GOOS == "android" && GOARCH == "arm" {
-		// Android arm devices always support GOARM=7.
-		def = "7"
-	}
-	switch v := envOr("GOARM", def); v {
-	case "5":
-		return 5
-	case "6":
-		return 6
-	case "7":
-		return 7
-	}
-	// Fail here, rather than validate at multiple call sites.
-	log.Fatalf("Invalid GOARM value. Must be 5, 6, or 7.")
-	panic("unreachable")
-}
-
-func gomips() string {
-	switch v := envOr("GOMIPS", defaultGOMIPS); v {
-	case "hardfloat", "softfloat":
-		return v
-	}
-	log.Fatalf("Invalid GOMIPS value. Must be hardfloat or softfloat.")
-	panic("unreachable")
-}
-
-func gomips64() string {
-	switch v := envOr("GOMIPS64", defaultGOMIPS64); v {
-	case "hardfloat", "softfloat":
-		return v
-	}
-	log.Fatalf("Invalid GOMIPS64 value. Must be hardfloat or softfloat.")
-	panic("unreachable")
-}
-
-func goppc64() int {
-	switch v := envOr("GOPPC64", defaultGOPPC64); v {
-	case "power8":
-		return 8
-	case "power9":
-		return 9
-	}
-	log.Fatalf("Invalid GOPPC64 value. Must be power8 or power9.")
-	panic("unreachable")
-}
-
-type gowasmFeatures struct {
-	SignExt bool
-	SatConv bool
-}
-
-func (f gowasmFeatures) String() string {
-	var flags []string
-	if f.SatConv {
-		flags = append(flags, "satconv")
-	}
-	if f.SignExt {
-		flags = append(flags, "signext")
-	}
-	return strings.Join(flags, ",")
-}
-
-func gowasm() (f gowasmFeatures) {
-	for _, opt := range strings.Split(envOr("GOWASM", ""), ",") {
-		switch opt {
-		case "satconv":
-			f.SatConv = true
-		case "signext":
-			f.SignExt = true
-		case "":
-			// ignore
-		default:
-			log.Fatalf("Invalid GOWASM value. No such feature: " + opt)
-		}
-	}
-	return
-}
-
-func Getgoextlinkenabled() string {
-	return envOr("GO_EXTLINK_ENABLED", defaultGO_EXTLINK_ENABLED)
-}
-
 // HeaderString returns the toolchain configuration string written in
 // Go object headers. This string ensures we don't attempt to import
 // or link object files that are incompatible with each other. This
 // string always starts with "go object ".
 func HeaderString() string {
-	return fmt.Sprintf("go object %s %s %s X:%s\n", GOOS, GOARCH, Version, strings.Join(EnabledExperiments(), ","))
+	return fmt.Sprintf("go object %s %s %s X:%s\n", buildcfg.GOOS, buildcfg.GOARCH, buildcfg.Version, strings.Join(buildcfg.EnabledExperiments(), ","))
 }
diff --git a/src/cmd/link/internal/ld/ar.go b/src/cmd/link/internal/ld/ar.go
index e4fd591676..22f53a4df2 100644
--- a/src/cmd/link/internal/ld/ar.go
+++ b/src/cmd/link/internal/ld/ar.go
@@ -32,10 +32,10 @@ package ld
 
 import (
 	"cmd/internal/bio"
-	"cmd/internal/objabi"
 	"cmd/link/internal/sym"
 	"encoding/binary"
 	"fmt"
+	"internal/buildcfg"
 	"io"
 	"os"
 )
@@ -170,7 +170,7 @@ func readArmap(filename string, f *bio.Reader, arhdr ArHdr) archiveMap {
 
 		// For Mach-O and PE/386 files we strip a leading
 		// underscore from the symbol name.
-		if objabi.GOOS == "darwin" || objabi.GOOS == "ios" || (objabi.GOOS == "windows" && objabi.GOARCH == "386") {
+		if buildcfg.GOOS == "darwin" || buildcfg.GOOS == "ios" || (buildcfg.GOOS == "windows" && buildcfg.GOARCH == "386") {
 			if name[0] == '_' && len(name) > 1 {
 				name = name[1:]
 			}
diff --git a/src/cmd/link/internal/ld/config.go b/src/cmd/link/internal/ld/config.go
index 9228962fb3..75fddc6a38 100644
--- a/src/cmd/link/internal/ld/config.go
+++ b/src/cmd/link/internal/ld/config.go
@@ -5,9 +5,9 @@
 package ld
 
 import (
-	"cmd/internal/objabi"
 	"cmd/internal/sys"
 	"fmt"
+	"internal/buildcfg"
 )
 
 // A BuildMode indicates the sort of object we are building.
@@ -28,23 +28,23 @@ const (
 
 func (mode *BuildMode) Set(s string) error {
 	badmode := func() error {
-		return fmt.Errorf("buildmode %s not supported on %s/%s", s, objabi.GOOS, objabi.GOARCH)
+		return fmt.Errorf("buildmode %s not supported on %s/%s", s, buildcfg.GOOS, buildcfg.GOARCH)
 	}
 	switch s {
 	default:
 		return fmt.Errorf("invalid buildmode: %q", s)
 	case "exe":
-		switch objabi.GOOS + "/" + objabi.GOARCH {
+		switch buildcfg.GOOS + "/" + buildcfg.GOARCH {
 		case "darwin/arm64", "windows/arm", "windows/arm64": // On these platforms, everything is PIE
 			*mode = BuildModePIE
 		default:
 			*mode = BuildModeExe
 		}
 	case "pie":
-		switch objabi.GOOS {
+		switch buildcfg.GOOS {
 		case "aix", "android", "linux", "windows", "darwin", "ios":
 		case "freebsd":
-			switch objabi.GOARCH {
+			switch buildcfg.GOARCH {
 			case "amd64":
 			default:
 				return badmode()
@@ -54,16 +54,16 @@ func (mode *BuildMode) Set(s string) error {
 		}
 		*mode = BuildModePIE
 	case "c-archive":
-		switch objabi.GOOS {
+		switch buildcfg.GOOS {
 		case "aix", "darwin", "ios", "linux":
 		case "freebsd":
-			switch objabi.GOARCH {
+			switch buildcfg.GOARCH {
 			case "amd64":
 			default:
 				return badmode()
 			}
 		case "windows":
-			switch objabi.GOARCH {
+			switch buildcfg.GOARCH {
 			case "amd64", "386", "arm", "arm64":
 			default:
 				return badmode()
@@ -73,16 +73,16 @@ func (mode *BuildMode) Set(s string) error {
 		}
 		*mode = BuildModeCArchive
 	case "c-shared":
-		switch objabi.GOARCH {
+		switch buildcfg.GOARCH {
 		case "386", "amd64", "arm", "arm64", "ppc64le", "s390x":
 		default:
 			return badmode()
 		}
 		*mode = BuildModeCShared
 	case "shared":
-		switch objabi.GOOS {
+		switch buildcfg.GOOS {
 		case "linux":
-			switch objabi.GOARCH {
+			switch buildcfg.GOARCH {
 			case "386", "amd64", "arm", "arm64", "ppc64le", "s390x":
 			default:
 				return badmode()
@@ -92,21 +92,21 @@ func (mode *BuildMode) Set(s string) error {
 		}
 		*mode = BuildModeShared
 	case "plugin":
-		switch objabi.GOOS {
+		switch buildcfg.GOOS {
 		case "linux":
-			switch objabi.GOARCH {
+			switch buildcfg.GOARCH {
 			case "386", "amd64", "arm", "arm64", "s390x", "ppc64le":
 			default:
 				return badmode()
 			}
 		case "darwin":
-			switch objabi.GOARCH {
+			switch buildcfg.GOARCH {
 			case "amd64", "arm64":
 			default:
 				return badmode()
 			}
 		case "freebsd":
-			switch objabi.GOARCH {
+			switch buildcfg.GOARCH {
 			case "amd64":
 			default:
 				return badmode()
@@ -185,8 +185,8 @@ func mustLinkExternal(ctxt *Link) (res bool, reason string) {
 		}()
 	}
 
-	if sys.MustLinkExternal(objabi.GOOS, objabi.GOARCH) {
-		return true, fmt.Sprintf("%s/%s requires external linking", objabi.GOOS, objabi.GOARCH)
+	if sys.MustLinkExternal(buildcfg.GOOS, buildcfg.GOARCH) {
+		return true, fmt.Sprintf("%s/%s requires external linking", buildcfg.GOOS, buildcfg.GOARCH)
 	}
 
 	if *flagMsan {
@@ -197,20 +197,20 @@ func mustLinkExternal(ctxt *Link) (res bool, reason string) {
 	// https://golang.org/issue/14449
 	// https://golang.org/issue/21961
 	if iscgo && ctxt.Arch.InFamily(sys.MIPS64, sys.MIPS, sys.PPC64, sys.RISCV64) {
-		return true, objabi.GOARCH + " does not support internal cgo"
+		return true, buildcfg.GOARCH + " does not support internal cgo"
 	}
-	if iscgo && (objabi.GOOS == "android" || objabi.GOOS == "dragonfly") {
+	if iscgo && (buildcfg.GOOS == "android" || buildcfg.GOOS == "dragonfly") {
 		// It seems that on Dragonfly thread local storage is
 		// set up by the dynamic linker, so internal cgo linking
 		// doesn't work. Test case is "go test runtime/cgo".
-		return true, objabi.GOOS + " does not support internal cgo"
+		return true, buildcfg.GOOS + " does not support internal cgo"
 	}
 
 	// When the race flag is set, the LLVM tsan relocatable file is linked
 	// into the final binary, which means external linking is required because
 	// internal linking does not support it.
 	if *flagRace && ctxt.Arch.InFamily(sys.PPC64) {
-		return true, "race on " + objabi.GOARCH
+		return true, "race on " + buildcfg.GOARCH
 	}
 
 	// Some build modes require work the internal linker cannot do (yet).
@@ -220,7 +220,7 @@ func mustLinkExternal(ctxt *Link) (res bool, reason string) {
 	case BuildModeCShared:
 		return true, "buildmode=c-shared"
 	case BuildModePIE:
-		switch objabi.GOOS + "/" + objabi.GOARCH {
+		switch buildcfg.GOOS + "/" + buildcfg.GOARCH {
 		case "linux/amd64", "linux/arm64", "android/arm64":
 		case "windows/386", "windows/amd64", "windows/arm", "windows/arm64":
 		case "darwin/amd64", "darwin/arm64":
@@ -254,7 +254,7 @@ func determineLinkMode(ctxt *Link) {
 		// default value of -linkmode. If it is not set when the
 		// linker is called we take the value it was set to when
 		// cmd/link was compiled. (See make.bash.)
-		switch objabi.Getgoextlinkenabled() {
+		switch buildcfg.Getgoextlinkenabled() {
 		case "0":
 			ctxt.LinkMode = LinkInternal
 			via = "via GO_EXTLINK_ENABLED "
@@ -277,8 +277,8 @@ func determineLinkMode(ctxt *Link) {
 		}
 	case LinkExternal:
 		switch {
-		case objabi.GOARCH == "ppc64" && objabi.GOOS != "aix":
-			Exitf("external linking not supported for %s/ppc64", objabi.GOOS)
+		case buildcfg.GOARCH == "ppc64" && buildcfg.GOOS != "aix":
+			Exitf("external linking not supported for %s/ppc64", buildcfg.GOOS)
 		}
 	}
 }
diff --git a/src/cmd/link/internal/ld/data_test.go b/src/cmd/link/internal/ld/data_test.go
index 7c46307bd8..f91493bc41 100644
--- a/src/cmd/link/internal/ld/data_test.go
+++ b/src/cmd/link/internal/ld/data_test.go
@@ -8,6 +8,7 @@ import (
 	"cmd/internal/objabi"
 	"cmd/internal/sys"
 	"cmd/link/internal/loader"
+	"internal/buildcfg"
 	"testing"
 )
 
@@ -63,14 +64,14 @@ func TestAddGotSym(t *testing.T) {
 	}
 
 	// Save the architecture as we're going to set it on each test run.
-	origArch := objabi.GOARCH
+	origArch := buildcfg.GOARCH
 	defer func() {
-		objabi.GOARCH = origArch
+		buildcfg.GOARCH = origArch
 	}()
 
 	for i, test := range tests {
 		iself := len(test.rel) != 0
-		objabi.GOARCH = test.arch.Name
+		buildcfg.GOARCH = test.arch.Name
 		ctxt := setUpContext(test.arch, iself, test.ht, test.bm, test.lm)
 		foo := ctxt.loader.CreateSymForUpdate("foo", 0)
 		ctxt.loader.CreateExtSym("bar", 0)
diff --git a/src/cmd/link/internal/ld/deadcode.go b/src/cmd/link/internal/ld/deadcode.go
index 741a72cad8..1ed5598c99 100644
--- a/src/cmd/link/internal/ld/deadcode.go
+++ b/src/cmd/link/internal/ld/deadcode.go
@@ -11,6 +11,7 @@ import (
 	"cmd/link/internal/loader"
 	"cmd/link/internal/sym"
 	"fmt"
+	"internal/buildcfg"
 	"unicode"
 )
 
@@ -32,7 +33,7 @@ type deadcodePass struct {
 func (d *deadcodePass) init() {
 	d.ldr.InitReachable()
 	d.ifaceMethod = make(map[methodsig]bool)
-	if objabi.Experiment.FieldTrack {
+	if buildcfg.Experiment.FieldTrack {
 		d.ldr.Reachparent = make([]loader.Sym, d.ldr.NSym())
 	}
 	d.dynlink = d.ctxt.DynlinkingGo()
@@ -258,7 +259,7 @@ func (d *deadcodePass) mark(symIdx, parent loader.Sym) {
 	if symIdx != 0 && !d.ldr.AttrReachable(symIdx) {
 		d.wq.push(symIdx)
 		d.ldr.SetAttrReachable(symIdx, true)
-		if objabi.Experiment.FieldTrack && d.ldr.Reachparent[symIdx] == 0 {
+		if buildcfg.Experiment.FieldTrack && d.ldr.Reachparent[symIdx] == 0 {
 			d.ldr.Reachparent[symIdx] = parent
 		}
 		if *flagDumpDep {
diff --git a/src/cmd/link/internal/ld/dwarf.go b/src/cmd/link/internal/ld/dwarf.go
index 2f19c3eaa2..c53d2408cb 100644
--- a/src/cmd/link/internal/ld/dwarf.go
+++ b/src/cmd/link/internal/ld/dwarf.go
@@ -22,6 +22,7 @@ import (
 	"cmd/link/internal/loader"
 	"cmd/link/internal/sym"
 	"fmt"
+	"internal/buildcfg"
 	"log"
 	"path"
 	"runtime"
@@ -1843,7 +1844,7 @@ func dwarfGenerateDebugInfo(ctxt *Link) {
 			if producerExtra := d.ldr.Lookup(dwarf.CUInfoPrefix+"producer."+unit.Lib.Pkg, 0); producerExtra != 0 {
 				peData = d.ldr.Data(producerExtra)
 			}
-			producer := "Go cmd/compile " + objabi.Version
+			producer := "Go cmd/compile " + buildcfg.Version
 			if len(peData) > 0 {
 				// We put a semicolon before the flags to clearly
 				// separate them from the version, which can be long
diff --git a/src/cmd/link/internal/ld/elf.go b/src/cmd/link/internal/ld/elf.go
index 3ba9f329ee..87d88dd957 100644
--- a/src/cmd/link/internal/ld/elf.go
+++ b/src/cmd/link/internal/ld/elf.go
@@ -14,6 +14,7 @@ import (
 	"encoding/binary"
 	"encoding/hex"
 	"fmt"
+	"internal/buildcfg"
 	"path/filepath"
 	"sort"
 	"strings"
@@ -584,7 +585,7 @@ func elfWriteMipsAbiFlags(ctxt *Link) int {
 	ctxt.Out.Write8(1)  // gprSize
 	ctxt.Out.Write8(1)  // cpr1Size
 	ctxt.Out.Write8(0)  // cpr2Size
-	if objabi.GOMIPS == "softfloat" {
+	if buildcfg.GOMIPS == "softfloat" {
 		ctxt.Out.Write8(MIPS_FPABI_SOFT) // fpAbi
 	} else {
 		// Go cannot make sure non odd-number-fpr is used (ie, in load a double from memory).
@@ -1557,7 +1558,7 @@ func (ctxt *Link) doelf() {
 		gnuattributes.AddUint8(1)                 // 1:file, 2: section, 3: symbol, 1 here
 		gnuattributes.AddUint32(ctxt.Arch, 7)     // tag length, including tag, 7 here
 		gnuattributes.AddUint8(4)                 // 4 for FP, 8 for MSA
-		if objabi.GOMIPS == "softfloat" {
+		if buildcfg.GOMIPS == "softfloat" {
 			gnuattributes.AddUint8(MIPS_FPABI_SOFT)
 		} else {
 			// Note: MIPS_FPABI_ANY is bad naming: in fact it is MIPS I style FPR usage.
@@ -1743,14 +1744,14 @@ func asmbElf(ctxt *Link) {
 		sh.Flags = uint64(elf.SHF_ALLOC)
 		sh.Addralign = 1
 
-		if interpreter == "" && objabi.GO_LDSO != "" {
-			interpreter = objabi.GO_LDSO
+		if interpreter == "" && buildcfg.GO_LDSO != "" {
+			interpreter = buildcfg.GO_LDSO
 		}
 
 		if interpreter == "" {
 			switch ctxt.HeadType {
 			case objabi.Hlinux:
-				if objabi.GOOS == "android" {
+				if buildcfg.GOOS == "android" {
 					interpreter = thearch.Androiddynld
 					if interpreter == "" {
 						Exitf("ELF interpreter not set")
diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index b709569103..b814a277e6 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -49,6 +49,7 @@ import (
 	"encoding/base64"
 	"encoding/binary"
 	"fmt"
+	"internal/buildcfg"
 	exec "internal/execabs"
 	"io"
 	"io/ioutil"
@@ -379,7 +380,7 @@ func libinit(ctxt *Link) {
 		suffix = "msan"
 	}
 
-	Lflag(ctxt, filepath.Join(objabi.GOROOT, "pkg", fmt.Sprintf("%s_%s%s%s", objabi.GOOS, objabi.GOARCH, suffixsep, suffix)))
+	Lflag(ctxt, filepath.Join(buildcfg.GOROOT, "pkg", fmt.Sprintf("%s_%s%s%s", buildcfg.GOOS, buildcfg.GOARCH, suffixsep, suffix)))
 
 	mayberemoveoutfile()
 
@@ -390,9 +391,9 @@ func libinit(ctxt *Link) {
 	if *flagEntrySymbol == "" {
 		switch ctxt.BuildMode {
 		case BuildModeCShared, BuildModeCArchive:
-			*flagEntrySymbol = fmt.Sprintf("_rt0_%s_%s_lib", objabi.GOARCH, objabi.GOOS)
+			*flagEntrySymbol = fmt.Sprintf("_rt0_%s_%s_lib", buildcfg.GOARCH, buildcfg.GOOS)
 		case BuildModeExe, BuildModePIE:
-			*flagEntrySymbol = fmt.Sprintf("_rt0_%s_%s", objabi.GOARCH, objabi.GOOS)
+			*flagEntrySymbol = fmt.Sprintf("_rt0_%s_%s", buildcfg.GOARCH, buildcfg.GOOS)
 		case BuildModeShared, BuildModePlugin:
 			// No *flagEntrySymbol for -buildmode=shared and plugin
 		default:
@@ -495,7 +496,7 @@ func (ctxt *Link) loadlib() {
 	default:
 		log.Fatalf("invalid -strictdups flag value %d", *FlagStrictDups)
 	}
-	if !objabi.Experiment.RegabiWrappers || ctxt.linkShared {
+	if !buildcfg.Experiment.RegabiWrappers || ctxt.linkShared {
 		// Use ABI aliases if ABI wrappers are not used.
 		// TODO: for now we still use ABI aliases in shared linkage, even if
 		// the wrapper is enabled.
@@ -543,7 +544,7 @@ func (ctxt *Link) loadlib() {
 	// We now have enough information to determine the link mode.
 	determineLinkMode(ctxt)
 
-	if ctxt.LinkMode == LinkExternal && !iscgo && !(objabi.GOOS == "darwin" && ctxt.BuildMode != BuildModePlugin && ctxt.Arch.Family == sys.AMD64) {
+	if ctxt.LinkMode == LinkExternal && !iscgo && !(buildcfg.GOOS == "darwin" && ctxt.BuildMode != BuildModePlugin && ctxt.Arch.Family == sys.AMD64) {
 		// This indicates a user requested -linkmode=external.
 		// The startup code uses an import of runtime/cgo to decide
 		// whether to initialize the TLS.  So give it one. This could
@@ -705,7 +706,7 @@ func (ctxt *Link) linksetup() {
 		}
 	}
 
-	if ctxt.LinkMode == LinkExternal && ctxt.Arch.Family == sys.PPC64 && objabi.GOOS != "aix" {
+	if ctxt.LinkMode == LinkExternal && ctxt.Arch.Family == sys.PPC64 && buildcfg.GOOS != "aix" {
 		toc := ctxt.loader.LookupOrCreateSym(".TOC.", 0)
 		sb := ctxt.loader.MakeSymbolUpdater(toc)
 		sb.SetType(sym.SDYNIMPORT)
@@ -714,7 +715,7 @@ func (ctxt *Link) linksetup() {
 	// The Android Q linker started to complain about underalignment of the our TLS
 	// section. We don't actually use the section on android, so don't
 	// generate it.
-	if objabi.GOOS != "android" {
+	if buildcfg.GOOS != "android" {
 		tlsg := ctxt.loader.LookupOrCreateSym("runtime.tlsg", 0)
 		sb := ctxt.loader.MakeSymbolUpdater(tlsg)
 
@@ -755,7 +756,7 @@ func (ctxt *Link) linksetup() {
 			sb := ctxt.loader.MakeSymbolUpdater(goarm)
 			sb.SetType(sym.SDATA)
 			sb.SetSize(0)
-			sb.AddUint8(uint8(objabi.GOARM))
+			sb.AddUint8(uint8(buildcfg.GOARM))
 		}
 
 		// Set runtime.disableMemoryProfiling bool if
@@ -1248,7 +1249,7 @@ func (ctxt *Link) hostlink() {
 			// -headerpad is incompatible with -fembed-bitcode.
 			argv = append(argv, "-Wl,-headerpad,1144")
 		}
-		if ctxt.DynlinkingGo() && objabi.GOOS != "ios" {
+		if ctxt.DynlinkingGo() && buildcfg.GOOS != "ios" {
 			// -flat_namespace is deprecated on iOS.
 			// It is useful for supporting plugins. We don't support plugins on iOS.
 			argv = append(argv, "-Wl,-flat_namespace")
@@ -1366,12 +1367,12 @@ func (ctxt *Link) hostlink() {
 		// from the beginning of the section (like sym.STYPE).
 		argv = append(argv, "-Wl,-znocopyreloc")
 
-		if objabi.GOOS == "android" {
+		if buildcfg.GOOS == "android" {
 			// Use lld to avoid errors from default linker (issue #38838)
 			altLinker = "lld"
 		}
 
-		if ctxt.Arch.InFamily(sys.ARM, sys.ARM64) && objabi.GOOS == "linux" {
+		if ctxt.Arch.InFamily(sys.ARM, sys.ARM64) && buildcfg.GOOS == "linux" {
 			// On ARM, the GNU linker will generate COPY relocations
 			// even with -znocopyreloc set.
 			// https://sourceware.org/bugzilla/show_bug.cgi?id=19962
@@ -1393,7 +1394,7 @@ func (ctxt *Link) hostlink() {
 			}
 		}
 	}
-	if ctxt.Arch.Family == sys.ARM64 && objabi.GOOS == "freebsd" {
+	if ctxt.Arch.Family == sys.ARM64 && buildcfg.GOOS == "freebsd" {
 		// Switch to ld.bfd on freebsd/arm64.
 		altLinker = "bfd"
 
@@ -1420,7 +1421,7 @@ func (ctxt *Link) hostlink() {
 	// only want to do this when producing a Windows output file
 	// on a Windows host.
 	outopt := *flagOutfile
-	if objabi.GOOS == "windows" && runtime.GOOS == "windows" && filepath.Ext(outopt) == "" {
+	if buildcfg.GOOS == "windows" && runtime.GOOS == "windows" && filepath.Ext(outopt) == "" {
 		outopt += "."
 	}
 	argv = append(argv, "-o")
@@ -1737,7 +1738,7 @@ func hostlinkArchArgs(arch *sys.Arch) []string {
 	case sys.I386:
 		return []string{"-m32"}
 	case sys.AMD64:
-		if objabi.GOOS == "darwin" {
+		if buildcfg.GOOS == "darwin" {
 			return []string{"-arch", "x86_64", "-m64"}
 		}
 		return []string{"-m64"}
@@ -1746,7 +1747,7 @@ func hostlinkArchArgs(arch *sys.Arch) []string {
 	case sys.ARM:
 		return []string{"-marm"}
 	case sys.ARM64:
-		if objabi.GOOS == "darwin" {
+		if buildcfg.GOOS == "darwin" {
 			return []string{"-arch", "arm64"}
 		}
 	case sys.MIPS64:
@@ -1754,7 +1755,7 @@ func hostlinkArchArgs(arch *sys.Arch) []string {
 	case sys.MIPS:
 		return []string{"-mabi=32"}
 	case sys.PPC64:
-		if objabi.GOOS == "aix" {
+		if buildcfg.GOOS == "aix" {
 			return []string{"-maix64"}
 		} else {
 			return []string{"-m64"}
@@ -1862,7 +1863,7 @@ func ldobj(ctxt *Link, f *bio.Reader, lib *sym.Library, length int64, pn string,
 	}
 
 	// First, check that the basic GOOS, GOARCH, and Version match.
-	t := fmt.Sprintf("%s %s %s ", objabi.GOOS, objabi.GOARCH, objabi.Version)
+	t := fmt.Sprintf("%s %s %s ", buildcfg.GOOS, buildcfg.GOARCH, buildcfg.Version)
 
 	line = strings.TrimRight(line, "\n")
 	if !strings.HasPrefix(line[10:]+" ", t) && !*flagF {
@@ -2084,7 +2085,7 @@ func ldshlibsyms(ctxt *Link, shlib string) {
 
 	// collect text symbol ABI versions.
 	symabi := make(map[string]int) // map (unmangled) symbol name to version
-	if objabi.Experiment.RegabiWrappers {
+	if buildcfg.Experiment.RegabiWrappers {
 		for _, elfsym := range syms {
 			if elf.ST_TYPE(elfsym.Info) != elf.STT_FUNC {
 				continue
@@ -2112,7 +2113,7 @@ func ldshlibsyms(ctxt *Link, shlib string) {
 		symname := elfsym.Name // (unmangled) symbol name
 		if elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC && strings.HasPrefix(elfsym.Name, "type.") {
 			ver = sym.SymVerABIInternal
-		} else if objabi.Experiment.RegabiWrappers && elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC {
+		} else if buildcfg.Experiment.RegabiWrappers && elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC {
 			if strings.HasSuffix(elfsym.Name, ".abiinternal") {
 				ver = sym.SymVerABIInternal
 				symname = strings.TrimSuffix(elfsym.Name, ".abiinternal")
@@ -2162,7 +2163,7 @@ func ldshlibsyms(ctxt *Link, shlib string) {
 		// mangle Go function names in the .so to include the
 		// ABI.
 		if elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC && ver == 0 {
-			if objabi.Experiment.RegabiWrappers {
+			if buildcfg.Experiment.RegabiWrappers {
 				if _, ok := symabi[symname]; ok {
 					continue // only use alias for functions w/o ABI wrappers
 				}
@@ -2234,7 +2235,7 @@ func (ctxt *Link) dostkcheck() {
 	// of non-splitting functions.
 	var ch chain
 	ch.limit = objabi.StackLimit - callsize(ctxt)
-	if objabi.GOARCH == "arm64" {
+	if buildcfg.GOARCH == "arm64" {
 		// need extra 8 bytes below SP to save FP
 		ch.limit -= 8
 	}
diff --git a/src/cmd/link/internal/ld/macho.go b/src/cmd/link/internal/ld/macho.go
index 4c55c5761f..98c9a32f4d 100644
--- a/src/cmd/link/internal/ld/macho.go
+++ b/src/cmd/link/internal/ld/macho.go
@@ -15,6 +15,7 @@ import (
 	"debug/macho"
 	"encoding/binary"
 	"fmt"
+	"internal/buildcfg"
 	"io"
 	"os"
 	"sort"
@@ -945,12 +946,12 @@ func collectmachosyms(ctxt *Link) {
 			if machoPlatform == PLATFORM_MACOS {
 				switch n := ldr.SymExtname(s); n {
 				case "fdopendir":
-					switch objabi.GOARCH {
+					switch buildcfg.GOARCH {
 					case "amd64":
 						ldr.SetSymExtname(s, n+"$INODE64")
 					}
 				case "readdir_r", "getfsstat":
-					switch objabi.GOARCH {
+					switch buildcfg.GOARCH {
 					case "amd64":
 						ldr.SetSymExtname(s, n+"$INODE64")
 					}
diff --git a/src/cmd/link/internal/ld/main.go b/src/cmd/link/internal/ld/main.go
index 1e3c3bdff7..7ab9ca7d10 100644
--- a/src/cmd/link/internal/ld/main.go
+++ b/src/cmd/link/internal/ld/main.go
@@ -37,6 +37,7 @@ import (
 	"cmd/internal/sys"
 	"cmd/link/internal/benchmark"
 	"flag"
+	"internal/buildcfg"
 	"log"
 	"os"
 	"runtime"
@@ -118,14 +119,14 @@ func Main(arch *sys.Arch, theArch Arch) {
 	addstrdata1(ctxt, "runtime.defaultGOROOT="+final)
 	addstrdata1(ctxt, "cmd/internal/objabi.defaultGOROOT="+final)
 
-	buildVersion := objabi.Version
-	if goexperiment := objabi.GOEXPERIMENT(); goexperiment != "" {
+	buildVersion := buildcfg.Version
+	if goexperiment := buildcfg.GOEXPERIMENT(); goexperiment != "" {
 		buildVersion += " X:" + goexperiment
 	}
 	addstrdata1(ctxt, "runtime.buildVersion="+buildVersion)
 
 	// TODO(matloob): define these above and then check flag values here
-	if ctxt.Arch.Family == sys.AMD64 && objabi.GOOS == "plan9" {
+	if ctxt.Arch.Family == sys.AMD64 && buildcfg.GOOS == "plan9" {
 		flag.BoolVar(&flag8, "8", false, "use 64-bit addresses in symbol table")
 	}
 	flagHeadType := flag.String("H", "", "set header `type`")
@@ -159,7 +160,7 @@ func Main(arch *sys.Arch, theArch Arch) {
 		}
 	}
 	if ctxt.HeadType == objabi.Hunknown {
-		ctxt.HeadType.Set(objabi.GOOS)
+		ctxt.HeadType.Set(buildcfg.GOOS)
 	}
 
 	if !*flagAslr && ctxt.BuildMode != BuildModeCShared {
@@ -255,7 +256,7 @@ func Main(arch *sys.Arch, theArch Arch) {
 
 	bench.Start("dostrdata")
 	ctxt.dostrdata()
-	if objabi.Experiment.FieldTrack {
+	if buildcfg.Experiment.FieldTrack {
 		bench.Start("fieldtrack")
 		fieldtrack(ctxt.Arch, ctxt.loader)
 	}
diff --git a/src/cmd/link/internal/ld/pcln.go b/src/cmd/link/internal/ld/pcln.go
index 61b64f4f5a..79ad9d73e9 100644
--- a/src/cmd/link/internal/ld/pcln.go
+++ b/src/cmd/link/internal/ld/pcln.go
@@ -11,6 +11,7 @@ import (
 	"cmd/link/internal/loader"
 	"cmd/link/internal/sym"
 	"fmt"
+	"internal/buildcfg"
 	"os"
 	"path/filepath"
 )
@@ -879,7 +880,7 @@ func (ctxt *Link) pclntab(container loader.Bitmap) *pclntab {
 }
 
 func gorootFinal() string {
-	root := objabi.GOROOT
+	root := buildcfg.GOROOT
 	if final := os.Getenv("GOROOT_FINAL"); final != "" {
 		root = final
 	}
diff --git a/src/cmd/link/internal/ld/pe.go b/src/cmd/link/internal/ld/pe.go
index 3ed8943828..729b6b2443 100644
--- a/src/cmd/link/internal/ld/pe.go
+++ b/src/cmd/link/internal/ld/pe.go
@@ -15,6 +15,7 @@ import (
 	"debug/pe"
 	"encoding/binary"
 	"fmt"
+	"internal/buildcfg"
 	"sort"
 	"strconv"
 	"strings"
@@ -481,9 +482,9 @@ func (f *peFile) addInitArray(ctxt *Link) *peSection {
 	// that this will need to grow in the future.
 	var size int
 	var alignment uint32
-	switch objabi.GOARCH {
+	switch buildcfg.GOARCH {
 	default:
-		Exitf("peFile.addInitArray: unsupported GOARCH=%q\n", objabi.GOARCH)
+		Exitf("peFile.addInitArray: unsupported GOARCH=%q\n", buildcfg.GOARCH)
 	case "386", "arm":
 		size = 4
 		alignment = IMAGE_SCN_ALIGN_4BYTES
@@ -499,7 +500,7 @@ func (f *peFile) addInitArray(ctxt *Link) *peSection {
 
 	init_entry := ctxt.loader.Lookup(*flagEntrySymbol, 0)
 	addr := uint64(ctxt.loader.SymValue(init_entry)) - ctxt.loader.SymSect(init_entry).Vaddr
-	switch objabi.GOARCH {
+	switch buildcfg.GOARCH {
 	case "386", "arm":
 		ctxt.Out.Write32(uint32(addr))
 	case "amd64", "arm64":
@@ -610,9 +611,9 @@ dwarfLoop:
 		dottext := ldr.Lookup(".text", 0)
 		ctxt.Out.Write32(0)
 		ctxt.Out.Write32(uint32(ldr.SymDynid(dottext)))
-		switch objabi.GOARCH {
+		switch buildcfg.GOARCH {
 		default:
-			ctxt.Errorf(dottext, "unknown architecture for PE: %q\n", objabi.GOARCH)
+			ctxt.Errorf(dottext, "unknown architecture for PE: %q\n", buildcfg.GOARCH)
 		case "386":
 			ctxt.Out.Write16(IMAGE_REL_I386_DIR32)
 		case "amd64":
diff --git a/src/cmd/link/internal/ld/sym.go b/src/cmd/link/internal/ld/sym.go
index 75489720cc..72639962e2 100644
--- a/src/cmd/link/internal/ld/sym.go
+++ b/src/cmd/link/internal/ld/sym.go
@@ -36,6 +36,7 @@ import (
 	"cmd/internal/sys"
 	"cmd/link/internal/loader"
 	"cmd/link/internal/sym"
+	"internal/buildcfg"
 	"log"
 	"runtime"
 )
@@ -53,8 +54,8 @@ func linknew(arch *sys.Arch) *Link {
 		generatorSyms: make(map[loader.Sym]generatorFunc),
 	}
 
-	if objabi.GOARCH != arch.Name {
-		log.Fatalf("invalid objabi.GOARCH %s (want %s)", objabi.GOARCH, arch.Name)
+	if buildcfg.GOARCH != arch.Name {
+		log.Fatalf("invalid buildcfg.GOARCH %s (want %s)", buildcfg.GOARCH, arch.Name)
 	}
 
 	AtExit(func() {
diff --git a/src/cmd/link/internal/ld/symtab.go b/src/cmd/link/internal/ld/symtab.go
index dcb9d7eb48..013f7b55b6 100644
--- a/src/cmd/link/internal/ld/symtab.go
+++ b/src/cmd/link/internal/ld/symtab.go
@@ -37,6 +37,7 @@ import (
 	"cmd/link/internal/sym"
 	"debug/elf"
 	"fmt"
+	"internal/buildcfg"
 	"path/filepath"
 	"strings"
 )
@@ -844,7 +845,7 @@ func mangleABIName(ldr *loader.Loader, x loader.Sym, name string) string {
 	// TODO: avoid the ldr.Lookup calls below by instead using an aux
 	// sym or marker relocation to associate the wrapper with the
 	// wrapped function.
-	if !objabi.Experiment.RegabiWrappers {
+	if !buildcfg.Experiment.RegabiWrappers {
 		return name
 	}
 
diff --git a/src/cmd/link/internal/mips/obj.go b/src/cmd/link/internal/mips/obj.go
index f20597c0f5..5ca7582529 100644
--- a/src/cmd/link/internal/mips/obj.go
+++ b/src/cmd/link/internal/mips/obj.go
@@ -34,11 +34,12 @@ import (
 	"cmd/internal/objabi"
 	"cmd/internal/sys"
 	"cmd/link/internal/ld"
+	"internal/buildcfg"
 )
 
 func Init() (*sys.Arch, ld.Arch) {
 	arch := sys.ArchMIPS
-	if objabi.GOARCH == "mipsle" {
+	if buildcfg.GOARCH == "mipsle" {
 		arch = sys.ArchMIPSLE
 	}
 
diff --git a/src/cmd/link/internal/mips64/obj.go b/src/cmd/link/internal/mips64/obj.go
index 01d89a209c..544e1ef7be 100644
--- a/src/cmd/link/internal/mips64/obj.go
+++ b/src/cmd/link/internal/mips64/obj.go
@@ -34,11 +34,12 @@ import (
 	"cmd/internal/objabi"
 	"cmd/internal/sys"
 	"cmd/link/internal/ld"
+	"internal/buildcfg"
 )
 
 func Init() (*sys.Arch, ld.Arch) {
 	arch := sys.ArchMIPS64
-	if objabi.GOARCH == "mips64le" {
+	if buildcfg.GOARCH == "mips64le" {
 		arch = sys.ArchMIPS64LE
 	}
 
diff --git a/src/cmd/link/internal/ppc64/obj.go b/src/cmd/link/internal/ppc64/obj.go
index ef4393f489..54d4606487 100644
--- a/src/cmd/link/internal/ppc64/obj.go
+++ b/src/cmd/link/internal/ppc64/obj.go
@@ -34,11 +34,12 @@ import (
 	"cmd/internal/objabi"
 	"cmd/internal/sys"
 	"cmd/link/internal/ld"
+	"internal/buildcfg"
 )
 
 func Init() (*sys.Arch, ld.Arch) {
 	arch := sys.ArchPPC64
-	if objabi.GOARCH == "ppc64le" {
+	if buildcfg.GOARCH == "ppc64le" {
 		arch = sys.ArchPPC64LE
 	}
 
diff --git a/src/cmd/link/internal/wasm/asm.go b/src/cmd/link/internal/wasm/asm.go
index 31851fbb56..5bdfdbaee6 100644
--- a/src/cmd/link/internal/wasm/asm.go
+++ b/src/cmd/link/internal/wasm/asm.go
@@ -10,6 +10,7 @@ import (
 	"cmd/link/internal/ld"
 	"cmd/link/internal/loader"
 	"cmd/link/internal/sym"
+	"internal/buildcfg"
 	"io"
 	"regexp"
 )
@@ -506,15 +507,15 @@ func writeProducerSec(ctxt *ld.Link) {
 
 	writeUleb128(ctxt.Out, 2) // number of fields
 
-	writeName(ctxt.Out, "language")     // field name
-	writeUleb128(ctxt.Out, 1)           // number of values
-	writeName(ctxt.Out, "Go")           // value: name
-	writeName(ctxt.Out, objabi.Version) // value: version
+	writeName(ctxt.Out, "language")       // field name
+	writeUleb128(ctxt.Out, 1)             // number of values
+	writeName(ctxt.Out, "Go")             // value: name
+	writeName(ctxt.Out, buildcfg.Version) // value: version
 
 	writeName(ctxt.Out, "processed-by")   // field name
 	writeUleb128(ctxt.Out, 1)             // number of values
 	writeName(ctxt.Out, "Go cmd/compile") // value: name
-	writeName(ctxt.Out, objabi.Version)   // value: version
+	writeName(ctxt.Out, buildcfg.Version) // value: version
 
 	writeSecSize(ctxt, sizeOffset)
 }
diff --git a/src/cmd/link/linkbig_test.go b/src/cmd/link/linkbig_test.go
index 917bd9e8a3..9a4430c162 100644
--- a/src/cmd/link/linkbig_test.go
+++ b/src/cmd/link/linkbig_test.go
@@ -10,8 +10,8 @@ package main
 
 import (
 	"bytes"
-	"cmd/internal/objabi"
 	"fmt"
+	"internal/buildcfg"
 	"internal/testenv"
 	"io/ioutil"
 	"os/exec"
@@ -19,8 +19,8 @@ import (
 )
 
 func TestLargeText(t *testing.T) {
-	if testing.Short() || (objabi.GOARCH != "ppc64le" && objabi.GOARCH != "ppc64" && objabi.GOARCH != "arm") {
-		t.Skipf("Skipping large text section test in short mode or on %s", objabi.GOARCH)
+	if testing.Short() || (buildcfg.GOARCH != "ppc64le" && buildcfg.GOARCH != "ppc64" && buildcfg.GOARCH != "arm") {
+		t.Skipf("Skipping large text section test in short mode or on %s", buildcfg.GOARCH)
 	}
 	testenv.MustHaveGoBuild(t)
 
@@ -42,7 +42,7 @@ func TestLargeText(t *testing.T) {
 		"ppc64le": "\tMOVD\tR0,R3\n",
 		"arm":     "\tMOVW\tR0,R1\n",
 	}
-	inst := instOnArch[objabi.GOARCH]
+	inst := instOnArch[buildcfg.GOARCH]
 	for j := 0; j < FN; j++ {
 		testname := fmt.Sprintf("bigfn%d", j)
 		fmt.Fprintf(&w, "TEXT ·%s(SB),$0\n", testname)
diff --git a/src/cmd/link/main.go b/src/cmd/link/main.go
index 6b4ca9706d..d92478e61e 100644
--- a/src/cmd/link/main.go
+++ b/src/cmd/link/main.go
@@ -5,7 +5,6 @@
 package main
 
 import (
-	"cmd/internal/objabi"
 	"cmd/internal/sys"
 	"cmd/link/internal/amd64"
 	"cmd/link/internal/arm"
@@ -19,6 +18,7 @@ import (
 	"cmd/link/internal/wasm"
 	"cmd/link/internal/x86"
 	"fmt"
+	"internal/buildcfg"
 	"os"
 )
 
@@ -40,9 +40,10 @@ func main() {
 	var arch *sys.Arch
 	var theArch ld.Arch
 
-	switch objabi.GOARCH {
+	buildcfg.Check()
+	switch buildcfg.GOARCH {
 	default:
-		fmt.Fprintf(os.Stderr, "link: unknown architecture %q\n", objabi.GOARCH)
+		fmt.Fprintf(os.Stderr, "link: unknown architecture %q\n", buildcfg.GOARCH)
 		os.Exit(2)
 	case "386":
 		arch, theArch = x86.Init()
diff --git a/src/go/build/deps_test.go b/src/go/build/deps_test.go
index a1ed834c71..1b93348edb 100644
--- a/src/go/build/deps_test.go
+++ b/src/go/build/deps_test.go
@@ -297,7 +297,10 @@ var depsRules = `
 	container/heap, go/constant, go/parser, regexp
 	< go/types;
 
-	go/build/constraint, go/doc, go/parser, internal/goroot, internal/goversion
+	FMT, internal/goexperiment
+	< internal/buildcfg;
+
+	go/build/constraint, go/doc, go/parser, internal/buildcfg, internal/goroot, internal/goversion
 	< go/build;
 
 	DEBUG, go/build, go/types, text/scanner
diff --git a/src/internal/buildcfg/cfg.go b/src/internal/buildcfg/cfg.go
new file mode 100644
index 0000000000..9fe7f211fb
--- /dev/null
+++ b/src/internal/buildcfg/cfg.go
@@ -0,0 +1,136 @@
+// Copyright 2021 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 buildcfg provides access to the build configuration
+// described by the current environment. It is for use by build tools
+// such as cmd/go or cmd/compile and for setting up go/build's Default context.
+//
+// Note that it does NOT provide access to the build configuration used to
+// build the currently-running binary. For that, use runtime.GOOS etc
+// as well as internal/goexperiment.
+package buildcfg
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+var (
+	defaultGOROOT string // set by linker
+
+	GOROOT   = envOr("GOROOT", defaultGOROOT)
+	GOARCH   = envOr("GOARCH", defaultGOARCH)
+	GOOS     = envOr("GOOS", defaultGOOS)
+	GO386    = envOr("GO386", defaultGO386)
+	GOARM    = goarm()
+	GOMIPS   = gomips()
+	GOMIPS64 = gomips64()
+	GOPPC64  = goppc64()
+	GOWASM   = gowasm()
+	GO_LDSO  = defaultGO_LDSO
+	Version  = version
+)
+
+// Error is one of the errors found (if any) in the build configuration.
+var Error error
+
+// Check exits the program with a fatal error if Error is non-nil.
+func Check() {
+	if Error != nil {
+		fmt.Fprintf(os.Stderr, "%s: %v\n", filepath.Base(os.Args[0]), Error)
+		os.Exit(2)
+	}
+}
+
+func envOr(key, value string) string {
+	if x := os.Getenv(key); x != "" {
+		return x
+	}
+	return value
+}
+
+func goarm() int {
+	def := defaultGOARM
+	if GOOS == "android" && GOARCH == "arm" {
+		// Android arm devices always support GOARM=7.
+		def = "7"
+	}
+	switch v := envOr("GOARM", def); v {
+	case "5":
+		return 5
+	case "6":
+		return 6
+	case "7":
+		return 7
+	}
+	Error = fmt.Errorf("invalid GOARM: must be 5, 6, 7")
+	return int(def[0] - '0')
+}
+
+func gomips() string {
+	switch v := envOr("GOMIPS", defaultGOMIPS); v {
+	case "hardfloat", "softfloat":
+		return v
+	}
+	Error = fmt.Errorf("invalid GOMIPS: must be hardfloat, softfloat")
+	return defaultGOMIPS
+}
+
+func gomips64() string {
+	switch v := envOr("GOMIPS64", defaultGOMIPS64); v {
+	case "hardfloat", "softfloat":
+		return v
+	}
+	Error = fmt.Errorf("invalid GOMIPS64: must be hardfloat, softfloat")
+	return defaultGOMIPS64
+}
+
+func goppc64() int {
+	switch v := envOr("GOPPC64", defaultGOPPC64); v {
+	case "power8":
+		return 8
+	case "power9":
+		return 9
+	}
+	Error = fmt.Errorf("invalid GOPPC64: must be power8, power9")
+	return int(defaultGOPPC64[len("power")] - '0')
+}
+
+type gowasmFeatures struct {
+	SignExt bool
+	SatConv bool
+}
+
+func (f gowasmFeatures) String() string {
+	var flags []string
+	if f.SatConv {
+		flags = append(flags, "satconv")
+	}
+	if f.SignExt {
+		flags = append(flags, "signext")
+	}
+	return strings.Join(flags, ",")
+}
+
+func gowasm() (f gowasmFeatures) {
+	for _, opt := range strings.Split(envOr("GOWASM", ""), ",") {
+		switch opt {
+		case "satconv":
+			f.SatConv = true
+		case "signext":
+			f.SignExt = true
+		case "":
+			// ignore
+		default:
+			Error = fmt.Errorf("invalid GOWASM: no such feature %q", opt)
+		}
+	}
+	return
+}
+
+func Getgoextlinkenabled() string {
+	return envOr("GO_EXTLINK_ENABLED", defaultGO_EXTLINK_ENABLED)
+}
diff --git a/src/cmd/internal/objabi/exp.go b/src/internal/buildcfg/exp.go
similarity index 94%
rename from src/cmd/internal/objabi/exp.go
rename to src/internal/buildcfg/exp.go
index 3371c6c8f8..dc0adb0963 100644
--- a/src/cmd/internal/objabi/exp.go
+++ b/src/internal/buildcfg/exp.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package objabi
+package buildcfg
 
 import (
 	"fmt"
@@ -23,7 +23,7 @@ var Experiment goexperiment.Flags = parseExperiments()
 // experimentBaseline specifies the experiment flags that are enabled by
 // default in the current toolchain. This is, in effect, the "control"
 // configuration and any variation from this is an experiment.
-var experimentBaseline goexperiment.Flags
+var experimentBaseline = goexperiment.Flags{}
 
 // FramePointerEnabled enables the use of platform conventions for
 // saving frame pointers.
@@ -149,3 +149,9 @@ func GOEXPERIMENT() string {
 func EnabledExperiments() []string {
 	return expList(&Experiment, nil, false)
 }
+
+// AllExperiments returns a list of all experiment settings.
+// Disabled experiments appear in the list prefixed by "no".
+func AllExperiments() []string {
+	return expList(&Experiment, nil, true)
+}
diff --git a/src/internal/goexperiment/flags.go b/src/internal/goexperiment/flags.go
index 932df10ded..e77734caa4 100644
--- a/src/internal/goexperiment/flags.go
+++ b/src/internal/goexperiment/flags.go
@@ -30,7 +30,16 @@
 // and "go version <binary>" if it differs from the default experiments.
 //
 // For the set of experiments supported by the current toolchain, see
-// go doc internal/experiment.Flags.
+// "go doc goexperiment.Flags".
+//
+// Note that this package defines the set of experiments (in Flags)
+// and records the experiments that were enabled when the package
+// was compiled (as boolean and integer constants).
+//
+// Note especially that this package does not itself change behavior
+// at run time based on the GOEXPERIMENT variable.
+// The code used in builds to interpret the GOEXPERIMENT variable
+// is in the separate package internal/buildcfg.
 package goexperiment
 
 //go:generate go run mkconsts.go
-- 
GitLab


From dba89283ad05e600defc41dbf94df91ce9027566 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 15 Apr 2021 23:07:41 -0400
Subject: [PATCH 1616/2400] cmd/go, go/build: add ToolTags to build.Default

The build.Default context really needs to accurately describe
the default build context. The goexperiment tags being a special
case in the go command violates that rule and is the root cause
of the various try-bot failures blocking the enabling of regabi.

(The cleanups I made in golang.org/x/tools were long overdue
but are not strictly necessary for making regabi work; this CL is.)

Having moved the GOEXPERIMENT parsing into internal/buildcfg,
go/build can now use it to set up build.Default, in the new field
ToolTags, meant to hold toolchain-determined tags (for now,
just the experiments). And at the same time we can remove the
duplication of GOOS and GOARCH defaults.

And then once build.Default is set up accurately, the special case
code in cmd/go itself can be removed, and the special case code
in test/run.go is at least a bit less special.

Change-Id: Ib7394e10aa018e492cb9a83fb8fb9a5011a8c25b
Reviewed-on: https://go-review.googlesource.com/c/go/+/310732
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Reviewed-by: Austin Clements <austin@google.com>
---
 src/cmd/go/alldocs.go               |  1 +
 src/cmd/go/internal/list/context.go |  2 ++
 src/cmd/go/internal/list/list.go    |  1 +
 src/cmd/go/internal/work/init.go    | 10 ---------
 src/go/build/build.go               | 34 ++++++++++++++++++++++-------
 test/run.go                         | 25 +++++----------------
 6 files changed, 35 insertions(+), 38 deletions(-)

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index 999fcf7e53..9d4626769d 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -841,6 +841,7 @@
 //         UseAllFiles   bool     // use files regardless of +build lines, file names
 //         Compiler      string   // compiler to assume when computing target paths
 //         BuildTags     []string // build constraints to match in +build lines
+//         ToolTags      []string // toolchain-specific build constraints
 //         ReleaseTags   []string // releases the current release is compatible with
 //         InstallSuffix string   // suffix to use in the name of the install dir
 //     }
diff --git a/src/cmd/go/internal/list/context.go b/src/cmd/go/internal/list/context.go
index 68d691ebe2..2dc63766b7 100644
--- a/src/cmd/go/internal/list/context.go
+++ b/src/cmd/go/internal/list/context.go
@@ -17,6 +17,7 @@ type Context struct {
 	UseAllFiles   bool     `json:",omitempty"` // use files regardless of +build lines, file names
 	Compiler      string   `json:",omitempty"` // compiler to assume when computing target paths
 	BuildTags     []string `json:",omitempty"` // build constraints to match in +build lines
+	ToolTags      []string `json:",omitempty"` // toolchain-specific build constraints
 	ReleaseTags   []string `json:",omitempty"` // releases the current release is compatible with
 	InstallSuffix string   `json:",omitempty"` // suffix to use in the name of the install dir
 }
@@ -31,6 +32,7 @@ func newContext(c *build.Context) *Context {
 		UseAllFiles:   c.UseAllFiles,
 		Compiler:      c.Compiler,
 		BuildTags:     c.BuildTags,
+		ToolTags:      c.ToolTags,
 		ReleaseTags:   c.ReleaseTags,
 		InstallSuffix: c.InstallSuffix,
 	}
diff --git a/src/cmd/go/internal/list/list.go b/src/cmd/go/internal/list/list.go
index 221370bd19..53bf75e27e 100644
--- a/src/cmd/go/internal/list/list.go
+++ b/src/cmd/go/internal/list/list.go
@@ -148,6 +148,7 @@ The template function "context" returns the build context, defined as:
         UseAllFiles   bool     // use files regardless of +build lines, file names
         Compiler      string   // compiler to assume when computing target paths
         BuildTags     []string // build constraints to match in +build lines
+        ToolTags      []string // toolchain-specific build constraints
         ReleaseTags   []string // releases the current release is compatible with
         InstallSuffix string   // suffix to use in the name of the install dir
     }
diff --git a/src/cmd/go/internal/work/init.go b/src/cmd/go/internal/work/init.go
index 66e1ca7d80..ca7e04d280 100644
--- a/src/cmd/go/internal/work/init.go
+++ b/src/cmd/go/internal/work/init.go
@@ -14,7 +14,6 @@ import (
 	"cmd/internal/sys"
 	"flag"
 	"fmt"
-	"internal/buildcfg"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -46,15 +45,6 @@ func BuildInit() {
 			base.Fatalf("go %s: %s environment variable is relative; must be absolute path: %s\n", flag.Args()[0], key, path)
 		}
 	}
-
-	// For each experiment that has been enabled in the toolchain, define a
-	// build tag with the same name but prefixed by "goexperiment." which can be
-	// used for compiling alternative files for the experiment. This allows
-	// changes for the experiment, like extra struct fields in the runtime,
-	// without affecting the base non-experiment code at all.
-	for _, expt := range buildcfg.EnabledExperiments() {
-		cfg.BuildContext.BuildTags = append(cfg.BuildContext.BuildTags, "goexperiment."+expt)
-	}
 }
 
 func instrumentInit() {
diff --git a/src/go/build/build.go b/src/go/build/build.go
index 501ce2e8dd..8d1a107c6e 100644
--- a/src/go/build/build.go
+++ b/src/go/build/build.go
@@ -12,6 +12,7 @@ import (
 	"go/build/constraint"
 	"go/doc"
 	"go/token"
+	"internal/buildcfg"
 	exec "internal/execabs"
 	"internal/goroot"
 	"internal/goversion"
@@ -48,16 +49,18 @@ type Context struct {
 	UseAllFiles bool   // use files regardless of +build lines, file names
 	Compiler    string // compiler to assume when computing target paths
 
-	// The build and release tags specify build constraints
+	// The build, tool, and release tags specify build constraints
 	// that should be considered satisfied when processing +build lines.
 	// Clients creating a new context may customize BuildTags, which
-	// defaults to empty, but it is usually an error to customize ReleaseTags,
-	// which defaults to the list of Go releases the current release is compatible with.
+	// defaults to empty, but it is usually an error to customize ToolTags or ReleaseTags.
+	// ToolTags defaults to build tags appropriate to the current Go toolchain configuration.
+	// ReleaseTags defaults to the list of Go releases the current release is compatible with.
 	// BuildTags is not set for the Default build Context.
-	// In addition to the BuildTags and ReleaseTags, build constraints
+	// In addition to the BuildTags, ToolTags, and ReleaseTags, build constraints
 	// consider the values of GOARCH and GOOS as satisfied tags.
 	// The last element in ReleaseTags is assumed to be the current release.
 	BuildTags   []string
+	ToolTags    []string
 	ReleaseTags []string
 
 	// The install suffix specifies a suffix to use in the name of the installation
@@ -292,17 +295,27 @@ func defaultGOPATH() string {
 	return ""
 }
 
-var defaultReleaseTags []string
+var defaultToolTags, defaultReleaseTags []string
 
 func defaultContext() Context {
 	var c Context
 
-	c.GOARCH = envOr("GOARCH", runtime.GOARCH)
-	c.GOOS = envOr("GOOS", runtime.GOOS)
+	c.GOARCH = buildcfg.GOARCH
+	c.GOOS = buildcfg.GOOS
 	c.GOROOT = pathpkg.Clean(runtime.GOROOT())
 	c.GOPATH = envOr("GOPATH", defaultGOPATH())
 	c.Compiler = runtime.Compiler
 
+	// For each experiment that has been enabled in the toolchain, define a
+	// build tag with the same name but prefixed by "goexperiment." which can be
+	// used for compiling alternative files for the experiment. This allows
+	// changes for the experiment, like extra struct fields in the runtime,
+	// without affecting the base non-experiment code at all.
+	for _, exp := range buildcfg.EnabledExperiments() {
+		c.ToolTags = append(c.ToolTags, "goexperiment."+exp)
+	}
+	defaultToolTags = append([]string{}, c.ToolTags...) // our own private copy
+
 	// Each major Go release in the Go 1.x series adds a new
 	// "go1.x" release tag. That is, the go1.x tag is present in
 	// all releases >= Go 1.x. Code that requires Go 1.x or later
@@ -1056,7 +1069,7 @@ func (ctxt *Context) importGo(p *Package, path, srcDir string, mode ImportMode)
 	// we must not being doing special things like AllowBinary or IgnoreVendor,
 	// and all the file system callbacks must be nil (we're meant to use the local file system).
 	if mode&AllowBinary != 0 || mode&IgnoreVendor != 0 ||
-		ctxt.JoinPath != nil || ctxt.SplitPathList != nil || ctxt.IsAbsPath != nil || ctxt.IsDir != nil || ctxt.HasSubdir != nil || ctxt.ReadDir != nil || ctxt.OpenFile != nil || !equal(ctxt.ReleaseTags, defaultReleaseTags) {
+		ctxt.JoinPath != nil || ctxt.SplitPathList != nil || ctxt.IsAbsPath != nil || ctxt.IsDir != nil || ctxt.HasSubdir != nil || ctxt.ReadDir != nil || ctxt.OpenFile != nil || !equal(ctxt.ToolTags, defaultToolTags) || !equal(ctxt.ReleaseTags, defaultReleaseTags) {
 		return errNoModules
 	}
 
@@ -1892,6 +1905,11 @@ func (ctxt *Context) matchTag(name string, allTags map[string]bool) bool {
 			return true
 		}
 	}
+	for _, tag := range ctxt.ToolTags {
+		if tag == name {
+			return true
+		}
+	}
 	for _, tag := range ctxt.ReleaseTags {
 		if tag == name {
 			return true
diff --git a/test/run.go b/test/run.go
index feec2b50be..5e60de7624 100644
--- a/test/run.go
+++ b/test/run.go
@@ -12,6 +12,7 @@ import (
 	"errors"
 	"flag"
 	"fmt"
+	"go/build"
 	"hash/fnv"
 	"io"
 	"io/fs"
@@ -376,7 +377,6 @@ type context struct {
 	GOARCH     string
 	cgoEnabled bool
 	noOptEnv   bool
-	expTags    map[string]bool // Set lazily
 }
 
 // shouldTest looks for build tags in a source file and returns
@@ -447,27 +447,12 @@ func (ctxt *context) match(name string) bool {
 	}
 
 	if strings.HasPrefix(name, "goexperiment.") {
-		// Query goexperiment tags from the toolchain.
-		if ctxt.expTags == nil {
-			ctxt.expTags = make(map[string]bool)
-			cmd := exec.Command(goTool(), "tool", "compile", "-V=goexperiment")
-			out, err := cmd.CombinedOutput()
-			if err != nil {
-				log.Fatalf("failed to get GOEXPERIMENT configuration:\n%s", out)
-			}
-			i := bytes.Index(out, []byte("X:"))
-			if i != -1 {
-				for _, exp := range strings.Split(string(out[i+2:]), ",") {
-					v := true
-					if strings.HasPrefix(exp, "no") {
-						v, exp = false, exp[2:]
-					}
-					ctxt.expTags["goexperiment."+exp] = v
-				}
+		for _, tag := range build.Default.ToolTags {
+			if tag == name {
+				return true
 			}
 		}
-
-		return ctxt.expTags[name]
+		return false
 	}
 
 	if name == "cgo" && ctxt.cgoEnabled {
-- 
GitLab


From ef57834360cf69f2e8b52b32c7a05d96bf6bbba7 Mon Sep 17 00:00:00 2001
From: Johan Brandhorst <johan.brandhorst@gmail.com>
Date: Sun, 28 Mar 2021 16:39:47 +0100
Subject: [PATCH 1617/2400] crypto/tls: fix flaky handshake cancellation tests

Simplified both tests significantly by removing logic for writing
the client/server side messages. The flake was likely because of a
race between the closing of the local pipe from inside the test
and closing of the pipe from within the handshakeContext goroutine.
Wait to close the local pipe in the test until after the test
has finished running.

Fixes #45106
Fixes #45299

Change-Id: If7ca75aeff7df70cda03c934fa9d8513276d465d
Reviewed-on: https://go-review.googlesource.com/c/go/+/305250
Trust: Johan Brandhorst-Satzkorn <johan.brandhorst@gmail.com>
Trust: Katie Hockman <katie@golang.org>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
---
 src/crypto/tls/handshake_client_test.go | 34 +++++++++++++++++++++++++
 src/crypto/tls/handshake_server_test.go | 26 +++++++------------
 2 files changed, 43 insertions(+), 17 deletions(-)

diff --git a/src/crypto/tls/handshake_client_test.go b/src/crypto/tls/handshake_client_test.go
index 693f9686a7..f499cf3970 100644
--- a/src/crypto/tls/handshake_client_test.go
+++ b/src/crypto/tls/handshake_client_test.go
@@ -6,6 +6,7 @@ package tls
 
 import (
 	"bytes"
+	"context"
 	"crypto/rsa"
 	"crypto/x509"
 	"encoding/base64"
@@ -20,6 +21,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"reflect"
+	"runtime"
 	"strconv"
 	"strings"
 	"testing"
@@ -2511,3 +2513,35 @@ func testResumptionKeepsOCSPAndSCT(t *testing.T, ver uint16) {
 			serverConfig.Certificates[0].SignedCertificateTimestamps, ccs.SignedCertificateTimestamps)
 	}
 }
+
+// TestClientHandshakeContextCancellation tests that cancelling
+// the context given to the client side conn.HandshakeContext
+// interrupts the in-progress handshake.
+func TestClientHandshakeContextCancellation(t *testing.T) {
+	c, s := localPipe(t)
+	ctx, cancel := context.WithCancel(context.Background())
+	unblockServer := make(chan struct{})
+	defer close(unblockServer)
+	go func() {
+		cancel()
+		<-unblockServer
+		_ = s.Close()
+	}()
+	cli := Client(c, testConfig)
+	// Initiates client side handshake, which will block until the client hello is read
+	// by the server, unless the cancellation works.
+	err := cli.HandshakeContext(ctx)
+	if err == nil {
+		t.Fatal("Client handshake did not error when the context was canceled")
+	}
+	if err != context.Canceled {
+		t.Errorf("Unexpected client handshake error: %v", err)
+	}
+	if runtime.GOARCH == "wasm" {
+		t.Skip("conn.Close does not error as expected when called multiple times on WASM")
+	}
+	err = cli.Close()
+	if err == nil {
+		t.Error("Client connection was not closed when the context was canceled")
+	}
+}
diff --git a/src/crypto/tls/handshake_server_test.go b/src/crypto/tls/handshake_server_test.go
index 756d288cb3..4c2d319fb1 100644
--- a/src/crypto/tls/handshake_server_test.go
+++ b/src/crypto/tls/handshake_server_test.go
@@ -1946,27 +1946,22 @@ func TestAESCipherReordering13(t *testing.T) {
 	}
 }
 
+// TestServerHandshakeContextCancellation tests that cancelling
+// the context given to the server side conn.HandshakeContext
+// interrupts the in-progress handshake.
 func TestServerHandshakeContextCancellation(t *testing.T) {
 	c, s := localPipe(t)
-	clientConfig := testConfig.Clone()
-	clientErr := make(chan error, 1)
 	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	unblockClient := make(chan struct{})
+	defer close(unblockClient)
 	go func() {
-		defer close(clientErr)
-		defer c.Close()
-		clientHello := &clientHelloMsg{
-			vers:               VersionTLS10,
-			random:             make([]byte, 32),
-			cipherSuites:       []uint16{TLS_RSA_WITH_RC4_128_SHA},
-			compressionMethods: []uint8{compressionNone},
-		}
-		cli := Client(c, clientConfig)
-		_, err := cli.writeRecord(recordTypeHandshake, clientHello.marshal())
 		cancel()
-		clientErr <- err
+		<-unblockClient
+		_ = c.Close()
 	}()
 	conn := Server(s, testConfig)
+	// Initiates server side handshake, which will block until a client hello is read
+	// unless the cancellation works.
 	err := conn.HandshakeContext(ctx)
 	if err == nil {
 		t.Fatal("Server handshake did not error when the context was canceled")
@@ -1974,9 +1969,6 @@ func TestServerHandshakeContextCancellation(t *testing.T) {
 	if err != context.Canceled {
 		t.Errorf("Unexpected server handshake error: %v", err)
 	}
-	if err := <-clientErr; err != nil {
-		t.Errorf("Unexpected client error: %v", err)
-	}
 	if runtime.GOARCH == "wasm" {
 		t.Skip("conn.Close does not error as expected when called multiple times on WASM")
 	}
-- 
GitLab


From fff236e659fa819e036ab849130931dd6245c7b2 Mon Sep 17 00:00:00 2001
From: Hilko Bengen <bengen@hilluzination.de>
Date: Sun, 6 Dec 2020 21:33:59 +0000
Subject: [PATCH 1618/2400] net/http/fcgi: eliminate race, keep request id
 until end of stdin

There was a race condition that could lead to child.serveRequest
removing the request ID before child.handleRequest had read the empty
FCGI_STDIN message that indicates end-of-stream which in turn could
lead to child.serveRequest blocking while trying to consume the
request body.

Now, we remove the request ID from within child.handleRequest after
the end of stdin has been detected, eliminating the race condition.

Since there are no more concurrent modifications/accesses
to child.requests, we remove the accompanying sync.Mutex.

Change-Id: I80c68e65904a988dfa9e3cceec1829496628ff34
GitHub-Last-Rev: b3976111ae1d3bbbfa36045f99acce7911a18c44
GitHub-Pull-Request: golang/go#42840
Reviewed-on: https://go-review.googlesource.com/c/go/+/273366
Trust: Damien Neil <dneil@google.com>
Trust: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Damien Neil <dneil@google.com>
---
 src/net/http/fcgi/child.go     | 20 ++++---------
 src/net/http/fcgi/fcgi_test.go | 53 ++++++++++++++++++++++++++++++++++
 2 files changed, 58 insertions(+), 15 deletions(-)

diff --git a/src/net/http/fcgi/child.go b/src/net/http/fcgi/child.go
index 756722ba14..dc82bf7c3a 100644
--- a/src/net/http/fcgi/child.go
+++ b/src/net/http/fcgi/child.go
@@ -16,7 +16,6 @@ import (
 	"net/http/cgi"
 	"os"
 	"strings"
-	"sync"
 	"time"
 )
 
@@ -154,7 +153,6 @@ type child struct {
 	conn    *conn
 	handler http.Handler
 
-	mu       sync.Mutex          // protects requests:
 	requests map[uint16]*request // keyed by request ID
 }
 
@@ -193,9 +191,7 @@ var ErrRequestAborted = errors.New("fcgi: request aborted by web server")
 var ErrConnClosed = errors.New("fcgi: connection to web server closed")
 
 func (c *child) handleRecord(rec *record) error {
-	c.mu.Lock()
 	req, ok := c.requests[rec.h.Id]
-	c.mu.Unlock()
 	if !ok && rec.h.Type != typeBeginRequest && rec.h.Type != typeGetValues {
 		// The spec says to ignore unknown request IDs.
 		return nil
@@ -218,9 +214,7 @@ func (c *child) handleRecord(rec *record) error {
 			return nil
 		}
 		req = newRequest(rec.h.Id, br.flags)
-		c.mu.Lock()
 		c.requests[rec.h.Id] = req
-		c.mu.Unlock()
 		return nil
 	case typeParams:
 		// NOTE(eds): Technically a key-value pair can straddle the boundary
@@ -248,8 +242,11 @@ func (c *child) handleRecord(rec *record) error {
 			// TODO(eds): This blocks until the handler reads from the pipe.
 			// If the handler takes a long time, it might be a problem.
 			req.pw.Write(content)
-		} else if req.pw != nil {
-			req.pw.Close()
+		} else {
+			delete(c.requests, req.reqId)
+			if req.pw != nil {
+				req.pw.Close()
+			}
 		}
 		return nil
 	case typeGetValues:
@@ -260,9 +257,7 @@ func (c *child) handleRecord(rec *record) error {
 		// If the filter role is implemented, read the data stream here.
 		return nil
 	case typeAbortRequest:
-		c.mu.Lock()
 		delete(c.requests, rec.h.Id)
-		c.mu.Unlock()
 		c.conn.writeEndRequest(rec.h.Id, 0, statusRequestComplete)
 		if req.pw != nil {
 			req.pw.CloseWithError(ErrRequestAborted)
@@ -309,9 +304,6 @@ func (c *child) serveRequest(req *request, body io.ReadCloser) {
 	// Make sure we serve something even if nothing was written to r
 	r.Write(nil)
 	r.Close()
-	c.mu.Lock()
-	delete(c.requests, req.reqId)
-	c.mu.Unlock()
 	c.conn.writeEndRequest(req.reqId, 0, statusRequestComplete)
 
 	// Consume the entire body, so the host isn't still writing to
@@ -330,8 +322,6 @@ func (c *child) serveRequest(req *request, body io.ReadCloser) {
 }
 
 func (c *child) cleanUp() {
-	c.mu.Lock()
-	defer c.mu.Unlock()
 	for _, req := range c.requests {
 		if req.pw != nil {
 			// race with call to Close in c.serveRequest doesn't matter because
diff --git a/src/net/http/fcgi/fcgi_test.go b/src/net/http/fcgi/fcgi_test.go
index b58111de20..5888783620 100644
--- a/src/net/http/fcgi/fcgi_test.go
+++ b/src/net/http/fcgi/fcgi_test.go
@@ -11,6 +11,7 @@ import (
 	"net/http"
 	"strings"
 	"testing"
+	"time"
 )
 
 var sizeTests = []struct {
@@ -399,3 +400,55 @@ func TestResponseWriterSniffsContentType(t *testing.T) {
 		})
 	}
 }
+
+type signallingNopCloser struct {
+	io.Reader
+	closed chan bool
+}
+
+func (*signallingNopCloser) Write(buf []byte) (int, error) {
+	return len(buf), nil
+}
+
+func (rc *signallingNopCloser) Close() error {
+	close(rc.closed)
+	return nil
+}
+
+// Test whether server properly closes connection when processing slow
+// requests
+func TestSlowRequest(t *testing.T) {
+	pr, pw := io.Pipe()
+	go func(w io.Writer) {
+		for _, buf := range [][]byte{
+			streamBeginTypeStdin,
+			makeRecord(typeStdin, 1, nil),
+		} {
+			pw.Write(buf)
+			time.Sleep(100 * time.Millisecond)
+		}
+	}(pw)
+
+	rc := &signallingNopCloser{pr, make(chan bool)}
+	handlerDone := make(chan bool)
+
+	c := newChild(rc, http.HandlerFunc(func(
+		w http.ResponseWriter,
+		r *http.Request,
+	) {
+		w.WriteHeader(200)
+		close(handlerDone)
+	}))
+	go c.serve()
+	defer c.cleanUp()
+
+	timeout := time.After(2 * time.Second)
+
+	<-handlerDone
+	select {
+	case <-rc.closed:
+		t.Log("FastCGI child closed connection")
+	case <-timeout:
+		t.Error("FastCGI child did not close socket after handling request")
+	}
+}
-- 
GitLab


From b6e1c336037e53ae095e84cfed4a312d8fd3ad45 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Fri, 16 Apr 2021 00:15:31 -0400
Subject: [PATCH 1619/2400] cmd/compile: spill all the parameters around
 morestack

former code only spilled those parameters mentioned in code
AT THE REGISTER LEVEL, this caused problems with liveness
sometimes (which worked on whole variables including
aggregates).

Updates #40724.

Change-Id: Ib9fdc50d95d1d2b1f1e405dd370540e88582ac71
Reviewed-on: https://go-review.googlesource.com/c/go/+/310690
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/amd64/ssa.go      |  4 ++--
 src/cmd/compile/internal/ssa/func.go       |  2 +-
 src/cmd/compile/internal/ssa/location.go   | 28 ++++------------------
 src/cmd/compile/internal/ssa/stackalloc.go |  9 -------
 src/cmd/compile/internal/ssagen/ssa.go     | 24 ++++++++++++++-----
 5 files changed, 25 insertions(+), 42 deletions(-)

diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index 42c12953f9..38d2d43e27 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -989,9 +989,9 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		// The loop only runs once.
 		for _, ap := range v.Block.Func.RegArgs {
 			// Pass the spill/unspill information along to the assembler, offset by size of return PC pushed on stack.
-			addr := ssagen.SpillSlotAddr(ap.Mem(), x86.REG_SP, v.Block.Func.Config.PtrSize)
+			addr := ssagen.SpillSlotAddr(ap, x86.REG_SP, v.Block.Func.Config.PtrSize)
 			s.FuncInfo().AddSpill(
-				obj.RegSpill{Reg: ap.Reg(), Addr: addr, Unspill: loadByType(ap.Type()), Spill: storeByType(ap.Type())})
+				obj.RegSpill{Reg: ap.Reg, Addr: addr, Unspill: loadByType(ap.Type), Spill: storeByType(ap.Type)})
 		}
 		v.Block.Func.RegArgs = nil
 		ssagen.CheckArgReg(v)
diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go
index 819d7573d6..378a73a95a 100644
--- a/src/cmd/compile/internal/ssa/func.go
+++ b/src/cmd/compile/internal/ssa/func.go
@@ -64,7 +64,7 @@ type Func struct {
 	Names []LocalSlot
 
 	// RegArgs is a slice of register-memory pairs that must be spilled and unspilled in the uncommon path of function entry.
-	RegArgs []ArgPair
+	RegArgs []Spill
 	// AuxCall describing parameters and results for this function.
 	OwnAux *AuxCall
 
diff --git a/src/cmd/compile/internal/ssa/location.go b/src/cmd/compile/internal/ssa/location.go
index af0a913d17..252c47cdeb 100644
--- a/src/cmd/compile/internal/ssa/location.go
+++ b/src/cmd/compile/internal/ssa/location.go
@@ -102,28 +102,8 @@ func (t LocResults) String() string {
 	return a
 }
 
-type ArgPair struct {
-	reg *Register
-	mem LocalSlot
-}
-
-func (ap *ArgPair) Reg() int16 {
-	return ap.reg.objNum
-}
-
-func (ap *ArgPair) Type() *types.Type {
-	return ap.mem.Type
-}
-
-func (ap *ArgPair) Mem() *LocalSlot {
-	return &ap.mem
-}
-
-func (t ArgPair) String() string {
-	n0 := "nil"
-	if t.reg != nil {
-		n0 = t.reg.String()
-	}
-	n1 := t.mem.String()
-	return fmt.Sprintf("<%s,%s>", n0, n1)
+type Spill struct {
+	Type   *types.Type
+	Offset int64
+	Reg    int16
 }
diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go
index 45058d4e72..8fe18e5f02 100644
--- a/src/cmd/compile/internal/ssa/stackalloc.go
+++ b/src/cmd/compile/internal/ssa/stackalloc.go
@@ -165,15 +165,6 @@ func (s *stackAllocState) stackalloc() {
 			f.setHome(v, loc)
 			continue
 		}
-
-		nameOff := v.Aux.(*AuxNameOffset)
-		loc := LocalSlot{N: nameOff.Name, Type: v.Type, Off: nameOff.Offset}
-		if f.pass.debug > stackDebug {
-			fmt.Printf("stackalloc Op%s %s to %s\n", v.Op, v, loc)
-		}
-		// register args already allocated to registers, but need to know the stack allocation for later
-		reg := f.getHome(v.ID).(*Register)
-		f.RegArgs = append(f.RegArgs, ArgPair{reg: reg, mem: loc})
 	}
 
 	// For each type, we keep track of all the stack slots we
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index f0bce0756a..e7d4865375 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -641,6 +641,22 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 		s.emitOpenDeferInfo()
 	}
 
+	// Record incoming parameter spill information for morestack calls emitted in the assembler.
+	// This is done here, using all the parameters (used, partially used, and unused) because
+	// it mimics the behavior of the former ABI (everything stored) and because it's not 100%
+	// clear if naming conventions are respected in autogenerated code.
+	// TODO figure out exactly what's unused, don't spill it. Make liveness fine-grained, also.
+	// TODO non-amd64 architectures have link registers etc that may require adjustment here.
+	for _, p := range params.InParams() {
+		typs, offs := p.RegisterTypesAndOffsets()
+		for i, t := range typs {
+			o := offs[i]                // offset within parameter
+			fo := p.FrameOffset(params) // offset of parameter in frame
+			reg := ssa.ObjRegForAbiReg(p.Registers[i], s.f.Config)
+			s.f.RegArgs = append(s.f.RegArgs, ssa.Spill{Reg: reg, Offset: fo + o, Type: t})
+		}
+	}
+
 	return s.f
 }
 
@@ -7578,16 +7594,12 @@ func deferstruct(stksize int64) *types.Type {
 // The resulting addr is used in a non-standard context -- in the prologue
 // of a function, before the frame has been constructed, so the standard
 // addressing for the parameters will be wrong.
-func SpillSlotAddr(slot *ssa.LocalSlot, baseReg int16, extraOffset int64) obj.Addr {
-	n, off := slot.N, slot.Off
-	if n.Class != ir.PPARAM && n.Class != ir.PPARAMOUT {
-		panic("Only expected to see param and returns here")
-	}
+func SpillSlotAddr(spill ssa.Spill, baseReg int16, extraOffset int64) obj.Addr {
 	return obj.Addr{
 		Name:   obj.NAME_NONE,
 		Type:   obj.TYPE_MEM,
 		Reg:    baseReg,
-		Offset: off + extraOffset + n.FrameOffset(),
+		Offset: spill.Offset + extraOffset,
 	}
 }
 
-- 
GitLab


From 4fb74e055595a0009f11272432c2a5047a64507b Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 15 Apr 2021 11:19:30 -0400
Subject: [PATCH 1620/2400] reflect: preserve ctxt across moveMakeFuncArgPtrs

In makeFuncStub and methodValueCall, it stores ctxt (DX) as an
argument of moveMakeFuncArgPtrs, and assumes it does not change
by the call. This is not guaranteed, and it does happen if
-clobberdead compiler flag is used. Store it somewhere else and
reload after the call.

Change-Id: I9307e3cf94db4b38305ab35494088386dfcbaae8
Reviewed-on: https://go-review.googlesource.com/c/go/+/310409
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/reflect/asm_amd64.s | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/reflect/asm_amd64.s b/src/reflect/asm_amd64.s
index 22d95f2a7e..facf07516d 100644
--- a/src/reflect/asm_amd64.s
+++ b/src/reflect/asm_amd64.s
@@ -33,9 +33,12 @@ TEXT ·makeFuncStub<ABIInternal>(SB),(NOSPLIT|WRAPPER),$312
 	// frame is specially handled in the runtime. See the comment above LOCAL_RETVALID.
 	LEAQ	LOCAL_REGARGS(SP), R12
 	CALL	runtime·spillArgs<ABIInternal>(SB)
+	MOVQ	DX, 24(SP) // outside of moveMakeFuncArgPtrs's arg area
 	MOVQ	DX, 0(SP)
 	MOVQ	R12, 8(SP)
 	CALL	·moveMakeFuncArgPtrs(SB)
+	MOVQ	24(SP), DX
+	MOVQ	DX, 0(SP)
 	LEAQ	argframe+0(FP), CX
 	MOVQ	CX, 8(SP)
 	MOVB	$0, LOCAL_RETVALID(SP)
@@ -61,9 +64,12 @@ TEXT ·methodValueCall<ABIInternal>(SB),(NOSPLIT|WRAPPER),$312
 	// frame is specially handled in the runtime. See the comment above LOCAL_RETVALID.
 	LEAQ	LOCAL_REGARGS(SP), R12
 	CALL	runtime·spillArgs<ABIInternal>(SB)
+	MOVQ	DX, 24(SP) // outside of moveMakeFuncArgPtrs's arg area
 	MOVQ	DX, 0(SP)
 	MOVQ	R12, 8(SP)
 	CALL	·moveMakeFuncArgPtrs(SB)
+	MOVQ	24(SP), DX
+	MOVQ	DX, 0(SP)
 	LEAQ	argframe+0(FP), CX
 	MOVQ	CX, 8(SP)
 	MOVB	$0, LOCAL_RETVALID(SP)
-- 
GitLab


From 9fbcba6664840ada5aaedb7f1a587d0cca1c9035 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Wed, 14 Apr 2021 23:36:14 -0400
Subject: [PATCH 1621/2400] cmd/compile: in clobberdead mode, don't clobber
 slots that are live for defers

There are stack slots that are kept live for defers, which are
tracked separately. Don't clobber them.

Change-Id: Ib558345758b5a4fd89c7ff8a3fe08087059add21
Reviewed-on: https://go-review.googlesource.com/c/go/+/310329
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/liveness/plive.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/liveness/plive.go b/src/cmd/compile/internal/liveness/plive.go
index 53feb6cc32..9eca05b040 100644
--- a/src/cmd/compile/internal/liveness/plive.go
+++ b/src/cmd/compile/internal/liveness/plive.go
@@ -995,9 +995,11 @@ func (lv *liveness) clobber(b *ssa.Block) {
 // of b.Values.
 func clobber(lv *liveness, b *ssa.Block, live bitvec.BitVec) {
 	for i, n := range lv.vars {
-		if !live.Get(int32(i)) && !n.Addrtaken() {
+		if !live.Get(int32(i)) && !n.Addrtaken() && !n.OpenDeferSlot() && !n.IsOutputParamHeapAddr() {
 			// Don't clobber stack objects (address-taken). They are
 			// tracked dynamically.
+			// Also don't clobber slots that are live for defers (see
+			// the code setting livedefer in epilogue).
 			clobberVar(b, n)
 		}
 	}
-- 
GitLab


From f6e7fe2711849e2e57f79b89ee7928b8806618c8 Mon Sep 17 00:00:00 2001
From: Michael Pratt <mpratt@google.com>
Date: Wed, 7 Apr 2021 10:15:33 -0400
Subject: [PATCH 1622/2400] runtime: move findrunnable timer delay computation
 closer to use

findrunnable has a couple places where delta is recomputed from a new
pollUntil value. This proves to be a pain in refactoring, as it is easy
to forget to do properly.

Move computation of delta closer to its use, where it is more logical
anyways.

This CL should have no functional changes.

For #43997.
For #44313.

Change-Id: I89980fd7f40f8a4c56c7540cae03ff99e12e1422
Reviewed-on: https://go-review.googlesource.com/c/go/+/307910
Trust: Michael Pratt <mpratt@google.com>
Run-TryBot: Michael Pratt <mpratt@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/lock_futex.go |  2 +-
 src/runtime/lock_js.go    |  7 ++++++-
 src/runtime/lock_sema.go  |  2 +-
 src/runtime/proc.go       | 31 +++++++++++++------------------
 4 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/src/runtime/lock_futex.go b/src/runtime/lock_futex.go
index 017b481c64..e4c8d01941 100644
--- a/src/runtime/lock_futex.go
+++ b/src/runtime/lock_futex.go
@@ -239,7 +239,7 @@ func notetsleepg(n *note, ns int64) bool {
 	return ok
 }
 
-func beforeIdle(int64) (*g, bool) {
+func beforeIdle(int64, int64) (*g, bool) {
 	return nil, false
 }
 
diff --git a/src/runtime/lock_js.go b/src/runtime/lock_js.go
index 04e7e85c12..0ca3512baf 100644
--- a/src/runtime/lock_js.go
+++ b/src/runtime/lock_js.go
@@ -176,7 +176,12 @@ var idleID int32
 // If an event handler returned, we resume it and it will pause the execution.
 // beforeIdle either returns the specific goroutine to schedule next or
 // indicates with otherReady that some goroutine became ready.
-func beforeIdle(delay int64) (gp *g, otherReady bool) {
+func beforeIdle(now, pollUntil int64) (gp *g, otherReady bool) {
+	delay := int64(-1)
+	if pollUntil != 0 {
+		delay = pollUntil - now
+	}
+
 	if delay > 0 {
 		clearIdleID()
 		if delay < 1e6 {
diff --git a/src/runtime/lock_sema.go b/src/runtime/lock_sema.go
index 3c0a7ca67e..7a6af28b56 100644
--- a/src/runtime/lock_sema.go
+++ b/src/runtime/lock_sema.go
@@ -298,7 +298,7 @@ func notetsleepg(n *note, ns int64) bool {
 	return ok
 }
 
-func beforeIdle(int64) (*g, bool) {
+func beforeIdle(int64, int64) (*g, bool) {
 	return nil, false
 }
 
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 6c1c5dd917..3ee5805aef 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -2742,17 +2742,11 @@ stop:
 		}
 	}
 
-	delta := int64(-1)
-	if pollUntil != 0 {
-		// checkTimers ensures that polluntil > now.
-		delta = pollUntil - now
-	}
-
 	// wasm only:
 	// If a callback returned and no other goroutine is awake,
 	// then wake event handler goroutine which pauses execution
 	// until a callback was triggered.
-	gp, otherReady := beforeIdle(delta)
+	gp, otherReady := beforeIdle(now, pollUntil)
 	if gp != nil {
 		casgstatus(gp, _Gwaiting, _Grunnable)
 		if trace.enabled {
@@ -2842,15 +2836,6 @@ stop:
 			}
 		}
 	}
-	if pollUntil != 0 {
-		if now == 0 {
-			now = nanotime()
-		}
-		delta = pollUntil - now
-		if delta < 0 {
-			delta = 0
-		}
-	}
 
 	// Check for idle-priority GC work again.
 	//
@@ -2909,11 +2894,21 @@ stop:
 		if _g_.m.spinning {
 			throw("findrunnable: netpoll with spinning")
 		}
+		delay := int64(-1)
+		if pollUntil != 0 {
+			if now == 0 {
+				now = nanotime()
+			}
+			delay = pollUntil - now
+			if delay < 0 {
+				delay = 0
+			}
+		}
 		if faketime != 0 {
 			// When using fake time, just poll.
-			delta = 0
+			delay = 0
 		}
-		list := netpoll(delta) // block until new work is available
+		list := netpoll(delay) // block until new work is available
 		atomic.Store64(&sched.pollUntil, 0)
 		atomic.Store64(&sched.lastpoll, uint64(nanotime()))
 		if faketime != 0 && list.empty() {
-- 
GitLab


From 800fb11efb8a57d8aaf11052e3a9d91138964f21 Mon Sep 17 00:00:00 2001
From: Michael Pratt <mpratt@google.com>
Date: Tue, 16 Feb 2021 16:47:34 -0500
Subject: [PATCH 1623/2400] runtime: remove redudant tryWakeP component

Here tryWakeP can't already be true, so there is no need to combine the
values.

This CL should have no functional changes.

For #43997.
For #44313.

Change-Id: I640c7bb88a5f70c8d22f89f0b5b146b3f60c0136
Reviewed-on: https://go-review.googlesource.com/c/go/+/307911
Trust: Michael Pratt <mpratt@google.com>
Run-TryBot: Michael Pratt <mpratt@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/proc.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 3ee5805aef..f479967d41 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -3136,7 +3136,9 @@ top:
 	}
 	if gp == nil && gcBlackenEnabled != 0 {
 		gp = gcController.findRunnableGCWorker(_g_.m.p.ptr())
-		tryWakeP = tryWakeP || gp != nil
+		if gp != nil {
+			tryWakeP = true
+		}
 	}
 	if gp == nil {
 		// Check the global runnable queue once in a while to ensure fairness.
-- 
GitLab


From 13368ab56a75134910e70db4bc0e2860e6a97829 Mon Sep 17 00:00:00 2001
From: Michael Pratt <mpratt@google.com>
Date: Tue, 16 Feb 2021 10:52:38 -0500
Subject: [PATCH 1624/2400] runtime: clarify which work needs spinning
 coordination

The overview comments discuss readying goroutines, which is the most
common source of work, but timers and idle-priority GC work also require
the same synchronization w.r.t. spinning Ms.

This CL should have no functional changes.

For #43997
Updates #44313

Change-Id: I7910a7f93764dde07c3ed63666277eb832bf8299
Reviewed-on: https://go-review.googlesource.com/c/go/+/307912
Trust: Michael Pratt <mpratt@google.com>
Run-TryBot: Michael Pratt <mpratt@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/proc.go | 106 ++++++++++++++++++++++++++++++--------------
 1 file changed, 72 insertions(+), 34 deletions(-)

diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index f479967d41..2c06b28955 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -50,33 +50,64 @@ var modinfo string
 //    any work to do.
 //
 // The current approach:
-// We unpark an additional thread when we ready a goroutine if (1) there is an
-// idle P and there are no "spinning" worker threads. A worker thread is considered
-// spinning if it is out of local work and did not find work in global run queue/
-// netpoller; the spinning state is denoted in m.spinning and in sched.nmspinning.
-// Threads unparked this way are also considered spinning; we don't do goroutine
-// handoff so such threads are out of work initially. Spinning threads do some
-// spinning looking for work in per-P run queues before parking. If a spinning
+//
+// This approach applies to three primary sources of potential work: readying a
+// goroutine, new/modified-earlier timers, and idle-priority GC. See below for
+// additional details.
+//
+// We unpark an additional thread when we submit work if (this is wakep()):
+// 1. There is an idle P, and
+// 2. There are no "spinning" worker threads.
+//
+// A worker thread is considered spinning if it is out of local work and did
+// not find work in the global run queue or netpoller; the spinning state is
+// denoted in m.spinning and in sched.nmspinning. Threads unparked this way are
+// also considered spinning; we don't do goroutine handoff so such threads are
+// out of work initially. Spinning threads spin on looking for work in per-P
+// run queues and timer heaps or from the GC before parking. If a spinning
 // thread finds work it takes itself out of the spinning state and proceeds to
-// execution. If it does not find work it takes itself out of the spinning state
-// and then parks.
-// If there is at least one spinning thread (sched.nmspinning>1), we don't unpark
-// new threads when readying goroutines. To compensate for that, if the last spinning
-// thread finds work and stops spinning, it must unpark a new spinning thread.
-// This approach smooths out unjustified spikes of thread unparking,
-// but at the same time guarantees eventual maximal CPU parallelism utilization.
+// execution. If it does not find work it takes itself out of the spinning
+// state and then parks.
+//
+// If there is at least one spinning thread (sched.nmspinning>1), we don't
+// unpark new threads when submitting work. To compensate for that, if the last
+// spinning thread finds work and stops spinning, it must unpark a new spinning
+// thread.  This approach smooths out unjustified spikes of thread unparking,
+// but at the same time guarantees eventual maximal CPU parallelism
+// utilization.
+//
+// The main implementation complication is that we need to be very careful
+// during spinning->non-spinning thread transition. This transition can race
+// with submission of new work, and either one part or another needs to unpark
+// another worker thread. If they both fail to do that, we can end up with
+// semi-persistent CPU underutilization.
+//
+// The general pattern for submission is:
+// 1. Submit work to the local run queue, timer heap, or GC state.
+// 2. #StoreLoad-style memory barrier.
+// 3. Check sched.nmspinning.
 //
-// The main implementation complication is that we need to be very careful during
-// spinning->non-spinning thread transition. This transition can race with submission
-// of a new goroutine, and either one part or another needs to unpark another worker
-// thread. If they both fail to do that, we can end up with semi-persistent CPU
-// underutilization. The general pattern for goroutine readying is: submit a goroutine
-// to local work queue, #StoreLoad-style memory barrier, check sched.nmspinning.
-// The general pattern for spinning->non-spinning transition is: decrement nmspinning,
-// #StoreLoad-style memory barrier, check all per-P work queues for new work.
-// Note that all this complexity does not apply to global run queue as we are not
-// sloppy about thread unparking when submitting to global queue. Also see comments
-// for nmspinning manipulation.
+// The general pattern for spinning->non-spinning transition is:
+// 1. Decrement nmspinning.
+// 2. #StoreLoad-style memory barrier.
+// 3. Check all per-P work queues and GC for new work.
+//
+// Note that all this complexity does not apply to global run queue as we are
+// not sloppy about thread unparking when submitting to global queue. Also see
+// comments for nmspinning manipulation.
+//
+// How these different sources of work behave varies, though it doesn't affect
+// the synchronization approach:
+// * Ready goroutine: this is an obvious source of work; the goroutine is
+//   immediately ready and must run on some thread eventually.
+// * New/modified-earlier timer: The current timer implementation (see time.go)
+//   uses netpoll in a thread with no work available to wait for the soonest
+//   timer. If there is no thread waiting, we want a new spinning thread to go
+//   wait.
+// * Idle-priority GC: The GC wakes a stopped idle thread to contribute to
+//   background GC work (note: currently disabled per golang.org/issue/19112).
+//   Also see golang.org/issue/44313, as this should be extended to all GC
+//   workers.
 
 var (
 	m0           m
@@ -2785,18 +2816,25 @@ stop:
 	pidleput(_p_)
 	unlock(&sched.lock)
 
-	// Delicate dance: thread transitions from spinning to non-spinning state,
-	// potentially concurrently with submission of new goroutines. We must
-	// drop nmspinning first and then check all per-P queues again (with
-	// #StoreLoad memory barrier in between). If we do it the other way around,
-	// another thread can submit a goroutine after we've checked all run queues
-	// but before we drop nmspinning; as a result nobody will unpark a thread
-	// to run the goroutine.
+	// Delicate dance: thread transitions from spinning to non-spinning
+	// state, potentially concurrently with submission of new work. We must
+	// drop nmspinning first and then check all sources again (with
+	// #StoreLoad memory barrier in between). If we do it the other way
+	// around, another thread can submit work after we've checked all
+	// sources but before we drop nmspinning; as a result nobody will
+	// unpark a thread to run the work.
+	//
+	// This applies to the following sources of work:
+	//
+	// * Goroutines added to a per-P run queue.
+	// * New/modified-earlier timers on a per-P timer heap.
+	// * Idle-priority GC work (barring golang.org/issue/19112).
+	//
 	// If we discover new work below, we need to restore m.spinning as a signal
 	// for resetspinning to unpark a new worker thread (because there can be more
 	// than one starving goroutine). However, if after discovering new work
-	// we also observe no idle Ps, it is OK to just park the current thread:
-	// the system is fully loaded so no spinning threads are required.
+	// we also observe no idle Ps it is OK to skip unparking a new worker
+	// thread: the system is fully loaded so no spinning threads are required.
 	// Also see "Worker thread parking/unparking" comment at the top of the file.
 	wasSpinning := _g_.m.spinning
 	if _g_.m.spinning {
-- 
GitLab


From 9e8a312b71b3ad271026947d15f4d9fc483b0132 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 24 Mar 2021 21:55:49 -0400
Subject: [PATCH 1625/2400] go/parser: move type params in scope for the
 function signature

Type parameter resolution is a bit tricky: type parameters are in the
function scope, but unlike ordinary parameters may reference eachother.
When resolving the function scope, we must be careful about the order in
which objects are resolved and declared.

Using ordering allows us to avoid passing around temporary scopes for
field declarations.

Add a bunch of tests for this behavior, and skip "_" in resolution tests
as it just adds noise.

For #45221

Change-Id: Id080cddce3fd76396bf86ba5aba856aedf64a458
Reviewed-on: https://go-review.googlesource.com/c/go/+/304456
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/parser/resolver.go                     | 101 +++++++++++++-----
 src/go/parser/resolver_test.go                |   3 +-
 .../parser/testdata/resolution/issue45136.src |   6 +-
 .../parser/testdata/resolution/issue45160.src |   2 +-
 .../parser/testdata/resolution/resolution.src |  13 ++-
 .../parser/testdata/resolution/typeparams.go2 |  32 ++++--
 6 files changed, 119 insertions(+), 38 deletions(-)

diff --git a/src/go/parser/resolver.go b/src/go/parser/resolver.go
index 1e357e26df..cf92c7e4f5 100644
--- a/src/go/parser/resolver.go
+++ b/src/go/parser/resolver.go
@@ -19,12 +19,12 @@ const debugResolve = false
 // If declErr is non-nil, it is used to report declaration errors during
 // resolution. tok is used to format position in error messages.
 func resolveFile(file *ast.File, handle *token.File, declErr func(token.Pos, string)) {
-	topScope := ast.NewScope(nil)
+	pkgScope := ast.NewScope(nil)
 	r := &resolver{
 		handle:   handle,
 		declErr:  declErr,
-		topScope: topScope,
-		pkgScope: topScope,
+		topScope: pkgScope,
+		pkgScope: pkgScope,
 	}
 
 	for _, decl := range file.Decls {
@@ -245,9 +245,10 @@ func (r *resolver) Visit(node ast.Node) ast.Visitor {
 		r.resolve(n, true)
 
 	case *ast.FuncLit:
-		functionScope := ast.NewScope(r.topScope)
-		r.walkFuncType(functionScope, n.Type)
-		r.walkBody(functionScope, n.Body)
+		r.openScope(n.Pos())
+		defer r.closeScope()
+		r.walkFuncType(n.Type)
+		r.walkBody(n.Body)
 
 	case *ast.SelectorExpr:
 		ast.Walk(r, n.X)
@@ -255,12 +256,14 @@ func (r *resolver) Visit(node ast.Node) ast.Visitor {
 		// resolution.
 
 	case *ast.StructType:
-		scope := ast.NewScope(nil)
-		r.walkFieldList(scope, n.Fields, ast.Var)
+		r.openScope(n.Pos())
+		defer r.closeScope()
+		r.walkFieldList(n.Fields, ast.Var)
 
 	case *ast.FuncType:
-		scope := ast.NewScope(r.topScope)
-		r.walkFuncType(scope, n)
+		r.openScope(n.Pos())
+		defer r.closeScope()
+		r.walkFuncType(n)
 
 	case *ast.CompositeLit:
 		if n.Type != nil {
@@ -283,8 +286,9 @@ func (r *resolver) Visit(node ast.Node) ast.Visitor {
 		}
 
 	case *ast.InterfaceType:
-		scope := ast.NewScope(nil)
-		r.walkFieldList(scope, n.Methods, ast.Fun)
+		r.openScope(n.Pos())
+		defer r.closeScope()
+		r.walkFieldList(n.Methods, ast.Fun)
 
 	// Statements
 	case *ast.LabeledStmt:
@@ -454,17 +458,36 @@ func (r *resolver) Visit(node ast.Node) ast.Visitor {
 				if tparams := typeparams.Get(spec); tparams != nil {
 					r.openScope(spec.Pos())
 					defer r.closeScope()
-					r.walkFieldList(r.topScope, tparams, ast.Typ)
+					r.walkTParams(tparams)
 				}
 				ast.Walk(r, spec.Type)
 			}
 		}
 
 	case *ast.FuncDecl:
-		scope := ast.NewScope(r.topScope)
-		r.walkFieldList(scope, n.Recv, ast.Var)
-		r.walkFuncType(scope, n.Type)
-		r.walkBody(scope, n.Body)
+		// Open the function scope.
+		r.openScope(n.Pos())
+		defer r.closeScope()
+
+		// Resolve the receiver first, without declaring.
+		r.resolveList(n.Recv)
+
+		// Type parameters are walked normally: they can reference each other, and
+		// can be referenced by normal parameters.
+		if tparams := typeparams.Get(n.Type); tparams != nil {
+			r.walkTParams(tparams)
+			// TODO(rFindley): need to address receiver type parameters.
+		}
+
+		// Resolve and declare parameters in a specific order to get duplicate
+		// declaration errors in the correct location.
+		r.resolveList(n.Type.Params)
+		r.resolveList(n.Type.Results)
+		r.declareList(n.Recv, ast.Var)
+		r.declareList(n.Type.Params, ast.Var)
+		r.declareList(n.Type.Results, ast.Var)
+
+		r.walkBody(n.Body)
 		if n.Recv == nil && n.Name.Name != "init" {
 			r.declare(n, nil, r.pkgScope, ast.Fun, n.Name)
 		}
@@ -476,12 +499,15 @@ func (r *resolver) Visit(node ast.Node) ast.Visitor {
 	return nil
 }
 
-func (r *resolver) walkFuncType(scope *ast.Scope, typ *ast.FuncType) {
-	r.walkFieldList(scope, typ.Params, ast.Var)
-	r.walkFieldList(scope, typ.Results, ast.Var)
+func (r *resolver) walkFuncType(typ *ast.FuncType) {
+	// typ.TParams must be walked separately for FuncDecls.
+	r.resolveList(typ.Params)
+	r.resolveList(typ.Results)
+	r.declareList(typ.Params, ast.Var)
+	r.declareList(typ.Results, ast.Var)
 }
 
-func (r *resolver) walkFieldList(scope *ast.Scope, list *ast.FieldList, kind ast.ObjKind) {
+func (r *resolver) resolveList(list *ast.FieldList) {
 	if list == nil {
 		return
 	}
@@ -489,16 +515,41 @@ func (r *resolver) walkFieldList(scope *ast.Scope, list *ast.FieldList, kind ast
 		if f.Type != nil {
 			ast.Walk(r, f.Type)
 		}
-		r.declare(f, nil, scope, kind, f.Names...)
 	}
 }
 
-func (r *resolver) walkBody(scope *ast.Scope, body *ast.BlockStmt) {
+func (r *resolver) declareList(list *ast.FieldList, kind ast.ObjKind) {
+	if list == nil {
+		return
+	}
+	for _, f := range list.List {
+		r.declare(f, nil, r.topScope, kind, f.Names...)
+	}
+}
+
+func (r *resolver) walkFieldList(list *ast.FieldList, kind ast.ObjKind) {
+	if list == nil {
+		return
+	}
+	r.resolveList(list)
+	r.declareList(list, kind)
+}
+
+// walkTParams is like walkFieldList, but declares type parameters eagerly so
+// that they may be resolved in the constraint expressions held in the field
+// Type.
+func (r *resolver) walkTParams(list *ast.FieldList) {
+	if list == nil {
+		return
+	}
+	r.declareList(list, ast.Typ)
+	r.resolveList(list)
+}
+
+func (r *resolver) walkBody(body *ast.BlockStmt) {
 	if body == nil {
 		return
 	}
-	r.topScope = scope // open function scope
-	defer r.closeScope()
 	r.openLabelScope()
 	defer r.closeLabelScope()
 	r.walkStmts(body.List)
diff --git a/src/go/parser/resolver_test.go b/src/go/parser/resolver_test.go
index 80a6638210..625c009c91 100644
--- a/src/go/parser/resolver_test.go
+++ b/src/go/parser/resolver_test.go
@@ -86,7 +86,8 @@ func TestResolution(t *testing.T) {
 func declsFromParser(file *ast.File) map[token.Pos]token.Pos {
 	objmap := map[token.Pos]token.Pos{}
 	ast.Inspect(file, func(node ast.Node) bool {
-		if ident, _ := node.(*ast.Ident); ident != nil && ident.Obj != nil {
+		// Ignore blank identifiers to reduce noise.
+		if ident, _ := node.(*ast.Ident); ident != nil && ident.Obj != nil && ident.Name != "_" {
 			objmap[ident.Pos()] = ident.Obj.Pos()
 		}
 		return true
diff --git a/src/go/parser/testdata/resolution/issue45136.src b/src/go/parser/testdata/resolution/issue45136.src
index 671001f5a3..e1d63d8377 100644
--- a/src/go/parser/testdata/resolution/issue45136.src
+++ b/src/go/parser/testdata/resolution/issue45136.src
@@ -8,7 +8,7 @@ type obj /* =@obj */ struct {
 	name /*=@name */ string
 }
 
-func _ /* =@blank */ () {
+func _() {
 	var foo /* =@foo */ = "foo"
 	obj /* @obj */ ["foo"]
 	obj /* @obj */ .run()
@@ -19,8 +19,8 @@ func _ /* =@blank */ () {
 		name: "bar",
 	}.run()
 
-	var _ /* @=blank4 */ = File{key: obj /* @obj */ {}}
-	var _ /* @=blank3 */ = File{obj /* @obj */ {}}
+	var _ = File{key: obj /* @obj */ {}}
+	var _ = File{obj /* @obj */ {}}
 
 	[]obj /* @obj */ {foo /* @foo */}
 	x /* =@x1 */ := obj /* @obj */{}
diff --git a/src/go/parser/testdata/resolution/issue45160.src b/src/go/parser/testdata/resolution/issue45160.src
index 77cf0fa9c0..6be933b783 100644
--- a/src/go/parser/testdata/resolution/issue45160.src
+++ b/src/go/parser/testdata/resolution/issue45160.src
@@ -6,7 +6,7 @@ package issue45160
 
 func mklink1 /* =@mklink1func */() {}
 
-func _ /* =@blank */ () {
+func _() {
 	var tests /* =@tests */ = []dirLinkTest /* @dirLinkTest */ {
 		{
 			mklink1 /* @mklink1func */: func() {},
diff --git a/src/go/parser/testdata/resolution/resolution.src b/src/go/parser/testdata/resolution/resolution.src
index d76a83d9ed..a880dd1c5e 100644
--- a/src/go/parser/testdata/resolution/resolution.src
+++ b/src/go/parser/testdata/resolution/resolution.src
@@ -21,7 +21,7 @@ const (
 
 type T /* =@T */ int
 
-func _ /* =@blankFunc */ (count /* =@count */ T /* @T */) {
+func _(count /* =@count */ T /* @T */) {
 	x /* =@x1 */ := c /* @cdecl */{}
 	switch x /* =@x2 */ := x /* @x1 */; x /* =@x3 */ := x /* @x2 */.(type) {
 	case c /* @cdecl */:
@@ -39,8 +39,19 @@ loop /* =@loop */:
 	case err /* =@err2 */ := <-_:
 		return err /* @err2 */
 	}
+
+	_ = func(p1 /* =@p1 */ int, p2 /* =@p2 */ p1) {
+		closed /* =@closed */ := p1 // @p1
+		shadowed /* =@shadowed1 */ := p2 // @p2
+		_ = func(shadowed /* =@shadowed2 */ p2 /* @p2 */) {
+			closed /* @closed */ = 1
+			shadowed /* @shadowed2 */ = 2
+		}
+	}
 }
 
+func (r /* =@r */ c /* @cdecl */) m(_ r) c /* @cdecl */ { return r /* @r */ }
+
 var cycle /* =@cycle */ = cycle /* @cycle */ + 1
 
 type chain /* =@chain */ struct {
diff --git a/src/go/parser/testdata/resolution/typeparams.go2 b/src/go/parser/testdata/resolution/typeparams.go2
index c03a596203..0ffecd69b5 100644
--- a/src/go/parser/testdata/resolution/typeparams.go2
+++ b/src/go/parser/testdata/resolution/typeparams.go2
@@ -9,17 +9,35 @@ type List /* =@List */ [E /* =@E */ any] []E // @E
 type Pair /* =@Pair */ [L /* =@L */, R /* =@R */ any] struct {
 	Left /* =@Left */ L // @L
 	Right /* =@Right */ R // @R
+	L /* =@Lfield */ int
 }
 
-var _ /* =@blank */ = Pair /* @Pair */ [int, string]{}
+var _ = Pair /* @Pair */ [int, string]{}
 
 type Addable /* =@Addable */ interface {
 	type int64, float64
 }
 
-// TODO (#45221): resolve references to T in the signature below.
-// TODO(rFindley): re-enable these once type parameter resolution is fixed.
-// func Add /* =@AddDecl */[T /* =@T */ Addable /* @Addable */](l /* =@l */, r /* =@r */ T) T {
-	// var t /* =@t */ T /* @T */
-	// return l /* @l */ + r /* @r */ + t /* @t */
-// }
+func Add /* =@AddDecl */[T /* =@T */ Addable /* @Addable */](l /* =@l */, r /* =@r */ T /* @T */) T /* @T */ {
+	var t /* =@t */ T /* @T */
+	return l /* @l */ + r /* @r */ + t /* @t */
+}
+
+type Receiver /* =@Receiver */[P /* =@P */ any] struct {}
+
+// TODO(rFindley): make a decision on how/whether to resolve identifiers that
+// refer to receiver type parameters, as is the case for the 'P' result
+// parameter below.
+func (r /* =@recv */ Receiver /* @Receiver */ [P]) m() P {}
+
+func f /* =@f */[T1 /* =@T1 */ interface{type []T2 /* @T2 */}, T2 /* =@T2 */ any](
+  x /* =@x */ T1 /* @T1 */, T1 /* =@T1_duplicate */ y,  // Note that this is a bug:
+                                                        // the duplicate T1 should
+							// not be allowed.
+  ){
+  // Note that duplicate short var declarations resolve to their alt declaration.
+  x /* @x */ := 0
+  y /* =@y */ := 0
+  T1 /* @T1 */ := 0
+  var t1var /* =@t1var */ T1 /* @T1 */
+}
-- 
GitLab


From b91f8a4c0b0b9be44b24b445cbf2955050a55b69 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 7 Apr 2021 17:18:17 -0400
Subject: [PATCH 1626/2400] go/scanner: fix a typo in scanner_test.go

Change-Id: I99f07328da3dd99d34b8da5f913c98206b4dc76a
Reviewed-on: https://go-review.googlesource.com/c/go/+/308609
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/scanner/scanner_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/go/scanner/scanner_test.go b/src/go/scanner/scanner_test.go
index ab4c2dd962..db095b3da6 100644
--- a/src/go/scanner/scanner_test.go
+++ b/src/go/scanner/scanner_test.go
@@ -628,7 +628,7 @@ func TestInvalidLineDirectives(t *testing.T) {
 	}
 
 	if S.ErrorCount != len(invalidSegments) {
-		t.Errorf("go %d errors; want %d", S.ErrorCount, len(invalidSegments))
+		t.Errorf("got %d errors; want %d", S.ErrorCount, len(invalidSegments))
 	}
 }
 
-- 
GitLab


From 02a2ff47ef6004a59e4d688c7c93198778c36bcf Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Mon, 29 Mar 2021 16:03:51 -0400
Subject: [PATCH 1627/2400] go/parser: add a SkipObjectResolution mode to
 bypass object resolution

Parser object resolution is an auxiliary feature in which the parser
attempts to resolve identifiers to their declarations. In functionality,
it significantly overlaps with go/types and in fact cannot be correctly
computed at parse-time without type information (for example, it is
generally not possible to resolve k in the composite lit c{k: v}). Due
to these limitations, it is of limited utility and rarely used.

Now that object resolution is isolated as a post-processing pass, it is
trivial to offer a parser mode that skips it entirely. This CL adds that
mode.

Fixes #45104

Change-Id: I5a2c05437e298964ad2039e1ff98e63d6efbd1af
Reviewed-on: https://go-review.googlesource.com/c/go/+/306149
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/parser/interface.go | 23 ++++++++++++++---------
 src/go/parser/parser.go    |  4 +++-
 2 files changed, 17 insertions(+), 10 deletions(-)

diff --git a/src/go/parser/interface.go b/src/go/parser/interface.go
index dcc5fa6616..85486d2f4b 100644
--- a/src/go/parser/interface.go
+++ b/src/go/parser/interface.go
@@ -49,13 +49,14 @@ func readSource(filename string, src interface{}) ([]byte, error) {
 type Mode uint
 
 const (
-	PackageClauseOnly Mode             = 1 << iota // stop parsing after package clause
-	ImportsOnly                                    // stop parsing after import declarations
-	ParseComments                                  // parse comments and add them to AST
-	Trace                                          // print a trace of parsed productions
-	DeclarationErrors                              // report declaration errors
-	SpuriousErrors                                 // same as AllErrors, for backward-compatibility
-	AllErrors         = SpuriousErrors             // report all errors (not just the first 10 on different lines)
+	PackageClauseOnly    Mode             = 1 << iota // stop parsing after package clause
+	ImportsOnly                                       // stop parsing after import declarations
+	ParseComments                                     // parse comments and add them to AST
+	Trace                                             // print a trace of parsed productions
+	DeclarationErrors                                 // report declaration errors
+	SpuriousErrors                                    // same as AllErrors, for backward-compatibility
+	SkipObjectResolution                              // don't resolve identifiers to objects - see ParseFile
+	AllErrors            = SpuriousErrors             // report all errors (not just the first 10 on different lines)
 )
 
 // ParseFile parses the source code of a single Go source file and returns
@@ -68,8 +69,12 @@ const (
 // If src == nil, ParseFile parses the file specified by filename.
 //
 // The mode parameter controls the amount of source text parsed and other
-// optional parser functionality. Position information is recorded in the
-// file set fset, which must not be nil.
+// optional parser functionality. If the SkipObjectResolution mode bit is set,
+// the object resolution phase of parsing will be skipped, causing File.Scope,
+// File.Unresolved, and all Ident.Obj fields to be nil.
+//
+// Position information is recorded in the file set fset, which must not be
+// nil.
 //
 // If the source couldn't be read, the returned AST is nil and the error
 // indicates the specific failure. If the source was read but syntax
diff --git a/src/go/parser/parser.go b/src/go/parser/parser.go
index aff5838780..cddaef350e 100644
--- a/src/go/parser/parser.go
+++ b/src/go/parser/parser.go
@@ -2636,7 +2636,9 @@ func (p *parser) parseFile() *ast.File {
 	if p.mode&DeclarationErrors != 0 {
 		declErr = p.error
 	}
-	resolveFile(f, p.file, declErr)
+	if p.mode&SkipObjectResolution == 0 {
+		resolveFile(f, p.file, declErr)
+	}
 
 	return f
 }
-- 
GitLab


From b65f8589e847826f7a353011823558c41491cda0 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 16 Apr 2021 17:30:12 -0400
Subject: [PATCH 1628/2400] cmd/dist: defend self against misc/reboot test

Change-Id: Ice89ecae980d46b16b5ed32ac733bd23c92115af
Reviewed-on: https://go-review.googlesource.com/c/go/+/310870
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Austin Clements <austin@google.com>
---
 src/cmd/dist/util.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/cmd/dist/util.go b/src/cmd/dist/util.go
index e99375f538..df60145d1e 100644
--- a/src/cmd/dist/util.go
+++ b/src/cmd/dist/util.go
@@ -249,6 +249,7 @@ func writefile(text, file string, flag int) {
 	if flag&writeExec != 0 {
 		mode = 0777
 	}
+	xremove(file) // in case of symlink tricks by misc/reboot test
 	err := ioutil.WriteFile(file, new, mode)
 	if err != nil {
 		fatalf("%v", err)
-- 
GitLab


From b05903a9f6408065c390ea6c62e523d9f51853a5 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Fri, 16 Apr 2021 16:46:33 -0400
Subject: [PATCH 1629/2400] cmd/link: fix defaultGOROOT package

CL 310731 moved cmd/internal/objabi.defaultGOROOT to
internal/buildcfg.defaultGOROOT, but didn't update the place in the
linker that sets its value.

Fixes the failing reboot test on the GOEXPERIMENT builders.

Change-Id: I135b6bfc0fdadbe6cfc144d7aa55ca13519ba004
Reviewed-on: https://go-review.googlesource.com/c/go/+/310869
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/link/internal/ld/main.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/link/internal/ld/main.go b/src/cmd/link/internal/ld/main.go
index 7ab9ca7d10..52dfe91993 100644
--- a/src/cmd/link/internal/ld/main.go
+++ b/src/cmd/link/internal/ld/main.go
@@ -117,7 +117,7 @@ func Main(arch *sys.Arch, theArch Arch) {
 
 	final := gorootFinal()
 	addstrdata1(ctxt, "runtime.defaultGOROOT="+final)
-	addstrdata1(ctxt, "cmd/internal/objabi.defaultGOROOT="+final)
+	addstrdata1(ctxt, "internal/buildcfg.defaultGOROOT="+final)
 
 	buildVersion := buildcfg.Version
 	if goexperiment := buildcfg.GOEXPERIMENT(); goexperiment != "" {
-- 
GitLab


From 94817890c221b8abdbb24f52e92e5a7882c3f870 Mon Sep 17 00:00:00 2001
From: Leonard Wang <wangdeyu0907@gmail.com>
Date: Fri, 16 Apr 2021 23:30:59 +0800
Subject: [PATCH 1630/2400] runtime: remove useless nFlushCacheRoots

Change-Id: I70cb8f8e9a0eec68ea11f22ca8699aa7e0c91ede
Reviewed-on: https://go-review.googlesource.com/c/go/+/310710
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/runtime/mgc.go     |  2 --
 src/runtime/mgcmark.go | 10 ++--------
 2 files changed, 2 insertions(+), 10 deletions(-)

diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index e4bbf1f016..601593087d 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -325,11 +325,9 @@ var work struct {
 	nwait  uint32
 
 	// Number of roots of various root types. Set by gcMarkRootPrepare.
-	nFlushCacheRoots                               int
 	nDataRoots, nBSSRoots, nSpanRoots, nStackRoots int
 
 	// Base indexes of each root type. Set by gcMarkRootPrepare.
-	baseFlushCache                                    uint32
 	baseData, baseBSS, baseSpans, baseStacks, baseEnd uint32
 
 	// Each type of GC state transition is protected by a lock.
diff --git a/src/runtime/mgcmark.go b/src/runtime/mgcmark.go
index 061d2f5c9d..719b21055b 100644
--- a/src/runtime/mgcmark.go
+++ b/src/runtime/mgcmark.go
@@ -56,8 +56,6 @@ const (
 func gcMarkRootPrepare() {
 	assertWorldStopped()
 
-	work.nFlushCacheRoots = 0
-
 	// Compute how many data and BSS root blocks there are.
 	nBlocks := func(bytes uintptr) int {
 		return int(divRoundUp(bytes, rootBlockBytes))
@@ -105,11 +103,10 @@ func gcMarkRootPrepare() {
 	work.nStackRoots = int(atomic.Loaduintptr(&allglen))
 
 	work.markrootNext = 0
-	work.markrootJobs = uint32(fixedRootCount + work.nFlushCacheRoots + work.nDataRoots + work.nBSSRoots + work.nSpanRoots + work.nStackRoots)
+	work.markrootJobs = uint32(fixedRootCount + work.nDataRoots + work.nBSSRoots + work.nSpanRoots + work.nStackRoots)
 
 	// Calculate base indexes of each root type
-	work.baseFlushCache = uint32(fixedRootCount)
-	work.baseData = work.baseFlushCache + uint32(work.nFlushCacheRoots)
+	work.baseData = uint32(fixedRootCount)
 	work.baseBSS = work.baseData + uint32(work.nDataRoots)
 	work.baseSpans = work.baseBSS + uint32(work.nBSSRoots)
 	work.baseStacks = work.baseSpans + uint32(work.nSpanRoots)
@@ -159,9 +156,6 @@ var oneptrmask = [...]uint8{1}
 func markroot(gcw *gcWork, i uint32) {
 	// Note: if you add a case here, please also update heapdump.go:dumproots.
 	switch {
-	case work.baseFlushCache <= i && i < work.baseData:
-		flushmcache(int(i - work.baseFlushCache))
-
 	case work.baseData <= i && i < work.baseBSS:
 		for _, datap := range activeModules() {
 			markrootBlock(datap.data, datap.edata-datap.data, datap.gcdatamask.bytedata, gcw, int(i-work.baseData))
-- 
GitLab


From 14dbd6e7762662f8bec95d537281f09ad3d508e4 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Thu, 15 Apr 2021 16:18:30 -0400
Subject: [PATCH 1631/2400] internal/buildcfg: make regabi an alias for regabi
 sub-experiments

Currently, specifying GOEXPERIMENT=regabi will turn on all regabi
sub-experiments, but GOEXPERIMENT=noregabi won't turn anything off.
Regabi also isn't a "real" experiment in the sense that nothing in the
code base should depend on it as an experiment flag (it should depend
on the appropriate sub-experiments).

Hence, drop Regabi from goexperiment.Flags and make "regabi" in
GOEXPERIMENT be a real alias for all of the sub-flags, so regabi will
turn on all of the sub-flags and noregabi will turn off all of the
sub-flags.

This way, once we enable the sub-experiments in the baseline
configuration, it will be easy to turn off with "noregabi".

For #40724.

Change-Id: I0fb95be42f756d412e729a396be607d629ae2bab
Reviewed-on: https://go-review.googlesource.com/c/go/+/310609
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/internal/buildcfg/exp.go       | 31 ++++++++++++++++--------------
 src/internal/goexperiment/flags.go |  7 ++++---
 2 files changed, 21 insertions(+), 17 deletions(-)

diff --git a/src/internal/buildcfg/exp.go b/src/internal/buildcfg/exp.go
index dc0adb0963..6eaf2bd7c2 100644
--- a/src/internal/buildcfg/exp.go
+++ b/src/internal/buildcfg/exp.go
@@ -45,12 +45,25 @@ func parseExperiments() goexperiment.Flags {
 
 	if env != "" {
 		// Create a map of known experiment names.
-		names := make(map[string]reflect.Value)
+		names := make(map[string]func(bool))
 		rv := reflect.ValueOf(&flags).Elem()
 		rt := rv.Type()
 		for i := 0; i < rt.NumField(); i++ {
 			field := rv.Field(i)
-			names[strings.ToLower(rt.Field(i).Name)] = field
+			names[strings.ToLower(rt.Field(i).Name)] = field.SetBool
+		}
+
+		// "regabi" is an alias for all working regabi
+		// subexperiments, and not an experiment itself. Doing
+		// this as an alias make both "regabi" and "noregabi"
+		// do the right thing.
+		names["regabi"] = func(v bool) {
+			flags.RegabiWrappers = v
+			flags.RegabiG = v
+			flags.RegabiReflect = v
+			flags.RegabiDefer = v
+			// Not ready yet:
+			//flags.RegabiArgs = v
 		}
 
 		// Parse names.
@@ -69,33 +82,23 @@ func parseExperiments() goexperiment.Flags {
 			if strings.HasPrefix(f, "no") {
 				f, val = f[2:], false
 			}
-			field, ok := names[f]
+			set, ok := names[f]
 			if !ok {
 				fmt.Printf("unknown experiment %s\n", f)
 				os.Exit(2)
 			}
-			field.SetBool(val)
+			set(val)
 		}
 	}
 
 	// regabi is only supported on amd64.
 	if GOARCH != "amd64" {
-		flags.Regabi = false
 		flags.RegabiWrappers = false
 		flags.RegabiG = false
 		flags.RegabiReflect = false
 		flags.RegabiDefer = false
 		flags.RegabiArgs = false
 	}
-	// Setting regabi sets working sub-experiments.
-	if flags.Regabi {
-		flags.RegabiWrappers = true
-		flags.RegabiG = true
-		flags.RegabiReflect = true
-		flags.RegabiDefer = true
-		// Not ready yet:
-		//flags.RegabiArgs = true
-	}
 	// Check regabi dependencies.
 	if flags.RegabiG && !flags.RegabiWrappers {
 		panic("GOEXPERIMENT regabig requires regabiwrappers")
diff --git a/src/internal/goexperiment/flags.go b/src/internal/goexperiment/flags.go
index e77734caa4..cd4c178818 100644
--- a/src/internal/goexperiment/flags.go
+++ b/src/internal/goexperiment/flags.go
@@ -60,9 +60,10 @@ type Flags struct {
 	StaticLockRanking bool
 
 	// Regabi is split into several sub-experiments that can be
-	// enabled individually. GOEXPERIMENT=regabi implies the
-	// subset that are currently "working". Not all combinations work.
-	Regabi bool
+	// enabled individually. Not all combinations work.
+	// The "regabi" GOEXPERIMENT is an alias for all "working"
+	// subexperiments.
+
 	// RegabiWrappers enables ABI wrappers for calling between
 	// ABI0 and ABIInternal functions. Without this, the ABIs are
 	// assumed to be identical so cross-ABI calls are direct.
-- 
GitLab


From 067bad2eef1bacb811bf69b38cf0aec67b60482a Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Fri, 16 Apr 2021 17:48:51 -0400
Subject: [PATCH 1632/2400] runtime: update stale comment

Missed in CL 310731.

Change-Id: Ia26cd2cedec1508ecfd7f0beb63cd6a6ab546f1e
Reviewed-on: https://go-review.googlesource.com/c/go/+/310909
Trust: Austin Clements <austin@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/runtime/runtime2.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index 9e547f8200..387841e60b 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -1123,5 +1123,5 @@ var (
 	isarchive bool // -buildmode=c-archive
 )
 
-// Must agree with cmd/internal/objabi.Experiment.FramePointer.
+// Must agree with internal/buildcfg.Experiment.FramePointer.
 const framepointer_enabled = GOARCH == "amd64" || GOARCH == "arm64"
-- 
GitLab


From 43466399cbce877273c8dad2697772cdb443f32b Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Fri, 16 Apr 2021 15:26:57 -0400
Subject: [PATCH 1633/2400] internal/buildcfg: make regabi enable regabiargs

For #40724.

Change-Id: I6e9d7eb91883857479699972a974a39ce3d9d2cc
Reviewed-on: https://go-review.googlesource.com/c/go/+/310849
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/internal/buildcfg/exp.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/internal/buildcfg/exp.go b/src/internal/buildcfg/exp.go
index 6eaf2bd7c2..f4368ccdcf 100644
--- a/src/internal/buildcfg/exp.go
+++ b/src/internal/buildcfg/exp.go
@@ -62,8 +62,7 @@ func parseExperiments() goexperiment.Flags {
 			flags.RegabiG = v
 			flags.RegabiReflect = v
 			flags.RegabiDefer = v
-			// Not ready yet:
-			//flags.RegabiArgs = v
+			flags.RegabiArgs = v
 		}
 
 		// Parse names.
-- 
GitLab


From fd3612e4339d10a0e02571a8e43868d569b11a9f Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Wed, 14 Apr 2021 12:37:04 -0400
Subject: [PATCH 1634/2400] internal/buildcfg: enable regabiwrappers by default

For #40724.

Change-Id: I75d6ba2d3e4e2d858eea8053efd0f3fd4439dab7
Reviewed-on: https://go-review.googlesource.com/c/go/+/310172
Trust: Austin Clements <austin@google.com>
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/internal/buildcfg/exp.go | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/internal/buildcfg/exp.go b/src/internal/buildcfg/exp.go
index f4368ccdcf..bf4a8fa977 100644
--- a/src/internal/buildcfg/exp.go
+++ b/src/internal/buildcfg/exp.go
@@ -20,10 +20,14 @@ import (
 // was built with.)
 var Experiment goexperiment.Flags = parseExperiments()
 
+var regabiSupported = GOARCH == "amd64" && (GOOS == "linux" || GOOS == "darwin" || GOOS == "windows")
+
 // experimentBaseline specifies the experiment flags that are enabled by
 // default in the current toolchain. This is, in effect, the "control"
 // configuration and any variation from this is an experiment.
-var experimentBaseline = goexperiment.Flags{}
+var experimentBaseline = goexperiment.Flags{
+	RegabiWrappers: regabiSupported,
+}
 
 // FramePointerEnabled enables the use of platform conventions for
 // saving frame pointers.
-- 
GitLab


From 4efd581383ade76c562953289ed8210bb55bff47 Mon Sep 17 00:00:00 2001
From: Paschalis Tsilias <paschalis.tsilias@gmail.com>
Date: Tue, 13 Apr 2021 15:51:58 +0300
Subject: [PATCH 1635/2400] archive/zip: fix imports block of biggestZipBytes
 generator

Fixes #45529

Change-Id: I4d64c40aa6733b783dc4066e222f17abeb7ad413
Reviewed-on: https://go-review.googlesource.com/c/go/+/309357
Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
Trust: Joe Tsai <thebrokentoaster@gmail.com>
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Joe Tsai <thebrokentoaster@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/archive/zip/reader_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/archive/zip/reader_test.go b/src/archive/zip/reader_test.go
index 5faf1f49b5..fbaf9d4388 100644
--- a/src/archive/zip/reader_test.go
+++ b/src/archive/zip/reader_test.go
@@ -776,8 +776,8 @@ func returnRecursiveZip() (r io.ReaderAt, size int64) {
 //		"archive/zip"
 //		"bytes"
 //		"io"
-//		"io/ioutil"
 //		"log"
+//		"os"
 //	)
 //
 //	type zeros struct{}
-- 
GitLab


From c914e6160db8b6af358cad90ed7272ebc5c22dda Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Fri, 16 Apr 2021 21:45:02 -0400
Subject: [PATCH 1636/2400] cmd/go: drop GOEXPERIMENT in script tests

TestScript sets the GOEXPERIMENT environment variable to the value of
buildcfg.GOEXPERIMENT() with the intent that tests can use this to
inspect the value of buildcfg.GOEXPERIMENT. This has the unfortunate
side-effect of also affecting the experiments enabled for all builds
done by TestScript. For the most part this is harmless, but
GOEXPERIMENT can be GOOS/GOARCH-sensitive, so if a test changes GOOS
or GOARCH, it will continue to use the GOEXPERIMENT from the host
GOOS/GOARCH rather than what makes sense (or is even allowed) in the
test's GOOS/GOARCH. In fact, prior to CL 307819, TestScript set
GOEXPSTRING instead of GOEXPERIMENT because it previously captured
objabi.Expstring(), so the captured value didn't affect the build.

There's only one experiment that actually uses TestScript's
GOEXPERIMENT and there's a much better way to write that test now such
that it doesn't need to read GOEXPERIMENT at all. Hence, this CL
rewrites this test and drops GOEXPERIMENT from TestScript.

This should fix the *-regabi builders.

Change-Id: I3fcbf1f21e1b471ebc0e953c31333645553ea24c
Reviewed-on: https://go-review.googlesource.com/c/go/+/310969
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/go/script_test.go                     |  2 -
 src/cmd/go/testdata/script/README             |  1 -
 .../script/build_tag_goexperiment.txt         | 93 +++----------------
 3 files changed, 11 insertions(+), 85 deletions(-)

diff --git a/src/cmd/go/script_test.go b/src/cmd/go/script_test.go
index 87b5971aa7..2274335a75 100644
--- a/src/cmd/go/script_test.go
+++ b/src/cmd/go/script_test.go
@@ -13,7 +13,6 @@ import (
 	"errors"
 	"fmt"
 	"go/build"
-	"internal/buildcfg"
 	"internal/testenv"
 	"io/fs"
 	"os"
@@ -165,7 +164,6 @@ func (ts *testScript) setup() {
 		"GOCACHE=" + testGOCACHE,
 		"GODEBUG=" + os.Getenv("GODEBUG"),
 		"GOEXE=" + cfg.ExeSuffix,
-		"GOEXPERIMENT=" + buildcfg.GOEXPERIMENT(),
 		"GOOS=" + runtime.GOOS,
 		"GOPATH=" + filepath.Join(ts.workdir, "gopath"),
 		"GOPROXY=" + proxyURL,
diff --git a/src/cmd/go/testdata/script/README b/src/cmd/go/testdata/script/README
index b4dcb1f5a2..d7e67bb7b6 100644
--- a/src/cmd/go/testdata/script/README
+++ b/src/cmd/go/testdata/script/README
@@ -29,7 +29,6 @@ Scripts also have access to these other environment variables:
 	GOARCH=<target GOARCH>
 	GOCACHE=<actual GOCACHE being used outside the test>
 	GOEXE=<executable file suffix: .exe on Windows, empty on other systems>
-	GOEXPERIMENT=<value of objabi.GOEXPERIMENT>
 	GOOS=<target GOOS>
 	GOPATH=$WORK/gopath
 	GOPROXY=<local module proxy serving from cmd/go/testdata/mod>
diff --git a/src/cmd/go/testdata/script/build_tag_goexperiment.txt b/src/cmd/go/testdata/script/build_tag_goexperiment.txt
index dfda3d2629..bee218f4c1 100644
--- a/src/cmd/go/testdata/script/build_tag_goexperiment.txt
+++ b/src/cmd/go/testdata/script/build_tag_goexperiment.txt
@@ -1,83 +1,20 @@
-# compile_ext will fail if the buildtags that are enabled (or not enabled) for the
-# framepointer and fieldtrack experiments are not consistent with the value of
-# objabi.GOEXPERIMENT.
-
 [short] skip
+# Reset all experiments so fieldtrack is definitely off.
+env GOEXPERIMENT=none
 go run m
-
--- expt_main.go --
-package main
-
-import (
-	"os"
-	"strings"
-)
-
-func main() {
-  fp()
-  ft()
-}
-
-func hasExpEntry(s string) bool {
-	// script_test.go defines GOEXPERIMENT to be the enabled experiments.
-	g := os.Getenv("GOEXPERIMENT")
-	for _, f := range strings.Split(g, ",") {
-		if f == s {
-			return true
-		}
-	}
-	return false
-}
-
--- fp_off.go --
-// +build !goexperiment.framepointer
-
-package main
-
-import (
-	"fmt"
-	"os"
-)
-
-func fp() {
-	if hasExpEntry("framepointer") {
-		fmt.Println("in !framepointer build, but objabi.GOEXPERIMENT has 'framepointer'")
-		os.Exit(1)
-	}
-}
-
--- fp_on.go --
-// +build goexperiment.framepointer
-
-package main
-
-import (
-	"fmt"
-	"os"
-)
-
-func fp() {
-	if !hasExpEntry("framepointer") {
-		fmt.Println("in framepointer build, but objabi.GOEXPERIMENT does not have 'framepointer', is", os.Getenv("GOEXPERIMENT"))
-		os.Exit(1)
-	}
-}
+stderr 'fieldtrack off'
+# Turn fieldtrack on.
+env GOEXPERIMENT=none,fieldtrack
+go run m
+stderr 'fieldtrack on'
 
 -- ft_off.go --
 // +build !goexperiment.fieldtrack
 
 package main
 
-import (
-	"fmt"
-	"os"
-)
-
-func ft() {
-	if hasExpEntry("fieldtrack") {
-		fmt.Println("in !fieldtrack build, but objabi.GOEXPERIMENT has 'fieldtrack'")
-		os.Exit(1)
-	}
+func main() {
+	println("fieldtrack off")
 }
 
 -- ft_on.go --
@@ -85,16 +22,8 @@ func ft() {
 
 package main
 
-import (
-	"fmt"
-	"os"
-)
-
-func ft() {
-	if !hasExpEntry("fieldtrack") {
-		fmt.Println("in fieldtrack build, but objabi.GOEXPERIMENT does not have 'fieldtrack', is", os.Getenv("GOEXPERIMENT"))
-		os.Exit(1)
-	}
+func main() {
+	println("fieldtrack on")
 }
 
 -- go.mod --
-- 
GitLab


From a72622d028077643169dc48c90271a82021f0534 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong@orijtech.com>
Date: Mon, 19 Apr 2021 02:39:50 +0700
Subject: [PATCH 1637/2400] cmd/compile: skip "_" function in
 reflectdata.MarkUsedIfaceMethod

CL 256798 added compiler ability to retain only used interface methods,
by generating a mark relocation whenever an interface method is used. To
do that, the compiler needs the current function linker object.

However, for unnamed function "func _()", its linker object is nil,
causes the compiler crashes for code in #45258.

CL 283313 fixed the code in #45258 unintentionally, since when the
compiler now does not walk unnamed functions anymore.

This CL fixes the root issue, by making reflectdata.MarkUsedIfaceMethod
skips unnamed functions, and also adding regression test.

Fixes #45258

Change-Id: I4cbefb0a89d9928f70c00dc8a271cb61cd20a49c
Reviewed-on: https://go-review.googlesource.com/c/go/+/311130
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 .../compile/internal/reflectdata/reflect.go   |  4 +++
 test/fixedbugs/issue45258.go                  | 28 +++++++++++++++++++
 2 files changed, 32 insertions(+)
 create mode 100644 test/fixedbugs/issue45258.go

diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index f0a60998a1..d23ca6b839 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -1837,6 +1837,10 @@ func MarkTypeUsedInInterface(t *types.Type, from *obj.LSym) {
 // MarkUsedIfaceMethod marks that an interface method is used in the current
 // function. n is OCALLINTER node.
 func MarkUsedIfaceMethod(n *ir.CallExpr) {
+	// skip unnamed functions (func _())
+	if ir.CurFunc.LSym == nil {
+		return
+	}
 	dot := n.X.(*ir.SelectorExpr)
 	ityp := dot.X.Type()
 	tsym := TypeLinksym(ityp)
diff --git a/test/fixedbugs/issue45258.go b/test/fixedbugs/issue45258.go
new file mode 100644
index 0000000000..f4d6fccf17
--- /dev/null
+++ b/test/fixedbugs/issue45258.go
@@ -0,0 +1,28 @@
+// compile
+
+// Copyright 2021 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
+
+type Fooer interface {
+	Foo() Barer
+}
+
+type Barer interface {
+	Bar()
+}
+
+type impl struct{}
+
+func (r *impl) Foo() Barer {
+	return r
+}
+
+func (r *impl) Bar() {}
+
+func _() {
+	var r Fooer = &impl{}
+	r.Foo().Bar()
+}
-- 
GitLab


From a9c244a849659a696a970b0cb862b2d1f66671bf Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Sat, 17 Apr 2021 00:46:53 -0400
Subject: [PATCH 1638/2400] test: add liveness test for regabi

With defer/go wrapping and register arguments, some liveness info
changed and live.go test was disabled for regabi. This CL adds a
new one for regabi.

Change-Id: I65f03a6ef156366d8b76c62a16251c3e818f4b02
Reviewed-on: https://go-review.googlesource.com/c/go/+/311369
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: David Chase <drchase@google.com>
---
 test/live.go        |   3 +-
 test/live_regabi.go | 719 ++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 721 insertions(+), 1 deletion(-)
 create mode 100644 test/live_regabi.go

diff --git a/test/live.go b/test/live.go
index 6d1a475492..bc7b3849cf 100644
--- a/test/live.go
+++ b/test/live.go
@@ -3,7 +3,8 @@
 
 // ppc64 needs a better tighten pass to make f18 pass
 // rescheduling checks need to be turned off because there are some live variables across the inserted check call
-// TODO(register args): temporarily disabled when GOEXPERIMENT=regabi due to additional temporaries live at "go" statements when regabi is in effect.
+//
+// For register ABI, liveness info changes slightly. See live_regabi.go.
 
 // Copyright 2014 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/live_regabi.go b/test/live_regabi.go
new file mode 100644
index 0000000000..2b0278ecb8
--- /dev/null
+++ b/test/live_regabi.go
@@ -0,0 +1,719 @@
+// errorcheckwithauto -0 -l -live -wb=0 -d=ssa/insert_resched_checks/off
+// +build amd64,goexperiment.regabidefer,goexperiment.regabiargs
+
+// Copyright 2014 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.
+
+// liveness tests with inlining disabled.
+// see also live2.go.
+
+package main
+
+func printnl()
+
+//go:noescape
+func printpointer(**int)
+
+//go:noescape
+func printintpointer(*int)
+
+//go:noescape
+func printstringpointer(*string)
+
+//go:noescape
+func printstring(string)
+
+//go:noescape
+func printbytepointer(*byte)
+
+func printint(int)
+
+func f1() {
+	var x *int       // ERROR "stack object x \*int$"
+	printpointer(&x) // ERROR "live at call to printpointer: x$"
+	printpointer(&x)
+}
+
+func f2(b bool) {
+	if b {
+		printint(0) // nothing live here
+		return
+	}
+	var x *int       // ERROR "stack object x \*int$"
+	printpointer(&x) // ERROR "live at call to printpointer: x$"
+	printpointer(&x)
+}
+
+func f3(b1, b2 bool) {
+	// Here x and y are ambiguously live. In previous go versions they
+	// were marked as live throughout the function to avoid being
+	// poisoned in GODEBUG=gcdead=1 mode; this is now no longer the
+	// case.
+
+	printint(0)
+	if b1 == false {
+		printint(0)
+		return
+	}
+
+	if b2 {
+		var x *int       // ERROR "stack object x \*int$"
+		printpointer(&x) // ERROR "live at call to printpointer: x$"
+		printpointer(&x)
+	} else {
+		var y *int       // ERROR "stack object y \*int$"
+		printpointer(&y) // ERROR "live at call to printpointer: y$"
+		printpointer(&y)
+	}
+	printint(0) // nothing is live here
+}
+
+// The old algorithm treated x as live on all code that
+// could flow to a return statement, so it included the
+// function entry and code above the declaration of x
+// but would not include an indirect use of x in an infinite loop.
+// Check that these cases are handled correctly.
+
+func f4(b1, b2 bool) { // x not live here
+	if b2 {
+		printint(0) // x not live here
+		return
+	}
+	var z **int
+	x := new(int) // ERROR "stack object x \*int$"
+	*x = 42
+	z = &x
+	printint(**z) // ERROR "live at call to printint: x$"
+	if b2 {
+		printint(1) // x not live here
+		return
+	}
+	for {
+		printint(**z) // ERROR "live at call to printint: x$"
+	}
+}
+
+func f5(b1 bool) {
+	var z **int
+	if b1 {
+		x := new(int) // ERROR "stack object x \*int$"
+		*x = 42
+		z = &x
+	} else {
+		y := new(int) // ERROR "stack object y \*int$"
+		*y = 54
+		z = &y
+	}
+	printint(**z) // nothing live here
+}
+
+// confusion about the _ result used to cause spurious "live at entry to f6: _".
+
+func f6() (_, y string) {
+	y = "hello"
+	return
+}
+
+// confusion about addressed results used to cause "live at entry to f7: x".
+
+func f7() (x string) { // ERROR "stack object x string"
+	_ = &x
+	x = "hello"
+	return
+}
+
+// ignoring block returns used to cause "live at entry to f8: x, y".
+
+func f8() (x, y string) {
+	return g8()
+}
+
+func g8() (string, string)
+
+// ignoring block assignments used to cause "live at entry to f9: x"
+// issue 7205
+
+var i9 interface{}
+
+func f9() bool {
+	g8()
+	x := i9
+	y := interface{}(g18()) // ERROR "live at call to convT2E: x.data$" "live at call to g18: x.data$" "stack object .autotmp_[0-9]+ \[2\]string$"
+	i9 = y                  // make y escape so the line above has to call convT2E
+	return x != y
+}
+
+// liveness formerly confused by UNDEF followed by RET,
+// leading to "live at entry to f10: ~r1" (unnamed result).
+
+func f10() string {
+	panic(1)
+}
+
+// liveness formerly confused by select, thinking runtime.selectgo
+// can return to next instruction; it always jumps elsewhere.
+// note that you have to use at least two cases in the select
+// to get a true select; smaller selects compile to optimized helper functions.
+
+var c chan *int
+var b bool
+
+// this used to have a spurious "live at entry to f11a: ~r0"
+func f11a() *int {
+	select { // ERROR "stack object .autotmp_[0-9]+ \[2\]struct"
+	case <-c:
+		return nil
+	case <-c:
+		return nil
+	}
+}
+
+func f11b() *int {
+	p := new(int)
+	if b {
+		// At this point p is dead: the code here cannot
+		// get to the bottom of the function.
+		// This used to have a spurious "live at call to printint: p".
+		printint(1) // nothing live here!
+		select {    // ERROR "stack object .autotmp_[0-9]+ \[2\]struct"
+		case <-c:
+			return nil
+		case <-c:
+			return nil
+		}
+	}
+	println(*p)
+	return nil
+}
+
+var sink *int
+
+func f11c() *int {
+	p := new(int)
+	sink = p // prevent stack allocation, otherwise p is rematerializeable
+	if b {
+		// Unlike previous, the cases in this select fall through,
+		// so we can get to the println, so p is not dead.
+		printint(1) // ERROR "live at call to printint: p$"
+		select {    // ERROR "live at call to selectgo: p$" "stack object .autotmp_[0-9]+ \[2\]struct"
+		case <-c:
+		case <-c:
+		}
+	}
+	println(*p)
+	return nil
+}
+
+// similarly, select{} does not fall through.
+// this used to have a spurious "live at entry to f12: ~r0".
+
+func f12() *int {
+	if b {
+		select {}
+	} else {
+		return nil
+	}
+}
+
+// incorrectly placed VARDEF annotations can cause missing liveness annotations.
+// this used to be missing the fact that s is live during the call to g13 (because it is
+// needed for the call to h13).
+
+func f13() {
+	s := g14()
+	s = h13(s, g13(s)) // ERROR "live at call to g13: s.ptr$"
+}
+
+func g13(string) string
+func h13(string, string) string
+
+// more incorrectly placed VARDEF.
+
+func f14() {
+	x := g14() // ERROR "stack object x string$"
+	printstringpointer(&x)
+}
+
+func g14() string
+
+// Checking that various temporaries do not persist or cause
+// ambiguously live values that must be zeroed.
+// The exact temporary names are inconsequential but we are
+// trying to check that there is only one at any given site,
+// and also that none show up in "ambiguously live" messages.
+
+var m map[string]int
+var mi map[interface{}]int
+
+// str and iface are used to ensure that a temp is required for runtime calls below.
+func str() string
+func iface() interface{}
+
+func f16() {
+	if b {
+		delete(mi, iface()) // ERROR "stack object .autotmp_[0-9]+ interface \{\}$"
+	}
+	delete(mi, iface())
+	delete(mi, iface())
+}
+
+var m2s map[string]*byte
+var m2 map[[2]string]*byte
+var x2 [2]string
+var bp *byte
+
+func f17a(p *byte) { // ERROR "live at entry to f17a: p$"
+	if b {
+		m2[x2] = p // ERROR "live at call to mapassign: p$"
+	}
+	m2[x2] = p // ERROR "live at call to mapassign: p$"
+	m2[x2] = p // ERROR "live at call to mapassign: p$"
+}
+
+func f17b(p *byte) { // ERROR "live at entry to f17b: p$"
+	// key temporary
+	if b {
+		m2s[str()] = p // ERROR "live at call to mapassign_faststr: p$" "live at call to str: p$"
+	}
+	m2s[str()] = p // ERROR "live at call to mapassign_faststr: p$" "live at call to str: p$"
+	m2s[str()] = p // ERROR "live at call to mapassign_faststr: p$" "live at call to str: p$"
+}
+
+func f17c() {
+	// key and value temporaries
+	if b {
+		m2s[str()] = f17d() // ERROR "live at call to f17d: .autotmp_[0-9]+$" "live at call to mapassign_faststr: .autotmp_[0-9]+$"
+	}
+	m2s[str()] = f17d() // ERROR "live at call to f17d: .autotmp_[0-9]+$" "live at call to mapassign_faststr: .autotmp_[0-9]+$"
+	m2s[str()] = f17d() // ERROR "live at call to f17d: .autotmp_[0-9]+$" "live at call to mapassign_faststr: .autotmp_[0-9]+$"
+}
+
+func f17d() *byte
+
+func g18() [2]string
+
+func f18() {
+	// key temporary for mapaccess.
+	// temporary introduced by orderexpr.
+	var z *byte
+	if b {
+		z = m2[g18()] // ERROR "stack object .autotmp_[0-9]+ \[2\]string$"
+	}
+	z = m2[g18()]
+	z = m2[g18()]
+	printbytepointer(z)
+}
+
+var ch chan *byte
+
+// byteptr is used to ensure that a temp is required for runtime calls below.
+func byteptr() *byte
+
+func f19() {
+	// dest temporary for channel receive.
+	var z *byte
+
+	if b {
+		z = <-ch // ERROR "stack object .autotmp_[0-9]+ \*byte$"
+	}
+	z = <-ch
+	z = <-ch // ERROR "live at call to chanrecv1: .autotmp_[0-9]+$"
+	printbytepointer(z)
+}
+
+func f20() {
+	// src temporary for channel send
+	if b {
+		ch <- byteptr() // ERROR "stack object .autotmp_[0-9]+ \*byte$"
+	}
+	ch <- byteptr()
+	ch <- byteptr()
+}
+
+func f21() {
+	// key temporary for mapaccess using array literal key.
+	var z *byte
+	if b {
+		z = m2[[2]string{"x", "y"}] // ERROR "stack object .autotmp_[0-9]+ \[2\]string$"
+	}
+	z = m2[[2]string{"x", "y"}]
+	z = m2[[2]string{"x", "y"}]
+	printbytepointer(z)
+}
+
+func f23() {
+	// key temporary for two-result map access using array literal key.
+	var z *byte
+	var ok bool
+	if b {
+		z, ok = m2[[2]string{"x", "y"}] // ERROR "stack object .autotmp_[0-9]+ \[2\]string$"
+	}
+	z, ok = m2[[2]string{"x", "y"}]
+	z, ok = m2[[2]string{"x", "y"}]
+	printbytepointer(z)
+	print(ok)
+}
+
+func f24() {
+	// key temporary for map access using array literal key.
+	// value temporary too.
+	if b {
+		m2[[2]string{"x", "y"}] = nil // ERROR "stack object .autotmp_[0-9]+ \[2\]string$"
+	}
+	m2[[2]string{"x", "y"}] = nil
+	m2[[2]string{"x", "y"}] = nil
+}
+
+// Non-open-coded defers should not cause autotmps.  (Open-coded defers do create extra autotmps).
+func f25(b bool) {
+	for i := 0; i < 2; i++ {
+		// Put in loop to make sure defer is not open-coded
+		defer g25()
+	}
+	if b {
+		return
+	}
+	var x string
+	x = g14()
+	printstring(x)
+	return
+}
+
+func g25()
+
+// non-escaping ... slices passed to function call should die on return,
+// so that the temporaries do not stack and do not cause ambiguously
+// live variables.
+
+func f26(b bool) {
+	if b {
+		print26((*int)(nil), (*int)(nil), (*int)(nil)) // ERROR "stack object .autotmp_[0-9]+ \[3\]interface \{\}$"
+	}
+	print26((*int)(nil), (*int)(nil), (*int)(nil))
+	print26((*int)(nil), (*int)(nil), (*int)(nil))
+	printnl()
+}
+
+//go:noescape
+func print26(...interface{})
+
+// non-escaping closures passed to function call should die on return
+
+func f27(b bool) {
+	x := 0
+	if b {
+		call27(func() { x++ }) // ERROR "stack object .autotmp_[0-9]+ struct \{"
+	}
+	call27(func() { x++ })
+	call27(func() { x++ })
+	printnl()
+}
+
+// but defer does escape to later execution in the function
+
+func f27defer(b bool) {
+	x := 0
+	if b {
+		defer call27(func() { x++ }) // ERROR "stack object .autotmp_[0-9]+ struct \{"
+	}
+	defer call27(func() { x++ }) // ERROR "stack object .autotmp_[0-9]+ struct \{"
+	printnl()                    // ERROR "live at call to printnl: .autotmp_[0-9]+ .autotmp_[0-9]+"
+	return                       // ERROR "live at indirect call: .autotmp_[0-9]+"
+}
+
+// and newproc (go) escapes to the heap
+
+func f27go(b bool) {
+	x := 0
+	if b {
+		go call27(func() { x++ }) // ERROR "live at call to newobject: &x$" "live at call to newobject: &x .autotmp_[0-9]+$" "live at call to newproc: &x$" // allocate two closures, the func literal, and the wrapper for go
+	}
+	go call27(func() { x++ }) // ERROR "live at call to newobject: &x$" "live at call to newobject: .autotmp_[0-9]+$" // allocate two closures, the func literal, and the wrapper for go
+	printnl()
+}
+
+//go:noescape
+func call27(func())
+
+// concatstring slice should die on return
+
+var s1, s2, s3, s4, s5, s6, s7, s8, s9, s10 string
+
+func f28(b bool) {
+	if b {
+		printstring(s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10) // ERROR "stack object .autotmp_[0-9]+ \[10\]string$"
+	}
+	printstring(s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10)
+	printstring(s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10)
+}
+
+// map iterator should die on end of range loop
+
+func f29(b bool) {
+	if b {
+		for k := range m { // ERROR "live at call to mapiterinit: .autotmp_[0-9]+$" "live at call to mapiternext: .autotmp_[0-9]+$" "stack object .autotmp_[0-9]+ map.iter\[string\]int$"
+			printstring(k) // ERROR "live at call to printstring: .autotmp_[0-9]+$"
+		}
+	}
+	for k := range m { // ERROR "live at call to mapiterinit: .autotmp_[0-9]+$" "live at call to mapiternext: .autotmp_[0-9]+$"
+		printstring(k) // ERROR "live at call to printstring: .autotmp_[0-9]+$"
+	}
+	for k := range m { // ERROR "live at call to mapiterinit: .autotmp_[0-9]+$" "live at call to mapiternext: .autotmp_[0-9]+$"
+		printstring(k) // ERROR "live at call to printstring: .autotmp_[0-9]+$"
+	}
+}
+
+// copy of array of pointers should die at end of range loop
+var pstructarr [10]pstruct
+
+// Struct size chosen to make pointer to element in pstructarr
+// not computable by strength reduction.
+type pstruct struct {
+	intp *int
+	_    [8]byte
+}
+
+func f30(b bool) {
+	// live temp during printintpointer(p):
+	// the internal iterator pointer if a pointer to pstruct in pstructarr
+	// can not be easily computed by strength reduction.
+	if b {
+		for _, p := range pstructarr { // ERROR "stack object .autotmp_[0-9]+ \[10\]pstruct$"
+			printintpointer(p.intp) // ERROR "live at call to printintpointer: .autotmp_[0-9]+$"
+		}
+	}
+	for _, p := range pstructarr {
+		printintpointer(p.intp) // ERROR "live at call to printintpointer: .autotmp_[0-9]+$"
+	}
+	for _, p := range pstructarr {
+		printintpointer(p.intp) // ERROR "live at call to printintpointer: .autotmp_[0-9]+$"
+	}
+}
+
+// conversion to interface should not leave temporary behind
+
+func f31(b1, b2, b3 bool) {
+	if b1 {
+		g31(g18()) // ERROR "stack object .autotmp_[0-9]+ \[2\]string$"
+	}
+	if b2 {
+		h31(g18()) // ERROR "live at call to convT2E: .autotmp_[0-9]+$" "live at call to newobject: .autotmp_[0-9]+$"
+	}
+	if b3 {
+		panic(g18())
+	}
+	print(b3)
+}
+
+func g31(interface{})
+func h31(...interface{})
+
+// non-escaping partial functions passed to function call should die on return
+
+type T32 int
+
+func (t *T32) Inc() { // ERROR "live at entry to \(\*T32\).Inc: t$"
+	*t++
+}
+
+var t32 T32
+
+func f32(b bool) {
+	if b {
+		call32(t32.Inc) // ERROR "stack object .autotmp_[0-9]+ struct \{"
+	}
+	call32(t32.Inc)
+	call32(t32.Inc)
+}
+
+//go:noescape
+func call32(func())
+
+// temporaries introduced during if conditions and && || expressions
+// should die once the condition has been acted upon.
+
+var m33 map[interface{}]int
+
+func f33() {
+	if m33[byteptr()] == 0 { // ERROR "stack object .autotmp_[0-9]+ interface \{\}$"
+		printnl()
+		return
+	} else {
+		printnl()
+	}
+	printnl()
+}
+
+func f34() {
+	if m33[byteptr()] == 0 { // ERROR "stack object .autotmp_[0-9]+ interface \{\}$"
+		printnl()
+		return
+	}
+	printnl()
+}
+
+func f35() {
+	if m33[byteptr()] == 0 && // ERROR "stack object .autotmp_[0-9]+ interface \{\}"
+		m33[byteptr()] == 0 { // ERROR "stack object .autotmp_[0-9]+ interface \{\}"
+		printnl()
+		return
+	}
+	printnl()
+}
+
+func f36() {
+	if m33[byteptr()] == 0 || // ERROR "stack object .autotmp_[0-9]+ interface \{\}"
+		m33[byteptr()] == 0 { // ERROR "stack object .autotmp_[0-9]+ interface \{\}"
+		printnl()
+		return
+	}
+	printnl()
+}
+
+func f37() {
+	if (m33[byteptr()] == 0 || // ERROR "stack object .autotmp_[0-9]+ interface \{\}"
+		m33[byteptr()] == 0) && // ERROR "stack object .autotmp_[0-9]+ interface \{\}"
+		m33[byteptr()] == 0 {
+		printnl()
+		return
+	}
+	printnl()
+}
+
+// select temps should disappear in the case bodies
+
+var c38 chan string
+
+func fc38() chan string
+func fi38(int) *string
+func fb38() *bool
+
+func f38(b bool) {
+	// we don't care what temps are printed on the lines with output.
+	// we care that the println lines have no live variables
+	// and therefore no output.
+	if b {
+		select { // ERROR "live at call to selectgo:( .autotmp_[0-9]+)+$" "stack object .autotmp_[0-9]+ \[4\]struct \{"
+		case <-fc38():
+			printnl()
+		case fc38() <- *fi38(1): // ERROR "live at call to fc38:( .autotmp_[0-9]+)+$" "live at call to fi38:( .autotmp_[0-9]+)+$" "stack object .autotmp_[0-9]+ string$"
+			printnl()
+		case *fi38(2) = <-fc38(): // ERROR "live at call to fc38:( .autotmp_[0-9]+)+$" "live at call to fi38:( .autotmp_[0-9]+)+$" "stack object .autotmp_[0-9]+ string$"
+			printnl()
+		case *fi38(3), *fb38() = <-fc38(): // ERROR "stack object .autotmp_[0-9]+ string$" "live at call to fc38:( .autotmp_[0-9]+)+$" "live at call to fi38:( .autotmp_[0-9]+)+$"
+			printnl()
+		}
+		printnl()
+	}
+	printnl()
+}
+
+// issue 8097: mishandling of x = x during return.
+
+func f39() (x []int) {
+	x = []int{1}
+	printnl() // ERROR "live at call to printnl: .autotmp_[0-9]+$"
+	return x
+}
+
+func f39a() (x []int) {
+	x = []int{1}
+	printnl() // ERROR "live at call to printnl: .autotmp_[0-9]+$"
+	return
+}
+
+func f39b() (x [10]*int) {
+	x = [10]*int{}
+	x[0] = new(int) // ERROR "live at call to newobject: x$"
+	printnl()       // ERROR "live at call to printnl: x$"
+	return x
+}
+
+func f39c() (x [10]*int) {
+	x = [10]*int{}
+	x[0] = new(int) // ERROR "live at call to newobject: x$"
+	printnl()       // ERROR "live at call to printnl: x$"
+	return
+}
+
+// issue 8142: lost 'addrtaken' bit on inlined variables.
+// no inlining in this test, so just checking that non-inlined works.
+
+type T40 struct {
+	m map[int]int
+}
+
+//go:noescape
+func useT40(*T40)
+
+func newT40() *T40 {
+	ret := T40{}
+	ret.m = make(map[int]int, 42) // ERROR "live at call to makemap: &ret$"
+	return &ret
+}
+
+func bad40() {
+	t := newT40()
+	_ = t
+	printnl()
+}
+
+func good40() {
+	ret := T40{}              // ERROR "stack object ret T40$"
+	ret.m = make(map[int]int) // ERROR "live at call to fastrand: .autotmp_[0-9]+$" "stack object .autotmp_[0-9]+ map.hdr\[int\]int$"
+	t := &ret
+	printnl() // ERROR "live at call to printnl: ret$"
+	// Note: ret is live at the printnl because the compiler moves &ret
+	// from before the printnl to after.
+	useT40(t)
+}
+
+func ddd1(x, y *int) { // ERROR "live at entry to ddd1: x y$"
+	ddd2(x, y) // ERROR "stack object .autotmp_[0-9]+ \[2\]\*int$"
+	printnl()
+	// Note: no .?autotmp live at printnl.  See issue 16996.
+}
+func ddd2(a ...*int) { // ERROR "live at entry to ddd2: a$"
+	sink = a[0]
+}
+
+// issue 16016: autogenerated wrapper should have arguments live
+type T struct{}
+
+func (*T) Foo(ptr *int) {}
+
+type R struct{ *T } // ERRORAUTO "live at entry to \(\*R\)\.Foo: \.this ptr" "live at entry to R\.Foo: \.this ptr"
+
+// issue 18860: output arguments must be live all the time if there is a defer.
+// In particular, at printint r must be live.
+func f41(p, q *int) (r *int) { // ERROR "live at entry to f41: p q$"
+	r = p
+	defer func() {
+		recover()
+	}()
+	printint(0) // ERROR "live at call to printint: q .autotmp_[0-9]+ r$"
+	r = q
+	return // ERROR "live at call to f41.func1: .autotmp_[0-9]+ r$"
+}
+
+func f42() {
+	var p, q, r int
+	f43([]*int{&p, &q, &r}) // ERROR "stack object .autotmp_[0-9]+ \[3\]\*int$"
+	f43([]*int{&p, &r, &q})
+	f43([]*int{&q, &p, &r})
+}
+
+//go:noescape
+func f43(a []*int)
+
+// Assigning to a sub-element that makes up an entire local variable
+// should clobber that variable.
+func f44(f func() [2]*int) interface{} { // ERROR "live at entry to f44: f"
+	type T struct {
+		s [1][2]*int
+	}
+	ret := T{}
+	ret.s[0] = f()
+	return ret // ERROR "stack object .autotmp_[0-9]+ T"
+}
-- 
GitLab


From b21e739f871d9dc119dccfba82622bfb18227391 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Sat, 17 Apr 2021 00:56:34 -0400
Subject: [PATCH 1639/2400] test: add test for CL 310589

Change-Id: Iff0876bd17c2a93db72dc90678f3a46ef8effd74
Reviewed-on: https://go-review.googlesource.com/c/go/+/311370
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
---
 test/abi/result_live.go | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 test/abi/result_live.go

diff --git a/test/abi/result_live.go b/test/abi/result_live.go
new file mode 100644
index 0000000000..2be54e3868
--- /dev/null
+++ b/test/abi/result_live.go
@@ -0,0 +1,20 @@
+// errorcheck -0 -live
+
+// Copyright 2021 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 p
+
+type T struct { a, b, c, d string } // pass in registers, not SSA-able
+
+//go:registerparams
+func F() (r T) {
+	r.a = g(1) // ERROR "live at call to g: r"
+	r.b = g(2) // ERROR "live at call to g: r"
+	r.c = g(3) // ERROR "live at call to g: r"
+	r.d = g(4) // ERROR "live at call to g: r"
+	return
+}
+
+func g(int) string
-- 
GitLab


From 6b8e3e2d060b009fe92b39f7022445d96e225325 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Sat, 17 Apr 2021 22:50:13 -0400
Subject: [PATCH 1640/2400] cmd/compile: reduce redundant register moves for
 regabi calls

Currently, if we have AX=a and BX=b, and we want to make a call
F(1, a, b), to move arguments into the desired registers it emits

	MOVQ AX, CX
	MOVL $1, AX // AX=1
	MOVQ BX, DX
	MOVQ CX, BX // BX=a
	MOVQ DX, CX // CX=b

This has a few redundant moves.

This is because we process inputs in order. First, allocate 1 to
AX, which kicks out a (in AX) to CX (a free register at the
moment). Then, allocate a to BX, which kicks out b (in BX) to DX.
Finally, put b to CX.

Notice that if we start with allocating CX=b, then BX=a, AX=1,
we will not have redundant moves. This CL reduces redundant moves
by allocating them in different order: First, for inpouts that are
already in place, keep them there. Then allocate free registers.
Then everything else.

                             before       after
cmd/compile binary size     23703888    23609680
            text size        8565899     8533291

(with regabiargs enabled.)

Change-Id: I69e1bdf745f2c90bb791f6d7c45b37384af1e874
Reviewed-on: https://go-review.googlesource.com/c/go/+/311371
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/ssa/regalloc.go | 54 ++++++++++++++++++++++--
 test/codegen/regabi_regalloc.go          | 23 ++++++++++
 2 files changed, 73 insertions(+), 4 deletions(-)
 create mode 100644 test/codegen/regabi_regalloc.go

diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go
index 336cd3d737..8ddb3d045b 100644
--- a/src/cmd/compile/internal/ssa/regalloc.go
+++ b/src/cmd/compile/internal/ssa/regalloc.go
@@ -1377,12 +1377,58 @@ func (s *regAllocState) regalloc(f *Func) {
 				}
 			}
 
-			// Move arguments to registers. Process in an ordering defined
+			// Move arguments to registers.
+			// First, if an arg must be in a specific register and it is already
+			// in place, keep it.
+			args = append(args[:0], make([]*Value, len(v.Args))...)
+			for i, a := range v.Args {
+				if !s.values[a.ID].needReg {
+					args[i] = a
+				}
+			}
+			for _, i := range regspec.inputs {
+				mask := i.regs
+				if countRegs(mask) == 1 && mask&s.values[v.Args[i.idx].ID].regs != 0 {
+					args[i.idx] = s.allocValToReg(v.Args[i.idx], mask, true, v.Pos)
+				}
+			}
+			// Then, if an arg must be in a specific register and that
+			// register is free, allocate that one. Otherwise when processing
+			// another input we may kick a value into the free register, which
+			// then will be kicked out again.
+			// This is a common case for passing-in-register arguments for
+			// function calls.
+			for {
+				freed := false
+				for _, i := range regspec.inputs {
+					if args[i.idx] != nil {
+						continue // already allocated
+					}
+					mask := i.regs
+					if countRegs(mask) == 1 && mask&^s.used != 0 {
+						args[i.idx] = s.allocValToReg(v.Args[i.idx], mask, true, v.Pos)
+						// If the input is in other registers that will be clobbered by v,
+						// or the input is dead, free the registers. This may make room
+						// for other inputs.
+						oldregs := s.values[v.Args[i.idx].ID].regs
+						if oldregs&^regspec.clobbers == 0 || !s.liveAfterCurrentInstruction(v.Args[i.idx]) {
+							s.freeRegs(oldregs &^ mask &^ s.nospill)
+							freed = true
+						}
+					}
+				}
+				if !freed {
+					break
+				}
+			}
+			// Last, allocate remaining ones, in an ordering defined
 			// by the register specification (most constrained first).
-			args = append(args[:0], v.Args...)
 			for _, i := range regspec.inputs {
+				if args[i.idx] != nil {
+					continue // already allocated
+				}
 				mask := i.regs
-				if mask&s.values[args[i.idx].ID].regs == 0 {
+				if mask&s.values[v.Args[i.idx].ID].regs == 0 {
 					// Need a new register for the input.
 					mask &= s.allocatable
 					mask &^= s.nospill
@@ -1401,7 +1447,7 @@ func (s *regAllocState) regalloc(f *Func) {
 						mask &^= desired.avoid
 					}
 				}
-				args[i.idx] = s.allocValToReg(args[i.idx], mask, true, v.Pos)
+				args[i.idx] = s.allocValToReg(v.Args[i.idx], mask, true, v.Pos)
 			}
 
 			// If the output clobbers the input register, make sure we have
diff --git a/test/codegen/regabi_regalloc.go b/test/codegen/regabi_regalloc.go
new file mode 100644
index 0000000000..a7b7bd52bc
--- /dev/null
+++ b/test/codegen/regabi_regalloc.go
@@ -0,0 +1,23 @@
+// asmcheck
+
+// Copyright 2021 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 codegen
+
+//go:registerparams
+func f1(a, b int) {
+	// amd64:"MOVQ\tBX, CX", "MOVQ\tAX, BX", "MOVL\t\\$1, AX", -"MOVQ\t.*DX"
+	g(1, a, b)
+}
+
+//go:registerparams
+func f2(a, b int) {
+	// amd64:"MOVQ\tBX, AX", "MOVQ\t[AB]X, CX", -"MOVQ\t.*, BX"
+	g(b, b, b)
+}
+
+//go:noinline
+//go:registerparams
+func g(int, int, int) {}
-- 
GitLab


From 5780ab4f605fdf0ca7f12ebc08e80d3ac170e98a Mon Sep 17 00:00:00 2001
From: Ariel Mashraki <ariel@mashraki.co.il>
Date: Sun, 14 Mar 2021 19:04:31 +0200
Subject: [PATCH 1641/2400] text/template/parse: add a mode to skip func-check
 on parsing

Following the discussion on #34652 and the proposal of #36911 (gopls),
this CL adds an option to skip the function declartion check on parsing,
in order to make it possible to parse arbitrary template text files and
get their AST.

Fixed #38627

Change-Id: Id1e0360fc726b49dcdd49716ce25563ebaae6c10
Reviewed-on: https://go-review.googlesource.com/c/go/+/301493
Reviewed-by: Rob Pike <r@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Ian Lance Taylor <iant@golang.org>
---
 src/text/template/parse/parse.go      |  6 ++++--
 src/text/template/parse/parse_test.go | 16 ++++++++++++++++
 2 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/src/text/template/parse/parse.go b/src/text/template/parse/parse.go
index 5e6e512eb4..ff1358b001 100644
--- a/src/text/template/parse/parse.go
+++ b/src/text/template/parse/parse.go
@@ -38,7 +38,8 @@ type Tree struct {
 type Mode uint
 
 const (
-	ParseComments Mode = 1 << iota // parse comments and add them to AST
+	ParseComments  Mode = 1 << iota // parse comments and add them to AST
+	DeferFuncCheck                  // defer type checking functions until template is executed
 )
 
 // Copy returns a copy of the Tree. Any parsing state is discarded.
@@ -689,7 +690,8 @@ func (t *Tree) operand() Node {
 func (t *Tree) term() Node {
 	switch token := t.nextNonSpace(); token.typ {
 	case itemIdentifier:
-		if !t.hasFunction(token.val) {
+		checkFunc := t.Mode&DeferFuncCheck == 0
+		if checkFunc && !t.hasFunction(token.val) {
 			t.errorf("function %q not defined", token.val)
 		}
 		return NewIdentifier(token.val).SetTree(t).SetPos(token.pos)
diff --git a/src/text/template/parse/parse_test.go b/src/text/template/parse/parse_test.go
index 220f984777..c4585f6912 100644
--- a/src/text/template/parse/parse_test.go
+++ b/src/text/template/parse/parse_test.go
@@ -379,6 +379,22 @@ func TestParseWithComments(t *testing.T) {
 	}
 }
 
+func TestDeferFuncCheck(t *testing.T) {
+	oldTextFormat := textFormat
+	textFormat = "%q"
+	defer func() { textFormat = oldTextFormat }()
+	tr := New("defer func check")
+	tr.Mode = DeferFuncCheck
+	tmpl, err := tr.Parse("{{fn 1 2}}", "", "", make(map[string]*Tree))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	expected := "{{fn 1 2}}"
+	if result := tmpl.Root.String(); result != expected {
+		t.Errorf("got\n\t%v\nexpected\n\t%v", result, expected)
+	}
+}
+
 type isEmptyTest struct {
 	name  string
 	input string
-- 
GitLab


From f8892147bdfd16fe7ef04eccf59c4abf774550f1 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Mon, 19 Apr 2021 13:58:07 -0400
Subject: [PATCH 1642/2400] runtime: open up space for callee's arg spill slot
 in mcall (regabi version)

mcall calls fn with an argument. Currently, in the regabi version
of mcall it does not reserve space for that argument's spill slot.
If the callee spills its argument, it may clobber things on the
g0 stack at 0(SP) (e.g. the old SP saved in cgocallback).

Reserve the space.

Change-Id: I85a314273cd996c7fac8fd0b03cd9033faae9c5a
Reviewed-on: https://go-review.googlesource.com/c/go/+/311489
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/asm_amd64.s | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index ca6b1501d1..1e6d8189c9 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -302,8 +302,10 @@ goodm:
 	get_tls(CX)		// Set G in TLS
 	MOVQ	R14, g(CX)
 	MOVQ	(g_sched+gobuf_sp)(R14), SP	// sp = g0.sched.sp
+	PUSHQ	AX	// open up space for fn's arg spill slot
 	MOVQ	0(DX), R12
 	CALL	R12		// fn(g)
+	POPQ	AX
 	JMP	runtime·badmcall2(SB)
 	RET
 #else
-- 
GitLab


From bbb510ccc96e2ca1d0d1c91d244fba4e735d5a80 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Wed, 14 Apr 2021 12:37:04 -0400
Subject: [PATCH 1643/2400] internal/buildcfg: enable regabig by default

For #40724.

Change-Id: Ibf4ff8b24b501813839657ac195b909682ac7d0b
Reviewed-on: https://go-review.googlesource.com/c/go/+/310173
Trust: Austin Clements <austin@google.com>
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/internal/buildcfg/exp.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/internal/buildcfg/exp.go b/src/internal/buildcfg/exp.go
index bf4a8fa977..f3903be862 100644
--- a/src/internal/buildcfg/exp.go
+++ b/src/internal/buildcfg/exp.go
@@ -27,6 +27,7 @@ var regabiSupported = GOARCH == "amd64" && (GOOS == "linux" || GOOS == "darwin"
 // configuration and any variation from this is an experiment.
 var experimentBaseline = goexperiment.Flags{
 	RegabiWrappers: regabiSupported,
+	RegabiG:        regabiSupported,
 }
 
 // FramePointerEnabled enables the use of platform conventions for
-- 
GitLab


From e97d8eb027c0067f757860b6f766644de15941f2 Mon Sep 17 00:00:00 2001
From: HowJMay <vulxj0j8j8@gmail.com>
Date: Mon, 19 Apr 2021 18:06:54 +0000
Subject: [PATCH 1644/2400] net: pass MSG_CMSG_CLOEXEC flag in ReadMsgUnix

As mentioned in #42765, calling "recvmsg" syscall on Linux should come
with "MSG_CMSG_CLOEXEC" flag.

For other systems which not supports "MSG_CMSG_CLOEXEC". ReadMsgUnix()
would check the header. If the header type is "syscall.SCM_RIGHTS",
then ReadMsgUnix() would parse the SocketControlMessage and call each
fd with "syscall.CloseOnExec"

Fixes #42765

Change-Id: I74347db72b465685d7684bf0f32415d285845ebb
GitHub-Last-Rev: ca59e2c9e0e8de1ae590e9b6dc165cb768a574f5
GitHub-Pull-Request: golang/go#42768
Reviewed-on: https://go-review.googlesource.com/c/go/+/272226
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/internal/poll/fd_unix.go      |   6 +-
 src/internal/poll/fd_windows.go   |   3 +-
 src/net/fd_posix.go               |   6 +-
 src/net/iprawsock_posix.go        |   2 +-
 src/net/net_fake.go               |   2 +-
 src/net/udpsock_posix.go          |   2 +-
 src/net/unixsock_posix.go         |   6 +-
 src/net/unixsock_readmsg_linux.go |  17 +++++
 src/net/unixsock_readmsg_other.go |  13 ++++
 src/net/unixsock_readmsg_posix.go |  33 ++++++++++
 src/net/unixsock_readmsg_test.go  | 105 ++++++++++++++++++++++++++++++
 src/syscall/creds_test.go         |   4 +-
 12 files changed, 186 insertions(+), 13 deletions(-)
 create mode 100644 src/net/unixsock_readmsg_linux.go
 create mode 100644 src/net/unixsock_readmsg_other.go
 create mode 100644 src/net/unixsock_readmsg_posix.go
 create mode 100644 src/net/unixsock_readmsg_test.go

diff --git a/src/internal/poll/fd_unix.go b/src/internal/poll/fd_unix.go
index fe8a5c8ec0..3b17cd22b0 100644
--- a/src/internal/poll/fd_unix.go
+++ b/src/internal/poll/fd_unix.go
@@ -231,7 +231,7 @@ func (fd *FD) ReadFrom(p []byte) (int, syscall.Sockaddr, error) {
 }
 
 // ReadMsg wraps the recvmsg network call.
-func (fd *FD) ReadMsg(p []byte, oob []byte) (int, int, int, syscall.Sockaddr, error) {
+func (fd *FD) ReadMsg(p []byte, oob []byte, flags int) (int, int, int, syscall.Sockaddr, error) {
 	if err := fd.readLock(); err != nil {
 		return 0, 0, 0, nil, err
 	}
@@ -240,7 +240,7 @@ func (fd *FD) ReadMsg(p []byte, oob []byte) (int, int, int, syscall.Sockaddr, er
 		return 0, 0, 0, nil, err
 	}
 	for {
-		n, oobn, flags, sa, err := syscall.Recvmsg(fd.Sysfd, p, oob, 0)
+		n, oobn, sysflags, sa, err := syscall.Recvmsg(fd.Sysfd, p, oob, flags)
 		if err != nil {
 			if err == syscall.EINTR {
 				continue
@@ -253,7 +253,7 @@ func (fd *FD) ReadMsg(p []byte, oob []byte) (int, int, int, syscall.Sockaddr, er
 			}
 		}
 		err = fd.eofError(n, err)
-		return n, oobn, flags, sa, err
+		return n, oobn, sysflags, sa, err
 	}
 }
 
diff --git a/src/internal/poll/fd_windows.go b/src/internal/poll/fd_windows.go
index d8c834f929..4a5169527c 100644
--- a/src/internal/poll/fd_windows.go
+++ b/src/internal/poll/fd_windows.go
@@ -1013,7 +1013,7 @@ func sockaddrToRaw(sa syscall.Sockaddr) (unsafe.Pointer, int32, error) {
 }
 
 // ReadMsg wraps the WSARecvMsg network call.
-func (fd *FD) ReadMsg(p []byte, oob []byte) (int, int, int, syscall.Sockaddr, error) {
+func (fd *FD) ReadMsg(p []byte, oob []byte, flags int) (int, int, int, syscall.Sockaddr, error) {
 	if err := fd.readLock(); err != nil {
 		return 0, 0, 0, nil, err
 	}
@@ -1028,6 +1028,7 @@ func (fd *FD) ReadMsg(p []byte, oob []byte) (int, int, int, syscall.Sockaddr, er
 	o.rsa = new(syscall.RawSockaddrAny)
 	o.msg.Name = (syscall.Pointer)(unsafe.Pointer(o.rsa))
 	o.msg.Namelen = int32(unsafe.Sizeof(*o.rsa))
+	o.msg.Flags = uint32(flags)
 	n, err := execIO(o, func(o *operation) error {
 		return windows.WSARecvMsg(o.fd.Sysfd, &o.msg, &o.qty, &o.o, nil)
 	})
diff --git a/src/net/fd_posix.go b/src/net/fd_posix.go
index 2945e46a48..4703ff33a1 100644
--- a/src/net/fd_posix.go
+++ b/src/net/fd_posix.go
@@ -64,10 +64,10 @@ func (fd *netFD) readFrom(p []byte) (n int, sa syscall.Sockaddr, err error) {
 	return n, sa, wrapSyscallError(readFromSyscallName, err)
 }
 
-func (fd *netFD) readMsg(p []byte, oob []byte) (n, oobn, flags int, sa syscall.Sockaddr, err error) {
-	n, oobn, flags, sa, err = fd.pfd.ReadMsg(p, oob)
+func (fd *netFD) readMsg(p []byte, oob []byte, flags int) (n, oobn, retflags int, sa syscall.Sockaddr, err error) {
+	n, oobn, retflags, sa, err = fd.pfd.ReadMsg(p, oob, flags)
 	runtime.KeepAlive(fd)
-	return n, oobn, flags, sa, wrapSyscallError(readMsgSyscallName, err)
+	return n, oobn, retflags, sa, wrapSyscallError(readMsgSyscallName, err)
 }
 
 func (fd *netFD) Write(p []byte) (nn int, err error) {
diff --git a/src/net/iprawsock_posix.go b/src/net/iprawsock_posix.go
index c1514f1698..b94eec0e18 100644
--- a/src/net/iprawsock_posix.go
+++ b/src/net/iprawsock_posix.go
@@ -75,7 +75,7 @@ func stripIPv4Header(n int, b []byte) int {
 
 func (c *IPConn) readMsg(b, oob []byte) (n, oobn, flags int, addr *IPAddr, err error) {
 	var sa syscall.Sockaddr
-	n, oobn, flags, sa, err = c.fd.readMsg(b, oob)
+	n, oobn, flags, sa, err = c.fd.readMsg(b, oob, 0)
 	switch sa := sa.(type) {
 	case *syscall.SockaddrInet4:
 		addr = &IPAddr{IP: sa.Addr[0:]}
diff --git a/src/net/net_fake.go b/src/net/net_fake.go
index 49dc57c6ff..74fc1da6fd 100644
--- a/src/net/net_fake.go
+++ b/src/net/net_fake.go
@@ -268,7 +268,7 @@ func (fd *netFD) readFrom(p []byte) (n int, sa syscall.Sockaddr, err error) {
 	return 0, nil, syscall.ENOSYS
 }
 
-func (fd *netFD) readMsg(p []byte, oob []byte) (n, oobn, flags int, sa syscall.Sockaddr, err error) {
+func (fd *netFD) readMsg(p []byte, oob []byte, flags int) (n, oobn, retflags int, sa syscall.Sockaddr, err error) {
 	return 0, 0, 0, nil, syscall.ENOSYS
 }
 
diff --git a/src/net/udpsock_posix.go b/src/net/udpsock_posix.go
index 3b5346e573..fcfb9c004c 100644
--- a/src/net/udpsock_posix.go
+++ b/src/net/udpsock_posix.go
@@ -56,7 +56,7 @@ func (c *UDPConn) readFrom(b []byte, addr *UDPAddr) (int, *UDPAddr, error) {
 
 func (c *UDPConn) readMsg(b, oob []byte) (n, oobn, flags int, addr *UDPAddr, err error) {
 	var sa syscall.Sockaddr
-	n, oobn, flags, sa, err = c.fd.readMsg(b, oob)
+	n, oobn, flags, sa, err = c.fd.readMsg(b, oob, 0)
 	switch sa := sa.(type) {
 	case *syscall.SockaddrInet4:
 		addr = &UDPAddr{IP: sa.Addr[0:], Port: sa.Port}
diff --git a/src/net/unixsock_posix.go b/src/net/unixsock_posix.go
index 1d1f27449f..0306b5989b 100644
--- a/src/net/unixsock_posix.go
+++ b/src/net/unixsock_posix.go
@@ -113,7 +113,11 @@ func (c *UnixConn) readFrom(b []byte) (int, *UnixAddr, error) {
 
 func (c *UnixConn) readMsg(b, oob []byte) (n, oobn, flags int, addr *UnixAddr, err error) {
 	var sa syscall.Sockaddr
-	n, oobn, flags, sa, err = c.fd.readMsg(b, oob)
+	n, oobn, flags, sa, err = c.fd.readMsg(b, oob, readMsgFlags)
+	if oobn > 0 {
+		setReadMsgCloseOnExec(oob[:oobn])
+	}
+
 	switch sa := sa.(type) {
 	case *syscall.SockaddrUnix:
 		if sa.Name != "" {
diff --git a/src/net/unixsock_readmsg_linux.go b/src/net/unixsock_readmsg_linux.go
new file mode 100644
index 0000000000..3296681017
--- /dev/null
+++ b/src/net/unixsock_readmsg_linux.go
@@ -0,0 +1,17 @@
+// Copyright 2021 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.
+
+//go:build linux
+// +build linux
+
+package net
+
+import (
+	"syscall"
+)
+
+const readMsgFlags = syscall.MSG_CMSG_CLOEXEC
+
+func setReadMsgCloseOnExec(oob []byte) {
+}
diff --git a/src/net/unixsock_readmsg_other.go b/src/net/unixsock_readmsg_other.go
new file mode 100644
index 0000000000..c8db657cd6
--- /dev/null
+++ b/src/net/unixsock_readmsg_other.go
@@ -0,0 +1,13 @@
+// Copyright 2021 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.
+
+//go:build (js && wasm) || windows
+// +build js,wasm windows
+
+package net
+
+const readMsgFlags = 0
+
+func setReadMsgCloseOnExec(oob []byte) {
+}
diff --git a/src/net/unixsock_readmsg_posix.go b/src/net/unixsock_readmsg_posix.go
new file mode 100644
index 0000000000..07d7df5e66
--- /dev/null
+++ b/src/net/unixsock_readmsg_posix.go
@@ -0,0 +1,33 @@
+// Copyright 2021 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.
+
+//go:build aix || darwin || dragonfly || freebsd || netbsd || openbsd || solaris
+// +build aix darwin dragonfly freebsd netbsd openbsd solaris
+
+package net
+
+import (
+	"syscall"
+)
+
+const readMsgFlags = 0
+
+func setReadMsgCloseOnExec(oob []byte) {
+	scms, err := syscall.ParseSocketControlMessage(oob)
+	if err != nil {
+		return
+	}
+
+	for _, scm := range scms {
+		if scm.Header.Level == syscall.SOL_SOCKET && scm.Header.Type == syscall.SCM_RIGHTS {
+			fds, err := syscall.ParseUnixRights(&scm)
+			if err != nil {
+				continue
+			}
+			for _, fd := range fds {
+				syscall.CloseOnExec(fd)
+			}
+		}
+	}
+}
diff --git a/src/net/unixsock_readmsg_test.go b/src/net/unixsock_readmsg_test.go
new file mode 100644
index 0000000000..4961ecbe10
--- /dev/null
+++ b/src/net/unixsock_readmsg_test.go
@@ -0,0 +1,105 @@
+// Copyright 2021 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.
+
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
+// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
+
+package net
+
+import (
+	"os"
+	"syscall"
+	"testing"
+	"time"
+)
+
+func TestUnixConnReadMsgUnixSCMRightsCloseOnExec(t *testing.T) {
+	if !testableNetwork("unix") {
+		t.Skip("not unix system")
+	}
+
+	scmFile, err := os.Open(os.DevNull)
+	if err != nil {
+		t.Fatalf("file open: %v", err)
+	}
+	defer scmFile.Close()
+
+	rights := syscall.UnixRights(int(scmFile.Fd()))
+	fds, err := syscall.Socketpair(syscall.AF_LOCAL, syscall.SOCK_STREAM, 0)
+	if err != nil {
+		t.Fatalf("Socketpair: %v", err)
+	}
+
+	writeFile := os.NewFile(uintptr(fds[0]), "write-socket")
+	defer writeFile.Close()
+	readFile := os.NewFile(uintptr(fds[1]), "read-socket")
+	defer readFile.Close()
+
+	cw, err := FileConn(writeFile)
+	if err != nil {
+		t.Fatalf("FileConn: %v", err)
+	}
+	defer cw.Close()
+	cr, err := FileConn(readFile)
+	if err != nil {
+		t.Fatalf("FileConn: %v", err)
+	}
+	defer cr.Close()
+
+	ucw, ok := cw.(*UnixConn)
+	if !ok {
+		t.Fatalf("got %T; want UnixConn", cw)
+	}
+	ucr, ok := cr.(*UnixConn)
+	if !ok {
+		t.Fatalf("got %T; want UnixConn", cr)
+	}
+
+	oob := make([]byte, syscall.CmsgSpace(4))
+	err = ucw.SetWriteDeadline(time.Now().Add(5 * time.Second))
+	if err != nil {
+		t.Fatalf("Can't set unix connection timeout: %v", err)
+	}
+	_, _, err = ucw.WriteMsgUnix(nil, rights, nil)
+	if err != nil {
+		t.Fatalf("UnixConn readMsg: %v", err)
+	}
+	err = ucr.SetReadDeadline(time.Now().Add(5 * time.Second))
+	if err != nil {
+		t.Fatalf("Can't set unix connection timeout: %v", err)
+	}
+	_, oobn, _, _, err := ucr.ReadMsgUnix(nil, oob)
+	if err != nil {
+		t.Fatalf("UnixConn readMsg: %v", err)
+	}
+
+	scms, err := syscall.ParseSocketControlMessage(oob[:oobn])
+	if err != nil {
+		t.Fatalf("ParseSocketControlMessage: %v", err)
+	}
+	if len(scms) != 1 {
+		t.Fatalf("got scms = %#v; expected 1 SocketControlMessage", scms)
+	}
+	scm := scms[0]
+	gotFds, err := syscall.ParseUnixRights(&scm)
+	if err != nil {
+		t.Fatalf("syscall.ParseUnixRights: %v", err)
+	}
+	if len(gotFds) != 1 {
+		t.Fatalf("got FDs %#v: wanted only 1 fd", gotFds)
+	}
+	defer func() {
+		if err := syscall.Close(int(gotFds[0])); err != nil {
+			t.Fatalf("fail to close gotFds: %v", err)
+		}
+	}()
+
+	flags, _, errno := syscall.Syscall(syscall.SYS_FCNTL, uintptr(gotFds[0]), uintptr(syscall.F_GETFD), 0)
+	if errno != 0 {
+		t.Fatalf("Can't get flags of fd:%#v, with err:%v", gotFds[0], errno)
+	}
+	if flags&syscall.FD_CLOEXEC == 0 {
+		t.Fatalf("got flags %#x, want %#x (FD_CLOEXEC) set", flags, syscall.FD_CLOEXEC)
+	}
+}
diff --git a/src/syscall/creds_test.go b/src/syscall/creds_test.go
index 736b497bc4..c1a8b516e8 100644
--- a/src/syscall/creds_test.go
+++ b/src/syscall/creds_test.go
@@ -105,8 +105,8 @@ func TestSCMCredentials(t *testing.T) {
 		if err != nil {
 			t.Fatalf("ReadMsgUnix: %v", err)
 		}
-		if flags != 0 {
-			t.Fatalf("ReadMsgUnix flags = 0x%x, want 0", flags)
+		if flags != syscall.MSG_CMSG_CLOEXEC {
+			t.Fatalf("ReadMsgUnix flags = %#x, want %#x (MSG_CMSG_CLOEXEC)", flags, syscall.MSG_CMSG_CLOEXEC)
 		}
 		if n != tt.dataLen {
 			t.Fatalf("ReadMsgUnix n = %d, want %d", n, tt.dataLen)
-- 
GitLab


From bc5de81e70f9572d7b1d63040c95b999dac57f50 Mon Sep 17 00:00:00 2001
From: Michael Fraenkel <michael.fraenkel@gmail.com>
Date: Mon, 12 Apr 2021 18:34:04 -0600
Subject: [PATCH 1645/2400] testing: remove data races so that parallel
 benchmarks can safely call .Fatal* and .Skip*

Protects the usages of (*common).finished with locks
to prevent data races, thus allowing benchmarks to safely invoke
.Fatal* and .Skip* concurrently.

Fixes #45526

Change-Id: I2b4846f525c426d6c7d3418f8f6c86446adbf986
Reviewed-on: https://go-review.googlesource.com/c/go/+/309572
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/testing/benchmark.go      |  7 +++++--
 src/testing/benchmark_test.go | 24 ++++++++++++++++++++++++
 src/testing/testing.go        | 26 ++++++++++++++++----------
 3 files changed, 45 insertions(+), 12 deletions(-)

diff --git a/src/testing/benchmark.go b/src/testing/benchmark.go
index a8f75e9712..15b4426c5a 100644
--- a/src/testing/benchmark.go
+++ b/src/testing/benchmark.go
@@ -238,12 +238,15 @@ func (b *B) run1() bool {
 	}
 	// Only print the output if we know we are not going to proceed.
 	// Otherwise it is printed in processBench.
-	if atomic.LoadInt32(&b.hasSub) != 0 || b.finished {
+	b.mu.RLock()
+	finished := b.finished
+	b.mu.RUnlock()
+	if atomic.LoadInt32(&b.hasSub) != 0 || finished {
 		tag := "BENCH"
 		if b.skipped {
 			tag = "SKIP"
 		}
-		if b.chatty != nil && (len(b.output) > 0 || b.finished) {
+		if b.chatty != nil && (len(b.output) > 0 || finished) {
 			b.trimOutput()
 			fmt.Fprintf(b.w, "--- %s: %s\n%s", tag, b.name, b.output)
 		}
diff --git a/src/testing/benchmark_test.go b/src/testing/benchmark_test.go
index 4c1cbd1933..3b1dc8275b 100644
--- a/src/testing/benchmark_test.go
+++ b/src/testing/benchmark_test.go
@@ -102,6 +102,30 @@ func TestRunParallelFail(t *testing.T) {
 	})
 }
 
+func TestRunParallelFatal(t *testing.T) {
+	testing.Benchmark(func(b *testing.B) {
+		b.RunParallel(func(pb *testing.PB) {
+			for pb.Next() {
+				if b.N > 1 {
+					b.Fatal("error")
+				}
+			}
+		})
+	})
+}
+
+func TestRunParallelSkipNow(t *testing.T) {
+	testing.Benchmark(func(b *testing.B) {
+		b.RunParallel(func(pb *testing.PB) {
+			for pb.Next() {
+				if b.N > 1 {
+					b.SkipNow()
+				}
+			}
+		})
+	})
+}
+
 func ExampleB_RunParallel() {
 	// Parallel benchmark for text/template.Template.Execute on a single object.
 	testing.Benchmark(func(b *testing.B) {
diff --git a/src/testing/testing.go b/src/testing/testing.go
index 851b118df4..2146195956 100644
--- a/src/testing/testing.go
+++ b/src/testing/testing.go
@@ -395,10 +395,10 @@ type common struct {
 	cleanups    []func()             // optional functions to be called at the end of the test
 	cleanupName string               // Name of the cleanup function.
 	cleanupPc   []uintptr            // The stack trace at the point where Cleanup was called.
+	finished    bool                 // Test function has completed.
 
 	chatty     *chattyPrinter // A copy of chattyPrinter, if the chatty flag is set.
 	bench      bool           // Whether the current test is a benchmark.
-	finished   bool           // Test function has completed.
 	hasSub     int32          // Written atomically.
 	raceErrors int            // Number of races detected during test.
 	runner     string         // Function name of tRunner running the test.
@@ -738,7 +738,9 @@ func (c *common) FailNow() {
 	// it would run on a test failure. Because we send on c.signal during
 	// a top-of-stack deferred function now, we know that the send
 	// only happens after any other stacked defers have completed.
+	c.mu.Lock()
 	c.finished = true
+	c.mu.Unlock()
 	runtime.Goexit()
 }
 
@@ -837,15 +839,11 @@ func (c *common) Skipf(format string, args ...interface{}) {
 // other goroutines created during the test. Calling SkipNow does not stop
 // those other goroutines.
 func (c *common) SkipNow() {
-	c.skip()
-	c.finished = true
-	runtime.Goexit()
-}
-
-func (c *common) skip() {
 	c.mu.Lock()
-	defer c.mu.Unlock()
 	c.skipped = true
+	c.finished = true
+	c.mu.Unlock()
+	runtime.Goexit()
 }
 
 // Skipped reports whether the test was skipped.
@@ -1138,10 +1136,16 @@ func tRunner(t *T, fn func(t *T)) {
 		err := recover()
 		signal := true
 
-		if !t.finished && err == nil {
+		t.mu.RLock()
+		finished := t.finished
+		t.mu.RUnlock()
+		if !finished && err == nil {
 			err = errNilPanicOrGoexit
 			for p := t.parent; p != nil; p = p.parent {
-				if p.finished {
+				p.mu.RLock()
+				finished = p.finished
+				p.mu.RUnlock()
+				if finished {
 					t.Errorf("%v: subtest may have called FailNow on a parent test", err)
 					err = nil
 					signal = false
@@ -1235,7 +1239,9 @@ func tRunner(t *T, fn func(t *T)) {
 	fn(t)
 
 	// code beyond here will not be executed when FailNow is invoked
+	t.mu.Lock()
 	t.finished = true
+	t.mu.Unlock()
 }
 
 // Run runs f as a subtest of t called name. It runs f in a separate goroutine
-- 
GitLab


From 88655480f349ca07f523191112e52a49629cca8b Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Wed, 14 Apr 2021 12:37:04 -0400
Subject: [PATCH 1646/2400] internal/buildcfg: enable regabireflect by default

For #40724.

Change-Id: Ib3e4a67c3826176f0d51619754270022344ee194
Reviewed-on: https://go-review.googlesource.com/c/go/+/310174
Trust: Austin Clements <austin@google.com>
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/internal/buildcfg/exp.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/internal/buildcfg/exp.go b/src/internal/buildcfg/exp.go
index f3903be862..e0d02b9d46 100644
--- a/src/internal/buildcfg/exp.go
+++ b/src/internal/buildcfg/exp.go
@@ -28,6 +28,7 @@ var regabiSupported = GOARCH == "amd64" && (GOOS == "linux" || GOOS == "darwin"
 var experimentBaseline = goexperiment.Flags{
 	RegabiWrappers: regabiSupported,
 	RegabiG:        regabiSupported,
+	RegabiReflect:  regabiSupported,
 }
 
 // FramePointerEnabled enables the use of platform conventions for
-- 
GitLab


From 7252e1e5b6c99189dadb525a0793344ad9d137d5 Mon Sep 17 00:00:00 2001
From: Michael Hudson-Doyle <michael.hudson@canonical.com>
Date: Thu, 15 Apr 2021 15:50:41 +1200
Subject: [PATCH 1647/2400] cmd/link: convert -I foo to
 -Wl,--dynamic-linker,foo when externally linking

Fixes #22446

Change-Id: Id5b3fbc9cd3a7d6c4bf4e28428b8cb6d45a9ca92
Reviewed-on: https://go-review.googlesource.com/c/go/+/310349
Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/cmd/link/internal/ld/lib.go | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index b814a277e6..c840e5ea51 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -1431,6 +1431,14 @@ func (ctxt *Link) hostlink() {
 		argv = append(argv, fmt.Sprintf("-Wl,-rpath,%s", rpath.val))
 	}
 
+	if *flagInterpreter != "" {
+		// Many linkers support both -I and the --dynamic-linker flags
+		// to set the ELF interpreter, but lld only supports
+		// --dynamic-linker so prefer that (ld on very old Solaris only
+		// supports -I but that seems less important).
+		argv = append(argv, fmt.Sprintf("-Wl,--dynamic-linker,%s", *flagInterpreter))
+	}
+
 	// Force global symbols to be exported for dlopen, etc.
 	if ctxt.IsELF {
 		argv = append(argv, "-rdynamic")
-- 
GitLab


From 62cad233a62d59366dc3721bd8f97b388f02ee58 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Mon, 8 Mar 2021 17:02:12 -0500
Subject: [PATCH 1648/2400] go/types: remove stale commented-out testdata

Change-Id: I44b191204b05cd44ab6e3c662ddd05596aa3af1a
Reviewed-on: https://go-review.googlesource.com/c/go/+/299831
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/testdata/typeparams.go2 | 29 ----------------------------
 1 file changed, 29 deletions(-)

diff --git a/src/go/types/testdata/typeparams.go2 b/src/go/types/testdata/typeparams.go2
index bb7f016a83..1577ad6f8d 100644
--- a/src/go/types/testdata/typeparams.go2
+++ b/src/go/types/testdata/typeparams.go2
@@ -431,32 +431,3 @@ func _[P interface{}] (x P) {
 func _[P any] (x P) {
 	x.m /* ERROR type bound for P has no method m */ ()
 }
-
-// automatic distinguishing between array and generic types
-// NOTE: Disabled when using unified parameter list syntax.
-/*
-const P = 10
-type A1 [P]byte
-func _(a A1) {
-        assert(len(a) == 10)
-}
-
-type A2 [P]struct{
-        f [P]byte
-}
-func _(a A2) {
-        assert(len(a) == 10)
-        assert(len(a[0].f) == 10)
-}
-
-type A3 [P]func(x [P]A3)
-func _(a A3) {
-        assert(len(a) == 10)
-}
-
-type T2[P] struct{ P }
-var _ T2[int]
-
-type T3[P] func(P)
-var _ T3[int]
-*/
-- 
GitLab


From b3a5640397e887514a860b9eb73e125c2b650f7b Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Mon, 8 Mar 2021 23:38:42 -0500
Subject: [PATCH 1649/2400] go/types: remove the concept of finals

Checker.finals and the corresponding atEnd were added in CL 191418 as a
mechanism to postpone interface type comparison until after all
interfaces were complete. In the intervening CL 195837 we've adopted a
convention of ensuring that interfaces are complete before comparing
them. Since then we've also added the additional case of expansion for
lazily resolving syntax.

Checker.later defers resolution of types until points in the checking
pass where all reachable types can be fully type checked, so the concept
of finals should no longer be necessary.

Change-Id: I58818c1a6b605dccc9b0ecb3a1f6859c138175d5
Reviewed-on: https://go-review.googlesource.com/c/go/+/299590
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/check.go   | 21 ---------------------
 src/go/types/typexpr.go | 12 ++++++------
 2 files changed, 6 insertions(+), 27 deletions(-)

diff --git a/src/go/types/check.go b/src/go/types/check.go
index 69e9466a8b..b28481d7bd 100644
--- a/src/go/types/check.go
+++ b/src/go/types/check.go
@@ -104,7 +104,6 @@ type Checker struct {
 	methods  map[*TypeName][]*Func // maps package scope type names to associated non-blank (non-interface) methods
 	untyped  map[ast.Expr]exprInfo // map of expressions without final type
 	delayed  []func()              // stack of delayed action segments; segments are processed in FIFO order
-	finals   []func()              // list of final actions; processed at the end of type-checking the current set of files
 	objPath  []Object              // path of object dependencies during type inference (for cycle reporting)
 
 	// context within which the current object is type-checked
@@ -144,14 +143,6 @@ func (check *Checker) later(f func()) {
 	check.delayed = append(check.delayed, f)
 }
 
-// atEnd adds f to the list of actions processed at the end
-// of type-checking, before initialization order computation.
-// Actions added by atEnd are processed after any actions
-// added by later.
-func (check *Checker) atEnd(f func()) {
-	check.finals = append(check.finals, f)
-}
-
 // push pushes obj onto the object path and returns its index in the path.
 func (check *Checker) push(obj Object) int {
 	check.objPath = append(check.objPath, obj)
@@ -212,7 +203,6 @@ func (check *Checker) initFiles(files []*ast.File) {
 	check.methods = nil
 	check.untyped = nil
 	check.delayed = nil
-	check.finals = nil
 
 	// determine package name and collect valid files
 	pkg := check.pkg
@@ -269,7 +259,6 @@ func (check *Checker) checkFiles(files []*ast.File) (err error) {
 	check.packageObjects()
 
 	check.processDelayed(0) // incl. all functions
-	check.processFinals()
 
 	check.initOrder()
 
@@ -308,16 +297,6 @@ func (check *Checker) processDelayed(top int) {
 	check.delayed = check.delayed[:top]
 }
 
-func (check *Checker) processFinals() {
-	n := len(check.finals)
-	for _, f := range check.finals {
-		f() // must not append to check.finals
-	}
-	if len(check.finals) != n {
-		panic("internal error: final action list grew")
-	}
-}
-
 func (check *Checker) recordUntyped() {
 	if !debug && check.Types == nil {
 		return // nothing to do
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index e6846545c6..5185c33fcb 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -140,7 +140,7 @@ func (check *Checker) ordinaryType(pos positioner, typ Type) {
 	// while we are in the middle of type-checking parameter declarations that
 	// might belong to interface methods. Delay this check to the end of
 	// type-checking.
-	check.atEnd(func() {
+	check.later(func() {
 		if t := asInterface(typ); t != nil {
 			check.completeInterface(pos.Pos(), t) // TODO(gri) is this the correct position?
 			if t.allTypes != nil {
@@ -531,7 +531,7 @@ func (check *Checker) typInternal(e0 ast.Expr, def *Named) (T Type) {
 		//
 		// Delay this check because it requires fully setup types;
 		// it is safe to continue in any case (was issue 6667).
-		check.atEnd(func() {
+		check.later(func() {
 			if !Comparable(typ.key) {
 				var why string
 				if asTypeParam(typ.key) != nil {
@@ -635,7 +635,7 @@ func (check *Checker) instantiatedType(x ast.Expr, targs []ast.Expr, def *Named)
 
 	// make sure we check instantiation works at least once
 	// and that the resulting type is valid
-	check.atEnd(func() {
+	check.later(func() {
 		t := typ.expand()
 		check.validType(t, nil)
 	})
@@ -905,7 +905,7 @@ func (check *Checker) completeInterface(pos token.Pos, ityp *Interface) {
 			// If we're pre-go1.14 (overlapping embeddings are not permitted), report that
 			// error here as well (even though we could do it eagerly) because it's the same
 			// error message.
-			check.atEnd(func() {
+			check.later(func() {
 				if !check.allowVersion(m.pkg, 1, 14) || !check.identical(m.typ, other.Type()) {
 					check.errorf(atPos(pos), _DuplicateDecl, "duplicate method %s", m.name)
 					check.errorf(atPos(mpos[other.(*Func)]), _DuplicateDecl, "\tother declaration of %s", m.name) // secondary error, \t indented
@@ -1119,7 +1119,7 @@ func (check *Checker) structType(styp *Struct, e *ast.StructType) {
 			embeddedTyp := typ
 			embeddedPos := f.Type
 
-			check.atEnd(func() {
+			check.later(func() {
 				t, isPtr := deref(embeddedTyp)
 				switch t := optype(t).(type) {
 				case *Basic:
@@ -1177,7 +1177,7 @@ func (check *Checker) collectTypeConstraints(pos token.Pos, types []ast.Expr) []
 	// interfaces, which may not be complete yet. It's ok to do this check at the
 	// end because it's not a requirement for correctness of the code.
 	// Note: This is a quadratic algorithm, but type lists tend to be short.
-	check.atEnd(func() {
+	check.later(func() {
 		for i, t := range list {
 			if t := asInterface(t); t != nil {
 				check.completeInterface(types[i].Pos(), t)
-- 
GitLab


From 3711ea0b5d1bc381bda02ec3fe16369ed997eda6 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Fri, 16 Apr 2021 17:29:38 -0400
Subject: [PATCH 1650/2400] cmd/compile: do not clobber arguments for
 reflect.callReflect and callMethod's ABI wrappers

reflect.callReflect and reflect.callMethod are called from special
functions makeFuncStub and methodValueCall. The runtime expects
that it can find the first argument (ctxt) at 0(SP) in
makeFuncStub and methodValueCall's frame. Normally callReflect and
callMethod already do not modify the argument, and keep it alive.
But the compiler-generated ABI wrappers don't do that. Special
case the wrappers to not clobber its arguments.

Change-Id: I1769f49b81c38eabe452d561001c418352814d86
Reviewed-on: https://go-review.googlesource.com/c/go/+/310889
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/liveness/plive.go | 23 ++++++++++++++++++----
 1 file changed, 19 insertions(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/liveness/plive.go b/src/cmd/compile/internal/liveness/plive.go
index 9eca05b040..424d248590 100644
--- a/src/cmd/compile/internal/liveness/plive.go
+++ b/src/cmd/compile/internal/liveness/plive.go
@@ -146,7 +146,8 @@ type liveness struct {
 	// a part of it is used, but we may not initialize all parts.
 	partLiveArgs map[*ir.Name]bool
 
-	doClobber bool // Whether to clobber dead stack slots in this function.
+	doClobber     bool // Whether to clobber dead stack slots in this function.
+	noClobberArgs bool // Do not clobber function arguments
 }
 
 // Map maps from *ssa.Value to LivenessIndex.
@@ -930,16 +931,27 @@ func (lv *liveness) enableClobber() {
 		// Otherwise, giant functions make this experiment generate too much code.
 		return
 	}
-	if lv.f.Name == "forkAndExecInChild" || lv.f.Name == "wbBufFlush" {
+	if lv.f.Name == "forkAndExecInChild" {
 		// forkAndExecInChild calls vfork on some platforms.
 		// The code we add here clobbers parts of the stack in the child.
 		// When the parent resumes, it is using the same stack frame. But the
 		// child has clobbered stack variables that the parent needs. Boom!
 		// In particular, the sys argument gets clobbered.
-		//
+		return
+	}
+	if lv.f.Name == "wbBufFlush" ||
+		((lv.f.Name == "callReflect" || lv.f.Name == "callMethod") && lv.fn.ABIWrapper()) {
 		// runtime.wbBufFlush must not modify its arguments. See the comments
 		// in runtime/mwbbuf.go:wbBufFlush.
-		return
+		//
+		// reflect.callReflect and reflect.callMethod are called from special
+		// functions makeFuncStub and methodValueCall. The runtime expects
+		// that it can find the first argument (ctxt) at 0(SP) in makeFuncStub
+		// and methodValueCall's frame (see runtime/traceback.go:getArgInfo).
+		// Normally callReflect and callMethod already do not modify the
+		// argument, and keep it alive. But the compiler-generated ABI wrappers
+		// don't do that. Special case the wrappers to not clobber its arguments.
+		lv.noClobberArgs = true
 	}
 	if h := os.Getenv("GOCLOBBERDEADHASH"); h != "" {
 		// Clobber only functions where the hash of the function name matches a pattern.
@@ -1000,6 +1012,9 @@ func clobber(lv *liveness, b *ssa.Block, live bitvec.BitVec) {
 			// tracked dynamically.
 			// Also don't clobber slots that are live for defers (see
 			// the code setting livedefer in epilogue).
+			if lv.noClobberArgs && n.Class == ir.PPARAM {
+				continue
+			}
 			clobberVar(b, n)
 		}
 	}
-- 
GitLab


From 9f87943424df86e501175e10e5e3b8b00dfd03d7 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Mon, 19 Apr 2021 19:10:09 -0400
Subject: [PATCH 1651/2400] go/types: fix panic when using multiple type
 arguments

Fix a panic caused by using type arguments without first unpacking.

This was noticed in the review of CL 300998, but unfortunately not yet
fixed.

Fixes #45635

Change-Id: I8ab1720f3e27a6002bc925f0eea943ec6f778341
Reviewed-on: https://go-review.googlesource.com/c/go/+/311669
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/go/types/expr.go                  | 3 ++-
 src/go/types/fixedbugs/issue45635.go2 | 9 +++++++++
 2 files changed, 11 insertions(+), 1 deletion(-)
 create mode 100644 src/go/types/fixedbugs/issue45635.go2

diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 170761afb3..5576c43819 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -10,6 +10,7 @@ import (
 	"fmt"
 	"go/ast"
 	"go/constant"
+	"go/internal/typeparams"
 	"go/token"
 	"math"
 )
@@ -1435,7 +1436,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 	case *ast.IndexExpr:
 		check.exprOrType(x, e.X)
 		if x.mode == invalid {
-			check.use(e.Index)
+			check.use(typeparams.UnpackExpr(e.Index)...)
 			goto Error
 		}
 
diff --git a/src/go/types/fixedbugs/issue45635.go2 b/src/go/types/fixedbugs/issue45635.go2
new file mode 100644
index 0000000000..1fbe0382ea
--- /dev/null
+++ b/src/go/types/fixedbugs/issue45635.go2
@@ -0,0 +1,9 @@
+// Copyright 2021 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
+
+func main() {
+	some /* ERROR "undeclared name" */ [int, int]()
+}
-- 
GitLab


From 4f5aec46039347c7abc02a10103f35f936f39c2b Mon Sep 17 00:00:00 2001
From: Yury Smolsky <yury@smolsky.by>
Date: Sat, 17 Apr 2021 12:12:28 +0300
Subject: [PATCH 1652/2400] all: remove redundant spaces before . and ,

Change-Id: I6a4bd2544276d0638bddf07ebcf2ee636db30fea
Reviewed-on: https://go-review.googlesource.com/c/go/+/311009
Run-TryBot: Yury Smolsky <yury@smolsky.by>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/cmd/compile/internal/walk/assign.go |  2 +-
 src/crypto/sha512/sha512_test.go        |  2 +-
 src/encoding/asn1/marshal_test.go       |  2 +-
 src/encoding/gob/decoder.go             |  2 +-
 src/go/parser/parser.go                 |  2 +-
 src/go/printer/testdata/parser.go       |  2 +-
 src/hash/crc32/crc32_s390x.s            |  2 +-
 src/math/big/arith_s390x.s              | 10 +++++-----
 8 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/cmd/compile/internal/walk/assign.go b/src/cmd/compile/internal/walk/assign.go
index 8550cfb5c8..4ab219f5ea 100644
--- a/src/cmd/compile/internal/walk/assign.go
+++ b/src/cmd/compile/internal/walk/assign.go
@@ -558,7 +558,7 @@ func appendSlice(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 	return s
 }
 
-// isAppendOfMake reports whether n is of the form append(x , make([]T, y)...).
+// isAppendOfMake reports whether n is of the form append(x, make([]T, y)...).
 // isAppendOfMake assumes n has already been typechecked.
 func isAppendOfMake(n ir.Node) bool {
 	if base.Flag.N != 0 || base.Flag.Cfg.Instrumenting {
diff --git a/src/crypto/sha512/sha512_test.go b/src/crypto/sha512/sha512_test.go
index 74a13331af..0e1528fc69 100644
--- a/src/crypto/sha512/sha512_test.go
+++ b/src/crypto/sha512/sha512_test.go
@@ -788,7 +788,7 @@ func TestMarshalMismatch(t *testing.T) {
 			}
 
 			if err := h2.(encoding.BinaryUnmarshaler).UnmarshalBinary(state); err == nil {
-				t.Errorf("i=%d, j=%d: got no error , expected one: %v", i, j, err)
+				t.Errorf("i=%d, j=%d: got no error, expected one: %v", i, j, err)
 			}
 		}
 	}
diff --git a/src/encoding/asn1/marshal_test.go b/src/encoding/asn1/marshal_test.go
index e3a7d8ff00..f0217ba8a5 100644
--- a/src/encoding/asn1/marshal_test.go
+++ b/src/encoding/asn1/marshal_test.go
@@ -306,7 +306,7 @@ func TestIssue11130(t *testing.T) {
 		return
 	}
 	if !reflect.DeepEqual(v, v1) {
-		t.Errorf("got: %#v data=%q , want : %#v data=%q\n ", v1, data1, v, data)
+		t.Errorf("got: %#v data=%q, want : %#v data=%q\n ", v1, data1, v, data)
 	}
 }
 
diff --git a/src/encoding/gob/decoder.go b/src/encoding/gob/decoder.go
index 7eb3093391..b476aaac93 100644
--- a/src/encoding/gob/decoder.go
+++ b/src/encoding/gob/decoder.go
@@ -218,7 +218,7 @@ func (dec *Decoder) DecodeValue(v reflect.Value) error {
 	return dec.err
 }
 
-// If debug.go is compiled into the program , debugFunc prints a human-readable
+// If debug.go is compiled into the program, debugFunc prints a human-readable
 // representation of the gob data read from r by calling that file's Debug function.
 // Otherwise it is nil.
 var debugFunc func(io.Reader)
diff --git a/src/go/parser/parser.go b/src/go/parser/parser.go
index cddaef350e..a4db57170b 100644
--- a/src/go/parser/parser.go
+++ b/src/go/parser/parser.go
@@ -115,7 +115,7 @@ func (p *parser) next0() {
 	// Because of one-token look-ahead, print the previous token
 	// when tracing as it provides a more readable output. The
 	// very first token (!p.pos.IsValid()) is not initialized
-	// (it is token.ILLEGAL), so don't print it .
+	// (it is token.ILLEGAL), so don't print it.
 	if p.trace && p.pos.IsValid() {
 		s := p.tok.String()
 		switch {
diff --git a/src/go/printer/testdata/parser.go b/src/go/printer/testdata/parser.go
index 80b476cf2e..fc2812adee 100644
--- a/src/go/printer/testdata/parser.go
+++ b/src/go/printer/testdata/parser.go
@@ -231,7 +231,7 @@ func (p *parser) next0() {
 	// Because of one-token look-ahead, print the previous token
 	// when tracing as it provides a more readable output. The
 	// very first token (!p.pos.IsValid()) is not initialized
-	// (it is token.ILLEGAL), so don't print it .
+	// (it is token.ILLEGAL), so don't print it.
 	if p.trace && p.pos.IsValid() {
 		s := p.tok.String()
 		switch {
diff --git a/src/hash/crc32/crc32_s390x.s b/src/hash/crc32/crc32_s390x.s
index a168fad277..8aabc602a7 100644
--- a/src/hash/crc32/crc32_s390x.s
+++ b/src/hash/crc32/crc32_s390x.s
@@ -217,7 +217,7 @@ final_fold:
 	// V2 and XOR the intermediate result, T2(x),  with the value in V1.
 	// The final result is in the rightmost word of V2.
 
-	VUPLLF  V2 , V2
+	VUPLLF  V2, V2
 	VGFMAG  CONST_CRC_POLY, V2, V1, V2
 
 done:
diff --git a/src/math/big/arith_s390x.s b/src/math/big/arith_s390x.s
index caa4db0829..e96480699a 100644
--- a/src/math/big/arith_s390x.s
+++ b/src/math/big/arith_s390x.s
@@ -18,7 +18,7 @@ TEXT ·mulWW(SB), NOSPLIT, $0
 	RET
 
 
-// DI = R3, CX = R4, SI = r10, r8 = r8, r9=r9, r10 = r2 , r11 = r5, r12 = r6, r13 = r7, r14 = r1 (R0 set to 0) + use R11
+// DI = R3, CX = R4, SI = r10, r8 = r8, r9=r9, r10 = r2, r11 = r5, r12 = r6, r13 = r7, r14 = r1 (R0 set to 0) + use R11
 // func addVV(z, x, y []Word) (c Word)
 
 TEXT ·addVV(SB), NOSPLIT, $0
@@ -288,7 +288,7 @@ vectorimpl:
 GLOBL subvectorfacility+0x00(SB), NOPTR, $8
 DATA subvectorfacility+0x00(SB)/8, $·subVV_check(SB)
 
-// DI = R3, CX = R4, SI = r10, r8 = r8, r9=r9, r10 = r2 , r11 = r5, r12 = r6, r13 = r7, r14 = r1 (R0 set to 0) + use R11
+// DI = R3, CX = R4, SI = r10, r8 = r8, r9=r9, r10 = r2, r11 = r5, r12 = r6, r13 = r7, r14 = r1 (R0 set to 0) + use R11
 // func subVV(z, x, y []Word) (c Word)
 // (same as addVV except for SUBC/SUBE instead of ADDC/ADDE and label names)
 TEXT ·subVV_vec(SB), NOSPLIT, $0
@@ -442,7 +442,7 @@ E1:
 	MOVD R4, c+72(FP) // return c
 	RET
 
-// DI = R3, CX = R4, SI = r10, r8 = r8, r9=r9, r10 = r2 , r11 = r5, r12 = r6, r13 = r7, r14 = r1 (R0 set to 0) + use R11
+// DI = R3, CX = R4, SI = r10, r8 = r8, r9=r9, r10 = r2, r11 = r5, r12 = r6, r13 = r7, r14 = r1 (R0 set to 0) + use R11
 // func subVV(z, x, y []Word) (c Word)
 // (same as addVV except for SUBC/SUBE instead of ADDC/ADDE and label names)
 TEXT ·subVV_novec(SB), NOSPLIT, $0
@@ -699,7 +699,7 @@ TEXT ·shlVU(SB), NOSPLIT, $0
 TEXT ·shrVU(SB), NOSPLIT, $0
 	BR ·shrVU_g(SB)
 
-// CX = R4, r8 = r8, r9=r9, r10 = r2 , r11 = r5, DX = r3, AX = r6 , BX = R1 , (R0 set to 0) + use R11 + use R7 for i
+// CX = R4, r8 = r8, r9=r9, r10 = r2, r11 = r5, DX = r3, AX = r6, BX = R1, (R0 set to 0) + use R11 + use R7 for i
 // func mulAddVWW(z, x []Word, y, r Word) (c Word)
 TEXT ·mulAddVWW(SB), NOSPLIT, $0
 	MOVD z+0(FP), R2
@@ -729,7 +729,7 @@ E5:
 	RET
 
 // func addMulVVW(z, x []Word, y Word) (c Word)
-// CX = R4, r8 = r8, r9=r9, r10 = r2 , r11 = r5, AX = r11, DX = R6, r12=r12, BX = R1 , (R0 set to 0) + use R11 + use R7 for i
+// CX = R4, r8 = r8, r9=r9, r10 = r2, r11 = r5, AX = r11, DX = R6, r12=r12, BX = R1, (R0 set to 0) + use R11 + use R7 for i
 TEXT ·addMulVVW(SB), NOSPLIT, $0
 	MOVD z+0(FP), R2
 	MOVD x+24(FP), R8
-- 
GitLab


From 0ccdcb21024271211a64a5bb7e9c3c64d72f2699 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Wed, 14 Apr 2021 23:38:10 -0400
Subject: [PATCH 1653/2400] runtime: crash the GC when clobberdead pointer is
 seen

When -clobberdead compiler flag is set, the compiler inserts
instructions that set dead slots a specific value. If the GC sees
this value as a live pointer, something is probably wrong. Crash.

Only do this on AMD64 for now, as it is the only platform where
compiler's clobberdead mode is implemented. And on AMD64 the
clobberdead address can never be a valid address.

Change-Id: Ica687b132b5d3ba2a062500d13264fa730405d11
Reviewed-on: https://go-review.googlesource.com/c/go/+/310330
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/mbitmap.go | 25 +++++++++++++++++++------
 1 file changed, 19 insertions(+), 6 deletions(-)

diff --git a/src/runtime/mbitmap.go b/src/runtime/mbitmap.go
index 2d12c563b8..32b8db7a50 100644
--- a/src/runtime/mbitmap.go
+++ b/src/runtime/mbitmap.go
@@ -333,6 +333,10 @@ func heapBitsForAddr(addr uintptr) (h heapBits) {
 	return
 }
 
+// clobberdeadPtr is a special value that is used by the compiler to
+// clobber dead stack slots, when -clobberdead flag is set.
+const clobberdeadPtr = uintptr(0xdeaddead | 0xdeaddead<<((^uintptr(0)>>63)*32))
+
 // badPointer throws bad pointer in heap panic.
 func badPointer(s *mspan, p, refBase, refOff uintptr) {
 	// Typically this indicates an incorrect use
@@ -345,13 +349,16 @@ func badPointer(s *mspan, p, refBase, refOff uintptr) {
 	// in allocated spans.
 	printlock()
 	print("runtime: pointer ", hex(p))
-	state := s.state.get()
-	if state != mSpanInUse {
-		print(" to unallocated span")
-	} else {
-		print(" to unused region of span")
+	if s != nil {
+		state := s.state.get()
+		if state != mSpanInUse {
+			print(" to unallocated span")
+		} else {
+			print(" to unused region of span")
+		}
+		print(" span.base()=", hex(s.base()), " span.limit=", hex(s.limit), " span.state=", state)
 	}
-	print(" span.base()=", hex(s.base()), " span.limit=", hex(s.limit), " span.state=", state, "\n")
+	print("\n")
 	if refBase != 0 {
 		print("runtime: found in object at *(", hex(refBase), "+", hex(refOff), ")\n")
 		gcDumpObject("object", refBase, refOff)
@@ -379,6 +386,12 @@ func findObject(p, refBase, refOff uintptr) (base uintptr, s *mspan, objIndex ui
 	// If s is nil, the virtual address has never been part of the heap.
 	// This pointer may be to some mmap'd region, so we allow it.
 	if s == nil {
+		if GOARCH == "amd64" && p == clobberdeadPtr && debug.invalidptr != 0 {
+			// Crash if clobberdeadPtr is seen. Only on AMD64 for now, as
+			// it is the only platform where compiler's clobberdead mode is
+			// implemented. On AMD64 clobberdeadPtr cannot be a valid address.
+			badPointer(s, p, refBase, refOff)
+		}
 		return
 	}
 	// If p is a bad pointer, it may not be in s's bounds.
-- 
GitLab


From fe26dfadc3630617d133b8c94bcb2ccb2e85dc1b Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Mon, 19 Apr 2021 18:39:52 -0700
Subject: [PATCH 1654/2400] net: use syscall.fcntl on libc systems

Should fix the AIX builder.

Change-Id: I3498805fb2eee2f0ad50268b5afbbf091c5f6e63
Reviewed-on: https://go-review.googlesource.com/c/go/+/311650
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/net/fcntl_libc_test.go       | 14 ++++++++++++++
 src/net/fcntl_syscall_test.go    | 21 +++++++++++++++++++++
 src/net/unixsock_readmsg_test.go | 16 ++++++++--------
 3 files changed, 43 insertions(+), 8 deletions(-)
 create mode 100644 src/net/fcntl_libc_test.go
 create mode 100644 src/net/fcntl_syscall_test.go

diff --git a/src/net/fcntl_libc_test.go b/src/net/fcntl_libc_test.go
new file mode 100644
index 0000000000..0320d63a86
--- /dev/null
+++ b/src/net/fcntl_libc_test.go
@@ -0,0 +1,14 @@
+// Copyright 2021 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.
+
+//go:build aix || darwin || solaris
+// +build aix darwin solaris
+
+package net
+
+import _ "unsafe" // for go:linkname
+
+// Implemented in the syscall package.
+//go:linkname fcntl syscall.fcntl
+func fcntl(fd int, cmd int, arg int) (int, error)
diff --git a/src/net/fcntl_syscall_test.go b/src/net/fcntl_syscall_test.go
new file mode 100644
index 0000000000..0f04bb4ed6
--- /dev/null
+++ b/src/net/fcntl_syscall_test.go
@@ -0,0 +1,21 @@
+// Copyright 2021 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.
+
+//go:build dragonfly || freebsd || linux || netbsd || openbsd
+// +build dragonfly freebsd linux netbsd openbsd
+
+package net
+
+import (
+	"internal/syscall/unix"
+	"syscall"
+)
+
+func fcntl(fd int, cmd int, arg int) (int, error) {
+	r, _, e := syscall.Syscall(unix.FcntlSyscall, uintptr(fd), uintptr(cmd), uintptr(arg))
+	if e != 0 {
+		return int(r), syscall.Errno(e)
+	}
+	return int(r), nil
+}
diff --git a/src/net/unixsock_readmsg_test.go b/src/net/unixsock_readmsg_test.go
index 4961ecbe10..a4d2fca69c 100644
--- a/src/net/unixsock_readmsg_test.go
+++ b/src/net/unixsock_readmsg_test.go
@@ -82,22 +82,22 @@ func TestUnixConnReadMsgUnixSCMRightsCloseOnExec(t *testing.T) {
 		t.Fatalf("got scms = %#v; expected 1 SocketControlMessage", scms)
 	}
 	scm := scms[0]
-	gotFds, err := syscall.ParseUnixRights(&scm)
+	gotFDs, err := syscall.ParseUnixRights(&scm)
 	if err != nil {
 		t.Fatalf("syscall.ParseUnixRights: %v", err)
 	}
-	if len(gotFds) != 1 {
-		t.Fatalf("got FDs %#v: wanted only 1 fd", gotFds)
+	if len(gotFDs) != 1 {
+		t.Fatalf("got FDs %#v: wanted only 1 fd", gotFDs)
 	}
 	defer func() {
-		if err := syscall.Close(int(gotFds[0])); err != nil {
-			t.Fatalf("fail to close gotFds: %v", err)
+		if err := syscall.Close(gotFDs[0]); err != nil {
+			t.Fatalf("fail to close gotFDs: %v", err)
 		}
 	}()
 
-	flags, _, errno := syscall.Syscall(syscall.SYS_FCNTL, uintptr(gotFds[0]), uintptr(syscall.F_GETFD), 0)
-	if errno != 0 {
-		t.Fatalf("Can't get flags of fd:%#v, with err:%v", gotFds[0], errno)
+	flags, err := fcntl(gotFDs[0], syscall.F_GETFD, 0)
+	if err != nil {
+		t.Fatalf("Can't get flags of fd:%#v, with err:%v", gotFDs[0], err)
 	}
 	if flags&syscall.FD_CLOEXEC == 0 {
 		t.Fatalf("got flags %#x, want %#x (FD_CLOEXEC) set", flags, syscall.FD_CLOEXEC)
-- 
GitLab


From 3ff6ff7f8476b912ac6746c8e5afca852d62af7a Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Mon, 19 Apr 2021 17:37:25 -0400
Subject: [PATCH 1655/2400] cmd/compile: preserve pointerness when creating map
 key temp

When creating the temporary for map functions, if the key
contains pointer, we need to create pointer-typed temporary. So
if the temporary is live across a function call, the pointer is
live.

Change-Id: Id6e14ec9def8bc7987f0f8ce8423caf1e3754fcb
Reviewed-on: https://go-review.googlesource.com/c/go/+/311379
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/walk/assign.go  | 10 +------
 src/cmd/compile/internal/walk/builtin.go |  5 +---
 src/cmd/compile/internal/walk/expr.go    | 36 ++++++++++++++++--------
 src/cmd/compile/internal/walk/order.go   | 10 ++++---
 test/abi/map.go                          | 34 ++++++++++++++++++++++
 5 files changed, 67 insertions(+), 28 deletions(-)
 create mode 100644 test/abi/map.go

diff --git a/src/cmd/compile/internal/walk/assign.go b/src/cmd/compile/internal/walk/assign.go
index 4ab219f5ea..c8342b4fa4 100644
--- a/src/cmd/compile/internal/walk/assign.go
+++ b/src/cmd/compile/internal/walk/assign.go
@@ -157,15 +157,7 @@ func walkAssignMapRead(init *ir.Nodes, n *ir.AssignListStmt) ir.Node {
 	t := r.X.Type()
 
 	fast := mapfast(t)
-	var key ir.Node
-	if fast != mapslow {
-		// fast versions take key by value
-		key = r.Index
-	} else {
-		// standard version takes key by reference
-		// order.expr made sure key is addressable.
-		key = typecheck.NodAddr(r.Index)
-	}
+	key := mapKeyArg(fast, r, r.Index)
 
 	// from:
 	//   a,b = m[i]
diff --git a/src/cmd/compile/internal/walk/builtin.go b/src/cmd/compile/internal/walk/builtin.go
index b5b24b26ca..684fc7d72a 100644
--- a/src/cmd/compile/internal/walk/builtin.go
+++ b/src/cmd/compile/internal/walk/builtin.go
@@ -214,10 +214,7 @@ func walkDelete(init *ir.Nodes, n *ir.CallExpr) ir.Node {
 
 	t := map_.Type()
 	fast := mapfast(t)
-	if fast == mapslow {
-		// order.stmt made sure key is addressable.
-		key = typecheck.NodAddr(key)
-	}
+	key = mapKeyArg(fast, n, key)
 	return mkcall1(mapfndel(mapdelete[fast], t), nil, init, reflectdata.TypePtr(t), map_, key)
 }
 
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index d8160d971c..6affbd4aec 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -669,6 +669,29 @@ func walkIndex(n *ir.IndexExpr, init *ir.Nodes) ir.Node {
 	return n
 }
 
+// mapKeyArg returns an expression for key that is suitable to be passed
+// as the key argument for mapaccess and mapdelete functions.
+// n is is the map indexing or delete Node (to provide Pos).
+// Note: this is not used for mapassign, which does distinguish pointer vs.
+// integer key.
+func mapKeyArg(fast int, n, key ir.Node) ir.Node {
+	switch fast {
+	case mapslow:
+		// standard version takes key by reference.
+		// order.expr made sure key is addressable.
+		return typecheck.NodAddr(key)
+	case mapfast32ptr:
+		// mapaccess and mapdelete don't distinguish pointer vs. integer key.
+		return ir.NewConvExpr(n.Pos(), ir.OCONVNOP, types.Types[types.TUINT32], key)
+	case mapfast64ptr:
+		// mapaccess and mapdelete don't distinguish pointer vs. integer key.
+		return ir.NewConvExpr(n.Pos(), ir.OCONVNOP, types.Types[types.TUINT64], key)
+	default:
+		// fast version takes key by value.
+		return key
+	}
+}
+
 // walkIndexMap walks an OINDEXMAP node.
 func walkIndexMap(n *ir.IndexExpr, init *ir.Nodes) ir.Node {
 	// Replace m[k] with *map{access1,assign}(maptype, m, &k)
@@ -681,25 +704,16 @@ func walkIndexMap(n *ir.IndexExpr, init *ir.Nodes) ir.Node {
 	if n.Assigned {
 		// This m[k] expression is on the left-hand side of an assignment.
 		fast := mapfast(t)
-		switch fast {
-		case mapslow:
+		if fast == mapslow {
 			// standard version takes key by reference.
 			// order.expr made sure key is addressable.
 			key = typecheck.NodAddr(key)
-		case mapfast32ptr, mapfast64ptr:
-			// pointer version takes pointer key.
-			key = ir.NewConvExpr(n.Pos(), ir.OCONVNOP, types.Types[types.TUNSAFEPTR], key)
 		}
 		call = mkcall1(mapfn(mapassign[fast], t, false), nil, init, reflectdata.TypePtr(t), map_, key)
 	} else {
 		// m[k] is not the target of an assignment.
 		fast := mapfast(t)
-		if fast == mapslow {
-			// standard version takes key by reference.
-			// order.expr made sure key is addressable.
-			key = typecheck.NodAddr(key)
-		}
-
+		key = mapKeyArg(fast, n, key)
 		if w := t.Elem().Width; w <= zeroValSize {
 			call = mkcall1(mapfn(mapaccess1[fast], t, false), types.NewPtr(t.Elem()), init, reflectdata.TypePtr(t), map_, key)
 		} else {
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index 7b69f34e85..dcb8f654f5 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -276,10 +276,12 @@ func (o *orderState) mapKeyTemp(t *types.Type, n ir.Node) ir.Node {
 	}
 	var kt *types.Type
 	switch alg {
-	case mapfast32, mapfast32ptr:
+	case mapfast32:
 		kt = types.Types[types.TUINT32]
-	case mapfast64, mapfast64ptr:
+	case mapfast64:
 		kt = types.Types[types.TUINT64]
+	case mapfast32ptr, mapfast64ptr:
+		kt = types.Types[types.TUNSAFEPTR]
 	case mapfaststr:
 		kt = types.Types[types.TSTRING]
 	}
@@ -287,8 +289,8 @@ func (o *orderState) mapKeyTemp(t *types.Type, n ir.Node) ir.Node {
 	switch {
 	case nt == kt:
 		return n
-	case nt.Kind() == kt.Kind():
-		// can directly convert (e.g. named type to underlying type)
+	case nt.Kind() == kt.Kind(), nt.IsPtrShaped() && kt.IsPtrShaped():
+		// can directly convert (e.g. named type to underlying type, or one pointer to another)
 		return typecheck.Expr(ir.NewConvExpr(n.Pos(), ir.OCONVNOP, kt, n))
 	case nt.IsInteger() && kt.IsInteger():
 		// can directly convert (e.g. int32 to uint32)
diff --git a/test/abi/map.go b/test/abi/map.go
new file mode 100644
index 0000000000..236655a3af
--- /dev/null
+++ b/test/abi/map.go
@@ -0,0 +1,34 @@
+// run
+
+// Copyright 2021 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"
+
+type T [10]int
+
+var m map[*T]int
+
+//go:noinline
+func F() {
+	m = map[*T]int{
+		K(): V(), // the key temp should be live across call to V
+	}
+}
+
+//go:noinline
+func V() int { runtime.GC(); runtime.GC(); runtime.GC(); return 123 }
+
+//go:noinline
+func K() *T {
+	p := new(T)
+	runtime.SetFinalizer(p, func(*T) { println("FAIL") })
+	return p
+}
+
+func main() {
+	F()
+}
-- 
GitLab


From af8a176e911a013ab5054318224a90e5bab67efc Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Wed, 14 Apr 2021 12:37:04 -0400
Subject: [PATCH 1656/2400] internal/buildcfg: enable regabidefer by default

For #40724.

Change-Id: If3a66c0e29cb20dd29ac13c8d00aa46ee279ab97
Reviewed-on: https://go-review.googlesource.com/c/go/+/310175
Trust: Austin Clements <austin@google.com>
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/internal/buildcfg/exp.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/internal/buildcfg/exp.go b/src/internal/buildcfg/exp.go
index e0d02b9d46..7704efa994 100644
--- a/src/internal/buildcfg/exp.go
+++ b/src/internal/buildcfg/exp.go
@@ -29,6 +29,7 @@ var experimentBaseline = goexperiment.Flags{
 	RegabiWrappers: regabiSupported,
 	RegabiG:        regabiSupported,
 	RegabiReflect:  regabiSupported,
+	RegabiDefer:    regabiSupported,
 }
 
 // FramePointerEnabled enables the use of platform conventions for
-- 
GitLab


From 4ce49b4a158b3ace253a3302f6092862c8109a94 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Mon, 19 Apr 2021 17:18:54 -0400
Subject: [PATCH 1657/2400] go/types: support type parameters in NewMethodSet

Add handling for TypeParams in NewMethodSet, to bring it in sync with
lookupFieldOrMethod. Also add a test, since we had none. I wanted this
fix to get gopls completion working with type params, but due to the
subtlety of lookupFieldOrMethod, I left a TODO to confirm that there are
no behavioral differences between the APIs.

Updates #45639

Change-Id: I16723e16d4d944ca4ecb4d87fc196815abb6fcff
Reviewed-on: https://go-review.googlesource.com/c/go/+/311455
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/api_test.go       |   7 +++
 src/go/types/lookup.go         |   2 +
 src/go/types/methodset.go      |  15 +++--
 src/go/types/methodset_test.go | 109 +++++++++++++++++++++++++++++++++
 4 files changed, 129 insertions(+), 4 deletions(-)
 create mode 100644 src/go/types/methodset_test.go

diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go
index a8e29d3fda..6998fc0a0d 100644
--- a/src/go/types/api_test.go
+++ b/src/go/types/api_test.go
@@ -21,6 +21,11 @@ import (
 	. "go/types"
 )
 
+// pkgFor parses and type checks the package specified by path and source,
+// populating info if provided.
+//
+// If source begins with "package generic_" and type parameters are enabled,
+// generic code is permitted.
 func pkgFor(path, source string, info *Info) (*Package, error) {
 	fset := token.NewFileSet()
 	mode := modeForSource(source)
@@ -1213,6 +1218,8 @@ func TestLookupFieldOrMethod(t *testing.T) {
 	// Test cases assume a lookup of the form a.f or x.f, where a stands for an
 	// addressable value, and x for a non-addressable value (even though a variable
 	// for ease of test case writing).
+	//
+	// Should be kept in sync with TestMethodSet.
 	var tests = []struct {
 		src      string
 		found    bool
diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go
index 3691b1ecaa..9c7bfd4bb9 100644
--- a/src/go/types/lookup.go
+++ b/src/go/types/lookup.go
@@ -142,6 +142,8 @@ func (check *Checker) rawLookupFieldOrMethod(T Type, addressable bool, pkg *Pack
 
 				// continue with underlying type, but only if it's not a type parameter
 				// TODO(gri) is this what we want to do for type parameters? (spec question)
+				// TODO(#45639) the error message produced as a result of skipping an
+				//              underlying type parameter should be improved.
 				typ = named.under()
 				if asTypeParam(typ) != nil {
 					continue
diff --git a/src/go/types/methodset.go b/src/go/types/methodset.go
index c44009f1a5..ae8011a2ee 100644
--- a/src/go/types/methodset.go
+++ b/src/go/types/methodset.go
@@ -63,7 +63,7 @@ func (s *MethodSet) Lookup(pkg *Package, name string) *Selection {
 var emptyMethodSet MethodSet
 
 // Note: NewMethodSet is intended for external use only as it
-//       requires interfaces to be complete. If may be used
+//       requires interfaces to be complete. It may be used
 //       internally if LookupFieldOrMethod completed the same
 //       interfaces beforehand.
 
@@ -73,8 +73,8 @@ func NewMethodSet(T Type) *MethodSet {
 	// WARNING: The code in this function is extremely subtle - do not modify casually!
 	//          This function and lookupFieldOrMethod should be kept in sync.
 
-	// TODO(gri) This code is out-of-sync with the lookup code at this point.
-	//           Need to update.
+	// TODO(rfindley) confirm that this code is in sync with lookupFieldOrMethod
+	//                with respect to type params.
 
 	// method set up to the current depth, allocated lazily
 	var base methodSet
@@ -127,8 +127,12 @@ func NewMethodSet(T Type) *MethodSet {
 
 				mset = mset.add(named.methods, e.index, e.indirect, e.multiples)
 
-				// continue with underlying type
+				// continue with underlying type, but only if it's not a type parameter
+				// TODO(rFindley): should this use named.under()? Can there be a difference?
 				typ = named.underlying
+				if _, ok := typ.(*_TypeParam); ok {
+					continue
+				}
 			}
 
 			switch t := typ.(type) {
@@ -154,6 +158,9 @@ func NewMethodSet(T Type) *MethodSet {
 
 			case *Interface:
 				mset = mset.add(t.allMethods, e.index, true, e.multiples)
+
+			case *_TypeParam:
+				mset = mset.add(t.Bound().allMethods, e.index, true, e.multiples)
 			}
 		}
 
diff --git a/src/go/types/methodset_test.go b/src/go/types/methodset_test.go
new file mode 100644
index 0000000000..4a373fa2c4
--- /dev/null
+++ b/src/go/types/methodset_test.go
@@ -0,0 +1,109 @@
+// Copyright 2021 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 types_test
+
+import (
+	"testing"
+
+	"go/internal/typeparams"
+	. "go/types"
+)
+
+func TestNewMethodSet(t *testing.T) {
+	type method struct {
+		name     string
+		index    []int
+		indirect bool
+	}
+
+	// Tests are expressed src -> methods, for simplifying the composite literal.
+	// Should be kept in sync with TestLookupFieldOrMethod.
+	tests := map[string][]method{
+		// Named types
+		"var a T; type T struct{}; func (T) f() {}":   {{"f", []int{0}, false}},
+		"var a *T; type T struct{}; func (T) f() {}":  {{"f", []int{0}, true}},
+		"var a T; type T struct{}; func (*T) f() {}":  {},
+		"var a *T; type T struct{}; func (*T) f() {}": {{"f", []int{0}, true}},
+
+		// Interfaces
+		"var a T; type T interface{ f() }":                           {{"f", []int{0}, true}},
+		"var a T1; type ( T1 T2; T2 interface{ f() } )":              {{"f", []int{0}, true}},
+		"var a T1; type ( T1 interface{ T2 }; T2 interface{ f() } )": {{"f", []int{0}, true}},
+
+		// Embedding
+		"var a struct{ E }; type E interface{ f() }":            {{"f", []int{0, 0}, true}},
+		"var a *struct{ E }; type E interface{ f() }":           {{"f", []int{0, 0}, true}},
+		"var a struct{ E }; type E struct{}; func (E) f() {}":   {{"f", []int{0, 0}, false}},
+		"var a struct{ *E }; type E struct{}; func (E) f() {}":  {{"f", []int{0, 0}, true}},
+		"var a struct{ E }; type E struct{}; func (*E) f() {}":  {},
+		"var a struct{ *E }; type E struct{}; func (*E) f() {}": {{"f", []int{0, 0}, true}},
+
+		// collisions
+		"var a struct{ E1; *E2 }; type ( E1 interface{ f() }; E2 struct{ f int })":            {},
+		"var a struct{ E1; *E2 }; type ( E1 struct{ f int }; E2 struct{} ); func (E2) f() {}": {},
+	}
+
+	genericTests := map[string][]method{
+		// By convention, look up a in the scope of "g"
+		"type C interface{ f() }; func g[T C](a T){}":                       {{"f", []int{0}, true}},
+		"type C interface{ f() }; func g[T C]() { var a T; _ = a }":         {{"f", []int{0}, true}},
+		"type C interface{ f() }; func g[T C]() { var a struct{T}; _ = a }": {{"f", []int{0, 0}, true}},
+
+		// Issue #45639.
+		"type C interface{ f() }; func g[T C]() { type Y T; var a Y; _ = a }": {},
+	}
+
+	check := func(src string, methods []method, generic bool) {
+		pkgName := "p"
+		if generic {
+			// The generic_ prefix causes pkgFor to allow generic code.
+			pkgName = "generic_p"
+		}
+		pkg, err := pkgFor("test", "package "+pkgName+";"+src, nil)
+		if err != nil {
+			t.Errorf("%s: incorrect test case: %s", src, err)
+			return
+		}
+
+		scope := pkg.Scope()
+		if generic {
+			fn := pkg.Scope().Lookup("g").(*Func)
+			scope = fn.Scope()
+		}
+		obj := scope.Lookup("a")
+		if obj == nil {
+			t.Errorf("%s: incorrect test case - no object a", src)
+			return
+		}
+
+		ms := NewMethodSet(obj.Type())
+		if got, want := ms.Len(), len(methods); got != want {
+			t.Errorf("%s: got %d methods, want %d", src, got, want)
+			return
+		}
+		for i, m := range methods {
+			sel := ms.At(i)
+			if got, want := sel.Obj().Name(), m.name; got != want {
+				t.Errorf("%s [method %d]: got name = %q at, want %q", src, i, got, want)
+			}
+			if got, want := sel.Index(), m.index; !sameSlice(got, want) {
+				t.Errorf("%s [method %d]: got index = %v, want %v", src, i, got, want)
+			}
+			if got, want := sel.Indirect(), m.indirect; got != want {
+				t.Errorf("%s [method %d]: got indirect = %v, want %v", src, i, got, want)
+			}
+		}
+	}
+
+	for src, methods := range tests {
+		check(src, methods, false)
+	}
+
+	if typeparams.Enabled {
+		for src, methods := range genericTests {
+			check(src, methods, true)
+		}
+	}
+}
-- 
GitLab


From 24875e3880c1ef7aca6c844c5b28cf32aea5c418 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Mon, 19 Apr 2021 17:49:30 -0400
Subject: [PATCH 1658/2400] cmd/compile/internal/types2: fix some typos in
 rawLookupFieldOrMethod

Change-Id: Ibc04a82b1d618deeb9bc168ba518dbf1d752fba7
Reviewed-on: https://go-review.googlesource.com/c/go/+/311456
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/types2/lookup.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go
index cadaf05ca8..78299502e9 100644
--- a/src/cmd/compile/internal/types2/lookup.go
+++ b/src/cmd/compile/internal/types2/lookup.go
@@ -206,8 +206,8 @@ func (check *Checker) rawLookupFieldOrMethod(T Type, addressable bool, pkg *Pack
 				}
 				if obj == nil {
 					// At this point we're not (yet) looking into methods
-					// that any underlyng type of the types in the type list
-					// migth have.
+					// that any underlying type of the types in the type list
+					// might have.
 					// TODO(gri) Do we want to specify the language that way?
 				}
 			}
-- 
GitLab


From 9dd71ba91397c7f69571ae7f0810d64f2f38547a Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Wed, 14 Apr 2021 12:37:04 -0400
Subject: [PATCH 1659/2400] internal/buildcfg: enable regabiargs by default

For #40724.

Change-Id: I7509668478d20dd625f210e5a33f5d896a76d6b5
Reviewed-on: https://go-review.googlesource.com/c/go/+/310176
Trust: Austin Clements <austin@google.com>
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/internal/buildcfg/exp.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/internal/buildcfg/exp.go b/src/internal/buildcfg/exp.go
index 7704efa994..c3da77d40a 100644
--- a/src/internal/buildcfg/exp.go
+++ b/src/internal/buildcfg/exp.go
@@ -30,6 +30,7 @@ var experimentBaseline = goexperiment.Flags{
 	RegabiG:        regabiSupported,
 	RegabiReflect:  regabiSupported,
 	RegabiDefer:    regabiSupported,
+	RegabiArgs:     regabiSupported,
 }
 
 // FramePointerEnabled enables the use of platform conventions for
-- 
GitLab


From 60ab197bc2bebb0ad25e7f4610c6e4aae71d29e4 Mon Sep 17 00:00:00 2001
From: Michael Pratt <mpratt@google.com>
Date: Tue, 16 Feb 2021 15:50:49 -0500
Subject: [PATCH 1660/2400] runtime: refactor work stealing to dedicated
 function

findrunnable has grown very large and hard to follow over the years.
Parts we can split out into logical chunks should help make it more
understandable and easier to change in the future.

The work stealing loop is one such big chunk that is fairly trivial to
split out into its own function, and even has the advantage of
simplifying control flow by removing a goto around work stealing.

This CL should have no functional changes.

For #43997.
For #44313.

Change-Id: Ie69670c7bc60bd6c114e860184918717829adb22
Reviewed-on: https://go-review.googlesource.com/c/go/+/307913
Trust: Michael Pratt <mpratt@google.com>
Run-TryBot: Michael Pratt <mpratt@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Chris Hines <chris.cs.guy@gmail.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/proc.go | 180 ++++++++++++++++++++++++++------------------
 1 file changed, 105 insertions(+), 75 deletions(-)

diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 2c06b28955..a712b11c4f 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -2681,85 +2681,40 @@ top:
 		}
 	}
 
-	// Steal work from other P's.
+	// Spinning Ms: steal work from other Ps.
+	//
+	// Limit the number of spinning Ms to half the number of busy Ps.
+	// This is necessary to prevent excessive CPU consumption when
+	// GOMAXPROCS>>1 but the program parallelism is low.
 	procs := uint32(gomaxprocs)
-	ranTimer := false
-	// If number of spinning M's >= number of busy P's, block.
-	// This is necessary to prevent excessive CPU consumption
-	// when GOMAXPROCS>>1 but the program parallelism is low.
-	if !_g_.m.spinning && 2*atomic.Load(&sched.nmspinning) >= procs-atomic.Load(&sched.npidle) {
-		goto stop
-	}
-	if !_g_.m.spinning {
-		_g_.m.spinning = true
-		atomic.Xadd(&sched.nmspinning, 1)
-	}
-	const stealTries = 4
-	for i := 0; i < stealTries; i++ {
-		stealTimersOrRunNextG := i == stealTries-1
-
-		for enum := stealOrder.start(fastrand()); !enum.done(); enum.next() {
-			if sched.gcwaiting != 0 {
-				goto top
-			}
-			p2 := allp[enum.position()]
-			if _p_ == p2 {
-				continue
-			}
-
-			// Steal timers from p2. This call to checkTimers is the only place
-			// where we might hold a lock on a different P's timers. We do this
-			// once on the last pass before checking runnext because stealing
-			// from the other P's runnext should be the last resort, so if there
-			// are timers to steal do that first.
-			//
-			// We only check timers on one of the stealing iterations because
-			// the time stored in now doesn't change in this loop and checking
-			// the timers for each P more than once with the same value of now
-			// is probably a waste of time.
-			//
-			// timerpMask tells us whether the P may have timers at all. If it
-			// can't, no need to check at all.
-			if stealTimersOrRunNextG && timerpMask.read(enum.position()) {
-				tnow, w, ran := checkTimers(p2, now)
-				now = tnow
-				if w != 0 && (pollUntil == 0 || w < pollUntil) {
-					pollUntil = w
-				}
-				if ran {
-					// Running the timers may have
-					// made an arbitrary number of G's
-					// ready and added them to this P's
-					// local run queue. That invalidates
-					// the assumption of runqsteal
-					// that is always has room to add
-					// stolen G's. So check now if there
-					// is a local G to run.
-					if gp, inheritTime := runqget(_p_); gp != nil {
-						return gp, inheritTime
-					}
-					ranTimer = true
-				}
-			}
+	if _g_.m.spinning || 2*atomic.Load(&sched.nmspinning) < procs-atomic.Load(&sched.npidle) {
+		if !_g_.m.spinning {
+			_g_.m.spinning = true
+			atomic.Xadd(&sched.nmspinning, 1)
+		}
 
-			// Don't bother to attempt to steal if p2 is idle.
-			if !idlepMask.read(enum.position()) {
-				if gp := runqsteal(_p_, p2, stealTimersOrRunNextG); gp != nil {
-					return gp, false
-				}
-			}
+		gp, inheritTime, tnow, w, newWork := stealWork(now)
+		now = tnow
+		if gp != nil {
+			// Successfully stole.
+			return gp, inheritTime
+		}
+		if newWork {
+			// There may be new timer or GC work; restart to
+			// discover.
+			goto top
+		}
+		if w != 0 && (pollUntil == 0 || w < pollUntil) {
+			// Earlier timer to wait for.
+			pollUntil = w
 		}
 	}
-	if ranTimer {
-		// Running a timer may have made some goroutine ready.
-		goto top
-	}
-
-stop:
 
-	// We have nothing to do. If we're in the GC mark phase, can
-	// safely scan and blacken objects, and have work to do, run
-	// idle-time marking rather than give up the P.
+	// We have nothing to do.
+	//
+	// If we're in the GC mark phase, can safely scan and blacken objects,
+	// and have work to do, run idle-time marking rather than give up the
+	// P.
 	if gcBlackenEnabled != 0 && gcMarkWorkAvailable(_p_) {
 		node := (*gcBgMarkWorkerNode)(gcBgMarkWorkerPool.pop())
 		if node != nil {
@@ -3008,6 +2963,81 @@ func pollWork() bool {
 	return false
 }
 
+// stealWork attempts to steal a runnable goroutine or timer from any P.
+//
+// If newWork is true, new work may have been readied.
+//
+// If now is not 0 it is the current time. stealWork returns the passed time or
+// the current time if now was passed as 0.
+func stealWork(now int64) (gp *g, inheritTime bool, rnow, pollUntil int64, newWork bool) {
+	pp := getg().m.p.ptr()
+
+	ranTimer := false
+
+	const stealTries = 4
+	for i := 0; i < stealTries; i++ {
+		stealTimersOrRunNextG := i == stealTries-1
+
+		for enum := stealOrder.start(fastrand()); !enum.done(); enum.next() {
+			if sched.gcwaiting != 0 {
+				// GC work may be available.
+				return nil, false, now, pollUntil, true
+			}
+			p2 := allp[enum.position()]
+			if pp == p2 {
+				continue
+			}
+
+			// Steal timers from p2. This call to checkTimers is the only place
+			// where we might hold a lock on a different P's timers. We do this
+			// once on the last pass before checking runnext because stealing
+			// from the other P's runnext should be the last resort, so if there
+			// are timers to steal do that first.
+			//
+			// We only check timers on one of the stealing iterations because
+			// the time stored in now doesn't change in this loop and checking
+			// the timers for each P more than once with the same value of now
+			// is probably a waste of time.
+			//
+			// timerpMask tells us whether the P may have timers at all. If it
+			// can't, no need to check at all.
+			if stealTimersOrRunNextG && timerpMask.read(enum.position()) {
+				tnow, w, ran := checkTimers(p2, now)
+				now = tnow
+				if w != 0 && (pollUntil == 0 || w < pollUntil) {
+					pollUntil = w
+				}
+				if ran {
+					// Running the timers may have
+					// made an arbitrary number of G's
+					// ready and added them to this P's
+					// local run queue. That invalidates
+					// the assumption of runqsteal
+					// that it always has room to add
+					// stolen G's. So check now if there
+					// is a local G to run.
+					if gp, inheritTime := runqget(pp); gp != nil {
+						return gp, inheritTime, now, pollUntil, ranTimer
+					}
+					ranTimer = true
+				}
+			}
+
+			// Don't bother to attempt to steal if p2 is idle.
+			if !idlepMask.read(enum.position()) {
+				if gp := runqsteal(pp, p2, stealTimersOrRunNextG); gp != nil {
+					return gp, false, now, pollUntil, ranTimer
+				}
+			}
+		}
+	}
+
+	// No goroutines found to steal. Regardless, running a timer may have
+	// made some goroutine ready that we missed. Indicate the next timer to
+	// wait for.
+	return nil, false, now, pollUntil, ranTimer
+}
+
 // wakeNetPoller wakes up the thread sleeping in the network poller if it isn't
 // going to wake up before the when argument; or it wakes an idle P to service
 // timers and the network poller if there isn't one already.
@@ -3252,7 +3282,7 @@ func dropg() {
 
 // checkTimers runs any timers for the P that are ready.
 // If now is not 0 it is the current time.
-// It returns the current time or 0 if it is not known,
+// It returns the passed time or the current time if now was passed as 0.
 // and the time when the next timer should run or 0 if there is no next timer,
 // and reports whether it ran any timers.
 // If the time when the next timer should run is not 0,
-- 
GitLab


From 109d7580a5c507b1e4f460445a5c4cd7313e4aa6 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 20 Apr 2021 11:59:40 -0400
Subject: [PATCH 1661/2400] cmd/compile: disable name preservation on copies in
 expand_calls

Apparently CL 309330 caused the compiler OOMing on some large
input (giant generated switch statement). I don't quite understand
it for now. Disable it for now.

Change-Id: I19c84f3f5e158897bff0b32d6217fcff3c66874d
Reviewed-on: https://go-review.googlesource.com/c/go/+/311829
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ssa/expand_calls.go | 18 ++++++++++--------
 test/live_regabi.go                          |  5 ++++-
 2 files changed, 14 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index b2b2b5d877..be460457a8 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -1450,15 +1450,17 @@ func expandCalls(f *Func) {
 
 	// Step 6: elide any copies introduced.
 	// Update named values.
-	for _, name := range f.Names {
-		values := f.NamedValues[name]
-		for i, v := range values {
-			if v.Op == OpCopy {
-				a := v.Args[0]
-				for a.Op == OpCopy {
-					a = a.Args[0]
+	if false { // TODO: reeanable. It caused compiler OOMing on large input.
+		for _, name := range f.Names {
+			values := f.NamedValues[name]
+			for i, v := range values {
+				if v.Op == OpCopy {
+					a := v.Args[0]
+					for a.Op == OpCopy {
+						a = a.Args[0]
+					}
+					values[i] = a
 				}
-				values[i] = a
 			}
 		}
 	}
diff --git a/test/live_regabi.go b/test/live_regabi.go
index 2b0278ecb8..af14ede73f 100644
--- a/test/live_regabi.go
+++ b/test/live_regabi.go
@@ -1,5 +1,8 @@
 // errorcheckwithauto -0 -l -live -wb=0 -d=ssa/insert_resched_checks/off
-// +build amd64,goexperiment.regabidefer,goexperiment.regabiargs
+// +build amd64,goexperiment.regabidefer,goexperiment.regabiargs,ignore
+
+// Disabled for now. The compiler sometimes has bad name-value association
+// for args, causing args appears as autotmps.
 
 // Copyright 2014 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
-- 
GitLab


From 77860ad2809d88566d28783e0382073fb9836d9b Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 20 Apr 2021 13:09:54 -0400
Subject: [PATCH 1662/2400] cmd/compile: guard partially live arg spilling with
 number of registers

The code that does partially live in-register arg spilling is
currently guarded with GOEXPERIMENT=regabiargs. But on platforms
where GOEXPERIMENT=regabiargs is not enabled there are still tests
that use register args. Guard it with actual number of registers
used, so it covers both.

Should fix the freeBSD builder.

Change-Id: I0d3c49d7a2389096cb6b17ca35b9b4ce567bc91e
Reviewed-on: https://go-review.googlesource.com/c/go/+/311830
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/ssagen/ssa.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index e7d4865375..c5b1ae2e4a 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -6898,7 +6898,7 @@ func defframe(s *State, e *ssafn, f *ssa.Func) {
 	// and not address-taken (for non-SSA-able or address-taken arguments we always
 	// spill upfront).
 	// TODO(register args) Make liveness more fine-grained to that partial spilling is okay.
-	if buildcfg.Experiment.RegabiArgs {
+	if f.OwnAux.ABIInfo().InRegistersUsed() != 0 {
 		// First, see if it is already spilled before it may be live. Look for a spill
 		// in the entry block up to the first safepoint.
 		type nameOff struct {
-- 
GitLab


From fbb600b28349a41742d35f1d2417c5843c6ba6e4 Mon Sep 17 00:00:00 2001
From: Andy Pan <panjf2000@gmail.com>
Date: Thu, 15 Apr 2021 00:04:17 +0800
Subject: [PATCH 1663/2400] runtime: implement runqdrain() for GC mark worker
 goroutines

Change-Id: Ida44a2e07f277bee8806538ecee4beee3474cf3d
Reviewed-on: https://go-review.googlesource.com/c/go/+/310149
Reviewed-by: Michael Pratt <mpratt@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Michael Pratt <mpratt@google.com>
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Michael Pratt <mpratt@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/mgc.go      | 12 ++++--------
 src/runtime/proc.go     | 38 ++++++++++++++++++++++++++++++++++++++
 src/runtime/runtime2.go |  3 +++
 3 files changed, 45 insertions(+), 8 deletions(-)

diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index 601593087d..4585663535 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -1273,15 +1273,11 @@ func gcBgMarkWorker() {
 					// everything out of the run
 					// queue so it can run
 					// somewhere else.
-					lock(&sched.lock)
-					for {
-						gp, _ := runqget(pp)
-						if gp == nil {
-							break
-						}
-						globrunqput(gp)
+					if drainQ, n := runqdrain(pp); n > 0 {
+						lock(&sched.lock)
+						globrunqputbatch(&drainQ, int32(n))
+						unlock(&sched.lock)
 					}
-					unlock(&sched.lock)
 				}
 				// Go back to draining, this time
 				// without preemption.
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index a712b11c4f..c4fe6dd0f8 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -5911,6 +5911,44 @@ func runqget(_p_ *p) (gp *g, inheritTime bool) {
 	}
 }
 
+// runqdrain drains the local runnable queue of _p_ and returns all g's in it.
+// Executed only by the owner P.
+func runqdrain(_p_ *p) (drainQ gQueue, n uint32) {
+	var getNext bool
+	oldNext := _p_.runnext
+	if oldNext != 0 && _p_.runnext.cas(oldNext, 0) {
+		drainQ.pushBack(oldNext.ptr())
+		n++
+		getNext = true
+	}
+
+	for {
+		h := atomic.LoadAcq(&_p_.runqhead) // load-acquire, synchronize with other consumers
+		t := _p_.runqtail
+		qn := t - h
+		if qn == 0 {
+			return
+		}
+		for i := uint32(0); i < qn; i++ {
+			gp := _p_.runq[(h+i)%uint32(len(_p_.runq))].ptr()
+			drainQ.pushBack(gp)
+		}
+		if atomic.CasRel(&_p_.runqhead, h, h+qn) { // cas-release, commits consume
+			n += qn
+			return
+		}
+
+		// Clean up if it failed to drain _p_ in this round and start over until it succeed.
+		drainQ = gQueue{}
+		n = 0
+		// Push the prior old _p_.runnext back into drainQ.
+		if getNext {
+			drainQ.pushBack(oldNext.ptr())
+			n++
+		}
+	}
+}
+
 // Grabs a batch of goroutines from _p_'s runnable queue into batch.
 // Batch is a ring buffer starting at batchHead.
 // Returns number of grabbed goroutines.
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index 387841e60b..82b6c596e5 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -622,6 +622,9 @@ type p struct {
 	// unit and eliminates the (potentially large) scheduling
 	// latency that otherwise arises from adding the ready'd
 	// goroutines to the end of the run queue.
+	//
+	// Note that while other P's may atomically CAS this to zero,
+	// only the owner P can CAS it to a valid G.
 	runnext guintptr
 
 	// Available G's (status == Gdead)
-- 
GitLab


From 7473a6a0ebb270c24c20994d3ea6e3fd96def223 Mon Sep 17 00:00:00 2001
From: Jinzhu <wosmvp@gmail.com>
Date: Tue, 20 Apr 2021 02:47:54 +0000
Subject: [PATCH 1664/2400] reflect: fix stack overflow panic when using
 haveIdenticalUnderlyingType

haveIdenticalUnderlyingType raises stack overflow when compares
self-referential structs having same structure in different packages.

Change-Id: I7c79ab988edcffadcf7e0730a50b4d31b136bb6a
GitHub-Last-Rev: 4d4217f0c16ef14aa1f38ff7cf88c98755bb8ddd
GitHub-Pull-Request: golang/go#45543
Reviewed-on: https://go-review.googlesource.com/c/go/+/309729
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/reflect/all_test.go                  | 25 ++++++++++++++++++++++++
 src/reflect/internal/example1/example.go |  6 ++++++
 src/reflect/internal/example2/example.go |  6 ++++++
 src/reflect/type.go                      |  2 +-
 4 files changed, 38 insertions(+), 1 deletion(-)
 create mode 100644 src/reflect/internal/example1/example.go
 create mode 100644 src/reflect/internal/example2/example.go

diff --git a/src/reflect/all_test.go b/src/reflect/all_test.go
index 241f6b0b5a..3269f5ffce 100644
--- a/src/reflect/all_test.go
+++ b/src/reflect/all_test.go
@@ -15,6 +15,8 @@ import (
 	"math/rand"
 	"os"
 	. "reflect"
+	"reflect/internal/example1"
+	"reflect/internal/example2"
 	"runtime"
 	"sort"
 	"strconv"
@@ -3808,6 +3810,16 @@ type Empty struct{}
 type MyStruct struct {
 	x int `some:"tag"`
 }
+type MyStruct1 struct {
+	x struct {
+		int `some:"bar"`
+	}
+}
+type MyStruct2 struct {
+	x struct {
+		int `some:"foo"`
+	}
+}
 type MyString string
 type MyBytes []byte
 type MyRunes []int32
@@ -4158,6 +4170,9 @@ var convertTests = []struct {
 		x int `some:"bar"`
 	}{}), V(MyStruct{})},
 
+	{V(MyStruct1{}), V(MyStruct2{})},
+	{V(MyStruct2{}), V(MyStruct1{})},
+
 	// can convert *byte and *MyByte
 	{V((*byte)(nil)), V((*MyByte)(nil))},
 	{V((*MyByte)(nil)), V((*byte)(nil))},
@@ -7231,3 +7246,13 @@ func iterateToString(it *MapIter) string {
 	sort.Strings(got)
 	return "[" + strings.Join(got, ", ") + "]"
 }
+
+func TestConvertibleTo(t *testing.T) {
+	t1 := ValueOf(example1.MyStruct{}).Type()
+	t2 := ValueOf(example2.MyStruct{}).Type()
+
+	// Shouldn't raise stack overflow
+	if t1.ConvertibleTo(t2) {
+		t.Fatalf("(%s).ConvertibleTo(%s) = true, want false", t1, t2)
+	}
+}
diff --git a/src/reflect/internal/example1/example.go b/src/reflect/internal/example1/example.go
new file mode 100644
index 0000000000..0f829a86bf
--- /dev/null
+++ b/src/reflect/internal/example1/example.go
@@ -0,0 +1,6 @@
+package example1
+
+type MyStruct struct {
+	MyStructs []MyStruct
+	MyStruct  *MyStruct
+}
diff --git a/src/reflect/internal/example2/example.go b/src/reflect/internal/example2/example.go
new file mode 100644
index 0000000000..df64ba1ff9
--- /dev/null
+++ b/src/reflect/internal/example2/example.go
@@ -0,0 +1,6 @@
+package example2
+
+type MyStruct struct {
+	MyStructs []MyStruct
+	MyStruct  *MyStruct
+}
diff --git a/src/reflect/type.go b/src/reflect/type.go
index c213b31941..d50559e933 100644
--- a/src/reflect/type.go
+++ b/src/reflect/type.go
@@ -1599,7 +1599,7 @@ func haveIdenticalType(T, V Type, cmpTags bool) bool {
 		return T == V
 	}
 
-	if T.Name() != V.Name() || T.Kind() != V.Kind() {
+	if T.Name() != V.Name() || T.Kind() != V.Kind() || T.PkgPath() != V.PkgPath() {
 		return false
 	}
 
-- 
GitLab


From dbade774c379393f76105242e69cdcf2ad32e5c3 Mon Sep 17 00:00:00 2001
From: Michael Pratt <mpratt@google.com>
Date: Wed, 7 Apr 2021 09:58:18 -0400
Subject: [PATCH 1665/2400] runtime: refactor findrunnable spinning recheck

Break the main components of the findrunnable spinning -> non-spinning
recheck out into their own functions, which simplifies both findrunnable
and the new functions, which can make use of fancy features like early
returns.

This CL should have no functional changes.

For #43997
For #44313

Change-Id: I6d3060fcecda9920a3471ff338f73d53b1d848a3
Reviewed-on: https://go-review.googlesource.com/c/go/+/307914
Trust: Michael Pratt <mpratt@google.com>
Run-TryBot: Michael Pratt <mpratt@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/proc.go | 177 +++++++++++++++++++++++++++-----------------
 1 file changed, 110 insertions(+), 67 deletions(-)

diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index c4fe6dd0f8..40da76d9f0 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -2799,86 +2799,42 @@ top:
 		}
 	}
 
-	// check all runqueues once again
-	for id, _p_ := range allpSnapshot {
-		if !idlepMaskSnapshot.read(uint32(id)) && !runqempty(_p_) {
-			lock(&sched.lock)
-			_p_ = pidleget()
-			unlock(&sched.lock)
-			if _p_ != nil {
-				acquirep(_p_)
-				if wasSpinning {
-					_g_.m.spinning = true
-					atomic.Xadd(&sched.nmspinning, 1)
-				}
-				goto top
-			}
-			break
+	// Check all runqueues once again.
+	_p_ = checkRunqsNoP(allpSnapshot, idlepMaskSnapshot)
+	if _p_ != nil {
+		acquirep(_p_)
+		if wasSpinning {
+			_g_.m.spinning = true
+			atomic.Xadd(&sched.nmspinning, 1)
 		}
+		goto top
 	}
 
 	// Similar to above, check for timer creation or expiry concurrently with
 	// transitioning from spinning to non-spinning. Note that we cannot use
 	// checkTimers here because it calls adjusttimers which may need to allocate
 	// memory, and that isn't allowed when we don't have an active P.
-	for id, _p_ := range allpSnapshot {
-		if timerpMaskSnapshot.read(uint32(id)) {
-			w := nobarrierWakeTime(_p_)
-			if w != 0 && (pollUntil == 0 || w < pollUntil) {
-				pollUntil = w
-			}
-		}
-	}
+	pollUntil = checkTimersNoP(allpSnapshot, timerpMaskSnapshot, pollUntil)
 
-	// Check for idle-priority GC work again.
-	//
-	// N.B. Since we have no P, gcBlackenEnabled may change at any time; we
-	// must check again after acquiring a P.
-	if atomic.Load(&gcBlackenEnabled) != 0 && gcMarkWorkAvailable(nil) {
-		// Work is available; we can start an idle GC worker only if
-		// there is an available P and available worker G.
-		//
-		// We can attempt to acquire these in either order. Workers are
-		// almost always available (see comment in findRunnableGCWorker
-		// for the one case there may be none). Since we're slightly
-		// less likely to find a P, check for that first.
-		lock(&sched.lock)
-		var node *gcBgMarkWorkerNode
-		_p_ = pidleget()
-		if _p_ != nil {
-			// Now that we own a P, gcBlackenEnabled can't change
-			// (as it requires STW).
-			if gcBlackenEnabled != 0 {
-				node = (*gcBgMarkWorkerNode)(gcBgMarkWorkerPool.pop())
-				if node == nil {
-					pidleput(_p_)
-					_p_ = nil
-				}
-			} else {
-				pidleput(_p_)
-				_p_ = nil
-			}
+	// Finally, check for idle-priority GC work.
+	_p_, gp = checkIdleGCNoP()
+	if _p_ != nil {
+		acquirep(_p_)
+		if wasSpinning {
+			_g_.m.spinning = true
+			atomic.Xadd(&sched.nmspinning, 1)
 		}
-		unlock(&sched.lock)
-		if _p_ != nil {
-			acquirep(_p_)
-			if wasSpinning {
-				_g_.m.spinning = true
-				atomic.Xadd(&sched.nmspinning, 1)
-			}
 
-			// Run the idle worker.
-			_p_.gcMarkWorkerMode = gcMarkWorkerIdleMode
-			gp := node.gp.ptr()
-			casgstatus(gp, _Gwaiting, _Grunnable)
-			if trace.enabled {
-				traceGoUnpark(gp, 0)
-			}
-			return gp, false
+		// Run the idle worker.
+		_p_.gcMarkWorkerMode = gcMarkWorkerIdleMode
+		casgstatus(gp, _Gwaiting, _Grunnable)
+		if trace.enabled {
+			traceGoUnpark(gp, 0)
 		}
+		return gp, false
 	}
 
-	// poll network
+	// Poll network until next timer.
 	if netpollinited() && (atomic.Load(&netpollWaiters) > 0 || pollUntil != 0) && atomic.Xchg64(&sched.lastpoll, 0) != 0 {
 		atomic.Store64(&sched.pollUntil, uint64(pollUntil))
 		if _g_.m.p != 0 {
@@ -3038,6 +2994,93 @@ func stealWork(now int64) (gp *g, inheritTime bool, rnow, pollUntil int64, newWo
 	return nil, false, now, pollUntil, ranTimer
 }
 
+// Check all Ps for a runnable G to steal.
+//
+// On entry we have no P. If a G is available to steal and a P is available,
+// the P is returned which the caller should acquire and attempt to steal the
+// work to.
+func checkRunqsNoP(allpSnapshot []*p, idlepMaskSnapshot pMask) *p {
+	for id, p2 := range allpSnapshot {
+		if !idlepMaskSnapshot.read(uint32(id)) && !runqempty(p2) {
+			lock(&sched.lock)
+			pp := pidleget()
+			unlock(&sched.lock)
+			if pp != nil {
+				return pp
+			}
+
+			// Can't get a P, don't bother checking remaining Ps.
+			break
+		}
+	}
+
+	return nil
+}
+
+// Check all Ps for a timer expiring sooner than pollUntil.
+//
+// Returns updated pollUntil value.
+func checkTimersNoP(allpSnapshot []*p, timerpMaskSnapshot pMask, pollUntil int64) int64 {
+	for id, p2 := range allpSnapshot {
+		if timerpMaskSnapshot.read(uint32(id)) {
+			w := nobarrierWakeTime(p2)
+			if w != 0 && (pollUntil == 0 || w < pollUntil) {
+				pollUntil = w
+			}
+		}
+	}
+
+	return pollUntil
+}
+
+// Check for idle-priority GC, without a P on entry.
+//
+// If some GC work, a P, and a worker G are all available, the P and G will be
+// returned. The returned P has not been wired yet.
+func checkIdleGCNoP() (*p, *g) {
+	// N.B. Since we have no P, gcBlackenEnabled may change at any time; we
+	// must check again after acquiring a P.
+	if atomic.Load(&gcBlackenEnabled) == 0 {
+		return nil, nil
+	}
+	if !gcMarkWorkAvailable(nil) {
+		return nil, nil
+	}
+
+	// Work is available; we can start an idle GC worker only if
+	// there is an available P and available worker G.
+	//
+	// We can attempt to acquire these in either order. Workers are
+	// almost always available (see comment in findRunnableGCWorker
+	// for the one case there may be none). Since we're slightly
+	// less likely to find a P, check for that first.
+	lock(&sched.lock)
+	pp := pidleget()
+	unlock(&sched.lock)
+	if pp == nil {
+		return nil, nil
+	}
+
+	// Now that we own a P, gcBlackenEnabled can't change
+	// (as it requires STW).
+	if gcBlackenEnabled == 0 {
+		lock(&sched.lock)
+		pidleput(pp)
+		unlock(&sched.lock)
+		return nil, nil
+	}
+
+	node := (*gcBgMarkWorkerNode)(gcBgMarkWorkerPool.pop())
+	if node == nil {
+		lock(&sched.lock)
+		pidleput(pp)
+		unlock(&sched.lock)
+		return nil, nil
+	}
+
+	return pp, node.gp.ptr()
+}
+
 // wakeNetPoller wakes up the thread sleeping in the network poller if it isn't
 // going to wake up before the when argument; or it wakes an idle P to service
 // timers and the network poller if there isn't one already.
-- 
GitLab


From 3f8e64878a93a1b005e1ff0f2a939bab826b8b9f Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Tue, 20 Apr 2021 12:58:53 +0200
Subject: [PATCH 1666/2400] internal/poll, net: fix comments regarding accept
 and sysSocket

The implementation of accept was moved from package net to internal/poll
in CL 36799.

Change-Id: I6e5964e0ee22e9c84bc444860cdd497817451fec
Reviewed-on: https://go-review.googlesource.com/c/go/+/311571
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/internal/poll/sock_cloexec.go | 4 ++--
 src/internal/poll/sys_cloexec.go  | 4 ++--
 src/net/sock_cloexec.go           | 4 ++--
 src/net/sys_cloexec.go            | 4 ++--
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/internal/poll/sock_cloexec.go b/src/internal/poll/sock_cloexec.go
index 52191d85c6..b3038290b9 100644
--- a/src/internal/poll/sock_cloexec.go
+++ b/src/internal/poll/sock_cloexec.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// This file implements sysSocket and accept for platforms that
-// provide a fast path for setting SetNonblock and CloseOnExec.
+// This file implements accept for platforms that provide a fast path for
+// setting SetNonblock and CloseOnExec.
 
 //go:build dragonfly || freebsd || illumos || linux || netbsd || openbsd
 // +build dragonfly freebsd illumos linux netbsd openbsd
diff --git a/src/internal/poll/sys_cloexec.go b/src/internal/poll/sys_cloexec.go
index 69207a4b89..7e6d422d62 100644
--- a/src/internal/poll/sys_cloexec.go
+++ b/src/internal/poll/sys_cloexec.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// This file implements sysSocket and accept for platforms that do not
-// provide a fast path for setting SetNonblock and CloseOnExec.
+// This file implements accept for platforms that do not provide a fast path for
+// setting SetNonblock and CloseOnExec.
 
 //go:build aix || darwin || (js && wasm) || (solaris && !illumos)
 // +build aix darwin js,wasm solaris,!illumos
diff --git a/src/net/sock_cloexec.go b/src/net/sock_cloexec.go
index efc91fdb53..6861c4bf63 100644
--- a/src/net/sock_cloexec.go
+++ b/src/net/sock_cloexec.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// This file implements sysSocket and accept for platforms that
-// provide a fast path for setting SetNonblock and CloseOnExec.
+// This file implements sysSocket for platforms that provide a fast path for
+// setting SetNonblock and CloseOnExec.
 
 //go:build dragonfly || freebsd || illumos || linux || netbsd || openbsd
 // +build dragonfly freebsd illumos linux netbsd openbsd
diff --git a/src/net/sys_cloexec.go b/src/net/sys_cloexec.go
index 4d7112051f..a32483e2df 100644
--- a/src/net/sys_cloexec.go
+++ b/src/net/sys_cloexec.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// This file implements sysSocket and accept for platforms that do not
-// provide a fast path for setting SetNonblock and CloseOnExec.
+// This file implements sysSocket for platforms that do not provide a fast path
+// for setting SetNonblock and CloseOnExec.
 
 //go:build aix || darwin || (solaris && !illumos)
 // +build aix darwin solaris,!illumos
-- 
GitLab


From 57b0d838ed2e0c128dfc480fee3b5c43309d3369 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Tue, 20 Apr 2021 10:25:19 +0200
Subject: [PATCH 1667/2400] net: pass MSG_CMSG_CLOEXEC in ReadMsgUnix on
 dragonfly, netbsd and openbsd

Add support for passing MSG_CMSG_CLOEXEC to the recvmsg syscall on
dragonfly, netbsd and openbsd. MSG_CMSG_CLOEXEC on freebsd is currently
broken, see https://reviews.freebsd.org/D29328.

Change-Id: Ie4c6e3cb550cd0ae32a1c2acca12edf77569e96a
Reviewed-on: https://go-review.googlesource.com/c/go/+/311570
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/net/unixsock_posix.go                             |  2 +-
 ...k_readmsg_posix.go => unixsock_readmsg_cloexec.go} |  8 +++-----
 ...dmsg_linux.go => unixsock_readmsg_cmsg_cloexec.go} | 11 ++++-------
 src/net/unixsock_readmsg_other.go                     |  3 +--
 src/syscall/zerrors_dragonfly_amd64.go                |  1 +
 src/syscall/zerrors_openbsd_386.go                    |  1 +
 src/syscall/zerrors_openbsd_amd64.go                  |  1 +
 7 files changed, 12 insertions(+), 15 deletions(-)
 rename src/net/{unixsock_readmsg_posix.go => unixsock_readmsg_cloexec.go} (78%)
 rename src/net/{unixsock_readmsg_linux.go => unixsock_readmsg_cmsg_cloexec.go} (59%)

diff --git a/src/net/unixsock_posix.go b/src/net/unixsock_posix.go
index 0306b5989b..99a89c827b 100644
--- a/src/net/unixsock_posix.go
+++ b/src/net/unixsock_posix.go
@@ -114,7 +114,7 @@ func (c *UnixConn) readFrom(b []byte) (int, *UnixAddr, error) {
 func (c *UnixConn) readMsg(b, oob []byte) (n, oobn, flags int, addr *UnixAddr, err error) {
 	var sa syscall.Sockaddr
 	n, oobn, flags, sa, err = c.fd.readMsg(b, oob, readMsgFlags)
-	if oobn > 0 {
+	if readMsgFlags == 0 && err == nil && oobn > 0 {
 		setReadMsgCloseOnExec(oob[:oobn])
 	}
 
diff --git a/src/net/unixsock_readmsg_posix.go b/src/net/unixsock_readmsg_cloexec.go
similarity index 78%
rename from src/net/unixsock_readmsg_posix.go
rename to src/net/unixsock_readmsg_cloexec.go
index 07d7df5e66..716484cc6c 100644
--- a/src/net/unixsock_readmsg_posix.go
+++ b/src/net/unixsock_readmsg_cloexec.go
@@ -2,14 +2,12 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build aix || darwin || dragonfly || freebsd || netbsd || openbsd || solaris
-// +build aix darwin dragonfly freebsd netbsd openbsd solaris
+//go:build aix || darwin || freebsd || solaris
+// +build aix darwin freebsd solaris
 
 package net
 
-import (
-	"syscall"
-)
+import "syscall"
 
 const readMsgFlags = 0
 
diff --git a/src/net/unixsock_readmsg_linux.go b/src/net/unixsock_readmsg_cmsg_cloexec.go
similarity index 59%
rename from src/net/unixsock_readmsg_linux.go
rename to src/net/unixsock_readmsg_cmsg_cloexec.go
index 3296681017..bb851b89c0 100644
--- a/src/net/unixsock_readmsg_linux.go
+++ b/src/net/unixsock_readmsg_cmsg_cloexec.go
@@ -2,16 +2,13 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build linux
-// +build linux
+//go:build dragonfly || linux || netbsd || openbsd
+// +build dragonfly linux netbsd openbsd
 
 package net
 
-import (
-	"syscall"
-)
+import "syscall"
 
 const readMsgFlags = syscall.MSG_CMSG_CLOEXEC
 
-func setReadMsgCloseOnExec(oob []byte) {
-}
+func setReadMsgCloseOnExec(oob []byte) {}
diff --git a/src/net/unixsock_readmsg_other.go b/src/net/unixsock_readmsg_other.go
index c8db657cd6..329076183a 100644
--- a/src/net/unixsock_readmsg_other.go
+++ b/src/net/unixsock_readmsg_other.go
@@ -9,5 +9,4 @@ package net
 
 const readMsgFlags = 0
 
-func setReadMsgCloseOnExec(oob []byte) {
-}
+func setReadMsgCloseOnExec(oob []byte) {}
diff --git a/src/syscall/zerrors_dragonfly_amd64.go b/src/syscall/zerrors_dragonfly_amd64.go
index b572f44a6b..8ed611b3e4 100644
--- a/src/syscall/zerrors_dragonfly_amd64.go
+++ b/src/syscall/zerrors_dragonfly_amd64.go
@@ -850,6 +850,7 @@ const (
 	MAP_VPAGETABLE                    = 0x2000
 	MCL_CURRENT                       = 0x1
 	MCL_FUTURE                        = 0x2
+	MSG_CMSG_CLOEXEC                  = 0x1000
 	MSG_CTRUNC                        = 0x20
 	MSG_DONTROUTE                     = 0x4
 	MSG_DONTWAIT                      = 0x80
diff --git a/src/syscall/zerrors_openbsd_386.go b/src/syscall/zerrors_openbsd_386.go
index 04d1b3f177..a8457c6edf 100644
--- a/src/syscall/zerrors_openbsd_386.go
+++ b/src/syscall/zerrors_openbsd_386.go
@@ -891,6 +891,7 @@ const (
 	MCL_CURRENT                       = 0x1
 	MCL_FUTURE                        = 0x2
 	MSG_BCAST                         = 0x100
+	MSG_CMSG_CLOEXEC                  = 0x800
 	MSG_CTRUNC                        = 0x20
 	MSG_DONTROUTE                     = 0x4
 	MSG_DONTWAIT                      = 0x80
diff --git a/src/syscall/zerrors_openbsd_amd64.go b/src/syscall/zerrors_openbsd_amd64.go
index 923a3a47c5..eb19537a2a 100644
--- a/src/syscall/zerrors_openbsd_amd64.go
+++ b/src/syscall/zerrors_openbsd_amd64.go
@@ -891,6 +891,7 @@ const (
 	MCL_CURRENT                       = 0x1
 	MCL_FUTURE                        = 0x2
 	MSG_BCAST                         = 0x100
+	MSG_CMSG_CLOEXEC                  = 0x800
 	MSG_CTRUNC                        = 0x20
 	MSG_DONTROUTE                     = 0x4
 	MSG_DONTWAIT                      = 0x80
-- 
GitLab


From f448cb8ba83be1055cc73101e0c217c2a503c8ad Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 20 Apr 2021 17:29:57 -0400
Subject: [PATCH 1668/2400] cmd/compile: use f.Nname.Type() in makeABIWrapper

Apparently, f.Nname.Ntype.Type() doesn't work with types2, as it
doesn't set Ntype, unlike the old type checker. f.Nname.Type()
works for both.

Change-Id: I6fa8a81c9fc7b65e008d9f158b88f0d56d84c3ff
Reviewed-on: https://go-review.googlesource.com/c/go/+/312089
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ssagen/abi.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ssagen/abi.go b/src/cmd/compile/internal/ssagen/abi.go
index 7d56362302..e460adaf95 100644
--- a/src/cmd/compile/internal/ssagen/abi.go
+++ b/src/cmd/compile/internal/ssagen/abi.go
@@ -311,7 +311,7 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 
 	// At the moment we don't support wrapping a method, we'd need machinery
 	// below to handle the receiver. Panic if we see this scenario.
-	ft := f.Nname.Ntype.Type()
+	ft := f.Nname.Type()
 	if ft.NumRecvs() != 0 {
 		panic("makeABIWrapper support for wrapping methods not implemented")
 	}
-- 
GitLab


From c7d708e42ed4db9dd323899256d5666c5062e5ab Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Tue, 20 Apr 2021 14:29:53 -0700
Subject: [PATCH 1669/2400] cmd/compile: pass struct field note information
 along in exported info

This is needed to make field tracking work correctly.

Change-Id: I0c3452a48d6f36862f6ee8aacc001813866c0ad4
Reviewed-on: https://go-review.googlesource.com/c/go/+/312069
Trust: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/typecheck/iexport.go | 1 +
 src/cmd/compile/internal/typecheck/iimport.go | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index 911d758083..b59a610cf7 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -749,6 +749,7 @@ func (w *exportWriter) exoticParam(f *types.Field) {
 	w.uint64(uint64(f.Offset))
 	w.exoticType(f.Type)
 	w.bool(f.IsDDD())
+	w.string(f.Note)
 }
 func (w *exportWriter) exoticSym(s *types.Sym) {
 	if s == nil {
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index c55e3fbe2a..53576bf725 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -592,6 +592,7 @@ func (r *importReader) exoticParam() *types.Field {
 		f.Nname = ir.NewNameAt(pos, sym)
 	}
 	f.SetIsDDD(ddd)
+	f.Note = r.string()
 	return f
 }
 
-- 
GitLab


From 48e3d924548ce6b96f55ff74e40f9a16449ac659 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Tue, 20 Apr 2021 21:50:13 +0000
Subject: [PATCH 1670/2400] Revert "runtime: implement runqdrain() for GC mark
 worker goroutines"

This reverts CL 310149.

Reason for revert: Breaks longtest builders:

https://build.golang.org/log/6af9fb147fa3101154db10e7ce055e8267cd4c93
https://build.golang.org/log/172ed6e1ec3bb503370333ee421c590fd2a72d0a

Change-Id: Iaf5a8b9eec51d0517311e050d0b0f7569759d292
Reviewed-on: https://go-review.googlesource.com/c/go/+/312129
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/mgc.go      | 12 ++++++++----
 src/runtime/proc.go     | 38 --------------------------------------
 src/runtime/runtime2.go |  3 ---
 3 files changed, 8 insertions(+), 45 deletions(-)

diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index 4585663535..601593087d 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -1273,11 +1273,15 @@ func gcBgMarkWorker() {
 					// everything out of the run
 					// queue so it can run
 					// somewhere else.
-					if drainQ, n := runqdrain(pp); n > 0 {
-						lock(&sched.lock)
-						globrunqputbatch(&drainQ, int32(n))
-						unlock(&sched.lock)
+					lock(&sched.lock)
+					for {
+						gp, _ := runqget(pp)
+						if gp == nil {
+							break
+						}
+						globrunqput(gp)
 					}
+					unlock(&sched.lock)
 				}
 				// Go back to draining, this time
 				// without preemption.
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 40da76d9f0..ef3b373b1c 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -5954,44 +5954,6 @@ func runqget(_p_ *p) (gp *g, inheritTime bool) {
 	}
 }
 
-// runqdrain drains the local runnable queue of _p_ and returns all g's in it.
-// Executed only by the owner P.
-func runqdrain(_p_ *p) (drainQ gQueue, n uint32) {
-	var getNext bool
-	oldNext := _p_.runnext
-	if oldNext != 0 && _p_.runnext.cas(oldNext, 0) {
-		drainQ.pushBack(oldNext.ptr())
-		n++
-		getNext = true
-	}
-
-	for {
-		h := atomic.LoadAcq(&_p_.runqhead) // load-acquire, synchronize with other consumers
-		t := _p_.runqtail
-		qn := t - h
-		if qn == 0 {
-			return
-		}
-		for i := uint32(0); i < qn; i++ {
-			gp := _p_.runq[(h+i)%uint32(len(_p_.runq))].ptr()
-			drainQ.pushBack(gp)
-		}
-		if atomic.CasRel(&_p_.runqhead, h, h+qn) { // cas-release, commits consume
-			n += qn
-			return
-		}
-
-		// Clean up if it failed to drain _p_ in this round and start over until it succeed.
-		drainQ = gQueue{}
-		n = 0
-		// Push the prior old _p_.runnext back into drainQ.
-		if getNext {
-			drainQ.pushBack(oldNext.ptr())
-			n++
-		}
-	}
-}
-
 // Grabs a batch of goroutines from _p_'s runnable queue into batch.
 // Batch is a ring buffer starting at batchHead.
 // Returns number of grabbed goroutines.
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index 82b6c596e5..387841e60b 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -622,9 +622,6 @@ type p struct {
 	// unit and eliminates the (potentially large) scheduling
 	// latency that otherwise arises from adding the ready'd
 	// goroutines to the end of the run queue.
-	//
-	// Note that while other P's may atomically CAS this to zero,
-	// only the owner P can CAS it to a valid G.
 	runnext guintptr
 
 	// Available G's (status == Gdead)
-- 
GitLab


From e12b0afa5454c7683cb27bef0b6979f964dd0e96 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Tue, 20 Apr 2021 15:36:11 -0700
Subject: [PATCH 1671/2400] cmd/compile: separate out parameter and field
 export encoding

These two types of *types.Field encode different concepts, so we
encode them separately (and ignore fields that don't matter for
each concept).

Change-Id: I9d1608413949a109f12a3ebd52cd7af5f476e415
Reviewed-on: https://go-review.googlesource.com/c/go/+/312130
Trust: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/typecheck/iexport.go | 10 +++++++++-
 src/cmd/compile/internal/typecheck/iimport.go | 18 ++++++++++++++++--
 2 files changed, 25 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index b59a610cf7..6a56abb1b9 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -749,8 +749,16 @@ func (w *exportWriter) exoticParam(f *types.Field) {
 	w.uint64(uint64(f.Offset))
 	w.exoticType(f.Type)
 	w.bool(f.IsDDD())
+}
+
+func (w *exportWriter) exoticField(f *types.Field) {
+	w.pos(f.Pos)
+	w.exoticSym(f.Sym)
+	w.uint64(uint64(f.Offset))
+	w.exoticType(f.Type)
 	w.string(f.Note)
 }
+
 func (w *exportWriter) exoticSym(s *types.Sym) {
 	if s == nil {
 		w.string("")
@@ -1593,7 +1601,7 @@ func (w *exportWriter) expr(n ir.Node) {
 		if go117ExportTypes {
 			w.exoticType(n.Type())
 			if n.Op() == ir.ODOT || n.Op() == ir.ODOTPTR || n.Op() == ir.ODOTINTER {
-				w.exoticParam(n.Selection)
+				w.exoticField(n.Selection)
 			}
 			// n.Selection is not required for OMETHEXPR, ODOTMETH, and OCALLPART. It will
 			// be reconstructed during import.
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 53576bf725..8c197215d7 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -592,7 +592,21 @@ func (r *importReader) exoticParam() *types.Field {
 		f.Nname = ir.NewNameAt(pos, sym)
 	}
 	f.SetIsDDD(ddd)
-	f.Note = r.string()
+	return f
+}
+
+func (r *importReader) exoticField() *types.Field {
+	pos := r.pos()
+	sym := r.exoticSym()
+	off := r.uint64()
+	typ := r.exoticType()
+	note := r.string()
+	f := types.NewField(pos, sym, typ)
+	f.Offset = int64(off)
+	if sym != nil {
+		f.Nname = ir.NewNameAt(pos, sym)
+	}
+	f.Note = note
 	return f
 }
 
@@ -1202,7 +1216,7 @@ func (r *importReader) node() ir.Node {
 		n.SetType(r.exoticType())
 		switch op {
 		case ir.ODOT, ir.ODOTPTR, ir.ODOTINTER:
-			n.Selection = r.exoticParam()
+			n.Selection = r.exoticField()
 		case ir.ODOTMETH, ir.OCALLPART, ir.OMETHEXPR:
 			// These require a Lookup to link to the correct declaration.
 			rcvrType := expr.Type()
-- 
GitLab


From 1c268431f49ee2fc843eac52a0854aea3d02a6e0 Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Sat, 25 Jan 2020 11:07:33 -0800
Subject: [PATCH 1672/2400] spec: allow conversion from slice to array ptr

Implementation follows in subsequent changes.

Updates #395

Change-Id: Ic97ee822805e4c236fdd9d224e776cb2ae62c817
Reviewed-on: https://go-review.googlesource.com/c/go/+/216424
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
Reviewed-by: Rob Pike <r@golang.org>
---
 doc/go_spec.html | 24 +++++++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index 8c9003434c..13b8beb06c 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1,6 +1,6 @@
 <!--{
 	"Title": "The Go Programming Language Specification",
-	"Subtitle": "Version of Mar 16, 2021",
+	"Subtitle": "Version of Apr 20, 2021",
 	"Path": "/ref/spec"
 }-->
 
@@ -4164,6 +4164,10 @@ in any of these cases:
 	<li>
 	<code>x</code> is a string and <code>T</code> is a slice of bytes or runes.
 	</li>
+	<li>
+	<code>x</code> is a slice, <code>T</code> is a pointer to an array,
+	and the slice and array types have <a href="#Type_identity">identical</a> element types.
+	</li>
 </ul>
 
 <p>
@@ -4314,6 +4318,24 @@ MyRunes("白鵬翔")           // []rune{0x767d, 0x9d6c, 0x7fd4}
 </li>
 </ol>
 
+<h4 id="Conversions_from_slice_to_array_pointer">Conversions from slice to array pointer</h4>
+
+<p>
+Converting a slice to an array pointer yields a pointer to the underlying array of the slice.
+If the <a href="#Length_and_capacity">length</a> of the slice is less than the length of the array,
+a <a href="#Run_time_panics">run-time panic<a/> occurs.
+</p>
+
+<pre>
+s := make([]byte, 2, 4)
+s0 := (*[0]byte)(s)      // s0 != nil
+s2 := (*[2]byte)(s)      // &amp;s2[0] == &amp;s[0]
+s4 := (*[4]byte)(s)      // panics: len([4]byte) > len(s)
+
+var t []string
+t0 := (*[0]string)(t)    // t0 == nil
+t1 := (*[1]string)(t)    // panics: len([1]string) > len(s)
+</pre>
 
 <h3 id="Constant_expressions">Constant expressions</h3>
 
-- 
GitLab


From faa4fa1a6e94fce4f6fa22524a2bece5125213b6 Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Sun, 14 Mar 2021 14:24:47 -0700
Subject: [PATCH 1673/2400] cmd/compile: allow conversion from slice to array
 ptr

Panic if the slice is too short.

Updates #395

Change-Id: I90f4bff2da5d8f3148ba06d2482084f32b25c29a
Reviewed-on: https://go-review.googlesource.com/c/go/+/301650
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/escape/escape.go     |   5 +-
 src/cmd/compile/internal/ir/expr.go           |   2 +-
 src/cmd/compile/internal/ir/fmt.go            |   4 +-
 src/cmd/compile/internal/ir/node.go           |   1 +
 src/cmd/compile/internal/ir/op_string.go      | 269 +++++++++---------
 src/cmd/compile/internal/ssa/expand_calls.go  |   4 +-
 src/cmd/compile/internal/ssa/gen/dec.rules    |   1 +
 .../compile/internal/ssa/gen/genericOps.go    |   4 +
 src/cmd/compile/internal/ssa/op.go            |   4 +-
 src/cmd/compile/internal/ssa/opGen.go         |   6 +
 src/cmd/compile/internal/ssa/rewritedec.go    |  16 ++
 src/cmd/compile/internal/ssagen/ssa.go        |  14 +
 src/cmd/compile/internal/typecheck/builtin.go |   1 +
 .../internal/typecheck/builtin/runtime.go     |   1 +
 src/cmd/compile/internal/typecheck/subr.go    |  12 +-
 src/cmd/compile/internal/types2/api_test.go   |   3 +
 .../compile/internal/types2/conversions.go    |  12 +
 src/cmd/compile/internal/walk/expr.go         |   5 +
 src/go/types/stdlib_test.go                   |   4 +
 src/runtime/asm_386.s                         |   4 +
 src/runtime/asm_amd64.s                       |   8 +
 src/runtime/asm_arm.s                         |   4 +
 src/runtime/asm_arm64.s                       |   4 +
 src/runtime/asm_mips64x.s                     |   4 +
 src/runtime/asm_mipsx.s                       |   4 +
 src/runtime/asm_ppc64x.s                      |   4 +
 src/runtime/asm_riscv64.s                     |   4 +
 src/runtime/asm_s390x.s                       |   4 +
 src/runtime/error.go                          |   2 +
 src/runtime/panic.go                          |   7 +
 test/convert2.go                              |  14 +
 test/convert4.go                              |  86 ++++++
 test/escape_slice.go                          |   4 +
 33 files changed, 380 insertions(+), 141 deletions(-)
 create mode 100644 test/convert4.go

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index 6bebe5422f..b706d7d2c8 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -669,7 +669,10 @@ func (e *escape) exprSkipInit(k hole, n ir.Node) {
 			k = e.spill(k, n)
 		}
 		e.expr(k.note(n, "interface-converted"), n.X)
-
+	case ir.OSLICE2ARRPTR:
+		// the slice pointer flows directly to the result
+		n := n.(*ir.ConvExpr)
+		e.expr(k, n.X)
 	case ir.ORECV:
 		n := n.(*ir.UnaryExpr)
 		e.discard(n.X)
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 112d3941ce..a9f8c6eae5 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -277,7 +277,7 @@ func (n *ConvExpr) SetOp(op Op) {
 	switch op {
 	default:
 		panic(n.no("SetOp " + op.String()))
-	case OCONV, OCONVIFACE, OCONVNOP, OBYTES2STR, OBYTES2STRTMP, ORUNES2STR, OSTR2BYTES, OSTR2BYTESTMP, OSTR2RUNES, ORUNESTR:
+	case OCONV, OCONVIFACE, OCONVNOP, OBYTES2STR, OBYTES2STRTMP, ORUNES2STR, OSTR2BYTES, OSTR2BYTESTMP, OSTR2RUNES, ORUNESTR, OSLICE2ARRPTR:
 		n.op = op
 	}
 }
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 1a05079dac..8eb1cffc59 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -206,6 +206,7 @@ var OpPrec = []int{
 	OPRINT:         8,
 	ORUNESTR:       8,
 	OSIZEOF:        8,
+	OSLICE2ARRPTR:  8,
 	OSTR2BYTES:     8,
 	OSTR2RUNES:     8,
 	OSTRUCTLIT:     8,
@@ -804,7 +805,8 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		ORUNES2STR,
 		OSTR2BYTES,
 		OSTR2RUNES,
-		ORUNESTR:
+		ORUNESTR,
+		OSLICE2ARRPTR:
 		n := n.(*ConvExpr)
 		if n.Type() == nil || n.Type().Sym() == nil {
 			fmt.Fprintf(s, "(%v)", n.Type())
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index b6be74296f..b4db79e5c2 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -137,6 +137,7 @@ const (
 	OSTR2BYTES    // Type(Left) (Type is []byte, Left is a string)
 	OSTR2BYTESTMP // Type(Left) (Type is []byte, Left is a string, ephemeral)
 	OSTR2RUNES    // Type(Left) (Type is []rune, Left is a string)
+	OSLICE2ARRPTR // Type(Left) (Type is *[N]T, Left is a []T)
 	// Left = Right or (if Colas=true) Left := Right
 	// If Colas, then Ninit includes a DCL node for Left.
 	OAS
diff --git a/src/cmd/compile/internal/ir/op_string.go b/src/cmd/compile/internal/ir/op_string.go
index cfd36c7b3d..156ffd69ba 100644
--- a/src/cmd/compile/internal/ir/op_string.go
+++ b/src/cmd/compile/internal/ir/op_string.go
@@ -29,143 +29,144 @@ func _() {
 	_ = x[OSTR2BYTES-18]
 	_ = x[OSTR2BYTESTMP-19]
 	_ = x[OSTR2RUNES-20]
-	_ = x[OAS-21]
-	_ = x[OAS2-22]
-	_ = x[OAS2DOTTYPE-23]
-	_ = x[OAS2FUNC-24]
-	_ = x[OAS2MAPR-25]
-	_ = x[OAS2RECV-26]
-	_ = x[OASOP-27]
-	_ = x[OCALL-28]
-	_ = x[OCALLFUNC-29]
-	_ = x[OCALLMETH-30]
-	_ = x[OCALLINTER-31]
-	_ = x[OCALLPART-32]
-	_ = x[OCAP-33]
-	_ = x[OCLOSE-34]
-	_ = x[OCLOSURE-35]
-	_ = x[OCOMPLIT-36]
-	_ = x[OMAPLIT-37]
-	_ = x[OSTRUCTLIT-38]
-	_ = x[OARRAYLIT-39]
-	_ = x[OSLICELIT-40]
-	_ = x[OPTRLIT-41]
-	_ = x[OCONV-42]
-	_ = x[OCONVIFACE-43]
-	_ = x[OCONVNOP-44]
-	_ = x[OCOPY-45]
-	_ = x[ODCL-46]
-	_ = x[ODCLFUNC-47]
-	_ = x[ODCLCONST-48]
-	_ = x[ODCLTYPE-49]
-	_ = x[ODELETE-50]
-	_ = x[ODOT-51]
-	_ = x[ODOTPTR-52]
-	_ = x[ODOTMETH-53]
-	_ = x[ODOTINTER-54]
-	_ = x[OXDOT-55]
-	_ = x[ODOTTYPE-56]
-	_ = x[ODOTTYPE2-57]
-	_ = x[OEQ-58]
-	_ = x[ONE-59]
-	_ = x[OLT-60]
-	_ = x[OLE-61]
-	_ = x[OGE-62]
-	_ = x[OGT-63]
-	_ = x[ODEREF-64]
-	_ = x[OINDEX-65]
-	_ = x[OINDEXMAP-66]
-	_ = x[OKEY-67]
-	_ = x[OSTRUCTKEY-68]
-	_ = x[OLEN-69]
-	_ = x[OMAKE-70]
-	_ = x[OMAKECHAN-71]
-	_ = x[OMAKEMAP-72]
-	_ = x[OMAKESLICE-73]
-	_ = x[OMAKESLICECOPY-74]
-	_ = x[OMUL-75]
-	_ = x[ODIV-76]
-	_ = x[OMOD-77]
-	_ = x[OLSH-78]
-	_ = x[ORSH-79]
-	_ = x[OAND-80]
-	_ = x[OANDNOT-81]
-	_ = x[ONEW-82]
-	_ = x[ONOT-83]
-	_ = x[OBITNOT-84]
-	_ = x[OPLUS-85]
-	_ = x[ONEG-86]
-	_ = x[OOROR-87]
-	_ = x[OPANIC-88]
-	_ = x[OPRINT-89]
-	_ = x[OPRINTN-90]
-	_ = x[OPAREN-91]
-	_ = x[OSEND-92]
-	_ = x[OSLICE-93]
-	_ = x[OSLICEARR-94]
-	_ = x[OSLICESTR-95]
-	_ = x[OSLICE3-96]
-	_ = x[OSLICE3ARR-97]
-	_ = x[OSLICEHEADER-98]
-	_ = x[ORECOVER-99]
-	_ = x[ORECV-100]
-	_ = x[ORUNESTR-101]
-	_ = x[OSELRECV2-102]
-	_ = x[OIOTA-103]
-	_ = x[OREAL-104]
-	_ = x[OIMAG-105]
-	_ = x[OCOMPLEX-106]
-	_ = x[OALIGNOF-107]
-	_ = x[OOFFSETOF-108]
-	_ = x[OSIZEOF-109]
-	_ = x[OMETHEXPR-110]
-	_ = x[OSTMTEXPR-111]
-	_ = x[OBLOCK-112]
-	_ = x[OBREAK-113]
-	_ = x[OCASE-114]
-	_ = x[OCONTINUE-115]
-	_ = x[ODEFER-116]
-	_ = x[OFALL-117]
-	_ = x[OFOR-118]
-	_ = x[OFORUNTIL-119]
-	_ = x[OGOTO-120]
-	_ = x[OIF-121]
-	_ = x[OLABEL-122]
-	_ = x[OGO-123]
-	_ = x[ORANGE-124]
-	_ = x[ORETURN-125]
-	_ = x[OSELECT-126]
-	_ = x[OSWITCH-127]
-	_ = x[OTYPESW-128]
-	_ = x[OFUNCINST-129]
-	_ = x[OTCHAN-130]
-	_ = x[OTMAP-131]
-	_ = x[OTSTRUCT-132]
-	_ = x[OTINTER-133]
-	_ = x[OTFUNC-134]
-	_ = x[OTARRAY-135]
-	_ = x[OTSLICE-136]
-	_ = x[OINLCALL-137]
-	_ = x[OEFACE-138]
-	_ = x[OITAB-139]
-	_ = x[OIDATA-140]
-	_ = x[OSPTR-141]
-	_ = x[OCFUNC-142]
-	_ = x[OCHECKNIL-143]
-	_ = x[OVARDEF-144]
-	_ = x[OVARKILL-145]
-	_ = x[OVARLIVE-146]
-	_ = x[ORESULT-147]
-	_ = x[OINLMARK-148]
-	_ = x[OLINKSYMOFFSET-149]
-	_ = x[OTAILCALL-150]
-	_ = x[OGETG-151]
-	_ = x[OEND-152]
+	_ = x[OSLICE2ARRPTR-21]
+	_ = x[OAS-22]
+	_ = x[OAS2-23]
+	_ = x[OAS2DOTTYPE-24]
+	_ = x[OAS2FUNC-25]
+	_ = x[OAS2MAPR-26]
+	_ = x[OAS2RECV-27]
+	_ = x[OASOP-28]
+	_ = x[OCALL-29]
+	_ = x[OCALLFUNC-30]
+	_ = x[OCALLMETH-31]
+	_ = x[OCALLINTER-32]
+	_ = x[OCALLPART-33]
+	_ = x[OCAP-34]
+	_ = x[OCLOSE-35]
+	_ = x[OCLOSURE-36]
+	_ = x[OCOMPLIT-37]
+	_ = x[OMAPLIT-38]
+	_ = x[OSTRUCTLIT-39]
+	_ = x[OARRAYLIT-40]
+	_ = x[OSLICELIT-41]
+	_ = x[OPTRLIT-42]
+	_ = x[OCONV-43]
+	_ = x[OCONVIFACE-44]
+	_ = x[OCONVNOP-45]
+	_ = x[OCOPY-46]
+	_ = x[ODCL-47]
+	_ = x[ODCLFUNC-48]
+	_ = x[ODCLCONST-49]
+	_ = x[ODCLTYPE-50]
+	_ = x[ODELETE-51]
+	_ = x[ODOT-52]
+	_ = x[ODOTPTR-53]
+	_ = x[ODOTMETH-54]
+	_ = x[ODOTINTER-55]
+	_ = x[OXDOT-56]
+	_ = x[ODOTTYPE-57]
+	_ = x[ODOTTYPE2-58]
+	_ = x[OEQ-59]
+	_ = x[ONE-60]
+	_ = x[OLT-61]
+	_ = x[OLE-62]
+	_ = x[OGE-63]
+	_ = x[OGT-64]
+	_ = x[ODEREF-65]
+	_ = x[OINDEX-66]
+	_ = x[OINDEXMAP-67]
+	_ = x[OKEY-68]
+	_ = x[OSTRUCTKEY-69]
+	_ = x[OLEN-70]
+	_ = x[OMAKE-71]
+	_ = x[OMAKECHAN-72]
+	_ = x[OMAKEMAP-73]
+	_ = x[OMAKESLICE-74]
+	_ = x[OMAKESLICECOPY-75]
+	_ = x[OMUL-76]
+	_ = x[ODIV-77]
+	_ = x[OMOD-78]
+	_ = x[OLSH-79]
+	_ = x[ORSH-80]
+	_ = x[OAND-81]
+	_ = x[OANDNOT-82]
+	_ = x[ONEW-83]
+	_ = x[ONOT-84]
+	_ = x[OBITNOT-85]
+	_ = x[OPLUS-86]
+	_ = x[ONEG-87]
+	_ = x[OOROR-88]
+	_ = x[OPANIC-89]
+	_ = x[OPRINT-90]
+	_ = x[OPRINTN-91]
+	_ = x[OPAREN-92]
+	_ = x[OSEND-93]
+	_ = x[OSLICE-94]
+	_ = x[OSLICEARR-95]
+	_ = x[OSLICESTR-96]
+	_ = x[OSLICE3-97]
+	_ = x[OSLICE3ARR-98]
+	_ = x[OSLICEHEADER-99]
+	_ = x[ORECOVER-100]
+	_ = x[ORECV-101]
+	_ = x[ORUNESTR-102]
+	_ = x[OSELRECV2-103]
+	_ = x[OIOTA-104]
+	_ = x[OREAL-105]
+	_ = x[OIMAG-106]
+	_ = x[OCOMPLEX-107]
+	_ = x[OALIGNOF-108]
+	_ = x[OOFFSETOF-109]
+	_ = x[OSIZEOF-110]
+	_ = x[OMETHEXPR-111]
+	_ = x[OSTMTEXPR-112]
+	_ = x[OBLOCK-113]
+	_ = x[OBREAK-114]
+	_ = x[OCASE-115]
+	_ = x[OCONTINUE-116]
+	_ = x[ODEFER-117]
+	_ = x[OFALL-118]
+	_ = x[OFOR-119]
+	_ = x[OFORUNTIL-120]
+	_ = x[OGOTO-121]
+	_ = x[OIF-122]
+	_ = x[OLABEL-123]
+	_ = x[OGO-124]
+	_ = x[ORANGE-125]
+	_ = x[ORETURN-126]
+	_ = x[OSELECT-127]
+	_ = x[OSWITCH-128]
+	_ = x[OTYPESW-129]
+	_ = x[OFUNCINST-130]
+	_ = x[OTCHAN-131]
+	_ = x[OTMAP-132]
+	_ = x[OTSTRUCT-133]
+	_ = x[OTINTER-134]
+	_ = x[OTFUNC-135]
+	_ = x[OTARRAY-136]
+	_ = x[OTSLICE-137]
+	_ = x[OINLCALL-138]
+	_ = x[OEFACE-139]
+	_ = x[OITAB-140]
+	_ = x[OIDATA-141]
+	_ = x[OSPTR-142]
+	_ = x[OCFUNC-143]
+	_ = x[OCHECKNIL-144]
+	_ = x[OVARDEF-145]
+	_ = x[OVARKILL-146]
+	_ = x[OVARLIVE-147]
+	_ = x[ORESULT-148]
+	_ = x[OINLMARK-149]
+	_ = x[OLINKSYMOFFSET-150]
+	_ = x[OTAILCALL-151]
+	_ = x[OGETG-152]
+	_ = x[OEND-153]
 }
 
-const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWFUNCINSTTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKLINKSYMOFFSETTAILCALLGETGEND"
+const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESSLICE2ARRPTRASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWFUNCINSTTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKLINKSYMOFFSETTAILCALLGETGEND"
 
-var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 126, 129, 139, 146, 153, 160, 164, 168, 176, 184, 193, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 280, 284, 287, 294, 302, 309, 315, 318, 324, 331, 339, 343, 350, 358, 360, 362, 364, 366, 368, 370, 375, 380, 388, 391, 400, 403, 407, 415, 422, 431, 444, 447, 450, 453, 456, 459, 462, 468, 471, 474, 480, 484, 487, 491, 496, 501, 507, 512, 516, 521, 529, 537, 543, 552, 563, 570, 574, 581, 589, 593, 597, 601, 608, 615, 623, 629, 637, 645, 650, 655, 659, 667, 672, 676, 679, 687, 691, 693, 698, 700, 705, 711, 717, 723, 729, 737, 742, 746, 753, 759, 764, 770, 776, 783, 788, 792, 797, 801, 806, 814, 820, 827, 834, 840, 847, 860, 868, 872, 875}
+var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 136, 138, 141, 151, 158, 165, 172, 176, 180, 188, 196, 205, 213, 216, 221, 228, 235, 241, 250, 258, 266, 272, 276, 285, 292, 296, 299, 306, 314, 321, 327, 330, 336, 343, 351, 355, 362, 370, 372, 374, 376, 378, 380, 382, 387, 392, 400, 403, 412, 415, 419, 427, 434, 443, 456, 459, 462, 465, 468, 471, 474, 480, 483, 486, 492, 496, 499, 503, 508, 513, 519, 524, 528, 533, 541, 549, 555, 564, 575, 582, 586, 593, 601, 605, 609, 613, 620, 627, 635, 641, 649, 657, 662, 667, 671, 679, 684, 688, 691, 699, 703, 705, 710, 712, 717, 723, 729, 735, 741, 749, 754, 758, 765, 771, 776, 782, 788, 795, 800, 804, 809, 813, 818, 826, 832, 839, 846, 852, 859, 872, 880, 884, 887}
 
 func (i Op) String() string {
 	if i >= Op(len(_Op_index)-1) {
diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index be460457a8..46c2388e7b 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -508,7 +508,7 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64,
 		ls := x.rewriteSelect(leaf, selector.Args[0], offset, regOffset)
 		locs = x.splitSlots(ls, ".ptr", 0, x.typs.BytePtr)
 
-	case OpSlicePtr:
+	case OpSlicePtr, OpSlicePtrUnchecked:
 		w := selector.Args[0]
 		ls := x.rewriteSelect(leaf, w, offset, regOffset)
 		locs = x.splitSlots(ls, ".ptr", 0, types.NewPtr(w.Type.Elem()))
@@ -1202,7 +1202,7 @@ func expandCalls(f *Func) {
 			case OpStructSelect, OpArraySelect,
 				OpIData, OpITab,
 				OpStringPtr, OpStringLen,
-				OpSlicePtr, OpSliceLen, OpSliceCap,
+				OpSlicePtr, OpSliceLen, OpSliceCap, OpSlicePtrUnchecked,
 				OpComplexReal, OpComplexImag,
 				OpInt64Hi, OpInt64Lo:
 				w := v.Args[0]
diff --git a/src/cmd/compile/internal/ssa/gen/dec.rules b/src/cmd/compile/internal/ssa/gen/dec.rules
index 4c677f8418..b19489870d 100644
--- a/src/cmd/compile/internal/ssa/gen/dec.rules
+++ b/src/cmd/compile/internal/ssa/gen/dec.rules
@@ -56,6 +56,7 @@
 (SlicePtr (SliceMake ptr _ _ )) => ptr
 (SliceLen (SliceMake _ len _)) => len
 (SliceCap (SliceMake _ _ cap)) => cap
+(SlicePtrUnchecked (SliceMake ptr _ _ )) => ptr
 
 (Load <t> ptr mem) && t.IsSlice() =>
   (SliceMake
diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go
index c38d22e07f..9f6664386c 100644
--- a/src/cmd/compile/internal/ssa/gen/genericOps.go
+++ b/src/cmd/compile/internal/ssa/gen/genericOps.go
@@ -479,6 +479,10 @@ var genericOps = []opData{
 	{name: "SlicePtr", argLength: 1, typ: "BytePtr"}, // ptr(arg0)
 	{name: "SliceLen", argLength: 1},                 // len(arg0)
 	{name: "SliceCap", argLength: 1},                 // cap(arg0)
+	// SlicePtrUnchecked, like SlicePtr, extracts the pointer from a slice.
+	// SlicePtr values are assumed non-nil, because they are guarded by bounds checks.
+	// SlicePtrUnchecked values can be nil.
+	{name: "SlicePtrUnchecked", argLength: 1},
 
 	// Complex (part/whole)
 	{name: "ComplexMake", argLength: 2}, // arg0=real, arg1=imag
diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go
index b99a7a6646..f09a08abcf 100644
--- a/src/cmd/compile/internal/ssa/op.go
+++ b/src/cmd/compile/internal/ssa/op.go
@@ -469,6 +469,7 @@ const (
 	BoundsSlice3BU                      // ... with unsigned high
 	BoundsSlice3C                       // 3-arg slicing operation, 0 <= low <= high failed
 	BoundsSlice3CU                      // ... with unsigned low
+	BoundsConvert                       // conversion to array pointer failed
 	BoundsKindCount
 )
 
@@ -496,7 +497,8 @@ func boundsABI(b int64) int {
 	case BoundsSlice3Alen,
 		BoundsSlice3AlenU,
 		BoundsSlice3Acap,
-		BoundsSlice3AcapU:
+		BoundsSlice3AcapU,
+		BoundsConvert:
 		return 0
 	case BoundsSliceAlen,
 		BoundsSliceAlenU,
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index 8c753ea2a3..2f56625397 100644
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -2834,6 +2834,7 @@ const (
 	OpSlicePtr
 	OpSliceLen
 	OpSliceCap
+	OpSlicePtrUnchecked
 	OpComplexMake
 	OpComplexReal
 	OpComplexImag
@@ -35898,6 +35899,11 @@ var opcodeTable = [...]opInfo{
 		argLen:  1,
 		generic: true,
 	},
+	{
+		name:    "SlicePtrUnchecked",
+		argLen:  1,
+		generic: true,
+	},
 	{
 		name:    "ComplexMake",
 		argLen:  2,
diff --git a/src/cmd/compile/internal/ssa/rewritedec.go b/src/cmd/compile/internal/ssa/rewritedec.go
index 4b7db60551..2a73a5ddc8 100644
--- a/src/cmd/compile/internal/ssa/rewritedec.go
+++ b/src/cmd/compile/internal/ssa/rewritedec.go
@@ -23,6 +23,8 @@ func rewriteValuedec(v *Value) bool {
 		return rewriteValuedec_OpSliceLen(v)
 	case OpSlicePtr:
 		return rewriteValuedec_OpSlicePtr(v)
+	case OpSlicePtrUnchecked:
+		return rewriteValuedec_OpSlicePtrUnchecked(v)
 	case OpStore:
 		return rewriteValuedec_OpStore(v)
 	case OpStringLen:
@@ -248,6 +250,20 @@ func rewriteValuedec_OpSlicePtr(v *Value) bool {
 	}
 	return false
 }
+func rewriteValuedec_OpSlicePtrUnchecked(v *Value) bool {
+	v_0 := v.Args[0]
+	// match: (SlicePtrUnchecked (SliceMake ptr _ _ ))
+	// result: ptr
+	for {
+		if v_0.Op != OpSliceMake {
+			break
+		}
+		ptr := v_0.Args[0]
+		v.copyOf(ptr)
+		return true
+	}
+	return false
+}
 func rewriteValuedec_OpStore(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index c5b1ae2e4a..10f02fc987 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -164,6 +164,7 @@ func InitConfig() {
 		BoundsCheckFunc[ssa.BoundsSlice3BU] = typecheck.LookupRuntimeFunc("goPanicSlice3BU")
 		BoundsCheckFunc[ssa.BoundsSlice3C] = typecheck.LookupRuntimeFunc("goPanicSlice3C")
 		BoundsCheckFunc[ssa.BoundsSlice3CU] = typecheck.LookupRuntimeFunc("goPanicSlice3CU")
+		BoundsCheckFunc[ssa.BoundsConvert] = typecheck.LookupRuntimeFunc("goPanicSliceConvert")
 	} else {
 		BoundsCheckFunc[ssa.BoundsIndex] = typecheck.LookupRuntimeFunc("panicIndex")
 		BoundsCheckFunc[ssa.BoundsIndexU] = typecheck.LookupRuntimeFunc("panicIndexU")
@@ -181,6 +182,7 @@ func InitConfig() {
 		BoundsCheckFunc[ssa.BoundsSlice3BU] = typecheck.LookupRuntimeFunc("panicSlice3BU")
 		BoundsCheckFunc[ssa.BoundsSlice3C] = typecheck.LookupRuntimeFunc("panicSlice3C")
 		BoundsCheckFunc[ssa.BoundsSlice3CU] = typecheck.LookupRuntimeFunc("panicSlice3CU")
+		BoundsCheckFunc[ssa.BoundsConvert] = typecheck.LookupRuntimeFunc("panicSliceConvert")
 	}
 	if Arch.LinkArch.PtrSize == 4 {
 		ExtendCheckFunc[ssa.BoundsIndex] = typecheck.LookupRuntimeVar("panicExtendIndex")
@@ -3148,6 +3150,18 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		p, l, _ := s.slice(v, i, j, nil, n.Bounded())
 		return s.newValue2(ssa.OpStringMake, n.Type(), p, l)
 
+	case ir.OSLICE2ARRPTR:
+		// if arrlen > slice.len {
+		//   panic(...)
+		// }
+		// slice.ptr
+		n := n.(*ir.ConvExpr)
+		v := s.expr(n.X)
+		arrlen := s.constInt(types.Types[types.TINT], n.Type().Elem().NumElem())
+		cap := s.newValue1(ssa.OpSliceLen, types.Types[types.TINT], v)
+		s.boundsCheck(arrlen, cap, ssa.BoundsConvert, false)
+		return s.newValue1(ssa.OpSlicePtrUnchecked, types.Types[types.TINT], v)
+
 	case ir.OCALLFUNC:
 		n := n.(*ir.CallExpr)
 		if ir.IsIntrinsicCall(n) {
diff --git a/src/cmd/compile/internal/typecheck/builtin.go b/src/cmd/compile/internal/typecheck/builtin.go
index d83791df8b..0631a67780 100644
--- a/src/cmd/compile/internal/typecheck/builtin.go
+++ b/src/cmd/compile/internal/typecheck/builtin.go
@@ -39,6 +39,7 @@ var runtimeDecls = [...]struct {
 	{"goPanicSlice3BU", funcTag, 18},
 	{"goPanicSlice3C", funcTag, 16},
 	{"goPanicSlice3CU", funcTag, 18},
+	{"goPanicSliceConvert", funcTag, 16},
 	{"printbool", funcTag, 19},
 	{"printfloat", funcTag, 21},
 	{"printint", funcTag, 23},
diff --git a/src/cmd/compile/internal/typecheck/builtin/runtime.go b/src/cmd/compile/internal/typecheck/builtin/runtime.go
index 183ae40456..e736f913b6 100644
--- a/src/cmd/compile/internal/typecheck/builtin/runtime.go
+++ b/src/cmd/compile/internal/typecheck/builtin/runtime.go
@@ -46,6 +46,7 @@ func goPanicSlice3B(x int, y int)
 func goPanicSlice3BU(x uint, y int)
 func goPanicSlice3C(x int, y int)
 func goPanicSlice3CU(x uint, y int)
+func goPanicSliceConvert(x int, y int)
 
 func printbool(bool)
 func printfloat(float64)
diff --git a/src/cmd/compile/internal/typecheck/subr.go b/src/cmd/compile/internal/typecheck/subr.go
index 76c565ebee..9ee7a94b1f 100644
--- a/src/cmd/compile/internal/typecheck/subr.go
+++ b/src/cmd/compile/internal/typecheck/subr.go
@@ -574,7 +574,7 @@ func Convertop(srcConstant bool, src, dst *types.Type) (ir.Op, string) {
 		return ir.OCONVNOP, ""
 	}
 
-	// src is map and dst is a pointer to corresponding hmap.
+	// 10. src is map and dst is a pointer to corresponding hmap.
 	// This rule is needed for the implementation detail that
 	// go gc maps are implemented as a pointer to a hmap struct.
 	if src.Kind() == types.TMAP && dst.IsPtr() &&
@@ -582,6 +582,16 @@ func Convertop(srcConstant bool, src, dst *types.Type) (ir.Op, string) {
 		return ir.OCONVNOP, ""
 	}
 
+	// 11. src is a slice and dst is a pointer-to-array.
+	// They must have same element type.
+	if src.IsSlice() && dst.IsPtr() && dst.Elem().IsArray() &&
+		types.Identical(src.Elem(), dst.Elem().Elem()) {
+		if !types.AllowsGoVersion(curpkg(), 1, 17) {
+			return ir.OXXX, ":\n\tconversion of slices to array pointers only supported as of -lang=go1.17"
+		}
+		return ir.OSLICE2ARRPTR, ""
+	}
+
 	return ir.OXXX, ""
 }
 
diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go
index b3b16131ce..68048f28d3 100644
--- a/src/cmd/compile/internal/types2/api_test.go
+++ b/src/cmd/compile/internal/types2/api_test.go
@@ -1578,6 +1578,9 @@ func TestConvertibleTo(t *testing.T) {
 		{newDefined(new(Struct)), new(Struct), true},
 		{newDefined(Typ[Int]), new(Struct), false},
 		{Typ[UntypedInt], Typ[Int], true},
+		{NewSlice(Typ[Int]), NewPointer(NewArray(Typ[Int], 10)), true},
+		{NewSlice(Typ[Int]), NewArray(Typ[Int], 10), false},
+		{NewSlice(Typ[Int]), NewPointer(NewArray(Typ[Uint], 10)), false},
 		// Untyped string values are not permitted by the spec, so the below
 		// behavior is undefined.
 		{Typ[UntypedString], Typ[String], true},
diff --git a/src/cmd/compile/internal/types2/conversions.go b/src/cmd/compile/internal/types2/conversions.go
index eabed7ba9b..51be50e9ad 100644
--- a/src/cmd/compile/internal/types2/conversions.go
+++ b/src/cmd/compile/internal/types2/conversions.go
@@ -135,6 +135,18 @@ func (x *operand) convertibleTo(check *Checker, T Type) bool {
 		return true
 	}
 
+	// "x is a slice, T is a pointer-to-array type,
+	// and the slice and array types have identical element types."
+	if s := asSlice(V); s != nil {
+		if p := asPointer(T); p != nil {
+			if a := asArray(p.Elem()); a != nil {
+				if check.identical(s.Elem(), a.Elem()) {
+					return true
+				}
+			}
+		}
+	}
+
 	return false
 }
 
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 6affbd4aec..a50473db52 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -205,6 +205,11 @@ func walkExpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		n := n.(*ir.ConvExpr)
 		return walkConv(n, init)
 
+	case ir.OSLICE2ARRPTR:
+		n := n.(*ir.ConvExpr)
+		n.X = walkExpr(n.X, init)
+		return n
+
 	case ir.ODIV, ir.OMOD:
 		n := n.(*ir.BinaryExpr)
 		return walkDivMod(n, init)
diff --git a/src/go/types/stdlib_test.go b/src/go/types/stdlib_test.go
index 29f71137df..8f9218c864 100644
--- a/src/go/types/stdlib_test.go
+++ b/src/go/types/stdlib_test.go
@@ -163,6 +163,10 @@ func TestStdTest(t *testing.T) {
 		"embedfunc.go",   // tests //go:embed
 		"embedvers.go",   // tests //go:embed
 		"linkname2.go",   // go/types doesn't check validity of //go:xxx directives
+
+		"convert2.go",     // temporary: go/types doesn't know yet about converting from slices to array pointers
+		"convert4.go",     // temporary: go/types doesn't know yet about converting from slices to array pointers
+		"escape_slice.go", // temporary: go/types doesn't know yet about converting from slices to array pointers
 	)
 }
 
diff --git a/src/runtime/asm_386.s b/src/runtime/asm_386.s
index 5cf6827c21..45f8bf1003 100644
--- a/src/runtime/asm_386.s
+++ b/src/runtime/asm_386.s
@@ -1473,6 +1473,10 @@ TEXT runtime·panicSlice3CU(SB),NOSPLIT,$0-8
 	MOVL	AX, x+0(FP)
 	MOVL	CX, y+4(FP)
 	JMP	runtime·goPanicSlice3CU(SB)
+TEXT runtime·panicSliceConvert(SB),NOSPLIT,$0-8
+	MOVL	DX, x+0(FP)
+	MOVL	BX, y+4(FP)
+	JMP	runtime·goPanicSliceConvert(SB)
 
 // Extended versions for 64-bit indexes.
 TEXT runtime·panicExtendIndex(SB),NOSPLIT,$0-12
diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index 1e6d8189c9..d2848e5a45 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -2091,6 +2091,14 @@ TEXT runtime·panicSlice3CU<ABIInternal>(SB),NOSPLIT,$0-16
 	MOVQ	CX, y+8(FP)
 #endif
 	JMP	runtime·goPanicSlice3CU<ABIInternal>(SB)
+TEXT runtime·panicSliceConvert<ABIInternal>(SB),NOSPLIT,$0-16
+#ifdef GOEXPERIMENT_regabiargs
+	MOVQ	DX, AX
+#else
+	MOVQ	DX, x+0(FP)
+	MOVQ	BX, y+8(FP)
+#endif
+	JMP	runtime·goPanicSliceConvert<ABIInternal>(SB)
 
 #ifdef GOOS_android
 // Use the free TLS_SLOT_APP slot #2 on Android Q.
diff --git a/src/runtime/asm_arm.s b/src/runtime/asm_arm.s
index 9896ab4383..f468b77ee3 100644
--- a/src/runtime/asm_arm.s
+++ b/src/runtime/asm_arm.s
@@ -992,6 +992,10 @@ TEXT runtime·panicSlice3CU(SB),NOSPLIT,$0-8
 	MOVW	R0, x+0(FP)
 	MOVW	R1, y+4(FP)
 	JMP	runtime·goPanicSlice3CU(SB)
+TEXT runtime·panicSliceConvert(SB),NOSPLIT,$0-8
+	MOVW	R2, x+0(FP)
+	MOVW	R3, y+4(FP)
+	JMP	runtime·goPanicSliceConvert(SB)
 
 // Extended versions for 64-bit indexes.
 TEXT runtime·panicExtendIndex(SB),NOSPLIT,$0-12
diff --git a/src/runtime/asm_arm64.s b/src/runtime/asm_arm64.s
index 2e120dcf1e..2d495397a8 100644
--- a/src/runtime/asm_arm64.s
+++ b/src/runtime/asm_arm64.s
@@ -1314,3 +1314,7 @@ TEXT runtime·panicSlice3CU(SB),NOSPLIT,$0-16
 	MOVD	R0, x+0(FP)
 	MOVD	R1, y+8(FP)
 	JMP	runtime·goPanicSlice3CU(SB)
+TEXT runtime·panicSliceConvert(SB),NOSPLIT,$0-16
+	MOVD	R2, x+0(FP)
+	MOVD	R3, y+8(FP)
+	JMP	runtime·goPanicSliceConvert(SB)
diff --git a/src/runtime/asm_mips64x.s b/src/runtime/asm_mips64x.s
index cee4b528bb..c3b57e472a 100644
--- a/src/runtime/asm_mips64x.s
+++ b/src/runtime/asm_mips64x.s
@@ -805,3 +805,7 @@ TEXT runtime·panicSlice3CU(SB),NOSPLIT,$0-16
 	MOVV	R1, x+0(FP)
 	MOVV	R2, y+8(FP)
 	JMP	runtime·goPanicSlice3CU(SB)
+TEXT runtime·panicSliceConvert(SB),NOSPLIT,$0-16
+	MOVV	R3, x+0(FP)
+	MOVV	R4, y+8(FP)
+	JMP	runtime·goPanicSliceConvert(SB)
diff --git a/src/runtime/asm_mipsx.s b/src/runtime/asm_mipsx.s
index 17fbc902c2..1d828b03cf 100644
--- a/src/runtime/asm_mipsx.s
+++ b/src/runtime/asm_mipsx.s
@@ -801,6 +801,10 @@ TEXT runtime·panicSlice3CU(SB),NOSPLIT,$0-8
 	MOVW	R1, x+0(FP)
 	MOVW	R2, y+4(FP)
 	JMP	runtime·goPanicSlice3CU(SB)
+TEXT runtime·panicSliceConvert(SB),NOSPLIT,$0-8
+	MOVW	R3, x+0(FP)
+	MOVW	R4, y+4(FP)
+	JMP	runtime·goPanicSliceConvert(SB)
 
 // Extended versions for 64-bit indexes.
 TEXT runtime·panicExtendIndex(SB),NOSPLIT,$0-12
diff --git a/src/runtime/asm_ppc64x.s b/src/runtime/asm_ppc64x.s
index 6544048497..2c39b38912 100644
--- a/src/runtime/asm_ppc64x.s
+++ b/src/runtime/asm_ppc64x.s
@@ -1022,3 +1022,7 @@ TEXT runtime·panicSlice3CU(SB),NOSPLIT,$0-16
 	MOVD	R3, x+0(FP)
 	MOVD	R4, y+8(FP)
 	JMP	runtime·goPanicSlice3CU(SB)
+TEXT runtime·panicSliceConvert(SB),NOSPLIT,$0-16
+	MOVD	R5, x+0(FP)
+	MOVD	R6, y+8(FP)
+	JMP	runtime·goPanicSliceConvert(SB)
diff --git a/src/runtime/asm_riscv64.s b/src/runtime/asm_riscv64.s
index d8d5252ed5..ef7af4e10d 100644
--- a/src/runtime/asm_riscv64.s
+++ b/src/runtime/asm_riscv64.s
@@ -806,6 +806,10 @@ TEXT runtime·panicSlice3CU(SB),NOSPLIT,$0-16
 	MOV	T0, x+0(FP)
 	MOV	T1, y+8(FP)
 	JMP	runtime·goPanicSlice3CU(SB)
+TEXT runtime·panicSliceConvert(SB),NOSPLIT,$0-16
+	MOV	T2, x+0(FP)
+	MOV	T3, y+8(FP)
+	JMP	runtime·goPanicSliceConvert(SB)
 
 DATA	runtime·mainPC+0(SB)/8,$runtime·main(SB)
 GLOBL	runtime·mainPC(SB),RODATA,$8
diff --git a/src/runtime/asm_s390x.s b/src/runtime/asm_s390x.s
index 4748e00aa8..fb38271630 100644
--- a/src/runtime/asm_s390x.s
+++ b/src/runtime/asm_s390x.s
@@ -906,3 +906,7 @@ TEXT runtime·panicSlice3CU(SB),NOSPLIT,$0-16
 	MOVD	R0, x+0(FP)
 	MOVD	R1, y+8(FP)
 	JMP	runtime·goPanicSlice3CU(SB)
+TEXT runtime·panicSliceConvert(SB),NOSPLIT,$0-16
+	MOVD	R2, x+0(FP)
+	MOVD	R3, y+8(FP)
+	JMP	runtime·goPanicSliceConvert(SB)
diff --git a/src/runtime/error.go b/src/runtime/error.go
index 9e6cdf35dd..91f83ae126 100644
--- a/src/runtime/error.go
+++ b/src/runtime/error.go
@@ -134,6 +134,7 @@ const (
 	boundsSlice3B    // s[?:x:y], 0 <= x <= y failed (but boundsSlice3A didn't happen)
 	boundsSlice3C    // s[x:y:?], 0 <= x <= y failed (but boundsSlice3A/B didn't happen)
 
+	boundsConvert // (*[x]T)(s), 0 <= x <= len(s) failed
 	// Note: in the above, len(s) and cap(s) are stored in y
 )
 
@@ -149,6 +150,7 @@ var boundsErrorFmts = [...]string{
 	boundsSlice3Acap: "slice bounds out of range [::%x] with capacity %y",
 	boundsSlice3B:    "slice bounds out of range [:%x:%y]",
 	boundsSlice3C:    "slice bounds out of range [%x:%y:]",
+	boundsConvert:    "cannot convert slice with length %y to pointer to array with length %x",
 }
 
 // boundsNegErrorFmts are overriding formats if x is negative. In this case there's no need to report y.
diff --git a/src/runtime/panic.go b/src/runtime/panic.go
index f8f2f39dbb..f6c38aafcc 100644
--- a/src/runtime/panic.go
+++ b/src/runtime/panic.go
@@ -160,6 +160,12 @@ func goPanicSlice3CU(x uint, y int) {
 	panic(boundsError{x: int64(x), signed: false, y: y, code: boundsSlice3C})
 }
 
+// failures in the conversion (*[x]T)s, 0 <= x <= y, x == cap(s)
+func goPanicSliceConvert(x int, y int) {
+	panicCheck1(getcallerpc(), "slice length too short to convert to pointer to array")
+	panic(boundsError{x: int64(x), signed: true, y: y, code: boundsConvert})
+}
+
 // Implemented in assembly, as they take arguments in registers.
 // Declared here to mark them as ABIInternal.
 func panicIndex(x int, y int)
@@ -178,6 +184,7 @@ func panicSlice3B(x int, y int)
 func panicSlice3BU(x uint, y int)
 func panicSlice3C(x int, y int)
 func panicSlice3CU(x uint, y int)
+func panicSliceConvert(x int, y int)
 
 var shiftError = error(errorString("negative shift amount"))
 
diff --git a/test/convert2.go b/test/convert2.go
index e7044b2453..8e43967aaa 100644
--- a/test/convert2.go
+++ b/test/convert2.go
@@ -313,3 +313,17 @@ func _() {
 	t = u       // ERROR "cannot use .* in assignment|incompatible type"
 	t = (*T)(u) // ERROR "cannot convert"
 }
+
+func _() {
+	var s []byte
+	_ = ([4]byte)(s) // ERROR "cannot convert"
+	_ = (*[4]byte)(s)
+
+	type A [4]byte
+	_ = (A)(s) // ERROR "cannot convert"
+	_ = (*A)(s)
+
+	type P *[4]byte
+	_ = (P)(s)
+	_ = (*P)(s) // ERROR "cannot convert"
+}
diff --git a/test/convert4.go b/test/convert4.go
new file mode 100644
index 0000000000..2bc9c96a52
--- /dev/null
+++ b/test/convert4.go
@@ -0,0 +1,86 @@
+// run
+
+// Copyright 2020 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.
+
+// Test conversion from slice to array pointer.
+
+package main
+
+func wantPanic(fn func(), s string) {
+	defer func() {
+		err := recover()
+		if err == nil {
+			panic("expected panic")
+		}
+		if got := err.(error).Error(); got != s {
+			panic("expected panic " + s + " got " + got)
+		}
+	}()
+	fn()
+}
+
+func main() {
+	s := make([]byte, 8, 10)
+	if p := (*[8]byte)(s); &p[0] != &s[0] {
+		panic("*[8]byte conversion failed")
+	}
+	wantPanic(
+		func() {
+			_ = (*[9]byte)(s)
+		},
+		"runtime error: cannot convert slice with length 8 to pointer to array with length 9",
+	)
+
+	var n []byte
+	if p := (*[0]byte)(n); p != nil {
+		panic("nil slice converted to *[0]byte should be nil")
+	}
+
+	z := make([]byte, 0)
+	if p := (*[0]byte)(z); p == nil {
+		panic("empty slice converted to *[0]byte should be non-nil")
+	}
+
+	// Test with named types
+	type Slice []int
+	type Int4 [4]int
+	type PInt4 *[4]int
+	ii := make(Slice, 4)
+	if p := (*Int4)(ii); &p[0] != &ii[0] {
+		panic("*Int4 conversion failed")
+	}
+	if p := PInt4(ii); &p[0] != &ii[0] {
+		panic("PInt4 conversion failed")
+	}
+}
+
+// test static variable conversion
+
+var (
+	ss  = make([]string, 10)
+	s5  = (*[5]string)(ss)
+	s10 = (*[10]string)(ss)
+
+	ns  []string
+	ns0 = (*[0]string)(ns)
+
+	zs  = make([]string, 0)
+	zs0 = (*[0]string)(zs)
+)
+
+func init() {
+	if &ss[0] != &s5[0] {
+		panic("s5 conversion failed")
+	}
+	if &ss[0] != &s10[0] {
+		panic("s5 conversion failed")
+	}
+	if ns0 != nil {
+		panic("ns0 should be nil")
+	}
+	if zs0 == nil {
+		panic("zs0 should not be nil")
+	}
+}
diff --git a/test/escape_slice.go b/test/escape_slice.go
index 6ce852e9c5..d60414736c 100644
--- a/test/escape_slice.go
+++ b/test/escape_slice.go
@@ -101,6 +101,10 @@ func slice11() {
 	_ = s
 }
 
+func slice12(x []int) *[1]int { // ERROR "leaking param: x to result ~r1 level=0$"
+	return (*[1]int)(x)
+}
+
 func envForDir(dir string) []string { // ERROR "dir does not escape"
 	env := os.Environ()
 	return mergeEnvLists([]string{"PWD=" + dir}, env) // ERROR ".PWD=. \+ dir escapes to heap" "\[\]string{...} does not escape"
-- 
GitLab


From c18744377afa1f9c2310c122e6932fa663f9294a Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Sun, 14 Mar 2021 14:27:28 -0700
Subject: [PATCH 1674/2400] go/types: allow conversion from slice to array ptr

These match the changes to cmd/compile/internal/types2 in CL 301650.

Updates #395

Change-Id: I1e85b6355c8c8fdba0996c26a2505c65fab908d6
Reviewed-on: https://go-review.googlesource.com/c/go/+/301651
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/api_test.go    |  3 +++
 src/go/types/conversions.go | 12 ++++++++++++
 src/go/types/stdlib_test.go |  4 ----
 3 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go
index 6998fc0a0d..3438d79024 100644
--- a/src/go/types/api_test.go
+++ b/src/go/types/api_test.go
@@ -1430,6 +1430,9 @@ func TestConvertibleTo(t *testing.T) {
 		{newDefined(new(Struct)), new(Struct), true},
 		{newDefined(Typ[Int]), new(Struct), false},
 		{Typ[UntypedInt], Typ[Int], true},
+		{NewSlice(Typ[Int]), NewPointer(NewArray(Typ[Int], 10)), true},
+		{NewSlice(Typ[Int]), NewArray(Typ[Int], 10), false},
+		{NewSlice(Typ[Int]), NewPointer(NewArray(Typ[Uint], 10)), false},
 		// Untyped string values are not permitted by the spec, so the below
 		// behavior is undefined.
 		{Typ[UntypedString], Typ[String], true},
diff --git a/src/go/types/conversions.go b/src/go/types/conversions.go
index d93ff465bb..e977d0db1f 100644
--- a/src/go/types/conversions.go
+++ b/src/go/types/conversions.go
@@ -133,6 +133,18 @@ func (x *operand) convertibleTo(check *Checker, T Type) bool {
 		return true
 	}
 
+	// "x is a slice, T is a pointer-to-array type,
+	// and the slice and array types have identical element types."
+	if s := asSlice(V); s != nil {
+		if p := asPointer(T); p != nil {
+			if a := asArray(p.Elem()); a != nil {
+				if check.identical(s.Elem(), a.Elem()) {
+					return true
+				}
+			}
+		}
+	}
+
 	return false
 }
 
diff --git a/src/go/types/stdlib_test.go b/src/go/types/stdlib_test.go
index 8f9218c864..29f71137df 100644
--- a/src/go/types/stdlib_test.go
+++ b/src/go/types/stdlib_test.go
@@ -163,10 +163,6 @@ func TestStdTest(t *testing.T) {
 		"embedfunc.go",   // tests //go:embed
 		"embedvers.go",   // tests //go:embed
 		"linkname2.go",   // go/types doesn't check validity of //go:xxx directives
-
-		"convert2.go",     // temporary: go/types doesn't know yet about converting from slices to array pointers
-		"convert4.go",     // temporary: go/types doesn't know yet about converting from slices to array pointers
-		"escape_slice.go", // temporary: go/types doesn't know yet about converting from slices to array pointers
 	)
 }
 
-- 
GitLab


From 760d3b2a16544aab553ca7ec6e6ed3bf4dc9aa3f Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Sun, 14 Mar 2021 14:31:50 -0700
Subject: [PATCH 1675/2400] reflect: allow conversion from slice to array ptr

Note that this removes an invariant:

v.Type().ConvertibleTo(t) might return true,
yet v.Convert(t) might panic nevertheless.

This is a fairly unavoidable consequence of the decision
to add the first-ever conversion that can panic.

ConvertibleTo describes a relationship between types,
but whether the conversion panics now depends on the value,
not just the type.

If this turns out to be a problem, we can add v.ConvertibleTo(t),
or something similar, to allow callers to avoid the panic.

This is the last of the changes needed to complete the implementation.

Fixes #395

Change-Id: I79b7e4dd87a67a47723e00a65d0b1ac6090371b7
Reviewed-on: https://go-review.googlesource.com/c/go/+/301652
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/reflect/all_test.go | 44 +++++++++++++++++++++++++++++++++++++++++
 src/reflect/type.go     |  2 ++
 src/reflect/value.go    | 18 ++++++++++++++++-
 3 files changed, 63 insertions(+), 1 deletion(-)

diff --git a/src/reflect/all_test.go b/src/reflect/all_test.go
index 3269f5ffce..065ff04611 100644
--- a/src/reflect/all_test.go
+++ b/src/reflect/all_test.go
@@ -3822,6 +3822,10 @@ type MyStruct2 struct {
 }
 type MyString string
 type MyBytes []byte
+type MyBytesArrayPtr0 *[0]byte
+type MyBytesArrayPtr *[4]byte
+type MyBytesArray0 [0]byte
+type MyBytesArray [4]byte
 type MyRunes []int32
 type MyFunc func()
 type MyByte byte
@@ -4128,6 +4132,30 @@ var convertTests = []struct {
 	{V(MyString("runes♝")), V(MyRunes("runes♝"))},
 	{V(MyRunes("runes♕")), V(MyString("runes♕"))},
 
+	// slice to array pointer
+	{V([]byte(nil)), V((*[0]byte)(nil))},
+	{V([]byte{}), V(new([0]byte))},
+	{V([]byte{7}), V(&[1]byte{7})},
+	{V(MyBytes([]byte(nil))), V((*[0]byte)(nil))},
+	{V(MyBytes([]byte{})), V(new([0]byte))},
+	{V(MyBytes([]byte{9})), V(&[1]byte{9})},
+	{V([]byte(nil)), V(MyBytesArrayPtr0(nil))},
+	{V([]byte{}), V(MyBytesArrayPtr0(new([0]byte)))},
+	{V([]byte{1, 2, 3, 4}), V(MyBytesArrayPtr(&[4]byte{1, 2, 3, 4}))},
+	{V(MyBytes([]byte{})), V(MyBytesArrayPtr0(new([0]byte)))},
+	{V(MyBytes([]byte{5, 6, 7, 8})), V(MyBytesArrayPtr(&[4]byte{5, 6, 7, 8}))},
+
+	{V([]byte(nil)), V((*MyBytesArray0)(nil))},
+	{V([]byte{}), V((*MyBytesArray0)(new([0]byte)))},
+	{V([]byte{1, 2, 3, 4}), V(&MyBytesArray{1, 2, 3, 4})},
+	{V(MyBytes([]byte(nil))), V((*MyBytesArray0)(nil))},
+	{V(MyBytes([]byte{})), V((*MyBytesArray0)(new([0]byte)))},
+	{V(MyBytes([]byte{5, 6, 7, 8})), V(&MyBytesArray{5, 6, 7, 8})},
+	{V(new([0]byte)), V(new(MyBytesArray0))},
+	{V(new(MyBytesArray0)), V(new([0]byte))},
+	{V(MyBytesArrayPtr0(nil)), V((*[0]byte)(nil))},
+	{V((*[0]byte)(nil)), V(MyBytesArrayPtr0(nil))},
+
 	// named types and equal underlying types
 	{V(new(int)), V(new(integer))},
 	{V(new(integer)), V(new(int))},
@@ -4288,6 +4316,9 @@ func TestConvert(t *testing.T) {
 		if vout2.Type() != tt.out.Type() || !DeepEqual(out2, tt.out.Interface()) {
 			t.Errorf("ValueOf(%T(%[1]v)).Convert(%s) = %T(%[3]v), want %T(%[4]v)", tt.in.Interface(), t2, out2, tt.out.Interface())
 		}
+		if got, want := vout2.Kind(), vout2.Type().Kind(); got != want {
+			t.Errorf("ValueOf(%T(%[1]v)).Convert(%s) has internal kind %v want %v", tt.in.Interface(), t1, got, want)
+		}
 
 		// vout3 represents a new value of the out type, set to vout2.  This makes
 		// sure the converted value vout2 is really usable as a regular value.
@@ -4332,6 +4363,19 @@ func TestConvert(t *testing.T) {
 	}
 }
 
+func TestConvertPanic(t *testing.T) {
+	s := make([]byte, 4)
+	p := new([8]byte)
+	v := ValueOf(s)
+	pt := TypeOf(p)
+	if !v.Type().ConvertibleTo(pt) {
+		t.Errorf("[]byte should be convertible to *[8]byte")
+	}
+	shouldPanic("reflect: cannot convert slice with length 4 to array pointer with length 8", func() {
+		_ = v.Convert(pt)
+	})
+}
+
 var gFloat32 float32
 
 func TestConvertNaNs(t *testing.T) {
diff --git a/src/reflect/type.go b/src/reflect/type.go
index d50559e933..9727bfe467 100644
--- a/src/reflect/type.go
+++ b/src/reflect/type.go
@@ -106,9 +106,11 @@ type Type interface {
 	AssignableTo(u Type) bool
 
 	// ConvertibleTo reports whether a value of the type is convertible to type u.
+	// Even if ConvertibleTo returns true, the conversion may still panic.
 	ConvertibleTo(u Type) bool
 
 	// Comparable reports whether values of this type are comparable.
+	// Even if Comparable returns true, the comparison may still panic.
 	Comparable() bool
 
 	// Methods applicable only to some types, depending on Kind.
diff --git a/src/reflect/value.go b/src/reflect/value.go
index 6f1a3c02d6..418dff781f 100644
--- a/src/reflect/value.go
+++ b/src/reflect/value.go
@@ -6,6 +6,7 @@ package reflect
 
 import (
 	"internal/abi"
+	"internal/itoa"
 	"internal/unsafeheader"
 	"math"
 	"runtime"
@@ -2770,7 +2771,7 @@ func (v Value) assignTo(context string, dst *rtype, target unsafe.Pointer) Value
 
 // Convert returns the value v converted to type t.
 // If the usual Go conversion rules do not allow conversion
-// of the value v to type t, Convert panics.
+// of the value v to type t, or if converting v to type t panics, Convert panics.
 func (v Value) Convert(t Type) Value {
 	if v.flag&flagMethod != 0 {
 		v = makeMethodValue("Convert", v)
@@ -2841,6 +2842,11 @@ func convertOp(dst, src *rtype) func(Value, Type) Value {
 				return cvtRunesString
 			}
 		}
+		// "x is a slice, T is a pointer-to-array type,
+		// and the slice and array types have identical element types."
+		if dst.Kind() == Ptr && dst.Elem().Kind() == Array && src.Elem() == dst.Elem().Elem() {
+			return cvtSliceArrayPtr
+		}
 
 	case Chan:
 		if dst.Kind() == Chan && specialChannelAssignability(dst, src) {
@@ -3034,6 +3040,16 @@ func cvtStringRunes(v Value, t Type) Value {
 	return makeRunes(v.flag.ro(), []rune(v.String()), t)
 }
 
+// convertOp: []T -> *[N]T
+func cvtSliceArrayPtr(v Value, t Type) Value {
+	n := t.Elem().Len()
+	h := (*unsafeheader.Slice)(v.ptr)
+	if n > h.Len {
+		panic("reflect: cannot convert slice with length " + itoa.Itoa(h.Len) + " to array pointer with length " + itoa.Itoa(n))
+	}
+	return Value{t.common(), h.Data, v.flag&^(flagIndir|flagAddr|flagKindMask) | flag(Ptr)}
+}
+
 // convertOp: direct copy
 func cvtDirect(v Value, typ Type) Value {
 	f := v.flag
-- 
GitLab


From 190cb937f7acdc1568a09c0cbbe1c14031c94ca9 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 19 Apr 2021 18:48:16 -0700
Subject: [PATCH 1676/2400] cmd/compile/internal/types2: fix type inference

Don't let type parameters that are not filled in with concrete
type arguments escape from constraint type inference - such
inferred types are not "real".

While at it, implement a tparamsList.String method for debugging.

Fixes #45548.

Change-Id: I40f13ff7af08d0357a5c66234bfcdd0b7ed5fdd6
Reviewed-on: https://go-review.googlesource.com/c/go/+/311651
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 .../internal/types2/fixedbugs/issue45548.go2  | 13 +++++++++++++
 src/cmd/compile/internal/types2/infer.go      | 19 +++++++++++++++++++
 src/cmd/compile/internal/types2/unify.go      | 18 ++++++++++++++++++
 3 files changed, 50 insertions(+)
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue45548.go2

diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue45548.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue45548.go2
new file mode 100644
index 0000000000..b1e42497e8
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue45548.go2
@@ -0,0 +1,13 @@
+// Copyright 2021 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 p
+
+func f[F interface{type *Q}, G interface{type *R}, Q, R any](q Q, r R) {}
+
+func _() {
+	f[*float64, *int](1, 2)
+	f[*float64](1, 2)
+	f(1, 2)
+}
diff --git a/src/cmd/compile/internal/types2/infer.go b/src/cmd/compile/internal/types2/infer.go
index 13a9ccda0c..c136823fd8 100644
--- a/src/cmd/compile/internal/types2/infer.go
+++ b/src/cmd/compile/internal/types2/infer.go
@@ -451,6 +451,25 @@ func (check *Checker) inferB(tparams []*TypeName, targs []Type, report bool) (ty
 		dirty = dirty[:n]
 	}
 
+	// Once nothing changes anymore, we may still have type parameters left;
+	// e.g., a structural constraint *P may match a type parameter Q but we
+	// don't have any type arguments to fill in for *P or Q (issue #45548).
+	// Don't let such inferences escape, instead nil them out.
+	for i, typ := range types {
+		if typ != nil && isParameterized(tparams, typ) {
+			types[i] = nil
+		}
+	}
+
+	// update index
+	index = -1
+	for i, typ := range types {
+		if typ == nil {
+			index = i
+			break
+		}
+	}
+
 	return
 }
 
diff --git a/src/cmd/compile/internal/types2/unify.go b/src/cmd/compile/internal/types2/unify.go
index d2ea2b952b..e1832bbb2a 100644
--- a/src/cmd/compile/internal/types2/unify.go
+++ b/src/cmd/compile/internal/types2/unify.go
@@ -6,6 +6,8 @@
 
 package types2
 
+import "bytes"
+
 // The unifier maintains two separate sets of type parameters x and y
 // which are used to resolve type parameters in the x and y arguments
 // provided to the unify call. For unidirectional unification, only
@@ -69,6 +71,22 @@ type tparamsList struct {
 	indices []int // len(d.indices) == len(d.tparams)
 }
 
+// String returns a string representation for a tparamsList. For debugging.
+func (d *tparamsList) String() string {
+	var buf bytes.Buffer
+	buf.WriteByte('[')
+	for i, tname := range d.tparams {
+		if i > 0 {
+			buf.WriteString(", ")
+		}
+		writeType(&buf, tname.typ, nil, nil)
+		buf.WriteString(": ")
+		writeType(&buf, d.at(i), nil, nil)
+	}
+	buf.WriteByte(']')
+	return buf.String()
+}
+
 // init initializes d with the given type parameters.
 // The type parameters must be in the order in which they appear in their declaration
 // (this ensures that the tparams indices match the respective type parameter index).
-- 
GitLab


From c33ced6d8a2bb4db6896ff36cfcaac2bbdf123d1 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Tue, 20 Apr 2021 17:02:37 -0700
Subject: [PATCH 1677/2400] runtime: don't test sig.inuse in sigsend

Signals can be delivered on a different thread. There is no necessary
happens-before relationship between setting sig.inuse in signal_enable
and checking it in sigsend. It is theoretically possible, if unlikely,
that sig.inuse is set by thread 1, thread 2 receives a signal, does not
see that sig.inuse is set, and discards the signal. This could happen
if the signal is received immediately after the first call to signal_enable.

For #33174

Change-Id: Idb0f1c77847b7d4d418bd139e801c0c4460531d2
Reviewed-on: https://go-review.googlesource.com/c/go/+/312131
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/runtime/sigqueue.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/sigqueue.go b/src/runtime/sigqueue.go
index a282c7aca7..aae1d00046 100644
--- a/src/runtime/sigqueue.go
+++ b/src/runtime/sigqueue.go
@@ -72,7 +72,7 @@ const (
 // It runs from the signal handler, so it's limited in what it can do.
 func sigsend(s uint32) bool {
 	bit := uint32(1) << uint(s&31)
-	if !sig.inuse || s >= uint32(32*len(sig.wanted)) {
+	if s >= uint32(32*len(sig.wanted)) {
 		return false
 	}
 
-- 
GitLab


From 81fcb18df5557943a80d27f248de43968e048aae Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Wed, 14 Apr 2021 17:12:27 -0400
Subject: [PATCH 1678/2400] cmd/go: make Tidy an option in PackageOpts rather
 than a separate call

This eliminates some awkwardly-stateful outside calls to
modload.{Disallow,Allow,}WriteGoMod.

Perhaps more importantly, it gives the loader the opportunity to
reload packages and revise dependencies after the tidied requirements
are computed. With lazy loading, dropping an irrelevant requirement
from the main module's go.mod file may (rarely) cause other test
dependencies for packages outside the main module to become
unresolved, which may require the loader to re-resolve those
dependencies, which may in turn add new roots and increase the
selected versions of modules providing other packages.

This refactoring allows the loader to iterate between tidying the
build list and reloading packages as needed, making the exact
sequencing of loading and tidying an implementation detail of the
modload package.

For #36460
For #40775

Change-Id: Ib6da3672f32153d5bd7d653d85e3672ab96cbe36
Reviewed-on: https://go-review.googlesource.com/c/go/+/310181
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modcmd/tidy.go       | 14 +--------
 src/cmd/go/internal/modload/buildlist.go | 21 ++++++--------
 src/cmd/go/internal/modload/init.go      | 36 +++++++++++++++---------
 src/cmd/go/internal/modload/load.go      | 30 +++++++++++++-------
 4 files changed, 51 insertions(+), 50 deletions(-)

diff --git a/src/cmd/go/internal/modcmd/tidy.go b/src/cmd/go/internal/modcmd/tidy.go
index fc70cd3f22..a9b277817f 100644
--- a/src/cmd/go/internal/modcmd/tidy.go
+++ b/src/cmd/go/internal/modcmd/tidy.go
@@ -60,26 +60,14 @@ func runTidy(ctx context.Context, cmd *base.Command, args []string) {
 	// request that their test dependencies be included.
 	modload.ForceUseModules = true
 	modload.RootMode = modload.NeedRoot
-	modload.DisallowWriteGoMod() // Suppress writing until we've tidied the file.
 
 	modload.LoadPackages(ctx, modload.PackageOpts{
 		Tags:                     imports.AnyTags(),
+		Tidy:                     true,
 		VendorModulesInGOROOTSrc: true,
 		ResolveMissingImports:    true,
 		LoadTests:                true,
 		AllowErrors:              tidyE,
 		SilenceMissingStdImports: true,
 	}, "all")
-
-	modload.TidyBuildList(ctx)
-	modload.TrimGoSum(ctx)
-
-	modload.AllowWriteGoMod()
-
-	// TODO(#40775): Toggling global state via AllowWriteGoMod makes the
-	// invariants for go.mod cleanliness harder to reason about. Instead, either
-	// make DisallowWriteGoMod an explicit PackageOpts field, or add a Tidy
-	// argument to modload.LoadPackages so that Tidy is just one call into the
-	// module loader, or perhaps both.
-	modload.WriteGoMod(ctx)
 }
diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index ad138887a0..2eb47d2c9f 100644
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -79,8 +79,8 @@ type cachedGraph struct {
 //
 // It is always non-nil if the main module's go.mod file has been loaded.
 //
-// This variable should only be read from the LoadModFile function,
-// and should only be written in the writeGoMod function.
+// This variable should only be read from the loadModFile function, and should
+// only be written in the loadModFile and commitRequirements functions.
 // All other functions that need or produce a *Requirements should
 // accept and/or return an explicit parameter.
 var requirements *Requirements
@@ -538,14 +538,9 @@ type Conflict struct {
 	Constraint module.Version
 }
 
-// TidyBuildList trims the build list to the minimal requirements needed to
-// retain the same versions of all packages from the preceding call to
-// LoadPackages.
-func TidyBuildList(ctx context.Context) {
-	if loaded == nil {
-		panic("internal error: TidyBuildList called when no packages have been loaded")
-	}
-
+// tidyBuildList trims the build list to the minimal requirements needed to
+// retain the same versions of all packages loaded by ld.
+func tidyBuildList(ctx context.Context, ld *loader, initialRS *Requirements) *Requirements {
 	if go117LazyTODO {
 		// Tidy needs to maintain the lazy-loading invariants for lazy modules.
 		// The implementation for eager modules should be factored out into a function.
@@ -557,7 +552,7 @@ func TidyBuildList(ctx context.Context) {
 		// changed after loading packages.
 	}
 
-	tidy, err := updateRoots(ctx, depth, loaded.requirements.direct, loaded.pkgs, nil)
+	tidy, err := updateRoots(ctx, depth, ld.requirements.direct, ld.pkgs, nil)
 	if err != nil {
 		base.Fatalf("go: %v", err)
 	}
@@ -565,7 +560,7 @@ func TidyBuildList(ctx context.Context) {
 	if cfg.BuildV {
 		mg, _ := tidy.Graph(ctx)
 
-		for _, m := range LoadModFile(ctx).rootModules {
+		for _, m := range initialRS.rootModules {
 			if mg.Selected(m.Path) == "none" {
 				fmt.Fprintf(os.Stderr, "unused %s\n", m.Path)
 			} else if go117LazyTODO {
@@ -575,7 +570,7 @@ func TidyBuildList(ctx context.Context) {
 		}
 	}
 
-	commitRequirements(ctx, tidy)
+	return tidy
 }
 
 // updateRoots returns a set of root requirements that includes the selected
diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index 35bbcc795e..953419a718 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -365,8 +365,8 @@ var errGoModDirty error = goModDirtyError{}
 // build list from its go.mod file.
 //
 // LoadModFile may make changes in memory, like adding a go directive and
-// ensuring requirements are consistent. WriteGoMod should be called later to
-// write changes out to disk or report errors in readonly mode.
+// ensuring requirements are consistent, and will write those changes back to
+// disk unless DisallowWriteGoMod is in effect.
 //
 // As a side-effect, LoadModFile may change cfg.BuildMod to "vendor" if
 // -mod wasn't set explicitly and automatic vendoring should be enabled.
@@ -379,8 +379,22 @@ var errGoModDirty error = goModDirtyError{}
 // it for global consistency. Most callers outside of the modload package should
 // use LoadModGraph instead.
 func LoadModFile(ctx context.Context) *Requirements {
+	rs, needCommit := loadModFile(ctx)
+	if needCommit {
+		commitRequirements(ctx, rs)
+	}
+	return rs
+}
+
+// loadModFile is like LoadModFile, but does not implicitly commit the
+// requirements back to disk after fixing inconsistencies.
+//
+// If needCommit is true, after the caller makes any other needed changes to the
+// returned requirements they should invoke commitRequirements to fix any
+// inconsistencies that may be present in the on-disk go.mod file.
+func loadModFile(ctx context.Context) (rs *Requirements, needCommit bool) {
 	if requirements != nil {
-		return requirements
+		return requirements, false
 	}
 
 	Init()
@@ -388,8 +402,8 @@ func LoadModFile(ctx context.Context) *Requirements {
 		Target = module.Version{Path: "command-line-arguments"}
 		targetPrefix = "command-line-arguments"
 		rawGoVersion.Store(Target, latestGoVersion())
-		commitRequirements(ctx, newRequirements(index.depth(), nil, nil))
-		return requirements
+		requirements = newRequirements(index.depth(), nil, nil)
+		return requirements, false
 	}
 
 	gomod := ModFilePath()
@@ -418,7 +432,7 @@ func LoadModFile(ctx context.Context) *Requirements {
 	}
 
 	setDefaultBuildMod() // possibly enable automatic vendoring
-	rs := requirementsFromModFile(ctx, f)
+	rs = requirementsFromModFile(ctx, f)
 
 	if cfg.BuildMod == "vendor" {
 		readVendorList()
@@ -450,9 +464,8 @@ func LoadModFile(ctx context.Context) *Requirements {
 		}
 	}
 
-	// Fix up roots if inconsistent.
-	commitRequirements(ctx, rs)
-	return requirements
+	requirements = rs
+	return requirements, true
 }
 
 // CreateModFile initializes a new module by creating a go.mod file.
@@ -1136,8 +1149,3 @@ const (
 func modkey(m module.Version) module.Version {
 	return module.Version{Path: m.Path, Version: m.Version + "/go.mod"}
 }
-
-func TrimGoSum(ctx context.Context) {
-	rs := LoadModFile(ctx)
-	modfetch.TrimGoSum(keepSums(ctx, loaded, rs, loadedZipSumsOnly))
-}
diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index 5de26c15e7..1da8493c36 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -138,6 +138,11 @@ type PackageOpts struct {
 	// If nil, treated as equivalent to imports.Tags().
 	Tags map[string]bool
 
+	// Tidy, if true, requests that the build list and go.sum file be reduced to
+	// the minimial dependencies needed to reproducibly reload the requested
+	// packages.
+	Tidy bool
+
 	// VendorModulesInGOROOTSrc indicates that if we are within a module in
 	// GOROOT/src, packages in the module's vendor directory should be resolved as
 	// actual module dependencies (instead of standard-library packages).
@@ -202,8 +207,6 @@ type PackageOpts struct {
 // LoadPackages identifies the set of packages matching the given patterns and
 // loads the packages in the import graph rooted at that set.
 func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (matches []*search.Match, loadedPackages []string) {
-	rs := LoadModFile(ctx)
-
 	if opts.Tags == nil {
 		opts.Tags = imports.Tags()
 	}
@@ -218,7 +221,7 @@ func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (ma
 		}
 	}
 
-	updateMatches := func(ld *loader) {
+	updateMatches := func(rs *Requirements, ld *loader) {
 		for _, m := range matches {
 			switch {
 			case m.IsLocal():
@@ -293,15 +296,17 @@ func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (ma
 		}
 	}
 
+	initialRS, _ := loadModFile(ctx) // Ignore needCommit — we're going to commit at the end regardless.
+
 	ld := loadFromRoots(ctx, loaderParams{
 		PackageOpts:  opts,
-		requirements: rs,
+		requirements: initialRS,
 
 		allClosesOverTests: index.allPatternClosesOverTests() && !opts.UseVendorAll,
 		allPatternIsRoot:   allPatternIsRoot,
 
-		listRoots: func() (roots []string) {
-			updateMatches(nil)
+		listRoots: func(rs *Requirements) (roots []string) {
+			updateMatches(rs, nil)
 			for _, m := range matches {
 				roots = append(roots, m.Pkgs...)
 			}
@@ -310,7 +315,7 @@ func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (ma
 	})
 
 	// One last pass to finalize wildcards.
-	updateMatches(ld)
+	updateMatches(ld.requirements, ld)
 
 	// Report errors, if any.
 	checkMultiplePaths(ld.requirements)
@@ -365,6 +370,11 @@ func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (ma
 		search.WarnUnmatched(matches)
 	}
 
+	if ld.Tidy {
+		ld.requirements = tidyBuildList(ctx, ld, initialRS)
+		modfetch.TrimGoSum(keepSums(ctx, ld, ld.requirements, loadedZipSumsOnly))
+	}
+
 	// Success! Update go.mod (if needed) and return the results.
 	loaded = ld
 	commitRequirements(ctx, loaded.requirements)
@@ -588,7 +598,7 @@ func ImportFromFiles(ctx context.Context, gofiles []string) {
 		},
 		requirements:       rs,
 		allClosesOverTests: index.allPatternClosesOverTests(),
-		listRoots: func() (roots []string) {
+		listRoots: func(*Requirements) (roots []string) {
 			roots = append(roots, imports...)
 			roots = append(roots, testImports...)
 			return roots
@@ -747,7 +757,7 @@ type loaderParams struct {
 	allClosesOverTests bool // Does the "all" pattern include the transitive closure of tests of packages in "all"?
 	allPatternIsRoot   bool // Is the "all" pattern an additional root?
 
-	listRoots func() []string
+	listRoots func(rs *Requirements) []string
 }
 
 func (ld *loader) reset() {
@@ -876,7 +886,7 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 		// Note: the returned roots can change on each iteration,
 		// since the expansion of package patterns depends on the
 		// build list we're using.
-		rootPkgs := ld.listRoots()
+		rootPkgs := ld.listRoots(ld.requirements)
 
 		if go117LazyTODO {
 			// Before we start loading transitive imports of packages, locate all of
-- 
GitLab


From 69c94ad55f9bf3072a5ad466b779e1427a3a07e0 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Thu, 15 Apr 2021 16:54:41 -0400
Subject: [PATCH 1679/2400] cmd/go/internal/modload: split updateRoots into
 separate functions for updating and tidying

In CL 293689, I fused the mvs.Reqs calls that were formerly in MinReqs
and TidyBuildList into a single function, updateRoots, in the hope
that it expressed a fundamental operation. As I have been working on
the lazy equivalents, I have come to realize that these functions are
deeply related but fundamentally different.

In order to help me reason about the two different roles, I am making
the two functions separate once more, but leaving them colocated in
the code.

For #36460

Change-Id: I851d6d81fbfd84f39411e0d076ee72a9909c60ee
Reviewed-on: https://go-review.googlesource.com/c/go/+/310629
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modload/buildlist.go | 170 ++++++++++++-----------
 src/cmd/go/internal/modload/init.go      |   2 +-
 src/cmd/go/internal/modload/load.go      |  14 +-
 3 files changed, 106 insertions(+), 80 deletions(-)

diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index 2eb47d2c9f..07d9fdfc54 100644
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -409,7 +409,7 @@ func expandGraph(ctx context.Context, rs *Requirements) (*Requirements, *ModuleG
 		// roots — but in a lazy module it may pull in previously-irrelevant
 		// transitive dependencies.
 
-		newRS, rsErr := updateRoots(ctx, rs.depth, rs.direct, nil, rs)
+		newRS, rsErr := updateRoots(ctx, rs.direct, rs)
 		if rsErr != nil {
 			// Failed to update roots, perhaps because of an error in a transitive
 			// dependency needed for the update. Return the original Requirements
@@ -552,7 +552,15 @@ func tidyBuildList(ctx context.Context, ld *loader, initialRS *Requirements) *Re
 		// changed after loading packages.
 	}
 
-	tidy, err := updateRoots(ctx, depth, ld.requirements.direct, ld.pkgs, nil)
+	var (
+		tidy *Requirements
+		err  error
+	)
+	if depth == lazy {
+		panic("internal error: 'go mod tidy' for lazy modules is not yet implemented")
+	} else {
+		tidy, err = tidyEagerRoots(ctx, ld.requirements, ld.pkgs)
+	}
 	if err != nil {
 		base.Fatalf("go: %v", err)
 	}
@@ -573,75 +581,57 @@ func tidyBuildList(ctx context.Context, ld *loader, initialRS *Requirements) *Re
 	return tidy
 }
 
-// updateRoots returns a set of root requirements that includes the selected
-// version of every module path in direct as a root, and maintains the selected
-// versions of every module selected in the graph of rs (if rs is non-nil), or
-// every module that provides any package in pkgs (otherwise).
-//
-// If pkgs is non-empty and rs is non-nil, the packages are assumed to be loaded
-// from the modules selected in the graph of rs.
-//
-// The roots are updated such that:
-//
-// 	1. The selected version of every module path in direct is included as a root
-// 	   (if it is not "none").
-// 	2. Each root is the selected version of its path. (We say that such a root
-// 	   set is “consistent”.)
-// 	3. The selected version of the module providing each package in pkgs remains
-// 	   selected.
-// 	4. If rs is non-nil, every version selected in the graph of rs remains selected.
-func updateRoots(ctx context.Context, depth modDepth, direct map[string]bool, pkgs []*loadPkg, rs *Requirements) (*Requirements, error) {
+// tidyEagerRoots returns a minimal set of root requirements that maintains the
+// selected version of every module that provided a package in pkgs, and
+// includes the selected version of every such module in rs.direct as a root.
+func tidyEagerRoots(ctx context.Context, rs *Requirements, pkgs []*loadPkg) (*Requirements, error) {
+	var (
+		keep     []module.Version
+		keptPath = map[string]bool{}
+	)
 	var (
 		rootPaths   []string // module paths that should be included as roots
 		inRootPaths = map[string]bool{}
 	)
-
-	var keep []module.Version
-	if rs != nil {
-		mg, err := rs.Graph(ctx)
-		if err != nil {
-			// We can't ignore errors in the module graph even if the user passed the -e
-			// flag to try to push past them. If we can't load the complete module
-			// dependencies, then we can't reliably compute a minimal subset of them.
-			return rs, err
-		}
-		keep = mg.BuildList()[1:]
-
-		for _, root := range rs.rootModules {
-			// If the selected version of the root is the same as what was already
-			// listed in the go.mod file, retain it as a root (even if redundant) to
-			// avoid unnecessary churn. (See https://golang.org/issue/34822.)
-			//
-			// We do this even for indirect requirements, since we don't know why they
-			// were added and they could become direct at any time.
-			if !inRootPaths[root.Path] && mg.Selected(root.Path) == root.Version {
-				rootPaths = append(rootPaths, root.Path)
-				inRootPaths[root.Path] = true
-			}
+	for _, pkg := range pkgs {
+		if !pkg.fromExternalModule() {
+			continue
 		}
-	} else {
-		kept := map[module.Version]bool{Target: true}
-		for _, pkg := range pkgs {
-			if pkg.mod.Path != "" && !kept[pkg.mod] {
-				keep = append(keep, pkg.mod)
-				kept[pkg.mod] = true
+		if m := pkg.mod; !keptPath[m.Path] {
+			keep = append(keep, m)
+			keptPath[m.Path] = true
+			if rs.direct[m.Path] && !inRootPaths[m.Path] {
+				rootPaths = append(rootPaths, m.Path)
+				inRootPaths[m.Path] = true
 			}
 		}
 	}
 
-	// “The selected version of every module path in direct is included as a root.”
-	//
-	// This is only for convenience and clarity for end users: the choice of
-	// explicit vs. implicit dependency has no impact on MVS selection (for itself
-	// or any other module).
-	if go117LazyTODO {
-		// Update the above comment to reflect lazy loading once implemented.
+	min, err := mvs.Req(Target, rootPaths, &mvsReqs{roots: keep})
+	if err != nil {
+		return nil, err
 	}
-	for _, m := range keep {
-		if direct[m.Path] && !inRootPaths[m.Path] {
-			rootPaths = append(rootPaths, m.Path)
-			inRootPaths[m.Path] = true
-		}
+	return newRequirements(eager, min, rs.direct), nil
+}
+
+// updateRoots returns a set of root requirements that includes the selected
+// version of every module path in direct as a root, and maintains the selected
+// version of every module selected in the graph of rs.
+//
+// The roots are updated such that:
+//
+// 	1. The selected version of every module path in direct is included as a root
+// 	   (if it is not "none").
+// 	2. Each root is the selected version of its path. (We say that such a root
+// 	   set is “consistent”.)
+// 	3. Every version selected in the graph of rs remains selected.
+func updateRoots(ctx context.Context, direct map[string]bool, rs *Requirements) (*Requirements, error) {
+	mg, err := rs.Graph(ctx)
+	if err != nil {
+		// We can't ignore errors in the module graph even if the user passed the -e
+		// flag to try to push past them. If we can't load the complete module
+		// dependencies, then we can't reliably compute a minimal subset of them.
+		return rs, err
 	}
 
 	if cfg.BuildMod != "mod" {
@@ -652,7 +642,13 @@ func updateRoots(ctx context.Context, depth modDepth, direct map[string]bool, pk
 			// but we aren't even allowed to modify them.
 			return rs, errGoModDirty
 		}
-		for _, mPath := range rootPaths {
+		for _, m := range rs.rootModules {
+			if m.Version != mg.Selected(m.Path) {
+				// The root version v is misleading: the actual selected version is higher.
+				return rs, errGoModDirty
+			}
+		}
+		for mPath := range direct {
 			if _, ok := rs.rootSelected(mPath); !ok {
 				// Module m is supposed to be listed explicitly, but isn't.
 				//
@@ -662,21 +658,6 @@ func updateRoots(ctx context.Context, depth modDepth, direct map[string]bool, pk
 				return rs, errGoModDirty
 			}
 		}
-		for _, m := range keep {
-			if v, ok := rs.rootSelected(m.Path); ok && v != m.Version {
-				// The root version v is misleading: the actual selected version is
-				// m.Version.
-				return rs, errGoModDirty
-			}
-		}
-		for _, m := range rs.rootModules {
-			if v, ok := rs.rootSelected(m.Path); ok && v != m.Version {
-				// The roots list both m.Version and some higher version of m.Path.
-				// The root for m.Version is misleading: the actual selected version is
-				// *at least* v.
-				return rs, errGoModDirty
-			}
-		}
 
 		// No explicit roots are missing and all roots are already at the versions
 		// we want to keep. Any other changes we would make are purely cosmetic,
@@ -685,6 +666,39 @@ func updateRoots(ctx context.Context, depth modDepth, direct map[string]bool, pk
 		return rs, nil
 	}
 
+	var (
+		rootPaths   []string // module paths that should be included as roots
+		inRootPaths = map[string]bool{}
+	)
+	for _, root := range rs.rootModules {
+		// If the selected version of the root is the same as what was already
+		// listed in the go.mod file, retain it as a root (even if redundant) to
+		// avoid unnecessary churn. (See https://golang.org/issue/34822.)
+		//
+		// We do this even for indirect requirements, since we don't know why they
+		// were added and they could become direct at any time.
+		if !inRootPaths[root.Path] && mg.Selected(root.Path) == root.Version {
+			rootPaths = append(rootPaths, root.Path)
+			inRootPaths[root.Path] = true
+		}
+	}
+
+	// “The selected version of every module path in direct is included as a root.”
+	//
+	// This is only for convenience and clarity for end users: the choice of
+	// explicit vs. implicit dependency has no impact on MVS selection (for itself
+	// or any other module).
+	if go117LazyTODO {
+		// Update the above comment to reflect lazy loading once implemented.
+	}
+	keep := mg.BuildList()[1:]
+	for _, m := range keep {
+		if direct[m.Path] && !inRootPaths[m.Path] {
+			rootPaths = append(rootPaths, m.Path)
+			inRootPaths[m.Path] = true
+		}
+	}
+
 	min, err := mvs.Req(Target, rootPaths, &mvsReqs{roots: keep})
 	if err != nil {
 		return rs, err
@@ -695,7 +709,7 @@ func updateRoots(ctx context.Context, depth modDepth, direct map[string]bool, pk
 	// the root set is the same as the original root set in rs and recycle its
 	// module graph and build list, if they have already been loaded.
 
-	return newRequirements(depth, min, direct), nil
+	return newRequirements(rs.depth, min, direct), nil
 }
 
 // checkMultiplePaths verifies that a given module path is used as itself
diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index 953419a718..238e471c54 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -691,7 +691,7 @@ func requirementsFromModFile(ctx context.Context, f *modfile.File) *Requirements
 	for _, n := range mPathCount {
 		if n > 1 {
 			var err error
-			rs, err = updateRoots(ctx, rs.depth, rs.direct, nil, rs)
+			rs, err = updateRoots(ctx, rs.direct, rs)
 			if err != nil {
 				base.Fatalf("go: %v", err)
 			}
diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index 1da8493c36..98707eadd7 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -864,6 +864,18 @@ func (pkg *loadPkg) isTest() bool {
 	return pkg.testOf != nil
 }
 
+// fromExternalModule reports whether pkg was loaded from a module other than
+// the main module.
+func (pkg *loadPkg) fromExternalModule() bool {
+	if pkg.mod.Path == "" {
+		return false // loaded from the standard library, not a module
+	}
+	if pkg.mod.Path == Target.Path {
+		return false // loaded from the main module.
+	}
+	return true
+}
+
 var errMissing = errors.New("cannot find package")
 
 // loadFromRoots attempts to load the build graph needed to process a set of
@@ -1030,7 +1042,7 @@ func (ld *loader) updateRequirements(ctx context.Context) error {
 		}
 	}
 
-	rs, err := updateRoots(ctx, rs.depth, direct, ld.pkgs, rs)
+	rs, err := updateRoots(ctx, direct, rs)
 	if err == nil {
 		ld.requirements = rs
 	}
-- 
GitLab


From f53c2fac46e2e193493045eef08591ded1496b74 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 16 Apr 2021 00:47:35 -0400
Subject: [PATCH 1680/2400] cmd/go/internal/modload: in newRequirements, verify
 that rootModules is sorted
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The comment for the Requirements.rootModules field requires that it be
"sorted and capped to length". I noticed that we were not capping it
correctly — we were capping the local variable (the rorotModules
argument itself) but not the struct field. That prompted me to
question whether we were also at some point failing to sort it
correctly, so I decided to add an explicit check.

With the explicit check, all tests continue to pass.

For #36460

Change-Id: I6687de8ef8ecc5129fa8810d678e5673752fd27b
Reviewed-on: https://go-review.googlesource.com/c/go/+/310790
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modload/buildlist.go | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index 07d9fdfc54..8be5cc2a1b 100644
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -19,6 +19,7 @@ import (
 	"sync/atomic"
 
 	"golang.org/x/mod/module"
+	"golang.org/x/mod/semver"
 )
 
 // capVersionSlice returns s with its cap reduced to its length.
@@ -89,6 +90,7 @@ var requirements *Requirements
 // The dependencies of the roots will be loaded lazily at the first call to the
 // Graph method.
 //
+// The rootModules slice must be sorted according to module.Sort.
 // The caller must not modify the rootModules slice or direct map after passing
 // them to newRequirements.
 //
@@ -102,15 +104,20 @@ func newRequirements(depth modDepth, rootModules []module.Version, direct map[st
 		if m.Path == "" || m.Version == "" {
 			panic(fmt.Sprintf("bad requirement: rootModules[%v] = %v", i, m))
 		}
+		if i > 0 {
+			prev := rootModules[i-1]
+			if prev.Path > m.Path || (prev.Path == m.Path && semver.Compare(prev.Version, m.Version) > 0) {
+				panic(fmt.Sprintf("newRequirements called with unsorted roots: %v", rootModules))
+			}
+		}
 	}
 
 	rs := &Requirements{
 		depth:          depth,
-		rootModules:    rootModules,
+		rootModules:    capVersionSlice(rootModules),
 		maxRootVersion: make(map[string]string, len(rootModules)),
 		direct:         direct,
 	}
-	rootModules = capVersionSlice(rootModules)
 
 	for _, m := range rootModules {
 		if v, ok := rs.maxRootVersion[m.Path]; ok && cmpVersion(v, m.Version) >= 0 {
-- 
GitLab


From acf1b46de52a50f479600682fd80763ccb2e6f74 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Wed, 21 Apr 2021 01:59:51 +0700
Subject: [PATCH 1681/2400] cmd/compile: update ir.Node ops comments

After Russquake, all the Node ops now have different structure, update
comment to reflect that.

Change-Id: I43f859783cda457528ae4d2da9857f2cc0438b62
Reviewed-on: https://go-review.googlesource.com/c/go/+/311949
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/node.go | 251 ++++++++++++++--------------
 1 file changed, 125 insertions(+), 126 deletions(-)

diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index b4db79e5c2..b248d59e96 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -123,167 +123,166 @@ const (
 	ONIL     // nil
 
 	// expressions
-	OADD          // Left + Right
-	OSUB          // Left - Right
-	OOR           // Left | Right
-	OXOR          // Left ^ Right
+	OADD          // X + Y
+	OSUB          // X - Y
+	OOR           // X | Y
+	OXOR          // X ^ Y
 	OADDSTR       // +{List} (string addition, list elements are strings)
-	OADDR         // &Left
-	OANDAND       // Left && Right
-	OAPPEND       // append(List); after walk, Left may contain elem type descriptor
-	OBYTES2STR    // Type(Left) (Type is string, Left is a []byte)
-	OBYTES2STRTMP // Type(Left) (Type is string, Left is a []byte, ephemeral)
-	ORUNES2STR    // Type(Left) (Type is string, Left is a []rune)
-	OSTR2BYTES    // Type(Left) (Type is []byte, Left is a string)
-	OSTR2BYTESTMP // Type(Left) (Type is []byte, Left is a string, ephemeral)
-	OSTR2RUNES    // Type(Left) (Type is []rune, Left is a string)
-	OSLICE2ARRPTR // Type(Left) (Type is *[N]T, Left is a []T)
-	// Left = Right or (if Colas=true) Left := Right
-	// If Colas, then Ninit includes a DCL node for Left.
+	OADDR         // &X
+	OANDAND       // X && Y
+	OAPPEND       // append(Args); after walk, X may contain elem type descriptor
+	OBYTES2STR    // Type(X) (Type is string, X is a []byte)
+	OBYTES2STRTMP // Type(X) (Type is string, X is a []byte, ephemeral)
+	ORUNES2STR    // Type(X) (Type is string, X is a []rune)
+	OSTR2BYTES    // Type(X) (Type is []byte, X is a string)
+	OSTR2BYTESTMP // Type(X) (Type is []byte, X is a string, ephemeral)
+	OSTR2RUNES    // Type(X) (Type is []rune, X is a string)
+	OSLICE2ARRPTR // Type(X) (Type is *[N]T, X is a []T)
+	// X = Y or (if Def=true) X := Y
+	// If Def, then Init includes a DCL node for X.
 	OAS
-	// List = Rlist (x, y, z = a, b, c) or (if Colas=true) List := Rlist
-	// If Colas, then Ninit includes DCL nodes for List
+	// Lhs = Rhs (x, y, z = a, b, c) or (if Def=true) Lhs := Rhs
+	// If Def, then Init includes DCL nodes for Lhs
 	OAS2
-	OAS2DOTTYPE // List = Right (x, ok = I.(int))
-	OAS2FUNC    // List = Right (x, y = f())
-	OAS2MAPR    // List = Right (x, ok = m["foo"])
-	OAS2RECV    // List = Right (x, ok = <-c)
-	OASOP       // Left Etype= Right (x += y)
-	OCALL       // Left(List) (function call, method call or type conversion)
+	OAS2DOTTYPE // Lhs = Rhs (x, ok = I.(int))
+	OAS2FUNC    // Lhs = Rhs (x, y = f())
+	OAS2MAPR    // Lhs = Rhs (x, ok = m["foo"])
+	OAS2RECV    // Lhs = Rhs (x, ok = <-c)
+	OASOP       // X AsOp= Y (x += y)
+	OCALL       // X(Args) (function call, method call or type conversion)
 
 	// OCALLFUNC, OCALLMETH, and OCALLINTER have the same structure.
-	// Prior to walk, they are: Left(List), where List is all regular arguments.
-	// After walk, List is a series of assignments to temporaries,
-	// and Rlist is an updated set of arguments.
-	// Nbody is all OVARLIVE nodes that are attached to OCALLxxx.
-	// TODO(josharian/khr): Use Ninit instead of List for the assignments to temporaries. See CL 114797.
-	OCALLFUNC  // Left(List/Rlist) (function call f(args))
-	OCALLMETH  // Left(List/Rlist) (direct method call x.Method(args))
-	OCALLINTER // Left(List/Rlist) (interface method call x.Method(args))
-	OCALLPART  // Left.Right (method expression x.Method, not called)
-	OCAP       // cap(Left)
-	OCLOSE     // close(Left)
-	OCLOSURE   // func Type { Func.Closure.Nbody } (func literal)
-	OCOMPLIT   // Right{List} (composite literal, not yet lowered to specific form)
+	// Prior to walk, they are: X(Args), where Args is all regular arguments.
+	// After walk, if any argument whose evaluation might requires temporary variable,
+	// that temporary variable will be pushed to Init, Args will contains an updated
+	// set of arguments. KeepAlive is all OVARLIVE nodes that are attached to OCALLxxx.
+	OCALLFUNC  // X(Args) (function call f(args))
+	OCALLMETH  // X(Args) (direct method call x.Method(args))
+	OCALLINTER // X(Args) (interface method call x.Method(args))
+	OCALLPART  // X.Sel (method expression x.Method, not called)
+	OCAP       // cap(X)
+	OCLOSE     // close(X)
+	OCLOSURE   // func Type { Func.Closure.Body } (func literal)
+	OCOMPLIT   // Type{List} (composite literal, not yet lowered to specific form)
 	OMAPLIT    // Type{List} (composite literal, Type is map)
 	OSTRUCTLIT // Type{List} (composite literal, Type is struct)
 	OARRAYLIT  // Type{List} (composite literal, Type is array)
-	OSLICELIT  // Type{List} (composite literal, Type is slice) Right.Int64() = slice length.
-	OPTRLIT    // &Left (left is composite literal)
-	OCONV      // Type(Left) (type conversion)
-	OCONVIFACE // Type(Left) (type conversion, to interface)
-	OCONVNOP   // Type(Left) (type conversion, no effect)
-	OCOPY      // copy(Left, Right)
-	ODCL       // var Left (declares Left of type Left.Type)
+	OSLICELIT  // Type{List} (composite literal, Type is slice), Len is slice length.
+	OPTRLIT    // &X (X is composite literal)
+	OCONV      // Type(X) (type conversion)
+	OCONVIFACE // Type(X) (type conversion, to interface)
+	OCONVNOP   // Type(X) (type conversion, no effect)
+	OCOPY      // copy(X, Y)
+	ODCL       // var X (declares X of type X.Type)
 
 	// Used during parsing but don't last.
 	ODCLFUNC  // func f() or func (r) f()
 	ODCLCONST // const pi = 3.14
 	ODCLTYPE  // type Int int or type Int = int
 
-	ODELETE        // delete(List)
-	ODOT           // Left.Sym (Left is of struct type)
-	ODOTPTR        // Left.Sym (Left is of pointer to struct type)
-	ODOTMETH       // Left.Sym (Left is non-interface, Right is method name)
-	ODOTINTER      // Left.Sym (Left is interface, Right is method name)
-	OXDOT          // Left.Sym (before rewrite to one of the preceding)
-	ODOTTYPE       // Left.Right or Left.Type (.Right during parsing, .Type once resolved); after walk, .Right contains address of interface type descriptor and .Right.Right contains address of concrete type descriptor
-	ODOTTYPE2      // Left.Right or Left.Type (.Right during parsing, .Type once resolved; on rhs of OAS2DOTTYPE); after walk, .Right contains address of interface type descriptor
-	OEQ            // Left == Right
-	ONE            // Left != Right
-	OLT            // Left < Right
-	OLE            // Left <= Right
-	OGE            // Left >= Right
-	OGT            // Left > Right
-	ODEREF         // *Left
-	OINDEX         // Left[Right] (index of array or slice)
-	OINDEXMAP      // Left[Right] (index of map)
-	OKEY           // Left:Right (key:value in struct/array/map literal)
-	OSTRUCTKEY     // Sym:Left (key:value in struct literal, after type checking)
-	OLEN           // len(Left)
-	OMAKE          // make(List) (before type checking converts to one of the following)
-	OMAKECHAN      // make(Type, Left) (type is chan)
-	OMAKEMAP       // make(Type, Left) (type is map)
-	OMAKESLICE     // make(Type, Left, Right) (type is slice)
-	OMAKESLICECOPY // makeslicecopy(Type, Left, Right) (type is slice; Left is length and Right is the copied from slice)
+	ODELETE        // delete(Args)
+	ODOT           // X.Sel (X is of struct type)
+	ODOTPTR        // X.Sel (X is of pointer to struct type)
+	ODOTMETH       // X.Sel (X is non-interface, Sel is method name)
+	ODOTINTER      // X.Sel (X is interface, Sel is method name)
+	OXDOT          // X.Sel (before rewrite to one of the preceding)
+	ODOTTYPE       // X.Ntype or X.Type (.Ntype during parsing, .Type once resolved); after walk, Itab contains address of interface type descriptor and Itab.X contains address of concrete type descriptor
+	ODOTTYPE2      // X.Ntype or X.Type (.Ntype during parsing, .Type once resolved; on rhs of OAS2DOTTYPE); after walk, Itab contains address of interface type descriptor
+	OEQ            // X == Y
+	ONE            // X != Y
+	OLT            // X < Y
+	OLE            // X <= Y
+	OGE            // X >= Y
+	OGT            // X > Y
+	ODEREF         // *X
+	OINDEX         // X[Index] (index of array or slice)
+	OINDEXMAP      // X[Index] (index of map)
+	OKEY           // Key:Value (key:value in struct/array/map literal)
+	OSTRUCTKEY     // Field:Value (key:value in struct literal, after type checking)
+	OLEN           // len(X)
+	OMAKE          // make(Args) (before type checking converts to one of the following)
+	OMAKECHAN      // make(Type[, Len]) (type is chan)
+	OMAKEMAP       // make(Type[, Len]) (type is map)
+	OMAKESLICE     // make(Type[, Len[, Cap]]) (type is slice)
+	OMAKESLICECOPY // makeslicecopy(Type, Len, Cap) (type is slice; Len is length and Cap is the copied from slice)
 	// OMAKESLICECOPY is created by the order pass and corresponds to:
-	//  s = make(Type, Left); copy(s, Right)
+	//  s = make(Type, Len); copy(s, Cap)
 	//
-	// Bounded can be set on the node when Left == len(Right) is known at compile time.
+	// Bounded can be set on the node when Len == len(Cap) is known at compile time.
 	//
 	// This node is created so the walk pass can optimize this pattern which would
 	// otherwise be hard to detect after the order pass.
-	OMUL         // Left * Right
-	ODIV         // Left / Right
-	OMOD         // Left % Right
-	OLSH         // Left << Right
-	ORSH         // Left >> Right
-	OAND         // Left & Right
-	OANDNOT      // Left &^ Right
-	ONEW         // new(Left); corresponds to calls to new in source code
-	ONOT         // !Left
-	OBITNOT      // ^Left
-	OPLUS        // +Left
-	ONEG         // -Left
-	OOROR        // Left || Right
-	OPANIC       // panic(Left)
+	OMUL         // X * Y
+	ODIV         // X / Y
+	OMOD         // X % Y
+	OLSH         // X << Y
+	ORSH         // X >> Y
+	OAND         // X & Y
+	OANDNOT      // X &^ Y
+	ONEW         // new(X); corresponds to calls to new in source code
+	ONOT         // !X
+	OBITNOT      // ^X
+	OPLUS        // +X
+	ONEG         // -X
+	OOROR        // X || Y
+	OPANIC       // panic(X)
 	OPRINT       // print(List)
 	OPRINTN      // println(List)
-	OPAREN       // (Left)
-	OSEND        // Left <- Right
-	OSLICE       // Left[List[0] : List[1]] (Left is untypechecked or slice)
-	OSLICEARR    // Left[List[0] : List[1]] (Left is pointer to array)
-	OSLICESTR    // Left[List[0] : List[1]] (Left is string)
-	OSLICE3      // Left[List[0] : List[1] : List[2]] (Left is untypedchecked or slice)
-	OSLICE3ARR   // Left[List[0] : List[1] : List[2]] (Left is pointer to array)
-	OSLICEHEADER // sliceheader{Left, List[0], List[1]} (Left is unsafe.Pointer, List[0] is length, List[1] is capacity)
+	OPAREN       // (X)
+	OSEND        // Chan <- Value
+	OSLICE       // X[Low : High] (X is untypechecked or slice)
+	OSLICEARR    // X[Low : High] (X is pointer to array)
+	OSLICESTR    // X[Low : High] (X is string)
+	OSLICE3      // X[Low : High : Max] (X is untypedchecked or slice)
+	OSLICE3ARR   // X[Low : High : Max] (X is pointer to array)
+	OSLICEHEADER // sliceheader{Ptr, Len, Cap} (Ptr is unsafe.Pointer, Len is length, Cap is capacity)
 	ORECOVER     // recover()
-	ORECV        // <-Left
-	ORUNESTR     // Type(Left) (Type is string, Left is rune)
-	OSELRECV2    // like OAS2: List = Rlist where len(List)=2, len(Rlist)=1, Rlist[0].Op = ORECV (appears as .Left of OCASE)
+	ORECV        // <-X
+	ORUNESTR     // Type(X) (Type is string, X is rune)
+	OSELRECV2    // like OAS2: Lhs = Rhs where len(Lhs)=2, len(Rhs)=1, Rhs[0].Op = ORECV (appears as .Var of OCASE)
 	OIOTA        // iota
-	OREAL        // real(Left)
-	OIMAG        // imag(Left)
-	OCOMPLEX     // complex(Left, Right) or complex(List[0]) where List[0] is a 2-result function call
-	OALIGNOF     // unsafe.Alignof(Left)
-	OOFFSETOF    // unsafe.Offsetof(Left)
-	OSIZEOF      // unsafe.Sizeof(Left)
+	OREAL        // real(X)
+	OIMAG        // imag(X)
+	OCOMPLEX     // complex(X, Y)
+	OALIGNOF     // unsafe.Alignof(X)
+	OOFFSETOF    // unsafe.Offsetof(X)
+	OSIZEOF      // unsafe.Sizeof(X)
 	OMETHEXPR    // method expression
-	OSTMTEXPR    // statement expression (Init; Left)
+	OSTMTEXPR    // statement expression (Init; X)
 
 	// statements
 	OBLOCK // { List } (block of code)
-	OBREAK // break [Sym]
-	// OCASE:  case List: Nbody (List==nil means default)
+	OBREAK // break [Label]
+	// OCASE:  case List: Body (List==nil means default)
 	//   For OTYPESW, List is a OTYPE node for the specified type (or OLITERAL
 	//   for nil), and, if a type-switch variable is specified, Rlist is an
 	//   ONAME for the version of the type-switch variable with the specified
 	//   type.
 	OCASE
-	OCONTINUE // continue [Sym]
-	ODEFER    // defer Left (Left must be call)
+	OCONTINUE // continue [Label]
+	ODEFER    // defer Call
 	OFALL     // fallthrough
-	OFOR      // for Ninit; Left; Right { Nbody }
-	// OFORUNTIL is like OFOR, but the test (Left) is applied after the body:
-	// 	Ninit
-	// 	top: { Nbody }   // Execute the body at least once
-	// 	cont: Right
-	// 	if Left {        // And then test the loop condition
+	OFOR      // for Init; Cond; Post { Body }
+	// OFORUNTIL is like OFOR, but the test (Cond) is applied after the body:
+	// 	Init
+	// 	top: { Body }   // Execute the body at least once
+	// 	cont: Post
+	// 	if Cond {        // And then test the loop condition
 	// 		List     // Before looping to top, execute List
 	// 		goto top
 	// 	}
 	// OFORUNTIL is created by walk. There's no way to write this in Go code.
 	OFORUNTIL
-	OGOTO   // goto Sym
-	OIF     // if Ninit; Left { Nbody } else { Rlist }
-	OLABEL  // Sym:
-	OGO     // go Left (Left must be call)
-	ORANGE  // for List = range Right { Nbody }
-	ORETURN // return List
-	OSELECT // select { List } (List is list of OCASE)
-	OSWITCH // switch Ninit; Left { List } (List is a list of OCASE)
-	// OTYPESW:  Left := Right.(type) (appears as .Left of OSWITCH)
-	//   Left is nil if there is no type-switch variable
+	OGOTO   // goto Label
+	OIF     // if Init; Cond { Then } else { Else }
+	OLABEL  // Label:
+	OGO     // go Call
+	ORANGE  // for Key, Value = range X { Body }
+	ORETURN // return Results
+	OSELECT // select { Cases }
+	OSWITCH // switch Init; Expr { Cases }
+	// OTYPESW:  X := Y.(type) (appears as .Tag of OSWITCH)
+	//   X is nil if there is no type-switch variable
 	OTYPESW
 	OFUNCINST // instantiation of a generic function
 
@@ -292,7 +291,7 @@ const (
 	OTMAP    // map[string]int
 	OTSTRUCT // struct{}
 	OTINTER  // interface{}
-	// OTFUNC: func() - Left is receiver field, List is list of param fields, Rlist is
+	// OTFUNC: func() - Recv is receiver field, Params is list of param fields, Results is
 	// list of result fields.
 	OTFUNC
 	OTARRAY // [8]int or [...]int
@@ -306,7 +305,7 @@ const (
 	OINLCALL       // intermediary representation of an inlined call.
 	OEFACE         // itable and data words of an empty-interface value.
 	OITAB          // itable word of an interface value.
-	OIDATA         // data word of an interface value in Left
+	OIDATA         // data word of an interface value in X
 	OSPTR          // base pointer of a slice or string.
 	OCFUNC         // reference to c function pointer (not go func value)
 	OCHECKNIL      // emit code to ensure pointer/interface not nil
@@ -539,7 +538,7 @@ func SetPos(n Node) src.XPos {
 }
 
 // The result of InitExpr MUST be assigned back to n, e.g.
-// 	n.Left = InitExpr(init, n.Left)
+// 	n.X = InitExpr(init, n.X)
 func InitExpr(init []Node, expr Node) Node {
 	if len(init) == 0 {
 		return expr
-- 
GitLab


From 7735ec96c17f0aa8b27c64d82115755e29214164 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Wed, 21 Apr 2021 02:01:51 +0700
Subject: [PATCH 1682/2400] cmd/compile: remove ir.OSTMTEXPR op

It is not used anywhere.

Change-Id: I2b8d64902e16893ab5e1b84943f6d865c6e9c7bd
Reviewed-on: https://go-review.googlesource.com/c/go/+/311950
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/node.go      |  1 -
 src/cmd/compile/internal/ir/op_string.go | 87 ++++++++++++------------
 2 files changed, 43 insertions(+), 45 deletions(-)

diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index b248d59e96..cbc7681d12 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -248,7 +248,6 @@ const (
 	OOFFSETOF    // unsafe.Offsetof(X)
 	OSIZEOF      // unsafe.Sizeof(X)
 	OMETHEXPR    // method expression
-	OSTMTEXPR    // statement expression (Init; X)
 
 	// statements
 	OBLOCK // { List } (block of code)
diff --git a/src/cmd/compile/internal/ir/op_string.go b/src/cmd/compile/internal/ir/op_string.go
index 156ffd69ba..776a5c1e8d 100644
--- a/src/cmd/compile/internal/ir/op_string.go
+++ b/src/cmd/compile/internal/ir/op_string.go
@@ -120,53 +120,52 @@ func _() {
 	_ = x[OOFFSETOF-109]
 	_ = x[OSIZEOF-110]
 	_ = x[OMETHEXPR-111]
-	_ = x[OSTMTEXPR-112]
-	_ = x[OBLOCK-113]
-	_ = x[OBREAK-114]
-	_ = x[OCASE-115]
-	_ = x[OCONTINUE-116]
-	_ = x[ODEFER-117]
-	_ = x[OFALL-118]
-	_ = x[OFOR-119]
-	_ = x[OFORUNTIL-120]
-	_ = x[OGOTO-121]
-	_ = x[OIF-122]
-	_ = x[OLABEL-123]
-	_ = x[OGO-124]
-	_ = x[ORANGE-125]
-	_ = x[ORETURN-126]
-	_ = x[OSELECT-127]
-	_ = x[OSWITCH-128]
-	_ = x[OTYPESW-129]
-	_ = x[OFUNCINST-130]
-	_ = x[OTCHAN-131]
-	_ = x[OTMAP-132]
-	_ = x[OTSTRUCT-133]
-	_ = x[OTINTER-134]
-	_ = x[OTFUNC-135]
-	_ = x[OTARRAY-136]
-	_ = x[OTSLICE-137]
-	_ = x[OINLCALL-138]
-	_ = x[OEFACE-139]
-	_ = x[OITAB-140]
-	_ = x[OIDATA-141]
-	_ = x[OSPTR-142]
-	_ = x[OCFUNC-143]
-	_ = x[OCHECKNIL-144]
-	_ = x[OVARDEF-145]
-	_ = x[OVARKILL-146]
-	_ = x[OVARLIVE-147]
-	_ = x[ORESULT-148]
-	_ = x[OINLMARK-149]
-	_ = x[OLINKSYMOFFSET-150]
-	_ = x[OTAILCALL-151]
-	_ = x[OGETG-152]
-	_ = x[OEND-153]
+	_ = x[OBLOCK-112]
+	_ = x[OBREAK-113]
+	_ = x[OCASE-114]
+	_ = x[OCONTINUE-115]
+	_ = x[ODEFER-116]
+	_ = x[OFALL-117]
+	_ = x[OFOR-118]
+	_ = x[OFORUNTIL-119]
+	_ = x[OGOTO-120]
+	_ = x[OIF-121]
+	_ = x[OLABEL-122]
+	_ = x[OGO-123]
+	_ = x[ORANGE-124]
+	_ = x[ORETURN-125]
+	_ = x[OSELECT-126]
+	_ = x[OSWITCH-127]
+	_ = x[OTYPESW-128]
+	_ = x[OFUNCINST-129]
+	_ = x[OTCHAN-130]
+	_ = x[OTMAP-131]
+	_ = x[OTSTRUCT-132]
+	_ = x[OTINTER-133]
+	_ = x[OTFUNC-134]
+	_ = x[OTARRAY-135]
+	_ = x[OTSLICE-136]
+	_ = x[OINLCALL-137]
+	_ = x[OEFACE-138]
+	_ = x[OITAB-139]
+	_ = x[OIDATA-140]
+	_ = x[OSPTR-141]
+	_ = x[OCFUNC-142]
+	_ = x[OCHECKNIL-143]
+	_ = x[OVARDEF-144]
+	_ = x[OVARKILL-145]
+	_ = x[OVARLIVE-146]
+	_ = x[ORESULT-147]
+	_ = x[OINLMARK-148]
+	_ = x[OLINKSYMOFFSET-149]
+	_ = x[OTAILCALL-150]
+	_ = x[OGETG-151]
+	_ = x[OEND-152]
 }
 
-const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESSLICE2ARRPTRASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRSTMTEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWFUNCINSTTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKLINKSYMOFFSETTAILCALLGETGEND"
+const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESSLICE2ARRPTRASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWFUNCINSTTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKLINKSYMOFFSETTAILCALLGETGEND"
 
-var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 136, 138, 141, 151, 158, 165, 172, 176, 180, 188, 196, 205, 213, 216, 221, 228, 235, 241, 250, 258, 266, 272, 276, 285, 292, 296, 299, 306, 314, 321, 327, 330, 336, 343, 351, 355, 362, 370, 372, 374, 376, 378, 380, 382, 387, 392, 400, 403, 412, 415, 419, 427, 434, 443, 456, 459, 462, 465, 468, 471, 474, 480, 483, 486, 492, 496, 499, 503, 508, 513, 519, 524, 528, 533, 541, 549, 555, 564, 575, 582, 586, 593, 601, 605, 609, 613, 620, 627, 635, 641, 649, 657, 662, 667, 671, 679, 684, 688, 691, 699, 703, 705, 710, 712, 717, 723, 729, 735, 741, 749, 754, 758, 765, 771, 776, 782, 788, 795, 800, 804, 809, 813, 818, 826, 832, 839, 846, 852, 859, 872, 880, 884, 887}
+var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 136, 138, 141, 151, 158, 165, 172, 176, 180, 188, 196, 205, 213, 216, 221, 228, 235, 241, 250, 258, 266, 272, 276, 285, 292, 296, 299, 306, 314, 321, 327, 330, 336, 343, 351, 355, 362, 370, 372, 374, 376, 378, 380, 382, 387, 392, 400, 403, 412, 415, 419, 427, 434, 443, 456, 459, 462, 465, 468, 471, 474, 480, 483, 486, 492, 496, 499, 503, 508, 513, 519, 524, 528, 533, 541, 549, 555, 564, 575, 582, 586, 593, 601, 605, 609, 613, 620, 627, 635, 641, 649, 654, 659, 663, 671, 676, 680, 683, 691, 695, 697, 702, 704, 709, 715, 721, 727, 733, 741, 746, 750, 757, 763, 768, 774, 780, 787, 792, 796, 801, 805, 810, 818, 824, 831, 838, 844, 851, 864, 872, 876, 879}
 
 func (i Op) String() string {
 	if i >= Op(len(_Op_index)-1) {
-- 
GitLab


From 5f1df260a91183c605c08af7b00741d2761b84e4 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Wed, 21 Apr 2021 15:42:05 +0700
Subject: [PATCH 1683/2400] cmd/compile: allow export/import OSLICE2ARRPTR

Updates #395
Fixes #45665

Change-Id: Iaf053c0439a573e9193d40942fbdb22ac3b4d3bb
Reviewed-on: https://go-review.googlesource.com/c/go/+/312070
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/typecheck/iexport.go |  2 +-
 src/cmd/compile/internal/typecheck/iimport.go |  2 +-
 test/fixedbugs/issue45665.go                  | 15 +++++++++++++++
 3 files changed, 17 insertions(+), 2 deletions(-)
 create mode 100644 test/fixedbugs/issue45665.go

diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index 6a56abb1b9..5955b3d358 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -1677,7 +1677,7 @@ func (w *exportWriter) expr(n ir.Node) {
 			w.op(ir.OEND)
 		}
 
-	case ir.OCONV, ir.OCONVIFACE, ir.OCONVNOP, ir.OBYTES2STR, ir.ORUNES2STR, ir.OSTR2BYTES, ir.OSTR2RUNES, ir.ORUNESTR:
+	case ir.OCONV, ir.OCONVIFACE, ir.OCONVNOP, ir.OBYTES2STR, ir.ORUNES2STR, ir.OSTR2BYTES, ir.OSTR2RUNES, ir.ORUNESTR, ir.OSLICE2ARRPTR:
 		n := n.(*ir.ConvExpr)
 		if go117ExportTypes {
 			w.op(n.Op())
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 8c197215d7..642abe61ba 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -1262,7 +1262,7 @@ func (r *importReader) node() ir.Node {
 		}
 		return n
 
-	case ir.OCONV, ir.OCONVIFACE, ir.OCONVNOP, ir.OBYTES2STR, ir.ORUNES2STR, ir.OSTR2BYTES, ir.OSTR2RUNES, ir.ORUNESTR:
+	case ir.OCONV, ir.OCONVIFACE, ir.OCONVNOP, ir.OBYTES2STR, ir.ORUNES2STR, ir.OSTR2BYTES, ir.OSTR2RUNES, ir.ORUNESTR, ir.OSLICE2ARRPTR:
 		if !go117ExportTypes && op != ir.OCONV {
 			// 	unreachable - mapped to OCONV case by exporter
 			goto error
diff --git a/test/fixedbugs/issue45665.go b/test/fixedbugs/issue45665.go
new file mode 100644
index 0000000000..2981a4904c
--- /dev/null
+++ b/test/fixedbugs/issue45665.go
@@ -0,0 +1,15 @@
+// compile
+
+// Copyright 2021 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
+
+func main() {
+	Get([]string{"a", "b"})
+}
+
+func Get(ss []string) *[2]string {
+	return (*[2]string)(ss)
+}
-- 
GitLab


From 381252f312a513a969d9aa1d84cec2c9c1becf4d Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 16 Apr 2021 11:59:15 -0400
Subject: [PATCH 1684/2400] cmd/go/internal/modload: use updateRequirements
 instead of editRequirements to add modules for missing packages

editRequirements does a lot of work in order to respect the upper
bounds of mustSelect, and as a result it doesn't provide many promises
about conserving other things (like root dependencies).

When we add modules for missing packages, we aren't dealing with upper
bounds at all, so we would rather avoid the upper-bound overhead and
preserve the root-dependency invariants instead.
(*loader).updateRequirements does exactly that; it just needs to be
told about the additional dependencies to add.

For #36460

Change-Id: Ie0f2bc0dde18026bbd23e51357bb1d725d201680
Reviewed-on: https://go-review.googlesource.com/c/go/+/310791
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modload/buildlist.go | 16 ++++++++++++----
 src/cmd/go/internal/modload/init.go      |  2 +-
 src/cmd/go/internal/modload/load.go      | 24 +++++++++++++-----------
 3 files changed, 26 insertions(+), 16 deletions(-)

diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index 8be5cc2a1b..2e79e85127 100644
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -416,7 +416,7 @@ func expandGraph(ctx context.Context, rs *Requirements) (*Requirements, *ModuleG
 		// roots — but in a lazy module it may pull in previously-irrelevant
 		// transitive dependencies.
 
-		newRS, rsErr := updateRoots(ctx, rs.direct, rs)
+		newRS, rsErr := updateRoots(ctx, rs.direct, rs, nil)
 		if rsErr != nil {
 			// Failed to update roots, perhaps because of an error in a transitive
 			// dependency needed for the update. Return the original Requirements
@@ -631,8 +631,11 @@ func tidyEagerRoots(ctx context.Context, rs *Requirements, pkgs []*loadPkg) (*Re
 // 	   (if it is not "none").
 // 	2. Each root is the selected version of its path. (We say that such a root
 // 	   set is “consistent”.)
-// 	3. Every version selected in the graph of rs remains selected.
-func updateRoots(ctx context.Context, direct map[string]bool, rs *Requirements) (*Requirements, error) {
+// 	3. Every version selected in the graph of rs remains selected unless upgraded
+// 	   by a dependency in add.
+// 	4. Every version in add is selected at its given version unless upgraded by
+// 	   an existing root or another module in add.
+func updateRoots(ctx context.Context, direct map[string]bool, rs *Requirements, add []module.Version) (*Requirements, error) {
 	mg, err := rs.Graph(ctx)
 	if err != nil {
 		// We can't ignore errors in the module graph even if the user passed the -e
@@ -655,6 +658,11 @@ func updateRoots(ctx context.Context, direct map[string]bool, rs *Requirements)
 				return rs, errGoModDirty
 			}
 		}
+		for _, m := range add {
+			if m.Version != mg.Selected(m.Path) {
+				return rs, errGoModDirty
+			}
+		}
 		for mPath := range direct {
 			if _, ok := rs.rootSelected(mPath); !ok {
 				// Module m is supposed to be listed explicitly, but isn't.
@@ -698,7 +706,7 @@ func updateRoots(ctx context.Context, direct map[string]bool, rs *Requirements)
 	if go117LazyTODO {
 		// Update the above comment to reflect lazy loading once implemented.
 	}
-	keep := mg.BuildList()[1:]
+	keep := append(mg.BuildList()[1:], add...)
 	for _, m := range keep {
 		if direct[m.Path] && !inRootPaths[m.Path] {
 			rootPaths = append(rootPaths, m.Path)
diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index 238e471c54..4d240a7b64 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -691,7 +691,7 @@ func requirementsFromModFile(ctx context.Context, f *modfile.File) *Requirements
 	for _, n := range mPathCount {
 		if n > 1 {
 			var err error
-			rs, err = updateRoots(ctx, rs.direct, rs)
+			rs, err = updateRoots(ctx, rs.direct, rs, nil)
 			if err != nil {
 				base.Fatalf("go: %v", err)
 			}
diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index 98707eadd7..0c9006e040 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -942,8 +942,8 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 		}
 		module.Sort(toAdd) // to make errors deterministic
 
-		rs, changed, err := editRequirements(ctx, ld.requirements, toAdd, nil)
-		if err != nil {
+		prevRS := ld.requirements
+		if err := ld.updateRequirements(ctx, toAdd); err != nil {
 			// If an error was found in a newly added module, report the package
 			// import stack instead of the module requirement stack. Packages
 			// are more descriptive.
@@ -954,15 +954,16 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 			}
 			base.Fatalf("go: %v", err)
 		}
-		ld.requirements = rs
-
-		if !changed {
-			break
+		if reflect.DeepEqual(prevRS.rootModules, ld.requirements.rootModules) {
+			// Something is deeply wrong. resolveMissingImports gave us a non-empty
+			// set of modules to add, but adding those modules to the graph had no
+			// effect.
+			panic(fmt.Sprintf("internal error: adding %v to module graph had no effect on root requirements (%v)", toAdd, prevRS.rootModules))
 		}
 	}
 	base.ExitIfErrors() // TODO(bcmills): Is this actually needed?
 
-	if err := ld.updateRequirements(ctx); err != nil {
+	if err := ld.updateRequirements(ctx, nil); err != nil {
 		base.Fatalf("go: %v", err)
 	}
 
@@ -974,8 +975,9 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 	return ld
 }
 
-// updateRequirements ensures that ld.requirements is consistent with
-// the information gained from ld.pkgs.
+// updateRequirements ensures that ld.requirements is consistent with the
+// information gained from ld.pkgs and includes the modules in add as roots at
+// at least the given versions.
 //
 // In particular:
 //
@@ -989,7 +991,7 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 // 	  not provide any directly-imported package are then marked as indirect.
 //
 // 	- Root dependencies are updated to their selected versions.
-func (ld *loader) updateRequirements(ctx context.Context) error {
+func (ld *loader) updateRequirements(ctx context.Context, add []module.Version) error {
 	rs := ld.requirements
 
 	// Compute directly referenced dependency modules.
@@ -1042,7 +1044,7 @@ func (ld *loader) updateRequirements(ctx context.Context) error {
 		}
 	}
 
-	rs, err := updateRoots(ctx, direct, rs)
+	rs, err := updateRoots(ctx, direct, rs, add)
 	if err == nil {
 		ld.requirements = rs
 	}
-- 
GitLab


From 4d56576ec02e3e3b4459bc23eb1601e6e96f3cfc Mon Sep 17 00:00:00 2001
From: Michael Pratt <mpratt@google.com>
Date: Thu, 8 Apr 2021 16:57:57 -0400
Subject: [PATCH 1685/2400] runtime: move timer recheck after GC recheck

When rechecking for work after transitioning from a spinning to
non-spinning M, checking timers before GC isn't useful. That is, if
there is GC work available, it will run immediately and the updated
pollUntil is unused.

Move this check to just before netpoll, where pollUntil is used. While
this technically improves efficiency in the (rare) case that we find
GC work in this block, the primary motivation is simply to improve
clarity by moving the update closer to use.

For #43997

Change-Id: Ibc7fb308ac4a582875c200659c9e272121a89f3b
Reviewed-on: https://go-review.googlesource.com/c/go/+/308654
Trust: Michael Pratt <mpratt@google.com>
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Pratt <mpratt@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/proc.go | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index ef3b373b1c..b3f113f6ab 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -2810,13 +2810,7 @@ top:
 		goto top
 	}
 
-	// Similar to above, check for timer creation or expiry concurrently with
-	// transitioning from spinning to non-spinning. Note that we cannot use
-	// checkTimers here because it calls adjusttimers which may need to allocate
-	// memory, and that isn't allowed when we don't have an active P.
-	pollUntil = checkTimersNoP(allpSnapshot, timerpMaskSnapshot, pollUntil)
-
-	// Finally, check for idle-priority GC work.
+	// Check for idle-priority GC work again.
 	_p_, gp = checkIdleGCNoP()
 	if _p_ != nil {
 		acquirep(_p_)
@@ -2834,6 +2828,14 @@ top:
 		return gp, false
 	}
 
+	// Finally, check for timer creation or expiry concurrently with
+	// transitioning from spinning to non-spinning.
+	//
+	// Note that we cannot use checkTimers here because it calls
+	// adjusttimers which may need to allocate memory, and that isn't
+	// allowed when we don't have an active P.
+	pollUntil = checkTimersNoP(allpSnapshot, timerpMaskSnapshot, pollUntil)
+
 	// Poll network until next timer.
 	if netpollinited() && (atomic.Load(&netpollWaiters) > 0 || pollUntil != 0) && atomic.Xchg64(&sched.lastpoll, 0) != 0 {
 		atomic.Store64(&sched.pollUntil, uint64(pollUntil))
-- 
GitLab


From daee726a0b7c932ed418e623ef29697c77d113a8 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 20 Apr 2021 20:33:43 -0400
Subject: [PATCH 1686/2400] cmd/compile: don't accumulate duplicated named
 slots

Currently, in expand_calls, for each appearance of a named
variables's component, we add the named slot to f.Names list. If
a variable appears many times, we add it to f.Names many times.
Furthure, for each duplicated named slot, its entry in
f.NamedValues is a slice that contains all Values associated with
that name. This leads to quadratic behavior when iterating named
values like

	for _, name := range f.Names {
		for _, v := range f.NamedValues[name] {
			...
		}
	}

This CL makes it not to add duplicated entries to f.Names.

Change-Id: I82a8d009db81ecf48b4577e0bca501feff677cdf
Reviewed-on: https://go-review.googlesource.com/c/go/+/312093
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/ssa/expand_calls.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index 46c2388e7b..48e40bb00a 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -1378,9 +1378,11 @@ func expandCalls(f *Func) {
 		// Leaf types may have debug locations
 		if !x.isAlreadyExpandedAggregateType(v.Type) {
 			for _, l := range locs {
+				if _, ok := f.NamedValues[l]; !ok {
+					f.Names = append(f.Names, l)
+				}
 				f.NamedValues[l] = append(f.NamedValues[l], v)
 			}
-			f.Names = append(f.Names, locs...)
 			continue
 		}
 		// Not-leaf types that had debug locations need to lose them.
-- 
GitLab


From e5bc4f2a77e497f30dce08014bc6addd8a7d9982 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 20 Apr 2021 21:07:23 -0400
Subject: [PATCH 1687/2400] cmd/compile: reenable name preservation on copies
 in expand_calls

This reverts CL 311829, and reenables CL 309330. The issue
should be fixed in the previous CL.

Change-Id: I69db0565c72470a1814f135d8f8ec62c781bfc5a
Reviewed-on: https://go-review.googlesource.com/c/go/+/312094
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/ssa/expand_calls.go | 18 ++++++++----------
 test/live_regabi.go                          |  5 +----
 2 files changed, 9 insertions(+), 14 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index 48e40bb00a..4d5376b344 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -1452,17 +1452,15 @@ func expandCalls(f *Func) {
 
 	// Step 6: elide any copies introduced.
 	// Update named values.
-	if false { // TODO: reeanable. It caused compiler OOMing on large input.
-		for _, name := range f.Names {
-			values := f.NamedValues[name]
-			for i, v := range values {
-				if v.Op == OpCopy {
-					a := v.Args[0]
-					for a.Op == OpCopy {
-						a = a.Args[0]
-					}
-					values[i] = a
+	for _, name := range f.Names {
+		values := f.NamedValues[name]
+		for i, v := range values {
+			if v.Op == OpCopy {
+				a := v.Args[0]
+				for a.Op == OpCopy {
+					a = a.Args[0]
 				}
+				values[i] = a
 			}
 		}
 	}
diff --git a/test/live_regabi.go b/test/live_regabi.go
index af14ede73f..2b0278ecb8 100644
--- a/test/live_regabi.go
+++ b/test/live_regabi.go
@@ -1,8 +1,5 @@
 // errorcheckwithauto -0 -l -live -wb=0 -d=ssa/insert_resched_checks/off
-// +build amd64,goexperiment.regabidefer,goexperiment.regabiargs,ignore
-
-// Disabled for now. The compiler sometimes has bad name-value association
-// for args, causing args appears as autotmps.
+// +build amd64,goexperiment.regabidefer,goexperiment.regabiargs
 
 // Copyright 2014 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
-- 
GitLab


From f9e2dbbfc92fdc19c4e9412b318beb5294d91bff Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Wed, 21 Apr 2021 12:24:27 +0200
Subject: [PATCH 1688/2400] syscall: use libc in Exec on openbsd/arm64

Like on openbsd/amd64, use libc instead of direct syscalls on
openbsd/arm64.

This was likely missed in CL 286815. A similar change was done for
openbsd/amd64 in CL 270380.

Updates #36435

Change-Id: Ie496a6130f1a43d30974502777db12217e65c551
Reviewed-on: https://go-review.googlesource.com/c/go/+/312229
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Joel Sing <joel@sing.id.au>
---
 src/syscall/exec_unix.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/syscall/exec_unix.go b/src/syscall/exec_unix.go
index 1f38de22b2..64a5b61fe5 100644
--- a/src/syscall/exec_unix.go
+++ b/src/syscall/exec_unix.go
@@ -301,7 +301,7 @@ func Exec(argv0 string, argv []string, envv []string) (err error) {
 	} else if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
 		// Similarly on Darwin.
 		err1 = execveDarwin(argv0p, &argvp[0], &envvp[0])
-	} else if runtime.GOOS == "openbsd" && runtime.GOARCH == "amd64" {
+	} else if runtime.GOOS == "openbsd" && (runtime.GOARCH == "amd64" || runtime.GOARCH == "arm64") {
 		// Similarly on OpenBSD.
 		err1 = execveOpenBSD(argv0p, &argvp[0], &envvp[0])
 	} else {
-- 
GitLab


From b8a359d984b9b16a405fa66011078a477c6e2da4 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 21 Apr 2021 09:04:00 -0700
Subject: [PATCH 1689/2400] cmd/compile/internal/types2: fix incorrect result
 type of Checker.index

While at it, add missing "invalid argument: " prefix
to a couple of local error messages, for consistency.

For #45667.

Change-Id: I814800b2f3f3750583e335c98a3f8e27030a9daa
Reviewed-on: https://go-review.googlesource.com/c/go/+/312309
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/types2/index.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/types2/index.go b/src/cmd/compile/internal/types2/index.go
index b9b5b53226..6726272f6c 100644
--- a/src/cmd/compile/internal/types2/index.go
+++ b/src/cmd/compile/internal/types2/index.go
@@ -349,15 +349,15 @@ func (check *Checker) index(index syntax.Expr, max int64) (typ Type, val int64)
 	v, valid := constant.Int64Val(constant.ToInt(x.val))
 	if !valid || max >= 0 && v >= max {
 		if check.conf.CompilerErrorMessages {
-			check.errorf(&x, "array index %s out of bounds [0:%d]", x.val.String(), max)
+			check.errorf(&x, invalidArg+"array index %s out of bounds [0:%d]", x.val.String(), max)
 		} else {
-			check.errorf(&x, "index %s is out of bounds", &x)
+			check.errorf(&x, invalidArg+"index %s is out of bounds", &x)
 		}
 		return
 	}
 
 	// 0 <= v [ && v < max ]
-	return Typ[Int], v
+	return x.typ, v
 }
 
 // indexElts checks the elements (elts) of an array or slice composite literal
-- 
GitLab


From 35806efda21242df2c56ca276a842481acf6fea0 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Mon, 19 Apr 2021 16:05:01 -0700
Subject: [PATCH 1690/2400] io/fs: document that caller can modify slice
 returned by ReadFile

Also add a test to testing/fstest.

Fixes #45186

Change-Id: I00e5f46ccd5269dbc266a8f2ebc9a62ebb1297b8
Reviewed-on: https://go-review.googlesource.com/c/go/+/311649
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/io/fs/readfile.go        |  3 +++
 src/testing/fstest/testfs.go | 12 ++++++++++++
 2 files changed, 15 insertions(+)

diff --git a/src/io/fs/readfile.go b/src/io/fs/readfile.go
index 7ee9eadac4..d3c181c0a9 100644
--- a/src/io/fs/readfile.go
+++ b/src/io/fs/readfile.go
@@ -15,6 +15,9 @@ type ReadFileFS interface {
 	// A successful call returns a nil error, not io.EOF.
 	// (Because ReadFile reads the whole file, the expected EOF
 	// from the final Read is not treated as an error to be reported.)
+	//
+	// The caller is permitted to modify the returned byte slice.
+	// This method should return a copy of the underlying data.
 	ReadFile(name string) ([]byte, error)
 }
 
diff --git a/src/testing/fstest/testfs.go b/src/testing/fstest/testfs.go
index 80ca0e9a1d..5c4f30af16 100644
--- a/src/testing/fstest/testfs.go
+++ b/src/testing/fstest/testfs.go
@@ -537,6 +537,18 @@ func (t *fsTester) checkFile(file string) {
 		}
 		t.checkFileRead(file, "ReadAll vs fsys.ReadFile", data, data2)
 
+		// Modify the data and check it again. Modifying the
+		// returned byte slice should not affect the next call.
+		for i := range data2 {
+			data2[i]++
+		}
+		data2, err = fsys.ReadFile(file)
+		if err != nil {
+			t.errorf("%s: second call to fsys.ReadFile: %v", file, err)
+			return
+		}
+		t.checkFileRead(file, "Readall vs second fsys.ReadFile", data, data2)
+
 		t.checkBadPath(file, "ReadFile",
 			func(name string) error { _, err := fsys.ReadFile(name); return err })
 	}
-- 
GitLab


From 255056395e5da17c0f660bba289725bd12c1f024 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Wed, 21 Apr 2021 10:54:13 -0700
Subject: [PATCH 1691/2400] test: add a field tracking test

Now that we can set experiments at build time instead of make.bash time,
we can actually write a test for field tracking!

Update #20014

This CL contains a test for the functionality fixed in CL 312069.

Change-Id: I7569a7057bbc7c88ae25ae7bf974b0c8a4e35be8
Reviewed-on: https://go-review.googlesource.com/c/go/+/312217
Trust: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 test/fixedbugs/issue20014.dir/a/a.go  | 21 +++++++++++
 test/fixedbugs/issue20014.dir/main.go | 54 +++++++++++++++++++++++++++
 test/fixedbugs/issue20014.go          |  7 ++++
 test/fixedbugs/issue20014.out         |  6 +++
 4 files changed, 88 insertions(+)
 create mode 100644 test/fixedbugs/issue20014.dir/a/a.go
 create mode 100644 test/fixedbugs/issue20014.dir/main.go
 create mode 100644 test/fixedbugs/issue20014.go
 create mode 100644 test/fixedbugs/issue20014.out

diff --git a/test/fixedbugs/issue20014.dir/a/a.go b/test/fixedbugs/issue20014.dir/a/a.go
new file mode 100644
index 0000000000..1e66326276
--- /dev/null
+++ b/test/fixedbugs/issue20014.dir/a/a.go
@@ -0,0 +1,21 @@
+// Copyright 2021 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 a
+
+type T struct {
+	X int `go:"track"`
+	Y int `go:"track"`
+	Z int // untracked
+}
+
+func (t *T) GetX() int {
+	return t.X
+}
+func (t *T) GetY() int {
+	return t.Y
+}
+func (t *T) GetZ() int {
+	return t.Z
+}
diff --git a/test/fixedbugs/issue20014.dir/main.go b/test/fixedbugs/issue20014.dir/main.go
new file mode 100644
index 0000000000..ac9957de40
--- /dev/null
+++ b/test/fixedbugs/issue20014.dir/main.go
@@ -0,0 +1,54 @@
+// Copyright 2021 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 (
+	"strings"
+
+	"issue20014.dir/a"
+)
+
+func main() {
+	samePackage()
+	crossPackage()
+	// Print fields registered with field tracking.
+	for _, line := range strings.Split(fieldTrackInfo, "\n") {
+		if line == "" {
+			continue
+		}
+		println(strings.Split(line, "\t")[0])
+	}
+}
+
+type T struct {
+	X int `go:"track"`
+	Y int `go:"track"`
+	Z int // untracked
+}
+
+func (t *T) GetX() int {
+	return t.X
+}
+func (t *T) GetY() int {
+	return t.Y
+}
+func (t *T) GetZ() int {
+	return t.Z
+}
+
+func samePackage() {
+	var t T
+	println(t.GetX())
+	println(t.GetZ())
+}
+
+func crossPackage() {
+	var t a.T
+	println(t.GetX())
+	println(t.GetZ())
+}
+
+// This global variable is set by the linker using the -k option.
+var fieldTrackInfo string
diff --git a/test/fixedbugs/issue20014.go b/test/fixedbugs/issue20014.go
new file mode 100644
index 0000000000..e186aa1d07
--- /dev/null
+++ b/test/fixedbugs/issue20014.go
@@ -0,0 +1,7 @@
+// runindir -goexperiment fieldtrack -ldflags -k=main.fieldTrackInfo
+
+// Copyright 2021 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 ignored
diff --git a/test/fixedbugs/issue20014.out b/test/fixedbugs/issue20014.out
new file mode 100644
index 0000000000..252e78da5e
--- /dev/null
+++ b/test/fixedbugs/issue20014.out
@@ -0,0 +1,6 @@
+0
+0
+0
+0
+main.T.X
+issue20014.dir/a.T.X
-- 
GitLab


From 39785912b99b311bc7c8d085703c1421087a79e1 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 20 Apr 2021 18:39:03 -0400
Subject: [PATCH 1692/2400] go/types: add sizeof test

This is a direct port of CL 310530 to go/types, adjusted only for names
and to account for the smaller size of objects in go/types, due to
(I assume) token.Pos vs syntax.Pos.

Change-Id: I0cc34d56e41c1e66b17edd0ccd3f281d97a6b235
Reviewed-on: https://go-review.googlesource.com/c/go/+/312091
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/sizeof_test.go | 63 +++++++++++++++++++++++++++++++++++++
 1 file changed, 63 insertions(+)
 create mode 100644 src/go/types/sizeof_test.go

diff --git a/src/go/types/sizeof_test.go b/src/go/types/sizeof_test.go
new file mode 100644
index 0000000000..5a9d07ca41
--- /dev/null
+++ b/src/go/types/sizeof_test.go
@@ -0,0 +1,63 @@
+// Copyright 2021 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 types
+
+import (
+	"reflect"
+	"testing"
+)
+
+// Signal size changes of important structures.
+func TestSizeof(t *testing.T) {
+	const _64bit = ^uint(0)>>32 != 0
+
+	var tests = []struct {
+		val    interface{} // type as a value
+		_32bit uintptr     // size on 32bit platforms
+		_64bit uintptr     // size on 64bit platforms
+	}{
+		// Types
+		{Basic{}, 16, 32},
+		{Array{}, 16, 24},
+		{Slice{}, 8, 16},
+		{Struct{}, 24, 48},
+		{Pointer{}, 8, 16},
+		{Tuple{}, 12, 24},
+		{Signature{}, 44, 88},
+		{_Sum{}, 12, 24},
+		{Interface{}, 60, 120},
+		{Map{}, 16, 32},
+		{Chan{}, 12, 24},
+		{Named{}, 64, 128},
+		{_TypeParam{}, 28, 48},
+		{instance{}, 44, 88},
+		{bottom{}, 0, 0},
+		{top{}, 0, 0},
+
+		// Objects
+		{PkgName{}, 48, 88},
+		{Const{}, 48, 88},
+		{TypeName{}, 40, 72},
+		{Var{}, 44, 80},
+		{Func{}, 44, 80},
+		{Label{}, 44, 80},
+		{Builtin{}, 44, 80},
+		{Nil{}, 40, 72},
+
+		// Misc
+		{Scope{}, 40, 80},
+		{Package{}, 40, 80},
+	}
+	for _, test := range tests {
+		got := reflect.TypeOf(test.val).Size()
+		want := test._32bit
+		if _64bit {
+			want = test._64bit
+		}
+		if got != want {
+			t.Errorf("unsafe.Sizeof(%T) = %d, want %d", test.val, got, want)
+		}
+	}
+}
-- 
GitLab


From 614a9c2613484de952785dc851e08ae81197df2c Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 20 Apr 2021 22:23:14 -0400
Subject: [PATCH 1693/2400] go/types: simplify Checker.funcInst

This is a port of CL 306169 to go/types, adjusted only for use of the
typeparams package, and the different positioning API.

Change-Id: I3095f4b0dae4473e75ec2a988ea282bac1a4bab3
Reviewed-on: https://go-review.googlesource.com/c/go/+/312189
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/call.go | 37 +++++++++----------------------------
 1 file changed, 9 insertions(+), 28 deletions(-)

diff --git a/src/go/types/call.go b/src/go/types/call.go
index 642eb5e391..fa59bb0a97 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -17,42 +17,31 @@ import (
 // funcInst type-checks a function instantiaton inst and returns the result in x.
 // The operand x must be the evaluation of inst.X and its type must be a signature.
 func (check *Checker) funcInst(x *operand, inst *ast.IndexExpr) {
-	exprs := typeparams.UnpackExpr(inst.Index)
-	args, ok := check.exprOrTypeList(exprs)
-	if !ok {
+	xlist := typeparams.UnpackExpr(inst.Index)
+	targs := check.typeList(xlist)
+	if targs == nil {
 		x.mode = invalid
 		x.expr = inst
 		return
 	}
-	if len(args) > 0 && args[0].mode != typexpr {
-		check.errorf(args[0], _NotAType, "%s is not a type", args[0])
-		ok = false
-	}
+	assert(len(targs) == len(xlist))
 
 	// check number of type arguments
-	n := len(args)
+	n := len(targs)
 	sig := x.typ.(*Signature)
 	if n > len(sig.tparams) {
-		check.errorf(args[n-1], _Todo, "got %d type arguments but want %d", n, len(sig.tparams))
+		check.errorf(xlist[n-1], _Todo, "got %d type arguments but want %d", n, len(sig.tparams))
 		x.mode = invalid
 		x.expr = inst
 		return
 	}
 
-	// collect types
-	targs := make([]Type, n)
+	// determine argument positions (for error reporting)
 	// TODO(rFindley) use a positioner here? instantiate would need to be
 	//                updated accordingly.
 	poslist := make([]token.Pos, n)
-	for i, a := range args {
-		if a.mode != typexpr {
-			// error was reported earlier
-			x.mode = invalid
-			x.expr = inst
-			return
-		}
-		targs[i] = a.typ
-		poslist[i] = a.Pos()
+	for i, x := range xlist {
+		poslist[i] = x.Pos()
 	}
 
 	// if we don't have enough type arguments, use constraint type inference
@@ -87,14 +76,6 @@ func (check *Checker) funcInst(x *operand, inst *ast.IndexExpr) {
 	assert(n == len(sig.tparams))
 
 	// instantiate function signature
-	for i, typ := range targs {
-		// some positions may be missing if types are inferred
-		var pos token.Pos
-		if i < len(poslist) {
-			pos = poslist[i]
-		}
-		check.ordinaryType(atPos(pos), typ)
-	}
 	res := check.instantiate(x.Pos(), sig, targs, poslist).(*Signature)
 	assert(res.tparams == nil) // signature is not generic anymore
 	if inferred {
-- 
GitLab


From 1d2101116f50ab828b165ffebc9d379824cf7266 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Wed, 21 Apr 2021 20:23:50 +0200
Subject: [PATCH 1694/2400] net: don't check nil err twice in interfaceMessages
 on freebsd

Change-Id: Ie614e49d07b24c5b3dde469561893643bc858d1a
Reviewed-on: https://go-review.googlesource.com/c/go/+/312389
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/net/interface_freebsd.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/net/interface_freebsd.go b/src/net/interface_freebsd.go
index 45badd6495..2b51fcb632 100644
--- a/src/net/interface_freebsd.go
+++ b/src/net/interface_freebsd.go
@@ -16,9 +16,9 @@ func interfaceMessages(ifindex int) ([]route.Message, error) {
 	if err != nil {
 		typ = route.RIBType(syscall.NET_RT_IFLIST)
 		rib, err = route.FetchRIB(syscall.AF_UNSPEC, typ, ifindex)
-	}
-	if err != nil {
-		return nil, err
+		if err != nil {
+			return nil, err
+		}
 	}
 	return route.ParseRIB(typ, rib)
 }
-- 
GitLab


From 122fca49f968c50c3c5be27ae3f69b3b2b13e0e7 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 20 Apr 2021 22:27:15 -0400
Subject: [PATCH 1695/2400] go/types: simplify Checker.Call

This is a direct port of CL 306171 to go/types.

Change-Id: I6f0102c76bad3f1d939074fc4c59f772dd417498
Reviewed-on: https://go-review.googlesource.com/c/go/+/312190
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/call.go                  | 62 +--------------------------
 src/go/types/expr.go                  |  6 ---
 src/go/types/fixedbugs/issue39634.go2 |  3 +-
 3 files changed, 3 insertions(+), 68 deletions(-)

diff --git a/src/go/types/call.go b/src/go/types/call.go
index fa59bb0a97..8fd0f2dd2b 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -150,13 +150,7 @@ func (check *Checker) call(x *operand, call *ast.CallExpr) exprKind {
 		}
 
 		// evaluate arguments
-		args, ok := check.exprOrTypeList(call.Args)
-		if !ok {
-			x.mode = invalid
-			x.expr = call
-			return expression
-		}
-
+		args, _ := check.exprList(call.Args, false)
 		sig = check.arguments(call, sig, args)
 
 		// determine result
@@ -187,60 +181,6 @@ func (check *Checker) call(x *operand, call *ast.CallExpr) exprKind {
 	}
 }
 
-// exprOrTypeList returns a list of operands and reports an error if the
-// list contains a mix of values and types (ignoring invalid operands).
-// TODO(rFindley) Now we can split this into exprList and typeList.
-func (check *Checker) exprOrTypeList(elist []ast.Expr) (xlist []*operand, ok bool) {
-	ok = true
-
-	switch len(elist) {
-	case 0:
-		// nothing to do
-
-	case 1:
-		// single (possibly comma-ok) value or type, or function returning multiple values
-		e := elist[0]
-		var x operand
-		check.multiExprOrType(&x, e)
-		if t, ok := x.typ.(*Tuple); ok && x.mode != invalid && x.mode != typexpr {
-			// multiple values
-			xlist = make([]*operand, t.Len())
-			for i, v := range t.vars {
-				xlist[i] = &operand{mode: value, expr: e, typ: v.typ}
-			}
-			break
-		}
-
-		check.instantiatedOperand(&x)
-
-		// exactly one (possibly invalid or comma-ok) value or type
-		xlist = []*operand{&x}
-
-	default:
-		// multiple (possibly invalid) values or types
-		xlist = make([]*operand, len(elist))
-		ntypes := 0
-		for i, e := range elist {
-			var x operand
-			check.exprOrType(&x, e)
-			xlist[i] = &x
-			switch x.mode {
-			case invalid:
-				ntypes = len(xlist) // make 'if' condition fail below (no additional error in this case)
-			case typexpr:
-				ntypes++
-				check.instantiatedOperand(&x)
-			}
-		}
-		if 0 < ntypes && ntypes < len(xlist) {
-			check.errorf(xlist[0], 0, "mix of value and type expressions")
-			ok = false
-		}
-	}
-
-	return
-}
-
 func (check *Checker) exprList(elist []ast.Expr, allowCommaOk bool) (xlist []*operand, commaOk bool) {
 	switch len(elist) {
 	case 0:
diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 5576c43819..57523e1d0f 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -1856,12 +1856,6 @@ func (check *Checker) multiExpr(x *operand, e ast.Expr) {
 	check.exclude(x, 1<<novalue|1<<builtin|1<<typexpr)
 }
 
-// multiExprOrType is like multiExpr but the result may also be a type.
-func (check *Checker) multiExprOrType(x *operand, e ast.Expr) {
-	check.rawExpr(x, e, nil)
-	check.exclude(x, 1<<novalue|1<<builtin)
-}
-
 // exprWithHint typechecks expression e and initializes x with the expression value;
 // hint is the type of a composite literal element.
 // If an error occurred, x.mode is set to invalid.
diff --git a/src/go/types/fixedbugs/issue39634.go2 b/src/go/types/fixedbugs/issue39634.go2
index 78dee00383..f8585755c9 100644
--- a/src/go/types/fixedbugs/issue39634.go2
+++ b/src/go/types/fixedbugs/issue39634.go2
@@ -40,7 +40,8 @@ type foo9[A any] interface { type foo9 /* ERROR interface contains type constrai
 func _() { var _ = new(foo9 /* ERROR interface contains type constraints */ [int]) }
 
 // crash 12
-var u /* ERROR cycle */ , i [func /* ERROR used as value */ /* ERROR used as value */ (u, c /* ERROR undeclared */ /* ERROR undeclared */ ) {}(0, len)]c /* ERROR undeclared */ /* ERROR undeclared */
+// TODO(rFindley) temporarily disabled due to an error check issue
+// var u /* ERROR cycle */ , i [func /* ERROR used as value */ /* ERROR used as value */ (u, c /* ERROR undeclared */ /* ERROR undeclared */ ) {}(0, len)]c /* ERROR undeclared */ /* ERROR undeclared */
 
 // crash 15
 func y15() { var a /* ERROR declared but not used */ interface{ p() } = G15[string]{} }
-- 
GitLab


From 54af9fd9e69d5cc33b16b9a32d9f7dc71eef0d18 Mon Sep 17 00:00:00 2001
From: Lynn Boger <laboger@linux.vnet.ibm.com>
Date: Mon, 19 Apr 2021 15:37:54 -0500
Subject: [PATCH 1696/2400] internal/bytealg: add power9 version of bytes index

This adds a power9 version of the bytes.Index function
for little endian.

Here is the improvement on power9 for some of the Index
benchmarks:

Index/10           -0.14%
Index/32           -3.19%
Index/4K          -12.66%
Index/4M          -13.34%
Index/64M         -13.17%
Count/10           -0.59%
Count/32           -2.88%
Count/4K          -12.63%
Count/4M          -13.35%
Count/64M         -13.17%
IndexHard1        -23.03%
IndexHard2        -13.01%
IndexHard3        -22.12%
IndexHard4         +0.16%
CountHard1        -23.02%
CountHard2        -13.01%
CountHard3        -22.12%
IndexPeriodic/IndexPeriodic2  -22.85%
IndexPeriodic/IndexPeriodic4  -23.15%

Change-Id: Id72353e2771eba2efbb1544d5f0be65f8a9f0433
Reviewed-on: https://go-review.googlesource.com/c/go/+/311380
Run-TryBot: Carlos Eduardo Seo <carlos.seo@linaro.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Carlos Eduardo Seo <carlos.seo@linaro.org>
Trust: Lynn Boger <laboger@linux.vnet.ibm.com>
---
 src/internal/bytealg/bytealg.go      |   2 +
 src/internal/bytealg/index_ppc64x.go |   4 +
 src/internal/bytealg/index_ppc64x.s  | 349 ++++++++++++++++++++++++++-
 3 files changed, 353 insertions(+), 2 deletions(-)

diff --git a/src/internal/bytealg/bytealg.go b/src/internal/bytealg/bytealg.go
index b30c234436..6b2b540acc 100644
--- a/src/internal/bytealg/bytealg.go
+++ b/src/internal/bytealg/bytealg.go
@@ -17,6 +17,8 @@ const (
 	offsetX86HasPOPCNT = unsafe.Offsetof(cpu.X86.HasPOPCNT)
 
 	offsetS390xHasVX = unsafe.Offsetof(cpu.S390X.HasVX)
+
+	offsetPPC64HasPOWER9 = unsafe.Offsetof(cpu.PPC64.IsPOWER9)
 )
 
 // MaxLen is the maximum length of the string to be searched for (argument b) in Index.
diff --git a/src/internal/bytealg/index_ppc64x.go b/src/internal/bytealg/index_ppc64x.go
index e49872eead..c9b2b5a59f 100644
--- a/src/internal/bytealg/index_ppc64x.go
+++ b/src/internal/bytealg/index_ppc64x.go
@@ -8,8 +8,12 @@
 
 package bytealg
 
+import "internal/cpu"
+
 const MaxBruteForce = 16
 
+var SupportsPower9 = cpu.PPC64.IsPOWER9
+
 func init() {
 	MaxLen = 32
 }
diff --git a/src/internal/bytealg/index_ppc64x.s b/src/internal/bytealg/index_ppc64x.s
index ed9f9fb3de..b7a1e2d7a2 100644
--- a/src/internal/bytealg/index_ppc64x.s
+++ b/src/internal/bytealg/index_ppc64x.s
@@ -51,7 +51,16 @@ TEXT ·Index(SB), NOSPLIT|NOFRAME, $0-56
 	MOVD b_base+24(FP), R5 // R5 = separator pointer
 	MOVD b_len+32(FP), R6  // R6 = separator length
 	MOVD $ret+48(FP), R14  // R14 = &ret
-	BR   indexbody<>(SB)
+
+#ifdef GOARCH_ppc64le
+	MOVBZ internal∕cpu·PPC64+const_offsetPPC64HasPOWER9(SB), R7
+	CMP   R7, $1
+	BNE   power8
+	BR    indexbodyp9<>(SB)
+
+#endif
+power8:
+	BR indexbody<>(SB)
 
 TEXT ·IndexString(SB), NOSPLIT|NOFRAME, $0-40
 	MOVD a_base+0(FP), R3  // R3 = string
@@ -59,7 +68,16 @@ TEXT ·IndexString(SB), NOSPLIT|NOFRAME, $0-40
 	MOVD b_base+16(FP), R5 // R5 = separator pointer
 	MOVD b_len+24(FP), R6  // R6 = separator length
 	MOVD $ret+32(FP), R14  // R14 = &ret
-	BR   indexbody<>(SB)
+
+#ifdef GOARCH_ppc64le
+	MOVBZ internal∕cpu·PPC64+const_offsetPPC64HasPOWER9(SB), R7
+	CMP   R7, $1
+	BNE   power8
+	BR    indexbody<>(SB)
+
+#endif
+power8:
+	BR indexbody<>(SB)
 
 	// s: string we are searching
 	// sep: string to search for
@@ -420,3 +438,330 @@ found:
 	SUB  R3, R7    // Return byte where found
 	MOVD R7, (R14)
 	RET
+
+TEXT indexbodyp9<>(SB), NOSPLIT|NOFRAME, $0
+	CMP      R6, R4                // Compare lengths
+	BGT      notfound              // If sep len is > string, notfound
+	ADD      R4, R3, LASTBYTE      // find last byte addr
+	SUB      R6, LASTBYTE, LASTSTR // LAST=&s[len(s)-len(sep)] (last valid start index)
+	CMP      R6, $0                // Check sep len
+	BEQ      notfound              // sep len 0 -- not found
+	MOVD     R3, R7                // Copy of string addr
+	MOVD     $16, R16              // Index value 16
+	MOVD     $17, R17              // Index value 17
+	MOVD     $18, R18              // Index value 18
+	MOVD     $1, R19               // Index value 1
+	VSPLTISB $0xFF, ONES           // splat all 1s
+
+	CMP    R6, $16, CR4        // CR4 for len(sep) >= 16
+	VOR    ONES, ONES, SEPMASK // Set up full SEPMASK
+	BGE    CR4, loadge16       // Load for len(sep) >= 16
+	SUB    R6, R16, R9         // 16-len of sep
+	SLD    $3, R9              // Set up for VSLO
+	MTVSRD R9, V9_             // Set up for VSLO
+	VSLDOI $8, V9, V9, V9      // Set up for VSLO
+	VSLO   ONES, V9, SEPMASK   // Mask for separator len(sep) < 16
+
+loadge16:
+	ANDCC $15, R5, R9 // Find byte offset of sep
+	ADD   R9, R6, R10 // Add sep len
+	CMP   R10, $16    // Check if sep len+offset > 16
+	BGE   sepcross16  // Sep crosses 16 byte boundary
+
+	RLDICR  $0, R5, $59, R8 // Adjust addr to 16 byte container
+	LXVB16X (R8)(R0), V0_   // Load 16 bytes @R8 into V0
+	SLD     $3, R9          // Set up shift count for VSLO
+	MTVSRD  R9, V8_         // Set up shift count for VSLO
+	VSLDOI  $8, V8, V8, V8
+	VSLO    V0, V8, V0      // Shift by start byte
+
+	VAND V0, SEPMASK, V0 // Mask separator (< 16)
+	BR   index2plus
+
+sepcross16:
+	LXVB16X (R5)(R0), V0_ // Load 16 bytes @R5 into V0
+
+	VAND V0, SEPMASK, V0 // mask out separator
+	BLE  CR4, index2to16
+	BR   index17plus     // Handle sep > 16
+
+index2plus:
+	CMP      R6, $2       // Check length of sep
+	BNE      index3plus   // If not 2, check for 3
+	ADD      $16, R7, R9  // Check if next 16 bytes past last
+	CMP      R9, LASTBYTE // compare with last
+	BGE      index2to16   // 2 <= len(string) <= 16
+	MOVD     $0xff00, R21 // Mask for later
+	MTVSRD   R21, V25     // Move to Vreg
+	VSPLTH   $3, V25, V31 // Splat mask
+	VSPLTH   $0, V0, V1   // Splat 1st 2 bytes of sep
+	VSPLTISB $0, V10      // Clear V10
+
+	// First case: 2 byte separator
+	// V1: 2 byte separator splatted
+	// V2: 16 bytes at addr
+	// V4: 16 bytes at addr+1
+	// Compare 2 byte separator at start
+	// and at start+1. Use VSEL to combine
+	// those results to find the first
+	// matching start byte, returning
+	// that value when found. Loop as
+	// long as len(string) > 16
+index2loop2:
+	LXVB16X (R7)(R19), V3_ // Load 16 bytes @R7+1 into V3
+
+index2loop:
+	LXVB16X  (R7)(R0), V2_   // Load 16 bytes @R7 into V2
+	VCMPEQUH V1, V2, V5      // Search for sep
+	VCMPEQUH V1, V3, V6      // Search for sep offset by 1
+	VSEL     V6, V5, V31, V7 // merge even and odd indices
+	VCLZD    V7, V18         // find index of first match
+	MFVSRD   V18, R25        // get first value
+	CMP      R25, $64        // Found if < 64
+	BLT      foundR25        // Return byte index where found
+
+	MFVSRLD V18, R25        // get second value
+	CMP     R25, $64        // Found if < 64
+	ADD     $64, R25        // Update byte offset
+	BLT     foundR25        // Return value
+	ADD     $16, R7         // R7+=16 Update string pointer
+	ADD     $17, R7, R9     // R9=F7+17 since loop unrolled
+	CMP     R9, LASTBYTE    // Compare addr+17 against last byte
+	BLT     index2loop2     // If < last, continue loop
+	CMP     R7, LASTBYTE    // Compare addr+16 against last byte
+	BLT     index2to16      // If < 16 handle specially
+	LXVB16X (R7)(R0), V3_   // Load 16 bytes @R7 into V3
+	VSLDOI  $1, V3, V10, V3 // Shift left by 1 byte
+	BR      index2loop
+
+index3plus:
+	CMP    R6, $3       // Check if sep == 3
+	BNE    index4plus   // If not check larger
+	ADD    $19, R7, R9  // Find bytes for use in this loop
+	CMP    R9, LASTBYTE // Compare against last byte
+	BGE    index2to16   // Remaining string 2<=len<=16
+	MOVD   $0xff00, R21 // Set up mask for upcoming loop
+	MTVSRD R21, V25     // Move mask to Vreg
+	VSPLTH $3, V25, V31 // Splat mask
+	VSPLTH $0, V0, V1   // Splat 1st two bytes of sep
+	VSPLTB $2, V0, V8   // Splat 3rd byte of sep
+
+	// Loop to process 3 byte separator.
+	// string[0:16] is in V2
+	// string[2:18] is in V3
+	// sep[0:2] splatted in V1
+	// sec[3] splatted in v8
+	// Load vectors at string, string+1
+	// and string+2. Compare string, string+1
+	// against first 2 bytes of separator
+	// splatted, and string+2 against 3rd
+	// byte splatted. Merge the results with
+	// VSEL to find the first byte of a match.
+
+	// Special handling for last 16 bytes if the
+	// string fits in 16 byte multiple.
+index3loop2:
+	MOVD     $2, R21          // Set up index for 2
+	VSPLTISB $0, V10          // Clear V10
+	LXVB16X  (R7)(R21), V3_   // Load 16 bytes @R7+2 into V3
+	VSLDOI   $14, V3, V10, V3 // Left justify next 2 bytes
+
+index3loop:
+	LXVB16X  (R7)(R0), V2_   // Load 16 bytes @R7
+	VSLDOI   $1, V2, V3, V4  // string[1:17]
+	VSLDOI   $2, V2, V3, V9  // string[2:18]
+	VCMPEQUH V1, V2, V5      // compare hw even indices
+	VCMPEQUH V1, V4, V6      // compare hw odd indices
+	VCMPEQUB V8, V9, V10     // compare 3rd to last byte
+	VSEL     V6, V5, V31, V7 // Find 1st matching byte using mask
+	VAND     V7, V10, V7     // AND matched bytes with matched 3rd byte
+	VCLZD    V7, V18         // Find first nonzero indexes
+	MFVSRD   V18, R25        // Move 1st doubleword
+	CMP      R25, $64        // If < 64 found
+	BLT      foundR25        // Return matching index
+
+	MFVSRLD  V18, R25     // Move 2nd doubleword
+	CMP      R25, $64     // If < 64 found
+	ADD      $64, R25     // Update byte index
+	BLT      foundR25     // Return matching index
+	ADD      $16, R7      // R7+=16 string ptr
+	ADD      $19, R7, R9  // Number of string bytes for loop
+	CMP      R9, LASTBYTE // Compare against last byte of string
+	BLT      index3loop2  // If within, continue this loop
+	CMP      R7, LASTSTR  // Compare against last start byte
+	BLT      index2to16   // Process remainder
+	VSPLTISB $0, V3       // Special case for last 16 bytes
+	BR       index3loop   // Continue this loop
+
+	// Loop to process 4 byte separator
+	// string[0:16] in V2
+	// string[3:16] in V3
+	// sep[0:4] splatted in V1
+	// Set up vectors with strings at offsets
+	// 0, 1, 2, 3 and compare against the 4 byte
+	// separator also splatted. Use VSEL with the
+	// compare results to find the first byte where
+	// a separator match is found.
+index4plus:
+	CMP  R6, $4       // Check if 4 byte separator
+	BNE  index5plus   // If not next higher
+	ADD  $20, R7, R9  // Check string size to load
+	CMP  R9, LASTBYTE // Verify string length
+	BGE  index2to16   // If not large enough, process remaining
+	MOVD $2, R15      // Set up index
+
+	// Set up masks for use with VSEL
+	MOVD    $0xff, R21 // Set up mask 0xff000000ff000000...
+	SLD     $24, R21
+	MTVSRWS R21, V29
+
+	VSLDOI  $2, V29, V29, V30 // Mask 0x0000ff000000ff00...
+	MOVD    $0xffff, R21
+	SLD     $16, R21
+	MTVSRWS R21, V31
+
+	VSPLTW $0, V0, V1 // Splat 1st word of separator
+
+index4loop:
+	LXVB16X (R7)(R0), V2_ // Load 16 bytes @R7 into V2
+
+next4:
+	VSPLTISB $0, V10            // Clear
+	MOVD     $3, R9             // Number of bytes beyond 16
+	LXVB16X  (R7)(R9), V3_      // Load 16 bytes @R7 into V2
+	VSLDOI   $13, V3, V10, V3   // Shift left last 3 bytes
+	VSLDOI   $1, V2, V3, V4     // V4=(V2:V3)<<1
+	VSLDOI   $2, V2, V3, V9     // V9=(V2:V3)<<2
+	VSLDOI   $3, V2, V3, V10    // V10=(V2:v3)<<3
+	VCMPEQUW V1, V2, V5         // compare index 0, 4, ... with sep
+	VCMPEQUW V1, V4, V6         // compare index 1, 5, ... with sep
+	VCMPEQUW V1, V9, V11        // compare index 2, 6, ... with sep
+	VCMPEQUW V1, V10, V12       // compare index 3, 7, ... with sep
+	VSEL     V6, V5, V29, V13   // merge index 0, 1, 4, 5, using mask
+	VSEL     V12, V11, V30, V14 // merge index 2, 3, 6, 7, using mask
+	VSEL     V14, V13, V31, V7  // final merge
+	VCLZD    V7, V18            // Find first index for each half
+	MFVSRD   V18, R25           // Isolate value
+	CMP      R25, $64           // If < 64, found
+	BLT      foundR25           // Return found index
+
+	MFVSRLD V18, R25     // Isolate other value
+	CMP     R25, $64     // If < 64, found
+	ADD     $64, R25     // Update index for high doubleword
+	BLT     foundR25     // Return found index
+	ADD     $16, R7      // R7+=16 for next string
+	ADD     $20, R7, R9  // R+20 for all bytes to load
+	CMP     R9, LASTBYTE // Past end? Maybe check for extra?
+	BLT     index4loop   // If not, continue loop
+	CMP     R7, LASTSTR  // Check remainder
+	BLE     index2to16   // Process remainder
+	BR      notfound     // Not found
+
+index5plus:
+	CMP R6, $16     // Check for sep > 16
+	BGT index17plus // Handle large sep
+
+	// Assumption is that the separator is smaller than the string at this point
+index2to16:
+	CMP R7, LASTSTR // Compare last start byte
+	BGT notfound    // last takes len(sep) into account
+
+	ADD $16, R7, R9    // Check for last byte of string
+	CMP R9, LASTBYTE
+	BGT index2to16tail
+
+	// At least 16 bytes of string left
+	// Mask the number of bytes in sep
+index2to16loop:
+	LXVB16X (R7)(R0), V1_ // Load 16 bytes @R7 into V1
+
+compare:
+	VAND       V1, SEPMASK, V2 // Mask out sep size
+	VCMPEQUBCC V0, V2, V3      // Compare masked string
+	BLT        CR6, found      // All equal
+	ADD        $1, R7          // Update ptr to next byte
+	CMP        R7, LASTSTR     // Still less than last start byte
+	BGT        notfound        // Not found
+	ADD        $16, R7, R9     // Verify remaining bytes
+	CMP        R9, LASTBYTE    // At least 16
+	BLT        index2to16loop  // Try again
+
+	// Less than 16 bytes remaining in string
+	// Separator >= 2
+index2to16tail:
+	ADD     R3, R4, R9     // End of string
+	SUB     R7, R9, R9     // Number of bytes left
+	ANDCC   $15, R7, R10   // 16 byte offset
+	ADD     R10, R9, R11   // offset + len
+	CMP     R11, $16       // >= 16?
+	BLE     short          // Does not cross 16 bytes
+	LXVB16X (R7)(R0), V1_  // Load 16 bytes @R7 into V1
+	BR      index2to16next // Continue on
+
+short:
+	RLDICR   $0, R7, $59, R9 // Adjust addr to 16 byte container
+	LXVB16X  (R9)(R0), V1_   // Load 16 bytes @R9 into V1
+	SLD      $3, R10         // Set up shift
+	MTVSRD   R10, V8_        // Set up shift
+	VSLDOI   $8, V8, V8, V8
+	VSLO     V1, V8, V1      // Shift by start byte
+	VSPLTISB $0, V25         // Clear for later use
+
+index2to16next:
+	VAND       V1, SEPMASK, V2 // Just compare size of sep
+	VCMPEQUBCC V0, V2, V3      // Compare sep and partial string
+	BLT        CR6, found      // Found
+	ADD        $1, R7          // Not found, try next partial string
+	CMP        R7, LASTSTR     // Check for end of string
+	BGT        notfound        // If at end, then not found
+	VSLDOI     $1, V1, V25, V1 // Shift string left by 1 byte
+	BR         index2to16next  // Check the next partial string
+
+index17plus:
+	CMP      R6, $32       // Check if 17 < len(sep) <= 32
+	BGT      index33plus
+	SUB      $16, R6, R9   // Extra > 16
+	SLD      $56, R9, R10  // Shift to use in VSLO
+	MTVSRD   R10, V9_      // Set up for VSLO
+	LXVB16X  (R5)(R9), V1_ // Load 16 bytes @R5+R9 into V1
+	VSLO     V1, V9, V1    // Shift left
+	VSPLTISB $0xff, V7     // Splat 1s
+	VSPLTISB $0, V27       // Splat 0
+
+index17to32loop:
+	LXVB16X (R7)(R0), V2_ // Load 16 bytes @R7 into V2
+
+next17:
+	LXVB16X    (R7)(R9), V3_   // Load 16 bytes @R7+R9 into V3
+	VSLO       V3, V9, V3      // Shift left
+	VCMPEQUB   V0, V2, V4      // Compare first 16 bytes
+	VCMPEQUB   V1, V3, V5      // Compare extra over 16 bytes
+	VAND       V4, V5, V6      // Check if both equal
+	VCMPEQUBCC V6, V7, V8      // All equal?
+	BLT        CR6, found      // Yes
+	ADD        $1, R7          // On to next byte
+	CMP        R7, LASTSTR     // Check if last start byte
+	BGT        notfound        // If too high, not found
+	BR         index17to32loop // Continue
+
+notfound:
+	MOVD $-1, R8   // Return -1 if not found
+	MOVD R8, (R14)
+	RET
+
+index33plus:
+	MOVD $0, (R0) // Case not implemented
+	RET           // Crash before return
+
+foundR25:
+	SRD  $3, R25   // Convert from bits to bytes
+	ADD  R25, R7   // Add to current string address
+	SUB  R3, R7    // Subtract from start of string
+	MOVD R7, (R14) // Return byte where found
+	RET
+
+found:
+	SUB  R3, R7    // Return byte where found
+	MOVD R7, (R14)
+	RET
+
-- 
GitLab


From 7e97e4e8ccdba9677f31ab9380802cd7613f62c5 Mon Sep 17 00:00:00 2001
From: "Andrew G. Morgan" <agm@google.com>
Date: Fri, 26 Mar 2021 19:27:22 -0700
Subject: [PATCH 1697/2400] syscall: syscall.AllThreadsSyscall signal handling
 fixes

The runtime support for syscall.AllThreadsSyscall() functions had
some corner case deadlock issues when signal handling was in use.
This was observed in at least 3 build test failures on ppc64 and
amd64 architecture CGO_ENABLED=0 builds over the last few months.

The fixes involve more controlled handling of signals while the
AllThreads mechanism is being executed. Further details are
discussed in bug #44193.

The all-threads syscall support is new in go1.16, so earlier
releases are not affected by this bug.

Fixes #44193

Change-Id: I01ba8508a6e1bb2d872751f50da86dd07911a41d
Reviewed-on: https://go-review.googlesource.com/c/go/+/305149
Reviewed-by: Michael Pratt <mpratt@google.com>
Trust: Michael Pratt <mpratt@google.com>
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Michael Pratt <mpratt@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/os/signal/signal_test.go | 42 +++++++++++++++++++++++++++++
 src/runtime/proc.go          | 52 +++++++++++++++++++++++++++++++++---
 src/runtime/runtime2.go      |  7 +++--
 src/runtime/sigqueue.go      |  2 +-
 4 files changed, 96 insertions(+), 7 deletions(-)

diff --git a/src/os/signal/signal_test.go b/src/os/signal/signal_test.go
index 292d24c6f1..4c19281e91 100644
--- a/src/os/signal/signal_test.go
+++ b/src/os/signal/signal_test.go
@@ -16,6 +16,7 @@ import (
 	"os"
 	"os/exec"
 	"runtime"
+	"runtime/trace"
 	"strconv"
 	"sync"
 	"syscall"
@@ -854,3 +855,44 @@ func TestNotifyContextStringer(t *testing.T) {
 		t.Errorf("c.String() = %q, want %q", got, want)
 	}
 }
+
+// #44193 test signal handling while stopping and starting the world.
+func TestSignalTrace(t *testing.T) {
+	done := make(chan struct{})
+	quit := make(chan struct{})
+	c := make(chan os.Signal, 1)
+	Notify(c, syscall.SIGHUP)
+
+	// Source and sink for signals busy loop unsynchronized with
+	// trace starts and stops. We are ultimately validating that
+	// signals and runtime.(stop|start)TheWorldGC are compatible.
+	go func() {
+		defer close(done)
+		defer Stop(c)
+		pid := syscall.Getpid()
+		for {
+			select {
+			case <-quit:
+				return
+			default:
+				syscall.Kill(pid, syscall.SIGHUP)
+			}
+			waitSig(t, c, syscall.SIGHUP)
+		}
+	}()
+
+	for i := 0; i < 100; i++ {
+		buf := new(bytes.Buffer)
+		if err := trace.Start(buf); err != nil {
+			t.Fatalf("[%d] failed to start tracing: %v", i, err)
+		}
+		time.After(1 * time.Microsecond)
+		trace.Stop()
+		size := buf.Len()
+		if size == 0 {
+			t.Fatalf("[%d] trace is empty", i)
+		}
+	}
+	close(quit)
+	<-done
+}
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index b3f113f6ab..5c7328aacc 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -1402,6 +1402,9 @@ func mPark() {
 	g := getg()
 	for {
 		notesleep(&g.m.park)
+		// Note, because of signal handling by this parked m,
+		// a preemptive mDoFixup() may actually occur via
+		// mDoFixupAndOSYield(). (See golang.org/issue/44193)
 		noteclear(&g.m.park)
 		if !mDoFixup() {
 			return
@@ -1635,6 +1638,22 @@ func syscall_runtime_doAllThreadsSyscall(fn func(bool) bool) {
 	for atomic.Load(&sched.sysmonStarting) != 0 {
 		osyield()
 	}
+
+	// We don't want this thread to handle signals for the
+	// duration of this critical section. The underlying issue
+	// being that this locked coordinating m is the one monitoring
+	// for fn() execution by all the other m's of the runtime,
+	// while no regular go code execution is permitted (the world
+	// is stopped). If this present m were to get distracted to
+	// run signal handling code, and find itself waiting for a
+	// second thread to execute go code before being able to
+	// return from that signal handling, a deadlock will result.
+	// (See golang.org/issue/44193.)
+	lockOSThread()
+	var sigmask sigset
+	sigsave(&sigmask)
+	sigblock(false)
+
 	stopTheWorldGC("doAllThreadsSyscall")
 	if atomic.Load(&newmHandoff.haveTemplateThread) != 0 {
 		// Ensure that there are no in-flight thread
@@ -1686,6 +1705,7 @@ func syscall_runtime_doAllThreadsSyscall(fn func(bool) bool) {
 			// the possibility of racing with mp.
 			lock(&mp.mFixup.lock)
 			mp.mFixup.fn = fn
+			atomic.Store(&mp.mFixup.used, 1)
 			if mp.doesPark {
 				// For non-service threads this will
 				// cause the wakeup to be short lived
@@ -1702,9 +1722,7 @@ func syscall_runtime_doAllThreadsSyscall(fn func(bool) bool) {
 				if mp.procid == tid {
 					continue
 				}
-				lock(&mp.mFixup.lock)
-				done = done && (mp.mFixup.fn == nil)
-				unlock(&mp.mFixup.lock)
+				done = atomic.Load(&mp.mFixup.used) == 0
 			}
 			if done {
 				break
@@ -1731,6 +1749,8 @@ func syscall_runtime_doAllThreadsSyscall(fn func(bool) bool) {
 		unlock(&mFixupRace.lock)
 	}
 	startTheWorldGC()
+	msigrestore(sigmask)
+	unlockOSThread()
 }
 
 // runSafePointFn runs the safe point function, if any, for this P.
@@ -2225,9 +2245,21 @@ var mFixupRace struct {
 // mDoFixup runs any outstanding fixup function for the running m.
 // Returns true if a fixup was outstanding and actually executed.
 //
+// Note: to avoid deadlocks, and the need for the fixup function
+// itself to be async safe, signals are blocked for the working m
+// while it holds the mFixup lock. (See golang.org/issue/44193)
+//
 //go:nosplit
 func mDoFixup() bool {
 	_g_ := getg()
+	if used := atomic.Load(&_g_.m.mFixup.used); used == 0 {
+		return false
+	}
+
+	// slow path - if fixup fn is used, block signals and lock.
+	var sigmask sigset
+	sigsave(&sigmask)
+	sigblock(false)
 	lock(&_g_.m.mFixup.lock)
 	fn := _g_.m.mFixup.fn
 	if fn != nil {
@@ -2244,7 +2276,6 @@ func mDoFixup() bool {
 			// is more obviously safe.
 			throw("GC must be disabled to protect validity of fn value")
 		}
-		*(*uintptr)(unsafe.Pointer(&_g_.m.mFixup.fn)) = 0
 		if _g_.racectx != 0 || !raceenabled {
 			fn(false)
 		} else {
@@ -2259,11 +2290,24 @@ func mDoFixup() bool {
 			_g_.racectx = 0
 			unlock(&mFixupRace.lock)
 		}
+		*(*uintptr)(unsafe.Pointer(&_g_.m.mFixup.fn)) = 0
+		atomic.Store(&_g_.m.mFixup.used, 0)
 	}
 	unlock(&_g_.m.mFixup.lock)
+	msigrestore(sigmask)
 	return fn != nil
 }
 
+// mDoFixupAndOSYield is called when an m is unable to send a signal
+// because the allThreadsSyscall mechanism is in progress. That is, an
+// mPark() has been interrupted with this signal handler so we need to
+// ensure the fixup is executed from this context.
+//go:nosplit
+func mDoFixupAndOSYield() {
+	mDoFixup()
+	osyield()
+}
+
 // templateThread is a thread in a known-good state that exists solely
 // to start new threads in known-good states when the calling thread
 // may not be in a good state.
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index 387841e60b..f84cb51bad 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -554,10 +554,13 @@ type m struct {
 	syscalltick   uint32
 	freelink      *m // on sched.freem
 
-	// mFixup is used to synchronize OS related m state (credentials etc)
-	// use mutex to access.
+	// mFixup is used to synchronize OS related m state
+	// (credentials etc) use mutex to access. To avoid deadlocks
+	// an atomic.Load() of used being zero in mDoFixupFn()
+	// guarantees fn is nil.
 	mFixup struct {
 		lock mutex
+		used uint32
 		fn   func(bool) bool
 	}
 
diff --git a/src/runtime/sigqueue.go b/src/runtime/sigqueue.go
index aae1d00046..6c91fb3fb3 100644
--- a/src/runtime/sigqueue.go
+++ b/src/runtime/sigqueue.go
@@ -120,7 +120,7 @@ Send:
 			}
 		case sigFixup:
 			// nothing to do - we need to wait for sigIdle.
-			osyield()
+			mDoFixupAndOSYield()
 		}
 	}
 
-- 
GitLab


From 6639bb894d8770290f1860a4cad8f8726079b870 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Wed, 21 Apr 2021 20:45:44 +0000
Subject: [PATCH 1698/2400] runtime: call nanotimeQPC from nanotime1 normally

Currently we call runtimeQPC as ABIInternal because it shaves off 24
bytes by not having an extra wrapper, and at the time we were exceeding
the nosplit stack limit in some cases.

However, this code was written before we had the regabiargs GOEXPERIMENT
flag, and wasn't properly flagged. Naturally, with regabiargs enabled,
it leads to garbage being returned, because it needs to store
runtimeQPC's result to the stack.

We didn't notice this because today runtimeQPC is only used in Wine, not
on any native Windows platform.

Back when I wrote this code, it appeared to be necessary on even native
Windows, but it turns out that's not true anymore. Turn it back into a
native call through a wrapper.

For #40724.

Change-Id: Ia2e5901965ef46c5f299daccef49952026854fe6
Reviewed-on: https://go-review.googlesource.com/c/go/+/312429
Trust: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Michael Pratt <mpratt@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/sys_windows_amd64.s | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/src/runtime/sys_windows_amd64.s b/src/runtime/sys_windows_amd64.s
index a9a7dfdd49..72ced3cd1c 100644
--- a/src/runtime/sys_windows_amd64.s
+++ b/src/runtime/sys_windows_amd64.s
@@ -367,13 +367,7 @@ loop:
 	MOVQ	CX, ret+0(FP)
 	RET
 useQPC:
-	// Call with ABIInternal because we could be
-	// very deep in a nosplit context and the wrapper
-	// adds stack space.
-	// TODO(#40724): The result from nanotimeQPC will
-	// be passed in a register, so store that to the
-	// stack so we can return through a wrapper.
-	JMP	runtime·nanotimeQPC<ABIInternal>(SB)
+	JMP	runtime·nanotimeQPC(SB)
 	RET
 
 TEXT time·now(SB),NOSPLIT,$0-24
-- 
GitLab


From 7bedd477980175aecda5feb782e88041e86c2756 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 20 Apr 2021 22:59:59 -0400
Subject: [PATCH 1699/2400] go/types: combine all type inference in a single
 function

This is a port of CL 306170 to go/types, adjusted for the different
positioning API.

Some of the error positions in tests had to be adjusted, but I think the
new locations are better.

Change-Id: Ib157fbb47d7483e3c6302bd57f5070bd74602a36
Reviewed-on: https://go-review.googlesource.com/c/go/+/312191
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 .../internal/types2/fixedbugs/issue40056.go2  |   2 +-
 src/go/types/call.go                          |  85 +++------
 src/go/types/fixedbugs/issue39634.go2         |   2 +-
 src/go/types/fixedbugs/issue40056.go2         |   4 +-
 src/go/types/infer.go                         | 172 +++++++++++++++---
 src/go/types/testdata/typeparams.go2          |  10 +-
 6 files changed, 176 insertions(+), 99 deletions(-)

diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue40056.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue40056.go2
index 0c78c3f289..98ded7c49a 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue40056.go2
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue40056.go2
@@ -13,4 +13,4 @@ type S struct {}
 
 func NewS[T any]() *S
 
-func (_ *S /* ERROR S is not a generic type */ [T]) M()
\ No newline at end of file
+func (_ *S /* ERROR S is not a generic type */ [T]) M()
diff --git a/src/go/types/call.go b/src/go/types/call.go
index 8fd0f2dd2b..4834bd02c1 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -26,54 +26,39 @@ func (check *Checker) funcInst(x *operand, inst *ast.IndexExpr) {
 	}
 	assert(len(targs) == len(xlist))
 
-	// check number of type arguments
-	n := len(targs)
+	// check number of type arguments (got) vs number of type parameters (want)
 	sig := x.typ.(*Signature)
-	if n > len(sig.tparams) {
-		check.errorf(xlist[n-1], _Todo, "got %d type arguments but want %d", n, len(sig.tparams))
+	got, want := len(targs), len(sig.tparams)
+	if got > want {
+		check.errorf(xlist[got-1], _Todo, "got %d type arguments but want %d", got, want)
 		x.mode = invalid
 		x.expr = inst
 		return
 	}
 
-	// determine argument positions (for error reporting)
-	// TODO(rFindley) use a positioner here? instantiate would need to be
-	//                updated accordingly.
-	poslist := make([]token.Pos, n)
-	for i, x := range xlist {
-		poslist[i] = x.Pos()
-	}
+	// if we don't have enough type arguments, try type inference
+	inferred := false
 
-	// if we don't have enough type arguments, use constraint type inference
-	var inferred bool
-	if n < len(sig.tparams) {
-		var failed int
-		targs, failed = check.inferB(sig.tparams, targs)
+	if got < want {
+		targs = check.infer(inst, sig.tparams, targs, nil, nil, true)
 		if targs == nil {
 			// error was already reported
 			x.mode = invalid
 			x.expr = inst
 			return
 		}
-		if failed >= 0 {
-			// at least one type argument couldn't be inferred
-			assert(targs[failed] == nil)
-			tpar := sig.tparams[failed]
-			check.errorf(inNode(inst, inst.Rbrack), 0, "cannot infer %s (%v) (%s)", tpar.name, tpar.pos, targs)
-			x.mode = invalid
-			x.expr = inst
-			return
-		}
-		// all type arguments were inferred successfully
-		if debug {
-			for _, targ := range targs {
-				assert(targ != nil)
-			}
-		}
-		n = len(targs)
+		got = len(targs)
 		inferred = true
 	}
-	assert(n == len(sig.tparams))
+	assert(got == want)
+
+	// determine argument positions (for error reporting)
+	// TODO(rFindley) use a positioner here? instantiate would need to be
+	//                updated accordingly.
+	poslist := make([]token.Pos, len(xlist))
+	for i, x := range xlist {
+		poslist[i] = x.Pos()
+	}
 
 	// instantiate function signature
 	res := check.instantiate(x.Pos(), sig, targs, poslist).(*Signature)
@@ -307,32 +292,10 @@ func (check *Checker) arguments(call *ast.CallExpr, sig *Signature, args []*oper
 	if len(sig.tparams) > 0 {
 		// TODO(gri) provide position information for targs so we can feed
 		//           it to the instantiate call for better error reporting
-		targs, failed := check.infer(sig.tparams, sigParams, args)
+		targs := check.infer(call, sig.tparams, nil, sigParams, args, true)
 		if targs == nil {
 			return // error already reported
 		}
-		if failed >= 0 {
-			// Some type arguments couldn't be inferred. Use
-			// bounds type inference to try to make progress.
-			targs, failed = check.inferB(sig.tparams, targs)
-			if targs == nil {
-				return // error already reported
-			}
-			if failed >= 0 {
-				// at least one type argument couldn't be inferred
-				assert(targs[failed] == nil)
-				tpar := sig.tparams[failed]
-				ppos := check.fset.Position(tpar.pos).String()
-				check.errorf(inNode(call, call.Rparen), _Todo, "cannot infer %s (%s) (%s)", tpar.name, ppos, targs)
-				return
-			}
-		}
-		// all type arguments were inferred successfully
-		if debug {
-			for _, targ := range targs {
-				assert(targ != nil)
-			}
-		}
 
 		// compute result signature
 		rsig = check.instantiate(call.Pos(), sig, targs, nil).(*Signature)
@@ -544,13 +507,13 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr) {
 					recv = recv.(*Pointer).base
 				}
 			}
+			// Disable reporting of errors during inference below. If we're unable to infer
+			// the receiver type arguments here, the receiver must be be otherwise invalid
+			// and an error has been reported elsewhere.
 			arg := operand{mode: variable, expr: x.expr, typ: recv}
-			targs, failed := check.infer(sig.rparams, NewTuple(sig.recv), []*operand{&arg})
-			if failed >= 0 {
+			targs := check.infer(m, sig.rparams, nil, NewTuple(sig.recv), []*operand{&arg}, false /* no error reporting */)
+			if targs == nil {
 				// We may reach here if there were other errors (see issue #40056).
-				// check.infer will report a follow-up error.
-				// TODO(gri) avoid the follow-up error as it is confusing
-				//           (there's no inference in the source code)
 				goto Error
 			}
 			// Don't modify m. Instead - for now - make a copy of m and use that instead.
diff --git a/src/go/types/fixedbugs/issue39634.go2 b/src/go/types/fixedbugs/issue39634.go2
index f8585755c9..af1f1e44c5 100644
--- a/src/go/types/fixedbugs/issue39634.go2
+++ b/src/go/types/fixedbugs/issue39634.go2
@@ -89,4 +89,4 @@ func F26[Z any]() T26 { return F26[] /* ERROR operand */ }
 
 // crash 27
 func e27[T any]() interface{ x27 /* ERROR not a type */ }
-func x27() { e27() /* ERROR cannot infer T */ }
+func x27() { e27 /* ERROR cannot infer T */ () }
diff --git a/src/go/types/fixedbugs/issue40056.go2 b/src/go/types/fixedbugs/issue40056.go2
index 71074be67e..f587691e3d 100644
--- a/src/go/types/fixedbugs/issue40056.go2
+++ b/src/go/types/fixedbugs/issue40056.go2
@@ -5,11 +5,11 @@
 package p
 
 func _() {
-	NewS() /* ERROR cannot infer T */ .M()
+	NewS /* ERROR cannot infer T */ ().M()
 }
 
 type S struct {}
 
 func NewS[T any]() *S
 
-func (_ *S /* ERROR S is not a generic type */ [T]) M()
\ No newline at end of file
+func (_ *S /* ERROR S is not a generic type */ [T]) M()
diff --git a/src/go/types/infer.go b/src/go/types/infer.go
index 4b20836f88..9aae1bb248 100644
--- a/src/go/types/infer.go
+++ b/src/go/types/infer.go
@@ -12,22 +12,104 @@ import (
 	"strings"
 )
 
-// infer returns the list of actual type arguments for the given list of type parameters tparams
-// by inferring them from the actual arguments args for the parameters params. If type inference
-// is impossible because unification fails, an error is reported and the resulting types list is
-// nil, and index is 0. Otherwise, types is the list of inferred type arguments, and index is
-// the index of the first type argument in that list that couldn't be inferred (and thus is nil).
-// If all type arguments were inferred successfully, index is < 0.
-func (check *Checker) infer(tparams []*TypeName, params *Tuple, args []*operand) (types []Type, index int) {
+// infer attempts to infer the complete set of type arguments for generic function instantiation/call
+// based on the given type parameters tparams, type arguments targs, function parameters params, and
+// function arguments args, if any. There must be at least one type parameter, no more type arguments
+// than type parameters, and params and args must match in number (incl. zero).
+// If successful, infer returns the complete list of type arguments, one for each type parameter.
+// Otherwise the result is nil and appropriate errors will be reported unless report is set to false.
+//
+// Inference proceeds in 3 steps:
+//
+//   1) Start with given type arguments.
+//   2) Infer type arguments from typed function arguments.
+//   3) Infer type arguments from untyped function arguments.
+//
+// Constraint type inference is used after each step to expand the set of type arguments.
+//
+func (check *Checker) infer(posn positioner, tparams []*TypeName, targs []Type, params *Tuple, args []*operand, report bool) (result []Type) {
+	if debug {
+		defer func() {
+			assert(result == nil || len(result) == len(tparams))
+			for _, targ := range result {
+				assert(targ != nil)
+			}
+			//check.dump("### inferred targs = %s", result)
+		}()
+	}
+
+	// There must be at least one type parameter, and no more type arguments than type parameters.
+	n := len(tparams)
+	assert(n > 0 && len(targs) <= n)
+
+	// Function parameters and arguments must match in number.
 	assert(params.Len() == len(args))
 
+	// --- 0 ---
+	// If we already have all type arguments, we're done.
+	if len(targs) == n {
+		return targs
+	}
+	// len(targs) < n
+
+	// --- 1 ---
+	// Explicitly provided type arguments take precedence over any inferred types;
+	// and types inferred via constraint type inference take precedence over types
+	// inferred from function arguments.
+	// If we have type arguments, see how far we get with constraint type inference.
+	if len(targs) > 0 {
+		var index int
+		targs, index = check.inferB(tparams, targs, report)
+		if targs == nil || index < 0 {
+			return targs
+		}
+	}
+
+	// Continue with the type arguments we have now. Avoid matching generic
+	// parameters that already have type arguments against function arguments:
+	// It may fail because matching uses type identity while parameter passing
+	// uses assignment rules. Instantiate the parameter list with the type
+	// arguments we have, and continue with that parameter list.
+
+	// First, make sure we have a "full" list of type arguments, so of which
+	// may be nil (unknown).
+	if len(targs) < n {
+		targs2 := make([]Type, n)
+		copy(targs2, targs)
+		targs = targs2
+	}
+	// len(targs) == n
+
+	// Substitute type arguments for their respective type parameters in params,
+	// if any. Note that nil targs entries are ignored by check.subst.
+	// TODO(gri) Can we avoid this (we're setting known type argumemts below,
+	//           but that doesn't impact the isParameterized check for now).
+	if params.Len() > 0 {
+		smap := makeSubstMap(tparams, targs)
+		params = check.subst(token.NoPos, params, smap).(*Tuple)
+	}
+
+	// --- 2 ---
+	// Unify parameter and argument types for generic parameters with typed arguments
+	// and collect the indices of generic parameters with untyped arguments.
+	// Terminology: generic parameter = function parameter with a type-parameterized type
 	u := newUnifier(check, false)
 	u.x.init(tparams)
 
+	// Set the type arguments which we know already.
+	for i, targ := range targs {
+		if targ != nil {
+			u.x.set(i, targ)
+		}
+	}
+
 	errorf := func(kind string, tpar, targ Type, arg *operand) {
+		if !report {
+			return
+		}
 		// provide a better error message if we can
-		targs, failed := u.x.types()
-		if failed == 0 {
+		targs, index := u.x.types()
+		if index == 0 {
 			// The first type parameter couldn't be inferred.
 			// If none of them could be inferred, don't try
 			// to provide the inferred type in the error msg.
@@ -53,16 +135,13 @@ func (check *Checker) infer(tparams []*TypeName, params *Tuple, args []*operand)
 		}
 	}
 
-	// Terminology: generic parameter = function parameter with a type-parameterized type
-
-	// 1st pass: Unify parameter and argument types for generic parameters with typed arguments
-	//           and collect the indices of generic parameters with untyped arguments.
+	// indices of the generic parameters with untyped arguments - save for later
 	var indices []int
 	for i, arg := range args {
 		par := params.At(i)
 		// If we permit bidirectional unification, this conditional code needs to be
 		// executed even if par.typ is not parameterized since the argument may be a
-		// generic function (for which we want to infer // its type arguments).
+		// generic function (for which we want to infer its type arguments).
 		if isParameterized(tparams, par.typ) {
 			if arg.mode == invalid {
 				// An error was reported earlier. Ignore this targ
@@ -76,7 +155,7 @@ func (check *Checker) infer(tparams []*TypeName, params *Tuple, args []*operand)
 				// the respective type parameters of targ.
 				if !u.unify(par.typ, targ) {
 					errorf("type", par.typ, targ, arg)
-					return nil, 0
+					return nil
 				}
 			} else {
 				indices = append(indices, i)
@@ -84,12 +163,25 @@ func (check *Checker) infer(tparams []*TypeName, params *Tuple, args []*operand)
 		}
 	}
 
-	// Some generic parameters with untyped arguments may have been given a type
-	// indirectly through another generic parameter with a typed argument; we can
-	// ignore those now. (This only means that we know the types for those generic
-	// parameters; it doesn't mean untyped arguments can be passed safely. We still
-	// need to verify that assignment of those arguments is valid when we check
-	// function parameter passing external to infer.)
+	// If we've got all type arguments, we're done.
+	var index int
+	targs, index = u.x.types()
+	if index < 0 {
+		return targs
+	}
+
+	// See how far we get with constraint type inference.
+	// Note that even if we don't have any type arguments, constraint type inference
+	// may produce results for constraints that explicitly specify a type.
+	targs, index = check.inferB(tparams, targs, report)
+	if targs == nil || index < 0 {
+		return targs
+	}
+
+	// --- 3 ---
+	// Use any untyped arguments to infer additional type arguments.
+	// Some generic parameters with untyped arguments may have been given
+	// a type by now, we can ignore them.
 	j := 0
 	for _, i := range indices {
 		par := params.At(i)
@@ -98,14 +190,15 @@ func (check *Checker) infer(tparams []*TypeName, params *Tuple, args []*operand)
 		// only parameter type it can possibly match against is a *TypeParam.
 		// Thus, only keep the indices of generic parameters that are not of
 		// composite types and which don't have a type inferred yet.
-		if tpar, _ := par.typ.(*_TypeParam); tpar != nil && u.x.at(tpar.index) == nil {
+		if tpar, _ := par.typ.(*_TypeParam); tpar != nil && targs[tpar.index] == nil {
 			indices[j] = i
 			j++
 		}
 	}
 	indices = indices[:j]
 
-	// 2nd pass: Unify parameter and default argument types for remaining generic parameters.
+	// Unify parameter and default argument types for remaining generic parameters.
+	// TODO(gri) Rather than iterating again, combine this code with the loop above.
 	for _, i := range indices {
 		par := params.At(i)
 		arg := args[i]
@@ -115,11 +208,29 @@ func (check *Checker) infer(tparams []*TypeName, params *Tuple, args []*operand)
 		// nil by making sure all default argument types are typed.
 		if isTyped(targ) && !u.unify(par.typ, targ) {
 			errorf("default type", par.typ, targ, arg)
-			return nil, 0
+			return nil
 		}
 	}
 
-	return u.x.types()
+	// If we've got all type arguments, we're done.
+	targs, index = u.x.types()
+	if index < 0 {
+		return targs
+	}
+
+	// Again, follow up with constraint type inference.
+	targs, index = check.inferB(tparams, targs, report)
+	if targs == nil || index < 0 {
+		return targs
+	}
+
+	// At least one type argument couldn't be inferred.
+	assert(targs != nil && index >= 0 && targs[index] == nil)
+	tpar := tparams[index]
+	if report {
+		check.errorf(posn, _Todo, "cannot infer %s (%v) (%v)", tpar.name, tpar.pos, targs)
+	}
+	return nil
 }
 
 // typeNamesString produces a string containing all the
@@ -268,12 +379,13 @@ func (w *tpWalker) isParameterizedList(list []Type) bool {
 
 // inferB returns the list of actual type arguments inferred from the type parameters'
 // bounds and an initial set of type arguments. If type inference is impossible because
-// unification fails, an error is reported, the resulting types list is nil, and index is 0.
+// unification fails, an error is reported if report is set to true, the resulting types
+// list is nil, and index is 0.
 // Otherwise, types is the list of inferred type arguments, and index is the index of the
 // first type argument in that list that couldn't be inferred (and thus is nil). If all
-// type arguments where inferred successfully, index is < 0. The number of type arguments
+// type arguments were inferred successfully, index is < 0. The number of type arguments
 // provided may be less than the number of type parameters, but there must be at least one.
-func (check *Checker) inferB(tparams []*TypeName, targs []Type) (types []Type, index int) {
+func (check *Checker) inferB(tparams []*TypeName, targs []Type, report bool) (types []Type, index int) {
 	assert(len(tparams) >= len(targs) && len(targs) > 0)
 
 	// Setup bidirectional unification between those structural bounds
@@ -295,7 +407,9 @@ func (check *Checker) inferB(tparams []*TypeName, targs []Type) (types []Type, i
 		sbound := check.structuralType(typ.bound)
 		if sbound != nil {
 			if !u.unify(typ, sbound) {
-				check.errorf(tpar, 0, "%s does not match %s", tpar, sbound)
+				if report {
+					check.errorf(tpar, 0, "%s does not match %s", tpar, sbound)
+				}
 				return nil, 0
 			}
 		}
diff --git a/src/go/types/testdata/typeparams.go2 b/src/go/types/testdata/typeparams.go2
index 1577ad6f8d..d95e02e443 100644
--- a/src/go/types/testdata/typeparams.go2
+++ b/src/go/types/testdata/typeparams.go2
@@ -178,17 +178,17 @@ func _[T interface{ type string, chan<-int }](x T) {
 
 // type inference checks
 
-var _ = new() /* ERROR cannot infer T */
+var _ = new /* ERROR cannot infer T */ ()
 
 func f4[A, B, C any](A, B) C
 
-var _ = f4(1, 2) /* ERROR cannot infer C */
+var _ = f4 /* ERROR cannot infer C */ (1, 2)
 var _ = f4[int, float32, complex128](1, 2)
 
 func f5[A, B, C any](A, []*B, struct{f []C}) int
 
 var _ = f5[int, float32, complex128](0, nil, struct{f []complex128}{})
-var _ = f5(0, nil, struct{f []complex128}{}) // ERROR cannot infer
+var _ = f5 /* ERROR cannot infer */ (0, nil, struct{f []complex128}{})
 var _ = f5(0, []*float32{new[float32]()}, struct{f []complex128}{})
 
 func f6[A any](A, []A) int
@@ -197,13 +197,13 @@ var _ = f6(0, nil)
 
 func f6nil[A any](A) int
 
-var _ = f6nil(nil) // ERROR cannot infer
+var _ = f6nil /* ERROR cannot infer */ (nil)
 
 // type inference with variadic functions
 
 func f7[T any](...T) T
 
-var _ int = f7() /* ERROR cannot infer T */
+var _ int = f7 /* ERROR cannot infer T */ ()
 var _ int = f7(1)
 var _ int = f7(1, 2)
 var _ int = f7([]int{}...)
-- 
GitLab


From 02a8e836616cb8eb6d776514c6239095b1328fd2 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Wed, 21 Apr 2021 16:44:59 -0700
Subject: [PATCH 1700/2400] runtime: don't run TestCrashDumpsAllThreads in
 parallel

It sometimes seems to time out on slow systems, perhaps due to
being run at the same time as a lot of other work.

Also move the code to testdata/testprog, so that we don't have to
build it separately.

I hope that this
Fixes #35356

Change-Id: I875b858fa23836513ae14d3116461e22fffd5352
Reviewed-on: https://go-review.googlesource.com/c/go/+/312510
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/crash_unix_test.go             | 69 +++-------------------
 src/runtime/testdata/testprog/crashdump.go | 47 +++++++++++++++
 2 files changed, 55 insertions(+), 61 deletions(-)
 create mode 100644 src/runtime/testdata/testprog/crashdump.go

diff --git a/src/runtime/crash_unix_test.go b/src/runtime/crash_unix_test.go
index b5cc910ad1..9469d5e6a6 100644
--- a/src/runtime/crash_unix_test.go
+++ b/src/runtime/crash_unix_test.go
@@ -13,7 +13,6 @@ import (
 	"io"
 	"os"
 	"os/exec"
-	"path/filepath"
 	"runtime"
 	"strings"
 	"sync"
@@ -78,27 +77,14 @@ func TestCrashDumpsAllThreads(t *testing.T) {
 		t.Skip("skipping; SIGQUIT is blocked, see golang.org/issue/19196")
 	}
 
-	// We don't use executeTest because we need to kill the
-	// program while it is running.
-
 	testenv.MustHaveGoBuild(t)
 
-	t.Parallel()
-
-	dir := t.TempDir()
-
-	if err := os.WriteFile(filepath.Join(dir, "main.go"), []byte(crashDumpsAllThreadsSource), 0666); err != nil {
-		t.Fatalf("failed to create Go file: %v", err)
-	}
-
-	cmd := exec.Command(testenv.GoToolPath(t), "build", "-o", "a.exe", "main.go")
-	cmd.Dir = dir
-	out, err := testenv.CleanCmdEnv(cmd).CombinedOutput()
+	exe, err := buildTestProg(t, "testprog")
 	if err != nil {
-		t.Fatalf("building source: %v\n%s", err, out)
+		t.Fatal(err)
 	}
 
-	cmd = exec.Command(filepath.Join(dir, "a.exe"))
+	cmd := exec.Command(exe, "CrashDumpsAllThreads")
 	cmd = testenv.CleanCmdEnv(cmd)
 	cmd.Env = append(cmd.Env,
 		"GOTRACEBACK=crash",
@@ -120,9 +106,12 @@ func TestCrashDumpsAllThreads(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+	defer rp.Close()
+
 	cmd.ExtraFiles = []*os.File{wp}
 
 	if err := cmd.Start(); err != nil {
+		wp.Close()
 		t.Fatalf("starting program: %v", err)
 	}
 
@@ -144,56 +133,14 @@ func TestCrashDumpsAllThreads(t *testing.T) {
 	// We want to see a stack trace for each thread.
 	// Before https://golang.org/cl/2811 running threads would say
 	// "goroutine running on other thread; stack unavailable".
-	out = outbuf.Bytes()
-	n := bytes.Count(out, []byte("main.loop("))
+	out := outbuf.Bytes()
+	n := bytes.Count(out, []byte("main.crashDumpsAllThreadsLoop("))
 	if n != 4 {
 		t.Errorf("found %d instances of main.loop; expected 4", n)
 		t.Logf("%s", out)
 	}
 }
 
-const crashDumpsAllThreadsSource = `
-package main
-
-import (
-	"fmt"
-	"os"
-	"runtime"
-)
-
-func main() {
-	const count = 4
-	runtime.GOMAXPROCS(count + 1)
-
-	chans := make([]chan bool, count)
-	for i := range chans {
-		chans[i] = make(chan bool)
-		go loop(i, chans[i])
-	}
-
-	// Wait for all the goroutines to start executing.
-	for _, c := range chans {
-		<-c
-	}
-
-	// Tell our parent that all the goroutines are executing.
-	if _, err := os.NewFile(3, "pipe").WriteString("x"); err != nil {
-		fmt.Fprintf(os.Stderr, "write to pipe failed: %v\n", err)
-		os.Exit(2)
-	}
-
-	select {}
-}
-
-func loop(i int, c chan bool) {
-	close(c)
-	for {
-		for j := 0; j < 0x7fffffff; j++ {
-		}
-	}
-}
-`
-
 func TestPanicSystemstack(t *testing.T) {
 	// Test that GOTRACEBACK=crash prints both the system and user
 	// stack of other threads.
diff --git a/src/runtime/testdata/testprog/crashdump.go b/src/runtime/testdata/testprog/crashdump.go
new file mode 100644
index 0000000000..bced397b8a
--- /dev/null
+++ b/src/runtime/testdata/testprog/crashdump.go
@@ -0,0 +1,47 @@
+// Copyright 2021 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 (
+	"fmt"
+	"os"
+	"runtime"
+)
+
+func init() {
+	register("CrashDumpsAllThreads", CrashDumpsAllThreads)
+}
+
+func CrashDumpsAllThreads() {
+	const count = 4
+	runtime.GOMAXPROCS(count + 1)
+
+	chans := make([]chan bool, count)
+	for i := range chans {
+		chans[i] = make(chan bool)
+		go crashDumpsAllThreadsLoop(i, chans[i])
+	}
+
+	// Wait for all the goroutines to start executing.
+	for _, c := range chans {
+		<-c
+	}
+
+	// Tell our parent that all the goroutines are executing.
+	if _, err := os.NewFile(3, "pipe").WriteString("x"); err != nil {
+		fmt.Fprintf(os.Stderr, "write to pipe failed: %v\n", err)
+		os.Exit(2)
+	}
+
+	select {}
+}
+
+func crashDumpsAllThreadsLoop(i int, c chan bool) {
+	close(c)
+	for {
+		for j := 0; j < 0x7fffffff; j++ {
+		}
+	}
+}
-- 
GitLab


From 0636d88f6d79827e0acdc8e53b8f249652061d2d Mon Sep 17 00:00:00 2001
From: fanzha02 <fannie.zhang@arm.com>
Date: Mon, 19 Apr 2021 10:40:20 +0800
Subject: [PATCH 1701/2400] cmd/compile: add restrictions on the shift amount
 range of arm64 various instructions

For arm64 constant shift instructions, e.g., LSL(immediate), they use
only the low 6 bits. To conform the semantics of the hardware instructions,
this CL comments in ARM64OPS.go about restricted AuxInt ranges for the
various instructions involved.

Change-Id: I2b6560d6580e22ba7cbfa744a02b046dd5714b8a
Reviewed-on: https://go-review.googlesource.com/c/go/+/303569
Trust: fannie zhang <Fannie.Zhang@arm.com>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/ssa/gen/ARM64Ops.go | 93 ++++++++++----------
 1 file changed, 47 insertions(+), 46 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/gen/ARM64Ops.go b/src/cmd/compile/internal/ssa/gen/ARM64Ops.go
index 65e54202bf..18a5666b40 100644
--- a/src/cmd/compile/internal/ssa/gen/ARM64Ops.go
+++ b/src/cmd/compile/internal/ssa/gen/ARM64Ops.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 package main
@@ -266,17 +267,17 @@ func init() {
 
 		// shifts
 		{name: "SLL", argLength: 2, reg: gp21, asm: "LSL"},                        // arg0 << arg1, shift amount is mod 64
-		{name: "SLLconst", argLength: 1, reg: gp11, asm: "LSL", aux: "Int64"},     // arg0 << auxInt
+		{name: "SLLconst", argLength: 1, reg: gp11, asm: "LSL", aux: "Int64"},     // arg0 << auxInt, auxInt should be in the range 0 to 63.
 		{name: "SRL", argLength: 2, reg: gp21, asm: "LSR"},                        // arg0 >> arg1, unsigned, shift amount is mod 64
-		{name: "SRLconst", argLength: 1, reg: gp11, asm: "LSR", aux: "Int64"},     // arg0 >> auxInt, unsigned
+		{name: "SRLconst", argLength: 1, reg: gp11, asm: "LSR", aux: "Int64"},     // arg0 >> auxInt, unsigned, auxInt should be in the range 0 to 63.
 		{name: "SRA", argLength: 2, reg: gp21, asm: "ASR"},                        // arg0 >> arg1, signed, shift amount is mod 64
-		{name: "SRAconst", argLength: 1, reg: gp11, asm: "ASR", aux: "Int64"},     // arg0 >> auxInt, signed
+		{name: "SRAconst", argLength: 1, reg: gp11, asm: "ASR", aux: "Int64"},     // arg0 >> auxInt, signed, auxInt should be in the range 0 to 63.
 		{name: "ROR", argLength: 2, reg: gp21, asm: "ROR"},                        // arg0 right rotate by (arg1 mod 64) bits
 		{name: "RORW", argLength: 2, reg: gp21, asm: "RORW"},                      // arg0 right rotate by (arg1 mod 32) bits
-		{name: "RORconst", argLength: 1, reg: gp11, asm: "ROR", aux: "Int64"},     // arg0 right rotate by auxInt bits
-		{name: "RORWconst", argLength: 1, reg: gp11, asm: "RORW", aux: "Int64"},   // uint32(arg0) right rotate by auxInt bits
-		{name: "EXTRconst", argLength: 2, reg: gp21, asm: "EXTR", aux: "Int64"},   // extract 64 bits from arg0:arg1 starting at lsb auxInt
-		{name: "EXTRWconst", argLength: 2, reg: gp21, asm: "EXTRW", aux: "Int64"}, // extract 32 bits from arg0[31:0]:arg1[31:0] starting at lsb auxInt and zero top 32 bits
+		{name: "RORconst", argLength: 1, reg: gp11, asm: "ROR", aux: "Int64"},     // arg0 right rotate by auxInt bits, auxInt should be in the range 0 to 63.
+		{name: "RORWconst", argLength: 1, reg: gp11, asm: "RORW", aux: "Int64"},   // uint32(arg0) right rotate by auxInt bits, auxInt should be in the range 0 to 31.
+		{name: "EXTRconst", argLength: 2, reg: gp21, asm: "EXTR", aux: "Int64"},   // extract 64 bits from arg0:arg1 starting at lsb auxInt, auxInt should be in the range 0 to 63.
+		{name: "EXTRWconst", argLength: 2, reg: gp21, asm: "EXTRW", aux: "Int64"}, // extract 32 bits from arg0[31:0]:arg1[31:0] starting at lsb auxInt and zero top 32 bits, auxInt should be in the range 0 to 31.
 
 		// comparisons
 		{name: "CMP", argLength: 2, reg: gp2flags, asm: "CMP", typ: "Flags"},                      // arg0 compare to arg1
@@ -297,45 +298,45 @@ func init() {
 		{name: "FCMPD0", argLength: 1, reg: fp1flags, asm: "FCMPD", typ: "Flags"},                 // arg0 compare to 0, float64
 
 		// shifted ops
-		{name: "MVNshiftLL", argLength: 1, reg: gp11, asm: "MVN", aux: "Int64"},                   // ^(arg0<<auxInt)
-		{name: "MVNshiftRL", argLength: 1, reg: gp11, asm: "MVN", aux: "Int64"},                   // ^(arg0>>auxInt), unsigned shift
-		{name: "MVNshiftRA", argLength: 1, reg: gp11, asm: "MVN", aux: "Int64"},                   // ^(arg0>>auxInt), signed shift
-		{name: "NEGshiftLL", argLength: 1, reg: gp11, asm: "NEG", aux: "Int64"},                   // -(arg0<<auxInt)
-		{name: "NEGshiftRL", argLength: 1, reg: gp11, asm: "NEG", aux: "Int64"},                   // -(arg0>>auxInt), unsigned shift
-		{name: "NEGshiftRA", argLength: 1, reg: gp11, asm: "NEG", aux: "Int64"},                   // -(arg0>>auxInt), signed shift
-		{name: "ADDshiftLL", argLength: 2, reg: gp21, asm: "ADD", aux: "Int64"},                   // arg0 + arg1<<auxInt
-		{name: "ADDshiftRL", argLength: 2, reg: gp21, asm: "ADD", aux: "Int64"},                   // arg0 + arg1>>auxInt, unsigned shift
-		{name: "ADDshiftRA", argLength: 2, reg: gp21, asm: "ADD", aux: "Int64"},                   // arg0 + arg1>>auxInt, signed shift
-		{name: "SUBshiftLL", argLength: 2, reg: gp21, asm: "SUB", aux: "Int64"},                   // arg0 - arg1<<auxInt
-		{name: "SUBshiftRL", argLength: 2, reg: gp21, asm: "SUB", aux: "Int64"},                   // arg0 - arg1>>auxInt, unsigned shift
-		{name: "SUBshiftRA", argLength: 2, reg: gp21, asm: "SUB", aux: "Int64"},                   // arg0 - arg1>>auxInt, signed shift
-		{name: "ANDshiftLL", argLength: 2, reg: gp21, asm: "AND", aux: "Int64"},                   // arg0 & (arg1<<auxInt)
-		{name: "ANDshiftRL", argLength: 2, reg: gp21, asm: "AND", aux: "Int64"},                   // arg0 & (arg1>>auxInt), unsigned shift
-		{name: "ANDshiftRA", argLength: 2, reg: gp21, asm: "AND", aux: "Int64"},                   // arg0 & (arg1>>auxInt), signed shift
-		{name: "ORshiftLL", argLength: 2, reg: gp21, asm: "ORR", aux: "Int64"},                    // arg0 | arg1<<auxInt
-		{name: "ORshiftRL", argLength: 2, reg: gp21, asm: "ORR", aux: "Int64"},                    // arg0 | arg1>>auxInt, unsigned shift
-		{name: "ORshiftRA", argLength: 2, reg: gp21, asm: "ORR", aux: "Int64"},                    // arg0 | arg1>>auxInt, signed shift
-		{name: "XORshiftLL", argLength: 2, reg: gp21, asm: "EOR", aux: "Int64"},                   // arg0 ^ arg1<<auxInt
-		{name: "XORshiftRL", argLength: 2, reg: gp21, asm: "EOR", aux: "Int64"},                   // arg0 ^ arg1>>auxInt, unsigned shift
-		{name: "XORshiftRA", argLength: 2, reg: gp21, asm: "EOR", aux: "Int64"},                   // arg0 ^ arg1>>auxInt, signed shift
-		{name: "BICshiftLL", argLength: 2, reg: gp21, asm: "BIC", aux: "Int64"},                   // arg0 &^ (arg1<<auxInt)
-		{name: "BICshiftRL", argLength: 2, reg: gp21, asm: "BIC", aux: "Int64"},                   // arg0 &^ (arg1>>auxInt), unsigned shift
-		{name: "BICshiftRA", argLength: 2, reg: gp21, asm: "BIC", aux: "Int64"},                   // arg0 &^ (arg1>>auxInt), signed shift
-		{name: "EONshiftLL", argLength: 2, reg: gp21, asm: "EON", aux: "Int64"},                   // arg0 ^ ^(arg1<<auxInt)
-		{name: "EONshiftRL", argLength: 2, reg: gp21, asm: "EON", aux: "Int64"},                   // arg0 ^ ^(arg1>>auxInt), unsigned shift
-		{name: "EONshiftRA", argLength: 2, reg: gp21, asm: "EON", aux: "Int64"},                   // arg0 ^ ^(arg1>>auxInt), signed shift
-		{name: "ORNshiftLL", argLength: 2, reg: gp21, asm: "ORN", aux: "Int64"},                   // arg0 | ^(arg1<<auxInt)
-		{name: "ORNshiftRL", argLength: 2, reg: gp21, asm: "ORN", aux: "Int64"},                   // arg0 | ^(arg1>>auxInt), unsigned shift
-		{name: "ORNshiftRA", argLength: 2, reg: gp21, asm: "ORN", aux: "Int64"},                   // arg0 | ^(arg1>>auxInt), signed shift
-		{name: "CMPshiftLL", argLength: 2, reg: gp2flags, asm: "CMP", aux: "Int64", typ: "Flags"}, // arg0 compare to arg1<<auxInt
-		{name: "CMPshiftRL", argLength: 2, reg: gp2flags, asm: "CMP", aux: "Int64", typ: "Flags"}, // arg0 compare to arg1>>auxInt, unsigned shift
-		{name: "CMPshiftRA", argLength: 2, reg: gp2flags, asm: "CMP", aux: "Int64", typ: "Flags"}, // arg0 compare to arg1>>auxInt, signed shift
-		{name: "CMNshiftLL", argLength: 2, reg: gp2flags, asm: "CMN", aux: "Int64", typ: "Flags"}, // (arg0 + arg1<<auxInt) compare to 0
-		{name: "CMNshiftRL", argLength: 2, reg: gp2flags, asm: "CMN", aux: "Int64", typ: "Flags"}, // (arg0 + arg1>>auxInt) compare to 0, unsigned shift
-		{name: "CMNshiftRA", argLength: 2, reg: gp2flags, asm: "CMN", aux: "Int64", typ: "Flags"}, // (arg0 + arg1>>auxInt) compare to 0, signed shift
-		{name: "TSTshiftLL", argLength: 2, reg: gp2flags, asm: "TST", aux: "Int64", typ: "Flags"}, // (arg0 & arg1<<auxInt) compare to 0
-		{name: "TSTshiftRL", argLength: 2, reg: gp2flags, asm: "TST", aux: "Int64", typ: "Flags"}, // (arg0 & arg1>>auxInt) compare to 0, unsigned shift
-		{name: "TSTshiftRA", argLength: 2, reg: gp2flags, asm: "TST", aux: "Int64", typ: "Flags"}, // (arg0 & arg1>>auxInt) compare to 0, signed shift
+		{name: "MVNshiftLL", argLength: 1, reg: gp11, asm: "MVN", aux: "Int64"},                   // ^(arg0<<auxInt), auxInt should be in the range 0 to 63.
+		{name: "MVNshiftRL", argLength: 1, reg: gp11, asm: "MVN", aux: "Int64"},                   // ^(arg0>>auxInt), unsigned shift, auxInt should be in the range 0 to 63.
+		{name: "MVNshiftRA", argLength: 1, reg: gp11, asm: "MVN", aux: "Int64"},                   // ^(arg0>>auxInt), signed shift, auxInt should be in the range 0 to 63.
+		{name: "NEGshiftLL", argLength: 1, reg: gp11, asm: "NEG", aux: "Int64"},                   // -(arg0<<auxInt), auxInt should be in the range 0 to 63.
+		{name: "NEGshiftRL", argLength: 1, reg: gp11, asm: "NEG", aux: "Int64"},                   // -(arg0>>auxInt), unsigned shift, auxInt should be in the range 0 to 63.
+		{name: "NEGshiftRA", argLength: 1, reg: gp11, asm: "NEG", aux: "Int64"},                   // -(arg0>>auxInt), signed shift, auxInt should be in the range 0 to 63.
+		{name: "ADDshiftLL", argLength: 2, reg: gp21, asm: "ADD", aux: "Int64"},                   // arg0 + arg1<<auxInt, auxInt should be in the range 0 to 63.
+		{name: "ADDshiftRL", argLength: 2, reg: gp21, asm: "ADD", aux: "Int64"},                   // arg0 + arg1>>auxInt, unsigned shift, auxInt should be in the range 0 to 63.
+		{name: "ADDshiftRA", argLength: 2, reg: gp21, asm: "ADD", aux: "Int64"},                   // arg0 + arg1>>auxInt, signed shift, auxInt should be in the range 0 to 63.
+		{name: "SUBshiftLL", argLength: 2, reg: gp21, asm: "SUB", aux: "Int64"},                   // arg0 - arg1<<auxInt, auxInt should be in the range 0 to 63.
+		{name: "SUBshiftRL", argLength: 2, reg: gp21, asm: "SUB", aux: "Int64"},                   // arg0 - arg1>>auxInt, unsigned shift, auxInt should be in the range 0 to 63.
+		{name: "SUBshiftRA", argLength: 2, reg: gp21, asm: "SUB", aux: "Int64"},                   // arg0 - arg1>>auxInt, signed shift, auxInt should be in the range 0 to 63.
+		{name: "ANDshiftLL", argLength: 2, reg: gp21, asm: "AND", aux: "Int64"},                   // arg0 & (arg1<<auxInt), auxInt should be in the range 0 to 63.
+		{name: "ANDshiftRL", argLength: 2, reg: gp21, asm: "AND", aux: "Int64"},                   // arg0 & (arg1>>auxInt), unsigned shift, auxInt should be in the range 0 to 63.
+		{name: "ANDshiftRA", argLength: 2, reg: gp21, asm: "AND", aux: "Int64"},                   // arg0 & (arg1>>auxInt), signed shift, auxInt should be in the range 0 to 63.
+		{name: "ORshiftLL", argLength: 2, reg: gp21, asm: "ORR", aux: "Int64"},                    // arg0 | arg1<<auxInt, auxInt should be in the range 0 to 63.
+		{name: "ORshiftRL", argLength: 2, reg: gp21, asm: "ORR", aux: "Int64"},                    // arg0 | arg1>>auxInt, unsigned shift, auxInt should be in the range 0 to 63.
+		{name: "ORshiftRA", argLength: 2, reg: gp21, asm: "ORR", aux: "Int64"},                    // arg0 | arg1>>auxInt, signed shift, auxInt should be in the range 0 to 63.
+		{name: "XORshiftLL", argLength: 2, reg: gp21, asm: "EOR", aux: "Int64"},                   // arg0 ^ arg1<<auxInt, auxInt should be in the range 0 to 63.
+		{name: "XORshiftRL", argLength: 2, reg: gp21, asm: "EOR", aux: "Int64"},                   // arg0 ^ arg1>>auxInt, unsigned shift, auxInt should be in the range 0 to 63.
+		{name: "XORshiftRA", argLength: 2, reg: gp21, asm: "EOR", aux: "Int64"},                   // arg0 ^ arg1>>auxInt, signed shift, auxInt should be in the range 0 to 63.
+		{name: "BICshiftLL", argLength: 2, reg: gp21, asm: "BIC", aux: "Int64"},                   // arg0 &^ (arg1<<auxInt), auxInt should be in the range 0 to 63.
+		{name: "BICshiftRL", argLength: 2, reg: gp21, asm: "BIC", aux: "Int64"},                   // arg0 &^ (arg1>>auxInt), unsigned shift, auxInt should be in the range 0 to 63.
+		{name: "BICshiftRA", argLength: 2, reg: gp21, asm: "BIC", aux: "Int64"},                   // arg0 &^ (arg1>>auxInt), signed shift, auxInt should be in the range 0 to 63.
+		{name: "EONshiftLL", argLength: 2, reg: gp21, asm: "EON", aux: "Int64"},                   // arg0 ^ ^(arg1<<auxInt), auxInt should be in the range 0 to 63.
+		{name: "EONshiftRL", argLength: 2, reg: gp21, asm: "EON", aux: "Int64"},                   // arg0 ^ ^(arg1>>auxInt), unsigned shift, auxInt should be in the range 0 to 63.
+		{name: "EONshiftRA", argLength: 2, reg: gp21, asm: "EON", aux: "Int64"},                   // arg0 ^ ^(arg1>>auxInt), signed shift, auxInt should be in the range 0 to 63.
+		{name: "ORNshiftLL", argLength: 2, reg: gp21, asm: "ORN", aux: "Int64"},                   // arg0 | ^(arg1<<auxInt), auxInt should be in the range 0 to 63.
+		{name: "ORNshiftRL", argLength: 2, reg: gp21, asm: "ORN", aux: "Int64"},                   // arg0 | ^(arg1>>auxInt), unsigned shift, auxInt should be in the range 0 to 63.
+		{name: "ORNshiftRA", argLength: 2, reg: gp21, asm: "ORN", aux: "Int64"},                   // arg0 | ^(arg1>>auxInt), signed shift, auxInt should be in the range 0 to 63.
+		{name: "CMPshiftLL", argLength: 2, reg: gp2flags, asm: "CMP", aux: "Int64", typ: "Flags"}, // arg0 compare to arg1<<auxInt, auxInt should be in the range 0 to 63.
+		{name: "CMPshiftRL", argLength: 2, reg: gp2flags, asm: "CMP", aux: "Int64", typ: "Flags"}, // arg0 compare to arg1>>auxInt, unsigned shift, auxInt should be in the range 0 to 63.
+		{name: "CMPshiftRA", argLength: 2, reg: gp2flags, asm: "CMP", aux: "Int64", typ: "Flags"}, // arg0 compare to arg1>>auxInt, signed shift, auxInt should be in the range 0 to 63.
+		{name: "CMNshiftLL", argLength: 2, reg: gp2flags, asm: "CMN", aux: "Int64", typ: "Flags"}, // (arg0 + arg1<<auxInt) compare to 0, auxInt should be in the range 0 to 63.
+		{name: "CMNshiftRL", argLength: 2, reg: gp2flags, asm: "CMN", aux: "Int64", typ: "Flags"}, // (arg0 + arg1>>auxInt) compare to 0, unsigned shift, auxInt should be in the range 0 to 63.
+		{name: "CMNshiftRA", argLength: 2, reg: gp2flags, asm: "CMN", aux: "Int64", typ: "Flags"}, // (arg0 + arg1>>auxInt) compare to 0, signed shift, auxInt should be in the range 0 to 63.
+		{name: "TSTshiftLL", argLength: 2, reg: gp2flags, asm: "TST", aux: "Int64", typ: "Flags"}, // (arg0 & arg1<<auxInt) compare to 0, auxInt should be in the range 0 to 63.
+		{name: "TSTshiftRL", argLength: 2, reg: gp2flags, asm: "TST", aux: "Int64", typ: "Flags"}, // (arg0 & arg1>>auxInt) compare to 0, unsigned shift, auxInt should be in the range 0 to 63.
+		{name: "TSTshiftRA", argLength: 2, reg: gp2flags, asm: "TST", aux: "Int64", typ: "Flags"}, // (arg0 & arg1>>auxInt) compare to 0, signed shift, auxInt should be in the range 0 to 63.
 
 		// bitfield ops
 		// for all bitfield ops lsb is auxInt>>8, width is auxInt&0xff
-- 
GitLab


From 5daefc5363080acd631ae97a84faf651a70d9888 Mon Sep 17 00:00:00 2001
From: eric fang <eric.fang@arm.com>
Date: Thu, 15 Apr 2021 03:27:55 +0000
Subject: [PATCH 1702/2400] cmd/internal/obj/arm64: fix the wrong ROR operator
 of some instructions

Instructions such as ADD, SUB, CMP do not support ROR shift operations,
but we have not checked this at present. This CL adds this check.

Change-Id: Icac461f61ad6ddb60886a59ba34dddd29df1cc0f
Reviewed-on: https://go-review.googlesource.com/c/go/+/310035
Reviewed-by: eric fang <eric.fang@arm.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: eric fang <eric.fang@arm.com>
Run-TryBot: eric fang <eric.fang@arm.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 .../asm/internal/asm/testdata/arm64error.s    | 18 ++++
 src/cmd/internal/obj/arm64/asm7.go            | 93 ++++++++++---------
 2 files changed, 67 insertions(+), 44 deletions(-)

diff --git a/src/cmd/asm/internal/asm/testdata/arm64error.s b/src/cmd/asm/internal/asm/testdata/arm64error.s
index 474ed556d0..1744c09b98 100644
--- a/src/cmd/asm/internal/asm/testdata/arm64error.s
+++ b/src/cmd/asm/internal/asm/testdata/arm64error.s
@@ -32,6 +32,24 @@ TEXT errors(SB),$0
 	ANDS	$0x22220000, R2, RSP                             // ERROR "illegal combination"
 	ADD	R1, R2, R3, R4                                   // ERROR "illegal combination"
 	BICW	R7@>33, R5, R16                                  // ERROR "shift amount out of range 0 to 31"
+	NEGW	R7<<33, R5                                       // ERROR "shift amount out of range 0 to 31"
+	NEGSW	R7<<33, R5                                       // ERROR "shift amount out of range 0 to 31"
+	ADD	R7@>2, R5, R16                                   // ERROR "unsupported shift operator"
+	ADDW	R7@>2, R5, R16                                   // ERROR "unsupported shift operator"
+	ADDS	R7@>2, R5, R16                                   // ERROR "unsupported shift operator"
+	ADDSW	R7@>2, R5, R16                                   // ERROR "unsupported shift operator"
+	SUB	R7@>2, R5, R16                                   // ERROR "unsupported shift operator"
+	SUBW	R7@>2, R5, R16                                   // ERROR "unsupported shift operator"
+	SUBS	R7@>2, R5, R16                                   // ERROR "unsupported shift operator"
+	SUBSW	R7@>2, R5, R16                                   // ERROR "unsupported shift operator"
+	CMP	R7@>2, R5                                        // ERROR "unsupported shift operator"
+	CMPW	R7@>2, R5                                        // ERROR "unsupported shift operator"
+	CMN	R7@>2, R5                                        // ERROR "unsupported shift operator"
+	CMNW	R7@>2, R5                                        // ERROR "unsupported shift operator"
+	NEG	R7@>2, R5                                        // ERROR "unsupported shift operator"
+	NEGW	R7@>2, R5                                        // ERROR "unsupported shift operator"
+	NEGS	R7@>2, R5                                        // ERROR "unsupported shift operator"
+	NEGSW	R7@>2, R5                                        // ERROR "unsupported shift operator"
 	CINC	CS, R2, R3, R4                                   // ERROR "illegal combination"
 	CSEL	LT, R1, R2                                       // ERROR "illegal combination"
 	LDP.P	8(R2), (R2, R3)                                  // ERROR "constrained unpredictable behavior"
diff --git a/src/cmd/internal/obj/arm64/asm7.go b/src/cmd/internal/obj/arm64/asm7.go
index 2dbaea98b6..64067a4a17 100644
--- a/src/cmd/internal/obj/arm64/asm7.go
+++ b/src/cmd/internal/obj/arm64/asm7.go
@@ -321,12 +321,12 @@ var optab = []Optab{
 	{ACMP, C_VCON, C_REG, C_NONE, C_NONE, 13, 20, 0, 0, 0},
 	{AADD, C_SHIFT, C_REG, C_NONE, C_REG, 3, 4, 0, 0, 0},
 	{AADD, C_SHIFT, C_NONE, C_NONE, C_REG, 3, 4, 0, 0, 0},
-	{AADD, C_SHIFT, C_RSP, C_NONE, C_RSP, 107, 4, 0, 0, 0},
-	{AADD, C_SHIFT, C_NONE, C_NONE, C_RSP, 107, 4, 0, 0, 0},
+	{AADD, C_SHIFT, C_RSP, C_NONE, C_RSP, 26, 4, 0, 0, 0},
+	{AADD, C_SHIFT, C_NONE, C_NONE, C_RSP, 26, 4, 0, 0, 0},
 	{AMVN, C_SHIFT, C_NONE, C_NONE, C_REG, 3, 4, 0, 0, 0},
 	{ACMP, C_SHIFT, C_REG, C_NONE, C_NONE, 3, 4, 0, 0, 0},
-	{ACMP, C_SHIFT, C_RSP, C_NONE, C_NONE, 107, 4, 0, 0, 0},
-	{ANEG, C_SHIFT, C_NONE, C_NONE, C_REG, 26, 4, 0, 0, 0},
+	{ACMP, C_SHIFT, C_RSP, C_NONE, C_NONE, 26, 4, 0, 0, 0},
+	{ANEG, C_SHIFT, C_NONE, C_NONE, C_REG, 3, 4, 0, 0, 0},
 	{AADD, C_REG, C_RSP, C_NONE, C_RSP, 27, 4, 0, 0, 0},
 	{AADD, C_REG, C_NONE, C_NONE, C_RSP, 27, 4, 0, 0, 0},
 	{ACMP, C_REG, C_RSP, C_NONE, C_NONE, 27, 4, 0, 0, 0},
@@ -1355,6 +1355,14 @@ func isADDSop(op obj.As) bool {
 	return false
 }
 
+func isNEGop(op obj.As) bool {
+	switch op {
+	case ANEG, ANEGW, ANEGS, ANEGSW:
+		return true
+	}
+	return false
+}
+
 func isRegShiftOrExt(a *obj.Addr) bool {
 	return (a.Index-obj.RBaseARM64)&REG_EXT != 0 || (a.Index-obj.RBaseARM64)&REG_LSL != 0
 }
@@ -3251,13 +3259,17 @@ func (c *ctxt7) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		if is64bit == 0 && amount >= 32 {
 			c.ctxt.Diag("shift amount out of range 0 to 31: %v", p)
 		}
+		shift := (p.From.Offset >> 22) & 3
+		if (shift > 2 || shift < 0) && (isADDop(p.As) || isADDWop(p.As) || isNEGop(p.As)) {
+			c.ctxt.Diag("unsupported shift operator: %v", p)
+		}
 		o1 |= uint32(p.From.Offset) /* includes reg, op, etc */
 		rt := int(p.To.Reg)
 		if p.To.Type == obj.TYPE_NONE {
 			rt = REGZERO
 		}
 		r := int(p.Reg)
-		if p.As == AMVN || p.As == AMVNW {
+		if p.As == AMVN || p.As == AMVNW || isNEGop(p.As) {
 			r = REGZERO
 		} else if r == 0 {
 			r = rt
@@ -3665,12 +3677,40 @@ func (c *ctxt7) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		rt := int(p.To.Reg)
 		o1 |= (uint32(rf&31) << 16) | (REGZERO & 31 << 5) | uint32(rt&31)
 
-	case 26: /* negX Rm<<s, Rd -> subX Rm<<s, ZR, Rd */
-		o1 = c.oprrr(p, p.As)
+	case 26: // op R<<n, RSP, RSP (extended register)
+		// Refer to ARM reference manual, if "Rd" or "Rn" is RSP,
+		// it can be encoded as op(extended regster) instruction.
+		if !(p.To.Reg == REGSP || p.Reg == REGSP) {
+			c.ctxt.Diag("expected SP reference: %v", p)
+			break
+		}
+		if p.To.Reg == REGSP && (p.As == AADDS || p.As == AADDSW || p.As == ASUBS || p.As == ASUBSW) {
+			c.ctxt.Diag("unexpected SP reference: %v", p)
+			break
+		}
+		amount := (p.From.Offset >> 10) & 63
+		shift := (p.From.Offset >> 22) & 3
+		if shift != 0 {
+			c.ctxt.Diag("illegal combination: %v", p)
+			break
+		}
 
-		o1 |= uint32(p.From.Offset) /* includes reg, op, etc */
+		if amount > 4 {
+			c.ctxt.Diag("the left shift amount out of range 0 to 4: %v", p)
+			break
+		}
+		rf := (p.From.Offset >> 16) & 31
 		rt := int(p.To.Reg)
-		o1 |= (REGZERO & 31 << 5) | uint32(rt&31)
+		r := int(p.Reg)
+		if p.To.Type == obj.TYPE_NONE {
+			rt = REGZERO
+		}
+		if r == 0 {
+			r = rt
+		}
+
+		o1 = c.opxrrr(p, p.As, false)
+		o1 |= uint32(rf)<<16 | uint32(amount&7)<<10 | (uint32(r&31) << 5) | uint32(rt&31)
 
 	case 27: /* op Rm<<n[,Rn],Rd (extended register) */
 		if p.To.Reg == REG_RSP && isADDSop(p.As) {
@@ -5492,41 +5532,6 @@ func (c *ctxt7) asmout(p *obj.Prog, o *Optab, out []uint32) {
 			c.ctxt.Diag("illegal destination register: %v\n", p)
 		}
 		o1 |= enc | uint32(rs&31)<<16 | uint32(rb&31)<<5 | uint32(rt&31)
-
-	case 107: // op R<<n, RSP, RSP (extended register)
-		// Refer to ARM reference manual, if "Rd" or "Rn" is RSP,
-		// it can be encoded as op(extended regster) instruction.
-		if !(p.To.Reg == REGSP || p.Reg == REGSP) {
-			c.ctxt.Diag("expected SP reference: %v", p)
-			break
-		}
-		if p.To.Reg == REGSP && (p.As == AADDS || p.As == AADDSW || p.As == ASUBS || p.As == ASUBSW) {
-			c.ctxt.Diag("unexpected SP reference: %v", p)
-			break
-		}
-		amount := (p.From.Offset >> 10) & 63
-		shift := (p.From.Offset >> 22) & 3
-		if shift != 0 {
-			c.ctxt.Diag("illegal combination: %v", p)
-			break
-		}
-
-		if amount > 4 {
-			c.ctxt.Diag("the left shift amount out of range 0 to 4: %v", p)
-			break
-		}
-		rf := (p.From.Offset >> 16) & 31
-		rt := int(p.To.Reg)
-		r := int(p.Reg)
-		if p.To.Type == obj.TYPE_NONE {
-			rt = REGZERO
-		}
-		if r == 0 {
-			r = rt
-		}
-
-		o1 = c.opxrrr(p, p.As, false)
-		o1 |= uint32(rf)<<16 | uint32(amount&7)<<10 | (uint32(r&31) << 5) | uint32(rt&31)
 	}
 	out[0] = o1
 	out[1] = o2
-- 
GitLab


From f0a8101d34b396c4dc9ea6581c03ce16419192ab Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 20 Apr 2021 23:10:09 -0400
Subject: [PATCH 1703/2400] go/types: combine two loops (cleanup of TODO)

This is an exact port of CL 307949 to go/types.

Change-Id: I796f3030a86d76deb80e58bb547460b586480911
Reviewed-on: https://go-review.googlesource.com/c/go/+/312096
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/infer.go | 32 +++++++++++---------------------
 1 file changed, 11 insertions(+), 21 deletions(-)

diff --git a/src/go/types/infer.go b/src/go/types/infer.go
index 9aae1bb248..8b491eb3ba 100644
--- a/src/go/types/infer.go
+++ b/src/go/types/infer.go
@@ -182,33 +182,23 @@ func (check *Checker) infer(posn positioner, tparams []*TypeName, targs []Type,
 	// Use any untyped arguments to infer additional type arguments.
 	// Some generic parameters with untyped arguments may have been given
 	// a type by now, we can ignore them.
-	j := 0
 	for _, i := range indices {
 		par := params.At(i)
 		// Since untyped types are all basic (i.e., non-composite) types, an
 		// untyped argument will never match a composite parameter type; the
 		// only parameter type it can possibly match against is a *TypeParam.
-		// Thus, only keep the indices of generic parameters that are not of
-		// composite types and which don't have a type inferred yet.
+		// Thus, only consider untyped arguments for generic parameters that
+		// are not of composite types and which don't have a type inferred yet.
 		if tpar, _ := par.typ.(*_TypeParam); tpar != nil && targs[tpar.index] == nil {
-			indices[j] = i
-			j++
-		}
-	}
-	indices = indices[:j]
-
-	// Unify parameter and default argument types for remaining generic parameters.
-	// TODO(gri) Rather than iterating again, combine this code with the loop above.
-	for _, i := range indices {
-		par := params.At(i)
-		arg := args[i]
-		targ := Default(arg.typ)
-		// The default type for an untyped nil is untyped nil. We must not
-		// infer an untyped nil type as type parameter type. Ignore untyped
-		// nil by making sure all default argument types are typed.
-		if isTyped(targ) && !u.unify(par.typ, targ) {
-			errorf("default type", par.typ, targ, arg)
-			return nil
+			arg := args[i]
+			targ := Default(arg.typ)
+			// The default type for an untyped nil is untyped nil. We must not
+			// infer an untyped nil type as type parameter type. Ignore untyped
+			// nil by making sure all default argument types are typed.
+			if isTyped(targ) && !u.unify(par.typ, targ) {
+				errorf("default type", par.typ, targ, arg)
+				return nil
+			}
 		}
 	}
 
-- 
GitLab


From 617a83ec68b7657b0185a6b190f04460de30f31e Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 20 Apr 2021 23:25:12 -0400
Subject: [PATCH 1704/2400] go/types: re-enable a commented out test

This test was unnecessarily commented out in CL 312190: re-enable it and
update its assertions.

Change-Id: Ic08563e25c9b05a8e35d67690f5d27a761133266
Reviewed-on: https://go-review.googlesource.com/c/go/+/312097
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/fixedbugs/issue39634.go2 | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/go/types/fixedbugs/issue39634.go2 b/src/go/types/fixedbugs/issue39634.go2
index af1f1e44c5..a13ed13ce5 100644
--- a/src/go/types/fixedbugs/issue39634.go2
+++ b/src/go/types/fixedbugs/issue39634.go2
@@ -40,8 +40,7 @@ type foo9[A any] interface { type foo9 /* ERROR interface contains type constrai
 func _() { var _ = new(foo9 /* ERROR interface contains type constraints */ [int]) }
 
 // crash 12
-// TODO(rFindley) temporarily disabled due to an error check issue
-// var u /* ERROR cycle */ , i [func /* ERROR used as value */ /* ERROR used as value */ (u, c /* ERROR undeclared */ /* ERROR undeclared */ ) {}(0, len)]c /* ERROR undeclared */ /* ERROR undeclared */
+var u /* ERROR cycle */ , i [func /* ERROR used as value */ /* ERROR used as value */ (u, c /* ERROR undeclared */ /* ERROR undeclared */ ) {}(0, len /* ERROR must be called */ /* ERROR must be called */ )]c /* ERROR undeclared */ /* ERROR undeclared */
 
 // crash 15
 func y15() { var a /* ERROR declared but not used */ interface{ p() } = G15[string]{} }
-- 
GitLab


From 48b368b01fa1f4f9a4380722f03b35d449a09871 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 20 Apr 2021 10:55:59 -0700
Subject: [PATCH 1705/2400] cmd/compile/internal/types2: avoid follow-on errors
 for invalid [...] array

Fixes #42987.

Change-Id: Iaaa46e1f79525cd1e418c1a81a6414d11f8120b5
Reviewed-on: https://go-review.googlesource.com/c/go/+/311889
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/api_test.go              | 2 +-
 src/cmd/compile/internal/types2/fixedbugs/issue42987.src | 8 ++++++++
 src/cmd/compile/internal/types2/typexpr.go               | 5 ++++-
 3 files changed, 13 insertions(+), 2 deletions(-)
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue42987.src

diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go
index 68048f28d3..c90f2e7510 100644
--- a/src/cmd/compile/internal/types2/api_test.go
+++ b/src/cmd/compile/internal/types2/api_test.go
@@ -326,7 +326,7 @@ func TestTypesInfo(t *testing.T) {
 		{brokenPkg + `x2; func _() { var a, b string; type x struct {f string}; z := &x{f: a, f: b,}}`, `b`, `string`},
 		{brokenPkg + `x3; var x = panic("");`, `panic`, `func(interface{})`},
 		{`package x4; func _() { panic("") }`, `panic`, `func(interface{})`},
-		{brokenPkg + `x5; func _() { var x map[string][...]int; x = map[string][...]int{"": {1,2,3}} }`, `x`, `map[string][-1]int`},
+		{brokenPkg + `x5; func _() { var x map[string][...]int; x = map[string][...]int{"": {1,2,3}} }`, `x`, `map[string]invalid type`},
 
 		// parameterized functions
 		{genericPkg + `p0; func f[T any](T); var _ = f[int]`, `f`, `func[T₁ interface{}](T₁)`},
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue42987.src b/src/cmd/compile/internal/types2/fixedbugs/issue42987.src
new file mode 100644
index 0000000000..8aa3544272
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue42987.src
@@ -0,0 +1,8 @@
+// Copyright 2021 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.
+
+// Check that there is only one error (no follow-on errors).
+
+package p
+var _ = [ /* ERROR invalid use of .* array */ ...]byte("foo")
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 61b290c075..e64d804c30 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -518,7 +518,10 @@ func (check *Checker) typInternal(e0 syntax.Expr, def *Named) (T Type) {
 			typ.len = -1
 		}
 		typ.elem = check.varType(e.Elem)
-		return typ
+		if typ.len >= 0 {
+			return typ
+		}
+		// report error if we encountered [...]
 
 	case *syntax.SliceType:
 		typ := new(Slice)
-- 
GitLab


From ece59353645d250162e47c792da77cbb44a84f01 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 20 Apr 2021 16:18:59 -0700
Subject: [PATCH 1706/2400] cmd/compile/internal/types2: better errors for
 invalid short var decls

- rewrite Checker.shortVarDecl core loop for clarity
- match compiler error messages (#43087)
- don't allow multiple identical redeclarations (#45652)

For #43087.
For #45652.

Change-Id: I8c3329a553aa104d7853fbaea8b88049bc9b3b88
Reviewed-on: https://go-review.googlesource.com/c/go/+/312170
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 .../compile/internal/types2/assignments.go    | 98 +++++++++++--------
 .../internal/types2/fixedbugs/issue43087.src  | 43 ++++++++
 .../internal/types2/testdata/stmt0.src        |  6 +-
 3 files changed, 105 insertions(+), 42 deletions(-)
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue43087.src

diff --git a/src/cmd/compile/internal/types2/assignments.go b/src/cmd/compile/internal/types2/assignments.go
index ddcb5e00b3..ec9fdbba62 100644
--- a/src/cmd/compile/internal/types2/assignments.go
+++ b/src/cmd/compile/internal/types2/assignments.go
@@ -330,40 +330,59 @@ func (check *Checker) shortVarDecl(pos syntax.Pos, lhs, rhs []syntax.Expr) {
 	scope := check.scope
 
 	// collect lhs variables
-	var newVars []*Var
-	var lhsVars = make([]*Var, len(lhs))
+	seen := make(map[string]bool, len(lhs))
+	lhsVars := make([]*Var, len(lhs))
+	newVars := make([]*Var, 0, len(lhs))
+	hasErr := false
 	for i, lhs := range lhs {
-		var obj *Var
-		if ident, _ := lhs.(*syntax.Name); ident != nil {
-			// Use the correct obj if the ident is redeclared. The
-			// variable's scope starts after the declaration; so we
-			// must use Scope.Lookup here and call Scope.Insert
-			// (via check.declare) later.
-			name := ident.Value
-			if alt := scope.Lookup(name); alt != nil {
-				// redeclared object must be a variable
-				if alt, _ := alt.(*Var); alt != nil {
-					obj = alt
-				} else {
-					check.errorf(lhs, "cannot assign to %s", lhs)
-				}
-				check.recordUse(ident, alt)
+		ident, _ := lhs.(*syntax.Name)
+		if ident == nil {
+			check.useLHS(lhs)
+			check.errorf(lhs, "non-name %s on left side of :=", lhs)
+			hasErr = true
+			continue
+		}
+
+		name := ident.Value
+		if name == "_" {
+			continue
+		}
+
+		if seen[name] {
+			check.errorf(lhs, "%s repeated on left side of :=", lhs)
+			hasErr = true
+			continue
+		}
+		seen[name] = true
+
+		// Use the correct obj if the ident is redeclared. The
+		// variable's scope starts after the declaration; so we
+		// must use Scope.Lookup here and call Scope.Insert
+		// (via check.declare) later.
+		if alt := scope.Lookup(name); alt != nil {
+			check.recordUse(ident, alt)
+			// redeclared object must be a variable
+			if obj, _ := alt.(*Var); obj != nil {
+				lhsVars[i] = obj
 			} else {
-				// declare new variable, possibly a blank (_) variable
-				obj = NewVar(ident.Pos(), check.pkg, name, nil)
-				if name != "_" {
-					newVars = append(newVars, obj)
-				}
-				check.recordDef(ident, obj)
+				check.errorf(lhs, "cannot assign to %s", lhs)
+				hasErr = true
 			}
-		} else {
-			check.useLHS(lhs)
-			check.errorf(lhs, "cannot declare %s", lhs)
+			continue
 		}
+
+		// declare new variable
+		obj := NewVar(ident.Pos(), check.pkg, name, nil)
+		lhsVars[i] = obj
+		newVars = append(newVars, obj)
+		check.recordDef(ident, obj)
+	}
+
+	// create dummy variables where the lhs is invalid
+	for i, obj := range lhsVars {
 		if obj == nil {
-			obj = NewVar(lhs.Pos(), check.pkg, "_", nil) // dummy variable
+			lhsVars[i] = NewVar(lhs[i].Pos(), check.pkg, "_", nil)
 		}
-		lhsVars[i] = obj
 	}
 
 	check.initVars(lhsVars, rhs, nopos)
@@ -371,17 +390,18 @@ func (check *Checker) shortVarDecl(pos syntax.Pos, lhs, rhs []syntax.Expr) {
 	// process function literals in rhs expressions before scope changes
 	check.processDelayed(top)
 
-	// declare new variables
-	if len(newVars) > 0 {
-		// spec: "The scope of a constant or variable identifier declared inside
-		// a function begins at the end of the ConstSpec or VarSpec (ShortVarDecl
-		// for short variable declarations) and ends at the end of the innermost
-		// containing block."
-		scopePos := syntax.EndPos(rhs[len(rhs)-1])
-		for _, obj := range newVars {
-			check.declare(scope, nil, obj, scopePos) // recordObject already called
-		}
-	} else {
+	if len(newVars) == 0 && !hasErr {
 		check.softErrorf(pos, "no new variables on left side of :=")
+		return
+	}
+
+	// declare new variables
+	// spec: "The scope of a constant or variable identifier declared inside
+	// a function begins at the end of the ConstSpec or VarSpec (ShortVarDecl
+	// for short variable declarations) and ends at the end of the innermost
+	// containing block."
+	scopePos := syntax.EndPos(rhs[len(rhs)-1])
+	for _, obj := range newVars {
+		check.declare(scope, nil, obj, scopePos) // id = nil: recordDef already called
 	}
 }
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue43087.src b/src/cmd/compile/internal/types2/fixedbugs/issue43087.src
new file mode 100644
index 0000000000..85d4450139
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue43087.src
@@ -0,0 +1,43 @@
+// Copyright 2021 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 p
+
+func _() {
+	a, b, b /* ERROR b repeated on left side of := */ := 1, 2, 3
+	_ = a
+	_ = b
+}
+
+func _() {
+	a, _, _ := 1, 2, 3 // multiple _'s ok
+	_ = a
+}
+
+func _() {
+	var b int
+	a, b, b /* ERROR b repeated on left side of := */ := 1, 2, 3
+	_ = a
+	_ = b
+}
+
+func _() {
+	var a []int
+	a /* ERROR non-name .* on left side of := */ [0], b := 1, 2
+	_ = a
+	_ = b
+}
+
+func _() {
+	var a int
+	a, a /* ERROR a repeated on left side of := */ := 1, 2
+	_ = a
+}
+
+func _() {
+	var a, b int
+	a, b := /* ERROR no new variables on left side of := */ 1, 2
+	_ = a
+	_ = b
+}
diff --git a/src/cmd/compile/internal/types2/testdata/stmt0.src b/src/cmd/compile/internal/types2/testdata/stmt0.src
index 022883040b..bedcbe5fce 100644
--- a/src/cmd/compile/internal/types2/testdata/stmt0.src
+++ b/src/cmd/compile/internal/types2/testdata/stmt0.src
@@ -143,11 +143,11 @@ func issue6487() {
 }
 
 func issue6766a() {
-	a, a /* ERROR redeclared */ := 1, 2
+	a, a /* ERROR a repeated on left side of := */ := 1, 2
 	_ = a
-	a, b, b /* ERROR redeclared */ := 1, 2, 3
+	a, b, b /* ERROR b repeated on left side of := */ := 1, 2, 3
 	_ = b
-	c, c /* ERROR redeclared */, b := 1, 2, 3
+	c, c /* ERROR c repeated on left side of := */, b := 1, 2, 3
 	_ = c
 	a, b := /* ERROR no new variables */ 1, 2
 }
-- 
GitLab


From a71528ad317bdeeac515dcd3d35d7adad5ebc7c3 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 21 Apr 2021 17:26:25 -0700
Subject: [PATCH 1707/2400] cmd/compile/internal/types2: review fixedbugs tests

These tests match the corresponding tests for go/types
which have been reviewed.
This CL simply removes the UNREVIEWED disclaimer.

Change-Id: I4dfe2aedc1341ebb9ba206aac1a072f32cbe1f78
Reviewed-on: https://go-review.googlesource.com/c/go/+/312569
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/fixedbugs/issue39634.go2 | 1 -
 src/cmd/compile/internal/types2/fixedbugs/issue39664.go2 | 1 -
 src/cmd/compile/internal/types2/fixedbugs/issue39680.go2 | 1 -
 src/cmd/compile/internal/types2/fixedbugs/issue39693.go2 | 1 -
 src/cmd/compile/internal/types2/fixedbugs/issue39699.go2 | 1 -
 src/cmd/compile/internal/types2/fixedbugs/issue39711.go2 | 1 -
 src/cmd/compile/internal/types2/fixedbugs/issue39723.go2 | 1 -
 src/cmd/compile/internal/types2/fixedbugs/issue39725.go2 | 1 -
 src/cmd/compile/internal/types2/fixedbugs/issue39755.go2 | 1 -
 src/cmd/compile/internal/types2/fixedbugs/issue39768.go2 | 1 -
 src/cmd/compile/internal/types2/fixedbugs/issue39938.go2 | 1 -
 src/cmd/compile/internal/types2/fixedbugs/issue39948.go2 | 1 -
 src/cmd/compile/internal/types2/fixedbugs/issue39976.go2 | 1 -
 src/cmd/compile/internal/types2/fixedbugs/issue39982.go2 | 1 -
 src/cmd/compile/internal/types2/fixedbugs/issue40038.go2 | 1 -
 src/cmd/compile/internal/types2/fixedbugs/issue40056.go2 | 1 -
 src/cmd/compile/internal/types2/fixedbugs/issue40057.go2 | 1 -
 src/cmd/compile/internal/types2/fixedbugs/issue40301.go2 | 1 -
 src/cmd/compile/internal/types2/fixedbugs/issue40684.go2 | 1 -
 src/cmd/compile/internal/types2/fixedbugs/issue41124.go2 | 1 -
 20 files changed, 20 deletions(-)

diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39634.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39634.go2
index 36ad1ba08a..2c1299feb0 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue39634.go2
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39634.go2
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2020 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.
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39664.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39664.go2
index cf566c3e24..3b3ec56980 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue39664.go2
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39664.go2
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2020 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.
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39680.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39680.go2
index 3239c57d43..9bc26f3546 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue39680.go2
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39680.go2
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2020 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.
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39693.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39693.go2
index 6f4d701185..316ab1982e 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue39693.go2
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39693.go2
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2020 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.
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39699.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39699.go2
index c8655efee5..75491e7e26 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue39699.go2
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39699.go2
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2020 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.
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39711.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39711.go2
index 8edce78c10..df621a4c17 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue39711.go2
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39711.go2
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2020 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.
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39723.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39723.go2
index 8a4006ef84..55464e6b77 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue39723.go2
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39723.go2
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2020 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.
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39725.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39725.go2
index 6de661a38e..e19b6770bf 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue39725.go2
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39725.go2
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2020 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.
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39755.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39755.go2
index 93aea85215..b7ab68818e 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue39755.go2
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39755.go2
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2020 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.
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39768.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39768.go2
index 81b4a91f2c..abac141d7f 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue39768.go2
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39768.go2
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2020 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.
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39938.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39938.go2
index 19e69e6486..76e7e369ca 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue39938.go2
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39938.go2
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2020 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.
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39948.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39948.go2
index dede9c5797..c2b460902c 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue39948.go2
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39948.go2
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2020 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.
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39976.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39976.go2
index 2ab9664f88..3db4eae012 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue39976.go2
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39976.go2
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2020 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.
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39982.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue39982.go2
index 3abdfcb1b0..9810b6386a 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue39982.go2
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue39982.go2
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2020 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.
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue40038.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue40038.go2
index fe3963aac2..8948d61caa 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue40038.go2
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue40038.go2
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2020 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.
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue40056.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue40056.go2
index 98ded7c49a..747aab49dd 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue40056.go2
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue40056.go2
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2020 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.
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue40057.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue40057.go2
index b2ff11e4bf..fdc8fb1c00 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue40057.go2
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue40057.go2
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2020 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.
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue40301.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue40301.go2
index 6a3dfc741e..5d97855f8a 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue40301.go2
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue40301.go2
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2020 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.
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue40684.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue40684.go2
index 001c6d7b99..0269c3a62c 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue40684.go2
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue40684.go2
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2020 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.
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue41124.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue41124.go2
index 3098f44948..61f766bcbd 100644
--- a/src/cmd/compile/internal/types2/fixedbugs/issue41124.go2
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue41124.go2
@@ -1,4 +1,3 @@
-// UNREVIEWED
 // Copyright 2020 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.
-- 
GitLab


From 14a18b7d2538232c6cd6937297c421d5f6b7d92f Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 21 Apr 2021 18:24:15 -0700
Subject: [PATCH 1708/2400] cmd/compile/internal/types2: move a handful of
 tests

These tests belong into the fixedbugs directory.
This matches the go/types organization.
No changes to the code.

Change-Id: I36bcf70672d9ea5a40175c445e1d036c603ae76f
Reviewed-on: https://go-review.googlesource.com/c/go/+/312570
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 .../internal/types2/{testdata => fixedbugs}/issue23203a.src       | 0
 .../internal/types2/{testdata => fixedbugs}/issue23203b.src       | 0
 .../internal/types2/{testdata => fixedbugs}/issue26390.src        | 0
 .../internal/types2/{testdata => fixedbugs}/issue28251.src        | 0
 .../compile/internal/types2/{testdata => fixedbugs}/issue6977.src | 0
 5 files changed, 0 insertions(+), 0 deletions(-)
 rename src/cmd/compile/internal/types2/{testdata => fixedbugs}/issue23203a.src (100%)
 rename src/cmd/compile/internal/types2/{testdata => fixedbugs}/issue23203b.src (100%)
 rename src/cmd/compile/internal/types2/{testdata => fixedbugs}/issue26390.src (100%)
 rename src/cmd/compile/internal/types2/{testdata => fixedbugs}/issue28251.src (100%)
 rename src/cmd/compile/internal/types2/{testdata => fixedbugs}/issue6977.src (100%)

diff --git a/src/cmd/compile/internal/types2/testdata/issue23203a.src b/src/cmd/compile/internal/types2/fixedbugs/issue23203a.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/issue23203a.src
rename to src/cmd/compile/internal/types2/fixedbugs/issue23203a.src
diff --git a/src/cmd/compile/internal/types2/testdata/issue23203b.src b/src/cmd/compile/internal/types2/fixedbugs/issue23203b.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/issue23203b.src
rename to src/cmd/compile/internal/types2/fixedbugs/issue23203b.src
diff --git a/src/cmd/compile/internal/types2/testdata/issue26390.src b/src/cmd/compile/internal/types2/fixedbugs/issue26390.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/issue26390.src
rename to src/cmd/compile/internal/types2/fixedbugs/issue26390.src
diff --git a/src/cmd/compile/internal/types2/testdata/issue28251.src b/src/cmd/compile/internal/types2/fixedbugs/issue28251.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/issue28251.src
rename to src/cmd/compile/internal/types2/fixedbugs/issue28251.src
diff --git a/src/cmd/compile/internal/types2/testdata/issue6977.src b/src/cmd/compile/internal/types2/fixedbugs/issue6977.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/issue6977.src
rename to src/cmd/compile/internal/types2/fixedbugs/issue6977.src
-- 
GitLab


From a4f3ff22056646a563fbde663ff56fce33b7773f Mon Sep 17 00:00:00 2001
From: Aofei Sheng <aofei@aofeisheng.com>
Date: Thu, 22 Apr 2021 15:26:20 +0800
Subject: [PATCH 1709/2400] cmd/go: update TestScript/mod_convert

Fixes #45659

Change-Id: Ie7e07c9acfc500222c244464fbebfcc8e5b14c64
Reviewed-on: https://go-review.googlesource.com/c/go/+/312629
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Trust: Dmitri Shuralyov <dmitshur@golang.org>
---
 src/cmd/go/testdata/script/mod_convert.txt | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/cmd/go/testdata/script/mod_convert.txt b/src/cmd/go/testdata/script/mod_convert.txt
index 6e9b136356..f60fe87637 100644
--- a/src/cmd/go/testdata/script/mod_convert.txt
+++ b/src/cmd/go/testdata/script/mod_convert.txt
@@ -1,4 +1,6 @@
 [short] skip
+[!net] skip
+[!exec:git] skip
 
 env GO111MODULE=on
 env GOPROXY=
-- 
GitLab


From b2a032add8e46ca03af0b2c1c72052b75e056101 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Wed, 21 Apr 2021 19:02:11 -0400
Subject: [PATCH 1710/2400] cmd/link: update machoPlatform selection

Now that we have darwin/arm64 and ios/arm64 ports, make it based
on GOOS, instead of GOARCH.

Also drop a remaining case of 32-bit ARM.

Change-Id: I954fff980712fd3b81b561ddcb6f3a4ef73fa0b9
Reviewed-on: https://go-review.googlesource.com/c/go/+/312549
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/ld/macho.go | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/cmd/link/internal/ld/macho.go b/src/cmd/link/internal/ld/macho.go
index 98c9a32f4d..1c88c05dd4 100644
--- a/src/cmd/link/internal/ld/macho.go
+++ b/src/cmd/link/internal/ld/macho.go
@@ -468,9 +468,12 @@ func (ctxt *Link) domacho() {
 		}
 	}
 	if machoPlatform == 0 {
+		machoPlatform = PLATFORM_MACOS
+		if buildcfg.GOOS == "ios" {
+			machoPlatform = PLATFORM_IOS
+		}
 		switch ctxt.Arch.Family {
 		default:
-			machoPlatform = PLATFORM_MACOS
 			if ctxt.LinkMode == LinkInternal {
 				// For lldb, must say LC_VERSION_MIN_MACOSX or else
 				// it won't know that this Mach-O binary is from OS X
@@ -486,8 +489,7 @@ func (ctxt *Link) domacho() {
 				ml.data[0] = 10<<16 | 9<<8 | 0<<0 // OS X version 10.9.0
 				ml.data[1] = 10<<16 | 9<<8 | 0<<0 // SDK 10.9.0
 			}
-		case sys.ARM, sys.ARM64:
-			machoPlatform = PLATFORM_IOS
+		case sys.ARM64:
 		}
 	}
 
-- 
GitLab


From d5b2d809b09b5a7404ad334a5e56b2210a06254c Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Wed, 21 Apr 2021 19:12:38 -0400
Subject: [PATCH 1711/2400] cmd/link: emit LC_BUILD_VERSION on Mach-O

LC_VERSION_MIN_MACOSX seems deprecated. Emit LC_BUILD_VERSION
instead. Also emit it on darwin/arm64, where it was not emitted
before.

Fixes #45091.

Change-Id: I18fb80d571f681da3bd258e53beb520e68f354bd
Reviewed-on: https://go-review.googlesource.com/c/go/+/312550
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/ld/macho.go | 28 ++++++++++++----------------
 src/cmd/link/link_test.go         | 18 +++++++++---------
 2 files changed, 21 insertions(+), 25 deletions(-)

diff --git a/src/cmd/link/internal/ld/macho.go b/src/cmd/link/internal/ld/macho.go
index 1c88c05dd4..85269b30d0 100644
--- a/src/cmd/link/internal/ld/macho.go
+++ b/src/cmd/link/internal/ld/macho.go
@@ -472,24 +472,20 @@ func (ctxt *Link) domacho() {
 		if buildcfg.GOOS == "ios" {
 			machoPlatform = PLATFORM_IOS
 		}
-		switch ctxt.Arch.Family {
-		default:
-			if ctxt.LinkMode == LinkInternal {
-				// For lldb, must say LC_VERSION_MIN_MACOSX or else
-				// it won't know that this Mach-O binary is from OS X
-				// (could be iOS or WatchOS instead).
-				// Go on iOS uses linkmode=external, and linkmode=external
-				// adds this itself. So we only need this code for linkmode=internal
-				// and we can assume OS X.
-				//
-				// See golang.org/issues/12941.
-				//
+		if ctxt.LinkMode == LinkInternal && machoPlatform == PLATFORM_MACOS {
+			var version uint32
+			switch ctxt.Arch.Family {
+			case sys.AMD64:
 				// The version must be at least 10.9; see golang.org/issues/30488.
-				ml := newMachoLoad(ctxt.Arch, LC_VERSION_MIN_MACOSX, 2)
-				ml.data[0] = 10<<16 | 9<<8 | 0<<0 // OS X version 10.9.0
-				ml.data[1] = 10<<16 | 9<<8 | 0<<0 // SDK 10.9.0
+				version = 10<<16 | 9<<8 | 0<<0 // 10.9.0
+			case sys.ARM64:
+				version = 11<<16 | 0<<8 | 0<<0 // 11.0.0
 			}
-		case sys.ARM64:
+			ml := newMachoLoad(ctxt.Arch, LC_BUILD_VERSION, 4)
+			ml.data[0] = uint32(machoPlatform)
+			ml.data[1] = version // OS version
+			ml.data[2] = version // SDK version
+			ml.data[3] = 0       // ntools
 		}
 	}
 
diff --git a/src/cmd/link/link_test.go b/src/cmd/link/link_test.go
index 9369e550f4..985aed49e2 100644
--- a/src/cmd/link/link_test.go
+++ b/src/cmd/link/link_test.go
@@ -333,12 +333,12 @@ func TestXFlag(t *testing.T) {
 	}
 }
 
-var testMacOSVersionSrc = `
+var testMachOBuildVersionSrc = `
 package main
 func main() { }
 `
 
-func TestMacOSVersion(t *testing.T) {
+func TestMachOBuildVersion(t *testing.T) {
 	testenv.MustHaveGoBuild(t)
 
 	t.Parallel()
@@ -346,7 +346,7 @@ func TestMacOSVersion(t *testing.T) {
 	tmpdir := t.TempDir()
 
 	src := filepath.Join(tmpdir, "main.go")
-	err := ioutil.WriteFile(src, []byte(testMacOSVersionSrc), 0666)
+	err := ioutil.WriteFile(src, []byte(testMachOBuildVersionSrc), 0666)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -371,28 +371,28 @@ func TestMacOSVersion(t *testing.T) {
 		t.Fatal(err)
 	}
 	found := false
-	const LC_VERSION_MIN_MACOSX = 0x24
+	const LC_BUILD_VERSION = 0x32
 	checkMin := func(ver uint32) {
 		major, minor := (ver>>16)&0xff, (ver>>8)&0xff
 		if major != 10 || minor < 9 {
-			t.Errorf("LC_VERSION_MIN_MACOSX version %d.%d < 10.9", major, minor)
+			t.Errorf("LC_BUILD_VERSION version %d.%d < 10.9", major, minor)
 		}
 	}
 	for _, cmd := range exem.Loads {
 		raw := cmd.Raw()
 		type_ := exem.ByteOrder.Uint32(raw)
-		if type_ != LC_VERSION_MIN_MACOSX {
+		if type_ != LC_BUILD_VERSION {
 			continue
 		}
-		osVer := exem.ByteOrder.Uint32(raw[8:])
+		osVer := exem.ByteOrder.Uint32(raw[12:])
 		checkMin(osVer)
-		sdkVer := exem.ByteOrder.Uint32(raw[12:])
+		sdkVer := exem.ByteOrder.Uint32(raw[16:])
 		checkMin(sdkVer)
 		found = true
 		break
 	}
 	if !found {
-		t.Errorf("no LC_VERSION_MIN_MACOSX load command found")
+		t.Errorf("no LC_BUILD_VERSION load command found")
 	}
 }
 
-- 
GitLab


From d3853fb4e6ee2b9f873ab2e41adc0e62a82e73e4 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 22 Apr 2021 11:12:21 -0400
Subject: [PATCH 1712/2400] runtime: call cgocallbackg indirectly

cgocallback calls cgocallbackg after switching the stack. Call it
indirectly to bypass the linker's nosplit check.

Apparently (at least on Windows) cgocallbackg can use quite a bit
stack space in a nosplit chain. We have been running over the
nosplit limit, or very close to the limit. Since it switches
stack in cgocallback, it is not meaningful to count frames above
cgocallback and below cgocallbackg together. Bypass the check.

For #45658.

Change-Id: Ie22017e3f82d2c1fcc37336696f2d02757856399
Reviewed-on: https://go-review.googlesource.com/c/go/+/312669
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/asm_amd64.s | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index d2848e5a45..789e159c76 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -911,7 +911,8 @@ havem:
 	MOVQ	BX, 0(SP)
 	MOVQ	CX, 8(SP)
 	MOVQ	DX, 16(SP)
-	CALL	runtime·cgocallbackg(SB)
+	MOVQ	$runtime·cgocallbackg(SB), AX
+	CALL	AX	// indirect call to bypass nosplit check. We're on a different stack now.
 
 	// Compute the size of the frame again. FP and SP have
 	// completely different values here than they did above,
-- 
GitLab


From e8666abd9884f6743f78229ed210bf12a35e7368 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 22 Apr 2021 11:36:29 -0400
Subject: [PATCH 1713/2400] cmd/compile: keep call's args in elim dead auto
 pass

If the address of an auto is used in a Call, we need to keep it,
as we keep the Call itself.

Fixes #45693.

Change-Id: Ie548d6dffc95bf916868a8885d4ab4cf9e86355a
Reviewed-on: https://go-review.googlesource.com/c/go/+/312670
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/ssa/deadstore.go |  3 ++-
 test/fixedbugs/issue45693.go              | 16 ++++++++++++++++
 2 files changed, 18 insertions(+), 1 deletion(-)
 create mode 100644 test/fixedbugs/issue45693.go

diff --git a/src/cmd/compile/internal/ssa/deadstore.go b/src/cmd/compile/internal/ssa/deadstore.go
index 31d3f62d4e..d694133ec3 100644
--- a/src/cmd/compile/internal/ssa/deadstore.go
+++ b/src/cmd/compile/internal/ssa/deadstore.go
@@ -201,8 +201,9 @@ func elimDeadAutosGeneric(f *Func) {
 			panic("unhandled op with sym effect")
 		}
 
-		if v.Uses == 0 && v.Op != OpNilCheck || len(args) == 0 {
+		if v.Uses == 0 && v.Op != OpNilCheck && !v.Op.IsCall() && !v.Op.HasSideEffects() || len(args) == 0 {
 			// Nil check has no use, but we need to keep it.
+			// Also keep calls and values that have side effects.
 			return
 		}
 
diff --git a/test/fixedbugs/issue45693.go b/test/fixedbugs/issue45693.go
new file mode 100644
index 0000000000..20a0cec8ff
--- /dev/null
+++ b/test/fixedbugs/issue45693.go
@@ -0,0 +1,16 @@
+// compile
+
+// Copyright 2021 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.
+
+// Issue 45693: ICE with register args.
+
+package p
+
+func f() {
+	var s string
+	s = s + "" + s + "" + s + ""
+	for {
+	}
+}
-- 
GitLab


From d4aa72002e76c09f81a8fd82f37781f5126c9cbe Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Fri, 16 Apr 2021 15:15:17 -0500
Subject: [PATCH 1714/2400] cmd/asm: fix RLDCR const1,reg,const2,reg on ppc64

The extended opcode field (XO) is generated incorrectly. OPVCC
assumes an X-form like layout for the XO field. MD-form insns
also have an XO field, but it is both smaller and in a different
bit position.

This hasn't been noticed since const1 == 0 matches as a register
argument instead of a constant, thus it is unlikely anyone has
attempted to assemble this instruction with a non-zero shift
argument.

Likewise, update all other MD-form instructions using OPVCC
to use the new OPMD function.

Change-Id: Id81fa2727fb701431911a05492c2038415ad0a4d
Reviewed-on: https://go-review.googlesource.com/c/go/+/310851
Run-TryBot: Paul Murphy <murp@ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Lynn Boger <laboger@linux.vnet.ibm.com>
Reviewed-by: Carlos Eduardo Seo <carlos.seo@linaro.org>
---
 src/cmd/asm/internal/asm/testdata/ppc64.s |  2 ++
 src/cmd/internal/obj/ppc64/asm9.go        | 33 +++++++++++++----------
 2 files changed, 21 insertions(+), 14 deletions(-)

diff --git a/src/cmd/asm/internal/asm/testdata/ppc64.s b/src/cmd/asm/internal/asm/testdata/ppc64.s
index eaec24b8b7..edaecaea49 100644
--- a/src/cmd/asm/internal/asm/testdata/ppc64.s
+++ b/src/cmd/asm/internal/asm/testdata/ppc64.s
@@ -318,6 +318,8 @@ TEXT asmtest(SB),DUPOK|NOSPLIT,$0
 	RLDICCC $0, R4, $15, R6         // 788603c9
 	CLRLSLWI $16, R5, $8, R4        // 54a4422e
 	CLRLSLDI $24, R4, $2, R3        // 78831588
+	RLDCR	$1, R1, $-16, R1        // 78210ee4
+	RLDCRCC	$1, R1, $-16, R1        // 78210ee5
 
 	BEQ 0(PC)                       // 41820000
 	BEQ CR1,0(PC)                   // 41860000
diff --git a/src/cmd/internal/obj/ppc64/asm9.go b/src/cmd/internal/obj/ppc64/asm9.go
index 373fbedec7..69c84b21d4 100644
--- a/src/cmd/internal/obj/ppc64/asm9.go
+++ b/src/cmd/internal/obj/ppc64/asm9.go
@@ -1987,6 +1987,11 @@ func OPCC(o uint32, xo uint32, rc uint32) uint32 {
 	return OPVCC(o, xo, 0, rc)
 }
 
+/* Generate MD-form opcode */
+func OPMD(o, xo, rc uint32) uint32 {
+	return o<<26 | xo<<2 | rc&1
+}
+
 /* the order is dest, a/s, b/imm for both arithmetic and logical operations */
 func AOP_RRR(op uint32, d uint32, a uint32, b uint32) uint32 {
 	return op | (d&31)<<21 | (a&31)<<16 | (b&31)<<11
@@ -4230,14 +4235,14 @@ func (c *ctxt9) oprrr(a obj.As) uint32 {
 	case ARLDICLCC:
 		return OPVCC(30, 0, 0, 1)
 	case ARLDICR:
-		return OPVCC(30, 0, 0, 0) | 2<<1 // rldicr
+		return OPMD(30, 1, 0) // rldicr
 	case ARLDICRCC:
-		return OPVCC(30, 0, 0, 1) | 2<<1 // rldicr.
+		return OPMD(30, 1, 1) // rldicr.
 
 	case ARLDIC:
-		return OPVCC(30, 0, 0, 0) | 4<<1 // rldic
+		return OPMD(30, 2, 0) // rldic
 	case ARLDICCC:
-		return OPVCC(30, 0, 0, 1) | 4<<1 // rldic.
+		return OPMD(30, 2, 1) // rldic.
 
 	case ASYSCALL:
 		return OPVCC(17, 1, 0, 0)
@@ -4895,30 +4900,30 @@ func (c *ctxt9) opirr(a obj.As) uint32 {
 	case ARLWMICC:
 		return OPVCC(20, 0, 0, 1)
 	case ARLDMI:
-		return OPVCC(30, 0, 0, 0) | 3<<2 /* rldimi */
+		return OPMD(30, 3, 0) /* rldimi */
 	case ARLDMICC:
-		return OPVCC(30, 0, 0, 1) | 3<<2
+		return OPMD(30, 3, 1) /* rldimi. */
 	case ARLDIMI:
-		return OPVCC(30, 0, 0, 0) | 3<<2 /* rldimi */
+		return OPMD(30, 3, 0) /* rldimi */
 	case ARLDIMICC:
-		return OPVCC(30, 0, 0, 1) | 3<<2
+		return OPMD(30, 3, 1) /* rldimi. */
 	case ARLWNM:
 		return OPVCC(21, 0, 0, 0) /* rlwinm */
 	case ARLWNMCC:
 		return OPVCC(21, 0, 0, 1)
 
 	case ARLDCL:
-		return OPVCC(30, 0, 0, 0) /* rldicl */
+		return OPMD(30, 0, 0) /* rldicl */
 	case ARLDCLCC:
-		return OPVCC(30, 0, 0, 1)
+		return OPMD(30, 0, 1) /* rldicl. */
 	case ARLDCR:
-		return OPVCC(30, 1, 0, 0) /* rldicr */
+		return OPMD(30, 1, 0) /* rldicr */
 	case ARLDCRCC:
-		return OPVCC(30, 1, 0, 1)
+		return OPMD(30, 1, 1) /* rldicr. */
 	case ARLDC:
-		return OPVCC(30, 0, 0, 0) | 2<<2
+		return OPMD(30, 2, 0) /* rldic */
 	case ARLDCCC:
-		return OPVCC(30, 0, 0, 1) | 2<<2
+		return OPMD(30, 2, 1) /* rldic. */
 
 	case ASRAW:
 		return OPVCC(31, 824, 0, 0)
-- 
GitLab


From 537cde0b4b411f1dc3016cac430b9494cf91caf0 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Fri, 15 Jan 2021 17:58:41 -0500
Subject: [PATCH 1715/2400] cmd/compile, runtime: add metadata for argument
 printing in traceback

Currently, when the runtime printing a stack track (at panic, or
when runtime.Stack is called), it prints the function arguments
as words in memory. With a register-based calling convention,
the layout of argument area of the memory changes, so the
printing also needs to change. In particular, the memory order
and the syntax order of the arguments may differ. To address
that, this CL lets the compiler to emit some metadata about the
memory layout of the arguments, and the runtime will use this
information to print arguments in syntax order.

Previously we print the memory contents of the results along with
the arguments. The results are likely uninitialized when the
traceback is taken, so that information is rarely useful. Also,
with a register-based calling convention the results may not
have corresponding locations in memory. This CL changes it to not
print results.

Previously the runtime simply prints the memory contents as
pointer-sized words. With a register-based calling convention,
as the layout changes, arguments that were packed in one word
may no longer be in one word. Also, as the spill slots are not
always initialized, it is possible that some part of a word
contains useful informationwhile the rest contains garbage.
Instead of letting the runtime recreating the ABI0 layout and
print them as words, we now print each component separately.
Aggregate-typed argument/component is surrounded by "{}".

For example, for a function

F(int, [3]byte, byte) int

when called as F(1, [3]byte{2, 3, 4}, 5), it used to print

F(0x1, 0x5040302, 0xXXXXXXXX) // assuming little endian, 0xXXXXXXXX is uninitilized result

Now prints

F(0x1, {0x2, 0x3, 0x4}, 0x5).

Note: the liveness tracking of the spill splots has not been
implemented in this CL. Currently the runtime just assumes all
the slots are live and print them all.

Increase binary sizes by ~1.5%.

                     old          new
hello (println)    1171328      1187712 (+1.4%)
hello (fmt)        1877024      1901600 (+1.3%)
cmd/compile       22326928     22662800 (+1.5%)
cmd/go            13505024     13726208 (+1.6%)

Updates #40724.

Change-Id: I351e0bf497f99bdbb3f91df2fb17e3c2c5c316dc
Reviewed-on: https://go-review.googlesource.com/c/go/+/304470
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/cmd/compile/internal/gc/obj.go        |   5 +
 src/cmd/compile/internal/ssagen/ssa.go    | 158 ++++++++++++++++++++++
 src/cmd/internal/obj/link.go              |   1 +
 src/cmd/internal/objabi/funcdata.go       |   1 +
 src/cmd/link/internal/ld/deadcode_test.go |   4 +-
 src/runtime/funcdata.h                    |   1 +
 src/runtime/symtab.go                     |   1 +
 src/runtime/traceback.go                  |  89 ++++++++++--
 src/runtime/traceback_test.go             | 121 +++++++++++++++++
 9 files changed, 368 insertions(+), 13 deletions(-)
 create mode 100644 src/runtime/traceback_test.go

diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index f87a3c6b48..0b10cb8a9e 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -257,6 +257,11 @@ func addGCLocals() {
 		if x := fn.OpenCodedDeferInfo; x != nil {
 			objw.Global(x, int32(len(x.P)), obj.RODATA|obj.DUPOK)
 		}
+		if x := fn.ArgInfo; x != nil {
+			objw.Global(x, int32(len(x.P)), obj.RODATA|obj.DUPOK)
+			x.Set(obj.AttrStatic, true)
+			x.Set(obj.AttrContentAddressable, true)
+		}
 	}
 }
 
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 10f02fc987..c293e4db19 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -6554,6 +6554,163 @@ func (s *State) DebugFriendlySetPosFrom(v *ssa.Value) {
 	}
 }
 
+// emit argument info (locations on stack) for traceback.
+func emitArgInfo(e *ssafn, pp *objw.Progs) {
+	ft := e.curfn.Type()
+	if ft.NumRecvs() == 0 && ft.NumParams() == 0 {
+		return
+	}
+
+	x := base.Ctxt.Lookup(fmt.Sprintf("%s.arginfo%d", e.curfn.LSym.Name, e.curfn.LSym.ABI()))
+	e.curfn.LSym.Func().ArgInfo = x
+
+	PtrSize := int64(types.PtrSize)
+
+	isAggregate := func(t *types.Type) bool {
+		return t.IsStruct() || t.IsArray() || t.IsComplex() || t.IsInterface() || t.IsString() || t.IsSlice()
+	}
+
+	// Populate the data.
+	// The data is a stream of bytes, which contains the offsets and sizes of the
+	// non-aggregate arguments or non-aggregate fields/elements of aggregate-typed
+	// arguments, along with special "operators". Specifically,
+	// - for each non-aggrgate arg/field/element, its offset from FP (1 byte) and
+	//   size (1 byte)
+	// - special operators:
+	//   - 0xff - end of sequence
+	//   - 0xfe - print { (at the start of an aggregate-typed argument)
+	//   - 0xfd - print } (at the end of an aggregate-typed argument)
+	//   - 0xfc - print ... (more args/fields/elements)
+	//   - 0xfb - print _ (offset too large)
+	// These constants need to be in sync with runtime.traceback.go:printArgs.
+	const (
+		_endSeq         = 0xff
+		_startAgg       = 0xfe
+		_endAgg         = 0xfd
+		_dotdotdot      = 0xfc
+		_offsetTooLarge = 0xfb
+		_special        = 0xf0 // above this are operators, below this are ordinary offsets
+	)
+
+	const (
+		limit    = 10 // print no more than 10 args/components
+		maxDepth = 5  // no more than 5 layers of nesting
+
+		// maxLen is a (conservative) upper bound of the byte stream length. For
+		// each arg/component, it has no more than 2 bytes of data (size, offset),
+		// and no more than one {, }, ... at each level (it cannot have both the
+		// data and ... unless it is the last one, just be conservative). Plus 1
+		// for _endSeq.
+		maxLen = (maxDepth*3+2)*limit + 1
+	)
+
+	wOff := 0
+	n := 0
+	writebyte := func(o uint8) { wOff = objw.Uint8(x, wOff, o) }
+
+	// Write one non-aggrgate arg/field/element if there is room.
+	// Returns whether to continue.
+	write1 := func(sz, offset int64) bool {
+		if n >= limit {
+			return false
+		}
+		if offset >= _special {
+			writebyte(_offsetTooLarge)
+		} else {
+			writebyte(uint8(offset))
+			writebyte(uint8(sz))
+		}
+		n++
+		return true
+	}
+
+	// Visit t recursively and write it out.
+	// Returns whether to continue visiting.
+	var visitType func(baseOffset int64, t *types.Type, depth int) bool
+	visitType = func(baseOffset int64, t *types.Type, depth int) bool {
+		if n >= limit {
+			return false
+		}
+		if !isAggregate(t) {
+			return write1(t.Size(), baseOffset)
+		}
+		writebyte(_startAgg)
+		depth++
+		if depth >= maxDepth {
+			writebyte(_dotdotdot)
+			writebyte(_endAgg)
+			n++
+			return true
+		}
+		var r bool
+		switch {
+		case t.IsInterface(), t.IsString():
+			r = write1(PtrSize, baseOffset) &&
+				write1(PtrSize, baseOffset+PtrSize)
+		case t.IsSlice():
+			r = write1(PtrSize, baseOffset) &&
+				write1(PtrSize, baseOffset+PtrSize) &&
+				write1(PtrSize, baseOffset+PtrSize*2)
+		case t.IsComplex():
+			r = write1(t.Size()/2, baseOffset) &&
+				write1(t.Size()/2, baseOffset+t.Size()/2)
+		case t.IsArray():
+			r = true
+			if t.NumElem() == 0 {
+				n++ // {} counts as a component
+				break
+			}
+			for i := int64(0); i < t.NumElem(); i++ {
+				if !visitType(baseOffset, t.Elem(), depth) {
+					r = false
+					break
+				}
+				baseOffset += t.Elem().Size()
+			}
+		case t.IsStruct():
+			r = true
+			if t.NumFields() == 0 {
+				n++ // {} counts as a component
+				break
+			}
+			for _, field := range t.Fields().Slice() {
+				if !visitType(baseOffset+field.Offset, field.Type, depth) {
+					r = false
+					break
+				}
+			}
+		}
+		if !r {
+			writebyte(_dotdotdot)
+		}
+		writebyte(_endAgg)
+		return r
+	}
+
+	c := true
+outer:
+	for _, fs := range &types.RecvsParams {
+		for _, a := range fs(ft).Fields().Slice() {
+			if !c {
+				writebyte(_dotdotdot)
+				break outer
+			}
+			c = visitType(a.Offset, a.Type, 0)
+		}
+	}
+	writebyte(_endSeq)
+	if wOff > maxLen {
+		base.Fatalf("ArgInfo too large")
+	}
+
+	// Emit a funcdata pointing at the arg info data.
+	p := pp.Prog(obj.AFUNCDATA)
+	p.From.SetConst(objabi.FUNCDATA_ArgInfo)
+	p.To.Type = obj.TYPE_MEM
+	p.To.Name = obj.NAME_EXTERN
+	p.To.Sym = x
+}
+
 // genssa appends entries to pp for each instruction in f.
 func genssa(f *ssa.Func, pp *objw.Progs) {
 	var s State
@@ -6562,6 +6719,7 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 	e := f.Frontend().(*ssafn)
 
 	s.livenessMap, s.partLiveArgs = liveness.Compute(e.curfn, f, e.stkptrsize, pp)
+	emitArgInfo(e, pp)
 
 	openDeferInfo := e.curfn.LSym.Func().OpenCodedDeferInfo
 	if openDeferInfo != nil {
diff --git a/src/cmd/internal/obj/link.go b/src/cmd/internal/obj/link.go
index 7530690185..28626e6e03 100644
--- a/src/cmd/internal/obj/link.go
+++ b/src/cmd/internal/obj/link.go
@@ -485,6 +485,7 @@ type FuncInfo struct {
 	GCLocals           *LSym
 	StackObjects       *LSym
 	OpenCodedDeferInfo *LSym
+	ArgInfo            *LSym // argument info for traceback
 
 	FuncInfoSym *LSym
 }
diff --git a/src/cmd/internal/objabi/funcdata.go b/src/cmd/internal/objabi/funcdata.go
index faa2863325..4ff0ebe13d 100644
--- a/src/cmd/internal/objabi/funcdata.go
+++ b/src/cmd/internal/objabi/funcdata.go
@@ -20,6 +20,7 @@ const (
 	FUNCDATA_StackObjects       = 2
 	FUNCDATA_InlTree            = 3
 	FUNCDATA_OpenCodedDeferInfo = 4
+	FUNCDATA_ArgInfo            = 5
 
 	// ArgsSizeUnknown is set in Func.argsize to mark all functions
 	// whose argument size is unknown (C vararg functions, and
diff --git a/src/cmd/link/internal/ld/deadcode_test.go b/src/cmd/link/internal/ld/deadcode_test.go
index bd74205a1a..6e128432dc 100644
--- a/src/cmd/link/internal/ld/deadcode_test.go
+++ b/src/cmd/link/internal/ld/deadcode_test.go
@@ -40,10 +40,10 @@ func TestDeadcode(t *testing.T) {
 			if err != nil {
 				t.Fatalf("%v: %v:\n%s", cmd.Args, err, out)
 			}
-			if test.pos != "" && !bytes.Contains(out, []byte(test.pos)) {
+			if test.pos != "" && !bytes.Contains(out, []byte(test.pos+"\n")) {
 				t.Errorf("%s should be reachable. Output:\n%s", test.pos, out)
 			}
-			if test.neg != "" && bytes.Contains(out, []byte(test.neg)) {
+			if test.neg != "" && bytes.Contains(out, []byte(test.neg+"\n")) {
 				t.Errorf("%s should not be reachable. Output:\n%s", test.neg, out)
 			}
 		})
diff --git a/src/runtime/funcdata.h b/src/runtime/funcdata.h
index 798dbaceab..1002b181e4 100644
--- a/src/runtime/funcdata.h
+++ b/src/runtime/funcdata.h
@@ -17,6 +17,7 @@
 #define FUNCDATA_StackObjects 2
 #define FUNCDATA_InlTree 3
 #define FUNCDATA_OpenCodedDeferInfo 4 /* info for func with open-coded defers */
+#define FUNCDATA_ArgInfo 5
 
 // Pseudo-assembly statements.
 
diff --git a/src/runtime/symtab.go b/src/runtime/symtab.go
index e8c7447f61..6b535dfcbf 100644
--- a/src/runtime/symtab.go
+++ b/src/runtime/symtab.go
@@ -281,6 +281,7 @@ const (
 	_FUNCDATA_StackObjects       = 2
 	_FUNCDATA_InlTree            = 3
 	_FUNCDATA_OpenCodedDeferInfo = 4
+	_FUNCDATA_ArgInfo            = 5
 
 	_ArgsSizeUnknown = -0x80000000
 )
diff --git a/src/runtime/traceback.go b/src/runtime/traceback.go
index 0969af1a21..167d51c452 100644
--- a/src/runtime/traceback.go
+++ b/src/runtime/traceback.go
@@ -457,17 +457,8 @@ func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max in
 					name = "panic"
 				}
 				print(name, "(")
-				argp := (*[100]uintptr)(unsafe.Pointer(frame.argp))
-				for i := uintptr(0); i < frame.arglen/sys.PtrSize; i++ {
-					if i >= 10 {
-						print(", ...")
-						break
-					}
-					if i != 0 {
-						print(", ")
-					}
-					print(hex(argp[i]))
-				}
+				argp := unsafe.Pointer(frame.argp)
+				printArgs(f, argp)
 				print(")\n")
 				print("\t", file, ":", line)
 				if frame.pc > f.entry {
@@ -579,6 +570,82 @@ func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max in
 	return n
 }
 
+// printArgs prints function arguments in traceback.
+func printArgs(f funcInfo, argp unsafe.Pointer) {
+	// The "instruction" of argument printing is encoded in _FUNCDATA_ArgInfo.
+	// See cmd/compile/internal/ssagen.emitArgInfo for the description of the
+	// encoding.
+	// These constants need to be in sync with the compiler.
+	const (
+		_endSeq         = 0xff
+		_startAgg       = 0xfe
+		_endAgg         = 0xfd
+		_dotdotdot      = 0xfc
+		_offsetTooLarge = 0xfb
+	)
+
+	const (
+		limit    = 10                       // print no more than 10 args/components
+		maxDepth = 5                        // no more than 5 layers of nesting
+		maxLen   = (maxDepth*3+2)*limit + 1 // max length of _FUNCDATA_ArgInfo (see the compiler side for reasoning)
+	)
+
+	p := (*[maxLen]uint8)(funcdata(f, _FUNCDATA_ArgInfo))
+	if p == nil {
+		return
+	}
+
+	print1 := func(off, sz uint8) {
+		x := readUnaligned64(add(argp, uintptr(off)))
+		// mask out irrelavant bits
+		if sz < 8 {
+			shift := 64 - sz*8
+			if sys.BigEndian {
+				x = x >> shift
+			} else {
+				x = x << shift >> shift
+			}
+		}
+		print(hex(x))
+	}
+
+	start := true
+	printcomma := func() {
+		if !start {
+			print(", ")
+		}
+	}
+	pi := 0
+printloop:
+	for {
+		o := p[pi]
+		pi++
+		switch o {
+		case _endSeq:
+			break printloop
+		case _startAgg:
+			printcomma()
+			print("{")
+			start = true
+			continue
+		case _endAgg:
+			print("}")
+		case _dotdotdot:
+			printcomma()
+			print("...")
+		case _offsetTooLarge:
+			printcomma()
+			print("_")
+		default:
+			printcomma()
+			sz := p[pi]
+			pi++
+			print1(o, sz)
+		}
+		start = false
+	}
+}
+
 // reflectMethodValue is a partial duplicate of reflect.makeFuncImpl
 // and reflect.methodValue.
 type reflectMethodValue struct {
diff --git a/src/runtime/traceback_test.go b/src/runtime/traceback_test.go
new file mode 100644
index 0000000000..2a0497e9a9
--- /dev/null
+++ b/src/runtime/traceback_test.go
@@ -0,0 +1,121 @@
+// Copyright 2021 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 runtime_test
+
+import (
+	"bytes"
+	"runtime"
+	"testing"
+)
+
+var testTracebackArgsBuf [1000]byte
+
+func TestTracebackArgs(t *testing.T) {
+	tests := []struct {
+		fn     func() int
+		expect string
+	}{
+		// simple ints
+		{
+			func() int { return testTracebackArgs1(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12) },
+			"testTracebackArgs1(0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, ...)",
+		},
+		// some aggregates
+		{
+			func() int {
+				return testTracebackArgs2(false, struct {
+					a, b, c int
+					x       [2]int
+				}{1, 2, 3, [2]int{4, 5}}, [0]int{}, [3]byte{6, 7, 8})
+			},
+			"testTracebackArgs2(0x0, {0x1, 0x2, 0x3, {0x4, 0x5}}, {}, {0x6, 0x7, 0x8})",
+		},
+		{
+			func() int { return testTracebackArgs3([3]byte{1, 2, 3}, 4, 5, 6, [3]byte{7, 8, 9}) },
+			"testTracebackArgs3({0x1, 0x2, 0x3}, 0x4, 0x5, 0x6, {0x7, 0x8, 0x9})",
+		},
+		// too deeply nested type
+		{
+			func() int { return testTracebackArgs4(false, [1][1][1][1][1][1][1][1][1][1]int{}) },
+			"testTracebackArgs4(0x0, {{{{{...}}}}})",
+		},
+		// a lot of zero-sized type
+		{
+			func() int {
+				z := [0]int{}
+				return testTracebackArgs5(false, struct {
+					x int
+					y [0]int
+					z [2][0]int
+				}{1, z, [2][0]int{}}, z, z, z, z, z, z, z, z, z, z, z, z)
+			},
+			"testTracebackArgs5(0x0, {0x1, {}, {{}, {}}}, {}, {}, {}, {}, {}, ...)",
+		},
+	}
+	for _, test := range tests {
+		n := test.fn()
+		got := testTracebackArgsBuf[:n]
+		if !bytes.Contains(got, []byte(test.expect)) {
+			t.Errorf("traceback does not contain expected string: want %q, got\n%s", test.expect, got)
+		}
+	}
+}
+
+//go:noinline
+func testTracebackArgs1(a, b, c, d, e, f, g, h, i, j, k, l int) int {
+	n := runtime.Stack(testTracebackArgsBuf[:], false)
+	if a < 0 {
+		// use in-reg args to keep them alive
+		return a + b + c + d + e + f + g + h + i + j + k + l
+	}
+	return n
+}
+
+//go:noinline
+func testTracebackArgs2(a bool, b struct {
+	a, b, c int
+	x       [2]int
+}, _ [0]int, d [3]byte) int {
+	n := runtime.Stack(testTracebackArgsBuf[:], false)
+	if a {
+		// use in-reg args to keep them alive
+		return b.a + b.b + b.c + b.x[0] + b.x[1] + int(d[0]) + int(d[1]) + int(d[2])
+	}
+	return n
+
+}
+
+//go:noinline
+//go:registerparams
+func testTracebackArgs3(x [3]byte, a, b, c int, y [3]byte) int {
+	n := runtime.Stack(testTracebackArgsBuf[:], false)
+	if a < 0 {
+		// use in-reg args to keep them alive
+		return int(x[0]) + int(x[1]) + int(x[2]) + a + b + c + int(y[0]) + int(y[1]) + int(y[2])
+	}
+	return n
+}
+
+//go:noinline
+func testTracebackArgs4(a bool, x [1][1][1][1][1][1][1][1][1][1]int) int {
+	n := runtime.Stack(testTracebackArgsBuf[:], false)
+	if a {
+		panic(x) // use args to keep them alive
+	}
+	return n
+}
+
+//go:noinline
+func testTracebackArgs5(a bool, x struct {
+	x int
+	y [0]int
+	z [2][0]int
+}, _, _, _, _, _, _, _, _, _, _, _, _ [0]int) int {
+	n := runtime.Stack(testTracebackArgsBuf[:], false)
+	if a {
+		panic(x) // use args to keep them alive
+	}
+	return n
+}
-- 
GitLab


From 9c1b769d5fdd419bbaf416bc51981f0ba2af0831 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 16 Apr 2021 17:06:02 -0400
Subject: [PATCH 1716/2400] cmd/go: add a source file in the multiple-paths
 module in TestScript/mod_tidy_replace
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This situation is analogous to CL 309334: the test expects 'go mod
tidy' to fail due to a module used for more than one path in the build
list, but doesn't actually contain any packages or imports — so no
module is necessarily used at all, and the error only occurs if we
report it prematurely.

For #36460

Change-Id: I5ccecf30f280895eba913a8d62571872b75e710d
Reviewed-on: https://go-review.googlesource.com/c/go/+/312098
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/testdata/script/mod_tidy_replace.txt | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/cmd/go/testdata/script/mod_tidy_replace.txt b/src/cmd/go/testdata/script/mod_tidy_replace.txt
index dd99438891..297f6a6a45 100644
--- a/src/cmd/go/testdata/script/mod_tidy_replace.txt
+++ b/src/cmd/go/testdata/script/mod_tidy_replace.txt
@@ -136,3 +136,10 @@ require (
 )
 
 replace not-rsc.io/quote/v3 => rsc.io/quote/v3 v3.0.0
+-- multiple-paths/use.go --
+package quoter
+
+import (
+	_ "not-rsc.io/quote/v3"
+	_ "rsc.io/quote/v3"
+)
-- 
GitLab


From 1a5665533be3641511b72dac5b91f1c7500e40b5 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Thu, 25 Mar 2021 23:26:56 -0400
Subject: [PATCH 1717/2400] cmd/go/internal/modload: migrate editBuildList to
 use a structured requirement graph

For #36460

Change-Id: Ic87d7e25402bb938d2872d33d26c4bf397776d1b
Reviewed-on: https://go-review.googlesource.com/c/go/+/308517
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modload/buildlist.go      |  66 ---
 src/cmd/go/internal/modload/edit.go           | 446 ++++++++++++++----
 .../go/testdata/script/mod_load_badchain.txt  |   3 +-
 3 files changed, 356 insertions(+), 159 deletions(-)

diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index 2e79e85127..a833dbee62 100644
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -12,7 +12,6 @@ import (
 	"context"
 	"fmt"
 	"os"
-	"reflect"
 	"runtime"
 	"strings"
 	"sync"
@@ -455,71 +454,6 @@ func EditBuildList(ctx context.Context, add, mustSelect []module.Version) (chang
 	return changed, err
 }
 
-func editRequirements(ctx context.Context, rs *Requirements, add, mustSelect []module.Version) (edited *Requirements, changed bool, err error) {
-	mg, err := rs.Graph(ctx)
-	if err != nil {
-		return nil, false, err
-	}
-	buildList := mg.BuildList()
-
-	final, err := editBuildList(ctx, buildList, add, mustSelect)
-	if err != nil {
-		return nil, false, err
-	}
-
-	if !reflect.DeepEqual(final, buildList) {
-		changed = true
-	} else if len(mustSelect) == 0 {
-		// No change to the build list and no explicit roots to promote, so we're done.
-		return rs, false, nil
-	}
-
-	var rootPaths []string
-	for _, m := range mustSelect {
-		if m.Version != "none" && m.Path != Target.Path {
-			rootPaths = append(rootPaths, m.Path)
-		}
-	}
-	for _, m := range final[1:] {
-		if v, ok := rs.rootSelected(m.Path); ok && (v == m.Version || rs.direct[m.Path]) {
-			// m.Path was formerly a root, and either its version hasn't changed or
-			// we believe that it provides a package directly imported by a package
-			// or test in the main module. For now we'll assume that it is still
-			// relevant. If we actually load all of the packages and tests in the
-			// main module (which we are not doing here), we can revise the explicit
-			// roots at that point.
-			rootPaths = append(rootPaths, m.Path)
-		}
-	}
-
-	if go117LazyTODO {
-		// mvs.Req is not lazy, and in a lazily-loaded module we don't want
-		// to minimize the roots anyway. (Instead, we want to retain explicit
-		// root paths so that they remain explicit: only 'go mod tidy' should
-		// remove roots.)
-	}
-
-	min, err := mvs.Req(Target, rootPaths, &mvsReqs{roots: final[1:]})
-	if err != nil {
-		return nil, false, err
-	}
-
-	// A module that is not even in the build list necessarily cannot provide
-	// any imported packages. Mark as direct only the direct modules that are
-	// still in the build list.
-	//
-	// TODO(bcmills): Would it make more sense to leave the direct map as-is
-	// but allow it to refer to modules that are no longer in the build list?
-	// That might complicate updateRoots, but it may be cleaner in other ways.
-	direct := make(map[string]bool, len(rs.direct))
-	for _, m := range final {
-		if rs.direct[m.Path] {
-			direct[m.Path] = true
-		}
-	}
-	return newRequirements(rs.depth, min, direct), changed, nil
-}
-
 // A ConstraintError describes inconsistent constraints in EditBuildList
 type ConstraintError struct {
 	// Conflict lists the source of the conflict for each version in mustSelect
diff --git a/src/cmd/go/internal/modload/edit.go b/src/cmd/go/internal/modload/edit.go
index 858fec5dd5..2921b38157 100644
--- a/src/cmd/go/internal/modload/edit.go
+++ b/src/cmd/go/internal/modload/edit.go
@@ -5,100 +5,321 @@
 package modload
 
 import (
+	"cmd/go/internal/mvs"
 	"context"
+	"reflect"
 	"sort"
 
-	"cmd/go/internal/mvs"
-
 	"golang.org/x/mod/module"
 	"golang.org/x/mod/semver"
 )
 
-// editBuildList returns an edited version of initial such that:
+// editRequirements returns an edited version of rs such that:
 //
 // 	1. Each module version in mustSelect is selected.
 //
 // 	2. Each module version in tryUpgrade is upgraded toward the indicated
 // 	   version as far as can be done without violating (1).
 //
-// 	3. Each module version in initial is downgraded from its original version
-// 	   only to the extent needed to satisfy (1), or upgraded only to the extent
-// 	   needed to satisfy (1) and (2).
+// 	3. Each module version in rs.rootModules (or rs.graph, if rs.depth is eager)
+// 	   is downgraded from its original version only to the extent needed to
+// 	   satisfy (1), or upgraded only to the extent needed to satisfy (1) and
+// 	   (2).
 //
 // 	4. No module is upgraded above the maximum version of its path found in the
-// 	   combined dependency graph of list, tryUpgrade, and mustSelect.
-func editBuildList(ctx context.Context, initial, tryUpgrade, mustSelect []module.Version) ([]module.Version, error) {
-	// Per https://research.swtch.com/vgo-mvs#algorithm_4:
-	// “To avoid an unnecessary downgrade to E 1.1, we must also add a new
-	// requirement on E 1.2. We can apply Algorithm R to find the minimal set of
-	// new requirements to write to go.mod.”
-	//
-	// In order to generate those new requirements, we need consider versions for
-	// every module in the existing build list, plus every module being directly
-	// added by the edit. However, modules added only as dependencies of tentative
-	// versions should not be retained if they end up being upgraded or downgraded
-	// away due to versions in mustSelect.
-
-	// When we downgrade modules in order to reach mustSelect, we don't want to
-	// upgrade any existing module above the version that would be selected if we
-	// just added all of the new requirements and *didn't* downgrade.
-	//
-	// So we'll do exactly that: just add all of the new requirements and not
-	// downgrade, and return the resulting versions as an upper bound. This
-	// intentionally limits our solution space so that edits that the user
-	// percieves as “downgrades” will not also result in upgrades.
-	max := make(map[string]string)
-	maxes, err := mvs.Upgrade(Target, &mvsReqs{
-		roots: append(capVersionSlice(initial[1:]), mustSelect...),
-	}, tryUpgrade...)
+// 	   dependency graph of rs, the combined dependency graph of the versions in
+// 	   mustSelect, or the dependencies of each individual module version in
+// 	   tryUpgrade.
+//
+// Generally, the module versions in mustSelect are due to the module or a
+// package within the module matching an explicit command line argument to 'go
+// get', and the versions in tryUpgrade are transitive dependencies that are
+// either being upgraded by 'go get -u' or being added to satisfy some
+// otherwise-missing package import.
+func editRequirements(ctx context.Context, rs *Requirements, tryUpgrade, mustSelect []module.Version) (edited *Requirements, changed bool, err error) {
+	limiter, err := limiterForEdit(ctx, rs, tryUpgrade, mustSelect)
 	if err != nil {
-		return nil, err
-	}
-	for _, m := range maxes {
-		max[m.Path] = m.Version
-	}
-	// The versions in mustSelect override whatever we would naively select —
-	// we will downgrade other modules as needed in order to meet them.
-	for _, m := range mustSelect {
-		max[m.Path] = m.Version
+		return rs, false, err
 	}
 
-	limiter := newVersionLimiter(max)
-
 	var conflicts []Conflict
 	for _, m := range mustSelect {
-		dq := limiter.check(m)
-		switch {
-		case dq.err != nil:
-			return nil, err
-		case dq.conflict != module.Version{}:
+		conflict, err := limiter.Select(m)
+		if err != nil {
+			return rs, false, err
+		}
+		if conflict.Path != "" {
 			conflicts = append(conflicts, Conflict{
 				Source: m,
-				Dep:    dq.conflict,
+				Dep:    conflict,
 				Constraint: module.Version{
-					Path:    dq.conflict.Path,
-					Version: limiter.max[dq.conflict.Path],
+					Path:    conflict.Path,
+					Version: limiter.max[conflict.Path],
 				},
 			})
 		}
-		limiter.selected[m.Path] = m.Version
 	}
 	if len(conflicts) > 0 {
-		return nil, &ConstraintError{Conflicts: conflicts}
+		return rs, false, &ConstraintError{Conflicts: conflicts}
+	}
+
+	mods, changed, err := selectPotentiallyImportedModules(ctx, limiter, rs, tryUpgrade)
+	if err != nil {
+		return rs, false, err
+	}
+
+	var roots []module.Version
+	if rs.depth == eager {
+		// In an eager module, modules that provide packages imported by the main
+		// module may either be explicit roots or implicit transitive dependencies.
+		// We promote the modules in mustSelect to be explicit requirements.
+		var rootPaths []string
+		for _, m := range mustSelect {
+			if m.Version != "none" && m.Path != Target.Path {
+				rootPaths = append(rootPaths, m.Path)
+			}
+		}
+		if !changed && len(rootPaths) == 0 {
+			// The build list hasn't changed and we have no new roots to add.
+			// We don't need to recompute the minimal roots for the module.
+			return rs, false, nil
+		}
+
+		for _, m := range mods {
+			if v, ok := rs.rootSelected(m.Path); ok && (v == m.Version || rs.direct[m.Path]) {
+				// m.Path was formerly a root, and either its version hasn't changed or
+				// we believe that it provides a package directly imported by a package
+				// or test in the main module. For now we'll assume that it is still
+				// relevant enough to remain a root. If we actually load all of the
+				// packages and tests in the main module (which we are not doing here),
+				// we can revise the explicit roots at that point.
+				rootPaths = append(rootPaths, m.Path)
+			}
+		}
+
+		roots, err = mvs.Req(Target, rootPaths, &mvsReqs{roots: mods})
+		if err != nil {
+			return nil, false, err
+		}
+	} else {
+		// In a lazy module, every module that provides a package imported by the
+		// main module must be retained as a root.
+		roots = mods
+		if !changed {
+			// Because the roots we just computed are unchanged, the entire graph must
+			// be the same as it was before. Save the original rs, since we have
+			// probably already loaded its requirement graph.
+			return rs, false, nil
+		}
+	}
+
+	// A module that is not even in the build list necessarily cannot provide
+	// any imported packages. Mark as direct only the direct modules that are
+	// still in the build list.
+	//
+	// TODO(bcmills): Would it make more sense to leave the direct map as-is
+	// but allow it to refer to modules that are no longer in the build list?
+	// That might complicate updateRoots, but it may be cleaner in other ways.
+	direct := make(map[string]bool, len(rs.direct))
+	for _, m := range roots {
+		if rs.direct[m.Path] {
+			direct[m.Path] = true
+		}
+	}
+	return newRequirements(rs.depth, roots, direct), changed, nil
+}
+
+// limiterForEdit returns a versionLimiter with its max versions set such that
+// the max version for every module path in mustSelect is the version listed
+// there, and the max version for every other module path is the maximum version
+// of its path found in the dependency graph of rs, the combined dependency
+// graph of the versions in mustSelect, or the dependencies of each individual
+// module version in tryUpgrade.
+func limiterForEdit(ctx context.Context, rs *Requirements, tryUpgrade, mustSelect []module.Version) (*versionLimiter, error) {
+	mg, err := rs.Graph(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	maxVersion := map[string]string{} // module path → version
+	restrictTo := func(m module.Version) {
+		v, ok := maxVersion[m.Path]
+		if !ok || cmpVersion(v, m.Version) > 0 {
+			maxVersion[m.Path] = m.Version
+		}
+	}
+
+	if rs.depth == eager {
+		// Eager go.mod files don't indicate which transitive dependencies are
+		// actually relevant to the main module, so we have to assume that any module
+		// that could have provided any package — that is, any module whose selected
+		// version was not "none" — may be relevant.
+		for _, m := range mg.BuildList() {
+			restrictTo(m)
+		}
+	} else {
+		// The go.mod file explicitly records every module that provides a package
+		// imported by the main module.
+		//
+		// If we need to downgrade an existing root or a new root found in
+		// tryUpgrade, we don't want to allow that downgrade to incidentally upgrade
+		// a module imported by the main module to some arbitrary version.
+		// However, we don't particularly care about arbitrary upgrades to modules
+		// that are (at best) only providing packages imported by tests of
+		// dependencies outside the main module.
+		for _, m := range rs.rootModules {
+			restrictTo(module.Version{
+				Path:    m.Path,
+				Version: mg.Selected(m.Path),
+			})
+		}
+	}
+
+	if err := raiseLimitsForUpgrades(ctx, maxVersion, rs.depth, tryUpgrade, mustSelect); err != nil {
+		return nil, err
+	}
+
+	// The versions in mustSelect override whatever we would naively select —
+	// we will downgrade other modules as needed in order to meet them.
+	for _, m := range mustSelect {
+		restrictTo(m)
+	}
+
+	return newVersionLimiter(rs.depth, maxVersion), nil
+}
+
+// raiseLimitsForUpgrades increases the module versions in maxVersions to the
+// versions that would be needed to allow each of the modules in tryUpgrade
+// (individually) and all of the modules in mustSelect (simultaneously) to be
+// added as roots.
+//
+// Versions not present in maxVersion are unrestricted, and it is assumed that
+// they will not be promoted to root requirements (and thus will not contribute
+// their own dependencies if the main module is lazy).
+//
+// These limits provide an upper bound on how far a module may be upgraded as
+// part of an incidental downgrade, if downgrades are needed in order to select
+// the versions in mustSelect.
+func raiseLimitsForUpgrades(ctx context.Context, maxVersion map[string]string, depth modDepth, tryUpgrade []module.Version, mustSelect []module.Version) error {
+	// allow raises the limit for m.Path to at least m.Version.
+	// If m.Path was already unrestricted, it remains unrestricted.
+	allow := func(m module.Version) {
+		v, ok := maxVersion[m.Path]
+		if !ok {
+			return // m.Path is unrestricted.
+		}
+		if cmpVersion(v, m.Version) < 0 {
+			maxVersion[m.Path] = m.Version
+		}
+	}
+
+	var eagerUpgrades []module.Version
+	if depth == eager {
+		eagerUpgrades = tryUpgrade
+	} else {
+		for _, m := range tryUpgrade {
+			if m.Path == Target.Path {
+				// Target is already considered to be higher than any possible m, so we
+				// won't be upgrading to it anyway and there is no point scanning its
+				// dependencies.
+				continue
+			}
+
+			summary, err := goModSummary(m)
+			if err != nil {
+				return err
+			}
+			if summary.depth() == eager {
+				// For efficiency, we'll load all of the eager upgrades as one big
+				// graph, rather than loading the (potentially-overlapping) subgraph for
+				// each upgrade individually.
+				eagerUpgrades = append(eagerUpgrades, m)
+				continue
+			}
+
+			for _, r := range summary.require {
+				allow(r)
+			}
+		}
 	}
 
-	// For each module, we want to get as close as we can to either the upgrade
-	// version or the previously-selected version in the build list, whichever is
-	// higher. We can compute those in either order, but the upgrades will tend to
-	// be higher than the build list, so we arbitrarily start with those.
+	if len(eagerUpgrades) > 0 {
+		// Compute the max versions for eager upgrades all together.
+		// Since these modules are eager, we'll end up scanning all of their
+		// transitive dependencies no matter which versions end up selected,
+		// and since we have a large dependency graph to scan we might get
+		// a significant benefit from not revisiting dependencies that are at
+		// common versions among multiple upgrades.
+		upgradeGraph, err := readModGraph(ctx, eager, eagerUpgrades)
+		if err != nil {
+			if go117LazyTODO {
+				// Compute the requirement path from a module path in tryUpgrade to the
+				// error, and the requirement path (if any) from rs.rootModules to the
+				// tryUpgrade module path. Return a *mvs.BuildListError showing the
+				// concatenation of the paths (with an upgrade in the middle).
+			}
+			return err
+		}
+
+		for _, r := range upgradeGraph.BuildList() {
+			// Upgrading to m would upgrade to r, and the caller requested that we
+			// try to upgrade to m, so it's ok to upgrade to r.
+			allow(r)
+		}
+	}
+
+	if len(mustSelect) > 0 {
+		mustGraph, err := readModGraph(ctx, depth, mustSelect)
+		if err != nil {
+			return err
+		}
+
+		for _, r := range mustGraph.BuildList() {
+			// Some module in mustSelect requires r, so we must allow at least r.Version
+			// unless it conflicts with an entry in mustSelect.
+			allow(r)
+		}
+	}
+
+	return nil
+}
+
+// selectPotentiallyImportedModules increases the limiter-selected version of
+// every module in rs that potentially provides a package imported (directly or
+// indirectly) by the main module, and every module in tryUpgrade, toward the
+// highest version seen in rs or tryUpgrade, but not above the maximums enforced
+// by the limiter.
+//
+// It returns the list of module versions selected by the limiter, sorted by
+// path, along with a boolean indicating whether that list is different from the
+// list of modules read from rs.
+func selectPotentiallyImportedModules(ctx context.Context, limiter *versionLimiter, rs *Requirements, tryUpgrade []module.Version) (mods []module.Version, changed bool, err error) {
 	for _, m := range tryUpgrade {
-		if err := limiter.upgradeToward(ctx, m); err != nil {
-			return nil, err
+		if err := limiter.UpgradeToward(ctx, m); err != nil {
+			return nil, false, err
+		}
+	}
+
+	var initial []module.Version
+	if rs.depth == eager {
+		mg, err := rs.Graph(ctx)
+		if err != nil {
+			return nil, false, err
 		}
+		initial = mg.BuildList()[1:]
+	} else {
+		initial = rs.rootModules
 	}
 	for _, m := range initial {
-		if err := limiter.upgradeToward(ctx, m); err != nil {
-			return nil, err
+		if err := limiter.UpgradeToward(ctx, m); err != nil {
+			return nil, false, err
+		}
+	}
+
+	mods = make([]module.Version, 0, len(limiter.selected))
+	for path, v := range limiter.selected {
+		if v != "none" && path != Target.Path {
+			mods = append(mods, module.Version{Path: path, Version: v})
 		}
 	}
 
@@ -107,46 +328,46 @@ func editBuildList(ctx context.Context, initial, tryUpgrade, mustSelect []module
 	// downgraded module may require a higher (but still allowed) version of
 	// another. The lower version may require extraneous dependencies that aren't
 	// actually relevant, so we need to compute the actual selected versions.
-	adjusted := make([]module.Version, 0, len(maxes))
-	for _, m := range maxes[1:] {
-		if v, ok := limiter.selected[m.Path]; ok {
-			adjusted = append(adjusted, module.Version{Path: m.Path, Version: v})
-		}
-	}
-	consistent, err := mvs.BuildList(Target, &mvsReqs{roots: adjusted})
+	mg, err := readModGraph(ctx, rs.depth, mods)
 	if err != nil {
-		return nil, err
+		return nil, false, err
 	}
-
-	// We have the correct selected versions. Now we need to re-run MVS with only
-	// the actually-selected versions in order to eliminate extraneous
-	// dependencies from lower-than-selected ones.
-	compacted := consistent[:0]
-	for _, m := range consistent[1:] {
-		if _, ok := limiter.selected[m.Path]; ok {
-			// The fact that the limiter has a version for m.Path indicates that we
-			// care about retaining that path, even if the version was upgraded for
-			// consistency.
-			compacted = append(compacted, m)
+	mods = make([]module.Version, 0, len(limiter.selected))
+	for path, _ := range limiter.selected {
+		if path != Target.Path {
+			if v := mg.Selected(path); v != "none" {
+				mods = append(mods, module.Version{Path: path, Version: v})
+			}
 		}
 	}
+	module.Sort(mods)
+
+	changed = !reflect.DeepEqual(mods, initial)
 
-	return mvs.BuildList(Target, &mvsReqs{roots: compacted})
+	return mods, changed, err
 }
 
 // A versionLimiter tracks the versions that may be selected for each module
 // subject to constraints on the maximum versions of transitive dependencies.
 type versionLimiter struct {
+	// depth is the depth at which the dependencies of the modules passed to
+	// Select and UpgradeToward are loaded.
+	depth modDepth
+
 	// max maps each module path to the maximum version that may be selected for
-	// that path. Paths with no entry are unrestricted.
+	// that path.
+	//
+	// Paths with no entry are unrestricted, and we assume that they will not be
+	// promoted to root dependencies (so will not contribute dependencies if the
+	// main module is lazy).
 	max map[string]string
 
 	// selected maps each module path to a version of that path (if known) whose
 	// transitive dependencies do not violate any max version. The version kept
-	// is the highest one found during any call to upgradeToward for the given
+	// is the highest one found during any call to UpgradeToward for the given
 	// module path.
 	//
-	// If a higher acceptable version is found during a call to upgradeToward for
+	// If a higher acceptable version is found during a call to UpgradeToward for
 	// some *other* module path, that does not update the selected version.
 	// Ignoring those versions keeps the downgrades computed for two modules
 	// together close to the individual downgrades that would be computed for each
@@ -183,18 +404,32 @@ func (dq dqState) isDisqualified() bool {
 	return dq != dqState{}
 }
 
-func newVersionLimiter(max map[string]string) *versionLimiter {
+// newVersionLimiter returns a versionLimiter that restricts the module paths
+// that appear as keys in max.
+//
+// max maps each module path to its maximum version; paths that are not present
+// in the map are unrestricted. The limiter assumes that unrestricted paths will
+// not be promoted to root dependencies.
+//
+// If depth is lazy, then if a module passed to UpgradeToward or Select is
+// itself lazy, its unrestricted dependencies are skipped when scanning
+// requirements.
+func newVersionLimiter(depth modDepth, max map[string]string) *versionLimiter {
 	return &versionLimiter{
-		selected:  map[string]string{Target.Path: Target.Version},
+		depth:     depth,
 		max:       max,
+		selected:  map[string]string{Target.Path: Target.Version},
 		dqReason:  map[module.Version]dqState{},
 		requiring: map[module.Version][]module.Version{},
 	}
 }
 
-// upgradeToward attempts to upgrade the selected version of m.Path as close as
+// UpgradeToward attempts to upgrade the selected version of m.Path as close as
 // possible to m.Version without violating l's maximum version limits.
-func (l *versionLimiter) upgradeToward(ctx context.Context, m module.Version) error {
+//
+// If depth is lazy and m itself is lazy, the the dependencies of unrestricted
+// dependencies of m will not be followed.
+func (l *versionLimiter) UpgradeToward(ctx context.Context, m module.Version) error {
 	selected, ok := l.selected[m.Path]
 	if ok {
 		if cmpVersion(selected, m.Version) >= 0 {
@@ -205,7 +440,7 @@ func (l *versionLimiter) upgradeToward(ctx context.Context, m module.Version) er
 		selected = "none"
 	}
 
-	if l.check(m).isDisqualified() {
+	if l.check(m, l.depth).isDisqualified() {
 		candidates, err := versions(ctx, m.Path, CheckAllowed)
 		if err != nil {
 			// This is likely a transient error reaching the repository,
@@ -222,7 +457,7 @@ func (l *versionLimiter) upgradeToward(ctx context.Context, m module.Version) er
 		})
 		candidates = candidates[:i]
 
-		for l.check(m).isDisqualified() {
+		for l.check(m, l.depth).isDisqualified() {
 			n := len(candidates)
 			if n == 0 || cmpVersion(selected, candidates[n-1]) >= 0 {
 				// We couldn't find a suitable candidate above the already-selected version.
@@ -237,9 +472,26 @@ func (l *versionLimiter) upgradeToward(ctx context.Context, m module.Version) er
 	return nil
 }
 
+// Select attempts to set the selected version of m.Path to exactly m.Version.
+func (l *versionLimiter) Select(m module.Version) (conflict module.Version, err error) {
+	dq := l.check(m, l.depth)
+	if !dq.isDisqualified() {
+		l.selected[m.Path] = m.Version
+	}
+	return dq.conflict, dq.err
+}
+
 // check determines whether m (or its transitive dependencies) would violate l's
 // maximum version limits if added to the module requirement graph.
-func (l *versionLimiter) check(m module.Version) dqState {
+//
+// If depth is lazy and m itself is lazy, then the dependencies of unrestricted
+// dependencies of m will not be followed. If the lazy loading invariants hold
+// for the main module up to this point, the packages in those modules are at
+// best only imported by tests of dependencies that are themselves loaded from
+// outside modules. Although we would like to keep 'go test all' as reproducible
+// as is feasible, we don't want to retain test dependencies that are only
+// marginally relevant at best.
+func (l *versionLimiter) check(m module.Version, depth modDepth) dqState {
 	if m.Version == "none" || m == Target {
 		// version "none" has no requirements, and the dependencies of Target are
 		// tautological.
@@ -270,8 +522,20 @@ func (l *versionLimiter) check(m module.Version) dqState {
 		return l.disqualify(m, dqState{err: err})
 	}
 
+	if summary.depth() == eager {
+		depth = eager
+	}
 	for _, r := range summary.require {
-		if dq := l.check(r); dq.isDisqualified() {
+		if depth == lazy {
+			if _, restricted := l.max[r.Path]; !restricted {
+				// r.Path is unrestricted, so we don't care at what version it is
+				// selected. We assume that r.Path will not become a root dependency, so
+				// since m is lazy, r's dependencies won't be followed.
+				continue
+			}
+		}
+
+		if dq := l.check(r, depth); dq.isDisqualified() {
 			return l.disqualify(m, dq)
 		}
 
diff --git a/src/cmd/go/testdata/script/mod_load_badchain.txt b/src/cmd/go/testdata/script/mod_load_badchain.txt
index 9e28b2d9a4..8cb7eec0aa 100644
--- a/src/cmd/go/testdata/script/mod_load_badchain.txt
+++ b/src/cmd/go/testdata/script/mod_load_badchain.txt
@@ -69,8 +69,7 @@ import (
 
 func Test(t *testing.T) {}
 -- update-main-expected --
-go get: example.com/badchain/c@v1.0.0 updating to
-	example.com/badchain/c@v1.1.0: parsing go.mod:
+go get: example.com/badchain/c@v1.1.0: parsing go.mod:
 	module declares its path as: badchain.example.com/c
 	        but was required as: example.com/badchain/c
 -- update-a-expected --
-- 
GitLab


From b6ff3c69d5fdf933f5265f95ae4bb12eaecc792f Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 22 Apr 2021 13:45:19 -0400
Subject: [PATCH 1718/2400] cmd/link: support more load commands on Mach-O

Change-Id: I74dd9170a51cc93ce3ec5e5860c2eb2912f081f5
Reviewed-on: https://go-review.googlesource.com/c/go/+/312729
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/link/internal/ld/macho.go               |  4 ++++
 src/cmd/link/internal/ld/macho_combine_dwarf.go | 12 ++++++++++--
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/src/cmd/link/internal/ld/macho.go b/src/cmd/link/internal/ld/macho.go
index 85269b30d0..ad53e45b38 100644
--- a/src/cmd/link/internal/ld/macho.go
+++ b/src/cmd/link/internal/ld/macho.go
@@ -88,6 +88,8 @@ const (
 	MACHO_SUBCPU_ARMV7                   = 9
 	MACHO_CPU_ARM64                      = 1<<24 | 12
 	MACHO_SUBCPU_ARM64_ALL               = 0
+	MACHO_SUBCPU_ARM64_V8                = 1
+	MACHO_SUBCPU_ARM64E                  = 2
 	MACHO32SYMSIZE                       = 12
 	MACHO64SYMSIZE                       = 16
 	MACHO_X86_64_RELOC_UNSIGNED          = 0
@@ -178,6 +180,8 @@ const (
 	LC_VERSION_MIN_WATCHOS      = 0x30
 	LC_VERSION_NOTE             = 0x31
 	LC_BUILD_VERSION            = 0x32
+	LC_DYLD_EXPORTS_TRIE        = 0x80000033
+	LC_DYLD_CHAINED_FIXUPS      = 0x80000034
 )
 
 const (
diff --git a/src/cmd/link/internal/ld/macho_combine_dwarf.go b/src/cmd/link/internal/ld/macho_combine_dwarf.go
index ae873ca6fa..2ab7da967a 100644
--- a/src/cmd/link/internal/ld/macho_combine_dwarf.go
+++ b/src/cmd/link/internal/ld/macho_combine_dwarf.go
@@ -222,11 +222,19 @@ func machoCombineDwarf(ctxt *Link, exef *os.File, exem *macho.File, dsym, outexe
 			err = machoUpdateLoadCommand(reader, linkseg, linkoffset, &macho.SymtabCmd{}, "Symoff", "Stroff")
 		case macho.LoadCmdDysymtab:
 			err = machoUpdateLoadCommand(reader, linkseg, linkoffset, &macho.DysymtabCmd{}, "Tocoffset", "Modtaboff", "Extrefsymoff", "Indirectsymoff", "Extreloff", "Locreloff")
-		case LC_CODE_SIGNATURE, LC_SEGMENT_SPLIT_INFO, LC_FUNCTION_STARTS, LC_DATA_IN_CODE, LC_DYLIB_CODE_SIGN_DRS:
+		case LC_CODE_SIGNATURE, LC_SEGMENT_SPLIT_INFO, LC_FUNCTION_STARTS, LC_DATA_IN_CODE, LC_DYLIB_CODE_SIGN_DRS,
+			LC_DYLD_EXPORTS_TRIE, LC_DYLD_CHAINED_FIXUPS:
 			err = machoUpdateLoadCommand(reader, linkseg, linkoffset, &linkEditDataCmd{}, "DataOff")
 		case LC_ENCRYPTION_INFO, LC_ENCRYPTION_INFO_64:
 			err = machoUpdateLoadCommand(reader, linkseg, linkoffset, &encryptionInfoCmd{}, "CryptOff")
-		case macho.LoadCmdDylib, macho.LoadCmdThread, macho.LoadCmdUnixThread, LC_PREBOUND_DYLIB, LC_UUID, LC_VERSION_MIN_MACOSX, LC_VERSION_MIN_IPHONEOS, LC_SOURCE_VERSION, LC_MAIN, LC_LOAD_DYLINKER, LC_LOAD_WEAK_DYLIB, LC_REEXPORT_DYLIB, LC_RPATH, LC_ID_DYLIB, LC_SYMSEG, LC_LOADFVMLIB, LC_IDFVMLIB, LC_IDENT, LC_FVMFILE, LC_PREPAGE, LC_ID_DYLINKER, LC_ROUTINES, LC_SUB_FRAMEWORK, LC_SUB_UMBRELLA, LC_SUB_CLIENT, LC_SUB_LIBRARY, LC_TWOLEVEL_HINTS, LC_PREBIND_CKSUM, LC_ROUTINES_64, LC_LAZY_LOAD_DYLIB, LC_LOAD_UPWARD_DYLIB, LC_DYLD_ENVIRONMENT, LC_LINKER_OPTION, LC_LINKER_OPTIMIZATION_HINT, LC_VERSION_MIN_TVOS, LC_VERSION_MIN_WATCHOS, LC_VERSION_NOTE, LC_BUILD_VERSION:
+		case macho.LoadCmdDylib, macho.LoadCmdThread, macho.LoadCmdUnixThread,
+			LC_PREBOUND_DYLIB, LC_UUID, LC_VERSION_MIN_MACOSX, LC_VERSION_MIN_IPHONEOS, LC_SOURCE_VERSION,
+			LC_MAIN, LC_LOAD_DYLINKER, LC_LOAD_WEAK_DYLIB, LC_REEXPORT_DYLIB, LC_RPATH, LC_ID_DYLIB,
+			LC_SYMSEG, LC_LOADFVMLIB, LC_IDFVMLIB, LC_IDENT, LC_FVMFILE, LC_PREPAGE, LC_ID_DYLINKER,
+			LC_ROUTINES, LC_SUB_FRAMEWORK, LC_SUB_UMBRELLA, LC_SUB_CLIENT, LC_SUB_LIBRARY, LC_TWOLEVEL_HINTS,
+			LC_PREBIND_CKSUM, LC_ROUTINES_64, LC_LAZY_LOAD_DYLIB, LC_LOAD_UPWARD_DYLIB, LC_DYLD_ENVIRONMENT,
+			LC_LINKER_OPTION, LC_LINKER_OPTIMIZATION_HINT, LC_VERSION_MIN_TVOS, LC_VERSION_MIN_WATCHOS,
+			LC_VERSION_NOTE, LC_BUILD_VERSION:
 			// Nothing to update
 		default:
 			err = fmt.Errorf("unknown load command 0x%x (%s)", int(cmd.Cmd), cmd.Cmd)
-- 
GitLab


From ecfce58965da6017e02f5fc5c03eda52fc41c8d6 Mon Sep 17 00:00:00 2001
From: Michael Pratt <mpratt@google.com>
Date: Wed, 7 Apr 2021 12:01:44 -0400
Subject: [PATCH 1719/2400] runtime: skip work recheck for non-spinning Ms

When an M transitions from spinning to non-spinning state, it must
recheck most sources of work to avoid missing work submitted between its
initial check and decrementing sched.nmspinning (see "delicate dance"
comment).

Ever since the scheduler rewrite in Go 1.1 (golang.org/cl/7314062), we
have performed this recheck on all Ms before stopping, regardless of
whether or not they were spinning.

Unfortunately, there is a problem with this approach: non-spinning Ms
are not eligible to steal work (note the skip over the stealWork block),
but can detect work during the recheck. If there is work available, this
non-spinning M will jump to top, skip stealing, land in recheck again,
and repeat. i.e., it will spin uselessly.

The spin is bounded. This can only occur if there is another spinning M,
which will either take the work, allowing this M to stop, or take some
other work, allowing this M to upgrade to spinning. But the spinning is
ultimately just a fancy spin-wait.

golang.org/issue/43997 discusses several ways to address this. This CL
takes the simplest approach: skipping the recheck on non-spinning Ms and
allowing them to go to stop.

Results for scheduler-relevant runtime and time benchmarks can be found
at https://perf.golang.org/search?q=upload:20210420.5.

The new BenchmarkCreateGoroutinesSingle is a characteristic example
workload that hits this issue hard. A single M readies lots of work
without itself parking. Other Ms must spin to steal work, which is very
short-lived, forcing those Ms to spin again. Some of the Ms will be
non-spinning and hit the above bug.

With this fixed, that benchmark drops in CPU usage by a massive 68%, and
wall time 24%. BenchmarkNetpollBreak shows similar drops because it is
unintentionally almost the same benchmark (create short-living Gs in a
loop). Typical well-behaved programs show little change.

We also measure scheduling latency (time from goready to execute). Note
that many of these benchmarks are very noisy because they don't involve
much scheduling. Those that do, like CreateGoroutinesSingle, are
expected to increase as we are replacing unintentional spin waiting with
a real park.

Fixes #43997

Change-Id: Ie1d1e1800f393cee1792455412caaa5865d13562
Reviewed-on: https://go-review.googlesource.com/c/go/+/310850
Trust: Michael Pratt <mpratt@google.com>
Run-TryBot: Michael Pratt <mpratt@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/proc.go      | 58 +++++++++++++++++++++-------------------
 src/runtime/proc_test.go | 49 +++++++++++++++++++++++++++++++++
 2 files changed, 79 insertions(+), 28 deletions(-)

diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 5c7328aacc..37c051634c 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -2841,44 +2841,46 @@ top:
 		if int32(atomic.Xadd(&sched.nmspinning, -1)) < 0 {
 			throw("findrunnable: negative nmspinning")
 		}
-	}
 
-	// Check all runqueues once again.
-	_p_ = checkRunqsNoP(allpSnapshot, idlepMaskSnapshot)
-	if _p_ != nil {
-		acquirep(_p_)
-		if wasSpinning {
+		// Note the for correctness, only the last M transitioning from
+		// spinning to non-spinning must perform these rechecks to
+		// ensure no missed work. We are performing it on every M that
+		// transitions as a conservative change to monitor effects on
+		// latency. See golang.org/issue/43997.
+
+		// Check all runqueues once again.
+		_p_ = checkRunqsNoP(allpSnapshot, idlepMaskSnapshot)
+		if _p_ != nil {
+			acquirep(_p_)
 			_g_.m.spinning = true
 			atomic.Xadd(&sched.nmspinning, 1)
+			goto top
 		}
-		goto top
-	}
 
-	// Check for idle-priority GC work again.
-	_p_, gp = checkIdleGCNoP()
-	if _p_ != nil {
-		acquirep(_p_)
-		if wasSpinning {
+		// Check for idle-priority GC work again.
+		_p_, gp = checkIdleGCNoP()
+		if _p_ != nil {
+			acquirep(_p_)
 			_g_.m.spinning = true
 			atomic.Xadd(&sched.nmspinning, 1)
-		}
 
-		// Run the idle worker.
-		_p_.gcMarkWorkerMode = gcMarkWorkerIdleMode
-		casgstatus(gp, _Gwaiting, _Grunnable)
-		if trace.enabled {
-			traceGoUnpark(gp, 0)
+			// Run the idle worker.
+			_p_.gcMarkWorkerMode = gcMarkWorkerIdleMode
+			casgstatus(gp, _Gwaiting, _Grunnable)
+			if trace.enabled {
+				traceGoUnpark(gp, 0)
+			}
+			return gp, false
 		}
-		return gp, false
-	}
 
-	// Finally, check for timer creation or expiry concurrently with
-	// transitioning from spinning to non-spinning.
-	//
-	// Note that we cannot use checkTimers here because it calls
-	// adjusttimers which may need to allocate memory, and that isn't
-	// allowed when we don't have an active P.
-	pollUntil = checkTimersNoP(allpSnapshot, timerpMaskSnapshot, pollUntil)
+		// Finally, check for timer creation or expiry concurrently with
+		// transitioning from spinning to non-spinning.
+		//
+		// Note that we cannot use checkTimers here because it calls
+		// adjusttimers which may need to allocate memory, and that isn't
+		// allowed when we don't have an active P.
+		pollUntil = checkTimersNoP(allpSnapshot, timerpMaskSnapshot, pollUntil)
+	}
 
 	// Poll network until next timer.
 	if netpollinited() && (atomic.Load(&netpollWaiters) > 0 || pollUntil != 0) && atomic.Xchg64(&sched.lastpoll, 0) != 0 {
diff --git a/src/runtime/proc_test.go b/src/runtime/proc_test.go
index 767bde15b4..01152dff76 100644
--- a/src/runtime/proc_test.go
+++ b/src/runtime/proc_test.go
@@ -692,6 +692,55 @@ func BenchmarkCreateGoroutinesCapture(b *testing.B) {
 	}
 }
 
+// warmupScheduler ensures the scheduler has at least targetThreadCount threads
+// in its thread pool.
+func warmupScheduler(targetThreadCount int) {
+	var wg sync.WaitGroup
+	var count int32
+	for i := 0; i < targetThreadCount; i++ {
+		wg.Add(1)
+		go func() {
+			atomic.AddInt32(&count, 1)
+			for atomic.LoadInt32(&count) < int32(targetThreadCount) {
+				// spin until all threads started
+			}
+
+			// spin a bit more to ensure they are all running on separate CPUs.
+			doWork(time.Millisecond)
+			wg.Done()
+		}()
+	}
+	wg.Wait()
+}
+
+func doWork(dur time.Duration) {
+	start := time.Now()
+	for time.Since(start) < dur {
+	}
+}
+
+// BenchmarkCreateGoroutinesSingle creates many goroutines, all from a single
+// producer (the main benchmark goroutine).
+//
+// Compared to BenchmarkCreateGoroutines, this causes different behavior in the
+// scheduler because Ms are much more likely to need to steal work from the
+// main P rather than having work in the local run queue.
+func BenchmarkCreateGoroutinesSingle(b *testing.B) {
+	// Since we are interested in stealing behavior, warm the scheduler to
+	// get all the Ps running first.
+	warmupScheduler(runtime.GOMAXPROCS(0))
+	b.ResetTimer()
+
+	var wg sync.WaitGroup
+	wg.Add(b.N)
+	for i := 0; i < b.N; i++ {
+		go func(){
+			wg.Done()
+		}()
+	}
+	wg.Wait()
+}
+
 func BenchmarkClosureCall(b *testing.B) {
 	sum := 0
 	off1 := 1
-- 
GitLab


From cfe5d79c5c2c9888a0e56e089dca99e405a225b9 Mon Sep 17 00:00:00 2001
From: Egon Elbre <egonelbre@gmail.com>
Date: Tue, 20 Apr 2021 17:38:54 +0300
Subject: [PATCH 1720/2400] os: depend on Readlink only when necessary

Currently Readlink gets linked into the binary even when Executable is
not needed.

This reduces a simple "os.Stdout.Write([]byte("hello"))" by ~10KiB.

Previously the executable path was read during init time, because
deleting the executable would make "Readlink" return "(deleted)" suffix.
There's probably a slight chance that the init time reading would return
it anyways.

Updates #6853

Change-Id: Ic76190c5b64d9320ceb489cd6a553108614653d1
Reviewed-on: https://go-review.googlesource.com/c/go/+/311790
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/os/executable_procfs.go | 21 +++++++-----
 src/os/executable_test.go   | 65 +++++++++++++++++++++++++++++++++++++
 2 files changed, 78 insertions(+), 8 deletions(-)

diff --git a/src/os/executable_procfs.go b/src/os/executable_procfs.go
index 9c64a0d474..76ba0e6d08 100644
--- a/src/os/executable_procfs.go
+++ b/src/os/executable_procfs.go
@@ -12,10 +12,7 @@ import (
 	"runtime"
 )
 
-// We query the executable path at init time to avoid the problem of
-// readlink returns a path appended with " (deleted)" when the original
-// binary gets deleted.
-var executablePath, executablePathErr = func() (string, error) {
+func executable() (string, error) {
 	var procfn string
 	switch runtime.GOOS {
 	default:
@@ -25,9 +22,17 @@ var executablePath, executablePathErr = func() (string, error) {
 	case "netbsd":
 		procfn = "/proc/curproc/exe"
 	}
-	return Readlink(procfn)
-}()
+	path, err := Readlink(procfn)
 
-func executable() (string, error) {
-	return executablePath, executablePathErr
+	// When the executable has been deleted then Readlink returns a
+	// path appended with " (deleted)".
+	return stringsTrimSuffix(path, " (deleted)"), err
+}
+
+// stringsTrimSuffix is the same as strings.TrimSuffix.
+func stringsTrimSuffix(s, suffix string) string {
+	if len(s) >= len(suffix) && s[len(s)-len(suffix):] == suffix {
+		return s[:len(s)-len(suffix)]
+	}
+	return s
 }
diff --git a/src/os/executable_test.go b/src/os/executable_test.go
index f25ee0c95a..f682105fa6 100644
--- a/src/os/executable_test.go
+++ b/src/os/executable_test.go
@@ -86,3 +86,68 @@ func init() {
 		os.Exit(0)
 	}
 }
+
+func TestExecutableDeleted(t *testing.T) {
+	testenv.MustHaveExec(t)
+	switch runtime.GOOS {
+	case "windows":
+		t.Skip("windows does not support deleting running binary")
+	case "openbsd", "freebsd":
+		t.Skipf("%v does not support reading deleted binary name", runtime.GOOS)
+	}
+
+	dir := t.TempDir()
+
+	src := filepath.Join(dir, "testdel.go")
+	exe := filepath.Join(dir, "testdel.exe")
+
+	err := os.WriteFile(src, []byte(testExecutableDeletion), 0666)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	out, err := osexec.Command(testenv.GoToolPath(t), "build", "-o", exe, src).CombinedOutput()
+	t.Logf("build output:\n%s", out)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	out, err = osexec.Command(exe).CombinedOutput()
+	t.Logf("exec output:\n%s", out)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+const testExecutableDeletion = `package main
+
+import (
+	"fmt"
+	"os"
+)
+
+func main() {
+	before, err := os.Executable()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "failed to read executable name before deletion: %v\n", err)
+		os.Exit(1)
+	}
+
+	err = os.Remove(before)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "failed to remove executable: %v\n", err)
+		os.Exit(1)
+	}
+
+	after, err := os.Executable()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "failed to read executable name after deletion: %v\n", err)
+		os.Exit(1)
+	}
+
+	if before != after {
+		fmt.Fprintf(os.Stderr, "before and after do not match: %v != %v\n", before, after)
+		os.Exit(1)
+	}
+}
+`
-- 
GitLab


From f7afdfd48383c4f0ea8653ea9f8c7b9a3d93abee Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 21 Apr 2021 18:22:35 -0700
Subject: [PATCH 1721/2400] go/types: cleanup and fix Checker.index

A couple minor spec compliance issues: constant, typed index operands
must still be representable as type "int", but should also be recorded
as their original type.

Fixes #45667.

Change-Id: Iefeb29f20a8e48350af83a62c9ae0e92198c5ef7
Reviewed-on: https://go-review.googlesource.com/c/go/+/312591
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/builtins_test.go |  3 ++
 src/go/types/check_test.go    | 15 ++++++++--
 src/go/types/expr.go          | 56 ++++++++++++++++++++++-------------
 3 files changed, 51 insertions(+), 23 deletions(-)

diff --git a/src/go/types/builtins_test.go b/src/go/types/builtins_test.go
index cfd19d5e28..e9ffd28508 100644
--- a/src/go/types/builtins_test.go
+++ b/src/go/types/builtins_test.go
@@ -87,6 +87,9 @@ var builtinCalls = []struct {
 	{"make", `var    c int32; _ = make([]float64   , 0, c)`, `func([]float64, int, int32) []float64`},
 	{"make", `var l, c uint ; _ = make([]complex128, l, c)`, `func([]complex128, uint, uint) []complex128`},
 
+	// issue #45667
+	{"make", `const l uint = 1; _ = make([]int, l)`, `func([]int, uint) []int`},
+
 	{"new", `_ = new(int)`, `func(int) *int`},
 	{"new", `type T struct{}; _ = new(T)`, `func(p.T) *p.T`},
 
diff --git a/src/go/types/check_test.go b/src/go/types/check_test.go
index 8a15841e37..422488744b 100644
--- a/src/go/types/check_test.go
+++ b/src/go/types/check_test.go
@@ -203,7 +203,7 @@ func asGoVersion(s string) string {
 	return ""
 }
 
-func checkFiles(t *testing.T, goVersion string, filenames []string, srcs [][]byte) {
+func checkFiles(t *testing.T, sizes Sizes, goVersion string, filenames []string, srcs [][]byte) {
 	if len(filenames) == 0 {
 		t.Fatal("no source files")
 	}
@@ -239,6 +239,7 @@ func checkFiles(t *testing.T, goVersion string, filenames []string, srcs [][]byt
 
 	// typecheck and collect typechecker errors
 	var conf Config
+	conf.Sizes = sizes
 	conf.GoVersion = goVersion
 
 	// special case for importC.src
@@ -310,7 +311,15 @@ func TestCheck(t *testing.T) {
 func TestLongConstants(t *testing.T) {
 	format := "package longconst\n\nconst _ = %s\nconst _ = %s // ERROR excessively long constant"
 	src := fmt.Sprintf(format, strings.Repeat("1", 9999), strings.Repeat("1", 10001))
-	checkFiles(t, "", []string{"longconst.go"}, [][]byte{[]byte(src)})
+	checkFiles(t, nil, "", []string{"longconst.go"}, [][]byte{[]byte(src)})
+}
+
+// TestIndexRepresentability tests that constant index operands must
+// be representable as int even if they already have a type that can
+// represent larger values.
+func TestIndexRepresentability(t *testing.T) {
+	const src = "package index\n\nvar s []byte\nvar _ = s[int64 /* ERROR \"int64\\(1\\) << 40 \\(.*\\) overflows int\" */ (1) << 40]"
+	checkFiles(t, &StdSizes{4, 4}, "", []string{"index.go"}, [][]byte{[]byte(src)})
 }
 
 func TestTestdata(t *testing.T)  { DefPredeclaredTestFuncs(); testDir(t, "testdata") }
@@ -358,5 +367,5 @@ func testPkg(t *testing.T, filenames []string, goVersion string) {
 		}
 		srcs[i] = src
 	}
-	checkFiles(t, goVersion, filenames, srcs)
+	checkFiles(t, nil, goVersion, filenames, srcs)
 }
diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 57523e1d0f..b4eea229b8 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -1012,19 +1012,7 @@ func (check *Checker) index(index ast.Expr, max int64) (typ Type, val int64) {
 
 	var x operand
 	check.expr(&x, index)
-	if x.mode == invalid {
-		return
-	}
-
-	// an untyped constant must be representable as Int
-	check.convertUntyped(&x, Typ[Int])
-	if x.mode == invalid {
-		return
-	}
-
-	// the index must be of integer type
-	if !isInteger(x.typ) {
-		check.invalidArg(&x, _InvalidIndex, "index %s must be integer", &x)
+	if !check.isValidIndex(&x, _InvalidIndex, "index", false) {
 		return
 	}
 
@@ -1032,12 +1020,6 @@ func (check *Checker) index(index ast.Expr, max int64) (typ Type, val int64) {
 		return x.typ, -1
 	}
 
-	// a constant index i must be in bounds
-	if constant.Sign(x.val) < 0 {
-		check.invalidArg(&x, _InvalidIndex, "index %s must not be negative", &x)
-		return
-	}
-
 	v, valid := constant.Int64Val(constant.ToInt(x.val))
 	if !valid || max >= 0 && v >= max {
 		check.errorf(&x, _InvalidIndex, "index %s is out of bounds", &x)
@@ -1045,7 +1027,41 @@ func (check *Checker) index(index ast.Expr, max int64) (typ Type, val int64) {
 	}
 
 	// 0 <= v [ && v < max ]
-	return Typ[Int], v
+	return x.typ, v
+}
+
+func (check *Checker) isValidIndex(x *operand, code errorCode, what string, allowNegative bool) bool {
+	if x.mode == invalid {
+		return false
+	}
+
+	// spec: "a constant index that is untyped is given type int"
+	check.convertUntyped(x, Typ[Int])
+	if x.mode == invalid {
+		return false
+	}
+
+	// spec: "the index x must be of integer type or an untyped constant"
+	if !isInteger(x.typ) {
+		check.invalidArg(x, code, "%s %s must be integer", what, x)
+		return false
+	}
+
+	if x.mode == constant_ {
+		// spec: "a constant index must be non-negative ..."
+		if !allowNegative && constant.Sign(x.val) < 0 {
+			check.invalidArg(x, code, "%s %s must not be negative", what, x)
+			return false
+		}
+
+		// spec: "... and representable by a value of type int"
+		if !representableConst(x.val, check, Typ[Int], &x.val) {
+			check.invalidArg(x, code, "%s %s overflows int", what, x)
+			return false
+		}
+	}
+
+	return true
 }
 
 // indexElts checks the elements (elts) of an array or slice composite literal
-- 
GitLab


From 74059685fda0b60d539450ad6b7331ade838e90c Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 22 Apr 2021 12:42:33 -0700
Subject: [PATCH 1722/2400] go/types: suppress index-out-of-bounds error on
 Unknown constants

Follow up to CL 312591, which was stumping rfindley and I for a
while. Credit to him for figuring out a repro and explaining the
correct solution.

Change-Id: Ib8578bba05f60fc41d382c34c5266d815441e7a1
Reviewed-on: https://go-review.googlesource.com/c/go/+/312790
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Trust: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/go/types/expr.go            | 11 ++++++++---
 src/go/types/testdata/expr3.src |  1 +
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index b4eea229b8..4023362a4e 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -1020,9 +1020,14 @@ func (check *Checker) index(index ast.Expr, max int64) (typ Type, val int64) {
 		return x.typ, -1
 	}
 
-	v, valid := constant.Int64Val(constant.ToInt(x.val))
-	if !valid || max >= 0 && v >= max {
-		check.errorf(&x, _InvalidIndex, "index %s is out of bounds", &x)
+	if x.val.Kind() == constant.Unknown {
+		return
+	}
+
+	v, ok := constant.Int64Val(x.val)
+	assert(ok)
+	if max >= 0 && v >= max {
+		check.invalidArg(&x, _InvalidIndex, "index %s is out of bounds", &x)
 		return
 	}
 
diff --git a/src/go/types/testdata/expr3.src b/src/go/types/testdata/expr3.src
index c3158e6cf4..0525a5a33a 100644
--- a/src/go/types/testdata/expr3.src
+++ b/src/go/types/testdata/expr3.src
@@ -34,6 +34,7 @@ func indexes() {
 	_ = a[9]
 	_ = a[10 /* ERROR "index .* out of bounds" */ ]
 	_ = a[1 /* ERROR "overflows" */ <<100]
+	_ = a[1<< /* ERROR "constant shift overflow" */ 1000] // no out-of-bounds follow-on error
 	_ = a[10:]
 	_ = a[:10]
 	_ = a[10:10]
-- 
GitLab


From 1da05eb0cebed9595ee0d326d9bd67edd046af0d Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 21 Apr 2021 00:12:02 -0700
Subject: [PATCH 1723/2400] spec: add unsafe.Add and unsafe.Slice

Updates #19367.
Updates #40481.

Change-Id: I578066ad68d2cd6bea50df1a534cf799e4404a7f
Reviewed-on: https://go-review.googlesource.com/c/go/+/312212
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Rob Pike <r@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 doc/go_spec.html     | 32 +++++++++++++++++++++++++++++++-
 src/unsafe/unsafe.go | 23 +++++++++++++++++++++++
 2 files changed, 54 insertions(+), 1 deletion(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index 13b8beb06c..bbcdd54b02 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1,6 +1,6 @@
 <!--{
 	"Title": "The Go Programming Language Specification",
-	"Subtitle": "Version of Apr 20, 2021",
+	"Subtitle": "Version of Apr 21, 2021",
 	"Path": "/ref/spec"
 }-->
 
@@ -6711,6 +6711,10 @@ type Pointer *ArbitraryType
 func Alignof(variable ArbitraryType) uintptr
 func Offsetof(selector ArbitraryType) uintptr
 func Sizeof(variable ArbitraryType) uintptr
+
+type IntegerType int  // shorthand for an integer type; it is not a real type
+func Add(ptr Pointer, len IntegerType) Pointer
+func Slice(ptr *ArbitraryType, len IntegerType) []ArbitraryType
 </pre>
 
 <p>
@@ -6767,6 +6771,32 @@ Calls to <code>Alignof</code>, <code>Offsetof</code>, and
 <code>Sizeof</code> are compile-time constant expressions of type <code>uintptr</code>.
 </p>
 
+<p>
+The function <code>Add</code> adds <code>len</code> to <code>ptr</code>
+and returns the updated pointer <code>unsafe.Pointer(uintptr(ptr) + uintptr(len))</code>.
+The <code>len</code> argument must be of integer type or an untyped <a href="#Constants">constant</a>.
+A constant <code>len</code> argument must be <a href="#Representability">representable</a> by a value of type <code>int</code>;
+if it is an untyped constant it is given type <code>int</code>.
+The rules for <a href="/pkg/unsafe#Pointer">valid uses</a> of <code>Pointer</code> still apply.
+</p>
+
+<p>
+The function <code>Slice</code> returns a slice whose underlying array starts at <code>ptr</code>
+and whose length and capacity are <code>len</code>:
+</p>
+
+<pre>
+(*[len]ArbitraryType)(unsafe.Pointer(ptr))[:]
+</pre>
+
+<p>
+The <code>len</code> argument must be of integer type or an untyped <a href="#Constants">constant</a>.
+A constant <code>len</code> argument must be non-negative and <a href="#Representability">representable</a> by a value of type <code>int</code>;
+if it is an untyped constant it is given type <code>int</code>.
+If <code>ptr</code> is <code>nil</code> or <code>len</code> is negative at run time,
+a <a href="#Run_time_panics">run-time panic</a> occurs.
+</p>
+
 <h3 id="Size_and_alignment_guarantees">Size and alignment guarantees</h3>
 
 <p>
diff --git a/src/unsafe/unsafe.go b/src/unsafe/unsafe.go
index 272761d936..ecbd28c523 100644
--- a/src/unsafe/unsafe.go
+++ b/src/unsafe/unsafe.go
@@ -14,6 +14,10 @@ package unsafe
 // part of the unsafe package. It represents the type of an arbitrary Go expression.
 type ArbitraryType int
 
+// IntegerType is here for the purposes of documentation only and is not actually
+// part of the unsafe package. It represents any arbitrary integer type.
+type IntegerType int
+
 // Pointer represents a pointer to an arbitrary type. There are four special operations
 // available for type Pointer that are not available for other types:
 //	- A pointer value of any type can be converted to a Pointer.
@@ -203,3 +207,22 @@ func Offsetof(x ArbitraryType) uintptr
 // value returned by reflect.TypeOf(s.f).FieldAlign().
 // The return value of Alignof is a Go constant.
 func Alignof(x ArbitraryType) uintptr
+
+// The function Add adds len to ptr and returns the updated pointer
+// Pointer(uintptr(ptr) + uintptr(len)).
+// The len argument must be of integer type or an untyped constant.
+// A constant len argument must be representable by a value of type int;
+// if it is an untyped constant it is given type int.
+// The rules for valid uses of Pointer still apply.
+func Add(ptr Pointer, len IntegerType) Pointer
+
+// The function Slice returns a slice whose underlying array starts at ptr
+// and whose length and capacity are len:
+//
+//	(*[len]ArbitraryType)(unsafe.Pointer(ptr))[:]
+//
+// The len argument must be of integer type or an untyped constant.
+// A constant len argument must be non-negative and representable by a value of type int;
+// if it is an untyped constant it is given type int.
+// If ptr is nil or len is negative at run time, a run-time panic occurs.
+func Slice(ptr *ArbitraryType, len IntegerType) []ArbitraryType
-- 
GitLab


From 050b408dcc9d06316d87743fdc41b99dda4e12d5 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 21 Apr 2021 03:29:18 -0700
Subject: [PATCH 1724/2400] go/types: implement unsafe.Add and unsafe.Slice

Updates #19367.
Updates #40481.

Change-Id: Id2b2d2e3e716f91f0dd9e5102689a1ba90a819e4
Reviewed-on: https://go-review.googlesource.com/c/go/+/312213
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/go/types/builtins.go      | 39 +++++++++++++++++++++++++++++++++++
 src/go/types/builtins_test.go |  7 +++++++
 src/go/types/check.go         | 10 ++++-----
 src/go/types/errorcodes.go    | 39 +++++++++++++++++++++++++++++++++++
 src/go/types/universe.go      |  4 ++++
 5 files changed, 94 insertions(+), 5 deletions(-)

diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go
index 3df82fffda..9c5a0b5842 100644
--- a/src/go/types/builtins.go
+++ b/src/go/types/builtins.go
@@ -586,6 +586,25 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 			check.recordBuiltinType(call.Fun, makeSig(x.typ))
 		}
 
+	case _Add:
+		// unsafe.Add(ptr unsafe.Pointer, len IntegerType) unsafe.Pointer
+		check.assignment(x, Typ[UnsafePointer], "argument to unsafe.Add")
+		if x.mode == invalid {
+			return
+		}
+
+		var y operand
+		arg(&y, 1)
+		if !check.isValidIndex(&y, _InvalidUnsafeAdd, "length", true) {
+			return
+		}
+
+		x.mode = value
+		x.typ = Typ[UnsafePointer]
+		if check.Types != nil {
+			check.recordBuiltinType(call.Fun, makeSig(x.typ, x.typ, y.typ))
+		}
+
 	case _Alignof:
 		// unsafe.Alignof(x T) uintptr
 		if asTypeParam(x.typ) != nil {
@@ -663,6 +682,26 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 		x.typ = Typ[Uintptr]
 		// result is constant - no need to record signature
 
+	case _Slice:
+		// unsafe.Slice(ptr *T, len IntegerType) []T
+		typ := asPointer(x.typ)
+		if typ == nil {
+			check.invalidArg(x, _InvalidUnsafeSlice, "%s is not a pointer", x)
+			return
+		}
+
+		var y operand
+		arg(&y, 1)
+		if !check.isValidIndex(&y, _InvalidUnsafeSlice, "length", false) {
+			return
+		}
+
+		x.mode = value
+		x.typ = NewSlice(typ.base)
+		if check.Types != nil {
+			check.recordBuiltinType(call.Fun, makeSig(x.typ, typ, y.typ))
+		}
+
 	case _Assert:
 		// assert(pred) causes a typechecker error if pred is false.
 		// The result of assert is the value of pred if there is no error.
diff --git a/src/go/types/builtins_test.go b/src/go/types/builtins_test.go
index e9ffd28508..11de9a1ac1 100644
--- a/src/go/types/builtins_test.go
+++ b/src/go/types/builtins_test.go
@@ -107,6 +107,10 @@ var builtinCalls = []struct {
 	{"recover", `recover()`, `func() interface{}`},
 	{"recover", `_ = recover()`, `func() interface{}`},
 
+	{"Add", `var p unsafe.Pointer; _ = unsafe.Add(p, -1.0)`, `func(unsafe.Pointer, int) unsafe.Pointer`},
+	{"Add", `var p unsafe.Pointer; var n uintptr; _ = unsafe.Add(p, n)`, `func(unsafe.Pointer, uintptr) unsafe.Pointer`},
+	{"Add", `_ = unsafe.Add(nil, 0)`, `func(unsafe.Pointer, int) unsafe.Pointer`},
+
 	{"Alignof", `_ = unsafe.Alignof(0)`, `invalid type`},                 // constant
 	{"Alignof", `var x struct{}; _ = unsafe.Alignof(x)`, `invalid type`}, // constant
 
@@ -116,6 +120,9 @@ var builtinCalls = []struct {
 	{"Sizeof", `_ = unsafe.Sizeof(0)`, `invalid type`},                 // constant
 	{"Sizeof", `var x struct{}; _ = unsafe.Sizeof(x)`, `invalid type`}, // constant
 
+	{"Slice", `var p *int; _ = unsafe.Slice(p, 1)`, `func(*int, int) []int`},
+	{"Slice", `var p *byte; var n uintptr; _ = unsafe.Slice(p, n)`, `func(*byte, uintptr) []byte`},
+
 	{"assert", `assert(true)`, `invalid type`},                                    // constant
 	{"assert", `type B bool; const pred B = 1 < 2; assert(pred)`, `invalid type`}, // constant
 
diff --git a/src/go/types/check.go b/src/go/types/check.go
index b28481d7bd..2c8f683ad5 100644
--- a/src/go/types/check.go
+++ b/src/go/types/check.go
@@ -329,14 +329,14 @@ func (check *Checker) recordTypeAndValue(x ast.Expr, mode operandMode, typ Type,
 }
 
 func (check *Checker) recordBuiltinType(f ast.Expr, sig *Signature) {
-	// f must be a (possibly parenthesized) identifier denoting a built-in
-	// (built-ins in package unsafe always produce a constant result and
-	// we don't record their signatures, so we don't see qualified idents
-	// here): record the signature for f and possible children.
+	// f must be a (possibly parenthesized, possibly qualified)
+	// identifier denoting a built-in (including unsafe's non-constant
+	// functions Add and Slice): record the signature for f and possible
+	// children.
 	for {
 		check.recordTypeAndValue(f, builtin, sig, nil)
 		switch p := f.(type) {
-		case *ast.Ident:
+		case *ast.Ident, *ast.SelectorExpr:
 			return // we're done
 		case *ast.ParenExpr:
 			f = p.X
diff --git a/src/go/types/errorcodes.go b/src/go/types/errorcodes.go
index 257fc4eff4..1106cd986f 100644
--- a/src/go/types/errorcodes.go
+++ b/src/go/types/errorcodes.go
@@ -883,6 +883,45 @@ const (
 	//  var _ = real(int(1))
 	_InvalidReal
 
+	// _InvalidUnsafeAdd occurs when unsafe.Add is called with a
+	// length argument that is not of integer type.
+	//
+	// Example:
+	//  import "unsafe"
+	//
+	//  var p unsafe.Pointer
+	//  var _ = unsafe.Add(p, float64(1))
+	_InvalidUnsafeAdd
+
+	// _InvalidUnsafeSlice occurs when unsafe.Slice is called with a
+	// pointer argument that is not of pointer type or a length argument
+	// that is not of integer type, negative, or out of bounds.
+	//
+	// Example:
+	//  import "unsafe"
+	//
+	//  var x int
+	//  var _ = unsafe.Slice(x, 1)
+	//
+	// Example:
+	//  import "unsafe"
+	//
+	//  var x int
+	//  var _ = unsafe.Slice(&x, float64(1))
+	//
+	// Example:
+	//  import "unsafe"
+	//
+	//  var x int
+	//  var _ = unsafe.Slice(&x, -1)
+	//
+	// Example:
+	//  import "unsafe"
+	//
+	//  var x int
+	//  var _ = unsafe.Slice(&x, uint64(1) << 63)
+	_InvalidUnsafeSlice
+
 	/* exprs > assertion */
 
 	// _InvalidAssert occurs when a type assertion is applied to a
diff --git a/src/go/types/universe.go b/src/go/types/universe.go
index 4ced018f8e..7c211fa6f7 100644
--- a/src/go/types/universe.go
+++ b/src/go/types/universe.go
@@ -137,9 +137,11 @@ const (
 	_Recover
 
 	// package unsafe
+	_Add
 	_Alignof
 	_Offsetof
 	_Sizeof
+	_Slice
 
 	// testing support
 	_Assert
@@ -168,9 +170,11 @@ var predeclaredFuncs = [...]struct {
 	_Real:    {"real", 1, false, expression},
 	_Recover: {"recover", 0, false, statement},
 
+	_Add:      {"Add", 2, false, expression},
 	_Alignof:  {"Alignof", 1, false, expression},
 	_Offsetof: {"Offsetof", 1, false, expression},
 	_Sizeof:   {"Sizeof", 1, false, expression},
+	_Slice:    {"Slice", 2, false, expression},
 
 	_Assert: {"assert", 1, false, statement},
 	_Trace:  {"trace", 0, true, statement},
-- 
GitLab


From 14056d0d004489592ee0173e685ff86f241cfb4f Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 22 Apr 2021 15:38:33 -0700
Subject: [PATCH 1725/2400] cmd/compile/internal/types2: add unsafe.Add and
 unsafe.Slice

This is a port of CL 312212, CL 312591 (except check_test.go), and
CL 312790 to types2.

Updates #19367.
Updates #40481.

Change-Id: I58ba0b0dad157baba3f82c909d5eb1268b931be4
Reviewed-on: https://go-review.googlesource.com/c/go/+/312511
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/types2/builtins.go   | 39 +++++++++++++
 .../compile/internal/types2/builtins_test.go  | 10 ++++
 src/cmd/compile/internal/types2/check.go      | 10 ++--
 src/cmd/compile/internal/types2/check_test.go |  2 +-
 src/cmd/compile/internal/types2/index.go      | 57 +++++++++++++------
 .../internal/types2/testdata/expr3.src        |  1 +
 src/cmd/compile/internal/types2/universe.go   |  4 ++
 test/makechan.go                              |  2 +-
 test/makemap.go                               |  4 +-
 9 files changed, 102 insertions(+), 27 deletions(-)

diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go
index 25bfb24ef4..b9e178dd57 100644
--- a/src/cmd/compile/internal/types2/builtins.go
+++ b/src/cmd/compile/internal/types2/builtins.go
@@ -577,6 +577,25 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 			check.recordBuiltinType(call.Fun, makeSig(x.typ))
 		}
 
+	case _Add:
+		// unsafe.Add(ptr unsafe.Pointer, len IntegerType) unsafe.Pointer
+		check.assignment(x, Typ[UnsafePointer], "argument to unsafe.Add")
+		if x.mode == invalid {
+			return
+		}
+
+		var y operand
+		arg(&y, 1)
+		if !check.isValidIndex(&y, "length", true) {
+			return
+		}
+
+		x.mode = value
+		x.typ = Typ[UnsafePointer]
+		if check.Types != nil {
+			check.recordBuiltinType(call.Fun, makeSig(x.typ, x.typ, y.typ))
+		}
+
 	case _Alignof:
 		// unsafe.Alignof(x T) uintptr
 		if asTypeParam(x.typ) != nil {
@@ -654,6 +673,26 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 		x.typ = Typ[Uintptr]
 		// result is constant - no need to record signature
 
+	case _Slice:
+		// unsafe.Slice(ptr *T, len IntegerType) []T
+		typ := asPointer(x.typ)
+		if typ == nil {
+			check.errorf(x, invalidArg+"%s is not a pointer", x)
+			return
+		}
+
+		var y operand
+		arg(&y, 1)
+		if !check.isValidIndex(&y, "length", false) {
+			return
+		}
+
+		x.mode = value
+		x.typ = NewSlice(typ.base)
+		if check.Types != nil {
+			check.recordBuiltinType(call.Fun, makeSig(x.typ, typ, y.typ))
+		}
+
 	case _Assert:
 		// assert(pred) causes a typechecker error if pred is false.
 		// The result of assert is the value of pred if there is no error.
diff --git a/src/cmd/compile/internal/types2/builtins_test.go b/src/cmd/compile/internal/types2/builtins_test.go
index 780d0a15a7..82c786b86e 100644
--- a/src/cmd/compile/internal/types2/builtins_test.go
+++ b/src/cmd/compile/internal/types2/builtins_test.go
@@ -85,6 +85,9 @@ var builtinCalls = []struct {
 	{"make", `var    c int32; _ = make([]float64   , 0, c)`, `func([]float64, int, int32) []float64`},
 	{"make", `var l, c uint ; _ = make([]complex128, l, c)`, `func([]complex128, uint, uint) []complex128`},
 
+	// issue #45667
+	{"make", `const l uint = 1; _ = make([]int, l)`, `func([]int, uint) []int`},
+
 	{"new", `_ = new(int)`, `func(int) *int`},
 	{"new", `type T struct{}; _ = new(T)`, `func(p.T) *p.T`},
 
@@ -102,6 +105,10 @@ var builtinCalls = []struct {
 	{"recover", `recover()`, `func() interface{}`},
 	{"recover", `_ = recover()`, `func() interface{}`},
 
+	{"Add", `var p unsafe.Pointer; _ = unsafe.Add(p, -1.0)`, `func(unsafe.Pointer, int) unsafe.Pointer`},
+	{"Add", `var p unsafe.Pointer; var n uintptr; _ = unsafe.Add(p, n)`, `func(unsafe.Pointer, uintptr) unsafe.Pointer`},
+	{"Add", `_ = unsafe.Add(nil, 0)`, `func(unsafe.Pointer, int) unsafe.Pointer`},
+
 	{"Alignof", `_ = unsafe.Alignof(0)`, `invalid type`},                 // constant
 	{"Alignof", `var x struct{}; _ = unsafe.Alignof(x)`, `invalid type`}, // constant
 
@@ -111,6 +118,9 @@ var builtinCalls = []struct {
 	{"Sizeof", `_ = unsafe.Sizeof(0)`, `invalid type`},                 // constant
 	{"Sizeof", `var x struct{}; _ = unsafe.Sizeof(x)`, `invalid type`}, // constant
 
+	{"Slice", `var p *int; _ = unsafe.Slice(p, 1)`, `func(*int, int) []int`},
+	{"Slice", `var p *byte; var n uintptr; _ = unsafe.Slice(p, n)`, `func(*byte, uintptr) []byte`},
+
 	{"assert", `assert(true)`, `invalid type`},                                    // constant
 	{"assert", `type B bool; const pred B = 1 < 2; assert(pred)`, `invalid type`}, // constant
 
diff --git a/src/cmd/compile/internal/types2/check.go b/src/cmd/compile/internal/types2/check.go
index 66637459e7..c8ca118c3c 100644
--- a/src/cmd/compile/internal/types2/check.go
+++ b/src/cmd/compile/internal/types2/check.go
@@ -364,14 +364,14 @@ func (check *Checker) recordTypeAndValue(x syntax.Expr, mode operandMode, typ Ty
 }
 
 func (check *Checker) recordBuiltinType(f syntax.Expr, sig *Signature) {
-	// f must be a (possibly parenthesized) identifier denoting a built-in
-	// (built-ins in package unsafe always produce a constant result and
-	// we don't record their signatures, so we don't see qualified idents
-	// here): record the signature for f and possible children.
+	// f must be a (possibly parenthesized, possibly qualified)
+	// identifier denoting a built-in (including unsafe's non-constant
+	// functions Add and Slice): record the signature for f and possible
+	// children.
 	for {
 		check.recordTypeAndValue(f, builtin, sig, nil)
 		switch p := f.(type) {
-		case *syntax.Name:
+		case *syntax.Name, *syntax.SelectorExpr:
 			return // we're done
 		case *syntax.ParenExpr:
 			f = p.X
diff --git a/src/cmd/compile/internal/types2/check_test.go b/src/cmd/compile/internal/types2/check_test.go
index 331f0c7105..1ecd43778e 100644
--- a/src/cmd/compile/internal/types2/check_test.go
+++ b/src/cmd/compile/internal/types2/check_test.go
@@ -250,7 +250,7 @@ func TestCheck(t *testing.T) {
 	checkFiles(t, strings.Split(*testFiles, ","), *goVersion, 0, testing.Verbose())
 }
 
-// TODO(gri) go/types has an extra TestLongConstants test
+// TODO(gri) go/types has extra TestLongConstants and TestIndexRepresentability tests
 
 func TestTestdata(t *testing.T)  { DefPredeclaredTestFuncs(); testDir(t, "testdata", 75) } // TODO(gri) narrow column tolerance
 func TestExamples(t *testing.T)  { testDir(t, "examples", 0) }
diff --git a/src/cmd/compile/internal/types2/index.go b/src/cmd/compile/internal/types2/index.go
index 6726272f6c..b30799d37c 100644
--- a/src/cmd/compile/internal/types2/index.go
+++ b/src/cmd/compile/internal/types2/index.go
@@ -320,19 +320,7 @@ func (check *Checker) index(index syntax.Expr, max int64) (typ Type, val int64)
 
 	var x operand
 	check.expr(&x, index)
-	if x.mode == invalid {
-		return
-	}
-
-	// an untyped constant must be representable as Int
-	check.convertUntyped(&x, Typ[Int])
-	if x.mode == invalid {
-		return
-	}
-
-	// the index must be of integer type
-	if !isInteger(x.typ) {
-		check.errorf(&x, invalidArg+"index %s must be integer", &x)
+	if !check.isValidIndex(&x, "index", false) {
 		return
 	}
 
@@ -340,14 +328,13 @@ func (check *Checker) index(index syntax.Expr, max int64) (typ Type, val int64)
 		return x.typ, -1
 	}
 
-	// a constant index i must be in bounds
-	if constant.Sign(x.val) < 0 {
-		check.errorf(&x, invalidArg+"index %s must not be negative", &x)
+	if x.val.Kind() == constant.Unknown {
 		return
 	}
 
-	v, valid := constant.Int64Val(constant.ToInt(x.val))
-	if !valid || max >= 0 && v >= max {
+	v, ok := constant.Int64Val(x.val)
+	assert(ok)
+	if max >= 0 && v >= max {
 		if check.conf.CompilerErrorMessages {
 			check.errorf(&x, invalidArg+"array index %s out of bounds [0:%d]", x.val.String(), max)
 		} else {
@@ -360,6 +347,40 @@ func (check *Checker) index(index syntax.Expr, max int64) (typ Type, val int64)
 	return x.typ, v
 }
 
+func (check *Checker) isValidIndex(x *operand, what string, allowNegative bool) bool {
+	if x.mode == invalid {
+		return false
+	}
+
+	// spec: "a constant index that is untyped is given type int"
+	check.convertUntyped(x, Typ[Int])
+	if x.mode == invalid {
+		return false
+	}
+
+	// spec: "the index x must be of integer type or an untyped constant"
+	if !isInteger(x.typ) {
+		check.errorf(x, invalidArg+"%s %s must be integer", what, x)
+		return false
+	}
+
+	if x.mode == constant_ {
+		// spec: "a constant index must be non-negative ..."
+		if !allowNegative && constant.Sign(x.val) < 0 {
+			check.errorf(x, invalidArg+"%s %s must not be negative", what, x)
+			return false
+		}
+
+		// spec: "... and representable by a value of type int"
+		if !representableConst(x.val, check, Typ[Int], &x.val) {
+			check.errorf(x, invalidArg+"%s %s overflows int", what, x)
+			return false
+		}
+	}
+
+	return true
+}
+
 // indexElts checks the elements (elts) of an array or slice composite literal
 // against the literal's element type (typ), and the element indices against
 // the literal length if known (length >= 0). It returns the length of the
diff --git a/src/cmd/compile/internal/types2/testdata/expr3.src b/src/cmd/compile/internal/types2/testdata/expr3.src
index d1be806cfd..eab3f72c4d 100644
--- a/src/cmd/compile/internal/types2/testdata/expr3.src
+++ b/src/cmd/compile/internal/types2/testdata/expr3.src
@@ -35,6 +35,7 @@ func indexes() {
 	_ = a[9]
 	_ = a[10 /* ERROR "index .* out of bounds" */ ]
 	_ = a[1 /* ERROR "overflows" */ <<100]
+	_ = a[1<< /* ERROR "constant shift overflow" */ 1000] // no out-of-bounds follow-on error
 	_ = a[10:]
 	_ = a[:10]
 	_ = a[10:10]
diff --git a/src/cmd/compile/internal/types2/universe.go b/src/cmd/compile/internal/types2/universe.go
index 3654ab4945..76d4e55e84 100644
--- a/src/cmd/compile/internal/types2/universe.go
+++ b/src/cmd/compile/internal/types2/universe.go
@@ -136,9 +136,11 @@ const (
 	_Recover
 
 	// package unsafe
+	_Add
 	_Alignof
 	_Offsetof
 	_Sizeof
+	_Slice
 
 	// testing support
 	_Assert
@@ -167,9 +169,11 @@ var predeclaredFuncs = [...]struct {
 	_Real:    {"real", 1, false, expression},
 	_Recover: {"recover", 0, false, statement},
 
+	_Add:      {"Add", 2, false, expression},
 	_Alignof:  {"Alignof", 1, false, expression},
 	_Offsetof: {"Offsetof", 1, false, expression},
 	_Sizeof:   {"Sizeof", 1, false, expression},
+	_Slice:    {"Slice", 2, false, expression},
 
 	_Assert: {"assert", 1, false, statement},
 	_Trace:  {"trace", 0, true, statement},
diff --git a/test/makechan.go b/test/makechan.go
index 30a57456b3..9fabd1701f 100644
--- a/test/makechan.go
+++ b/test/makechan.go
@@ -16,7 +16,7 @@ var sink T
 
 func main() {
 	sink = make(T, -1)            // ERROR "negative buffer argument in make.*|must not be negative"
-	sink = make(T, uint64(1<<63)) // ERROR "buffer argument too large in make.*|out of bounds"
+	sink = make(T, uint64(1<<63)) // ERROR "buffer argument too large in make.*|overflows int"
 
 	sink = make(T, 0.5) // ERROR "constant 0.5 truncated to integer|truncated to int"
 	sink = make(T, 1.0)
diff --git a/test/makemap.go b/test/makemap.go
index a60f5b5ee5..f63e5b4b6a 100644
--- a/test/makemap.go
+++ b/test/makemap.go
@@ -16,13 +16,13 @@ var sink T
 
 func main() {
 	sink = make(T, -1)            // ERROR "negative size argument in make.*|must not be negative"
-	sink = make(T, uint64(1<<63)) // ERROR "size argument too large in make.*|out of bounds"
+	sink = make(T, uint64(1<<63)) // ERROR "size argument too large in make.*|overflows int"
 
 	// Test that errors are emitted at call sites, not const declarations
 	const x = -1
 	sink = make(T, x) // ERROR "negative size argument in make.*|must not be negative"
 	const y = uint64(1 << 63)
-	sink = make(T, y) // ERROR "size argument too large in make.*|out of bounds"
+	sink = make(T, y) // ERROR "size argument too large in make.*|overflows int"
 
 	sink = make(T, 0.5) // ERROR "constant 0.5 truncated to integer|truncated to int"
 	sink = make(T, 1.0)
-- 
GitLab


From cfac62a1cc021cae55c9c5e373ebe9c408b75a5d Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Thu, 22 Apr 2021 18:34:57 -0400
Subject: [PATCH 1726/2400] cmd/compile: fix bug in defer wrapping

The defer wrapping feature added to the compiler's "order" phase
creates temporaries into which it copies defer arguments. If one of
these temps is large enough that we place it into the defer closure by
address (as opposed to by value), then the temp in question can't be
reused later on in the order phase, nor do we want a VARKILL
annotation for it at the end of the current block scope.

Test written by Cherry.

Updates #40724.

Change-Id: Iec7efd87ec5a3e3d7de41cdcc7f39c093ed1e815
Reviewed-on: https://go-review.googlesource.com/c/go/+/312869
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/walk/order.go | 20 +++++++++++---
 test/abi/wrapdefer_largetmp.go         | 37 ++++++++++++++++++++++++++
 test/abi/wrapdefer_largetmp.out        |  1 +
 3 files changed, 55 insertions(+), 3 deletions(-)
 create mode 100644 test/abi/wrapdefer_largetmp.go
 create mode 100644 test/abi/wrapdefer_largetmp.out

diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index dcb8f654f5..7037b8ea60 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -1592,12 +1592,26 @@ func (o *orderState) wrapGoDefer(n *ir.GoDeferStmt) {
 		return n.Esc() != ir.EscNever
 	}()
 
-	// A helper for making a copy of an argument.
+	// A helper for making a copy of an argument. Note that it is
+	// not safe to use o.copyExpr(arg) if we're putting a
+	// reference to the temp into the closure (as opposed to
+	// copying it in by value), since in the by-reference case we
+	// need a temporary whose lifetime extends to the end of the
+	// function (as opposed to being local to the current block or
+	// statement being ordered).
 	mkArgCopy := func(arg ir.Node) *ir.Name {
-		argCopy := o.copyExpr(arg)
+		t := arg.Type()
+		byval := t.Size() <= 128 || cloEscapes
+		var argCopy *ir.Name
+		if byval {
+			argCopy = o.copyExpr(arg)
+		} else {
+			argCopy = typecheck.Temp(t)
+			o.append(ir.NewAssignStmt(base.Pos, argCopy, arg))
+		}
 		// The value of 128 below is meant to be consistent with code
 		// in escape analysis that picks byval/byaddr based on size.
-		argCopy.SetByval(argCopy.Type().Size() <= 128 || cloEscapes)
+		argCopy.SetByval(byval)
 		return argCopy
 	}
 
diff --git a/test/abi/wrapdefer_largetmp.go b/test/abi/wrapdefer_largetmp.go
new file mode 100644
index 0000000000..fb6eebaaca
--- /dev/null
+++ b/test/abi/wrapdefer_largetmp.go
@@ -0,0 +1,37 @@
+// run
+
+//go:build !wasm
+// +build !wasm
+
+// Copyright 2021 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
+
+//go:noinline
+func F() {
+	b := g()
+	defer g2(b)
+	n := g()[20]
+	println(n)
+}
+
+type T [45]int
+
+var x = 0
+
+//go:noinline
+func g() T {
+	x++
+	return T{20: x}
+}
+
+//go:noinline
+func g2(t T) {
+	if t[20] != 1 {
+		println("FAIL", t[20])
+	}
+}
+
+func main() { F() }
diff --git a/test/abi/wrapdefer_largetmp.out b/test/abi/wrapdefer_largetmp.out
new file mode 100644
index 0000000000..0cfbf08886
--- /dev/null
+++ b/test/abi/wrapdefer_largetmp.out
@@ -0,0 +1 @@
+2
-- 
GitLab


From 1b0a0316802b8048d69da49dc23c5a5ab08e8ae8 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 22 Apr 2021 20:36:05 -0400
Subject: [PATCH 1727/2400] cmd/compile: escape "go" wrapper closure everywhere

For go statement, the wrapper closure needs to esacpe because it
runs asynchronously. Currently, it is not allowed for closures to
escape in the runtime. We have worked around this in the runtime,
so it doesn't "go" any function with arguments and so doesn't
need wrapping. If it ever does, it is not that we can have the
closure not escape, which may lead to miscompilation. Instead,
make the closure escape (which will fail the compilation). In the
future we may allow go'd closure to escape in the runtime.

Change-Id: I5bbe47b524371d2270c242f6c275013cd52abfc1
Reviewed-on: https://go-review.googlesource.com/c/go/+/312889
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/walk/order.go | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index 7037b8ea60..99a166119a 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -1582,10 +1582,8 @@ func (o *orderState) wrapGoDefer(n *ir.GoDeferStmt) {
 	// (needs heap allocation).
 	cloEscapes := func() bool {
 		if n.Op() == ir.OGO {
-			// For "go", assume that all closures escape (with an
-			// exception for the runtime, which doesn't permit
-			// heap-allocated closures).
-			return base.Ctxt.Pkgpath != "runtime"
+			// For "go", assume that all closures escape.
+			return true
 		}
 		// For defer, just use whatever result escape analysis
 		// has determined for the defer.
-- 
GitLab


From d310b2a6b8a66eeb5953b1e682cf27669c8a08c2 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Thu, 22 Apr 2021 17:14:10 +0700
Subject: [PATCH 1728/2400] cmd/compile: set correct Defn for inlined vars

Currently, when copying definition node of an inlined var, we do not
update var Defn field to point to new copied node. That causes all
inlined vars point to the same Defn, and ir.StaticValue can not find
inlined var in the lhs of its definition.

clovar creates new ONAME node for local variables or params of closure
inside inlined function, by copying most of the old node fields. So the
new Node.Defn is not modified, its lhs still refer to old node
instead of new one.

To fix this, we need to do two things:

 - In subst.clovar, set a dummy Defn node for inlvar
 - During subst.node, when seeing OAS/OAS2 nodes, after substituting, we
   check if any node in lhs has the dummy Defn, then set it to the current
   OAS/OAS2 node.

Fixes #45606

Change-Id: Ib517b753a7643756dcd61d36deae60f1a0fc53c5
Reviewed-on: https://go-review.googlesource.com/c/go/+/312630
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/inline/inl.go | 31 +++++++++++++++++++++++++-
 test/fixedbugs/issue45606.go           | 17 ++++++++++++++
 2 files changed, 47 insertions(+), 1 deletion(-)
 create mode 100644 test/fixedbugs/issue45606.go

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 3cbe932d55..54fcb2b830 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -1002,6 +1002,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 		retvars:      retvars,
 		delayretvars: delayretvars,
 		inlvars:      inlvars,
+		defnMarker:   ir.NilExpr{},
 		bases:        make(map[*src.PosBase]*src.PosBase),
 		newInlIndex:  newIndex,
 		fn:           fn,
@@ -1103,6 +1104,10 @@ type inlsubst struct {
 	delayretvars bool
 
 	inlvars map[*ir.Name]*ir.Name
+	// defnMarker is used to mark a Node for reassignment.
+	// inlsubst.clovar set this during creating new ONAME.
+	// inlsubst.node will set the correct Defn for inlvar.
+	defnMarker ir.NilExpr
 
 	// bases maps from original PosBase to PosBase with an extra
 	// inlined call frame.
@@ -1160,7 +1165,11 @@ func (subst *inlsubst) clovar(n *ir.Name) *ir.Name {
 	m := &ir.Name{}
 	*m = *n
 	m.Curfn = subst.newclofn
-	if n.Defn != nil && n.Defn.Op() == ir.ONAME {
+
+	switch defn := n.Defn.(type) {
+	case nil:
+		// ok
+	case *ir.Name:
 		if !n.IsClosureVar() {
 			base.FatalfAt(n.Pos(), "want closure variable, got: %+v", n)
 		}
@@ -1182,7 +1191,13 @@ func (subst *inlsubst) clovar(n *ir.Name) *ir.Name {
 		if subst.inlvars[n.Defn.(*ir.Name)] != nil {
 			m.Defn = subst.node(n.Defn)
 		}
+	case *ir.AssignStmt, *ir.AssignListStmt:
+		// Mark node for reassignment at the end of inlsubst.node.
+		m.Defn = &subst.defnMarker
+	default:
+		base.FatalfAt(n.Pos(), "unexpected Defn: %+v", defn)
 	}
+
 	if n.Outer != nil {
 		// Either the outer variable is defined in function being inlined,
 		// and we will replace it with the substituted variable, or it is
@@ -1406,6 +1421,20 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 	m := ir.Copy(n)
 	m.SetPos(subst.updatedPos(m.Pos()))
 	ir.EditChildren(m, subst.edit)
+
+	switch m := m.(type) {
+	case *ir.AssignStmt:
+		if lhs, ok := m.X.(*ir.Name); ok && lhs.Defn == &subst.defnMarker {
+			lhs.Defn = m
+		}
+	case *ir.AssignListStmt:
+		for _, lhs := range m.Lhs {
+			if lhs, ok := lhs.(*ir.Name); ok && lhs.Defn == &subst.defnMarker {
+				lhs.Defn = m
+			}
+		}
+	}
+
 	return m
 }
 
diff --git a/test/fixedbugs/issue45606.go b/test/fixedbugs/issue45606.go
new file mode 100644
index 0000000000..1b52b4e7d5
--- /dev/null
+++ b/test/fixedbugs/issue45606.go
@@ -0,0 +1,17 @@
+// compile
+
+// Copyright 2021 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 p
+
+func x() {
+	func() func() {
+		return func() {
+			f := func() {}
+			g, _ := f, 0
+			g()
+		}
+	}()()
+}
-- 
GitLab


From 5963f0a332496a68f1eb2d0c6a5badd73c9f046d Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Fri, 23 Apr 2021 09:31:19 +0700
Subject: [PATCH 1729/2400] cmd/vendor: get golang.org/x/tools@f946a157eef

To bring in the fix for sigchanyzer pass to detect valid usage of
unbuffer channel to builtin make.

Fixes #45043

Change-Id: I60d2ee90f7c111183b33747008903a7df88b76ca
Reviewed-on: https://go-review.googlesource.com/c/go/+/312631
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go.mod                                |  3 +-
 src/cmd/go.sum                                | 21 +++--
 .../unix/{asm_darwin_386.s => asm_bsd_386.s}  | 10 +--
 .../{asm_darwin_amd64.s => asm_bsd_amd64.s}   |  8 +-
 .../unix/{asm_netbsd_arm.s => asm_bsd_arm.s}  |  8 +-
 .../{asm_netbsd_amd64.s => asm_bsd_arm64.s}   |  8 +-
 .../golang.org/x/sys/unix/asm_darwin_arm.s    | 30 -------
 .../golang.org/x/sys/unix/asm_darwin_arm64.s  | 30 -------
 .../x/sys/unix/asm_dragonfly_amd64.s          | 29 -------
 .../golang.org/x/sys/unix/asm_freebsd_386.s   | 29 -------
 .../golang.org/x/sys/unix/asm_freebsd_amd64.s | 29 -------
 .../golang.org/x/sys/unix/asm_freebsd_arm.s   | 29 -------
 .../golang.org/x/sys/unix/asm_freebsd_arm64.s | 29 -------
 .../golang.org/x/sys/unix/asm_netbsd_386.s    | 29 -------
 .../golang.org/x/sys/unix/asm_netbsd_arm64.s  | 29 -------
 .../golang.org/x/sys/unix/asm_openbsd_386.s   | 29 -------
 .../golang.org/x/sys/unix/asm_openbsd_amd64.s | 29 -------
 .../golang.org/x/sys/unix/asm_openbsd_arm.s   | 29 -------
 .../golang.org/x/sys/unix/asm_openbsd_arm64.s | 29 -------
 src/cmd/vendor/golang.org/x/sys/unix/mkall.sh |  2 +-
 .../vendor/golang.org/x/sys/unix/mkerrors.sh  |  9 +-
 .../golang.org/x/sys/unix/syscall_aix.go      |  2 +-
 .../golang.org/x/sys/unix/syscall_illumos.go  | 53 +++++++++++-
 .../golang.org/x/sys/unix/syscall_linux.go    |  1 +
 .../x/sys/unix/syscall_linux_s390x.go         |  2 +-
 .../golang.org/x/sys/unix/syscall_solaris.go  |  7 +-
 .../x/sys/unix/zerrors_darwin_amd64.go        | 25 ++++++
 .../x/sys/unix/zerrors_darwin_arm64.go        | 25 ++++++
 .../x/sys/unix/zerrors_freebsd_arm.go         |  9 ++
 .../golang.org/x/sys/unix/zerrors_linux.go    |  5 ++
 .../x/sys/unix/zerrors_solaris_amd64.go       |  3 +
 .../x/sys/unix/zerrors_zos_s390x.go           |  1 +
 .../x/sys/unix/zsyscall_illumos_amd64.go      | 28 ++++++-
 .../golang.org/x/sys/unix/zsyscall_linux.go   | 10 +++
 .../x/sys/unix/zsyscall_solaris_amd64.go      |  5 +-
 .../x/sys/unix/ztypes_illumos_amd64.go        | 40 +++++++++
 .../golang.org/x/sys/unix/ztypes_linux.go     | 11 +++
 .../x/sys/windows/security_windows.go         | 16 +++-
 .../golang.org/x/sys/windows/types_windows.go |  3 +
 .../go/analysis/passes/inspect/inspect.go     |  4 +-
 .../passes/sigchanyzer/sigchanyzer.go         | 18 ++++
 src/cmd/vendor/modules.txt                    |  5 +-
 src/go.mod                                    |  4 +-
 src/go.sum                                    |  9 +-
 .../x/net/dns/dnsmessage/message.go           | 83 ++++++++++++++++++-
 src/vendor/modules.txt                        |  4 +-
 46 files changed, 383 insertions(+), 438 deletions(-)
 rename src/cmd/vendor/golang.org/x/sys/unix/{asm_darwin_386.s => asm_bsd_386.s} (70%)
 rename src/cmd/vendor/golang.org/x/sys/unix/{asm_darwin_amd64.s => asm_bsd_amd64.s} (72%)
 rename src/cmd/vendor/golang.org/x/sys/unix/{asm_netbsd_arm.s => asm_bsd_arm.s} (74%)
 rename src/cmd/vendor/golang.org/x/sys/unix/{asm_netbsd_amd64.s => asm_bsd_arm64.s} (75%)
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/asm_darwin_arm.s
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/asm_darwin_arm64.s
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/asm_dragonfly_amd64.s
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/asm_freebsd_386.s
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/asm_freebsd_amd64.s
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/asm_freebsd_arm.s
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/asm_freebsd_arm64.s
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/asm_netbsd_386.s
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/asm_netbsd_arm64.s
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_386.s
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_amd64.s
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_arm.s
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_arm64.s
 create mode 100644 src/cmd/vendor/golang.org/x/sys/unix/ztypes_illumos_amd64.go

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index ad899ab4bd..c5f3271a9d 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -7,7 +7,6 @@ require (
 	golang.org/x/arch v0.0.0-20210308155006-05f8f0431f72
 	golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 // indirect
 	golang.org/x/mod v0.4.3-0.20210409134425-858fdbee9c24
-	golang.org/x/sys v0.0.0-20210309074719-68d13333faf2 // indirect
 	golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d
-	golang.org/x/tools v0.1.1-0.20210312185553-8e4f4c86593a
+	golang.org/x/tools v0.1.1-0.20210422170518-f946a157eefe
 )
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 84f42376a3..0f13c366d0 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -5,40 +5,39 @@ github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5 h1:zIaiqGYDQwa4HVx5wG
 github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
 github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639 h1:mV02weKRL81bEnm8A0HT1/CAelMQDBuQIfLw8n+d6xI=
 github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
-github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.3.3/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
 golang.org/x/arch v0.0.0-20210308155006-05f8f0431f72 h1:CdaLHkic8S6xdhpWgHmtWij2rv2DTGwPuJZjjEDGk2w=
 golang.org/x/arch v0.0.0-20210308155006-05f8f0431f72/go.mod h1:flIaEI6LNU6xOCD5PaJvn9wGP0agmIOqjrtsKGRguv4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 h1:/ZScEX8SfEmUGRHs0gxpqteO5nfNW6axyZbBdw9A12g=
 golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
-golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.3-0.20210409134425-858fdbee9c24 h1:XWBCOnD7qf8cYkORdr1AfVspwadsirSDgThkrje7nWs=
 golang.org/x/mod v0.4.3-0.20210409134425-858fdbee9c24/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210309074719-68d13333faf2 h1:46ULzRKLh1CwgRq2dC5SlBzEqqNCi8rreOZnNrbqcIY=
-golang.org/x/sys v0.0.0-20210309074719-68d13333faf2/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57 h1:F5Gozwx4I1xtr/sr/8CFbb57iKi3297KFs0QDbGN60A=
+golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d h1:SZxvLBoTP5yHO3Frd4z4vrF+DBX9vMVanchswa69toE=
 golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.1.1-0.20210312185553-8e4f4c86593a h1:dM42cKDDlU6VAcfE6/ANedIkHqAPncj3GWNGqjv0f0Q=
-golang.org/x/tools v0.1.1-0.20210312185553-8e4f4c86593a/go.mod h1:9bzcO0MWcOuT0tm1iBGzDVPshzfwoVvREIui8C+MHqU=
+golang.org/x/tools v0.1.1-0.20210422170518-f946a157eefe h1:HNJiwGJfGFN64PAg8ZAP2gPPqlFQb/RLlE4lNoozcrw=
+golang.org/x/tools v0.1.1-0.20210422170518-f946a157eefe/go.mod h1:q7cPXv+8VGj9Sx5ckHx2nzMtCSaZFrowzWpjN/cwVb8=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_darwin_386.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_bsd_386.s
similarity index 70%
rename from src/cmd/vendor/golang.org/x/sys/unix/asm_darwin_386.s
rename to src/cmd/vendor/golang.org/x/sys/unix/asm_bsd_386.s
index 8a06b87d71..7f29275fa0 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_darwin_386.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/asm_bsd_386.s
@@ -1,14 +1,14 @@
-// Copyright 2009 The Go Authors. All rights reserved.
+// Copyright 2021 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.
 
+//go:build (darwin || freebsd || netbsd || openbsd) && gc
+// +build darwin freebsd netbsd openbsd
 // +build gc
 
 #include "textflag.h"
 
-//
-// System call support for 386, Darwin
-//
+// System call support for 386 BSD
 
 // Just jump to package syscall's implementation for all these functions.
 // The runtime may know about them.
@@ -22,7 +22,7 @@ TEXT	·Syscall6(SB),NOSPLIT,$0-40
 TEXT	·Syscall9(SB),NOSPLIT,$0-52
 	JMP	syscall·Syscall9(SB)
 
-TEXT ·RawSyscall(SB),NOSPLIT,$0-28
+TEXT	·RawSyscall(SB),NOSPLIT,$0-28
 	JMP	syscall·RawSyscall(SB)
 
 TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_darwin_amd64.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_bsd_amd64.s
similarity index 72%
rename from src/cmd/vendor/golang.org/x/sys/unix/asm_darwin_amd64.s
rename to src/cmd/vendor/golang.org/x/sys/unix/asm_bsd_amd64.s
index f2397fde55..2b99c349a2 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_darwin_amd64.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/asm_bsd_amd64.s
@@ -1,14 +1,14 @@
-// Copyright 2009 The Go Authors. All rights reserved.
+// Copyright 2021 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.
 
+//go:build (darwin || dragonfly || freebsd || netbsd || openbsd) && gc
+// +build darwin dragonfly freebsd netbsd openbsd
 // +build gc
 
 #include "textflag.h"
 
-//
-// System call support for AMD64, Darwin
-//
+// System call support for AMD64 BSD
 
 // Just jump to package syscall's implementation for all these functions.
 // The runtime may know about them.
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_netbsd_arm.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_bsd_arm.s
similarity index 74%
rename from src/cmd/vendor/golang.org/x/sys/unix/asm_netbsd_arm.s
rename to src/cmd/vendor/golang.org/x/sys/unix/asm_bsd_arm.s
index d7da175e1a..98ebfad9d5 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_netbsd_arm.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/asm_bsd_arm.s
@@ -1,14 +1,14 @@
-// Copyright 2013 The Go Authors. All rights reserved.
+// Copyright 2021 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.
 
+//go:build (darwin || freebsd || netbsd || openbsd) && gc
+// +build darwin freebsd netbsd openbsd
 // +build gc
 
 #include "textflag.h"
 
-//
-// System call support for ARM, NetBSD
-//
+// System call support for ARM BSD
 
 // Just jump to package syscall's implementation for all these functions.
 // The runtime may know about them.
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_netbsd_amd64.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_bsd_arm64.s
similarity index 75%
rename from src/cmd/vendor/golang.org/x/sys/unix/asm_netbsd_amd64.s
rename to src/cmd/vendor/golang.org/x/sys/unix/asm_bsd_arm64.s
index e57367c17a..fe36a7391a 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_netbsd_amd64.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/asm_bsd_arm64.s
@@ -1,14 +1,14 @@
-// Copyright 2009 The Go Authors. All rights reserved.
+// Copyright 2021 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.
 
+//go:build (darwin || freebsd || netbsd || openbsd) && gc
+// +build darwin freebsd netbsd openbsd
 // +build gc
 
 #include "textflag.h"
 
-//
-// System call support for AMD64, NetBSD
-//
+// System call support for ARM64 BSD
 
 // Just jump to package syscall's implementation for all these functions.
 // The runtime may know about them.
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_darwin_arm.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_darwin_arm.s
deleted file mode 100644
index c9e6b6fc8b..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_darwin_arm.s
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright 2015 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.
-
-// +build gc
-// +build arm,darwin
-
-#include "textflag.h"
-
-//
-// System call support for ARM, Darwin
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-28
-	B	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-40
-	B	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-52
-	B	syscall·Syscall9(SB)
-
-TEXT	·RawSyscall(SB),NOSPLIT,$0-28
-	B	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
-	B	syscall·RawSyscall6(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_darwin_arm64.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_darwin_arm64.s
deleted file mode 100644
index 89843f8f4b..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_darwin_arm64.s
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright 2015 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.
-
-// +build gc
-// +build arm64,darwin
-
-#include "textflag.h"
-
-//
-// System call support for AMD64, Darwin
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-56
-	B	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-80
-	B	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-104
-	B	syscall·Syscall9(SB)
-
-TEXT	·RawSyscall(SB),NOSPLIT,$0-56
-	B	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
-	B	syscall·RawSyscall6(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_dragonfly_amd64.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_dragonfly_amd64.s
deleted file mode 100644
index 27674e1caf..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_dragonfly_amd64.s
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2009 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.
-
-// +build gc
-
-#include "textflag.h"
-
-//
-// System call support for AMD64, DragonFly
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-56
-	JMP	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-104
-	JMP	syscall·Syscall9(SB)
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-56
-	JMP	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·RawSyscall6(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_freebsd_386.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_freebsd_386.s
deleted file mode 100644
index 49f0ac2364..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_freebsd_386.s
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2009 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.
-
-// +build gc
-
-#include "textflag.h"
-
-//
-// System call support for 386, FreeBSD
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-28
-	JMP	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-40
-	JMP	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-52
-	JMP	syscall·Syscall9(SB)
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-28
-	JMP	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
-	JMP	syscall·RawSyscall6(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_freebsd_amd64.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_freebsd_amd64.s
deleted file mode 100644
index f2dfc57b83..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_freebsd_amd64.s
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2009 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.
-
-// +build gc
-
-#include "textflag.h"
-
-//
-// System call support for AMD64, FreeBSD
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-56
-	JMP	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-104
-	JMP	syscall·Syscall9(SB)
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-56
-	JMP	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·RawSyscall6(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_freebsd_arm.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_freebsd_arm.s
deleted file mode 100644
index 6d740db2c0..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_freebsd_arm.s
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2012 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.
-
-// +build gc
-
-#include "textflag.h"
-
-//
-// System call support for ARM, FreeBSD
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-28
-	B	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-40
-	B	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-52
-	B	syscall·Syscall9(SB)
-
-TEXT	·RawSyscall(SB),NOSPLIT,$0-28
-	B	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
-	B	syscall·RawSyscall6(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_freebsd_arm64.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_freebsd_arm64.s
deleted file mode 100644
index a8f5a29b35..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_freebsd_arm64.s
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2018 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.
-
-// +build gc
-
-#include "textflag.h"
-
-//
-// System call support for ARM64, FreeBSD
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-56
-	JMP	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-104
-	JMP	syscall·Syscall9(SB)
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-56
-	JMP	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·RawSyscall6(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_netbsd_386.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_netbsd_386.s
deleted file mode 100644
index ae7b498d50..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_netbsd_386.s
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2009 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.
-
-// +build gc
-
-#include "textflag.h"
-
-//
-// System call support for 386, NetBSD
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-28
-	JMP	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-40
-	JMP	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-52
-	JMP	syscall·Syscall9(SB)
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-28
-	JMP	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
-	JMP	syscall·RawSyscall6(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_netbsd_arm64.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_netbsd_arm64.s
deleted file mode 100644
index e7cbe1904c..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_netbsd_arm64.s
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2019 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.
-
-// +build gc
-
-#include "textflag.h"
-
-//
-// System call support for ARM64, NetBSD
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-56
-	B	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-80
-	B	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-104
-	B	syscall·Syscall9(SB)
-
-TEXT	·RawSyscall(SB),NOSPLIT,$0-56
-	B	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
-	B	syscall·RawSyscall6(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_386.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_386.s
deleted file mode 100644
index 2f00b0310f..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_386.s
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2009 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.
-
-// +build gc
-
-#include "textflag.h"
-
-//
-// System call support for 386, OpenBSD
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-28
-	JMP	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-40
-	JMP	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-52
-	JMP	syscall·Syscall9(SB)
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-28
-	JMP	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
-	JMP	syscall·RawSyscall6(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_amd64.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_amd64.s
deleted file mode 100644
index 07632c99ce..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_amd64.s
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2009 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.
-
-// +build gc
-
-#include "textflag.h"
-
-//
-// System call support for AMD64, OpenBSD
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-56
-	JMP	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-104
-	JMP	syscall·Syscall9(SB)
-
-TEXT	·RawSyscall(SB),NOSPLIT,$0-56
-	JMP	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·RawSyscall6(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_arm.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_arm.s
deleted file mode 100644
index 73e997320f..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_arm.s
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2017 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.
-
-// +build gc
-
-#include "textflag.h"
-
-//
-// System call support for ARM, OpenBSD
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-28
-	B	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-40
-	B	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-52
-	B	syscall·Syscall9(SB)
-
-TEXT	·RawSyscall(SB),NOSPLIT,$0-28
-	B	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
-	B	syscall·RawSyscall6(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_arm64.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_arm64.s
deleted file mode 100644
index c47302aa46..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_arm64.s
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2019 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.
-
-// +build gc
-
-#include "textflag.h"
-
-//
-// System call support for arm64, OpenBSD
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-56
-	JMP	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-104
-	JMP	syscall·Syscall9(SB)
-
-TEXT	·RawSyscall(SB),NOSPLIT,$0-56
-	JMP	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·RawSyscall6(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/mkall.sh b/src/cmd/vendor/golang.org/x/sys/unix/mkall.sh
index d257fac505..d727cad19c 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/mkall.sh
+++ b/src/cmd/vendor/golang.org/x/sys/unix/mkall.sh
@@ -199,7 +199,7 @@ illumos_amd64)
         mksyscall="go run mksyscall_solaris.go"
 	mkerrors=
 	mksysnum=
-	mktypes=
+	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
 	;;
 *)
 	echo 'unrecognized $GOOS_$GOARCH: ' "$GOOSARCH" 1>&2
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/mkerrors.sh b/src/cmd/vendor/golang.org/x/sys/unix/mkerrors.sh
index 87f9d1e351..007358af8f 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/mkerrors.sh
+++ b/src/cmd/vendor/golang.org/x/sys/unix/mkerrors.sh
@@ -56,6 +56,7 @@ includes_Darwin='
 #define _DARWIN_C_SOURCE
 #define KERNEL
 #define _DARWIN_USE_64_BIT_INODE
+#define __APPLE_USE_RFC_3542
 #include <stdint.h>
 #include <sys/attr.h>
 #include <sys/clonefile.h>
@@ -216,6 +217,7 @@ struct ltchars {
 #include <linux/genetlink.h>
 #include <linux/hdreg.h>
 #include <linux/hidraw.h>
+#include <linux/icmp.h>
 #include <linux/icmpv6.h>
 #include <linux/if.h>
 #include <linux/if_addr.h>
@@ -403,10 +405,11 @@ includes_SunOS='
 #include <net/if_arp.h>
 #include <net/if_types.h>
 #include <net/route.h>
+#include <netinet/icmp6.h>
 #include <netinet/in.h>
-#include <termios.h>
 #include <netinet/ip.h>
 #include <netinet/ip_mroute.h>
+#include <termios.h>
 '
 
 
@@ -497,10 +500,10 @@ ccflags="$@"
 		$2 ~ /^LOCK_(SH|EX|NB|UN)$/ ||
 		$2 ~ /^LO_(KEY|NAME)_SIZE$/ ||
 		$2 ~ /^LOOP_(CLR|CTL|GET|SET)_/ ||
-		$2 ~ /^(AF|SOCK|SO|SOL|IPPROTO|IP|IPV6|ICMP6|TCP|MCAST|EVFILT|NOTE|SHUT|PROT|MAP|MFD|T?PACKET|MSG|SCM|MCL|DT|MADV|PR|LOCAL)_/ ||
+		$2 ~ /^(AF|SOCK|SO|SOL|IPPROTO|IP|IPV6|TCP|MCAST|EVFILT|NOTE|SHUT|PROT|MAP|MFD|T?PACKET|MSG|SCM|MCL|DT|MADV|PR|LOCAL)_/ ||
 		$2 ~ /^TP_STATUS_/ ||
 		$2 ~ /^FALLOC_/ ||
-		$2 == "ICMPV6_FILTER" ||
+		$2 ~ /^ICMPV?6?_(FILTER|SEC)/ ||
 		$2 == "SOMAXCONN" ||
 		$2 == "NAME_MAX" ||
 		$2 == "IFNAMSIZ" ||
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix.go
index d2723225ec..d8efb715ff 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix.go
@@ -252,7 +252,7 @@ func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) {
 			}
 		}
 
-		bytes := (*[10000]byte)(unsafe.Pointer(&pp.Path[0]))[0:n]
+		bytes := (*[len(pp.Path)]byte)(unsafe.Pointer(&pp.Path[0]))[0:n]
 		sa.Name = string(bytes)
 		return sa, nil
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_illumos.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_illumos.go
index bc442e3bac..c5c58806ca 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_illumos.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_illumos.go
@@ -9,7 +9,9 @@
 
 package unix
 
-import "unsafe"
+import (
+	"unsafe"
+)
 
 func bytes2iovec(bs [][]byte) []Iovec {
 	iovecs := make([]Iovec, len(bs))
@@ -76,3 +78,52 @@ func Accept4(fd int, flags int) (nfd int, sa Sockaddr, err error) {
 	}
 	return
 }
+
+//sys	putmsg(fd int, clptr *strbuf, dataptr *strbuf, flags int) (err error)
+
+func Putmsg(fd int, cl []byte, data []byte, flags int) (err error) {
+	var clp, datap *strbuf
+	if len(cl) > 0 {
+		clp = &strbuf{
+			Len: int32(len(cl)),
+			Buf: (*int8)(unsafe.Pointer(&cl[0])),
+		}
+	}
+	if len(data) > 0 {
+		datap = &strbuf{
+			Len: int32(len(data)),
+			Buf: (*int8)(unsafe.Pointer(&data[0])),
+		}
+	}
+	return putmsg(fd, clp, datap, flags)
+}
+
+//sys	getmsg(fd int, clptr *strbuf, dataptr *strbuf, flags *int) (err error)
+
+func Getmsg(fd int, cl []byte, data []byte) (retCl []byte, retData []byte, flags int, err error) {
+	var clp, datap *strbuf
+	if len(cl) > 0 {
+		clp = &strbuf{
+			Maxlen: int32(len(cl)),
+			Buf:    (*int8)(unsafe.Pointer(&cl[0])),
+		}
+	}
+	if len(data) > 0 {
+		datap = &strbuf{
+			Maxlen: int32(len(data)),
+			Buf:    (*int8)(unsafe.Pointer(&data[0])),
+		}
+	}
+
+	if err = getmsg(fd, clp, datap, &flags); err != nil {
+		return nil, nil, 0, err
+	}
+
+	if len(cl) > 0 {
+		retCl = cl[:clp.Len]
+	}
+	if len(data) > 0 {
+		retData = data[:datap.Len]
+	}
+	return retCl, retData, flags, nil
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go
index 0a48548e80..44ea96e39c 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go
@@ -1877,6 +1877,7 @@ func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err e
 //sys	ClockGettime(clockid int32, time *Timespec) (err error)
 //sys	ClockNanosleep(clockid int32, flags int, request *Timespec, remain *Timespec) (err error)
 //sys	Close(fd int) (err error)
+//sys	CloseRange(first uint, last uint, flags uint) (err error)
 //sys	CopyFileRange(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int, err error)
 //sys	DeleteModule(name string, flags int) (err error)
 //sys	Dup(oldfd int) (fd int, err error)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_s390x.go
index a941d88815..a1e45694b4 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_s390x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_s390x.go
@@ -250,7 +250,7 @@ func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen
 }
 
 func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) error {
-	args := [4]uintptr{uintptr(s), uintptr(level), uintptr(name), uintptr(val)}
+	args := [5]uintptr{uintptr(s), uintptr(level), uintptr(name), uintptr(val), vallen}
 	_, _, err := Syscall(SYS_SOCKETCALL, netSetSockOpt, uintptr(unsafe.Pointer(&args)), 0)
 	if err != 0 {
 		return err
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_solaris.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_solaris.go
index 169497f062..77fcde7c18 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_solaris.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_solaris.go
@@ -565,7 +565,12 @@ func Minor(dev uint64) uint32 {
  * Expose the ioctl function
  */
 
-//sys	ioctl(fd int, req uint, arg uintptr) (err error)
+//sys	ioctlRet(fd int, req uint, arg uintptr) (ret int, err error) = libc.ioctl
+
+func ioctl(fd int, req uint, arg uintptr) (err error) {
+	_, err = ioctlRet(fd, req, arg)
+	return err
+}
 
 func IoctlSetTermio(fd int, req uint, value *Termio) error {
 	err := ioctl(fd, req, uintptr(unsafe.Pointer(value)))
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
index 0100cb12f1..991996b609 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
@@ -776,15 +776,24 @@ const (
 	IPV6_2292PKTINFO                  = 0x13
 	IPV6_2292PKTOPTIONS               = 0x19
 	IPV6_2292RTHDR                    = 0x18
+	IPV6_3542DSTOPTS                  = 0x32
+	IPV6_3542HOPLIMIT                 = 0x2f
+	IPV6_3542HOPOPTS                  = 0x31
+	IPV6_3542NEXTHOP                  = 0x30
+	IPV6_3542PKTINFO                  = 0x2e
+	IPV6_3542RTHDR                    = 0x33
 	IPV6_ADDR_MC_FLAGS_PREFIX         = 0x20
 	IPV6_ADDR_MC_FLAGS_TRANSIENT      = 0x10
 	IPV6_ADDR_MC_FLAGS_UNICAST_BASED  = 0x30
+	IPV6_AUTOFLOWLABEL                = 0x3b
 	IPV6_BINDV6ONLY                   = 0x1b
 	IPV6_BOUND_IF                     = 0x7d
 	IPV6_CHECKSUM                     = 0x1a
 	IPV6_DEFAULT_MULTICAST_HOPS       = 0x1
 	IPV6_DEFAULT_MULTICAST_LOOP       = 0x1
 	IPV6_DEFHLIM                      = 0x40
+	IPV6_DONTFRAG                     = 0x3e
+	IPV6_DSTOPTS                      = 0x32
 	IPV6_FAITH                        = 0x1d
 	IPV6_FLOWINFO_MASK                = 0xffffff0f
 	IPV6_FLOWLABEL_MASK               = 0xffff0f00
@@ -796,6 +805,8 @@ const (
 	IPV6_FW_GET                       = 0x22
 	IPV6_FW_ZERO                      = 0x21
 	IPV6_HLIMDEC                      = 0x1
+	IPV6_HOPLIMIT                     = 0x2f
+	IPV6_HOPOPTS                      = 0x31
 	IPV6_IPSEC_POLICY                 = 0x1c
 	IPV6_JOIN_GROUP                   = 0xc
 	IPV6_LEAVE_GROUP                  = 0xd
@@ -807,20 +818,34 @@ const (
 	IPV6_MAX_SOCK_SRC_FILTER          = 0x80
 	IPV6_MIN_MEMBERSHIPS              = 0x1f
 	IPV6_MMTU                         = 0x500
+	IPV6_MSFILTER                     = 0x4a
 	IPV6_MULTICAST_HOPS               = 0xa
 	IPV6_MULTICAST_IF                 = 0x9
 	IPV6_MULTICAST_LOOP               = 0xb
+	IPV6_NEXTHOP                      = 0x30
+	IPV6_PATHMTU                      = 0x2c
+	IPV6_PKTINFO                      = 0x2e
 	IPV6_PORTRANGE                    = 0xe
 	IPV6_PORTRANGE_DEFAULT            = 0x0
 	IPV6_PORTRANGE_HIGH               = 0x1
 	IPV6_PORTRANGE_LOW                = 0x2
+	IPV6_PREFER_TEMPADDR              = 0x3f
+	IPV6_RECVDSTOPTS                  = 0x28
+	IPV6_RECVHOPLIMIT                 = 0x25
+	IPV6_RECVHOPOPTS                  = 0x27
+	IPV6_RECVPATHMTU                  = 0x2b
+	IPV6_RECVPKTINFO                  = 0x3d
+	IPV6_RECVRTHDR                    = 0x26
 	IPV6_RECVTCLASS                   = 0x23
+	IPV6_RTHDR                        = 0x33
+	IPV6_RTHDRDSTOPTS                 = 0x39
 	IPV6_RTHDR_LOOSE                  = 0x0
 	IPV6_RTHDR_STRICT                 = 0x1
 	IPV6_RTHDR_TYPE_0                 = 0x0
 	IPV6_SOCKOPT_RESERVED1            = 0x3
 	IPV6_TCLASS                       = 0x24
 	IPV6_UNICAST_HOPS                 = 0x4
+	IPV6_USE_MIN_MTU                  = 0x2a
 	IPV6_V6ONLY                       = 0x1b
 	IPV6_VERSION                      = 0x60
 	IPV6_VERSION_MASK                 = 0xf0
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
index df26a19681..e644eaf5e7 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
@@ -776,15 +776,24 @@ const (
 	IPV6_2292PKTINFO                  = 0x13
 	IPV6_2292PKTOPTIONS               = 0x19
 	IPV6_2292RTHDR                    = 0x18
+	IPV6_3542DSTOPTS                  = 0x32
+	IPV6_3542HOPLIMIT                 = 0x2f
+	IPV6_3542HOPOPTS                  = 0x31
+	IPV6_3542NEXTHOP                  = 0x30
+	IPV6_3542PKTINFO                  = 0x2e
+	IPV6_3542RTHDR                    = 0x33
 	IPV6_ADDR_MC_FLAGS_PREFIX         = 0x20
 	IPV6_ADDR_MC_FLAGS_TRANSIENT      = 0x10
 	IPV6_ADDR_MC_FLAGS_UNICAST_BASED  = 0x30
+	IPV6_AUTOFLOWLABEL                = 0x3b
 	IPV6_BINDV6ONLY                   = 0x1b
 	IPV6_BOUND_IF                     = 0x7d
 	IPV6_CHECKSUM                     = 0x1a
 	IPV6_DEFAULT_MULTICAST_HOPS       = 0x1
 	IPV6_DEFAULT_MULTICAST_LOOP       = 0x1
 	IPV6_DEFHLIM                      = 0x40
+	IPV6_DONTFRAG                     = 0x3e
+	IPV6_DSTOPTS                      = 0x32
 	IPV6_FAITH                        = 0x1d
 	IPV6_FLOWINFO_MASK                = 0xffffff0f
 	IPV6_FLOWLABEL_MASK               = 0xffff0f00
@@ -796,6 +805,8 @@ const (
 	IPV6_FW_GET                       = 0x22
 	IPV6_FW_ZERO                      = 0x21
 	IPV6_HLIMDEC                      = 0x1
+	IPV6_HOPLIMIT                     = 0x2f
+	IPV6_HOPOPTS                      = 0x31
 	IPV6_IPSEC_POLICY                 = 0x1c
 	IPV6_JOIN_GROUP                   = 0xc
 	IPV6_LEAVE_GROUP                  = 0xd
@@ -807,20 +818,34 @@ const (
 	IPV6_MAX_SOCK_SRC_FILTER          = 0x80
 	IPV6_MIN_MEMBERSHIPS              = 0x1f
 	IPV6_MMTU                         = 0x500
+	IPV6_MSFILTER                     = 0x4a
 	IPV6_MULTICAST_HOPS               = 0xa
 	IPV6_MULTICAST_IF                 = 0x9
 	IPV6_MULTICAST_LOOP               = 0xb
+	IPV6_NEXTHOP                      = 0x30
+	IPV6_PATHMTU                      = 0x2c
+	IPV6_PKTINFO                      = 0x2e
 	IPV6_PORTRANGE                    = 0xe
 	IPV6_PORTRANGE_DEFAULT            = 0x0
 	IPV6_PORTRANGE_HIGH               = 0x1
 	IPV6_PORTRANGE_LOW                = 0x2
+	IPV6_PREFER_TEMPADDR              = 0x3f
+	IPV6_RECVDSTOPTS                  = 0x28
+	IPV6_RECVHOPLIMIT                 = 0x25
+	IPV6_RECVHOPOPTS                  = 0x27
+	IPV6_RECVPATHMTU                  = 0x2b
+	IPV6_RECVPKTINFO                  = 0x3d
+	IPV6_RECVRTHDR                    = 0x26
 	IPV6_RECVTCLASS                   = 0x23
+	IPV6_RTHDR                        = 0x33
+	IPV6_RTHDRDSTOPTS                 = 0x39
 	IPV6_RTHDR_LOOSE                  = 0x0
 	IPV6_RTHDR_STRICT                 = 0x1
 	IPV6_RTHDR_TYPE_0                 = 0x0
 	IPV6_SOCKOPT_RESERVED1            = 0x3
 	IPV6_TCLASS                       = 0x24
 	IPV6_UNICAST_HOPS                 = 0x4
+	IPV6_USE_MIN_MTU                  = 0x2a
 	IPV6_V6ONLY                       = 0x1b
 	IPV6_VERSION                      = 0x60
 	IPV6_VERSION_MASK                 = 0xf0
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_freebsd_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_freebsd_arm.go
index 0326a6b3af..3df99f285f 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_freebsd_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_freebsd_arm.go
@@ -1022,6 +1022,15 @@ const (
 	MAP_RESERVED0100               = 0x100
 	MAP_SHARED                     = 0x1
 	MAP_STACK                      = 0x400
+	MCAST_BLOCK_SOURCE             = 0x54
+	MCAST_EXCLUDE                  = 0x2
+	MCAST_INCLUDE                  = 0x1
+	MCAST_JOIN_GROUP               = 0x50
+	MCAST_JOIN_SOURCE_GROUP        = 0x52
+	MCAST_LEAVE_GROUP              = 0x51
+	MCAST_LEAVE_SOURCE_GROUP       = 0x53
+	MCAST_UNBLOCK_SOURCE           = 0x55
+	MCAST_UNDEFINED                = 0x0
 	MCL_CURRENT                    = 0x1
 	MCL_FUTURE                     = 0x2
 	MNT_ACLS                       = 0x8000000
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux.go
index 504dd6cd2d..35de419c6d 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux.go
@@ -974,6 +974,11 @@ const (
 	HUGETLBFS_MAGIC                             = 0x958458f6
 	IBSHIFT                                     = 0x10
 	ICMPV6_FILTER                               = 0x1
+	ICMPV6_FILTER_BLOCK                         = 0x1
+	ICMPV6_FILTER_BLOCKOTHERS                   = 0x3
+	ICMPV6_FILTER_PASS                          = 0x2
+	ICMPV6_FILTER_PASSONLY                      = 0x4
+	ICMP_FILTER                                 = 0x1
 	ICRNL                                       = 0x100
 	IFA_F_DADFAILED                             = 0x8
 	IFA_F_DEPRECATED                            = 0x20
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_solaris_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_solaris_amd64.go
index 65fb2c5cd8..1afee6a089 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_solaris_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_solaris_amd64.go
@@ -366,6 +366,7 @@ const (
 	HUPCL                         = 0x400
 	IBSHIFT                       = 0x10
 	ICANON                        = 0x2
+	ICMP6_FILTER                  = 0x1
 	ICRNL                         = 0x100
 	IEXTEN                        = 0x8000
 	IFF_ADDRCONF                  = 0x80000
@@ -612,6 +613,7 @@ const (
 	IP_RECVPKTINFO                = 0x1a
 	IP_RECVRETOPTS                = 0x6
 	IP_RECVSLLA                   = 0xa
+	IP_RECVTOS                    = 0xc
 	IP_RECVTTL                    = 0xb
 	IP_RETOPTS                    = 0x8
 	IP_REUSEADDR                  = 0x104
@@ -704,6 +706,7 @@ const (
 	O_APPEND                      = 0x8
 	O_CLOEXEC                     = 0x800000
 	O_CREAT                       = 0x100
+	O_DIRECT                      = 0x2000000
 	O_DIRECTORY                   = 0x1000000
 	O_DSYNC                       = 0x40
 	O_EXCL                        = 0x400
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go
index 4117ce08a5..c8c7909038 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go
@@ -137,6 +137,7 @@ const (
 	IP_TTL                          = 3
 	IP_UNBLOCK_SOURCE               = 11
 	ICANON                          = 0x0010
+	ICMP6_FILTER                    = 0x26
 	ICRNL                           = 0x0002
 	IEXTEN                          = 0x0020
 	IGNBRK                          = 0x0004
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_illumos_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_illumos_amd64.go
index b57c7050d7..af5cb064ec 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_illumos_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_illumos_amd64.go
@@ -15,19 +15,25 @@ import (
 //go:cgo_import_dynamic libc_writev writev "libc.so"
 //go:cgo_import_dynamic libc_pwritev pwritev "libc.so"
 //go:cgo_import_dynamic libc_accept4 accept4 "libsocket.so"
+//go:cgo_import_dynamic libc_putmsg putmsg "libc.so"
+//go:cgo_import_dynamic libc_getmsg getmsg "libc.so"
 
 //go:linkname procreadv libc_readv
 //go:linkname procpreadv libc_preadv
 //go:linkname procwritev libc_writev
 //go:linkname procpwritev libc_pwritev
 //go:linkname procaccept4 libc_accept4
+//go:linkname procputmsg libc_putmsg
+//go:linkname procgetmsg libc_getmsg
 
 var (
 	procreadv,
 	procpreadv,
 	procwritev,
 	procpwritev,
-	procaccept4 syscallFunc
+	procaccept4,
+	procputmsg,
+	procgetmsg syscallFunc
 )
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -100,3 +106,23 @@ func accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int,
 	}
 	return
 }
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func putmsg(fd int, clptr *strbuf, dataptr *strbuf, flags int) (err error) {
+	_, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procputmsg)), 4, uintptr(fd), uintptr(unsafe.Pointer(clptr)), uintptr(unsafe.Pointer(dataptr)), uintptr(flags), 0, 0)
+	if e1 != 0 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func getmsg(fd int, clptr *strbuf, dataptr *strbuf, flags *int) (err error) {
+	_, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procgetmsg)), 4, uintptr(fd), uintptr(unsafe.Pointer(clptr)), uintptr(unsafe.Pointer(dataptr)), uintptr(unsafe.Pointer(flags)), 0, 0)
+	if e1 != 0 {
+		err = e1
+	}
+	return
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux.go
index 3ee26f4ad1..7305cc915b 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux.go
@@ -532,6 +532,16 @@ func Close(fd int) (err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func CloseRange(first uint, last uint, flags uint) (err error) {
+	_, _, e1 := Syscall(SYS_CLOSE_RANGE, uintptr(first), uintptr(last), uintptr(flags))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func CopyFileRange(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int, err error) {
 	r0, _, e1 := Syscall6(SYS_COPY_FILE_RANGE, uintptr(rfd), uintptr(unsafe.Pointer(roff)), uintptr(wfd), uintptr(unsafe.Pointer(woff)), uintptr(len), uintptr(flags))
 	n = int(r0)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go
index 7099f555aa..4e18d5c99f 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go
@@ -619,8 +619,9 @@ func __minor(version int, dev uint64) (val uint) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func ioctl(fd int, req uint, arg uintptr) (err error) {
-	_, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procioctl)), 3, uintptr(fd), uintptr(req), uintptr(arg), 0, 0, 0)
+func ioctlRet(fd int, req uint, arg uintptr) (ret int, err error) {
+	r0, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procioctl)), 3, uintptr(fd), uintptr(req), uintptr(arg), 0, 0, 0)
+	ret = int(r0)
 	if e1 != 0 {
 		err = e1
 	}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_illumos_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_illumos_amd64.go
new file mode 100644
index 0000000000..1137a5a1f4
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_illumos_amd64.go
@@ -0,0 +1,40 @@
+// cgo -godefs types_illumos.go | go run mkpost.go
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+//go:build amd64 && illumos
+// +build amd64,illumos
+
+package unix
+
+const (
+	TUNNEWPPA = 0x540001
+	TUNSETPPA = 0x540002
+
+	I_STR     = 0x5308
+	I_POP     = 0x5303
+	I_PUSH    = 0x5302
+	I_PLINK   = 0x5316
+	I_PUNLINK = 0x5317
+
+	IF_UNITSEL = -0x7ffb8cca
+)
+
+type strbuf struct {
+	Maxlen int32
+	Len    int32
+	Buf    *int8
+}
+
+type strioctl struct {
+	Cmd    int32
+	Timout int32
+	Len    int32
+	Dp     *int8
+}
+
+type lifreq struct {
+	Name   [32]int8
+	Lifru1 [4]byte
+	Type   uint32
+	Lifru  [336]byte
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go
index d3a18713bb..c769e73cd6 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go
@@ -3709,3 +3709,14 @@ type (
 		Product int16
 	}
 )
+
+const (
+	CLOSE_RANGE_UNSHARE = 0x2
+	CLOSE_RANGE_CLOEXEC = 0x4
+)
+
+const (
+	NLMSGERR_ATTR_MSG    = 0x1
+	NLMSGERR_ATTR_OFFS   = 0x2
+	NLMSGERR_ATTR_COOKIE = 0x3
+)
diff --git a/src/cmd/vendor/golang.org/x/sys/windows/security_windows.go b/src/cmd/vendor/golang.org/x/sys/windows/security_windows.go
index 0e428ecbbd..111c10d3a7 100644
--- a/src/cmd/vendor/golang.org/x/sys/windows/security_windows.go
+++ b/src/cmd/vendor/golang.org/x/sys/windows/security_windows.go
@@ -1334,7 +1334,11 @@ func (absoluteSD *SECURITY_DESCRIPTOR) ToSelfRelative() (selfRelativeSD *SECURIT
 }
 
 func (selfRelativeSD *SECURITY_DESCRIPTOR) copySelfRelativeSecurityDescriptor() *SECURITY_DESCRIPTOR {
-	sdLen := (int)(selfRelativeSD.Length())
+	sdLen := int(selfRelativeSD.Length())
+	const min = int(unsafe.Sizeof(SECURITY_DESCRIPTOR{}))
+	if sdLen < min {
+		sdLen = min
+	}
 
 	var src []byte
 	h := (*unsafeheader.Slice)(unsafe.Pointer(&src))
@@ -1342,7 +1346,15 @@ func (selfRelativeSD *SECURITY_DESCRIPTOR) copySelfRelativeSecurityDescriptor()
 	h.Len = sdLen
 	h.Cap = sdLen
 
-	dst := make([]byte, sdLen)
+	const psize = int(unsafe.Sizeof(uintptr(0)))
+
+	var dst []byte
+	h = (*unsafeheader.Slice)(unsafe.Pointer(&dst))
+	alloc := make([]uintptr, (sdLen+psize-1)/psize)
+	h.Data = (*unsafeheader.Slice)(unsafe.Pointer(&alloc)).Data
+	h.Len = sdLen
+	h.Cap = sdLen
+
 	copy(dst, src)
 	return (*SECURITY_DESCRIPTOR)(unsafe.Pointer(&dst[0]))
 }
diff --git a/src/cmd/vendor/golang.org/x/sys/windows/types_windows.go b/src/cmd/vendor/golang.org/x/sys/windows/types_windows.go
index 369cc91da7..23fe18ecef 100644
--- a/src/cmd/vendor/golang.org/x/sys/windows/types_windows.go
+++ b/src/cmd/vendor/golang.org/x/sys/windows/types_windows.go
@@ -1020,6 +1020,7 @@ const (
 
 	// cf. http://support.microsoft.com/default.aspx?scid=kb;en-us;257460
 
+	IP_HDRINCL         = 0x2
 	IP_TOS             = 0x3
 	IP_TTL             = 0x4
 	IP_MULTICAST_IF    = 0x9
@@ -1027,6 +1028,7 @@ const (
 	IP_MULTICAST_LOOP  = 0xb
 	IP_ADD_MEMBERSHIP  = 0xc
 	IP_DROP_MEMBERSHIP = 0xd
+	IP_PKTINFO         = 0x13
 
 	IPV6_V6ONLY         = 0x1b
 	IPV6_UNICAST_HOPS   = 0x4
@@ -1035,6 +1037,7 @@ const (
 	IPV6_MULTICAST_LOOP = 0xb
 	IPV6_JOIN_GROUP     = 0xc
 	IPV6_LEAVE_GROUP    = 0xd
+	IPV6_PKTINFO        = 0x13
 
 	MSG_OOB       = 0x1
 	MSG_PEEK      = 0x2
diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/inspect/inspect.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/inspect/inspect.go
index 2856df137c..4bb652a726 100644
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/inspect/inspect.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/inspect/inspect.go
@@ -3,8 +3,8 @@
 // license that can be found in the LICENSE file.
 
 // Package inspect defines an Analyzer that provides an AST inspector
-// (golang.org/x/tools/go/ast/inspect.Inspect) for the syntax trees of a
-// package. It is only a building block for other analyzers.
+// (golang.org/x/tools/go/ast/inspector.Inspector) for the syntax trees
+// of a package. It is only a building block for other analyzers.
 //
 // Example of use in another analysis:
 //
diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/sigchanyzer/sigchanyzer.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/sigchanyzer/sigchanyzer.go
index 3d89061d17..b00aa7e144 100644
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/sigchanyzer/sigchanyzer.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/sigchanyzer/sigchanyzer.go
@@ -49,6 +49,11 @@ func run(pass *analysis.Pass) (interface{}, error) {
 				chanDecl = decl
 			}
 		case *ast.CallExpr:
+			// Only signal.Notify(make(chan os.Signal), os.Interrupt) is safe,
+			// conservatively treate others as not safe, see golang/go#45043
+			if isBuiltinMake(pass.TypesInfo, arg) {
+				return
+			}
 			chanDecl = arg
 		}
 		if chanDecl == nil || len(chanDecl.Args) != 1 {
@@ -127,3 +132,16 @@ func findDecl(arg *ast.Ident) ast.Node {
 	}
 	return nil
 }
+
+func isBuiltinMake(info *types.Info, call *ast.CallExpr) bool {
+	typVal := info.Types[call.Fun]
+	if !typVal.IsBuiltin() {
+		return false
+	}
+	switch fun := call.Fun.(type) {
+	case *ast.Ident:
+		return info.ObjectOf(fun).Name() == "make"
+	default:
+		return false
+	}
+}
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 80ccb2bf24..9229d2dc8b 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -38,8 +38,7 @@ golang.org/x/mod/sumdb/dirhash
 golang.org/x/mod/sumdb/note
 golang.org/x/mod/sumdb/tlog
 golang.org/x/mod/zip
-# golang.org/x/sys v0.0.0-20210309074719-68d13333faf2
-## explicit
+# golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57
 golang.org/x/sys/internal/unsafeheader
 golang.org/x/sys/plan9
 golang.org/x/sys/unix
@@ -47,7 +46,7 @@ golang.org/x/sys/windows
 # golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d
 ## explicit
 golang.org/x/term
-# golang.org/x/tools v0.1.1-0.20210312185553-8e4f4c86593a
+# golang.org/x/tools v0.1.1-0.20210422170518-f946a157eefe
 ## explicit
 golang.org/x/tools/cover
 golang.org/x/tools/go/analysis
diff --git a/src/go.mod b/src/go.mod
index 2ddab18077..89ad19d288 100644
--- a/src/go.mod
+++ b/src/go.mod
@@ -4,7 +4,7 @@ go 1.17
 
 require (
 	golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83
-	golang.org/x/net v0.0.0-20210226172049-e18ecbb05110
-	golang.org/x/sys v0.0.0-20210309074719-68d13333faf2 // indirect
+	golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4
+	golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57 // indirect
 	golang.org/x/text v0.3.6-0.20210227105805-e3aa4adf54f6 // indirect
 )
diff --git a/src/go.sum b/src/go.sum
index 85c7dd9268..034d8506f4 100644
--- a/src/go.sum
+++ b/src/go.sum
@@ -2,13 +2,14 @@ golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACk
 golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 h1:/ZScEX8SfEmUGRHs0gxpqteO5nfNW6axyZbBdw9A12g=
 golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20210226172049-e18ecbb05110 h1:qWPm9rbaAMKs8Bq/9LRpbMqxWRVUAQwMI9fVrssnTfw=
-golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4 h1:4nGaVu0QrbjT/AK2PRLuQfQuh6DJve+pELhqTdAj3x0=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210309074719-68d13333faf2 h1:46ULzRKLh1CwgRq2dC5SlBzEqqNCi8rreOZnNrbqcIY=
-golang.org/x/sys v0.0.0-20210309074719-68d13333faf2/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57 h1:F5Gozwx4I1xtr/sr/8CFbb57iKi3297KFs0QDbGN60A=
+golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
diff --git a/src/vendor/golang.org/x/net/dns/dnsmessage/message.go b/src/vendor/golang.org/x/net/dns/dnsmessage/message.go
index 654f191f8a..1736fc5d12 100644
--- a/src/vendor/golang.org/x/net/dns/dnsmessage/message.go
+++ b/src/vendor/golang.org/x/net/dns/dnsmessage/message.go
@@ -1023,6 +1023,24 @@ func (p *Parser) OPTResource() (OPTResource, error) {
 	return r, nil
 }
 
+// UnknownResource parses a single UnknownResource.
+//
+// One of the XXXHeader methods must have been called before calling this
+// method.
+func (p *Parser) UnknownResource() (UnknownResource, error) {
+	if !p.resHeaderValid {
+		return UnknownResource{}, ErrNotStarted
+	}
+	r, err := unpackUnknownResource(p.resHeader.Type, p.msg, p.off, p.resHeader.Length)
+	if err != nil {
+		return UnknownResource{}, err
+	}
+	p.off += int(p.resHeader.Length)
+	p.resHeaderValid = false
+	p.index++
+	return r, nil
+}
+
 // Unpack parses a full Message.
 func (m *Message) Unpack(msg []byte) error {
 	var p Parser
@@ -1557,6 +1575,30 @@ func (b *Builder) OPTResource(h ResourceHeader, r OPTResource) error {
 	return nil
 }
 
+// UnknownResource adds a single UnknownResource.
+func (b *Builder) UnknownResource(h ResourceHeader, r UnknownResource) error {
+	if err := b.checkResourceSection(); err != nil {
+		return err
+	}
+	h.Type = r.realType()
+	msg, lenOff, err := h.pack(b.msg, b.compression, b.start)
+	if err != nil {
+		return &nestedError{"ResourceHeader", err}
+	}
+	preLen := len(msg)
+	if msg, err = r.pack(msg, b.compression, b.start); err != nil {
+		return &nestedError{"UnknownResource body", err}
+	}
+	if err := h.fixLen(msg, lenOff, preLen); err != nil {
+		return err
+	}
+	if err := b.incrementSectionCount(); err != nil {
+		return err
+	}
+	b.msg = msg
+	return nil
+}
+
 // Finish ends message building and generates a binary message.
 func (b *Builder) Finish() ([]byte, error) {
 	if b.section < sectionHeader {
@@ -2135,13 +2177,15 @@ func unpackResourceBody(msg []byte, off int, hdr ResourceHeader) (ResourceBody,
 		rb, err = unpackOPTResource(msg, off, hdr.Length)
 		r = &rb
 		name = "OPT"
+	default:
+		var rb UnknownResource
+		rb, err = unpackUnknownResource(hdr.Type, msg, off, hdr.Length)
+		r = &rb
+		name = "Unknown"
 	}
 	if err != nil {
 		return nil, off, &nestedError{name + " record", err}
 	}
-	if r == nil {
-		return nil, off, errors.New("invalid resource type: " + hdr.Type.String())
-	}
 	return r, off + int(hdr.Length), nil
 }
 
@@ -2585,3 +2629,36 @@ func unpackOPTResource(msg []byte, off int, length uint16) (OPTResource, error)
 	}
 	return OPTResource{opts}, nil
 }
+
+// An UnknownResource is a catch-all container for unknown record types.
+type UnknownResource struct {
+	Type Type
+	Data []byte
+}
+
+func (r *UnknownResource) realType() Type {
+	return r.Type
+}
+
+// pack appends the wire format of the UnknownResource to msg.
+func (r *UnknownResource) pack(msg []byte, compression map[string]int, compressionOff int) ([]byte, error) {
+	return packBytes(msg, r.Data[:]), nil
+}
+
+// GoString implements fmt.GoStringer.GoString.
+func (r *UnknownResource) GoString() string {
+	return "dnsmessage.UnknownResource{" +
+		"Type: " + r.Type.GoString() + ", " +
+		"Data: []byte{" + printByteSlice(r.Data) + "}}"
+}
+
+func unpackUnknownResource(recordType Type, msg []byte, off int, length uint16) (UnknownResource, error) {
+	parsed := UnknownResource{
+		Type: recordType,
+		Data: make([]byte, length),
+	}
+	if _, err := unpackBytes(msg, off, parsed.Data); err != nil {
+		return UnknownResource{}, err
+	}
+	return parsed, nil
+}
diff --git a/src/vendor/modules.txt b/src/vendor/modules.txt
index 15a3aef4f8..499e6fc3fa 100644
--- a/src/vendor/modules.txt
+++ b/src/vendor/modules.txt
@@ -8,7 +8,7 @@ golang.org/x/crypto/curve25519
 golang.org/x/crypto/hkdf
 golang.org/x/crypto/internal/subtle
 golang.org/x/crypto/poly1305
-# golang.org/x/net v0.0.0-20210226172049-e18ecbb05110
+# golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4
 ## explicit
 golang.org/x/net/dns/dnsmessage
 golang.org/x/net/http/httpguts
@@ -18,7 +18,7 @@ golang.org/x/net/idna
 golang.org/x/net/lif
 golang.org/x/net/nettest
 golang.org/x/net/route
-# golang.org/x/sys v0.0.0-20210309074719-68d13333faf2
+# golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57
 ## explicit
 golang.org/x/sys/cpu
 # golang.org/x/text v0.3.6-0.20210227105805-e3aa4adf54f6
-- 
GitLab


From 105a6e9518a5195950a2798769af6e86b6d87417 Mon Sep 17 00:00:00 2001
From: Egon Elbre <egonelbre@gmail.com>
Date: Fri, 23 Apr 2021 08:41:07 +0300
Subject: [PATCH 1730/2400] os: skip TestExecutableDeleted on aix

aix does not support reading deleted executable name.

Change-Id: I955ed2c22bd0693440e2c889a4d3132d0a375c48
Reviewed-on: https://go-review.googlesource.com/c/go/+/312392
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/os/executable_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/os/executable_test.go b/src/os/executable_test.go
index f682105fa6..9ff6327149 100644
--- a/src/os/executable_test.go
+++ b/src/os/executable_test.go
@@ -92,7 +92,7 @@ func TestExecutableDeleted(t *testing.T) {
 	switch runtime.GOOS {
 	case "windows":
 		t.Skip("windows does not support deleting running binary")
-	case "openbsd", "freebsd":
+	case "openbsd", "freebsd", "aix":
 		t.Skipf("%v does not support reading deleted binary name", runtime.GOOS)
 	}
 
-- 
GitLab


From bedfeed54a7a80123c07f83c325a0bcfe5c43398 Mon Sep 17 00:00:00 2001
From: Michael Pratt <mpratt@google.com>
Date: Fri, 7 Aug 2020 16:28:35 +0000
Subject: [PATCH 1731/2400] runtime,runtime/metrics: add metric to track
 scheduling latencies

This change adds a metric to track scheduling latencies, defined as the
cumulative amount of time a goroutine spends being runnable before
running again. The metric is an approximations and samples instead of
trying to record every goroutine scheduling latency.

This change was primarily authored by mknyszek@google.com.

Change-Id: Ie0be7e6e7be421572eb2317d3dd8dd6f3d6aa152
Reviewed-on: https://go-review.googlesource.com/c/go/+/308933
Trust: Michael Pratt <mpratt@google.com>
Run-TryBot: Michael Pratt <mpratt@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/histogram.go           |  4 +++
 src/runtime/metrics.go             |  9 +++++++
 src/runtime/metrics/description.go |  5 ++++
 src/runtime/metrics/doc.go         |  4 +++
 src/runtime/proc.go                | 41 ++++++++++++++++++++++++++++++
 src/runtime/runtime2.go            | 17 +++++++++++++
 src/runtime/sizeof_test.go         |  2 +-
 7 files changed, 81 insertions(+), 1 deletion(-)

diff --git a/src/runtime/histogram.go b/src/runtime/histogram.go
index da4910d341..0cccbcca16 100644
--- a/src/runtime/histogram.go
+++ b/src/runtime/histogram.go
@@ -81,6 +81,10 @@ type timeHistogram struct {
 }
 
 // record adds the given duration to the distribution.
+//
+// Disallow preemptions and stack growths because this function
+// may run in sensitive locations.
+//go:nosplit
 func (h *timeHistogram) record(duration int64) {
 	if duration < 0 {
 		atomic.Xadd64(&h.underflow, 1)
diff --git a/src/runtime/metrics.go b/src/runtime/metrics.go
index e4343f9148..fe82688aac 100644
--- a/src/runtime/metrics.go
+++ b/src/runtime/metrics.go
@@ -245,6 +245,15 @@ func initMetrics() {
 				out.scalar = uint64(gcount())
 			},
 		},
+		"/sched/latencies:seconds": {
+			compute: func(_ *statAggregate, out *metricValue) {
+				hist := out.float64HistOrInit(timeHistBuckets)
+				hist.counts[0] = atomic.Load64(&sched.timeToRun.underflow)
+				for i := range sched.timeToRun.counts {
+					hist.counts[i+1] = atomic.Load64(&sched.timeToRun.counts[i])
+				}
+			},
+		},
 	}
 	metricsInit = true
 }
diff --git a/src/runtime/metrics/description.go b/src/runtime/metrics/description.go
index 1175156104..9aaf457135 100644
--- a/src/runtime/metrics/description.go
+++ b/src/runtime/metrics/description.go
@@ -176,6 +176,11 @@ var allDesc = []Description{
 		Description: "Count of live goroutines.",
 		Kind:        KindUint64,
 	},
+	{
+		Name:        "/sched/latencies:seconds",
+		Description: "Distribution of the time goroutines have spent in the scheduler in a runnable state before actually running.",
+		Kind:        KindFloat64Histogram,
+	},
 }
 
 // All returns a slice of containing metric descriptions for all supported metrics.
diff --git a/src/runtime/metrics/doc.go b/src/runtime/metrics/doc.go
index 7f790afc12..7cbc0415dc 100644
--- a/src/runtime/metrics/doc.go
+++ b/src/runtime/metrics/doc.go
@@ -139,5 +139,9 @@ Below is the full list of supported metrics, ordered lexicographically.
 
 	/sched/goroutines:goroutines
 		Count of live goroutines.
+
+	/sched/latencies:seconds
+		Distribution of the time goroutines have spent in the scheduler
+		in a runnable state before actually running.
 */
 package metrics
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 37c051634c..2f9818d9f1 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -697,6 +697,11 @@ func schedinit() {
 	sigsave(&_g_.m.sigmask)
 	initSigmask = _g_.m.sigmask
 
+	if offset := unsafe.Offsetof(sched.timeToRun); offset%8 != 0 {
+		println(offset)
+		throw("sched.timeToRun not aligned to 8 bytes")
+	}
+
 	goargs()
 	goenvs()
 	parsedebugvars()
@@ -973,6 +978,37 @@ func casgstatus(gp *g, oldval, newval uint32) {
 			nextYield = nanotime() + yieldDelay/2
 		}
 	}
+
+	// Handle tracking for scheduling latencies.
+	if oldval == _Grunning {
+		// Track every 8th time a goroutine transitions out of running.
+		if gp.trackingSeq%gTrackingPeriod == 0 {
+			gp.tracking = true
+		}
+		gp.trackingSeq++
+	}
+	if gp.tracking {
+		now := nanotime()
+		if oldval == _Grunnable {
+			// We transitioned out of runnable, so measure how much
+			// time we spent in this state and add it to
+			// runnableTime.
+			gp.runnableTime += now - gp.runnableStamp
+			gp.runnableStamp = 0
+		}
+		if newval == _Grunnable {
+			// We just transitioned into runnable, so record what
+			// time that happened.
+			gp.runnableStamp = now
+		} else if newval == _Grunning {
+			// We're transitioning into running, so turn off
+			// tracking and record how much time we spent in
+			// runnable.
+			gp.tracking = false
+			sched.timeToRun.record(gp.runnableTime)
+			gp.runnableTime = 0
+		}
+	}
 }
 
 // casgstatus(gp, oldstatus, Gcopystack), assuming oldstatus is Gwaiting or Grunnable.
@@ -4286,6 +4322,11 @@ func newproc1(fn *funcval, argp unsafe.Pointer, narg int32, callergp *g, callerp
 	if isSystemGoroutine(newg, false) {
 		atomic.Xadd(&sched.ngsys, +1)
 	}
+	// Track initial transition?
+	newg.trackingSeq = uint8(fastrand())
+	if newg.trackingSeq%gTrackingPeriod == 0 {
+		newg.tracking = true
+	}
 	casgstatus(newg, _Gdead, _Grunnable)
 
 	if _p_.goidcache == _p_.goidcacheend {
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index f84cb51bad..7fc7174334 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -462,6 +462,10 @@ type g struct {
 
 	raceignore     int8     // ignore race detection events
 	sysblocktraced bool     // StartTrace has emitted EvGoInSyscall about this goroutine
+	tracking       bool     // whether we're tracking this G for sched latency statistics
+	trackingSeq    uint8    // used to decide whether to track this G
+	runnableStamp  int64    // timestamp of when the G last became runnable, only used when tracking
+	runnableTime   int64    // the amount of time spent runnable, cleared when running, only used when tracking
 	sysexitticks   int64    // cputicks when syscall has returned (for tracing)
 	traceseq       uint64   // trace event sequencer
 	tracelastp     puintptr // last P emitted an event for this goroutine
@@ -493,6 +497,10 @@ type g struct {
 	gcAssistBytes int64
 }
 
+// gTrackingPeriod is the number of transitions out of _Grunning between
+// latency tracking runs.
+const gTrackingPeriod = 8
+
 const (
 	// tlsSlots is the number of pointer-sized slots reserved for TLS on some platforms,
 	// like Windows.
@@ -824,6 +832,15 @@ type schedt struct {
 	// Acquire and hold this mutex to block sysmon from interacting
 	// with the rest of the runtime.
 	sysmonlock mutex
+
+	_ uint32 // ensure timeToRun has 8-byte alignment
+
+	// timeToRun is a distribution of scheduling latencies, defined
+	// as the sum of time a G spends in the _Grunnable state before
+	// it transitions to _Grunning.
+	//
+	// timeToRun is protected by sched.lock.
+	timeToRun timeHistogram
 }
 
 // Values for the flags field of a sigTabT.
diff --git a/src/runtime/sizeof_test.go b/src/runtime/sizeof_test.go
index 736e848f8c..bbbd1becf7 100644
--- a/src/runtime/sizeof_test.go
+++ b/src/runtime/sizeof_test.go
@@ -21,7 +21,7 @@ func TestSizeof(t *testing.T) {
 		_32bit uintptr     // size on 32bit platforms
 		_64bit uintptr     // size on 64bit platforms
 	}{
-		{runtime.G{}, 216, 376},   // g, but exported for testing
+		{runtime.G{}, 236, 392},   // g, but exported for testing
 		{runtime.Sudog{}, 56, 88}, // sudog, but exported for testing
 	}
 
-- 
GitLab


From d4bfe006155ea0d9c2970e22fca5a027125c8a98 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Wed, 21 Apr 2021 10:28:27 -0400
Subject: [PATCH 1732/2400] cmd/go: make build cache tag sensitive to GOSSADIR;
 remove unused

GOSSADIR is a useful compiler flag for debugging.
Removed GO_SSA_PHI_LOC_CUTOFF, it is no longer mentioned in the compiler.

Change-Id: I3600f4c6ded95c9d34b85a6f0da6ba89b17a13ec
Reviewed-on: https://go-review.googlesource.com/c/go/+/312290
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/go/internal/work/exec.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/go/internal/work/exec.go b/src/cmd/go/internal/work/exec.go
index a68bdd6d29..ab9ce88c3c 100644
--- a/src/cmd/go/internal/work/exec.go
+++ b/src/cmd/go/internal/work/exec.go
@@ -289,7 +289,7 @@ func (b *Builder) buildActionID(a *Action) cache.ActionID {
 		magic := []string{
 			"GOCLOBBERDEADHASH",
 			"GOSSAFUNC",
-			"GO_SSA_PHI_LOC_CUTOFF",
+			"GOSSADIR",
 			"GOSSAHASH",
 		}
 		for _, env := range magic {
-- 
GitLab


From 8c666697646bc820beb3725b3ff4a4cd5514bbe7 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Fri, 23 Apr 2021 12:53:51 +0700
Subject: [PATCH 1733/2400] cmd/compile: make sure ascompatee walk lhs init
 statements

CL 281152 improved ascompatee by removing the call to safeExpr on lhs.
But we forgot that lhs int statements, if any, must be walked prior
saving subexpressions, which cause the bug in #45706.

Fixes #45706

Change-Id: I0064315056ef4ca92ebf3c332c2e3a9bb2b26f68
Reviewed-on: https://go-review.googlesource.com/c/go/+/312632
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/walk/assign.go |  3 +++
 test/fixedbugs/issue45706.go            | 16 ++++++++++++++++
 2 files changed, 19 insertions(+)
 create mode 100644 test/fixedbugs/issue45706.go

diff --git a/src/cmd/compile/internal/walk/assign.go b/src/cmd/compile/internal/walk/assign.go
index c8342b4fa4..3abf2a060c 100644
--- a/src/cmd/compile/internal/walk/assign.go
+++ b/src/cmd/compile/internal/walk/assign.go
@@ -341,6 +341,9 @@ func ascompatee(op ir.Op, nl, nr []ir.Node) []ir.Node {
 			break
 		}
 
+		walkStmtList(l.Init())
+		early.Append(ir.TakeInit(l)...)
+
 		var name *ir.Name
 		switch l.Op() {
 		default:
diff --git a/test/fixedbugs/issue45706.go b/test/fixedbugs/issue45706.go
new file mode 100644
index 0000000000..facf488b3d
--- /dev/null
+++ b/test/fixedbugs/issue45706.go
@@ -0,0 +1,16 @@
+// compile
+
+// Copyright 2021 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 p
+
+var i int
+var arr []*int
+var f func() int
+
+func g() {
+	for i, *(arr[f()]) = range []int{} {
+	}
+}
-- 
GitLab


From d2f96f2f75f6808362136dd1f20ae338e91aed81 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Thu, 15 Apr 2021 13:31:32 +0200
Subject: [PATCH 1734/2400] math/rand: make the security warning clearer and
 more prominent

It is still a common misconception that math/rand can be used for
security-sensitive work if seeded with crypto/rand
(lazyledger/lazyledger-core#270). It can not.

Change-Id: I8598c352d1750eabeada50be9976ab68cbb42cc0
Reviewed-on: https://go-review.googlesource.com/c/go/+/310350
Trust: Filippo Valsorda <filippo@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/math/rand/rand.go | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/math/rand/rand.go b/src/math/rand/rand.go
index d6422c914d..8179d9f464 100644
--- a/src/math/rand/rand.go
+++ b/src/math/rand/rand.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Package rand implements pseudo-random number generators.
+// Package rand implements pseudo-random number generators unsuitable for
+// security-sensitive work.
 //
 // Random numbers are generated by a Source. Top-level functions, such as
 // Float64 and Int, use a default shared Source that produces a deterministic
@@ -14,8 +15,9 @@
 // Mathematical interval notation such as [0, n) is used throughout the
 // documentation for this package.
 //
-// For random numbers suitable for security-sensitive work, see the crypto/rand
-// package.
+// This package's outputs might be easily predictable regardless of how it's
+// seeded. For random numbers suitable for security-sensitive work, see the
+// crypto/rand package.
 package rand
 
 import "sync"
-- 
GitLab


From c3e2ed711ce1e5758e5d01a26d74445813de2857 Mon Sep 17 00:00:00 2001
From: Sean Liao <seankhliao@gmail.com>
Date: Tue, 2 Feb 2021 18:08:50 +0100
Subject: [PATCH 1735/2400] cmd/go: use builtin version and reexec for env

Skip execing for version (most reliable) and attempt to reexec
for env, falling back to the go in GOROOT

Fixes #43981

Change-Id: I17fb84d36036807274eecca3d4f64b3add9b9483
Reviewed-on: https://go-review.googlesource.com/c/go/+/288693
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/bug/bug.go     |  8 ++++++--
 src/cmd/go/testdata/script/bug.txt | 14 +++++++++++++-
 2 files changed, 19 insertions(+), 3 deletions(-)

diff --git a/src/cmd/go/internal/bug/bug.go b/src/cmd/go/internal/bug/bug.go
index 4aa08b4ff6..df63c579d9 100644
--- a/src/cmd/go/internal/bug/bug.go
+++ b/src/cmd/go/internal/bug/bug.go
@@ -81,7 +81,7 @@ func printGoVersion(w io.Writer) {
 	fmt.Fprintf(w, "### What version of Go are you using (`go version`)?\n\n")
 	fmt.Fprintf(w, "<pre>\n")
 	fmt.Fprintf(w, "$ go version\n")
-	printCmdOut(w, "", "go", "version")
+	fmt.Fprintf(w, "go version %s %s/%s\n", runtime.Version(), runtime.GOOS, runtime.GOARCH)
 	fmt.Fprintf(w, "</pre>\n")
 	fmt.Fprintf(w, "\n")
 }
@@ -90,7 +90,11 @@ func printEnvDetails(w io.Writer) {
 	fmt.Fprintf(w, "### What operating system and processor architecture are you using (`go env`)?\n\n")
 	fmt.Fprintf(w, "<details><summary><code>go env</code> Output</summary><br><pre>\n")
 	fmt.Fprintf(w, "$ go env\n")
-	printCmdOut(w, "", "go", "env")
+	goexe, err := os.Executable()
+	if err != nil {
+		goexe = filepath.Join(runtime.GOROOT(), "bin/go")
+	}
+	printCmdOut(w, "", goexe, "env")
 	printGoDetails(w)
 	printOSDetails(w)
 	printCDetails(w)
diff --git a/src/cmd/go/testdata/script/bug.txt b/src/cmd/go/testdata/script/bug.txt
index b9bbaaad33..571d507358 100644
--- a/src/cmd/go/testdata/script/bug.txt
+++ b/src/cmd/go/testdata/script/bug.txt
@@ -1,9 +1,11 @@
 # Verify that go bug creates the appropriate URL issue body
 
 [!linux] skip
+[short] skip
 
 go install
-env BROWSER=$GOPATH/bin/browser
+go build -o $TMPDIR/go ./go
+env BROWSER=$GOPATH/bin/browser PATH=$TMPDIR:$PATH
 go bug
 exists $TMPDIR/browser
 grep '^go version' $TMPDIR/browser
@@ -44,3 +46,13 @@ func main() {
 	}
 }
 
+-- go/main.go --
+package main
+
+import (
+    "os"
+)
+
+func main() {
+    os.Exit(1)
+}
-- 
GitLab


From 768a39975d8851f1c309b163a8eb4b7a5388aa24 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 23 Apr 2021 01:13:50 -0400
Subject: [PATCH 1736/2400] cmd/go/internal/modload: remove the addedModuleFor
 map
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

At one point this map checked for infinite loops during package iteration.
The last write to the map was mistakenly removed in CL 251445.

However, looking at the code before that change, the map-based
termination strategy was never quite right to begin with: it checked
whether we had ever added any module for the given package, not
whether we had already added the module being proposed right now. (For
packages within nested modules, we could try adding multiple different
modules for a given package without looping.)

Moreover, the "looping trying to add package" failure message was only
marginally helpful. Users are capable of noticing that an invocation
of the 'go' command is taking too long, and will report a bug for an
infinite loop just as readily as a "looping trying to add package"
error.

We could try to add this tracking back in, but it's no substitute for
a proper proof of convergence, and the code is simpler without it.
Instead I'm going to add a proper proof of convergence — or, barring
that, a more accurate and useful check for failure to converge. In the
meantime, this invariantly-empty map isn't doing anybody any good.

For #36460

Change-Id: I2c111d4b4bf59159af0d7e62d1c0ef4ce0a43a71
Reviewed-on: https://go-review.googlesource.com/c/go/+/312929
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modload/load.go | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index 0c9006e040..b13c41aaef 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -890,7 +890,6 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 		work:         par.NewQueue(runtime.GOMAXPROCS(0)),
 	}
 
-	addedModuleFor := make(map[string]bool)
 	for {
 		ld.reset()
 
@@ -931,7 +930,7 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 			// We've loaded as much as we can without resolving missing imports.
 			break
 		}
-		modAddedBy := ld.resolveMissingImports(ctx, addedModuleFor)
+		modAddedBy := ld.resolveMissingImports(ctx)
 		if len(modAddedBy) == 0 {
 			break
 		}
@@ -1057,7 +1056,7 @@ func (ld *loader) updateRequirements(ctx context.Context, add []module.Version)
 // The newly-resolved packages are added to the addedModuleFor map, and
 // resolveMissingImports returns a map from each new module version to
 // the first missing package that module would resolve.
-func (ld *loader) resolveMissingImports(ctx context.Context, addedModuleFor map[string]bool) (modAddedBy map[module.Version]*loadPkg) {
+func (ld *loader) resolveMissingImports(ctx context.Context) (modAddedBy map[module.Version]*loadPkg) {
 	var needPkgs []*loadPkg
 	for _, pkg := range ld.pkgs {
 		if pkg.err == nil {
@@ -1089,11 +1088,6 @@ func (ld *loader) resolveMissingImports(ctx context.Context, addedModuleFor map[
 		}
 
 		fmt.Fprintf(os.Stderr, "go: found %s in %s %s\n", pkg.path, pkg.mod.Path, pkg.mod.Version)
-		if addedModuleFor[pkg.path] {
-			// TODO(bcmills): This should only be an error if pkg.mod is the same
-			// version we already tried to add previously.
-			base.Fatalf("go: %s: looping trying to add package", pkg.stackText())
-		}
 		if modAddedBy[pkg.mod] == nil {
 			modAddedBy[pkg.mod] = pkg
 		}
-- 
GitLab


From 691e1b84c11d038060807f9c79107996ca2f19ae Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 23 Apr 2021 12:18:59 -0700
Subject: [PATCH 1737/2400] cmd/compile: generalize fix for lvalue-init
 evaluation

The previous fix to ensure early evaluation of lvalue-init statements
(CL 312632) added it after we'd already peeled away any array-OINDEX
expressions. But those might have init statements too, so we need to
do this earlier actually and perhaps more than once.

Longer term, lvalue expressions shouldn't have init statements anyway.
But rsc and I both spent a while looking into this earlier in the dev
cycle and couldn't come up with anything reasonable.

Fixes #45706.

Change-Id: I2d19c5ba421b3f019c62eec45774c84cf04b30ef
Reviewed-on: https://go-review.googlesource.com/c/go/+/313011
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/walk/assign.go | 10 +++++++---
 test/fixedbugs/issue45706.go            |  9 +++++++++
 2 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/walk/assign.go b/src/cmd/compile/internal/walk/assign.go
index 3abf2a060c..6d697a53ae 100644
--- a/src/cmd/compile/internal/walk/assign.go
+++ b/src/cmd/compile/internal/walk/assign.go
@@ -322,6 +322,13 @@ func ascompatee(op ir.Op, nl, nr []ir.Node) []ir.Node {
 		// Save subexpressions needed on left side.
 		// Drill through non-dereferences.
 		for {
+			// If an expression has init statements, they must be evaluated
+			// before any of its saved sub-operands (#45706).
+			// TODO(mdempsky): Disallow init statements on lvalues.
+			init := ir.TakeInit(l)
+			walkStmtList(init)
+			early.Append(init...)
+
 			switch ll := l.(type) {
 			case *ir.IndexExpr:
 				if ll.X.Type().IsArray() {
@@ -341,9 +348,6 @@ func ascompatee(op ir.Op, nl, nr []ir.Node) []ir.Node {
 			break
 		}
 
-		walkStmtList(l.Init())
-		early.Append(ir.TakeInit(l)...)
-
 		var name *ir.Name
 		switch l.Op() {
 		default:
diff --git a/test/fixedbugs/issue45706.go b/test/fixedbugs/issue45706.go
index facf488b3d..6518dbf090 100644
--- a/test/fixedbugs/issue45706.go
+++ b/test/fixedbugs/issue45706.go
@@ -14,3 +14,12 @@ func g() {
 	for i, *(arr[f()]) = range []int{} {
 	}
 }
+
+func h() {
+	var x int
+	var f func() int
+	var arr []int
+	var arr2 [][0]rune
+	for arr[x], arr2[arr[f()]][x] = range "" {
+	}
+}
-- 
GitLab


From 142151697397235ba5f30a7a660ed8a159adce0b Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Fri, 2 Apr 2021 13:24:35 -0400
Subject: [PATCH 1738/2400] cmd/compile, internal/abi: add FuncPCABIxxx
 intrinsics

When ABI wrappers are used, there are cases where in Go code we
need the PC of the defined function instead of the ABI wrapper.
Currently we work around this by define such functions as
ABIInternal, even if they do not actually follow the internal ABI.

This CL introduces internal/abi.FuncPCABIxxx functions as compiler
intrinsics, which return the underlying defined function's entry
PC if the argument is a direct reference of a function of the
expected ABI, and reject it if it is of a different ABI.

As a proof of concept, change runtime.goexit back to ABI0 and use
internal/abi.FuncPCABI0 to retrieve its PC.

Updates #44065.

Change-Id: I02286f0f9d99e6a3090f9e8169dbafc6804a2da6
Reviewed-on: https://go-review.googlesource.com/c/go/+/304232
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/staticdata/data.go |  9 +--
 src/cmd/compile/internal/walk/expr.go       | 37 ++++++++++
 src/cmd/compile/internal/walk/order.go      | 23 +++++++
 src/internal/abi/abi.go                     | 24 +++++++
 src/internal/abi/abi_test.go                | 76 +++++++++++++++++++++
 src/internal/abi/abi_test.s                 | 27 ++++++++
 src/internal/abi/export_test.go             | 14 ++++
 src/internal/abi/testdata/x.go              | 22 ++++++
 src/internal/abi/testdata/x.s               |  6 ++
 src/runtime/asm_amd64.s                     |  7 +-
 src/runtime/proc.go                         |  5 +-
 11 files changed, 239 insertions(+), 11 deletions(-)
 create mode 100644 src/internal/abi/abi_test.go
 create mode 100644 src/internal/abi/abi_test.s
 create mode 100644 src/internal/abi/export_test.go
 create mode 100644 src/internal/abi/testdata/x.go
 create mode 100644 src/internal/abi/testdata/x.s

diff --git a/src/cmd/compile/internal/staticdata/data.go b/src/cmd/compile/internal/staticdata/data.go
index b5206c2442..abb0bba646 100644
--- a/src/cmd/compile/internal/staticdata/data.go
+++ b/src/cmd/compile/internal/staticdata/data.go
@@ -287,10 +287,11 @@ func NeedFuncSym(fn *ir.Func) {
 		return
 	}
 	s := fn.Nname.Sym()
-	if base.Flag.CompilingRuntime && (s.Name == "getg" || s.Name == "getclosureptr" || s.Name == "getcallerpc" || s.Name == "getcallersp") {
-		// runtime.getg(), getclosureptr(), getcallerpc(), and
-		// getcallersp() are not real functions and so do not
-		// get funcsyms.
+	if base.Flag.CompilingRuntime && (s.Name == "getg" || s.Name == "getclosureptr" || s.Name == "getcallerpc" || s.Name == "getcallersp") ||
+		(base.Ctxt.Pkgpath == "internal/abi" && (s.Name == "FuncPCABI0" || s.Name == "FuncPCABIInternal")) {
+		// runtime.getg(), getclosureptr(), getcallerpc(), getcallersp(),
+		// and internal/abi.FuncPCABIxxx() are not real functions and so
+		// do not get funcsyms.
 		return
 	}
 	funcsyms = append(funcsyms, fn.Nname)
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index a50473db52..5a1a2441bf 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -497,6 +497,43 @@ func walkCall(n *ir.CallExpr, init *ir.Nodes) ir.Node {
 		directClosureCall(n)
 	}
 
+	if isFuncPCIntrinsic(n) {
+		// For internal/abi.FuncPCABIxxx(fn), if fn is a defined function, rewrite
+		// it to the address of the function of the ABI fn is defined.
+		name := n.X.(*ir.Name).Sym().Name
+		arg := n.Args[0]
+		var wantABI obj.ABI
+		switch name {
+		case "FuncPCABI0":
+			wantABI = obj.ABI0
+		case "FuncPCABIInternal":
+			wantABI = obj.ABIInternal
+		}
+		if isIfaceOfFunc(arg) {
+			fn := arg.(*ir.ConvExpr).X.(*ir.Name)
+			abi := fn.Func.ABI
+			if abi != wantABI {
+				base.ErrorfAt(n.Pos(), "internal/abi.%s expects an %v function, %s is defined as %v", name, wantABI, fn.Sym().Name, abi)
+			}
+			var e ir.Node = ir.NewLinksymExpr(n.Pos(), fn.Sym().LinksymABI(abi), types.Types[types.TUINTPTR])
+			e = ir.NewAddrExpr(n.Pos(), e)
+			e.SetType(types.Types[types.TUINTPTR].PtrTo())
+			e = ir.NewConvExpr(n.Pos(), ir.OCONVNOP, n.Type(), e)
+			return e
+		}
+		// fn is not a defined function. It must be ABIInternal.
+		// Read the address from func value, i.e. *(*uintptr)(idata(fn)).
+		if wantABI != obj.ABIInternal {
+			base.ErrorfAt(n.Pos(), "internal/abi.%s does not accept func expression, which is ABIInternal", name)
+		}
+		arg = walkExpr(arg, init)
+		var e ir.Node = ir.NewUnaryExpr(n.Pos(), ir.OIDATA, arg)
+		e.SetType(n.Type().PtrTo())
+		e = ir.NewStarExpr(n.Pos(), e)
+		e.SetType(n.Type())
+		return e
+	}
+
 	walkCall1(n, init)
 	return n
 }
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index 99a166119a..b733d3a29f 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -544,6 +544,14 @@ func (o *orderState) call(nn ir.Node) {
 
 	n := nn.(*ir.CallExpr)
 	typecheck.FixVariadicCall(n)
+
+	if isFuncPCIntrinsic(n) && isIfaceOfFunc(n.Args[0]) {
+		// For internal/abi.FuncPCABIxxx(fn), if fn is a defined function,
+		// do not introduce temporaries here, so it is easier to rewrite it
+		// to symbol address reference later in walk.
+		return
+	}
+
 	n.X = o.expr(n.X, nil)
 	o.exprList(n.Args)
 
@@ -1796,3 +1804,18 @@ func (o *orderState) wrapGoDefer(n *ir.GoDeferStmt) {
 	// Finally, point the defer statement at the newly generated call.
 	n.Call = topcall
 }
+
+// isFuncPCIntrinsic returns whether n is a direct call of internal/abi.FuncPCABIxxx functions.
+func isFuncPCIntrinsic(n *ir.CallExpr) bool {
+	if n.Op() != ir.OCALLFUNC || n.X.Op() != ir.ONAME {
+		return false
+	}
+	fn := n.X.(*ir.Name).Sym()
+	return (fn.Name == "FuncPCABI0" || fn.Name == "FuncPCABIInternal") &&
+		(fn.Pkg.Path == "internal/abi" || fn.Pkg == types.LocalPkg && base.Ctxt.Pkgpath == "internal/abi")
+}
+
+// isIfaceOfFunc returns whether n is an interface conversion from a direct reference of a func.
+func isIfaceOfFunc(n ir.Node) bool {
+	return n.Op() == ir.OCONVIFACE && n.(*ir.ConvExpr).X.Op() == ir.ONAME && n.(*ir.ConvExpr).X.(*ir.Name).Class == ir.PFUNC
+}
diff --git a/src/internal/abi/abi.go b/src/internal/abi/abi.go
index 6700facc04..aaff9cece3 100644
--- a/src/internal/abi/abi.go
+++ b/src/internal/abi/abi.go
@@ -51,3 +51,27 @@ func (b *IntArgRegBitmap) Set(i int) {
 func (b *IntArgRegBitmap) Get(i int) bool {
 	return b[i/8]&(uint8(1)<<(i%8)) != 0
 }
+
+// FuncPC* intrinsics.
+//
+// CAREFUL: In programs with plugins, FuncPC* can return different values
+// for the same function (because there are actually multiple copies of
+// the same function in the address space). To be safe, don't use the
+// results of this function in any == expression. It is only safe to
+// use the result as an address at which to start executing code.
+
+// FuncPCABI0 returns the entry PC of the function f, which must be a
+// direct reference of a function defined as ABI0. Otherwise it is a
+// compile-time error.
+//
+// Implemented as a compile intrinsic.
+func FuncPCABI0(f interface{}) uintptr
+
+// FuncPCABIInternal returns the entry PC of the function f. If f is a
+// direct reference of a function, it must be defined as ABIInternal.
+// Otherwise it is a compile-time error. If f is not a direct reference
+// of a defined function, it assumes that f is a func value. Otherwise
+// the behavior is undefined.
+//
+// Implemented as a compile intrinsic.
+func FuncPCABIInternal(f interface{}) uintptr
diff --git a/src/internal/abi/abi_test.go b/src/internal/abi/abi_test.go
new file mode 100644
index 0000000000..5a3b6b616d
--- /dev/null
+++ b/src/internal/abi/abi_test.go
@@ -0,0 +1,76 @@
+// Copyright 2021 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 abi_test
+
+import (
+	"internal/abi"
+	"internal/testenv"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestFuncPC(t *testing.T) {
+	// Test that FuncPC* can get correct function PC.
+	pcFromAsm := abi.FuncPCTestFnAddr
+
+	// Test FuncPC for locally defined function
+	pcFromGo := abi.FuncPCTest()
+	if pcFromGo != pcFromAsm {
+		t.Errorf("FuncPC returns wrong PC, want %x, got %x", pcFromAsm, pcFromGo)
+	}
+
+	// Test FuncPC for imported function
+	pcFromGo = abi.FuncPCABI0(abi.FuncPCTestFn)
+	if pcFromGo != pcFromAsm {
+		t.Errorf("FuncPC returns wrong PC, want %x, got %x", pcFromAsm, pcFromGo)
+	}
+}
+
+func TestFuncPCCompileError(t *testing.T) {
+	// Test that FuncPC* on a function of a mismatched ABI is rejected.
+	testenv.MustHaveGoBuild(t)
+
+	// We want to test internal package, which we cannot normally import.
+	// Run the assembler and compiler manually.
+	tmpdir := t.TempDir()
+	asmSrc := filepath.Join("testdata", "x.s")
+	goSrc := filepath.Join("testdata", "x.go")
+	symabi := filepath.Join(tmpdir, "symabi")
+	obj := filepath.Join(tmpdir, "x.o")
+
+	// parse assembly code for symabi.
+	cmd := exec.Command(testenv.GoToolPath(t), "tool", "asm", "-gensymabis", "-o", symabi, asmSrc)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("go tool asm -gensymabis failed: %v\n%s", err, out)
+	}
+
+	// compile go code.
+	cmd = exec.Command(testenv.GoToolPath(t), "tool", "compile", "-symabis", symabi, "-o", obj, goSrc)
+	out, err = cmd.CombinedOutput()
+	if err == nil {
+		t.Fatalf("go tool compile did not fail")
+	}
+
+	// Expect errors in line 17, 18, 20, no errors on other lines.
+	want := []string{"x.go:17", "x.go:18", "x.go:20"}
+	got := strings.Split(string(out), "\n")
+	if got[len(got)-1] == "" {
+		got = got[:len(got)-1] // remove last empty line
+	}
+	for i, s := range got {
+		if !strings.Contains(s, want[i]) {
+			t.Errorf("did not error on line %s", want[i])
+		}
+	}
+	if len(got) != len(want) {
+		t.Errorf("unexpected number of errors, want %d, got %d", len(want), len(got))
+	}
+	if t.Failed() {
+		t.Logf("output:\n%s", string(out))
+	}
+}
diff --git a/src/internal/abi/abi_test.s b/src/internal/abi/abi_test.s
new file mode 100644
index 0000000000..93ace3ef48
--- /dev/null
+++ b/src/internal/abi/abi_test.s
@@ -0,0 +1,27 @@
+// Copyright 2021 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.
+
+#include "textflag.h"
+
+#ifdef GOARCH_386
+#define PTRSIZE 4
+#endif
+#ifdef GOARCH_arm
+#define PTRSIZE 4
+#endif
+#ifdef GOARCH_mips
+#define PTRSIZE 4
+#endif
+#ifdef GOARCH_mipsle
+#define PTRSIZE 4
+#endif
+#ifndef PTRSIZE
+#define PTRSIZE 8
+#endif
+
+TEXT	internal∕abi·FuncPCTestFn(SB),NOSPLIT,$0-0
+	RET
+
+GLOBL	internal∕abi·FuncPCTestFnAddr(SB), NOPTR, $PTRSIZE
+DATA	internal∕abi·FuncPCTestFnAddr(SB)/PTRSIZE, $internal∕abi·FuncPCTestFn(SB)
diff --git a/src/internal/abi/export_test.go b/src/internal/abi/export_test.go
new file mode 100644
index 0000000000..2a87e9de7f
--- /dev/null
+++ b/src/internal/abi/export_test.go
@@ -0,0 +1,14 @@
+// Copyright 2021 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 abi
+
+func FuncPCTestFn()
+
+var FuncPCTestFnAddr uintptr // address of FuncPCTestFn, directly retrieved from assembly
+
+//go:noinline
+func FuncPCTest() uintptr {
+	return FuncPCABI0(FuncPCTestFn)
+}
diff --git a/src/internal/abi/testdata/x.go b/src/internal/abi/testdata/x.go
new file mode 100644
index 0000000000..cae103d78b
--- /dev/null
+++ b/src/internal/abi/testdata/x.go
@@ -0,0 +1,22 @@
+// Copyright 2021 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 x
+
+import "internal/abi"
+
+func Fn0() // defined in assembly
+
+func Fn1() {}
+
+var FnExpr func()
+
+func test() {
+	_ = abi.FuncPCABI0(Fn0)           // line 16, no error
+	_ = abi.FuncPCABIInternal(Fn0)    // line 17, error
+	_ = abi.FuncPCABI0(Fn1)           // line 18, error
+	_ = abi.FuncPCABIInternal(Fn1)    // line 19, no error
+	_ = abi.FuncPCABI0(FnExpr)        // line 20, error
+	_ = abi.FuncPCABIInternal(FnExpr) // line 21, no error
+}
diff --git a/src/internal/abi/testdata/x.s b/src/internal/abi/testdata/x.s
new file mode 100644
index 0000000000..63c1385998
--- /dev/null
+++ b/src/internal/abi/testdata/x.s
@@ -0,0 +1,6 @@
+// Copyright 2021 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.
+
+TEXT	·Fn0(SB), 0, $0-0
+	RET
diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index 789e159c76..14f29e1964 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -1576,11 +1576,8 @@ TEXT _cgo_topofstack(SB),NOSPLIT,$0
 	RET
 
 // The top-most function running on a goroutine
-// returns to goexit+PCQuantum. Defined as ABIInternal
-// so as to make it identifiable to traceback (this
-// function it used as a sentinel; traceback wants to
-// see the func PC, not a wrapper PC).
-TEXT runtime·goexit<ABIInternal>(SB),NOSPLIT|TOPFRAME,$0-0
+// returns to goexit+PCQuantum.
+TEXT runtime·goexit(SB),NOSPLIT|TOPFRAME,$0-0
 	BYTE	$0x90	// NOP
 	CALL	runtime·goexit1(SB)	// does not return
 	// traceback from goexit1 must hit code range of goexit
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 2f9818d9f1..1b1b5769ff 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -5,6 +5,7 @@
 package runtime
 
 import (
+	"internal/abi"
 	"internal/cpu"
 	"internal/goexperiment"
 	"runtime/internal/atomic"
@@ -2022,7 +2023,7 @@ func oneNewExtraM() {
 	// the goroutine stack ends.
 	mp := allocm(nil, nil, -1)
 	gp := malg(4096)
-	gp.sched.pc = funcPC(goexit) + sys.PCQuantum
+	gp.sched.pc = abi.FuncPCABI0(goexit) + sys.PCQuantum
 	gp.sched.sp = gp.stack.hi
 	gp.sched.sp -= 4 * sys.PtrSize // extra space in case of reads slightly beyond frame
 	gp.sched.lr = 0
@@ -4310,7 +4311,7 @@ func newproc1(fn *funcval, argp unsafe.Pointer, narg int32, callergp *g, callerp
 	memclrNoHeapPointers(unsafe.Pointer(&newg.sched), unsafe.Sizeof(newg.sched))
 	newg.sched.sp = sp
 	newg.stktopsp = sp
-	newg.sched.pc = funcPC(goexit) + sys.PCQuantum // +PCQuantum so that previous instruction is in same function
+	newg.sched.pc = abi.FuncPCABI0(goexit) + sys.PCQuantum // +PCQuantum so that previous instruction is in same function
 	newg.sched.g = guintptr(unsafe.Pointer(newg))
 	gostartcallfn(&newg.sched, fn)
 	newg.gopc = callerpc
-- 
GitLab


From 19470dc535513dc824fe5c1dbec700329e7692dc Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 20 Apr 2021 13:30:50 -0400
Subject: [PATCH 1739/2400] misc/cgo/test: do not redeclare exported Go
 functions

An exported Go function like

	//export F
	func F() {}

gets declared in _cgo_export.h as something like

	extern void F(void);

The exact declaration varies by operating system.
In particular, Windows adds __declspec(dllimport).

Clang on Windows/ARM64 rejects code that contains
conflicting declarations for F, like:

	extern void F(void);
	extern void __declspec(dllimport) F(void);

This means that F must not be declared separately from _cgo_export.h:
any code that wants to refer to F must use #include "_cgo_export.h".

Unfortunately, the cgo prologue itself (the commented code before import "C")
cannot include "_cgo_export.h", because that file is itself produced from the
cgo Go sources and therefore cannot be a dependency of the cgo Go sources.

This CL rewrites misc/cgo/test to avoid redeclaring exported functions.
Most of the time, this is not a significant problem: just move the code
that needs the header into a .c file, perhaps with a wrapper exposed
to the cgo Go sources.

The one case that is potentially problematic is f7665, which is part of
the test for golang.org/issue/7665. That bug report explicitly identified
a bug in referring to the C name for an exported function in the same
Go source file as it was exported function. That is now impossible,
at least on Windows/ARM64, so the test is modified a bit and possibly
does not test what the original bug was. But the original bug should
be long gone: that part of the compiler has been rewritten.

Change-Id: I0d14d9336632f0e5e3db4273d9d32ef2cca0298d
Reviewed-on: https://go-review.googlesource.com/c/go/+/312029
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 misc/cgo/test/issue8148.c  | 11 +++++++++++
 misc/cgo/test/issue8148.go | 11 ++---------
 misc/cgo/test/testx.c      | 24 ++++++++++++++++++++++++
 misc/cgo/test/testx.go     | 24 ++----------------------
 4 files changed, 39 insertions(+), 31 deletions(-)
 create mode 100644 misc/cgo/test/issue8148.c
 create mode 100644 misc/cgo/test/testx.c

diff --git a/misc/cgo/test/issue8148.c b/misc/cgo/test/issue8148.c
new file mode 100644
index 0000000000..927b4346cb
--- /dev/null
+++ b/misc/cgo/test/issue8148.c
@@ -0,0 +1,11 @@
+// Copyright 2014 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.
+
+#include "_cgo_export.h"
+
+int get8148(void) {
+	T t;
+	t.i = 42;
+	return issue8148Callback(&t);
+}
diff --git a/misc/cgo/test/issue8148.go b/misc/cgo/test/issue8148.go
index f704788aef..aee9003d50 100644
--- a/misc/cgo/test/issue8148.go
+++ b/misc/cgo/test/issue8148.go
@@ -10,14 +10,7 @@ package cgotest
 
 /*
 typedef struct { int i; } T;
-
-int issue8148Callback(T*);
-
-static int get() {
-	T t;
-	t.i = 42;
-	return issue8148Callback(&t);
-}
+int get8148(void);
 */
 import "C"
 
@@ -27,5 +20,5 @@ func issue8148Callback(t *C.T) C.int {
 }
 
 func Issue8148() int {
-	return int(C.get())
+	return int(C.get8148())
 }
diff --git a/misc/cgo/test/testx.c b/misc/cgo/test/testx.c
new file mode 100644
index 0000000000..1258e326a4
--- /dev/null
+++ b/misc/cgo/test/testx.c
@@ -0,0 +1,24 @@
+// Copyright 2021 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.
+
+#include "_cgo_export.h"
+
+void lockOSThreadC(void) {
+	lockOSThreadCallback();
+}
+
+void issue7978c(uint32_t *sync) {
+	while(__atomic_load_n(sync, __ATOMIC_SEQ_CST) != 0)
+		;
+	__atomic_add_fetch(sync, 1, __ATOMIC_SEQ_CST);
+	while(__atomic_load_n(sync, __ATOMIC_SEQ_CST) != 2)
+		;
+	issue7978cb();
+	__atomic_add_fetch(sync, 1, __ATOMIC_SEQ_CST);
+	while(__atomic_load_n(sync, __ATOMIC_SEQ_CST) != 6)
+		;
+}
+
+void f7665(void) {
+}
diff --git a/misc/cgo/test/testx.go b/misc/cgo/test/testx.go
index 044c5bceff..823c3e13d2 100644
--- a/misc/cgo/test/testx.go
+++ b/misc/cgo/test/testx.go
@@ -27,7 +27,6 @@ import (
 extern void doAdd(int, int);
 
 // issue 1328
-extern void BackIntoGo(void);
 void IntoC(void);
 
 // issue 1560
@@ -39,11 +38,7 @@ long long mysleep(int seconds);
 long long twoSleep(int);
 
 // issue 3775
-void lockOSThreadCallback(void);
-inline static void lockOSThreadC(void)
-{
-        lockOSThreadCallback();
-}
+void lockOSThreadC(void);
 int usleep(unsigned usec);
 
 // issue 4054 part 2 - part 1 in test.go
@@ -82,21 +77,9 @@ extern void f7665(void);
 
 #include <stdint.h>
 
-void issue7978cb(void);
-
 // use ugly atomic variable sync since that doesn't require calling back into
 // Go code or OS dependencies
-static void issue7978c(uint32_t *sync) {
-	while(__atomic_load_n(sync, __ATOMIC_SEQ_CST) != 0)
-		;
-	__atomic_add_fetch(sync, 1, __ATOMIC_SEQ_CST);
-	while(__atomic_load_n(sync, __ATOMIC_SEQ_CST) != 2)
-		;
-	issue7978cb();
-	__atomic_add_fetch(sync, 1, __ATOMIC_SEQ_CST);
-	while(__atomic_load_n(sync, __ATOMIC_SEQ_CST) != 6)
-		;
-}
+void issue7978c(uint32_t *sync);
 
 // issue 8331 part 2 - part 1 in test.go
 // A typedef of an unnamed struct is the same struct when
@@ -429,9 +412,6 @@ func test6907Go(t *testing.T) {
 
 // issue 7665
 
-//export f7665
-func f7665() {}
-
 var bad7665 unsafe.Pointer = C.f7665
 var good7665 uintptr = uintptr(C.f7665)
 
-- 
GitLab


From cef3a442eaa1f86b81bb67fb881c5bb9e446fb13 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 20 Apr 2021 14:08:58 -0400
Subject: [PATCH 1740/2400] cmd/asm, cmd/link: use full objabi header

The cmd/link check of the objabi header was a bit lax because
historically the assembler has not included the full version string.
And the assembler didn't do that because it didn't have access to it:
that was buried inside the compiler.

But now that we have cmd/internal/objabi, all the tools have full
access to the expected string, and they can use it, which simplifies
the cmd/link consistency check.

Do that.

Change-Id: I33bd2f9d36c373cc3c32ff02ec6368365088b011
Reviewed-on: https://go-review.googlesource.com/c/go/+/312030
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/asm/main.go             |  3 ++-
 src/cmd/link/internal/ld/lib.go | 22 ++++------------------
 2 files changed, 6 insertions(+), 19 deletions(-)

diff --git a/src/cmd/asm/main.go b/src/cmd/asm/main.go
index e5a9ee565e..043bc696e5 100644
--- a/src/cmd/asm/main.go
+++ b/src/cmd/asm/main.go
@@ -19,6 +19,7 @@ import (
 
 	"cmd/internal/bio"
 	"cmd/internal/obj"
+	"cmd/internal/objabi"
 )
 
 func main() {
@@ -69,7 +70,7 @@ func main() {
 	defer buf.Close()
 
 	if !*flags.SymABIs {
-		fmt.Fprintf(buf, "go object %s %s %s\n", buildcfg.GOOS, buildcfg.GOARCH, buildcfg.Version)
+		buf.WriteString(objabi.HeaderString())
 		fmt.Fprintf(buf, "!\n")
 	}
 
diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index c840e5ea51..d2dc3fb175 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -1773,6 +1773,8 @@ func hostlinkArchArgs(arch *sys.Arch) []string {
 	return nil
 }
 
+var wantHdr = objabi.HeaderString()
+
 // ldobj loads an input object. If it is a host object (an object
 // compiled by a non-Go compiler) it returns the Hostobj pointer. If
 // it is a Go object, it returns nil.
@@ -1871,24 +1873,8 @@ func ldobj(ctxt *Link, f *bio.Reader, lib *sym.Library, length int64, pn string,
 	}
 
 	// First, check that the basic GOOS, GOARCH, and Version match.
-	t := fmt.Sprintf("%s %s %s ", buildcfg.GOOS, buildcfg.GOARCH, buildcfg.Version)
-
-	line = strings.TrimRight(line, "\n")
-	if !strings.HasPrefix(line[10:]+" ", t) && !*flagF {
-		Errorf(nil, "%s: object is [%s] expected [%s]", pn, line[10:], t)
-		return nil
-	}
-
-	// Second, check that longer lines match each other exactly,
-	// so that the Go compiler and write additional information
-	// that must be the same from run to run.
-	if len(line) >= len(t)+10 {
-		if theline == "" {
-			theline = line[10:]
-		} else if theline != line[10:] {
-			Errorf(nil, "%s: object is [%s] expected [%s]", pn, line[10:], theline)
-			return nil
-		}
+	if line != wantHdr {
+		Errorf(nil, "%s: linked object header mismatch:\nhave %q\nwant %q\n", pn, line, wantHdr)
 	}
 
 	// Skip over exports and other info -- ends with \n!\n.
-- 
GitLab


From 073f9139497401e019e4357d110c2801c5be31e1 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 20 Apr 2021 15:41:24 -0400
Subject: [PATCH 1741/2400] debug/dwarf: skip over zero-length compilation
 units

DWARF sections generated by mingw-clang seem to include these
(not often - only one out of many in the binary that I am looking at).
Skipping over them, everything parses correctly.

This makes TestDefaultLinkerDWARF pass on windows/arm64.

Change-Id: Ie4a7daa1423f51cbc8c4aac88b1d27c3b52ee880
Reviewed-on: https://go-review.googlesource.com/c/go/+/312031
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/debug/dwarf/unit.go | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/debug/dwarf/unit.go b/src/debug/dwarf/unit.go
index 29a744fd18..9b3d6e902d 100644
--- a/src/debug/dwarf/unit.go
+++ b/src/debug/dwarf/unit.go
@@ -48,7 +48,9 @@ func (d *Data) parseUnits() ([]unit, error) {
 			break
 		}
 		b.skip(int(len))
-		nunit++
+		if len > 0 {
+			nunit++
+		}
 	}
 	if b.err != nil {
 		return nil, b.err
@@ -61,7 +63,9 @@ func (d *Data) parseUnits() ([]unit, error) {
 		u := &units[i]
 		u.base = b.off
 		var n Offset
-		n, u.is64 = b.unitLength()
+		for n == 0 {
+			n, u.is64 = b.unitLength()
+		}
 		dataOff := b.off
 		vers := b.uint16()
 		if vers < 2 || vers > 5 {
-- 
GitLab


From c0e1301b8c137d4b9f93067469b9608c252f2cea Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 20 Apr 2021 15:00:35 -0400
Subject: [PATCH 1742/2400] cmd/link: fix PE section attributes for
 windows/arm64

The clang-mingw toolchain on windows/arm64 expects
.text to NOT be listed as containing initialized data and
.dwarf* to be listed as  containing initialized data.
Neither is true today, resulting in the go .text and .dwarf*
not being merged with the system .text and .dwarf*.
Having multiple .text and .dwarf* sections confuses all
kinds of tools.

Change-Id: I1b9832804c5f5d594bf19e8ee0a5ed31bc1d381d
Reviewed-on: https://go-review.googlesource.com/c/go/+/312032
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/link/internal/ld/pe.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/link/internal/ld/pe.go b/src/cmd/link/internal/ld/pe.go
index 729b6b2443..30654412b9 100644
--- a/src/cmd/link/internal/ld/pe.go
+++ b/src/cmd/link/internal/ld/pe.go
@@ -452,7 +452,7 @@ func (f *peFile) addDWARFSection(name string, size int) *peSection {
 	off := f.stringTable.add(name)
 	h := f.addSection(name, size, size)
 	h.shortName = fmt.Sprintf("/%d", off)
-	h.characteristics = IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_DISCARDABLE
+	h.characteristics = IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_CNT_INITIALIZED_DATA
 	return h
 }
 
@@ -1593,7 +1593,7 @@ func addpersrc(ctxt *Link) {
 
 func asmbPe(ctxt *Link) {
 	t := pefile.addSection(".text", int(Segtext.Length), int(Segtext.Length))
-	t.characteristics = IMAGE_SCN_CNT_CODE | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ
+	t.characteristics = IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ
 	if ctxt.LinkMode == LinkExternal {
 		// some data symbols (e.g. masks) end up in the .text section, and they normally
 		// expect larger alignment requirement than the default text section alignment.
-- 
GitLab


From 9f7079c44e670532df68ab78a1869cb99531c864 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 14 Apr 2021 12:30:36 -0400
Subject: [PATCH 1743/2400] cmd/link: sort the pclntab relocations

llvm-mingw's lld produces an invalid windows/arm64 executable
when presented with relocations that are out of order
(the relocation for each function is emitted for two different
locations, so we end up with two sorted streams roughly
interlaced, not one sorted stream).

Sorting should not break other systems, so sort always.

Change-Id: Ic9a95e7145881db5984cbda442f27b0cc24748fb
Reviewed-on: https://go-review.googlesource.com/c/go/+/312033
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/link/internal/ld/pcln.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/cmd/link/internal/ld/pcln.go b/src/cmd/link/internal/ld/pcln.go
index 79ad9d73e9..05fd302369 100644
--- a/src/cmd/link/internal/ld/pcln.go
+++ b/src/cmd/link/internal/ld/pcln.go
@@ -590,6 +590,7 @@ func (state *pclntab) generateFunctab(ctxt *Link, funcs []loader.Sym, inlSyms ma
 	if !useSymValue {
 		// Generate relocations for funcdata when externally linking.
 		state.writeFuncData(ctxt, sb, funcs, inlSyms, startLocations, setAddr, setUintNOP)
+		sb.SortRelocs()
 	}
 }
 
-- 
GitLab


From 41e5ae4883b2f3c32958731ef589488f4fc06449 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 14 Apr 2021 19:53:59 -0400
Subject: [PATCH 1744/2400] cmd/link: deal with no constructors

Change-Id: I6ed153b780c70fa90822e4daa5749478ac43afca
Reviewed-on: https://go-review.googlesource.com/c/go/+/312034
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/link/internal/ld/pe.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/cmd/link/internal/ld/pe.go b/src/cmd/link/internal/ld/pe.go
index 30654412b9..b70c0693e8 100644
--- a/src/cmd/link/internal/ld/pe.go
+++ b/src/cmd/link/internal/ld/pe.go
@@ -607,6 +607,10 @@ dwarfLoop:
 		Errorf(nil, "emitRelocations: could not find %q section", sect.Name)
 	}
 
+	if f.ctorsSect == nil {
+		return
+	}
+
 	f.ctorsSect.emitRelocations(ctxt.Out, func() int {
 		dottext := ldr.Lookup(".text", 0)
 		ctxt.Out.Write32(0)
-- 
GitLab


From 199575a119d909b98afb044a94f43249883c1062 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 14 Apr 2021 19:53:43 -0400
Subject: [PATCH 1745/2400] cmd/link: count relocations better

Change-Id: Ie188abeb0194bf266d38c9bd0dda4b8f48934697
Reviewed-on: https://go-review.googlesource.com/c/go/+/312035
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/link/internal/ld/pe.go | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/cmd/link/internal/ld/pe.go b/src/cmd/link/internal/ld/pe.go
index b70c0693e8..9643f9690c 100644
--- a/src/cmd/link/internal/ld/pe.go
+++ b/src/cmd/link/internal/ld/pe.go
@@ -524,7 +524,6 @@ func (f *peFile) emitRelocations(ctxt *Link) {
 		if sect.Vaddr >= sect.Seg.Vaddr+sect.Seg.Filelen {
 			return 0
 		}
-		nrelocs := 0
 		sect.Reloff = uint64(ctxt.Out.Offset())
 		for i, s := range syms {
 			if !ldr.AttrReachable(s) {
@@ -562,11 +561,11 @@ func (f *peFile) emitRelocations(ctxt *Link) {
 				if !thearch.PEreloc1(ctxt.Arch, ctxt.Out, ldr, s, rr, int64(uint64(ldr.SymValue(s)+int64(r.Off()))-base)) {
 					ctxt.Errorf(s, "unsupported obj reloc %d/%d to %s", r.Type(), r.Siz(), ldr.SymName(r.Sym()))
 				}
-				nrelocs++
 			}
 		}
 		sect.Rellen = uint64(ctxt.Out.Offset()) - sect.Reloff
-		return nrelocs
+		const relocLen = 4 + 4 + 2
+		return int(sect.Rellen / relocLen)
 	}
 
 	sects := []struct {
-- 
GitLab


From 59ceb985c7f78ca5dba6b83ff126d97d86267d7c Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 14 Apr 2021 12:44:04 -0400
Subject: [PATCH 1746/2400] cmd/link: make Loader.SymName not crash

Even if not presented with a valid symbol, recover gracefully,
so that debug prints do not crash.

Change-Id: I06bbe4bec5f90b79b4830e772a7fc3d7c919df1b
Reviewed-on: https://go-review.googlesource.com/c/go/+/312036
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/link/internal/loader/loader.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/cmd/link/internal/loader/loader.go b/src/cmd/link/internal/loader/loader.go
index 141dd0ac68..d5331b3fef 100644
--- a/src/cmd/link/internal/loader/loader.go
+++ b/src/cmd/link/internal/loader/loader.go
@@ -771,6 +771,9 @@ func (l *Loader) SymName(i Sym) string {
 		return pp.name
 	}
 	r, li := l.toLocal(i)
+	if r == nil {
+		return "?"
+	}
 	name := r.Sym(li).Name(r.Reader)
 	if !r.NeedNameExpansion() {
 		return name
-- 
GitLab


From a0248a99a8567fcd8188e08977ec5eafd553bc18 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 14 Apr 2021 12:55:43 -0400
Subject: [PATCH 1747/2400] cmd/link: fix PE emitRelocations for >4GB base
 address

Change-Id: I1dda31bb1efa177159e4e7b4c9c9cc615e2fdc0c
Reviewed-on: https://go-review.googlesource.com/c/go/+/312037
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/link/internal/ld/pe.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/cmd/link/internal/ld/pe.go b/src/cmd/link/internal/ld/pe.go
index 9643f9690c..3490dd698a 100644
--- a/src/cmd/link/internal/ld/pe.go
+++ b/src/cmd/link/internal/ld/pe.go
@@ -534,12 +534,12 @@ func (f *peFile) emitRelocations(ctxt *Link) {
 				break
 			}
 		}
-		eaddr := int32(sect.Vaddr + sect.Length)
+		eaddr := int64(sect.Vaddr + sect.Length)
 		for _, s := range syms {
 			if !ldr.AttrReachable(s) {
 				continue
 			}
-			if ldr.SymValue(s) >= int64(eaddr) {
+			if ldr.SymValue(s) >= eaddr {
 				break
 			}
 			// Compute external relocations on the go, and pass to PEreloc1
@@ -559,7 +559,7 @@ func (f *peFile) emitRelocations(ctxt *Link) {
 					ctxt.Errorf(s, "reloc %d to non-coff symbol %s (outer=%s) %d", r.Type(), ldr.SymName(r.Sym()), ldr.SymName(rr.Xsym), ldr.SymType(r.Sym()))
 				}
 				if !thearch.PEreloc1(ctxt.Arch, ctxt.Out, ldr, s, rr, int64(uint64(ldr.SymValue(s)+int64(r.Off()))-base)) {
-					ctxt.Errorf(s, "unsupported obj reloc %d/%d to %s", r.Type(), r.Siz(), ldr.SymName(r.Sym()))
+					ctxt.Errorf(s, "unsupported obj reloc %v/%d to %s", r.Type(), r.Siz(), ldr.SymName(r.Sym()))
 				}
 			}
 		}
-- 
GitLab


From 79f35130cd8cd391ae98dffb1eb303b53610a0be Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 14 Apr 2021 12:52:53 -0400
Subject: [PATCH 1748/2400] cmd/link: expand PE constants and fix doc URL

Change-Id: Ie3492b925f6d12430ce05e7d727e739a62f201e5
Reviewed-on: https://go-review.googlesource.com/c/go/+/312038
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/link/internal/ld/pe.go | 35 ++++++++++++++++++++++++++++------
 1 file changed, 29 insertions(+), 6 deletions(-)

diff --git a/src/cmd/link/internal/ld/pe.go b/src/cmd/link/internal/ld/pe.go
index 3490dd698a..5424bdc99a 100644
--- a/src/cmd/link/internal/ld/pe.go
+++ b/src/cmd/link/internal/ld/pe.go
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.
 
 // PE (Portable Executable) file writing
-// https://www.microsoft.com/whdc/system/platform/firmware/PECOFF.mspx
+// https://docs.microsoft.com/en-us/windows/win32/debug/pe-format
 
 package ld
 
@@ -62,14 +62,37 @@ const (
 	IMAGE_SCN_CNT_CODE               = 0x00000020
 	IMAGE_SCN_CNT_INITIALIZED_DATA   = 0x00000040
 	IMAGE_SCN_CNT_UNINITIALIZED_DATA = 0x00000080
+	IMAGE_SCN_LNK_OTHER              = 0x00000100
+	IMAGE_SCN_LNK_INFO               = 0x00000200
+	IMAGE_SCN_LNK_REMOVE             = 0x00000800
+	IMAGE_SCN_LNK_COMDAT             = 0x00001000
+	IMAGE_SCN_GPREL                  = 0x00008000
+	IMAGE_SCN_MEM_PURGEABLE          = 0x00020000
+	IMAGE_SCN_MEM_16BIT              = 0x00020000
+	IMAGE_SCN_MEM_LOCKED             = 0x00040000
+	IMAGE_SCN_MEM_PRELOAD            = 0x00080000
+	IMAGE_SCN_ALIGN_1BYTES           = 0x00100000
+	IMAGE_SCN_ALIGN_2BYTES           = 0x00200000
+	IMAGE_SCN_ALIGN_4BYTES           = 0x00300000
+	IMAGE_SCN_ALIGN_8BYTES           = 0x00400000
+	IMAGE_SCN_ALIGN_16BYTES          = 0x00500000
+	IMAGE_SCN_ALIGN_32BYTES          = 0x00600000
+	IMAGE_SCN_ALIGN_64BYTES          = 0x00700000
+	IMAGE_SCN_ALIGN_128BYTES         = 0x00800000
+	IMAGE_SCN_ALIGN_256BYTES         = 0x00900000
+	IMAGE_SCN_ALIGN_512BYTES         = 0x00A00000
+	IMAGE_SCN_ALIGN_1024BYTES        = 0x00B00000
+	IMAGE_SCN_ALIGN_2048BYTES        = 0x00C00000
+	IMAGE_SCN_ALIGN_4096BYTES        = 0x00D00000
+	IMAGE_SCN_ALIGN_8192BYTES        = 0x00E00000
+	IMAGE_SCN_LNK_NRELOC_OVFL        = 0x01000000
+	IMAGE_SCN_MEM_DISCARDABLE        = 0x02000000
+	IMAGE_SCN_MEM_NOT_CACHED         = 0x04000000
+	IMAGE_SCN_MEM_NOT_PAGED          = 0x08000000
+	IMAGE_SCN_MEM_SHARED             = 0x10000000
 	IMAGE_SCN_MEM_EXECUTE            = 0x20000000
 	IMAGE_SCN_MEM_READ               = 0x40000000
 	IMAGE_SCN_MEM_WRITE              = 0x80000000
-	IMAGE_SCN_MEM_DISCARDABLE        = 0x2000000
-	IMAGE_SCN_LNK_NRELOC_OVFL        = 0x1000000
-	IMAGE_SCN_ALIGN_4BYTES           = 0x300000
-	IMAGE_SCN_ALIGN_8BYTES           = 0x400000
-	IMAGE_SCN_ALIGN_32BYTES          = 0x600000
 )
 
 // See https://docs.microsoft.com/en-us/windows/win32/debug/pe-format.
-- 
GitLab


From e5a6c5243c67523e181607e64957b718f48a3b7c Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 14 Apr 2021 12:50:40 -0400
Subject: [PATCH 1749/2400] cmd/link: force external link for windows/arm64 cgo
 binaries

Change-Id: I833cac61125513fde4b93ebf14da8bab88908eab
Reviewed-on: https://go-review.googlesource.com/c/go/+/312040
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/link/internal/ld/config.go | 4 ++++
 src/cmd/link/internal/ld/lib.go    | 2 +-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/cmd/link/internal/ld/config.go b/src/cmd/link/internal/ld/config.go
index 75fddc6a38..ae0d7520eb 100644
--- a/src/cmd/link/internal/ld/config.go
+++ b/src/cmd/link/internal/ld/config.go
@@ -205,6 +205,10 @@ func mustLinkExternal(ctxt *Link) (res bool, reason string) {
 		// doesn't work. Test case is "go test runtime/cgo".
 		return true, buildcfg.GOOS + " does not support internal cgo"
 	}
+	if iscgo && buildcfg.GOOS == "windows" && buildcfg.GOARCH == "arm64" {
+		// windows/arm64 internal linking is not implemented.
+		return true, buildcfg.GOOS + "/" + buildcfg.GOARCH + " does not support internal cgo"
+	}
 
 	// When the race flag is set, the LLVM tsan relocatable file is linked
 	// into the final binary, which means external linking is required because
diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index d2dc3fb175..adf1669cf2 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -1868,7 +1868,7 @@ func ldobj(ctxt *Link, f *bio.Reader, lib *sym.Library, length int64, pn string,
 			return nil
 		}
 
-		Errorf(nil, "%s: not an object file", pn)
+		Errorf(nil, "%s: not an object file: @%d %02x%02x%02x%02x", pn, start, c1, c2, c3, c4)
 		return nil
 	}
 
-- 
GitLab


From 16330817aa6588651a09df03b556091c16052ce6 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 14 Apr 2021 12:33:51 -0400
Subject: [PATCH 1750/2400] runtime: add windows/arm64 cgo-linking code

This code is needed for use with cgo proper
(as opposed to hand-written DLL calls, which
we always use but only exercise cgo execution,
not cgo linking).

Change-Id: Iddc31d9c1c924d83d032b80dca65ddfda6624046
Reviewed-on: https://go-review.googlesource.com/c/go/+/312041
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/cgo/gcc_windows_arm64.c | 46 +++++++++++++++++++++++++++++
 src/runtime/rt0_windows_arm64.s     | 17 +++++++++++
 src/runtime/sys_windows_arm.s       |  2 +-
 3 files changed, 64 insertions(+), 1 deletion(-)
 create mode 100644 src/runtime/cgo/gcc_windows_arm64.c

diff --git a/src/runtime/cgo/gcc_windows_arm64.c b/src/runtime/cgo/gcc_windows_arm64.c
new file mode 100644
index 0000000000..61ef094866
--- /dev/null
+++ b/src/runtime/cgo/gcc_windows_arm64.c
@@ -0,0 +1,46 @@
+// Copyright 2009 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.
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <process.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include "libcgo.h"
+#include "libcgo_windows.h"
+
+static void threadentry(void*);
+static void (*setg_gcc)(void*);
+
+void
+x_cgo_init(G *g, void (*setg)(void*))
+{
+	setg_gcc = setg;
+}
+
+void
+_cgo_sys_thread_start(ThreadStart *ts)
+{
+	uintptr_t thandle;
+
+	thandle = _beginthread(threadentry, 0, ts);
+	if(thandle == -1) {
+		fprintf(stderr, "runtime: failed to create new OS thread (%d)\n", errno);
+		abort();
+	}
+}
+
+extern void crosscall1(void (*fn)(void), void (*setg_gcc)(void*), void *g);
+
+static void
+threadentry(void *v)
+{
+	ThreadStart ts;
+
+	ts = *(ThreadStart*)v;
+	free(v);
+
+	crosscall1(ts.fn, setg_gcc, (void *)ts.g);
+}
diff --git a/src/runtime/rt0_windows_arm64.s b/src/runtime/rt0_windows_arm64.s
index 1e71a068d3..bad85c28ac 100644
--- a/src/runtime/rt0_windows_arm64.s
+++ b/src/runtime/rt0_windows_arm64.s
@@ -10,3 +10,20 @@
 // kernel for an ordinary -buildmode=exe program.
 TEXT _rt0_arm64_windows(SB),NOSPLIT|NOFRAME,$0
 	B	·rt0_go(SB)
+
+TEXT _rt0_arm64_windows_lib(SB),NOSPLIT|NOFRAME,$0
+	MOVD	$_rt0_arm64_windows_lib_go(SB), R0
+	MOVD	$0, R1
+	MOVD	_cgo_sys_thread_create(SB), R2
+	B	(R2)
+
+TEXT _rt0_arm64_windows_lib_go(SB),NOSPLIT|NOFRAME,$0
+	MOVD	$0, R0
+	MOVD	$0, R1
+	MOVD	$runtime·rt0_go(SB), R2
+	B	(R2)
+
+TEXT main(SB),NOSPLIT,$0
+	MOVD	$runtime·rt0_go(SB), R2
+	B	(R2)
+
diff --git a/src/runtime/sys_windows_arm.s b/src/runtime/sys_windows_arm.s
index 8073fc0198..6234203798 100644
--- a/src/runtime/sys_windows_arm.s
+++ b/src/runtime/sys_windows_arm.s
@@ -335,7 +335,7 @@ TEXT runtime·switchtothread(SB),NOSPLIT|NOFRAME,$0
 TEXT ·publicationBarrier(SB),NOSPLIT|NOFRAME,$0-0
 	B	runtime·armPublicationBarrier(SB)
 
-// never called (cgo not supported)
+// never called (this is a GOARM=7 platform)
 TEXT runtime·read_tls_fallback(SB),NOSPLIT|NOFRAME,$0
 	MOVW	$0xabcd, R0
 	MOVW	R0, (R0)
-- 
GitLab


From a25d1d45d968253f0b257cca9d57619a5af248c9 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 20 Apr 2021 14:05:49 -0400
Subject: [PATCH 1751/2400] runtime: fix windows/arm64 callbackasm1 for frame
 pointer hack

Fixes the previously failing TestStdcallAndCDeclCallbacks
for the 9+ argument case.

The last time this code passed, the invisible frame pointer
below SP was apparently not enabled on windows/arm64.

Change-Id: Ifc3064e894b2f39d6410f3be51c17309ebab08a4
Reviewed-on: https://go-review.googlesource.com/c/go/+/312042
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/sys_windows_arm64.s | 23 ++++++++++++++---------
 1 file changed, 14 insertions(+), 9 deletions(-)

diff --git a/src/runtime/sys_windows_arm64.s b/src/runtime/sys_windows_arm64.s
index 6b28a0c2ef..9fce9a8158 100644
--- a/src/runtime/sys_windows_arm64.s
+++ b/src/runtime/sys_windows_arm64.s
@@ -309,14 +309,19 @@ TEXT runtime·callbackasm1<ABIInternal>(SB),NOSPLIT,$208-0
 
 	// Save callback register arguments R0-R7.
 	// We do this at the top of the frame so they're contiguous with stack arguments.
-	MOVD	R0, arg0-(8*8)(SP)
-	MOVD	R1, arg1-(7*8)(SP)
-	MOVD	R2, arg2-(6*8)(SP)
-	MOVD	R3, arg3-(5*8)(SP)
-	MOVD	R4, arg4-(4*8)(SP)
-	MOVD	R5, arg5-(3*8)(SP)
-	MOVD	R6, arg6-(2*8)(SP)
-	MOVD	R7, arg7-(1*8)(SP)
+	// The 7*8 setting up R14 looks like a bug but is not: the eighth word
+	// is the space the assembler reserved for our caller's frame pointer,
+	// but we are not called from Go so that space is ours to use,
+	// and we must to be contiguous with the stack arguments.
+	MOVD	$arg0-(7*8)(SP), R14
+	MOVD	R0, (0*8)(R14)
+	MOVD	R1, (1*8)(R14)
+	MOVD	R2, (2*8)(R14)
+	MOVD	R3, (3*8)(R14)
+	MOVD	R4, (4*8)(R14)
+	MOVD	R5, (5*8)(R14)
+	MOVD	R6, (6*8)(R14)
+	MOVD	R7, (7*8)(R14)
 
 	// Push C callee-save registers R19-R28.
 	// LR, FP already saved.
@@ -325,7 +330,7 @@ TEXT runtime·callbackasm1<ABIInternal>(SB),NOSPLIT,$208-0
 	// Create a struct callbackArgs on our stack.
 	MOVD	$cbargs-(18*8+callbackArgs__size)(SP), R13
 	MOVD	R12, callbackArgs_index(R13)	// callback index
-	MOVD	$arg0-(8*8)(SP), R0
+	MOVD	R14, R0
 	MOVD	R0, callbackArgs_args(R13)		// address of args vector
 	MOVD	$0, R0
 	MOVD	R0, callbackArgs_result(R13)	// result
-- 
GitLab


From bf9216055b98e94cb2c96f4534777dd6d0ee0532 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 20 Apr 2021 14:06:51 -0400
Subject: [PATCH 1752/2400] runtime/testdata: fix testprogcgo for windows/arm64

Our toolchain does not like -mnop-fun-dllimport.

Change-Id: Iaaee01fe0f4b0959406a35eb13aefa390116b483
Reviewed-on: https://go-review.googlesource.com/c/go/+/312043
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/testdata/testprogcgo/windows/win.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/testdata/testprogcgo/windows/win.go b/src/runtime/testdata/testprogcgo/windows/win.go
index f2eabb9548..12488aa658 100644
--- a/src/runtime/testdata/testprogcgo/windows/win.go
+++ b/src/runtime/testdata/testprogcgo/windows/win.go
@@ -1,7 +1,7 @@
 package windows
 
 /*
-#cgo CFLAGS: -mnop-fun-dllimport
+#cgo amd64 386 CFLAGS: -mnop-fun-dllimport
 
 #include <windows.h>
 
-- 
GitLab


From 8e368708c510219dabfb38a4781d2152420c778f Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 20 Apr 2021 14:12:04 -0400
Subject: [PATCH 1753/2400] cmd/link: implement windows/arm64 external linking

Change-Id: Ia73309ec7013138b37028e669d7ae5eac81126e8
Reviewed-on: https://go-review.googlesource.com/c/go/+/312044
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/link/internal/arm64/asm.go | 186 ++++++++++++++++++++---------
 src/cmd/link/internal/ld/pe.go     |  10 ++
 2 files changed, 140 insertions(+), 56 deletions(-)

diff --git a/src/cmd/link/internal/arm64/asm.go b/src/cmd/link/internal/arm64/asm.go
index 90ae38594e..68e59f2dcf 100644
--- a/src/cmd/link/internal/arm64/asm.go
+++ b/src/cmd/link/internal/arm64/asm.go
@@ -464,8 +464,9 @@ func elfreloc1(ctxt *ld.Link, out *ld.OutBuf, ldr *loader.Loader, s loader.Sym,
 	return true
 }
 
-// sign-extends from 24-bit.
-func signext24(x int64) int64 { return x << 40 >> 40 }
+// sign-extends from 21, 24-bit.
+func signext21(x int64) int64 { return x << (64 - 21) >> (64 - 21) }
+func signext24(x int64) int64 { return x << (64 - 24) >> (64 - 24) }
 
 func machoreloc1(arch *sys.Arch, out *ld.OutBuf, ldr *loader.Loader, s loader.Sym, r loader.ExtReloc, sectoff int64) bool {
 	var v uint32
@@ -478,7 +479,7 @@ func machoreloc1(arch *sys.Arch, out *ld.OutBuf, ldr *loader.Loader, s loader.Sy
 	if xadd != signext24(xadd) {
 		// If the relocation target would overflow the addend, then target
 		// a linker-manufactured label symbol with a smaller addend instead.
-		label := ldr.Lookup(machoLabelName(ldr, rs, xadd), ldr.SymVersion(rs))
+		label := ldr.Lookup(offsetLabelName(ldr, rs, xadd/machoRelocLimit*machoRelocLimit), ldr.SymVersion(rs))
 		if label != 0 {
 			xadd = ldr.SymValue(rs) + xadd - ldr.SymValue(label)
 			rs = label
@@ -569,35 +570,67 @@ func machoreloc1(arch *sys.Arch, out *ld.OutBuf, ldr *loader.Loader, s loader.Sy
 }
 
 func pereloc1(arch *sys.Arch, out *ld.OutBuf, ldr *loader.Loader, s loader.Sym, r loader.ExtReloc, sectoff int64) bool {
-	var v uint32
-
 	rs := r.Xsym
 	rt := r.Type
 
-	if ldr.SymDynid(rs) < 0 {
+	if r.Xadd != signext21(r.Xadd) {
+		// If the relocation target would overflow the addend, then target
+		// a linker-manufactured label symbol with a smaller addend instead.
+		label := ldr.Lookup(offsetLabelName(ldr, rs, r.Xadd/peRelocLimit*peRelocLimit), ldr.SymVersion(rs))
+		if label == 0 {
+			ldr.Errorf(s, "invalid relocation: %v %s+0x%x", rt, ldr.SymName(rs), r.Xadd)
+			return false
+		}
+		rs = label
+	}
+	if rt == objabi.R_CALLARM64 && r.Xadd != 0 {
+		label := ldr.Lookup(offsetLabelName(ldr, rs, r.Xadd), ldr.SymVersion(rs))
+		if label == 0 {
+			ldr.Errorf(s, "invalid relocation: %v %s+0x%x", rt, ldr.SymName(rs), r.Xadd)
+			return false
+		}
+		rs = label
+	}
+	symdynid := ldr.SymDynid(rs)
+	if symdynid < 0 {
 		ldr.Errorf(s, "reloc %d (%s) to non-coff symbol %s type=%d (%s)", rt, sym.RelocName(arch, rt), ldr.SymName(rs), ldr.SymType(rs), ldr.SymType(rs))
 		return false
 	}
 
-	out.Write32(uint32(sectoff))
-	out.Write32(uint32(ldr.SymDynid(rs)))
-
 	switch rt {
 	default:
 		return false
 
 	case objabi.R_DWARFSECREF:
-		v = ld.IMAGE_REL_ARM64_SECREL
+		out.Write32(uint32(sectoff))
+		out.Write32(uint32(symdynid))
+		out.Write16(ld.IMAGE_REL_ARM64_SECREL)
 
 	case objabi.R_ADDR:
+		out.Write32(uint32(sectoff))
+		out.Write32(uint32(symdynid))
 		if r.Size == 8 {
-			v = ld.IMAGE_REL_ARM64_ADDR64
+			out.Write16(ld.IMAGE_REL_ARM64_ADDR64)
 		} else {
-			v = ld.IMAGE_REL_ARM64_ADDR32
+			out.Write16(ld.IMAGE_REL_ARM64_ADDR32)
 		}
-	}
 
-	out.Write16(uint16(v))
+	case objabi.R_ADDRARM64:
+		// Note: r.Xadd has been taken care of below, in archreloc.
+		out.Write32(uint32(sectoff))
+		out.Write32(uint32(symdynid))
+		out.Write16(ld.IMAGE_REL_ARM64_PAGEBASE_REL21)
+
+		out.Write32(uint32(sectoff + 4))
+		out.Write32(uint32(symdynid))
+		out.Write16(ld.IMAGE_REL_ARM64_PAGEOFFSET_12A)
+
+	case objabi.R_CALLARM64:
+		// Note: r.Xadd has been taken care of above, by using a label pointing into the middle of the function.
+		out.Write32(uint32(sectoff))
+		out.Write32(uint32(symdynid))
+		out.Write16(ld.IMAGE_REL_ARM64_BRANCH26)
+	}
 
 	return true
 }
@@ -628,14 +661,8 @@ func archreloc(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, r loade
 				nExtReloc = 4 // need another two relocations for non-zero addend
 			}
 
-			// Note: ld64 currently has a bug that any non-zero addend for BR26 relocation
-			// will make the linking fail because it thinks the code is not PIC even though
-			// the BR26 relocation should be fully resolved at link time.
-			// That is the reason why the next if block is disabled. When the bug in ld64
-			// is fixed, we can enable this block and also enable duff's device in cmd/7g.
-			if false && target.IsDarwin() {
+			if target.IsWindows() {
 				var o0, o1 uint32
-
 				if target.IsBigEndian() {
 					o0 = uint32(val >> 32)
 					o1 = uint32(val)
@@ -643,15 +670,20 @@ func archreloc(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, r loade
 					o0 = uint32(val)
 					o1 = uint32(val >> 32)
 				}
-				// Mach-O wants the addend to be encoded in the instruction
-				// Note that although Mach-O supports ARM64_RELOC_ADDEND, it
-				// can only encode 24-bit of signed addend, but the instructions
-				// supports 33-bit of signed addend, so we always encode the
-				// addend in place.
-				o0 |= (uint32((xadd>>12)&3) << 29) | (uint32((xadd>>12>>2)&0x7ffff) << 5)
-				o1 |= uint32(xadd&0xfff) << 10
-
-				// when laid out, the instruction order must always be o1, o2.
+
+				// The first instruction (ADRP) has a 21-bit immediate field,
+				// and the second (ADD) has a 12-bit immediate field.
+				// The first instruction is only for high bits, but to get the carry bits right we have
+				// to put the full addend, including the bottom 12 bits again.
+				// That limits the distance of any addend to only 21 bits.
+				// But we assume that LDRP's top bit will be interpreted as a sign bit,
+				// so we only use 20 bits.
+				// pereloc takes care of introducing new symbol labels
+				// every megabyte for longer relocations.
+				xadd := uint32(xadd)
+				o0 |= (xadd&3)<<29 | (xadd&0xffffc)<<3
+				o1 |= (xadd & 0xfff) << 10
+
 				if target.IsBigEndian() {
 					val = int64(o0)<<32 | int64(o1)
 				} else {
@@ -668,6 +700,18 @@ func archreloc(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, r loade
 				nExtReloc = 2 // need two ELF relocations. see elfreloc1
 			}
 			return val, nExtReloc, isOk
+
+		case objabi.R_ADDR:
+			if target.IsWindows() && r.Add() != 0 {
+				if r.Siz() == 8 {
+					val = r.Add()
+				} else if target.IsBigEndian() {
+					val = int64(uint32(val)) | int64(r.Add())<<32
+				} else {
+					val = val>>32<<32 | int64(uint32(r.Add()))
+				}
+				return val, 1, true
+			}
 		}
 	}
 
@@ -1018,37 +1062,54 @@ func addpltsym(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, s loade
 	}
 }
 
-const machoRelocLimit = 1 << 23
+const (
+	machoRelocLimit = 1 << 23
+	peRelocLimit    = 1 << 20
+)
 
 func gensymlate(ctxt *ld.Link, ldr *loader.Loader) {
 	// When external linking on darwin, Mach-O relocation has only signed 24-bit
 	// addend. For large symbols, we generate "label" symbols in the middle, so
 	// that relocations can target them with smaller addends.
-	if !ctxt.IsDarwin() || !ctxt.IsExternal() {
+	// On Windows, we only get 21 bits, again (presumably) signed.
+	if !ctxt.IsDarwin() && !ctxt.IsWindows() || !ctxt.IsExternal() {
 		return
 	}
 
-	big := false
-	for _, seg := range ld.Segments {
-		if seg.Length >= machoRelocLimit {
-			big = true
-			break
-		}
+	limit := int64(machoRelocLimit)
+	if ctxt.IsWindows() {
+		limit = peRelocLimit
 	}
-	if !big {
-		return // skip work if nothing big
+
+	if ctxt.IsDarwin() {
+		big := false
+		for _, seg := range ld.Segments {
+			if seg.Length >= machoRelocLimit {
+				big = true
+				break
+			}
+		}
+		if !big {
+			return // skip work if nothing big
+		}
 	}
 
-	// addLabelSyms adds "label" symbols at s+machoRelocLimit, s+2*machoRelocLimit, etc.
-	addLabelSyms := func(s loader.Sym, sz int64) {
+	// addLabelSyms adds "label" symbols at s+limit, s+2*limit, etc.
+	addLabelSyms := func(s loader.Sym, limit, sz int64) {
 		v := ldr.SymValue(s)
-		for off := int64(machoRelocLimit); off < sz; off += machoRelocLimit {
-			p := ldr.LookupOrCreateSym(machoLabelName(ldr, s, off), ldr.SymVersion(s))
+		for off := limit; off < sz; off += limit {
+			p := ldr.LookupOrCreateSym(offsetLabelName(ldr, s, off), ldr.SymVersion(s))
 			ldr.SetAttrReachable(p, true)
 			ldr.SetSymValue(p, v+off)
 			ldr.SetSymSect(p, ldr.SymSect(s))
-			ld.AddMachoSym(ldr, p)
-			//fmt.Printf("gensymlate %s %x\n", ldr.SymName(p), ldr.SymValue(p))
+			if ctxt.IsDarwin() {
+				ld.AddMachoSym(ldr, p)
+			} else if ctxt.IsWindows() {
+				ld.AddPELabelSym(ldr, p)
+			} else {
+				panic("missing case in gensymlate")
+			}
+			// fmt.Printf("gensymlate %s %x\n", ldr.SymName(p), ldr.SymValue(p))
 		}
 	}
 
@@ -1057,26 +1118,39 @@ func gensymlate(ctxt *ld.Link, ldr *loader.Loader) {
 			continue
 		}
 		if ldr.SymType(s) == sym.STEXT {
-			continue // we don't target the middle of a function
+			if ctxt.IsDarwin() || ctxt.IsWindows() {
+				// Cannot relocate into middle of function.
+				// Generate symbol names for every offset we need in duffcopy/duffzero (only 64 each).
+				switch ldr.SymName(s) {
+				case "runtime.duffcopy":
+					addLabelSyms(s, 8, 8*64)
+				case "runtime.duffzero":
+					addLabelSyms(s, 4, 4*64)
+				}
+			}
+			continue // we don't target the middle of other functions
 		}
 		sz := ldr.SymSize(s)
-		if sz <= machoRelocLimit {
+		if sz <= limit {
 			continue
 		}
-		addLabelSyms(s, sz)
+		addLabelSyms(s, limit, sz)
 	}
 
 	// Also for carrier symbols (for which SymSize is 0)
 	for _, ss := range ld.CarrierSymByType {
-		if ss.Sym != 0 && ss.Size > machoRelocLimit {
-			addLabelSyms(ss.Sym, ss.Size)
+		if ss.Sym != 0 && ss.Size > limit {
+			addLabelSyms(ss.Sym, limit, ss.Size)
 		}
 	}
 }
 
-// machoLabelName returns the name of the "label" symbol used for a
-// relocation targeting s+off. The label symbols is used on darwin
-// when external linking, so that the addend fits in a Mach-O relocation.
-func machoLabelName(ldr *loader.Loader, s loader.Sym, off int64) string {
-	return fmt.Sprintf("%s.%d", ldr.SymExtname(s), off/machoRelocLimit)
+// offsetLabelName returns the name of the "label" symbol used for a
+// relocation targeting s+off. The label symbols is used on Darwin/Windows
+// when external linking, so that the addend fits in a Mach-O/PE relocation.
+func offsetLabelName(ldr *loader.Loader, s loader.Sym, off int64) string {
+	if off>>20<<20 == off {
+		return fmt.Sprintf("%s+%dMB", ldr.SymExtname(s), off>>20)
+	}
+	return fmt.Sprintf("%s+%d", ldr.SymExtname(s), off)
 }
diff --git a/src/cmd/link/internal/ld/pe.go b/src/cmd/link/internal/ld/pe.go
index 5424bdc99a..b7d057ebdc 100644
--- a/src/cmd/link/internal/ld/pe.go
+++ b/src/cmd/link/internal/ld/pe.go
@@ -704,6 +704,12 @@ func (f *peFile) mapToPESection(ldr *loader.Loader, s loader.Sym, linkmode LinkM
 	return f.bssSect.index, int64(v - Segdata.Filelen), nil
 }
 
+var isLabel = make(map[loader.Sym]bool)
+
+func AddPELabelSym(ldr *loader.Loader, s loader.Sym) {
+	isLabel[s] = true
+}
+
 // writeSymbols writes all COFF symbol table records.
 func (f *peFile) writeSymbols(ctxt *Link) {
 	ldr := ctxt.loader
@@ -800,6 +806,10 @@ func (f *peFile) writeSymbols(ctxt *Link) {
 		switch t {
 		case sym.SDYNIMPORT, sym.SHOSTOBJ, sym.SUNDEFEXT:
 			addsym(s)
+		default:
+			if len(isLabel) > 0 && isLabel[s] {
+				addsym(s)
+			}
 		}
 	}
 }
-- 
GitLab


From 9cc3469106df94ad0d3c806bcfbddb7e5224d8b6 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 20 Apr 2021 15:43:17 -0400
Subject: [PATCH 1754/2400] all: do not test internal linking on windows/arm64

(It doesn't work and isn't used by default.)

Change-Id: I90118d889bd963471f0915d8183502b55bd9dbf2
Reviewed-on: https://go-review.googlesource.com/c/go/+/312045
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/link/link_test.go     | 3 ++-
 src/cmd/nm/nm_cgo_test.go     | 5 +++++
 src/debug/pe/file_cgo_test.go | 4 ++++
 3 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/src/cmd/link/link_test.go b/src/cmd/link/link_test.go
index 985aed49e2..285c650282 100644
--- a/src/cmd/link/link_test.go
+++ b/src/cmd/link/link_test.go
@@ -177,7 +177,8 @@ func TestIssue33979(t *testing.T) {
 	case "mips", "mipsle", "mips64", "mips64le":
 		t.Skipf("Skipping on %s/%s", runtime.GOOS, runtime.GOARCH)
 	}
-	if runtime.GOOS == "aix" {
+	if runtime.GOOS == "aix" ||
+		runtime.GOOS == "windows" && runtime.GOARCH == "arm64" {
 		t.Skipf("Skipping on %s/%s", runtime.GOOS, runtime.GOARCH)
 	}
 
diff --git a/src/cmd/nm/nm_cgo_test.go b/src/cmd/nm/nm_cgo_test.go
index 536e87e4ae..d0937904a2 100644
--- a/src/cmd/nm/nm_cgo_test.go
+++ b/src/cmd/nm/nm_cgo_test.go
@@ -33,6 +33,11 @@ func canInternalLink() bool {
 		case "arm64":
 			return false
 		}
+	case "windows":
+		switch runtime.GOARCH {
+		case "arm64":
+			return false
+		}
 	}
 	return true
 }
diff --git a/src/debug/pe/file_cgo_test.go b/src/debug/pe/file_cgo_test.go
index bba3a068d6..13eb4e62b2 100644
--- a/src/debug/pe/file_cgo_test.go
+++ b/src/debug/pe/file_cgo_test.go
@@ -9,6 +9,7 @@ package pe
 
 import (
 	"os/exec"
+	"runtime"
 	"testing"
 )
 
@@ -24,6 +25,9 @@ func TestDefaultLinkerDWARF(t *testing.T) {
 }
 
 func TestInternalLinkerDWARF(t *testing.T) {
+	if runtime.GOARCH == "arm64" {
+		t.Skip("internal linker disabled on windows/arm64")
+	}
 	testCgoDWARF(t, linkCgoInternal)
 }
 
-- 
GitLab


From a6d3dc40c40c8a93e6b8bd641104d7655eb5093b Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 20 Apr 2021 16:22:01 -0400
Subject: [PATCH 1755/2400] misc/cgo/testso, misc/cgo/testsovar: fix for
 Windows

At least in mingw-clang it is not permitted to just name a .dll
on the command line. You must name the corresponding import
library instead, even though the dll is used when the executable
is run.

This fixes misc/cgo/testso and misc/cgo/testsovar on windows/arm64.

Change-Id: I516b6ccba2fe3a9ee2c01e710a71850c4df8522f
Reviewed-on: https://go-review.googlesource.com/c/go/+/312046
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 misc/cgo/testso/so_test.go           | 4 ++++
 misc/cgo/testso/testdata/cgoso.go    | 2 +-
 misc/cgo/testsovar/so_test.go        | 4 ++++
 misc/cgo/testsovar/testdata/cgoso.go | 2 +-
 4 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/misc/cgo/testso/so_test.go b/misc/cgo/testso/so_test.go
index 1c97ae9bcb..2023c51f11 100644
--- a/misc/cgo/testso/so_test.go
+++ b/misc/cgo/testso/so_test.go
@@ -79,6 +79,10 @@ func TestSO(t *testing.T) {
 	case "windows":
 		ext = "dll"
 		args = append(args, "-DEXPORT_DLL")
+		// At least in mingw-clang it is not permitted to just name a .dll
+		// on the command line. You must name the corresponding import
+		// library instead, even though the dll is used when the executable is run.
+		args = append(args, "-Wl,-out-implib,libcgosotest.a")
 	case "aix":
 		ext = "so.1"
 	}
diff --git a/misc/cgo/testso/testdata/cgoso.go b/misc/cgo/testso/testdata/cgoso.go
index bba5de3312..b59b2a8e8b 100644
--- a/misc/cgo/testso/testdata/cgoso.go
+++ b/misc/cgo/testso/testdata/cgoso.go
@@ -14,7 +14,7 @@ package cgosotest
 #cgo solaris LDFLAGS: -L. -lcgosotest
 #cgo netbsd LDFLAGS: -L. libcgosotest.so
 #cgo darwin LDFLAGS: -L. libcgosotest.dylib
-#cgo windows LDFLAGS: -L. libcgosotest.dll
+#cgo windows LDFLAGS: -L. libcgosotest.a
 #cgo aix LDFLAGS: -L. -l cgosotest
 
 void init(void);
diff --git a/misc/cgo/testsovar/so_test.go b/misc/cgo/testsovar/so_test.go
index 1c97ae9bcb..2023c51f11 100644
--- a/misc/cgo/testsovar/so_test.go
+++ b/misc/cgo/testsovar/so_test.go
@@ -79,6 +79,10 @@ func TestSO(t *testing.T) {
 	case "windows":
 		ext = "dll"
 		args = append(args, "-DEXPORT_DLL")
+		// At least in mingw-clang it is not permitted to just name a .dll
+		// on the command line. You must name the corresponding import
+		// library instead, even though the dll is used when the executable is run.
+		args = append(args, "-Wl,-out-implib,libcgosotest.a")
 	case "aix":
 		ext = "so.1"
 	}
diff --git a/misc/cgo/testsovar/testdata/cgoso.go b/misc/cgo/testsovar/testdata/cgoso.go
index 9c7f95e92e..d9deb556da 100644
--- a/misc/cgo/testsovar/testdata/cgoso.go
+++ b/misc/cgo/testsovar/testdata/cgoso.go
@@ -18,7 +18,7 @@ package cgosotest
 #cgo solaris LDFLAGS: -L. -lcgosotest
 #cgo netbsd LDFLAGS: -L. libcgosotest.so
 #cgo darwin LDFLAGS: -L. libcgosotest.dylib
-#cgo windows LDFLAGS: -L. libcgosotest.dll
+#cgo windows LDFLAGS: -L. libcgosotest.a
 #cgo aix LDFLAGS: -L. -l cgosotest
 
 #include "cgoso_c.h"
-- 
GitLab


From b8fed48a9ae7e6229a4fdccf6aae7bc670f61aca Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 14 Apr 2021 12:38:20 -0400
Subject: [PATCH 1756/2400] cmd/dist: enable cgo on windows/arm64

Change-Id: I4d470e2af1bfb4fba004a6f3e00a163a575593da
Reviewed-on: https://go-review.googlesource.com/c/go/+/312047
Trust: Russ Cox <rsc@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/cmd/dist/build.go | 2 +-
 src/cmd/dist/test.go  | 6 ++++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/cmd/dist/build.go b/src/cmd/dist/build.go
index 63dd8005e3..28c814d316 100644
--- a/src/cmd/dist/build.go
+++ b/src/cmd/dist/build.go
@@ -1598,7 +1598,7 @@ var cgoEnabled = map[string]bool{
 	"windows/386":     true,
 	"windows/amd64":   true,
 	"windows/arm":     false,
-	"windows/arm64":   false,
+	"windows/arm64":   true,
 }
 
 // List of platforms which are supported but not complete yet. These get
diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go
index 5ae0bf92cf..8b1ec458ed 100644
--- a/src/cmd/dist/test.go
+++ b/src/cmd/dist/test.go
@@ -976,6 +976,9 @@ func (t *tester) internalLink() bool {
 	if goos == "ios" {
 		return false
 	}
+	if goos == "windows" && goarch == "arm64" {
+		return false
+	}
 	// Internally linking cgo is incomplete on some architectures.
 	// https://golang.org/issue/10373
 	// https://golang.org/issue/14449
@@ -1108,8 +1111,7 @@ func (t *tester) cgoTest(dt *distTest) error {
 	cmd := t.addCmd(dt, "misc/cgo/test", t.goTest())
 	cmd.Env = append(os.Environ(), "GOFLAGS=-ldflags=-linkmode=auto")
 
-	// Skip internal linking cases on arm64 to support GCC-9.4 and above,
-	// only for linux, conservatively.
+	// Skip internal linking cases on linux/arm64 to support GCC-9.4 and above.
 	// See issue #39466.
 	skipInternalLink := goarch == "arm64" && goos == "linux"
 
-- 
GitLab


From e7db792fc539603a61b89ae27104730a0a92c1e6 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Fri, 23 Apr 2021 18:11:52 +0000
Subject: [PATCH 1757/2400] runtime: simplify TestSelectStackAdjust

Currently this test attempts to trigger a concurrent GC in a very
indirect way, but the way it does so is extremely error-prone. This test
is virtually always prone to flaking based on test order. For example if
the test that executed immediately before this one made a big heap but
didn't clean it up, then this test could easily fail to trigger a GC.
I was able to prove this with a small reproducer.

This roundabout way of triggering a GC is also way overkill for this
test. It just wants to get goroutines in a select and shrink their
stacks. Every GC will schedule a stack for shrinking if it can.

Replace all the complicated machinery with a single runtime.GC call.
I've confirmed that the test consistently triggers a stack shrink,
noting that both shrinkstack's copystack call is made and that
syncadjustsudogs (the relevant function that's being indirectly tested)
are both called.

Fixes #44610.

Change-Id: Ib1c091e0d1475bf6c596f56dc9b85eaea366fc73
Reviewed-on: https://go-review.googlesource.com/c/go/+/313109
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
---
 src/runtime/chan_test.go | 18 ++----------------
 1 file changed, 2 insertions(+), 16 deletions(-)

diff --git a/src/runtime/chan_test.go b/src/runtime/chan_test.go
index 003d6a9fb3..c9ce3ac643 100644
--- a/src/runtime/chan_test.go
+++ b/src/runtime/chan_test.go
@@ -708,8 +708,6 @@ func TestSelectDuplicateChannel(t *testing.T) {
 	c <- 8 // wake up B.  This operation used to fail because c.recvq was corrupted (it tries to wake up an already running G instead of B)
 }
 
-var selectSink interface{}
-
 func TestSelectStackAdjust(t *testing.T) {
 	// Test that channel receive slots that contain local stack
 	// pointers are adjusted correctly by stack shrinking.
@@ -766,20 +764,8 @@ func TestSelectStackAdjust(t *testing.T) {
 	<-ready2
 	time.Sleep(10 * time.Millisecond)
 
-	// Force concurrent GC a few times.
-	var before, after runtime.MemStats
-	runtime.ReadMemStats(&before)
-	for i := 0; i < 100; i++ {
-		selectSink = new([1 << 20]byte)
-		runtime.ReadMemStats(&after)
-		if after.NumGC-before.NumGC >= 2 {
-			goto done
-		}
-		runtime.Gosched()
-	}
-	t.Fatal("failed to trigger concurrent GC")
-done:
-	selectSink = nil
+	// Force concurrent GC to shrink the stacks.
+	runtime.GC()
 
 	// Wake selects.
 	close(d)
-- 
GitLab


From 70deaa33ebd91944484526ab368fa19c499ff29f Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Wed, 21 Apr 2021 10:30:25 -0400
Subject: [PATCH 1758/2400] cmd/compile: extend GOSSAFUNC match to well-formed
 package suffix match.

e.g., LeadingZeros, bits.LeadingZeros, math/bits.LeadingZeros
but not its.LeadingZeros

Change-Id: Ib9a57e4db0af03c55bf5b5027aa6f8a5a84f2134
Reviewed-on: https://go-review.googlesource.com/c/go/+/312291
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssagen/ssa.go | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index c293e4db19..800d6a0b63 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -399,8 +399,10 @@ func okOffset(offset int64) int64 {
 func buildssa(fn *ir.Func, worker int) *ssa.Func {
 	name := ir.FuncName(fn)
 	printssa := false
-	if ssaDump != "" { // match either a simple name e.g. "(*Reader).Reset", or a package.name e.g. "compress/gzip.(*Reader).Reset"
-		printssa = name == ssaDump || base.Ctxt.Pkgpath+"."+name == ssaDump
+	if ssaDump != "" { // match either a simple name e.g. "(*Reader).Reset", package.name e.g. "compress/gzip.(*Reader).Reset", or subpackage name "gzip.(*Reader).Reset"
+		pkgDotName := base.Ctxt.Pkgpath+"."+name
+		printssa = name == ssaDump ||
+			strings.HasSuffix(pkgDotName, ssaDump) && (pkgDotName == ssaDump || strings.HasSuffix(pkgDotName, "/"+ssaDump))
 	}
 	var astBuf *bytes.Buffer
 	if printssa {
-- 
GitLab


From 00d42ffc895be17db72f195c1cf8f23be141a6fc Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Wed, 21 Apr 2021 16:21:30 -0400
Subject: [PATCH 1759/2400] cmd/compile: spos handling fixes to improve prolog
 debuggability

With the new register ABI, the compiler sometimes introduces spills of
argument registers in function prologs; depending on the positions
assigned to these spills and whether they have the IsStmt flag set,
this can degrade the debugging experience. For example, in this
function from one of the Delve regression tests:

L13:  func foo((eface interface{}) {
L14:	if eface != nil {
L15:		n++
L16:	}
L17   }

we wind up with a prolog containing two spill instructions, the first
with line 14, the second with line 13.  The end result for the user
is that if you set a breakpoint in foo and run to it, then do "step",
execution will initially stop at L14, then jump "backwards" to L13.

The root of the problem in this case is that an ArgIntReg pseudo-op is
introduced during expand calls, then promoted (due to lowering) to a
first-class statement (IsStmt flag set), which in turn causes
downstream handling to propagate its position to the first of the register
spills in the prolog.

To help improve things, this patch changes the rewriter to avoid
moving an "IsStmt" flag from a deleted/replaced instruction to an
Arg{Int,Float}Reg value, and adds Arg{Int,Float}Reg to the list of
opcodes not suitable for selection as statement boundaries, and
suppresses generation of additional register spills in defframe() when
optimization is disabled (since in that case things will get spilled
in any case).

This is not a comprehensive/complete fix; there are still cases where
we get less-than-ideal source position markers (ex: issue 45680).

Updates #40724.

Change-Id: Ica8bba4940b2291bef6b5d95ff0cfd84412a2d40
Reviewed-on: https://go-review.googlesource.com/c/go/+/312989
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/amd64/ssa.go       | 1 +
 src/cmd/compile/internal/ssa/numberlines.go | 5 +++--
 src/cmd/compile/internal/ssa/rewrite.go     | 2 +-
 src/cmd/compile/internal/ssagen/ssa.go      | 4 +++-
 4 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index 38d2d43e27..6a478de2a0 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -1370,5 +1370,6 @@ func spillArgReg(pp *objw.Progs, p *obj.Prog, f *ssa.Func, t *types.Type, reg in
 	p = pp.Append(p, storeByType(t), obj.TYPE_REG, reg, 0, obj.TYPE_MEM, 0, n.FrameOffset()+off)
 	p.To.Name = obj.NAME_PARAM
 	p.To.Sym = n.Linksym()
+	p.Pos = p.Pos.WithNotStmt()
 	return p
 }
diff --git a/src/cmd/compile/internal/ssa/numberlines.go b/src/cmd/compile/internal/ssa/numberlines.go
index 54a158ff87..9d6aeca9c0 100644
--- a/src/cmd/compile/internal/ssa/numberlines.go
+++ b/src/cmd/compile/internal/ssa/numberlines.go
@@ -16,7 +16,8 @@ func isPoorStatementOp(op Op) bool {
 	// so that a debugger-user sees the stop before the panic, and can examine the value.
 	case OpAddr, OpLocalAddr, OpOffPtr, OpStructSelect, OpPhi, OpITab, OpIData,
 		OpIMake, OpStringMake, OpSliceMake, OpStructMake0, OpStructMake1, OpStructMake2, OpStructMake3, OpStructMake4,
-		OpConstBool, OpConst8, OpConst16, OpConst32, OpConst64, OpConst32F, OpConst64F, OpSB, OpSP:
+		OpConstBool, OpConst8, OpConst16, OpConst32, OpConst64, OpConst32F, OpConst64F, OpSB, OpSP,
+		OpArgIntReg, OpArgFloatReg:
 		return true
 	}
 	return false
@@ -61,7 +62,7 @@ func nextGoodStatementIndex(v *Value, i int, b *Block) int {
 // statement boundary.
 func notStmtBoundary(op Op) bool {
 	switch op {
-	case OpCopy, OpPhi, OpVarKill, OpVarDef, OpVarLive, OpUnknown, OpFwdRef, OpArg:
+	case OpCopy, OpPhi, OpVarKill, OpVarDef, OpVarLive, OpUnknown, OpFwdRef, OpArg, OpArgIntReg, OpArgFloatReg:
 		return true
 	}
 	return false
diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go
index bdc4f799aa..375c4d5a56 100644
--- a/src/cmd/compile/internal/ssa/rewrite.go
+++ b/src/cmd/compile/internal/ssa/rewrite.go
@@ -159,7 +159,7 @@ func applyRewrite(f *Func, rb blockRewriter, rv valueRewriter, deadcode deadValu
 				f.freeValue(v)
 				continue
 			}
-			if v.Pos.IsStmt() != src.PosNotStmt && pendingLines.get(vl) == int32(b.ID) {
+			if v.Pos.IsStmt() != src.PosNotStmt && !notStmtBoundary(v.Op) && pendingLines.get(vl) == int32(b.ID) {
 				pendingLines.remove(vl)
 				v.Pos = v.Pos.WithIsStmt()
 			}
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 800d6a0b63..891047f56d 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -7071,8 +7071,10 @@ func defframe(s *State, e *ssafn, f *ssa.Func) {
 	// slot. This can only happen with aggregate-typed arguments that are SSA-able
 	// and not address-taken (for non-SSA-able or address-taken arguments we always
 	// spill upfront).
+	// Note: spilling is unnecessary in the -N/no-optimize case, since all values
+	// will be considered non-SSAable and spilled up front.
 	// TODO(register args) Make liveness more fine-grained to that partial spilling is okay.
-	if f.OwnAux.ABIInfo().InRegistersUsed() != 0 {
+	if f.OwnAux.ABIInfo().InRegistersUsed() != 0 && base.Flag.N == 0 {
 		// First, see if it is already spilled before it may be live. Look for a spill
 		// in the entry block up to the first safepoint.
 		type nameOff struct {
-- 
GitLab


From 1f7ddf57d2908319c0ca7dc621a206935d8726f2 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Fri, 23 Apr 2021 19:02:44 -0400
Subject: [PATCH 1760/2400] syscall, etc.: use abi.FuncPCABI0 for libc syscall
 wrappers

In CL 288092 we made Darwin syscall wrappers as ABIInternal, so
their addresses taken from Go using funcPC are the actual function
entries, not the wrappers.

As we introduced internal/abi.FuncPCABIxxx intrinsics, use that.
And change the assembly functions back to ABI0.

Do it on OpenBSD as well, as OpenBSD and Darwin share code
generator.

Change-Id: I408120795f7fc826637c867394248f8f373906bd
Reviewed-on: https://go-review.googlesource.com/c/go/+/313230
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/cmd/dist/build.go                         |   2 -
 src/cmd/internal/objabi/path.go               |   2 -
 .../x509/internal/macos/corefoundation.go     |  26 +-
 .../x509/internal/macos/corefoundation.s      |  18 +-
 src/crypto/x509/internal/macos/security.go    |   9 +-
 src/crypto/x509/internal/macos/security.s     |   8 +-
 src/syscall/exec_libc2.go                     |  47 +--
 src/syscall/mkasm.go                          |   3 +-
 src/syscall/mksyscall.pl                      |  15 +-
 src/syscall/syscall_darwin.go                 |  22 +-
 src/syscall/syscall_darwin_amd64.go           |   7 +-
 src/syscall/syscall_darwin_arm64.go           |   7 +-
 src/syscall/syscall_openbsd_libc.go           |  21 +-
 src/syscall/zsyscall_darwin_amd64.go          | 248 ++++++------
 src/syscall/zsyscall_darwin_amd64.s           | 250 ++++++-------
 src/syscall/zsyscall_darwin_arm64.go          | 248 ++++++------
 src/syscall/zsyscall_darwin_arm64.s           | 250 ++++++-------
 src/syscall/zsyscall_openbsd_amd64.go         | 352 ++++++------------
 src/syscall/zsyscall_openbsd_amd64.s          | 230 ++++++------
 src/syscall/zsyscall_openbsd_arm64.go         | 352 ++++++------------
 src/syscall/zsyscall_openbsd_arm64.s          | 230 ++++++------
 21 files changed, 1059 insertions(+), 1288 deletions(-)

diff --git a/src/cmd/dist/build.go b/src/cmd/dist/build.go
index 28c814d316..c81fe6a586 100644
--- a/src/cmd/dist/build.go
+++ b/src/cmd/dist/build.go
@@ -1776,8 +1776,6 @@ func IsRuntimePackagePath(pkgpath string) bool {
 		rval = true
 	case "syscall":
 		rval = true
-	case "crypto/x509/internal/macos": // libc function wrappers need to be ABIInternal
-		rval = true
 	case "internal/bytealg":
 		rval = true
 	default:
diff --git a/src/cmd/internal/objabi/path.go b/src/cmd/internal/objabi/path.go
index d49de141cc..aacab9a0ca 100644
--- a/src/cmd/internal/objabi/path.go
+++ b/src/cmd/internal/objabi/path.go
@@ -58,8 +58,6 @@ func IsRuntimePackagePath(pkgpath string) bool {
 		rval = true
 	case "syscall":
 		rval = true
-	case "crypto/x509/internal/macos": // libc function wrappers need to be ABIInternal
-		rval = true
 	case "internal/bytealg":
 		rval = true
 	default:
diff --git a/src/crypto/x509/internal/macos/corefoundation.go b/src/crypto/x509/internal/macos/corefoundation.go
index abcdcdd91e..fcfbc1e561 100644
--- a/src/crypto/x509/internal/macos/corefoundation.go
+++ b/src/crypto/x509/internal/macos/corefoundation.go
@@ -12,6 +12,7 @@ package macOS
 
 import (
 	"errors"
+	"internal/abi"
 	"reflect"
 	"runtime"
 	"unsafe"
@@ -45,7 +46,7 @@ const kCFStringEncodingUTF8 = 0x08000100
 // StringToCFString returns a copy of the UTF-8 contents of s as a new CFString.
 func StringToCFString(s string) CFString {
 	p := unsafe.Pointer((*reflect.StringHeader)(unsafe.Pointer(&s)).Data)
-	ret := syscall(funcPC(x509_CFStringCreateWithBytes_trampoline), kCFAllocatorDefault, uintptr(p),
+	ret := syscall(abi.FuncPCABI0(x509_CFStringCreateWithBytes_trampoline), kCFAllocatorDefault, uintptr(p),
 		uintptr(len(s)), uintptr(kCFStringEncodingUTF8), 0 /* isExternalRepresentation */, 0)
 	runtime.KeepAlive(p)
 	return CFString(ret)
@@ -55,7 +56,7 @@ func x509_CFStringCreateWithBytes_trampoline()
 //go:cgo_import_dynamic x509_CFDictionaryGetValueIfPresent CFDictionaryGetValueIfPresent "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 func CFDictionaryGetValueIfPresent(dict CFRef, key CFString) (value CFRef, ok bool) {
-	ret := syscall(funcPC(x509_CFDictionaryGetValueIfPresent_trampoline), uintptr(dict), uintptr(key),
+	ret := syscall(abi.FuncPCABI0(x509_CFDictionaryGetValueIfPresent_trampoline), uintptr(dict), uintptr(key),
 		uintptr(unsafe.Pointer(&value)), 0, 0, 0)
 	if ret == 0 {
 		return 0, false
@@ -70,7 +71,7 @@ const kCFNumberSInt32Type = 3
 
 func CFNumberGetValue(num CFRef) (int32, error) {
 	var value int32
-	ret := syscall(funcPC(x509_CFNumberGetValue_trampoline), uintptr(num), uintptr(kCFNumberSInt32Type),
+	ret := syscall(abi.FuncPCABI0(x509_CFNumberGetValue_trampoline), uintptr(num), uintptr(kCFNumberSInt32Type),
 		uintptr(unsafe.Pointer(&value)), 0, 0, 0)
 	if ret == 0 {
 		return 0, errors.New("CFNumberGetValue call failed")
@@ -82,7 +83,7 @@ func x509_CFNumberGetValue_trampoline()
 //go:cgo_import_dynamic x509_CFDataGetLength CFDataGetLength "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 func CFDataGetLength(data CFRef) int {
-	ret := syscall(funcPC(x509_CFDataGetLength_trampoline), uintptr(data), 0, 0, 0, 0, 0)
+	ret := syscall(abi.FuncPCABI0(x509_CFDataGetLength_trampoline), uintptr(data), 0, 0, 0, 0, 0)
 	return int(ret)
 }
 func x509_CFDataGetLength_trampoline()
@@ -90,7 +91,7 @@ func x509_CFDataGetLength_trampoline()
 //go:cgo_import_dynamic x509_CFDataGetBytePtr CFDataGetBytePtr "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 func CFDataGetBytePtr(data CFRef) uintptr {
-	ret := syscall(funcPC(x509_CFDataGetBytePtr_trampoline), uintptr(data), 0, 0, 0, 0, 0)
+	ret := syscall(abi.FuncPCABI0(x509_CFDataGetBytePtr_trampoline), uintptr(data), 0, 0, 0, 0, 0)
 	return ret
 }
 func x509_CFDataGetBytePtr_trampoline()
@@ -98,7 +99,7 @@ func x509_CFDataGetBytePtr_trampoline()
 //go:cgo_import_dynamic x509_CFArrayGetCount CFArrayGetCount "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 func CFArrayGetCount(array CFRef) int {
-	ret := syscall(funcPC(x509_CFArrayGetCount_trampoline), uintptr(array), 0, 0, 0, 0, 0)
+	ret := syscall(abi.FuncPCABI0(x509_CFArrayGetCount_trampoline), uintptr(array), 0, 0, 0, 0, 0)
 	return int(ret)
 }
 func x509_CFArrayGetCount_trampoline()
@@ -106,7 +107,7 @@ func x509_CFArrayGetCount_trampoline()
 //go:cgo_import_dynamic x509_CFArrayGetValueAtIndex CFArrayGetValueAtIndex "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 func CFArrayGetValueAtIndex(array CFRef, index int) CFRef {
-	ret := syscall(funcPC(x509_CFArrayGetValueAtIndex_trampoline), uintptr(array), uintptr(index), 0, 0, 0, 0)
+	ret := syscall(abi.FuncPCABI0(x509_CFArrayGetValueAtIndex_trampoline), uintptr(array), uintptr(index), 0, 0, 0, 0)
 	return CFRef(ret)
 }
 func x509_CFArrayGetValueAtIndex_trampoline()
@@ -114,7 +115,7 @@ func x509_CFArrayGetValueAtIndex_trampoline()
 //go:cgo_import_dynamic x509_CFEqual CFEqual "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 func CFEqual(a, b CFRef) bool {
-	ret := syscall(funcPC(x509_CFEqual_trampoline), uintptr(a), uintptr(b), 0, 0, 0, 0)
+	ret := syscall(abi.FuncPCABI0(x509_CFEqual_trampoline), uintptr(a), uintptr(b), 0, 0, 0, 0)
 	return ret == 1
 }
 func x509_CFEqual_trampoline()
@@ -122,16 +123,9 @@ func x509_CFEqual_trampoline()
 //go:cgo_import_dynamic x509_CFRelease CFRelease "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
 
 func CFRelease(ref CFRef) {
-	syscall(funcPC(x509_CFRelease_trampoline), uintptr(ref), 0, 0, 0, 0, 0)
+	syscall(abi.FuncPCABI0(x509_CFRelease_trampoline), uintptr(ref), 0, 0, 0, 0, 0)
 }
 func x509_CFRelease_trampoline()
 
 // syscall is implemented in the runtime package (runtime/sys_darwin.go)
 func syscall(fn, a1, a2, a3, a4, a5, a6 uintptr) uintptr
-
-// funcPC returns the entry point for f. See comments in runtime/proc.go
-// for the function of the same name.
-//go:nosplit
-func funcPC(f func()) uintptr {
-	return **(**uintptr)(unsafe.Pointer(&f))
-}
diff --git a/src/crypto/x509/internal/macos/corefoundation.s b/src/crypto/x509/internal/macos/corefoundation.s
index 1ce39fac9d..a9efaa299d 100644
--- a/src/crypto/x509/internal/macos/corefoundation.s
+++ b/src/crypto/x509/internal/macos/corefoundation.s
@@ -9,21 +9,21 @@
 // The trampolines are ABIInternal as they are address-taken in
 // Go code.
 
-TEXT ·x509_CFArrayGetCount_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·x509_CFArrayGetCount_trampoline(SB),NOSPLIT,$0-0
 	JMP	x509_CFArrayGetCount(SB)
-TEXT ·x509_CFArrayGetValueAtIndex_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·x509_CFArrayGetValueAtIndex_trampoline(SB),NOSPLIT,$0-0
 	JMP	x509_CFArrayGetValueAtIndex(SB)
-TEXT ·x509_CFDataGetBytePtr_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·x509_CFDataGetBytePtr_trampoline(SB),NOSPLIT,$0-0
 	JMP	x509_CFDataGetBytePtr(SB)
-TEXT ·x509_CFDataGetLength_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·x509_CFDataGetLength_trampoline(SB),NOSPLIT,$0-0
 	JMP	x509_CFDataGetLength(SB)
-TEXT ·x509_CFStringCreateWithBytes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·x509_CFStringCreateWithBytes_trampoline(SB),NOSPLIT,$0-0
 	JMP	x509_CFStringCreateWithBytes(SB)
-TEXT ·x509_CFRelease_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·x509_CFRelease_trampoline(SB),NOSPLIT,$0-0
 	JMP	x509_CFRelease(SB)
-TEXT ·x509_CFDictionaryGetValueIfPresent_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·x509_CFDictionaryGetValueIfPresent_trampoline(SB),NOSPLIT,$0-0
 	JMP	x509_CFDictionaryGetValueIfPresent(SB)
-TEXT ·x509_CFNumberGetValue_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·x509_CFNumberGetValue_trampoline(SB),NOSPLIT,$0-0
 	JMP	x509_CFNumberGetValue(SB)
-TEXT ·x509_CFEqual_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·x509_CFEqual_trampoline(SB),NOSPLIT,$0-0
 	JMP	x509_CFEqual(SB)
diff --git a/src/crypto/x509/internal/macos/security.go b/src/crypto/x509/internal/macos/security.go
index f346ff4c7f..0f6fa42b7b 100644
--- a/src/crypto/x509/internal/macos/security.go
+++ b/src/crypto/x509/internal/macos/security.go
@@ -9,6 +9,7 @@ package macOS
 
 import (
 	"errors"
+	"internal/abi"
 	"strconv"
 	"unsafe"
 )
@@ -67,7 +68,7 @@ const errSecNoTrustSettings = -25263
 //go:cgo_import_dynamic x509_SecTrustSettingsCopyCertificates SecTrustSettingsCopyCertificates "/System/Library/Frameworks/Security.framework/Versions/A/Security"
 
 func SecTrustSettingsCopyCertificates(domain SecTrustSettingsDomain) (certArray CFRef, err error) {
-	ret := syscall(funcPC(x509_SecTrustSettingsCopyCertificates_trampoline), uintptr(domain),
+	ret := syscall(abi.FuncPCABI0(x509_SecTrustSettingsCopyCertificates_trampoline), uintptr(domain),
 		uintptr(unsafe.Pointer(&certArray)), 0, 0, 0, 0)
 	if int32(ret) == errSecNoTrustSettings {
 		return 0, ErrNoTrustSettings
@@ -83,7 +84,7 @@ const kSecFormatX509Cert int32 = 9
 //go:cgo_import_dynamic x509_SecItemExport SecItemExport "/System/Library/Frameworks/Security.framework/Versions/A/Security"
 
 func SecItemExport(cert CFRef) (data CFRef, err error) {
-	ret := syscall(funcPC(x509_SecItemExport_trampoline), uintptr(cert), uintptr(kSecFormatX509Cert),
+	ret := syscall(abi.FuncPCABI0(x509_SecItemExport_trampoline), uintptr(cert), uintptr(kSecFormatX509Cert),
 		0 /* flags */, 0 /* keyParams */, uintptr(unsafe.Pointer(&data)), 0)
 	if ret != 0 {
 		return 0, OSStatus{"SecItemExport", int32(ret)}
@@ -97,7 +98,7 @@ const errSecItemNotFound = -25300
 //go:cgo_import_dynamic x509_SecTrustSettingsCopyTrustSettings SecTrustSettingsCopyTrustSettings "/System/Library/Frameworks/Security.framework/Versions/A/Security"
 
 func SecTrustSettingsCopyTrustSettings(cert CFRef, domain SecTrustSettingsDomain) (trustSettings CFRef, err error) {
-	ret := syscall(funcPC(x509_SecTrustSettingsCopyTrustSettings_trampoline), uintptr(cert), uintptr(domain),
+	ret := syscall(abi.FuncPCABI0(x509_SecTrustSettingsCopyTrustSettings_trampoline), uintptr(cert), uintptr(domain),
 		uintptr(unsafe.Pointer(&trustSettings)), 0, 0, 0)
 	if int32(ret) == errSecItemNotFound {
 		return 0, ErrNoTrustSettings
@@ -111,7 +112,7 @@ func x509_SecTrustSettingsCopyTrustSettings_trampoline()
 //go:cgo_import_dynamic x509_SecPolicyCopyProperties SecPolicyCopyProperties "/System/Library/Frameworks/Security.framework/Versions/A/Security"
 
 func SecPolicyCopyProperties(policy CFRef) CFRef {
-	ret := syscall(funcPC(x509_SecPolicyCopyProperties_trampoline), uintptr(policy), 0, 0, 0, 0, 0)
+	ret := syscall(abi.FuncPCABI0(x509_SecPolicyCopyProperties_trampoline), uintptr(policy), 0, 0, 0, 0, 0)
 	return CFRef(ret)
 }
 func x509_SecPolicyCopyProperties_trampoline()
diff --git a/src/crypto/x509/internal/macos/security.s b/src/crypto/x509/internal/macos/security.s
index bea265a5ef..09ce5c6c76 100644
--- a/src/crypto/x509/internal/macos/security.s
+++ b/src/crypto/x509/internal/macos/security.s
@@ -9,11 +9,11 @@
 // The trampolines are ABIInternal as they are address-taken in
 // Go code.
 
-TEXT ·x509_SecTrustSettingsCopyCertificates_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·x509_SecTrustSettingsCopyCertificates_trampoline(SB),NOSPLIT,$0-0
 	JMP	x509_SecTrustSettingsCopyCertificates(SB)
-TEXT ·x509_SecItemExport_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·x509_SecItemExport_trampoline(SB),NOSPLIT,$0-0
 	JMP	x509_SecItemExport(SB)
-TEXT ·x509_SecTrustSettingsCopyTrustSettings_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·x509_SecTrustSettingsCopyTrustSettings_trampoline(SB),NOSPLIT,$0-0
 	JMP	x509_SecTrustSettingsCopyTrustSettings(SB)
-TEXT ·x509_SecPolicyCopyProperties_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·x509_SecPolicyCopyProperties_trampoline(SB),NOSPLIT,$0-0
 	JMP	x509_SecPolicyCopyProperties(SB)
diff --git a/src/syscall/exec_libc2.go b/src/syscall/exec_libc2.go
index 507eff8ab3..37df790193 100644
--- a/src/syscall/exec_libc2.go
+++ b/src/syscall/exec_libc2.go
@@ -8,6 +8,7 @@
 package syscall
 
 import (
+	"internal/abi"
 	"unsafe"
 )
 
@@ -76,7 +77,7 @@ func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr
 	// About to call fork.
 	// No more allocation or calls of non-assembly functions.
 	runtime_BeforeFork()
-	r1, _, err1 = rawSyscall(funcPC(libc_fork_trampoline), 0, 0, 0)
+	r1, _, err1 = rawSyscall(abi.FuncPCABI0(libc_fork_trampoline), 0, 0, 0)
 	if err1 != 0 {
 		runtime_AfterFork()
 		return 0, err1
@@ -102,7 +103,7 @@ func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr
 
 	// Session ID
 	if sys.Setsid {
-		_, _, err1 = rawSyscall(funcPC(libc_setsid_trampoline), 0, 0, 0)
+		_, _, err1 = rawSyscall(abi.FuncPCABI0(libc_setsid_trampoline), 0, 0, 0)
 		if err1 != 0 {
 			goto childerror
 		}
@@ -111,7 +112,7 @@ func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr
 	// Set process group
 	if sys.Setpgid || sys.Foreground {
 		// Place child in process group.
-		_, _, err1 = rawSyscall(funcPC(libc_setpgid_trampoline), 0, uintptr(sys.Pgid), 0)
+		_, _, err1 = rawSyscall(abi.FuncPCABI0(libc_setpgid_trampoline), 0, uintptr(sys.Pgid), 0)
 		if err1 != 0 {
 			goto childerror
 		}
@@ -120,7 +121,7 @@ func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr
 	if sys.Foreground {
 		pgrp := sys.Pgid
 		if pgrp == 0 {
-			r1, _, err1 = rawSyscall(funcPC(libc_getpid_trampoline), 0, 0, 0)
+			r1, _, err1 = rawSyscall(abi.FuncPCABI0(libc_getpid_trampoline), 0, 0, 0)
 			if err1 != 0 {
 				goto childerror
 			}
@@ -129,7 +130,7 @@ func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr
 		}
 
 		// Place process group in foreground.
-		_, _, err1 = rawSyscall(funcPC(libc_ioctl_trampoline), uintptr(sys.Ctty), uintptr(TIOCSPGRP), uintptr(unsafe.Pointer(&pgrp)))
+		_, _, err1 = rawSyscall(abi.FuncPCABI0(libc_ioctl_trampoline), uintptr(sys.Ctty), uintptr(TIOCSPGRP), uintptr(unsafe.Pointer(&pgrp)))
 		if err1 != 0 {
 			goto childerror
 		}
@@ -137,7 +138,7 @@ func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr
 
 	// Chroot
 	if chroot != nil {
-		_, _, err1 = rawSyscall(funcPC(libc_chroot_trampoline), uintptr(unsafe.Pointer(chroot)), 0, 0)
+		_, _, err1 = rawSyscall(abi.FuncPCABI0(libc_chroot_trampoline), uintptr(unsafe.Pointer(chroot)), 0, 0)
 		if err1 != 0 {
 			goto childerror
 		}
@@ -151,16 +152,16 @@ func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr
 			groups = uintptr(unsafe.Pointer(&cred.Groups[0]))
 		}
 		if !cred.NoSetGroups {
-			_, _, err1 = rawSyscall(funcPC(libc_setgroups_trampoline), ngroups, groups, 0)
+			_, _, err1 = rawSyscall(abi.FuncPCABI0(libc_setgroups_trampoline), ngroups, groups, 0)
 			if err1 != 0 {
 				goto childerror
 			}
 		}
-		_, _, err1 = rawSyscall(funcPC(libc_setgid_trampoline), uintptr(cred.Gid), 0, 0)
+		_, _, err1 = rawSyscall(abi.FuncPCABI0(libc_setgid_trampoline), uintptr(cred.Gid), 0, 0)
 		if err1 != 0 {
 			goto childerror
 		}
-		_, _, err1 = rawSyscall(funcPC(libc_setuid_trampoline), uintptr(cred.Uid), 0, 0)
+		_, _, err1 = rawSyscall(abi.FuncPCABI0(libc_setuid_trampoline), uintptr(cred.Uid), 0, 0)
 		if err1 != 0 {
 			goto childerror
 		}
@@ -168,7 +169,7 @@ func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr
 
 	// Chdir
 	if dir != nil {
-		_, _, err1 = rawSyscall(funcPC(libc_chdir_trampoline), uintptr(unsafe.Pointer(dir)), 0, 0)
+		_, _, err1 = rawSyscall(abi.FuncPCABI0(libc_chdir_trampoline), uintptr(unsafe.Pointer(dir)), 0, 0)
 		if err1 != 0 {
 			goto childerror
 		}
@@ -177,11 +178,11 @@ func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr
 	// Pass 1: look for fd[i] < i and move those up above len(fd)
 	// so that pass 2 won't stomp on an fd it needs later.
 	if pipe < nextfd {
-		_, _, err1 = rawSyscall(funcPC(libc_dup2_trampoline), uintptr(pipe), uintptr(nextfd), 0)
+		_, _, err1 = rawSyscall(abi.FuncPCABI0(libc_dup2_trampoline), uintptr(pipe), uintptr(nextfd), 0)
 		if err1 != 0 {
 			goto childerror
 		}
-		rawSyscall(funcPC(libc_fcntl_trampoline), uintptr(nextfd), F_SETFD, FD_CLOEXEC)
+		rawSyscall(abi.FuncPCABI0(libc_fcntl_trampoline), uintptr(nextfd), F_SETFD, FD_CLOEXEC)
 		pipe = nextfd
 		nextfd++
 	}
@@ -190,11 +191,11 @@ func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr
 			if nextfd == pipe { // don't stomp on pipe
 				nextfd++
 			}
-			_, _, err1 = rawSyscall(funcPC(libc_dup2_trampoline), uintptr(fd[i]), uintptr(nextfd), 0)
+			_, _, err1 = rawSyscall(abi.FuncPCABI0(libc_dup2_trampoline), uintptr(fd[i]), uintptr(nextfd), 0)
 			if err1 != 0 {
 				goto childerror
 			}
-			rawSyscall(funcPC(libc_fcntl_trampoline), uintptr(nextfd), F_SETFD, FD_CLOEXEC)
+			rawSyscall(abi.FuncPCABI0(libc_fcntl_trampoline), uintptr(nextfd), F_SETFD, FD_CLOEXEC)
 			fd[i] = nextfd
 			nextfd++
 		}
@@ -203,13 +204,13 @@ func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr
 	// Pass 2: dup fd[i] down onto i.
 	for i = 0; i < len(fd); i++ {
 		if fd[i] == -1 {
-			rawSyscall(funcPC(libc_close_trampoline), uintptr(i), 0, 0)
+			rawSyscall(abi.FuncPCABI0(libc_close_trampoline), uintptr(i), 0, 0)
 			continue
 		}
 		if fd[i] == int(i) {
 			// dup2(i, i) won't clear close-on-exec flag on Linux,
 			// probably not elsewhere either.
-			_, _, err1 = rawSyscall(funcPC(libc_fcntl_trampoline), uintptr(fd[i]), F_SETFD, 0)
+			_, _, err1 = rawSyscall(abi.FuncPCABI0(libc_fcntl_trampoline), uintptr(fd[i]), F_SETFD, 0)
 			if err1 != 0 {
 				goto childerror
 			}
@@ -217,7 +218,7 @@ func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr
 		}
 		// The new fd is created NOT close-on-exec,
 		// which is exactly what we want.
-		_, _, err1 = rawSyscall(funcPC(libc_dup2_trampoline), uintptr(fd[i]), uintptr(i), 0)
+		_, _, err1 = rawSyscall(abi.FuncPCABI0(libc_dup2_trampoline), uintptr(fd[i]), uintptr(i), 0)
 		if err1 != 0 {
 			goto childerror
 		}
@@ -228,12 +229,12 @@ func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr
 	// Programs that know they inherit fds >= 3 will need
 	// to set them close-on-exec.
 	for i = len(fd); i < 3; i++ {
-		rawSyscall(funcPC(libc_close_trampoline), uintptr(i), 0, 0)
+		rawSyscall(abi.FuncPCABI0(libc_close_trampoline), uintptr(i), 0, 0)
 	}
 
 	// Detach fd 0 from tty
 	if sys.Noctty {
-		_, _, err1 = rawSyscall(funcPC(libc_ioctl_trampoline), 0, uintptr(TIOCNOTTY), 0)
+		_, _, err1 = rawSyscall(abi.FuncPCABI0(libc_ioctl_trampoline), 0, uintptr(TIOCNOTTY), 0)
 		if err1 != 0 {
 			goto childerror
 		}
@@ -241,22 +242,22 @@ func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr
 
 	// Set the controlling TTY to Ctty
 	if sys.Setctty {
-		_, _, err1 = rawSyscall(funcPC(libc_ioctl_trampoline), uintptr(sys.Ctty), uintptr(TIOCSCTTY), 0)
+		_, _, err1 = rawSyscall(abi.FuncPCABI0(libc_ioctl_trampoline), uintptr(sys.Ctty), uintptr(TIOCSCTTY), 0)
 		if err1 != 0 {
 			goto childerror
 		}
 	}
 
 	// Time to exec.
-	_, _, err1 = rawSyscall(funcPC(libc_execve_trampoline),
+	_, _, err1 = rawSyscall(abi.FuncPCABI0(libc_execve_trampoline),
 		uintptr(unsafe.Pointer(argv0)),
 		uintptr(unsafe.Pointer(&argv[0])),
 		uintptr(unsafe.Pointer(&envv[0])))
 
 childerror:
 	// send error code on pipe
-	rawSyscall(funcPC(libc_write_trampoline), uintptr(pipe), uintptr(unsafe.Pointer(&err1)), unsafe.Sizeof(err1))
+	rawSyscall(abi.FuncPCABI0(libc_write_trampoline), uintptr(pipe), uintptr(unsafe.Pointer(&err1)), unsafe.Sizeof(err1))
 	for {
-		rawSyscall(funcPC(libc_exit_trampoline), 253, 0, 0)
+		rawSyscall(abi.FuncPCABI0(libc_exit_trampoline), 253, 0, 0)
 	}
 }
diff --git a/src/syscall/mkasm.go b/src/syscall/mkasm.go
index 39461145e9..e0ec46681d 100644
--- a/src/syscall/mkasm.go
+++ b/src/syscall/mkasm.go
@@ -54,8 +54,7 @@ func main() {
 		fn := line[5 : len(line)-13]
 		if !trampolines[fn] {
 			trampolines[fn] = true
-			// The trampolines are ABIInternal as they are address-taken in Go code.
-			fmt.Fprintf(&out, "TEXT ·%s_trampoline<ABIInternal>(SB),NOSPLIT,$0-0\n", fn)
+			fmt.Fprintf(&out, "TEXT ·%s_trampoline(SB),NOSPLIT,$0-0\n", fn)
 			fmt.Fprintf(&out, "\tJMP\t%s(SB)\n", fn)
 		}
 	}
diff --git a/src/syscall/mksyscall.pl b/src/syscall/mksyscall.pl
index c1ed3a35d9..452ab6c96a 100755
--- a/src/syscall/mksyscall.pl
+++ b/src/syscall/mksyscall.pl
@@ -32,6 +32,8 @@ my $dragonfly = 0;
 my $arm = 0; # 64-bit value should use (even, odd)-pair
 my $libc = 0;
 my $tags = "";  # build tags
+my $newtags = ""; # new style build tags
+my $extraimports = "";
 
 if($ARGV[0] eq "-b32") {
 	$_32bit = "big-endian";
@@ -80,6 +82,10 @@ if($ARGV[0] =~ /^-/) {
 	exit 1;
 }
 
+if($libc) {
+	$extraimports = 'import "internal/abi"';
+}
+
 sub parseparamlist($) {
 	my ($list) = @_;
 	$list =~ s/^\s*//;
@@ -276,7 +282,7 @@ while(<>) {
 			$sysname = substr $sysname, 4;
 			$funcname = "libc_$sysname";
 		}
-		$sysname = "funcPC(${funcname}_trampoline)";
+		$sysname = "abi.FuncPCABI0(${funcname}_trampoline)";
 	}
 
 	# Actual call.
@@ -350,7 +356,7 @@ while(<>) {
 		if (not exists $trampolines{$funcname}) {
 			$trampolines{$funcname} = 1;
 			# The assembly trampoline that jumps to the libc routine.
-			$text .= "func ${funcname}_trampoline()\n";
+			$text .= "func ${funcname}_trampoline()\n\n";
 			# Tell the linker that funcname can be found in libSystem using varname without the libc_ prefix.
 			my $basename = substr $funcname, 5;
 			my $libc = "libc.so";
@@ -369,15 +375,20 @@ if($errors) {
 	exit 1;
 }
 
+# TODO: this assumes tags are just simply comma separated. For now this is all the uses.
+$newtags = $tags =~ s/,/ && /r;
+
 print <<EOF;
 // $cmdline
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build $newtags
 // +build $tags
 
 package syscall
 
 import "unsafe"
+$extraimports
 
 $text
 EOF
diff --git a/src/syscall/syscall_darwin.go b/src/syscall/syscall_darwin.go
index 162e94479f..a4fe4f1962 100644
--- a/src/syscall/syscall_darwin.go
+++ b/src/syscall/syscall_darwin.go
@@ -12,7 +12,10 @@
 
 package syscall
 
-import "unsafe"
+import (
+	"internal/abi"
+	"unsafe"
+)
 
 type SockaddrDatalink struct {
 	Len    uint8
@@ -105,7 +108,7 @@ func Getfsstat(buf []Statfs_t, flags int) (n int, err error) {
 		_p0 = unsafe.Pointer(&buf[0])
 		bufsize = unsafe.Sizeof(Statfs_t{}) * uintptr(len(buf))
 	}
-	r0, _, e1 := syscall(funcPC(libc_getfsstat_trampoline), uintptr(_p0), bufsize, uintptr(flags))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_getfsstat_trampoline), uintptr(_p0), bufsize, uintptr(flags))
 	n = int(r0)
 	if e1 != 0 {
 		err = e1
@@ -131,7 +134,7 @@ func setattrlistTimes(path string, times []Timespec) error {
 	attributes := [2]Timespec{times[1], times[0]}
 	const options = 0
 	_, _, e1 := syscall6(
-		funcPC(libc_setattrlist_trampoline),
+		abi.FuncPCABI0(libc_setattrlist_trampoline),
 		uintptr(unsafe.Pointer(_p0)),
 		uintptr(unsafe.Pointer(&attrList)),
 		uintptr(unsafe.Pointer(&attributes)),
@@ -264,7 +267,7 @@ func init() {
 }
 
 func fdopendir(fd int) (dir uintptr, err error) {
-	r0, _, e1 := syscallPtr(funcPC(libc_fdopendir_trampoline), uintptr(fd), 0, 0)
+	r0, _, e1 := syscallPtr(abi.FuncPCABI0(libc_fdopendir_trampoline), uintptr(fd), 0, 0)
 	dir = uintptr(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -277,7 +280,7 @@ func libc_fdopendir_trampoline()
 //go:cgo_import_dynamic libc_fdopendir fdopendir "/usr/lib/libSystem.B.dylib"
 
 func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -286,7 +289,7 @@ func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
 }
 
 func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -376,10 +379,3 @@ func syscall6X(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
 func rawSyscall(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
 func rawSyscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
 func syscallPtr(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
-
-// Find the entry point for f. See comments in runtime/proc.go for the
-// function of the same name.
-//go:nosplit
-func funcPC(f func()) uintptr {
-	return **(**uintptr)(unsafe.Pointer(&f))
-}
diff --git a/src/syscall/syscall_darwin_amd64.go b/src/syscall/syscall_darwin_amd64.go
index 687efff770..ef3c1998aa 100644
--- a/src/syscall/syscall_darwin_amd64.go
+++ b/src/syscall/syscall_darwin_amd64.go
@@ -4,7 +4,10 @@
 
 package syscall
 
-import "unsafe"
+import (
+	"internal/abi"
+	"unsafe"
+)
 
 func setTimespec(sec, nsec int64) Timespec {
 	return Timespec{Sec: sec, Nsec: nsec}
@@ -44,7 +47,7 @@ func (cmsg *Cmsghdr) SetLen(length int) {
 func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
 	var length = uint64(count)
 
-	_, _, e1 := syscall6(funcPC(libc_sendfile_trampoline), uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(unsafe.Pointer(&length)), 0, 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_sendfile_trampoline), uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(unsafe.Pointer(&length)), 0, 0)
 
 	written = int(length)
 
diff --git a/src/syscall/syscall_darwin_arm64.go b/src/syscall/syscall_darwin_arm64.go
index ab57117475..cea42772bb 100644
--- a/src/syscall/syscall_darwin_arm64.go
+++ b/src/syscall/syscall_darwin_arm64.go
@@ -4,7 +4,10 @@
 
 package syscall
 
-import "unsafe"
+import (
+	"internal/abi"
+	"unsafe"
+)
 
 func setTimespec(sec, nsec int64) Timespec {
 	return Timespec{Sec: sec, Nsec: nsec}
@@ -44,7 +47,7 @@ func (cmsg *Cmsghdr) SetLen(length int) {
 func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
 	var length = uint64(count)
 
-	_, _, e1 := syscall6(funcPC(libc_sendfile_trampoline), uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(unsafe.Pointer(&length)), 0, 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_sendfile_trampoline), uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(unsafe.Pointer(&length)), 0, 0)
 
 	written = int(length)
 
diff --git a/src/syscall/syscall_openbsd_libc.go b/src/syscall/syscall_openbsd_libc.go
index 610c66fd34..b967b4e3ac 100644
--- a/src/syscall/syscall_openbsd_libc.go
+++ b/src/syscall/syscall_openbsd_libc.go
@@ -7,7 +7,9 @@
 
 package syscall
 
-import "unsafe"
+import (
+	"internal/abi"
+)
 
 func init() {
 	execveOpenBSD = execve
@@ -16,23 +18,23 @@ func init() {
 //sys directSyscall(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr) (ret uintptr, err error) = SYS_syscall
 
 func syscallInternal(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) {
-	return syscall6X(funcPC(libc_syscall_trampoline), trap, a1, a2, a3, 0, 0)
+	return syscall6X(abi.FuncPCABI0(libc_syscall_trampoline), trap, a1, a2, a3, 0, 0)
 }
 
 func syscall6Internal(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) {
-	return syscall10X(funcPC(libc_syscall_trampoline), trap, a1, a2, a3, a4, a5, a6, 0, 0, 0)
+	return syscall10X(abi.FuncPCABI0(libc_syscall_trampoline), trap, a1, a2, a3, a4, a5, a6, 0, 0, 0)
 }
 
 func rawSyscallInternal(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) {
-	return rawSyscall6X(funcPC(libc_syscall_trampoline), trap, a1, a2, a3, 0, 0)
+	return rawSyscall6X(abi.FuncPCABI0(libc_syscall_trampoline), trap, a1, a2, a3, 0, 0)
 }
 
 func rawSyscall6Internal(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) {
-	return rawSyscall10X(funcPC(libc_syscall_trampoline), trap, a1, a2, a3, a4, a5, a6, 0, 0, 0)
+	return rawSyscall10X(abi.FuncPCABI0(libc_syscall_trampoline), trap, a1, a2, a3, a4, a5, a6, 0, 0, 0)
 }
 
 func syscall9Internal(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno) {
-	return rawSyscall10X(funcPC(libc_syscall_trampoline), trap, a1, a2, a3, a4, a5, a6, a7, a8, a9)
+	return rawSyscall10X(abi.FuncPCABI0(libc_syscall_trampoline), trap, a1, a2, a3, a4, a5, a6, a7, a8, a9)
 }
 
 // Implemented in the runtime package (runtime/sys_openbsd3.go)
@@ -54,13 +56,6 @@ func syscall9X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr,
 	return syscall10X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, 0)
 }
 
-// Find the entry point for f. See comments in runtime/proc.go for the
-// function of the same name.
-//go:nosplit
-func funcPC(f func()) uintptr {
-	return **(**uintptr)(unsafe.Pointer(&f))
-}
-
 //sys	readlen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_read
 //sys	writelen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_write
 //sys	Seek(fd int, offset int64, whence int) (newoffset int64, err error) = SYS_lseek
diff --git a/src/syscall/zsyscall_darwin_amd64.go b/src/syscall/zsyscall_darwin_amd64.go
index 13dfacdba2..369f5a1702 100644
--- a/src/syscall/zsyscall_darwin_amd64.go
+++ b/src/syscall/zsyscall_darwin_amd64.go
@@ -7,11 +7,12 @@
 package syscall
 
 import "unsafe"
+import "internal/abi"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
-	r0, _, e1 := rawSyscall(funcPC(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -26,7 +27,7 @@ func libc_getgroups_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func setgroups(ngid int, gid *_Gid_t) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -40,7 +41,7 @@ func libc_setgroups_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) {
-	r0, _, e1 := syscall6(funcPC(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
 	wpid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -55,7 +56,7 @@ func libc_wait4_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -70,7 +71,7 @@ func libc_accept_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
-	_, _, e1 := syscall(funcPC(libc_bind_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_bind_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -84,7 +85,7 @@ func libc_bind_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
-	_, _, e1 := syscall(funcPC(libc_connect_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_connect_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -98,7 +99,7 @@ func libc_connect_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func socket(domain int, typ int, proto int) (fd int, err error) {
-	r0, _, e1 := rawSyscall(funcPC(libc_socket_trampoline), uintptr(domain), uintptr(typ), uintptr(proto))
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_socket_trampoline), uintptr(domain), uintptr(typ), uintptr(proto))
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -113,7 +114,7 @@ func libc_socket_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
-	_, _, e1 := syscall6(funcPC(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -127,7 +128,7 @@ func libc_getsockopt_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
-	_, _, e1 := syscall6(funcPC(libc_setsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_setsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -141,7 +142,7 @@ func libc_setsockopt_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -155,7 +156,7 @@ func libc_getpeername_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -169,7 +170,7 @@ func libc_getsockname_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Shutdown(s int, how int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_shutdown_trampoline), uintptr(s), uintptr(how), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_shutdown_trampoline), uintptr(s), uintptr(how), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -183,7 +184,7 @@ func libc_shutdown_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
-	_, _, e1 := rawSyscall6(funcPC(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
+	_, _, e1 := rawSyscall6(abi.FuncPCABI0(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -203,7 +204,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall6(funcPC(libc_recvfrom_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_recvfrom_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -224,7 +225,7 @@ func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall6(funcPC(libc_sendto_trampoline), uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_sendto_trampoline), uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -238,7 +239,7 @@ func libc_sendto_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -253,7 +254,7 @@ func libc_recvmsg_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -268,7 +269,7 @@ func libc_sendmsg_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
-	r0, _, e1 := syscall6(funcPC(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -288,7 +289,7 @@ func utimes(path string, timeval *[2]Timeval) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -302,7 +303,7 @@ func libc_utimes_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func futimes(fd int, timeval *[2]Timeval) (err error) {
-	_, _, e1 := syscall(funcPC(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -316,7 +317,7 @@ func libc_futimes_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func fcntl(fd int, cmd int, arg int) (val int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -331,7 +332,7 @@ func libc_fcntl_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func pipe(p *[2]int32) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_pipe_trampoline), uintptr(unsafe.Pointer(p)), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_pipe_trampoline), uintptr(unsafe.Pointer(p)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -345,7 +346,7 @@ func libc_pipe_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func kill(pid int, signum int, posix int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_kill_trampoline), uintptr(pid), uintptr(signum), uintptr(posix))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_kill_trampoline), uintptr(pid), uintptr(signum), uintptr(posix))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -364,7 +365,7 @@ func Access(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -378,7 +379,7 @@ func libc_access_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Adjtime(delta *Timeval, olddelta *Timeval) (err error) {
-	_, _, e1 := syscall(funcPC(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -397,7 +398,7 @@ func Chdir(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -416,7 +417,7 @@ func Chflags(path string, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -435,7 +436,7 @@ func Chmod(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -454,7 +455,7 @@ func Chown(path string, uid int, gid int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -473,7 +474,7 @@ func Chroot(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -487,7 +488,7 @@ func libc_chroot_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Close(fd int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_close_trampoline), uintptr(fd), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_close_trampoline), uintptr(fd), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -501,7 +502,7 @@ func libc_close_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func closedir(dir uintptr) (err error) {
-	_, _, e1 := syscall(funcPC(libc_closedir_trampoline), uintptr(dir), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_closedir_trampoline), uintptr(dir), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -515,7 +516,7 @@ func libc_closedir_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Dup(fd int) (nfd int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_dup_trampoline), uintptr(fd), 0, 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_dup_trampoline), uintptr(fd), 0, 0)
 	nfd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -530,7 +531,7 @@ func libc_dup_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Dup2(from int, to int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_dup2_trampoline), uintptr(from), uintptr(to), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_dup2_trampoline), uintptr(from), uintptr(to), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -554,7 +555,7 @@ func Exchangedata(path1 string, path2 string, options int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_exchangedata_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_exchangedata_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -568,7 +569,7 @@ func libc_exchangedata_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchdir(fd int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fchdir_trampoline), uintptr(fd), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fchdir_trampoline), uintptr(fd), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -582,7 +583,7 @@ func libc_fchdir_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchflags(fd int, flags int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fchflags_trampoline), uintptr(fd), uintptr(flags), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fchflags_trampoline), uintptr(fd), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -596,7 +597,7 @@ func libc_fchflags_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchmod(fd int, mode uint32) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fchmod_trampoline), uintptr(fd), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fchmod_trampoline), uintptr(fd), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -610,7 +611,7 @@ func libc_fchmod_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchown(fd int, uid int, gid int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fchown_trampoline), uintptr(fd), uintptr(uid), uintptr(gid))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fchown_trampoline), uintptr(fd), uintptr(uid), uintptr(gid))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -624,7 +625,7 @@ func libc_fchown_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Flock(fd int, how int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_flock_trampoline), uintptr(fd), uintptr(how), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_flock_trampoline), uintptr(fd), uintptr(how), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -638,7 +639,7 @@ func libc_flock_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fpathconf(fd int, name int) (val int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_fpathconf_trampoline), uintptr(fd), uintptr(name), 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_fpathconf_trampoline), uintptr(fd), uintptr(name), 0)
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -653,7 +654,7 @@ func libc_fpathconf_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fsync(fd int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fsync_trampoline), uintptr(fd), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fsync_trampoline), uintptr(fd), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -667,7 +668,7 @@ func libc_fsync_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Ftruncate(fd int, length int64) (err error) {
-	_, _, e1 := syscall(funcPC(libc_ftruncate_trampoline), uintptr(fd), uintptr(length), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_ftruncate_trampoline), uintptr(fd), uintptr(length), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -681,7 +682,7 @@ func libc_ftruncate_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getdtablesize() (size int) {
-	r0, _, _ := syscall(funcPC(libc_getdtablesize_trampoline), 0, 0, 0)
+	r0, _, _ := syscall(abi.FuncPCABI0(libc_getdtablesize_trampoline), 0, 0, 0)
 	size = int(r0)
 	return
 }
@@ -693,7 +694,7 @@ func libc_getdtablesize_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getegid() (egid int) {
-	r0, _, _ := rawSyscall(funcPC(libc_getegid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getegid_trampoline), 0, 0, 0)
 	egid = int(r0)
 	return
 }
@@ -705,7 +706,7 @@ func libc_getegid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Geteuid() (uid int) {
-	r0, _, _ := rawSyscall(funcPC(libc_geteuid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_geteuid_trampoline), 0, 0, 0)
 	uid = int(r0)
 	return
 }
@@ -717,7 +718,7 @@ func libc_geteuid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getgid() (gid int) {
-	r0, _, _ := rawSyscall(funcPC(libc_getgid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getgid_trampoline), 0, 0, 0)
 	gid = int(r0)
 	return
 }
@@ -729,7 +730,7 @@ func libc_getgid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpgid(pid int) (pgid int, err error) {
-	r0, _, e1 := rawSyscall(funcPC(libc_getpgid_trampoline), uintptr(pid), 0, 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getpgid_trampoline), uintptr(pid), 0, 0)
 	pgid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -744,7 +745,7 @@ func libc_getpgid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpgrp() (pgrp int) {
-	r0, _, _ := rawSyscall(funcPC(libc_getpgrp_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getpgrp_trampoline), 0, 0, 0)
 	pgrp = int(r0)
 	return
 }
@@ -756,7 +757,7 @@ func libc_getpgrp_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpid() (pid int) {
-	r0, _, _ := rawSyscall(funcPC(libc_getpid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getpid_trampoline), 0, 0, 0)
 	pid = int(r0)
 	return
 }
@@ -768,7 +769,7 @@ func libc_getpid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getppid() (ppid int) {
-	r0, _, _ := rawSyscall(funcPC(libc_getppid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getppid_trampoline), 0, 0, 0)
 	ppid = int(r0)
 	return
 }
@@ -780,7 +781,7 @@ func libc_getppid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpriority(which int, who int) (prio int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_getpriority_trampoline), uintptr(which), uintptr(who), 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_getpriority_trampoline), uintptr(which), uintptr(who), 0)
 	prio = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -795,7 +796,7 @@ func libc_getpriority_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getrlimit(which int, lim *Rlimit) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -809,7 +810,7 @@ func libc_getrlimit_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getrusage(who int, rusage *Rusage) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -823,7 +824,7 @@ func libc_getrusage_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getsid(pid int) (sid int, err error) {
-	r0, _, e1 := rawSyscall(funcPC(libc_getsid_trampoline), uintptr(pid), 0, 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getsid_trampoline), uintptr(pid), 0, 0)
 	sid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -838,7 +839,7 @@ func libc_getsid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getuid() (uid int) {
-	r0, _, _ := rawSyscall(funcPC(libc_getuid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getuid_trampoline), 0, 0, 0)
 	uid = int(r0)
 	return
 }
@@ -850,7 +851,7 @@ func libc_getuid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Issetugid() (tainted bool) {
-	r0, _, _ := rawSyscall(funcPC(libc_issetugid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_issetugid_trampoline), 0, 0, 0)
 	tainted = bool(r0 != 0)
 	return
 }
@@ -862,7 +863,7 @@ func libc_issetugid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Kqueue() (fd int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_kqueue_trampoline), 0, 0, 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_kqueue_trampoline), 0, 0, 0)
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -882,7 +883,7 @@ func Lchown(path string, uid int, gid int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -906,7 +907,7 @@ func Link(path string, link string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -920,7 +921,7 @@ func libc_link_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Listen(s int, backlog int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_listen_trampoline), uintptr(s), uintptr(backlog), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_listen_trampoline), uintptr(s), uintptr(backlog), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -939,7 +940,7 @@ func Mkdir(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -958,7 +959,7 @@ func Mkfifo(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -977,7 +978,7 @@ func Mknod(path string, mode uint32, dev int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -997,7 +998,7 @@ func Mlock(b []byte) (err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall(funcPC(libc_mlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_mlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1011,7 +1012,7 @@ func libc_mlock_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Mlockall(flags int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_mlockall_trampoline), uintptr(flags), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_mlockall_trampoline), uintptr(flags), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1031,7 +1032,7 @@ func Mprotect(b []byte, prot int) (err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall(funcPC(libc_mprotect_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(prot))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_mprotect_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(prot))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1051,7 +1052,7 @@ func Munlock(b []byte) (err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall(funcPC(libc_munlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_munlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1065,7 +1066,7 @@ func libc_munlock_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Munlockall() (err error) {
-	_, _, e1 := syscall(funcPC(libc_munlockall_trampoline), 0, 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_munlockall_trampoline), 0, 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1084,7 +1085,7 @@ func Open(path string, mode int, perm uint32) (fd int, err error) {
 	if err != nil {
 		return
 	}
-	r0, _, e1 := syscall(funcPC(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1104,7 +1105,7 @@ func Pathconf(path string, name int) (val int, err error) {
 	if err != nil {
 		return
 	}
-	r0, _, e1 := syscall(funcPC(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1125,7 +1126,7 @@ func Pread(fd int, p []byte, offset int64) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall6(funcPC(libc_pread_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_pread_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1146,7 +1147,7 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall6(funcPC(libc_pwrite_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_pwrite_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1167,7 +1168,7 @@ func read(fd int, p []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_read_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1182,7 +1183,7 @@ func libc_read_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func readdir_r(dir uintptr, entry *Dirent, result **Dirent) (res Errno) {
-	r0, _, _ := syscall(funcPC(libc_readdir_r_trampoline), uintptr(dir), uintptr(unsafe.Pointer(entry)), uintptr(unsafe.Pointer(result)))
+	r0, _, _ := syscall(abi.FuncPCABI0(libc_readdir_r_trampoline), uintptr(dir), uintptr(unsafe.Pointer(entry)), uintptr(unsafe.Pointer(result)))
 	res = Errno(r0)
 	return
 }
@@ -1205,7 +1206,7 @@ func Readlink(path string, buf []byte) (n int, err error) {
 	} else {
 		_p1 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall(funcPC(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1230,7 +1231,7 @@ func Rename(from string, to string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1249,7 +1250,7 @@ func Revoke(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1268,7 +1269,7 @@ func Rmdir(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1282,7 +1283,7 @@ func libc_rmdir_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
-	r0, _, e1 := syscallX(funcPC(libc_lseek_trampoline), uintptr(fd), uintptr(offset), uintptr(whence))
+	r0, _, e1 := syscallX(abi.FuncPCABI0(libc_lseek_trampoline), uintptr(fd), uintptr(offset), uintptr(whence))
 	newoffset = int64(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1297,7 +1298,7 @@ func libc_lseek_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (err error) {
-	_, _, e1 := syscall6(funcPC(libc_select_trampoline), uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_select_trampoline), uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1311,7 +1312,7 @@ func libc_select_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setegid(egid int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_setegid_trampoline), uintptr(egid), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_setegid_trampoline), uintptr(egid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1325,7 +1326,7 @@ func libc_setegid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Seteuid(euid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_seteuid_trampoline), uintptr(euid), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_seteuid_trampoline), uintptr(euid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1339,7 +1340,7 @@ func libc_seteuid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setgid(gid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setgid_trampoline), uintptr(gid), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setgid_trampoline), uintptr(gid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1358,7 +1359,7 @@ func Setlogin(name string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1372,7 +1373,7 @@ func libc_setlogin_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setpgid(pid int, pgid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setpgid_trampoline), uintptr(pid), uintptr(pgid), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setpgid_trampoline), uintptr(pid), uintptr(pgid), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1386,7 +1387,7 @@ func libc_setpgid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setpriority(which int, who int, prio int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_setpriority_trampoline), uintptr(which), uintptr(who), uintptr(prio))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_setpriority_trampoline), uintptr(which), uintptr(who), uintptr(prio))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1400,7 +1401,7 @@ func libc_setpriority_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setprivexec(flag int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_setprivexec_trampoline), uintptr(flag), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_setprivexec_trampoline), uintptr(flag), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1414,7 +1415,7 @@ func libc_setprivexec_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setregid(rgid int, egid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setregid_trampoline), uintptr(rgid), uintptr(egid), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setregid_trampoline), uintptr(rgid), uintptr(egid), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1428,7 +1429,7 @@ func libc_setregid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setreuid(ruid int, euid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setreuid_trampoline), uintptr(ruid), uintptr(euid), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setreuid_trampoline), uintptr(ruid), uintptr(euid), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1442,7 +1443,7 @@ func libc_setreuid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setrlimit(which int, lim *Rlimit) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1456,7 +1457,7 @@ func libc_setrlimit_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setsid() (pid int, err error) {
-	r0, _, e1 := rawSyscall(funcPC(libc_setsid_trampoline), 0, 0, 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setsid_trampoline), 0, 0, 0)
 	pid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1471,7 +1472,7 @@ func libc_setsid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Settimeofday(tp *Timeval) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1485,7 +1486,7 @@ func libc_settimeofday_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setuid(uid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setuid_trampoline), uintptr(uid), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setuid_trampoline), uintptr(uid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1509,7 +1510,7 @@ func Symlink(path string, link string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1523,7 +1524,7 @@ func libc_symlink_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Sync() (err error) {
-	_, _, e1 := syscall(funcPC(libc_sync_trampoline), 0, 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_sync_trampoline), 0, 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1542,7 +1543,7 @@ func Truncate(path string, length int64) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1556,7 +1557,7 @@ func libc_truncate_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Umask(newmask int) (oldmask int) {
-	r0, _, _ := syscall(funcPC(libc_umask_trampoline), uintptr(newmask), 0, 0)
+	r0, _, _ := syscall(abi.FuncPCABI0(libc_umask_trampoline), uintptr(newmask), 0, 0)
 	oldmask = int(r0)
 	return
 }
@@ -1573,7 +1574,7 @@ func Undelete(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_undelete_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_undelete_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1592,7 +1593,7 @@ func Unlink(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1611,7 +1612,7 @@ func Unmount(path string, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1631,7 +1632,7 @@ func write(fd int, p []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_write_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1652,7 +1653,7 @@ func writev(fd int, iovecs []Iovec) (cnt uintptr, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscallX(funcPC(libc_writev_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(iovecs)))
+	r0, _, e1 := syscallX(abi.FuncPCABI0(libc_writev_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(iovecs)))
 	cnt = uintptr(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1667,7 +1668,7 @@ func libc_writev_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
-	r0, _, e1 := syscall6X(funcPC(libc_mmap_trampoline), uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
+	r0, _, e1 := syscall6X(abi.FuncPCABI0(libc_mmap_trampoline), uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
 	ret = uintptr(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1682,7 +1683,7 @@ func libc_mmap_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func munmap(addr uintptr, length uintptr) (err error) {
-	_, _, e1 := syscall(funcPC(libc_munmap_trampoline), uintptr(addr), uintptr(length), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_munmap_trampoline), uintptr(addr), uintptr(length), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1696,7 +1697,7 @@ func libc_munmap_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func fork() (pid int, err error) {
-	r0, _, e1 := rawSyscall(funcPC(libc_fork_trampoline), 0, 0, 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_fork_trampoline), 0, 0, 0)
 	pid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1711,7 +1712,7 @@ func libc_fork_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func ioctl(fd int, req int, arg int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1725,7 +1726,7 @@ func libc_ioctl_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1735,7 +1736,7 @@ func ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) {
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func execve(path *byte, argv **byte, envp **byte) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_execve_trampoline), uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(argv)), uintptr(unsafe.Pointer(envp)))
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_execve_trampoline), uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(argv)), uintptr(unsafe.Pointer(envp)))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1749,7 +1750,7 @@ func libc_execve_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func exit(res int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_exit_trampoline), uintptr(res), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_exit_trampoline), uintptr(res), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1769,7 +1770,7 @@ func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr)
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall6(funcPC(libc_sysctl_trampoline), uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_sysctl_trampoline), uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1783,7 +1784,7 @@ func libc_sysctl_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func fcntlPtr(fd int, cmd int, arg unsafe.Pointer) (val int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1799,7 +1800,7 @@ func unlinkat(fd int, path string, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_unlinkat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_unlinkat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1818,7 +1819,7 @@ func openat(fd int, path string, flags int, perm uint32) (fdret int, err error)
 	if err != nil {
 		return
 	}
-	r0, _, e1 := syscall6(funcPC(libc_openat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(perm), 0, 0)
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_openat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(perm), 0, 0)
 	fdret = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1839,7 +1840,7 @@ func getcwd(buf []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall(funcPC(libc_getcwd_trampoline), uintptr(_p0), uintptr(len(buf)), 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_getcwd_trampoline), uintptr(_p0), uintptr(len(buf)), 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1854,7 +1855,7 @@ func libc_getcwd_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fstat(fd int, stat *Stat_t) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fstat64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fstat64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1868,7 +1869,7 @@ func libc_fstat64_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fstatfs(fd int, stat *Statfs_t) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fstatfs64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fstatfs64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1882,7 +1883,7 @@ func libc_fstatfs64_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Gettimeofday(tp *Timeval) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1901,7 +1902,7 @@ func Lstat(path string, stat *Stat_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_lstat64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_lstat64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1920,7 +1921,7 @@ func Stat(path string, stat *Stat_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_stat64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_stat64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1939,7 +1940,7 @@ func Statfs(path string, stat *Statfs_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_statfs64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_statfs64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1958,7 +1959,7 @@ func fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall6(funcPC(libc_fstatat64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_fstatat64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1971,9 +1972,8 @@ func libc_fstatat64_trampoline()
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-//go:nosplit
 func ptrace1(request int, pid int, addr uintptr, data uintptr) (err error) {
-	_, _, e1 := syscall6(funcPC(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
diff --git a/src/syscall/zsyscall_darwin_amd64.s b/src/syscall/zsyscall_darwin_amd64.s
index 5eb48cee44..492f947855 100644
--- a/src/syscall/zsyscall_darwin_amd64.s
+++ b/src/syscall/zsyscall_darwin_amd64.s
@@ -1,253 +1,253 @@
 // go run mkasm.go darwin amd64
 // Code generated by the command above; DO NOT EDIT.
 #include "textflag.h"
-TEXT ·libc_getfsstat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getfsstat_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getfsstat(SB)
-TEXT ·libc_setattrlist_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setattrlist_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setattrlist(SB)
-TEXT ·libc_fdopendir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fdopendir_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fdopendir(SB)
-TEXT ·libc_sendfile_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_sendfile_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_sendfile(SB)
-TEXT ·libc_getgroups_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getgroups_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getgroups(SB)
-TEXT ·libc_setgroups_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setgroups_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setgroups(SB)
-TEXT ·libc_wait4_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_wait4_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_wait4(SB)
-TEXT ·libc_accept_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_accept_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_accept(SB)
-TEXT ·libc_bind_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_bind_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_bind(SB)
-TEXT ·libc_connect_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_connect_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_connect(SB)
-TEXT ·libc_socket_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_socket_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_socket(SB)
-TEXT ·libc_getsockopt_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getsockopt_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getsockopt(SB)
-TEXT ·libc_setsockopt_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setsockopt_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setsockopt(SB)
-TEXT ·libc_getpeername_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getpeername_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getpeername(SB)
-TEXT ·libc_getsockname_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getsockname_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getsockname(SB)
-TEXT ·libc_shutdown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_shutdown_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_shutdown(SB)
-TEXT ·libc_socketpair_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_socketpair_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_socketpair(SB)
-TEXT ·libc_recvfrom_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_recvfrom_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_recvfrom(SB)
-TEXT ·libc_sendto_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_sendto_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_sendto(SB)
-TEXT ·libc_recvmsg_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_recvmsg_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_recvmsg(SB)
-TEXT ·libc_sendmsg_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_sendmsg_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_sendmsg(SB)
-TEXT ·libc_kevent_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_kevent_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_kevent(SB)
-TEXT ·libc_utimes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_utimes_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_utimes(SB)
-TEXT ·libc_futimes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_futimes_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_futimes(SB)
-TEXT ·libc_fcntl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fcntl_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fcntl(SB)
-TEXT ·libc_pipe_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_pipe_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_pipe(SB)
-TEXT ·libc_kill_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_kill_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_kill(SB)
-TEXT ·libc_access_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_access_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_access(SB)
-TEXT ·libc_adjtime_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_adjtime_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_adjtime(SB)
-TEXT ·libc_chdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_chdir_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_chdir(SB)
-TEXT ·libc_chflags_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_chflags_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_chflags(SB)
-TEXT ·libc_chmod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_chmod_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_chmod(SB)
-TEXT ·libc_chown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_chown_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_chown(SB)
-TEXT ·libc_chroot_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_chroot_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_chroot(SB)
-TEXT ·libc_close_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_close_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_close(SB)
-TEXT ·libc_closedir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_closedir_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_closedir(SB)
-TEXT ·libc_dup_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_dup_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_dup(SB)
-TEXT ·libc_dup2_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_dup2_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_dup2(SB)
-TEXT ·libc_exchangedata_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_exchangedata_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_exchangedata(SB)
-TEXT ·libc_fchdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fchdir_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fchdir(SB)
-TEXT ·libc_fchflags_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fchflags_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fchflags(SB)
-TEXT ·libc_fchmod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fchmod_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fchmod(SB)
-TEXT ·libc_fchown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fchown_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fchown(SB)
-TEXT ·libc_flock_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_flock_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_flock(SB)
-TEXT ·libc_fpathconf_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fpathconf_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fpathconf(SB)
-TEXT ·libc_fsync_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fsync_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fsync(SB)
-TEXT ·libc_ftruncate_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_ftruncate_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_ftruncate(SB)
-TEXT ·libc_getdtablesize_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getdtablesize_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getdtablesize(SB)
-TEXT ·libc_getegid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getegid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getegid(SB)
-TEXT ·libc_geteuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_geteuid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_geteuid(SB)
-TEXT ·libc_getgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getgid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getgid(SB)
-TEXT ·libc_getpgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getpgid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getpgid(SB)
-TEXT ·libc_getpgrp_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getpgrp_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getpgrp(SB)
-TEXT ·libc_getpid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getpid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getpid(SB)
-TEXT ·libc_getppid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getppid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getppid(SB)
-TEXT ·libc_getpriority_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getpriority_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getpriority(SB)
-TEXT ·libc_getrlimit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getrlimit_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getrlimit(SB)
-TEXT ·libc_getrusage_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getrusage_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getrusage(SB)
-TEXT ·libc_getsid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getsid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getsid(SB)
-TEXT ·libc_getuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getuid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getuid(SB)
-TEXT ·libc_issetugid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_issetugid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_issetugid(SB)
-TEXT ·libc_kqueue_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_kqueue_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_kqueue(SB)
-TEXT ·libc_lchown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_lchown_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_lchown(SB)
-TEXT ·libc_link_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_link_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_link(SB)
-TEXT ·libc_listen_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_listen_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_listen(SB)
-TEXT ·libc_mkdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_mkdir_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_mkdir(SB)
-TEXT ·libc_mkfifo_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_mkfifo_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_mkfifo(SB)
-TEXT ·libc_mknod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_mknod_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_mknod(SB)
-TEXT ·libc_mlock_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_mlock_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_mlock(SB)
-TEXT ·libc_mlockall_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_mlockall_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_mlockall(SB)
-TEXT ·libc_mprotect_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_mprotect_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_mprotect(SB)
-TEXT ·libc_munlock_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_munlock_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_munlock(SB)
-TEXT ·libc_munlockall_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_munlockall_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_munlockall(SB)
-TEXT ·libc_open_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_open_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_open(SB)
-TEXT ·libc_pathconf_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_pathconf_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_pathconf(SB)
-TEXT ·libc_pread_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_pread_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_pread(SB)
-TEXT ·libc_pwrite_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_pwrite_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_pwrite(SB)
-TEXT ·libc_read_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_read_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_read(SB)
-TEXT ·libc_readdir_r_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_readdir_r_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_readdir_r(SB)
-TEXT ·libc_readlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_readlink_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_readlink(SB)
-TEXT ·libc_rename_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_rename_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_rename(SB)
-TEXT ·libc_revoke_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_revoke_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_revoke(SB)
-TEXT ·libc_rmdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_rmdir_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_rmdir(SB)
-TEXT ·libc_lseek_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_lseek_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_lseek(SB)
-TEXT ·libc_select_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_select_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_select(SB)
-TEXT ·libc_setegid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setegid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setegid(SB)
-TEXT ·libc_seteuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_seteuid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_seteuid(SB)
-TEXT ·libc_setgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setgid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setgid(SB)
-TEXT ·libc_setlogin_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setlogin_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setlogin(SB)
-TEXT ·libc_setpgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setpgid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setpgid(SB)
-TEXT ·libc_setpriority_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setpriority_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setpriority(SB)
-TEXT ·libc_setprivexec_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setprivexec_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setprivexec(SB)
-TEXT ·libc_setregid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setregid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setregid(SB)
-TEXT ·libc_setreuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setreuid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setreuid(SB)
-TEXT ·libc_setrlimit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setrlimit_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setrlimit(SB)
-TEXT ·libc_setsid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setsid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setsid(SB)
-TEXT ·libc_settimeofday_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_settimeofday_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_settimeofday(SB)
-TEXT ·libc_setuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setuid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setuid(SB)
-TEXT ·libc_symlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_symlink_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_symlink(SB)
-TEXT ·libc_sync_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_sync_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_sync(SB)
-TEXT ·libc_truncate_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_truncate_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_truncate(SB)
-TEXT ·libc_umask_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_umask_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_umask(SB)
-TEXT ·libc_undelete_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_undelete_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_undelete(SB)
-TEXT ·libc_unlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_unlink_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_unlink(SB)
-TEXT ·libc_unmount_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_unmount_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_unmount(SB)
-TEXT ·libc_write_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_write_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_write(SB)
-TEXT ·libc_writev_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_writev_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_writev(SB)
-TEXT ·libc_mmap_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_mmap_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_mmap(SB)
-TEXT ·libc_munmap_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_munmap_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_munmap(SB)
-TEXT ·libc_fork_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fork_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fork(SB)
-TEXT ·libc_ioctl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_ioctl_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_ioctl(SB)
-TEXT ·libc_execve_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_execve_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_execve(SB)
-TEXT ·libc_exit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_exit_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_exit(SB)
-TEXT ·libc_sysctl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_sysctl_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_sysctl(SB)
-TEXT ·libc_unlinkat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_unlinkat_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_unlinkat(SB)
-TEXT ·libc_openat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_openat_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_openat(SB)
-TEXT ·libc_getcwd_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getcwd_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getcwd(SB)
-TEXT ·libc_fstat64_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fstat64_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fstat64(SB)
-TEXT ·libc_fstatfs64_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fstatfs64_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fstatfs64(SB)
-TEXT ·libc_gettimeofday_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_gettimeofday_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_gettimeofday(SB)
-TEXT ·libc_lstat64_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_lstat64_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_lstat64(SB)
-TEXT ·libc_stat64_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_stat64_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_stat64(SB)
-TEXT ·libc_statfs64_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_statfs64_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_statfs64(SB)
-TEXT ·libc_fstatat64_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fstatat64_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fstatat64(SB)
-TEXT ·libc_ptrace_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_ptrace_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_ptrace(SB)
diff --git a/src/syscall/zsyscall_darwin_arm64.go b/src/syscall/zsyscall_darwin_arm64.go
index 79576eedf7..2185f324c1 100644
--- a/src/syscall/zsyscall_darwin_arm64.go
+++ b/src/syscall/zsyscall_darwin_arm64.go
@@ -7,11 +7,12 @@
 package syscall
 
 import "unsafe"
+import "internal/abi"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
-	r0, _, e1 := rawSyscall(funcPC(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -26,7 +27,7 @@ func libc_getgroups_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func setgroups(ngid int, gid *_Gid_t) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -40,7 +41,7 @@ func libc_setgroups_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) {
-	r0, _, e1 := syscall6(funcPC(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
 	wpid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -55,7 +56,7 @@ func libc_wait4_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -70,7 +71,7 @@ func libc_accept_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
-	_, _, e1 := syscall(funcPC(libc_bind_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_bind_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -84,7 +85,7 @@ func libc_bind_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
-	_, _, e1 := syscall(funcPC(libc_connect_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_connect_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -98,7 +99,7 @@ func libc_connect_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func socket(domain int, typ int, proto int) (fd int, err error) {
-	r0, _, e1 := rawSyscall(funcPC(libc_socket_trampoline), uintptr(domain), uintptr(typ), uintptr(proto))
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_socket_trampoline), uintptr(domain), uintptr(typ), uintptr(proto))
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -113,7 +114,7 @@ func libc_socket_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
-	_, _, e1 := syscall6(funcPC(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -127,7 +128,7 @@ func libc_getsockopt_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
-	_, _, e1 := syscall6(funcPC(libc_setsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_setsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -141,7 +142,7 @@ func libc_setsockopt_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -155,7 +156,7 @@ func libc_getpeername_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -169,7 +170,7 @@ func libc_getsockname_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Shutdown(s int, how int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_shutdown_trampoline), uintptr(s), uintptr(how), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_shutdown_trampoline), uintptr(s), uintptr(how), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -183,7 +184,7 @@ func libc_shutdown_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
-	_, _, e1 := rawSyscall6(funcPC(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
+	_, _, e1 := rawSyscall6(abi.FuncPCABI0(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -203,7 +204,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall6(funcPC(libc_recvfrom_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_recvfrom_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -224,7 +225,7 @@ func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall6(funcPC(libc_sendto_trampoline), uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_sendto_trampoline), uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -238,7 +239,7 @@ func libc_sendto_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -253,7 +254,7 @@ func libc_recvmsg_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -268,7 +269,7 @@ func libc_sendmsg_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
-	r0, _, e1 := syscall6(funcPC(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -288,7 +289,7 @@ func utimes(path string, timeval *[2]Timeval) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -302,7 +303,7 @@ func libc_utimes_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func futimes(fd int, timeval *[2]Timeval) (err error) {
-	_, _, e1 := syscall(funcPC(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -316,7 +317,7 @@ func libc_futimes_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func fcntl(fd int, cmd int, arg int) (val int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -331,7 +332,7 @@ func libc_fcntl_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func pipe(p *[2]int32) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_pipe_trampoline), uintptr(unsafe.Pointer(p)), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_pipe_trampoline), uintptr(unsafe.Pointer(p)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -345,7 +346,7 @@ func libc_pipe_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func kill(pid int, signum int, posix int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_kill_trampoline), uintptr(pid), uintptr(signum), uintptr(posix))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_kill_trampoline), uintptr(pid), uintptr(signum), uintptr(posix))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -364,7 +365,7 @@ func Access(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -378,7 +379,7 @@ func libc_access_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Adjtime(delta *Timeval, olddelta *Timeval) (err error) {
-	_, _, e1 := syscall(funcPC(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -397,7 +398,7 @@ func Chdir(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -416,7 +417,7 @@ func Chflags(path string, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -435,7 +436,7 @@ func Chmod(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -454,7 +455,7 @@ func Chown(path string, uid int, gid int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -473,7 +474,7 @@ func Chroot(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -487,7 +488,7 @@ func libc_chroot_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Close(fd int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_close_trampoline), uintptr(fd), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_close_trampoline), uintptr(fd), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -501,7 +502,7 @@ func libc_close_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func closedir(dir uintptr) (err error) {
-	_, _, e1 := syscall(funcPC(libc_closedir_trampoline), uintptr(dir), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_closedir_trampoline), uintptr(dir), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -515,7 +516,7 @@ func libc_closedir_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Dup(fd int) (nfd int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_dup_trampoline), uintptr(fd), 0, 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_dup_trampoline), uintptr(fd), 0, 0)
 	nfd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -530,7 +531,7 @@ func libc_dup_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Dup2(from int, to int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_dup2_trampoline), uintptr(from), uintptr(to), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_dup2_trampoline), uintptr(from), uintptr(to), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -554,7 +555,7 @@ func Exchangedata(path1 string, path2 string, options int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_exchangedata_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_exchangedata_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -568,7 +569,7 @@ func libc_exchangedata_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchdir(fd int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fchdir_trampoline), uintptr(fd), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fchdir_trampoline), uintptr(fd), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -582,7 +583,7 @@ func libc_fchdir_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchflags(fd int, flags int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fchflags_trampoline), uintptr(fd), uintptr(flags), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fchflags_trampoline), uintptr(fd), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -596,7 +597,7 @@ func libc_fchflags_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchmod(fd int, mode uint32) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fchmod_trampoline), uintptr(fd), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fchmod_trampoline), uintptr(fd), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -610,7 +611,7 @@ func libc_fchmod_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchown(fd int, uid int, gid int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fchown_trampoline), uintptr(fd), uintptr(uid), uintptr(gid))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fchown_trampoline), uintptr(fd), uintptr(uid), uintptr(gid))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -624,7 +625,7 @@ func libc_fchown_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Flock(fd int, how int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_flock_trampoline), uintptr(fd), uintptr(how), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_flock_trampoline), uintptr(fd), uintptr(how), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -638,7 +639,7 @@ func libc_flock_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fpathconf(fd int, name int) (val int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_fpathconf_trampoline), uintptr(fd), uintptr(name), 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_fpathconf_trampoline), uintptr(fd), uintptr(name), 0)
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -653,7 +654,7 @@ func libc_fpathconf_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fsync(fd int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fsync_trampoline), uintptr(fd), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fsync_trampoline), uintptr(fd), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -667,7 +668,7 @@ func libc_fsync_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Ftruncate(fd int, length int64) (err error) {
-	_, _, e1 := syscall(funcPC(libc_ftruncate_trampoline), uintptr(fd), uintptr(length), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_ftruncate_trampoline), uintptr(fd), uintptr(length), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -681,7 +682,7 @@ func libc_ftruncate_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getdtablesize() (size int) {
-	r0, _, _ := syscall(funcPC(libc_getdtablesize_trampoline), 0, 0, 0)
+	r0, _, _ := syscall(abi.FuncPCABI0(libc_getdtablesize_trampoline), 0, 0, 0)
 	size = int(r0)
 	return
 }
@@ -693,7 +694,7 @@ func libc_getdtablesize_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getegid() (egid int) {
-	r0, _, _ := rawSyscall(funcPC(libc_getegid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getegid_trampoline), 0, 0, 0)
 	egid = int(r0)
 	return
 }
@@ -705,7 +706,7 @@ func libc_getegid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Geteuid() (uid int) {
-	r0, _, _ := rawSyscall(funcPC(libc_geteuid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_geteuid_trampoline), 0, 0, 0)
 	uid = int(r0)
 	return
 }
@@ -717,7 +718,7 @@ func libc_geteuid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getgid() (gid int) {
-	r0, _, _ := rawSyscall(funcPC(libc_getgid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getgid_trampoline), 0, 0, 0)
 	gid = int(r0)
 	return
 }
@@ -729,7 +730,7 @@ func libc_getgid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpgid(pid int) (pgid int, err error) {
-	r0, _, e1 := rawSyscall(funcPC(libc_getpgid_trampoline), uintptr(pid), 0, 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getpgid_trampoline), uintptr(pid), 0, 0)
 	pgid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -744,7 +745,7 @@ func libc_getpgid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpgrp() (pgrp int) {
-	r0, _, _ := rawSyscall(funcPC(libc_getpgrp_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getpgrp_trampoline), 0, 0, 0)
 	pgrp = int(r0)
 	return
 }
@@ -756,7 +757,7 @@ func libc_getpgrp_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpid() (pid int) {
-	r0, _, _ := rawSyscall(funcPC(libc_getpid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getpid_trampoline), 0, 0, 0)
 	pid = int(r0)
 	return
 }
@@ -768,7 +769,7 @@ func libc_getpid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getppid() (ppid int) {
-	r0, _, _ := rawSyscall(funcPC(libc_getppid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getppid_trampoline), 0, 0, 0)
 	ppid = int(r0)
 	return
 }
@@ -780,7 +781,7 @@ func libc_getppid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpriority(which int, who int) (prio int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_getpriority_trampoline), uintptr(which), uintptr(who), 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_getpriority_trampoline), uintptr(which), uintptr(who), 0)
 	prio = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -795,7 +796,7 @@ func libc_getpriority_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getrlimit(which int, lim *Rlimit) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -809,7 +810,7 @@ func libc_getrlimit_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getrusage(who int, rusage *Rusage) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -823,7 +824,7 @@ func libc_getrusage_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getsid(pid int) (sid int, err error) {
-	r0, _, e1 := rawSyscall(funcPC(libc_getsid_trampoline), uintptr(pid), 0, 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getsid_trampoline), uintptr(pid), 0, 0)
 	sid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -838,7 +839,7 @@ func libc_getsid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getuid() (uid int) {
-	r0, _, _ := rawSyscall(funcPC(libc_getuid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getuid_trampoline), 0, 0, 0)
 	uid = int(r0)
 	return
 }
@@ -850,7 +851,7 @@ func libc_getuid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Issetugid() (tainted bool) {
-	r0, _, _ := rawSyscall(funcPC(libc_issetugid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_issetugid_trampoline), 0, 0, 0)
 	tainted = bool(r0 != 0)
 	return
 }
@@ -862,7 +863,7 @@ func libc_issetugid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Kqueue() (fd int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_kqueue_trampoline), 0, 0, 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_kqueue_trampoline), 0, 0, 0)
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -882,7 +883,7 @@ func Lchown(path string, uid int, gid int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -906,7 +907,7 @@ func Link(path string, link string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -920,7 +921,7 @@ func libc_link_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Listen(s int, backlog int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_listen_trampoline), uintptr(s), uintptr(backlog), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_listen_trampoline), uintptr(s), uintptr(backlog), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -939,7 +940,7 @@ func Mkdir(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -958,7 +959,7 @@ func Mkfifo(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -977,7 +978,7 @@ func Mknod(path string, mode uint32, dev int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -997,7 +998,7 @@ func Mlock(b []byte) (err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall(funcPC(libc_mlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_mlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1011,7 +1012,7 @@ func libc_mlock_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Mlockall(flags int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_mlockall_trampoline), uintptr(flags), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_mlockall_trampoline), uintptr(flags), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1031,7 +1032,7 @@ func Mprotect(b []byte, prot int) (err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall(funcPC(libc_mprotect_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(prot))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_mprotect_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(prot))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1051,7 +1052,7 @@ func Munlock(b []byte) (err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall(funcPC(libc_munlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_munlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1065,7 +1066,7 @@ func libc_munlock_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Munlockall() (err error) {
-	_, _, e1 := syscall(funcPC(libc_munlockall_trampoline), 0, 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_munlockall_trampoline), 0, 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1084,7 +1085,7 @@ func Open(path string, mode int, perm uint32) (fd int, err error) {
 	if err != nil {
 		return
 	}
-	r0, _, e1 := syscall(funcPC(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1104,7 +1105,7 @@ func Pathconf(path string, name int) (val int, err error) {
 	if err != nil {
 		return
 	}
-	r0, _, e1 := syscall(funcPC(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1125,7 +1126,7 @@ func Pread(fd int, p []byte, offset int64) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall6(funcPC(libc_pread_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_pread_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1146,7 +1147,7 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall6(funcPC(libc_pwrite_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_pwrite_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1167,7 +1168,7 @@ func read(fd int, p []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_read_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1182,7 +1183,7 @@ func libc_read_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func readdir_r(dir uintptr, entry *Dirent, result **Dirent) (res Errno) {
-	r0, _, _ := syscall(funcPC(libc_readdir_r_trampoline), uintptr(dir), uintptr(unsafe.Pointer(entry)), uintptr(unsafe.Pointer(result)))
+	r0, _, _ := syscall(abi.FuncPCABI0(libc_readdir_r_trampoline), uintptr(dir), uintptr(unsafe.Pointer(entry)), uintptr(unsafe.Pointer(result)))
 	res = Errno(r0)
 	return
 }
@@ -1205,7 +1206,7 @@ func Readlink(path string, buf []byte) (n int, err error) {
 	} else {
 		_p1 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall(funcPC(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1230,7 +1231,7 @@ func Rename(from string, to string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1249,7 +1250,7 @@ func Revoke(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1268,7 +1269,7 @@ func Rmdir(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1282,7 +1283,7 @@ func libc_rmdir_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
-	r0, _, e1 := syscallX(funcPC(libc_lseek_trampoline), uintptr(fd), uintptr(offset), uintptr(whence))
+	r0, _, e1 := syscallX(abi.FuncPCABI0(libc_lseek_trampoline), uintptr(fd), uintptr(offset), uintptr(whence))
 	newoffset = int64(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1297,7 +1298,7 @@ func libc_lseek_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (err error) {
-	_, _, e1 := syscall6(funcPC(libc_select_trampoline), uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_select_trampoline), uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1311,7 +1312,7 @@ func libc_select_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setegid(egid int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_setegid_trampoline), uintptr(egid), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_setegid_trampoline), uintptr(egid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1325,7 +1326,7 @@ func libc_setegid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Seteuid(euid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_seteuid_trampoline), uintptr(euid), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_seteuid_trampoline), uintptr(euid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1339,7 +1340,7 @@ func libc_seteuid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setgid(gid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setgid_trampoline), uintptr(gid), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setgid_trampoline), uintptr(gid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1358,7 +1359,7 @@ func Setlogin(name string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1372,7 +1373,7 @@ func libc_setlogin_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setpgid(pid int, pgid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setpgid_trampoline), uintptr(pid), uintptr(pgid), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setpgid_trampoline), uintptr(pid), uintptr(pgid), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1386,7 +1387,7 @@ func libc_setpgid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setpriority(which int, who int, prio int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_setpriority_trampoline), uintptr(which), uintptr(who), uintptr(prio))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_setpriority_trampoline), uintptr(which), uintptr(who), uintptr(prio))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1400,7 +1401,7 @@ func libc_setpriority_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setprivexec(flag int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_setprivexec_trampoline), uintptr(flag), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_setprivexec_trampoline), uintptr(flag), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1414,7 +1415,7 @@ func libc_setprivexec_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setregid(rgid int, egid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setregid_trampoline), uintptr(rgid), uintptr(egid), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setregid_trampoline), uintptr(rgid), uintptr(egid), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1428,7 +1429,7 @@ func libc_setregid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setreuid(ruid int, euid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setreuid_trampoline), uintptr(ruid), uintptr(euid), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setreuid_trampoline), uintptr(ruid), uintptr(euid), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1442,7 +1443,7 @@ func libc_setreuid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setrlimit(which int, lim *Rlimit) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1456,7 +1457,7 @@ func libc_setrlimit_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setsid() (pid int, err error) {
-	r0, _, e1 := rawSyscall(funcPC(libc_setsid_trampoline), 0, 0, 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setsid_trampoline), 0, 0, 0)
 	pid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1471,7 +1472,7 @@ func libc_setsid_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Settimeofday(tp *Timeval) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1485,7 +1486,7 @@ func libc_settimeofday_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setuid(uid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setuid_trampoline), uintptr(uid), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setuid_trampoline), uintptr(uid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1509,7 +1510,7 @@ func Symlink(path string, link string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1523,7 +1524,7 @@ func libc_symlink_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Sync() (err error) {
-	_, _, e1 := syscall(funcPC(libc_sync_trampoline), 0, 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_sync_trampoline), 0, 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1542,7 +1543,7 @@ func Truncate(path string, length int64) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1556,7 +1557,7 @@ func libc_truncate_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Umask(newmask int) (oldmask int) {
-	r0, _, _ := syscall(funcPC(libc_umask_trampoline), uintptr(newmask), 0, 0)
+	r0, _, _ := syscall(abi.FuncPCABI0(libc_umask_trampoline), uintptr(newmask), 0, 0)
 	oldmask = int(r0)
 	return
 }
@@ -1573,7 +1574,7 @@ func Undelete(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_undelete_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_undelete_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1592,7 +1593,7 @@ func Unlink(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1611,7 +1612,7 @@ func Unmount(path string, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1631,7 +1632,7 @@ func write(fd int, p []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_write_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1652,7 +1653,7 @@ func writev(fd int, iovecs []Iovec) (cnt uintptr, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscallX(funcPC(libc_writev_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(iovecs)))
+	r0, _, e1 := syscallX(abi.FuncPCABI0(libc_writev_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(iovecs)))
 	cnt = uintptr(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1667,7 +1668,7 @@ func libc_writev_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
-	r0, _, e1 := syscall6X(funcPC(libc_mmap_trampoline), uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
+	r0, _, e1 := syscall6X(abi.FuncPCABI0(libc_mmap_trampoline), uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
 	ret = uintptr(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1682,7 +1683,7 @@ func libc_mmap_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func munmap(addr uintptr, length uintptr) (err error) {
-	_, _, e1 := syscall(funcPC(libc_munmap_trampoline), uintptr(addr), uintptr(length), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_munmap_trampoline), uintptr(addr), uintptr(length), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1696,7 +1697,7 @@ func libc_munmap_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func fork() (pid int, err error) {
-	r0, _, e1 := rawSyscall(funcPC(libc_fork_trampoline), 0, 0, 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_fork_trampoline), 0, 0, 0)
 	pid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1711,7 +1712,7 @@ func libc_fork_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func ioctl(fd int, req int, arg int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1725,7 +1726,7 @@ func libc_ioctl_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1735,7 +1736,7 @@ func ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) {
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func execve(path *byte, argv **byte, envp **byte) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_execve_trampoline), uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(argv)), uintptr(unsafe.Pointer(envp)))
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_execve_trampoline), uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(argv)), uintptr(unsafe.Pointer(envp)))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1749,7 +1750,7 @@ func libc_execve_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func exit(res int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_exit_trampoline), uintptr(res), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_exit_trampoline), uintptr(res), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1769,7 +1770,7 @@ func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr)
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall6(funcPC(libc_sysctl_trampoline), uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_sysctl_trampoline), uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1783,7 +1784,7 @@ func libc_sysctl_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func fcntlPtr(fd int, cmd int, arg unsafe.Pointer) (val int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1799,7 +1800,7 @@ func unlinkat(fd int, path string, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_unlinkat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_unlinkat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1818,7 +1819,7 @@ func openat(fd int, path string, flags int, perm uint32) (fdret int, err error)
 	if err != nil {
 		return
 	}
-	r0, _, e1 := syscall6(funcPC(libc_openat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(perm), 0, 0)
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_openat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(perm), 0, 0)
 	fdret = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1839,7 +1840,7 @@ func getcwd(buf []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall(funcPC(libc_getcwd_trampoline), uintptr(_p0), uintptr(len(buf)), 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_getcwd_trampoline), uintptr(_p0), uintptr(len(buf)), 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1854,7 +1855,7 @@ func libc_getcwd_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fstat(fd int, stat *Stat_t) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fstat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fstat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1868,7 +1869,7 @@ func libc_fstat_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fstatfs(fd int, stat *Statfs_t) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fstatfs_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fstatfs_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1882,7 +1883,7 @@ func libc_fstatfs_trampoline()
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Gettimeofday(tp *Timeval) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1901,7 +1902,7 @@ func Lstat(path string, stat *Stat_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_lstat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_lstat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1920,7 +1921,7 @@ func Stat(path string, stat *Stat_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_stat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_stat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1939,7 +1940,7 @@ func Statfs(path string, stat *Statfs_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_statfs_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_statfs_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1958,7 +1959,7 @@ func fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall6(funcPC(libc_fstatat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_fstatat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1971,9 +1972,8 @@ func libc_fstatat_trampoline()
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-//go:nosplit
 func ptrace1(request int, pid int, addr uintptr, data uintptr) (err error) {
-	_, _, e1 := syscall6(funcPC(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
diff --git a/src/syscall/zsyscall_darwin_arm64.s b/src/syscall/zsyscall_darwin_arm64.s
index 73e4a3fd8d..b606c6e49e 100644
--- a/src/syscall/zsyscall_darwin_arm64.s
+++ b/src/syscall/zsyscall_darwin_arm64.s
@@ -1,253 +1,253 @@
 // go run mkasm.go darwin arm64
 // Code generated by the command above; DO NOT EDIT.
 #include "textflag.h"
-TEXT ·libc_getfsstat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getfsstat_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getfsstat(SB)
-TEXT ·libc_setattrlist_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setattrlist_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setattrlist(SB)
-TEXT ·libc_fdopendir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fdopendir_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fdopendir(SB)
-TEXT ·libc_sendfile_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_sendfile_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_sendfile(SB)
-TEXT ·libc_getgroups_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getgroups_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getgroups(SB)
-TEXT ·libc_setgroups_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setgroups_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setgroups(SB)
-TEXT ·libc_wait4_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_wait4_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_wait4(SB)
-TEXT ·libc_accept_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_accept_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_accept(SB)
-TEXT ·libc_bind_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_bind_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_bind(SB)
-TEXT ·libc_connect_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_connect_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_connect(SB)
-TEXT ·libc_socket_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_socket_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_socket(SB)
-TEXT ·libc_getsockopt_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getsockopt_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getsockopt(SB)
-TEXT ·libc_setsockopt_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setsockopt_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setsockopt(SB)
-TEXT ·libc_getpeername_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getpeername_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getpeername(SB)
-TEXT ·libc_getsockname_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getsockname_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getsockname(SB)
-TEXT ·libc_shutdown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_shutdown_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_shutdown(SB)
-TEXT ·libc_socketpair_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_socketpair_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_socketpair(SB)
-TEXT ·libc_recvfrom_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_recvfrom_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_recvfrom(SB)
-TEXT ·libc_sendto_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_sendto_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_sendto(SB)
-TEXT ·libc_recvmsg_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_recvmsg_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_recvmsg(SB)
-TEXT ·libc_sendmsg_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_sendmsg_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_sendmsg(SB)
-TEXT ·libc_kevent_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_kevent_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_kevent(SB)
-TEXT ·libc_utimes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_utimes_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_utimes(SB)
-TEXT ·libc_futimes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_futimes_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_futimes(SB)
-TEXT ·libc_fcntl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fcntl_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fcntl(SB)
-TEXT ·libc_pipe_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_pipe_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_pipe(SB)
-TEXT ·libc_kill_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_kill_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_kill(SB)
-TEXT ·libc_access_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_access_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_access(SB)
-TEXT ·libc_adjtime_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_adjtime_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_adjtime(SB)
-TEXT ·libc_chdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_chdir_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_chdir(SB)
-TEXT ·libc_chflags_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_chflags_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_chflags(SB)
-TEXT ·libc_chmod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_chmod_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_chmod(SB)
-TEXT ·libc_chown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_chown_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_chown(SB)
-TEXT ·libc_chroot_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_chroot_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_chroot(SB)
-TEXT ·libc_close_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_close_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_close(SB)
-TEXT ·libc_closedir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_closedir_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_closedir(SB)
-TEXT ·libc_dup_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_dup_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_dup(SB)
-TEXT ·libc_dup2_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_dup2_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_dup2(SB)
-TEXT ·libc_exchangedata_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_exchangedata_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_exchangedata(SB)
-TEXT ·libc_fchdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fchdir_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fchdir(SB)
-TEXT ·libc_fchflags_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fchflags_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fchflags(SB)
-TEXT ·libc_fchmod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fchmod_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fchmod(SB)
-TEXT ·libc_fchown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fchown_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fchown(SB)
-TEXT ·libc_flock_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_flock_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_flock(SB)
-TEXT ·libc_fpathconf_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fpathconf_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fpathconf(SB)
-TEXT ·libc_fsync_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fsync_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fsync(SB)
-TEXT ·libc_ftruncate_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_ftruncate_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_ftruncate(SB)
-TEXT ·libc_getdtablesize_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getdtablesize_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getdtablesize(SB)
-TEXT ·libc_getegid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getegid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getegid(SB)
-TEXT ·libc_geteuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_geteuid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_geteuid(SB)
-TEXT ·libc_getgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getgid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getgid(SB)
-TEXT ·libc_getpgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getpgid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getpgid(SB)
-TEXT ·libc_getpgrp_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getpgrp_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getpgrp(SB)
-TEXT ·libc_getpid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getpid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getpid(SB)
-TEXT ·libc_getppid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getppid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getppid(SB)
-TEXT ·libc_getpriority_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getpriority_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getpriority(SB)
-TEXT ·libc_getrlimit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getrlimit_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getrlimit(SB)
-TEXT ·libc_getrusage_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getrusage_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getrusage(SB)
-TEXT ·libc_getsid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getsid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getsid(SB)
-TEXT ·libc_getuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getuid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getuid(SB)
-TEXT ·libc_issetugid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_issetugid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_issetugid(SB)
-TEXT ·libc_kqueue_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_kqueue_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_kqueue(SB)
-TEXT ·libc_lchown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_lchown_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_lchown(SB)
-TEXT ·libc_link_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_link_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_link(SB)
-TEXT ·libc_listen_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_listen_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_listen(SB)
-TEXT ·libc_mkdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_mkdir_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_mkdir(SB)
-TEXT ·libc_mkfifo_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_mkfifo_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_mkfifo(SB)
-TEXT ·libc_mknod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_mknod_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_mknod(SB)
-TEXT ·libc_mlock_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_mlock_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_mlock(SB)
-TEXT ·libc_mlockall_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_mlockall_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_mlockall(SB)
-TEXT ·libc_mprotect_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_mprotect_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_mprotect(SB)
-TEXT ·libc_munlock_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_munlock_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_munlock(SB)
-TEXT ·libc_munlockall_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_munlockall_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_munlockall(SB)
-TEXT ·libc_open_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_open_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_open(SB)
-TEXT ·libc_pathconf_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_pathconf_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_pathconf(SB)
-TEXT ·libc_pread_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_pread_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_pread(SB)
-TEXT ·libc_pwrite_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_pwrite_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_pwrite(SB)
-TEXT ·libc_read_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_read_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_read(SB)
-TEXT ·libc_readdir_r_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_readdir_r_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_readdir_r(SB)
-TEXT ·libc_readlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_readlink_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_readlink(SB)
-TEXT ·libc_rename_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_rename_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_rename(SB)
-TEXT ·libc_revoke_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_revoke_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_revoke(SB)
-TEXT ·libc_rmdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_rmdir_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_rmdir(SB)
-TEXT ·libc_lseek_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_lseek_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_lseek(SB)
-TEXT ·libc_select_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_select_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_select(SB)
-TEXT ·libc_setegid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setegid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setegid(SB)
-TEXT ·libc_seteuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_seteuid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_seteuid(SB)
-TEXT ·libc_setgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setgid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setgid(SB)
-TEXT ·libc_setlogin_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setlogin_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setlogin(SB)
-TEXT ·libc_setpgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setpgid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setpgid(SB)
-TEXT ·libc_setpriority_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setpriority_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setpriority(SB)
-TEXT ·libc_setprivexec_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setprivexec_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setprivexec(SB)
-TEXT ·libc_setregid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setregid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setregid(SB)
-TEXT ·libc_setreuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setreuid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setreuid(SB)
-TEXT ·libc_setrlimit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setrlimit_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setrlimit(SB)
-TEXT ·libc_setsid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setsid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setsid(SB)
-TEXT ·libc_settimeofday_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_settimeofday_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_settimeofday(SB)
-TEXT ·libc_setuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setuid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setuid(SB)
-TEXT ·libc_symlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_symlink_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_symlink(SB)
-TEXT ·libc_sync_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_sync_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_sync(SB)
-TEXT ·libc_truncate_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_truncate_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_truncate(SB)
-TEXT ·libc_umask_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_umask_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_umask(SB)
-TEXT ·libc_undelete_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_undelete_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_undelete(SB)
-TEXT ·libc_unlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_unlink_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_unlink(SB)
-TEXT ·libc_unmount_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_unmount_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_unmount(SB)
-TEXT ·libc_write_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_write_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_write(SB)
-TEXT ·libc_writev_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_writev_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_writev(SB)
-TEXT ·libc_mmap_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_mmap_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_mmap(SB)
-TEXT ·libc_munmap_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_munmap_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_munmap(SB)
-TEXT ·libc_fork_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fork_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fork(SB)
-TEXT ·libc_ioctl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_ioctl_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_ioctl(SB)
-TEXT ·libc_execve_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_execve_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_execve(SB)
-TEXT ·libc_exit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_exit_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_exit(SB)
-TEXT ·libc_sysctl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_sysctl_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_sysctl(SB)
-TEXT ·libc_unlinkat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_unlinkat_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_unlinkat(SB)
-TEXT ·libc_openat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_openat_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_openat(SB)
-TEXT ·libc_getcwd_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getcwd_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getcwd(SB)
-TEXT ·libc_fstat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fstat_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fstat(SB)
-TEXT ·libc_fstatfs_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fstatfs_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fstatfs(SB)
-TEXT ·libc_gettimeofday_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_gettimeofday_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_gettimeofday(SB)
-TEXT ·libc_lstat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_lstat_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_lstat(SB)
-TEXT ·libc_stat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_stat_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_stat(SB)
-TEXT ·libc_statfs_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_statfs_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_statfs(SB)
-TEXT ·libc_fstatat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fstatat_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fstatat(SB)
-TEXT ·libc_ptrace_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_ptrace_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_ptrace(SB)
diff --git a/src/syscall/zsyscall_openbsd_amd64.go b/src/syscall/zsyscall_openbsd_amd64.go
index b4698b79e2..85cb195739 100644
--- a/src/syscall/zsyscall_openbsd_amd64.go
+++ b/src/syscall/zsyscall_openbsd_amd64.go
@@ -7,11 +7,12 @@
 package syscall
 
 import "unsafe"
+import "internal/abi"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
-	r0, _, e1 := rawSyscall(funcPC(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -21,13 +22,12 @@ func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
 
 func libc_getgroups_trampoline()
 
-//go:linkname libc_getgroups libc_getgroups
 //go:cgo_import_dynamic libc_getgroups getgroups "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func setgroups(ngid int, gid *_Gid_t) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -36,13 +36,12 @@ func setgroups(ngid int, gid *_Gid_t) (err error) {
 
 func libc_setgroups_trampoline()
 
-//go:linkname libc_setgroups libc_setgroups
 //go:cgo_import_dynamic libc_setgroups setgroups "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) {
-	r0, _, e1 := syscall6(funcPC(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
 	wpid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -52,13 +51,12 @@ func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err
 
 func libc_wait4_trampoline()
 
-//go:linkname libc_wait4 libc_wait4
 //go:cgo_import_dynamic libc_wait4 wait4 "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -68,13 +66,12 @@ func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
 
 func libc_accept_trampoline()
 
-//go:linkname libc_accept libc_accept
 //go:cgo_import_dynamic libc_accept accept "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
-	_, _, e1 := syscall(funcPC(libc_bind_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_bind_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -83,13 +80,12 @@ func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
 
 func libc_bind_trampoline()
 
-//go:linkname libc_bind libc_bind
 //go:cgo_import_dynamic libc_bind bind "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
-	_, _, e1 := syscall(funcPC(libc_connect_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_connect_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -98,13 +94,12 @@ func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
 
 func libc_connect_trampoline()
 
-//go:linkname libc_connect libc_connect
 //go:cgo_import_dynamic libc_connect connect "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func socket(domain int, typ int, proto int) (fd int, err error) {
-	r0, _, e1 := rawSyscall(funcPC(libc_socket_trampoline), uintptr(domain), uintptr(typ), uintptr(proto))
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_socket_trampoline), uintptr(domain), uintptr(typ), uintptr(proto))
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -114,13 +109,12 @@ func socket(domain int, typ int, proto int) (fd int, err error) {
 
 func libc_socket_trampoline()
 
-//go:linkname libc_socket libc_socket
 //go:cgo_import_dynamic libc_socket socket "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
-	_, _, e1 := syscall6(funcPC(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -129,13 +123,12 @@ func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen
 
 func libc_getsockopt_trampoline()
 
-//go:linkname libc_getsockopt libc_getsockopt
 //go:cgo_import_dynamic libc_getsockopt getsockopt "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
-	_, _, e1 := syscall6(funcPC(libc_setsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_setsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -144,13 +137,12 @@ func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr)
 
 func libc_setsockopt_trampoline()
 
-//go:linkname libc_setsockopt libc_setsockopt
 //go:cgo_import_dynamic libc_setsockopt setsockopt "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -159,13 +151,12 @@ func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
 
 func libc_getpeername_trampoline()
 
-//go:linkname libc_getpeername libc_getpeername
 //go:cgo_import_dynamic libc_getpeername getpeername "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -174,13 +165,12 @@ func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
 
 func libc_getsockname_trampoline()
 
-//go:linkname libc_getsockname libc_getsockname
 //go:cgo_import_dynamic libc_getsockname getsockname "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Shutdown(s int, how int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_shutdown_trampoline), uintptr(s), uintptr(how), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_shutdown_trampoline), uintptr(s), uintptr(how), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -189,13 +179,12 @@ func Shutdown(s int, how int) (err error) {
 
 func libc_shutdown_trampoline()
 
-//go:linkname libc_shutdown libc_shutdown
 //go:cgo_import_dynamic libc_shutdown shutdown "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
-	_, _, e1 := rawSyscall6(funcPC(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
+	_, _, e1 := rawSyscall6(abi.FuncPCABI0(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -204,7 +193,6 @@ func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
 
 func libc_socketpair_trampoline()
 
-//go:linkname libc_socketpair libc_socketpair
 //go:cgo_import_dynamic libc_socketpair socketpair "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -216,7 +204,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall6(funcPC(libc_recvfrom_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_recvfrom_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -226,7 +214,6 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
 
 func libc_recvfrom_trampoline()
 
-//go:linkname libc_recvfrom libc_recvfrom
 //go:cgo_import_dynamic libc_recvfrom recvfrom "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -238,7 +225,7 @@ func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall6(funcPC(libc_sendto_trampoline), uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_sendto_trampoline), uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -247,13 +234,12 @@ func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (
 
 func libc_sendto_trampoline()
 
-//go:linkname libc_sendto libc_sendto
 //go:cgo_import_dynamic libc_sendto sendto "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -263,13 +249,12 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 
 func libc_recvmsg_trampoline()
 
-//go:linkname libc_recvmsg libc_recvmsg
 //go:cgo_import_dynamic libc_recvmsg recvmsg "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -279,13 +264,12 @@ func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 
 func libc_sendmsg_trampoline()
 
-//go:linkname libc_sendmsg libc_sendmsg
 //go:cgo_import_dynamic libc_sendmsg sendmsg "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
-	r0, _, e1 := syscall6(funcPC(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -295,7 +279,6 @@ func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, ne
 
 func libc_kevent_trampoline()
 
-//go:linkname libc_kevent libc_kevent
 //go:cgo_import_dynamic libc_kevent kevent "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -306,7 +289,7 @@ func utimes(path string, timeval *[2]Timeval) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -315,13 +298,12 @@ func utimes(path string, timeval *[2]Timeval) (err error) {
 
 func libc_utimes_trampoline()
 
-//go:linkname libc_utimes libc_utimes
 //go:cgo_import_dynamic libc_utimes utimes "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func futimes(fd int, timeval *[2]Timeval) (err error) {
-	_, _, e1 := syscall(funcPC(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -330,13 +312,12 @@ func futimes(fd int, timeval *[2]Timeval) (err error) {
 
 func libc_futimes_trampoline()
 
-//go:linkname libc_futimes libc_futimes
 //go:cgo_import_dynamic libc_futimes futimes "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func fcntl(fd int, cmd int, arg int) (val int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -346,13 +327,12 @@ func fcntl(fd int, cmd int, arg int) (val int, err error) {
 
 func libc_fcntl_trampoline()
 
-//go:linkname libc_fcntl libc_fcntl
 //go:cgo_import_dynamic libc_fcntl fcntl "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func pipe2(p *[2]_C_int, flags int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_pipe2_trampoline), uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_pipe2_trampoline), uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -361,13 +341,12 @@ func pipe2(p *[2]_C_int, flags int) (err error) {
 
 func libc_pipe2_trampoline()
 
-//go:linkname libc_pipe2 libc_pipe2
 //go:cgo_import_dynamic libc_pipe2 pipe2 "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func accept4(fd int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (nfd int, err error) {
-	r0, _, e1 := syscall6(funcPC(libc_accept4_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_accept4_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
 	nfd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -377,7 +356,6 @@ func accept4(fd int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (nfd int
 
 func libc_accept4_trampoline()
 
-//go:linkname libc_accept4 libc_accept4
 //go:cgo_import_dynamic libc_accept4 accept4 "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -389,7 +367,7 @@ func getdents(fd int, buf []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall(funcPC(libc_getdents_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(buf)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_getdents_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(buf)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -399,7 +377,6 @@ func getdents(fd int, buf []byte) (n int, err error) {
 
 func libc_getdents_trampoline()
 
-//go:linkname libc_getdents libc_getdents
 //go:cgo_import_dynamic libc_getdents getdents "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -410,7 +387,7 @@ func Access(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -419,13 +396,12 @@ func Access(path string, mode uint32) (err error) {
 
 func libc_access_trampoline()
 
-//go:linkname libc_access libc_access
 //go:cgo_import_dynamic libc_access access "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Adjtime(delta *Timeval, olddelta *Timeval) (err error) {
-	_, _, e1 := syscall(funcPC(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -434,7 +410,6 @@ func Adjtime(delta *Timeval, olddelta *Timeval) (err error) {
 
 func libc_adjtime_trampoline()
 
-//go:linkname libc_adjtime libc_adjtime
 //go:cgo_import_dynamic libc_adjtime adjtime "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -445,7 +420,7 @@ func Chdir(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -454,7 +429,6 @@ func Chdir(path string) (err error) {
 
 func libc_chdir_trampoline()
 
-//go:linkname libc_chdir libc_chdir
 //go:cgo_import_dynamic libc_chdir chdir "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -465,7 +439,7 @@ func Chflags(path string, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -474,7 +448,6 @@ func Chflags(path string, flags int) (err error) {
 
 func libc_chflags_trampoline()
 
-//go:linkname libc_chflags libc_chflags
 //go:cgo_import_dynamic libc_chflags chflags "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -485,7 +458,7 @@ func Chmod(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -494,7 +467,6 @@ func Chmod(path string, mode uint32) (err error) {
 
 func libc_chmod_trampoline()
 
-//go:linkname libc_chmod libc_chmod
 //go:cgo_import_dynamic libc_chmod chmod "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -505,7 +477,7 @@ func Chown(path string, uid int, gid int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -514,7 +486,6 @@ func Chown(path string, uid int, gid int) (err error) {
 
 func libc_chown_trampoline()
 
-//go:linkname libc_chown libc_chown
 //go:cgo_import_dynamic libc_chown chown "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -525,7 +496,7 @@ func Chroot(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -534,13 +505,12 @@ func Chroot(path string) (err error) {
 
 func libc_chroot_trampoline()
 
-//go:linkname libc_chroot libc_chroot
 //go:cgo_import_dynamic libc_chroot chroot "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Close(fd int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_close_trampoline), uintptr(fd), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_close_trampoline), uintptr(fd), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -549,13 +519,12 @@ func Close(fd int) (err error) {
 
 func libc_close_trampoline()
 
-//go:linkname libc_close libc_close
 //go:cgo_import_dynamic libc_close close "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Dup(fd int) (nfd int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_dup_trampoline), uintptr(fd), 0, 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_dup_trampoline), uintptr(fd), 0, 0)
 	nfd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -565,13 +534,12 @@ func Dup(fd int) (nfd int, err error) {
 
 func libc_dup_trampoline()
 
-//go:linkname libc_dup libc_dup
 //go:cgo_import_dynamic libc_dup dup "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Dup2(from int, to int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_dup2_trampoline), uintptr(from), uintptr(to), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_dup2_trampoline), uintptr(from), uintptr(to), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -580,13 +548,12 @@ func Dup2(from int, to int) (err error) {
 
 func libc_dup2_trampoline()
 
-//go:linkname libc_dup2 libc_dup2
 //go:cgo_import_dynamic libc_dup2 dup2 "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchdir(fd int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fchdir_trampoline), uintptr(fd), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fchdir_trampoline), uintptr(fd), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -595,13 +562,12 @@ func Fchdir(fd int) (err error) {
 
 func libc_fchdir_trampoline()
 
-//go:linkname libc_fchdir libc_fchdir
 //go:cgo_import_dynamic libc_fchdir fchdir "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchflags(fd int, flags int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fchflags_trampoline), uintptr(fd), uintptr(flags), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fchflags_trampoline), uintptr(fd), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -610,13 +576,12 @@ func Fchflags(fd int, flags int) (err error) {
 
 func libc_fchflags_trampoline()
 
-//go:linkname libc_fchflags libc_fchflags
 //go:cgo_import_dynamic libc_fchflags fchflags "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchmod(fd int, mode uint32) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fchmod_trampoline), uintptr(fd), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fchmod_trampoline), uintptr(fd), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -625,13 +590,12 @@ func Fchmod(fd int, mode uint32) (err error) {
 
 func libc_fchmod_trampoline()
 
-//go:linkname libc_fchmod libc_fchmod
 //go:cgo_import_dynamic libc_fchmod fchmod "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchown(fd int, uid int, gid int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fchown_trampoline), uintptr(fd), uintptr(uid), uintptr(gid))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fchown_trampoline), uintptr(fd), uintptr(uid), uintptr(gid))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -640,13 +604,12 @@ func Fchown(fd int, uid int, gid int) (err error) {
 
 func libc_fchown_trampoline()
 
-//go:linkname libc_fchown libc_fchown
 //go:cgo_import_dynamic libc_fchown fchown "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Flock(fd int, how int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_flock_trampoline), uintptr(fd), uintptr(how), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_flock_trampoline), uintptr(fd), uintptr(how), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -655,13 +618,12 @@ func Flock(fd int, how int) (err error) {
 
 func libc_flock_trampoline()
 
-//go:linkname libc_flock libc_flock
 //go:cgo_import_dynamic libc_flock flock "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fpathconf(fd int, name int) (val int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_fpathconf_trampoline), uintptr(fd), uintptr(name), 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_fpathconf_trampoline), uintptr(fd), uintptr(name), 0)
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -671,13 +633,12 @@ func Fpathconf(fd int, name int) (val int, err error) {
 
 func libc_fpathconf_trampoline()
 
-//go:linkname libc_fpathconf libc_fpathconf
 //go:cgo_import_dynamic libc_fpathconf fpathconf "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fstat(fd int, stat *Stat_t) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fstat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fstat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -686,13 +647,12 @@ func Fstat(fd int, stat *Stat_t) (err error) {
 
 func libc_fstat_trampoline()
 
-//go:linkname libc_fstat libc_fstat
 //go:cgo_import_dynamic libc_fstat fstat "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fstatfs(fd int, stat *Statfs_t) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fstatfs_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fstatfs_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -701,13 +661,12 @@ func Fstatfs(fd int, stat *Statfs_t) (err error) {
 
 func libc_fstatfs_trampoline()
 
-//go:linkname libc_fstatfs libc_fstatfs
 //go:cgo_import_dynamic libc_fstatfs fstatfs "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fsync(fd int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fsync_trampoline), uintptr(fd), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fsync_trampoline), uintptr(fd), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -716,13 +675,12 @@ func Fsync(fd int) (err error) {
 
 func libc_fsync_trampoline()
 
-//go:linkname libc_fsync libc_fsync
 //go:cgo_import_dynamic libc_fsync fsync "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Ftruncate(fd int, length int64) (err error) {
-	_, _, e1 := syscall(funcPC(libc_ftruncate_trampoline), uintptr(fd), uintptr(length), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_ftruncate_trampoline), uintptr(fd), uintptr(length), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -731,52 +689,48 @@ func Ftruncate(fd int, length int64) (err error) {
 
 func libc_ftruncate_trampoline()
 
-//go:linkname libc_ftruncate libc_ftruncate
 //go:cgo_import_dynamic libc_ftruncate ftruncate "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getegid() (egid int) {
-	r0, _, _ := rawSyscall(funcPC(libc_getegid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getegid_trampoline), 0, 0, 0)
 	egid = int(r0)
 	return
 }
 
 func libc_getegid_trampoline()
 
-//go:linkname libc_getegid libc_getegid
 //go:cgo_import_dynamic libc_getegid getegid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Geteuid() (uid int) {
-	r0, _, _ := rawSyscall(funcPC(libc_geteuid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_geteuid_trampoline), 0, 0, 0)
 	uid = int(r0)
 	return
 }
 
 func libc_geteuid_trampoline()
 
-//go:linkname libc_geteuid libc_geteuid
 //go:cgo_import_dynamic libc_geteuid geteuid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getgid() (gid int) {
-	r0, _, _ := rawSyscall(funcPC(libc_getgid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getgid_trampoline), 0, 0, 0)
 	gid = int(r0)
 	return
 }
 
 func libc_getgid_trampoline()
 
-//go:linkname libc_getgid libc_getgid
 //go:cgo_import_dynamic libc_getgid getgid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpgid(pid int) (pgid int, err error) {
-	r0, _, e1 := rawSyscall(funcPC(libc_getpgid_trampoline), uintptr(pid), 0, 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getpgid_trampoline), uintptr(pid), 0, 0)
 	pgid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -786,52 +740,48 @@ func Getpgid(pid int) (pgid int, err error) {
 
 func libc_getpgid_trampoline()
 
-//go:linkname libc_getpgid libc_getpgid
 //go:cgo_import_dynamic libc_getpgid getpgid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpgrp() (pgrp int) {
-	r0, _, _ := rawSyscall(funcPC(libc_getpgrp_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getpgrp_trampoline), 0, 0, 0)
 	pgrp = int(r0)
 	return
 }
 
 func libc_getpgrp_trampoline()
 
-//go:linkname libc_getpgrp libc_getpgrp
 //go:cgo_import_dynamic libc_getpgrp getpgrp "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpid() (pid int) {
-	r0, _, _ := rawSyscall(funcPC(libc_getpid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getpid_trampoline), 0, 0, 0)
 	pid = int(r0)
 	return
 }
 
 func libc_getpid_trampoline()
 
-//go:linkname libc_getpid libc_getpid
 //go:cgo_import_dynamic libc_getpid getpid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getppid() (ppid int) {
-	r0, _, _ := rawSyscall(funcPC(libc_getppid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getppid_trampoline), 0, 0, 0)
 	ppid = int(r0)
 	return
 }
 
 func libc_getppid_trampoline()
 
-//go:linkname libc_getppid libc_getppid
 //go:cgo_import_dynamic libc_getppid getppid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpriority(which int, who int) (prio int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_getpriority_trampoline), uintptr(which), uintptr(who), 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_getpriority_trampoline), uintptr(which), uintptr(who), 0)
 	prio = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -841,13 +791,12 @@ func Getpriority(which int, who int) (prio int, err error) {
 
 func libc_getpriority_trampoline()
 
-//go:linkname libc_getpriority libc_getpriority
 //go:cgo_import_dynamic libc_getpriority getpriority "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getrlimit(which int, lim *Rlimit) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -856,13 +805,12 @@ func Getrlimit(which int, lim *Rlimit) (err error) {
 
 func libc_getrlimit_trampoline()
 
-//go:linkname libc_getrlimit libc_getrlimit
 //go:cgo_import_dynamic libc_getrlimit getrlimit "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getrusage(who int, rusage *Rusage) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -871,13 +819,12 @@ func Getrusage(who int, rusage *Rusage) (err error) {
 
 func libc_getrusage_trampoline()
 
-//go:linkname libc_getrusage libc_getrusage
 //go:cgo_import_dynamic libc_getrusage getrusage "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getsid(pid int) (sid int, err error) {
-	r0, _, e1 := rawSyscall(funcPC(libc_getsid_trampoline), uintptr(pid), 0, 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getsid_trampoline), uintptr(pid), 0, 0)
 	sid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -887,13 +834,12 @@ func Getsid(pid int) (sid int, err error) {
 
 func libc_getsid_trampoline()
 
-//go:linkname libc_getsid libc_getsid
 //go:cgo_import_dynamic libc_getsid getsid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Gettimeofday(tv *Timeval) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tv)), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tv)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -902,39 +848,36 @@ func Gettimeofday(tv *Timeval) (err error) {
 
 func libc_gettimeofday_trampoline()
 
-//go:linkname libc_gettimeofday libc_gettimeofday
 //go:cgo_import_dynamic libc_gettimeofday gettimeofday "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getuid() (uid int) {
-	r0, _, _ := rawSyscall(funcPC(libc_getuid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getuid_trampoline), 0, 0, 0)
 	uid = int(r0)
 	return
 }
 
 func libc_getuid_trampoline()
 
-//go:linkname libc_getuid libc_getuid
 //go:cgo_import_dynamic libc_getuid getuid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Issetugid() (tainted bool) {
-	r0, _, _ := syscall(funcPC(libc_issetugid_trampoline), 0, 0, 0)
+	r0, _, _ := syscall(abi.FuncPCABI0(libc_issetugid_trampoline), 0, 0, 0)
 	tainted = bool(r0 != 0)
 	return
 }
 
 func libc_issetugid_trampoline()
 
-//go:linkname libc_issetugid libc_issetugid
 //go:cgo_import_dynamic libc_issetugid issetugid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Kill(pid int, signum Signal) (err error) {
-	_, _, e1 := syscall(funcPC(libc_kill_trampoline), uintptr(pid), uintptr(signum), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_kill_trampoline), uintptr(pid), uintptr(signum), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -943,13 +886,12 @@ func Kill(pid int, signum Signal) (err error) {
 
 func libc_kill_trampoline()
 
-//go:linkname libc_kill libc_kill
 //go:cgo_import_dynamic libc_kill kill "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Kqueue() (fd int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_kqueue_trampoline), 0, 0, 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_kqueue_trampoline), 0, 0, 0)
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -959,7 +901,6 @@ func Kqueue() (fd int, err error) {
 
 func libc_kqueue_trampoline()
 
-//go:linkname libc_kqueue libc_kqueue
 //go:cgo_import_dynamic libc_kqueue kqueue "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -970,7 +911,7 @@ func Lchown(path string, uid int, gid int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -979,7 +920,6 @@ func Lchown(path string, uid int, gid int) (err error) {
 
 func libc_lchown_trampoline()
 
-//go:linkname libc_lchown libc_lchown
 //go:cgo_import_dynamic libc_lchown lchown "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -995,7 +935,7 @@ func Link(path string, link string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1004,13 +944,12 @@ func Link(path string, link string) (err error) {
 
 func libc_link_trampoline()
 
-//go:linkname libc_link libc_link
 //go:cgo_import_dynamic libc_link link "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Listen(s int, backlog int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_listen_trampoline), uintptr(s), uintptr(backlog), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_listen_trampoline), uintptr(s), uintptr(backlog), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1019,7 +958,6 @@ func Listen(s int, backlog int) (err error) {
 
 func libc_listen_trampoline()
 
-//go:linkname libc_listen libc_listen
 //go:cgo_import_dynamic libc_listen listen "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1030,7 +968,7 @@ func Lstat(path string, stat *Stat_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_lstat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_lstat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1039,7 +977,6 @@ func Lstat(path string, stat *Stat_t) (err error) {
 
 func libc_lstat_trampoline()
 
-//go:linkname libc_lstat libc_lstat
 //go:cgo_import_dynamic libc_lstat lstat "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1050,7 +987,7 @@ func Mkdir(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1059,7 +996,6 @@ func Mkdir(path string, mode uint32) (err error) {
 
 func libc_mkdir_trampoline()
 
-//go:linkname libc_mkdir libc_mkdir
 //go:cgo_import_dynamic libc_mkdir mkdir "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1070,7 +1006,7 @@ func Mkfifo(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1079,7 +1015,6 @@ func Mkfifo(path string, mode uint32) (err error) {
 
 func libc_mkfifo_trampoline()
 
-//go:linkname libc_mkfifo libc_mkfifo
 //go:cgo_import_dynamic libc_mkfifo mkfifo "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1090,7 +1025,7 @@ func Mknod(path string, mode uint32, dev int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1099,13 +1034,12 @@ func Mknod(path string, mode uint32, dev int) (err error) {
 
 func libc_mknod_trampoline()
 
-//go:linkname libc_mknod libc_mknod
 //go:cgo_import_dynamic libc_mknod mknod "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Nanosleep(time *Timespec, leftover *Timespec) (err error) {
-	_, _, e1 := syscall(funcPC(libc_nanosleep_trampoline), uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_nanosleep_trampoline), uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1114,7 +1048,6 @@ func Nanosleep(time *Timespec, leftover *Timespec) (err error) {
 
 func libc_nanosleep_trampoline()
 
-//go:linkname libc_nanosleep libc_nanosleep
 //go:cgo_import_dynamic libc_nanosleep nanosleep "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1125,7 +1058,7 @@ func Open(path string, mode int, perm uint32) (fd int, err error) {
 	if err != nil {
 		return
 	}
-	r0, _, e1 := syscall(funcPC(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1135,7 +1068,6 @@ func Open(path string, mode int, perm uint32) (fd int, err error) {
 
 func libc_open_trampoline()
 
-//go:linkname libc_open libc_open
 //go:cgo_import_dynamic libc_open open "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1146,7 +1078,7 @@ func Pathconf(path string, name int) (val int, err error) {
 	if err != nil {
 		return
 	}
-	r0, _, e1 := syscall(funcPC(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1156,7 +1088,6 @@ func Pathconf(path string, name int) (val int, err error) {
 
 func libc_pathconf_trampoline()
 
-//go:linkname libc_pathconf libc_pathconf
 //go:cgo_import_dynamic libc_pathconf pathconf "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1168,7 +1099,7 @@ func Pread(fd int, p []byte, offset int64) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall6(funcPC(libc_pread_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_pread_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1178,7 +1109,6 @@ func Pread(fd int, p []byte, offset int64) (n int, err error) {
 
 func libc_pread_trampoline()
 
-//go:linkname libc_pread libc_pread
 //go:cgo_import_dynamic libc_pread pread "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1190,7 +1120,7 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall6(funcPC(libc_pwrite_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_pwrite_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1200,7 +1130,6 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
 
 func libc_pwrite_trampoline()
 
-//go:linkname libc_pwrite libc_pwrite
 //go:cgo_import_dynamic libc_pwrite pwrite "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1212,7 +1141,7 @@ func read(fd int, p []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_read_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1222,7 +1151,6 @@ func read(fd int, p []byte) (n int, err error) {
 
 func libc_read_trampoline()
 
-//go:linkname libc_read libc_read
 //go:cgo_import_dynamic libc_read read "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1239,7 +1167,7 @@ func Readlink(path string, buf []byte) (n int, err error) {
 	} else {
 		_p1 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall(funcPC(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1249,7 +1177,6 @@ func Readlink(path string, buf []byte) (n int, err error) {
 
 func libc_readlink_trampoline()
 
-//go:linkname libc_readlink libc_readlink
 //go:cgo_import_dynamic libc_readlink readlink "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1265,7 +1192,7 @@ func Rename(from string, to string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1274,7 +1201,6 @@ func Rename(from string, to string) (err error) {
 
 func libc_rename_trampoline()
 
-//go:linkname libc_rename libc_rename
 //go:cgo_import_dynamic libc_rename rename "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1285,7 +1211,7 @@ func Revoke(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1294,7 +1220,6 @@ func Revoke(path string) (err error) {
 
 func libc_revoke_trampoline()
 
-//go:linkname libc_revoke libc_revoke
 //go:cgo_import_dynamic libc_revoke revoke "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1305,7 +1230,7 @@ func Rmdir(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1314,13 +1239,12 @@ func Rmdir(path string) (err error) {
 
 func libc_rmdir_trampoline()
 
-//go:linkname libc_rmdir libc_rmdir
 //go:cgo_import_dynamic libc_rmdir rmdir "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (err error) {
-	_, _, e1 := syscall6(funcPC(libc_select_trampoline), uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_select_trampoline), uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1329,13 +1253,12 @@ func Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (err error) {
 
 func libc_select_trampoline()
 
-//go:linkname libc_select libc_select
 //go:cgo_import_dynamic libc_select select "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setegid(egid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setegid_trampoline), uintptr(egid), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setegid_trampoline), uintptr(egid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1344,13 +1267,12 @@ func Setegid(egid int) (err error) {
 
 func libc_setegid_trampoline()
 
-//go:linkname libc_setegid libc_setegid
 //go:cgo_import_dynamic libc_setegid setegid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Seteuid(euid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_seteuid_trampoline), uintptr(euid), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_seteuid_trampoline), uintptr(euid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1359,13 +1281,12 @@ func Seteuid(euid int) (err error) {
 
 func libc_seteuid_trampoline()
 
-//go:linkname libc_seteuid libc_seteuid
 //go:cgo_import_dynamic libc_seteuid seteuid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setgid(gid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setgid_trampoline), uintptr(gid), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setgid_trampoline), uintptr(gid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1374,7 +1295,6 @@ func Setgid(gid int) (err error) {
 
 func libc_setgid_trampoline()
 
-//go:linkname libc_setgid libc_setgid
 //go:cgo_import_dynamic libc_setgid setgid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1385,7 +1305,7 @@ func Setlogin(name string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1394,13 +1314,12 @@ func Setlogin(name string) (err error) {
 
 func libc_setlogin_trampoline()
 
-//go:linkname libc_setlogin libc_setlogin
 //go:cgo_import_dynamic libc_setlogin setlogin "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setpgid(pid int, pgid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setpgid_trampoline), uintptr(pid), uintptr(pgid), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setpgid_trampoline), uintptr(pid), uintptr(pgid), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1409,13 +1328,12 @@ func Setpgid(pid int, pgid int) (err error) {
 
 func libc_setpgid_trampoline()
 
-//go:linkname libc_setpgid libc_setpgid
 //go:cgo_import_dynamic libc_setpgid setpgid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setpriority(which int, who int, prio int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_setpriority_trampoline), uintptr(which), uintptr(who), uintptr(prio))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_setpriority_trampoline), uintptr(which), uintptr(who), uintptr(prio))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1424,13 +1342,12 @@ func Setpriority(which int, who int, prio int) (err error) {
 
 func libc_setpriority_trampoline()
 
-//go:linkname libc_setpriority libc_setpriority
 //go:cgo_import_dynamic libc_setpriority setpriority "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setregid(rgid int, egid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setregid_trampoline), uintptr(rgid), uintptr(egid), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setregid_trampoline), uintptr(rgid), uintptr(egid), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1439,13 +1356,12 @@ func Setregid(rgid int, egid int) (err error) {
 
 func libc_setregid_trampoline()
 
-//go:linkname libc_setregid libc_setregid
 //go:cgo_import_dynamic libc_setregid setregid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setreuid(ruid int, euid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setreuid_trampoline), uintptr(ruid), uintptr(euid), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setreuid_trampoline), uintptr(ruid), uintptr(euid), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1454,13 +1370,12 @@ func Setreuid(ruid int, euid int) (err error) {
 
 func libc_setreuid_trampoline()
 
-//go:linkname libc_setreuid libc_setreuid
 //go:cgo_import_dynamic libc_setreuid setreuid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setrlimit(which int, lim *Rlimit) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1469,13 +1384,12 @@ func Setrlimit(which int, lim *Rlimit) (err error) {
 
 func libc_setrlimit_trampoline()
 
-//go:linkname libc_setrlimit libc_setrlimit
 //go:cgo_import_dynamic libc_setrlimit setrlimit "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setsid() (pid int, err error) {
-	r0, _, e1 := rawSyscall(funcPC(libc_setsid_trampoline), 0, 0, 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setsid_trampoline), 0, 0, 0)
 	pid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1485,13 +1399,12 @@ func Setsid() (pid int, err error) {
 
 func libc_setsid_trampoline()
 
-//go:linkname libc_setsid libc_setsid
 //go:cgo_import_dynamic libc_setsid setsid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Settimeofday(tp *Timeval) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1500,13 +1413,12 @@ func Settimeofday(tp *Timeval) (err error) {
 
 func libc_settimeofday_trampoline()
 
-//go:linkname libc_settimeofday libc_settimeofday
 //go:cgo_import_dynamic libc_settimeofday settimeofday "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setuid(uid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setuid_trampoline), uintptr(uid), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setuid_trampoline), uintptr(uid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1515,7 +1427,6 @@ func Setuid(uid int) (err error) {
 
 func libc_setuid_trampoline()
 
-//go:linkname libc_setuid libc_setuid
 //go:cgo_import_dynamic libc_setuid setuid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1526,7 +1437,7 @@ func Stat(path string, stat *Stat_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_stat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_stat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1535,7 +1446,6 @@ func Stat(path string, stat *Stat_t) (err error) {
 
 func libc_stat_trampoline()
 
-//go:linkname libc_stat libc_stat
 //go:cgo_import_dynamic libc_stat stat "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1546,7 +1456,7 @@ func Statfs(path string, stat *Statfs_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_statfs_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_statfs_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1555,7 +1465,6 @@ func Statfs(path string, stat *Statfs_t) (err error) {
 
 func libc_statfs_trampoline()
 
-//go:linkname libc_statfs libc_statfs
 //go:cgo_import_dynamic libc_statfs statfs "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1571,7 +1480,7 @@ func Symlink(path string, link string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1580,13 +1489,12 @@ func Symlink(path string, link string) (err error) {
 
 func libc_symlink_trampoline()
 
-//go:linkname libc_symlink libc_symlink
 //go:cgo_import_dynamic libc_symlink symlink "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Sync() (err error) {
-	_, _, e1 := syscall(funcPC(libc_sync_trampoline), 0, 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_sync_trampoline), 0, 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1595,7 +1503,6 @@ func Sync() (err error) {
 
 func libc_sync_trampoline()
 
-//go:linkname libc_sync libc_sync
 //go:cgo_import_dynamic libc_sync sync "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1606,7 +1513,7 @@ func Truncate(path string, length int64) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1615,20 +1522,18 @@ func Truncate(path string, length int64) (err error) {
 
 func libc_truncate_trampoline()
 
-//go:linkname libc_truncate libc_truncate
 //go:cgo_import_dynamic libc_truncate truncate "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Umask(newmask int) (oldmask int) {
-	r0, _, _ := syscall(funcPC(libc_umask_trampoline), uintptr(newmask), 0, 0)
+	r0, _, _ := syscall(abi.FuncPCABI0(libc_umask_trampoline), uintptr(newmask), 0, 0)
 	oldmask = int(r0)
 	return
 }
 
 func libc_umask_trampoline()
 
-//go:linkname libc_umask libc_umask
 //go:cgo_import_dynamic libc_umask umask "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1639,7 +1544,7 @@ func Unlink(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1648,7 +1553,6 @@ func Unlink(path string) (err error) {
 
 func libc_unlink_trampoline()
 
-//go:linkname libc_unlink libc_unlink
 //go:cgo_import_dynamic libc_unlink unlink "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1659,7 +1563,7 @@ func Unmount(path string, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1668,7 +1572,6 @@ func Unmount(path string, flags int) (err error) {
 
 func libc_unmount_trampoline()
 
-//go:linkname libc_unmount libc_unmount
 //go:cgo_import_dynamic libc_unmount unmount "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1680,7 +1583,7 @@ func write(fd int, p []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_write_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1690,13 +1593,12 @@ func write(fd int, p []byte) (n int, err error) {
 
 func libc_write_trampoline()
 
-//go:linkname libc_write libc_write
 //go:cgo_import_dynamic libc_write write "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
-	r0, _, e1 := syscall6X(funcPC(libc_mmap_trampoline), uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
+	r0, _, e1 := syscall6X(abi.FuncPCABI0(libc_mmap_trampoline), uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
 	ret = uintptr(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1706,13 +1608,12 @@ func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (
 
 func libc_mmap_trampoline()
 
-//go:linkname libc_mmap libc_mmap
 //go:cgo_import_dynamic libc_mmap mmap "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func munmap(addr uintptr, length uintptr) (err error) {
-	_, _, e1 := syscall(funcPC(libc_munmap_trampoline), uintptr(addr), uintptr(length), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_munmap_trampoline), uintptr(addr), uintptr(length), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1721,7 +1622,6 @@ func munmap(addr uintptr, length uintptr) (err error) {
 
 func libc_munmap_trampoline()
 
-//go:linkname libc_munmap libc_munmap
 //go:cgo_import_dynamic libc_munmap munmap "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1732,7 +1632,7 @@ func utimensat(dirfd int, path string, times *[2]Timespec, flag int) (err error)
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall6(funcPC(libc_utimensat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), uintptr(flag), 0, 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_utimensat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), uintptr(flag), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1741,13 +1641,12 @@ func utimensat(dirfd int, path string, times *[2]Timespec, flag int) (err error)
 
 func libc_utimensat_trampoline()
 
-//go:linkname libc_utimensat libc_utimensat
 //go:cgo_import_dynamic libc_utimensat utimensat "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func directSyscall(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr) (ret uintptr, err error) {
-	r0, _, e1 := syscall6X(funcPC(libc_syscall_trampoline), uintptr(trap), uintptr(a1), uintptr(a2), uintptr(a3), uintptr(a4), uintptr(a5))
+	r0, _, e1 := syscall6X(abi.FuncPCABI0(libc_syscall_trampoline), uintptr(trap), uintptr(a1), uintptr(a2), uintptr(a3), uintptr(a4), uintptr(a5))
 	ret = uintptr(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1757,13 +1656,12 @@ func directSyscall(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr,
 
 func libc_syscall_trampoline()
 
-//go:linkname libc_syscall libc_syscall
 //go:cgo_import_dynamic libc_syscall syscall "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1774,7 +1672,7 @@ func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1785,7 +1683,7 @@ func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
-	r0, _, e1 := syscallX(funcPC(libc_lseek_trampoline), uintptr(fd), uintptr(offset), uintptr(whence))
+	r0, _, e1 := syscallX(abi.FuncPCABI0(libc_lseek_trampoline), uintptr(fd), uintptr(offset), uintptr(whence))
 	newoffset = int64(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1795,7 +1693,6 @@ func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
 
 func libc_lseek_trampoline()
 
-//go:linkname libc_lseek libc_lseek
 //go:cgo_import_dynamic libc_lseek lseek "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1807,7 +1704,7 @@ func getcwd(buf []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall(funcPC(libc_getcwd_trampoline), uintptr(_p0), uintptr(len(buf)), 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_getcwd_trampoline), uintptr(_p0), uintptr(len(buf)), 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1817,7 +1714,6 @@ func getcwd(buf []byte) (n int, err error) {
 
 func libc_getcwd_trampoline()
 
-//go:linkname libc_getcwd libc_getcwd
 //go:cgo_import_dynamic libc_getcwd getcwd "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1829,7 +1725,7 @@ func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr)
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall6(funcPC(libc_sysctl_trampoline), uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_sysctl_trampoline), uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1838,13 +1734,12 @@ func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr)
 
 func libc_sysctl_trampoline()
 
-//go:linkname libc_sysctl libc_sysctl
 //go:cgo_import_dynamic libc_sysctl sysctl "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func fork() (pid int, err error) {
-	r0, _, e1 := rawSyscall(funcPC(libc_fork_trampoline), 0, 0, 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_fork_trampoline), 0, 0, 0)
 	pid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1854,13 +1749,12 @@ func fork() (pid int, err error) {
 
 func libc_fork_trampoline()
 
-//go:linkname libc_fork libc_fork
 //go:cgo_import_dynamic libc_fork fork "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func ioctl(fd int, req int, arg int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1869,13 +1763,12 @@ func ioctl(fd int, req int, arg int) (err error) {
 
 func libc_ioctl_trampoline()
 
-//go:linkname libc_ioctl libc_ioctl
 //go:cgo_import_dynamic libc_ioctl ioctl "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func execve(path *byte, argv **byte, envp **byte) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_execve_trampoline), uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(argv)), uintptr(unsafe.Pointer(envp)))
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_execve_trampoline), uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(argv)), uintptr(unsafe.Pointer(envp)))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1884,13 +1777,12 @@ func execve(path *byte, argv **byte, envp **byte) (err error) {
 
 func libc_execve_trampoline()
 
-//go:linkname libc_execve libc_execve
 //go:cgo_import_dynamic libc_execve execve "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func exit(res int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_exit_trampoline), uintptr(res), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_exit_trampoline), uintptr(res), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1899,14 +1791,13 @@ func exit(res int) (err error) {
 
 func libc_exit_trampoline()
 
-//go:linkname libc_exit libc_exit
 //go:cgo_import_dynamic libc_exit exit "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 //go:nosplit
 func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
-	_, _, e1 := syscall6(funcPC(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1915,7 +1806,6 @@ func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
 
 func libc_ptrace_trampoline()
 
-//go:linkname libc_ptrace libc_ptrace
 //go:cgo_import_dynamic libc_ptrace ptrace "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1927,7 +1817,7 @@ func getentropy(p []byte) (err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := rawSyscall(funcPC(libc_getentropy_trampoline), uintptr(_p0), uintptr(len(p)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getentropy_trampoline), uintptr(_p0), uintptr(len(p)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1936,7 +1826,6 @@ func getentropy(p []byte) (err error) {
 
 func libc_getentropy_trampoline()
 
-//go:linkname libc_getentropy libc_getentropy
 //go:cgo_import_dynamic libc_getentropy getentropy "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1947,7 +1836,7 @@ func fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall6(funcPC(libc_fstatat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_fstatat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1956,13 +1845,12 @@ func fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
 
 func libc_fstatat_trampoline()
 
-//go:linkname libc_fstatat libc_fstatat
 //go:cgo_import_dynamic libc_fstatat fstatat "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func fcntlPtr(fd int, cmd int, arg unsafe.Pointer) (val int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1978,7 +1866,7 @@ func unlinkat(fd int, path string, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_unlinkat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_unlinkat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1987,7 +1875,6 @@ func unlinkat(fd int, path string, flags int) (err error) {
 
 func libc_unlinkat_trampoline()
 
-//go:linkname libc_unlinkat libc_unlinkat
 //go:cgo_import_dynamic libc_unlinkat unlinkat "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1998,7 +1885,7 @@ func openat(fd int, path string, flags int, perm uint32) (fdret int, err error)
 	if err != nil {
 		return
 	}
-	r0, _, e1 := syscall6(funcPC(libc_openat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(perm), 0, 0)
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_openat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(perm), 0, 0)
 	fdret = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -2008,5 +1895,4 @@ func openat(fd int, path string, flags int, perm uint32) (fdret int, err error)
 
 func libc_openat_trampoline()
 
-//go:linkname libc_openat libc_openat
 //go:cgo_import_dynamic libc_openat openat "libc.so"
diff --git a/src/syscall/zsyscall_openbsd_amd64.s b/src/syscall/zsyscall_openbsd_amd64.s
index 8256a451f5..e5c5dde930 100644
--- a/src/syscall/zsyscall_openbsd_amd64.s
+++ b/src/syscall/zsyscall_openbsd_amd64.s
@@ -1,233 +1,233 @@
 // go run mkasm.go openbsd amd64
 // Code generated by the command above; DO NOT EDIT.
 #include "textflag.h"
-TEXT ·libc_getgroups_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getgroups_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getgroups(SB)
-TEXT ·libc_setgroups_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setgroups_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setgroups(SB)
-TEXT ·libc_wait4_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_wait4_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_wait4(SB)
-TEXT ·libc_accept_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_accept_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_accept(SB)
-TEXT ·libc_bind_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_bind_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_bind(SB)
-TEXT ·libc_connect_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_connect_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_connect(SB)
-TEXT ·libc_socket_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_socket_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_socket(SB)
-TEXT ·libc_getsockopt_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getsockopt_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getsockopt(SB)
-TEXT ·libc_setsockopt_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setsockopt_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setsockopt(SB)
-TEXT ·libc_getpeername_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getpeername_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getpeername(SB)
-TEXT ·libc_getsockname_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getsockname_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getsockname(SB)
-TEXT ·libc_shutdown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_shutdown_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_shutdown(SB)
-TEXT ·libc_socketpair_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_socketpair_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_socketpair(SB)
-TEXT ·libc_recvfrom_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_recvfrom_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_recvfrom(SB)
-TEXT ·libc_sendto_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_sendto_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_sendto(SB)
-TEXT ·libc_recvmsg_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_recvmsg_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_recvmsg(SB)
-TEXT ·libc_sendmsg_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_sendmsg_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_sendmsg(SB)
-TEXT ·libc_kevent_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_kevent_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_kevent(SB)
-TEXT ·libc_utimes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_utimes_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_utimes(SB)
-TEXT ·libc_futimes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_futimes_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_futimes(SB)
-TEXT ·libc_fcntl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fcntl_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fcntl(SB)
-TEXT ·libc_pipe2_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_pipe2_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_pipe2(SB)
-TEXT ·libc_accept4_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_accept4_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_accept4(SB)
-TEXT ·libc_getdents_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getdents_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getdents(SB)
-TEXT ·libc_access_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_access_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_access(SB)
-TEXT ·libc_adjtime_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_adjtime_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_adjtime(SB)
-TEXT ·libc_chdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_chdir_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_chdir(SB)
-TEXT ·libc_chflags_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_chflags_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_chflags(SB)
-TEXT ·libc_chmod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_chmod_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_chmod(SB)
-TEXT ·libc_chown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_chown_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_chown(SB)
-TEXT ·libc_chroot_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_chroot_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_chroot(SB)
-TEXT ·libc_close_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_close_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_close(SB)
-TEXT ·libc_dup_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_dup_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_dup(SB)
-TEXT ·libc_dup2_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_dup2_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_dup2(SB)
-TEXT ·libc_fchdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fchdir_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fchdir(SB)
-TEXT ·libc_fchflags_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fchflags_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fchflags(SB)
-TEXT ·libc_fchmod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fchmod_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fchmod(SB)
-TEXT ·libc_fchown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fchown_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fchown(SB)
-TEXT ·libc_flock_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_flock_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_flock(SB)
-TEXT ·libc_fpathconf_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fpathconf_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fpathconf(SB)
-TEXT ·libc_fstat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fstat_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fstat(SB)
-TEXT ·libc_fstatfs_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fstatfs_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fstatfs(SB)
-TEXT ·libc_fsync_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fsync_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fsync(SB)
-TEXT ·libc_ftruncate_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_ftruncate_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_ftruncate(SB)
-TEXT ·libc_getegid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getegid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getegid(SB)
-TEXT ·libc_geteuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_geteuid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_geteuid(SB)
-TEXT ·libc_getgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getgid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getgid(SB)
-TEXT ·libc_getpgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getpgid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getpgid(SB)
-TEXT ·libc_getpgrp_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getpgrp_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getpgrp(SB)
-TEXT ·libc_getpid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getpid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getpid(SB)
-TEXT ·libc_getppid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getppid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getppid(SB)
-TEXT ·libc_getpriority_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getpriority_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getpriority(SB)
-TEXT ·libc_getrlimit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getrlimit_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getrlimit(SB)
-TEXT ·libc_getrusage_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getrusage_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getrusage(SB)
-TEXT ·libc_getsid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getsid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getsid(SB)
-TEXT ·libc_gettimeofday_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_gettimeofday_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_gettimeofday(SB)
-TEXT ·libc_getuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getuid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getuid(SB)
-TEXT ·libc_issetugid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_issetugid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_issetugid(SB)
-TEXT ·libc_kill_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_kill_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_kill(SB)
-TEXT ·libc_kqueue_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_kqueue_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_kqueue(SB)
-TEXT ·libc_lchown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_lchown_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_lchown(SB)
-TEXT ·libc_link_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_link_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_link(SB)
-TEXT ·libc_listen_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_listen_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_listen(SB)
-TEXT ·libc_lstat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_lstat_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_lstat(SB)
-TEXT ·libc_mkdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_mkdir_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_mkdir(SB)
-TEXT ·libc_mkfifo_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_mkfifo_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_mkfifo(SB)
-TEXT ·libc_mknod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_mknod_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_mknod(SB)
-TEXT ·libc_nanosleep_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_nanosleep_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_nanosleep(SB)
-TEXT ·libc_open_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_open_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_open(SB)
-TEXT ·libc_pathconf_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_pathconf_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_pathconf(SB)
-TEXT ·libc_pread_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_pread_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_pread(SB)
-TEXT ·libc_pwrite_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_pwrite_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_pwrite(SB)
-TEXT ·libc_read_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_read_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_read(SB)
-TEXT ·libc_readlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_readlink_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_readlink(SB)
-TEXT ·libc_rename_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_rename_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_rename(SB)
-TEXT ·libc_revoke_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_revoke_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_revoke(SB)
-TEXT ·libc_rmdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_rmdir_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_rmdir(SB)
-TEXT ·libc_select_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_select_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_select(SB)
-TEXT ·libc_setegid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setegid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setegid(SB)
-TEXT ·libc_seteuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_seteuid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_seteuid(SB)
-TEXT ·libc_setgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setgid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setgid(SB)
-TEXT ·libc_setlogin_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setlogin_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setlogin(SB)
-TEXT ·libc_setpgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setpgid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setpgid(SB)
-TEXT ·libc_setpriority_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setpriority_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setpriority(SB)
-TEXT ·libc_setregid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setregid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setregid(SB)
-TEXT ·libc_setreuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setreuid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setreuid(SB)
-TEXT ·libc_setrlimit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setrlimit_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setrlimit(SB)
-TEXT ·libc_setsid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setsid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setsid(SB)
-TEXT ·libc_settimeofday_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_settimeofday_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_settimeofday(SB)
-TEXT ·libc_setuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setuid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setuid(SB)
-TEXT ·libc_stat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_stat_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_stat(SB)
-TEXT ·libc_statfs_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_statfs_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_statfs(SB)
-TEXT ·libc_symlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_symlink_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_symlink(SB)
-TEXT ·libc_sync_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_sync_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_sync(SB)
-TEXT ·libc_truncate_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_truncate_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_truncate(SB)
-TEXT ·libc_umask_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_umask_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_umask(SB)
-TEXT ·libc_unlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_unlink_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_unlink(SB)
-TEXT ·libc_unmount_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_unmount_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_unmount(SB)
-TEXT ·libc_write_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_write_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_write(SB)
-TEXT ·libc_mmap_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_mmap_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_mmap(SB)
-TEXT ·libc_munmap_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_munmap_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_munmap(SB)
-TEXT ·libc_utimensat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_utimensat_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_utimensat(SB)
-TEXT ·libc_syscall_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_syscall_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_syscall(SB)
-TEXT ·libc_lseek_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_lseek_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_lseek(SB)
-TEXT ·libc_getcwd_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getcwd_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getcwd(SB)
-TEXT ·libc_sysctl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_sysctl_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_sysctl(SB)
-TEXT ·libc_fork_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fork_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fork(SB)
-TEXT ·libc_ioctl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_ioctl_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_ioctl(SB)
-TEXT ·libc_execve_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_execve_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_execve(SB)
-TEXT ·libc_exit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_exit_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_exit(SB)
-TEXT ·libc_ptrace_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_ptrace_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_ptrace(SB)
-TEXT ·libc_getentropy_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getentropy_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getentropy(SB)
-TEXT ·libc_fstatat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fstatat_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fstatat(SB)
-TEXT ·libc_unlinkat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_unlinkat_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_unlinkat(SB)
-TEXT ·libc_openat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_openat_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_openat(SB)
diff --git a/src/syscall/zsyscall_openbsd_arm64.go b/src/syscall/zsyscall_openbsd_arm64.go
index de6db1e3fa..fa35905d1b 100644
--- a/src/syscall/zsyscall_openbsd_arm64.go
+++ b/src/syscall/zsyscall_openbsd_arm64.go
@@ -7,11 +7,12 @@
 package syscall
 
 import "unsafe"
+import "internal/abi"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
-	r0, _, e1 := rawSyscall(funcPC(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -21,13 +22,12 @@ func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
 
 func libc_getgroups_trampoline()
 
-//go:linkname libc_getgroups libc_getgroups
 //go:cgo_import_dynamic libc_getgroups getgroups "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func setgroups(ngid int, gid *_Gid_t) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -36,13 +36,12 @@ func setgroups(ngid int, gid *_Gid_t) (err error) {
 
 func libc_setgroups_trampoline()
 
-//go:linkname libc_setgroups libc_setgroups
 //go:cgo_import_dynamic libc_setgroups setgroups "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) {
-	r0, _, e1 := syscall6(funcPC(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
 	wpid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -52,13 +51,12 @@ func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err
 
 func libc_wait4_trampoline()
 
-//go:linkname libc_wait4 libc_wait4
 //go:cgo_import_dynamic libc_wait4 wait4 "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -68,13 +66,12 @@ func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
 
 func libc_accept_trampoline()
 
-//go:linkname libc_accept libc_accept
 //go:cgo_import_dynamic libc_accept accept "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
-	_, _, e1 := syscall(funcPC(libc_bind_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_bind_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -83,13 +80,12 @@ func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
 
 func libc_bind_trampoline()
 
-//go:linkname libc_bind libc_bind
 //go:cgo_import_dynamic libc_bind bind "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
-	_, _, e1 := syscall(funcPC(libc_connect_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_connect_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -98,13 +94,12 @@ func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
 
 func libc_connect_trampoline()
 
-//go:linkname libc_connect libc_connect
 //go:cgo_import_dynamic libc_connect connect "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func socket(domain int, typ int, proto int) (fd int, err error) {
-	r0, _, e1 := rawSyscall(funcPC(libc_socket_trampoline), uintptr(domain), uintptr(typ), uintptr(proto))
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_socket_trampoline), uintptr(domain), uintptr(typ), uintptr(proto))
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -114,13 +109,12 @@ func socket(domain int, typ int, proto int) (fd int, err error) {
 
 func libc_socket_trampoline()
 
-//go:linkname libc_socket libc_socket
 //go:cgo_import_dynamic libc_socket socket "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
-	_, _, e1 := syscall6(funcPC(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -129,13 +123,12 @@ func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen
 
 func libc_getsockopt_trampoline()
 
-//go:linkname libc_getsockopt libc_getsockopt
 //go:cgo_import_dynamic libc_getsockopt getsockopt "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
-	_, _, e1 := syscall6(funcPC(libc_setsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_setsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -144,13 +137,12 @@ func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr)
 
 func libc_setsockopt_trampoline()
 
-//go:linkname libc_setsockopt libc_setsockopt
 //go:cgo_import_dynamic libc_setsockopt setsockopt "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -159,13 +151,12 @@ func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
 
 func libc_getpeername_trampoline()
 
-//go:linkname libc_getpeername libc_getpeername
 //go:cgo_import_dynamic libc_getpeername getpeername "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -174,13 +165,12 @@ func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
 
 func libc_getsockname_trampoline()
 
-//go:linkname libc_getsockname libc_getsockname
 //go:cgo_import_dynamic libc_getsockname getsockname "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Shutdown(s int, how int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_shutdown_trampoline), uintptr(s), uintptr(how), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_shutdown_trampoline), uintptr(s), uintptr(how), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -189,13 +179,12 @@ func Shutdown(s int, how int) (err error) {
 
 func libc_shutdown_trampoline()
 
-//go:linkname libc_shutdown libc_shutdown
 //go:cgo_import_dynamic libc_shutdown shutdown "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
-	_, _, e1 := rawSyscall6(funcPC(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
+	_, _, e1 := rawSyscall6(abi.FuncPCABI0(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -204,7 +193,6 @@ func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
 
 func libc_socketpair_trampoline()
 
-//go:linkname libc_socketpair libc_socketpair
 //go:cgo_import_dynamic libc_socketpair socketpair "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -216,7 +204,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall6(funcPC(libc_recvfrom_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_recvfrom_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -226,7 +214,6 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
 
 func libc_recvfrom_trampoline()
 
-//go:linkname libc_recvfrom libc_recvfrom
 //go:cgo_import_dynamic libc_recvfrom recvfrom "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -238,7 +225,7 @@ func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall6(funcPC(libc_sendto_trampoline), uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_sendto_trampoline), uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -247,13 +234,12 @@ func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (
 
 func libc_sendto_trampoline()
 
-//go:linkname libc_sendto libc_sendto
 //go:cgo_import_dynamic libc_sendto sendto "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -263,13 +249,12 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 
 func libc_recvmsg_trampoline()
 
-//go:linkname libc_recvmsg libc_recvmsg
 //go:cgo_import_dynamic libc_recvmsg recvmsg "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -279,13 +264,12 @@ func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 
 func libc_sendmsg_trampoline()
 
-//go:linkname libc_sendmsg libc_sendmsg
 //go:cgo_import_dynamic libc_sendmsg sendmsg "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
-	r0, _, e1 := syscall6(funcPC(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -295,7 +279,6 @@ func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, ne
 
 func libc_kevent_trampoline()
 
-//go:linkname libc_kevent libc_kevent
 //go:cgo_import_dynamic libc_kevent kevent "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -306,7 +289,7 @@ func utimes(path string, timeval *[2]Timeval) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -315,13 +298,12 @@ func utimes(path string, timeval *[2]Timeval) (err error) {
 
 func libc_utimes_trampoline()
 
-//go:linkname libc_utimes libc_utimes
 //go:cgo_import_dynamic libc_utimes utimes "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func futimes(fd int, timeval *[2]Timeval) (err error) {
-	_, _, e1 := syscall(funcPC(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -330,13 +312,12 @@ func futimes(fd int, timeval *[2]Timeval) (err error) {
 
 func libc_futimes_trampoline()
 
-//go:linkname libc_futimes libc_futimes
 //go:cgo_import_dynamic libc_futimes futimes "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func fcntl(fd int, cmd int, arg int) (val int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -346,13 +327,12 @@ func fcntl(fd int, cmd int, arg int) (val int, err error) {
 
 func libc_fcntl_trampoline()
 
-//go:linkname libc_fcntl libc_fcntl
 //go:cgo_import_dynamic libc_fcntl fcntl "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func pipe2(p *[2]_C_int, flags int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_pipe2_trampoline), uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_pipe2_trampoline), uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -361,13 +341,12 @@ func pipe2(p *[2]_C_int, flags int) (err error) {
 
 func libc_pipe2_trampoline()
 
-//go:linkname libc_pipe2 libc_pipe2
 //go:cgo_import_dynamic libc_pipe2 pipe2 "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func accept4(fd int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (nfd int, err error) {
-	r0, _, e1 := syscall6(funcPC(libc_accept4_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_accept4_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
 	nfd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -377,7 +356,6 @@ func accept4(fd int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (nfd int
 
 func libc_accept4_trampoline()
 
-//go:linkname libc_accept4 libc_accept4
 //go:cgo_import_dynamic libc_accept4 accept4 "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -389,7 +367,7 @@ func getdents(fd int, buf []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall(funcPC(libc_getdents_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(buf)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_getdents_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(buf)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -399,7 +377,6 @@ func getdents(fd int, buf []byte) (n int, err error) {
 
 func libc_getdents_trampoline()
 
-//go:linkname libc_getdents libc_getdents
 //go:cgo_import_dynamic libc_getdents getdents "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -410,7 +387,7 @@ func Access(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -419,13 +396,12 @@ func Access(path string, mode uint32) (err error) {
 
 func libc_access_trampoline()
 
-//go:linkname libc_access libc_access
 //go:cgo_import_dynamic libc_access access "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Adjtime(delta *Timeval, olddelta *Timeval) (err error) {
-	_, _, e1 := syscall(funcPC(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -434,7 +410,6 @@ func Adjtime(delta *Timeval, olddelta *Timeval) (err error) {
 
 func libc_adjtime_trampoline()
 
-//go:linkname libc_adjtime libc_adjtime
 //go:cgo_import_dynamic libc_adjtime adjtime "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -445,7 +420,7 @@ func Chdir(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -454,7 +429,6 @@ func Chdir(path string) (err error) {
 
 func libc_chdir_trampoline()
 
-//go:linkname libc_chdir libc_chdir
 //go:cgo_import_dynamic libc_chdir chdir "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -465,7 +439,7 @@ func Chflags(path string, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -474,7 +448,6 @@ func Chflags(path string, flags int) (err error) {
 
 func libc_chflags_trampoline()
 
-//go:linkname libc_chflags libc_chflags
 //go:cgo_import_dynamic libc_chflags chflags "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -485,7 +458,7 @@ func Chmod(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -494,7 +467,6 @@ func Chmod(path string, mode uint32) (err error) {
 
 func libc_chmod_trampoline()
 
-//go:linkname libc_chmod libc_chmod
 //go:cgo_import_dynamic libc_chmod chmod "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -505,7 +477,7 @@ func Chown(path string, uid int, gid int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -514,7 +486,6 @@ func Chown(path string, uid int, gid int) (err error) {
 
 func libc_chown_trampoline()
 
-//go:linkname libc_chown libc_chown
 //go:cgo_import_dynamic libc_chown chown "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -525,7 +496,7 @@ func Chroot(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -534,13 +505,12 @@ func Chroot(path string) (err error) {
 
 func libc_chroot_trampoline()
 
-//go:linkname libc_chroot libc_chroot
 //go:cgo_import_dynamic libc_chroot chroot "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Close(fd int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_close_trampoline), uintptr(fd), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_close_trampoline), uintptr(fd), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -549,13 +519,12 @@ func Close(fd int) (err error) {
 
 func libc_close_trampoline()
 
-//go:linkname libc_close libc_close
 //go:cgo_import_dynamic libc_close close "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Dup(fd int) (nfd int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_dup_trampoline), uintptr(fd), 0, 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_dup_trampoline), uintptr(fd), 0, 0)
 	nfd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -565,13 +534,12 @@ func Dup(fd int) (nfd int, err error) {
 
 func libc_dup_trampoline()
 
-//go:linkname libc_dup libc_dup
 //go:cgo_import_dynamic libc_dup dup "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Dup2(from int, to int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_dup2_trampoline), uintptr(from), uintptr(to), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_dup2_trampoline), uintptr(from), uintptr(to), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -580,13 +548,12 @@ func Dup2(from int, to int) (err error) {
 
 func libc_dup2_trampoline()
 
-//go:linkname libc_dup2 libc_dup2
 //go:cgo_import_dynamic libc_dup2 dup2 "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchdir(fd int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fchdir_trampoline), uintptr(fd), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fchdir_trampoline), uintptr(fd), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -595,13 +562,12 @@ func Fchdir(fd int) (err error) {
 
 func libc_fchdir_trampoline()
 
-//go:linkname libc_fchdir libc_fchdir
 //go:cgo_import_dynamic libc_fchdir fchdir "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchflags(fd int, flags int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fchflags_trampoline), uintptr(fd), uintptr(flags), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fchflags_trampoline), uintptr(fd), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -610,13 +576,12 @@ func Fchflags(fd int, flags int) (err error) {
 
 func libc_fchflags_trampoline()
 
-//go:linkname libc_fchflags libc_fchflags
 //go:cgo_import_dynamic libc_fchflags fchflags "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchmod(fd int, mode uint32) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fchmod_trampoline), uintptr(fd), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fchmod_trampoline), uintptr(fd), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -625,13 +590,12 @@ func Fchmod(fd int, mode uint32) (err error) {
 
 func libc_fchmod_trampoline()
 
-//go:linkname libc_fchmod libc_fchmod
 //go:cgo_import_dynamic libc_fchmod fchmod "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchown(fd int, uid int, gid int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fchown_trampoline), uintptr(fd), uintptr(uid), uintptr(gid))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fchown_trampoline), uintptr(fd), uintptr(uid), uintptr(gid))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -640,13 +604,12 @@ func Fchown(fd int, uid int, gid int) (err error) {
 
 func libc_fchown_trampoline()
 
-//go:linkname libc_fchown libc_fchown
 //go:cgo_import_dynamic libc_fchown fchown "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Flock(fd int, how int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_flock_trampoline), uintptr(fd), uintptr(how), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_flock_trampoline), uintptr(fd), uintptr(how), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -655,13 +618,12 @@ func Flock(fd int, how int) (err error) {
 
 func libc_flock_trampoline()
 
-//go:linkname libc_flock libc_flock
 //go:cgo_import_dynamic libc_flock flock "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fpathconf(fd int, name int) (val int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_fpathconf_trampoline), uintptr(fd), uintptr(name), 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_fpathconf_trampoline), uintptr(fd), uintptr(name), 0)
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -671,13 +633,12 @@ func Fpathconf(fd int, name int) (val int, err error) {
 
 func libc_fpathconf_trampoline()
 
-//go:linkname libc_fpathconf libc_fpathconf
 //go:cgo_import_dynamic libc_fpathconf fpathconf "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fstat(fd int, stat *Stat_t) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fstat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fstat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -686,13 +647,12 @@ func Fstat(fd int, stat *Stat_t) (err error) {
 
 func libc_fstat_trampoline()
 
-//go:linkname libc_fstat libc_fstat
 //go:cgo_import_dynamic libc_fstat fstat "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fstatfs(fd int, stat *Statfs_t) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fstatfs_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fstatfs_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -701,13 +661,12 @@ func Fstatfs(fd int, stat *Statfs_t) (err error) {
 
 func libc_fstatfs_trampoline()
 
-//go:linkname libc_fstatfs libc_fstatfs
 //go:cgo_import_dynamic libc_fstatfs fstatfs "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fsync(fd int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_fsync_trampoline), uintptr(fd), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fsync_trampoline), uintptr(fd), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -716,13 +675,12 @@ func Fsync(fd int) (err error) {
 
 func libc_fsync_trampoline()
 
-//go:linkname libc_fsync libc_fsync
 //go:cgo_import_dynamic libc_fsync fsync "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Ftruncate(fd int, length int64) (err error) {
-	_, _, e1 := syscall(funcPC(libc_ftruncate_trampoline), uintptr(fd), uintptr(length), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_ftruncate_trampoline), uintptr(fd), uintptr(length), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -731,52 +689,48 @@ func Ftruncate(fd int, length int64) (err error) {
 
 func libc_ftruncate_trampoline()
 
-//go:linkname libc_ftruncate libc_ftruncate
 //go:cgo_import_dynamic libc_ftruncate ftruncate "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getegid() (egid int) {
-	r0, _, _ := rawSyscall(funcPC(libc_getegid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getegid_trampoline), 0, 0, 0)
 	egid = int(r0)
 	return
 }
 
 func libc_getegid_trampoline()
 
-//go:linkname libc_getegid libc_getegid
 //go:cgo_import_dynamic libc_getegid getegid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Geteuid() (uid int) {
-	r0, _, _ := rawSyscall(funcPC(libc_geteuid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_geteuid_trampoline), 0, 0, 0)
 	uid = int(r0)
 	return
 }
 
 func libc_geteuid_trampoline()
 
-//go:linkname libc_geteuid libc_geteuid
 //go:cgo_import_dynamic libc_geteuid geteuid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getgid() (gid int) {
-	r0, _, _ := rawSyscall(funcPC(libc_getgid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getgid_trampoline), 0, 0, 0)
 	gid = int(r0)
 	return
 }
 
 func libc_getgid_trampoline()
 
-//go:linkname libc_getgid libc_getgid
 //go:cgo_import_dynamic libc_getgid getgid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpgid(pid int) (pgid int, err error) {
-	r0, _, e1 := rawSyscall(funcPC(libc_getpgid_trampoline), uintptr(pid), 0, 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getpgid_trampoline), uintptr(pid), 0, 0)
 	pgid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -786,52 +740,48 @@ func Getpgid(pid int) (pgid int, err error) {
 
 func libc_getpgid_trampoline()
 
-//go:linkname libc_getpgid libc_getpgid
 //go:cgo_import_dynamic libc_getpgid getpgid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpgrp() (pgrp int) {
-	r0, _, _ := rawSyscall(funcPC(libc_getpgrp_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getpgrp_trampoline), 0, 0, 0)
 	pgrp = int(r0)
 	return
 }
 
 func libc_getpgrp_trampoline()
 
-//go:linkname libc_getpgrp libc_getpgrp
 //go:cgo_import_dynamic libc_getpgrp getpgrp "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpid() (pid int) {
-	r0, _, _ := rawSyscall(funcPC(libc_getpid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getpid_trampoline), 0, 0, 0)
 	pid = int(r0)
 	return
 }
 
 func libc_getpid_trampoline()
 
-//go:linkname libc_getpid libc_getpid
 //go:cgo_import_dynamic libc_getpid getpid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getppid() (ppid int) {
-	r0, _, _ := rawSyscall(funcPC(libc_getppid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getppid_trampoline), 0, 0, 0)
 	ppid = int(r0)
 	return
 }
 
 func libc_getppid_trampoline()
 
-//go:linkname libc_getppid libc_getppid
 //go:cgo_import_dynamic libc_getppid getppid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpriority(which int, who int) (prio int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_getpriority_trampoline), uintptr(which), uintptr(who), 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_getpriority_trampoline), uintptr(which), uintptr(who), 0)
 	prio = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -841,13 +791,12 @@ func Getpriority(which int, who int) (prio int, err error) {
 
 func libc_getpriority_trampoline()
 
-//go:linkname libc_getpriority libc_getpriority
 //go:cgo_import_dynamic libc_getpriority getpriority "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getrlimit(which int, lim *Rlimit) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -856,13 +805,12 @@ func Getrlimit(which int, lim *Rlimit) (err error) {
 
 func libc_getrlimit_trampoline()
 
-//go:linkname libc_getrlimit libc_getrlimit
 //go:cgo_import_dynamic libc_getrlimit getrlimit "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getrusage(who int, rusage *Rusage) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -871,13 +819,12 @@ func Getrusage(who int, rusage *Rusage) (err error) {
 
 func libc_getrusage_trampoline()
 
-//go:linkname libc_getrusage libc_getrusage
 //go:cgo_import_dynamic libc_getrusage getrusage "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getsid(pid int) (sid int, err error) {
-	r0, _, e1 := rawSyscall(funcPC(libc_getsid_trampoline), uintptr(pid), 0, 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getsid_trampoline), uintptr(pid), 0, 0)
 	sid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -887,13 +834,12 @@ func Getsid(pid int) (sid int, err error) {
 
 func libc_getsid_trampoline()
 
-//go:linkname libc_getsid libc_getsid
 //go:cgo_import_dynamic libc_getsid getsid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Gettimeofday(tv *Timeval) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tv)), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tv)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -902,39 +848,36 @@ func Gettimeofday(tv *Timeval) (err error) {
 
 func libc_gettimeofday_trampoline()
 
-//go:linkname libc_gettimeofday libc_gettimeofday
 //go:cgo_import_dynamic libc_gettimeofday gettimeofday "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getuid() (uid int) {
-	r0, _, _ := rawSyscall(funcPC(libc_getuid_trampoline), 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getuid_trampoline), 0, 0, 0)
 	uid = int(r0)
 	return
 }
 
 func libc_getuid_trampoline()
 
-//go:linkname libc_getuid libc_getuid
 //go:cgo_import_dynamic libc_getuid getuid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Issetugid() (tainted bool) {
-	r0, _, _ := syscall(funcPC(libc_issetugid_trampoline), 0, 0, 0)
+	r0, _, _ := syscall(abi.FuncPCABI0(libc_issetugid_trampoline), 0, 0, 0)
 	tainted = bool(r0 != 0)
 	return
 }
 
 func libc_issetugid_trampoline()
 
-//go:linkname libc_issetugid libc_issetugid
 //go:cgo_import_dynamic libc_issetugid issetugid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Kill(pid int, signum Signal) (err error) {
-	_, _, e1 := syscall(funcPC(libc_kill_trampoline), uintptr(pid), uintptr(signum), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_kill_trampoline), uintptr(pid), uintptr(signum), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -943,13 +886,12 @@ func Kill(pid int, signum Signal) (err error) {
 
 func libc_kill_trampoline()
 
-//go:linkname libc_kill libc_kill
 //go:cgo_import_dynamic libc_kill kill "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Kqueue() (fd int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_kqueue_trampoline), 0, 0, 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_kqueue_trampoline), 0, 0, 0)
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -959,7 +901,6 @@ func Kqueue() (fd int, err error) {
 
 func libc_kqueue_trampoline()
 
-//go:linkname libc_kqueue libc_kqueue
 //go:cgo_import_dynamic libc_kqueue kqueue "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -970,7 +911,7 @@ func Lchown(path string, uid int, gid int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -979,7 +920,6 @@ func Lchown(path string, uid int, gid int) (err error) {
 
 func libc_lchown_trampoline()
 
-//go:linkname libc_lchown libc_lchown
 //go:cgo_import_dynamic libc_lchown lchown "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -995,7 +935,7 @@ func Link(path string, link string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1004,13 +944,12 @@ func Link(path string, link string) (err error) {
 
 func libc_link_trampoline()
 
-//go:linkname libc_link libc_link
 //go:cgo_import_dynamic libc_link link "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Listen(s int, backlog int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_listen_trampoline), uintptr(s), uintptr(backlog), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_listen_trampoline), uintptr(s), uintptr(backlog), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1019,7 +958,6 @@ func Listen(s int, backlog int) (err error) {
 
 func libc_listen_trampoline()
 
-//go:linkname libc_listen libc_listen
 //go:cgo_import_dynamic libc_listen listen "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1030,7 +968,7 @@ func Lstat(path string, stat *Stat_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_lstat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_lstat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1039,7 +977,6 @@ func Lstat(path string, stat *Stat_t) (err error) {
 
 func libc_lstat_trampoline()
 
-//go:linkname libc_lstat libc_lstat
 //go:cgo_import_dynamic libc_lstat lstat "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1050,7 +987,7 @@ func Mkdir(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1059,7 +996,6 @@ func Mkdir(path string, mode uint32) (err error) {
 
 func libc_mkdir_trampoline()
 
-//go:linkname libc_mkdir libc_mkdir
 //go:cgo_import_dynamic libc_mkdir mkdir "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1070,7 +1006,7 @@ func Mkfifo(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1079,7 +1015,6 @@ func Mkfifo(path string, mode uint32) (err error) {
 
 func libc_mkfifo_trampoline()
 
-//go:linkname libc_mkfifo libc_mkfifo
 //go:cgo_import_dynamic libc_mkfifo mkfifo "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1090,7 +1025,7 @@ func Mknod(path string, mode uint32, dev int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1099,13 +1034,12 @@ func Mknod(path string, mode uint32, dev int) (err error) {
 
 func libc_mknod_trampoline()
 
-//go:linkname libc_mknod libc_mknod
 //go:cgo_import_dynamic libc_mknod mknod "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Nanosleep(time *Timespec, leftover *Timespec) (err error) {
-	_, _, e1 := syscall(funcPC(libc_nanosleep_trampoline), uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_nanosleep_trampoline), uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1114,7 +1048,6 @@ func Nanosleep(time *Timespec, leftover *Timespec) (err error) {
 
 func libc_nanosleep_trampoline()
 
-//go:linkname libc_nanosleep libc_nanosleep
 //go:cgo_import_dynamic libc_nanosleep nanosleep "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1125,7 +1058,7 @@ func Open(path string, mode int, perm uint32) (fd int, err error) {
 	if err != nil {
 		return
 	}
-	r0, _, e1 := syscall(funcPC(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1135,7 +1068,6 @@ func Open(path string, mode int, perm uint32) (fd int, err error) {
 
 func libc_open_trampoline()
 
-//go:linkname libc_open libc_open
 //go:cgo_import_dynamic libc_open open "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1146,7 +1078,7 @@ func Pathconf(path string, name int) (val int, err error) {
 	if err != nil {
 		return
 	}
-	r0, _, e1 := syscall(funcPC(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1156,7 +1088,6 @@ func Pathconf(path string, name int) (val int, err error) {
 
 func libc_pathconf_trampoline()
 
-//go:linkname libc_pathconf libc_pathconf
 //go:cgo_import_dynamic libc_pathconf pathconf "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1168,7 +1099,7 @@ func Pread(fd int, p []byte, offset int64) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall6(funcPC(libc_pread_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_pread_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1178,7 +1109,6 @@ func Pread(fd int, p []byte, offset int64) (n int, err error) {
 
 func libc_pread_trampoline()
 
-//go:linkname libc_pread libc_pread
 //go:cgo_import_dynamic libc_pread pread "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1190,7 +1120,7 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall6(funcPC(libc_pwrite_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_pwrite_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1200,7 +1130,6 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
 
 func libc_pwrite_trampoline()
 
-//go:linkname libc_pwrite libc_pwrite
 //go:cgo_import_dynamic libc_pwrite pwrite "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1212,7 +1141,7 @@ func read(fd int, p []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_read_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1222,7 +1151,6 @@ func read(fd int, p []byte) (n int, err error) {
 
 func libc_read_trampoline()
 
-//go:linkname libc_read libc_read
 //go:cgo_import_dynamic libc_read read "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1239,7 +1167,7 @@ func Readlink(path string, buf []byte) (n int, err error) {
 	} else {
 		_p1 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall(funcPC(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1249,7 +1177,6 @@ func Readlink(path string, buf []byte) (n int, err error) {
 
 func libc_readlink_trampoline()
 
-//go:linkname libc_readlink libc_readlink
 //go:cgo_import_dynamic libc_readlink readlink "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1265,7 +1192,7 @@ func Rename(from string, to string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1274,7 +1201,6 @@ func Rename(from string, to string) (err error) {
 
 func libc_rename_trampoline()
 
-//go:linkname libc_rename libc_rename
 //go:cgo_import_dynamic libc_rename rename "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1285,7 +1211,7 @@ func Revoke(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1294,7 +1220,6 @@ func Revoke(path string) (err error) {
 
 func libc_revoke_trampoline()
 
-//go:linkname libc_revoke libc_revoke
 //go:cgo_import_dynamic libc_revoke revoke "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1305,7 +1230,7 @@ func Rmdir(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1314,13 +1239,12 @@ func Rmdir(path string) (err error) {
 
 func libc_rmdir_trampoline()
 
-//go:linkname libc_rmdir libc_rmdir
 //go:cgo_import_dynamic libc_rmdir rmdir "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (err error) {
-	_, _, e1 := syscall6(funcPC(libc_select_trampoline), uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_select_trampoline), uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1329,13 +1253,12 @@ func Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (err error) {
 
 func libc_select_trampoline()
 
-//go:linkname libc_select libc_select
 //go:cgo_import_dynamic libc_select select "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setegid(egid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setegid_trampoline), uintptr(egid), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setegid_trampoline), uintptr(egid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1344,13 +1267,12 @@ func Setegid(egid int) (err error) {
 
 func libc_setegid_trampoline()
 
-//go:linkname libc_setegid libc_setegid
 //go:cgo_import_dynamic libc_setegid setegid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Seteuid(euid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_seteuid_trampoline), uintptr(euid), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_seteuid_trampoline), uintptr(euid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1359,13 +1281,12 @@ func Seteuid(euid int) (err error) {
 
 func libc_seteuid_trampoline()
 
-//go:linkname libc_seteuid libc_seteuid
 //go:cgo_import_dynamic libc_seteuid seteuid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setgid(gid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setgid_trampoline), uintptr(gid), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setgid_trampoline), uintptr(gid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1374,7 +1295,6 @@ func Setgid(gid int) (err error) {
 
 func libc_setgid_trampoline()
 
-//go:linkname libc_setgid libc_setgid
 //go:cgo_import_dynamic libc_setgid setgid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1385,7 +1305,7 @@ func Setlogin(name string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1394,13 +1314,12 @@ func Setlogin(name string) (err error) {
 
 func libc_setlogin_trampoline()
 
-//go:linkname libc_setlogin libc_setlogin
 //go:cgo_import_dynamic libc_setlogin setlogin "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setpgid(pid int, pgid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setpgid_trampoline), uintptr(pid), uintptr(pgid), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setpgid_trampoline), uintptr(pid), uintptr(pgid), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1409,13 +1328,12 @@ func Setpgid(pid int, pgid int) (err error) {
 
 func libc_setpgid_trampoline()
 
-//go:linkname libc_setpgid libc_setpgid
 //go:cgo_import_dynamic libc_setpgid setpgid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setpriority(which int, who int, prio int) (err error) {
-	_, _, e1 := syscall(funcPC(libc_setpriority_trampoline), uintptr(which), uintptr(who), uintptr(prio))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_setpriority_trampoline), uintptr(which), uintptr(who), uintptr(prio))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1424,13 +1342,12 @@ func Setpriority(which int, who int, prio int) (err error) {
 
 func libc_setpriority_trampoline()
 
-//go:linkname libc_setpriority libc_setpriority
 //go:cgo_import_dynamic libc_setpriority setpriority "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setregid(rgid int, egid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setregid_trampoline), uintptr(rgid), uintptr(egid), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setregid_trampoline), uintptr(rgid), uintptr(egid), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1439,13 +1356,12 @@ func Setregid(rgid int, egid int) (err error) {
 
 func libc_setregid_trampoline()
 
-//go:linkname libc_setregid libc_setregid
 //go:cgo_import_dynamic libc_setregid setregid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setreuid(ruid int, euid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setreuid_trampoline), uintptr(ruid), uintptr(euid), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setreuid_trampoline), uintptr(ruid), uintptr(euid), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1454,13 +1370,12 @@ func Setreuid(ruid int, euid int) (err error) {
 
 func libc_setreuid_trampoline()
 
-//go:linkname libc_setreuid libc_setreuid
 //go:cgo_import_dynamic libc_setreuid setreuid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setrlimit(which int, lim *Rlimit) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1469,13 +1384,12 @@ func Setrlimit(which int, lim *Rlimit) (err error) {
 
 func libc_setrlimit_trampoline()
 
-//go:linkname libc_setrlimit libc_setrlimit
 //go:cgo_import_dynamic libc_setrlimit setrlimit "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setsid() (pid int, err error) {
-	r0, _, e1 := rawSyscall(funcPC(libc_setsid_trampoline), 0, 0, 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setsid_trampoline), 0, 0, 0)
 	pid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1485,13 +1399,12 @@ func Setsid() (pid int, err error) {
 
 func libc_setsid_trampoline()
 
-//go:linkname libc_setsid libc_setsid
 //go:cgo_import_dynamic libc_setsid setsid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Settimeofday(tp *Timeval) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1500,13 +1413,12 @@ func Settimeofday(tp *Timeval) (err error) {
 
 func libc_settimeofday_trampoline()
 
-//go:linkname libc_settimeofday libc_settimeofday
 //go:cgo_import_dynamic libc_settimeofday settimeofday "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setuid(uid int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_setuid_trampoline), uintptr(uid), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setuid_trampoline), uintptr(uid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1515,7 +1427,6 @@ func Setuid(uid int) (err error) {
 
 func libc_setuid_trampoline()
 
-//go:linkname libc_setuid libc_setuid
 //go:cgo_import_dynamic libc_setuid setuid "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1526,7 +1437,7 @@ func Stat(path string, stat *Stat_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_stat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_stat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1535,7 +1446,6 @@ func Stat(path string, stat *Stat_t) (err error) {
 
 func libc_stat_trampoline()
 
-//go:linkname libc_stat libc_stat
 //go:cgo_import_dynamic libc_stat stat "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1546,7 +1456,7 @@ func Statfs(path string, stat *Statfs_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_statfs_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_statfs_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1555,7 +1465,6 @@ func Statfs(path string, stat *Statfs_t) (err error) {
 
 func libc_statfs_trampoline()
 
-//go:linkname libc_statfs libc_statfs
 //go:cgo_import_dynamic libc_statfs statfs "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1571,7 +1480,7 @@ func Symlink(path string, link string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1580,13 +1489,12 @@ func Symlink(path string, link string) (err error) {
 
 func libc_symlink_trampoline()
 
-//go:linkname libc_symlink libc_symlink
 //go:cgo_import_dynamic libc_symlink symlink "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Sync() (err error) {
-	_, _, e1 := syscall(funcPC(libc_sync_trampoline), 0, 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_sync_trampoline), 0, 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1595,7 +1503,6 @@ func Sync() (err error) {
 
 func libc_sync_trampoline()
 
-//go:linkname libc_sync libc_sync
 //go:cgo_import_dynamic libc_sync sync "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1606,7 +1513,7 @@ func Truncate(path string, length int64) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1615,20 +1522,18 @@ func Truncate(path string, length int64) (err error) {
 
 func libc_truncate_trampoline()
 
-//go:linkname libc_truncate libc_truncate
 //go:cgo_import_dynamic libc_truncate truncate "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Umask(newmask int) (oldmask int) {
-	r0, _, _ := syscall(funcPC(libc_umask_trampoline), uintptr(newmask), 0, 0)
+	r0, _, _ := syscall(abi.FuncPCABI0(libc_umask_trampoline), uintptr(newmask), 0, 0)
 	oldmask = int(r0)
 	return
 }
 
 func libc_umask_trampoline()
 
-//go:linkname libc_umask libc_umask
 //go:cgo_import_dynamic libc_umask umask "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1639,7 +1544,7 @@ func Unlink(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1648,7 +1553,6 @@ func Unlink(path string) (err error) {
 
 func libc_unlink_trampoline()
 
-//go:linkname libc_unlink libc_unlink
 //go:cgo_import_dynamic libc_unlink unlink "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1659,7 +1563,7 @@ func Unmount(path string, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1668,7 +1572,6 @@ func Unmount(path string, flags int) (err error) {
 
 func libc_unmount_trampoline()
 
-//go:linkname libc_unmount libc_unmount
 //go:cgo_import_dynamic libc_unmount unmount "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1680,7 +1583,7 @@ func write(fd int, p []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_write_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1690,13 +1593,12 @@ func write(fd int, p []byte) (n int, err error) {
 
 func libc_write_trampoline()
 
-//go:linkname libc_write libc_write
 //go:cgo_import_dynamic libc_write write "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
-	r0, _, e1 := syscall6X(funcPC(libc_mmap_trampoline), uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
+	r0, _, e1 := syscall6X(abi.FuncPCABI0(libc_mmap_trampoline), uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
 	ret = uintptr(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1706,13 +1608,12 @@ func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (
 
 func libc_mmap_trampoline()
 
-//go:linkname libc_mmap libc_mmap
 //go:cgo_import_dynamic libc_mmap mmap "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func munmap(addr uintptr, length uintptr) (err error) {
-	_, _, e1 := syscall(funcPC(libc_munmap_trampoline), uintptr(addr), uintptr(length), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_munmap_trampoline), uintptr(addr), uintptr(length), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1721,7 +1622,6 @@ func munmap(addr uintptr, length uintptr) (err error) {
 
 func libc_munmap_trampoline()
 
-//go:linkname libc_munmap libc_munmap
 //go:cgo_import_dynamic libc_munmap munmap "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1732,7 +1632,7 @@ func utimensat(dirfd int, path string, times *[2]Timespec, flag int) (err error)
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall6(funcPC(libc_utimensat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), uintptr(flag), 0, 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_utimensat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), uintptr(flag), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1741,13 +1641,12 @@ func utimensat(dirfd int, path string, times *[2]Timespec, flag int) (err error)
 
 func libc_utimensat_trampoline()
 
-//go:linkname libc_utimensat libc_utimensat
 //go:cgo_import_dynamic libc_utimensat utimensat "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func directSyscall(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr) (ret uintptr, err error) {
-	r0, _, e1 := syscall6X(funcPC(libc_syscall_trampoline), uintptr(trap), uintptr(a1), uintptr(a2), uintptr(a3), uintptr(a4), uintptr(a5))
+	r0, _, e1 := syscall6X(abi.FuncPCABI0(libc_syscall_trampoline), uintptr(trap), uintptr(a1), uintptr(a2), uintptr(a3), uintptr(a4), uintptr(a5))
 	ret = uintptr(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1757,13 +1656,12 @@ func directSyscall(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr,
 
 func libc_syscall_trampoline()
 
-//go:linkname libc_syscall libc_syscall
 //go:cgo_import_dynamic libc_syscall syscall "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1774,7 +1672,7 @@ func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1785,7 +1683,7 @@ func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
-	r0, _, e1 := syscallX(funcPC(libc_lseek_trampoline), uintptr(fd), uintptr(offset), uintptr(whence))
+	r0, _, e1 := syscallX(abi.FuncPCABI0(libc_lseek_trampoline), uintptr(fd), uintptr(offset), uintptr(whence))
 	newoffset = int64(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1795,7 +1693,6 @@ func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
 
 func libc_lseek_trampoline()
 
-//go:linkname libc_lseek libc_lseek
 //go:cgo_import_dynamic libc_lseek lseek "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1807,7 +1704,7 @@ func getcwd(buf []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall(funcPC(libc_getcwd_trampoline), uintptr(_p0), uintptr(len(buf)), 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_getcwd_trampoline), uintptr(_p0), uintptr(len(buf)), 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1817,7 +1714,6 @@ func getcwd(buf []byte) (n int, err error) {
 
 func libc_getcwd_trampoline()
 
-//go:linkname libc_getcwd libc_getcwd
 //go:cgo_import_dynamic libc_getcwd getcwd "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1829,7 +1725,7 @@ func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr)
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall6(funcPC(libc_sysctl_trampoline), uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_sysctl_trampoline), uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1838,13 +1734,12 @@ func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr)
 
 func libc_sysctl_trampoline()
 
-//go:linkname libc_sysctl libc_sysctl
 //go:cgo_import_dynamic libc_sysctl sysctl "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func fork() (pid int, err error) {
-	r0, _, e1 := rawSyscall(funcPC(libc_fork_trampoline), 0, 0, 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_fork_trampoline), 0, 0, 0)
 	pid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1854,13 +1749,12 @@ func fork() (pid int, err error) {
 
 func libc_fork_trampoline()
 
-//go:linkname libc_fork libc_fork
 //go:cgo_import_dynamic libc_fork fork "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func ioctl(fd int, req int, arg int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1869,13 +1763,12 @@ func ioctl(fd int, req int, arg int) (err error) {
 
 func libc_ioctl_trampoline()
 
-//go:linkname libc_ioctl libc_ioctl
 //go:cgo_import_dynamic libc_ioctl ioctl "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func execve(path *byte, argv **byte, envp **byte) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_execve_trampoline), uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(argv)), uintptr(unsafe.Pointer(envp)))
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_execve_trampoline), uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(argv)), uintptr(unsafe.Pointer(envp)))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1884,13 +1777,12 @@ func execve(path *byte, argv **byte, envp **byte) (err error) {
 
 func libc_execve_trampoline()
 
-//go:linkname libc_execve libc_execve
 //go:cgo_import_dynamic libc_execve execve "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func exit(res int) (err error) {
-	_, _, e1 := rawSyscall(funcPC(libc_exit_trampoline), uintptr(res), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_exit_trampoline), uintptr(res), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1899,14 +1791,13 @@ func exit(res int) (err error) {
 
 func libc_exit_trampoline()
 
-//go:linkname libc_exit libc_exit
 //go:cgo_import_dynamic libc_exit exit "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 //go:nosplit
 func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
-	_, _, e1 := syscall6(funcPC(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1915,7 +1806,6 @@ func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
 
 func libc_ptrace_trampoline()
 
-//go:linkname libc_ptrace libc_ptrace
 //go:cgo_import_dynamic libc_ptrace ptrace "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1927,7 +1817,7 @@ func getentropy(p []byte) (err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := rawSyscall(funcPC(libc_getentropy_trampoline), uintptr(_p0), uintptr(len(p)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getentropy_trampoline), uintptr(_p0), uintptr(len(p)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1936,7 +1826,6 @@ func getentropy(p []byte) (err error) {
 
 func libc_getentropy_trampoline()
 
-//go:linkname libc_getentropy libc_getentropy
 //go:cgo_import_dynamic libc_getentropy getentropy "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1947,7 +1836,7 @@ func fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall6(funcPC(libc_fstatat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_fstatat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1956,13 +1845,12 @@ func fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
 
 func libc_fstatat_trampoline()
 
-//go:linkname libc_fstatat libc_fstatat
 //go:cgo_import_dynamic libc_fstatat fstatat "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func fcntlPtr(fd int, cmd int, arg unsafe.Pointer) (val int, err error) {
-	r0, _, e1 := syscall(funcPC(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1978,7 +1866,7 @@ func unlinkat(fd int, path string, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall(funcPC(libc_unlinkat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_unlinkat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -1987,7 +1875,6 @@ func unlinkat(fd int, path string, flags int) (err error) {
 
 func libc_unlinkat_trampoline()
 
-//go:linkname libc_unlinkat libc_unlinkat
 //go:cgo_import_dynamic libc_unlinkat unlinkat "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
@@ -1998,7 +1885,7 @@ func openat(fd int, path string, flags int, perm uint32) (fdret int, err error)
 	if err != nil {
 		return
 	}
-	r0, _, e1 := syscall6(funcPC(libc_openat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(perm), 0, 0)
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_openat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(perm), 0, 0)
 	fdret = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -2008,5 +1895,4 @@ func openat(fd int, path string, flags int, perm uint32) (fdret int, err error)
 
 func libc_openat_trampoline()
 
-//go:linkname libc_openat libc_openat
 //go:cgo_import_dynamic libc_openat openat "libc.so"
diff --git a/src/syscall/zsyscall_openbsd_arm64.s b/src/syscall/zsyscall_openbsd_arm64.s
index f6e0a8da94..37778b1db5 100644
--- a/src/syscall/zsyscall_openbsd_arm64.s
+++ b/src/syscall/zsyscall_openbsd_arm64.s
@@ -1,233 +1,233 @@
 // go run mkasm.go openbsd arm64
 // Code generated by the command above; DO NOT EDIT.
 #include "textflag.h"
-TEXT ·libc_getgroups_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getgroups_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getgroups(SB)
-TEXT ·libc_setgroups_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setgroups_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setgroups(SB)
-TEXT ·libc_wait4_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_wait4_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_wait4(SB)
-TEXT ·libc_accept_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_accept_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_accept(SB)
-TEXT ·libc_bind_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_bind_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_bind(SB)
-TEXT ·libc_connect_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_connect_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_connect(SB)
-TEXT ·libc_socket_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_socket_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_socket(SB)
-TEXT ·libc_getsockopt_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getsockopt_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getsockopt(SB)
-TEXT ·libc_setsockopt_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setsockopt_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setsockopt(SB)
-TEXT ·libc_getpeername_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getpeername_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getpeername(SB)
-TEXT ·libc_getsockname_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getsockname_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getsockname(SB)
-TEXT ·libc_shutdown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_shutdown_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_shutdown(SB)
-TEXT ·libc_socketpair_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_socketpair_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_socketpair(SB)
-TEXT ·libc_recvfrom_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_recvfrom_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_recvfrom(SB)
-TEXT ·libc_sendto_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_sendto_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_sendto(SB)
-TEXT ·libc_recvmsg_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_recvmsg_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_recvmsg(SB)
-TEXT ·libc_sendmsg_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_sendmsg_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_sendmsg(SB)
-TEXT ·libc_kevent_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_kevent_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_kevent(SB)
-TEXT ·libc_utimes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_utimes_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_utimes(SB)
-TEXT ·libc_futimes_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_futimes_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_futimes(SB)
-TEXT ·libc_fcntl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fcntl_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fcntl(SB)
-TEXT ·libc_pipe2_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_pipe2_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_pipe2(SB)
-TEXT ·libc_accept4_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_accept4_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_accept4(SB)
-TEXT ·libc_getdents_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getdents_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getdents(SB)
-TEXT ·libc_access_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_access_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_access(SB)
-TEXT ·libc_adjtime_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_adjtime_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_adjtime(SB)
-TEXT ·libc_chdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_chdir_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_chdir(SB)
-TEXT ·libc_chflags_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_chflags_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_chflags(SB)
-TEXT ·libc_chmod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_chmod_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_chmod(SB)
-TEXT ·libc_chown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_chown_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_chown(SB)
-TEXT ·libc_chroot_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_chroot_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_chroot(SB)
-TEXT ·libc_close_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_close_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_close(SB)
-TEXT ·libc_dup_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_dup_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_dup(SB)
-TEXT ·libc_dup2_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_dup2_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_dup2(SB)
-TEXT ·libc_fchdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fchdir_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fchdir(SB)
-TEXT ·libc_fchflags_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fchflags_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fchflags(SB)
-TEXT ·libc_fchmod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fchmod_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fchmod(SB)
-TEXT ·libc_fchown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fchown_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fchown(SB)
-TEXT ·libc_flock_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_flock_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_flock(SB)
-TEXT ·libc_fpathconf_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fpathconf_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fpathconf(SB)
-TEXT ·libc_fstat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fstat_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fstat(SB)
-TEXT ·libc_fstatfs_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fstatfs_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fstatfs(SB)
-TEXT ·libc_fsync_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fsync_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fsync(SB)
-TEXT ·libc_ftruncate_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_ftruncate_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_ftruncate(SB)
-TEXT ·libc_getegid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getegid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getegid(SB)
-TEXT ·libc_geteuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_geteuid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_geteuid(SB)
-TEXT ·libc_getgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getgid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getgid(SB)
-TEXT ·libc_getpgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getpgid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getpgid(SB)
-TEXT ·libc_getpgrp_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getpgrp_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getpgrp(SB)
-TEXT ·libc_getpid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getpid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getpid(SB)
-TEXT ·libc_getppid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getppid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getppid(SB)
-TEXT ·libc_getpriority_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getpriority_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getpriority(SB)
-TEXT ·libc_getrlimit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getrlimit_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getrlimit(SB)
-TEXT ·libc_getrusage_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getrusage_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getrusage(SB)
-TEXT ·libc_getsid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getsid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getsid(SB)
-TEXT ·libc_gettimeofday_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_gettimeofday_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_gettimeofday(SB)
-TEXT ·libc_getuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getuid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getuid(SB)
-TEXT ·libc_issetugid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_issetugid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_issetugid(SB)
-TEXT ·libc_kill_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_kill_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_kill(SB)
-TEXT ·libc_kqueue_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_kqueue_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_kqueue(SB)
-TEXT ·libc_lchown_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_lchown_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_lchown(SB)
-TEXT ·libc_link_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_link_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_link(SB)
-TEXT ·libc_listen_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_listen_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_listen(SB)
-TEXT ·libc_lstat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_lstat_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_lstat(SB)
-TEXT ·libc_mkdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_mkdir_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_mkdir(SB)
-TEXT ·libc_mkfifo_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_mkfifo_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_mkfifo(SB)
-TEXT ·libc_mknod_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_mknod_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_mknod(SB)
-TEXT ·libc_nanosleep_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_nanosleep_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_nanosleep(SB)
-TEXT ·libc_open_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_open_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_open(SB)
-TEXT ·libc_pathconf_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_pathconf_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_pathconf(SB)
-TEXT ·libc_pread_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_pread_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_pread(SB)
-TEXT ·libc_pwrite_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_pwrite_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_pwrite(SB)
-TEXT ·libc_read_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_read_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_read(SB)
-TEXT ·libc_readlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_readlink_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_readlink(SB)
-TEXT ·libc_rename_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_rename_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_rename(SB)
-TEXT ·libc_revoke_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_revoke_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_revoke(SB)
-TEXT ·libc_rmdir_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_rmdir_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_rmdir(SB)
-TEXT ·libc_select_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_select_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_select(SB)
-TEXT ·libc_setegid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setegid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setegid(SB)
-TEXT ·libc_seteuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_seteuid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_seteuid(SB)
-TEXT ·libc_setgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setgid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setgid(SB)
-TEXT ·libc_setlogin_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setlogin_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setlogin(SB)
-TEXT ·libc_setpgid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setpgid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setpgid(SB)
-TEXT ·libc_setpriority_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setpriority_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setpriority(SB)
-TEXT ·libc_setregid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setregid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setregid(SB)
-TEXT ·libc_setreuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setreuid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setreuid(SB)
-TEXT ·libc_setrlimit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setrlimit_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setrlimit(SB)
-TEXT ·libc_setsid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setsid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setsid(SB)
-TEXT ·libc_settimeofday_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_settimeofday_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_settimeofday(SB)
-TEXT ·libc_setuid_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_setuid_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_setuid(SB)
-TEXT ·libc_stat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_stat_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_stat(SB)
-TEXT ·libc_statfs_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_statfs_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_statfs(SB)
-TEXT ·libc_symlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_symlink_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_symlink(SB)
-TEXT ·libc_sync_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_sync_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_sync(SB)
-TEXT ·libc_truncate_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_truncate_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_truncate(SB)
-TEXT ·libc_umask_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_umask_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_umask(SB)
-TEXT ·libc_unlink_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_unlink_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_unlink(SB)
-TEXT ·libc_unmount_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_unmount_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_unmount(SB)
-TEXT ·libc_write_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_write_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_write(SB)
-TEXT ·libc_mmap_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_mmap_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_mmap(SB)
-TEXT ·libc_munmap_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_munmap_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_munmap(SB)
-TEXT ·libc_utimensat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_utimensat_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_utimensat(SB)
-TEXT ·libc_syscall_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_syscall_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_syscall(SB)
-TEXT ·libc_lseek_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_lseek_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_lseek(SB)
-TEXT ·libc_getcwd_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getcwd_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getcwd(SB)
-TEXT ·libc_sysctl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_sysctl_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_sysctl(SB)
-TEXT ·libc_fork_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fork_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fork(SB)
-TEXT ·libc_ioctl_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_ioctl_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_ioctl(SB)
-TEXT ·libc_execve_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_execve_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_execve(SB)
-TEXT ·libc_exit_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_exit_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_exit(SB)
-TEXT ·libc_ptrace_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_ptrace_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_ptrace(SB)
-TEXT ·libc_getentropy_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_getentropy_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_getentropy(SB)
-TEXT ·libc_fstatat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_fstatat_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_fstatat(SB)
-TEXT ·libc_unlinkat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_unlinkat_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_unlinkat(SB)
-TEXT ·libc_openat_trampoline<ABIInternal>(SB),NOSPLIT,$0-0
+TEXT ·libc_openat_trampoline(SB),NOSPLIT,$0-0
 	JMP	libc_openat(SB)
-- 
GitLab


From d5d24dbe419c429b43046049d57b97b0abd42a87 Mon Sep 17 00:00:00 2001
From: Ruslan Andreev <ruslan.andreev@huawei.com>
Date: Wed, 10 Mar 2021 19:31:59 +0800
Subject: [PATCH 1761/2400] sync: improve sync.Pool object stealing
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This CL provide abilty to randomly select P to steal object from its
shared queue. In order to provide such ability randomOrder structure
was copied from runtime/proc.go.
It should reduce contention in firsts Ps and improve balance of object
stealing across all Ps. Also, the patch provides new benchmark
PoolStarvation which force Ps to steal objects.
Benchmarks:
name                old time/op     new time/op     delta
Pool-8                 2.16ns ±14%     2.14ns ±16%    ~     (p=0.425 n=10+10)
PoolOverflow-8          489ns ± 0%      489ns ± 0%    ~     (p=0.719 n=9+10)
PoolStarvation-8       7.00µs ± 4%     6.59µs ± 2%  -5.86%  (p=0.000 n=10+10)
PoolSTW-8              15.1µs ± 1%     15.2µs ± 1%  +0.99%  (p=0.001 n=10+10)
PoolExpensiveNew-8     1.25ms ±10%     1.31ms ± 9%    ~     (p=0.143 n=10+10)
[Geo mean]             2.68µs          2.68µs       -0.28%

name                old p50-ns/STW  new p50-ns/STW  delta
PoolSTW-8               15.0k ± 1%      15.1k ± 1%  +0.92%  (p=0.000 n=10+10)

name                old p95-ns/STW  new p95-ns/STW  delta
PoolSTW-8               16.2k ± 3%      16.4k ± 2%    ~     (p=0.143 n=10+10)

name                old GCs/op      new GCs/op      delta
PoolExpensiveNew-8       0.29 ± 2%       0.30 ± 1%  +2.84%  (p=0.000 n=8+10)

name                old New/op      new New/op      delta
PoolExpensiveNew-8       8.07 ±11%       8.49 ±10%    ~     (p=0.123 n=10+10)

Change-Id: I3ca1d0bf1f358b1148c58e64740fb2d5bfc0bc02
Reviewed-on: https://go-review.googlesource.com/c/go/+/303949
Reviewed-by: David Chase <drchase@google.com>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/sync/pool.go      | 103 ++++++++++++++++++++++++++++++++++++++----
 src/sync/pool_test.go |  18 ++++++++
 2 files changed, 111 insertions(+), 10 deletions(-)

diff --git a/src/sync/pool.go b/src/sync/pool.go
index 1ae70127ac..3fb4dc07de 100644
--- a/src/sync/pool.go
+++ b/src/sync/pool.go
@@ -70,6 +70,57 @@ type poolLocal struct {
 	pad [128 - unsafe.Sizeof(poolLocalInternal{})%128]byte
 }
 
+// The randomOrder and randomEnum are copied from runtime/proc.go
+type randomOrder struct {
+	count    uint32
+	coprimes []uint32
+}
+
+type randomEnum struct {
+	i     uint32
+	count uint32
+	pos   uint32
+	inc   uint32
+}
+
+func (ord *randomOrder) reset(count uint32) {
+	ord.count = count
+	ord.coprimes = ord.coprimes[:0]
+	for i := uint32(1); i <= count; i++ {
+		if gcd(i, count) == 1 {
+			ord.coprimes = append(ord.coprimes, i)
+		}
+	}
+}
+
+func (ord *randomOrder) start(i uint32) randomEnum {
+	return randomEnum{
+		count: ord.count,
+		pos:   i % ord.count,
+		inc:   ord.coprimes[i%uint32(len(ord.coprimes))],
+	}
+}
+
+func (enum *randomEnum) done() bool {
+	return enum.i == enum.count
+}
+
+func (enum *randomEnum) next() {
+	enum.i++
+	enum.pos = (enum.pos + enum.inc) % enum.count
+}
+
+func (enum *randomEnum) position() uint32 {
+	return enum.pos
+}
+
+func gcd(a, b uint32) uint32 {
+	for b != 0 {
+		a, b = b, a%b
+	}
+	return a
+}
+
 // from runtime
 func fastrand() uint32
 
@@ -153,12 +204,27 @@ func (p *Pool) Get() interface{} {
 func (p *Pool) getSlow(pid int) interface{} {
 	// See the comment in pin regarding ordering of the loads.
 	size := runtime_LoadAcquintptr(&p.localSize) // load-acquire
-	locals := p.local                            // load-consume
-	// Try to steal one element from other procs.
-	for i := 0; i < int(size); i++ {
-		l := indexLocal(locals, (pid+i+1)%int(size))
-		if x, _ := l.shared.popTail(); x != nil {
-			return x
+	// Load pOrder atomically to prevent possible races
+	order := (*randomOrder)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&pOrder)))) // load-consume
+
+	// Pin function always returns non-zero localSize, and it will remain so until runtime_procUnpin
+	// is called. This invariant is maintained by pin ensuring that locals is always big enough to
+	// account for the current P and that poolCleanup can never execute concurrently with a pinned P
+	// due to disabled preemtion.
+	// So, we can remove this condition which protects from division by zero in loop's body,
+	// but we leave it here just to be sure there is no any possibility for error
+	if size != 0 {
+		locals := p.local // load-consume
+		// Try to steal one element from other procs.
+		for rndp := order.start(fastrand()); !rndp.done(); rndp.next() {
+			i := int(rndp.position())
+			// While pOrder is limited to returning indexes within the range of Ps,
+			// locals may be smaller either because it was reset or because of a race
+			// with pinSlow. Hence, we must still mod the local index by size.
+			l := indexLocal(locals, (pid+i+1)%int(size))
+			if x, _ := l.shared.popTail(); x != nil {
+				return x
+			}
 		}
 	}
 
@@ -166,16 +232,25 @@ func (p *Pool) getSlow(pid int) interface{} {
 	// from all primary caches because we want objects in the
 	// victim cache to age out if at all possible.
 	size = atomic.LoadUintptr(&p.victimSize)
+
+	// We also have to ensure that victim cache is big enough to account current P
+	// and size is not equal to zero (protects from division by zero) similar as pin
+	// function do
 	if uintptr(pid) >= size {
 		return nil
 	}
-	locals = p.victim
+	locals := p.victim
 	l := indexLocal(locals, pid)
+
+	// Check private cache
 	if x := l.private; x != nil {
 		l.private = nil
 		return x
 	}
-	for i := 0; i < int(size); i++ {
+
+	// Try to fetch from the tail of other P queues
+	for rndp := order.start(fastrand()); !rndp.done(); rndp.next() {
+		i := int(rndp.position())
 		l := indexLocal(locals, (pid+i)%int(size))
 		if x, _ := l.shared.popTail(); x != nil {
 			return x
@@ -224,9 +299,13 @@ func (p *Pool) pinSlow() (*poolLocal, int) {
 	}
 	// If GOMAXPROCS changes between GCs, we re-allocate the array and lose the old one.
 	size := runtime.GOMAXPROCS(0)
+	// Set count of Ps for random ordering
+	order := &randomOrder{}
+	order.reset(uint32(size))
 	local := make([]poolLocal, size)
-	atomic.StorePointer(&p.local, unsafe.Pointer(&local[0])) // store-release
-	runtime_StoreReluintptr(&p.localSize, uintptr(size))     // store-release
+	atomic.StorePointer(&p.local, unsafe.Pointer(&local[0]))                               // store-release
+	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(&pOrder)), unsafe.Pointer(order)) // store-release
+	runtime_StoreReluintptr(&p.localSize, uintptr(size))                                   // store-release
 	return &local[pid], pid
 }
 
@@ -267,6 +346,10 @@ var (
 	// oldPools is the set of pools that may have non-empty victim
 	// caches. Protected by STW.
 	oldPools []*Pool
+
+	// pOrder is a random order of Ps used for stealing. Writes
+	// are protected by allPoolsMu. Reads are atomic.
+	pOrder *randomOrder
 )
 
 func init() {
diff --git a/src/sync/pool_test.go b/src/sync/pool_test.go
index 65666daab4..6cccd8a533 100644
--- a/src/sync/pool_test.go
+++ b/src/sync/pool_test.go
@@ -271,6 +271,24 @@ func BenchmarkPoolOverflow(b *testing.B) {
 	})
 }
 
+// Simulate object starvation in order to force Ps to steal objects
+// from other Ps.
+func BenchmarkPoolStarvation(b *testing.B) {
+	var p Pool
+	count := 100
+	count_starved := count - (count / runtime.GOMAXPROCS(0))
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			for b := 0; b < count_starved; b++ {
+				p.Put(1)
+			}
+			for b := 0; b < count; b++ {
+				p.Get()
+			}
+		}
+	})
+}
+
 var globalSink interface{}
 
 func BenchmarkPoolSTW(b *testing.B) {
-- 
GitLab


From d02026414cc0b292ee2aef4fbc36f185c56db0c8 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Fri, 23 Apr 2021 12:03:48 -0700
Subject: [PATCH 1762/2400] cmd/go: don't add generated SWIG C++ files to
 CompiledGoFiles

Also include SWIG C++ files in cgo hash.

For #28749
Fixes #37098

Change-Id: I6d912db2788200c2abdf328e382d4fbefda0a9ac
Reviewed-on: https://go-review.googlesource.com/c/go/+/313131
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go/internal/work/exec.go            |  8 ++++--
 src/cmd/go/testdata/script/list_swigcxx.txt | 27 +++++++++++++++++++++
 2 files changed, 33 insertions(+), 2 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/list_swigcxx.txt

diff --git a/src/cmd/go/internal/work/exec.go b/src/cmd/go/internal/work/exec.go
index ab9ce88c3c..38e826607e 100644
--- a/src/cmd/go/internal/work/exec.go
+++ b/src/cmd/go/internal/work/exec.go
@@ -246,11 +246,11 @@ func (b *Builder) buildActionID(a *Action) cache.ActionID {
 	if p.Internal.ForceLibrary {
 		fmt.Fprintf(h, "forcelibrary\n")
 	}
-	if len(p.CgoFiles)+len(p.SwigFiles) > 0 {
+	if len(p.CgoFiles)+len(p.SwigFiles)+len(p.SwigCXXFiles) > 0 {
 		fmt.Fprintf(h, "cgo %q\n", b.toolID("cgo"))
 		cppflags, cflags, cxxflags, fflags, ldflags, _ := b.CFlags(p)
 		fmt.Fprintf(h, "CC=%q %q %q %q\n", b.ccExe(), cppflags, cflags, ldflags)
-		if len(p.CXXFiles)+len(p.SwigFiles) > 0 {
+		if len(p.CXXFiles)+len(p.SwigCXXFiles) > 0 {
 			fmt.Fprintf(h, "CXX=%q %q\n", b.cxxExe(), cxxflags)
 		}
 		if len(p.FFiles) > 0 {
@@ -654,6 +654,10 @@ OverlayLoop:
 		}
 
 		outGo, outObj, err := b.cgo(a, base.Tool("cgo"), objdir, pcCFLAGS, pcLDFLAGS, mkAbsFiles(a.Package.Dir, cgofiles), gccfiles, cxxfiles, a.Package.MFiles, a.Package.FFiles)
+
+		// The files in cxxfiles have now been handled by b.cgo.
+		cxxfiles = nil
+
 		if err != nil {
 			return err
 		}
diff --git a/src/cmd/go/testdata/script/list_swigcxx.txt b/src/cmd/go/testdata/script/list_swigcxx.txt
new file mode 100644
index 0000000000..c6acd9ecdb
--- /dev/null
+++ b/src/cmd/go/testdata/script/list_swigcxx.txt
@@ -0,0 +1,27 @@
+# go list should not report SWIG-generated C++ files in CompiledGoFiles.
+
+[!exec:swig] skip
+[!exec:g++] skip
+
+# CompiledGoFiles should contain 4 files:
+#  a.go
+#  a.swigcxx.go
+#  _cgo_gotypes.go
+#  a.cgo1.go
+
+go list -f '{{.CompiledGoFiles}}' -compiled=true example/swig
+
+# These names we see here, other than a.go, will be from the build cache,
+# so we just count them.
+stdout a\.go
+stdout -count=3 $GOCACHE
+
+-- go.mod --
+module example
+
+go 1.16
+
+-- swig/a.go --
+package swig
+
+-- swig/a.swigcxx --
-- 
GitLab


From 14ade57ab8f2a6b9608fc3cab57957f39caead40 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Fri, 23 Apr 2021 22:20:55 +0000
Subject: [PATCH 1763/2400] runtime: fix scavenge min fraction constant floor
 division

Currently there's a minor bug where the constant for the min fraction of
time spent scavenging is rounded down to zero. I don't think this
affects anything in practice because this case is exceedingly rare and
extreme, but currently it doesn't properly prevent the pacing parameters
from getting out of hand in these extreme cases.

Fixes #44036.

Change-Id: I7de644ab0ecac33765c337a736482a0966882780
Reviewed-on: https://go-review.googlesource.com/c/go/+/313249
Reviewed-by: Michael Pratt <mpratt@google.com>
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/mgcscavenge.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/mgcscavenge.go b/src/runtime/mgcscavenge.go
index 7e32348670..7578129f9d 100644
--- a/src/runtime/mgcscavenge.go
+++ b/src/runtime/mgcscavenge.go
@@ -372,7 +372,7 @@ func bgscavenge() {
 		// Due to OS-related anomalies we may "sleep" for an inordinate amount
 		// of time. Let's avoid letting the ratio get out of hand by bounding
 		// the sleep time we use in our EWMA.
-		const minFraction = 1 / 1000
+		const minFraction = 1.0 / 1000.0
 		if fraction < minFraction {
 			fraction = minFraction
 		}
-- 
GitLab


From 8ff1da0b8182667560ed6bd3079ad7692e5c722b Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Mon, 26 Apr 2021 14:30:00 -0400
Subject: [PATCH 1764/2400] runtime: fix offset in comment

Change-Id: I2770195cb53220948081a6265f891ef064e4f763
Reviewed-on: https://go-review.googlesource.com/c/go/+/313629
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/sys_windows_amd64.s | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/sys_windows_amd64.s b/src/runtime/sys_windows_amd64.s
index 72ced3cd1c..ed44561084 100644
--- a/src/runtime/sys_windows_amd64.s
+++ b/src/runtime/sys_windows_amd64.s
@@ -148,7 +148,7 @@ TEXT sigtramp<>(SB),NOSPLIT|NOFRAME,$0-0
 	// and re-save old SP for restoring later.
 	// Adjust g0 stack by the space we're using and
 	// save SP at the same place on the g0 stack.
-	// The 32(DI) here must match the 32(SP) above.
+	// The 40(DI) here must match the 40(SP) above.
 	SUBQ	$(REGS_HOST_TO_ABI0_STACK + 48), DI
 	MOVQ	SP, 40(DI)
 	MOVQ	DI, SP
-- 
GitLab


From c4303139925d45b3e784d61dd3901f66c41189d4 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Fri, 23 Apr 2021 19:50:42 -0400
Subject: [PATCH 1765/2400] runtime: use abi.FuncPCABI0 for libc syscall
 wrappers

In CL 288092 we made Darwin syscall wrappers as ABIInternal, so
their addresses taken from Go using funcPC are the actual function
entries, not the wrappers.

As we introduced internal/abi.FuncPCABIxxx intrinsics, use that.
And change the assembly functions back to ABI0.

Change-Id: I50645af74883e2d5dfcd67a5e8c739222c6f645b
Reviewed-on: https://go-review.googlesource.com/c/go/+/313250
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/os_darwin.go       | 13 +++--
 src/runtime/sys_darwin.go      | 97 +++++++++++++++++----------------
 src/runtime/sys_darwin_amd64.s | 98 +++++++++++++++++-----------------
 3 files changed, 106 insertions(+), 102 deletions(-)

diff --git a/src/runtime/os_darwin.go b/src/runtime/os_darwin.go
index 470698d0a3..00139351ab 100644
--- a/src/runtime/os_darwin.go
+++ b/src/runtime/os_darwin.go
@@ -4,7 +4,10 @@
 
 package runtime
 
-import "unsafe"
+import (
+	"internal/abi"
+	"unsafe"
+)
 
 type mOS struct {
 	initialized bool
@@ -221,7 +224,7 @@ func newosproc(mp *m) {
 	// setup and then calls mstart.
 	var oset sigset
 	sigprocmask(_SIG_SETMASK, &sigset_all, &oset)
-	err = pthread_create(&attr, funcPC(mstart_stub), unsafe.Pointer(mp))
+	err = pthread_create(&attr, abi.FuncPCABI0(mstart_stub), unsafe.Pointer(mp))
 	sigprocmask(_SIG_SETMASK, &oset, nil)
 	if err != 0 {
 		write(2, unsafe.Pointer(&failthreadcreate[0]), int32(len(failthreadcreate)))
@@ -361,11 +364,11 @@ func setsig(i uint32, fn uintptr) {
 	var sa usigactiont
 	sa.sa_flags = _SA_SIGINFO | _SA_ONSTACK | _SA_RESTART
 	sa.sa_mask = ^uint32(0)
-	if fn == funcPC(sighandler) {
+	if fn == funcPC(sighandler) { // funcPC(sighandler) matches the callers in signal_unix.go
 		if iscgo {
-			fn = funcPC(cgoSigtramp)
+			fn = abi.FuncPCABI0(cgoSigtramp)
 		} else {
-			fn = funcPC(sigtramp)
+			fn = abi.FuncPCABI0(sigtramp)
 		}
 	}
 	*(*uintptr)(unsafe.Pointer(&sa.__sigaction_u)) = fn
diff --git a/src/runtime/sys_darwin.go b/src/runtime/sys_darwin.go
index 4ae259ac63..6d7460fae2 100644
--- a/src/runtime/sys_darwin.go
+++ b/src/runtime/sys_darwin.go
@@ -4,7 +4,10 @@
 
 package runtime
 
-import "unsafe"
+import (
+	"internal/abi"
+	"unsafe"
+)
 
 // The X versions of syscall expect the libc call to return a 64-bit result.
 // Otherwise (the non-X version) expects a 32-bit result.
@@ -17,7 +20,7 @@ import "unsafe"
 //go:cgo_unsafe_args
 func syscall_syscall(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
 	entersyscall()
-	libcCall(unsafe.Pointer(funcPC(syscall)), unsafe.Pointer(&fn))
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(syscall)), unsafe.Pointer(&fn))
 	exitsyscall()
 	return
 }
@@ -28,7 +31,7 @@ func syscall()
 //go:cgo_unsafe_args
 func syscall_syscallX(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
 	entersyscall()
-	libcCall(unsafe.Pointer(funcPC(syscallX)), unsafe.Pointer(&fn))
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(syscallX)), unsafe.Pointer(&fn))
 	exitsyscall()
 	return
 }
@@ -39,7 +42,7 @@ func syscallX()
 //go:cgo_unsafe_args
 func syscall_syscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) {
 	entersyscall()
-	libcCall(unsafe.Pointer(funcPC(syscall6)), unsafe.Pointer(&fn))
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(syscall6)), unsafe.Pointer(&fn))
 	exitsyscall()
 	return
 }
@@ -50,7 +53,7 @@ func syscall6()
 //go:cgo_unsafe_args
 func syscall_syscall6X(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) {
 	entersyscall()
-	libcCall(unsafe.Pointer(funcPC(syscall6X)), unsafe.Pointer(&fn))
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(syscall6X)), unsafe.Pointer(&fn))
 	exitsyscall()
 	return
 }
@@ -61,7 +64,7 @@ func syscall6X()
 //go:cgo_unsafe_args
 func syscall_syscallPtr(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
 	entersyscall()
-	libcCall(unsafe.Pointer(funcPC(syscallPtr)), unsafe.Pointer(&fn))
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(syscallPtr)), unsafe.Pointer(&fn))
 	exitsyscall()
 	return
 }
@@ -71,7 +74,7 @@ func syscallPtr()
 //go:nosplit
 //go:cgo_unsafe_args
 func syscall_rawSyscall(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
-	libcCall(unsafe.Pointer(funcPC(syscall)), unsafe.Pointer(&fn))
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(syscall)), unsafe.Pointer(&fn))
 	return
 }
 
@@ -79,7 +82,7 @@ func syscall_rawSyscall(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
 //go:nosplit
 //go:cgo_unsafe_args
 func syscall_rawSyscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) {
-	libcCall(unsafe.Pointer(funcPC(syscall6)), unsafe.Pointer(&fn))
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(syscall6)), unsafe.Pointer(&fn))
 	return
 }
 
@@ -90,7 +93,7 @@ func syscall_rawSyscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintpt
 //go:cgo_unsafe_args
 func crypto_x509_syscall(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1 uintptr) {
 	entersyscall()
-	libcCall(unsafe.Pointer(funcPC(syscallNoErr)), unsafe.Pointer(&fn))
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(syscallNoErr)), unsafe.Pointer(&fn))
 	exitsyscall()
 	return
 }
@@ -102,42 +105,42 @@ func syscallNoErr()
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_attr_init(attr *pthreadattr) int32 {
-	return libcCall(unsafe.Pointer(funcPC(pthread_attr_init_trampoline)), unsafe.Pointer(&attr))
+	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_attr_init_trampoline)), unsafe.Pointer(&attr))
 }
 func pthread_attr_init_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_attr_getstacksize(attr *pthreadattr, size *uintptr) int32 {
-	return libcCall(unsafe.Pointer(funcPC(pthread_attr_getstacksize_trampoline)), unsafe.Pointer(&attr))
+	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_attr_getstacksize_trampoline)), unsafe.Pointer(&attr))
 }
 func pthread_attr_getstacksize_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_attr_setdetachstate(attr *pthreadattr, state int) int32 {
-	return libcCall(unsafe.Pointer(funcPC(pthread_attr_setdetachstate_trampoline)), unsafe.Pointer(&attr))
+	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_attr_setdetachstate_trampoline)), unsafe.Pointer(&attr))
 }
 func pthread_attr_setdetachstate_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_create(attr *pthreadattr, start uintptr, arg unsafe.Pointer) int32 {
-	return libcCall(unsafe.Pointer(funcPC(pthread_create_trampoline)), unsafe.Pointer(&attr))
+	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_create_trampoline)), unsafe.Pointer(&attr))
 }
 func pthread_create_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func raise(sig uint32) {
-	libcCall(unsafe.Pointer(funcPC(raise_trampoline)), unsafe.Pointer(&sig))
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(raise_trampoline)), unsafe.Pointer(&sig))
 }
 func raise_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_self() (t pthread) {
-	libcCall(unsafe.Pointer(funcPC(pthread_self_trampoline)), unsafe.Pointer(&t))
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_self_trampoline)), unsafe.Pointer(&t))
 	return
 }
 func pthread_self_trampoline()
@@ -145,7 +148,7 @@ func pthread_self_trampoline()
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_kill(t pthread, sig uint32) {
-	libcCall(unsafe.Pointer(funcPC(pthread_kill_trampoline)), unsafe.Pointer(&t))
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_kill_trampoline)), unsafe.Pointer(&t))
 	return
 }
 func pthread_kill_trampoline()
@@ -163,7 +166,7 @@ func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) (un
 		ret1            unsafe.Pointer
 		ret2            int
 	}{addr, n, prot, flags, fd, off, nil, 0}
-	libcCall(unsafe.Pointer(funcPC(mmap_trampoline)), unsafe.Pointer(&args))
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(mmap_trampoline)), unsafe.Pointer(&args))
 	return args.ret1, args.ret2
 }
 func mmap_trampoline()
@@ -171,34 +174,34 @@ func mmap_trampoline()
 //go:nosplit
 //go:cgo_unsafe_args
 func munmap(addr unsafe.Pointer, n uintptr) {
-	libcCall(unsafe.Pointer(funcPC(munmap_trampoline)), unsafe.Pointer(&addr))
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(munmap_trampoline)), unsafe.Pointer(&addr))
 }
 func munmap_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func madvise(addr unsafe.Pointer, n uintptr, flags int32) {
-	libcCall(unsafe.Pointer(funcPC(madvise_trampoline)), unsafe.Pointer(&addr))
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(madvise_trampoline)), unsafe.Pointer(&addr))
 }
 func madvise_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func mlock(addr unsafe.Pointer, n uintptr) {
-	libcCall(unsafe.Pointer(funcPC(mlock_trampoline)), unsafe.Pointer(&addr))
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(mlock_trampoline)), unsafe.Pointer(&addr))
 }
 func mlock_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func read(fd int32, p unsafe.Pointer, n int32) int32 {
-	return libcCall(unsafe.Pointer(funcPC(read_trampoline)), unsafe.Pointer(&fd))
+	return libcCall(unsafe.Pointer(abi.FuncPCABI0(read_trampoline)), unsafe.Pointer(&fd))
 }
 func read_trampoline()
 
 func pipe() (r, w int32, errno int32) {
 	var p [2]int32
-	errno = libcCall(unsafe.Pointer(funcPC(pipe_trampoline)), noescape(unsafe.Pointer(&p)))
+	errno = libcCall(unsafe.Pointer(abi.FuncPCABI0(pipe_trampoline)), noescape(unsafe.Pointer(&p)))
 	return p[0], p[1], errno
 }
 func pipe_trampoline()
@@ -206,7 +209,7 @@ func pipe_trampoline()
 //go:nosplit
 //go:cgo_unsafe_args
 func closefd(fd int32) int32 {
-	return libcCall(unsafe.Pointer(funcPC(close_trampoline)), unsafe.Pointer(&fd))
+	return libcCall(unsafe.Pointer(abi.FuncPCABI0(close_trampoline)), unsafe.Pointer(&fd))
 }
 func close_trampoline()
 
@@ -216,34 +219,34 @@ func close_trampoline()
 // This is exported via linkname to assembly in runtime/cgo.
 //go:linkname exit
 func exit(code int32) {
-	libcCall(unsafe.Pointer(funcPC(exit_trampoline)), unsafe.Pointer(&code))
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(exit_trampoline)), unsafe.Pointer(&code))
 }
 func exit_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func usleep(usec uint32) {
-	libcCall(unsafe.Pointer(funcPC(usleep_trampoline)), unsafe.Pointer(&usec))
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(usleep_trampoline)), unsafe.Pointer(&usec))
 }
 func usleep_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func usleep_no_g(usec uint32) {
-	asmcgocall_no_g(unsafe.Pointer(funcPC(usleep_trampoline)), unsafe.Pointer(&usec))
+	asmcgocall_no_g(unsafe.Pointer(abi.FuncPCABI0(usleep_trampoline)), unsafe.Pointer(&usec))
 }
 
 //go:nosplit
 //go:cgo_unsafe_args
 func write1(fd uintptr, p unsafe.Pointer, n int32) int32 {
-	return libcCall(unsafe.Pointer(funcPC(write_trampoline)), unsafe.Pointer(&fd))
+	return libcCall(unsafe.Pointer(abi.FuncPCABI0(write_trampoline)), unsafe.Pointer(&fd))
 }
 func write_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func open(name *byte, mode, perm int32) (ret int32) {
-	return libcCall(unsafe.Pointer(funcPC(open_trampoline)), unsafe.Pointer(&name))
+	return libcCall(unsafe.Pointer(abi.FuncPCABI0(open_trampoline)), unsafe.Pointer(&name))
 }
 func open_trampoline()
 
@@ -254,7 +257,7 @@ func nanotime1() int64 {
 		t            int64  // raw timer
 		numer, denom uint32 // conversion factors. nanoseconds = t * numer / denom.
 	}
-	libcCall(unsafe.Pointer(funcPC(nanotime_trampoline)), unsafe.Pointer(&r))
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(nanotime_trampoline)), unsafe.Pointer(&r))
 	// Note: Apple seems unconcerned about overflow here. See
 	// https://developer.apple.com/library/content/qa/qa1398/_index.html
 	// Note also, numer == denom == 1 is common.
@@ -273,7 +276,7 @@ func nanotime_trampoline()
 //go:cgo_unsafe_args
 func walltime1() (int64, int32) {
 	var t timespec
-	libcCall(unsafe.Pointer(funcPC(walltime_trampoline)), unsafe.Pointer(&t))
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(walltime_trampoline)), unsafe.Pointer(&t))
 	return t.tv_sec, int32(t.tv_nsec)
 }
 func walltime_trampoline()
@@ -281,14 +284,14 @@ func walltime_trampoline()
 //go:nosplit
 //go:cgo_unsafe_args
 func sigaction(sig uint32, new *usigactiont, old *usigactiont) {
-	libcCall(unsafe.Pointer(funcPC(sigaction_trampoline)), unsafe.Pointer(&sig))
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(sigaction_trampoline)), unsafe.Pointer(&sig))
 }
 func sigaction_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func sigprocmask(how uint32, new *sigset, old *sigset) {
-	libcCall(unsafe.Pointer(funcPC(sigprocmask_trampoline)), unsafe.Pointer(&how))
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(sigprocmask_trampoline)), unsafe.Pointer(&how))
 }
 func sigprocmask_trampoline()
 
@@ -302,49 +305,49 @@ func sigaltstack(new *stackt, old *stackt) {
 		// ref: http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20140421/214296.html
 		new.ss_size = 32768
 	}
-	libcCall(unsafe.Pointer(funcPC(sigaltstack_trampoline)), unsafe.Pointer(&new))
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(sigaltstack_trampoline)), unsafe.Pointer(&new))
 }
 func sigaltstack_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func raiseproc(sig uint32) {
-	libcCall(unsafe.Pointer(funcPC(raiseproc_trampoline)), unsafe.Pointer(&sig))
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(raiseproc_trampoline)), unsafe.Pointer(&sig))
 }
 func raiseproc_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func setitimer(mode int32, new, old *itimerval) {
-	libcCall(unsafe.Pointer(funcPC(setitimer_trampoline)), unsafe.Pointer(&mode))
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(setitimer_trampoline)), unsafe.Pointer(&mode))
 }
 func setitimer_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func sysctl(mib *uint32, miblen uint32, oldp *byte, oldlenp *uintptr, newp *byte, newlen uintptr) int32 {
-	return libcCall(unsafe.Pointer(funcPC(sysctl_trampoline)), unsafe.Pointer(&mib))
+	return libcCall(unsafe.Pointer(abi.FuncPCABI0(sysctl_trampoline)), unsafe.Pointer(&mib))
 }
 func sysctl_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func sysctlbyname(name *byte, oldp *byte, oldlenp *uintptr, newp *byte, newlen uintptr) int32 {
-	return libcCall(unsafe.Pointer(funcPC(sysctlbyname_trampoline)), unsafe.Pointer(&name))
+	return libcCall(unsafe.Pointer(abi.FuncPCABI0(sysctlbyname_trampoline)), unsafe.Pointer(&name))
 }
 func sysctlbyname_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func fcntl(fd, cmd, arg int32) int32 {
-	return libcCall(unsafe.Pointer(funcPC(fcntl_trampoline)), unsafe.Pointer(&fd))
+	return libcCall(unsafe.Pointer(abi.FuncPCABI0(fcntl_trampoline)), unsafe.Pointer(&fd))
 }
 func fcntl_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func kqueue() int32 {
-	v := libcCall(unsafe.Pointer(funcPC(kqueue_trampoline)), nil)
+	v := libcCall(unsafe.Pointer(abi.FuncPCABI0(kqueue_trampoline)), nil)
 	return v
 }
 func kqueue_trampoline()
@@ -352,56 +355,56 @@ func kqueue_trampoline()
 //go:nosplit
 //go:cgo_unsafe_args
 func kevent(kq int32, ch *keventt, nch int32, ev *keventt, nev int32, ts *timespec) int32 {
-	return libcCall(unsafe.Pointer(funcPC(kevent_trampoline)), unsafe.Pointer(&kq))
+	return libcCall(unsafe.Pointer(abi.FuncPCABI0(kevent_trampoline)), unsafe.Pointer(&kq))
 }
 func kevent_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_mutex_init(m *pthreadmutex, attr *pthreadmutexattr) int32 {
-	return libcCall(unsafe.Pointer(funcPC(pthread_mutex_init_trampoline)), unsafe.Pointer(&m))
+	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_mutex_init_trampoline)), unsafe.Pointer(&m))
 }
 func pthread_mutex_init_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_mutex_lock(m *pthreadmutex) int32 {
-	return libcCall(unsafe.Pointer(funcPC(pthread_mutex_lock_trampoline)), unsafe.Pointer(&m))
+	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_mutex_lock_trampoline)), unsafe.Pointer(&m))
 }
 func pthread_mutex_lock_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_mutex_unlock(m *pthreadmutex) int32 {
-	return libcCall(unsafe.Pointer(funcPC(pthread_mutex_unlock_trampoline)), unsafe.Pointer(&m))
+	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_mutex_unlock_trampoline)), unsafe.Pointer(&m))
 }
 func pthread_mutex_unlock_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_cond_init(c *pthreadcond, attr *pthreadcondattr) int32 {
-	return libcCall(unsafe.Pointer(funcPC(pthread_cond_init_trampoline)), unsafe.Pointer(&c))
+	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_cond_init_trampoline)), unsafe.Pointer(&c))
 }
 func pthread_cond_init_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_cond_wait(c *pthreadcond, m *pthreadmutex) int32 {
-	return libcCall(unsafe.Pointer(funcPC(pthread_cond_wait_trampoline)), unsafe.Pointer(&c))
+	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_cond_wait_trampoline)), unsafe.Pointer(&c))
 }
 func pthread_cond_wait_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_cond_timedwait_relative_np(c *pthreadcond, m *pthreadmutex, t *timespec) int32 {
-	return libcCall(unsafe.Pointer(funcPC(pthread_cond_timedwait_relative_np_trampoline)), unsafe.Pointer(&c))
+	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_cond_timedwait_relative_np_trampoline)), unsafe.Pointer(&c))
 }
 func pthread_cond_timedwait_relative_np_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_cond_signal(c *pthreadcond) int32 {
-	return libcCall(unsafe.Pointer(funcPC(pthread_cond_signal_trampoline)), unsafe.Pointer(&c))
+	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_cond_signal_trampoline)), unsafe.Pointer(&c))
 }
 func pthread_cond_signal_trampoline()
 
diff --git a/src/runtime/sys_darwin_amd64.s b/src/runtime/sys_darwin_amd64.s
index 803d95bcca..3bd027f982 100644
--- a/src/runtime/sys_darwin_amd64.s
+++ b/src/runtime/sys_darwin_amd64.s
@@ -5,8 +5,6 @@
 // System calls and other sys.stuff for AMD64, Darwin
 // System calls are implemented in libSystem, this file contains
 // trampolines that convert from Go to C calling convention.
-// The trampolines are ABIInternal as they are referenced from
-// Go code with funcPC.
 
 #include "go_asm.h"
 #include "go_tls.h"
@@ -16,7 +14,7 @@
 #define CLOCK_REALTIME		0
 
 // Exit the entire program (like C exit)
-TEXT runtime·exit_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·exit_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVL	0(DI), DI		// arg 1 exit status
@@ -25,7 +23,7 @@ TEXT runtime·exit_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·open_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·open_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVL	8(DI), SI		// arg 2 flags
@@ -36,7 +34,7 @@ TEXT runtime·open_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·close_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·close_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVL	0(DI), DI		// arg 1 fd
@@ -44,7 +42,7 @@ TEXT runtime·close_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·read_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·read_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI		// arg 2 buf
@@ -60,7 +58,7 @@ noerr:
 	POPQ	BP
 	RET
 
-TEXT runtime·write_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·write_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI		// arg 2 buf
@@ -76,7 +74,7 @@ noerr:
 	POPQ	BP
 	RET
 
-TEXT runtime·pipe_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·pipe_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	CALL	libc_pipe(SB)		// pointer already in DI
@@ -87,7 +85,7 @@ TEXT runtime·pipe_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·setitimer_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·setitimer_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI		// arg 2 new
@@ -97,7 +95,7 @@ TEXT runtime·setitimer_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·madvise_trampoline<ABIInternal>(SB), NOSPLIT, $0
+TEXT runtime·madvise_trampoline(SB), NOSPLIT, $0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI	// arg 2 len
@@ -108,12 +106,12 @@ TEXT runtime·madvise_trampoline<ABIInternal>(SB), NOSPLIT, $0
 	POPQ	BP
 	RET
 
-TEXT runtime·mlock_trampoline<ABIInternal>(SB), NOSPLIT, $0
+TEXT runtime·mlock_trampoline(SB), NOSPLIT, $0
 	UNDEF // unimplemented
 
 GLOBL timebase<>(SB),NOPTR,$(machTimebaseInfo__size)
 
-TEXT runtime·nanotime_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·nanotime_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	DI, BX
@@ -142,7 +140,7 @@ initialized:
 	POPQ	BP
 	RET
 
-TEXT runtime·walltime_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·walltime_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP			// make a frame; keep stack aligned
 	MOVQ	SP, BP
 	MOVQ	DI, SI			// arg 2 timespec
@@ -151,7 +149,7 @@ TEXT runtime·walltime_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·sigaction_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·sigaction_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI		// arg 2 new
@@ -164,7 +162,7 @@ TEXT runtime·sigaction_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·sigprocmask_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·sigprocmask_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI	// arg 2 new
@@ -177,7 +175,7 @@ TEXT runtime·sigprocmask_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·sigaltstack_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·sigaltstack_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI		// arg 2 old
@@ -189,7 +187,7 @@ TEXT runtime·sigaltstack_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·raiseproc_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·raiseproc_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVL	0(DI), BX	// signal
@@ -216,7 +214,7 @@ TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
 // This is the function registered during sigaction and is invoked when
 // a signal is received. It just redirects to the Go function sigtrampgo.
 // Called using C ABI.
-TEXT runtime·sigtramp<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·sigtramp(SB),NOSPLIT,$0
 	// Transition from C ABI to Go ABI.
 	PUSH_REGS_HOST_TO_ABI0()
 
@@ -234,7 +232,7 @@ TEXT runtime·sigtramp<ABIInternal>(SB),NOSPLIT,$0
 
 // Used instead of sigtramp in programs that use cgo.
 // Arguments from kernel are in DI, SI, DX.
-TEXT runtime·cgoSigtramp<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0
 	// If no traceback function, do usual sigtramp.
 	MOVQ	runtime·cgoTraceback(SB), AX
 	TESTQ	AX, AX
@@ -277,12 +275,12 @@ TEXT runtime·cgoSigtramp<ABIInternal>(SB),NOSPLIT,$0
 	// The first three arguments, and the fifth, are already in registers.
 	// Set the two remaining arguments now.
 	MOVQ	runtime·cgoTraceback(SB), CX
-	MOVQ	$runtime·sigtramp<ABIInternal>(SB), R9
+	MOVQ	$runtime·sigtramp(SB), R9
 	MOVQ	_cgo_callers(SB), AX
 	JMP	AX
 
 sigtramp:
-	JMP	runtime·sigtramp<ABIInternal>(SB)
+	JMP	runtime·sigtramp(SB)
 
 sigtrampnog:
 	// Signal arrived on a non-Go thread. If this is SIGPROF, get a
@@ -308,7 +306,7 @@ sigtrampnog:
 	MOVQ	_cgo_callers(SB), AX
 	JMP	AX
 
-TEXT runtime·mmap_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·mmap_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP			// make a frame; keep stack aligned
 	MOVQ	SP, BP
 	MOVQ	DI, BX
@@ -331,7 +329,7 @@ ok:
 	POPQ	BP
 	RET
 
-TEXT runtime·munmap_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·munmap_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI		// arg 2 len
@@ -343,7 +341,7 @@ TEXT runtime·munmap_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·usleep_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·usleep_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVL	0(DI), DI	// arg 1 usec
@@ -355,7 +353,7 @@ TEXT runtime·settls(SB),NOSPLIT,$32
 	// Nothing to do on Darwin, pthread already set thread-local storage up.
 	RET
 
-TEXT runtime·sysctl_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·sysctl_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVL	8(DI), SI		// arg 2 miblen
@@ -368,7 +366,7 @@ TEXT runtime·sysctl_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·sysctlbyname_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·sysctlbyname_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI		// arg 2 oldp
@@ -380,14 +378,14 @@ TEXT runtime·sysctlbyname_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·kqueue_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·kqueue_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	CALL	libc_kqueue(SB)
 	POPQ	BP
 	RET
 
-TEXT runtime·kevent_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·kevent_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI		// arg 2 keventt
@@ -406,7 +404,7 @@ ok:
 	POPQ	BP
 	RET
 
-TEXT runtime·fcntl_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVL	4(DI), SI		// arg 2 cmd
@@ -420,7 +418,7 @@ TEXT runtime·fcntl_trampoline<ABIInternal>(SB),NOSPLIT,$0
 // mstart_stub is the first function executed on a new thread started by pthread_create.
 // It just does some low-level setup and then calls mstart.
 // Note: called with the C calling convention.
-TEXT runtime·mstart_stub<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·mstart_stub(SB),NOSPLIT,$0
 	// DI points to the m.
 	// We are already on m's g0 stack.
 
@@ -448,7 +446,7 @@ TEXT runtime·mstart_stub<ABIInternal>(SB),NOSPLIT,$0
 // A pointer to the arguments is passed in DI.
 // A single int32 result is returned in AX.
 // (For more results, make an args/results structure.)
-TEXT runtime·pthread_attr_init_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·pthread_attr_init_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP	// make frame, keep stack 16-byte aligned.
 	MOVQ	SP, BP
 	MOVQ	0(DI), DI // arg 1 attr
@@ -456,7 +454,7 @@ TEXT runtime·pthread_attr_init_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·pthread_attr_getstacksize_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·pthread_attr_getstacksize_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI	// arg 2 size
@@ -465,7 +463,7 @@ TEXT runtime·pthread_attr_getstacksize_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·pthread_attr_setdetachstate_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·pthread_attr_setdetachstate_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI	// arg 2 state
@@ -474,7 +472,7 @@ TEXT runtime·pthread_attr_setdetachstate_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·pthread_create_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·pthread_create_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	SUBQ	$16, SP
@@ -487,7 +485,7 @@ TEXT runtime·pthread_create_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·raise_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·raise_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVL	0(DI), DI	// arg 1 signal
@@ -495,7 +493,7 @@ TEXT runtime·raise_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·pthread_mutex_init_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·pthread_mutex_init_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI	// arg 2 attr
@@ -504,7 +502,7 @@ TEXT runtime·pthread_mutex_init_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·pthread_mutex_lock_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·pthread_mutex_lock_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	0(DI), DI	// arg 1 mutex
@@ -512,7 +510,7 @@ TEXT runtime·pthread_mutex_lock_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·pthread_mutex_unlock_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·pthread_mutex_unlock_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	0(DI), DI	// arg 1 mutex
@@ -520,7 +518,7 @@ TEXT runtime·pthread_mutex_unlock_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·pthread_cond_init_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·pthread_cond_init_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI	// arg 2 attr
@@ -529,7 +527,7 @@ TEXT runtime·pthread_cond_init_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·pthread_cond_wait_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·pthread_cond_wait_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI	// arg 2 mutex
@@ -538,7 +536,7 @@ TEXT runtime·pthread_cond_wait_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·pthread_cond_timedwait_relative_np_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·pthread_cond_timedwait_relative_np_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI	// arg 2 mutex
@@ -548,7 +546,7 @@ TEXT runtime·pthread_cond_timedwait_relative_np_trampoline<ABIInternal>(SB),NOS
 	POPQ	BP
 	RET
 
-TEXT runtime·pthread_cond_signal_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·pthread_cond_signal_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	0(DI), DI	// arg 1 cond
@@ -556,7 +554,7 @@ TEXT runtime·pthread_cond_signal_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·pthread_self_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·pthread_self_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	DI, BX		// BX is caller-save
@@ -565,7 +563,7 @@ TEXT runtime·pthread_self_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	POPQ	BP
 	RET
 
-TEXT runtime·pthread_kill_trampoline<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·pthread_kill_trampoline(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	MOVQ	8(DI), SI	// arg 2 sig
@@ -590,7 +588,7 @@ TEXT runtime·pthread_kill_trampoline<ABIInternal>(SB),NOSPLIT,$0
 //
 // syscall expects a 32-bit result and tests for 32-bit -1
 // to decide there was an error.
-TEXT runtime·syscall<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·syscall(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	SUBQ	$16, SP
@@ -640,7 +638,7 @@ ok:
 //
 // syscallX is like syscall but expects a 64-bit result
 // and tests for 64-bit -1 to decide there was an error.
-TEXT runtime·syscallX<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·syscallX(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	SUBQ	$16, SP
@@ -676,7 +674,7 @@ ok:
 
 // syscallPtr is like syscallX except that the libc function reports an
 // error by returning NULL and setting errno.
-TEXT runtime·syscallPtr<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·syscallPtr(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	SUBQ	$16, SP
@@ -729,7 +727,7 @@ ok:
 //
 // syscall6 expects a 32-bit result and tests for 32-bit -1
 // to decide there was an error.
-TEXT runtime·syscall6<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·syscall6(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	SUBQ	$16, SP
@@ -782,7 +780,7 @@ ok:
 //
 // syscall6X is like syscall6 but expects a 64-bit result
 // and tests for 64-bit -1 to decide there was an error.
-TEXT runtime·syscall6X<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·syscall6X(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	SUBQ	$16, SP
@@ -818,7 +816,7 @@ ok:
 
 // syscallNoErr is like syscall6 but does not check for errors, and
 // only returns one value, for use with standard C ABI library functions.
-TEXT runtime·syscallNoErr<ABIInternal>(SB),NOSPLIT,$0
+TEXT runtime·syscallNoErr(SB),NOSPLIT,$0
 	PUSHQ	BP
 	MOVQ	SP, BP
 	SUBQ	$16, SP
-- 
GitLab


From 0d1280c685c2353a9c982c11e77281ad4d34464a Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Mon, 26 Apr 2021 18:32:28 +0000
Subject: [PATCH 1766/2400] Revert "sync: improve sync.Pool object stealing"

This reverts CL 303949.

Reason for revert: broke linux-arm-aws TryBots.

Change-Id: Ib44949df70520cdabff857846be0d2221403d2f4
Reviewed-on: https://go-review.googlesource.com/c/go/+/313630
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/sync/pool.go      | 103 ++++--------------------------------------
 src/sync/pool_test.go |  18 --------
 2 files changed, 10 insertions(+), 111 deletions(-)

diff --git a/src/sync/pool.go b/src/sync/pool.go
index 3fb4dc07de..1ae70127ac 100644
--- a/src/sync/pool.go
+++ b/src/sync/pool.go
@@ -70,57 +70,6 @@ type poolLocal struct {
 	pad [128 - unsafe.Sizeof(poolLocalInternal{})%128]byte
 }
 
-// The randomOrder and randomEnum are copied from runtime/proc.go
-type randomOrder struct {
-	count    uint32
-	coprimes []uint32
-}
-
-type randomEnum struct {
-	i     uint32
-	count uint32
-	pos   uint32
-	inc   uint32
-}
-
-func (ord *randomOrder) reset(count uint32) {
-	ord.count = count
-	ord.coprimes = ord.coprimes[:0]
-	for i := uint32(1); i <= count; i++ {
-		if gcd(i, count) == 1 {
-			ord.coprimes = append(ord.coprimes, i)
-		}
-	}
-}
-
-func (ord *randomOrder) start(i uint32) randomEnum {
-	return randomEnum{
-		count: ord.count,
-		pos:   i % ord.count,
-		inc:   ord.coprimes[i%uint32(len(ord.coprimes))],
-	}
-}
-
-func (enum *randomEnum) done() bool {
-	return enum.i == enum.count
-}
-
-func (enum *randomEnum) next() {
-	enum.i++
-	enum.pos = (enum.pos + enum.inc) % enum.count
-}
-
-func (enum *randomEnum) position() uint32 {
-	return enum.pos
-}
-
-func gcd(a, b uint32) uint32 {
-	for b != 0 {
-		a, b = b, a%b
-	}
-	return a
-}
-
 // from runtime
 func fastrand() uint32
 
@@ -204,27 +153,12 @@ func (p *Pool) Get() interface{} {
 func (p *Pool) getSlow(pid int) interface{} {
 	// See the comment in pin regarding ordering of the loads.
 	size := runtime_LoadAcquintptr(&p.localSize) // load-acquire
-	// Load pOrder atomically to prevent possible races
-	order := (*randomOrder)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&pOrder)))) // load-consume
-
-	// Pin function always returns non-zero localSize, and it will remain so until runtime_procUnpin
-	// is called. This invariant is maintained by pin ensuring that locals is always big enough to
-	// account for the current P and that poolCleanup can never execute concurrently with a pinned P
-	// due to disabled preemtion.
-	// So, we can remove this condition which protects from division by zero in loop's body,
-	// but we leave it here just to be sure there is no any possibility for error
-	if size != 0 {
-		locals := p.local // load-consume
-		// Try to steal one element from other procs.
-		for rndp := order.start(fastrand()); !rndp.done(); rndp.next() {
-			i := int(rndp.position())
-			// While pOrder is limited to returning indexes within the range of Ps,
-			// locals may be smaller either because it was reset or because of a race
-			// with pinSlow. Hence, we must still mod the local index by size.
-			l := indexLocal(locals, (pid+i+1)%int(size))
-			if x, _ := l.shared.popTail(); x != nil {
-				return x
-			}
+	locals := p.local                            // load-consume
+	// Try to steal one element from other procs.
+	for i := 0; i < int(size); i++ {
+		l := indexLocal(locals, (pid+i+1)%int(size))
+		if x, _ := l.shared.popTail(); x != nil {
+			return x
 		}
 	}
 
@@ -232,25 +166,16 @@ func (p *Pool) getSlow(pid int) interface{} {
 	// from all primary caches because we want objects in the
 	// victim cache to age out if at all possible.
 	size = atomic.LoadUintptr(&p.victimSize)
-
-	// We also have to ensure that victim cache is big enough to account current P
-	// and size is not equal to zero (protects from division by zero) similar as pin
-	// function do
 	if uintptr(pid) >= size {
 		return nil
 	}
-	locals := p.victim
+	locals = p.victim
 	l := indexLocal(locals, pid)
-
-	// Check private cache
 	if x := l.private; x != nil {
 		l.private = nil
 		return x
 	}
-
-	// Try to fetch from the tail of other P queues
-	for rndp := order.start(fastrand()); !rndp.done(); rndp.next() {
-		i := int(rndp.position())
+	for i := 0; i < int(size); i++ {
 		l := indexLocal(locals, (pid+i)%int(size))
 		if x, _ := l.shared.popTail(); x != nil {
 			return x
@@ -299,13 +224,9 @@ func (p *Pool) pinSlow() (*poolLocal, int) {
 	}
 	// If GOMAXPROCS changes between GCs, we re-allocate the array and lose the old one.
 	size := runtime.GOMAXPROCS(0)
-	// Set count of Ps for random ordering
-	order := &randomOrder{}
-	order.reset(uint32(size))
 	local := make([]poolLocal, size)
-	atomic.StorePointer(&p.local, unsafe.Pointer(&local[0]))                               // store-release
-	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(&pOrder)), unsafe.Pointer(order)) // store-release
-	runtime_StoreReluintptr(&p.localSize, uintptr(size))                                   // store-release
+	atomic.StorePointer(&p.local, unsafe.Pointer(&local[0])) // store-release
+	runtime_StoreReluintptr(&p.localSize, uintptr(size))     // store-release
 	return &local[pid], pid
 }
 
@@ -346,10 +267,6 @@ var (
 	// oldPools is the set of pools that may have non-empty victim
 	// caches. Protected by STW.
 	oldPools []*Pool
-
-	// pOrder is a random order of Ps used for stealing. Writes
-	// are protected by allPoolsMu. Reads are atomic.
-	pOrder *randomOrder
 )
 
 func init() {
diff --git a/src/sync/pool_test.go b/src/sync/pool_test.go
index 6cccd8a533..65666daab4 100644
--- a/src/sync/pool_test.go
+++ b/src/sync/pool_test.go
@@ -271,24 +271,6 @@ func BenchmarkPoolOverflow(b *testing.B) {
 	})
 }
 
-// Simulate object starvation in order to force Ps to steal objects
-// from other Ps.
-func BenchmarkPoolStarvation(b *testing.B) {
-	var p Pool
-	count := 100
-	count_starved := count - (count / runtime.GOMAXPROCS(0))
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			for b := 0; b < count_starved; b++ {
-				p.Put(1)
-			}
-			for b := 0; b < count; b++ {
-				p.Get()
-			}
-		}
-	})
-}
-
 var globalSink interface{}
 
 func BenchmarkPoolSTW(b *testing.B) {
-- 
GitLab


From a53dc4c1ce0e21da328bd5984900448bab354ba1 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 23 Apr 2021 01:49:00 -0400
Subject: [PATCH 1767/2400] cmd/go/internal/modload: use (*loadPkg).mod only to
 indicate the module from which the package was loaded
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The (*loadPkg).mod field normally indicates the module from which the
package was loaded. However, if the package was missing, we previously
used the mod field to instead store the module from which we intend to
load the package next time around.

That sort of dual use makes the semantics (and synchronization) of the
mod field much more complex to reason about. For example, it would be
nice to have the invariant that the mod field is always one of the
modules in the overall build list, or one of the modules selected in
the overall module graph. Similarly, it would be nice to have the
invariant that the version indicated by the mod field can coexist with
(without upgrading) all of the other versions indicated in the mod
fields of other packages.

This repurposing of the mod field appears to be solely in the service
of storing the module when resolving missing imports. To keep
conceptually-separate fields separate, I have changed
resolveMissingImports to store a slice of package–module pairs,
instead of just packages that need to be revisited.

This may increase allocation pressure slightly if we have many
unresolved packages, but most packages are not unresolved, and it
seems worth the cost to use a little extra memory if it means we can
reason more clearly about the (quite complex) behaviors of the module
loader.

For #36460

Change-Id: Ic434df0f38185c6e9e892c5e9ba9ff53b3efe01f
Reviewed-on: https://go-review.googlesource.com/c/go/+/312930
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modload/load.go | 45 +++++++++++++++++++++++------
 1 file changed, 36 insertions(+), 9 deletions(-)

diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index b13c41aaef..8cbb768341 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -1057,7 +1057,11 @@ func (ld *loader) updateRequirements(ctx context.Context, add []module.Version)
 // resolveMissingImports returns a map from each new module version to
 // the first missing package that module would resolve.
 func (ld *loader) resolveMissingImports(ctx context.Context) (modAddedBy map[module.Version]*loadPkg) {
-	var needPkgs []*loadPkg
+	type pkgMod struct {
+		pkg *loadPkg
+		mod *module.Version
+	}
+	var pkgMods []pkgMod
 	for _, pkg := range ld.pkgs {
 		if pkg.err == nil {
 			continue
@@ -1072,24 +1076,47 @@ func (ld *loader) resolveMissingImports(ctx context.Context) (modAddedBy map[mod
 			continue
 		}
 
-		needPkgs = append(needPkgs, pkg)
-
 		pkg := pkg
+		var mod module.Version
 		ld.work.Add(func() {
-			pkg.mod, pkg.err = queryImport(ctx, pkg.path, ld.requirements)
+			var err error
+			mod, err = queryImport(ctx, pkg.path, ld.requirements)
+			if err != nil {
+				// pkg.err was already non-nil, so we can reasonably attribute the error
+				// for pkg to either the original error or the one returned by
+				// queryImport. The existing error indicates only that we couldn't find
+				// the package, whereas the query error also explains why we didn't fix
+				// the problem — so we prefer the latter.
+				pkg.err = err
+			}
+
+			// err is nil, but we intentionally leave pkg.err non-nil and pkg.mod
+			// unset: we still haven't satisfied other invariants of a
+			// successfully-loaded package, such as scanning and loading the imports
+			// of that package. If we succeed in resolving the new dependency graph,
+			// the caller can reload pkg and update the error at that point.
+			//
+			// Even then, the package might not be loaded from the version we've
+			// identified here. The module may be upgraded by some other dependency,
+			// or by a transitive dependency of mod itself, or — less likely — the
+			// package may be rejected by an AllowPackage hook or rendered ambiguous
+			// by some other newly-added or newly-upgraded dependency.
 		})
+
+		pkgMods = append(pkgMods, pkgMod{pkg: pkg, mod: &mod})
 	}
 	<-ld.work.Idle()
 
 	modAddedBy = map[module.Version]*loadPkg{}
-	for _, pkg := range needPkgs {
-		if pkg.err != nil {
+	for _, pm := range pkgMods {
+		pkg, mod := pm.pkg, *pm.mod
+		if mod.Path == "" {
 			continue
 		}
 
-		fmt.Fprintf(os.Stderr, "go: found %s in %s %s\n", pkg.path, pkg.mod.Path, pkg.mod.Version)
-		if modAddedBy[pkg.mod] == nil {
-			modAddedBy[pkg.mod] = pkg
+		fmt.Fprintf(os.Stderr, "go: found %s in %s %s\n", pkg.path, mod.Path, mod.Version)
+		if modAddedBy[mod] == nil {
+			modAddedBy[mod] = pkg
 		}
 	}
 
-- 
GitLab


From 9f601690da59e601ff68f9868d5eb863bd770eae Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 24 Apr 2021 02:12:55 -0700
Subject: [PATCH 1768/2400] cmd/compile: workaround inlining of closures with
 type switches

Within clovar, n.Defn can also be *ir.TypeSwitchGuard. The proper fix
here would be to populate m.Defn and have it filled in too, but we
already leave it nil in inlvar. So for consistency, this CL does the
same in clovar too.

Eventually inl.go should be rewritten to fully respect IR invariants.

Fixes #45743.

Change-Id: I8b38e5d8b2329ad242de97670f2141f713954d28
Reviewed-on: https://go-review.googlesource.com/c/go/+/313289
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
Trust: Dan Scales <danscales@google.com>
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/inline/inl.go |  2 ++
 test/fixedbugs/issue45743.go           | 20 ++++++++++++++++++++
 2 files changed, 22 insertions(+)
 create mode 100644 test/fixedbugs/issue45743.go

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 54fcb2b830..339ea77509 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -1194,6 +1194,8 @@ func (subst *inlsubst) clovar(n *ir.Name) *ir.Name {
 	case *ir.AssignStmt, *ir.AssignListStmt:
 		// Mark node for reassignment at the end of inlsubst.node.
 		m.Defn = &subst.defnMarker
+	case *ir.TypeSwitchGuard:
+		// TODO(mdempsky): Set m.Defn properly. See discussion on #45743.
 	default:
 		base.FatalfAt(n.Pos(), "unexpected Defn: %+v", defn)
 	}
diff --git a/test/fixedbugs/issue45743.go b/test/fixedbugs/issue45743.go
new file mode 100644
index 0000000000..0b30e0f2a4
--- /dev/null
+++ b/test/fixedbugs/issue45743.go
@@ -0,0 +1,20 @@
+// compile
+
+// Copyright 2021 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
+
+func fn() func(interface{}) {
+	return func(o interface{}) {
+		switch v := o.(type) {
+		case *int:
+			*v = 1
+		}
+	}
+}
+
+func main() {
+	fn()
+}
-- 
GitLab


From be28caf0aa1649c4422f64e687a388a027686e6e Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 26 Apr 2021 12:50:44 -0700
Subject: [PATCH 1769/2400] cmd/compile/internal/types2: respect
 IgnoreFuncBodies for function literals

Updates #45783.

Change-Id: Id552a60f262e2da62125acd6aec0901a82f5a29a
Reviewed-on: https://go-review.googlesource.com/c/go/+/313650
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/types2/expr.go | 26 +++++++++++++------------
 src/cmd/compile/internal/types2/stmt.go |  4 ++++
 2 files changed, 18 insertions(+), 12 deletions(-)

diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 76c6e7a3b3..8dbe6ea537 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -1132,18 +1132,20 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 
 	case *syntax.FuncLit:
 		if sig, ok := check.typ(e.Type).(*Signature); ok {
-			// Anonymous functions are considered part of the
-			// init expression/func declaration which contains
-			// them: use existing package-level declaration info.
-			decl := check.decl // capture for use in closure below
-			iota := check.iota // capture for use in closure below (#22345)
-			// Don't type-check right away because the function may
-			// be part of a type definition to which the function
-			// body refers. Instead, type-check as soon as possible,
-			// but before the enclosing scope contents changes (#22992).
-			check.later(func() {
-				check.funcBody(decl, "<function literal>", sig, e.Body, iota)
-			})
+			if !check.conf.IgnoreFuncBodies && e.Body != nil {
+				// Anonymous functions are considered part of the
+				// init expression/func declaration which contains
+				// them: use existing package-level declaration info.
+				decl := check.decl // capture for use in closure below
+				iota := check.iota // capture for use in closure below (#22345)
+				// Don't type-check right away because the function may
+				// be part of a type definition to which the function
+				// body refers. Instead, type-check as soon as possible,
+				// but before the enclosing scope contents changes (#22992).
+				check.later(func() {
+					check.funcBody(decl, "<function literal>", sig, e.Body, iota)
+				})
+			}
 			x.mode = value
 			x.typ = sig
 		} else {
diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go
index 9e3a45b6a8..c3e646c80c 100644
--- a/src/cmd/compile/internal/types2/stmt.go
+++ b/src/cmd/compile/internal/types2/stmt.go
@@ -13,6 +13,10 @@ import (
 )
 
 func (check *Checker) funcBody(decl *declInfo, name string, sig *Signature, body *syntax.BlockStmt, iota constant.Value) {
+	if check.conf.IgnoreFuncBodies {
+		panic("internal error: function body not ignored")
+	}
+
 	if check.conf.Trace {
 		check.trace(body.Pos(), "--- %s: %s", name, sig)
 		defer func() {
-- 
GitLab


From 903b25178e51fa96d37a91b020747ce236ba04f0 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Tue, 27 Apr 2021 00:11:00 +0200
Subject: [PATCH 1770/2400] syscall: on linux use accept4 in Accept, fall back
 to accept

Android seems to block the accept syscall in newer versions. Use accept4
instead on kernel versions that support it (Linux 2.6.28 and newer) and
fall back to accept on ENOSYS.

Fixes #45767

Change-Id: If190ace0e0213207fdaf6eeb79a5543ef18456de
Reviewed-on: https://go-review.googlesource.com/c/go/+/313769
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/syscall/syscall_linux.go | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/syscall/syscall_linux.go b/src/syscall/syscall_linux.go
index 24e051dcbd..dfce3d0a4b 100644
--- a/src/syscall/syscall_linux.go
+++ b/src/syscall/syscall_linux.go
@@ -553,7 +553,11 @@ func anyToSockaddr(rsa *RawSockaddrAny) (Sockaddr, error) {
 func Accept(fd int) (nfd int, sa Sockaddr, err error) {
 	var rsa RawSockaddrAny
 	var len _Socklen = SizeofSockaddrAny
-	nfd, err = accept(fd, &rsa, &len)
+	// Try accept4 first for Android, then try accept for kernel older than 2.6.28
+	nfd, err = accept4(fd, &rsa, &len, 0)
+	if err == ENOSYS {
+		nfd, err = accept(fd, &rsa, &len)
+	}
 	if err != nil {
 		return
 	}
-- 
GitLab


From 40254ec0db6d02118df141dbe7fcb6a95aec6560 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Sun, 25 Apr 2021 15:46:30 +0700
Subject: [PATCH 1771/2400] cmd/compile: fix wrong package path for
 unsafe.Pointer

It's not a predeclared type, but a type defined in "unsafe" package.

Fixes #44830

Change-Id: If39815b1070059b608be8231dfac9b7f3307cb15
Reviewed-on: https://go-review.googlesource.com/c/go/+/313349
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 .../compile/internal/reflectdata/reflect.go   |  2 +-
 test/fixedbugs/issue44830.go                  | 19 +++++++++++++++++++
 2 files changed, 20 insertions(+), 1 deletion(-)
 create mode 100644 test/fixedbugs/issue44830.go

diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index d23ca6b839..26b08ee08a 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -595,7 +595,7 @@ func typePkg(t *types.Type) *types.Pkg {
 			}
 		}
 	}
-	if tsym != nil && t != types.Types[t.Kind()] && t != types.ErrorType {
+	if tsym != nil && tsym.Pkg != types.BuiltinPkg {
 		return tsym.Pkg
 	}
 	return nil
diff --git a/test/fixedbugs/issue44830.go b/test/fixedbugs/issue44830.go
new file mode 100644
index 0000000000..7df5aeb857
--- /dev/null
+++ b/test/fixedbugs/issue44830.go
@@ -0,0 +1,19 @@
+// run
+
+// Copyright 2021 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 (
+	"reflect"
+	"unsafe"
+)
+
+func main() {
+	t := reflect.TypeOf(unsafe.Pointer(nil))
+	if pkgPath := t.PkgPath(); pkgPath != "unsafe" {
+		panic("unexpected t.PkgPath(): " + pkgPath)
+	}
+}
-- 
GitLab


From 15105dd4b56610e18fa4b5744c7deca069085bc5 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Mon, 26 Apr 2021 19:23:05 -0400
Subject: [PATCH 1772/2400] go/types: walk all imports when determining package
 name ambiguity

CL 209578 disambiguated paths among imported packages, but as
demonstrated in #43119, formatted types may reference packages that are
not directly imported.

Fix this by recursively walking all imports to determine whether there
is any ambiguity in the import graph. This might result in
over-qualification of names, but it is straightforward and should
eliminate any ambiguity.

In general this should be fine, but might introduce risk of infinite
recursion in the case of an importer bug, or performance problems for
very large import graphs. Mitigate the former by tracking seen packages,
and the latter by only walking the import graph once an error has been
produced.

Fixes #43119

Change-Id: If874f050ad0e808db8e354c2ffc88bc6d64fd277
Reviewed-on: https://go-review.googlesource.com/c/go/+/313035
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/check.go       | 21 ++++++++++----
 src/go/types/errors.go      | 27 +++++++++++++++++-
 src/go/types/issues_test.go | 55 +++++++++++++++++++++++++++++++++----
 src/go/types/resolver.go    |  6 +++-
 4 files changed, 97 insertions(+), 12 deletions(-)

diff --git a/src/go/types/check.go b/src/go/types/check.go
index 2c8f683ad5..4053fe2f4a 100644
--- a/src/go/types/check.go
+++ b/src/go/types/check.go
@@ -91,7 +91,16 @@ type Checker struct {
 	impMap  map[importKey]*Package     // maps (import path, source directory) to (complete or fake) package
 	posMap  map[*Interface][]token.Pos // maps interface types to lists of embedded interface positions
 	typMap  map[string]*Named          // maps an instantiated named type hash to a *Named type
-	pkgCnt  map[string]int             // counts number of imported packages with a given name (for better error messages)
+
+	// pkgPathMap maps package names to the set of distinct import paths we've
+	// seen for that name, anywhere in the import graph. It is used for
+	// disambiguating package names in error messages.
+	//
+	// pkgPathMap is allocated lazily, so that we don't pay the price of building
+	// it on the happy path. seenPkgMap tracks the packages that we've already
+	// walked.
+	pkgPathMap map[string]map[string]bool
+	seenPkgMap map[*Package]bool
 
 	// information collected during type-checking of a set of package files
 	// (initialized by Files, valid only for the duration of check.Files;
@@ -187,7 +196,6 @@ func NewChecker(conf *Config, fset *token.FileSet, pkg *Package, info *Info) *Ch
 		impMap:  make(map[importKey]*Package),
 		posMap:  make(map[*Interface][]token.Pos),
 		typMap:  make(map[string]*Named),
-		pkgCnt:  make(map[string]int),
 	}
 }
 
@@ -265,9 +273,6 @@ func (check *Checker) checkFiles(files []*ast.File) (err error) {
 	if !check.conf.DisableUnusedImportCheck {
 		check.unusedImports()
 	}
-	// no longer needed - release memory
-	check.imports = nil
-	check.dotImportMap = nil
 
 	check.recordUntyped()
 
@@ -277,6 +282,12 @@ func (check *Checker) checkFiles(files []*ast.File) (err error) {
 
 	check.pkg.complete = true
 
+	// no longer needed - release memory
+	check.imports = nil
+	check.dotImportMap = nil
+	check.pkgPathMap = nil
+	check.seenPkgMap = nil
+
 	// TODO(rFindley) There's more memory we should release at this point.
 
 	return
diff --git a/src/go/types/errors.go b/src/go/types/errors.go
index a956256762..19e9ae8d44 100644
--- a/src/go/types/errors.go
+++ b/src/go/types/errors.go
@@ -28,8 +28,13 @@ func unreachable() {
 func (check *Checker) qualifier(pkg *Package) string {
 	// Qualify the package unless it's the package being type-checked.
 	if pkg != check.pkg {
+		if check.pkgPathMap == nil {
+			check.pkgPathMap = make(map[string]map[string]bool)
+			check.seenPkgMap = make(map[*Package]bool)
+			check.markImports(pkg)
+		}
 		// If the same package name was used by multiple packages, display the full path.
-		if check.pkgCnt[pkg.name] > 1 {
+		if len(check.pkgPathMap[pkg.name]) > 1 {
 			return strconv.Quote(pkg.path)
 		}
 		return pkg.name
@@ -37,6 +42,26 @@ func (check *Checker) qualifier(pkg *Package) string {
 	return ""
 }
 
+// markImports recursively walks pkg and its imports, to record unique import
+// paths in pkgPathMap.
+func (check *Checker) markImports(pkg *Package) {
+	if check.seenPkgMap[pkg] {
+		return
+	}
+	check.seenPkgMap[pkg] = true
+
+	forName, ok := check.pkgPathMap[pkg.name]
+	if !ok {
+		forName = make(map[string]bool)
+		check.pkgPathMap[pkg.name] = forName
+	}
+	forName[pkg.path] = true
+
+	for _, imp := range pkg.imports {
+		check.markImports(imp)
+	}
+}
+
 func (check *Checker) sprintf(format string, args ...interface{}) string {
 	for i, arg := range args {
 		switch a := arg.(type) {
diff --git a/src/go/types/issues_test.go b/src/go/types/issues_test.go
index a773a362c7..44926919ef 100644
--- a/src/go/types/issues_test.go
+++ b/src/go/types/issues_test.go
@@ -477,7 +477,7 @@ func TestIssue34151(t *testing.T) {
 	}
 
 	bast := mustParse(t, bsrc)
-	conf := Config{Importer: importHelper{a}}
+	conf := Config{Importer: importHelper{pkg: a}}
 	b, err := conf.Check(bast.Name.Name, fset, []*ast.File{bast}, nil)
 	if err != nil {
 		t.Errorf("package %s failed to typecheck: %v", b.Name(), err)
@@ -485,14 +485,18 @@ func TestIssue34151(t *testing.T) {
 }
 
 type importHelper struct {
-	pkg *Package
+	pkg      *Package
+	fallback Importer
 }
 
 func (h importHelper) Import(path string) (*Package, error) {
-	if path != h.pkg.Path() {
+	if path == h.pkg.Path() {
+		return h.pkg, nil
+	}
+	if h.fallback == nil {
 		return nil, fmt.Errorf("got package path %q; want %q", path, h.pkg.Path())
 	}
-	return h.pkg, nil
+	return h.fallback.Import(path)
 }
 
 // TestIssue34921 verifies that we don't update an imported type's underlying
@@ -516,7 +520,7 @@ func TestIssue34921(t *testing.T) {
 	var pkg *Package
 	for _, src := range sources {
 		f := mustParse(t, src)
-		conf := Config{Importer: importHelper{pkg}}
+		conf := Config{Importer: importHelper{pkg: pkg}}
 		res, err := conf.Check(f.Name.Name, fset, []*ast.File{f}, nil)
 		if err != nil {
 			t.Errorf("%q failed to typecheck: %v", src, err)
@@ -571,3 +575,44 @@ func TestIssue44515(t *testing.T) {
 		t.Errorf("got %q; want %q", got, want)
 	}
 }
+
+func TestIssue43124(t *testing.T) {
+	// TODO(rFindley) enhance the testdata tests to be able to express this type
+	//                of setup.
+
+	// All involved packages have the same name (template). Error messages should
+	// disambiguate between text/template and html/template by printing the full
+	// path.
+	const (
+		asrc = `package a; import "text/template"; func F(template.Template) {}; func G(int) {}`
+		bsrc = `package b; import ("a"; "html/template"); func _() { a.F(template.Template{}) }`
+		csrc = `package c; import ("a"; "html/template"); func _() { a.G(template.Template{}) }`
+	)
+
+	a, err := pkgFor("a", asrc, nil)
+	if err != nil {
+		t.Fatalf("package a failed to typecheck: %v", err)
+	}
+	conf := Config{Importer: importHelper{pkg: a, fallback: importer.Default()}}
+
+	// Packages should be fully qualified when there is ambiguity within the
+	// error string itself.
+	bast := mustParse(t, bsrc)
+	_, err = conf.Check(bast.Name.Name, fset, []*ast.File{bast}, nil)
+	if err == nil {
+		t.Fatal("package b had no errors")
+	}
+	if !strings.Contains(err.Error(), "text/template") || !strings.Contains(err.Error(), "html/template") {
+		t.Errorf("type checking error for b does not disambiguate package template: %q", err)
+	}
+
+	// ...and also when there is any ambiguity in reachable packages.
+	cast := mustParse(t, csrc)
+	_, err = conf.Check(cast.Name.Name, fset, []*ast.File{cast}, nil)
+	if err == nil {
+		t.Fatal("package c had no errors")
+	}
+	if !strings.Contains(err.Error(), "html/template") {
+		t.Errorf("type checking error for c does not disambiguate package template: %q", err)
+	}
+}
diff --git a/src/go/types/resolver.go b/src/go/types/resolver.go
index 43d2c739a5..f67fc65cd1 100644
--- a/src/go/types/resolver.go
+++ b/src/go/types/resolver.go
@@ -192,7 +192,11 @@ func (check *Checker) importPackage(at positioner, path, dir string) *Package {
 	// package should be complete or marked fake, but be cautious
 	if imp.complete || imp.fake {
 		check.impMap[key] = imp
-		check.pkgCnt[imp.name]++
+		// Once we've formatted an error message once, keep the pkgPathMap
+		// up-to-date on subsequent imports.
+		if check.pkgPathMap != nil {
+			check.markImports(imp)
+		}
 		return imp
 	}
 
-- 
GitLab


From 434e12f77223e0915e29bcdaf2b214e52213f2ab Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Tue, 27 Apr 2021 08:30:41 +0700
Subject: [PATCH 1773/2400] cmd/compile: add more doc for Name.Defn

As discussion in CL 313289, Name.Defn is also be set for variables
declared in type switch, or name function.

Change-Id: I3deb3d79fca269356e4432b77df7c7720a523674
Reviewed-on: https://go-review.googlesource.com/c/go/+/313889
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/ir/name.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 5697213eac..b6c68bc5e0 100644
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -49,7 +49,9 @@ type Name struct {
 
 	PkgName *PkgName // real package for import . names
 	// For a local variable (not param) or extern, the initializing assignment (OAS or OAS2).
-	// For a closure var, the ONAME node of the outer captured variable
+	// For a closure var, the ONAME node of the outer captured variable.
+	// For the case-local variables of a type switch, the type switch guard (OTYPESW).
+	// For the name of a function, points to corresponding Func node.
 	Defn Node
 
 	// The function, method, or closure in which local variable or param is declared.
-- 
GitLab


From 3cc3a16029eea1c3d9fefa77a24a89760c7aa27d Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Wed, 21 Apr 2021 16:04:26 -0400
Subject: [PATCH 1774/2400] cmd/go: add tests for convergence in 'go mod tidy'

For #36460

Change-Id: I40194bb1ebab77459e5c9d43bdac4d9c1b826ac2
Reviewed-on: https://go-review.googlesource.com/c/go/+/312449
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 .../testdata/script/mod_tidy_convergence.txt  | 174 +++++++++++
 .../script/mod_tidy_convergence_loop.txt      | 272 ++++++++++++++++++
 2 files changed, 446 insertions(+)
 create mode 100644 src/cmd/go/testdata/script/mod_tidy_convergence.txt
 create mode 100644 src/cmd/go/testdata/script/mod_tidy_convergence_loop.txt

diff --git a/src/cmd/go/testdata/script/mod_tidy_convergence.txt b/src/cmd/go/testdata/script/mod_tidy_convergence.txt
new file mode 100644
index 0000000000..de85d23e5d
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_tidy_convergence.txt
@@ -0,0 +1,174 @@
+# This test demonstrates a simple case in which 'go mod tidy' may resolve a
+# missing package, only to remove that package when resolving its dependencies.
+#
+# If we naively iterate 'go mod tidy' until the dependency graph converges, this
+# scenario may fail to converge.
+
+# The import graph used in this test looks like:
+#
+# m --- x
+#       |
+#       x_test --- y
+#
+# The module dependency graph of m is initially empty.
+# Modules x and y look like:
+#
+# x.1 (provides package x that imports y, but does not depend on module y)
+#
+# x.2-pre (no dependencies, but does not provide package x)
+#
+# y.1 (no dependencies, but provides package y)
+#
+# y.2 --- x.2-pre (provides package y)
+#
+#
+# When we resolve the missing import of y in x_test, we add y@latest — which is
+# y.2, not y.1 — as a new dependency. That upgrades to x to x.2-pre, which
+# removes package x (and also the need for module y). We can then safely remove
+# the dependency on module y, because nothing imports package y any more!
+#
+# We might be tempted to remove the dependency on module x for the same reason:
+# it no longer provides any imported package. However, that would cause 'go mod
+# tidy -e' to become unstable: with x.2-pre out of the way, we could once again
+# resolve the missing import of package x by re-adding x.1.
+
+cp go.mod go.mod.orig
+
+# 'go mod tidy' without -e should fail without modifying go.mod,
+# because it cannot resolve x and y simultaneously.
+! go mod tidy
+
+cmp go.mod go.mod.orig
+
+stderr '^go: found example\.net/y in example\.net/y v0.2.0$'
+stderr '^go: finding module for package example\.net/x$'
+
+	# TODO: This error message should be clearer — it doesn't indicate why v0.2.0-pre is required.
+stderr '^example\.net/m imports\n\texample\.net/x: package example\.net/x provided by example\.net/x at latest version v0\.1\.0 but not at required version v0\.2\.0-pre$'
+
+
+# 'go mod tidy -e' should follow upgrades to try to resolve the modules that it
+# can, and then stop. When we resolve example.net/y, we upgrade to example.net/x
+# to v0.2.0-pre. At that version, package x no longer exists and no longer
+# imports package y, so the import of x should be left unsatisfied and the
+# existing dependency on example.net/x removed.
+#
+# TODO(bcmills): It would be ever better if we could keep the original
+# dependency on example.net/x v0.1.0, but I don't see a way to do that without
+# making the algorithm way too complicated. (We would have to detect that the
+# new dependency on example.net/y interferes with the package that caused us to
+# to add that dependency in the first place, and back out that part of the change
+# without also backing out any other needed changes.)
+
+go mod tidy -e
+cmp go.mod go.mod.tidye
+stderr '^go: found example\.net/y in example\.net/y v0.2.0$'
+
+	# TODO: This error message should be clearer — it doesn't indicate why v0.2.0-pre is required.
+stderr '^example\.net/m imports\n\texample\.net/x: package example\.net/x provided by example\.net/x at latest version v0\.1\.0 but not at required version v0\.2\.0-pre$'
+
+
+# Since we attempt to resolve the dependencies of package x whenever we add x itself,
+# this end state is stable.
+
+go mod tidy -e
+cmp go.mod go.mod.tidye
+
+
+# An explicit 'go get' with the correct versions should allow 'go mod tidy' to
+# succeed and remain stable. y.1 does not upgrade x, and can therefore be used
+# with it.
+
+go get -d example.net/x@v0.1.0 example.net/y@v0.1.0
+go mod tidy
+cmp go.mod go.mod.postget
+
+
+
+# TODO(#36460): Repeat this test with a lazy main module.
+
+
+-- go.mod --
+module example.net/m
+
+go 1.16
+
+replace (
+	example.net/x v0.1.0 => ./x1
+	example.net/x v0.2.0-pre => ./x2-pre
+	example.net/y v0.1.0 => ./y1
+	example.net/y v0.2.0 => ./y2
+)
+
+require (
+	example.net/x v0.1.0
+)
+-- go.mod.tidye --
+module example.net/m
+
+go 1.16
+
+replace (
+	example.net/x v0.1.0 => ./x1
+	example.net/x v0.2.0-pre => ./x2-pre
+	example.net/y v0.1.0 => ./y1
+	example.net/y v0.2.0 => ./y2
+)
+-- go.mod.postget --
+module example.net/m
+
+go 1.16
+
+replace (
+	example.net/x v0.1.0 => ./x1
+	example.net/x v0.2.0-pre => ./x2-pre
+	example.net/y v0.1.0 => ./y1
+	example.net/y v0.2.0 => ./y2
+)
+
+require (
+	example.net/x v0.1.0
+	example.net/y v0.1.0 // indirect
+)
+-- m.go --
+package m
+
+import _ "example.net/x"
+
+-- x1/go.mod --
+module example.net/x
+
+go 1.16
+-- x1/x.go --
+package x
+-- x1/x_test.go --
+package x
+
+import _ "example.net/y"
+
+-- x2-pre/go.mod --
+module example.net/x
+
+go 1.16
+-- x2-pre/README.txt --
+There is no package x here. Use example.com/x/subpkg instead.
+-- x2-pre/subpkg/subpkg.go --
+package subpkg  // import "example.net/x/subpkg"
+
+-- y1/go.mod --
+module example.net/y
+
+go 1.16
+-- y1/y.go --
+package y
+
+-- y2/go.mod --
+module example.net/y
+
+go 1.16
+
+require example.net/x v0.2.0-pre
+-- y2/y.go --
+package y
+
+import _ "example.net/x/subpkg"
diff --git a/src/cmd/go/testdata/script/mod_tidy_convergence_loop.txt b/src/cmd/go/testdata/script/mod_tidy_convergence_loop.txt
new file mode 100644
index 0000000000..efcd8f2a55
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_tidy_convergence_loop.txt
@@ -0,0 +1,272 @@
+# This test demonstrates a simple case in which 'go mod tidy' may resolve a
+# missing package, only to remove that package when resolving its dependencies.
+#
+# If we naively iterate 'go mod tidy' until the dependency graph converges, this
+# scenario may fail to converge.
+
+# The import graph used in this test looks like:
+#
+# m --- w
+# |
+# + --- x
+# |
+# + --- y
+# |
+# + --- z
+#
+# The module dependency graph of m initially contains w.1 (and, by extension,
+# y.2-pre and z.2-pre). This is an arbitrary point in the cycle of possible
+# configurations.
+#
+# w.1 requires y.2-pre and z.2-pre
+# x.1 requires z.2-pre and w.2-pre
+# y.1 requires w.2-pre and x.2-pre
+# z.1 requires x.2-pre and y.2-pre
+#
+# At each point, exactly one missing package can be resolved by adding a
+# dependency on the .1 release of the module that provides that package.
+# However, adding that dependency causes the module providing another package to
+# roll over from its .1 release to its .2-pre release, which removes the
+# package. Once the package is removed, 'go mod tidy -e' no longer sees the
+# module as relevant to the main module, and will happily remove the existing
+# dependency on it.
+#
+# The cycle is of length 4 so that at every step only one package can be
+# resolved. This is important because it prevents the iteration from ever
+# reaching a state in which every package is simultaneously over-upgraded — such
+# a state is stable and does not exhibit failure to converge.
+
+cp go.mod go.mod.orig
+
+# 'go mod tidy' without -e should fail without modifying go.mod,
+# because it cannot resolve x, y, and z simultaneously.
+! go mod tidy
+
+cmp go.mod go.mod.orig
+
+stderr '^go: finding module for package example\.net/w$'
+stderr '^go: finding module for package example\.net/x$'
+stderr -count=2 '^go: finding module for package example\.net/y$'
+stderr -count=2 '^go: finding module for package example\.net/z$'
+stderr '^go: found example\.net/x in example\.net/x v0.1.0$'
+
+	# TODO: These error messages should be clearer — it doesn't indicate why v0.2.0-pre is required.
+stderr '^example\.net/m imports\n\texample\.net/w: package example\.net/w provided by example\.net/w at latest version v0\.1\.0 but not at required version v0\.2\.0-pre$'
+stderr '^example\.net/m imports\n\texample\.net/y: package example\.net/y provided by example\.net/y at latest version v0\.1\.0 but not at required version v0\.2\.0-pre$'
+stderr '^example\.net/m imports\n\texample\.net/z: package example\.net/z provided by example\.net/z at latest version v0\.1\.0 but not at required version v0\.2\.0-pre$'
+
+
+# 'go mod tidy -e' should preserve all of the upgrades to modules that could
+# provide the missing packages but don't. That would at least explain why they
+# are missing, and why no individual module can be upgraded in order to satisfy
+# a missing import.
+#
+# TODO(bcmills): Today, it doesn't preserve those upgrades, and instead advances
+# the state by one through the cycle of semi-tidy states.
+
+go mod tidy -e
+
+cmp go.mod go.mod.tidye1
+
+stderr '^go: finding module for package example\.net/w$'
+stderr '^go: finding module for package example\.net/x$'
+stderr -count=2 '^go: finding module for package example\.net/y$'
+stderr -count=2 '^go: finding module for package example\.net/z$'
+stderr '^go: found example\.net/x in example\.net/x v0.1.0$'
+
+stderr '^example\.net/m imports\n\texample\.net/w: package example\.net/w provided by example\.net/w at latest version v0\.1\.0 but not at required version v0\.2\.0-pre$'
+stderr '^example\.net/m imports\n\texample\.net/y: package example\.net/y provided by example\.net/y at latest version v0\.1\.0 but not at required version v0\.2\.0-pre$'
+stderr '^example\.net/m imports\n\texample\.net/z: package example\.net/z provided by example\.net/z at latest version v0\.1\.0 but not at required version v0\.2\.0-pre$'
+
+
+go mod tidy -e
+cmp go.mod go.mod.tidye2
+
+go mod tidy -e
+cmp go.mod go.mod.tidye3
+
+go mod tidy -e
+cmp go.mod go.mod.orig
+
+
+# If we upgrade away all of the packages simultaneously, the resulting tidy
+# state converges at "no dependencies", because simultaneously adding all of the
+# packages simultaneously over-upgrades all of the dependencies, and 'go mod
+# tidy' treats "no package can be added" as a terminal state.
+
+go get -d example.net/w@v0.2.0-pre example.net/x@v0.2.0-pre example.net/y@v0.2.0-pre example.net/z@v0.2.0-pre
+go mod tidy -e
+cmp go.mod go.mod.postget
+go mod tidy -e
+cmp go.mod go.mod.postget
+
+
+# TODO(#36460): Repeat this test with a lazy main module.
+
+
+-- m.go --
+package m
+
+import (
+	_ "example.net/w"
+	_ "example.net/x"
+	_ "example.net/y"
+	_ "example.net/z"
+)
+
+-- go.mod --
+module example.net/m
+
+go 1.16
+
+replace (
+	example.net/w v0.1.0 => ./w1
+	example.net/w v0.2.0-pre => ./w2-pre
+	example.net/x v0.1.0 => ./x1
+	example.net/x v0.2.0-pre => ./x2-pre
+	example.net/y v0.1.0 => ./y1
+	example.net/y v0.2.0-pre => ./y2-pre
+	example.net/z v0.1.0 => ./z1
+	example.net/z v0.2.0-pre => ./z2-pre
+)
+
+require example.net/w v0.1.0
+-- go.mod.tidye1 --
+module example.net/m
+
+go 1.16
+
+replace (
+	example.net/w v0.1.0 => ./w1
+	example.net/w v0.2.0-pre => ./w2-pre
+	example.net/x v0.1.0 => ./x1
+	example.net/x v0.2.0-pre => ./x2-pre
+	example.net/y v0.1.0 => ./y1
+	example.net/y v0.2.0-pre => ./y2-pre
+	example.net/z v0.1.0 => ./z1
+	example.net/z v0.2.0-pre => ./z2-pre
+)
+
+require example.net/x v0.1.0
+-- go.mod.tidye2 --
+module example.net/m
+
+go 1.16
+
+replace (
+	example.net/w v0.1.0 => ./w1
+	example.net/w v0.2.0-pre => ./w2-pre
+	example.net/x v0.1.0 => ./x1
+	example.net/x v0.2.0-pre => ./x2-pre
+	example.net/y v0.1.0 => ./y1
+	example.net/y v0.2.0-pre => ./y2-pre
+	example.net/z v0.1.0 => ./z1
+	example.net/z v0.2.0-pre => ./z2-pre
+)
+
+require example.net/y v0.1.0
+-- go.mod.tidye3 --
+module example.net/m
+
+go 1.16
+
+replace (
+	example.net/w v0.1.0 => ./w1
+	example.net/w v0.2.0-pre => ./w2-pre
+	example.net/x v0.1.0 => ./x1
+	example.net/x v0.2.0-pre => ./x2-pre
+	example.net/y v0.1.0 => ./y1
+	example.net/y v0.2.0-pre => ./y2-pre
+	example.net/z v0.1.0 => ./z1
+	example.net/z v0.2.0-pre => ./z2-pre
+)
+
+require example.net/z v0.1.0
+-- go.mod.postget --
+module example.net/m
+
+go 1.16
+
+replace (
+	example.net/w v0.1.0 => ./w1
+	example.net/w v0.2.0-pre => ./w2-pre
+	example.net/x v0.1.0 => ./x1
+	example.net/x v0.2.0-pre => ./x2-pre
+	example.net/y v0.1.0 => ./y1
+	example.net/y v0.2.0-pre => ./y2-pre
+	example.net/z v0.1.0 => ./z1
+	example.net/z v0.2.0-pre => ./z2-pre
+)
+-- w1/go.mod --
+module example.net/w
+
+go 1.16
+
+require (
+	example.net/y v0.2.0-pre
+	example.net/z v0.2.0-pre
+)
+-- w1/w.go --
+package w
+-- w2-pre/go.mod --
+module example.net/w
+
+go 1.16
+-- w2-pre/README.txt --
+Package w has been removed.
+
+-- x1/go.mod --
+module example.net/x
+
+go 1.16
+
+require (
+	example.net/z v0.2.0-pre
+	example.net/w v0.2.0-pre
+)
+-- x1/x.go --
+package x
+-- x2-pre/go.mod --
+module example.net/x
+
+go 1.16
+-- x2-pre/README.txt --
+Package x has been removed.
+
+-- y1/go.mod --
+module example.net/y
+
+go 1.16
+
+require (
+	example.net/w v0.2.0-pre
+	example.net/x v0.2.0-pre
+)
+-- y1/y.go --
+package y
+
+-- y2-pre/go.mod --
+module example.net/y
+
+go 1.16
+-- y2-pre/README.txt --
+Package y has been removed.
+
+-- z1/go.mod --
+module example.net/z
+
+go 1.16
+
+require (
+	example.net/x v0.2.0-pre
+	example.net/y v0.2.0-pre
+)
+-- z1/z.go --
+package z
+
+-- z2-pre/go.mod --
+module example.net/z
+
+go 1.16
+-- z2-pre/README.txt --
+Package z has been removed.
-- 
GitLab


From 7ef0237d89b7cf5ca9537e926aca3ca59944e1e0 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 16 Apr 2021 17:00:02 -0400
Subject: [PATCH 1775/2400] cmd/go/internal/modload: clean up error reporting
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

• Consolidate 'if ld.AllowErrors' conditions into an 'ld.errorf'
  method.

• Rename SilenceErrors to SilencePackageErrors and clarify its
  documentation. (There is currently no way to silence errors in the
  module graph. Perhaps we should add one, but for now let's at least
  clarify the existing behavior.)

• Move 'tidy -v' verbose logging into LoadPackages, where other
  logging happens.

• Make checkMultiplePaths a loader method (since it only matters
  during package loading anyway).

• Check package and module-graph errors in loadFromRoots instead of
  LoadPackages. These checks were previously omitted on the
  ImportFromFiles path, which seems likely to be a bug. (We now
  suppress package errors explicitly in ImportFromFiles, which at
  least makes the bug more explicit.)

This somewhat simplifies the code structure in preparation for
the lazy-mode tidy implementation.

For #36460

Change-Id: I3ce3586c6934989d5194f00f99e7cc4423cf767f
Reviewed-on: https://go-review.googlesource.com/c/go/+/313229
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/load/pkg.go          |   2 +-
 src/cmd/go/internal/modcmd/why.go        |   2 +-
 src/cmd/go/internal/modget/get.go        |   2 +-
 src/cmd/go/internal/modload/buildlist.go |  65 ++------
 src/cmd/go/internal/modload/load.go      | 192 +++++++++++++++++------
 5 files changed, 156 insertions(+), 107 deletions(-)

diff --git a/src/cmd/go/internal/load/pkg.go b/src/cmd/go/internal/load/pkg.go
index 79c3a71f07..acba232308 100644
--- a/src/cmd/go/internal/load/pkg.go
+++ b/src/cmd/go/internal/load/pkg.go
@@ -2433,7 +2433,7 @@ func PackagesAndErrors(ctx context.Context, opts PackageOpts, patterns []string)
 		modOpts := modload.PackageOpts{
 			ResolveMissingImports: true,
 			LoadTests:             opts.ModResolveTests,
-			SilenceErrors:         true,
+			SilencePackageErrors:  true,
 		}
 		matches, _ = modload.LoadPackages(ctx, modOpts, patterns...)
 	} else {
diff --git a/src/cmd/go/internal/modcmd/why.go b/src/cmd/go/internal/modcmd/why.go
index db4a396be1..3b14b27c8c 100644
--- a/src/cmd/go/internal/modcmd/why.go
+++ b/src/cmd/go/internal/modcmd/why.go
@@ -71,7 +71,7 @@ func runWhy(ctx context.Context, cmd *base.Command, args []string) {
 		Tags:                     imports.AnyTags(),
 		VendorModulesInGOROOTSrc: true,
 		LoadTests:                !*whyVendor,
-		SilenceErrors:            true,
+		SilencePackageErrors:     true,
 		UseVendorAll:             *whyVendor,
 	}
 
diff --git a/src/cmd/go/internal/modget/get.go b/src/cmd/go/internal/modget/get.go
index 7e6226b0be..3a24b6a2f7 100644
--- a/src/cmd/go/internal/modget/get.go
+++ b/src/cmd/go/internal/modget/get.go
@@ -1152,7 +1152,7 @@ func (r *resolver) loadPackages(ctx context.Context, patterns []string, findPack
 		Tags:                     imports.AnyTags(),
 		VendorModulesInGOROOTSrc: true,
 		LoadTests:                *getT,
-		SilenceErrors:            true, // May be fixed by subsequent upgrades or downgrades.
+		SilencePackageErrors:     true, // May be fixed by subsequent upgrades or downgrades.
 	}
 
 	opts.AllowPackage = func(ctx context.Context, path string, m module.Version) error {
diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index a833dbee62..51fe40581a 100644
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -11,7 +11,7 @@ import (
 	"cmd/go/internal/par"
 	"context"
 	"fmt"
-	"os"
+	"reflect"
 	"runtime"
 	"strings"
 	"sync"
@@ -479,9 +479,9 @@ type Conflict struct {
 	Constraint module.Version
 }
 
-// tidyBuildList trims the build list to the minimal requirements needed to
+// tidyRoots trims the root requirements to the minimal roots needed to
 // retain the same versions of all packages loaded by ld.
-func tidyBuildList(ctx context.Context, ld *loader, initialRS *Requirements) *Requirements {
+func tidyRoots(ctx context.Context, rs *Requirements, pkgs []*loadPkg) (*Requirements, error) {
 	if go117LazyTODO {
 		// Tidy needs to maintain the lazy-loading invariants for lazy modules.
 		// The implementation for eager modules should be factored out into a function.
@@ -493,33 +493,10 @@ func tidyBuildList(ctx context.Context, ld *loader, initialRS *Requirements) *Re
 		// changed after loading packages.
 	}
 
-	var (
-		tidy *Requirements
-		err  error
-	)
-	if depth == lazy {
-		panic("internal error: 'go mod tidy' for lazy modules is not yet implemented")
-	} else {
-		tidy, err = tidyEagerRoots(ctx, ld.requirements, ld.pkgs)
-	}
-	if err != nil {
-		base.Fatalf("go: %v", err)
+	if depth == eager {
+		return tidyEagerRoots(ctx, rs, pkgs)
 	}
-
-	if cfg.BuildV {
-		mg, _ := tidy.Graph(ctx)
-
-		for _, m := range initialRS.rootModules {
-			if mg.Selected(m.Path) == "none" {
-				fmt.Fprintf(os.Stderr, "unused %s\n", m.Path)
-			} else if go117LazyTODO {
-				// If the main module is lazy and we demote a root to a non-root
-				// (because it is not actually relevant), should we log that too?
-			}
-		}
-	}
-
-	return tidy
+	panic("internal error: 'go mod tidy' for lazy modules is not yet implemented")
 }
 
 // tidyEagerRoots returns a minimal set of root requirements that maintains the
@@ -550,7 +527,11 @@ func tidyEagerRoots(ctx context.Context, rs *Requirements, pkgs []*loadPkg) (*Re
 
 	min, err := mvs.Req(Target, rootPaths, &mvsReqs{roots: keep})
 	if err != nil {
-		return nil, err
+		return rs, err
+	}
+	if reflect.DeepEqual(min, rs.rootModules) {
+		// rs is already tidy, so preserve its cached graph.
+		return rs, nil
 	}
 	return newRequirements(eager, min, rs.direct), nil
 }
@@ -660,27 +641,3 @@ func updateRoots(ctx context.Context, direct map[string]bool, rs *Requirements,
 
 	return newRequirements(rs.depth, min, direct), nil
 }
-
-// checkMultiplePaths verifies that a given module path is used as itself
-// or as a replacement for another module, but not both at the same time.
-//
-// (See https://golang.org/issue/26607 and https://golang.org/issue/34650.)
-func checkMultiplePaths(rs *Requirements) {
-	mods := rs.rootModules
-	if cached := rs.graph.Load(); cached != nil {
-		if mg := cached.(cachedGraph).mg; mg != nil {
-			mods = mg.BuildList()
-		}
-	}
-
-	firstPath := map[module.Version]string{}
-	for _, mod := range mods {
-		src := resolveReplacement(mod)
-		if prev, ok := firstPath[src]; !ok {
-			firstPath[src] = mod.Path
-		} else if prev != mod.Path {
-			base.Errorf("go: %s@%s used for two different module paths (%s and %s)", src.Path, src.Version, prev, mod.Path)
-		}
-	}
-	base.ExitIfErrors()
-}
diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index 8cbb768341..d4d100e196 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -180,9 +180,16 @@ type PackageOpts struct {
 	// an error occurs.
 	AllowErrors bool
 
-	// SilenceErrors indicates that LoadPackages should not print errors
-	// that occur while loading packages. SilenceErrors implies AllowErrors.
-	SilenceErrors bool
+	// SilencePackageErrors indicates that LoadPackages should not print errors
+	// that occur while matching or loading packages, and should not terminate the
+	// process if such an error occurs.
+	//
+	// Errors encountered in the module graph will still be reported.
+	//
+	// The caller may retrieve the silenced package errors using the Lookup
+	// function, and matching errors are still populated in the Errs field of the
+	// associated search.Match.)
+	SilencePackageErrors bool
 
 	// SilenceMissingStdImports indicates that LoadPackages should not print
 	// errors or terminate the process if an imported package is missing, and the
@@ -317,50 +324,12 @@ func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (ma
 	// One last pass to finalize wildcards.
 	updateMatches(ld.requirements, ld)
 
-	// Report errors, if any.
-	checkMultiplePaths(ld.requirements)
-	for _, pkg := range ld.pkgs {
-		if !pkg.isTest() {
-			loadedPackages = append(loadedPackages, pkg.path)
-		}
-
-		if pkg.err != nil {
-			if sumErr := (*ImportMissingSumError)(nil); errors.As(pkg.err, &sumErr) {
-				if importer := pkg.stack; importer != nil {
-					sumErr.importer = importer.path
-					sumErr.importerVersion = importer.mod.Version
-					sumErr.importerIsTest = importer.testOf != nil
-				}
-			}
-
-			if opts.SilenceErrors {
-				continue
-			}
-			if stdErr := (*ImportMissingError)(nil); errors.As(pkg.err, &stdErr) &&
-				stdErr.isStd && opts.SilenceMissingStdImports {
-				continue
-			}
-			if opts.SilenceNoGoErrors && errors.Is(pkg.err, imports.ErrNoGo) {
-				continue
-			}
-
-			if opts.AllowErrors {
-				fmt.Fprintf(os.Stderr, "%s: %v\n", pkg.stackText(), pkg.err)
-			} else {
-				base.Errorf("%s: %v", pkg.stackText(), pkg.err)
-			}
-		}
-	}
-	if !opts.SilenceErrors {
-		// Also list errors in matching patterns (such as directory permission
-		// errors for wildcard patterns).
+	// List errors in matching patterns (such as directory permission
+	// errors for wildcard patterns).
+	if !ld.SilencePackageErrors {
 		for _, match := range matches {
 			for _, err := range match.Errs {
-				if opts.AllowErrors {
-					fmt.Fprintf(os.Stderr, "%v\n", err)
-				} else {
-					base.Errorf("%v", err)
-				}
+				ld.errorf("%v\n", err)
 			}
 		}
 	}
@@ -370,14 +339,42 @@ func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (ma
 		search.WarnUnmatched(matches)
 	}
 
-	if ld.Tidy {
-		ld.requirements = tidyBuildList(ctx, ld, initialRS)
+	if opts.Tidy {
+		if cfg.BuildV {
+			mg, _ := ld.requirements.Graph(ctx)
+
+			for _, m := range initialRS.rootModules {
+				var unused bool
+				if ld.requirements.depth == eager {
+					// m is unused if it was dropped from the module graph entirely. If it
+					// was only demoted from direct to indirect, it may still be in use via
+					// a transitive import.
+					unused = mg.Selected(m.Path) == "none"
+				} else {
+					// m is unused if it was dropped from the roots. If it is still present
+					// as a transitive dependency, that transitive dependency is not needed
+					// by any package or test in the main module.
+					_, ok := ld.requirements.rootSelected(m.Path)
+					unused = !ok
+				}
+				if unused {
+					fmt.Fprintf(os.Stderr, "unused %s\n", m.Path)
+				}
+			}
+		}
+
 		modfetch.TrimGoSum(keepSums(ctx, ld, ld.requirements, loadedZipSumsOnly))
 	}
 
-	// Success! Update go.mod (if needed) and return the results.
+	// Success! Update go.mod and go.sum (if needed) and return the results.
 	loaded = ld
 	commitRequirements(ctx, loaded.requirements)
+
+	for _, pkg := range ld.pkgs {
+		if !pkg.isTest() {
+			loadedPackages = append(loadedPackages, pkg.path)
+		}
+	}
 	sort.Strings(loadedPackages)
 	return matches, loadedPackages
 }
@@ -582,6 +579,11 @@ func pathInModuleCache(ctx context.Context, dir string, rs *Requirements) string
 
 // ImportFromFiles adds modules to the build list as needed
 // to satisfy the imports in the named Go source files.
+//
+// Errors in missing dependencies are silenced.
+//
+// TODO(bcmills): Silencing errors seems off. Take a closer look at this and
+// figure out what the error-reporting actually ought to be.
 func ImportFromFiles(ctx context.Context, gofiles []string) {
 	rs := LoadModFile(ctx)
 
@@ -595,6 +597,7 @@ func ImportFromFiles(ctx context.Context, gofiles []string) {
 		PackageOpts: PackageOpts{
 			Tags:                  tags,
 			ResolveMissingImports: true,
+			SilencePackageErrors:  true,
 		},
 		requirements:       rs,
 		allClosesOverTests: index.allPatternClosesOverTests(),
@@ -772,6 +775,16 @@ func (ld *loader) reset() {
 	ld.pkgs = nil
 }
 
+// errorf reports an error via either os.Stderr or base.Errorf,
+// according to whether ld.AllowErrors is set.
+func (ld *loader) errorf(format string, args ...interface{}) {
+	if ld.AllowErrors {
+		fmt.Fprintf(os.Stderr, format, args...)
+	} else {
+		base.Errorf(format, args...)
+	}
+}
+
 // A loadPkg records information about a single loaded package.
 type loadPkg struct {
 	// Populated at construction time:
@@ -890,6 +903,14 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 		work:         par.NewQueue(runtime.GOMAXPROCS(0)),
 	}
 
+	if ld.requirements.depth == eager {
+		var err error
+		ld.requirements, _, err = expandGraph(ctx, ld.requirements)
+		if err != nil {
+			ld.errorf("go: %v\n", err)
+		}
+	}
+
 	for {
 		ld.reset()
 
@@ -971,6 +992,46 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 		// changing the build list. Iterate until the roots are stable.
 	}
 
+	// Tidy the build list, if applicable, before we report errors.
+	// (The process of tidying may remove errors from irrelevant dependencies.)
+	if ld.Tidy {
+		var err error
+		ld.requirements, err = tidyRoots(ctx, ld.requirements, ld.pkgs)
+		if err != nil {
+			ld.errorf("go: %v\n", err)
+		}
+	}
+
+	// Report errors, if any.
+	for _, pkg := range ld.pkgs {
+		if pkg.err == nil {
+			continue
+		}
+
+		// Add importer information to checksum errors.
+		if sumErr := (*ImportMissingSumError)(nil); errors.As(pkg.err, &sumErr) {
+			if importer := pkg.stack; importer != nil {
+				sumErr.importer = importer.path
+				sumErr.importerVersion = importer.mod.Version
+				sumErr.importerIsTest = importer.testOf != nil
+			}
+		}
+
+		if ld.SilencePackageErrors {
+			continue
+		}
+		if stdErr := (*ImportMissingError)(nil); errors.As(pkg.err, &stdErr) &&
+			stdErr.isStd && ld.SilenceMissingStdImports {
+			continue
+		}
+		if ld.SilenceNoGoErrors && errors.Is(pkg.err, imports.ErrNoGo) {
+			continue
+		}
+
+		ld.errorf("%s: %v\n", pkg.stackText(), pkg.err)
+	}
+
+	ld.checkMultiplePaths()
 	return ld
 }
 
@@ -1044,10 +1105,18 @@ func (ld *loader) updateRequirements(ctx context.Context, add []module.Version)
 	}
 
 	rs, err := updateRoots(ctx, direct, rs, add)
-	if err == nil {
+	if err != nil {
+		// We don't actually know what even the root requirements are supposed to be,
+		// so we can't proceed with loading. Return the error to the caller
+		return err
+	}
+	if rs != ld.requirements {
+		if _, err := rs.Graph(ctx); err != nil {
+			ld.errorf("go: %v\n", err)
+		}
 		ld.requirements = rs
 	}
-	return err
+	return nil
 }
 
 // resolveMissingImports returns a set of modules that could be added as
@@ -1387,6 +1456,29 @@ func (ld *loader) computePatternAll() (all []string) {
 	return all
 }
 
+// checkMultiplePaths verifies that a given module path is used as itself
+// or as a replacement for another module, but not both at the same time.
+//
+// (See https://golang.org/issue/26607 and https://golang.org/issue/34650.)
+func (ld *loader) checkMultiplePaths() {
+	mods := ld.requirements.rootModules
+	if cached := ld.requirements.graph.Load(); cached != nil {
+		if mg := cached.(cachedGraph).mg; mg != nil {
+			mods = mg.BuildList()
+		}
+	}
+
+	firstPath := map[module.Version]string{}
+	for _, mod := range mods {
+		src := resolveReplacement(mod)
+		if prev, ok := firstPath[src]; !ok {
+			firstPath[src] = mod.Path
+		} else if prev != mod.Path {
+			ld.errorf("go: %s@%s used for two different module paths (%s and %s)", src.Path, src.Version, prev, mod.Path)
+		}
+	}
+}
+
 // scanDir is like imports.ScanDir but elides known magic imports from the list,
 // so that we do not go looking for packages that don't really exist.
 //
-- 
GitLab


From c249491572db67acd226210dbcfb4f349614a632 Mon Sep 17 00:00:00 2001
From: lixianyang <lee1300394324@gmail.com>
Date: Tue, 27 Apr 2021 02:29:59 +0000
Subject: [PATCH 1776/2400] doc: change <a/> to </a> in spec

Change-Id: I21d0ee83c9204d51c587bd944209df2232b460ad
GitHub-Last-Rev: 47fab8dc582baaab5f5cd58a1d53f1c24604c769
GitHub-Pull-Request: golang/go#45771
Reviewed-on: https://go-review.googlesource.com/c/go/+/313449
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 doc/go_spec.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index bbcdd54b02..95bf7d30f8 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -4323,7 +4323,7 @@ MyRunes("白鵬翔")           // []rune{0x767d, 0x9d6c, 0x7fd4}
 <p>
 Converting a slice to an array pointer yields a pointer to the underlying array of the slice.
 If the <a href="#Length_and_capacity">length</a> of the slice is less than the length of the array,
-a <a href="#Run_time_panics">run-time panic<a/> occurs.
+a <a href="#Run_time_panics">run-time panic</a> occurs.
 </p>
 
 <pre>
-- 
GitLab


From cb34026a95f0637a0f9eadb5e1d7aa301635f943 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 26 Apr 2021 22:08:06 -0700
Subject: [PATCH 1777/2400] cmd/compile: tighten exportWriter.qualifiedIdent
 signature

It always takes an *ir.Name and would panic given anything else
anyway, so tighten the signature to match.

Change-Id: I44fec5c5cc6d7f0b9c59eb91c9f9633137485360
Reviewed-on: https://go-review.googlesource.com/c/go/+/314009
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/typecheck/iexport.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index 5955b3d358..ad9eaab07a 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -603,9 +603,9 @@ func (w *exportWriter) pkg(pkg *types.Pkg) {
 	w.string(pkg.Path)
 }
 
-func (w *exportWriter) qualifiedIdent(n ir.Node) {
+func (w *exportWriter) qualifiedIdent(n *ir.Name) {
 	// Ensure any referenced declarations are written out too.
-	w.p.pushDecl(n.Name())
+	w.p.pushDecl(n)
 
 	s := n.Sym()
 	w.string(s.Name)
-- 
GitLab


From ca8e8317be5b288163c3623f936fb234723484cc Mon Sep 17 00:00:00 2001
From: Alex Brainman <alex.brainman@gmail.com>
Date: Mon, 26 Apr 2021 17:56:10 +1000
Subject: [PATCH 1778/2400] runtime: add missing import "C" in
 TestLibraryCtrlHandler

CL 211139 added TestLibraryCtrlHandler. But the CL left out import "C"
line in the test file that is supposed to be build with Cgo.

While debugging issue #45638, I discovered that the DLL built during
TestLibraryCtrlHandler does not have Dummy function. Adding import "C"
makes Dummy function appear in DLL function list.

TestLibraryCtrlHandler does not actually calls Dummy function. So I
don't see how this change affects issue #45638, but still let's make
this code correct.

Updates #45638

Change-Id: Ibab8fed29ef2ae446d0815842cf0bd040a5fb943
Reviewed-on: https://go-review.googlesource.com/c/go/+/313350
Trust: Alex Brainman <alex.brainman@gmail.com>
Run-TryBot: Alex Brainman <alex.brainman@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/testdata/testwinlibsignal/dummy.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/runtime/testdata/testwinlibsignal/dummy.go b/src/runtime/testdata/testwinlibsignal/dummy.go
index 82dfd91c93..e610f15d06 100644
--- a/src/runtime/testdata/testwinlibsignal/dummy.go
+++ b/src/runtime/testdata/testwinlibsignal/dummy.go
@@ -1,7 +1,10 @@
+//go:build windows
 // +build windows
 
 package main
 
+import "C"
+
 //export Dummy
 func Dummy() int {
 	return 42
-- 
GitLab


From e0815d041c55dad8ae5642466b08fc2f520a59d4 Mon Sep 17 00:00:00 2001
From: Alex Brainman <alex.brainman@gmail.com>
Date: Sun, 25 Apr 2021 18:26:30 +1000
Subject: [PATCH 1779/2400] runtime: replace --buildmode with -buildmode in
 tests

While debugging issue #45638, I discovered that some tests were using
--buildmode command line parameter instead of -buildmode.

The --buildmode parameter is handled properly by the flag package - it
is read as -buildmode. But we should correct code anyway.

Updates #45638

Change-Id: I75cf95c7d11dcdf4aeccf568b2dea77bd8942352
Reviewed-on: https://go-review.googlesource.com/c/go/+/313351
Trust: Alex Brainman <alex.brainman@gmail.com>
Run-TryBot: Alex Brainman <alex.brainman@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/signal_windows_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/runtime/signal_windows_test.go b/src/runtime/signal_windows_test.go
index d0f61fb6c2..1b7cb9d4c4 100644
--- a/src/runtime/signal_windows_test.go
+++ b/src/runtime/signal_windows_test.go
@@ -32,7 +32,7 @@ func TestVectoredHandlerDontCrashOnLibrary(t *testing.T) {
 
 	// build go dll
 	dll := filepath.Join(dir, "testwinlib.dll")
-	cmd := exec.Command(testenv.GoToolPath(t), "build", "-o", dll, "--buildmode", "c-shared", "testdata/testwinlib/main.go")
+	cmd := exec.Command(testenv.GoToolPath(t), "build", "-o", dll, "-buildmode", "c-shared", "testdata/testwinlib/main.go")
 	out, err := testenv.CleanCmdEnv(cmd).CombinedOutput()
 	if err != nil {
 		t.Fatalf("failed to build go library: %s\n%s", err, out)
@@ -156,7 +156,7 @@ func TestLibraryCtrlHandler(t *testing.T) {
 
 	// build go dll
 	dll := filepath.Join(dir, "dummy.dll")
-	cmd := exec.Command(testenv.GoToolPath(t), "build", "-o", dll, "--buildmode", "c-shared", "testdata/testwinlibsignal/dummy.go")
+	cmd := exec.Command(testenv.GoToolPath(t), "build", "-o", dll, "-buildmode", "c-shared", "testdata/testwinlibsignal/dummy.go")
 	out, err := testenv.CleanCmdEnv(cmd).CombinedOutput()
 	if err != nil {
 		t.Fatalf("failed to build go library: %s\n%s", err, out)
-- 
GitLab


From 1eca6aa7472604eb7597cbb3b132c6e28b89ee55 Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Tue, 9 Mar 2021 16:55:13 -0600
Subject: [PATCH 1780/2400] cmd/internal/obj: refactor ppc64 address relocation
 code generation

The code for generating a long constant versus generating an address
(either via a relocation, or known offset) should be handled in the
same place.

Resolve this by classifying memory arguments as C_LACON (a long
address constant) instead of C_LCON (a long constant).

Likewise, reorder AMOVD/AMOVW optab entries to keep similar
classifications near each other. An extra optab entry for
DWORD is also added to continue handling C_LACON arguments
correctly.

Change-Id: I5ce28400492a071f615125a9b8d260826f1600d7
Reviewed-on: https://go-review.googlesource.com/c/go/+/312296
Run-TryBot: Paul Murphy <murp@ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
Reviewed-by: Carlos Eduardo Seo <carlos.seo@linaro.org>
Trust: Carlos Eduardo Seo <carlos.seo@linaro.org>
---
 src/cmd/asm/internal/asm/testdata/ppc64.s |  2 ++
 src/cmd/internal/obj/ppc64/asm9.go        | 44 +++++++++++------------
 2 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/src/cmd/asm/internal/asm/testdata/ppc64.s b/src/cmd/asm/internal/asm/testdata/ppc64.s
index edaecaea49..1bd4b1e1c8 100644
--- a/src/cmd/asm/internal/asm/testdata/ppc64.s
+++ b/src/cmd/asm/internal/asm/testdata/ppc64.s
@@ -41,6 +41,8 @@ TEXT asmtest(SB),DUPOK|NOSPLIT,$0
 	MOVDBR (R3)(R4), R5             // 7ca41c28
 	MOVWBR (R3)(R4), R5             // 7ca41c2c
 	MOVHBR (R3)(R4), R5             // 7ca41e2c
+	MOVD $foo+4009806848(FP), R5    // 3fe1ef0138bfcc20
+	MOVD $foo(SB), R5               // 3fe0000038bf0000
 
 	MOVDU 8(R3), R4                 // e8830009
 	MOVDU (R3)(R4), R5              // 7ca4186a
diff --git a/src/cmd/internal/obj/ppc64/asm9.go b/src/cmd/internal/obj/ppc64/asm9.go
index 69c84b21d4..60ffc936c5 100644
--- a/src/cmd/internal/obj/ppc64/asm9.go
+++ b/src/cmd/internal/obj/ppc64/asm9.go
@@ -222,11 +222,11 @@ var optab = []Optab{
 	{as: AMOVD, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4},
 	{as: AMOVD, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4},
 	{as: AMOVD, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVD, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
 	{as: AMOVD, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVD, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
 	{as: AMOVD, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
-	{as: AMOVD, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
 	{as: AMOVD, a1: C_GOTADDR, a6: C_REG, type_: 81, size: 8},
-	{as: AMOVD, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
 	{as: AMOVD, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
 	{as: AMOVD, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
 	{as: AMOVD, a1: C_TLS_LE, a6: C_REG, type_: 79, size: 8},
@@ -242,11 +242,11 @@ var optab = []Optab{
 	{as: AMOVW, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4},
 	{as: AMOVW, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4},
 	{as: AMOVW, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVW, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
 	{as: AMOVW, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
+	{as: AMOVW, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
 	{as: AMOVW, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
-	{as: AMOVW, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
 	{as: AMOVW, a1: C_CREG, a6: C_REG, type_: 68, size: 4},
-	{as: AMOVW, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
 	{as: AMOVW, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
 	{as: AMOVW, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
 	{as: AMOVW, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
@@ -304,6 +304,7 @@ var optab = []Optab{
 	{as: AWORD, a1: C_LCON, type_: 40, size: 4},
 	{as: ADWORD, a1: C_LCON, type_: 31, size: 8},
 	{as: ADWORD, a1: C_DCON, type_: 31, size: 8},
+	{as: ADWORD, a1: C_LACON, type_: 31, size: 8},
 	{as: AADDME, a1: C_REG, a6: C_REG, type_: 47, size: 4},
 	{as: AEXTSB, a1: C_REG, a6: C_REG, type_: 48, size: 4},
 	{as: AEXTSB, a6: C_REG, type_: 48, size: 4},
@@ -877,11 +878,8 @@ func (c *ctxt9) aclass(a *obj.Addr) int {
 			if s == nil {
 				return C_GOK
 			}
-
 			c.instoffset = a.Offset
-
-			/* not sure why this barfs */
-			return C_LCON
+			return C_LACON
 
 		case obj.NAME_AUTO:
 			c.instoffset = int64(c.autosize) + a.Offset
@@ -2775,13 +2773,8 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 
 	case 19: /* mov $lcon,r ==> cau+or */
 		d := c.vregoff(&p.From)
-
-		if p.From.Sym == nil {
-			o1 = loadu32(int(p.To.Reg), d)
-			o2 = LOP_IRR(OP_ORI, uint32(p.To.Reg), uint32(p.To.Reg), uint32(int32(d)))
-		} else {
-			o1, o2 = c.symbolAccess(p.From.Sym, d, p.To.Reg, OP_ADDI)
-		}
+		o1 = loadu32(int(p.To.Reg), d)
+		o2 = LOP_IRR(OP_ORI, uint32(p.To.Reg), uint32(p.To.Reg), uint32(int32(d)))
 
 	case 20: /* add $ucon,,r | addis $addcon,r,r */
 		v := c.regoff(&p.From)
@@ -2899,16 +2892,21 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		}
 
 	case 26: /* mov $lsext/auto/oreg,,r2 ==> addis+addi */
-		if p.To.Reg == REGTMP {
-			c.ctxt.Diag("can't synthesize large constant\n%v", p)
-		}
-		v := c.regoff(&p.From)
+		v := c.vregoff(&p.From)
 		r := int(p.From.Reg)
-		if r == 0 {
-			r = c.getimpliedreg(&p.From, p)
+
+		switch p.From.Name {
+		case obj.NAME_EXTERN, obj.NAME_STATIC:
+			// Load a 32 bit constant, or relocation depending on if a symbol is attached
+			o1, o2 = c.symbolAccess(p.From.Sym, v, p.To.Reg, OP_ADDI)
+		default:
+			if r == 0 {
+				r = c.getimpliedreg(&p.From, p)
+			}
+			// Add a 32 bit offset to a register.
+			o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(int32(v))))
+			o2 = AOP_IRR(OP_ADDI, uint32(p.To.Reg), REGTMP, uint32(v))
 		}
-		o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(v)))
-		o2 = AOP_IRR(OP_ADDI, uint32(p.To.Reg), REGTMP, uint32(v))
 
 	case 27: /* subc ra,$simm,rd => subfic rd,ra,$simm */
 		v := c.regoff(p.GetFrom3())
-- 
GitLab


From 6edd573218709e50dc73c49d5ae465819b7ef226 Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Mon, 5 Apr 2021 13:40:48 -0500
Subject: [PATCH 1781/2400] cmd/link: enforce larger alignment on split ppc64
 text sections

When laying out, we lazily increase the alignment for text sections
as symbols are found requiring more. This works if the start of
the virtual address (VA) for the section is greater than or equal
to the alignment required by any symbols placed in this section.

The minimum alignment of the section is only known after all
symbols are placed. The starting VA of this section is adjusted
upwards in ld.(*Link).address to meet the requested alignment.

This is a problem if the starting VA of the text section is not
already aligned. This can happen when the final symbol placed
into the previous section results in an insufficiently aligned
start VA of the next text section.

To workaround this, additional text sections are split, and both
the starting VA, and alignment of the section are aligned up to
match the known worst case alignment.

64B is chosen as the worst case alignment for all ppc64 targets,
as it will respect PCALIGN and eventually prefixed instructions
which will be introduced in the future.

Likewise, the xcoff size calculations need to be improved to
handle padding bytes when function symbols have been aligned.
This is done by tracking the largest valid VA offset encountered
when placing symbols.

Change-Id: Iefef09a1ee7c963fb8dfce2288a084a95cb77fca
Reviewed-on: https://go-review.googlesource.com/c/go/+/307431
Run-TryBot: Paul Murphy <murp@ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
---
 src/cmd/link/internal/ld/data.go  | 12 ++++++++++
 src/cmd/link/internal/ld/xcoff.go | 37 ++++++++++++++++++++-----------
 2 files changed, 36 insertions(+), 13 deletions(-)

diff --git a/src/cmd/link/internal/ld/data.go b/src/cmd/link/internal/ld/data.go
index b909526de8..a135fe8fd2 100644
--- a/src/cmd/link/internal/ld/data.go
+++ b/src/cmd/link/internal/ld/data.go
@@ -2298,12 +2298,23 @@ func assignAddress(ctxt *Link, sect *sym.Section, n int, s loader.Sym, va uint64
 		}
 
 		if va-sect.Vaddr+funcsize+maxSizeTrampolinesPPC64(ldr, s, isTramp) > textSizelimit {
+			// Align the next text section to the worst case function alignment likely
+			// to be encountered when processing function symbols. The start address
+			// is rounded against the final alignment of the text section later on in
+			// (*Link).address. This may happen due to usage of PCALIGN directives
+			// larger than Funcalign, or usage of ISA 3.1 prefixed instructions
+			// (see ISA 3.1 Book I 1.9).
+			const ppc64maxFuncalign = 64
+			va = uint64(Rnd(int64(va), ppc64maxFuncalign))
+
 			// Set the length for the previous text section
 			sect.Length = va - sect.Vaddr
 
 			// Create new section, set the starting Vaddr
 			sect = addsection(ctxt.loader, ctxt.Arch, &Segtext, ".text", 05)
+
 			sect.Vaddr = va
+			sect.Align = ppc64maxFuncalign
 			ldr.SetSymSect(s, sect)
 
 			// Create a symbol for the start of the secondary text sections
@@ -2316,6 +2327,7 @@ func assignAddress(ctxt *Link, sect *sym.Section, n int, s loader.Sym, va uint64
 				ntext.SetType(sym.STEXT)
 				ntext.SetSize(int64(MINFUNC))
 				ntext.SetOnList(true)
+				ntext.SetAlign(ppc64maxFuncalign)
 				ctxt.tramps = append(ctxt.tramps, ntext.Sym())
 
 				ntext.SetValue(int64(va))
diff --git a/src/cmd/link/internal/ld/xcoff.go b/src/cmd/link/internal/ld/xcoff.go
index d412c6966b..12bd23f7e5 100644
--- a/src/cmd/link/internal/ld/xcoff.go
+++ b/src/cmd/link/internal/ld/xcoff.go
@@ -28,8 +28,11 @@ const (
 	// Total amount of space to reserve at the start of the file
 	// for File Header, Auxiliary Header, and Section Headers.
 	// May waste some.
-	XCOFFHDRRESERVE       = FILHSZ_64 + AOUTHSZ_EXEC64 + SCNHSZ_64*23
-	XCOFFSECTALIGN  int64 = 32 // base on dump -o
+	XCOFFHDRRESERVE = FILHSZ_64 + AOUTHSZ_EXEC64 + SCNHSZ_64*23
+
+	// base on dump -o, then rounded from 32B to 64B to
+	// match worst case elf text section alignment on ppc64.
+	XCOFFSECTALIGN int64 = 64
 
 	// XCOFF binaries should normally have all its sections position-independent.
 	// However, this is not yet possible for .text because of some R_ADDR relocations
@@ -555,11 +558,12 @@ func Xcoffinit(ctxt *Link) {
 
 // type records C_FILE information needed for genasmsym in XCOFF.
 type xcoffSymSrcFile struct {
-	name       string
-	file       *XcoffSymEnt64   // Symbol of this C_FILE
-	csectAux   *XcoffAuxCSect64 // Symbol for the current .csect
-	csectSymNb uint64           // Symbol number for the current .csect
-	csectSize  int64
+	name         string
+	file         *XcoffSymEnt64   // Symbol of this C_FILE
+	csectAux     *XcoffAuxCSect64 // Symbol for the current .csect
+	csectSymNb   uint64           // Symbol number for the current .csect
+	csectVAStart int64
+	csectVAEnd   int64
 }
 
 var (
@@ -746,7 +750,8 @@ func (f *xcoffFile) writeSymbolNewFile(ctxt *Link, name string, firstEntry uint6
 	f.addSymbol(aux)
 
 	currSymSrcFile.csectAux = aux
-	currSymSrcFile.csectSize = 0
+	currSymSrcFile.csectVAStart = int64(firstEntry)
+	currSymSrcFile.csectVAEnd = int64(firstEntry)
 }
 
 // Update values for the previous package.
@@ -768,8 +773,9 @@ func (f *xcoffFile) updatePreviousFile(ctxt *Link, last bool) {
 
 	// update csect scnlen in this auxiliary entry
 	aux := currSymSrcFile.csectAux
-	aux.Xscnlenlo = uint32(currSymSrcFile.csectSize & 0xFFFFFFFF)
-	aux.Xscnlenhi = uint32(currSymSrcFile.csectSize >> 32)
+	csectSize := currSymSrcFile.csectVAEnd - currSymSrcFile.csectVAStart
+	aux.Xscnlenlo = uint32(csectSize & 0xFFFFFFFF)
+	aux.Xscnlenhi = uint32(csectSize >> 32)
 }
 
 // Write symbol representing a .text function.
@@ -832,8 +838,13 @@ func (f *xcoffFile) writeSymbolFunc(ctxt *Link, x loader.Sym) []xcoffSym {
 	ldr.SetSymDynid(x, int32(xfile.symbolCount))
 	syms = append(syms, s)
 
-	// Update current csect size
-	currSymSrcFile.csectSize += ldr.SymSize(x)
+	// Keep track of the section size by tracking the VA range. Individual
+	// alignment differences may introduce a few extra bytes of padding
+	// which are not fully accounted for by ldr.SymSize(x).
+	sv := ldr.SymValue(x) + ldr.SymSize(x)
+	if currSymSrcFile.csectVAEnd < sv {
+		currSymSrcFile.csectVAEnd = sv
+	}
 
 	// create auxiliary entries
 	a2 := &XcoffAuxFcn64{
@@ -1549,7 +1560,7 @@ func (f *xcoffFile) writeFileHeader(ctxt *Link) {
 		f.xahdr.Otoc = uint64(ldr.SymValue(toc))
 		f.xahdr.Osntoc = f.getXCOFFscnum(ldr.SymSect(toc))
 
-		f.xahdr.Oalgntext = int16(logBase2(int(Funcalign)))
+		f.xahdr.Oalgntext = int16(logBase2(int(XCOFFSECTALIGN)))
 		f.xahdr.Oalgndata = 0x5
 
 		binary.Write(ctxt.Out, binary.BigEndian, &f.xfhdr)
-- 
GitLab


From 39844971fb92992305babb4b64d50faa7fea40a0 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Mon, 26 Apr 2021 22:25:56 -0400
Subject: [PATCH 1782/2400] go/types: don't panic when checking a ListExpr in
 exprInternal

As an alternative to CL 312149, add a catch-all error message in
exprInternal when encountering a ListExpr, rather than panicking.

We still might want something like CL 312149 to improve the error
message or recovery from bad indexing.

Change-Id: I865f7cc4eefa4a3b7bd8f3100df96d0144e1712f
Reviewed-on: https://go-review.googlesource.com/c/go/+/313909
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/internal/typeparams/notypeparams.go |  4 ++++
 src/go/internal/typeparams/typeparams.go   |  5 +++++
 src/go/types/expr.go                       |  6 +++++-
 src/go/types/fixedbugs/issue45635.go2      | 23 ++++++++++++++++++++++
 4 files changed, 37 insertions(+), 1 deletion(-)

diff --git a/src/go/internal/typeparams/notypeparams.go b/src/go/internal/typeparams/notypeparams.go
index 7bd62c9efe..a8c25ac2b1 100644
--- a/src/go/internal/typeparams/notypeparams.go
+++ b/src/go/internal/typeparams/notypeparams.go
@@ -30,6 +30,10 @@ func UnpackExpr(expr ast.Expr) []ast.Expr {
 	return []ast.Expr{expr}
 }
 
+func IsListExpr(n ast.Node) bool {
+	return false
+}
+
 func Get(ast.Node) *ast.FieldList {
 	return nil
 }
diff --git a/src/go/internal/typeparams/typeparams.go b/src/go/internal/typeparams/typeparams.go
index 0332b6b816..66f66afb28 100644
--- a/src/go/internal/typeparams/typeparams.go
+++ b/src/go/internal/typeparams/typeparams.go
@@ -38,6 +38,11 @@ func UnpackExpr(x ast.Expr) []ast.Expr {
 	return nil
 }
 
+func IsListExpr(n ast.Node) bool {
+	_, ok := n.(*ast.ListExpr)
+	return ok
+}
+
 func Get(n ast.Node) *ast.FieldList {
 	switch n := n.(type) {
 	case *ast.TypeSpec:
diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 4023362a4e..7d701d985b 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -1805,7 +1805,11 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 		// types, which are comparatively rare.
 
 	default:
-		panic(fmt.Sprintf("%s: unknown expression type %T", check.fset.Position(e.Pos()), e))
+		if typeparams.IsListExpr(e) {
+			check.errorf(e, _Todo, "invalid multi-index expression")
+		} else {
+			panic(fmt.Sprintf("%s: unknown expression type %T", check.fset.Position(e.Pos()), e))
+		}
 	}
 
 	// everything went well
diff --git a/src/go/types/fixedbugs/issue45635.go2 b/src/go/types/fixedbugs/issue45635.go2
index 1fbe0382ea..ec5cf3c5ff 100644
--- a/src/go/types/fixedbugs/issue45635.go2
+++ b/src/go/types/fixedbugs/issue45635.go2
@@ -7,3 +7,26 @@ package main
 func main() {
 	some /* ERROR "undeclared name" */ [int, int]()
 }
+
+type N[T any] struct{}
+
+var _ N /* ERROR "0 arguments but 1 type parameters" */ []
+
+type I interface {
+	type map[int]int, []int
+}
+
+func _[T I]() {
+	var m map[int]int
+	_ = m[1 /* ERROR "multi-index expression" */, 2 /* ERROR "expected type" */ ]
+
+	var a [3]int
+	_ = a[1 /* ERROR "multi-index expression" */, 2 /* ERROR "expected type" */ ]
+
+	var s []int
+	_ = s[1 /* ERROR "multi-index expression" */, 2 /* ERROR "expected type" */ ]
+
+	var t T
+	// TODO(rFindley) Fix the duplicate error below.
+	_ = t[1 /* ERROR "multi-index expression" */ /* ERROR "multi-index expression" */, 2 /* ERROR "expected type" */ ]
+}
-- 
GitLab


From 7d22c2181b4343b58e40962cefd52af1284b4294 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Mon, 26 Apr 2021 17:27:58 -0700
Subject: [PATCH 1783/2400] syscall: restore signal mask after setting
 foreground process group

Fixes #37217

Change-Id: I0151bb77fc4c4552d1b19c31d784943b72f84b80
Reviewed-on: https://go-review.googlesource.com/c/go/+/313653
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/syscall/exec_bsd.go       |  6 +++--
 src/syscall/exec_libc.go      |  6 +++--
 src/syscall/exec_libc2.go     |  6 +++--
 src/syscall/exec_linux.go     |  6 +++--
 src/syscall/exec_unix_test.go | 41 ++++++++++++++++++++++++++++++++++-
 5 files changed, 56 insertions(+), 9 deletions(-)

diff --git a/src/syscall/exec_bsd.go b/src/syscall/exec_bsd.go
index 9c1fbbaeab..051d130459 100644
--- a/src/syscall/exec_bsd.go
+++ b/src/syscall/exec_bsd.go
@@ -90,8 +90,6 @@ func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr
 
 	// Fork succeeded, now in child.
 
-	runtime_AfterForkInChild()
-
 	// Enable tracing if requested.
 	if sys.Ptrace {
 		_, _, err1 = RawSyscall(SYS_PTRACE, uintptr(PTRACE_TRACEME), 0, 0)
@@ -137,6 +135,10 @@ func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr
 		}
 	}
 
+	// Restore the signal mask. We do this after TIOCSPGRP to avoid
+	// having the kernel send a SIGTTOU signal to the process group.
+	runtime_AfterForkInChild()
+
 	// Chroot
 	if chroot != nil {
 		_, _, err1 = RawSyscall(SYS_CHROOT, uintptr(unsafe.Pointer(chroot)), 0, 0)
diff --git a/src/syscall/exec_libc.go b/src/syscall/exec_libc.go
index 3c8e87d32f..8a84954051 100644
--- a/src/syscall/exec_libc.go
+++ b/src/syscall/exec_libc.go
@@ -116,8 +116,6 @@ func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr
 
 	// Fork succeeded, now in child.
 
-	runtime_AfterForkInChild()
-
 	// Session ID
 	if sys.Setsid {
 		_, err1 = setsid()
@@ -153,6 +151,10 @@ func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr
 		}
 	}
 
+	// Restore the signal mask. We do this after TIOCSPGRP to avoid
+	// having the kernel send a SIGTTOU signal to the process group.
+	runtime_AfterForkInChild()
+
 	// Chroot
 	if chroot != nil {
 		err1 = chroot1(uintptr(unsafe.Pointer(chroot)))
diff --git a/src/syscall/exec_libc2.go b/src/syscall/exec_libc2.go
index 37df790193..61b1a226eb 100644
--- a/src/syscall/exec_libc2.go
+++ b/src/syscall/exec_libc2.go
@@ -91,8 +91,6 @@ func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr
 
 	// Fork succeeded, now in child.
 
-	runtime_AfterForkInChild()
-
 	// Enable tracing if requested.
 	if sys.Ptrace {
 		if err := ptrace(PTRACE_TRACEME, 0, 0, 0); err != nil {
@@ -136,6 +134,10 @@ func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr
 		}
 	}
 
+	// Restore the signal mask. We do this after TIOCSPGRP to avoid
+	// having the kernel send a SIGTTOU signal to the process group.
+	runtime_AfterForkInChild()
+
 	// Chroot
 	if chroot != nil {
 		_, _, err1 = rawSyscall(abi.FuncPCABI0(libc_chroot_trampoline), uintptr(unsafe.Pointer(chroot)), 0, 0)
diff --git a/src/syscall/exec_linux.go b/src/syscall/exec_linux.go
index deb8aa38b7..ccc0e39e30 100644
--- a/src/syscall/exec_linux.go
+++ b/src/syscall/exec_linux.go
@@ -233,8 +233,6 @@ func forkAndExecInChild1(argv0 *byte, argv, envv []*byte, chroot, dir *byte, att
 
 	// Fork succeeded, now in child.
 
-	runtime_AfterForkInChild()
-
 	// Enable the "keep capabilities" flag to set ambient capabilities later.
 	if len(sys.AmbientCaps) > 0 {
 		_, _, err1 = RawSyscall6(SYS_PRCTL, PR_SET_KEEPCAPS, 1, 0, 0, 0, 0)
@@ -294,6 +292,10 @@ func forkAndExecInChild1(argv0 *byte, argv, envv []*byte, chroot, dir *byte, att
 		}
 	}
 
+	// Restore the signal mask. We do this after TIOCSPGRP to avoid
+	// having the kernel send a SIGTTOU signal to the process group.
+	runtime_AfterForkInChild()
+
 	// Unshare
 	if sys.Unshareflags != 0 {
 		_, _, err1 = RawSyscall(SYS_UNSHARE, sys.Unshareflags, 0, 0)
diff --git a/src/syscall/exec_unix_test.go b/src/syscall/exec_unix_test.go
index 10bad5ac46..643c2e9789 100644
--- a/src/syscall/exec_unix_test.go
+++ b/src/syscall/exec_unix_test.go
@@ -167,11 +167,13 @@ func TestPgid(t *testing.T) {
 
 func TestForeground(t *testing.T) {
 	signal.Ignore(syscall.SIGTTIN, syscall.SIGTTOU)
+	defer signal.Reset()
 
 	tty, err := os.OpenFile("/dev/tty", os.O_RDWR, 0)
 	if err != nil {
 		t.Skipf("Can't test Foreground. Couldn't open /dev/tty: %s", err)
 	}
+	defer tty.Close()
 
 	// This should really be pid_t, however _C_int (aka int32) is generally
 	// equivalent.
@@ -216,8 +218,45 @@ func TestForeground(t *testing.T) {
 	if errno != 0 {
 		t.Fatalf("TIOCSPGRP failed with error code: %s", errno)
 	}
+}
+
+func TestForegroundSignal(t *testing.T) {
+	tty, err := os.OpenFile("/dev/tty", os.O_RDWR, 0)
+	if err != nil {
+		t.Skipf("couldn't open /dev/tty: %s", err)
+	}
+	defer tty.Close()
+
+	ch1 := make(chan os.Signal, 1)
+	ch2 := make(chan bool)
+
+	signal.Notify(ch1, syscall.SIGTTIN, syscall.SIGTTOU)
+	defer signal.Stop(ch1)
 
-	signal.Reset()
+	go func() {
+		cmd := create(t)
+		cmd.proc.SysProcAttr = &syscall.SysProcAttr{
+			Ctty:       int(tty.Fd()),
+			Foreground: true,
+		}
+		cmd.Start()
+		cmd.Stop()
+		close(ch2)
+	}()
+
+	timer := time.NewTimer(30 * time.Second)
+	defer timer.Stop()
+	for {
+		select {
+		case sig := <-ch1:
+			t.Errorf("unexpected signal %v", sig)
+		case <-ch2:
+			// Success.
+			return
+		case <-timer.C:
+			t.Fatal("timed out waiting for child process")
+		}
+	}
 }
 
 // Test a couple of cases that SysProcAttr can't handle. Issue 29458.
-- 
GitLab


From 0b9ca4d90737017fc9bb0cf125e2005c61782b79 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Wed, 21 Apr 2021 23:50:58 +0000
Subject: [PATCH 1784/2400] runtime/metrics: add tiny allocs metric

Currently tiny allocations are not represented in either MemStats or
runtime/metrics, but they're represented in MemStats (indirectly) via
Mallocs. Add them to runtime/metrics by first merging
memstats.tinyallocs into consistentHeapStats (just for simplicity; it's
monotonic so metrics would still be self-consistent if we just read it
atomically) and then adding /gc/heap/tiny/allocs:objects to the list of
supported metrics.

Change-Id: Ie478006ab942a3e877b4a79065ffa43569722f3d
Reviewed-on: https://go-review.googlesource.com/c/go/+/312909
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
---
 src/runtime/export_test.go         |  2 +-
 src/runtime/mcache.go              | 18 +++++++++++-------
 src/runtime/metrics.go             |  7 +++++++
 src/runtime/metrics/description.go | 10 ++++++++++
 src/runtime/metrics/doc.go         |  7 +++++++
 src/runtime/metrics_test.go        | 23 ++++++++++++++++++++++-
 src/runtime/mstats.go              | 10 ++++++----
 7 files changed, 64 insertions(+), 13 deletions(-)

diff --git a/src/runtime/export_test.go b/src/runtime/export_test.go
index 81200da915..f742225d51 100644
--- a/src/runtime/export_test.go
+++ b/src/runtime/export_test.go
@@ -393,7 +393,7 @@ func ReadMemStatsSlow() (base, slow MemStats) {
 			bySize[i].Mallocs += uint64(m.smallFreeCount[i])
 			smallFree += uint64(m.smallFreeCount[i]) * uint64(class_to_size[i])
 		}
-		slow.Frees += memstats.tinyallocs + uint64(m.largeFreeCount)
+		slow.Frees += uint64(m.tinyAllocCount) + uint64(m.largeFreeCount)
 		slow.Mallocs += slow.Frees
 
 		slow.TotalAlloc = slow.Alloc + uint64(m.largeFree) + smallFree
diff --git a/src/runtime/mcache.go b/src/runtime/mcache.go
index 2390be406f..097e4a5ade 100644
--- a/src/runtime/mcache.go
+++ b/src/runtime/mcache.go
@@ -176,17 +176,17 @@ func (c *mcache) refill(spc spanClass) {
 	// mcache. If it gets uncached, we'll adjust this.
 	stats := memstats.heapStats.acquire()
 	atomic.Xadduintptr(&stats.smallAllocCount[spc.sizeclass()], uintptr(s.nelems)-uintptr(s.allocCount))
-	memstats.heapStats.release()
-
-	// Update gcController.heapLive with the same assumption.
-	usedBytes := uintptr(s.allocCount) * s.elemsize
-	atomic.Xadd64(&gcController.heapLive, int64(s.npages*pageSize)-int64(usedBytes))
 
 	// Flush tinyAllocs.
 	if spc == tinySpanClass {
-		atomic.Xadd64(&memstats.tinyallocs, int64(c.tinyAllocs))
+		atomic.Xadduintptr(&stats.tinyAllocCount, c.tinyAllocs)
 		c.tinyAllocs = 0
 	}
+	memstats.heapStats.release()
+
+	// Update gcController.heapLive with the same assumption.
+	usedBytes := uintptr(s.allocCount) * s.elemsize
+	atomic.Xadd64(&gcController.heapLive, int64(s.npages*pageSize)-int64(usedBytes))
 
 	// While we're here, flush scanAlloc, since we have to call
 	// revise anyway.
@@ -280,8 +280,12 @@ func (c *mcache) releaseAll() {
 	// Clear tinyalloc pool.
 	c.tiny = 0
 	c.tinyoffset = 0
-	atomic.Xadd64(&memstats.tinyallocs, int64(c.tinyAllocs))
+
+	// Flush tinyAllocs.
+	stats := memstats.heapStats.acquire()
+	atomic.Xadduintptr(&stats.tinyAllocCount, c.tinyAllocs)
 	c.tinyAllocs = 0
+	memstats.heapStats.release()
 
 	// Updated heapScan and possible gcController.heapLive.
 	if gcBlackenEnabled != 0 {
diff --git a/src/runtime/metrics.go b/src/runtime/metrics.go
index fe82688aac..240813b169 100644
--- a/src/runtime/metrics.go
+++ b/src/runtime/metrics.go
@@ -124,6 +124,13 @@ func initMetrics() {
 				out.scalar = in.heapStats.numObjects
 			},
 		},
+		"/gc/heap/tiny/allocs:objects": {
+			deps: makeStatDepSet(heapStatsDep),
+			compute: func(in *statAggregate, out *metricValue) {
+				out.kind = metricKindUint64
+				out.scalar = uint64(in.heapStats.tinyAllocCount)
+			},
+		},
 		"/gc/pauses:seconds": {
 			compute: func(_ *statAggregate, out *metricValue) {
 				hist := out.float64HistOrInit(timeHistBuckets)
diff --git a/src/runtime/metrics/description.go b/src/runtime/metrics/description.go
index 9aaf457135..697bc94e84 100644
--- a/src/runtime/metrics/description.go
+++ b/src/runtime/metrics/description.go
@@ -91,6 +91,16 @@ var allDesc = []Description{
 		Description: "Number of objects, live or unswept, occupying heap memory.",
 		Kind:        KindUint64,
 	},
+	{
+		Name: "/gc/heap/tiny/allocs:objects",
+		Description: "Count of small allocations that are packed together into blocks. " +
+			"These allocations are counted separately from other allocations " +
+			"because each individual allocation is not tracked by the runtime, " +
+			"only their block. Each block is already accounted for in " +
+			"allocs-by-size and frees-by-size.",
+		Kind:       KindUint64,
+		Cumulative: true,
+	},
 	{
 		Name:        "/gc/pauses:seconds",
 		Description: "Distribution individual GC-related stop-the-world pause latencies.",
diff --git a/src/runtime/metrics/doc.go b/src/runtime/metrics/doc.go
index 7cbc0415dc..cd8ccf46c3 100644
--- a/src/runtime/metrics/doc.go
+++ b/src/runtime/metrics/doc.go
@@ -72,6 +72,13 @@ Below is the full list of supported metrics, ordered lexicographically.
 	/gc/heap/objects:objects
 		Number of objects, live or unswept, occupying heap memory.
 
+	/gc/heap/tiny/allocs:objects
+		Count of small allocations that are packed together into blocks.
+		These allocations are counted separately from other allocations
+		because each individual allocation is not tracked by the runtime,
+		only their block. Each block is already accounted for in
+		allocs-by-size and frees-by-size.
+
 	/gc/pauses:seconds
 		Distribution individual GC-related stop-the-world pause latencies.
 
diff --git a/src/runtime/metrics_test.go b/src/runtime/metrics_test.go
index 8a3cf019bd..e405d807e4 100644
--- a/src/runtime/metrics_test.go
+++ b/src/runtime/metrics_test.go
@@ -40,6 +40,8 @@ func TestReadMetrics(t *testing.T) {
 	}
 
 	// Check to make sure the values we read line up with other values we read.
+	var allocsBySize *metrics.Float64Histogram
+	var tinyAllocs uint64
 	for i := range samples {
 		switch name := samples[i].Name; name {
 		case "/memory/classes/heap/free:bytes":
@@ -84,6 +86,7 @@ func TestReadMetrics(t *testing.T) {
 					t.Errorf("histogram counts do not much BySize for class %d: got %d, want %d", i, c, m)
 				}
 			}
+			allocsBySize = hist
 		case "/gc/heap/frees-by-size:bytes":
 			hist := samples[i].Value.Float64Histogram()
 			// Skip size class 0 in BySize, because it's always empty and not represented
@@ -95,9 +98,20 @@ func TestReadMetrics(t *testing.T) {
 					continue
 				}
 				if c, f := hist.Counts[i], sc.Frees; c != f {
-					t.Errorf("histogram counts do not much BySize for class %d: got %d, want %d", i, c, f)
+					t.Errorf("histogram counts do not match BySize for class %d: got %d, want %d", i, c, f)
 				}
 			}
+		case "/gc/heap/tiny/allocs:objects":
+			// Currently, MemStats adds tiny alloc count to both Mallocs AND Frees.
+			// The reason for this is because MemStats couldn't be extended at the time
+			// but there was a desire to have Mallocs at least be a little more representative,
+			// while having Mallocs - Frees still represent a live object count.
+			// Unfortunately, MemStats doesn't actually export a large allocation count,
+			// so it's impossible to pull this number out directly.
+			//
+			// Check tiny allocation count outside of this loop, by using the allocs-by-size
+			// histogram in order to figure out how many large objects there are.
+			tinyAllocs = samples[i].Value.Uint64()
 		case "/gc/heap/objects:objects":
 			checkUint64(t, name, samples[i].Value.Uint64(), mstats.HeapObjects)
 		case "/gc/heap/goal:bytes":
@@ -110,6 +124,13 @@ func TestReadMetrics(t *testing.T) {
 			checkUint64(t, name, samples[i].Value.Uint64(), uint64(mstats.NumGC))
 		}
 	}
+
+	// Check tinyAllocs.
+	nonTinyAllocs := uint64(0)
+	for _, c := range allocsBySize.Counts {
+		nonTinyAllocs += c
+	}
+	checkUint64(t, "/gc/heap/tiny/allocs:objects", tinyAllocs, mstats.Mallocs-nonTinyAllocs)
 }
 
 func TestReadMetricsConsistency(t *testing.T) {
diff --git a/src/runtime/mstats.go b/src/runtime/mstats.go
index c68cb2fcc3..eeb2a7b4bc 100644
--- a/src/runtime/mstats.go
+++ b/src/runtime/mstats.go
@@ -8,6 +8,7 @@ package runtime
 
 import (
 	"runtime/internal/atomic"
+	"runtime/internal/sys"
 	"unsafe"
 )
 
@@ -86,7 +87,6 @@ type mstats struct {
 	_ [1 - _NumSizeClasses%2]uint32
 
 	last_gc_nanotime uint64 // last gc (monotonic time)
-	tinyallocs       uint64 // number of tiny allocations that didn't cause actual allocation; not exported to go directly
 	last_heap_inuse  uint64 // heap_inuse at mark termination of the previous GC
 
 	// heapStats is a set of statistics
@@ -586,8 +586,8 @@ func updatememstats() {
 	}
 
 	// Account for tiny allocations.
-	memstats.nfree += memstats.tinyallocs
-	memstats.nmalloc += memstats.tinyallocs
+	memstats.nfree += uint64(consStats.tinyAllocCount)
+	memstats.nmalloc += uint64(consStats.tinyAllocCount)
 
 	// Calculate derived stats.
 	memstats.total_alloc = totalAlloc
@@ -703,6 +703,7 @@ type heapStatsDelta struct {
 	inPtrScalarBits int64 // byte delta of memory reserved for unrolled GC prog bits
 
 	// Allocator stats.
+	tinyAllocCount  uintptr                  // number of tiny allocations
 	largeAlloc      uintptr                  // bytes allocated for large objects
 	largeAllocCount uintptr                  // number of large object allocations
 	smallAllocCount [_NumSizeClasses]uintptr // number of allocs for small objects
@@ -712,7 +713,7 @@ type heapStatsDelta struct {
 
 	// Add a uint32 to ensure this struct is a multiple of 8 bytes in size.
 	// Only necessary on 32-bit platforms.
-	// _ [(sys.PtrSize / 4) % 2]uint32
+	_ [(sys.PtrSize / 4) % 2]uint32
 }
 
 // merge adds in the deltas from b into a.
@@ -724,6 +725,7 @@ func (a *heapStatsDelta) merge(b *heapStatsDelta) {
 	a.inWorkBufs += b.inWorkBufs
 	a.inPtrScalarBits += b.inPtrScalarBits
 
+	a.tinyAllocCount += b.tinyAllocCount
 	a.largeAlloc += b.largeAlloc
 	a.largeAllocCount += b.largeAllocCount
 	for i := range b.smallAllocCount {
-- 
GitLab


From 88a8a2705684e693082cabaec18b76615cf0b4f0 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Tue, 27 Apr 2021 13:51:45 +0200
Subject: [PATCH 1785/2400] os: don't check non-nil err twice in Symlink on
 windows

Change-Id: I398d324723025b559fdca783fc334de9be68f2d1
Reviewed-on: https://go-review.googlesource.com/c/go/+/314030
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/os/file_windows.go | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/src/os/file_windows.go b/src/os/file_windows.go
index 0d3c048a75..a2cb96e457 100644
--- a/src/os/file_windows.go
+++ b/src/os/file_windows.go
@@ -365,17 +365,14 @@ func Symlink(oldname, newname string) error {
 		flags |= syscall.SYMBOLIC_LINK_FLAG_DIRECTORY
 	}
 	err = syscall.CreateSymbolicLink(n, o, flags)
-
 	if err != nil {
 		// the unprivileged create flag is unsupported
 		// below Windows 10 (1703, v10.0.14972). retry without it.
 		flags &^= windows.SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE
-
 		err = syscall.CreateSymbolicLink(n, o, flags)
-	}
-
-	if err != nil {
-		return &LinkError{"symlink", oldname, newname, err}
+		if err != nil {
+			return &LinkError{"symlink", oldname, newname, err}
+		}
 	}
 	return nil
 }
-- 
GitLab


From 6fa12172d9f0696b6ae6a0155b63994ae23b8d21 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 30 Mar 2021 08:26:24 -0400
Subject: [PATCH 1786/2400] go/parser: add benchmarks for syntax-only parsing
 and object resolution

Change-Id: I73d1b2d18ab4051443d66c60df493d1163d0ba3f
Reviewed-on: https://go-review.googlesource.com/c/go/+/306150
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/parser/performance_test.go | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/src/go/parser/performance_test.go b/src/go/parser/performance_test.go
index f81bcee969..6f8a97770b 100644
--- a/src/go/parser/performance_test.go
+++ b/src/go/parser/performance_test.go
@@ -10,6 +10,8 @@ import (
 	"testing"
 )
 
+// TODO(rFindley): use a testdata file or file from another package here, to
+//                 avoid a moving target.
 var src = readFile("parser.go")
 
 func readFile(filename string) []byte {
@@ -28,3 +30,27 @@ func BenchmarkParse(b *testing.B) {
 		}
 	}
 }
+
+func BenchmarkParseOnly(b *testing.B) {
+	b.SetBytes(int64(len(src)))
+	for i := 0; i < b.N; i++ {
+		if _, err := ParseFile(token.NewFileSet(), "", src, ParseComments|SkipObjectResolution); err != nil {
+			b.Fatalf("benchmark failed due to parse error: %s", err)
+		}
+	}
+}
+
+func BenchmarkResolve(b *testing.B) {
+	b.SetBytes(int64(len(src)))
+	for i := 0; i < b.N; i++ {
+		b.StopTimer()
+		fset := token.NewFileSet()
+		file, err := ParseFile(fset, "", src, SkipObjectResolution)
+		if err != nil {
+			b.Fatalf("benchmark failed due to parse error: %s", err)
+		}
+		b.StartTimer()
+		handle := fset.File(file.Package)
+		resolveFile(file, handle, nil)
+	}
+}
-- 
GitLab


From bc6288794de10fddea0a3c3cfcb1cfd2bf2aa8a0 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 7 Apr 2021 17:43:09 -0400
Subject: [PATCH 1787/2400] go/scanner: improve variety in benchmarks for file
 scanning

BenchmarkScanFile was scanning scanner.go, which makes comparison
difficult for a CL modifying that file. That file is also is not
necessarily representative syntax.

Add a few additional files as subtests to provide a larger variety of
metrics.

Change-Id: Ib78303c2546debd84a0b5478ae438ba891d9e6e9
Reviewed-on: https://go-review.googlesource.com/c/go/+/308610
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/scanner/scanner_test.go | 49 +++++++++++++++++++++-------------
 1 file changed, 30 insertions(+), 19 deletions(-)

diff --git a/src/go/scanner/scanner_test.go b/src/go/scanner/scanner_test.go
index db095b3da6..ac8d257716 100644
--- a/src/go/scanner/scanner_test.go
+++ b/src/go/scanner/scanner_test.go
@@ -889,26 +889,37 @@ func BenchmarkScan(b *testing.B) {
 	}
 }
 
-func BenchmarkScanFile(b *testing.B) {
-	b.StopTimer()
-	const filename = "scanner.go"
-	src, err := os.ReadFile(filename)
-	if err != nil {
-		panic(err)
-	}
-	fset := token.NewFileSet()
-	file := fset.AddFile(filename, fset.Base(), len(src))
-	b.SetBytes(int64(len(src)))
-	var s Scanner
-	b.StartTimer()
-	for i := 0; i < b.N; i++ {
-		s.Init(file, src, nil, ScanComments)
-		for {
-			_, tok, _ := s.Scan()
-			if tok == token.EOF {
-				break
+func BenchmarkScanFiles(b *testing.B) {
+	// Scan a few arbitrary large files, and one small one, to provide some
+	// variety in benchmarks.
+	for _, p := range []string{
+		"go/types/expr.go",
+		"go/parser/parser.go",
+		"net/http/server.go",
+		"go/scanner/errors.go",
+	} {
+		b.Run(p, func(b *testing.B) {
+			b.StopTimer()
+			filename := filepath.Join("..", "..", filepath.FromSlash(p))
+			src, err := os.ReadFile(filename)
+			if err != nil {
+				b.Fatal(err)
 			}
-		}
+			fset := token.NewFileSet()
+			file := fset.AddFile(filename, fset.Base(), len(src))
+			b.SetBytes(int64(len(src)))
+			var s Scanner
+			b.StartTimer()
+			for i := 0; i < b.N; i++ {
+				s.Init(file, src, nil, ScanComments)
+				for {
+					_, tok, _ := s.Scan()
+					if tok == token.EOF {
+						break
+					}
+				}
+			}
+		})
 	}
 }
 
-- 
GitLab


From d553c0144d2a532b3e962715899d6cd9db47192a Mon Sep 17 00:00:00 2001
From: yangwenmai <yangwen.yw@gmail.com>
Date: Tue, 27 Apr 2021 08:30:25 +0800
Subject: [PATCH 1788/2400] bits: use same expression with system bit size

Change-Id: Ibce07f8f36f7c64f7022ce656f8efbec5dff3f82
Reviewed-on: https://go-review.googlesource.com/c/go/+/313829
Reviewed-by: Robert Griesemer <gri@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ssa/poset.go | 2 +-
 src/math/bits/bits.go                 | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/poset.go b/src/cmd/compile/internal/ssa/poset.go
index 1e04b48ba4..d2719eb8a1 100644
--- a/src/cmd/compile/internal/ssa/poset.go
+++ b/src/cmd/compile/internal/ssa/poset.go
@@ -12,7 +12,7 @@ import (
 // If true, check poset integrity after every mutation
 var debugPoset = false
 
-const uintSize = 32 << (^uint(0) >> 32 & 1) // 32 or 64
+const uintSize = 32 << (^uint(0) >> 63) // 32 or 64
 
 // bitset is a bit array for dense indexes.
 type bitset []uint
diff --git a/src/math/bits/bits.go b/src/math/bits/bits.go
index 879ef2da54..65452feda2 100644
--- a/src/math/bits/bits.go
+++ b/src/math/bits/bits.go
@@ -8,7 +8,7 @@
 // functions for the predeclared unsigned integer types.
 package bits
 
-const uintSize = 32 << (^uint(0) >> 32 & 1) // 32 or 64
+const uintSize = 32 << (^uint(0) >> 63) // 32 or 64
 
 // UintSize is the size of a uint in bits.
 const UintSize = uintSize
-- 
GitLab


From 55c517a8b330710e6aaf6cc7133a9c7759bbb1d1 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Mon, 26 Apr 2021 17:52:53 -0700
Subject: [PATCH 1789/2400] cmd/compile: fix handling of ir.CurFunc during
 stenciling

The transform functions (specifically transformArgs, which is used from
transformCall/transformReturn) require that ir.CurFunc is set correctly.
Since transformCall() is used on the call of an instantiated generic
function, we need to set ir.CurFunc correctly in stencil(). Also,
correctly save/restore ir.CurFunc in genericSubst().

Without this fix, ir.CurFunc can be nil when we call TransformCall()
from stencil(), which leads to some temp variables being added
incorrectly to ir.TodoFunc (which leads to the fatal panic in the
issue).

Fixes #45722

Change-Id: Iddf4a67d28f2100dde8cde5dbc9ca1e00dad6089
Reviewed-on: https://go-review.googlesource.com/c/go/+/313869
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
Trust: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/noder/stencil.go |  8 +++++-
 test/typeparam/issue45722.go              | 34 +++++++++++++++++++++++
 2 files changed, 41 insertions(+), 1 deletion(-)
 create mode 100644 test/typeparam/issue45722.go

diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 53ac617d12..d60f0af548 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -52,6 +52,8 @@ func (g *irgen) stencil() {
 				// Skip any generic functions
 				continue
 			}
+			// transformCall() below depends on CurFunc being set.
+			ir.CurFunc = decl.(*ir.Func)
 
 		case ir.OAS, ir.OAS2, ir.OAS2DOTTYPE, ir.OAS2FUNC, ir.OAS2MAPR, ir.OAS2RECV, ir.OASOP:
 			// These are all the various kinds of global assignments,
@@ -127,6 +129,7 @@ func (g *irgen) stencil() {
 		if base.Flag.W > 1 && modified {
 			ir.Dump(fmt.Sprintf("\nmodified %v", decl), decl)
 		}
+		ir.CurFunc = nil
 		// We may have seen new fully-instantiated generic types while
 		// instantiating any needed functions/methods in the above
 		// function. If so, instantiate all the methods of those types
@@ -275,6 +278,9 @@ func (g *irgen) genericSubst(newsym *types.Sym, nameNode *ir.Name, targs []ir.No
 	newf.Nname.Func = newf
 	newf.Nname.Defn = newf
 	newsym.Def = newf.Nname
+	savef := ir.CurFunc
+	// transformCall/transformReturn (called during stenciling of the body)
+	// depend on ir.CurFunc being set.
 	ir.CurFunc = newf
 
 	assert(len(tparams) == len(targs))
@@ -310,7 +316,7 @@ func (g *irgen) genericSubst(newsym *types.Sym, nameNode *ir.Name, targs []ir.No
 
 	// Make sure name/type of newf is set before substituting the body.
 	newf.Body = subst.list(gf.Body)
-	ir.CurFunc = nil
+	ir.CurFunc = savef
 
 	return newf
 }
diff --git a/test/typeparam/issue45722.go b/test/typeparam/issue45722.go
new file mode 100644
index 0000000000..0d7c20c264
--- /dev/null
+++ b/test/typeparam/issue45722.go
@@ -0,0 +1,34 @@
+// run -gcflags=-G=3
+
+// Copyright 2021 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 (
+	"fmt"
+	"log"
+)
+
+func try[T any](v T, err error) T {
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+func handle(handle func(error)) {
+	if issue := recover(); issue != nil {
+		if e, ok := issue.(error); ok && e != nil {
+			handle(e)
+		} else {
+			handle(fmt.Errorf("%v", e))
+		}
+	}
+}
+
+func main() {
+	defer handle(func(e error) { log.Fatalln(e) })
+	_ = try(fmt.Print(""))
+}
-- 
GitLab


From 074a49bfe82cd4722c05c48568a43434eab639fa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9my=20Oudompheng?= <remyoudompheng@gmail.com>
Date: Tue, 27 Apr 2021 08:31:49 +0200
Subject: [PATCH 1790/2400] strconv: remove unused extfloat (Grisu3) ftoa code

Change-Id: Ie8995362f9e8072b173d08820330d2d1e512aa71
Reviewed-on: https://go-review.googlesource.com/c/go/+/314029
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/strconv/extfloat.go | 517 ----------------------------------------
 src/strconv/ftoaryu.go  |   5 +
 2 files changed, 5 insertions(+), 517 deletions(-)
 delete mode 100644 src/strconv/extfloat.go

diff --git a/src/strconv/extfloat.go b/src/strconv/extfloat.go
deleted file mode 100644
index e7bfe511fb..0000000000
--- a/src/strconv/extfloat.go
+++ /dev/null
@@ -1,517 +0,0 @@
-// Copyright 2011 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 strconv
-
-import (
-	"math/bits"
-)
-
-// An extFloat represents an extended floating-point number, with more
-// precision than a float64. It does not try to save bits: the
-// number represented by the structure is mant*(2^exp), with a negative
-// sign if neg is true.
-type extFloat struct {
-	mant uint64
-	exp  int
-	neg  bool
-}
-
-// Powers of ten taken from double-conversion library.
-// https://code.google.com/p/double-conversion/
-const (
-	firstPowerOfTen = -348
-	stepPowerOfTen  = 8
-)
-
-var smallPowersOfTen = [...]extFloat{
-	{1 << 63, -63, false},        // 1
-	{0xa << 60, -60, false},      // 1e1
-	{0x64 << 57, -57, false},     // 1e2
-	{0x3e8 << 54, -54, false},    // 1e3
-	{0x2710 << 50, -50, false},   // 1e4
-	{0x186a0 << 47, -47, false},  // 1e5
-	{0xf4240 << 44, -44, false},  // 1e6
-	{0x989680 << 40, -40, false}, // 1e7
-}
-
-var powersOfTen = [...]extFloat{
-	{0xfa8fd5a0081c0288, -1220, false}, // 10^-348
-	{0xbaaee17fa23ebf76, -1193, false}, // 10^-340
-	{0x8b16fb203055ac76, -1166, false}, // 10^-332
-	{0xcf42894a5dce35ea, -1140, false}, // 10^-324
-	{0x9a6bb0aa55653b2d, -1113, false}, // 10^-316
-	{0xe61acf033d1a45df, -1087, false}, // 10^-308
-	{0xab70fe17c79ac6ca, -1060, false}, // 10^-300
-	{0xff77b1fcbebcdc4f, -1034, false}, // 10^-292
-	{0xbe5691ef416bd60c, -1007, false}, // 10^-284
-	{0x8dd01fad907ffc3c, -980, false},  // 10^-276
-	{0xd3515c2831559a83, -954, false},  // 10^-268
-	{0x9d71ac8fada6c9b5, -927, false},  // 10^-260
-	{0xea9c227723ee8bcb, -901, false},  // 10^-252
-	{0xaecc49914078536d, -874, false},  // 10^-244
-	{0x823c12795db6ce57, -847, false},  // 10^-236
-	{0xc21094364dfb5637, -821, false},  // 10^-228
-	{0x9096ea6f3848984f, -794, false},  // 10^-220
-	{0xd77485cb25823ac7, -768, false},  // 10^-212
-	{0xa086cfcd97bf97f4, -741, false},  // 10^-204
-	{0xef340a98172aace5, -715, false},  // 10^-196
-	{0xb23867fb2a35b28e, -688, false},  // 10^-188
-	{0x84c8d4dfd2c63f3b, -661, false},  // 10^-180
-	{0xc5dd44271ad3cdba, -635, false},  // 10^-172
-	{0x936b9fcebb25c996, -608, false},  // 10^-164
-	{0xdbac6c247d62a584, -582, false},  // 10^-156
-	{0xa3ab66580d5fdaf6, -555, false},  // 10^-148
-	{0xf3e2f893dec3f126, -529, false},  // 10^-140
-	{0xb5b5ada8aaff80b8, -502, false},  // 10^-132
-	{0x87625f056c7c4a8b, -475, false},  // 10^-124
-	{0xc9bcff6034c13053, -449, false},  // 10^-116
-	{0x964e858c91ba2655, -422, false},  // 10^-108
-	{0xdff9772470297ebd, -396, false},  // 10^-100
-	{0xa6dfbd9fb8e5b88f, -369, false},  // 10^-92
-	{0xf8a95fcf88747d94, -343, false},  // 10^-84
-	{0xb94470938fa89bcf, -316, false},  // 10^-76
-	{0x8a08f0f8bf0f156b, -289, false},  // 10^-68
-	{0xcdb02555653131b6, -263, false},  // 10^-60
-	{0x993fe2c6d07b7fac, -236, false},  // 10^-52
-	{0xe45c10c42a2b3b06, -210, false},  // 10^-44
-	{0xaa242499697392d3, -183, false},  // 10^-36
-	{0xfd87b5f28300ca0e, -157, false},  // 10^-28
-	{0xbce5086492111aeb, -130, false},  // 10^-20
-	{0x8cbccc096f5088cc, -103, false},  // 10^-12
-	{0xd1b71758e219652c, -77, false},   // 10^-4
-	{0x9c40000000000000, -50, false},   // 10^4
-	{0xe8d4a51000000000, -24, false},   // 10^12
-	{0xad78ebc5ac620000, 3, false},     // 10^20
-	{0x813f3978f8940984, 30, false},    // 10^28
-	{0xc097ce7bc90715b3, 56, false},    // 10^36
-	{0x8f7e32ce7bea5c70, 83, false},    // 10^44
-	{0xd5d238a4abe98068, 109, false},   // 10^52
-	{0x9f4f2726179a2245, 136, false},   // 10^60
-	{0xed63a231d4c4fb27, 162, false},   // 10^68
-	{0xb0de65388cc8ada8, 189, false},   // 10^76
-	{0x83c7088e1aab65db, 216, false},   // 10^84
-	{0xc45d1df942711d9a, 242, false},   // 10^92
-	{0x924d692ca61be758, 269, false},   // 10^100
-	{0xda01ee641a708dea, 295, false},   // 10^108
-	{0xa26da3999aef774a, 322, false},   // 10^116
-	{0xf209787bb47d6b85, 348, false},   // 10^124
-	{0xb454e4a179dd1877, 375, false},   // 10^132
-	{0x865b86925b9bc5c2, 402, false},   // 10^140
-	{0xc83553c5c8965d3d, 428, false},   // 10^148
-	{0x952ab45cfa97a0b3, 455, false},   // 10^156
-	{0xde469fbd99a05fe3, 481, false},   // 10^164
-	{0xa59bc234db398c25, 508, false},   // 10^172
-	{0xf6c69a72a3989f5c, 534, false},   // 10^180
-	{0xb7dcbf5354e9bece, 561, false},   // 10^188
-	{0x88fcf317f22241e2, 588, false},   // 10^196
-	{0xcc20ce9bd35c78a5, 614, false},   // 10^204
-	{0x98165af37b2153df, 641, false},   // 10^212
-	{0xe2a0b5dc971f303a, 667, false},   // 10^220
-	{0xa8d9d1535ce3b396, 694, false},   // 10^228
-	{0xfb9b7cd9a4a7443c, 720, false},   // 10^236
-	{0xbb764c4ca7a44410, 747, false},   // 10^244
-	{0x8bab8eefb6409c1a, 774, false},   // 10^252
-	{0xd01fef10a657842c, 800, false},   // 10^260
-	{0x9b10a4e5e9913129, 827, false},   // 10^268
-	{0xe7109bfba19c0c9d, 853, false},   // 10^276
-	{0xac2820d9623bf429, 880, false},   // 10^284
-	{0x80444b5e7aa7cf85, 907, false},   // 10^292
-	{0xbf21e44003acdd2d, 933, false},   // 10^300
-	{0x8e679c2f5e44ff8f, 960, false},   // 10^308
-	{0xd433179d9c8cb841, 986, false},   // 10^316
-	{0x9e19db92b4e31ba9, 1013, false},  // 10^324
-	{0xeb96bf6ebadf77d9, 1039, false},  // 10^332
-	{0xaf87023b9bf0ee6b, 1066, false},  // 10^340
-}
-
-// AssignComputeBounds sets f to the floating point value
-// defined by mant, exp and precision given by flt. It returns
-// lower, upper such that any number in the closed interval
-// [lower, upper] is converted back to the same floating point number.
-func (f *extFloat) AssignComputeBounds(mant uint64, exp int, neg bool, flt *floatInfo) (lower, upper extFloat) {
-	f.mant = mant
-	f.exp = exp - int(flt.mantbits)
-	f.neg = neg
-	if f.exp <= 0 && mant == (mant>>uint(-f.exp))<<uint(-f.exp) {
-		// An exact integer
-		f.mant >>= uint(-f.exp)
-		f.exp = 0
-		return *f, *f
-	}
-	expBiased := exp - flt.bias
-
-	upper = extFloat{mant: 2*f.mant + 1, exp: f.exp - 1, neg: f.neg}
-	if mant != 1<<flt.mantbits || expBiased == 1 {
-		lower = extFloat{mant: 2*f.mant - 1, exp: f.exp - 1, neg: f.neg}
-	} else {
-		lower = extFloat{mant: 4*f.mant - 1, exp: f.exp - 2, neg: f.neg}
-	}
-	return
-}
-
-// Normalize normalizes f so that the highest bit of the mantissa is
-// set, and returns the number by which the mantissa was left-shifted.
-func (f *extFloat) Normalize() uint {
-	// bits.LeadingZeros64 would return 64
-	if f.mant == 0 {
-		return 0
-	}
-	shift := bits.LeadingZeros64(f.mant)
-	f.mant <<= uint(shift)
-	f.exp -= shift
-	return uint(shift)
-}
-
-// Multiply sets f to the product f*g: the result is correctly rounded,
-// but not normalized.
-func (f *extFloat) Multiply(g extFloat) {
-	hi, lo := bits.Mul64(f.mant, g.mant)
-	// Round up.
-	f.mant = hi + (lo >> 63)
-	f.exp = f.exp + g.exp + 64
-}
-
-var uint64pow10 = [...]uint64{
-	1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
-	1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
-}
-
-// Frexp10 is an analogue of math.Frexp for decimal powers. It scales
-// f by an approximate power of ten 10^-exp, and returns exp10, so
-// that f*10^exp10 has the same value as the old f, up to an ulp,
-// as well as the index of 10^-exp in the powersOfTen table.
-func (f *extFloat) frexp10() (exp10, index int) {
-	// The constants expMin and expMax constrain the final value of the
-	// binary exponent of f. We want a small integral part in the result
-	// because finding digits of an integer requires divisions, whereas
-	// digits of the fractional part can be found by repeatedly multiplying
-	// by 10.
-	const expMin = -60
-	const expMax = -32
-	// Find power of ten such that x * 10^n has a binary exponent
-	// between expMin and expMax.
-	approxExp10 := ((expMin+expMax)/2 - f.exp) * 28 / 93 // log(10)/log(2) is close to 93/28.
-	i := (approxExp10 - firstPowerOfTen) / stepPowerOfTen
-Loop:
-	for {
-		exp := f.exp + powersOfTen[i].exp + 64
-		switch {
-		case exp < expMin:
-			i++
-		case exp > expMax:
-			i--
-		default:
-			break Loop
-		}
-	}
-	// Apply the desired decimal shift on f. It will have exponent
-	// in the desired range. This is multiplication by 10^-exp10.
-	f.Multiply(powersOfTen[i])
-
-	return -(firstPowerOfTen + i*stepPowerOfTen), i
-}
-
-// frexp10Many applies a common shift by a power of ten to a, b, c.
-func frexp10Many(a, b, c *extFloat) (exp10 int) {
-	exp10, i := c.frexp10()
-	a.Multiply(powersOfTen[i])
-	b.Multiply(powersOfTen[i])
-	return
-}
-
-// FixedDecimal stores in d the first n significant digits
-// of the decimal representation of f. It returns false
-// if it cannot be sure of the answer.
-func (f *extFloat) FixedDecimal(d *decimalSlice, n int) bool {
-	if f.mant == 0 {
-		d.nd = 0
-		d.dp = 0
-		d.neg = f.neg
-		return true
-	}
-	if n == 0 {
-		panic("strconv: internal error: extFloat.FixedDecimal called with n == 0")
-	}
-	// Multiply by an appropriate power of ten to have a reasonable
-	// number to process.
-	f.Normalize()
-	exp10, _ := f.frexp10()
-
-	shift := uint(-f.exp)
-	integer := uint32(f.mant >> shift)
-	fraction := f.mant - (uint64(integer) << shift)
-	ε := uint64(1) // ε is the uncertainty we have on the mantissa of f.
-
-	// Write exactly n digits to d.
-	needed := n        // how many digits are left to write.
-	integerDigits := 0 // the number of decimal digits of integer.
-	pow10 := uint64(1) // the power of ten by which f was scaled.
-	for i, pow := 0, uint64(1); i < 20; i++ {
-		if pow > uint64(integer) {
-			integerDigits = i
-			break
-		}
-		pow *= 10
-	}
-	rest := integer
-	if integerDigits > needed {
-		// the integral part is already large, trim the last digits.
-		pow10 = uint64pow10[integerDigits-needed]
-		integer /= uint32(pow10)
-		rest -= integer * uint32(pow10)
-	} else {
-		rest = 0
-	}
-
-	// Write the digits of integer: the digits of rest are omitted.
-	var buf [32]byte
-	pos := len(buf)
-	for v := integer; v > 0; {
-		v1 := v / 10
-		v -= 10 * v1
-		pos--
-		buf[pos] = byte(v + '0')
-		v = v1
-	}
-	for i := pos; i < len(buf); i++ {
-		d.d[i-pos] = buf[i]
-	}
-	nd := len(buf) - pos
-	d.nd = nd
-	d.dp = integerDigits + exp10
-	needed -= nd
-
-	if needed > 0 {
-		if rest != 0 || pow10 != 1 {
-			panic("strconv: internal error, rest != 0 but needed > 0")
-		}
-		// Emit digits for the fractional part. Each time, 10*fraction
-		// fits in a uint64 without overflow.
-		for needed > 0 {
-			fraction *= 10
-			ε *= 10 // the uncertainty scales as we multiply by ten.
-			if 2*ε > 1<<shift {
-				// the error is so large it could modify which digit to write, abort.
-				return false
-			}
-			digit := fraction >> shift
-			d.d[nd] = byte(digit + '0')
-			fraction -= digit << shift
-			nd++
-			needed--
-		}
-		d.nd = nd
-	}
-
-	// We have written a truncation of f (a numerator / 10^d.dp). The remaining part
-	// can be interpreted as a small number (< 1) to be added to the last digit of the
-	// numerator.
-	//
-	// If rest > 0, the amount is:
-	//    (rest<<shift | fraction) / (pow10 << shift)
-	//    fraction being known with a ±ε uncertainty.
-	//    The fact that n > 0 guarantees that pow10 << shift does not overflow a uint64.
-	//
-	// If rest = 0, pow10 == 1 and the amount is
-	//    fraction / (1 << shift)
-	//    fraction being known with a ±ε uncertainty.
-	//
-	// We pass this information to the rounding routine for adjustment.
-
-	ok := adjustLastDigitFixed(d, uint64(rest)<<shift|fraction, pow10, shift, ε)
-	if !ok {
-		return false
-	}
-	// Trim trailing zeros.
-	for i := d.nd - 1; i >= 0; i-- {
-		if d.d[i] != '0' {
-			d.nd = i + 1
-			break
-		}
-	}
-	return true
-}
-
-// adjustLastDigitFixed assumes d contains the representation of the integral part
-// of some number, whose fractional part is num / (den << shift). The numerator
-// num is only known up to an uncertainty of size ε, assumed to be less than
-// (den << shift)/2.
-//
-// It will increase the last digit by one to account for correct rounding, typically
-// when the fractional part is greater than 1/2, and will return false if ε is such
-// that no correct answer can be given.
-func adjustLastDigitFixed(d *decimalSlice, num, den uint64, shift uint, ε uint64) bool {
-	if num > den<<shift {
-		panic("strconv: num > den<<shift in adjustLastDigitFixed")
-	}
-	if 2*ε > den<<shift {
-		panic("strconv: ε > (den<<shift)/2")
-	}
-	if 2*(num+ε) < den<<shift {
-		return true
-	}
-	if 2*(num-ε) > den<<shift {
-		// increment d by 1.
-		i := d.nd - 1
-		for ; i >= 0; i-- {
-			if d.d[i] == '9' {
-				d.nd--
-			} else {
-				break
-			}
-		}
-		if i < 0 {
-			d.d[0] = '1'
-			d.nd = 1
-			d.dp++
-		} else {
-			d.d[i]++
-		}
-		return true
-	}
-	return false
-}
-
-// ShortestDecimal stores in d the shortest decimal representation of f
-// which belongs to the open interval (lower, upper), where f is supposed
-// to lie. It returns false whenever the result is unsure. The implementation
-// uses the Grisu3 algorithm.
-func (f *extFloat) ShortestDecimal(d *decimalSlice, lower, upper *extFloat) bool {
-	if f.mant == 0 {
-		d.nd = 0
-		d.dp = 0
-		d.neg = f.neg
-		return true
-	}
-	if f.exp == 0 && *lower == *f && *lower == *upper {
-		// an exact integer.
-		var buf [24]byte
-		n := len(buf) - 1
-		for v := f.mant; v > 0; {
-			v1 := v / 10
-			v -= 10 * v1
-			buf[n] = byte(v + '0')
-			n--
-			v = v1
-		}
-		nd := len(buf) - n - 1
-		for i := 0; i < nd; i++ {
-			d.d[i] = buf[n+1+i]
-		}
-		d.nd, d.dp = nd, nd
-		for d.nd > 0 && d.d[d.nd-1] == '0' {
-			d.nd--
-		}
-		if d.nd == 0 {
-			d.dp = 0
-		}
-		d.neg = f.neg
-		return true
-	}
-	upper.Normalize()
-	// Uniformize exponents.
-	if f.exp > upper.exp {
-		f.mant <<= uint(f.exp - upper.exp)
-		f.exp = upper.exp
-	}
-	if lower.exp > upper.exp {
-		lower.mant <<= uint(lower.exp - upper.exp)
-		lower.exp = upper.exp
-	}
-
-	exp10 := frexp10Many(lower, f, upper)
-	// Take a safety margin due to rounding in frexp10Many, but we lose precision.
-	upper.mant++
-	lower.mant--
-
-	// The shortest representation of f is either rounded up or down, but
-	// in any case, it is a truncation of upper.
-	shift := uint(-upper.exp)
-	integer := uint32(upper.mant >> shift)
-	fraction := upper.mant - (uint64(integer) << shift)
-
-	// How far we can go down from upper until the result is wrong.
-	allowance := upper.mant - lower.mant
-	// How far we should go to get a very precise result.
-	targetDiff := upper.mant - f.mant
-
-	// Count integral digits: there are at most 10.
-	var integerDigits int
-	for i, pow := 0, uint64(1); i < 20; i++ {
-		if pow > uint64(integer) {
-			integerDigits = i
-			break
-		}
-		pow *= 10
-	}
-	for i := 0; i < integerDigits; i++ {
-		pow := uint64pow10[integerDigits-i-1]
-		digit := integer / uint32(pow)
-		d.d[i] = byte(digit + '0')
-		integer -= digit * uint32(pow)
-		// evaluate whether we should stop.
-		if currentDiff := uint64(integer)<<shift + fraction; currentDiff < allowance {
-			d.nd = i + 1
-			d.dp = integerDigits + exp10
-			d.neg = f.neg
-			// Sometimes allowance is so large the last digit might need to be
-			// decremented to get closer to f.
-			return adjustLastDigit(d, currentDiff, targetDiff, allowance, pow<<shift, 2)
-		}
-	}
-	d.nd = integerDigits
-	d.dp = d.nd + exp10
-	d.neg = f.neg
-
-	// Compute digits of the fractional part. At each step fraction does not
-	// overflow. The choice of minExp implies that fraction is less than 2^60.
-	var digit int
-	multiplier := uint64(1)
-	for {
-		fraction *= 10
-		multiplier *= 10
-		digit = int(fraction >> shift)
-		d.d[d.nd] = byte(digit + '0')
-		d.nd++
-		fraction -= uint64(digit) << shift
-		if fraction < allowance*multiplier {
-			// We are in the admissible range. Note that if allowance is about to
-			// overflow, that is, allowance > 2^64/10, the condition is automatically
-			// true due to the limited range of fraction.
-			return adjustLastDigit(d,
-				fraction, targetDiff*multiplier, allowance*multiplier,
-				1<<shift, multiplier*2)
-		}
-	}
-}
-
-// adjustLastDigit modifies d = x-currentDiff*ε, to get closest to
-// d = x-targetDiff*ε, without becoming smaller than x-maxDiff*ε.
-// It assumes that a decimal digit is worth ulpDecimal*ε, and that
-// all data is known with an error estimate of ulpBinary*ε.
-func adjustLastDigit(d *decimalSlice, currentDiff, targetDiff, maxDiff, ulpDecimal, ulpBinary uint64) bool {
-	if ulpDecimal < 2*ulpBinary {
-		// Approximation is too wide.
-		return false
-	}
-	for currentDiff+ulpDecimal/2+ulpBinary < targetDiff {
-		d.d[d.nd-1]--
-		currentDiff += ulpDecimal
-	}
-	if currentDiff+ulpDecimal <= targetDiff+ulpDecimal/2+ulpBinary {
-		// we have two choices, and don't know what to do.
-		return false
-	}
-	if currentDiff < ulpBinary || currentDiff > maxDiff-ulpBinary {
-		// we went too far
-		return false
-	}
-	if d.nd == 1 && d.d[0] == '0' {
-		// the number has actually reached zero.
-		d.nd = 0
-		d.dp = 0
-	}
-	return true
-}
diff --git a/src/strconv/ftoaryu.go b/src/strconv/ftoaryu.go
index e53de75667..1c61288b9f 100644
--- a/src/strconv/ftoaryu.go
+++ b/src/strconv/ftoaryu.go
@@ -156,6 +156,11 @@ func ryuFtoaFixed64(d *decimalSlice, mant uint64, exp int, prec int) {
 	d.dp -= q
 }
 
+var uint64pow10 = [...]uint64{
+	1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
+	1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
+}
+
 // formatDecimal fills d with at most prec decimal digits
 // of mantissa m. The boolean trunc indicates whether m
 // is truncated compared to the original number being formatted.
-- 
GitLab


From cde6a675bccb95f0660e302965065eeef6a68128 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 1 Apr 2021 12:23:22 -0400
Subject: [PATCH 1791/2400] go/scanner: optimize scanIdentifier
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

While profiling parsing, I noticed that scanIdentifier was extremely
hot, and could be optimized: it is responsible for a significant
fraction of scanning and had a lot of unnecessary branching, bounds
checks, and function calls.

This CL implements some of those optimizations, while trying to strike a
balance between optimization and readability. It achieves this by
optimizing for the common case of ASCII identifiers, falling back on the
slower scan when encountering the first non-ASCII character.

Benchmark results:

name                               old time/op    new time/op    delta
Scan-12                              16.9µs ± 4%    15.8µs ± 5%   -6.92%  (p=0.000 n=20+18)
ScanFiles/go/types/expr.go-12         793µs ± 4%     672µs ± 6%  -15.23%  (p=0.000 n=20+20)
ScanFiles/go/parser/parser.go-12     1.08ms ± 6%    0.90ms ± 4%  -16.68%  (p=0.000 n=20+20)
ScanFiles/net/http/server.go-12      1.44ms ± 4%    1.23ms ± 5%  -14.58%  (p=0.000 n=18+20)
ScanFiles/go/scanner/errors.go-12    40.7µs ± 2%    32.6µs ± 3%  -20.01%  (p=0.000 n=19+20)

Change-Id: If78380004248e3ea75cfc78eb7f38f528124dced
Reviewed-on: https://go-review.googlesource.com/c/go/+/308611
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/scanner/scanner.go | 53 ++++++++++++++++++++++++++++++++++++---
 1 file changed, 50 insertions(+), 3 deletions(-)

diff --git a/src/go/scanner/scanner.go b/src/go/scanner/scanner.go
index 00fe2dc0b1..299c03fc97 100644
--- a/src/go/scanner/scanner.go
+++ b/src/go/scanner/scanner.go
@@ -48,11 +48,16 @@ type Scanner struct {
 	ErrorCount int // number of errors encountered
 }
 
-const bom = 0xFEFF // byte order mark, only permitted as very first character
+const (
+	bom = 0xFEFF // byte order mark, only permitted as very first character
+	eof = -1     // end of file
+)
 
 // Read the next Unicode char into s.ch.
 // s.ch < 0 means end-of-file.
 //
+// For optimization, there is some overlap between this method and
+// s.scanIdentifier.
 func (s *Scanner) next() {
 	if s.rdOffset < len(s.src) {
 		s.offset = s.rdOffset
@@ -81,7 +86,7 @@ func (s *Scanner) next() {
 			s.lineOffset = s.offset
 			s.file.AddLine(s.offset)
 		}
-		s.ch = -1 // eof
+		s.ch = eof
 	}
 }
 
@@ -347,11 +352,53 @@ func isDigit(ch rune) bool {
 	return isDecimal(ch) || ch >= utf8.RuneSelf && unicode.IsDigit(ch)
 }
 
+// scanIdentifier reads the string of valid identifier characters at s.offset.
+// It must only be called when s.ch is known to be a valid letter.
+//
+// Be careful when making changes to this function: it is optimized and affects
+// scanning performance significantly.
 func (s *Scanner) scanIdentifier() string {
 	offs := s.offset
-	for isLetter(s.ch) || isDigit(s.ch) {
+
+	// Optimize for the common case of an ASCII identifier.
+	//
+	// Ranging over s.src[s.rdOffset:] lets us avoid some bounds checks, and
+	// avoids conversions to runes.
+	//
+	// In case we encounter a non-ASCII character, fall back on the slower path
+	// of calling into s.next().
+	for rdOffset, b := range s.src[s.rdOffset:] {
+		if 'a' <= b && b <= 'z' || 'A' <= b && b <= 'Z' || b == '_' || '0' <= b && b <= '9' {
+			// Avoid assigning a rune for the common case of an ascii character.
+			continue
+		}
+		s.rdOffset += rdOffset
+		if b < utf8.RuneSelf {
+			// Optimization: we've encountered an ASCII character that's not a letter
+			// or number. Avoid the call into s.next() and corresponding set up.
+			//
+			// Note that s.next() does some line accounting if s.ch is '\n', so this
+			// shortcut is only possible because we know that the preceding character
+			// is not '\n'.
+			s.ch = rune(b)
+			s.offset = s.rdOffset
+			s.rdOffset++
+			goto exit
+		}
+		// We know that the preceding character is valid for an identifier because
+		// scanIdentifier is only called when s.ch is a letter, so calling s.next()
+		// at s.rdOffset resets the scanner state.
 		s.next()
+		for isLetter(s.ch) || isDigit(s.ch) {
+			s.next()
+		}
+		goto exit
 	}
+	s.offset = len(s.src)
+	s.rdOffset = len(s.src)
+	s.ch = eof
+
+exit:
 	return string(s.src[offs:s.offset])
 }
 
-- 
GitLab


From 222101549a1b0d9810e2069f776c92b6807a739d Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 27 Apr 2021 10:54:09 -0400
Subject: [PATCH 1792/2400] syscall: restore nosplit for ptrace1 on Darwin

ptrace1 must be nosplit because it is called from
forAndExecInChild. It was marked nosplit in the generated code
but not in the generator. CL 313230 regenerated the code and lost
the nosplit mark. This CL restores it.

Change-Id: I4645d83650f1818bed3cb650328bba97074b6b2d
Reviewed-on: https://go-review.googlesource.com/c/go/+/314249
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/syscall/mksyscall.pl             | 2 +-
 src/syscall/zsyscall_darwin_amd64.go | 1 +
 src/syscall/zsyscall_darwin_arm64.go | 1 +
 3 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/syscall/mksyscall.pl b/src/syscall/mksyscall.pl
index 452ab6c96a..5ca3b465d8 100755
--- a/src/syscall/mksyscall.pl
+++ b/src/syscall/mksyscall.pl
@@ -137,7 +137,7 @@ while(<>) {
 	# without reading the header.
 	$text .= "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n";
 
-	if (($darwin || ($openbsd && $libc)) && $func eq "ptrace") {
+	if (($darwin && $func eq "ptrace1") || (($openbsd && $libc) && $func eq "ptrace")) {
 		# The ptrace function is called from forkAndExecInChild where stack
 		# growth is forbidden.
 		$text .= "//go:nosplit\n"
diff --git a/src/syscall/zsyscall_darwin_amd64.go b/src/syscall/zsyscall_darwin_amd64.go
index 369f5a1702..07a519d7d6 100644
--- a/src/syscall/zsyscall_darwin_amd64.go
+++ b/src/syscall/zsyscall_darwin_amd64.go
@@ -1972,6 +1972,7 @@ func libc_fstatat64_trampoline()
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+//go:nosplit
 func ptrace1(request int, pid int, addr uintptr, data uintptr) (err error) {
 	_, _, e1 := syscall6(abi.FuncPCABI0(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
 	if e1 != 0 {
diff --git a/src/syscall/zsyscall_darwin_arm64.go b/src/syscall/zsyscall_darwin_arm64.go
index 2185f324c1..5ae096730e 100644
--- a/src/syscall/zsyscall_darwin_arm64.go
+++ b/src/syscall/zsyscall_darwin_arm64.go
@@ -1972,6 +1972,7 @@ func libc_fstatat_trampoline()
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+//go:nosplit
 func ptrace1(request int, pid int, addr uintptr, data uintptr) (err error) {
 	_, _, e1 := syscall6(abi.FuncPCABI0(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
 	if e1 != 0 {
-- 
GitLab


From bd2175e1b1369bce59cdceb9282c817802a87746 Mon Sep 17 00:00:00 2001
From: Ray Wu <ray@liftoff.io>
Date: Tue, 20 Apr 2021 10:41:37 -0700
Subject: [PATCH 1793/2400] cmd/go: show warnings about symlinks only for
 patterns containing ...

Go commands show a warning message any time a pattern is expanded and a
symlink to a directory is encountered. For monorepo with non Go projects
using symlinks underneath, the output of go commands could be spammed by
this warning.

This commit includes the behavior change to only print this warning when
there's a pattern containing ... .

Fixes #35941

Change-Id: I094da2628bcd47b86fee8c6529d1066aa013a43b
Reviewed-on: https://go-review.googlesource.com/c/go/+/311890
Run-TryBot: Caleb Spare <cespare@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
Trust: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modload/search.go         |  2 +-
 src/cmd/go/internal/search/search.go          |  2 +-
 .../script/list_symlink_issue35941.txt        | 18 ++++++++++
 .../script/mod_tidy_symlink_issue35941.txt    | 36 +++++++++++++++++++
 4 files changed, 56 insertions(+), 2 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/list_symlink_issue35941.txt
 create mode 100644 src/cmd/go/testdata/script/mod_tidy_symlink_issue35941.txt

diff --git a/src/cmd/go/internal/modload/search.go b/src/cmd/go/internal/modload/search.go
index c34f745a24..658fc6f55a 100644
--- a/src/cmd/go/internal/modload/search.go
+++ b/src/cmd/go/internal/modload/search.go
@@ -86,7 +86,7 @@ func matchPackages(ctx context.Context, m *search.Match, tags map[string]bool, f
 			}
 
 			if !fi.IsDir() {
-				if fi.Mode()&fs.ModeSymlink != 0 && want {
+				if fi.Mode()&fs.ModeSymlink != 0 && want && strings.Contains(m.Pattern(), "...") {
 					if target, err := fsys.Stat(path); err == nil && target.IsDir() {
 						fmt.Fprintf(os.Stderr, "warning: ignoring symlink %s\n", path)
 					}
diff --git a/src/cmd/go/internal/search/search.go b/src/cmd/go/internal/search/search.go
index faf3a321dd..f1152080a7 100644
--- a/src/cmd/go/internal/search/search.go
+++ b/src/cmd/go/internal/search/search.go
@@ -155,7 +155,7 @@ func (m *Match) MatchPackages() {
 			}
 
 			if !fi.IsDir() {
-				if fi.Mode()&fs.ModeSymlink != 0 && want {
+				if fi.Mode()&fs.ModeSymlink != 0 && want && strings.Contains(m.pattern, "...") {
 					if target, err := fsys.Stat(path); err == nil && target.IsDir() {
 						fmt.Fprintf(os.Stderr, "warning: ignoring symlink %s\n", path)
 					}
diff --git a/src/cmd/go/testdata/script/list_symlink_issue35941.txt b/src/cmd/go/testdata/script/list_symlink_issue35941.txt
new file mode 100644
index 0000000000..eb12bde6ce
--- /dev/null
+++ b/src/cmd/go/testdata/script/list_symlink_issue35941.txt
@@ -0,0 +1,18 @@
+[!symlink] skip
+env GO111MODULE=off
+
+# Issue 35941: suppress symlink warnings when running 'go list all'.
+symlink goproj/css -> $GOPATH/src/css
+
+go list all
+! stderr 'warning: ignoring symlink'
+
+# Show symlink warnings when patterns contain '...'.
+go list goproj/...
+stderr 'warning: ignoring symlink'
+
+-- goproj/a.go --
+package a
+
+-- css/index.css --
+body {}
diff --git a/src/cmd/go/testdata/script/mod_tidy_symlink_issue35941.txt b/src/cmd/go/testdata/script/mod_tidy_symlink_issue35941.txt
new file mode 100644
index 0000000000..d4658c65d4
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_tidy_symlink_issue35941.txt
@@ -0,0 +1,36 @@
+env GO111MODULE=on
+[!symlink] skip
+
+cd m
+symlink symlink -> ../outside
+
+cp go.mod go.mod.orig
+
+# Issue 35941: suppress symlink warnings when running 'go mod tidy'.
+# 'go mod tidy' should not scan packages in symlinked subdirectories.
+go mod tidy
+! stderr 'warning: ignoring symlink'
+cmp go.mod go.mod.orig
+
+! go build ./symlink
+stderr '^symlink[\\/]symlink.go:3:8: module example.net/unresolved provides package example.net/unresolved and is replaced but not required; to add it:\n\tgo get example.net/unresolved@v0.1.0$'
+
+-- m/go.mod --
+module example.net/m
+
+go 1.16
+
+replace example.net/unresolved v0.1.0 => ../unresolved
+-- m/a.go --
+package a
+-- outside/symlink.go --
+package symlink
+
+import _ "example.net/unresolved"
+-- unresolved/go.mod --
+module example.net/unresolved
+
+go 1.16
+-- unresolved/unresolved.go --
+// Package unresolved exists, but 'go mod tidy' won't add it.
+package unresolved
-- 
GitLab


From 8e0023b81b81352c1f8ea5cd58eea91939924f9d Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Tue, 27 Apr 2021 03:01:08 -0400
Subject: [PATCH 1794/2400] cmd/go/internal/load: treat packages with errors as
 potentially main packages
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

If a package declares 'package main' but for some reason we fail to
read its name (for example, due to a permission or checksum error),
we may be tempted to drop the package from the output of
mainPackagesOnly. However, that leads to a confusing
"no packages loaded from …" error message.

Instead, we will treat packages with errors as potentially-main
packages, and print the error. At least if we print why the package is
broken, the user will understand that the weird behavior is due to the
broken package rather than, say, a typo on their part in the command
arguments.

Updates #42088
For #36460

Change-Id: I033c0d28ac7d105d9df3ba5f9327e5c0c2a29954
Reviewed-on: https://go-review.googlesource.com/c/go/+/314050
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/load/pkg.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/go/internal/load/pkg.go b/src/cmd/go/internal/load/pkg.go
index acba232308..c1e3eaa0f3 100644
--- a/src/cmd/go/internal/load/pkg.go
+++ b/src/cmd/go/internal/load/pkg.go
@@ -2563,7 +2563,7 @@ func mainPackagesOnly(pkgs []*Package, patterns []string) []*Package {
 	mainCount := make([]int, len(patterns))
 	nonMainCount := make([]int, len(patterns))
 	for _, pkg := range pkgs {
-		if pkg.Name == "main" {
+		if pkg.Name == "main" || (pkg.Incomplete && pkg.Name == "") {
 			matchedPkgs = append(matchedPkgs, pkg)
 			for i := range patterns {
 				if matchers[i] != nil && matchers[i](pkg.ImportPath) {
-- 
GitLab


From 0ae9c3b98bf01862f11d764ee379bebc29a76431 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Felix=20Geisend=C3=B6rfer?=
 <felix.geisendoerfer@datadoghq.com>
Date: Fri, 26 Feb 2021 14:41:19 +0100
Subject: [PATCH 1795/2400] runtime/pprof: fix block profile bias

Block profiles were biased towards infrequent long events over frequent
short events. This fix corrects the bias by aggregating shorter events
as longer but less frequent in the profiles. As a result their
cumulative duration will be accurately represented in the profile
without skewing their sample mean (duration/count).

Credit to @dvyukov for suggesting to adjust the count in the
saveblockevent function.

Fixes #44192.

Change-Id: I71a99d7f6ebdb2d484d44890a2517863cceb4004
Reviewed-on: https://go-review.googlesource.com/c/go/+/299991
Trust: Michael Pratt <mpratt@google.com>
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Michael Pratt <mpratt@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
---
 src/runtime/mprof.go            | 35 ++++++++++++-----
 src/runtime/pprof/pprof_test.go | 70 +++++++++++++++++++++++++++++++++
 2 files changed, 95 insertions(+), 10 deletions(-)

diff --git a/src/runtime/mprof.go b/src/runtime/mprof.go
index 1156329615..5235b898e4 100644
--- a/src/runtime/mprof.go
+++ b/src/runtime/mprof.go
@@ -133,7 +133,7 @@ func (a *memRecordCycle) add(b *memRecordCycle) {
 // A blockRecord is the bucket data for a bucket of type blockProfile,
 // which is used in blocking and mutex profiles.
 type blockRecord struct {
-	count  int64
+	count  float64
 	cycles int64
 }
 
@@ -398,20 +398,23 @@ func blockevent(cycles int64, skip int) {
 	if cycles <= 0 {
 		cycles = 1
 	}
-	if blocksampled(cycles) {
-		saveblockevent(cycles, skip+1, blockProfile)
+
+	rate := int64(atomic.Load64(&blockprofilerate))
+	if blocksampled(cycles, rate) {
+		saveblockevent(cycles, rate, skip+1, blockProfile)
 	}
 }
 
-func blocksampled(cycles int64) bool {
-	rate := int64(atomic.Load64(&blockprofilerate))
+// blocksampled returns true for all events where cycles >= rate. Shorter
+// events have a cycles/rate random chance of returning true.
+func blocksampled(cycles, rate int64) bool {
 	if rate <= 0 || (rate > cycles && int64(fastrand())%rate > cycles) {
 		return false
 	}
 	return true
 }
 
-func saveblockevent(cycles int64, skip int, which bucketType) {
+func saveblockevent(cycles, rate int64, skip int, which bucketType) {
 	gp := getg()
 	var nstk int
 	var stk [maxStack]uintptr
@@ -422,8 +425,15 @@ func saveblockevent(cycles int64, skip int, which bucketType) {
 	}
 	lock(&proflock)
 	b := stkbucket(which, 0, stk[:nstk], true)
-	b.bp().count++
-	b.bp().cycles += cycles
+
+	if which == blockProfile && cycles < rate {
+		// Remove sampling bias, see discussion on http://golang.org/cl/299991.
+		b.bp().count += float64(rate) / float64(cycles)
+		b.bp().cycles += rate
+	} else {
+		b.bp().count++
+		b.bp().cycles += cycles
+	}
 	unlock(&proflock)
 }
 
@@ -454,7 +464,7 @@ func mutexevent(cycles int64, skip int) {
 	// TODO(pjw): measure impact of always calling fastrand vs using something
 	// like malloc.go:nextSample()
 	if rate > 0 && int64(fastrand())%rate == 0 {
-		saveblockevent(cycles, skip+1, mutexProfile)
+		saveblockevent(cycles, rate, skip+1, mutexProfile)
 	}
 }
 
@@ -656,7 +666,12 @@ func BlockProfile(p []BlockProfileRecord) (n int, ok bool) {
 		for b := bbuckets; b != nil; b = b.allnext {
 			bp := b.bp()
 			r := &p[0]
-			r.Count = bp.count
+			r.Count = int64(bp.count)
+			// Prevent callers from having to worry about division by zero errors.
+			// See discussion on http://golang.org/cl/299991.
+			if r.Count == 0 {
+				r.Count = 1
+			}
 			r.Cycles = bp.cycles
 			if raceenabled {
 				racewriterangepc(unsafe.Pointer(&r.Stack0[0]), unsafe.Sizeof(r.Stack0), getcallerpc(), funcPC(BlockProfile))
diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go
index 3423f8dc3d..7cbb4fc7ae 100644
--- a/src/runtime/pprof/pprof_test.go
+++ b/src/runtime/pprof/pprof_test.go
@@ -14,6 +14,7 @@ import (
 	"internal/profile"
 	"internal/testenv"
 	"io"
+	"math"
 	"math/big"
 	"os"
 	"os/exec"
@@ -24,6 +25,7 @@ import (
 	"sync/atomic"
 	"testing"
 	"time"
+	_ "unsafe"
 )
 
 func cpuHogger(f func(x int) int, y *int, dur time.Duration) {
@@ -895,6 +897,74 @@ func blockCond() {
 	mu.Unlock()
 }
 
+// See http://golang.org/cl/299991.
+func TestBlockProfileBias(t *testing.T) {
+	rate := int(1000) // arbitrary value
+	runtime.SetBlockProfileRate(rate)
+	defer runtime.SetBlockProfileRate(0)
+
+	// simulate blocking events
+	blockFrequentShort(rate)
+	blockInfrequentLong(rate)
+
+	var w bytes.Buffer
+	Lookup("block").WriteTo(&w, 0)
+	p, err := profile.Parse(&w)
+	if err != nil {
+		t.Fatalf("failed to parse profile: %v", err)
+	}
+	t.Logf("parsed proto: %s", p)
+
+	il := float64(-1) // blockInfrequentLong duration
+	fs := float64(-1) // blockFrequentShort duration
+	for _, s := range p.Sample {
+		for _, l := range s.Location {
+			for _, line := range l.Line {
+				if len(s.Value) < 2 {
+					t.Fatal("block profile has less than 2 sample types")
+				}
+
+				if line.Function.Name == "runtime/pprof.blockInfrequentLong" {
+					il = float64(s.Value[1])
+				} else if line.Function.Name == "runtime/pprof.blockFrequentShort" {
+					fs = float64(s.Value[1])
+				}
+			}
+		}
+	}
+	if il == -1 || fs == -1 {
+		t.Fatal("block profile is missing expected functions")
+	}
+
+	// stddev of bias from 100 runs on local machine multiplied by 10x
+	const threshold = 0.2
+	if bias := (il - fs) / il; math.Abs(bias) > threshold {
+		t.Fatalf("bias: abs(%f) > %f", bias, threshold)
+	} else {
+		t.Logf("bias: abs(%f) < %f", bias, threshold)
+	}
+}
+
+// blockFrequentShort produces 100000 block events with an average duration of
+// rate / 10.
+func blockFrequentShort(rate int) {
+	for i := 0; i < 100000; i++ {
+		blockevent(int64(rate/10), 1)
+	}
+}
+
+// blockFrequentShort produces 10000 block events with an average duration of
+// rate.
+func blockInfrequentLong(rate int) {
+	for i := 0; i < 10000; i++ {
+		blockevent(int64(rate), 1)
+	}
+}
+
+// Used by TestBlockProfileBias.
+//go:linkname blockevent runtime.blockevent
+func blockevent(cycles int64, skip int)
+
 func TestMutexProfile(t *testing.T) {
 	// Generate mutex profile
 
-- 
GitLab


From 291eb0178f143b373a9bc4fbc4edaf3420175660 Mon Sep 17 00:00:00 2001
From: kumakichi <xyesan@gmail.com>
Date: Tue, 27 Apr 2021 18:38:55 +0000
Subject: [PATCH 1796/2400] go: various minor cleanups with the help of Goland
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

    • fix some typos
    • remove superfluous conversions/parentheses
    • remove superfluous nil checks

Change-Id: I428bf6a7be551b79270567047878c3076dd6f2ff
GitHub-Last-Rev: 3b1c7573cfdf89ac184fd6ae44bca4be78b0cd64
GitHub-Pull-Request: golang/go#45799
Reviewed-on: https://go-review.googlesource.com/c/go/+/314069
Reviewed-by: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
---
 src/go/internal/srcimporter/srcimporter.go | 2 +-
 src/go/parser/error_test.go                | 2 +-
 src/go/parser/parser.go                    | 2 +-
 src/go/printer/printer.go                  | 2 +-
 src/go/scanner/errors.go                   | 2 +-
 src/go/scanner/scanner.go                  | 2 +-
 src/go/types/infer.go                      | 2 +-
 7 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/go/internal/srcimporter/srcimporter.go b/src/go/internal/srcimporter/srcimporter.go
index 438ae0ff2e..e4225eb4d7 100644
--- a/src/go/internal/srcimporter/srcimporter.go
+++ b/src/go/internal/srcimporter/srcimporter.go
@@ -30,7 +30,7 @@ type Importer struct {
 	packages map[string]*types.Package
 }
 
-// NewImporter returns a new Importer for the given context, file set, and map
+// New returns a new Importer for the given context, file set, and map
 // of packages. The context is used to resolve import paths to package paths,
 // and identifying the files belonging to the package. If the context provides
 // non-nil file system functions, they are used instead of the regular package
diff --git a/src/go/parser/error_test.go b/src/go/parser/error_test.go
index 5d45a7b817..f4f0a5240a 100644
--- a/src/go/parser/error_test.go
+++ b/src/go/parser/error_test.go
@@ -90,7 +90,7 @@ func expectedErrors(fset *token.FileSet, filename string, src []byte) map[token.
 				if s[1] == "HERE" {
 					pos = here
 				}
-				errors[pos] = string(s[2])
+				errors[pos] = s[2]
 			}
 		case token.SEMICOLON:
 			// don't use the position of auto-inserted (invisible) semicolons
diff --git a/src/go/parser/parser.go b/src/go/parser/parser.go
index a4db57170b..36a044e3a2 100644
--- a/src/go/parser/parser.go
+++ b/src/go/parser/parser.go
@@ -891,7 +891,7 @@ func (p *parser) parseParameters(acceptTParams bool) (tparams, params *ast.Field
 		rbrack := p.expect(token.RBRACK)
 		tparams = &ast.FieldList{Opening: opening, List: list, Closing: rbrack}
 		// Type parameter lists must not be empty.
-		if tparams != nil && tparams.NumFields() == 0 {
+		if tparams.NumFields() == 0 {
 			p.error(tparams.Closing, "empty type parameter list")
 			tparams = nil // avoid follow-on errors
 		}
diff --git a/src/go/printer/printer.go b/src/go/printer/printer.go
index f02c1b847b..ba61f78226 100644
--- a/src/go/printer/printer.go
+++ b/src/go/printer/printer.go
@@ -844,7 +844,7 @@ func (p *printer) writeWhitespace(n int) {
 // ----------------------------------------------------------------------------
 // Printing interface
 
-// nlines limits n to maxNewlines.
+// nlimit limits n to maxNewlines.
 func nlimit(n int) int {
 	if n > maxNewlines {
 		n = maxNewlines
diff --git a/src/go/scanner/errors.go b/src/go/scanner/errors.go
index bf7bfa30e4..3114f4b645 100644
--- a/src/go/scanner/errors.go
+++ b/src/go/scanner/errors.go
@@ -86,7 +86,7 @@ func (p *ErrorList) RemoveMultiples() {
 			i++
 		}
 	}
-	(*p) = (*p)[0:i]
+	*p = (*p)[0:i]
 }
 
 // An ErrorList implements the error interface.
diff --git a/src/go/scanner/scanner.go b/src/go/scanner/scanner.go
index 299c03fc97..29cbf39721 100644
--- a/src/go/scanner/scanner.go
+++ b/src/go/scanner/scanner.go
@@ -430,7 +430,7 @@ func (s *Scanner) digits(base int, invalid *int) (digsep int) {
 			if s.ch == '_' {
 				ds = 2
 			} else if s.ch >= max && *invalid < 0 {
-				*invalid = int(s.offset) // record invalid rune offset
+				*invalid = s.offset // record invalid rune offset
 			}
 			digsep |= ds
 			s.next()
diff --git a/src/go/types/infer.go b/src/go/types/infer.go
index 8b491eb3ba..9a45d5e994 100644
--- a/src/go/types/infer.go
+++ b/src/go/types/infer.go
@@ -215,7 +215,7 @@ func (check *Checker) infer(posn positioner, tparams []*TypeName, targs []Type,
 	}
 
 	// At least one type argument couldn't be inferred.
-	assert(targs != nil && index >= 0 && targs[index] == nil)
+	assert(index >= 0 && targs[index] == nil)
 	tpar := tparams[index]
 	if report {
 		check.errorf(posn, _Todo, "cannot infer %s (%v) (%v)", tpar.name, tpar.pos, targs)
-- 
GitLab


From 0c3557e6adbc4892afbef65d76ec5bce3d84a964 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Tue, 27 Apr 2021 11:28:40 -0700
Subject: [PATCH 1797/2400] syscall: move TestForegroundSignal create call out
 of goroutine

That way the skip takes effect.

Also ignore the result of calling TIOCSPGRP when cleaing up TestForeground.
It has started to fail for some reason, and the result doesn't matter.

Also call TIOCSPGRP to clean up in TestForegroundSignal.

For #37217

Change-Id: I2e4282d7d91ad9a198eeb12cef01c2214c2a98c2
Reviewed-on: https://go-review.googlesource.com/c/go/+/314271
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/syscall/exec_unix_test.go | 29 ++++++++++++++++++++++++-----
 1 file changed, 24 insertions(+), 5 deletions(-)

diff --git a/src/syscall/exec_unix_test.go b/src/syscall/exec_unix_test.go
index 643c2e9789..866671ba2a 100644
--- a/src/syscall/exec_unix_test.go
+++ b/src/syscall/exec_unix_test.go
@@ -214,10 +214,9 @@ func TestForeground(t *testing.T) {
 
 	cmd.Stop()
 
-	errno = syscall.Ioctl(tty.Fd(), syscall.TIOCSPGRP, uintptr(unsafe.Pointer(&fpgrp)))
-	if errno != 0 {
-		t.Fatalf("TIOCSPGRP failed with error code: %s", errno)
-	}
+	// This call fails on darwin/arm64. The failure doesn't matter, though.
+	// This is just best effort.
+	syscall.Ioctl(tty.Fd(), syscall.TIOCSPGRP, uintptr(unsafe.Pointer(&fpgrp)))
 }
 
 func TestForegroundSignal(t *testing.T) {
@@ -227,14 +226,34 @@ func TestForegroundSignal(t *testing.T) {
 	}
 	defer tty.Close()
 
+	// This should really be pid_t, however _C_int (aka int32) is generally
+	// equivalent.
+	fpgrp := int32(0)
+
+	errno := syscall.Ioctl(tty.Fd(), syscall.TIOCGPGRP, uintptr(unsafe.Pointer(&fpgrp)))
+	if errno != 0 {
+		t.Fatalf("TIOCGPGRP failed with error code: %s", errno)
+	}
+
+	if fpgrp == 0 {
+		t.Fatalf("Foreground process group is zero")
+	}
+
+	defer func() {
+		signal.Ignore(syscall.SIGTTIN, syscall.SIGTTOU)
+		syscall.Ioctl(tty.Fd(), syscall.TIOCSPGRP, uintptr(unsafe.Pointer(&fpgrp)))
+		signal.Reset()
+	}()
+
 	ch1 := make(chan os.Signal, 1)
 	ch2 := make(chan bool)
 
 	signal.Notify(ch1, syscall.SIGTTIN, syscall.SIGTTOU)
 	defer signal.Stop(ch1)
 
+	cmd := create(t)
+
 	go func() {
-		cmd := create(t)
 		cmd.proc.SysProcAttr = &syscall.SysProcAttr{
 			Ctty:       int(tty.Fd()),
 			Foreground: true,
-- 
GitLab


From 8ab7064e33667f17b8d23b5db63468199c3eac02 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Tue, 27 Apr 2021 02:31:23 -0400
Subject: [PATCH 1798/2400] cmd/go: use a real Go version in the go.mod files
 in TestScript/mod_readonly

For some reason, the go.mod file added to this test in CL 147281 lists
'go 1.20' instead of the version that was actually current when the
go.mod file was added.

That causes the test's behavior to change under lazy loading, because
1.20 is above the threshold to trigger lazy-loading invariants (1.17).

For #36460

Change-Id: I92400996cb051ab30e99bfffafd91ff32a1e7087
Reviewed-on: https://go-review.googlesource.com/c/go/+/314049
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/testdata/script/mod_readonly.txt | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/cmd/go/testdata/script/mod_readonly.txt b/src/cmd/go/testdata/script/mod_readonly.txt
index 176be72967..d05ad2a317 100644
--- a/src/cmd/go/testdata/script/mod_readonly.txt
+++ b/src/cmd/go/testdata/script/mod_readonly.txt
@@ -89,7 +89,7 @@ stderr '^no required module provides package rsc.io/quote; to add it:\n\tgo get
 -- go.mod --
 module m
 
-go 1.20
+go 1.16
 
 -- x.go --
 package x
@@ -104,7 +104,7 @@ require (
 -- go.mod.redundant --
 module m
 
-go 1.20
+go 1.16
 
 require (
 	rsc.io/quote v1.5.2
@@ -114,7 +114,7 @@ require (
 -- go.mod.indirect --
 module m
 
-go 1.20
+go 1.16
 
 require (
 	rsc.io/quote v1.5.2 // indirect
@@ -124,7 +124,7 @@ require (
 -- go.mod.untidy --
 module m
 
-go 1.20
+go 1.16
 
 require (
 	rsc.io/sampler v1.3.0 // indirect
-- 
GitLab


From f432d3fc41b8f6b01131023aabcf935ebea172cb Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Mon, 26 Apr 2021 14:13:19 -0700
Subject: [PATCH 1799/2400] cmd/compile: fix nongeneric closures in generic
 functions

Ensure that formal parameter Names are correctly copied and marked
with the correct Curfn. We need to ensure this even when the underlying
closure has no type parameters.

(Aside: it is strange that the types of things contain formal
parameter names that need to be copied. Maybe that's an underlying
larger problem that needs to be fixed.)

Fixes #45738

Change-Id: Ia13d69eea992ff7080bd44065115bc52eb624e73
Reviewed-on: https://go-review.googlesource.com/c/go/+/313652
Trust: Keith Randall <khr@golang.org>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/escape/escape.go |  5 ++++-
 src/cmd/compile/internal/noder/stencil.go |  5 ++++-
 test/typeparam/issue45738.go              | 18 ++++++++++++++++++
 3 files changed, 26 insertions(+), 2 deletions(-)
 create mode 100644 test/typeparam/issue45738.go

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index b706d7d2c8..05bd44c35d 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -1295,7 +1295,7 @@ func (e *escape) newLoc(n ir.Node, transient bool) *location {
 		if n.Op() == ir.ONAME {
 			n := n.(*ir.Name)
 			if n.Curfn != e.curfn {
-				base.Fatalf("curfn mismatch: %v != %v", n.Curfn, e.curfn)
+				base.Fatalf("curfn mismatch: %v != %v for %v", n.Curfn, e.curfn, n)
 			}
 
 			if n.Opt != nil {
@@ -1308,6 +1308,9 @@ func (e *escape) newLoc(n ir.Node, transient bool) *location {
 }
 
 func (b *batch) oldLoc(n *ir.Name) *location {
+	if n.Canonical().Opt == nil {
+		base.Fatalf("%v has no location", n)
+	}
 	return n.Canonical().Opt.(*location)
 }
 
diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index d60f0af548..3ebc8dff6d 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -667,7 +667,10 @@ func instTypeName(name string, targs []*types.Type) string {
 // result is t; otherwise the result is a new type. It deals with recursive types
 // by using TFORW types and finding partially or fully created types via sym.Def.
 func (subst *subster) typ(t *types.Type) *types.Type {
-	if !t.HasTParam() {
+	if !t.HasTParam() && t.Kind() != types.TFUNC {
+		// Note: function types need to be copied regardless, as the
+		// types of closures may contain declarations that need
+		// to be copied. See #45738.
 		return t
 	}
 
diff --git a/test/typeparam/issue45738.go b/test/typeparam/issue45738.go
new file mode 100644
index 0000000000..9f03e796a3
--- /dev/null
+++ b/test/typeparam/issue45738.go
@@ -0,0 +1,18 @@
+// compile -G=3
+
+// Copyright 2021 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
+
+//go:noinline
+func f[T any]() {
+	x := 5
+	g := func() int { return x }
+	g()
+}
+
+func main() {
+	f[int]()
+}
-- 
GitLab


From 13e87cda000149ff3efce95210b0c921f7d772bf Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Mon, 26 Apr 2021 17:49:28 -0700
Subject: [PATCH 1800/2400] time: increase slop for TestTicker

Also sleep a bit each time it fails, in case the system is overloaded.

Fixes #37332

Change-Id: Iabf3d0a27b5834c1e2a87c826b6206146b4f62c5
Reviewed-on: https://go-review.googlesource.com/c/go/+/313849
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/time/tick_test.go | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/time/tick_test.go b/src/time/tick_test.go
index 9a1cdf9ab2..b5d0a189bc 100644
--- a/src/time/tick_test.go
+++ b/src/time/tick_test.go
@@ -52,9 +52,14 @@ func TestTicker(t *testing.T) {
 		t1 := Now()
 		dt := t1.Sub(t0)
 		target := 3 * delta * Duration(count/2)
-		slop := target * 2 / 10
+		slop := target * 3 / 10
 		if dt < target-slop || dt > target+slop {
-			errs = append(errs, fmt.Sprintf("%d %s ticks took %s, expected [%s,%s]", count, delta, dt, target-slop, target+slop))
+			errs = append(errs, fmt.Sprintf("%d %s ticks then %d %s ticks took %s, expected [%s,%s]", count/2, delta, count/2, delta*2, dt, target-slop, target+slop))
+			if dt > target+slop {
+				// System may be overloaded; sleep a bit
+				// in the hopes it will recover.
+				Sleep(Second / 2)
+			}
 			continue
 		}
 		// Now test that the ticker stopped.
-- 
GitLab


From b9dfaf77f55fb00173ae18b0dac9d43e7e5855c1 Mon Sep 17 00:00:00 2001
From: cuiweixie <cuiweixie@gmail.com>
Date: Tue, 27 Apr 2021 08:50:06 +0000
Subject: [PATCH 1801/2400] cmd/compile/internal/walk: merge operations

Change-Id: I018872da519dfb4aa6c252ea28fc09289c2d9711
GitHub-Last-Rev: 5969776197003cae317f6b45f88ac4ced10beaf3
GitHub-Pull-Request: golang/go#45795
Reviewed-on: https://go-review.googlesource.com/c/go/+/313550
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/walk/range.go | 32 ++++++++------------------
 1 file changed, 10 insertions(+), 22 deletions(-)

diff --git a/src/cmd/compile/internal/walk/range.go b/src/cmd/compile/internal/walk/range.go
index 3384bc826e..0c651c6289 100644
--- a/src/cmd/compile/internal/walk/range.go
+++ b/src/cmd/compile/internal/walk/range.go
@@ -118,9 +118,7 @@ func walkRange(nrange *ir.RangeStmt) ir.Node {
 			tmp.SetBounded(true)
 			// Use OAS2 to correctly handle assignments
 			// of the form "v1, a[v1] := range".
-			a := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-			a.Lhs = []ir.Node{v1, v2}
-			a.Rhs = []ir.Node{hv1, tmp}
+			a := ir.NewAssignListStmt(base.Pos, ir.OAS2, []ir.Node{v1, v2}, []ir.Node{hv1, tmp})
 			body = []ir.Node{a}
 			break
 		}
@@ -148,9 +146,7 @@ func walkRange(nrange *ir.RangeStmt) ir.Node {
 
 		// Use OAS2 to correctly handle assignments
 		// of the form "v1, a[v1] := range".
-		a := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-		a.Lhs = []ir.Node{v1, v2}
-		a.Rhs = []ir.Node{hv1, ir.NewStarExpr(base.Pos, hp)}
+		a := ir.NewAssignListStmt(base.Pos, ir.OAS2, []ir.Node{v1, v2}, []ir.Node{hv1, ir.NewStarExpr(base.Pos, hp)})
 		body = append(body, a)
 
 		// Advance pointer as part of the late increment.
@@ -190,9 +186,7 @@ func walkRange(nrange *ir.RangeStmt) ir.Node {
 			body = []ir.Node{ir.NewAssignStmt(base.Pos, v1, key)}
 		} else {
 			elem := ir.NewStarExpr(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, hit, elemsym))
-			a := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-			a.Lhs = []ir.Node{v1, v2}
-			a.Rhs = []ir.Node{key, elem}
+			a := ir.NewAssignListStmt(base.Pos, ir.OAS2, []ir.Node{v1, v2}, []ir.Node{key, elem})
 			body = []ir.Node{a}
 		}
 
@@ -208,10 +202,10 @@ func walkRange(nrange *ir.RangeStmt) ir.Node {
 		hb := typecheck.Temp(types.Types[types.TBOOL])
 
 		nfor.Cond = ir.NewBinaryExpr(base.Pos, ir.ONE, hb, ir.NewBool(false))
-		a := ir.NewAssignListStmt(base.Pos, ir.OAS2RECV, nil, nil)
+		lhs := []ir.Node{hv1, hb}
+		rhs := []ir.Node{ir.NewUnaryExpr(base.Pos, ir.ORECV, ha)}
+		a := ir.NewAssignListStmt(base.Pos, ir.OAS2RECV, lhs, rhs)
 		a.SetTypecheck(1)
-		a.Lhs = []ir.Node{hv1, hb}
-		a.Rhs = []ir.Node{ir.NewUnaryExpr(base.Pos, ir.ORECV, ha)}
 		nfor.Cond = ir.InitExpr([]ir.Node{a}, nfor.Cond)
 		if v1 == nil {
 			body = nil
@@ -270,24 +264,18 @@ func walkRange(nrange *ir.RangeStmt) ir.Node {
 		nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, hv1, ir.NewBinaryExpr(base.Pos, ir.OADD, hv1, ir.NewInt(1)))}
 
 		// } else {
-		eif := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-
 		// hv2, hv1 = decoderune(ha, hv1)
-		eif.Lhs = []ir.Node{hv2, hv1}
 		fn := typecheck.LookupRuntime("decoderune")
-		var fnInit ir.Nodes
-		eif.Rhs = []ir.Node{mkcall1(fn, fn.Type().Results(), &fnInit, ha, hv1)}
-		fnInit.Append(eif)
-		nif.Else = fnInit
+		call := mkcall1(fn, fn.Type().Results(), &nif.Else, ha, hv1)
+		a := ir.NewAssignListStmt(base.Pos, ir.OAS2, []ir.Node{hv2, hv1}, []ir.Node{call})
+		nif.Else.Append(a)
 
 		body = append(body, nif)
 
 		if v1 != nil {
 			if v2 != nil {
 				// v1, v2 = hv1t, hv2
-				a := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-				a.Lhs = []ir.Node{v1, v2}
-				a.Rhs = []ir.Node{hv1t, hv2}
+				a := ir.NewAssignListStmt(base.Pos, ir.OAS2, []ir.Node{v1, v2}, []ir.Node{hv1t, hv2})
 				body = append(body, a)
 			} else {
 				// v1 = hv1t
-- 
GitLab


From 30002e665658b4b2c147caaee6bf7734042952e8 Mon Sep 17 00:00:00 2001
From: SataQiu <shidaqiu2018@gmail.com>
Date: Thu, 15 Apr 2021 23:39:30 +0800
Subject: [PATCH 1802/2400] cmd/go/internal/modload: treat \ as a path
 separator instead of a shell special character

According to the code comment, \ should be treated as a path separator.
See fileNameOK in golang.org/x/mod/module/module.go.

Change-Id: I05e05246005191ecccfecf46848aba5cb1359956
Reviewed-on: https://go-review.googlesource.com/c/go/+/310429
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Trust: Robert Findley <rfindley@google.com>
---
 src/cmd/go/internal/modload/init.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index 4d240a7b64..3c7db6c8a7 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -554,7 +554,7 @@ func checkModulePathLax(p string) error {
 	// with file systems and subcommands. Disallow file path separators : and \
 	// because path separators other than / will confuse the module cache.
 	// See fileNameOK in golang.org/x/mod/module/module.go.
-	shellChars := "`" + `\"'*<>?|`
+	shellChars := "`" + `"'*<>?|`
 	fsChars := `\:`
 	if i := strings.IndexAny(p, shellChars); i >= 0 {
 		return errorf("contains disallowed shell character %q", p[i])
-- 
GitLab


From 645cb62ee3926ce88b8c2cf556fed6dea3d525ce Mon Sep 17 00:00:00 2001
From: Julien Tant <julien@craftyx.fr>
Date: Tue, 27 Apr 2021 21:32:18 +0000
Subject: [PATCH 1803/2400] testing: document that TestMain can be used with
 benchmarks

Fixes #45764

Change-Id: Ie6c18bb5c20721c2ffa8b4a9cf9f97cdc665a450
GitHub-Last-Rev: 8bcea7e0ff60227c05437b372c0a3546e151af31
GitHub-Pull-Request: golang/go#45808
Reviewed-on: https://go-review.googlesource.com/c/go/+/314349
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Bryan C. Mills <bcmills@google.com>
---
 src/testing/testing.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/testing/testing.go b/src/testing/testing.go
index 2146195956..1562eadef0 100644
--- a/src/testing/testing.go
+++ b/src/testing/testing.go
@@ -208,14 +208,14 @@
 //
 // Main
 //
-// It is sometimes necessary for a test program to do extra setup or teardown
-// before or after testing. It is also sometimes necessary for a test to control
+// It is sometimes necessary for a test or benchmark program to do extra setup or teardown
+// before or after it executes. It is also sometimes necessary to control
 // which code runs on the main thread. To support these and other cases,
 // if a test file contains a function:
 //
 //	func TestMain(m *testing.M)
 //
-// then the generated test will call TestMain(m) instead of running the tests
+// then the generated test will call TestMain(m) instead of running the tests or benchmarks
 // directly. TestMain runs in the main goroutine and can do whatever setup
 // and teardown is necessary around a call to m.Run. m.Run will return an exit
 // code that may be passed to os.Exit. If TestMain returns, the test wrapper
-- 
GitLab


From 214c8dd80c4059543b91d45c55ab12e8d58dec48 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 27 Apr 2021 16:30:26 -0400
Subject: [PATCH 1804/2400] go/types: factor out index/slice expr handling

This is a port of CL 308370 to go/types. There are some differences in
the index checking code, but the methodology for moving the code was the
same: replace `goto Error` with `x.mode = invalid; return`.

Change-Id: I880f577a7720e6ad8a5b096207001fcf7620396d
Reviewed-on: https://go-review.googlesource.com/c/go/+/312095
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/expr.go  | 380 +--------------------------------------
 src/go/types/index.go | 410 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 412 insertions(+), 378 deletions(-)
 create mode 100644 src/go/types/index.go

diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 7d701d985b..bdab7d9aa6 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -1002,121 +1002,6 @@ func (check *Checker) binary(x *operand, e ast.Expr, lhs, rhs ast.Expr, op token
 	// x.typ is unchanged
 }
 
-// index checks an index expression for validity.
-// If max >= 0, it is the upper bound for index.
-// If the result typ is != Typ[Invalid], index is valid and typ is its (possibly named) integer type.
-// If the result val >= 0, index is valid and val is its constant int value.
-func (check *Checker) index(index ast.Expr, max int64) (typ Type, val int64) {
-	typ = Typ[Invalid]
-	val = -1
-
-	var x operand
-	check.expr(&x, index)
-	if !check.isValidIndex(&x, _InvalidIndex, "index", false) {
-		return
-	}
-
-	if x.mode != constant_ {
-		return x.typ, -1
-	}
-
-	if x.val.Kind() == constant.Unknown {
-		return
-	}
-
-	v, ok := constant.Int64Val(x.val)
-	assert(ok)
-	if max >= 0 && v >= max {
-		check.invalidArg(&x, _InvalidIndex, "index %s is out of bounds", &x)
-		return
-	}
-
-	// 0 <= v [ && v < max ]
-	return x.typ, v
-}
-
-func (check *Checker) isValidIndex(x *operand, code errorCode, what string, allowNegative bool) bool {
-	if x.mode == invalid {
-		return false
-	}
-
-	// spec: "a constant index that is untyped is given type int"
-	check.convertUntyped(x, Typ[Int])
-	if x.mode == invalid {
-		return false
-	}
-
-	// spec: "the index x must be of integer type or an untyped constant"
-	if !isInteger(x.typ) {
-		check.invalidArg(x, code, "%s %s must be integer", what, x)
-		return false
-	}
-
-	if x.mode == constant_ {
-		// spec: "a constant index must be non-negative ..."
-		if !allowNegative && constant.Sign(x.val) < 0 {
-			check.invalidArg(x, code, "%s %s must not be negative", what, x)
-			return false
-		}
-
-		// spec: "... and representable by a value of type int"
-		if !representableConst(x.val, check, Typ[Int], &x.val) {
-			check.invalidArg(x, code, "%s %s overflows int", what, x)
-			return false
-		}
-	}
-
-	return true
-}
-
-// indexElts checks the elements (elts) of an array or slice composite literal
-// against the literal's element type (typ), and the element indices against
-// the literal length if known (length >= 0). It returns the length of the
-// literal (maximum index value + 1).
-//
-func (check *Checker) indexedElts(elts []ast.Expr, typ Type, length int64) int64 {
-	visited := make(map[int64]bool, len(elts))
-	var index, max int64
-	for _, e := range elts {
-		// determine and check index
-		validIndex := false
-		eval := e
-		if kv, _ := e.(*ast.KeyValueExpr); kv != nil {
-			if typ, i := check.index(kv.Key, length); typ != Typ[Invalid] {
-				if i >= 0 {
-					index = i
-					validIndex = true
-				} else {
-					check.errorf(e, _InvalidLitIndex, "index %s must be integer constant", kv.Key)
-				}
-			}
-			eval = kv.Value
-		} else if length >= 0 && index >= length {
-			check.errorf(e, _OversizeArrayLit, "index %d is out of bounds (>= %d)", index, length)
-		} else {
-			validIndex = true
-		}
-
-		// if we have a valid index, check for duplicate entries
-		if validIndex {
-			if visited[index] {
-				check.errorf(e, _DuplicateLitKey, "duplicate index %d in array or slice literal", index)
-			}
-			visited[index] = true
-		}
-		index++
-		if index > max {
-			max = index
-		}
-
-		// check element against composite literal element type
-		var x operand
-		check.exprWithHint(&x, eval, typ)
-		check.assignment(&x, typ, "array or slice literal")
-	}
-	return max
-}
-
 // exprKind describes the kind of an expression; the kind
 // determines if an expression is valid in 'statement context'.
 type exprKind int
@@ -1455,278 +1340,17 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 		check.selector(x, e)
 
 	case *ast.IndexExpr:
-		check.exprOrType(x, e.X)
+		check.indexExpr(x, e)
 		if x.mode == invalid {
-			check.use(typeparams.UnpackExpr(e.Index)...)
-			goto Error
-		}
-
-		if x.mode == typexpr {
-			// type instantiation
-			x.mode = invalid
-			x.typ = check.varType(e)
-			if x.typ != Typ[Invalid] {
-				x.mode = typexpr
-			}
-			return expression
-		}
-
-		if x.mode == value {
-			if sig := asSignature(x.typ); sig != nil && len(sig.tparams) > 0 {
-				check.funcInst(x, e)
-				return expression
-			}
-		}
-
-		valid := false
-		length := int64(-1) // valid if >= 0
-		switch typ := optype(x.typ).(type) {
-		case *Basic:
-			if isString(typ) {
-				valid = true
-				if x.mode == constant_ {
-					length = int64(len(constant.StringVal(x.val)))
-				}
-				// an indexed string always yields a byte value
-				// (not a constant) even if the string and the
-				// index are constant
-				x.mode = value
-				x.typ = universeByte // use 'byte' name
-			}
-
-		case *Array:
-			valid = true
-			length = typ.len
-			if x.mode != variable {
-				x.mode = value
-			}
-			x.typ = typ.elem
-
-		case *Pointer:
-			if typ := asArray(typ.base); typ != nil {
-				valid = true
-				length = typ.len
-				x.mode = variable
-				x.typ = typ.elem
-			}
-
-		case *Slice:
-			valid = true
-			x.mode = variable
-			x.typ = typ.elem
-
-		case *Map:
-			var key operand
-			check.expr(&key, e.Index)
-			check.assignment(&key, typ.key, "map index")
-			// ok to continue even if indexing failed - map element type is known
-			x.mode = mapindex
-			x.typ = typ.elem
-			x.expr = e
-			return expression
-
-		case *_Sum:
-			// A sum type can be indexed if all of the sum's types
-			// support indexing and have the same index and element
-			// type. Special rules apply for maps in the sum type.
-			var tkey, telem Type // key is for map types only
-			nmaps := 0           // number of map types in sum type
-			if typ.is(func(t Type) bool {
-				var e Type
-				switch t := under(t).(type) {
-				case *Basic:
-					if isString(t) {
-						e = universeByte
-					}
-				case *Array:
-					e = t.elem
-				case *Pointer:
-					if t := asArray(t.base); t != nil {
-						e = t.elem
-					}
-				case *Slice:
-					e = t.elem
-				case *Map:
-					// If there are multiple maps in the sum type,
-					// they must have identical key types.
-					// TODO(gri) We may be able to relax this rule
-					// but it becomes complicated very quickly.
-					if tkey != nil && !Identical(t.key, tkey) {
-						return false
-					}
-					tkey = t.key
-					e = t.elem
-					nmaps++
-				case *_TypeParam:
-					check.errorf(x, 0, "type of %s contains a type parameter - cannot index (implementation restriction)", x)
-				case *instance:
-					panic("unimplemented")
-				}
-				if e == nil || telem != nil && !Identical(e, telem) {
-					return false
-				}
-				telem = e
-				return true
-			}) {
-				// If there are maps, the index expression must be assignable
-				// to the map key type (as for simple map index expressions).
-				if nmaps > 0 {
-					var key operand
-					check.expr(&key, e.Index)
-					check.assignment(&key, tkey, "map index")
-					// ok to continue even if indexing failed - map element type is known
-
-					// If there are only maps, we are done.
-					if nmaps == len(typ.types) {
-						x.mode = mapindex
-						x.typ = telem
-						x.expr = e
-						return expression
-					}
-
-					// Otherwise we have mix of maps and other types. For
-					// now we require that the map key be an integer type.
-					// TODO(gri) This is probably not good enough.
-					valid = isInteger(tkey)
-					// avoid 2nd indexing error if indexing failed above
-					if !valid && key.mode == invalid {
-						goto Error
-					}
-					x.mode = value // map index expressions are not addressable
-				} else {
-					// no maps
-					valid = true
-					x.mode = variable
-				}
-				x.typ = telem
-			}
-		}
-
-		if !valid {
-			check.invalidOp(x, _NonIndexableOperand, "cannot index %s", x)
-			goto Error
-		}
-
-		if e.Index == nil {
-			check.invalidAST(e, "missing index for %s", x)
 			goto Error
 		}
 
-		// In pathological (invalid) cases (e.g.: type T1 [][[]T1{}[0][0]]T0)
-		// the element type may be accessed before it's set. Make sure we have
-		// a valid type.
-		if x.typ == nil {
-			x.typ = Typ[Invalid]
-		}
-
-		check.index(e.Index, length)
-		// ok to continue
-
 	case *ast.SliceExpr:
-		check.expr(x, e.X)
+		check.sliceExpr(x, e)
 		if x.mode == invalid {
-			check.use(e.Low, e.High, e.Max)
 			goto Error
 		}
 
-		valid := false
-		length := int64(-1) // valid if >= 0
-		switch typ := optype(x.typ).(type) {
-		case *Basic:
-			if isString(typ) {
-				if e.Slice3 {
-					check.invalidOp(x, _InvalidSliceExpr, "3-index slice of string")
-					goto Error
-				}
-				valid = true
-				if x.mode == constant_ {
-					length = int64(len(constant.StringVal(x.val)))
-				}
-				// spec: "For untyped string operands the result
-				// is a non-constant value of type string."
-				if typ.kind == UntypedString {
-					x.typ = Typ[String]
-				}
-			}
-
-		case *Array:
-			valid = true
-			length = typ.len
-			if x.mode != variable {
-				check.invalidOp(x, _NonSliceableOperand, "cannot slice %s (value not addressable)", x)
-				goto Error
-			}
-			x.typ = &Slice{elem: typ.elem}
-
-		case *Pointer:
-			if typ := asArray(typ.base); typ != nil {
-				valid = true
-				length = typ.len
-				x.typ = &Slice{elem: typ.elem}
-			}
-
-		case *Slice:
-			valid = true
-			// x.typ doesn't change
-
-		case *_Sum, *_TypeParam:
-			check.errorf(x, 0, "generic slice expressions not yet implemented")
-			goto Error
-		}
-
-		if !valid {
-			check.invalidOp(x, _NonSliceableOperand, "cannot slice %s", x)
-			goto Error
-		}
-
-		x.mode = value
-
-		// spec: "Only the first index may be omitted; it defaults to 0."
-		if e.Slice3 && (e.High == nil || e.Max == nil) {
-			check.invalidAST(inNode(e, e.Rbrack), "2nd and 3rd index required in 3-index slice")
-			goto Error
-		}
-
-		// check indices
-		var ind [3]int64
-		for i, expr := range []ast.Expr{e.Low, e.High, e.Max} {
-			x := int64(-1)
-			switch {
-			case expr != nil:
-				// The "capacity" is only known statically for strings, arrays,
-				// and pointers to arrays, and it is the same as the length for
-				// those types.
-				max := int64(-1)
-				if length >= 0 {
-					max = length + 1
-				}
-				if _, v := check.index(expr, max); v >= 0 {
-					x = v
-				}
-			case i == 0:
-				// default is 0 for the first index
-				x = 0
-			case length >= 0:
-				// default is length (== capacity) otherwise
-				x = length
-			}
-			ind[i] = x
-		}
-
-		// constant indices must be in range
-		// (check.index already checks that existing indices >= 0)
-	L:
-		for i, x := range ind[:len(ind)-1] {
-			if x > 0 {
-				for _, y := range ind[i+1:] {
-					if y >= 0 && x > y {
-						check.errorf(inNode(e, e.Rbrack), _SwappedSliceIndices, "swapped slice indices: %d > %d", x, y)
-						break L // only report one error, ok to continue
-					}
-				}
-			}
-		}
-
 	case *ast.TypeAssertExpr:
 		check.expr(x, e.X)
 		if x.mode == invalid {
diff --git a/src/go/types/index.go b/src/go/types/index.go
new file mode 100644
index 0000000000..f497b06dad
--- /dev/null
+++ b/src/go/types/index.go
@@ -0,0 +1,410 @@
+// Copyright 2021 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.
+
+// This file implements typechecking of index/slice expressions.
+
+package types
+
+import (
+	"go/ast"
+	"go/constant"
+	"go/internal/typeparams"
+)
+
+func (check *Checker) indexExpr(x *operand, e *ast.IndexExpr) {
+	check.exprOrType(x, e.X)
+	if x.mode == invalid {
+		check.use(typeparams.UnpackExpr(e.Index)...)
+		return
+	}
+
+	if x.mode == typexpr {
+		// type instantiation
+		x.mode = invalid
+		x.typ = check.varType(e)
+		if x.typ != Typ[Invalid] {
+			x.mode = typexpr
+		}
+		return
+	}
+
+	if x.mode == value {
+		if sig := asSignature(x.typ); sig != nil && len(sig.tparams) > 0 {
+			check.funcInst(x, e)
+			return
+		}
+	}
+
+	valid := false
+	length := int64(-1) // valid if >= 0
+	switch typ := optype(x.typ).(type) {
+	case *Basic:
+		if isString(typ) {
+			valid = true
+			if x.mode == constant_ {
+				length = int64(len(constant.StringVal(x.val)))
+			}
+			// an indexed string always yields a byte value
+			// (not a constant) even if the string and the
+			// index are constant
+			x.mode = value
+			x.typ = universeByte // use 'byte' name
+		}
+
+	case *Array:
+		valid = true
+		length = typ.len
+		if x.mode != variable {
+			x.mode = value
+		}
+		x.typ = typ.elem
+
+	case *Pointer:
+		if typ := asArray(typ.base); typ != nil {
+			valid = true
+			length = typ.len
+			x.mode = variable
+			x.typ = typ.elem
+		}
+
+	case *Slice:
+		valid = true
+		x.mode = variable
+		x.typ = typ.elem
+
+	case *Map:
+		var key operand
+		check.expr(&key, e.Index)
+		check.assignment(&key, typ.key, "map index")
+		// ok to continue even if indexing failed - map element type is known
+		x.mode = mapindex
+		x.typ = typ.elem
+		x.expr = e
+		return
+
+	case *_Sum:
+		// A sum type can be indexed if all of the sum's types
+		// support indexing and have the same index and element
+		// type. Special rules apply for maps in the sum type.
+		var tkey, telem Type // key is for map types only
+		nmaps := 0           // number of map types in sum type
+		if typ.is(func(t Type) bool {
+			var e Type
+			switch t := under(t).(type) {
+			case *Basic:
+				if isString(t) {
+					e = universeByte
+				}
+			case *Array:
+				e = t.elem
+			case *Pointer:
+				if t := asArray(t.base); t != nil {
+					e = t.elem
+				}
+			case *Slice:
+				e = t.elem
+			case *Map:
+				// If there are multiple maps in the sum type,
+				// they must have identical key types.
+				// TODO(gri) We may be able to relax this rule
+				// but it becomes complicated very quickly.
+				if tkey != nil && !Identical(t.key, tkey) {
+					return false
+				}
+				tkey = t.key
+				e = t.elem
+				nmaps++
+			case *_TypeParam:
+				check.errorf(x, 0, "type of %s contains a type parameter - cannot index (implementation restriction)", x)
+			case *instance:
+				panic("unimplemented")
+			}
+			if e == nil || telem != nil && !Identical(e, telem) {
+				return false
+			}
+			telem = e
+			return true
+		}) {
+			// If there are maps, the index expression must be assignable
+			// to the map key type (as for simple map index expressions).
+			if nmaps > 0 {
+				var key operand
+				check.expr(&key, e.Index)
+				check.assignment(&key, tkey, "map index")
+				// ok to continue even if indexing failed - map element type is known
+
+				// If there are only maps, we are done.
+				if nmaps == len(typ.types) {
+					x.mode = mapindex
+					x.typ = telem
+					x.expr = e
+					return
+				}
+
+				// Otherwise we have mix of maps and other types. For
+				// now we require that the map key be an integer type.
+				// TODO(gri) This is probably not good enough.
+				valid = isInteger(tkey)
+				// avoid 2nd indexing error if indexing failed above
+				if !valid && key.mode == invalid {
+					x.mode = invalid
+					return
+				}
+				x.mode = value // map index expressions are not addressable
+			} else {
+				// no maps
+				valid = true
+				x.mode = variable
+			}
+			x.typ = telem
+		}
+	}
+
+	if !valid {
+		check.invalidOp(x, _NonIndexableOperand, "cannot index %s", x)
+		x.mode = invalid
+		return
+	}
+
+	if e.Index == nil {
+		check.invalidAST(e, "missing index for %s", x)
+		x.mode = invalid
+		return
+	}
+
+	// In pathological (invalid) cases (e.g.: type T1 [][[]T1{}[0][0]]T0)
+	// the element type may be accessed before it's set. Make sure we have
+	// a valid type.
+	if x.typ == nil {
+		x.typ = Typ[Invalid]
+	}
+
+	check.index(e.Index, length)
+}
+
+func (check *Checker) sliceExpr(x *operand, e *ast.SliceExpr) {
+	check.expr(x, e.X)
+	if x.mode == invalid {
+		check.use(e.Low, e.High, e.Max)
+		return
+	}
+
+	valid := false
+	length := int64(-1) // valid if >= 0
+	switch typ := optype(x.typ).(type) {
+	case *Basic:
+		if isString(typ) {
+			if e.Slice3 {
+				check.invalidOp(x, _InvalidSliceExpr, "3-index slice of string")
+				x.mode = invalid
+				return
+			}
+			valid = true
+			if x.mode == constant_ {
+				length = int64(len(constant.StringVal(x.val)))
+			}
+			// spec: "For untyped string operands the result
+			// is a non-constant value of type string."
+			if typ.kind == UntypedString {
+				x.typ = Typ[String]
+			}
+		}
+
+	case *Array:
+		valid = true
+		length = typ.len
+		if x.mode != variable {
+			check.invalidOp(x, _NonSliceableOperand, "cannot slice %s (value not addressable)", x)
+			x.mode = invalid
+			return
+		}
+		x.typ = &Slice{elem: typ.elem}
+
+	case *Pointer:
+		if typ := asArray(typ.base); typ != nil {
+			valid = true
+			length = typ.len
+			x.typ = &Slice{elem: typ.elem}
+		}
+
+	case *Slice:
+		valid = true
+		// x.typ doesn't change
+
+	case *_Sum, *_TypeParam:
+		check.errorf(x, 0, "generic slice expressions not yet implemented")
+		x.mode = invalid
+		return
+	}
+
+	if !valid {
+		check.invalidOp(x, _NonSliceableOperand, "cannot slice %s", x)
+		x.mode = invalid
+		return
+	}
+
+	x.mode = value
+
+	// spec: "Only the first index may be omitted; it defaults to 0."
+	if e.Slice3 && (e.High == nil || e.Max == nil) {
+		check.invalidAST(inNode(e, e.Rbrack), "2nd and 3rd index required in 3-index slice")
+		x.mode = invalid
+		return
+	}
+
+	// check indices
+	var ind [3]int64
+	for i, expr := range []ast.Expr{e.Low, e.High, e.Max} {
+		x := int64(-1)
+		switch {
+		case expr != nil:
+			// The "capacity" is only known statically for strings, arrays,
+			// and pointers to arrays, and it is the same as the length for
+			// those types.
+			max := int64(-1)
+			if length >= 0 {
+				max = length + 1
+			}
+			if _, v := check.index(expr, max); v >= 0 {
+				x = v
+			}
+		case i == 0:
+			// default is 0 for the first index
+			x = 0
+		case length >= 0:
+			// default is length (== capacity) otherwise
+			x = length
+		}
+		ind[i] = x
+	}
+
+	// constant indices must be in range
+	// (check.index already checks that existing indices >= 0)
+L:
+	for i, x := range ind[:len(ind)-1] {
+		if x > 0 {
+			for _, y := range ind[i+1:] {
+				if y >= 0 && x > y {
+					check.errorf(inNode(e, e.Rbrack), _SwappedSliceIndices, "swapped slice indices: %d > %d", x, y)
+					break L // only report one error, ok to continue
+				}
+			}
+		}
+	}
+}
+
+// index checks an index expression for validity.
+// If max >= 0, it is the upper bound for index.
+// If the result typ is != Typ[Invalid], index is valid and typ is its (possibly named) integer type.
+// If the result val >= 0, index is valid and val is its constant int value.
+func (check *Checker) index(index ast.Expr, max int64) (typ Type, val int64) {
+	typ = Typ[Invalid]
+	val = -1
+
+	var x operand
+	check.expr(&x, index)
+	if !check.isValidIndex(&x, _InvalidIndex, "index", false) {
+		return
+	}
+
+	if x.mode != constant_ {
+		return x.typ, -1
+	}
+
+	if x.val.Kind() == constant.Unknown {
+		return
+	}
+
+	v, ok := constant.Int64Val(x.val)
+	assert(ok)
+	if max >= 0 && v >= max {
+		check.invalidArg(&x, _InvalidIndex, "index %s is out of bounds", &x)
+		return
+	}
+
+	// 0 <= v [ && v < max ]
+	return x.typ, v
+}
+
+func (check *Checker) isValidIndex(x *operand, code errorCode, what string, allowNegative bool) bool {
+	if x.mode == invalid {
+		return false
+	}
+
+	// spec: "a constant index that is untyped is given type int"
+	check.convertUntyped(x, Typ[Int])
+	if x.mode == invalid {
+		return false
+	}
+
+	// spec: "the index x must be of integer type or an untyped constant"
+	if !isInteger(x.typ) {
+		check.invalidArg(x, code, "%s %s must be integer", what, x)
+		return false
+	}
+
+	if x.mode == constant_ {
+		// spec: "a constant index must be non-negative ..."
+		if !allowNegative && constant.Sign(x.val) < 0 {
+			check.invalidArg(x, code, "%s %s must not be negative", what, x)
+			return false
+		}
+
+		// spec: "... and representable by a value of type int"
+		if !representableConst(x.val, check, Typ[Int], &x.val) {
+			check.invalidArg(x, code, "%s %s overflows int", what, x)
+			return false
+		}
+	}
+
+	return true
+}
+
+// indexElts checks the elements (elts) of an array or slice composite literal
+// against the literal's element type (typ), and the element indices against
+// the literal length if known (length >= 0). It returns the length of the
+// literal (maximum index value + 1).
+//
+func (check *Checker) indexedElts(elts []ast.Expr, typ Type, length int64) int64 {
+	visited := make(map[int64]bool, len(elts))
+	var index, max int64
+	for _, e := range elts {
+		// determine and check index
+		validIndex := false
+		eval := e
+		if kv, _ := e.(*ast.KeyValueExpr); kv != nil {
+			if typ, i := check.index(kv.Key, length); typ != Typ[Invalid] {
+				if i >= 0 {
+					index = i
+					validIndex = true
+				} else {
+					check.errorf(e, _InvalidLitIndex, "index %s must be integer constant", kv.Key)
+				}
+			}
+			eval = kv.Value
+		} else if length >= 0 && index >= length {
+			check.errorf(e, _OversizeArrayLit, "index %d is out of bounds (>= %d)", index, length)
+		} else {
+			validIndex = true
+		}
+
+		// if we have a valid index, check for duplicate entries
+		if validIndex {
+			if visited[index] {
+				check.errorf(e, _DuplicateLitKey, "duplicate index %d in array or slice literal", index)
+			}
+			visited[index] = true
+		}
+		index++
+		if index > max {
+			max = index
+		}
+
+		// check element against composite literal element type
+		var x operand
+		check.exprWithHint(&x, eval, typ)
+		check.assignment(&x, typ, "array or slice literal")
+	}
+	return max
+}
-- 
GitLab


From 983dea90c169930e35721232afe39fd4e3fbe4a6 Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Tue, 27 Apr 2021 15:05:51 -0500
Subject: [PATCH 1805/2400] cmd/link: disable plugin support if cgo is disabled

Functional plugin support requires cgo to be enabled. Disable
it if the environment has disabled cgo.

This prevents unexpected linker failures when linking large
binaries with cgo disabled which use the plugin package.

Fixes #45564

Change-Id: Ib71f0e089f7373b7b3e3cd53da3612291e7bc473
Reviewed-on: https://go-review.googlesource.com/c/go/+/314449
Run-TryBot: Paul Murphy <murp@ibm.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Lynn Boger <laboger@linux.vnet.ibm.com>
---
 src/cmd/link/internal/ld/lib.go | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index adf1669cf2..043bf5a35e 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -539,7 +539,10 @@ func (ctxt *Link) loadlib() {
 	// up symbol by name may not get expected result.
 
 	iscgo = ctxt.LibraryByPkg["runtime/cgo"] != nil
-	ctxt.canUsePlugins = ctxt.LibraryByPkg["plugin"] != nil
+
+	// Plugins a require cgo support to function. Similarly, plugins may require additional
+	// internal linker support on some platforms which may not be implemented.
+	ctxt.canUsePlugins = ctxt.LibraryByPkg["plugin"] != nil && iscgo
 
 	// We now have enough information to determine the link mode.
 	determineLinkMode(ctxt)
-- 
GitLab


From c9f43507c6d8106646b1262052cc9a2c5dbb6e4c Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Tue, 27 Apr 2021 23:01:16 +0700
Subject: [PATCH 1806/2400] cmd/compile: fix typechecking logical operators
 panic with non-boolean operand

In CL 255899, we added code to make clearer error when non-bool used
as operand to logical operators. The code is safe, because node type
is guaranteed to be non-nil.

In CL 279442, we refactored typechecking arith, including moving
typechecking logical operators to separate case. Now we have to
explicitly check if operand type is not nil, because calling Expr can
set operand type nil for non-bool operands.

Fixes #45804

Change-Id: Ie2b6e18f65c0614a803b343f60e78ee1d660bbeb
Reviewed-on: https://go-review.googlesource.com/c/go/+/314209
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 .../compile/internal/typecheck/typecheck.go   |  4 ++++
 test/fixedbugs/issue45804.go                  | 19 +++++++++++++++++++
 2 files changed, 23 insertions(+)
 create mode 100644 test/fixedbugs/issue45804.go

diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index ab493e0caa..00dd44b96b 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -596,6 +596,10 @@ func typecheck1(n ir.Node, top int) ir.Node {
 	case ir.OANDAND, ir.OOROR:
 		n := n.(*ir.LogicalExpr)
 		n.X, n.Y = Expr(n.X), Expr(n.Y)
+		if n.X.Type() == nil || n.Y.Type() == nil {
+			n.SetType(nil)
+			return n
+		}
 		// For "x == x && len(s)", it's better to report that "len(s)" (type int)
 		// can't be used with "&&" than to report that "x == x" (type untyped bool)
 		// can't be converted to int (see issue #41500).
diff --git a/test/fixedbugs/issue45804.go b/test/fixedbugs/issue45804.go
new file mode 100644
index 0000000000..28d42c8d81
--- /dev/null
+++ b/test/fixedbugs/issue45804.go
@@ -0,0 +1,19 @@
+// errorcheck
+
+// Copyright 2021 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 p
+
+func g() int
+func h(int)
+
+var b bool
+
+func f() {
+	did := g()
+	if !did && b { // ERROR "invalid operation"
+		h(x) // ERROR "undefined"
+	}
+}
-- 
GitLab


From f439a762533f3a75eb928b67d0415010aa8a81d7 Mon Sep 17 00:00:00 2001
From: eric fang <eric.fang@arm.com>
Date: Tue, 27 Apr 2021 06:19:57 +0000
Subject: [PATCH 1807/2400] cmd/internal/obj/arm64: fix the wrong error message
 of out-of-range checking

The error message of checking whether the offset value of load/store
instruction is out of range is wrong. The right range is [-256, 255], not
[-255, 254]. The CL fixes it.

Change-Id: Ia342957f1f6bcec65eceb45944221d3972641bed
Reviewed-on: https://go-review.googlesource.com/c/go/+/313891
Reviewed-by: eric fang <eric.fang@arm.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: eric fang <eric.fang@arm.com>
Run-TryBot: eric fang <eric.fang@arm.com>
---
 src/cmd/asm/internal/asm/testdata/arm64error.s | 4 ++--
 src/cmd/internal/obj/arm64/asm7.go             | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/cmd/asm/internal/asm/testdata/arm64error.s b/src/cmd/asm/internal/asm/testdata/arm64error.s
index 1744c09b98..feb03abacd 100644
--- a/src/cmd/asm/internal/asm/testdata/arm64error.s
+++ b/src/cmd/asm/internal/asm/testdata/arm64error.s
@@ -59,8 +59,8 @@ TEXT errors(SB),$0
 	LDP	(R0), (R3, ZR)                                   // ERROR "invalid register pair"
 	LDXPW	(RSP), (R2, R2)                                  // ERROR "constrained unpredictable behavior"
 	LDAXPW	(R5), (R2, R2)                                   // ERROR "constrained unpredictable behavior"
-	MOVD.P	300(R2), R3                                      // ERROR "offset out of range [-255,254]"
-	MOVD.P	R3, 344(R2)                                      // ERROR "offset out of range [-255,254]"
+	MOVD.P	300(R2), R3                                      // ERROR "offset out of range [-256,255]"
+	MOVD.P	R3, 344(R2)                                      // ERROR "offset out of range [-256,255]"
 	MOVD	(R3)(R7.SXTX<<2), R8                             // ERROR "invalid index shift amount"
 	MOVWU	(R5)(R4.UXTW<<3), R10                            // ERROR "invalid index shift amount"
 	MOVWU	(R5)(R4<<1), R10                                 // ERROR "invalid index shift amount"
diff --git a/src/cmd/internal/obj/arm64/asm7.go b/src/cmd/internal/obj/arm64/asm7.go
index 64067a4a17..f2188c3403 100644
--- a/src/cmd/internal/obj/arm64/asm7.go
+++ b/src/cmd/internal/obj/arm64/asm7.go
@@ -3621,7 +3621,7 @@ func (c *ctxt7) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		v := int32(p.From.Offset)
 
 		if v < -256 || v > 255 {
-			c.ctxt.Diag("offset out of range [-255,254]: %v", p)
+			c.ctxt.Diag("offset out of range [-256,255]: %v", p)
 		}
 		o1 = c.opldr(p, p.As)
 		if o.scond == C_XPOST {
@@ -3639,7 +3639,7 @@ func (c *ctxt7) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		v := int32(p.To.Offset)
 
 		if v < -256 || v > 255 {
-			c.ctxt.Diag("offset out of range [-255,254]: %v", p)
+			c.ctxt.Diag("offset out of range [-256,255]: %v", p)
 		}
 		o1 = c.opstr(p, p.As)
 		if o.scond == C_XPOST {
-- 
GitLab


From 9726c78539f4945087c837201c1ec3545a318389 Mon Sep 17 00:00:00 2001
From: eric fang <eric.fang@arm.com>
Date: Wed, 21 Apr 2021 03:12:20 +0000
Subject: [PATCH 1808/2400] cmd/asm: add check for register and shift/extension
 combination on arm64

The current code lacks a check on whether the register and shift/extension
combination is valid, for example the follow instructions also compiles.
	ADD     F1<<1, R1, R3
	ADD     V1<<1, R1, R3
	MOVW    (R9)(F8.SXTW<<2), R19
	VST1    R4.D[1], (R0)

Actually only general registers can perform shift operations, and element
and arrangement extensions are only applicable to vector registers. This
CL adds a check for the register and shift/extension combination on arm64.

Change-Id: I93dd9343e92a66899cba8eaf4e0ac5430e94692b
Reviewed-on: https://go-review.googlesource.com/c/go/+/312571
Trust: eric fang <eric.fang@arm.com>
Reviewed-by: eric fang <eric.fang@arm.com>
Reviewed-by: Keith Randall <khr@golang.org>
Run-TryBot: eric fang <eric.fang@arm.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/asm/internal/arch/arm64.go            | 306 +++++++++---------
 src/cmd/asm/internal/asm/parse.go             |   6 +-
 .../asm/internal/asm/testdata/arm64error.s    |  14 +-
 3 files changed, 174 insertions(+), 152 deletions(-)

diff --git a/src/cmd/asm/internal/arch/arm64.go b/src/cmd/asm/internal/arch/arm64.go
index e557630ca6..40d828a1fe 100644
--- a/src/cmd/asm/internal/arch/arm64.go
+++ b/src/cmd/asm/internal/arch/arm64.go
@@ -147,7 +147,16 @@ func arm64RegisterNumber(name string, n int16) (int16, bool) {
 	return 0, false
 }
 
-// ARM64RegisterExtension parses an ARM64 register with extension or arrangement.
+// ARM64RegisterShift constructs an ARM64 register with shift operation.
+func ARM64RegisterShift(reg, op, count int16) (int64, error) {
+	// the base register of shift operations must be general register.
+	if reg > arm64.REG_R31 || reg < arm64.REG_R0 {
+		return 0, errors.New("invalid register for shift operation")
+	}
+	return int64(reg&31)<<16 | int64(op)<<22 | int64(uint16(count)), nil
+}
+
+// ARM64RegisterExtension constructs an ARM64 register with extension or arrangement.
 func ARM64RegisterExtension(a *obj.Addr, ext string, reg, num int16, isAmount, isIndex bool) error {
 	Rnum := (reg & 31) + int16(num<<5)
 	if isAmount {
@@ -155,154 +164,163 @@ func ARM64RegisterExtension(a *obj.Addr, ext string, reg, num int16, isAmount, i
 			return errors.New("index shift amount is out of range")
 		}
 	}
-	switch ext {
-	case "UXTB":
-		if !isAmount {
-			return errors.New("invalid register extension")
-		}
-		if a.Type == obj.TYPE_MEM {
-			return errors.New("invalid shift for the register offset addressing mode")
-		}
-		a.Reg = arm64.REG_UXTB + Rnum
-	case "UXTH":
-		if !isAmount {
-			return errors.New("invalid register extension")
-		}
-		if a.Type == obj.TYPE_MEM {
-			return errors.New("invalid shift for the register offset addressing mode")
-		}
-		a.Reg = arm64.REG_UXTH + Rnum
-	case "UXTW":
-		if !isAmount {
-			return errors.New("invalid register extension")
-		}
-		// effective address of memory is a base register value and an offset register value.
-		if a.Type == obj.TYPE_MEM {
-			a.Index = arm64.REG_UXTW + Rnum
-		} else {
-			a.Reg = arm64.REG_UXTW + Rnum
-		}
-	case "UXTX":
-		if !isAmount {
-			return errors.New("invalid register extension")
-		}
-		if a.Type == obj.TYPE_MEM {
-			return errors.New("invalid shift for the register offset addressing mode")
-		}
-		a.Reg = arm64.REG_UXTX + Rnum
-	case "SXTB":
-		if !isAmount {
-			return errors.New("invalid register extension")
-		}
-		a.Reg = arm64.REG_SXTB + Rnum
-	case "SXTH":
-		if !isAmount {
-			return errors.New("invalid register extension")
-		}
-		if a.Type == obj.TYPE_MEM {
-			return errors.New("invalid shift for the register offset addressing mode")
-		}
-		a.Reg = arm64.REG_SXTH + Rnum
-	case "SXTW":
-		if !isAmount {
-			return errors.New("invalid register extension")
-		}
-		if a.Type == obj.TYPE_MEM {
-			a.Index = arm64.REG_SXTW + Rnum
-		} else {
-			a.Reg = arm64.REG_SXTW + Rnum
-		}
-	case "SXTX":
-		if !isAmount {
-			return errors.New("invalid register extension")
-		}
-		if a.Type == obj.TYPE_MEM {
-			a.Index = arm64.REG_SXTX + Rnum
-		} else {
-			a.Reg = arm64.REG_SXTX + Rnum
-		}
-	case "LSL":
-		if !isAmount {
-			return errors.New("invalid register extension")
-		}
-		a.Index = arm64.REG_LSL + Rnum
-	case "B8":
-		if isIndex {
-			return errors.New("invalid register extension")
-		}
-		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_8B & 15) << 5)
-	case "B16":
-		if isIndex {
-			return errors.New("invalid register extension")
-		}
-		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_16B & 15) << 5)
-	case "H4":
-		if isIndex {
-			return errors.New("invalid register extension")
-		}
-		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_4H & 15) << 5)
-	case "H8":
-		if isIndex {
-			return errors.New("invalid register extension")
-		}
-		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_8H & 15) << 5)
-	case "S2":
-		if isIndex {
-			return errors.New("invalid register extension")
-		}
-		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_2S & 15) << 5)
-	case "S4":
-		if isIndex {
-			return errors.New("invalid register extension")
-		}
-		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_4S & 15) << 5)
-	case "D1":
-		if isIndex {
-			return errors.New("invalid register extension")
-		}
-		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_1D & 15) << 5)
-	case "D2":
-		if isIndex {
-			return errors.New("invalid register extension")
-		}
-		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_2D & 15) << 5)
-	case "Q1":
-		if isIndex {
-			return errors.New("invalid register extension")
-		}
-		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_1Q & 15) << 5)
-	case "B":
-		if !isIndex {
-			return nil
-		}
-		a.Reg = arm64.REG_ELEM + (reg & 31) + ((arm64.ARNG_B & 15) << 5)
-		a.Index = num
-	case "H":
-		if !isIndex {
-			return nil
-		}
-		a.Reg = arm64.REG_ELEM + (reg & 31) + ((arm64.ARNG_H & 15) << 5)
-		a.Index = num
-	case "S":
-		if !isIndex {
-			return nil
-		}
-		a.Reg = arm64.REG_ELEM + (reg & 31) + ((arm64.ARNG_S & 15) << 5)
-		a.Index = num
-	case "D":
-		if !isIndex {
-			return nil
+	if reg <= arm64.REG_R31 && reg >= arm64.REG_R0 {
+		switch ext {
+		case "UXTB":
+			if !isAmount {
+				return errors.New("invalid register extension")
+			}
+			if a.Type == obj.TYPE_MEM {
+				return errors.New("invalid shift for the register offset addressing mode")
+			}
+			a.Reg = arm64.REG_UXTB + Rnum
+		case "UXTH":
+			if !isAmount {
+				return errors.New("invalid register extension")
+			}
+			if a.Type == obj.TYPE_MEM {
+				return errors.New("invalid shift for the register offset addressing mode")
+			}
+			a.Reg = arm64.REG_UXTH + Rnum
+		case "UXTW":
+			if !isAmount {
+				return errors.New("invalid register extension")
+			}
+			// effective address of memory is a base register value and an offset register value.
+			if a.Type == obj.TYPE_MEM {
+				a.Index = arm64.REG_UXTW + Rnum
+			} else {
+				a.Reg = arm64.REG_UXTW + Rnum
+			}
+		case "UXTX":
+			if !isAmount {
+				return errors.New("invalid register extension")
+			}
+			if a.Type == obj.TYPE_MEM {
+				return errors.New("invalid shift for the register offset addressing mode")
+			}
+			a.Reg = arm64.REG_UXTX + Rnum
+		case "SXTB":
+			if !isAmount {
+				return errors.New("invalid register extension")
+			}
+			a.Reg = arm64.REG_SXTB + Rnum
+		case "SXTH":
+			if !isAmount {
+				return errors.New("invalid register extension")
+			}
+			if a.Type == obj.TYPE_MEM {
+				return errors.New("invalid shift for the register offset addressing mode")
+			}
+			a.Reg = arm64.REG_SXTH + Rnum
+		case "SXTW":
+			if !isAmount {
+				return errors.New("invalid register extension")
+			}
+			if a.Type == obj.TYPE_MEM {
+				a.Index = arm64.REG_SXTW + Rnum
+			} else {
+				a.Reg = arm64.REG_SXTW + Rnum
+			}
+		case "SXTX":
+			if !isAmount {
+				return errors.New("invalid register extension")
+			}
+			if a.Type == obj.TYPE_MEM {
+				a.Index = arm64.REG_SXTX + Rnum
+			} else {
+				a.Reg = arm64.REG_SXTX + Rnum
+			}
+		case "LSL":
+			if !isAmount {
+				return errors.New("invalid register extension")
+			}
+			a.Index = arm64.REG_LSL + Rnum
+		default:
+			return errors.New("unsupported general register extension type: " + ext)
+
 		}
-		a.Reg = arm64.REG_ELEM + (reg & 31) + ((arm64.ARNG_D & 15) << 5)
-		a.Index = num
-	default:
-		return errors.New("unsupported register extension type: " + ext)
+	} else if reg <= arm64.REG_V31 && reg >= arm64.REG_V0 {
+		switch ext {
+		case "B8":
+			if isIndex {
+				return errors.New("invalid register extension")
+			}
+			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_8B & 15) << 5)
+		case "B16":
+			if isIndex {
+				return errors.New("invalid register extension")
+			}
+			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_16B & 15) << 5)
+		case "H4":
+			if isIndex {
+				return errors.New("invalid register extension")
+			}
+			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_4H & 15) << 5)
+		case "H8":
+			if isIndex {
+				return errors.New("invalid register extension")
+			}
+			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_8H & 15) << 5)
+		case "S2":
+			if isIndex {
+				return errors.New("invalid register extension")
+			}
+			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_2S & 15) << 5)
+		case "S4":
+			if isIndex {
+				return errors.New("invalid register extension")
+			}
+			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_4S & 15) << 5)
+		case "D1":
+			if isIndex {
+				return errors.New("invalid register extension")
+			}
+			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_1D & 15) << 5)
+		case "D2":
+			if isIndex {
+				return errors.New("invalid register extension")
+			}
+			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_2D & 15) << 5)
+		case "Q1":
+			if isIndex {
+				return errors.New("invalid register extension")
+			}
+			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_1Q & 15) << 5)
+		case "B":
+			if !isIndex {
+				return nil
+			}
+			a.Reg = arm64.REG_ELEM + (reg & 31) + ((arm64.ARNG_B & 15) << 5)
+			a.Index = num
+		case "H":
+			if !isIndex {
+				return nil
+			}
+			a.Reg = arm64.REG_ELEM + (reg & 31) + ((arm64.ARNG_H & 15) << 5)
+			a.Index = num
+		case "S":
+			if !isIndex {
+				return nil
+			}
+			a.Reg = arm64.REG_ELEM + (reg & 31) + ((arm64.ARNG_S & 15) << 5)
+			a.Index = num
+		case "D":
+			if !isIndex {
+				return nil
+			}
+			a.Reg = arm64.REG_ELEM + (reg & 31) + ((arm64.ARNG_D & 15) << 5)
+			a.Index = num
+		default:
+			return errors.New("unsupported simd register extension type: " + ext)
+		}
+	} else {
+		return errors.New("invalid register and extension combination")
 	}
-
 	return nil
 }
 
-// ARM64RegisterArrangement parses an ARM64 vector register arrangement.
+// ARM64RegisterArrangement constructs an ARM64 vector register arrangement.
 func ARM64RegisterArrangement(reg int16, name, arng string) (int64, error) {
 	var curQ, curSize uint16
 	if name[0] != 'V' {
diff --git a/src/cmd/asm/internal/asm/parse.go b/src/cmd/asm/internal/asm/parse.go
index 2c7332877f..ab48632a44 100644
--- a/src/cmd/asm/internal/asm/parse.go
+++ b/src/cmd/asm/internal/asm/parse.go
@@ -689,7 +689,11 @@ func (p *Parser) registerShift(name string, prefix rune) int64 {
 		p.errorf("unexpected %s in register shift", tok.String())
 	}
 	if p.arch.Family == sys.ARM64 {
-		return int64(r1&31)<<16 | int64(op)<<22 | int64(uint16(count))
+		off, err := arch.ARM64RegisterShift(r1, op, count)
+		if err != nil {
+			p.errorf(err.Error())
+		}
+		return off
 	} else {
 		return int64((r1 & 15) | op<<5 | count)
 	}
diff --git a/src/cmd/asm/internal/asm/testdata/arm64error.s b/src/cmd/asm/internal/asm/testdata/arm64error.s
index feb03abacd..66fc910759 100644
--- a/src/cmd/asm/internal/asm/testdata/arm64error.s
+++ b/src/cmd/asm/internal/asm/testdata/arm64error.s
@@ -96,13 +96,13 @@ TEXT errors(SB),$0
 	VMOV	V8.H[9], R3                                      // ERROR "register element index out of range 0 to 7"
 	VMOV	V8.S[4], R3                                      // ERROR "register element index out of range 0 to 3"
 	VMOV	V8.D[2], R3                                      // ERROR "register element index out of range 0 to 1"
-	VDUP	V8.B[16], R3.B16                                 // ERROR "register element index out of range 0 to 15"
-	VDUP	V8.B[17], R3.B8                                  // ERROR "register element index out of range 0 to 15"
-	VDUP	V8.H[9], R3.H4                                   // ERROR "register element index out of range 0 to 7"
-	VDUP	V8.H[9], R3.H8                                   // ERROR "register element index out of range 0 to 7"
-	VDUP	V8.S[4], R3.S2                                   // ERROR "register element index out of range 0 to 3"
-	VDUP	V8.S[4], R3.S4                                   // ERROR "register element index out of range 0 to 3"
-	VDUP	V8.D[2], R3.D2                                   // ERROR "register element index out of range 0 to 1"
+	VDUP	V8.B[16], V3.B16                                 // ERROR "register element index out of range 0 to 15"
+	VDUP	V8.B[17], V3.B8                                  // ERROR "register element index out of range 0 to 15"
+	VDUP	V8.H[9], V3.H4                                   // ERROR "register element index out of range 0 to 7"
+	VDUP	V8.H[9], V3.H8                                   // ERROR "register element index out of range 0 to 7"
+	VDUP	V8.S[4], V3.S2                                   // ERROR "register element index out of range 0 to 3"
+	VDUP	V8.S[4], V3.S4                                   // ERROR "register element index out of range 0 to 3"
+	VDUP	V8.D[2], V3.D2                                   // ERROR "register element index out of range 0 to 1"
 	VFMLA	V1.D2, V12.D2, V3.S2                             // ERROR "operand mismatch"
 	VFMLA	V1.S2, V12.S2, V3.D2                             // ERROR "operand mismatch"
 	VFMLA	V1.S4, V12.S2, V3.D2                             // ERROR "operand mismatch"
-- 
GitLab


From 92d1afe9890056808ed074e28f0c26380c7e4141 Mon Sep 17 00:00:00 2001
From: eric fang <eric.fang@arm.com>
Date: Thu, 9 Jul 2020 11:27:03 +0000
Subject: [PATCH 1809/2400] cmd/compile/ssa: optimize the derivable known
 branch of If block
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When the control value of a If block is known for a particular inbound edge
because its value can be inferred from the control value of its predecessor,
then this inbound edge can be redirected to the known successor directly,
This CL optimizes this kind of cases to eliminate unnecessary comparision.

For example, the following piece of code comes from runtime.atoi,
if !neg && un > uint(maxInt) {
	return 0, false
}
if neg && un > uint(maxInt)+1 {
	return 0, false
}

Before this optimization, if the first "if" statement does not return, both
conditions of the second "if" statement will be checked. But obviously the
value of neg is known through the first "if" statement, and there is no need
to check neg repeatedly.

After this optimization, this redundancy check is eliminated, and the execution
logic becomes as follows.
if !neg {
	if un > uint(maxInt) {
		return 0, false
	}
} else {
	if un > uint(maxInt)+1 {
		return 0, false
	}
}

This CL does not bring significant performance changes, but it makes the code
structure look more reasonable.

Statistical data from tool compilecmp on Linux/amd64:
name                      old time/op       new time/op       delta
Template                        380ms ± 4%        385ms ± 3%  +1.16%  (p=0.000 n=50+49)
Unicode                         168ms ± 9%        169ms ± 9%    ~     (p=0.421 n=49+46)
GoTypes                         1.99s ± 4%        2.02s ± 4%  +1.48%  (p=0.000 n=49+49)
Compiler                        188ms ± 8%        188ms ± 9%    ~     (p=0.997 n=49+50)
SSA                             11.8s ± 2%        12.0s ± 2%  +1.24%  (p=0.000 n=48+50)
Flate                           242ms ± 6%        244ms ± 9%    ~     (p=0.307 n=46+49)
GoParser                        361ms ± 3%        366ms ± 4%  +1.23%  (p=0.000 n=48+49)
Reflect                         836ms ± 3%        842ms ± 3%  +0.70%  (p=0.004 n=48+48)
Tar                             335ms ± 3%        340ms ± 4%  +1.47%  (p=0.000 n=49+46)
XML                             432ms ± 4%        437ms ± 4%  +1.11%  (p=0.002 n=49+49)
LinkCompiler                    701ms ± 4%        704ms ± 5%    ~     (p=0.278 n=49+50)
ExternalLinkCompiler            1.83s ± 3%        1.84s ± 3%  +0.51%  (p=0.034 n=48+49)
LinkWithoutDebugCompiler        436ms ± 6%        438ms ± 6%    ~     (p=0.419 n=48+49)
[Geo mean]                      612ms             617ms       +0.84%

name                      old alloc/op      new alloc/op      delta
Template                       38.7MB ± 1%       39.1MB ± 1%  +1.19%  (p=0.000 n=50+50)
Unicode                        28.1MB ± 0%       28.1MB ± 0%  +0.20%  (p=0.000 n=49+45)
GoTypes                         168MB ± 1%        170MB ± 1%  +1.05%  (p=0.000 n=48+49)
Compiler                       23.0MB ± 1%       23.1MB ± 1%  +0.63%  (p=0.000 n=50+50)
SSA                            1.54GB ± 1%       1.55GB ± 1%  +0.85%  (p=0.000 n=50+50)
Flate                          23.6MB ± 1%       23.9MB ± 1%  +1.36%  (p=0.000 n=43+46)
GoParser                       35.0MB ± 1%       35.3MB ± 1%  +0.94%  (p=0.000 n=50+50)
Reflect                        84.7MB ± 1%       86.1MB ± 1%  +1.72%  (p=0.000 n=49+49)
Tar                            34.5MB ± 1%       34.9MB ± 1%  +1.07%  (p=0.000 n=47+48)
XML                            44.2MB ± 3%       44.6MB ± 3%  +0.70%  (p=0.003 n=50+49)
LinkCompiler                    128MB ± 0%        128MB ± 0%  +0.01%  (p=0.004 n=49+50)
ExternalLinkCompiler            120MB ± 0%        120MB ± 0%  +0.01%  (p=0.000 n=49+50)
LinkWithoutDebugCompiler       77.3MB ± 0%       77.3MB ± 0%  +0.02%  (p=0.000 n=50+50)
[Geo mean]                     69.1MB            69.6MB       +0.75%

file      before    after     Δ       %
addr2line 4049276   4051308   +2032   +0.050%
api       5248940   5248996   +56     +0.001%
asm       4868093   4868037   -56     -0.001%
buildid   2627666   2626026   -1640   -0.062%
cgo       4614432   4615040   +608    +0.013%
compile   23298888  23301267  +2379   +0.010%
cover     4591609   4591161   -448    -0.010%
dist      3449638   3450254   +616    +0.018%
doc       3925667   3926363   +696    +0.018%
fix       3322936   3323464   +528    +0.016%
link      6628632   6629560   +928    +0.014%
nm        3991753   3996497   +4744   +0.119%
objdump   4396119   4395615   -504    -0.011%
pack      2399719   2399535   -184    -0.008%
pprof     13616418  13622866  +6448   +0.047%
test2json 2646121   2646081   -40     -0.002%
trace     10233087  10226359  -6728   -0.066%
vet       7117994   7121066   +3072   +0.043%
total     111026988 111039495 +12507  +0.011%

On linux arm64:
name                      old time/op       new time/op       delta
Template                        284ms ± 1%        286ms ± 1%  +0.70%  (p=0.000 n=49+50)
Unicode                         125ms ± 3%        125ms ± 2%    ~     (p=0.548 n=50+50)
GoTypes                         1.69s ± 1%        1.71s ± 1%  +1.02%  (p=0.000 n=49+49)
Compiler                        125ms ± 1%        124ms ± 2%  -0.35%  (p=0.020 n=50+50)
SSA                             12.7s ± 1%        12.8s ± 1%  +1.21%  (p=0.000 n=49+49)
Flate                           172ms ± 1%        173ms ± 1%  +0.20%  (p=0.047 n=50+50)
GoParser                        265ms ± 1%        266ms ± 1%  +0.64%  (p=0.000 n=50+50)
Reflect                         651ms ± 1%        650ms ± 1%    ~     (p=0.079 n=48+48)
Tar                             246ms ± 1%        246ms ± 1%    ~     (p=0.202 n=50+46)
XML                             328ms ± 1%        332ms ± 1%  +1.28%  (p=0.000 n=50+49)
LinkCompiler                    600ms ± 1%        599ms ± 1%    ~     (p=0.264 n=50+50)
ExternalLinkCompiler            1.88s ± 1%        1.90s ± 0%  +1.36%  (p=0.000 n=50+50)
LinkWithoutDebugCompiler        365ms ± 1%        365ms ± 1%    ~     (p=0.602 n=50+46)
[Geo mean]                      490ms             492ms       +0.47%

name                      old alloc/op      new alloc/op      delta
Template                       38.8MB ± 1%       39.1MB ± 1%  +0.92%  (p=0.000 n=44+42)
Unicode                        28.4MB ± 0%       28.4MB ± 0%  +0.22%  (p=0.000 n=44+45)
GoTypes                         169MB ± 1%        171MB ± 1%  +1.12%  (p=0.000 n=50+50)
Compiler                       23.2MB ± 1%       23.3MB ± 1%  +0.56%  (p=0.000 n=42+43)
SSA                            1.55GB ± 0%       1.56GB ± 0%  +0.91%  (p=0.000 n=48+49)
Flate                          23.7MB ± 2%       24.0MB ± 1%  +1.20%  (p=0.000 n=50+50)
GoParser                       35.3MB ± 1%       35.6MB ± 1%  +0.88%  (p=0.000 n=50+50)
Reflect                        85.0MB ± 0%       86.5MB ± 0%  +1.70%  (p=0.000 n=49+48)
Tar                            34.5MB ± 1%       34.9MB ± 1%  +1.03%  (p=0.000 n=47+50)
XML                            43.8MB ± 2%       44.0MB ± 0%  +0.41%  (p=0.002 n=49+38)
LinkCompiler                    136MB ± 0%        136MB ± 0%  +0.01%  (p=0.006 n=50+49)
ExternalLinkCompiler            127MB ± 0%        127MB ± 0%  +0.02%  (p=0.000 n=49+50)
LinkWithoutDebugCompiler       84.1MB ± 0%       84.1MB ± 0%    ~     (p=0.534 n=50+50)
[Geo mean]                     70.4MB            70.9MB       +0.69%

file      before    after     Δ       %
addr2line 4006004   4004556   -1448   -0.036%
api       5029716   5028828   -888    -0.018%
asm       4936863   4934943   -1920   -0.039%
buildid   2594947   2594099   -848    -0.033%
cgo       4399702   4399502   -200    -0.005%
compile   22233139  22230486  -2653   -0.012%
cover     4443681   4443881   +200    +0.005%
dist      3365902   3365486   -416    -0.012%
doc       3776175   3776151   -24     -0.001%
fix       3218624   3218600   -24     -0.001%
link      6365001   6361409   -3592   -0.056%
nm        3923345   3923065   -280    -0.007%
objdump   4295473   4296673   +1200   +0.028%
pack      2390561   2389393   -1168   -0.049%
pprof     12866419  12865115  -1304   -0.010%
test2json 2587113   2585561   -1552   -0.060%
trace     9609814   9610846   +1032   +0.011%
vet       6790272   6789760   -512    -0.008%
total     106832751 106818354 -14397  -0.013%

Update: #37608

Change-Id: I2831238b12e3af5aef2261f64f804bf0a8b43f86
Reviewed-on: https://go-review.googlesource.com/c/go/+/244737
Reviewed-by: eric fang <eric.fang@arm.com>
Reviewed-by: Keith Randall <khr@golang.org>
Trust: eric fang <eric.fang@arm.com>
Run-TryBot: eric fang <eric.fang@arm.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ssa/fuse.go          |   8 +-
 .../internal/ssa/fuse_branchredirect.go       | 110 ++++++++++
 src/cmd/compile/internal/ssa/prove.go         |  26 ++-
 test/fuse.go                                  | 190 ++++++++++++++++++
 4 files changed, 321 insertions(+), 13 deletions(-)
 create mode 100644 src/cmd/compile/internal/ssa/fuse_branchredirect.go
 create mode 100644 test/fuse.go

diff --git a/src/cmd/compile/internal/ssa/fuse.go b/src/cmd/compile/internal/ssa/fuse.go
index 236d5bbc55..fec2ba8773 100644
--- a/src/cmd/compile/internal/ssa/fuse.go
+++ b/src/cmd/compile/internal/ssa/fuse.go
@@ -11,8 +11,8 @@ import (
 // fuseEarly runs fuse(f, fuseTypePlain|fuseTypeIntInRange).
 func fuseEarly(f *Func) { fuse(f, fuseTypePlain|fuseTypeIntInRange) }
 
-// fuseLate runs fuse(f, fuseTypePlain|fuseTypeIf).
-func fuseLate(f *Func) { fuse(f, fuseTypePlain|fuseTypeIf) }
+// fuseLate runs fuse(f, fuseTypePlain|fuseTypeIf|fuseTypeBranchRedirect).
+func fuseLate(f *Func) { fuse(f, fuseTypePlain|fuseTypeIf|fuseTypeBranchRedirect) }
 
 type fuseType uint8
 
@@ -20,6 +20,7 @@ const (
 	fuseTypePlain fuseType = 1 << iota
 	fuseTypeIf
 	fuseTypeIntInRange
+	fuseTypeBranchRedirect
 	fuseTypeShortCircuit
 )
 
@@ -43,6 +44,9 @@ func fuse(f *Func, typ fuseType) {
 				changed = shortcircuitBlock(b) || changed
 			}
 		}
+		if typ&fuseTypeBranchRedirect != 0 {
+			changed = fuseBranchRedirect(f) || changed
+		}
 		if changed {
 			f.invalidateCFG()
 		}
diff --git a/src/cmd/compile/internal/ssa/fuse_branchredirect.go b/src/cmd/compile/internal/ssa/fuse_branchredirect.go
new file mode 100644
index 0000000000..1b8b307bca
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/fuse_branchredirect.go
@@ -0,0 +1,110 @@
+// Copyright 2021 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 ssa
+
+// fuseBranchRedirect checks for a CFG in which the outbound branch
+// of an If block can be derived from its predecessor If block, in
+// some such cases, we can redirect the predecessor If block to the
+// corresponding successor block directly. For example:
+// p:
+//   v11 = Less64 <bool> v10 v8
+//   If v11 goto b else u
+// b: <- p ...
+//   v17 = Leq64 <bool> v10 v8
+//   If v17 goto s else o
+// We can redirect p to s directly.
+//
+// The implementation here borrows the framework of the prove pass.
+// 1, Traverse all blocks of function f to find If blocks.
+// 2,   For any If block b, traverse all its predecessors to find If blocks.
+// 3,     For any If block predecessor p, update relationship p->b.
+// 4,     Traverse all successors of b.
+// 5,       For any successor s of b, try to update relationship b->s, if a
+//          contradiction is found then redirect p to another successor of b.
+func fuseBranchRedirect(f *Func) bool {
+	ft := newFactsTable(f)
+	ft.checkpoint()
+
+	changed := false
+	for i := len(f.Blocks) - 1; i >= 0; i-- {
+		b := f.Blocks[i]
+		if b.Kind != BlockIf {
+			continue
+		}
+		// b is either empty or only contains the control value.
+		// TODO: if b contains only OpCopy or OpNot related to b.Controls,
+		// such as Copy(Not(Copy(Less64(v1, v2)))), perhaps it can be optimized.
+		bCtl := b.Controls[0]
+		if bCtl.Block != b && len(b.Values) != 0 || (len(b.Values) != 1 || bCtl.Uses != 1) && bCtl.Block == b {
+			continue
+		}
+
+		for k := 0; k < len(b.Preds); k++ {
+			pk := b.Preds[k]
+			p := pk.b
+			if p.Kind != BlockIf || p == b {
+				continue
+			}
+			pbranch := positive
+			if pk.i == 1 {
+				pbranch = negative
+			}
+			ft.checkpoint()
+			// Assume branch p->b is taken.
+			addBranchRestrictions(ft, p, pbranch)
+			// Check if any outgoing branch is unreachable based on the above condition.
+			parent := b
+			for j, bbranch := range [...]branch{positive, negative} {
+				ft.checkpoint()
+				// Try to update relationship b->child, and check if the contradiction occurs.
+				addBranchRestrictions(ft, parent, bbranch)
+				unsat := ft.unsat
+				ft.restore()
+				if !unsat {
+					continue
+				}
+				// This branch is impossible,so redirect p directly to another branch.
+				out := 1 ^ j
+				child := parent.Succs[out].b
+				if child == b {
+					continue
+				}
+				b.removePred(k)
+				p.Succs[pk.i] = Edge{child, len(child.Preds)}
+				// Fix up Phi value in b to have one less argument.
+				for _, v := range b.Values {
+					if v.Op != OpPhi {
+						continue
+					}
+					v.RemoveArg(k)
+					phielimValue(v)
+				}
+				// Fix up child to have one more predecessor.
+				child.Preds = append(child.Preds, Edge{p, pk.i})
+				ai := b.Succs[out].i
+				for _, v := range child.Values {
+					if v.Op != OpPhi {
+						continue
+					}
+					v.AddArg(v.Args[ai])
+				}
+				if b.Func.pass.debug > 0 {
+					b.Func.Warnl(b.Controls[0].Pos, "Redirect %s based on %s", b.Controls[0].Op, p.Controls[0].Op)
+				}
+				changed = true
+				k--
+				break
+			}
+			ft.restore()
+		}
+		if len(b.Preds) == 0 && b != f.Entry {
+			// Block is now dead.
+			b.Kind = BlockInvalid
+		}
+	}
+	ft.restore()
+	ft.cleanup(f)
+	return changed
+}
diff --git a/src/cmd/compile/internal/ssa/prove.go b/src/cmd/compile/internal/ssa/prove.go
index bcfdfc13f0..b203584c6b 100644
--- a/src/cmd/compile/internal/ssa/prove.go
+++ b/src/cmd/compile/internal/ssa/prove.go
@@ -726,6 +726,20 @@ var (
 	}
 )
 
+// cleanup returns the posets to the free list
+func (ft *factsTable) cleanup(f *Func) {
+	for _, po := range []*poset{ft.orderS, ft.orderU} {
+		// Make sure it's empty as it should be. A non-empty poset
+		// might cause errors and miscompilations if reused.
+		if checkEnabled {
+			if err := po.CheckEmpty(); err != nil {
+				f.Fatalf("poset not empty after function %s: %v", f.Name, err)
+			}
+		}
+		f.retPoset(po)
+	}
+}
+
 // prove removes redundant BlockIf branches that can be inferred
 // from previous dominating comparisons.
 //
@@ -917,17 +931,7 @@ func prove(f *Func) {
 
 	ft.restore()
 
-	// Return the posets to the free list
-	for _, po := range []*poset{ft.orderS, ft.orderU} {
-		// Make sure it's empty as it should be. A non-empty poset
-		// might cause errors and miscompilations if reused.
-		if checkEnabled {
-			if err := po.CheckEmpty(); err != nil {
-				f.Fatalf("prove poset not empty after function %s: %v", f.Name, err)
-			}
-		}
-		f.retPoset(po)
-	}
+	ft.cleanup(f)
 }
 
 // getBranch returns the range restrictions added by p
diff --git a/test/fuse.go b/test/fuse.go
new file mode 100644
index 0000000000..7d39c3cdb9
--- /dev/null
+++ b/test/fuse.go
@@ -0,0 +1,190 @@
+// +build amd64 arm64
+// errorcheck -0 -d=ssa/late_fuse/debug=1
+
+// Copyright 2021 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 "strings"
+
+const Cf2 = 2.0
+
+func fEqEq(a int, f float64) bool {
+	return a == 0 && f > Cf2 || a == 0 && f < -Cf2 // ERROR "Redirect Eq64 based on Eq64$"
+}
+
+func fEqNeq(a int32, f float64) bool {
+	return a == 0 && f > Cf2 || a != 0 && f < -Cf2 // ERROR "Redirect Neq32 based on Eq32$"
+}
+
+func fEqLess(a int8, f float64) bool {
+	return a == 0 && f > Cf2 || a < 0 && f < -Cf2
+}
+
+func fEqLeq(a float64, f float64) bool {
+	return a == 0 && f > Cf2 || a <= 0 && f < -Cf2
+}
+
+func fEqLessU(a uint, f float64) bool {
+	return a == 0 && f > Cf2 || a < 0 && f < -Cf2
+}
+
+func fEqLeqU(a uint64, f float64) bool {
+	return a == 0 && f > Cf2 || a <= 0 && f < -Cf2 // ERROR "Redirect Leq64U based on Eq64$"
+}
+
+func fNeqEq(a int, f float64) bool {
+	return a != 0 && f > Cf2 || a == 0 && f < -Cf2 // ERROR "Redirect Eq64 based on Neq64$"
+}
+
+func fNeqNeq(a int32, f float64) bool {
+	return a != 0 && f > Cf2 || a != 0 && f < -Cf2 // ERROR "Redirect Neq32 based on Neq32$"
+}
+
+func fNeqLess(a float32, f float64) bool {
+	// TODO: Add support for floating point numbers in prove
+	return a != 0 && f > Cf2 || a < 0 && f < -Cf2
+}
+
+func fNeqLeq(a int16, f float64) bool {
+	return a != 0 && f > Cf2 || a <= 0 && f < -Cf2 // ERROR "Redirect Leq16 based on Neq16$"
+}
+
+func fNeqLessU(a uint, f float64) bool {
+	return a != 0 && f > Cf2 || a < 0 && f < -Cf2
+}
+
+func fNeqLeqU(a uint32, f float64) bool {
+	return a != 0 && f > Cf2 || a <= 0 && f < -Cf2 // ERROR "Redirect Leq32U based on Neq32$"
+}
+
+func fLessEq(a int, f float64) bool {
+	return a < 0 && f > Cf2 || a == 0 && f < -Cf2
+}
+
+func fLessNeq(a int32, f float64) bool {
+	return a < 0 && f > Cf2 || a != 0 && f < -Cf2
+}
+
+func fLessLess(a float32, f float64) bool {
+	return a < 0 && f > Cf2 || a < 0 && f < -Cf2 // ERROR "Redirect Less32F based on Less32F$"
+}
+
+func fLessLeq(a float64, f float64) bool {
+	return a < 0 && f > Cf2 || a <= 0 && f < -Cf2
+}
+
+func fLeqEq(a float64, f float64) bool {
+	return a <= 0 && f > Cf2 || a == 0 && f < -Cf2
+}
+
+func fLeqNeq(a int16, f float64) bool {
+	return a <= 0 && f > Cf2 || a != 0 && f < -Cf2 // ERROR "Redirect Neq16 based on Leq16$"
+}
+
+func fLeqLess(a float32, f float64) bool {
+	return a <= 0 && f > Cf2 || a < 0 && f < -Cf2
+}
+
+func fLeqLeq(a int8, f float64) bool {
+	return a <= 0 && f > Cf2 || a <= 0 && f < -Cf2 // ERROR "Redirect Leq8 based on Leq8$"
+}
+
+func fLessUEq(a uint8, f float64) bool {
+	return a < 0 && f > Cf2 || a == 0 && f < -Cf2
+}
+
+func fLessUNeq(a uint16, f float64) bool {
+	return a < 0 && f > Cf2 || a != 0 && f < -Cf2
+}
+
+func fLessULessU(a uint32, f float64) bool {
+	return a < 0 && f > Cf2 || a < 0 && f < -Cf2
+}
+
+func fLessULeqU(a uint64, f float64) bool {
+	return a < 0 && f > Cf2 || a <= 0 && f < -Cf2
+}
+
+func fLeqUEq(a uint8, f float64) bool {
+	return a <= 0 && f > Cf2 || a == 0 && f < -Cf2 // ERROR "Redirect Eq8 based on Leq8U$"
+}
+
+func fLeqUNeq(a uint16, f float64) bool {
+	return a <= 0 && f > Cf2 || a != 0 && f < -Cf2 // ERROR "Redirect Neq16 based on Leq16U$"
+}
+
+func fLeqLessU(a uint32, f float64) bool {
+	return a <= 0 && f > Cf2 || a < 0 && f < -Cf2
+}
+
+func fLeqLeqU(a uint64, f float64) bool {
+	return a <= 0 && f > Cf2 || a <= 0 && f < -Cf2 // ERROR "Redirect Leq64U based on Leq64U$"
+}
+
+// Arg tests are disabled because the op name is different on amd64 and arm64.
+
+func fEqPtrEqPtr(a, b *int, f float64) bool {
+	return a == b && f > Cf2 || a == b && f < -Cf2 // ERROR "Redirect EqPtr based on EqPtr$"
+}
+
+func fEqPtrNeqPtr(a, b *int, f float64) bool {
+	return a == b && f > Cf2 || a != b && f < -Cf2 // ERROR "Redirect NeqPtr based on EqPtr$"
+}
+
+func fNeqPtrEqPtr(a, b *int, f float64) bool {
+	return a != b && f > Cf2 || a == b && f < -Cf2 // ERROR "Redirect EqPtr based on NeqPtr$"
+}
+
+func fNeqPtrNeqPtr(a, b *int, f float64) bool {
+	return a != b && f > Cf2 || a != b && f < -Cf2 // ERROR "Redirect NeqPtr based on NeqPtr$"
+}
+
+func fEqInterEqInter(a interface{}, f float64) bool {
+	return a == nil && f > Cf2 || a == nil && f < -Cf2 // ERROR "Redirect IsNonNil based on IsNonNil$"
+}
+
+func fEqInterNeqInter(a interface{}, f float64) bool {
+	return a == nil && f > Cf2 || a != nil && f < -Cf2
+}
+
+func fNeqInterEqInter(a interface{}, f float64) bool {
+	return a != nil && f > Cf2 || a == nil && f < -Cf2
+}
+
+func fNeqInterNeqInter(a interface{}, f float64) bool {
+	return a != nil && f > Cf2 || a != nil && f < -Cf2 // ERROR "Redirect IsNonNil based on IsNonNil$"
+}
+
+func fEqSliceEqSlice(a []int, f float64) bool {
+	return a == nil && f > Cf2 || a == nil && f < -Cf2 // ERROR "Redirect IsNonNil based on IsNonNil$"
+}
+
+func fEqSliceNeqSlice(a []int, f float64) bool {
+	return a == nil && f > Cf2 || a != nil && f < -Cf2
+}
+
+func fNeqSliceEqSlice(a []int, f float64) bool {
+	return a != nil && f > Cf2 || a == nil && f < -Cf2
+}
+
+func fNeqSliceNeqSlice(a []int, f float64) bool {
+	return a != nil && f > Cf2 || a != nil && f < -Cf2 // ERROR "Redirect IsNonNil based on IsNonNil$"
+}
+
+func fPhi(a, b string) string {
+	aslash := strings.HasSuffix(a, "/") // ERROR "Redirect Phi based on Phi$"
+	bslash := strings.HasPrefix(b, "/")
+	switch {
+	case aslash && bslash:
+		return a + b[1:]
+	case !aslash && !bslash:
+		return a + "/" + b
+	}
+	return a + b
+}
+
+func main() {
+}
-- 
GitLab


From f68878f0fc542708bbe1dc4f131d32b21fac0d3c Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Tue, 8 Dec 2020 04:30:22 +1100
Subject: [PATCH 1810/2400] cmd/dist,runtime: support cgo on openbsd/mips64

Add support for cgo on openbsd/mips64.

Fixes #43005

Change-Id: I2386204f53fa984a01a9d89f0b6c96455768f326
Reviewed-on: https://go-review.googlesource.com/c/go/+/275896
Trust: Joel Sing <joel@sing.id.au>
Run-TryBot: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/dist/build.go                |  2 +-
 src/cmd/link/internal/mips64/asm.go  | 15 ++++++-
 src/cmd/nm/nm_cgo_test.go            |  2 +-
 src/runtime/cgo/gcc_openbsd_mips64.c | 67 ++++++++++++++++++++++++++++
 4 files changed, 83 insertions(+), 3 deletions(-)
 create mode 100644 src/runtime/cgo/gcc_openbsd_mips64.c

diff --git a/src/cmd/dist/build.go b/src/cmd/dist/build.go
index c81fe6a586..00e23ef179 100644
--- a/src/cmd/dist/build.go
+++ b/src/cmd/dist/build.go
@@ -1590,7 +1590,7 @@ var cgoEnabled = map[string]bool{
 	"openbsd/amd64":   true,
 	"openbsd/arm":     true,
 	"openbsd/arm64":   true,
-	"openbsd/mips64":  false,
+	"openbsd/mips64":  true,
 	"plan9/386":       false,
 	"plan9/amd64":     false,
 	"plan9/arm":       false,
diff --git a/src/cmd/link/internal/mips64/asm.go b/src/cmd/link/internal/mips64/asm.go
index 55b4ba2fc8..f7f91d1e8b 100644
--- a/src/cmd/link/internal/mips64/asm.go
+++ b/src/cmd/link/internal/mips64/asm.go
@@ -52,6 +52,8 @@ func elfreloc1(ctxt *ld.Link, out *ld.OutBuf, ldr *loader.Loader, s loader.Sym,
 	//		type	uint8
 	//		addend	int64
 
+	addend := r.Xadd
+
 	out.Write64(uint64(sectoff))
 
 	elfsym := ld.ElfSymForReloc(ctxt, r.Xsym)
@@ -77,11 +79,17 @@ func elfreloc1(ctxt *ld.Link, out *ld.OutBuf, ldr *loader.Loader, s loader.Sym,
 		out.Write8(uint8(elf.R_MIPS_HI16))
 	case objabi.R_ADDRMIPSTLS:
 		out.Write8(uint8(elf.R_MIPS_TLS_TPREL_LO16))
+		if ctxt.Target.IsOpenbsd() {
+			// OpenBSD mips64 does not currently offset TLS by 0x7000,
+			// as such we need to add this back to get the correct offset
+			// via the external linker.
+			addend += 0x7000
+		}
 	case objabi.R_CALLMIPS,
 		objabi.R_JMPMIPS:
 		out.Write8(uint8(elf.R_MIPS_26))
 	}
-	out.Write64(uint64(r.Xadd))
+	out.Write64(uint64(addend))
 
 	return true
 }
@@ -124,6 +132,11 @@ func archreloc(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, r loade
 	case objabi.R_ADDRMIPSTLS:
 		// thread pointer is at 0x7000 offset from the start of TLS data area
 		t := ldr.SymValue(rs) + r.Add() - 0x7000
+		if target.IsOpenbsd() {
+			// OpenBSD mips64 does not currently offset TLS by 0x7000,
+			// as such we need to add this back to get the correct offset.
+			t += 0x7000
+		}
 		if t < -32768 || t >= 32678 {
 			ldr.Errorf(s, "TLS offset out of range %d", t)
 		}
diff --git a/src/cmd/nm/nm_cgo_test.go b/src/cmd/nm/nm_cgo_test.go
index d0937904a2..1544be041a 100644
--- a/src/cmd/nm/nm_cgo_test.go
+++ b/src/cmd/nm/nm_cgo_test.go
@@ -30,7 +30,7 @@ func canInternalLink() bool {
 		}
 	case "openbsd":
 		switch runtime.GOARCH {
-		case "arm64":
+		case "arm64", "mips64":
 			return false
 		}
 	case "windows":
diff --git a/src/runtime/cgo/gcc_openbsd_mips64.c b/src/runtime/cgo/gcc_openbsd_mips64.c
new file mode 100644
index 0000000000..79f039a373
--- /dev/null
+++ b/src/runtime/cgo/gcc_openbsd_mips64.c
@@ -0,0 +1,67 @@
+// Copyright 2020 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.
+
+#include <sys/types.h>
+#include <pthread.h>
+#include <signal.h>
+#include <string.h>
+#include "libcgo.h"
+#include "libcgo_unix.h"
+
+static void* threadentry(void*);
+static void (*setg_gcc)(void*);
+
+void
+x_cgo_init(G *g, void (*setg)(void*))
+{
+	pthread_attr_t attr;
+	size_t size;
+
+	setg_gcc = setg;
+	pthread_attr_init(&attr);
+	pthread_attr_getstacksize(&attr, &size);
+	g->stacklo = (uintptr)&attr - size + 4096;
+	pthread_attr_destroy(&attr);
+}
+
+void
+_cgo_sys_thread_start(ThreadStart *ts)
+{
+	pthread_attr_t attr;
+	sigset_t ign, oset;
+	pthread_t p;
+	size_t size;
+	int err;
+
+	sigfillset(&ign);
+	pthread_sigmask(SIG_SETMASK, &ign, &oset);
+
+	pthread_attr_init(&attr);
+	pthread_attr_getstacksize(&attr, &size);
+
+	// Leave stacklo=0 and set stackhi=size; mstart will do the rest.
+	ts->g->stackhi = size;
+	err = _cgo_try_pthread_create(&p, &attr, threadentry, ts);
+
+	pthread_sigmask(SIG_SETMASK, &oset, nil);
+
+	if (err != 0) {
+		fprintf(stderr, "runtime/cgo: pthread_create failed: %s\n", strerror(err));
+		abort();
+	}
+}
+
+extern void crosscall1(void (*fn)(void), void (*setg_gcc)(void*), void *g);
+
+static void*
+threadentry(void *v)
+{
+	ThreadStart ts;
+
+	ts = *(ThreadStart*)v;
+	free(v);
+
+	crosscall1(ts.fn, setg_gcc, (void*)ts.g);
+	return nil;
+}
-- 
GitLab


From 4fe324dd0f3497f6bf4f46ba39921d7855dbc29b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Daniel=20Mart=C3=AD?= <mvdan@mvdan.cc>
Date: Mon, 26 Apr 2021 23:06:53 +0100
Subject: [PATCH 1811/2400] cmd/go: make TOOLEXEC_IMPORTPATH consistent with
 'go list -f {{.ImportPath}}'
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

TOOLEXEC_IMPORTPATH is useful for the toolexec program to know what
package is currently being built. This is otherwise tricky to figure out.

Unfortunately, for test packages it was lacking. In the added test case,
we have a total of four packages in 'go list -test':

	test/main
	test/main.test
	test/main [test/main.test]
	test/main_test [test/main.test]

And, when running with -toolexec, one would get the following values:

        # test/main_test [test/main.test]
        compile TOOLEXEC_IMPORTPATH="test/main_test"
        # test/main [test/main.test]
        compile TOOLEXEC_IMPORTPATH="test/main"
        # test/main.test
        compile TOOLEXEC_IMPORTPATH="test/main.test"

Note how the " [test/main.test]" suffixes are missing. Because of that,
when one sees TOOLEXEC_IMPORTPATH="test/main", it is ambiguous whether
the regular "test/main" package is meant, or its test variant, otherwise
known as "test/main [test/main.test]" and including foo_test.go

To fix this, we need unambiguous strings to identify the packages
involved, just like one can do with "go list -test". "go list" already
has such a field, ImportPath, which is also used when printing output
from each build "action" as seen above.

That string is not really an import path - internally, it's
load.Package.Desc, and called a "description". However, it makes sense
to be consistent with "go list -json", because it's the source of truth
for practically all tools interacting with the Go toolchain.

To keep cmd/go more consistent, "go list -f {{.ImportPath}}" now calls
Package.Desc as well, instead of having its own copy of the string
concatenation for ForTest.

Fixes #44963.

Change-Id: Ibce7fbb5549209dac50526043c0c7daa0beebc08
Reviewed-on: https://go-review.googlesource.com/c/go/+/313770
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Daniel Martí <mvdan@mvdan.cc>
---
 src/cmd/go/alldocs.go                   |  2 +
 src/cmd/go/internal/list/list.go        |  2 +-
 src/cmd/go/internal/work/build.go       |  2 +
 src/cmd/go/internal/work/exec.go        |  5 ++-
 src/cmd/go/testdata/script/toolexec.txt | 51 +++++++++++++++++++++----
 5 files changed, 53 insertions(+), 9 deletions(-)

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index 9d4626769d..103eecf79c 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -198,6 +198,8 @@
 // 		a program to use to invoke toolchain programs like vet and asm.
 // 		For example, instead of running asm, the go command will run
 // 		'cmd args /path/to/asm <arguments for asm>'.
+// 		The TOOLEXEC_IMPORTPATH environment variable will be set,
+// 		matching 'go list -f {{.ImportPath}}' for the package being built.
 //
 // The -asmflags, -gccgoflags, -gcflags, and -ldflags flags accept a
 // space-separated list of arguments to pass to an underlying tool
diff --git a/src/cmd/go/internal/list/list.go b/src/cmd/go/internal/list/list.go
index 53bf75e27e..53aaf311ec 100644
--- a/src/cmd/go/internal/list/list.go
+++ b/src/cmd/go/internal/list/list.go
@@ -628,7 +628,7 @@ func runList(ctx context.Context, cmd *base.Command, args []string) {
 		old := make(map[string]string)
 		for _, p := range all {
 			if p.ForTest != "" {
-				new := p.ImportPath + " [" + p.ForTest + ".test]"
+				new := p.Desc()
 				old[new] = p.ImportPath
 				p.ImportPath = new
 			}
diff --git a/src/cmd/go/internal/work/build.go b/src/cmd/go/internal/work/build.go
index a75ace7d4e..1babbda889 100644
--- a/src/cmd/go/internal/work/build.go
+++ b/src/cmd/go/internal/work/build.go
@@ -152,6 +152,8 @@ and test commands:
 		a program to use to invoke toolchain programs like vet and asm.
 		For example, instead of running asm, the go command will run
 		'cmd args /path/to/asm <arguments for asm>'.
+		The TOOLEXEC_IMPORTPATH environment variable will be set,
+		matching 'go list -f {{.ImportPath}}' for the package being built.
 
 The -asmflags, -gccgoflags, -gcflags, and -ldflags flags accept a
 space-separated list of arguments to pass to an underlying tool
diff --git a/src/cmd/go/internal/work/exec.go b/src/cmd/go/internal/work/exec.go
index 38e826607e..d04ba06901 100644
--- a/src/cmd/go/internal/work/exec.go
+++ b/src/cmd/go/internal/work/exec.go
@@ -2071,8 +2071,11 @@ func (b *Builder) runOut(a *Action, dir string, env []string, cmdargs ...interfa
 
 	// Add the TOOLEXEC_IMPORTPATH environment variable for -toolexec tools.
 	// It doesn't really matter if -toolexec isn't being used.
+	// Note that a.Package.Desc is not really an import path,
+	// but this is consistent with 'go list -f {{.ImportPath}}'.
+	// Plus, it is useful to uniquely identify packages in 'go list -json'.
 	if a != nil && a.Package != nil {
-		cmd.Env = append(cmd.Env, "TOOLEXEC_IMPORTPATH="+a.Package.ImportPath)
+		cmd.Env = append(cmd.Env, "TOOLEXEC_IMPORTPATH="+a.Package.Desc())
 	}
 
 	cmd.Env = append(cmd.Env, env...)
diff --git a/src/cmd/go/testdata/script/toolexec.txt b/src/cmd/go/testdata/script/toolexec.txt
index 526234196b..4f26da6d26 100644
--- a/src/cmd/go/testdata/script/toolexec.txt
+++ b/src/cmd/go/testdata/script/toolexec.txt
@@ -11,12 +11,37 @@ go build ./cmd/mytool
 # Finally, note that asm and cgo are run twice.
 
 go build -toolexec=$PWD/mytool
-[amd64] stderr -count=2 '^asm'${GOEXE}' TOOLEXEC_IMPORTPATH=test/main/withasm$'
-stderr -count=1 '^compile'${GOEXE}' TOOLEXEC_IMPORTPATH=test/main/withasm$'
-[cgo] stderr -count=2 '^cgo'${GOEXE}' TOOLEXEC_IMPORTPATH=test/main/withcgo$'
-[cgo] stderr -count=1 '^compile'${GOEXE}' TOOLEXEC_IMPORTPATH=test/main/withcgo$'
-stderr -count=1 '^compile'${GOEXE}' TOOLEXEC_IMPORTPATH=test/main$'
-stderr -count=1 '^link'${GOEXE}' TOOLEXEC_IMPORTPATH=test/main$'
+[amd64] stderr -count=2 '^asm'${GOEXE}' TOOLEXEC_IMPORTPATH="test/main/withasm"$'
+stderr -count=1 '^compile'${GOEXE}' TOOLEXEC_IMPORTPATH="test/main/withasm"$'
+[cgo] stderr -count=2 '^cgo'${GOEXE}' TOOLEXEC_IMPORTPATH="test/main/withcgo"$'
+[cgo] stderr -count=1 '^compile'${GOEXE}' TOOLEXEC_IMPORTPATH="test/main/withcgo"$'
+stderr -count=1 '^compile'${GOEXE}' TOOLEXEC_IMPORTPATH="test/main"$'
+stderr -count=1 '^link'${GOEXE}' TOOLEXEC_IMPORTPATH="test/main"$'
+
+# Test packages are a little bit trickier.
+# We have four variants of test/main, as reported by 'go list -test':
+#
+#    test/main                        - the regular non-test package
+#    test/main.test                   - the generated test program
+#    test/main [test/main.test]       - the test package for foo_test.go
+#    test/main_test [test/main.test]  - the test package for foo_separate_test.go
+#
+# As such, TOOLEXEC_IMPORTPATH must see the same strings, to be able to uniquely
+# identify each package being built as reported by 'go list -f {{.ImportPath}}'.
+# Note that these are not really "import paths" anymore, but that naming is
+# consistent with 'go list -json' at least.
+
+go test -toolexec=$PWD/mytool
+
+stderr -count=2 '^# test/main\.test$'
+stderr -count=1 '^compile'${GOEXE}' TOOLEXEC_IMPORTPATH="test/main\.test"$'
+stderr -count=1 '^link'${GOEXE}' TOOLEXEC_IMPORTPATH="test/main\.test"$'
+
+stderr -count=1 '^# test/main \[test/main\.test\]$'
+stderr -count=1 '^compile'${GOEXE}' TOOLEXEC_IMPORTPATH="test/main \[test/main\.test\]"$'
+
+stderr -count=1 '^# test/main_test \[test/main\.test\]$'
+stderr -count=1 '^compile'${GOEXE}' TOOLEXEC_IMPORTPATH="test/main_test \[test/main\.test\]"$'
 
 -- go.mod --
 module test/main
@@ -32,6 +57,18 @@ import (
 )
 
 func main() {}
+-- foo_test.go --
+package main
+
+import "testing"
+
+func TestFoo(t *testing.T) {}
+-- foo_separate_test.go --
+package main_test
+
+import "testing"
+
+func TestSeparateFoo(t *testing.T) {}
 -- withcgo/withcgo.go --
 package withcgo
 
@@ -71,7 +108,7 @@ func main() {
 		// We can't alter the version output.
 	} else {
 		// Print which tool we're running, and on what package.
-		fmt.Fprintf(os.Stdout, "%s TOOLEXEC_IMPORTPATH=%s\n", toolName, os.Getenv("TOOLEXEC_IMPORTPATH"))
+		fmt.Fprintf(os.Stdout, "%s TOOLEXEC_IMPORTPATH=%q\n", toolName, os.Getenv("TOOLEXEC_IMPORTPATH"))
 	}
 
 	// Simply run the tool.
-- 
GitLab


From 4a7effa418b4644abc5142e35228e26c6a52a50a Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 27 Apr 2021 17:19:42 -0400
Subject: [PATCH 1812/2400] cmd/compile: mark R12 clobbered for special calls

In external linking mode the external linker may insert
trampolines, which use R12 as a scratch register. So a call could
potentially clobber R12 if the target is laid out too far. Mark
R12 clobbered.

Also, we will use R12 for trampolines in the Go linker as well.

CL 310731 updated the generated rewrite files so imports are
grouped, but the generator was not updated to do so. Grouped
imports are nice. But as those are generated files, for
simplicity and my laziness, just regenerate with the current
generator (which makes imports not grouped).

Change-Id: Iddb741ff7314a291ade5fbffc7d315f555808409
Reviewed-on: https://go-review.googlesource.com/c/go/+/314453
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/ssa/gen/ARMOps.go     | 11 ++++++-----
 src/cmd/compile/internal/ssa/opGen.go          |  8 ++++----
 src/cmd/compile/internal/ssa/rewrite386.go     |  6 ++----
 src/cmd/compile/internal/ssa/rewriteAMD64.go   | 10 ++++------
 src/cmd/compile/internal/ssa/rewriteARM.go     |  6 ++----
 src/cmd/compile/internal/ssa/rewritePPC64.go   |  8 +++-----
 src/cmd/compile/internal/ssa/rewriteRISCV64.go |  6 ++----
 src/cmd/compile/internal/ssa/rewriteS390X.go   |  8 +++-----
 src/cmd/compile/internal/ssa/rewriteWasm.go    |  8 +++-----
 src/cmd/compile/internal/ssa/rewritegeneric.go |  6 ++----
 10 files changed, 31 insertions(+), 46 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/gen/ARMOps.go b/src/cmd/compile/internal/ssa/gen/ARMOps.go
index 253ff573ec..d1f86039a3 100644
--- a/src/cmd/compile/internal/ssa/gen/ARMOps.go
+++ b/src/cmd/compile/internal/ssa/gen/ARMOps.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ignore
 // +build ignore
 
 package main
@@ -156,7 +157,7 @@ func init() {
 			reg: regInfo{
 				inputs:   []regMask{buildReg("R1"), buildReg("R0")},
 				outputs:  []regMask{buildReg("R0"), buildReg("R1")},
-				clobbers: buildReg("R2 R3 R14"),
+				clobbers: buildReg("R2 R3 R12 R14"), // R14 is LR, R12 is linker trampoline scratch register
 			},
 			clobberFlags: true,
 			typ:          "(UInt32,UInt32)",
@@ -459,7 +460,7 @@ func init() {
 			argLength: 3,
 			reg: regInfo{
 				inputs:   []regMask{buildReg("R1"), buildReg("R0")},
-				clobbers: buildReg("R1 R14"),
+				clobbers: buildReg("R1 R12 R14"), // R14 is LR, R12 is linker trampoline scratch register
 			},
 			faultOnNilArg0: true,
 		},
@@ -476,7 +477,7 @@ func init() {
 			argLength: 3,
 			reg: regInfo{
 				inputs:   []regMask{buildReg("R2"), buildReg("R1")},
-				clobbers: buildReg("R0 R1 R2 R14"),
+				clobbers: buildReg("R0 R1 R2 R12 R14"), // R14 is LR, R12 is linker trampoline scratch register
 			},
 			faultOnNilArg0: true,
 			faultOnNilArg1: true,
@@ -564,8 +565,8 @@ func init() {
 
 		// LoweredWB invokes runtime.gcWriteBarrier. arg0=destptr, arg1=srcptr, arg2=mem, aux=runtime.gcWriteBarrier
 		// It saves all GP registers if necessary,
-		// but clobbers R14 (LR) because it's a call.
-		{name: "LoweredWB", argLength: 3, reg: regInfo{inputs: []regMask{buildReg("R2"), buildReg("R3")}, clobbers: (callerSave &^ gpg) | buildReg("R14")}, clobberFlags: true, aux: "Sym", symEffect: "None"},
+		// but clobbers R14 (LR) because it's a call, and R12 which is linker trampoline scratch register.
+		{name: "LoweredWB", argLength: 3, reg: regInfo{inputs: []regMask{buildReg("R2"), buildReg("R3")}, clobbers: (callerSave &^ gpg) | buildReg("R12 R14")}, clobberFlags: true, aux: "Sym", symEffect: "None"},
 	}
 
 	blocks := []blockData{
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index 2f56625397..51cb0881b8 100644
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -13879,7 +13879,7 @@ var opcodeTable = [...]opInfo{
 				{0, 2}, // R1
 				{1, 1}, // R0
 			},
-			clobbers: 16396, // R2 R3 R14
+			clobbers: 20492, // R2 R3 R12 R14
 			outputs: []outputInfo{
 				{0, 1}, // R0
 				{1, 2}, // R1
@@ -17228,7 +17228,7 @@ var opcodeTable = [...]opInfo{
 				{0, 2}, // R1
 				{1, 1}, // R0
 			},
-			clobbers: 16386, // R1 R14
+			clobbers: 20482, // R1 R12 R14
 		},
 	},
 	{
@@ -17242,7 +17242,7 @@ var opcodeTable = [...]opInfo{
 				{0, 4}, // R2
 				{1, 2}, // R1
 			},
-			clobbers: 16391, // R0 R1 R2 R14
+			clobbers: 20487, // R0 R1 R2 R12 R14
 		},
 	},
 	{
@@ -17403,7 +17403,7 @@ var opcodeTable = [...]opInfo{
 				{0, 4}, // R2
 				{1, 8}, // R3
 			},
-			clobbers: 4294918144, // R14 F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
+			clobbers: 4294922240, // R12 R14 F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
 		},
 	},
 
diff --git a/src/cmd/compile/internal/ssa/rewrite386.go b/src/cmd/compile/internal/ssa/rewrite386.go
index 93b258afac..1ec2d26f75 100644
--- a/src/cmd/compile/internal/ssa/rewrite386.go
+++ b/src/cmd/compile/internal/ssa/rewrite386.go
@@ -3,10 +3,8 @@
 
 package ssa
 
-import (
-	"cmd/compile/internal/types"
-	"math"
-)
+import "math"
+import "cmd/compile/internal/types"
 
 func rewriteValue386(v *Value) bool {
 	switch v.Op {
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index dd92b41c20..0b98b9ddf6 100644
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -3,12 +3,10 @@
 
 package ssa
 
-import (
-	"cmd/compile/internal/types"
-	"cmd/internal/obj"
-	"internal/buildcfg"
-	"math"
-)
+import "internal/buildcfg"
+import "math"
+import "cmd/internal/obj"
+import "cmd/compile/internal/types"
 
 func rewriteValueAMD64(v *Value) bool {
 	switch v.Op {
diff --git a/src/cmd/compile/internal/ssa/rewriteARM.go b/src/cmd/compile/internal/ssa/rewriteARM.go
index 25db5b9fba..febb5566e3 100644
--- a/src/cmd/compile/internal/ssa/rewriteARM.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM.go
@@ -3,10 +3,8 @@
 
 package ssa
 
-import (
-	"cmd/compile/internal/types"
-	"internal/buildcfg"
-)
+import "internal/buildcfg"
+import "cmd/compile/internal/types"
 
 func rewriteValueARM(v *Value) bool {
 	switch v.Op {
diff --git a/src/cmd/compile/internal/ssa/rewritePPC64.go b/src/cmd/compile/internal/ssa/rewritePPC64.go
index fe7620c218..96dee0bd21 100644
--- a/src/cmd/compile/internal/ssa/rewritePPC64.go
+++ b/src/cmd/compile/internal/ssa/rewritePPC64.go
@@ -3,11 +3,9 @@
 
 package ssa
 
-import (
-	"cmd/compile/internal/types"
-	"internal/buildcfg"
-	"math"
-)
+import "internal/buildcfg"
+import "math"
+import "cmd/compile/internal/types"
 
 func rewriteValuePPC64(v *Value) bool {
 	switch v.Op {
diff --git a/src/cmd/compile/internal/ssa/rewriteRISCV64.go b/src/cmd/compile/internal/ssa/rewriteRISCV64.go
index bc4b18e0cd..431fb1aaf6 100644
--- a/src/cmd/compile/internal/ssa/rewriteRISCV64.go
+++ b/src/cmd/compile/internal/ssa/rewriteRISCV64.go
@@ -3,10 +3,8 @@
 
 package ssa
 
-import (
-	"cmd/compile/internal/types"
-	"math"
-)
+import "math"
+import "cmd/compile/internal/types"
 
 func rewriteValueRISCV64(v *Value) bool {
 	switch v.Op {
diff --git a/src/cmd/compile/internal/ssa/rewriteS390X.go b/src/cmd/compile/internal/ssa/rewriteS390X.go
index 49c5898704..8b41d62c31 100644
--- a/src/cmd/compile/internal/ssa/rewriteS390X.go
+++ b/src/cmd/compile/internal/ssa/rewriteS390X.go
@@ -3,11 +3,9 @@
 
 package ssa
 
-import (
-	"cmd/compile/internal/types"
-	"cmd/internal/obj/s390x"
-	"math"
-)
+import "math"
+import "cmd/compile/internal/types"
+import "cmd/internal/obj/s390x"
 
 func rewriteValueS390X(v *Value) bool {
 	switch v.Op {
diff --git a/src/cmd/compile/internal/ssa/rewriteWasm.go b/src/cmd/compile/internal/ssa/rewriteWasm.go
index ed23ae032a..5dab09f85b 100644
--- a/src/cmd/compile/internal/ssa/rewriteWasm.go
+++ b/src/cmd/compile/internal/ssa/rewriteWasm.go
@@ -3,11 +3,9 @@
 
 package ssa
 
-import (
-	"cmd/compile/internal/types"
-	"internal/buildcfg"
-	"math"
-)
+import "internal/buildcfg"
+import "math"
+import "cmd/compile/internal/types"
 
 func rewriteValueWasm(v *Value) bool {
 	switch v.Op {
diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go
index 0e5f49491e..52258201ca 100644
--- a/src/cmd/compile/internal/ssa/rewritegeneric.go
+++ b/src/cmd/compile/internal/ssa/rewritegeneric.go
@@ -3,10 +3,8 @@
 
 package ssa
 
-import (
-	"cmd/compile/internal/types"
-	"math"
-)
+import "math"
+import "cmd/compile/internal/types"
 
 func rewriteValuegeneric(v *Value) bool {
 	switch v.Op {
-- 
GitLab


From 11052d77a307a417a4de94991303949bf697b8ee Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 27 Apr 2021 17:05:36 -0400
Subject: [PATCH 1813/2400] cmd/link: use R12 as trampoline scratch register on
 ARM

The external linker uses R12. Do the same. We previously use R11,
the temp register in Go ABI. This does not really matter if the
caller is Go code, because all registers are clobbered at call.
But it the caller is C code, it may assume R11 live across a call.
Using R11 may clobber live value. On the callee side, R12 is not
an argument register in both Go and C calling convention.

Change-Id: I958c5dad52aa51bb282a7ad420f5423863e69c14
Reviewed-on: https://go-review.googlesource.com/c/go/+/314454
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/arm/asm.go | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/cmd/link/internal/arm/asm.go b/src/cmd/link/internal/arm/asm.go
index efdaff198d..33b20febd7 100644
--- a/src/cmd/link/internal/arm/asm.go
+++ b/src/cmd/link/internal/arm/asm.go
@@ -443,8 +443,8 @@ func gentramp(arch *sys.Arch, linkmode ld.LinkMode, ldr *loader.Loader, tramp *l
 	tramp.SetSize(12) // 3 instructions
 	P := make([]byte, tramp.Size())
 	t := ldr.SymValue(target) + offset
-	o1 := uint32(0xe5900000 | 11<<12 | 15<<16) // MOVW (R15), R11 // R15 is actual pc + 8
-	o2 := uint32(0xe12fff10 | 11)              // JMP  (R11)
+	o1 := uint32(0xe5900000 | 12<<12 | 15<<16) // MOVW (R15), R12 // R15 is actual pc + 8
+	o2 := uint32(0xe12fff10 | 12)              // JMP  (R12)
 	o3 := uint32(t)                            // WORD $target
 	arch.ByteOrder.PutUint32(P, o1)
 	arch.ByteOrder.PutUint32(P[4:], o2)
@@ -464,9 +464,9 @@ func gentramp(arch *sys.Arch, linkmode ld.LinkMode, ldr *loader.Loader, tramp *l
 func gentramppic(arch *sys.Arch, tramp *loader.SymbolBuilder, target loader.Sym, offset int64) {
 	tramp.SetSize(16) // 4 instructions
 	P := make([]byte, tramp.Size())
-	o1 := uint32(0xe5900000 | 11<<12 | 15<<16 | 4)  // MOVW 4(R15), R11 // R15 is actual pc + 8
-	o2 := uint32(0xe0800000 | 11<<12 | 15<<16 | 11) // ADD R15, R11, R11
-	o3 := uint32(0xe12fff10 | 11)                   // JMP  (R11)
+	o1 := uint32(0xe5900000 | 12<<12 | 15<<16 | 4)  // MOVW 4(R15), R12 // R15 is actual pc + 8
+	o2 := uint32(0xe0800000 | 12<<12 | 15<<16 | 12) // ADD R15, R12, R12
+	o3 := uint32(0xe12fff10 | 12)                   // JMP  (R12)
 	o4 := uint32(0)                                 // WORD $(target-pc) // filled in with relocation
 	arch.ByteOrder.PutUint32(P, o1)
 	arch.ByteOrder.PutUint32(P[4:], o2)
@@ -484,10 +484,10 @@ func gentramppic(arch *sys.Arch, tramp *loader.SymbolBuilder, target loader.Sym,
 // generate a trampoline to target+offset in dynlink mode (using GOT)
 func gentrampdyn(arch *sys.Arch, tramp *loader.SymbolBuilder, target loader.Sym, offset int64) {
 	tramp.SetSize(20)                               // 5 instructions
-	o1 := uint32(0xe5900000 | 11<<12 | 15<<16 | 8)  // MOVW 8(R15), R11 // R15 is actual pc + 8
-	o2 := uint32(0xe0800000 | 11<<12 | 15<<16 | 11) // ADD R15, R11, R11
-	o3 := uint32(0xe5900000 | 11<<12 | 11<<16)      // MOVW (R11), R11
-	o4 := uint32(0xe12fff10 | 11)                   // JMP  (R11)
+	o1 := uint32(0xe5900000 | 12<<12 | 15<<16 | 8)  // MOVW 8(R15), R12 // R15 is actual pc + 8
+	o2 := uint32(0xe0800000 | 12<<12 | 15<<16 | 12) // ADD R15, R12, R12
+	o3 := uint32(0xe5900000 | 12<<12 | 12<<16)      // MOVW (R12), R12
+	o4 := uint32(0xe12fff10 | 12)                   // JMP  (R12)
 	o5 := uint32(0)                                 // WORD $target@GOT // filled in with relocation
 	o6 := uint32(0)
 	if offset != 0 {
@@ -495,8 +495,8 @@ func gentrampdyn(arch *sys.Arch, tramp *loader.SymbolBuilder, target loader.Sym,
 		tramp.SetSize(24) // 6 instructions
 		o6 = o5
 		o5 = o4
-		o4 = 0xe2800000 | 11<<12 | 11<<16 | immrot(uint32(offset)) // ADD $offset, R11, R11
-		o1 = uint32(0xe5900000 | 11<<12 | 15<<16 | 12)             // MOVW 12(R15), R11
+		o4 = 0xe2800000 | 12<<12 | 12<<16 | immrot(uint32(offset)) // ADD $offset, R12, R12
+		o1 = uint32(0xe5900000 | 12<<12 | 15<<16 | 12)             // MOVW 12(R15), R12
 	}
 	P := make([]byte, tramp.Size())
 	arch.ByteOrder.PutUint32(P, o1)
-- 
GitLab


From 5c69cb2a5bc33ae2c8af598a53f4337bd1e77508 Mon Sep 17 00:00:00 2001
From: unbyte <i@shangyes.net>
Date: Wed, 28 Apr 2021 04:32:15 +0000
Subject: [PATCH 1814/2400] cmd/go: populate module info even if an error
 occurs in loading package

The existing implementation ignores module info if there is any error loading the package.

Fixes #44287

Change-Id: I24142e4c7256517292fc654e29d759871b80bc09
GitHub-Last-Rev: 28e9bf85e8c119f3b805c38c79aef60322fcc551
GitHub-Pull-Request: golang/go#45777
Reviewed-on: https://go-review.googlesource.com/c/go/+/313549
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/load/pkg.go               | 23 ++++++++++---------
 .../script/list_module_when_error.txt         | 19 +++++++++++++++
 2 files changed, 31 insertions(+), 11 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/list_module_when_error.txt

diff --git a/src/cmd/go/internal/load/pkg.go b/src/cmd/go/internal/load/pkg.go
index c1e3eaa0f3..2d91d10583 100644
--- a/src/cmd/go/internal/load/pkg.go
+++ b/src/cmd/go/internal/load/pkg.go
@@ -1846,6 +1846,14 @@ func (p *Package) load(ctx context.Context, opts PackageOpts, path string, stk *
 	stk.Push(path)
 	defer stk.Pop()
 
+	pkgPath := p.ImportPath
+	if p.Internal.CmdlineFiles {
+		pkgPath = "command-line-arguments"
+	}
+	if cfg.ModulesEnabled {
+		p.Module = modload.PackageModuleInfo(ctx, pkgPath)
+	}
+
 	p.EmbedFiles, p.Internal.Embed, err = resolveEmbed(p.Dir, p.EmbedPatterns)
 	if err != nil {
 		p.Incomplete = true
@@ -1905,6 +1913,10 @@ func (p *Package) load(ctx context.Context, opts PackageOpts, path string, stk *
 	p.Internal.Imports = imports
 	p.collectDeps()
 
+	if cfg.ModulesEnabled && p.Error == nil && p.Name == "main" && len(p.DepsErrors) == 0 {
+		p.Internal.BuildInfo = modload.PackageBuildInfo(pkgPath, p.Deps)
+	}
+
 	// unsafe is a fake package.
 	if p.Standard && (p.ImportPath == "unsafe" || cfg.BuildContext.Compiler == "gccgo") {
 		p.Target = ""
@@ -1944,17 +1956,6 @@ func (p *Package) load(ctx context.Context, opts PackageOpts, path string, stk *
 		setError(fmt.Errorf("Fortran source files not allowed when not using cgo or SWIG: %s", strings.Join(p.FFiles, " ")))
 		return
 	}
-
-	if cfg.ModulesEnabled && p.Error == nil {
-		mainPath := p.ImportPath
-		if p.Internal.CmdlineFiles {
-			mainPath = "command-line-arguments"
-		}
-		p.Module = modload.PackageModuleInfo(ctx, mainPath)
-		if p.Name == "main" && len(p.DepsErrors) == 0 {
-			p.Internal.BuildInfo = modload.PackageBuildInfo(mainPath, p.Deps)
-		}
-	}
 }
 
 // An EmbedError indicates a problem with a go:embed directive.
diff --git a/src/cmd/go/testdata/script/list_module_when_error.txt b/src/cmd/go/testdata/script/list_module_when_error.txt
new file mode 100644
index 0000000000..844164cd6a
--- /dev/null
+++ b/src/cmd/go/testdata/script/list_module_when_error.txt
@@ -0,0 +1,19 @@
+# The Module field should be populated even if there is an error loading the package.
+
+env GO111MODULE=on
+
+go list -e -f {{.Module}}
+stdout '^mod.com$'
+
+-- go.mod --
+module mod.com
+
+go 1.16
+
+-- blah.go --
+package blah
+
+import _ "embed"
+
+//go:embed README.md
+var readme string
-- 
GitLab


From 12af403624baa87700fe05db3e21c26e410871fd Mon Sep 17 00:00:00 2001
From: Manlio Perillo <manlio.perillo@gmail.com>
Date: Tue, 27 Apr 2021 14:48:20 +0200
Subject: [PATCH 1815/2400] cmd/go/internal/bug: use envcmd instead of go env

Add the printGoEnv function to print the go environment variables, using
the envcmd package instead of invoking go env.

Add the PrintEnv function to the envcmd package, to avoid duplicating
code.

Updates #45803

Change-Id: I38d5b936c0ebb16e741ffbee4309b95d6d0ecc6c
Reviewed-on: https://go-review.googlesource.com/c/go/+/314230
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/internal/bug/bug.go    | 14 +++++++++-----
 src/cmd/go/internal/envcmd/env.go | 20 +++++++++++++-------
 2 files changed, 22 insertions(+), 12 deletions(-)

diff --git a/src/cmd/go/internal/bug/bug.go b/src/cmd/go/internal/bug/bug.go
index df63c579d9..307527c695 100644
--- a/src/cmd/go/internal/bug/bug.go
+++ b/src/cmd/go/internal/bug/bug.go
@@ -20,6 +20,7 @@ import (
 
 	"cmd/go/internal/base"
 	"cmd/go/internal/cfg"
+	"cmd/go/internal/envcmd"
 	"cmd/go/internal/web"
 )
 
@@ -90,17 +91,20 @@ func printEnvDetails(w io.Writer) {
 	fmt.Fprintf(w, "### What operating system and processor architecture are you using (`go env`)?\n\n")
 	fmt.Fprintf(w, "<details><summary><code>go env</code> Output</summary><br><pre>\n")
 	fmt.Fprintf(w, "$ go env\n")
-	goexe, err := os.Executable()
-	if err != nil {
-		goexe = filepath.Join(runtime.GOROOT(), "bin/go")
-	}
-	printCmdOut(w, "", goexe, "env")
+	printGoEnv(w)
 	printGoDetails(w)
 	printOSDetails(w)
 	printCDetails(w)
 	fmt.Fprintf(w, "</pre></details>\n\n")
 }
 
+func printGoEnv(w io.Writer) {
+	env := envcmd.MkEnv()
+	env = append(env, envcmd.ExtraEnvVars()...)
+	env = append(env, envcmd.ExtraEnvVarsCostly()...)
+	envcmd.PrintEnv(w, env)
+}
+
 func printGoDetails(w io.Writer) {
 	printCmdOut(w, "GOROOT/bin/go version: ", filepath.Join(runtime.GOROOT(), "bin/go"), "version")
 	printCmdOut(w, "GOROOT/bin/go tool compile -V: ", filepath.Join(runtime.GOROOT(), "bin/go"), "tool", "compile", "-V")
diff --git a/src/cmd/go/internal/envcmd/env.go b/src/cmd/go/internal/envcmd/env.go
index aad5d704e5..8dbb8af1e7 100644
--- a/src/cmd/go/internal/envcmd/env.go
+++ b/src/cmd/go/internal/envcmd/env.go
@@ -10,6 +10,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"go/build"
+	"io"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -347,27 +348,32 @@ func runEnv(ctx context.Context, cmd *base.Command, args []string) {
 		return
 	}
 
+	PrintEnv(os.Stdout, env)
+}
+
+// PrintEnv prints the environment variables to w.
+func PrintEnv(w io.Writer, env []cfg.EnvVar) {
 	for _, e := range env {
 		if e.Name != "TERM" {
 			switch runtime.GOOS {
 			default:
-				fmt.Printf("%s=\"%s\"\n", e.Name, e.Value)
+				fmt.Fprintf(w, "%s=\"%s\"\n", e.Name, e.Value)
 			case "plan9":
 				if strings.IndexByte(e.Value, '\x00') < 0 {
-					fmt.Printf("%s='%s'\n", e.Name, strings.ReplaceAll(e.Value, "'", "''"))
+					fmt.Fprintf(w, "%s='%s'\n", e.Name, strings.ReplaceAll(e.Value, "'", "''"))
 				} else {
 					v := strings.Split(e.Value, "\x00")
-					fmt.Printf("%s=(", e.Name)
+					fmt.Fprintf(w, "%s=(", e.Name)
 					for x, s := range v {
 						if x > 0 {
-							fmt.Printf(" ")
+							fmt.Fprintf(w, " ")
 						}
-						fmt.Printf("%s", s)
+						fmt.Fprintf(w, "%s", s)
 					}
-					fmt.Printf(")\n")
+					fmt.Fprintf(w, ")\n")
 				}
 			case "windows":
-				fmt.Printf("set %s=%s\n", e.Name, e.Value)
+				fmt.Fprintf(w, "set %s=%s\n", e.Name, e.Value)
 			}
 		}
 	}
-- 
GitLab


From 24ea547a210b90eff7f4fefbd12dc8f72853406a Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Tue, 27 Apr 2021 21:56:46 -0700
Subject: [PATCH 1816/2400] cmd/link: don't pass -Wl,--dynamic-linker if
 -static

As with -rdynamic, clang will pass -Wl,--dynamic-linker to the linker
even when linking statically. When using lld this will produce a statically
linked executable with a dynamic interpreter, which will crash at runtime.
This CL changes the linker to drop -Wl,--dynamic-linker when using -static,
as it already does with -rdynamic.

This has become more important since CL 310349, which changes the linker
to always pass a -Wl,--dynamic-linker option if the Go linker is invoked
with a -I option.

Change-Id: I68ed431064f02c70018bc0547585e5b0ebd20a41
Reviewed-on: https://go-review.googlesource.com/c/go/+/314412
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/link/internal/ld/lib.go | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index 043bf5a35e..7408526076 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -1520,12 +1520,13 @@ func (ctxt *Link) hostlink() {
 	// even when linking with -static, causing a linker
 	// error when using GNU ld. So take out -rdynamic if
 	// we added it. We do it in this order, rather than
-	// only adding -rdynamic later, so that -*extldflags
+	// only adding -rdynamic later, so that -extldflags
 	// can override -rdynamic without using -static.
+	// Similarly for -Wl,--dynamic-linker.
 	checkStatic := func(arg string) {
 		if ctxt.IsELF && arg == "-static" {
 			for i := range argv {
-				if argv[i] == "-rdynamic" {
+				if argv[i] == "-rdynamic" || strings.HasPrefix(argv[i], "-Wl,--dynamic-linker,") {
 					argv[i] = "-static"
 				}
 			}
-- 
GitLab


From becb9a278fdeccfb562dd1232f052050f00a4aaa Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Wed, 28 Apr 2021 11:24:24 -0400
Subject: [PATCH 1817/2400] test: do not run fuse test in noopt mode

Change-Id: Iad8ac2253ce28fd0a331bde36836d1b7f25797bd
Reviewed-on: https://go-review.googlesource.com/c/go/+/314632
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 test/fuse.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/fuse.go b/test/fuse.go
index 7d39c3cdb9..ea908bfd4d 100644
--- a/test/fuse.go
+++ b/test/fuse.go
@@ -1,4 +1,4 @@
-// +build amd64 arm64
+// +build amd64,!gcflags_noopt arm64,!gcflags_noopt
 // errorcheck -0 -d=ssa/late_fuse/debug=1
 
 // Copyright 2021 The Go Authors. All rights reserved.
-- 
GitLab


From 92c9f3a9b80eda50a55f8860587c2ed7734f4a29 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Tue, 27 Apr 2021 17:32:02 -0700
Subject: [PATCH 1818/2400] cmd/go: include C/C++/Fortran compiler version in
 build ID

This will force a rebuild if the C/C++/Fortran compiler changes.

No test because a real test requires installing two different compilers.

Fixes #40042

Change-Id: I83cc88ade90d665a6fce06435068f39c811e43af
Reviewed-on: https://go-review.googlesource.com/c/go/+/314276
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go/internal/work/buildid.go |  2 +-
 src/cmd/go/internal/work/exec.go    | 27 ++++++++++++++++++++-------
 2 files changed, 21 insertions(+), 8 deletions(-)

diff --git a/src/cmd/go/internal/work/buildid.go b/src/cmd/go/internal/work/buildid.go
index c555d4a9f1..4e9189a363 100644
--- a/src/cmd/go/internal/work/buildid.go
+++ b/src/cmd/go/internal/work/buildid.go
@@ -204,7 +204,7 @@ func (b *Builder) toolID(name string) string {
 // In order to get reproducible builds for released compilers, we
 // detect a released compiler by the absence of "experimental" in the
 // --version output, and in that case we just use the version string.
-func (b *Builder) gccgoToolID(name, language string) (string, error) {
+func (b *Builder) gccToolID(name, language string) (string, error) {
 	key := name + "." + language
 	b.id.Lock()
 	id := b.toolIDCache[key]
diff --git a/src/cmd/go/internal/work/exec.go b/src/cmd/go/internal/work/exec.go
index d04ba06901..994c4dafcf 100644
--- a/src/cmd/go/internal/work/exec.go
+++ b/src/cmd/go/internal/work/exec.go
@@ -249,14 +249,27 @@ func (b *Builder) buildActionID(a *Action) cache.ActionID {
 	if len(p.CgoFiles)+len(p.SwigFiles)+len(p.SwigCXXFiles) > 0 {
 		fmt.Fprintf(h, "cgo %q\n", b.toolID("cgo"))
 		cppflags, cflags, cxxflags, fflags, ldflags, _ := b.CFlags(p)
-		fmt.Fprintf(h, "CC=%q %q %q %q\n", b.ccExe(), cppflags, cflags, ldflags)
+
+		ccExe := b.ccExe()
+		fmt.Fprintf(h, "CC=%q %q %q %q\n", ccExe, cppflags, cflags, ldflags)
+		if ccID, err := b.gccToolID(ccExe[0], "c"); err == nil {
+			fmt.Fprintf(h, "CC ID=%q\n", ccID)
+		}
 		if len(p.CXXFiles)+len(p.SwigCXXFiles) > 0 {
-			fmt.Fprintf(h, "CXX=%q %q\n", b.cxxExe(), cxxflags)
+			cxxExe := b.cxxExe()
+			fmt.Fprintf(h, "CXX=%q %q\n", cxxExe, cxxflags)
+			if cxxID, err := b.gccToolID(cxxExe[0], "c++"); err == nil {
+				fmt.Fprintf(h, "CXX ID=%q\n", cxxID)
+			}
 		}
 		if len(p.FFiles) > 0 {
-			fmt.Fprintf(h, "FC=%q %q\n", b.fcExe(), fflags)
+			fcExe := b.fcExe()
+			fmt.Fprintf(h, "FC=%q %q\n", fcExe, fflags)
+			if fcID, err := b.gccToolID(fcExe[0], "f95"); err == nil {
+				fmt.Fprintf(h, "FC ID=%q\n", fcID)
+			}
 		}
-		// TODO(rsc): Should we include the SWIG version or Fortran/GCC/G++/Objective-C compiler versions?
+		// TODO(rsc): Should we include the SWIG version?
 	}
 	if p.Internal.CoverMode != "" {
 		fmt.Fprintf(h, "cover %q %q\n", p.Internal.CoverMode, b.toolID("cover"))
@@ -316,7 +329,7 @@ func (b *Builder) buildActionID(a *Action) cache.ActionID {
 		}
 
 	case "gccgo":
-		id, err := b.gccgoToolID(BuildToolchain.compiler(), "go")
+		id, err := b.gccToolID(BuildToolchain.compiler(), "go")
 		if err != nil {
 			base.Fatalf("%v", err)
 		}
@@ -324,7 +337,7 @@ func (b *Builder) buildActionID(a *Action) cache.ActionID {
 		fmt.Fprintf(h, "pkgpath %s\n", gccgoPkgpath(p))
 		fmt.Fprintf(h, "ar %q\n", BuildToolchain.(gccgoToolchain).ar())
 		if len(p.SFiles) > 0 {
-			id, _ = b.gccgoToolID(BuildToolchain.compiler(), "assembler-with-cpp")
+			id, _ = b.gccToolID(BuildToolchain.compiler(), "assembler-with-cpp")
 			// Ignore error; different assembler versions
 			// are unlikely to make any difference anyhow.
 			fmt.Fprintf(h, "asm %q\n", id)
@@ -1274,7 +1287,7 @@ func (b *Builder) printLinkerConfig(h io.Writer, p *load.Package) {
 		// Or external linker settings and flags?
 
 	case "gccgo":
-		id, err := b.gccgoToolID(BuildToolchain.linker(), "go")
+		id, err := b.gccToolID(BuildToolchain.linker(), "go")
 		if err != nil {
 			base.Fatalf("%v", err)
 		}
-- 
GitLab


From e51246c8819f16cd78d3da01162ca14b432d30bc Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Tue, 27 Apr 2021 10:58:54 -0700
Subject: [PATCH 1819/2400] runtime: consolidate Windows time constants into
 single copy

Change-Id: I1a583d3da9cca4ac51f3fec9b508b7638b452d60
Reviewed-on: https://go-review.googlesource.com/c/go/+/314270
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/sys_windows_386.s   | 11 +----------
 src/runtime/sys_windows_amd64.s | 11 +----------
 src/runtime/sys_windows_arm.s   | 11 +----------
 src/runtime/sys_windows_arm64.s | 11 +----------
 src/runtime/time_windows.h      | 16 ++++++++++++++++
 5 files changed, 20 insertions(+), 40 deletions(-)
 create mode 100644 src/runtime/time_windows.h

diff --git a/src/runtime/sys_windows_386.s b/src/runtime/sys_windows_386.s
index d6b521ab65..d8b14eb644 100644
--- a/src/runtime/sys_windows_386.s
+++ b/src/runtime/sys_windows_386.s
@@ -5,6 +5,7 @@
 #include "go_asm.h"
 #include "go_tls.h"
 #include "textflag.h"
+#include "time_windows.h"
 
 // void runtime·asmstdcall(void *c);
 TEXT runtime·asmstdcall<ABIInternal>(SB),NOSPLIT,$0
@@ -331,16 +332,6 @@ TEXT runtime·switchtothread(SB),NOSPLIT,$0
 	MOVL	BP, SP
 	RET
 
-// See https://wrkhpi.wordpress.com/2007/08/09/getting-os-information-the-kuser_shared_data-structure/
-// Archived copy at:
-// http://web.archive.org/web/20210411000829/https://wrkhpi.wordpress.com/2007/08/09/getting-os-information-the-kuser_shared_data-structure/
-// Must read hi1, then lo, then hi2. The snapshot is valid if hi1 == hi2.
-#define _INTERRUPT_TIME 0x7ffe0008
-#define _SYSTEM_TIME 0x7ffe0014
-#define time_lo 0
-#define time_hi1 4
-#define time_hi2 8
-
 TEXT runtime·nanotime1(SB),NOSPLIT,$0-8
 	CMPB	runtime·useQPCTime(SB), $0
 	JNE	useQPC
diff --git a/src/runtime/sys_windows_amd64.s b/src/runtime/sys_windows_amd64.s
index ed44561084..868fd9d20f 100644
--- a/src/runtime/sys_windows_amd64.s
+++ b/src/runtime/sys_windows_amd64.s
@@ -5,6 +5,7 @@
 #include "go_asm.h"
 #include "go_tls.h"
 #include "textflag.h"
+#include "time_windows.h"
 #include "cgo/abi_amd64.h"
 
 // maxargs should be divisible by 2, as Windows stack
@@ -341,16 +342,6 @@ TEXT runtime·switchtothread(SB),NOSPLIT|NOFRAME,$0
 	MOVQ	32(SP), SP
 	RET
 
-// See https://wrkhpi.wordpress.com/2007/08/09/getting-os-information-the-kuser_shared_data-structure/
-// Archived copy at:
-// http://web.archive.org/web/20210411000829/https://wrkhpi.wordpress.com/2007/08/09/getting-os-information-the-kuser_shared_data-structure/
-// Must read hi1, then lo, then hi2. The snapshot is valid if hi1 == hi2.
-#define _INTERRUPT_TIME 0x7ffe0008
-#define _SYSTEM_TIME 0x7ffe0014
-#define time_lo 0
-#define time_hi1 4
-#define time_hi2 8
-
 TEXT runtime·nanotime1(SB),NOSPLIT,$0-8
 	CMPB	runtime·useQPCTime(SB), $0
 	JNE	useQPC
diff --git a/src/runtime/sys_windows_arm.s b/src/runtime/sys_windows_arm.s
index 6234203798..7676bc1ff8 100644
--- a/src/runtime/sys_windows_arm.s
+++ b/src/runtime/sys_windows_arm.s
@@ -5,6 +5,7 @@
 #include "go_asm.h"
 #include "go_tls.h"
 #include "textflag.h"
+#include "time_windows.h"
 
 // Note: For system ABI, R0-R3 are args, R4-R11 are callee-save.
 
@@ -341,16 +342,6 @@ TEXT runtime·read_tls_fallback(SB),NOSPLIT|NOFRAME,$0
 	MOVW	R0, (R0)
 	RET
 
-// See https://wrkhpi.wordpress.com/2007/08/09/getting-os-information-the-kuser_shared_data-structure/
-// Archived copy at:
-// http://web.archive.org/web/20210411000829/https://wrkhpi.wordpress.com/2007/08/09/getting-os-information-the-kuser_shared_data-structure/
-// Must read hi1, then lo, then hi2. The snapshot is valid if hi1 == hi2.
-#define _INTERRUPT_TIME 0x7ffe0008
-#define _SYSTEM_TIME 0x7ffe0014
-#define time_lo 0
-#define time_hi1 4
-#define time_hi2 8
-
 TEXT runtime·nanotime1(SB),NOSPLIT|NOFRAME,$0-8
 	MOVW	$0, R0
 	MOVB	runtime·useQPCTime(SB), R0
diff --git a/src/runtime/sys_windows_arm64.s b/src/runtime/sys_windows_arm64.s
index 9fce9a8158..aa9ea7ed98 100644
--- a/src/runtime/sys_windows_arm64.s
+++ b/src/runtime/sys_windows_arm64.s
@@ -6,6 +6,7 @@
 #include "go_tls.h"
 #include "textflag.h"
 #include "funcdata.h"
+#include "time_windows.h"
 
 // Offsets into Thread Environment Block (pointer in R18)
 #define TEB_error 0x68
@@ -407,16 +408,6 @@ TEXT runtime·switchtothread(SB),NOSPLIT,$16-0
 	ADD	$16, RSP
 	RET
 
-// See https://wrkhpi.wordpress.com/2007/08/09/getting-os-information-the-kuser_shared_data-structure/
-// Archived copy at:
-// http://web.archive.org/web/20210411000829/https://wrkhpi.wordpress.com/2007/08/09/getting-os-information-the-kuser_shared_data-structure/
-// Must read hi1, then lo, then hi2. The snapshot is valid if hi1 == hi2.
-#define _INTERRUPT_TIME 0x7ffe0008
-#define _SYSTEM_TIME 0x7ffe0014
-#define time_lo 0
-#define time_hi1 4
-#define time_hi2 8
-
 TEXT runtime·nanotime1(SB),NOSPLIT|NOFRAME,$0-8
 	MOVB	runtime·useQPCTime(SB), R0
 	CMP	$0, R0
diff --git a/src/runtime/time_windows.h b/src/runtime/time_windows.h
new file mode 100644
index 0000000000..cd16fd163b
--- /dev/null
+++ b/src/runtime/time_windows.h
@@ -0,0 +1,16 @@
+// Copyright 2021 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.
+
+// Constants for fetching time values on Windows for use in asm code.
+
+// See https://wrkhpi.wordpress.com/2007/08/09/getting-os-information-the-kuser_shared_data-structure/
+// Archived copy at:
+// http://web.archive.org/web/20210411000829/https://wrkhpi.wordpress.com/2007/08/09/getting-os-information-the-kuser_shared_data-structure/
+
+// Must read hi1, then lo, then hi2. The snapshot is valid if hi1 == hi2.
+#define _INTERRUPT_TIME 0x7ffe0008
+#define _SYSTEM_TIME 0x7ffe0014
+#define time_lo 0
+#define time_hi1 4
+#define time_hi2 8
-- 
GitLab


From cbb3f090477de92a7e158050803ef71a5ea825ee Mon Sep 17 00:00:00 2001
From: Paschalis Tsilias <paschalis.tsilias@gmail.com>
Date: Wed, 14 Apr 2021 23:55:38 +0300
Subject: [PATCH 1820/2400] testing: add -shuffle=off|on|N to alter the
 execution order of tests and benchmarks

This CL adds a new flag to the testing package and the go test command
which randomizes the execution order for tests and benchmarks.
This can be useful for identifying unwanted dependencies
between test or benchmark functions.
The flag is off by default. If `-shuffle` is set to `on` then the system
clock will be used as the seed value. If `-shuffle` is set to an integer
N, then N will be used as the seed value. In both cases, the seed will
be reported for failed runs so that they can reproduced later on.

Fixes #28592

Change-Id: I62e7dfae5f63f97a0cbd7830ea844d9f7beac335
Reviewed-on: https://go-review.googlesource.com/c/go/+/310033
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Trust: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go/alldocs.go                       |   7 +
 src/cmd/go/internal/test/flagdefs.go        |   1 +
 src/cmd/go/internal/test/test.go            |   8 ++
 src/cmd/go/internal/test/testflag.go        |  37 +++++
 src/cmd/go/testdata/script/test_shuffle.txt | 148 ++++++++++++++++++++
 src/go/build/deps_test.go                   |   2 +-
 src/math/rand/export_test.go                |  17 +++
 src/math/rand/race_test.go                  |   3 +-
 src/math/rand/rand_test.go                  |   8 +-
 src/testing/testing.go                      |  22 +++
 10 files changed, 249 insertions(+), 4 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/test_shuffle.txt
 create mode 100644 src/math/rand/export_test.go

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index 103eecf79c..0a12eaf4e9 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -2667,6 +2667,13 @@
 // 	    the Go tree can run a sanity check but not spend time running
 // 	    exhaustive tests.
 //
+// 	-shuffle off,on,N
+// 		Randomize the execution order of tests and benchmarks.
+// 		It is off by default. If -shuffle is set to on, then it will seed
+// 		the randomizer using the system clock. If -shuffle is set to an
+// 		integer N, then N will be used as the seed value. In both cases,
+// 		the seed will be reported for reproducibility.
+//
 // 	-timeout d
 // 	    If a test binary runs longer than duration d, panic.
 // 	    If d is 0, the timeout is disabled.
diff --git a/src/cmd/go/internal/test/flagdefs.go b/src/cmd/go/internal/test/flagdefs.go
index 8a0a07683b..37ac81c267 100644
--- a/src/cmd/go/internal/test/flagdefs.go
+++ b/src/cmd/go/internal/test/flagdefs.go
@@ -28,6 +28,7 @@ var passFlagToTest = map[string]bool{
 	"parallel":             true,
 	"run":                  true,
 	"short":                true,
+	"shuffle":              true,
 	"timeout":              true,
 	"trace":                true,
 	"v":                    true,
diff --git a/src/cmd/go/internal/test/test.go b/src/cmd/go/internal/test/test.go
index 847b9357b4..c2f8aed004 100644
--- a/src/cmd/go/internal/test/test.go
+++ b/src/cmd/go/internal/test/test.go
@@ -272,6 +272,13 @@ control the execution of any test:
 	    the Go tree can run a sanity check but not spend time running
 	    exhaustive tests.
 
+	-shuffle off,on,N
+		Randomize the execution order of tests and benchmarks.
+		It is off by default. If -shuffle is set to on, then it will seed
+		the randomizer using the system clock. If -shuffle is set to an
+		integer N, then N will be used as the seed value. In both cases,
+		the seed will be reported for reproducibility.
+
 	-timeout d
 	    If a test binary runs longer than duration d, panic.
 	    If d is 0, the timeout is disabled.
@@ -480,6 +487,7 @@ var (
 	testList         string                            // -list flag
 	testO            string                            // -o flag
 	testOutputDir    = base.Cwd                        // -outputdir flag
+	testShuffle      shuffleFlag                       // -shuffle flag
 	testTimeout      time.Duration                     // -timeout flag
 	testV            bool                              // -v flag
 	testVet          = vetFlag{flags: defaultVetFlags} // -vet flag
diff --git a/src/cmd/go/internal/test/testflag.go b/src/cmd/go/internal/test/testflag.go
index 10e6604da5..6ed96a36d0 100644
--- a/src/cmd/go/internal/test/testflag.go
+++ b/src/cmd/go/internal/test/testflag.go
@@ -10,6 +10,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strconv"
 	"strings"
 	"time"
 
@@ -68,6 +69,7 @@ func init() {
 	cf.DurationVar(&testTimeout, "timeout", 10*time.Minute, "")
 	cf.StringVar(&testTrace, "trace", "", "")
 	cf.BoolVar(&testV, "v", false, "")
+	cf.Var(&testShuffle, "shuffle", "")
 
 	for name, _ := range passFlagToTest {
 		cf.Var(cf.Lookup(name).Value, "test."+name, "")
@@ -194,6 +196,41 @@ func (f *vetFlag) Set(value string) error {
 	return nil
 }
 
+type shuffleFlag struct {
+	on   bool
+	seed *int64
+}
+
+func (f *shuffleFlag) String() string {
+	if !f.on {
+		return "off"
+	}
+	if f.seed == nil {
+		return "on"
+	}
+	return fmt.Sprintf("%d", *f.seed)
+}
+
+func (f *shuffleFlag) Set(value string) error {
+	if value == "off" {
+		*f = shuffleFlag{on: false}
+		return nil
+	}
+
+	if value == "on" {
+		*f = shuffleFlag{on: true}
+		return nil
+	}
+
+	seed, err := strconv.ParseInt(value, 10, 64)
+	if err != nil {
+		return fmt.Errorf(`-shuffle argument must be "on", "off", or an int64: %v`, err)
+	}
+
+	*f = shuffleFlag{on: true, seed: &seed}
+	return nil
+}
+
 // testFlags processes the command line, grabbing -x and -c, rewriting known flags
 // to have "test" before them, and reading the command line for the test binary.
 // Unfortunately for us, we need to do our own flag processing because go test
diff --git a/src/cmd/go/testdata/script/test_shuffle.txt b/src/cmd/go/testdata/script/test_shuffle.txt
new file mode 100644
index 0000000000..3a50605c34
--- /dev/null
+++ b/src/cmd/go/testdata/script/test_shuffle.txt
@@ -0,0 +1,148 @@
+# Shuffle order of tests and benchmarks
+
+# Run tests
+go test -v foo_test.go
+! stdout '-test.shuffle '
+stdout '(?s)TestOne(.*)TestTwo(.*)TestThree'
+
+go test -v -shuffle=off foo_test.go
+! stdout '-test.shuffle '
+stdout '(?s)TestOne(.*)TestTwo(.*)TestThree'
+
+go test -v -shuffle=42 foo_test.go
+stdout '^-test.shuffle 42'
+stdout '(?s)TestThree(.*)TestOne(.*)TestTwo'
+
+go test -v -shuffle=43 foo_test.go
+stdout '^-test.shuffle 43'
+stdout '(?s)TestThree(.*)TestTwo(.*)TestOne'
+
+go test -v -shuffle=44 foo_test.go
+stdout '^-test.shuffle 44'
+stdout '(?s)TestOne(.*)TestThree(.*)TestTwo'
+
+go test -v -shuffle=0 foo_test.go
+stdout '^-test.shuffle 0'
+stdout '(?s)TestTwo(.*)TestOne(.*)TestThree'
+
+go test -v -shuffle -1 foo_test.go
+stdout '^-test.shuffle -1'
+stdout '(?s)TestThree(.*)TestOne(.*)TestTwo'
+
+go test -v -shuffle=on foo_test.go
+stdout '^-test.shuffle '
+stdout '(?s)=== RUN   TestOne(.*)--- PASS: TestOne'
+stdout '(?s)=== RUN   TestTwo(.*)--- PASS: TestTwo'
+stdout '(?s)=== RUN   TestThree(.*)--- PASS: TestThree'
+
+
+# Run tests and benchmarks
+go test -v -bench=. foo_test.go
+! stdout '-test.shuffle '
+stdout '(?s)TestOne(.*)TestTwo(.*)TestThree(.*)BenchmarkOne(.*)BenchmarkTwo(.*)BenchmarkThree'
+
+go test -v -bench=. -shuffle=off foo_test.go
+! stdout '-test.shuffle '
+stdout '(?s)TestOne(.*)TestTwo(.*)TestThree(.*)BenchmarkOne(.*)BenchmarkTwo(.*)BenchmarkThree'
+
+go test -v -bench=. -shuffle=42 foo_test.go
+stdout '^-test.shuffle 42'
+stdout '(?s)TestThree(.*)TestOne(.*)TestTwo(.*)BenchmarkThree(.*)BenchmarkOne(.*)BenchmarkTwo'
+
+go test -v -bench=. -shuffle=43 foo_test.go
+stdout '^-test.shuffle 43'
+stdout '(?s)TestThree(.*)TestTwo(.*)TestOne(.*)BenchmarkThree(.*)BenchmarkOne(.*)BenchmarkTwo'
+
+go test -v -bench=. -shuffle=44 foo_test.go
+stdout '^-test.shuffle 44'
+stdout '(?s)TestOne(.*)TestThree(.*)TestTwo(.*)BenchmarkTwo(.*)BenchmarkOne(.*)BenchmarkThree'
+
+go test -v -bench=. -shuffle=0 foo_test.go
+stdout '^-test.shuffle 0'
+stdout '(?s)TestTwo(.*)TestOne(.*)TestThree(.*)BenchmarkThree(.*)BenchmarkOne(.*)BenchmarkTwo'
+
+go test -v -bench=. -shuffle -1 foo_test.go
+stdout '^-test.shuffle -1'
+stdout '(?s)TestThree(.*)TestOne(.*)TestTwo(.*)BenchmarkOne(.*)BenchmarkThree(.*)BenchmarkTwo'
+
+go test -v -bench=. -shuffle=on foo_test.go
+stdout '^-test.shuffle '
+stdout '(?s)=== RUN   TestOne(.*)--- PASS: TestOne'
+stdout '(?s)=== RUN   TestTwo(.*)--- PASS: TestTwo'
+stdout '(?s)=== RUN   TestThree(.*)--- PASS: TestThree'
+stdout -count=2 'BenchmarkOne'
+stdout -count=2 'BenchmarkTwo'
+stdout -count=2 'BenchmarkThree'
+
+
+# When running go test -count=N, each of the N runs distinct runs should maintain the same
+# shuffled order of these tests.
+go test -v -shuffle=43 -count=4 foo_test.go
+stdout '^-test.shuffle 43'
+stdout '(?s)TestThree(.*)TestTwo(.*)TestOne(.*)TestThree(.*)TestTwo(.*)TestOne(.*)TestThree(.*)TestTwo(.*)TestOne(.*)TestThree(.*)TestTwo(.*)TestOne'
+
+go test -v -bench=. -shuffle=44 -count=2 foo_test.go
+stdout '^-test.shuffle 44'
+stdout '(?s)TestOne(.*)TestThree(.*)TestTwo(.*)TestOne(.*)TestThree(.*)TestTwo(.*)BenchmarkTwo(.*)BenchmarkOne(.*)BenchmarkThree(.*)'
+
+
+# The feature should work with test binaries as well
+go test -c
+exec ./m.test -test.shuffle=off
+! stdout '^-test.shuffle '
+
+exec ./m.test -test.shuffle=on
+stdout '^-test.shuffle '
+
+exec ./m.test -test.v -test.bench=. -test.shuffle=0 foo_test.go
+stdout '^-test.shuffle 0'
+stdout '(?s)TestTwo(.*)TestOne(.*)TestThree(.*)BenchmarkThree(.*)BenchmarkOne(.*)BenchmarkTwo'
+
+exec ./m.test -test.v -test.bench=. -test.shuffle=123 foo_test.go
+stdout '^-test.shuffle 123'
+stdout '(?s)TestThree(.*)TestOne(.*)TestTwo(.*)BenchmarkThree(.*)BenchmarkTwo(.*)BenchmarkOne'
+
+exec ./m.test -test.v -test.bench=. -test.shuffle=-1 foo_test.go
+stdout '^-test.shuffle -1'
+stdout '(?s)TestThree(.*)TestOne(.*)TestTwo(.*)BenchmarkOne(.*)BenchmarkThree(.*)BenchmarkTwo'
+
+exec ./m.test -test.v -test.bench=. -test.shuffle=44 -test.count=2 foo_test.go
+stdout '^-test.shuffle 44'
+stdout '(?s)TestOne(.*)TestThree(.*)TestTwo(.*)TestOne(.*)TestThree(.*)TestTwo(.*)BenchmarkTwo(.*)BenchmarkOne(.*)BenchmarkThree(.*)'
+
+
+# Negative testcases for invalid input
+! go test -shuffle -count=2
+stderr 'invalid value "-count=2" for flag -shuffle: -shuffle argument must be "on", "off", or an int64: strconv.ParseInt: parsing "-count=2": invalid syntax'
+
+! go test -shuffle=
+stderr '(?s)invalid value "" for flag -shuffle: -shuffle argument must be "on", "off", or an int64: strconv.ParseInt: parsing "": invalid syntax'
+
+! go test -shuffle=' '
+stderr '(?s)invalid value " " for flag -shuffle: -shuffle argument must be "on", "off", or an int64: strconv.ParseInt: parsing " ": invalid syntax'
+
+! go test -shuffle=true
+stderr 'invalid value "true" for flag -shuffle: -shuffle argument must be "on", "off", or an int64: strconv.ParseInt: parsing "true": invalid syntax'
+
+! go test -shuffle='abc'
+stderr 'invalid value "abc" for flag -shuffle: -shuffle argument must be "on", "off", or an int64: strconv.ParseInt: parsing "abc": invalid syntax'
+
+-- go.mod --
+module m
+
+go 1.16
+-- foo_test.go --
+package foo
+
+import "testing"
+
+func TestOne(t *testing.T)   {}
+func TestTwo(t *testing.T)   {}
+func TestThree(t *testing.T) {}
+
+func BenchmarkOne(b *testing.B)   {}
+func BenchmarkTwo(b *testing.B)   {}
+func BenchmarkThree(b *testing.B) {}
+
+-- foo.go --
+package foo
diff --git a/src/go/build/deps_test.go b/src/go/build/deps_test.go
index 1b93348edb..9cdfb898ba 100644
--- a/src/go/build/deps_test.go
+++ b/src/go/build/deps_test.go
@@ -503,7 +503,7 @@ var depsRules = `
 	FMT, flag, math/rand
 	< testing/quick;
 
-	FMT, flag, runtime/debug, runtime/trace, internal/sysinfo
+	FMT, flag, runtime/debug, runtime/trace, internal/sysinfo, math/rand
 	< testing;
 
 	internal/testlog, runtime/pprof, regexp
diff --git a/src/math/rand/export_test.go b/src/math/rand/export_test.go
new file mode 100644
index 0000000000..560010be6b
--- /dev/null
+++ b/src/math/rand/export_test.go
@@ -0,0 +1,17 @@
+// Copyright 2021 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 rand
+
+func Int31nForTest(r *Rand, n int32) int32 {
+	return r.int31n(n)
+}
+
+func GetNormalDistributionParameters() (float64, [128]uint32, [128]float32, [128]float32) {
+	return rn, kn, wn, fn
+}
+
+func GetExponentialDistributionParameters() (float64, [256]uint32, [256]float32, [256]float32) {
+	return re, ke, we, fe
+}
diff --git a/src/math/rand/race_test.go b/src/math/rand/race_test.go
index 186c7169d8..e7d103664b 100644
--- a/src/math/rand/race_test.go
+++ b/src/math/rand/race_test.go
@@ -2,9 +2,10 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package rand
+package rand_test
 
 import (
+	. "math/rand"
 	"sync"
 	"testing"
 )
diff --git a/src/math/rand/rand_test.go b/src/math/rand/rand_test.go
index e037aaed0e..462de8b73b 100644
--- a/src/math/rand/rand_test.go
+++ b/src/math/rand/rand_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package rand
+package rand_test
 
 import (
 	"bytes"
@@ -11,6 +11,7 @@ import (
 	"internal/testenv"
 	"io"
 	"math"
+	. "math/rand"
 	"os"
 	"runtime"
 	"testing"
@@ -21,6 +22,9 @@ const (
 	numTestSamples = 10000
 )
 
+var rn, kn, wn, fn = GetNormalDistributionParameters()
+var re, ke, we, fe = GetExponentialDistributionParameters()
+
 type statsResults struct {
 	mean        float64
 	stddev      float64
@@ -503,7 +507,7 @@ func TestUniformFactorial(t *testing.T) {
 				fn   func() int
 			}{
 				{name: "Int31n", fn: func() int { return int(r.Int31n(int32(nfact))) }},
-				{name: "int31n", fn: func() int { return int(r.int31n(int32(nfact))) }},
+				{name: "int31n", fn: func() int { return int(Int31nForTest(r, int32(nfact))) }},
 				{name: "Perm", fn: func() int { return encodePerm(r.Perm(n)) }},
 				{name: "Shuffle", fn: func() int {
 					// Generate permutation using Shuffle.
diff --git a/src/testing/testing.go b/src/testing/testing.go
index 1562eadef0..85a7fec65f 100644
--- a/src/testing/testing.go
+++ b/src/testing/testing.go
@@ -242,6 +242,7 @@ import (
 	"fmt"
 	"internal/race"
 	"io"
+	"math/rand"
 	"os"
 	"runtime"
 	"runtime/debug"
@@ -299,6 +300,7 @@ func Init() {
 	cpuListStr = flag.String("test.cpu", "", "comma-separated `list` of cpu counts to run each test with")
 	parallel = flag.Int("test.parallel", runtime.GOMAXPROCS(0), "run at most `n` tests in parallel")
 	testlog = flag.String("test.testlogfile", "", "write test action log to `file` (for use only by cmd/go)")
+	shuffle = flag.String("test.shuffle", "off", "randomize the execution order of tests and benchmarks")
 
 	initBenchmarkFlags()
 }
@@ -325,6 +327,7 @@ var (
 	timeout              *time.Duration
 	cpuListStr           *string
 	parallel             *int
+	shuffle              *string
 	testlog              *string
 
 	haveExamples bool // are there examples?
@@ -1456,6 +1459,25 @@ func (m *M) Run() (code int) {
 		return
 	}
 
+	if *shuffle != "off" {
+		var n int64
+		var err error
+		if *shuffle == "on" {
+			n = time.Now().UnixNano()
+		} else {
+			n, err = strconv.ParseInt(*shuffle, 10, 64)
+			if err != nil {
+				fmt.Fprintln(os.Stderr, `testing: -shuffle should be "off", "on", or a valid integer:`, err)
+				m.exitCode = 2
+				return
+			}
+		}
+		fmt.Println("-test.shuffle", n)
+		rng := rand.New(rand.NewSource(n))
+		rng.Shuffle(len(m.tests), func(i, j int) { m.tests[i], m.tests[j] = m.tests[j], m.tests[i] })
+		rng.Shuffle(len(m.benchmarks), func(i, j int) { m.benchmarks[i], m.benchmarks[j] = m.benchmarks[j], m.benchmarks[i] })
+	}
+
 	parseCpuList()
 
 	m.before()
-- 
GitLab


From 5b328c4a2fbae10ec10d233d691435fe0295fc39 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Wed, 28 Apr 2021 11:00:15 -0400
Subject: [PATCH 1821/2400] cmd/compile: use desired register only if it
 satisfies register mask

In the register allocator, if possible, we allocate a value to its
desired register (the ideal register for its next use). In some
cases the desired register does not satisfies the value's output
register mask. We should not use the register in this case.

In the following example, v33 is going to be returned as a
function result, so it is allocated to its desired register AX.
However, its Op cannot use AX as output, causing miscompilation.

v33 = CMOVQEQF <int> v24 v28 v29 : AX (~R0[int])
v35 = MakeResult <int,int,mem> v33 v26 v18
Ret v35

Change-Id: Id0f4f27c4b233ee297e83077e3c8494fe193e664
Reviewed-on: https://go-review.googlesource.com/c/go/+/314630
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/ssa/regalloc.go |  7 ++--
 test/abi/result_regalloc.go              | 46 ++++++++++++++++++++++++
 2 files changed, 51 insertions(+), 2 deletions(-)
 create mode 100644 test/abi/result_regalloc.go

diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go
index 8ddb3d045b..c81d5574fe 100644
--- a/src/cmd/compile/internal/ssa/regalloc.go
+++ b/src/cmd/compile/internal/ssa/regalloc.go
@@ -1493,9 +1493,9 @@ func (s *regAllocState) regalloc(f *Func) {
 					goto ok
 				}
 
-				// Try to move an input to the desired output.
+				// Try to move an input to the desired output, if allowed.
 				for _, r := range dinfo[idx].out {
-					if r != noRegister && m>>r&1 != 0 {
+					if r != noRegister && (m&regspec.outputs[0].regs)>>r&1 != 0 {
 						m = regMask(1) << r
 						args[0] = s.allocValToReg(v.Args[0], m, true, v.Pos)
 						// Note: we update args[0] so the instruction will
@@ -1569,6 +1569,9 @@ func (s *regAllocState) regalloc(f *Func) {
 						if !opcodeTable[v.Op].commutative {
 							// Output must use the same register as input 0.
 							r := register(s.f.getHome(args[0].ID).(*Register).num)
+							if mask>>r&1 == 0 {
+								s.f.Fatalf("resultInArg0 value's input %v cannot be an output of %s", s.f.getHome(args[0].ID).(*Register), v.LongString())
+							}
 							mask = regMask(1) << r
 						} else {
 							// Output must use the same register as input 0 or 1.
diff --git a/test/abi/result_regalloc.go b/test/abi/result_regalloc.go
new file mode 100644
index 0000000000..58aecad970
--- /dev/null
+++ b/test/abi/result_regalloc.go
@@ -0,0 +1,46 @@
+// run
+
+// Copyright 2021 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.
+
+// Bug: in (*bb).d, the value to be returned was not allocated to
+// a register that satisfies its register mask.
+
+package main
+
+type bb struct {
+	r float64
+	x []float64
+}
+
+//go:noinline
+func B(r float64, x []float64) I {
+	return bb{r, x}
+}
+
+func (b bb) d() (int, int) {
+	if b.r == 0 {
+		return 0, len(b.x)
+	}
+	return len(b.x), len(b.x)
+}
+
+type I interface { d() (int, int) }
+
+func D(r I) (int, int) { return r.d() }
+
+//go:noinline
+func F() (int, int) {
+	r := float64(1)
+	x := []float64{0, 1, 2}
+	b := B(r, x)
+	return D(b)
+}
+
+func main() {
+	x, y := F()
+	if x != 3 || y != 3 {
+		panic("FAIL")
+	}
+}
-- 
GitLab


From f893f35d9f7acc3bad32efeac693a44849b5e895 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 27 Apr 2021 16:54:58 -0400
Subject: [PATCH 1822/2400] go/types: split out function instantiation from
 index expr

This is a port of CL 308371 to go/types. The only meaningful change from
that CL is to use explicit return values in Checker.indexExpr, which I
felt was more readable. I made the same change in types2 to keep them in
sync

Change-Id: I3380c03fe49d3bf4167cadad305abe942785af19
Reviewed-on: https://go-review.googlesource.com/c/go/+/314432
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/types2/index.go |  6 +-
 src/go/types/call.go                     | 83 +++++++++++++-----------
 src/go/types/check.go                    | 27 ++++++++
 src/go/types/expr.go                     | 32 ++-------
 src/go/types/index.go                    | 24 ++++---
 5 files changed, 94 insertions(+), 78 deletions(-)

diff --git a/src/cmd/compile/internal/types2/index.go b/src/cmd/compile/internal/types2/index.go
index b30799d37c..d9a402f212 100644
--- a/src/cmd/compile/internal/types2/index.go
+++ b/src/cmd/compile/internal/types2/index.go
@@ -20,7 +20,7 @@ func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) (isFuncInst boo
 	switch x.mode {
 	case invalid:
 		check.use(e.Index)
-		return
+		return false
 
 	case typexpr:
 		// type instantiation
@@ -29,7 +29,7 @@ func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) (isFuncInst boo
 		if x.typ != Typ[Invalid] {
 			x.mode = typexpr
 		}
-		return
+		return false
 
 	case value:
 		if sig := asSignature(x.typ); sig != nil && len(sig.tparams) > 0 {
@@ -196,7 +196,7 @@ func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) (isFuncInst boo
 	}
 
 	check.index(index, length)
-	return
+	return false
 }
 
 func (check *Checker) sliceExpr(x *operand, e *syntax.SliceExpr) {
diff --git a/src/go/types/call.go b/src/go/types/call.go
index 4834bd02c1..e23bdb830d 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -14,7 +14,7 @@ import (
 	"unicode"
 )
 
-// funcInst type-checks a function instantiaton inst and returns the result in x.
+// funcInst type-checks a function instantiation inst and returns the result in x.
 // The operand x must be the evaluation of inst.X and its type must be a signature.
 func (check *Checker) funcInst(x *operand, inst *ast.IndexExpr) {
 	xlist := typeparams.UnpackExpr(inst.Index)
@@ -71,8 +71,16 @@ func (check *Checker) funcInst(x *operand, inst *ast.IndexExpr) {
 	x.expr = inst
 }
 
-func (check *Checker) call(x *operand, call *ast.CallExpr) exprKind {
-	check.exprOrType(x, call.Fun)
+func (check *Checker) callExpr(x *operand, call *ast.CallExpr) exprKind {
+	if iexpr, _ := call.Fun.(*ast.IndexExpr); iexpr != nil {
+		if check.indexExpr(x, iexpr) {
+			check.funcInst(x, iexpr)
+		}
+		x.expr = iexpr
+		check.record(x)
+	} else {
+		check.exprOrType(x, call.Fun)
+	}
 
 	switch x.mode {
 	case invalid:
@@ -121,49 +129,48 @@ func (check *Checker) call(x *operand, call *ast.CallExpr) exprKind {
 			check.hasCallOrRecv = true
 		}
 		return predeclaredFuncs[id].kind
+	}
 
-	default:
-		// function/method call
-		cgocall := x.mode == cgofunc
+	// ordinary function/method call
+	cgocall := x.mode == cgofunc
 
-		sig := asSignature(x.typ)
-		if sig == nil {
-			check.invalidOp(x, _InvalidCall, "cannot call non-function %s", x)
-			x.mode = invalid
-			x.expr = call
-			return statement
-		}
+	sig := asSignature(x.typ)
+	if sig == nil {
+		check.invalidOp(x, _InvalidCall, "cannot call non-function %s", x)
+		x.mode = invalid
+		x.expr = call
+		return statement
+	}
 
-		// evaluate arguments
-		args, _ := check.exprList(call.Args, false)
-		sig = check.arguments(call, sig, args)
+	// evaluate arguments
+	args, _ := check.exprList(call.Args, false)
+	sig = check.arguments(call, sig, args)
 
-		// determine result
-		switch sig.results.Len() {
-		case 0:
-			x.mode = novalue
-		case 1:
-			if cgocall {
-				x.mode = commaerr
-			} else {
-				x.mode = value
-			}
-			x.typ = sig.results.vars[0].typ // unpack tuple
-		default:
+	// determine result
+	switch sig.results.Len() {
+	case 0:
+		x.mode = novalue
+	case 1:
+		if cgocall {
+			x.mode = commaerr
+		} else {
 			x.mode = value
-			x.typ = sig.results
-		}
-		x.expr = call
-		check.hasCallOrRecv = true
-
-		// if type inference failed, a parametrized result must be invalidated
-		// (operands cannot have a parametrized type)
-		if x.mode == value && len(sig.tparams) > 0 && isParameterized(sig.tparams, x.typ) {
-			x.mode = invalid
 		}
+		x.typ = sig.results.vars[0].typ // unpack tuple
+	default:
+		x.mode = value
+		x.typ = sig.results
+	}
+	x.expr = call
+	check.hasCallOrRecv = true
 
-		return statement
+	// if type inference failed, a parametrized result must be invalidated
+	// (operands cannot have a parametrized type)
+	if x.mode == value && len(sig.tparams) > 0 && isParameterized(sig.tparams, x.typ) {
+		x.mode = invalid
 	}
+
+	return statement
 }
 
 func (check *Checker) exprList(elist []ast.Expr, allowCommaOk bool) (xlist []*operand, commaOk bool) {
diff --git a/src/go/types/check.go b/src/go/types/check.go
index 4053fe2f4a..83568c9353 100644
--- a/src/go/types/check.go
+++ b/src/go/types/check.go
@@ -308,6 +308,33 @@ func (check *Checker) processDelayed(top int) {
 	check.delayed = check.delayed[:top]
 }
 
+func (check *Checker) record(x *operand) {
+	// convert x into a user-friendly set of values
+	// TODO(gri) this code can be simplified
+	var typ Type
+	var val constant.Value
+	switch x.mode {
+	case invalid:
+		typ = Typ[Invalid]
+	case novalue:
+		typ = (*Tuple)(nil)
+	case constant_:
+		typ = x.typ
+		val = x.val
+	default:
+		typ = x.typ
+	}
+	assert(x.expr != nil && typ != nil)
+
+	if isUntyped(typ) {
+		// delay type and value recording until we know the type
+		// or until the end of type checking
+		check.rememberUntyped(x.expr, false, x.mode, typ.(*Basic), val)
+	} else {
+		check.recordTypeAndValue(x.expr, x.mode, typ, val)
+	}
+}
+
 func (check *Checker) recordUntyped() {
 	if !debug && check.Types == nil {
 		return // nothing to do
diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index bdab7d9aa6..4055cdd080 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -1027,31 +1027,7 @@ func (check *Checker) rawExpr(x *operand, e ast.Expr, hint Type) exprKind {
 	}
 
 	kind := check.exprInternal(x, e, hint)
-
-	// convert x into a user-friendly set of values
-	// TODO(gri) this code can be simplified
-	var typ Type
-	var val constant.Value
-	switch x.mode {
-	case invalid:
-		typ = Typ[Invalid]
-	case novalue:
-		typ = (*Tuple)(nil)
-	case constant_:
-		typ = x.typ
-		val = x.val
-	default:
-		typ = x.typ
-	}
-	assert(x.expr != nil && typ != nil)
-
-	if isUntyped(typ) {
-		// delay type and value recording until we know the type
-		// or until the end of type checking
-		check.rememberUntyped(x.expr, false, x.mode, typ.(*Basic), val)
-	} else {
-		check.recordTypeAndValue(e, x.mode, typ, val)
-	}
+	check.record(x)
 
 	return kind
 }
@@ -1340,7 +1316,9 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 		check.selector(x, e)
 
 	case *ast.IndexExpr:
-		check.indexExpr(x, e)
+		if check.indexExpr(x, e) {
+			check.funcInst(x, e)
+		}
 		if x.mode == invalid {
 			goto Error
 		}
@@ -1378,7 +1356,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 		x.typ = T
 
 	case *ast.CallExpr:
-		return check.call(x, e)
+		return check.callExpr(x, e)
 
 	case *ast.StarExpr:
 		check.exprOrType(x, e.X)
diff --git a/src/go/types/index.go b/src/go/types/index.go
index f497b06dad..f51c3f6acf 100644
--- a/src/go/types/index.go
+++ b/src/go/types/index.go
@@ -12,27 +12,30 @@ import (
 	"go/internal/typeparams"
 )
 
-func (check *Checker) indexExpr(x *operand, e *ast.IndexExpr) {
+// If e is a valid function instantiation, indexExpr returns true.
+// In that case x represents the uninstantiated function value and
+// it is the caller's responsibility to instantiate the function.
+func (check *Checker) indexExpr(x *operand, e *ast.IndexExpr) (isFuncInst bool) {
 	check.exprOrType(x, e.X)
-	if x.mode == invalid {
+
+	switch x.mode {
+	case invalid:
 		check.use(typeparams.UnpackExpr(e.Index)...)
-		return
-	}
+		return false
 
-	if x.mode == typexpr {
+	case typexpr:
 		// type instantiation
 		x.mode = invalid
 		x.typ = check.varType(e)
 		if x.typ != Typ[Invalid] {
 			x.mode = typexpr
 		}
-		return
-	}
+		return false
 
-	if x.mode == value {
+	case value:
 		if sig := asSignature(x.typ); sig != nil && len(sig.tparams) > 0 {
-			check.funcInst(x, e)
-			return
+			// function instantiation
+			return true
 		}
 	}
 
@@ -181,6 +184,7 @@ func (check *Checker) indexExpr(x *operand, e *ast.IndexExpr) {
 	}
 
 	check.index(e.Index, length)
+	return false
 }
 
 func (check *Checker) sliceExpr(x *operand, e *ast.SliceExpr) {
-- 
GitLab


From 22a56b629d86508a36d1dd8b90124ccd9dc90e06 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Wed, 28 Apr 2021 11:47:49 -0400
Subject: [PATCH 1823/2400] cmd/go/internal/modload: in importFromModules, do
 not wrap module graph errors in ImportMissingError

If an error occurs in loading the module graph (such as a missing
checksum for a relevant go.mod file), that error should be terminal
and we should not look elsewhere to try to resolve the import. An
ImportMissingError instructs the caller to do exactly that, so don't
use that error type for this case.

(This behavior is tested incidentally in a later CL in this stack.)

For #36460

Change-Id: I963e39cc7fbc457c12a626c1402c0be29203d23b
Reviewed-on: https://go-review.googlesource.com/c/go/+/314633
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modload/import.go | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/cmd/go/internal/modload/import.go b/src/cmd/go/internal/modload/import.go
index 1d321bb24b..4e62e61bb0 100644
--- a/src/cmd/go/internal/modload/import.go
+++ b/src/cmd/go/internal/modload/import.go
@@ -303,7 +303,11 @@ func importFromModules(ctx context.Context, path string, rs *Requirements) (m mo
 	} else {
 		mg, err = rs.Graph(ctx)
 		if err != nil {
-			return module.Version{}, "", &ImportMissingError{Path: path, QueryErr: err}
+			// We might be missing one or more transitive (implicit) dependencies from
+			// the module graph, so we can't return an ImportMissingError here — one
+			// of the missing modules might actually contain the package in question,
+			// in which case we shouldn't go looking for it in some new dependency.
+			return module.Version{}, "", err
 		}
 	}
 
-- 
GitLab


From a54762586fd7b91cb1a8b8bb404db87e6b976d59 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Daniel=20Mart=C3=AD?= <mvdan@mvdan.cc>
Date: Fri, 15 Jan 2021 23:10:48 +0000
Subject: [PATCH 1824/2400] cmd/gofmt: simplify arg handling
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

First, we can use flag.Args instead of flag.NArg and flag.Arg.

Second, just call filepath.WalkDir directly on each argument. We don't
need to check if each argument is a directory or not, since the function
will still work on regular files as expected.

To continue giving an error in the "gofmt does-not-exist.go" case, we
now need to return and handle errors from filepath.WalkDir, too.
Arguably, that should have always been the case.

While at it, I noticed that the printinf of the "diff" command did not
obey the "out" parameter. Fix that.

Finally, remove the code to ignore IsNotExist errors. It was added in CL
19301, though it didn't include tests and its reasoning is dubious.
Using gofmt on a directory treewhile another program is concurrently
editing or removing files is inherently racy. Hiding errors can hide
valid problems from the user, and such racy usages aren't supported.

Change-Id: I2e74cc04c53eeefb25231d804752b53562b97371
Reviewed-on: https://go-review.googlesource.com/c/go/+/284138
Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
Trust: Daniel Martí <mvdan@mvdan.cc>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/gofmt/gofmt.go | 29 ++++++++---------------------
 1 file changed, 8 insertions(+), 21 deletions(-)

diff --git a/src/cmd/gofmt/gofmt.go b/src/cmd/gofmt/gofmt.go
index 2793c2c2a4..fef86c941f 100644
--- a/src/cmd/gofmt/gofmt.go
+++ b/src/cmd/gofmt/gofmt.go
@@ -151,7 +151,7 @@ func processFile(filename string, in io.Reader, out io.Writer, stdin bool) error
 			if err != nil {
 				return fmt.Errorf("computing diff: %s", err)
 			}
-			fmt.Printf("diff -u %s %s\n", filepath.ToSlash(filename+".orig"), filepath.ToSlash(filename))
+			fmt.Fprintf(out, "diff -u %s %s\n", filepath.ToSlash(filename+".orig"), filepath.ToSlash(filename))
 			out.Write(data)
 		}
 	}
@@ -164,21 +164,15 @@ func processFile(filename string, in io.Reader, out io.Writer, stdin bool) error
 }
 
 func visitFile(path string, f fs.DirEntry, err error) error {
-	if err == nil && isGoFile(f) {
-		err = processFile(path, nil, os.Stdout, false)
+	if err != nil || !isGoFile(f) {
+		return err
 	}
-	// Don't complain if a file was deleted in the meantime (i.e.
-	// the directory changed concurrently while running gofmt).
-	if err != nil && !os.IsNotExist(err) {
+	if err := processFile(path, nil, os.Stdout, false); err != nil {
 		report(err)
 	}
 	return nil
 }
 
-func walkDir(path string) {
-	filepath.WalkDir(path, visitFile)
-}
-
 func main() {
 	// call gofmtMain in a separate function
 	// so that it can use defer and have them
@@ -206,7 +200,8 @@ func gofmtMain() {
 	initParserMode()
 	initRewrite()
 
-	if flag.NArg() == 0 {
+	args := flag.Args()
+	if len(args) == 0 {
 		if *write {
 			fmt.Fprintln(os.Stderr, "error: cannot use -w with standard input")
 			exitCode = 2
@@ -218,17 +213,9 @@ func gofmtMain() {
 		return
 	}
 
-	for i := 0; i < flag.NArg(); i++ {
-		path := flag.Arg(i)
-		switch dir, err := os.Stat(path); {
-		case err != nil:
+	for _, arg := range args {
+		if err := filepath.WalkDir(arg, visitFile); err != nil {
 			report(err)
-		case dir.IsDir():
-			walkDir(path)
-		default:
-			if err := processFile(path, nil, os.Stdout, false); err != nil {
-				report(err)
-			}
 		}
 	}
 }
-- 
GitLab


From 90614ff46236e970acbcb3645edd03186718667a Mon Sep 17 00:00:00 2001
From: Jeff Widman <jeff@jeffwidman.com>
Date: Wed, 28 Apr 2021 17:21:43 +0000
Subject: [PATCH 1825/2400] cmd/go/internal/modfetch: fix comment that mentions
 no-longer returned error

In c9211577eb77df9c51f0565f1da7d20ff91d59df @bcmills removed the returned error from
`Lookup`. However, the function docstring still mentions that this can return an error.

So this corrects the docs.

Change-Id: Idca74a200dfdb024e3d7ff6c439c70632cfec11a
GitHub-Last-Rev: 62eaacf70c3886d8aba25b79212c61485a89fde0
GitHub-Pull-Request: golang/go#45822
Reviewed-on: https://go-review.googlesource.com/c/go/+/314572
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/internal/modfetch/repo.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/cmd/go/internal/modfetch/repo.go b/src/cmd/go/internal/modfetch/repo.go
index 20469c5432..0bffa55af6 100644
--- a/src/cmd/go/internal/modfetch/repo.go
+++ b/src/cmd/go/internal/modfetch/repo.go
@@ -183,7 +183,8 @@ type lookupCacheKey struct {
 // from its origin, and "noproxy" indicates that the patch should be fetched
 // directly only if GONOPROXY matches the given path.
 //
-// For the distinguished proxy "off", Lookup always returns a non-nil error.
+// For the distinguished proxy "off", Lookup always returns a Repo that returns
+// a non-nil error for every method call.
 //
 // A successful return does not guarantee that the module
 // has any defined versions.
-- 
GitLab


From ea65a12f895ce67ee6fd843b9cee97d42f6ad0b4 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 27 Apr 2021 12:12:01 -0700
Subject: [PATCH 1826/2400] cmd/compile/internal/types2: catch unexpected
 expression lists

This is a modified port of the https://golang.org/cl/313909
change for go/types.

- add catch-all cases for unexpected expression lists
- add Checker.singleIndex function to check single indices
- better syntax error handling in parser for invalid type
  instantiations that are missing a type argument

Change-Id: I6f0f396d637ad66b79f803d886fdc20ee55a98b3
Reviewed-on: https://go-review.googlesource.com/c/go/+/314409
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/syntax/parser.go     | 13 ++---
 src/cmd/compile/internal/types2/expr.go       |  6 ++
 .../internal/types2/fixedbugs/issue45635.go2  | 32 +++++++++++
 src/cmd/compile/internal/types2/index.go      | 55 +++++++++++++------
 .../internal/types2/testdata/typeinst.go2     |  6 +-
 5 files changed, 86 insertions(+), 26 deletions(-)
 create mode 100644 src/cmd/compile/internal/types2/fixedbugs/issue45635.go2

diff --git a/src/cmd/compile/internal/syntax/parser.go b/src/cmd/compile/internal/syntax/parser.go
index 80250212dd..e7b8840b33 100644
--- a/src/cmd/compile/internal/syntax/parser.go
+++ b/src/cmd/compile/internal/syntax/parser.go
@@ -1291,16 +1291,15 @@ func (p *parser) typeInstance(typ Expr) Expr {
 
 	pos := p.pos()
 	p.want(_Lbrack)
-	if p.tok == _Rbrack {
-		p.error("expecting type")
-		p.next()
-		return typ
-	}
-
 	x := new(IndexExpr)
 	x.pos = pos
 	x.X = typ
-	x.Index, _ = p.typeList()
+	if p.tok == _Rbrack {
+		p.syntaxError("expecting type")
+		x.Index = p.badExpr()
+	} else {
+		x.Index, _ = p.typeList()
+	}
 	p.want(_Rbrack)
 	return x
 }
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 8dbe6ea537..23b79656bb 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -508,6 +508,7 @@ func (check *Checker) updateExprType(x syntax.Expr, typ Type, final bool) {
 		*syntax.IndexExpr,
 		*syntax.SliceExpr,
 		*syntax.AssertExpr,
+		*syntax.ListExpr,
 		//*syntax.StarExpr,
 		*syntax.KeyValueExpr,
 		*syntax.ArrayType,
@@ -1410,6 +1411,11 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 	case *syntax.CallExpr:
 		return check.callExpr(x, e)
 
+	case *syntax.ListExpr:
+		// catch-all for unexpected expression lists
+		check.error(e, "unexpected list of expressions")
+		goto Error
+
 	// case *syntax.UnaryExpr:
 	// 	check.expr(x, e.X)
 	// 	if x.mode == invalid {
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue45635.go2 b/src/cmd/compile/internal/types2/fixedbugs/issue45635.go2
new file mode 100644
index 0000000000..65662cdc76
--- /dev/null
+++ b/src/cmd/compile/internal/types2/fixedbugs/issue45635.go2
@@ -0,0 +1,32 @@
+// Copyright 2021 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
+
+func main() {
+	some /* ERROR "undeclared name" */ [int, int]()
+}
+
+type N[T any] struct{}
+
+var _ N[] /* ERROR expecting type */
+
+type I interface {
+	type map[int]int, []int
+}
+
+func _[T I](i, j int) {
+	var m map[int]int
+	_ = m[i, j /* ERROR more than one index */ ]
+
+	var a [3]int
+	_ = a[i, j /* ERROR more than one index */ ]
+
+	var s []int
+	_ = s[i, j /* ERROR more than one index */ ]
+
+	var t T
+	// TODO(gri) fix multiple error below
+	_ = t[i, j /* ERROR more than one index */ /* ERROR more than one index */ ]
+}
diff --git a/src/cmd/compile/internal/types2/index.go b/src/cmd/compile/internal/types2/index.go
index d9a402f212..c94017a8fb 100644
--- a/src/cmd/compile/internal/types2/index.go
+++ b/src/cmd/compile/internal/types2/index.go
@@ -77,8 +77,13 @@ func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) (isFuncInst boo
 		x.typ = typ.elem
 
 	case *Map:
+		index := check.singleIndex(e)
+		if index == nil {
+			x.mode = invalid
+			return
+		}
 		var key operand
-		check.expr(&key, e.Index)
+		check.expr(&key, index)
 		check.assignment(&key, typ.key, "map index")
 		// ok to continue even if indexing failed - map element type is known
 		x.mode = mapindex
@@ -132,8 +137,13 @@ func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) (isFuncInst boo
 			// If there are maps, the index expression must be assignable
 			// to the map key type (as for simple map index expressions).
 			if nmaps > 0 {
+				index := check.singleIndex(e)
+				if index == nil {
+					x.mode = invalid
+					return
+				}
 				var key operand
-				check.expr(&key, e.Index)
+				check.expr(&key, index)
 				check.assignment(&key, tkey, "map index")
 				// ok to continue even if indexing failed - map element type is known
 
@@ -170,24 +180,12 @@ func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) (isFuncInst boo
 		return
 	}
 
-	if e.Index == nil {
-		check.errorf(e, invalidAST+"missing index for %s", x)
+	index := check.singleIndex(e)
+	if index == nil {
 		x.mode = invalid
 		return
 	}
 
-	index := e.Index
-	if l, _ := index.(*syntax.ListExpr); l != nil {
-		if n := len(l.ElemList); n <= 1 {
-			check.errorf(e, invalidAST+"invalid use of ListExpr for index expression %v with %d indices", e, n)
-			x.mode = invalid
-			return
-		}
-		// len(l.ElemList) > 1
-		check.error(l.ElemList[1], invalidOp+"more than one index")
-		index = l.ElemList[0] // continue with first index
-	}
-
 	// In pathological (invalid) cases (e.g.: type T1 [][[]T1{}[0][0]]T0)
 	// the element type may be accessed before it's set. Make sure we have
 	// a valid type.
@@ -310,6 +308,27 @@ L:
 	}
 }
 
+// singleIndex returns the (single) index from the index expression e.
+// If the index is missing, or if there are multiple indices, an error
+// is reported and the result is nil.
+func (check *Checker) singleIndex(e *syntax.IndexExpr) syntax.Expr {
+	index := e.Index
+	if index == nil {
+		check.errorf(e, invalidAST+"missing index for %s", e.X)
+		return nil
+	}
+	if l, _ := index.(*syntax.ListExpr); l != nil {
+		if n := len(l.ElemList); n <= 1 {
+			check.errorf(e, invalidAST+"invalid use of ListExpr for index expression %v with %d indices", e, n)
+			return nil
+		}
+		// len(l.ElemList) > 1
+		check.error(l.ElemList[1], invalidOp+"more than one index")
+		index = l.ElemList[0] // continue with first index
+	}
+	return index
+}
+
 // index checks an index expression for validity.
 // If max >= 0, it is the upper bound for index.
 // If the result typ is != Typ[Invalid], index is valid and typ is its (possibly named) integer type.
@@ -347,6 +366,10 @@ func (check *Checker) index(index syntax.Expr, max int64) (typ Type, val int64)
 	return x.typ, v
 }
 
+// isValidIndex checks whether operand x satisfies the criteria for integer
+// index values. If allowNegative is set, a constant operand may be negative.
+// If the operand is not valid, an error is reported (using what as context)
+// and the result is false.
 func (check *Checker) isValidIndex(x *operand, what string, allowNegative bool) bool {
 	if x.mode == invalid {
 		return false
diff --git a/src/cmd/compile/internal/types2/testdata/typeinst.go2 b/src/cmd/compile/internal/types2/testdata/typeinst.go2
index 6757cd57fd..0d628cb9d0 100644
--- a/src/cmd/compile/internal/types2/testdata/typeinst.go2
+++ b/src/cmd/compile/internal/types2/testdata/typeinst.go2
@@ -33,11 +33,11 @@ var _ A3
 var x int
 type _ x /* ERROR not a type */ [int]
 
-type _ int[] // ERROR expecting type
-type _ myInt[] // ERROR expecting type
+type _ int /* ERROR not a generic type */ [] // ERROR expecting type
+type _ myInt /* ERROR not a generic type */ [] // ERROR expecting type
 
 // TODO(gri) better error messages
-type _ T1 /* ERROR without instantiation */ [] // ERROR expecting type
+type _ T1[] // ERROR expecting type
 type _ T1[x /* ERROR not a type */ ]
 type _ T1 /* ERROR got 2 arguments but 1 type parameters */ [int, float32]
 
-- 
GitLab


From 42812a2feec29873aa6ee594d1355948e78e92a3 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 27 Apr 2021 12:54:39 -0700
Subject: [PATCH 1827/2400] types2: disambiguate package qualifiers in error
 messages

This is a port of the go/types CL https://golang.org/cl/313035
with minor adjustments (use of package syntax rather than go/ast).

Change-Id: I89410efb3d27be85fdbe827f966c2c91ee5693b5
Reviewed-on: https://go-review.googlesource.com/c/go/+/314410
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/check.go      | 21 ++++++--
 src/cmd/compile/internal/types2/errors.go     | 27 +++++++++-
 .../compile/internal/types2/issues_test.go    | 52 +++++++++++++++++--
 src/cmd/compile/internal/types2/resolver.go   |  6 ++-
 4 files changed, 94 insertions(+), 12 deletions(-)

diff --git a/src/cmd/compile/internal/types2/check.go b/src/cmd/compile/internal/types2/check.go
index c8ca118c3c..8d6cd1edab 100644
--- a/src/cmd/compile/internal/types2/check.go
+++ b/src/cmd/compile/internal/types2/check.go
@@ -87,7 +87,16 @@ type Checker struct {
 	impMap  map[importKey]*Package      // maps (import path, source directory) to (complete or fake) package
 	posMap  map[*Interface][]syntax.Pos // maps interface types to lists of embedded interface positions
 	typMap  map[string]*Named           // maps an instantiated named type hash to a *Named type
-	pkgCnt  map[string]int              // counts number of imported packages with a given name (for better error messages)
+
+	// pkgPathMap maps package names to the set of distinct import paths we've
+	// seen for that name, anywhere in the import graph. It is used for
+	// disambiguating package names in error messages.
+	//
+	// pkgPathMap is allocated lazily, so that we don't pay the price of building
+	// it on the happy path. seenPkgMap tracks the packages that we've already
+	// walked.
+	pkgPathMap map[string]map[string]bool
+	seenPkgMap map[*Package]bool
 
 	// information collected during type-checking of a set of package files
 	// (initialized by Files, valid only for the duration of check.Files;
@@ -181,7 +190,6 @@ func NewChecker(conf *Config, pkg *Package, info *Info) *Checker {
 		impMap:  make(map[importKey]*Package),
 		posMap:  make(map[*Interface][]syntax.Pos),
 		typMap:  make(map[string]*Named),
-		pkgCnt:  make(map[string]int),
 	}
 }
 
@@ -271,9 +279,6 @@ func (check *Checker) checkFiles(files []*syntax.File) (err error) {
 		print("== unusedImports ==")
 		check.unusedImports()
 	}
-	// no longer needed - release memory
-	check.imports = nil
-	check.dotImportMap = nil
 
 	print("== recordUntyped ==")
 	check.recordUntyped()
@@ -285,6 +290,12 @@ func (check *Checker) checkFiles(files []*syntax.File) (err error) {
 
 	check.pkg.complete = true
 
+	// no longer needed - release memory
+	check.imports = nil
+	check.dotImportMap = nil
+	check.pkgPathMap = nil
+	check.seenPkgMap = nil
+
 	// TODO(gri) There's more memory we should release at this point.
 
 	return
diff --git a/src/cmd/compile/internal/types2/errors.go b/src/cmd/compile/internal/types2/errors.go
index d66528a8fd..af4ecb2300 100644
--- a/src/cmd/compile/internal/types2/errors.go
+++ b/src/cmd/compile/internal/types2/errors.go
@@ -108,8 +108,13 @@ func sprintf(qf Qualifier, format string, args ...interface{}) string {
 func (check *Checker) qualifier(pkg *Package) string {
 	// Qualify the package unless it's the package being type-checked.
 	if pkg != check.pkg {
+		if check.pkgPathMap == nil {
+			check.pkgPathMap = make(map[string]map[string]bool)
+			check.seenPkgMap = make(map[*Package]bool)
+			check.markImports(pkg)
+		}
 		// If the same package name was used by multiple packages, display the full path.
-		if check.pkgCnt[pkg.name] > 1 {
+		if len(check.pkgPathMap[pkg.name]) > 1 {
 			return strconv.Quote(pkg.path)
 		}
 		return pkg.name
@@ -117,6 +122,26 @@ func (check *Checker) qualifier(pkg *Package) string {
 	return ""
 }
 
+// markImports recursively walks pkg and its imports, to record unique import
+// paths in pkgPathMap.
+func (check *Checker) markImports(pkg *Package) {
+	if check.seenPkgMap[pkg] {
+		return
+	}
+	check.seenPkgMap[pkg] = true
+
+	forName, ok := check.pkgPathMap[pkg.name]
+	if !ok {
+		forName = make(map[string]bool)
+		check.pkgPathMap[pkg.name] = forName
+	}
+	forName[pkg.path] = true
+
+	for _, imp := range pkg.imports {
+		check.markImports(imp)
+	}
+}
+
 func (check *Checker) sprintf(format string, args ...interface{}) string {
 	return sprintf(check.qualifier, format, args...)
 }
diff --git a/src/cmd/compile/internal/types2/issues_test.go b/src/cmd/compile/internal/types2/issues_test.go
index 643d6789b5..e716a48038 100644
--- a/src/cmd/compile/internal/types2/issues_test.go
+++ b/src/cmd/compile/internal/types2/issues_test.go
@@ -474,7 +474,7 @@ func TestIssue34151(t *testing.T) {
 	}
 
 	bast := mustParse(t, bsrc)
-	conf := Config{Importer: importHelper{a}}
+	conf := Config{Importer: importHelper{pkg: a}}
 	b, err := conf.Check(bast.PkgName.Value, []*syntax.File{bast}, nil)
 	if err != nil {
 		t.Errorf("package %s failed to typecheck: %v", b.Name(), err)
@@ -482,14 +482,18 @@ func TestIssue34151(t *testing.T) {
 }
 
 type importHelper struct {
-	pkg *Package
+	pkg      *Package
+	fallback Importer
 }
 
 func (h importHelper) Import(path string) (*Package, error) {
-	if path != h.pkg.Path() {
+	if path == h.pkg.Path() {
+		return h.pkg, nil
+	}
+	if h.fallback == nil {
 		return nil, fmt.Errorf("got package path %q; want %q", path, h.pkg.Path())
 	}
-	return h.pkg, nil
+	return h.fallback.Import(path)
 }
 
 // TestIssue34921 verifies that we don't update an imported type's underlying
@@ -513,7 +517,7 @@ func TestIssue34921(t *testing.T) {
 	var pkg *Package
 	for _, src := range sources {
 		f := mustParse(t, src)
-		conf := Config{Importer: importHelper{pkg}}
+		conf := Config{Importer: importHelper{pkg: pkg}}
 		res, err := conf.Check(f.PkgName.Value, []*syntax.File{f}, nil)
 		if err != nil {
 			t.Errorf("%q failed to typecheck: %v", src, err)
@@ -568,3 +572,41 @@ func TestIssue44515(t *testing.T) {
 		t.Errorf("got %q; want %q", got, want)
 	}
 }
+
+func TestIssue43124(t *testing.T) {
+	// All involved packages have the same name (template). Error messages should
+	// disambiguate between text/template and html/template by printing the full
+	// path.
+	const (
+		asrc = `package a; import "text/template"; func F(template.Template) {}; func G(int) {}`
+		bsrc = `package b; import ("a"; "html/template"); func _() { a.F(template.Template{}) }`
+		csrc = `package c; import ("a"; "html/template"); func _() { a.G(template.Template{}) }`
+	)
+
+	a, err := pkgFor("a", asrc, nil)
+	if err != nil {
+		t.Fatalf("package a failed to typecheck: %v", err)
+	}
+	conf := Config{Importer: importHelper{pkg: a, fallback: defaultImporter()}}
+
+	// Packages should be fully qualified when there is ambiguity within the
+	// error string itself.
+	bast := mustParse(t, bsrc)
+	_, err = conf.Check(bast.PkgName.Value, []*syntax.File{bast}, nil)
+	if err == nil {
+		t.Fatal("package b had no errors")
+	}
+	if !strings.Contains(err.Error(), "text/template") || !strings.Contains(err.Error(), "html/template") {
+		t.Errorf("type checking error for b does not disambiguate package template: %q", err)
+	}
+
+	// ...and also when there is any ambiguity in reachable packages.
+	cast := mustParse(t, csrc)
+	_, err = conf.Check(cast.PkgName.Value, []*syntax.File{cast}, nil)
+	if err == nil {
+		t.Fatal("package c had no errors")
+	}
+	if !strings.Contains(err.Error(), "html/template") {
+		t.Errorf("type checking error for c does not disambiguate package template: %q", err)
+	}
+}
diff --git a/src/cmd/compile/internal/types2/resolver.go b/src/cmd/compile/internal/types2/resolver.go
index 86eeb72b21..fa30650bd4 100644
--- a/src/cmd/compile/internal/types2/resolver.go
+++ b/src/cmd/compile/internal/types2/resolver.go
@@ -179,7 +179,11 @@ func (check *Checker) importPackage(pos syntax.Pos, path, dir string) *Package {
 	// package should be complete or marked fake, but be cautious
 	if imp.complete || imp.fake {
 		check.impMap[key] = imp
-		check.pkgCnt[imp.name]++
+		// Once we've formatted an error message once, keep the pkgPathMap
+		// up-to-date on subsequent imports.
+		if check.pkgPathMap != nil {
+			check.markImports(imp)
+		}
 		return imp
 	}
 
-- 
GitLab


From 764f53eb6ccc55ad52ddfeed47485de76f4453bb Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 27 Apr 2021 18:05:20 -0700
Subject: [PATCH 1828/2400] spec: clarify conditions for switch expression type

1. The existing prose implied that a switch expression type must
   be comparable because it is tested for equality against all case
   expressions. But for an empty switch (no case expressions), it
   was not clear if the switch expression needed to be comparable.
   Require it to match the behavior of compiler and type checkers.

2. While making this change, remove redundant language explaining
   what happens with untyped boolean switch expression values: the
   default type of an untyped boolean value is bool, this is already
   covered by the first part of the relevant sentence.

Fixes #43200.

Change-Id: Id8e0f29cfa8722b57cd2b7b58cba85b58c5f842b
Reviewed-on: https://go-review.googlesource.com/c/go/+/314411
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Rob Pike <r@golang.org>
---
 doc/go_spec.html | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index 95bf7d30f8..e59b3554f2 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1,6 +1,6 @@
 <!--{
 	"Title": "The Go Programming Language Specification",
-	"Subtitle": "Version of Apr 21, 2021",
+	"Subtitle": "Version of Apr 28, 2021",
 	"Path": "/ref/spec"
 }-->
 
@@ -4953,9 +4953,9 @@ ExprSwitchCase = "case" ExpressionList | "default" .
 
 <p>
 If the switch expression evaluates to an untyped constant, it is first implicitly
-<a href="#Conversions">converted</a> to its <a href="#Constants">default type</a>;
-if it is an untyped boolean value, it is first implicitly converted to type <code>bool</code>.
+<a href="#Conversions">converted</a> to its <a href="#Constants">default type</a>.
 The predeclared untyped value <code>nil</code> cannot be used as a switch expression.
+The switch expression type must be <a href="#Comparison_operators">comparable</a>.
 </p>
 
 <p>
-- 
GitLab


From ad989c7dbad8227a0e6944802f0557e625807bb2 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Wed, 28 Apr 2021 02:12:17 -0400
Subject: [PATCH 1829/2400] crypto/cipher: make AES-GCM benchmarks match
 ChaCha20Poly1305 ones
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

It's useful to compare TLS AEADs. Here are the numbers on my MacBook
with an Intel(R) Core(TM) i7-7920HQ CPU @ 3.10GHz.

name                            speed
AESGCM/Open-128-64-8             692MB/s ± 2%
AESGCM/Seal-128-64-8             568MB/s ± 1%
AESGCM/Open-128-1350-8          3.96GB/s ± 1%
AESGCM/Seal-128-1350-8          3.17GB/s ± 4%
AESGCM/Open-128-8192-8          5.46GB/s ± 2%
AESGCM/Seal-128-8192-8          4.40GB/s ± 3%

name                            speed
AESGCM/Open-256-64-8             602MB/s ± 2%
AESGCM/Seal-256-64-8             508MB/s ± 1%
AESGCM/Open-256-1350-8          3.06GB/s ± 1%
AESGCM/Seal-256-1350-8          2.65GB/s ± 2%
AESGCM/Open-256-8192-8          4.02GB/s ± 3%
AESGCM/Seal-256-8192-8          3.53GB/s ± 2%

name                            speed
Chacha20Poly1305/Open-64-8       385MB/s ± 3%
Chacha20Poly1305/Seal-64-8       396MB/s ± 3%
Chacha20Poly1305/Open-1350-8    1.67GB/s ± 2%
Chacha20Poly1305/Seal-1350-8    1.62GB/s ± 1%
Chacha20Poly1305/Open-8192-8    2.04GB/s ± 2%
Chacha20Poly1305/Seal-8192-8    2.04GB/s ± 3%

Change-Id: I9373ab85bf132b45b41078205259100fa2d46dda
Reviewed-on: https://go-review.googlesource.com/c/go/+/314610
Trust: Filippo Valsorda <filippo@golang.org>
Run-TryBot: Filippo Valsorda <filippo@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Roland Shoemaker <roland@golang.org>
---
 src/crypto/cipher/benchmark_test.go | 68 +++++++++++------------------
 1 file changed, 26 insertions(+), 42 deletions(-)

diff --git a/src/crypto/cipher/benchmark_test.go b/src/crypto/cipher/benchmark_test.go
index 90d0cd7138..eb02cd08c5 100644
--- a/src/crypto/cipher/benchmark_test.go
+++ b/src/crypto/cipher/benchmark_test.go
@@ -7,28 +7,15 @@ package cipher_test
 import (
 	"crypto/aes"
 	"crypto/cipher"
+	"strconv"
 	"testing"
 )
 
-func benchmarkAESGCMSign(b *testing.B, buf []byte) {
+func benchmarkAESGCMSeal(b *testing.B, buf []byte, keySize int) {
+	b.ReportAllocs()
 	b.SetBytes(int64(len(buf)))
 
-	var key [16]byte
-	var nonce [12]byte
-	aes, _ := aes.NewCipher(key[:])
-	aesgcm, _ := cipher.NewGCM(aes)
-	var out []byte
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		out = aesgcm.Seal(out[:0], nonce[:], nil, buf)
-	}
-}
-
-func benchmarkAESGCMSeal(b *testing.B, buf []byte) {
-	b.SetBytes(int64(len(buf)))
-
-	var key [16]byte
+	var key = make([]byte, keySize)
 	var nonce [12]byte
 	var ad [13]byte
 	aes, _ := aes.NewCipher(key[:])
@@ -41,44 +28,41 @@ func benchmarkAESGCMSeal(b *testing.B, buf []byte) {
 	}
 }
 
-func benchmarkAESGCMOpen(b *testing.B, buf []byte) {
+func benchmarkAESGCMOpen(b *testing.B, buf []byte, keySize int) {
+	b.ReportAllocs()
 	b.SetBytes(int64(len(buf)))
 
-	var key [16]byte
+	var key = make([]byte, keySize)
 	var nonce [12]byte
 	var ad [13]byte
 	aes, _ := aes.NewCipher(key[:])
 	aesgcm, _ := cipher.NewGCM(aes)
 	var out []byte
-	out = aesgcm.Seal(out[:0], nonce[:], buf, ad[:])
+
+	ct := aesgcm.Seal(nil, nonce[:], buf[:], ad[:])
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		_, err := aesgcm.Open(buf[:0], nonce[:], out, ad[:])
-		if err != nil {
-			b.Errorf("Open: %v", err)
-		}
+		out, _ = aesgcm.Open(out[:0], nonce[:], ct, ad[:])
 	}
 }
 
-func BenchmarkAESGCMSeal1K(b *testing.B) {
-	benchmarkAESGCMSeal(b, make([]byte, 1024))
-}
-
-func BenchmarkAESGCMOpen1K(b *testing.B) {
-	benchmarkAESGCMOpen(b, make([]byte, 1024))
-}
-
-func BenchmarkAESGCMSign8K(b *testing.B) {
-	benchmarkAESGCMSign(b, make([]byte, 8*1024))
-}
-
-func BenchmarkAESGCMSeal8K(b *testing.B) {
-	benchmarkAESGCMSeal(b, make([]byte, 8*1024))
-}
-
-func BenchmarkAESGCMOpen8K(b *testing.B) {
-	benchmarkAESGCMOpen(b, make([]byte, 8*1024))
+func BenchmarkAESGCM(b *testing.B) {
+	for _, length := range []int{64, 1350, 8 * 1024} {
+		b.Run("Open-128-"+strconv.Itoa(length), func(b *testing.B) {
+			benchmarkAESGCMOpen(b, make([]byte, length), 128/8)
+		})
+		b.Run("Seal-128-"+strconv.Itoa(length), func(b *testing.B) {
+			benchmarkAESGCMSeal(b, make([]byte, length), 128/8)
+		})
+
+		b.Run("Open-256-"+strconv.Itoa(length), func(b *testing.B) {
+			benchmarkAESGCMOpen(b, make([]byte, length), 256/8)
+		})
+		b.Run("Seal-256-"+strconv.Itoa(length), func(b *testing.B) {
+			benchmarkAESGCMSeal(b, make([]byte, length), 256/8)
+		})
+	}
 }
 
 func benchmarkAESStream(b *testing.B, mode func(cipher.Block, []byte) cipher.Stream, buf []byte) {
-- 
GitLab


From 1e235cd454b58f5ae26cac2a41e8ec131312ac6b Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Tue, 27 Apr 2021 22:52:56 -0400
Subject: [PATCH 1830/2400] go/types: use combined type and ordinary args for
 type inference

This is a port of CL 308372 to go/types. The only meaningful change was
to add TODOs to improve the positioning error messages.

Change-Id: I8314615d0851a59c2b5fd30eb897d581652eacc3
Reviewed-on: https://go-review.googlesource.com/c/go/+/314435
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/builtins.go              |  2 +-
 src/go/types/call.go                  | 37 ++++++++++++++++++++++++---
 src/go/types/fixedbugs/issue39754.go2 |  6 ++++-
 src/go/types/fixedbugs/issue44799.go2 | 20 +++++++++++++++
 src/go/types/testdata/issues.go2      |  5 ++--
 5 files changed, 62 insertions(+), 8 deletions(-)
 create mode 100644 src/go/types/fixedbugs/issue44799.go2

diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go
index 9c5a0b5842..739051cc61 100644
--- a/src/go/types/builtins.go
+++ b/src/go/types/builtins.go
@@ -130,7 +130,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 			arg(&x, i)
 			xlist = append(xlist, &x)
 		}
-		check.arguments(call, sig, xlist) // discard result (we know the result type)
+		check.arguments(call, sig, nil, xlist) // discard result (we know the result type)
 		// ok to continue even if check.arguments reported errors
 
 		x.mode = value
diff --git a/src/go/types/call.go b/src/go/types/call.go
index e23bdb830d..631ea426c6 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -72,9 +72,14 @@ func (check *Checker) funcInst(x *operand, inst *ast.IndexExpr) {
 }
 
 func (check *Checker) callExpr(x *operand, call *ast.CallExpr) exprKind {
+	var inst *ast.IndexExpr
 	if iexpr, _ := call.Fun.(*ast.IndexExpr); iexpr != nil {
 		if check.indexExpr(x, iexpr) {
-			check.funcInst(x, iexpr)
+			// Delay function instantiation to argument checking,
+			// where we combine type and value arguments for type
+			// inference.
+			assert(x.mode == value)
+			inst = iexpr
 		}
 		x.expr = iexpr
 		check.record(x)
@@ -142,9 +147,33 @@ func (check *Checker) callExpr(x *operand, call *ast.CallExpr) exprKind {
 		return statement
 	}
 
+	// evaluate type arguments, if any
+	var targs []Type
+	if inst != nil {
+		xlist := typeparams.UnpackExpr(inst.Index)
+		targs = check.typeList(xlist)
+		if targs == nil {
+			check.use(call.Args...)
+			x.mode = invalid
+			x.expr = call
+			return statement
+		}
+		assert(len(targs) == len(xlist))
+
+		// check number of type arguments (got) vs number of type parameters (want)
+		got, want := len(targs), len(sig.tparams)
+		if got > want {
+			check.errorf(xlist[want], _Todo, "got %d type arguments but want %d", got, want)
+			check.use(call.Args...)
+			x.mode = invalid
+			x.expr = call
+			return statement
+		}
+	}
+
 	// evaluate arguments
 	args, _ := check.exprList(call.Args, false)
-	sig = check.arguments(call, sig, args)
+	sig = check.arguments(call, sig, targs, args)
 
 	// determine result
 	switch sig.results.Len() {
@@ -217,7 +246,7 @@ func (check *Checker) exprList(elist []ast.Expr, allowCommaOk bool) (xlist []*op
 	return
 }
 
-func (check *Checker) arguments(call *ast.CallExpr, sig *Signature, args []*operand) (rsig *Signature) {
+func (check *Checker) arguments(call *ast.CallExpr, sig *Signature, targs []Type, args []*operand) (rsig *Signature) {
 	rsig = sig
 
 	// TODO(gri) try to eliminate this extra verification loop
@@ -299,7 +328,7 @@ func (check *Checker) arguments(call *ast.CallExpr, sig *Signature, args []*oper
 	if len(sig.tparams) > 0 {
 		// TODO(gri) provide position information for targs so we can feed
 		//           it to the instantiate call for better error reporting
-		targs := check.infer(call, sig.tparams, nil, sigParams, args, true)
+		targs := check.infer(call, sig.tparams, targs, sigParams, args, true)
 		if targs == nil {
 			return // error already reported
 		}
diff --git a/src/go/types/fixedbugs/issue39754.go2 b/src/go/types/fixedbugs/issue39754.go2
index 2ed84dc8ab..4b4420d997 100644
--- a/src/go/types/fixedbugs/issue39754.go2
+++ b/src/go/types/fixedbugs/issue39754.go2
@@ -16,5 +16,9 @@ func f[V interface{}, A, B Box[V]]() {}
 
 func _() {
 	f[int, Optional[int], Optional[int]]()
-	// f[int, Optional[int], Optional /* ERROR does not satisfy Box */ [string]]()
+	_ = f[int, Optional[int], Optional /* ERROR does not satisfy Box */ [string]]
+	// TODO(gri) Provide better position information here.
+	//           See TODO in call.go, Checker.arguments.
+	// TODO(rFindley) Reconcile this error position with types2.
+	f /* ERROR does not satisfy Box */ [int, Optional[int], Optional[string]]()
 }
diff --git a/src/go/types/fixedbugs/issue44799.go2 b/src/go/types/fixedbugs/issue44799.go2
new file mode 100644
index 0000000000..33f2c9a25c
--- /dev/null
+++ b/src/go/types/fixedbugs/issue44799.go2
@@ -0,0 +1,20 @@
+// Copyright 2021 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
+
+func Map[F, T any](s []F, f func(F) T) []T { return nil }
+
+func Reduce[Elem1, Elem2 any](s []Elem1, initializer Elem2, f func(Elem2, Elem1) Elem2) Elem2 { var x Elem2; return x }
+
+func main() {
+	var s []int
+	var f1 func(int) float64
+	var f2 func(float64, int) float64
+	_ = Map[int](s, f1)
+	_ = Map(s, f1)
+	_ = Reduce[int](s, 0, f2)
+	_ = Reduce(s, 0, f2)
+}
+
diff --git a/src/go/types/testdata/issues.go2 b/src/go/types/testdata/issues.go2
index 2d4bb32c4b..8994164eac 100644
--- a/src/go/types/testdata/issues.go2
+++ b/src/go/types/testdata/issues.go2
@@ -26,7 +26,7 @@ func _() {
 
 // If we have a receiver of pointer type (below: *T) we must ignore
 // the pointer in the implementation of the method lookup because
-// the type bound of T is an interface an pointer to interface types
+// the type bound of T is an interface and pointer to interface types
 // have no methods and then the lookup would fail.
 type C[T any] interface {
     m()
@@ -55,7 +55,8 @@ func (T) m1()
 func (*T) m2()
 
 func _() {
-	f2[T /* ERROR wrong method signature */]()
+	// TODO(rFindley) this error should be positioned on the 'T'.
+	f2 /* ERROR wrong method signature */ [T]()
 	f2[*T]()
 }
 
-- 
GitLab


From 168dd4e6aa8ad375748ade7613f2f75d6ef4204f Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 28 Apr 2021 09:54:56 -0400
Subject: [PATCH 1831/2400] go/types: add example test for type inference

This is a port of CL 308973. The only change is to remove a TODO at
inference.go2:100 to improve the error position. The go/types error
position is fine.

Change-Id: Ibf61f3458adde91dec9c7531cbd892ca654a5497
Reviewed-on: https://go-review.googlesource.com/c/go/+/314593
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/examples/inference.go2 | 101 ++++++++++++++++++++++++++++
 1 file changed, 101 insertions(+)
 create mode 100644 src/go/types/examples/inference.go2

diff --git a/src/go/types/examples/inference.go2 b/src/go/types/examples/inference.go2
new file mode 100644
index 0000000000..b4f3369aa0
--- /dev/null
+++ b/src/go/types/examples/inference.go2
@@ -0,0 +1,101 @@
+// Copyright 2021 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.
+
+// This file shows some examples of type inference.
+
+package p
+
+type Ordered interface {
+	type int, float64, string
+}
+
+func min[T Ordered](x, y T) T
+
+func _() {
+	// min can be called with explicit instantiation.
+	_ = min[int](1, 2)
+
+	// Alternatively, the type argument can be inferred from
+	// one of the arguments. Untyped arguments will be considered
+	// last.
+	var x int
+	_ = min(x, x)
+	_ = min(x, 1)
+	_ = min(x, 1.0)
+	_ = min(1, 2)
+	_ = min(1, 2.3 /* ERROR default type float64 .* does not match */ )
+
+	var y float64
+	_ = min(1, y)
+	_ = min(1.2, y)
+	_ = min(1.2, 3.4)
+	_ = min(1.2, 3 /* ERROR default type int .* does not match */ )
+
+	var s string
+	_ = min(s, "foo")
+	_ = min("foo", "bar")
+}
+
+func mixed[T1, T2, T3 any](T1, T2, T3)
+
+func _() {
+	// mixed can be called with explicit instantiation.
+	mixed[int, string, bool](0, "", false)
+
+	// Alternatively, partial type arguments may be provided
+	// (from left to right), and the other may be inferred.
+	mixed[int, string](0, "", false)
+	mixed[int](0, "", false)
+	mixed(0, "", false)
+
+	// Provided type arguments always take precedence over
+	// inferred types.
+	mixed[int, string](1.1 /* ERROR cannot use 1.1 */ , "", false)
+}
+
+func related1[Slice interface{type []Elem}, Elem any](s Slice, e Elem)
+
+func _() {
+	// related1 can be called with explicit instantiation.
+	var si []int
+	related1[[]int, int](si, 0)
+
+	// Alternatively, the 2nd type argument can be inferred
+	// from the first one through constraint type inference.
+	var ss []string
+	_ = related1[[]string]
+	related1[[]string](ss, "foo")
+
+	// A type argument inferred from another explicitly provided
+	// type argument overrides whatever value argument type is given.
+	related1[[]string](ss, 0 /* ERROR cannot use 0 */ )
+
+	// A type argument may be inferred from a value argument
+	// and then help infer another type argument via constraint
+	// type inference.
+	related1(si, 0)
+	related1(si, "foo" /* ERROR cannot use "foo" */ )
+}
+
+func related2[Elem any, Slice interface{type []Elem}](e Elem, s Slice)
+
+func _() {
+	// related2 can be called with explicit instantiation.
+	var si []int
+	related2[int, []int](0, si)
+
+	// Alternatively, the 2nd type argument can be inferred
+	// from the first one through constraint type inference.
+	var ss []string
+	_ = related2[string]
+	related2[string]("foo", ss)
+
+	// A type argument may be inferred from a value argument
+	// and then help infer another type argument via constraint
+	// type inference. Untyped arguments are always considered
+	// last.
+	related2(1.2, []float64{})
+	related2(1.0, []int{})
+	related2 /* ERROR does not satisfy */ (float64(1.0), []int{})
+}
-- 
GitLab


From 07e006dd9322cc484303e1bef3d58c7e51d4f92c Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 28 Apr 2021 10:02:16 -0400
Subject: [PATCH 1832/2400] go/types: use a global atomic counter for type
 parameter ids

This is a 1:1 port of CL 309830 to go/types.

Change-Id: Ibf709f8194dd5e93a87145e5f9db674ce93af529
Reviewed-on: https://go-review.googlesource.com/c/go/+/314594
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/api_test.go   |  1 +
 src/go/types/check.go      |  2 --
 src/go/types/type.go       | 13 +++++++++++--
 src/go/types/types_test.go | 13 +++++++++++++
 4 files changed, 25 insertions(+), 4 deletions(-)
 create mode 100644 src/go/types/types_test.go

diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go
index 3438d79024..5ac91bedd2 100644
--- a/src/go/types/api_test.go
+++ b/src/go/types/api_test.go
@@ -353,6 +353,7 @@ func TestTypesInfo(t *testing.T) {
 	}
 
 	for _, test := range tests {
+		ResetId() // avoid renumbering of type parameter ids when adding tests
 		if strings.HasPrefix(test.src, genericPkg) && !typeparams.Enabled {
 			continue
 		}
diff --git a/src/go/types/check.go b/src/go/types/check.go
index 83568c9353..1f64d3e3c3 100644
--- a/src/go/types/check.go
+++ b/src/go/types/check.go
@@ -86,7 +86,6 @@ type Checker struct {
 	pkg  *Package
 	*Info
 	version version                    // accepted language version
-	nextId  uint64                     // unique Id for type parameters (first valid Id is 1)
 	objMap  map[Object]*declInfo       // maps package-level objects and (non-interface) methods to declaration info
 	impMap  map[importKey]*Package     // maps (import path, source directory) to (complete or fake) package
 	posMap  map[*Interface][]token.Pos // maps interface types to lists of embedded interface positions
@@ -191,7 +190,6 @@ func NewChecker(conf *Config, fset *token.FileSet, pkg *Package, info *Info) *Ch
 		pkg:     pkg,
 		Info:    info,
 		version: version,
-		nextId:  1,
 		objMap:  make(map[Object]*declInfo),
 		impMap:  make(map[importKey]*Package),
 		posMap:  make(map[*Interface][]token.Pos),
diff --git a/src/go/types/type.go b/src/go/types/type.go
index 21d49de3aa..3303cfc077 100644
--- a/src/go/types/type.go
+++ b/src/go/types/type.go
@@ -7,6 +7,7 @@ package types
 import (
 	"fmt"
 	"go/token"
+	"sync/atomic"
 )
 
 // A Type represents a type of Go.
@@ -715,6 +716,15 @@ func (t *Named) AddMethod(m *Func) {
 	}
 }
 
+// Note: This is a uint32 rather than a uint64 because the
+// respective 64 bit atomic instructions are not available
+// on all platforms.
+var lastId uint32
+
+// nextId returns a value increasing monotonically by 1 with
+// each call, starting with 1. It may be called concurrently.
+func nextId() uint64 { return uint64(atomic.AddUint32(&lastId, 1)) }
+
 // A _TypeParam represents a type parameter type.
 type _TypeParam struct {
 	check *Checker  // for lazy type bound completion
@@ -727,8 +737,7 @@ type _TypeParam struct {
 // newTypeParam returns a new TypeParam.
 func (check *Checker) newTypeParam(obj *TypeName, index int, bound Type) *_TypeParam {
 	assert(bound != nil)
-	typ := &_TypeParam{check: check, id: check.nextId, obj: obj, index: index, bound: bound}
-	check.nextId++
+	typ := &_TypeParam{check: check, id: nextId(), obj: obj, index: index, bound: bound}
 	if obj.typ == nil {
 		obj.typ = typ
 	}
diff --git a/src/go/types/types_test.go b/src/go/types/types_test.go
new file mode 100644
index 0000000000..fd9462c4a2
--- /dev/null
+++ b/src/go/types/types_test.go
@@ -0,0 +1,13 @@
+// Copyright 2021 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 types
+
+import "sync/atomic"
+
+// Upon calling ResetId, nextId starts with 1 again.
+// It may be called concurrently. This is only needed
+// for tests where we may want to have a consistent
+// numbering for each individual test case.
+func ResetId() { atomic.StoreUint32(&lastId, 0) }
-- 
GitLab


From b36596b14f8d3bee586479323c56b5db416a49e5 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Tue, 27 Apr 2021 16:04:56 -0700
Subject: [PATCH 1833/2400] runtime: move Windows time.now implementations into
 separate files

This is a step toward separating whether time.now is implemented in
assembly from whether we are using faketime.

Change-Id: I8bf059b44a103b034835e3d3b799319cc05e9552
Reviewed-on: https://go-review.googlesource.com/c/go/+/314273
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/sys_windows_386.s    | 75 ----------------------------
 src/runtime/sys_windows_amd64.s  | 46 -----------------
 src/runtime/sys_windows_arm.s    | 76 -----------------------------
 src/runtime/sys_windows_arm64.s  | 56 ---------------------
 src/runtime/time_windows_386.s   | 82 +++++++++++++++++++++++++++++++
 src/runtime/time_windows_amd64.s | 53 ++++++++++++++++++++
 src/runtime/time_windows_arm.s   | 84 ++++++++++++++++++++++++++++++++
 src/runtime/time_windows_arm64.s | 64 ++++++++++++++++++++++++
 8 files changed, 283 insertions(+), 253 deletions(-)
 create mode 100644 src/runtime/time_windows_386.s
 create mode 100644 src/runtime/time_windows_amd64.s
 create mode 100644 src/runtime/time_windows_arm.s
 create mode 100644 src/runtime/time_windows_arm64.s

diff --git a/src/runtime/sys_windows_386.s b/src/runtime/sys_windows_386.s
index d8b14eb644..64b12859ae 100644
--- a/src/runtime/sys_windows_386.s
+++ b/src/runtime/sys_windows_386.s
@@ -354,78 +354,3 @@ loop:
 useQPC:
 	JMP	runtime·nanotimeQPC(SB)
 	RET
-
-TEXT time·now(SB),NOSPLIT,$0-20
-	CMPB	runtime·useQPCTime(SB), $0
-	JNE	useQPC
-loop:
-	MOVL	(_INTERRUPT_TIME+time_hi1), AX
-	MOVL	(_INTERRUPT_TIME+time_lo), CX
-	MOVL	(_INTERRUPT_TIME+time_hi2), DI
-	CMPL	AX, DI
-	JNE	loop
-
-	// w = DI:CX
-	// multiply by 100
-	MOVL	$100, AX
-	MULL	CX
-	IMULL	$100, DI
-	ADDL	DI, DX
-	// w*100 = DX:AX
-	MOVL	AX, mono+12(FP)
-	MOVL	DX, mono+16(FP)
-
-wall:
-	MOVL	(_SYSTEM_TIME+time_hi1), CX
-	MOVL	(_SYSTEM_TIME+time_lo), AX
-	MOVL	(_SYSTEM_TIME+time_hi2), DX
-	CMPL	CX, DX
-	JNE	wall
-
-	// w = DX:AX
-	// convert to Unix epoch (but still 100ns units)
-	#define delta 116444736000000000
-	SUBL	$(delta & 0xFFFFFFFF), AX
-	SBBL $(delta >> 32), DX
-
-	// nano/100 = DX:AX
-	// split into two decimal halves by div 1e9.
-	// (decimal point is two spots over from correct place,
-	// but we avoid overflow in the high word.)
-	MOVL	$1000000000, CX
-	DIVL	CX
-	MOVL	AX, DI
-	MOVL	DX, SI
-
-	// DI = nano/100/1e9 = nano/1e11 = sec/100, DX = SI = nano/100%1e9
-	// split DX into seconds and nanoseconds by div 1e7 magic multiply.
-	MOVL	DX, AX
-	MOVL	$1801439851, CX
-	MULL	CX
-	SHRL	$22, DX
-	MOVL	DX, BX
-	IMULL	$10000000, DX
-	MOVL	SI, CX
-	SUBL	DX, CX
-
-	// DI = sec/100 (still)
-	// BX = (nano/100%1e9)/1e7 = (nano/1e9)%100 = sec%100
-	// CX = (nano/100%1e9)%1e7 = (nano%1e9)/100 = nsec/100
-	// store nsec for return
-	IMULL	$100, CX
-	MOVL	CX, nsec+8(FP)
-
-	// DI = sec/100 (still)
-	// BX = sec%100
-	// construct DX:AX = 64-bit sec and store for return
-	MOVL	$0, DX
-	MOVL	$100, AX
-	MULL	DI
-	ADDL	BX, AX
-	ADCL	$0, DX
-	MOVL	AX, sec+0(FP)
-	MOVL	DX, sec+4(FP)
-	RET
-useQPC:
-	JMP	runtime·nowQPC(SB)
-	RET
diff --git a/src/runtime/sys_windows_amd64.s b/src/runtime/sys_windows_amd64.s
index 868fd9d20f..e5e2083be2 100644
--- a/src/runtime/sys_windows_amd64.s
+++ b/src/runtime/sys_windows_amd64.s
@@ -361,52 +361,6 @@ useQPC:
 	JMP	runtime·nanotimeQPC(SB)
 	RET
 
-TEXT time·now(SB),NOSPLIT,$0-24
-	CMPB	runtime·useQPCTime(SB), $0
-	JNE	useQPC
-	MOVQ	$_INTERRUPT_TIME, DI
-loop:
-	MOVL	time_hi1(DI), AX
-	MOVL	time_lo(DI), BX
-	MOVL	time_hi2(DI), CX
-	CMPL	AX, CX
-	JNE	loop
-	SHLQ	$32, AX
-	ORQ	BX, AX
-	IMULQ	$100, AX
-	MOVQ	AX, mono+16(FP)
-
-	MOVQ	$_SYSTEM_TIME, DI
-wall:
-	MOVL	time_hi1(DI), AX
-	MOVL	time_lo(DI), BX
-	MOVL	time_hi2(DI), CX
-	CMPL	AX, CX
-	JNE	wall
-	SHLQ	$32, AX
-	ORQ	BX, AX
-	MOVQ	$116444736000000000, DI
-	SUBQ	DI, AX
-	IMULQ	$100, AX
-
-	// generated code for
-	//	func f(x uint64) (uint64, uint64) { return x/1000000000, x%100000000 }
-	// adapted to reduce duplication
-	MOVQ	AX, CX
-	MOVQ	$1360296554856532783, AX
-	MULQ	CX
-	ADDQ	CX, DX
-	RCRQ	$1, DX
-	SHRQ	$29, DX
-	MOVQ	DX, sec+0(FP)
-	IMULQ	$1000000000, DX
-	SUBQ	DX, CX
-	MOVL	CX, nsec+8(FP)
-	RET
-useQPC:
-	JMP	runtime·nowQPC(SB)
-	RET
-
 // func osSetupTLS(mp *m)
 // Setup TLS. for use by needm on Windows.
 TEXT runtime·osSetupTLS(SB),NOSPLIT,$0-8
diff --git a/src/runtime/sys_windows_arm.s b/src/runtime/sys_windows_arm.s
index 7676bc1ff8..189d2f6780 100644
--- a/src/runtime/sys_windows_arm.s
+++ b/src/runtime/sys_windows_arm.s
@@ -367,82 +367,6 @@ loop:
 useQPC:
 	B	runtime·nanotimeQPC(SB)		// tail call
 
-TEXT time·now(SB),NOSPLIT|NOFRAME,$0-20
-	MOVW    $0, R0
-	MOVB    runtime·useQPCTime(SB), R0
-	CMP	$0, R0
-	BNE	useQPC
-	MOVW	$_INTERRUPT_TIME, R3
-loop:
-	MOVW	time_hi1(R3), R1
-	MOVW	time_lo(R3), R0
-	MOVW	time_hi2(R3), R2
-	CMP	R1, R2
-	BNE	loop
-
-	// wintime = R1:R0, multiply by 100
-	MOVW	$100, R2
-	MULLU	R0, R2, (R4, R3)    // R4:R3 = R1:R0 * R2
-	MULA	R1, R2, R4, R4
-
-	// wintime*100 = R4:R3
-	MOVW	R3, mono+12(FP)
-	MOVW	R4, mono+16(FP)
-
-	MOVW	$_SYSTEM_TIME, R3
-wall:
-	MOVW	time_hi1(R3), R1
-	MOVW	time_lo(R3), R0
-	MOVW	time_hi2(R3), R2
-	CMP	R1, R2
-	BNE	wall
-
-	// w = R1:R0 in 100ns untis
-	// convert to Unix epoch (but still 100ns units)
-	#define delta 116444736000000000
-	SUB.S   $(delta & 0xFFFFFFFF), R0
-	SBC     $(delta >> 32), R1
-
-	// Convert to nSec
-	MOVW    $100, R2
-	MULLU   R0, R2, (R4, R3)    // R4:R3 = R1:R0 * R2
-	MULA    R1, R2, R4, R4
-	// w = R2:R1 in nSec
-	MOVW    R3, R1	      // R4:R3 -> R2:R1
-	MOVW    R4, R2
-
-	// multiply nanoseconds by reciprocal of 10**9 (scaled by 2**61)
-	// to get seconds (96 bit scaled result)
-	MOVW	$0x89705f41, R3		// 2**61 * 10**-9
-	MULLU	R1,R3,(R6,R5)		// R7:R6:R5 = R2:R1 * R3
-	MOVW	$0,R7
-	MULALU	R2,R3,(R7,R6)
-
-	// unscale by discarding low 32 bits, shifting the rest by 29
-	MOVW	R6>>29,R6		// R7:R6 = (R7:R6:R5 >> 61)
-	ORR	R7<<3,R6
-	MOVW	R7>>29,R7
-
-	// subtract (10**9 * sec) from nsec to get nanosecond remainder
-	MOVW	$1000000000, R5	// 10**9
-	MULLU	R6,R5,(R9,R8)   // R9:R8 = R7:R6 * R5
-	MULA	R7,R5,R9,R9
-	SUB.S	R8,R1		// R2:R1 -= R9:R8
-	SBC	R9,R2
-
-	// because reciprocal was a truncated repeating fraction, quotient
-	// may be slightly too small -- adjust to make remainder < 10**9
-	CMP	R5,R1	// if remainder > 10**9
-	SUB.HS	R5,R1   //    remainder -= 10**9
-	ADD.HS	$1,R6	//    sec += 1
-
-	MOVW	R6,sec_lo+0(FP)
-	MOVW	R7,sec_hi+4(FP)
-	MOVW	R1,nsec+8(FP)
-	RET
-useQPC:
-	B	runtime·nowQPC(SB)		// tail call
-
 // save_g saves the g register (R10) into thread local memory
 // so that we can call externally compiled
 // ARM code that will overwrite those registers.
diff --git a/src/runtime/sys_windows_arm64.s b/src/runtime/sys_windows_arm64.s
index aa9ea7ed98..33ac091e12 100644
--- a/src/runtime/sys_windows_arm64.s
+++ b/src/runtime/sys_windows_arm64.s
@@ -429,62 +429,6 @@ loop:
 useQPC:
 	B	runtime·nanotimeQPC(SB)		// tail call
 
-TEXT time·now(SB),NOSPLIT|NOFRAME,$0-24
-	MOVB    runtime·useQPCTime(SB), R0
-	CMP	$0, R0
-	BNE	useQPC
-	MOVD	$_INTERRUPT_TIME, R3
-loop:
-	MOVWU	time_hi1(R3), R1
-	MOVWU	time_lo(R3), R0
-	MOVWU	time_hi2(R3), R2
-	CMP	R1, R2
-	BNE	loop
-
-	// wintime = R1:R0, multiply by 100
-	ORR	R1<<32, R0
-	MOVD	$100, R1
-	MUL	R1, R0
-	MOVD	R0, mono+16(FP)
-
-	MOVD	$_SYSTEM_TIME, R3
-wall:
-	MOVWU	time_hi1(R3), R1
-	MOVWU	time_lo(R3), R0
-	MOVWU	time_hi2(R3), R2
-	CMP	R1, R2
-	BNE	wall
-
-	// w = R1:R0 in 100ns units
-	// convert to Unix epoch (but still 100ns units)
-	#define delta 116444736000000000
-	ORR	R1<<32, R0
-	SUB	$delta, R0
-
-	// Convert to nSec
-	MOVD	$100, R1
-	MUL	R1, R0
-
-	// Code stolen from compiler output for:
-	//
-	//	var x uint64
-	//	func f() (sec uint64, nsec uint32) { return x / 1000000000, uint32(x % 100000000) }
-	//
-	LSR	$1, R0, R1
-	MOVD	$-8543223759426509416, R2
-	UMULH	R2, R1, R1
-	LSR	$28, R1, R1
-	MOVD	R1, sec+0(FP)
-	MOVD	$-6067343680855748867, R1
-	UMULH	R0, R1, R1
-	LSR	$26, R1, R1
-	MOVD	$100000000, R2
-	MSUB	R1, R0, R2, R0
-	MOVW	R0, nsec+8(FP)
-	RET
-useQPC:
-	B	runtime·nowQPC(SB)		// tail call
-
 // This is called from rt0_go, which runs on the system stack
 // using the initial stack allocated by the OS.
 // It calls back into standard C using the BL below.
diff --git a/src/runtime/time_windows_386.s b/src/runtime/time_windows_386.s
new file mode 100644
index 0000000000..d1235c9414
--- /dev/null
+++ b/src/runtime/time_windows_386.s
@@ -0,0 +1,82 @@
+// Copyright 2009 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.
+
+#include "go_asm.h"
+#include "textflag.h"
+#include "time_windows.h"
+
+TEXT time·now(SB),NOSPLIT,$0-20
+	CMPB	runtime·useQPCTime(SB), $0
+	JNE	useQPC
+loop:
+	MOVL	(_INTERRUPT_TIME+time_hi1), AX
+	MOVL	(_INTERRUPT_TIME+time_lo), CX
+	MOVL	(_INTERRUPT_TIME+time_hi2), DI
+	CMPL	AX, DI
+	JNE	loop
+
+	// w = DI:CX
+	// multiply by 100
+	MOVL	$100, AX
+	MULL	CX
+	IMULL	$100, DI
+	ADDL	DI, DX
+	// w*100 = DX:AX
+	MOVL	AX, mono+12(FP)
+	MOVL	DX, mono+16(FP)
+
+wall:
+	MOVL	(_SYSTEM_TIME+time_hi1), CX
+	MOVL	(_SYSTEM_TIME+time_lo), AX
+	MOVL	(_SYSTEM_TIME+time_hi2), DX
+	CMPL	CX, DX
+	JNE	wall
+
+	// w = DX:AX
+	// convert to Unix epoch (but still 100ns units)
+	#define delta 116444736000000000
+	SUBL	$(delta & 0xFFFFFFFF), AX
+	SBBL $(delta >> 32), DX
+
+	// nano/100 = DX:AX
+	// split into two decimal halves by div 1e9.
+	// (decimal point is two spots over from correct place,
+	// but we avoid overflow in the high word.)
+	MOVL	$1000000000, CX
+	DIVL	CX
+	MOVL	AX, DI
+	MOVL	DX, SI
+
+	// DI = nano/100/1e9 = nano/1e11 = sec/100, DX = SI = nano/100%1e9
+	// split DX into seconds and nanoseconds by div 1e7 magic multiply.
+	MOVL	DX, AX
+	MOVL	$1801439851, CX
+	MULL	CX
+	SHRL	$22, DX
+	MOVL	DX, BX
+	IMULL	$10000000, DX
+	MOVL	SI, CX
+	SUBL	DX, CX
+
+	// DI = sec/100 (still)
+	// BX = (nano/100%1e9)/1e7 = (nano/1e9)%100 = sec%100
+	// CX = (nano/100%1e9)%1e7 = (nano%1e9)/100 = nsec/100
+	// store nsec for return
+	IMULL	$100, CX
+	MOVL	CX, nsec+8(FP)
+
+	// DI = sec/100 (still)
+	// BX = sec%100
+	// construct DX:AX = 64-bit sec and store for return
+	MOVL	$0, DX
+	MOVL	$100, AX
+	MULL	DI
+	ADDL	BX, AX
+	ADCL	$0, DX
+	MOVL	AX, sec+0(FP)
+	MOVL	DX, sec+4(FP)
+	RET
+useQPC:
+	JMP	runtime·nowQPC(SB)
+	RET
diff --git a/src/runtime/time_windows_amd64.s b/src/runtime/time_windows_amd64.s
new file mode 100644
index 0000000000..7d1fcfbcf5
--- /dev/null
+++ b/src/runtime/time_windows_amd64.s
@@ -0,0 +1,53 @@
+// Copyright 2011 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.
+
+#include "go_asm.h"
+#include "textflag.h"
+#include "time_windows.h"
+
+TEXT time·now(SB),NOSPLIT,$0-24
+	CMPB	runtime·useQPCTime(SB), $0
+	JNE	useQPC
+	MOVQ	$_INTERRUPT_TIME, DI
+loop:
+	MOVL	time_hi1(DI), AX
+	MOVL	time_lo(DI), BX
+	MOVL	time_hi2(DI), CX
+	CMPL	AX, CX
+	JNE	loop
+	SHLQ	$32, AX
+	ORQ	BX, AX
+	IMULQ	$100, AX
+	MOVQ	AX, mono+16(FP)
+
+	MOVQ	$_SYSTEM_TIME, DI
+wall:
+	MOVL	time_hi1(DI), AX
+	MOVL	time_lo(DI), BX
+	MOVL	time_hi2(DI), CX
+	CMPL	AX, CX
+	JNE	wall
+	SHLQ	$32, AX
+	ORQ	BX, AX
+	MOVQ	$116444736000000000, DI
+	SUBQ	DI, AX
+	IMULQ	$100, AX
+
+	// generated code for
+	//	func f(x uint64) (uint64, uint64) { return x/1000000000, x%100000000 }
+	// adapted to reduce duplication
+	MOVQ	AX, CX
+	MOVQ	$1360296554856532783, AX
+	MULQ	CX
+	ADDQ	CX, DX
+	RCRQ	$1, DX
+	SHRQ	$29, DX
+	MOVQ	DX, sec+0(FP)
+	IMULQ	$1000000000, DX
+	SUBQ	DX, CX
+	MOVL	CX, nsec+8(FP)
+	RET
+useQPC:
+	JMP	runtime·nowQPC(SB)
+	RET
diff --git a/src/runtime/time_windows_arm.s b/src/runtime/time_windows_arm.s
new file mode 100644
index 0000000000..70d0b60f78
--- /dev/null
+++ b/src/runtime/time_windows_arm.s
@@ -0,0 +1,84 @@
+// Copyright 2018 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.
+
+#include "go_asm.h"
+#include "textflag.h"
+#include "time_windows.h"
+
+TEXT time·now(SB),NOSPLIT|NOFRAME,$0-20
+	MOVW    $0, R0
+	MOVB    runtime·useQPCTime(SB), R0
+	CMP	$0, R0
+	BNE	useQPC
+	MOVW	$_INTERRUPT_TIME, R3
+loop:
+	MOVW	time_hi1(R3), R1
+	MOVW	time_lo(R3), R0
+	MOVW	time_hi2(R3), R2
+	CMP	R1, R2
+	BNE	loop
+
+	// wintime = R1:R0, multiply by 100
+	MOVW	$100, R2
+	MULLU	R0, R2, (R4, R3)    // R4:R3 = R1:R0 * R2
+	MULA	R1, R2, R4, R4
+
+	// wintime*100 = R4:R3
+	MOVW	R3, mono+12(FP)
+	MOVW	R4, mono+16(FP)
+
+	MOVW	$_SYSTEM_TIME, R3
+wall:
+	MOVW	time_hi1(R3), R1
+	MOVW	time_lo(R3), R0
+	MOVW	time_hi2(R3), R2
+	CMP	R1, R2
+	BNE	wall
+
+	// w = R1:R0 in 100ns untis
+	// convert to Unix epoch (but still 100ns units)
+	#define delta 116444736000000000
+	SUB.S   $(delta & 0xFFFFFFFF), R0
+	SBC     $(delta >> 32), R1
+
+	// Convert to nSec
+	MOVW    $100, R2
+	MULLU   R0, R2, (R4, R3)    // R4:R3 = R1:R0 * R2
+	MULA    R1, R2, R4, R4
+	// w = R2:R1 in nSec
+	MOVW    R3, R1	      // R4:R3 -> R2:R1
+	MOVW    R4, R2
+
+	// multiply nanoseconds by reciprocal of 10**9 (scaled by 2**61)
+	// to get seconds (96 bit scaled result)
+	MOVW	$0x89705f41, R3		// 2**61 * 10**-9
+	MULLU	R1,R3,(R6,R5)		// R7:R6:R5 = R2:R1 * R3
+	MOVW	$0,R7
+	MULALU	R2,R3,(R7,R6)
+
+	// unscale by discarding low 32 bits, shifting the rest by 29
+	MOVW	R6>>29,R6		// R7:R6 = (R7:R6:R5 >> 61)
+	ORR	R7<<3,R6
+	MOVW	R7>>29,R7
+
+	// subtract (10**9 * sec) from nsec to get nanosecond remainder
+	MOVW	$1000000000, R5	// 10**9
+	MULLU	R6,R5,(R9,R8)   // R9:R8 = R7:R6 * R5
+	MULA	R7,R5,R9,R9
+	SUB.S	R8,R1		// R2:R1 -= R9:R8
+	SBC	R9,R2
+
+	// because reciprocal was a truncated repeating fraction, quotient
+	// may be slightly too small -- adjust to make remainder < 10**9
+	CMP	R5,R1	// if remainder > 10**9
+	SUB.HS	R5,R1   //    remainder -= 10**9
+	ADD.HS	$1,R6	//    sec += 1
+
+	MOVW	R6,sec_lo+0(FP)
+	MOVW	R7,sec_hi+4(FP)
+	MOVW	R1,nsec+8(FP)
+	RET
+useQPC:
+	B	runtime·nowQPC(SB)		// tail call
+
diff --git a/src/runtime/time_windows_arm64.s b/src/runtime/time_windows_arm64.s
new file mode 100644
index 0000000000..61ce7577ce
--- /dev/null
+++ b/src/runtime/time_windows_arm64.s
@@ -0,0 +1,64 @@
+// Copyright 2018 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.
+
+#include "go_asm.h"
+#include "textflag.h"
+#include "time_windows.h"
+
+TEXT time·now(SB),NOSPLIT|NOFRAME,$0-24
+	MOVB    runtime·useQPCTime(SB), R0
+	CMP	$0, R0
+	BNE	useQPC
+	MOVD	$_INTERRUPT_TIME, R3
+loop:
+	MOVWU	time_hi1(R3), R1
+	MOVWU	time_lo(R3), R0
+	MOVWU	time_hi2(R3), R2
+	CMP	R1, R2
+	BNE	loop
+
+	// wintime = R1:R0, multiply by 100
+	ORR	R1<<32, R0
+	MOVD	$100, R1
+	MUL	R1, R0
+	MOVD	R0, mono+16(FP)
+
+	MOVD	$_SYSTEM_TIME, R3
+wall:
+	MOVWU	time_hi1(R3), R1
+	MOVWU	time_lo(R3), R0
+	MOVWU	time_hi2(R3), R2
+	CMP	R1, R2
+	BNE	wall
+
+	// w = R1:R0 in 100ns units
+	// convert to Unix epoch (but still 100ns units)
+	#define delta 116444736000000000
+	ORR	R1<<32, R0
+	SUB	$delta, R0
+
+	// Convert to nSec
+	MOVD	$100, R1
+	MUL	R1, R0
+
+	// Code stolen from compiler output for:
+	//
+	//	var x uint64
+	//	func f() (sec uint64, nsec uint32) { return x / 1000000000, uint32(x % 100000000) }
+	//
+	LSR	$1, R0, R1
+	MOVD	$-8543223759426509416, R2
+	UMULH	R2, R1, R1
+	LSR	$28, R1, R1
+	MOVD	R1, sec+0(FP)
+	MOVD	$-6067343680855748867, R1
+	UMULH	R0, R1, R1
+	LSR	$26, R1, R1
+	MOVD	$100000000, R2
+	MSUB	R1, R0, R2, R0
+	MOVW	R0, nsec+8(FP)
+	RET
+useQPC:
+	B	runtime·nowQPC(SB)		// tail call
+
-- 
GitLab


From c96fec9036e8b446b7ffefb59d2775b385ec6701 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Tue, 27 Apr 2021 16:22:25 -0700
Subject: [PATCH 1834/2400] runtime: use a single definition of time_now for
 faketime

Build other definitions with the !faketime build tag.

This makes it easy for us to add new assembly implementations of time.now.

Change-Id: I4e48e41a4a04ab001030e6d1cdd9cebfa0161b0d
Reviewed-on: https://go-review.googlesource.com/c/go/+/314274
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/time_fake.go         | 21 ++++++++++-----------
 src/runtime/time_windows_386.s   |  3 +++
 src/runtime/time_windows_amd64.s |  3 +++
 src/runtime/time_windows_arm.s   |  3 +++
 src/runtime/time_windows_arm64.s |  3 +++
 src/runtime/timeasm.go           |  4 ++--
 src/runtime/timestub.go          |  4 ++--
 7 files changed, 26 insertions(+), 15 deletions(-)

diff --git a/src/runtime/time_fake.go b/src/runtime/time_fake.go
index 1238744ebf..9d9a1e2ca6 100644
--- a/src/runtime/time_fake.go
+++ b/src/runtime/time_fake.go
@@ -5,17 +5,10 @@
 //go:build faketime && !windows
 // +build faketime,!windows
 
-// Faketime isn't currently supported on Windows. This would require:
-//
-// 1. Shadowing time_now, which is implemented in assembly on Windows.
-//    Since that's exported directly to the time package from runtime
-//    assembly, this would involve moving it from sys_windows_*.s into
-//    its own assembly files build-tagged with !faketime and using the
-//    implementation of time_now from timestub.go in faketime mode.
-//
-// 2. Modifying syscall.Write to call syscall.faketimeWrite,
-//    translating the Stdout and Stderr handles into FDs 1 and 2.
-//    (See CL 192739 PS 3.)
+// Faketime isn't currently supported on Windows. This would require
+// modifying syscall.Write to call syscall.faketimeWrite,
+// translating the Stdout and Stderr handles into FDs 1 and 2.
+// (See CL 192739 PS 3.)
 
 package runtime
 
@@ -48,6 +41,12 @@ func walltime() (sec int64, nsec int32) {
 	return faketime / 1000000000, int32(faketime % 1000000000)
 }
 
+//go:linkname time_now time.now
+func time_now() (sec int64, nsec int32, mono int64) {
+	sec, nsec = walltime()
+	return sec, nsec, nanotime()
+}
+
 func write(fd uintptr, p unsafe.Pointer, n int32) int32 {
 	if !(fd == 1 || fd == 2) {
 		// Do an ordinary write.
diff --git a/src/runtime/time_windows_386.s b/src/runtime/time_windows_386.s
index d1235c9414..19ce6910d7 100644
--- a/src/runtime/time_windows_386.s
+++ b/src/runtime/time_windows_386.s
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !faketime
+// +build !faketime
+
 #include "go_asm.h"
 #include "textflag.h"
 #include "time_windows.h"
diff --git a/src/runtime/time_windows_amd64.s b/src/runtime/time_windows_amd64.s
index 7d1fcfbcf5..93ab960b06 100644
--- a/src/runtime/time_windows_amd64.s
+++ b/src/runtime/time_windows_amd64.s
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !faketime
+// +build !faketime
+
 #include "go_asm.h"
 #include "textflag.h"
 #include "time_windows.h"
diff --git a/src/runtime/time_windows_arm.s b/src/runtime/time_windows_arm.s
index 70d0b60f78..7c763b66ed 100644
--- a/src/runtime/time_windows_arm.s
+++ b/src/runtime/time_windows_arm.s
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !faketime
+// +build !faketime
+
 #include "go_asm.h"
 #include "textflag.h"
 #include "time_windows.h"
diff --git a/src/runtime/time_windows_arm64.s b/src/runtime/time_windows_arm64.s
index 61ce7577ce..ef52ce4c99 100644
--- a/src/runtime/time_windows_arm64.s
+++ b/src/runtime/time_windows_arm64.s
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !faketime
+// +build !faketime
+
 #include "go_asm.h"
 #include "textflag.h"
 #include "time_windows.h"
diff --git a/src/runtime/timeasm.go b/src/runtime/timeasm.go
index fe38a086fc..f0c09461bd 100644
--- a/src/runtime/timeasm.go
+++ b/src/runtime/timeasm.go
@@ -4,8 +4,8 @@
 
 // Declarations for operating systems implementing time.now directly in assembly.
 
-//go:build windows
-// +build windows
+//go:build !faketime && windows
+// +build !faketime,windows
 
 package runtime
 
diff --git a/src/runtime/timestub.go b/src/runtime/timestub.go
index 2ef8d4665f..a3d9d58286 100644
--- a/src/runtime/timestub.go
+++ b/src/runtime/timestub.go
@@ -5,8 +5,8 @@
 // Declarations for operating systems implementing time.now
 // indirectly, in terms of walltime and nanotime assembly.
 
-//go:build !windows
-// +build !windows
+//go:build !faketime && !windows
+// +build !faketime,!windows
 
 package runtime
 
-- 
GitLab


From 414af503d7ec20cdfd6df23d5dee733401644ba3 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 28 Apr 2021 10:07:18 -0400
Subject: [PATCH 1835/2400] go/types: fix type inference

This is a 1:1 port of CL 311651 to go/types.

Change-Id: I9d91b45cc5fa7ce686d6a91d4dde274d9f80e0d7
Reviewed-on: https://go-review.googlesource.com/c/go/+/314595
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/fixedbugs/issue44799.go2 |  1 -
 src/go/types/fixedbugs/issue45548.go2 | 13 +++++++++++++
 src/go/types/infer.go                 | 19 +++++++++++++++++++
 src/go/types/unify.go                 | 17 +++++++++++++++++
 4 files changed, 49 insertions(+), 1 deletion(-)
 create mode 100644 src/go/types/fixedbugs/issue45548.go2

diff --git a/src/go/types/fixedbugs/issue44799.go2 b/src/go/types/fixedbugs/issue44799.go2
index 33f2c9a25c..9e528a7475 100644
--- a/src/go/types/fixedbugs/issue44799.go2
+++ b/src/go/types/fixedbugs/issue44799.go2
@@ -17,4 +17,3 @@ func main() {
 	_ = Reduce[int](s, 0, f2)
 	_ = Reduce(s, 0, f2)
 }
-
diff --git a/src/go/types/fixedbugs/issue45548.go2 b/src/go/types/fixedbugs/issue45548.go2
new file mode 100644
index 0000000000..b1e42497e8
--- /dev/null
+++ b/src/go/types/fixedbugs/issue45548.go2
@@ -0,0 +1,13 @@
+// Copyright 2021 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 p
+
+func f[F interface{type *Q}, G interface{type *R}, Q, R any](q Q, r R) {}
+
+func _() {
+	f[*float64, *int](1, 2)
+	f[*float64](1, 2)
+	f(1, 2)
+}
diff --git a/src/go/types/infer.go b/src/go/types/infer.go
index 9a45d5e994..da3a521870 100644
--- a/src/go/types/infer.go
+++ b/src/go/types/infer.go
@@ -446,6 +446,25 @@ func (check *Checker) inferB(tparams []*TypeName, targs []Type, report bool) (ty
 		dirty = dirty[:n]
 	}
 
+	// Once nothing changes anymore, we may still have type parameters left;
+	// e.g., a structural constraint *P may match a type parameter Q but we
+	// don't have any type arguments to fill in for *P or Q (issue #45548).
+	// Don't let such inferences escape, instead nil them out.
+	for i, typ := range types {
+		if typ != nil && isParameterized(tparams, typ) {
+			types[i] = nil
+		}
+	}
+
+	// update index
+	index = -1
+	for i, typ := range types {
+		if typ == nil {
+			index = i
+			break
+		}
+	}
+
 	return
 }
 
diff --git a/src/go/types/unify.go b/src/go/types/unify.go
index fbcd64c442..db06e21cf7 100644
--- a/src/go/types/unify.go
+++ b/src/go/types/unify.go
@@ -7,6 +7,7 @@
 package types
 
 import (
+	"bytes"
 	"go/token"
 	"sort"
 )
@@ -74,6 +75,22 @@ type tparamsList struct {
 	indices []int // len(d.indices) == len(d.tparams)
 }
 
+// String returns a string representation for a tparamsList. For debugging.
+func (d *tparamsList) String() string {
+	var buf bytes.Buffer
+	buf.WriteByte('[')
+	for i, tname := range d.tparams {
+		if i > 0 {
+			buf.WriteString(", ")
+		}
+		writeType(&buf, tname.typ, nil, nil)
+		buf.WriteString(": ")
+		writeType(&buf, d.at(i), nil, nil)
+	}
+	buf.WriteByte(']')
+	return buf.String()
+}
+
 // init initializes d with the given type parameters.
 // The type parameters must be in the order in which they appear in their declaration
 // (this ensures that the tparams indices match the respective type parameter index).
-- 
GitLab


From 6082c05d8b4ab59e74204a3749629c8e6240b7b0 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 28 Apr 2021 10:35:53 -0400
Subject: [PATCH 1836/2400] go/types: better errors for invalid short var decls

This is a port of CL 312170 to go/types, adjusted to use go/ast and to
add error codes. go/parser already emits errors for non-identifiers on
the LHS of a short var decl, so a TODO is added to reconsider this
redundancy.

A new error code is added for repeated identifiers in short var decls.
This is a bit specific, but I considered it to be a unique kind of
error.

The x/tools tests for this port turned up a bug: the new logic failed to
call recordDef for blank identifiers. Patchset #2 contains the fix for
this bug, both in go/types and cmd/compile/internal/types2.

Change-Id: Ibdc40b8b4ad0e0696111d431682e1f1056fd5eeb
Reviewed-on: https://go-review.googlesource.com/c/go/+/314629
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/types2/api_test.go   |  1 +
 .../compile/internal/types2/assignments.go    | 20 ++--
 src/go/types/api_test.go                      |  1 +
 src/go/types/assignments.go                   | 99 +++++++++++--------
 src/go/types/errorcodes.go                    |  9 ++
 src/go/types/fixedbugs/issue43087.src         | 43 ++++++++
 src/go/types/testdata/stmt0.src               |  6 +-
 7 files changed, 127 insertions(+), 52 deletions(-)
 create mode 100644 src/go/types/fixedbugs/issue43087.src

diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go
index c90f2e7510..873390c1e9 100644
--- a/src/cmd/compile/internal/types2/api_test.go
+++ b/src/cmd/compile/internal/types2/api_test.go
@@ -555,6 +555,7 @@ func TestDefsInfo(t *testing.T) {
 		{`package p2; var x int`, `x`, `var p2.x int`},
 		{`package p3; type x int`, `x`, `type p3.x int`},
 		{`package p4; func f()`, `f`, `func p4.f()`},
+		{`package p5; func f() int { x, _ := 1, 2; return x }`, `_`, `var _ int`},
 
 		// generic types must be sanitized
 		// (need to use sufficiently nested types to provoke unexpanded types)
diff --git a/src/cmd/compile/internal/types2/assignments.go b/src/cmd/compile/internal/types2/assignments.go
index ec9fdbba62..583118c8b2 100644
--- a/src/cmd/compile/internal/types2/assignments.go
+++ b/src/cmd/compile/internal/types2/assignments.go
@@ -344,16 +344,14 @@ func (check *Checker) shortVarDecl(pos syntax.Pos, lhs, rhs []syntax.Expr) {
 		}
 
 		name := ident.Value
-		if name == "_" {
-			continue
-		}
-
-		if seen[name] {
-			check.errorf(lhs, "%s repeated on left side of :=", lhs)
-			hasErr = true
-			continue
+		if name != "_" {
+			if seen[name] {
+				check.errorf(lhs, "%s repeated on left side of :=", lhs)
+				hasErr = true
+				continue
+			}
+			seen[name] = true
 		}
-		seen[name] = true
 
 		// Use the correct obj if the ident is redeclared. The
 		// variable's scope starts after the declaration; so we
@@ -374,7 +372,9 @@ func (check *Checker) shortVarDecl(pos syntax.Pos, lhs, rhs []syntax.Expr) {
 		// declare new variable
 		obj := NewVar(ident.Pos(), check.pkg, name, nil)
 		lhsVars[i] = obj
-		newVars = append(newVars, obj)
+		if name != "_" {
+			newVars = append(newVars, obj)
+		}
 		check.recordDef(ident, obj)
 	}
 
diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go
index 5ac91bedd2..f37b91d5a4 100644
--- a/src/go/types/api_test.go
+++ b/src/go/types/api_test.go
@@ -401,6 +401,7 @@ func TestDefsInfo(t *testing.T) {
 		{`package p2; var x int`, `x`, `var p2.x int`},
 		{`package p3; type x int`, `x`, `type p3.x int`},
 		{`package p4; func f()`, `f`, `func p4.f()`},
+		{`package p5; func f() int { x, _ := 1, 2; return x }`, `_`, `var _ int`},
 
 		// generic types must be sanitized
 		// (need to use sufficiently nested types to provoke unexpanded types)
diff --git a/src/go/types/assignments.go b/src/go/types/assignments.go
index 3aa06e8939..18eae62184 100644
--- a/src/go/types/assignments.go
+++ b/src/go/types/assignments.go
@@ -308,40 +308,60 @@ func (check *Checker) shortVarDecl(pos positioner, lhs, rhs []ast.Expr) {
 	scope := check.scope
 
 	// collect lhs variables
-	var newVars []*Var
-	var lhsVars = make([]*Var, len(lhs))
+	seen := make(map[string]bool, len(lhs))
+	lhsVars := make([]*Var, len(lhs))
+	newVars := make([]*Var, 0, len(lhs))
+	hasErr := false
 	for i, lhs := range lhs {
-		var obj *Var
-		if ident, _ := lhs.(*ast.Ident); ident != nil {
-			// Use the correct obj if the ident is redeclared. The
-			// variable's scope starts after the declaration; so we
-			// must use Scope.Lookup here and call Scope.Insert
-			// (via check.declare) later.
-			name := ident.Name
-			if alt := scope.Lookup(name); alt != nil {
-				// redeclared object must be a variable
-				if alt, _ := alt.(*Var); alt != nil {
-					obj = alt
-				} else {
-					check.errorf(lhs, _UnassignableOperand, "cannot assign to %s", lhs)
-				}
-				check.recordUse(ident, alt)
+		ident, _ := lhs.(*ast.Ident)
+		if ident == nil {
+			check.useLHS(lhs)
+			// TODO(rFindley) this is redundant with a parser error. Consider omitting?
+			check.errorf(lhs, _BadDecl, "non-name %s on left side of :=", lhs)
+			hasErr = true
+			continue
+		}
+
+		name := ident.Name
+		if name != "_" {
+			if seen[name] {
+				check.errorf(lhs, _RepeatedDecl, "%s repeated on left side of :=", lhs)
+				hasErr = true
+				continue
+			}
+			seen[name] = true
+		}
+
+		// Use the correct obj if the ident is redeclared. The
+		// variable's scope starts after the declaration; so we
+		// must use Scope.Lookup here and call Scope.Insert
+		// (via check.declare) later.
+		if alt := scope.Lookup(name); alt != nil {
+			check.recordUse(ident, alt)
+			// redeclared object must be a variable
+			if obj, _ := alt.(*Var); obj != nil {
+				lhsVars[i] = obj
 			} else {
-				// declare new variable, possibly a blank (_) variable
-				obj = NewVar(ident.Pos(), check.pkg, name, nil)
-				if name != "_" {
-					newVars = append(newVars, obj)
-				}
-				check.recordDef(ident, obj)
+				check.errorf(lhs, _UnassignableOperand, "cannot assign to %s", lhs)
+				hasErr = true
 			}
-		} else {
-			check.useLHS(lhs)
-			check.invalidAST(lhs, "cannot declare %s", lhs)
+			continue
+		}
+
+		// declare new variable
+		obj := NewVar(ident.Pos(), check.pkg, name, nil)
+		lhsVars[i] = obj
+		if name != "_" {
+			newVars = append(newVars, obj)
 		}
+		check.recordDef(ident, obj)
+	}
+
+	// create dummy variables where the lhs is invalid
+	for i, obj := range lhsVars {
 		if obj == nil {
-			obj = NewVar(lhs.Pos(), check.pkg, "_", nil) // dummy variable
+			lhsVars[i] = NewVar(lhs[i].Pos(), check.pkg, "_", nil)
 		}
-		lhsVars[i] = obj
 	}
 
 	check.initVars(lhsVars, rhs, token.NoPos)
@@ -349,17 +369,18 @@ func (check *Checker) shortVarDecl(pos positioner, lhs, rhs []ast.Expr) {
 	// process function literals in rhs expressions before scope changes
 	check.processDelayed(top)
 
-	// declare new variables
-	if len(newVars) > 0 {
-		// spec: "The scope of a constant or variable identifier declared inside
-		// a function begins at the end of the ConstSpec or VarSpec (ShortVarDecl
-		// for short variable declarations) and ends at the end of the innermost
-		// containing block."
-		scopePos := rhs[len(rhs)-1].End()
-		for _, obj := range newVars {
-			check.declare(scope, nil, obj, scopePos) // recordObject already called
-		}
-	} else {
+	if len(newVars) == 0 && !hasErr {
 		check.softErrorf(pos, _NoNewVar, "no new variables on left side of :=")
+		return
+	}
+
+	// declare new variables
+	// spec: "The scope of a constant or variable identifier declared inside
+	// a function begins at the end of the ConstSpec or VarSpec (ShortVarDecl
+	// for short variable declarations) and ends at the end of the innermost
+	// containing block."
+	scopePos := rhs[len(rhs)-1].End()
+	for _, obj := range newVars {
+		check.declare(scope, nil, obj, scopePos) // id = nil: recordDef already called
 	}
 }
diff --git a/src/go/types/errorcodes.go b/src/go/types/errorcodes.go
index 1106cd986f..a33a4e7dce 100644
--- a/src/go/types/errorcodes.go
+++ b/src/go/types/errorcodes.go
@@ -1357,6 +1357,15 @@ const (
 	// _BadDecl occurs when a declaration has invalid syntax.
 	_BadDecl
 
+	// _RepeatedDecl occurs when an identifier occurs more than once on the left
+	// hand side of a short variable declaration.
+	//
+	// Example:
+	//  func _() {
+	//  	x, y, y := 1, 2, 3
+	//  }
+	_RepeatedDecl
+
 	// _Todo is a placeholder for error codes that have not been decided.
 	// TODO(rFindley) remove this error code after deciding on errors for generics code.
 	_Todo
diff --git a/src/go/types/fixedbugs/issue43087.src b/src/go/types/fixedbugs/issue43087.src
new file mode 100644
index 0000000000..ef37b4aa29
--- /dev/null
+++ b/src/go/types/fixedbugs/issue43087.src
@@ -0,0 +1,43 @@
+// Copyright 2021 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 p
+
+func _() {
+	a, b, b /* ERROR b repeated on left side of := */ := 1, 2, 3
+	_ = a
+	_ = b
+}
+
+func _() {
+	a, _, _ := 1, 2, 3 // multiple _'s ok
+	_ = a
+}
+
+func _() {
+	var b int
+	a, b, b /* ERROR b repeated on left side of := */ := 1, 2, 3
+	_ = a
+	_ = b
+}
+
+func _() {
+	var a []int
+	a /* ERROR expected identifier */ /* ERROR non-name .* on left side of := */ [0], b := 1, 2
+	_ = a
+	_ = b
+}
+
+func _() {
+	var a int
+	a, a /* ERROR a repeated on left side of := */ := 1, 2
+	_ = a
+}
+
+func _() {
+	var a, b int
+	a, b := /* ERROR no new variables on left side of := */ 1, 2
+	_ = a
+	_ = b
+}
diff --git a/src/go/types/testdata/stmt0.src b/src/go/types/testdata/stmt0.src
index 2602d7dacf..76b6e70d63 100644
--- a/src/go/types/testdata/stmt0.src
+++ b/src/go/types/testdata/stmt0.src
@@ -143,11 +143,11 @@ func issue6487() {
 }
 
 func issue6766a() {
-	a, a /* ERROR redeclared */ := 1, 2
+	a, a /* ERROR a repeated on left side of := */ := 1, 2
 	_ = a
-	a, b, b /* ERROR redeclared */ := 1, 2, 3
+	a, b, b /* ERROR b repeated on left side of := */ := 1, 2, 3
 	_ = b
-	c, c /* ERROR redeclared */, b := 1, 2, 3
+	c, c /* ERROR c repeated on left side of := */, b := 1, 2, 3
 	_ = c
 	a, b := /* ERROR no new variables */ 1, 2
 }
-- 
GitLab


From fa6ed6e81ae6414681336c08da16213b943c45e3 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 28 Apr 2021 11:13:35 -0400
Subject: [PATCH 1837/2400] go/types: respect IgnoreFuncBodies for function
 literals

This is a 1:1 port of CL 313650 to go/types.

Change-Id: Iec01ac2831f21162d9977a139549e081ee769f90
Reviewed-on: https://go-review.googlesource.com/c/go/+/314631
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/expr.go | 26 ++++++++++++++------------
 src/go/types/stmt.go |  4 ++++
 2 files changed, 18 insertions(+), 12 deletions(-)

diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 4055cdd080..9bfe23a815 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -1085,18 +1085,20 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 
 	case *ast.FuncLit:
 		if sig, ok := check.typ(e.Type).(*Signature); ok {
-			// Anonymous functions are considered part of the
-			// init expression/func declaration which contains
-			// them: use existing package-level declaration info.
-			decl := check.decl // capture for use in closure below
-			iota := check.iota // capture for use in closure below (#22345)
-			// Don't type-check right away because the function may
-			// be part of a type definition to which the function
-			// body refers. Instead, type-check as soon as possible,
-			// but before the enclosing scope contents changes (#22992).
-			check.later(func() {
-				check.funcBody(decl, "<function literal>", sig, e.Body, iota)
-			})
+			if !check.conf.IgnoreFuncBodies && e.Body != nil {
+				// Anonymous functions are considered part of the
+				// init expression/func declaration which contains
+				// them: use existing package-level declaration info.
+				decl := check.decl // capture for use in closure below
+				iota := check.iota // capture for use in closure below (#22345)
+				// Don't type-check right away because the function may
+				// be part of a type definition to which the function
+				// body refers. Instead, type-check as soon as possible,
+				// but before the enclosing scope contents changes (#22992).
+				check.later(func() {
+					check.funcBody(decl, "<function literal>", sig, e.Body, iota)
+				})
+			}
 			x.mode = value
 			x.typ = sig
 		} else {
diff --git a/src/go/types/stmt.go b/src/go/types/stmt.go
index 27da198a85..47f6dcfbd1 100644
--- a/src/go/types/stmt.go
+++ b/src/go/types/stmt.go
@@ -14,6 +14,10 @@ import (
 )
 
 func (check *Checker) funcBody(decl *declInfo, name string, sig *Signature, body *ast.BlockStmt, iota constant.Value) {
+	if check.conf.IgnoreFuncBodies {
+		panic("internal error: function body not ignored")
+	}
+
 	if trace {
 		check.trace(body.Pos(), "--- %s: %s", name, sig)
 		defer func() {
-- 
GitLab


From 756fd56bbf4f965cfab29cc71e0853f0c48a331f Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Wed, 28 Apr 2021 18:10:22 -0400
Subject: [PATCH 1838/2400] cmd/compile: remove an unused function

Remove unused function AddrForParamSlot.

Change-Id: I8e3ed8cc6607d30ad6da7bc6ccbaa87b7e001e79
Reviewed-on: https://go-review.googlesource.com/c/go/+/314909
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssagen/ssa.go | 18 +-----------------
 1 file changed, 1 insertion(+), 17 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 891047f56d..c49350005e 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -400,7 +400,7 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func {
 	name := ir.FuncName(fn)
 	printssa := false
 	if ssaDump != "" { // match either a simple name e.g. "(*Reader).Reset", package.name e.g. "compress/gzip.(*Reader).Reset", or subpackage name "gzip.(*Reader).Reset"
-		pkgDotName := base.Ctxt.Pkgpath+"."+name
+		pkgDotName := base.Ctxt.Pkgpath + "." + name
 		printssa = name == ssaDump ||
 			strings.HasSuffix(pkgDotName, ssaDump) && (pkgDotName == ssaDump || strings.HasSuffix(pkgDotName, "/"+ssaDump))
 	}
@@ -7779,22 +7779,6 @@ func SpillSlotAddr(spill ssa.Spill, baseReg int16, extraOffset int64) obj.Addr {
 	}
 }
 
-// AddrForParamSlot fills in an Addr appropriately for a Spill,
-// Restore, or VARLIVE.
-func AddrForParamSlot(slot *ssa.LocalSlot, addr *obj.Addr) {
-	// TODO replace this boilerplate in a couple of places.
-	n, off := slot.N, slot.Off
-	addr.Type = obj.TYPE_MEM
-	addr.Sym = n.Linksym()
-	addr.Offset = off
-	if n.Class == ir.PPARAM || (n.Class == ir.PPARAMOUT && !n.IsOutputParamInRegisters()) {
-		addr.Name = obj.NAME_PARAM
-		addr.Offset += n.FrameOffset()
-	} else { // out parameters in registers allocate stack slots like autos.
-		addr.Name = obj.NAME_AUTO
-	}
-}
-
 var (
 	BoundsCheckFunc [ssa.BoundsKindCount]*obj.LSym
 	ExtendCheckFunc [ssa.BoundsKindCount]*obj.LSym
-- 
GitLab


From d09947522d1fbe17d6a8aece07d70e31a3a5311e Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Tue, 27 Apr 2021 16:46:53 -0700
Subject: [PATCH 1839/2400] runtime: implement time.now in assembly for
 linux-amd64
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

name                                                       old time/op      new time/op      delta
AfterFunc-12                                                   66.7µs ± 3%      66.8µs ± 4%     ~     (p=0.836 n=20+20)
After-12                                                       99.4µs ± 4%      98.1µs ± 3%   -1.31%  (p=0.013 n=20+20)
Stop-12                                                        66.1µs ±12%      65.4µs ±10%     ~     (p=0.602 n=20+20)
SimultaneousAfterFunc-12                                        110µs ± 1%       114µs ± 2%   +3.98%  (p=0.000 n=19+18)
StartStop-12                                                   32.1µs ±15%      32.2µs ±13%     ~     (p=0.620 n=20+20)
Reset-12                                                       3.66µs ± 2%      3.63µs ± 5%   -0.92%  (p=0.018 n=20+17)
Sleep-12                                                        134µs ± 1%       139µs ± 4%   +3.97%  (p=0.000 n=20+18)
Ticker-12                                                      32.8µs ± 1%      32.6µs ± 2%   -0.63%  (p=0.017 n=18+20)
TickerReset-12                                                 3.72µs ± 3%      3.71µs ± 3%     ~     (p=0.753 n=20+20)
TickerResetNaive-12                                            68.9µs ±11%      65.8µs ± 8%   -4.44%  (p=0.008 n=20+20)
Now-12                                                         33.3ns ± 1%      29.6ns ± 0%  -11.06%  (p=0.000 n=18+16)
NowUnixNano-12                                                 34.6ns ± 0%      31.2ns ± 0%   -9.94%  (p=0.000 n=20+17)
NowUnixMilli-12                                                35.0ns ± 1%      30.9ns ± 0%  -11.75%  (p=0.000 n=19+15)
NowUnixMicro-12                                                35.0ns ± 0%      30.9ns ± 0%  -11.85%  (p=0.000 n=20+19)
Format-12                                                       302ns ± 3%       306ns ± 3%   +1.22%  (p=0.009 n=20+20)
FormatNow-12                                                    184ns ± 5%       187ns ± 2%   +1.25%  (p=0.046 n=20+19)
MarshalJSON-12                                                  262ns ± 2%       270ns ± 3%   +2.99%  (p=0.000 n=20+20)
MarshalText-12                                                  262ns ± 3%       268ns ± 3%   +2.37%  (p=0.000 n=19+19)
Parse-12                                                        145ns ± 1%       148ns ± 0%   +2.27%  (p=0.000 n=18+19)
ParseDuration-12                                               82.3ns ± 1%      79.7ns ± 1%   -3.06%  (p=0.000 n=20+20)
Hour-12                                                        4.48ns ± 1%      4.42ns ± 1%   -1.32%  (p=0.000 n=19+19)
Second-12                                                      4.44ns ± 1%      4.42ns ± 1%   -0.39%  (p=0.000 n=20+18)
Year-12                                                        11.2ns ± 1%      11.1ns ± 1%     ~     (p=0.193 n=20+20)
Day-12                                                         14.8ns ± 0%      14.8ns ± 1%     ~     (p=0.873 n=19+20)
ISOWeek-12                                                     17.2ns ± 0%      17.2ns ± 0%     ~     (p=0.605 n=18+20)

name                                                       old avg-late-ns  new avg-late-ns  delta
ParallelTimerLatency-12                                          375k ± 3%        377k ± 3%     ~     (p=0.445 n=20+20)
StaggeredTickerLatency/work-dur=300µs/tickers-per-P=1-12         136k ± 2%        137k ± 2%     ~     (p=0.242 n=20+20)
StaggeredTickerLatency/work-dur=300µs/tickers-per-P=2-12        97.4k ±11%       96.4k ±10%     ~     (p=0.336 n=19+20)
StaggeredTickerLatency/work-dur=300µs/tickers-per-P=3-12        74.8k ± 3%       74.2k ± 3%     ~     (p=0.158 n=20+19)
StaggeredTickerLatency/work-dur=300µs/tickers-per-P=4-12        70.7k ± 7%       70.4k ± 6%     ~     (p=0.879 n=20+19)
StaggeredTickerLatency/work-dur=300µs/tickers-per-P=5-12        65.8k ± 9%       66.3k ±14%     ~     (p=0.594 n=17+19)
StaggeredTickerLatency/work-dur=300µs/tickers-per-P=6-12        55.5k ±29%       56.7k ±30%     ~     (p=0.758 n=20+20)
StaggeredTickerLatency/work-dur=300µs/tickers-per-P=7-12        45.3k ±29%       43.6k ±33%     ~     (p=0.212 n=19+19)
StaggeredTickerLatency/work-dur=300µs/tickers-per-P=8-12        64.7k ±46%       65.2k ±78%     ~     (p=0.480 n=18+19)
StaggeredTickerLatency/work-dur=300µs/tickers-per-P=9-12         147k ±88%        119k ±83%     ~     (p=0.092 n=19+18)
StaggeredTickerLatency/work-dur=300µs/tickers-per-P=10-12       2.63M ±29%       2.70M ±59%     ~     (p=0.989 n=19+20)
StaggeredTickerLatency/work-dur=2ms/tickers-per-P=1-12          81.4k ± 4%       80.2k ± 3%   -1.55%  (p=0.009 n=17+18)

name                                                       old max-late-ns  new max-late-ns  delta
ParallelTimerLatency-12                                        7.66M ±102%      6.98M ±131%     ~     (p=0.445 n=20+20)
StaggeredTickerLatency/work-dur=300µs/tickers-per-P=1-12         381k ±12%        382k ±17%     ~     (p=0.901 n=17+16)
StaggeredTickerLatency/work-dur=300µs/tickers-per-P=2-12         388k ±69%        356k ±10%     ~     (p=0.363 n=17+16)
StaggeredTickerLatency/work-dur=300µs/tickers-per-P=3-12         350k ±17%        347k ±25%     ~     (p=0.538 n=19+18)
StaggeredTickerLatency/work-dur=300µs/tickers-per-P=4-12         378k ±52%        341k ±30%     ~     (p=0.153 n=18+17)
StaggeredTickerLatency/work-dur=300µs/tickers-per-P=5-12         392k ±54%        410k ±78%     ~     (p=0.730 n=18+19)
StaggeredTickerLatency/work-dur=300µs/tickers-per-P=6-12         467k ±80%       527k ±129%     ~     (p=0.616 n=17+19)
StaggeredTickerLatency/work-dur=300µs/tickers-per-P=7-12        915k ±138%      1023k ±227%     ~     (p=0.696 n=20+18)
StaggeredTickerLatency/work-dur=300µs/tickers-per-P=8-12       1.84M ±155%      1.74M ±158%     ~     (p=0.893 n=18+19)
StaggeredTickerLatency/work-dur=300µs/tickers-per-P=9-12        6.95M ±92%       7.66M ±91%     ~     (p=0.687 n=19+20)
StaggeredTickerLatency/work-dur=300µs/tickers-per-P=10-12       18.6M ±22%       16.2M ±28%  -12.78%  (p=0.003 n=19+19)
StaggeredTickerLatency/work-dur=2ms/tickers-per-P=1-12          1.01M ± 8%       1.04M ±10%     ~     (p=0.111 n=19+18)

Change-Id: I96aa2e0206a6e9286bcbfc8be372e84608ed4e2f
Reviewed-on: https://go-review.googlesource.com/c/go/+/314277
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/time_linux_amd64.s | 97 ++++++++++++++++++++++++++++++++++
 src/runtime/timeasm.go         |  5 +-
 src/runtime/timestub.go        |  6 ++-
 3 files changed, 104 insertions(+), 4 deletions(-)
 create mode 100644 src/runtime/time_linux_amd64.s

diff --git a/src/runtime/time_linux_amd64.s b/src/runtime/time_linux_amd64.s
new file mode 100644
index 0000000000..0dd7919896
--- /dev/null
+++ b/src/runtime/time_linux_amd64.s
@@ -0,0 +1,97 @@
+// Copyright 2021 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.
+
+//go:build !faketime
+// +build !faketime
+
+#include "go_asm.h"
+#include "go_tls.h"
+#include "textflag.h"
+
+#define SYS_clock_gettime	228
+
+// func time.now() (sec int64, nsec int32, mono int64)
+TEXT time·now(SB),NOSPLIT,$16-24
+	MOVQ	SP, R12 // Save old SP; R12 unchanged by C code.
+
+#ifdef GOEXPERIMENT_regabig
+	MOVQ	g_m(R14), BX // BX unchanged by C code.
+#else
+	get_tls(CX)
+	MOVQ	g(CX), AX
+	MOVQ	g_m(AX), BX // BX unchanged by C code.
+#endif
+
+	// Store CLOCK_REALTIME results directly to return space.
+	LEAQ	sec+0(FP), SI
+
+	// Set vdsoPC and vdsoSP for SIGPROF traceback.
+	// Save the old values on stack and restore them on exit,
+	// so this function is reentrant.
+	MOVQ	m_vdsoPC(BX), CX
+	MOVQ	m_vdsoSP(BX), DX
+	MOVQ	CX, 0(SP)
+	MOVQ	DX, 8(SP)
+
+	MOVQ	-8(SI), CX	// Sets CX to function return address.
+	MOVQ	CX, m_vdsoPC(BX)
+	MOVQ	SI, m_vdsoSP(BX)
+
+#ifdef GOEXPERIMENT_regabig
+	CMPQ	R14, m_curg(BX)	// Only switch if on curg.
+#else
+	CMPQ	AX, m_curg(BX)	// Only switch if on curg.
+#endif
+	JNE	noswitch
+
+	MOVQ	m_g0(BX), DX
+	MOVQ	(g_sched+gobuf_sp)(DX), SP	// Set SP to g0 stack
+
+noswitch:
+	SUBQ	$16, SP		// Space for monotonic time results
+	ANDQ	$~15, SP	// Align for C code
+
+	MOVL	$0, DI // CLOCK_REALTIME
+	MOVQ	runtime·vdsoClockgettimeSym(SB), AX
+	CMPQ	AX, $0
+	JEQ	fallback
+	CALL	AX
+
+	MOVL	$1, DI // CLOCK_MONOTONIC
+	LEAQ	0(SP), SI
+	MOVQ	runtime·vdsoClockgettimeSym(SB), AX
+	CALL	AX
+
+ret:
+	MOVQ	0(SP), AX	// sec
+	MOVQ	8(SP), DX	// nsec
+
+	MOVQ	R12, SP		// Restore real SP
+	// Restore vdsoPC, vdsoSP
+	// We don't worry about being signaled between the two stores.
+	// If we are not in a signal handler, we'll restore vdsoSP to 0,
+	// and no one will care about vdsoPC. If we are in a signal handler,
+	// we cannot receive another signal.
+	MOVQ	8(SP), CX
+	MOVQ	CX, m_vdsoSP(BX)
+	MOVQ	0(SP), CX
+	MOVQ	CX, m_vdsoPC(BX)
+
+	// sec is in AX, nsec in DX
+	// return nsec in AX
+	IMULQ	$1000000000, AX
+	ADDQ	DX, AX
+	MOVQ	AX, mono+16(FP)
+	RET
+
+fallback:
+	MOVQ	$SYS_clock_gettime, AX
+	SYSCALL
+
+	MOVL	$1, DI // CLOCK_MONOTONIC
+	LEAQ	0(SP), SI
+	MOVQ	$SYS_clock_gettime, AX
+	SYSCALL
+
+	JMP	ret
diff --git a/src/runtime/timeasm.go b/src/runtime/timeasm.go
index f0c09461bd..468ff8a0d3 100644
--- a/src/runtime/timeasm.go
+++ b/src/runtime/timeasm.go
@@ -4,8 +4,9 @@
 
 // Declarations for operating systems implementing time.now directly in assembly.
 
-//go:build !faketime && windows
-// +build !faketime,windows
+//go:build !faketime && (windows || (linux && amd64))
+// +build !faketime
+// +build windows linux,amd64
 
 package runtime
 
diff --git a/src/runtime/timestub.go b/src/runtime/timestub.go
index a3d9d58286..6f16c70b81 100644
--- a/src/runtime/timestub.go
+++ b/src/runtime/timestub.go
@@ -5,8 +5,10 @@
 // Declarations for operating systems implementing time.now
 // indirectly, in terms of walltime and nanotime assembly.
 
-//go:build !faketime && !windows
-// +build !faketime,!windows
+//go:build !faketime && !windows && !(linux && amd64)
+// +build !faketime
+// +build !windows
+// +build !linux !amd64
 
 package runtime
 
-- 
GitLab


From 42953bc9f5ded1bcf4ff727d82ddd3b7a8a2b8de Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Wed, 28 Apr 2021 11:10:07 -0700
Subject: [PATCH 1840/2400] runtime: remove walltime function

There was only one meaningful caller, which changes to call time_now.

This clearly separates systems that use walltime1 to be just those
that use the stub version of time_now. That is to say, those that do
not provide an assembler version of time_now.

Change-Id: I14c06cc402070bd705f953af6f9966785015e2a5
Reviewed-on: https://go-review.googlesource.com/c/go/+/314769
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/time_fake.go         | 7 +------
 src/runtime/time_nofake.go       | 4 ----
 src/runtime/timestub.go          | 2 +-
 src/runtime/write_err_android.go | 2 +-
 4 files changed, 3 insertions(+), 12 deletions(-)

diff --git a/src/runtime/time_fake.go b/src/runtime/time_fake.go
index 9d9a1e2ca6..c790faba3d 100644
--- a/src/runtime/time_fake.go
+++ b/src/runtime/time_fake.go
@@ -37,14 +37,9 @@ func nanotime() int64 {
 	return faketime
 }
 
-func walltime() (sec int64, nsec int32) {
-	return faketime / 1000000000, int32(faketime % 1000000000)
-}
-
 //go:linkname time_now time.now
 func time_now() (sec int64, nsec int32, mono int64) {
-	sec, nsec = walltime()
-	return sec, nsec, nanotime()
+	return faketime / 1e9, int32(faketime % 1e9), faketime
 }
 
 func write(fd uintptr, p unsafe.Pointer, n int32) int32 {
diff --git a/src/runtime/time_nofake.go b/src/runtime/time_nofake.go
index 13bf1c2d4f..5a4ceaf43d 100644
--- a/src/runtime/time_nofake.go
+++ b/src/runtime/time_nofake.go
@@ -20,10 +20,6 @@ func nanotime() int64 {
 	return nanotime1()
 }
 
-func walltime() (sec int64, nsec int32) {
-	return walltime1()
-}
-
 // write must be nosplit on Windows (see write1)
 //
 //go:nosplit
diff --git a/src/runtime/timestub.go b/src/runtime/timestub.go
index 6f16c70b81..44e65845cb 100644
--- a/src/runtime/timestub.go
+++ b/src/runtime/timestub.go
@@ -16,6 +16,6 @@ import _ "unsafe" // for go:linkname
 
 //go:linkname time_now time.now
 func time_now() (sec int64, nsec int32, mono int64) {
-	sec, nsec = walltime()
+	sec, nsec = walltime1()
 	return sec, nsec, nanotime()
 }
diff --git a/src/runtime/write_err_android.go b/src/runtime/write_err_android.go
index 2419fc8663..a876900c95 100644
--- a/src/runtime/write_err_android.go
+++ b/src/runtime/write_err_android.go
@@ -144,7 +144,7 @@ func writeLogdHeader() int {
 	//      hdr[3:7] sec unsigned uint32, little endian.
 	//      hdr[7:11] nsec unsigned uint32, little endian.
 	hdr[0] = 0 // LOG_ID_MAIN
-	sec, nsec := walltime()
+	sec, nsec, _ := time_now()
 	packUint32(hdr[3:7], uint32(sec))
 	packUint32(hdr[7:11], uint32(nsec))
 
-- 
GitLab


From 6afa0ae4e54ec049f291050b82c2a770bb3644b1 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 28 Apr 2021 18:00:16 -0700
Subject: [PATCH 1841/2400] cmd/compile/internal/types2: match compiler error
 for invalid type alias decl

Fixes #45594.

Change-Id: I2fcc784e6908403dd96b009546e1ac2f53b9f0e8
Reviewed-on: https://go-review.googlesource.com/c/go/+/314776
Trust: Robert Griesemer <gri@golang.org>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/types2/decl.go | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index 178bebe2ec..4966f19892 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -602,7 +602,11 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *syntax.TypeDecl, def *Named
 	if alias {
 		// type alias declaration
 		if !check.allowVersion(obj.pkg, 1, 9) {
-			check.error(tdecl, "type aliases requires go1.9 or later")
+			if check.conf.CompilerErrorMessages {
+				check.error(tdecl, "type aliases only supported as of -lang=go1.9")
+			} else {
+				check.error(tdecl, "type aliases requires go1.9 or later")
+			}
 		}
 
 		obj.typ = Typ[Invalid]
-- 
GitLab


From c4c68fb57f1b081557a837e8809094b42cfdc5e3 Mon Sep 17 00:00:00 2001
From: cuiweixie <cuiweixie@gmail.com>
Date: Wed, 28 Apr 2021 05:21:33 +0000
Subject: [PATCH 1842/2400] cmd/compile/internal/walk: delete unused statement

Change-Id: I3f118c868b13ec51b2e501424b35564929eed56d
GitHub-Last-Rev: d15ae124c582417cd10bceaef0b5c0ebbf100f7e
GitHub-Pull-Request: golang/go#45816
Reviewed-on: https://go-review.googlesource.com/c/go/+/314570
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/walk/range.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/cmd/compile/internal/walk/range.go b/src/cmd/compile/internal/walk/range.go
index 0c651c6289..b1169fdae8 100644
--- a/src/cmd/compile/internal/walk/range.go
+++ b/src/cmd/compile/internal/walk/range.go
@@ -421,7 +421,6 @@ func arrayClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
 	// 	i = len(a) - 1
 	// }
 	n := ir.NewIfStmt(base.Pos, nil, nil, nil)
-	n.Body = nil
 	n.Cond = ir.NewBinaryExpr(base.Pos, ir.ONE, ir.NewUnaryExpr(base.Pos, ir.OLEN, a), ir.NewInt(0))
 
 	// hp = &a[0]
-- 
GitLab


From 47cb0c46b206d3d1bcc176314c200e35c1f62cf2 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 28 Apr 2021 14:40:53 -0400
Subject: [PATCH 1843/2400] go/types: nest all test data under the testdata
 directory

Having multiple subdirectories of go/types containing test data is
slightly problematic:
 - If ever we were to include a .go file in one of these directories,
   we'd inadvertently create a visible package.
 - It's difficult to add other content in testdata/, since TestTestdata
   scans the entire directory.

Move everything down a level, into testdata/{fixedbugs,examples,check},
and update tests accordingly.

Change-Id: Idd074c94b7b261d678934330539e41a48c2a9dc9
Reviewed-on: https://go-review.googlesource.com/c/go/+/314829
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/check_test.go                           | 12 +++++++-----
 src/go/types/testdata/{ => check}/blank.src          |  0
 src/go/types/testdata/{ => check}/builtins.go2       |  0
 src/go/types/testdata/{ => check}/builtins.src       |  0
 src/go/types/testdata/{ => check}/chans.go2          |  0
 src/go/types/testdata/{ => check}/const0.src         |  0
 src/go/types/testdata/{ => check}/const1.src         |  0
 src/go/types/testdata/{ => check}/constdecl.src      |  0
 src/go/types/testdata/{ => check}/conversions.src    |  0
 src/go/types/testdata/{ => check}/conversions2.src   |  0
 src/go/types/testdata/{ => check}/cycles.src         |  0
 src/go/types/testdata/{ => check}/cycles1.src        |  0
 src/go/types/testdata/{ => check}/cycles2.src        |  0
 src/go/types/testdata/{ => check}/cycles3.src        |  0
 src/go/types/testdata/{ => check}/cycles4.src        |  0
 src/go/types/testdata/{ => check}/cycles5.src        |  0
 src/go/types/testdata/{ => check}/decls0.src         |  0
 src/go/types/testdata/{ => check}/decls1.src         |  0
 src/go/types/testdata/{ => check}/decls2/decls2a.src |  0
 src/go/types/testdata/{ => check}/decls2/decls2b.src |  0
 src/go/types/testdata/{ => check}/decls3.src         |  0
 src/go/types/testdata/{ => check}/decls4.src         |  0
 src/go/types/testdata/{ => check}/decls5.src         |  0
 src/go/types/testdata/{ => check}/errors.src         |  0
 src/go/types/testdata/{ => check}/expr0.src          |  0
 src/go/types/testdata/{ => check}/expr1.src          |  0
 src/go/types/testdata/{ => check}/expr2.src          |  0
 src/go/types/testdata/{ => check}/expr3.src          |  0
 src/go/types/testdata/{ => check}/go1_12.src         |  0
 src/go/types/testdata/{ => check}/go1_13.src         |  0
 src/go/types/testdata/{ => check}/go1_8.src          |  0
 src/go/types/testdata/{ => check}/gotos.src          |  0
 src/go/types/testdata/{ => check}/importC.src        |  0
 .../{ => check}/importdecl0/importdecl0a.src         |  0
 .../{ => check}/importdecl0/importdecl0b.src         |  0
 .../{ => check}/importdecl1/importdecl1a.src         |  0
 .../{ => check}/importdecl1/importdecl1b.src         |  0
 src/go/types/testdata/{ => check}/init0.src          |  0
 src/go/types/testdata/{ => check}/init1.src          |  0
 src/go/types/testdata/{ => check}/init2.src          |  0
 .../testdata/{ => check}/issue25008/issue25008a.src  |  0
 .../testdata/{ => check}/issue25008/issue25008b.src  |  0
 src/go/types/testdata/{ => check}/issues.go2         |  0
 src/go/types/testdata/{ => check}/issues.src         |  0
 src/go/types/testdata/{ => check}/labels.src         |  0
 src/go/types/testdata/{ => check}/linalg.go2         |  0
 src/go/types/testdata/{ => check}/literals.src       |  0
 src/go/types/testdata/{ => check}/main.src           |  0
 src/go/types/testdata/{ => check}/map.go2            |  0
 src/go/types/testdata/{ => check}/map2.go2           |  0
 src/go/types/testdata/{ => check}/methodsets.src     |  0
 src/go/types/testdata/{ => check}/shifts.src         |  0
 src/go/types/testdata/{ => check}/slices.go2         |  0
 src/go/types/testdata/{ => check}/stmt0.src          |  0
 src/go/types/testdata/{ => check}/stmt1.src          |  0
 src/go/types/testdata/{ => check}/tinference.go2     |  0
 src/go/types/testdata/{ => check}/tmp.go2            |  0
 src/go/types/testdata/{ => check}/todos.go2          |  0
 src/go/types/testdata/{ => check}/typeinst.go2       |  0
 src/go/types/testdata/{ => check}/typeinst2.go2      |  0
 src/go/types/testdata/{ => check}/typeparams.go2     |  0
 src/go/types/testdata/{ => check}/vardecl.src        |  0
 src/go/types/{ => testdata}/examples/functions.go2   |  0
 src/go/types/{ => testdata}/examples/inference.go2   |  0
 src/go/types/{ => testdata}/examples/methods.go2     |  0
 src/go/types/{ => testdata}/examples/types.go2       |  0
 src/go/types/{ => testdata}/fixedbugs/issue20583.src |  0
 .../types/{ => testdata}/fixedbugs/issue23203a.src   |  0
 .../types/{ => testdata}/fixedbugs/issue23203b.src   |  0
 src/go/types/{ => testdata}/fixedbugs/issue26390.src |  0
 src/go/types/{ => testdata}/fixedbugs/issue28251.src |  0
 src/go/types/{ => testdata}/fixedbugs/issue39634.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue39664.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue39680.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue39693.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue39699.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue39711.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue39723.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue39725.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue39754.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue39755.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue39768.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue39938.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue39948.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue39976.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue39982.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue40038.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue40056.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue40057.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue40301.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue40684.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue41124.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue42695.src |  0
 src/go/types/{ => testdata}/fixedbugs/issue42758.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue43087.src |  0
 src/go/types/{ => testdata}/fixedbugs/issue43110.src |  0
 src/go/types/{ => testdata}/fixedbugs/issue43124.src |  0
 src/go/types/{ => testdata}/fixedbugs/issue44688.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue44799.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue45548.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue45635.go2 |  0
 src/go/types/{ => testdata}/fixedbugs/issue6977.src  |  0
 102 files changed, 7 insertions(+), 5 deletions(-)
 rename src/go/types/testdata/{ => check}/blank.src (100%)
 rename src/go/types/testdata/{ => check}/builtins.go2 (100%)
 rename src/go/types/testdata/{ => check}/builtins.src (100%)
 rename src/go/types/testdata/{ => check}/chans.go2 (100%)
 rename src/go/types/testdata/{ => check}/const0.src (100%)
 rename src/go/types/testdata/{ => check}/const1.src (100%)
 rename src/go/types/testdata/{ => check}/constdecl.src (100%)
 rename src/go/types/testdata/{ => check}/conversions.src (100%)
 rename src/go/types/testdata/{ => check}/conversions2.src (100%)
 rename src/go/types/testdata/{ => check}/cycles.src (100%)
 rename src/go/types/testdata/{ => check}/cycles1.src (100%)
 rename src/go/types/testdata/{ => check}/cycles2.src (100%)
 rename src/go/types/testdata/{ => check}/cycles3.src (100%)
 rename src/go/types/testdata/{ => check}/cycles4.src (100%)
 rename src/go/types/testdata/{ => check}/cycles5.src (100%)
 rename src/go/types/testdata/{ => check}/decls0.src (100%)
 rename src/go/types/testdata/{ => check}/decls1.src (100%)
 rename src/go/types/testdata/{ => check}/decls2/decls2a.src (100%)
 rename src/go/types/testdata/{ => check}/decls2/decls2b.src (100%)
 rename src/go/types/testdata/{ => check}/decls3.src (100%)
 rename src/go/types/testdata/{ => check}/decls4.src (100%)
 rename src/go/types/testdata/{ => check}/decls5.src (100%)
 rename src/go/types/testdata/{ => check}/errors.src (100%)
 rename src/go/types/testdata/{ => check}/expr0.src (100%)
 rename src/go/types/testdata/{ => check}/expr1.src (100%)
 rename src/go/types/testdata/{ => check}/expr2.src (100%)
 rename src/go/types/testdata/{ => check}/expr3.src (100%)
 rename src/go/types/testdata/{ => check}/go1_12.src (100%)
 rename src/go/types/testdata/{ => check}/go1_13.src (100%)
 rename src/go/types/testdata/{ => check}/go1_8.src (100%)
 rename src/go/types/testdata/{ => check}/gotos.src (100%)
 rename src/go/types/testdata/{ => check}/importC.src (100%)
 rename src/go/types/testdata/{ => check}/importdecl0/importdecl0a.src (100%)
 rename src/go/types/testdata/{ => check}/importdecl0/importdecl0b.src (100%)
 rename src/go/types/testdata/{ => check}/importdecl1/importdecl1a.src (100%)
 rename src/go/types/testdata/{ => check}/importdecl1/importdecl1b.src (100%)
 rename src/go/types/testdata/{ => check}/init0.src (100%)
 rename src/go/types/testdata/{ => check}/init1.src (100%)
 rename src/go/types/testdata/{ => check}/init2.src (100%)
 rename src/go/types/testdata/{ => check}/issue25008/issue25008a.src (100%)
 rename src/go/types/testdata/{ => check}/issue25008/issue25008b.src (100%)
 rename src/go/types/testdata/{ => check}/issues.go2 (100%)
 rename src/go/types/testdata/{ => check}/issues.src (100%)
 rename src/go/types/testdata/{ => check}/labels.src (100%)
 rename src/go/types/testdata/{ => check}/linalg.go2 (100%)
 rename src/go/types/testdata/{ => check}/literals.src (100%)
 rename src/go/types/testdata/{ => check}/main.src (100%)
 rename src/go/types/testdata/{ => check}/map.go2 (100%)
 rename src/go/types/testdata/{ => check}/map2.go2 (100%)
 rename src/go/types/testdata/{ => check}/methodsets.src (100%)
 rename src/go/types/testdata/{ => check}/shifts.src (100%)
 rename src/go/types/testdata/{ => check}/slices.go2 (100%)
 rename src/go/types/testdata/{ => check}/stmt0.src (100%)
 rename src/go/types/testdata/{ => check}/stmt1.src (100%)
 rename src/go/types/testdata/{ => check}/tinference.go2 (100%)
 rename src/go/types/testdata/{ => check}/tmp.go2 (100%)
 rename src/go/types/testdata/{ => check}/todos.go2 (100%)
 rename src/go/types/testdata/{ => check}/typeinst.go2 (100%)
 rename src/go/types/testdata/{ => check}/typeinst2.go2 (100%)
 rename src/go/types/testdata/{ => check}/typeparams.go2 (100%)
 rename src/go/types/testdata/{ => check}/vardecl.src (100%)
 rename src/go/types/{ => testdata}/examples/functions.go2 (100%)
 rename src/go/types/{ => testdata}/examples/inference.go2 (100%)
 rename src/go/types/{ => testdata}/examples/methods.go2 (100%)
 rename src/go/types/{ => testdata}/examples/types.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue20583.src (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue23203a.src (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue23203b.src (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue26390.src (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue28251.src (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue39634.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue39664.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue39680.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue39693.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue39699.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue39711.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue39723.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue39725.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue39754.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue39755.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue39768.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue39938.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue39948.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue39976.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue39982.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue40038.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue40056.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue40057.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue40301.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue40684.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue41124.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue42695.src (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue42758.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue43087.src (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue43110.src (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue43124.src (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue44688.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue44799.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue45548.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue45635.go2 (100%)
 rename src/go/types/{ => testdata}/fixedbugs/issue6977.src (100%)

diff --git a/src/go/types/check_test.go b/src/go/types/check_test.go
index 422488744b..0f23952380 100644
--- a/src/go/types/check_test.go
+++ b/src/go/types/check_test.go
@@ -47,8 +47,8 @@ import (
 var (
 	haltOnError = flag.Bool("halt", false, "halt on error")
 	listErrors  = flag.Bool("errlist", false, "list errors")
-	testFiles   = flag.String("files", "", "comma-separated list of test files")
-	goVersion   = flag.String("lang", "", "Go language version (e.g. \"go1.12\"")
+	testFiles   = flag.String("files", "", "comma-separated list of test files for TestManual")
+	goVersion   = flag.String("lang", "", "Go language version (e.g. \"go1.12\") for TestManual")
 )
 
 var fset = token.NewFileSet()
@@ -297,9 +297,10 @@ func checkFiles(t *testing.T, sizes Sizes, goVersion string, filenames []string,
 	}
 }
 
-// TestCheck is for manual testing of selected input files, provided with -files.
+// TestManual is for manual testing of selected input files, provided with
+// -files.
 // The accepted Go language version can be controlled with the -lang flag.
-func TestCheck(t *testing.T) {
+func TestManual(t *testing.T) {
 	if *testFiles == "" {
 		return
 	}
@@ -322,13 +323,14 @@ func TestIndexRepresentability(t *testing.T) {
 	checkFiles(t, &StdSizes{4, 4}, "", []string{"index.go"}, [][]byte{[]byte(src)})
 }
 
-func TestTestdata(t *testing.T)  { DefPredeclaredTestFuncs(); testDir(t, "testdata") }
+func TestCheck(t *testing.T)     { DefPredeclaredTestFuncs(); testDir(t, "check") }
 func TestExamples(t *testing.T)  { testDir(t, "examples") }
 func TestFixedbugs(t *testing.T) { testDir(t, "fixedbugs") }
 
 func testDir(t *testing.T, dir string) {
 	testenv.MustHaveGoBuild(t)
 
+	dir = filepath.Join("testdata", dir)
 	fis, err := os.ReadDir(dir)
 	if err != nil {
 		t.Error(err)
diff --git a/src/go/types/testdata/blank.src b/src/go/types/testdata/check/blank.src
similarity index 100%
rename from src/go/types/testdata/blank.src
rename to src/go/types/testdata/check/blank.src
diff --git a/src/go/types/testdata/builtins.go2 b/src/go/types/testdata/check/builtins.go2
similarity index 100%
rename from src/go/types/testdata/builtins.go2
rename to src/go/types/testdata/check/builtins.go2
diff --git a/src/go/types/testdata/builtins.src b/src/go/types/testdata/check/builtins.src
similarity index 100%
rename from src/go/types/testdata/builtins.src
rename to src/go/types/testdata/check/builtins.src
diff --git a/src/go/types/testdata/chans.go2 b/src/go/types/testdata/check/chans.go2
similarity index 100%
rename from src/go/types/testdata/chans.go2
rename to src/go/types/testdata/check/chans.go2
diff --git a/src/go/types/testdata/const0.src b/src/go/types/testdata/check/const0.src
similarity index 100%
rename from src/go/types/testdata/const0.src
rename to src/go/types/testdata/check/const0.src
diff --git a/src/go/types/testdata/const1.src b/src/go/types/testdata/check/const1.src
similarity index 100%
rename from src/go/types/testdata/const1.src
rename to src/go/types/testdata/check/const1.src
diff --git a/src/go/types/testdata/constdecl.src b/src/go/types/testdata/check/constdecl.src
similarity index 100%
rename from src/go/types/testdata/constdecl.src
rename to src/go/types/testdata/check/constdecl.src
diff --git a/src/go/types/testdata/conversions.src b/src/go/types/testdata/check/conversions.src
similarity index 100%
rename from src/go/types/testdata/conversions.src
rename to src/go/types/testdata/check/conversions.src
diff --git a/src/go/types/testdata/conversions2.src b/src/go/types/testdata/check/conversions2.src
similarity index 100%
rename from src/go/types/testdata/conversions2.src
rename to src/go/types/testdata/check/conversions2.src
diff --git a/src/go/types/testdata/cycles.src b/src/go/types/testdata/check/cycles.src
similarity index 100%
rename from src/go/types/testdata/cycles.src
rename to src/go/types/testdata/check/cycles.src
diff --git a/src/go/types/testdata/cycles1.src b/src/go/types/testdata/check/cycles1.src
similarity index 100%
rename from src/go/types/testdata/cycles1.src
rename to src/go/types/testdata/check/cycles1.src
diff --git a/src/go/types/testdata/cycles2.src b/src/go/types/testdata/check/cycles2.src
similarity index 100%
rename from src/go/types/testdata/cycles2.src
rename to src/go/types/testdata/check/cycles2.src
diff --git a/src/go/types/testdata/cycles3.src b/src/go/types/testdata/check/cycles3.src
similarity index 100%
rename from src/go/types/testdata/cycles3.src
rename to src/go/types/testdata/check/cycles3.src
diff --git a/src/go/types/testdata/cycles4.src b/src/go/types/testdata/check/cycles4.src
similarity index 100%
rename from src/go/types/testdata/cycles4.src
rename to src/go/types/testdata/check/cycles4.src
diff --git a/src/go/types/testdata/cycles5.src b/src/go/types/testdata/check/cycles5.src
similarity index 100%
rename from src/go/types/testdata/cycles5.src
rename to src/go/types/testdata/check/cycles5.src
diff --git a/src/go/types/testdata/decls0.src b/src/go/types/testdata/check/decls0.src
similarity index 100%
rename from src/go/types/testdata/decls0.src
rename to src/go/types/testdata/check/decls0.src
diff --git a/src/go/types/testdata/decls1.src b/src/go/types/testdata/check/decls1.src
similarity index 100%
rename from src/go/types/testdata/decls1.src
rename to src/go/types/testdata/check/decls1.src
diff --git a/src/go/types/testdata/decls2/decls2a.src b/src/go/types/testdata/check/decls2/decls2a.src
similarity index 100%
rename from src/go/types/testdata/decls2/decls2a.src
rename to src/go/types/testdata/check/decls2/decls2a.src
diff --git a/src/go/types/testdata/decls2/decls2b.src b/src/go/types/testdata/check/decls2/decls2b.src
similarity index 100%
rename from src/go/types/testdata/decls2/decls2b.src
rename to src/go/types/testdata/check/decls2/decls2b.src
diff --git a/src/go/types/testdata/decls3.src b/src/go/types/testdata/check/decls3.src
similarity index 100%
rename from src/go/types/testdata/decls3.src
rename to src/go/types/testdata/check/decls3.src
diff --git a/src/go/types/testdata/decls4.src b/src/go/types/testdata/check/decls4.src
similarity index 100%
rename from src/go/types/testdata/decls4.src
rename to src/go/types/testdata/check/decls4.src
diff --git a/src/go/types/testdata/decls5.src b/src/go/types/testdata/check/decls5.src
similarity index 100%
rename from src/go/types/testdata/decls5.src
rename to src/go/types/testdata/check/decls5.src
diff --git a/src/go/types/testdata/errors.src b/src/go/types/testdata/check/errors.src
similarity index 100%
rename from src/go/types/testdata/errors.src
rename to src/go/types/testdata/check/errors.src
diff --git a/src/go/types/testdata/expr0.src b/src/go/types/testdata/check/expr0.src
similarity index 100%
rename from src/go/types/testdata/expr0.src
rename to src/go/types/testdata/check/expr0.src
diff --git a/src/go/types/testdata/expr1.src b/src/go/types/testdata/check/expr1.src
similarity index 100%
rename from src/go/types/testdata/expr1.src
rename to src/go/types/testdata/check/expr1.src
diff --git a/src/go/types/testdata/expr2.src b/src/go/types/testdata/check/expr2.src
similarity index 100%
rename from src/go/types/testdata/expr2.src
rename to src/go/types/testdata/check/expr2.src
diff --git a/src/go/types/testdata/expr3.src b/src/go/types/testdata/check/expr3.src
similarity index 100%
rename from src/go/types/testdata/expr3.src
rename to src/go/types/testdata/check/expr3.src
diff --git a/src/go/types/testdata/go1_12.src b/src/go/types/testdata/check/go1_12.src
similarity index 100%
rename from src/go/types/testdata/go1_12.src
rename to src/go/types/testdata/check/go1_12.src
diff --git a/src/go/types/testdata/go1_13.src b/src/go/types/testdata/check/go1_13.src
similarity index 100%
rename from src/go/types/testdata/go1_13.src
rename to src/go/types/testdata/check/go1_13.src
diff --git a/src/go/types/testdata/go1_8.src b/src/go/types/testdata/check/go1_8.src
similarity index 100%
rename from src/go/types/testdata/go1_8.src
rename to src/go/types/testdata/check/go1_8.src
diff --git a/src/go/types/testdata/gotos.src b/src/go/types/testdata/check/gotos.src
similarity index 100%
rename from src/go/types/testdata/gotos.src
rename to src/go/types/testdata/check/gotos.src
diff --git a/src/go/types/testdata/importC.src b/src/go/types/testdata/check/importC.src
similarity index 100%
rename from src/go/types/testdata/importC.src
rename to src/go/types/testdata/check/importC.src
diff --git a/src/go/types/testdata/importdecl0/importdecl0a.src b/src/go/types/testdata/check/importdecl0/importdecl0a.src
similarity index 100%
rename from src/go/types/testdata/importdecl0/importdecl0a.src
rename to src/go/types/testdata/check/importdecl0/importdecl0a.src
diff --git a/src/go/types/testdata/importdecl0/importdecl0b.src b/src/go/types/testdata/check/importdecl0/importdecl0b.src
similarity index 100%
rename from src/go/types/testdata/importdecl0/importdecl0b.src
rename to src/go/types/testdata/check/importdecl0/importdecl0b.src
diff --git a/src/go/types/testdata/importdecl1/importdecl1a.src b/src/go/types/testdata/check/importdecl1/importdecl1a.src
similarity index 100%
rename from src/go/types/testdata/importdecl1/importdecl1a.src
rename to src/go/types/testdata/check/importdecl1/importdecl1a.src
diff --git a/src/go/types/testdata/importdecl1/importdecl1b.src b/src/go/types/testdata/check/importdecl1/importdecl1b.src
similarity index 100%
rename from src/go/types/testdata/importdecl1/importdecl1b.src
rename to src/go/types/testdata/check/importdecl1/importdecl1b.src
diff --git a/src/go/types/testdata/init0.src b/src/go/types/testdata/check/init0.src
similarity index 100%
rename from src/go/types/testdata/init0.src
rename to src/go/types/testdata/check/init0.src
diff --git a/src/go/types/testdata/init1.src b/src/go/types/testdata/check/init1.src
similarity index 100%
rename from src/go/types/testdata/init1.src
rename to src/go/types/testdata/check/init1.src
diff --git a/src/go/types/testdata/init2.src b/src/go/types/testdata/check/init2.src
similarity index 100%
rename from src/go/types/testdata/init2.src
rename to src/go/types/testdata/check/init2.src
diff --git a/src/go/types/testdata/issue25008/issue25008a.src b/src/go/types/testdata/check/issue25008/issue25008a.src
similarity index 100%
rename from src/go/types/testdata/issue25008/issue25008a.src
rename to src/go/types/testdata/check/issue25008/issue25008a.src
diff --git a/src/go/types/testdata/issue25008/issue25008b.src b/src/go/types/testdata/check/issue25008/issue25008b.src
similarity index 100%
rename from src/go/types/testdata/issue25008/issue25008b.src
rename to src/go/types/testdata/check/issue25008/issue25008b.src
diff --git a/src/go/types/testdata/issues.go2 b/src/go/types/testdata/check/issues.go2
similarity index 100%
rename from src/go/types/testdata/issues.go2
rename to src/go/types/testdata/check/issues.go2
diff --git a/src/go/types/testdata/issues.src b/src/go/types/testdata/check/issues.src
similarity index 100%
rename from src/go/types/testdata/issues.src
rename to src/go/types/testdata/check/issues.src
diff --git a/src/go/types/testdata/labels.src b/src/go/types/testdata/check/labels.src
similarity index 100%
rename from src/go/types/testdata/labels.src
rename to src/go/types/testdata/check/labels.src
diff --git a/src/go/types/testdata/linalg.go2 b/src/go/types/testdata/check/linalg.go2
similarity index 100%
rename from src/go/types/testdata/linalg.go2
rename to src/go/types/testdata/check/linalg.go2
diff --git a/src/go/types/testdata/literals.src b/src/go/types/testdata/check/literals.src
similarity index 100%
rename from src/go/types/testdata/literals.src
rename to src/go/types/testdata/check/literals.src
diff --git a/src/go/types/testdata/main.src b/src/go/types/testdata/check/main.src
similarity index 100%
rename from src/go/types/testdata/main.src
rename to src/go/types/testdata/check/main.src
diff --git a/src/go/types/testdata/map.go2 b/src/go/types/testdata/check/map.go2
similarity index 100%
rename from src/go/types/testdata/map.go2
rename to src/go/types/testdata/check/map.go2
diff --git a/src/go/types/testdata/map2.go2 b/src/go/types/testdata/check/map2.go2
similarity index 100%
rename from src/go/types/testdata/map2.go2
rename to src/go/types/testdata/check/map2.go2
diff --git a/src/go/types/testdata/methodsets.src b/src/go/types/testdata/check/methodsets.src
similarity index 100%
rename from src/go/types/testdata/methodsets.src
rename to src/go/types/testdata/check/methodsets.src
diff --git a/src/go/types/testdata/shifts.src b/src/go/types/testdata/check/shifts.src
similarity index 100%
rename from src/go/types/testdata/shifts.src
rename to src/go/types/testdata/check/shifts.src
diff --git a/src/go/types/testdata/slices.go2 b/src/go/types/testdata/check/slices.go2
similarity index 100%
rename from src/go/types/testdata/slices.go2
rename to src/go/types/testdata/check/slices.go2
diff --git a/src/go/types/testdata/stmt0.src b/src/go/types/testdata/check/stmt0.src
similarity index 100%
rename from src/go/types/testdata/stmt0.src
rename to src/go/types/testdata/check/stmt0.src
diff --git a/src/go/types/testdata/stmt1.src b/src/go/types/testdata/check/stmt1.src
similarity index 100%
rename from src/go/types/testdata/stmt1.src
rename to src/go/types/testdata/check/stmt1.src
diff --git a/src/go/types/testdata/tinference.go2 b/src/go/types/testdata/check/tinference.go2
similarity index 100%
rename from src/go/types/testdata/tinference.go2
rename to src/go/types/testdata/check/tinference.go2
diff --git a/src/go/types/testdata/tmp.go2 b/src/go/types/testdata/check/tmp.go2
similarity index 100%
rename from src/go/types/testdata/tmp.go2
rename to src/go/types/testdata/check/tmp.go2
diff --git a/src/go/types/testdata/todos.go2 b/src/go/types/testdata/check/todos.go2
similarity index 100%
rename from src/go/types/testdata/todos.go2
rename to src/go/types/testdata/check/todos.go2
diff --git a/src/go/types/testdata/typeinst.go2 b/src/go/types/testdata/check/typeinst.go2
similarity index 100%
rename from src/go/types/testdata/typeinst.go2
rename to src/go/types/testdata/check/typeinst.go2
diff --git a/src/go/types/testdata/typeinst2.go2 b/src/go/types/testdata/check/typeinst2.go2
similarity index 100%
rename from src/go/types/testdata/typeinst2.go2
rename to src/go/types/testdata/check/typeinst2.go2
diff --git a/src/go/types/testdata/typeparams.go2 b/src/go/types/testdata/check/typeparams.go2
similarity index 100%
rename from src/go/types/testdata/typeparams.go2
rename to src/go/types/testdata/check/typeparams.go2
diff --git a/src/go/types/testdata/vardecl.src b/src/go/types/testdata/check/vardecl.src
similarity index 100%
rename from src/go/types/testdata/vardecl.src
rename to src/go/types/testdata/check/vardecl.src
diff --git a/src/go/types/examples/functions.go2 b/src/go/types/testdata/examples/functions.go2
similarity index 100%
rename from src/go/types/examples/functions.go2
rename to src/go/types/testdata/examples/functions.go2
diff --git a/src/go/types/examples/inference.go2 b/src/go/types/testdata/examples/inference.go2
similarity index 100%
rename from src/go/types/examples/inference.go2
rename to src/go/types/testdata/examples/inference.go2
diff --git a/src/go/types/examples/methods.go2 b/src/go/types/testdata/examples/methods.go2
similarity index 100%
rename from src/go/types/examples/methods.go2
rename to src/go/types/testdata/examples/methods.go2
diff --git a/src/go/types/examples/types.go2 b/src/go/types/testdata/examples/types.go2
similarity index 100%
rename from src/go/types/examples/types.go2
rename to src/go/types/testdata/examples/types.go2
diff --git a/src/go/types/fixedbugs/issue20583.src b/src/go/types/testdata/fixedbugs/issue20583.src
similarity index 100%
rename from src/go/types/fixedbugs/issue20583.src
rename to src/go/types/testdata/fixedbugs/issue20583.src
diff --git a/src/go/types/fixedbugs/issue23203a.src b/src/go/types/testdata/fixedbugs/issue23203a.src
similarity index 100%
rename from src/go/types/fixedbugs/issue23203a.src
rename to src/go/types/testdata/fixedbugs/issue23203a.src
diff --git a/src/go/types/fixedbugs/issue23203b.src b/src/go/types/testdata/fixedbugs/issue23203b.src
similarity index 100%
rename from src/go/types/fixedbugs/issue23203b.src
rename to src/go/types/testdata/fixedbugs/issue23203b.src
diff --git a/src/go/types/fixedbugs/issue26390.src b/src/go/types/testdata/fixedbugs/issue26390.src
similarity index 100%
rename from src/go/types/fixedbugs/issue26390.src
rename to src/go/types/testdata/fixedbugs/issue26390.src
diff --git a/src/go/types/fixedbugs/issue28251.src b/src/go/types/testdata/fixedbugs/issue28251.src
similarity index 100%
rename from src/go/types/fixedbugs/issue28251.src
rename to src/go/types/testdata/fixedbugs/issue28251.src
diff --git a/src/go/types/fixedbugs/issue39634.go2 b/src/go/types/testdata/fixedbugs/issue39634.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue39634.go2
rename to src/go/types/testdata/fixedbugs/issue39634.go2
diff --git a/src/go/types/fixedbugs/issue39664.go2 b/src/go/types/testdata/fixedbugs/issue39664.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue39664.go2
rename to src/go/types/testdata/fixedbugs/issue39664.go2
diff --git a/src/go/types/fixedbugs/issue39680.go2 b/src/go/types/testdata/fixedbugs/issue39680.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue39680.go2
rename to src/go/types/testdata/fixedbugs/issue39680.go2
diff --git a/src/go/types/fixedbugs/issue39693.go2 b/src/go/types/testdata/fixedbugs/issue39693.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue39693.go2
rename to src/go/types/testdata/fixedbugs/issue39693.go2
diff --git a/src/go/types/fixedbugs/issue39699.go2 b/src/go/types/testdata/fixedbugs/issue39699.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue39699.go2
rename to src/go/types/testdata/fixedbugs/issue39699.go2
diff --git a/src/go/types/fixedbugs/issue39711.go2 b/src/go/types/testdata/fixedbugs/issue39711.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue39711.go2
rename to src/go/types/testdata/fixedbugs/issue39711.go2
diff --git a/src/go/types/fixedbugs/issue39723.go2 b/src/go/types/testdata/fixedbugs/issue39723.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue39723.go2
rename to src/go/types/testdata/fixedbugs/issue39723.go2
diff --git a/src/go/types/fixedbugs/issue39725.go2 b/src/go/types/testdata/fixedbugs/issue39725.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue39725.go2
rename to src/go/types/testdata/fixedbugs/issue39725.go2
diff --git a/src/go/types/fixedbugs/issue39754.go2 b/src/go/types/testdata/fixedbugs/issue39754.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue39754.go2
rename to src/go/types/testdata/fixedbugs/issue39754.go2
diff --git a/src/go/types/fixedbugs/issue39755.go2 b/src/go/types/testdata/fixedbugs/issue39755.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue39755.go2
rename to src/go/types/testdata/fixedbugs/issue39755.go2
diff --git a/src/go/types/fixedbugs/issue39768.go2 b/src/go/types/testdata/fixedbugs/issue39768.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue39768.go2
rename to src/go/types/testdata/fixedbugs/issue39768.go2
diff --git a/src/go/types/fixedbugs/issue39938.go2 b/src/go/types/testdata/fixedbugs/issue39938.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue39938.go2
rename to src/go/types/testdata/fixedbugs/issue39938.go2
diff --git a/src/go/types/fixedbugs/issue39948.go2 b/src/go/types/testdata/fixedbugs/issue39948.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue39948.go2
rename to src/go/types/testdata/fixedbugs/issue39948.go2
diff --git a/src/go/types/fixedbugs/issue39976.go2 b/src/go/types/testdata/fixedbugs/issue39976.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue39976.go2
rename to src/go/types/testdata/fixedbugs/issue39976.go2
diff --git a/src/go/types/fixedbugs/issue39982.go2 b/src/go/types/testdata/fixedbugs/issue39982.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue39982.go2
rename to src/go/types/testdata/fixedbugs/issue39982.go2
diff --git a/src/go/types/fixedbugs/issue40038.go2 b/src/go/types/testdata/fixedbugs/issue40038.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue40038.go2
rename to src/go/types/testdata/fixedbugs/issue40038.go2
diff --git a/src/go/types/fixedbugs/issue40056.go2 b/src/go/types/testdata/fixedbugs/issue40056.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue40056.go2
rename to src/go/types/testdata/fixedbugs/issue40056.go2
diff --git a/src/go/types/fixedbugs/issue40057.go2 b/src/go/types/testdata/fixedbugs/issue40057.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue40057.go2
rename to src/go/types/testdata/fixedbugs/issue40057.go2
diff --git a/src/go/types/fixedbugs/issue40301.go2 b/src/go/types/testdata/fixedbugs/issue40301.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue40301.go2
rename to src/go/types/testdata/fixedbugs/issue40301.go2
diff --git a/src/go/types/fixedbugs/issue40684.go2 b/src/go/types/testdata/fixedbugs/issue40684.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue40684.go2
rename to src/go/types/testdata/fixedbugs/issue40684.go2
diff --git a/src/go/types/fixedbugs/issue41124.go2 b/src/go/types/testdata/fixedbugs/issue41124.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue41124.go2
rename to src/go/types/testdata/fixedbugs/issue41124.go2
diff --git a/src/go/types/fixedbugs/issue42695.src b/src/go/types/testdata/fixedbugs/issue42695.src
similarity index 100%
rename from src/go/types/fixedbugs/issue42695.src
rename to src/go/types/testdata/fixedbugs/issue42695.src
diff --git a/src/go/types/fixedbugs/issue42758.go2 b/src/go/types/testdata/fixedbugs/issue42758.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue42758.go2
rename to src/go/types/testdata/fixedbugs/issue42758.go2
diff --git a/src/go/types/fixedbugs/issue43087.src b/src/go/types/testdata/fixedbugs/issue43087.src
similarity index 100%
rename from src/go/types/fixedbugs/issue43087.src
rename to src/go/types/testdata/fixedbugs/issue43087.src
diff --git a/src/go/types/fixedbugs/issue43110.src b/src/go/types/testdata/fixedbugs/issue43110.src
similarity index 100%
rename from src/go/types/fixedbugs/issue43110.src
rename to src/go/types/testdata/fixedbugs/issue43110.src
diff --git a/src/go/types/fixedbugs/issue43124.src b/src/go/types/testdata/fixedbugs/issue43124.src
similarity index 100%
rename from src/go/types/fixedbugs/issue43124.src
rename to src/go/types/testdata/fixedbugs/issue43124.src
diff --git a/src/go/types/fixedbugs/issue44688.go2 b/src/go/types/testdata/fixedbugs/issue44688.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue44688.go2
rename to src/go/types/testdata/fixedbugs/issue44688.go2
diff --git a/src/go/types/fixedbugs/issue44799.go2 b/src/go/types/testdata/fixedbugs/issue44799.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue44799.go2
rename to src/go/types/testdata/fixedbugs/issue44799.go2
diff --git a/src/go/types/fixedbugs/issue45548.go2 b/src/go/types/testdata/fixedbugs/issue45548.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue45548.go2
rename to src/go/types/testdata/fixedbugs/issue45548.go2
diff --git a/src/go/types/fixedbugs/issue45635.go2 b/src/go/types/testdata/fixedbugs/issue45635.go2
similarity index 100%
rename from src/go/types/fixedbugs/issue45635.go2
rename to src/go/types/testdata/fixedbugs/issue45635.go2
diff --git a/src/go/types/fixedbugs/issue6977.src b/src/go/types/testdata/fixedbugs/issue6977.src
similarity index 100%
rename from src/go/types/fixedbugs/issue6977.src
rename to src/go/types/testdata/fixedbugs/issue6977.src
-- 
GitLab


From c8a92d454c74d89f172f6d534395a0553eff8f20 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 28 Apr 2021 15:49:17 -0400
Subject: [PATCH 1844/2400] go/types: ensure that error code values do not
 change in 1.17

Over this cycle some error code values have changed due to codes being
added/removed. This is probably OK to do once more before we export
error codes in a later Go version, but for now let's keep them stable.

Move things around to correct the changes, and update comments in
errorcodes.go to make it clearer that new codes should be added at the
end.

Change-Id: Id32827ef1a72cfd876ccc039da11d0a1be7470e9
Reviewed-on: https://go-review.googlesource.com/c/go/+/314830
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/errorcodes.go | 150 ++++++++++++-------------------------
 1 file changed, 47 insertions(+), 103 deletions(-)

diff --git a/src/go/types/errorcodes.go b/src/go/types/errorcodes.go
index a33a4e7dce..3d24da7b53 100644
--- a/src/go/types/errorcodes.go
+++ b/src/go/types/errorcodes.go
@@ -10,6 +10,8 @@ type errorCode int
 // Collectively, these codes provide an identifier that may be used to
 // implement special handling for certain types of errors.
 //
+// Error code values should not be changed: add new codes at the end.
+//
 // Error codes should be fine-grained enough that the exact nature of the error
 // can be easily determined, but coarse enough that they are not an
 // implementation detail of the type checking algorithm. As a rule-of-thumb,
@@ -34,8 +36,6 @@ const (
 	// _Test is reserved for errors that only apply while in self-test mode.
 	_Test
 
-	/* package names */
-
 	// _BlankPkgName occurs when a package name is the blank identifier "_".
 	//
 	// Per the spec:
@@ -55,8 +55,6 @@ const (
 	//  var _ = fmt
 	_InvalidPkgUse
 
-	/* imports */
-
 	// _BadImportPath occurs when an import path is not valid.
 	_BadImportPath
 
@@ -81,8 +79,6 @@ const (
 	//  func main() {}
 	_UnusedImport
 
-	/* initialization */
-
 	// _InvalidInitCycle occurs when an invalid cycle is detected within the
 	// initialization graph.
 	//
@@ -92,8 +88,6 @@ const (
 	//  func f() int { return x }
 	_InvalidInitCycle
 
-	/* decls */
-
 	// _DuplicateDecl occurs when an identifier is declared multiple times.
 	//
 	// Example:
@@ -122,8 +116,6 @@ const (
 	//  type T [unsafe.Sizeof(T{})]int
 	_InvalidTypeCycle
 
-	/* decls > const */
-
 	// _InvalidConstInit occurs when a const declaration has a non-constant
 	// initializer.
 	//
@@ -149,8 +141,6 @@ const (
 	//  const c *int = 4
 	_InvalidConstType
 
-	/* decls > var (+ other variable assignment codes) */
-
 	// _UntypedNil occurs when the predeclared (untyped) value nil is used to
 	// initialize a variable declared without an explicit type.
 	//
@@ -249,8 +239,6 @@ const (
 	//  }
 	_UnaddressableFieldAssign
 
-	/* decls > type (+ other type expression codes) */
-
 	// _NotAType occurs when the identifier used as the underlying type in a type
 	// declaration or the right-hand side of a type alias does not denote a type.
 	//
@@ -320,8 +308,6 @@ const (
 	//  }
 	_InvalidPtrEmbed
 
-	/* decls > func and method */
-
 	// _BadRecv occurs when a method declaration does not have exactly one
 	// receiver parameter.
 	//
@@ -358,8 +344,6 @@ const (
 	//  func (T) m(i int) int { return i }
 	_DuplicateMethod
 
-	/* decls > special */
-
 	// _InvalidBlank occurs when a blank identifier is used as a value or type.
 	//
 	// Per the spec:
@@ -404,8 +388,6 @@ const (
 	// function, in a main package.
 	_InvalidMainDecl
 
-	/* exprs */
-
 	// _TooManyValues occurs when a function returns too many values for the
 	// expression context in which it is used.
 	//
@@ -428,8 +410,6 @@ const (
 	//  }
 	_NotAnExpr
 
-	/* exprs > const */
-
 	// _TruncatedFloat occurs when a float constant is truncated to an integer
 	// value.
 	//
@@ -443,8 +423,6 @@ const (
 	//  var x int8 = 1000
 	_NumericOverflow
 
-	/* exprs > operation */
-
 	// _UndefinedOp occurs when an operator is not defined for the type(s) used
 	// in an operation.
 	//
@@ -479,8 +457,6 @@ const (
 	//  }
 	_NonNumericIncDec
 
-	/* exprs > ptr */
-
 	// _UnaddressableOperand occurs when the & operator is applied to an
 	// unaddressable expression.
 	//
@@ -496,8 +472,6 @@ const (
 	//  var y = *x
 	_InvalidIndirection
 
-	/* exprs > [] */
-
 	// _NonIndexableOperand occurs when an index operation is applied to a value
 	// that cannot be indexed.
 	//
@@ -530,8 +504,6 @@ const (
 	//  var _ = []int{1,2,3}[2:1]
 	_SwappedSliceIndices
 
-	/* operators > slice */
-
 	// _NonSliceableOperand occurs when a slice operation is applied to a value
 	// whose type is not sliceable, or is unaddressable.
 	//
@@ -551,8 +523,6 @@ const (
 	//  var x = s[1:2:3]
 	_InvalidSliceExpr
 
-	/* exprs > shift */
-
 	// _InvalidShiftCount occurs when the right-hand side of a shift operation is
 	// either non-integer, negative, or too large.
 	//
@@ -570,8 +540,6 @@ const (
 	//  var x = s << 2
 	_InvalidShiftOperand
 
-	/* exprs > chan */
-
 	// _InvalidReceive occurs when there is a channel receive from a value that
 	// is either not a channel, or is a send-only channel.
 	//
@@ -592,8 +560,6 @@ const (
 	//  }
 	_InvalidSend
 
-	/* exprs > literal */
-
 	// _DuplicateLitKey occurs when an index is duplicated in a slice, array, or
 	// map literal.
 	//
@@ -683,8 +649,6 @@ const (
 	//  var _ = P {}
 	_InvalidLit
 
-	/* exprs > selector */
-
 	// _AmbiguousSelector occurs when a selector is ambiguous.
 	//
 	// Example:
@@ -730,8 +694,6 @@ const (
 	//  var x = T{}.f
 	_MissingFieldOrMethod
 
-	/* exprs > ... */
-
 	// _BadDotDotDotSyntax occurs when a "..." occurs in a context where it is
 	// not valid.
 	//
@@ -762,6 +724,8 @@ const (
 	// 	func f(...int, int)
 	_MisplacedDotDotDot
 
+	_ // _InvalidDotDotDotOperand was removed.
+
 	// _InvalidDotDotDot occurs when a "..." is used in a non-variadic built-in
 	// function.
 	//
@@ -770,8 +734,6 @@ const (
 	//  var l = len(s...)
 	_InvalidDotDotDot
 
-	/* exprs > built-in */
-
 	// _UncalledBuiltin occurs when a built-in function is used as a
 	// function-valued expression, instead of being called.
 	//
@@ -883,47 +845,6 @@ const (
 	//  var _ = real(int(1))
 	_InvalidReal
 
-	// _InvalidUnsafeAdd occurs when unsafe.Add is called with a
-	// length argument that is not of integer type.
-	//
-	// Example:
-	//  import "unsafe"
-	//
-	//  var p unsafe.Pointer
-	//  var _ = unsafe.Add(p, float64(1))
-	_InvalidUnsafeAdd
-
-	// _InvalidUnsafeSlice occurs when unsafe.Slice is called with a
-	// pointer argument that is not of pointer type or a length argument
-	// that is not of integer type, negative, or out of bounds.
-	//
-	// Example:
-	//  import "unsafe"
-	//
-	//  var x int
-	//  var _ = unsafe.Slice(x, 1)
-	//
-	// Example:
-	//  import "unsafe"
-	//
-	//  var x int
-	//  var _ = unsafe.Slice(&x, float64(1))
-	//
-	// Example:
-	//  import "unsafe"
-	//
-	//  var x int
-	//  var _ = unsafe.Slice(&x, -1)
-	//
-	// Example:
-	//  import "unsafe"
-	//
-	//  var x int
-	//  var _ = unsafe.Slice(&x, uint64(1) << 63)
-	_InvalidUnsafeSlice
-
-	/* exprs > assertion */
-
 	// _InvalidAssert occurs when a type assertion is applied to a
 	// value that is not of interface type.
 	//
@@ -947,8 +868,6 @@ const (
 	//  var _ = x.(T)
 	_ImpossibleAssert
 
-	/* exprs > conversion */
-
 	// _InvalidConversion occurs when the argument type cannot be converted to the
 	// target.
 	//
@@ -968,8 +887,6 @@ const (
 	//  var _ = 1 + ""
 	_InvalidUntypedConversion
 
-	/* offsetof */
-
 	// _BadOffsetofSyntax occurs when unsafe.Offsetof is called with an argument
 	// that is not a selector expression.
 	//
@@ -1008,8 +925,6 @@ const (
 	//  var _ = unsafe.Offsetof(s.m)
 	_InvalidOffsetof
 
-	/* control flow > scope */
-
 	// _UnusedExpr occurs when a side-effect free expression is used as a
 	// statement. Such a statement has no effect.
 	//
@@ -1057,8 +972,6 @@ const (
 	//  }
 	_OutOfScopeResult
 
-	/* control flow > if */
-
 	// _InvalidCond occurs when an if condition is not a boolean expression.
 	//
 	// Example:
@@ -1069,8 +982,6 @@ const (
 	//  }
 	_InvalidCond
 
-	/* control flow > for */
-
 	// _InvalidPostDecl occurs when there is a declaration in a for-loop post
 	// statement.
 	//
@@ -1080,6 +991,8 @@ const (
 	//  }
 	_InvalidPostDecl
 
+	_ // _InvalidChanRange was removed.
+
 	// _InvalidIterVar occurs when two iteration variables are used while ranging
 	// over a channel.
 	//
@@ -1102,8 +1015,6 @@ const (
 	//  }
 	_InvalidRangeExpr
 
-	/* control flow > switch */
-
 	// _MisplacedBreak occurs when a break statement is not within a for, switch,
 	// or select statement of the innermost function definition.
 	//
@@ -1207,8 +1118,6 @@ const (
 	//  }
 	_InvalidExprSwitch
 
-	/* control flow > select */
-
 	// _InvalidSelectCase occurs when a select case is not a channel send or
 	// receive.
 	//
@@ -1223,8 +1132,6 @@ const (
 	//  }
 	_InvalidSelectCase
 
-	/* control flow > labels and jumps */
-
 	// _UndeclaredLabel occurs when an undeclared label is jumped to.
 	//
 	// Example:
@@ -1292,8 +1199,6 @@ const (
 	// }
 	_JumpIntoBlock
 
-	/* control flow > calls */
-
 	// _InvalidMethodExpr occurs when a pointer method is called but the argument
 	// is not addressable.
 	//
@@ -1321,8 +1226,6 @@ const (
 	//  var y = x()
 	_InvalidCall
 
-	/* control flow > suspended */
-
 	// _UnusedResults occurs when a restricted expression-only built-in function
 	// is suspended via go or defer. Such a suspension discards the results of
 	// these side-effect free built-in functions, and therefore is ineffectual.
@@ -1354,6 +1257,8 @@ const (
 	//  }
 	_InvalidGo
 
+	// All codes below were added in Go 1.17.
+
 	// _BadDecl occurs when a declaration has invalid syntax.
 	_BadDecl
 
@@ -1366,6 +1271,45 @@ const (
 	//  }
 	_RepeatedDecl
 
+	// _InvalidUnsafeAdd occurs when unsafe.Add is called with a
+	// length argument that is not of integer type.
+	//
+	// Example:
+	//  import "unsafe"
+	//
+	//  var p unsafe.Pointer
+	//  var _ = unsafe.Add(p, float64(1))
+	_InvalidUnsafeAdd
+
+	// _InvalidUnsafeSlice occurs when unsafe.Slice is called with a
+	// pointer argument that is not of pointer type or a length argument
+	// that is not of integer type, negative, or out of bounds.
+	//
+	// Example:
+	//  import "unsafe"
+	//
+	//  var x int
+	//  var _ = unsafe.Slice(x, 1)
+	//
+	// Example:
+	//  import "unsafe"
+	//
+	//  var x int
+	//  var _ = unsafe.Slice(&x, float64(1))
+	//
+	// Example:
+	//  import "unsafe"
+	//
+	//  var x int
+	//  var _ = unsafe.Slice(&x, -1)
+	//
+	// Example:
+	//  import "unsafe"
+	//
+	//  var x int
+	//  var _ = unsafe.Slice(&x, uint64(1) << 63)
+	_InvalidUnsafeSlice
+
 	// _Todo is a placeholder for error codes that have not been decided.
 	// TODO(rFindley) remove this error code after deciding on errors for generics code.
 	_Todo
-- 
GitLab


From eb3fe28d7079692a1545887a2c609b325ec7f087 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 28 Apr 2021 16:32:38 -0400
Subject: [PATCH 1845/2400] go/types: improve error messages for unexpected
 ListExprs

This CL is a mix of CL 312149 and CL 314409, adding the
Checker.singleIndex method to provide better error messages when an
unexpected ListExpr is encountered.

Change-Id: I45d6de9b4dfc299dc2d356ca14d05c9191de818d
Reviewed-on: https://go-review.googlesource.com/c/go/+/314869
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/expr.go                          |  3 +-
 src/go/types/index.go                         | 42 ++++++++++++++++---
 .../types/testdata/fixedbugs/issue45635.go2   | 10 ++---
 3 files changed, 44 insertions(+), 11 deletions(-)

diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 9bfe23a815..5c65fad447 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -1410,7 +1410,8 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 
 	default:
 		if typeparams.IsListExpr(e) {
-			check.errorf(e, _Todo, "invalid multi-index expression")
+			// catch-all for unexpected expression lists
+			check.errorf(e, _Todo, "unexpected list of expressions")
 		} else {
 			panic(fmt.Sprintf("%s: unknown expression type %T", check.fset.Position(e.Pos()), e))
 		}
diff --git a/src/go/types/index.go b/src/go/types/index.go
index f51c3f6acf..2ba3475f89 100644
--- a/src/go/types/index.go
+++ b/src/go/types/index.go
@@ -77,8 +77,13 @@ func (check *Checker) indexExpr(x *operand, e *ast.IndexExpr) (isFuncInst bool)
 		x.typ = typ.elem
 
 	case *Map:
+		index := check.singleIndex(e)
+		if index == nil {
+			x.mode = invalid
+			return
+		}
 		var key operand
-		check.expr(&key, e.Index)
+		check.expr(&key, index)
 		check.assignment(&key, typ.key, "map index")
 		// ok to continue even if indexing failed - map element type is known
 		x.mode = mapindex
@@ -132,8 +137,13 @@ func (check *Checker) indexExpr(x *operand, e *ast.IndexExpr) (isFuncInst bool)
 			// If there are maps, the index expression must be assignable
 			// to the map key type (as for simple map index expressions).
 			if nmaps > 0 {
+				index := check.singleIndex(e)
+				if index == nil {
+					x.mode = invalid
+					return
+				}
 				var key operand
-				check.expr(&key, e.Index)
+				check.expr(&key, index)
 				check.assignment(&key, tkey, "map index")
 				// ok to continue even if indexing failed - map element type is known
 
@@ -170,8 +180,8 @@ func (check *Checker) indexExpr(x *operand, e *ast.IndexExpr) (isFuncInst bool)
 		return
 	}
 
-	if e.Index == nil {
-		check.invalidAST(e, "missing index for %s", x)
+	index := check.singleIndex(e)
+	if index == nil {
 		x.mode = invalid
 		return
 	}
@@ -183,7 +193,7 @@ func (check *Checker) indexExpr(x *operand, e *ast.IndexExpr) (isFuncInst bool)
 		x.typ = Typ[Invalid]
 	}
 
-	check.index(e.Index, length)
+	check.index(index, length)
 	return false
 }
 
@@ -298,6 +308,28 @@ L:
 	}
 }
 
+// singleIndex returns the (single) index from the index expression e.
+// If the index is missing, or if there are multiple indices, an error
+// is reported and the result is nil.
+func (check *Checker) singleIndex(e *ast.IndexExpr) ast.Expr {
+	index := e.Index
+	if index == nil {
+		check.invalidAST(e, "missing index for %s", e)
+		return nil
+	}
+
+	indexes := typeparams.UnpackExpr(index)
+	if len(indexes) == 0 {
+		check.invalidAST(index, "index expression %v with 0 indices", index)
+		return nil
+	}
+	if len(indexes) > 1 {
+		// TODO(rFindley) should this get a distinct error code?
+		check.invalidOp(indexes[1], _InvalidIndex, "more than one index")
+	}
+	return indexes[0]
+}
+
 // index checks an index expression for validity.
 // If max >= 0, it is the upper bound for index.
 // If the result typ is != Typ[Invalid], index is valid and typ is its (possibly named) integer type.
diff --git a/src/go/types/testdata/fixedbugs/issue45635.go2 b/src/go/types/testdata/fixedbugs/issue45635.go2
index ec5cf3c5ff..3e2cceca2d 100644
--- a/src/go/types/testdata/fixedbugs/issue45635.go2
+++ b/src/go/types/testdata/fixedbugs/issue45635.go2
@@ -16,17 +16,17 @@ type I interface {
 	type map[int]int, []int
 }
 
-func _[T I]() {
+func _[T I](i, j int) {
 	var m map[int]int
-	_ = m[1 /* ERROR "multi-index expression" */, 2 /* ERROR "expected type" */ ]
+	_ = m[i, j /* ERROR "more than one index" */ ]
 
 	var a [3]int
-	_ = a[1 /* ERROR "multi-index expression" */, 2 /* ERROR "expected type" */ ]
+	_ = a[i, j /* ERROR "more than one index" */ ]
 
 	var s []int
-	_ = s[1 /* ERROR "multi-index expression" */, 2 /* ERROR "expected type" */ ]
+	_ = s[i, j /* ERROR "more than one index" */ ]
 
 	var t T
 	// TODO(rFindley) Fix the duplicate error below.
-	_ = t[1 /* ERROR "multi-index expression" */ /* ERROR "multi-index expression" */, 2 /* ERROR "expected type" */ ]
+	_ = t[i, j /* ERROR "more than one index" */ /* ERROR "more than one index" */ ]
 }
-- 
GitLab


From d80da19fc99d3e729c6497bf9bf9bb836ed9d9f6 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Wed, 28 Apr 2021 19:36:54 -0400
Subject: [PATCH 1846/2400] cmd/link: update comment for PLT/GOT helper
 functions

PLT and GOT are used more than on PE. Update the comment.

Change-Id: Iaddb326680a7709a1442675a38c021331be32472
Reviewed-on: https://go-review.googlesource.com/c/go/+/314929
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/loader/loader.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/cmd/link/internal/loader/loader.go b/src/cmd/link/internal/loader/loader.go
index d5331b3fef..1bfcfe435a 100644
--- a/src/cmd/link/internal/loader/loader.go
+++ b/src/cmd/link/internal/loader/loader.go
@@ -1446,7 +1446,7 @@ func (l *Loader) SetSymLocalElfSym(i Sym, es int32) {
 	}
 }
 
-// SymPlt returns the plt value for pe symbols.
+// SymPlt returns the PLT offset of symbol s.
 func (l *Loader) SymPlt(s Sym) int32 {
 	if v, ok := l.plt[s]; ok {
 		return v
@@ -1454,7 +1454,7 @@ func (l *Loader) SymPlt(s Sym) int32 {
 	return -1
 }
 
-// SetPlt sets the plt value for pe symbols.
+// SetPlt sets the PLT offset of symbol i.
 func (l *Loader) SetPlt(i Sym, v int32) {
 	if i >= Sym(len(l.objSyms)) || i == 0 {
 		panic("bad symbol for SetPlt")
@@ -1466,7 +1466,7 @@ func (l *Loader) SetPlt(i Sym, v int32) {
 	}
 }
 
-// SymGot returns the got value for pe symbols.
+// SymGot returns the GOT offset of symbol s.
 func (l *Loader) SymGot(s Sym) int32 {
 	if v, ok := l.got[s]; ok {
 		return v
@@ -1474,7 +1474,7 @@ func (l *Loader) SymGot(s Sym) int32 {
 	return -1
 }
 
-// SetGot sets the got value for pe symbols.
+// SetGot sets the GOT offset of symbol i.
 func (l *Loader) SetGot(i Sym, v int32) {
 	if i >= Sym(len(l.objSyms)) || i == 0 {
 		panic("bad symbol for SetGot")
-- 
GitLab


From 18852e8372fcd6e0964f051d608839a093f6b5c7 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Mon, 26 Apr 2021 19:26:34 -0400
Subject: [PATCH 1847/2400] cmd/link: use a two-pass approach for trampoline
 insertion

Currently in the linker, for trampoline insertion it does a one-pass
approach, where it assigns addresses for each function and inserts
trampolines on the go. For this to work and not to emit too many
unnecessary trampolines, the functions need to be laid out in
dependency order, so a direct call's target is always as a known
address (or known to be not too far).

This mostly works, but there are a few exceptions:
- linkname can break dependency tree and cause cycles.
- in internal linking mode, on some platforms, some calls are turned
  into calls via PLT, but the PLT stubs are inserted rather late.

Also, this is expensive in that it has to investigate all CALL
relocations.

This CL changes it to use a two-pass approach. The first pass is
just to assign addresses without inserting any trampolines, assuming
the program is not too big. If this succeeds, no extra work needs to
be done. If this fails, start over and insert trampolines for too-
far targets as well as targets with unknown addresses. This should
make it faster for small programs (most cases) and generate fewer
conservative trampolines.

Change-Id: Ib13e01f38ec6dfbef1cd446b06da33ee17bded5d
Reviewed-on: https://go-review.googlesource.com/c/go/+/314450
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/arm/obj.go   |   1 +
 src/cmd/link/internal/ld/data.go   | 128 ++++++++++++++++++++---------
 src/cmd/link/internal/ld/lib.go    |  17 ++--
 src/cmd/link/internal/ppc64/obj.go |   1 +
 4 files changed, 103 insertions(+), 44 deletions(-)

diff --git a/src/cmd/link/internal/arm/obj.go b/src/cmd/link/internal/arm/obj.go
index fed8dce4de..b7d149851c 100644
--- a/src/cmd/link/internal/arm/obj.go
+++ b/src/cmd/link/internal/arm/obj.go
@@ -45,6 +45,7 @@ func Init() (*sys.Arch, ld.Arch) {
 		Minalign:   minAlign,
 		Dwarfregsp: dwarfRegSP,
 		Dwarfreglr: dwarfRegLR,
+		TrampLimit: 0x1c00000, // 24-bit signed offset * 4, leave room for PLT etc.
 
 		Plan9Magic: 0x647,
 
diff --git a/src/cmd/link/internal/ld/data.go b/src/cmd/link/internal/ld/data.go
index a135fe8fd2..a5e6d37f29 100644
--- a/src/cmd/link/internal/ld/data.go
+++ b/src/cmd/link/internal/ld/data.go
@@ -117,7 +117,6 @@ func trampoline(ctxt *Link, s loader.Sym) {
 
 		thearch.Trampoline(ctxt, ldr, ri, rs, s)
 	}
-
 }
 
 // FoldSubSymbolOffset computes the offset of symbol s to its top-level outer
@@ -2203,23 +2202,87 @@ func (ctxt *Link) textaddress() {
 		ctxt.Textp[0] = text
 	}
 
-	va := uint64(Rnd(*FlagTextAddr, int64(Funcalign)))
+	start := uint64(Rnd(*FlagTextAddr, int64(Funcalign)))
+	va := start
 	n := 1
 	sect.Vaddr = va
-	ntramps := 0
-	for _, s := range ctxt.Textp {
-		sect, n, va = assignAddress(ctxt, sect, n, s, va, false)
 
-		trampoline(ctxt, s) // resolve jumps, may add trampolines if jump too far
+	limit := thearch.TrampLimit
+	if limit == 0 {
+		limit = 1 << 63 // unlimited
+	}
+	if *FlagDebugTextSize != 0 {
+		limit = uint64(*FlagDebugTextSize)
+	}
+	if *FlagDebugTramp > 1 {
+		limit = 1 // debug mode, force generating trampolines for everything
+	}
+
+	if ctxt.IsAIX() && ctxt.IsExternal() {
+		// On AIX, normally we won't generate direct calls to external symbols,
+		// except in one test, cmd/go/testdata/script/link_syso_issue33139.txt.
+		// That test doesn't make much sense, and I'm not sure it ever works.
+		// Just generate trampoline for now (which will turn a direct call to
+		// an indirect call, which at least builds).
+		limit = 1
+	}
+
+	// First pass: assign addresses assuming the program is small and
+	// don't generate trampolines.
+	big := false
+	for _, s := range ctxt.Textp {
+		sect, n, va = assignAddress(ctxt, sect, n, s, va, false, big)
+		if va-start >= limit {
+			big = true
+			break
+		}
+	}
 
-		// lay down trampolines after each function
-		for ; ntramps < len(ctxt.tramps); ntramps++ {
-			tramp := ctxt.tramps[ntramps]
-			if ctxt.IsAIX() && strings.HasPrefix(ldr.SymName(tramp), "runtime.text.") {
-				// Already set in assignAddress
+	// Second pass: only if it is too big, insert trampolines for too-far
+	// jumps and targets with unknown addresses.
+	if big {
+		// reset addresses
+		for _, s := range ctxt.Textp {
+			if ldr.OuterSym(s) != 0 || s == text {
 				continue
 			}
-			sect, n, va = assignAddress(ctxt, sect, n, tramp, va, true)
+			oldv := ldr.SymValue(s)
+			for sub := s; sub != 0; sub = ldr.SubSym(sub) {
+				ldr.SetSymValue(sub, ldr.SymValue(sub)-oldv)
+			}
+		}
+		va = start
+
+		ntramps := 0
+		for _, s := range ctxt.Textp {
+			sect, n, va = assignAddress(ctxt, sect, n, s, va, false, big)
+
+			trampoline(ctxt, s) // resolve jumps, may add trampolines if jump too far
+
+			// lay down trampolines after each function
+			for ; ntramps < len(ctxt.tramps); ntramps++ {
+				tramp := ctxt.tramps[ntramps]
+				if ctxt.IsAIX() && strings.HasPrefix(ldr.SymName(tramp), "runtime.text.") {
+					// Already set in assignAddress
+					continue
+				}
+				sect, n, va = assignAddress(ctxt, sect, n, tramp, va, true, big)
+			}
+		}
+
+		// merge tramps into Textp, keeping Textp in address order
+		if ntramps != 0 {
+			newtextp := make([]loader.Sym, 0, len(ctxt.Textp)+ntramps)
+			i := 0
+			for _, s := range ctxt.Textp {
+				for ; i < ntramps && ldr.SymValue(ctxt.tramps[i]) < ldr.SymValue(s); i++ {
+					newtextp = append(newtextp, ctxt.tramps[i])
+				}
+				newtextp = append(newtextp, s)
+			}
+			newtextp = append(newtextp, ctxt.tramps[i:ntramps]...)
+
+			ctxt.Textp = newtextp
 		}
 	}
 
@@ -2231,25 +2294,10 @@ func (ctxt *Link) textaddress() {
 		ldr.SetSymValue(etext, int64(va))
 		ldr.SetSymValue(text, int64(Segtext.Sections[0].Vaddr))
 	}
-
-	// merge tramps into Textp, keeping Textp in address order
-	if ntramps != 0 {
-		newtextp := make([]loader.Sym, 0, len(ctxt.Textp)+ntramps)
-		i := 0
-		for _, s := range ctxt.Textp {
-			for ; i < ntramps && ldr.SymValue(ctxt.tramps[i]) < ldr.SymValue(s); i++ {
-				newtextp = append(newtextp, ctxt.tramps[i])
-			}
-			newtextp = append(newtextp, s)
-		}
-		newtextp = append(newtextp, ctxt.tramps[i:ntramps]...)
-
-		ctxt.Textp = newtextp
-	}
 }
 
 // assigns address for a text symbol, returns (possibly new) section, its number, and the address
-func assignAddress(ctxt *Link, sect *sym.Section, n int, s loader.Sym, va uint64, isTramp bool) (*sym.Section, int, uint64) {
+func assignAddress(ctxt *Link, sect *sym.Section, n int, s loader.Sym, va uint64, isTramp, big bool) (*sym.Section, int, uint64) {
 	ldr := ctxt.loader
 	if thearch.AssignAddress != nil {
 		return thearch.AssignAddress(ldr, sect, n, s, va, isTramp)
@@ -2277,20 +2325,19 @@ func assignAddress(ctxt *Link, sect *sym.Section, n int, s loader.Sym, va uint64
 	// On ppc64x a text section should not be larger than 2^26 bytes due to the size of
 	// call target offset field in the bl instruction.  Splitting into smaller text
 	// sections smaller than this limit allows the GNU linker to modify the long calls
-	// appropriately.  The limit allows for the space needed for tables inserted by the linker.
-
+	// appropriately. The limit allows for the space needed for tables inserted by the linker.
+	//
 	// If this function doesn't fit in the current text section, then create a new one.
-
+	//
 	// Only break at outermost syms.
+	if ctxt.Arch.InFamily(sys.PPC64) && ldr.OuterSym(s) == 0 && ctxt.IsExternal() && big {
+		// For debugging purposes, allow text size limit to be cranked down,
+		// so as to stress test the code that handles multiple text sections.
+		var textSizelimit uint64 = thearch.TrampLimit
+		if *FlagDebugTextSize != 0 {
+			textSizelimit = uint64(*FlagDebugTextSize)
+		}
 
-	// For debugging purposes, allow text size limit to be cranked down,
-	// so as to stress test the code that handles multiple text sections.
-	var textSizelimit uint64 = 0x1c00000
-	if *FlagDebugTextSize != 0 {
-		textSizelimit = uint64(*FlagDebugTextSize)
-	}
-
-	if ctxt.Arch.InFamily(sys.PPC64) && ldr.OuterSym(s) == 0 && ctxt.IsExternal() {
 		// Sanity check: make sure the limit is larger than any
 		// individual text symbol.
 		if funcsize > textSizelimit {
@@ -2346,6 +2393,9 @@ func assignAddress(ctxt *Link, sect *sym.Section, n int, s loader.Sym, va uint64
 	ldr.SetSymValue(s, 0)
 	for sub := s; sub != 0; sub = ldr.SubSym(sub) {
 		ldr.SetSymValue(sub, ldr.SymValue(sub)+int64(va))
+		if ctxt.Debugvlog > 2 {
+			fmt.Println("assign text address:", ldr.SymName(sub), ldr.SymValue(sub))
+		}
 	}
 
 	va += funcsize
diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index 7408526076..e9349a4b3e 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -177,11 +177,18 @@ func (ctxt *Link) setArchSyms() {
 }
 
 type Arch struct {
-	Funcalign      int
-	Maxalign       int
-	Minalign       int
-	Dwarfregsp     int
-	Dwarfreglr     int
+	Funcalign  int
+	Maxalign   int
+	Minalign   int
+	Dwarfregsp int
+	Dwarfreglr int
+
+	// Threshold of total text size, used for trampoline insertion. If the total
+	// text size is smaller than TrampLimit, we won't need to insert trampolines.
+	// It is pretty close to the offset range of a direct CALL machine instruction.
+	// We leave some room for extra stuff like PLT stubs.
+	TrampLimit uint64
+
 	Androiddynld   string
 	Linuxdynld     string
 	Freebsddynld   string
diff --git a/src/cmd/link/internal/ppc64/obj.go b/src/cmd/link/internal/ppc64/obj.go
index 54d4606487..f56fa76b5b 100644
--- a/src/cmd/link/internal/ppc64/obj.go
+++ b/src/cmd/link/internal/ppc64/obj.go
@@ -49,6 +49,7 @@ func Init() (*sys.Arch, ld.Arch) {
 		Minalign:        minAlign,
 		Dwarfregsp:      dwarfRegSP,
 		Dwarfreglr:      dwarfRegLR,
+		TrampLimit:      0x1c00000,
 		WriteTextBlocks: true,
 
 		Adddynrel:        adddynrel,
-- 
GitLab


From 4e3e6b58f7ba16caa58f4c826a63d85e26849036 Mon Sep 17 00:00:00 2001
From: kumakichi <xyesan@gmail.com>
Date: Thu, 29 Apr 2021 05:45:35 +0000
Subject: [PATCH 1848/2400] cmd/compile/internal/ir: fix doc

Change-Id: I8fc77e29cb44fef264a62ff00452b9fcf6e30be8
GitHub-Last-Rev: 414cda8ce6e64fb53d3d1ec01caa7e33c0219236
GitHub-Pull-Request: golang/go#45842
Reviewed-on: https://go-review.googlesource.com/c/go/+/314990
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/ir/dump.go | 4 ++--
 src/cmd/compile/internal/ir/expr.go | 4 ++--
 src/cmd/compile/internal/ir/func.go | 4 ++--
 src/cmd/compile/internal/ir/node.go | 4 ++--
 src/cmd/compile/internal/ir/stmt.go | 2 +-
 src/cmd/compile/internal/ir/val.go  | 6 +++---
 6 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/cmd/compile/internal/ir/dump.go b/src/cmd/compile/internal/ir/dump.go
index fc995cee62..59914baa5c 100644
--- a/src/cmd/compile/internal/ir/dump.go
+++ b/src/cmd/compile/internal/ir/dump.go
@@ -20,12 +20,12 @@ import (
 	"cmd/internal/src"
 )
 
-// dump is like fdump but prints to stderr.
+// DumpAny is like FDumpAny but prints to stderr.
 func DumpAny(root interface{}, filter string, depth int) {
 	FDumpAny(os.Stderr, root, filter, depth)
 }
 
-// fdump prints the structure of a rooted data structure
+// FDumpAny prints the structure of a rooted data structure
 // to w by depth-first traversal of the data structure.
 //
 // The filter parameter is a regular expression. If it is
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index a9f8c6eae5..94255116a0 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -1060,7 +1060,7 @@ func MethodSymSuffix(recv *types.Type, msym *types.Sym, suffix string) *types.Sy
 	return rpkg.LookupBytes(b.Bytes())
 }
 
-// MethodName returns the ONAME representing the method
+// MethodExprName returns the ONAME representing the method
 // referenced by expression n, which must be a method selector,
 // method expression, or method value.
 func MethodExprName(n Node) *Name {
@@ -1068,7 +1068,7 @@ func MethodExprName(n Node) *Name {
 	return name
 }
 
-// MethodFunc is like MethodName, but returns the types.Field instead.
+// MethodExprFunc is like MethodExprName, but returns the types.Field instead.
 func MethodExprFunc(n Node) *types.Field {
 	switch n.Op() {
 	case ODOTMETH, OMETHEXPR, OCALLPART:
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index bcedfe138c..385866b3c8 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -238,7 +238,7 @@ func (f *Func) SetWBPos(pos src.XPos) {
 	}
 }
 
-// funcname returns the name (without the package) of the function n.
+// FuncName returns the name (without the package) of the function n.
 func FuncName(f *Func) string {
 	if f == nil || f.Nname == nil {
 		return "<nil>"
@@ -246,7 +246,7 @@ func FuncName(f *Func) string {
 	return f.Sym().Name
 }
 
-// pkgFuncName returns the name of the function referenced by n, with package prepended.
+// PkgFuncName returns the name of the function referenced by n, with package prepended.
 // This differs from the compiler's internal convention where local functions lack a package
 // because the ultimate consumer of this is a human looking at an IDE; package is only empty
 // if the compilation package is actually the empty string.
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index cbc7681d12..a73b81d196 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -80,7 +80,7 @@ func IsAutoTmp(n Node) bool {
 	return n.Name().AutoTemp()
 }
 
-// mayBeShared reports whether n may occur in multiple places in the AST.
+// MayBeShared reports whether n may occur in multiple places in the AST.
 // Extra care must be taken when mutating such a node.
 func MayBeShared(n Node) bool {
 	switch n.Op() {
@@ -477,7 +477,7 @@ func IsConst(n Node, ct constant.Kind) bool {
 	return ConstType(n) == ct
 }
 
-// isNil reports whether n represents the universal untyped zero value "nil".
+// IsNil reports whether n represents the universal untyped zero value "nil".
 func IsNil(n Node) bool {
 	// Check n.Orig because constant propagation may produce typed nil constants,
 	// which don't exist in the Go spec.
diff --git a/src/cmd/compile/internal/ir/stmt.go b/src/cmd/compile/internal/ir/stmt.go
index c304867e1d..8115012f97 100644
--- a/src/cmd/compile/internal/ir/stmt.go
+++ b/src/cmd/compile/internal/ir/stmt.go
@@ -224,7 +224,7 @@ func (n *ForStmt) SetOp(op Op) {
 
 // A GoDeferStmt is a go or defer statement: go Call / defer Call.
 //
-// The two opcodes use a signle syntax because the implementations
+// The two opcodes use a single syntax because the implementations
 // are very similar: both are concerned with saving Call and running it
 // in a different context (a separate goroutine or a later time).
 type GoDeferStmt struct {
diff --git a/src/cmd/compile/internal/ir/val.go b/src/cmd/compile/internal/ir/val.go
index ff45f31074..03c320e205 100644
--- a/src/cmd/compile/internal/ir/val.go
+++ b/src/cmd/compile/internal/ir/val.go
@@ -19,7 +19,7 @@ func ConstType(n Node) constant.Kind {
 	return n.Val().Kind()
 }
 
-// ValueInterface returns the constant value stored in n as an interface{}.
+// ConstValue returns the constant value stored in n as an interface{}.
 // It returns int64s for ints and runes, float64s for floats,
 // and complex128s for complex values.
 func ConstValue(n Node) interface{} {
@@ -40,7 +40,7 @@ func ConstValue(n Node) interface{} {
 	}
 }
 
-// int64Val returns v converted to int64.
+// IntVal returns v converted to int64.
 // Note: if t is uint64, very large values will be converted to negative int64.
 func IntVal(t *types.Type, v constant.Value) int64 {
 	if t.IsUnsigned() {
@@ -90,7 +90,7 @@ func ValidTypeForConst(t *types.Type, v constant.Value) bool {
 	panic("unreachable")
 }
 
-// nodlit returns a new untyped constant with value v.
+// NewLiteral returns a new untyped constant with value v.
 func NewLiteral(v constant.Value) Node {
 	return NewBasicLit(base.Pos, v)
 }
-- 
GitLab


From 862ddb37b4e24bcb89f060d50325c8f863ee99bc Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Wed, 28 Apr 2021 11:42:34 -0700
Subject: [PATCH 1849/2400] runtime: rename walltime1 to walltime

Change-Id: Iec9de5ca56eb68d524bbaa0668515dbd09ad38a1
Reviewed-on: https://go-review.googlesource.com/c/go/+/314770
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 misc/wasm/wasm_exec.js             | 4 ++--
 src/runtime/os3_solaris.go         | 2 +-
 src/runtime/os_aix.go              | 2 +-
 src/runtime/os_openbsd_syscall2.go | 2 +-
 src/runtime/os_windows.go          | 3 ---
 src/runtime/sys_darwin.go          | 2 +-
 src/runtime/sys_dragonfly_amd64.s  | 4 ++--
 src/runtime/sys_linux_386.s        | 4 ++--
 src/runtime/sys_linux_amd64.s      | 4 ++--
 src/runtime/sys_linux_arm.s        | 2 +-
 src/runtime/sys_linux_arm64.s      | 4 ++--
 src/runtime/sys_linux_mips64x.s    | 6 +++---
 src/runtime/sys_linux_mipsx.s      | 4 ++--
 src/runtime/sys_linux_ppc64x.s     | 4 ++--
 src/runtime/sys_linux_riscv64.s    | 4 ++--
 src/runtime/sys_linux_s390x.s      | 4 ++--
 src/runtime/sys_netbsd_386.s       | 4 ++--
 src/runtime/sys_netbsd_amd64.s     | 4 ++--
 src/runtime/sys_netbsd_arm.s       | 4 ++--
 src/runtime/sys_netbsd_arm64.s     | 4 ++--
 src/runtime/sys_openbsd2.go        | 2 +-
 src/runtime/sys_openbsd_386.s      | 4 ++--
 src/runtime/sys_openbsd_arm.s      | 4 ++--
 src/runtime/sys_openbsd_mips64.s   | 4 ++--
 src/runtime/sys_plan9_386.s        | 4 ++--
 src/runtime/sys_plan9_amd64.s      | 4 ++--
 src/runtime/sys_plan9_arm.s        | 4 ++--
 src/runtime/sys_wasm.s             | 2 +-
 src/runtime/timestub.go            | 2 +-
 src/runtime/timestub2.go           | 2 +-
 src/runtime/vdso_freebsd.go        | 2 +-
 31 files changed, 51 insertions(+), 54 deletions(-)

diff --git a/misc/wasm/wasm_exec.js b/misc/wasm/wasm_exec.js
index 82041e6bb9..3e41e628ef 100644
--- a/misc/wasm/wasm_exec.js
+++ b/misc/wasm/wasm_exec.js
@@ -296,8 +296,8 @@
 						setInt64(sp + 8, (timeOrigin + performance.now()) * 1000000);
 					},
 
-					// func walltime1() (sec int64, nsec int32)
-					"runtime.walltime1": (sp) => {
+					// func walltime() (sec int64, nsec int32)
+					"runtime.walltime": (sp) => {
 						sp >>>= 0;
 						const msec = (new Date).getTime();
 						setInt64(sp + 8, msec / 1000);
diff --git a/src/runtime/os3_solaris.go b/src/runtime/os3_solaris.go
index 4b65139eb8..39ef831acf 100644
--- a/src/runtime/os3_solaris.go
+++ b/src/runtime/os3_solaris.go
@@ -531,7 +531,7 @@ func usleep(µs uint32) {
 	usleep1(µs)
 }
 
-func walltime1() (sec int64, nsec int32) {
+func walltime() (sec int64, nsec int32) {
 	var ts mts
 	sysvicall2(&libc_clock_gettime, _CLOCK_REALTIME, uintptr(unsafe.Pointer(&ts)))
 	return ts.tv_sec, int32(ts.tv_nsec)
diff --git a/src/runtime/os_aix.go b/src/runtime/os_aix.go
index 557b17cc75..4fb1c8e845 100644
--- a/src/runtime/os_aix.go
+++ b/src/runtime/os_aix.go
@@ -336,7 +336,7 @@ func nanotime1() int64 {
 	return tp.tv_sec*1000000000 + tp.tv_nsec
 }
 
-func walltime1() (sec int64, nsec int32) {
+func walltime() (sec int64, nsec int32) {
 	ts := &timespec{}
 	if clock_gettime(_CLOCK_REALTIME, ts) != 0 {
 		throw("syscall clock_gettime failed")
diff --git a/src/runtime/os_openbsd_syscall2.go b/src/runtime/os_openbsd_syscall2.go
index 3b1707126b..e16f9420db 100644
--- a/src/runtime/os_openbsd_syscall2.go
+++ b/src/runtime/os_openbsd_syscall2.go
@@ -98,4 +98,4 @@ func sigaltstack(new, old *stackt)
 func closeonexec(fd int32)
 func setNonblock(fd int32)
 
-func walltime1() (sec int64, nsec int32)
+func walltime() (sec int64, nsec int32)
diff --git a/src/runtime/os_windows.go b/src/runtime/os_windows.go
index 36182f4e9a..f0935264ac 100644
--- a/src/runtime/os_windows.go
+++ b/src/runtime/os_windows.go
@@ -804,9 +804,6 @@ func writeConsoleUTF16(handle uintptr, b []uint16) {
 	return
 }
 
-// walltime1 isn't implemented on Windows, but will never be called.
-func walltime1() (sec int64, nsec int32)
-
 //go:nosplit
 func semasleep(ns int64) int32 {
 	const (
diff --git a/src/runtime/sys_darwin.go b/src/runtime/sys_darwin.go
index 6d7460fae2..0f91685d6c 100644
--- a/src/runtime/sys_darwin.go
+++ b/src/runtime/sys_darwin.go
@@ -274,7 +274,7 @@ func nanotime_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
-func walltime1() (int64, int32) {
+func walltime() (int64, int32) {
 	var t timespec
 	libcCall(unsafe.Pointer(abi.FuncPCABI0(walltime_trampoline)), unsafe.Pointer(&t))
 	return t.tv_sec, int32(t.tv_nsec)
diff --git a/src/runtime/sys_dragonfly_amd64.s b/src/runtime/sys_dragonfly_amd64.s
index 43f864194d..d57bc2a7a4 100644
--- a/src/runtime/sys_dragonfly_amd64.s
+++ b/src/runtime/sys_dragonfly_amd64.s
@@ -184,8 +184,8 @@ TEXT runtime·setitimer(SB), NOSPLIT, $-8
 	SYSCALL
 	RET
 
-// func walltime1() (sec int64, nsec int32)
-TEXT runtime·walltime1(SB), NOSPLIT, $32
+// func walltime() (sec int64, nsec int32)
+TEXT runtime·walltime(SB), NOSPLIT, $32
 	MOVL	$232, AX // clock_gettime
 	MOVQ	$0, DI  	// CLOCK_REALTIME
 	LEAQ	8(SP), SI
diff --git a/src/runtime/sys_linux_386.s b/src/runtime/sys_linux_386.s
index 6e7737e89f..3ae5a9099f 100644
--- a/src/runtime/sys_linux_386.s
+++ b/src/runtime/sys_linux_386.s
@@ -219,8 +219,8 @@ TEXT runtime·mincore(SB),NOSPLIT,$0-16
 	MOVL	AX, ret+12(FP)
 	RET
 
-// func walltime1() (sec int64, nsec int32)
-TEXT runtime·walltime1(SB), NOSPLIT, $8-12
+// func walltime() (sec int64, nsec int32)
+TEXT runtime·walltime(SB), NOSPLIT, $8-12
 	// We don't know how much stack space the VDSO code will need,
 	// so switch to g0.
 
diff --git a/src/runtime/sys_linux_amd64.s b/src/runtime/sys_linux_amd64.s
index da8a1f7663..ee587de805 100644
--- a/src/runtime/sys_linux_amd64.s
+++ b/src/runtime/sys_linux_amd64.s
@@ -204,9 +204,9 @@ TEXT runtime·mincore(SB),NOSPLIT,$0-28
 	MOVL	AX, ret+24(FP)
 	RET
 
-// func walltime1() (sec int64, nsec int32)
+// func walltime() (sec int64, nsec int32)
 // non-zero frame-size means bp is saved and restored
-TEXT runtime·walltime1(SB),NOSPLIT,$16-12
+TEXT runtime·walltime(SB),NOSPLIT,$16-12
 	// We don't know how much stack space the VDSO code will need,
 	// so switch to g0.
 	// In particular, a kernel configured with CONFIG_OPTIMIZE_INLINING=n
diff --git a/src/runtime/sys_linux_arm.s b/src/runtime/sys_linux_arm.s
index 475f52344c..02a5d4a642 100644
--- a/src/runtime/sys_linux_arm.s
+++ b/src/runtime/sys_linux_arm.s
@@ -242,7 +242,7 @@ TEXT runtime·mincore(SB),NOSPLIT,$0
 	MOVW	R0, ret+12(FP)
 	RET
 
-TEXT runtime·walltime1(SB),NOSPLIT,$8-12
+TEXT runtime·walltime(SB),NOSPLIT,$8-12
 	// We don't know how much stack space the VDSO code will need,
 	// so switch to g0.
 
diff --git a/src/runtime/sys_linux_arm64.s b/src/runtime/sys_linux_arm64.s
index 198a5bacef..69ac160278 100644
--- a/src/runtime/sys_linux_arm64.s
+++ b/src/runtime/sys_linux_arm64.s
@@ -206,8 +206,8 @@ TEXT runtime·mincore(SB),NOSPLIT|NOFRAME,$0-28
 	MOVW	R0, ret+24(FP)
 	RET
 
-// func walltime1() (sec int64, nsec int32)
-TEXT runtime·walltime1(SB),NOSPLIT,$24-12
+// func walltime() (sec int64, nsec int32)
+TEXT runtime·walltime(SB),NOSPLIT,$24-12
 	MOVD	RSP, R20	// R20 is unchanged by C code
 	MOVD	RSP, R1
 
diff --git a/src/runtime/sys_linux_mips64x.s b/src/runtime/sys_linux_mips64x.s
index c3e9f37694..0206cb88bd 100644
--- a/src/runtime/sys_linux_mips64x.s
+++ b/src/runtime/sys_linux_mips64x.s
@@ -213,8 +213,8 @@ TEXT runtime·mincore(SB),NOSPLIT|NOFRAME,$0-28
 	MOVW	R2, ret+24(FP)
 	RET
 
-// func walltime1() (sec int64, nsec int32)
-TEXT runtime·walltime1(SB),NOSPLIT,$16-12
+// func walltime() (sec int64, nsec int32)
+TEXT runtime·walltime(SB),NOSPLIT,$16-12
 	MOVV	R29, R16	// R16 is unchanged by C code
 	MOVV	R29, R1
 
@@ -319,7 +319,7 @@ noswitch:
 	BEQ	R25, fallback
 
 	JAL	(R25)
-	// see walltime1 for detail
+	// see walltime for detail
 	BEQ	R2, R0, finish
 	MOVV	R0, runtime·vdsoClockgettimeSym(SB)
 	MOVW	$1, R4 // CLOCK_MONOTONIC
diff --git a/src/runtime/sys_linux_mipsx.s b/src/runtime/sys_linux_mipsx.s
index fab2ab3892..d5317d3957 100644
--- a/src/runtime/sys_linux_mipsx.s
+++ b/src/runtime/sys_linux_mipsx.s
@@ -218,8 +218,8 @@ TEXT runtime·mincore(SB),NOSPLIT,$0-16
 	MOVW	R2, ret+12(FP)
 	RET
 
-// func walltime1() (sec int64, nsec int32)
-TEXT runtime·walltime1(SB),NOSPLIT,$8-12
+// func walltime() (sec int64, nsec int32)
+TEXT runtime·walltime(SB),NOSPLIT,$8-12
 	MOVW	$0, R4	// CLOCK_REALTIME
 	MOVW	$4(R29), R5
 	MOVW	$SYS_clock_gettime, R2
diff --git a/src/runtime/sys_linux_ppc64x.s b/src/runtime/sys_linux_ppc64x.s
index fd69ee70a5..75da130357 100644
--- a/src/runtime/sys_linux_ppc64x.s
+++ b/src/runtime/sys_linux_ppc64x.s
@@ -184,8 +184,8 @@ TEXT runtime·mincore(SB),NOSPLIT|NOFRAME,$0-28
 	MOVW	R3, ret+24(FP)
 	RET
 
-// func walltime1() (sec int64, nsec int32)
-TEXT runtime·walltime1(SB),NOSPLIT,$16-12
+// func walltime() (sec int64, nsec int32)
+TEXT runtime·walltime(SB),NOSPLIT,$16-12
 	MOVD	R1, R15		// R15 is unchanged by C code
 	MOVD	g_m(g), R21	// R21 = m
 
diff --git a/src/runtime/sys_linux_riscv64.s b/src/runtime/sys_linux_riscv64.s
index 626ab3912c..2389f1cc18 100644
--- a/src/runtime/sys_linux_riscv64.s
+++ b/src/runtime/sys_linux_riscv64.s
@@ -219,8 +219,8 @@ TEXT runtime·mincore(SB),NOSPLIT|NOFRAME,$0-28
 	MOVW	A0, ret+24(FP)
 	RET
 
-// func walltime1() (sec int64, nsec int32)
-TEXT runtime·walltime1(SB),NOSPLIT,$24-12
+// func walltime() (sec int64, nsec int32)
+TEXT runtime·walltime(SB),NOSPLIT,$24-12
 	MOV	$0, A0 // CLOCK_REALTIME
 	MOV	$8(X2), A1
 	MOV	$SYS_clock_gettime, A7
diff --git a/src/runtime/sys_linux_s390x.s b/src/runtime/sys_linux_s390x.s
index c15a1d5364..916dfada8d 100644
--- a/src/runtime/sys_linux_s390x.s
+++ b/src/runtime/sys_linux_s390x.s
@@ -194,8 +194,8 @@ TEXT runtime·mincore(SB),NOSPLIT|NOFRAME,$0-28
 	MOVW	R2, ret+24(FP)
 	RET
 
-// func walltime1() (sec int64, nsec int32)
-TEXT runtime·walltime1(SB),NOSPLIT,$16
+// func walltime() (sec int64, nsec int32)
+TEXT runtime·walltime(SB),NOSPLIT,$16
 	MOVW	$0, R2 // CLOCK_REALTIME
 	MOVD	$tp-16(SP), R3
 	MOVW	$SYS_clock_gettime, R1
diff --git a/src/runtime/sys_netbsd_386.s b/src/runtime/sys_netbsd_386.s
index d3f22454a4..8a33894892 100644
--- a/src/runtime/sys_netbsd_386.s
+++ b/src/runtime/sys_netbsd_386.s
@@ -206,8 +206,8 @@ TEXT runtime·setitimer(SB),NOSPLIT,$-4
 	INT	$0x80
 	RET
 
-// func walltime1() (sec int64, nsec int32)
-TEXT runtime·walltime1(SB), NOSPLIT, $32
+// func walltime() (sec int64, nsec int32)
+TEXT runtime·walltime(SB), NOSPLIT, $32
 	LEAL	12(SP), BX
 	MOVL	$CLOCK_REALTIME, 4(SP)	// arg 1 - clock_id
 	MOVL	BX, 8(SP)		// arg 2 - tp
diff --git a/src/runtime/sys_netbsd_amd64.s b/src/runtime/sys_netbsd_amd64.s
index db76e86d1d..02f5b4ba3b 100644
--- a/src/runtime/sys_netbsd_amd64.s
+++ b/src/runtime/sys_netbsd_amd64.s
@@ -238,8 +238,8 @@ TEXT runtime·setitimer(SB),NOSPLIT,$-8
 	SYSCALL
 	RET
 
-// func walltime1() (sec int64, nsec int32)
-TEXT runtime·walltime1(SB), NOSPLIT, $32
+// func walltime() (sec int64, nsec int32)
+TEXT runtime·walltime(SB), NOSPLIT, $32
 	MOVQ	$CLOCK_REALTIME, DI	// arg 1 - clock_id
 	LEAQ	8(SP), SI		// arg 2 - tp
 	MOVL	$SYS___clock_gettime50, AX
diff --git a/src/runtime/sys_netbsd_arm.s b/src/runtime/sys_netbsd_arm.s
index 82f9d2161e..3a763b2a6a 100644
--- a/src/runtime/sys_netbsd_arm.s
+++ b/src/runtime/sys_netbsd_arm.s
@@ -216,8 +216,8 @@ TEXT runtime·setitimer(SB),NOSPLIT|NOFRAME,$0
 	SWI $SYS___setitimer50
 	RET
 
-// func walltime1() (sec int64, nsec int32)
-TEXT runtime·walltime1(SB), NOSPLIT, $32
+// func walltime() (sec int64, nsec int32)
+TEXT runtime·walltime(SB), NOSPLIT, $32
 	MOVW $0, R0	// CLOCK_REALTIME
 	MOVW $8(R13), R1
 	SWI $SYS___clock_gettime50
diff --git a/src/runtime/sys_netbsd_arm64.s b/src/runtime/sys_netbsd_arm64.s
index 1446a27f4c..2d0b894d47 100644
--- a/src/runtime/sys_netbsd_arm64.s
+++ b/src/runtime/sys_netbsd_arm64.s
@@ -224,8 +224,8 @@ TEXT runtime·setitimer(SB),NOSPLIT,$-8
 	SVC	$SYS___setitimer50
 	RET
 
-// func walltime1() (sec int64, nsec int32)
-TEXT runtime·walltime1(SB), NOSPLIT, $32
+// func walltime() (sec int64, nsec int32)
+TEXT runtime·walltime(SB), NOSPLIT, $32
 	MOVW	$CLOCK_REALTIME, R0	// arg 1 - clock_id
 	MOVD	$8(RSP), R1		// arg 2 - tp
 	SVC	$SYS___clock_gettime50
diff --git a/src/runtime/sys_openbsd2.go b/src/runtime/sys_openbsd2.go
index 73157043be..16a518df17 100644
--- a/src/runtime/sys_openbsd2.go
+++ b/src/runtime/sys_openbsd2.go
@@ -162,7 +162,7 @@ func nanotime1() int64 {
 func clock_gettime_trampoline()
 
 //go:nosplit
-func walltime1() (int64, int32) {
+func walltime() (int64, int32) {
 	var ts timespec
 	args := struct {
 		clock_id int32
diff --git a/src/runtime/sys_openbsd_386.s b/src/runtime/sys_openbsd_386.s
index 24fbfd6266..0f7895aef8 100644
--- a/src/runtime/sys_openbsd_386.s
+++ b/src/runtime/sys_openbsd_386.s
@@ -170,8 +170,8 @@ TEXT runtime·setitimer(SB),NOSPLIT,$-4
 	INT	$0x80
 	RET
 
-// func walltime1() (sec int64, nsec int32)
-TEXT runtime·walltime1(SB), NOSPLIT, $32
+// func walltime() (sec int64, nsec int32)
+TEXT runtime·walltime(SB), NOSPLIT, $32
 	LEAL	12(SP), BX
 	MOVL	$0, 4(SP)		// arg 1 - clock_id
 	MOVL	BX, 8(SP)		// arg 2 - tp
diff --git a/src/runtime/sys_openbsd_arm.s b/src/runtime/sys_openbsd_arm.s
index 9e18ce0e16..45d69a312a 100644
--- a/src/runtime/sys_openbsd_arm.s
+++ b/src/runtime/sys_openbsd_arm.s
@@ -188,8 +188,8 @@ TEXT runtime·setitimer(SB),NOSPLIT,$0
 	INVOKE_SYSCALL
 	RET
 
-// func walltime1() (sec int64, nsec int32)
-TEXT runtime·walltime1(SB), NOSPLIT, $32
+// func walltime() (sec int64, nsec int32)
+TEXT runtime·walltime(SB), NOSPLIT, $32
 	MOVW	CLOCK_REALTIME, R0	// arg 1 - clock_id
 	MOVW	$8(R13), R1		// arg 2 - tp
 	MOVW	$87, R12		// sys_clock_gettime
diff --git a/src/runtime/sys_openbsd_mips64.s b/src/runtime/sys_openbsd_mips64.s
index 3e4d209081..f8ae8e7c30 100644
--- a/src/runtime/sys_openbsd_mips64.s
+++ b/src/runtime/sys_openbsd_mips64.s
@@ -186,8 +186,8 @@ TEXT runtime·setitimer(SB),NOSPLIT,$0
 	SYSCALL
 	RET
 
-// func walltime1() (sec int64, nsec int32)
-TEXT runtime·walltime1(SB), NOSPLIT, $32
+// func walltime() (sec int64, nsec int32)
+TEXT runtime·walltime(SB), NOSPLIT, $32
 	MOVW	CLOCK_REALTIME, R4	// arg 1 - clock_id
 	MOVV	$8(R29), R5		// arg 2 - tp
 	MOVV	$87, R2			// sys_clock_gettime
diff --git a/src/runtime/sys_plan9_386.s b/src/runtime/sys_plan9_386.s
index f9969f6d10..b3d2f1376d 100644
--- a/src/runtime/sys_plan9_386.s
+++ b/src/runtime/sys_plan9_386.s
@@ -102,8 +102,8 @@ TEXT runtime·nsec(SB),NOSPLIT,$8
 	MOVL	$-1, ret_hi+8(FP)
 	RET
 
-// func walltime1() (sec int64, nsec int32)
-TEXT runtime·walltime1(SB),NOSPLIT,$8-12
+// func walltime() (sec int64, nsec int32)
+TEXT runtime·walltime(SB),NOSPLIT,$8-12
 	CALL	runtime·nanotime1(SB)
 	MOVL	0(SP), AX
 	MOVL	4(SP), DX
diff --git a/src/runtime/sys_plan9_amd64.s b/src/runtime/sys_plan9_amd64.s
index 383622b5a6..731306ab44 100644
--- a/src/runtime/sys_plan9_amd64.s
+++ b/src/runtime/sys_plan9_amd64.s
@@ -88,8 +88,8 @@ TEXT runtime·nsec(SB),NOSPLIT,$0
 	MOVQ	AX, ret+8(FP)
 	RET
 
-// func walltime1() (sec int64, nsec int32)
-TEXT runtime·walltime1(SB),NOSPLIT,$8-12
+// func walltime() (sec int64, nsec int32)
+TEXT runtime·walltime(SB),NOSPLIT,$8-12
 	CALL	runtime·nanotime1(SB)
 	MOVQ	0(SP), AX
 
diff --git a/src/runtime/sys_plan9_arm.s b/src/runtime/sys_plan9_arm.s
index 9fbe30536d..5343085743 100644
--- a/src/runtime/sys_plan9_arm.s
+++ b/src/runtime/sys_plan9_arm.s
@@ -138,8 +138,8 @@ TEXT runtime·nsec(SB),NOSPLIT|NOFRAME,$0-12
 	MOVW	R0, ret_hi+8(FP)
 	RET
 
-// func walltime1() (sec int64, nsec int32)
-TEXT runtime·walltime1(SB),NOSPLIT,$12-12
+// func walltime() (sec int64, nsec int32)
+TEXT runtime·walltime(SB),NOSPLIT,$12-12
 	// use nsec system call to get current time in nanoseconds
 	MOVW	$sysnsec_lo-8(SP), R0	// destination addr
 	MOVW	R0,res-12(SP)
diff --git a/src/runtime/sys_wasm.s b/src/runtime/sys_wasm.s
index e7a6570095..164dd16ec9 100644
--- a/src/runtime/sys_wasm.s
+++ b/src/runtime/sys_wasm.s
@@ -185,7 +185,7 @@ TEXT ·nanotime1(SB), NOSPLIT, $0
 	CallImport
 	RET
 
-TEXT ·walltime1(SB), NOSPLIT, $0
+TEXT ·walltime(SB), NOSPLIT, $0
 	CallImport
 	RET
 
diff --git a/src/runtime/timestub.go b/src/runtime/timestub.go
index 44e65845cb..6f16c70b81 100644
--- a/src/runtime/timestub.go
+++ b/src/runtime/timestub.go
@@ -16,6 +16,6 @@ import _ "unsafe" // for go:linkname
 
 //go:linkname time_now time.now
 func time_now() (sec int64, nsec int32, mono int64) {
-	sec, nsec = walltime1()
+	sec, nsec = walltime()
 	return sec, nsec, nanotime()
 }
diff --git a/src/runtime/timestub2.go b/src/runtime/timestub2.go
index 53b10885af..d66579440e 100644
--- a/src/runtime/timestub2.go
+++ b/src/runtime/timestub2.go
@@ -7,4 +7,4 @@
 
 package runtime
 
-func walltime1() (sec int64, nsec int32)
+func walltime() (sec int64, nsec int32)
diff --git a/src/runtime/vdso_freebsd.go b/src/runtime/vdso_freebsd.go
index 74b2f1435a..7ca7b2810b 100644
--- a/src/runtime/vdso_freebsd.go
+++ b/src/runtime/vdso_freebsd.go
@@ -106,7 +106,7 @@ func nanotime1() int64 {
 	return int64((1e9 * uint64(bt.sec)) + ((1e9 * uint64(bt.frac>>32)) >> 32))
 }
 
-func walltime1() (sec int64, nsec int32) {
+func walltime() (sec int64, nsec int32) {
 	bt := vdsoClockGettime(_CLOCK_REALTIME)
 	if bt == zeroBintime {
 		return fallback_walltime()
-- 
GitLab


From b15372f39bb555196053ddac5e86931a1502c86c Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Wed, 28 Apr 2021 13:06:55 -0700
Subject: [PATCH 1850/2400] runtime: remove linux-amd64 walltime function

It's never called.

Change-Id: I8956743b21301816b5f37a9b34e3f50ef7b2e70a
Reviewed-on: https://go-review.googlesource.com/c/go/+/314771
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/sys_linux_amd64.s | 73 +----------------------------------
 src/runtime/timestub2.go      | 10 ++++-
 2 files changed, 10 insertions(+), 73 deletions(-)

diff --git a/src/runtime/sys_linux_amd64.s b/src/runtime/sys_linux_amd64.s
index ee587de805..33cc670b64 100644
--- a/src/runtime/sys_linux_amd64.s
+++ b/src/runtime/sys_linux_amd64.s
@@ -204,9 +204,8 @@ TEXT runtime·mincore(SB),NOSPLIT,$0-28
 	MOVL	AX, ret+24(FP)
 	RET
 
-// func walltime() (sec int64, nsec int32)
-// non-zero frame-size means bp is saved and restored
-TEXT runtime·walltime(SB),NOSPLIT,$16-12
+// func nanotime1() int64
+TEXT runtime·nanotime1(SB),NOSPLIT,$16-8
 	// We don't know how much stack space the VDSO code will need,
 	// so switch to g0.
 	// In particular, a kernel configured with CONFIG_OPTIMIZE_INLINING=n
@@ -216,74 +215,6 @@ TEXT runtime·walltime(SB),NOSPLIT,$16-12
 
 	MOVQ	SP, R12	// Save old SP; R12 unchanged by C code.
 
-#ifdef GOEXPERIMENT_regabig
-	MOVQ	g_m(R14), BX // BX unchanged by C code.
-#else
-	get_tls(CX)
-	MOVQ	g(CX), AX
-	MOVQ	g_m(AX), BX // BX unchanged by C code.
-#endif
-
-	// Set vdsoPC and vdsoSP for SIGPROF traceback.
-	// Save the old values on stack and restore them on exit,
-	// so this function is reentrant.
-	MOVQ	m_vdsoPC(BX), CX
-	MOVQ	m_vdsoSP(BX), DX
-	MOVQ	CX, 0(SP)
-	MOVQ	DX, 8(SP)
-
-	LEAQ	sec+0(FP), DX
-	MOVQ	-8(DX), CX
-	MOVQ	CX, m_vdsoPC(BX)
-	MOVQ	DX, m_vdsoSP(BX)
-
-#ifdef GOEXPERIMENT_regabig
-	CMPQ	R14, m_curg(BX)	// Only switch if on curg.
-#else
-	CMPQ	AX, m_curg(BX)	// Only switch if on curg.
-#endif
-	JNE	noswitch
-
-	MOVQ	m_g0(BX), DX
-	MOVQ	(g_sched+gobuf_sp)(DX), SP	// Set SP to g0 stack
-
-noswitch:
-	SUBQ	$16, SP		// Space for results
-	ANDQ	$~15, SP	// Align for C code
-
-	MOVL	$0, DI // CLOCK_REALTIME
-	LEAQ	0(SP), SI
-	MOVQ	runtime·vdsoClockgettimeSym(SB), AX
-	CMPQ	AX, $0
-	JEQ	fallback
-	CALL	AX
-ret:
-	MOVQ	0(SP), AX	// sec
-	MOVQ	8(SP), DX	// nsec
-	MOVQ	R12, SP		// Restore real SP
-	// Restore vdsoPC, vdsoSP
-	// We don't worry about being signaled between the two stores.
-	// If we are not in a signal handler, we'll restore vdsoSP to 0,
-	// and no one will care about vdsoPC. If we are in a signal handler,
-	// we cannot receive another signal.
-	MOVQ	8(SP), CX
-	MOVQ	CX, m_vdsoSP(BX)
-	MOVQ	0(SP), CX
-	MOVQ	CX, m_vdsoPC(BX)
-	MOVQ	AX, sec+0(FP)
-	MOVL	DX, nsec+8(FP)
-	RET
-fallback:
-	MOVQ	$SYS_clock_gettime, AX
-	SYSCALL
-	JMP ret
-
-// func nanotime1() int64
-TEXT runtime·nanotime1(SB),NOSPLIT,$16-8
-	// Switch to g0 stack. See comment above in runtime·walltime.
-
-	MOVQ	SP, R12	// Save old SP; R12 unchanged by C code.
-
 #ifdef GOEXPERIMENT_regabig
 	MOVQ	g_m(R14), BX // BX unchanged by C code.
 #else
diff --git a/src/runtime/timestub2.go b/src/runtime/timestub2.go
index d66579440e..800a2a94e0 100644
--- a/src/runtime/timestub2.go
+++ b/src/runtime/timestub2.go
@@ -2,8 +2,14 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build !aix && !darwin && !freebsd && !openbsd && !solaris && !windows
-// +build !aix,!darwin,!freebsd,!openbsd,!solaris,!windows
+//go:build !aix && !darwin && !freebsd && !openbsd && !solaris && !windows && !(linux && amd64)
+// +build !aix
+// +build !darwin
+// +build !freebsd
+// +build !openbsd
+// +build !solaris
+// +build !windows
+// +build !linux !amd64
 
 package runtime
 
-- 
GitLab


From f12dfeac89637dd509cb3eaa81d3116fc49a4daf Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Mon, 26 Apr 2021 22:25:20 -0400
Subject: [PATCH 1851/2400] cmd/link: support trampoline insertion on ARM64

Compared to ARM32 or PPC64, ARM64 has larger range for direct jumps.
But for very large programs it can still go over the limit. Add
trampoline insertion for ARM64.

Updates #40492.

Change-Id: Id97301dbc35fb577ba3f8d5f3316a8424d4f53c4
Reviewed-on: https://go-review.googlesource.com/c/go/+/314451
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/arm64/asm.go | 132 +++++++++++++++++++++++++++++
 src/cmd/link/internal/arm64/obj.go |   2 +
 src/cmd/link/link_test.go          |   2 +-
 3 files changed, 135 insertions(+), 1 deletion(-)

diff --git a/src/cmd/link/internal/arm64/asm.go b/src/cmd/link/internal/arm64/asm.go
index 68e59f2dcf..fad709d314 100644
--- a/src/cmd/link/internal/arm64/asm.go
+++ b/src/cmd/link/internal/arm64/asm.go
@@ -413,6 +413,34 @@ func adddynrel(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, s loade
 			// (e.g. go version).
 			return true
 		}
+
+	case objabi.R_ARM64_GOTPCREL:
+		if target.IsExternal() {
+			// External linker will do this relocation.
+			return true
+		}
+		if targType != sym.SDYNIMPORT {
+			ldr.Errorf(s, "R_ARM64_GOTPCREL target is not SDYNIMPORT symbol: %v", ldr.SymName(targ))
+		}
+		if r.Add() != 0 {
+			ldr.Errorf(s, "R_ARM64_GOTPCREL with non-zero addend (%v)", r.Add())
+		}
+		if target.IsElf() {
+			ld.AddGotSym(target, ldr, syms, targ, uint32(elf.R_AARCH64_GLOB_DAT))
+		} else {
+			ld.AddGotSym(target, ldr, syms, targ, 0)
+		}
+		// turn into two relocations, one for each instruction.
+		su := ldr.MakeSymbolUpdater(s)
+		r.SetType(objabi.R_ARM64_GOT)
+		r.SetSiz(4)
+		r.SetSym(syms.GOT)
+		r.SetAdd(int64(ldr.SymGot(targ)))
+		r2, _ := su.AddRel(objabi.R_ARM64_GOT)
+		r2.SetSiz(4)
+		r2.SetOff(r.Off() + 4)
+		r2.SetSym(syms.GOT)
+		r2.SetAdd(int64(ldr.SymGot(targ)))
 	}
 	return false
 }
@@ -1154,3 +1182,107 @@ func offsetLabelName(ldr *loader.Loader, s loader.Sym, off int64) string {
 	}
 	return fmt.Sprintf("%s+%d", ldr.SymExtname(s), off)
 }
+
+// Convert the direct jump relocation r to refer to a trampoline if the target is too far
+func trampoline(ctxt *ld.Link, ldr *loader.Loader, ri int, rs, s loader.Sym) {
+	relocs := ldr.Relocs(s)
+	r := relocs.At(ri)
+	switch r.Type() {
+	case objabi.R_CALLARM64:
+		var t int64
+		// ldr.SymValue(rs) == 0 indicates a cross-package jump to a function that is not yet
+		// laid out. Conservatively use a trampoline. This should be rare, as we lay out packages
+		// in dependency order.
+		if ldr.SymValue(rs) != 0 {
+			t = ldr.SymValue(rs) + r.Add() - (ldr.SymValue(s) + int64(r.Off()))
+		}
+		if t >= 1<<27 || t < -1<<27 || ldr.SymValue(rs) == 0 || (*ld.FlagDebugTramp > 1 && ldr.SymPkg(s) != ldr.SymPkg(rs)) {
+			// direct call too far, need to insert trampoline.
+			// look up existing trampolines first. if we found one within the range
+			// of direct call, we can reuse it. otherwise create a new one.
+			var tramp loader.Sym
+			for i := 0; ; i++ {
+				oName := ldr.SymName(rs)
+				name := oName + fmt.Sprintf("%+x-tramp%d", r.Add(), i)
+				tramp = ldr.LookupOrCreateSym(name, int(ldr.SymVersion(rs)))
+				ldr.SetAttrReachable(tramp, true)
+				if ldr.SymType(tramp) == sym.SDYNIMPORT {
+					// don't reuse trampoline defined in other module
+					continue
+				}
+				if oName == "runtime.deferreturn" {
+					ldr.SetIsDeferReturnTramp(tramp, true)
+				}
+				if ldr.SymValue(tramp) == 0 {
+					// either the trampoline does not exist -- we need to create one,
+					// or found one the address which is not assigned -- this will be
+					// laid down immediately after the current function. use this one.
+					break
+				}
+
+				t = ldr.SymValue(tramp) - (ldr.SymValue(s) + int64(r.Off()))
+				if t >= -1<<27 && t < 1<<27 {
+					// found an existing trampoline that is not too far
+					// we can just use it
+					break
+				}
+			}
+			if ldr.SymType(tramp) == 0 {
+				// trampoline does not exist, create one
+				trampb := ldr.MakeSymbolUpdater(tramp)
+				ctxt.AddTramp(trampb)
+				if ldr.SymType(rs) == sym.SDYNIMPORT {
+					if r.Add() != 0 {
+						ctxt.Errorf(s, "nonzero addend for DYNIMPORT call: %v+%d", ldr.SymName(rs), r.Add())
+					}
+					gentrampgot(ctxt, ldr, trampb, rs)
+				} else {
+					gentramp(ctxt, ldr, trampb, rs, r.Add())
+				}
+			}
+			// modify reloc to point to tramp, which will be resolved later
+			sb := ldr.MakeSymbolUpdater(s)
+			relocs := sb.Relocs()
+			r := relocs.At(ri)
+			r.SetSym(tramp)
+			r.SetAdd(0) // clear the offset embedded in the instruction
+		}
+	default:
+		ctxt.Errorf(s, "trampoline called with non-jump reloc: %d (%s)", r.Type(), sym.RelocName(ctxt.Arch, r.Type()))
+	}
+}
+
+// generate a trampoline to target+offset.
+func gentramp(ctxt *ld.Link, ldr *loader.Loader, tramp *loader.SymbolBuilder, target loader.Sym, offset int64) {
+	tramp.SetSize(12) // 3 instructions
+	P := make([]byte, tramp.Size())
+	o1 := uint32(0x90000010) // adrp x16, target
+	o2 := uint32(0x91000210) // add x16, pc-relative-offset
+	o3 := uint32(0xd61f0200) // br x16
+	ctxt.Arch.ByteOrder.PutUint32(P, o1)
+	ctxt.Arch.ByteOrder.PutUint32(P[4:], o2)
+	ctxt.Arch.ByteOrder.PutUint32(P[8:], o3)
+	tramp.SetData(P)
+
+	r, _ := tramp.AddRel(objabi.R_ADDRARM64)
+	r.SetSiz(8)
+	r.SetSym(target)
+	r.SetAdd(offset)
+}
+
+// generate a trampoline to target+offset for a DYNIMPORT symbol via GOT.
+func gentrampgot(ctxt *ld.Link, ldr *loader.Loader, tramp *loader.SymbolBuilder, target loader.Sym) {
+	tramp.SetSize(12) // 3 instructions
+	P := make([]byte, tramp.Size())
+	o1 := uint32(0x90000010) // adrp x16, target@GOT
+	o2 := uint32(0xf9400210) // ldr x16, [x16, offset]
+	o3 := uint32(0xd61f0200) // br x16
+	ctxt.Arch.ByteOrder.PutUint32(P, o1)
+	ctxt.Arch.ByteOrder.PutUint32(P[4:], o2)
+	ctxt.Arch.ByteOrder.PutUint32(P[8:], o3)
+	tramp.SetData(P)
+
+	r, _ := tramp.AddRel(objabi.R_ARM64_GOTPCREL)
+	r.SetSiz(8)
+	r.SetSym(target)
+}
diff --git a/src/cmd/link/internal/arm64/obj.go b/src/cmd/link/internal/arm64/obj.go
index 18a32531e9..9c7459855c 100644
--- a/src/cmd/link/internal/arm64/obj.go
+++ b/src/cmd/link/internal/arm64/obj.go
@@ -45,6 +45,7 @@ func Init() (*sys.Arch, ld.Arch) {
 		Minalign:   minAlign,
 		Dwarfregsp: dwarfRegSP,
 		Dwarfreglr: dwarfRegLR,
+		TrampLimit: 0x7c00000, // 26-bit signed offset * 4, leave room for PLT etc.
 
 		Adddynrel:        adddynrel,
 		Archinit:         archinit,
@@ -59,6 +60,7 @@ func Init() (*sys.Arch, ld.Arch) {
 		Machoreloc1:      machoreloc1,
 		MachorelocSize:   8,
 		PEreloc1:         pereloc1,
+		Trampoline:       trampoline,
 
 		Androiddynld: "/system/bin/linker64",
 		Linuxdynld:   "/lib/ld-linux-aarch64.so.1",
diff --git a/src/cmd/link/link_test.go b/src/cmd/link/link_test.go
index 285c650282..bf4c2ab91e 100644
--- a/src/cmd/link/link_test.go
+++ b/src/cmd/link/link_test.go
@@ -618,7 +618,7 @@ func TestTrampoline(t *testing.T) {
 	// threshold for trampoline generation, and essentially all cross-package
 	// calls will use trampolines.
 	switch runtime.GOARCH {
-	case "arm", "ppc64", "ppc64le":
+	case "arm", "arm64", "ppc64", "ppc64le":
 	default:
 		t.Skipf("trampoline insertion is not implemented on %s", runtime.GOARCH)
 	}
-- 
GitLab


From 657f58d845e83c47c7d4b7638ccbee8e5a2acbf5 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 27 Apr 2021 10:57:09 -0400
Subject: [PATCH 1852/2400] cmd/link: support trampoline insertion for PLT
 calls on ARM64

When internal linking with C objects, some C object relocations
may be turned into a CALL via PLT. For very large programs, the
PLT stub may be laid too far.

PLT stubs are generated late in the linker, and laid out after
the end of the text section. So if the text section is big, the
PLT stubs are likely too far.

To avoid this situation, add trampolines for PLT calls in the
trampoline pass. Only do this when the program is known too large
(i.e. the second pass of the two-pass algorithm).

Updates #40492.

Change-Id: I21f65d6cbc6bde84e3cf9c2ae05f5233df6cfa72
Reviewed-on: https://go-review.googlesource.com/c/go/+/314452
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/arm64/asm.go | 10 +++++++++-
 src/cmd/link/internal/ld/data.go   | 26 +++++++++++++++++++++++---
 2 files changed, 32 insertions(+), 4 deletions(-)

diff --git a/src/cmd/link/internal/arm64/asm.go b/src/cmd/link/internal/arm64/asm.go
index fad709d314..c10bdc4120 100644
--- a/src/cmd/link/internal/arm64/asm.go
+++ b/src/cmd/link/internal/arm64/asm.go
@@ -441,6 +441,7 @@ func adddynrel(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, s loade
 		r2.SetOff(r.Off() + 4)
 		r2.SetSym(syms.GOT)
 		r2.SetAdd(int64(ldr.SymGot(targ)))
+		return true
 	}
 	return false
 }
@@ -1187,7 +1188,14 @@ func offsetLabelName(ldr *loader.Loader, s loader.Sym, off int64) string {
 func trampoline(ctxt *ld.Link, ldr *loader.Loader, ri int, rs, s loader.Sym) {
 	relocs := ldr.Relocs(s)
 	r := relocs.At(ri)
+	const pcrel = 1
 	switch r.Type() {
+	case objabi.ElfRelocOffset + objabi.RelocType(elf.R_AARCH64_CALL26),
+		objabi.ElfRelocOffset + objabi.RelocType(elf.R_AARCH64_JUMP26),
+		objabi.MachoRelocOffset + ld.MACHO_ARM64_RELOC_BRANCH26*2 + pcrel:
+		// Host object relocations that will be turned into a PLT call.
+		// The PLT may be too far. Insert a trampoline for them.
+		fallthrough
 	case objabi.R_CALLARM64:
 		var t int64
 		// ldr.SymValue(rs) == 0 indicates a cross-package jump to a function that is not yet
@@ -1196,7 +1204,7 @@ func trampoline(ctxt *ld.Link, ldr *loader.Loader, ri int, rs, s loader.Sym) {
 		if ldr.SymValue(rs) != 0 {
 			t = ldr.SymValue(rs) + r.Add() - (ldr.SymValue(s) + int64(r.Off()))
 		}
-		if t >= 1<<27 || t < -1<<27 || ldr.SymValue(rs) == 0 || (*ld.FlagDebugTramp > 1 && ldr.SymPkg(s) != ldr.SymPkg(rs)) {
+		if t >= 1<<27 || t < -1<<27 || ldr.SymValue(rs) == 0 || (*ld.FlagDebugTramp > 1 && (ldr.SymPkg(s) == "" || ldr.SymPkg(s) != ldr.SymPkg(rs))) {
 			// direct call too far, need to insert trampoline.
 			// look up existing trampolines first. if we found one within the range
 			// of direct call, we can reuse it. otherwise create a new one.
diff --git a/src/cmd/link/internal/ld/data.go b/src/cmd/link/internal/ld/data.go
index a5e6d37f29..1b5eb2f7e3 100644
--- a/src/cmd/link/internal/ld/data.go
+++ b/src/cmd/link/internal/ld/data.go
@@ -39,6 +39,7 @@ import (
 	"cmd/link/internal/loader"
 	"cmd/link/internal/sym"
 	"compress/zlib"
+	"debug/elf"
 	"encoding/binary"
 	"fmt"
 	"log"
@@ -98,7 +99,8 @@ func trampoline(ctxt *Link, s loader.Sym) {
 	relocs := ldr.Relocs(s)
 	for ri := 0; ri < relocs.Count(); ri++ {
 		r := relocs.At(ri)
-		if !r.Type().IsDirectCallOrJump() {
+		rt := r.Type()
+		if !rt.IsDirectCallOrJump() && !isPLTCall(rt) {
 			continue
 		}
 		rs := r.Sym()
@@ -107,8 +109,11 @@ func trampoline(ctxt *Link, s loader.Sym) {
 		}
 		rs = ldr.ResolveABIAlias(rs)
 		if ldr.SymValue(rs) == 0 && (ldr.SymType(rs) != sym.SDYNIMPORT && ldr.SymType(rs) != sym.SUNDEFEXT) {
-			if ldr.SymPkg(rs) == ldr.SymPkg(s) {
-				continue // symbols in the same package are laid out together
+			if ldr.SymPkg(s) != "" && ldr.SymPkg(rs) == ldr.SymPkg(s) {
+				// Symbols in the same package are laid out together.
+				// Except that if SymPkg(s) == "", it is a host object symbol
+				// which may call an external symbol via PLT.
+				continue
 			}
 			if isRuntimeDepPkg(ldr.SymPkg(s)) && isRuntimeDepPkg(ldr.SymPkg(rs)) {
 				continue // runtime packages are laid out together
@@ -119,6 +124,21 @@ func trampoline(ctxt *Link, s loader.Sym) {
 	}
 }
 
+// whether rt is a (host object) relocation that will be turned into
+// a call to PLT.
+func isPLTCall(rt objabi.RelocType) bool {
+	const pcrel = 1
+	switch rt {
+	// ARM64
+	case objabi.ElfRelocOffset + objabi.RelocType(elf.R_AARCH64_CALL26),
+		objabi.ElfRelocOffset + objabi.RelocType(elf.R_AARCH64_JUMP26),
+		objabi.MachoRelocOffset + MACHO_ARM64_RELOC_BRANCH26*2 + pcrel:
+		return true
+	}
+	// TODO: other architectures.
+	return false
+}
+
 // FoldSubSymbolOffset computes the offset of symbol s to its top-level outer
 // symbol. Returns the top-level symbol and the offset.
 // This is used in generating external relocations.
-- 
GitLab


From 12eaefead46d7ba10fce622f093d4c9b2989a5c0 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 27 Apr 2021 17:11:03 -0400
Subject: [PATCH 1853/2400] cmd/link: support trampoline insertion for PLT
 calls on ARM

This is CL 314452, for ARM.

Fixes #30949.

Change-Id: Ib4e46a5bd11c698c4f8ea3bc4e7a605d7a538efc
Reviewed-on: https://go-review.googlesource.com/c/go/+/314455
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/arm/asm.go | 25 +++++++++++++++++++++++--
 src/cmd/link/internal/ld/data.go |  6 ++++++
 2 files changed, 29 insertions(+), 2 deletions(-)

diff --git a/src/cmd/link/internal/arm/asm.go b/src/cmd/link/internal/arm/asm.go
index 33b20febd7..ab780214bb 100644
--- a/src/cmd/link/internal/arm/asm.go
+++ b/src/cmd/link/internal/arm/asm.go
@@ -111,7 +111,7 @@ func adddynrel(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, s loade
 			return false
 		}
 
-		// Handle relocations found in ELF object files.
+	// Handle relocations found in ELF object files.
 	case objabi.ElfRelocOffset + objabi.RelocType(elf.R_ARM_PLT32):
 		su := ldr.MakeSymbolUpdater(s)
 		su.SetRelocType(rIdx, objabi.R_CALLARM)
@@ -237,6 +237,21 @@ func adddynrel(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, s loade
 			su.SetRelocSym(rIdx, 0)
 			return true
 		}
+
+	case objabi.R_GOTPCREL:
+		if target.IsExternal() {
+			// External linker will do this relocation.
+			return true
+		}
+		if targType != sym.SDYNIMPORT {
+			ldr.Errorf(s, "R_GOTPCREL target is not SDYNIMPORT symbol: %v", ldr.SymName(targ))
+		}
+		ld.AddGotSym(target, ldr, syms, targ, uint32(elf.R_ARM_GLOB_DAT))
+		su := ldr.MakeSymbolUpdater(s)
+		su.SetRelocType(rIdx, objabi.R_PCREL)
+		su.SetRelocSym(rIdx, syms.GOT)
+		su.SetRelocAdd(rIdx, r.Add()+int64(ldr.SymGot(targ)))
+		return true
 	}
 
 	return false
@@ -369,6 +384,12 @@ func trampoline(ctxt *ld.Link, ldr *loader.Loader, ri int, rs, s loader.Sym) {
 	relocs := ldr.Relocs(s)
 	r := relocs.At(ri)
 	switch r.Type() {
+	case objabi.ElfRelocOffset + objabi.RelocType(elf.R_ARM_CALL),
+		objabi.ElfRelocOffset + objabi.RelocType(elf.R_ARM_PC24),
+		objabi.ElfRelocOffset + objabi.RelocType(elf.R_ARM_JUMP24):
+		// Host object relocations that will be turned into a PLT call.
+		// The PLT may be too far. Insert a trampoline for them.
+		fallthrough
 	case objabi.R_CALLARM:
 		var t int64
 		// ldr.SymValue(rs) == 0 indicates a cross-package jump to a function that is not yet
@@ -415,7 +436,7 @@ func trampoline(ctxt *ld.Link, ldr *loader.Loader, ri int, rs, s loader.Sym) {
 				// trampoline does not exist, create one
 				trampb := ldr.MakeSymbolUpdater(tramp)
 				ctxt.AddTramp(trampb)
-				if ctxt.DynlinkingGo() {
+				if ctxt.DynlinkingGo() || ldr.SymType(rs) == sym.SDYNIMPORT {
 					if immrot(uint32(offset)) == 0 {
 						ctxt.Errorf(s, "odd offset in dynlink direct call: %v+%d", ldr.SymName(rs), offset)
 					}
diff --git a/src/cmd/link/internal/ld/data.go b/src/cmd/link/internal/ld/data.go
index 1b5eb2f7e3..1c3af94692 100644
--- a/src/cmd/link/internal/ld/data.go
+++ b/src/cmd/link/internal/ld/data.go
@@ -134,6 +134,12 @@ func isPLTCall(rt objabi.RelocType) bool {
 		objabi.ElfRelocOffset + objabi.RelocType(elf.R_AARCH64_JUMP26),
 		objabi.MachoRelocOffset + MACHO_ARM64_RELOC_BRANCH26*2 + pcrel:
 		return true
+
+	// ARM
+	case objabi.ElfRelocOffset + objabi.RelocType(elf.R_ARM_CALL),
+		objabi.ElfRelocOffset + objabi.RelocType(elf.R_ARM_PC24),
+		objabi.ElfRelocOffset + objabi.RelocType(elf.R_ARM_JUMP24):
+		return true
 	}
 	// TODO: other architectures.
 	return false
-- 
GitLab


From 948a262455346c6035df6bd5dc36c5d4b6aca409 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 28 Apr 2021 15:08:47 -0700
Subject: [PATCH 1854/2400] cmd/compile/internal/types2: nest all test data
 under the testdata directory

This matches https://golang.org/cl/314829 for go/types.

Change-Id: If3d127af0557bb13d504581920ea03e39db0eb07
Reviewed-on: https://go-review.googlesource.com/c/go/+/314772
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/check_test.go         | 11 ++++++-----
 .../internal/types2/testdata/{ => check}/blank.src    |  0
 .../internal/types2/testdata/{ => check}/builtins.go2 |  0
 .../internal/types2/testdata/{ => check}/builtins.src |  0
 .../internal/types2/testdata/{ => check}/chans.go2    |  0
 .../internal/types2/testdata/{ => check}/const0.src   |  0
 .../internal/types2/testdata/{ => check}/const1.src   |  0
 .../types2/testdata/{ => check}/constdecl.src         |  0
 .../types2/testdata/{ => check}/conversions.src       |  0
 .../types2/testdata/{ => check}/conversions2.src      |  0
 .../internal/types2/testdata/{ => check}/cycles.src   |  0
 .../internal/types2/testdata/{ => check}/cycles1.src  |  0
 .../internal/types2/testdata/{ => check}/cycles2.src  |  0
 .../internal/types2/testdata/{ => check}/cycles3.src  |  0
 .../internal/types2/testdata/{ => check}/cycles4.src  |  0
 .../internal/types2/testdata/{ => check}/cycles5.src  |  0
 .../internal/types2/testdata/{ => check}/decls0.src   |  0
 .../internal/types2/testdata/{ => check}/decls1.src   |  0
 .../types2/testdata/{ => check}/decls2/decls2a.src    |  0
 .../types2/testdata/{ => check}/decls2/decls2b.src    |  0
 .../internal/types2/testdata/{ => check}/decls3.src   |  0
 .../internal/types2/testdata/{ => check}/decls4.src   |  0
 .../internal/types2/testdata/{ => check}/decls5.src   |  0
 .../internal/types2/testdata/{ => check}/errors.src   |  0
 .../internal/types2/testdata/{ => check}/expr0.src    |  0
 .../internal/types2/testdata/{ => check}/expr1.src    |  0
 .../internal/types2/testdata/{ => check}/expr2.src    |  0
 .../internal/types2/testdata/{ => check}/expr3.src    |  0
 .../internal/types2/testdata/{ => check}/go1_12.src   |  0
 .../internal/types2/testdata/{ => check}/go1_13.src   |  0
 .../internal/types2/testdata/{ => check}/go1_8.src    |  0
 .../internal/types2/testdata/{ => check}/gotos.src    |  0
 .../internal/types2/testdata/{ => check}/importC.src  |  0
 .../testdata/{ => check}/importdecl0/importdecl0a.src |  0
 .../testdata/{ => check}/importdecl0/importdecl0b.src |  0
 .../testdata/{ => check}/importdecl1/importdecl1a.src |  0
 .../testdata/{ => check}/importdecl1/importdecl1b.src |  0
 .../internal/types2/testdata/{ => check}/init0.src    |  0
 .../internal/types2/testdata/{ => check}/init1.src    |  0
 .../internal/types2/testdata/{ => check}/init2.src    |  0
 .../testdata/{ => check}/issue25008/issue25008a.src   |  0
 .../testdata/{ => check}/issue25008/issue25008b.src   |  0
 .../internal/types2/testdata/{ => check}/issues.go2   |  0
 .../internal/types2/testdata/{ => check}/issues.src   |  0
 .../internal/types2/testdata/{ => check}/labels.src   |  0
 .../internal/types2/testdata/{ => check}/linalg.go2   |  0
 .../internal/types2/testdata/{ => check}/literals.src |  0
 .../internal/types2/testdata/{ => check}/main.go2     |  0
 .../internal/types2/testdata/{ => check}/main.src     |  0
 .../internal/types2/testdata/{ => check}/map.go2      |  0
 .../internal/types2/testdata/{ => check}/map2.go2     |  0
 .../types2/testdata/{ => check}/methodsets.src        |  0
 .../types2/testdata/{ => check}/mtypeparams.go2       |  0
 .../internal/types2/testdata/{ => check}/shifts.src   |  0
 .../internal/types2/testdata/{ => check}/slices.go2   |  0
 .../internal/types2/testdata/{ => check}/stmt0.src    |  0
 .../internal/types2/testdata/{ => check}/stmt1.src    |  0
 .../types2/testdata/{ => check}/tinference.go2        |  0
 .../internal/types2/testdata/{ => check}/tmp.go2      |  0
 .../internal/types2/testdata/{ => check}/typeinst.go2 |  0
 .../types2/testdata/{ => check}/typeinst2.go2         |  0
 .../types2/testdata/{ => check}/typeparams.go2        |  0
 .../internal/types2/testdata/{ => check}/vardecl.src  |  0
 .../types2/{ => testdata}/examples/functions.go2      |  0
 .../types2/{ => testdata}/examples/inference.go2      |  0
 .../types2/{ => testdata}/examples/methods.go2        |  0
 .../internal/types2/{ => testdata}/examples/types.go2 |  0
 .../types2/{ => testdata}/fixedbugs/issue20583.src    |  0
 .../types2/{ => testdata}/fixedbugs/issue23203a.src   |  0
 .../types2/{ => testdata}/fixedbugs/issue23203b.src   |  0
 .../types2/{ => testdata}/fixedbugs/issue26390.src    |  0
 .../types2/{ => testdata}/fixedbugs/issue28251.src    |  0
 .../types2/{ => testdata}/fixedbugs/issue39634.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue39664.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue39680.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue39693.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue39699.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue39711.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue39723.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue39725.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue39754.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue39755.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue39768.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue39938.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue39948.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue39976.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue39982.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue40038.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue40056.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue40057.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue40301.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue40684.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue41124.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue42695.src    |  0
 .../types2/{ => testdata}/fixedbugs/issue42758.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue42987.src    |  0
 .../types2/{ => testdata}/fixedbugs/issue43087.src    |  0
 .../types2/{ => testdata}/fixedbugs/issue43110.src    |  0
 .../types2/{ => testdata}/fixedbugs/issue43124.src    |  0
 .../types2/{ => testdata}/fixedbugs/issue43125.src    |  0
 .../types2/{ => testdata}/fixedbugs/issue43190.src    |  0
 .../types2/{ => testdata}/fixedbugs/issue44688.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue44799.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue45548.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue45635.go2    |  0
 .../types2/{ => testdata}/fixedbugs/issue6977.src     |  0
 106 files changed, 6 insertions(+), 5 deletions(-)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/blank.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/builtins.go2 (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/builtins.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/chans.go2 (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/const0.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/const1.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/constdecl.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/conversions.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/conversions2.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/cycles.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/cycles1.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/cycles2.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/cycles3.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/cycles4.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/cycles5.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/decls0.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/decls1.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/decls2/decls2a.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/decls2/decls2b.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/decls3.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/decls4.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/decls5.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/errors.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/expr0.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/expr1.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/expr2.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/expr3.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/go1_12.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/go1_13.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/go1_8.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/gotos.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/importC.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/importdecl0/importdecl0a.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/importdecl0/importdecl0b.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/importdecl1/importdecl1a.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/importdecl1/importdecl1b.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/init0.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/init1.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/init2.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/issue25008/issue25008a.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/issue25008/issue25008b.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/issues.go2 (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/issues.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/labels.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/linalg.go2 (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/literals.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/main.go2 (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/main.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/map.go2 (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/map2.go2 (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/methodsets.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/mtypeparams.go2 (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/shifts.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/slices.go2 (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/stmt0.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/stmt1.src (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/tinference.go2 (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/tmp.go2 (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/typeinst.go2 (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/typeinst2.go2 (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/typeparams.go2 (100%)
 rename src/cmd/compile/internal/types2/testdata/{ => check}/vardecl.src (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/examples/functions.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/examples/inference.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/examples/methods.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/examples/types.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue20583.src (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue23203a.src (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue23203b.src (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue26390.src (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue28251.src (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue39634.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue39664.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue39680.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue39693.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue39699.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue39711.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue39723.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue39725.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue39754.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue39755.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue39768.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue39938.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue39948.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue39976.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue39982.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue40038.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue40056.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue40057.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue40301.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue40684.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue41124.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue42695.src (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue42758.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue42987.src (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue43087.src (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue43110.src (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue43124.src (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue43125.src (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue43190.src (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue44688.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue44799.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue45548.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue45635.go2 (100%)
 rename src/cmd/compile/internal/types2/{ => testdata}/fixedbugs/issue6977.src (100%)

diff --git a/src/cmd/compile/internal/types2/check_test.go b/src/cmd/compile/internal/types2/check_test.go
index 1ecd43778e..61bff28c8e 100644
--- a/src/cmd/compile/internal/types2/check_test.go
+++ b/src/cmd/compile/internal/types2/check_test.go
@@ -42,8 +42,8 @@ import (
 var (
 	haltOnError = flag.Bool("halt", false, "halt on error")
 	listErrors  = flag.Bool("errlist", false, "list errors")
-	testFiles   = flag.String("files", "", "comma-separated list of test files")
-	goVersion   = flag.String("lang", "", "Go language version (e.g. \"go1.12\"")
+	testFiles   = flag.String("files", "", "comma-separated list of TestManual")
+	goVersion   = flag.String("lang", "", "Go language version (e.g. \"go1.12\") for TestManual")
 )
 
 func parseFiles(t *testing.T, filenames []string, mode syntax.Mode) ([]*syntax.File, []error) {
@@ -239,9 +239,9 @@ func checkFiles(t *testing.T, filenames []string, goVersion string, colDelta uin
 	}
 }
 
-// TestCheck is for manual testing of selected input files, provided with -files.
+// TestManual is for manual testing of selected input files, provided with -files.
 // The accepted Go language version can be controlled with the -lang flag.
-func TestCheck(t *testing.T) {
+func TestManual(t *testing.T) {
 	if *testFiles == "" {
 		return
 	}
@@ -252,13 +252,14 @@ func TestCheck(t *testing.T) {
 
 // TODO(gri) go/types has extra TestLongConstants and TestIndexRepresentability tests
 
-func TestTestdata(t *testing.T)  { DefPredeclaredTestFuncs(); testDir(t, "testdata", 75) } // TODO(gri) narrow column tolerance
+func TestCheck(t *testing.T)     { DefPredeclaredTestFuncs(); testDir(t, "check", 75) } // TODO(gri) narrow column tolerance
 func TestExamples(t *testing.T)  { testDir(t, "examples", 0) }
 func TestFixedbugs(t *testing.T) { testDir(t, "fixedbugs", 0) }
 
 func testDir(t *testing.T, dir string, colDelta uint) {
 	testenv.MustHaveGoBuild(t)
 
+	dir = filepath.Join("testdata", dir)
 	fis, err := os.ReadDir(dir)
 	if err != nil {
 		t.Error(err)
diff --git a/src/cmd/compile/internal/types2/testdata/blank.src b/src/cmd/compile/internal/types2/testdata/check/blank.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/blank.src
rename to src/cmd/compile/internal/types2/testdata/check/blank.src
diff --git a/src/cmd/compile/internal/types2/testdata/builtins.go2 b/src/cmd/compile/internal/types2/testdata/check/builtins.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/builtins.go2
rename to src/cmd/compile/internal/types2/testdata/check/builtins.go2
diff --git a/src/cmd/compile/internal/types2/testdata/builtins.src b/src/cmd/compile/internal/types2/testdata/check/builtins.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/builtins.src
rename to src/cmd/compile/internal/types2/testdata/check/builtins.src
diff --git a/src/cmd/compile/internal/types2/testdata/chans.go2 b/src/cmd/compile/internal/types2/testdata/check/chans.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/chans.go2
rename to src/cmd/compile/internal/types2/testdata/check/chans.go2
diff --git a/src/cmd/compile/internal/types2/testdata/const0.src b/src/cmd/compile/internal/types2/testdata/check/const0.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/const0.src
rename to src/cmd/compile/internal/types2/testdata/check/const0.src
diff --git a/src/cmd/compile/internal/types2/testdata/const1.src b/src/cmd/compile/internal/types2/testdata/check/const1.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/const1.src
rename to src/cmd/compile/internal/types2/testdata/check/const1.src
diff --git a/src/cmd/compile/internal/types2/testdata/constdecl.src b/src/cmd/compile/internal/types2/testdata/check/constdecl.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/constdecl.src
rename to src/cmd/compile/internal/types2/testdata/check/constdecl.src
diff --git a/src/cmd/compile/internal/types2/testdata/conversions.src b/src/cmd/compile/internal/types2/testdata/check/conversions.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/conversions.src
rename to src/cmd/compile/internal/types2/testdata/check/conversions.src
diff --git a/src/cmd/compile/internal/types2/testdata/conversions2.src b/src/cmd/compile/internal/types2/testdata/check/conversions2.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/conversions2.src
rename to src/cmd/compile/internal/types2/testdata/check/conversions2.src
diff --git a/src/cmd/compile/internal/types2/testdata/cycles.src b/src/cmd/compile/internal/types2/testdata/check/cycles.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/cycles.src
rename to src/cmd/compile/internal/types2/testdata/check/cycles.src
diff --git a/src/cmd/compile/internal/types2/testdata/cycles1.src b/src/cmd/compile/internal/types2/testdata/check/cycles1.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/cycles1.src
rename to src/cmd/compile/internal/types2/testdata/check/cycles1.src
diff --git a/src/cmd/compile/internal/types2/testdata/cycles2.src b/src/cmd/compile/internal/types2/testdata/check/cycles2.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/cycles2.src
rename to src/cmd/compile/internal/types2/testdata/check/cycles2.src
diff --git a/src/cmd/compile/internal/types2/testdata/cycles3.src b/src/cmd/compile/internal/types2/testdata/check/cycles3.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/cycles3.src
rename to src/cmd/compile/internal/types2/testdata/check/cycles3.src
diff --git a/src/cmd/compile/internal/types2/testdata/cycles4.src b/src/cmd/compile/internal/types2/testdata/check/cycles4.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/cycles4.src
rename to src/cmd/compile/internal/types2/testdata/check/cycles4.src
diff --git a/src/cmd/compile/internal/types2/testdata/cycles5.src b/src/cmd/compile/internal/types2/testdata/check/cycles5.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/cycles5.src
rename to src/cmd/compile/internal/types2/testdata/check/cycles5.src
diff --git a/src/cmd/compile/internal/types2/testdata/decls0.src b/src/cmd/compile/internal/types2/testdata/check/decls0.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/decls0.src
rename to src/cmd/compile/internal/types2/testdata/check/decls0.src
diff --git a/src/cmd/compile/internal/types2/testdata/decls1.src b/src/cmd/compile/internal/types2/testdata/check/decls1.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/decls1.src
rename to src/cmd/compile/internal/types2/testdata/check/decls1.src
diff --git a/src/cmd/compile/internal/types2/testdata/decls2/decls2a.src b/src/cmd/compile/internal/types2/testdata/check/decls2/decls2a.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/decls2/decls2a.src
rename to src/cmd/compile/internal/types2/testdata/check/decls2/decls2a.src
diff --git a/src/cmd/compile/internal/types2/testdata/decls2/decls2b.src b/src/cmd/compile/internal/types2/testdata/check/decls2/decls2b.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/decls2/decls2b.src
rename to src/cmd/compile/internal/types2/testdata/check/decls2/decls2b.src
diff --git a/src/cmd/compile/internal/types2/testdata/decls3.src b/src/cmd/compile/internal/types2/testdata/check/decls3.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/decls3.src
rename to src/cmd/compile/internal/types2/testdata/check/decls3.src
diff --git a/src/cmd/compile/internal/types2/testdata/decls4.src b/src/cmd/compile/internal/types2/testdata/check/decls4.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/decls4.src
rename to src/cmd/compile/internal/types2/testdata/check/decls4.src
diff --git a/src/cmd/compile/internal/types2/testdata/decls5.src b/src/cmd/compile/internal/types2/testdata/check/decls5.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/decls5.src
rename to src/cmd/compile/internal/types2/testdata/check/decls5.src
diff --git a/src/cmd/compile/internal/types2/testdata/errors.src b/src/cmd/compile/internal/types2/testdata/check/errors.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/errors.src
rename to src/cmd/compile/internal/types2/testdata/check/errors.src
diff --git a/src/cmd/compile/internal/types2/testdata/expr0.src b/src/cmd/compile/internal/types2/testdata/check/expr0.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/expr0.src
rename to src/cmd/compile/internal/types2/testdata/check/expr0.src
diff --git a/src/cmd/compile/internal/types2/testdata/expr1.src b/src/cmd/compile/internal/types2/testdata/check/expr1.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/expr1.src
rename to src/cmd/compile/internal/types2/testdata/check/expr1.src
diff --git a/src/cmd/compile/internal/types2/testdata/expr2.src b/src/cmd/compile/internal/types2/testdata/check/expr2.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/expr2.src
rename to src/cmd/compile/internal/types2/testdata/check/expr2.src
diff --git a/src/cmd/compile/internal/types2/testdata/expr3.src b/src/cmd/compile/internal/types2/testdata/check/expr3.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/expr3.src
rename to src/cmd/compile/internal/types2/testdata/check/expr3.src
diff --git a/src/cmd/compile/internal/types2/testdata/go1_12.src b/src/cmd/compile/internal/types2/testdata/check/go1_12.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/go1_12.src
rename to src/cmd/compile/internal/types2/testdata/check/go1_12.src
diff --git a/src/cmd/compile/internal/types2/testdata/go1_13.src b/src/cmd/compile/internal/types2/testdata/check/go1_13.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/go1_13.src
rename to src/cmd/compile/internal/types2/testdata/check/go1_13.src
diff --git a/src/cmd/compile/internal/types2/testdata/go1_8.src b/src/cmd/compile/internal/types2/testdata/check/go1_8.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/go1_8.src
rename to src/cmd/compile/internal/types2/testdata/check/go1_8.src
diff --git a/src/cmd/compile/internal/types2/testdata/gotos.src b/src/cmd/compile/internal/types2/testdata/check/gotos.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/gotos.src
rename to src/cmd/compile/internal/types2/testdata/check/gotos.src
diff --git a/src/cmd/compile/internal/types2/testdata/importC.src b/src/cmd/compile/internal/types2/testdata/check/importC.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/importC.src
rename to src/cmd/compile/internal/types2/testdata/check/importC.src
diff --git a/src/cmd/compile/internal/types2/testdata/importdecl0/importdecl0a.src b/src/cmd/compile/internal/types2/testdata/check/importdecl0/importdecl0a.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/importdecl0/importdecl0a.src
rename to src/cmd/compile/internal/types2/testdata/check/importdecl0/importdecl0a.src
diff --git a/src/cmd/compile/internal/types2/testdata/importdecl0/importdecl0b.src b/src/cmd/compile/internal/types2/testdata/check/importdecl0/importdecl0b.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/importdecl0/importdecl0b.src
rename to src/cmd/compile/internal/types2/testdata/check/importdecl0/importdecl0b.src
diff --git a/src/cmd/compile/internal/types2/testdata/importdecl1/importdecl1a.src b/src/cmd/compile/internal/types2/testdata/check/importdecl1/importdecl1a.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/importdecl1/importdecl1a.src
rename to src/cmd/compile/internal/types2/testdata/check/importdecl1/importdecl1a.src
diff --git a/src/cmd/compile/internal/types2/testdata/importdecl1/importdecl1b.src b/src/cmd/compile/internal/types2/testdata/check/importdecl1/importdecl1b.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/importdecl1/importdecl1b.src
rename to src/cmd/compile/internal/types2/testdata/check/importdecl1/importdecl1b.src
diff --git a/src/cmd/compile/internal/types2/testdata/init0.src b/src/cmd/compile/internal/types2/testdata/check/init0.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/init0.src
rename to src/cmd/compile/internal/types2/testdata/check/init0.src
diff --git a/src/cmd/compile/internal/types2/testdata/init1.src b/src/cmd/compile/internal/types2/testdata/check/init1.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/init1.src
rename to src/cmd/compile/internal/types2/testdata/check/init1.src
diff --git a/src/cmd/compile/internal/types2/testdata/init2.src b/src/cmd/compile/internal/types2/testdata/check/init2.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/init2.src
rename to src/cmd/compile/internal/types2/testdata/check/init2.src
diff --git a/src/cmd/compile/internal/types2/testdata/issue25008/issue25008a.src b/src/cmd/compile/internal/types2/testdata/check/issue25008/issue25008a.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/issue25008/issue25008a.src
rename to src/cmd/compile/internal/types2/testdata/check/issue25008/issue25008a.src
diff --git a/src/cmd/compile/internal/types2/testdata/issue25008/issue25008b.src b/src/cmd/compile/internal/types2/testdata/check/issue25008/issue25008b.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/issue25008/issue25008b.src
rename to src/cmd/compile/internal/types2/testdata/check/issue25008/issue25008b.src
diff --git a/src/cmd/compile/internal/types2/testdata/issues.go2 b/src/cmd/compile/internal/types2/testdata/check/issues.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/issues.go2
rename to src/cmd/compile/internal/types2/testdata/check/issues.go2
diff --git a/src/cmd/compile/internal/types2/testdata/issues.src b/src/cmd/compile/internal/types2/testdata/check/issues.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/issues.src
rename to src/cmd/compile/internal/types2/testdata/check/issues.src
diff --git a/src/cmd/compile/internal/types2/testdata/labels.src b/src/cmd/compile/internal/types2/testdata/check/labels.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/labels.src
rename to src/cmd/compile/internal/types2/testdata/check/labels.src
diff --git a/src/cmd/compile/internal/types2/testdata/linalg.go2 b/src/cmd/compile/internal/types2/testdata/check/linalg.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/linalg.go2
rename to src/cmd/compile/internal/types2/testdata/check/linalg.go2
diff --git a/src/cmd/compile/internal/types2/testdata/literals.src b/src/cmd/compile/internal/types2/testdata/check/literals.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/literals.src
rename to src/cmd/compile/internal/types2/testdata/check/literals.src
diff --git a/src/cmd/compile/internal/types2/testdata/main.go2 b/src/cmd/compile/internal/types2/testdata/check/main.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/main.go2
rename to src/cmd/compile/internal/types2/testdata/check/main.go2
diff --git a/src/cmd/compile/internal/types2/testdata/main.src b/src/cmd/compile/internal/types2/testdata/check/main.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/main.src
rename to src/cmd/compile/internal/types2/testdata/check/main.src
diff --git a/src/cmd/compile/internal/types2/testdata/map.go2 b/src/cmd/compile/internal/types2/testdata/check/map.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/map.go2
rename to src/cmd/compile/internal/types2/testdata/check/map.go2
diff --git a/src/cmd/compile/internal/types2/testdata/map2.go2 b/src/cmd/compile/internal/types2/testdata/check/map2.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/map2.go2
rename to src/cmd/compile/internal/types2/testdata/check/map2.go2
diff --git a/src/cmd/compile/internal/types2/testdata/methodsets.src b/src/cmd/compile/internal/types2/testdata/check/methodsets.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/methodsets.src
rename to src/cmd/compile/internal/types2/testdata/check/methodsets.src
diff --git a/src/cmd/compile/internal/types2/testdata/mtypeparams.go2 b/src/cmd/compile/internal/types2/testdata/check/mtypeparams.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/mtypeparams.go2
rename to src/cmd/compile/internal/types2/testdata/check/mtypeparams.go2
diff --git a/src/cmd/compile/internal/types2/testdata/shifts.src b/src/cmd/compile/internal/types2/testdata/check/shifts.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/shifts.src
rename to src/cmd/compile/internal/types2/testdata/check/shifts.src
diff --git a/src/cmd/compile/internal/types2/testdata/slices.go2 b/src/cmd/compile/internal/types2/testdata/check/slices.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/slices.go2
rename to src/cmd/compile/internal/types2/testdata/check/slices.go2
diff --git a/src/cmd/compile/internal/types2/testdata/stmt0.src b/src/cmd/compile/internal/types2/testdata/check/stmt0.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/stmt0.src
rename to src/cmd/compile/internal/types2/testdata/check/stmt0.src
diff --git a/src/cmd/compile/internal/types2/testdata/stmt1.src b/src/cmd/compile/internal/types2/testdata/check/stmt1.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/stmt1.src
rename to src/cmd/compile/internal/types2/testdata/check/stmt1.src
diff --git a/src/cmd/compile/internal/types2/testdata/tinference.go2 b/src/cmd/compile/internal/types2/testdata/check/tinference.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/tinference.go2
rename to src/cmd/compile/internal/types2/testdata/check/tinference.go2
diff --git a/src/cmd/compile/internal/types2/testdata/tmp.go2 b/src/cmd/compile/internal/types2/testdata/check/tmp.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/tmp.go2
rename to src/cmd/compile/internal/types2/testdata/check/tmp.go2
diff --git a/src/cmd/compile/internal/types2/testdata/typeinst.go2 b/src/cmd/compile/internal/types2/testdata/check/typeinst.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/typeinst.go2
rename to src/cmd/compile/internal/types2/testdata/check/typeinst.go2
diff --git a/src/cmd/compile/internal/types2/testdata/typeinst2.go2 b/src/cmd/compile/internal/types2/testdata/check/typeinst2.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/typeinst2.go2
rename to src/cmd/compile/internal/types2/testdata/check/typeinst2.go2
diff --git a/src/cmd/compile/internal/types2/testdata/typeparams.go2 b/src/cmd/compile/internal/types2/testdata/check/typeparams.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/typeparams.go2
rename to src/cmd/compile/internal/types2/testdata/check/typeparams.go2
diff --git a/src/cmd/compile/internal/types2/testdata/vardecl.src b/src/cmd/compile/internal/types2/testdata/check/vardecl.src
similarity index 100%
rename from src/cmd/compile/internal/types2/testdata/vardecl.src
rename to src/cmd/compile/internal/types2/testdata/check/vardecl.src
diff --git a/src/cmd/compile/internal/types2/examples/functions.go2 b/src/cmd/compile/internal/types2/testdata/examples/functions.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/examples/functions.go2
rename to src/cmd/compile/internal/types2/testdata/examples/functions.go2
diff --git a/src/cmd/compile/internal/types2/examples/inference.go2 b/src/cmd/compile/internal/types2/testdata/examples/inference.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/examples/inference.go2
rename to src/cmd/compile/internal/types2/testdata/examples/inference.go2
diff --git a/src/cmd/compile/internal/types2/examples/methods.go2 b/src/cmd/compile/internal/types2/testdata/examples/methods.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/examples/methods.go2
rename to src/cmd/compile/internal/types2/testdata/examples/methods.go2
diff --git a/src/cmd/compile/internal/types2/examples/types.go2 b/src/cmd/compile/internal/types2/testdata/examples/types.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/examples/types.go2
rename to src/cmd/compile/internal/types2/testdata/examples/types.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue20583.src b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue20583.src
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue20583.src
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue20583.src
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue23203a.src b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue23203a.src
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue23203a.src
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue23203a.src
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue23203b.src b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue23203b.src
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue23203b.src
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue23203b.src
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue26390.src b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue26390.src
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue26390.src
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue26390.src
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue28251.src b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue28251.src
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue28251.src
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue28251.src
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39634.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39634.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue39634.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue39634.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39664.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39664.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue39664.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue39664.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39680.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39680.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue39680.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue39680.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39693.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39693.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue39693.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue39693.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39699.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39699.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue39699.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue39699.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39711.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39711.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue39711.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue39711.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39723.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39723.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue39723.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue39723.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39725.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39725.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue39725.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue39725.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39754.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39754.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue39754.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue39754.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39755.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39755.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue39755.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue39755.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39768.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39768.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue39768.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue39768.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39938.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39938.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue39938.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue39938.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39948.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39948.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue39948.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue39948.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39976.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39976.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue39976.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue39976.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue39982.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39982.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue39982.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue39982.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue40038.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue40038.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue40038.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue40038.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue40056.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue40056.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue40056.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue40056.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue40057.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue40057.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue40057.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue40057.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue40301.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue40301.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue40301.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue40301.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue40684.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue40684.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue40684.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue40684.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue41124.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue41124.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue41124.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue41124.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue42695.src b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue42695.src
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue42695.src
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue42695.src
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue42758.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue42758.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue42758.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue42758.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue42987.src b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue42987.src
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue42987.src
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue42987.src
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue43087.src b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue43087.src
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue43087.src
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue43087.src
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue43110.src b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue43110.src
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue43110.src
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue43110.src
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue43124.src b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue43124.src
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue43124.src
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue43124.src
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue43125.src b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue43125.src
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue43125.src
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue43125.src
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue43190.src b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue43190.src
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue43190.src
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue43190.src
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue44688.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue44688.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue44688.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue44688.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue44799.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue44799.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue44799.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue44799.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue45548.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue45548.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue45548.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue45548.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue45635.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue45635.go2
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue45635.go2
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue45635.go2
diff --git a/src/cmd/compile/internal/types2/fixedbugs/issue6977.src b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue6977.src
similarity index 100%
rename from src/cmd/compile/internal/types2/fixedbugs/issue6977.src
rename to src/cmd/compile/internal/types2/testdata/fixedbugs/issue6977.src
-- 
GitLab


From f7c6f6210be16d6ecfdece7c283fcd4ddc28b151 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Tue, 27 Apr 2021 14:57:11 -0400
Subject: [PATCH 1855/2400] cmd/link: test trampolines with cgo

Updates #40492, #30949.

Change-Id: I6d7923ac83275c5ab08958f7a501f7975aea151a
Reviewed-on: https://go-review.googlesource.com/c/go/+/314456
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/link_test.go | 71 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 71 insertions(+)

diff --git a/src/cmd/link/link_test.go b/src/cmd/link/link_test.go
index bf4c2ab91e..8805ff1f02 100644
--- a/src/cmd/link/link_test.go
+++ b/src/cmd/link/link_test.go
@@ -651,6 +651,77 @@ func TestTrampoline(t *testing.T) {
 	}
 }
 
+const testTrampCgoSrc = `
+package main
+
+// #include <stdio.h>
+// void CHello() { printf("hello\n"); fflush(stdout); }
+import "C"
+
+func main() {
+	C.CHello()
+}
+`
+
+func TestTrampolineCgo(t *testing.T) {
+	// Test that trampoline insertion works for cgo code.
+	// For stress test, we set -debugtramp=2 flag, which sets a very low
+	// threshold for trampoline generation, and essentially all cross-package
+	// calls will use trampolines.
+	switch runtime.GOARCH {
+	case "arm", "arm64", "ppc64", "ppc64le":
+	default:
+		t.Skipf("trampoline insertion is not implemented on %s", runtime.GOARCH)
+	}
+
+	testenv.MustHaveGoBuild(t)
+	testenv.MustHaveCGO(t)
+
+	t.Parallel()
+
+	tmpdir := t.TempDir()
+
+	src := filepath.Join(tmpdir, "hello.go")
+	err := ioutil.WriteFile(src, []byte(testTrampCgoSrc), 0666)
+	if err != nil {
+		t.Fatal(err)
+	}
+	exe := filepath.Join(tmpdir, "hello.exe")
+
+	cmd := exec.Command(testenv.GoToolPath(t), "build", "-ldflags=-debugtramp=2", "-o", exe, src)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("build failed: %v\n%s", err, out)
+	}
+	cmd = exec.Command(exe)
+	out, err = cmd.CombinedOutput()
+	if err != nil {
+		t.Errorf("executable failed to run: %v\n%s", err, out)
+	}
+	if string(out) != "hello\n" {
+		t.Errorf("unexpected output:\n%s", out)
+	}
+
+	// Test internal linking mode.
+
+	if runtime.GOARCH == "ppc64" || runtime.GOARCH == "ppc64le" || (runtime.GOARCH == "arm64" && runtime.GOOS == "windows") || !testenv.CanInternalLink() {
+		return // internal linking cgo is not supported
+	}
+	cmd = exec.Command(testenv.GoToolPath(t), "build", "-ldflags=-debugtramp=2 -linkmode=internal", "-o", exe, src)
+	out, err = cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("build failed: %v\n%s", err, out)
+	}
+	cmd = exec.Command(exe)
+	out, err = cmd.CombinedOutput()
+	if err != nil {
+		t.Errorf("executable failed to run: %v\n%s", err, out)
+	}
+	if string(out) != "hello\n" {
+		t.Errorf("unexpected output:\n%s", out)
+	}
+}
+
 func TestIndexMismatch(t *testing.T) {
 	// Test that index mismatch will cause a link-time error (not run-time error).
 	// This shouldn't happen with "go build". We invoke the compiler and the linker
-- 
GitLab


From 5a8435d701c1c8c39f403942d4f6a0ac065635db Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 29 Apr 2021 11:42:35 -0400
Subject: [PATCH 1856/2400] go/types: add additional test data from types2

Add some test data files that were not included in go/types.

- Issue 43125 only pertained to types2 because go/ast differentiates
  StarExpr, UnaryExpr, and BinaryExpr, so typexpr.go was already
  catching the invalid type expressions.
- Issues 42987 and 43190 are handled differently by go/parser.
- main.go2 was not added when ported to go/types, because this work
  happened on the dev.regabi branch, which didn't support generics.

Test files are modified to adjust errors messages and positions, and to
update the copyright year.

Change-Id: Ia737eaab9afb2b59600b661ccf3eec3cbbb2d66c
Reviewed-on: https://go-review.googlesource.com/c/go/+/315070
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/testdata/check/main.go2          |  7 ++++++
 .../types/testdata/fixedbugs/issue42987.src   | 10 +++++++++
 .../types/testdata/fixedbugs/issue43125.src   |  8 +++++++
 .../types/testdata/fixedbugs/issue43190.src   | 22 +++++++++++++++++++
 4 files changed, 47 insertions(+)
 create mode 100644 src/go/types/testdata/check/main.go2
 create mode 100644 src/go/types/testdata/fixedbugs/issue42987.src
 create mode 100644 src/go/types/testdata/fixedbugs/issue43125.src
 create mode 100644 src/go/types/testdata/fixedbugs/issue43190.src

diff --git a/src/go/types/testdata/check/main.go2 b/src/go/types/testdata/check/main.go2
new file mode 100644
index 0000000000..65e9aa2962
--- /dev/null
+++ b/src/go/types/testdata/check/main.go2
@@ -0,0 +1,7 @@
+// Copyright 2021 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
+
+func main[ /* ERROR "func main must have no type parameters" */ T any]() {}
diff --git a/src/go/types/testdata/fixedbugs/issue42987.src b/src/go/types/testdata/fixedbugs/issue42987.src
new file mode 100644
index 0000000000..6060ec84bd
--- /dev/null
+++ b/src/go/types/testdata/fixedbugs/issue42987.src
@@ -0,0 +1,10 @@
+// Copyright 2021 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.
+
+// Check that there is only one error (no follow-on errors).
+
+package p
+// TODO(rFindley) This is a parser error, but in types2 it is a type checking
+//                error. We could probably do without this check in the parser.
+var _ = [... /* ERROR expected array length, found '...' */ ]byte("foo")
diff --git a/src/go/types/testdata/fixedbugs/issue43125.src b/src/go/types/testdata/fixedbugs/issue43125.src
new file mode 100644
index 0000000000..456888de6b
--- /dev/null
+++ b/src/go/types/testdata/fixedbugs/issue43125.src
@@ -0,0 +1,8 @@
+// Copyright 2021 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 p
+
+var _ = new(- /* ERROR not a type */ 1)
+var _ = new(1 /* ERROR not a type */ + 1)
diff --git a/src/go/types/testdata/fixedbugs/issue43190.src b/src/go/types/testdata/fixedbugs/issue43190.src
new file mode 100644
index 0000000000..96acb3a2e3
--- /dev/null
+++ b/src/go/types/testdata/fixedbugs/issue43190.src
@@ -0,0 +1,22 @@
+// Copyright 2021 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.
+
+// Most of the errors below are actually produced by the parser, but we check
+// them here for consistency with the types2 tests.
+
+package p
+
+import ; /* ERROR invalid import path */ /* ERROR expected 'STRING' */
+import // ERROR expected ';'
+var _ int
+import /* ERROR expected declaration */ .;
+
+import ()
+import (.)
+import (
+	"fmt"
+	.
+)
+
+var _ = fmt /* ERROR "undeclared name" */ .Println
-- 
GitLab


From e03cca64073bd1b4704482c81061d19ab019b5cc Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Mon, 16 Nov 2020 22:03:17 +0000
Subject: [PATCH 1857/2400] runtime: use 4 MiB heap arenas on iOS

iOS arm64 is a 64-bit platform but with a strictly 32-bit address space
(technically 33 bits, but the bottom half is unavailable to the
application). Since address space is limited, use 4 MiB arenas instead
of 64 MiB arenas. No changes are needed to the arena index because it's
still relatively small; this change just brings iOS more in line with
32-bit platforms.

Change-Id: I484e2d273d896fd0a57cd5c25012df0aef160290
Reviewed-on: https://go-review.googlesource.com/c/go/+/270538
Trust: Michael Knyszek <mknyszek@google.com>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Trust: Brad Fitzpatrick <bradfitz@golang.org>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Austin Clements <austin@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/malloc.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/runtime/malloc.go b/src/runtime/malloc.go
index 5e4974d40e..f2d2425f53 100644
--- a/src/runtime/malloc.go
+++ b/src/runtime/malloc.go
@@ -227,6 +227,7 @@ const (
 	// --------------  ---------  ----------  ----------  -----------
 	//       */64-bit         48        64MB           1    4M (32MB)
 	// windows/64-bit         48         4MB          64    1M  (8MB)
+	//      ios/arm64         33         4MB           1  2048  (8KB)
 	//       */32-bit         32         4MB           1  1024  (4KB)
 	//     */mips(le)         31         4MB           1   512  (2KB)
 
@@ -247,7 +248,7 @@ const (
 	// logHeapArenaBytes is log_2 of heapArenaBytes. For clarity,
 	// prefer using heapArenaBytes where possible (we need the
 	// constant to compute some other constants).
-	logHeapArenaBytes = (6+20)*(_64bit*(1-sys.GoosWindows)*(1-sys.GoarchWasm)) + (2+20)*(_64bit*sys.GoosWindows) + (2+20)*(1-_64bit) + (2+20)*sys.GoarchWasm
+	logHeapArenaBytes = (6+20)*(_64bit*(1-sys.GoosWindows)*(1-sys.GoarchWasm)*(1-sys.GoosIos*sys.GoarchArm64)) + (2+20)*(_64bit*sys.GoosWindows) + (2+20)*(1-_64bit) + (2+20)*sys.GoarchWasm + (2+20)*sys.GoosIos*sys.GoarchArm64
 
 	// heapArenaBitmapBytes is the size of each heap arena's bitmap.
 	heapArenaBitmapBytes = heapArenaBytes / (sys.PtrSize * 8 / 2)
-- 
GitLab


From 32dbaac572f9aed4fbaa6aa359bdc821fa02e9d4 Mon Sep 17 00:00:00 2001
From: cuiweixie <cuiweixie@gmail.com>
Date: Thu, 29 Apr 2021 14:28:43 +0000
Subject: [PATCH 1858/2400] =?UTF-8?q?cmd/compile/internal/walk:=20merge=20?=
 =?UTF-8?q?operations=20when=20calling=20ir.NewSlic=E2=80=A6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Change-Id: I55ef35a9d8157063c4a41b23cd1ac0002838d30a
GitHub-Last-Rev: e716c5200545a944313ae0d995fcb6eb17d2720e
GitHub-Pull-Request: golang/go#45814
Reviewed-on: https://go-review.googlesource.com/c/go/+/314569
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/walk/builtin.go | 35 +++++++++---------------
 1 file changed, 13 insertions(+), 22 deletions(-)

diff --git a/src/cmd/compile/internal/walk/builtin.go b/src/cmd/compile/internal/walk/builtin.go
index 684fc7d72a..aacdedcb4d 100644
--- a/src/cmd/compile/internal/walk/builtin.go
+++ b/src/cmd/compile/internal/walk/builtin.go
@@ -421,16 +421,13 @@ func walkMakeSlice(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
 		fnname = "makeslice"
 		argtype = types.Types[types.TINT]
 	}
-
-	m := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
-	m.SetType(t)
-
 	fn := typecheck.LookupRuntime(fnname)
-	m.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, reflectdata.TypePtr(t.Elem()), typecheck.Conv(len, argtype), typecheck.Conv(cap, argtype))
-	m.Ptr.MarkNonNil()
-	m.Len = typecheck.Conv(len, types.Types[types.TINT])
-	m.Cap = typecheck.Conv(cap, types.Types[types.TINT])
-	return walkExpr(typecheck.Expr(m), init)
+	ptr := mkcall1(fn, types.Types[types.TUNSAFEPTR], init, reflectdata.TypePtr(t.Elem()), typecheck.Conv(len, argtype), typecheck.Conv(cap, argtype))
+	ptr.MarkNonNil()
+	len = typecheck.Conv(len, types.Types[types.TINT])
+	cap = typecheck.Conv(cap, types.Types[types.TINT])
+	sh := ir.NewSliceHeaderExpr(base.Pos, t, ptr, len, cap)
+	return walkExpr(typecheck.Expr(sh), init)
 }
 
 // walkMakeSliceCopy walks an OMAKESLICECOPY node.
@@ -459,12 +456,9 @@ func walkMakeSliceCopy(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
 
 		// instantiate mallocgc(size uintptr, typ *byte, needszero bool) unsafe.Pointer
 		fn := typecheck.LookupRuntime("mallocgc")
-		sh := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
-		sh.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, size, typecheck.NodNil(), ir.NewBool(false))
-		sh.Ptr.MarkNonNil()
-		sh.Len = length
-		sh.Cap = length
-		sh.SetType(t)
+		ptr := mkcall1(fn, types.Types[types.TUNSAFEPTR], init, size, typecheck.NodNil(), ir.NewBool(false))
+		ptr.MarkNonNil()
+		sh := ir.NewSliceHeaderExpr(base.Pos, t, ptr, length, length)
 
 		s := typecheck.Temp(t)
 		r := typecheck.Stmt(ir.NewAssignStmt(base.Pos, s, sh))
@@ -482,13 +476,10 @@ func walkMakeSliceCopy(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
 	// Replace make+copy with runtime.makeslicecopy.
 	// instantiate makeslicecopy(typ *byte, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointer
 	fn := typecheck.LookupRuntime("makeslicecopy")
-	s := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
-	s.Ptr = mkcall1(fn, types.Types[types.TUNSAFEPTR], init, reflectdata.TypePtr(t.Elem()), length, copylen, typecheck.Conv(copyptr, types.Types[types.TUNSAFEPTR]))
-	s.Ptr.MarkNonNil()
-	s.Len = length
-	s.Cap = length
-	s.SetType(t)
-	return walkExpr(typecheck.Expr(s), init)
+	ptr := mkcall1(fn, types.Types[types.TUNSAFEPTR], init, reflectdata.TypePtr(t.Elem()), length, copylen, typecheck.Conv(copyptr, types.Types[types.TUNSAFEPTR]))
+	ptr.MarkNonNil()
+	sh := ir.NewSliceHeaderExpr(base.Pos, t, ptr, length, length)
+	return walkExpr(typecheck.Expr(sh), init)
 }
 
 // walkNew walks an ONEW node.
-- 
GitLab


From 2c05ba4ae08317c6d0ad7418d5ecb0f971275d69 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Wed, 28 Apr 2021 23:07:38 -0700
Subject: [PATCH 1859/2400] runtime: top align tinyallocs in race mode

Top align allocations in tinyalloc buckets when in race mode.
This will make checkptr checks more reliable, because any code
that modifies a pointer past the end of the object will trigger
a checkptr error.

No test, because we need -race for this to actually kick in.  We could
add it to the race detector tests, but the race detector tests are all
geared towards race detector reports, not checkptr reports. Mucking
with parsing reports is more than a test is worth.

Fixes #38872

Change-Id: Ie56f0fbd1a9385539f6631fd1ac40c3de5600154
Reviewed-on: https://go-review.googlesource.com/c/go/+/315029
Trust: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/export_test.go |  2 ++
 src/runtime/malloc.go      | 19 ++++++++++++++++++-
 src/runtime/malloc_test.go |  6 ++++++
 3 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/src/runtime/export_test.go b/src/runtime/export_test.go
index f742225d51..a6fc1e4785 100644
--- a/src/runtime/export_test.go
+++ b/src/runtime/export_test.go
@@ -1267,3 +1267,5 @@ func GCTestIsReachable(ptrs ...unsafe.Pointer) (mask uint64) {
 func GCTestPointerClass(p unsafe.Pointer) string {
 	return gcTestPointerClass(p)
 }
+
+const Raceenabled = raceenabled
diff --git a/src/runtime/malloc.go b/src/runtime/malloc.go
index f2d2425f53..3db884f498 100644
--- a/src/runtime/malloc.go
+++ b/src/runtime/malloc.go
@@ -1047,7 +1047,8 @@ func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 			(*[2]uint64)(x)[1] = 0
 			// See if we need to replace the existing tiny block with the new one
 			// based on amount of remaining free space.
-			if size < c.tinyoffset || c.tiny == 0 {
+			if !raceenabled && (size < c.tinyoffset || c.tiny == 0) {
+				// Note: disabled when race detector is on, see comment near end of this function.
 				c.tiny = uintptr(x)
 				c.tinyoffset = size
 			}
@@ -1165,6 +1166,22 @@ func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 		}
 	}
 
+	if raceenabled && noscan && dataSize < maxTinySize {
+		// Pad tinysize allocations so they are aligned with the end
+		// of the tinyalloc region. This ensures that any arithmetic
+		// that goes off the top end of the object will be detectable
+		// by checkptr (issue 38872).
+		// Note that we disable tinyalloc when raceenabled for this to work.
+		// TODO: This padding is only performed when the race detector
+		// is enabled. It would be nice to enable it if any package
+		// was compiled with checkptr, but there's no easy way to
+		// detect that (especially at compile time).
+		// TODO: enable this padding for all allocations, not just
+		// tinyalloc ones. It's tricky because of pointer maps.
+		// Maybe just all noscan objects?
+		x = add(x, size-dataSize)
+	}
+
 	return x
 }
 
diff --git a/src/runtime/malloc_test.go b/src/runtime/malloc_test.go
index 4ba94d0494..e028554b23 100644
--- a/src/runtime/malloc_test.go
+++ b/src/runtime/malloc_test.go
@@ -154,6 +154,9 @@ func TestStringConcatenationAllocs(t *testing.T) {
 }
 
 func TestTinyAlloc(t *testing.T) {
+	if runtime.Raceenabled {
+		t.Skip("tinyalloc suppressed when running in race mode")
+	}
 	const N = 16
 	var v [N]unsafe.Pointer
 	for i := range v {
@@ -182,6 +185,9 @@ type obj12 struct {
 }
 
 func TestTinyAllocIssue37262(t *testing.T) {
+	if runtime.Raceenabled {
+		t.Skip("tinyalloc suppressed when running in race mode")
+	}
 	// Try to cause an alignment access fault
 	// by atomically accessing the first 64-bit
 	// value of a tiny-allocated object.
-- 
GitLab


From 6d95e5a4ff9f2ffa12ca225974d0ce45fd2504d4 Mon Sep 17 00:00:00 2001
From: Roger Peppe <rogpeppe@gmail.com>
Date: Thu, 11 Feb 2021 13:54:45 +0000
Subject: [PATCH 1860/2400] encoding/csv: add FieldPos method
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This enables a consumer of a CSV to find out the position
of a CSV field without implementing an intermediate buffer.
This is useful to produce good higher level error messages when
the CSV syntax is OK but the field values don't match expectations.

This also changes the existing semantics of the `ParseError.Column`
field to bring it in line with precedent elsewhere in the Go
standard library (notably go/token.Position) - the column is
now 1-based and indicates a byte count rather than a rune count,
and the error position reporting at the end of a last line without
a newline is now fixed.

This change has some impact on performance:

```
name                                     old time/op    new time/op    delta
Read-8                                     2.14µs ± 0%    2.15µs ± 0%    ~     (p=0.056 n=5+5)
ReadWithFieldsPerRecord-8                  2.15µs ± 2%    2.15µs ± 1%    ~     (p=0.151 n=5+5)
ReadWithoutFieldsPerRecord-8               2.15µs ± 0%    2.15µs ± 0%  +0.37%  (p=0.024 n=5+5)
ReadLargeFields-8                          3.55µs ± 2%    3.59µs ± 0%    ~     (p=0.206 n=5+5)
ReadReuseRecord-8                          1.18µs ± 1%    1.22µs ± 1%  +2.93%  (p=0.008 n=5+5)
ReadReuseRecordWithFieldsPerRecord-8       1.18µs ± 0%    1.21µs ± 0%  +2.54%  (p=0.008 n=5+5)
ReadReuseRecordWithoutFieldsPerRecord-8    1.18µs ± 0%    1.22µs ± 1%  +3.66%  (p=0.008 n=5+5)
ReadReuseRecordLargeFields-8               2.53µs ± 1%    2.57µs ± 1%  +1.70%  (p=0.008 n=5+5)
Write-8                                    1.02µs ± 1%    1.01µs ± 0%  -1.18%  (p=0.016 n=5+4)
```

Fixes #44221.

Change-Id: Id37c50fc396024eef406c5bad45380ecd414f5ea
Reviewed-on: https://go-review.googlesource.com/c/go/+/291290
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Paul Jolly <paul@myitcv.org.uk>
---
 src/encoding/csv/reader.go      |  71 ++-
 src/encoding/csv/reader_test.go | 909 ++++++++++++++++++--------------
 2 files changed, 585 insertions(+), 395 deletions(-)

diff --git a/src/encoding/csv/reader.go b/src/encoding/csv/reader.go
index c40aa506b0..f860f4f25f 100644
--- a/src/encoding/csv/reader.go
+++ b/src/encoding/csv/reader.go
@@ -66,7 +66,7 @@ import (
 type ParseError struct {
 	StartLine int   // Line where the record starts
 	Line      int   // Line where the error occurred
-	Column    int   // Column (rune index) where the error occurred
+	Column    int   // Column (1-based byte index) where the error occurred
 	Err       error // The actual error
 }
 
@@ -162,6 +162,10 @@ type Reader struct {
 	// The i'th field ends at offset fieldIndexes[i] in recordBuffer.
 	fieldIndexes []int
 
+	// fieldPositions is an index of field positions for the
+	// last record returned by Read.
+	fieldPositions []position
+
 	// lastRecord is a record cache and only used when ReuseRecord == true.
 	lastRecord []string
 }
@@ -192,6 +196,25 @@ func (r *Reader) Read() (record []string, err error) {
 	return record, err
 }
 
+// FieldPos returns the line and column corresponding to
+// the start of the field with the given index in the slice most recently
+// returned by Read. Numbering of lines and columns starts at 1;
+// columns are counted in bytes, not runes.
+//
+// If this is called with an out-of-bounds index, it panics.
+func (r *Reader) FieldPos(field int) (line, column int) {
+	if field < 0 || field >= len(r.fieldPositions) {
+		panic("out of range index passed to FieldPos")
+	}
+	p := &r.fieldPositions[field]
+	return p.line, p.col
+}
+
+// pos holds the position of a field in the current line.
+type position struct {
+	line, col int
+}
+
 // ReadAll reads all the remaining records from r.
 // Each record is a slice of fields.
 // A successful call returns err == nil, not err == io.EOF. Because ReadAll is
@@ -260,7 +283,7 @@ func (r *Reader) readRecord(dst []string) ([]string, error) {
 	}
 
 	// Read line (automatically skipping past empty lines and any comments).
-	var line, fullLine []byte
+	var line []byte
 	var errRead error
 	for errRead == nil {
 		line, errRead = r.readLine()
@@ -272,7 +295,6 @@ func (r *Reader) readRecord(dst []string) ([]string, error) {
 			line = nil
 			continue // Skip empty lines
 		}
-		fullLine = line
 		break
 	}
 	if errRead == io.EOF {
@@ -286,10 +308,20 @@ func (r *Reader) readRecord(dst []string) ([]string, error) {
 	recLine := r.numLine // Starting line for record
 	r.recordBuffer = r.recordBuffer[:0]
 	r.fieldIndexes = r.fieldIndexes[:0]
+	r.fieldPositions = r.fieldPositions[:0]
+	pos := position{line: r.numLine, col: 1}
 parseField:
 	for {
 		if r.TrimLeadingSpace {
-			line = bytes.TrimLeftFunc(line, unicode.IsSpace)
+			i := bytes.IndexFunc(line, func(r rune) bool {
+				return !unicode.IsSpace(r)
+			})
+			if i < 0 {
+				i = len(line)
+				pos.col -= lengthNL(line)
+			}
+			line = line[i:]
+			pos.col += i
 		}
 		if len(line) == 0 || line[0] != '"' {
 			// Non-quoted string field
@@ -303,48 +335,56 @@ parseField:
 			// Check to make sure a quote does not appear in field.
 			if !r.LazyQuotes {
 				if j := bytes.IndexByte(field, '"'); j >= 0 {
-					col := utf8.RuneCount(fullLine[:len(fullLine)-len(line[j:])])
+					col := pos.col + j
 					err = &ParseError{StartLine: recLine, Line: r.numLine, Column: col, Err: ErrBareQuote}
 					break parseField
 				}
 			}
 			r.recordBuffer = append(r.recordBuffer, field...)
 			r.fieldIndexes = append(r.fieldIndexes, len(r.recordBuffer))
+			r.fieldPositions = append(r.fieldPositions, pos)
 			if i >= 0 {
 				line = line[i+commaLen:]
+				pos.col += i + commaLen
 				continue parseField
 			}
 			break parseField
 		} else {
 			// Quoted string field
+			fieldPos := pos
 			line = line[quoteLen:]
+			pos.col += quoteLen
 			for {
 				i := bytes.IndexByte(line, '"')
 				if i >= 0 {
 					// Hit next quote.
 					r.recordBuffer = append(r.recordBuffer, line[:i]...)
 					line = line[i+quoteLen:]
+					pos.col += i + quoteLen
 					switch rn := nextRune(line); {
 					case rn == '"':
 						// `""` sequence (append quote).
 						r.recordBuffer = append(r.recordBuffer, '"')
 						line = line[quoteLen:]
+						pos.col += quoteLen
 					case rn == r.Comma:
 						// `",` sequence (end of field).
 						line = line[commaLen:]
+						pos.col += commaLen
 						r.fieldIndexes = append(r.fieldIndexes, len(r.recordBuffer))
+						r.fieldPositions = append(r.fieldPositions, fieldPos)
 						continue parseField
 					case lengthNL(line) == len(line):
 						// `"\n` sequence (end of line).
 						r.fieldIndexes = append(r.fieldIndexes, len(r.recordBuffer))
+						r.fieldPositions = append(r.fieldPositions, fieldPos)
 						break parseField
 					case r.LazyQuotes:
 						// `"` sequence (bare quote).
 						r.recordBuffer = append(r.recordBuffer, '"')
 					default:
 						// `"*` sequence (invalid non-escaped quote).
-						col := utf8.RuneCount(fullLine[:len(fullLine)-len(line)-quoteLen])
-						err = &ParseError{StartLine: recLine, Line: r.numLine, Column: col, Err: ErrQuote}
+						err = &ParseError{StartLine: recLine, Line: r.numLine, Column: pos.col - quoteLen, Err: ErrQuote}
 						break parseField
 					}
 				} else if len(line) > 0 {
@@ -353,19 +393,23 @@ parseField:
 					if errRead != nil {
 						break parseField
 					}
+					pos.col += len(line)
 					line, errRead = r.readLine()
+					if len(line) > 0 {
+						pos.line++
+						pos.col = 1
+					}
 					if errRead == io.EOF {
 						errRead = nil
 					}
-					fullLine = line
 				} else {
 					// Abrupt end of file (EOF or error).
 					if !r.LazyQuotes && errRead == nil {
-						col := utf8.RuneCount(fullLine)
-						err = &ParseError{StartLine: recLine, Line: r.numLine, Column: col, Err: ErrQuote}
+						err = &ParseError{StartLine: recLine, Line: pos.line, Column: pos.col, Err: ErrQuote}
 						break parseField
 					}
 					r.fieldIndexes = append(r.fieldIndexes, len(r.recordBuffer))
+					r.fieldPositions = append(r.fieldPositions, fieldPos)
 					break parseField
 				}
 			}
@@ -392,7 +436,12 @@ parseField:
 	// Check or update the expected fields per record.
 	if r.FieldsPerRecord > 0 {
 		if len(dst) != r.FieldsPerRecord && err == nil {
-			err = &ParseError{StartLine: recLine, Line: recLine, Err: ErrFieldCount}
+			err = &ParseError{
+				StartLine: recLine,
+				Line:      recLine,
+				Column:    1,
+				Err:       ErrFieldCount,
+			}
 		}
 	} else if r.FieldsPerRecord == 0 {
 		r.FieldsPerRecord = len(dst)
diff --git a/src/encoding/csv/reader_test.go b/src/encoding/csv/reader_test.go
index 5121791cb3..abe3fdfb39 100644
--- a/src/encoding/csv/reader_test.go
+++ b/src/encoding/csv/reader_test.go
@@ -5,6 +5,8 @@
 package csv
 
 import (
+	"errors"
+	"fmt"
 	"io"
 	"reflect"
 	"strings"
@@ -12,405 +14,544 @@ import (
 	"unicode/utf8"
 )
 
-func TestRead(t *testing.T) {
-	tests := []struct {
-		Name   string
-		Input  string
-		Output [][]string
-		Error  error
+type readTest struct {
+	Name      string
+	Input     string
+	Output    [][]string
+	Positions [][][2]int
+	Errors    []error
+
+	// These fields are copied into the Reader
+	Comma              rune
+	Comment            rune
+	UseFieldsPerRecord bool // false (default) means FieldsPerRecord is -1
+	FieldsPerRecord    int
+	LazyQuotes         bool
+	TrimLeadingSpace   bool
+	ReuseRecord        bool
+}
 
-		// These fields are copied into the Reader
-		Comma              rune
-		Comment            rune
-		UseFieldsPerRecord bool // false (default) means FieldsPerRecord is -1
-		FieldsPerRecord    int
-		LazyQuotes         bool
-		TrimLeadingSpace   bool
-		ReuseRecord        bool
-	}{{
-		Name:   "Simple",
-		Input:  "a,b,c\n",
-		Output: [][]string{{"a", "b", "c"}},
-	}, {
-		Name:   "CRLF",
-		Input:  "a,b\r\nc,d\r\n",
-		Output: [][]string{{"a", "b"}, {"c", "d"}},
-	}, {
-		Name:   "BareCR",
-		Input:  "a,b\rc,d\r\n",
-		Output: [][]string{{"a", "b\rc", "d"}},
-	}, {
-		Name: "RFC4180test",
-		Input: `#field1,field2,field3
-"aaa","bb
-b","ccc"
-"a,a","b""bb","ccc"
-zzz,yyy,xxx
+// In these tests, the §, ¶ and ∑ characters in readTest.Input are used to denote
+// the start of a field, a record boundary and the position of an error respectively.
+// They are removed before parsing and are used to verify the position
+// information reported by FieldPos.
+
+var readTests = []readTest{{
+	Name:   "Simple",
+	Input:  "§a,§b,§c\n",
+	Output: [][]string{{"a", "b", "c"}},
+}, {
+	Name:   "CRLF",
+	Input:  "§a,§b\r\n¶§c,§d\r\n",
+	Output: [][]string{{"a", "b"}, {"c", "d"}},
+}, {
+	Name:   "BareCR",
+	Input:  "§a,§b\rc,§d\r\n",
+	Output: [][]string{{"a", "b\rc", "d"}},
+}, {
+	Name: "RFC4180test",
+	Input: `§#field1,§field2,§field3
+¶§"aaa",§"bb
+b",§"ccc"
+¶§"a,a",§"b""bb",§"ccc"
+¶§zzz,§yyy,§xxx
 `,
-		Output: [][]string{
-			{"#field1", "field2", "field3"},
-			{"aaa", "bb\nb", "ccc"},
-			{"a,a", `b"bb`, "ccc"},
-			{"zzz", "yyy", "xxx"},
-		},
-		UseFieldsPerRecord: true,
-		FieldsPerRecord:    0,
-	}, {
-		Name:   "NoEOLTest",
-		Input:  "a,b,c",
-		Output: [][]string{{"a", "b", "c"}},
-	}, {
-		Name:   "Semicolon",
-		Input:  "a;b;c\n",
-		Output: [][]string{{"a", "b", "c"}},
-		Comma:  ';',
-	}, {
-		Name: "MultiLine",
-		Input: `"two
-line","one line","three
+	Output: [][]string{
+		{"#field1", "field2", "field3"},
+		{"aaa", "bb\nb", "ccc"},
+		{"a,a", `b"bb`, "ccc"},
+		{"zzz", "yyy", "xxx"},
+	},
+	UseFieldsPerRecord: true,
+	FieldsPerRecord:    0,
+}, {
+	Name:   "NoEOLTest",
+	Input:  "§a,§b,§c",
+	Output: [][]string{{"a", "b", "c"}},
+}, {
+	Name:   "Semicolon",
+	Input:  "§a;§b;§c\n",
+	Output: [][]string{{"a", "b", "c"}},
+	Comma:  ';',
+}, {
+	Name: "MultiLine",
+	Input: `§"two
+line",§"one line",§"three
 line
 field"`,
-		Output: [][]string{{"two\nline", "one line", "three\nline\nfield"}},
-	}, {
-		Name:  "BlankLine",
-		Input: "a,b,c\n\nd,e,f\n\n",
-		Output: [][]string{
-			{"a", "b", "c"},
-			{"d", "e", "f"},
-		},
-	}, {
-		Name:  "BlankLineFieldCount",
-		Input: "a,b,c\n\nd,e,f\n\n",
-		Output: [][]string{
-			{"a", "b", "c"},
-			{"d", "e", "f"},
-		},
-		UseFieldsPerRecord: true,
-		FieldsPerRecord:    0,
-	}, {
-		Name:             "TrimSpace",
-		Input:            " a,  b,   c\n",
-		Output:           [][]string{{"a", "b", "c"}},
-		TrimLeadingSpace: true,
-	}, {
-		Name:   "LeadingSpace",
-		Input:  " a,  b,   c\n",
-		Output: [][]string{{" a", "  b", "   c"}},
-	}, {
-		Name:    "Comment",
-		Input:   "#1,2,3\na,b,c\n#comment",
-		Output:  [][]string{{"a", "b", "c"}},
-		Comment: '#',
-	}, {
-		Name:   "NoComment",
-		Input:  "#1,2,3\na,b,c",
-		Output: [][]string{{"#1", "2", "3"}, {"a", "b", "c"}},
-	}, {
-		Name:       "LazyQuotes",
-		Input:      `a "word","1"2",a","b`,
-		Output:     [][]string{{`a "word"`, `1"2`, `a"`, `b`}},
-		LazyQuotes: true,
-	}, {
-		Name:       "BareQuotes",
-		Input:      `a "word","1"2",a"`,
-		Output:     [][]string{{`a "word"`, `1"2`, `a"`}},
-		LazyQuotes: true,
-	}, {
-		Name:       "BareDoubleQuotes",
-		Input:      `a""b,c`,
-		Output:     [][]string{{`a""b`, `c`}},
-		LazyQuotes: true,
-	}, {
-		Name:  "BadDoubleQuotes",
-		Input: `a""b,c`,
-		Error: &ParseError{StartLine: 1, Line: 1, Column: 1, Err: ErrBareQuote},
-	}, {
-		Name:             "TrimQuote",
-		Input:            ` "a"," b",c`,
-		Output:           [][]string{{"a", " b", "c"}},
-		TrimLeadingSpace: true,
-	}, {
-		Name:  "BadBareQuote",
-		Input: `a "word","b"`,
-		Error: &ParseError{StartLine: 1, Line: 1, Column: 2, Err: ErrBareQuote},
-	}, {
-		Name:  "BadTrailingQuote",
-		Input: `"a word",b"`,
-		Error: &ParseError{StartLine: 1, Line: 1, Column: 10, Err: ErrBareQuote},
-	}, {
-		Name:  "ExtraneousQuote",
-		Input: `"a "word","b"`,
-		Error: &ParseError{StartLine: 1, Line: 1, Column: 3, Err: ErrQuote},
-	}, {
-		Name:               "BadFieldCount",
-		Input:              "a,b,c\nd,e",
-		Error:              &ParseError{StartLine: 2, Line: 2, Err: ErrFieldCount},
-		UseFieldsPerRecord: true,
-		FieldsPerRecord:    0,
-	}, {
-		Name:               "BadFieldCount1",
-		Input:              `a,b,c`,
-		Error:              &ParseError{StartLine: 1, Line: 1, Err: ErrFieldCount},
-		UseFieldsPerRecord: true,
-		FieldsPerRecord:    2,
-	}, {
-		Name:   "FieldCount",
-		Input:  "a,b,c\nd,e",
-		Output: [][]string{{"a", "b", "c"}, {"d", "e"}},
-	}, {
-		Name:   "TrailingCommaEOF",
-		Input:  "a,b,c,",
-		Output: [][]string{{"a", "b", "c", ""}},
-	}, {
-		Name:   "TrailingCommaEOL",
-		Input:  "a,b,c,\n",
-		Output: [][]string{{"a", "b", "c", ""}},
-	}, {
-		Name:             "TrailingCommaSpaceEOF",
-		Input:            "a,b,c, ",
-		Output:           [][]string{{"a", "b", "c", ""}},
-		TrimLeadingSpace: true,
-	}, {
-		Name:             "TrailingCommaSpaceEOL",
-		Input:            "a,b,c, \n",
-		Output:           [][]string{{"a", "b", "c", ""}},
-		TrimLeadingSpace: true,
-	}, {
-		Name:             "TrailingCommaLine3",
-		Input:            "a,b,c\nd,e,f\ng,hi,",
-		Output:           [][]string{{"a", "b", "c"}, {"d", "e", "f"}, {"g", "hi", ""}},
-		TrimLeadingSpace: true,
-	}, {
-		Name:   "NotTrailingComma3",
-		Input:  "a,b,c, \n",
-		Output: [][]string{{"a", "b", "c", " "}},
-	}, {
-		Name: "CommaFieldTest",
-		Input: `x,y,z,w
-x,y,z,
-x,y,,
-x,,,
-,,,
-"x","y","z","w"
-"x","y","z",""
-"x","y","",""
-"x","","",""
-"","","",""
+	Output: [][]string{{"two\nline", "one line", "three\nline\nfield"}},
+}, {
+	Name:  "BlankLine",
+	Input: "§a,§b,§c\n\n¶§d,§e,§f\n\n",
+	Output: [][]string{
+		{"a", "b", "c"},
+		{"d", "e", "f"},
+	},
+}, {
+	Name:  "BlankLineFieldCount",
+	Input: "§a,§b,§c\n\n¶§d,§e,§f\n\n",
+	Output: [][]string{
+		{"a", "b", "c"},
+		{"d", "e", "f"},
+	},
+	UseFieldsPerRecord: true,
+	FieldsPerRecord:    0,
+}, {
+	Name:             "TrimSpace",
+	Input:            " §a,  §b,   §c\n",
+	Output:           [][]string{{"a", "b", "c"}},
+	TrimLeadingSpace: true,
+}, {
+	Name:   "LeadingSpace",
+	Input:  "§ a,§  b,§   c\n",
+	Output: [][]string{{" a", "  b", "   c"}},
+}, {
+	Name:    "Comment",
+	Input:   "#1,2,3\n§a,§b,§c\n#comment",
+	Output:  [][]string{{"a", "b", "c"}},
+	Comment: '#',
+}, {
+	Name:   "NoComment",
+	Input:  "§#1,§2,§3\n¶§a,§b,§c",
+	Output: [][]string{{"#1", "2", "3"}, {"a", "b", "c"}},
+}, {
+	Name:       "LazyQuotes",
+	Input:      `§a "word",§"1"2",§a",§"b`,
+	Output:     [][]string{{`a "word"`, `1"2`, `a"`, `b`}},
+	LazyQuotes: true,
+}, {
+	Name:       "BareQuotes",
+	Input:      `§a "word",§"1"2",§a"`,
+	Output:     [][]string{{`a "word"`, `1"2`, `a"`}},
+	LazyQuotes: true,
+}, {
+	Name:       "BareDoubleQuotes",
+	Input:      `§a""b,§c`,
+	Output:     [][]string{{`a""b`, `c`}},
+	LazyQuotes: true,
+}, {
+	Name:   "BadDoubleQuotes",
+	Input:  `§a∑""b,c`,
+	Errors: []error{&ParseError{Err: ErrBareQuote}},
+}, {
+	Name:             "TrimQuote",
+	Input:            ` §"a",§" b",§c`,
+	Output:           [][]string{{"a", " b", "c"}},
+	TrimLeadingSpace: true,
+}, {
+	Name:   "BadBareQuote",
+	Input:  `§a ∑"word","b"`,
+	Errors: []error{&ParseError{Err: ErrBareQuote}},
+}, {
+	Name:   "BadTrailingQuote",
+	Input:  `§"a word",b∑"`,
+	Errors: []error{&ParseError{Err: ErrBareQuote}},
+}, {
+	Name:   "ExtraneousQuote",
+	Input:  `§"a ∑"word","b"`,
+	Errors: []error{&ParseError{Err: ErrQuote}},
+}, {
+	Name:               "BadFieldCount",
+	Input:              "§a,§b,§c\n¶∑§d,§e",
+	Errors:             []error{nil, &ParseError{Err: ErrFieldCount}},
+	Output:             [][]string{{"a", "b", "c"}, {"d", "e"}},
+	UseFieldsPerRecord: true,
+	FieldsPerRecord:    0,
+}, {
+	Name:               "BadFieldCountMultiple",
+	Input:              "§a,§b,§c\n¶∑§d,§e\n¶∑§f",
+	Errors:             []error{nil, &ParseError{Err: ErrFieldCount}, &ParseError{Err: ErrFieldCount}},
+	Output:             [][]string{{"a", "b", "c"}, {"d", "e"}, {"f"}},
+	UseFieldsPerRecord: true,
+	FieldsPerRecord:    0,
+}, {
+	Name:               "BadFieldCount1",
+	Input:              `§∑a,§b,§c`,
+	Errors:             []error{&ParseError{Err: ErrFieldCount}},
+	Output:             [][]string{{"a", "b", "c"}},
+	UseFieldsPerRecord: true,
+	FieldsPerRecord:    2,
+}, {
+	Name:   "FieldCount",
+	Input:  "§a,§b,§c\n¶§d,§e",
+	Output: [][]string{{"a", "b", "c"}, {"d", "e"}},
+}, {
+	Name:   "TrailingCommaEOF",
+	Input:  "§a,§b,§c,§",
+	Output: [][]string{{"a", "b", "c", ""}},
+}, {
+	Name:   "TrailingCommaEOL",
+	Input:  "§a,§b,§c,§\n",
+	Output: [][]string{{"a", "b", "c", ""}},
+}, {
+	Name:             "TrailingCommaSpaceEOF",
+	Input:            "§a,§b,§c, §",
+	Output:           [][]string{{"a", "b", "c", ""}},
+	TrimLeadingSpace: true,
+}, {
+	Name:             "TrailingCommaSpaceEOL",
+	Input:            "§a,§b,§c, §\n",
+	Output:           [][]string{{"a", "b", "c", ""}},
+	TrimLeadingSpace: true,
+}, {
+	Name:             "TrailingCommaLine3",
+	Input:            "§a,§b,§c\n¶§d,§e,§f\n¶§g,§hi,§",
+	Output:           [][]string{{"a", "b", "c"}, {"d", "e", "f"}, {"g", "hi", ""}},
+	TrimLeadingSpace: true,
+}, {
+	Name:   "NotTrailingComma3",
+	Input:  "§a,§b,§c,§ \n",
+	Output: [][]string{{"a", "b", "c", " "}},
+}, {
+	Name: "CommaFieldTest",
+	Input: `§x,§y,§z,§w
+¶§x,§y,§z,§
+¶§x,§y,§,§
+¶§x,§,§,§
+¶§,§,§,§
+¶§"x",§"y",§"z",§"w"
+¶§"x",§"y",§"z",§""
+¶§"x",§"y",§"",§""
+¶§"x",§"",§"",§""
+¶§"",§"",§"",§""
 `,
-		Output: [][]string{
-			{"x", "y", "z", "w"},
-			{"x", "y", "z", ""},
-			{"x", "y", "", ""},
-			{"x", "", "", ""},
-			{"", "", "", ""},
-			{"x", "y", "z", "w"},
-			{"x", "y", "z", ""},
-			{"x", "y", "", ""},
-			{"x", "", "", ""},
-			{"", "", "", ""},
-		},
-	}, {
-		Name:  "TrailingCommaIneffective1",
-		Input: "a,b,\nc,d,e",
-		Output: [][]string{
-			{"a", "b", ""},
-			{"c", "d", "e"},
-		},
-		TrimLeadingSpace: true,
-	}, {
-		Name:  "ReadAllReuseRecord",
-		Input: "a,b\nc,d",
-		Output: [][]string{
-			{"a", "b"},
-			{"c", "d"},
-		},
-		ReuseRecord: true,
-	}, {
-		Name:  "StartLine1", // Issue 19019
-		Input: "a,\"b\nc\"d,e",
-		Error: &ParseError{StartLine: 1, Line: 2, Column: 1, Err: ErrQuote},
-	}, {
-		Name:  "StartLine2",
-		Input: "a,b\n\"d\n\n,e",
-		Error: &ParseError{StartLine: 2, Line: 5, Column: 0, Err: ErrQuote},
-	}, {
-		Name:  "CRLFInQuotedField", // Issue 21201
-		Input: "A,\"Hello\r\nHi\",B\r\n",
-		Output: [][]string{
-			{"A", "Hello\nHi", "B"},
-		},
-	}, {
-		Name:   "BinaryBlobField", // Issue 19410
-		Input:  "x09\x41\xb4\x1c,aktau",
-		Output: [][]string{{"x09A\xb4\x1c", "aktau"}},
-	}, {
-		Name:   "TrailingCR",
-		Input:  "field1,field2\r",
-		Output: [][]string{{"field1", "field2"}},
-	}, {
-		Name:   "QuotedTrailingCR",
-		Input:  "\"field\"\r",
-		Output: [][]string{{"field"}},
-	}, {
-		Name:  "QuotedTrailingCRCR",
-		Input: "\"field\"\r\r",
-		Error: &ParseError{StartLine: 1, Line: 1, Column: 6, Err: ErrQuote},
-	}, {
-		Name:   "FieldCR",
-		Input:  "field\rfield\r",
-		Output: [][]string{{"field\rfield"}},
-	}, {
-		Name:   "FieldCRCR",
-		Input:  "field\r\rfield\r\r",
-		Output: [][]string{{"field\r\rfield\r"}},
-	}, {
-		Name:   "FieldCRCRLF",
-		Input:  "field\r\r\nfield\r\r\n",
-		Output: [][]string{{"field\r"}, {"field\r"}},
-	}, {
-		Name:   "FieldCRCRLFCR",
-		Input:  "field\r\r\n\rfield\r\r\n\r",
-		Output: [][]string{{"field\r"}, {"\rfield\r"}},
-	}, {
-		Name:   "FieldCRCRLFCRCR",
-		Input:  "field\r\r\n\r\rfield\r\r\n\r\r",
-		Output: [][]string{{"field\r"}, {"\r\rfield\r"}, {"\r"}},
-	}, {
-		Name:  "MultiFieldCRCRLFCRCR",
-		Input: "field1,field2\r\r\n\r\rfield1,field2\r\r\n\r\r,",
-		Output: [][]string{
-			{"field1", "field2\r"},
-			{"\r\rfield1", "field2\r"},
-			{"\r\r", ""},
-		},
-	}, {
-		Name:             "NonASCIICommaAndComment",
-		Input:            "a£b,c£ \td,e\n€ comment\n",
-		Output:           [][]string{{"a", "b,c", "d,e"}},
-		TrimLeadingSpace: true,
-		Comma:            '£',
-		Comment:          '€',
-	}, {
-		Name:    "NonASCIICommaAndCommentWithQuotes",
-		Input:   "a€\"  b,\"€ c\nλ comment\n",
-		Output:  [][]string{{"a", "  b,", " c"}},
-		Comma:   '€',
-		Comment: 'λ',
-	}, {
-		// λ and θ start with the same byte.
-		// This tests that the parser doesn't confuse such characters.
-		Name:    "NonASCIICommaConfusion",
-		Input:   "\"abθcd\"λefθgh",
-		Output:  [][]string{{"abθcd", "efθgh"}},
-		Comma:   'λ',
-		Comment: '€',
-	}, {
-		Name:    "NonASCIICommentConfusion",
-		Input:   "λ\nλ\nθ\nλ\n",
-		Output:  [][]string{{"λ"}, {"λ"}, {"λ"}},
-		Comment: 'θ',
-	}, {
-		Name:   "QuotedFieldMultipleLF",
-		Input:  "\"\n\n\n\n\"",
-		Output: [][]string{{"\n\n\n\n"}},
-	}, {
-		Name:  "MultipleCRLF",
-		Input: "\r\n\r\n\r\n\r\n",
-	}, {
-		// The implementation may read each line in several chunks if it doesn't fit entirely
-		// in the read buffer, so we should test the code to handle that condition.
-		Name:    "HugeLines",
-		Input:   strings.Repeat("#ignore\n", 10000) + strings.Repeat("@", 5000) + "," + strings.Repeat("*", 5000),
-		Output:  [][]string{{strings.Repeat("@", 5000), strings.Repeat("*", 5000)}},
-		Comment: '#',
-	}, {
-		Name:  "QuoteWithTrailingCRLF",
-		Input: "\"foo\"bar\"\r\n",
-		Error: &ParseError{StartLine: 1, Line: 1, Column: 4, Err: ErrQuote},
-	}, {
-		Name:       "LazyQuoteWithTrailingCRLF",
-		Input:      "\"foo\"bar\"\r\n",
-		Output:     [][]string{{`foo"bar`}},
-		LazyQuotes: true,
-	}, {
-		Name:   "DoubleQuoteWithTrailingCRLF",
-		Input:  "\"foo\"\"bar\"\r\n",
-		Output: [][]string{{`foo"bar`}},
-	}, {
-		Name:   "EvenQuotes",
-		Input:  `""""""""`,
-		Output: [][]string{{`"""`}},
-	}, {
-		Name:  "OddQuotes",
-		Input: `"""""""`,
-		Error: &ParseError{StartLine: 1, Line: 1, Column: 7, Err: ErrQuote},
-	}, {
-		Name:       "LazyOddQuotes",
-		Input:      `"""""""`,
-		Output:     [][]string{{`"""`}},
-		LazyQuotes: true,
-	}, {
-		Name:  "BadComma1",
-		Comma: '\n',
-		Error: errInvalidDelim,
-	}, {
-		Name:  "BadComma2",
-		Comma: '\r',
-		Error: errInvalidDelim,
-	}, {
-		Name:  "BadComma3",
-		Comma: '"',
-		Error: errInvalidDelim,
-	}, {
-		Name:  "BadComma4",
-		Comma: utf8.RuneError,
-		Error: errInvalidDelim,
-	}, {
-		Name:    "BadComment1",
-		Comment: '\n',
-		Error:   errInvalidDelim,
-	}, {
-		Name:    "BadComment2",
-		Comment: '\r',
-		Error:   errInvalidDelim,
-	}, {
-		Name:    "BadComment3",
-		Comment: utf8.RuneError,
-		Error:   errInvalidDelim,
-	}, {
-		Name:    "BadCommaComment",
-		Comma:   'X',
-		Comment: 'X',
-		Error:   errInvalidDelim,
-	}}
+	Output: [][]string{
+		{"x", "y", "z", "w"},
+		{"x", "y", "z", ""},
+		{"x", "y", "", ""},
+		{"x", "", "", ""},
+		{"", "", "", ""},
+		{"x", "y", "z", "w"},
+		{"x", "y", "z", ""},
+		{"x", "y", "", ""},
+		{"x", "", "", ""},
+		{"", "", "", ""},
+	},
+}, {
+	Name:  "TrailingCommaIneffective1",
+	Input: "§a,§b,§\n¶§c,§d,§e",
+	Output: [][]string{
+		{"a", "b", ""},
+		{"c", "d", "e"},
+	},
+	TrimLeadingSpace: true,
+}, {
+	Name:  "ReadAllReuseRecord",
+	Input: "§a,§b\n¶§c,§d",
+	Output: [][]string{
+		{"a", "b"},
+		{"c", "d"},
+	},
+	ReuseRecord: true,
+}, {
+	Name:   "StartLine1", // Issue 19019
+	Input:  "§a,\"b\nc∑\"d,e",
+	Errors: []error{&ParseError{Err: ErrQuote}},
+}, {
+	Name:   "StartLine2",
+	Input:  "§a,§b\n¶§\"d\n\n,e∑",
+	Errors: []error{nil, &ParseError{Err: ErrQuote}},
+	Output: [][]string{{"a", "b"}},
+}, {
+	Name:  "CRLFInQuotedField", // Issue 21201
+	Input: "§A,§\"Hello\r\nHi\",§B\r\n",
+	Output: [][]string{
+		{"A", "Hello\nHi", "B"},
+	},
+}, {
+	Name:   "BinaryBlobField", // Issue 19410
+	Input:  "§x09\x41\xb4\x1c,§aktau",
+	Output: [][]string{{"x09A\xb4\x1c", "aktau"}},
+}, {
+	Name:   "TrailingCR",
+	Input:  "§field1,§field2\r",
+	Output: [][]string{{"field1", "field2"}},
+}, {
+	Name:   "QuotedTrailingCR",
+	Input:  "§\"field\"\r",
+	Output: [][]string{{"field"}},
+}, {
+	Name:   "QuotedTrailingCRCR",
+	Input:  "§\"field∑\"\r\r",
+	Errors: []error{&ParseError{Err: ErrQuote}},
+}, {
+	Name:   "FieldCR",
+	Input:  "§field\rfield\r",
+	Output: [][]string{{"field\rfield"}},
+}, {
+	Name:   "FieldCRCR",
+	Input:  "§field\r\rfield\r\r",
+	Output: [][]string{{"field\r\rfield\r"}},
+}, {
+	Name:   "FieldCRCRLF",
+	Input:  "§field\r\r\n¶§field\r\r\n",
+	Output: [][]string{{"field\r"}, {"field\r"}},
+}, {
+	Name:   "FieldCRCRLFCR",
+	Input:  "§field\r\r\n¶§\rfield\r\r\n\r",
+	Output: [][]string{{"field\r"}, {"\rfield\r"}},
+}, {
+	Name:   "FieldCRCRLFCRCR",
+	Input:  "§field\r\r\n¶§\r\rfield\r\r\n¶§\r\r",
+	Output: [][]string{{"field\r"}, {"\r\rfield\r"}, {"\r"}},
+}, {
+	Name:  "MultiFieldCRCRLFCRCR",
+	Input: "§field1,§field2\r\r\n¶§\r\rfield1,§field2\r\r\n¶§\r\r,§",
+	Output: [][]string{
+		{"field1", "field2\r"},
+		{"\r\rfield1", "field2\r"},
+		{"\r\r", ""},
+	},
+}, {
+	Name:             "NonASCIICommaAndComment",
+	Input:            "§a£§b,c£ \t§d,e\n€ comment\n",
+	Output:           [][]string{{"a", "b,c", "d,e"}},
+	TrimLeadingSpace: true,
+	Comma:            '£',
+	Comment:          '€',
+}, {
+	Name:    "NonASCIICommaAndCommentWithQuotes",
+	Input:   "§a€§\"  b,\"€§ c\nλ comment\n",
+	Output:  [][]string{{"a", "  b,", " c"}},
+	Comma:   '€',
+	Comment: 'λ',
+}, {
+	// λ and θ start with the same byte.
+	// This tests that the parser doesn't confuse such characters.
+	Name:    "NonASCIICommaConfusion",
+	Input:   "§\"abθcd\"λ§efθgh",
+	Output:  [][]string{{"abθcd", "efθgh"}},
+	Comma:   'λ',
+	Comment: '€',
+}, {
+	Name:    "NonASCIICommentConfusion",
+	Input:   "§λ\n¶§λ\nθ\n¶§λ\n",
+	Output:  [][]string{{"λ"}, {"λ"}, {"λ"}},
+	Comment: 'θ',
+}, {
+	Name:   "QuotedFieldMultipleLF",
+	Input:  "§\"\n\n\n\n\"",
+	Output: [][]string{{"\n\n\n\n"}},
+}, {
+	Name:  "MultipleCRLF",
+	Input: "\r\n\r\n\r\n\r\n",
+}, {
+	// The implementation may read each line in several chunks if it doesn't fit entirely
+	// in the read buffer, so we should test the code to handle that condition.
+	Name:    "HugeLines",
+	Input:   strings.Repeat("#ignore\n", 10000) + "§" + strings.Repeat("@", 5000) + ",§" + strings.Repeat("*", 5000),
+	Output:  [][]string{{strings.Repeat("@", 5000), strings.Repeat("*", 5000)}},
+	Comment: '#',
+}, {
+	Name:   "QuoteWithTrailingCRLF",
+	Input:  "§\"foo∑\"bar\"\r\n",
+	Errors: []error{&ParseError{Err: ErrQuote}},
+}, {
+	Name:       "LazyQuoteWithTrailingCRLF",
+	Input:      "§\"foo\"bar\"\r\n",
+	Output:     [][]string{{`foo"bar`}},
+	LazyQuotes: true,
+}, {
+	Name:   "DoubleQuoteWithTrailingCRLF",
+	Input:  "§\"foo\"\"bar\"\r\n",
+	Output: [][]string{{`foo"bar`}},
+}, {
+	Name:   "EvenQuotes",
+	Input:  `§""""""""`,
+	Output: [][]string{{`"""`}},
+}, {
+	Name:   "OddQuotes",
+	Input:  `§"""""""∑`,
+	Errors: []error{&ParseError{Err: ErrQuote}},
+}, {
+	Name:       "LazyOddQuotes",
+	Input:      `§"""""""`,
+	Output:     [][]string{{`"""`}},
+	LazyQuotes: true,
+}, {
+	Name:   "BadComma1",
+	Comma:  '\n',
+	Errors: []error{errInvalidDelim},
+}, {
+	Name:   "BadComma2",
+	Comma:  '\r',
+	Errors: []error{errInvalidDelim},
+}, {
+	Name:   "BadComma3",
+	Comma:  '"',
+	Errors: []error{errInvalidDelim},
+}, {
+	Name:   "BadComma4",
+	Comma:  utf8.RuneError,
+	Errors: []error{errInvalidDelim},
+}, {
+	Name:    "BadComment1",
+	Comment: '\n',
+	Errors:  []error{errInvalidDelim},
+}, {
+	Name:    "BadComment2",
+	Comment: '\r',
+	Errors:  []error{errInvalidDelim},
+}, {
+	Name:    "BadComment3",
+	Comment: utf8.RuneError,
+	Errors:  []error{errInvalidDelim},
+}, {
+	Name:    "BadCommaComment",
+	Comma:   'X',
+	Comment: 'X',
+	Errors:  []error{errInvalidDelim},
+}}
 
-	for _, tt := range tests {
-		t.Run(tt.Name, func(t *testing.T) {
-			r := NewReader(strings.NewReader(tt.Input))
+func TestRead(t *testing.T) {
+	newReader := func(tt readTest) (*Reader, [][][2]int, map[int][2]int) {
+		positions, errPositions, input := makePositions(tt.Input)
+		r := NewReader(strings.NewReader(input))
 
-			if tt.Comma != 0 {
-				r.Comma = tt.Comma
-			}
-			r.Comment = tt.Comment
-			if tt.UseFieldsPerRecord {
-				r.FieldsPerRecord = tt.FieldsPerRecord
+		if tt.Comma != 0 {
+			r.Comma = tt.Comma
+		}
+		r.Comment = tt.Comment
+		if tt.UseFieldsPerRecord {
+			r.FieldsPerRecord = tt.FieldsPerRecord
+		} else {
+			r.FieldsPerRecord = -1
+		}
+		r.LazyQuotes = tt.LazyQuotes
+		r.TrimLeadingSpace = tt.TrimLeadingSpace
+		r.ReuseRecord = tt.ReuseRecord
+		return r, positions, errPositions
+	}
+
+	for _, tt := range readTests {
+		t.Run(tt.Name, func(t *testing.T) {
+			r, positions, errPositions := newReader(tt)
+			out, err := r.ReadAll()
+			if wantErr := firstError(tt.Errors, positions, errPositions); wantErr != nil {
+				if !reflect.DeepEqual(err, wantErr) {
+					t.Fatalf("ReadAll() error mismatch:\ngot  %v (%#v)\nwant %v (%#v)", err, err, wantErr, wantErr)
+				}
+				if out != nil {
+					t.Fatalf("ReadAll() output:\ngot  %q\nwant nil", out)
+				}
 			} else {
-				r.FieldsPerRecord = -1
+				if err != nil {
+					t.Fatalf("unexpected Readall() error: %v", err)
+				}
+				if !reflect.DeepEqual(out, tt.Output) {
+					t.Fatalf("ReadAll() output:\ngot  %q\nwant %q", out, tt.Output)
+				}
 			}
-			r.LazyQuotes = tt.LazyQuotes
-			r.TrimLeadingSpace = tt.TrimLeadingSpace
-			r.ReuseRecord = tt.ReuseRecord
 
-			out, err := r.ReadAll()
-			if !reflect.DeepEqual(err, tt.Error) {
-				t.Errorf("ReadAll() error:\ngot  %v\nwant %v", err, tt.Error)
-			} else if !reflect.DeepEqual(out, tt.Output) {
-				t.Errorf("ReadAll() output:\ngot  %q\nwant %q", out, tt.Output)
+			// Check field and error positions.
+			r, _, _ = newReader(tt)
+			for recNum := 0; ; recNum++ {
+				rec, err := r.Read()
+				var wantErr error
+				if recNum < len(tt.Errors) && tt.Errors[recNum] != nil {
+					wantErr = errorWithPosition(tt.Errors[recNum], recNum, positions, errPositions)
+				} else if recNum >= len(tt.Output) {
+					wantErr = io.EOF
+				}
+				if !reflect.DeepEqual(err, wantErr) {
+					t.Fatalf("Read() error at record %d:\ngot %v (%#v)\nwant %v (%#v)", recNum, err, err, wantErr, wantErr)
+				}
+				// ErrFieldCount is explicitly non-fatal.
+				if err != nil && !errors.Is(err, ErrFieldCount) {
+					if recNum < len(tt.Output) {
+						t.Fatalf("need more records; got %d want %d", recNum, len(tt.Output))
+					}
+					break
+				}
+				if got, want := rec, tt.Output[recNum]; !reflect.DeepEqual(got, want) {
+					t.Errorf("Read vs ReadAll mismatch;\ngot %q\nwant %q", got, want)
+				}
+				pos := positions[recNum]
+				if len(pos) != len(rec) {
+					t.Fatalf("mismatched position length at record %d", recNum)
+				}
+				for i := range rec {
+					line, col := r.FieldPos(i)
+					if got, want := [2]int{line, col}, pos[i]; got != want {
+						t.Errorf("position mismatch at record %d, field %d;\ngot %v\nwant %v", recNum, i, got, want)
+					}
+				}
 			}
 		})
 	}
 }
 
+// firstError returns the first non-nil error in errs,
+// with the position adjusted according to the error's
+// index inside positions.
+func firstError(errs []error, positions [][][2]int, errPositions map[int][2]int) error {
+	for i, err := range errs {
+		if err != nil {
+			return errorWithPosition(err, i, positions, errPositions)
+		}
+	}
+	return nil
+}
+
+func errorWithPosition(err error, recNum int, positions [][][2]int, errPositions map[int][2]int) error {
+	parseErr, ok := err.(*ParseError)
+	if !ok {
+		return err
+	}
+	if recNum >= len(positions) {
+		panic(fmt.Errorf("no positions found for error at record %d", recNum))
+	}
+	errPos, ok := errPositions[recNum]
+	if !ok {
+		panic(fmt.Errorf("no error position found for error at record %d", recNum))
+	}
+	parseErr1 := *parseErr
+	parseErr1.StartLine = positions[recNum][0][0]
+	parseErr1.Line = errPos[0]
+	parseErr1.Column = errPos[1]
+	return &parseErr1
+}
+
+// makePositions returns the expected field positions of all
+// the fields in text, the positions of any errors, and the text with the position markers
+// removed.
+//
+// The start of each field is marked with a § symbol;
+// CSV lines are separated by ¶ symbols;
+// Error positions are marked with ∑ symbols.
+func makePositions(text string) ([][][2]int, map[int][2]int, string) {
+	buf := make([]byte, 0, len(text))
+	var positions [][][2]int
+	errPositions := make(map[int][2]int)
+	line, col := 1, 1
+	recNum := 0
+
+	for len(text) > 0 {
+		r, size := utf8.DecodeRuneInString(text)
+		switch r {
+		case '\n':
+			line++
+			col = 1
+			buf = append(buf, '\n')
+		case '§':
+			if len(positions) == 0 {
+				positions = append(positions, [][2]int{})
+			}
+			positions[len(positions)-1] = append(positions[len(positions)-1], [2]int{line, col})
+		case '¶':
+			positions = append(positions, [][2]int{})
+			recNum++
+		case '∑':
+			errPositions[recNum] = [2]int{line, col}
+		default:
+			buf = append(buf, text[:size]...)
+			col += size
+		}
+		text = text[size:]
+	}
+	return positions, errPositions, string(buf)
+}
+
 // nTimes is an io.Reader which yields the string s n times.
 type nTimes struct {
 	s   string
-- 
GitLab


From 87e4dcd446df2ab1985ef61ce15da329493248a1 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Mon, 19 Apr 2021 13:51:53 -0700
Subject: [PATCH 1861/2400] archive/zip: only return directory once via
 io/fs.FS

While we're here fix the ModTime value for directories.

Fixes #43872
Fixes #45345

Change-Id: I155e6517713ef6a9482b9431f1167a44337c6ad2
Reviewed-on: https://go-review.googlesource.com/c/go/+/311530
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
---
 src/archive/zip/reader.go           |  54 +++++++++++++++++++--------
 src/archive/zip/reader_test.go      |  56 ++++++++++++++++++++++++++--
 src/archive/zip/testdata/subdir.zip | Bin 0 -> 428 bytes
 3 files changed, 92 insertions(+), 18 deletions(-)
 create mode 100644 src/archive/zip/testdata/subdir.zip

diff --git a/src/archive/zip/reader.go b/src/archive/zip/reader.go
index c288ad965b..18f9833db0 100644
--- a/src/archive/zip/reader.go
+++ b/src/archive/zip/reader.go
@@ -628,10 +628,11 @@ func (b *readBuf) sub(n int) readBuf {
 }
 
 // A fileListEntry is a File and its ename.
-// If file == nil, the fileListEntry describes a directory, without metadata.
+// If file == nil, the fileListEntry describes a directory without metadata.
 type fileListEntry struct {
-	name string
-	file *File // nil for directories
+	name  string
+	file  *File
+	isDir bool
 }
 
 type fileInfoDirEntry interface {
@@ -640,20 +641,26 @@ type fileInfoDirEntry interface {
 }
 
 func (e *fileListEntry) stat() fileInfoDirEntry {
-	if e.file != nil {
+	if !e.isDir {
 		return headerFileInfo{&e.file.FileHeader}
 	}
 	return e
 }
 
 // Only used for directories.
-func (f *fileListEntry) Name() string       { _, elem, _ := split(f.name); return elem }
-func (f *fileListEntry) Size() int64        { return 0 }
-func (f *fileListEntry) ModTime() time.Time { return time.Time{} }
-func (f *fileListEntry) Mode() fs.FileMode  { return fs.ModeDir | 0555 }
-func (f *fileListEntry) Type() fs.FileMode  { return fs.ModeDir }
-func (f *fileListEntry) IsDir() bool        { return true }
-func (f *fileListEntry) Sys() interface{}   { return nil }
+func (f *fileListEntry) Name() string      { _, elem, _ := split(f.name); return elem }
+func (f *fileListEntry) Size() int64       { return 0 }
+func (f *fileListEntry) Mode() fs.FileMode { return fs.ModeDir | 0555 }
+func (f *fileListEntry) Type() fs.FileMode { return fs.ModeDir }
+func (f *fileListEntry) IsDir() bool       { return true }
+func (f *fileListEntry) Sys() interface{}  { return nil }
+
+func (f *fileListEntry) ModTime() time.Time {
+	if f.file == nil {
+		return time.Time{}
+	}
+	return f.file.FileHeader.Modified.UTC()
+}
 
 func (f *fileListEntry) Info() (fs.FileInfo, error) { return f, nil }
 
@@ -673,15 +680,32 @@ func toValidName(name string) string {
 func (r *Reader) initFileList() {
 	r.fileListOnce.Do(func() {
 		dirs := make(map[string]bool)
+		knownDirs := make(map[string]bool)
 		for _, file := range r.File {
+			isDir := len(file.Name) > 0 && file.Name[len(file.Name)-1] == '/'
 			name := toValidName(file.Name)
 			for dir := path.Dir(name); dir != "."; dir = path.Dir(dir) {
 				dirs[dir] = true
 			}
-			r.fileList = append(r.fileList, fileListEntry{name, file})
+			entry := fileListEntry{
+				name:  name,
+				file:  file,
+				isDir: isDir,
+			}
+			r.fileList = append(r.fileList, entry)
+			if isDir {
+				knownDirs[name] = true
+			}
 		}
 		for dir := range dirs {
-			r.fileList = append(r.fileList, fileListEntry{dir + "/", nil})
+			if !knownDirs[dir] {
+				entry := fileListEntry{
+					name:  dir,
+					file:  nil,
+					isDir: true,
+				}
+				r.fileList = append(r.fileList, entry)
+			}
 		}
 
 		sort.Slice(r.fileList, func(i, j int) bool { return fileEntryLess(r.fileList[i].name, r.fileList[j].name) })
@@ -705,7 +729,7 @@ func (r *Reader) Open(name string) (fs.File, error) {
 	if e == nil || !fs.ValidPath(name) {
 		return nil, &fs.PathError{Op: "open", Path: name, Err: fs.ErrNotExist}
 	}
-	if e.file == nil || strings.HasSuffix(e.file.Name, "/") {
+	if e.isDir {
 		return &openDir{e, r.openReadDir(name), 0}, nil
 	}
 	rc, err := e.file.Open()
@@ -730,7 +754,7 @@ func split(name string) (dir, elem string, isDir bool) {
 	return name[:i], name[i+1:], isDir
 }
 
-var dotFile = &fileListEntry{name: "./"}
+var dotFile = &fileListEntry{name: "./", isDir: true}
 
 func (r *Reader) openLookup(name string) *fileListEntry {
 	if name == "." {
diff --git a/src/archive/zip/reader_test.go b/src/archive/zip/reader_test.go
index fbaf9d4388..6ee62ef997 100644
--- a/src/archive/zip/reader_test.go
+++ b/src/archive/zip/reader_test.go
@@ -1073,12 +1073,62 @@ func TestIssue12449(t *testing.T) {
 }
 
 func TestFS(t *testing.T) {
-	z, err := OpenReader("testdata/unix.zip")
+	for _, test := range []struct {
+		file string
+		want []string
+	}{
+		{
+			"testdata/unix.zip",
+			[]string{"hello", "dir/bar", "readonly"},
+		},
+		{
+			"testdata/subdir.zip",
+			[]string{"a/b/c"},
+		},
+	} {
+		t.Run(test.file, func(t *testing.T) {
+			t.Parallel()
+			z, err := OpenReader(test.file)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer z.Close()
+			if err := fstest.TestFS(z, test.want...); err != nil {
+				t.Error(err)
+			}
+		})
+	}
+}
+
+func TestFSModTime(t *testing.T) {
+	t.Parallel()
+	z, err := OpenReader("testdata/subdir.zip")
 	if err != nil {
 		t.Fatal(err)
 	}
-	if err := fstest.TestFS(z, "hello", "dir/bar", "dir/empty", "readonly"); err != nil {
-		t.Fatal(err)
+	defer z.Close()
+
+	for _, test := range []struct {
+		name string
+		want time.Time
+	}{
+		{
+			"a",
+			time.Date(2021, 4, 19, 12, 29, 56, 0, timeZone(-7*time.Hour)).UTC(),
+		},
+		{
+			"a/b/c",
+			time.Date(2021, 4, 19, 12, 29, 59, 0, timeZone(-7*time.Hour)).UTC(),
+		},
+	} {
+		fi, err := fs.Stat(z, test.name)
+		if err != nil {
+			t.Errorf("%s: %v", test.name, err)
+			continue
+		}
+		if got := fi.ModTime(); !got.Equal(test.want) {
+			t.Errorf("%s: got modtime %v, want %v", test.name, got, test.want)
+		}
 	}
 }
 
diff --git a/src/archive/zip/testdata/subdir.zip b/src/archive/zip/testdata/subdir.zip
new file mode 100644
index 0000000000000000000000000000000000000000..324d06b48d19e59fa5e5875bf006bdc31c097090
GIT binary patch
literal 428
zcmWIWW@h1H0D(QplY>As3^OsvFeK`ShHx@4o7}2RSbVECp|paVfssYTm4SgJIG&LK
zq4xlqUKX(4B#3TvQgyRJbti)@2Wbak49gjr<d|_eT>|P00frZjASTEotPqdjF$dEd
z$mZBEFfb(QgFMB`z)ZkJ=q9l;z)WIbSkPDnH7PkX1eZ~)Y#?VdGcYsUWnf^~3F0sS
E00PxO-v9sr

literal 0
HcmV?d00001

-- 
GitLab


From 7b32830f58b7f33b51af0370cfd42ba561c3ca9e Mon Sep 17 00:00:00 2001
From: Roland Shoemaker <roland@golang.org>
Date: Thu, 29 Apr 2021 10:11:56 -0700
Subject: [PATCH 1862/2400] crypto/elliptic: store P-256 precomputed basepoint
 table in source

Store the precomputed P-256 basepoint table in source rather than
computing it at runtime, saving ~88kB from the heap. The flip side
is that this increases binary sizes by ~77kB.

Fixes #44992

Change-Id: Ia5421eae87b41522b0d8cecba051cba1d2ed73db
Reviewed-on: https://go-review.googlesource.com/c/go/+/315189
Run-TryBot: Roland Shoemaker <roland@golang.org>
Trust: Roland Shoemaker <roland@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
---
 src/crypto/elliptic/p256_asm.go            |   51 +-
 src/crypto/elliptic/p256_asm_table.go      | 1473 ++++++++++++++++++++
 src/crypto/elliptic/p256_asm_table_test.go |   59 +
 3 files changed, 1533 insertions(+), 50 deletions(-)
 create mode 100644 src/crypto/elliptic/p256_asm_table.go
 create mode 100644 src/crypto/elliptic/p256_asm_table_test.go

diff --git a/src/crypto/elliptic/p256_asm.go b/src/crypto/elliptic/p256_asm.go
index c405718b5e..08dbd2ea54 100644
--- a/src/crypto/elliptic/p256_asm.go
+++ b/src/crypto/elliptic/p256_asm.go
@@ -17,7 +17,6 @@ package elliptic
 
 import (
 	"math/big"
-	"sync"
 )
 
 type (
@@ -31,9 +30,7 @@ type (
 )
 
 var (
-	p256            p256Curve
-	p256Precomputed *[43][32 * 8]uint64
-	precomputeOnce  sync.Once
+	p256 p256Curve
 )
 
 func initP256() {
@@ -412,53 +409,7 @@ func boothW6(in uint) (int, int) {
 	return int(d), int(s & 1)
 }
 
-func initTable() {
-	p256Precomputed = new([43][32 * 8]uint64)
-
-	basePoint := []uint64{
-		0x79e730d418a9143c, 0x75ba95fc5fedb601, 0x79fb732b77622510, 0x18905f76a53755c6,
-		0xddf25357ce95560a, 0x8b4ab8e4ba19e45c, 0xd2e88688dd21f325, 0x8571ff1825885d85,
-		0x0000000000000001, 0xffffffff00000000, 0xffffffffffffffff, 0x00000000fffffffe,
-	}
-	t1 := make([]uint64, 12)
-	t2 := make([]uint64, 12)
-	copy(t2, basePoint)
-
-	zInv := make([]uint64, 4)
-	zInvSq := make([]uint64, 4)
-	for j := 0; j < 32; j++ {
-		copy(t1, t2)
-		for i := 0; i < 43; i++ {
-			// The window size is 6 so we need to double 6 times.
-			if i != 0 {
-				for k := 0; k < 6; k++ {
-					p256PointDoubleAsm(t1, t1)
-				}
-			}
-			// Convert the point to affine form. (Its values are
-			// still in Montgomery form however.)
-			p256Inverse(zInv, t1[8:12])
-			p256Sqr(zInvSq, zInv, 1)
-			p256Mul(zInv, zInv, zInvSq)
-
-			p256Mul(t1[:4], t1[:4], zInvSq)
-			p256Mul(t1[4:8], t1[4:8], zInv)
-
-			copy(t1[8:12], basePoint[8:12])
-			// Update the table entry
-			copy(p256Precomputed[i][j*8:], t1[:8])
-		}
-		if j == 0 {
-			p256PointDoubleAsm(t2, basePoint)
-		} else {
-			p256PointAddAsm(t2, t2, basePoint)
-		}
-	}
-}
-
 func (p *p256Point) p256BaseMult(scalar []uint64) {
-	precomputeOnce.Do(initTable)
-
 	wvalue := (scalar[0] << 1) & 0x7f
 	sel, sign := boothW6(uint(wvalue))
 	p256SelectBase(p.xyz[0:8], p256Precomputed[0][0:], sel)
diff --git a/src/crypto/elliptic/p256_asm_table.go b/src/crypto/elliptic/p256_asm_table.go
new file mode 100644
index 0000000000..16a4b4f224
--- /dev/null
+++ b/src/crypto/elliptic/p256_asm_table.go
@@ -0,0 +1,1473 @@
+// Copyright 2021 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.
+
+//go:build amd64 || arm64
+// +build amd64 arm64
+
+package elliptic
+
+var p256Precomputed = &[43][32 * 8]uint64{
+	{
+		8784043285714375740, 8483257759279461889, 8789745728267363600, 1770019616739251654, 15992936863339206154, 10037038012062884956, 15197544864945402661, 9615747158586711429,
+		9583737883674400333, 12279877754802111101, 8296198976379850969, 17778859909846088251, 3401986641240187301, 1525831644595056632, 1849003687033449918, 8702493044913179195,
+		18423170064697770279, 12693387071620743675, 7398701556189346968, 2779682216903406718, 12703629940499916779, 6358598532389273114, 8683512038509439374, 15415938252666293255,
+		8408419572923862476, 5066733120953500019, 926242532005776114, 6301489109130024811, 3285079390283344806, 1685054835664548935, 7740622190510199342, 9561507292862134371,
+		13698695174800826869, 10442832251048252285, 10672604962207744524, 14485711676978308040, 16947216143812808464, 8342189264337602603, 3837253281927274344, 8331789856935110934,
+		4627808394696681034, 6174000022702321214, 15351247319787348909, 1371147458593240691, 10651965436787680331, 2998319090323362997, 17592419471314886417, 11874181791118522207,
+		524165018444839759, 3157588572894920951, 17599692088379947784, 1421537803477597699, 2902517390503550285, 7440776657136679901, 17263207614729765269, 16928425260420958311,
+		2878166099891431311, 5056053391262430293, 10345032411278802027, 13214556496570163981, 17698482058276194679, 2441850938900527637, 1314061001345252336, 6263402014353842038,
+		8487436533858443496, 12386798851261442113, 3224748875345095424, 16166568617729909099, 2213369110503306004, 6246347469485852131, 3129440554298978074, 605269941184323483,
+		3177531230451277512, 11022989490494865721, 8321856985295555401, 14727273563873821327, 876865438755954294, 14139765236890058248, 6880705719513638354, 8678887646434118325,
+		16896703203004244996, 11377226897030111200, 2302364246994590389, 4499255394192625779, 1906858144627445384, 2670515414718439880, 868537809054295101, 7535366755622172814,
+		339769604981749608, 12384581172556225075, 2596838235904096350, 5684069910326796630, 913125548148611907, 1661497269948077623, 2892028918424825190, 9220412792897768138,
+		14754959387565938441, 1023838193204581133, 13599978343236540433, 8323909593307920217, 3852032956982813055, 7526785533690696419, 8993798556223495105, 18140648187477079959,
+		11692087196810962506, 1328079167955601379, 1664008958165329504, 18063501818261063470, 2861243404839114859, 13702578580056324034, 16781565866279299035, 1524194541633674171,
+		8267721299596412251, 273633183929630283, 17164190306640434032, 16332882679719778825, 4663567915067622493, 15521151801790569253, 7273215397645141911, 2324445691280731636,
+		9262509587234749312, 6377906816499461739, 15415592259881792841, 6113140067088447267, 17505803833889144731, 3922849788840338823, 6180172597177093790, 7272741317181956640,
+		10883262735810583709, 17399134577381480315, 12750035195491397119, 13953097270363313998, 2485196748577282439, 393430759246706702, 3408702096065201083, 16993508724217005008,
+		6863012803048745338, 5403358912802668606, 12029756355518540153, 7447472859343023066, 7395681837001497117, 5416243410959797052, 2749045697176435642, 7813683613416962381,
+		18350218749545913064, 7509253999860752750, 13295789896366834092, 18326374111226872828, 3258048562491844971, 6342797029666289605, 9612474478300039361, 17807494771134060923,
+		9986610307523639857, 6419466267862117340, 324428332031706042, 16344106992423140174, 9434790811884847197, 11733262517030341550, 10475871084940451430, 6836751077061091536,
+		6209985515928007176, 8422208926220809341, 7866188125456775984, 17071696982741312252, 17482363193291892153, 1949968206030126177, 8823961512355572132, 13873010936602132387,
+		1136614876084383862, 14528605954969250458, 7641208364604111421, 18286716654189762724, 10711679476846124804, 7209187038097309348, 11378652158954714549, 8736575389915992180,
+		17651988839102959720, 4019365809979531118, 15024676458991206505, 12622721674297982786, 243375780477240745, 16572583194372185930, 5189991834753707889, 9498206494038386287,
+		7870185149723322393, 7858065912377481781, 7050328012468471455, 17977001023138181397, 11912539230960339911, 1290924823368819542, 8532615064753763585, 6439520053123840906,
+		11863354073576605599, 8052916203396229040, 16399182063316628399, 10837704607074036270, 5444229620349428264, 10866168931038804304, 1298875461760659950, 8904898233335519592,
+		7053953350607273992, 16629865408105641272, 1929728580699289339, 11046110151029488400, 9569890690274721816, 6501378768832742664, 1512621765961532661, 17084264658609527495,
+		300662505135603380, 15234062183651308307, 5319536121171934679, 11496182741145732970, 10520610739189276272, 4310163027157056344, 3285324287508696251, 3261468597637865009,
+		5427469457023618335, 8296698312021944466, 10882999905197052907, 16825284839961451415, 2106903142647479713, 12008841566652934760, 5361688498494289694, 12228623597691228792,
+		6799789383171367218, 17419525584795621504, 10685476378747845090, 16314000862057872712, 11014509959317588121, 10396318154903722147, 9986284919279346079, 4005974039875805723,
+		12980531573372269379, 11790791377897350561, 14264262096731994829, 14999393269362129980, 15405842559289002684, 13147503876582120266, 15449556979080143937, 5047767509783027570,
+		16354606995222167433, 15941889353688553446, 10301254747221876749, 10704428461746587572, 15702361407127630489, 3283718562982354984, 18081088275079496700, 17549094608770385733,
+		15620168851912893400, 13762314693487747007, 13577625382054330775, 4116976667540664996, 712200332640207605, 9098568002202933512, 8905476951567380032, 7075673514150314660,
+	},
+	{
+		15811459837282651008, 4038049993244767161, 9054218236388056577, 10807376403937048775, 11113869110590438959, 10336442539492421506, 9228056645601479672, 2983388754829658480,
+		7189376137127712298, 9147574701720272724, 3983921661449444789, 12479790317447783959, 13221020976679959405, 13001868979553711359, 17918176319017234744, 18030393246529651080,
+		13903368497828271814, 8050546449078305498, 6932373216915935575, 16010012759059004304, 15451708272653450375, 211711129247219149, 10435723642185827585, 17790507800712341232,
+		5218985848865375996, 5835476376320976237, 9096499658845542933, 8952489298840360492, 16605895184424459659, 505731104315931813, 17784248872812610986, 4151555707609374291,
+		2650786429127545939, 15186825834659456704, 6983758297535957561, 1268007525252235269, 11433489869282443481, 12352824209154665189, 14555720778982121964, 3578659908492218328,
+		4038120750249579469, 8304001815287976437, 251700810512667658, 17170873737273596918, 12809642145843734737, 5765073376623244019, 7923401246629348462, 5401634486288115286,
+		12830329023522940651, 1302336131164509751, 7011936976469244509, 8446680306499168806, 1386043952588989461, 9057741950701319559, 6719607413978812889, 17371065020414280890,
+		4963953120977916566, 6585250545846301109, 4490972754776862709, 10674499592300479120, 17494988318349821345, 1814042777264686189, 8938395423478059768, 9062966010283426056,
+		4683683785459765575, 8782133909400988812, 7201726172249963453, 16855412996123591560, 12016536526053703526, 6004686128951599125, 4323130180079993082, 7578596978943754924,
+		13272384473390546409, 15052793429857194942, 3597944793474963009, 5659515835454510338, 18013102402609680655, 15096936721974473248, 9096406212198787674, 948405832772983882,
+		7533214627823316056, 8009521942734148665, 15370181949218639901, 17395801240657257383, 13217990616373936619, 16323510521919428293, 10737557422966235859, 11113837024463125316,
+		3879469818714011415, 11493820457829716643, 10091807027724827301, 5032134849078736052, 18015749204009276046, 9667758283246223357, 4629693773460610802, 3807196436109718946,
+		3214144211600931504, 9454007581819416365, 15275469051811991033, 18196204074031746058, 14853793468372596948, 7707818604949749658, 3266782539036976530, 12810995382868348472,
+		17461133192060813135, 16870745208936545685, 5903437034120721004, 9683544852742219696, 7903581348090948266, 13461951083275541722, 2454715926022970060, 11781268272016425522,
+		3026443193966185195, 8027125782547146632, 17998666917527163386, 17214321347454260227, 10230244243647560419, 8728893474426972780, 16205038544687771303, 13771356055080873468,
+		5724217930909760221, 15420221591912350415, 9910465013739250802, 12511683773790779491, 2841532862707547306, 16614426471009646589, 407574220261191228, 17422057170120224031,
+		17151505459068312604, 2041124098660595410, 3221606782120899146, 1382742171848704850, 17222534050501711510, 3195635935311449393, 17295393886051199723, 6296241746423654238,
+		16510537668852450348, 15650518534057329304, 475704671950317376, 782416820485820540, 10970369699990900408, 16601298147057372792, 1599283701215392453, 8464446359559369186,
+		602848212987973622, 9275953159572178443, 15133444738457385545, 7264639569553811785, 14831517002293569763, 4277078717758211028, 12880437544322007232, 16339691585101354857,
+		3725101809714764432, 2995111022132376824, 9338883729618021504, 8824923738291347476, 3745497072215538317, 3576446898425965872, 2350077748663612773, 15793255155885543355,
+		8020669822852194733, 5865488997462325879, 13508617967776537887, 12934930135071898613, 11708185641249600577, 14265801329217514207, 10451671488560352734, 13251349632343744236,
+		10155392082337432799, 16725751190167983672, 17791070776350679280, 6653785531179322348, 10087876256887835780, 8422365820961469204, 13614411778251983480, 11687935452237305960,
+		6094298050768263419, 13949448434836272414, 14194554169090099223, 2625524360834828424, 2823844915913169919, 14077211807091283985, 15592587505996634401, 6562949920171518305,
+		12904339001067417585, 1972265247859388742, 8908590936681392405, 10320719400504224158, 8298368064038407143, 2105745729886511647, 16509751074757847095, 15156289751671616565,
+		13922601558154971179, 10541544592627074316, 9996345160543671471, 2956094548427827774, 3384122842786043431, 7003441038438960180, 11945730502649377204, 14797331669618433927,
+		533287349958250211, 13929395807878461602, 10036169742264959424, 18402398814900480008, 8793706913568807269, 4438954128288889267, 13996827050589647592, 6637236830429213437,
+		4308464751705576538, 12193581114161194913, 7322672375339219540, 329737085274484939, 15312435499764491079, 1530264129038944128, 1545025965426980152, 14559433923601957161,
+		885617946245226760, 17871561572095909264, 16413308527330544768, 2938750343525834336, 6332736376778563648, 16772687696658236231, 9760470695949399178, 17420556823805232882,
+		15040671962589188567, 5841393164221253498, 8923415548773111750, 17449640982747951473, 541686588805328549, 9579487672246868564, 12793813917570150236, 5744918442591934533,
+		12406806484060734474, 4655292039647906135, 5745141229449178147, 12923621608907306732, 1329768221522217568, 16293616079741201891, 16309603918079351385, 8282635243638078478,
+		10842935462043546322, 9397166878596340773, 5807145729199489911, 17083242467628861919, 11473470924584853882, 15220945465200609206, 10470712526179658906, 8129601297261864071,
+		4407657041250297528, 13832960959347315977, 15056546959967740939, 4350443362134191429, 8013419913016572733, 8888684099801298477, 15401479253620745715, 18279947201669400847,
+	},
+	{
+		7454214833719424418, 2128900810399984335, 8254953962723841408, 5341529923812819418, 11486532916552139238, 4528331821405917357, 5048485034448492541, 4189495710753944825,
+		9223539587116638677, 879142711399260546, 2878829560233905572, 13081522393987952773, 3067261963348061547, 16008150780594711643, 5466468631453287640, 16659147898971349582,
+		8047766502132608624, 8715815570878148809, 9093649079884580138, 3437267783531715968, 17562225708466062266, 3512667182749067601, 9223059995161026858, 1366690634827047376,
+		17929132376737482163, 5565926714491294456, 5252303555134107501, 8169975563698132305, 1829326230943509100, 13780918661853274468, 17736665596871232627, 4246797342334307384,
+		5113556452592134569, 7304867793218750141, 6016631926489320290, 16471860203547627727, 3444471410714850041, 16571738096215232488, 2003912224952639024, 4203884000388032492,
+		16858425223672505353, 3192567884201479579, 1688923188642613263, 4159042130811153987, 14900413503869744297, 7521485042788722327, 14038093805562042641, 14713051866364662650,
+		3738774192924465076, 14037618828827556145, 12882915396530927286, 10882862194263941815, 13115222579444494605, 18244214260845794346, 17217867059738274194, 2458870331386500577,
+		8768788172344064509, 2761897497254272960, 1400167175024837359, 2591319596670212133, 1499652044223484974, 6820326453941021707, 9701009499879906773, 6897435972338565418,
+		8314355711464256163, 8435944020779763783, 1814803522962187872, 1875253356755380905, 8214588085484192137, 18062045700553127821, 6649947905482043494, 3119726140944397531,
+		11881571666857493523, 6300786026612414187, 4928573492087752294, 18343550313462089203, 6770642120472453960, 11296815027803718740, 17312916793783562794, 13028515123652649961,
+		583508939637547757, 3195115082527873085, 8497784022800549923, 15135719419829981016, 1180291993378114150, 5447281494912347899, 4710517655176242215, 606503081693490000,
+		17732293765863716052, 853971165248416821, 2022886284923413326, 7522564752651732633, 1417954193520965954, 5046659528429172066, 11426939225844711305, 17687206690616539318,
+		6518552374736169438, 7940416740434530770, 15228615103587329007, 10662504584317997513, 18370800756791469891, 5564085264882124489, 51043856061444814, 11996026931884728651,
+		7009195269496826002, 18330778751427846129, 7903886241001925539, 8198930484643879628, 5453546027419466587, 10378692433982210944, 2242412603379120569, 14762161396393277464,
+		6146718865488327808, 8559779132928137805, 14001994895150170346, 9915701789711858841, 17119408219089522083, 4345363585985782988, 7559492126634131602, 17074565022279033371,
+		1081257522368061155, 16144982029632101790, 2280210790959566458, 5000326950136078873, 10441086845859171982, 5717080014740953823, 16816253740467637151, 5185838557034755093,
+		5835900675852976641, 14850646160621635240, 7784412869482958370, 2550282385659033114, 5102457400165153071, 16480738116286616710, 10726825595752219296, 3297564208881065856,
+		1801069609044825811, 12940364451588241698, 11725236374887225564, 4731241880784054295, 8874695411069669852, 10719836334830130110, 12983549127094653526, 3498884940869443564,
+		5044718241380586525, 9152928988998314956, 13274353997717834972, 5731942246653336838, 9453579625340936273, 6013700107129234092, 8535405089994224035, 12024982282827680252,
+		8296339816955798913, 17352704937535250450, 11768204246645005024, 263391795317009517, 6622964609352808474, 14563414288208376628, 17887389278697258458, 1552357122641071119,
+		13193447428787140357, 6701071088186218635, 17090465712567125397, 13844922841372559745, 4526664599449630663, 11321311100342816810, 2490532976442445147, 12506579957986846905,
+		15880983134955361922, 12396434033732989105, 16113831675045409693, 2288598422068078002, 2992425583703267972, 5056435264545116829, 12961420259857080621, 3600697676136115398,
+		12817090821406743193, 18109694174173693756, 17050997692981853333, 15796663317536421728, 15462568940214327094, 15151767385082666402, 17711108405932879054, 4030072071760424157,
+		15725012875727498089, 7622633481063722008, 2241559275264867670, 4018985714167034871, 6507661741395512701, 13435865773135624096, 9564553262368888543, 2283482276790194513,
+		2968718708369505078, 5001470555537559034, 985353756026354700, 3145435598301843880, 16410370922030326027, 13981261173663429189, 12565590835494971812, 222252377400865123,
+		3096505383227168071, 9129898186148780825, 13266305466206099845, 16135309871416543685, 17993464782237414425, 8124413037611692960, 8497190057115012501, 16568064870411415344,
+		7703394153241465824, 2740794419858297964, 4228931976096177316, 11207299659959318490, 3319492324515199082, 15611937984154016609, 3431896575019701337, 10686234123352138088,
+		9979039962499030832, 11759414020433216431, 15164411293105859178, 2834464820255498467, 10716371968480406389, 2722055037405581557, 9240657586762413776, 267811388229104916,
+		8385388272348876655, 16035999427286017211, 11255427708348651444, 18402964994101916340, 17964277099260928049, 16377129731672778885, 12034488763192562427, 15854195461740399790,
+		14134352329607480415, 2406779189916280288, 1148342927890148438, 15859735140823564382, 12055096645840568482, 16044304241162505738, 7466809979198503617, 4519925955244504432,
+		576546655711744206, 7729660311499709518, 16864252562359023573, 10537888397995064025, 11828992107618549830, 875843272290362538, 5328675038336932433, 3162100370899364658,
+		3897734650128449985, 3892478283047854402, 153850176068596076, 4448963435449755938, 9911011406822436713, 6379744721342779297, 360324666931028426, 8002086405015565067,
+	},
+	{
+		18068291112584812890, 10288580446655316879, 16866690514199445805, 15458664010538199871, 17175925202246173890, 12208778610361755998, 927739404697616036, 10330183209424493139,
+		17095781462759061506, 13984950766342782369, 7038608479806172868, 7073471193601880894, 9212126909381119712, 15865851343492198107, 3874039137971369196, 15366505242302572319,
+		3235058267792568155, 8030551941244615429, 12851363585510555514, 9786973022560471711, 4901414898060251968, 13240438628487941170, 4707852389766057435, 6503805666511566831,
+		12081034000518110752, 2773740877021737013, 6429475399936543899, 6804412599792308979, 16082860502313571182, 10013838454082912732, 7176778953927883654, 8065751639278576331,
+		2577328127707636877, 17299987330349518428, 15104751346159263209, 15422444943335124822, 7934601464470854115, 2803659700354182364, 186161376356596699, 10049927908892587253,
+		14226302346438044875, 11259466681405724608, 3945860952925292329, 3287876564263331089, 9461394118536996000, 12404803552046013762, 16569223065554335449, 15881973563254196893,
+		6665552777203645232, 5302850683863152336, 7778922028047389493, 14212904863357452615, 15966527672828304861, 3802704091320278344, 10517530714917238300, 3742971938824724276,
+		17741525051518363144, 1374267330336191942, 4677891169679898540, 9639823611685431337, 5482431056894095950, 6629146695374718376, 3884574854221819712, 13266790928096813258,
+		16028684877412556061, 13405436055762225966, 12268280467958284214, 17956874998292211440, 8610745336676661311, 2945210828327041653, 7889492068658434371, 8032335517518163423,
+		17096678157067198548, 11751872841896846778, 14951591239724148110, 14946797103632354342, 15001812923533485850, 1354666869219009884, 15934246013528228877, 17674533676709494379,
+		5120889077991995845, 1349360562851394781, 7965752316528770369, 16276575673105864366, 16613052983770261287, 11454051240568463780, 16146905806612132291, 15806571503343623359,
+		17505459029376928465, 14087658194607915364, 12240552390931686885, 1809009366037859941, 9468395484396723291, 9446052656478984520, 3720796795453397330, 18035355127900871187,
+		10937782812576841853, 2203021845094443505, 9622750764486021477, 5518948515641487288, 8021555402800950130, 8884074473434139094, 3925095588129480413, 6199533424090268508,
+		3824657730049729815, 4646911366274335188, 5283751816651713473, 16396970607630079440, 9102362834410101425, 3641728106404110497, 5923630184251416230, 13179374259571264822,
+		656781601862662976, 13284523818709348938, 14255949685810234815, 17662122984572331094, 14005272187244763785, 2769973460677437621, 9745740172208222044, 4399769039990314590,
+		18221138344920380175, 16761112742545021198, 14421639991115588619, 9419167563943683547, 6237248361283446238, 889754338720059891, 2289880386545166424, 4280148734121099084,
+		8456687949810928719, 6224977199672540221, 9826855484829367341, 10345583292656523462, 715642447678891171, 10791247680314230673, 4390153264475025171, 6710036254773432312,
+		11434352627810350015, 2720291857616706675, 15035363195148805272, 2358906741960696657, 9439888337759970778, 9654563570832962181, 6013570511081660799, 12742404245236356978,
+		16538557679183724426, 6137267799072203525, 13879005145532324670, 14569289845201353615, 13784903266526414562, 1051135786146476033, 9343275973150690259, 18338317230916899584,
+		5259165122317589354, 6306061166879114159, 2622163270351284906, 15212813592118086979, 11497359168652342849, 7085380391293263482, 11799059272489792659, 4912160901181298022,
+		10956239956289671191, 12649697329483184719, 17174497942073298839, 16454040570484021598, 1964314354536023134, 15533681501854792750, 11384243972598433754, 14387731385073008825,
+		1627256545355657442, 9010013556811110994, 14616120598404631231, 8391972858400276155, 244817907132802237, 1484397967210729699, 2663560284299448875, 4820353472962713985,
+		6567121006858416952, 17119959301239619281, 3965303761563489817, 10211688306206007722, 724618943950031080, 16749575186941231354, 9181397347361086360, 470616631211702666,
+		10512473611770099290, 11735037909076331019, 2922606398008539984, 2599799834378751770, 10226702495047936424, 6109026252412854338, 15572556822827169237, 11993701786788749663,
+		12951512375864063487, 9270845327881823041, 13198171264747338719, 9240466821667660686, 14918848310897324032, 10111918274408213257, 9869937817792431868, 11316967879062014936,
+		5691364106926740802, 2782311978438620206, 13067832493996441150, 12682941211395745221, 10515041347274706648, 9910726429809603026, 10540072260993990483, 15078586909891471233,
+		10892036011159420575, 9833543566604313963, 15176473361412960115, 14504845496732895720, 15845034940445278100, 5364672156984348678, 308167090528488415, 12390239901799634313,
+		5106897453764491321, 10540479232768400094, 3938246597140945859, 13156157265138481529, 4932443191001849637, 11374218582626530502, 2907557293167002437, 6807344711257391317,
+		5413712686694380670, 13147753106081951274, 2960292187746417883, 13977097845105551070, 17642067093469099040, 7699556298723812469, 11597002672863564976, 12392265705126521509,
+		4607947077536257852, 17763906282816835996, 11288463953418287893, 18299911648497821660, 3194698850612319839, 13371221457376435780, 10047718724723936081, 4488868185988157408,
+		13742985513958274859, 14201726926009534105, 2183997556320958457, 2564950343266657518, 8846625471673389624, 10147673280504740463, 186524308060896613, 16409126738088317791,
+		3993197157612782947, 14810882170056329119, 3476738916713041107, 1512933700383846542, 17820889751141311776, 9132720567660500233, 17598924894608972696, 9704537908665702455,
+	},
+	{
+		15695265447782578013, 15506558718447241194, 12341861439298989232, 18400958156300100845, 13704811286967591150, 5802260047239067846, 3266013253411255445, 9892957742319181954,
+		6053458788987550519, 3243549259991905443, 17990025476026266205, 3918149716414968130, 562225565996136148, 12175287017902713154, 16317970834262634990, 5431198806775607012,
+		15123186170178367264, 3054913246068400920, 8130663466272395280, 2852812622149318730, 6747630551931917110, 18302049774259156971, 3663865061939346221, 12340091610704678811,
+		17453312277789785069, 1148609799196055657, 5931758962926317381, 5297597381576544508, 9136842287749269744, 3007653173299649609, 12364677607049679091, 3656932227466449489,
+		17732801126130995365, 16093023291975796560, 17028512234142609413, 6293028118993952199, 4019599708379609715, 3557632583507755601, 16737140015288442165, 7041678499288317736,
+		5187842645752673199, 14914432544387315508, 4944360914161982641, 4177329533692612281, 18423887817846407126, 11935898134550505219, 9191754399457615042, 962223885189306707,
+		5467152559317256227, 13407023128339380091, 656806207084558176, 10823228592509573890, 282802378108427873, 13003319652664166176, 11501612671901244594, 8595770155487539951,
+		1805255869285898834, 11676967700876044626, 3486630203654875772, 8366336693945605431, 17874084888474647879, 8803709150655606891, 680993178667234696, 1603785777136148315,
+		3637712241808318043, 1673622542455477465, 14468899013751477571, 6607241816357171779, 2332200248940843815, 14077155355848738174, 17298155509321457563, 13624623885136011130,
+		12550073596584561722, 13898852145577133829, 31360866049197404, 12629522544897401454, 4563446134761510332, 7272813487383198495, 16767195814334178362, 13600498026689482359,
+		5170414136067325373, 10875290278133558518, 7331268231382198947, 4082234313337835514, 11725295114019619895, 6488017511603508543, 11399466652931338200, 2898113599278666684,
+		7553418756944942759, 2324485560009697358, 16004009784734101843, 8345371056076551939, 7377284629098981027, 11049718262343754276, 8021605820736410979, 8175349759714152494,
+		805625092558946929, 11996029844853502332, 1725029464967101849, 8189609560660709539, 10396089572662865065, 1756007811373736605, 7645529329516777410, 2608132938055260111,
+		17014595621244604813, 1574499958190108567, 8684546755761322906, 9997538531915911005, 5652402150243592363, 6315865356369667235, 8687115108443972047, 12369176255146729475,
+		5117004045853299762, 2238407612548002914, 12392667457861900490, 10614312910576266709, 6446577503758597410, 3767883614425995197, 17954966454260719539, 5233322901463099,
+		9194523390605857831, 2335161171394626054, 12290490336543843159, 12464172604156286188, 15842196578033029974, 9081285134201585379, 6123406461662038242, 5504260508195082396,
+		5345718195770885739, 10397124463462860788, 13439280718993427040, 15556816356929214653, 17286785976489019906, 13891416634083443852, 16346644312573564447, 917629419222512011,
+		7892626957952656865, 11229871638807701267, 5249460237065799805, 9529842808650392581, 11803106868201977918, 4600784567377577444, 7178870186583927975, 13829108773971861655,
+		1289703927368007546, 16175369390684210381, 2195306032582966573, 11284704298115036296, 4385727852306374408, 6915138269030006111, 13440775052829788601, 7742359656861485339,
+		1418252737937945274, 10664598666472920539, 5146625453081549320, 7716408631061669307, 15481216546649435253, 9087869057854823101, 8438781502742166926, 16066665509570633845,
+		13091912700111633391, 15443255616678375884, 11338466119311799740, 9641919445273031117, 12359044485240987114, 7665168466660756789, 13845183791692700257, 10700410793152785934,
+		8528578803314347534, 18126789418189181716, 6819229450418907940, 10542951903574211724, 10335954505229790439, 773396809431100386, 763679854573261611, 7782804492252573047,
+		14102889564247144327, 15479515297699126743, 6400257822506917934, 12400211936189844586, 8190162441518233318, 16489757979266243333, 11074854544980782334, 5650848136444824725,
+		49299995316533601, 1658812626798186796, 14321322055030354, 1062750633396640947, 11458188738562323084, 10319462683954522885, 15398455357851813321, 9473384090828584828,
+		17723857482947114516, 17563952877363564604, 3160294749187111891, 15485369139883303866, 7487527166185553604, 9661144290316674030, 16387431126208996705, 7499766964252214921,
+		18331281993562501191, 16034836629143884193, 11149238385567891503, 1413880911197321245, 513884082842080653, 462183409527465946, 404977499728878854, 1459875951423441439,
+		17249202826373649180, 11151860661862313351, 13606113651347187963, 13653298062695357606, 12346841931589648448, 10659825520992339734, 17857177794617595021, 12846976930859175746,
+		7421386827645898229, 4567141110780940726, 9022716764262477732, 7287282267953917487, 12950322172330872807, 2675202024861592519, 18339036521791481203, 7003909904344391740,
+		13539440097944399044, 7108271818419613260, 13229113021954558930, 14920952138366964142, 11082363944167072746, 16156446445495173622, 15515349862819133984, 12359827931233605745,
+		17013104138257181849, 6982996767213561282, 16259302607976830987, 1579942890487532721, 8635464047344487404, 10435012080572068738, 2976844365866972753, 9471858478345924179,
+		2347775782107812070, 311367032040459687, 10852128873404113998, 1338612296059509077, 1599132038614432432, 11533828746166635650, 14264087792956755961, 13004615331499537807,
+		9599159247384506427, 13011559959971256245, 6331802547989957841, 2642320882309956905, 9140255367820630480, 6883541786494880896, 9560822438260750771, 9273862677291701694,
+	},
+	{
+		6185067974942684922, 6452325785873503452, 15247257292915812252, 3689324664200339196, 3264129576054154137, 14977721630214750038, 10720913377937894256, 15914487080763816378,
+		5498621600689515064, 11498885804037952971, 12697073118321478539, 13999008478737234463, 4324885099420360642, 14021182496192299466, 10763088992583373843, 12898585157666243299,
+		11622402383521841588, 18271726976204770291, 4805501248621435402, 13483122453682180759, 9288143526654965614, 4688427612851085031, 3280806057528512375, 2249349779106893174,
+		2317249352525369754, 15030797481081533168, 12237590576308284360, 15660076992611440873, 11341015819700735887, 8280257602754365719, 9212501234696283343, 9673375202141178099,
+		1576552382781604867, 14644873134348781157, 9860879950368557094, 12941927431704225849, 11959666739052502184, 16171152369226594315, 18364294470656574060, 15172859394935215584,
+		7521577570681641021, 410124023045579310, 13806534589183327176, 2731801491329207875, 9959087943014269549, 16205635445474657221, 12069145915768935630, 14906463509471682144,
+		13803661539609326912, 3233094883493439444, 13409742688319755923, 4298169788674760921, 12847636671560067434, 6702365884489797170, 5650404576647289813, 7380374625644226212,
+		9762534010701623728, 15349113802811029024, 8305297169667044246, 18013018210154476198, 18414050009163335761, 2190126859433916996, 5444481274452218807, 13415988647365667724,
+		12538763466834894269, 1385338113050483955, 17489001033590767373, 12734464941837886525, 5762578105750980174, 1466528690684075875, 4231060025049573530, 11218444849081704286,
+		13520439252664960951, 3770430920651384098, 18274623217805904547, 11545267616883260257, 4084783424859113779, 13863968977657663867, 10237835480648574698, 7395611844854084274,
+		12891185742908997266, 2889148203703402614, 663579373261619221, 7616112456816883701, 9002890885722034437, 10753730807791931375, 3553894671829778441, 4368240432504457389,
+		11641532224340210206, 71261001011952801, 2321745415903209397, 6595984444855093239, 10341299657770272718, 11529878689049370930, 14381510695605158203, 6869272773579747365,
+		18407769999912340511, 13801873415230385184, 8080153703167941484, 14143463895182697871, 5248006623352376562, 9271982788122934275, 11225161179021692620, 5076519449784098178,
+		2388868518767189674, 381125256886459269, 11316805024982236485, 11671355336111917711, 3564177948445768908, 5245093046097324328, 16144139891410041039, 1201010948447708436,
+		16591032462856670656, 533850935988668408, 2263232738784171066, 5572124915367282948, 12583782854491678471, 15015562207264407653, 1167486851113549964, 2987176661273439670,
+		1073778278665127828, 301289653767944933, 11482324780950168317, 10626716202328004967, 7258024014655363102, 12597648090458567878, 2617914106162603499, 12324652644266476584,
+		3803745429517922765, 1699256829990081513, 2179986933466617785, 4330084096014112280, 10403896221616386733, 11682369673591069651, 3879392495596713886, 17249085256521020624,
+		13938687445393525296, 13822790166673492712, 13216892716897321740, 2165870280409061482, 9147830602451471293, 16339144108911449834, 17837507766320968023, 15340710005345158245,
+		4485838034764604283, 8426970493386126530, 7709201418726935942, 13468796449943783583, 16441091014185628843, 2374269830239737237, 13423059086148485716, 17132218391020520330,
+		13957732574177025801, 1100344278733481546, 12156946932617203965, 2007756425747006287, 16454508610548016441, 18058668363064769203, 15619001054652658323, 1201476243910931863,
+		1292412381963708933, 10908631677673353277, 15138649576688192753, 10741579086621436813, 16534963566169304684, 10228646729525192055, 4256608246548223655, 16176814322718522963,
+		3012125536603284881, 5466178753014623970, 16598422155702380175, 9902071731736699653, 13861556771123036741, 9534711573278556274, 9805898455743897538, 14683694395093520838,
+		9125214754744730198, 143353181770418225, 8976042597473555858, 13405481215779362056, 2863125481657826330, 12333764090388731260, 15250359513836914002, 5086706595778559056,
+		16341334571424533804, 4657494880554316004, 18092783076286521475, 19832895869027143, 8667365497283429486, 11501953273367138162, 5832487631687776985, 664754160781757174,
+		13604774408440609080, 12660956565879820101, 4535452877362385626, 8063311919592303330, 4591511734775484245, 5164119991271568303, 5282209033000495913, 15181017218549722334,
+		5070228782679699429, 277881850788922387, 17424210585510719837, 13586569401109299583, 16661809787463692974, 11543434536078774133, 2062889565117549061, 14261113517104795690,
+		17683343658262519228, 13727986689138309987, 9352982220536939533, 7578301410191413286, 7970586266869249410, 14357824150096386968, 4381700479561442130, 13217807763329274501,
+		13524719886605363170, 11553593166914861649, 12034020205580665813, 985175984881624722, 11040631342644137311, 12107496606245418129, 7328748654066365904, 14741972847454326011,
+		9790251609380109406, 2449588380962781369, 4694893010228180943, 5172145489692928848, 5411277023198532852, 12752098113265127406, 4559500999103209672, 14921033543082064351,
+		2248082728820243864, 8720404853152831367, 12431505213690884811, 14883031570121462817, 2278273022936639560, 14988529405400451352, 16732922988142595529, 1071232319627396164,
+		8793441611217807824, 13198147137434605751, 8167936709747999601, 7685928882032231744, 8779182451658438210, 8059106577297479923, 18394590909567718507, 15508315617300242773,
+		12828567388121500364, 2264959796189127526, 6222205589523394088, 8827682270015065013, 2619170858745203321, 14835030117099398518, 5960028394532808010, 2233397097850889639,
+	},
+	{
+		16319476863352440541, 10283930715856640343, 17675054544532098447, 11261132162985242084, 13712716897981761400, 2681907143459288706, 6930256922080133347, 1445069157579547822,
+		16928574868467385886, 166417019993787654, 5882811520342817815, 14106304179344008065, 3747123724781081800, 197109533566874475, 14303280595714789450, 15457633026018307066,
+		10773597511592584859, 12552868588431074640, 13500771767160426835, 8002499270056378440, 13792839099998553174, 12949371255843262119, 1713974340992291550, 16150173130483658061,
+		14745984256428057001, 9333707338036985191, 15365925315303462, 11789129028059619744, 7873100217437235208, 5289763977161829145, 17731215200358323788, 8876377479309635703,
+		265950821974454804, 5047467530470542278, 17523044368516619801, 10054436503372765176, 10321185867287373431, 1212061937729015591, 15311258419138633926, 11236518538207084768,
+		10904693956407098222, 9013418755007070130, 15510005599846320670, 995378633446250700, 12234095025518917836, 6689106237771514188, 2809193993744369126, 548124799387888260,
+		267350765778774337, 2853877351938464055, 3677119082593358544, 7685335121077514739, 6491980094762370981, 1384870316654548002, 10568872345228996498, 241629538659623878,
+		5839400175629113441, 5238299193248381245, 16787876416022887315, 6051613843621920008, 9219569873668974552, 5916753090530931032, 13390630214643423749, 3265335490455191268,
+		1507475744849985303, 2597075068965622770, 14968669113917266926, 597606442423659891, 44293923912414886, 3832651144752540816, 17438860065613195810, 782112340603343331,
+		9050896199196733903, 6427608033444590004, 13787696679536621857, 9682087046920409188, 4519093754155995429, 13564098392055667371, 10512507082236058799, 5289934424008191746,
+		3477191607403300916, 18283244229745029067, 8462159792484018099, 3056576498976014760, 7259283167233712785, 12530251965039903998, 10232104933720625111, 14190745998092156987,
+		15759362035410895911, 16075598437961371531, 4651513528876405575, 7694151626503869614, 14468862724637972284, 1838601521755586245, 4168957446435305706, 8694905613027663664,
+		14825552838983151434, 8639609968952840931, 15547914584352392016, 2313507499500708287, 6902543375698033684, 9987468886016348918, 9068175779860656258, 6899641689193116297,
+		7449110402827616954, 5689206471789540768, 12722069021950813669, 16017131401246233663, 2240977975275954837, 4794705713606614946, 5734937900461809607, 118285984764445639,
+		13917685647531721740, 2432096911145792817, 17733637484624159521, 3848601825403209903, 8192433211051054683, 17388066421914150767, 14336306308847565282, 7501625553608785022,
+		9844707592410952215, 8167497709587672711, 18115463401502884199, 8471563375691441535, 17525405040226359165, 2460181803833371342, 3375780580907171205, 3024376384135966552,
+		15446204978718816914, 10131769697256428720, 10937168660849553757, 12174257400309926241, 4774490771219074715, 13764876998736771340, 14299051476546774038, 11409551629093945893,
+		5471366060803425265, 5927845172343647238, 13321967429805195545, 1981489848211999240, 3657997933879283852, 1341488083977381854, 11001000434984172675, 12666440712128450303,
+		2127920575549495889, 8861781778185702064, 10501256952986753134, 8967441017586595593, 12224364761159418844, 11856305587178745520, 8176487286367052930, 4988165299911239066,
+		12279712962388998309, 7552494563001503282, 7388800608466198128, 15704167671257743517, 17781278773093632973, 6688613358271814698, 12261263098366698895, 2585757657252460656,
+		17064077609211627595, 14437064866605257652, 14386408901468621215, 14935685266532365200, 16350265985491822570, 5195856143474093260, 4623415440658404410, 2936315929072503688,
+		18399447684263070219, 11294713679768342649, 1600242588657342501, 2841752419388937826, 15111313732750279467, 8179471361906256467, 10611923788752807866, 10823997080784081293,
+		15607034385960553579, 6934034624930683639, 13318618594774430459, 7552865293216027192, 13692640408995992185, 11143313220936824014, 16721999332340829387, 6993089466645938014,
+		1749509641415861857, 8597876492914031095, 17942224190138398306, 1760222146515426983, 1030117883582412628, 6655464189981098460, 14222900139576809037, 13041171493967200019,
+		12415333505074758067, 16988669193263876033, 10482573641416551070, 368049292090348794, 16109255925523895167, 4949934055388640387, 12038479532506656790, 10829864449693781036,
+		8355401100656399994, 16963696462538033761, 10131652431024537917, 4166156454906166144, 12888240412190236596, 8396312458335953166, 445297814986468978, 10512295830234020744,
+		14405236772348157690, 6950094157338825845, 13379457125020057613, 11396720859761560260, 14063367153572826959, 4476298515903789197, 12708437873915498860, 8163633089770520638,
+		6432708226771955694, 7524978005081948959, 6442046223716866789, 4082077252385606982, 13626979819841658005, 4264573835620574342, 14788317690584235128, 4710414518172449402,
+		9592766374657389840, 3206081438027351157, 16013702689312533501, 15788528722601567812, 18314198451066123850, 13236688692074994659, 3229858297074852748, 2968037605940641303,
+		148470760067500612, 10319937899190593880, 7185467485673911733, 13041030391924988650, 17119842693824847662, 10989053172849710331, 16048294708726813099, 6612710923681979611,
+		17408606709137505005, 4263600430695220256, 8941719936291239640, 6115030817534063286, 838024703679813150, 9772071103323550178, 14394690179107421621, 8621372196164819917,
+		18138724984190926809, 4154767406604950048, 5209478936276366634, 15469512148904762872, 3613429290324777670, 12631812917445459751, 10280179062385049041, 19656860716268566,
+	},
+	{
+		12030193727051241373, 13981191132445467472, 18205169646206905593, 12162181194046583886, 10929925499200074058, 15291772758590352491, 8452344520852919320, 8199821440451878776,
+		9876482463501409337, 17331045017548147052, 17542726936580732548, 8299195336372136083, 12891767721269002608, 14062358772374813347, 4165127680073507756, 16350672737379495431,
+		7595271959296927018, 15286771623821390629, 980612661413312852, 5738158184597378995, 6972117550390447038, 6246497134979772260, 2935831443692029059, 12837371529160496660,
+		10228366644420455452, 12084265406352277347, 10265869676493821892, 3560143954870272139, 14368775225608592689, 13173522067191372913, 3592475039513249949, 11243554718624931135,
+		15959892157814064696, 1882528744932347842, 3354709518288681174, 14147909176429982637, 12969888425264095514, 12509610747258602648, 10437226619684632037, 7605683691113295811,
+		5697384515599291245, 14896081221061315030, 4329502046122948975, 16301954510440819492, 5191621061031169335, 12944691824816066027, 8080452646904372453, 793075614214301908,
+		2662373477940179766, 8950125653339535995, 15717799081080898304, 7088593450282143511, 11723351531494404904, 38673945663198753, 5289769381065195334, 1742280067441486108,
+		6543255501112359319, 6063422531520498671, 17228726254778244409, 7570754775709645369, 18222396492501523182, 14903937974816691813, 1216646642383641441, 7602781158453005929,
+		3007861146695764376, 8267227185027440857, 3177625538211272080, 3144345182124760000, 9215753228267875296, 1342253891473772992, 8185239004636232247, 14951188427081280984,
+		10569785547248986188, 3109435167722572449, 13661123218513357442, 4646373703143839998, 9712828426076586682, 11389514152975496268, 9796826623781200498, 234067627740956181,
+		2188380882990542468, 9914251329861595119, 13616219875099353594, 16135919125023820218, 10732193797566088293, 7172996278550642736, 8531638916719074975, 14749121691457005349,
+		14568782576170814716, 17582848432122737506, 1079387064102681806, 17278567874821675408, 3094302191119669899, 3730448048895347901, 3508894590334961422, 14091660942919228106,
+		8414395549498864629, 370884714015114625, 9859130251236103342, 17120282094084970181, 15213286581037020029, 2737545283554254673, 12422648607044275574, 10601123825482591606,
+		7332173975514924017, 6689389428877729175, 15162654177270425320, 17333672210015736765, 10717615330136876266, 15245080807947386155, 9830331968044142933, 16156512094344185621,
+		9151817936103586393, 3495709317444898385, 10881665308947458223, 7087755261386867019, 18372828768905212167, 12873774245490293443, 12750361906770763255, 17688389897350887716,
+		13329033749048978810, 4765695903433858377, 4452680451529163940, 5638854187414651620, 7897503022043776206, 17187635538005569019, 17766753195497526986, 13201529234556380285,
+		3638940913491383692, 16533217388164981609, 4668956005988168087, 14053696531704823982, 12029006663244142834, 12043309283447175601, 7840964186868745782, 5691369519440953069,
+		8500871974974230561, 6371833132372813539, 4002756625312698938, 7281624589760047276, 8813214993155334737, 7738842112797657395, 12616064385239668311, 11875709199633531753,
+		13080663957403320059, 7305658810888170771, 12002632153917673214, 14713338572031413494, 11629178662016777533, 11669230410217642326, 6563025945717173284, 15889630204666511658,
+		8934119620399766972, 4226481091885914732, 16000709195004445297, 14687868180928846933, 16269913392757896907, 18294005838441325342, 17625669613551023126, 10864307042201644469,
+		1539179629859629979, 3357767843775461146, 2101360073251832751, 17234081431682678130, 10847284171622250162, 2314478515498414576, 17530153382031867644, 16210890762511619844,
+		16932765725476234252, 17974885539458965712, 40892050255466590, 13934027942808790590, 6621543269907021363, 11796852321134174354, 16673775773384613137, 3370296079966463186,
+		16962514259432373133, 4639769064050336100, 16965148588326727680, 2922022742538957808, 16752379982369550296, 12896050752492664079, 2708685629936199207, 17894058559833424187,
+		14722530431277419104, 12333728409662476827, 4162946257347548625, 7052045338975163666, 16435875989376103923, 527141841571514699, 8480360258792897962, 4322786951393806781,
+		17366230017999184054, 3121469063237497918, 16903979375392804254, 8204447732627807538, 10469007462907301028, 1938243801077680483, 10156223751968769092, 14290141776757271674,
+		2576841693080637380, 17952976066680364360, 4927209893946473523, 12406446420948698970, 18104668447274679200, 11321546081935789882, 11763004760954725540, 7488613143173641394,
+		7566233859107262691, 14065899052643539237, 17156645465457086529, 11936850757897686493, 17529993825395532749, 17145245039398670236, 17597009579379584432, 3472628483897995694,
+		14380803034817149259, 11042134597430846555, 9992762805140200547, 9895143575678511242, 3228768306004664915, 16153114680219541243, 12036181641761325912, 491369524302296324,
+		6378343037075212083, 4634622317247307316, 3415247351446435530, 5939760313513758783, 9540802244218497398, 2134082884335789009, 15623633842188443713, 6824600547587227473,
+		2021901489047050575, 4365578779519871721, 8603845379677060773, 8929020214929242215, 13010370953605249273, 8071113541575997356, 10681914788594101574, 13369522272664029829,
+		4241327321249984516, 12810477007632864750, 16880581634097860698, 3630333431846970294, 3439918565119627078, 6613942714960548236, 8647431674406387604, 13352599355545805355,
+		12320933424684960076, 8906954611339502145, 16931708732547376267, 6446897311644431583, 13749563256713530203, 11522599770043814384, 14455556215959342791, 9022955938835504923,
+	},
+	{
+		14734199666349771791, 4159865781008764547, 4413963548436270853, 4489431649937855880, 2824856157476907519, 5111945927271461159, 9825486821405155220, 7657332565522279292,
+		8798422177670065832, 1250388939918922012, 5145324733132743026, 3716299737175574168, 14387202892738514375, 10255681359895407489, 8563822744122397080, 18430417713920116013,
+		7857399215288147901, 2593284350589299949, 10086687882410147351, 14407837835956327624, 4469878646287387405, 6845712208092605310, 3019047164798827279, 2760591274816994522,
+		10930605176025081830, 5850835312463207607, 9603163404664606781, 15623771803942139684, 4096748595672894276, 13060617166821837740, 11222939712741281346, 18445178894593253710,
+		7976335583419810431, 16568954524837045521, 5581116346602990350, 18369129318179031997, 1930478946186473631, 14255806344323769850, 5302512325798050097, 10008570767203424472,
+		929118050943456183, 445163760697913504, 7208246135487165437, 13565354217377841149, 3835063466770003968, 8214155842021576753, 2078717035803259674, 12502657820500987763,
+		17741004372977419914, 16320851348541958575, 11853008901690968430, 9954777341381304447, 14274892887030297417, 10721339848307167540, 8731332510371325649, 13676383433520290197,
+		6251805914672095769, 1063060143452094078, 16647397170554915088, 15454955736319919321, 11509235104607349098, 8441647766544589978, 956121464218389431, 10752793912033728149,
+		14879603883666664508, 11158422912437249402, 8667988090392051507, 12702057193823135575, 13234479167199208223, 13752955092077643608, 1117550756888145931, 1184967682872965330,
+		7004802666964716824, 395433501626287206, 16674151908279399004, 2279551165611331131, 18032555740803644790, 3573953642384243989, 9892480504006025100, 2397759375236735831,
+		15032723931727013905, 4176673226777913017, 7270920367565154969, 8867675920919464620, 8174119413251699506, 15030539680120439131, 12325981936900309518, 2932283844656871802,
+		3227890727136855788, 10772277744280338071, 10065219931092397730, 17233706446636791341, 1372997838851103811, 14430098741859995846, 3290287064497023581, 13054133915521430696,
+		3404625123065318735, 11884832674715736469, 16513753127836546671, 2355202492840722899, 2182039060332057784, 17942518439766613327, 16731345075928062112, 5501869092504492134,
+		15704211025163561149, 14596679078416770266, 10262177146233936833, 12443005669252298316, 1541294166390346144, 2952804996209068760, 15358481016273272880, 1321729586231860999,
+		6862865331233391228, 15106279167311639122, 3283008666555627541, 13405610967904725343, 9845239597399801983, 10764942720093673542, 6506992344666983370, 2483131164245259278,
+		9508384588323002196, 4786531415304518048, 2690306308552249535, 12208815515689370850, 5145548243685871201, 1536915039528215765, 709289946127949333, 7152734178531880864,
+		1555309551759198315, 13156609441579560529, 3264147002083956017, 13629162110016732793, 10295903344220946201, 13835148808782379287, 15646840234722388037, 5850505683234532491,
+		13348528763144385986, 8174978337870000956, 261860806345683810, 4561309263594732686, 973813267913726588, 5812176512716041479, 14361848397565071235, 9009461390894364897,
+		4179825720483458009, 3146850391122074949, 16612045757277946305, 5253713786583408340, 5426943015912173764, 17275032103121420023, 8467860410750483621, 18150546576917688519,
+		12762630566060098764, 9762645120146998728, 3635705124656800121, 3295681695622364165, 1764654124266477879, 16610065552429288987, 12182970194869512424, 1144643512390613083,
+		10286763540130161498, 3400614528650953395, 16801086752981339314, 5746334081386875705, 4489937467701177898, 9249554406360134002, 8258038249111147700, 1922443676251769427,
+		5981893063992017591, 11780456280008557800, 6865399120670384939, 6192294124015342683, 12388377965276278882, 754882660516751393, 13476094069874573591, 1000347292494612314,
+		12753947115797128456, 1864834899756446490, 12873792436322150068, 15420857687427067065, 6214698061215951246, 11174167031334850459, 16378107708672199269, 13073812080094584194,
+		3531275996684891316, 11764951512033875164, 12239314899306115751, 12701224435273087197, 152051042384837402, 47099568832954431, 766394328496626388, 666084094458729910,
+		145223485883456390, 2445564470200462527, 6482144922631612251, 2316071592874761856, 16548688346252111305, 342430477320199814, 17819268336019413198, 9112976726726029531,
+		8272548370610798443, 13910434751574602849, 4252192981011400377, 9590519351704710983, 4172183866405471444, 5567646223402949380, 6059725713353637560, 7169982539312028092,
+		8422701298619809502, 5749403137850675219, 16696307763582818287, 7683947097864552851, 8685161999810728314, 15931494353777534155, 21629333141204286, 14374464903502564030,
+		2354260355218724624, 2822702976206523812, 15817484232297668127, 8389777239766813455, 7962301702220496539, 8489354871723216960, 6637394823950686331, 5853452396705295777,
+		5949957329602421631, 18059540496274524007, 301304345046470155, 15775279105880040289, 15979581939040500554, 7142046514802237176, 9965619645220287167, 14369754349691428035,
+		8777708254369249245, 17882304730732025188, 3127583543205765491, 17274466425160820249, 12870181470212293464, 5881181695848312122, 15338161852429951632, 7245877162563127935,
+		2634466441339054819, 13057158409330115380, 7410310056430957860, 16362149248469660371, 1435827663585128427, 8005375008235415486, 10865470829924734253, 3177600727860863968,
+		9627905753364576437, 12776456422166281355, 2851899644189834214, 16998174196920379994, 9001602524188761177, 8960294999163663712, 6580949973363012183, 7568306074815116797,
+	},
+	{
+		13345381996769253014, 6278048669175242345, 15990349685835870151, 16358261962292186792, 8505261070637963021, 9396725065098564446, 15331953351049782155, 16194796339208321205,
+		7076257175157660597, 13221730879315432464, 4499548735964119085, 7559253754663705944, 10196808438730350168, 2391718471837563931, 914409564589897387, 6649744842278078706,
+		5502356275170104522, 12750322860129485966, 9581277511584938955, 3872282844937972630, 13668854758739140874, 15020438121087800965, 4581631138384430657, 13296613956093963588,
+		14380343880230315251, 6834909096379668102, 15975839936772635678, 7738230945027714388, 7971648870467745046, 8320128435052726628, 10820026056424631461, 7058118462476293754,
+		7264036154081699231, 1304060579978677195, 18166928140052040308, 12593450560996175288, 16027666629366472835, 3677101504316839585, 1477956412235870359, 11566116495906585190,
+		5990066097615398579, 2092999434824845091, 774626818169813708, 12815491981614523669, 6993666706115136402, 17707947501239782961, 4907798919001453899, 8644498548438963907,
+		10893744790193607860, 5425031394266373727, 7829758685118664025, 11448863214220512751, 12538690882574195219, 5021176303769859871, 5820297470465439264, 5119144562842414323,
+		11165438517321289842, 8661037418831619311, 4401480924846865713, 9355650368902126256, 14352422544185763829, 12268031594529744663, 17607497268577344783, 12698954426769962214,
+		5383780168621648368, 3613813760948797485, 5757643543708300439, 11434310585555684688, 2345981080034027974, 17817292757133028083, 18327982597027759229, 3812144950722314021,
+		8792386854586041066, 18039588893139878329, 5501406599000558473, 17117814302557684702, 7341401626090786647, 13233670006052290433, 2192568639640447778, 8946253989965365943,
+		16557600339807647183, 3024845786116641335, 415867109882960964, 5024769423994345740, 6707880221250244075, 1889203596997453159, 2063004021323938442, 15149146696320496954,
+		5091534986326281709, 8005812102849517353, 17366496686564185717, 3658878980438307796, 8455810244524637026, 7649393961871195909, 8629386422022530934, 507133797409068858,
+		8757568869745664865, 18237318628906764926, 3340648953867756474, 561136277959994100, 7271097445297070958, 2011054670254573698, 5452809131990689118, 13469888024447314143,
+		609640447772904263, 18299734743899574512, 9082773418653747144, 17312950936823165983, 8565594704932296493, 366163155689429929, 12596423288683198842, 6787120926470876217,
+		18404298100226778075, 8425329164435445437, 7431919288426595458, 10680902470574406179, 7944931189168061880, 9822761000408762356, 794258562727155839, 14627123549563592012,
+		10098955144981013765, 4095621933458866623, 313357785962326778, 14880249056209398407, 10605627454111004262, 7841561005378789988, 5015399193497762029, 5818383539901203899,
+		486788682374900660, 17535646661984222270, 10786441143551223569, 9744277172896797168, 3600223448942144865, 8847805713765285452, 15255336563751266306, 14792236445425212896,
+		1569380763811592357, 16850350231819425451, 14974316825768144065, 2974893813338477794, 16726324408135381195, 15000665607479486464, 886632233152598796, 3783793991897659851,
+		17267037371866619240, 16498595171305365582, 6453906744948258368, 17267405673163971478, 1676214913570622682, 5051819157163581842, 4315279707026326708, 15525840981760267164,
+		829322392873083372, 3459913121476606612, 4547714508342797986, 5801286056105229312, 11591136160675314269, 17965845487226778560, 7022309609363885527, 5990586084398664157,
+		17415594387520595717, 1453256163777911406, 8242859112004661961, 17561205531134219898, 4881570838375824387, 8392772608437744175, 8797957464506597080, 3142154188155936579,
+		6248409301753564092, 912147011448492506, 10413108318416902948, 3349445377400918439, 15887909530347096066, 5138859116738406557, 10990929831134698266, 5911273060564729281,
+		5197581879950405305, 3001975514736631403, 1919678782193534342, 16811100109848336275, 13086769249238533805, 4351245282425706500, 18281601243717625371, 16799537683941038764,
+		6288277991521986035, 12231480617236286340, 8633990423689180869, 13535190275290488690, 13419223868164389899, 17622732596713666209, 10071779220640400024, 9451660464882303005,
+		14029940454474238624, 4957972603307996503, 6311878080193524221, 7485203809274562760, 14450074580092843779, 16845073066403496624, 15870387052570816676, 15700883809468229388,
+		6623653867803819118, 1037643671564549885, 1236506073247459642, 2997396263933967582, 6182371056378366305, 9773995232878719062, 3356495419149379609, 10710833980055523526,
+		9965766500412107699, 16895652751136174589, 7310937934566947318, 17649841370865305295, 5052693369483848536, 8093060855248113928, 15777336335257114359, 4642979535698186085,
+		11761084765182152401, 9226969173242076459, 5445719591917489914, 9371133174853825566, 18381867235964583187, 17262888224001222346, 1934253649802391267, 3574888052111089863,
+		7862401495691359736, 674970329153306547, 14447324101549742216, 15408908436196428001, 5339840774639473099, 15542473999923245378, 17353380999887736706, 17787369898686553525,
+		2301964326759931592, 17775852221342579469, 345763078096690431, 5079606662887837532, 14863722102334084051, 8905941255852264870, 3806200576416892831, 6668327519801544161,
+		3672519063263749482, 11898207454593385701, 2364050348970898536, 3761861796987022528, 8159458273489411574, 3231262679605967088, 17179214124164291006, 8770284079122589350,
+		15270079546607712667, 8471883658965202468, 10333206241569264742, 7414741159725097798, 7709713706668701850, 4461310100162632915, 10099194304024685274, 4760203118683828795,
+	},
+	{
+		7237168574323016859, 17908810107504968137, 16225708127838178121, 11127095986977103648, 9346291308317410251, 7381283458277047010, 15168602815371846943, 9193719743691734294,
+		9607254959726458411, 16837156817186931862, 16178143308706847393, 10970721795101931539, 10840376278605273092, 8298765077094727469, 15520543037910966843, 11484620381947762562,
+		17395070963094117711, 7608132718922490881, 6531178971071758016, 1302814667007331361, 4002629363862769670, 14649492495298089937, 6868174210142585697, 15456170652716048683,
+		3688308493559609536, 5123828159813683938, 6245436817220183971, 13062234263274605325, 1313395302496832996, 4961840797708687855, 4990192311341859196, 5283131006216350959,
+		16952735659396950704, 1249482796824289329, 17859504101404809981, 13260403650830168625, 1583343855370236084, 11389120333403185826, 13676599385745755008, 5066667130137739346,
+		4799264864906918301, 18347145714884655971, 17034125441088681346, 11828378178487279470, 1759038296522081901, 9582407833575609381, 4195817009050503354, 12618256395967210055,
+		6486755100213398364, 5270923715575268322, 9268255346880651103, 3147724493117082267, 16710318779269985633, 1240462642985509644, 2400811796254219369, 13670743068809614358,
+		11437779990773246594, 13609113239383378152, 31268927496646090, 11618772705165035208, 3078024460365036167, 12138983306908962712, 4779157919015181380, 11901698850260672002,
+		14642787507945832432, 16258081639927585935, 2560321462542164242, 16286882196975458174, 4328159372518768969, 14313553865397841147, 13769372656320240568, 8950675126435331579,
+		1309709344837422378, 18403288028608342631, 17102350491414677993, 1133523394849437315, 12526496222782003755, 5447309058259018864, 17311120581405946631, 3760058661125144368,
+		17891474172606596407, 320094264574086461, 93927075222964142, 14355817838636249140, 1777882427773785068, 8237021421587560510, 11520559469641852991, 10567910693910023157,
+		9164300764173563614, 12322279811717869943, 2768902015676238485, 7761799112151133995, 5740162933856370894, 8043946608495226840, 8923704438836381869, 15189322655373943849,
+		12046275966378825708, 5909386969214935556, 1201990704907881028, 12128549009950617306, 10773478878317625320, 4554854625564648958, 14029736945871573056, 1353247251064221090,
+		11909123603272307101, 5517949035179831783, 3295386484950432959, 5605137795524476293, 10718654547602473221, 4984952409581272095, 883267724006996723, 17328431094026829348,
+		13671210467347025770, 9980617617519781731, 8339868735163579231, 2150724314757661915, 8571153021065445899, 9146903697769397191, 9122246102814640373, 7744779513085605450,
+		5733697799130763963, 962857090393715865, 10538932452511329419, 3413281437172590207, 6635428480179771287, 4404718679994229138, 329074170931436370, 17746708206910902139,
+		465623292609655544, 12740391094094156750, 15600221933467635716, 10712500242632508096, 4760789577759901270, 408323003115848014, 464706673403009712, 11801112998381624421,
+		5545681129476190458, 8725689673989867696, 2143812364199804063, 12133065347666807143, 14072918710585286097, 9027361966934517640, 12608281386782336413, 2053972384317260152,
+		11862793362110657447, 2615766363986534825, 5065170482898519596, 2878903691735623036, 5204682974850023849, 3382494556217615091, 15421437169807703253, 14936317525837021790,
+		12363228588136583724, 15035239525394825264, 16312817933687103988, 5294641777817034798, 1197907056067071148, 13084871057903003628, 5240492218216802394, 13798739245031559476,
+		16167519903361647970, 13106036157861122437, 2112866661358918425, 941609107359251234, 7240286582201258992, 17783018133711208779, 10433192833270769862, 4303514224506582113,
+		1549168540255262874, 7958641388293572779, 17867057222043259063, 1752211085999288773, 11828273580240483781, 11712913016012991853, 2373360154803731890, 6779610934665321824,
+		6633997178003959408, 145323909693817907, 2198452664824754574, 2920221908918689777, 11047294234593305837, 16840329825128198329, 5479733463453508239, 14054694221361300990,
+		7908792292118068471, 2703859967221946473, 6268006869726038724, 9406994672213611166, 12424098071734234719, 11900750387777467409, 10724482893673149484, 3191937460539390989,
+		7635348735946750413, 15019610708452651937, 107671898858364780, 16808612119435524257, 6120109999123152232, 2251481693156523545, 10792076820325151003, 12924551065805570215,
+		11225852067204798645, 7665324911993544151, 10402215331683389905, 2856131542917118235, 14152013119539822346, 12731746180172488022, 16402457225039188820, 11129045951416314666,
+		13009066459618795885, 9636541685854928780, 4783713672495759319, 13224924194053497016, 8044695420996588716, 4054951559323242873, 8718047667110955699, 13479622910466265834,
+		4333570709684826136, 3188483692974505359, 17976757824852085147, 12585927226835238762, 16665346689006249776, 14033419552450595393, 12216049696243171604, 447536030797427204,
+		14100792221456700414, 11757964686555543320, 3971513799111193530, 224065891283865758, 1282520657830780512, 9120233956471705454, 13711191981326748211, 3725543277190035504,
+		12094220323799678341, 16876894723130932646, 14806566188177921577, 2283878370700345373, 12254260799985999571, 12764268124075139223, 2425316412794046071, 2088679341162220742,
+		172600248248909168, 4338060849169481673, 12046085844143054569, 16220699277291497444, 10358794035289405365, 6739081270984238196, 16079387007561085178, 13471688054064884318,
+		179238781994802586, 9017860544212172426, 16179187983079961859, 1380105261896053495, 6187003332254463653, 9896593306091975718, 17181949235068293496, 6820143159816507763,
+	},
+	{
+		11156900805411912784, 1737275748212365168, 16993486692205800040, 12538938066475152524, 13167476167764338790, 17373319366642541595, 6054831428930905282, 7118452124011953000,
+		743288751022377974, 9226164090128370715, 17669221687181604232, 1117842260351396541, 17697784451833850722, 14382209306891991103, 16951372733687268016, 188390802712613066,
+		13268209255833199938, 16633146482265079265, 6044233937395578074, 1733872861371247406, 14239198956565602758, 4036306057099495106, 1778912298053970082, 6174082695927204648,
+		6390361653475754940, 1093882175267357438, 3784079074949811167, 17343872969822169769, 3359715652121662979, 16808529787251986583, 5169730697018536870, 52766949850965558,
+		1403521870654810721, 11668153767441183906, 12890534559297323775, 13255750643204945388, 8838011266491753399, 8488733891344199335, 7468199299966346977, 10645543722243906719,
+		17019046551094178629, 3055711824867115856, 10841870683594132444, 382072777978364200, 725450988418371589, 12501774248954630111, 10130164067258601487, 7823254091037946722,
+		1866199290196467180, 554488389245696218, 15654194385091454776, 6131785419830586829, 17856850737824439617, 17602611196814472081, 18244498160243832872, 5819736122106091373,
+		13147212495082910072, 5628914243538540648, 439989514095330941, 7620472329041817834, 4272251824771633288, 16564977601507013119, 5441117136715882317, 5622571730905974389,
+		8706277077547369587, 4848592786700984858, 11350018329458740004, 143688324288835298, 16536982722430328270, 6522962371020150117, 9511378862712142567, 18221873727623821967,
+		3985496688414455558, 11118602672015528143, 5383196298446424580, 6116994806363767576, 4051800833472889243, 12236802048340231756, 2619572929682123355, 6008593592518397571,
+		18159379849046931840, 11283007389905902377, 7465803490016928282, 7730454089227756796, 3569936088077890000, 2804205711716327520, 14107136042131448408, 12050401455009236937,
+		4207421531032215145, 7924589143024019458, 5496622772676523695, 7061817399179278712, 7371689806847905735, 8282663810521090335, 11422487361383982601, 6397294642072086677,
+		15924576759579234055, 9923512276109397968, 6142441356128988365, 11189756906743802872, 17790684027455851021, 14143953977451478354, 4002828116425422775, 7521923183240026608,
+		8349314793194266723, 8850246337652136896, 16635419760398709839, 12466509089914036008, 2686508850003621675, 15822032015692543407, 2211302095278204426, 12550915236378020964,
+		3844358527917324404, 15045102416646491178, 558560187822263769, 119801275176287297, 15593003307431898979, 12817356186703401527, 531419248069516921, 7957931139148417935,
+		960381383357168877, 16774709963697143275, 17896181076874992240, 1150415168189819777, 5498481130530161530, 6895900060791069290, 2079514944189747822, 3428689507902936354,
+		8525743843643076774, 6014251588524085384, 16423924202355808346, 2605496565158241796, 16676209604549923678, 4870342652354143869, 8337072895802905281, 2478197702680510974,
+		17076629945963768258, 7647523525256473652, 3999707005939039144, 9578933944626939348, 10469359763046002307, 17515033080264359276, 14272203721184987484, 9979666177276073145,
+		3896303254672567310, 17167309259158926479, 13231865857998180315, 2260217573257466310, 15465674863730076330, 4460025914284098438, 718707264700157542, 7215235109325196153,
+		12056920178557394302, 5131253251712581899, 16251877995882633963, 10883064494054484051, 9473274815269607947, 8874308005470196739, 4412709653190846630, 16469366225886156991,
+		13309932065155297376, 11504232979548718747, 14366229841750030472, 12797870458094162590, 12894694064456675527, 16977997035748966590, 15080606548583635864, 9292471759789693596,
+		1226107676031264801, 2683510924831720521, 4344623677417870872, 6581244316153602113, 12516966236091151915, 6758725397469564403, 3190083750600883646, 13018714111448482165,
+		877612159223846777, 1550479938877814973, 11850498481046386377, 18144061425551419288, 6811504328538189985, 16351446194603329949, 14495016749549056145, 15394017693349630053,
+		3547198835521135552, 9940690805769919242, 15170549880149605690, 10701681269101530298, 5914809102954412895, 15790219349994701461, 13664049285300230863, 5735249081148743651,
+		12395092509541605535, 2320592554345067500, 14213227630916688382, 12847883717490005600, 10192971941898238362, 18392117086623245662, 14369915478097042954, 9636190568462370402,
+		13308009076055104849, 9679299541833059768, 1512845037409468381, 18211703514703978816, 8337549295001075127, 15882458005321062689, 1212364284844818969, 13856780176955551126,
+		7602636613718406141, 2678224565451628558, 6976331354727208830, 7414684104929828967, 13536889690553324858, 13086024708711030952, 3748455179863046304, 1853373561223967487,
+		14753645881295168970, 9410794713982813264, 13485977523338061503, 14267793994973767571, 15813187206361118954, 16449603969001878152, 17705410933007144731, 10960511750491378082,
+		42380674434071200, 10068881872338405083, 14327149378182272744, 18264050153181932597, 8600790433943161385, 2952021171158508784, 13461070885471956301, 9633226987835715039,
+		10360728550079953555, 8471248683929284652, 6673003382103023756, 8972723925695500528, 5941683993959582947, 13500073059240140624, 17856131583218769324, 16799784995825923732,
+		7292102941225494742, 4807816512907139693, 11271815982004383122, 1065441269547643077, 5279915279332961503, 12100441009657772185, 10448964764090871372, 2944169874578456259,
+		4669722990542640772, 10017368027073540045, 13392819319228640800, 1070815632453829996, 7274130058405640448, 4460835865761538026, 15283885107956150892, 5815884817303156137,
+	},
+	{
+		987127652983079722, 6872208513691823695, 10110578719299008714, 16457381243184327116, 10779072738879347999, 5965282398006505989, 18251577267494363268, 9321323379108563422,
+		6119049170407437179, 12938407708038792521, 10105420405825346383, 3416306788177016826, 330648587825212481, 125568991290568141, 13857127346570918649, 4376080986981308805,
+		5930434126597036589, 11240994623469578584, 839346533006694594, 10015087329724081709, 6285097815938761787, 17244606485954860090, 11523249727882012981, 7178451948850151803,
+		16733615335426327004, 14833564736134873977, 15736159435317472941, 17560193966711884894, 4670172300306758374, 9477713670983496835, 14243955354032737980, 6459864769649694970,
+		16053517698989562256, 2069464650596796670, 18305730134729303993, 1090863611964008044, 10595928817546105363, 11743183506441120484, 8584767248013363683, 9187452830514379903,
+		6938579711827578880, 16268282168771714072, 4567473305742437221, 754548046014059669, 7773636946295303572, 8132380485366854656, 5054542590195827722, 6074347500754248128,
+		3955857908381474930, 11852678900999621852, 13783017203403417097, 13616745777931267488, 13189924588414196918, 14519927295809952876, 9334100965942760501, 15172548734242885286,
+		4869852132020793901, 14921212823114724347, 14342559113353033349, 13336827701782657309, 11168346789878684452, 9790480725902426052, 9171116079841529936, 9268902731763220711,
+		4417372365016540659, 17280138652899703220, 6650972319709075180, 11252221422799491438, 6825784270383052414, 18308562203755695191, 4237445205082731447, 8485872406483449772,
+		11718726714045105993, 2624508790343569765, 5794111482300008213, 12819216567095091385, 285329842793152354, 17257707863943097374, 16912487373614458842, 9501952033607497057,
+		13074643344738491288, 8505193022029238118, 9932652098552590323, 267408114280737600, 14802861246220332716, 17506028737327736269, 15929083591675282371, 10937680132245212187,
+		16688733766460131050, 12777635326299184071, 7769405825716531061, 12435979606514844725, 2767987141420672349, 6723940414217341603, 16114182069580717377, 4541113259200434040,
+		8506371389960537559, 18031198550689409305, 11510251852995503442, 1923472385053944821, 6189904387119195613, 345664413118550356, 6439003191582953600, 18344385760549575361,
+		5320548958745018096, 8341561189829530680, 3327828110998403156, 17981346269177513223, 14254804273025688074, 11111147827704077234, 9093333670517437191, 7272552282364063165,
+		7587268797387514088, 4402481408866840263, 11260815389095334885, 14391444701764948710, 4224880318604689771, 2472148458660279030, 961218007313548745, 13826356220879831691,
+		4477325369345373420, 299141931133875776, 6787652129916359301, 2498016036564260464, 13342319943892943548, 11124287719737492205, 2456333599771808442, 5084719026388755304,
+		11208298545009109072, 9361672558653085726, 11597473974277116433, 9123409098329262113, 2315750487079392743, 14788891796020803799, 16477373474431052867, 6394267218565388055,
+		15099803091969065643, 7815556206466442264, 10304177785190927723, 6493522556494567776, 14386173575053274652, 4399768637448990408, 2996083572119906777, 9762267038999270167,
+		204205141115459509, 15145142808374731170, 1678672167166598389, 12032976094920574395, 7472791648310888425, 3687068899306742850, 2661021646792225638, 13705804163602287184,
+		9320611303424530507, 7295004960403065170, 15749376924513664173, 11543669941217924178, 3710258597217352196, 11371260298937340150, 3902566672028686120, 17983841473999282668,
+		11814188798674654097, 13017429106091059634, 11079902218909650978, 9064898043690914606, 12023954026861289442, 3592879256613061321, 9997625973577562433, 16073808232708438680,
+		15365030910001289574, 8789654976305207659, 3460532362538090307, 12992239135084766157, 11449242863169591803, 5418502644558230048, 7981056000757137731, 13021725301900406539,
+		7782773734814780443, 9390379677704432300, 7130223982341575476, 6496906770393189740, 5095392170846288421, 11058865093605824851, 11021902438459302094, 6088242418938968652,
+		5966014717657529537, 5136588784988696205, 6360472729290909457, 4447169061266082500, 12506934948427595318, 16433395045878253504, 5116318868244944213, 6640832565780621049,
+		4132920736998081103, 11827975663170283136, 379030309731223785, 3149051804072184938, 12035317616979166548, 9642536337674500310, 15531497803043399747, 14399049832547796531,
+		5493097462539196248, 1629980144571354138, 13641173578972112594, 11096917099468924214, 10934169048860132281, 11269991112518485434, 11206050457519414207, 7939067479736521906,
+		3806755078949823895, 15988975666336042818, 8246267395645554105, 9703363749164024623, 7795606269507901456, 451102251659512683, 5865831186929065346, 81064915983990550,
+		5810137226573964106, 8424253088401255706, 4543883508937971494, 7386148745257823512, 1348150366217548727, 2103092839740150931, 8353010273955146981, 16831854467863536537,
+		5095778754322493440, 16577416628492146129, 12288076721910512064, 10563487622054214075, 14620553808255752273, 8159958565993701874, 6712100880095874267, 13203797993773281759,
+		9640010815039549413, 17460773950401928956, 18229977265837445092, 9252634318278265623, 16798979334068219458, 11731856767337519419, 1551975378671663669, 14320102155496153821,
+		10528988339881191052, 3808685834232068820, 1064376960475785008, 6466670187430364599, 16860839938395945578, 8876458447995837267, 7897541112736965607, 10283235741250763328,
+		12246932755942887931, 10842213418139067847, 1827392608284960926, 6961756951208563550, 14626966634382828071, 12653808277900379805, 3359368990539585596, 1190255644328095727,
+	},
+	{
+		10836955050615624183, 6228108794259714192, 3769609579318360527, 1481673673659326756, 301329772189110029, 3574710782304999603, 3037244905687722509, 14442941761397229485,
+		7739110373965523311, 11019153332996240080, 7346010155518751797, 14853737521111213548, 2542883237207113209, 11015136828834421504, 1998601666328316353, 1540417751495800469,
+		599034134015360884, 11263317530774995092, 6667501365379084069, 9844276013103312691, 7566306886180438990, 13702768345615509363, 12525031963170717968, 8463786212988210464,
+		16430555432520738762, 11225321696360643709, 11777973654353154098, 13133115227828884393, 17678738157022850345, 1586660156856830642, 840647763693221003, 8645742354464326466,
+		8067725618510810414, 6229041032854057836, 8025364837156161898, 1290443646630661359, 10991323655842003728, 9346782840170054789, 8939059450584871902, 4772347025802041241,
+		8187379062828795656, 14744366698824202673, 17014663804743197103, 7704635785366672415, 17162645929628468457, 12942442527592695216, 13291710923558633295, 5800071247768119960,
+		3552067877931717181, 590108493628737243, 497390871097272557, 12785795808441396281, 5561451613221796230, 14263823913216836845, 10481729699001112354, 7818094022046194698,
+		3598736754916501501, 4827022662021197854, 8203180748141933720, 10283251600632599041, 16186680658340956808, 15183393398087319142, 8714402370450665212, 13217902016653171217,
+		13766344083396522552, 3843491774288631026, 1174164282483810421, 6398024882371290634, 5459580537585379131, 5871096222069618377, 9611875286525007701, 1940221124144536452,
+		11598781954647517543, 15695098933552070478, 14976427118847622464, 7147358677856872160, 17135524627354123951, 8338407198954935663, 18099467407613897492, 9025371359994313919,
+		11451018285787631498, 11710749546511767589, 12969419493657624536, 2338911230088800542, 17492614411321910750, 15274296072504110502, 1258801445108685875, 15178229640559232741,
+		11743016372336018414, 6125536020759642301, 16563280170798047733, 14529052521060111789, 15253502329174644388, 1556763737841306861, 3041940064290508531, 18020881359462953336,
+		3035547704692483898, 462291414338050452, 4209186193642705826, 929930084709639338, 5246348806539841852, 16407585218848843770, 6076996892610687611, 16547395936238439809,
+		7781914900266335582, 17967080065814694611, 14677062197599091614, 6667353926398988267, 5658765839564756939, 15807817354312473921, 7476371642206655552, 1194561222317134506,
+		10645607622061780068, 11583886495890779582, 6879987349345299140, 5119348262235800038, 6546217876212430196, 5534845503308945424, 2003680599532879233, 2824480091030475274,
+		2297585344913389180, 13965959247788377604, 11341378863608387800, 9890953382689640379, 10443523266835246852, 9631856696811288063, 6944503116553031744, 10030824122780966395,
+		2699238910420203023, 13176131497943324759, 2961070701879546988, 1511208990650977146, 13153451530298458944, 254163587562261430, 6668642257003911712, 9040693998431169077,
+		5596789796292416136, 10505785820531892681, 3803057245175025164, 13601446877323203658, 7939638174866660891, 14141848241206986005, 13782885912650943563, 6287188921995938212,
+		12999700407775352603, 2664314004284450753, 7085329252118415126, 17472483363754271126, 15550759073378819069, 7572177503239633527, 15705617684783232308, 8586972133880335199,
+		6636244234467769744, 18284390012667441869, 722929822219329257, 3274166388651987221, 13177791837760949480, 2568122970128111127, 3477167651270374316, 11371867850093288299,
+		4065583279544717744, 15575999213135020408, 1319417044854511604, 14713082471342741360, 9399053450949627084, 8900637792268080986, 13511414538589410393, 601556817111475086,
+		9243142430859561073, 14638657859832212223, 15324499241122936340, 14477761753578941934, 14699832840191454785, 5114873517253108658, 7427057898915535537, 12536800031182849473,
+		11775949216482616439, 9736654184925478086, 2941126957776086651, 11331303510371804917, 3535865528819665754, 2488682969529955908, 922100556888217739, 17904958255578472855,
+		12876460969864886954, 4692925517843901006, 17390372170975588763, 14692578774429957295, 1759864963511373267, 12016553435172103063, 13015881292003590351, 16187569590073958370,
+		15154092100094191059, 8103665941237580228, 3265383210728928809, 8341136973870067643, 17281635732314163959, 16433737305161442677, 9130496888060417111, 7070932927684908859,
+		2129695226164849659, 15163429615374108928, 2225893409909150746, 7870945454511315288, 11525457118388411301, 10519485231888976311, 17601979933176863246, 5257431126828903605,
+		8898009465920717074, 9418463821940622934, 3166596280515383312, 14529914354665032916, 17743784337460844568, 15964972678726654742, 17116339264937332927, 17098426671353029801,
+		5868176722765418764, 8429364877332796959, 7785756492654137899, 14975349488807886278, 3272010964035218775, 8946396491617515063, 3774503492701710541, 2113917870331282160,
+		8185651664029868180, 7343199417670698200, 16586532029502206227, 1531724981369431299, 5596507566645246686, 1033673521199123313, 6075312368002387319, 6988496924054716781,
+		4604669688530289732, 1867259042549585024, 16180237500272383882, 3296394050993129267, 4326520583229998770, 6557569103657179065, 4126356691591689646, 8674328613473447843,
+		18057076842177382833, 13020419432300857029, 13646402493577420410, 16962268104464192344, 5358581430340252761, 16443104373870300795, 10099216829282619724, 14890543634568831960,
+		13276631120161396750, 16968574704982977753, 2376454925072971568, 9477134218094425043, 13784622991820528988, 2074505569780291922, 14294803056569335889, 8759684036994631222,
+	},
+	{
+		16549155412115374305, 75977962737081600, 8870825488941031605, 7403557657089993256, 5825394234709429518, 11978746413791918409, 1876293130790608838, 9416631623519692610,
+		12346821858361333862, 6352722970730511156, 9920942104315084988, 10492373916708072181, 11163323626947992791, 17035282992056675772, 835685192553490421, 12792459312570503983,
+		10447922451077327640, 1515090998837129975, 13498807582085718212, 1212623301098019779, 11573518650162536086, 4823461685803772444, 7289704908733783271, 13167881392748327839,
+		16959954449957105311, 11051594981465026138, 16062472412226411858, 1976004115345602080, 3630495248560019222, 12698191555196404138, 10107923614229901155, 1597725222698864118,
+		3416019089997140849, 3011417601086561495, 6275242351124667286, 14197557183081060761, 5633711018871057458, 9723496411345030748, 13910057756335530832, 7285051335492395815,
+		16774605620279328247, 10223834398868957807, 15781733027568799739, 2607095622729296315, 16499590296954181006, 7576646116121533069, 16638313875339315529, 14296194207652471696,
+		12874411821611501068, 1998417862388106640, 13882642435422318946, 5791129521978463837, 7512934139125398199, 6966283273373526248, 5475728301311080129, 13542211842758381589,
+		7798993150530415596, 3288770257171840452, 13373286069558329631, 9784279046496345014, 15725032660238528813, 16038931923358478835, 6921788930154218900, 6093507035435214187,
+		12194839527972802101, 8376199250979271449, 9055995864116790217, 8125030124567662718, 1070812422878398727, 3950906148308170707, 10121516919638719072, 813471384549762068,
+		7610605259962047827, 14617655900985224117, 16089669078196617440, 10594009761533811214, 3425971360520359121, 1245021768718221594, 16690372892586114152, 9933179766195044175,
+		15142732720676276463, 17435583143726694663, 6030257647680338377, 243683009289621849, 3064238900429394982, 7655019927497549159, 4484400084400458429, 11650860345018651068,
+		16203650576183697977, 17614744533772112337, 1119292890050870301, 4574885263986729787, 8108207498737924504, 9708434439316056191, 10676823369888368482, 1078311554675991883,
+		6876202174636220158, 18057502510666060150, 7821730895845187783, 8882321799602877790, 16220624224336230256, 15562800387021280583, 3043825293109091520, 697130162105054983,
+		5394549491776704087, 14795348078061113966, 14206080764200897220, 4623073019242398493, 5850602047109930316, 13783531993760979209, 14764346975698048641, 8951680172224205890,
+		7302725075484262769, 12572584665857403749, 6499691362933905099, 14476353114356185371, 7381716148644532401, 1573798302334388880, 8128390307766282880, 14547454176248589604,
+		12109367644744157376, 18037756988516427980, 814572839386760074, 913616818805172815, 12974490864633240943, 5228203788953366069, 11458421156905635350, 14534725545904442520,
+		7717994192616957513, 12204841747568567286, 3911093871228418198, 11236736110419819217, 3283907124458179474, 11742518530965881218, 15033771683298452989, 5201173013910789542,
+		13950307561490203211, 2109530041534182225, 16966608361725322273, 17050013487213560977, 6582524050666171954, 8348662591649610062, 18257068567217206885, 12084557407109908164,
+		18134052713971906645, 13522834551049471624, 11796035797088472898, 4408384297249203940, 13184035659663315829, 10318594606381671372, 43784547091343099, 5864759723778872652,
+		273751009786971880, 17433500308695913052, 14095169299451888252, 9384697581863180516, 3670310635026975567, 7512955195757960238, 1061441390592395566, 8687976820410979119,
+		5847434943730572861, 6139588162124989313, 16640425042872222986, 2868461478718351559, 4582082172412426839, 15999623457772192080, 3911979819012561187, 2157661418664981538,
+		1679437503202036379, 3357369754420384657, 14227038694942012893, 10849243658636382261, 14698996273665673323, 15473144682787301630, 12886363027445513063, 4218522843946321369,
+		4305571301049736163, 7569433164869749160, 9286896219015408706, 3061813620853218759, 13836461093317197944, 12893856993043908140, 17368798334120212403, 3507360881370918016,
+		17887381848254057882, 5080557806347717197, 10977337278063191668, 13725230338861893934, 12618602415751234016, 7913767807930932665, 7119689779124353718, 14253582440914432409,
+		16180079775228731323, 7952167928403988663, 17529082815577219791, 14568667835887326401, 80331144542697157, 16190739578357987369, 8688615216852085496, 16668129019590270615,
+		7430615013050690552, 16490141830322172211, 9793941851666815428, 12678643730925993658, 248986629347794843, 14250412400606998841, 7671639316274744213, 198890803142183275,
+		14099347485199617889, 10490379547566026579, 2979540189595374423, 1947868558918413664, 14807112327541983728, 2275659819146309375, 14464189275380358394, 11448352451702208893,
+		6508543885912264241, 11768683250765503158, 10952591955476802447, 13816638967602836229, 15422608700909569544, 2270147616630940233, 11179267547770249728, 10448962907285827304,
+		16734703714440778657, 5221611440144584595, 14517195248502569256, 17256223341936104100, 13260411672715241049, 15406026631864099983, 13737383554048659263, 15455560302156741675,
+		1751310744149771156, 13066379976997527874, 3353407191478085130, 1488844206746128853, 5630044290904406795, 14205180196532348798, 10021323252656730909, 4177092513333669169,
+		16120743770319899284, 12307096057555293266, 15459231763664176764, 889710173957193674, 4419259815443372538, 17256024223837463177, 6105822529166486288, 14459703836399905847,
+		13918155529832261002, 12953608416498491778, 4285102780598248527, 15853935066983430239, 2610351403194505517, 14905969693015035277, 12043976761492019990, 3883507340167876094,
+	},
+	{
+		10994470105201067642, 16033352651464686189, 15774427704233149170, 4596106024708523955, 8854068685612048031, 13529126595187822090, 11509928293490788309, 11620850709434334690,
+		2068337952936280662, 6856444059219131741, 17213926210819196459, 513413453513211652, 5520465604253824995, 12970886588014924605, 12296275668437451137, 16808287251356954962,
+		3413637388791433603, 16937929882486384885, 11215805046681294327, 11559398419268924015, 11697258172757450737, 6137795229387768085, 3190984692021653574, 15347236891154706739,
+		17955247196574331290, 285928599571507431, 11902987704297070981, 2841167725097799100, 9281167410796848363, 16444340476026142274, 3423202423051178709, 9101021305726472246,
+		7129792976024548817, 11116052691850916690, 13765136177550464799, 15815419857669199536, 3490265904262366633, 3075105190264147815, 13090337405102529529, 3772589223509323910,
+		1865569627339845981, 14405510401062639678, 16548248891153314376, 18134729633170718083, 7342289204282809135, 13678804825671892797, 11309594694670555920, 6482941613725556691,
+		15861081392207208208, 8373665453512079014, 1489270058265748447, 3594001972161344915, 1115942979837741628, 11080512787291988167, 8129036993725083225, 3358115086982889477,
+		8869273893561412239, 10349812081309865197, 8913824872487209090, 3148808685596180274, 530908416884501807, 10284103744075805979, 13606889938905754722, 2418062398586758364,
+		12413212040240282991, 7478703750955930147, 1623142090654002287, 3800351594986125089, 483782039790230646, 7823394007049468275, 7643246613581822171, 15001087565682987468,
+		4027740097060141621, 11299467443664320327, 11151439614540606708, 866223440636939151, 3440384894029167420, 3873155505711856537, 5954029035616033594, 15381861683078360474,
+		536906646315848696, 4762701494256722953, 3244970900590282998, 13809219136128336072, 6259009038800226590, 15448401588227595780, 5228638796256712654, 52817644221507266,
+		2298603653884322501, 601221199968240092, 1285112712738261659, 13882709760355308533, 13563254433762438170, 13447718334658435053, 13493687958886238103, 11032778298151679283,
+		17130548285854289846, 13389656739579236890, 11825243553071488462, 3295650559395515332, 5681593832990094932, 1986112566735995333, 6900923912677810734, 12885634718618182763,
+		5991348986251844787, 10652959958005297329, 4727138097613835700, 11665606181484659859, 17818486388489237050, 17381457056943650121, 11483713831771420728, 14346336385265122549,
+		6806904066777263417, 13464056321884738018, 6982639430167685380, 7669355554060154277, 5859444273628884163, 13073052226541367148, 9082949662405155834, 12390918296713433257,
+		8626760324117733843, 16403951745962159364, 5837394731212322914, 6847167719031297053, 2888142337636247281, 3409818743436360750, 1677113113408664401, 1222157560539217476,
+		2099068961815044779, 12562181036171628906, 16101890713848274666, 6017764396716978009, 13064414845499489050, 8419967306079989759, 18212218073753486044, 1008986649080828268,
+		14883940931343463293, 12319376897638542821, 12367185247284838739, 5861252096374912155, 10018798299303262817, 6422772579819453330, 2070123940915480886, 12141302052520620302,
+		7347211048650261526, 4324486111460763452, 1238262417801832007, 7620393213816116173, 13629115925647807355, 17975185632155863015, 6751253893269214002, 3530207280414557051,
+		2294668553308381923, 17165287249067859297, 9897724011823072967, 17409851874231284314, 13888575318617508639, 12092766090379658603, 8412268183255186961, 8046572777745318483,
+		4493498909328627892, 14652253245762410953, 5345262207345951514, 3970988687199074488, 2208768899312608620, 1510839623981662369, 642580537527653605, 14940785106713466054,
+		12480576687390709541, 11249304546887636239, 6075047530003410694, 6121669232248820705, 10309256543424460776, 101796817907499847, 2110451750984093184, 10778335615512351243,
+		2885395260584376454, 612553588199732392, 17978615338185945515, 10414937982597482385, 6078565000469652304, 11381998957121196965, 1536418226678270090, 15114446343888525079,
+		13178439025428734594, 16388038968589028071, 16165750006742628176, 17903639397633243161, 9560319088110737392, 7888974492854359310, 16116323630343158496, 10177829649622711030,
+		12866004572891901059, 10190228418101288877, 4717913135317392922, 13460871068228811018, 4756401774767581561, 7711771325649205249, 13695132008344052711, 13361851345229950778,
+		938191787235564236, 14328703178349042628, 10217257468952800498, 10415924210674864240, 7171739159943819214, 6502538915112206091, 3300616451202954689, 9576887970605726107,
+		17259872866446195810, 3694244894150718459, 3214322135693408389, 15571503654130046642, 2332159362399220208, 14087696453363417437, 14318693886833071484, 6131092646618026480,
+		2378363646789710539, 494954399989334038, 6915496914984330558, 757197055392642378, 9097171378505823650, 12104288338329241488, 1905673690814481722, 13011078677095066032,
+		8123217305309052526, 2527408826476194625, 10072980201182378784, 15489255866670747761, 12978131276673936002, 8312787524887306087, 13561211528259491689, 6311660759462081662,
+		16247831307849916845, 8654394682758927217, 1180998443932568506, 3847327552938166714, 17658215545137701161, 11975413369861829206, 10679985684889599173, 14928266362876119222,
+		7605162785889302718, 5718899840342120733, 6057249397801266401, 9486440247354542717, 10618370743126190918, 16153494357430969850, 16785070420314699787, 11277000340020413902,
+		12712274459771886808, 15748114764509451764, 1994630377849062253, 564390855806287868, 135493276425567450, 4305883520257541088, 4842008929542073044, 7035106970720249617,
+	},
+	{
+		5757832545805155636, 17609080533053427627, 13855662030602089892, 9622498683452213297, 12281586442064581946, 610529441714948581, 14740357477019436626, 16983190111725558863,
+		8470173855499872166, 15915210069852758660, 12368087246231545517, 3867174158581293223, 9082358201271846042, 16663463402757176964, 13740908859955866819, 7748969412274962298,
+		13375424826931892789, 8508645806391261552, 18359272328758476903, 16433208398005282080, 13071423254987294580, 7999383023651164492, 14514701556577587750, 4848295889377673720,
+		1020519568493754982, 10467781020270669620, 17607771250627508499, 6620300538436640218, 3858527175523168333, 13798129597334232823, 12495322651937391008, 3926713306087152023,
+		5116038770086590715, 9943789276328255827, 13715439407309914230, 4887040860130243503, 18288477612078228131, 7640050573721350378, 14537362862524718973, 1658575506924200900,
+		18400486168653423966, 18026904540891591040, 2037921821724043966, 18010956304511658647, 3751340308708032971, 16275459031633957091, 17177866831427164840, 1635431811339422016,
+		3897330996014812355, 14347736534650088376, 16862404119462964612, 12216005411754788835, 11561909516001453735, 6261639657930189859, 9101978764314050064, 12280333151331067982,
+		910276569977357717, 2872810615152156462, 1942106118995935911, 8734004121981822024, 13862118436432879698, 1912639548162720505, 13060137938875924732, 10642216911059510120,
+		5132232031613377471, 3053931945527415993, 2695169719602504430, 11855046366025891084, 16462491222215366712, 16664416596202206835, 3077124688577987843, 7109495326459366311,
+		3858762384693274897, 7520194928987242278, 4496744297661574884, 16159343214247089321, 6441167128044578145, 3604951495694157848, 3072075325567814428, 1964798869371174506,
+		13689578474000942304, 8998724267038772595, 3350174507425430811, 15015413657749135511, 4848907595494161497, 7935644131326131098, 385849363817229511, 10087353746314516691,
+		6067717601858189468, 10438404859927821308, 9991403870358837471, 17728358586134467771, 13476949968946830198, 7311235997042381570, 4429835371823736972, 17463216455983091974,
+		3446799583712077997, 6763499387263152328, 9231082163128267527, 7733182914440272884, 17225092062157610409, 8163842076250628108, 14230171836718858439, 8195740716303697476,
+		57759226194841354, 14962480748390190557, 2047254208877381876, 2830450574091058648, 14905486147404440754, 15792397930637469157, 16383409053580142957, 8686506861607761226,
+		11120178572139812895, 11534611317577597022, 10437856602660752754, 13925966850017814278, 16776862023867799947, 17362554889424346260, 3408825299914455645, 2606150045870067742,
+		1119490156854665483, 16772836556735128526, 8607715508817325509, 9931017263385440911, 8799481055779587022, 11740562709785257943, 1956849872282864970, 595288629437737005,
+		2281206023740505682, 9926719762453358166, 4061056930877891291, 15576657447058286418, 2614863633636977404, 2206334532799385250, 3474210873232711865, 8477734925846980028,
+		3340305349427486363, 5188523629566097463, 6160790887356413747, 9863988255192204305, 14066826366866912046, 11932779567129411871, 12863116515340321220, 15222969978942513045,
+		12758642615291604404, 3209096496454847183, 11182564090025111575, 1931382908005123647, 15151007707308352245, 5954868822601995640, 15742433078711209582, 3347972315985628205,
+		16490337555999239547, 8990885971520264447, 10360258506616249745, 6630482203535351500, 16999397485942558889, 6788531264412870316, 7229988042452941955, 9856917486277085502,
+		10734804718395003162, 14385908274213668346, 6022876926209575383, 371182857232839872, 7412466195447558077, 7961511694540082231, 8030758761844457080, 8046696009323575767,
+		6399666206029163609, 17663811097734928631, 11470778017516778751, 17702646621253134508, 14876192013866833082, 12935280981291312476, 1467399042175927183, 8848908916563618579,
+		14359906986235888744, 4587839368531771442, 10497105860390751463, 14244616431904836676, 14906421794748569105, 7955760173743833219, 17152550002849021490, 138081467951201370,
+		2349932829525749283, 14749355610935637731, 14751838563606808702, 18058355029195133983, 8461199524627795693, 4219910612621001507, 12776964042319070094, 15905069451612157329,
+		1355498131832429384, 15975585519420207244, 15757549940022310945, 11357394570768845273, 8197697208897202922, 1901621009956576265, 4290101364365692172, 11947148614241269523,
+		5840762872471677309, 7514977007446174348, 1527060545570586419, 16609099121469101859, 9320342325870097548, 13965331598495025936, 9683433385601741715, 8845290689278472178,
+		14119395813630029665, 8634138112335652518, 4658233985292819043, 9622846971166516113, 996353694479629398, 7404001202059682426, 18145845493517798921, 6449664057746980028,
+		16521775738375440178, 14142357232938693849, 10990147202113110230, 9959066954415780230, 13034621383041722634, 5025797339352139456, 10322111864643366459, 2614961497496501105,
+		12557910439954509999, 12230084394391362713, 8427020226737465235, 12518021396913122088, 7134271418642259845, 3905501389650646356, 15707807001177039585, 2909191175572717037,
+		769225015796913609, 8753059944613840368, 1611869096690868003, 11449828005116201197, 11517191665323762104, 2697717476879599241, 11188965056705006770, 6249359019890699508,
+		15594613737645580981, 3037156291483237329, 5604071908229825169, 1604475019228431078, 7766918222574600204, 9339455406279970318, 16266564745812517195, 4799424886612563329,
+		11601570184515356415, 11247678357869162156, 8415095559389686315, 9625816053586466047, 11807876143163335372, 15690209134241397733, 8684637224468015605, 15974968144193406020,
+	},
+	{
+		11275984449259340674, 14922638629881602958, 17186426309348732477, 2094500549052461127, 1245672419927595636, 7529921141299797945, 3181089597449057707, 7749529014968942143,
+		12842581296013847382, 7845624487558348664, 8747439372999364825, 849305823897878133, 2217292264321907974, 8173534404179332054, 3588643190593022889, 12047811416592660080,
+		6959527445237219799, 17170778245769606301, 807762173031474321, 9151445233487017286, 15103411489939446333, 7976669669591851659, 14824323986579638641, 1535817133122800221,
+		2365455792963674834, 2249234228455309648, 5237136544555745182, 8814246419234451463, 13017813702607013347, 2241193992640629733, 17982226236989862510, 9800528153239873634,
+		14106286229675768856, 13210380707737857536, 8049798856134302097, 9734560649539497957, 1623205786926824588, 14287958304696241706, 1800854015662052826, 1212925137572581937,
+		3026947385483276729, 13169758424754896088, 6834174387382969128, 7206544572805916922, 6934064062491731757, 10620406409375153308, 5194048681860016706, 1469688754160716493,
+		12993558037376222988, 4669474265806332952, 4832324179281001408, 4413085485243863075, 5405837906169635761, 10091776239975644239, 5290719555562061144, 4213669820858776415,
+		17271890190678399664, 284117971978206043, 14999643475704678808, 6264699496666119083, 8859934981351804429, 8300880062060532031, 3667839168820458685, 17133003164910522197,
+		2997449698566957466, 7884833253198684528, 12498695470674374226, 3115564300965505022, 13376506794876055601, 17895331353362057251, 16990581103090492269, 4674862843410794096,
+		5006430925084708381, 16053115139414023422, 7049813739763202517, 6676629839394309180, 2410666182773729148, 8945309185393628712, 17674821778351929167, 2683163960153153804,
+		14505459891908974624, 1849503921080779239, 13990490450160111440, 5181610498614712941, 8653117877167770474, 8814499350344722617, 5343755460620184433, 243401361005198353,
+		17791633957402883820, 5938849497629314459, 8356801465373786047, 3163889445599730677, 9723709910898285412, 2841967670768995554, 10896757438566636700, 7434996874241771203,
+		7372440365321345784, 2862880403174214663, 8420116322934238724, 2818552325655576635, 111342786192022359, 74705672003306783, 6591511741514218962, 13124391319573921957,
+		9931074113040228488, 15362193958291437280, 6613002366394890474, 5258448208225327677, 5126245224005997831, 8755434042915330962, 4405830479557957055, 13343591337768921462,
+		9242810916685205316, 2838356272544913798, 10099476622515682546, 15551100165305852662, 737838832976059770, 11188026425234857295, 10166119013055947704, 8628233674684143419,
+		14086272070125896854, 12009239107306499026, 6592816798466831203, 11371087141421707743, 16277593907837607793, 16449564916599232060, 17471042072158213549, 11953382410698485455,
+		823047236880870350, 7830286704456953572, 6464058012664717582, 15521380082330968365, 10182202815901986450, 18143527955004661429, 3207725716803325445, 3193887560605396493,
+		15569872930692175382, 5346306686087630019, 6632365629111827330, 15865883909120927399, 7200040798106687333, 5723169387900917854, 15027071603483375844, 11018037359110138454,
+		741009114382240162, 13879961246490269823, 4790141947869766711, 4479737908710468090, 4979904969974036721, 634413885118778288, 101727670723732801, 3160663692354720401,
+		14613304240735929191, 7658770973133328064, 3028731168325633068, 1486737152001467114, 16715835021406106944, 15214200823642287507, 18441898204110447697, 5669963154424393607,
+		4313074171267006471, 16217697149498819074, 2027993870023154350, 18018610229517524263, 117205923522590215, 1784380715025232199, 307956084870608716, 4140912860495129528,
+		3938313265660748839, 13018885466029447230, 12461354215832959401, 14495299413345669177, 16234805331742830462, 1578184208291171741, 17168468892394781152, 12575003872292801090,
+		10424668870965277693, 8952352824982702795, 18017430252932614600, 14101949308713937413, 16342352613992153502, 6862842966642668923, 7238655696295295374, 11216037980129705353,
+		8381651800836461905, 275661552864412688, 5548629401959193001, 7174991431295718071, 7441251258233899268, 14052832476485122412, 301250917807487282, 17797202428295526090,
+		5173263645506172639, 7621852612520351243, 4670271322283433581, 8663786927624336026, 14433502423455668413, 6926265712671351075, 9776903322968672826, 542207238644018218,
+		9588056942118198784, 14024040464098859998, 17712446698584877455, 17945455593410056285, 18104078100936060946, 9565731894604896153, 13213845893767817606, 16043575675737450101,
+		3436179376183792489, 8124476612946977721, 2169106928994773725, 8589833084708985039, 15137137534993478994, 12789920909097626916, 6767184505234754407, 8369097443031908183,
+		16448089571044203401, 1396460397790470601, 9796571033221459545, 8162511506983092708, 13893406727199803081, 16188892369453405032, 16023105002157964343, 7061289566170423383,
+		10448117565485426152, 8145533940921335838, 1579413779055052019, 14761309857236492983, 9815666466018583851, 15131106965446764630, 16986514923298225288, 3751380281663155649,
+		2224143503200162255, 9410177163066991107, 7157489123570995878, 13420515130397093319, 2675717750075873421, 6702938999067232257, 394050047437199204, 11922372120263518221,
+		9930837889018815244, 11397955329795684905, 6931891256005909739, 516538601500853702, 923444815286512108, 16665363217941733257, 1377231042965759902, 8439923996651310778,
+		8743817608749172620, 7804846024944300667, 507107926259802795, 5258061329638283805, 15071070675288472598, 1848743106176521296, 16295570828486620412, 7409462376590083349,
+	},
+	{
+		10223936123327786454, 2321887803300626936, 13607747528117965743, 10456421630388400123, 3266519591187534953, 1053691207967834494, 7151443045753788549, 18124688636664828399,
+		6946488664257064464, 9775328903143754150, 58700362449753229, 7901817271072273406, 5074738678159003249, 18397239731906005785, 15911102965988125888, 9277654580204145348,
+		1874700306906525099, 7337351570334852732, 7954195906114335343, 17230226427261850070, 5181329498860909261, 107167242193237170, 4364856176182710332, 14611171841443342914,
+		10990327814895720476, 16588412771027628390, 2850177278998422188, 11569813740328484871, 3922148781422941186, 3581659216490446242, 3646872304052351376, 10887870617200051198,
+		8175121141368087217, 15079393830876652065, 16766987879267543828, 10582796406546815217, 16832256009371376870, 10042650470778064892, 17867163453935683780, 7123418345572641116,
+		1782651072016504775, 11033882508408412333, 11105300284232190625, 3276372405089292929, 6399472468041061588, 15319690780388315076, 4928530863063375966, 11596222198340277418,
+		5452424185619067445, 12050433097586021281, 15018766900844679217, 273234254926088220, 15426383635547379531, 5213762666043737626, 2829185842069118470, 3230799283770935127,
+		280030342772428106, 17354882606189694746, 17455445295460080284, 18076709382926018941, 9895982528034548913, 13681172423928175330, 1656433131309057012, 11935757350437721114,
+		14437472586336929440, 17387041914242263390, 14861577074379746687, 5146556788377906297, 13036814755814090195, 15108836859245573802, 1667563994642521213, 14722845469958372258,
+		7781061995240980266, 2066078418484154391, 4089376589847114892, 2434843609506038666, 18376509832460312721, 7187709121160627756, 2455436656049651823, 14419116837518875372,
+		1270185079976403265, 9214436628411717184, 15450450827683432913, 2880014804806096082, 15448799931519826757, 10080240282127928735, 10673974088219619287, 12998944469117087518,
+		18028691745165748687, 8931519595829275195, 18379893031942930865, 12120980098075498008, 9596371470855895261, 4133427878071274570, 13159312399982591699, 1639865074052258019,
+		1661696187746428348, 2656198437014978712, 13769477291975851694, 12512848714492869444, 5980926616932344693, 15821983893144953005, 5816015630031200526, 15887565799959254415,
+		16463929919291729278, 14920112063826664828, 10056471508435050704, 10696267144984026763, 12049530292963090991, 11926086636123189182, 9464890378472966538, 9719194510330239601,
+		18110249193861022779, 5612784685592189906, 11360454032996393150, 6795401682138043705, 1961398978248902107, 8999847457729547905, 8941741619641401180, 6086938661427918241,
+		10153847769616409178, 16591913677701651064, 11369151065084080884, 9493662847124813178, 14299126668179023903, 2451525064998641745, 16055696673728703463, 7600736037142850105,
+		3331094657189179723, 8579232659787725167, 11007434086335446933, 7488529659250917009, 17217317841029490639, 7202184784979805220, 10955913831459448069, 9000508720500651545,
+		12966352809478736412, 9643078159289928329, 1577471789984999485, 3065864601417367655, 13683627106599504109, 12782093364215596525, 12883456287502344466, 384144415368165580,
+		2010495664660209855, 15520744321638216967, 5385447087428594566, 12897496516555487055, 7343279016502952747, 11323820480524965410, 3414484402519450292, 2497721392671865580,
+		16065061175628739123, 13981641072236579791, 6942197664821630380, 1667302033233547783, 11254994815452647404, 5265777633437443003, 1242523090981771320, 11333562630675377559,
+		13967113064180443992, 10679621597408504672, 16223869620849920309, 8813286726524283182, 2000697484240530777, 5417120625530117302, 12109041278382745291, 13257693171778388584,
+		11737174095432286870, 13459661128718998448, 4655386724404378836, 3119616752887818891, 13324285182058113375, 1078137740985006431, 1610820303976884986, 10433300853468291587,
+		13552049979590080822, 4379357932546858489, 7594644709024650108, 7268811721525297059, 6728671136192921869, 8183021491392757516, 6569378188404015319, 6481294988812800823,
+		6071501855022377789, 3805172128285889052, 6802689634429908933, 11713310861536728752, 18291420299754708339, 7582277238191809023, 6183429490206797252, 10452668103640934631,
+		16083971675285095468, 2965035896159234764, 9379493912871845724, 13109394112987303523, 231416620515766991, 630445729708227114, 10015412267172773636, 18104521419340860951,
+		13169770634232644390, 12462964563528956096, 2689434882719314440, 5936289129999384022, 17773436345927091892, 2631892834965929605, 8167719122803587721, 2458223071457452931,
+		10744932251818515465, 13367480890778627284, 15909410072235544918, 9252559547875570290, 16355895225285344183, 5115003811789024567, 7369371640924666845, 4586532908333332092,
+		15999516281080615520, 10972478396135936147, 9002100275598932738, 9043399249857967875, 4975188939801806064, 14240375126510021504, 4497218436093285729, 899858725260616391,
+		4788026362409273347, 8940774760122210910, 66616358927988247, 13054723206705508289, 6256911511259454580, 589353691478007084, 17831732841616807303, 10847300659030294141,
+		3016120727980669767, 340560476433708073, 10516500208515875331, 14933811541787518485, 9941997565508314935, 9752941942651093949, 1928238223054143159, 16147782066840428568,
+		8953947187833770878, 6627103431982157573, 1279114735725952920, 5378128106441279737, 15447712974588571571, 10552843735673449739, 14956126644414569830, 1994513099978508850,
+		3339871688614476269, 2937156932445032796, 2071344655111136329, 509603454456841298, 10929109734329673813, 4531629375826317764, 1802431569220697099, 7971315018970882891,
+	},
+	{
+		4307546666223047416, 13914498777427309061, 6812156124789414732, 1680174913762530491, 6756325174405757110, 2535144759174364990, 11263393915003278429, 14767595249676286403,
+		6981289090623415465, 8930069945493884157, 8223216504978132408, 796477795300774057, 3120155459209743472, 14825603392456550470, 3711879425019804830, 11041054473536223927,
+		14135544350792474553, 6171419888118563156, 12495035851387242130, 2843310747449412555, 5668766087526340552, 10117858698838396246, 5181027414039980750, 13247490124270426,
+		10847249691051757241, 13332329214721571156, 12457628412284474075, 17044657510482764070, 5218221397478351943, 6922630493693541156, 6207927102810766143, 5644846665334649748,
+		3169200533952511826, 13123046990387029463, 10303462306703730135, 3315008874027436174, 12427067008037332041, 13190195608614554888, 11930408619792340463, 12881268563913740396,
+		6700154625941523096, 796110091507466427, 5388163944686450548, 3113104467109529928, 12930558649635882086, 7536049463980825715, 11851825635055645132, 2654888532632283214,
+		17530163750522835336, 9722612350417778827, 13244522480616169491, 13740964907388846002, 793235549667461791, 1998252773625399730, 9697911491069876538, 3365596945186794622,
+		6506371904134856034, 9541373683805144018, 3149037850125132851, 7111810601994573897, 16732445693192247884, 4994069681898274622, 7223719243730104348, 5649174084086150712,
+		4640203560336739679, 9900565149463137003, 1093715346388527458, 17169722430093991108, 14911871124664548213, 8091096017016862097, 2911569128494944136, 10192934055727569503,
+		13251895658744991883, 18083873142202267221, 8241707078409323349, 5240943892375002838, 7329419846032881810, 17784005510850539551, 14034072243705748841, 10459194866755836024,
+		16396304393792022741, 510358226971662693, 2002127643935690257, 14681425695950046262, 481902649451190280, 1717807040845239061, 3358903321435525144, 12361252150277163759,
+		16562962997045986629, 1977585352264948582, 15588655103333244279, 253344970359156714, 12939363813291366775, 12548224526376199974, 14450582788883748364, 5869541533939881460,
+		15346378007864735078, 9904337403373774864, 17933855382993937953, 9391248304932723816, 2250334275383247202, 5978804056136420670, 1528238852592364099, 6491566547950141733,
+		8439860020828526478, 8674532462170555517, 13889716766953024111, 1166696901054897271, 3599113965286446905, 3276801695553601157, 6631284861504552600, 757022358659145685,
+		1117291222568805017, 7148845117809308441, 4044258438241699262, 16593433123496068718, 13992202310165134218, 2998204381658279116, 11137382784909083266, 11972581616612094469,
+		13970586842647892965, 3680317572634289692, 3416494470839852757, 8341497967750607131, 5522860734580749818, 6847292760525096386, 9317394708872196559, 8522252330730808934,
+		7951036477225560362, 3718789111033607646, 11667291286820266731, 6927579620295878614, 6796746225018555970, 2070061401518338268, 2452626412419851405, 6130352643925327785,
+		128317967134069640, 18241952544586374251, 10689311587315723515, 16537482248073764435, 15914436258832414511, 15518344078557945167, 15883120902045970449, 16251109112716994957,
+		11957637677355945602, 8965882791601648704, 9390723380463051523, 15025038333096274711, 14983844148312808973, 14488574793452236487, 15795526425513195718, 11651978879566144360,
+		6838341670149165895, 12326189699069923388, 9258908232339348843, 17297038041466207989, 5242182985453021593, 9648294165629935142, 9715128265517308395, 2662662536493743894,
+		11289660454922592938, 470300170724369955, 4571871646010841181, 8724229358245178735, 10173959190953118810, 3611286966550223594, 10810806064515103403, 13571898391208639897,
+		6782514579206442308, 893150666351200058, 2099535232722538223, 300696716419619813, 4778737709473194628, 16786610674618434170, 1751624209281870237, 1677055321500839173,
+		8950755642341912951, 1974922263791844623, 5333377426024439800, 13909803085973342843, 7639604505882407937, 16195074617613125552, 8954461446680048430, 6823359994465290754,
+		6790869670806738567, 4499989093713728199, 17496748050437205626, 7194829324969293638, 18432532588985091708, 12041300075343806904, 7788543067151959941, 13703334460383638224,
+		15088053026772564466, 18172984562199594382, 3119317310593433742, 13835498717175822656, 10015747176747842576, 11008571041665092033, 9377877781626879674, 10465443099481589185,
+		8933481722931715231, 10811948483433850165, 16314247813274714890, 503147444786527544, 2533443680646505069, 7617720894972668760, 12477410920355308950, 422423516920457876,
+		1501843276089632258, 18180777013307233967, 2535426997299341256, 5318958493284100856, 16758265544916918856, 8118598628492446123, 2511013049335776232, 11181447982017705826,
+		5996381448168274884, 8108757135223610234, 8067369725584584297, 7184925262427750366, 8199341143188441284, 13031376443169557016, 16036606349050125404, 11958720833222295864,
+		15336831835795822898, 6806921200736832713, 5959923980569572002, 16835674225684329982, 9985579070716031367, 6517360043741716503, 16609518082836868591, 15878184747124924573,
+		4786224758360153905, 10283234398763800487, 13695837902615591472, 7260571034197533442, 9225062953237806971, 5969706575516748564, 6537573986766117532, 15754484267739133126,
+		5004791824134844360, 4971286291135250424, 1811371968353107289, 15772458387007519716, 17381493577383518445, 14326903440006940586, 14237922492359728234, 6234116464684325431,
+		9293668142017263584, 17134656749295164870, 5879480323258506465, 4788695233340705697, 17809277710857366810, 15157733645094688870, 14143869691462709080, 3162286338158090229,
+	},
+	{
+		4471613312912718060, 13601785177495103328, 8083849806888905297, 9053545412554844461, 1876605639999952155, 6124537911475118673, 16877891074567085688, 16541720065079132344,
+		18138305348849897995, 11498878557125400853, 14125346336359365201, 11991638807788804369, 13935355764550912568, 16209147067155729660, 11086190285777019292, 16727288863943596410,
+		8873152377611229668, 6260821826956744083, 11489383533808918262, 6585112195310961861, 7365821041919648819, 1936165695028211587, 16164747634991415711, 17957320776652490392,
+		13065030057172289846, 7278765836407486850, 383827150208081081, 7832055893191054601, 5249323286889945617, 1631661912887095912, 4431088469837785451, 2866263172993336891,
+		6140213328062333551, 16704025329777067037, 5839832043209342792, 9196354634862869885, 2735762290983671190, 5323501742548818139, 3199127466610501482, 6719610946615763192,
+		4032564124345275293, 240208626666701335, 10264845378648897042, 15608289126091352415, 17866864241918154829, 6207477318890336372, 491708931325462670, 7002400618323099260,
+		11507747783030541234, 13683043390668171754, 9924966309328785763, 5549516466627385909, 3724001483041449858, 2408778220985427590, 10510707601023430105, 12862520912519186496,
+		5012372868660694231, 12033652755433827667, 5960732801180177919, 6089487525155575261, 18400192045204062277, 12754175136438960528, 6170965736016609163, 10141374482047067946,
+		11781193922347227447, 16937876011211881637, 2982972111293427964, 1728244726890919596, 3327997232304084768, 4754833121145407334, 5871027825507908591, 15772493911709624273,
+		5862944033912881884, 11132730978666088350, 12167180155548291888, 16449838286695349787, 14399676610730016345, 17071083123672650337, 13727728787831175379, 7507765123422748291,
+		4883057314704644529, 6606742732149784343, 16070555141087563722, 8408294891669305261, 4298316003054547788, 1573237855902568238, 5357176885445018289, 5855732582172939202,
+		11721126538980357625, 7216004194033429913, 12765889884935948315, 6003399149613653734, 4571046290325663920, 15023470461830485075, 11463513436288928362, 16135217522406374542,
+		14300855104129153291, 11491527690078786162, 5674183453812271017, 5044682546652747711, 9153978680942338831, 400454762074409409, 12351470849648616331, 10559229320903248832,
+		11839166519633311143, 16489041153719856002, 4820713204385149226, 13768001962143023630, 13107713406478328396, 15471245828032402460, 6733652296473831544, 7665657127090105428,
+		6114372925011600760, 13061069979571997963, 12156991017966837826, 12403009591138383583, 5761958709898299258, 1907771304051897263, 3007439379929412593, 18410854883912163962,
+		14408045416865494124, 2442199381796557002, 10475326303775862953, 13637445125954159957, 3778313603630758744, 9247460369874272772, 17572237597883145087, 11338350096360776602,
+		16486104352829691584, 11856560607954368882, 7574789609701925021, 12240083183242127118, 9872957337376856275, 11508929285199799229, 12084460294902152451, 5537978390111837838,
+		17987471707896681874, 13038244305326284081, 6130570860032709721, 13697749322780057427, 15250226813583295859, 11214437899623632196, 11227424166765094355, 16073863048822462466,
+		12399110995748365941, 8259021120978314016, 13249466772279340115, 11201772702582865107, 6680428295197296613, 14825065014187212998, 11638499193934854444, 13944483483619391536,
+		12792956896156056673, 17521293339475028823, 5738513258925006248, 7070317930523546296, 11175557000762820214, 15356683721815441509, 3038847573301969409, 3712495274059632476,
+		9703339902904468931, 6903532388259237787, 6598718994389707957, 3524767540333384210, 17230409287786477986, 398508689507908728, 12956323124513250470, 3050411724956364887,
+		9936181795041159997, 16502578966693139346, 12331385558134766329, 16368402633574222539, 17549179704234998175, 16732353056786161257, 7018642409136068141, 13907639522324102590,
+		3202436334590923936, 10521323531132496064, 17087322194145514933, 2557934785422493682, 1054672647095378624, 13197226692868722325, 1089249862965154915, 6479925079582112772,
+		3880905381896902231, 16702686708922296685, 9815623322445801304, 3275100382267252573, 6882533095211022198, 11000715667767797665, 17615808190378608947, 7418883369171949489,
+		15109802007060416273, 6172716471862133951, 10675428021956965140, 5719399515177959211, 13414568332401128475, 15437234656470291881, 15174397947571718085, 15093134682110367825,
+		12767354263003560893, 9423701226679222965, 15980976879563466685, 16370172902785037004, 8843543841582241065, 16817827501960591898, 1524531339915785994, 11624580276885598157,
+		17147068462804570503, 413038056092618151, 5178874804057490245, 6267545065511948977, 17573054445714024932, 7120476833739422223, 5707115123830922617, 10971108972695387841,
+		12546478152711337402, 3213958910433616233, 1066524299473173792, 6276669942370566610, 14816818963020520773, 7372806616674468946, 12220278123497641030, 4953625488417522128,
+		9443607421568920607, 2583030461169574647, 9900905053299561307, 15892418329702922907, 1184158607153919924, 17842123060489837980, 2681791639846598155, 14394984710894548047,
+		17363678829105605076, 3907856148144141388, 7535915338133892356, 4354053943074081189, 9644954727645503986, 6816908226661921388, 15867806610099035654, 13874346146744695721,
+		2654416582410062512, 9232324386948815478, 13864516581612906345, 17132638924861000235, 16875312639179645137, 11536057026563830119, 1090137303802556590, 15667188983774010898,
+		4336697789732072031, 16054848662858822197, 17934449813415035557, 14518380622432694666, 14100582434152190048, 6262866632984449325, 18069160441815400774, 9798342103009260692,
+	},
+	{
+		687104890149081183, 1938816743979859301, 11342071981175913904, 4270322127259097184, 4964776270155503160, 17849333582861534767, 15814479527332819692, 8083943565773123408,
+		3986890035154628803, 15316660330065019741, 11560940574529263780, 12576851520091035878, 10883944418224886092, 9908329441525486205, 11238684990962507809, 12900626758810151662,
+		4077800412543228484, 7173833470188867493, 4604439809988262876, 8090706047559948234, 6117166546062912279, 15748537214854486946, 16719594636199001564, 563850925691991999,
+		7109145612337154341, 10502845970727626855, 6527587047878193251, 7049690136888681718, 16750703006415156202, 2559311261501721445, 1222802194566919230, 18019462938525560766,
+		322982839910423931, 2590270731903609206, 14012397059804449007, 4254569016772908483, 8508420263334539908, 9175848619353159735, 9777676085150569067, 51565612432741329,
+		10233009747926770582, 4858065366607044068, 17837971428933010861, 10016544790726166742, 15260359301638740999, 5101999662344938158, 8809855615759524306, 15369468763003019252,
+		4549989329927399868, 4866130696079291940, 2784467031729859937, 12617898982021887868, 2721301974598150044, 1014232218549205942, 5446756626431953863, 7315134179045561903,
+		2592184418896595488, 1723751460114310463, 11198512454461769811, 6203707848404803677, 2601731234271436477, 18186700975610533226, 4757569424831899615, 13359873383138312209,
+		7339520839328992093, 3349084091338116256, 16532710170417471614, 4425958052714174548, 16833748535746803845, 12665172019028452441, 11274971974705134171, 6504206221872290467,
+		17921256304121537300, 16573867650874642543, 18439217559900658467, 2917797231317530012, 2415475159165597656, 2027542924210178369, 13542535558170959524, 9428931592662127870,
+		17821420552135083528, 332847653840014838, 11832506312426064436, 8314663852639826188, 5744960486691350299, 8069724388577179929, 7949740770152910898, 7431049632429535950,
+		13904640252203718708, 10747313134117021792, 14667070697514384141, 2600977347774743546, 15498986940124021079, 14740645313274577011, 17403811028932224808, 8060102076475954685,
+		3517334016249952489, 10826317205305313746, 9664766330892822745, 4145357045596983962, 123566849370572650, 6452080295201963409, 15558941970553263818, 1191650177320171029,
+		13303794914626036653, 12135860919529132656, 3620217653879289461, 5443663950311568399, 9020744500355505374, 11953955628401776228, 2101814526784564259, 18218598416910848525,
+		306945432061418036, 3150552227215797902, 12928374347433953916, 13299101042862573370, 13702883318367407795, 4879985767563062391, 17591048490944890593, 5088664549487213106,
+		12990649636107730851, 13002224935892458030, 4380799638612122791, 7935443787987894924, 10438069978940053126, 302419699431148366, 551508078777729872, 366155636877501719,
+		1657628676376133571, 11398060401420699070, 15376723048512638551, 9875623386041366116, 9978954704196888739, 13768323245406799962, 3568095027938899541, 11120740210192996096,
+		15561317952331530901, 10479759083279078649, 16536004935523752634, 2928518661531554130, 736056663469575928, 6131440330717529370, 11275149343392851570, 9601030074480228347,
+		2397968519718544666, 7793046606567840651, 8971792946996316712, 16581860514259510747, 9067804351225143661, 12322425857061932421, 10680196669251962457, 7226521395530060461,
+		14734735764746786753, 1378251478826083755, 13509550209468602124, 14458158239096821346, 5681313138148713219, 9054039627425609375, 4235536482830620712, 1502753755874778370,
+		10053374816829223121, 5956370573575798562, 6842782625116195714, 6646143553705917790, 10487617951080656190, 3930886288654953669, 13141858447548326172, 6966039733711006320,
+		3565931266726110263, 10142260659118036168, 18315406451571961983, 16857333990691080595, 6889519058362658033, 11812045051361479600, 12503117299646153207, 7223531498406875484,
+		15243128568488310595, 13798032762330794140, 4456440673105474920, 17896260893739107970, 5519537045179649847, 11908888770632658821, 5444504459295913107, 5588728973482930155,
+		8914021876030553161, 9071747156187788379, 14974736924255494885, 17070198435868341999, 3643991391224035758, 260637732328275649, 17609644917816078225, 2302996326941944665,
+		1293835161492069734, 5795029109259991590, 6978986253519330084, 10360755458408067486, 9467742127861782141, 9197981630801498774, 6297600026339958279, 1375635441408481019,
+		16875086338187280639, 18188722331528885957, 2047282716697647836, 17808297209051779725, 4756860180475663362, 16103863616340614471, 4416311024167936572, 6340715229216403079,
+		14261984008515151673, 8778722476581699445, 1624620854396291363, 8490568310899028272, 6147263592092458803, 3717414274397202281, 3449154725620836174, 13526832985450537957,
+		5888744936142942064, 17277140802638358763, 10290028650289820825, 1940657436863195045, 10796401239257150661, 7788083050548605852, 13474393003015663489, 8961936186303685357,
+		81364364291228199, 11636155122637141142, 927710893705810893, 1403208391464987879, 4332234662194589819, 7913319387647351094, 2589089673930123808, 5387282875974124558,
+		10611669207938469024, 4491327257859270050, 14129391883837344111, 13924810848449766461, 8792187899775727862, 15048142623570073200, 3933861866144269656, 1162055633060412126,
+		6883724061714130987, 10416279294253729103, 12247033224345499651, 10291073256885105234, 4480789666471481188, 6022169887991948086, 3778647272347441051, 9527380466585130391,
+		16407225233842256953, 13423683834633513951, 17454464203550700633, 6033758555290610449, 5063673994339442907, 12250392784929419939, 5954485814444410119, 10099095370725442279,
+	},
+	{
+		7669790431656261769, 2776517632462593286, 11694025667665633506, 9533794089008895277, 2895611631120558023, 11551410655448788956, 10026541900772270925, 6243136875017000843,
+		9434484992529186384, 16435748047660609525, 16190660694150989986, 7083965852434071085, 4216306437741910756, 2698742177539497614, 5199793642504009017, 17298424769819019160,
+		4041169394784902550, 5699517344009382913, 5306272267462320559, 15846674482556330025, 2606351264228884283, 4162585980422107281, 3715151019132039005, 6607223447043258693,
+		8168579295855409503, 16727569921530031841, 6182114460261837773, 8940603165471931374, 6081572078077526926, 5890840443923124563, 11215305828294759727, 2875117534361804712,
+		9045974983664041829, 905036705033699463, 6962033946652121779, 3027264198782618401, 13786415307358010100, 3643342525745067473, 13641958783381681886, 15675065537779359584,
+		7507377696839752642, 1061259379811757443, 10276590160392917813, 6889137095037822679, 16373913505782725550, 12287733095803524526, 5695917172259210496, 6360958736925918808,
+		7459854586357006968, 702429387211615855, 8231296036461604410, 628323703857882004, 1059802628602873385, 12517208225099517507, 2368172548334856593, 4792344750094708709,
+		18352334786472886037, 7096021570596476676, 17045407505128867173, 2467670847537319400, 2225663888244226889, 1876713214939672742, 5329943993157142620, 12168650975912182188,
+		6639850268372381409, 2284514769224558945, 15390110317831975716, 13933785559694229008, 12787641603764341997, 793886210532292741, 3222136169196008839, 11104892506868626444,
+		12660547967989039787, 2109392063597767300, 9889743271997754037, 11803327596624324036, 6940409327849314286, 1466399127363116843, 2572333022681966275, 4216097356402537802,
+		16858757460581672909, 5838407119753001493, 4453405435911954669, 2828665451507432751, 13657966632733241760, 6875986784381874300, 2390233934255482553, 17386653779125555159,
+		2976756344404126744, 17032556609402836559, 16348907464011574182, 2196781021202618892, 8270822867494340805, 4738372358350764889, 6088256422707334932, 17121369334507507505,
+		2081729301541563384, 5577186154173396778, 1865152567701500436, 1422284589642218069, 2489023909725140903, 276494395149046869, 17420927169263487236, 8292343688801608074,
+		7819174654675104600, 12778055482430336726, 14615848543490171611, 17498415175263742825, 4785899184222234034, 5227136636239697699, 1570704808469050246, 2858953380860123257,
+		4323577007857413306, 10524228743339400397, 5418808897687027557, 5939367271366264075, 3569359126353670574, 12961495213964770607, 8906990808988099905, 261084295374207271,
+		13937553904380032591, 9165760362893872288, 14159606902675650669, 7794101517494576908, 11994596892880464164, 16211278212275417034, 1568324133241165712, 6579463633356173526,
+		3784436423124943604, 14504130598322564217, 13343318845201913758, 2617267381187565844, 10063945174501910869, 8584806992850354016, 17494557973113338328, 16987450461117846543,
+		3191556545349441897, 4780077336463115599, 102121356289129288, 18353108394754479957, 10099934050411322327, 10323433488737585897, 1480832277301232858, 8304664509429164326,
+		16494820005379860880, 1719281141269927630, 2983529566257876158, 15928721259545722550, 3714203000118655889, 15922105900709017310, 17662263539397115758, 1577461381995722723,
+		3426958921435818822, 395886748655323570, 280632942609884625, 4361473570148050146, 6600885194277340683, 16668323952296831943, 10057749804882861513, 5701592287343868424,
+		6951585494335471689, 15680855848517030170, 9776921814538436791, 17640230976984644473, 5777838393869379647, 2176689364164694052, 10884627395386092313, 17656310368333301757,
+		215205608065278414, 15361057989137229644, 6756215047166430628, 12215084297877052825, 7185815532109454500, 3394755837885079236, 1778980761557523977, 1861969072415300655,
+		1535235777601157298, 8875662482214652105, 15404846185148709157, 6538418983879634448, 8341745508628160868, 7582603669233291629, 13003716464169800826, 13309194956036155778,
+		4791947847339351337, 15204996809755844932, 11672964318683763318, 13067259871945801803, 2139419248113049376, 18195694858089271989, 7208559250123396675, 4671149208567820584,
+		7276586425415793787, 14549539461274532692, 7381249250982432115, 3215735370879771405, 9197833835152018601, 17236122023193655371, 5029275100388702506, 10829687080866991082,
+		15533362570521057331, 6942829144635570952, 9572990445468151820, 6294042535380467396, 9052929167426522790, 18293430694900525497, 9076155092724374912, 6410242671697688127,
+		16930844972313552415, 9009509357611549679, 10722442939705348974, 4686888495512108749, 6326319203058274828, 2590592779822711917, 12876493112068819735, 12372064322375408146,
+		11938822647496400962, 15333527667419199710, 2385985954862343680, 14776415112244140169, 12817753724474105460, 5129368568396757194, 607898027127847045, 3917240453172744497,
+		47211231428738650, 9333275559955619158, 7534434473427098199, 8557232404317963052, 11597011861056629671, 15926835677212702441, 17943276685960195536, 2513989430679125485,
+		2903417389682946131, 15905578940823611094, 4910425097773753648, 10817415382143821768, 16356392378927186116, 1174713154793914656, 9176413825070952738, 17779105524945038711,
+		18302140065591767046, 6334261306636966429, 4203057092695998640, 2740754645452686340, 10020911575632378009, 5906713384548665207, 13902791548718280892, 2505591245136304093,
+		369660229032730089, 11851915833529805698, 13485269529443969890, 1270120511649175022, 9128783725626301238, 6173048611666804214, 14151404531169195672, 18241008099921643437,
+	},
+	{
+		16226789363155700046, 13734705589524056856, 9629995513492843231, 2636144377026081617, 1233405076007260313, 2119672919365858964, 4932766292290315579, 4185117177904214366,
+		16996170392430604056, 2476294162951949891, 6677439492116109133, 1649550562276235959, 7307278264575968221, 17128676264244010843, 9768062299436691373, 3825325732056225433,
+		5861627228365499618, 5011684805137210454, 1579621475012951778, 11535371650014354624, 12847902922833318241, 4997014846790385136, 9875988184618650628, 13094082946822736823,
+		17224650011872599657, 11430188086182976152, 12892063618843720029, 5912993124689510433, 7069617917494051681, 1298012103142698333, 7943359430865057535, 9329776843721719539,
+		9091412025380293893, 8622355764644651307, 8718353412518918238, 12338548766610785709, 5241721208413391572, 6315749100915178625, 17919741546105181107, 13677847475856526539,
+		17388254638056933809, 5422523708003180288, 16851423629233109043, 5504298365310420423, 15145549220326540137, 5184279399795985462, 2201159255780420815, 12506121988996036804,
+		4460258780042860751, 1816027820333214126, 7778555198679811350, 8155451943744426012, 18392325810806023014, 3955295139981696248, 17141295608995204052, 14206938573418983337,
+		9464085603669036454, 7848014338005901108, 2368914226155404065, 11578416111848517850, 6323647866244499941, 14399589996703947996, 2824522520842155768, 391310842153371124,
+		17489550078249576530, 13418700716683405568, 8265132837103985034, 8386855948619700037, 4642739669076635265, 1941217860224507563, 7402267177254210690, 9863923110146355168,
+		6176679707488254741, 4307819088229734202, 7082712522654871200, 14603822721598353371, 4115674343542702663, 4132348830250348245, 5992042367418590636, 15937819366199058986,
+		11008669567537833607, 14841150752801539889, 5253470025479549456, 5665837575328478629, 4601810548582757669, 6173003636576141170, 6899193615399367692, 968231402917393055,
+		9948650801233133770, 5836115460383443197, 11404170696974449207, 4791020823967734476, 423024247809958592, 11251668387880260801, 5562546584223492723, 578572156618131794,
+		13456676488167240303, 17121749146829956377, 17370555398500311209, 5041791432274350681, 4009412063225388868, 2407629981571159579, 13052555280728877038, 11483117063845312302,
+		13421089948800544371, 5001604265596626568, 15312985179876036482, 16032805766802337150, 12508684642650694186, 10422897636519090240, 3970071218688010847, 17419166239676042564,
+		400453640980208069, 15220637399286523210, 17321057148174216619, 14860227640908306879, 8047994708253288483, 10174040071518845057, 3280567772472213687, 5651529697807929627,
+		13988854693674964723, 10817154032069031941, 3171651998645961547, 5518712225783687705, 14706905091132091970, 13960758460934966876, 12141035142079693145, 3149939820435101269,
+		17047631647660916802, 11327141967045825261, 6773994317182166280, 5064726840218426586, 11921340002806613391, 9067034595359929709, 16499225867422892436, 9333282251383805811,
+		16851791401266483516, 3629537449474963381, 9616439067014312078, 17691280261538133313, 13915291913519800282, 4229243823856128517, 5998682815524220834, 18293451622818510596,
+		13740317056016164038, 15410121987858832401, 12080671504470100936, 11635316325777860129, 2584464163154495637, 9849046399519426256, 7991103215010751716, 2109987257001640948,
+		2505301881938098126, 9962323478923652140, 9312199523950444342, 12957822502673689705, 8060810607849163143, 737408553843844193, 8143568733429881786, 18003168270780769476,
+		18361695650419575705, 15964191128341330249, 14834821085064012697, 12512940671502931238, 11592194993753547188, 14358438239394059598, 2876909840522954216, 13154864917311376528,
+		1919485747906370662, 5250174270363591951, 6270889482486194520, 726576673961648732, 5067680336545953003, 3152041783219682891, 15674051618916413369, 12438966377512424334,
+		7755405178378312585, 2001220826274540277, 13276328134279740680, 5464764824709243977, 5374818714652367118, 7988129049563289676, 13996688354532099099, 14091540329663446637,
+		4460927228453411137, 16058422703785787527, 8016770980039986075, 11450941100964860520, 2742597710491507274, 16940752978671801273, 5897441526901650840, 5926672707007682446,
+		11513132526446047688, 2371334524276946445, 2461552185903242316, 2195417192784351355, 8821293936856062699, 17392142102281287994, 4066797133115509650, 10704373174879556404,
+		15778536817306082589, 5755579035239870289, 2105368957367433938, 16043807797277162048, 14990960263520315004, 15618512283659189876, 1020703273079622517, 9735594589053383212,
+		11529096471626785524, 13217557548494128192, 6973227637542883184, 17901194406865837244, 2414269359614891938, 9165268075797348071, 1013041849562373861, 17525420894350269712,
+		5772778048593061508, 15424756817708323928, 11842041259277183807, 17669952685051160523, 5405007811515938363, 4415223809135251038, 2223192286456742546, 15742105795795272774,
+		2844957165101842208, 5188198001787563362, 17071130520794983821, 6691797472842348899, 4294126956896299534, 5788827614077663481, 16267876196920424765, 10795461545625002360,
+		4405006158507706423, 8343317561528812223, 7851955346465616798, 14568481075913348758, 4391527082463073614, 13997921112025001396, 15259963045788570485, 6787776208020191083,
+		4002627348223514978, 16231148554725644698, 9578235186329928114, 14741034641204805809, 14651073646349829984, 1797163177099497214, 982043220105120238, 9027434646723092211,
+		11809342655313500273, 16822704101813284237, 13097372075606737923, 5463281428453250615, 11967866991673525562, 6828790575157689223, 12568831962097805646, 8385980093725157349,
+	},
+	{
+		9246769514475702626, 5788284997389507365, 15857897362850327403, 13864676801095094218, 12881526722328523267, 2620841421323221200, 12599981775316397124, 12820989846844560040,
+		13066648645100247757, 16727492115601921665, 15749471761440498106, 937594351871983779, 8381111811209734349, 10884357918725639691, 781591570669492079, 12778743765298428266,
+		1797915488494232282, 17274756142259274463, 14207994319179101777, 9405903752538915237, 9001743317941152797, 15048752608061590843, 4925745663463425863, 17143694017177138485,
+		11613437975225156304, 8619196433402562266, 11907033287998837424, 5056904365610561965, 7637552956459333558, 2827449950719061527, 9998507085256853501, 9238562885525900325,
+		13246436769495027717, 5445015753017977819, 16266739009580878036, 15566606095998238977, 12196078605380432771, 4854324313875295137, 10974170498288217052, 6425550765546527417,
+		14574824159194628650, 16992289415800830701, 3499062703303067574, 11220872042664151226, 18135860701984580530, 13630928571014923388, 2913126838766947469, 15869180955632349704,
+		10621010745328025245, 14637275395423748577, 12928463178963493980, 3270672471462681194, 11765440832075775157, 8138439106739837848, 10004644076263261924, 12582897670868871780,
+		9605391611675301152, 14014632424042523224, 4638465078692570733, 3013469722048440965, 10972600060210514686, 4497572559400894366, 2652629676209366276, 15827846806499715082,
+		216774559418075105, 7056732230404238374, 4342481467357759950, 16143194646968227790, 12304857685680249595, 5021239809847286634, 745754913624924064, 1603290801266214539,
+		2784418922013631805, 3554650219010546629, 8896448905401216908, 13445015286698819482, 6508982623352460996, 3322529327934132311, 18417788670080975365, 17554108945303789353,
+		17620122226715347133, 9738429733440215024, 15577771434516492888, 12422193389576942718, 18383756008252443605, 12736926759685644351, 16981429110294392086, 11999528928951986433,
+		14489177617081844909, 15995916840320959685, 6361381313838994395, 11146176143708648759, 17190512001934479207, 8406914945663974955, 18073221191428103088, 14075266763636071788,
+		11493260321718935244, 7134447477334726345, 10489281872281557152, 6145540581503915475, 4002857892747271740, 5167943945955725680, 2892864850826359384, 16887114279977647596,
+		16493058314197913501, 14642843949567816202, 8421201635021034279, 3645913604138483317, 6127272877310948153, 3660286308390076870, 14343325047340052700, 5355450922054278073,
+		8426383571761073988, 17627146217941553397, 7396223609641674418, 2402241526082789613, 4067059813672963823, 10306840429023537942, 18342506396531908477, 7249869764848707701,
+		17055119974261943875, 6266720893662254540, 13102139953381148874, 5249314164321788611, 7157525732140787612, 15381277459195914226, 17265025258266710353, 17573500432599548120,
+		11703325491493519624, 6756922948215553472, 10849241105791329449, 4442124988071574400, 13193138084274485850, 11408181130174894537, 16602978650637017500, 4282478513876287613,
+		15849352004835856215, 7022332658299393045, 2753527422472509447, 2508636546397160815, 18156018186852519542, 13445036260276495365, 6279372959444826452, 4487789154840943220,
+		6912674041294744283, 18177825269025993506, 2129493844567951509, 6833453501368177831, 1878514166200306112, 12873954541639117785, 7984716702294892278, 1590286870058148425,
+		13310953099825480439, 942949035351116482, 7073926138905956784, 7700580694019269362, 3135382872993338421, 14860196563555722941, 10662854588851556233, 5736680857908686906,
+		3285730769783013255, 5648284582450022694, 16712547815126338303, 16508335566005209527, 12272617736405465053, 6690178916455692547, 3481505327914964440, 9148348679521508925,
+		5445751308732564169, 15671537507319596886, 17721221564106627243, 379590599139121791, 11923849517192812255, 11794879354344258105, 4802202540817083733, 9502952511912834734,
+		10387170863530151921, 5325952605083195756, 9255511257002170523, 413412942592261158, 2693041233704004652, 14135620291598275670, 11595337134421837671, 1965085859594934829,
+		10567751951694288416, 10466024270444644770, 17138727632883910786, 12652567654757797118, 13864111438265559205, 2552332838857882141, 3739570066357761968, 1439381288436968019,
+		14926469836092482784, 1974273958550553776, 10770915481273902280, 4033929759715842024, 15461883773070197251, 5631323369668498153, 13319268013678629907, 16483196656661792008,
+		5825598074470439590, 15514383036808278765, 836600073173284669, 17006029483641514808, 2253041172677940136, 10109282146738215012, 2050330973627959134, 13783991480192211446,
+		7361422649689322835, 16012782899552425604, 10324124765039044621, 12319908523309013390, 17065808121376215422, 14844145564675640794, 2754581529304803758, 1149534055082731343,
+		5371192675994106473, 15892724499541682278, 3862864290653799361, 15759456296270265029, 12018492462347307225, 11503979417352537931, 1894695486127847219, 15184833349947874986,
+		14711143160318482298, 15515618319260581947, 10015362293284733112, 1169298538214120845, 14481541537099551545, 10304547737174682912, 9351439436434829996, 15807708290724844107,
+		16946643895530263911, 6110142153011856496, 6857516759047242219, 2026267735072107620, 10338469980804248611, 8224240981205716101, 12739986350836865860, 6828408496869642385,
+		18199296108774357398, 10154672256889745380, 1190269705881674139, 2317654455984851716, 6948704988682993246, 7864433505284017226, 12371653445644439372, 16432795124971446509,
+		940679263188661008, 14653357165718140350, 15439920797347843673, 9415587255510557494, 18115037054677722678, 8165849408798239027, 17369387099667572407, 17619066457126678815,
+	},
+	{
+		11047138821675365077, 8918121441180891972, 26692501222219426, 15248413052700323978, 7305399157133896461, 7065644238942265367, 3949166834387057064, 14178248206708015607,
+		69860179712677448, 15464996655458230480, 15095351218136595554, 3792171085643513009, 3187131848664503636, 12713332789590787064, 6278731049699775392, 1597379696359884724,
+		3952205381894147962, 11371446109407143937, 7231851263356642380, 11612512368538303138, 5227214975837085115, 10737565048439707166, 6333629542995218640, 12386725921557807638,
+		3631886121917081375, 14286411187847401959, 1546298555066841633, 4790996540037176549, 9541492152219486842, 12304868498960755609, 11426775785781090329, 10793898029125361155,
+		16970032026045908366, 4739834790205788500, 11604777595337607879, 7222013010088766249, 5472916641327283117, 4172262758310864960, 5724466588558015820, 1116300519629843659,
+		15795014995613238211, 14290583239597353888, 2490895887909073495, 11130992987297321872, 17554999787604367088, 3420129662095546057, 11472786435923282727, 16869713476687852227,
+		15035061229930585935, 453017670704522761, 13269498238801130975, 9381945743239523058, 2560842189862328725, 6461599464735341542, 12067824007347016987, 254830492191366350,
+		10932352970046201499, 5875690226460998551, 3699681560657289718, 8665743594825198441, 10232089728487302472, 15664572298733091969, 7267222702489958195, 10552093353886118696,
+		15492342672675114391, 415437554733257587, 12890781990283079094, 13204935186176658494, 16394061615709463286, 5115734945762570776, 10421418042968619739, 5523853293632283162,
+		11813086056645720947, 8830149648607040713, 12579056778157665738, 8379445845509747387, 11968812374998926933, 7579079245215672446, 18392522237039663466, 14209436550919930092,
+		10567400467353853420, 12039111362360014956, 9752698954159464580, 974455144078370581, 16749750902684349652, 7431880327875076520, 16572811640260132367, 197121614392940749,
+		4008236965647744142, 8547116629188387980, 13874587567755370880, 12696453513706541959, 10752386832421030566, 365775083075323708, 14295272684753058141, 11024897725724291722,
+		9389823976782902582, 12987864137510618346, 14351996708263571593, 9397276818616280108, 8943695845699072910, 16761881794918812428, 14395546039428720745, 9608138420173912436,
+		1876375509629583057, 3290820252719995988, 488255726920613097, 12524692306565281959, 1588481057230489293, 2737168321842385117, 3787136521155591587, 2297952115270241626,
+		14002797112021507101, 15941913959379016886, 13373428680779564378, 905956693320605119, 14911807685762669378, 13046351903511292109, 5010776430112230246, 13569296078340893444,
+		2399232949134869057, 16408469118941953277, 17229778225562184411, 15990256768949242309, 10694906341686584836, 2816242351659628719, 10794163145486835660, 15601904974333104002,
+		11025280186920123511, 2638544612389113264, 14138782464677956897, 8182901095979048555, 11304014986311338849, 5418181013691186545, 4702887342992202530, 10901371551431733592,
+		7470028071605003558, 15552389775050890646, 8285175978626575302, 11755261053723122966, 10951094485216236078, 5507384267235142469, 13239757172982680465, 16153920989213321821,
+		18058993449364903238, 13898361855323379776, 4830208064835445821, 2108287244297002782, 403367259355957679, 5208097191763320114, 5105753392567780820, 6874403921011777407,
+		1158521281204350113, 6232098057848694897, 12517518152351190341, 17852831094628421272, 11653774695260269881, 4420518556213490728, 13835371272800239099, 12119809446886544909,
+		13202632776652821767, 12444449950521044637, 11128589812117041029, 13640351754206364654, 12210309609173025143, 2998033188714623978, 2790558847086549679, 1412882974937756344,
+		8872627396983903111, 13010748252899511409, 9503554222158928531, 17266043773425260257, 14299273669130129568, 8206060595465248374, 2391269797717981426, 11490348680137544215,
+		5625434013536513462, 11006046905736534335, 12974260386406529669, 9092861657954444193, 9064784322822166467, 388172762639483312, 7975459140038679785, 16519143691087724914,
+		5143546864201185527, 6400878864024957342, 15513803558106064076, 6712861984922181478, 15623960351786428150, 3094277713920675576, 6184647748693682810, 7857605928718754519,
+		17306606255667524897, 5112741148301782470, 12807238528895999857, 15137864759480529337, 14604908573844046691, 17945466774813936069, 8840495514948749443, 11197321446299638637,
+		17220811598578674405, 4438480777123093236, 3563461541688367236, 3111403934731489046, 16319666149508644048, 11775149819643332554, 6467838040542164752, 1567553021477840718,
+		5384669083154912160, 17619132083131362037, 8938889855576647487, 9107335704092137106, 10077424566800668390, 15550874273916351174, 15171215175982142697, 15277375103802490853,
+		2219152199405421709, 5367881810186787185, 9606063680551349934, 18233690822105957780, 9941441403610160291, 14996958158691873775, 4936282940888570414, 16608409936766385729,
+		3344228690528365773, 14741103791830625697, 12105806333035047780, 4814603778329751458, 15692542571489717296, 4074467482166609769, 11583878004635312071, 15057041878895842153,
+		12046059187840675577, 1106267261822046486, 4800396230944794513, 6983782857932290361, 12630891077786998995, 18331269049237387531, 8843236455524152484, 8233277245902259517,
+		4072376012468301087, 15956856707868364136, 6651399164294705117, 9169559249495366525, 8774931051408681195, 7328702764302633441, 3821510551720221090, 13559321821383641691,
+		13270099407878039596, 11569032926557804346, 7759575992876193458, 8239088820951102451, 9633607727685959064, 9775909232917811341, 12297921731498614906, 14756100221590046549,
+	},
+	{
+		5228416958727036186, 12534300056259911378, 6859045937063682340, 16561718753727911412, 9427589074776024847, 4167904055656501509, 10156691045253563236, 17557096561606923049,
+		12847261474293104380, 15935635664155479706, 11956861064550631146, 11743590506948225647, 15973092866215748716, 8269726904881958353, 15639962392523441528, 15171417818360069012,
+		2605212343977737441, 18393471024186189813, 2302707671753008158, 8606549841034095192, 3842822953634987820, 3094721493917442423, 6408313759447502937, 13486364200254727287,
+		2191808101092881088, 128992526124656216, 738676021426139131, 10157323147642681558, 11221959943853120586, 18255489816550713347, 10885231659068427649, 12104397395119665023,
+		7707807226411417919, 16609863548699265350, 17639371636697428128, 8755472387723764172, 164779854477783265, 9714199241756765614, 3491355372893948450, 17683742455036967163,
+		13595758632462338296, 14515163666150177917, 6720823780841221770, 15071435664343609336, 9016075014492765983, 16881277609836316886, 6969993988115170067, 15419704786434737070,
+		14933348768149415725, 8499210770493553168, 6778840616148281272, 13282837866452012488, 12007326272174861053, 11172739862019218274, 15202495365302649711, 8797477675597086120,
+		17862558746132168231, 4941846130090682869, 17131557654945008226, 5312800819142473968, 5818269467205924209, 13458582047859447022, 2683428091382447153, 12956887954464730664,
+		11820752998821943867, 5623379642132478491, 11666807493120740820, 7241997274572162616, 17165010508995490690, 1769225877906480182, 3814296306467163522, 1913823003062817434,
+		11936813336110488997, 3878433838529606580, 6540053284493149566, 10610279324743393563, 14079852809920102066, 9176732841330794388, 14287311909822853963, 7146204303626670196,
+		1222343790928490335, 2199405396044383670, 14080919887213592148, 7341303626667347624, 11784881532696657518, 17307742911086150556, 6036132721599132043, 12167106497065306941,
+		13817073203406999359, 7220729284169210756, 14908407498603601482, 13536224989620701632, 1615171540711527931, 2063856048260214664, 10622581435417474559, 16378505765730768032,
+		6855676470217754770, 9517149712286624325, 11080380031068971680, 667425509348698033, 6136243307299269825, 5326577850303193160, 16120190278345757447, 1982981965726975383,
+		15399454106099176868, 3988744407816581672, 3596277710300384050, 15129113714633923498, 1554582462382333698, 3164553872715651710, 12729140363982748426, 16366728035709811784,
+		11647936211409428873, 14704462653811533865, 10005129575282387925, 1526194796943187368, 10906326807488904308, 18256878690674435807, 13093574545395154003, 12352810226542367406,
+		15290817014272444879, 8012864091692295774, 7591940515496590516, 9299619125326026848, 7297256232167521068, 17861204372399797627, 3100022958796565106, 15313770879200204613,
+		10190931844127971311, 4449277895844944513, 18060903840299422620, 5786504870079014862, 13877878835839147302, 17536010013969819055, 12266576574650233794, 3344384108564085445,
+		10406231172694378191, 12785551100938284935, 12210880209800471137, 16615829503150405150, 11718424737227538631, 2245674303359461903, 9283401225508960391, 7699506693893764319,
+		2278745583218618906, 10638058115573097116, 5685140621618740987, 7758115175926730915, 9043786871908073988, 11442680114439652875, 15805407285446479015, 17615595308217319903,
+		17127838629068819444, 14692086977823146619, 2491742894643214379, 3238012827598604955, 4066194902402629617, 3613111175737094005, 3296022969960608152, 4860674720288543209,
+		3753308721541654311, 13160824061458819791, 11298768140351857216, 14042645015841972579, 10518697187157549363, 9641851844202952198, 9254393371864075771, 11429987449073904258,
+		2566815986599406395, 7824829323439900657, 14465315986665451243, 2957504741164666523, 2280672126115151165, 14999624386740200468, 6090063205272921919, 3478652904863279960,
+		18131467168461028363, 16471039226156513736, 14133684792391617163, 7137732710914086892, 17299189471163637576, 17270681183882183871, 9046519354210103502, 16091721986926209161,
+		6572875037492082093, 18318192911446580882, 18107990043035854610, 13573958681720538720, 2821064027974708708, 13000417359062035623, 18286430707379660800, 13070676610179458046,
+		8521670721910745896, 7440450230382417926, 13794050882540606099, 3657777690979179248, 15466400576048586018, 7802926536345945651, 11932698778931413693, 4291944108972289013,
+		16729016738422946915, 4082443597391481873, 2238453914102498318, 1806710580451019071, 18305396377745213463, 2262209146853870557, 17240603302299977012, 1540474707615687112,
+		16013022710115947086, 8748688582020024424, 10921431579160628425, 2228053349060750948, 7024441100951863599, 15816203310189470753, 9078141084316010447, 9841344410499582933,
+		13377311905703150010, 6352753896568161822, 11086576920416079356, 7629848369702522073, 5472036379742160857, 6535781794177956975, 7671272114437903042, 5056286897725243410,
+		14579350500102276494, 5882738271691348624, 7188200631561491668, 3605286077046581049, 8957701412704914688, 10347270272487533128, 5995825272041784807, 18321189862831103872,
+		2376178340116743056, 2263593380938083722, 1990228394694589285, 13477447633165073333, 9023956677421314778, 7820910817739139038, 5288765314200405868, 13070699273589738968,
+		6765952613794178887, 347733275422001747, 7640026333627494061, 12925707101320796635, 5670472934143686904, 15041817307271371058, 18176041895529109656, 6838891343875575060,
+		9902363248877274636, 15776195244792726061, 1935342462634574355, 16572507349421626602, 7503944294807242065, 7454248748618678609, 2837392985175901475, 16494567631149775512,
+	},
+	{
+		12299242278498309265, 117303082144788574, 18382936515565701803, 7941141688858846015, 14923823358299367958, 15681089039073030752, 16878721085421212785, 3933697483394042011,
+		2878536922988449879, 8819365314325664735, 2696760638950720974, 11357179421800829605, 14730809809256560583, 16277258726425730599, 13189689275745970592, 13769784951430309444,
+		10292669945637125918, 13595563061674492799, 18301330068714272653, 16981073598172019270, 4022713583718555211, 847970754090163894, 12867993617169467387, 10021141621864633865,
+		15254713655124736464, 6283719686609422435, 5417864180357938798, 14010638809605797246, 10873690600705871523, 15014239467130590294, 15765460219545280655, 6048061577845125750,
+		13465802402879986040, 12777495579796377113, 11251142258511736751, 8312965145580158560, 223338793373356823, 813747086573652373, 534790745256052224, 3658554932030960904,
+		223170064814687698, 12938716002978051117, 3848816111228150666, 17463649319617382466, 12886402189488467296, 9605942357133455486, 12272689261734151433, 9916808458308982839,
+		2879267873712146919, 1770061136847768757, 3497337219301780129, 17065005588401306579, 7675751531915094916, 4337540836976665798, 12505868586426061855, 16929961945120117126,
+		12012729503226546642, 4811951115754240681, 2652621264600062520, 1108958391967017223, 2508980100759035797, 9023233544151778447, 11183557587641545146, 10726727280840759519,
+		7189877122763725514, 14656082750550993666, 13508306914749420120, 4564443784575285318, 15450566991657647015, 14019683331552104148, 7751003035652012225, 960642801291306739,
+		4621870789074053275, 2699296606556701282, 17510056683561737074, 14554735156054608866, 9556940770704438829, 10801168482998872433, 2280142648958056556, 4982572404720159279,
+		14621729774738200671, 16850208728798178903, 2650832773786164628, 8325244333065591089, 17692120343646193143, 2242845836784335580, 9386711085286369304, 517979059098779699,
+		396296174223428093, 16763788748988621834, 10606803701784640909, 2399987183687936561, 3641562114746393614, 8536687357022564742, 14532545286961725758, 14658331097531946901,
+		13237433907493396869, 4990918623816750268, 17673032790739307275, 15907935024302716062, 8613470231259845273, 9346326052910147032, 17747177708802561938, 4490130127498754807,
+		13867405496809412712, 7002613759387491643, 13033935552806967378, 67437088702121131, 1528641041740753990, 7001198041125832592, 6102137699349551632, 11527483925092226802,
+		5535652777947676324, 1216916140919282417, 343617165825197489, 10806931059627863289, 3212291315152120591, 3351900116486367965, 8595828725191802110, 15621077401736893558,
+		2386026063595321071, 9144724461940169335, 13121187420621518554, 17351696676224980491, 143495028693925520, 4590642171152119027, 8655406817079059692, 10005507077955932112,
+		6982427644490593208, 5211219672384700779, 14348546115682624722, 5876199850746516331, 18396840586595761484, 1465795856184232635, 9374516147960853174, 11803025633575966436,
+		16374709377982692229, 2545295070586009694, 17366393861359867323, 18067336234259281315, 9181658491221440805, 16188192004088261717, 13669686513572099673, 2044092029751770484,
+		7308293641399229883, 9813539775451467496, 4837144575100457648, 14073521030008335794, 12371724228966966456, 9185074727660313894, 7387427551441329556, 1866580457929037678,
+		2047964090310465728, 14133690277069748515, 8287749071957055844, 16821270580974431218, 10324684883587585565, 9652498187344172497, 2461802306013063247, 15048850312040680643,
+		9659170831875656345, 4251587871822599596, 12391279033133774782, 7346556824831912968, 2133114137534468833, 8694105814921565301, 1000087733076615381, 3478818915231998954,
+		15832320183998834886, 898251865651859288, 16874504161383651033, 18425166917936355349, 13387271833996394553, 808054572728974308, 2281828182196149100, 14620221246129351423,
+		2755242181069093228, 16155597320469161129, 17375128328249992589, 13376690667170223367, 12825454052191060221, 13625129606409283552, 5627148592782580041, 3092789333954796605,
+		105705035058376953, 7541598459498134635, 6627685529861836787, 5724525771392188178, 13865897118300842617, 627652561624109853, 167084371112939132, 14192831153344015422,
+		15618434900514973465, 14267977447705810206, 8823759714826430108, 7918740515193061263, 1664424041430494212, 9076733744947861202, 12010737794701759719, 13920688631446302868,
+		14823160144680924028, 15690572793903331709, 1101762466949115887, 19462496059060771, 6099422315003219574, 4300077459158116870, 1282001407902323746, 5792772971400374848,
+		11488321122368726901, 14632273370344181937, 12984850848826263218, 1857014998357880446, 13897135914532207935, 15925630222053677390, 11992050787349110965, 10072349923584966035,
+		12837696619944805389, 13470316523008526719, 3074966674353053986, 2630814767089382743, 13353767941686870870, 11405513520090968568, 3071969598389884693, 8212421686942839224,
+		7866179127856055582, 11874624506147226333, 5793384221044709375, 4411967221310302622, 3004913667339358722, 12230878672003882045, 7395980261120250376, 5188846147165419817,
+		16160221386626609076, 2876994290210606255, 6065036384672004173, 14696333348949573335, 2667009584785381424, 12100192661844794919, 12401945669155059163, 12847772853650923808,
+		2286437117905535902, 3130250324287833414, 3662253455746154641, 13229041365675585947, 3663813013822489770, 3093300797589723687, 11507645566517710232, 3715061633580408995,
+		3464453985305889088, 7486900500389940957, 8944303108517222303, 18319933556403836918, 6782476025105836770, 12822840946923377510, 2799592944286097404, 8737598030273298051,
+	},
+	{
+		2754563581284692865, 11257360722362829387, 8254261291934606879, 10023569920325096229, 7980898855627864603, 17162063449612285703, 9275759455936104363, 15936804738099638644,
+		303387668469489035, 7978391052264888020, 15413722057350324494, 508608987485166058, 5585753287556892522, 1344134516582665443, 15144279405777509214, 17014353449841567149,
+		12518577022215294774, 11347384788122950558, 17122718824958020364, 5431993665805279177, 1445831254446028321, 9845654210244803480, 18315778529692612284, 930563922336183289,
+		4894710987714215219, 15704993603878996107, 1606204036324478223, 14308635149530198932, 5026736228773269251, 2911689442372084137, 9004077539360196849, 7770049130277452000,
+		2745120518194234905, 17255944807561408883, 7371907591838942770, 11781525288383871227, 7814952754785494862, 15022715213812536212, 4112388658963418656, 13703771908397991335,
+		17455440140812341569, 16738670164475421762, 13259904130186215994, 2168106064304872507, 1969289843772256992, 9025317999701057831, 5835661391798891929, 3826587698101558069,
+		9149648374608464235, 7248346993716635643, 17283919168525322365, 10107681064815728795, 12176813938029507719, 15110337574289033068, 2436453685316043712, 5876967059744625564,
+		6197919059881189313, 3300993078638782623, 9357667752372201437, 17688129755135009447, 5477090746558113696, 12602024521188880300, 15889961935507293355, 7135039746373941272,
+		12561063426893244305, 3079971284510744316, 15695857190375815873, 16730673956207425338, 12065477821845465116, 13846158368121919228, 2126156187526559500, 3005167441915916768,
+		3858987859895327040, 17043903959888117395, 5861237635520080595, 3292646198413575902, 14286644557048422360, 14346409530388980974, 12583555046601155161, 4665981927428063991,
+		7657686120974201842, 2388299767028319466, 17934808017791217639, 16708640707026372313, 14122341266134976486, 9547124998857374491, 11194069918436025923, 14657538980930727877,
+		18115789712912297420, 6543740714573413570, 1955886376702349613, 14736853369719086334, 3914330395250768396, 7607848156418885173, 18220633528980056514, 11930952850158858930,
+		17010681753474701341, 6961088634819162945, 18395881317121515295, 11611411242007267179, 7996717433149311639, 2687736005475404867, 15340214362731923149, 7116441414289074727,
+		14302198697220662403, 11915041511943922518, 12363437164440173650, 4047410026894059083, 11439743031696133447, 8776097395071907030, 6851061783357383945, 16484733576581941012,
+		2861660066704264713, 16453202148771053225, 10039035813504063627, 6275446616881871868, 7150609984920482782, 11100941755544354363, 6219760433202580646, 2875377482232912143,
+		16477698187919702699, 2757160833848759781, 5976267476122243443, 7375951277779829055, 6525111513935493528, 9969722922172879681, 12582700753056539952, 3861958159147836631,
+		4207324524057007052, 13478421263392765917, 13318275642734768006, 8504333045658265535, 3960720256367501697, 1601661680373853468, 7704205542213854353, 1552780884856863914,
+		11788483659211580527, 8739274750400900816, 17562450707643849072, 2113004873311762141, 8542099133996522813, 5273956141012313478, 15661081976505113338, 2290009483289921559,
+		7730337285529332076, 910421998453976119, 1242962796308775978, 15931313183507922513, 296811920445331257, 5821874870466240960, 3843405649348506130, 9007082448812181532,
+		7200777231000974420, 15816416455380831370, 12932038056359512011, 16422801186386616731, 489979647738684819, 8269568123908387407, 11617965045895762979, 10069799398667455631,
+		8245819835927284113, 5237630684564909794, 16572245571184457585, 13396211619915630497, 9177789877937729597, 7598297211302983411, 3133511073496333246, 16553020037702090576,
+		13441991323065749602, 15441570013111011986, 291172418860690999, 765089869758770890, 15943751395897588683, 1887511823199710563, 15452188663399676440, 15028027691170546376,
+		11009923302693800320, 5465227554242327455, 6511134004216481185, 2187999546010819375, 8387421071023131689, 174295266381833460, 6010935117399493668, 3340537243300033200,
+		270646782953286316, 6635640130829923909, 12717598479778596267, 3198506535831522029, 2605714695474737827, 14548588937126505914, 10448279824323025574, 16008560590494788290,
+		11460241048816176102, 6557818897531989327, 6948658872009630691, 12506263743501199667, 1813031030961999507, 18320107449706503757, 16783076453582799039, 10113937529079967843,
+		3096618551325580575, 16427990761832670936, 11792441105446619028, 682188988823121368, 15606025696371121549, 15395362449248397023, 10158149307437310549, 4442375503593769727,
+		5486499432056098253, 3811951715772590831, 3856863699598204250, 559724736042732093, 13251752681229681959, 3173330346541355882, 3597530263899943500, 11567248716558420280,
+		12822024566847931229, 14487146762942136806, 1361688279016339671, 2776885758026394514, 13616222293131162973, 4629388276054227930, 8304132204812769256, 15188275451670510949,
+		3676452641243730693, 10839008248003066479, 7676518604603740317, 18384275325050378660, 7827069556104560937, 14335741841451672783, 1145975213382205474, 13691620069378415495,
+		2513451633312793643, 17331457978938147928, 11588204658848186728, 8824497684232939293, 5956154520546906549, 14434958079241686709, 11798870987920360447, 5875117843056165993,
+		11313908033360767461, 14678575871510948417, 8479250768537158849, 13854183783158898926, 9413525381201650053, 10077438283140087199, 11413783222317729281, 4418417663988371635,
+		6001837395299394988, 7545846298204709215, 6662102781970969966, 12696054550672669874, 7436995610194789060, 9042605089262227561, 11621508125069628605, 7289479057360149973,
+	},
+	{
+		15555649500689005370, 7857014165815014600, 4664069234996337119, 8058230521837307501, 18090421626009183450, 9278179697462444898, 17138879353097908770, 18285223269807746171,
+		12741225973381753432, 5461579923265799106, 4348015554411389960, 14970536173310927872, 11568371199139699619, 11748662751675667230, 15495664823061891700, 670495577617908409,
+		9865772269601493999, 7325690007062740244, 18437964667185475354, 9546360111100619473, 6266116854923135821, 295905071295541234, 16037468634731642095, 16602609756229843150,
+		13266892287530449189, 2232961926857263527, 5934654989155432442, 5415975493246016158, 17117784386882463158, 3875398271691758986, 15755743581177209843, 11380746535012415659,
+		2047267291755864302, 5637045342080349843, 15779859211873634959, 2415175423642772217, 8664113127182901077, 3032959071705433205, 4250761979529656864, 8729259992491925346,
+		16559648310139278090, 4796731467175572814, 9267555165184254828, 1400425639375650333, 5199035239208036114, 7994153995816640929, 15677746297407711038, 16338895562326287438,
+		1740700879164022194, 8442598604870387302, 14969965175291161450, 3086786406508018865, 12097766404705693713, 3199218739761578935, 1744290654371906763, 3672816528005113908,
+		10162459499000477259, 7534168794800651527, 6320985751131807192, 9263840233901040421, 12178625283764017250, 13143797113231152006, 13089053551699608219, 13480464010111258056,
+		6572275813002629593, 15328678880838895837, 4281489161088939969, 17996597009627631572, 10405019085582914256, 4773602940383417103, 1455403777441353089, 14766164051850429812,
+		3886207141264898075, 4215113531127552656, 14283840761174092490, 11161507022796293343, 11235510295695006534, 2260082644337974884, 3781681413610409735, 5577127823856153222,
+		15609337727165147542, 5725010295752332028, 10091444858515990726, 16162855978360002823, 2478705273652882251, 11394669968372227148, 512641267828429208, 581410050368207889,
+		11426681347395118622, 17135867298562042628, 10870734720453621112, 13803364322975322217, 9740527283062276630, 13765238480893165263, 4792349632705804116, 18359029140065847048,
+		15215482935039834459, 3553551735757600990, 2471323651039083728, 11355669733892999598, 15830640053604899661, 1625382463038435804, 11969247519895019474, 14372668755409420943,
+		11113773299077372683, 16618589175113863833, 12580653821785550146, 8264195478884998326, 13569468260761711850, 16539804400793525042, 14464540796871846551, 7710175783216723569,
+		17565888320840294282, 12018783137972195797, 12159604578082686310, 3210316551614996638, 7700243787046971168, 8307491254792612954, 18022719331150542511, 15890872243361196004,
+		1420251412241033168, 6449255753238336368, 7468624722117319576, 5716072259994197219, 8165015263320602150, 4757529151848960259, 2040364517493350115, 11069642333484542749,
+		6861520668253090597, 14998859189233167760, 4851545815068976365, 594940747993801912, 8473464707442482665, 2316305389548210767, 3995416902578245152, 15770229481630179441,
+		7316766449463697051, 1410976281384361962, 2878678490331118371, 17638505404208445694, 1130528985192221086, 7544558337870473835, 12071909234624857373, 436426448500115731,
+		17436263074416557505, 4339627812592344328, 1076653379358004720, 4996950998108333398, 8528954985898069924, 8259369611572362613, 7869239207308554342, 3592003501289265534,
+		9434687670958330812, 4808705744496679962, 13910334628239183613, 2628594509406050235, 10055911465166862298, 8069256921143792190, 11886968715847498191, 6351594160398684406,
+		9865961381837093259, 9590584894285774485, 10674927452501376239, 13861388033657872936, 808108663597281834, 16581187679405825998, 490312642991375167, 11352102610468872412,
+		12888468148530619065, 542846015600866106, 2086677842713697080, 2758534484095407635, 15767123419143795297, 7077908316515201321, 10297306681753168866, 4641656730233236179,
+		104445550853777927, 3829969899624802332, 4713997522991885393, 677661257782477991, 12383280183673921457, 4373178143111769979, 6375181113677777933, 18335077047046332699,
+		5472832021993175857, 6120966193470238758, 13156950075464061259, 14833372202848630444, 5760885723102571027, 18022572190906170343, 9870918995920897221, 9546055667466056471,
+		9516299398994303577, 11139435630263588724, 7364473923787049608, 15378275072059759415, 7378721410182635028, 2461490895435109307, 2579531356642691202, 11061693189962996686,
+		17380308085259417126, 12584808641030185141, 15485460243194852460, 16172215807782473427, 690761937231979275, 17570908286361380250, 3347059970688467328, 10404397759606846636,
+		1302709369035452282, 7149637102192386111, 11659118804203241786, 13909758997057192683, 4361167997834561257, 2300569874961985919, 1609719848856066643, 9866395233709297503,
+		17124591880405051324, 3379747334483646957, 2084957978131092947, 2413497199486596627, 2867893699156486423, 1357836849049583382, 13607307985344221035, 18039194570940763745,
+		831259058391834318, 12782538711785697535, 12640197944141330321, 11004378265133697847, 13622812183191119169, 5878590957416415562, 4810392157669422629, 11128662835376944411,
+		2248775486830407244, 1550340755758127506, 8399436463450785695, 11063895076440303538, 2168511054719571959, 12238498894267955838, 10824266376477587807, 1073243669335517712,
+		13568560319245254019, 17615770913976878569, 13214159705850440913, 7542574047209989510, 7392331519546111377, 2685908847786414772, 14835825677444128105, 11347648758435372538,
+		13230815692170010235, 10662664037814374845, 10120384214921531334, 8892863196093018212, 4443096401408136417, 1896901619181196514, 739574867683694091, 11233952771600927581,
+	},
+	{
+		10708602749843635238, 8046488591192123621, 11391158257016334553, 2512908912806916201, 14760224624269838038, 2631910198880826809, 2387247811669872033, 2048193899742148806,
+		17392983665205025720, 12603331233691760840, 3752711326309791976, 8281544857330094164, 17004651346561270106, 10399322540256775923, 9721299450284863176, 3725182263994944884,
+		13643198694788276032, 8127425924819487897, 14165945065582850538, 16520977003164405917, 1941948502806705647, 12390949208067741787, 17112117376594486408, 10232906951259490042,
+		74190110112564319, 11227229657066745164, 10151080599595091944, 16591051376074591375, 8256332495682655293, 7127985739945537626, 5708687346183367016, 18310921046455023281,
+		10040565835468209502, 3986586816478505371, 7957179672896506016, 13347112914739722590, 14099734293320932556, 13921950344400895005, 17478414833301838037, 961445463330402797,
+		10553899634420153414, 4215979268474142438, 3643081140297634139, 11620906704125380460, 17733628678553828301, 137473878710304143, 6211837577294956591, 13926110616399428016,
+		15203257341351417031, 11597829209697937782, 17317571979811895272, 15929491640570317745, 5731227916276913121, 17093153916149088230, 3908757069480556294, 18211818355208735794,
+		6887629766078662088, 15330755394432598442, 14144608177273202986, 13258654996547018856, 8975611270007504091, 16869834856279102361, 12707970875852047823, 8520055680055874514,
+		1643407997152867899, 5400650551136488814, 14663391437159245064, 4743209938058826866, 1728998201888511561, 11238331920657195520, 11617984741897247805, 13858029141809651878,
+		14003691155137683825, 14641672309228817657, 4031783205073356111, 7414359968614421153, 8166814052414482491, 5209260157266028169, 17555696996149558694, 9780166780476833956,
+		16029688335186691281, 4244772808651443261, 6450459413414527821, 695875191412722741, 11104054226249884864, 146461617619843327, 17480214580411209436, 11285418463967817315,
+		4922928863857449168, 7226901725606965824, 7568276305032368752, 6253457805758596797, 14345040877576203078, 1718759302498746946, 3544444746772280646, 17880302727399449566,
+		10693864548794383214, 736148233485985101, 5241869061152863453, 7166954323782542739, 16861482585847848251, 11483636939866570861, 5950529069765100144, 700887039653157350,
+		3906969739692830848, 5546431121705298614, 10491799900914853406, 5871175286230239238, 2851574662174517162, 5511397532379144624, 17409985391224790540, 319012646822749823,
+		15269778527761027251, 16471737837294177924, 8830398856035267114, 8206807757132984992, 1421214226977370752, 14233751335943482739, 9668238787333455452, 8700964319357541954,
+		17561670470565298976, 9524122142014309347, 12619871254022879995, 4098610542031538614, 8338691110372464881, 4378598564044777665, 16435680634249352743, 12067828180476756532,
+		17102475410743425567, 16244272017711449252, 17598420420289880464, 17858587557620312875, 7275673248698358659, 13952444068457447282, 14004356855576602555, 15776401868125266614,
+		9848210305813205280, 13777844361911806961, 874096498600831552, 6286216140019341540, 1229781121487503670, 1221366673976886811, 4534525466071627057, 12966848050780717673,
+		14890015174575641658, 7082696407720868596, 14546372439063914434, 18306301153433516531, 14360952638570231274, 5387283652784509262, 7246876761413034655, 4917620254108676720,
+		16572428185201836512, 15535161956998457706, 3118508753345802652, 1036719175817464914, 9929541174185476740, 17658764424885337186, 3038747611544544975, 9299826573437432057,
+		4068144934809412921, 10422353259330469599, 10820596685747357573, 18174251490011716747, 14838047097904304200, 6494279871501263445, 10908514990777375627, 2395220126873880030,
+		8963350163641627638, 7331858013030906816, 15047142507680204097, 6113080618647404016, 7520779807516814683, 10255234845683676901, 12010823325949652354, 4005195924244758895,
+		14455661618497189876, 980858168361168621, 5057114595071838088, 9447128440518577562, 17115933446433165191, 2063106073840638313, 5944852338857186064, 14601740796836275216,
+		12750698494453238590, 822220438401342753, 12735466470750534773, 15168985403101776640, 17837672477921333079, 5413174218886573483, 8340507718774735027, 3796235681866322764,
+		3366536195244539993, 13901131415620358879, 9146606194544531067, 7568835872371146677, 7101767951356426039, 1958938171972212156, 3871412404872561111, 6437054924013233533,
+		12849284342518738377, 6061751293342567452, 15168528907847693260, 2071752334274992986, 338461453751559028, 17270401493472349305, 14152214298057413781, 14074152302209367061,
+		3814267663972523036, 16047424572869508620, 328411057776532579, 2321721854548154476, 14950895796162035951, 2381867458906113095, 3121132178592915484, 11019696935452271225,
+		17929201703034060485, 15478512769360046037, 11652099424221007544, 8436785170867890275, 16340404489137765730, 13705192502407972039, 9464924753010269658, 17372624212933856135,
+		11237648987477338397, 850109691127167972, 6566350160877169296, 8028073340740368222, 4445151747345891893, 7753144690511205475, 7551118086710031441, 16785474804106433438,
+		3919851124685189663, 16028223238454025712, 9008783533564802058, 15647028843636411071, 2029953422298604024, 361326896057539567, 7653333452646403127, 9211397293968688243,
+		1817762546790624760, 15025271080704836746, 5761603182050280401, 10355268146728370750, 12900583599325924868, 1488036927944469046, 3405173852255315327, 5600132277974719103,
+		12574920924242276218, 18146097977073890534, 18281543194137545725, 4432773597060264867, 797962164984225968, 13432184750641235201, 12394976215803938078, 3054137600383896411,
+	},
+	{
+		18270562314314829224, 17574550722906577917, 15522987576586641271, 4200899284963891561, 15719788437321868967, 18390235318178988753, 17371818886753265385, 4583380351670429228,
+		10102001197913431240, 6211688443233768420, 1986665099237206297, 9248907879269017005, 3081890249882755206, 7828527646248386813, 12676034092230326487, 14655968027461080131,
+		11464797300361906821, 1444449385286554508, 12433005157477847389, 964895564896662942, 8457290958728547067, 7044433897330872257, 12292673928275053405, 13679355097865192207,
+		5841260956815214452, 9461234662498869948, 4761949640006529525, 18229823346336752572, 16055957459773168413, 4272222475092786627, 18249888117586812770, 4531982814021269346,
+		6528332072572425694, 15678657170585498065, 14462305190193144746, 10159286562616704237, 8919172138248087686, 13247073064443362933, 3056992278576665488, 8216417459286092432,
+		15095644792163717355, 9931529712396800935, 8608932369590222253, 17019087735655287783, 17120516184457264144, 16412592485673181957, 11221555966650765276, 6815162077372858604,
+		2239262553722461896, 16518231021003046485, 12875479040073845800, 5243141733462514317, 12216971859495819530, 8917663622006068692, 2606734295032613674, 11237688605489138628,
+		7270238601276019194, 7318279377964882079, 5226788506940171017, 16838449902078450273, 3375184937745100689, 16320655850583231520, 2173229791272659780, 9816381971766204380,
+		11061652864259684005, 3625039563689831268, 4435107405432574197, 17570841169180914890, 13981724030179216670, 4992487505540472327, 12893808204753555435, 12899171569920731024,
+		12002788024483301555, 629439982201171214, 13749214763651595011, 7164215996082938159, 63895081825959000, 7006379700570403491, 11929054672290963822, 14290981753366049931,
+		13554823979828564217, 15627748053816803157, 12924111102804720301, 3165135223777020148, 16345805559363705538, 17656153856991335888, 5211305829410935273, 17846236012427517420,
+		17113448198982970082, 8879656883528014268, 15215762680430094206, 15232212751792759071, 13699137317730183483, 11815206710130297569, 12298409691055054593, 2192455093917691024,
+		6973243752017383665, 15334919534387330350, 12203459507012560294, 1880762698376948842, 13008085926447766632, 11695961991328184563, 1311309249708428072, 11981691262998313807,
+		9209757463013140118, 6782250604095077195, 7896297860376631775, 11500117438976638113, 9099678680126826621, 11908588510950302487, 16863479726536938776, 6368086884375751995,
+		6220904427249143299, 4501361418756965744, 13907877383736656540, 4499586229279778873, 7233050316216252450, 2775027076708404645, 5669561106187108564, 13951461080947060780,
+		9742819322069712752, 8779224519997661749, 2591205872359340025, 9144644967919881415, 10495832103710459914, 4557264342687723360, 935865282128150338, 7120324256648044882,
+		10780007491891304021, 14382731247791652187, 3296810302419712004, 12567831906993651128, 13933396378746555124, 9754754796778422405, 2905077741505886450, 1522919492210831578,
+		7282056954663740402, 4915867300034445627, 234865561845141598, 8874426225092097899, 196269165389812019, 8951904020835594063, 6908903359164319029, 14062039535595890356,
+		17922518107542393156, 17388335427727081004, 9077910363057082196, 15157438705071651749, 5615196861086779767, 17404239261681991687, 9772161835068093639, 8380484042808490346,
+		4683169301229531061, 14940390399739549639, 13128742567354398401, 15222231511210090535, 7352694898928671332, 1221555526903686446, 8697118143614336514, 14515400523185205597,
+		1119145169329993209, 3453487026721044641, 13723232966162256192, 15282444658208236515, 17806849942057939434, 158876409507122147, 11954364486113732203, 17566268785944006600,
+		1443798830844295330, 5744920153630226551, 15739845606128975055, 10458513157123726949, 14711103578835123416, 13886988522344422595, 4454455988362290346, 3507977514728491242,
+		15328194945269186082, 16398971046683442289, 16293780909421539295, 14488637138080135219, 1108438550767062231, 16291467684905586857, 11891067917592351245, 10459212739896579624,
+		10239864229747754958, 12477284975467600510, 14054830413782031834, 17752968481181892755, 16082713391521411762, 17191329716867535304, 11245514405315337909, 15159733745232554536,
+		4102022129275956496, 9361580273813141387, 13824110615577377618, 17115977884930866990, 15058705994968389537, 8039281695081359531, 7179945727911625126, 17628825480910826356,
+		2477336341361304271, 18030759410783456479, 1164757311756325043, 14195508307731677040, 9794350654156795137, 1135232100348022155, 16693007636113380448, 17770308235375345497,
+		7064407865619227176, 13284912648471743270, 9099541805618279168, 7383718461788433067, 3311987567268438113, 10943963018398042859, 8038765968977300792, 11039205462473399718,
+		15444441705629456398, 12030687282161152512, 16500102437404896225, 11467410246278043769, 14031300093087427598, 14458597378298191386, 9434445586505481169, 18221119130471329822,
+		2269899977501467759, 9674818903084386596, 11781166634280447465, 11752600152694102168, 14011747753002945247, 1084585411243442928, 15614695372212325691, 17196679090968022414,
+		5062812993852092949, 13193601915773858975, 12910718608861476282, 447390754333146274, 18393090736120037653, 13231946117349235609, 13365030203093499221, 9724404925244523782,
+		18064151108813428175, 3928735035534454387, 186686833744587171, 18406101378699384605, 16477405641027895528, 697258480673566897, 8958117283476321666, 6970167016227017231,
+		12694666558858009121, 10992313774737315187, 6046508760845509477, 16818819584649823054, 10464090160691032219, 1221502600750419478, 8658907655588546849, 16110628890984509877,
+	},
+	{
+		6266830413981331818, 10890859480409122410, 738708598357264321, 9241173142142102299, 9152169484987657321, 12122430118903337055, 14270062735458703743, 13877635605034675649,
+		4572419849863661964, 16330741525817240677, 5456771007607263420, 8798510164381810403, 16547183593064549865, 11355135595370359779, 17581910791451710925, 11684604415749005488,
+		2766130068233451740, 15909689412657372214, 3272828023364980896, 12907534005596438003, 7065629942275705493, 10609982651084321649, 17330343421617897811, 1746246157222856918,
+		13168953859078137190, 9072500190247791267, 11090199374278127099, 3503847851309060744, 14395788825673846582, 15073993563711333791, 12879874391706003251, 15417028700542288171,
+		2686132933630431595, 334448852204016400, 5636563341880055087, 3897420469445246068, 10569177829735084588, 8244586887721364305, 17973493209847502315, 18083956436923498083,
+		15514509130323617046, 9833490355170899102, 12028021566105512521, 6349458533674010018, 13470024118569549588, 7867188201997717819, 6110792121234766402, 9917858515766574695,
+		8273062939911446888, 1936638151089648185, 44602505720759914, 7839132833110815763, 13045756168264521992, 5375972549477973022, 16964151563535745964, 2871770426902555432,
+		14164643693563803212, 6386904235704679249, 931435629437735510, 4496152555914735639, 820099532545743339, 13419988718062417698, 8948965620484833159, 7238410427920554862,
+		4387941928212462673, 8023190031094282215, 12322462122895470016, 17311901330042910195, 16445894183838823370, 690424095855074674, 12820742226551488738, 227935274674223825,
+		17437729542205914525, 8439533239207225162, 2862942422640746698, 7340866642549630610, 6770451500989398335, 17262212260581413381, 2156505157624055602, 12195119268846383898,
+		13685370053507732180, 8304030489296890211, 7042719123662732989, 12115154796394040286, 10496877583013829980, 8909625177349683785, 5268451666475070682, 8910488385056259560,
+		8874918984373509240, 6652428549855789281, 14866714872885601270, 12093494664302554643, 10149999253136441007, 1611873554177023520, 10271627298853910516, 15171882630355491729,
+		17085353800722834618, 3271271583189511718, 9338466116389304614, 4685545953421459012, 5059702655119414343, 201476627889215522, 6388612869673101372, 8357217932305360896,
+		1836621694151238424, 11438765101326043062, 5537182303007083642, 2657011195641217678, 15370176245454161308, 1478361893117141052, 8729368992402422055, 4807782542738120272,
+		5084555197036037383, 500829604818691390, 8128181767026348964, 17895639808733462562, 4138748420878083709, 267892430674902987, 8954358455330696651, 1946224964877667668,
+		9440495138081785154, 17328162383695942099, 1870751290505230781, 17987066187778049275, 9952223038481207705, 10126409487298126876, 1181369784146909444, 8158422380540037915,
+		13005094963168549814, 7254364757817833162, 3708127625424981603, 13214729399033107803, 14306349749849146051, 6983270854272831328, 14340019638575491596, 704963281855585401,
+		14561080905697443279, 7640393429462623622, 15685656608213407004, 6317405842945074950, 4586197269496115618, 4352991463721324184, 18421865732314202847, 13679296167045126011,
+		5024751682397066348, 16464187416447039066, 17561916915150311869, 1553872229528720506, 3971081625989469183, 16363381852589102144, 270446294712200212, 4668332646727035585,
+		4623922898967168175, 14927682190770218553, 18082407698612059245, 8156136453512346914, 17256761355350416250, 16185397881787027880, 15277309552707416345, 5991448876439153037,
+		1334994484802978518, 6876293985013000163, 4439518198423905531, 18287119869714109760, 10942138263490204506, 13981840082343935999, 186527448590996253, 11759869552919496944,
+		12652601656062843187, 3947181446273381189, 6235196886760030384, 10531746495897900463, 13249616872107073217, 7937663398525899211, 8701780810784627798, 5901496026068341468,
+		1059285256835989485, 18284969105568513488, 8222225088165109003, 1178299600673068913, 16068875143685216551, 17849596766342630525, 1648308197824141718, 6344465813776674352,
+		13850247359965870279, 17391106451201459411, 9882112511974412840, 9027485913083134379, 2654737707750698953, 2829872619210764000, 10765067664204983675, 6008367494734883394,
+		3596754664049660092, 4049565277418079196, 14294713401434678004, 682517403208603499, 13234861305501540306, 2878761138137340816, 7563571058666806838, 10752984583868770507,
+		16399575624290910947, 4698193514990054887, 16222170007882213172, 6300376482027477465, 11587700570984519002, 4408509191665524069, 8909599698892352923, 15110169407475815879,
+		13814725956725513903, 11675366986709837701, 8008867936756292473, 9627238521208818281, 500674066787171963, 7307892989752288627, 16701476208533897826, 13745712031279374379,
+		14988991093658383268, 6586109441484875615, 1456715231981080716, 10587865765103526958, 7439504550868615754, 430398141621608230, 17710495017725824018, 1267747579289674850,
+		7939033276966801601, 2952159422351169438, 10439776924885737877, 13630489377585028212, 1779349587540144503, 17209739673050012100, 4174716919431642272, 4986592555205663040,
+		7110204405213656469, 5225260473696365908, 13544564684169074596, 10807318789744351361, 16301252682064971136, 5046748520130689465, 7049174921499294642, 433785658536711265,
+		14622798677938552282, 10254953149954221954, 2609148400899865119, 8197897294400569748, 11784700166516996756, 18107483989994737564, 5332550435198791193, 13389061302706010047,
+		10892870009313407934, 5709686117526627488, 16343828906887149047, 16063790174205876315, 9076070192754075075, 4639156357669822592, 4904064385440242264, 5942264027390072320,
+	},
+	{
+		17271984572727555145, 2097715321690717305, 5328035183708920909, 13206781766168781008, 5915693606819932446, 3870849056297265622, 18070792155150730518, 7786839743829304936,
+		7939886940063870939, 3597929036186322512, 12732772396498766041, 13300425267730247515, 2345112231224079293, 12327614629296314761, 17106102937162407683, 1702694317559034053,
+		8821632341545057929, 16708916351043551467, 9171560460858577216, 5711973041149612575, 15808302665077457285, 8412173943543358851, 12602476370021215716, 4778674887660148537,
+		2707032230021934480, 14943945588296447659, 13333962501998857701, 10603744732015256400, 3386903941135274495, 8507451908469049716, 9231176235773710950, 995464562185179329,
+		1251633503842168929, 8646405730060859011, 7525758827556699239, 12781503299321323139, 3762059070509735358, 12904588764985510882, 518456268741331092, 2752400776174997580,
+		2965193395248314453, 17005383961540689211, 2510904953800463288, 14582093408745785683, 14930278391247460535, 15319775861672772086, 7915822626743762260, 10481055458185028303,
+		750419144665626202, 4009275022270511551, 4810013488865977907, 13090697535304919393, 17408171061427940566, 13469810562978287715, 3952372983235223818, 12596642250700034956,
+		1497127512412966214, 11292269970549257426, 13920714718237672232, 1363993524078475237, 3687544717271789391, 14097532154250414203, 8367320351336033564, 11089672460564007700,
+		3927746316404254574, 9973240942982210953, 14122301504960485144, 13249357693517290445, 4259646940372475995, 13156585130751616020, 424701295260668232, 13006066175253059189,
+		10308406270137410351, 18444509448482991837, 12509509048086126555, 8343613342319774737, 7902938427788958534, 9924925722974851885, 3762983399809982874, 3397026083592781307,
+		2116063253535766674, 12792173758770945620, 11357854367169339661, 4502375174987631263, 11374536277081101446, 718846097450449491, 6555869089578359747, 8571702699293548804,
+		16993953276024768829, 12025590727803527383, 2672535181364381995, 2183111709986676538, 14822521615475063339, 10618745739454592027, 9957515072444869664, 4797521918890127374,
+		4582720743315312164, 18280419827142252016, 13380629421749133990, 16786942173448683921, 5929601960379909803, 6715621236552343797, 11192523517069751956, 228125323996215945,
+		11861176681909235996, 830114321507110720, 13132205092670772295, 15318287322892364044, 9027539547229346224, 17629383881225964174, 17167841317952050345, 2169650970520181403,
+		11366374573920831312, 81590945660392134, 3339836125719372590, 6176339191258224503, 13498384602634172923, 17380518646558253069, 6505222573402454298, 3404196177841425416,
+		18097777493026370528, 398882723487597643, 10462164796529820357, 7704526739683689547, 12438059168025171393, 8163001730991802064, 3319372757738711275, 11518015261707325261,
+		11235814273447729629, 17827792960634604769, 10951458440780869321, 13957342734404907932, 7344502969085321880, 15052563297577817908, 9276707332138855229, 16077312904856138176,
+		10945312442787809330, 8353703025227023259, 2523779015225839136, 5997809042199398051, 5595238423081509301, 1901941038793828090, 983256298544496123, 929860142706986099,
+		1859865867925261002, 7171610585558961405, 1708769301690637951, 1669524125723022855, 1126574755172968332, 2284167219201068318, 14925928881489847288, 4349400324295146347,
+		7809927122217534998, 6003738786706135597, 16541272992243715653, 11352602417510156921, 6070703545889058045, 3742828100079104877, 9416263310824977145, 1406892456840131842,
+		15907861713154660116, 1789008941779432664, 1086909323248385272, 5337878342158043460, 16405416607888113885, 8262005873603178297, 12775015438669465500, 18394022127507526579,
+		9832954710628449545, 14612341389215489179, 8860090710725054989, 501948203387806263, 9969784653624607958, 8524029089859194791, 18028069685553315869, 7863046312587606086,
+		940114737935470576, 15661699274328042324, 2496303902262203344, 17900779334646110602, 10928989106385540880, 11160326060698033088, 6591628982832414200, 12860480197090465356,
+		4005088727670892586, 10215872293486093012, 7634075494800881158, 7707144163086802537, 7085702388211248163, 12168208652772836726, 16347414703478252736, 9386623607672009940,
+		10720163442173876242, 185901255673735804, 189524655270248212, 17937598483325200462, 9672767027914841820, 10911520298114954717, 17238190140596785520, 12302850034563751398,
+		1819872496749425461, 5856173707582412777, 8519855762092470428, 16315722646681962500, 11554620938156340375, 11822224388003836169, 8221825485736638318, 8413608007099273503,
+		16265754830488408124, 13716061973016396515, 6050948709307262401, 7654402024031530787, 149712175032162058, 8319305312043679388, 6115793437696694706, 9669523344165801010,
+		16530167766100505402, 14672843572926881623, 10752276706209340624, 6888427606311779724, 9060900993058482991, 10439396339124215720, 17640982730425880863, 12916411341252677116,
+		13182242421100666863, 5267519287044706312, 1780278156705475292, 12839545421803851420, 9724873776343820617, 11742602593528879231, 7598735248774560112, 4512374343657017031,
+		15080601286098047668, 6570749562833033851, 17494147260115946401, 4878559727303047850, 2259644365338981526, 4232993783633913284, 3035566741498855042, 4306414296080197928,
+		3878740698199360708, 1631626027682263021, 10479957065093850273, 1678395573475248815, 9964111965340163993, 8992208313996775841, 8147773940555378986, 6205594793300838098,
+		11776245660806714247, 18129100488268011560, 15389929343761297429, 14544292652959164154, 18063319363114104433, 13433144948667100183, 462314076175867487, 1862686058702915115,
+	},
+	{
+		17596113920958619489, 11920824479658301378, 3786905428099710821, 11112764289322906111, 8817260450068629272, 6518847791514184438, 14593687325057339783, 18018581321332807475,
+		2056254186648603335, 12143016575009965669, 3290271983033386616, 4338404082685850854, 12660444972475266123, 6345409453044955404, 13278869140778657354, 10063005167581762786,
+		5303950317664091150, 17409642188139937758, 12135894348302287058, 16444741243419918751, 13935885817311324323, 8496908197501732703, 12163317723288843510, 16891353436915314685,
+		4168420842704770545, 338440394515115377, 2102734009665481092, 9772725684473416465, 1247616337419130000, 4222072446972129729, 4836898447189504007, 9154346000276664999,
+		14649401370738987318, 10044081678892811795, 1306517740393103656, 16586067283450489622, 8211832777731897494, 12849393859171286949, 17327526552807783018, 14171704619529498238,
+		12849053390245557890, 12693731077061619694, 5891211584023409476, 1008960642219209210, 15593393872187214387, 7381248773473326001, 16559656086795428559, 2106025108820858934,
+		4347667984894353308, 2129883711661222690, 1076488804494872856, 15059968377755299195, 12380937310378496242, 16425480883270944108, 4769192332535557551, 10388305045430499744,
+		8553482596123775980, 12627020622203381515, 10774788686070344669, 6271789114731522097, 6270586844349642345, 5584690155569770537, 9478526526319537174, 3405597782572827563,
+		10255408065071335198, 2384996481315588922, 10679447117297819075, 3734157461055440416, 1635042286365643780, 11321809677772938996, 2373960964139986040, 4869129159740273704,
+		16681657814739017038, 2045405432090866328, 9473434018957974472, 5549808619751464269, 3650191693776946828, 15805634549736708741, 16764187297356548667, 6849534466635874363,
+		15295973549776084894, 8150873746601283651, 8017271980921908229, 4899654767305073834, 15257501950484641691, 17365331272978440066, 14582514748324426172, 14727798284858071666,
+		3180828552573045472, 17698570278585440462, 8986722854533057232, 4518665117523514004, 1718699978312382231, 16973074530347269964, 5684175730451960274, 17228649521631238473,
+		2897180423141326703, 13691273076814343144, 2967066815351306232, 1032540647518716635, 16365716239989474776, 9503666134295232767, 4599017511227366879, 14475021161770955579,
+		4512626226592149712, 13575110216387069176, 13488662643497927183, 9673147324484250604, 143936220816719815, 2307325398241477161, 468315224038772027, 17743582630124600591,
+		1476494936296433813, 3408612621327299295, 11632756669813257564, 14296719897220703576, 2241234207239321749, 12237974399755684219, 16253635131573079566, 11892871179872526079,
+		8492025373682814159, 9341562763134230960, 10104358220305514878, 17545404790574939459, 15737064134098795026, 3880597485411313924, 388663918823974597, 15032915458906101183,
+		965170717686924337, 17890763357610871180, 17588999527212997589, 13975763809893342952, 5109669798963414493, 7891916061794044612, 4789971769354067287, 13049661741280223048,
+		13047125712251887103, 6463859133854403980, 12163714608926575519, 1018022589444930561, 1736262463418943433, 15665908585957261569, 8814123147308650486, 4798595000205497714,
+		7506024921976923590, 5624217973379693717, 1727881279508834884, 6843292805721229768, 14721392495779901462, 15739256886195814859, 4955780690636679890, 7941019297099640360,
+		1679075860853192334, 11512607379850785303, 8606478479964129549, 11355506676698290554, 8638706560448426692, 11314948425220125007, 192055228531777598, 1407009579456262795,
+		13286048494307428802, 9003344338654830342, 14153483128501604993, 18443414499226619410, 1307798988667786279, 4422280407538765508, 1295189585361403916, 13026087054487841568,
+		2784400402546744378, 15890015749743051151, 2721137876244951114, 5096506081391833837, 7797931926335359630, 11689452583898581132, 14104784079353186010, 3188967683935096888,
+		11330231400343362000, 12540174755074499088, 10360616188128925049, 3458938550662172118, 9983547038346979353, 14986318734459319551, 6345635939240236679, 6320686366534231970,
+		14746231842102190633, 3622710091833101572, 12626649920759262265, 7005023704205322451, 8825692535315999015, 4515463777365688013, 9604411949030284505, 440641657645532650,
+		15551627195111259367, 17849357920181562395, 12870839822102241674, 13056924324197787476, 15109676201265834798, 12974964680406025093, 12841612415554457877, 2986633967268013902,
+		16172780290314506283, 6024364507532794579, 11981052290745212925, 14235100278052078327, 12912505872017936022, 4228821405313065812, 2097279962856941481, 5542690235350104224,
+		6815123236701278368, 6160442936745831892, 8260371745376005388, 715614132817606668, 7741929556783214361, 6266561134278568728, 13996537792746468394, 13116379830815883328,
+		2212637711439965528, 14217650183061928416, 540869510933311267, 6195450915592159668, 14904187357299823445, 5215400274033728644, 6907285779833076435, 15804222685871187391,
+		11124404141552478131, 15318338152189072517, 4067893425297764249, 1697503410612817642, 219476584157335935, 13106826093753036522, 13049745208482785760, 11832231199490391669,
+		10493328169052594634, 10627081887813813659, 11388663495964140754, 1823051796271862577, 12476400584366298768, 13709148086980681224, 4023418280354022922, 7805776130903851852,
+		11989040498741265687, 10985482710426001838, 598034896692782488, 12230542700168560619, 1496676485546951232, 6833695919100964828, 527254545105454187, 6276811762216173921,
+		9452334891928331309, 15207477416486363718, 8081596400773698461, 7528187414539292243, 4773782664413845594, 9435822414884353799, 2722451711480791323, 13642248100035410269,
+	},
+	{
+		16570512961992288509, 15784840936011612960, 17797638261217375128, 10589124475671334830, 16848440972121709899, 697679021479737566, 1456738239410270672, 7214966028857473701,
+		11434157439953722433, 9090860151661100670, 8407869262026581159, 17882547383849407986, 5277257988019769029, 11463853580825342183, 13607489835500075467, 16878800997498950751,
+		16059297404709367406, 8426877510924536482, 15269952608796785555, 6256768900860981984, 13142655793714702073, 14566340391957173918, 17147065283704191109, 879106195264399,
+		1169887957113173798, 4936710663791789838, 8029349457377894665, 3317691225106441967, 3622769674498678594, 1954144360900150482, 1432045977341997899, 934737636789214593,
+		3519438486034584001, 16935008858078961013, 11197550931955434437, 14100007087636813411, 11096181469792598416, 1355325916242161182, 3003143504356161310, 5855778258533244174,
+		3469569649879539425, 2734409579230557820, 11243101718460963222, 14449395552625174865, 2832531264658408884, 12736053595733579053, 8514265014627300817, 4646556172848350801,
+		1035318057221356651, 16671259128991069733, 933190532640544326, 10073090919720429370, 16298191828003546946, 89465711115503243, 1726024123088964037, 6293688775358665990,
+		9646181593082190523, 16068017411165381498, 13319927590045936565, 6113055520205251774, 5576373032696512038, 13880344501714804196, 12022206929479211261, 7387979357081975315,
+		14353322331225872624, 14137906560696321406, 9597841809127146330, 14479164716385450316, 18390885446667453601, 13789601367024187697, 10599569472420906075, 2183893278236533867,
+		17984045804937170919, 3008713646989855019, 11485907798025297413, 14380740919052976941, 3447658178143557676, 9095585806057103587, 698302327819557146, 7922185712178340950,
+		12592522203651044465, 1491459000495558958, 16988036704095888812, 4620491143241098446, 3378886739158384486, 4601357523445825298, 7994566595487207192, 4507705687201434902,
+		13553890993911526641, 1237937561304731611, 11053651340854998814, 8737874920379363783, 15414508226001886918, 9311523317130687807, 12080742822716708234, 4715194040021784977,
+		11413808093931937231, 8917864246709968658, 13554307490245863526, 2827250138133094370, 7637229863299622584, 6947884496333162143, 4815638417787805223, 10291803792760846879,
+		12634048591085853546, 14321728045924893987, 12328747445286182403, 436433860116637979, 5910966881246245784, 11478152401127002379, 15956760875311888867, 9580341487614973173,
+		5405380974793160831, 17240616607222875763, 18407061562244315632, 1777973921117407170, 6264824459040652928, 18267228171835175724, 1278124974392461846, 16099414790431742315,
+		17182132836049601530, 1486820395924546410, 14089047182364760490, 5375431386740917568, 2352352269256972682, 6220398075470064021, 11444733678216077372, 8173002234516562536,
+		2862732059898640615, 16485439906762588046, 8431038226899400253, 8931540904642954995, 792388953489761723, 9296018986570869365, 406447163304028453, 13270392174836298982,
+		7772216409762031099, 334915652033124323, 9705063888720244418, 9829080877134570370, 13800256788887079067, 6121678265481939341, 11747955988727867922, 15561904257519022219,
+		11919247213871390231, 15058232650937578711, 16509435050946309716, 4585646383560577121, 7109079914182671169, 11070600764446172401, 13212464399509938674, 18057628120939602025,
+		7896339057146013415, 17613745684396593735, 4238258305077796259, 15438639564771394288, 1482402451684594916, 3104492350488980260, 5195487229736262641, 1361150797580203482,
+		16473144777827648385, 1226441665397311636, 11587851779002173636, 5723433682141598491, 3818559725806959172, 9177247615754603193, 9531025756553277601, 1716800965379459594,
+		10276432666086031385, 14627452075834666747, 18000674623336885291, 15328386422432799237, 18139556051577750412, 2213209867616444127, 9597214736611625280, 2458176131336755868,
+		17117806110792423322, 15887422186644000204, 18208397717053970445, 7361598408210891485, 13818554723430207838, 12816010025806087198, 17883064936092688211, 1716893191215908273,
+		15949855327936545010, 15892613064802301412, 7776232754624386979, 2193423430757249310, 10751855334513902678, 13772090376350944100, 5644047706587449960, 370992037484721524,
+		10797607675141630710, 16625594903133516890, 4419277245854893028, 2258389314023537326, 16758443963306613299, 15289730903996513589, 17124263661185245991, 15862017582286958991,
+		12272869926038995590, 4569089761627301260, 6495211060884501138, 11124576322292919277, 18314798224925096163, 13232331582712038213, 4402693571738173484, 9384301049965683996,
+		9611026793910805538, 11152002731283498747, 12528844591327054806, 1485961507414531975, 12820893906402770618, 16248407567081091370, 15794078730898691457, 18231302945982292403,
+		16329953561108738383, 14553061366216182492, 5112198484879130320, 1893048255589705004, 11469678860036344015, 8992526488267920066, 18208245559304821518, 8980963391041920447,
+		17694621707784163170, 16317870945177246022, 9173265111786762052, 761657177655159269, 4876597178189658673, 8185879737091523833, 7520213092991049248, 6827963030155074898,
+		4104149897263226969, 1008830393844825523, 1692548451180187046, 10984924503299463085, 3526468436911084942, 18012043951628458646, 15181223987778535698, 18016160796635284569,
+		1524865955503524054, 7479709667052337482, 1064851658558537015, 14404181438374010311, 192685278892740648, 38546070651855709, 17006752915941498851, 7120034574635007914,
+		5783711159088718530, 3503029393593618754, 10736192136662142256, 15443859608128978668, 271805305647187927, 8244170003029416464, 17017071503038388446, 2536084345379259313,
+	},
+	{
+		11535283160083833975, 15102917952496589829, 12909095696891909745, 4611119212602854744, 4195756524232932570, 3754603965149529000, 11539276962358607816, 4401424391553230481,
+		6842993463058627120, 2708745114617181146, 3832382691810282630, 10333834458057320812, 15028197197004077388, 7681293343255119354, 16227537691626587485, 6703363869832495607,
+		17567108285065737529, 8693245930330183070, 4025672038042952121, 3491067119247522844, 2100799837993193702, 9579542950705774054, 5091525285265581997, 1806757015709820088,
+		7757354840118131559, 16227348978414023262, 5800861674805516343, 16486235803248700961, 15646700163023677309, 504258765210816549, 13724147899924699697, 13588899538317277096,
+		15895596198730294923, 12513494396374459899, 13552575153453342654, 11312160635199213507, 12446618129881485796, 11286186116805515445, 1584191291800429567, 10188741008566636830,
+		10157626021970320469, 6580688164585715207, 17158416694471177787, 2873484006255074946, 14852216457444863041, 7463041347566136496, 2190030775722958628, 1116223035803602728,
+		8598875756176012541, 2146658618778432566, 17575736667490551813, 3602654209723135985, 7223347129734689099, 7256921024940026570, 12249118963297692963, 18168532365040819099,
+		7585174044375463988, 2491923406404093282, 9355733262044036112, 11484079611349577325, 13145030009254943291, 1234932884591406048, 479845670619308618, 87735010308690865,
+		17307641427543377277, 5862898330718319545, 485176909118483750, 9845223919324484076, 4293549583740204024, 12765124043303931186, 17870894781132657382, 6508172378961793849,
+		14234156373312856400, 16210939788814051708, 6478880037923038392, 10435512103812909561, 18142844321802359753, 3243996803126554757, 395603619159523019, 10213589535656704607,
+		13256075137060741204, 991285459654295161, 7857174835799942102, 16201105040554625727, 18398612085349994216, 4512860776717176840, 3521452275695011919, 10622137733045360311,
+		14993897771652736376, 3320388672992783302, 18421556740970114213, 7438967127794745135, 15048397725789819354, 12721899159423777001, 1135125102123667189, 6637485660805148630,
+		205606553319362431, 15484041062449893984, 12896720585684759529, 16675624014916513672, 7579112430564108390, 4602460356900251082, 2677787525524280838, 16723483619407414479,
+		17981939084373319995, 3989926231875116241, 15342509934701840045, 12999252495311233519, 15389919024942778009, 6136335679373143315, 4117381415379544275, 13342256463740646775,
+		7622769999043907199, 15227992053145045634, 2719412067263856950, 17811161335980566241, 15036003689029442301, 4919601685231030712, 6756893600905532338, 18029567067112075531,
+		15804957839814547154, 7924193945337173678, 1080401129055171214, 10816444561878528576, 13171610473229361771, 8099842733764406841, 9284741070210451667, 9245195215372025289,
+		7352706423771400643, 11698139248518535945, 12836997796963939813, 5747451345763534394, 7572033904536738295, 17752330422795919668, 16404760947165813434, 13477251724246705199,
+		13700661979310397040, 11172816633936827025, 7087232997755437759, 601317374152115944, 16028751590837491967, 2749566595186093629, 4445248645671399873, 14714182958477634997,
+		9630153311383545953, 6436885924177487891, 2150319761793765423, 3799049242167098053, 13902640603080497957, 13121685068446422901, 10099985117244683905, 10692630753099650856,
+		15680946025356791729, 10935239212262708062, 15255596602338430716, 15502989798538458360, 906862139952472300, 16128362872146694687, 9038121313842477036, 18304772087255114926,
+		16961332967315316395, 2872796507989583018, 18145413156795763341, 6377517922859730669, 3543621377523624979, 10701607653242580646, 17747200374013876449, 15987594633077120628,
+		3487728992359467218, 11271201736509774853, 5968332690756574092, 3519182420015237550, 17144214368301394415, 1805926423542721773, 13696269518209159134, 942126126861202483,
+		16211326119697754410, 9043490763746629445, 13119640043033532883, 9720862297941999125, 12662669665140843415, 2188499520755532048, 2671631563874698813, 621164898587943254,
+		4804461736506692241, 10698651491947798952, 3524135800884470917, 11451653751986650957, 10424912129082359813, 6912080226482239953, 10357808719970986526, 11757540241185558439,
+		1841157911016607198, 17522398974331009019, 17392843956059453556, 10510758656389762948, 7666344868273530034, 10739409534839380580, 18010518965344703872, 14478457810678500914,
+		1617286442811984718, 4008909641875477702, 9328654790542709745, 12015676532404599710, 1763241944305573436, 9348325841675336084, 4072126498552363080, 17245688939115723821,
+		17277555838655940279, 16604852268187595492, 11674181070138727191, 9847423407697994070, 13562477602392929772, 8181792789545038731, 6999326623175714057, 1227784795779857129,
+		14923095901189736698, 90760593075377861, 11732533481504731510, 6000651333412910877, 7847865090059184838, 16859539404919901595, 2709105957383645337, 10263820965340474390,
+		3161036642361826348, 5744405044938832483, 8939741099437920817, 9766097724147073614, 12117283480449144394, 14632688836103128438, 9491651214417380913, 13676064073123352224,
+		4673738700738845848, 2758750364605631228, 16596306154038523740, 4124917668203310922, 2170509910405778957, 4178077301639210933, 5109055439238993109, 9627760120514410208,
+		7259236533647228872, 9608619771663043870, 4148523959415435806, 8831501534166306825, 7919036824652396994, 13625969543100731176, 2546426055029800579, 14852443398434563210,
+		7185947197544988797, 13306809398790059447, 11440959253278285287, 15084384140482244570, 5059824327869316332, 7585354587200615362, 6801884469610571467, 6427162399794357267,
+	},
+	{
+		1453348772281274490, 13028088570940491471, 16100623112750251840, 5210244400259879874, 9443916155735416174, 16869520919318450506, 7479400208826706574, 14374970913352602458,
+		10149597276931117465, 5778043705364022356, 13888443605241209218, 6889225091714429810, 16209363638493043975, 8516350006446457646, 9214830076046105138, 8894115046323798175,
+		13026208197163596446, 1935567165776196957, 17296090833026336866, 8461284827078097590, 14545382879887213077, 3302103559307506085, 16026840048628844803, 4599071908983273604,
+		16375505785562641226, 4903074653735993511, 10355787845763031761, 3188849033041803587, 3145147452182864049, 13878747873108378466, 2798650520315922121, 2325962694441538199,
+		3587824003578414733, 14942115314012282784, 5312737955169054323, 12478174640832111702, 7866537714619856949, 1076672758151595875, 12163513815501875048, 8343003998956997868,
+		1392855790923554429, 928317148609633070, 18064469091536763974, 13446092366984636072, 1975222540660444795, 15443703204026028192, 4016450768356916736, 16656367700821047808,
+		11505659892372808762, 10322665279031813234, 16948868760451861492, 13706671779256832515, 1968671033447691229, 2446599110590827903, 13721045634744350023, 11053432744256776013,
+		11530583608023224967, 15979155166527001287, 592931868138800645, 5361781029549479856, 11246418752830406096, 11882251984248471436, 12026389461944629423, 12289077922798223820,
+		7685868633977346753, 12528120620943035447, 18394735788313062922, 8523101916703102094, 14261596878655792929, 6364753027040158382, 6433482955677830548, 11538026548937002170,
+		16221339092185577802, 2285289075757313223, 1151823739515800834, 1010537560193450047, 10651328720714490261, 426599792903611671, 7181136719074122463, 15350479907287263858,
+		7559201271967630136, 3561344874280275357, 16379496429080959327, 9662226613694502966, 10995850494788192620, 14875349277152338391, 730989400822814422, 14352408679782573731,
+		1328339467113622233, 13374824154992864223, 12057132015324007824, 8507647484414695512, 9286016370798146986, 9083798709648036612, 4312959727577073260, 3732271624824420608,
+		13007262390446754395, 5631627784562092966, 2644488352265945851, 15340614364643014664, 6692152810984634488, 3903120388658969320, 2513009101887784188, 11999681442010831364,
+		8301343575202991577, 7108394080005777057, 3477086484634015274, 8772644795325835021, 14747670046873500269, 11068536909552811695, 12349879357573378133, 8898863927320049679,
+		5231654281125841638, 5181061730027800171, 10657176101406080919, 2548241936122768256, 17140253194139059526, 17961047717804458883, 12407260567549658707, 1464243167234637194,
+		14129872794455315922, 16354810591314135702, 3177417010197743958, 16494351130927698692, 16557765056328447818, 3139394196704738651, 16891813998271303650, 7374470997276173905,
+		18244279644122204437, 10097660526910786400, 9270181538098732492, 362243376823712218, 12369863141977485111, 2550957813014523686, 7768963959853738595, 470330801228165919,
+		14632133560934390222, 13844843545192224059, 12232948338847787315, 18223343336729121487, 5219716370019749202, 2729037467284418866, 4546118556621109595, 12191675540034649671,
+		15868991745937371466, 12686820201922367283, 14799186526268126508, 1241626948050017911, 7080072468753824165, 10793537086099229143, 7855065677501047369, 9747396305344084667,
+		1547814412223404746, 14194709348405912167, 15771028929623393801, 10945048172868684389, 11234483878611528405, 9542605377580701681, 4555391547268120796, 14916872217451960022,
+		398873176015355134, 17609838001051405497, 3752252377312468061, 10441993652683449973, 5218696730429184844, 6514361533063264268, 16024112124035725701, 13453525984055386124,
+		3452753233449684767, 8937677805622461008, 15346651759545553711, 17055791435062851045, 7025089132368408239, 7345356702153522862, 17760529714295220737, 10772604293313163303,
+		9940223451501501487, 13671810088603813912, 1432075826781639138, 8145669182511487125, 852664959675237493, 11640273224943853609, 16220508798123490173, 12787926729706993802,
+		15490131882364039637, 5140304620645573547, 9403655757498826823, 9824850954989176893, 6366139388903157264, 1981838834216345294, 14659870286877979556, 12091578124492612524,
+		9672198938588933438, 1848525214318852627, 6500329435429402369, 8547555101599185897, 4282139019453982058, 13391782461875853462, 956960429753408730, 1865393350316759140,
+		9155847368519787501, 17397005067762861574, 9943535970799289809, 16365250691105460494, 13595148040475375224, 8300668237654861875, 7149654787413440141, 9226755501324961219,
+		9359301870380673800, 9344500253098672841, 282669288080771734, 1996492472861301505, 4777949892950526502, 1374151996531969836, 1529729047243522545, 3371309923165192567,
+		6832171775190531128, 7903951882621813138, 13717573220828409267, 15400575122727850054, 6101307565293576434, 17226772767105983314, 3485283905347036760, 18439321272895583847,
+		5095761409418784463, 15484673138064200869, 7743962634971666154, 9119597914470879266, 17978461537972396088, 11490423388734028778, 6537551181013090408, 11706370534703673937,
+		6635008658379780815, 11428304571924124070, 392068559161657302, 16314310970878215293, 13769492864572584674, 16880907685897496637, 2877983831559338706, 10391660973242662710,
+		16861266984653213659, 1968749328591656132, 13301499995824894911, 14523175695360471336, 15130688872832023531, 1794208537894703529, 10525607764904270704, 14288604199111912452,
+		6289130721434350290, 16129337673129720846, 6648351866142453445, 7705983837166554199, 8120136556582544814, 7924417299222764443, 7821995671300500892, 17697662726179084739,
+	},
+	{
+		14086745261650819748, 17953107869776717888, 1777725846494438428, 2765314406831814212, 2603997194371852991, 2223517025105045134, 15579901335531749634, 6571733615332171148,
+		5478465698516556930, 287443454357750768, 12201204663663129285, 782849770204658255, 11270045035009204251, 18152683972363144337, 10463300037926642739, 14363641589598863851,
+		3790592075869665284, 5120320091554329756, 15361581282394028709, 14360464660911164915, 15249656958991931940, 2563751872827049233, 13745792006936646733, 14572943674933168173,
+		3167679014977537749, 3417445004776702290, 1709246158507866266, 5861367897285174360, 8437429877561342262, 17231607446243478748, 16047596399306766948, 17656438585829685897,
+		12977336347094692192, 13723871955002954132, 17399919575273038847, 16163973860244779675, 14997921584659740746, 6543247361992425067, 4675926398794487109, 17580512382853194054,
+		10778828023580771765, 9812611440536367405, 14168149065325522570, 6692229110872358750, 11010962724400581057, 13055203605065073902, 11396463140731730116, 16969789651736772232,
+		3285258013801327520, 14114268241282882888, 5367399533198476395, 17277410244918727028, 2751895479568588421, 751309667192066167, 13038472116718581917, 16013586354334596135,
+		12364168614988940500, 13194367252463423118, 12223406606527741280, 5014139294736037086, 11244699482831816093, 5336498572491451990, 14268404582568856142, 14502318820969599316,
+		13295673091232554814, 313981772853781347, 11829785736449464030, 13341198421333360997, 16787450350663111566, 6525407229623764159, 2012189087039636323, 2110887590404698758,
+		16984895766311549717, 1057465499230843916, 13565444352859773343, 1019268943988786852, 2190009140530404855, 10045598732295352970, 4789803496780829836, 10700158388954091321,
+		14840255112988420500, 10066628133368048408, 6527354835873855384, 16106607076894419125, 3989024604987083046, 10713316697020150694, 16811389107269552264, 11294596059797019619,
+		622403023838932676, 11423409007234191765, 17086830255702454786, 1213655124481948199, 3976593910085142945, 6315875935390432543, 17947502153968859628, 18031540937011531543,
+		342675887578148289, 18366454547938469828, 3853530442390999217, 7499455395579634652, 768597405171336502, 1636271570683567151, 16786205337983572309, 13056241332863199715,
+		15991153618414855143, 803325462494472241, 5709347424437559249, 10138502962472290727, 4675124205115228106, 9599016746550345197, 2769443894695609085, 12311020551315051087,
+		11470964304318784059, 17313372553735202469, 10686997186364536871, 9228453594798060121, 57933324335302024, 8931389936300346353, 17823596478938529898, 1126996688113949835,
+		10457697409306668434, 7830477435299250296, 7772379952622394912, 6109610138112185532, 4382803614711332911, 286231563340803504, 14408860285425706036, 9445290615796219321,
+		17536503470234411585, 10755841521760916925, 15905055604395954066, 10842889504280336728, 10780689817551616331, 12490302644719656914, 14399349211478895553, 6458867531104408547,
+		18263696007238300109, 14344529985676987842, 12351733186419515951, 14648750128188787544, 3817061805140294292, 13460439592176294955, 2651602395003150964, 17613970291099197676,
+		1107162420032075035, 14270134754120385897, 4090584027509443635, 16066949131129832709, 10961641187652236678, 5480069976143996625, 8549185711954755645, 3125346629140152790,
+		18337941236561689695, 2899707239319273137, 10519944305927777790, 6913088845356962577, 13796383125935684169, 2756403850320695444, 10018647980137529204, 15185795467001072323,
+		678732289042224133, 4682655677430115166, 4806112367076139288, 7101473987708012826, 9907594813802528406, 5572757906434657546, 17819688309930892783, 8734990255058630746,
+		4831187103439262344, 8323117365987697459, 10690753367486223100, 8744079000061869982, 12737295198832254982, 8667406752954112119, 7942221205780634447, 12612313636795726189,
+		16544756691464009983, 3413196415113664237, 18442955254149959801, 10193439941306925215, 15178607176290875326, 10962146035584651400, 11757614026658646304, 16241528460556234026,
+		9593194029396792148, 6376573619820601945, 14694667798662125868, 473733746941891591, 662607401339043361, 12105576520816361855, 16629740468317868384, 12416206001206121129,
+		6655696780366945398, 12313066500177107654, 15308290012322636383, 2159880960357061128, 12374858353753840133, 11331956329091160239, 11794840094276473821, 14170553661155653327,
+		3336445037682266403, 3746885541049520962, 12688476435907418892, 7399089272376853858, 4625608774712059624, 1535040330210000507, 6878676093546636363, 14533846142831376645,
+		6250279356724130049, 3901672557903829499, 4884397030724371499, 17385695093365573379, 1240675257703364805, 9703149291204612490, 10295741452056015824, 7249917314998921510,
+		3336800790505577062, 319907795530586958, 15852045830964927276, 5538471989976998401, 16558766045222360422, 3135574045680866961, 7590873965560972285, 17191236425969884848,
+		542161999237385999, 11197034618748267807, 9595673564043235773, 16351524685431643264, 17127456926935032059, 15448416181819692483, 2035065584045934249, 10976830957530152324,
+		3230012351101746458, 1662948417350421518, 16062645290454019168, 6021730506322388306, 9903225699788133023, 8549278993611431648, 16267339446315716903, 9759051179942016620,
+		14281696762614162345, 14970002486407845832, 14940104843292093805, 7021313216295048550, 18131586729996841512, 13957742754718859034, 14322894803959804982, 12861731196696133597,
+		8838210194055479741, 16190279688839291456, 16520121358582757556, 16768959728701970634, 17279896910204983538, 3582816187015369256, 372137484481226748, 12972230207718993241,
+	},
+	{
+		11480031272463364121, 2525856087688686375, 5875255653057452580, 5606696614467440464, 12094715534218447962, 6173479337351577758, 18244015404482482803, 13199349349511499695,
+		6097225965006328457, 2630336000831717722, 7049638698786526134, 4203465038263485233, 4677974565964393904, 16044036678123636261, 7266049959100300634, 11339674070148504929,
+		1979992348876614621, 7494083465935166973, 16035723662722831744, 6820849908885211777, 16740735239901023053, 2017530162004533409, 3087262288875984227, 9072904925376793991,
+		1830819081327272165, 11951292080860646547, 18002500803418629938, 13317986695217403840, 5005574200470766330, 10138179785738652504, 1610518863105278224, 13309443265578956954,
+		8383241685301818332, 6629521234420338478, 8997316634951392497, 9976633096395028594, 5171570735720385772, 8129153749198218776, 10596302915145665067, 3726383961188926740,
+		14494271933981109919, 9056473564311980628, 10557807473422306929, 1549747977888697589, 4534184223615087698, 12977118933167042558, 11930457930026683843, 8346041661496792064,
+		7756665146227128459, 15140824521273386708, 693427108108819556, 14819189462601222526, 4507393341357475468, 8710020646873218244, 4535796033535410044, 11884504632761707946,
+		14192194428653714479, 11578618567931657764, 6032668189933768881, 15981535562386193924, 8925792218631314923, 9408714146004183681, 8859017894477140398, 1675606340537058506,
+		13447287279335601133, 7792625320709870803, 5347956615552953057, 335662974452886013, 892825083599137885, 1017154417323307505, 11923254597349925339, 13818364932306372202,
+		15945578153358602744, 6304522416189552358, 2545503746231186920, 14563857419242252397, 9711931929315762229, 7949505077082864287, 8780199792032437102, 10109661610848827442,
+		1628958128919487289, 9818701341087940523, 16480240737841185501, 12633108361335093100, 7982147509828265471, 17959437456356197928, 14370416793872407673, 3577532534573396628,
+		3265119697568866078, 13753322853248061974, 15435163376825672274, 13646180516491714938, 15620545622955090250, 18241486585498394565, 459566729126467878, 9728217493753855944,
+		3187267754295885454, 7928049460349917700, 737484733736740002, 16459695106656291329, 13000947522838718027, 11933371771659873912, 4720706464557996274, 7997020276574823784,
+		12655797542121172150, 16574741514838026101, 13532097913031715162, 13578832971779600350, 18171552525916232035, 1516234640889581592, 13625693062693291889, 3869929504544890755,
+		5134589228918179333, 5186584327613952853, 4114726195152833642, 578924708883784650, 9128473117392713984, 17390547319520768186, 15077700332150016764, 8707446714183162237,
+		9883406233903270985, 17184231210468300584, 5498903678702785900, 6903833261382863389, 11489138095102981636, 9021901931786177471, 3227433089132150317, 16639455550797627042,
+		2873811051246262545, 12759149028054319339, 17920917684786397179, 2576455203420292139, 3181713670456310447, 1109589489775958300, 8920119044838278090, 16056330702164227666,
+		14277712977137303378, 3896132440952049994, 13252040000848248790, 7844779060499908154, 8651912177362107995, 5527615699397299219, 17688189207278018869, 14560189235973121390,
+		10861951673021959044, 16820848382034483641, 6761027571816469843, 3555385088072119757, 9363319138244920099, 14172742116400795253, 9535965929584057049, 15628517769546199992,
+		839045372102318861, 2032615141683118500, 1921816835840256924, 504869150737570005, 15932184001422473505, 7849475855313305697, 1189994394722618598, 9874798350548229684,
+		11973862230325381876, 7670835358390713178, 2113918814334481709, 2289514490388170400, 4570586695077036349, 9449360682811675838, 16506880875578470116, 13723444740920888736,
+		14210428465641691143, 15330786835024186142, 14173742373807858721, 15041216914246450688, 6027140311333696225, 17929849776014561356, 3955935517651718925, 12080548003455651805,
+		1974142217308765297, 2347591555456293560, 9029256828390326937, 15561672734848339972, 4719329765359230610, 1924866103348851009, 4950258359754995181, 3245952633715281425,
+		4636201671610663345, 16662311204732135584, 12398897461787695675, 1355753199357412657, 14695655628527768564, 1692838776852698754, 7346906782826540912, 14869028424564984700,
+		7242751356102425321, 7770223857340282376, 14976092066160539655, 389604327668352376, 3472336298605227213, 11456496863560248128, 14597769228654187922, 17838672631901123288,
+		10997764239928568735, 16648935573721932916, 13735964592293716412, 1364388817619955667, 2511134998006929958, 811167458534120344, 9371523327214092569, 9359553283016173792,
+		15311627918891973770, 17170652974122329165, 12620036374776436604, 17439165699070911984, 18124482726761033947, 18390083820175794165, 5492125340791896125, 16506113603670143446,
+		14240080119980315297, 4751983902385717684, 7941412103662252178, 4796803816695225123, 9327986654018000413, 15111345676387005726, 3582558555283734415, 11913156735178831102,
+		2000999613038609412, 1070613390669459171, 595743672188217500, 9169968884291187666, 17960105939867090032, 13927107353795575459, 17872593051171658925, 11087013461789649235,
+		2280207936513065312, 11704149285124951522, 2138093032627822381, 6816805886026674440, 12141709925796155041, 12164596600353477920, 5711177504477877148, 17211856235678509153,
+		6061025098309340877, 4060747063380827182, 15186975689243681841, 18380882388949786706, 927262408801716090, 7447789770541113239, 14074172896745727729, 15372475239996145400,
+		12915868875134296756, 3071143582305760275, 10848717856747030010, 10973183887638314967, 5983269487036236823, 9885184706933333413, 14509493669845681951, 9669608065801379977,
+	},
+	{
+		1190044221726873109, 732025666411072563, 7781096808432277694, 13079879637655900365, 9048680577986693793, 12528346194104542124, 10575369576322629835, 14068913038053465964,
+		3297775431071502652, 7947266993949467566, 6161673381820779563, 10604626734847205996, 17669018066064502925, 2386071939136502354, 1076023928806956187, 16075459682742916440,
+		12387028018538599950, 5791681577936683396, 7536922194386052138, 15377770247350254336, 6564316170002440575, 10629371267149545956, 16125760269901494382, 16051398044897962024,
+		6237354803374899565, 1782400080026955610, 16115027077529639342, 17907259814836219524, 13179234383592426160, 7302978467158243198, 13607720993463749225, 6693531817169120736,
+		9659467198848065929, 13765104107473534739, 820057324758632016, 16604163594878267405, 15321524555426147294, 14524167419333362957, 157291234996957911, 3689488130722730671,
+		13896531645245568605, 13598412639648980920, 3875086557856143664, 9242105512956135595, 17410265178284161091, 14904754836127450463, 2354327747158525902, 3858493849578874654,
+		17288438225198818690, 15275190140700748774, 14532856272428522409, 2192294551011758591, 4275966798014984695, 13252812474545742114, 8604705074440591847, 504054699541924162,
+		3623027910997185067, 15957466839356832933, 3504133700071704955, 4135728439139397021, 1160600455691338871, 4431928072859292239, 1542956305318065546, 14109181184369694855,
+		9135041378474229537, 15626265487594878380, 2645257479784082878, 8105679948445763432, 8579715781576202730, 13437359533149316300, 4344754720520585005, 13326372852934103673,
+		11341622086474305983, 17104958945811183278, 8154944722722765678, 6696975609844549775, 10895966360082878017, 2277686037575837054, 12236842881540344526, 2086470279064067791,
+		2942668817124399651, 11439025398519255779, 17477264434671471242, 9606507094132585461, 1771475584689465869, 10791261379080046759, 12901998265727968789, 16423426725595035468,
+		555419805011031621, 13715683285513290290, 15526654591995532751, 7023761423093873354, 15093366433178982304, 8625749648874372840, 6412297471587129206, 12161114204724955762,
+		9362623422820895267, 6491356159483508885, 8543224082493101588, 17290929683278258587, 17348088672546490894, 3323350644823701753, 398525379151271104, 17794417664139368677,
+		5880914635028486784, 2898124605786107494, 7953506026198179840, 2189477357380899574, 11207122442953694293, 9288539232660208671, 13527697625010979453, 448462453367651162,
+		11262205719433170585, 7539606872920196479, 492385789142086954, 16036594120332851267, 8084547797138041354, 10063336189771527714, 2484395715469739911, 4879298610504146231,
+		194633990068625151, 1028128699653523895, 7436102537486268753, 1855520454959348468, 5098690958966904466, 3342676718901330604, 6942212660412942406, 16510188838209674083,
+		8847926418142642416, 13342814936333556870, 7082971165114489981, 9307541560233171550, 3013250253632606412, 289291445038948658, 2146586262066552853, 17331519863134074479,
+		13747350589043267381, 6342477793304440894, 10087817302474912962, 18076409030930122816, 240893790090129194, 16364025156922886538, 13518167316464590136, 8034023137744309866,
+		14013962864860194917, 5900268096329749317, 578665371390927342, 1407477069341362927, 15142181569643383319, 5217173950329651840, 7999234477517614232, 14722759409199120103,
+		857809728583972424, 12785911478120621636, 11351522624307635957, 6288237507210579634, 15030282678317951238, 5521516375915920991, 1243458350248005764, 3567973108073272461,
+		2834660673354035229, 10728451420162645120, 13396052377701115268, 5730788601228223475, 1616452754395208882, 18236419625072278846, 1179103743668306981, 9179882267624091153,
+		14087439523312437665, 7814060325531094731, 16777382811045908592, 16916500419494378884, 16312259370378381991, 15848836870251345077, 16352246673954213424, 5228629139249919486,
+		16889782864065172884, 4486233301301317202, 12424854171669138635, 12490430652425390015, 17335301435940798099, 9685877269515541824, 8728054940414220990, 12781228698496150916,
+		15949574575791239459, 10394047428873141717, 15915386168603191086, 11400139144838475744, 17198578050070482368, 10505386377385262682, 11269920026804647377, 6796664536515856824,
+		3285292208372623455, 3132524240856145976, 9712372580979649457, 10523781046601368064, 4797168047433466290, 11748687702182632788, 4177442610271848350, 8549047039673741703,
+		6897143822689085584, 12727238507037725105, 12692443686524496083, 1187606781546544862, 11016254758711515442, 15622643445771261724, 16669571628491989170, 7099030384210775042,
+		3541342827520921014, 12596176563952906070, 5209816272233406534, 17158219989390045881, 9096207539532607151, 12291463442559161708, 5188945441827912424, 12721126884401346746,
+		8137171114112655022, 6980210601071561830, 10156197453074241467, 4481350962546197264, 1902625885079226055, 18310954340184922140, 10624840172920793227, 121304340390125189,
+		5261036238619130144, 1418912875050883205, 4741122621962383610, 17995804738511375239, 15493968366750472633, 8417505178158780382, 14685111207483504618, 9729483826733360559,
+		13434828863770210135, 2940287993177646896, 18241509923298296610, 7613631401252601295, 16815829390381900683, 8566309323681786413, 11094402941539790077, 8442864581771174862,
+		17650059733379916650, 4260524072883785227, 8351659371377110706, 710338300032970720, 5512358883882849029, 15533759462039713914, 14352344066268876816, 16708588250954382269,
+		7963995066277321795, 14986230345162551366, 10616366460602472778, 16186943329215681149, 9522855644164647723, 9858336437877021178, 16344942402271072884, 18027353494090590022,
+	},
+	{
+		13175608910844763921, 11168387468381338510, 5555873864224342205, 17780559602571640345, 1582669533588472814, 8145133762789622706, 1625372887980692455, 4576809104068554285,
+		2900978533555060931, 1749946807863203576, 11705734511931072459, 4446980691693419424, 14437524160594907241, 12795912566640000773, 10400036254697939154, 8356113088668925361,
+		8900726473285671992, 890209742292473781, 16059468388719373167, 16577940938542233221, 17381766864962227733, 231915274132518769, 16477817024012878700, 15646021286310268545,
+		17511864284462479051, 4391315454785363822, 16633389246499252566, 4290325975494843430, 15912670649662225191, 14172733821603328367, 12709802627494541709, 9648238681838878635,
+		4196883387800999444, 11261069840079702254, 7135968036494594517, 14537849011631244070, 1930221875891546479, 3029378442249928630, 6219774718328347890, 5922417028077454069,
+		12470404961188516783, 10420863874252801995, 1369334550763670666, 4781925915058005676, 13086538845357988031, 11031029468188842766, 15252022305121561855, 10497770692868889659,
+		8808726441417268278, 8201526072266158452, 1136378216494101481, 15014143365043073153, 9752793532008788265, 18423606089906807282, 12708377698545978413, 13697405528655748691,
+		12840624483048662115, 13614226123606379619, 15087571995173849344, 1395488309690794621, 7173958427217959878, 1198561064176820332, 16821886260165681626, 10019479169661217935,
+		8089335244564816024, 4652396396372834438, 8473523796721514770, 4493469844513366216, 5448577418901909194, 13487502520341193870, 17978888920023381084, 13125222810420128122,
+		11369140159803973135, 8391820975236191093, 4865145203995472561, 14899728882581231165, 11169032718524058736, 14532440521453562763, 7464998467530340358, 14981246381757614771,
+		1242992129726403300, 2014928170416925311, 6341058783517690890, 11690291498253019630, 15951586247597589423, 14033993236702971559, 16963725291567059464, 15075124616754319226,
+		9901328250515532535, 12796305315632203942, 10819069447660403847, 12542238242508661240, 17077777737462854238, 4364294351375777648, 8335244153165894685, 8863541604979427311,
+		12648774127830238318, 5576880401343711606, 11786867566889606858, 7421038047404952574, 1037620897405863409, 16680872357246325645, 10443290127564886223, 9718182896013830581,
+		15199007294286606824, 10225517367964809030, 12827778649823141649, 16046039393887815140, 284741135347255597, 4015036609703147909, 3902771329647468314, 5128707935422024078,
+		16953148044626345363, 5101833106541998042, 7655361325113312133, 15948906743291877728, 11619404274756349415, 7521254459857915559, 14978040810149334918, 18392994517091959591,
+		11029520456752683158, 2297291237551781454, 7934683676555855479, 1563954733146546128, 2252805128528536255, 10523375695822939112, 4598652721256818062, 17493379105069761435,
+		1717382065475436420, 12444276194160330384, 3605273785657402256, 17503422605669121015, 12066457002913396306, 18109827202111882684, 11555238022219952400, 1993655497207863497,
+		14852223665677610379, 4743851404709775958, 8525514757892437524, 10402777181498591725, 17096034999928466604, 4289543339828736175, 4306145672261807290, 15366124999227707930,
+		9159996652502914864, 10301349423202296392, 13530090903323000632, 4082840779249202050, 8824726775176314063, 16033767772359951785, 9181204573557660412, 7582747879080399183,
+		2747551692916263132, 3151123035150683281, 13938314333309683791, 11970864255483579560, 7894236725861110998, 10515613623232567716, 10445557830757066839, 11155097727742050955,
+		511773909731247800, 2463012923954369656, 15859141716591041471, 4940781664379556792, 12435624343534748284, 10278084527750129328, 13178135781125832492, 5930328346313533490,
+		9122100956633732655, 4007876149211873275, 8339438668849688737, 7791075492023424820, 1771434463088769532, 17441254147665904787, 9470298561063283873, 16552350513326886351,
+		2842235074681099572, 6045955093828210410, 12534027406207583719, 9023829328537353058, 1661393615224515538, 3265308219651631507, 14825441620546235307, 6190486519065164472,
+		9569762631377921701, 10341967309273270300, 4697570564829842013, 16684762125903667303, 5281929071085172097, 13027961546412671127, 18398764602992176314, 3872796039504642974,
+		3625046733403850478, 18072436321985678348, 12926724831909767455, 17260889391923475120, 2205546675974800411, 4823605748727161314, 11756378320036258430, 12725625915588142865,
+		3620769638269480452, 531680461898170, 10213227252513668871, 15446816035938502695, 15189868868814686765, 8689079054027125562, 10767300823767661010, 12185259819280811201,
+		2954211398425891878, 887045055614004603, 17024961552904496644, 11183183814128062689, 2275500228939836642, 8454621353771976628, 13706050871317440521, 13152782683288296426,
+		5035609627965208105, 6338722048255995169, 11594969687968475335, 5639340633771742838, 6928934109570365590, 11589609913085167707, 18353534295019770247, 6879412911232288750,
+		13223374340976842384, 5803903047180226505, 10382392856292138950, 6807712794865416975, 7273350714698980002, 16071615116869102753, 11130104866208195846, 17099222713467268806,
+		4288395624114587260, 10186593737807119648, 5970871638851383523, 17274628153010076591, 11083355019391773968, 15571651381840416650, 7269503864920933911, 34314525388851272,
+		13518907013113787435, 13799188114963266222, 10949327997049617616, 12851874981220611149, 14245323937486085594, 18324803746062213911, 13224741762315864830, 15910543010675195930,
+		10042008593756684008, 6713471518385846030, 10961845838926538977, 855334359173719954, 7598642325962297361, 18006511265377032901, 6844179774752820363, 248341098560552116,
+	},
+	{
+		9259451175701532574, 15597985540941612547, 4541553034987877619, 8927802479718285609, 14672230714928802576, 14284617950605306700, 13339970812390782046, 787078889494395850,
+		18165439414433063919, 14693282888419586094, 14992616289789993230, 13232208150801553912, 16850347485914337693, 223364064845089224, 7302899015436300563, 4391216311540396088,
+		12558388403188680537, 10687978569513354810, 9373570856564649772, 4079327722512691465, 5372437374337150740, 3297421622932790851, 9326853593823854687, 8305371884938201251,
+		13121472331750731303, 323745485980480220, 15110308702528119977, 4696302365805118372, 9859094500834571602, 5315656270700787939, 4187063204400651801, 1695695129564818327,
+		12817586844019849804, 15425488216915741929, 15293562913126043054, 11770898970765978555, 6806103820345670787, 17789094149138630459, 3807781571713999192, 5823254011289457198,
+		10112524230916015604, 13571143908656270599, 6031089010487808103, 5774558171390644848, 1808959243244841573, 14071312530426692155, 9241399242704553402, 9836150050655369231,
+		14083007972403535491, 16009534514129505275, 12481249112231139039, 10309390659262581143, 5782517315325366794, 16717384553294759530, 4578392002424884134, 239005024949492645,
+		1836857790164349346, 11263074778654917115, 4786985732596838094, 10525445084936097674, 1484357665966453236, 3110871407036679558, 1668700683093601768, 2736269131339849752,
+		9249362594190920246, 8088172462140746331, 4080107866285682736, 16205599538438551353, 18312943145606312277, 9100632964181080418, 3969991115337154345, 5340098959750368315,
+		12122448407048035645, 2891250339380982359, 12794212052932523400, 7166035112141500392, 15777441312724841162, 4552528682229856831, 2210391301762911476, 16410254680957321386,
+		6910044784455706429, 11951245774670922855, 207795885948948810, 3884359690300962405, 4578772752480772344, 2948797025787714138, 16774444535658202808, 1388183483009000463,
+		16561979129019905420, 1881862411760441386, 15441950514711322010, 12933020223458438856, 5570341451312029630, 18172638959728259059, 9074261777549091198, 6171200053222754816,
+		10126435102176037237, 1545112930055760251, 11563139991870561593, 10766754172364938834, 5116781688621052838, 14471715119500781375, 4724882615229687192, 10031687030722046325,
+		15016829467434780812, 6777508689306592732, 3811682306063049290, 11475361222871876387, 6080948654298953274, 11612742274762615033, 5268311600240325047, 9147351973710519861,
+		12130203770930472759, 3880998309361490881, 8807462332494735511, 9291388074337055133, 18165312304248982432, 12733144434841535979, 18090195697688236271, 5825342884125782172,
+		13034385644450400616, 16498936039876211302, 13019014556329727588, 17911110193068084415, 2034190024798401134, 1526884555531436223, 8108814142164064795, 4075908755148182733,
+		6404489603451030675, 16601749455344583377, 12907740667428956072, 8446383351289364752, 698035388979141580, 3593914367189873571, 6744392605914028800, 18168078953147292456,
+		14484703498492722699, 6030798911934842161, 15931002029256202288, 13491601992324491240, 8585568434702372483, 9113555433818303018, 6375455514164501736, 1476639189214882947,
+		5209683814158663472, 16895526973128357178, 10457488910391635027, 17530003042232440701, 4030542539553991812, 9445656287872984963, 4212489101708176016, 837886727556721620,
+		2983790309644332360, 11276772732994425347, 1310621139116895737, 3131558545024164284, 3529698629777893989, 13271773334458143370, 8171825923423406479, 305718858162497191,
+		12347543988562572522, 4315642616923374215, 17586477762860427847, 1037334149869395772, 18311071546005132724, 1489505092175764848, 8926409949339059078, 10260307609945070716,
+		1253128470325829265, 917180526219408600, 10471425074479693158, 12658678264459355332, 8502334428811982364, 3789675096428271759, 4531393894096863308, 12176495757901795513,
+		15081766794595471636, 3944913291385975654, 14507832069904091484, 3624606168811123851, 11476968507677098110, 1056328247986567681, 15246608002200052960, 6566558379177875405,
+		652315099041528631, 4287214618428297946, 11730560225433863449, 7935915607867430686, 15979159466809939008, 9209839549459543141, 9501045239358734673, 15490773728258884277,
+		14281001444503113096, 9253803478538227873, 3842669056581745692, 18399990656305827164, 11841387504710944221, 16052361836589007383, 831115622826254867, 8219898649601530197,
+		2339128600785774471, 1426373723429876004, 3299581455481810683, 16966544600853047157, 8419320331267538738, 8376963013864643226, 1996128805959565963, 2376766970819731241,
+		10963611841695254911, 2914831079289063424, 15884256460390936367, 8724520571578171796, 329402220949313078, 8905943304651682982, 1280899166177109409, 6980213851983339340,
+		5524321102331478758, 2149164875175284006, 10897639484514200325, 14605181792035620644, 316829907946955098, 13776780818927038502, 18167912441745301047, 16845612593885106452,
+		15817940025107036888, 14405005201957074368, 11647077937228007305, 13795438792777593442, 9813339145840642083, 13196196205982926907, 5981408724994946624, 12303812818084690125,
+		11821409230485627325, 1934768678832528678, 15798397330147151183, 2089418311766868031, 16206123311846842647, 10276976147555604745, 14858750786699873336, 2500482310681473276,
+		9502861285700748804, 12163827978530279544, 9383068907817479934, 5717811606328725851, 12416198015020836733, 15689586164720677894, 14337921697724349521, 9392403465642971279,
+		6696074876763293236, 10302972695440286968, 16647054763285662245, 7841147641486000427, 10612636854719975349, 3592516733641215266, 14172459823963607855, 1290213042793222575,
+	},
+}
diff --git a/src/crypto/elliptic/p256_asm_table_test.go b/src/crypto/elliptic/p256_asm_table_test.go
new file mode 100644
index 0000000000..6b64f26286
--- /dev/null
+++ b/src/crypto/elliptic/p256_asm_table_test.go
@@ -0,0 +1,59 @@
+// Copyright 2021 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.
+
+//go:build amd64 || arm64
+// +build amd64 arm64
+
+package elliptic
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestP256PrecomputedTable(t *testing.T) {
+
+	basePoint := []uint64{
+		0x79e730d418a9143c, 0x75ba95fc5fedb601, 0x79fb732b77622510, 0x18905f76a53755c6,
+		0xddf25357ce95560a, 0x8b4ab8e4ba19e45c, 0xd2e88688dd21f325, 0x8571ff1825885d85,
+		0x0000000000000001, 0xffffffff00000000, 0xffffffffffffffff, 0x00000000fffffffe,
+	}
+	t1 := make([]uint64, 12)
+	t2 := make([]uint64, 12)
+	copy(t2, basePoint)
+
+	zInv := make([]uint64, 4)
+	zInvSq := make([]uint64, 4)
+	for j := 0; j < 32; j++ {
+		copy(t1, t2)
+		for i := 0; i < 43; i++ {
+			// The window size is 6 so we need to double 6 times.
+			if i != 0 {
+				for k := 0; k < 6; k++ {
+					p256PointDoubleAsm(t1, t1)
+				}
+			}
+			// Convert the point to affine form. (Its values are
+			// still in Montgomery form however.)
+			p256Inverse(zInv, t1[8:12])
+			p256Sqr(zInvSq, zInv, 1)
+			p256Mul(zInv, zInv, zInvSq)
+
+			p256Mul(t1[:4], t1[:4], zInvSq)
+			p256Mul(t1[4:8], t1[4:8], zInv)
+
+			copy(t1[8:12], basePoint[8:12])
+
+			if got, want := p256Precomputed[i][j*8:(j*8)+8], t1[:8]; !reflect.DeepEqual(got, want) {
+				t.Fatalf("Unexpected table entry at [%d][%d:%d]: got %v, want %v", i, j*8, (j*8)+8, got, want)
+			}
+		}
+		if j == 0 {
+			p256PointDoubleAsm(t2, basePoint)
+		} else {
+			p256PointAddAsm(t2, t2, basePoint)
+		}
+	}
+
+}
-- 
GitLab


From fd095936673dcb53b96b825d95c1e83adde3ce15 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Thu, 29 Apr 2021 14:52:24 -0400
Subject: [PATCH 1863/2400] cmd/compile: minor doc enhancements

Add a little more detail to the ssa README relating to GOSSAFUNC.

Update the -d=ssa help section to give a little more detail on what
to expect with applying the /debug=X qualifier to a phase.

Change-Id: I7027735f1f2955dbb5b9be36d9a648e8dc655048
Reviewed-on: https://go-review.googlesource.com/c/go/+/315229
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/ssa/README.md  | 13 +++++++++++++
 src/cmd/compile/internal/ssa/compile.go |  5 +++++
 2 files changed, 18 insertions(+)

diff --git a/src/cmd/compile/internal/ssa/README.md b/src/cmd/compile/internal/ssa/README.md
index 4483c2c85f..833bf1ddc9 100644
--- a/src/cmd/compile/internal/ssa/README.md
+++ b/src/cmd/compile/internal/ssa/README.md
@@ -184,6 +184,19 @@ compile passes, making it easy to see what each pass does to a particular
 program. You can also click on values and blocks to highlight them, to help
 follow the control flow and values.
 
+The value specified in GOSSAFUNC can also be a package-qualified function
+name, e.g. 
+
+	GOSSAFUNC=blah.Foo go build
+    
+This will match any function named "Foo" within a package whose final
+suffix is "blah" (e.g. something/blah.Foo, anotherthing/extra/blah.Foo).
+
+If non-HTML dumps are needed, append a "+" to the GOSSAFUNC value
+and dumps will be written to stdout:
+
+	GOSSAFUNC=Bar+ go build
+
 <!---
 TODO: need more ideas for this section
 -->
diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go
index 8aae04f2ec..cd8eba405d 100644
--- a/src/cmd/compile/internal/ssa/compile.go
+++ b/src/cmd/compile/internal/ssa/compile.go
@@ -297,6 +297,11 @@ enables time reporting for all phases
     -d=ssa/prove/debug=2
 sets debugging level to 2 in the prove pass
 
+Be aware that when "/debug=X" is applied to a pass, some passes
+will emit debug output for all functions, and other passes will
+only emit debug output for functions that match the current
+GOSSAFUNC value.
+
 Multiple flags can be passed at once, by separating them with
 commas. For example:
 
-- 
GitLab


From 897baae953ca812005703d367234b3b867f2a4b0 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Tue, 20 Apr 2021 19:30:21 +0000
Subject: [PATCH 1864/2400] runtime/metrics: add additional allocation metrics

This change adds four additional metrics to the runtime/metrics package
to fill in a few gaps with runtime.MemStats that were overlooked. The
biggest one is TotalAlloc, which is impossible to find with the
runtime/metrics package, but also add a few others for convenience and
clarity. For instance, the total number of objects allocated and freed
are technically available via allocs-by-size and frees-by-size, but it's
onerous to get them (one needs to sum the sample counts in the
histograms).

The four additional metrics are:
- /gc/heap/allocs:bytes   -- total bytes allocated (TotalAlloc)
- /gc/heap/allocs:objects -- total objects allocated (Mallocs - [tiny])
- /gc/heap/frees:bytes    -- total bytes frees (TotalAlloc-HeapAlloc)
- /gc/heap/frees:objects  -- total objects freed (Frees - [tiny])

This change also updates the descriptions of allocs-by-size and
frees-by-size to be more precise.

Change-Id: Iec8c1797a584491e3484b198f2e7f325b68954a7
Reviewed-on: https://go-review.googlesource.com/c/go/+/312431
Reviewed-by: Michael Pratt <mpratt@google.com>
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/metrics.go             | 61 +++++++++++++++++++++++++++---
 src/runtime/metrics/description.go | 45 +++++++++++++++++++---
 src/runtime/metrics/doc.go         | 24 +++++++++++-
 src/runtime/metrics_test.go        | 52 ++++++++++++++++++++++---
 4 files changed, 164 insertions(+), 18 deletions(-)

diff --git a/src/runtime/metrics.go b/src/runtime/metrics.go
index 240813b169..ba0a920a5d 100644
--- a/src/runtime/metrics.go
+++ b/src/runtime/metrics.go
@@ -98,6 +98,20 @@ func initMetrics() {
 				}
 			},
 		},
+		"/gc/heap/allocs:bytes": {
+			deps: makeStatDepSet(heapStatsDep),
+			compute: func(in *statAggregate, out *metricValue) {
+				out.kind = metricKindUint64
+				out.scalar = in.heapStats.totalAllocated
+			},
+		},
+		"/gc/heap/allocs:objects": {
+			deps: makeStatDepSet(heapStatsDep),
+			compute: func(in *statAggregate, out *metricValue) {
+				out.kind = metricKindUint64
+				out.scalar = in.heapStats.totalAllocs
+			},
+		},
 		"/gc/heap/frees-by-size:bytes": {
 			deps: makeStatDepSet(heapStatsDep),
 			compute: func(in *statAggregate, out *metricValue) {
@@ -110,6 +124,20 @@ func initMetrics() {
 				}
 			},
 		},
+		"/gc/heap/frees:bytes": {
+			deps: makeStatDepSet(heapStatsDep),
+			compute: func(in *statAggregate, out *metricValue) {
+				out.kind = metricKindUint64
+				out.scalar = in.heapStats.totalFreed
+			},
+		},
+		"/gc/heap/frees:objects": {
+			deps: makeStatDepSet(heapStatsDep),
+			compute: func(in *statAggregate, out *metricValue) {
+				out.kind = metricKindUint64
+				out.scalar = in.heapStats.totalFrees
+			},
+		},
 		"/gc/heap/goal:bytes": {
 			deps: makeStatDepSet(sysStatsDep),
 			compute: func(in *statAggregate, out *metricValue) {
@@ -337,6 +365,22 @@ type heapStatsAggregate struct {
 
 	// numObjects is the number of live objects in the heap.
 	numObjects uint64
+
+	// totalAllocated is the total bytes of heap objects allocated
+	// over the lifetime of the program.
+	totalAllocated uint64
+
+	// totalFreed is the total bytes of heap objects freed
+	// over the lifetime of the program.
+	totalFreed uint64
+
+	// totalAllocs is the number of heap objects allocated over
+	// the lifetime of the program.
+	totalAllocs uint64
+
+	// totalFrees is the number of heap objects freed over
+	// the lifetime of the program.
+	totalFrees uint64
 }
 
 // compute populates the heapStatsAggregate with values from the runtime.
@@ -344,13 +388,20 @@ func (a *heapStatsAggregate) compute() {
 	memstats.heapStats.read(&a.heapStatsDelta)
 
 	// Calculate derived stats.
-	a.inObjects = uint64(a.largeAlloc - a.largeFree)
-	a.numObjects = uint64(a.largeAllocCount - a.largeFreeCount)
+	a.totalAllocs = uint64(a.largeAllocCount)
+	a.totalFrees = uint64(a.largeFreeCount)
+	a.totalAllocated = uint64(a.largeAlloc)
+	a.totalFreed = uint64(a.largeFree)
 	for i := range a.smallAllocCount {
-		n := uint64(a.smallAllocCount[i] - a.smallFreeCount[i])
-		a.inObjects += n * uint64(class_to_size[i])
-		a.numObjects += n
+		na := uint64(a.smallAllocCount[i])
+		nf := uint64(a.smallFreeCount[i])
+		a.totalAllocs += na
+		a.totalFrees += nf
+		a.totalAllocated += na * uint64(class_to_size[i])
+		a.totalFreed += nf * uint64(class_to_size[i])
 	}
+	a.inObjects = a.totalAllocated - a.totalFreed
+	a.numObjects = a.totalAllocs - a.totalFrees
 }
 
 // sysStatsAggregate represents system memory stats obtained
diff --git a/src/runtime/metrics/description.go b/src/runtime/metrics/description.go
index 697bc94e84..c147cada89 100644
--- a/src/runtime/metrics/description.go
+++ b/src/runtime/metrics/description.go
@@ -70,17 +70,50 @@ var allDesc = []Description{
 		Cumulative:  true,
 	},
 	{
-		Name:        "/gc/heap/allocs-by-size:bytes",
-		Description: "Distribution of all objects allocated by approximate size.",
-		Kind:        KindFloat64Histogram,
+		Name: "/gc/heap/allocs-by-size:bytes",
+		Description: "Distribution of heap allocations by approximate size. " +
+			"Note that this does not include tiny objects as defined by " +
+			"/gc/heap/tiny/allocs:objects, only tiny blocks.",
+		Kind:       KindFloat64Histogram,
+		Cumulative: true,
+	},
+	{
+		Name:        "/gc/heap/allocs:bytes",
+		Description: "Cumulative sum of memory allocated to the heap by the application.",
+		Kind:        KindUint64,
 		Cumulative:  true,
 	},
 	{
-		Name:        "/gc/heap/frees-by-size:bytes",
-		Description: "Distribution of all objects freed by approximate size.",
-		Kind:        KindFloat64Histogram,
+		Name: "/gc/heap/allocs:objects",
+		Description: "Cumulative count of heap allocations triggered by the application. " +
+			"Note that this does not include tiny objects as defined by " +
+			"/gc/heap/tiny/allocs:objects, only tiny blocks.",
+		Kind:       KindUint64,
+		Cumulative: true,
+	},
+	{
+		Name: "/gc/heap/frees-by-size:bytes",
+		Description: "Distribution of freed heap allocations by approximate size. " +
+			"Note that this does not include tiny objects as defined by " +
+			"/gc/heap/tiny/allocs:objects, only tiny blocks.",
+		Kind:       KindFloat64Histogram,
+		Cumulative: true,
+	},
+	{
+		Name:        "/gc/heap/frees:bytes",
+		Description: "Cumulative sum of heap memory freed by the garbage collector.",
+		Kind:        KindUint64,
 		Cumulative:  true,
 	},
+	{
+		Name: "/gc/heap/frees:objects",
+		Description: "Cumulative count of heap allocations whose storage was freed " +
+			"by the garbage collector. " +
+			"Note that this does not include tiny objects as defined by " +
+			"/gc/heap/tiny/allocs:objects, only tiny blocks.",
+		Kind:       KindUint64,
+		Cumulative: true,
+	},
 	{
 		Name:        "/gc/heap/goal:bytes",
 		Description: "Heap size target for the end of the GC cycle.",
diff --git a/src/runtime/metrics/doc.go b/src/runtime/metrics/doc.go
index cd8ccf46c3..91ef03072d 100644
--- a/src/runtime/metrics/doc.go
+++ b/src/runtime/metrics/doc.go
@@ -61,10 +61,30 @@ Below is the full list of supported metrics, ordered lexicographically.
 		Count of all completed GC cycles.
 
 	/gc/heap/allocs-by-size:bytes
-		Distribution of all objects allocated by approximate size.
+		Distribution of heap allocations by approximate size.
+		Note that this does not include tiny objects as defined by /gc/heap/tiny/allocs:objects,
+		only tiny blocks.
+
+	/gc/heap/allocs:bytes
+		Cumulative sum of memory allocated to the heap by the application.
+
+	/gc/heap/allocs:objects
+		Cumulative count of heap allocations triggered by the application.
+		Note that this does not include tiny objects as defined by /gc/heap/tiny/allocs:objects,
+		only tiny blocks.
 
 	/gc/heap/frees-by-size:bytes
-		Distribution of all objects freed by approximate size.
+		Distribution of freed heap allocations by approximate size.
+		Note that this does not include tiny objects as defined by /gc/heap/tiny/allocs:objects,
+		only tiny blocks.
+
+	/gc/heap/frees:bytes
+		Cumulative sum of heap memory freed by the garbage collector.
+
+	/gc/heap/frees:objects
+		Cumulative count of heap allocations whose storage was freed by the garbage collector.
+		Note that this does not include tiny objects as defined by /gc/heap/tiny/allocs:objects,
+		only tiny blocks.
 
 	/gc/heap/goal:bytes
 		Heap size target for the end of the GC cycle.
diff --git a/src/runtime/metrics_test.go b/src/runtime/metrics_test.go
index e405d807e4..5d32ef469c 100644
--- a/src/runtime/metrics_test.go
+++ b/src/runtime/metrics_test.go
@@ -42,6 +42,7 @@ func TestReadMetrics(t *testing.T) {
 	// Check to make sure the values we read line up with other values we read.
 	var allocsBySize *metrics.Float64Histogram
 	var tinyAllocs uint64
+	var mallocs, frees uint64
 	for i := range samples {
 		switch name := samples[i].Name; name {
 		case "/memory/classes/heap/free:bytes":
@@ -87,6 +88,8 @@ func TestReadMetrics(t *testing.T) {
 				}
 			}
 			allocsBySize = hist
+		case "/gc/heap/allocs:bytes":
+			checkUint64(t, name, samples[i].Value.Uint64(), mstats.TotalAlloc)
 		case "/gc/heap/frees-by-size:bytes":
 			hist := samples[i].Value.Float64Histogram()
 			// Skip size class 0 in BySize, because it's always empty and not represented
@@ -101,6 +104,8 @@ func TestReadMetrics(t *testing.T) {
 					t.Errorf("histogram counts do not match BySize for class %d: got %d, want %d", i, c, f)
 				}
 			}
+		case "/gc/heap/frees:bytes":
+			checkUint64(t, name, samples[i].Value.Uint64(), mstats.TotalAlloc-mstats.HeapAlloc)
 		case "/gc/heap/tiny/allocs:objects":
 			// Currently, MemStats adds tiny alloc count to both Mallocs AND Frees.
 			// The reason for this is because MemStats couldn't be extended at the time
@@ -112,6 +117,13 @@ func TestReadMetrics(t *testing.T) {
 			// Check tiny allocation count outside of this loop, by using the allocs-by-size
 			// histogram in order to figure out how many large objects there are.
 			tinyAllocs = samples[i].Value.Uint64()
+			// Because the next two metrics tests are checking against Mallocs and Frees,
+			// we can't check them directly for the same reason: we need to account for tiny
+			// allocations included in Mallocs and Frees.
+		case "/gc/heap/allocs:objects":
+			mallocs = samples[i].Value.Uint64()
+		case "/gc/heap/frees:objects":
+			frees = samples[i].Value.Uint64()
 		case "/gc/heap/objects:objects":
 			checkUint64(t, name, samples[i].Value.Uint64(), mstats.HeapObjects)
 		case "/gc/heap/goal:bytes":
@@ -131,6 +143,10 @@ func TestReadMetrics(t *testing.T) {
 		nonTinyAllocs += c
 	}
 	checkUint64(t, "/gc/heap/tiny/allocs:objects", tinyAllocs, mstats.Mallocs-nonTinyAllocs)
+
+	// Check allocation and free counts.
+	checkUint64(t, "/gc/heap/allocs:objects", mallocs, mstats.Mallocs-tinyAllocs)
+	checkUint64(t, "/gc/heap/frees:objects", frees, mstats.Frees-tinyAllocs)
 }
 
 func TestReadMetricsConsistency(t *testing.T) {
@@ -153,8 +169,10 @@ func TestReadMetricsConsistency(t *testing.T) {
 		got, want uint64
 	}
 	var objects struct {
-		alloc, free *metrics.Float64Histogram
-		total       uint64
+		alloc, free             *metrics.Float64Histogram
+		allocs, frees           uint64
+		allocdBytes, freedBytes uint64
+		total, totalBytes       uint64
 	}
 	var gc struct {
 		numGC  uint64
@@ -180,10 +198,20 @@ func TestReadMetricsConsistency(t *testing.T) {
 		switch samples[i].Name {
 		case "/memory/classes/total:bytes":
 			totalVirtual.got = samples[i].Value.Uint64()
+		case "/memory/classes/heap/objects:bytes":
+			objects.totalBytes = samples[i].Value.Uint64()
 		case "/gc/heap/objects:objects":
 			objects.total = samples[i].Value.Uint64()
+		case "/gc/heap/allocs:bytes":
+			objects.allocdBytes = samples[i].Value.Uint64()
+		case "/gc/heap/allocs:objects":
+			objects.allocs = samples[i].Value.Uint64()
 		case "/gc/heap/allocs-by-size:bytes":
 			objects.alloc = samples[i].Value.Float64Histogram()
+		case "/gc/heap/frees:bytes":
+			objects.freedBytes = samples[i].Value.Uint64()
+		case "/gc/heap/frees:objects":
+			objects.frees = samples[i].Value.Uint64()
 		case "/gc/heap/frees-by-size:bytes":
 			objects.free = samples[i].Value.Float64Histogram()
 		case "/gc/cycles:gc-cycles":
@@ -203,6 +231,12 @@ func TestReadMetricsConsistency(t *testing.T) {
 	if totalVirtual.got != totalVirtual.want {
 		t.Errorf(`"/memory/classes/total:bytes" does not match sum of /memory/classes/**: got %d, want %d`, totalVirtual.got, totalVirtual.want)
 	}
+	if got, want := objects.allocs-objects.frees, objects.total; got != want {
+		t.Errorf("mismatch between object alloc/free tallies and total: got %d, want %d", got, want)
+	}
+	if got, want := objects.allocdBytes-objects.freedBytes, objects.totalBytes; got != want {
+		t.Errorf("mismatch between object alloc/free tallies and total: got %d, want %d", got, want)
+	}
 	if b, c := len(objects.alloc.Buckets), len(objects.alloc.Counts); b != c+1 {
 		t.Errorf("allocs-by-size has wrong bucket or counts length: %d buckets, %d counts", b, c)
 	}
@@ -222,17 +256,25 @@ func TestReadMetricsConsistency(t *testing.T) {
 			}
 		}
 		if !t.Failed() {
-			got, want := uint64(0), objects.total
+			var gotAlloc, gotFree uint64
+			want := objects.total
 			for i := range objects.alloc.Counts {
 				if objects.alloc.Counts[i] < objects.free.Counts[i] {
 					t.Errorf("found more allocs than frees in object dist bucket %d", i)
 					continue
 				}
-				got += objects.alloc.Counts[i] - objects.free.Counts[i]
+				gotAlloc += objects.alloc.Counts[i]
+				gotFree += objects.free.Counts[i]
 			}
-			if got != want {
+			if got := gotAlloc - gotFree; got != want {
 				t.Errorf("object distribution counts don't match count of live objects: got %d, want %d", got, want)
 			}
+			if gotAlloc != objects.allocs {
+				t.Errorf("object distribution counts don't match total allocs: got %d, want %d", gotAlloc, objects.allocs)
+			}
+			if gotFree != objects.frees {
+				t.Errorf("object distribution counts don't match total allocs: got %d, want %d", gotFree, objects.frees)
+			}
 		}
 	}
 	// The current GC has at least 2 pauses per GC.
-- 
GitLab


From 1df309eb023973f52b4955ea5b001c0d44961743 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Fri, 23 Apr 2021 22:30:38 -0400
Subject: [PATCH 1865/2400] cmd/compile: skip types.Sym for GC mask symbols

For GC mask symbols, we don't need to create types.Sym, just the
LSym.

Change-Id: I285b518cfd60bfaa3202a02b3005a7122daeb338
Reviewed-on: https://go-review.googlesource.com/c/go/+/313512
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/reflectdata/reflect.go | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index 26b08ee08a..836174d0ce 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -1509,12 +1509,10 @@ func dgcsym(t *types.Type) (lsym *obj.LSym, useGCProg bool, ptrdata int64) {
 func dgcptrmask(t *types.Type) *obj.LSym {
 	ptrmask := make([]byte, (types.PtrDataSize(t)/int64(types.PtrSize)+7)/8)
 	fillptrmask(t, ptrmask)
-	p := fmt.Sprintf("gcbits.%x", ptrmask)
+	p := fmt.Sprintf("runtime.gcbits.%x", ptrmask)
 
-	sym := ir.Pkgs.Runtime.Lookup(p)
-	lsym := sym.Linksym()
-	if !sym.Uniq() {
-		sym.SetUniq(true)
+	lsym := base.Ctxt.Lookup(p)
+	if !lsym.OnList() {
 		for i, x := range ptrmask {
 			objw.Uint8(lsym, i, x)
 		}
-- 
GitLab


From e99dfb0e5cd964c94d946cabeca9856634416737 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Sat, 24 Apr 2021 01:05:19 -0400
Subject: [PATCH 1866/2400] cmd/compile: make GC prog symbol
 content-addressable

Change-Id: I759ac021ae5882429f26455fd849613a33e41783
Reviewed-on: https://go-review.googlesource.com/c/go/+/313513
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/reflectdata/reflect.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index 836174d0ce..06c4986cf4 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -1590,6 +1590,7 @@ func (p *gcProg) end() {
 	p.w.End()
 	objw.Uint32(p.lsym, 0, uint32(p.symoff-4))
 	objw.Global(p.lsym, int32(p.symoff), obj.DUPOK|obj.RODATA|obj.LOCAL)
+	p.lsym.Set(obj.AttrContentAddressable, true)
 	if base.Debug.GCProg > 0 {
 		fmt.Fprintf(os.Stderr, "compile: end GCProg for %v\n", p.lsym)
 	}
-- 
GitLab


From a9705e157beb51574233e23cc2e2a412d4681a15 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 29 Apr 2021 10:02:01 -0700
Subject: [PATCH 1867/2400] cmd/compile/internal/types2: slice-to-array-pointer
 conversion requires go1.17

Add missing version check. Even though this is a new types2 error
we separate between the compiler and the types2 error message: we
have the compiler error message to match the compiler style, and
we have a types2-specific error message to match the types2 style
for these kinds of errors (for now).

Eventually we need to decide which style we like better and clean
this up.

Follow-up on https://golang.org/cl/301650.

Updates #395.

Change-Id: I5b779f345994c66b1f4a4db466466f98b7d3c491
Reviewed-on: https://go-review.googlesource.com/c/go/+/315169
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/conversions.go  | 17 ++++++++++++++---
 src/cmd/compile/internal/types2/decl.go         |  2 +-
 .../internal/types2/testdata/check/go1_16.src   | 13 +++++++++++++
 3 files changed, 28 insertions(+), 4 deletions(-)
 create mode 100644 src/cmd/compile/internal/types2/testdata/check/go1_16.src

diff --git a/src/cmd/compile/internal/types2/conversions.go b/src/cmd/compile/internal/types2/conversions.go
index 51be50e9ad..30201e2b7f 100644
--- a/src/cmd/compile/internal/types2/conversions.go
+++ b/src/cmd/compile/internal/types2/conversions.go
@@ -38,8 +38,10 @@ func (check *Checker) conversion(x *operand, T Type) {
 	}
 
 	if !ok {
-		check.errorf(x, "cannot convert %s to %s", x, T)
-		x.mode = invalid
+		if x.mode != invalid {
+			check.errorf(x, "cannot convert %s to %s", x, T)
+			x.mode = invalid
+		}
 		return
 	}
 
@@ -141,7 +143,16 @@ func (x *operand) convertibleTo(check *Checker, T Type) bool {
 		if p := asPointer(T); p != nil {
 			if a := asArray(p.Elem()); a != nil {
 				if check.identical(s.Elem(), a.Elem()) {
-					return true
+					if check == nil || check.allowVersion(check.pkg, 1, 17) {
+						return true
+					}
+					// check != nil
+					if check.conf.CompilerErrorMessages {
+						check.error(x, "conversion of slices to array pointers only supported as of -lang=go1.17")
+					} else {
+						check.error(x, "conversion of slices to array pointers requires go1.17 or later")
+					}
+					x.mode = invalid // avoid follow-up error
 				}
 			}
 		}
diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index 4966f19892..1333e4c0ec 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -601,7 +601,7 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *syntax.TypeDecl, def *Named
 
 	if alias {
 		// type alias declaration
-		if !check.allowVersion(obj.pkg, 1, 9) {
+		if !check.allowVersion(check.pkg, 1, 9) {
 			if check.conf.CompilerErrorMessages {
 				check.error(tdecl, "type aliases only supported as of -lang=go1.9")
 			} else {
diff --git a/src/cmd/compile/internal/types2/testdata/check/go1_16.src b/src/cmd/compile/internal/types2/testdata/check/go1_16.src
new file mode 100644
index 0000000000..fdf5c99d7e
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/check/go1_16.src
@@ -0,0 +1,13 @@
+// Copyright 2021 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.
+
+// Check Go language version-specific errors.
+
+package go1_16 // go1.16
+
+type Slice []byte
+type Array [8]byte
+
+var s Slice
+var p = (*Array)(s /* ERROR requires go1.17 or later */ )
-- 
GitLab


From 02ab8d1a1dc82ce019969221313bfa28911f54a1 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Sat, 24 Apr 2021 12:41:17 -0400
Subject: [PATCH 1868/2400] cmd/compile, runtime: emit only GC data for stack
 objects
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Currently, for stack objects, the compiler emits metadata that
includes the offset and type descriptor for each object. The type
descriptor symbol has many fields, and it references many other
symbols, e.g. field/element types, equality functions, names.

Observe that what we actually need at runtime is only the GC
metadata that are needed to scan the object, and the GC metadata
are "leaf" symbols (which doesn't reference other symbols). Emit
only the GC data instead. This avoids bringing live the type
descriptor as well as things referenced by it (if it is not
otherwise live).

This reduces binary sizes:

                     old          new
hello (println)    1187776      1133856 (-4.5%)
hello (fmt)        1902448      1844416 (-3.1%)
cmd/compile       22670432     22438576 (-1.0%)
cmd/link           6346272      6225408 (-1.9%)

No significant change in compiler speed.

name        old time/op       new time/op       delta
Template          184ms ± 2%        186ms ± 5%    ~     (p=0.905 n=9+10)
Unicode          78.4ms ± 5%       76.3ms ± 3%  -2.60%  (p=0.009 n=10+10)
GoTypes           1.09s ± 1%        1.08s ± 1%  -0.73%  (p=0.027 n=10+8)
Compiler         85.6ms ± 3%       84.6ms ± 4%    ~     (p=0.143 n=10+10)
SSA               7.23s ± 1%        7.25s ± 1%    ~     (p=0.780 n=10+9)
Flate             116ms ± 5%        115ms ± 6%    ~     (p=0.912 n=10+10)
GoParser          201ms ± 4%        195ms ± 1%    ~     (p=0.089 n=10+10)
Reflect           455ms ± 1%        458ms ± 2%    ~     (p=0.050 n=9+9)
Tar               155ms ± 2%        155ms ± 3%    ~     (p=0.436 n=10+10)
XML               202ms ± 2%        200ms ± 2%    ~     (p=0.053 n=10+9)

Change-Id: I33a7f383d79afba1a482cac6da0cf5b7de9c0ec4
Reviewed-on: https://go-review.googlesource.com/c/go/+/313514
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/liveness/plive.go    | 22 ++++++-
 .../compile/internal/reflectdata/reflect.go   | 64 +++++++++++++++----
 src/runtime/mgcmark.go                        | 28 ++++----
 src/runtime/mgcstack.go                       | 22 +++----
 src/runtime/stack.go                          | 40 +++++++++---
 5 files changed, 128 insertions(+), 48 deletions(-)

diff --git a/src/cmd/compile/internal/liveness/plive.go b/src/cmd/compile/internal/liveness/plive.go
index 424d248590..f5c2ef7709 100644
--- a/src/cmd/compile/internal/liveness/plive.go
+++ b/src/cmd/compile/internal/liveness/plive.go
@@ -1431,8 +1431,26 @@ func (lv *liveness) emitStackObjects() *obj.LSym {
 		// Note: arguments and return values have non-negative Xoffset,
 		// in which case the offset is relative to argp.
 		// Locals have a negative Xoffset, in which case the offset is relative to varp.
-		off = objw.Uintptr(x, off, uint64(v.FrameOffset()))
-		off = objw.SymPtr(x, off, reflectdata.TypeLinksym(v.Type()), 0)
+		// We already limit the frame size, so the offset and the object size
+		// should not be too big.
+		frameOffset := v.FrameOffset()
+		if frameOffset != int64(int32(frameOffset)) {
+			base.Fatalf("frame offset too big: %v %d", v, frameOffset)
+		}
+		off = objw.Uint32(x, off, uint32(frameOffset))
+
+		t := v.Type()
+		sz := t.Width
+		if sz != int64(int32(sz)) {
+			base.Fatalf("stack object too big: %v of type %v, size %d", v, t, sz)
+		}
+		lsym, useGCProg, ptrdata := reflectdata.GCSym(t)
+		if useGCProg {
+			ptrdata = -ptrdata
+		}
+		off = objw.Uint32(x, off, uint32(sz))
+		off = objw.Uint32(x, off, uint32(ptrdata))
+		off = objw.SymPtr(x, off, lsym, 0)
 	}
 
 	if base.Flag.Live != 0 {
diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index 06c4986cf4..01eaf26a0a 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -52,6 +52,9 @@ var (
 	signatset   = make(map[*types.Type]struct{})
 	signatslice []*types.Type
 
+	gcsymmu  sync.Mutex // protects gcsymset and gcsymslice
+	gcsymset = make(map[*types.Type]struct{})
+
 	itabs []itabEntry
 	ptabs []*ir.Name
 )
@@ -694,7 +697,8 @@ func dcommontype(lsym *obj.LSym, t *types.Type) int {
 		sptr = writeType(tptr)
 	}
 
-	gcsym, useGCProg, ptrdata := dgcsym(t)
+	gcsym, useGCProg, ptrdata := dgcsym(t, true)
+	delete(gcsymset, t)
 
 	// ../../../../reflect/type.go:/^type.rtype
 	// actual type structure
@@ -1321,6 +1325,16 @@ func WriteRuntimeTypes() {
 			}
 		}
 	}
+
+	// Emit GC data symbols.
+	gcsyms := make([]typeAndStr, 0, len(gcsymset))
+	for t := range gcsymset {
+		gcsyms = append(gcsyms, typeAndStr{t: t, short: types.TypeSymName(t), regular: t.String()})
+	}
+	sort.Sort(typesByString(gcsyms))
+	for _, ts := range gcsyms {
+		dgcsym(ts.t, true)
+	}
 }
 
 func WriteTabs() {
@@ -1490,29 +1504,46 @@ func (a typesByString) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
 //
 const maxPtrmaskBytes = 2048
 
-// dgcsym emits and returns a data symbol containing GC information for type t,
-// along with a boolean reporting whether the UseGCProg bit should be set in
-// the type kind, and the ptrdata field to record in the reflect type information.
-func dgcsym(t *types.Type) (lsym *obj.LSym, useGCProg bool, ptrdata int64) {
+// GCSym returns a data symbol containing GC information for type t, along
+// with a boolean reporting whether the UseGCProg bit should be set in the
+// type kind, and the ptrdata field to record in the reflect type information.
+// GCSym may be called in concurrent backend, so it does not emit the symbol
+// content.
+func GCSym(t *types.Type) (lsym *obj.LSym, useGCProg bool, ptrdata int64) {
+	// Record that we need to emit the GC symbol.
+	gcsymmu.Lock()
+	if _, ok := gcsymset[t]; !ok {
+		gcsymset[t] = struct{}{}
+	}
+	gcsymmu.Unlock()
+
+	return dgcsym(t, false)
+}
+
+// dgcsym returns a data symbol containing GC information for type t, along
+// with a boolean reporting whether the UseGCProg bit should be set in the
+// type kind, and the ptrdata field to record in the reflect type information.
+// When write is true, it writes the symbol data.
+func dgcsym(t *types.Type, write bool) (lsym *obj.LSym, useGCProg bool, ptrdata int64) {
 	ptrdata = types.PtrDataSize(t)
 	if ptrdata/int64(types.PtrSize) <= maxPtrmaskBytes*8 {
-		lsym = dgcptrmask(t)
+		lsym = dgcptrmask(t, write)
 		return
 	}
 
 	useGCProg = true
-	lsym, ptrdata = dgcprog(t)
+	lsym, ptrdata = dgcprog(t, write)
 	return
 }
 
 // dgcptrmask emits and returns the symbol containing a pointer mask for type t.
-func dgcptrmask(t *types.Type) *obj.LSym {
+func dgcptrmask(t *types.Type, write bool) *obj.LSym {
 	ptrmask := make([]byte, (types.PtrDataSize(t)/int64(types.PtrSize)+7)/8)
 	fillptrmask(t, ptrmask)
 	p := fmt.Sprintf("runtime.gcbits.%x", ptrmask)
 
 	lsym := base.Ctxt.Lookup(p)
-	if !lsym.OnList() {
+	if write && !lsym.OnList() {
 		for i, x := range ptrmask {
 			objw.Uint8(lsym, i, x)
 		}
@@ -1549,14 +1580,14 @@ func fillptrmask(t *types.Type, ptrmask []byte) {
 // [types.PtrDataSize(t), t.Width]).
 // In practice, the size is types.PtrDataSize(t) except for non-trivial arrays.
 // For non-trivial arrays, the program describes the full t.Width size.
-func dgcprog(t *types.Type) (*obj.LSym, int64) {
+func dgcprog(t *types.Type, write bool) (*obj.LSym, int64) {
 	types.CalcSize(t)
 	if t.Width == types.BADWIDTH {
 		base.Fatalf("dgcprog: %v badwidth", t)
 	}
 	lsym := TypeLinksymPrefix(".gcprog", t)
 	var p gcProg
-	p.init(lsym)
+	p.init(lsym, write)
 	p.emit(t, 0)
 	offset := p.w.BitIndex() * int64(types.PtrSize)
 	p.end()
@@ -1570,11 +1601,17 @@ type gcProg struct {
 	lsym   *obj.LSym
 	symoff int
 	w      gcprog.Writer
+	write  bool
 }
 
-func (p *gcProg) init(lsym *obj.LSym) {
+func (p *gcProg) init(lsym *obj.LSym, write bool) {
 	p.lsym = lsym
+	p.write = write && !lsym.OnList()
 	p.symoff = 4 // first 4 bytes hold program length
+	if !write {
+		p.w.Init(func(byte) {})
+		return
+	}
 	p.w.Init(p.writeByte)
 	if base.Debug.GCProg > 0 {
 		fmt.Fprintf(os.Stderr, "compile: start GCProg for %v\n", lsym)
@@ -1588,6 +1625,9 @@ func (p *gcProg) writeByte(x byte) {
 
 func (p *gcProg) end() {
 	p.w.End()
+	if !p.write {
+		return
+	}
 	objw.Uint32(p.lsym, 0, uint32(p.symoff-4))
 	objw.Global(p.lsym, int32(p.symoff), obj.DUPOK|obj.RODATA|obj.LOCAL)
 	p.lsym.Set(obj.AttrContentAddressable, true)
diff --git a/src/runtime/mgcmark.go b/src/runtime/mgcmark.go
index 719b21055b..1fd0732d62 100644
--- a/src/runtime/mgcmark.go
+++ b/src/runtime/mgcmark.go
@@ -792,24 +792,24 @@ func scanstack(gp *g, gcw *gcWork) {
 		if obj == nil {
 			continue
 		}
-		t := obj.typ
-		if t == nil {
+		r := obj.r
+		if r == nil {
 			// We've already scanned this object.
 			continue
 		}
-		obj.setType(nil) // Don't scan it again.
+		obj.setRecord(nil) // Don't scan it again.
 		if stackTraceDebug {
 			printlock()
-			print("  live stkobj at", hex(state.stack.lo+uintptr(obj.off)), "of type", t.string())
+			print("  live stkobj at", hex(state.stack.lo+uintptr(obj.off)), "of size", obj.size)
 			if conservative {
 				print(" (conservative)")
 			}
 			println()
 			printunlock()
 		}
-		gcdata := t.gcdata
+		gcdata := r.gcdata
 		var s *mspan
-		if t.kind&kindGCProg != 0 {
+		if r.useGCProg() {
 			// This path is pretty unlikely, an object large enough
 			// to have a GC program allocated on the stack.
 			// We need some space to unpack the program into a straight
@@ -819,15 +819,15 @@ func scanstack(gp *g, gcw *gcWork) {
 			// to change from a Lempel-Ziv style program to something else.
 			// Or we can forbid putting objects on stacks if they require
 			// a gc program (see issue 27447).
-			s = materializeGCProg(t.ptrdata, gcdata)
+			s = materializeGCProg(r.ptrdata(), gcdata)
 			gcdata = (*byte)(unsafe.Pointer(s.startAddr))
 		}
 
 		b := state.stack.lo + uintptr(obj.off)
 		if conservative {
-			scanConservative(b, t.ptrdata, gcdata, gcw, &state)
+			scanConservative(b, r.ptrdata(), gcdata, gcw, &state)
 		} else {
-			scanblock(b, t.ptrdata, gcdata, gcw, &state)
+			scanblock(b, r.ptrdata(), gcdata, gcw, &state)
 		}
 
 		if s != nil {
@@ -843,10 +843,10 @@ func scanstack(gp *g, gcw *gcWork) {
 		if stackTraceDebug {
 			for i := 0; i < x.nobj; i++ {
 				obj := &x.obj[i]
-				if obj.typ == nil { // reachable
+				if obj.r == nil { // reachable
 					continue
 				}
-				println("  dead stkobj at", hex(gp.stack.lo+uintptr(obj.off)), "of type", obj.typ.string())
+				println("  dead stkobj at", hex(gp.stack.lo+uintptr(obj.off)), "of size", obj.r.size)
 				// Note: not necessarily really dead - only reachable-from-ptr dead.
 			}
 		}
@@ -927,7 +927,7 @@ func scanframeworker(frame *stkframe, state *stackScanState, gcw *gcWork) {
 		// varp is 0 for defers, where there are no locals.
 		// In that case, there can't be a pointer to its args, either.
 		// (And all args would be scanned above anyway.)
-		for _, obj := range objs {
+		for i, obj := range objs {
 			off := obj.off
 			base := frame.varp // locals base pointer
 			if off >= 0 {
@@ -939,9 +939,9 @@ func scanframeworker(frame *stkframe, state *stackScanState, gcw *gcWork) {
 				continue
 			}
 			if stackTraceDebug {
-				println("stkobj at", hex(ptr), "of type", obj.typ.string())
+				println("stkobj at", hex(ptr), "of size", obj.size)
 			}
-			state.addObject(ptr, obj.typ)
+			state.addObject(ptr, &objs[i])
 		}
 	}
 }
diff --git a/src/runtime/mgcstack.go b/src/runtime/mgcstack.go
index 8eb941a328..92d58485f6 100644
--- a/src/runtime/mgcstack.go
+++ b/src/runtime/mgcstack.go
@@ -150,19 +150,19 @@ func init() {
 //
 //go:notinheap
 type stackObject struct {
-	off   uint32       // offset above stack.lo
-	size  uint32       // size of object
-	typ   *_type       // type info (for ptr/nonptr bits). nil if object has been scanned.
-	left  *stackObject // objects with lower addresses
-	right *stackObject // objects with higher addresses
+	off   uint32             // offset above stack.lo
+	size  uint32             // size of object
+	r     *stackObjectRecord // info of the object (for ptr/nonptr bits). nil if object has been scanned.
+	left  *stackObject       // objects with lower addresses
+	right *stackObject       // objects with higher addresses
 }
 
-// obj.typ = typ, but with no write barrier.
+// obj.r = r, but with no write barrier.
 //go:nowritebarrier
-func (obj *stackObject) setType(typ *_type) {
+func (obj *stackObject) setRecord(r *stackObjectRecord) {
 	// Types of stack objects are always in read-only memory, not the heap.
 	// So not using a write barrier is ok.
-	*(*uintptr)(unsafe.Pointer(&obj.typ)) = uintptr(unsafe.Pointer(typ))
+	*(*uintptr)(unsafe.Pointer(&obj.r)) = uintptr(unsafe.Pointer(r))
 }
 
 // A stackScanState keeps track of the state used during the GC walk
@@ -271,7 +271,7 @@ func (s *stackScanState) getPtr() (p uintptr, conservative bool) {
 }
 
 // addObject adds a stack object at addr of type typ to the set of stack objects.
-func (s *stackScanState) addObject(addr uintptr, typ *_type) {
+func (s *stackScanState) addObject(addr uintptr, r *stackObjectRecord) {
 	x := s.tail
 	if x == nil {
 		// initial setup
@@ -294,8 +294,8 @@ func (s *stackScanState) addObject(addr uintptr, typ *_type) {
 	obj := &x.obj[x.nobj]
 	x.nobj++
 	obj.off = uint32(addr - s.stack.lo)
-	obj.size = uint32(typ.size)
-	obj.setType(typ)
+	obj.size = uint32(r.size)
+	obj.setRecord(r)
 	// obj.left and obj.right will be initialized by buildIndex before use.
 	s.nobjs++
 }
diff --git a/src/runtime/stack.go b/src/runtime/stack.go
index babfdfccf0..b21c9c9518 100644
--- a/src/runtime/stack.go
+++ b/src/runtime/stack.go
@@ -702,15 +702,15 @@ func adjustframe(frame *stkframe, arg unsafe.Pointer) bool {
 				// we call into morestack.)
 				continue
 			}
-			t := obj.typ
-			gcdata := t.gcdata
+			ptrdata := obj.ptrdata()
+			gcdata := obj.gcdata
 			var s *mspan
-			if t.kind&kindGCProg != 0 {
+			if obj.useGCProg() {
 				// See comments in mgcmark.go:scanstack
-				s = materializeGCProg(t.ptrdata, gcdata)
+				s = materializeGCProg(ptrdata, gcdata)
 				gcdata = (*byte)(unsafe.Pointer(s.startAddr))
 			}
-			for i := uintptr(0); i < t.ptrdata; i += sys.PtrSize {
+			for i := uintptr(0); i < ptrdata; i += sys.PtrSize {
 				if *addb(gcdata, i/(8*sys.PtrSize))>>(i/sys.PtrSize&7)&1 != 0 {
 					adjustpointer(adjinfo, unsafe.Pointer(p+i))
 				}
@@ -1346,20 +1346,42 @@ var (
 	abiRegArgsType           *_type      = efaceOf(&abiRegArgsEface)._type
 	methodValueCallFrameObjs             = []stackObjectRecord{
 		{
-			off: -int(alignUp(abiRegArgsType.size, 8)), // It's always the highest address local.
-			typ: abiRegArgsType,
+			off:      -int32(alignUp(abiRegArgsType.size, 8)), // It's always the highest address local.
+			size:     int32(abiRegArgsType.size),
+			_ptrdata: int32(abiRegArgsType.ptrdata),
+			gcdata:   abiRegArgsType.gcdata,
 		},
 	}
 )
 
+func init() {
+	if abiRegArgsType.kind&kindGCProg != 0 {
+		throw("abiRegArgsType needs GC Prog, update methodValueCallFrameObjs")
+	}
+}
+
 // A stackObjectRecord is generated by the compiler for each stack object in a stack frame.
 // This record must match the generator code in cmd/compile/internal/liveness/plive.go:emitStackObjects.
 type stackObjectRecord struct {
 	// offset in frame
 	// if negative, offset from varp
 	// if non-negative, offset from argp
-	off int
-	typ *_type
+	off      int32
+	size     int32
+	_ptrdata int32 // ptrdata, or -ptrdata is GC prog is used
+	gcdata   *byte // pointer map or GC prog of the type
+}
+
+func (r *stackObjectRecord) useGCProg() bool {
+	return r._ptrdata < 0
+}
+
+func (r *stackObjectRecord) ptrdata() uintptr {
+	x := r._ptrdata
+	if x < 0 {
+		return uintptr(-x)
+	}
+	return uintptr(x)
 }
 
 // This is exported as ABI0 via linkname so obj can call it.
-- 
GitLab


From 3498027329a32c77315754054d1591e06349db59 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 29 Apr 2021 15:01:29 -0700
Subject: [PATCH 1869/2400] math: increase precision of
 math.SmallestNonzeroFloat64

The original value was rounded too early, which lead to the
surprising behavior that float64(math.SmallestNonzeroFloat64 / 2)
wasn't 0. That is, the exact compile-time computation of
math.SmallestNonzeroFloat64 / 2 resulted in a value that was
rounded up when converting to float64. To address this, added 3
more digits to the mantissa, ending in a 0.

While at it, also slightly increased the precision of MaxFloat64
to end in a 0.

Computed exact values via https://play.golang.org/p/yt4KTpIx_wP.

Added a test to verify expected behavior.

In contrast to the other (irrational) constants, expanding these
extreme values to more digits is unlikely to be important as they
are not going to appear in numeric computations except for tests
verifying their correctness (as is the case here).

Re-enabled a disabled test in go/types and types2.

Updates #44057.
Fixes #44058.

Change-Id: I8f363155e02331354e929beabe993c8d8de75646
Reviewed-on: https://go-review.googlesource.com/c/go/+/315170
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 api/except.txt                                         |  2 ++
 .../compile/internal/types2/testdata/check/const1.src  | 10 +++++-----
 src/go/types/testdata/check/const1.src                 | 10 +++++-----
 src/math/all_test.go                                   |  9 +++++++++
 src/math/const.go                                      |  4 ++--
 5 files changed, 23 insertions(+), 12 deletions(-)

diff --git a/api/except.txt b/api/except.txt
index 6f6f839ba6..f5a7aa854e 100644
--- a/api/except.txt
+++ b/api/except.txt
@@ -1,4 +1,6 @@
 pkg encoding/json, method (*RawMessage) MarshalJSON() ([]uint8, error)
+pkg math, const MaxFloat64 = 1.79769e+308  // 179769313486231570814527423731704356798100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+pkg math, const SmallestNonzeroFloat64 = 4.94066e-324  // 4940656458412465441765687928682213723651/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
 pkg math/big, const MaxBase = 36
 pkg math/big, type Word uintptr
 pkg net, func ListenUnixgram(string, *UnixAddr) (*UDPConn, error)
diff --git a/src/cmd/compile/internal/types2/testdata/check/const1.src b/src/cmd/compile/internal/types2/testdata/check/const1.src
index 56b6bd4ca5..c9128017cf 100644
--- a/src/cmd/compile/internal/types2/testdata/check/const1.src
+++ b/src/cmd/compile/internal/types2/testdata/check/const1.src
@@ -6,6 +6,8 @@
 
 package const1
 
+import "math"
+
 const(
 	mi = ^int(0)
 	mu = ^uint(0)
@@ -48,7 +50,7 @@ const (
 	//           without overflow. For now we match the compiler.
 	//           See also issue #44057.
 	// smallestFloat64 = 1.0 / (1<<(1023 - 1 + 52))
-	smallestFloat64 = 4.940656458412465441765687928682213723651e-324
+	smallestFloat64 = math.SmallestNonzeroFloat64
 )
 
 const (
@@ -63,7 +65,7 @@ const (
 	//           without overflow. For now we match the compiler.
 	//           See also issue #44057.
 	// maxFloat64 = 1<<1023 * (1<<53 - 1) / (1.0<<52)
-	maxFloat64 = 1.797693134862315708145274237317043567981e+308
+	maxFloat64 = math.MaxFloat64
 )
 
 const (
@@ -281,9 +283,7 @@ const (
 	_ = assert(float64(smallestFloat32) == smallestFloat32)
 	_ = assert(float64(smallestFloat32/2) == smallestFloat32/2)
 	_ = assert(float64(smallestFloat64) == smallestFloat64)
-	// TODO(gri) With the change to the declaration of smallestFloat64
-	//           this now fails to be true. See issue #44058.
-	// _ = assert(float64(smallestFloat64/2) == 0)
+	_ = assert(float64(smallestFloat64/2) == 0)
 )
 
 const (
diff --git a/src/go/types/testdata/check/const1.src b/src/go/types/testdata/check/const1.src
index 56b6bd4ca5..c9128017cf 100644
--- a/src/go/types/testdata/check/const1.src
+++ b/src/go/types/testdata/check/const1.src
@@ -6,6 +6,8 @@
 
 package const1
 
+import "math"
+
 const(
 	mi = ^int(0)
 	mu = ^uint(0)
@@ -48,7 +50,7 @@ const (
 	//           without overflow. For now we match the compiler.
 	//           See also issue #44057.
 	// smallestFloat64 = 1.0 / (1<<(1023 - 1 + 52))
-	smallestFloat64 = 4.940656458412465441765687928682213723651e-324
+	smallestFloat64 = math.SmallestNonzeroFloat64
 )
 
 const (
@@ -63,7 +65,7 @@ const (
 	//           without overflow. For now we match the compiler.
 	//           See also issue #44057.
 	// maxFloat64 = 1<<1023 * (1<<53 - 1) / (1.0<<52)
-	maxFloat64 = 1.797693134862315708145274237317043567981e+308
+	maxFloat64 = math.MaxFloat64
 )
 
 const (
@@ -281,9 +283,7 @@ const (
 	_ = assert(float64(smallestFloat32) == smallestFloat32)
 	_ = assert(float64(smallestFloat32/2) == smallestFloat32/2)
 	_ = assert(float64(smallestFloat64) == smallestFloat64)
-	// TODO(gri) With the change to the declaration of smallestFloat64
-	//           this now fails to be true. See issue #44058.
-	// _ = assert(float64(smallestFloat64/2) == 0)
+	_ = assert(float64(smallestFloat64/2) == 0)
 )
 
 const (
diff --git a/src/math/all_test.go b/src/math/all_test.go
index d154457999..55c805e199 100644
--- a/src/math/all_test.go
+++ b/src/math/all_test.go
@@ -3196,6 +3196,15 @@ func TestFloatMinMax(t *testing.T) {
 	}
 }
 
+func TestFloatMinima(t *testing.T) {
+	if q := float32(SmallestNonzeroFloat32 / 2); q != 0 {
+		t.Errorf("float32(SmallestNonzeroFloat32 / 2) = %g, want 0", q)
+	}
+	if q := float64(SmallestNonzeroFloat64 / 2); q != 0 {
+		t.Errorf("float64(SmallestNonzeroFloat64 / 2) = %g, want 0", q)
+	}
+}
+
 var indirectSqrt = Sqrt
 
 // TestFloat32Sqrt checks the correctness of the float32 square root optimization result.
diff --git a/src/math/const.go b/src/math/const.go
index 0fc8715dd0..441b295ed4 100644
--- a/src/math/const.go
+++ b/src/math/const.go
@@ -31,8 +31,8 @@ const (
 	MaxFloat32             = 3.40282346638528859811704183484516925440e+38  // 2**127 * (2**24 - 1) / 2**23
 	SmallestNonzeroFloat32 = 1.401298464324817070923729583289916131280e-45 // 1 / 2**(127 - 1 + 23)
 
-	MaxFloat64             = 1.797693134862315708145274237317043567981e+308 // 2**1023 * (2**53 - 1) / 2**52
-	SmallestNonzeroFloat64 = 4.940656458412465441765687928682213723651e-324 // 1 / 2**(1023 - 1 + 52)
+	MaxFloat64             = 1.79769313486231570814527423731704356798070e+308   // 2**1023 * (2**53 - 1) / 2**52
+	SmallestNonzeroFloat64 = 4.9406564584124654417656879286822137236505980e-324 // 1 / 2**(1023 - 1 + 52)
 )
 
 // Integer limit values.
-- 
GitLab


From 303b194c6daf319f88e56d8ece56d924044f65a8 Mon Sep 17 00:00:00 2001
From: Dmitri Shuralyov <dmitshur@golang.org>
Date: Thu, 29 Apr 2021 12:32:44 -0400
Subject: [PATCH 1870/2400] api: update next.txt

There's no reason not to, and it'll help me test an upcoming fix
for #43956. The API additions look reasonable to me, and they'll
go through a more comprehensive API audit during the freeze.

Change-Id: I0daa6e978b199d69568f5100fdfc1b4bcfaeaef2
Reviewed-on: https://go-review.googlesource.com/c/go/+/315349
Trust: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 api/next.txt | 99 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 99 insertions(+)

diff --git a/api/next.txt b/api/next.txt
index e69de29bb2..a6471c7f3a 100644
--- a/api/next.txt
+++ b/api/next.txt
@@ -0,0 +1,99 @@
+pkg compress/lzw, method (*Reader) Close() error
+pkg compress/lzw, method (*Reader) Read([]uint8) (int, error)
+pkg compress/lzw, method (*Reader) Reset(io.Reader, Order, int)
+pkg compress/lzw, method (*Writer) Close() error
+pkg compress/lzw, method (*Writer) Reset(io.Writer, Order, int)
+pkg compress/lzw, method (*Writer) Write([]uint8) (int, error)
+pkg compress/lzw, type Reader struct
+pkg compress/lzw, type Writer struct
+pkg crypto/tls, method (*CertificateRequestInfo) Context() context.Context
+pkg crypto/tls, method (*ClientHelloInfo) Context() context.Context
+pkg crypto/tls, method (*Conn) HandshakeContext(context.Context) error
+pkg debug/elf, const SHT_MIPS_ABIFLAGS = 1879048234
+pkg debug/elf, const SHT_MIPS_ABIFLAGS SectionType
+pkg encoding/csv, method (*Reader) FieldPos(int) (int, int)
+pkg go/ast, method (*FuncDecl) IsMethod() bool
+pkg go/build, type Context struct, ToolTags []string
+pkg go/parser, const SkipObjectResolution = 64
+pkg go/parser, const SkipObjectResolution Mode
+pkg go/types, type Config struct, GoVersion string
+pkg io/fs, func FileInfoToDirEntry(FileInfo) DirEntry
+pkg net, method (*ParseError) Temporary() bool
+pkg net, method (*ParseError) Timeout() bool
+pkg net, method (IP) IsPrivate() bool
+pkg reflect, func VisibleFields(Type) []StructField
+pkg reflect, method (Method) IsExported() bool
+pkg reflect, method (StructField) IsExported() bool
+pkg runtime/cgo (darwin-amd64-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (darwin-amd64-cgo), method (Handle) Delete()
+pkg runtime/cgo (darwin-amd64-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (darwin-amd64-cgo), type Handle uintptr
+pkg runtime/cgo (freebsd-386-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (freebsd-386-cgo), method (Handle) Delete()
+pkg runtime/cgo (freebsd-386-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (freebsd-386-cgo), type Handle uintptr
+pkg runtime/cgo (freebsd-amd64-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (freebsd-amd64-cgo), method (Handle) Delete()
+pkg runtime/cgo (freebsd-amd64-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (freebsd-amd64-cgo), type Handle uintptr
+pkg runtime/cgo (freebsd-arm-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (freebsd-arm-cgo), method (Handle) Delete()
+pkg runtime/cgo (freebsd-arm-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (freebsd-arm-cgo), type Handle uintptr
+pkg runtime/cgo (linux-386-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (linux-386-cgo), method (Handle) Delete()
+pkg runtime/cgo (linux-386-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (linux-386-cgo), type Handle uintptr
+pkg runtime/cgo (linux-amd64-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (linux-amd64-cgo), method (Handle) Delete()
+pkg runtime/cgo (linux-amd64-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (linux-amd64-cgo), type Handle uintptr
+pkg runtime/cgo (linux-arm-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (linux-arm-cgo), method (Handle) Delete()
+pkg runtime/cgo (linux-arm-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (linux-arm-cgo), type Handle uintptr
+pkg runtime/cgo (netbsd-386-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (netbsd-386-cgo), method (Handle) Delete()
+pkg runtime/cgo (netbsd-386-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (netbsd-386-cgo), type Handle uintptr
+pkg runtime/cgo (netbsd-amd64-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (netbsd-amd64-cgo), method (Handle) Delete()
+pkg runtime/cgo (netbsd-amd64-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (netbsd-amd64-cgo), type Handle uintptr
+pkg runtime/cgo (netbsd-arm-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (netbsd-arm-cgo), method (Handle) Delete()
+pkg runtime/cgo (netbsd-arm-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (netbsd-arm-cgo), type Handle uintptr
+pkg runtime/cgo (netbsd-arm64-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (netbsd-arm64-cgo), method (Handle) Delete()
+pkg runtime/cgo (netbsd-arm64-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (netbsd-arm64-cgo), type Handle uintptr
+pkg runtime/cgo (openbsd-386-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (openbsd-386-cgo), method (Handle) Delete()
+pkg runtime/cgo (openbsd-386-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (openbsd-386-cgo), type Handle uintptr
+pkg runtime/cgo (openbsd-amd64-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (openbsd-amd64-cgo), method (Handle) Delete()
+pkg runtime/cgo (openbsd-amd64-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (openbsd-amd64-cgo), type Handle uintptr
+pkg syscall (openbsd-386), const MSG_CMSG_CLOEXEC = 2048
+pkg syscall (openbsd-386), const MSG_CMSG_CLOEXEC ideal-int
+pkg syscall (openbsd-386-cgo), const MSG_CMSG_CLOEXEC = 2048
+pkg syscall (openbsd-386-cgo), const MSG_CMSG_CLOEXEC ideal-int
+pkg syscall (openbsd-amd64), const MSG_CMSG_CLOEXEC = 2048
+pkg syscall (openbsd-amd64), const MSG_CMSG_CLOEXEC ideal-int
+pkg syscall (openbsd-amd64-cgo), const MSG_CMSG_CLOEXEC = 2048
+pkg syscall (openbsd-amd64-cgo), const MSG_CMSG_CLOEXEC ideal-int
+pkg syscall (windows-386), type SysProcAttr struct, AdditionalInheritedHandles []Handle
+pkg syscall (windows-386), type SysProcAttr struct, ParentProcess Handle
+pkg syscall (windows-amd64), type SysProcAttr struct, AdditionalInheritedHandles []Handle
+pkg syscall (windows-amd64), type SysProcAttr struct, ParentProcess Handle
+pkg testing, method (*B) Setenv(string, string)
+pkg testing, method (*T) Setenv(string, string)
+pkg text/template/parse, const DeferFuncCheck = 2
+pkg text/template/parse, const DeferFuncCheck Mode
+pkg time, func UnixMicro(int64) Time
+pkg time, func UnixMilli(int64) Time
+pkg time, method (*Time) IsDST() bool
+pkg time, method (Time) UnixMicro() int64
+pkg time, method (Time) UnixMilli() int64
-- 
GitLab


From 9c7207891c16951121d8b3f19f49ec72f87da9fe Mon Sep 17 00:00:00 2001
From: eric fang <eric.fang@arm.com>
Date: Thu, 29 Apr 2021 06:33:21 +0000
Subject: [PATCH 1871/2400] cmd/internal/obj/arm64: fix the size of STP series
 instructions in optab

When the class of p.To is C_NAUTO4K, STP series instructions will be translated
into add/sub + stp instructions, the total size is 8. Currently this size
value in optab is 12, this CL fixes it.

Change-Id: Ife1b9e9f8a28edca9b59f62b45a80d83f38993b0
Reviewed-on: https://go-review.googlesource.com/c/go/+/314210
Reviewed-by: eric fang <eric.fang@arm.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: eric fang <eric.fang@arm.com>
Run-TryBot: eric fang <eric.fang@arm.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/internal/obj/arm64/asm7.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/cmd/internal/obj/arm64/asm7.go b/src/cmd/internal/obj/arm64/asm7.go
index f2188c3403..575436d764 100644
--- a/src/cmd/internal/obj/arm64/asm7.go
+++ b/src/cmd/internal/obj/arm64/asm7.go
@@ -720,7 +720,7 @@ var optab = []Optab{
 	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_PQAUTO_16, 67, 4, REGSP, 0, C_XPRE},
 	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_PQAUTO_16, 67, 4, REGSP, 0, C_XPOST},
 	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_UAUTO4K, 76, 8, REGSP, 0, 0},
-	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_NAUTO4K, 76, 12, REGSP, 0, 0},
+	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_NAUTO4K, 76, 8, REGSP, 0, 0},
 	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_LAUTO, 77, 12, REGSP, LTO, 0},
 	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_NQOREG_16, 67, 4, 0, 0, 0},
 	{AFSTPQ, C_PAIR, C_NONE, C_NONE, C_NQOREG_16, 67, 4, 0, 0, C_XPRE},
@@ -760,7 +760,7 @@ var optab = []Optab{
 	{ASTP, C_PAIR, C_NONE, C_NONE, C_PPAUTO, 67, 4, REGSP, 0, C_XPRE},
 	{ASTP, C_PAIR, C_NONE, C_NONE, C_PPAUTO, 67, 4, REGSP, 0, C_XPOST},
 	{ASTP, C_PAIR, C_NONE, C_NONE, C_UAUTO4K, 76, 8, REGSP, 0, 0},
-	{ASTP, C_PAIR, C_NONE, C_NONE, C_NAUTO4K, 76, 12, REGSP, 0, 0},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_NAUTO4K, 76, 8, REGSP, 0, 0},
 	{ASTP, C_PAIR, C_NONE, C_NONE, C_LAUTO, 77, 12, REGSP, LTO, 0},
 	{ASTP, C_PAIR, C_NONE, C_NONE, C_NPOREG, 67, 4, 0, 0, 0},
 	{ASTP, C_PAIR, C_NONE, C_NONE, C_NPOREG, 67, 4, 0, 0, C_XPRE},
@@ -801,7 +801,7 @@ var optab = []Optab{
 	{ASTPW, C_PAIR, C_NONE, C_NONE, C_PSAUTO_4, 67, 4, REGSP, 0, C_XPRE},
 	{ASTPW, C_PAIR, C_NONE, C_NONE, C_PSAUTO_4, 67, 4, REGSP, 0, C_XPOST},
 	{ASTPW, C_PAIR, C_NONE, C_NONE, C_UAUTO4K, 76, 8, REGSP, 0, 0},
-	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NAUTO4K, 76, 12, REGSP, 0, 0},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NAUTO4K, 76, 8, REGSP, 0, 0},
 	{ASTPW, C_PAIR, C_NONE, C_NONE, C_LAUTO, 77, 12, REGSP, LTO, 0},
 	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NSOREG_4, 67, 4, 0, 0, 0},
 	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NSOREG_4, 67, 4, 0, 0, C_XPRE},
-- 
GitLab


From 06ac303f6a14b133254f757e54599c48e3c2a4ad Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Tue, 9 Mar 2021 16:55:15 -0600
Subject: [PATCH 1872/2400] cmd/internal/obj/ppc64: simplify got/toc address
 classification

These generate similar machine code sequences to
other symbol accesses, therefore we should merge them.

Change-Id: Id8ead284d430fadd2e58bad255deb465498dfade
Reviewed-on: https://go-review.googlesource.com/c/go/+/314109
Run-TryBot: Paul Murphy <murp@ibm.com>
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/cmd/internal/obj/ppc64/a.out.go   |  2 -
 src/cmd/internal/obj/ppc64/anames9.go |  2 -
 src/cmd/internal/obj/ppc64/asm9.go    | 92 ++++++++++-----------------
 3 files changed, 33 insertions(+), 63 deletions(-)

diff --git a/src/cmd/internal/obj/ppc64/a.out.go b/src/cmd/internal/obj/ppc64/a.out.go
index d1b662cad9..428cac528a 100644
--- a/src/cmd/internal/obj/ppc64/a.out.go
+++ b/src/cmd/internal/obj/ppc64/a.out.go
@@ -383,8 +383,6 @@ const (
 	C_ANY
 	C_GOK
 	C_ADDR
-	C_GOTADDR
-	C_TOCADDR
 	C_TLS_LE
 	C_TLS_IE
 	C_TEXTSIZE
diff --git a/src/cmd/internal/obj/ppc64/anames9.go b/src/cmd/internal/obj/ppc64/anames9.go
index 7ef00dc34e..b2632aa9ed 100644
--- a/src/cmd/internal/obj/ppc64/anames9.go
+++ b/src/cmd/internal/obj/ppc64/anames9.go
@@ -35,8 +35,6 @@ var cnames9 = []string{
 	"ANY",
 	"GOK",
 	"ADDR",
-	"GOTADDR",
-	"TOCADDR",
 	"TLS_LE",
 	"TLS_IE",
 	"TEXTSIZE",
diff --git a/src/cmd/internal/obj/ppc64/asm9.go b/src/cmd/internal/obj/ppc64/asm9.go
index 60ffc936c5..051663601a 100644
--- a/src/cmd/internal/obj/ppc64/asm9.go
+++ b/src/cmd/internal/obj/ppc64/asm9.go
@@ -226,12 +226,10 @@ var optab = []Optab{
 	{as: AMOVD, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
 	{as: AMOVD, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
 	{as: AMOVD, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
-	{as: AMOVD, a1: C_GOTADDR, a6: C_REG, type_: 81, size: 8},
 	{as: AMOVD, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
 	{as: AMOVD, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
 	{as: AMOVD, a1: C_TLS_LE, a6: C_REG, type_: 79, size: 8},
 	{as: AMOVD, a1: C_TLS_IE, a6: C_REG, type_: 80, size: 12},
-	{as: AMOVD, a1: C_TOCADDR, a6: C_REG, type_: 95, size: 8},
 	{as: AMOVD, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
 	{as: AMOVD, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 	{as: AMOVD, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
@@ -791,29 +789,24 @@ func (c *ctxt9) aclass(a *obj.Addr) int {
 
 	case obj.TYPE_MEM:
 		switch a.Name {
+		case obj.NAME_GOTREF, obj.NAME_TOCREF:
+			return C_ADDR
+
 		case obj.NAME_EXTERN,
 			obj.NAME_STATIC:
+			c.instoffset = a.Offset
 			if a.Sym == nil {
 				break
-			}
-			c.instoffset = a.Offset
-			if a.Sym != nil { // use relocation
-				if a.Sym.Type == objabi.STLSBSS {
-					if c.ctxt.Flag_shared {
-						return C_TLS_IE
-					} else {
-						return C_TLS_LE
-					}
+			} else if a.Sym.Type == objabi.STLSBSS {
+				// For PIC builds, use 12 byte got initial-exec TLS accesses.
+				if c.ctxt.Flag_shared {
+					return C_TLS_IE
 				}
+				// Otherwise, use 8 byte local-exec TLS accesses.
+				return C_TLS_LE
+			} else {
 				return C_ADDR
 			}
-			return C_LOREG
-
-		case obj.NAME_GOTREF:
-			return C_GOTADDR
-
-		case obj.NAME_TOCREF:
-			return C_TOCADDR
 
 		case obj.NAME_AUTO:
 			c.instoffset = int64(c.autosize) + a.Offset
@@ -3435,18 +3428,34 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		}
 		o1, o2 = c.symbolAccess(p.To.Sym, v, p.From.Reg, inst)
 
-	//if(dlm) reloc(&p->to, p->pc, 1);
+	case 75: // 32 bit offset symbol loads (got/toc/addr)
+		v := p.From.Offset
 
-	case 75:
-		v := c.vregoff(&p.From)
 		// Offsets in DS form loads must be a multiple of 4
 		inst := c.opload(p.As)
 		if c.opform(inst) == DS_FORM && v&0x3 != 0 {
 			log.Fatalf("invalid offset for DS form load/store %v", p)
 		}
-		o1, o2 = c.symbolAccess(p.From.Sym, v, p.To.Reg, inst)
-
-	//if(dlm) reloc(&p->from, p->pc, 1);
+		switch p.From.Name {
+		case obj.NAME_GOTREF, obj.NAME_TOCREF:
+			if v != 0 {
+				c.ctxt.Diag("invalid offset for GOT/TOC access %v", p)
+			}
+			o1 = AOP_IRR(OP_ADDIS, uint32(p.To.Reg), REG_R2, 0)
+			o2 = AOP_IRR(inst, uint32(p.To.Reg), uint32(p.To.Reg), 0)
+			rel := obj.Addrel(c.cursym)
+			rel.Off = int32(c.pc)
+			rel.Siz = 8
+			rel.Sym = p.From.Sym
+			switch p.From.Name {
+			case obj.NAME_GOTREF:
+				rel.Type = objabi.R_ADDRPOWER_GOT
+			case obj.NAME_TOCREF:
+				rel.Type = objabi.R_ADDRPOWER_TOCREL_DS
+			}
+		default:
+			o1, o2 = c.symbolAccess(p.From.Sym, v, p.To.Reg, inst)
+		}
 
 	case 76:
 		v := c.vregoff(&p.From)
@@ -3458,8 +3467,6 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		o1, o2 = c.symbolAccess(p.From.Sym, v, p.To.Reg, inst)
 		o3 = LOP_RRR(OP_EXTSB, uint32(p.To.Reg), uint32(p.To.Reg), 0)
 
-		//if(dlm) reloc(&p->from, p->pc, 1);
-
 	case 79:
 		if p.From.Offset != 0 {
 			c.ctxt.Diag("invalid offset against tls var %v", p)
@@ -3490,19 +3497,6 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		rel.Sym = p.From.Sym
 		rel.Type = objabi.R_POWER_TLS
 
-	case 81:
-		v := c.vregoff(&p.To)
-		if v != 0 {
-			c.ctxt.Diag("invalid offset against GOT slot %v", p)
-		}
-
-		o1 = AOP_IRR(OP_ADDIS, uint32(p.To.Reg), REG_R2, 0)
-		o2 = AOP_IRR(c.opload(AMOVD), uint32(p.To.Reg), uint32(p.To.Reg), 0)
-		rel := obj.Addrel(c.cursym)
-		rel.Off = int32(c.pc)
-		rel.Siz = 8
-		rel.Sym = p.From.Sym
-		rel.Type = objabi.R_ADDRPOWER_GOT
 	case 82: /* vector instructions, VX-form and VC-form */
 		if p.From.Type == obj.TYPE_REG {
 			/* reg reg none OR reg reg reg */
@@ -3671,26 +3665,6 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		cy := int(c.regoff(p.GetFrom3()))
 		o1 = AOP_Z23I(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg), uint32(cy))
 
-	case 95: /* Retrieve TOC relative symbol */
-		/* This code is for AIX only */
-		v := c.vregoff(&p.From)
-		if v != 0 {
-			c.ctxt.Diag("invalid offset against TOC slot %v", p)
-		}
-
-		inst := c.opload(p.As)
-		if c.opform(inst) != DS_FORM {
-			c.ctxt.Diag("invalid form for a TOC access in %v", p)
-		}
-
-		o1 = AOP_IRR(OP_ADDIS, uint32(p.To.Reg), REG_R2, 0)
-		o2 = AOP_IRR(inst, uint32(p.To.Reg), uint32(p.To.Reg), 0)
-		rel := obj.Addrel(c.cursym)
-		rel.Off = int32(c.pc)
-		rel.Siz = 8
-		rel.Sym = p.From.Sym
-		rel.Type = objabi.R_ADDRPOWER_TOCREL_DS
-
 	case 96: /* VSX load, DQ-form */
 		/* reg imm reg */
 		/* operand order: (RA)(DQ), XT */
-- 
GitLab


From 0dfb6fb4907c770269d5530f210567e371eebeaa Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 29 Apr 2021 21:38:43 -0700
Subject: [PATCH 1873/2400] go/ast: print CommentMap contents in source order

Sort the comment map entries before printing.
Makes it easier to use the output for debugging.

For #39753.

Change-Id: Ic8e7d27dd2df59173e2c3a04a6b71ae966703885
Reviewed-on: https://go-review.googlesource.com/c/go/+/315370
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/go/ast/commentmap.go | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/go/ast/commentmap.go b/src/go/ast/commentmap.go
index 2a653a60ac..5161ea70b7 100644
--- a/src/go/ast/commentmap.go
+++ b/src/go/ast/commentmap.go
@@ -315,9 +315,17 @@ loop:
 }
 
 func (cmap CommentMap) String() string {
+	// print map entries in sorted order
+	var nodes []Node
+	for node := range cmap {
+		nodes = append(nodes, node)
+	}
+	sort.Sort(byInterval(nodes))
+
 	var buf bytes.Buffer
 	fmt.Fprintln(&buf, "CommentMap {")
-	for node, comment := range cmap {
+	for _, node := range nodes {
+		comment := cmap[node]
 		// print name of identifiers; print node type for other nodes
 		var s string
 		if ident, ok := node.(*Ident); ok {
-- 
GitLab


From cc02d59e84b60b3221e6c079afe04d3b7e59b872 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Daniel=20Mart=C3=AD?= <mvdan@mvdan.cc>
Date: Thu, 29 Apr 2021 22:54:26 +0100
Subject: [PATCH 1874/2400] cmd/gofmt: always format non-directory arguments
 again
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

golang.org/cl/284138 introduced a regression: running "gofmt foo" would
silently ignore the file due to its lack of a ".go" extension, whereas
the tool is documented otherwise:

	Given a file, it operates on that file; given a directory, it
	operates on all .go files in that directory, recursively.

This wasn't caught as there were no tests for these edge cases. gofmt's
own tests are regular Go tests, so it's hard to test it properly without
adding an abstraction layer on top of func main.

Luckily, this kind of test is a great fit for cmd/go's own script tests,
and it just takes a few straightforward lines.

Finally, add the relevant logic back, with documentation to clarify its
intentional purpose.

Fixes #45859.

Change-Id: Ic5bf5937b8f95fcdad2b6933227c8b504ef38a82
Reviewed-on: https://go-review.googlesource.com/c/go/+/315270
Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
Trust: Daniel Martí <mvdan@mvdan.cc>
Trust: Robert Griesemer <gri@golang.org>
Trust: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go/testdata/script/fmt_load_errors.txt | 13 +++++++++++++
 src/cmd/gofmt/gofmt.go                         | 13 ++++++++++++-
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/src/cmd/go/testdata/script/fmt_load_errors.txt b/src/cmd/go/testdata/script/fmt_load_errors.txt
index 297ec0fe3c..84bf41cfba 100644
--- a/src/cmd/go/testdata/script/fmt_load_errors.txt
+++ b/src/cmd/go/testdata/script/fmt_load_errors.txt
@@ -6,6 +6,17 @@ go fmt -n exclude
 stdout 'exclude[/\\]x\.go'
 stdout 'exclude[/\\]x_linux\.go'
 
+# Test edge cases with gofmt.
+# Note that this execs GOROOT/bin/gofmt.
+
+! exec gofmt does-not-exist
+
+exec gofmt gofmt-dir/no-extension
+stdout 'package x'
+
+exec gofmt gofmt-dir
+! stdout 'package x'
+
 -- exclude/empty/x.txt --
 -- exclude/ignore/_x.go --
 package x
@@ -17,3 +28,5 @@ package x
 // +build windows
 
 package x
+-- gofmt-dir/no-extension --
+package x
diff --git a/src/cmd/gofmt/gofmt.go b/src/cmd/gofmt/gofmt.go
index fef86c941f..b3c120daab 100644
--- a/src/cmd/gofmt/gofmt.go
+++ b/src/cmd/gofmt/gofmt.go
@@ -214,8 +214,19 @@ func gofmtMain() {
 	}
 
 	for _, arg := range args {
-		if err := filepath.WalkDir(arg, visitFile); err != nil {
+		switch info, err := os.Stat(arg); {
+		case err != nil:
 			report(err)
+		case !info.IsDir():
+			// Non-directory arguments are always formatted.
+			if err := processFile(arg, nil, os.Stdout, false); err != nil {
+				report(err)
+			}
+		default:
+			// Directories are walked, ignoring non-Go files.
+			if err := filepath.WalkDir(arg, visitFile); err != nil {
+				report(err)
+			}
 		}
 	}
 }
-- 
GitLab


From 3366556d1c97a7c7925432e19f2c0bb1ecb69ecd Mon Sep 17 00:00:00 2001
From: cuiweixie <cuiweixie@gmail.com>
Date: Thu, 29 Apr 2021 15:04:15 +0000
Subject: [PATCH 1875/2400] A+C: add Weixie Cui (individual CLA)

Change-Id: I897864984bd4b79f2e224ea1a7f323e0bd5e2ef0
GitHub-Last-Rev: b85415541d12128c7515af91b02c098617478a50
GitHub-Pull-Request: golang/go#45849
Reviewed-on: https://go-review.googlesource.com/c/go/+/314991
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Ben Shi <powerman1st@163.com>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 AUTHORS      | 1 +
 CONTRIBUTORS | 1 +
 2 files changed, 2 insertions(+)

diff --git a/AUTHORS b/AUTHORS
index 1763ab88d8..48ce71f4cc 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -1425,6 +1425,7 @@ Wèi Cōngruì <crvv.mail@gmail.com>
 Wei Fu <fhfuwei@163.com>
 Wei Guangjing <vcc.163@gmail.com>
 Weichao Tang <tevic.tt@gmail.com>
+Weixie Cui <cuiweixie@gmail.com> <523516579@qq.com>
 Wembley G. Leach, Jr <wembley.gl@gmail.com>
 Will Faught <will.faught@gmail.com>
 Will Storey <will@summercat.com>
diff --git a/CONTRIBUTORS b/CONTRIBUTORS
index 5574026b75..56e3da4274 100644
--- a/CONTRIBUTORS
+++ b/CONTRIBUTORS
@@ -2526,6 +2526,7 @@ Wei Guangjing <vcc.163@gmail.com>
 Wei Xiao <wei.xiao@arm.com>
 Wei Xikai <xykwei@gmail.com>
 Weichao Tang <tevic.tt@gmail.com>
+Weixie Cui <cuiweixie@gmail.com> <523516579@qq.com>
 Wembley G. Leach, Jr <wembley.gl@gmail.com>
 Wenlei (Frank) He <wlhe@google.com>
 Wenzel Lowe <lowewenzel@gmail.com>
-- 
GitLab


From a893682d83760a9f9bb6f5d543b907ee6467cc6e Mon Sep 17 00:00:00 2001
From: Ian Mckay <iann0036@gmail.com>
Date: Thu, 29 Apr 2021 06:30:44 +0000
Subject: [PATCH 1876/2400] net/url: add Values.Has

Adds a method within Values for detecting whether a query parameter is set.

Fixes #45100

Change-Id: I6bb49417e8547e11cc7e8d55c5211d24ee436ec1
GitHub-Last-Rev: 0b27cdab9024b93bad1eab9941aff8928a29fa76
GitHub-Pull-Request: golang/go#45835
Reviewed-on: https://go-review.googlesource.com/c/go/+/314850
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Cherry Zhang <cherryyz@google.com>
---
 src/net/url/url.go      |  6 ++++++
 src/net/url/url_test.go | 18 +++++++++++++++---
 2 files changed, 21 insertions(+), 3 deletions(-)

diff --git a/src/net/url/url.go b/src/net/url/url.go
index e138082d22..a4d7c03a87 100644
--- a/src/net/url/url.go
+++ b/src/net/url/url.go
@@ -909,6 +909,12 @@ func (v Values) Del(key string) {
 	delete(v, key)
 }
 
+// Has checks whether a given key is set.
+func (v Values) Has(key string) bool {
+	_, ok := v[key]
+	return ok
+}
+
 // ParseQuery parses the URL-encoded query string and returns
 // a map listing the values specified for each key.
 // ParseQuery always returns a non-nil map containing all the
diff --git a/src/net/url/url_test.go b/src/net/url/url_test.go
index f02e4650d8..55348c4a7d 100644
--- a/src/net/url/url_test.go
+++ b/src/net/url/url_test.go
@@ -1295,10 +1295,10 @@ func TestResolveReference(t *testing.T) {
 }
 
 func TestQueryValues(t *testing.T) {
-	u, _ := Parse("http://x.com?foo=bar&bar=1&bar=2")
+	u, _ := Parse("http://x.com?foo=bar&bar=1&bar=2&baz")
 	v := u.Query()
-	if len(v) != 2 {
-		t.Errorf("got %d keys in Query values, want 2", len(v))
+	if len(v) != 3 {
+		t.Errorf("got %d keys in Query values, want 3", len(v))
 	}
 	if g, e := v.Get("foo"), "bar"; g != e {
 		t.Errorf("Get(foo) = %q, want %q", g, e)
@@ -1313,6 +1313,18 @@ func TestQueryValues(t *testing.T) {
 	if g, e := v.Get("baz"), ""; g != e {
 		t.Errorf("Get(baz) = %q, want %q", g, e)
 	}
+	if h, e := v.Has("foo"), true; h != e {
+		t.Errorf("Has(foo) = %t, want %t", h, e)
+	}
+	if h, e := v.Has("bar"), true; h != e {
+		t.Errorf("Has(bar) = %t, want %t", h, e)
+	}
+	if h, e := v.Has("baz"), true; h != e {
+		t.Errorf("Has(baz) = %t, want %t", h, e)
+	}
+	if h, e := v.Has("noexist"), false; h != e {
+		t.Errorf("Has(noexist) = %t, want %t", h, e)
+	}
 	v.Del("bar")
 	if g, e := v.Get("bar"), ""; g != e {
 		t.Errorf("second Get(bar) = %q, want %q", g, e)
-- 
GitLab


From 89bf297b2486adaaff04be154a066ea9f5e63994 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Thu, 29 Apr 2021 21:49:15 -0400
Subject: [PATCH 1877/2400] cmd/internal/objfile: emit better error for Go
 object of a different version

The Go object file format can change from version to version.
Tools like cmd/objdump and cmd/nm only onderstand the current
version of the object file. Currently, when it encounters an
object built with a different version of the toolchain, it emits
a generic error "unrecognized object file", which is not very
helpful for users. This CL makes it emit a clearer error. Now it
emits

objdump: open go116.o: go object of a different version: go116ld

Change-Id: I063c6078ed1da78f97cea65796779ae093a1a8cb
Reviewed-on: https://go-review.googlesource.com/c/go/+/315609
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/internal/archive/archive.go |  11 ++++++++++-
 src/cmd/internal/objfile/objfile.go |   3 +++
 src/cmd/objdump/objdump_test.go     |  15 +++++++++++++++
 src/cmd/objdump/testdata/go116.o    | Bin 0 -> 478 bytes
 4 files changed, 28 insertions(+), 1 deletion(-)
 create mode 100644 src/cmd/objdump/testdata/go116.o

diff --git a/src/cmd/internal/archive/archive.go b/src/cmd/internal/archive/archive.go
index e9b25fe240..d1d51b2855 100644
--- a/src/cmd/internal/archive/archive.go
+++ b/src/cmd/internal/archive/archive.go
@@ -106,6 +106,12 @@ var (
 	errNotObject        = errors.New("unrecognized object file format")
 )
 
+type ErrGoObjOtherVersion struct{ magic []byte }
+
+func (e ErrGoObjOtherVersion) Error() string {
+	return fmt.Sprintf("go object of a different version: %s", e.magic)
+}
+
 // An objReader is an object file reader.
 type objReader struct {
 	a      *Archive
@@ -389,7 +395,7 @@ func (r *objReader) parseArchive(verbose bool) error {
 // The object file consists of a textual header ending in "\n!\n"
 // and then the part we want to parse begins.
 // The format of that part is defined in a comment at the top
-// of src/liblink/objfile.c.
+// of cmd/internal/goobj/objfile.go.
 func (r *objReader) parseObject(o *GoObj, size int64) error {
 	h := make([]byte, 0, 256)
 	var c1, c2, c3 byte
@@ -418,6 +424,9 @@ func (r *objReader) parseObject(o *GoObj, size int64) error {
 		return err
 	}
 	if !bytes.Equal(p, []byte(goobj.Magic)) {
+		if bytes.HasPrefix(p, []byte("\x00go1")) && bytes.HasSuffix(p, []byte("ld")) {
+			return r.error(ErrGoObjOtherVersion{p})
+		}
 		return r.error(errCorruptObject)
 	}
 	r.skip(o.Size)
diff --git a/src/cmd/internal/objfile/objfile.go b/src/cmd/internal/objfile/objfile.go
index a58e0e159c..dcfd158ec2 100644
--- a/src/cmd/internal/objfile/objfile.go
+++ b/src/cmd/internal/objfile/objfile.go
@@ -6,6 +6,7 @@
 package objfile
 
 import (
+	"cmd/internal/archive"
 	"debug/dwarf"
 	"debug/gosym"
 	"fmt"
@@ -73,6 +74,8 @@ func Open(name string) (*File, error) {
 	}
 	if f, err := openGoFile(r); err == nil {
 		return f, nil
+	} else if _, ok := err.(archive.ErrGoObjOtherVersion); ok {
+		return nil, fmt.Errorf("open %s: %v", name, err)
 	}
 	for _, try := range openers {
 		if raw, err := try(r); err == nil {
diff --git a/src/cmd/objdump/objdump_test.go b/src/cmd/objdump/objdump_test.go
index ac184441ea..f231a7c6e0 100644
--- a/src/cmd/objdump/objdump_test.go
+++ b/src/cmd/objdump/objdump_test.go
@@ -345,3 +345,18 @@ func TestGoobjFileNumber(t *testing.T) {
 		t.Logf("output:\n%s", text)
 	}
 }
+
+func TestGoObjOtherVersion(t *testing.T) {
+	testenv.MustHaveExec(t)
+	t.Parallel()
+
+	obj := filepath.Join("testdata", "go116.o")
+	cmd := exec.Command(exe, obj)
+	out, err := cmd.CombinedOutput()
+	if err == nil {
+		t.Fatalf("objdump go116.o succeeded unexpectly")
+	}
+	if !strings.Contains(string(out), "go object of a different version") {
+		t.Errorf("unexpected error message:\n%s", out)
+	}
+}
diff --git a/src/cmd/objdump/testdata/go116.o b/src/cmd/objdump/testdata/go116.o
new file mode 100644
index 0000000000000000000000000000000000000000..6434d5c8cffe54de18af70cf255f2da061e4b1cb
GIT binary patch
literal 478
zcmY$iNi0gvu;Yr4*9-7=cX4%7fB*vs1tuYE2x(?w0v0oea1|6361dXy74nm^Qj<#*
zQWA^GGxHP@b5qPr6w>nz^$gAQj1?lR^78XixwyDgRGhdn8JQUv7z-E~7#SEC1W&8|
zkv3m^fJ;S%D?U9xUN0YPIGBK2prD`tVM9om3yjPy!RknIfg%?}dcL8dSxySfY9<B-
zhGkH^j)8$;9~!>Qz`%fxZ!<73JZ4~Ec#VYLFfcH{aC*L8a%pB>TE1REVsdt3dTL%`
zZmM2-ep+Tus-B)rVrfZ!dTL&3QDRAIiXBW?za+OnKQ*_Yq*5<EpMimaA%%f~L7ahs
hp^AZlL6m`kVIl(qgBVntfq?@QejsJoF-W$60RXM6W!?Y)

literal 0
HcmV?d00001

-- 
GitLab


From c55d5c887e8644df1e024573dbcf4e6e819371c2 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Fri, 30 Apr 2021 09:43:39 -0700
Subject: [PATCH 1878/2400] cmd/compile/internal/types2: simplify use of
 TestManual

Running the TestManual test (for manual debugging) requires
user-provided files as input. Rather than using another flag
(-files) to provide these files, just use the (remaining)
command line arguments.

Change-Id: I9b20d9f1a6a7ce839bbd690c311ce3f0d0a10496
Reviewed-on: https://go-review.googlesource.com/c/go/+/315689
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/check_test.go | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/types2/check_test.go b/src/cmd/compile/internal/types2/check_test.go
index 61bff28c8e..0ee579062a 100644
--- a/src/cmd/compile/internal/types2/check_test.go
+++ b/src/cmd/compile/internal/types2/check_test.go
@@ -42,7 +42,6 @@ import (
 var (
 	haltOnError = flag.Bool("halt", false, "halt on error")
 	listErrors  = flag.Bool("errlist", false, "list errors")
-	testFiles   = flag.String("files", "", "comma-separated list of TestManual")
 	goVersion   = flag.String("lang", "", "Go language version (e.g. \"go1.12\") for TestManual")
 )
 
@@ -239,15 +238,23 @@ func checkFiles(t *testing.T, filenames []string, goVersion string, colDelta uin
 	}
 }
 
-// TestManual is for manual testing of selected input files, provided with -files.
+// TestManual is for manual testing of input files, provided as a list
+// of arguments after the test arguments (and a separating "--"). For
+// instance, to check the files foo.go and bar.go, use:
+//
+// 	go test -run Manual -- foo.go bar.go
+//
+// To get an error list rather than having the test check against
+// ERROR comments in the input files, provide the -errlist flag.
 // The accepted Go language version can be controlled with the -lang flag.
 func TestManual(t *testing.T) {
-	if *testFiles == "" {
+	filenames := flag.Args()
+	if len(filenames) == 0 {
 		return
 	}
 	testenv.MustHaveGoBuild(t)
 	DefPredeclaredTestFuncs()
-	checkFiles(t, strings.Split(*testFiles, ","), *goVersion, 0, testing.Verbose())
+	checkFiles(t, filenames, *goVersion, 0, testing.Verbose())
 }
 
 // TODO(gri) go/types has extra TestLongConstants and TestIndexRepresentability tests
-- 
GitLab


From 95c5f4da80960d0e3511d39c9a9db7280099a37e Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Fri, 30 Apr 2021 10:20:38 -0700
Subject: [PATCH 1879/2400] cmd/compile/internal/types2: list errors by default
 in TestManual

TestManual is used for debugging; in this case we usually want to
see error messages reported rather than checked against ERROR comments
in the provided files. Make this the default. Use the new -verify
flag to verify reported errors against ERROR comments.

With this change we cannot get an error list for the non-manual
tests, but that is usually not useful anyway because there are
usually many errors in those test files. Run those tests manually
instead.

Also, corrected -lang flag synopsys: it applies to all tests, not
just TestManual.

Change-Id: I56e0ea0583840fc3ea150d9ccfc330370b66191c
Reviewed-on: https://go-review.googlesource.com/c/go/+/315729
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/check_test.go | 23 ++++++++++---------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/src/cmd/compile/internal/types2/check_test.go b/src/cmd/compile/internal/types2/check_test.go
index 0ee579062a..a3a0eea0cc 100644
--- a/src/cmd/compile/internal/types2/check_test.go
+++ b/src/cmd/compile/internal/types2/check_test.go
@@ -40,9 +40,9 @@ import (
 )
 
 var (
-	haltOnError = flag.Bool("halt", false, "halt on error")
-	listErrors  = flag.Bool("errlist", false, "list errors")
-	goVersion   = flag.String("lang", "", "Go language version (e.g. \"go1.12\") for TestManual")
+	haltOnError  = flag.Bool("halt", false, "halt on error")
+	verifyErrors = flag.Bool("verify", false, "verify errors (rather than list them) in TestManual")
+	goVersion    = flag.String("lang", "", "Go language version (e.g. \"go1.12\")")
 )
 
 func parseFiles(t *testing.T, filenames []string, mode syntax.Mode) ([]*syntax.File, []error) {
@@ -96,7 +96,7 @@ func asGoVersion(s string) string {
 	return ""
 }
 
-func checkFiles(t *testing.T, filenames []string, goVersion string, colDelta uint, trace bool) {
+func checkFiles(t *testing.T, filenames []string, goVersion string, colDelta uint, manual bool) {
 	if len(filenames) == 0 {
 		t.Fatal("no source files")
 	}
@@ -118,7 +118,8 @@ func checkFiles(t *testing.T, filenames []string, goVersion string, colDelta uin
 		goVersion = asGoVersion(pkgName)
 	}
 
-	if *listErrors && len(errlist) > 0 {
+	listErrors := manual && !*verifyErrors
+	if listErrors && len(errlist) > 0 {
 		t.Errorf("--- %s:", pkgName)
 		for _, err := range errlist {
 			t.Error(err)
@@ -132,13 +133,13 @@ func checkFiles(t *testing.T, filenames []string, goVersion string, colDelta uin
 	if len(filenames) == 1 && strings.HasSuffix(filenames[0], "importC.src") {
 		conf.FakeImportC = true
 	}
-	conf.Trace = trace
+	conf.Trace = manual && testing.Verbose()
 	conf.Importer = defaultImporter()
 	conf.Error = func(err error) {
 		if *haltOnError {
 			defer panic(err)
 		}
-		if *listErrors {
+		if listErrors {
 			t.Error(err)
 			return
 		}
@@ -146,7 +147,7 @@ func checkFiles(t *testing.T, filenames []string, goVersion string, colDelta uin
 	}
 	conf.Check(pkgName, files, nil)
 
-	if *listErrors {
+	if listErrors {
 		return
 	}
 
@@ -244,8 +245,8 @@ func checkFiles(t *testing.T, filenames []string, goVersion string, colDelta uin
 //
 // 	go test -run Manual -- foo.go bar.go
 //
-// To get an error list rather than having the test check against
-// ERROR comments in the input files, provide the -errlist flag.
+// Provide the -verify flag to verify errors against ERROR comments in
+// the input files rather than having a list of errors reported.
 // The accepted Go language version can be controlled with the -lang flag.
 func TestManual(t *testing.T) {
 	filenames := flag.Args()
@@ -254,7 +255,7 @@ func TestManual(t *testing.T) {
 	}
 	testenv.MustHaveGoBuild(t)
 	DefPredeclaredTestFuncs()
-	checkFiles(t, filenames, *goVersion, 0, testing.Verbose())
+	checkFiles(t, filenames, *goVersion, 0, true)
 }
 
 // TODO(gri) go/types has extra TestLongConstants and TestIndexRepresentability tests
-- 
GitLab


From 9c12f1b433e9dc8c2679a6dbabb98586b5d77742 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Thu, 29 Apr 2021 21:10:05 -0700
Subject: [PATCH 1880/2400] internal/buildcfg: enable regabi for Android

This will permit us to write ABIInternal assembler code for linux-amd64.

For #40724

Change-Id: I681866651554eda4229d6faa7f0c1ba42d07e57d
Reviewed-on: https://go-review.googlesource.com/c/go/+/315390
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/internal/buildcfg/exp.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/internal/buildcfg/exp.go b/src/internal/buildcfg/exp.go
index c3da77d40a..ef769b5415 100644
--- a/src/internal/buildcfg/exp.go
+++ b/src/internal/buildcfg/exp.go
@@ -20,7 +20,7 @@ import (
 // was built with.)
 var Experiment goexperiment.Flags = parseExperiments()
 
-var regabiSupported = GOARCH == "amd64" && (GOOS == "linux" || GOOS == "darwin" || GOOS == "windows")
+var regabiSupported = GOARCH == "amd64" && (GOOS == "android" || GOOS == "linux" || GOOS == "darwin" || GOOS == "windows")
 
 // experimentBaseline specifies the experiment flags that are enabled by
 // default in the current toolchain. This is, in effect, the "control"
-- 
GitLab


From 2bd3e48055cc36306d1ce5abc96685ada4e3c836 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Wed, 28 Apr 2021 11:30:48 -0400
Subject: [PATCH 1881/2400] cmd/go/internal/modload: implement lazy loading

For #36460
Updates #41297

Change-Id: I1b82176a45df499e52f1a3a0ffe23eab2a1ca86e
Reviewed-on: https://go-review.googlesource.com/c/go/+/265777
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modload/buildlist.go | 374 ++++++++++++++++++++---
 src/cmd/go/internal/modload/init.go      |   2 +-
 src/cmd/go/internal/modload/load.go      | 290 +++++++++++++++---
 src/cmd/go/testdata/script/mod_list.txt  |   3 +-
 4 files changed, 590 insertions(+), 79 deletions(-)

diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index 51fe40581a..46aee45bd5 100644
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -415,7 +415,7 @@ func expandGraph(ctx context.Context, rs *Requirements) (*Requirements, *ModuleG
 		// roots — but in a lazy module it may pull in previously-irrelevant
 		// transitive dependencies.
 
-		newRS, rsErr := updateRoots(ctx, rs.direct, rs, nil)
+		newRS, rsErr := updateRoots(ctx, rs.direct, rs, nil, nil)
 		if rsErr != nil {
 			// Failed to update roots, perhaps because of an error in a transitive
 			// dependency needed for the update. Return the original Requirements
@@ -479,30 +479,338 @@ type Conflict struct {
 	Constraint module.Version
 }
 
-// tidyRoots trims the root requirements to the minimal roots needed to
-// retain the same versions of all packages loaded by ld.
+// tidyRoots trims the root dependencies to the minimal requirements needed to
+// both retain the same versions of all packages in pkgs and satisfy the
+// lazy loading invariants (if applicable).
 func tidyRoots(ctx context.Context, rs *Requirements, pkgs []*loadPkg) (*Requirements, error) {
-	if go117LazyTODO {
-		// Tidy needs to maintain the lazy-loading invariants for lazy modules.
-		// The implementation for eager modules should be factored out into a function.
+	if rs.depth == eager {
+		return tidyEagerRoots(ctx, rs.direct, pkgs)
 	}
+	return tidyLazyRoots(ctx, rs.direct, pkgs)
+}
+
+func updateRoots(ctx context.Context, direct map[string]bool, rs *Requirements, pkgs []*loadPkg, add []module.Version) (*Requirements, error) {
+	if rs.depth == eager {
+		return updateEagerRoots(ctx, direct, rs, add)
+	}
+	return updateLazyRoots(ctx, direct, rs, pkgs, add)
+}
+
+// tidyLazyRoots returns a minimal set of root requirements that maintains the
+// "lazy loading" invariants of the go.mod file for the given packages:
+//
+// 	1. For each package marked with pkgInAll, the module path that provided that
+// 	   package is included as a root.
+// 	2. For all packages, the module that provided that package either remains
+// 	   selected at the same version or is upgraded by the dependencies of a
+// 	   root.
+//
+// If any module that provided a package has been upgraded above its previous,
+// version, the caller may need to reload and recompute the package graph.
+//
+// To ensure that the loading process eventually converges, the caller should
+// add any needed roots from the tidy root set (without removing existing untidy
+// roots) until the set of roots has converged.
+func tidyLazyRoots(ctx context.Context, direct map[string]bool, pkgs []*loadPkg) (*Requirements, error) {
+	var (
+		roots        []module.Version
+		pathIncluded = map[string]bool{Target.Path: true}
+	)
+	// We start by adding roots for every package in "all".
+	//
+	// Once that is done, we may still need to add more roots to cover upgraded or
+	// otherwise-missing test dependencies for packages in "all". For those test
+	// dependencies, we prefer to add roots for packages with shorter import
+	// stacks first, on the theory that the module requirements for those will
+	// tend to fill in the requirements for their transitive imports (which have
+	// deeper import stacks). So we add the missing dependencies for one depth at
+	// a time, starting with the packages actually in "all" and expanding outwards
+	// until we have scanned every package that was loaded.
+	var (
+		queue  []*loadPkg
+		queued = map[*loadPkg]bool{}
+	)
+	for _, pkg := range pkgs {
+		if !pkg.flags.has(pkgInAll) {
+			continue
+		}
+		if pkg.fromExternalModule() && !pathIncluded[pkg.mod.Path] {
+			roots = append(roots, pkg.mod)
+			pathIncluded[pkg.mod.Path] = true
+		}
+		queue = append(queue, pkg)
+		queued[pkg] = true
+	}
+	module.Sort(roots)
+	tidy := newRequirements(lazy, roots, direct)
+
+	for len(queue) > 0 {
+		roots = tidy.rootModules
+		mg, err := tidy.Graph(ctx)
+		if err != nil {
+			return nil, err
+		}
+
+		prevQueue := queue
+		queue = nil
+		for _, pkg := range prevQueue {
+			m := pkg.mod
+			if m.Path == "" {
+				continue
+			}
+			for _, dep := range pkg.imports {
+				if !queued[dep] {
+					queue = append(queue, dep)
+					queued[dep] = true
+				}
+			}
+			if pkg.test != nil && !queued[pkg.test] {
+				queue = append(queue, pkg.test)
+				queued[pkg.test] = true
+			}
+			if !pathIncluded[m.Path] {
+				if s := mg.Selected(m.Path); cmpVersion(s, m.Version) < 0 {
+					roots = append(roots, m)
+				}
+				pathIncluded[m.Path] = true
+			}
+		}
+
+		if len(roots) > len(tidy.rootModules) {
+			module.Sort(roots)
+			tidy = newRequirements(lazy, roots, tidy.direct)
+		}
+	}
+
+	_, err := tidy.Graph(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return tidy, nil
+}
+
+// updateLazyRoots returns a set of root requirements that maintains the “lazy
+// loading” invariants of the go.mod file:
+//
+// 	1. The selected version of the module providing each package marked with
+// 	   either pkgInAll or pkgIsRoot is included as a root.
+// 	   Note that certain root patterns (such as '...') may explode the root set
+// 	   to contain every module that provides any package imported (or merely
+// 	   required) by any other module.
+// 	2. Each root appears only once, at the selected version of its path
+// 	   (if rs.graph is non-nil) or at the highest version otherwise present as a
+// 	   root (otherwise).
+// 	3. Every module path that appears as a root in rs remains a root.
+// 	4. Every version in add is selected at its given version unless upgraded by
+// 	   (the dependencies of) an existing root or another module in add.
+//
+// The packages in pkgs are assumed to have been loaded from either the roots of
+// rs or the modules selected in the graph of rs.
+//
+// The above invariants together imply the “lazy loading” invariants for the
+// go.mod file:
+//
+// 	1. (The import invariant.) Every module that provides a package transitively
+// 	   imported by any package or test in the main module is included as a root.
+// 	   This follows by induction from (1) and (3) above. Transitively-imported
+// 	   packages loaded during this invocation are marked with pkgInAll (1),
+// 	   and by hypothesis any transitively-imported packages loaded in previous
+// 	   invocations were already roots in rs (3).
+//
+// 	2. (The argument invariant.) Every module that provides a package matching
+// 	   an explicit package pattern is included as a root. This follows directly
+// 	   from (1): packages matching explicit package patterns are marked with
+// 	   pkgIsRoot.
+//
+// 	3. (The completeness invariant.) Every module that contributed any package
+// 	   to the build is required by either the main module or one of the modules
+// 	   it requires explicitly. This invariant is left up to the caller, who must
+// 	   not load packages from outside the module graph but may add roots to the
+// 	   graph, but is facilited by (3). If the caller adds roots to the graph in
+// 	   order to resolve missing packages, then updateLazyRoots will retain them,
+// 	   the selected versions of those roots cannot regress, and they will
+// 	   eventually be written back to the main module's go.mod file.
+//
+// (See https://golang.org/design/36460-lazy-module-loading#invariants for more
+// detail.)
+func updateLazyRoots(ctx context.Context, direct map[string]bool, rs *Requirements, pkgs []*loadPkg, add []module.Version) (*Requirements, error) {
+	roots := rs.rootModules
+	rootsUpgraded := false
+
+	// “The selected version of the module providing each package marked with
+	// either pkgInAll or pkgIsRoot is included as a root.”
+	needSort := false
+	for _, pkg := range pkgs {
+		if !pkg.fromExternalModule() {
+			// pkg was not loaded from a module dependency, so we don't need
+			// to do anything special to maintain that dependency.
+			continue
+		}
 
-	depth := index.depth()
-	if go117LazyTODO {
-		// TODO(#45094): add a -go flag to 'go mod tidy' to allow the depth to be
-		// changed after loading packages.
+		switch {
+		case pkg.flags.has(pkgInAll):
+			// pkg is transitively imported by a package or test in the main module.
+			// We need to promote the module that maintains it to a root: if some
+			// other module depends on the main module, and that other module also
+			// uses lazy loading, it will expect to find all of our transitive
+			// dependencies by reading just our go.mod file, not the go.mod files of
+			// everything we depend on.
+			//
+			// (This is the “import invariant” that makes lazy loading possible.)
+
+		case pkg.flags.has(pkgIsRoot):
+			// pkg is a root of the package-import graph. (Generally this means that
+			// it matches a command-line argument.) We want future invocations of the
+			// 'go' command — such as 'go test' on the same package — to continue to
+			// use the same versions of its dependencies that we are using right now.
+			// So we need to bring this package's dependencies inside the lazy-loading
+			// horizon.
+			//
+			// Making the module containing this package a root of the module graph
+			// does exactly that: if the module containing the package is lazy it
+			// should satisfy the import invariant itself, so all of its dependencies
+			// should be in its go.mod file, and if the module containing the package
+			// is eager then if we make it a root we will load all of its transitive
+			// dependencies into the module graph.
+			//
+			// (This is the “argument invariant” of lazy loading, and is important for
+			// reproducibility.)
+
+		default:
+			// pkg is a dependency of some other package outside of the main module.
+			// As far as we know it's not relevant to the main module (and thus not
+			// relevant to consumers of the main module either), and its dependencies
+			// should already be in the module graph — included in the dependencies of
+			// the package that imported it.
+
+			if go117LazyTODO {
+				// It is possible that one of the packages we just imported came from a
+				// module with an incomplete or erroneous go.mod file — for example,
+				// perhaps the author forgot to 'git add' their updated go.mod file
+				// after adding a new package import. If that happens, ideally we want
+				// to detect the missing requirements and fix them up here.
+				//
+				// However, we should ignore transitive dependencies of external tests:
+				// the go.mod file for the module containing the test itself is expected
+				// to provide all of the relevant dependencies, and we explicitly don't
+				// want to pull in requirements on *irrelevant* requirements that happen
+				// to occur in the go.mod files for these transitive-test-only
+				// dependencies.
+			}
+
+			continue
+		}
+
+		if _, ok := rs.rootSelected(pkg.mod.Path); !ok {
+			roots = append(roots, pkg.mod)
+			rootsUpgraded = true
+			// The roots slice was initially sorted because rs.rootModules was sorted,
+			// but the root we just added could be out of order.
+			needSort = true
+		}
 	}
 
-	if depth == eager {
-		return tidyEagerRoots(ctx, rs, pkgs)
+	for _, m := range add {
+		if v, ok := rs.rootSelected(m.Path); !ok || cmpVersion(v, m.Version) < 0 {
+			roots = append(roots, m)
+			rootsUpgraded = true
+			needSort = true
+		}
+	}
+	if needSort {
+		module.Sort(roots)
 	}
-	panic("internal error: 'go mod tidy' for lazy modules is not yet implemented")
+
+	// "Each root appears only once, at the selected version of its path ….”
+	for {
+		var mg *ModuleGraph
+		if rootsUpgraded {
+			// We've added or upgraded one or more roots, so load the full module
+			// graph so that we can update those roots to be consistent with other
+			// requirements.
+			if cfg.BuildMod != "mod" {
+				// Our changes to the roots may have moved dependencies into or out of
+				// the lazy-loading horizon, which could in turn change the selected
+				// versions of other modules. (Unlike for eager modules, for lazy
+				// modules adding or removing an explicit root is a semantic change, not
+				// just a cosmetic one.)
+				return rs, errGoModDirty
+			}
+
+			rs = newRequirements(lazy, roots, direct)
+			var err error
+			mg, err = rs.Graph(ctx)
+			if err != nil {
+				return rs, err
+			}
+		} else {
+			// Since none of the roots have been upgraded, we have no reason to
+			// suspect that they are inconsistent with the requirements of any other
+			// roots. Only look at the full module graph if we've already loaded it.
+			mg, _ = rs.graph.Load().(*ModuleGraph) // May be nil.
+		}
+
+		roots = make([]module.Version, 0, len(rs.rootModules))
+		rootsUpgraded = false
+		inRootPaths := make(map[string]bool, len(rs.rootModules))
+		for _, m := range rs.rootModules {
+			if inRootPaths[m.Path] {
+				// This root specifies a redundant path. We already retained the
+				// selected version of this path when we saw it before, so omit the
+				// redundant copy regardless of its version.
+				//
+				// When we read the full module graph, we include the dependencies of
+				// every root even if that root is redundant. That better preserves
+				// reproducibility if, say, some automated tool adds a redundant
+				// 'require' line and then runs 'go mod tidy' to try to make everything
+				// consistent, since the requirements of the older version are carried
+				// over.
+				//
+				// So omitting a root that was previously present may *reduce* the
+				// selected versions of non-roots, but merely removing a requirement
+				// cannot *increase* the selected versions of other roots as a result —
+				// we don't need to mark this change as an upgrade. (This particular
+				// change cannot invalidate any other roots.)
+				continue
+			}
+
+			var v string
+			if mg == nil {
+				v, _ = rs.rootSelected(m.Path)
+			} else {
+				v = mg.Selected(m.Path)
+			}
+			roots = append(roots, module.Version{Path: m.Path, Version: v})
+			inRootPaths[m.Path] = true
+			if v != m.Version {
+				rootsUpgraded = true
+			}
+		}
+		// Note that rs.rootModules was already sorted by module path and version,
+		// and we appended to the roots slice in the same order and guaranteed that
+		// each path has only one version, so roots is also sorted by module path
+		// and (trivially) version.
+
+		if !rootsUpgraded {
+			// The root set has converged: every root going into this iteration was
+			// already at its selected version, although we have have removed other
+			// (redundant) roots for the same path.
+			break
+		}
+	}
+
+	if rs.depth == lazy && reflect.DeepEqual(roots, rs.rootModules) && reflect.DeepEqual(direct, rs.direct) {
+		// The root set is unchanged and rs was already lazy, so keep rs to
+		// preserve its cached ModuleGraph (if any).
+		return rs, nil
+	}
+	return newRequirements(lazy, roots, direct), nil
 }
 
 // tidyEagerRoots returns a minimal set of root requirements that maintains the
 // selected version of every module that provided a package in pkgs, and
-// includes the selected version of every such module in rs.direct as a root.
-func tidyEagerRoots(ctx context.Context, rs *Requirements, pkgs []*loadPkg) (*Requirements, error) {
+// includes the selected version of every such module in direct as a root.
+func tidyEagerRoots(ctx context.Context, direct map[string]bool, pkgs []*loadPkg) (*Requirements, error) {
 	var (
 		keep     []module.Version
 		keptPath = map[string]bool{}
@@ -518,7 +826,7 @@ func tidyEagerRoots(ctx context.Context, rs *Requirements, pkgs []*loadPkg) (*Re
 		if m := pkg.mod; !keptPath[m.Path] {
 			keep = append(keep, m)
 			keptPath[m.Path] = true
-			if rs.direct[m.Path] && !inRootPaths[m.Path] {
+			if direct[m.Path] && !inRootPaths[m.Path] {
 				rootPaths = append(rootPaths, m.Path)
 				inRootPaths[m.Path] = true
 			}
@@ -527,16 +835,12 @@ func tidyEagerRoots(ctx context.Context, rs *Requirements, pkgs []*loadPkg) (*Re
 
 	min, err := mvs.Req(Target, rootPaths, &mvsReqs{roots: keep})
 	if err != nil {
-		return rs, err
-	}
-	if reflect.DeepEqual(min, rs.rootModules) {
-		// rs is already tidy, so preserve its cached graph.
-		return rs, nil
+		return nil, err
 	}
-	return newRequirements(eager, min, rs.direct), nil
+	return newRequirements(eager, min, direct), nil
 }
 
-// updateRoots returns a set of root requirements that includes the selected
+// updateEagerRoots returns a set of root requirements that includes the selected
 // version of every module path in direct as a root, and maintains the selected
 // version of every module selected in the graph of rs.
 //
@@ -549,8 +853,8 @@ func tidyEagerRoots(ctx context.Context, rs *Requirements, pkgs []*loadPkg) (*Re
 // 	3. Every version selected in the graph of rs remains selected unless upgraded
 // 	   by a dependency in add.
 // 	4. Every version in add is selected at its given version unless upgraded by
-// 	   an existing root or another module in add.
-func updateRoots(ctx context.Context, direct map[string]bool, rs *Requirements, add []module.Version) (*Requirements, error) {
+// 	   (the dependencies of) an existing root or another module in add.
+func updateEagerRoots(ctx context.Context, direct map[string]bool, rs *Requirements, add []module.Version) (*Requirements, error) {
 	mg, err := rs.Graph(ctx)
 	if err != nil {
 		// We can't ignore errors in the module graph even if the user passed the -e
@@ -615,12 +919,9 @@ func updateRoots(ctx context.Context, direct map[string]bool, rs *Requirements,
 
 	// “The selected version of every module path in direct is included as a root.”
 	//
-	// This is only for convenience and clarity for end users: the choice of
-	// explicit vs. implicit dependency has no impact on MVS selection (for itself
-	// or any other module).
-	if go117LazyTODO {
-		// Update the above comment to reflect lazy loading once implemented.
-	}
+	// This is only for convenience and clarity for end users: in an eager module,
+	// the choice of explicit vs. implicit dependency has no impact on MVS
+	// selection (for itself or any other module).
 	keep := append(mg.BuildList()[1:], add...)
 	for _, m := range keep {
 		if direct[m.Path] && !inRootPaths[m.Path] {
@@ -633,11 +934,10 @@ func updateRoots(ctx context.Context, direct map[string]bool, rs *Requirements,
 	if err != nil {
 		return rs, err
 	}
-
-	// Note: if it turns out that we spend a lot of time reconstructing module
-	// graphs after this point, we could make some effort here to detect whether
-	// the root set is the same as the original root set in rs and recycle its
-	// module graph and build list, if they have already been loaded.
-
+	if reflect.DeepEqual(min, rs.rootModules) && reflect.DeepEqual(direct, rs.direct) {
+		// The root set is unchanged, so keep rs to preserve its cached ModuleGraph
+		// (if any).
+		return rs, nil
+	}
 	return newRequirements(rs.depth, min, direct), nil
 }
diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index 3c7db6c8a7..cb206a3dea 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -691,7 +691,7 @@ func requirementsFromModFile(ctx context.Context, f *modfile.File) *Requirements
 	for _, n := range mPathCount {
 		if n > 1 {
 			var err error
-			rs, err = updateRoots(ctx, rs.direct, rs, nil)
+			rs, err = updateRoots(ctx, rs.direct, rs, nil, nil)
 			if err != nil {
 				base.Fatalf("go: %v", err)
 			}
diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index d4d100e196..b822e74eb5 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -920,13 +920,22 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 		// build list we're using.
 		rootPkgs := ld.listRoots(ld.requirements)
 
-		if go117LazyTODO {
+		if ld.requirements.depth == lazy && cfg.BuildMod == "mod" {
 			// Before we start loading transitive imports of packages, locate all of
 			// the root packages and promote their containing modules to root modules
 			// dependencies. If their go.mod files are tidy (the common case) and the
 			// set of root packages does not change then we can select the correct
 			// versions of all transitive imports on the first try and complete
 			// loading in a single iteration.
+			changedBuildList := ld.preloadRootModules(ctx, rootPkgs)
+			if changedBuildList {
+				// The build list has changed, so the set of root packages may have also
+				// changed. Start over to pick up the changes. (Preloading roots is much
+				// cheaper than loading the full import graph, so we would rather pay
+				// for an extra iteration of preloading than potentially end up
+				// discarding the result of a full iteration of loading.)
+				continue
+			}
 		}
 
 		inRoots := map[*loadPkg]bool{}
@@ -947,12 +956,29 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 
 		ld.buildStacks()
 
+		changed, err := ld.updateRequirements(ctx)
+		if err != nil {
+			ld.errorf("go: %v\n", err)
+			break
+		}
+		if changed {
+			// Don't resolve missing imports until the module graph have stabilized.
+			// If the roots are still changing, they may turn out to specify a
+			// requirement on the missing package(s), and we would rather use a
+			// version specified by a new root than add a new dependency on an
+			// unrelated version.
+			continue
+		}
+
 		if !ld.ResolveMissingImports || (!HasModRoot() && !allowMissingModuleImports) {
 			// We've loaded as much as we can without resolving missing imports.
 			break
 		}
+
 		modAddedBy := ld.resolveMissingImports(ctx)
 		if len(modAddedBy) == 0 {
+			// The roots are stable, and we've resolved all of the missing packages
+			// that we can.
 			break
 		}
 
@@ -962,44 +988,59 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 		}
 		module.Sort(toAdd) // to make errors deterministic
 
-		prevRS := ld.requirements
-		if err := ld.updateRequirements(ctx, toAdd); err != nil {
+		// We ran updateRequirements before resolving missing imports and it didn't
+		// make any changes, so we know that the requirement graph is already
+		// consistent with ld.pkgs: we don't need to pass ld.pkgs to updateRoots
+		// again. (That would waste time looking for changes that we have already
+		// applied.)
+		var noPkgs []*loadPkg
+		// We also know that we're going to call updateRequirements again next
+		// iteration so we don't need to also update it here. (That would waste time
+		// computing a "direct" map that we'll have to recompute later anyway.)
+		direct := ld.requirements.direct
+		rs, err := updateRoots(ctx, direct, ld.requirements, noPkgs, toAdd)
+		if err != nil {
 			// If an error was found in a newly added module, report the package
 			// import stack instead of the module requirement stack. Packages
 			// are more descriptive.
 			if err, ok := err.(*mvs.BuildListError); ok {
 				if pkg := modAddedBy[err.Module()]; pkg != nil {
-					base.Fatalf("go: %s: %v", pkg.stackText(), err.Err)
+					ld.errorf("go: %s: %v\n", pkg.stackText(), err.Err)
+					break
 				}
 			}
-			base.Fatalf("go: %v", err)
+			ld.errorf("go: %v\n", err)
+			break
 		}
-		if reflect.DeepEqual(prevRS.rootModules, ld.requirements.rootModules) {
+		if reflect.DeepEqual(rs.rootModules, ld.requirements.rootModules) {
 			// Something is deeply wrong. resolveMissingImports gave us a non-empty
-			// set of modules to add, but adding those modules to the graph had no
-			// effect.
-			panic(fmt.Sprintf("internal error: adding %v to module graph had no effect on root requirements (%v)", toAdd, prevRS.rootModules))
+			// set of modules to add to the graph, but adding those modules had no
+			// effect — either they were already in the graph, or updateRoots did not
+			// add them as requested.
+			panic(fmt.Sprintf("internal error: adding %v to module graph had no effect on root requirements (%v)", toAdd, rs.rootModules))
 		}
+		ld.requirements = rs
 	}
 	base.ExitIfErrors() // TODO(bcmills): Is this actually needed?
 
-	if err := ld.updateRequirements(ctx, nil); err != nil {
-		base.Fatalf("go: %v", err)
-	}
-
-	if go117LazyTODO {
-		// Promoting a root can pull in previously-irrelevant requirements,
-		// changing the build list. Iterate until the roots are stable.
-	}
-
 	// Tidy the build list, if applicable, before we report errors.
 	// (The process of tidying may remove errors from irrelevant dependencies.)
 	if ld.Tidy {
-		var err error
-		ld.requirements, err = tidyRoots(ctx, ld.requirements, ld.pkgs)
+		rs, err := tidyRoots(ctx, ld.requirements, ld.pkgs)
 		if err != nil {
 			ld.errorf("go: %v\n", err)
 		}
+
+		// We continuously add tidy roots to ld.requirements during loading, so at
+		// this point the tidy roots should be a subset of the roots of
+		// ld.requirements. If not, there is a bug in the loading loop above.
+		for _, m := range rs.rootModules {
+			if v, ok := ld.requirements.rootSelected(m.Path); !ok || v != m.Version {
+				ld.errorf("go: internal error: a requirement on %v is needed but was not added during package loading\n", m)
+				base.ExitIfErrors()
+			}
+		}
+		ld.requirements = rs
 	}
 
 	// Report errors, if any.
@@ -1051,17 +1092,40 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 // 	  not provide any directly-imported package are then marked as indirect.
 //
 // 	- Root dependencies are updated to their selected versions.
-func (ld *loader) updateRequirements(ctx context.Context, add []module.Version) error {
+//
+// The "changed" return value reports whether the update changed the selected
+// version of any module that either provided a loaded package or may now
+// provide a package that was previously unresolved.
+func (ld *loader) updateRequirements(ctx context.Context) (changed bool, err error) {
 	rs := ld.requirements
 
-	// Compute directly referenced dependency modules.
-	direct := make(map[string]bool)
+	// direct contains the set of modules believed to provide packages directly
+	// imported by the main module.
+	var direct map[string]bool
+
+	// If we didn't scan all of the imports from the main module, or didn't use
+	// imports.AnyTags, then we didn't necessarily load every package that
+	// contributes “direct” imports — so we can't safely mark existing direct
+	// dependencies in ld.requirements as indirect-only. Propagate them as direct.
+	loadedDirect := ld.allPatternIsRoot && reflect.DeepEqual(ld.Tags, imports.AnyTags())
+	if loadedDirect {
+		direct = make(map[string]bool)
+	} else {
+		// TODO(bcmills): It seems like a shame to allocate and copy a map here when
+		// it will only rarely actually vary from rs.direct. Measure this cost and
+		// maybe avoid the copy.
+		direct = make(map[string]bool, len(rs.direct))
+		for mPath := range rs.direct {
+			direct[mPath] = true
+		}
+	}
+
 	for _, pkg := range ld.pkgs {
 		if pkg.mod != Target {
 			continue
 		}
 		for _, dep := range pkg.imports {
-			if dep.mod.Path == "" || dep.mod.Path == Target.Path {
+			if !dep.fromExternalModule() {
 				continue
 			}
 
@@ -1093,30 +1157,95 @@ func (ld *loader) updateRequirements(ctx context.Context, add []module.Version)
 		}
 	}
 
-	// If we didn't scan all of the imports from the main module, or didn't use
-	// imports.AnyTags, then we didn't necessarily load every package that
-	// contributes “direct” imports — so we can't safely mark existing direct
-	// dependencies in ld.requirements as indirect-only. Propagate them as direct.
-	loadedDirect := ld.allPatternIsRoot && reflect.DeepEqual(ld.Tags, imports.AnyTags())
-	if !loadedDirect {
-		for mPath := range rs.direct {
-			direct[mPath] = true
+	var addRoots []module.Version
+	if ld.Tidy {
+		// When we are tidying a lazy module, we may need to add roots to preserve
+		// the versions of indirect, test-only dependencies that are upgraded
+		// above or otherwise missing from the go.mod files of direct
+		// dependencies. (For example, the direct dependency might be a very
+		// stable codebase that predates modules and thus lacks a go.mod file, or
+		// the author of the direct dependency may have forgotten to commit a
+		// change to the go.mod file, or may have made an erroneous hand-edit that
+		// causes it to be untidy.)
+		//
+		// Promoting an indirect dependency to a root adds the next layer of its
+		// dependencies to the module graph, which may increase the selected
+		// versions of other modules from which we have already loaded packages.
+		// So after we promote an indirect dependency to a root, we need to reload
+		// packages, which means another iteration of loading.
+		//
+		// As an extra wrinkle, the upgrades due to promoting a root can cause
+		// previously-resolved packages to become unresolved. For example, the
+		// module providing an unstable package might be upgraded to a version
+		// that no longer contains that package. If we then resolve the missing
+		// package, we might add yet another root that upgrades away some other
+		// dependency. (The tests in mod_tidy_convergence*.txt illustrate some
+		// particularly worrisome cases.)
+		//
+		// To ensure that this process of promoting, adding, and upgrading roots
+		// eventually terminates, during iteration we only ever add modules to the
+		// root set — we only remove irrelevant roots at the very end of
+		// iteration, after we have already added every root that we plan to need
+		// in the (eventual) tidy root set.
+		//
+		// Since we do not remove any roots during iteration, even if they no
+		// longer provide any imported packages, the selected versions of the
+		// roots can only increase and the set of roots can only expand. The set
+		// of extant root paths is finite and the set of versions of each path is
+		// finite, so the iteration *must* reach a stable fixed-point.
+		tidy, err := tidyRoots(ctx, rs, ld.pkgs)
+		if err != nil {
+			return false, err
 		}
+		addRoots = tidy.rootModules
 	}
 
-	rs, err := updateRoots(ctx, direct, rs, add)
+	rs, err = updateRoots(ctx, direct, rs, ld.pkgs, addRoots)
 	if err != nil {
 		// We don't actually know what even the root requirements are supposed to be,
 		// so we can't proceed with loading. Return the error to the caller
-		return err
+		return false, err
 	}
-	if rs != ld.requirements {
-		if _, err := rs.Graph(ctx); err != nil {
-			ld.errorf("go: %v\n", err)
+
+	if rs != ld.requirements && !reflect.DeepEqual(rs.rootModules, ld.requirements.rootModules) {
+		// The roots of the module graph have changed in some way (not just the
+		// "direct" markings). Check whether the changes affected any of the loaded
+		// packages.
+		mg, err := rs.Graph(ctx)
+		if err != nil {
+			return false, err
+		}
+		for _, pkg := range ld.pkgs {
+			if pkg.fromExternalModule() && mg.Selected(pkg.mod.Path) != pkg.mod.Version {
+				changed = true
+				break
+			}
+			if pkg.err != nil {
+				// Promoting a module to a root may resolve an import that was
+				// previously missing (by pulling in a previously-prune dependency that
+				// provides it) or ambiguous (by promoting exactly one of the
+				// alternatives to a root and ignoring the second-level alternatives) or
+				// otherwise errored out (by upgrading from a version that cannot be
+				// fetched to one that can be).
+				//
+				// Instead of enumerating all of the possible errors, we'll just check
+				// whether importFromModules returns nil for the package.
+				// False-positives are ok: if we have a false-positive here, we'll do an
+				// extra iteration of package loading this time, but we'll still
+				// converge when the root set stops changing.
+				//
+				// In some sense, we can think of this as ‘upgraded the module providing
+				// pkg.path from "none" to a version higher than "none"’.
+				if _, _, err = importFromModules(ctx, pkg.path, rs); err == nil {
+					changed = true
+					break
+				}
+			}
 		}
-		ld.requirements = rs
 	}
-	return nil
+
+	ld.requirements = rs
+	return changed, nil
 }
 
 // resolveMissingImports returns a set of modules that could be added as
@@ -1286,6 +1415,87 @@ func (ld *loader) applyPkgFlags(ctx context.Context, pkg *loadPkg, flags loadPkg
 	}
 }
 
+// preloadRootModules loads the module requirements needed to identify the
+// selected version of each module providing a package in rootPkgs,
+// adding new root modules to the module graph if needed.
+func (ld *loader) preloadRootModules(ctx context.Context, rootPkgs []string) (changedBuildList bool) {
+	needc := make(chan map[module.Version]bool, 1)
+	needc <- map[module.Version]bool{}
+	for _, path := range rootPkgs {
+		path := path
+		ld.work.Add(func() {
+			// First, try to identify the module containing the package using only roots.
+			//
+			// If the main module is tidy and the package is in "all" — or if we're
+			// lucky — we can identify all of its imports without actually loading the
+			// full module graph.
+			m, _, err := importFromModules(ctx, path, ld.requirements)
+			if err != nil {
+				var missing *ImportMissingError
+				if errors.As(err, &missing) && ld.ResolveMissingImports {
+					// This package isn't provided by any selected module.
+					// If we can find it, it will be a new root dependency.
+					m, err = queryImport(ctx, path, ld.requirements)
+				}
+				if err != nil {
+					// We couldn't identify the root module containing this package.
+					// Leave it unresolved; we will report it during loading.
+					return
+				}
+			}
+			if m.Path == "" {
+				// The package is in std or cmd. We don't need to change the root set.
+				return
+			}
+
+			v, ok := ld.requirements.rootSelected(m.Path)
+			if !ok || v != m.Version {
+				// We found the requested package in m, but m is not a root, so
+				// loadModGraph will not load its requirements. We need to promote the
+				// module to a root to ensure that any other packages this package
+				// imports are resolved from correct dependency versions.
+				//
+				// (This is the “argument invariant” from the lazy loading design.)
+				need := <-needc
+				need[m] = true
+				needc <- need
+			}
+		})
+	}
+	<-ld.work.Idle()
+
+	need := <-needc
+	if len(need) == 0 {
+		return false // No roots to add.
+	}
+
+	toAdd := make([]module.Version, 0, len(need))
+	for m := range need {
+		toAdd = append(toAdd, m)
+	}
+	module.Sort(toAdd)
+
+	rs, err := updateRoots(ctx, ld.requirements.direct, ld.requirements, nil, toAdd)
+	if err != nil {
+		// We are missing some root dependency, and for some reason we can't load
+		// enough of the module dependency graph to add the missing root. Package
+		// loading is doomed to fail, so fail quickly.
+		ld.errorf("go: %v\n", err)
+		base.ExitIfErrors()
+		return false
+	}
+	if reflect.DeepEqual(rs.rootModules, ld.requirements.rootModules) {
+		// Something is deeply wrong. resolveMissingImports gave us a non-empty
+		// set of modules to add to the graph, but adding those modules had no
+		// effect — either they were already in the graph, or updateRoots did not
+		// add them as requested.
+		panic(fmt.Sprintf("internal error: adding %v to module graph had no effect on root requirements (%v)", toAdd, rs.rootModules))
+	}
+
+	ld.requirements = rs
+	return true
+}
+
 // load loads an individual package.
 func (ld *loader) load(ctx context.Context, pkg *loadPkg) {
 	if strings.Contains(pkg.path, "@") {
@@ -1474,7 +1684,7 @@ func (ld *loader) checkMultiplePaths() {
 		if prev, ok := firstPath[src]; !ok {
 			firstPath[src] = mod.Path
 		} else if prev != mod.Path {
-			ld.errorf("go: %s@%s used for two different module paths (%s and %s)", src.Path, src.Version, prev, mod.Path)
+			ld.errorf("go: %s@%s used for two different module paths (%s and %s)\n", src.Path, src.Version, prev, mod.Path)
 		}
 	}
 }
diff --git a/src/cmd/go/testdata/script/mod_list.txt b/src/cmd/go/testdata/script/mod_list.txt
index 1ba6d7c910..239c7caa4a 100644
--- a/src/cmd/go/testdata/script/mod_list.txt
+++ b/src/cmd/go/testdata/script/mod_list.txt
@@ -29,7 +29,8 @@ stdout 'v1.3.0.*mod[\\/]rsc.io[\\/]sampler@v1.3.1 .*[\\/]v1.3.1.mod => v1.3.1.*s
 go list std
 stdout ^math/big
 
-# rsc.io/quote/buggy should be listable as a package
+# rsc.io/quote/buggy should be listable as a package,
+# even though it is only a test.
 go list -mod=mod rsc.io/quote/buggy
 
 # rsc.io/quote/buggy should not be listable as a module
-- 
GitLab


From 9a81702b974f9d6e5569f069baaad58a0829c63a Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Wed, 28 Apr 2021 12:57:38 -0400
Subject: [PATCH 1882/2400] cmd/go: enable lazy loading
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This change activates the dormant “lazy loading” codepaths added in CL
265777 and its predecessors. Dependencies of modules that declare 'go
1.17' or higher are loaded lazily, and the dependencies in the go.mod
file maintain additional invariants to support more efficient lazy
loading for downstream dependent modules.

See https://golang.org/design/36460-lazy-module-loading for the
detailed design.

For #36460

Change-Id: Ic12ee7842aef9580357fcf8909d87654fcb2ad12
Reviewed-on: https://go-review.googlesource.com/c/go/+/314634
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 doc/go1.17.html                               | 17 +++-
 src/cmd/go.mod                                |  3 +
 src/cmd/go/internal/modload/modfile.go        |  2 +-
 src/cmd/go/testdata/script/mod_all.txt        | 54 ++++++++---
 .../script/mod_get_missing_ziphash.txt        |  2 +-
 .../script/mod_install_pkg_version.txt        |  4 +-
 .../go/testdata/script/mod_lazy_downgrade.txt | 56 +++++++++--
 .../script/mod_lazy_import_allmod.txt         | 36 +++++--
 .../testdata/script/mod_lazy_new_import.txt   | 56 ++++++++++-
 .../testdata/script/mod_lazy_test_horizon.txt | 16 ++--
 .../script/mod_lazy_test_of_test_dep.txt      | 94 +++++++++++++++++--
 src/cmd/go/testdata/script/mod_list_sums.txt  | 35 +++++++
 .../testdata/script/mod_run_pkg_version.txt   |  4 +-
 .../testdata/script/mod_tidy_convergence.txt  | 16 +++-
 .../script/mod_tidy_convergence_loop.txt      | 59 +++++++++++-
 src/cmd/vendor/modules.txt                    |  3 +
 16 files changed, 396 insertions(+), 61 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/mod_list_sums.txt

diff --git a/doc/go1.17.html b/doc/go1.17.html
index ef4086d2a5..be3b4e6d71 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -43,7 +43,22 @@ Do not send CLs removing the interior tags from such phrases.
 
 <h3 id="go-command">Go command</h3>
 
-<h4 id="modules">Modules</h4>
+<h4 id="lazy-loading">Lazy module loading</h4>
+
+<p><!-- golang.org/issue/36460 -->
+  If a module specifies <code>go</code> <code>1.17</code> or higher in its
+  <code>go.mod</code> file, its transitive requirements are now loaded lazily,
+  avoding the need to download or read <code>go.mod</code> files for
+  otherwise-irrelevant dependencies. To support lazy loading, in Go 1.17 modules
+  the <code>go</code> command maintains <em>explicit</em> requirements in
+  the <code>go.mod</code> file for every dependency that provides any package
+  transitively imported by any package or test within the module.
+  See <a href="https://golang.org/design/36460-lazy-module-loading">the design
+  document</a> for more detail.
+  <!-- TODO(bcmills): replace the design-doc link with proper documentation. -->
+</p>
+
+<h4 id="module-deprecation-comments">Module deprecation comments</h4>
 
 <p><!-- golang.org/issue/40357 -->
   Module authors may deprecate a module by adding a
diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index c5f3271a9d..1487025268 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -4,9 +4,12 @@ go 1.17
 
 require (
 	github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5
+	github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639 // indirect
 	golang.org/x/arch v0.0.0-20210308155006-05f8f0431f72
 	golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 // indirect
 	golang.org/x/mod v0.4.3-0.20210409134425-858fdbee9c24
+	golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57 // indirect
 	golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d
 	golang.org/x/tools v0.1.1-0.20210422170518-f946a157eefe
+	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
 )
diff --git a/src/cmd/go/internal/modload/modfile.go b/src/cmd/go/internal/modload/modfile.go
index 7b92a2b7ab..cd08fa5859 100644
--- a/src/cmd/go/internal/modload/modfile.go
+++ b/src/cmd/go/internal/modload/modfile.go
@@ -41,7 +41,7 @@ const (
 	// go117EnableLazyLoading toggles whether lazy-loading code paths should be
 	// active. It will be removed once the lazy loading implementation is stable
 	// and well-tested.
-	go117EnableLazyLoading = false
+	go117EnableLazyLoading = true
 
 	// go1117LazyTODO is a constant that exists only until lazy loading is
 	// implemented. Its use indicates a condition that will need to change if the
diff --git a/src/cmd/go/testdata/script/mod_all.txt b/src/cmd/go/testdata/script/mod_all.txt
index aac66292d6..090eeee22d 100644
--- a/src/cmd/go/testdata/script/mod_all.txt
+++ b/src/cmd/go/testdata/script/mod_all.txt
@@ -189,19 +189,22 @@ stdout '^example.com/main/testonly_test \[example.com/main/testonly.test\]$'
 
 rm vendor
 
-# Convert all modules to go 1.16 to enable lazy loading.
-go mod edit -go=1.16 a/go.mod
-go mod edit -go=1.16 b/go.mod
-go mod edit -go=1.16 c/go.mod
-go mod edit -go=1.16 d/go.mod
-go mod edit -go=1.16 q/go.mod
-go mod edit -go=1.16 r/go.mod
-go mod edit -go=1.16 s/go.mod
-go mod edit -go=1.16 t/go.mod
-go mod edit -go=1.16 u/go.mod
-go mod edit -go=1.16 w/go.mod
-go mod edit -go=1.16 x/go.mod
-go mod edit -go=1.16
+# Convert all modules to go 1.17 to enable lazy loading.
+go mod edit -go=1.17 a/go.mod
+go mod edit -go=1.17 b/go.mod
+go mod edit -go=1.17 c/go.mod
+go mod edit -go=1.17 d/go.mod
+go mod edit -go=1.17 q/go.mod
+go mod edit -go=1.17 r/go.mod
+go mod edit -go=1.17 s/go.mod
+go mod edit -go=1.17 t/go.mod
+go mod edit -go=1.17 u/go.mod
+go mod edit -go=1.17 w/go.mod
+go mod edit -go=1.17 x/go.mod
+go mod edit -go=1.17
+cp go.mod go.mod.orig
+go mod tidy
+cmp go.mod go.mod.orig
 
 # With lazy loading, 'go list all' with neither -mod=vendor nor -test should
 # match -mod=vendor without -test in 1.15.
@@ -282,20 +285,41 @@ stdout '^example.com/t_test \[example.com/t.test\]$'
 stdout '^example.com/u.test$'
 stdout '^example.com/u_test \[example.com/u.test\]$'
 
+# 'go list -m all' should cover all of the modules providing packages in
+# 'go list -test -deps all', but should exclude modules d and x,
+# which are not relevant to the main module and are outside of the
+# lazy-loading horizon.
 
-# TODO(#36460):
-# 'go list -m all' should exactly cover the packages in 'go list -test all'.
+go list -m -f $MODFMT all
+stdout -count=10 '^.'
+stdout '^example.com/a$'
+stdout '^example.com/b$'
+stdout '^example.com/c$'
+! stdout '^example.com/d$'
+stdout '^example.com/main$'
+stdout '^example.com/q$'
+stdout '^example.com/r$'
+stdout '^example.com/s$'
+stdout '^example.com/t$'
+stdout '^example.com/u$'
+stdout '^example.com/w$'
+! stdout '^example.com/x$'
 
 -- go.mod --
 module example.com/main
 
+// Note: this go.mod file initially specifies go 1.15,
+// but includes some redundant roots so that it
+// also already obeys the 1.17 lazy loading invariants.
 go 1.15
 
 require (
 	example.com/a v0.1.0
 	example.com/b v0.1.0
 	example.com/q v0.1.0
+	example.com/r v0.1.0 // indirect
 	example.com/t v0.1.0
+	example.com/u v0.1.0 // indirect
 )
 
 replace (
diff --git a/src/cmd/go/testdata/script/mod_get_missing_ziphash.txt b/src/cmd/go/testdata/script/mod_get_missing_ziphash.txt
index 8f6793edf5..789d42d24d 100644
--- a/src/cmd/go/testdata/script/mod_get_missing_ziphash.txt
+++ b/src/cmd/go/testdata/script/mod_get_missing_ziphash.txt
@@ -29,7 +29,7 @@ go build -n use
 -- go.mod --
 module use
 
-go 1.17
+go 1.16
 
 require rsc.io/quote v1.5.2
 -- go.sum.tidy --
diff --git a/src/cmd/go/testdata/script/mod_install_pkg_version.txt b/src/cmd/go/testdata/script/mod_install_pkg_version.txt
index 9a803c4218..b024fce174 100644
--- a/src/cmd/go/testdata/script/mod_install_pkg_version.txt
+++ b/src/cmd/go/testdata/script/mod_install_pkg_version.txt
@@ -67,9 +67,9 @@ cd tmp
 go mod init tmp
 go mod edit -require=rsc.io/fortune@v1.0.0
 ! go install -mod=readonly $GOPATH/pkg/mod/rsc.io/fortune@v1.0.0
-stderr '^go: rsc.io/fortune@v1.0.0: missing go.sum entry; to add it:\n\tgo mod download rsc.io/fortune$'
+stderr '^rsc.io/fortune@v1.0.0: missing go.sum entry; to add it:\n\tgo mod download rsc.io/fortune$'
 ! go install -mod=readonly ../../pkg/mod/rsc.io/fortune@v1.0.0
-stderr '^go: rsc.io/fortune@v1.0.0: missing go.sum entry; to add it:\n\tgo mod download rsc.io/fortune$'
+stderr '^rsc.io/fortune@v1.0.0: missing go.sum entry; to add it:\n\tgo mod download rsc.io/fortune$'
 go get -d rsc.io/fortune@v1.0.0
 go install -mod=readonly $GOPATH/pkg/mod/rsc.io/fortune@v1.0.0
 exists $GOPATH/bin/fortune$GOEXE
diff --git a/src/cmd/go/testdata/script/mod_lazy_downgrade.txt b/src/cmd/go/testdata/script/mod_lazy_downgrade.txt
index 1e84820f81..2f815fef22 100644
--- a/src/cmd/go/testdata/script/mod_lazy_downgrade.txt
+++ b/src/cmd/go/testdata/script/mod_lazy_downgrade.txt
@@ -1,5 +1,5 @@
 # This test illustrates the interaction between lazy loading and downgrading in
-# 'go get.
+# 'go get'.
 
 # The package import graph used in this test looks like:
 #
@@ -46,7 +46,7 @@ go list -m all
 # outside of the deepening scan should not affect the downgrade.
 
 cp go.mod.orig go.mod
-go mod edit -go=1.16
+go mod edit -go=1.17
 
 go list -m all
 stdout '^example.com/a v0.1.0 '
@@ -59,12 +59,50 @@ stdout '^example.com/a v0.1.0 '
 stdout '^example.com/b v0.2.0 '
 stdout '^example.com/c v0.1.0 '
 
+# At this point, b.2 is still an explicit root, so its dependency on c
+# is still tracked, and it will still be downgraded away if we remove c.
+# ('go get' never makes a root into a non-root. Only 'go mod tidy' does that.)
+
 go get -d example.com/c@none
 go list -m all
-! stdout '^example.com/a '  # TODO(#36460): example.com/a v0.1.0
-! stdout '^example.com/b '  # TODO(#36460): example.com/b v0.1.0
+! stdout '^example.com/a '
+! stdout '^example.com/b '
 ! stdout '^example.com/c '
 
+
+# This time, we drop the explicit 'b' root by downgrading it to v0.1.0
+# (the version required by a.1) and running 'go mod tidy'.
+# It is still selected at v0.1.0 (as a dependency of a),
+# but its dependency on c is now pruned from the module graph, so it doesn't
+# result in any downgrades to b or a if we run 'go get c@none'.
+
+cp go.mod.orig go.mod
+go mod edit -go=1.17
+
+go list -m all
+stdout '^example.com/a v0.1.0 '
+stdout '^example.com/b v0.3.0 '
+stdout '^example.com/c v0.2.0 '
+
+go get -d example.com/c@v0.1.0 example.com/b@v0.1.0
+go list -m all
+stdout '^example.com/a v0.1.0 '
+stdout '^example.com/b v0.1.0 '
+stdout '^example.com/c v0.1.0 '
+
+go mod tidy
+go list -m all
+stdout '^example.com/a v0.1.0 '
+stdout '^example.com/b v0.1.0 '
+! stdout '^example.com/c '
+
+go get -d example.com/c@none
+go list -m all
+stdout '^example.com/a v0.1.0'
+stdout '^example.com/b v0.1.0'
+! stdout '^example.com/c '
+
+
 -- go.mod --
 module example.com/lazy
 
@@ -91,7 +129,7 @@ import _ "example.com/a"
 -- a/go.mod --
 module example.com/a
 
-go 1.15
+go 1.17
 
 require example.com/b v0.1.0
 -- a/a.go --
@@ -104,7 +142,7 @@ import _ "example.com/b"
 -- b1/go.mod --
 module example.com/b
 
-go 1.15
+go 1.17
 
 require example.com/c v0.1.0
 -- b1/b.go --
@@ -116,7 +154,7 @@ import _ "example.com/c"
 -- b2/go.mod --
 module example.com/b
 
-go 1.15
+go 1.17
 
 require example.com/c v0.1.0
 -- b2/b.go --
@@ -128,7 +166,7 @@ import _ "example.com/c"
 -- b3/go.mod --
 module example.com/b
 
-go 1.15
+go 1.17
 
 require example.com/c v0.2.0
 -- b3/b.go --
@@ -140,6 +178,6 @@ import _ "example.com/c"
 -- c/go.mod --
 module example.com/c
 
-go 1.15
+go 1.17
 -- c/c.go --
 package c
diff --git a/src/cmd/go/testdata/script/mod_lazy_import_allmod.txt b/src/cmd/go/testdata/script/mod_lazy_import_allmod.txt
index 4ad8cbf8ee..3dc1515df2 100644
--- a/src/cmd/go/testdata/script/mod_lazy_import_allmod.txt
+++ b/src/cmd/go/testdata/script/mod_lazy_import_allmod.txt
@@ -53,8 +53,8 @@ stdout '^c v0.1.0 '
 
 cp m.go.orig m.go
 cp go.mod.orig go.mod
-go mod edit -go=1.16
-go mod edit -go=1.16 go.mod.new
+go mod edit -go=1.17
+go mod edit -go=1.17 go.mod.new
 
 cp go.mod go.mod.orig
 go mod tidy
@@ -63,14 +63,15 @@ cmp go.mod.orig go.mod
 go list -m all
 stdout '^a v0.1.0 '
 stdout '^b v0.1.0 '
-stdout '^c v0.1.0 '  # TODO(#36460): This should be pruned out.
+! stdout '^c '
 
-# After adding a new import of b/y,
-# the import of c from b/y should again resolve to the version required by b.
+# After adding a new direct import of b/y,
+# the existing verison of b should be promoted to a root,
+# bringing the version of c required by b into the build list.
 
 cp m.go.new m.go
 go mod tidy
-cmp go.mod.new go.mod
+cmp go.mod.lazy go.mod
 
 go list -m all
 stdout '^a v0.1.0 '
@@ -124,6 +125,23 @@ require (
 	b v0.1.0
 )
 
+replace (
+	a v0.1.0 => ./a1
+	b v0.1.0 => ./b1
+	c v0.1.0 => ./c1
+	c v0.2.0 => ./c2
+)
+-- go.mod.lazy --
+module m
+
+go 1.17
+
+require (
+	a v0.1.0
+	b v0.1.0
+	c v0.1.0 // indirect
+)
+
 replace (
 	a v0.1.0 => ./a1
 	b v0.1.0 => ./b1
@@ -133,7 +151,7 @@ replace (
 -- a1/go.mod --
 module a
 
-go 1.16
+go 1.17
 
 require b v0.1.0
 -- a1/a.go --
@@ -145,7 +163,7 @@ import _ "b/x"
 -- b1/go.mod --
 module b
 
-go 1.16
+go 1.17
 
 require c v0.1.0
 -- b1/x/x.go --
@@ -161,7 +179,7 @@ func CVersion() string {
 -- c1/go.mod --
 module c
 
-go 1.16
+go 1.17
 -- c1/c.go --
 package c
 
diff --git a/src/cmd/go/testdata/script/mod_lazy_new_import.txt b/src/cmd/go/testdata/script/mod_lazy_new_import.txt
index 1be61a1561..86b14b64b6 100644
--- a/src/cmd/go/testdata/script/mod_lazy_new_import.txt
+++ b/src/cmd/go/testdata/script/mod_lazy_new_import.txt
@@ -5,7 +5,7 @@
 #
 # lazy ---- a/x ---- b
 #     \
-#      ---- a/y ---- c
+#      ---- a/y (new) ---- c
 #
 # Where a/x and x/y are disjoint packages, but both contained in module a.
 #
@@ -35,14 +35,29 @@ go list -m all
 stdout '^example.com/c v0.1.0' # not v0.2.0 as would be resolved by 'latest'
 cmp go.mod go.mod.old
 
-# TODO(#36460):
+# Now, we repeat the test with a lazy main module.
 cp lazy.go.old lazy.go
-cp go.mod.old go.mod
-go mod edit -go=1.16
+cp go.mod.117 go.mod
+
+# Before adding a new import, the go.mod file should
+# enumerate modules for all packages already imported.
+go list all
+cmp go.mod go.mod.117
 
 # When a new import is found, we should perform a deepening scan of the existing
 # dependencies and add a requirement on the version required by those
 # dependencies — not re-resolve 'latest'.
+cp lazy.go.new lazy.go
+
+! go list all
+stderr '^go: updates to go.mod needed; to update it:\n\tgo mod tidy$'
+
+go mod tidy
+go list all
+go list -m all
+stdout '^example.com/c v0.1.0' # not v0.2.0 as would be resolved by 'latest'
+
+cmp go.mod go.mod.new
 
 
 -- go.mod --
@@ -52,6 +67,39 @@ go 1.15
 
 require example.com/a v0.1.0
 
+replace (
+	example.com/a v0.1.0 => ./a
+	example.com/b v0.1.0 => ./b
+	example.com/c v0.1.0 => ./c1
+	example.com/c v0.2.0 => ./c2
+)
+-- go.mod.117 --
+module example.com/lazy
+
+go 1.17
+
+require (
+	example.com/a v0.1.0
+	example.com/b v0.1.0 // indirect
+)
+
+replace (
+	example.com/a v0.1.0 => ./a
+	example.com/b v0.1.0 => ./b
+	example.com/c v0.1.0 => ./c1
+	example.com/c v0.2.0 => ./c2
+)
+-- go.mod.new --
+module example.com/lazy
+
+go 1.17
+
+require (
+	example.com/a v0.1.0
+	example.com/b v0.1.0 // indirect
+	example.com/c v0.1.0 // indirect
+)
+
 replace (
 	example.com/a v0.1.0 => ./a
 	example.com/b v0.1.0 => ./b
diff --git a/src/cmd/go/testdata/script/mod_lazy_test_horizon.txt b/src/cmd/go/testdata/script/mod_lazy_test_horizon.txt
index 9cdfad79f6..7d07eb60aa 100644
--- a/src/cmd/go/testdata/script/mod_lazy_test_horizon.txt
+++ b/src/cmd/go/testdata/script/mod_lazy_test_horizon.txt
@@ -32,12 +32,12 @@ stdout '^c v0.2.0 '
 # but the irrelevant dependency on c v0.2.0 should be pruned out,
 # leaving only the relevant dependency on c v0.1.0.
 
-go mod edit -go=1.16
+go mod edit -go=1.17
 go list -m c
-stdout '^c v0.2.0'  # TODO(#36460): v0.1.0
+stdout '^c v0.1.0'
 
 [!short] go test -v x
-[!short] stdout ' c v0.2.0$'  # TODO(#36460): v0.1.0
+[!short] stdout ' c v0.1.0$'
 
 -- m.go --
 package m
@@ -66,7 +66,7 @@ replace (
 -- a1/go.mod --
 module a
 
-go 1.16
+go 1.17
 
 require b v0.1.0
 -- a1/a.go --
@@ -78,7 +78,7 @@ import _ "b"
 -- b1/go.mod --
 module b
 
-go 1.16
+go 1.17
 
 require c v0.2.0
 -- b1/b.go --
@@ -97,7 +97,7 @@ func TestCVersion(t *testing.T) {
 -- c1/go.mod --
 module c
 
-go 1.16
+go 1.17
 -- c1/c.go --
 package c
 
@@ -105,7 +105,7 @@ const Version = "v0.1.0"
 -- c2/go.mod --
 module c
 
-go 1.16
+go 1.17
 -- c2/c.go --
 package c
 
@@ -113,7 +113,7 @@ const Version = "v0.2.0"
 -- x1/go.mod --
 module x
 
-go 1.16
+go 1.17
 
 require c v0.1.0
 -- x1/x.go --
diff --git a/src/cmd/go/testdata/script/mod_lazy_test_of_test_dep.txt b/src/cmd/go/testdata/script/mod_lazy_test_of_test_dep.txt
index ca6c55040e..722712d1f2 100644
--- a/src/cmd/go/testdata/script/mod_lazy_test_of_test_dep.txt
+++ b/src/cmd/go/testdata/script/mod_lazy_test_of_test_dep.txt
@@ -21,12 +21,13 @@ cp go.mod go.mod.old
 go mod tidy
 cmp go.mod go.mod.old
 
+
 # In Go 1.15 mode, 'go list -m all' includes modules needed by the
 # transitive closure of tests of dependencies of tests of dependencies of ….
 
 go list -m all
-stdout 'example.com/b v0.1.0'
-stdout 'example.com/c v0.1.0'
+stdout '^example.com/b v0.1.0 '
+stdout '^example.com/c v0.1.0 '
 cmp go.mod go.mod.old
 
 # 'go test' (or equivalent) of any such dependency, no matter how remote, does
@@ -36,18 +37,24 @@ go list -test -deps example.com/a
 stdout example.com/b
 ! stdout example.com/c
 
-[!short] go test -c example.com/a
+[!short] go test -c -o $devnull example.com/a
 [!short] cmp go.mod go.mod.old
 
 go list -test -deps example.com/b
 stdout example.com/c
 
-[!short] go test -c example.com/b
+[!short] go test -c -o $devnull example.com/b
 [!short] cmp go.mod go.mod.old
 
-# TODO(#36460):
+go mod edit -go=1.17 a/go.mod
+go mod edit -go=1.17 b1/go.mod
+go mod edit -go=1.17 b2/go.mod
+go mod edit -go=1.17 c1/go.mod
+go mod edit -go=1.17 c2/go.mod
+go mod edit -go=1.17
+
 
-# After changing to 'go 1.16` uniformly, 'go list -m all' should prune out
+# After changing to 'go 1.17` uniformly, 'go list -m all' should prune out
 # example.com/c, because it is not imported by any package (or test of a package)
 # transitively imported by the main module.
 #
@@ -62,10 +69,66 @@ stdout example.com/c
 # version of its module.
 
 # However, if we reach c by running successive tests starting from the main
-# module, we should end up with exactly the version require by c, with an update
+# module, we should end up with exactly the version required by b, with an update
 # to the go.mod file as soon as we test a test dependency that is not itself in
 # "all".
 
+cp go.mod go.mod.117
+go mod tidy
+cmp go.mod go.mod.117
+
+go list -m all
+stdout '^example.com/b v0.1.0 '
+! stdout '^example.com/c '
+
+# 'go test' of a package (transitively) imported by the main module
+# should work without changes to the go.mod file.
+
+go list -test -deps example.com/a
+stdout example.com/b
+! stdout example.com/c
+
+[!short] go test -c -o $devnull example.com/a
+
+# However, 'go test' of a package that is itself a dependency should require an
+# update to the go.mod file.
+! go list -test -deps example.com/b
+
+	# TODO(#36460): The hint here is wrong. We should suggest
+	# 'go get -t example.com/b@v0.1.0' instead of 'go mod tidy'.
+stderr '^go: updates to go\.mod needed; to update it:\n\tgo mod tidy$'
+
+[!short] ! go test -c -o $devnull example.com/b
+[!short] stderr '^go: updates to go\.mod needed; to update it:\n\tgo mod tidy$'
+
+go get -t example.com/b@v0.1.0
+go list -test -deps example.com/b
+stdout example.com/c
+
+[!short] go test -c -o $devnull example.com/b
+
+# The update should bring the version required by b, not the latest version of c.
+
+go list -m example.com/c
+stdout '^example.com/c v0.1.0 '
+
+cmp go.mod go.mod.b
+
+
+# We should reach the same state if we arrive at it via `go test -mod=mod`.
+
+cp go.mod.117 go.mod
+
+[short] go list -mod=mod -test -deps example.com/a
+[!short] go test -mod=mod -c -o $devnull example.com/a
+
+[short] go list -mod=mod -test -deps example.com/b
+[!short] go test -mod=mod -c -o $devnull example.com/b
+
+cmp go.mod go.mod.b
+
+
+
 -- go.mod --
 module example.com/lazy
 
@@ -73,6 +136,23 @@ go 1.15
 
 require example.com/a v0.1.0
 
+replace (
+	example.com/a v0.1.0 => ./a
+	example.com/b v0.1.0 => ./b1
+	example.com/b v0.2.0 => ./b2
+	example.com/c v0.1.0 => ./c1
+	example.com/c v0.2.0 => ./c2
+)
+-- go.mod.b --
+module example.com/lazy
+
+go 1.17
+
+require (
+	example.com/a v0.1.0
+	example.com/b v0.1.0 // indirect
+)
+
 replace (
 	example.com/a v0.1.0 => ./a
 	example.com/b v0.1.0 => ./b1
diff --git a/src/cmd/go/testdata/script/mod_list_sums.txt b/src/cmd/go/testdata/script/mod_list_sums.txt
new file mode 100644
index 0000000000..e5f80d7fb6
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_list_sums.txt
@@ -0,0 +1,35 @@
+# https://golang.org/issue/41297: 'go list -m' should not require go.sum with
+# -versions or when all args are version queries.
+
+go mod init m
+go mod edit -require=rsc.io/quote@v1.5.1
+
+# 'go list' currently loads the whole build list, even when listing only
+# non-dependencies.
+#
+# TODO(#41297): Thes should not be errors.
+
+! go list -m -mod=readonly rsc.io/quote@latest
+stderr '^go list -m: rsc\.io/quote@v1\.5\.1: missing go\.sum entry; to add it:\n\tgo mod download rsc\.io/quote$'
+
+! go list -m -mod=readonly -versions rsc.io/quote
+stderr '^go list -m: rsc\.io/quote@v1\.5\.1: missing go\.sum entry; to add it:\n\tgo mod download rsc\.io/quote$'
+
+# Incidentally fetching the required version of a module records its checksum,
+# just because it happens to be in the build list, and recording the checksum
+# triggers an error under -mod=readonly.
+#
+# TODO(#41297): This should not be an error.
+! go list -m -mod=readonly rsc.io/quote@<v1.5.2
+stderr '^go list -m: rsc\.io/quote@v1\.5\.1: missing go\.sum entry; to add it:\n\tgo mod download rsc\.io/quote$'
+! stderr '^go: updates to go.sum needed, disabled by -mod=readonly$'
+
+# Attempting to list the versions of a module that is not a root dependency
+# causes the build list to be resolved (so that the selected version can *also*
+# be identified, even though it is not relevant to this particular output).
+# That, in turn, causes us to need checksums for the go.sum files for the
+# modules in the module graph.
+#
+# TODO(#41297): This should not be an error either.
+! go list -m -mod=readonly -versions rsc.io/sampler
+stderr '^go list -m: rsc\.io/quote@v1\.5\.1: missing go\.sum entry; to add it:\n\tgo mod download rsc\.io/quote$'
diff --git a/src/cmd/go/testdata/script/mod_run_pkg_version.txt b/src/cmd/go/testdata/script/mod_run_pkg_version.txt
index 48462230b6..3c3ed27e91 100644
--- a/src/cmd/go/testdata/script/mod_run_pkg_version.txt
+++ b/src/cmd/go/testdata/script/mod_run_pkg_version.txt
@@ -64,9 +64,9 @@ cd tmp
 go mod init tmp
 go mod edit -require=rsc.io/fortune@v1.0.0
 ! go run -mod=readonly $GOPATH/pkg/mod/rsc.io/fortune@v1.0.0
-stderr '^go: rsc.io/fortune@v1.0.0: missing go.sum entry; to add it:\n\tgo mod download rsc.io/fortune$'
+stderr '^rsc.io/fortune@v1.0.0: missing go.sum entry; to add it:\n\tgo mod download rsc.io/fortune$'
 ! go run -mod=readonly ../../pkg/mod/rsc.io/fortune@v1.0.0
-stderr '^go: rsc.io/fortune@v1.0.0: missing go.sum entry; to add it:\n\tgo mod download rsc.io/fortune$'
+stderr '^rsc.io/fortune@v1.0.0: missing go.sum entry; to add it:\n\tgo mod download rsc.io/fortune$'
 cd ..
 rm tmp
 
diff --git a/src/cmd/go/testdata/script/mod_tidy_convergence.txt b/src/cmd/go/testdata/script/mod_tidy_convergence.txt
index de85d23e5d..22c8fc66c5 100644
--- a/src/cmd/go/testdata/script/mod_tidy_convergence.txt
+++ b/src/cmd/go/testdata/script/mod_tidy_convergence.txt
@@ -84,8 +84,22 @@ go mod tidy
 cmp go.mod go.mod.postget
 
 
+# The 'tidy' logic for a lazy main module is somewhat different from that for an
+# eager main module, but the overall behavior is the same.
 
-# TODO(#36460): Repeat this test with a lazy main module.
+cp go.mod.orig go.mod
+go mod edit -go=1.17 go.mod
+go mod edit -go=1.17 go.mod.tidye
+go mod edit -go=1.17 go.mod.postget
+
+go mod tidy -e
+cmp go.mod go.mod.tidye
+stderr '^go: found example\.net/y in example\.net/y v0.2.0$'
+stderr '^example\.net/m imports\n\texample\.net/x: package example\.net/x provided by example\.net/x at latest version v0\.1\.0 but not at required version v0\.2\.0-pre$'
+
+go get -d example.net/x@v0.1.0 example.net/y@v0.1.0
+go mod tidy
+cmp go.mod go.mod.postget
 
 
 -- go.mod --
diff --git a/src/cmd/go/testdata/script/mod_tidy_convergence_loop.txt b/src/cmd/go/testdata/script/mod_tidy_convergence_loop.txt
index efcd8f2a55..3c4d3244d5 100644
--- a/src/cmd/go/testdata/script/mod_tidy_convergence_loop.txt
+++ b/src/cmd/go/testdata/script/mod_tidy_convergence_loop.txt
@@ -101,7 +101,64 @@ go mod tidy -e
 cmp go.mod go.mod.postget
 
 
-# TODO(#36460): Repeat this test with a lazy main module.
+# The 'tidy' logic for a lazy main module requires more iterations to converge,
+# because it is willing to drop dependencies on non-root modules that do not
+# otherwise provide imported packages.
+#
+# On the first iteration, it adds x.1 as a root, which upgrades z and w,
+# dropping w.1's requirement on y. w.1 was initially a root, so the upgraded
+# w.2-pre is retained as a root.
+#
+# On the second iteration, it adds y.1 as a root, which upgrades w and x,
+# dropping x.1's requirement on z. x.1 was added as a root in the previous step,
+# so the upgraded x.2-pre is retained as a root.
+#
+# On the third iteration, it adds z.1 as a root, which upgrades x and y.
+# x and y were already roots (from the previous steps), so their upgraded versions
+# are retained (not dropped) and the iteration stops.
+#
+# At that point, we have z.1 as a root providing package z,
+# and w, x, and y have all been upgraded to no longer provide any packages.
+# So only z is retained as a new root.
+#
+# (From the above, we can see that in a lazy module we still cycle through the
+# same possible root states, but in a different order from the eager case.)
+#
+# TODO(bcmills): if we retained the upgrades on w, x, and y (since they are
+# lexical prefixes for unresolved packages w, x, and y, respectively), then 'go
+# mod tidy -e' itself would become stable and no longer cycle through states.
+
+cp go.mod.orig go.mod
+go mod edit -go=1.17 go.mod
+cp go.mod go.mod.117
+go mod edit -go=1.17 go.mod.tidye1
+go mod edit -go=1.17 go.mod.tidye2
+go mod edit -go=1.17 go.mod.tidye3
+go mod edit -go=1.17 go.mod.postget
+
+go list -m all
+
+go mod tidy -e
+cmp go.mod go.mod.tidye3
+
+go mod tidy -e
+cmp go.mod go.mod.tidye2
+
+go mod tidy -e
+cmp go.mod go.mod.tidye1
+
+go mod tidy -e
+cmp go.mod go.mod.117
+
+
+# As in the eager case, for the lazy module the fully-upgraded dependency graph
+# becomes empty, and the empty graph is stable.
+
+go get -d example.net/w@v0.2.0-pre example.net/x@v0.2.0-pre example.net/y@v0.2.0-pre example.net/z@v0.2.0-pre
+go mod tidy -e
+cmp go.mod go.mod.postget
+go mod tidy -e
+cmp go.mod go.mod.postget
 
 
 -- m.go --
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 9229d2dc8b..0457b374b0 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -16,6 +16,7 @@ github.com/google/pprof/third_party/d3
 github.com/google/pprof/third_party/d3flamegraph
 github.com/google/pprof/third_party/svgpan
 # github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639
+## explicit
 github.com/ianlancetaylor/demangle
 # golang.org/x/arch v0.0.0-20210308155006-05f8f0431f72
 ## explicit
@@ -39,6 +40,7 @@ golang.org/x/mod/sumdb/note
 golang.org/x/mod/sumdb/tlog
 golang.org/x/mod/zip
 # golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57
+## explicit
 golang.org/x/sys/internal/unsafeheader
 golang.org/x/sys/plan9
 golang.org/x/sys/unix
@@ -91,5 +93,6 @@ golang.org/x/tools/go/types/typeutil
 golang.org/x/tools/internal/analysisinternal
 golang.org/x/tools/internal/lsp/fuzzy
 # golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1
+## explicit
 golang.org/x/xerrors
 golang.org/x/xerrors/internal
-- 
GitLab


From 8d8abb3b8a80d341ce2d7c6dd3f2a43fd586bed8 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Thu, 29 Apr 2021 10:27:43 -0400
Subject: [PATCH 1883/2400] cmd/go: verify lazy-loading invariants when loading
 the vendor list for a lazy module

For #36460

Change-Id: Ib4b1baea35826c3e359456f8dba09a49283e7fee
Reviewed-on: https://go-review.googlesource.com/c/go/+/315069
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modload/buildlist.go | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index 46aee45bd5..4b83ede541 100644
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -140,12 +140,21 @@ func (rs *Requirements) initVendor(vendorList []module.Version) {
 			// The roots of a lazy module should already include every module in the
 			// vendor list, because the vendored modules are the same as those
 			// maintained as roots by the lazy loading “import invariant”.
-			if go117LazyTODO {
-				// Double-check here that that invariant holds.
+			//
+			// Just to be sure, we'll double-check that here.
+			inconsistent := false
+			for _, m := range vendorList {
+				if v, ok := rs.rootSelected(m.Path); !ok || v != m.Version {
+					base.Errorf("go: vendored module %v should be required explicitly in go.mod", m)
+					inconsistent = true
+				}
+			}
+			if inconsistent {
+				base.Fatalf("go: %v", errGoModDirty)
 			}
 
-			// So we can just treat the rest of the module graph as effectively
-			// “pruned out”, like a more aggressive version of lazy loading:
+			// Now we can treat the rest of the module graph as effectively “pruned
+			// out”, like a more aggressive version of lazy loading: in vendor mode,
 			// the root requirements *are* the complete module graph.
 			mg.g.Require(Target, rs.rootModules)
 		} else {
-- 
GitLab


From 4063605e0d0ce2ee2603c70a70c3a918adb7369a Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Wed, 28 Apr 2021 12:57:55 -0400
Subject: [PATCH 1884/2400] cmd/go/internal/modload: avoid loading the full
 module graph for imports satisfied by lazy roots

For #36460

Change-Id: Ibdbaa893ded772617e22f12db7a0463604db5195
Reviewed-on: https://go-review.googlesource.com/c/go/+/308516
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modload/import.go         | 176 ++++++++++--------
 src/cmd/go/internal/modload/init.go           |  16 ++
 src/cmd/go/internal/modload/load.go           |  23 ++-
 .../script/mod_install_pkg_version.txt        |   4 +-
 .../testdata/script/mod_run_pkg_version.txt   |   4 +-
 5 files changed, 136 insertions(+), 87 deletions(-)

diff --git a/src/cmd/go/internal/modload/import.go b/src/cmd/go/internal/modload/import.go
index 4e62e61bb0..6c863351ff 100644
--- a/src/cmd/go/internal/modload/import.go
+++ b/src/cmd/go/internal/modload/import.go
@@ -220,10 +220,13 @@ func (e *invalidImportError) Unwrap() error {
 	return e.err
 }
 
-// importFromModules finds the module and directory in the build list
-// containing the package with the given import path. The answer must be unique:
-// importFromModules returns an error if multiple modules attempt to provide
-// the same package.
+// importFromModules finds the module and directory in the dependency graph of
+// rs containing the package with the given import path. If mg is nil,
+// importFromModules attempts to locate the module using only the main module
+// and the roots of rs before it loads the full graph.
+//
+// The answer must be unique: importFromModules returns an error if multiple
+// modules are observed to provide the same package.
 //
 // importFromModules can return a module with an empty m.Path, for packages in
 // the standard library.
@@ -233,7 +236,7 @@ func (e *invalidImportError) Unwrap() error {
 //
 // If the package is not present in any module selected from the requirement
 // graph, importFromModules returns an *ImportMissingError.
-func importFromModules(ctx context.Context, path string, rs *Requirements) (m module.Version, dir string, err error) {
+func importFromModules(ctx context.Context, path string, rs *Requirements, mg *ModuleGraph) (m module.Version, dir string, err error) {
 	if strings.Contains(path, "@") {
 		return module.Version{}, "", fmt.Errorf("import path should not have @version")
 	}
@@ -295,93 +298,106 @@ func importFromModules(ctx context.Context, path string, rs *Requirements) (m mo
 	// large projects both M and P may be very large (note that M ≤ P), but k
 	// will tend to remain smallish (if for no other reason than filesystem
 	// path limitations).
-	var mg *ModuleGraph
-	if go117LazyTODO {
-		// Pull the prefix-matching loop below into another (new) loop.
-		// If the main module is lazy, try it once with mg == nil, and then load mg
-		// and try again.
-	} else {
-		mg, err = rs.Graph(ctx)
-		if err != nil {
-			// We might be missing one or more transitive (implicit) dependencies from
-			// the module graph, so we can't return an ImportMissingError here — one
-			// of the missing modules might actually contain the package in question,
-			// in which case we shouldn't go looking for it in some new dependency.
-			return module.Version{}, "", err
-		}
-	}
+	//
+	// We perform this iteration either one or two times. If mg is initially nil,
+	// then we first attempt to load the package using only the main module and
+	// its root requirements. If that does not identify the package, or if mg is
+	// already non-nil, then we attempt to load the package using the full
+	// requirements in mg.
+	for {
+		var sumErrMods []module.Version
+		for prefix := path; prefix != "."; prefix = pathpkg.Dir(prefix) {
+			var (
+				v  string
+				ok bool
+			)
+			if mg == nil {
+				v, ok = rs.rootSelected(prefix)
+			} else {
+				v, ok = mg.Selected(prefix), true
+			}
+			if !ok || v == "none" {
+				continue
+			}
+			m := module.Version{Path: prefix, Version: v}
 
-	var sumErrMods []module.Version
-	for prefix := path; prefix != "."; prefix = pathpkg.Dir(prefix) {
-		v := mg.Selected(prefix)
-		if v == "none" {
-			continue
+			needSum := true
+			root, isLocal, err := fetch(ctx, m, needSum)
+			if err != nil {
+				if sumErr := (*sumMissingError)(nil); errors.As(err, &sumErr) {
+					// We are missing a sum needed to fetch a module in the build list.
+					// We can't verify that the package is unique, and we may not find
+					// the package at all. Keep checking other modules to decide which
+					// error to report. Multiple sums may be missing if we need to look in
+					// multiple nested modules to resolve the import; we'll report them all.
+					sumErrMods = append(sumErrMods, m)
+					continue
+				}
+				// Report fetch error.
+				// Note that we don't know for sure this module is necessary,
+				// but it certainly _could_ provide the package, and even if we
+				// continue the loop and find the package in some other module,
+				// we need to look at this module to make sure the import is
+				// not ambiguous.
+				return module.Version{}, "", err
+			}
+			if dir, ok, err := dirInModule(path, m.Path, root, isLocal); err != nil {
+				return module.Version{}, "", err
+			} else if ok {
+				mods = append(mods, m)
+				dirs = append(dirs, dir)
+			}
 		}
-		m := module.Version{Path: prefix, Version: v}
 
-		needSum := true
-		root, isLocal, err := fetch(ctx, m, needSum)
-		if err != nil {
-			if sumErr := (*sumMissingError)(nil); errors.As(err, &sumErr) {
-				// We are missing a sum needed to fetch a module in the build list.
-				// We can't verify that the package is unique, and we may not find
-				// the package at all. Keep checking other modules to decide which
-				// error to report. Multiple sums may be missing if we need to look in
-				// multiple nested modules to resolve the import; we'll report them all.
-				sumErrMods = append(sumErrMods, m)
-				continue
+		if len(mods) > 1 {
+			// We produce the list of directories from longest to shortest candidate
+			// module path, but the AmbiguousImportError should report them from
+			// shortest to longest. Reverse them now.
+			for i := 0; i < len(mods)/2; i++ {
+				j := len(mods) - 1 - i
+				mods[i], mods[j] = mods[j], mods[i]
+				dirs[i], dirs[j] = dirs[j], dirs[i]
 			}
-			// Report fetch error.
-			// Note that we don't know for sure this module is necessary,
-			// but it certainly _could_ provide the package, and even if we
-			// continue the loop and find the package in some other module,
-			// we need to look at this module to make sure the import is
-			// not ambiguous.
-			return module.Version{}, "", err
+			return module.Version{}, "", &AmbiguousImportError{importPath: path, Dirs: dirs, Modules: mods}
 		}
-		if dir, ok, err := dirInModule(path, m.Path, root, isLocal); err != nil {
-			return module.Version{}, "", err
-		} else if ok {
-			mods = append(mods, m)
-			dirs = append(dirs, dir)
-		}
-	}
 
-	if len(mods) > 1 {
-		// We produce the list of directories from longest to shortest candidate
-		// module path, but the AmbiguousImportError should report them from
-		// shortest to longest. Reverse them now.
-		for i := 0; i < len(mods)/2; i++ {
-			j := len(mods) - 1 - i
-			mods[i], mods[j] = mods[j], mods[i]
-			dirs[i], dirs[j] = dirs[j], dirs[i]
+		if len(sumErrMods) > 0 {
+			for i := 0; i < len(sumErrMods)/2; i++ {
+				j := len(sumErrMods) - 1 - i
+				sumErrMods[i], sumErrMods[j] = sumErrMods[j], sumErrMods[i]
+			}
+			return module.Version{}, "", &ImportMissingSumError{
+				importPath: path,
+				mods:       sumErrMods,
+				found:      len(mods) > 0,
+			}
 		}
-		return module.Version{}, "", &AmbiguousImportError{importPath: path, Dirs: dirs, Modules: mods}
-	}
 
-	if len(sumErrMods) > 0 {
-		for i := 0; i < len(sumErrMods)/2; i++ {
-			j := len(sumErrMods) - 1 - i
-			sumErrMods[i], sumErrMods[j] = sumErrMods[j], sumErrMods[i]
+		if len(mods) == 1 {
+			return mods[0], dirs[0], nil
 		}
-		return module.Version{}, "", &ImportMissingSumError{
-			importPath: path,
-			mods:       sumErrMods,
-			found:      len(mods) > 0,
-		}
-	}
 
-	if len(mods) == 1 {
-		return mods[0], dirs[0], nil
-	}
+		if mg != nil {
+			// We checked the full module graph and still didn't find the
+			// requested package.
+			var queryErr error
+			if !HasModRoot() {
+				queryErr = ErrNoModRoot
+			}
+			return module.Version{}, "", &ImportMissingError{Path: path, QueryErr: queryErr, isStd: pathIsStd}
+		}
 
-	// We checked the full module graph and still didn't find the
-	// requested package.
-	var queryErr error
-	if !HasModRoot() {
-		queryErr = ErrNoModRoot
+		// So far we've checked the root dependencies.
+		// Load the full module graph and try again.
+		mg, err = rs.Graph(ctx)
+		if err != nil {
+			// We might be missing one or more transitive (implicit) dependencies from
+			// the module graph, so we can't return an ImportMissingError here — one
+			// of the missing modules might actually contain the package in question,
+			// in which case we shouldn't go looking for it in some new dependency.
+			return module.Version{}, "", err
+		}
 	}
-	return module.Version{}, "", &ImportMissingError{Path: path, QueryErr: queryErr, isStd: pathIsStd}
 }
 
 // queryImport attempts to locate a module that can be added to the current
diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index cb206a3dea..f46c58f474 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -1125,6 +1125,22 @@ func keepSums(ctx context.Context, ld *loader, rs *Requirements, which whichSums
 				continue
 			}
 
+			if rs.depth == lazy && pkg.mod.Path != "" {
+				if v, ok := rs.rootSelected(pkg.mod.Path); ok && v == pkg.mod.Version {
+					// pkg was loaded from a root module, and because the main module is
+					// lazy we do not check non-root modules for conflicts for packages
+					// that can be found in roots. So we only need the checksums for the
+					// root modules that may contain pkg, not all possible modules.
+					for prefix := pkg.path; prefix != "."; prefix = path.Dir(prefix) {
+						if v, ok := rs.rootSelected(prefix); ok && v != "none" {
+							m := module.Version{Path: prefix, Version: v}
+							keep[resolveReplacement(m)] = true
+						}
+					}
+					continue
+				}
+			}
+
 			for prefix := pkg.path; prefix != "."; prefix = path.Dir(prefix) {
 				if v := mg.Selected(prefix); v != "none" {
 					m := module.Version{Path: prefix, Version: v}
diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index b822e74eb5..ddacf49ead 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -1236,7 +1236,7 @@ func (ld *loader) updateRequirements(ctx context.Context) (changed bool, err err
 				//
 				// In some sense, we can think of this as ‘upgraded the module providing
 				// pkg.path from "none" to a version higher than "none"’.
-				if _, _, err = importFromModules(ctx, pkg.path, rs); err == nil {
+				if _, _, err = importFromModules(ctx, pkg.path, rs, nil); err == nil {
 					changed = true
 					break
 				}
@@ -1429,7 +1429,7 @@ func (ld *loader) preloadRootModules(ctx context.Context, rootPkgs []string) (ch
 			// If the main module is tidy and the package is in "all" — or if we're
 			// lucky — we can identify all of its imports without actually loading the
 			// full module graph.
-			m, _, err := importFromModules(ctx, path, ld.requirements)
+			m, _, err := importFromModules(ctx, path, ld.requirements, nil)
 			if err != nil {
 				var missing *ImportMissingError
 				if errors.As(err, &missing) && ld.ResolveMissingImports {
@@ -1516,7 +1516,24 @@ func (ld *loader) load(ctx context.Context, pkg *loadPkg) {
 		return
 	}
 
-	pkg.mod, pkg.dir, pkg.err = importFromModules(ctx, pkg.path, ld.requirements)
+	var mg *ModuleGraph
+	if ld.requirements.depth == eager {
+		var err error
+		mg, err = ld.requirements.Graph(ctx)
+		if err != nil {
+			// We already checked the error from Graph in loadFromRoots and/or
+			// updateRequirements, so we ignored the error on purpose and we should
+			// keep trying to push past it.
+			//
+			// However, because mg may be incomplete (and thus may select inaccurate
+			// versions), we shouldn't use it to load packages. Instead, we pass a nil
+			// *ModuleGraph, which will cause mg to first try loading from only the
+			// main module and root dependencies.
+			mg = nil
+		}
+	}
+
+	pkg.mod, pkg.dir, pkg.err = importFromModules(ctx, pkg.path, ld.requirements, mg)
 	if pkg.dir == "" {
 		return
 	}
diff --git a/src/cmd/go/testdata/script/mod_install_pkg_version.txt b/src/cmd/go/testdata/script/mod_install_pkg_version.txt
index b024fce174..2c14ef737b 100644
--- a/src/cmd/go/testdata/script/mod_install_pkg_version.txt
+++ b/src/cmd/go/testdata/script/mod_install_pkg_version.txt
@@ -67,9 +67,9 @@ cd tmp
 go mod init tmp
 go mod edit -require=rsc.io/fortune@v1.0.0
 ! go install -mod=readonly $GOPATH/pkg/mod/rsc.io/fortune@v1.0.0
-stderr '^rsc.io/fortune@v1.0.0: missing go.sum entry; to add it:\n\tgo mod download rsc.io/fortune$'
+stderr '^missing go\.sum entry for module providing package rsc\.io/fortune; to add:\n\tgo mod download rsc\.io/fortune$'
 ! go install -mod=readonly ../../pkg/mod/rsc.io/fortune@v1.0.0
-stderr '^rsc.io/fortune@v1.0.0: missing go.sum entry; to add it:\n\tgo mod download rsc.io/fortune$'
+stderr '^missing go\.sum entry for module providing package rsc\.io/fortune; to add:\n\tgo mod download rsc\.io/fortune$'
 go get -d rsc.io/fortune@v1.0.0
 go install -mod=readonly $GOPATH/pkg/mod/rsc.io/fortune@v1.0.0
 exists $GOPATH/bin/fortune$GOEXE
diff --git a/src/cmd/go/testdata/script/mod_run_pkg_version.txt b/src/cmd/go/testdata/script/mod_run_pkg_version.txt
index 3c3ed27e91..e921fab508 100644
--- a/src/cmd/go/testdata/script/mod_run_pkg_version.txt
+++ b/src/cmd/go/testdata/script/mod_run_pkg_version.txt
@@ -64,9 +64,9 @@ cd tmp
 go mod init tmp
 go mod edit -require=rsc.io/fortune@v1.0.0
 ! go run -mod=readonly $GOPATH/pkg/mod/rsc.io/fortune@v1.0.0
-stderr '^rsc.io/fortune@v1.0.0: missing go.sum entry; to add it:\n\tgo mod download rsc.io/fortune$'
+stderr '^missing go\.sum entry for module providing package rsc\.io/fortune; to add:\n\tgo mod download rsc\.io/fortune$'
 ! go run -mod=readonly ../../pkg/mod/rsc.io/fortune@v1.0.0
-stderr '^rsc.io/fortune@v1.0.0: missing go.sum entry; to add it:\n\tgo mod download rsc.io/fortune$'
+stderr '^missing go\.sum entry for module providing package rsc\.io/fortune; to add:\n\tgo mod download rsc\.io/fortune$'
 cd ..
 rm tmp
 
-- 
GitLab


From ee4f9656ac419bb92408f65f082c735a6b82d1fa Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 9 Apr 2021 22:00:14 -0400
Subject: [PATCH 1885/2400] cmd/go/internal/modload: avoid loading the full
 module graph to determine which checksums to add to go.sum

For #36460

Change-Id: I606314054bd9064f7c4053f56049fabbaec54143
Reviewed-on: https://go-review.googlesource.com/c/go/+/309189
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modload/init.go | 58 ++++++++++++++++++-----------
 1 file changed, 36 insertions(+), 22 deletions(-)

diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index f46c58f474..ef21908064 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -1094,34 +1094,16 @@ func keepSums(ctx context.Context, ld *loader, rs *Requirements, which whichSums
 	// that version is selected).
 	keep := make(map[module.Version]bool)
 
-	if go117LazyTODO {
-		// If the main module is lazy, avoid loading the module graph if it hasn't
-		// already been loaded.
-	}
-
-	mg, _ := rs.Graph(ctx)
-	mg.WalkBreadthFirst(func(m module.Version) {
-		if _, ok := mg.RequiredBy(m); ok {
-			// The requirements from m's go.mod file are present in the module graph,
-			// so they are relevant to the MVS result regardless of whether m was
-			// actually selected.
-			keep[modkey(resolveReplacement(m))] = true
-		}
-	})
-
-	if which == addBuildListZipSums {
-		for _, m := range mg.BuildList() {
-			keep[resolveReplacement(m)] = true
-		}
-	}
-
 	// Add entries for modules in the build list with paths that are prefixes of
 	// paths of loaded packages. We need to retain sums for all of these modules —
 	// not just the modules containing the actual packages — in order to rule out
 	// ambiguous import errors the next time we load the package.
 	if ld != nil {
 		for _, pkg := range ld.pkgs {
-			if pkg.testOf != nil || pkg.inStd || module.CheckImportPath(pkg.path) != nil {
+			// We check pkg.mod.Path here instead of pkg.inStd because the
+			// pseudo-package "C" is not in std, but not provided by any module (and
+			// shouldn't force loading the whole module graph).
+			if pkg.testOf != nil || (pkg.mod.Path == "" && pkg.err == nil) || module.CheckImportPath(pkg.path) != nil {
 				continue
 			}
 
@@ -1141,6 +1123,7 @@ func keepSums(ctx context.Context, ld *loader, rs *Requirements, which whichSums
 				}
 			}
 
+			mg, _ := rs.Graph(ctx)
 			for prefix := pkg.path; prefix != "."; prefix = path.Dir(prefix) {
 				if v := mg.Selected(prefix); v != "none" {
 					m := module.Version{Path: prefix, Version: v}
@@ -1150,6 +1133,37 @@ func keepSums(ctx context.Context, ld *loader, rs *Requirements, which whichSums
 		}
 	}
 
+	if rs.depth == lazy && rs.graph.Load() == nil {
+		// The main module is lazy and we haven't needed to load the module graph so
+		// far. Don't incur the cost of loading it now — since we haven't loaded the
+		// graph, we probably don't have any checksums to contribute to the distant
+		// parts of the graph anyway. Instead, just request sums for the roots that
+		// we know about.
+		for _, m := range rs.rootModules {
+			r := resolveReplacement(m)
+			keep[modkey(r)] = true
+			if which == addBuildListZipSums {
+				keep[r] = true
+			}
+		}
+	} else {
+		mg, _ := rs.Graph(ctx)
+		mg.WalkBreadthFirst(func(m module.Version) {
+			if _, ok := mg.RequiredBy(m); ok {
+				// The requirements from m's go.mod file are present in the module graph,
+				// so they are relevant to the MVS result regardless of whether m was
+				// actually selected.
+				keep[modkey(resolveReplacement(m))] = true
+			}
+		})
+
+		if which == addBuildListZipSums {
+			for _, m := range mg.BuildList() {
+				keep[resolveReplacement(m)] = true
+			}
+		}
+	}
+
 	return keep
 }
 
-- 
GitLab


From c05d50f8f3b2f8a9ca66a6288168adf74d10586f Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 9 Apr 2021 22:51:07 -0400
Subject: [PATCH 1886/2400] cmd/go/internal/modload: avoid loading the module
 graph to list only the name of the main module

For #36460
For #29666

Change-Id: I9e46f7054d52c053be80c483757cdd34b22822d9
Reviewed-on: https://go-review.googlesource.com/c/go/+/309190
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modload/list.go              | 12 ++++--------
 src/cmd/go/testdata/script/mod_load_badchain.txt |  2 +-
 2 files changed, 5 insertions(+), 9 deletions(-)

diff --git a/src/cmd/go/internal/modload/list.go b/src/cmd/go/internal/modload/list.go
index e33078b53c..66927a8288 100644
--- a/src/cmd/go/internal/modload/list.go
+++ b/src/cmd/go/internal/modload/list.go
@@ -78,6 +78,10 @@ func ListModules(ctx context.Context, args []string, mode ListMode) ([]*modinfo.
 }
 
 func listModules(ctx context.Context, rs *Requirements, args []string, mode ListMode) (_ *Requirements, mods []*modinfo.ModulePublic, mgErr error) {
+	if len(args) == 0 {
+		return rs, []*modinfo.ModulePublic{moduleInfo(ctx, rs, Target, mode)}, nil
+	}
+
 	var mg *ModuleGraph
 	if go117LazyTODO {
 		// Pull the args-loop below into another (new) loop.
@@ -90,10 +94,6 @@ func listModules(ctx context.Context, rs *Requirements, args []string, mode List
 		rs, mg, mgErr = expandGraph(ctx, rs)
 	}
 
-	if len(args) == 0 {
-		return rs, []*modinfo.ModulePublic{moduleInfo(ctx, rs, Target, mode)}, mgErr
-	}
-
 	matchedModule := map[module.Version]bool{}
 	for _, arg := range args {
 		if strings.Contains(arg, `\`) {
@@ -149,10 +149,6 @@ func listModules(ctx context.Context, rs *Requirements, args []string, mode List
 			continue
 		}
 
-		if go117LazyTODO {
-			ModRoot() // Unversioned paths require that we be inside a module.
-		}
-
 		// Module path or pattern.
 		var match func(string) bool
 		if arg == "all" {
diff --git a/src/cmd/go/testdata/script/mod_load_badchain.txt b/src/cmd/go/testdata/script/mod_load_badchain.txt
index 8cb7eec0aa..eb464ab0d3 100644
--- a/src/cmd/go/testdata/script/mod_load_badchain.txt
+++ b/src/cmd/go/testdata/script/mod_load_badchain.txt
@@ -22,7 +22,7 @@ cmp go.mod go.mod.orig
 
 # Update manually. Listing modules should produce an error.
 go mod edit -require=example.com/badchain/a@v1.1.0
-! go list -m
+! go list -m all
 cmp stderr list-expected
 
 # Try listing a package that imports a package
-- 
GitLab


From 0e315ad79ae388eedb03dce27101c40b29292e2a Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 9 Apr 2021 23:40:22 -0400
Subject: [PATCH 1887/2400] cmd/go/internal/modload: avoid loading the full
 module graph when listing specific modules

For #36460
For #41297
Updates #29666

Change-Id: I5f324c0ef9a164f8043d2188101d141bb5fa7454
Reviewed-on: https://go-review.googlesource.com/c/go/+/309191
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modload/list.go          | 67 ++++++++++++++------
 src/cmd/go/testdata/script/mod_list_sums.txt | 19 +++---
 2 files changed, 57 insertions(+), 29 deletions(-)

diff --git a/src/cmd/go/internal/modload/list.go b/src/cmd/go/internal/modload/list.go
index 66927a8288..344b2aa2c7 100644
--- a/src/cmd/go/internal/modload/list.go
+++ b/src/cmd/go/internal/modload/list.go
@@ -82,19 +82,7 @@ func listModules(ctx context.Context, rs *Requirements, args []string, mode List
 		return rs, []*modinfo.ModulePublic{moduleInfo(ctx, rs, Target, mode)}, nil
 	}
 
-	var mg *ModuleGraph
-	if go117LazyTODO {
-		// Pull the args-loop below into another (new) loop.
-		// If the main module is lazy, try it once with mg == nil, and then load mg
-		// and try again.
-	} else {
-		// TODO(#41297): Don't bother loading or expanding the graph if all
-		// arguments are explicit version queries (including if no arguments are
-		// present at all).
-		rs, mg, mgErr = expandGraph(ctx, rs)
-	}
-
-	matchedModule := map[module.Version]bool{}
+	needFullGraph := false
 	for _, arg := range args {
 		if strings.Contains(arg, `\`) {
 			base.Fatalf("go: module paths never use backslash")
@@ -102,19 +90,51 @@ func listModules(ctx context.Context, rs *Requirements, args []string, mode List
 		if search.IsRelativePath(arg) {
 			base.Fatalf("go: cannot use relative path %s to specify module", arg)
 		}
-		if !HasModRoot() {
-			if arg == "all" || strings.Contains(arg, "...") {
+		if arg == "all" || strings.Contains(arg, "...") {
+			needFullGraph = true
+			if !HasModRoot() {
 				base.Fatalf("go: cannot match %q: %v", arg, ErrNoModRoot)
 			}
-			if mode&ListVersions == 0 && !strings.Contains(arg, "@") {
+			continue
+		}
+		if i := strings.Index(arg, "@"); i >= 0 {
+			path := arg[:i]
+			vers := arg[i+1:]
+			if vers == "upgrade" || vers == "patch" {
+				if _, ok := rs.rootSelected(path); !ok || rs.depth == eager {
+					needFullGraph = true
+					if !HasModRoot() {
+						base.Fatalf("go: cannot match %q: %v", arg, ErrNoModRoot)
+					}
+				}
+			}
+			continue
+		}
+		if _, ok := rs.rootSelected(arg); !ok || rs.depth == eager {
+			needFullGraph = true
+			if mode&ListVersions == 0 && !HasModRoot() {
 				base.Fatalf("go: cannot match %q without -versions or an explicit version: %v", arg, ErrNoModRoot)
 			}
 		}
+	}
+
+	var mg *ModuleGraph
+	if needFullGraph {
+		rs, mg, mgErr = expandGraph(ctx, rs)
+	}
+
+	matchedModule := map[module.Version]bool{}
+	for _, arg := range args {
 		if i := strings.Index(arg, "@"); i >= 0 {
 			path := arg[:i]
 			vers := arg[i+1:]
 
-			current := mg.Selected(path)
+			var current string
+			if mg == nil {
+				current, _ = rs.rootSelected(path)
+			} else {
+				current = mg.Selected(path)
+			}
 			if current == "none" && mgErr != nil {
 				if vers == "upgrade" || vers == "patch" {
 					// The module graph is incomplete, so we don't know what version we're
@@ -156,7 +176,18 @@ func listModules(ctx context.Context, rs *Requirements, args []string, mode List
 		} else if strings.Contains(arg, "...") {
 			match = search.MatchPattern(arg)
 		} else {
-			v := mg.Selected(arg)
+			var v string
+			if mg == nil {
+				var ok bool
+				v, ok = rs.rootSelected(arg)
+				if !ok {
+					// We checked rootSelected(arg) in the earlier args loop, so if there
+					// is no such root we should have loaded a non-nil mg.
+					panic(fmt.Sprintf("internal error: root requirement expected but not found for %v", arg))
+				}
+			} else {
+				v = mg.Selected(arg)
+			}
 			if v == "none" && mgErr != nil {
 				// mgErr is already set, so just skip this module.
 				continue
diff --git a/src/cmd/go/testdata/script/mod_list_sums.txt b/src/cmd/go/testdata/script/mod_list_sums.txt
index e5f80d7fb6..86c528f829 100644
--- a/src/cmd/go/testdata/script/mod_list_sums.txt
+++ b/src/cmd/go/testdata/script/mod_list_sums.txt
@@ -4,16 +4,13 @@
 go mod init m
 go mod edit -require=rsc.io/quote@v1.5.1
 
-# 'go list' currently loads the whole build list, even when listing only
-# non-dependencies.
-#
-# TODO(#41297): Thes should not be errors.
+go list -m -mod=readonly rsc.io/quote@latest
+stdout '^rsc\.io/quote v1\.5\.2$'
+! stderr .
 
-! go list -m -mod=readonly rsc.io/quote@latest
-stderr '^go list -m: rsc\.io/quote@v1\.5\.1: missing go\.sum entry; to add it:\n\tgo mod download rsc\.io/quote$'
-
-! go list -m -mod=readonly -versions rsc.io/quote
-stderr '^go list -m: rsc\.io/quote@v1\.5\.1: missing go\.sum entry; to add it:\n\tgo mod download rsc\.io/quote$'
+go list -m -mod=readonly -versions rsc.io/quote
+stdout 'rsc\.io/quote v1\.0\.0 .* v1\.5\.3-pre1$'
+! stderr .
 
 # Incidentally fetching the required version of a module records its checksum,
 # just because it happens to be in the build list, and recording the checksum
@@ -21,8 +18,8 @@ stderr '^go list -m: rsc\.io/quote@v1\.5\.1: missing go\.sum entry; to add it:\n
 #
 # TODO(#41297): This should not be an error.
 ! go list -m -mod=readonly rsc.io/quote@<v1.5.2
-stderr '^go list -m: rsc\.io/quote@v1\.5\.1: missing go\.sum entry; to add it:\n\tgo mod download rsc\.io/quote$'
-! stderr '^go: updates to go.sum needed, disabled by -mod=readonly$'
+stderr '^go: updates to go.sum needed, disabled by -mod=readonly$'
+! stderr 'missing go.sum entry'
 
 # Attempting to list the versions of a module that is not a root dependency
 # causes the build list to be resolved (so that the selected version can *also*
-- 
GitLab


From 7dedc237c528fa268934a8ed81c01fc65db5f800 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Thu, 29 Apr 2021 09:27:40 -0400
Subject: [PATCH 1888/2400] cmd/go: smooth out upgrade paths for lazy loading
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This change adds two possible upgrade paths for lazy loading:

1. Run 'go mod tidy -go=1.17'.

2. Starting in a module with no existing 'go' directive,
   run any 'go' command that updates the go.mod file.

In the latter case, commands other than 'go mod tidy'
may leave the go.mod file *very* untidy if it had non-trivial
dependencies. (The 'go' invocation will promote all
implicit eager dependencies to explicit lazy ones,
which preserves the original module graph — most of which is
not actually relevant.)

'go mod tidy -go=1.17' can be used to enable lazy loading without
accidentally downgrading existing transitive dependencies.

'go mod tidy -go=1.16' can be used to disable lazy loading and clear
away redundant roots in a single step (if reducing the go version), or
to prune away dependencies of tests-of-external-tests (if increasing
the go version).

'go mod tidy -go=1.15' can be used to add dependencies of
tests-of-external-tests, although there isn't much point to that.

DO NOT MERGE

This change still needs an explicit test and a release note.

Fixes #45094
For #36460

Change-Id: I68f057e39489dfd6a667cd11dc1e320c1ee1aec1
Reviewed-on: https://go-review.googlesource.com/c/go/+/315210
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 doc/go1.17.html                               |  11 +
 src/cmd/go/alldocs.go                         |   8 +-
 src/cmd/go/internal/modcmd/tidy.go            |  23 +-
 src/cmd/go/internal/modload/build.go          |   4 +-
 src/cmd/go/internal/modload/buildlist.go      |  44 +++-
 src/cmd/go/internal/modload/edit.go           |   4 +-
 src/cmd/go/internal/modload/init.go           |  65 ++---
 src/cmd/go/internal/modload/list.go           |   2 +-
 src/cmd/go/internal/modload/load.go           |  52 +++-
 src/cmd/go/internal/modload/modfile.go        |  81 +++---
 .../script/mod_go_version_missing.txt         |  36 ++-
 .../script/mod_load_replace_mismatch.txt      |   2 +-
 src/cmd/go/testdata/script/mod_retention.txt  |   4 +-
 .../go/testdata/script/mod_tidy_version.txt   | 248 ++++++++++++++++++
 14 files changed, 479 insertions(+), 105 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/mod_tidy_version.txt

diff --git a/doc/go1.17.html b/doc/go1.17.html
index be3b4e6d71..eab4e1eeeb 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -58,6 +58,17 @@ Do not send CLs removing the interior tags from such phrases.
   <!-- TODO(bcmills): replace the design-doc link with proper documentation. -->
 </p>
 
+<p><!-- golang.org/issue/45094 --> To facilitate the upgrade to lazy loading,
+  the <code>go</code> <code>mod</code> <code>tidy</code> subcommand now supports
+  a <code>-go</code> flag to set or change the <code>go</code> version in
+  the <code>go.mod</code> file. To enable lazy loading for an existing module
+  without changing the selected versions of its dependencies, run:
+</p>
+
+<pre>
+  go mod tidy -go=1.17
+</pre>
+
 <h4 id="module-deprecation-comments">Module deprecation comments</h4>
 
 <p><!-- golang.org/issue/40357 -->
diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index 0a12eaf4e9..052b61c03d 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -1221,7 +1221,7 @@
 //
 // Usage:
 //
-// 	go mod tidy [-e] [-v]
+// 	go mod tidy [-e] [-v] [-go=version]
 //
 // Tidy makes sure go.mod matches the source code in the module.
 // It adds any missing modules necessary to build the current module's
@@ -1235,6 +1235,12 @@
 // The -e flag causes tidy to attempt to proceed despite errors
 // encountered while loading packages.
 //
+// The -go flag causes tidy to update the 'go' directive in the go.mod
+// file to the given version, which may change which module dependencies
+// are retained as explicit requirements in the go.mod file.
+// (Go versions 1.17 and higher retain more requirements in order to
+// support lazy module loading.)
+//
 // See https://golang.org/ref/mod#go-mod-tidy for more about 'go mod tidy'.
 //
 //
diff --git a/src/cmd/go/internal/modcmd/tidy.go b/src/cmd/go/internal/modcmd/tidy.go
index a9b277817f..c72ec30a57 100644
--- a/src/cmd/go/internal/modcmd/tidy.go
+++ b/src/cmd/go/internal/modcmd/tidy.go
@@ -12,10 +12,12 @@ import (
 	"cmd/go/internal/imports"
 	"cmd/go/internal/modload"
 	"context"
+
+	"golang.org/x/mod/modfile"
 )
 
 var cmdTidy = &base.Command{
-	UsageLine: "go mod tidy [-e] [-v]",
+	UsageLine: "go mod tidy [-e] [-v] [-go=version]",
 	Short:     "add missing and remove unused modules",
 	Long: `
 Tidy makes sure go.mod matches the source code in the module.
@@ -30,16 +32,26 @@ to standard error.
 The -e flag causes tidy to attempt to proceed despite errors
 encountered while loading packages.
 
+The -go flag causes tidy to update the 'go' directive in the go.mod
+file to the given version, which may change which module dependencies
+are retained as explicit requirements in the go.mod file.
+(Go versions 1.17 and higher retain more requirements in order to
+support lazy module loading.)
+
 See https://golang.org/ref/mod#go-mod-tidy for more about 'go mod tidy'.
 	`,
 	Run: runTidy,
 }
 
-var tidyE bool // if true, report errors but proceed anyway.
+var (
+	tidyE  bool   // if true, report errors but proceed anyway.
+	tidyGo string // go version to write to the tidied go.mod file (toggles lazy loading)
+)
 
 func init() {
 	cmdTidy.Flag.BoolVar(&cfg.BuildV, "v", false, "")
 	cmdTidy.Flag.BoolVar(&tidyE, "e", false, "")
+	cmdTidy.Flag.StringVar(&tidyGo, "go", "", "")
 	base.AddModCommonFlags(&cmdTidy.Flag)
 }
 
@@ -48,6 +60,12 @@ func runTidy(ctx context.Context, cmd *base.Command, args []string) {
 		base.Fatalf("go mod tidy: no arguments allowed")
 	}
 
+	if tidyGo != "" {
+		if !modfile.GoVersionRE.MatchString(tidyGo) {
+			base.Fatalf(`go mod: invalid -go option %q; expecting something like "-go 1.17"`, tidyGo)
+		}
+	}
+
 	// Tidy aims to make 'go test' reproducible for any package in 'all', so we
 	// need to include test dependencies. For modules that specify go 1.15 or
 	// earlier this is a no-op (because 'all' saturates transitive test
@@ -62,6 +80,7 @@ func runTidy(ctx context.Context, cmd *base.Command, args []string) {
 	modload.RootMode = modload.NeedRoot
 
 	modload.LoadPackages(ctx, modload.PackageOpts{
+		GoVersion:                tidyGo,
 		Tags:                     imports.AnyTags(),
 		Tidy:                     true,
 		VendorModulesInGOROOTSrc: true,
diff --git a/src/cmd/go/internal/modload/build.go b/src/cmd/go/internal/modload/build.go
index 53771b2231..76e1ad589f 100644
--- a/src/cmd/go/internal/modload/build.go
+++ b/src/cmd/go/internal/modload/build.go
@@ -259,8 +259,8 @@ func moduleInfo(ctx context.Context, rs *Requirements, m module.Version, mode Li
 		if m.GoVersion == "" && checksumOk("/go.mod") {
 			// Load the go.mod file to determine the Go version, since it hasn't
 			// already been populated from rawGoVersion.
-			if summary, err := rawGoModSummary(mod); err == nil && summary.goVersionV != "" {
-				m.GoVersion = summary.goVersionV[1:]
+			if summary, err := rawGoModSummary(mod); err == nil && summary.goVersion != "" {
+				m.GoVersion = summary.goVersion
 			}
 		}
 
diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index 4b83ede541..e7af892996 100644
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -299,7 +299,7 @@ func readModGraph(ctx context.Context, depth modDepth, roots []module.Version) (
 			// sufficient to build the packages it contains. We must load its full
 			// transitive dependency graph to be sure that we see all relevant
 			// dependencies.
-			if depth == eager || summary.depth() == eager {
+			if depth == eager || summary.depth == eager {
 				for _, r := range summary.require {
 					enqueue(r, eager)
 				}
@@ -393,7 +393,7 @@ func LoadModGraph(ctx context.Context) *ModuleGraph {
 		base.Fatalf("go: %v", err)
 	}
 
-	commitRequirements(ctx, rs)
+	commitRequirements(ctx, modFileGoVersion(), rs)
 	return mg
 }
 
@@ -459,7 +459,7 @@ func EditBuildList(ctx context.Context, add, mustSelect []module.Version) (chang
 	if err != nil {
 		return false, err
 	}
-	commitRequirements(ctx, rs)
+	commitRequirements(ctx, modFileGoVersion(), rs)
 	return changed, err
 }
 
@@ -943,10 +943,40 @@ func updateEagerRoots(ctx context.Context, direct map[string]bool, rs *Requireme
 	if err != nil {
 		return rs, err
 	}
-	if reflect.DeepEqual(min, rs.rootModules) && reflect.DeepEqual(direct, rs.direct) {
-		// The root set is unchanged, so keep rs to preserve its cached ModuleGraph
-		// (if any).
+	if rs.depth == eager && reflect.DeepEqual(min, rs.rootModules) && reflect.DeepEqual(direct, rs.direct) {
+		// The root set is unchanged and rs was already eager, so keep rs to
+		// preserve its cached ModuleGraph (if any).
 		return rs, nil
 	}
-	return newRequirements(rs.depth, min, direct), nil
+	return newRequirements(eager, min, direct), nil
+}
+
+// convertDepth returns a version of rs with the given depth.
+// If rs already has the given depth, convertDepth returns rs unmodified.
+func convertDepth(ctx context.Context, rs *Requirements, depth modDepth) (*Requirements, error) {
+	if rs.depth == depth {
+		return rs, nil
+	}
+
+	if depth == eager {
+		// We are converting a lazy module to an eager one. The roots of an eager
+		// module graph are a superset of the roots of a lazy graph, so we don't
+		// need to add any new roots — we just need to prune away the ones that are
+		// redundant given eager loading, which is exactly what updateEagerRoots
+		// does.
+		return updateEagerRoots(ctx, rs.direct, rs, nil)
+	}
+
+	// We are converting an eager module to a lazy one. The module graph of an
+	// eager module includes the transitive dependencies of every module in the
+	// build list.
+	//
+	// Hey, we can express that as a lazy root set! “Include the transitive
+	// dependencies of every module in the build list” is exactly what happens in
+	// a lazy module if we promote every module in the build list to a root!
+	mg, err := rs.Graph(ctx)
+	if err != nil {
+		return rs, err
+	}
+	return newRequirements(lazy, mg.BuildList()[1:], rs.direct), nil
 }
diff --git a/src/cmd/go/internal/modload/edit.go b/src/cmd/go/internal/modload/edit.go
index 2921b38157..c350b9d1b5 100644
--- a/src/cmd/go/internal/modload/edit.go
+++ b/src/cmd/go/internal/modload/edit.go
@@ -229,7 +229,7 @@ func raiseLimitsForUpgrades(ctx context.Context, maxVersion map[string]string, d
 			if err != nil {
 				return err
 			}
-			if summary.depth() == eager {
+			if summary.depth == eager {
 				// For efficiency, we'll load all of the eager upgrades as one big
 				// graph, rather than loading the (potentially-overlapping) subgraph for
 				// each upgrade individually.
@@ -522,7 +522,7 @@ func (l *versionLimiter) check(m module.Version, depth modDepth) dqState {
 		return l.disqualify(m, dqState{err: err})
 	}
 
-	if summary.depth() == eager {
+	if summary.depth == eager {
 		depth = eager
 	}
 	for _, r := range summary.require {
diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index ef21908064..88d647d9ea 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -381,7 +381,7 @@ var errGoModDirty error = goModDirtyError{}
 func LoadModFile(ctx context.Context) *Requirements {
 	rs, needCommit := loadModFile(ctx)
 	if needCommit {
-		commitRequirements(ctx, rs)
+		commitRequirements(ctx, modFileGoVersion(), rs)
 	}
 	return rs
 }
@@ -401,8 +401,9 @@ func loadModFile(ctx context.Context) (rs *Requirements, needCommit bool) {
 	if modRoot == "" {
 		Target = module.Version{Path: "command-line-arguments"}
 		targetPrefix = "command-line-arguments"
-		rawGoVersion.Store(Target, latestGoVersion())
-		requirements = newRequirements(index.depth(), nil, nil)
+		goVersion := latestGoVersion()
+		rawGoVersion.Store(Target, goVersion)
+		requirements = newRequirements(modDepthFromGoVersion(goVersion), nil, nil)
 		return requirements, false
 	}
 
@@ -432,7 +433,7 @@ func loadModFile(ctx context.Context) (rs *Requirements, needCommit bool) {
 	}
 
 	setDefaultBuildMod() // possibly enable automatic vendoring
-	rs = requirementsFromModFile(ctx, f)
+	rs = requirementsFromModFile(ctx)
 
 	if cfg.BuildMod == "vendor" {
 		readVendorList()
@@ -440,27 +441,23 @@ func loadModFile(ctx context.Context) (rs *Requirements, needCommit bool) {
 		rs.initVendor(vendorList)
 	}
 	if index.goVersionV == "" {
-		// The main module necessarily has a go.mod file, and that file lacks a
-		// 'go' directive. The 'go' command has been adding that directive
-		// automatically since Go 1.12, so this module either dates to Go 1.11 or
-		// has been erroneously hand-edited.
-		//
-		// The semantics of the go.mod file are more-or-less the same from Go 1.11
-		// through Go 1.16, changing at 1.17 for lazy loading. So even though a
-		// go.mod file without a 'go' directive is theoretically a Go 1.11 file,
-		// scripts may assume that it ends up as a Go 1.16 module. We can't go
-		// higher than that, because we don't know which semantics the user intends.
-		//
-		// (Note that 'go mod init' always adds the latest version, so scripts that
-		// use 'go mod init' will result in current-version modules instead of Go
-		// 1.16 modules.)
-		//
-		// If we are able to modify the go.mod file, we will add a 'go' directive
-		// to at least make the situation explicit going forward.
-		if cfg.BuildMod == "mod" {
-			addGoStmt("1.16")
+		// TODO(#45551): Do something more principled instead of checking
+		// cfg.CmdName directly here.
+		if cfg.BuildMod == "mod" && cfg.CmdName != "mod graph" && cfg.CmdName != "mod why" {
+			addGoStmt(latestGoVersion())
+			if go117EnableLazyLoading {
+				// We need to add a 'go' version to the go.mod file, but we must assume
+				// that its existing contents match something between Go 1.11 and 1.16.
+				// Go 1.11 through 1.16 have eager requirements, but the latest Go
+				// version uses lazy requirements instead — so we need to cnvert the
+				// requirements to be lazy.
+				rs, err = convertDepth(ctx, rs, lazy)
+				if err != nil {
+					base.Fatalf("go: %v", err)
+				}
+			}
 		} else {
-			rawGoVersion.Store(Target, "1.16")
+			rawGoVersion.Store(Target, modFileGoVersion())
 		}
 	}
 
@@ -509,7 +506,7 @@ func CreateModFile(ctx context.Context, modPath string) {
 		base.Fatalf("go: %v", err)
 	}
 
-	commitRequirements(ctx, requirementsFromModFile(ctx, modFile))
+	commitRequirements(ctx, modFileGoVersion(), requirementsFromModFile(ctx))
 
 	// Suggest running 'go mod tidy' unless the project is empty. Even if we
 	// imported all the correct requirements above, we're probably missing
@@ -661,12 +658,13 @@ func initTarget(m module.Version) {
 	}
 }
 
-// requirementsFromModFile returns the set of non-excluded requirements from f.
-func requirementsFromModFile(ctx context.Context, f *modfile.File) *Requirements {
-	roots := make([]module.Version, 0, len(f.Require))
+// requirementsFromModFile returns the set of non-excluded requirements from
+// the global modFile.
+func requirementsFromModFile(ctx context.Context) *Requirements {
+	roots := make([]module.Version, 0, len(modFile.Require))
 	mPathCount := map[string]int{Target.Path: 1}
 	direct := map[string]bool{}
-	for _, r := range f.Require {
+	for _, r := range modFile.Require {
 		if index != nil && index.exclude[r.Mod] {
 			if cfg.BuildMod == "mod" {
 				fmt.Fprintf(os.Stderr, "go: dropping requirement on excluded version %s %s\n", r.Mod.Path, r.Mod.Version)
@@ -683,7 +681,7 @@ func requirementsFromModFile(ctx context.Context, f *modfile.File) *Requirements
 		}
 	}
 	module.Sort(roots)
-	rs := newRequirements(index.depth(), roots, direct)
+	rs := newRequirements(modDepthFromGoVersion(modFileGoVersion()), roots, direct)
 
 	// If any module path appears more than once in the roots, we know that the
 	// go.mod file needs to be updated even though we have not yet loaded any
@@ -988,12 +986,12 @@ func WriteGoMod(ctx context.Context) {
 	if !allowWriteGoMod {
 		panic("WriteGoMod called while disallowed")
 	}
-	commitRequirements(ctx, LoadModFile(ctx))
+	commitRequirements(ctx, modFileGoVersion(), LoadModFile(ctx))
 }
 
 // commitRequirements writes sets the global requirements variable to rs and
 // writes its contents back to the go.mod file on disk.
-func commitRequirements(ctx context.Context, rs *Requirements) {
+func commitRequirements(ctx context.Context, goVersion string, rs *Requirements) {
 	requirements = rs
 
 	if !allowWriteGoMod {
@@ -1014,6 +1012,9 @@ func commitRequirements(ctx context.Context, rs *Requirements) {
 		})
 	}
 	modFile.SetRequire(list)
+	if goVersion != "" {
+		modFile.AddGoStmt(goVersion)
+	}
 	modFile.Cleanup()
 
 	dirty := index.modFileIsDirty(modFile)
diff --git a/src/cmd/go/internal/modload/list.go b/src/cmd/go/internal/modload/list.go
index 344b2aa2c7..ccdeb9b1d1 100644
--- a/src/cmd/go/internal/modload/list.go
+++ b/src/cmd/go/internal/modload/list.go
@@ -72,7 +72,7 @@ func ListModules(ctx context.Context, args []string, mode ListMode) ([]*modinfo.
 	}
 
 	if err == nil {
-		commitRequirements(ctx, rs)
+		commitRequirements(ctx, modFileGoVersion(), rs)
 	}
 	return mods, err
 }
diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index ddacf49ead..f434b399d8 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -49,7 +49,7 @@ package modload
 // Because "go mod vendor" prunes out the tests of vendored packages, the
 // behavior of the "all" pattern with -mod=vendor in Go 1.11–1.15 is the same
 // as the "all" pattern (regardless of the -mod flag) in 1.16+.
-// The allClosesOverTests parameter to the loader indicates whether the "all"
+// The loader uses the GoVersion parameter to determine whether the "all"
 // pattern should close over tests (as in Go 1.11–1.15) or stop at only those
 // packages transitively imported by the packages and tests in the main module
 // ("all" in Go 1.16+ and "go mod vendor" in Go 1.11+).
@@ -121,6 +121,7 @@ import (
 	"cmd/go/internal/str"
 
 	"golang.org/x/mod/module"
+	"golang.org/x/mod/semver"
 )
 
 // loaded is the most recently-used package loader.
@@ -133,6 +134,14 @@ var loaded *loader
 
 // PackageOpts control the behavior of the LoadPackages function.
 type PackageOpts struct {
+	// GoVersion is the Go version to which the go.mod file should be updated
+	// after packages have been loaded.
+	//
+	// An empty GoVersion means to use the Go version already specified in the
+	// main module's go.mod file, or the latest Go version if there is no main
+	// module.
+	GoVersion string
+
 	// Tags are the build tags in effect (as interpreted by the
 	// cmd/go/internal/imports package).
 	// If nil, treated as equivalent to imports.Tags().
@@ -305,12 +314,15 @@ func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (ma
 
 	initialRS, _ := loadModFile(ctx) // Ignore needCommit — we're going to commit at the end regardless.
 
+	if opts.GoVersion == "" {
+		opts.GoVersion = modFileGoVersion()
+	}
+
 	ld := loadFromRoots(ctx, loaderParams{
 		PackageOpts:  opts,
 		requirements: initialRS,
 
-		allClosesOverTests: index.allPatternClosesOverTests() && !opts.UseVendorAll,
-		allPatternIsRoot:   allPatternIsRoot,
+		allPatternIsRoot: allPatternIsRoot,
 
 		listRoots: func(rs *Requirements) (roots []string) {
 			updateMatches(rs, nil)
@@ -368,7 +380,7 @@ func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (ma
 
 	// Success! Update go.mod and go.sum (if needed) and return the results.
 	loaded = ld
-	commitRequirements(ctx, loaded.requirements)
+	commitRequirements(ctx, opts.GoVersion, loaded.requirements)
 
 	for _, pkg := range ld.pkgs {
 		if !pkg.isTest() {
@@ -593,21 +605,22 @@ func ImportFromFiles(ctx context.Context, gofiles []string) {
 		base.Fatalf("go: %v", err)
 	}
 
+	goVersion := modFileGoVersion()
 	loaded = loadFromRoots(ctx, loaderParams{
 		PackageOpts: PackageOpts{
+			GoVersion:             goVersion,
 			Tags:                  tags,
 			ResolveMissingImports: true,
 			SilencePackageErrors:  true,
 		},
-		requirements:       rs,
-		allClosesOverTests: index.allPatternClosesOverTests(),
+		requirements: rs,
 		listRoots: func(*Requirements) (roots []string) {
 			roots = append(roots, imports...)
 			roots = append(roots, testImports...)
 			return roots
 		},
 	})
-	commitRequirements(ctx, loaded.requirements)
+	commitRequirements(ctx, goVersion, loaded.requirements)
 }
 
 // DirImportPath returns the effective import path for dir,
@@ -743,6 +756,12 @@ func Lookup(parentPath string, parentIsStd bool, path string) (dir, realPath str
 type loader struct {
 	loaderParams
 
+	// allClosesOverTests indicates whether the "all" pattern includes
+	// dependencies of tests outside the main module (as in Go 1.11–1.15).
+	// (Otherwise — as in Go 1.16+ — the "all" pattern includes only the packages
+	// transitively *imported by* the packages and tests in the main module.)
+	allClosesOverTests bool
+
 	work *par.Queue
 
 	// reset on each iteration
@@ -757,8 +776,7 @@ type loaderParams struct {
 	PackageOpts
 	requirements *Requirements
 
-	allClosesOverTests bool // Does the "all" pattern include the transitive closure of tests of packages in "all"?
-	allPatternIsRoot   bool // Is the "all" pattern an additional root?
+	allPatternIsRoot bool // Is the "all" pattern an additional root?
 
 	listRoots func(rs *Requirements) []string
 }
@@ -903,6 +921,22 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 		work:         par.NewQueue(runtime.GOMAXPROCS(0)),
 	}
 
+	if params.GoVersion != "" {
+		if semver.Compare("v"+params.GoVersion, narrowAllVersionV) < 0 && !ld.UseVendorAll {
+			// The module's go version explicitly predates the change in "all" for lazy
+			// loading, so continue to use the older interpretation.
+			// (If params.GoVersion is empty, we are probably not in any module at all
+			// and should use the latest semantics.)
+			ld.allClosesOverTests = true
+		}
+
+		var err error
+		ld.requirements, err = convertDepth(ctx, ld.requirements, modDepthFromGoVersion(params.GoVersion))
+		if err != nil {
+			ld.errorf("go: %v\n", err)
+		}
+	}
+
 	if ld.requirements.depth == eager {
 		var err error
 		ld.requirements, _, err = expandGraph(ctx, ld.requirements)
diff --git a/src/cmd/go/internal/modload/modfile.go b/src/cmd/go/internal/modload/modfile.go
index cd08fa5859..7595db7755 100644
--- a/src/cmd/go/internal/modload/modfile.go
+++ b/src/cmd/go/internal/modload/modfile.go
@@ -51,6 +51,27 @@ const (
 
 var modFile *modfile.File
 
+// modFileGoVersion returns the (non-empty) Go version at which the requirements
+// in modFile are intepreted, or the latest Go version if modFile is nil.
+func modFileGoVersion() string {
+	if modFile == nil {
+		return latestGoVersion()
+	}
+	if modFile.Go == nil || modFile.Go.Version == "" {
+		// The main module necessarily has a go.mod file, and that file lacks a
+		// 'go' directive. The 'go' command has been adding that directive
+		// automatically since Go 1.12, so this module either dates to Go 1.11 or
+		// has been erroneously hand-edited.
+		//
+		// The semantics of the go.mod file are more-or-less the same from Go 1.11
+		// through Go 1.16, changing at 1.17 for lazy loading. So even though a
+		// go.mod file without a 'go' directive is theoretically a Go 1.11 file,
+		// scripts may assume that it ends up as a Go 1.16 module.
+		return "1.16"
+	}
+	return modFile.Go.Version
+}
+
 // A modFileIndex is an index of data corresponding to a modFile
 // at a specific point in time.
 type modFileIndex struct {
@@ -79,6 +100,16 @@ const (
 	eager                 // load all transitive dependencies eagerly
 )
 
+func modDepthFromGoVersion(goVersion string) modDepth {
+	if !go117EnableLazyLoading {
+		return eager
+	}
+	if semver.Compare("v"+goVersion, lazyLoadingVersionV) < 0 {
+		return eager
+	}
+	return lazy
+}
+
 // CheckAllowed returns an error equivalent to ErrDisallowed if m is excluded by
 // the main module's go.mod or retracted by its author. Most version queries use
 // this to filter out versions that should not be used.
@@ -344,32 +375,6 @@ func indexModFile(data []byte, modFile *modfile.File, needsFix bool) *modFileInd
 	return i
 }
 
-// allPatternClosesOverTests reports whether the "all" pattern includes
-// dependencies of tests outside the main module (as in Go 1.11–1.15).
-// (Otherwise — as in Go 1.16+ — the "all" pattern includes only the packages
-// transitively *imported by* the packages and tests in the main module.)
-func (i *modFileIndex) allPatternClosesOverTests() bool {
-	if i != nil && i.goVersionV != "" && semver.Compare(i.goVersionV, narrowAllVersionV) < 0 {
-		// The module explicitly predates the change in "all" for lazy loading, so
-		// continue to use the older interpretation. (If i == nil, we not in any
-		// module at all and should use the latest semantics.)
-		return true
-	}
-	return false
-}
-
-// depth reports the modDepth indicated by the indexed go.mod file,
-// or lazy if the go.mod file has not been indexed.
-func (i *modFileIndex) depth() modDepth {
-	if !go117EnableLazyLoading {
-		return eager
-	}
-	if i != nil && semver.Compare(i.goVersionV, lazyLoadingVersionV) < 0 {
-		return eager
-	}
-	return lazy
-}
-
 // modFileIsDirty reports whether the go.mod file differs meaningfully
 // from what was indexed.
 // If modFile has been changed (even cosmetically) since it was first read,
@@ -396,7 +401,7 @@ func (i *modFileIndex) modFileIsDirty(modFile *modfile.File) bool {
 			return true
 		}
 	} else if "v"+modFile.Go.Version != i.goVersionV {
-		if i.goVersionV == "" && cfg.BuildMod == "readonly" {
+		if i.goVersionV == "" && cfg.BuildMod != "mod" {
 			// go.mod files did not always require a 'go' version, so do not error out
 			// if one is missing — we may be inside an older module in the module
 			// cache, and should bias toward providing useful behavior.
@@ -452,7 +457,8 @@ var rawGoVersion sync.Map // map[module.Version]string
 // module.
 type modFileSummary struct {
 	module     module.Version
-	goVersionV string // GoVersion with "v" prefix
+	goVersion  string
+	depth      modDepth
 	require    []module.Version
 	retract    []retraction
 	deprecated string
@@ -465,20 +471,6 @@ type retraction struct {
 	Rationale string
 }
 
-func (s *modFileSummary) depth() modDepth {
-	if !go117EnableLazyLoading {
-		return eager
-	}
-	// The 'go' command fills in the 'go' directive automatically, so an empty
-	// goVersionV in a dependency implies either Go 1.11 (eager loading) or no
-	// explicit go.mod file at all (no difference between eager and lazy because
-	// the module doesn't specify any requirements at all).
-	if s.goVersionV == "" || semver.Compare(s.goVersionV, lazyLoadingVersionV) < 0 {
-		return eager
-	}
-	return lazy
-}
-
 // goModSummary returns a summary of the go.mod file for module m,
 // taking into account any replacements for m, exclusions of its dependencies,
 // and/or vendoring.
@@ -638,7 +630,10 @@ func rawGoModSummary(m module.Version) (*modFileSummary, error) {
 		}
 		if f.Go != nil && f.Go.Version != "" {
 			rawGoVersion.LoadOrStore(m, f.Go.Version)
-			summary.goVersionV = "v" + f.Go.Version
+			summary.goVersion = f.Go.Version
+			summary.depth = modDepthFromGoVersion(f.Go.Version)
+		} else {
+			summary.depth = eager
 		}
 		if len(f.Require) > 0 {
 			summary.require = make([]module.Version, 0, len(f.Require))
diff --git a/src/cmd/go/testdata/script/mod_go_version_missing.txt b/src/cmd/go/testdata/script/mod_go_version_missing.txt
index ea5050ca3d..aca36a0450 100644
--- a/src/cmd/go/testdata/script/mod_go_version_missing.txt
+++ b/src/cmd/go/testdata/script/mod_go_version_missing.txt
@@ -30,12 +30,26 @@ cmp go.mod go.mod.orig
 stderr 'cannot find package "\." in:\n\t.*[/\\]vendor[/\\]example.com[/\\]badedit$'
 
 # When we set -mod=mod, the go version should be updated immediately,
-# to Go 1.16 (not the current version).
+# to the current version, converting the requirements from eager to lazy.
+#
+# Since we don't know which requirements are actually relevant to the main
+# module, all requirements are added as roots, making the requirements untidy.
 
 go list -mod=mod all
 ! stdout '^example.com/testdep$'
 cmp stdout list-1.txt
-cmp go.mod go.mod.want
+cmpenv go.mod go.mod.untidy
+
+go mod tidy
+cmpenv go.mod go.mod.tidy
+
+# On the other hand, if we jump straight to 'go mod tidy',
+# the requirements remain tidy from the start.
+
+cp go.mod.orig go.mod
+go mod tidy
+cmpenv go.mod go.mod.tidy
+
 
 # The updated version should have been written back to go.mod, so now the 'go'
 # directive is explicit. -mod=vendor should trigger by default, and the stronger
@@ -54,10 +68,24 @@ replace (
 	example.com/dep v0.1.0 => ./dep
 	example.com/testdep v0.1.0 => ./testdep
 )
--- go.mod.want --
+-- go.mod.untidy --
+module example.com/m
+
+go $goversion
+
+require (
+	example.com/dep v0.1.0
+	example.com/testdep v0.1.0 // indirect
+)
+
+replace (
+	example.com/dep v0.1.0 => ./dep
+	example.com/testdep v0.1.0 => ./testdep
+)
+-- go.mod.tidy --
 module example.com/m
 
-go 1.16
+go $goversion
 
 require example.com/dep v0.1.0
 
diff --git a/src/cmd/go/testdata/script/mod_load_replace_mismatch.txt b/src/cmd/go/testdata/script/mod_load_replace_mismatch.txt
index dd386f1628..2ca8b3cace 100644
--- a/src/cmd/go/testdata/script/mod_load_replace_mismatch.txt
+++ b/src/cmd/go/testdata/script/mod_load_replace_mismatch.txt
@@ -18,6 +18,6 @@ package use
 import _ "rsc.io/quote"
 
 -- want --
-go mod download: rsc.io/quote@v1.5.2 (replaced by example.com/quote@v1.5.2): parsing go.mod:
+go: rsc.io/quote@v1.5.2 (replaced by example.com/quote@v1.5.2): parsing go.mod:
 	module declares its path as: rsc.io/Quote
 	        but was required as: rsc.io/quote
diff --git a/src/cmd/go/testdata/script/mod_retention.txt b/src/cmd/go/testdata/script/mod_retention.txt
index 711d28b10f..0e639db551 100644
--- a/src/cmd/go/testdata/script/mod_retention.txt
+++ b/src/cmd/go/testdata/script/mod_retention.txt
@@ -62,6 +62,7 @@ cmp go.mod go.mod.tidy
 
 # A missing "go" version directive should be added.
 # However, that should not remove other redundant requirements.
+# In fact, it may *add* redundant requirements due to activating lazy loading.
 cp go.mod.nogo go.mod
 go list -mod=mod all
 cmpenv go.mod go.mod.addedgo
@@ -136,9 +137,10 @@ require (
 -- go.mod.addedgo --
 module m
 
-go 1.16
+go $goversion
 
 require (
+	golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c // indirect
 	rsc.io/quote v1.5.2
 	rsc.io/sampler v1.3.0 // indirect
 	rsc.io/testonly v1.0.0 // indirect
diff --git a/src/cmd/go/testdata/script/mod_tidy_version.txt b/src/cmd/go/testdata/script/mod_tidy_version.txt
new file mode 100644
index 0000000000..5441d9cc06
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_tidy_version.txt
@@ -0,0 +1,248 @@
+# https://golang.org/issue/45094: 'go mod tidy' now accepts a '-go' flag
+# to change the language version in use.
+#
+# The package import graph used in this test looks like:
+#
+# m --- a --- b
+#             |
+#             b_test --- c
+#                        |
+#                        c_test --- d
+#
+# The module diagram looks like:
+#
+# m --- a --- b
+# |
+# + --- c
+# |
+# + --- d
+#
+# Module b omits its dependency on c, and module c omits its dependency on d.
+#
+# In go 1.15, the tidy main module must require a (because it is direct),
+# c (because it is a missing test dependency of an imported package),
+# and d (because it is a missing transitive test dependency).
+#
+# In go 1.16, the tidy main module can omit d because it is no longer
+# included in "all".
+#
+# In go 1.17, the main module must explicitly require b
+# (because it is transitively imported by the main module).
+
+
+cp go.mod go.mod.orig
+
+# An invalid argument should be rejected.
+
+! go mod tidy -go=bananas
+stderr '^go mod: invalid -go option "bananas"; expecting something like "-go 1.17"$'
+cmp go.mod go.mod.orig
+
+
+go mod tidy -go=1.15
+cmp go.mod go.mod.115
+
+go mod tidy
+cmp go.mod go.mod.115
+
+
+go mod tidy -go=1.16
+cmp go.mod go.mod.116
+
+go mod tidy
+cmp go.mod go.mod.116
+
+
+go mod tidy -go=1.17
+cmp go.mod go.mod.117
+
+go mod tidy
+cmp go.mod go.mod.117
+
+
+# If we downgrade back to 1.15, we should re-resolve d to v0.2.0 instead
+# of the original v0.1.0 (because the original requirement is lost).
+
+go mod tidy -go=1.15
+cmp go.mod go.mod.115-2
+
+
+# -go= (with an empty argument) maintains the existing version or adds the
+#  default version (just like omitting the flag).
+
+go mod tidy -go=''
+cmp go.mod go.mod.115-2
+
+cp go.mod.orig go.mod
+go mod tidy -go=''
+cmpenv go.mod go.mod.latest
+
+
+
+-- go.mod --
+module example.com/m
+
+require (
+	example.net/a v0.1.0
+	example.net/c v0.1.0 // indirect
+	example.net/d v0.1.0 // indirect
+)
+
+replace (
+	example.net/a v0.1.0 => ./a
+	example.net/a v0.2.0 => ./a
+	example.net/b v0.1.0 => ./b
+	example.net/b v0.2.0 => ./b
+	example.net/c v0.1.0 => ./c
+	example.net/c v0.2.0 => ./c
+	example.net/d v0.1.0 => ./d
+	example.net/d v0.2.0 => ./d
+)
+-- m.go --
+package m
+
+import _ "example.net/a"
+
+-- go.mod.115 --
+module example.com/m
+
+go 1.15
+
+require (
+	example.net/a v0.1.0
+	example.net/c v0.1.0 // indirect
+	example.net/d v0.1.0 // indirect
+)
+
+replace (
+	example.net/a v0.1.0 => ./a
+	example.net/a v0.2.0 => ./a
+	example.net/b v0.1.0 => ./b
+	example.net/b v0.2.0 => ./b
+	example.net/c v0.1.0 => ./c
+	example.net/c v0.2.0 => ./c
+	example.net/d v0.1.0 => ./d
+	example.net/d v0.2.0 => ./d
+)
+-- go.mod.115-2 --
+module example.com/m
+
+go 1.15
+
+require (
+	example.net/a v0.1.0
+	example.net/c v0.1.0 // indirect
+	example.net/d v0.2.0 // indirect
+)
+
+replace (
+	example.net/a v0.1.0 => ./a
+	example.net/a v0.2.0 => ./a
+	example.net/b v0.1.0 => ./b
+	example.net/b v0.2.0 => ./b
+	example.net/c v0.1.0 => ./c
+	example.net/c v0.2.0 => ./c
+	example.net/d v0.1.0 => ./d
+	example.net/d v0.2.0 => ./d
+)
+-- go.mod.116 --
+module example.com/m
+
+go 1.16
+
+require (
+	example.net/a v0.1.0
+	example.net/c v0.1.0 // indirect
+)
+
+replace (
+	example.net/a v0.1.0 => ./a
+	example.net/a v0.2.0 => ./a
+	example.net/b v0.1.0 => ./b
+	example.net/b v0.2.0 => ./b
+	example.net/c v0.1.0 => ./c
+	example.net/c v0.2.0 => ./c
+	example.net/d v0.1.0 => ./d
+	example.net/d v0.2.0 => ./d
+)
+-- go.mod.117 --
+module example.com/m
+
+go 1.17
+
+require (
+	example.net/a v0.1.0
+	example.net/b v0.1.0 // indirect
+	example.net/c v0.1.0 // indirect
+)
+
+replace (
+	example.net/a v0.1.0 => ./a
+	example.net/a v0.2.0 => ./a
+	example.net/b v0.1.0 => ./b
+	example.net/b v0.2.0 => ./b
+	example.net/c v0.1.0 => ./c
+	example.net/c v0.2.0 => ./c
+	example.net/d v0.1.0 => ./d
+	example.net/d v0.2.0 => ./d
+)
+-- go.mod.latest --
+module example.com/m
+
+go $goversion
+
+require (
+	example.net/a v0.1.0
+	example.net/b v0.1.0 // indirect
+	example.net/c v0.1.0 // indirect
+)
+
+replace (
+	example.net/a v0.1.0 => ./a
+	example.net/a v0.2.0 => ./a
+	example.net/b v0.1.0 => ./b
+	example.net/b v0.2.0 => ./b
+	example.net/c v0.1.0 => ./c
+	example.net/c v0.2.0 => ./c
+	example.net/d v0.1.0 => ./d
+	example.net/d v0.2.0 => ./d
+)
+-- a/go.mod --
+module example.net/a
+
+go 1.15
+
+require example.net/b v0.1.0
+-- a/a.go --
+package a
+
+import _ "example.net/b"
+
+-- b/go.mod --
+module example.net/b
+
+go 1.15
+-- b/b.go --
+package b
+-- b/b_test.go --
+package b_test
+
+import _ "example.net/c"
+
+-- c/go.mod --
+module example.net/c
+
+go 1.15
+-- c/c.go --
+package c
+-- c/c_test.go --
+package c_test
+
+import _ "example.net/d"
+
+-- d/go.mod --
+module example.net/d
+
+go 1.15
+-- d/d.go --
+package d
-- 
GitLab


From c3365ad5f25043d6293f5cec1e71d1526678ac62 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 30 Apr 2021 00:04:19 -0400
Subject: [PATCH 1889/2400] cmd/go: annotate versions in vendor/modules.txt

In order to prevent edit wars with previous cmd/go releases,
the new version annotations are only included if the main module
specifies 'go 1.17' or higher.

Fixes #36876

Change-Id: Iba15e47dd1ac2c16d754679a9b501db4069fa250
Reviewed-on: https://go-review.googlesource.com/c/go/+/315409
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 doc/go1.17.html                               | 10 +++
 src/cmd/go/internal/modcmd/vendor.go          | 57 +++++++-----
 src/cmd/go/internal/modload/vendor.go         |  5 ++
 .../testdata/script/mod_go_version_vendor.txt |  4 +-
 .../testdata/script/mod_vendor_goversion.txt  | 87 +++++++++++++++++++
 src/cmd/vendor/modules.txt                    | 16 ++--
 src/vendor/modules.txt                        |  8 +-
 7 files changed, 154 insertions(+), 33 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/mod_vendor_goversion.txt

diff --git a/doc/go1.17.html b/doc/go1.17.html
index eab4e1eeeb..ef1472d90a 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -120,6 +120,16 @@ Do not send CLs removing the interior tags from such phrases.
   files.)
 </p>
 
+<h4 id="vendor-go-versions"><code>go</code> versions in <code>vendor/modules.txt</code></h4>
+
+<p><!-- golang.org/issue/36876 -->
+  If the main module specifies <code>go</code> <code>1.17</code> or higher,
+  <code>go</code> <code>mod</code> <code>vendor</code> now annotates
+  <code>vendor/modules.txt</code> with the <code>go</code> version indicated by
+  each vendored module in its own <code>go.mod</code> file. The annotated
+  version is used when building the module's packages from vendored source code.
+</p>
+
 <h2 id="runtime">Runtime</h2>
 
 <p>
diff --git a/src/cmd/go/internal/modcmd/vendor.go b/src/cmd/go/internal/modcmd/vendor.go
index 6ebc18dcd8..86eab89065 100644
--- a/src/cmd/go/internal/modcmd/vendor.go
+++ b/src/cmd/go/internal/modcmd/vendor.go
@@ -88,15 +88,23 @@ func runVendor(ctx context.Context, cmd *base.Command, args []string) {
 	}
 
 	includeAllReplacements := false
+	includeGoVersions := false
 	isExplicit := map[module.Version]bool{}
-	if gv := modload.ModFile().Go; gv != nil && semver.Compare("v"+gv.Version, "v1.14") >= 0 {
-		// If the Go version is at least 1.14, annotate all explicit 'require' and
-		// 'replace' targets found in the go.mod file so that we can perform a
-		// stronger consistency check when -mod=vendor is set.
-		for _, r := range modload.ModFile().Require {
-			isExplicit[r.Mod] = true
+	if gv := modload.ModFile().Go; gv != nil {
+		if semver.Compare("v"+gv.Version, "v1.14") >= 0 {
+			// If the Go version is at least 1.14, annotate all explicit 'require' and
+			// 'replace' targets found in the go.mod file so that we can perform a
+			// stronger consistency check when -mod=vendor is set.
+			for _, r := range modload.ModFile().Require {
+				isExplicit[r.Mod] = true
+			}
+			includeAllReplacements = true
+		}
+		if semver.Compare("v"+gv.Version, "v1.17") >= 0 {
+			// If the Go version is at least 1.17, annotate all modules with their
+			// 'go' version directives.
+			includeGoVersions = true
 		}
-		includeAllReplacements = true
 	}
 
 	var vendorMods []module.Version
@@ -110,26 +118,35 @@ func runVendor(ctx context.Context, cmd *base.Command, args []string) {
 	}
 	module.Sort(vendorMods)
 
-	var buf bytes.Buffer
+	var (
+		buf bytes.Buffer
+		w   io.Writer = &buf
+	)
+	if cfg.BuildV {
+		w = io.MultiWriter(&buf, os.Stderr)
+	}
+
 	for _, m := range vendorMods {
 		line := moduleLine(m, modload.Replacement(m))
-		buf.WriteString(line)
-		if cfg.BuildV {
-			os.Stderr.WriteString(line)
+		io.WriteString(w, line)
+
+		goVersion := ""
+		if includeGoVersions {
+			goVersion = modload.ModuleInfo(ctx, m.Path).GoVersion
 		}
-		if isExplicit[m] {
-			buf.WriteString("## explicit\n")
-			if cfg.BuildV {
-				os.Stderr.WriteString("## explicit\n")
-			}
+		switch {
+		case isExplicit[m] && goVersion != "":
+			fmt.Fprintf(w, "## explicit; go %s\n", goVersion)
+		case isExplicit[m]:
+			io.WriteString(w, "## explicit\n")
+		case goVersion != "":
+			fmt.Fprintf(w, "## go %s\n", goVersion)
 		}
+
 		pkgs := modpkgs[m]
 		sort.Strings(pkgs)
 		for _, pkg := range pkgs {
-			fmt.Fprintf(&buf, "%s\n", pkg)
-			if cfg.BuildV {
-				fmt.Fprintf(os.Stderr, "%s\n", pkg)
-			}
+			fmt.Fprintf(w, "%s\n", pkg)
 			vendorPkg(vdir, pkg)
 		}
 	}
diff --git a/src/cmd/go/internal/modload/vendor.go b/src/cmd/go/internal/modload/vendor.go
index d8fd91f1fe..80713b0812 100644
--- a/src/cmd/go/internal/modload/vendor.go
+++ b/src/cmd/go/internal/modload/vendor.go
@@ -31,6 +31,7 @@ var (
 type vendorMetadata struct {
 	Explicit    bool
 	Replacement module.Version
+	GoVersion   string
 }
 
 // readVendorList reads the list of vendored modules from vendor/modules.txt.
@@ -104,6 +105,10 @@ func readVendorList() {
 					if entry == "explicit" {
 						meta.Explicit = true
 					}
+					if strings.HasPrefix(entry, "go ") {
+						meta.GoVersion = strings.TrimPrefix(entry, "go ")
+						rawGoVersion.Store(mod, meta.GoVersion)
+					}
 					// All other tokens are reserved for future use.
 				}
 				vendorMeta[mod] = meta
diff --git a/src/cmd/go/testdata/script/mod_go_version_vendor.txt b/src/cmd/go/testdata/script/mod_go_version_vendor.txt
index 05be54886f..6364e17daa 100644
--- a/src/cmd/go/testdata/script/mod_go_version_vendor.txt
+++ b/src/cmd/go/testdata/script/mod_go_version_vendor.txt
@@ -4,7 +4,6 @@
 
 [short] skip
 
-go mod init example.com/foo
 go mod edit -replace=example.com/use113@v0.1.0=./use113
 
 go mod vendor
@@ -20,7 +19,10 @@ go mod vendor
 ! grep 1.13 vendor/modules.txt
 go build .
 
+-- go.mod --
+module example.com/foo
 
+go 1.16
 -- foo.go --
 package foo
 
diff --git a/src/cmd/go/testdata/script/mod_vendor_goversion.txt b/src/cmd/go/testdata/script/mod_vendor_goversion.txt
new file mode 100644
index 0000000000..7bc67ef30f
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_vendor_goversion.txt
@@ -0,0 +1,87 @@
+# https://golang.org/issue/36876: As of Go 1.17, vendor/modules.txt should
+# indicate the language version used by each dependency.
+
+[short] skip
+
+
+# Control case: without a vendor directory, need117 builds and bad114 doesn't.
+
+go build example.net/need117
+! go build example.net/bad114
+stderr '^bad114[/\\]bad114.go:15:2: duplicate method Y$'
+
+
+# With a vendor/modules.txt lacking language versions, the world is topsy-turvy.
+# Things that ought to build shouldn't, and things that shouldn't build do.
+
+go mod vendor
+go build example.net/bad114
+! go build example.net/need117
+stderr '^vendor[/\\]example\.net[/\\]need117[/\\]need117.go:5:18: .*\n\tconversion of slices to array pointers only supported as of -lang=go1\.17'
+
+
+# Upgrading the main module to 1.17 adds version annotations.
+# Then everything is once again consistent with the non-vendored world.
+
+go mod edit -go=1.17
+go mod vendor
+go build example.net/need117
+! go build example.net/bad114
+stderr '^vendor[/\\]example\.net[/\\]bad114[/\\]bad114.go:15:2: duplicate method Y$'
+
+
+-- go.mod --
+module example.net/m
+
+go 1.16
+
+require (
+	example.net/bad114 v0.1.0
+	example.net/need117 v0.1.0
+)
+
+replace (
+	example.net/bad114 v0.1.0 => ./bad114
+	example.net/need117 v0.1.0 => ./need117
+)
+-- m.go --
+package m
+
+import _ "example.net/bad114"
+import _ "example.net/need117"
+
+-- bad114/go.mod --
+// Module bad114 requires Go 1.14 or higher, but declares Go 1.13.
+module example.net/bad114
+
+go 1.13
+-- bad114/bad114.go --
+package bad114
+
+type XY interface {
+	X()
+	Y()
+}
+
+type YZ interface {
+	Y()
+	Z()
+}
+
+type XYZ interface {
+	XY
+	YZ
+}
+
+-- need117/go.mod --
+// Module need117 requires Go 1.17 or higher.
+module example.net/need117
+
+go 1.17
+-- need117/need117.go --
+package need117
+
+func init() {
+		 s := make([]byte, 4)
+		 _ = (*[4]byte)(s)
+}
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 0457b374b0..69d10d074a 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -1,5 +1,5 @@
 # github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5
-## explicit
+## explicit; go 1.14
 github.com/google/pprof/driver
 github.com/google/pprof/internal/binutils
 github.com/google/pprof/internal/driver
@@ -19,17 +19,17 @@ github.com/google/pprof/third_party/svgpan
 ## explicit
 github.com/ianlancetaylor/demangle
 # golang.org/x/arch v0.0.0-20210308155006-05f8f0431f72
-## explicit
+## explicit; go 1.11
 golang.org/x/arch/arm/armasm
 golang.org/x/arch/arm64/arm64asm
 golang.org/x/arch/ppc64/ppc64asm
 golang.org/x/arch/x86/x86asm
 # golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83
-## explicit
+## explicit; go 1.11
 golang.org/x/crypto/ed25519
 golang.org/x/crypto/ed25519/internal/edwards25519
 # golang.org/x/mod v0.4.3-0.20210409134425-858fdbee9c24
-## explicit
+## explicit; go 1.12
 golang.org/x/mod/internal/lazyregexp
 golang.org/x/mod/modfile
 golang.org/x/mod/module
@@ -40,16 +40,16 @@ golang.org/x/mod/sumdb/note
 golang.org/x/mod/sumdb/tlog
 golang.org/x/mod/zip
 # golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57
-## explicit
+## explicit; go 1.12
 golang.org/x/sys/internal/unsafeheader
 golang.org/x/sys/plan9
 golang.org/x/sys/unix
 golang.org/x/sys/windows
 # golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d
-## explicit
+## explicit; go 1.11
 golang.org/x/term
 # golang.org/x/tools v0.1.1-0.20210422170518-f946a157eefe
-## explicit
+## explicit; go 1.12
 golang.org/x/tools/cover
 golang.org/x/tools/go/analysis
 golang.org/x/tools/go/analysis/internal/analysisflags
@@ -93,6 +93,6 @@ golang.org/x/tools/go/types/typeutil
 golang.org/x/tools/internal/analysisinternal
 golang.org/x/tools/internal/lsp/fuzzy
 # golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1
-## explicit
+## explicit; go 1.11
 golang.org/x/xerrors
 golang.org/x/xerrors/internal
diff --git a/src/vendor/modules.txt b/src/vendor/modules.txt
index 499e6fc3fa..d849d6553c 100644
--- a/src/vendor/modules.txt
+++ b/src/vendor/modules.txt
@@ -1,5 +1,5 @@
 # golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83
-## explicit
+## explicit; go 1.11
 golang.org/x/crypto/chacha20
 golang.org/x/crypto/chacha20poly1305
 golang.org/x/crypto/cryptobyte
@@ -9,7 +9,7 @@ golang.org/x/crypto/hkdf
 golang.org/x/crypto/internal/subtle
 golang.org/x/crypto/poly1305
 # golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4
-## explicit
+## explicit; go 1.11
 golang.org/x/net/dns/dnsmessage
 golang.org/x/net/http/httpguts
 golang.org/x/net/http/httpproxy
@@ -19,10 +19,10 @@ golang.org/x/net/lif
 golang.org/x/net/nettest
 golang.org/x/net/route
 # golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57
-## explicit
+## explicit; go 1.12
 golang.org/x/sys/cpu
 # golang.org/x/text v0.3.6-0.20210227105805-e3aa4adf54f6
-## explicit
+## explicit; go 1.11
 golang.org/x/text/secure/bidirule
 golang.org/x/text/transform
 golang.org/x/text/unicode/bidi
-- 
GitLab


From eb71887b99fa656ed627c9c1d41319b9198979c8 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 30 Apr 2021 00:34:54 -0400
Subject: [PATCH 1890/2400] cmd/go: prune go.mod and go.sum files from vendored
 dependencies

Fixes #42970

Change-Id: I79246ef7fc16ae05c8e7b40ffb239a61f6415447
Reviewed-on: https://go-review.googlesource.com/c/go/+/315410
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 doc/go1.17.html                               | 10 ++++-
 src/cmd/go/internal/modcmd/vendor.go          |  9 +++++
 .../go/testdata/script/mod_vendor_gomod.txt   | 38 +++++++++++++++++++
 src/cmd/vendor/golang.org/x/term/go.mod       |  5 ---
 src/cmd/vendor/golang.org/x/term/go.sum       |  2 -
 src/cmd/vendor/golang.org/x/xerrors/go.mod    |  3 --
 6 files changed, 56 insertions(+), 11 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/mod_vendor_gomod.txt
 delete mode 100644 src/cmd/vendor/golang.org/x/term/go.mod
 delete mode 100644 src/cmd/vendor/golang.org/x/term/go.sum
 delete mode 100644 src/cmd/vendor/golang.org/x/xerrors/go.mod

diff --git a/doc/go1.17.html b/doc/go1.17.html
index ef1472d90a..b670d1b149 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -120,7 +120,7 @@ Do not send CLs removing the interior tags from such phrases.
   files.)
 </p>
 
-<h4 id="vendor-go-versions"><code>go</code> versions in <code>vendor/modules.txt</code></h4>
+<h4 id="vendor"><code>vendor</code> contents</h4>
 
 <p><!-- golang.org/issue/36876 -->
   If the main module specifies <code>go</code> <code>1.17</code> or higher,
@@ -130,6 +130,14 @@ Do not send CLs removing the interior tags from such phrases.
   version is used when building the module's packages from vendored source code.
 </p>
 
+<p><!-- golang.org/issue/42970 -->
+  If the main module specifies <code>go</code> <code>1.17</code> or higher,
+  <code>go</code> <code>mod</code> <code>vendor</code> now omits <code>go.mod</code>
+  and <code>go.sum</code> files for vendored dependencies, which can otherwise
+  interfere with the ability of the <code>go</code> command to identify the correct
+  module root when invoked within the <code>vendor</code> tree.
+</p>
+
 <h2 id="runtime">Runtime</h2>
 
 <p>
diff --git a/src/cmd/go/internal/modcmd/vendor.go b/src/cmd/go/internal/modcmd/vendor.go
index 86eab89065..8e1c0432f7 100644
--- a/src/cmd/go/internal/modcmd/vendor.go
+++ b/src/cmd/go/internal/modcmd/vendor.go
@@ -340,6 +340,15 @@ func matchPotentialSourceFile(dir string, info fs.DirEntry) bool {
 	if strings.HasSuffix(info.Name(), "_test.go") {
 		return false
 	}
+	if info.Name() == "go.mod" || info.Name() == "go.sum" {
+		if gv := modload.ModFile().Go; gv != nil && semver.Compare("v"+gv.Version, "v1.17") >= 0 {
+			// As of Go 1.17, we strip go.mod and go.sum files from dependency modules.
+			// Otherwise, 'go' commands invoked within the vendor subtree may misidentify
+			// an arbitrary directory within the vendor tree as a module root.
+			// (See https://golang.org/issue/42970.)
+			return false
+		}
+	}
 	if strings.HasSuffix(info.Name(), ".go") {
 		f, err := fsys.Open(filepath.Join(dir, info.Name()))
 		if err != nil {
diff --git a/src/cmd/go/testdata/script/mod_vendor_gomod.txt b/src/cmd/go/testdata/script/mod_vendor_gomod.txt
new file mode 100644
index 0000000000..3f6ea3561a
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_vendor_gomod.txt
@@ -0,0 +1,38 @@
+# https://golang.org/issue/42970: As of Go 1.17, go.mod and go.sum files should
+# be stripped from vendored dependencies.
+
+go mod vendor
+cd vendor/example.net/x
+go list all
+! stdout '^example.net/m'
+stdout '^example.net/x$'
+exists ./go.sum
+
+cd ../../..
+go mod edit -go=1.17
+go mod vendor
+cd vendor/example.net/x
+go list all
+stdout '^example.net/m$'
+stdout '^example.net/x$'
+! exists ./go.sum
+
+-- go.mod --
+module example.net/m
+
+go 1.16
+
+require example.net/x v0.1.0
+
+replace example.net/x v0.1.0 => ./x
+-- m.go --
+package m
+
+import _ "example.net/x"
+-- x/go.mod --
+module example.net/x
+
+go 1.16
+-- x/go.sum --
+-- x/x.go --
+package x
diff --git a/src/cmd/vendor/golang.org/x/term/go.mod b/src/cmd/vendor/golang.org/x/term/go.mod
deleted file mode 100644
index d45f52851e..0000000000
--- a/src/cmd/vendor/golang.org/x/term/go.mod
+++ /dev/null
@@ -1,5 +0,0 @@
-module golang.org/x/term
-
-go 1.11
-
-require golang.org/x/sys v0.0.0-20201119102817-f84b799fce68
diff --git a/src/cmd/vendor/golang.org/x/term/go.sum b/src/cmd/vendor/golang.org/x/term/go.sum
deleted file mode 100644
index de9e09c654..0000000000
--- a/src/cmd/vendor/golang.org/x/term/go.sum
+++ /dev/null
@@ -1,2 +0,0 @@
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68 h1:nxC68pudNYkKU6jWhgrqdreuFiOQWj1Fs7T3VrH4Pjw=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
diff --git a/src/cmd/vendor/golang.org/x/xerrors/go.mod b/src/cmd/vendor/golang.org/x/xerrors/go.mod
deleted file mode 100644
index 870d4f612d..0000000000
--- a/src/cmd/vendor/golang.org/x/xerrors/go.mod
+++ /dev/null
@@ -1,3 +0,0 @@
-module golang.org/x/xerrors
-
-go 1.11
-- 
GitLab


From cbff713e68a1378713f1692cbfe13499106de7eb Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 30 Apr 2021 01:29:57 -0400
Subject: [PATCH 1891/2400] cmd/go: add GODEBUG tokens for debugging lazy
 module loading

GODEBUG=lazymod=log causes the go command to log a stack dump whenever
the full module graph is loaded in a lazy module.

GODEBUG=lazymod=strict does the same, but also terminates the command
with a nonzero exit code.

For #36460

Change-Id: Ia5a4c46069044bcc157b285f64c2392990d70bd0
Reviewed-on: https://go-review.googlesource.com/c/go/+/315411
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modload/buildlist.go | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index e7af892996..7820fcf6f1 100644
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -11,8 +11,10 @@ import (
 	"cmd/go/internal/par"
 	"context"
 	"fmt"
+	"os"
 	"reflect"
 	"runtime"
+	"runtime/debug"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -232,12 +234,29 @@ type summaryError struct {
 	err     error
 }
 
+var readModGraphDebugOnce sync.Once
+
 // readModGraph reads and returns the module dependency graph starting at the
 // given roots.
 //
 // Unlike LoadModGraph, readModGraph does not attempt to diagnose or update
 // inconsistent roots.
 func readModGraph(ctx context.Context, depth modDepth, roots []module.Version) (*ModuleGraph, error) {
+	if depth == lazy {
+		readModGraphDebugOnce.Do(func() {
+			for _, f := range strings.Split(os.Getenv("GODEBUG"), ",") {
+				switch f {
+				case "lazymod=log":
+					debug.PrintStack()
+					fmt.Fprintf(os.Stderr, "go: read full module graph.\n")
+				case "lazymod=strict":
+					debug.PrintStack()
+					base.Fatalf("go: read full module graph (forbidden by GODEBUG=lazymod=strict).")
+				}
+			}
+		})
+	}
+
 	var (
 		mu       sync.Mutex // guards mg.g and hasError during loading
 		hasError bool
-- 
GitLab


From d9bfda81249f25959090b1493ac8e261dd4542f4 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 30 Apr 2021 01:51:16 -0400
Subject: [PATCH 1892/2400] cmd/go: remove the special case for "unsafe" in
 importFromModules

The comment for this special case claims:
> There's no directory for import "C" or import "unsafe".

However, there clearly is a directory for "unsafe" in
GOROOT/src/unsafe, and all of our integration tests seem to pass
without this special case. As far as I can tell, it's just confusing.

Also note that the internal/goroot package explicitly considers
package "unsafe" to be in the standard library; see CL 137435.

For #36460

Change-Id: Ib857d18f731a7f3c911c1bd116a34e3a9b3d74a5
Reviewed-on: https://go-review.googlesource.com/c/go/+/315412
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modload/import.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/go/internal/modload/import.go b/src/cmd/go/internal/modload/import.go
index 6c863351ff..f76befcfe3 100644
--- a/src/cmd/go/internal/modload/import.go
+++ b/src/cmd/go/internal/modload/import.go
@@ -243,8 +243,8 @@ func importFromModules(ctx context.Context, path string, rs *Requirements, mg *M
 	if build.IsLocalImport(path) {
 		return module.Version{}, "", fmt.Errorf("relative import not supported")
 	}
-	if path == "C" || path == "unsafe" {
-		// There's no directory for import "C" or import "unsafe".
+	if path == "C" {
+		// There's no directory for import "C".
 		return module.Version{}, "", nil
 	}
 	// Before any further lookup, check that the path is valid.
-- 
GitLab


From 4893eee9dc307a234bff1aa441acf849111e1beb Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Wed, 26 Aug 2020 03:23:42 +1000
Subject: [PATCH 1893/2400] runtime: switch openbsd/386 to pthreads

This switches openbsd/386 to thread creation via pthreads, rather than doing
direct system calls.

Update #36435

Change-Id: I000a815fc0edd0272c3285954f3f007229bc60a0
Reviewed-on: https://go-review.googlesource.com/c/go/+/250577
Trust: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/asm_386.s             |   4 +
 src/runtime/defs_openbsd_386.go   |   9 +
 src/runtime/os_openbsd_libc.go    |   4 +-
 src/runtime/os_openbsd_syscall.go |   4 +-
 src/runtime/proc.go               |   2 +-
 src/runtime/sys_libc.go           |   4 +-
 src/runtime/sys_openbsd.go        |   4 +-
 src/runtime/sys_openbsd_386.s     | 282 +++++++++++++++++-------------
 8 files changed, 178 insertions(+), 135 deletions(-)

diff --git a/src/runtime/asm_386.s b/src/runtime/asm_386.s
index 45f8bf1003..ec5ea58028 100644
--- a/src/runtime/asm_386.s
+++ b/src/runtime/asm_386.s
@@ -195,6 +195,10 @@ nocpuinfo:
 	JMP ok
 #endif
 needtls:
+#ifdef GOOS_openbsd
+	// skip runtime·ldt0setup(SB) and tls test on OpenBSD in all cases
+	JMP	ok
+#endif
 #ifdef GOOS_plan9
 	// skip runtime·ldt0setup(SB) and tls test on Plan 9 in all cases
 	JMP	ok
diff --git a/src/runtime/defs_openbsd_386.go b/src/runtime/defs_openbsd_386.go
index 35f2e53fcf..6a62261f5b 100644
--- a/src/runtime/defs_openbsd_386.go
+++ b/src/runtime/defs_openbsd_386.go
@@ -30,6 +30,8 @@ const (
 	_SA_RESTART = 0x2
 	_SA_ONSTACK = 0x1
 
+	_PTHREAD_CREATE_DETACHED = 0x1
+
 	_SIGHUP    = 0x1
 	_SIGINT    = 0x2
 	_SIGQUIT   = 0x3
@@ -166,3 +168,10 @@ type keventt struct {
 	data   int64
 	udata  *byte
 }
+
+type pthread uintptr
+type pthreadattr uintptr
+type pthreadcond uintptr
+type pthreadcondattr uintptr
+type pthreadmutex uintptr
+type pthreadmutexattr uintptr
diff --git a/src/runtime/os_openbsd_libc.go b/src/runtime/os_openbsd_libc.go
index 3f43ade558..cff5a092d7 100644
--- a/src/runtime/os_openbsd_libc.go
+++ b/src/runtime/os_openbsd_libc.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (openbsd && amd64) || (openbsd && arm64)
-// +build openbsd,amd64 openbsd,arm64
+//go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm64)
+// +build openbsd,386 openbsd,amd64 openbsd,arm64
 
 package runtime
 
diff --git a/src/runtime/os_openbsd_syscall.go b/src/runtime/os_openbsd_syscall.go
index 6facf31593..5315487961 100644
--- a/src/runtime/os_openbsd_syscall.go
+++ b/src/runtime/os_openbsd_syscall.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build openbsd && !amd64 && openbsd && !arm64
-// +build openbsd,!amd64,openbsd,!arm64
+//go:build openbsd && !386 && openbsd && !amd64 && openbsd && !arm64
+// +build openbsd,!386,openbsd,!amd64,openbsd,!arm64
 
 package runtime
 
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 1b1b5769ff..497dbd5443 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -1316,7 +1316,7 @@ func mStackIsSystemAllocated() bool {
 		return true
 	case "openbsd":
 		switch GOARCH {
-		case "amd64", "arm64":
+		case "386", "amd64", "arm64":
 			return true
 		}
 	}
diff --git a/src/runtime/sys_libc.go b/src/runtime/sys_libc.go
index 99d073517b..91195eb3c0 100644
--- a/src/runtime/sys_libc.go
+++ b/src/runtime/sys_libc.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build darwin || (openbsd && amd64) || (openbsd && arm64)
-// +build darwin openbsd,amd64 openbsd,arm64
+//go:build darwin || (openbsd && 386) || (openbsd && amd64) || (openbsd && arm64)
+// +build darwin openbsd,386 openbsd,amd64 openbsd,arm64
 
 package runtime
 
diff --git a/src/runtime/sys_openbsd.go b/src/runtime/sys_openbsd.go
index 362fa777ef..f6146c2e1d 100644
--- a/src/runtime/sys_openbsd.go
+++ b/src/runtime/sys_openbsd.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (openbsd && amd64) || (openbsd && arm64)
-// +build openbsd,amd64 openbsd,arm64
+//go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm64)
+// +build openbsd,386 openbsd,amd64 openbsd,arm64
 
 package runtime
 
diff --git a/src/runtime/sys_openbsd_386.s b/src/runtime/sys_openbsd_386.s
index 0f7895aef8..8eb252904f 100644
--- a/src/runtime/sys_openbsd_386.s
+++ b/src/runtime/sys_openbsd_386.s
@@ -3,7 +3,9 @@
 // license that can be found in the LICENSE file.
 //
 // System calls and other sys.stuff for 386, OpenBSD
-// /usr/src/sys/kern/syscalls.master for syscall numbers.
+// System calls are implemented in libc/libpthread, this file
+// contains trampolines that convert from Go to C calling convention.
+// Some direct system call implementations currently remain.
 //
 
 #include "go_asm.h"
@@ -12,6 +14,159 @@
 
 #define	CLOCK_MONOTONIC	$3
 
+TEXT runtime·setldt(SB),NOSPLIT,$0
+	// Nothing to do, pthread already set thread-local storage up.
+	RET
+
+// mstart_stub is the first function executed on a new thread started by pthread_create.
+// It just does some low-level setup and then calls mstart.
+// Note: called with the C calling convention.
+TEXT runtime·mstart_stub(SB),NOSPLIT,$28
+	// We are already on m's g0 stack.
+
+	// Save callee-save registers.
+	MOVL	BX, bx-4(SP)
+	MOVL	BP, bp-8(SP)
+	MOVL	SI, si-12(SP)
+	MOVL	DI, di-16(SP)
+
+	MOVL	32(SP), AX	// m
+	MOVL	m_g0(AX), DX
+	get_tls(CX)
+	MOVL	DX, g(CX)
+
+	CALL	runtime·mstart(SB)
+
+	// Restore callee-save registers.
+	MOVL	di-16(SP), DI
+	MOVL	si-12(SP), SI
+	MOVL	bp-8(SP),  BP
+	MOVL	bx-4(SP),  BX
+
+	// Go is all done with this OS thread.
+	// Tell pthread everything is ok (we never join with this thread, so
+	// the value here doesn't really matter).
+	MOVL	$0, AX
+	RET
+
+TEXT runtime·sigfwd(SB),NOSPLIT,$0-16
+	MOVL	fn+0(FP), AX
+	MOVL	sig+4(FP), BX
+	MOVL	info+8(FP), CX
+	MOVL	ctx+12(FP), DX
+	MOVL	SP, SI
+	SUBL	$32, SP
+	ANDL	$~15, SP	// align stack: handler might be a C function
+	MOVL	BX, 0(SP)
+	MOVL	CX, 4(SP)
+	MOVL	DX, 8(SP)
+	MOVL	SI, 12(SP)	// save SI: handler might be a Go function
+	CALL	AX
+	MOVL	12(SP), AX
+	MOVL	AX, SP
+	RET
+
+// Called by OS using C ABI.
+TEXT runtime·sigtramp(SB),NOSPLIT,$28
+	NOP	SP	// tell vet SP changed - stop checking offsets
+	// Save callee-saved C registers, since the caller may be a C signal handler.
+	MOVL	BX, bx-4(SP)
+	MOVL	BP, bp-8(SP)
+	MOVL	SI, si-12(SP)
+	MOVL	DI, di-16(SP)
+	// We don't save mxcsr or the x87 control word because sigtrampgo doesn't
+	// modify them.
+
+	MOVL	32(SP), BX // signo
+	MOVL	BX, 0(SP)
+	MOVL	36(SP), BX // info
+	MOVL	BX, 4(SP)
+	MOVL	40(SP), BX // context
+	MOVL	BX, 8(SP)
+	CALL	runtime·sigtrampgo(SB)
+
+	MOVL	di-16(SP), DI
+	MOVL	si-12(SP), SI
+	MOVL	bp-8(SP),  BP
+	MOVL	bx-4(SP),  BX
+	RET
+
+// These trampolines help convert from Go calling convention to C calling convention.
+// They should be called with asmcgocall - note that while asmcgocall does
+// stack alignment, creation of a frame undoes it again.
+// A pointer to the arguments is passed on the stack.
+// A single int32 result is returned in AX.
+// (For more results, make an args/results structure.)
+TEXT runtime·pthread_attr_init_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$4, SP
+	MOVL	12(SP), DX		// pointer to args
+	MOVL	0(DX), AX
+	MOVL	AX, 0(SP)		// arg 1 - attr
+	CALL	libc_pthread_attr_init(SB)
+	MOVL	BP, SP
+	POPL	BP
+	RET
+
+TEXT runtime·pthread_attr_destroy_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$4, SP
+	MOVL	12(SP), DX		// pointer to args
+	MOVL	0(DX), AX
+	MOVL	AX, 0(SP)		// arg 1 - attr
+	CALL	libc_pthread_attr_destroy(SB)
+	MOVL	BP, SP
+	POPL	BP
+	RET
+
+TEXT runtime·pthread_attr_getstacksize_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$8, SP
+	MOVL	16(SP), DX		// pointer to args
+	MOVL	0(DX), AX
+	MOVL	4(DX), BX
+	MOVL	AX, 0(SP)		// arg 1 - attr
+	MOVL	BX, 4(SP)		// arg 2 - size
+	CALL	libc_pthread_attr_getstacksize(SB)
+	MOVL	BP, SP
+	POPL	BP
+	RET
+
+TEXT runtime·pthread_attr_setdetachstate_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$8, SP
+	MOVL	16(SP), DX		// pointer to args
+	MOVL	0(DX), AX
+	MOVL	4(DX), BX
+	MOVL	AX, 0(SP)		// arg 1 - attr
+	MOVL	BX, 4(SP)		// arg 2 - state
+	CALL	libc_pthread_attr_setdetachstate(SB)
+	MOVL	BP, SP
+	POPL	BP
+	RET
+
+TEXT runtime·pthread_create_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$20, SP
+	MOVL	28(SP), DX		// pointer to args
+	LEAL	16(SP), AX
+	MOVL	AX, 0(SP)		// arg 1 - &threadid (discarded)
+	MOVL	0(DX), AX
+	MOVL	4(DX), BX
+	MOVL	8(DX), CX
+	MOVL	AX, 4(SP)		// arg 2 - attr
+	MOVL	BX, 8(SP)		// arg 3 - start
+	MOVL	CX, 12(SP)		// arg 4 - arg
+	CALL	libc_pthread_create(SB)
+	MOVL	BP, SP
+	POPL	BP
+	RET
+
 // Exit the entire program (like C exit)
 TEXT runtime·exit(SB),NOSPLIT,$-4
 	MOVL	$1, AX
@@ -226,124 +381,6 @@ TEXT runtime·obsdsigprocmask(SB),NOSPLIT,$-4
 	MOVL	AX, ret+8(FP)
 	RET
 
-TEXT runtime·sigfwd(SB),NOSPLIT,$12-16
-	MOVL	fn+0(FP), AX
-	MOVL	sig+4(FP), BX
-	MOVL	info+8(FP), CX
-	MOVL	ctx+12(FP), DX
-	MOVL	SP, SI
-	SUBL	$32, SP
-	ANDL	$~15, SP	// align stack: handler might be a C function
-	MOVL	BX, 0(SP)
-	MOVL	CX, 4(SP)
-	MOVL	DX, 8(SP)
-	MOVL	SI, 12(SP)	// save SI: handler might be a Go function
-	CALL	AX
-	MOVL	12(SP), AX
-	MOVL	AX, SP
-	RET
-
-// Called by OS using C ABI.
-TEXT runtime·sigtramp(SB),NOSPLIT,$28
-	NOP	SP	// tell vet SP changed - stop checking offsets
-	// Save callee-saved C registers, since the caller may be a C signal handler.
-	MOVL	BX, bx-4(SP)
-	MOVL	BP, bp-8(SP)
-	MOVL	SI, si-12(SP)
-	MOVL	DI, di-16(SP)
-	// We don't save mxcsr or the x87 control word because sigtrampgo doesn't
-	// modify them.
-
-	MOVL	32(SP), BX // signo
-	MOVL	BX, 0(SP)
-	MOVL	36(SP), BX // info
-	MOVL	BX, 4(SP)
-	MOVL	40(SP), BX // context
-	MOVL	BX, 8(SP)
-	CALL	runtime·sigtrampgo(SB)
-
-	MOVL	di-16(SP), DI
-	MOVL	si-12(SP), SI
-	MOVL	bp-8(SP),  BP
-	MOVL	bx-4(SP),  BX
-	RET
-
-// int32 tfork(void *param, uintptr psize, M *mp, G *gp, void (*fn)(void));
-TEXT runtime·tfork(SB),NOSPLIT,$12
-
-	// Copy mp, gp and fn from the parent stack onto the child stack.
-	MOVL	param+0(FP), AX
-	MOVL	8(AX), CX		// tf_stack
-	SUBL	$16, CX
-	MOVL	CX, 8(AX)
-	MOVL	mm+8(FP), SI
-	MOVL	SI, 0(CX)
-	MOVL	gg+12(FP), SI
-	MOVL	SI, 4(CX)
-	MOVL	fn+16(FP), SI
-	MOVL	SI, 8(CX)
-	MOVL	$1234, 12(CX)
-
-	MOVL	$0, 0(SP)		// syscall gap
-	MOVL	param+0(FP), AX
-	MOVL	AX, 4(SP)		// arg 1 - param
-	MOVL	psize+4(FP), AX
-	MOVL	AX, 8(SP)		// arg 2 - psize
-	MOVL	$8, AX			// sys___tfork
-	INT	$0x80
-
-	// Return if tfork syscall failed.
-	JCC	4(PC)
-	NEGL	AX
-	MOVL	AX, ret+20(FP)
-	RET
-
-	// In parent, return.
-	CMPL	AX, $0
-	JEQ	3(PC)
-	MOVL	AX, ret+20(FP)
-	RET
-
-	// Paranoia: check that SP is as we expect.
-	MOVL	12(SP), BP
-	CMPL	BP, $1234
-	JEQ	2(PC)
-	INT	$3
-
-	// Reload registers.
-	MOVL	0(SP), BX		// m
-	MOVL	4(SP), DX		// g
-	MOVL	8(SP), SI		// fn
-
-	// Set FS to point at m->tls.
-	LEAL	m_tls(BX), BP
-	PUSHAL				// save registers
-	PUSHL	BP
-	CALL	set_tcb<>(SB)
-	POPL	AX
-	POPAL
-
-	// Now segment is established. Initialize m, g.
-	get_tls(AX)
-	MOVL	DX, g(AX)
-	MOVL	BX, g_m(DX)
-
-	CALL	runtime·stackcheck(SB)	// smashes AX, CX
-	MOVL	0(DX), DX		// paranoia; check they are not nil
-	MOVL	0(BX), BX
-
-	// More paranoia; check that stack splitting code works.
-	PUSHAL
-	CALL	runtime·emptyfunc(SB)
-	POPAL
-
-	// Call fn.
-	CALL	SI
-
-	// fn should never return.
-	MOVL	$0x1234, 0x1005
-	RET
-
 TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
 	MOVL	$288, AX		// sys_sigaltstack
 	MOVL	new+0(FP), BX
@@ -354,13 +391,6 @@ TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
 	INT	$3
 	RET
 
-TEXT runtime·setldt(SB),NOSPLIT,$4
-	// Under OpenBSD we set the GS base instead of messing with the LDT.
-	MOVL	base+4(FP), AX
-	MOVL	AX, 0(SP)
-	CALL	set_tcb<>(SB)
-	RET
-
 TEXT set_tcb<>(SB),NOSPLIT,$8
 	// adjust for ELF: wants to use -4(GS) for g
 	MOVL	tlsbase+0(FP), CX
-- 
GitLab


From c3b2b0415666a1b2a3e00583a2f192ad2001f93e Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Thu, 28 Jan 2021 23:06:56 +1100
Subject: [PATCH 1894/2400] runtime: switch openbsd/386 locking to libc

Switch openbsd/386 to locking via libc, rather than performing direct
system calls.

Update #36435

Change-Id: I8198171e21f9acf28846ad723ea9ff48f7c8a69d
Reviewed-on: https://go-review.googlesource.com/c/go/+/287652
Trust: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/os_openbsd_syscall1.go |  4 +-
 src/runtime/sys_openbsd1.go        |  4 +-
 src/runtime/sys_openbsd_386.s      | 59 +++++++++++++++++++++---------
 3 files changed, 46 insertions(+), 21 deletions(-)

diff --git a/src/runtime/os_openbsd_syscall1.go b/src/runtime/os_openbsd_syscall1.go
index 0f3d5f0b73..ecae67aa2f 100644
--- a/src/runtime/os_openbsd_syscall1.go
+++ b/src/runtime/os_openbsd_syscall1.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build openbsd && !amd64 && !arm64
-// +build openbsd,!amd64,!arm64
+//go:build openbsd && !386 && !amd64 && !arm64
+// +build openbsd,!386,!amd64,!arm64
 
 package runtime
 
diff --git a/src/runtime/sys_openbsd1.go b/src/runtime/sys_openbsd1.go
index 43e0058985..b007b6d3f5 100644
--- a/src/runtime/sys_openbsd1.go
+++ b/src/runtime/sys_openbsd1.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (openbsd && amd64) || (openbsd && arm64)
-// +build openbsd,amd64 openbsd,arm64
+//go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm64)
+// +build openbsd,386 openbsd,amd64 openbsd,arm64
 
 package runtime
 
diff --git a/src/runtime/sys_openbsd_386.s b/src/runtime/sys_openbsd_386.s
index 8eb252904f..f1911a588d 100644
--- a/src/runtime/sys_openbsd_386.s
+++ b/src/runtime/sys_openbsd_386.s
@@ -167,6 +167,48 @@ TEXT runtime·pthread_create_trampoline(SB),NOSPLIT,$0
 	POPL	BP
 	RET
 
+TEXT runtime·thrsleep_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$20, SP
+	MOVL	28(SP), DX		// pointer to args
+	MOVL	0(DX), AX
+	MOVL	4(DX), BX
+	MOVL	8(DX), CX
+	MOVL	AX, 0(SP)		// arg 1 - id
+	MOVL	BX, 4(SP)		// arg 2 - clock_id
+	MOVL	CX, 8(SP)		// arg 3 - abstime
+	MOVL	12(DX), AX
+	MOVL	16(DX), BX
+	MOVL	AX, 12(SP)		// arg 4 - lock
+	MOVL	BX, 16(SP)		// arg 5 - abort
+	CALL	libc_thrsleep(SB)
+	MOVL	BP, SP
+	POPL	BP
+	RET
+
+TEXT runtime·thrwakeup_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$8, SP
+	MOVL	16(SP), DX		// pointer to args
+	MOVL	0(DX), AX
+	MOVL	4(DX), BX
+	MOVL	AX, 0(SP)		// arg 1 - id
+	MOVL	BX, 4(SP)		// arg 2 - count
+	CALL	libc_thrwakeup(SB)
+	MOVL	BP, SP
+	POPL	BP
+	RET
+
+TEXT runtime·sched_yield_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	CALL	libc_sched_yield(SB)
+	MOVL	BP, SP
+	POPL	BP
+	RET
+
 // Exit the entire program (like C exit)
 TEXT runtime·exit(SB),NOSPLIT,$-4
 	MOVL	$1, AX
@@ -403,23 +445,6 @@ TEXT set_tcb<>(SB),NOSPLIT,$8
 	MOVL	$0xf1, 0xf1		// crash
 	RET
 
-TEXT runtime·osyield(SB),NOSPLIT,$-4
-	MOVL	$298, AX		// sys_sched_yield
-	INT	$0x80
-	RET
-
-TEXT runtime·thrsleep(SB),NOSPLIT,$-4
-	MOVL	$94, AX			// sys___thrsleep
-	INT	$0x80
-	MOVL	AX, ret+20(FP)
-	RET
-
-TEXT runtime·thrwakeup(SB),NOSPLIT,$-4
-	MOVL	$301, AX		// sys___thrwakeup
-	INT	$0x80
-	MOVL	AX, ret+8(FP)
-	RET
-
 TEXT runtime·sysctl(SB),NOSPLIT,$28
 	LEAL	mib+0(FP), SI
 	LEAL	4(SP), DI
-- 
GitLab


From 83ac59b1a55a4ae728393b445e2d2438f930b767 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Fri, 30 Apr 2021 13:57:12 -0400
Subject: [PATCH 1895/2400] cmd/internal/archive: make error message contain
 printable characters only

Use %q instead of %s to print unchecked bytes. Also strip the
"\x00" byte, as "go116ld" reads better than "\x00go116ld".

Change-Id: Id3d1f426ea91d53a55b928dac4a68e1333b80158
Reviewed-on: https://go-review.googlesource.com/c/go/+/315750
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/internal/archive/archive.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/internal/archive/archive.go b/src/cmd/internal/archive/archive.go
index d1d51b2855..da1f293243 100644
--- a/src/cmd/internal/archive/archive.go
+++ b/src/cmd/internal/archive/archive.go
@@ -109,7 +109,7 @@ var (
 type ErrGoObjOtherVersion struct{ magic []byte }
 
 func (e ErrGoObjOtherVersion) Error() string {
-	return fmt.Sprintf("go object of a different version: %s", e.magic)
+	return fmt.Sprintf("go object of a different version: %q", e.magic)
 }
 
 // An objReader is an object file reader.
@@ -425,7 +425,7 @@ func (r *objReader) parseObject(o *GoObj, size int64) error {
 	}
 	if !bytes.Equal(p, []byte(goobj.Magic)) {
 		if bytes.HasPrefix(p, []byte("\x00go1")) && bytes.HasSuffix(p, []byte("ld")) {
-			return r.error(ErrGoObjOtherVersion{p})
+			return r.error(ErrGoObjOtherVersion{p[1:]}) // strip the \x00 byte
 		}
 		return r.error(errCorruptObject)
 	}
-- 
GitLab


From afa58ddf5a17a3618a24baf161b06cf0e066cb88 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Wed, 28 Apr 2021 18:26:54 -0400
Subject: [PATCH 1896/2400] cmd/compile: revise block/func end sentinels in
 debug analysis

The SSA code for debug variable location analysis (for DWARF) has two
special 'sentinel' values that it uses to handshake with the
debugInfo.GetPC callback when capturing the PC values of debug
variable ranges after prog generatoin: "BlockStart" and "BlockEnd".

"BlockStart" has the expected semantics: it means "the PC value of the
first instruction of block B", but "BlockEnd" does not mean "PC value
of the last instruction of block B", but rather it is implemented as
"the PC value of the last instruction of the function". This causes
confusion when reading the code, and seems to to result in implementation
flaws in the past, leading to incorrect ranges in some cases.

To help with this, add a new sentinel "FuncEnd" (which has the "last
inst in the function" semantics) and change the implementation of
"BlockEnd" to actually mean what its name implies (last inst in
block).

Updates #45720.

Change-Id: Ic3497fb60413e898d2bfe27805c3db56483d12a2
Reviewed-on: https://go-review.googlesource.com/c/go/+/314930
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/ssa/debug.go  | 8 +++++++-
 src/cmd/compile/internal/ssagen/ssa.go | 8 ++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ssa/debug.go b/src/cmd/compile/internal/ssa/debug.go
index d725fc526e..46743f54eb 100644
--- a/src/cmd/compile/internal/ssa/debug.go
+++ b/src/cmd/compile/internal/ssa/debug.go
@@ -152,6 +152,12 @@ var BlockEnd = &Value{
 	Aux: StringToAux("BlockEnd"),
 }
 
+var FuncEnd = &Value{
+	ID:  -30000,
+	Op:  OpInvalid,
+	Aux: StringToAux("FuncEnd"),
+}
+
 // RegisterSet is a bitmap of registers, indexed by Register.num.
 type RegisterSet uint64
 
@@ -948,7 +954,7 @@ func (state *debugState) buildLocationLists(blockLocs []*BlockDebug) {
 
 	// Flush any leftover entries live at the end of the last block.
 	for varID := range state.lists {
-		state.writePendingEntry(VarID(varID), state.f.Blocks[len(state.f.Blocks)-1].ID, BlockEnd.ID)
+		state.writePendingEntry(VarID(varID), state.f.Blocks[len(state.f.Blocks)-1].ID, FuncEnd.ID)
 		list := state.lists[varID]
 		if state.loggingEnabled {
 			if len(list) == 0 {
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index c49350005e..fb35d8044e 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -6964,6 +6964,10 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 		debugInfo := ssa.BuildFuncDebug(base.Ctxt, f, base.Debug.LocationLists > 1, StackOffset)
 		e.curfn.DebugInfo = debugInfo
 		bstart := s.bstart
+		idToIdx := make([]int, f.NumBlocks())
+		for i, b := range f.Blocks {
+			idToIdx[b.ID] = i
+		}
 		// Note that at this moment, Prog.Pc is a sequence number; it's
 		// not a real PC until after assembly, so this mapping has to
 		// be done later.
@@ -6976,6 +6980,10 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 				}
 				return bstart[b].Pc
 			case ssa.BlockEnd.ID:
+				blk := f.Blocks[idToIdx[b]]
+				nv := len(blk.Values)
+				return valueToProgAfter[blk.Values[nv-1].ID].Pc
+			case ssa.FuncEnd.ID:
 				return e.curfn.LSym.Size
 			default:
 				return valueToProgAfter[v].Pc
-- 
GitLab


From c23a32284a5a1e45855915a7401ebb715b837d10 Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Sat, 1 May 2021 04:47:00 +1000
Subject: [PATCH 1897/2400] runtime: work around vet asmdecl checks for
 openbsd/386 mstart_stub

Include a NOP with the SP in order to disable/bypass vet asmdecl checks
for runtime.mstart_stub on openbsd/386. Without this we get:

runtime/sys_openbsd_386.s:33:1: [386] mstart_stub: use of 32(SP) points beyond argument frame

Change-Id: I834ae3dbceffcb5776481b076ec2afe3700671cf
Reviewed-on: https://go-review.googlesource.com/c/go/+/315789
Trust: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Joel Sing <joel@sing.id.au>
---
 src/runtime/sys_openbsd_386.s | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/runtime/sys_openbsd_386.s b/src/runtime/sys_openbsd_386.s
index f1911a588d..2701097c64 100644
--- a/src/runtime/sys_openbsd_386.s
+++ b/src/runtime/sys_openbsd_386.s
@@ -22,6 +22,8 @@ TEXT runtime·setldt(SB),NOSPLIT,$0
 // It just does some low-level setup and then calls mstart.
 // Note: called with the C calling convention.
 TEXT runtime·mstart_stub(SB),NOSPLIT,$28
+	NOP	SP	// tell vet SP changed - stop checking offsets
+
 	// We are already on m's g0 stack.
 
 	// Save callee-save registers.
-- 
GitLab


From 93200b98c75500b80a2bf7cc31c2a72deff2741c Mon Sep 17 00:00:00 2001
From: Matt Harden <matt.harden@gmail.com>
Date: Fri, 30 Apr 2021 01:34:44 +0000
Subject: [PATCH 1898/2400] bufio: mention ErrFinalToken in SplitFunc
 documentation

It is documented elsewhere in the package documentation but this additional
mention of it will hopefully reduce confusion.

Fixes #44261

Change-Id: I4e9d8f4564ebb7fbe047c92ee2cdffedb39f2a31
GitHub-Last-Rev: 64b6421503dfb9396e46f94f9805ff7f8bf2b31b
GitHub-Pull-Request: golang/go#45839
Reviewed-on: https://go-review.googlesource.com/c/go/+/314969
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Rob Pike <r@golang.org>
---
 src/bufio/scan.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/bufio/scan.go b/src/bufio/scan.go
index af46a14fbb..4846d4f733 100644
--- a/src/bufio/scan.go
+++ b/src/bufio/scan.go
@@ -48,7 +48,8 @@ type Scanner struct {
 // and the next token to return to the user, if any, plus an error, if any.
 //
 // Scanning stops if the function returns an error, in which case some of
-// the input may be discarded.
+// the input may be discarded. If that error is ErrFinalToken, scanning
+// stops with no error.
 //
 // Otherwise, the Scanner advances the input. If the token is not nil,
 // the Scanner returns it to the user. If the token is nil, the
-- 
GitLab


From 162d4f9c92cb618e8b434e445a842351160fb84d Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Tue, 27 Apr 2021 12:40:43 -0400
Subject: [PATCH 1899/2400] cmd/compile: regabi support for DWARF location
 expressions

Revise the code that generates DWARF location expressions for input
parameters to get it to work properly with the new register ABI when
optimization is turned off.

The previously implementation assumed stack locations for all
input+output parameters when -N (disable optimization) was in effect.
In the new implementation, a register-resident input parameter is
given a 2-element location list, the first list element pointing to
the ABI register(s) containing the param, and the second element
pointing to the stack home once it has been spilled.

NB, this change fixes a bunch of the Delve pkg/proc unit tests (maybe
about half of the outstanding failures). Still a good number that need
to be investigated, however.

Updates #40724.
Updates #45720.

Change-Id: I743bbb9af187bcdebeb8e690fdd6db58094ca415
Reviewed-on: https://go-review.googlesource.com/c/go/+/314431
Trust: Than McIntosh <thanm@google.com>
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/dwarfgen/dwarf.go |  34 +++
 src/cmd/compile/internal/ssa/debug.go      | 244 ++++++++++++++++++++-
 src/cmd/compile/internal/ssagen/ssa.go     |   7 +-
 3 files changed, 282 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/dwarfgen/dwarf.go b/src/cmd/compile/internal/dwarfgen/dwarf.go
index 0754a8810c..09e1f12a05 100644
--- a/src/cmd/compile/internal/dwarfgen/dwarf.go
+++ b/src/cmd/compile/internal/dwarfgen/dwarf.go
@@ -138,8 +138,11 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 	var vars []*dwarf.Var
 	var decls []*ir.Name
 	var selected ir.NameSet
+
 	if base.Ctxt.Flag_locationlists && base.Ctxt.Flag_optimize && fn.DebugInfo != nil && complexOK {
 		decls, vars, selected = createComplexVars(fnsym, fn)
+	} else if fn.ABI == obj.ABIInternal && base.Flag.N != 0 && complexOK {
+		decls, vars, selected = createABIVars(fnsym, fn, apDecls)
 	} else {
 		decls, vars, selected = createSimpleVars(fnsym, apDecls)
 	}
@@ -314,6 +317,37 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 	}
 }
 
+// createABIVars creates DWARF variables for functions in which the
+// register ABI is enabled but optimization is turned off. It uses a
+// hybrid approach in which register-resident input params are
+// captured with location lists, and all other vars use the "simple"
+// strategy.
+func createABIVars(fnsym *obj.LSym, fn *ir.Func, apDecls []*ir.Name) ([]*ir.Name, []*dwarf.Var, ir.NameSet) {
+
+	// Invoke createComplexVars to generate dwarf vars for input parameters
+	// that are register-allocated according to the ABI rules.
+	decls, vars, selected := createComplexVars(fnsym, fn)
+
+	// Now fill in the remainder of the variables: input parameters
+	// that are not register-resident, output parameters, and local
+	// variables.
+	for _, n := range apDecls {
+		if ir.IsAutoTmp(n) {
+			continue
+		}
+		if _, ok := selected[n]; ok {
+			// already handled
+			continue
+		}
+
+		decls = append(decls, n)
+		vars = append(vars, createSimpleVar(fnsym, n))
+		selected.Add(n)
+	}
+
+	return decls, vars, selected
+}
+
 // createComplexVars creates recomposed DWARF vars with location lists,
 // suitable for describing optimized code.
 func createComplexVars(fnsym *obj.LSym, fn *ir.Func) ([]*ir.Name, []*dwarf.Var, ir.NameSet) {
diff --git a/src/cmd/compile/internal/ssa/debug.go b/src/cmd/compile/internal/ssa/debug.go
index 46743f54eb..4401f56703 100644
--- a/src/cmd/compile/internal/ssa/debug.go
+++ b/src/cmd/compile/internal/ssa/debug.go
@@ -5,6 +5,7 @@
 package ssa
 
 import (
+	"cmd/compile/internal/abi"
 	"cmd/compile/internal/ir"
 	"cmd/internal/dwarf"
 	"cmd/internal/obj"
@@ -1124,8 +1125,11 @@ func (debugInfo *FuncDebug) PutLocationList(list []byte, ctxt *obj.Link, listSym
 	listSym.WriteInt(ctxt, listSym.Size, ctxt.Arch.PtrSize, 0)
 }
 
-// Pack a value and block ID into an address-sized uint, returning ~0 if they
-// don't fit.
+// Pack a value and block ID into an address-sized uint, returning encoded
+// value and boolean indicating whether the encoding succeeded.  For
+// 32-bit architectures the process may fail for very large procedures
+// (the theory being that it's ok to have degraded debug quality in
+// this case).
 func encodeValue(ctxt *obj.Link, b, v ID) (uint64, bool) {
 	if ctxt.Arch.PtrSize == 8 {
 		result := uint64(b)<<32 | uint64(uint32(v))
@@ -1192,3 +1196,239 @@ func readPtr(ctxt *obj.Link, buf []byte) uint64 {
 	}
 
 }
+
+// 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)
+	if !startOK || !endOK {
+		// This could happen if someone writes a function that uses
+		// >65K values on a 32-bit platform. Hopefully a degraded debugging
+		// experience is ok in that case.
+		return nil, 0
+	}
+	list = appendPtr(ctxt, list, start)
+	list = appendPtr(ctxt, list, end)
+
+	// Where to write the length of the location description once
+	// we know how big it is.
+	sizeIdx := len(list)
+	list = list[:len(list)+2]
+	return list, sizeIdx
+}
+
+// locatePrologEnd walks the entry block of a function with incoming
+// register arguments and locates the last instruction in the prolog
+// that spills a register arg. It returns the ID of that instruction
+// Example:
+//
+//   b1:
+//       v3 = ArgIntReg <int> {p1+0} [0] : AX
+//       ... more arg regs ..
+//       v4 = ArgFloatReg <float32> {f1+0} [0] : X0
+//       v52 = MOVQstore <mem> {p1} v2 v3 v1
+//       ... more stores ...
+//       v68 = MOVSSstore <mem> {f4} v2 v67 v66
+//       v38 = MOVQstoreconst <mem> {blob} [val=0,off=0] v2 v32
+//
+// Important: locatePrologEnd is expected to work properly only with
+// optimization turned off (e.g. "-N"). If optimization is enabled
+// we can't be assured of finding all input arguments spilled in the
+// entry block prolog.
+func locatePrologEnd(f *Func) ID {
+
+	// returns true if this instruction looks like it moves an ABI
+	// register to the stack, along with the value being stored.
+	isRegMoveLike := func(v *Value) (bool, ID) {
+		n, ok := v.Aux.(*ir.Name)
+		var r ID
+		if !ok || n.Class != ir.PPARAM {
+			return false, r
+		}
+		regInputs, memInputs, spInputs := 0, 0, 0
+		for _, a := range v.Args {
+			if a.Op == OpArgIntReg || a.Op == OpArgFloatReg {
+				regInputs++
+				r = a.ID
+			} else if a.Type.IsMemory() {
+				memInputs++
+			} else if a.Op == OpSP {
+				spInputs++
+			} else {
+				return false, r
+			}
+		}
+		return v.Type.IsMemory() && memInputs == 1 &&
+			regInputs == 1 && spInputs == 1, r
+	}
+
+	// OpArg*Reg values we've seen so far on our forward walk,
+	// for which we have not yet seen a corresponding spill.
+	regArgs := make([]ID, 0, 32)
+
+	// removeReg tries to remove a value from regArgs, returning true
+	// if found and removed, or false otherwise.
+	removeReg := func(r ID) bool {
+		for i := 0; i < len(regArgs); i++ {
+			if regArgs[i] == r {
+				regArgs = append(regArgs[:i], regArgs[i+1:]...)
+				return true
+			}
+		}
+		return false
+	}
+
+	// Walk forwards through the block. When we see OpArg*Reg, record
+	// the value it produces in the regArgs list. When see a store that uses
+	// the value, remove the entry. When we hit the last store (use)
+	// then we've arrived at the end of the prolog.
+	for k, v := range f.Entry.Values {
+		if v.Op == OpArgIntReg || v.Op == OpArgFloatReg {
+			regArgs = append(regArgs, v.ID)
+			continue
+		}
+		if ok, r := isRegMoveLike(v); ok {
+			if removed := removeReg(r); removed {
+				if len(regArgs) == 0 {
+					// Found our last spill; return the value after
+					// it. Note that it is possible that this spill is
+					// the last instruction in the block. If so, then
+					// return the "end of block" sentinel.
+					if k < len(f.Entry.Values)-1 {
+						return f.Entry.Values[k+1].ID
+					}
+					return BlockEnd.ID
+				}
+			}
+		}
+		if v.Op.IsCall() {
+			// if we hit a call, we've gone too far.
+			return v.ID
+		}
+	}
+	// nothing found
+	return ID(-1)
+}
+
+// isNamedRegParam returns true if the param corresponding to "p"
+// is a named, non-blank input parameter assigned to one or more
+// registers.
+func isNamedRegParam(p abi.ABIParamAssignment) bool {
+	if p.Name == nil {
+		return false
+	}
+	n := p.Name.(*ir.Name)
+	if n.Sym() == nil || n.Sym().IsBlank() {
+		return false
+	}
+	if len(p.Registers) == 0 {
+		return false
+	}
+	return true
+}
+
+// BuildFuncDebugNoOptimized constructs a FuncDebug object with
+// entries corresponding to the register-resident input parameters for
+// the function "f"; it is used when we are compiling without
+// optimization but the register ABI is enabled. For each reg param,
+// it constructs a 2-element location list: the first element holds
+// the input register, and the second element holds the stack location
+// of the param (the assumption being that when optimization is off,
+// each input param reg will be spilled in the prolog.
+func BuildFuncDebugNoOptimized(ctxt *obj.Link, f *Func, loggingEnabled bool, stackOffset func(LocalSlot) int32) *FuncDebug {
+	fd := FuncDebug{}
+
+	pri := f.ABISelf.ABIAnalyzeFuncType(f.Type.FuncType())
+
+	// Look to see if we have any named register-promoted parameters.
+	// If there are none, bail early and let the caller sort things
+	// out for the remainder of the params/locals.
+	numRegParams := 0
+	for _, inp := range pri.InParams() {
+		if isNamedRegParam(inp) {
+			numRegParams++
+		}
+	}
+	if numRegParams == 0 {
+		return &fd
+	}
+
+	// Allocate location lists.
+	fd.LocationLists = make([][]byte, numRegParams)
+
+	// Locate the value corresponding to the last spill of
+	// an input register.
+	afterPrologVal := locatePrologEnd(f)
+	if afterPrologVal == ID(-1) {
+		panic(fmt.Sprintf("internal error: f=%s: can't locate after prolog value", f.Name))
+	}
+
+	// Walk the input params again and process the register-resident elements.
+	pidx := 0
+	for _, inp := range pri.InParams() {
+		if !isNamedRegParam(inp) {
+			// will be sorted out elsewhere
+			continue
+		}
+
+		n := inp.Name.(*ir.Name)
+		sl := LocalSlot{N: n, Type: inp.Type, Off: 0}
+		fd.Vars = append(fd.Vars, n)
+		fd.Slots = append(fd.Slots, sl)
+		slid := len(fd.VarSlots)
+		fd.VarSlots = append(fd.VarSlots, []SlotID{SlotID(slid)})
+
+		// 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, fd.LocationLists[pidx],
+			BlockStart.ID, afterPrologVal)
+		if list == nil {
+			pidx++
+			continue
+		}
+		rtypes, _ := inp.RegisterTypesAndOffsets()
+		for k, r := range inp.Registers {
+			reg := ObjRegForAbiReg(r, f.Config)
+			dwreg := ctxt.Arch.DWARFRegisters[reg]
+			if dwreg < 32 {
+				list = append(list, dwarf.DW_OP_reg0+byte(dwreg))
+			} else {
+				list = append(list, dwarf.DW_OP_regx)
+				list = dwarf.AppendUleb128(list, uint64(dwreg))
+			}
+			if len(inp.Registers) > 1 {
+				list = append(list, dwarf.DW_OP_piece)
+				ts := rtypes[k].Width
+				list = dwarf.AppendUleb128(list, uint64(ts))
+			}
+		}
+		// fill in length of location expression element
+		ctxt.Arch.ByteOrder.PutUint16(list[sizeIdx:], uint16(len(list)-sizeIdx-2))
+
+		// 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,
+			afterPrologVal, FuncEnd.ID)
+		if list == nil {
+			pidx++
+			continue
+		}
+		soff := stackOffset(sl)
+		if soff == 0 {
+			list = append(list, dwarf.DW_OP_call_frame_cfa)
+		} else {
+			list = append(list, dwarf.DW_OP_fbreg)
+			list = dwarf.AppendSleb128(list, int64(soff))
+		}
+		// fill in size
+		ctxt.Arch.ByteOrder.PutUint16(list[sizeIdx:], uint16(len(list)-sizeIdx-2))
+
+		fd.LocationLists[pidx] = list
+		pidx++
+	}
+	return &fd
+}
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index fb35d8044e..5eda8c4b1c 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -6961,7 +6961,12 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 	}
 
 	if base.Ctxt.Flag_locationlists {
-		debugInfo := ssa.BuildFuncDebug(base.Ctxt, f, base.Debug.LocationLists > 1, StackOffset)
+		var debugInfo *ssa.FuncDebug
+		if e.curfn.ABI == obj.ABIInternal && base.Flag.N != 0 {
+			debugInfo = ssa.BuildFuncDebugNoOptimized(base.Ctxt, f, base.Debug.LocationLists > 1, StackOffset)
+		} else {
+			debugInfo = ssa.BuildFuncDebug(base.Ctxt, f, base.Debug.LocationLists > 1, StackOffset)
+		}
 		e.curfn.DebugInfo = debugInfo
 		bstart := s.bstart
 		idToIdx := make([]int, f.NumBlocks())
-- 
GitLab


From d19eece91f7825556eadfef08e7011e22a719ec0 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Thu, 29 Apr 2021 11:47:18 -0400
Subject: [PATCH 1900/2400] cmd/compile: handle field padding for
 register-passed structs

When constructing multi-piece DWARF location expressions for
struct-typed parameters using the register ABI, make sure that the
location expressions generated properly reflect padding between
elements (this is required by debuggers). Example:

   type small struct { x uint16 ; y uint8 ; z int32 }
   func ABC(p1 int, p2 small, f1 float32) {
     ...

In the DWARF location expression for "p2" on entry to the routine, we
need pieces for each field, but for debuggers (such as GDB) to work
properly, we also need to describe the padding between elements. Thus
instead of

  <rbx> DW_OP_piece 2 <rcx> DW_OP_piece 1 <rdi> DW_OP_piece 4

we need to emit

  <rbx> DW_OP_piece 2 <rcx> DW_OP_piece 1 DW_OP_piece 1 <rdi> DW_OP_piece 4

This patch adds a new helper routine in abiutils to compute the
correct padding amounts for a struct type, a unit test for the helper,
and updates the debug generation code to call the helper and insert
apadding "piece" ops in the right spots.

Updates #40724.
Updates #45720.

Change-Id: Ie208bee25776b9eb70642041869e65e4fa65a005
Reviewed-on: https://go-review.googlesource.com/c/go/+/315071
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/abi/abiutils.go      | 48 +++++++++++++++++++
 src/cmd/compile/internal/ssa/debug.go         |  6 +++
 .../compile/internal/test/abiutils_test.go    | 36 ++++++++++++++
 3 files changed, 90 insertions(+)

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index e192adb5e1..cb8e9d7b0f 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -790,3 +790,51 @@ func (state *assignState) assignParamOrReturn(pt *types.Type, n types.Object, is
 		return state.stackAllocate(pt, n)
 	}
 }
+
+// ComputePadding returns a list of "post element" padding values in
+// the case where we have a structure being passed in registers. Give
+// a param assignment corresponding to a struct, it returns a list of
+// contaning padding values for each field, e.g. the Kth element in
+// the list is the amount of padding between field K and the following
+// field. For things that are not struct (or structs without padding)
+// it returns a list of zeros. Example:
+//
+// type small struct {
+//   x uint16
+//   y uint8
+//   z int32
+//   w int32
+// }
+//
+// For this struct we would return a list [0, 1, 0, 0], meaning that
+// we have one byte of padding after the second field, and no bytes of
+// padding after any of the other fields. Input parameter "storage"
+// is with enough capacity to accommodate padding elements for
+// the architected register set in question.
+func (pa *ABIParamAssignment) ComputePadding(storage []uint64) []uint64 {
+	nr := len(pa.Registers)
+	padding := storage[:nr]
+	for i := 0; i < nr; i++ {
+		padding[i] = 0
+	}
+	if pa.Type.Kind() != types.TSTRUCT || nr == 0 {
+		return padding
+	}
+	types := make([]*types.Type, 0, nr)
+	types = appendParamTypes(types, pa.Type)
+	if len(types) != nr {
+		panic("internal error")
+	}
+	off := int64(0)
+	for idx, t := range types {
+		ts := t.Size()
+		off += int64(ts)
+		if idx < len(types)-1 {
+			noff := align(off, types[idx+1])
+			if noff != off {
+				padding[idx] = uint64(noff - off)
+			}
+		}
+	}
+	return padding
+}
diff --git a/src/cmd/compile/internal/ssa/debug.go b/src/cmd/compile/internal/ssa/debug.go
index 4401f56703..ee522f41ef 100644
--- a/src/cmd/compile/internal/ssa/debug.go
+++ b/src/cmd/compile/internal/ssa/debug.go
@@ -1391,6 +1391,8 @@ func BuildFuncDebugNoOptimized(ctxt *obj.Link, f *Func, loggingEnabled bool, sta
 			continue
 		}
 		rtypes, _ := inp.RegisterTypesAndOffsets()
+		padding := make([]uint64, 0, 32)
+		padding = inp.ComputePadding(padding)
 		for k, r := range inp.Registers {
 			reg := ObjRegForAbiReg(r, f.Config)
 			dwreg := ctxt.Arch.DWARFRegisters[reg]
@@ -1404,6 +1406,10 @@ func BuildFuncDebugNoOptimized(ctxt *obj.Link, f *Func, loggingEnabled bool, sta
 				list = append(list, dwarf.DW_OP_piece)
 				ts := rtypes[k].Width
 				list = dwarf.AppendUleb128(list, uint64(ts))
+				if padding[k] > 0 {
+					list = append(list, dwarf.DW_OP_piece)
+					list = dwarf.AppendUleb128(list, padding[k])
+				}
 			}
 		}
 		// fill in length of location expression element
diff --git a/src/cmd/compile/internal/test/abiutils_test.go b/src/cmd/compile/internal/test/abiutils_test.go
index daff99a799..b752c48612 100644
--- a/src/cmd/compile/internal/test/abiutils_test.go
+++ b/src/cmd/compile/internal/test/abiutils_test.go
@@ -14,6 +14,7 @@ import (
 	"cmd/internal/obj"
 	"cmd/internal/obj/x86"
 	"cmd/internal/src"
+	"fmt"
 	"os"
 	"testing"
 )
@@ -359,3 +360,38 @@ func TestABINumParamRegs(t *testing.T) {
 	nrtest(t, a, 12)
 
 }
+
+func TestABIUtilsComputePadding(t *testing.T) {
+	// type s1 { f1 int8; f2 int16; f3 struct{}; f4 int32; f5 int64 }
+	i8 := types.Types[types.TINT8]
+	i16 := types.Types[types.TINT16]
+	i32 := types.Types[types.TINT32]
+	i64 := types.Types[types.TINT64]
+	emptys := mkstruct([]*types.Type{})
+	s1 := mkstruct([]*types.Type{i8, i16, emptys, i32, i64})
+	// func (p1 int32, p2 s1, p3 emptys, p4 [1]int32)
+	a1 := types.NewArray(i32, 1)
+	ft := mkFuncType(nil, []*types.Type{i32, s1, emptys, a1}, []*types.Type{})
+
+	// Run abitest() just to document what we're expected to see.
+	exp := makeExpectedDump(`
+        IN 0: R{ I0 } spilloffset: 0 typ: int32
+        IN 1: R{ I1 I2 I3 I4 } spilloffset: 8 typ: struct { int8; int16; struct {}; int32; int64 }
+        IN 2: R{ } offset: 0 typ: struct {}
+        IN 3: R{ I5 } spilloffset: 24 typ: [1]int32
+        offsetToSpillArea: 0 spillAreaSize: 32
+`)
+	abitest(t, ft, exp)
+
+	// Analyze with full set of registers, then call ComputePadding
+	// on the second param, verifying the results.
+	regRes := configAMD64.ABIAnalyze(ft, false)
+	padding := make([]uint64, 32)
+	parm := regRes.InParams()[1]
+	padding = parm.ComputePadding(padding)
+	want := "[1 1 1 0]"
+	got := fmt.Sprintf("%+v", padding)
+	if got != want {
+		t.Errorf("padding mismatch: wanted %q got %q\n", got, want)
+	}
+}
-- 
GitLab


From 41afd3af42bd8028a1740c30a2b745105b4063d2 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Fri, 30 Apr 2021 11:15:44 -0400
Subject: [PATCH 1901/2400] cmd/compile: fix abbrev selection for output params

In Cl 302071 we changed the compiler to use a different recipe for
selecting the DWARF frame offset for output parameters, to reflect the
fact that registerized output params don't have a stack memory
location on entry to the function. In the process, however, we
switched from using an abbrev pf DW_ABRV_PARAM to an abbrev of
DW_ABRV_AUTO, which means that Delve can't recognize them correctly.
To fix the problem, switch back to picking the correct abbrev entry,
while leaving the new offset recipe intact.

Updates #40724.
Updates #45720.

Change-Id: If721c9255bcd030177806576cde3450563f7a235
Reviewed-on: https://go-review.googlesource.com/c/go/+/315610
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/dwarfgen/dwarf.go |  25 +++--
 src/cmd/link/internal/ld/dwarf_test.go     | 110 +++++++++++++++++++++
 2 files changed, 125 insertions(+), 10 deletions(-)

diff --git a/src/cmd/compile/internal/dwarfgen/dwarf.go b/src/cmd/compile/internal/dwarfgen/dwarf.go
index 09e1f12a05..422c7e66c4 100644
--- a/src/cmd/compile/internal/dwarfgen/dwarf.go
+++ b/src/cmd/compile/internal/dwarfgen/dwarf.go
@@ -268,23 +268,28 @@ func createSimpleVar(fnsym *obj.LSym, n *ir.Name) *dwarf.Var {
 	var abbrev int
 	var offs int64
 
-	switch n.Class {
-	case ir.PPARAM, ir.PPARAMOUT:
-		if !n.IsOutputParamInRegisters() {
-			abbrev = dwarf.DW_ABRV_PARAM
-			offs = n.FrameOffset() + base.Ctxt.FixedFrameSize()
-			break
-		}
-		fallthrough
-	case ir.PAUTO:
+	localAutoOffset := func() int64 {
 		offs = n.FrameOffset()
-		abbrev = dwarf.DW_ABRV_AUTO
 		if base.Ctxt.FixedFrameSize() == 0 {
 			offs -= int64(types.PtrSize)
 		}
 		if buildcfg.FramePointerEnabled {
 			offs -= int64(types.PtrSize)
 		}
+		return offs
+	}
+
+	switch n.Class {
+	case ir.PAUTO:
+		offs = localAutoOffset()
+		abbrev = dwarf.DW_ABRV_AUTO
+	case ir.PPARAM, ir.PPARAMOUT:
+		abbrev = dwarf.DW_ABRV_PARAM
+		if n.IsOutputParamInRegisters() {
+			offs = localAutoOffset()
+		} else {
+			offs = n.FrameOffset() + base.Ctxt.FixedFrameSize()
+		}
 
 	default:
 		base.Fatalf("createSimpleVar unexpected class %v for node %v", n.Class, n)
diff --git a/src/cmd/link/internal/ld/dwarf_test.go b/src/cmd/link/internal/ld/dwarf_test.go
index 56dc4753b2..5cc4800e2a 100644
--- a/src/cmd/link/internal/ld/dwarf_test.go
+++ b/src/cmd/link/internal/ld/dwarf_test.go
@@ -19,6 +19,7 @@ import (
 	"path/filepath"
 	"reflect"
 	"runtime"
+	"sort"
 	"strconv"
 	"strings"
 	"testing"
@@ -1641,3 +1642,112 @@ func TestIssue42484(t *testing.T) {
 	}
 	f.Close()
 }
+
+func TestOutputParamAbbrevAndAttr(t *testing.T) {
+	testenv.MustHaveGoBuild(t)
+
+	if runtime.GOOS == "plan9" {
+		t.Skip("skipping on plan9; no DWARF symbol table in executables")
+	}
+	t.Parallel()
+
+	// This test verifies that the compiler is selecting the correct
+	// DWARF abbreviation for output parameters, and that the
+	// variable parameter attribute is correct for in-params and
+	// out-params.
+
+	const prog = `
+package main
+
+//go:noinline
+func ABC(p1, p2, p3 int, f1, f2, f3 float32, b1 [1024]int) (r1 int, r2 int, r3 [1024]int, r4 byte) {
+	b1[0] = 6
+	r1, r2, r3, r4 = p3, p2, b1, 'a'
+	return
+}
+
+func main() {
+	a := [1024]int{}
+	v1, v2, v3, v4 := ABC(1, 2, 3, 1.0, 2.0, 1.0, a)
+	println(v1, v2, v3[0], v4)
+}
+`
+	dir := t.TempDir()
+	f := gobuild(t, dir, prog, NoOpt)
+	defer f.Close()
+
+	d, err := f.DWARF()
+	if err != nil {
+		t.Fatalf("error reading DWARF: %v", err)
+	}
+
+	rdr := d.Reader()
+	ex := examiner{}
+	if err := ex.populate(rdr); err != nil {
+		t.Fatalf("error reading DWARF: %v", err)
+	}
+
+	// Locate the main.ABC DIE
+	abcs := ex.Named("main.ABC")
+	if len(abcs) == 0 {
+		t.Fatalf("unable to locate DIE for main.ABC")
+	}
+	if len(abcs) != 1 {
+		t.Fatalf("more than one main.ABC DIE")
+	}
+	abcdie := abcs[0]
+
+	// Vet the DIE
+	if abcdie.Tag != dwarf.TagSubprogram {
+		t.Fatalf("unexpected tag %v on main.ABC DIE", abcdie.Tag)
+	}
+
+	// A setting of DW_AT_variable_parameter indicates that the
+	// param in question is an output parameter; we want to see this
+	// attribute set to TRUE for all Go return params. It would be
+	// OK to have it missing for input parameters, but for the moment
+	// we verify that the attr is present but set to false.
+
+	// Values in this map:
+	//
+	//   0: <no param of this name>
+	//  -1: varparm attr not found
+	//   1: varparm found with value false
+	//   2: varparm found with value true
+	//
+	foundParams := make(map[string]int)
+
+	// Walk ABCs's children looking for params.
+	abcIdx := ex.idxFromOffset(abcdie.Offset)
+	childDies := ex.Children(abcIdx)
+	for _, child := range childDies {
+		if child.Tag == dwarf.TagFormalParameter {
+			st := -1
+			if vp, ok := child.Val(dwarf.AttrVarParam).(bool); ok {
+				if vp {
+					st = 2
+				} else {
+					st = 1
+				}
+			}
+			if name, ok := child.Val(dwarf.AttrName).(string); ok {
+				foundParams[name] = st
+			}
+		}
+	}
+
+	// Digest the result.
+	found := make([]string, 0, len(foundParams))
+	for k, v := range foundParams {
+		found = append(found, fmt.Sprintf("%s:%d", k, v))
+	}
+	sort.Strings(found)
+
+	// Make sure we see all of the expected params, that they have
+	// the varparam attr, and the varparm is set for the returns.
+	expected := "[b1:1 f1:1 f2:1 f3:1 p1:1 p2:1 p3:1 r1:2 r2:2 r3:2 r4:2]"
+	if fmt.Sprintf("%+v", found) != expected {
+		t.Errorf("param check failed, wanted %s got %s\n",
+			expected, found)
+	}
+}
-- 
GitLab


From 0bbfc5c31eb4cb77f12e10c73d5462377e66b06c Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Tue, 17 Nov 2020 19:54:31 -0500
Subject: [PATCH 1902/2400] runtime: break up large calls to
 memclrNoHeapPointers to allow preemption

If something "huge" is allocated, and the zeroing is trivial (no pointers
involved) then zero it by chunks in a loop so that preemption can occur,
not all in a single non-preemptible call.

Benchmarking suggests that 256K is the best chunk size.

Updates #42642.

Change-Id: I94015e467eaa098c59870e479d6d83bc88efbfb4
Reviewed-on: https://go-review.googlesource.com/c/go/+/270943
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/malloc.go   | 40 +++++++++++++++++++++++++++++++++++++++-
 src/runtime/mcache.go   |  9 ++++++---
 src/runtime/mcentral.go |  2 +-
 src/runtime/mheap.go    |  7 +++++--
 4 files changed, 51 insertions(+), 7 deletions(-)

diff --git a/src/runtime/malloc.go b/src/runtime/malloc.go
index 3db884f498..81e5225883 100644
--- a/src/runtime/malloc.go
+++ b/src/runtime/malloc.go
@@ -979,6 +979,9 @@ func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 	var span *mspan
 	var x unsafe.Pointer
 	noscan := typ == nil || typ.ptrdata == 0
+	// In some cases block zeroing can profitably (for latency reduction purposes)
+	// be delayed till preemption is possible; isZeroed tracks that state.
+	isZeroed := true
 	if size <= maxSmallSize {
 		if noscan && size < maxTinySize {
 			// Tiny allocator.
@@ -1074,7 +1077,9 @@ func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 		}
 	} else {
 		shouldhelpgc = true
-		span = c.allocLarge(size, needzero, noscan)
+		// For large allocations, keep track of zeroed state so that
+		// bulk zeroing can be happen later in a preemptible context.
+		span, isZeroed = c.allocLarge(size, needzero && !noscan, noscan)
 		span.freeindex = 1
 		span.allocCount = 1
 		x = unsafe.Pointer(span.base())
@@ -1133,6 +1138,12 @@ func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 	mp.mallocing = 0
 	releasem(mp)
 
+	// Pointerfree data can be zeroed late in a context where preemption can occur.
+	// x will keep the memory alive.
+	if !isZeroed && needzero {
+		memclrNoHeapPointersChunked(size, x)
+	}
+
 	if debug.malloc {
 		if debug.allocfreetrace != 0 {
 			tracealloc(x, size, typ)
@@ -1185,6 +1196,33 @@ func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 	return x
 }
 
+// memclrNoHeapPointersChunked repeatedly calls memclrNoHeapPointers
+// on chunks of the buffer to be zeroed, with opportunities for preemption
+// along the way.  memclrNoHeapPointers contains no safepoints and also
+// cannot be preemptively scheduled, so this provides a still-efficient
+// block copy that can also be preempted on a reasonable granularity.
+//
+// Use this with care; if the data being cleared is tagged to contain
+// pointers, this allows the GC to run before it is all cleared.
+func memclrNoHeapPointersChunked(size uintptr, x unsafe.Pointer) {
+	v := uintptr(x)
+	// got this from benchmarking. 128k is too small, 512k is too large.
+	const chunkBytes = 256 * 1024
+	vsize := v + size
+	for voff := v; voff < vsize; voff = voff + chunkBytes {
+		if getg().preempt {
+			// may hold locks, e.g., profiling
+			goschedguarded()
+		}
+		// clear min(avail, lump) bytes
+		n := vsize - voff
+		if n > chunkBytes {
+			n = chunkBytes
+		}
+		memclrNoHeapPointers(unsafe.Pointer(voff), n)
+	}
+}
+
 // implementation of new builtin
 // compiler (both frontend and SSA backend) knows the signature
 // of this function
diff --git a/src/runtime/mcache.go b/src/runtime/mcache.go
index 097e4a5ade..a9e959109a 100644
--- a/src/runtime/mcache.go
+++ b/src/runtime/mcache.go
@@ -206,7 +206,10 @@ func (c *mcache) refill(spc spanClass) {
 }
 
 // allocLarge allocates a span for a large object.
-func (c *mcache) allocLarge(size uintptr, needzero bool, noscan bool) *mspan {
+// The boolean result indicates whether the span is known-zeroed.
+// If it did not need to be zeroed, it may not have been zeroed;
+// but if it came directly from the OS, it is already zeroed.
+func (c *mcache) allocLarge(size uintptr, needzero bool, noscan bool) (*mspan, bool) {
 	if size+_PageSize < size {
 		throw("out of memory")
 	}
@@ -221,7 +224,7 @@ func (c *mcache) allocLarge(size uintptr, needzero bool, noscan bool) *mspan {
 	deductSweepCredit(npages*_PageSize, npages)
 
 	spc := makeSpanClass(0, noscan)
-	s := mheap_.alloc(npages, spc, needzero)
+	s, isZeroed := mheap_.alloc(npages, spc, needzero)
 	if s == nil {
 		throw("out of memory")
 	}
@@ -245,7 +248,7 @@ func (c *mcache) allocLarge(size uintptr, needzero bool, noscan bool) *mspan {
 	mheap_.central[spc].mcentral.fullSwept(mheap_.sweepgen).push(s)
 	s.limit = s.base() + size
 	heapBitsForAddr(s.base()).initSpan(s)
-	return s
+	return s, isZeroed
 }
 
 func (c *mcache) releaseAll() {
diff --git a/src/runtime/mcentral.go b/src/runtime/mcentral.go
index 4eeac3be88..6013c94c69 100644
--- a/src/runtime/mcentral.go
+++ b/src/runtime/mcentral.go
@@ -238,7 +238,7 @@ func (c *mcentral) grow() *mspan {
 	npages := uintptr(class_to_allocnpages[c.spanclass.sizeclass()])
 	size := uintptr(class_to_size[c.spanclass.sizeclass()])
 
-	s := mheap_.alloc(npages, c.spanclass, true)
+	s, _ := mheap_.alloc(npages, c.spanclass, true)
 	if s == nil {
 		return nil
 	}
diff --git a/src/runtime/mheap.go b/src/runtime/mheap.go
index a34bab42a4..952c0b21b0 100644
--- a/src/runtime/mheap.go
+++ b/src/runtime/mheap.go
@@ -897,7 +897,8 @@ func (s spanAllocType) manual() bool {
 // spanclass indicates the span's size class and scannability.
 //
 // If needzero is true, the memory for the returned span will be zeroed.
-func (h *mheap) alloc(npages uintptr, spanclass spanClass, needzero bool) *mspan {
+// The boolean returned indicates whether the returned span is zeroed.
+func (h *mheap) alloc(npages uintptr, spanclass spanClass, needzero bool) (*mspan, bool) {
 	// Don't do any operations that lock the heap on the G stack.
 	// It might trigger stack growth, and the stack growth code needs
 	// to be able to allocate heap.
@@ -911,13 +912,15 @@ func (h *mheap) alloc(npages uintptr, spanclass spanClass, needzero bool) *mspan
 		s = h.allocSpan(npages, spanAllocHeap, spanclass)
 	})
 
+	isZeroed := s.needzero == 0
 	if s != nil {
 		if needzero && s.needzero != 0 {
 			memclrNoHeapPointers(unsafe.Pointer(s.base()), s.npages<<_PageShift)
+			isZeroed = true
 		}
 		s.needzero = 0
 	}
-	return s
+	return s, isZeroed
 }
 
 // allocManual allocates a manually-managed span of npage pages.
-- 
GitLab


From faff49aae6e90f7c6a8333f7974a6ca368c01228 Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Thu, 28 Jan 2021 23:43:33 +1100
Subject: [PATCH 1903/2400] runtime: switch runtime to libc for openbsd/386

Use libc rather than performing direct system calls for the runtime on
openbsd/386.

Updates #36435

Change-Id: I0cd65368bc824c81f5f98ea24e4f82db5468b170
Reviewed-on: https://go-review.googlesource.com/c/go/+/287653
Trust: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/defs_openbsd_386.go    |   5 +
 src/runtime/os_openbsd_syscall2.go |   4 +-
 src/runtime/proc.go                |   2 +-
 src/runtime/sys_openbsd2.go        |   4 +-
 src/runtime/sys_openbsd_386.s      | 649 ++++++++++++++++-------------
 5 files changed, 375 insertions(+), 289 deletions(-)

diff --git a/src/runtime/defs_openbsd_386.go b/src/runtime/defs_openbsd_386.go
index 6a62261f5b..a866ec880a 100644
--- a/src/runtime/defs_openbsd_386.go
+++ b/src/runtime/defs_openbsd_386.go
@@ -32,6 +32,11 @@ const (
 
 	_PTHREAD_CREATE_DETACHED = 0x1
 
+	_F_SETFD    = 0x2
+	_F_GETFL    = 0x3
+	_F_SETFL    = 0x4
+	_FD_CLOEXEC = 0x1
+
 	_SIGHUP    = 0x1
 	_SIGINT    = 0x2
 	_SIGQUIT   = 0x3
diff --git a/src/runtime/os_openbsd_syscall2.go b/src/runtime/os_openbsd_syscall2.go
index e16f9420db..6aa57a99da 100644
--- a/src/runtime/os_openbsd_syscall2.go
+++ b/src/runtime/os_openbsd_syscall2.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build openbsd && !amd64 && !arm64
-// +build openbsd,!amd64,!arm64
+//go:build openbsd && !386 && !amd64 && !arm64
+// +build openbsd,!386,!amd64,!arm64
 
 package runtime
 
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 497dbd5443..480afd07dd 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -1303,7 +1303,7 @@ func usesLibcall() bool {
 	case "aix", "darwin", "illumos", "ios", "solaris", "windows":
 		return true
 	case "openbsd":
-		return GOARCH == "amd64" || GOARCH == "arm64"
+		return GOARCH == "386" || GOARCH == "amd64" || GOARCH == "arm64"
 	}
 	return false
 }
diff --git a/src/runtime/sys_openbsd2.go b/src/runtime/sys_openbsd2.go
index 16a518df17..91ed04fb48 100644
--- a/src/runtime/sys_openbsd2.go
+++ b/src/runtime/sys_openbsd2.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (openbsd && amd64) || (openbsd && arm64)
-// +build openbsd,amd64 openbsd,arm64
+//go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm64)
+// +build openbsd,386 openbsd,amd64 openbsd,arm64
 
 package runtime
 
diff --git a/src/runtime/sys_openbsd_386.s b/src/runtime/sys_openbsd_386.s
index 2701097c64..e5a95a4899 100644
--- a/src/runtime/sys_openbsd_386.s
+++ b/src/runtime/sys_openbsd_386.s
@@ -169,6 +169,21 @@ TEXT runtime·pthread_create_trampoline(SB),NOSPLIT,$0
 	POPL	BP
 	RET
 
+TEXT runtime·thrkill_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$12, SP
+	MOVL	20(SP), DX		// pointer to args
+	MOVL	0(DX), AX
+	MOVL	4(DX), BX
+	MOVL	AX, 0(SP)		// arg 1 - tid
+	MOVL	BX, 4(SP)		// arg 2 - signal
+	MOVL	$0, 8(SP)		// arg 3 - tcb
+	CALL	libc_thrkill(SB)
+	MOVL	BP, SP
+	POPL	BP
+	RET
+
 TEXT runtime·thrsleep_trampoline(SB),NOSPLIT,$0
 	PUSHL	BP
 	MOVL	SP, BP
@@ -203,6 +218,42 @@ TEXT runtime·thrwakeup_trampoline(SB),NOSPLIT,$0
 	POPL	BP
 	RET
 
+TEXT runtime·exit_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$4, SP
+	MOVL	12(SP), DX		// pointer to args
+	MOVL	0(DX), AX
+	MOVL	AX, 0(SP)		// arg 1 - status
+	CALL	libc_exit(SB)
+	MOVL	$0xf1, 0xf1		// crash on failure
+	MOVL	BP, SP
+	POPL	BP
+	RET
+
+TEXT runtime·getthrid_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	CALL	libc_getthrid(SB)
+	NOP	SP			// tell vet SP changed - stop checking offsets
+	MOVL	8(SP), DX		// pointer to return value
+	MOVL	AX, 0(DX)
+	POPL	BP
+	RET
+
+TEXT runtime·raiseproc_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$8, SP
+	MOVL	16(SP), DX
+	MOVL	0(DX), BX
+	CALL	libc_getpid(SB)
+	MOVL	AX, 0(SP)		// arg 1 - pid
+	MOVL	BX, 4(SP)		// arg 2 - signal
+	CALL	libc_kill(SB)
+	MOVL	BP, SP
+	POPL	BP
+	RET
+
 TEXT runtime·sched_yield_trampoline(SB),NOSPLIT,$0
 	PUSHL	BP
 	MOVL	SP, BP
@@ -211,308 +262,338 @@ TEXT runtime·sched_yield_trampoline(SB),NOSPLIT,$0
 	POPL	BP
 	RET
 
-// Exit the entire program (like C exit)
-TEXT runtime·exit(SB),NOSPLIT,$-4
-	MOVL	$1, AX
-	INT	$0x80
-	MOVL	$0xf1, 0xf1		// crash
+TEXT runtime·mmap_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$32, SP
+	MOVL	40(SP), DX		// pointer to args
+	MOVL	0(DX), AX
+	MOVL	4(DX), BX
+	MOVL	8(DX), CX
+	MOVL	AX, 0(SP)		// arg 1 - addr
+	MOVL	BX, 4(SP)		// arg 2 - len
+	MOVL	CX, 8(SP)		// arg 3 - prot
+	MOVL	12(DX), AX
+	MOVL	16(DX), BX
+	MOVL	20(DX), CX
+	MOVL	AX, 12(SP)		// arg 4 - flags
+	MOVL	BX, 16(SP)		// arg 5 - fid
+	MOVL	$0, 20(SP)		// pad
+	MOVL	CX, 24(SP)		// arg 6 - offset (low 32 bits)
+	MOVL	$0, 28(SP)		// offset (high 32 bits)
+	CALL	libc_mmap(SB)
+	MOVL	$0, BX
+	CMPL	AX, $-1
+	JNE	ok
+	CALL	libc_errno(SB)
+	MOVL	(AX), BX
+	MOVL	$0, AX
+ok:
+	MOVL	40(SP), DX
+	MOVL	AX, 24(DX)
+	MOVL	BX, 28(DX)
+	MOVL	BP, SP
+	POPL	BP
 	RET
 
-// func exitThread(wait *uint32)
-TEXT runtime·exitThread(SB),NOSPLIT,$0-4
-	MOVL	$302, AX		// sys___threxit
-	INT	$0x80
-	MOVL	$0xf1, 0xf1		// crash
-	JMP	0(PC)
+TEXT runtime·munmap_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$8, SP
+	MOVL	16(SP), DX		// pointer to args
+	MOVL	0(DX), AX
+	MOVL	4(DX), BX
+	MOVL	AX, 0(SP)		// arg 1 - addr
+	MOVL	BX, 4(SP)		// arg 2 - len
+	CALL	libc_munmap(SB)
+	CMPL	AX, $-1
+	JNE	2(PC)
+	MOVL	$0xf1, 0xf1		// crash on failure
+	MOVL	BP, SP
+	POPL	BP
+	RET
+
+TEXT runtime·madvise_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$12, SP
+	MOVL	20(SP), DX		// pointer to args
+	MOVL	0(DX), AX
+	MOVL	4(DX), BX
+	MOVL	8(DX), CX
+	MOVL	AX, 0(SP)		// arg 1 - addr
+	MOVL	BX, 4(SP)		// arg 2 - len
+	MOVL	CX, 8(SP)		// arg 3 - advice
+	CALL	libc_madvise(SB)
+	// ignore failure - maybe pages are locked
+	MOVL	BP, SP
+	POPL	BP
+	RET
 
-TEXT runtime·open(SB),NOSPLIT,$-4
-	MOVL	$5, AX
-	INT	$0x80
-	JAE	2(PC)
-	MOVL	$-1, AX
-	MOVL	AX, ret+12(FP)
+TEXT runtime·open_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$16, SP
+	MOVL	24(SP), DX		// pointer to args
+	MOVL	0(DX), AX
+	MOVL	4(DX), BX
+	MOVL	8(DX), CX
+	MOVL	AX, 0(SP)		// arg 1 - path
+	MOVL	BX, 4(SP)		// arg 2 - flags
+	MOVL	CX, 8(SP)		// arg 3 - mode
+	MOVL	$0, 12(SP)		// vararg
+	CALL	libc_open(SB)
+	MOVL	BP, SP
+	POPL	BP
 	RET
 
-TEXT runtime·closefd(SB),NOSPLIT,$-4
-	MOVL	$6, AX
-	INT	$0x80
-	JAE	2(PC)
-	MOVL	$-1, AX
-	MOVL	AX, ret+4(FP)
+TEXT runtime·close_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$4, SP
+	MOVL	12(SP), DX
+	MOVL	0(DX), AX
+	MOVL	AX, 0(SP)		// arg 1 - fd
+	CALL	libc_close(SB)
+	MOVL	BP, SP
+	POPL	BP
 	RET
 
-TEXT runtime·read(SB),NOSPLIT,$-4
-	MOVL	$3, AX
-	INT	$0x80
-	JAE	2(PC)
+TEXT runtime·read_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$12, SP
+	MOVL	20(SP), DX		// pointer to args
+	MOVL	0(DX), AX
+	MOVL	4(DX), BX
+	MOVL	8(DX), CX
+	MOVL	AX, 0(SP)		// arg 1 - fd
+	MOVL	BX, 4(SP)		// arg 2 - buf
+	MOVL	CX, 8(SP)		// arg 3 - count
+	CALL	libc_read(SB)
+	CMPL	AX, $-1
+	JNE	noerr
+	CALL	libc_errno(SB)
+	MOVL	(AX), AX
 	NEGL	AX			// caller expects negative errno
-	MOVL	AX, ret+12(FP)
+noerr:
+	MOVL	BP, SP
+	POPL	BP
 	RET
 
-// func pipe() (r, w int32, errno int32)
-TEXT runtime·pipe(SB),NOSPLIT,$8-12
-	MOVL	$263, AX
-	LEAL	r+0(FP), BX
-	MOVL	BX, 4(SP)
-	INT	$0x80
-	MOVL	AX, errno+8(FP)
+TEXT runtime·write_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$12, SP
+	MOVL	20(SP), DX		// pointer to args
+	MOVL	0(DX), AX
+	MOVL	4(DX), BX
+	MOVL	8(DX), CX
+	MOVL	AX, 0(SP)		// arg 1 - fd
+	MOVL	BX, 4(SP)		// arg 2 - buf
+	MOVL	CX, 8(SP)		// arg 3 - count
+	CALL	libc_write(SB)
+	CMPL	AX, $-1
+	JNE	noerr
+	CALL	libc_errno(SB)
+	MOVL	(AX), AX
+	NEGL	AX			// caller expects negative errno
+noerr:
+	MOVL	BP, SP
+	POPL	BP
 	RET
 
-// func pipe2(flags int32) (r, w int32, errno int32)
-TEXT runtime·pipe2(SB),NOSPLIT,$12-16
-	MOVL	$101, AX
-	LEAL	r+4(FP), BX
-	MOVL	BX, 4(SP)
-	MOVL	flags+0(FP), BX
-	MOVL	BX, 8(SP)
-	INT	$0x80
-	MOVL	AX, errno+12(FP)
+TEXT runtime·pipe2_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$8, SP
+	MOVL	16(SP), DX		// pointer to args
+	MOVL	0(DX), AX
+	MOVL	4(DX), BX
+	MOVL	AX, 0(SP)		// arg 1 - fds
+	MOVL	BX, 4(SP)		// arg 2 - flags
+	CALL	libc_pipe2(SB)
+	CMPL	AX, $-1
+	JNE	noerr
+	CALL	libc_errno(SB)
+	MOVL	(AX), AX
+	NEGL	AX			// caller expects negative errno
+noerr:
+	MOVL	BP, SP
+	POPL	BP
+	RET
+
+TEXT runtime·setitimer_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$12, SP
+	MOVL	20(SP), DX		// pointer to args
+	MOVL	0(DX), AX
+	MOVL	4(DX), BX
+	MOVL	8(DX), CX
+	MOVL	AX, 0(SP)		// arg 1 - which
+	MOVL	BX, 4(SP)		// arg 2 - new
+	MOVL	CX, 8(SP)		// arg 3 - old
+	CALL	libc_setitimer(SB)
+	MOVL	BP, SP
+	POPL	BP
+	RET
+
+TEXT runtime·usleep_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$4, SP
+	MOVL	12(SP), DX		// pointer to args
+	MOVL	0(DX), AX
+	MOVL	AX, 0(SP)
+	CALL	libc_usleep(SB)
+	MOVL	BP, SP
+	POPL	BP
+	RET
+
+TEXT runtime·sysctl_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$24, SP
+	MOVL	32(SP), DX		// pointer to args
+	MOVL	0(DX), AX
+	MOVL	4(DX), BX
+	MOVL	8(DX), CX
+	MOVL	AX, 0(SP)		// arg 1 - name
+	MOVL	BX, 4(SP)		// arg 2 - namelen
+	MOVL	CX, 8(SP)		// arg 3 - old
+	MOVL	12(DX), AX
+	MOVL	16(DX), BX
+	MOVL	20(DX), CX
+	MOVL	AX, 12(SP)		// arg 4 - oldlenp
+	MOVL	BX, 16(SP)		// arg 5 - newp
+	MOVL	CX, 20(SP)		// arg 6 - newlen
+	CALL	libc_sysctl(SB)
+	MOVL	BP, SP
+	POPL	BP
+	RET
+
+TEXT runtime·kqueue_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	CALL	libc_kqueue(SB)
+	MOVL	BP, SP
+	POPL	BP
 	RET
 
-TEXT runtime·write1(SB),NOSPLIT,$-4
-	MOVL	$4, AX			// sys_write
-	INT	$0x80
-	JAE	2(PC)
+TEXT runtime·kevent_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$24, SP
+	MOVL	32(SP), DX		// pointer to args
+	MOVL	0(DX), AX
+	MOVL	4(DX), BX
+	MOVL	8(DX), CX
+	MOVL	AX, 0(SP)		// arg 1 - kq
+	MOVL	BX, 4(SP)		// arg 2 - keventt
+	MOVL	CX, 8(SP)		// arg 3 - nch
+	MOVL	12(DX), AX
+	MOVL	16(DX), BX
+	MOVL	20(DX), CX
+	MOVL	AX, 12(SP)		// arg 4 - ev
+	MOVL	BX, 16(SP)		// arg 5 - nev
+	MOVL	CX, 20(SP)		// arg 6 - ts
+	CALL	libc_kevent(SB)
+	CMPL	AX, $-1
+	JNE	noerr
+	CALL	libc_errno(SB)
+	MOVL	(AX), AX
 	NEGL	AX			// caller expects negative errno
-	MOVL	AX, ret+12(FP)
-	RET
-
-TEXT runtime·usleep(SB),NOSPLIT,$24
-	MOVL	$0, DX
-	MOVL	usec+0(FP), AX
-	MOVL	$1000000, CX
-	DIVL	CX
-	MOVL	AX, 12(SP)		// tv_sec - l32
-	MOVL	$0, 16(SP)		// tv_sec - h32
-	MOVL	$1000, AX
-	MULL	DX
-	MOVL	AX, 20(SP)		// tv_nsec
-
-	MOVL	$0, 0(SP)
-	LEAL	12(SP), AX
-	MOVL	AX, 4(SP)		// arg 1 - rqtp
-	MOVL	$0, 8(SP)		// arg 2 - rmtp
-	MOVL	$91, AX			// sys_nanosleep
-	INT	$0x80
-	RET
-
-TEXT runtime·getthrid(SB),NOSPLIT,$0-4
-	MOVL	$299, AX		// sys_getthrid
-	INT	$0x80
-	MOVL	AX, ret+0(FP)
-	RET
-
-TEXT runtime·thrkill(SB),NOSPLIT,$16-8
-	MOVL	$0, 0(SP)
-	MOVL	tid+0(FP), AX
-	MOVL	AX, 4(SP)		// arg 1 - tid
-	MOVL	sig+4(FP), AX
-	MOVL	AX, 8(SP)		// arg 2 - signum
-	MOVL	$0, 12(SP)		// arg 3 - tcb
-	MOVL	$119, AX		// sys_thrkill
-	INT	$0x80
-	RET
-
-TEXT runtime·raiseproc(SB),NOSPLIT,$12
-	MOVL	$20, AX			// sys_getpid
-	INT	$0x80
-	MOVL	$0, 0(SP)
-	MOVL	AX, 4(SP)		// arg 1 - pid
-	MOVL	sig+0(FP), AX
-	MOVL	AX, 8(SP)		// arg 2 - signum
-	MOVL	$122, AX		// sys_kill
-	INT	$0x80
-	RET
-
-TEXT runtime·mmap(SB),NOSPLIT,$36
-	LEAL	addr+0(FP), SI
-	LEAL	4(SP), DI
-	CLD
-	MOVSL				// arg 1 - addr
-	MOVSL				// arg 2 - len
-	MOVSL				// arg 3 - prot
-	MOVSL				// arg 4 - flags
-	MOVSL				// arg 5 - fd
-	MOVL	$0, AX
-	STOSL				// arg 6 - pad
-	MOVSL				// arg 7 - offset
-	MOVL	$0, AX			// top 32 bits of file offset
-	STOSL
-	MOVL	$197, AX		// sys_mmap
-	INT	$0x80
-	JAE	ok
-	MOVL	$0, p+24(FP)
-	MOVL	AX, err+28(FP)
+noerr:
+	MOVL	BP, SP
+	POPL	BP
 	RET
-ok:
-	MOVL	AX, p+24(FP)
-	MOVL	$0, err+28(FP)
+
+TEXT runtime·clock_gettime_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$8, SP
+	MOVL	16(SP), DX		// pointer to args
+	MOVL	0(DX), AX
+	MOVL	4(DX), BX
+	MOVL	AX, 0(SP)		// arg 1 - tp
+	MOVL	BX, 4(SP)		// arg 2 - clock_id
+	CALL	libc_clock_gettime(SB)
+	CMPL	AX, $-1
+	JNE	2(PC)
+	MOVL	$0xf1, 0xf1		// crash on failure
+	MOVL	BP, SP
+	POPL	BP
 	RET
 
-TEXT runtime·munmap(SB),NOSPLIT,$-4
-	MOVL	$73, AX			// sys_munmap
-	INT	$0x80
-	JAE	2(PC)
-	MOVL	$0xf1, 0xf1		// crash
-	RET
-
-TEXT runtime·madvise(SB),NOSPLIT,$-4
-	MOVL	$75, AX			// sys_madvise
-	INT	$0x80
-	JAE	2(PC)
-	MOVL	$-1, AX
-	MOVL	AX, ret+12(FP)
-	RET
-
-TEXT runtime·setitimer(SB),NOSPLIT,$-4
-	MOVL	$69, AX
-	INT	$0x80
-	RET
-
-// func walltime() (sec int64, nsec int32)
-TEXT runtime·walltime(SB), NOSPLIT, $32
-	LEAL	12(SP), BX
-	MOVL	$0, 4(SP)		// arg 1 - clock_id
-	MOVL	BX, 8(SP)		// arg 2 - tp
-	MOVL	$87, AX			// sys_clock_gettime
-	INT	$0x80
-
-	MOVL	12(SP), AX		// sec - l32
-	MOVL	AX, sec_lo+0(FP)
-	MOVL	16(SP), AX		// sec - h32
-	MOVL	AX, sec_hi+4(FP)
-
-	MOVL	20(SP), BX		// nsec
-	MOVL	BX, nsec+8(FP)
-	RET
-
-// int64 nanotime1(void) so really
-// void nanotime1(int64 *nsec)
-TEXT runtime·nanotime1(SB),NOSPLIT,$32
-	LEAL	12(SP), BX
-	MOVL	CLOCK_MONOTONIC, 4(SP)	// arg 1 - clock_id
-	MOVL	BX, 8(SP)		// arg 2 - tp
-	MOVL	$87, AX			// sys_clock_gettime
-	INT	$0x80
-
-	MOVL    16(SP), CX		// sec - h32
-	IMULL   $1000000000, CX
-
-	MOVL    12(SP), AX		// sec - l32
-	MOVL    $1000000000, BX
-	MULL    BX			// result in dx:ax
-
-	MOVL	20(SP), BX		// nsec
-	ADDL	BX, AX
-	ADCL	CX, DX			// add high bits with carry
-
-	MOVL	AX, ret_lo+0(FP)
-	MOVL	DX, ret_hi+4(FP)
-	RET
-
-TEXT runtime·sigaction(SB),NOSPLIT,$-4
-	MOVL	$46, AX			// sys_sigaction
-	INT	$0x80
-	JAE	2(PC)
-	MOVL	$0xf1, 0xf1		// crash
-	RET
-
-TEXT runtime·obsdsigprocmask(SB),NOSPLIT,$-4
-	MOVL	$48, AX			// sys_sigprocmask
-	INT	$0x80
-	JAE	2(PC)
-	MOVL	$0xf1, 0xf1		// crash
-	MOVL	AX, ret+8(FP)
-	RET
-
-TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
-	MOVL	$288, AX		// sys_sigaltstack
-	MOVL	new+0(FP), BX
-	MOVL	old+4(FP), CX
-	INT	$0x80
-	CMPL	AX, $0xfffff001
-	JLS	2(PC)
-	INT	$3
-	RET
-
-TEXT set_tcb<>(SB),NOSPLIT,$8
-	// adjust for ELF: wants to use -4(GS) for g
-	MOVL	tlsbase+0(FP), CX
-	ADDL	$4, CX
-	MOVL	$0, 0(SP)		// syscall gap
-	MOVL	CX, 4(SP)		// arg 1 - tcb
-	MOVL	$329, AX		// sys___set_tcb
-	INT	$0x80
-	JCC	2(PC)
-	MOVL	$0xf1, 0xf1		// crash
-	RET
-
-TEXT runtime·sysctl(SB),NOSPLIT,$28
-	LEAL	mib+0(FP), SI
-	LEAL	4(SP), DI
-	CLD
-	MOVSL				// arg 1 - name
-	MOVSL				// arg 2 - namelen
-	MOVSL				// arg 3 - oldp
-	MOVSL				// arg 4 - oldlenp
-	MOVSL				// arg 5 - newp
-	MOVSL				// arg 6 - newlen
-	MOVL	$202, AX		// sys___sysctl
-	INT	$0x80
-	JCC	4(PC)
-	NEGL	AX
-	MOVL	AX, ret+24(FP)
+TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$16, SP
+	MOVL	24(SP), DX		// pointer to args
+	MOVL	0(DX), AX
+	MOVL	4(DX), BX
+	MOVL	8(DX), CX
+	MOVL	AX, 0(SP)		// arg 1 - fd
+	MOVL	BX, 4(SP)		// arg 2 - cmd
+	MOVL	CX, 8(SP)		// arg 3 - arg
+	MOVL	$0, 12(SP)		// vararg
+	CALL	libc_fcntl(SB)
+	MOVL	BP, SP
+	POPL	BP
 	RET
-	MOVL	$0, AX
-	MOVL	AX, ret+24(FP)
-	RET
-
-// int32 runtime·kqueue(void);
-TEXT runtime·kqueue(SB),NOSPLIT,$0
-	MOVL	$269, AX
-	INT	$0x80
-	JAE	2(PC)
-	NEGL	AX
-	MOVL	AX, ret+0(FP)
-	RET
-
-// int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
-TEXT runtime·kevent(SB),NOSPLIT,$0
-	MOVL	$72, AX			// sys_kevent
-	INT	$0x80
-	JAE	2(PC)
-	NEGL	AX
-	MOVL	AX, ret+24(FP)
-	RET
-
-// int32 runtime·closeonexec(int32 fd);
-TEXT runtime·closeonexec(SB),NOSPLIT,$32
-	MOVL	$92, AX			// sys_fcntl
-	// 0(SP) is where the caller PC would be; kernel skips it
-	MOVL	fd+0(FP), BX
-	MOVL	BX, 4(SP)	// fd
-	MOVL	$2, 8(SP)	// F_SETFD
-	MOVL	$1, 12(SP)	// FD_CLOEXEC
-	INT	$0x80
-	JAE	2(PC)
-	NEGL	AX
-	RET
-
-// func runtime·setNonblock(fd int32)
-TEXT runtime·setNonblock(SB),NOSPLIT,$16-4
-	MOVL	$92, AX // fcntl
-	MOVL	fd+0(FP), BX // fd
-	MOVL	BX, 4(SP)
-	MOVL	$3, 8(SP) // F_GETFL
-	MOVL	$0, 12(SP)
-	INT	$0x80
-	MOVL	fd+0(FP), BX // fd
-	MOVL	BX, 4(SP)
-	MOVL	$4, 8(SP) // F_SETFL
-	ORL	$4, AX // O_NONBLOCK
-	MOVL	AX, 12(SP)
-	MOVL	$92, AX // fcntl
-	INT	$0x80
+
+TEXT runtime·sigaction_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$12, SP
+	MOVL	20(SP), DX		// pointer to args
+	MOVL	0(DX), AX
+	MOVL	4(DX), BX
+	MOVL	8(DX), CX
+	MOVL	AX, 0(SP)		// arg 1 - sig
+	MOVL	BX, 4(SP)		// arg 2 - new
+	MOVL	CX, 8(SP)		// arg 3 - old
+	CALL	libc_sigaction(SB)
+	CMPL	AX, $-1
+	JNE	2(PC)
+	MOVL	$0xf1, 0xf1		// crash on failure
+	MOVL	BP, SP
+	POPL	BP
 	RET
 
-GLOBL runtime·tlsoffset(SB),NOPTR,$4
+TEXT runtime·sigprocmask_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$12, SP
+	MOVL	20(SP), DX		// pointer to args
+	MOVL	0(DX), AX
+	MOVL	4(DX), BX
+	MOVL	8(DX), CX
+	MOVL	AX, 0(SP)		// arg 1 - how
+	MOVL	BX, 4(SP)		// arg 2 - new
+	MOVL	CX, 8(SP)		// arg 3 - old
+	CALL	libc_pthread_sigmask(SB)
+	CMPL	AX, $-1
+	JNE	2(PC)
+	MOVL	$0xf1, 0xf1		// crash on failure
+	MOVL	BP, SP
+	POPL	BP
+	RET
+
+TEXT runtime·sigaltstack_trampoline(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+	SUBL	$8, SP
+	MOVL	16(SP), DX		// pointer to args
+	MOVL	0(DX), AX
+	MOVL	4(DX), BX
+	MOVL	AX, 0(SP)		// arg 1 - new
+	MOVL	BX, 4(SP)		// arg 2 - old
+	CALL	libc_sigaltstack(SB)
+	CMPL	AX, $-1
+	JNE	2(PC)
+	MOVL	$0xf1, 0xf1		// crash on failure
+	MOVL	BP, SP
+	POPL	BP
+	RET
-- 
GitLab


From 8e91458b19b19584f2026c227265a02724700a55 Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Thu, 28 Jan 2021 23:50:30 +1100
Subject: [PATCH 1904/2400] runtime,syscall: convert syscall on openbsd/386 to
 libc

Convert the syscall package on openbsd/386 to use libc rather than performing
direct system calls.

Updates #36435

Change-Id: Ifcfbca0e6b933762596a564243caa850dac01442
Reviewed-on: https://go-review.googlesource.com/c/go/+/287654
Trust: Joel Sing <joel@sing.id.au>
Run-TryBot: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/sys_openbsd3.go         |   4 +-
 src/runtime/sys_openbsd_386.s       | 369 ++++++++++++
 src/syscall/asm_openbsd_386.s       |  32 +
 src/syscall/asm_unix_386.s          |   2 +-
 src/syscall/exec_bsd.go             |   4 +-
 src/syscall/exec_libc2.go           |   4 +-
 src/syscall/exec_unix.go            |   2 +-
 src/syscall/mkall.sh                |   3 +-
 src/syscall/syscall_openbsd1.go     |   4 +-
 src/syscall/syscall_openbsd_libc.go |   4 +-
 src/syscall/zsyscall_openbsd_386.go | 867 +++++++++++++++++++++++-----
 src/syscall/zsyscall_openbsd_386.s  | 233 ++++++++
 12 files changed, 1380 insertions(+), 148 deletions(-)
 create mode 100644 src/syscall/asm_openbsd_386.s
 create mode 100644 src/syscall/zsyscall_openbsd_386.s

diff --git a/src/runtime/sys_openbsd3.go b/src/runtime/sys_openbsd3.go
index 751c00c2b3..8fdee05733 100644
--- a/src/runtime/sys_openbsd3.go
+++ b/src/runtime/sys_openbsd3.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (openbsd && amd64) || (openbsd && arm64)
-// +build openbsd,amd64 openbsd,arm64
+//go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm64)
+// +build openbsd,386 openbsd,amd64 openbsd,arm64
 
 package runtime
 
diff --git a/src/runtime/sys_openbsd_386.s b/src/runtime/sys_openbsd_386.s
index e5a95a4899..7830b61b7d 100644
--- a/src/runtime/sys_openbsd_386.s
+++ b/src/runtime/sys_openbsd_386.s
@@ -597,3 +597,372 @@ TEXT runtime·sigaltstack_trampoline(SB),NOSPLIT,$0
 	MOVL	BP, SP
 	POPL	BP
 	RET
+
+// syscall calls a function in libc on behalf of the syscall package.
+// syscall takes a pointer to a struct like:
+// struct {
+//	fn    uintptr
+//	a1    uintptr
+//	a2    uintptr
+//	a3    uintptr
+//	r1    uintptr
+//	r2    uintptr
+//	err   uintptr
+// }
+// syscall must be called on the g0 stack with the
+// C calling convention (use libcCall).
+//
+// syscall expects a 32-bit result and tests for 32-bit -1
+// to decide there was an error.
+TEXT runtime·syscall(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+
+	SUBL	$12, SP
+	MOVL	20(SP), BX		// pointer to args
+
+	MOVL	(1*4)(BX), AX
+	MOVL	(2*4)(BX), CX
+	MOVL	(3*4)(BX), DX
+	MOVL	AX, (0*4)(SP)		// a1
+	MOVL	CX, (1*4)(SP)		// a2
+	MOVL	DX, (2*4)(SP)		// a3
+
+	MOVL	(0*4)(BX), AX		// fn
+	CALL	AX
+
+	MOVL	AX, (4*4)(BX)		// r1
+	MOVL	DX, (5*4)(BX)		// r2
+
+	// Standard libc functions return -1 on error and set errno.
+	CMPL	AX, $-1
+	JNE	ok
+
+	// Get error code from libc.
+	CALL	libc_errno(SB)
+	MOVL	(AX), AX
+	MOVW	AX, (6*4)(BX)		// err
+
+ok:
+	MOVL	$0, AX			// no error (it's ignored anyway)
+	MOVL	BP, SP
+	POPL	BP
+	RET
+
+// syscallX calls a function in libc on behalf of the syscall package.
+// syscallX takes a pointer to a struct like:
+// struct {
+//	fn    uintptr
+//	a1    uintptr
+//	a2    uintptr
+//	a3    uintptr
+//	r1    uintptr
+//	r2    uintptr
+//	err   uintptr
+// }
+// syscallX must be called on the g0 stack with the
+// C calling convention (use libcCall).
+//
+// syscallX is like syscall but expects a 64-bit result
+// and tests for 64-bit -1 to decide there was an error.
+TEXT runtime·syscallX(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+
+	SUBL	$12, SP
+	MOVL	20(SP), BX		// pointer to args
+
+	MOVL	(1*4)(BX), AX
+	MOVL	(2*4)(BX), CX
+	MOVL	(3*4)(BX), DX
+	MOVL	AX, (0*4)(SP)		// a1
+	MOVL	CX, (1*4)(SP)		// a2
+	MOVL	DX, (2*4)(SP)		// a3
+
+	MOVL	(0*4)(BX), AX		// fn
+	CALL	AX
+
+	MOVL	AX, (4*4)(BX)		// r1
+	MOVL	DX, (5*4)(BX)		// r2
+
+	// Standard libc functions return -1 on error and set errno.
+	CMPL	AX, $-1
+	JNE	ok
+	CMPL	DX, $-1
+	JNE	ok
+
+	// Get error code from libc.
+	CALL	libc_errno(SB)
+	MOVL	(AX), AX
+	MOVW	AX, (6*4)(BX)		// err
+
+ok:
+	MOVL	$0, AX			// no error (it's ignored anyway)
+	MOVL	BP, SP
+	POPL	BP
+	RET
+
+// syscall6 calls a function in libc on behalf of the syscall package.
+// syscall6 takes a pointer to a struct like:
+// struct {
+//	fn    uintptr
+//	a1    uintptr
+//	a2    uintptr
+//	a3    uintptr
+//	a4    uintptr
+//	a5    uintptr
+//	a6    uintptr
+//	r1    uintptr
+//	r2    uintptr
+//	err   uintptr
+// }
+// syscall6 must be called on the g0 stack with the
+// C calling convention (use libcCall).
+//
+// syscall6 expects a 32-bit result and tests for 32-bit -1
+// to decide there was an error.
+TEXT runtime·syscall6(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+
+	SUBL	$24, SP
+	MOVL	32(SP), BX		// pointer to args
+
+	MOVL	(1*4)(BX), AX
+	MOVL	(2*4)(BX), CX
+	MOVL	(3*4)(BX), DX
+	MOVL	AX, (0*4)(SP)		// a1
+	MOVL	CX, (1*4)(SP)		// a2
+	MOVL	DX, (2*4)(SP)		// a3
+	MOVL	(4*4)(BX), AX
+	MOVL	(5*4)(BX), CX
+	MOVL	(6*4)(BX), DX
+	MOVL	AX, (3*4)(SP)		// a4
+	MOVL	CX, (4*4)(SP)		// a5
+	MOVL	DX, (5*4)(SP)		// a6
+
+	MOVL	(0*4)(BX), AX		// fn
+	CALL	AX
+
+	MOVL	AX, (7*4)(BX)		// r1
+	MOVL	DX, (8*4)(BX)		// r2
+
+	// Standard libc functions return -1 on error and set errno.
+	CMPL	AX, $-1
+	JNE	ok
+
+	// Get error code from libc.
+	CALL	libc_errno(SB)
+	MOVL	(AX), AX
+	MOVW	AX, (9*4)(BX)		// err
+
+ok:
+	MOVL	$0, AX			// no error (it's ignored anyway)
+	MOVL	BP, SP
+	POPL	BP
+	RET
+
+// syscall6X calls a function in libc on behalf of the syscall package.
+// syscall6X takes a pointer to a struct like:
+// struct {
+//	fn    uintptr
+//	a1    uintptr
+//	a2    uintptr
+//	a3    uintptr
+//	a4    uintptr
+//	a5    uintptr
+//	a6    uintptr
+//	r1    uintptr
+//	r2    uintptr
+//	err   uintptr
+// }
+// syscall6X must be called on the g0 stack with the
+// C calling convention (use libcCall).
+//
+// syscall6X is like syscall6 but expects a 64-bit result
+// and tests for 64-bit -1 to decide there was an error.
+TEXT runtime·syscall6X(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+
+	SUBL	$24, SP
+	MOVL	32(SP), BX		// pointer to args
+
+	MOVL	(1*4)(BX), AX
+	MOVL	(2*4)(BX), CX
+	MOVL	(3*4)(BX), DX
+	MOVL	AX, (0*4)(SP)		// a1
+	MOVL	CX, (1*4)(SP)		// a2
+	MOVL	DX, (2*4)(SP)		// a3
+	MOVL	(4*4)(BX), AX
+	MOVL	(5*4)(BX), CX
+	MOVL	(6*4)(BX), DX
+	MOVL	AX, (3*4)(SP)		// a4
+	MOVL	CX, (4*4)(SP)		// a5
+	MOVL	DX, (5*4)(SP)		// a6
+
+	MOVL	(0*4)(BX), AX		// fn
+	CALL	AX
+
+	MOVL	AX, (7*4)(BX)		// r1
+	MOVL	DX, (8*4)(BX)		// r2
+
+	// Standard libc functions return -1 on error and set errno.
+	CMPL	AX, $-1
+	JNE	ok
+	CMPL	DX, $-1
+	JNE	ok
+
+	// Get error code from libc.
+	CALL	libc_errno(SB)
+	MOVL	(AX), AX
+	MOVW	AX, (9*4)(BX)		// err
+
+ok:
+	MOVL	$0, AX			// no error (it's ignored anyway)
+	MOVL	BP, SP
+	POPL	BP
+	RET
+
+// syscall10 calls a function in libc on behalf of the syscall package.
+// syscall10 takes a pointer to a struct like:
+// struct {
+//	fn    uintptr
+//	a1    uintptr
+//	a2    uintptr
+//	a3    uintptr
+//	a4    uintptr
+//	a5    uintptr
+//	a6    uintptr
+//	a7    uintptr
+//	a8    uintptr
+//	a9    uintptr
+//	a10   uintptr
+//	r1    uintptr
+//	r2    uintptr
+//	err   uintptr
+// }
+// syscall10 must be called on the g0 stack with the
+// C calling convention (use libcCall).
+TEXT runtime·syscall10(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+
+	SUBL	$40, SP
+	MOVL	48(SP), BX		// pointer to args
+
+	MOVL	(1*4)(BX), AX
+	MOVL	(2*4)(BX), CX
+	MOVL	(3*4)(BX), DX
+	MOVL	AX, (0*4)(SP)		// a1
+	MOVL	CX, (1*4)(SP)		// a2
+	MOVL	DX, (2*4)(SP)		// a3
+	MOVL	(4*4)(BX), AX
+	MOVL	(5*4)(BX), CX
+	MOVL	(6*4)(BX), DX
+	MOVL	AX, (3*4)(SP)		// a4
+	MOVL	CX, (4*4)(SP)		// a5
+	MOVL	DX, (5*4)(SP)		// a6
+	MOVL	(7*4)(BX), AX
+	MOVL	(8*4)(BX), CX
+	MOVL	(9*4)(BX), DX
+	MOVL	AX, (6*4)(SP)		// a7
+	MOVL	CX, (7*4)(SP)		// a8
+	MOVL	DX, (8*4)(SP)		// a9
+	MOVL	(10*4)(BX), AX
+	MOVL	AX, (9*4)(SP)		// a10
+
+	MOVL	(0*4)(BX), AX		// fn
+	CALL	AX
+
+	MOVL	AX, (11*4)(BX)		// r1
+	MOVL	DX, (12*4)(BX)		// r2
+
+	// Standard libc functions return -1 on error and set errno.
+	CMPL	AX, $-1
+	JNE	ok
+
+	// Get error code from libc.
+	CALL	libc_errno(SB)
+	MOVL	(AX), AX
+	MOVW	AX, (13*4)(BX)		// err
+
+ok:
+	MOVL	$0, AX			// no error (it's ignored anyway)
+	MOVL	BP, SP
+	POPL	BP
+	RET
+
+// syscall10X calls a function in libc on behalf of the syscall package.
+// syscall10X takes a pointer to a struct like:
+// struct {
+//	fn    uintptr
+//	a1    uintptr
+//	a2    uintptr
+//	a3    uintptr
+//	a4    uintptr
+//	a5    uintptr
+//	a6    uintptr
+//	a7    uintptr
+//	a8    uintptr
+//	a9    uintptr
+//	a10   uintptr
+//	r1    uintptr
+//	r2    uintptr
+//	err   uintptr
+// }
+// syscall10X must be called on the g0 stack with the
+// C calling convention (use libcCall).
+//
+// syscall10X is like syscall9 but expects a 64-bit result
+// and tests for 64-bit -1 to decide there was an error.
+TEXT runtime·syscall10X(SB),NOSPLIT,$0
+	PUSHL	BP
+	MOVL	SP, BP
+
+	SUBL	$40, SP
+	MOVL	48(SP), BX		// pointer to args
+
+	MOVL	(1*4)(BX), AX
+	MOVL	(2*4)(BX), CX
+	MOVL	(3*4)(BX), DX
+	MOVL	AX, (0*4)(SP)		// a1
+	MOVL	CX, (1*4)(SP)		// a2
+	MOVL	DX, (2*4)(SP)		// a3
+	MOVL	(4*4)(BX), AX
+	MOVL	(5*4)(BX), CX
+	MOVL	(6*4)(BX), DX
+	MOVL	AX, (3*4)(SP)		// a4
+	MOVL	CX, (4*4)(SP)		// a5
+	MOVL	DX, (5*4)(SP)		// a6
+	MOVL	(7*4)(BX), AX
+	MOVL	(8*4)(BX), CX
+	MOVL	(9*4)(BX), DX
+	MOVL	AX, (6*4)(SP)		// a7
+	MOVL	CX, (7*4)(SP)		// a8
+	MOVL	DX, (8*4)(SP)		// a9
+	MOVL	(10*4)(BX), AX
+	MOVL	AX, (9*4)(SP)		// a10
+
+	MOVL	(0*4)(BX), AX		// fn
+	CALL	AX
+
+	MOVL	AX, (11*4)(BX)		// r1
+	MOVL	DX, (12*4)(BX)		// r2
+
+	// Standard libc functions return -1 on error and set errno.
+	CMPL	AX, $-1
+	JNE	ok
+	CMPL	DX, $-1
+	JNE	ok
+
+	// Get error code from libc.
+	CALL	libc_errno(SB)
+	MOVL	(AX), AX
+	MOVW	AX, (13*4)(BX)		// err
+
+ok:
+	MOVL	$0, AX			// no error (it's ignored anyway)
+	MOVL	BP, SP
+	POPL	BP
+	RET
diff --git a/src/syscall/asm_openbsd_386.s b/src/syscall/asm_openbsd_386.s
new file mode 100644
index 0000000000..6f7b275431
--- /dev/null
+++ b/src/syscall/asm_openbsd_386.s
@@ -0,0 +1,32 @@
+// Copyright 2021 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.
+
+#include "textflag.h"
+
+//
+// System call support for 386, OpenBSD
+//
+
+// Provide these function names via assembly so they are provided as ABI0,
+// rather than ABIInternal.
+
+// func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
+TEXT	·Syscall(SB),NOSPLIT,$0-28
+	JMP	·syscallInternal(SB)
+
+// func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
+TEXT	·Syscall6(SB),NOSPLIT,$0-40
+	JMP	·syscall6Internal(SB)
+
+// func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
+TEXT	·RawSyscall(SB),NOSPLIT,$0-28
+	JMP	·rawSyscallInternal(SB)
+
+// func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
+TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
+	JMP	·rawSyscall6Internal(SB)
+
+// func Syscall9(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno)
+TEXT	·Syscall9(SB),NOSPLIT,$0-52
+	JMP	·syscall9Internal(SB)
diff --git a/src/syscall/asm_unix_386.s b/src/syscall/asm_unix_386.s
index 1e82b8800e..f262cd3adb 100644
--- a/src/syscall/asm_unix_386.s
+++ b/src/syscall/asm_unix_386.s
@@ -1,4 +1,4 @@
-// +build netbsd freebsd openbsd
+// +build netbsd freebsd
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/src/syscall/exec_bsd.go b/src/syscall/exec_bsd.go
index 051d130459..41d1f693b2 100644
--- a/src/syscall/exec_bsd.go
+++ b/src/syscall/exec_bsd.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build dragonfly || freebsd || netbsd || (openbsd && !amd64 && !arm64)
-// +build dragonfly freebsd netbsd openbsd,!amd64,!arm64
+//go:build dragonfly || freebsd || netbsd || (openbsd && !386 && !amd64 && !arm64)
+// +build dragonfly freebsd netbsd openbsd,!386,!amd64,!arm64
 
 package syscall
 
diff --git a/src/syscall/exec_libc2.go b/src/syscall/exec_libc2.go
index 61b1a226eb..8e957b3d4a 100644
--- a/src/syscall/exec_libc2.go
+++ b/src/syscall/exec_libc2.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build darwin || (openbsd && amd64) || (openbsd && arm64)
-// +build darwin openbsd,amd64 openbsd,arm64
+//go:build darwin || (openbsd && 386) || (openbsd && amd64) || (openbsd && arm64)
+// +build darwin openbsd,386 openbsd,amd64 openbsd,arm64
 
 package syscall
 
diff --git a/src/syscall/exec_unix.go b/src/syscall/exec_unix.go
index 64a5b61fe5..206a1e17d6 100644
--- a/src/syscall/exec_unix.go
+++ b/src/syscall/exec_unix.go
@@ -301,7 +301,7 @@ func Exec(argv0 string, argv []string, envv []string) (err error) {
 	} else if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
 		// Similarly on Darwin.
 		err1 = execveDarwin(argv0p, &argvp[0], &envvp[0])
-	} else if runtime.GOOS == "openbsd" && (runtime.GOARCH == "amd64" || runtime.GOARCH == "arm64") {
+	} else if runtime.GOOS == "openbsd" && (runtime.GOARCH == "386" || runtime.GOARCH == "amd64" || runtime.GOARCH == "arm64") {
 		// Similarly on OpenBSD.
 		err1 = execveOpenBSD(argv0p, &argvp[0], &envvp[0])
 	} else {
diff --git a/src/syscall/mkall.sh b/src/syscall/mkall.sh
index d1e28efa8c..7739147310 100755
--- a/src/syscall/mkall.sh
+++ b/src/syscall/mkall.sh
@@ -285,11 +285,12 @@ netbsd_arm64)
 openbsd_386)
 	GOOSARCH_in="syscall_openbsd1.go syscall_openbsd_$GOARCH.go"
 	mkerrors="$mkerrors -m32"
-	mksyscall="./mksyscall.pl -l32 -openbsd"
+	mksyscall="./mksyscall.pl -l32 -openbsd -libc"
 	mksysctl="./mksysctl_openbsd.pl"
 	zsysctl="zsysctl_openbsd.go"
 	mksysnum="curl -s 'http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master' | ./mksysnum_openbsd.pl"
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
+	mkasm="go run mkasm.go"
 	;;
 openbsd_amd64)
 	GOOSARCH_in="syscall_openbsd_libc.go syscall_openbsd_$GOARCH.go"
diff --git a/src/syscall/syscall_openbsd1.go b/src/syscall/syscall_openbsd1.go
index 0d6761d49e..c446768aab 100644
--- a/src/syscall/syscall_openbsd1.go
+++ b/src/syscall/syscall_openbsd1.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build openbsd && !amd64 && !arm64
-// +build openbsd,!amd64,!arm64
+//go:build openbsd && !386 && !amd64 && !arm64
+// +build openbsd,!386,!amd64,!arm64
 
 package syscall
 
diff --git a/src/syscall/syscall_openbsd_libc.go b/src/syscall/syscall_openbsd_libc.go
index b967b4e3ac..750be6f707 100644
--- a/src/syscall/syscall_openbsd_libc.go
+++ b/src/syscall/syscall_openbsd_libc.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (openbsd && amd64) || (openbsd && arm64)
-// +build openbsd,amd64 openbsd,arm64
+//go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm64)
+// +build openbsd,386 openbsd,amd64 openbsd,arm64
 
 package syscall
 
diff --git a/src/syscall/zsyscall_openbsd_386.go b/src/syscall/zsyscall_openbsd_386.go
index 7d4c4d342a..1ff5c95fa1 100644
--- a/src/syscall/zsyscall_openbsd_386.go
+++ b/src/syscall/zsyscall_openbsd_386.go
@@ -1,4 +1,4 @@
-// mksyscall.pl -l32 -openbsd -tags openbsd,386 syscall_bsd.go syscall_openbsd.go syscall_openbsd_386.go
+// mksyscall.pl -l32 -openbsd -libc -tags openbsd,386 syscall_bsd.go syscall_openbsd.go syscall_openbsd_libc.go syscall_openbsd_386.go
 // Code generated by the command above; DO NOT EDIT.
 
 //go:build openbsd && 386
@@ -7,11 +7,12 @@
 package syscall
 
 import "unsafe"
+import "internal/abi"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
-	r0, _, e1 := RawSyscall(SYS_GETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -19,20 +20,28 @@ func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
 	return
 }
 
+func libc_getgroups_trampoline()
+
+//go:cgo_import_dynamic libc_getgroups getgroups "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func setgroups(ngid int, gid *_Gid_t) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_setgroups_trampoline()
+
+//go:cgo_import_dynamic libc_setgroups setgroups "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) {
-	r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
 	wpid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -40,10 +49,14 @@ func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err
 	return
 }
 
+func libc_wait4_trampoline()
+
+//go:cgo_import_dynamic libc_wait4 wait4 "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
-	r0, _, e1 := Syscall(SYS_ACCEPT, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -51,30 +64,42 @@ func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
 	return
 }
 
+func libc_accept_trampoline()
+
+//go:cgo_import_dynamic libc_accept accept "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
-	_, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_bind_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_bind_trampoline()
+
+//go:cgo_import_dynamic libc_bind bind "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
-	_, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_connect_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_connect_trampoline()
+
+//go:cgo_import_dynamic libc_connect connect "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func socket(domain int, typ int, proto int) (fd int, err error) {
-	r0, _, e1 := RawSyscall(SYS_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto))
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_socket_trampoline), uintptr(domain), uintptr(typ), uintptr(proto))
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -82,66 +107,94 @@ func socket(domain int, typ int, proto int) (fd int, err error) {
 	return
 }
 
+func libc_socket_trampoline()
+
+//go:cgo_import_dynamic libc_socket socket "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
-	_, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_getsockopt_trampoline()
+
+//go:cgo_import_dynamic libc_getsockopt getsockopt "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
-	_, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_setsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_setsockopt_trampoline()
+
+//go:cgo_import_dynamic libc_setsockopt setsockopt "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
-	_, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_getpeername_trampoline()
+
+//go:cgo_import_dynamic libc_getpeername getpeername "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
-	_, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_getsockname_trampoline()
+
+//go:cgo_import_dynamic libc_getsockname getsockname "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Shutdown(s int, how int) (err error) {
-	_, _, e1 := Syscall(SYS_SHUTDOWN, uintptr(s), uintptr(how), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_shutdown_trampoline), uintptr(s), uintptr(how), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_shutdown_trampoline()
+
+//go:cgo_import_dynamic libc_shutdown shutdown "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
-	_, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
+	_, _, e1 := rawSyscall6(abi.FuncPCABI0(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_socketpair_trampoline()
+
+//go:cgo_import_dynamic libc_socketpair socketpair "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) {
@@ -151,7 +204,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := Syscall6(SYS_RECVFROM, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_recvfrom_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -159,6 +212,10 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
 	return
 }
 
+func libc_recvfrom_trampoline()
+
+//go:cgo_import_dynamic libc_recvfrom recvfrom "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
@@ -168,17 +225,21 @@ func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := Syscall6(SYS_SENDTO, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_sendto_trampoline), uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_sendto_trampoline()
+
+//go:cgo_import_dynamic libc_sendto sendto "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
-	r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -186,10 +247,14 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 	return
 }
 
+func libc_recvmsg_trampoline()
+
+//go:cgo_import_dynamic libc_recvmsg recvmsg "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
-	r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -197,10 +262,14 @@ func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 	return
 }
 
+func libc_sendmsg_trampoline()
+
+//go:cgo_import_dynamic libc_sendmsg sendmsg "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
-	r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -208,21 +277,9 @@ func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, ne
 	return
 }
 
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+func libc_kevent_trampoline()
 
-func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) {
-	var _p0 unsafe.Pointer
-	if len(mib) > 0 {
-		_p0 = unsafe.Pointer(&mib[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	_, _, e1 := Syscall6(SYS___SYSCTL, uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
+//go:cgo_import_dynamic libc_kevent kevent "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
@@ -232,27 +289,35 @@ func utimes(path string, timeval *[2]Timeval) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_utimes_trampoline()
+
+//go:cgo_import_dynamic libc_utimes utimes "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func futimes(fd int, timeval *[2]Timeval) (err error) {
-	_, _, e1 := Syscall(SYS_FUTIMES, uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_futimes_trampoline()
+
+//go:cgo_import_dynamic libc_futimes futimes "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func fcntl(fd int, cmd int, arg int) (val int, err error) {
-	r0, _, e1 := Syscall(SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -260,20 +325,28 @@ func fcntl(fd int, cmd int, arg int) (val int, err error) {
 	return
 }
 
+func libc_fcntl_trampoline()
+
+//go:cgo_import_dynamic libc_fcntl fcntl "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func pipe2(p *[2]_C_int, flags int) (err error) {
-	_, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_pipe2_trampoline), uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_pipe2_trampoline()
+
+//go:cgo_import_dynamic libc_pipe2 pipe2 "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func accept4(fd int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (nfd int, err error) {
-	r0, _, e1 := Syscall6(SYS_ACCEPT4, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_accept4_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
 	nfd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -281,6 +354,10 @@ func accept4(fd int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (nfd int
 	return
 }
 
+func libc_accept4_trampoline()
+
+//go:cgo_import_dynamic libc_accept4 accept4 "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getdents(fd int, buf []byte) (n int, err error) {
@@ -290,7 +367,7 @@ func getdents(fd int, buf []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := Syscall(SYS_GETDENTS, uintptr(fd), uintptr(_p0), uintptr(len(buf)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_getdents_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(buf)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -298,6 +375,10 @@ func getdents(fd int, buf []byte) (n int, err error) {
 	return
 }
 
+func libc_getdents_trampoline()
+
+//go:cgo_import_dynamic libc_getdents getdents "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Access(path string, mode uint32) (err error) {
@@ -306,23 +387,31 @@ func Access(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_ACCESS, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_access_trampoline()
+
+//go:cgo_import_dynamic libc_access access "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Adjtime(delta *Timeval, olddelta *Timeval) (err error) {
-	_, _, e1 := Syscall(SYS_ADJTIME, uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_adjtime_trampoline()
+
+//go:cgo_import_dynamic libc_adjtime adjtime "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Chdir(path string) (err error) {
@@ -331,13 +420,17 @@ func Chdir(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_chdir_trampoline()
+
+//go:cgo_import_dynamic libc_chdir chdir "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Chflags(path string, flags int) (err error) {
@@ -346,13 +439,17 @@ func Chflags(path string, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_CHFLAGS, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_chflags_trampoline()
+
+//go:cgo_import_dynamic libc_chflags chflags "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Chmod(path string, mode uint32) (err error) {
@@ -361,13 +458,17 @@ func Chmod(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_CHMOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_chmod_trampoline()
+
+//go:cgo_import_dynamic libc_chmod chmod "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Chown(path string, uid int, gid int) (err error) {
@@ -376,13 +477,17 @@ func Chown(path string, uid int, gid int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_CHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_chown_trampoline()
+
+//go:cgo_import_dynamic libc_chown chown "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Chroot(path string) (err error) {
@@ -391,27 +496,35 @@ func Chroot(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_chroot_trampoline()
+
+//go:cgo_import_dynamic libc_chroot chroot "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Close(fd int) (err error) {
-	_, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_close_trampoline), uintptr(fd), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_close_trampoline()
+
+//go:cgo_import_dynamic libc_close close "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Dup(fd int) (nfd int, err error) {
-	r0, _, e1 := Syscall(SYS_DUP, uintptr(fd), 0, 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_dup_trampoline), uintptr(fd), 0, 0)
 	nfd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -419,70 +532,98 @@ func Dup(fd int) (nfd int, err error) {
 	return
 }
 
+func libc_dup_trampoline()
+
+//go:cgo_import_dynamic libc_dup dup "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Dup2(from int, to int) (err error) {
-	_, _, e1 := Syscall(SYS_DUP2, uintptr(from), uintptr(to), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_dup2_trampoline), uintptr(from), uintptr(to), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_dup2_trampoline()
+
+//go:cgo_import_dynamic libc_dup2 dup2 "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchdir(fd int) (err error) {
-	_, _, e1 := Syscall(SYS_FCHDIR, uintptr(fd), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fchdir_trampoline), uintptr(fd), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_fchdir_trampoline()
+
+//go:cgo_import_dynamic libc_fchdir fchdir "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchflags(fd int, flags int) (err error) {
-	_, _, e1 := Syscall(SYS_FCHFLAGS, uintptr(fd), uintptr(flags), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fchflags_trampoline), uintptr(fd), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_fchflags_trampoline()
+
+//go:cgo_import_dynamic libc_fchflags fchflags "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchmod(fd int, mode uint32) (err error) {
-	_, _, e1 := Syscall(SYS_FCHMOD, uintptr(fd), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fchmod_trampoline), uintptr(fd), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_fchmod_trampoline()
+
+//go:cgo_import_dynamic libc_fchmod fchmod "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchown(fd int, uid int, gid int) (err error) {
-	_, _, e1 := Syscall(SYS_FCHOWN, uintptr(fd), uintptr(uid), uintptr(gid))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fchown_trampoline), uintptr(fd), uintptr(uid), uintptr(gid))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_fchown_trampoline()
+
+//go:cgo_import_dynamic libc_fchown fchown "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Flock(fd int, how int) (err error) {
-	_, _, e1 := Syscall(SYS_FLOCK, uintptr(fd), uintptr(how), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_flock_trampoline), uintptr(fd), uintptr(how), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_flock_trampoline()
+
+//go:cgo_import_dynamic libc_flock flock "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fpathconf(fd int, name int) (val int, err error) {
-	r0, _, e1 := Syscall(SYS_FPATHCONF, uintptr(fd), uintptr(name), 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_fpathconf_trampoline), uintptr(fd), uintptr(name), 0)
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -490,74 +631,106 @@ func Fpathconf(fd int, name int) (val int, err error) {
 	return
 }
 
+func libc_fpathconf_trampoline()
+
+//go:cgo_import_dynamic libc_fpathconf fpathconf "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fstat(fd int, stat *Stat_t) (err error) {
-	_, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fstat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_fstat_trampoline()
+
+//go:cgo_import_dynamic libc_fstat fstat "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fstatfs(fd int, stat *Statfs_t) (err error) {
-	_, _, e1 := Syscall(SYS_FSTATFS, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fstatfs_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_fstatfs_trampoline()
+
+//go:cgo_import_dynamic libc_fstatfs fstatfs "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fsync(fd int) (err error) {
-	_, _, e1 := Syscall(SYS_FSYNC, uintptr(fd), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fsync_trampoline), uintptr(fd), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_fsync_trampoline()
+
+//go:cgo_import_dynamic libc_fsync fsync "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Ftruncate(fd int, length int64) (err error) {
-	_, _, e1 := Syscall6(SYS_FTRUNCATE, uintptr(fd), 0, uintptr(length), uintptr(length>>32), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_ftruncate_trampoline), uintptr(fd), uintptr(length), uintptr(length>>32))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_ftruncate_trampoline()
+
+//go:cgo_import_dynamic libc_ftruncate ftruncate "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getegid() (egid int) {
-	r0, _, _ := RawSyscall(SYS_GETEGID, 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getegid_trampoline), 0, 0, 0)
 	egid = int(r0)
 	return
 }
 
+func libc_getegid_trampoline()
+
+//go:cgo_import_dynamic libc_getegid getegid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Geteuid() (uid int) {
-	r0, _, _ := RawSyscall(SYS_GETEUID, 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_geteuid_trampoline), 0, 0, 0)
 	uid = int(r0)
 	return
 }
 
+func libc_geteuid_trampoline()
+
+//go:cgo_import_dynamic libc_geteuid geteuid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getgid() (gid int) {
-	r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getgid_trampoline), 0, 0, 0)
 	gid = int(r0)
 	return
 }
 
+func libc_getgid_trampoline()
+
+//go:cgo_import_dynamic libc_getgid getgid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpgid(pid int) (pgid int, err error) {
-	r0, _, e1 := RawSyscall(SYS_GETPGID, uintptr(pid), 0, 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getpgid_trampoline), uintptr(pid), 0, 0)
 	pgid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -565,34 +738,50 @@ func Getpgid(pid int) (pgid int, err error) {
 	return
 }
 
+func libc_getpgid_trampoline()
+
+//go:cgo_import_dynamic libc_getpgid getpgid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpgrp() (pgrp int) {
-	r0, _, _ := RawSyscall(SYS_GETPGRP, 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getpgrp_trampoline), 0, 0, 0)
 	pgrp = int(r0)
 	return
 }
 
+func libc_getpgrp_trampoline()
+
+//go:cgo_import_dynamic libc_getpgrp getpgrp "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpid() (pid int) {
-	r0, _, _ := RawSyscall(SYS_GETPID, 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getpid_trampoline), 0, 0, 0)
 	pid = int(r0)
 	return
 }
 
+func libc_getpid_trampoline()
+
+//go:cgo_import_dynamic libc_getpid getpid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getppid() (ppid int) {
-	r0, _, _ := RawSyscall(SYS_GETPPID, 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getppid_trampoline), 0, 0, 0)
 	ppid = int(r0)
 	return
 }
 
+func libc_getppid_trampoline()
+
+//go:cgo_import_dynamic libc_getppid getppid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpriority(which int, who int) (prio int, err error) {
-	r0, _, e1 := Syscall(SYS_GETPRIORITY, uintptr(which), uintptr(who), 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_getpriority_trampoline), uintptr(which), uintptr(who), 0)
 	prio = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -600,30 +789,42 @@ func Getpriority(which int, who int) (prio int, err error) {
 	return
 }
 
+func libc_getpriority_trampoline()
+
+//go:cgo_import_dynamic libc_getpriority getpriority "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getrlimit(which int, lim *Rlimit) (err error) {
-	_, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_getrlimit_trampoline()
+
+//go:cgo_import_dynamic libc_getrlimit getrlimit "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getrusage(who int, rusage *Rusage) (err error) {
-	_, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_getrusage_trampoline()
+
+//go:cgo_import_dynamic libc_getrusage getrusage "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getsid(pid int) (sid int, err error) {
-	r0, _, e1 := RawSyscall(SYS_GETSID, uintptr(pid), 0, 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getsid_trampoline), uintptr(pid), 0, 0)
 	sid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -631,46 +832,66 @@ func Getsid(pid int) (sid int, err error) {
 	return
 }
 
+func libc_getsid_trampoline()
+
+//go:cgo_import_dynamic libc_getsid getsid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Gettimeofday(tv *Timeval) (err error) {
-	_, _, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tv)), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tv)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_gettimeofday_trampoline()
+
+//go:cgo_import_dynamic libc_gettimeofday gettimeofday "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getuid() (uid int) {
-	r0, _, _ := RawSyscall(SYS_GETUID, 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getuid_trampoline), 0, 0, 0)
 	uid = int(r0)
 	return
 }
 
+func libc_getuid_trampoline()
+
+//go:cgo_import_dynamic libc_getuid getuid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Issetugid() (tainted bool) {
-	r0, _, _ := Syscall(SYS_ISSETUGID, 0, 0, 0)
+	r0, _, _ := syscall(abi.FuncPCABI0(libc_issetugid_trampoline), 0, 0, 0)
 	tainted = bool(r0 != 0)
 	return
 }
 
+func libc_issetugid_trampoline()
+
+//go:cgo_import_dynamic libc_issetugid issetugid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Kill(pid int, signum Signal) (err error) {
-	_, _, e1 := Syscall(SYS_KILL, uintptr(pid), uintptr(signum), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_kill_trampoline), uintptr(pid), uintptr(signum), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_kill_trampoline()
+
+//go:cgo_import_dynamic libc_kill kill "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Kqueue() (fd int, err error) {
-	r0, _, e1 := Syscall(SYS_KQUEUE, 0, 0, 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_kqueue_trampoline), 0, 0, 0)
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -678,6 +899,10 @@ func Kqueue() (fd int, err error) {
 	return
 }
 
+func libc_kqueue_trampoline()
+
+//go:cgo_import_dynamic libc_kqueue kqueue "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Lchown(path string, uid int, gid int) (err error) {
@@ -686,13 +911,17 @@ func Lchown(path string, uid int, gid int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_LCHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_lchown_trampoline()
+
+//go:cgo_import_dynamic libc_lchown lchown "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Link(path string, link string) (err error) {
@@ -706,23 +935,31 @@ func Link(path string, link string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_link_trampoline()
+
+//go:cgo_import_dynamic libc_link link "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Listen(s int, backlog int) (err error) {
-	_, _, e1 := Syscall(SYS_LISTEN, uintptr(s), uintptr(backlog), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_listen_trampoline), uintptr(s), uintptr(backlog), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_listen_trampoline()
+
+//go:cgo_import_dynamic libc_listen listen "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Lstat(path string, stat *Stat_t) (err error) {
@@ -731,13 +968,17 @@ func Lstat(path string, stat *Stat_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_LSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_lstat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_lstat_trampoline()
+
+//go:cgo_import_dynamic libc_lstat lstat "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Mkdir(path string, mode uint32) (err error) {
@@ -746,13 +987,17 @@ func Mkdir(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_MKDIR, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_mkdir_trampoline()
+
+//go:cgo_import_dynamic libc_mkdir mkdir "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Mkfifo(path string, mode uint32) (err error) {
@@ -761,13 +1006,17 @@ func Mkfifo(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_MKFIFO, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_mkfifo_trampoline()
+
+//go:cgo_import_dynamic libc_mkfifo mkfifo "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Mknod(path string, mode uint32, dev int) (err error) {
@@ -776,23 +1025,31 @@ func Mknod(path string, mode uint32, dev int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_MKNOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_mknod_trampoline()
+
+//go:cgo_import_dynamic libc_mknod mknod "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Nanosleep(time *Timespec, leftover *Timespec) (err error) {
-	_, _, e1 := Syscall(SYS_NANOSLEEP, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_nanosleep_trampoline), uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_nanosleep_trampoline()
+
+//go:cgo_import_dynamic libc_nanosleep nanosleep "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Open(path string, mode int, perm uint32) (fd int, err error) {
@@ -801,7 +1058,7 @@ func Open(path string, mode int, perm uint32) (fd int, err error) {
 	if err != nil {
 		return
 	}
-	r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -809,6 +1066,10 @@ func Open(path string, mode int, perm uint32) (fd int, err error) {
 	return
 }
 
+func libc_open_trampoline()
+
+//go:cgo_import_dynamic libc_open open "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Pathconf(path string, name int) (val int, err error) {
@@ -817,7 +1078,7 @@ func Pathconf(path string, name int) (val int, err error) {
 	if err != nil {
 		return
 	}
-	r0, _, e1 := Syscall(SYS_PATHCONF, uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -825,6 +1086,10 @@ func Pathconf(path string, name int) (val int, err error) {
 	return
 }
 
+func libc_pathconf_trampoline()
+
+//go:cgo_import_dynamic libc_pathconf pathconf "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Pread(fd int, p []byte, offset int64) (n int, err error) {
@@ -834,7 +1099,7 @@ func Pread(fd int, p []byte, offset int64) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), 0, uintptr(offset), uintptr(offset>>32))
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_pread_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -842,6 +1107,10 @@ func Pread(fd int, p []byte, offset int64) (n int, err error) {
 	return
 }
 
+func libc_pread_trampoline()
+
+//go:cgo_import_dynamic libc_pread pread "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
@@ -851,7 +1120,7 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), 0, uintptr(offset), uintptr(offset>>32))
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_pwrite_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -859,6 +1128,10 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
 	return
 }
 
+func libc_pwrite_trampoline()
+
+//go:cgo_import_dynamic libc_pwrite pwrite "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func read(fd int, p []byte) (n int, err error) {
@@ -868,7 +1141,7 @@ func read(fd int, p []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_read_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -876,6 +1149,10 @@ func read(fd int, p []byte) (n int, err error) {
 	return
 }
 
+func libc_read_trampoline()
+
+//go:cgo_import_dynamic libc_read read "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Readlink(path string, buf []byte) (n int, err error) {
@@ -890,7 +1167,7 @@ func Readlink(path string, buf []byte) (n int, err error) {
 	} else {
 		_p1 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := Syscall(SYS_READLINK, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -898,6 +1175,10 @@ func Readlink(path string, buf []byte) (n int, err error) {
 	return
 }
 
+func libc_readlink_trampoline()
+
+//go:cgo_import_dynamic libc_readlink readlink "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Rename(from string, to string) (err error) {
@@ -911,13 +1192,17 @@ func Rename(from string, to string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_RENAME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_rename_trampoline()
+
+//go:cgo_import_dynamic libc_rename rename "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Revoke(path string) (err error) {
@@ -926,13 +1211,17 @@ func Revoke(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_REVOKE, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_revoke_trampoline()
+
+//go:cgo_import_dynamic libc_revoke revoke "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Rmdir(path string) (err error) {
@@ -941,64 +1230,73 @@ func Rmdir(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_RMDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+func libc_rmdir_trampoline()
 
-func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
-	r0, r1, e1 := Syscall6(SYS_LSEEK, uintptr(fd), 0, uintptr(offset), uintptr(offset>>32), uintptr(whence), 0)
-	newoffset = int64(int64(r1)<<32 | int64(r0))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
+//go:cgo_import_dynamic libc_rmdir rmdir "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (err error) {
-	_, _, e1 := Syscall6(SYS_SELECT, uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_select_trampoline), uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_select_trampoline()
+
+//go:cgo_import_dynamic libc_select select "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setegid(egid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETEGID, uintptr(egid), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setegid_trampoline), uintptr(egid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_setegid_trampoline()
+
+//go:cgo_import_dynamic libc_setegid setegid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Seteuid(euid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETEUID, uintptr(euid), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_seteuid_trampoline), uintptr(euid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_seteuid_trampoline()
+
+//go:cgo_import_dynamic libc_seteuid seteuid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setgid(gid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETGID, uintptr(gid), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setgid_trampoline), uintptr(gid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_setgid_trampoline()
+
+//go:cgo_import_dynamic libc_setgid setgid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setlogin(name string) (err error) {
@@ -1007,67 +1305,91 @@ func Setlogin(name string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_SETLOGIN, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_setlogin_trampoline()
+
+//go:cgo_import_dynamic libc_setlogin setlogin "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setpgid(pid int, pgid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETPGID, uintptr(pid), uintptr(pgid), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setpgid_trampoline), uintptr(pid), uintptr(pgid), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_setpgid_trampoline()
+
+//go:cgo_import_dynamic libc_setpgid setpgid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setpriority(which int, who int, prio int) (err error) {
-	_, _, e1 := Syscall(SYS_SETPRIORITY, uintptr(which), uintptr(who), uintptr(prio))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_setpriority_trampoline), uintptr(which), uintptr(who), uintptr(prio))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_setpriority_trampoline()
+
+//go:cgo_import_dynamic libc_setpriority setpriority "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setregid(rgid int, egid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETREGID, uintptr(rgid), uintptr(egid), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setregid_trampoline), uintptr(rgid), uintptr(egid), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_setregid_trampoline()
+
+//go:cgo_import_dynamic libc_setregid setregid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setreuid(ruid int, euid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETREUID, uintptr(ruid), uintptr(euid), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setreuid_trampoline), uintptr(ruid), uintptr(euid), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_setreuid_trampoline()
+
+//go:cgo_import_dynamic libc_setreuid setreuid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setrlimit(which int, lim *Rlimit) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_setrlimit_trampoline()
+
+//go:cgo_import_dynamic libc_setrlimit setrlimit "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setsid() (pid int, err error) {
-	r0, _, e1 := RawSyscall(SYS_SETSID, 0, 0, 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setsid_trampoline), 0, 0, 0)
 	pid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1075,26 +1397,38 @@ func Setsid() (pid int, err error) {
 	return
 }
 
+func libc_setsid_trampoline()
+
+//go:cgo_import_dynamic libc_setsid setsid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Settimeofday(tp *Timeval) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_settimeofday_trampoline()
+
+//go:cgo_import_dynamic libc_settimeofday settimeofday "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setuid(uid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETUID, uintptr(uid), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setuid_trampoline), uintptr(uid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_setuid_trampoline()
+
+//go:cgo_import_dynamic libc_setuid setuid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Stat(path string, stat *Stat_t) (err error) {
@@ -1103,13 +1437,17 @@ func Stat(path string, stat *Stat_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_stat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_stat_trampoline()
+
+//go:cgo_import_dynamic libc_stat stat "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Statfs(path string, stat *Statfs_t) (err error) {
@@ -1118,13 +1456,17 @@ func Statfs(path string, stat *Statfs_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_STATFS, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_statfs_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_statfs_trampoline()
+
+//go:cgo_import_dynamic libc_statfs statfs "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Symlink(path string, link string) (err error) {
@@ -1138,23 +1480,31 @@ func Symlink(path string, link string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_SYMLINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_symlink_trampoline()
+
+//go:cgo_import_dynamic libc_symlink symlink "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Sync() (err error) {
-	_, _, e1 := Syscall(SYS_SYNC, 0, 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_sync_trampoline), 0, 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_sync_trampoline()
+
+//go:cgo_import_dynamic libc_sync sync "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Truncate(path string, length int64) (err error) {
@@ -1163,21 +1513,29 @@ func Truncate(path string, length int64) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall6(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), 0, uintptr(length), uintptr(length>>32), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), uintptr(length>>32))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_truncate_trampoline()
+
+//go:cgo_import_dynamic libc_truncate truncate "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Umask(newmask int) (oldmask int) {
-	r0, _, _ := Syscall(SYS_UMASK, uintptr(newmask), 0, 0)
+	r0, _, _ := syscall(abi.FuncPCABI0(libc_umask_trampoline), uintptr(newmask), 0, 0)
 	oldmask = int(r0)
 	return
 }
 
+func libc_umask_trampoline()
+
+//go:cgo_import_dynamic libc_umask umask "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Unlink(path string) (err error) {
@@ -1186,13 +1544,17 @@ func Unlink(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_UNLINK, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_unlink_trampoline()
+
+//go:cgo_import_dynamic libc_unlink unlink "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Unmount(path string, flags int) (err error) {
@@ -1201,13 +1563,17 @@ func Unmount(path string, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_UNMOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_unmount_trampoline()
+
+//go:cgo_import_dynamic libc_unmount unmount "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func write(fd int, p []byte) (n int, err error) {
@@ -1217,7 +1583,7 @@ func write(fd int, p []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_write_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1225,10 +1591,14 @@ func write(fd int, p []byte) (n int, err error) {
 	return
 }
 
+func libc_write_trampoline()
+
+//go:cgo_import_dynamic libc_write write "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
-	r0, _, e1 := Syscall9(SYS_MMAP, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), 0, uintptr(pos), uintptr(pos>>32), 0)
+	r0, _, e1 := syscall9(abi.FuncPCABI0(libc_mmap_trampoline), uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos), uintptr(pos>>32), 0, 0)
 	ret = uintptr(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1236,20 +1606,62 @@ func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (
 	return
 }
 
+func libc_mmap_trampoline()
+
+//go:cgo_import_dynamic libc_mmap mmap "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func munmap(addr uintptr, length uintptr) (err error) {
-	_, _, e1 := Syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_munmap_trampoline), uintptr(addr), uintptr(length), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func libc_munmap_trampoline()
+
+//go:cgo_import_dynamic libc_munmap munmap "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func utimensat(dirfd int, path string, times *[2]Timespec, flag int) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_utimensat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), uintptr(flag), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_utimensat_trampoline()
+
+//go:cgo_import_dynamic libc_utimensat utimensat "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func directSyscall(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr) (ret uintptr, err error) {
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_syscall_trampoline), uintptr(trap), uintptr(a1), uintptr(a2), uintptr(a3), uintptr(a4), uintptr(a5))
+	ret = uintptr(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func libc_syscall_trampoline()
+
+//go:cgo_import_dynamic libc_syscall syscall "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
-	r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1260,7 +1672,7 @@ func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
-	r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1270,19 +1682,19 @@ func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func utimensat(dirfd int, path string, times *[2]Timespec, flag int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := Syscall6(SYS_UTIMENSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), uintptr(flag), 0, 0)
+func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
+	r0, r1, e1 := syscall6X(abi.FuncPCABI0(libc_lseek_trampoline), uintptr(fd), uintptr(offset), uintptr(offset>>32), uintptr(whence), 0, 0)
+	newoffset = int64(int64(r1)<<32 | int64(r0))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_lseek_trampoline()
+
+//go:cgo_import_dynamic libc_lseek lseek "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getcwd(buf []byte) (n int, err error) {
@@ -1292,10 +1704,195 @@ func getcwd(buf []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := Syscall(SYS___GETCWD, uintptr(_p0), uintptr(len(buf)), 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_getcwd_trampoline), uintptr(_p0), uintptr(len(buf)), 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
+
+func libc_getcwd_trampoline()
+
+//go:cgo_import_dynamic libc_getcwd getcwd "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) {
+	var _p0 unsafe.Pointer
+	if len(mib) > 0 {
+		_p0 = unsafe.Pointer(&mib[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_sysctl_trampoline), uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func libc_sysctl_trampoline()
+
+//go:cgo_import_dynamic libc_sysctl sysctl "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func fork() (pid int, err error) {
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_fork_trampoline), 0, 0, 0)
+	pid = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func libc_fork_trampoline()
+
+//go:cgo_import_dynamic libc_fork fork "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func ioctl(fd int, req int, arg int) (err error) {
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func libc_ioctl_trampoline()
+
+//go:cgo_import_dynamic libc_ioctl ioctl "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func execve(path *byte, argv **byte, envp **byte) (err error) {
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_execve_trampoline), uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(argv)), uintptr(unsafe.Pointer(envp)))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func libc_execve_trampoline()
+
+//go:cgo_import_dynamic libc_execve execve "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func exit(res int) (err error) {
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_exit_trampoline), uintptr(res), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func libc_exit_trampoline()
+
+//go:cgo_import_dynamic libc_exit exit "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+//go:nosplit
+func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func libc_ptrace_trampoline()
+
+//go:cgo_import_dynamic libc_ptrace ptrace "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func getentropy(p []byte) (err error) {
+	var _p0 unsafe.Pointer
+	if len(p) > 0 {
+		_p0 = unsafe.Pointer(&p[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getentropy_trampoline), uintptr(_p0), uintptr(len(p)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func libc_getentropy_trampoline()
+
+//go:cgo_import_dynamic libc_getentropy getentropy "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_fstatat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func libc_fstatat_trampoline()
+
+//go:cgo_import_dynamic libc_fstatat fstatat "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func fcntlPtr(fd int, cmd int, arg unsafe.Pointer) (val int, err error) {
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
+	val = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func unlinkat(fd int, path string, flags int) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_unlinkat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func libc_unlinkat_trampoline()
+
+//go:cgo_import_dynamic libc_unlinkat unlinkat "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func openat(fd int, path string, flags int, perm uint32) (fdret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_openat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(perm), 0, 0)
+	fdret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func libc_openat_trampoline()
+
+//go:cgo_import_dynamic libc_openat openat "libc.so"
diff --git a/src/syscall/zsyscall_openbsd_386.s b/src/syscall/zsyscall_openbsd_386.s
new file mode 100644
index 0000000000..d47a4f480d
--- /dev/null
+++ b/src/syscall/zsyscall_openbsd_386.s
@@ -0,0 +1,233 @@
+// go run mkasm.go openbsd 386
+// Code generated by the command above; DO NOT EDIT.
+#include "textflag.h"
+TEXT ·libc_getgroups_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getgroups(SB)
+TEXT ·libc_setgroups_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_setgroups(SB)
+TEXT ·libc_wait4_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_wait4(SB)
+TEXT ·libc_accept_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_accept(SB)
+TEXT ·libc_bind_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_bind(SB)
+TEXT ·libc_connect_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_connect(SB)
+TEXT ·libc_socket_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_socket(SB)
+TEXT ·libc_getsockopt_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getsockopt(SB)
+TEXT ·libc_setsockopt_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_setsockopt(SB)
+TEXT ·libc_getpeername_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getpeername(SB)
+TEXT ·libc_getsockname_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getsockname(SB)
+TEXT ·libc_shutdown_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_shutdown(SB)
+TEXT ·libc_socketpair_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_socketpair(SB)
+TEXT ·libc_recvfrom_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_recvfrom(SB)
+TEXT ·libc_sendto_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_sendto(SB)
+TEXT ·libc_recvmsg_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_recvmsg(SB)
+TEXT ·libc_sendmsg_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_sendmsg(SB)
+TEXT ·libc_kevent_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_kevent(SB)
+TEXT ·libc_utimes_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_utimes(SB)
+TEXT ·libc_futimes_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_futimes(SB)
+TEXT ·libc_fcntl_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_fcntl(SB)
+TEXT ·libc_pipe2_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_pipe2(SB)
+TEXT ·libc_accept4_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_accept4(SB)
+TEXT ·libc_getdents_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getdents(SB)
+TEXT ·libc_access_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_access(SB)
+TEXT ·libc_adjtime_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_adjtime(SB)
+TEXT ·libc_chdir_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_chdir(SB)
+TEXT ·libc_chflags_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_chflags(SB)
+TEXT ·libc_chmod_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_chmod(SB)
+TEXT ·libc_chown_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_chown(SB)
+TEXT ·libc_chroot_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_chroot(SB)
+TEXT ·libc_close_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_close(SB)
+TEXT ·libc_dup_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_dup(SB)
+TEXT ·libc_dup2_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_dup2(SB)
+TEXT ·libc_fchdir_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_fchdir(SB)
+TEXT ·libc_fchflags_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_fchflags(SB)
+TEXT ·libc_fchmod_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_fchmod(SB)
+TEXT ·libc_fchown_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_fchown(SB)
+TEXT ·libc_flock_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_flock(SB)
+TEXT ·libc_fpathconf_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_fpathconf(SB)
+TEXT ·libc_fstat_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_fstat(SB)
+TEXT ·libc_fstatfs_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_fstatfs(SB)
+TEXT ·libc_fsync_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_fsync(SB)
+TEXT ·libc_ftruncate_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_ftruncate(SB)
+TEXT ·libc_getegid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getegid(SB)
+TEXT ·libc_geteuid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_geteuid(SB)
+TEXT ·libc_getgid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getgid(SB)
+TEXT ·libc_getpgid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getpgid(SB)
+TEXT ·libc_getpgrp_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getpgrp(SB)
+TEXT ·libc_getpid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getpid(SB)
+TEXT ·libc_getppid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getppid(SB)
+TEXT ·libc_getpriority_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getpriority(SB)
+TEXT ·libc_getrlimit_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getrlimit(SB)
+TEXT ·libc_getrusage_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getrusage(SB)
+TEXT ·libc_getsid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getsid(SB)
+TEXT ·libc_gettimeofday_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_gettimeofday(SB)
+TEXT ·libc_getuid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getuid(SB)
+TEXT ·libc_issetugid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_issetugid(SB)
+TEXT ·libc_kill_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_kill(SB)
+TEXT ·libc_kqueue_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_kqueue(SB)
+TEXT ·libc_lchown_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_lchown(SB)
+TEXT ·libc_link_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_link(SB)
+TEXT ·libc_listen_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_listen(SB)
+TEXT ·libc_lstat_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_lstat(SB)
+TEXT ·libc_mkdir_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_mkdir(SB)
+TEXT ·libc_mkfifo_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_mkfifo(SB)
+TEXT ·libc_mknod_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_mknod(SB)
+TEXT ·libc_nanosleep_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_nanosleep(SB)
+TEXT ·libc_open_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_open(SB)
+TEXT ·libc_pathconf_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_pathconf(SB)
+TEXT ·libc_pread_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_pread(SB)
+TEXT ·libc_pwrite_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_pwrite(SB)
+TEXT ·libc_read_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_read(SB)
+TEXT ·libc_readlink_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_readlink(SB)
+TEXT ·libc_rename_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_rename(SB)
+TEXT ·libc_revoke_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_revoke(SB)
+TEXT ·libc_rmdir_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_rmdir(SB)
+TEXT ·libc_select_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_select(SB)
+TEXT ·libc_setegid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_setegid(SB)
+TEXT ·libc_seteuid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_seteuid(SB)
+TEXT ·libc_setgid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_setgid(SB)
+TEXT ·libc_setlogin_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_setlogin(SB)
+TEXT ·libc_setpgid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_setpgid(SB)
+TEXT ·libc_setpriority_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_setpriority(SB)
+TEXT ·libc_setregid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_setregid(SB)
+TEXT ·libc_setreuid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_setreuid(SB)
+TEXT ·libc_setrlimit_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_setrlimit(SB)
+TEXT ·libc_setsid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_setsid(SB)
+TEXT ·libc_settimeofday_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_settimeofday(SB)
+TEXT ·libc_setuid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_setuid(SB)
+TEXT ·libc_stat_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_stat(SB)
+TEXT ·libc_statfs_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_statfs(SB)
+TEXT ·libc_symlink_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_symlink(SB)
+TEXT ·libc_sync_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_sync(SB)
+TEXT ·libc_truncate_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_truncate(SB)
+TEXT ·libc_umask_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_umask(SB)
+TEXT ·libc_unlink_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_unlink(SB)
+TEXT ·libc_unmount_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_unmount(SB)
+TEXT ·libc_write_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_write(SB)
+TEXT ·libc_mmap_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_mmap(SB)
+TEXT ·libc_munmap_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_munmap(SB)
+TEXT ·libc_utimensat_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_utimensat(SB)
+TEXT ·libc_syscall_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_syscall(SB)
+TEXT ·libc_lseek_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_lseek(SB)
+TEXT ·libc_getcwd_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getcwd(SB)
+TEXT ·libc_sysctl_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_sysctl(SB)
+TEXT ·libc_fork_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_fork(SB)
+TEXT ·libc_ioctl_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_ioctl(SB)
+TEXT ·libc_execve_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_execve(SB)
+TEXT ·libc_exit_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_exit(SB)
+TEXT ·libc_ptrace_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_ptrace(SB)
+TEXT ·libc_getentropy_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getentropy(SB)
+TEXT ·libc_fstatat_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_fstatat(SB)
+TEXT ·libc_unlinkat_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_unlinkat(SB)
+TEXT ·libc_openat_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_openat(SB)
-- 
GitLab


From ffc38d8ab47753643687a99c66cecd8e044b5c70 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Fri, 30 Apr 2021 14:49:40 -0400
Subject: [PATCH 1905/2400] go/types: slice-to-array-pointer conversion
 requires go1.17

This is a port of CL 315169 to go/types. It uses a slightly different
mechanism for evaluating the convertibility error message, to be
consistent with operand.assignableTo.

Change-Id: Iea2e2a9fbb4cf17d472b2b7392786118e079528a
Reviewed-on: https://go-review.googlesource.com/c/go/+/315809
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/api.go                    |  2 +-
 src/go/types/conversions.go            | 18 ++++++++++++++----
 src/go/types/decl.go                   |  2 +-
 src/go/types/testdata/check/go1_16.src | 13 +++++++++++++
 4 files changed, 29 insertions(+), 6 deletions(-)
 create mode 100644 src/go/types/testdata/check/go1_16.src

diff --git a/src/go/types/api.go b/src/go/types/api.go
index 436c23099b..da23c8c52a 100644
--- a/src/go/types/api.go
+++ b/src/go/types/api.go
@@ -406,7 +406,7 @@ func AssignableTo(V, T Type) bool {
 // ConvertibleTo reports whether a value of type V is convertible to a value of type T.
 func ConvertibleTo(V, T Type) bool {
 	x := operand{mode: value, typ: V}
-	return x.convertibleTo(nil, T) // check not needed for non-constant x
+	return x.convertibleTo(nil, T, nil) // check not needed for non-constant x
 }
 
 // Implements reports whether type V implements interface T.
diff --git a/src/go/types/conversions.go b/src/go/types/conversions.go
index e977d0db1f..ad6d3eef10 100644
--- a/src/go/types/conversions.go
+++ b/src/go/types/conversions.go
@@ -17,6 +17,7 @@ func (check *Checker) conversion(x *operand, T Type) {
 	constArg := x.mode == constant_
 
 	var ok bool
+	var reason string
 	switch {
 	case constArg && isConstType(T):
 		// constant conversion
@@ -31,14 +32,18 @@ func (check *Checker) conversion(x *operand, T Type) {
 			x.val = constant.MakeString(string(codepoint))
 			ok = true
 		}
-	case x.convertibleTo(check, T):
+	case x.convertibleTo(check, T, &reason):
 		// non-constant conversion
 		x.mode = value
 		ok = true
 	}
 
 	if !ok {
-		check.errorf(x, _InvalidConversion, "cannot convert %s to %s", x, T)
+		if reason != "" {
+			check.errorf(x, _InvalidConversion, "cannot convert %s to %s (%s)", x, T, reason)
+		} else {
+			check.errorf(x, _InvalidConversion, "cannot convert %s to %s", x, T)
+		}
 		x.mode = invalid
 		return
 	}
@@ -79,7 +84,7 @@ func (check *Checker) conversion(x *operand, T Type) {
 // convertibleTo reports whether T(x) is valid.
 // The check parameter may be nil if convertibleTo is invoked through an
 // exported API call, i.e., when all methods have been type-checked.
-func (x *operand) convertibleTo(check *Checker, T Type) bool {
+func (x *operand) convertibleTo(check *Checker, T Type, reason *string) bool {
 	// "x is assignable to T"
 	if ok, _ := x.assignableTo(check, T, nil); ok {
 		return true
@@ -139,7 +144,12 @@ func (x *operand) convertibleTo(check *Checker, T Type) bool {
 		if p := asPointer(T); p != nil {
 			if a := asArray(p.Elem()); a != nil {
 				if check.identical(s.Elem(), a.Elem()) {
-					return true
+					if check == nil || check.allowVersion(check.pkg, 1, 17) {
+						return true
+					}
+					if reason != nil {
+						*reason = "conversion of slices to array pointers requires go1.17 or later"
+					}
 				}
 			}
 		}
diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index b5b9d35b24..5f38a346ce 100644
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -655,7 +655,7 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *ast.TypeSpec, def *Named) {
 
 	if alias {
 		// type alias declaration
-		if !check.allowVersion(obj.pkg, 1, 9) {
+		if !check.allowVersion(check.pkg, 1, 9) {
 			check.errorf(atPos(tdecl.Assign), _BadDecl, "type aliases requires go1.9 or later")
 		}
 
diff --git a/src/go/types/testdata/check/go1_16.src b/src/go/types/testdata/check/go1_16.src
new file mode 100644
index 0000000000..fdf5c99d7e
--- /dev/null
+++ b/src/go/types/testdata/check/go1_16.src
@@ -0,0 +1,13 @@
+// Copyright 2021 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.
+
+// Check Go language version-specific errors.
+
+package go1_16 // go1.16
+
+type Slice []byte
+type Array [8]byte
+
+var s Slice
+var p = (*Array)(s /* ERROR requires go1.17 or later */ )
-- 
GitLab


From a9db5a73867f676f2f6a1b8fd2bb61d06b0a10f7 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Fri, 30 Apr 2021 14:55:11 -0400
Subject: [PATCH 1906/2400] go/types: simplify use of TestManual

This is a 1:1 port of CL 315689 to go/types.

Change-Id: If71186b3719be8433c9d21b22c51ffde2cadd55b
Reviewed-on: https://go-review.googlesource.com/c/go/+/315849
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/check_test.go | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/src/go/types/check_test.go b/src/go/types/check_test.go
index 0f23952380..0bf9b7ae00 100644
--- a/src/go/types/check_test.go
+++ b/src/go/types/check_test.go
@@ -47,7 +47,6 @@ import (
 var (
 	haltOnError = flag.Bool("halt", false, "halt on error")
 	listErrors  = flag.Bool("errlist", false, "list errors")
-	testFiles   = flag.String("files", "", "comma-separated list of test files for TestManual")
 	goVersion   = flag.String("lang", "", "Go language version (e.g. \"go1.12\") for TestManual")
 )
 
@@ -297,16 +296,23 @@ func checkFiles(t *testing.T, sizes Sizes, goVersion string, filenames []string,
 	}
 }
 
-// TestManual is for manual testing of selected input files, provided with
-// -files.
+// TestManual is for manual testing of input files, provided as a list
+// of arguments after the test arguments (and a separating "--"). For
+// instance, to check the files foo.go and bar.go, use:
+//
+// 	go test -run Manual -- foo.go bar.go
+//
+// To get an error list rather than having the test check against
+// ERROR comments in the input files, provide the -errlist flag.
 // The accepted Go language version can be controlled with the -lang flag.
 func TestManual(t *testing.T) {
-	if *testFiles == "" {
+	filenames := flag.Args()
+	if len(filenames) == 0 {
 		return
 	}
 	testenv.MustHaveGoBuild(t)
 	DefPredeclaredTestFuncs()
-	testPkg(t, strings.Split(*testFiles, ","), *goVersion)
+	testPkg(t, filenames, *goVersion)
 }
 
 func TestLongConstants(t *testing.T) {
-- 
GitLab


From 879db69ce2de814bc3203c39b45617ba51cc5366 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Fri, 30 Apr 2021 15:38:11 -0400
Subject: [PATCH 1907/2400] go/types: list errors by default in TestManual

This is a port of CL 315729 to go/types, adjusted for the slightly
different test set-up in go/types.

Added a TODO to reconcile these differences.

Change-Id: I71cae712d8fc23b7311ce35e09168b258e07fa35
Reviewed-on: https://go-review.googlesource.com/c/go/+/315850
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/check_test.go | 32 +++++++++++++++++---------------
 1 file changed, 17 insertions(+), 15 deletions(-)

diff --git a/src/go/types/check_test.go b/src/go/types/check_test.go
index 0bf9b7ae00..c5dc93eade 100644
--- a/src/go/types/check_test.go
+++ b/src/go/types/check_test.go
@@ -45,9 +45,9 @@ import (
 )
 
 var (
-	haltOnError = flag.Bool("halt", false, "halt on error")
-	listErrors  = flag.Bool("errlist", false, "list errors")
-	goVersion   = flag.String("lang", "", "Go language version (e.g. \"go1.12\") for TestManual")
+	haltOnError  = flag.Bool("halt", false, "halt on error")
+	verifyErrors = flag.Bool("verify", false, "verify errors (rather than list them) in TestManual")
+	goVersion    = flag.String("lang", "", "Go language version (e.g. \"go1.12\") for TestManual")
 )
 
 var fset = token.NewFileSet()
@@ -202,7 +202,7 @@ func asGoVersion(s string) string {
 	return ""
 }
 
-func checkFiles(t *testing.T, sizes Sizes, goVersion string, filenames []string, srcs [][]byte) {
+func checkFiles(t *testing.T, sizes Sizes, goVersion string, filenames []string, srcs [][]byte, manual bool) {
 	if len(filenames) == 0 {
 		t.Fatal("no source files")
 	}
@@ -229,7 +229,8 @@ func checkFiles(t *testing.T, sizes Sizes, goVersion string, filenames []string,
 		goVersion = asGoVersion(pkgName)
 	}
 
-	if *listErrors && len(errlist) > 0 {
+	listErrors := manual && !*verifyErrors
+	if listErrors && len(errlist) > 0 {
 		t.Errorf("--- %s:", pkgName)
 		for _, err := range errlist {
 			t.Error(err)
@@ -253,7 +254,7 @@ func checkFiles(t *testing.T, sizes Sizes, goVersion string, filenames []string,
 		if *haltOnError {
 			defer panic(err)
 		}
-		if *listErrors {
+		if listErrors {
 			t.Error(err)
 			return
 		}
@@ -265,7 +266,7 @@ func checkFiles(t *testing.T, sizes Sizes, goVersion string, filenames []string,
 	}
 	conf.Check(pkgName, fset, files, nil)
 
-	if *listErrors {
+	if listErrors {
 		return
 	}
 
@@ -302,8 +303,8 @@ func checkFiles(t *testing.T, sizes Sizes, goVersion string, filenames []string,
 //
 // 	go test -run Manual -- foo.go bar.go
 //
-// To get an error list rather than having the test check against
-// ERROR comments in the input files, provide the -errlist flag.
+// Provide the -verify flag to verify errors against ERROR comments in
+// the input files rather than having a list of errors reported.
 // The accepted Go language version can be controlled with the -lang flag.
 func TestManual(t *testing.T) {
 	filenames := flag.Args()
@@ -312,13 +313,13 @@ func TestManual(t *testing.T) {
 	}
 	testenv.MustHaveGoBuild(t)
 	DefPredeclaredTestFuncs()
-	testPkg(t, filenames, *goVersion)
+	testPkg(t, filenames, *goVersion, true)
 }
 
 func TestLongConstants(t *testing.T) {
 	format := "package longconst\n\nconst _ = %s\nconst _ = %s // ERROR excessively long constant"
 	src := fmt.Sprintf(format, strings.Repeat("1", 9999), strings.Repeat("1", 10001))
-	checkFiles(t, nil, "", []string{"longconst.go"}, [][]byte{[]byte(src)})
+	checkFiles(t, nil, "", []string{"longconst.go"}, [][]byte{[]byte(src)}, false)
 }
 
 // TestIndexRepresentability tests that constant index operands must
@@ -326,7 +327,7 @@ func TestLongConstants(t *testing.T) {
 // represent larger values.
 func TestIndexRepresentability(t *testing.T) {
 	const src = "package index\n\nvar s []byte\nvar _ = s[int64 /* ERROR \"int64\\(1\\) << 40 \\(.*\\) overflows int\" */ (1) << 40]"
-	checkFiles(t, &StdSizes{4, 4}, "", []string{"index.go"}, [][]byte{[]byte(src)})
+	checkFiles(t, &StdSizes{4, 4}, "", []string{"index.go"}, [][]byte{[]byte(src)}, false)
 }
 
 func TestCheck(t *testing.T)     { DefPredeclaredTestFuncs(); testDir(t, "check") }
@@ -361,12 +362,13 @@ func testDir(t *testing.T, dir string) {
 			filenames = []string{path}
 		}
 		t.Run(filepath.Base(path), func(t *testing.T) {
-			testPkg(t, filenames, "")
+			testPkg(t, filenames, "", false)
 		})
 	}
 }
 
-func testPkg(t *testing.T, filenames []string, goVersion string) {
+// TODO(rFindley) reconcile the different test setup in go/types with types2.
+func testPkg(t *testing.T, filenames []string, goVersion string, manual bool) {
 	srcs := make([][]byte, len(filenames))
 	for i, filename := range filenames {
 		src, err := os.ReadFile(filename)
@@ -375,5 +377,5 @@ func testPkg(t *testing.T, filenames []string, goVersion string) {
 		}
 		srcs[i] = src
 	}
-	checkFiles(t, nil, goVersion, filenames, srcs)
+	checkFiles(t, nil, goVersion, filenames, srcs, manual)
 }
-- 
GitLab


From d7473fd9076a978352d3bb29c13464c3c17d46c3 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Fri, 30 Apr 2021 17:21:22 -0400
Subject: [PATCH 1908/2400] cmd/link: mangle ABI name for shared linkage

Currently, when ABI wrappers are used, we don't use ABI aliases.
One exception is shared linkage. When loading a shared library, if
a symbol has only one ABI, and the name is not mangled, we don't
know what ABI it is, so we have to use ABI aliases.

This CL makes it always mangle ABIInternal function name in shared
linkage, so we know what ABI to choose when loading a shared
library. And we now can fully stop using ABI aliases when ABI
wrappers are used.

Change-Id: Id15d9cd72a59f391f54574710ebba7dc44cb6e23
Reviewed-on: https://go-review.googlesource.com/c/go/+/315869
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/ld/lib.go    | 42 ++++--------------------------
 src/cmd/link/internal/ld/macho.go  |  2 +-
 src/cmd/link/internal/ld/pe.go     |  2 +-
 src/cmd/link/internal/ld/symtab.go | 18 ++++++++++---
 4 files changed, 22 insertions(+), 42 deletions(-)

diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index e9349a4b3e..fd687df9ef 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -503,10 +503,8 @@ func (ctxt *Link) loadlib() {
 	default:
 		log.Fatalf("invalid -strictdups flag value %d", *FlagStrictDups)
 	}
-	if !buildcfg.Experiment.RegabiWrappers || ctxt.linkShared {
+	if !buildcfg.Experiment.RegabiWrappers {
 		// Use ABI aliases if ABI wrappers are not used.
-		// TODO: for now we still use ABI aliases in shared linkage, even if
-		// the wrapper is enabled.
 		flags |= loader.FlagUseABIAlias
 	}
 	elfsetstring1 := func(str string, off int) { elfsetstring(ctxt, 0, str, off) }
@@ -2088,25 +2086,6 @@ func ldshlibsyms(ctxt *Link, shlib string) {
 		return
 	}
 
-	// collect text symbol ABI versions.
-	symabi := make(map[string]int) // map (unmangled) symbol name to version
-	if buildcfg.Experiment.RegabiWrappers {
-		for _, elfsym := range syms {
-			if elf.ST_TYPE(elfsym.Info) != elf.STT_FUNC {
-				continue
-			}
-			// Demangle the name. Keep in sync with symtab.go:putelfsym.
-			if strings.HasSuffix(elfsym.Name, ".abiinternal") {
-				// ABIInternal symbol has mangled name, so the primary symbol is ABI0.
-				symabi[strings.TrimSuffix(elfsym.Name, ".abiinternal")] = 0
-			}
-			if strings.HasSuffix(elfsym.Name, ".abi0") {
-				// ABI0 symbol has mangled name, so the primary symbol is ABIInternal.
-				symabi[strings.TrimSuffix(elfsym.Name, ".abi0")] = sym.SymVerABIInternal
-			}
-		}
-	}
-
 	for _, elfsym := range syms {
 		if elf.ST_TYPE(elfsym.Info) == elf.STT_NOTYPE || elf.ST_TYPE(elfsym.Info) == elf.STT_SECTION {
 			continue
@@ -2119,14 +2098,13 @@ func ldshlibsyms(ctxt *Link, shlib string) {
 		if elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC && strings.HasPrefix(elfsym.Name, "type.") {
 			ver = sym.SymVerABIInternal
 		} else if buildcfg.Experiment.RegabiWrappers && elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC {
+			// Demangle the ABI name. Keep in sync with symtab.go:mangleABIName.
 			if strings.HasSuffix(elfsym.Name, ".abiinternal") {
 				ver = sym.SymVerABIInternal
 				symname = strings.TrimSuffix(elfsym.Name, ".abiinternal")
 			} else if strings.HasSuffix(elfsym.Name, ".abi0") {
 				ver = 0
 				symname = strings.TrimSuffix(elfsym.Name, ".abi0")
-			} else if abi, ok := symabi[elfsym.Name]; ok {
-				ver = abi
 			}
 		}
 
@@ -2160,19 +2138,9 @@ func ldshlibsyms(ctxt *Link, shlib string) {
 			l.SetSymExtname(s, elfsym.Name)
 		}
 
-		// For function symbols, we don't know what ABI is
-		// available, so alias it under both ABIs.
-		//
-		// TODO(austin): This is almost certainly wrong once
-		// the ABIs are actually different. We might have to
-		// mangle Go function names in the .so to include the
-		// ABI.
-		if elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC && ver == 0 {
-			if buildcfg.Experiment.RegabiWrappers {
-				if _, ok := symabi[symname]; ok {
-					continue // only use alias for functions w/o ABI wrappers
-				}
-			}
+		// For function symbols, if ABI wrappers are not used, we don't
+		// know what ABI is available, so alias it under both ABIs.
+		if !buildcfg.Experiment.RegabiWrappers && elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC && ver == 0 {
 			alias := ctxt.loader.LookupOrCreateSym(symname, sym.SymVerABIInternal)
 			if l.SymType(alias) != 0 {
 				continue
diff --git a/src/cmd/link/internal/ld/macho.go b/src/cmd/link/internal/ld/macho.go
index ad53e45b38..000bb0b853 100644
--- a/src/cmd/link/internal/ld/macho.go
+++ b/src/cmd/link/internal/ld/macho.go
@@ -1047,7 +1047,7 @@ func machosymtab(ctxt *Link) {
 		// replace "·" as ".", because DTrace cannot handle it.
 		name := strings.Replace(ldr.SymExtname(s), "·", ".", -1)
 
-		name = mangleABIName(ldr, s, name)
+		name = mangleABIName(ctxt, ldr, s, name)
 		symstr.Addstring(name)
 
 		if t := ldr.SymType(s); t == sym.SDYNIMPORT || t == sym.SHOSTOBJ || t == sym.SUNDEFEXT {
diff --git a/src/cmd/link/internal/ld/pe.go b/src/cmd/link/internal/ld/pe.go
index b7d057ebdc..3540c07da1 100644
--- a/src/cmd/link/internal/ld/pe.go
+++ b/src/cmd/link/internal/ld/pe.go
@@ -727,7 +727,7 @@ func (f *peFile) writeSymbols(ctxt *Link) {
 			name = "_" + name
 		}
 
-		name = mangleABIName(ldr, s, name)
+		name = mangleABIName(ctxt, ldr, s, name)
 
 		var peSymType uint16
 		if ctxt.IsExternal() {
diff --git a/src/cmd/link/internal/ld/symtab.go b/src/cmd/link/internal/ld/symtab.go
index 013f7b55b6..3b4fda0c89 100644
--- a/src/cmd/link/internal/ld/symtab.go
+++ b/src/cmd/link/internal/ld/symtab.go
@@ -105,7 +105,7 @@ func putelfsym(ctxt *Link, x loader.Sym, typ elf.SymType, curbind elf.SymBind) {
 	}
 
 	sname := ldr.SymExtname(x)
-	sname = mangleABIName(ldr, x, sname)
+	sname = mangleABIName(ctxt, ldr, x, sname)
 
 	// One pass for each binding: elf.STB_LOCAL, elf.STB_GLOBAL,
 	// maybe one day elf.STB_WEAK.
@@ -834,9 +834,9 @@ func isStaticTmp(name string) bool {
 }
 
 // Mangle function name with ABI information.
-func mangleABIName(ldr *loader.Loader, x loader.Sym, name string) string {
+func mangleABIName(ctxt *Link, ldr *loader.Loader, x loader.Sym, name string) string {
 	// For functions with ABI wrappers, we have to make sure that we
-	// don't wind up with two elf symbol table entries with the same
+	// don't wind up with two symbol table entries with the same
 	// name (since this will generated an error from the external
 	// linker). If we have wrappers, keep the ABIInternal name
 	// unmangled since we want cross-load-module calls to target
@@ -854,5 +854,17 @@ func mangleABIName(ldr *loader.Loader, x loader.Sym, name string) string {
 			name = fmt.Sprintf("%s.abi%d", name, ldr.SymVersion(x))
 		}
 	}
+
+	// When loading a shared library, if a symbol has only one ABI,
+	// and the name is not mangled, we don't know what ABI it is.
+	// So we always mangle ABIInternal function name in shared linkage,
+	// except symbols that are exported to C. Type symbols are always
+	// ABIInternal so they are not mangled.
+	if ctxt.IsShared() {
+		if ldr.SymType(x) == sym.STEXT && ldr.SymVersion(x) == sym.SymVerABIInternal && !ldr.AttrCgoExport(x) && !strings.HasPrefix(name, "type.") {
+			name = fmt.Sprintf("%s.abiinternal", name)
+		}
+	}
+
 	return name
 }
-- 
GitLab


From 053fe2f485fa1fd191f079cdc4a32f33761e38e4 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Fri, 30 Apr 2021 20:53:14 -0400
Subject: [PATCH 1909/2400] cmd/link: emit better error for duplicated
 definition

Print the packages where the duplicates come from.

Change-Id: Ib3dc9aa0a3f5ddd97b03744be6d01d4bfcb33996
Reviewed-on: https://go-review.googlesource.com/c/go/+/315949
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/loader/loader.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/link/internal/loader/loader.go b/src/cmd/link/internal/loader/loader.go
index 1bfcfe435a..1b71a66c6f 100644
--- a/src/cmd/link/internal/loader/loader.go
+++ b/src/cmd/link/internal/loader/loader.go
@@ -471,14 +471,14 @@ func (st *loadState) addSym(name string, ver int, r *oReader, li uint32, kind in
 		// new symbol overwrites old symbol.
 		oldtyp := sym.AbiSymKindToSymKind[objabi.SymKind(oldsym.Type())]
 		if !(oldtyp.IsData() && oldr.DataSize(oldli) == 0) {
-			log.Fatalf("duplicated definition of symbol " + name)
+			log.Fatalf("duplicated definition of symbol %s, from %s and %s", name, r.unit.Lib.Pkg, oldr.unit.Lib.Pkg)
 		}
 		l.objSyms[oldi] = objSym{r.objidx, li}
 	} else {
 		// old symbol overwrites new symbol.
 		typ := sym.AbiSymKindToSymKind[objabi.SymKind(oldsym.Type())]
 		if !typ.IsData() { // only allow overwriting data symbol
-			log.Fatalf("duplicated definition of symbol " + name)
+			log.Fatalf("duplicated definition of symbol %s, from %s and %s", name, r.unit.Lib.Pkg, oldr.unit.Lib.Pkg)
 		}
 	}
 	return oldi
-- 
GitLab


From 352a322a8356ef5f7d9392c401cd9f181a1cf80b Mon Sep 17 00:00:00 2001
From: Vitaly Zdanevich <zdanevich.vitaly@ya.ru>
Date: Sat, 1 May 2021 21:13:38 +0000
Subject: [PATCH 1910/2400] path/filepath: fix documentation typo (was "each
 each")

Change-Id: I8dcf6c4489e16e91b8685c31569297cfeb700f9d
GitHub-Last-Rev: f6b40e029874230789a7ae2b750a42a355ae42cf
GitHub-Pull-Request: golang/go#45905
Reviewed-on: https://go-review.googlesource.com/c/go/+/316009
Reviewed-by: Rob Pike <r@golang.org>
Reviewed-by: Kevin Burke <kev@inburke.com>
Trust: Kevin Burke <kev@inburke.com>
---
 src/path/filepath/path.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/path/filepath/path.go b/src/path/filepath/path.go
index 28b30b1ae7..b56534dead 100644
--- a/src/path/filepath/path.go
+++ b/src/path/filepath/path.go
@@ -340,7 +340,7 @@ func Rel(basepath, targpath string) (string, error) {
 // as an error by any function.
 var SkipDir error = fs.SkipDir
 
-// WalkFunc is the type of the function called by Walk to visit each each
+// WalkFunc is the type of the function called by Walk to visit each
 // file or directory.
 //
 // The path argument contains the argument to Walk as a prefix.
-- 
GitLab


From 0d32d9e8a8784cf3ef39c471b73e502c51085b6d Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Tue, 27 Apr 2021 16:55:04 -0700
Subject: [PATCH 1911/2400] os: document that Windows Symlink to missing target
 creates file symlink

Fixes #39183

Change-Id: Iec4a5a561182ade57dc7dc24247710005d6b9f21
Reviewed-on: https://go-review.googlesource.com/c/go/+/314275
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/os/file_plan9.go   | 2 ++
 src/os/file_unix.go    | 2 ++
 src/os/file_windows.go | 2 ++
 3 files changed, 6 insertions(+)

diff --git a/src/os/file_plan9.go b/src/os/file_plan9.go
index 4f384e9211..604aea607b 100644
--- a/src/os/file_plan9.go
+++ b/src/os/file_plan9.go
@@ -440,6 +440,8 @@ func Link(oldname, newname string) error {
 }
 
 // Symlink creates newname as a symbolic link to oldname.
+// On Windows, a symlink to a non-existent oldname creates a file symlink;
+// if oldname is later created as a directory the symlink will not work.
 // If there is an error, it will be of type *LinkError.
 func Symlink(oldname, newname string) error {
 	return &LinkError{"symlink", oldname, newname, syscall.EPLAN9}
diff --git a/src/os/file_unix.go b/src/os/file_unix.go
index deec41324b..a2531b9656 100644
--- a/src/os/file_unix.go
+++ b/src/os/file_unix.go
@@ -351,6 +351,8 @@ func Link(oldname, newname string) error {
 }
 
 // Symlink creates newname as a symbolic link to oldname.
+// On Windows, a symlink to a non-existent oldname creates a file symlink;
+// if oldname is later created as a directory the symlink will not work.
 // If there is an error, it will be of type *LinkError.
 func Symlink(oldname, newname string) error {
 	e := ignoringEINTR(func() error {
diff --git a/src/os/file_windows.go b/src/os/file_windows.go
index a2cb96e457..378e2b1c7d 100644
--- a/src/os/file_windows.go
+++ b/src/os/file_windows.go
@@ -327,6 +327,8 @@ func Link(oldname, newname string) error {
 }
 
 // Symlink creates newname as a symbolic link to oldname.
+// On Windows, a symlink to a non-existent oldname creates a file symlink;
+// if oldname is later created as a directory the symlink will not work.
 // If there is an error, it will be of type *LinkError.
 func Symlink(oldname, newname string) error {
 	// '/' does not work in link's content
-- 
GitLab


From fadad851a3222867b374e901ede9c4919594837f Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 21 Apr 2021 02:11:15 -0700
Subject: [PATCH 1912/2400] cmd/compile: implement unsafe.Add and unsafe.Slice

Updates #19367.
Updates #40481.

Change-Id: Iabd2afdd0d520e5d68fd9e6dedd013335a4b3886
Reviewed-on: https://go-review.googlesource.com/c/go/+/312214
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Trust: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/escape/escape.go     |   7 +-
 src/cmd/compile/internal/ir/expr.go           |   2 +-
 src/cmd/compile/internal/ir/fmt.go            | 132 ++++++-------
 src/cmd/compile/internal/ir/node.go           |   2 +
 src/cmd/compile/internal/ir/op_string.go      |  90 ++++-----
 src/cmd/compile/internal/noder/expr.go        |   8 +
 src/cmd/compile/internal/noder/transform.go   |   4 +-
 src/cmd/compile/internal/ssagen/ssa.go        |   6 +
 src/cmd/compile/internal/typecheck/builtin.go | 176 +++++++++---------
 .../internal/typecheck/builtin/runtime.go     |   3 +
 src/cmd/compile/internal/typecheck/const.go   |   4 +-
 src/cmd/compile/internal/typecheck/func.go    |  38 +++-
 src/cmd/compile/internal/typecheck/iexport.go |   2 +-
 src/cmd/compile/internal/typecheck/iimport.go |   4 +-
 .../compile/internal/typecheck/typecheck.go   |  37 ++++
 .../compile/internal/typecheck/universe.go    |   2 +
 src/cmd/compile/internal/walk/builtin.go      |  39 ++++
 src/cmd/compile/internal/walk/expr.go         |   7 +-
 src/runtime/slice.go                          |  19 ++
 test/unsafebuiltins.go                        |  61 ++++++
 20 files changed, 439 insertions(+), 204 deletions(-)
 create mode 100644 test/unsafebuiltins.go

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index 05bd44c35d..3ac7ff1ebe 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -677,7 +677,7 @@ func (e *escape) exprSkipInit(k hole, n ir.Node) {
 		n := n.(*ir.UnaryExpr)
 		e.discard(n.X)
 
-	case ir.OCALLMETH, ir.OCALLFUNC, ir.OCALLINTER, ir.OLEN, ir.OCAP, ir.OCOMPLEX, ir.OREAL, ir.OIMAG, ir.OAPPEND, ir.OCOPY:
+	case ir.OCALLMETH, ir.OCALLFUNC, ir.OCALLINTER, ir.OLEN, ir.OCAP, ir.OCOMPLEX, ir.OREAL, ir.OIMAG, ir.OAPPEND, ir.OCOPY, ir.OUNSAFEADD, ir.OUNSAFESLICE:
 		e.call([]hole{k}, n, nil)
 
 	case ir.ONEW:
@@ -1101,6 +1101,11 @@ func (e *escape) call(ks []hole, call, where ir.Node) {
 	case ir.OLEN, ir.OCAP, ir.OREAL, ir.OIMAG, ir.OCLOSE:
 		call := call.(*ir.UnaryExpr)
 		argument(e.discardHole(), call.X)
+
+	case ir.OUNSAFEADD, ir.OUNSAFESLICE:
+		call := call.(*ir.BinaryExpr)
+		argument(ks[0], call.X)
+		argument(e.discardHole(), call.Y)
 	}
 }
 
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 94255116a0..f70645f079 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -136,7 +136,7 @@ func (n *BinaryExpr) SetOp(op Op) {
 		panic(n.no("SetOp " + op.String()))
 	case OADD, OADDSTR, OAND, OANDNOT, ODIV, OEQ, OGE, OGT, OLE,
 		OLSH, OLT, OMOD, OMUL, ONE, OOR, ORSH, OSUB, OXOR,
-		OCOPY, OCOMPLEX,
+		OCOPY, OCOMPLEX, OUNSAFEADD, OUNSAFESLICE,
 		OEFACE:
 		n.op = op
 	}
diff --git a/src/cmd/compile/internal/ir/fmt.go b/src/cmd/compile/internal/ir/fmt.go
index 8eb1cffc59..f2ae0f7606 100644
--- a/src/cmd/compile/internal/ir/fmt.go
+++ b/src/cmd/compile/internal/ir/fmt.go
@@ -25,69 +25,71 @@ import (
 // Op
 
 var OpNames = []string{
-	OADDR:     "&",
-	OADD:      "+",
-	OADDSTR:   "+",
-	OALIGNOF:  "unsafe.Alignof",
-	OANDAND:   "&&",
-	OANDNOT:   "&^",
-	OAND:      "&",
-	OAPPEND:   "append",
-	OAS:       "=",
-	OAS2:      "=",
-	OBREAK:    "break",
-	OCALL:     "function call", // not actual syntax
-	OCAP:      "cap",
-	OCASE:     "case",
-	OCLOSE:    "close",
-	OCOMPLEX:  "complex",
-	OBITNOT:   "^",
-	OCONTINUE: "continue",
-	OCOPY:     "copy",
-	ODELETE:   "delete",
-	ODEFER:    "defer",
-	ODIV:      "/",
-	OEQ:       "==",
-	OFALL:     "fallthrough",
-	OFOR:      "for",
-	OFORUNTIL: "foruntil", // not actual syntax; used to avoid off-end pointer live on backedge.892
-	OGE:       ">=",
-	OGOTO:     "goto",
-	OGT:       ">",
-	OIF:       "if",
-	OIMAG:     "imag",
-	OINLMARK:  "inlmark",
-	ODEREF:    "*",
-	OLEN:      "len",
-	OLE:       "<=",
-	OLSH:      "<<",
-	OLT:       "<",
-	OMAKE:     "make",
-	ONEG:      "-",
-	OMOD:      "%",
-	OMUL:      "*",
-	ONEW:      "new",
-	ONE:       "!=",
-	ONOT:      "!",
-	OOFFSETOF: "unsafe.Offsetof",
-	OOROR:     "||",
-	OOR:       "|",
-	OPANIC:    "panic",
-	OPLUS:     "+",
-	OPRINTN:   "println",
-	OPRINT:    "print",
-	ORANGE:    "range",
-	OREAL:     "real",
-	ORECV:     "<-",
-	ORECOVER:  "recover",
-	ORETURN:   "return",
-	ORSH:      ">>",
-	OSELECT:   "select",
-	OSEND:     "<-",
-	OSIZEOF:   "unsafe.Sizeof",
-	OSUB:      "-",
-	OSWITCH:   "switch",
-	OXOR:      "^",
+	OADDR:        "&",
+	OADD:         "+",
+	OADDSTR:      "+",
+	OALIGNOF:     "unsafe.Alignof",
+	OANDAND:      "&&",
+	OANDNOT:      "&^",
+	OAND:         "&",
+	OAPPEND:      "append",
+	OAS:          "=",
+	OAS2:         "=",
+	OBREAK:       "break",
+	OCALL:        "function call", // not actual syntax
+	OCAP:         "cap",
+	OCASE:        "case",
+	OCLOSE:       "close",
+	OCOMPLEX:     "complex",
+	OBITNOT:      "^",
+	OCONTINUE:    "continue",
+	OCOPY:        "copy",
+	ODELETE:      "delete",
+	ODEFER:       "defer",
+	ODIV:         "/",
+	OEQ:          "==",
+	OFALL:        "fallthrough",
+	OFOR:         "for",
+	OFORUNTIL:    "foruntil", // not actual syntax; used to avoid off-end pointer live on backedge.892
+	OGE:          ">=",
+	OGOTO:        "goto",
+	OGT:          ">",
+	OIF:          "if",
+	OIMAG:        "imag",
+	OINLMARK:     "inlmark",
+	ODEREF:       "*",
+	OLEN:         "len",
+	OLE:          "<=",
+	OLSH:         "<<",
+	OLT:          "<",
+	OMAKE:        "make",
+	ONEG:         "-",
+	OMOD:         "%",
+	OMUL:         "*",
+	ONEW:         "new",
+	ONE:          "!=",
+	ONOT:         "!",
+	OOFFSETOF:    "unsafe.Offsetof",
+	OOROR:        "||",
+	OOR:          "|",
+	OPANIC:       "panic",
+	OPLUS:        "+",
+	OPRINTN:      "println",
+	OPRINT:       "print",
+	ORANGE:       "range",
+	OREAL:        "real",
+	ORECV:        "<-",
+	ORECOVER:     "recover",
+	ORETURN:      "return",
+	ORSH:         ">>",
+	OSELECT:      "select",
+	OSEND:        "<-",
+	OSIZEOF:      "unsafe.Sizeof",
+	OSUB:         "-",
+	OSWITCH:      "switch",
+	OUNSAFEADD:   "unsafe.Add",
+	OUNSAFESLICE: "unsafe.Slice",
+	OXOR:         "^",
 }
 
 // GoString returns the Go syntax for the Op, or else its name.
@@ -218,6 +220,8 @@ var OpPrec = []int{
 	OTMAP:          8,
 	OTSTRUCT:       8,
 	OTYPE:          8,
+	OUNSAFEADD:     8,
+	OUNSAFESLICE:   8,
 	OINDEXMAP:      8,
 	OINDEX:         8,
 	OSLICE:         8,
@@ -794,7 +798,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
 		n := n.(*SliceHeaderExpr)
 		fmt.Fprintf(s, "sliceheader{%v,%v,%v}", n.Ptr, n.Len, n.Cap)
 
-	case OCOMPLEX, OCOPY:
+	case OCOMPLEX, OCOPY, OUNSAFEADD, OUNSAFESLICE:
 		n := n.(*BinaryExpr)
 		fmt.Fprintf(s, "%v(%v, %v)", n.Op(), n.X, n.Y)
 
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index a73b81d196..af559cc082 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -247,6 +247,8 @@ const (
 	OALIGNOF     // unsafe.Alignof(X)
 	OOFFSETOF    // unsafe.Offsetof(X)
 	OSIZEOF      // unsafe.Sizeof(X)
+	OUNSAFEADD   // unsafe.Add(X, Y)
+	OUNSAFESLICE // unsafe.Slice(X, Y)
 	OMETHEXPR    // method expression
 
 	// statements
diff --git a/src/cmd/compile/internal/ir/op_string.go b/src/cmd/compile/internal/ir/op_string.go
index 776a5c1e8d..405a0c6b3c 100644
--- a/src/cmd/compile/internal/ir/op_string.go
+++ b/src/cmd/compile/internal/ir/op_string.go
@@ -119,53 +119,55 @@ func _() {
 	_ = x[OALIGNOF-108]
 	_ = x[OOFFSETOF-109]
 	_ = x[OSIZEOF-110]
-	_ = x[OMETHEXPR-111]
-	_ = x[OBLOCK-112]
-	_ = x[OBREAK-113]
-	_ = x[OCASE-114]
-	_ = x[OCONTINUE-115]
-	_ = x[ODEFER-116]
-	_ = x[OFALL-117]
-	_ = x[OFOR-118]
-	_ = x[OFORUNTIL-119]
-	_ = x[OGOTO-120]
-	_ = x[OIF-121]
-	_ = x[OLABEL-122]
-	_ = x[OGO-123]
-	_ = x[ORANGE-124]
-	_ = x[ORETURN-125]
-	_ = x[OSELECT-126]
-	_ = x[OSWITCH-127]
-	_ = x[OTYPESW-128]
-	_ = x[OFUNCINST-129]
-	_ = x[OTCHAN-130]
-	_ = x[OTMAP-131]
-	_ = x[OTSTRUCT-132]
-	_ = x[OTINTER-133]
-	_ = x[OTFUNC-134]
-	_ = x[OTARRAY-135]
-	_ = x[OTSLICE-136]
-	_ = x[OINLCALL-137]
-	_ = x[OEFACE-138]
-	_ = x[OITAB-139]
-	_ = x[OIDATA-140]
-	_ = x[OSPTR-141]
-	_ = x[OCFUNC-142]
-	_ = x[OCHECKNIL-143]
-	_ = x[OVARDEF-144]
-	_ = x[OVARKILL-145]
-	_ = x[OVARLIVE-146]
-	_ = x[ORESULT-147]
-	_ = x[OINLMARK-148]
-	_ = x[OLINKSYMOFFSET-149]
-	_ = x[OTAILCALL-150]
-	_ = x[OGETG-151]
-	_ = x[OEND-152]
+	_ = x[OUNSAFEADD-111]
+	_ = x[OUNSAFESLICE-112]
+	_ = x[OMETHEXPR-113]
+	_ = x[OBLOCK-114]
+	_ = x[OBREAK-115]
+	_ = x[OCASE-116]
+	_ = x[OCONTINUE-117]
+	_ = x[ODEFER-118]
+	_ = x[OFALL-119]
+	_ = x[OFOR-120]
+	_ = x[OFORUNTIL-121]
+	_ = x[OGOTO-122]
+	_ = x[OIF-123]
+	_ = x[OLABEL-124]
+	_ = x[OGO-125]
+	_ = x[ORANGE-126]
+	_ = x[ORETURN-127]
+	_ = x[OSELECT-128]
+	_ = x[OSWITCH-129]
+	_ = x[OTYPESW-130]
+	_ = x[OFUNCINST-131]
+	_ = x[OTCHAN-132]
+	_ = x[OTMAP-133]
+	_ = x[OTSTRUCT-134]
+	_ = x[OTINTER-135]
+	_ = x[OTFUNC-136]
+	_ = x[OTARRAY-137]
+	_ = x[OTSLICE-138]
+	_ = x[OINLCALL-139]
+	_ = x[OEFACE-140]
+	_ = x[OITAB-141]
+	_ = x[OIDATA-142]
+	_ = x[OSPTR-143]
+	_ = x[OCFUNC-144]
+	_ = x[OCHECKNIL-145]
+	_ = x[OVARDEF-146]
+	_ = x[OVARKILL-147]
+	_ = x[OVARLIVE-148]
+	_ = x[ORESULT-149]
+	_ = x[OINLMARK-150]
+	_ = x[OLINKSYMOFFSET-151]
+	_ = x[OTAILCALL-152]
+	_ = x[OGETG-153]
+	_ = x[OEND-154]
 }
 
-const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESSLICE2ARRPTRASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFMETHEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWFUNCINSTTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKLINKSYMOFFSETTAILCALLGETGEND"
+const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESSLICE2ARRPTRASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCALLPARTCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFUNSAFEADDUNSAFESLICEMETHEXPRBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWFUNCINSTTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKLINKSYMOFFSETTAILCALLGETGEND"
 
-var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 136, 138, 141, 151, 158, 165, 172, 176, 180, 188, 196, 205, 213, 216, 221, 228, 235, 241, 250, 258, 266, 272, 276, 285, 292, 296, 299, 306, 314, 321, 327, 330, 336, 343, 351, 355, 362, 370, 372, 374, 376, 378, 380, 382, 387, 392, 400, 403, 412, 415, 419, 427, 434, 443, 456, 459, 462, 465, 468, 471, 474, 480, 483, 486, 492, 496, 499, 503, 508, 513, 519, 524, 528, 533, 541, 549, 555, 564, 575, 582, 586, 593, 601, 605, 609, 613, 620, 627, 635, 641, 649, 654, 659, 663, 671, 676, 680, 683, 691, 695, 697, 702, 704, 709, 715, 721, 727, 733, 741, 746, 750, 757, 763, 768, 774, 780, 787, 792, 796, 801, 805, 810, 818, 824, 831, 838, 844, 851, 864, 872, 876, 879}
+var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 136, 138, 141, 151, 158, 165, 172, 176, 180, 188, 196, 205, 213, 216, 221, 228, 235, 241, 250, 258, 266, 272, 276, 285, 292, 296, 299, 306, 314, 321, 327, 330, 336, 343, 351, 355, 362, 370, 372, 374, 376, 378, 380, 382, 387, 392, 400, 403, 412, 415, 419, 427, 434, 443, 456, 459, 462, 465, 468, 471, 474, 480, 483, 486, 492, 496, 499, 503, 508, 513, 519, 524, 528, 533, 541, 549, 555, 564, 575, 582, 586, 593, 601, 605, 609, 613, 620, 627, 635, 641, 650, 661, 669, 674, 679, 683, 691, 696, 700, 703, 711, 715, 717, 722, 724, 729, 735, 741, 747, 753, 761, 766, 770, 777, 783, 788, 794, 800, 807, 812, 816, 821, 825, 830, 838, 844, 851, 858, 864, 871, 884, 892, 896, 899}
 
 func (i Op) String() string {
 	if i >= Op(len(_Op_index)-1) {
diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index b2c2616b35..c7695ed920 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -29,6 +29,14 @@ func (g *irgen) expr(expr syntax.Expr) ir.Node {
 	}
 	switch {
 	case tv.IsBuiltin():
+		// Qualified builtins, such as unsafe.Add and unsafe.Slice.
+		if expr, ok := expr.(*syntax.SelectorExpr); ok {
+			if name, ok := expr.X.(*syntax.Name); ok {
+				if _, ok := g.info.Uses[name].(*types2.PkgName); ok {
+					return g.use(expr.Sel)
+				}
+			}
+		}
 		return g.use(expr.(*syntax.Name))
 	case tv.IsType():
 		return ir.TypeNode(g.typ(tv.Type))
diff --git a/src/cmd/compile/internal/noder/transform.go b/src/cmd/compile/internal/noder/transform.go
index 31f8d1d61b..2859089e69 100644
--- a/src/cmd/compile/internal/noder/transform.go
+++ b/src/cmd/compile/internal/noder/transform.go
@@ -795,11 +795,11 @@ func transformBuiltin(n *ir.CallExpr) ir.Node {
 			return u1
 		}
 
-	case ir.OCOMPLEX, ir.OCOPY:
+	case ir.OCOMPLEX, ir.OCOPY, ir.OUNSAFEADD, ir.OUNSAFESLICE:
 		transformArgs(n)
 		b := ir.NewBinaryExpr(n.Pos(), op, n.Args[0], n.Args[1])
 		n1 := typed(n.Type(), ir.InitExpr(n.Init(), b))
-		if op == ir.OCOPY {
+		if op != ir.OCOMPLEX {
 			// nothing more to do
 			return n1
 		}
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 5eda8c4b1c..0d4e3264ba 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -3196,6 +3196,12 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		n := n.(*ir.UnaryExpr)
 		return s.newObject(n.Type().Elem())
 
+	case ir.OUNSAFEADD:
+		n := n.(*ir.BinaryExpr)
+		ptr := s.expr(n.X)
+		len := s.expr(n.Y)
+		return s.newValue2(ssa.OpAddPtr, n.Type(), ptr, len)
+
 	default:
 		s.Fatalf("unhandled expr %v", n.Op())
 		return nil
diff --git a/src/cmd/compile/internal/typecheck/builtin.go b/src/cmd/compile/internal/typecheck/builtin.go
index 0631a67780..67a894c7ed 100644
--- a/src/cmd/compile/internal/typecheck/builtin.go
+++ b/src/cmd/compile/internal/typecheck/builtin.go
@@ -136,69 +136,71 @@ var runtimeDecls = [...]struct {
 	{"makeslice64", funcTag, 113},
 	{"makeslicecopy", funcTag, 114},
 	{"growslice", funcTag, 116},
-	{"memmove", funcTag, 117},
-	{"memclrNoHeapPointers", funcTag, 118},
-	{"memclrHasPointers", funcTag, 118},
-	{"memequal", funcTag, 119},
-	{"memequal0", funcTag, 120},
-	{"memequal8", funcTag, 120},
-	{"memequal16", funcTag, 120},
-	{"memequal32", funcTag, 120},
-	{"memequal64", funcTag, 120},
-	{"memequal128", funcTag, 120},
-	{"f32equal", funcTag, 121},
-	{"f64equal", funcTag, 121},
-	{"c64equal", funcTag, 121},
-	{"c128equal", funcTag, 121},
-	{"strequal", funcTag, 121},
-	{"interequal", funcTag, 121},
-	{"nilinterequal", funcTag, 121},
-	{"memhash", funcTag, 122},
-	{"memhash0", funcTag, 123},
-	{"memhash8", funcTag, 123},
-	{"memhash16", funcTag, 123},
-	{"memhash32", funcTag, 123},
-	{"memhash64", funcTag, 123},
-	{"memhash128", funcTag, 123},
-	{"f32hash", funcTag, 123},
-	{"f64hash", funcTag, 123},
-	{"c64hash", funcTag, 123},
-	{"c128hash", funcTag, 123},
-	{"strhash", funcTag, 123},
-	{"interhash", funcTag, 123},
-	{"nilinterhash", funcTag, 123},
-	{"int64div", funcTag, 124},
-	{"uint64div", funcTag, 125},
-	{"int64mod", funcTag, 124},
-	{"uint64mod", funcTag, 125},
-	{"float64toint64", funcTag, 126},
-	{"float64touint64", funcTag, 127},
-	{"float64touint32", funcTag, 128},
-	{"int64tofloat64", funcTag, 129},
-	{"uint64tofloat64", funcTag, 130},
-	{"uint32tofloat64", funcTag, 131},
-	{"complex128div", funcTag, 132},
-	{"getcallerpc", funcTag, 133},
-	{"getcallersp", funcTag, 133},
+	{"unsafeslice", funcTag, 117},
+	{"unsafeslice64", funcTag, 118},
+	{"memmove", funcTag, 119},
+	{"memclrNoHeapPointers", funcTag, 120},
+	{"memclrHasPointers", funcTag, 120},
+	{"memequal", funcTag, 121},
+	{"memequal0", funcTag, 122},
+	{"memequal8", funcTag, 122},
+	{"memequal16", funcTag, 122},
+	{"memequal32", funcTag, 122},
+	{"memequal64", funcTag, 122},
+	{"memequal128", funcTag, 122},
+	{"f32equal", funcTag, 123},
+	{"f64equal", funcTag, 123},
+	{"c64equal", funcTag, 123},
+	{"c128equal", funcTag, 123},
+	{"strequal", funcTag, 123},
+	{"interequal", funcTag, 123},
+	{"nilinterequal", funcTag, 123},
+	{"memhash", funcTag, 124},
+	{"memhash0", funcTag, 125},
+	{"memhash8", funcTag, 125},
+	{"memhash16", funcTag, 125},
+	{"memhash32", funcTag, 125},
+	{"memhash64", funcTag, 125},
+	{"memhash128", funcTag, 125},
+	{"f32hash", funcTag, 125},
+	{"f64hash", funcTag, 125},
+	{"c64hash", funcTag, 125},
+	{"c128hash", funcTag, 125},
+	{"strhash", funcTag, 125},
+	{"interhash", funcTag, 125},
+	{"nilinterhash", funcTag, 125},
+	{"int64div", funcTag, 126},
+	{"uint64div", funcTag, 127},
+	{"int64mod", funcTag, 126},
+	{"uint64mod", funcTag, 127},
+	{"float64toint64", funcTag, 128},
+	{"float64touint64", funcTag, 129},
+	{"float64touint32", funcTag, 130},
+	{"int64tofloat64", funcTag, 131},
+	{"uint64tofloat64", funcTag, 132},
+	{"uint32tofloat64", funcTag, 133},
+	{"complex128div", funcTag, 134},
+	{"getcallerpc", funcTag, 135},
+	{"getcallersp", funcTag, 135},
 	{"racefuncenter", funcTag, 31},
 	{"racefuncexit", funcTag, 9},
 	{"raceread", funcTag, 31},
 	{"racewrite", funcTag, 31},
-	{"racereadrange", funcTag, 134},
-	{"racewriterange", funcTag, 134},
-	{"msanread", funcTag, 134},
-	{"msanwrite", funcTag, 134},
-	{"msanmove", funcTag, 135},
-	{"checkptrAlignment", funcTag, 136},
-	{"checkptrArithmetic", funcTag, 138},
-	{"libfuzzerTraceCmp1", funcTag, 139},
-	{"libfuzzerTraceCmp2", funcTag, 140},
-	{"libfuzzerTraceCmp4", funcTag, 141},
-	{"libfuzzerTraceCmp8", funcTag, 142},
-	{"libfuzzerTraceConstCmp1", funcTag, 139},
-	{"libfuzzerTraceConstCmp2", funcTag, 140},
-	{"libfuzzerTraceConstCmp4", funcTag, 141},
-	{"libfuzzerTraceConstCmp8", funcTag, 142},
+	{"racereadrange", funcTag, 136},
+	{"racewriterange", funcTag, 136},
+	{"msanread", funcTag, 136},
+	{"msanwrite", funcTag, 136},
+	{"msanmove", funcTag, 137},
+	{"checkptrAlignment", funcTag, 138},
+	{"checkptrArithmetic", funcTag, 140},
+	{"libfuzzerTraceCmp1", funcTag, 141},
+	{"libfuzzerTraceCmp2", funcTag, 142},
+	{"libfuzzerTraceCmp4", funcTag, 143},
+	{"libfuzzerTraceCmp8", funcTag, 144},
+	{"libfuzzerTraceConstCmp1", funcTag, 141},
+	{"libfuzzerTraceConstCmp2", funcTag, 142},
+	{"libfuzzerTraceConstCmp4", funcTag, 143},
+	{"libfuzzerTraceConstCmp8", funcTag, 144},
 	{"x86HasPOPCNT", varTag, 6},
 	{"x86HasSSE41", varTag, 6},
 	{"x86HasFMA", varTag, 6},
@@ -221,7 +223,7 @@ func params(tlist ...*types.Type) []*types.Field {
 }
 
 func runtimeTypes() []*types.Type {
-	var typs [143]*types.Type
+	var typs [145]*types.Type
 	typs[0] = types.ByteType
 	typs[1] = types.NewPtr(typs[0])
 	typs[2] = types.Types[types.TANY]
@@ -339,31 +341,33 @@ func runtimeTypes() []*types.Type {
 	typs[114] = newSig(params(typs[1], typs[15], typs[15], typs[7]), params(typs[7]))
 	typs[115] = types.NewSlice(typs[2])
 	typs[116] = newSig(params(typs[1], typs[115], typs[15]), params(typs[115]))
-	typs[117] = newSig(params(typs[3], typs[3], typs[5]), nil)
-	typs[118] = newSig(params(typs[7], typs[5]), nil)
-	typs[119] = newSig(params(typs[3], typs[3], typs[5]), params(typs[6]))
-	typs[120] = newSig(params(typs[3], typs[3]), params(typs[6]))
-	typs[121] = newSig(params(typs[7], typs[7]), params(typs[6]))
-	typs[122] = newSig(params(typs[7], typs[5], typs[5]), params(typs[5]))
-	typs[123] = newSig(params(typs[7], typs[5]), params(typs[5]))
-	typs[124] = newSig(params(typs[22], typs[22]), params(typs[22]))
-	typs[125] = newSig(params(typs[24], typs[24]), params(typs[24]))
-	typs[126] = newSig(params(typs[20]), params(typs[22]))
-	typs[127] = newSig(params(typs[20]), params(typs[24]))
-	typs[128] = newSig(params(typs[20]), params(typs[60]))
-	typs[129] = newSig(params(typs[22]), params(typs[20]))
-	typs[130] = newSig(params(typs[24]), params(typs[20]))
-	typs[131] = newSig(params(typs[60]), params(typs[20]))
-	typs[132] = newSig(params(typs[26], typs[26]), params(typs[26]))
-	typs[133] = newSig(nil, params(typs[5]))
-	typs[134] = newSig(params(typs[5], typs[5]), nil)
-	typs[135] = newSig(params(typs[5], typs[5], typs[5]), nil)
-	typs[136] = newSig(params(typs[7], typs[1], typs[5]), nil)
-	typs[137] = types.NewSlice(typs[7])
-	typs[138] = newSig(params(typs[7], typs[137]), nil)
-	typs[139] = newSig(params(typs[64], typs[64]), nil)
-	typs[140] = newSig(params(typs[58], typs[58]), nil)
-	typs[141] = newSig(params(typs[60], typs[60]), nil)
-	typs[142] = newSig(params(typs[24], typs[24]), nil)
+	typs[117] = newSig(params(typs[1], typs[15]), nil)
+	typs[118] = newSig(params(typs[1], typs[22]), nil)
+	typs[119] = newSig(params(typs[3], typs[3], typs[5]), nil)
+	typs[120] = newSig(params(typs[7], typs[5]), nil)
+	typs[121] = newSig(params(typs[3], typs[3], typs[5]), params(typs[6]))
+	typs[122] = newSig(params(typs[3], typs[3]), params(typs[6]))
+	typs[123] = newSig(params(typs[7], typs[7]), params(typs[6]))
+	typs[124] = newSig(params(typs[7], typs[5], typs[5]), params(typs[5]))
+	typs[125] = newSig(params(typs[7], typs[5]), params(typs[5]))
+	typs[126] = newSig(params(typs[22], typs[22]), params(typs[22]))
+	typs[127] = newSig(params(typs[24], typs[24]), params(typs[24]))
+	typs[128] = newSig(params(typs[20]), params(typs[22]))
+	typs[129] = newSig(params(typs[20]), params(typs[24]))
+	typs[130] = newSig(params(typs[20]), params(typs[60]))
+	typs[131] = newSig(params(typs[22]), params(typs[20]))
+	typs[132] = newSig(params(typs[24]), params(typs[20]))
+	typs[133] = newSig(params(typs[60]), params(typs[20]))
+	typs[134] = newSig(params(typs[26], typs[26]), params(typs[26]))
+	typs[135] = newSig(nil, params(typs[5]))
+	typs[136] = newSig(params(typs[5], typs[5]), nil)
+	typs[137] = newSig(params(typs[5], typs[5], typs[5]), nil)
+	typs[138] = newSig(params(typs[7], typs[1], typs[5]), nil)
+	typs[139] = types.NewSlice(typs[7])
+	typs[140] = newSig(params(typs[7], typs[139]), nil)
+	typs[141] = newSig(params(typs[64], typs[64]), nil)
+	typs[142] = newSig(params(typs[58], typs[58]), nil)
+	typs[143] = newSig(params(typs[60], typs[60]), nil)
+	typs[144] = newSig(params(typs[24], typs[24]), nil)
 	return typs[:]
 }
diff --git a/src/cmd/compile/internal/typecheck/builtin/runtime.go b/src/cmd/compile/internal/typecheck/builtin/runtime.go
index e736f913b6..ebeaeae79e 100644
--- a/src/cmd/compile/internal/typecheck/builtin/runtime.go
+++ b/src/cmd/compile/internal/typecheck/builtin/runtime.go
@@ -183,6 +183,9 @@ func makeslice(typ *byte, len int, cap int) unsafe.Pointer
 func makeslice64(typ *byte, len int64, cap int64) unsafe.Pointer
 func makeslicecopy(typ *byte, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointer
 func growslice(typ *byte, old []any, cap int) (ary []any)
+func unsafeslice(typ *byte, len int)
+func unsafeslice64(typ *byte, len int64)
+
 func memmove(to *any, frm *any, length uintptr)
 func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
 func memclrHasPointers(ptr unsafe.Pointer, n uintptr)
diff --git a/src/cmd/compile/internal/typecheck/const.go b/src/cmd/compile/internal/typecheck/const.go
index 9b3a27b2d8..5a35eeade9 100644
--- a/src/cmd/compile/internal/typecheck/const.go
+++ b/src/cmd/compile/internal/typecheck/const.go
@@ -760,7 +760,9 @@ func anyCallOrChan(n ir.Node) bool {
 			ir.OPRINTN,
 			ir.OREAL,
 			ir.ORECOVER,
-			ir.ORECV:
+			ir.ORECV,
+			ir.OUNSAFEADD,
+			ir.OUNSAFESLICE:
 			return true
 		}
 		return false
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index eaae2a81fa..e154c39269 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -430,7 +430,7 @@ func tcCall(n *ir.CallExpr, top int) ir.Node {
 			u := ir.NewUnaryExpr(n.Pos(), l.BuiltinOp, arg)
 			return typecheck(ir.InitExpr(n.Init(), u), top) // typecheckargs can add to old.Init
 
-		case ir.OCOMPLEX, ir.OCOPY:
+		case ir.OCOMPLEX, ir.OCOPY, ir.OUNSAFEADD, ir.OUNSAFESLICE:
 			typecheckargs(n)
 			arg1, arg2, ok := needTwoArgs(n)
 			if !ok {
@@ -977,3 +977,39 @@ func tcRecover(n *ir.CallExpr) ir.Node {
 	n.SetType(types.Types[types.TINTER])
 	return n
 }
+
+// tcUnsafeAdd typechecks an OUNSAFEADD node.
+func tcUnsafeAdd(n *ir.BinaryExpr) *ir.BinaryExpr {
+	n.X = AssignConv(Expr(n.X), types.Types[types.TUNSAFEPTR], "argument to unsafe.Add")
+	n.Y = DefaultLit(Expr(n.Y), types.Types[types.TINT])
+	if n.X.Type() == nil || n.Y.Type() == nil {
+		n.SetType(nil)
+		return n
+	}
+	if !n.Y.Type().IsInteger() {
+		n.SetType(nil)
+		return n
+	}
+	n.SetType(n.X.Type())
+	return n
+}
+
+// tcUnsafeSlice typechecks an OUNSAFESLICE node.
+func tcUnsafeSlice(n *ir.BinaryExpr) *ir.BinaryExpr {
+	n.X = Expr(n.X)
+	n.Y = Expr(n.Y)
+	if n.X.Type() == nil || n.Y.Type() == nil {
+		n.SetType(nil)
+		return n
+	}
+	t := n.X.Type()
+	if !t.IsPtr() {
+		base.Errorf("first argument to unsafe.Slice must be pointer; have %L", t)
+	}
+	if !checkunsafeslice(&n.Y) {
+		n.SetType(nil)
+		return n
+	}
+	n.SetType(types.NewSlice(t.Elem()))
+	return n
+}
diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index ad9eaab07a..64d68ef625 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -1664,7 +1664,7 @@ func (w *exportWriter) expr(n ir.Node) {
 			w.typ(n.Type())
 		}
 
-	case ir.OCOPY, ir.OCOMPLEX:
+	case ir.OCOPY, ir.OCOMPLEX, ir.OUNSAFEADD, ir.OUNSAFESLICE:
 		// treated like other builtin calls (see e.g., OREAL)
 		n := n.(*ir.BinaryExpr)
 		w.op(n.Op())
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 642abe61ba..00f6a6e483 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -1269,10 +1269,10 @@ func (r *importReader) node() ir.Node {
 		}
 		return ir.NewConvExpr(r.pos(), op, r.typ(), r.expr())
 
-	case ir.OCOPY, ir.OCOMPLEX, ir.OREAL, ir.OIMAG, ir.OAPPEND, ir.OCAP, ir.OCLOSE, ir.ODELETE, ir.OLEN, ir.OMAKE, ir.ONEW, ir.OPANIC, ir.ORECOVER, ir.OPRINT, ir.OPRINTN:
+	case ir.OCOPY, ir.OCOMPLEX, ir.OREAL, ir.OIMAG, ir.OAPPEND, ir.OCAP, ir.OCLOSE, ir.ODELETE, ir.OLEN, ir.OMAKE, ir.ONEW, ir.OPANIC, ir.ORECOVER, ir.OPRINT, ir.OPRINTN, ir.OUNSAFEADD, ir.OUNSAFESLICE:
 		if go117ExportTypes {
 			switch op {
-			case ir.OCOPY, ir.OCOMPLEX:
+			case ir.OCOPY, ir.OCOMPLEX, ir.OUNSAFEADD, ir.OUNSAFESLICE:
 				n := ir.NewBinaryExpr(r.pos(), op, r.expr(), r.expr())
 				n.SetType(r.typ())
 				return n
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 00dd44b96b..1650144375 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -775,6 +775,14 @@ func typecheck1(n ir.Node, top int) ir.Node {
 		n := n.(*ir.CallExpr)
 		return tcRecover(n)
 
+	case ir.OUNSAFEADD:
+		n := n.(*ir.BinaryExpr)
+		return tcUnsafeAdd(n)
+
+	case ir.OUNSAFESLICE:
+		n := n.(*ir.BinaryExpr)
+		return tcUnsafeSlice(n)
+
 	case ir.OCLOSURE:
 		n := n.(*ir.ClosureExpr)
 		tcClosure(n, top)
@@ -1934,6 +1942,35 @@ func checkmake(t *types.Type, arg string, np *ir.Node) bool {
 	return true
 }
 
+// checkunsafeslice is like checkmake but for unsafe.Slice.
+func checkunsafeslice(np *ir.Node) bool {
+	n := *np
+	if !n.Type().IsInteger() && n.Type().Kind() != types.TIDEAL {
+		base.Errorf("non-integer len argument in unsafe.Slice - %v", n.Type())
+		return false
+	}
+
+	// Do range checks for constants before DefaultLit
+	// to avoid redundant "constant NNN overflows int" errors.
+	if n.Op() == ir.OLITERAL {
+		v := toint(n.Val())
+		if constant.Sign(v) < 0 {
+			base.Errorf("negative len argument in unsafe.Slice")
+			return false
+		}
+		if ir.ConstOverflow(v, types.Types[types.TINT]) {
+			base.Errorf("len argument too large in unsafe.Slice")
+			return false
+		}
+	}
+
+	// DefaultLit is necessary for non-constants too: n might be 1.1<<k.
+	n = DefaultLit(n, types.Types[types.TINT])
+	*np = n
+
+	return true
+}
+
 // markBreak marks control statements containing break statements with SetHasBreak(true).
 func markBreak(fn *ir.Func) {
 	var labels map[*types.Sym]ir.Node
diff --git a/src/cmd/compile/internal/typecheck/universe.go b/src/cmd/compile/internal/typecheck/universe.go
index f04dcb671c..de185ab944 100644
--- a/src/cmd/compile/internal/typecheck/universe.go
+++ b/src/cmd/compile/internal/typecheck/universe.go
@@ -85,9 +85,11 @@ var unsafeFuncs = [...]struct {
 	name string
 	op   ir.Op
 }{
+	{"Add", ir.OUNSAFEADD},
 	{"Alignof", ir.OALIGNOF},
 	{"Offsetof", ir.OOFFSETOF},
 	{"Sizeof", ir.OSIZEOF},
+	{"Slice", ir.OUNSAFESLICE},
 }
 
 // InitUniverse initializes the universe block.
diff --git a/src/cmd/compile/internal/walk/builtin.go b/src/cmd/compile/internal/walk/builtin.go
index aacdedcb4d..62eb4298f4 100644
--- a/src/cmd/compile/internal/walk/builtin.go
+++ b/src/cmd/compile/internal/walk/builtin.go
@@ -653,6 +653,45 @@ func walkRecover(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 	return mkcall("gorecover", nn.Type(), init, fp)
 }
 
+func walkUnsafeSlice(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
+	len := safeExpr(n.Y, init)
+
+	fnname := "unsafeslice64"
+	argtype := types.Types[types.TINT64]
+
+	// Type checking guarantees that TIDEAL len/cap are positive and fit in an int.
+	// The case of len or cap overflow when converting TUINT or TUINTPTR to TINT
+	// will be handled by the negative range checks in unsafeslice during runtime.
+	if len.Type().IsKind(types.TIDEAL) || len.Type().Size() <= types.Types[types.TUINT].Size() {
+		fnname = "unsafeslice"
+		argtype = types.Types[types.TINT]
+	}
+
+	t := n.Type()
+
+	// Call runtime.unsafeslice[64] to check that the length argument is
+	// non-negative and smaller than the max length allowed for the
+	// element type.
+	fn := typecheck.LookupRuntime(fnname)
+	init.Append(mkcall1(fn, nil, init, reflectdata.TypePtr(t.Elem()), typecheck.Conv(len, argtype)))
+
+	ptr := walkExpr(n.X, init)
+
+	c := ir.NewUnaryExpr(n.Pos(), ir.OCHECKNIL, ptr)
+	c.SetTypecheck(1)
+	init.Append(c)
+
+	// TODO(mdempsky): checkptr instrumentation. Maybe merge into length
+	// check above, along with nil check? Need to be careful about
+	// notinheap pointers though: can't pass them as unsafe.Pointer.
+
+	h := ir.NewSliceHeaderExpr(n.Pos(), t,
+		typecheck.Conv(ptr, types.Types[types.TUNSAFEPTR]),
+		typecheck.Conv(len, types.Types[types.TINT]),
+		typecheck.Conv(len, types.Types[types.TINT]))
+	return walkExpr(typecheck.Expr(h), init)
+}
+
 func badtype(op ir.Op, tl, tr *types.Type) {
 	var s string
 	if tl != nil {
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 5a1a2441bf..2fb907710b 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -117,12 +117,17 @@ func walkExpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		n.X = walkExpr(n.X, init)
 		return n
 
-	case ir.OEFACE, ir.OAND, ir.OANDNOT, ir.OSUB, ir.OMUL, ir.OADD, ir.OOR, ir.OXOR, ir.OLSH, ir.ORSH:
+	case ir.OEFACE, ir.OAND, ir.OANDNOT, ir.OSUB, ir.OMUL, ir.OADD, ir.OOR, ir.OXOR, ir.OLSH, ir.ORSH,
+		ir.OUNSAFEADD:
 		n := n.(*ir.BinaryExpr)
 		n.X = walkExpr(n.X, init)
 		n.Y = walkExpr(n.Y, init)
 		return n
 
+	case ir.OUNSAFESLICE:
+		n := n.(*ir.BinaryExpr)
+		return walkUnsafeSlice(n, init)
+
 	case ir.ODOT, ir.ODOTPTR:
 		n := n.(*ir.SelectorExpr)
 		return walkDot(n, init)
diff --git a/src/runtime/slice.go b/src/runtime/slice.go
index c0647d95a0..f9d4154acf 100644
--- a/src/runtime/slice.go
+++ b/src/runtime/slice.go
@@ -112,6 +112,25 @@ func makeslice64(et *_type, len64, cap64 int64) unsafe.Pointer {
 	return makeslice(et, len, cap)
 }
 
+func unsafeslice(et *_type, len int) {
+	mem, overflow := math.MulUintptr(et.size, uintptr(len))
+	if overflow || mem > maxAlloc || len < 0 {
+		panicunsafeslicelen()
+	}
+}
+
+func unsafeslice64(et *_type, len64 int64) {
+	len := int(len64)
+	if int64(len) != len64 {
+		panicunsafeslicelen()
+	}
+	unsafeslice(et, len)
+}
+
+func panicunsafeslicelen() {
+	panic(errorString("unsafe.Slice: len out of range"))
+}
+
 // growslice handles slice growth during append.
 // It is passed the slice element type, the old slice, and the desired new minimum capacity,
 // and it returns a new slice with at least that capacity, with the old data
diff --git a/test/unsafebuiltins.go b/test/unsafebuiltins.go
new file mode 100644
index 0000000000..c10f8084a7
--- /dev/null
+++ b/test/unsafebuiltins.go
@@ -0,0 +1,61 @@
+// run
+
+// Copyright 2021 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 (
+	"math"
+	"unsafe"
+)
+
+const maxUintptr = 1 << (8 * unsafe.Sizeof(uintptr(0)))
+
+func main() {
+	var p [10]byte
+
+	// unsafe.Add
+	{
+		p1 := unsafe.Pointer(&p[1])
+		assert(unsafe.Add(p1, 1) == unsafe.Pointer(&p[2]))
+		assert(unsafe.Add(p1, -1) == unsafe.Pointer(&p[0]))
+	}
+
+	// unsafe.Slice
+	{
+		s := unsafe.Slice(&p[0], len(p))
+		assert(&s[0] == &p[0])
+		assert(len(s) == len(p))
+		assert(cap(s) == len(p))
+
+		// nil pointer
+		mustPanic(func() { _ = unsafe.Slice((*int)(nil), 0) })
+
+		// negative length
+		var neg int = -1
+		mustPanic(func() { _ = unsafe.Slice(new(byte), neg) })
+
+		// length too large
+		var tooBig uint64 = math.MaxUint64
+		mustPanic(func() { _ = unsafe.Slice(new(byte), tooBig) })
+
+		// size overflows address space
+		mustPanic(func() { _ = unsafe.Slice(new(uint64), maxUintptr/8) })
+		mustPanic(func() { _ = unsafe.Slice(new(uint64), maxUintptr/8+1) })
+	}
+}
+
+func assert(ok bool) {
+	if !ok {
+		panic("FAIL")
+	}
+}
+
+func mustPanic(f func()) {
+	defer func() {
+		assert(recover() != nil)
+	}()
+	f()
+}
-- 
GitLab


From bb09f8a29b04b8fe4465d0b5d92f164979ee9213 Mon Sep 17 00:00:00 2001
From: Kevin Burke <kevin@burke.dev>
Date: Thu, 25 Mar 2021 12:33:35 -0700
Subject: [PATCH 1913/2400] time: make time.Time print a valid Go string with
 %#v

Previously calling fmt.Sprintf("%#v", t) on a time.Time value would
yield a result like:

    time.Time{wall:0x0, ext:63724924180, loc:(*time.Location)(nil)}

which does not compile when embedded in a Go program, and does not
tell you what value is represented at a glance.

This change adds a GoString method that returns much more legible
output:

    "time.Date(2009, time.February, 5, 5, 0, 57, 12345600, time.UTC)"

which gives you more information about the time.Time and also can be
usefully embedded in a Go program without additional work.

Update Quote() to hex escape non-ASCII characters (copying logic
from strconv), which makes it safer to embed them in the output of
GoString().

Fixes #39034.

Change-Id: Ic985bafe4e556f64e82223c643f65143c9a45c3b
Reviewed-on: https://go-review.googlesource.com/c/go/+/267017
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
---
 doc/go1.17.html         |  9 +++++
 src/time/format.go      | 85 ++++++++++++++++++++++++++++++++++++++---
 src/time/format_test.go | 30 ++++++++++++++-
 3 files changed, 117 insertions(+), 7 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index b670d1b149..0521f9fd91 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -205,6 +205,15 @@ that can be used to pass values between C and Go safely. See
   </p>
 </dl><!-- net/http -->
 
+<dl id="time"><dt><a href="/pkg/time/">time</a></dt>
+  <dd>
+    <p><!-- CL 260858 -->
+    time.Time now has a <a href="/pkg/time/#Time.GoString">GoString</a>
+    method that will return a more useful value for times when printed with
+    the <code>"%#v"</code> format specifier in the fmt package.
+    </p>
+  </dd>
+</dl><!-- time -->
 <p>
   TODO: complete this section
 </p>
diff --git a/src/time/format.go b/src/time/format.go
index 9624752fb4..f6dc8ee621 100644
--- a/src/time/format.go
+++ b/src/time/format.go
@@ -477,6 +477,60 @@ func (t Time) String() string {
 	return s
 }
 
+// GoString implements fmt.GoStringer and formats t to be printed in Go source
+// code.
+func (t Time) GoString() string {
+	buf := []byte("time.Date(")
+	buf = appendInt(buf, t.Year(), 0)
+	month := t.Month()
+	if January <= month && month <= December {
+		buf = append(buf, ", time."...)
+		buf = append(buf, t.Month().String()...)
+	} else {
+		// It's difficult to construct a time.Time with a date outside the
+		// standard range but we might as well try to handle the case.
+		buf = appendInt(buf, int(month), 0)
+	}
+	buf = append(buf, ", "...)
+	buf = appendInt(buf, t.Day(), 0)
+	buf = append(buf, ", "...)
+	buf = appendInt(buf, t.Hour(), 0)
+	buf = append(buf, ", "...)
+	buf = appendInt(buf, t.Minute(), 0)
+	buf = append(buf, ", "...)
+	buf = appendInt(buf, t.Second(), 0)
+	buf = append(buf, ", "...)
+	buf = appendInt(buf, t.Nanosecond(), 0)
+	buf = append(buf, ", "...)
+	switch loc := t.Location(); loc {
+	case UTC, nil:
+		buf = append(buf, "time.UTC"...)
+	case Local:
+		buf = append(buf, "time.Local"...)
+	default:
+		// there are several options for how we could display this, none of
+		// which are great:
+		//
+		// - use Location(loc.name), which is not technically valid syntax
+		// - use LoadLocation(loc.name), which will cause a syntax error when
+		// embedded and also would require us to escape the string without
+		// importing fmt or strconv
+		// - try to use FixedZone, which would also require escaping the name
+		// and would represent e.g. "America/Los_Angeles" daylight saving time
+		// shifts inaccurately
+		// - use the pointer format, which is no worse than you'd get with the
+		// old fmt.Sprintf("%#v", t) format.
+		//
+		// Of these, Location(loc.name) is the least disruptive. This is an edge
+		// case we hope not to hit too often.
+		buf = append(buf, `time.Location(`...)
+		buf = append(buf, []byte(quote(loc.name))...)
+		buf = append(buf, `)`...)
+	}
+	buf = append(buf, ')')
+	return string(buf)
+}
+
 // Format returns a textual representation of the time value formatted
 // according to layout, which defines the format by showing how the reference
 // time, defined to be
@@ -688,14 +742,33 @@ type ParseError struct {
 	Message    string
 }
 
+// These are borrowed from unicode/utf8 and strconv and replicate behavior in
+// that package, since we can't take a dependency on either.
+const runeSelf = 0x80
+const lowerhex = "0123456789abcdef"
+
 func quote(s string) string {
-	buf := make([]byte, 0, len(s)+2) // +2 for surrounding quotes
-	buf = append(buf, '"')
-	for _, c := range s {
-		if c == '"' || c == '\\' {
-			buf = append(buf, '\\')
+	buf := make([]byte, 1, len(s)+2) // slice will be at least len(s) + quotes
+	buf[0] = '"'
+	for i, c := range s {
+		if c >= runeSelf || c < ' ' {
+			// This means you are asking us to parse a time.Duration or
+			// time.Location with unprintable or non-ASCII characters in it.
+			// We don't expect to hit this case very often. We could try to
+			// reproduce strconv.Quote's behavior with full fidelity but
+			// given how rarely we expect to hit these edge cases, speed and
+			// conciseness are better.
+			for j := 0; j < len(string(c)) && j < len(s); j++ {
+				buf = append(buf, `\x`...)
+				buf = append(buf, lowerhex[s[i+j]>>4])
+				buf = append(buf, lowerhex[s[i+j]&0xF])
+			}
+		} else {
+			if c == '"' || c == '\\' {
+				buf = append(buf, '\\')
+			}
+			buf = append(buf, string(c)...)
 		}
-		buf = append(buf, string(c)...)
 	}
 	buf = append(buf, '"')
 	return string(buf)
diff --git a/src/time/format_test.go b/src/time/format_test.go
index 09d3f842e3..1af41e2dfb 100644
--- a/src/time/format_test.go
+++ b/src/time/format_test.go
@@ -129,6 +129,31 @@ func TestFormat(t *testing.T) {
 	}
 }
 
+var goStringTests = []struct {
+	in   Time
+	want string
+}{
+	{Date(2009, February, 5, 5, 0, 57, 12345600, UTC),
+		"time.Date(2009, time.February, 5, 5, 0, 57, 12345600, time.UTC)"},
+	{Date(2009, February, 5, 5, 0, 57, 12345600, Local),
+		"time.Date(2009, time.February, 5, 5, 0, 57, 12345600, time.Local)"},
+	{Date(2009, February, 5, 5, 0, 57, 12345600, FixedZone("Europe/Berlin", 3*60*60)),
+		`time.Date(2009, time.February, 5, 5, 0, 57, 12345600, time.Location("Europe/Berlin"))`,
+	},
+	{Date(2009, February, 5, 5, 0, 57, 12345600, FixedZone("Non-ASCII character ⏰", 3*60*60)),
+		`time.Date(2009, time.February, 5, 5, 0, 57, 12345600, time.Location("Non-ASCII character \xe2\x8f\xb0"))`,
+	},
+}
+
+func TestGoString(t *testing.T) {
+	// The numeric time represents Thu Feb  4 21:00:57.012345600 PST 2009
+	for _, tt := range goStringTests {
+		if tt.in.GoString() != tt.want {
+			t.Errorf("GoString (%q): got %q want %q", tt.in, tt.in.GoString(), tt.want)
+		}
+	}
+}
+
 // issue 12440.
 func TestFormatSingleDigits(t *testing.T) {
 	time := Date(2001, 2, 3, 4, 5, 6, 700000000, UTC)
@@ -796,10 +821,13 @@ func TestQuote(t *testing.T) {
 		{`abc"xyz"`, `"abc\"xyz\""`},
 		{"", `""`},
 		{"abc", `"abc"`},
+		{`☺`, `"\xe2\x98\xba"`},
+		{`☺ hello ☺ hello`, `"\xe2\x98\xba hello \xe2\x98\xba hello"`},
+		{"\x04", `"\x04"`},
 	}
 	for _, tt := range tests {
 		if q := Quote(tt.s); q != tt.want {
-			t.Errorf("Quote(%q) = %q, want %q", tt.s, q, tt.want)
+			t.Errorf("Quote(%q) = got %q, want %q", tt.s, q, tt.want)
 		}
 	}
 
-- 
GitLab


From 7eb2d308830003432601f9b40ba5ccf7382b6157 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Sat, 1 May 2021 15:37:44 +0200
Subject: [PATCH 1914/2400] syscall: add //go:build lines to files generated
 with with mksyscall_libc.pl

Change-Id: I2e02d02d9208fc2dbf01c0cea4a67c288967cd07
Reviewed-on: https://go-review.googlesource.com/c/go/+/315276
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/syscall/mksyscall_libc.pl | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/syscall/mksyscall_libc.pl b/src/syscall/mksyscall_libc.pl
index 5ceedc812a..631a07c819 100755
--- a/src/syscall/mksyscall_libc.pl
+++ b/src/syscall/mksyscall_libc.pl
@@ -23,6 +23,7 @@ my $cmdline = "mksyscall_libc.pl " . join(' ', @ARGV);
 my $errors = 0;
 my $_32bit = "";
 my $tags = "";  # build tags
+my $newtags = ""; # new style build tags
 my $aix = 0;
 my $solaris = 0;
 
@@ -300,10 +301,14 @@ if($errors) {
 	exit 1;
 }
 
+# TODO: this assumes tags are just simply comma separated. For now this is all the uses.
+$newtags = $tags =~ s/,/ && /r;
+
 print <<EOF;
 // $cmdline
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build $newtags
 // +build $tags
 
 package $package
-- 
GitLab


From b177b2d51ea14637d7a75542cbfd3843db387453 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Sat, 1 May 2021 19:43:55 +0200
Subject: [PATCH 1915/2400] os, syscall: use wait6 to avoid wait/kill race on
 dragonfly

Follow CL 23967 and CL 24021 which did the same on linux and freebsd,
respectively.

Updates #13987
Updates #16028

Change-Id: Ia30ef8b5cffd8f9eb75c29ee5fe350dac2be6d44
Reviewed-on: https://go-review.googlesource.com/c/go/+/315279
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/os/wait_unimp.go                   |  4 ++--
 src/os/wait_wait6.go                   | 12 +++++++-----
 src/syscall/zerrors_dragonfly_amd64.go |  2 ++
 src/syscall/zsysnum_dragonfly_amd64.go |  1 +
 4 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/src/os/wait_unimp.go b/src/os/wait_unimp.go
index 28dc2a5939..07b5b6b66b 100644
--- a/src/os/wait_unimp.go
+++ b/src/os/wait_unimp.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build aix || darwin || dragonfly || (js && wasm) || netbsd || openbsd || solaris
-// +build aix darwin dragonfly js,wasm netbsd openbsd solaris
+//go:build aix || darwin || (js && wasm) || netbsd || openbsd || solaris
+// +build aix darwin js,wasm netbsd openbsd solaris
 
 package os
 
diff --git a/src/os/wait_wait6.go b/src/os/wait_wait6.go
index 895f21069a..51193401f9 100644
--- a/src/os/wait_wait6.go
+++ b/src/os/wait_wait6.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build freebsd
-// +build freebsd
+//go:build dragonfly || freebsd
+// +build dragonfly freebsd
 
 package os
 
@@ -23,9 +23,9 @@ func (p *Process) blockUntilWaitable() (bool, error) {
 		// The arguments on 32-bit FreeBSD look like the following:
 		// - freebsd32_wait6_args{ idtype, id1, id2, status, options, wrusage, info } or
 		// - freebsd32_wait6_args{ idtype, pad, id1, id2, status, options, wrusage, info } when PAD64_REQUIRED=1 on ARM, MIPS or PowerPC
-		if runtime.GOARCH == "386" {
+		if runtime.GOOS == "freebsd" && runtime.GOARCH == "386" {
 			_, _, errno = syscall.Syscall9(syscall.SYS_WAIT6, _P_PID, uintptr(p.Pid), 0, 0, syscall.WEXITED|syscall.WNOWAIT, 0, 0, 0, 0)
-		} else if runtime.GOARCH == "arm" {
+		} else if runtime.GOOS == "freebsd" && runtime.GOARCH == "arm" {
 			_, _, errno = syscall.Syscall9(syscall.SYS_WAIT6, _P_PID, 0, uintptr(p.Pid), 0, 0, syscall.WEXITED|syscall.WNOWAIT, 0, 0, 0)
 		} else {
 			_, _, errno = syscall.Syscall6(syscall.SYS_WAIT6, _P_PID, uintptr(p.Pid), 0, syscall.WEXITED|syscall.WNOWAIT, 0, 0)
@@ -35,7 +35,9 @@ func (p *Process) blockUntilWaitable() (bool, error) {
 		}
 	}
 	runtime.KeepAlive(p)
-	if errno != 0 {
+	if errno == syscall.ENOSYS {
+		return false, nil
+	} else if errno != 0 {
 		return false, NewSyscallError("wait6", errno)
 	}
 	return true, nil
diff --git a/src/syscall/zerrors_dragonfly_amd64.go b/src/syscall/zerrors_dragonfly_amd64.go
index 8ed611b3e4..35e2a52d25 100644
--- a/src/syscall/zerrors_dragonfly_amd64.go
+++ b/src/syscall/zerrors_dragonfly_amd64.go
@@ -1239,8 +1239,10 @@ const (
 	VWERASE                           = 0x4
 	WCONTINUED                        = 0x4
 	WCOREFLAG                         = 0x80
+	WEXITED                           = 0x10
 	WLINUXCLONE                       = 0x80000000
 	WNOHANG                           = 0x1
+	WNOWAIT                           = 0x8
 	WSTOPPED                          = 0x7f
 	WUNTRACED                         = 0x2
 )
diff --git a/src/syscall/zsysnum_dragonfly_amd64.go b/src/syscall/zsysnum_dragonfly_amd64.go
index ae504a5f0c..e8996db0f8 100644
--- a/src/syscall/zsysnum_dragonfly_amd64.go
+++ b/src/syscall/zsysnum_dragonfly_amd64.go
@@ -305,4 +305,5 @@ const (
 	SYS_PIPE2                  = 538 // { int pipe2(int *fildes, int flags); }
 	SYS_UTIMENSAT              = 539 // { int utimensat(int fd, const char *path, const struct timespec *ts, int flags); }
 	SYS_ACCEPT4                = 541 // { int accept4(int s, caddr_t name, int *anamelen, int flags); }
+	SYS_WAIT6                  = 548 // { int wait6(idtype_t idtype, id_t id, int *status, int options, struct __wrusage *wrusage, siginfo_t *info); }
 )
-- 
GitLab


From abb110bf3de82f85aefe0fb284cc9359488b5f09 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Sat, 1 May 2021 15:41:34 +0000
Subject: [PATCH 1916/2400] os/user: implement (*User).GroupIds on solaris

It seems like getgrouplist is supported since Solaris 11.3 (released in
2016):
https://docs.oracle.com/cd/E86824_01/html/E54766/getgrouplist-3c.html

Use it to implement (*User).GroupIds on solaris, like on other Unix
platforms.

Unfortunately it looks like getgrouplist was added to illumos only
fairly recently, see
https://github.com/illumos/illumos-gate/commit/f2c438c5058c64b7373448f239156bf60009abcb

Thus, don't use it on GOOS=illumos for now.

Updates #14709

Change-Id: Ibfcdbfca6b7d1af96630512d08921e5637ca76d4
Reviewed-on: https://go-review.googlesource.com/c/go/+/315278
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/os/user/getgrouplist_unix.go                            | 4 ++--
 .../user/{listgroups_solaris.go => listgroups_illumos.go}   | 6 +++---
 src/os/user/listgroups_unix.go                              | 4 ++--
 src/os/user/user_test.go                                    | 2 +-
 4 files changed, 8 insertions(+), 8 deletions(-)
 rename src/os/user/{listgroups_solaris.go => listgroups_illumos.go} (74%)

diff --git a/src/os/user/getgrouplist_unix.go b/src/os/user/getgrouplist_unix.go
index 8393c5a474..fd66961ccf 100644
--- a/src/os/user/getgrouplist_unix.go
+++ b/src/os/user/getgrouplist_unix.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (dragonfly || freebsd || (!android && linux) || netbsd || openbsd) && cgo && !osusergo
-// +build dragonfly freebsd !android,linux netbsd openbsd
+//go:build (dragonfly || freebsd || (!android && linux) || netbsd || openbsd || (solaris && !illumos)) && cgo && !osusergo
+// +build dragonfly freebsd !android,linux netbsd openbsd solaris,!illumos
 // +build cgo
 // +build !osusergo
 
diff --git a/src/os/user/listgroups_solaris.go b/src/os/user/listgroups_illumos.go
similarity index 74%
rename from src/os/user/listgroups_solaris.go
rename to src/os/user/listgroups_illumos.go
index d993d30570..d25e0339b9 100644
--- a/src/os/user/listgroups_solaris.go
+++ b/src/os/user/listgroups_illumos.go
@@ -1,4 +1,4 @@
-// Copyright 2016 The Go Authors. All rights reserved.
+// Copyright 2021 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.
 
@@ -6,7 +6,7 @@
 // +build cgo,!osusergo
 
 // Even though this file requires no C, it is used to provide a
-// listGroup stub because all the other Solaris calls work.  Otherwise,
+// listGroup stub because all the other illumos calls work.  Otherwise,
 // this stub will conflict with the lookup_stubs.go fallback.
 
 package user
@@ -14,5 +14,5 @@ package user
 import "fmt"
 
 func listGroups(u *User) ([]string, error) {
-	return nil, fmt.Errorf("user: list groups for %s: not supported on Solaris", u.Username)
+	return nil, fmt.Errorf("user: list groups for %s: not supported on illumos", u.Username)
 }
diff --git a/src/os/user/listgroups_unix.go b/src/os/user/listgroups_unix.go
index c7b72062d5..38aa7653b0 100644
--- a/src/os/user/listgroups_unix.go
+++ b/src/os/user/listgroups_unix.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (dragonfly || darwin || freebsd || (!android && linux) || netbsd || openbsd) && cgo && !osusergo
-// +build dragonfly darwin freebsd !android,linux netbsd openbsd
+//go:build (dragonfly || darwin || freebsd || (!android && linux) || netbsd || openbsd || (solaris && !illumos)) && cgo && !osusergo
+// +build dragonfly darwin freebsd !android,linux netbsd openbsd solaris,!illumos
 // +build cgo
 // +build !osusergo
 
diff --git a/src/os/user/user_test.go b/src/os/user/user_test.go
index 8c4c817c2b..49920317be 100644
--- a/src/os/user/user_test.go
+++ b/src/os/user/user_test.go
@@ -132,7 +132,7 @@ func TestGroupIds(t *testing.T) {
 	if runtime.GOOS == "aix" {
 		t.Skip("skipping GroupIds, see golang.org/issue/30563")
 	}
-	if runtime.GOOS == "solaris" || runtime.GOOS == "illumos" {
+	if runtime.GOOS == "illumos" {
 		t.Skip("skipping GroupIds, see golang.org/issue/14709")
 	}
 	user, err := Current()
-- 
GitLab


From 2c9f5a1da823773c436f8b2c119635797d6db2d3 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Sun, 2 May 2021 08:52:06 -0400
Subject: [PATCH 1917/2400] cmd: update x/arch to pull in CL 315572

Because x/arch is now lazy, this removes the checksum for rsc.io/pdf
from the go.sum file: the requirements of rsc.io/pdf are known not to
be relevant to any package imported within the cmd packages.

For #36460
Updates #36905

Change-Id: I3abb6a8029cd0c9099b592ccb01ca5606c93edec
Reviewed-on: https://go-review.googlesource.com/c/go/+/316110
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 src/cmd/go.mod                                |     2 +-
 src/cmd/go.sum                                |     5 +-
 .../x/arch/arm64/arm64asm/plan9x.go           |    62 +-
 .../x/arch/ppc64/ppc64asm/decode.go           |    50 +-
 .../golang.org/x/arch/ppc64/ppc64asm/field.go |    20 +-
 .../golang.org/x/arch/ppc64/ppc64asm/gnu.go   |   116 +-
 .../golang.org/x/arch/ppc64/ppc64asm/inst.go  |    27 +-
 .../golang.org/x/arch/ppc64/ppc64asm/plan9.go |     5 +-
 .../x/arch/ppc64/ppc64asm/tables.go           | 11084 ++++++++--------
 src/cmd/vendor/modules.txt                    |     4 +-
 10 files changed, 5841 insertions(+), 5534 deletions(-)

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index 1487025268..96f709081f 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -5,7 +5,7 @@ go 1.17
 require (
 	github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5
 	github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639 // indirect
-	golang.org/x/arch v0.0.0-20210308155006-05f8f0431f72
+	golang.org/x/arch v0.0.0-20210502124803-cbf565b21d1e
 	golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 // indirect
 	golang.org/x/mod v0.4.3-0.20210409134425-858fdbee9c24
 	golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57 // indirect
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 0f13c366d0..9c702d0d33 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -6,8 +6,8 @@ github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLe
 github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639 h1:mV02weKRL81bEnm8A0HT1/CAelMQDBuQIfLw8n+d6xI=
 github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
 github.com/yuin/goldmark v1.3.3/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
-golang.org/x/arch v0.0.0-20210308155006-05f8f0431f72 h1:CdaLHkic8S6xdhpWgHmtWij2rv2DTGwPuJZjjEDGk2w=
-golang.org/x/arch v0.0.0-20210308155006-05f8f0431f72/go.mod h1:flIaEI6LNU6xOCD5PaJvn9wGP0agmIOqjrtsKGRguv4=
+golang.org/x/arch v0.0.0-20210502124803-cbf565b21d1e h1:pv3V0NlNSh5Q6AX/StwGLBjcLS7UN4m4Gq+V+uSecqM=
+golang.org/x/arch v0.0.0-20210502124803-cbf565b21d1e/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 h1:/ZScEX8SfEmUGRHs0gxpqteO5nfNW6axyZbBdw9A12g=
@@ -42,4 +42,3 @@ golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8T
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=
diff --git a/src/cmd/vendor/golang.org/x/arch/arm64/arm64asm/plan9x.go b/src/cmd/vendor/golang.org/x/arch/arm64/arm64asm/plan9x.go
index bae42e284e..3aaf0b2a30 100644
--- a/src/cmd/vendor/golang.org/x/arch/arm64/arm64asm/plan9x.go
+++ b/src/cmd/vendor/golang.org/x/arch/arm64/arm64asm/plan9x.go
@@ -126,7 +126,7 @@ func GoSyntax(inst Inst, pc uint64, symname func(uint64) (string, uint64), text
 			op = "VMOV"
 		}
 
-	case LDR:
+	case LDR, LDUR:
 		var rno uint16
 		if r, ok := inst.Args[0].(Reg); ok {
 			rno = uint16(r)
@@ -135,12 +135,21 @@ func GoSyntax(inst Inst, pc uint64, symname func(uint64) (string, uint64), text
 		}
 		if rno <= uint16(WZR) {
 			op = "MOVWU" + suffix
+		} else if rno >= uint16(B0) && rno <= uint16(B31) {
+			op = "FMOVB" + suffix
+			args[0] = fmt.Sprintf("F%d", rno&31)
+		} else if rno >= uint16(H0) && rno <= uint16(H31) {
+			op = "FMOVH" + suffix
+			args[0] = fmt.Sprintf("F%d", rno&31)
 		} else if rno >= uint16(S0) && rno <= uint16(S31) {
 			op = "FMOVS" + suffix
 			args[0] = fmt.Sprintf("F%d", rno&31)
 		} else if rno >= uint16(D0) && rno <= uint16(D31) {
 			op = "FMOVD" + suffix
 			args[0] = fmt.Sprintf("F%d", rno&31)
+		} else if rno >= uint16(Q0) && rno <= uint16(Q31) {
+			op = "FMOVQ" + suffix
+			args[0] = fmt.Sprintf("F%d", rno&31)
 		} else {
 			op = "MOVD" + suffix
 		}
@@ -181,12 +190,21 @@ func GoSyntax(inst Inst, pc uint64, symname func(uint64) (string, uint64), text
 		}
 		if rno <= uint16(WZR) {
 			op = "MOVW" + suffix
+		} else if rno >= uint16(B0) && rno <= uint16(B31) {
+			op = "FMOVB" + suffix
+			args[0] = fmt.Sprintf("F%d", rno&31)
+		} else if rno >= uint16(H0) && rno <= uint16(H31) {
+			op = "FMOVH" + suffix
+			args[0] = fmt.Sprintf("F%d", rno&31)
 		} else if rno >= uint16(S0) && rno <= uint16(S31) {
 			op = "FMOVS" + suffix
 			args[0] = fmt.Sprintf("F%d", rno&31)
 		} else if rno >= uint16(D0) && rno <= uint16(D31) {
 			op = "FMOVD" + suffix
 			args[0] = fmt.Sprintf("F%d", rno&31)
+		} else if rno >= uint16(Q0) && rno <= uint16(Q31) {
+			op = "FMOVQ" + suffix
+			args[0] = fmt.Sprintf("F%d", rno&31)
 		} else {
 			op = "MOVD" + suffix
 		}
@@ -251,18 +269,31 @@ func GoSyntax(inst Inst, pc uint64, symname func(uint64) (string, uint64), text
 				op += "W"
 			}
 		}
-		fallthrough
+		args[0] = fmt.Sprintf("(%s, %s)", args[0], args[1])
+		args[1] = args[2]
+		return op + " " + args[1] + ", " + args[0]
 
 	case STP, LDP:
 		args[0] = fmt.Sprintf("(%s, %s)", args[0], args[1])
 		args[1] = args[2]
-		if op == "STP" {
-			op = op + suffix
+
+		rno, ok := inst.Args[0].(Reg)
+		if !ok {
+			rno = Reg(inst.Args[0].(RegSP))
+		}
+		if rno <= WZR {
+			op = op + "W"
+		} else if rno >= S0 && rno <= S31 {
+			op = "F" + op + "S"
+		} else if rno >= D0 && rno <= D31 {
+			op = "F" + op + "D"
+		} else if rno >= Q0 && rno <= Q31 {
+			op = "F" + op + "Q"
+		}
+		op = op + suffix
+		if inst.Op.String() == "STP" {
 			return op + " " + args[0] + ", " + args[1]
-		} else if op == "LDP" {
-			op = op + suffix
-			return op + " " + args[1] + ", " + args[0]
-		} else if op == "LDAXP" || op == "LDXP" || op == "LDAXPW" || op == "LDXPW" {
+		} else {
 			return op + " " + args[1] + ", " + args[0]
 		}
 
@@ -469,6 +500,12 @@ SHA256SU0
 SHA256SU1
 `)
 
+// floating point instrcutions without "F" prefix.
+var fOpsWithoutFPrefix = map[Op]bool{
+	LDP: true,
+	STP: true,
+}
+
 func plan9Arg(inst *Inst, pc uint64, symname func(uint64) (string, uint64), arg Arg) string {
 	switch a := arg.(type) {
 	case Imm:
@@ -494,20 +531,17 @@ func plan9Arg(inst *Inst, pc uint64, symname func(uint64) (string, uint64), arg
 		regenum := uint16(a)
 		regno := uint16(a) & 31
 
-		if regenum >= uint16(B0) && regenum <= uint16(D31) {
-			if strings.HasPrefix(inst.Op.String(), "F") || strings.HasSuffix(inst.Op.String(), "CVTF") {
+		if regenum >= uint16(B0) && regenum <= uint16(Q31) {
+			if strings.HasPrefix(inst.Op.String(), "F") || strings.HasSuffix(inst.Op.String(), "CVTF") || fOpsWithoutFPrefix[inst.Op] {
 				// FP registers are the same ones as SIMD registers
 				// Print Fn for scalar variant to align with assembler (e.g., FCVT, SCVTF, UCVTF, etc.)
 				return fmt.Sprintf("F%d", regno)
 			} else {
+				// Print Vn to align with assembler (e.g., SHA256H)
 				return fmt.Sprintf("V%d", regno)
 			}
 
-		} else if regenum >= uint16(Q0) && regenum <= uint16(Q31) {
-			// Print Vn to align with assembler (e.g., SHA256H)
-			return fmt.Sprintf("V%d", regno)
 		}
-
 		if regno == 31 {
 			return "ZR"
 		}
diff --git a/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/decode.go b/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/decode.go
index 5f04ff40e4..59bd3258ef 100644
--- a/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/decode.go
+++ b/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/decode.go
@@ -12,18 +12,25 @@ import (
 
 const debugDecode = false
 
+const prefixOpcode = 1
+
 // instFormat is a decoding rule for one specific instruction form.
-// a uint32 instruction ins matches the rule if ins&Mask == Value
+// an instruction ins matches the rule if ins&Mask == Value
 // DontCare bits should be zero, but the machine might not reject
 // ones in those bits, they are mainly reserved for future expansion
 // of the instruction set.
 // The Args are stored in the same order as the instruction manual.
+//
+// Prefixed instructions are stored as:
+//   prefix << 32 | suffix,
+// Regular instructions are:
+//   inst << 32
 type instFormat struct {
 	Op       Op
-	Mask     uint32
-	Value    uint32
-	DontCare uint32
-	Args     [5]*argField
+	Mask     uint64
+	Value    uint64
+	DontCare uint64
+	Args     [6]*argField
 }
 
 // argField indicate how to decode an argument to an instruction.
@@ -36,7 +43,7 @@ type argField struct {
 }
 
 // Parse parses the Arg out from the given binary instruction i.
-func (a argField) Parse(i uint32) Arg {
+func (a argField) Parse(i [2]uint32) Arg {
 	switch a.Type {
 	default:
 		return nil
@@ -54,6 +61,10 @@ func (a argField) Parse(i uint32) Arg {
 		return V0 + Reg(a.BitFields.Parse(i))
 	case TypeVecSReg:
 		return VS0 + Reg(a.BitFields.Parse(i))
+	case TypeVecSpReg:
+		return VS0 + Reg(a.BitFields.Parse(i))*2
+	case TypeMMAReg:
+		return A0 + Reg(a.BitFields.Parse(i))
 	case TypeSpReg:
 		return SpReg(a.BitFields.Parse(i))
 	case TypeImmSigned:
@@ -81,6 +92,8 @@ const (
 	TypeFPReg                // floating point register
 	TypeVecReg               // vector register
 	TypeVecSReg              // VSX register
+	TypeVecSpReg             // VSX register pair (even only encoding)
+	TypeMMAReg               // MMA register
 	TypeSpReg                // special register (depends on Op)
 	TypeImmSigned            // signed immediate
 	TypeImmUnsigned          // unsigned immediate/flag/mask, this is the catch-all type
@@ -106,6 +119,10 @@ func (t ArgType) String() string {
 		return "VecReg"
 	case TypeVecSReg:
 		return "VecSReg"
+	case TypeVecSpReg:
+		return "VecSpReg"
+	case TypeMMAReg:
+		return "MMAReg"
 	case TypeSpReg:
 		return "SpReg"
 	case TypeImmSigned:
@@ -146,9 +163,22 @@ func Decode(src []byte, ord binary.ByteOrder) (inst Inst, err error) {
 	if decoderCover == nil {
 		decoderCover = make([]bool, len(instFormats))
 	}
-	inst.Len = 4 // only 4-byte instructions are supported
-	ui := ord.Uint32(src[:inst.Len])
-	inst.Enc = ui
+	inst.Len = 4
+	ui_extn := [2]uint32{ord.Uint32(src[:inst.Len]), 0}
+	ui := uint64(ui_extn[0]) << 32
+	inst.Enc = ui_extn[0]
+	opcode := inst.Enc >> 26
+	if opcode == prefixOpcode {
+		// This is a prefixed instruction
+		inst.Len = 8
+		if len(src) < 8 {
+			return inst, errShort
+		}
+		// Merge the suffixed word.
+		ui_extn[1] = ord.Uint32(src[4:inst.Len])
+		ui |= uint64(ui_extn[1])
+		inst.SuffixEnc = ui_extn[1]
+	}
 	for i, iform := range instFormats {
 		if ui&iform.Mask != iform.Value {
 			continue
@@ -163,7 +193,7 @@ func Decode(src []byte, ord binary.ByteOrder) (inst Inst, err error) {
 			if argfield == nil {
 				break
 			}
-			inst.Args[i] = argfield.Parse(ui)
+			inst.Args[i] = argfield.Parse(ui_extn)
 		}
 		inst.Op = iform.Op
 		if debugDecode {
diff --git a/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/field.go b/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/field.go
index 26a4fdf1a0..882c91ae12 100644
--- a/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/field.go
+++ b/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/field.go
@@ -14,6 +14,10 @@ import (
 type BitField struct {
 	Offs uint8 // the offset of the left-most bit.
 	Bits uint8 // length in bits.
+	// This instruction word holding this field.
+	// It is always 0 for ISA < 3.1 instructions. It is
+	// in decoding order. (0 == prefix, 1 == suffix on ISA 3.1)
+	Word uint8
 }
 
 func (b BitField) String() string {
@@ -28,16 +32,16 @@ func (b BitField) String() string {
 
 // Parse extracts the bitfield b from i, and return it as an unsigned integer.
 // Parse will panic if b is invalid.
-func (b BitField) Parse(i uint32) uint32 {
+func (b BitField) Parse(i [2]uint32) uint32 {
 	if b.Bits > 32 || b.Bits == 0 || b.Offs > 31 || b.Offs+b.Bits > 32 {
 		panic(fmt.Sprintf("invalid bitfiled %v", b))
 	}
-	return (i >> (32 - b.Offs - b.Bits)) & ((1 << b.Bits) - 1)
+	return (i[b.Word] >> (32 - b.Offs - b.Bits)) & ((1 << b.Bits) - 1)
 }
 
 // ParseSigned extracts the bitfield b from i, and return it as a signed integer.
 // ParseSigned will panic if b is invalid.
-func (b BitField) ParseSigned(i uint32) int32 {
+func (b BitField) ParseSigned(i [2]uint32) int32 {
 	u := int32(b.Parse(i))
 	return u << (32 - b.Bits) >> (32 - b.Bits)
 }
@@ -61,9 +65,9 @@ func (bs *BitFields) Append(b BitField) {
 // as an unsigned integer and the total length of all the bitfields.
 // parse will panic if any bitfield in b is invalid, but it doesn't check if
 // the sequence of bitfields is reasonable.
-func (bs BitFields) parse(i uint32) (u uint32, Bits uint8) {
+func (bs BitFields) parse(i [2]uint32) (u uint64, Bits uint8) {
 	for _, b := range bs {
-		u = (u << b.Bits) | b.Parse(i)
+		u = (uint64(u) << b.Bits) | uint64(b.Parse(i))
 		Bits += b.Bits
 	}
 	return u, Bits
@@ -71,14 +75,14 @@ func (bs BitFields) parse(i uint32) (u uint32, Bits uint8) {
 
 // Parse extracts the bitfields from i, concatenate them and return the result
 // as an unsigned integer. Parse will panic if any bitfield in b is invalid.
-func (bs BitFields) Parse(i uint32) uint32 {
+func (bs BitFields) Parse(i [2]uint32) uint64 {
 	u, _ := bs.parse(i)
 	return u
 }
 
 // Parse extracts the bitfields from i, concatenate them and return the result
 // as a signed integer. Parse will panic if any bitfield in b is invalid.
-func (bs BitFields) ParseSigned(i uint32) int32 {
+func (bs BitFields) ParseSigned(i [2]uint32) int64 {
 	u, l := bs.parse(i)
-	return int32(u) << (32 - l) >> (32 - l)
+	return int64(u) << (64 - l) >> (64 - l)
 }
diff --git a/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/gnu.go b/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/gnu.go
index 4631749745..225ef4fb88 100644
--- a/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/gnu.go
+++ b/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/gnu.go
@@ -34,6 +34,8 @@ func GNUSyntax(inst Inst, pc uint64) string {
 	startArg := 0
 	sep := " "
 	opName := inst.Op.String()
+	argList := inst.Args[:]
+
 	switch opName {
 	case "bc", "bcl", "bca", "bcla", "bclr", "bclrl", "bcctr", "bcctrl", "bctar", "bctarl":
 		sfx := inst.Op.String()[2:]
@@ -223,23 +225,111 @@ func GNUSyntax(inst Inst, pc uint64) string {
 			buf.WriteString("spr")
 		}
 
+	case "mtfsfi", "mtfsfi.":
+		buf.WriteString(opName)
+		l := inst.Args[2].(Imm)
+		if l == 0 {
+			// L == 0 is an extended mnemonic for the same.
+			asm := fmt.Sprintf(" %s,%s",
+				gnuArg(&inst, 0, inst.Args[0], PC),
+				gnuArg(&inst, 1, inst.Args[1], PC))
+			buf.WriteString(asm)
+			startArg = 3
+		}
+
+	case "paste.":
+		buf.WriteString(opName)
+		l := inst.Args[2].(Imm)
+		if l == 1 {
+			// L == 1 is an extended mnemonic for the same.
+			asm := fmt.Sprintf(" %s,%s",
+				gnuArg(&inst, 0, inst.Args[0], PC),
+				gnuArg(&inst, 1, inst.Args[1], PC))
+			buf.WriteString(asm)
+			startArg = 3
+		}
+
+	case "mtfsf", "mtfsf.":
+		buf.WriteString(opName)
+		l := inst.Args[3].(Imm)
+		if l == 0 {
+			// L == 0 is an extended mnemonic for the same.
+			asm := fmt.Sprintf(" %s,%s,%s",
+				gnuArg(&inst, 0, inst.Args[0], PC),
+				gnuArg(&inst, 1, inst.Args[1], PC),
+				gnuArg(&inst, 2, inst.Args[2], PC))
+			buf.WriteString(asm)
+			startArg = 4
+		}
+
 	case "sync":
-		switch arg := inst.Args[0].(type) {
-		case Imm:
-			switch arg {
-			case 0:
-				buf.WriteString("hwsync")
-			case 1:
-				buf.WriteString("lwsync")
-			case 2:
-				buf.WriteString("ptesync")
-			}
+		lsc := inst.Args[0].(Imm)<<4 | inst.Args[1].(Imm)
+		switch lsc {
+		case 0x00:
+			buf.WriteString("hwsync")
+			startArg = 2
+		case 0x10:
+			buf.WriteString("lwsync")
+			startArg = 2
+		default:
+			buf.WriteString(opName)
+		}
+
+	case "lbarx", "lharx", "lwarx", "ldarx":
+		// If EH == 0, omit printing EH.
+		eh := inst.Args[3].(Imm)
+		if eh == 0 {
+			argList = inst.Args[:3]
 		}
-		startArg = 2
-	default:
 		buf.WriteString(inst.Op.String())
+
+	case "paddi":
+		// There are several extended mnemonics.  Notably, "pla" is
+		// the only valid mnemonic for paddi (R=1), In this case, RA must
+		// always be 0.  Otherwise it is invalid.
+		r := inst.Args[3].(Imm)
+		ra := inst.Args[1].(Reg)
+		str := opName
+		if ra == R0 {
+			name := []string{"pli", "pla"}
+			str = fmt.Sprintf("%s %s,%s",
+				name[r&1],
+				gnuArg(&inst, 0, inst.Args[0], PC),
+				gnuArg(&inst, 2, inst.Args[2], PC))
+			startArg = 4
+		} else if r == 0 {
+			str = fmt.Sprintf("%s %s,%s,%s", opName,
+				gnuArg(&inst, 0, inst.Args[0], PC),
+				gnuArg(&inst, 1, inst.Args[1], PC),
+				gnuArg(&inst, 2, inst.Args[2], PC))
+			startArg = 4
+		}
+		buf.WriteString(str)
+
+	default:
+		// Prefixed load/stores do not print the displacement register when R==1 (they are PCrel).
+		// This also implies RA should be 0.  Likewise, when R==0, printing of R can be omitted.
+		if strings.HasPrefix(opName, "pl") || strings.HasPrefix(opName, "pst") {
+			r := inst.Args[3].(Imm)
+			ra := inst.Args[2].(Reg)
+			d := inst.Args[1].(Offset)
+			if r == 1 && ra == R0 {
+				str := fmt.Sprintf("%s %s,%d", opName, gnuArg(&inst, 0, inst.Args[0], PC), d)
+				buf.WriteString(str)
+				startArg = 4
+			} else if r == 0 {
+				str := fmt.Sprintf("%s %s,%d(%s)", opName,
+					gnuArg(&inst, 0, inst.Args[0], PC),
+					d,
+					gnuArg(&inst, 2, inst.Args[2], PC))
+				buf.WriteString(str)
+				startArg = 4
+			}
+		} else {
+			buf.WriteString(opName)
+		}
 	}
-	for i, arg := range inst.Args[:] {
+	for i, arg := range argList {
 		if arg == nil {
 			break
 		}
diff --git a/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/inst.go b/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/inst.go
index 870522a10b..41e04513dd 100644
--- a/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/inst.go
+++ b/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/inst.go
@@ -10,10 +10,11 @@ import (
 )
 
 type Inst struct {
-	Op   Op     // Opcode mnemonic
-	Enc  uint32 // Raw encoding bits
-	Len  int    // Length of encoding in bytes.
-	Args Args   // Instruction arguments, in Power ISA manual order.
+	Op        Op     // Opcode mnemonic
+	Enc       uint32 // Raw encoding bits (if Len == 8, this is the prefix word)
+	Len       int    // Length of encoding in bytes.
+	SuffixEnc uint32 // Raw encoding bits of second word (if Len == 8)
+	Args      Args   // Instruction arguments, in Power ISA manual order.
 }
 
 func (i Inst) String() string {
@@ -50,9 +51,9 @@ type Arg interface {
 }
 
 // An Args holds the instruction arguments.
-// If an instruction has fewer than 4 arguments,
+// If an instruction has fewer than 6 arguments,
 // the final elements in the array are nil.
-type Args [5]Arg
+type Args [6]Arg
 
 // A Reg is a single register. The zero value means R0, not the absence of a register.
 // It also includes special registers.
@@ -220,6 +221,14 @@ const (
 	VS61
 	VS62
 	VS63
+	A0 // MMA registers.  These are effectively shadow registers of four adjacent VSR's [An*4,An*4+3]
+	A1
+	A2
+	A3
+	A4
+	A5
+	A6
+	A7
 )
 
 func (Reg) IsArg() {}
@@ -233,6 +242,8 @@ func (r Reg) String() string {
 		return fmt.Sprintf("v%d", int(r-V0))
 	case VS0 <= r && r <= VS63:
 		return fmt.Sprintf("vs%d", int(r-VS0))
+	case A0 <= r && r <= A7:
+		return fmt.Sprintf("a%d", int(r-A0))
 	default:
 		return fmt.Sprintf("Reg(%d)", int(r))
 	}
@@ -328,7 +339,7 @@ func (l Label) String() string {
 }
 
 // Imm represents an immediate number.
-type Imm int32
+type Imm int64
 
 func (Imm) IsArg() {}
 func (i Imm) String() string {
@@ -336,7 +347,7 @@ func (i Imm) String() string {
 }
 
 // Offset represents a memory offset immediate.
-type Offset int32
+type Offset int64
 
 func (Offset) IsArg() {}
 func (o Offset) String() string {
diff --git a/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/plan9.go b/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/plan9.go
index 48a4e9790a..89b917320a 100644
--- a/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/plan9.go
+++ b/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/plan9.go
@@ -76,6 +76,9 @@ func GoSyntax(inst Inst, pc uint64, symname func(uint64) (string, uint64)) strin
 		}
 		args = append(args, args[0])
 		return op + " " + strings.Join(args[1:], ",")
+	case PASTECC:
+		// paste. has two input registers, and an L field, unlike other 3 operand instructions.
+		return op + " " + args[0] + "," + args[1] + "," + args[2]
 	case SYNC:
 		if args[0] == "$1" {
 			return "LWSYNC"
@@ -136,7 +139,7 @@ func GoSyntax(inst Inst, pc uint64, symname func(uint64) (string, uint64)) strin
 	case LXVL, LXVLL:
 		return op + " " + args[1] + "," + args[2] + "," + args[0]
 
-	case DCBT, DCBTST, DCBZ, DCBST, DCBI, ICBI:
+	case DCBT, DCBTST, DCBZ, DCBST, ICBI:
 		if args[0] == "0" || args[0] == "R0" {
 			return op + " (" + args[1] + ")"
 		}
diff --git a/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/tables.go b/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/tables.go
index 971816ddac..d42ab0f294 100644
--- a/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/tables.go
+++ b/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/tables.go
@@ -1,797 +1,669 @@
 // DO NOT EDIT
-// generated by: ppc64map -fmt=decoder pp64.csv
+// generated by: ppc64map -fmt=decoder ../pp64.csv
 
 package ppc64asm
 
 const (
 	_ Op = iota
-	CNTLZW
-	CNTLZWCC
-	B
-	BA
-	BL
-	BLA
-	BC
-	BCA
-	BCL
-	BCLA
-	BCLR
-	BCLRL
-	BCCTR
-	BCCTRL
+	BRD
+	BRH
+	BRW
+	CFUGED
+	CNTLZDM
+	CNTTZDM
+	DCFFIXQQ
+	DCTFIXQQ
+	LXVKQ
+	LXVP
+	LXVPX
+	LXVRBX
+	LXVRDX
+	LXVRHX
+	LXVRWX
+	MTVSRBM
+	MTVSRBMI
+	MTVSRDM
+	MTVSRHM
+	MTVSRQM
+	MTVSRWM
+	PADDI
+	PDEPD
+	PEXTD
+	PLBZ
+	PLD
+	PLFD
+	PLFS
+	PLHA
+	PLHZ
+	PLQ
+	PLWA
+	PLWZ
+	PLXSD
+	PLXSSP
+	PLXV
+	PLXVP
+	PMXVBF16GER2
+	PMXVBF16GER2NN
+	PMXVBF16GER2NP
+	PMXVBF16GER2PN
+	PMXVBF16GER2PP
+	PMXVF16GER2
+	PMXVF16GER2NN
+	PMXVF16GER2NP
+	PMXVF16GER2PN
+	PMXVF16GER2PP
+	PMXVF32GER
+	PMXVF32GERNN
+	PMXVF32GERNP
+	PMXVF32GERPN
+	PMXVF32GERPP
+	PMXVF64GER
+	PMXVF64GERNN
+	PMXVF64GERNP
+	PMXVF64GERPN
+	PMXVF64GERPP
+	PMXVI16GER2
+	PMXVI16GER2PP
+	PMXVI16GER2S
+	PMXVI16GER2SPP
+	PMXVI4GER8
+	PMXVI4GER8PP
+	PMXVI8GER4
+	PMXVI8GER4PP
+	PMXVI8GER4SPP
+	PNOP
+	PSTB
+	PSTD
+	PSTFD
+	PSTFS
+	PSTH
+	PSTQ
+	PSTW
+	PSTXSD
+	PSTXSSP
+	PSTXV
+	PSTXVP
+	SETBC
+	SETBCR
+	SETNBC
+	SETNBCR
+	STXVP
+	STXVPX
+	STXVRBX
+	STXVRDX
+	STXVRHX
+	STXVRWX
+	VCFUGED
+	VCLRLB
+	VCLRRB
+	VCLZDM
+	VCMPEQUQ
+	VCMPEQUQCC
+	VCMPGTSQ
+	VCMPGTSQCC
+	VCMPGTUQ
+	VCMPGTUQCC
+	VCMPSQ
+	VCMPUQ
+	VCNTMBB
+	VCNTMBD
+	VCNTMBH
+	VCNTMBW
+	VCTZDM
+	VDIVESD
+	VDIVESQ
+	VDIVESW
+	VDIVEUD
+	VDIVEUQ
+	VDIVEUW
+	VDIVSD
+	VDIVSQ
+	VDIVSW
+	VDIVUD
+	VDIVUQ
+	VDIVUW
+	VEXPANDBM
+	VEXPANDDM
+	VEXPANDHM
+	VEXPANDQM
+	VEXPANDWM
+	VEXTDDVLX
+	VEXTDDVRX
+	VEXTDUBVLX
+	VEXTDUBVRX
+	VEXTDUHVLX
+	VEXTDUHVRX
+	VEXTDUWVLX
+	VEXTDUWVRX
+	VEXTRACTBM
+	VEXTRACTDM
+	VEXTRACTHM
+	VEXTRACTQM
+	VEXTRACTWM
+	VEXTSD2Q
+	VGNB
+	VINSBLX
+	VINSBRX
+	VINSBVLX
+	VINSBVRX
+	VINSD
+	VINSDLX
+	VINSDRX
+	VINSHLX
+	VINSHRX
+	VINSHVLX
+	VINSHVRX
+	VINSW
+	VINSWLX
+	VINSWRX
+	VINSWVLX
+	VINSWVRX
+	VMODSD
+	VMODSQ
+	VMODSW
+	VMODUD
+	VMODUQ
+	VMODUW
+	VMSUMCUD
+	VMULESD
+	VMULEUD
+	VMULHSD
+	VMULHSW
+	VMULHUD
+	VMULHUW
+	VMULLD
+	VMULOSD
+	VMULOUD
+	VPDEPD
+	VPEXTD
+	VRLQ
+	VRLQMI
+	VRLQNM
+	VSLDBI
+	VSLQ
+	VSRAQ
+	VSRDBI
+	VSRQ
+	VSTRIBL
+	VSTRIBLCC
+	VSTRIBR
+	VSTRIBRCC
+	VSTRIHL
+	VSTRIHLCC
+	VSTRIHR
+	VSTRIHRCC
+	XSCMPEQQP
+	XSCMPGEQP
+	XSCMPGTQP
+	XSCVQPSQZ
+	XSCVQPUQZ
+	XSCVSQQP
+	XSCVUQQP
+	XSMAXCQP
+	XSMINCQP
+	XVBF16GER2
+	XVBF16GER2NN
+	XVBF16GER2NP
+	XVBF16GER2PN
+	XVBF16GER2PP
+	XVCVBF16SPN
+	XVCVSPBF16
+	XVF16GER2
+	XVF16GER2NN
+	XVF16GER2NP
+	XVF16GER2PN
+	XVF16GER2PP
+	XVF32GER
+	XVF32GERNN
+	XVF32GERNP
+	XVF32GERPN
+	XVF32GERPP
+	XVF64GER
+	XVF64GERNN
+	XVF64GERNP
+	XVF64GERPN
+	XVF64GERPP
+	XVI16GER2
+	XVI16GER2PP
+	XVI16GER2S
+	XVI16GER2SPP
+	XVI4GER8
+	XVI4GER8PP
+	XVI8GER4
+	XVI8GER4PP
+	XVI8GER4SPP
+	XVTLSBB
+	XXBLENDVB
+	XXBLENDVD
+	XXBLENDVH
+	XXBLENDVW
+	XXEVAL
+	XXGENPCVBM
+	XXGENPCVDM
+	XXGENPCVHM
+	XXGENPCVWM
+	XXMFACC
+	XXMTACC
+	XXPERMX
+	XXSETACCZ
+	XXSPLTI32DX
+	XXSPLTIDP
+	XXSPLTIW
+	MSGCLRU
+	MSGSNDU
+	URFID
+	ADDEX
+	MFFSCDRN
+	MFFSCDRNI
+	MFFSCE
+	MFFSCRN
+	MFFSCRNI
+	MFFSL
+	SLBIAG
+	VMSUMUDM
+	ADDPCIS
+	BCDCFNCC
+	BCDCFSQCC
+	BCDCFZCC
+	BCDCPSGNCC
+	BCDCTNCC
+	BCDCTSQCC
+	BCDCTZCC
+	BCDSCC
+	BCDSETSGNCC
+	BCDSRCC
+	BCDTRUNCCC
+	BCDUSCC
+	BCDUTRUNCCC
+	CMPEQB
+	CMPRB
+	CNTTZD
+	CNTTZDCC
+	CNTTZW
+	CNTTZWCC
+	COPY
+	CPABORT
+	DARN
+	DTSTSFI
+	DTSTSFIQ
+	EXTSWSLI
+	EXTSWSLICC
+	LDAT
+	LWAT
+	LXSD
+	LXSIBZX
+	LXSIHZX
+	LXSSP
+	LXV
+	LXVB16X
+	LXVH8X
+	LXVL
+	LXVLL
+	LXVWSX
+	LXVX
+	MADDHD
+	MADDHDU
+	MADDLD
+	MCRXRX
+	MFVSRLD
+	MODSD
+	MODSW
+	MODUD
+	MODUW
+	MSGSYNC
+	MTVSRDD
+	MTVSRWS
+	PASTECC
+	SETB
+	SLBIEG
+	SLBSYNC
+	STDAT
+	STOP
+	STWAT
+	STXSD
+	STXSIBX
+	STXSIHX
+	STXSSP
+	STXV
+	STXVB16X
+	STXVH8X
+	STXVL
+	STXVLL
+	STXVX
+	VABSDUB
+	VABSDUH
+	VABSDUW
+	VBPERMD
+	VCLZLSBB
+	VCMPNEB
+	VCMPNEBCC
+	VCMPNEH
+	VCMPNEHCC
+	VCMPNEW
+	VCMPNEWCC
+	VCMPNEZB
+	VCMPNEZBCC
+	VCMPNEZH
+	VCMPNEZHCC
+	VCMPNEZW
+	VCMPNEZWCC
+	VCTZB
+	VCTZD
+	VCTZH
+	VCTZLSBB
+	VCTZW
+	VEXTRACTD
+	VEXTRACTUB
+	VEXTRACTUH
+	VEXTRACTUW
+	VEXTSB2D
+	VEXTSB2W
+	VEXTSH2D
+	VEXTSH2W
+	VEXTSW2D
+	VEXTUBLX
+	VEXTUBRX
+	VEXTUHLX
+	VEXTUHRX
+	VEXTUWLX
+	VEXTUWRX
+	VINSERTB
+	VINSERTD
+	VINSERTH
+	VINSERTW
+	VMUL10CUQ
+	VMUL10ECUQ
+	VMUL10EUQ
+	VMUL10UQ
+	VNEGD
+	VNEGW
+	VPERMR
+	VPRTYBD
+	VPRTYBQ
+	VPRTYBW
+	VRLDMI
+	VRLDNM
+	VRLWMI
+	VRLWNM
+	VSLV
+	VSRV
+	WAIT
+	XSABSQP
+	XSADDQP
+	XSADDQPO
+	XSCMPEQDP
+	XSCMPEXPDP
+	XSCMPEXPQP
+	XSCMPGEDP
+	XSCMPGTDP
+	XSCMPOQP
+	XSCMPUQP
+	XSCPSGNQP
+	XSCVDPHP
+	XSCVDPQP
+	XSCVHPDP
+	XSCVQPDP
+	XSCVQPDPO
+	XSCVQPSDZ
+	XSCVQPSWZ
+	XSCVQPUDZ
+	XSCVQPUWZ
+	XSCVSDQP
+	XSCVUDQP
+	XSDIVQP
+	XSDIVQPO
+	XSIEXPDP
+	XSIEXPQP
+	XSMADDQP
+	XSMADDQPO
+	XSMAXCDP
+	XSMAXJDP
+	XSMINCDP
+	XSMINJDP
+	XSMSUBQP
+	XSMSUBQPO
+	XSMULQP
+	XSMULQPO
+	XSNABSQP
+	XSNEGQP
+	XSNMADDQP
+	XSNMADDQPO
+	XSNMSUBQP
+	XSNMSUBQPO
+	XSRQPI
+	XSRQPIX
+	XSRQPXP
+	XSSQRTQP
+	XSSQRTQPO
+	XSSUBQP
+	XSSUBQPO
+	XSTSTDCDP
+	XSTSTDCQP
+	XSTSTDCSP
+	XSXEXPDP
+	XSXEXPQP
+	XSXSIGDP
+	XSXSIGQP
+	XVCVHPSP
+	XVCVSPHP
+	XVIEXPDP
+	XVIEXPSP
+	XVTSTDCDP
+	XVTSTDCSP
+	XVXEXPDP
+	XVXEXPSP
+	XVXSIGDP
+	XVXSIGSP
+	XXBRD
+	XXBRH
+	XXBRQ
+	XXBRW
+	XXEXTRACTUW
+	XXINSERTW
+	XXPERM
+	XXPERMR
+	XXSPLTIB
+	BCDADDCC
+	BCDSUBCC
 	BCTAR
 	BCTARL
-	CRAND
-	CROR
-	CRNAND
-	CRXOR
-	CRNOR
-	CRANDC
-	MCRF
-	CREQV
-	CRORC
-	SC
 	CLRBHRB
+	FMRGEW
+	FMRGOW
+	ICBT
+	LQARX
+	LXSIWAX
+	LXSIWZX
+	LXSSPX
 	MFBHRBE
-	LBZ
-	LBZU
-	LBZX
-	LBZUX
-	LHZ
-	LHZU
-	LHZX
-	LHZUX
-	LHA
-	LHAU
-	LHAX
-	LHAUX
-	LWZ
-	LWZU
-	LWZX
-	LWZUX
-	LWA
-	LWAX
-	LWAUX
-	LD
-	LDU
-	LDX
-	LDUX
-	STB
-	STBU
-	STBX
-	STBUX
-	STH
-	STHU
-	STHX
-	STHUX
-	STW
-	STWU
-	STWX
-	STWUX
-	STD
-	STDU
-	STDX
-	STDUX
-	LQ
-	STQ
-	LHBRX
-	LWBRX
-	STHBRX
-	STWBRX
-	LDBRX
-	STDBRX
-	LMW
-	STMW
-	LSWI
-	LSWX
-	STSWI
-	STSWX
-	LI
-	ADDI
-	LIS
-	ADDIS
-	ADD
-	ADDCC
-	ADDO
-	ADDOCC
-	ADDIC
-	SUBF
-	SUBFCC
-	SUBFO
-	SUBFOCC
-	ADDICCC
-	SUBFIC
-	ADDC
-	ADDCCC
-	ADDCO
-	ADDCOCC
-	SUBFC
-	SUBFCCC
-	SUBFCO
-	SUBFCOCC
-	ADDE
-	ADDECC
-	ADDEO
-	ADDEOCC
-	ADDME
-	ADDMECC
-	ADDMEO
-	ADDMEOCC
-	SUBFE
-	SUBFECC
-	SUBFEO
-	SUBFEOCC
-	SUBFME
-	SUBFMECC
-	SUBFMEO
-	SUBFMEOCC
-	ADDZE
-	ADDZECC
-	ADDZEO
-	ADDZEOCC
-	SUBFZE
-	SUBFZECC
-	SUBFZEO
-	SUBFZEOCC
-	NEG
-	NEGCC
-	NEGO
-	NEGOCC
-	MULLI
-	MULLW
-	MULLWCC
-	MULLWO
-	MULLWOCC
-	MULHW
-	MULHWCC
-	MULHWU
-	MULHWUCC
-	DIVW
-	DIVWCC
-	DIVWO
-	DIVWOCC
-	DIVWU
-	DIVWUCC
-	DIVWUO
-	DIVWUOCC
-	DIVWE
-	DIVWECC
-	DIVWEO
-	DIVWEOCC
-	DIVWEU
-	DIVWEUCC
-	DIVWEUO
-	DIVWEUOCC
-	MULLD
-	MULLDCC
-	MULLDO
-	MULLDOCC
-	MULHDU
-	MULHDUCC
-	MULHD
-	MULHDCC
-	DIVD
-	DIVDCC
-	DIVDO
-	DIVDOCC
-	DIVDU
-	DIVDUCC
-	DIVDUO
-	DIVDUOCC
-	DIVDE
-	DIVDECC
-	DIVDEO
-	DIVDEOCC
-	DIVDEU
-	DIVDEUCC
-	DIVDEUO
-	DIVDEUOCC
-	MODSD
-	MODUD
-	MODSW
-	MODUW
-	CMPWI
-	CMPDI
-	CMPW
-	CMPD
-	CMPLWI
-	CMPLDI
-	CMPLW
-	CMPLD
-	TWI
-	TW
-	TDI
-	ISEL
-	TD
-	ANDICC
-	ANDISCC
-	ORI
-	ORIS
-	XORI
-	XORIS
-	AND
-	ANDCC
-	XOR
-	XORCC
-	NAND
-	NANDCC
-	OR
-	ORCC
-	NOR
-	NORCC
-	ANDC
-	ANDCCC
-	EXTSB
-	EXTSBCC
-	EQV
-	EQVCC
-	ORC
-	ORCCC
-	EXTSH
-	EXTSHCC
-	CMPB
-	POPCNTB
-	POPCNTW
-	PRTYD
-	PRTYW
-	EXTSW
-	EXTSWCC
-	CNTLZD
-	CNTLZDCC
-	POPCNTD
-	BPERMD
-	RLWINM
-	RLWINMCC
-	RLWNM
-	RLWNMCC
-	RLWIMI
-	RLWIMICC
-	RLDICL
-	RLDICLCC
-	RLDICR
-	RLDICRCC
-	RLDIC
-	RLDICCC
-	RLDCL
-	RLDCLCC
-	RLDCR
-	RLDCRCC
-	RLDIMI
-	RLDIMICC
-	SLW
-	SLWCC
-	SRW
-	SRWCC
-	SRAWI
-	SRAWICC
-	SRAW
-	SRAWCC
-	SLD
-	SLDCC
-	SRD
-	SRDCC
-	SRADI
-	SRADICC
-	SRAD
-	SRADCC
-	CDTBCD
-	CBCDTD
-	ADDG6S
-	MTSPR
-	MFSPR
-	MTCRF
-	MFCR
-	MTSLE
 	MFVSRD
 	MFVSRWZ
+	MSGCLR
+	MSGCLRP
+	MSGSND
+	MSGSNDP
 	MTVSRD
 	MTVSRWA
 	MTVSRWZ
-	MTOCRF
-	MFOCRF
-	MCRXR
-	MTDCRUX
-	MFDCRUX
-	LFS
-	LFSU
-	LFSX
-	LFSUX
-	LFD
-	LFDU
-	LFDX
-	LFDUX
-	LFIWAX
+	RFEBB
+	STQCXCC
+	STXSIWX
+	STXSSPX
+	VADDCUQ
+	VADDECUQ
+	VADDEUQM
+	VADDUDM
+	VADDUQM
+	VBPERMQ
+	VCIPHER
+	VCIPHERLAST
+	VCLZB
+	VCLZD
+	VCLZH
+	VCLZW
+	VCMPEQUD
+	VCMPEQUDCC
+	VCMPGTSD
+	VCMPGTSDCC
+	VCMPGTUD
+	VCMPGTUDCC
+	VEQV
+	VGBBD
+	VMAXSD
+	VMAXUD
+	VMINSD
+	VMINUD
+	VMRGEW
+	VMRGOW
+	VMULESW
+	VMULEUW
+	VMULOSW
+	VMULOUW
+	VMULUWM
+	VNAND
+	VNCIPHER
+	VNCIPHERLAST
+	VORC
+	VPERMXOR
+	VPKSDSS
+	VPKSDUS
+	VPKUDUM
+	VPKUDUS
+	VPMSUMB
+	VPMSUMD
+	VPMSUMH
+	VPMSUMW
+	VPOPCNTB
+	VPOPCNTD
+	VPOPCNTH
+	VPOPCNTW
+	VRLD
+	VSBOX
+	VSHASIGMAD
+	VSHASIGMAW
+	VSLD
+	VSRAD
+	VSRD
+	VSUBCUQ
+	VSUBECUQ
+	VSUBEUQM
+	VSUBUDM
+	VSUBUQM
+	VUPKHSW
+	VUPKLSW
+	XSADDSP
+	XSCVDPSPN
+	XSCVSPDPN
+	XSCVSXDSP
+	XSCVUXDSP
+	XSDIVSP
+	XSMADDASP
+	XSMADDMSP
+	XSMSUBASP
+	XSMSUBMSP
+	XSMULSP
+	XSNMADDASP
+	XSNMADDMSP
+	XSNMSUBASP
+	XSNMSUBMSP
+	XSRESP
+	XSRSP
+	XSRSQRTESP
+	XSSQRTSP
+	XSSUBSP
+	XXLEQV
+	XXLNAND
+	XXLORC
+	ADDG6S
+	BPERMD
+	CBCDTD
+	CDTBCD
+	DCFFIX
+	DCFFIXCC
+	DIVDE
+	DIVDECC
+	DIVDEO
+	DIVDEOCC
+	DIVDEU
+	DIVDEUCC
+	DIVDEUO
+	DIVDEUOCC
+	DIVWE
+	DIVWECC
+	DIVWEO
+	DIVWEOCC
+	DIVWEU
+	DIVWEUCC
+	DIVWEUO
+	DIVWEUOCC
+	FCFIDS
+	FCFIDSCC
+	FCFIDU
+	FCFIDUCC
+	FCFIDUS
+	FCFIDUSCC
+	FCTIDU
+	FCTIDUCC
+	FCTIDUZ
+	FCTIDUZCC
+	FCTIWU
+	FCTIWUCC
+	FCTIWUZ
+	FCTIWUZCC
+	FTDIV
+	FTSQRT
+	LBARX
+	LDBRX
 	LFIWZX
-	STFS
-	STFSU
-	STFSX
-	STFSUX
-	STFD
-	STFDU
-	STFDX
-	STFDUX
-	STFIWX
-	LFDP
-	LFDPX
-	STFDP
-	STFDPX
-	FMR
-	FMRCC
-	FABS
-	FABSCC
-	FNABS
-	FNABSCC
-	FNEG
-	FNEGCC
-	FCPSGN
-	FCPSGNCC
-	FMRGEW
-	FMRGOW
-	FADD
-	FADDCC
-	FADDS
-	FADDSCC
-	FSUB
-	FSUBCC
-	FSUBS
-	FSUBSCC
-	FMUL
-	FMULCC
-	FMULS
-	FMULSCC
-	FDIV
-	FDIVCC
-	FDIVS
-	FDIVSCC
-	FSQRT
-	FSQRTCC
-	FSQRTS
-	FSQRTSCC
-	FRE
-	FRECC
-	FRES
-	FRESCC
-	FRSQRTE
-	FRSQRTECC
-	FRSQRTES
-	FRSQRTESCC
-	FTDIV
-	FTSQRT
-	FMADD
-	FMADDCC
-	FMADDS
-	FMADDSCC
-	FMSUB
-	FMSUBCC
-	FMSUBS
-	FMSUBSCC
-	FNMADD
-	FNMADDCC
-	FNMADDS
-	FNMADDSCC
-	FNMSUB
-	FNMSUBCC
-	FNMSUBS
-	FNMSUBSCC
-	FRSP
-	FRSPCC
-	FCTID
-	FCTIDCC
-	FCTIDZ
-	FCTIDZCC
-	FCTIDU
-	FCTIDUCC
-	FCTIDUZ
-	FCTIDUZCC
-	FCTIW
-	FCTIWCC
-	FCTIWZ
-	FCTIWZCC
-	FCTIWU
-	FCTIWUCC
-	FCTIWUZ
-	FCTIWUZCC
-	FCFID
-	FCFIDCC
-	FCFIDU
-	FCFIDUCC
-	FCFIDS
-	FCFIDSCC
-	FCFIDUS
-	FCFIDUSCC
-	FRIN
-	FRINCC
-	FRIZ
-	FRIZCC
-	FRIP
-	FRIPCC
-	FRIM
-	FRIMCC
-	FCMPU
-	FCMPO
-	FSEL
-	FSELCC
-	MFFS
-	MFFSCC
-	MCRFS
-	MTFSFI
-	MTFSFICC
-	MTFSF
-	MTFSFCC
-	MTFSB0
-	MTFSB0CC
-	MTFSB1
-	MTFSB1CC
-	LVEBX
-	LVEHX
-	LVEWX
-	LVX
-	LVXL
-	STVEBX
-	STVEHX
-	STVEWX
-	STVX
-	STVXL
-	LVSL
-	LVSR
-	VPKPX
-	VPKSDSS
-	VPKSDUS
-	VPKSHSS
-	VPKSHUS
-	VPKSWSS
-	VPKSWUS
-	VPKUDUM
-	VPKUDUS
-	VPKUHUM
-	VPKUHUS
-	VPKUWUM
-	VPKUWUS
-	VUPKHPX
-	VUPKLPX
-	VUPKHSB
-	VUPKHSH
-	VUPKHSW
-	VUPKLSB
-	VUPKLSH
-	VUPKLSW
-	VMRGHB
-	VMRGHH
-	VMRGLB
-	VMRGLH
-	VMRGHW
-	VMRGLW
-	VMRGEW
-	VMRGOW
-	VSPLTB
-	VSPLTH
-	VSPLTW
-	VSPLTISB
-	VSPLTISH
-	VSPLTISW
-	VPERM
-	VPERMR
-	VSEL
-	VSL
-	VSLDOI
-	VSLO
-	VSR
-	VSRO
-	VADDCUW
-	VADDSBS
-	VADDSHS
-	VADDSWS
-	VADDUBM
-	VADDUDM
-	VADDUHM
-	VADDUWM
-	VADDUBS
-	VADDUHS
-	VADDUWS
-	VADDUQM
-	VADDEUQM
-	VADDCUQ
-	VADDECUQ
-	VSUBCUW
-	VSUBSBS
-	VSUBSHS
-	VSUBSWS
-	VSUBUBM
-	VSUBUDM
-	VSUBUHM
-	VSUBUWM
-	VSUBUBS
-	VSUBUHS
-	VSUBUWS
-	VSUBUQM
-	VSUBEUQM
-	VSUBCUQ
-	VSUBECUQ
-	VMULESB
-	VMULEUB
-	VMULOSB
-	VMULOUB
-	VMULESH
-	VMULEUH
-	VMULOSH
-	VMULOUH
-	VMULESW
-	VMULEUW
-	VMULOSW
-	VMULOUW
-	VMULUWM
-	VMHADDSHS
-	VMHRADDSHS
-	VMLADDUHM
-	VMSUMUBM
-	VMSUMMBM
-	VMSUMSHM
-	VMSUMSHS
-	VMSUMUHM
-	VMSUMUHS
-	VMSUMUDM
-	VSUMSWS
-	VSUM2SWS
-	VSUM4SBS
-	VSUM4SHS
-	VSUM4UBS
-	VAVGSB
-	VAVGSH
-	VAVGSW
-	VAVGUB
-	VAVGUW
-	VAVGUH
-	VMAXSB
-	VMAXSD
-	VMAXUB
-	VMAXUD
-	VMAXSH
-	VMAXSW
-	VMAXUH
-	VMAXUW
-	VMINSB
-	VMINSD
-	VMINUB
-	VMINUD
-	VMINSH
-	VMINSW
-	VMINUH
-	VMINUW
-	VCMPEQUB
-	VCMPEQUBCC
-	VCMPEQUH
-	VCMPEQUHCC
-	VCMPEQUW
-	VCMPEQUWCC
-	VCMPEQUD
-	VCMPEQUDCC
-	VCMPNEB
-	VCMPNEBCC
-	VCMPNEZB
-	VCMPNEZBCC
-	VCMPNEH
-	VCMPNEHCC
-	VCMPNEZH
-	VCMPNEZHCC
-	VCMPNEW
-	VCMPNEWCC
-	VCMPNEZW
-	VCMPNEZWCC
-	VCMPGTSB
-	VCMPGTSBCC
-	VCMPGTSD
-	VCMPGTSDCC
-	VCMPGTSH
-	VCMPGTSHCC
-	VCMPGTSW
-	VCMPGTSWCC
-	VCMPGTUB
-	VCMPGTUBCC
-	VCMPGTUD
-	VCMPGTUDCC
-	VCMPGTUH
-	VCMPGTUHCC
-	VCMPGTUW
-	VCMPGTUWCC
-	VAND
-	VANDC
-	VEQV
-	VNAND
-	VORC
-	VNOR
-	VOR
-	VXOR
-	VRLB
-	VRLH
-	VRLW
-	VRLD
-	VSLB
-	VSLH
-	VSLW
-	VSLD
-	VSRB
-	VSRH
-	VSRW
-	VSRD
-	VSRAB
-	VSRAH
-	VSRAW
-	VSRAD
-	VADDFP
-	VSUBFP
-	VMADDFP
-	VNMSUBFP
-	VMAXFP
-	VMINFP
-	VCTSXS
-	VCTUXS
-	VCFSX
-	VCFUX
-	VRFIM
-	VRFIN
-	VRFIP
-	VRFIZ
-	VCMPBFP
-	VCMPBFPCC
-	VCMPEQFP
-	VCMPEQFPCC
-	VCMPGEFP
-	VCMPGEFPCC
-	VCMPGTFP
-	VCMPGTFPCC
-	VEXPTEFP
-	VLOGEFP
-	VREFP
-	VRSQRTEFP
-	VCIPHER
-	VCIPHERLAST
-	VNCIPHER
-	VNCIPHERLAST
-	VSBOX
-	VSHASIGMAD
-	VSHASIGMAW
-	VPMSUMB
-	VPMSUMD
-	VPMSUMH
-	VPMSUMW
-	VPERMXOR
-	VGBBD
-	VCLZB
-	VCLZH
-	VCLZW
-	VCLZD
-	VPOPCNTB
-	VPOPCNTD
-	VPOPCNTH
-	VPOPCNTW
-	VBPERMQ
-	VBPERMD
-	BCDADDCC
-	BCDSUBCC
-	MTVSCR
-	MFVSCR
-	DADD
-	DADDCC
-	DSUB
-	DSUBCC
-	DMUL
-	DMULCC
-	DDIV
-	DDIVCC
-	DCMPU
-	DCMPO
-	DTSTDC
-	DTSTDG
-	DTSTEX
-	DTSTSF
-	DQUAI
-	DQUAICC
-	DQUA
-	DQUACC
-	DRRND
-	DRRNDCC
-	DRINTX
-	DRINTXCC
-	DRINTN
-	DRINTNCC
-	DCTDP
-	DCTDPCC
-	DCTQPQ
-	DCTQPQCC
-	DRSP
-	DRSPCC
-	DRDPQ
-	DRDPQCC
-	DCFFIX
-	DCFFIXCC
-	DCFFIXQ
-	DCFFIXQCC
-	DCTFIX
-	DCTFIXCC
-	DDEDPD
-	DDEDPDCC
-	DENBCD
-	DENBCDCC
-	DXEX
-	DXEXCC
-	DIEX
-	DIEXCC
-	DSCLI
-	DSCLICC
-	DSCRI
-	DSCRICC
+	LHARX
 	LXSDX
-	LXSIWAX
-	LXSIWZX
-	LXSSPX
 	LXVD2X
 	LXVDSX
 	LXVW4X
-	LXVH8X
-	LXVB16X
-	LXV
-	LXVL
-	LXVLL
-	LXVX
+	POPCNTD
+	POPCNTW
+	STBCXCC
+	STDBRX
+	STHCXCC
 	STXSDX
-	STXSIWX
-	STXSSPX
 	STXVD2X
 	STXVW4X
-	STXVH8X
-	STXVB16X
-	STXV
-	STXVL
-	STXVLL
-	STXVX
 	XSABSDP
 	XSADDDP
-	XSADDSP
 	XSCMPODP
 	XSCMPUDP
 	XSCPSGNDP
 	XSCVDPSP
-	XSCVDPSPN
 	XSCVDPSXDS
 	XSCVDPSXWS
 	XSCVDPUXDS
 	XSCVDPUXWS
 	XSCVSPDP
-	XSCVSPDPN
 	XSCVSXDDP
-	XSCVSXDSP
 	XSCVUXDDP
-	XSCVUXDSP
 	XSDIVDP
-	XSDIVSP
 	XSMADDADP
-	XSMADDASP
+	XSMADDMDP
 	XSMAXDP
 	XSMINDP
 	XSMSUBADP
-	XSMSUBASP
+	XSMSUBMDP
 	XSMULDP
-	XSMULSP
 	XSNABSDP
 	XSNEGDP
 	XSNMADDADP
-	XSNMADDASP
+	XSNMADDMDP
 	XSNMSUBADP
-	XSNMSUBASP
+	XSNMSUBMDP
 	XSRDPI
 	XSRDPIC
 	XSRDPIM
 	XSRDPIP
 	XSRDPIZ
 	XSREDP
-	XSRESP
-	XSRSP
 	XSRSQRTEDP
-	XSRSQRTESP
 	XSSQRTDP
-	XSSQRTSP
 	XSSUBDP
-	XSSUBSP
 	XSTDIVDP
 	XSTSQRTDP
 	XVABSDP
@@ -834,12 +706,16 @@ const (
 	XVDIVSP
 	XVMADDADP
 	XVMADDASP
+	XVMADDMDP
+	XVMADDMSP
 	XVMAXDP
 	XVMAXSP
 	XVMINDP
 	XVMINSP
 	XVMSUBADP
 	XVMSUBASP
+	XVMSUBMDP
+	XVMSUBMSP
 	XVMULDP
 	XVMULSP
 	XVNABSDP
@@ -848,8 +724,12 @@ const (
 	XVNEGSP
 	XVNMADDADP
 	XVNMADDASP
+	XVNMADDMDP
+	XVNMADDMSP
 	XVNMSUBADP
 	XVNMSUBASP
+	XVNMSUBMDP
+	XVNMSUBMSP
 	XVRDPI
 	XVRDPIC
 	XVRDPIM
@@ -874,4763 +754,5019 @@ const (
 	XVTSQRTSP
 	XXLAND
 	XXLANDC
-	XXLEQV
-	XXLNAND
-	XXLORC
 	XXLNOR
 	XXLOR
 	XXLXOR
 	XXMRGHW
 	XXMRGLW
 	XXPERMDI
-	XXPERM
 	XXSEL
 	XXSLDWI
 	XXSPLTW
-	XXBRD
-	XXBRW
-	XXBRH
-	BRINC
-	EVABS
-	EVADDIW
-	EVADDSMIAAW
-	EVADDSSIAAW
-	EVADDUMIAAW
-	EVADDUSIAAW
-	EVADDW
-	EVAND
-	EVCMPEQ
-	EVANDC
-	EVCMPGTS
-	EVCMPGTU
-	EVCMPLTU
-	EVCMPLTS
-	EVCNTLSW
-	EVCNTLZW
-	EVDIVWS
-	EVDIVWU
-	EVEQV
-	EVEXTSB
-	EVEXTSH
-	EVLDD
-	EVLDH
-	EVLDDX
-	EVLDHX
-	EVLDW
-	EVLHHESPLAT
-	EVLDWX
-	EVLHHESPLATX
-	EVLHHOSSPLAT
-	EVLHHOUSPLAT
-	EVLHHOSSPLATX
-	EVLHHOUSPLATX
-	EVLWHE
-	EVLWHOS
-	EVLWHEX
-	EVLWHOSX
-	EVLWHOU
-	EVLWHSPLAT
-	EVLWHOUX
-	EVLWHSPLATX
-	EVLWWSPLAT
-	EVMERGEHI
-	EVLWWSPLATX
-	EVMERGELO
-	EVMERGEHILO
-	EVMHEGSMFAA
-	EVMERGELOHI
-	EVMHEGSMFAN
-	EVMHEGSMIAA
-	EVMHEGUMIAA
-	EVMHEGSMIAN
-	EVMHEGUMIAN
-	EVMHESMF
-	EVMHESMFAAW
-	EVMHESMFA
-	EVMHESMFANW
-	EVMHESMI
-	EVMHESMIAAW
-	EVMHESMIA
-	EVMHESMIANW
-	EVMHESSF
-	EVMHESSFA
-	EVMHESSFAAW
-	EVMHESSFANW
-	EVMHESSIAAW
-	EVMHESSIANW
-	EVMHEUMI
-	EVMHEUMIAAW
-	EVMHEUMIA
-	EVMHEUMIANW
-	EVMHEUSIAAW
-	EVMHEUSIANW
-	EVMHOGSMFAA
-	EVMHOGSMIAA
-	EVMHOGSMFAN
-	EVMHOGSMIAN
-	EVMHOGUMIAA
-	EVMHOSMF
-	EVMHOGUMIAN
-	EVMHOSMFA
-	EVMHOSMFAAW
-	EVMHOSMI
-	EVMHOSMFANW
-	EVMHOSMIA
-	EVMHOSMIAAW
-	EVMHOSMIANW
-	EVMHOSSF
-	EVMHOSSFA
-	EVMHOSSFAAW
-	EVMHOSSFANW
-	EVMHOSSIAAW
-	EVMHOUMI
-	EVMHOSSIANW
-	EVMHOUMIA
-	EVMHOUMIAAW
-	EVMHOUSIAAW
-	EVMHOUMIANW
-	EVMHOUSIANW
-	EVMRA
-	EVMWHSMF
-	EVMWHSMI
-	EVMWHSMFA
-	EVMWHSMIA
-	EVMWHSSF
-	EVMWHUMI
-	EVMWHSSFA
-	EVMWHUMIA
-	EVMWLSMIAAW
-	EVMWLSSIAAW
-	EVMWLSMIANW
-	EVMWLSSIANW
-	EVMWLUMI
-	EVMWLUMIAAW
-	EVMWLUMIA
-	EVMWLUMIANW
-	EVMWLUSIAAW
-	EVMWSMF
-	EVMWLUSIANW
-	EVMWSMFA
-	EVMWSMFAA
-	EVMWSMI
-	EVMWSMIAA
-	EVMWSMFAN
-	EVMWSMIA
-	EVMWSMIAN
-	EVMWSSF
-	EVMWSSFA
-	EVMWSSFAA
-	EVMWUMI
-	EVMWSSFAN
-	EVMWUMIA
-	EVMWUMIAA
-	EVNAND
-	EVMWUMIAN
-	EVNEG
-	EVNOR
-	EVORC
-	EVOR
-	EVRLW
-	EVRLWI
-	EVSEL
-	EVRNDW
-	EVSLW
-	EVSPLATFI
-	EVSRWIS
-	EVSLWI
-	EVSPLATI
-	EVSRWIU
-	EVSRWS
-	EVSTDD
-	EVSRWU
-	EVSTDDX
-	EVSTDH
-	EVSTDW
-	EVSTDHX
-	EVSTDWX
-	EVSTWHE
-	EVSTWHO
-	EVSTWWE
-	EVSTWHEX
-	EVSTWHOX
-	EVSTWWEX
-	EVSTWWO
-	EVSUBFSMIAAW
-	EVSTWWOX
-	EVSUBFSSIAAW
-	EVSUBFUMIAAW
-	EVSUBFUSIAAW
-	EVSUBFW
-	EVSUBIFW
-	EVXOR
-	EVFSABS
-	EVFSNABS
-	EVFSNEG
-	EVFSADD
-	EVFSMUL
-	EVFSSUB
-	EVFSDIV
-	EVFSCMPGT
-	EVFSCMPLT
-	EVFSCMPEQ
-	EVFSTSTGT
-	EVFSTSTLT
-	EVFSTSTEQ
-	EVFSCFSI
-	EVFSCFSF
-	EVFSCFUI
-	EVFSCFUF
-	EVFSCTSI
-	EVFSCTUI
-	EVFSCTSIZ
-	EVFSCTUIZ
-	EVFSCTSF
-	EVFSCTUF
-	EFSABS
-	EFSNEG
-	EFSNABS
-	EFSADD
-	EFSMUL
-	EFSSUB
-	EFSDIV
-	EFSCMPGT
-	EFSCMPLT
-	EFSCMPEQ
-	EFSTSTGT
-	EFSTSTLT
-	EFSTSTEQ
-	EFSCFSI
-	EFSCFSF
-	EFSCTSI
-	EFSCFUI
-	EFSCFUF
-	EFSCTUI
-	EFSCTSIZ
-	EFSCTSF
-	EFSCTUIZ
-	EFSCTUF
-	EFDABS
-	EFDNEG
-	EFDNABS
-	EFDADD
-	EFDMUL
-	EFDSUB
-	EFDDIV
-	EFDCMPGT
-	EFDCMPEQ
-	EFDCMPLT
-	EFDTSTGT
-	EFDTSTLT
-	EFDCFSI
-	EFDTSTEQ
-	EFDCFUI
-	EFDCFSID
-	EFDCFSF
-	EFDCFUF
-	EFDCFUID
-	EFDCTSI
-	EFDCTUI
-	EFDCTSIDZ
-	EFDCTUIDZ
-	EFDCTSIZ
-	EFDCTSF
-	EFDCTUF
-	EFDCTUIZ
-	EFDCFS
-	EFSCFD
-	DLMZB
-	DLMZBCC
-	MACCHW
-	MACCHWCC
-	MACCHWO
-	MACCHWOCC
-	MACCHWS
-	MACCHWSCC
-	MACCHWSO
-	MACCHWSOCC
-	MACCHWU
-	MACCHWUCC
-	MACCHWUO
-	MACCHWUOCC
-	MACCHWSU
-	MACCHWSUCC
-	MACCHWSUO
-	MACCHWSUOCC
-	MACHHW
-	MACHHWCC
-	MACHHWO
-	MACHHWOCC
-	MACHHWS
-	MACHHWSCC
-	MACHHWSO
-	MACHHWSOCC
-	MACHHWU
-	MACHHWUCC
-	MACHHWUO
-	MACHHWUOCC
-	MACHHWSU
-	MACHHWSUCC
-	MACHHWSUO
-	MACHHWSUOCC
-	MACLHW
-	MACLHWCC
-	MACLHWO
-	MACLHWOCC
-	MACLHWS
-	MACLHWSCC
-	MACLHWSO
-	MACLHWSOCC
-	MACLHWU
-	MACLHWUCC
-	MACLHWUO
-	MACLHWUOCC
-	MULCHW
-	MULCHWCC
-	MACLHWSU
-	MACLHWSUCC
-	MACLHWSUO
-	MACLHWSUOCC
-	MULCHWU
-	MULCHWUCC
-	MULHHW
-	MULHHWCC
-	MULLHW
-	MULLHWCC
-	MULHHWU
-	MULHHWUCC
-	MULLHWU
-	MULLHWUCC
-	NMACCHW
-	NMACCHWCC
-	NMACCHWO
-	NMACCHWOCC
-	NMACCHWS
-	NMACCHWSCC
-	NMACCHWSO
-	NMACCHWSOCC
-	NMACHHW
-	NMACHHWCC
-	NMACHHWO
-	NMACHHWOCC
-	NMACHHWS
-	NMACHHWSCC
-	NMACHHWSO
-	NMACHHWSOCC
-	NMACLHW
-	NMACLHWCC
-	NMACLHWO
-	NMACLHWOCC
-	NMACLHWS
-	NMACLHWSCC
-	NMACLHWSO
-	NMACLHWSOCC
-	ICBI
-	ICBT
-	DCBA
+	CMPB
+	DADD
+	DADDCC
+	DADDQ
+	DADDQCC
+	DCFFIXQ
+	DCFFIXQCC
+	DCMPO
+	DCMPOQ
+	DCMPU
+	DCMPUQ
+	DCTDP
+	DCTDPCC
+	DCTFIX
+	DCTFIXCC
+	DCTFIXQ
+	DCTFIXQCC
+	DCTQPQ
+	DCTQPQCC
+	DDEDPD
+	DDEDPDCC
+	DDEDPDQ
+	DDEDPDQCC
+	DDIV
+	DDIVCC
+	DDIVQ
+	DDIVQCC
+	DENBCD
+	DENBCDCC
+	DENBCDQ
+	DENBCDQCC
+	DIEX
+	DIEXCC
+	DIEXQCC
+	DIEXQ
+	DMUL
+	DMULCC
+	DMULQ
+	DMULQCC
+	DQUA
+	DQUACC
+	DQUAI
+	DQUAICC
+	DQUAIQ
+	DQUAIQCC
+	DQUAQ
+	DQUAQCC
+	DRDPQ
+	DRDPQCC
+	DRINTN
+	DRINTNCC
+	DRINTNQ
+	DRINTNQCC
+	DRINTX
+	DRINTXCC
+	DRINTXQ
+	DRINTXQCC
+	DRRND
+	DRRNDCC
+	DRRNDQ
+	DRRNDQCC
+	DRSP
+	DRSPCC
+	DSCLI
+	DSCLICC
+	DSCLIQ
+	DSCLIQCC
+	DSCRI
+	DSCRICC
+	DSCRIQ
+	DSCRIQCC
+	DSUB
+	DSUBCC
+	DSUBQ
+	DSUBQCC
+	DTSTDC
+	DTSTDCQ
+	DTSTDG
+	DTSTDGQ
+	DTSTEX
+	DTSTEXQ
+	DTSTSF
+	DTSTSFQ
+	DXEX
+	DXEXCC
+	DXEXQ
+	DXEXQCC
+	FCPSGN
+	FCPSGNCC
+	LBZCIX
+	LDCIX
+	LFDP
+	LFDPX
+	LFIWAX
+	LHZCIX
+	LWZCIX
+	PRTYD
+	PRTYW
+	SLBFEECC
+	STBCIX
+	STDCIX
+	STFDP
+	STFDPX
+	STHCIX
+	STWCIX
+	ISEL
+	LVEBX
+	LVEHX
+	LVEWX
+	LVSL
+	LVSR
+	LVX
+	LVXL
+	MFVSCR
+	MTVSCR
+	STVEBX
+	STVEHX
+	STVEWX
+	STVX
+	STVXL
+	TLBIEL
+	VADDCUW
+	VADDFP
+	VADDSBS
+	VADDSHS
+	VADDSWS
+	VADDUBM
+	VADDUBS
+	VADDUHM
+	VADDUHS
+	VADDUWM
+	VADDUWS
+	VAND
+	VANDC
+	VAVGSB
+	VAVGSH
+	VAVGSW
+	VAVGUB
+	VAVGUH
+	VAVGUW
+	VCFSX
+	VCFUX
+	VCMPBFP
+	VCMPBFPCC
+	VCMPEQFP
+	VCMPEQFPCC
+	VCMPEQUB
+	VCMPEQUBCC
+	VCMPEQUH
+	VCMPEQUHCC
+	VCMPEQUW
+	VCMPEQUWCC
+	VCMPGEFP
+	VCMPGEFPCC
+	VCMPGTFP
+	VCMPGTFPCC
+	VCMPGTSB
+	VCMPGTSBCC
+	VCMPGTSH
+	VCMPGTSHCC
+	VCMPGTSW
+	VCMPGTSWCC
+	VCMPGTUB
+	VCMPGTUBCC
+	VCMPGTUH
+	VCMPGTUHCC
+	VCMPGTUW
+	VCMPGTUWCC
+	VCTSXS
+	VCTUXS
+	VEXPTEFP
+	VLOGEFP
+	VMADDFP
+	VMAXFP
+	VMAXSB
+	VMAXSH
+	VMAXSW
+	VMAXUB
+	VMAXUH
+	VMAXUW
+	VMHADDSHS
+	VMHRADDSHS
+	VMINFP
+	VMINSB
+	VMINSH
+	VMINSW
+	VMINUB
+	VMINUH
+	VMINUW
+	VMLADDUHM
+	VMRGHB
+	VMRGHH
+	VMRGHW
+	VMRGLB
+	VMRGLH
+	VMRGLW
+	VMSUMMBM
+	VMSUMSHM
+	VMSUMSHS
+	VMSUMUBM
+	VMSUMUHM
+	VMSUMUHS
+	VMULESB
+	VMULESH
+	VMULEUB
+	VMULEUH
+	VMULOSB
+	VMULOSH
+	VMULOUB
+	VMULOUH
+	VNMSUBFP
+	VNOR
+	VOR
+	VPERM
+	VPKPX
+	VPKSHSS
+	VPKSHUS
+	VPKSWSS
+	VPKSWUS
+	VPKUHUM
+	VPKUHUS
+	VPKUWUM
+	VPKUWUS
+	VREFP
+	VRFIM
+	VRFIN
+	VRFIP
+	VRFIZ
+	VRLB
+	VRLH
+	VRLW
+	VRSQRTEFP
+	VSEL
+	VSL
+	VSLB
+	VSLDOI
+	VSLH
+	VSLO
+	VSLW
+	VSPLTB
+	VSPLTH
+	VSPLTISB
+	VSPLTISH
+	VSPLTISW
+	VSPLTW
+	VSR
+	VSRAB
+	VSRAH
+	VSRAW
+	VSRB
+	VSRH
+	VSRO
+	VSRW
+	VSUBCUW
+	VSUBFP
+	VSUBSBS
+	VSUBSHS
+	VSUBSWS
+	VSUBUBM
+	VSUBUBS
+	VSUBUHM
+	VSUBUHS
+	VSUBUWM
+	VSUBUWS
+	VSUM2SWS
+	VSUM4SBS
+	VSUM4SHS
+	VSUM4UBS
+	VSUMSWS
+	VUPKHPX
+	VUPKHSB
+	VUPKHSH
+	VUPKLPX
+	VUPKLSB
+	VUPKLSH
+	VXOR
+	FRE
+	FRECC
+	FRIM
+	FRIMCC
+	FRIN
+	FRINCC
+	FRIP
+	FRIPCC
+	FRIZ
+	FRIZCC
+	FRSQRTES
+	FRSQRTESCC
+	HRFID
+	POPCNTB
+	MFOCRF
+	MTOCRF
+	SLBMFEE
+	SLBMFEV
+	SLBMTE
+	RFSCV
+	SCV
+	LQ
+	STQ
+	CNTLZD
+	CNTLZDCC
+	DCBF
+	DCBST
 	DCBT
 	DCBTST
+	DIVD
+	DIVDCC
+	DIVDO
+	DIVDOCC
+	DIVDU
+	DIVDUCC
+	DIVDUO
+	DIVDUOCC
+	DIVW
+	DIVWCC
+	DIVWO
+	DIVWOCC
+	DIVWU
+	DIVWUCC
+	DIVWUO
+	DIVWUOCC
+	EIEIO
+	EXTSB
+	EXTSBCC
+	EXTSW
+	EXTSWCC
+	FADDS
+	FADDSCC
+	FCFID
+	FCFIDCC
+	FCTID
+	FCTIDCC
+	FCTIDZ
+	FCTIDZCC
+	FDIVS
+	FDIVSCC
+	FMADDS
+	FMADDSCC
+	FMSUBS
+	FMSUBSCC
+	FMULS
+	FMULSCC
+	FNMADDS
+	FNMADDSCC
+	FNMSUBS
+	FNMSUBSCC
+	FRES
+	FRESCC
+	FRSQRTE
+	FRSQRTECC
+	FSEL
+	FSELCC
+	FSQRTS
+	FSQRTSCC
+	FSUBS
+	FSUBSCC
+	ICBI
+	LD
+	LDARX
+	LDU
+	LDUX
+	LDX
+	LWA
+	LWARX
+	LWAUX
+	LWAX
+	MFTB
+	MTMSRD
+	MULHD
+	MULHDCC
+	MULHDU
+	MULHDUCC
+	MULHW
+	MULHWCC
+	MULHWU
+	MULHWUCC
+	MULLD
+	MULLDCC
+	MULLDO
+	MULLDOCC
+	RFID
+	RLDCL
+	RLDCLCC
+	RLDCR
+	RLDCRCC
+	RLDIC
+	RLDICCC
+	RLDICL
+	RLDICLCC
+	RLDICR
+	RLDICRCC
+	RLDIMI
+	RLDIMICC
+	SC
+	SLBIA
+	SLBIE
+	SLD
+	SLDCC
+	SRAD
+	SRADCC
+	SRADI
+	SRADICC
+	SRD
+	SRDCC
+	STD
+	STDCXCC
+	STDU
+	STDUX
+	STDX
+	STFIWX
+	STWCXCC
+	SUBF
+	SUBFCC
+	SUBFO
+	SUBFOCC
+	TD
+	TDI
+	TLBSYNC
+	FCTIW
+	FCTIWCC
+	FCTIWZ
+	FCTIWZCC
+	FSQRT
+	FSQRTCC
+	ADD
+	ADDCC
+	ADDO
+	ADDOCC
+	ADDC
+	ADDCCC
+	ADDCO
+	ADDCOCC
+	ADDE
+	ADDECC
+	ADDEO
+	ADDEOCC
+	LI
+	ADDI
+	ADDIC
+	ADDICCC
+	LIS
+	ADDIS
+	ADDME
+	ADDMECC
+	ADDMEO
+	ADDMEOCC
+	ADDZE
+	ADDZECC
+	ADDZEO
+	ADDZEOCC
+	AND
+	ANDCC
+	ANDC
+	ANDCCC
+	ANDICC
+	ANDISCC
+	B
+	BA
+	BL
+	BLA
+	BC
+	BCA
+	BCL
+	BCLA
+	BCCTR
+	BCCTRL
+	BCLR
+	BCLRL
+	CMPW
+	CMPD
+	CMP
+	CMPWI
+	CMPDI
+	CMPI
+	CMPLW
+	CMPLD
+	CMPL
+	CMPLWI
+	CMPLDI
+	CMPLI
+	CNTLZW
+	CNTLZWCC
+	CRAND
+	CRANDC
+	CREQV
+	CRNAND
+	CRNOR
+	CROR
+	CRORC
+	CRXOR
 	DCBZ
-	DCBST
-	DCBF
+	EQV
+	EQVCC
+	EXTSH
+	EXTSHCC
+	FABS
+	FABSCC
+	FADD
+	FADDCC
+	FCMPO
+	FCMPU
+	FDIV
+	FDIVCC
+	FMADD
+	FMADDCC
+	FMR
+	FMRCC
+	FMSUB
+	FMSUBCC
+	FMUL
+	FMULCC
+	FNABS
+	FNABSCC
+	FNEG
+	FNEGCC
+	FNMADD
+	FNMADDCC
+	FNMSUB
+	FNMSUBCC
+	FRSP
+	FRSPCC
+	FSUB
+	FSUBCC
 	ISYNC
-	LBARX
-	LHARX
-	LWARX
-	STBCXCC
-	STHCXCC
-	STWCXCC
-	LDARX
-	STDCXCC
-	LQARX
-	STQCXCC
-	SYNC
-	EIEIO
-	MBAR
-	WAIT
-	TBEGINCC
-	TENDCC
-	TABORTCC
-	TABORTWCCC
-	TABORTWCICC
-	TABORTDCCC
-	TABORTDCICC
-	TSRCC
-	TCHECK
-	MFTB
-	RFEBB
-	LBDX
-	LHDX
-	LWDX
-	LDDX
-	LFDDX
-	STBDX
-	STHDX
-	STWDX
-	STDDX
-	STFDDX
-	DSN
-	ECIWX
-	ECOWX
-	RFID
-	HRFID
-	DOZE
-	NAP
-	SLEEP
-	RVWINKLE
-	LBZCIX
-	LWZCIX
-	LHZCIX
-	LDCIX
-	STBCIX
-	STWCIX
-	STHCIX
-	STDCIX
-	TRECLAIMCC
-	TRECHKPTCC
-	MTMSR
-	MTMSRD
+	LBZ
+	LBZU
+	LBZUX
+	LBZX
+	LFD
+	LFDU
+	LFDUX
+	LFDX
+	LFS
+	LFSU
+	LFSUX
+	LFSX
+	LHA
+	LHAU
+	LHAUX
+	LHAX
+	LHBRX
+	LHZ
+	LHZU
+	LHZUX
+	LHZX
+	LMW
+	LSWI
+	LSWX
+	LWBRX
+	LWZ
+	LWZU
+	LWZUX
+	LWZX
+	MCRF
+	MCRFS
+	MFCR
+	MFFS
+	MFFSCC
 	MFMSR
-	SLBIE
-	SLBIA
-	SLBMTE
-	SLBMFEV
-	SLBMFEE
-	SLBFEECC
-	MTSR
-	MTSRIN
-	MFSR
-	MFSRIN
+	MFSPR
+	MTCRF
+	MTFSB0
+	MTFSB0CC
+	MTFSB1
+	MTFSB1CC
+	MTFSF
+	MTFSFCC
+	MTFSFI
+	MTFSFICC
+	MTMSR
+	MTSPR
+	MULLI
+	MULLW
+	MULLWCC
+	MULLWO
+	MULLWOCC
+	NAND
+	NANDCC
+	NEG
+	NEGCC
+	NEGO
+	NEGOCC
+	NOR
+	NORCC
+	OR
+	ORCC
+	ORC
+	ORCCC
+	NOP
+	ORI
+	ORIS
+	RLWIMI
+	RLWIMICC
+	RLWINM
+	RLWINMCC
+	RLWNM
+	RLWNMCC
+	SLW
+	SLWCC
+	SRAW
+	SRAWCC
+	SRAWI
+	SRAWICC
+	SRW
+	SRWCC
+	STB
+	STBU
+	STBUX
+	STBX
+	STFD
+	STFDU
+	STFDUX
+	STFDX
+	STFS
+	STFSU
+	STFSUX
+	STFSX
+	STH
+	STHBRX
+	STHU
+	STHUX
+	STHX
+	STMW
+	STSWI
+	STSWX
+	STW
+	STWBRX
+	STWU
+	STWUX
+	STWX
+	SUBFC
+	SUBFCCC
+	SUBFCO
+	SUBFCOCC
+	SUBFE
+	SUBFECC
+	SUBFEO
+	SUBFEOCC
+	SUBFIC
+	SUBFME
+	SUBFMECC
+	SUBFMEO
+	SUBFMEOCC
+	SUBFZE
+	SUBFZECC
+	SUBFZEO
+	SUBFZEOCC
+	SYNC
 	TLBIE
-	TLBIEL
-	TLBIA
-	TLBSYNC
-	MSGSND
-	MSGCLR
-	MSGSNDP
-	MSGCLRP
-	MTTMR
-	RFI
-	RFCI
-	RFDI
-	RFMCI
-	RFGI
-	EHPRIV
-	MTDCR
-	MTDCRX
-	MFDCR
-	MFDCRX
-	WRTEE
-	WRTEEI
-	LBEPX
-	LHEPX
-	LWEPX
-	LDEPX
-	STBEPX
-	STHEPX
-	STWEPX
-	STDEPX
-	DCBSTEP
-	DCBTEP
-	DCBFEP
-	DCBTSTEP
-	ICBIEP
-	DCBZEP
-	LFDEPX
-	STFDEPX
-	EVLDDEPX
-	EVSTDDEPX
-	LVEPX
-	LVEPXL
-	STVEPX
-	STVEPXL
-	DCBI
-	DCBLQCC
-	ICBLQCC
-	DCBTLS
-	DCBTSTLS
-	ICBTLS
-	ICBLC
-	DCBLC
-	TLBIVAX
-	TLBILX
-	TLBSX
-	TLBSRXCC
-	TLBRE
-	TLBWE
-	DNH
-	DCI
-	ICI
-	DCREAD
-	ICREAD
-	MFPMR
-	MTPMR
-	ADDEX
-	DARN
-	MADDHD
-	MADDHDU
-	MADDLD
-	CMPRB
-	CMPEQB
-	EXTSWSLI
-	EXTSWSLICC
-	MFVSRLD
-	MTVSRDD
-	MTVSRWS
-	MCRXRX
-	COPY
-	PASTECC
+	TW
+	TWI
+	XOR
+	XORCC
+	XORI
+	XORIS
 )
 
 var opstr = [...]string{
-	CNTLZW:        "cntlzw",
-	CNTLZWCC:      "cntlzw.",
-	B:             "b",
-	BA:            "ba",
-	BL:            "bl",
-	BLA:           "bla",
-	BC:            "bc",
-	BCA:           "bca",
-	BCL:           "bcl",
-	BCLA:          "bcla",
-	BCLR:          "bclr",
-	BCLRL:         "bclrl",
-	BCCTR:         "bcctr",
-	BCCTRL:        "bcctrl",
-	BCTAR:         "bctar",
-	BCTARL:        "bctarl",
-	CRAND:         "crand",
-	CROR:          "cror",
-	CRNAND:        "crnand",
-	CRXOR:         "crxor",
-	CRNOR:         "crnor",
-	CRANDC:        "crandc",
-	MCRF:          "mcrf",
-	CREQV:         "creqv",
-	CRORC:         "crorc",
-	SC:            "sc",
-	CLRBHRB:       "clrbhrb",
-	MFBHRBE:       "mfbhrbe",
-	LBZ:           "lbz",
-	LBZU:          "lbzu",
-	LBZX:          "lbzx",
-	LBZUX:         "lbzux",
-	LHZ:           "lhz",
-	LHZU:          "lhzu",
-	LHZX:          "lhzx",
-	LHZUX:         "lhzux",
-	LHA:           "lha",
-	LHAU:          "lhau",
-	LHAX:          "lhax",
-	LHAUX:         "lhaux",
-	LWZ:           "lwz",
-	LWZU:          "lwzu",
-	LWZX:          "lwzx",
-	LWZUX:         "lwzux",
-	LWA:           "lwa",
-	LWAX:          "lwax",
-	LWAUX:         "lwaux",
-	LD:            "ld",
-	LDU:           "ldu",
-	LDX:           "ldx",
-	LDUX:          "ldux",
-	STB:           "stb",
-	STBU:          "stbu",
-	STBX:          "stbx",
-	STBUX:         "stbux",
-	STH:           "sth",
-	STHU:          "sthu",
-	STHX:          "sthx",
-	STHUX:         "sthux",
-	STW:           "stw",
-	STWU:          "stwu",
-	STWX:          "stwx",
-	STWUX:         "stwux",
-	STD:           "std",
-	STDU:          "stdu",
-	STDX:          "stdx",
-	STDUX:         "stdux",
-	LQ:            "lq",
-	STQ:           "stq",
-	LHBRX:         "lhbrx",
-	LWBRX:         "lwbrx",
-	STHBRX:        "sthbrx",
-	STWBRX:        "stwbrx",
-	LDBRX:         "ldbrx",
-	STDBRX:        "stdbrx",
-	LMW:           "lmw",
-	STMW:          "stmw",
-	LSWI:          "lswi",
-	LSWX:          "lswx",
-	STSWI:         "stswi",
-	STSWX:         "stswx",
-	LI:            "li",
-	ADDI:          "addi",
-	LIS:           "lis",
-	ADDIS:         "addis",
-	ADD:           "add",
-	ADDCC:         "add.",
-	ADDO:          "addo",
-	ADDOCC:        "addo.",
-	ADDIC:         "addic",
-	SUBF:          "subf",
-	SUBFCC:        "subf.",
-	SUBFO:         "subfo",
-	SUBFOCC:       "subfo.",
-	ADDICCC:       "addic.",
-	SUBFIC:        "subfic",
-	ADDC:          "addc",
-	ADDCCC:        "addc.",
-	ADDCO:         "addco",
-	ADDCOCC:       "addco.",
-	SUBFC:         "subfc",
-	SUBFCCC:       "subfc.",
-	SUBFCO:        "subfco",
-	SUBFCOCC:      "subfco.",
-	ADDE:          "adde",
-	ADDECC:        "adde.",
-	ADDEO:         "addeo",
-	ADDEOCC:       "addeo.",
-	ADDME:         "addme",
-	ADDMECC:       "addme.",
-	ADDMEO:        "addmeo",
-	ADDMEOCC:      "addmeo.",
-	SUBFE:         "subfe",
-	SUBFECC:       "subfe.",
-	SUBFEO:        "subfeo",
-	SUBFEOCC:      "subfeo.",
-	SUBFME:        "subfme",
-	SUBFMECC:      "subfme.",
-	SUBFMEO:       "subfmeo",
-	SUBFMEOCC:     "subfmeo.",
-	ADDZE:         "addze",
-	ADDZECC:       "addze.",
-	ADDZEO:        "addzeo",
-	ADDZEOCC:      "addzeo.",
-	SUBFZE:        "subfze",
-	SUBFZECC:      "subfze.",
-	SUBFZEO:       "subfzeo",
-	SUBFZEOCC:     "subfzeo.",
-	NEG:           "neg",
-	NEGCC:         "neg.",
-	NEGO:          "nego",
-	NEGOCC:        "nego.",
-	MULLI:         "mulli",
-	MULLW:         "mullw",
-	MULLWCC:       "mullw.",
-	MULLWO:        "mullwo",
-	MULLWOCC:      "mullwo.",
-	MULHW:         "mulhw",
-	MULHWCC:       "mulhw.",
-	MULHWU:        "mulhwu",
-	MULHWUCC:      "mulhwu.",
-	DIVW:          "divw",
-	DIVWCC:        "divw.",
-	DIVWO:         "divwo",
-	DIVWOCC:       "divwo.",
-	DIVWU:         "divwu",
-	DIVWUCC:       "divwu.",
-	DIVWUO:        "divwuo",
-	DIVWUOCC:      "divwuo.",
-	DIVWE:         "divwe",
-	DIVWECC:       "divwe.",
-	DIVWEO:        "divweo",
-	DIVWEOCC:      "divweo.",
-	DIVWEU:        "divweu",
-	DIVWEUCC:      "divweu.",
-	DIVWEUO:       "divweuo",
-	DIVWEUOCC:     "divweuo.",
-	MULLD:         "mulld",
-	MULLDCC:       "mulld.",
-	MULLDO:        "mulldo",
-	MULLDOCC:      "mulldo.",
-	MULHDU:        "mulhdu",
-	MULHDUCC:      "mulhdu.",
-	MULHD:         "mulhd",
-	MULHDCC:       "mulhd.",
-	DIVD:          "divd",
-	DIVDCC:        "divd.",
-	DIVDO:         "divdo",
-	DIVDOCC:       "divdo.",
-	DIVDU:         "divdu",
-	DIVDUCC:       "divdu.",
-	DIVDUO:        "divduo",
-	DIVDUOCC:      "divduo.",
-	DIVDE:         "divde",
-	DIVDECC:       "divde.",
-	DIVDEO:        "divdeo",
-	DIVDEOCC:      "divdeo.",
-	DIVDEU:        "divdeu",
-	DIVDEUCC:      "divdeu.",
-	DIVDEUO:       "divdeuo",
-	DIVDEUOCC:     "divdeuo.",
-	MODSD:         "modsd",
-	MODUD:         "modud",
-	MODSW:         "modsw",
-	MODUW:         "moduw",
-	CMPWI:         "cmpwi",
-	CMPDI:         "cmpdi",
-	CMPW:          "cmpw",
-	CMPD:          "cmpd",
-	CMPLWI:        "cmplwi",
-	CMPLDI:        "cmpldi",
-	CMPLW:         "cmplw",
-	CMPLD:         "cmpld",
-	TWI:           "twi",
-	TW:            "tw",
-	TDI:           "tdi",
-	ISEL:          "isel",
-	TD:            "td",
-	ANDICC:        "andi.",
-	ANDISCC:       "andis.",
-	ORI:           "ori",
-	ORIS:          "oris",
-	XORI:          "xori",
-	XORIS:         "xoris",
-	AND:           "and",
-	ANDCC:         "and.",
-	XOR:           "xor",
-	XORCC:         "xor.",
-	NAND:          "nand",
-	NANDCC:        "nand.",
-	OR:            "or",
-	ORCC:          "or.",
-	NOR:           "nor",
-	NORCC:         "nor.",
-	ANDC:          "andc",
-	ANDCCC:        "andc.",
-	EXTSB:         "extsb",
-	EXTSBCC:       "extsb.",
-	EQV:           "eqv",
-	EQVCC:         "eqv.",
-	ORC:           "orc",
-	ORCCC:         "orc.",
-	EXTSH:         "extsh",
-	EXTSHCC:       "extsh.",
-	CMPB:          "cmpb",
-	POPCNTB:       "popcntb",
-	POPCNTW:       "popcntw",
-	PRTYD:         "prtyd",
-	PRTYW:         "prtyw",
-	EXTSW:         "extsw",
-	EXTSWCC:       "extsw.",
-	CNTLZD:        "cntlzd",
-	CNTLZDCC:      "cntlzd.",
-	POPCNTD:       "popcntd",
-	BPERMD:        "bpermd",
-	RLWINM:        "rlwinm",
-	RLWINMCC:      "rlwinm.",
-	RLWNM:         "rlwnm",
-	RLWNMCC:       "rlwnm.",
-	RLWIMI:        "rlwimi",
-	RLWIMICC:      "rlwimi.",
-	RLDICL:        "rldicl",
-	RLDICLCC:      "rldicl.",
-	RLDICR:        "rldicr",
-	RLDICRCC:      "rldicr.",
-	RLDIC:         "rldic",
-	RLDICCC:       "rldic.",
-	RLDCL:         "rldcl",
-	RLDCLCC:       "rldcl.",
-	RLDCR:         "rldcr",
-	RLDCRCC:       "rldcr.",
-	RLDIMI:        "rldimi",
-	RLDIMICC:      "rldimi.",
-	SLW:           "slw",
-	SLWCC:         "slw.",
-	SRW:           "srw",
-	SRWCC:         "srw.",
-	SRAWI:         "srawi",
-	SRAWICC:       "srawi.",
-	SRAW:          "sraw",
-	SRAWCC:        "sraw.",
-	SLD:           "sld",
-	SLDCC:         "sld.",
-	SRD:           "srd",
-	SRDCC:         "srd.",
-	SRADI:         "sradi",
-	SRADICC:       "sradi.",
-	SRAD:          "srad",
-	SRADCC:        "srad.",
-	CDTBCD:        "cdtbcd",
-	CBCDTD:        "cbcdtd",
-	ADDG6S:        "addg6s",
-	MTSPR:         "mtspr",
-	MFSPR:         "mfspr",
-	MTCRF:         "mtcrf",
-	MFCR:          "mfcr",
-	MTSLE:         "mtsle",
-	MFVSRD:        "mfvsrd",
-	MFVSRWZ:       "mfvsrwz",
-	MTVSRD:        "mtvsrd",
-	MTVSRWA:       "mtvsrwa",
-	MTVSRWZ:       "mtvsrwz",
-	MTOCRF:        "mtocrf",
-	MFOCRF:        "mfocrf",
-	MCRXR:         "mcrxr",
-	MTDCRUX:       "mtdcrux",
-	MFDCRUX:       "mfdcrux",
-	LFS:           "lfs",
-	LFSU:          "lfsu",
-	LFSX:          "lfsx",
-	LFSUX:         "lfsux",
-	LFD:           "lfd",
-	LFDU:          "lfdu",
-	LFDX:          "lfdx",
-	LFDUX:         "lfdux",
-	LFIWAX:        "lfiwax",
-	LFIWZX:        "lfiwzx",
-	STFS:          "stfs",
-	STFSU:         "stfsu",
-	STFSX:         "stfsx",
-	STFSUX:        "stfsux",
-	STFD:          "stfd",
-	STFDU:         "stfdu",
-	STFDX:         "stfdx",
-	STFDUX:        "stfdux",
-	STFIWX:        "stfiwx",
-	LFDP:          "lfdp",
-	LFDPX:         "lfdpx",
-	STFDP:         "stfdp",
-	STFDPX:        "stfdpx",
-	FMR:           "fmr",
-	FMRCC:         "fmr.",
-	FABS:          "fabs",
-	FABSCC:        "fabs.",
-	FNABS:         "fnabs",
-	FNABSCC:       "fnabs.",
-	FNEG:          "fneg",
-	FNEGCC:        "fneg.",
-	FCPSGN:        "fcpsgn",
-	FCPSGNCC:      "fcpsgn.",
-	FMRGEW:        "fmrgew",
-	FMRGOW:        "fmrgow",
-	FADD:          "fadd",
-	FADDCC:        "fadd.",
-	FADDS:         "fadds",
-	FADDSCC:       "fadds.",
-	FSUB:          "fsub",
-	FSUBCC:        "fsub.",
-	FSUBS:         "fsubs",
-	FSUBSCC:       "fsubs.",
-	FMUL:          "fmul",
-	FMULCC:        "fmul.",
-	FMULS:         "fmuls",
-	FMULSCC:       "fmuls.",
-	FDIV:          "fdiv",
-	FDIVCC:        "fdiv.",
-	FDIVS:         "fdivs",
-	FDIVSCC:       "fdivs.",
-	FSQRT:         "fsqrt",
-	FSQRTCC:       "fsqrt.",
-	FSQRTS:        "fsqrts",
-	FSQRTSCC:      "fsqrts.",
-	FRE:           "fre",
-	FRECC:         "fre.",
-	FRES:          "fres",
-	FRESCC:        "fres.",
-	FRSQRTE:       "frsqrte",
-	FRSQRTECC:     "frsqrte.",
-	FRSQRTES:      "frsqrtes",
-	FRSQRTESCC:    "frsqrtes.",
-	FTDIV:         "ftdiv",
-	FTSQRT:        "ftsqrt",
-	FMADD:         "fmadd",
-	FMADDCC:       "fmadd.",
-	FMADDS:        "fmadds",
-	FMADDSCC:      "fmadds.",
-	FMSUB:         "fmsub",
-	FMSUBCC:       "fmsub.",
-	FMSUBS:        "fmsubs",
-	FMSUBSCC:      "fmsubs.",
-	FNMADD:        "fnmadd",
-	FNMADDCC:      "fnmadd.",
-	FNMADDS:       "fnmadds",
-	FNMADDSCC:     "fnmadds.",
-	FNMSUB:        "fnmsub",
-	FNMSUBCC:      "fnmsub.",
-	FNMSUBS:       "fnmsubs",
-	FNMSUBSCC:     "fnmsubs.",
-	FRSP:          "frsp",
-	FRSPCC:        "frsp.",
-	FCTID:         "fctid",
-	FCTIDCC:       "fctid.",
-	FCTIDZ:        "fctidz",
-	FCTIDZCC:      "fctidz.",
-	FCTIDU:        "fctidu",
-	FCTIDUCC:      "fctidu.",
-	FCTIDUZ:       "fctiduz",
-	FCTIDUZCC:     "fctiduz.",
-	FCTIW:         "fctiw",
-	FCTIWCC:       "fctiw.",
-	FCTIWZ:        "fctiwz",
-	FCTIWZCC:      "fctiwz.",
-	FCTIWU:        "fctiwu",
-	FCTIWUCC:      "fctiwu.",
-	FCTIWUZ:       "fctiwuz",
-	FCTIWUZCC:     "fctiwuz.",
-	FCFID:         "fcfid",
-	FCFIDCC:       "fcfid.",
-	FCFIDU:        "fcfidu",
-	FCFIDUCC:      "fcfidu.",
-	FCFIDS:        "fcfids",
-	FCFIDSCC:      "fcfids.",
-	FCFIDUS:       "fcfidus",
-	FCFIDUSCC:     "fcfidus.",
-	FRIN:          "frin",
-	FRINCC:        "frin.",
-	FRIZ:          "friz",
-	FRIZCC:        "friz.",
-	FRIP:          "frip",
-	FRIPCC:        "frip.",
-	FRIM:          "frim",
-	FRIMCC:        "frim.",
-	FCMPU:         "fcmpu",
-	FCMPO:         "fcmpo",
-	FSEL:          "fsel",
-	FSELCC:        "fsel.",
-	MFFS:          "mffs",
-	MFFSCC:        "mffs.",
-	MCRFS:         "mcrfs",
-	MTFSFI:        "mtfsfi",
-	MTFSFICC:      "mtfsfi.",
-	MTFSF:         "mtfsf",
-	MTFSFCC:       "mtfsf.",
-	MTFSB0:        "mtfsb0",
-	MTFSB0CC:      "mtfsb0.",
-	MTFSB1:        "mtfsb1",
-	MTFSB1CC:      "mtfsb1.",
-	LVEBX:         "lvebx",
-	LVEHX:         "lvehx",
-	LVEWX:         "lvewx",
-	LVX:           "lvx",
-	LVXL:          "lvxl",
-	STVEBX:        "stvebx",
-	STVEHX:        "stvehx",
-	STVEWX:        "stvewx",
-	STVX:          "stvx",
-	STVXL:         "stvxl",
-	LVSL:          "lvsl",
-	LVSR:          "lvsr",
-	VPKPX:         "vpkpx",
-	VPKSDSS:       "vpksdss",
-	VPKSDUS:       "vpksdus",
-	VPKSHSS:       "vpkshss",
-	VPKSHUS:       "vpkshus",
-	VPKSWSS:       "vpkswss",
-	VPKSWUS:       "vpkswus",
-	VPKUDUM:       "vpkudum",
-	VPKUDUS:       "vpkudus",
-	VPKUHUM:       "vpkuhum",
-	VPKUHUS:       "vpkuhus",
-	VPKUWUM:       "vpkuwum",
-	VPKUWUS:       "vpkuwus",
-	VUPKHPX:       "vupkhpx",
-	VUPKLPX:       "vupklpx",
-	VUPKHSB:       "vupkhsb",
-	VUPKHSH:       "vupkhsh",
-	VUPKHSW:       "vupkhsw",
-	VUPKLSB:       "vupklsb",
-	VUPKLSH:       "vupklsh",
-	VUPKLSW:       "vupklsw",
-	VMRGHB:        "vmrghb",
-	VMRGHH:        "vmrghh",
-	VMRGLB:        "vmrglb",
-	VMRGLH:        "vmrglh",
-	VMRGHW:        "vmrghw",
-	VMRGLW:        "vmrglw",
-	VMRGEW:        "vmrgew",
-	VMRGOW:        "vmrgow",
-	VSPLTB:        "vspltb",
-	VSPLTH:        "vsplth",
-	VSPLTW:        "vspltw",
-	VSPLTISB:      "vspltisb",
-	VSPLTISH:      "vspltish",
-	VSPLTISW:      "vspltisw",
-	VPERM:         "vperm",
-	VPERMR:        "vpermr",
-	VSEL:          "vsel",
-	VSL:           "vsl",
-	VSLDOI:        "vsldoi",
-	VSLO:          "vslo",
-	VSR:           "vsr",
-	VSRO:          "vsro",
-	VADDCUW:       "vaddcuw",
-	VADDSBS:       "vaddsbs",
-	VADDSHS:       "vaddshs",
-	VADDSWS:       "vaddsws",
-	VADDUBM:       "vaddubm",
-	VADDUDM:       "vaddudm",
-	VADDUHM:       "vadduhm",
-	VADDUWM:       "vadduwm",
-	VADDUBS:       "vaddubs",
-	VADDUHS:       "vadduhs",
-	VADDUWS:       "vadduws",
-	VADDUQM:       "vadduqm",
-	VADDEUQM:      "vaddeuqm",
-	VADDCUQ:       "vaddcuq",
-	VADDECUQ:      "vaddecuq",
-	VSUBCUW:       "vsubcuw",
-	VSUBSBS:       "vsubsbs",
-	VSUBSHS:       "vsubshs",
-	VSUBSWS:       "vsubsws",
-	VSUBUBM:       "vsububm",
-	VSUBUDM:       "vsubudm",
-	VSUBUHM:       "vsubuhm",
-	VSUBUWM:       "vsubuwm",
-	VSUBUBS:       "vsububs",
-	VSUBUHS:       "vsubuhs",
-	VSUBUWS:       "vsubuws",
-	VSUBUQM:       "vsubuqm",
-	VSUBEUQM:      "vsubeuqm",
-	VSUBCUQ:       "vsubcuq",
-	VSUBECUQ:      "vsubecuq",
-	VMULESB:       "vmulesb",
-	VMULEUB:       "vmuleub",
-	VMULOSB:       "vmulosb",
-	VMULOUB:       "vmuloub",
-	VMULESH:       "vmulesh",
-	VMULEUH:       "vmuleuh",
-	VMULOSH:       "vmulosh",
-	VMULOUH:       "vmulouh",
-	VMULESW:       "vmulesw",
-	VMULEUW:       "vmuleuw",
-	VMULOSW:       "vmulosw",
-	VMULOUW:       "vmulouw",
-	VMULUWM:       "vmuluwm",
-	VMHADDSHS:     "vmhaddshs",
-	VMHRADDSHS:    "vmhraddshs",
-	VMLADDUHM:     "vmladduhm",
-	VMSUMUBM:      "vmsumubm",
-	VMSUMMBM:      "vmsummbm",
-	VMSUMSHM:      "vmsumshm",
-	VMSUMSHS:      "vmsumshs",
-	VMSUMUHM:      "vmsumuhm",
-	VMSUMUHS:      "vmsumuhs",
-	VMSUMUDM:      "vmsumudm",
-	VSUMSWS:       "vsumsws",
-	VSUM2SWS:      "vsum2sws",
-	VSUM4SBS:      "vsum4sbs",
-	VSUM4SHS:      "vsum4shs",
-	VSUM4UBS:      "vsum4ubs",
-	VAVGSB:        "vavgsb",
-	VAVGSH:        "vavgsh",
-	VAVGSW:        "vavgsw",
-	VAVGUB:        "vavgub",
-	VAVGUW:        "vavguw",
-	VAVGUH:        "vavguh",
-	VMAXSB:        "vmaxsb",
-	VMAXSD:        "vmaxsd",
-	VMAXUB:        "vmaxub",
-	VMAXUD:        "vmaxud",
-	VMAXSH:        "vmaxsh",
-	VMAXSW:        "vmaxsw",
-	VMAXUH:        "vmaxuh",
-	VMAXUW:        "vmaxuw",
-	VMINSB:        "vminsb",
-	VMINSD:        "vminsd",
-	VMINUB:        "vminub",
-	VMINUD:        "vminud",
-	VMINSH:        "vminsh",
-	VMINSW:        "vminsw",
-	VMINUH:        "vminuh",
-	VMINUW:        "vminuw",
-	VCMPEQUB:      "vcmpequb",
-	VCMPEQUBCC:    "vcmpequb.",
-	VCMPEQUH:      "vcmpequh",
-	VCMPEQUHCC:    "vcmpequh.",
-	VCMPEQUW:      "vcmpequw",
-	VCMPEQUWCC:    "vcmpequw.",
-	VCMPEQUD:      "vcmpequd",
-	VCMPEQUDCC:    "vcmpequd.",
-	VCMPNEB:       "vcmpneb",
-	VCMPNEBCC:     "vcmpneb.",
-	VCMPNEZB:      "vcmpnezb",
-	VCMPNEZBCC:    "vcmpnezb.",
-	VCMPNEH:       "vcmpneh",
-	VCMPNEHCC:     "vcmpneh.",
-	VCMPNEZH:      "vcmpnezh",
-	VCMPNEZHCC:    "vcmpnezh.",
-	VCMPNEW:       "vcmpnew",
-	VCMPNEWCC:     "vcmpnew.",
-	VCMPNEZW:      "vcmpnezw",
-	VCMPNEZWCC:    "vcmpnezw.",
-	VCMPGTSB:      "vcmpgtsb",
-	VCMPGTSBCC:    "vcmpgtsb.",
-	VCMPGTSD:      "vcmpgtsd",
-	VCMPGTSDCC:    "vcmpgtsd.",
-	VCMPGTSH:      "vcmpgtsh",
-	VCMPGTSHCC:    "vcmpgtsh.",
-	VCMPGTSW:      "vcmpgtsw",
-	VCMPGTSWCC:    "vcmpgtsw.",
-	VCMPGTUB:      "vcmpgtub",
-	VCMPGTUBCC:    "vcmpgtub.",
-	VCMPGTUD:      "vcmpgtud",
-	VCMPGTUDCC:    "vcmpgtud.",
-	VCMPGTUH:      "vcmpgtuh",
-	VCMPGTUHCC:    "vcmpgtuh.",
-	VCMPGTUW:      "vcmpgtuw",
-	VCMPGTUWCC:    "vcmpgtuw.",
-	VAND:          "vand",
-	VANDC:         "vandc",
-	VEQV:          "veqv",
-	VNAND:         "vnand",
-	VORC:          "vorc",
-	VNOR:          "vnor",
-	VOR:           "vor",
-	VXOR:          "vxor",
-	VRLB:          "vrlb",
-	VRLH:          "vrlh",
-	VRLW:          "vrlw",
-	VRLD:          "vrld",
-	VSLB:          "vslb",
-	VSLH:          "vslh",
-	VSLW:          "vslw",
-	VSLD:          "vsld",
-	VSRB:          "vsrb",
-	VSRH:          "vsrh",
-	VSRW:          "vsrw",
-	VSRD:          "vsrd",
-	VSRAB:         "vsrab",
-	VSRAH:         "vsrah",
-	VSRAW:         "vsraw",
-	VSRAD:         "vsrad",
-	VADDFP:        "vaddfp",
-	VSUBFP:        "vsubfp",
-	VMADDFP:       "vmaddfp",
-	VNMSUBFP:      "vnmsubfp",
-	VMAXFP:        "vmaxfp",
-	VMINFP:        "vminfp",
-	VCTSXS:        "vctsxs",
-	VCTUXS:        "vctuxs",
-	VCFSX:         "vcfsx",
-	VCFUX:         "vcfux",
-	VRFIM:         "vrfim",
-	VRFIN:         "vrfin",
-	VRFIP:         "vrfip",
-	VRFIZ:         "vrfiz",
-	VCMPBFP:       "vcmpbfp",
-	VCMPBFPCC:     "vcmpbfp.",
-	VCMPEQFP:      "vcmpeqfp",
-	VCMPEQFPCC:    "vcmpeqfp.",
-	VCMPGEFP:      "vcmpgefp",
-	VCMPGEFPCC:    "vcmpgefp.",
-	VCMPGTFP:      "vcmpgtfp",
-	VCMPGTFPCC:    "vcmpgtfp.",
-	VEXPTEFP:      "vexptefp",
-	VLOGEFP:       "vlogefp",
-	VREFP:         "vrefp",
-	VRSQRTEFP:     "vrsqrtefp",
-	VCIPHER:       "vcipher",
-	VCIPHERLAST:   "vcipherlast",
-	VNCIPHER:      "vncipher",
-	VNCIPHERLAST:  "vncipherlast",
-	VSBOX:         "vsbox",
-	VSHASIGMAD:    "vshasigmad",
-	VSHASIGMAW:    "vshasigmaw",
-	VPMSUMB:       "vpmsumb",
-	VPMSUMD:       "vpmsumd",
-	VPMSUMH:       "vpmsumh",
-	VPMSUMW:       "vpmsumw",
-	VPERMXOR:      "vpermxor",
-	VGBBD:         "vgbbd",
-	VCLZB:         "vclzb",
-	VCLZH:         "vclzh",
-	VCLZW:         "vclzw",
-	VCLZD:         "vclzd",
-	VPOPCNTB:      "vpopcntb",
-	VPOPCNTD:      "vpopcntd",
-	VPOPCNTH:      "vpopcnth",
-	VPOPCNTW:      "vpopcntw",
-	VBPERMQ:       "vbpermq",
-	VBPERMD:       "vbpermd",
-	BCDADDCC:      "bcdadd.",
-	BCDSUBCC:      "bcdsub.",
-	MTVSCR:        "mtvscr",
-	MFVSCR:        "mfvscr",
-	DADD:          "dadd",
-	DADDCC:        "dadd.",
-	DSUB:          "dsub",
-	DSUBCC:        "dsub.",
-	DMUL:          "dmul",
-	DMULCC:        "dmul.",
-	DDIV:          "ddiv",
-	DDIVCC:        "ddiv.",
-	DCMPU:         "dcmpu",
-	DCMPO:         "dcmpo",
-	DTSTDC:        "dtstdc",
-	DTSTDG:        "dtstdg",
-	DTSTEX:        "dtstex",
-	DTSTSF:        "dtstsf",
-	DQUAI:         "dquai",
-	DQUAICC:       "dquai.",
-	DQUA:          "dqua",
-	DQUACC:        "dqua.",
-	DRRND:         "drrnd",
-	DRRNDCC:       "drrnd.",
-	DRINTX:        "drintx",
-	DRINTXCC:      "drintx.",
-	DRINTN:        "drintn",
-	DRINTNCC:      "drintn.",
-	DCTDP:         "dctdp",
-	DCTDPCC:       "dctdp.",
-	DCTQPQ:        "dctqpq",
-	DCTQPQCC:      "dctqpq.",
-	DRSP:          "drsp",
-	DRSPCC:        "drsp.",
-	DRDPQ:         "drdpq",
-	DRDPQCC:       "drdpq.",
-	DCFFIX:        "dcffix",
-	DCFFIXCC:      "dcffix.",
-	DCFFIXQ:       "dcffixq",
-	DCFFIXQCC:     "dcffixq.",
-	DCTFIX:        "dctfix",
-	DCTFIXCC:      "dctfix.",
-	DDEDPD:        "ddedpd",
-	DDEDPDCC:      "ddedpd.",
-	DENBCD:        "denbcd",
-	DENBCDCC:      "denbcd.",
-	DXEX:          "dxex",
-	DXEXCC:        "dxex.",
-	DIEX:          "diex",
-	DIEXCC:        "diex.",
-	DSCLI:         "dscli",
-	DSCLICC:       "dscli.",
-	DSCRI:         "dscri",
-	DSCRICC:       "dscri.",
-	LXSDX:         "lxsdx",
-	LXSIWAX:       "lxsiwax",
-	LXSIWZX:       "lxsiwzx",
-	LXSSPX:        "lxsspx",
-	LXVD2X:        "lxvd2x",
-	LXVDSX:        "lxvdsx",
-	LXVW4X:        "lxvw4x",
-	LXVH8X:        "lxvh8x",
-	LXVB16X:       "lxvb16x",
-	LXV:           "lxv",
-	LXVL:          "lxvl",
-	LXVLL:         "lxvll",
-	LXVX:          "lxvx",
-	STXSDX:        "stxsdx",
-	STXSIWX:       "stxsiwx",
-	STXSSPX:       "stxsspx",
-	STXVD2X:       "stxvd2x",
-	STXVW4X:       "stxvw4x",
-	STXVH8X:       "stxvh8x",
-	STXVB16X:      "stxvb16x",
-	STXV:          "stxv",
-	STXVL:         "stxvl",
-	STXVLL:        "stxvll",
-	STXVX:         "stxvx",
-	XSABSDP:       "xsabsdp",
-	XSADDDP:       "xsadddp",
-	XSADDSP:       "xsaddsp",
-	XSCMPODP:      "xscmpodp",
-	XSCMPUDP:      "xscmpudp",
-	XSCPSGNDP:     "xscpsgndp",
-	XSCVDPSP:      "xscvdpsp",
-	XSCVDPSPN:     "xscvdpspn",
-	XSCVDPSXDS:    "xscvdpsxds",
-	XSCVDPSXWS:    "xscvdpsxws",
-	XSCVDPUXDS:    "xscvdpuxds",
-	XSCVDPUXWS:    "xscvdpuxws",
-	XSCVSPDP:      "xscvspdp",
-	XSCVSPDPN:     "xscvspdpn",
-	XSCVSXDDP:     "xscvsxddp",
-	XSCVSXDSP:     "xscvsxdsp",
-	XSCVUXDDP:     "xscvuxddp",
-	XSCVUXDSP:     "xscvuxdsp",
-	XSDIVDP:       "xsdivdp",
-	XSDIVSP:       "xsdivsp",
-	XSMADDADP:     "xsmaddadp",
-	XSMADDASP:     "xsmaddasp",
-	XSMAXDP:       "xsmaxdp",
-	XSMINDP:       "xsmindp",
-	XSMSUBADP:     "xsmsubadp",
-	XSMSUBASP:     "xsmsubasp",
-	XSMULDP:       "xsmuldp",
-	XSMULSP:       "xsmulsp",
-	XSNABSDP:      "xsnabsdp",
-	XSNEGDP:       "xsnegdp",
-	XSNMADDADP:    "xsnmaddadp",
-	XSNMADDASP:    "xsnmaddasp",
-	XSNMSUBADP:    "xsnmsubadp",
-	XSNMSUBASP:    "xsnmsubasp",
-	XSRDPI:        "xsrdpi",
-	XSRDPIC:       "xsrdpic",
-	XSRDPIM:       "xsrdpim",
-	XSRDPIP:       "xsrdpip",
-	XSRDPIZ:       "xsrdpiz",
-	XSREDP:        "xsredp",
-	XSRESP:        "xsresp",
-	XSRSP:         "xsrsp",
-	XSRSQRTEDP:    "xsrsqrtedp",
-	XSRSQRTESP:    "xsrsqrtesp",
-	XSSQRTDP:      "xssqrtdp",
-	XSSQRTSP:      "xssqrtsp",
-	XSSUBDP:       "xssubdp",
-	XSSUBSP:       "xssubsp",
-	XSTDIVDP:      "xstdivdp",
-	XSTSQRTDP:     "xstsqrtdp",
-	XVABSDP:       "xvabsdp",
-	XVABSSP:       "xvabssp",
-	XVADDDP:       "xvadddp",
-	XVADDSP:       "xvaddsp",
-	XVCMPEQDP:     "xvcmpeqdp",
-	XVCMPEQDPCC:   "xvcmpeqdp.",
-	XVCMPEQSP:     "xvcmpeqsp",
-	XVCMPEQSPCC:   "xvcmpeqsp.",
-	XVCMPGEDP:     "xvcmpgedp",
-	XVCMPGEDPCC:   "xvcmpgedp.",
-	XVCMPGESP:     "xvcmpgesp",
-	XVCMPGESPCC:   "xvcmpgesp.",
-	XVCMPGTDP:     "xvcmpgtdp",
-	XVCMPGTDPCC:   "xvcmpgtdp.",
-	XVCMPGTSP:     "xvcmpgtsp",
-	XVCMPGTSPCC:   "xvcmpgtsp.",
-	XVCPSGNDP:     "xvcpsgndp",
-	XVCPSGNSP:     "xvcpsgnsp",
-	XVCVDPSP:      "xvcvdpsp",
-	XVCVDPSXDS:    "xvcvdpsxds",
-	XVCVDPSXWS:    "xvcvdpsxws",
-	XVCVDPUXDS:    "xvcvdpuxds",
-	XVCVDPUXWS:    "xvcvdpuxws",
-	XVCVSPDP:      "xvcvspdp",
-	XVCVSPSXDS:    "xvcvspsxds",
-	XVCVSPSXWS:    "xvcvspsxws",
-	XVCVSPUXDS:    "xvcvspuxds",
-	XVCVSPUXWS:    "xvcvspuxws",
-	XVCVSXDDP:     "xvcvsxddp",
-	XVCVSXDSP:     "xvcvsxdsp",
-	XVCVSXWDP:     "xvcvsxwdp",
-	XVCVSXWSP:     "xvcvsxwsp",
-	XVCVUXDDP:     "xvcvuxddp",
-	XVCVUXDSP:     "xvcvuxdsp",
-	XVCVUXWDP:     "xvcvuxwdp",
-	XVCVUXWSP:     "xvcvuxwsp",
-	XVDIVDP:       "xvdivdp",
-	XVDIVSP:       "xvdivsp",
-	XVMADDADP:     "xvmaddadp",
-	XVMADDASP:     "xvmaddasp",
-	XVMAXDP:       "xvmaxdp",
-	XVMAXSP:       "xvmaxsp",
-	XVMINDP:       "xvmindp",
-	XVMINSP:       "xvminsp",
-	XVMSUBADP:     "xvmsubadp",
-	XVMSUBASP:     "xvmsubasp",
-	XVMULDP:       "xvmuldp",
-	XVMULSP:       "xvmulsp",
-	XVNABSDP:      "xvnabsdp",
-	XVNABSSP:      "xvnabssp",
-	XVNEGDP:       "xvnegdp",
-	XVNEGSP:       "xvnegsp",
-	XVNMADDADP:    "xvnmaddadp",
-	XVNMADDASP:    "xvnmaddasp",
-	XVNMSUBADP:    "xvnmsubadp",
-	XVNMSUBASP:    "xvnmsubasp",
-	XVRDPI:        "xvrdpi",
-	XVRDPIC:       "xvrdpic",
-	XVRDPIM:       "xvrdpim",
-	XVRDPIP:       "xvrdpip",
-	XVRDPIZ:       "xvrdpiz",
-	XVREDP:        "xvredp",
-	XVRESP:        "xvresp",
-	XVRSPI:        "xvrspi",
-	XVRSPIC:       "xvrspic",
-	XVRSPIM:       "xvrspim",
-	XVRSPIP:       "xvrspip",
-	XVRSPIZ:       "xvrspiz",
-	XVRSQRTEDP:    "xvrsqrtedp",
-	XVRSQRTESP:    "xvrsqrtesp",
-	XVSQRTDP:      "xvsqrtdp",
-	XVSQRTSP:      "xvsqrtsp",
-	XVSUBDP:       "xvsubdp",
-	XVSUBSP:       "xvsubsp",
-	XVTDIVDP:      "xvtdivdp",
-	XVTDIVSP:      "xvtdivsp",
-	XVTSQRTDP:     "xvtsqrtdp",
-	XVTSQRTSP:     "xvtsqrtsp",
-	XXLAND:        "xxland",
-	XXLANDC:       "xxlandc",
-	XXLEQV:        "xxleqv",
-	XXLNAND:       "xxlnand",
-	XXLORC:        "xxlorc",
-	XXLNOR:        "xxlnor",
-	XXLOR:         "xxlor",
-	XXLXOR:        "xxlxor",
-	XXMRGHW:       "xxmrghw",
-	XXMRGLW:       "xxmrglw",
-	XXPERMDI:      "xxpermdi",
-	XXPERM:        "xxperm",
-	XXSEL:         "xxsel",
-	XXSLDWI:       "xxsldwi",
-	XXSPLTW:       "xxspltw",
-	XXBRD:         "xxbrd",
-	XXBRW:         "xxbrw",
-	XXBRH:         "xxbrh",
-	BRINC:         "brinc",
-	EVABS:         "evabs",
-	EVADDIW:       "evaddiw",
-	EVADDSMIAAW:   "evaddsmiaaw",
-	EVADDSSIAAW:   "evaddssiaaw",
-	EVADDUMIAAW:   "evaddumiaaw",
-	EVADDUSIAAW:   "evaddusiaaw",
-	EVADDW:        "evaddw",
-	EVAND:         "evand",
-	EVCMPEQ:       "evcmpeq",
-	EVANDC:        "evandc",
-	EVCMPGTS:      "evcmpgts",
-	EVCMPGTU:      "evcmpgtu",
-	EVCMPLTU:      "evcmpltu",
-	EVCMPLTS:      "evcmplts",
-	EVCNTLSW:      "evcntlsw",
-	EVCNTLZW:      "evcntlzw",
-	EVDIVWS:       "evdivws",
-	EVDIVWU:       "evdivwu",
-	EVEQV:         "eveqv",
-	EVEXTSB:       "evextsb",
-	EVEXTSH:       "evextsh",
-	EVLDD:         "evldd",
-	EVLDH:         "evldh",
-	EVLDDX:        "evlddx",
-	EVLDHX:        "evldhx",
-	EVLDW:         "evldw",
-	EVLHHESPLAT:   "evlhhesplat",
-	EVLDWX:        "evldwx",
-	EVLHHESPLATX:  "evlhhesplatx",
-	EVLHHOSSPLAT:  "evlhhossplat",
-	EVLHHOUSPLAT:  "evlhhousplat",
-	EVLHHOSSPLATX: "evlhhossplatx",
-	EVLHHOUSPLATX: "evlhhousplatx",
-	EVLWHE:        "evlwhe",
-	EVLWHOS:       "evlwhos",
-	EVLWHEX:       "evlwhex",
-	EVLWHOSX:      "evlwhosx",
-	EVLWHOU:       "evlwhou",
-	EVLWHSPLAT:    "evlwhsplat",
-	EVLWHOUX:      "evlwhoux",
-	EVLWHSPLATX:   "evlwhsplatx",
-	EVLWWSPLAT:    "evlwwsplat",
-	EVMERGEHI:     "evmergehi",
-	EVLWWSPLATX:   "evlwwsplatx",
-	EVMERGELO:     "evmergelo",
-	EVMERGEHILO:   "evmergehilo",
-	EVMHEGSMFAA:   "evmhegsmfaa",
-	EVMERGELOHI:   "evmergelohi",
-	EVMHEGSMFAN:   "evmhegsmfan",
-	EVMHEGSMIAA:   "evmhegsmiaa",
-	EVMHEGUMIAA:   "evmhegumiaa",
-	EVMHEGSMIAN:   "evmhegsmian",
-	EVMHEGUMIAN:   "evmhegumian",
-	EVMHESMF:      "evmhesmf",
-	EVMHESMFAAW:   "evmhesmfaaw",
-	EVMHESMFA:     "evmhesmfa",
-	EVMHESMFANW:   "evmhesmfanw",
-	EVMHESMI:      "evmhesmi",
-	EVMHESMIAAW:   "evmhesmiaaw",
-	EVMHESMIA:     "evmhesmia",
-	EVMHESMIANW:   "evmhesmianw",
-	EVMHESSF:      "evmhessf",
-	EVMHESSFA:     "evmhessfa",
-	EVMHESSFAAW:   "evmhessfaaw",
-	EVMHESSFANW:   "evmhessfanw",
-	EVMHESSIAAW:   "evmhessiaaw",
-	EVMHESSIANW:   "evmhessianw",
-	EVMHEUMI:      "evmheumi",
-	EVMHEUMIAAW:   "evmheumiaaw",
-	EVMHEUMIA:     "evmheumia",
-	EVMHEUMIANW:   "evmheumianw",
-	EVMHEUSIAAW:   "evmheusiaaw",
-	EVMHEUSIANW:   "evmheusianw",
-	EVMHOGSMFAA:   "evmhogsmfaa",
-	EVMHOGSMIAA:   "evmhogsmiaa",
-	EVMHOGSMFAN:   "evmhogsmfan",
-	EVMHOGSMIAN:   "evmhogsmian",
-	EVMHOGUMIAA:   "evmhogumiaa",
-	EVMHOSMF:      "evmhosmf",
-	EVMHOGUMIAN:   "evmhogumian",
-	EVMHOSMFA:     "evmhosmfa",
-	EVMHOSMFAAW:   "evmhosmfaaw",
-	EVMHOSMI:      "evmhosmi",
-	EVMHOSMFANW:   "evmhosmfanw",
-	EVMHOSMIA:     "evmhosmia",
-	EVMHOSMIAAW:   "evmhosmiaaw",
-	EVMHOSMIANW:   "evmhosmianw",
-	EVMHOSSF:      "evmhossf",
-	EVMHOSSFA:     "evmhossfa",
-	EVMHOSSFAAW:   "evmhossfaaw",
-	EVMHOSSFANW:   "evmhossfanw",
-	EVMHOSSIAAW:   "evmhossiaaw",
-	EVMHOUMI:      "evmhoumi",
-	EVMHOSSIANW:   "evmhossianw",
-	EVMHOUMIA:     "evmhoumia",
-	EVMHOUMIAAW:   "evmhoumiaaw",
-	EVMHOUSIAAW:   "evmhousiaaw",
-	EVMHOUMIANW:   "evmhoumianw",
-	EVMHOUSIANW:   "evmhousianw",
-	EVMRA:         "evmra",
-	EVMWHSMF:      "evmwhsmf",
-	EVMWHSMI:      "evmwhsmi",
-	EVMWHSMFA:     "evmwhsmfa",
-	EVMWHSMIA:     "evmwhsmia",
-	EVMWHSSF:      "evmwhssf",
-	EVMWHUMI:      "evmwhumi",
-	EVMWHSSFA:     "evmwhssfa",
-	EVMWHUMIA:     "evmwhumia",
-	EVMWLSMIAAW:   "evmwlsmiaaw",
-	EVMWLSSIAAW:   "evmwlssiaaw",
-	EVMWLSMIANW:   "evmwlsmianw",
-	EVMWLSSIANW:   "evmwlssianw",
-	EVMWLUMI:      "evmwlumi",
-	EVMWLUMIAAW:   "evmwlumiaaw",
-	EVMWLUMIA:     "evmwlumia",
-	EVMWLUMIANW:   "evmwlumianw",
-	EVMWLUSIAAW:   "evmwlusiaaw",
-	EVMWSMF:       "evmwsmf",
-	EVMWLUSIANW:   "evmwlusianw",
-	EVMWSMFA:      "evmwsmfa",
-	EVMWSMFAA:     "evmwsmfaa",
-	EVMWSMI:       "evmwsmi",
-	EVMWSMIAA:     "evmwsmiaa",
-	EVMWSMFAN:     "evmwsmfan",
-	EVMWSMIA:      "evmwsmia",
-	EVMWSMIAN:     "evmwsmian",
-	EVMWSSF:       "evmwssf",
-	EVMWSSFA:      "evmwssfa",
-	EVMWSSFAA:     "evmwssfaa",
-	EVMWUMI:       "evmwumi",
-	EVMWSSFAN:     "evmwssfan",
-	EVMWUMIA:      "evmwumia",
-	EVMWUMIAA:     "evmwumiaa",
-	EVNAND:        "evnand",
-	EVMWUMIAN:     "evmwumian",
-	EVNEG:         "evneg",
-	EVNOR:         "evnor",
-	EVORC:         "evorc",
-	EVOR:          "evor",
-	EVRLW:         "evrlw",
-	EVRLWI:        "evrlwi",
-	EVSEL:         "evsel",
-	EVRNDW:        "evrndw",
-	EVSLW:         "evslw",
-	EVSPLATFI:     "evsplatfi",
-	EVSRWIS:       "evsrwis",
-	EVSLWI:        "evslwi",
-	EVSPLATI:      "evsplati",
-	EVSRWIU:       "evsrwiu",
-	EVSRWS:        "evsrws",
-	EVSTDD:        "evstdd",
-	EVSRWU:        "evsrwu",
-	EVSTDDX:       "evstddx",
-	EVSTDH:        "evstdh",
-	EVSTDW:        "evstdw",
-	EVSTDHX:       "evstdhx",
-	EVSTDWX:       "evstdwx",
-	EVSTWHE:       "evstwhe",
-	EVSTWHO:       "evstwho",
-	EVSTWWE:       "evstwwe",
-	EVSTWHEX:      "evstwhex",
-	EVSTWHOX:      "evstwhox",
-	EVSTWWEX:      "evstwwex",
-	EVSTWWO:       "evstwwo",
-	EVSUBFSMIAAW:  "evsubfsmiaaw",
-	EVSTWWOX:      "evstwwox",
-	EVSUBFSSIAAW:  "evsubfssiaaw",
-	EVSUBFUMIAAW:  "evsubfumiaaw",
-	EVSUBFUSIAAW:  "evsubfusiaaw",
-	EVSUBFW:       "evsubfw",
-	EVSUBIFW:      "evsubifw",
-	EVXOR:         "evxor",
-	EVFSABS:       "evfsabs",
-	EVFSNABS:      "evfsnabs",
-	EVFSNEG:       "evfsneg",
-	EVFSADD:       "evfsadd",
-	EVFSMUL:       "evfsmul",
-	EVFSSUB:       "evfssub",
-	EVFSDIV:       "evfsdiv",
-	EVFSCMPGT:     "evfscmpgt",
-	EVFSCMPLT:     "evfscmplt",
-	EVFSCMPEQ:     "evfscmpeq",
-	EVFSTSTGT:     "evfststgt",
-	EVFSTSTLT:     "evfststlt",
-	EVFSTSTEQ:     "evfststeq",
-	EVFSCFSI:      "evfscfsi",
-	EVFSCFSF:      "evfscfsf",
-	EVFSCFUI:      "evfscfui",
-	EVFSCFUF:      "evfscfuf",
-	EVFSCTSI:      "evfsctsi",
-	EVFSCTUI:      "evfsctui",
-	EVFSCTSIZ:     "evfsctsiz",
-	EVFSCTUIZ:     "evfsctuiz",
-	EVFSCTSF:      "evfsctsf",
-	EVFSCTUF:      "evfsctuf",
-	EFSABS:        "efsabs",
-	EFSNEG:        "efsneg",
-	EFSNABS:       "efsnabs",
-	EFSADD:        "efsadd",
-	EFSMUL:        "efsmul",
-	EFSSUB:        "efssub",
-	EFSDIV:        "efsdiv",
-	EFSCMPGT:      "efscmpgt",
-	EFSCMPLT:      "efscmplt",
-	EFSCMPEQ:      "efscmpeq",
-	EFSTSTGT:      "efststgt",
-	EFSTSTLT:      "efststlt",
-	EFSTSTEQ:      "efststeq",
-	EFSCFSI:       "efscfsi",
-	EFSCFSF:       "efscfsf",
-	EFSCTSI:       "efsctsi",
-	EFSCFUI:       "efscfui",
-	EFSCFUF:       "efscfuf",
-	EFSCTUI:       "efsctui",
-	EFSCTSIZ:      "efsctsiz",
-	EFSCTSF:       "efsctsf",
-	EFSCTUIZ:      "efsctuiz",
-	EFSCTUF:       "efsctuf",
-	EFDABS:        "efdabs",
-	EFDNEG:        "efdneg",
-	EFDNABS:       "efdnabs",
-	EFDADD:        "efdadd",
-	EFDMUL:        "efdmul",
-	EFDSUB:        "efdsub",
-	EFDDIV:        "efddiv",
-	EFDCMPGT:      "efdcmpgt",
-	EFDCMPEQ:      "efdcmpeq",
-	EFDCMPLT:      "efdcmplt",
-	EFDTSTGT:      "efdtstgt",
-	EFDTSTLT:      "efdtstlt",
-	EFDCFSI:       "efdcfsi",
-	EFDTSTEQ:      "efdtsteq",
-	EFDCFUI:       "efdcfui",
-	EFDCFSID:      "efdcfsid",
-	EFDCFSF:       "efdcfsf",
-	EFDCFUF:       "efdcfuf",
-	EFDCFUID:      "efdcfuid",
-	EFDCTSI:       "efdctsi",
-	EFDCTUI:       "efdctui",
-	EFDCTSIDZ:     "efdctsidz",
-	EFDCTUIDZ:     "efdctuidz",
-	EFDCTSIZ:      "efdctsiz",
-	EFDCTSF:       "efdctsf",
-	EFDCTUF:       "efdctuf",
-	EFDCTUIZ:      "efdctuiz",
-	EFDCFS:        "efdcfs",
-	EFSCFD:        "efscfd",
-	DLMZB:         "dlmzb",
-	DLMZBCC:       "dlmzb.",
-	MACCHW:        "macchw",
-	MACCHWCC:      "macchw.",
-	MACCHWO:       "macchwo",
-	MACCHWOCC:     "macchwo.",
-	MACCHWS:       "macchws",
-	MACCHWSCC:     "macchws.",
-	MACCHWSO:      "macchwso",
-	MACCHWSOCC:    "macchwso.",
-	MACCHWU:       "macchwu",
-	MACCHWUCC:     "macchwu.",
-	MACCHWUO:      "macchwuo",
-	MACCHWUOCC:    "macchwuo.",
-	MACCHWSU:      "macchwsu",
-	MACCHWSUCC:    "macchwsu.",
-	MACCHWSUO:     "macchwsuo",
-	MACCHWSUOCC:   "macchwsuo.",
-	MACHHW:        "machhw",
-	MACHHWCC:      "machhw.",
-	MACHHWO:       "machhwo",
-	MACHHWOCC:     "machhwo.",
-	MACHHWS:       "machhws",
-	MACHHWSCC:     "machhws.",
-	MACHHWSO:      "machhwso",
-	MACHHWSOCC:    "machhwso.",
-	MACHHWU:       "machhwu",
-	MACHHWUCC:     "machhwu.",
-	MACHHWUO:      "machhwuo",
-	MACHHWUOCC:    "machhwuo.",
-	MACHHWSU:      "machhwsu",
-	MACHHWSUCC:    "machhwsu.",
-	MACHHWSUO:     "machhwsuo",
-	MACHHWSUOCC:   "machhwsuo.",
-	MACLHW:        "maclhw",
-	MACLHWCC:      "maclhw.",
-	MACLHWO:       "maclhwo",
-	MACLHWOCC:     "maclhwo.",
-	MACLHWS:       "maclhws",
-	MACLHWSCC:     "maclhws.",
-	MACLHWSO:      "maclhwso",
-	MACLHWSOCC:    "maclhwso.",
-	MACLHWU:       "maclhwu",
-	MACLHWUCC:     "maclhwu.",
-	MACLHWUO:      "maclhwuo",
-	MACLHWUOCC:    "maclhwuo.",
-	MULCHW:        "mulchw",
-	MULCHWCC:      "mulchw.",
-	MACLHWSU:      "maclhwsu",
-	MACLHWSUCC:    "maclhwsu.",
-	MACLHWSUO:     "maclhwsuo",
-	MACLHWSUOCC:   "maclhwsuo.",
-	MULCHWU:       "mulchwu",
-	MULCHWUCC:     "mulchwu.",
-	MULHHW:        "mulhhw",
-	MULHHWCC:      "mulhhw.",
-	MULLHW:        "mullhw",
-	MULLHWCC:      "mullhw.",
-	MULHHWU:       "mulhhwu",
-	MULHHWUCC:     "mulhhwu.",
-	MULLHWU:       "mullhwu",
-	MULLHWUCC:     "mullhwu.",
-	NMACCHW:       "nmacchw",
-	NMACCHWCC:     "nmacchw.",
-	NMACCHWO:      "nmacchwo",
-	NMACCHWOCC:    "nmacchwo.",
-	NMACCHWS:      "nmacchws",
-	NMACCHWSCC:    "nmacchws.",
-	NMACCHWSO:     "nmacchwso",
-	NMACCHWSOCC:   "nmacchwso.",
-	NMACHHW:       "nmachhw",
-	NMACHHWCC:     "nmachhw.",
-	NMACHHWO:      "nmachhwo",
-	NMACHHWOCC:    "nmachhwo.",
-	NMACHHWS:      "nmachhws",
-	NMACHHWSCC:    "nmachhws.",
-	NMACHHWSO:     "nmachhwso",
-	NMACHHWSOCC:   "nmachhwso.",
-	NMACLHW:       "nmaclhw",
-	NMACLHWCC:     "nmaclhw.",
-	NMACLHWO:      "nmaclhwo",
-	NMACLHWOCC:    "nmaclhwo.",
-	NMACLHWS:      "nmaclhws",
-	NMACLHWSCC:    "nmaclhws.",
-	NMACLHWSO:     "nmaclhwso",
-	NMACLHWSOCC:   "nmaclhwso.",
-	ICBI:          "icbi",
-	ICBT:          "icbt",
-	DCBA:          "dcba",
-	DCBT:          "dcbt",
-	DCBTST:        "dcbtst",
-	DCBZ:          "dcbz",
-	DCBST:         "dcbst",
-	DCBF:          "dcbf",
-	ISYNC:         "isync",
-	LBARX:         "lbarx",
-	LHARX:         "lharx",
-	LWARX:         "lwarx",
-	STBCXCC:       "stbcx.",
-	STHCXCC:       "sthcx.",
-	STWCXCC:       "stwcx.",
-	LDARX:         "ldarx",
-	STDCXCC:       "stdcx.",
-	LQARX:         "lqarx",
-	STQCXCC:       "stqcx.",
-	SYNC:          "sync",
-	EIEIO:         "eieio",
-	MBAR:          "mbar",
-	WAIT:          "wait",
-	TBEGINCC:      "tbegin.",
-	TENDCC:        "tend.",
-	TABORTCC:      "tabort.",
-	TABORTWCCC:    "tabortwc.",
-	TABORTWCICC:   "tabortwci.",
-	TABORTDCCC:    "tabortdc.",
-	TABORTDCICC:   "tabortdci.",
-	TSRCC:         "tsr.",
-	TCHECK:        "tcheck",
-	MFTB:          "mftb",
-	RFEBB:         "rfebb",
-	LBDX:          "lbdx",
-	LHDX:          "lhdx",
-	LWDX:          "lwdx",
-	LDDX:          "lddx",
-	LFDDX:         "lfddx",
-	STBDX:         "stbdx",
-	STHDX:         "sthdx",
-	STWDX:         "stwdx",
-	STDDX:         "stddx",
-	STFDDX:        "stfddx",
-	DSN:           "dsn",
-	ECIWX:         "eciwx",
-	ECOWX:         "ecowx",
-	RFID:          "rfid",
-	HRFID:         "hrfid",
-	DOZE:          "doze",
-	NAP:           "nap",
-	SLEEP:         "sleep",
-	RVWINKLE:      "rvwinkle",
-	LBZCIX:        "lbzcix",
-	LWZCIX:        "lwzcix",
-	LHZCIX:        "lhzcix",
-	LDCIX:         "ldcix",
-	STBCIX:        "stbcix",
-	STWCIX:        "stwcix",
-	STHCIX:        "sthcix",
-	STDCIX:        "stdcix",
-	TRECLAIMCC:    "treclaim.",
-	TRECHKPTCC:    "trechkpt.",
-	MTMSR:         "mtmsr",
-	MTMSRD:        "mtmsrd",
-	MFMSR:         "mfmsr",
-	SLBIE:         "slbie",
-	SLBIA:         "slbia",
-	SLBMTE:        "slbmte",
-	SLBMFEV:       "slbmfev",
-	SLBMFEE:       "slbmfee",
-	SLBFEECC:      "slbfee.",
-	MTSR:          "mtsr",
-	MTSRIN:        "mtsrin",
-	MFSR:          "mfsr",
-	MFSRIN:        "mfsrin",
-	TLBIE:         "tlbie",
-	TLBIEL:        "tlbiel",
-	TLBIA:         "tlbia",
-	TLBSYNC:       "tlbsync",
-	MSGSND:        "msgsnd",
-	MSGCLR:        "msgclr",
-	MSGSNDP:       "msgsndp",
-	MSGCLRP:       "msgclrp",
-	MTTMR:         "mttmr",
-	RFI:           "rfi",
-	RFCI:          "rfci",
-	RFDI:          "rfdi",
-	RFMCI:         "rfmci",
-	RFGI:          "rfgi",
-	EHPRIV:        "ehpriv",
-	MTDCR:         "mtdcr",
-	MTDCRX:        "mtdcrx",
-	MFDCR:         "mfdcr",
-	MFDCRX:        "mfdcrx",
-	WRTEE:         "wrtee",
-	WRTEEI:        "wrteei",
-	LBEPX:         "lbepx",
-	LHEPX:         "lhepx",
-	LWEPX:         "lwepx",
-	LDEPX:         "ldepx",
-	STBEPX:        "stbepx",
-	STHEPX:        "sthepx",
-	STWEPX:        "stwepx",
-	STDEPX:        "stdepx",
-	DCBSTEP:       "dcbstep",
-	DCBTEP:        "dcbtep",
-	DCBFEP:        "dcbfep",
-	DCBTSTEP:      "dcbtstep",
-	ICBIEP:        "icbiep",
-	DCBZEP:        "dcbzep",
-	LFDEPX:        "lfdepx",
-	STFDEPX:       "stfdepx",
-	EVLDDEPX:      "evlddepx",
-	EVSTDDEPX:     "evstddepx",
-	LVEPX:         "lvepx",
-	LVEPXL:        "lvepxl",
-	STVEPX:        "stvepx",
-	STVEPXL:       "stvepxl",
-	DCBI:          "dcbi",
-	DCBLQCC:       "dcblq.",
-	ICBLQCC:       "icblq.",
-	DCBTLS:        "dcbtls",
-	DCBTSTLS:      "dcbtstls",
-	ICBTLS:        "icbtls",
-	ICBLC:         "icblc",
-	DCBLC:         "dcblc",
-	TLBIVAX:       "tlbivax",
-	TLBILX:        "tlbilx",
-	TLBSX:         "tlbsx",
-	TLBSRXCC:      "tlbsrx.",
-	TLBRE:         "tlbre",
-	TLBWE:         "tlbwe",
-	DNH:           "dnh",
-	DCI:           "dci",
-	ICI:           "ici",
-	DCREAD:        "dcread",
-	ICREAD:        "icread",
-	MFPMR:         "mfpmr",
-	MTPMR:         "mtpmr",
-	ADDEX:         "addex",
-	DARN:          "darn",
-	MADDHD:        "maddhd",
-	MADDHDU:       "maddhdu",
-	MADDLD:        "maddld",
-	CMPRB:         "cmprb",
-	CMPEQB:        "cmpeqb",
-	EXTSWSLI:      "extswsli",
-	EXTSWSLICC:    "extswsli.",
-	MFVSRLD:       "mfvsrld",
-	MTVSRDD:       "mtvsrdd",
-	MTVSRWS:       "mtvsrws",
-	MCRXRX:        "mcrxrx",
-	COPY:          "copy",
-	PASTECC:       "paste.",
+	BRD:            "brd",
+	BRH:            "brh",
+	BRW:            "brw",
+	CFUGED:         "cfuged",
+	CNTLZDM:        "cntlzdm",
+	CNTTZDM:        "cnttzdm",
+	DCFFIXQQ:       "dcffixqq",
+	DCTFIXQQ:       "dctfixqq",
+	LXVKQ:          "lxvkq",
+	LXVP:           "lxvp",
+	LXVPX:          "lxvpx",
+	LXVRBX:         "lxvrbx",
+	LXVRDX:         "lxvrdx",
+	LXVRHX:         "lxvrhx",
+	LXVRWX:         "lxvrwx",
+	MTVSRBM:        "mtvsrbm",
+	MTVSRBMI:       "mtvsrbmi",
+	MTVSRDM:        "mtvsrdm",
+	MTVSRHM:        "mtvsrhm",
+	MTVSRQM:        "mtvsrqm",
+	MTVSRWM:        "mtvsrwm",
+	PADDI:          "paddi",
+	PDEPD:          "pdepd",
+	PEXTD:          "pextd",
+	PLBZ:           "plbz",
+	PLD:            "pld",
+	PLFD:           "plfd",
+	PLFS:           "plfs",
+	PLHA:           "plha",
+	PLHZ:           "plhz",
+	PLQ:            "plq",
+	PLWA:           "plwa",
+	PLWZ:           "plwz",
+	PLXSD:          "plxsd",
+	PLXSSP:         "plxssp",
+	PLXV:           "plxv",
+	PLXVP:          "plxvp",
+	PMXVBF16GER2:   "pmxvbf16ger2",
+	PMXVBF16GER2NN: "pmxvbf16ger2nn",
+	PMXVBF16GER2NP: "pmxvbf16ger2np",
+	PMXVBF16GER2PN: "pmxvbf16ger2pn",
+	PMXVBF16GER2PP: "pmxvbf16ger2pp",
+	PMXVF16GER2:    "pmxvf16ger2",
+	PMXVF16GER2NN:  "pmxvf16ger2nn",
+	PMXVF16GER2NP:  "pmxvf16ger2np",
+	PMXVF16GER2PN:  "pmxvf16ger2pn",
+	PMXVF16GER2PP:  "pmxvf16ger2pp",
+	PMXVF32GER:     "pmxvf32ger",
+	PMXVF32GERNN:   "pmxvf32gernn",
+	PMXVF32GERNP:   "pmxvf32gernp",
+	PMXVF32GERPN:   "pmxvf32gerpn",
+	PMXVF32GERPP:   "pmxvf32gerpp",
+	PMXVF64GER:     "pmxvf64ger",
+	PMXVF64GERNN:   "pmxvf64gernn",
+	PMXVF64GERNP:   "pmxvf64gernp",
+	PMXVF64GERPN:   "pmxvf64gerpn",
+	PMXVF64GERPP:   "pmxvf64gerpp",
+	PMXVI16GER2:    "pmxvi16ger2",
+	PMXVI16GER2PP:  "pmxvi16ger2pp",
+	PMXVI16GER2S:   "pmxvi16ger2s",
+	PMXVI16GER2SPP: "pmxvi16ger2spp",
+	PMXVI4GER8:     "pmxvi4ger8",
+	PMXVI4GER8PP:   "pmxvi4ger8pp",
+	PMXVI8GER4:     "pmxvi8ger4",
+	PMXVI8GER4PP:   "pmxvi8ger4pp",
+	PMXVI8GER4SPP:  "pmxvi8ger4spp",
+	PNOP:           "pnop",
+	PSTB:           "pstb",
+	PSTD:           "pstd",
+	PSTFD:          "pstfd",
+	PSTFS:          "pstfs",
+	PSTH:           "psth",
+	PSTQ:           "pstq",
+	PSTW:           "pstw",
+	PSTXSD:         "pstxsd",
+	PSTXSSP:        "pstxssp",
+	PSTXV:          "pstxv",
+	PSTXVP:         "pstxvp",
+	SETBC:          "setbc",
+	SETBCR:         "setbcr",
+	SETNBC:         "setnbc",
+	SETNBCR:        "setnbcr",
+	STXVP:          "stxvp",
+	STXVPX:         "stxvpx",
+	STXVRBX:        "stxvrbx",
+	STXVRDX:        "stxvrdx",
+	STXVRHX:        "stxvrhx",
+	STXVRWX:        "stxvrwx",
+	VCFUGED:        "vcfuged",
+	VCLRLB:         "vclrlb",
+	VCLRRB:         "vclrrb",
+	VCLZDM:         "vclzdm",
+	VCMPEQUQ:       "vcmpequq",
+	VCMPEQUQCC:     "vcmpequq.",
+	VCMPGTSQ:       "vcmpgtsq",
+	VCMPGTSQCC:     "vcmpgtsq.",
+	VCMPGTUQ:       "vcmpgtuq",
+	VCMPGTUQCC:     "vcmpgtuq.",
+	VCMPSQ:         "vcmpsq",
+	VCMPUQ:         "vcmpuq",
+	VCNTMBB:        "vcntmbb",
+	VCNTMBD:        "vcntmbd",
+	VCNTMBH:        "vcntmbh",
+	VCNTMBW:        "vcntmbw",
+	VCTZDM:         "vctzdm",
+	VDIVESD:        "vdivesd",
+	VDIVESQ:        "vdivesq",
+	VDIVESW:        "vdivesw",
+	VDIVEUD:        "vdiveud",
+	VDIVEUQ:        "vdiveuq",
+	VDIVEUW:        "vdiveuw",
+	VDIVSD:         "vdivsd",
+	VDIVSQ:         "vdivsq",
+	VDIVSW:         "vdivsw",
+	VDIVUD:         "vdivud",
+	VDIVUQ:         "vdivuq",
+	VDIVUW:         "vdivuw",
+	VEXPANDBM:      "vexpandbm",
+	VEXPANDDM:      "vexpanddm",
+	VEXPANDHM:      "vexpandhm",
+	VEXPANDQM:      "vexpandqm",
+	VEXPANDWM:      "vexpandwm",
+	VEXTDDVLX:      "vextddvlx",
+	VEXTDDVRX:      "vextddvrx",
+	VEXTDUBVLX:     "vextdubvlx",
+	VEXTDUBVRX:     "vextdubvrx",
+	VEXTDUHVLX:     "vextduhvlx",
+	VEXTDUHVRX:     "vextduhvrx",
+	VEXTDUWVLX:     "vextduwvlx",
+	VEXTDUWVRX:     "vextduwvrx",
+	VEXTRACTBM:     "vextractbm",
+	VEXTRACTDM:     "vextractdm",
+	VEXTRACTHM:     "vextracthm",
+	VEXTRACTQM:     "vextractqm",
+	VEXTRACTWM:     "vextractwm",
+	VEXTSD2Q:       "vextsd2q",
+	VGNB:           "vgnb",
+	VINSBLX:        "vinsblx",
+	VINSBRX:        "vinsbrx",
+	VINSBVLX:       "vinsbvlx",
+	VINSBVRX:       "vinsbvrx",
+	VINSD:          "vinsd",
+	VINSDLX:        "vinsdlx",
+	VINSDRX:        "vinsdrx",
+	VINSHLX:        "vinshlx",
+	VINSHRX:        "vinshrx",
+	VINSHVLX:       "vinshvlx",
+	VINSHVRX:       "vinshvrx",
+	VINSW:          "vinsw",
+	VINSWLX:        "vinswlx",
+	VINSWRX:        "vinswrx",
+	VINSWVLX:       "vinswvlx",
+	VINSWVRX:       "vinswvrx",
+	VMODSD:         "vmodsd",
+	VMODSQ:         "vmodsq",
+	VMODSW:         "vmodsw",
+	VMODUD:         "vmodud",
+	VMODUQ:         "vmoduq",
+	VMODUW:         "vmoduw",
+	VMSUMCUD:       "vmsumcud",
+	VMULESD:        "vmulesd",
+	VMULEUD:        "vmuleud",
+	VMULHSD:        "vmulhsd",
+	VMULHSW:        "vmulhsw",
+	VMULHUD:        "vmulhud",
+	VMULHUW:        "vmulhuw",
+	VMULLD:         "vmulld",
+	VMULOSD:        "vmulosd",
+	VMULOUD:        "vmuloud",
+	VPDEPD:         "vpdepd",
+	VPEXTD:         "vpextd",
+	VRLQ:           "vrlq",
+	VRLQMI:         "vrlqmi",
+	VRLQNM:         "vrlqnm",
+	VSLDBI:         "vsldbi",
+	VSLQ:           "vslq",
+	VSRAQ:          "vsraq",
+	VSRDBI:         "vsrdbi",
+	VSRQ:           "vsrq",
+	VSTRIBL:        "vstribl",
+	VSTRIBLCC:      "vstribl.",
+	VSTRIBR:        "vstribr",
+	VSTRIBRCC:      "vstribr.",
+	VSTRIHL:        "vstrihl",
+	VSTRIHLCC:      "vstrihl.",
+	VSTRIHR:        "vstrihr",
+	VSTRIHRCC:      "vstrihr.",
+	XSCMPEQQP:      "xscmpeqqp",
+	XSCMPGEQP:      "xscmpgeqp",
+	XSCMPGTQP:      "xscmpgtqp",
+	XSCVQPSQZ:      "xscvqpsqz",
+	XSCVQPUQZ:      "xscvqpuqz",
+	XSCVSQQP:       "xscvsqqp",
+	XSCVUQQP:       "xscvuqqp",
+	XSMAXCQP:       "xsmaxcqp",
+	XSMINCQP:       "xsmincqp",
+	XVBF16GER2:     "xvbf16ger2",
+	XVBF16GER2NN:   "xvbf16ger2nn",
+	XVBF16GER2NP:   "xvbf16ger2np",
+	XVBF16GER2PN:   "xvbf16ger2pn",
+	XVBF16GER2PP:   "xvbf16ger2pp",
+	XVCVBF16SPN:    "xvcvbf16spn",
+	XVCVSPBF16:     "xvcvspbf16",
+	XVF16GER2:      "xvf16ger2",
+	XVF16GER2NN:    "xvf16ger2nn",
+	XVF16GER2NP:    "xvf16ger2np",
+	XVF16GER2PN:    "xvf16ger2pn",
+	XVF16GER2PP:    "xvf16ger2pp",
+	XVF32GER:       "xvf32ger",
+	XVF32GERNN:     "xvf32gernn",
+	XVF32GERNP:     "xvf32gernp",
+	XVF32GERPN:     "xvf32gerpn",
+	XVF32GERPP:     "xvf32gerpp",
+	XVF64GER:       "xvf64ger",
+	XVF64GERNN:     "xvf64gernn",
+	XVF64GERNP:     "xvf64gernp",
+	XVF64GERPN:     "xvf64gerpn",
+	XVF64GERPP:     "xvf64gerpp",
+	XVI16GER2:      "xvi16ger2",
+	XVI16GER2PP:    "xvi16ger2pp",
+	XVI16GER2S:     "xvi16ger2s",
+	XVI16GER2SPP:   "xvi16ger2spp",
+	XVI4GER8:       "xvi4ger8",
+	XVI4GER8PP:     "xvi4ger8pp",
+	XVI8GER4:       "xvi8ger4",
+	XVI8GER4PP:     "xvi8ger4pp",
+	XVI8GER4SPP:    "xvi8ger4spp",
+	XVTLSBB:        "xvtlsbb",
+	XXBLENDVB:      "xxblendvb",
+	XXBLENDVD:      "xxblendvd",
+	XXBLENDVH:      "xxblendvh",
+	XXBLENDVW:      "xxblendvw",
+	XXEVAL:         "xxeval",
+	XXGENPCVBM:     "xxgenpcvbm",
+	XXGENPCVDM:     "xxgenpcvdm",
+	XXGENPCVHM:     "xxgenpcvhm",
+	XXGENPCVWM:     "xxgenpcvwm",
+	XXMFACC:        "xxmfacc",
+	XXMTACC:        "xxmtacc",
+	XXPERMX:        "xxpermx",
+	XXSETACCZ:      "xxsetaccz",
+	XXSPLTI32DX:    "xxsplti32dx",
+	XXSPLTIDP:      "xxspltidp",
+	XXSPLTIW:       "xxspltiw",
+	MSGCLRU:        "msgclru",
+	MSGSNDU:        "msgsndu",
+	URFID:          "urfid",
+	ADDEX:          "addex",
+	MFFSCDRN:       "mffscdrn",
+	MFFSCDRNI:      "mffscdrni",
+	MFFSCE:         "mffsce",
+	MFFSCRN:        "mffscrn",
+	MFFSCRNI:       "mffscrni",
+	MFFSL:          "mffsl",
+	SLBIAG:         "slbiag",
+	VMSUMUDM:       "vmsumudm",
+	ADDPCIS:        "addpcis",
+	BCDCFNCC:       "bcdcfn.",
+	BCDCFSQCC:      "bcdcfsq.",
+	BCDCFZCC:       "bcdcfz.",
+	BCDCPSGNCC:     "bcdcpsgn.",
+	BCDCTNCC:       "bcdctn.",
+	BCDCTSQCC:      "bcdctsq.",
+	BCDCTZCC:       "bcdctz.",
+	BCDSCC:         "bcds.",
+	BCDSETSGNCC:    "bcdsetsgn.",
+	BCDSRCC:        "bcdsr.",
+	BCDTRUNCCC:     "bcdtrunc.",
+	BCDUSCC:        "bcdus.",
+	BCDUTRUNCCC:    "bcdutrunc.",
+	CMPEQB:         "cmpeqb",
+	CMPRB:          "cmprb",
+	CNTTZD:         "cnttzd",
+	CNTTZDCC:       "cnttzd.",
+	CNTTZW:         "cnttzw",
+	CNTTZWCC:       "cnttzw.",
+	COPY:           "copy",
+	CPABORT:        "cpabort",
+	DARN:           "darn",
+	DTSTSFI:        "dtstsfi",
+	DTSTSFIQ:       "dtstsfiq",
+	EXTSWSLI:       "extswsli",
+	EXTSWSLICC:     "extswsli.",
+	LDAT:           "ldat",
+	LWAT:           "lwat",
+	LXSD:           "lxsd",
+	LXSIBZX:        "lxsibzx",
+	LXSIHZX:        "lxsihzx",
+	LXSSP:          "lxssp",
+	LXV:            "lxv",
+	LXVB16X:        "lxvb16x",
+	LXVH8X:         "lxvh8x",
+	LXVL:           "lxvl",
+	LXVLL:          "lxvll",
+	LXVWSX:         "lxvwsx",
+	LXVX:           "lxvx",
+	MADDHD:         "maddhd",
+	MADDHDU:        "maddhdu",
+	MADDLD:         "maddld",
+	MCRXRX:         "mcrxrx",
+	MFVSRLD:        "mfvsrld",
+	MODSD:          "modsd",
+	MODSW:          "modsw",
+	MODUD:          "modud",
+	MODUW:          "moduw",
+	MSGSYNC:        "msgsync",
+	MTVSRDD:        "mtvsrdd",
+	MTVSRWS:        "mtvsrws",
+	PASTECC:        "paste.",
+	SETB:           "setb",
+	SLBIEG:         "slbieg",
+	SLBSYNC:        "slbsync",
+	STDAT:          "stdat",
+	STOP:           "stop",
+	STWAT:          "stwat",
+	STXSD:          "stxsd",
+	STXSIBX:        "stxsibx",
+	STXSIHX:        "stxsihx",
+	STXSSP:         "stxssp",
+	STXV:           "stxv",
+	STXVB16X:       "stxvb16x",
+	STXVH8X:        "stxvh8x",
+	STXVL:          "stxvl",
+	STXVLL:         "stxvll",
+	STXVX:          "stxvx",
+	VABSDUB:        "vabsdub",
+	VABSDUH:        "vabsduh",
+	VABSDUW:        "vabsduw",
+	VBPERMD:        "vbpermd",
+	VCLZLSBB:       "vclzlsbb",
+	VCMPNEB:        "vcmpneb",
+	VCMPNEBCC:      "vcmpneb.",
+	VCMPNEH:        "vcmpneh",
+	VCMPNEHCC:      "vcmpneh.",
+	VCMPNEW:        "vcmpnew",
+	VCMPNEWCC:      "vcmpnew.",
+	VCMPNEZB:       "vcmpnezb",
+	VCMPNEZBCC:     "vcmpnezb.",
+	VCMPNEZH:       "vcmpnezh",
+	VCMPNEZHCC:     "vcmpnezh.",
+	VCMPNEZW:       "vcmpnezw",
+	VCMPNEZWCC:     "vcmpnezw.",
+	VCTZB:          "vctzb",
+	VCTZD:          "vctzd",
+	VCTZH:          "vctzh",
+	VCTZLSBB:       "vctzlsbb",
+	VCTZW:          "vctzw",
+	VEXTRACTD:      "vextractd",
+	VEXTRACTUB:     "vextractub",
+	VEXTRACTUH:     "vextractuh",
+	VEXTRACTUW:     "vextractuw",
+	VEXTSB2D:       "vextsb2d",
+	VEXTSB2W:       "vextsb2w",
+	VEXTSH2D:       "vextsh2d",
+	VEXTSH2W:       "vextsh2w",
+	VEXTSW2D:       "vextsw2d",
+	VEXTUBLX:       "vextublx",
+	VEXTUBRX:       "vextubrx",
+	VEXTUHLX:       "vextuhlx",
+	VEXTUHRX:       "vextuhrx",
+	VEXTUWLX:       "vextuwlx",
+	VEXTUWRX:       "vextuwrx",
+	VINSERTB:       "vinsertb",
+	VINSERTD:       "vinsertd",
+	VINSERTH:       "vinserth",
+	VINSERTW:       "vinsertw",
+	VMUL10CUQ:      "vmul10cuq",
+	VMUL10ECUQ:     "vmul10ecuq",
+	VMUL10EUQ:      "vmul10euq",
+	VMUL10UQ:       "vmul10uq",
+	VNEGD:          "vnegd",
+	VNEGW:          "vnegw",
+	VPERMR:         "vpermr",
+	VPRTYBD:        "vprtybd",
+	VPRTYBQ:        "vprtybq",
+	VPRTYBW:        "vprtybw",
+	VRLDMI:         "vrldmi",
+	VRLDNM:         "vrldnm",
+	VRLWMI:         "vrlwmi",
+	VRLWNM:         "vrlwnm",
+	VSLV:           "vslv",
+	VSRV:           "vsrv",
+	WAIT:           "wait",
+	XSABSQP:        "xsabsqp",
+	XSADDQP:        "xsaddqp",
+	XSADDQPO:       "xsaddqpo",
+	XSCMPEQDP:      "xscmpeqdp",
+	XSCMPEXPDP:     "xscmpexpdp",
+	XSCMPEXPQP:     "xscmpexpqp",
+	XSCMPGEDP:      "xscmpgedp",
+	XSCMPGTDP:      "xscmpgtdp",
+	XSCMPOQP:       "xscmpoqp",
+	XSCMPUQP:       "xscmpuqp",
+	XSCPSGNQP:      "xscpsgnqp",
+	XSCVDPHP:       "xscvdphp",
+	XSCVDPQP:       "xscvdpqp",
+	XSCVHPDP:       "xscvhpdp",
+	XSCVQPDP:       "xscvqpdp",
+	XSCVQPDPO:      "xscvqpdpo",
+	XSCVQPSDZ:      "xscvqpsdz",
+	XSCVQPSWZ:      "xscvqpswz",
+	XSCVQPUDZ:      "xscvqpudz",
+	XSCVQPUWZ:      "xscvqpuwz",
+	XSCVSDQP:       "xscvsdqp",
+	XSCVUDQP:       "xscvudqp",
+	XSDIVQP:        "xsdivqp",
+	XSDIVQPO:       "xsdivqpo",
+	XSIEXPDP:       "xsiexpdp",
+	XSIEXPQP:       "xsiexpqp",
+	XSMADDQP:       "xsmaddqp",
+	XSMADDQPO:      "xsmaddqpo",
+	XSMAXCDP:       "xsmaxcdp",
+	XSMAXJDP:       "xsmaxjdp",
+	XSMINCDP:       "xsmincdp",
+	XSMINJDP:       "xsminjdp",
+	XSMSUBQP:       "xsmsubqp",
+	XSMSUBQPO:      "xsmsubqpo",
+	XSMULQP:        "xsmulqp",
+	XSMULQPO:       "xsmulqpo",
+	XSNABSQP:       "xsnabsqp",
+	XSNEGQP:        "xsnegqp",
+	XSNMADDQP:      "xsnmaddqp",
+	XSNMADDQPO:     "xsnmaddqpo",
+	XSNMSUBQP:      "xsnmsubqp",
+	XSNMSUBQPO:     "xsnmsubqpo",
+	XSRQPI:         "xsrqpi",
+	XSRQPIX:        "xsrqpix",
+	XSRQPXP:        "xsrqpxp",
+	XSSQRTQP:       "xssqrtqp",
+	XSSQRTQPO:      "xssqrtqpo",
+	XSSUBQP:        "xssubqp",
+	XSSUBQPO:       "xssubqpo",
+	XSTSTDCDP:      "xststdcdp",
+	XSTSTDCQP:      "xststdcqp",
+	XSTSTDCSP:      "xststdcsp",
+	XSXEXPDP:       "xsxexpdp",
+	XSXEXPQP:       "xsxexpqp",
+	XSXSIGDP:       "xsxsigdp",
+	XSXSIGQP:       "xsxsigqp",
+	XVCVHPSP:       "xvcvhpsp",
+	XVCVSPHP:       "xvcvsphp",
+	XVIEXPDP:       "xviexpdp",
+	XVIEXPSP:       "xviexpsp",
+	XVTSTDCDP:      "xvtstdcdp",
+	XVTSTDCSP:      "xvtstdcsp",
+	XVXEXPDP:       "xvxexpdp",
+	XVXEXPSP:       "xvxexpsp",
+	XVXSIGDP:       "xvxsigdp",
+	XVXSIGSP:       "xvxsigsp",
+	XXBRD:          "xxbrd",
+	XXBRH:          "xxbrh",
+	XXBRQ:          "xxbrq",
+	XXBRW:          "xxbrw",
+	XXEXTRACTUW:    "xxextractuw",
+	XXINSERTW:      "xxinsertw",
+	XXPERM:         "xxperm",
+	XXPERMR:        "xxpermr",
+	XXSPLTIB:       "xxspltib",
+	BCDADDCC:       "bcdadd.",
+	BCDSUBCC:       "bcdsub.",
+	BCTAR:          "bctar",
+	BCTARL:         "bctarl",
+	CLRBHRB:        "clrbhrb",
+	FMRGEW:         "fmrgew",
+	FMRGOW:         "fmrgow",
+	ICBT:           "icbt",
+	LQARX:          "lqarx",
+	LXSIWAX:        "lxsiwax",
+	LXSIWZX:        "lxsiwzx",
+	LXSSPX:         "lxsspx",
+	MFBHRBE:        "mfbhrbe",
+	MFVSRD:         "mfvsrd",
+	MFVSRWZ:        "mfvsrwz",
+	MSGCLR:         "msgclr",
+	MSGCLRP:        "msgclrp",
+	MSGSND:         "msgsnd",
+	MSGSNDP:        "msgsndp",
+	MTVSRD:         "mtvsrd",
+	MTVSRWA:        "mtvsrwa",
+	MTVSRWZ:        "mtvsrwz",
+	RFEBB:          "rfebb",
+	STQCXCC:        "stqcx.",
+	STXSIWX:        "stxsiwx",
+	STXSSPX:        "stxsspx",
+	VADDCUQ:        "vaddcuq",
+	VADDECUQ:       "vaddecuq",
+	VADDEUQM:       "vaddeuqm",
+	VADDUDM:        "vaddudm",
+	VADDUQM:        "vadduqm",
+	VBPERMQ:        "vbpermq",
+	VCIPHER:        "vcipher",
+	VCIPHERLAST:    "vcipherlast",
+	VCLZB:          "vclzb",
+	VCLZD:          "vclzd",
+	VCLZH:          "vclzh",
+	VCLZW:          "vclzw",
+	VCMPEQUD:       "vcmpequd",
+	VCMPEQUDCC:     "vcmpequd.",
+	VCMPGTSD:       "vcmpgtsd",
+	VCMPGTSDCC:     "vcmpgtsd.",
+	VCMPGTUD:       "vcmpgtud",
+	VCMPGTUDCC:     "vcmpgtud.",
+	VEQV:           "veqv",
+	VGBBD:          "vgbbd",
+	VMAXSD:         "vmaxsd",
+	VMAXUD:         "vmaxud",
+	VMINSD:         "vminsd",
+	VMINUD:         "vminud",
+	VMRGEW:         "vmrgew",
+	VMRGOW:         "vmrgow",
+	VMULESW:        "vmulesw",
+	VMULEUW:        "vmuleuw",
+	VMULOSW:        "vmulosw",
+	VMULOUW:        "vmulouw",
+	VMULUWM:        "vmuluwm",
+	VNAND:          "vnand",
+	VNCIPHER:       "vncipher",
+	VNCIPHERLAST:   "vncipherlast",
+	VORC:           "vorc",
+	VPERMXOR:       "vpermxor",
+	VPKSDSS:        "vpksdss",
+	VPKSDUS:        "vpksdus",
+	VPKUDUM:        "vpkudum",
+	VPKUDUS:        "vpkudus",
+	VPMSUMB:        "vpmsumb",
+	VPMSUMD:        "vpmsumd",
+	VPMSUMH:        "vpmsumh",
+	VPMSUMW:        "vpmsumw",
+	VPOPCNTB:       "vpopcntb",
+	VPOPCNTD:       "vpopcntd",
+	VPOPCNTH:       "vpopcnth",
+	VPOPCNTW:       "vpopcntw",
+	VRLD:           "vrld",
+	VSBOX:          "vsbox",
+	VSHASIGMAD:     "vshasigmad",
+	VSHASIGMAW:     "vshasigmaw",
+	VSLD:           "vsld",
+	VSRAD:          "vsrad",
+	VSRD:           "vsrd",
+	VSUBCUQ:        "vsubcuq",
+	VSUBECUQ:       "vsubecuq",
+	VSUBEUQM:       "vsubeuqm",
+	VSUBUDM:        "vsubudm",
+	VSUBUQM:        "vsubuqm",
+	VUPKHSW:        "vupkhsw",
+	VUPKLSW:        "vupklsw",
+	XSADDSP:        "xsaddsp",
+	XSCVDPSPN:      "xscvdpspn",
+	XSCVSPDPN:      "xscvspdpn",
+	XSCVSXDSP:      "xscvsxdsp",
+	XSCVUXDSP:      "xscvuxdsp",
+	XSDIVSP:        "xsdivsp",
+	XSMADDASP:      "xsmaddasp",
+	XSMADDMSP:      "xsmaddmsp",
+	XSMSUBASP:      "xsmsubasp",
+	XSMSUBMSP:      "xsmsubmsp",
+	XSMULSP:        "xsmulsp",
+	XSNMADDASP:     "xsnmaddasp",
+	XSNMADDMSP:     "xsnmaddmsp",
+	XSNMSUBASP:     "xsnmsubasp",
+	XSNMSUBMSP:     "xsnmsubmsp",
+	XSRESP:         "xsresp",
+	XSRSP:          "xsrsp",
+	XSRSQRTESP:     "xsrsqrtesp",
+	XSSQRTSP:       "xssqrtsp",
+	XSSUBSP:        "xssubsp",
+	XXLEQV:         "xxleqv",
+	XXLNAND:        "xxlnand",
+	XXLORC:         "xxlorc",
+	ADDG6S:         "addg6s",
+	BPERMD:         "bpermd",
+	CBCDTD:         "cbcdtd",
+	CDTBCD:         "cdtbcd",
+	DCFFIX:         "dcffix",
+	DCFFIXCC:       "dcffix.",
+	DIVDE:          "divde",
+	DIVDECC:        "divde.",
+	DIVDEO:         "divdeo",
+	DIVDEOCC:       "divdeo.",
+	DIVDEU:         "divdeu",
+	DIVDEUCC:       "divdeu.",
+	DIVDEUO:        "divdeuo",
+	DIVDEUOCC:      "divdeuo.",
+	DIVWE:          "divwe",
+	DIVWECC:        "divwe.",
+	DIVWEO:         "divweo",
+	DIVWEOCC:       "divweo.",
+	DIVWEU:         "divweu",
+	DIVWEUCC:       "divweu.",
+	DIVWEUO:        "divweuo",
+	DIVWEUOCC:      "divweuo.",
+	FCFIDS:         "fcfids",
+	FCFIDSCC:       "fcfids.",
+	FCFIDU:         "fcfidu",
+	FCFIDUCC:       "fcfidu.",
+	FCFIDUS:        "fcfidus",
+	FCFIDUSCC:      "fcfidus.",
+	FCTIDU:         "fctidu",
+	FCTIDUCC:       "fctidu.",
+	FCTIDUZ:        "fctiduz",
+	FCTIDUZCC:      "fctiduz.",
+	FCTIWU:         "fctiwu",
+	FCTIWUCC:       "fctiwu.",
+	FCTIWUZ:        "fctiwuz",
+	FCTIWUZCC:      "fctiwuz.",
+	FTDIV:          "ftdiv",
+	FTSQRT:         "ftsqrt",
+	LBARX:          "lbarx",
+	LDBRX:          "ldbrx",
+	LFIWZX:         "lfiwzx",
+	LHARX:          "lharx",
+	LXSDX:          "lxsdx",
+	LXVD2X:         "lxvd2x",
+	LXVDSX:         "lxvdsx",
+	LXVW4X:         "lxvw4x",
+	POPCNTD:        "popcntd",
+	POPCNTW:        "popcntw",
+	STBCXCC:        "stbcx.",
+	STDBRX:         "stdbrx",
+	STHCXCC:        "sthcx.",
+	STXSDX:         "stxsdx",
+	STXVD2X:        "stxvd2x",
+	STXVW4X:        "stxvw4x",
+	XSABSDP:        "xsabsdp",
+	XSADDDP:        "xsadddp",
+	XSCMPODP:       "xscmpodp",
+	XSCMPUDP:       "xscmpudp",
+	XSCPSGNDP:      "xscpsgndp",
+	XSCVDPSP:       "xscvdpsp",
+	XSCVDPSXDS:     "xscvdpsxds",
+	XSCVDPSXWS:     "xscvdpsxws",
+	XSCVDPUXDS:     "xscvdpuxds",
+	XSCVDPUXWS:     "xscvdpuxws",
+	XSCVSPDP:       "xscvspdp",
+	XSCVSXDDP:      "xscvsxddp",
+	XSCVUXDDP:      "xscvuxddp",
+	XSDIVDP:        "xsdivdp",
+	XSMADDADP:      "xsmaddadp",
+	XSMADDMDP:      "xsmaddmdp",
+	XSMAXDP:        "xsmaxdp",
+	XSMINDP:        "xsmindp",
+	XSMSUBADP:      "xsmsubadp",
+	XSMSUBMDP:      "xsmsubmdp",
+	XSMULDP:        "xsmuldp",
+	XSNABSDP:       "xsnabsdp",
+	XSNEGDP:        "xsnegdp",
+	XSNMADDADP:     "xsnmaddadp",
+	XSNMADDMDP:     "xsnmaddmdp",
+	XSNMSUBADP:     "xsnmsubadp",
+	XSNMSUBMDP:     "xsnmsubmdp",
+	XSRDPI:         "xsrdpi",
+	XSRDPIC:        "xsrdpic",
+	XSRDPIM:        "xsrdpim",
+	XSRDPIP:        "xsrdpip",
+	XSRDPIZ:        "xsrdpiz",
+	XSREDP:         "xsredp",
+	XSRSQRTEDP:     "xsrsqrtedp",
+	XSSQRTDP:       "xssqrtdp",
+	XSSUBDP:        "xssubdp",
+	XSTDIVDP:       "xstdivdp",
+	XSTSQRTDP:      "xstsqrtdp",
+	XVABSDP:        "xvabsdp",
+	XVABSSP:        "xvabssp",
+	XVADDDP:        "xvadddp",
+	XVADDSP:        "xvaddsp",
+	XVCMPEQDP:      "xvcmpeqdp",
+	XVCMPEQDPCC:    "xvcmpeqdp.",
+	XVCMPEQSP:      "xvcmpeqsp",
+	XVCMPEQSPCC:    "xvcmpeqsp.",
+	XVCMPGEDP:      "xvcmpgedp",
+	XVCMPGEDPCC:    "xvcmpgedp.",
+	XVCMPGESP:      "xvcmpgesp",
+	XVCMPGESPCC:    "xvcmpgesp.",
+	XVCMPGTDP:      "xvcmpgtdp",
+	XVCMPGTDPCC:    "xvcmpgtdp.",
+	XVCMPGTSP:      "xvcmpgtsp",
+	XVCMPGTSPCC:    "xvcmpgtsp.",
+	XVCPSGNDP:      "xvcpsgndp",
+	XVCPSGNSP:      "xvcpsgnsp",
+	XVCVDPSP:       "xvcvdpsp",
+	XVCVDPSXDS:     "xvcvdpsxds",
+	XVCVDPSXWS:     "xvcvdpsxws",
+	XVCVDPUXDS:     "xvcvdpuxds",
+	XVCVDPUXWS:     "xvcvdpuxws",
+	XVCVSPDP:       "xvcvspdp",
+	XVCVSPSXDS:     "xvcvspsxds",
+	XVCVSPSXWS:     "xvcvspsxws",
+	XVCVSPUXDS:     "xvcvspuxds",
+	XVCVSPUXWS:     "xvcvspuxws",
+	XVCVSXDDP:      "xvcvsxddp",
+	XVCVSXDSP:      "xvcvsxdsp",
+	XVCVSXWDP:      "xvcvsxwdp",
+	XVCVSXWSP:      "xvcvsxwsp",
+	XVCVUXDDP:      "xvcvuxddp",
+	XVCVUXDSP:      "xvcvuxdsp",
+	XVCVUXWDP:      "xvcvuxwdp",
+	XVCVUXWSP:      "xvcvuxwsp",
+	XVDIVDP:        "xvdivdp",
+	XVDIVSP:        "xvdivsp",
+	XVMADDADP:      "xvmaddadp",
+	XVMADDASP:      "xvmaddasp",
+	XVMADDMDP:      "xvmaddmdp",
+	XVMADDMSP:      "xvmaddmsp",
+	XVMAXDP:        "xvmaxdp",
+	XVMAXSP:        "xvmaxsp",
+	XVMINDP:        "xvmindp",
+	XVMINSP:        "xvminsp",
+	XVMSUBADP:      "xvmsubadp",
+	XVMSUBASP:      "xvmsubasp",
+	XVMSUBMDP:      "xvmsubmdp",
+	XVMSUBMSP:      "xvmsubmsp",
+	XVMULDP:        "xvmuldp",
+	XVMULSP:        "xvmulsp",
+	XVNABSDP:       "xvnabsdp",
+	XVNABSSP:       "xvnabssp",
+	XVNEGDP:        "xvnegdp",
+	XVNEGSP:        "xvnegsp",
+	XVNMADDADP:     "xvnmaddadp",
+	XVNMADDASP:     "xvnmaddasp",
+	XVNMADDMDP:     "xvnmaddmdp",
+	XVNMADDMSP:     "xvnmaddmsp",
+	XVNMSUBADP:     "xvnmsubadp",
+	XVNMSUBASP:     "xvnmsubasp",
+	XVNMSUBMDP:     "xvnmsubmdp",
+	XVNMSUBMSP:     "xvnmsubmsp",
+	XVRDPI:         "xvrdpi",
+	XVRDPIC:        "xvrdpic",
+	XVRDPIM:        "xvrdpim",
+	XVRDPIP:        "xvrdpip",
+	XVRDPIZ:        "xvrdpiz",
+	XVREDP:         "xvredp",
+	XVRESP:         "xvresp",
+	XVRSPI:         "xvrspi",
+	XVRSPIC:        "xvrspic",
+	XVRSPIM:        "xvrspim",
+	XVRSPIP:        "xvrspip",
+	XVRSPIZ:        "xvrspiz",
+	XVRSQRTEDP:     "xvrsqrtedp",
+	XVRSQRTESP:     "xvrsqrtesp",
+	XVSQRTDP:       "xvsqrtdp",
+	XVSQRTSP:       "xvsqrtsp",
+	XVSUBDP:        "xvsubdp",
+	XVSUBSP:        "xvsubsp",
+	XVTDIVDP:       "xvtdivdp",
+	XVTDIVSP:       "xvtdivsp",
+	XVTSQRTDP:      "xvtsqrtdp",
+	XVTSQRTSP:      "xvtsqrtsp",
+	XXLAND:         "xxland",
+	XXLANDC:        "xxlandc",
+	XXLNOR:         "xxlnor",
+	XXLOR:          "xxlor",
+	XXLXOR:         "xxlxor",
+	XXMRGHW:        "xxmrghw",
+	XXMRGLW:        "xxmrglw",
+	XXPERMDI:       "xxpermdi",
+	XXSEL:          "xxsel",
+	XXSLDWI:        "xxsldwi",
+	XXSPLTW:        "xxspltw",
+	CMPB:           "cmpb",
+	DADD:           "dadd",
+	DADDCC:         "dadd.",
+	DADDQ:          "daddq",
+	DADDQCC:        "daddq.",
+	DCFFIXQ:        "dcffixq",
+	DCFFIXQCC:      "dcffixq.",
+	DCMPO:          "dcmpo",
+	DCMPOQ:         "dcmpoq",
+	DCMPU:          "dcmpu",
+	DCMPUQ:         "dcmpuq",
+	DCTDP:          "dctdp",
+	DCTDPCC:        "dctdp.",
+	DCTFIX:         "dctfix",
+	DCTFIXCC:       "dctfix.",
+	DCTFIXQ:        "dctfixq",
+	DCTFIXQCC:      "dctfixq.",
+	DCTQPQ:         "dctqpq",
+	DCTQPQCC:       "dctqpq.",
+	DDEDPD:         "ddedpd",
+	DDEDPDCC:       "ddedpd.",
+	DDEDPDQ:        "ddedpdq",
+	DDEDPDQCC:      "ddedpdq.",
+	DDIV:           "ddiv",
+	DDIVCC:         "ddiv.",
+	DDIVQ:          "ddivq",
+	DDIVQCC:        "ddivq.",
+	DENBCD:         "denbcd",
+	DENBCDCC:       "denbcd.",
+	DENBCDQ:        "denbcdq",
+	DENBCDQCC:      "denbcdq.",
+	DIEX:           "diex",
+	DIEXCC:         "diex.",
+	DIEXQCC:        "diexq.",
+	DIEXQ:          "diexq",
+	DMUL:           "dmul",
+	DMULCC:         "dmul.",
+	DMULQ:          "dmulq",
+	DMULQCC:        "dmulq.",
+	DQUA:           "dqua",
+	DQUACC:         "dqua.",
+	DQUAI:          "dquai",
+	DQUAICC:        "dquai.",
+	DQUAIQ:         "dquaiq",
+	DQUAIQCC:       "dquaiq.",
+	DQUAQ:          "dquaq",
+	DQUAQCC:        "dquaq.",
+	DRDPQ:          "drdpq",
+	DRDPQCC:        "drdpq.",
+	DRINTN:         "drintn",
+	DRINTNCC:       "drintn.",
+	DRINTNQ:        "drintnq",
+	DRINTNQCC:      "drintnq.",
+	DRINTX:         "drintx",
+	DRINTXCC:       "drintx.",
+	DRINTXQ:        "drintxq",
+	DRINTXQCC:      "drintxq.",
+	DRRND:          "drrnd",
+	DRRNDCC:        "drrnd.",
+	DRRNDQ:         "drrndq",
+	DRRNDQCC:       "drrndq.",
+	DRSP:           "drsp",
+	DRSPCC:         "drsp.",
+	DSCLI:          "dscli",
+	DSCLICC:        "dscli.",
+	DSCLIQ:         "dscliq",
+	DSCLIQCC:       "dscliq.",
+	DSCRI:          "dscri",
+	DSCRICC:        "dscri.",
+	DSCRIQ:         "dscriq",
+	DSCRIQCC:       "dscriq.",
+	DSUB:           "dsub",
+	DSUBCC:         "dsub.",
+	DSUBQ:          "dsubq",
+	DSUBQCC:        "dsubq.",
+	DTSTDC:         "dtstdc",
+	DTSTDCQ:        "dtstdcq",
+	DTSTDG:         "dtstdg",
+	DTSTDGQ:        "dtstdgq",
+	DTSTEX:         "dtstex",
+	DTSTEXQ:        "dtstexq",
+	DTSTSF:         "dtstsf",
+	DTSTSFQ:        "dtstsfq",
+	DXEX:           "dxex",
+	DXEXCC:         "dxex.",
+	DXEXQ:          "dxexq",
+	DXEXQCC:        "dxexq.",
+	FCPSGN:         "fcpsgn",
+	FCPSGNCC:       "fcpsgn.",
+	LBZCIX:         "lbzcix",
+	LDCIX:          "ldcix",
+	LFDP:           "lfdp",
+	LFDPX:          "lfdpx",
+	LFIWAX:         "lfiwax",
+	LHZCIX:         "lhzcix",
+	LWZCIX:         "lwzcix",
+	PRTYD:          "prtyd",
+	PRTYW:          "prtyw",
+	SLBFEECC:       "slbfee.",
+	STBCIX:         "stbcix",
+	STDCIX:         "stdcix",
+	STFDP:          "stfdp",
+	STFDPX:         "stfdpx",
+	STHCIX:         "sthcix",
+	STWCIX:         "stwcix",
+	ISEL:           "isel",
+	LVEBX:          "lvebx",
+	LVEHX:          "lvehx",
+	LVEWX:          "lvewx",
+	LVSL:           "lvsl",
+	LVSR:           "lvsr",
+	LVX:            "lvx",
+	LVXL:           "lvxl",
+	MFVSCR:         "mfvscr",
+	MTVSCR:         "mtvscr",
+	STVEBX:         "stvebx",
+	STVEHX:         "stvehx",
+	STVEWX:         "stvewx",
+	STVX:           "stvx",
+	STVXL:          "stvxl",
+	TLBIEL:         "tlbiel",
+	VADDCUW:        "vaddcuw",
+	VADDFP:         "vaddfp",
+	VADDSBS:        "vaddsbs",
+	VADDSHS:        "vaddshs",
+	VADDSWS:        "vaddsws",
+	VADDUBM:        "vaddubm",
+	VADDUBS:        "vaddubs",
+	VADDUHM:        "vadduhm",
+	VADDUHS:        "vadduhs",
+	VADDUWM:        "vadduwm",
+	VADDUWS:        "vadduws",
+	VAND:           "vand",
+	VANDC:          "vandc",
+	VAVGSB:         "vavgsb",
+	VAVGSH:         "vavgsh",
+	VAVGSW:         "vavgsw",
+	VAVGUB:         "vavgub",
+	VAVGUH:         "vavguh",
+	VAVGUW:         "vavguw",
+	VCFSX:          "vcfsx",
+	VCFUX:          "vcfux",
+	VCMPBFP:        "vcmpbfp",
+	VCMPBFPCC:      "vcmpbfp.",
+	VCMPEQFP:       "vcmpeqfp",
+	VCMPEQFPCC:     "vcmpeqfp.",
+	VCMPEQUB:       "vcmpequb",
+	VCMPEQUBCC:     "vcmpequb.",
+	VCMPEQUH:       "vcmpequh",
+	VCMPEQUHCC:     "vcmpequh.",
+	VCMPEQUW:       "vcmpequw",
+	VCMPEQUWCC:     "vcmpequw.",
+	VCMPGEFP:       "vcmpgefp",
+	VCMPGEFPCC:     "vcmpgefp.",
+	VCMPGTFP:       "vcmpgtfp",
+	VCMPGTFPCC:     "vcmpgtfp.",
+	VCMPGTSB:       "vcmpgtsb",
+	VCMPGTSBCC:     "vcmpgtsb.",
+	VCMPGTSH:       "vcmpgtsh",
+	VCMPGTSHCC:     "vcmpgtsh.",
+	VCMPGTSW:       "vcmpgtsw",
+	VCMPGTSWCC:     "vcmpgtsw.",
+	VCMPGTUB:       "vcmpgtub",
+	VCMPGTUBCC:     "vcmpgtub.",
+	VCMPGTUH:       "vcmpgtuh",
+	VCMPGTUHCC:     "vcmpgtuh.",
+	VCMPGTUW:       "vcmpgtuw",
+	VCMPGTUWCC:     "vcmpgtuw.",
+	VCTSXS:         "vctsxs",
+	VCTUXS:         "vctuxs",
+	VEXPTEFP:       "vexptefp",
+	VLOGEFP:        "vlogefp",
+	VMADDFP:        "vmaddfp",
+	VMAXFP:         "vmaxfp",
+	VMAXSB:         "vmaxsb",
+	VMAXSH:         "vmaxsh",
+	VMAXSW:         "vmaxsw",
+	VMAXUB:         "vmaxub",
+	VMAXUH:         "vmaxuh",
+	VMAXUW:         "vmaxuw",
+	VMHADDSHS:      "vmhaddshs",
+	VMHRADDSHS:     "vmhraddshs",
+	VMINFP:         "vminfp",
+	VMINSB:         "vminsb",
+	VMINSH:         "vminsh",
+	VMINSW:         "vminsw",
+	VMINUB:         "vminub",
+	VMINUH:         "vminuh",
+	VMINUW:         "vminuw",
+	VMLADDUHM:      "vmladduhm",
+	VMRGHB:         "vmrghb",
+	VMRGHH:         "vmrghh",
+	VMRGHW:         "vmrghw",
+	VMRGLB:         "vmrglb",
+	VMRGLH:         "vmrglh",
+	VMRGLW:         "vmrglw",
+	VMSUMMBM:       "vmsummbm",
+	VMSUMSHM:       "vmsumshm",
+	VMSUMSHS:       "vmsumshs",
+	VMSUMUBM:       "vmsumubm",
+	VMSUMUHM:       "vmsumuhm",
+	VMSUMUHS:       "vmsumuhs",
+	VMULESB:        "vmulesb",
+	VMULESH:        "vmulesh",
+	VMULEUB:        "vmuleub",
+	VMULEUH:        "vmuleuh",
+	VMULOSB:        "vmulosb",
+	VMULOSH:        "vmulosh",
+	VMULOUB:        "vmuloub",
+	VMULOUH:        "vmulouh",
+	VNMSUBFP:       "vnmsubfp",
+	VNOR:           "vnor",
+	VOR:            "vor",
+	VPERM:          "vperm",
+	VPKPX:          "vpkpx",
+	VPKSHSS:        "vpkshss",
+	VPKSHUS:        "vpkshus",
+	VPKSWSS:        "vpkswss",
+	VPKSWUS:        "vpkswus",
+	VPKUHUM:        "vpkuhum",
+	VPKUHUS:        "vpkuhus",
+	VPKUWUM:        "vpkuwum",
+	VPKUWUS:        "vpkuwus",
+	VREFP:          "vrefp",
+	VRFIM:          "vrfim",
+	VRFIN:          "vrfin",
+	VRFIP:          "vrfip",
+	VRFIZ:          "vrfiz",
+	VRLB:           "vrlb",
+	VRLH:           "vrlh",
+	VRLW:           "vrlw",
+	VRSQRTEFP:      "vrsqrtefp",
+	VSEL:           "vsel",
+	VSL:            "vsl",
+	VSLB:           "vslb",
+	VSLDOI:         "vsldoi",
+	VSLH:           "vslh",
+	VSLO:           "vslo",
+	VSLW:           "vslw",
+	VSPLTB:         "vspltb",
+	VSPLTH:         "vsplth",
+	VSPLTISB:       "vspltisb",
+	VSPLTISH:       "vspltish",
+	VSPLTISW:       "vspltisw",
+	VSPLTW:         "vspltw",
+	VSR:            "vsr",
+	VSRAB:          "vsrab",
+	VSRAH:          "vsrah",
+	VSRAW:          "vsraw",
+	VSRB:           "vsrb",
+	VSRH:           "vsrh",
+	VSRO:           "vsro",
+	VSRW:           "vsrw",
+	VSUBCUW:        "vsubcuw",
+	VSUBFP:         "vsubfp",
+	VSUBSBS:        "vsubsbs",
+	VSUBSHS:        "vsubshs",
+	VSUBSWS:        "vsubsws",
+	VSUBUBM:        "vsububm",
+	VSUBUBS:        "vsububs",
+	VSUBUHM:        "vsubuhm",
+	VSUBUHS:        "vsubuhs",
+	VSUBUWM:        "vsubuwm",
+	VSUBUWS:        "vsubuws",
+	VSUM2SWS:       "vsum2sws",
+	VSUM4SBS:       "vsum4sbs",
+	VSUM4SHS:       "vsum4shs",
+	VSUM4UBS:       "vsum4ubs",
+	VSUMSWS:        "vsumsws",
+	VUPKHPX:        "vupkhpx",
+	VUPKHSB:        "vupkhsb",
+	VUPKHSH:        "vupkhsh",
+	VUPKLPX:        "vupklpx",
+	VUPKLSB:        "vupklsb",
+	VUPKLSH:        "vupklsh",
+	VXOR:           "vxor",
+	FRE:            "fre",
+	FRECC:          "fre.",
+	FRIM:           "frim",
+	FRIMCC:         "frim.",
+	FRIN:           "frin",
+	FRINCC:         "frin.",
+	FRIP:           "frip",
+	FRIPCC:         "frip.",
+	FRIZ:           "friz",
+	FRIZCC:         "friz.",
+	FRSQRTES:       "frsqrtes",
+	FRSQRTESCC:     "frsqrtes.",
+	HRFID:          "hrfid",
+	POPCNTB:        "popcntb",
+	MFOCRF:         "mfocrf",
+	MTOCRF:         "mtocrf",
+	SLBMFEE:        "slbmfee",
+	SLBMFEV:        "slbmfev",
+	SLBMTE:         "slbmte",
+	RFSCV:          "rfscv",
+	SCV:            "scv",
+	LQ:             "lq",
+	STQ:            "stq",
+	CNTLZD:         "cntlzd",
+	CNTLZDCC:       "cntlzd.",
+	DCBF:           "dcbf",
+	DCBST:          "dcbst",
+	DCBT:           "dcbt",
+	DCBTST:         "dcbtst",
+	DIVD:           "divd",
+	DIVDCC:         "divd.",
+	DIVDO:          "divdo",
+	DIVDOCC:        "divdo.",
+	DIVDU:          "divdu",
+	DIVDUCC:        "divdu.",
+	DIVDUO:         "divduo",
+	DIVDUOCC:       "divduo.",
+	DIVW:           "divw",
+	DIVWCC:         "divw.",
+	DIVWO:          "divwo",
+	DIVWOCC:        "divwo.",
+	DIVWU:          "divwu",
+	DIVWUCC:        "divwu.",
+	DIVWUO:         "divwuo",
+	DIVWUOCC:       "divwuo.",
+	EIEIO:          "eieio",
+	EXTSB:          "extsb",
+	EXTSBCC:        "extsb.",
+	EXTSW:          "extsw",
+	EXTSWCC:        "extsw.",
+	FADDS:          "fadds",
+	FADDSCC:        "fadds.",
+	FCFID:          "fcfid",
+	FCFIDCC:        "fcfid.",
+	FCTID:          "fctid",
+	FCTIDCC:        "fctid.",
+	FCTIDZ:         "fctidz",
+	FCTIDZCC:       "fctidz.",
+	FDIVS:          "fdivs",
+	FDIVSCC:        "fdivs.",
+	FMADDS:         "fmadds",
+	FMADDSCC:       "fmadds.",
+	FMSUBS:         "fmsubs",
+	FMSUBSCC:       "fmsubs.",
+	FMULS:          "fmuls",
+	FMULSCC:        "fmuls.",
+	FNMADDS:        "fnmadds",
+	FNMADDSCC:      "fnmadds.",
+	FNMSUBS:        "fnmsubs",
+	FNMSUBSCC:      "fnmsubs.",
+	FRES:           "fres",
+	FRESCC:         "fres.",
+	FRSQRTE:        "frsqrte",
+	FRSQRTECC:      "frsqrte.",
+	FSEL:           "fsel",
+	FSELCC:         "fsel.",
+	FSQRTS:         "fsqrts",
+	FSQRTSCC:       "fsqrts.",
+	FSUBS:          "fsubs",
+	FSUBSCC:        "fsubs.",
+	ICBI:           "icbi",
+	LD:             "ld",
+	LDARX:          "ldarx",
+	LDU:            "ldu",
+	LDUX:           "ldux",
+	LDX:            "ldx",
+	LWA:            "lwa",
+	LWARX:          "lwarx",
+	LWAUX:          "lwaux",
+	LWAX:           "lwax",
+	MFTB:           "mftb",
+	MTMSRD:         "mtmsrd",
+	MULHD:          "mulhd",
+	MULHDCC:        "mulhd.",
+	MULHDU:         "mulhdu",
+	MULHDUCC:       "mulhdu.",
+	MULHW:          "mulhw",
+	MULHWCC:        "mulhw.",
+	MULHWU:         "mulhwu",
+	MULHWUCC:       "mulhwu.",
+	MULLD:          "mulld",
+	MULLDCC:        "mulld.",
+	MULLDO:         "mulldo",
+	MULLDOCC:       "mulldo.",
+	RFID:           "rfid",
+	RLDCL:          "rldcl",
+	RLDCLCC:        "rldcl.",
+	RLDCR:          "rldcr",
+	RLDCRCC:        "rldcr.",
+	RLDIC:          "rldic",
+	RLDICCC:        "rldic.",
+	RLDICL:         "rldicl",
+	RLDICLCC:       "rldicl.",
+	RLDICR:         "rldicr",
+	RLDICRCC:       "rldicr.",
+	RLDIMI:         "rldimi",
+	RLDIMICC:       "rldimi.",
+	SC:             "sc",
+	SLBIA:          "slbia",
+	SLBIE:          "slbie",
+	SLD:            "sld",
+	SLDCC:          "sld.",
+	SRAD:           "srad",
+	SRADCC:         "srad.",
+	SRADI:          "sradi",
+	SRADICC:        "sradi.",
+	SRD:            "srd",
+	SRDCC:          "srd.",
+	STD:            "std",
+	STDCXCC:        "stdcx.",
+	STDU:           "stdu",
+	STDUX:          "stdux",
+	STDX:           "stdx",
+	STFIWX:         "stfiwx",
+	STWCXCC:        "stwcx.",
+	SUBF:           "subf",
+	SUBFCC:         "subf.",
+	SUBFO:          "subfo",
+	SUBFOCC:        "subfo.",
+	TD:             "td",
+	TDI:            "tdi",
+	TLBSYNC:        "tlbsync",
+	FCTIW:          "fctiw",
+	FCTIWCC:        "fctiw.",
+	FCTIWZ:         "fctiwz",
+	FCTIWZCC:       "fctiwz.",
+	FSQRT:          "fsqrt",
+	FSQRTCC:        "fsqrt.",
+	ADD:            "add",
+	ADDCC:          "add.",
+	ADDO:           "addo",
+	ADDOCC:         "addo.",
+	ADDC:           "addc",
+	ADDCCC:         "addc.",
+	ADDCO:          "addco",
+	ADDCOCC:        "addco.",
+	ADDE:           "adde",
+	ADDECC:         "adde.",
+	ADDEO:          "addeo",
+	ADDEOCC:        "addeo.",
+	LI:             "li",
+	ADDI:           "addi",
+	ADDIC:          "addic",
+	ADDICCC:        "addic.",
+	LIS:            "lis",
+	ADDIS:          "addis",
+	ADDME:          "addme",
+	ADDMECC:        "addme.",
+	ADDMEO:         "addmeo",
+	ADDMEOCC:       "addmeo.",
+	ADDZE:          "addze",
+	ADDZECC:        "addze.",
+	ADDZEO:         "addzeo",
+	ADDZEOCC:       "addzeo.",
+	AND:            "and",
+	ANDCC:          "and.",
+	ANDC:           "andc",
+	ANDCCC:         "andc.",
+	ANDICC:         "andi.",
+	ANDISCC:        "andis.",
+	B:              "b",
+	BA:             "ba",
+	BL:             "bl",
+	BLA:            "bla",
+	BC:             "bc",
+	BCA:            "bca",
+	BCL:            "bcl",
+	BCLA:           "bcla",
+	BCCTR:          "bcctr",
+	BCCTRL:         "bcctrl",
+	BCLR:           "bclr",
+	BCLRL:          "bclrl",
+	CMPW:           "cmpw",
+	CMPD:           "cmpd",
+	CMP:            "cmp",
+	CMPWI:          "cmpwi",
+	CMPDI:          "cmpdi",
+	CMPI:           "cmpi",
+	CMPLW:          "cmplw",
+	CMPLD:          "cmpld",
+	CMPL:           "cmpl",
+	CMPLWI:         "cmplwi",
+	CMPLDI:         "cmpldi",
+	CMPLI:          "cmpli",
+	CNTLZW:         "cntlzw",
+	CNTLZWCC:       "cntlzw.",
+	CRAND:          "crand",
+	CRANDC:         "crandc",
+	CREQV:          "creqv",
+	CRNAND:         "crnand",
+	CRNOR:          "crnor",
+	CROR:           "cror",
+	CRORC:          "crorc",
+	CRXOR:          "crxor",
+	DCBZ:           "dcbz",
+	EQV:            "eqv",
+	EQVCC:          "eqv.",
+	EXTSH:          "extsh",
+	EXTSHCC:        "extsh.",
+	FABS:           "fabs",
+	FABSCC:         "fabs.",
+	FADD:           "fadd",
+	FADDCC:         "fadd.",
+	FCMPO:          "fcmpo",
+	FCMPU:          "fcmpu",
+	FDIV:           "fdiv",
+	FDIVCC:         "fdiv.",
+	FMADD:          "fmadd",
+	FMADDCC:        "fmadd.",
+	FMR:            "fmr",
+	FMRCC:          "fmr.",
+	FMSUB:          "fmsub",
+	FMSUBCC:        "fmsub.",
+	FMUL:           "fmul",
+	FMULCC:         "fmul.",
+	FNABS:          "fnabs",
+	FNABSCC:        "fnabs.",
+	FNEG:           "fneg",
+	FNEGCC:         "fneg.",
+	FNMADD:         "fnmadd",
+	FNMADDCC:       "fnmadd.",
+	FNMSUB:         "fnmsub",
+	FNMSUBCC:       "fnmsub.",
+	FRSP:           "frsp",
+	FRSPCC:         "frsp.",
+	FSUB:           "fsub",
+	FSUBCC:         "fsub.",
+	ISYNC:          "isync",
+	LBZ:            "lbz",
+	LBZU:           "lbzu",
+	LBZUX:          "lbzux",
+	LBZX:           "lbzx",
+	LFD:            "lfd",
+	LFDU:           "lfdu",
+	LFDUX:          "lfdux",
+	LFDX:           "lfdx",
+	LFS:            "lfs",
+	LFSU:           "lfsu",
+	LFSUX:          "lfsux",
+	LFSX:           "lfsx",
+	LHA:            "lha",
+	LHAU:           "lhau",
+	LHAUX:          "lhaux",
+	LHAX:           "lhax",
+	LHBRX:          "lhbrx",
+	LHZ:            "lhz",
+	LHZU:           "lhzu",
+	LHZUX:          "lhzux",
+	LHZX:           "lhzx",
+	LMW:            "lmw",
+	LSWI:           "lswi",
+	LSWX:           "lswx",
+	LWBRX:          "lwbrx",
+	LWZ:            "lwz",
+	LWZU:           "lwzu",
+	LWZUX:          "lwzux",
+	LWZX:           "lwzx",
+	MCRF:           "mcrf",
+	MCRFS:          "mcrfs",
+	MFCR:           "mfcr",
+	MFFS:           "mffs",
+	MFFSCC:         "mffs.",
+	MFMSR:          "mfmsr",
+	MFSPR:          "mfspr",
+	MTCRF:          "mtcrf",
+	MTFSB0:         "mtfsb0",
+	MTFSB0CC:       "mtfsb0.",
+	MTFSB1:         "mtfsb1",
+	MTFSB1CC:       "mtfsb1.",
+	MTFSF:          "mtfsf",
+	MTFSFCC:        "mtfsf.",
+	MTFSFI:         "mtfsfi",
+	MTFSFICC:       "mtfsfi.",
+	MTMSR:          "mtmsr",
+	MTSPR:          "mtspr",
+	MULLI:          "mulli",
+	MULLW:          "mullw",
+	MULLWCC:        "mullw.",
+	MULLWO:         "mullwo",
+	MULLWOCC:       "mullwo.",
+	NAND:           "nand",
+	NANDCC:         "nand.",
+	NEG:            "neg",
+	NEGCC:          "neg.",
+	NEGO:           "nego",
+	NEGOCC:         "nego.",
+	NOR:            "nor",
+	NORCC:          "nor.",
+	OR:             "or",
+	ORCC:           "or.",
+	ORC:            "orc",
+	ORCCC:          "orc.",
+	NOP:            "nop",
+	ORI:            "ori",
+	ORIS:           "oris",
+	RLWIMI:         "rlwimi",
+	RLWIMICC:       "rlwimi.",
+	RLWINM:         "rlwinm",
+	RLWINMCC:       "rlwinm.",
+	RLWNM:          "rlwnm",
+	RLWNMCC:        "rlwnm.",
+	SLW:            "slw",
+	SLWCC:          "slw.",
+	SRAW:           "sraw",
+	SRAWCC:         "sraw.",
+	SRAWI:          "srawi",
+	SRAWICC:        "srawi.",
+	SRW:            "srw",
+	SRWCC:          "srw.",
+	STB:            "stb",
+	STBU:           "stbu",
+	STBUX:          "stbux",
+	STBX:           "stbx",
+	STFD:           "stfd",
+	STFDU:          "stfdu",
+	STFDUX:         "stfdux",
+	STFDX:          "stfdx",
+	STFS:           "stfs",
+	STFSU:          "stfsu",
+	STFSUX:         "stfsux",
+	STFSX:          "stfsx",
+	STH:            "sth",
+	STHBRX:         "sthbrx",
+	STHU:           "sthu",
+	STHUX:          "sthux",
+	STHX:           "sthx",
+	STMW:           "stmw",
+	STSWI:          "stswi",
+	STSWX:          "stswx",
+	STW:            "stw",
+	STWBRX:         "stwbrx",
+	STWU:           "stwu",
+	STWUX:          "stwux",
+	STWX:           "stwx",
+	SUBFC:          "subfc",
+	SUBFCCC:        "subfc.",
+	SUBFCO:         "subfco",
+	SUBFCOCC:       "subfco.",
+	SUBFE:          "subfe",
+	SUBFECC:        "subfe.",
+	SUBFEO:         "subfeo",
+	SUBFEOCC:       "subfeo.",
+	SUBFIC:         "subfic",
+	SUBFME:         "subfme",
+	SUBFMECC:       "subfme.",
+	SUBFMEO:        "subfmeo",
+	SUBFMEOCC:      "subfmeo.",
+	SUBFZE:         "subfze",
+	SUBFZECC:       "subfze.",
+	SUBFZEO:        "subfzeo",
+	SUBFZEOCC:      "subfzeo.",
+	SYNC:           "sync",
+	TLBIE:          "tlbie",
+	TW:             "tw",
+	TWI:            "twi",
+	XOR:            "xor",
+	XORCC:          "xor.",
+	XORI:           "xori",
+	XORIS:          "xoris",
 }
 
 var (
-	ap_Reg_11_15               = &argField{Type: TypeReg, Shift: 0, BitFields: BitFields{{11, 5}}}
-	ap_Reg_6_10                = &argField{Type: TypeReg, Shift: 0, BitFields: BitFields{{6, 5}}}
-	ap_PCRel_6_29_shift2       = &argField{Type: TypePCRel, Shift: 2, BitFields: BitFields{{6, 24}}}
-	ap_Label_6_29_shift2       = &argField{Type: TypeLabel, Shift: 2, BitFields: BitFields{{6, 24}}}
-	ap_ImmUnsigned_6_10        = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{6, 5}}}
-	ap_CondRegBit_11_15        = &argField{Type: TypeCondRegBit, Shift: 0, BitFields: BitFields{{11, 5}}}
-	ap_PCRel_16_29_shift2      = &argField{Type: TypePCRel, Shift: 2, BitFields: BitFields{{16, 14}}}
-	ap_Label_16_29_shift2      = &argField{Type: TypeLabel, Shift: 2, BitFields: BitFields{{16, 14}}}
-	ap_ImmUnsigned_19_20       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{19, 2}}}
-	ap_CondRegBit_6_10         = &argField{Type: TypeCondRegBit, Shift: 0, BitFields: BitFields{{6, 5}}}
-	ap_CondRegBit_16_20        = &argField{Type: TypeCondRegBit, Shift: 0, BitFields: BitFields{{16, 5}}}
-	ap_CondRegField_6_8        = &argField{Type: TypeCondRegField, Shift: 0, BitFields: BitFields{{6, 3}}}
-	ap_CondRegField_11_13      = &argField{Type: TypeCondRegField, Shift: 0, BitFields: BitFields{{11, 3}}}
-	ap_ImmUnsigned_20_26       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{20, 7}}}
-	ap_SpReg_11_20             = &argField{Type: TypeSpReg, Shift: 0, BitFields: BitFields{{11, 10}}}
-	ap_Offset_16_31            = &argField{Type: TypeOffset, Shift: 0, BitFields: BitFields{{16, 16}}}
-	ap_Reg_16_20               = &argField{Type: TypeReg, Shift: 0, BitFields: BitFields{{16, 5}}}
-	ap_Offset_16_29_shift2     = &argField{Type: TypeOffset, Shift: 2, BitFields: BitFields{{16, 14}}}
-	ap_Offset_16_27_shift4     = &argField{Type: TypeOffset, Shift: 4, BitFields: BitFields{{16, 12}}}
-	ap_ImmUnsigned_16_20       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{16, 5}}}
-	ap_ImmSigned_16_31         = &argField{Type: TypeImmSigned, Shift: 0, BitFields: BitFields{{16, 16}}}
-	ap_ImmUnsigned_16_31       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{16, 16}}}
-	ap_CondRegBit_21_25        = &argField{Type: TypeCondRegBit, Shift: 0, BitFields: BitFields{{21, 5}}}
-	ap_ImmUnsigned_21_25       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{21, 5}}}
-	ap_ImmUnsigned_26_30       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{26, 5}}}
-	ap_ImmUnsigned_30_30_16_20 = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{30, 1}, {16, 5}}}
-	ap_ImmUnsigned_26_26_21_25 = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{26, 1}, {21, 5}}}
-	ap_SpReg_16_20_11_15       = &argField{Type: TypeSpReg, Shift: 0, BitFields: BitFields{{16, 5}, {11, 5}}}
-	ap_ImmUnsigned_12_19       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{12, 8}}}
-	ap_ImmUnsigned_10_10       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{10, 1}}}
-	ap_VecSReg_31_31_6_10      = &argField{Type: TypeVecSReg, Shift: 0, BitFields: BitFields{{31, 1}, {6, 5}}}
-	ap_FPReg_6_10              = &argField{Type: TypeFPReg, Shift: 0, BitFields: BitFields{{6, 5}}}
-	ap_FPReg_16_20             = &argField{Type: TypeFPReg, Shift: 0, BitFields: BitFields{{16, 5}}}
-	ap_FPReg_11_15             = &argField{Type: TypeFPReg, Shift: 0, BitFields: BitFields{{11, 5}}}
-	ap_FPReg_21_25             = &argField{Type: TypeFPReg, Shift: 0, BitFields: BitFields{{21, 5}}}
-	ap_ImmUnsigned_6_8         = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{6, 3}}}
-	ap_ImmUnsigned_16_19       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{16, 4}}}
-	ap_ImmUnsigned_15_15       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{15, 1}}}
-	ap_ImmUnsigned_7_14        = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{7, 8}}}
-	ap_ImmUnsigned_6_6         = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{6, 1}}}
-	ap_VecReg_6_10             = &argField{Type: TypeVecReg, Shift: 0, BitFields: BitFields{{6, 5}}}
-	ap_VecReg_11_15            = &argField{Type: TypeVecReg, Shift: 0, BitFields: BitFields{{11, 5}}}
-	ap_VecReg_16_20            = &argField{Type: TypeVecReg, Shift: 0, BitFields: BitFields{{16, 5}}}
-	ap_ImmUnsigned_12_15       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{12, 4}}}
-	ap_ImmUnsigned_13_15       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{13, 3}}}
-	ap_ImmUnsigned_14_15       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{14, 2}}}
-	ap_ImmSigned_11_15         = &argField{Type: TypeImmSigned, Shift: 0, BitFields: BitFields{{11, 5}}}
-	ap_VecReg_21_25            = &argField{Type: TypeVecReg, Shift: 0, BitFields: BitFields{{21, 5}}}
-	ap_ImmUnsigned_22_25       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{22, 4}}}
-	ap_ImmUnsigned_11_15       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{11, 5}}}
-	ap_ImmUnsigned_16_16       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{16, 1}}}
-	ap_ImmUnsigned_17_20       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{17, 4}}}
-	ap_ImmUnsigned_22_22       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{22, 1}}}
-	ap_ImmUnsigned_16_21       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{16, 6}}}
-	ap_ImmUnsigned_21_22       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{21, 2}}}
-	ap_ImmUnsigned_11_12       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{11, 2}}}
-	ap_ImmUnsigned_11_11       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{11, 1}}}
-	ap_VecSReg_28_28_6_10      = &argField{Type: TypeVecSReg, Shift: 0, BitFields: BitFields{{28, 1}, {6, 5}}}
-	ap_VecSReg_30_30_16_20     = &argField{Type: TypeVecSReg, Shift: 0, BitFields: BitFields{{30, 1}, {16, 5}}}
-	ap_VecSReg_29_29_11_15     = &argField{Type: TypeVecSReg, Shift: 0, BitFields: BitFields{{29, 1}, {11, 5}}}
-	ap_ImmUnsigned_22_23       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{22, 2}}}
-	ap_VecSReg_28_28_21_25     = &argField{Type: TypeVecSReg, Shift: 0, BitFields: BitFields{{28, 1}, {21, 5}}}
-	ap_CondRegField_29_31      = &argField{Type: TypeCondRegField, Shift: 0, BitFields: BitFields{{29, 3}}}
-	ap_ImmUnsigned_7_10        = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{7, 4}}}
-	ap_ImmUnsigned_9_10        = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{9, 2}}}
-	ap_ImmUnsigned_31_31       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{31, 1}}}
-	ap_ImmSigned_16_20         = &argField{Type: TypeImmSigned, Shift: 0, BitFields: BitFields{{16, 5}}}
-	ap_ImmUnsigned_20_20       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{20, 1}}}
-	ap_ImmUnsigned_8_10        = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{8, 3}}}
-	ap_SpReg_12_15             = &argField{Type: TypeSpReg, Shift: 0, BitFields: BitFields{{12, 4}}}
-	ap_ImmUnsigned_6_20        = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{6, 15}}}
-	ap_ImmUnsigned_11_20       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{11, 10}}}
-	ap_Reg_21_25               = &argField{Type: TypeReg, Shift: 0, BitFields: BitFields{{21, 5}}}
+	ap_Reg_11_15                     = &argField{Type: TypeReg, Shift: 0, BitFields: BitFields{{11, 5, 0}}}
+	ap_Reg_6_10                      = &argField{Type: TypeReg, Shift: 0, BitFields: BitFields{{6, 5, 0}}}
+	ap_Reg_16_20                     = &argField{Type: TypeReg, Shift: 0, BitFields: BitFields{{16, 5, 0}}}
+	ap_FPReg_6_10                    = &argField{Type: TypeFPReg, Shift: 0, BitFields: BitFields{{6, 5, 0}}}
+	ap_VecReg_16_20                  = &argField{Type: TypeVecReg, Shift: 0, BitFields: BitFields{{16, 5, 0}}}
+	ap_VecReg_6_10                   = &argField{Type: TypeVecReg, Shift: 0, BitFields: BitFields{{6, 5, 0}}}
+	ap_FPReg_16_20                   = &argField{Type: TypeFPReg, Shift: 0, BitFields: BitFields{{16, 5, 0}}}
+	ap_VecSReg_31_31_6_10            = &argField{Type: TypeVecSReg, Shift: 0, BitFields: BitFields{{31, 1, 0}, {6, 5, 0}}}
+	ap_ImmUnsigned_16_20             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{16, 5, 0}}}
+	ap_VecSpReg_10_10_6_9            = &argField{Type: TypeVecSpReg, Shift: 0, BitFields: BitFields{{10, 1, 0}, {6, 4, 0}}}
+	ap_Offset_16_27_shift4           = &argField{Type: TypeOffset, Shift: 4, BitFields: BitFields{{16, 12, 0}}}
+	ap_ImmUnsigned_16_25_11_15_31_31 = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{16, 10, 0}, {11, 5, 0}, {31, 1, 0}}}
+	ap_Reg_38_42                     = &argField{Type: TypeReg, Shift: 0, BitFields: BitFields{{6, 5, 1}}}
+	ap_Reg_43_47                     = &argField{Type: TypeReg, Shift: 0, BitFields: BitFields{{11, 5, 1}}}
+	ap_ImmSigned_14_31_48_63         = &argField{Type: TypeImmSigned, Shift: 0, BitFields: BitFields{{14, 18, 0}, {16, 16, 1}}}
+	ap_ImmUnsigned_11_11             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{11, 1, 0}}}
+	ap_Offset_14_31_48_63            = &argField{Type: TypeOffset, Shift: 0, BitFields: BitFields{{14, 18, 0}, {16, 16, 1}}}
+	ap_FPReg_38_42                   = &argField{Type: TypeFPReg, Shift: 0, BitFields: BitFields{{6, 5, 1}}}
+	ap_VecReg_38_42                  = &argField{Type: TypeVecReg, Shift: 0, BitFields: BitFields{{6, 5, 1}}}
+	ap_VecSReg_37_37_38_42           = &argField{Type: TypeVecSReg, Shift: 0, BitFields: BitFields{{5, 1, 1}, {6, 5, 1}}}
+	ap_VecSpReg_42_42_38_41          = &argField{Type: TypeVecSpReg, Shift: 0, BitFields: BitFields{{10, 1, 1}, {6, 4, 1}}}
+	ap_MMAReg_38_40                  = &argField{Type: TypeMMAReg, Shift: 0, BitFields: BitFields{{6, 3, 1}}}
+	ap_VecSReg_61_61_43_47           = &argField{Type: TypeVecSReg, Shift: 0, BitFields: BitFields{{29, 1, 1}, {11, 5, 1}}}
+	ap_VecSReg_62_62_48_52           = &argField{Type: TypeVecSReg, Shift: 0, BitFields: BitFields{{30, 1, 1}, {16, 5, 1}}}
+	ap_ImmUnsigned_24_27             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{24, 4, 0}}}
+	ap_ImmUnsigned_28_31             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{28, 4, 0}}}
+	ap_ImmUnsigned_16_17             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{16, 2, 0}}}
+	ap_ImmUnsigned_28_29             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{28, 2, 0}}}
+	ap_ImmUnsigned_16_23             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{16, 8, 0}}}
+	ap_ImmUnsigned_16_19             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{16, 4, 0}}}
+	ap_CondRegBit_11_15              = &argField{Type: TypeCondRegBit, Shift: 0, BitFields: BitFields{{11, 5, 0}}}
+	ap_VecReg_11_15                  = &argField{Type: TypeVecReg, Shift: 0, BitFields: BitFields{{11, 5, 0}}}
+	ap_CondRegField_6_8              = &argField{Type: TypeCondRegField, Shift: 0, BitFields: BitFields{{6, 3, 0}}}
+	ap_ImmUnsigned_15_15             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{15, 1, 0}}}
+	ap_Reg_21_25                     = &argField{Type: TypeReg, Shift: 0, BitFields: BitFields{{21, 5, 0}}}
+	ap_ImmUnsigned_13_15             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{13, 3, 0}}}
+	ap_ImmUnsigned_12_15             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{12, 4, 0}}}
+	ap_VecReg_21_25                  = &argField{Type: TypeVecReg, Shift: 0, BitFields: BitFields{{21, 5, 0}}}
+	ap_ImmUnsigned_23_25             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{23, 3, 0}}}
+	ap_MMAReg_6_8                    = &argField{Type: TypeMMAReg, Shift: 0, BitFields: BitFields{{6, 3, 0}}}
+	ap_VecSReg_29_29_11_15           = &argField{Type: TypeVecSReg, Shift: 0, BitFields: BitFields{{29, 1, 0}, {11, 5, 0}}}
+	ap_VecSReg_30_30_16_20           = &argField{Type: TypeVecSReg, Shift: 0, BitFields: BitFields{{30, 1, 0}, {16, 5, 0}}}
+	ap_VecSReg_63_63_38_42           = &argField{Type: TypeVecSReg, Shift: 0, BitFields: BitFields{{31, 1, 1}, {6, 5, 1}}}
+	ap_VecSReg_60_60_53_57           = &argField{Type: TypeVecSReg, Shift: 0, BitFields: BitFields{{28, 1, 1}, {21, 5, 1}}}
+	ap_ImmUnsigned_24_31             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{24, 8, 0}}}
+	ap_ImmUnsigned_11_15             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{11, 5, 0}}}
+	ap_ImmUnsigned_29_31             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{29, 3, 0}}}
+	ap_VecSReg_47_47_38_42           = &argField{Type: TypeVecSReg, Shift: 0, BitFields: BitFields{{15, 1, 1}, {6, 5, 1}}}
+	ap_ImmUnsigned_46_46             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{14, 1, 1}}}
+	ap_ImmUnsigned_16_31_48_63       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{16, 16, 0}, {16, 16, 1}}}
+	ap_ImmUnsigned_21_22             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{21, 2, 0}}}
+	ap_ImmUnsigned_18_20             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{18, 3, 0}}}
+	ap_ImmUnsigned_19_20             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{19, 2, 0}}}
+	ap_ImmSigned_16_25_11_15_31_31   = &argField{Type: TypeImmSigned, Shift: 0, BitFields: BitFields{{16, 10, 0}, {11, 5, 0}, {31, 1, 0}}}
+	ap_ImmUnsigned_22_22             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{22, 1, 0}}}
+	ap_ImmUnsigned_10_10             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{10, 1, 0}}}
+	ap_ImmUnsigned_14_15             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{14, 2, 0}}}
+	ap_ImmUnsigned_10_15             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{10, 6, 0}}}
+	ap_ImmUnsigned_30_30_16_20       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{30, 1, 0}, {16, 5, 0}}}
+	ap_Offset_16_29_shift2           = &argField{Type: TypeOffset, Shift: 2, BitFields: BitFields{{16, 14, 0}}}
+	ap_VecSReg_28_28_6_10            = &argField{Type: TypeVecSReg, Shift: 0, BitFields: BitFields{{28, 1, 0}, {6, 5, 0}}}
+	ap_CondRegField_11_13            = &argField{Type: TypeCondRegField, Shift: 0, BitFields: BitFields{{11, 3, 0}}}
+	ap_ImmUnsigned_9_10              = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{9, 2, 0}}}
+	ap_ImmUnsigned_9_15              = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{9, 7, 0}}}
+	ap_ImmUnsigned_25_25_29_29_11_15 = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{25, 1, 0}, {29, 1, 0}, {11, 5, 0}}}
+	ap_ImmUnsigned_13_20             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{13, 8, 0}}}
+	ap_ImmUnsigned_6_10              = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{6, 5, 0}}}
+	ap_FPReg_11_15                   = &argField{Type: TypeFPReg, Shift: 0, BitFields: BitFields{{11, 5, 0}}}
+	ap_ImmUnsigned_7_10              = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{7, 4, 0}}}
+	ap_ImmUnsigned_31_31             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{31, 1, 0}}}
+	ap_SpReg_11_20                   = &argField{Type: TypeSpReg, Shift: 0, BitFields: BitFields{{11, 10, 0}}}
+	ap_ImmUnsigned_20_20             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{20, 1, 0}}}
+	ap_ImmUnsigned_16_16             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{16, 1, 0}}}
+	ap_ImmUnsigned_17_20             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{17, 4, 0}}}
+	ap_ImmUnsigned_22_23             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{22, 2, 0}}}
+	ap_VecSReg_28_28_21_25           = &argField{Type: TypeVecSReg, Shift: 0, BitFields: BitFields{{28, 1, 0}, {21, 5, 0}}}
+	ap_ImmUnsigned_11_12             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{11, 2, 0}}}
+	ap_ImmSigned_11_15               = &argField{Type: TypeImmSigned, Shift: 0, BitFields: BitFields{{11, 5, 0}}}
+	ap_ImmUnsigned_16_21             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{16, 6, 0}}}
+	ap_CondRegBit_21_25              = &argField{Type: TypeCondRegBit, Shift: 0, BitFields: BitFields{{21, 5, 0}}}
+	ap_ImmUnsigned_12_13             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{12, 2, 0}}}
+	ap_ImmUnsigned_14_14             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{14, 1, 0}}}
+	ap_ImmUnsigned_22_25             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{22, 4, 0}}}
+	ap_ImmUnsigned_12_19             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{12, 8, 0}}}
+	ap_ImmUnsigned_20_26             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{20, 7, 0}}}
+	ap_ImmUnsigned_8_10              = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{8, 3, 0}}}
+	ap_FPReg_21_25                   = &argField{Type: TypeFPReg, Shift: 0, BitFields: BitFields{{21, 5, 0}}}
+	ap_SpReg_16_20_11_15             = &argField{Type: TypeSpReg, Shift: 0, BitFields: BitFields{{16, 5, 0}, {11, 5, 0}}}
+	ap_ImmUnsigned_26_26_21_25       = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{26, 1, 0}, {21, 5, 0}}}
+	ap_ImmSigned_16_31               = &argField{Type: TypeImmSigned, Shift: 0, BitFields: BitFields{{16, 16, 0}}}
+	ap_ImmUnsigned_16_31             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{16, 16, 0}}}
+	ap_PCRel_6_29_shift2             = &argField{Type: TypePCRel, Shift: 2, BitFields: BitFields{{6, 24, 0}}}
+	ap_Label_6_29_shift2             = &argField{Type: TypeLabel, Shift: 2, BitFields: BitFields{{6, 24, 0}}}
+	ap_PCRel_16_29_shift2            = &argField{Type: TypePCRel, Shift: 2, BitFields: BitFields{{16, 14, 0}}}
+	ap_Label_16_29_shift2            = &argField{Type: TypeLabel, Shift: 2, BitFields: BitFields{{16, 14, 0}}}
+	ap_CondRegBit_6_10               = &argField{Type: TypeCondRegBit, Shift: 0, BitFields: BitFields{{6, 5, 0}}}
+	ap_CondRegBit_16_20              = &argField{Type: TypeCondRegBit, Shift: 0, BitFields: BitFields{{16, 5, 0}}}
+	ap_Offset_16_31                  = &argField{Type: TypeOffset, Shift: 0, BitFields: BitFields{{16, 16, 0}}}
+	ap_ImmUnsigned_7_14              = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{7, 8, 0}}}
+	ap_ImmUnsigned_6_6               = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{6, 1, 0}}}
+	ap_ImmUnsigned_6_8               = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{6, 3, 0}}}
+	ap_ImmUnsigned_21_25             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{21, 5, 0}}}
+	ap_ImmUnsigned_26_30             = &argField{Type: TypeImmUnsigned, Shift: 0, BitFields: BitFields{{26, 5, 0}}}
 )
 
 var instFormats = [...]instFormat{
-	{CNTLZW, 0xfc0007ff, 0x7c000034, 0xf800, // Count Leading Zeros Word X-form (cntlzw RA, RS)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10}},
-	{CNTLZWCC, 0xfc0007ff, 0x7c000035, 0xf800, // Count Leading Zeros Word X-form (cntlzw. RA, RS)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10}},
-	{B, 0xfc000003, 0x48000000, 0x0, // Branch I-form (b target_addr)
-		[5]*argField{ap_PCRel_6_29_shift2}},
-	{BA, 0xfc000003, 0x48000002, 0x0, // Branch I-form (ba target_addr)
-		[5]*argField{ap_Label_6_29_shift2}},
-	{BL, 0xfc000003, 0x48000001, 0x0, // Branch I-form (bl target_addr)
-		[5]*argField{ap_PCRel_6_29_shift2}},
-	{BLA, 0xfc000003, 0x48000003, 0x0, // Branch I-form (bla target_addr)
-		[5]*argField{ap_Label_6_29_shift2}},
-	{BC, 0xfc000003, 0x40000000, 0x0, // Branch Conditional B-form (bc BO,BI,target_addr)
-		[5]*argField{ap_ImmUnsigned_6_10, ap_CondRegBit_11_15, ap_PCRel_16_29_shift2}},
-	{BCA, 0xfc000003, 0x40000002, 0x0, // Branch Conditional B-form (bca BO,BI,target_addr)
-		[5]*argField{ap_ImmUnsigned_6_10, ap_CondRegBit_11_15, ap_Label_16_29_shift2}},
-	{BCL, 0xfc000003, 0x40000001, 0x0, // Branch Conditional B-form (bcl BO,BI,target_addr)
-		[5]*argField{ap_ImmUnsigned_6_10, ap_CondRegBit_11_15, ap_PCRel_16_29_shift2}},
-	{BCLA, 0xfc000003, 0x40000003, 0x0, // Branch Conditional B-form (bcla BO,BI,target_addr)
-		[5]*argField{ap_ImmUnsigned_6_10, ap_CondRegBit_11_15, ap_Label_16_29_shift2}},
-	{BCLR, 0xfc0007ff, 0x4c000020, 0xe000, // Branch Conditional to Link Register XL-form (bclr BO,BI,BH)
-		[5]*argField{ap_ImmUnsigned_6_10, ap_CondRegBit_11_15, ap_ImmUnsigned_19_20}},
-	{BCLRL, 0xfc0007ff, 0x4c000021, 0xe000, // Branch Conditional to Link Register XL-form (bclrl BO,BI,BH)
-		[5]*argField{ap_ImmUnsigned_6_10, ap_CondRegBit_11_15, ap_ImmUnsigned_19_20}},
-	{BCCTR, 0xfc0007ff, 0x4c000420, 0xe000, // Branch Conditional to Count Register XL-form (bcctr BO,BI,BH)
-		[5]*argField{ap_ImmUnsigned_6_10, ap_CondRegBit_11_15, ap_ImmUnsigned_19_20}},
-	{BCCTRL, 0xfc0007ff, 0x4c000421, 0xe000, // Branch Conditional to Count Register XL-form (bcctrl BO,BI,BH)
-		[5]*argField{ap_ImmUnsigned_6_10, ap_CondRegBit_11_15, ap_ImmUnsigned_19_20}},
-	{BCTAR, 0xfc0007ff, 0x4c000460, 0xe000, // Branch Conditional to Branch Target Address Register XL-form (bctar BO,BI,BH)
-		[5]*argField{ap_ImmUnsigned_6_10, ap_CondRegBit_11_15, ap_ImmUnsigned_19_20}},
-	{BCTARL, 0xfc0007ff, 0x4c000461, 0xe000, // Branch Conditional to Branch Target Address Register XL-form (bctarl BO,BI,BH)
-		[5]*argField{ap_ImmUnsigned_6_10, ap_CondRegBit_11_15, ap_ImmUnsigned_19_20}},
-	{CRAND, 0xfc0007fe, 0x4c000202, 0x1, // Condition Register AND XL-form (crand BT,BA,BB)
-		[5]*argField{ap_CondRegBit_6_10, ap_CondRegBit_11_15, ap_CondRegBit_16_20}},
-	{CROR, 0xfc0007fe, 0x4c000382, 0x1, // Condition Register OR XL-form (cror BT,BA,BB)
-		[5]*argField{ap_CondRegBit_6_10, ap_CondRegBit_11_15, ap_CondRegBit_16_20}},
-	{CRNAND, 0xfc0007fe, 0x4c0001c2, 0x1, // Condition Register NAND XL-form (crnand BT,BA,BB)
-		[5]*argField{ap_CondRegBit_6_10, ap_CondRegBit_11_15, ap_CondRegBit_16_20}},
-	{CRXOR, 0xfc0007fe, 0x4c000182, 0x1, // Condition Register XOR XL-form (crxor BT,BA,BB)
-		[5]*argField{ap_CondRegBit_6_10, ap_CondRegBit_11_15, ap_CondRegBit_16_20}},
-	{CRNOR, 0xfc0007fe, 0x4c000042, 0x1, // Condition Register NOR XL-form (crnor BT,BA,BB)
-		[5]*argField{ap_CondRegBit_6_10, ap_CondRegBit_11_15, ap_CondRegBit_16_20}},
-	{CRANDC, 0xfc0007fe, 0x4c000102, 0x1, // Condition Register AND with Complement XL-form (crandc BT,BA,BB)
-		[5]*argField{ap_CondRegBit_6_10, ap_CondRegBit_11_15, ap_CondRegBit_16_20}},
-	{MCRF, 0xfc0007fe, 0x4c000000, 0x63f801, // Move Condition Register Field XL-form (mcrf BF,BFA)
-		[5]*argField{ap_CondRegField_6_8, ap_CondRegField_11_13}},
-	{CREQV, 0xfc0007fe, 0x4c000242, 0x1, // Condition Register Equivalent XL-form (creqv BT,BA,BB)
-		[5]*argField{ap_CondRegBit_6_10, ap_CondRegBit_11_15, ap_CondRegBit_16_20}},
-	{CRORC, 0xfc0007fe, 0x4c000342, 0x1, // Condition Register OR with Complement XL-form (crorc BT,BA,BB)
-		[5]*argField{ap_CondRegBit_6_10, ap_CondRegBit_11_15, ap_CondRegBit_16_20}},
-	{SC, 0xfc000002, 0x44000002, 0x3fff01d, // System Call SC-form (sc LEV)
-		[5]*argField{ap_ImmUnsigned_20_26}},
-	{CLRBHRB, 0xfc0007fe, 0x7c00035c, 0x3fff801, // Clear BHRB X-form (clrbhrb)
-		[5]*argField{}},
-	{MFBHRBE, 0xfc0007fe, 0x7c00025c, 0x1, // Move From Branch History Rolling Buffer XFX-form (mfbhrbe RT,BHRBE)
-		[5]*argField{ap_Reg_6_10, ap_SpReg_11_20}},
-	{LBZ, 0xfc000000, 0x88000000, 0x0, // Load Byte and Zero D-form (lbz RT,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
-	{LBZU, 0xfc000000, 0x8c000000, 0x0, // Load Byte and Zero with Update D-form (lbzu RT,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
-	{LBZX, 0xfc0007fe, 0x7c0000ae, 0x1, // Load Byte and Zero Indexed X-form (lbzx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LBZUX, 0xfc0007fe, 0x7c0000ee, 0x1, // Load Byte and Zero with Update Indexed X-form (lbzux RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LHZ, 0xfc000000, 0xa0000000, 0x0, // Load Halfword and Zero D-form (lhz RT,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
-	{LHZU, 0xfc000000, 0xa4000000, 0x0, // Load Halfword and Zero with Update D-form (lhzu RT,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
-	{LHZX, 0xfc0007fe, 0x7c00022e, 0x1, // Load Halfword and Zero Indexed X-form (lhzx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LHZUX, 0xfc0007fe, 0x7c00026e, 0x1, // Load Halfword and Zero with Update Indexed X-form (lhzux RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LHA, 0xfc000000, 0xa8000000, 0x0, // Load Halfword Algebraic D-form (lha RT,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
-	{LHAU, 0xfc000000, 0xac000000, 0x0, // Load Halfword Algebraic with Update D-form (lhau RT,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
-	{LHAX, 0xfc0007fe, 0x7c0002ae, 0x1, // Load Halfword Algebraic Indexed X-form (lhax RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LHAUX, 0xfc0007fe, 0x7c0002ee, 0x1, // Load Halfword Algebraic with Update Indexed X-form (lhaux RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LWZ, 0xfc000000, 0x80000000, 0x0, // Load Word and Zero D-form (lwz RT,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
-	{LWZU, 0xfc000000, 0x84000000, 0x0, // Load Word and Zero with Update D-form (lwzu RT,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
-	{LWZX, 0xfc0007fe, 0x7c00002e, 0x1, // Load Word and Zero Indexed X-form (lwzx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LWZUX, 0xfc0007fe, 0x7c00006e, 0x1, // Load Word and Zero with Update Indexed X-form (lwzux RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LWA, 0xfc000003, 0xe8000002, 0x0, // Load Word Algebraic DS-form (lwa RT,DS(RA))
-		[5]*argField{ap_Reg_6_10, ap_Offset_16_29_shift2, ap_Reg_11_15}},
-	{LWAX, 0xfc0007fe, 0x7c0002aa, 0x1, // Load Word Algebraic Indexed X-form (lwax RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LWAUX, 0xfc0007fe, 0x7c0002ea, 0x1, // Load Word Algebraic with Update Indexed X-form (lwaux RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LD, 0xfc000003, 0xe8000000, 0x0, // Load Doubleword DS-form (ld RT,DS(RA))
-		[5]*argField{ap_Reg_6_10, ap_Offset_16_29_shift2, ap_Reg_11_15}},
-	{LDU, 0xfc000003, 0xe8000001, 0x0, // Load Doubleword with Update DS-form (ldu RT,DS(RA))
-		[5]*argField{ap_Reg_6_10, ap_Offset_16_29_shift2, ap_Reg_11_15}},
-	{LDX, 0xfc0007fe, 0x7c00002a, 0x1, // Load Doubleword Indexed X-form (ldx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LDUX, 0xfc0007fe, 0x7c00006a, 0x1, // Load Doubleword with Update Indexed X-form (ldux RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STB, 0xfc000000, 0x98000000, 0x0, // Store Byte D-form (stb RS,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
-	{STBU, 0xfc000000, 0x9c000000, 0x0, // Store Byte with Update D-form (stbu RS,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
-	{STBX, 0xfc0007fe, 0x7c0001ae, 0x1, // Store Byte Indexed X-form (stbx RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STBUX, 0xfc0007fe, 0x7c0001ee, 0x1, // Store Byte with Update Indexed X-form (stbux RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STH, 0xfc000000, 0xb0000000, 0x0, // Store Halfword D-form (sth RS,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
-	{STHU, 0xfc000000, 0xb4000000, 0x0, // Store Halfword with Update D-form (sthu RS,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
-	{STHX, 0xfc0007fe, 0x7c00032e, 0x1, // Store Halfword Indexed X-form (sthx RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STHUX, 0xfc0007fe, 0x7c00036e, 0x1, // Store Halfword with Update Indexed X-form (sthux RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STW, 0xfc000000, 0x90000000, 0x0, // Store Word D-form (stw RS,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
-	{STWU, 0xfc000000, 0x94000000, 0x0, // Store Word with Update D-form (stwu RS,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
-	{STWX, 0xfc0007fe, 0x7c00012e, 0x1, // Store Word Indexed X-form (stwx RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STWUX, 0xfc0007fe, 0x7c00016e, 0x1, // Store Word with Update Indexed X-form (stwux RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STD, 0xfc000003, 0xf8000000, 0x0, // Store Doubleword DS-form (std RS,DS(RA))
-		[5]*argField{ap_Reg_6_10, ap_Offset_16_29_shift2, ap_Reg_11_15}},
-	{STDU, 0xfc000003, 0xf8000001, 0x0, // Store Doubleword with Update DS-form (stdu RS,DS(RA))
-		[5]*argField{ap_Reg_6_10, ap_Offset_16_29_shift2, ap_Reg_11_15}},
-	{STDX, 0xfc0007fe, 0x7c00012a, 0x1, // Store Doubleword Indexed X-form (stdx RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STDUX, 0xfc0007fe, 0x7c00016a, 0x1, // Store Doubleword with Update Indexed X-form (stdux RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LQ, 0xfc000000, 0xe0000000, 0xf, // Load Quadword DQ-form (lq RTp,DQ(RA))
-		[5]*argField{ap_Reg_6_10, ap_Offset_16_27_shift4, ap_Reg_11_15}},
-	{STQ, 0xfc000003, 0xf8000002, 0x0, // Store Quadword DS-form (stq RSp,DS(RA))
-		[5]*argField{ap_Reg_6_10, ap_Offset_16_29_shift2, ap_Reg_11_15}},
-	{LHBRX, 0xfc0007fe, 0x7c00062c, 0x1, // Load Halfword Byte-Reverse Indexed X-form (lhbrx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LWBRX, 0xfc0007fe, 0x7c00042c, 0x1, // Load Word Byte-Reverse Indexed X-form (lwbrx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STHBRX, 0xfc0007fe, 0x7c00072c, 0x1, // Store Halfword Byte-Reverse Indexed X-form (sthbrx RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STWBRX, 0xfc0007fe, 0x7c00052c, 0x1, // Store Word Byte-Reverse Indexed X-form (stwbrx RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LDBRX, 0xfc0007fe, 0x7c000428, 0x1, // Load Doubleword Byte-Reverse Indexed X-form (ldbrx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STDBRX, 0xfc0007fe, 0x7c000528, 0x1, // Store Doubleword Byte-Reverse Indexed X-form (stdbrx RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LMW, 0xfc000000, 0xb8000000, 0x0, // Load Multiple Word D-form (lmw RT,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
-	{STMW, 0xfc000000, 0xbc000000, 0x0, // Store Multiple Word D-form (stmw RS,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
-	{LSWI, 0xfc0007fe, 0x7c0004aa, 0x1, // Load String Word Immediate X-form (lswi RT,RA,NB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_ImmUnsigned_16_20}},
-	{LSWX, 0xfc0007fe, 0x7c00042a, 0x1, // Load String Word Indexed X-form (lswx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STSWI, 0xfc0007fe, 0x7c0005aa, 0x1, // Store String Word Immediate X-form (stswi RS,RA,NB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_ImmUnsigned_16_20}},
-	{STSWX, 0xfc0007fe, 0x7c00052a, 0x1, // Store String Word Indexed X-form (stswx RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LI, 0xfc1f0000, 0x38000000, 0x0, // Add Immediate D-form (li RT,SI)
-		[5]*argField{ap_Reg_6_10, ap_ImmSigned_16_31}},
-	{ADDI, 0xfc000000, 0x38000000, 0x0, // Add Immediate D-form (addi RT,RA,SI)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_ImmSigned_16_31}},
-	{LIS, 0xfc1f0000, 0x3c000000, 0x0, // Add Immediate Shifted D-form (lis RT, SI)
-		[5]*argField{ap_Reg_6_10, ap_ImmSigned_16_31}},
-	{ADDIS, 0xfc000000, 0x3c000000, 0x0, // Add Immediate Shifted D-form (addis RT,RA,SI)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_ImmSigned_16_31}},
-	{ADD, 0xfc0007ff, 0x7c000214, 0x0, // Add XO-form (add RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{ADDCC, 0xfc0007ff, 0x7c000215, 0x0, // Add XO-form (add. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{ADDO, 0xfc0007ff, 0x7c000614, 0x0, // Add XO-form (addo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{ADDOCC, 0xfc0007ff, 0x7c000615, 0x0, // Add XO-form (addo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{ADDIC, 0xfc000000, 0x30000000, 0x0, // Add Immediate Carrying D-form (addic RT,RA,SI)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_ImmSigned_16_31}},
-	{SUBF, 0xfc0007ff, 0x7c000050, 0x0, // Subtract From XO-form (subf RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{SUBFCC, 0xfc0007ff, 0x7c000051, 0x0, // Subtract From XO-form (subf. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{SUBFO, 0xfc0007ff, 0x7c000450, 0x0, // Subtract From XO-form (subfo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{SUBFOCC, 0xfc0007ff, 0x7c000451, 0x0, // Subtract From XO-form (subfo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{ADDICCC, 0xfc000000, 0x34000000, 0x0, // Add Immediate Carrying and Record D-form (addic. RT,RA,SI)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_ImmSigned_16_31}},
-	{SUBFIC, 0xfc000000, 0x20000000, 0x0, // Subtract From Immediate Carrying D-form (subfic RT,RA,SI)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_ImmSigned_16_31}},
-	{ADDC, 0xfc0007ff, 0x7c000014, 0x0, // Add Carrying XO-form (addc RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{ADDCCC, 0xfc0007ff, 0x7c000015, 0x0, // Add Carrying XO-form (addc. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{ADDCO, 0xfc0007ff, 0x7c000414, 0x0, // Add Carrying XO-form (addco RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{ADDCOCC, 0xfc0007ff, 0x7c000415, 0x0, // Add Carrying XO-form (addco. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{SUBFC, 0xfc0007ff, 0x7c000010, 0x0, // Subtract From Carrying XO-form (subfc RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{SUBFCCC, 0xfc0007ff, 0x7c000011, 0x0, // Subtract From Carrying XO-form (subfc. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{SUBFCO, 0xfc0007ff, 0x7c000410, 0x0, // Subtract From Carrying XO-form (subfco RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{SUBFCOCC, 0xfc0007ff, 0x7c000411, 0x0, // Subtract From Carrying XO-form (subfco. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{ADDE, 0xfc0007ff, 0x7c000114, 0x0, // Add Extended XO-form (adde RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{ADDECC, 0xfc0007ff, 0x7c000115, 0x0, // Add Extended XO-form (adde. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{ADDEO, 0xfc0007ff, 0x7c000514, 0x0, // Add Extended XO-form (addeo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{ADDEOCC, 0xfc0007ff, 0x7c000515, 0x0, // Add Extended XO-form (addeo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{ADDME, 0xfc0007ff, 0x7c0001d4, 0xf800, // Add to Minus One Extended XO-form (addme RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{ADDMECC, 0xfc0007ff, 0x7c0001d5, 0xf800, // Add to Minus One Extended XO-form (addme. RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{ADDMEO, 0xfc0007ff, 0x7c0005d4, 0xf800, // Add to Minus One Extended XO-form (addmeo RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{ADDMEOCC, 0xfc0007ff, 0x7c0005d5, 0xf800, // Add to Minus One Extended XO-form (addmeo. RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{SUBFE, 0xfc0007ff, 0x7c000110, 0x0, // Subtract From Extended XO-form (subfe RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{SUBFECC, 0xfc0007ff, 0x7c000111, 0x0, // Subtract From Extended XO-form (subfe. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{SUBFEO, 0xfc0007ff, 0x7c000510, 0x0, // Subtract From Extended XO-form (subfeo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{SUBFEOCC, 0xfc0007ff, 0x7c000511, 0x0, // Subtract From Extended XO-form (subfeo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{SUBFME, 0xfc0007ff, 0x7c0001d0, 0xf800, // Subtract From Minus One Extended XO-form (subfme RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{SUBFMECC, 0xfc0007ff, 0x7c0001d1, 0xf800, // Subtract From Minus One Extended XO-form (subfme. RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{SUBFMEO, 0xfc0007ff, 0x7c0005d0, 0xf800, // Subtract From Minus One Extended XO-form (subfmeo RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{SUBFMEOCC, 0xfc0007ff, 0x7c0005d1, 0xf800, // Subtract From Minus One Extended XO-form (subfmeo. RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{ADDZE, 0xfc0007ff, 0x7c000194, 0xf800, // Add to Zero Extended XO-form (addze RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{ADDZECC, 0xfc0007ff, 0x7c000195, 0xf800, // Add to Zero Extended XO-form (addze. RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{ADDZEO, 0xfc0007ff, 0x7c000594, 0xf800, // Add to Zero Extended XO-form (addzeo RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{ADDZEOCC, 0xfc0007ff, 0x7c000595, 0xf800, // Add to Zero Extended XO-form (addzeo. RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{SUBFZE, 0xfc0007ff, 0x7c000190, 0xf800, // Subtract From Zero Extended XO-form (subfze RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{SUBFZECC, 0xfc0007ff, 0x7c000191, 0xf800, // Subtract From Zero Extended XO-form (subfze. RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{SUBFZEO, 0xfc0007ff, 0x7c000590, 0xf800, // Subtract From Zero Extended XO-form (subfzeo RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{SUBFZEOCC, 0xfc0007ff, 0x7c000591, 0xf800, // Subtract From Zero Extended XO-form (subfzeo. RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{NEG, 0xfc0007ff, 0x7c0000d0, 0xf800, // Negate XO-form (neg RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{NEGCC, 0xfc0007ff, 0x7c0000d1, 0xf800, // Negate XO-form (neg. RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{NEGO, 0xfc0007ff, 0x7c0004d0, 0xf800, // Negate XO-form (nego RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{NEGOCC, 0xfc0007ff, 0x7c0004d1, 0xf800, // Negate XO-form (nego. RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{MULLI, 0xfc000000, 0x1c000000, 0x0, // Multiply Low Immediate D-form (mulli RT,RA,SI)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_ImmSigned_16_31}},
-	{MULLW, 0xfc0007ff, 0x7c0001d6, 0x0, // Multiply Low Word XO-form (mullw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULLWCC, 0xfc0007ff, 0x7c0001d7, 0x0, // Multiply Low Word XO-form (mullw. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULLWO, 0xfc0007ff, 0x7c0005d6, 0x0, // Multiply Low Word XO-form (mullwo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULLWOCC, 0xfc0007ff, 0x7c0005d7, 0x0, // Multiply Low Word XO-form (mullwo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULHW, 0xfc0003ff, 0x7c000096, 0x400, // Multiply High Word XO-form (mulhw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULHWCC, 0xfc0003ff, 0x7c000097, 0x400, // Multiply High Word XO-form (mulhw. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULHWU, 0xfc0003ff, 0x7c000016, 0x400, // Multiply High Word Unsigned XO-form (mulhwu RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULHWUCC, 0xfc0003ff, 0x7c000017, 0x400, // Multiply High Word Unsigned XO-form (mulhwu. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVW, 0xfc0007ff, 0x7c0003d6, 0x0, // Divide Word XO-form (divw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVWCC, 0xfc0007ff, 0x7c0003d7, 0x0, // Divide Word XO-form (divw. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVWO, 0xfc0007ff, 0x7c0007d6, 0x0, // Divide Word XO-form (divwo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVWOCC, 0xfc0007ff, 0x7c0007d7, 0x0, // Divide Word XO-form (divwo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVWU, 0xfc0007ff, 0x7c000396, 0x0, // Divide Word Unsigned XO-form (divwu RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVWUCC, 0xfc0007ff, 0x7c000397, 0x0, // Divide Word Unsigned XO-form (divwu. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVWUO, 0xfc0007ff, 0x7c000796, 0x0, // Divide Word Unsigned XO-form (divwuo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVWUOCC, 0xfc0007ff, 0x7c000797, 0x0, // Divide Word Unsigned XO-form (divwuo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVWE, 0xfc0007ff, 0x7c000356, 0x0, // Divide Word Extended XO-form (divwe RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVWECC, 0xfc0007ff, 0x7c000357, 0x0, // Divide Word Extended XO-form (divwe. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVWEO, 0xfc0007ff, 0x7c000756, 0x0, // Divide Word Extended XO-form (divweo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVWEOCC, 0xfc0007ff, 0x7c000757, 0x0, // Divide Word Extended XO-form (divweo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVWEU, 0xfc0007ff, 0x7c000316, 0x0, // Divide Word Extended Unsigned XO-form (divweu RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVWEUCC, 0xfc0007ff, 0x7c000317, 0x0, // Divide Word Extended Unsigned XO-form (divweu. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVWEUO, 0xfc0007ff, 0x7c000716, 0x0, // Divide Word Extended Unsigned XO-form (divweuo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVWEUOCC, 0xfc0007ff, 0x7c000717, 0x0, // Divide Word Extended Unsigned XO-form (divweuo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULLD, 0xfc0007ff, 0x7c0001d2, 0x0, // Multiply Low Doubleword XO-form (mulld RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULLDCC, 0xfc0007ff, 0x7c0001d3, 0x0, // Multiply Low Doubleword XO-form (mulld. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULLDO, 0xfc0007ff, 0x7c0005d2, 0x0, // Multiply Low Doubleword XO-form (mulldo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULLDOCC, 0xfc0007ff, 0x7c0005d3, 0x0, // Multiply Low Doubleword XO-form (mulldo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULHDU, 0xfc0003ff, 0x7c000012, 0x400, // Multiply High Doubleword Unsigned XO-form (mulhdu RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULHDUCC, 0xfc0003ff, 0x7c000013, 0x400, // Multiply High Doubleword Unsigned XO-form (mulhdu. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULHD, 0xfc0003ff, 0x7c000092, 0x400, // Multiply High Doubleword XO-form (mulhd RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULHDCC, 0xfc0003ff, 0x7c000093, 0x400, // Multiply High Doubleword XO-form (mulhd. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVD, 0xfc0007ff, 0x7c0003d2, 0x0, // Divide Doubleword XO-form (divd RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVDCC, 0xfc0007ff, 0x7c0003d3, 0x0, // Divide Doubleword XO-form (divd. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVDO, 0xfc0007ff, 0x7c0007d2, 0x0, // Divide Doubleword XO-form (divdo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVDOCC, 0xfc0007ff, 0x7c0007d3, 0x0, // Divide Doubleword XO-form (divdo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVDU, 0xfc0007ff, 0x7c000392, 0x0, // Divide Doubleword Unsigned XO-form (divdu RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVDUCC, 0xfc0007ff, 0x7c000393, 0x0, // Divide Doubleword Unsigned XO-form (divdu. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVDUO, 0xfc0007ff, 0x7c000792, 0x0, // Divide Doubleword Unsigned XO-form (divduo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVDUOCC, 0xfc0007ff, 0x7c000793, 0x0, // Divide Doubleword Unsigned XO-form (divduo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVDE, 0xfc0007ff, 0x7c000352, 0x0, // Divide Doubleword Extended XO-form (divde RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVDECC, 0xfc0007ff, 0x7c000353, 0x0, // Divide Doubleword Extended XO-form (divde. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVDEO, 0xfc0007ff, 0x7c000752, 0x0, // Divide Doubleword Extended XO-form (divdeo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVDEOCC, 0xfc0007ff, 0x7c000753, 0x0, // Divide Doubleword Extended XO-form (divdeo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVDEU, 0xfc0007ff, 0x7c000312, 0x0, // Divide Doubleword Extended Unsigned XO-form (divdeu RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVDEUCC, 0xfc0007ff, 0x7c000313, 0x0, // Divide Doubleword Extended Unsigned XO-form (divdeu. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVDEUO, 0xfc0007ff, 0x7c000712, 0x0, // Divide Doubleword Extended Unsigned XO-form (divdeuo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DIVDEUOCC, 0xfc0007ff, 0x7c000713, 0x0, // Divide Doubleword Extended Unsigned XO-form (divdeuo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MODSD, 0xfc0007fe, 0x7c000612, 0x1, // Modulo Signed Doubleword X-form (modsd RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MODUD, 0xfc0007fe, 0x7c000212, 0x1, // Modulo Unsigned Doubleword X-form (modud RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MODSW, 0xfc0007fe, 0x7c000616, 0x1, // Modulo Signed Word X-form (modsw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MODUW, 0xfc0007fe, 0x7c000216, 0x1, // Modulo Unsigned Word X-form (moduw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{CMPWI, 0xfc200000, 0x2c000000, 0x400000, // Compare Immediate D-form (cmpwi BF,RA,SI)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_ImmSigned_16_31}},
-	{CMPDI, 0xfc200000, 0x2c200000, 0x400000, // Compare Immediate D-form (cmpdi BF,RA,SI)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_ImmSigned_16_31}},
-	{CMPW, 0xfc2007fe, 0x7c000000, 0x400001, // Compare X-form (cmpw BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{CMPD, 0xfc2007fe, 0x7c200000, 0x400001, // Compare X-form (cmpd BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{CMPLWI, 0xfc200000, 0x28000000, 0x400000, // Compare Logical Immediate D-form (cmplwi BF,RA,UI)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_ImmUnsigned_16_31}},
-	{CMPLDI, 0xfc200000, 0x28200000, 0x400000, // Compare Logical Immediate D-form (cmpldi BF,RA,UI)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_ImmUnsigned_16_31}},
-	{CMPLW, 0xfc2007fe, 0x7c000040, 0x400001, // Compare Logical X-form (cmplw BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{CMPLD, 0xfc2007fe, 0x7c200040, 0x400001, // Compare Logical X-form (cmpld BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{TWI, 0xfc000000, 0xc000000, 0x0, // Trap Word Immediate D-form (twi TO,RA,SI)
-		[5]*argField{ap_ImmUnsigned_6_10, ap_Reg_11_15, ap_ImmSigned_16_31}},
-	{TW, 0xfc0007fe, 0x7c000008, 0x1, // Trap Word X-form (tw TO,RA,RB)
-		[5]*argField{ap_ImmUnsigned_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{TDI, 0xfc000000, 0x8000000, 0x0, // Trap Doubleword Immediate D-form (tdi TO,RA,SI)
-		[5]*argField{ap_ImmUnsigned_6_10, ap_Reg_11_15, ap_ImmSigned_16_31}},
-	{ISEL, 0xfc00003e, 0x7c00001e, 0x1, // Integer Select A-form (isel RT,RA,RB,BC)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20, ap_CondRegBit_21_25}},
-	{TD, 0xfc0007fe, 0x7c000088, 0x1, // Trap Doubleword X-form (td TO,RA,RB)
-		[5]*argField{ap_ImmUnsigned_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{ANDICC, 0xfc000000, 0x70000000, 0x0, // AND Immediate D-form (andi. RA,RS,UI)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_16_31}},
-	{ANDISCC, 0xfc000000, 0x74000000, 0x0, // AND Immediate Shifted D-form (andis. RA,RS,UI)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_16_31}},
-	{ORI, 0xfc000000, 0x60000000, 0x0, // OR Immediate D-form (ori RA,RS,UI)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_16_31}},
-	{ORIS, 0xfc000000, 0x64000000, 0x0, // OR Immediate Shifted D-form (oris RA,RS,UI)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_16_31}},
-	{XORI, 0xfc000000, 0x68000000, 0x0, // XOR Immediate D-form (xori RA,RS,UI)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_16_31}},
-	{XORIS, 0xfc000000, 0x6c000000, 0x0, // XOR Immediate Shifted D-form (xoris RA,RS,UI)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_16_31}},
-	{AND, 0xfc0007ff, 0x7c000038, 0x0, // AND X-form (and RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{ANDCC, 0xfc0007ff, 0x7c000039, 0x0, // AND X-form (and. RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{XOR, 0xfc0007ff, 0x7c000278, 0x0, // XOR X-form (xor RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{XORCC, 0xfc0007ff, 0x7c000279, 0x0, // XOR X-form (xor. RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{NAND, 0xfc0007ff, 0x7c0003b8, 0x0, // NAND X-form (nand RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{NANDCC, 0xfc0007ff, 0x7c0003b9, 0x0, // NAND X-form (nand. RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{OR, 0xfc0007ff, 0x7c000378, 0x0, // OR X-form (or RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{ORCC, 0xfc0007ff, 0x7c000379, 0x0, // OR X-form (or. RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{NOR, 0xfc0007ff, 0x7c0000f8, 0x0, // NOR X-form (nor RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{NORCC, 0xfc0007ff, 0x7c0000f9, 0x0, // NOR X-form (nor. RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{ANDC, 0xfc0007ff, 0x7c000078, 0x0, // AND with Complement X-form (andc RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{ANDCCC, 0xfc0007ff, 0x7c000079, 0x0, // AND with Complement X-form (andc. RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{EXTSB, 0xfc0007ff, 0x7c000774, 0xf800, // Extend Sign Byte X-form (extsb RA,RS)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10}},
-	{EXTSBCC, 0xfc0007ff, 0x7c000775, 0xf800, // Extend Sign Byte X-form (extsb. RA,RS)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10}},
-	{EQV, 0xfc0007ff, 0x7c000238, 0x0, // Equivalent X-form (eqv RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{EQVCC, 0xfc0007ff, 0x7c000239, 0x0, // Equivalent X-form (eqv. RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{ORC, 0xfc0007ff, 0x7c000338, 0x0, // OR with Complement X-form (orc RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{ORCCC, 0xfc0007ff, 0x7c000339, 0x0, // OR with Complement X-form (orc. RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{EXTSH, 0xfc0007ff, 0x7c000734, 0xf800, // Extend Sign Halfword X-form (extsh RA,RS)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10}},
-	{EXTSHCC, 0xfc0007ff, 0x7c000735, 0xf800, // Extend Sign Halfword X-form (extsh. RA,RS)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10}},
-	{CMPB, 0xfc0007fe, 0x7c0003f8, 0x1, // Compare Bytes X-form (cmpb RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{POPCNTB, 0xfc0007fe, 0x7c0000f4, 0xf801, // Population Count Bytes X-form (popcntb RA, RS)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10}},
-	{POPCNTW, 0xfc0007fe, 0x7c0002f4, 0xf801, // Population Count Words X-form (popcntw RA, RS)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10}},
-	{PRTYD, 0xfc0007fe, 0x7c000174, 0xf801, // Parity Doubleword X-form (prtyd RA,RS)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10}},
-	{PRTYW, 0xfc0007fe, 0x7c000134, 0xf801, // Parity Word X-form (prtyw RA,RS)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10}},
-	{EXTSW, 0xfc0007ff, 0x7c0007b4, 0xf800, // Extend Sign Word X-form (extsw RA,RS)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10}},
-	{EXTSWCC, 0xfc0007ff, 0x7c0007b5, 0xf800, // Extend Sign Word X-form (extsw. RA,RS)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10}},
-	{CNTLZD, 0xfc0007ff, 0x7c000074, 0xf800, // Count Leading Zeros Doubleword X-form (cntlzd RA,RS)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10}},
-	{CNTLZDCC, 0xfc0007ff, 0x7c000075, 0xf800, // Count Leading Zeros Doubleword X-form (cntlzd. RA,RS)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10}},
-	{POPCNTD, 0xfc0007fe, 0x7c0003f4, 0xf801, // Population Count Doubleword X-form (popcntd RA, RS)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10}},
-	{BPERMD, 0xfc0007fe, 0x7c0001f8, 0x1, // Bit Permute Doubleword X-form (bpermd RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{RLWINM, 0xfc000001, 0x54000000, 0x0, // Rotate Left Word Immediate then AND with Mask M-form (rlwinm RA,RS,SH,MB,ME)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_ImmUnsigned_21_25, ap_ImmUnsigned_26_30}},
-	{RLWINMCC, 0xfc000001, 0x54000001, 0x0, // Rotate Left Word Immediate then AND with Mask M-form (rlwinm. RA,RS,SH,MB,ME)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_ImmUnsigned_21_25, ap_ImmUnsigned_26_30}},
-	{RLWNM, 0xfc000001, 0x5c000000, 0x0, // Rotate Left Word then AND with Mask M-form (rlwnm RA,RS,RB,MB,ME)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20, ap_ImmUnsigned_21_25, ap_ImmUnsigned_26_30}},
-	{RLWNMCC, 0xfc000001, 0x5c000001, 0x0, // Rotate Left Word then AND with Mask M-form (rlwnm. RA,RS,RB,MB,ME)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20, ap_ImmUnsigned_21_25, ap_ImmUnsigned_26_30}},
-	{RLWIMI, 0xfc000001, 0x50000000, 0x0, // Rotate Left Word Immediate then Mask Insert M-form (rlwimi RA,RS,SH,MB,ME)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_ImmUnsigned_21_25, ap_ImmUnsigned_26_30}},
-	{RLWIMICC, 0xfc000001, 0x50000001, 0x0, // Rotate Left Word Immediate then Mask Insert M-form (rlwimi. RA,RS,SH,MB,ME)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_ImmUnsigned_21_25, ap_ImmUnsigned_26_30}},
-	{RLDICL, 0xfc00001d, 0x78000000, 0x0, // Rotate Left Doubleword Immediate then Clear Left MD-form (rldicl RA,RS,SH,MB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_30_30_16_20, ap_ImmUnsigned_26_26_21_25}},
-	{RLDICLCC, 0xfc00001d, 0x78000001, 0x0, // Rotate Left Doubleword Immediate then Clear Left MD-form (rldicl. RA,RS,SH,MB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_30_30_16_20, ap_ImmUnsigned_26_26_21_25}},
-	{RLDICR, 0xfc00001d, 0x78000004, 0x0, // Rotate Left Doubleword Immediate then Clear Right MD-form (rldicr RA,RS,SH,ME)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_30_30_16_20, ap_ImmUnsigned_26_26_21_25}},
-	{RLDICRCC, 0xfc00001d, 0x78000005, 0x0, // Rotate Left Doubleword Immediate then Clear Right MD-form (rldicr. RA,RS,SH,ME)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_30_30_16_20, ap_ImmUnsigned_26_26_21_25}},
-	{RLDIC, 0xfc00001d, 0x78000008, 0x0, // Rotate Left Doubleword Immediate then Clear MD-form (rldic RA,RS,SH,MB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_30_30_16_20, ap_ImmUnsigned_26_26_21_25}},
-	{RLDICCC, 0xfc00001d, 0x78000009, 0x0, // Rotate Left Doubleword Immediate then Clear MD-form (rldic. RA,RS,SH,MB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_30_30_16_20, ap_ImmUnsigned_26_26_21_25}},
-	{RLDCL, 0xfc00001f, 0x78000010, 0x0, // Rotate Left Doubleword then Clear Left MDS-form (rldcl RA,RS,RB,MB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20, ap_ImmUnsigned_26_26_21_25}},
-	{RLDCLCC, 0xfc00001f, 0x78000011, 0x0, // Rotate Left Doubleword then Clear Left MDS-form (rldcl. RA,RS,RB,MB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20, ap_ImmUnsigned_26_26_21_25}},
-	{RLDCR, 0xfc00001f, 0x78000012, 0x0, // Rotate Left Doubleword then Clear Right MDS-form (rldcr RA,RS,RB,ME)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20, ap_ImmUnsigned_26_26_21_25}},
-	{RLDCRCC, 0xfc00001f, 0x78000013, 0x0, // Rotate Left Doubleword then Clear Right MDS-form (rldcr. RA,RS,RB,ME)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20, ap_ImmUnsigned_26_26_21_25}},
-	{RLDIMI, 0xfc00001d, 0x7800000c, 0x0, // Rotate Left Doubleword Immediate then Mask Insert MD-form (rldimi RA,RS,SH,MB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_30_30_16_20, ap_ImmUnsigned_26_26_21_25}},
-	{RLDIMICC, 0xfc00001d, 0x7800000d, 0x0, // Rotate Left Doubleword Immediate then Mask Insert MD-form (rldimi. RA,RS,SH,MB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_30_30_16_20, ap_ImmUnsigned_26_26_21_25}},
-	{SLW, 0xfc0007ff, 0x7c000030, 0x0, // Shift Left Word X-form (slw RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{SLWCC, 0xfc0007ff, 0x7c000031, 0x0, // Shift Left Word X-form (slw. RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{SRW, 0xfc0007ff, 0x7c000430, 0x0, // Shift Right Word X-form (srw RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{SRWCC, 0xfc0007ff, 0x7c000431, 0x0, // Shift Right Word X-form (srw. RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{SRAWI, 0xfc0007ff, 0x7c000670, 0x0, // Shift Right Algebraic Word Immediate X-form (srawi RA,RS,SH)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_16_20}},
-	{SRAWICC, 0xfc0007ff, 0x7c000671, 0x0, // Shift Right Algebraic Word Immediate X-form (srawi. RA,RS,SH)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_16_20}},
-	{SRAW, 0xfc0007ff, 0x7c000630, 0x0, // Shift Right Algebraic Word X-form (sraw RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{SRAWCC, 0xfc0007ff, 0x7c000631, 0x0, // Shift Right Algebraic Word X-form (sraw. RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{SLD, 0xfc0007ff, 0x7c000036, 0x0, // Shift Left Doubleword X-form (sld RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{SLDCC, 0xfc0007ff, 0x7c000037, 0x0, // Shift Left Doubleword X-form (sld. RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{SRD, 0xfc0007ff, 0x7c000436, 0x0, // Shift Right Doubleword X-form (srd RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{SRDCC, 0xfc0007ff, 0x7c000437, 0x0, // Shift Right Doubleword X-form (srd. RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{SRADI, 0xfc0007fd, 0x7c000674, 0x0, // Shift Right Algebraic Doubleword Immediate XS-form (sradi RA,RS,SH)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_30_30_16_20}},
-	{SRADICC, 0xfc0007fd, 0x7c000675, 0x0, // Shift Right Algebraic Doubleword Immediate XS-form (sradi. RA,RS,SH)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_30_30_16_20}},
-	{SRAD, 0xfc0007ff, 0x7c000634, 0x0, // Shift Right Algebraic Doubleword X-form (srad RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{SRADCC, 0xfc0007ff, 0x7c000635, 0x0, // Shift Right Algebraic Doubleword X-form (srad. RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{CDTBCD, 0xfc0007fe, 0x7c000234, 0xf801, // Convert Declets To Binary Coded Decimal X-form (cdtbcd RA, RS)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10}},
-	{CBCDTD, 0xfc0007fe, 0x7c000274, 0xf801, // Convert Binary Coded Decimal To Declets X-form (cbcdtd RA, RS)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10}},
-	{ADDG6S, 0xfc0003fe, 0x7c000094, 0x401, // Add and Generate Sixes XO-form (addg6s RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MTSPR, 0xfc0007fe, 0x7c0003a6, 0x1, // Move To Special Purpose Register XFX-form (mtspr SPR,RS)
-		[5]*argField{ap_SpReg_16_20_11_15, ap_Reg_6_10}},
-	{MFSPR, 0xfc0007fe, 0x7c0002a6, 0x1, // Move From Special Purpose Register XFX-form (mfspr RT,SPR)
-		[5]*argField{ap_Reg_6_10, ap_SpReg_16_20_11_15}},
-	{MTCRF, 0xfc1007fe, 0x7c000120, 0x801, // Move To Condition Register Fields XFX-form (mtcrf FXM,RS)
-		[5]*argField{ap_ImmUnsigned_12_19, ap_Reg_6_10}},
-	{MFCR, 0xfc1007fe, 0x7c000026, 0xff801, // Move From Condition Register XFX-form (mfcr RT)
-		[5]*argField{ap_Reg_6_10}},
-	{MTSLE, 0xfc0007fe, 0x7c000126, 0x3dff801, // Move To Split Little Endian X-form (mtsle L)
-		[5]*argField{ap_ImmUnsigned_10_10}},
-	{MFVSRD, 0xfc0007fe, 0x7c000066, 0xf800, // Move From VSR Doubleword XX1-form (mfvsrd RA,XS)
-		[5]*argField{ap_Reg_11_15, ap_VecSReg_31_31_6_10}},
-	{MFVSRWZ, 0xfc0007fe, 0x7c0000e6, 0xf800, // Move From VSR Word and Zero XX1-form (mfvsrwz RA,XS)
-		[5]*argField{ap_Reg_11_15, ap_VecSReg_31_31_6_10}},
-	{MTVSRD, 0xfc0007fe, 0x7c000166, 0xf800, // Move To VSR Doubleword XX1-form (mtvsrd XT,RA)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15}},
-	{MTVSRWA, 0xfc0007fe, 0x7c0001a6, 0xf800, // Move To VSR Word Algebraic XX1-form (mtvsrwa XT,RA)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15}},
-	{MTVSRWZ, 0xfc0007fe, 0x7c0001e6, 0xf800, // Move To VSR Word and Zero XX1-form (mtvsrwz XT,RA)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15}},
-	{MTOCRF, 0xfc1007fe, 0x7c100120, 0x801, // Move To One Condition Register Field XFX-form (mtocrf FXM,RS)
-		[5]*argField{ap_ImmUnsigned_12_19, ap_Reg_6_10}},
-	{MFOCRF, 0xfc1007fe, 0x7c100026, 0x801, // Move From One Condition Register Field XFX-form (mfocrf RT,FXM)
-		[5]*argField{ap_Reg_6_10, ap_ImmUnsigned_12_19}},
-	{MCRXR, 0xfc0007fe, 0x7c000400, 0x7ff801, // Move to Condition Register from XER X-form (mcrxr BF)
-		[5]*argField{ap_CondRegField_6_8}},
-	{MTDCRUX, 0xfc0007fe, 0x7c000346, 0xf801, // Move To Device Control Register User-mode Indexed X-form (mtdcrux RS,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{MFDCRUX, 0xfc0007fe, 0x7c000246, 0xf801, // Move From Device Control Register User-mode Indexed X-form (mfdcrux RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{LFS, 0xfc000000, 0xc0000000, 0x0, // Load Floating-Point Single D-form (lfs FRT,D(RA))
-		[5]*argField{ap_FPReg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
-	{LFSU, 0xfc000000, 0xc4000000, 0x0, // Load Floating-Point Single with Update D-form (lfsu FRT,D(RA))
-		[5]*argField{ap_FPReg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
-	{LFSX, 0xfc0007fe, 0x7c00042e, 0x1, // Load Floating-Point Single Indexed X-form (lfsx FRT,RA,RB)
-		[5]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LFSUX, 0xfc0007fe, 0x7c00046e, 0x1, // Load Floating-Point Single with Update Indexed X-form (lfsux FRT,RA,RB)
-		[5]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LFD, 0xfc000000, 0xc8000000, 0x0, // Load Floating-Point Double D-form (lfd FRT,D(RA))
-		[5]*argField{ap_FPReg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
-	{LFDU, 0xfc000000, 0xcc000000, 0x0, // Load Floating-Point Double with Update D-form (lfdu FRT,D(RA))
-		[5]*argField{ap_FPReg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
-	{LFDX, 0xfc0007fe, 0x7c0004ae, 0x1, // Load Floating-Point Double Indexed X-form (lfdx FRT,RA,RB)
-		[5]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LFDUX, 0xfc0007fe, 0x7c0004ee, 0x1, // Load Floating-Point Double with Update Indexed X-form (lfdux FRT,RA,RB)
-		[5]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LFIWAX, 0xfc0007fe, 0x7c0006ae, 0x1, // Load Floating-Point as Integer Word Algebraic Indexed X-form (lfiwax FRT,RA,RB)
-		[5]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LFIWZX, 0xfc0007fe, 0x7c0006ee, 0x1, // Load Floating-Point as Integer Word and Zero Indexed X-form (lfiwzx FRT,RA,RB)
-		[5]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STFS, 0xfc000000, 0xd0000000, 0x0, // Store Floating-Point Single D-form (stfs FRS,D(RA))
-		[5]*argField{ap_FPReg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
-	{STFSU, 0xfc000000, 0xd4000000, 0x0, // Store Floating-Point Single with Update D-form (stfsu FRS,D(RA))
-		[5]*argField{ap_FPReg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
-	{STFSX, 0xfc0007fe, 0x7c00052e, 0x1, // Store Floating-Point Single Indexed X-form (stfsx FRS,RA,RB)
-		[5]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STFSUX, 0xfc0007fe, 0x7c00056e, 0x1, // Store Floating-Point Single with Update Indexed X-form (stfsux FRS,RA,RB)
-		[5]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STFD, 0xfc000000, 0xd8000000, 0x0, // Store Floating-Point Double D-form (stfd FRS,D(RA))
-		[5]*argField{ap_FPReg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
-	{STFDU, 0xfc000000, 0xdc000000, 0x0, // Store Floating-Point Double with Update D-form (stfdu FRS,D(RA))
-		[5]*argField{ap_FPReg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
-	{STFDX, 0xfc0007fe, 0x7c0005ae, 0x1, // Store Floating-Point Double Indexed X-form (stfdx FRS,RA,RB)
-		[5]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STFDUX, 0xfc0007fe, 0x7c0005ee, 0x1, // Store Floating-Point Double with Update Indexed X-form (stfdux FRS,RA,RB)
-		[5]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STFIWX, 0xfc0007fe, 0x7c0007ae, 0x1, // Store Floating-Point as Integer Word Indexed X-form (stfiwx FRS,RA,RB)
-		[5]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LFDP, 0xfc000003, 0xe4000000, 0x0, // Load Floating-Point Double Pair DS-form (lfdp FRTp,DS(RA))
-		[5]*argField{ap_FPReg_6_10, ap_Offset_16_29_shift2, ap_Reg_11_15}},
-	{LFDPX, 0xfc0007fe, 0x7c00062e, 0x1, // Load Floating-Point Double Pair Indexed X-form (lfdpx FRTp,RA,RB)
-		[5]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STFDP, 0xfc000003, 0xf4000000, 0x0, // Store Floating-Point Double Pair DS-form (stfdp FRSp,DS(RA))
-		[5]*argField{ap_FPReg_6_10, ap_Offset_16_29_shift2, ap_Reg_11_15}},
-	{STFDPX, 0xfc0007fe, 0x7c00072e, 0x1, // Store Floating-Point Double Pair Indexed X-form (stfdpx FRSp,RA,RB)
-		[5]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{FMR, 0xfc0007ff, 0xfc000090, 0x1f0000, // Floating Move Register X-form (fmr FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FMRCC, 0xfc0007ff, 0xfc000091, 0x1f0000, // Floating Move Register X-form (fmr. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FABS, 0xfc0007ff, 0xfc000210, 0x1f0000, // Floating Absolute Value X-form (fabs FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FABSCC, 0xfc0007ff, 0xfc000211, 0x1f0000, // Floating Absolute Value X-form (fabs. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FNABS, 0xfc0007ff, 0xfc000110, 0x1f0000, // Floating Negative Absolute Value X-form (fnabs FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FNABSCC, 0xfc0007ff, 0xfc000111, 0x1f0000, // Floating Negative Absolute Value X-form (fnabs. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FNEG, 0xfc0007ff, 0xfc000050, 0x1f0000, // Floating Negate X-form (fneg FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FNEGCC, 0xfc0007ff, 0xfc000051, 0x1f0000, // Floating Negate X-form (fneg. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCPSGN, 0xfc0007ff, 0xfc000010, 0x0, // Floating Copy Sign X-form (fcpsgn FRT, FRA, FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{FCPSGNCC, 0xfc0007ff, 0xfc000011, 0x0, // Floating Copy Sign X-form (fcpsgn. FRT, FRA, FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{FMRGEW, 0xfc0007fe, 0xfc00078c, 0x1, // Floating Merge Even Word X-form (fmrgew FRT,FRA,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{FMRGOW, 0xfc0007fe, 0xfc00068c, 0x1, // Floating Merge Odd Word X-form (fmrgow FRT,FRA,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{FADD, 0xfc00003f, 0xfc00002a, 0x7c0, // Floating Add [Single] A-form (fadd FRT,FRA,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{FADDCC, 0xfc00003f, 0xfc00002b, 0x7c0, // Floating Add [Single] A-form (fadd. FRT,FRA,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{FADDS, 0xfc00003f, 0xec00002a, 0x7c0, // Floating Add [Single] A-form (fadds FRT,FRA,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{FADDSCC, 0xfc00003f, 0xec00002b, 0x7c0, // Floating Add [Single] A-form (fadds. FRT,FRA,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{FSUB, 0xfc00003f, 0xfc000028, 0x7c0, // Floating Subtract [Single] A-form (fsub FRT,FRA,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{FSUBCC, 0xfc00003f, 0xfc000029, 0x7c0, // Floating Subtract [Single] A-form (fsub. FRT,FRA,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{FSUBS, 0xfc00003f, 0xec000028, 0x7c0, // Floating Subtract [Single] A-form (fsubs FRT,FRA,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{FSUBSCC, 0xfc00003f, 0xec000029, 0x7c0, // Floating Subtract [Single] A-form (fsubs. FRT,FRA,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{FMUL, 0xfc00003f, 0xfc000032, 0xf800, // Floating Multiply [Single] A-form (fmul FRT,FRA,FRC)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25}},
-	{FMULCC, 0xfc00003f, 0xfc000033, 0xf800, // Floating Multiply [Single] A-form (fmul. FRT,FRA,FRC)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25}},
-	{FMULS, 0xfc00003f, 0xec000032, 0xf800, // Floating Multiply [Single] A-form (fmuls FRT,FRA,FRC)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25}},
-	{FMULSCC, 0xfc00003f, 0xec000033, 0xf800, // Floating Multiply [Single] A-form (fmuls. FRT,FRA,FRC)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25}},
-	{FDIV, 0xfc00003f, 0xfc000024, 0x7c0, // Floating Divide [Single] A-form (fdiv FRT,FRA,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{FDIVCC, 0xfc00003f, 0xfc000025, 0x7c0, // Floating Divide [Single] A-form (fdiv. FRT,FRA,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{FDIVS, 0xfc00003f, 0xec000024, 0x7c0, // Floating Divide [Single] A-form (fdivs FRT,FRA,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{FDIVSCC, 0xfc00003f, 0xec000025, 0x7c0, // Floating Divide [Single] A-form (fdivs. FRT,FRA,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{FSQRT, 0xfc00003f, 0xfc00002c, 0x1f07c0, // Floating Square Root [Single] A-form (fsqrt FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FSQRTCC, 0xfc00003f, 0xfc00002d, 0x1f07c0, // Floating Square Root [Single] A-form (fsqrt. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FSQRTS, 0xfc00003f, 0xec00002c, 0x1f07c0, // Floating Square Root [Single] A-form (fsqrts FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FSQRTSCC, 0xfc00003f, 0xec00002d, 0x1f07c0, // Floating Square Root [Single] A-form (fsqrts. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FRE, 0xfc00003f, 0xfc000030, 0x1f07c0, // Floating Reciprocal Estimate [Single] A-form (fre FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FRECC, 0xfc00003f, 0xfc000031, 0x1f07c0, // Floating Reciprocal Estimate [Single] A-form (fre. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FRES, 0xfc00003f, 0xec000030, 0x1f07c0, // Floating Reciprocal Estimate [Single] A-form (fres FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FRESCC, 0xfc00003f, 0xec000031, 0x1f07c0, // Floating Reciprocal Estimate [Single] A-form (fres. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FRSQRTE, 0xfc00003f, 0xfc000034, 0x1f07c0, // Floating Reciprocal Square Root Estimate [Single] A-form (frsqrte FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FRSQRTECC, 0xfc00003f, 0xfc000035, 0x1f07c0, // Floating Reciprocal Square Root Estimate [Single] A-form (frsqrte. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FRSQRTES, 0xfc00003f, 0xec000034, 0x1f07c0, // Floating Reciprocal Square Root Estimate [Single] A-form (frsqrtes FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FRSQRTESCC, 0xfc00003f, 0xec000035, 0x1f07c0, // Floating Reciprocal Square Root Estimate [Single] A-form (frsqrtes. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FTDIV, 0xfc0007fe, 0xfc000100, 0x600001, // Floating Test for software Divide X-form (ftdiv BF,FRA,FRB)
-		[5]*argField{ap_CondRegField_6_8, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{FTSQRT, 0xfc0007fe, 0xfc000140, 0x7f0001, // Floating Test for software Square Root X-form (ftsqrt BF,FRB)
-		[5]*argField{ap_CondRegField_6_8, ap_FPReg_16_20}},
-	{FMADD, 0xfc00003f, 0xfc00003a, 0x0, // Floating Multiply-Add [Single] A-form (fmadd FRT,FRA,FRC,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
-	{FMADDCC, 0xfc00003f, 0xfc00003b, 0x0, // Floating Multiply-Add [Single] A-form (fmadd. FRT,FRA,FRC,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
-	{FMADDS, 0xfc00003f, 0xec00003a, 0x0, // Floating Multiply-Add [Single] A-form (fmadds FRT,FRA,FRC,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
-	{FMADDSCC, 0xfc00003f, 0xec00003b, 0x0, // Floating Multiply-Add [Single] A-form (fmadds. FRT,FRA,FRC,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
-	{FMSUB, 0xfc00003f, 0xfc000038, 0x0, // Floating Multiply-Subtract [Single] A-form (fmsub FRT,FRA,FRC,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
-	{FMSUBCC, 0xfc00003f, 0xfc000039, 0x0, // Floating Multiply-Subtract [Single] A-form (fmsub. FRT,FRA,FRC,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
-	{FMSUBS, 0xfc00003f, 0xec000038, 0x0, // Floating Multiply-Subtract [Single] A-form (fmsubs FRT,FRA,FRC,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
-	{FMSUBSCC, 0xfc00003f, 0xec000039, 0x0, // Floating Multiply-Subtract [Single] A-form (fmsubs. FRT,FRA,FRC,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
-	{FNMADD, 0xfc00003f, 0xfc00003e, 0x0, // Floating Negative Multiply-Add [Single] A-form (fnmadd FRT,FRA,FRC,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
-	{FNMADDCC, 0xfc00003f, 0xfc00003f, 0x0, // Floating Negative Multiply-Add [Single] A-form (fnmadd. FRT,FRA,FRC,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
-	{FNMADDS, 0xfc00003f, 0xec00003e, 0x0, // Floating Negative Multiply-Add [Single] A-form (fnmadds FRT,FRA,FRC,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
-	{FNMADDSCC, 0xfc00003f, 0xec00003f, 0x0, // Floating Negative Multiply-Add [Single] A-form (fnmadds. FRT,FRA,FRC,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
-	{FNMSUB, 0xfc00003f, 0xfc00003c, 0x0, // Floating Negative Multiply-Subtract [Single] A-form (fnmsub FRT,FRA,FRC,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
-	{FNMSUBCC, 0xfc00003f, 0xfc00003d, 0x0, // Floating Negative Multiply-Subtract [Single] A-form (fnmsub. FRT,FRA,FRC,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
-	{FNMSUBS, 0xfc00003f, 0xec00003c, 0x0, // Floating Negative Multiply-Subtract [Single] A-form (fnmsubs FRT,FRA,FRC,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
-	{FNMSUBSCC, 0xfc00003f, 0xec00003d, 0x0, // Floating Negative Multiply-Subtract [Single] A-form (fnmsubs. FRT,FRA,FRC,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
-	{FRSP, 0xfc0007ff, 0xfc000018, 0x1f0000, // Floating Round to Single-Precision X-form (frsp FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FRSPCC, 0xfc0007ff, 0xfc000019, 0x1f0000, // Floating Round to Single-Precision X-form (frsp. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCTID, 0xfc0007ff, 0xfc00065c, 0x1f0000, // Floating Convert To Integer Doubleword X-form (fctid FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCTIDCC, 0xfc0007ff, 0xfc00065d, 0x1f0000, // Floating Convert To Integer Doubleword X-form (fctid. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCTIDZ, 0xfc0007ff, 0xfc00065e, 0x1f0000, // Floating Convert To Integer Doubleword with round toward Zero X-form (fctidz FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCTIDZCC, 0xfc0007ff, 0xfc00065f, 0x1f0000, // Floating Convert To Integer Doubleword with round toward Zero X-form (fctidz. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCTIDU, 0xfc0007ff, 0xfc00075c, 0x1f0000, // Floating Convert To Integer Doubleword Unsigned X-form (fctidu FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCTIDUCC, 0xfc0007ff, 0xfc00075d, 0x1f0000, // Floating Convert To Integer Doubleword Unsigned X-form (fctidu. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCTIDUZ, 0xfc0007ff, 0xfc00075e, 0x1f0000, // Floating Convert To Integer Doubleword Unsigned with round toward Zero X-form (fctiduz FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCTIDUZCC, 0xfc0007ff, 0xfc00075f, 0x1f0000, // Floating Convert To Integer Doubleword Unsigned with round toward Zero X-form (fctiduz. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCTIW, 0xfc0007ff, 0xfc00001c, 0x1f0000, // Floating Convert To Integer Word X-form (fctiw FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCTIWCC, 0xfc0007ff, 0xfc00001d, 0x1f0000, // Floating Convert To Integer Word X-form (fctiw. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCTIWZ, 0xfc0007ff, 0xfc00001e, 0x1f0000, // Floating Convert To Integer Word with round toward Zero X-form (fctiwz FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCTIWZCC, 0xfc0007ff, 0xfc00001f, 0x1f0000, // Floating Convert To Integer Word with round toward Zero X-form (fctiwz. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCTIWU, 0xfc0007ff, 0xfc00011c, 0x1f0000, // Floating Convert To Integer Word Unsigned X-form (fctiwu FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCTIWUCC, 0xfc0007ff, 0xfc00011d, 0x1f0000, // Floating Convert To Integer Word Unsigned X-form (fctiwu. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCTIWUZ, 0xfc0007ff, 0xfc00011e, 0x1f0000, // Floating Convert To Integer Word Unsigned with round toward Zero X-form (fctiwuz FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCTIWUZCC, 0xfc0007ff, 0xfc00011f, 0x1f0000, // Floating Convert To Integer Word Unsigned with round toward Zero X-form (fctiwuz. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCFID, 0xfc0007ff, 0xfc00069c, 0x1f0000, // Floating Convert From Integer Doubleword X-form (fcfid FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCFIDCC, 0xfc0007ff, 0xfc00069d, 0x1f0000, // Floating Convert From Integer Doubleword X-form (fcfid. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCFIDU, 0xfc0007ff, 0xfc00079c, 0x1f0000, // Floating Convert From Integer Doubleword Unsigned X-form (fcfidu FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCFIDUCC, 0xfc0007ff, 0xfc00079d, 0x1f0000, // Floating Convert From Integer Doubleword Unsigned X-form (fcfidu. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCFIDS, 0xfc0007ff, 0xec00069c, 0x1f0000, // Floating Convert From Integer Doubleword Single X-form (fcfids FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCFIDSCC, 0xfc0007ff, 0xec00069d, 0x1f0000, // Floating Convert From Integer Doubleword Single X-form (fcfids. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCFIDUS, 0xfc0007ff, 0xec00079c, 0x1f0000, // Floating Convert From Integer Doubleword Unsigned Single X-form (fcfidus FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCFIDUSCC, 0xfc0007ff, 0xec00079d, 0x1f0000, // Floating Convert From Integer Doubleword Unsigned Single X-form (fcfidus. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FRIN, 0xfc0007ff, 0xfc000310, 0x1f0000, // Floating Round to Integer Nearest X-form (frin FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FRINCC, 0xfc0007ff, 0xfc000311, 0x1f0000, // Floating Round to Integer Nearest X-form (frin. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FRIZ, 0xfc0007ff, 0xfc000350, 0x1f0000, // Floating Round to Integer Toward Zero X-form (friz FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FRIZCC, 0xfc0007ff, 0xfc000351, 0x1f0000, // Floating Round to Integer Toward Zero X-form (friz. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FRIP, 0xfc0007ff, 0xfc000390, 0x1f0000, // Floating Round to Integer Plus X-form (frip FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FRIPCC, 0xfc0007ff, 0xfc000391, 0x1f0000, // Floating Round to Integer Plus X-form (frip. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FRIM, 0xfc0007ff, 0xfc0003d0, 0x1f0000, // Floating Round to Integer Minus X-form (frim FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FRIMCC, 0xfc0007ff, 0xfc0003d1, 0x1f0000, // Floating Round to Integer Minus X-form (frim. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{FCMPU, 0xfc0007fe, 0xfc000000, 0x600001, // Floating Compare Unordered X-form (fcmpu BF,FRA,FRB)
-		[5]*argField{ap_CondRegField_6_8, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{FCMPO, 0xfc0007fe, 0xfc000040, 0x600001, // Floating Compare Ordered X-form (fcmpo BF,FRA,FRB)
-		[5]*argField{ap_CondRegField_6_8, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{FSEL, 0xfc00003f, 0xfc00002e, 0x0, // Floating Select A-form (fsel FRT,FRA,FRC,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
-	{FSELCC, 0xfc00003f, 0xfc00002f, 0x0, // Floating Select A-form (fsel. FRT,FRA,FRC,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
-	{MFFS, 0xfc0007ff, 0xfc00048e, 0x1ff800, // Move From FPSCR X-form (mffs FRT)
-		[5]*argField{ap_FPReg_6_10}},
-	{MFFSCC, 0xfc0007ff, 0xfc00048f, 0x1ff800, // Move From FPSCR X-form (mffs. FRT)
-		[5]*argField{ap_FPReg_6_10}},
-	{MCRFS, 0xfc0007fe, 0xfc000080, 0x63f801, // Move to Condition Register from FPSCR X-form (mcrfs BF,BFA)
-		[5]*argField{ap_CondRegField_6_8, ap_CondRegField_11_13}},
-	{MTFSFI, 0xfc0007ff, 0xfc00010c, 0x7e0800, // Move To FPSCR Field Immediate X-form (mtfsfi BF,U,W)
-		[5]*argField{ap_ImmUnsigned_6_8, ap_ImmUnsigned_16_19, ap_ImmUnsigned_15_15}},
-	{MTFSFICC, 0xfc0007ff, 0xfc00010d, 0x7e0800, // Move To FPSCR Field Immediate X-form (mtfsfi. BF,U,W)
-		[5]*argField{ap_ImmUnsigned_6_8, ap_ImmUnsigned_16_19, ap_ImmUnsigned_15_15}},
-	{MTFSF, 0xfc0007ff, 0xfc00058e, 0x0, // Move To FPSCR Fields XFL-form (mtfsf FLM,FRB,L,W)
-		[5]*argField{ap_ImmUnsigned_7_14, ap_FPReg_16_20, ap_ImmUnsigned_6_6, ap_ImmUnsigned_15_15}},
-	{MTFSFCC, 0xfc0007ff, 0xfc00058f, 0x0, // Move To FPSCR Fields XFL-form (mtfsf. FLM,FRB,L,W)
-		[5]*argField{ap_ImmUnsigned_7_14, ap_FPReg_16_20, ap_ImmUnsigned_6_6, ap_ImmUnsigned_15_15}},
-	{MTFSB0, 0xfc0007ff, 0xfc00008c, 0x1ff800, // Move To FPSCR Bit 0 X-form (mtfsb0 BT)
-		[5]*argField{ap_ImmUnsigned_6_10}},
-	{MTFSB0CC, 0xfc0007ff, 0xfc00008d, 0x1ff800, // Move To FPSCR Bit 0 X-form (mtfsb0. BT)
-		[5]*argField{ap_ImmUnsigned_6_10}},
-	{MTFSB1, 0xfc0007ff, 0xfc00004c, 0x1ff800, // Move To FPSCR Bit 1 X-form (mtfsb1 BT)
-		[5]*argField{ap_ImmUnsigned_6_10}},
-	{MTFSB1CC, 0xfc0007ff, 0xfc00004d, 0x1ff800, // Move To FPSCR Bit 1 X-form (mtfsb1. BT)
-		[5]*argField{ap_ImmUnsigned_6_10}},
-	{LVEBX, 0xfc0007fe, 0x7c00000e, 0x1, // Load Vector Element Byte Indexed X-form (lvebx VRT,RA,RB)
-		[5]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LVEHX, 0xfc0007fe, 0x7c00004e, 0x1, // Load Vector Element Halfword Indexed X-form (lvehx VRT,RA,RB)
-		[5]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LVEWX, 0xfc0007fe, 0x7c00008e, 0x1, // Load Vector Element Word Indexed X-form (lvewx VRT,RA,RB)
-		[5]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LVX, 0xfc0007fe, 0x7c0000ce, 0x1, // Load Vector Indexed X-form (lvx VRT,RA,RB)
-		[5]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LVXL, 0xfc0007fe, 0x7c0002ce, 0x1, // Load Vector Indexed LRU X-form (lvxl VRT,RA,RB)
-		[5]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STVEBX, 0xfc0007fe, 0x7c00010e, 0x1, // Store Vector Element Byte Indexed X-form (stvebx VRS,RA,RB)
-		[5]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STVEHX, 0xfc0007fe, 0x7c00014e, 0x1, // Store Vector Element Halfword Indexed X-form (stvehx VRS,RA,RB)
-		[5]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STVEWX, 0xfc0007fe, 0x7c00018e, 0x1, // Store Vector Element Word Indexed X-form (stvewx VRS,RA,RB)
-		[5]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STVX, 0xfc0007fe, 0x7c0001ce, 0x1, // Store Vector Indexed X-form (stvx VRS,RA,RB)
-		[5]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STVXL, 0xfc0007fe, 0x7c0003ce, 0x1, // Store Vector Indexed LRU X-form (stvxl VRS,RA,RB)
-		[5]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LVSL, 0xfc0007fe, 0x7c00000c, 0x1, // Load Vector for Shift Left Indexed X-form (lvsl VRT,RA,RB)
-		[5]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LVSR, 0xfc0007fe, 0x7c00004c, 0x1, // Load Vector for Shift Right Indexed X-form (lvsr VRT,RA,RB)
-		[5]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{VPKPX, 0xfc0007ff, 0x1000030e, 0x0, // Vector Pack Pixel VX-form (vpkpx VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VPKSDSS, 0xfc0007ff, 0x100005ce, 0x0, // Vector Pack Signed Doubleword Signed Saturate VX-form (vpksdss VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VPKSDUS, 0xfc0007ff, 0x1000054e, 0x0, // Vector Pack Signed Doubleword Unsigned Saturate VX-form (vpksdus VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VPKSHSS, 0xfc0007ff, 0x1000018e, 0x0, // Vector Pack Signed Halfword Signed Saturate VX-form (vpkshss VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VPKSHUS, 0xfc0007ff, 0x1000010e, 0x0, // Vector Pack Signed Halfword Unsigned Saturate VX-form (vpkshus VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VPKSWSS, 0xfc0007ff, 0x100001ce, 0x0, // Vector Pack Signed Word Signed Saturate VX-form (vpkswss VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VPKSWUS, 0xfc0007ff, 0x1000014e, 0x0, // Vector Pack Signed Word Unsigned Saturate VX-form (vpkswus VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VPKUDUM, 0xfc0007ff, 0x1000044e, 0x0, // Vector Pack Unsigned Doubleword Unsigned Modulo VX-form (vpkudum VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VPKUDUS, 0xfc0007ff, 0x100004ce, 0x0, // Vector Pack Unsigned Doubleword Unsigned Saturate VX-form (vpkudus VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VPKUHUM, 0xfc0007ff, 0x1000000e, 0x0, // Vector Pack Unsigned Halfword Unsigned Modulo VX-form (vpkuhum VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VPKUHUS, 0xfc0007ff, 0x1000008e, 0x0, // Vector Pack Unsigned Halfword Unsigned Saturate VX-form (vpkuhus VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VPKUWUM, 0xfc0007ff, 0x1000004e, 0x0, // Vector Pack Unsigned Word Unsigned Modulo VX-form (vpkuwum VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VPKUWUS, 0xfc0007ff, 0x100000ce, 0x0, // Vector Pack Unsigned Word Unsigned Saturate VX-form (vpkuwus VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VUPKHPX, 0xfc0007ff, 0x1000034e, 0x1f0000, // Vector Unpack High Pixel VX-form (vupkhpx VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VUPKLPX, 0xfc0007ff, 0x100003ce, 0x1f0000, // Vector Unpack Low Pixel VX-form (vupklpx VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VUPKHSB, 0xfc0007ff, 0x1000020e, 0x1f0000, // Vector Unpack High Signed Byte VX-form (vupkhsb VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VUPKHSH, 0xfc0007ff, 0x1000024e, 0x1f0000, // Vector Unpack High Signed Halfword VX-form (vupkhsh VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VUPKHSW, 0xfc0007ff, 0x1000064e, 0x1f0000, // Vector Unpack High Signed Word VX-form (vupkhsw VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VUPKLSB, 0xfc0007ff, 0x1000028e, 0x1f0000, // Vector Unpack Low Signed Byte VX-form (vupklsb VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VUPKLSH, 0xfc0007ff, 0x100002ce, 0x1f0000, // Vector Unpack Low Signed Halfword VX-form (vupklsh VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VUPKLSW, 0xfc0007ff, 0x100006ce, 0x1f0000, // Vector Unpack Low Signed Word VX-form (vupklsw VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VMRGHB, 0xfc0007ff, 0x1000000c, 0x0, // Vector Merge High Byte VX-form (vmrghb VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMRGHH, 0xfc0007ff, 0x1000004c, 0x0, // Vector Merge High Halfword VX-form (vmrghh VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMRGLB, 0xfc0007ff, 0x1000010c, 0x0, // Vector Merge Low Byte VX-form (vmrglb VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMRGLH, 0xfc0007ff, 0x1000014c, 0x0, // Vector Merge Low Halfword VX-form (vmrglh VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMRGHW, 0xfc0007ff, 0x1000008c, 0x0, // Vector Merge High Word VX-form (vmrghw VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMRGLW, 0xfc0007ff, 0x1000018c, 0x0, // Vector Merge Low Word VX-form (vmrglw VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMRGEW, 0xfc0007ff, 0x1000078c, 0x0, // Vector Merge Even Word VX-form (vmrgew VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMRGOW, 0xfc0007ff, 0x1000068c, 0x0, // Vector Merge Odd Word VX-form (vmrgow VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSPLTB, 0xfc0007ff, 0x1000020c, 0x100000, // Vector Splat Byte VX-form (vspltb VRT,VRB,UIM)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_12_15}},
-	{VSPLTH, 0xfc0007ff, 0x1000024c, 0x180000, // Vector Splat Halfword VX-form (vsplth VRT,VRB,UIM)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_13_15}},
-	{VSPLTW, 0xfc0007ff, 0x1000028c, 0x1c0000, // Vector Splat Word VX-form (vspltw VRT,VRB,UIM)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_14_15}},
-	{VSPLTISB, 0xfc0007ff, 0x1000030c, 0xf800, // Vector Splat Immediate Signed Byte VX-form (vspltisb VRT,SIM)
-		[5]*argField{ap_VecReg_6_10, ap_ImmSigned_11_15}},
-	{VSPLTISH, 0xfc0007ff, 0x1000034c, 0xf800, // Vector Splat Immediate Signed Halfword VX-form (vspltish VRT,SIM)
-		[5]*argField{ap_VecReg_6_10, ap_ImmSigned_11_15}},
-	{VSPLTISW, 0xfc0007ff, 0x1000038c, 0xf800, // Vector Splat Immediate Signed Word VX-form (vspltisw VRT,SIM)
-		[5]*argField{ap_VecReg_6_10, ap_ImmSigned_11_15}},
-	{VPERM, 0xfc00003f, 0x1000002b, 0x0, // Vector Permute VA-form (vperm VRT,VRA,VRB,VRC)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
-	{VPERMR, 0xfc00003f, 0x1000003b, 0x0, // Vector Permute Right-indexed VA-form (vpermr VRT,VRA,VRB,VRC)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
-	{VSEL, 0xfc00003f, 0x1000002a, 0x0, // Vector Select VA-form (vsel VRT,VRA,VRB,VRC)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
-	{VSL, 0xfc0007ff, 0x100001c4, 0x0, // Vector Shift Left VX-form (vsl VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSLDOI, 0xfc00003f, 0x1000002c, 0x400, // Vector Shift Left Double by Octet Immediate VA-form (vsldoi VRT,VRA,VRB,SHB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_ImmUnsigned_22_25}},
-	{VSLO, 0xfc0007ff, 0x1000040c, 0x0, // Vector Shift Left by Octet VX-form (vslo VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSR, 0xfc0007ff, 0x100002c4, 0x0, // Vector Shift Right VX-form (vsr VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSRO, 0xfc0007ff, 0x1000044c, 0x0, // Vector Shift Right by Octet VX-form (vsro VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VADDCUW, 0xfc0007ff, 0x10000180, 0x0, // Vector Add and Write Carry-Out Unsigned Word VX-form (vaddcuw VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VADDSBS, 0xfc0007ff, 0x10000300, 0x0, // Vector Add Signed Byte Saturate VX-form (vaddsbs VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VADDSHS, 0xfc0007ff, 0x10000340, 0x0, // Vector Add Signed Halfword Saturate VX-form (vaddshs VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VADDSWS, 0xfc0007ff, 0x10000380, 0x0, // Vector Add Signed Word Saturate VX-form (vaddsws VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VADDUBM, 0xfc0007ff, 0x10000000, 0x0, // Vector Add Unsigned Byte Modulo VX-form (vaddubm VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VADDUDM, 0xfc0007ff, 0x100000c0, 0x0, // Vector Add Unsigned Doubleword Modulo VX-form (vaddudm VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VADDUHM, 0xfc0007ff, 0x10000040, 0x0, // Vector Add Unsigned Halfword Modulo VX-form (vadduhm VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VADDUWM, 0xfc0007ff, 0x10000080, 0x0, // Vector Add Unsigned Word Modulo VX-form (vadduwm VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VADDUBS, 0xfc0007ff, 0x10000200, 0x0, // Vector Add Unsigned Byte Saturate VX-form (vaddubs VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VADDUHS, 0xfc0007ff, 0x10000240, 0x0, // Vector Add Unsigned Halfword Saturate VX-form (vadduhs VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VADDUWS, 0xfc0007ff, 0x10000280, 0x0, // Vector Add Unsigned Word Saturate VX-form (vadduws VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VADDUQM, 0xfc0007ff, 0x10000100, 0x0, // Vector Add Unsigned Quadword Modulo VX-form (vadduqm VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VADDEUQM, 0xfc00003f, 0x1000003c, 0x0, // Vector Add Extended Unsigned Quadword Modulo VA-form (vaddeuqm VRT,VRA,VRB,VRC)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
-	{VADDCUQ, 0xfc0007ff, 0x10000140, 0x0, // Vector Add & write Carry Unsigned Quadword VX-form (vaddcuq VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VADDECUQ, 0xfc00003f, 0x1000003d, 0x0, // Vector Add Extended & write Carry Unsigned Quadword VA-form (vaddecuq VRT,VRA,VRB,VRC)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
-	{VSUBCUW, 0xfc0007ff, 0x10000580, 0x0, // Vector Subtract and Write Carry-Out Unsigned Word VX-form (vsubcuw VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSUBSBS, 0xfc0007ff, 0x10000700, 0x0, // Vector Subtract Signed Byte Saturate VX-form (vsubsbs VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSUBSHS, 0xfc0007ff, 0x10000740, 0x0, // Vector Subtract Signed Halfword Saturate VX-form (vsubshs VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSUBSWS, 0xfc0007ff, 0x10000780, 0x0, // Vector Subtract Signed Word Saturate VX-form (vsubsws VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSUBUBM, 0xfc0007ff, 0x10000400, 0x0, // Vector Subtract Unsigned Byte Modulo VX-form (vsububm VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSUBUDM, 0xfc0007ff, 0x100004c0, 0x0, // Vector Subtract Unsigned Doubleword Modulo VX-form (vsubudm VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSUBUHM, 0xfc0007ff, 0x10000440, 0x0, // Vector Subtract Unsigned Halfword Modulo VX-form (vsubuhm VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSUBUWM, 0xfc0007ff, 0x10000480, 0x0, // Vector Subtract Unsigned Word Modulo VX-form (vsubuwm VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSUBUBS, 0xfc0007ff, 0x10000600, 0x0, // Vector Subtract Unsigned Byte Saturate VX-form (vsububs VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSUBUHS, 0xfc0007ff, 0x10000640, 0x0, // Vector Subtract Unsigned Halfword Saturate VX-form (vsubuhs VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSUBUWS, 0xfc0007ff, 0x10000680, 0x0, // Vector Subtract Unsigned Word Saturate VX-form (vsubuws VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSUBUQM, 0xfc0007ff, 0x10000500, 0x0, // Vector Subtract Unsigned Quadword Modulo VX-form (vsubuqm VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSUBEUQM, 0xfc00003f, 0x1000003e, 0x0, // Vector Subtract Extended Unsigned Quadword Modulo VA-form (vsubeuqm VRT,VRA,VRB,VRC)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
-	{VSUBCUQ, 0xfc0007ff, 0x10000540, 0x0, // Vector Subtract & write Carry Unsigned Quadword VX-form (vsubcuq VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSUBECUQ, 0xfc00003f, 0x1000003f, 0x0, // Vector Subtract Extended & write Carry Unsigned Quadword VA-form (vsubecuq VRT,VRA,VRB,VRC)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
-	{VMULESB, 0xfc0007ff, 0x10000308, 0x0, // Vector Multiply Even Signed Byte VX-form (vmulesb VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMULEUB, 0xfc0007ff, 0x10000208, 0x0, // Vector Multiply Even Unsigned Byte VX-form (vmuleub VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMULOSB, 0xfc0007ff, 0x10000108, 0x0, // Vector Multiply Odd Signed Byte VX-form (vmulosb VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMULOUB, 0xfc0007ff, 0x10000008, 0x0, // Vector Multiply Odd Unsigned Byte VX-form (vmuloub VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMULESH, 0xfc0007ff, 0x10000348, 0x0, // Vector Multiply Even Signed Halfword VX-form (vmulesh VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMULEUH, 0xfc0007ff, 0x10000248, 0x0, // Vector Multiply Even Unsigned Halfword VX-form (vmuleuh VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMULOSH, 0xfc0007ff, 0x10000148, 0x0, // Vector Multiply Odd Signed Halfword VX-form (vmulosh VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMULOUH, 0xfc0007ff, 0x10000048, 0x0, // Vector Multiply Odd Unsigned Halfword VX-form (vmulouh VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMULESW, 0xfc0007ff, 0x10000388, 0x0, // Vector Multiply Even Signed Word VX-form (vmulesw VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMULEUW, 0xfc0007ff, 0x10000288, 0x0, // Vector Multiply Even Unsigned Word VX-form (vmuleuw VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMULOSW, 0xfc0007ff, 0x10000188, 0x0, // Vector Multiply Odd Signed Word VX-form (vmulosw VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMULOUW, 0xfc0007ff, 0x10000088, 0x0, // Vector Multiply Odd Unsigned Word VX-form (vmulouw VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMULUWM, 0xfc0007ff, 0x10000089, 0x0, // Vector Multiply Unsigned Word Modulo VX-form (vmuluwm VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMHADDSHS, 0xfc00003f, 0x10000020, 0x0, // Vector Multiply-High-Add Signed Halfword Saturate VA-form (vmhaddshs VRT,VRA,VRB,VRC)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
-	{VMHRADDSHS, 0xfc00003f, 0x10000021, 0x0, // Vector Multiply-High-Round-Add Signed Halfword Saturate VA-form (vmhraddshs VRT,VRA,VRB,VRC)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
-	{VMLADDUHM, 0xfc00003f, 0x10000022, 0x0, // Vector Multiply-Low-Add Unsigned Halfword Modulo VA-form (vmladduhm VRT,VRA,VRB,VRC)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
-	{VMSUMUBM, 0xfc00003f, 0x10000024, 0x0, // Vector Multiply-Sum Unsigned Byte Modulo VA-form (vmsumubm VRT,VRA,VRB,VRC)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
-	{VMSUMMBM, 0xfc00003f, 0x10000025, 0x0, // Vector Multiply-Sum Mixed Byte Modulo VA-form (vmsummbm VRT,VRA,VRB,VRC)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
-	{VMSUMSHM, 0xfc00003f, 0x10000028, 0x0, // Vector Multiply-Sum Signed Halfword Modulo VA-form (vmsumshm VRT,VRA,VRB,VRC)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
-	{VMSUMSHS, 0xfc00003f, 0x10000029, 0x0, // Vector Multiply-Sum Signed Halfword Saturate VA-form (vmsumshs VRT,VRA,VRB,VRC)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
-	{VMSUMUHM, 0xfc00003f, 0x10000026, 0x0, // Vector Multiply-Sum Unsigned Halfword Modulo VA-form (vmsumuhm VRT,VRA,VRB,VRC)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
-	{VMSUMUHS, 0xfc00003f, 0x10000027, 0x0, // Vector Multiply-Sum Unsigned Halfword Saturate VA-form (vmsumuhs VRT,VRA,VRB,VRC)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
-	{VMSUMUDM, 0xfc00003f, 0x10000023, 0x0, // Vector Multiply-Sum Unsigned Doubleword Modulo VA-form (vmsumudm VRT,VRA,VRB,VRC)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
-	{VSUMSWS, 0xfc0007ff, 0x10000788, 0x0, // Vector Sum across Signed Word Saturate VX-form (vsumsws VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSUM2SWS, 0xfc0007ff, 0x10000688, 0x0, // Vector Sum across Half Signed Word Saturate VX-form (vsum2sws VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSUM4SBS, 0xfc0007ff, 0x10000708, 0x0, // Vector Sum across Quarter Signed Byte Saturate VX-form (vsum4sbs VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSUM4SHS, 0xfc0007ff, 0x10000648, 0x0, // Vector Sum across Quarter Signed Halfword Saturate VX-form (vsum4shs VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSUM4UBS, 0xfc0007ff, 0x10000608, 0x0, // Vector Sum across Quarter Unsigned Byte Saturate VX-form (vsum4ubs VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VAVGSB, 0xfc0007ff, 0x10000502, 0x0, // Vector Average Signed Byte VX-form (vavgsb VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VAVGSH, 0xfc0007ff, 0x10000542, 0x0, // Vector Average Signed Halfword VX-form (vavgsh VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VAVGSW, 0xfc0007ff, 0x10000582, 0x0, // Vector Average Signed Word VX-form (vavgsw VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VAVGUB, 0xfc0007ff, 0x10000402, 0x0, // Vector Average Unsigned Byte VX-form (vavgub VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VAVGUW, 0xfc0007ff, 0x10000482, 0x0, // Vector Average Unsigned Word VX-form (vavguw VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VAVGUH, 0xfc0007ff, 0x10000442, 0x0, // Vector Average Unsigned Halfword VX-form (vavguh VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMAXSB, 0xfc0007ff, 0x10000102, 0x0, // Vector Maximum Signed Byte VX-form (vmaxsb VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMAXSD, 0xfc0007ff, 0x100001c2, 0x0, // Vector Maximum Signed Doubleword VX-form (vmaxsd VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMAXUB, 0xfc0007ff, 0x10000002, 0x0, // Vector Maximum Unsigned Byte VX-form (vmaxub VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMAXUD, 0xfc0007ff, 0x100000c2, 0x0, // Vector Maximum Unsigned Doubleword VX-form (vmaxud VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMAXSH, 0xfc0007ff, 0x10000142, 0x0, // Vector Maximum Signed Halfword VX-form (vmaxsh VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMAXSW, 0xfc0007ff, 0x10000182, 0x0, // Vector Maximum Signed Word VX-form (vmaxsw VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMAXUH, 0xfc0007ff, 0x10000042, 0x0, // Vector Maximum Unsigned Halfword VX-form (vmaxuh VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMAXUW, 0xfc0007ff, 0x10000082, 0x0, // Vector Maximum Unsigned Word VX-form (vmaxuw VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMINSB, 0xfc0007ff, 0x10000302, 0x0, // Vector Minimum Signed Byte VX-form (vminsb VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMINSD, 0xfc0007ff, 0x100003c2, 0x0, // Vector Minimum Signed Doubleword VX-form (vminsd VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMINUB, 0xfc0007ff, 0x10000202, 0x0, // Vector Minimum Unsigned Byte VX-form (vminub VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMINUD, 0xfc0007ff, 0x100002c2, 0x0, // Vector Minimum Unsigned Doubleword VX-form (vminud VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMINSH, 0xfc0007ff, 0x10000342, 0x0, // Vector Minimum Signed Halfword VX-form (vminsh VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMINSW, 0xfc0007ff, 0x10000382, 0x0, // Vector Minimum Signed Word VX-form (vminsw VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMINUH, 0xfc0007ff, 0x10000242, 0x0, // Vector Minimum Unsigned Halfword VX-form (vminuh VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMINUW, 0xfc0007ff, 0x10000282, 0x0, // Vector Minimum Unsigned Word VX-form (vminuw VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPEQUB, 0xfc0007ff, 0x10000006, 0x0, // Vector Compare Equal To Unsigned Byte VC-form (vcmpequb VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPEQUBCC, 0xfc0007ff, 0x10000406, 0x0, // Vector Compare Equal To Unsigned Byte VC-form (vcmpequb. VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPEQUH, 0xfc0007ff, 0x10000046, 0x0, // Vector Compare Equal To Unsigned Halfword VC-form (vcmpequh VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPEQUHCC, 0xfc0007ff, 0x10000446, 0x0, // Vector Compare Equal To Unsigned Halfword VC-form (vcmpequh. VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPEQUW, 0xfc0007ff, 0x10000086, 0x0, // Vector Compare Equal To Unsigned Word VC-form (vcmpequw VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPEQUWCC, 0xfc0007ff, 0x10000486, 0x0, // Vector Compare Equal To Unsigned Word VC-form (vcmpequw. VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPEQUD, 0xfc0007ff, 0x100000c7, 0x0, // Vector Compare Equal To Unsigned Doubleword VX-form (vcmpequd VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPEQUDCC, 0xfc0007ff, 0x100004c7, 0x0, // Vector Compare Equal To Unsigned Doubleword VX-form (vcmpequd. VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPNEB, 0xfc0007ff, 0x10000007, 0x0, // Vector Compare Not Equal Byte VX-form (vcmpneb VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPNEBCC, 0xfc0007ff, 0x10000407, 0x0, // Vector Compare Not Equal Byte VX-form (vcmpneb. VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPNEZB, 0xfc0007ff, 0x10000107, 0x0, // Vector Compare Not Equal or Zero Byte VX-form (vcmpnezb VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPNEZBCC, 0xfc0007ff, 0x10000507, 0x0, // Vector Compare Not Equal or Zero Byte VX-form (vcmpnezb. VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPNEH, 0xfc0007ff, 0x10000047, 0x0, // Vector Compare Not Equal Halfword VX-form (vcmpneh VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPNEHCC, 0xfc0007ff, 0x10000447, 0x0, // Vector Compare Not Equal Halfword VX-form (vcmpneh. VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPNEZH, 0xfc0007ff, 0x10000147, 0x0, // Vector Compare Not Equal or Zero Halfword VX-form (vcmpnezh VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPNEZHCC, 0xfc0007ff, 0x10000547, 0x0, // Vector Compare Not Equal or Zero Halfword VX-form (vcmpnezh. VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPNEW, 0xfc0007ff, 0x10000087, 0x0, // Vector Compare Not Equal Word VX-form (vcmpnew VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPNEWCC, 0xfc0007ff, 0x10000487, 0x0, // Vector Compare Not Equal Word VX-form (vcmpnew. VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPNEZW, 0xfc0007ff, 0x10000187, 0x0, // Vector Compare Not Equal or Zero Word VX-form (vcmpnezw VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPNEZWCC, 0xfc0007ff, 0x10000587, 0x0, // Vector Compare Not Equal or Zero Word VX-form (vcmpnezw. VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPGTSB, 0xfc0007ff, 0x10000306, 0x0, // Vector Compare Greater Than Signed Byte VC-form (vcmpgtsb VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPGTSBCC, 0xfc0007ff, 0x10000706, 0x0, // Vector Compare Greater Than Signed Byte VC-form (vcmpgtsb. VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPGTSD, 0xfc0007ff, 0x100003c7, 0x0, // Vector Compare Greater Than Signed Doubleword VX-form (vcmpgtsd VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPGTSDCC, 0xfc0007ff, 0x100007c7, 0x0, // Vector Compare Greater Than Signed Doubleword VX-form (vcmpgtsd. VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPGTSH, 0xfc0007ff, 0x10000346, 0x0, // Vector Compare Greater Than Signed Halfword VC-form (vcmpgtsh VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPGTSHCC, 0xfc0007ff, 0x10000746, 0x0, // Vector Compare Greater Than Signed Halfword VC-form (vcmpgtsh. VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPGTSW, 0xfc0007ff, 0x10000386, 0x0, // Vector Compare Greater Than Signed Word VC-form (vcmpgtsw VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPGTSWCC, 0xfc0007ff, 0x10000786, 0x0, // Vector Compare Greater Than Signed Word VC-form (vcmpgtsw. VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPGTUB, 0xfc0007ff, 0x10000206, 0x0, // Vector Compare Greater Than Unsigned Byte VC-form (vcmpgtub VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPGTUBCC, 0xfc0007ff, 0x10000606, 0x0, // Vector Compare Greater Than Unsigned Byte VC-form (vcmpgtub. VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPGTUD, 0xfc0007ff, 0x100002c7, 0x0, // Vector Compare Greater Than Unsigned Doubleword VX-form (vcmpgtud VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPGTUDCC, 0xfc0007ff, 0x100006c7, 0x0, // Vector Compare Greater Than Unsigned Doubleword VX-form (vcmpgtud. VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPGTUH, 0xfc0007ff, 0x10000246, 0x0, // Vector Compare Greater Than Unsigned Halfword VC-form (vcmpgtuh VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPGTUHCC, 0xfc0007ff, 0x10000646, 0x0, // Vector Compare Greater Than Unsigned Halfword VC-form (vcmpgtuh. VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPGTUW, 0xfc0007ff, 0x10000286, 0x0, // Vector Compare Greater Than Unsigned Word VC-form (vcmpgtuw VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPGTUWCC, 0xfc0007ff, 0x10000686, 0x0, // Vector Compare Greater Than Unsigned Word VC-form (vcmpgtuw. VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VAND, 0xfc0007ff, 0x10000404, 0x0, // Vector Logical AND VX-form (vand VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VANDC, 0xfc0007ff, 0x10000444, 0x0, // Vector Logical AND with Complement VX-form (vandc VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VEQV, 0xfc0007ff, 0x10000684, 0x0, // Vector Logical Equivalent VX-form (veqv VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VNAND, 0xfc0007ff, 0x10000584, 0x0, // Vector Logical NAND VX-form (vnand VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VORC, 0xfc0007ff, 0x10000544, 0x0, // Vector Logical OR with Complement VX-form (vorc VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VNOR, 0xfc0007ff, 0x10000504, 0x0, // Vector Logical NOR VX-form (vnor VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VOR, 0xfc0007ff, 0x10000484, 0x0, // Vector Logical OR VX-form (vor VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VXOR, 0xfc0007ff, 0x100004c4, 0x0, // Vector Logical XOR VX-form (vxor VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VRLB, 0xfc0007ff, 0x10000004, 0x0, // Vector Rotate Left Byte VX-form (vrlb VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VRLH, 0xfc0007ff, 0x10000044, 0x0, // Vector Rotate Left Halfword VX-form (vrlh VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VRLW, 0xfc0007ff, 0x10000084, 0x0, // Vector Rotate Left Word VX-form (vrlw VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VRLD, 0xfc0007ff, 0x100000c4, 0x0, // Vector Rotate Left Doubleword VX-form (vrld VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSLB, 0xfc0007ff, 0x10000104, 0x0, // Vector Shift Left Byte VX-form (vslb VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSLH, 0xfc0007ff, 0x10000144, 0x0, // Vector Shift Left Halfword VX-form (vslh VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSLW, 0xfc0007ff, 0x10000184, 0x0, // Vector Shift Left Word VX-form (vslw VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSLD, 0xfc0007ff, 0x100005c4, 0x0, // Vector Shift Left Doubleword VX-form (vsld VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSRB, 0xfc0007ff, 0x10000204, 0x0, // Vector Shift Right Byte VX-form (vsrb VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSRH, 0xfc0007ff, 0x10000244, 0x0, // Vector Shift Right Halfword VX-form (vsrh VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSRW, 0xfc0007ff, 0x10000284, 0x0, // Vector Shift Right Word VX-form (vsrw VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSRD, 0xfc0007ff, 0x100006c4, 0x0, // Vector Shift Right Doubleword VX-form (vsrd VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSRAB, 0xfc0007ff, 0x10000304, 0x0, // Vector Shift Right Algebraic Byte VX-form (vsrab VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSRAH, 0xfc0007ff, 0x10000344, 0x0, // Vector Shift Right Algebraic Halfword VX-form (vsrah VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSRAW, 0xfc0007ff, 0x10000384, 0x0, // Vector Shift Right Algebraic Word VX-form (vsraw VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSRAD, 0xfc0007ff, 0x100003c4, 0x0, // Vector Shift Right Algebraic Doubleword VX-form (vsrad VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VADDFP, 0xfc0007ff, 0x1000000a, 0x0, // Vector Add Single-Precision VX-form (vaddfp VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSUBFP, 0xfc0007ff, 0x1000004a, 0x0, // Vector Subtract Single-Precision VX-form (vsubfp VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMADDFP, 0xfc00003f, 0x1000002e, 0x0, // Vector Multiply-Add Single-Precision VA-form (vmaddfp VRT,VRA,VRC,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_21_25, ap_VecReg_16_20}},
-	{VNMSUBFP, 0xfc00003f, 0x1000002f, 0x0, // Vector Negative Multiply-Subtract Single-Precision VA-form (vnmsubfp VRT,VRA,VRC,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_21_25, ap_VecReg_16_20}},
-	{VMAXFP, 0xfc0007ff, 0x1000040a, 0x0, // Vector Maximum Single-Precision VX-form (vmaxfp VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VMINFP, 0xfc0007ff, 0x1000044a, 0x0, // Vector Minimum Single-Precision VX-form (vminfp VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCTSXS, 0xfc0007ff, 0x100003ca, 0x0, // Vector Convert To Signed Fixed-Point Word Saturate VX-form (vctsxs VRT,VRB,UIM)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_11_15}},
-	{VCTUXS, 0xfc0007ff, 0x1000038a, 0x0, // Vector Convert To Unsigned Fixed-Point Word Saturate VX-form (vctuxs VRT,VRB,UIM)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_11_15}},
-	{VCFSX, 0xfc0007ff, 0x1000034a, 0x0, // Vector Convert From Signed Fixed-Point Word VX-form (vcfsx VRT,VRB,UIM)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_11_15}},
-	{VCFUX, 0xfc0007ff, 0x1000030a, 0x0, // Vector Convert From Unsigned Fixed-Point Word VX-form (vcfux VRT,VRB,UIM)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_11_15}},
-	{VRFIM, 0xfc0007ff, 0x100002ca, 0x1f0000, // Vector Round to Single-Precision Integer toward -Infinity VX-form (vrfim VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VRFIN, 0xfc0007ff, 0x1000020a, 0x1f0000, // Vector Round to Single-Precision Integer Nearest VX-form (vrfin VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VRFIP, 0xfc0007ff, 0x1000028a, 0x1f0000, // Vector Round to Single-Precision Integer toward +Infinity VX-form (vrfip VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VRFIZ, 0xfc0007ff, 0x1000024a, 0x1f0000, // Vector Round to Single-Precision Integer toward Zero VX-form (vrfiz VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VCMPBFP, 0xfc0007ff, 0x100003c6, 0x0, // Vector Compare Bounds Single-Precision VC-form (vcmpbfp VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPBFPCC, 0xfc0007ff, 0x100007c6, 0x0, // Vector Compare Bounds Single-Precision VC-form (vcmpbfp. VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPEQFP, 0xfc0007ff, 0x100000c6, 0x0, // Vector Compare Equal To Single-Precision VC-form (vcmpeqfp VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPEQFPCC, 0xfc0007ff, 0x100004c6, 0x0, // Vector Compare Equal To Single-Precision VC-form (vcmpeqfp. VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPGEFP, 0xfc0007ff, 0x100001c6, 0x0, // Vector Compare Greater Than or Equal To Single-Precision VC-form (vcmpgefp VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPGEFPCC, 0xfc0007ff, 0x100005c6, 0x0, // Vector Compare Greater Than or Equal To Single-Precision VC-form (vcmpgefp. VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPGTFP, 0xfc0007ff, 0x100002c6, 0x0, // Vector Compare Greater Than Single-Precision VC-form (vcmpgtfp VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCMPGTFPCC, 0xfc0007ff, 0x100006c6, 0x0, // Vector Compare Greater Than Single-Precision VC-form (vcmpgtfp. VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VEXPTEFP, 0xfc0007ff, 0x1000018a, 0x1f0000, // Vector 2 Raised to the Exponent Estimate Floating-Point VX-form (vexptefp VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VLOGEFP, 0xfc0007ff, 0x100001ca, 0x1f0000, // Vector Log Base 2 Estimate Floating-Point VX-form (vlogefp VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VREFP, 0xfc0007ff, 0x1000010a, 0x1f0000, // Vector Reciprocal Estimate Single-Precision VX-form (vrefp VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VRSQRTEFP, 0xfc0007ff, 0x1000014a, 0x1f0000, // Vector Reciprocal Square Root Estimate Single-Precision VX-form (vrsqrtefp VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VCIPHER, 0xfc0007ff, 0x10000508, 0x0, // Vector AES Cipher VX-form (vcipher VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VCIPHERLAST, 0xfc0007ff, 0x10000509, 0x0, // Vector AES Cipher Last VX-form (vcipherlast VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VNCIPHER, 0xfc0007ff, 0x10000548, 0x0, // Vector AES Inverse Cipher VX-form (vncipher VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VNCIPHERLAST, 0xfc0007ff, 0x10000549, 0x0, // Vector AES Inverse Cipher Last VX-form (vncipherlast VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VSBOX, 0xfc0007ff, 0x100005c8, 0xf800, // Vector AES SubBytes VX-form (vsbox VRT,VRA)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15}},
-	{VSHASIGMAD, 0xfc0007ff, 0x100006c2, 0x0, // Vector SHA-512 Sigma Doubleword VX-form (vshasigmad VRT,VRA,ST,SIX)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_ImmUnsigned_16_16, ap_ImmUnsigned_17_20}},
-	{VSHASIGMAW, 0xfc0007ff, 0x10000682, 0x0, // Vector SHA-256 Sigma Word VX-form (vshasigmaw VRT,VRA,ST,SIX)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_ImmUnsigned_16_16, ap_ImmUnsigned_17_20}},
-	{VPMSUMB, 0xfc0007ff, 0x10000408, 0x0, // Vector Polynomial Multiply-Sum Byte VX-form (vpmsumb VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VPMSUMD, 0xfc0007ff, 0x100004c8, 0x0, // Vector Polynomial Multiply-Sum Doubleword VX-form (vpmsumd VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VPMSUMH, 0xfc0007ff, 0x10000448, 0x0, // Vector Polynomial Multiply-Sum Halfword VX-form (vpmsumh VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VPMSUMW, 0xfc0007ff, 0x10000488, 0x0, // Vector Polynomial Multiply-Sum Word VX-form (vpmsumw VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VPERMXOR, 0xfc00003f, 0x1000002d, 0x0, // Vector Permute and Exclusive-OR VA-form (vpermxor VRT,VRA,VRB,VRC)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
-	{VGBBD, 0xfc0007ff, 0x1000050c, 0x1f0000, // Vector Gather Bits by Bytes by Doubleword VX-form (vgbbd VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VCLZB, 0xfc0007ff, 0x10000702, 0x1f0000, // Vector Count Leading Zeros Byte VX-form (vclzb VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VCLZH, 0xfc0007ff, 0x10000742, 0x1f0000, // Vector Count Leading Zeros Halfword VX-form (vclzh VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VCLZW, 0xfc0007ff, 0x10000782, 0x1f0000, // Vector Count Leading Zeros Word VX-form (vclzw VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VCLZD, 0xfc0007ff, 0x100007c2, 0x1f0000, // Vector Count Leading Zeros Doubleword (vclzd VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VPOPCNTB, 0xfc0007ff, 0x10000703, 0x1f0000, // Vector Population Count Byte (vpopcntb VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VPOPCNTD, 0xfc0007ff, 0x100007c3, 0x1f0000, // Vector Population Count Doubleword (vpopcntd VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VPOPCNTH, 0xfc0007ff, 0x10000743, 0x1f0000, // Vector Population Count Halfword (vpopcnth VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VPOPCNTW, 0xfc0007ff, 0x10000783, 0x1f0000, // Vector Population Count Word (vpopcntw VRT,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
-	{VBPERMQ, 0xfc0007ff, 0x1000054c, 0x0, // Vector Bit Permute Quadword VX-form (vbpermq VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{VBPERMD, 0xfc0007ff, 0x100005cc, 0x0, // Vector Bit Permute Doubleword VX-form (vbpermd VRT,VRA,VRB)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
-	{BCDADDCC, 0xfc0005ff, 0x10000401, 0x0, // Decimal Add Modulo VX-form (bcdadd. VRT,VRA,VRB,PS)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_ImmUnsigned_22_22}},
-	{BCDSUBCC, 0xfc0005ff, 0x10000441, 0x0, // Decimal Subtract Modulo VX-form (bcdsub. VRT,VRA,VRB,PS)
-		[5]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_ImmUnsigned_22_22}},
-	{MTVSCR, 0xfc0007ff, 0x10000644, 0x3ff0000, // Move To Vector Status and Control Register VX-form (mtvscr VRB)
-		[5]*argField{ap_VecReg_16_20}},
-	{MFVSCR, 0xfc0007ff, 0x10000604, 0x1ff800, // Move From Vector Status and Control Register VX-form (mfvscr VRT)
-		[5]*argField{ap_VecReg_6_10}},
-	{DADD, 0xfc0007ff, 0xec000004, 0x0, // DFP Add [Quad] X-form (dadd FRT,FRA,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{DADDCC, 0xfc0007ff, 0xec000005, 0x0, // DFP Add [Quad] X-form (dadd. FRT,FRA,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{DSUB, 0xfc0007ff, 0xec000404, 0x0, // DFP Subtract [Quad] X-form (dsub FRT,FRA,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{DSUBCC, 0xfc0007ff, 0xec000405, 0x0, // DFP Subtract [Quad] X-form (dsub. FRT,FRA,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{DMUL, 0xfc0007ff, 0xec000044, 0x0, // DFP Multiply [Quad] X-form (dmul FRT,FRA,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{DMULCC, 0xfc0007ff, 0xec000045, 0x0, // DFP Multiply [Quad] X-form (dmul. FRT,FRA,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{DDIV, 0xfc0007ff, 0xec000444, 0x0, // DFP Divide [Quad] X-form (ddiv FRT,FRA,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{DDIVCC, 0xfc0007ff, 0xec000445, 0x0, // DFP Divide [Quad] X-form (ddiv. FRT,FRA,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{DCMPU, 0xfc0007fe, 0xec000504, 0x600001, // DFP Compare Unordered [Quad] X-form (dcmpu BF,FRA,FRB)
-		[5]*argField{ap_CondRegField_6_8, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{DCMPO, 0xfc0007fe, 0xec000104, 0x600001, // DFP Compare Ordered [Quad] X-form (dcmpo BF,FRA,FRB)
-		[5]*argField{ap_CondRegField_6_8, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{DTSTDC, 0xfc0003fe, 0xec000184, 0x600001, // DFP Test Data Class [Quad] Z22-form (dtstdc BF,FRA,DCM)
-		[5]*argField{ap_CondRegField_6_8, ap_FPReg_11_15, ap_ImmUnsigned_16_21}},
-	{DTSTDG, 0xfc0003fe, 0xec0001c4, 0x600001, // DFP Test Data Group [Quad] Z22-form (dtstdg BF,FRA,DGM)
-		[5]*argField{ap_CondRegField_6_8, ap_FPReg_11_15, ap_ImmUnsigned_16_21}},
-	{DTSTEX, 0xfc0007fe, 0xec000144, 0x600001, // DFP Test Exponent [Quad] X-form (dtstex BF,FRA,FRB)
-		[5]*argField{ap_CondRegField_6_8, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{DTSTSF, 0xfc0007fe, 0xec000544, 0x600001, // DFP Test Significance [Quad] X-form (dtstsf BF,FRA,FRB)
-		[5]*argField{ap_CondRegField_6_8, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{DQUAI, 0xfc0001ff, 0xec000086, 0x0, // DFP Quantize Immediate [Quad] Z23-form (dquai TE,FRT,FRB,RMC)
-		[5]*argField{ap_ImmSigned_11_15, ap_FPReg_6_10, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
-	{DQUAICC, 0xfc0001ff, 0xec000087, 0x0, // DFP Quantize Immediate [Quad] Z23-form (dquai. TE,FRT,FRB,RMC)
-		[5]*argField{ap_ImmSigned_11_15, ap_FPReg_6_10, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
-	{DQUA, 0xfc0001ff, 0xec000006, 0x0, // DFP Quantize [Quad] Z23-form (dqua FRT,FRA,FRB,RMC)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
-	{DQUACC, 0xfc0001ff, 0xec000007, 0x0, // DFP Quantize [Quad] Z23-form (dqua. FRT,FRA,FRB,RMC)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
-	{DRRND, 0xfc0001ff, 0xec000046, 0x0, // DFP Reround [Quad] Z23-form (drrnd FRT,FRA,FRB,RMC)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
-	{DRRNDCC, 0xfc0001ff, 0xec000047, 0x0, // DFP Reround [Quad] Z23-form (drrnd. FRT,FRA,FRB,RMC)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
-	{DRINTX, 0xfc0001ff, 0xec0000c6, 0x1e0000, // DFP Round To FP Integer With Inexact [Quad] Z23-form (drintx R,FRT,FRB,RMC)
-		[5]*argField{ap_ImmUnsigned_15_15, ap_FPReg_6_10, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
-	{DRINTXCC, 0xfc0001ff, 0xec0000c7, 0x1e0000, // DFP Round To FP Integer With Inexact [Quad] Z23-form (drintx. R,FRT,FRB,RMC)
-		[5]*argField{ap_ImmUnsigned_15_15, ap_FPReg_6_10, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
-	{DRINTN, 0xfc0001ff, 0xec0001c6, 0x1e0000, // DFP Round To FP Integer Without Inexact [Quad] Z23-form (drintn R,FRT,FRB,RMC)
-		[5]*argField{ap_ImmUnsigned_15_15, ap_FPReg_6_10, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
-	{DRINTNCC, 0xfc0001ff, 0xec0001c7, 0x1e0000, // DFP Round To FP Integer Without Inexact [Quad] Z23-form (drintn. R,FRT,FRB,RMC)
-		[5]*argField{ap_ImmUnsigned_15_15, ap_FPReg_6_10, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
-	{DCTDP, 0xfc0007ff, 0xec000204, 0x1f0000, // DFP Convert To DFP Long X-form (dctdp FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{DCTDPCC, 0xfc0007ff, 0xec000205, 0x1f0000, // DFP Convert To DFP Long X-form (dctdp. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{DCTQPQ, 0xfc0007ff, 0xfc000204, 0x1f0000, // DFP Convert To DFP Extended X-form (dctqpq FRTp,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{DCTQPQCC, 0xfc0007ff, 0xfc000205, 0x1f0000, // DFP Convert To DFP Extended X-form (dctqpq. FRTp,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{DRSP, 0xfc0007ff, 0xec000604, 0x1f0000, // DFP Round To DFP Short X-form (drsp FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{DRSPCC, 0xfc0007ff, 0xec000605, 0x1f0000, // DFP Round To DFP Short X-form (drsp. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{DRDPQ, 0xfc0007ff, 0xfc000604, 0x1f0000, // DFP Round To DFP Long X-form (drdpq FRTp,FRBp)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{DRDPQCC, 0xfc0007ff, 0xfc000605, 0x1f0000, // DFP Round To DFP Long X-form (drdpq. FRTp,FRBp)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{DCFFIX, 0xfc0007ff, 0xec000644, 0x1f0000, // DFP Convert From Fixed X-form (dcffix FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{DCFFIXCC, 0xfc0007ff, 0xec000645, 0x1f0000, // DFP Convert From Fixed X-form (dcffix. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{DCFFIXQ, 0xfc0007ff, 0xfc000644, 0x1f0000, // DFP Convert From Fixed Quad X-form (dcffixq FRTp,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{DCFFIXQCC, 0xfc0007ff, 0xfc000645, 0x1f0000, // DFP Convert From Fixed Quad X-form (dcffixq. FRTp,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{DCTFIX, 0xfc0007ff, 0xec000244, 0x1f0000, // DFP Convert To Fixed [Quad] X-form (dctfix FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{DCTFIXCC, 0xfc0007ff, 0xec000245, 0x1f0000, // DFP Convert To Fixed [Quad] X-form (dctfix. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{DDEDPD, 0xfc0007ff, 0xec000284, 0x70000, // DFP Decode DPD To BCD [Quad] X-form (ddedpd SP,FRT,FRB)
-		[5]*argField{ap_ImmUnsigned_11_12, ap_FPReg_6_10, ap_FPReg_16_20}},
-	{DDEDPDCC, 0xfc0007ff, 0xec000285, 0x70000, // DFP Decode DPD To BCD [Quad] X-form (ddedpd. SP,FRT,FRB)
-		[5]*argField{ap_ImmUnsigned_11_12, ap_FPReg_6_10, ap_FPReg_16_20}},
-	{DENBCD, 0xfc0007ff, 0xec000684, 0xf0000, // DFP Encode BCD To DPD [Quad] X-form (denbcd S,FRT,FRB)
-		[5]*argField{ap_ImmUnsigned_11_11, ap_FPReg_6_10, ap_FPReg_16_20}},
-	{DENBCDCC, 0xfc0007ff, 0xec000685, 0xf0000, // DFP Encode BCD To DPD [Quad] X-form (denbcd. S,FRT,FRB)
-		[5]*argField{ap_ImmUnsigned_11_11, ap_FPReg_6_10, ap_FPReg_16_20}},
-	{DXEX, 0xfc0007ff, 0xec0002c4, 0x1f0000, // DFP Extract Biased Exponent [Quad] X-form (dxex FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{DXEXCC, 0xfc0007ff, 0xec0002c5, 0x1f0000, // DFP Extract Biased Exponent [Quad] X-form (dxex. FRT,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
-	{DIEX, 0xfc0007ff, 0xec0006c4, 0x0, // DFP Insert Biased Exponent [Quad] X-form (diex FRT,FRA,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{DIEXCC, 0xfc0007ff, 0xec0006c5, 0x0, // DFP Insert Biased Exponent [Quad] X-form (diex. FRT,FRA,FRB)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
-	{DSCLI, 0xfc0003ff, 0xec000084, 0x0, // DFP Shift Significand Left Immediate [Quad] Z22-form (dscli FRT,FRA,SH)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_ImmUnsigned_16_21}},
-	{DSCLICC, 0xfc0003ff, 0xec000085, 0x0, // DFP Shift Significand Left Immediate [Quad] Z22-form (dscli. FRT,FRA,SH)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_ImmUnsigned_16_21}},
-	{DSCRI, 0xfc0003ff, 0xec0000c4, 0x0, // DFP Shift Significand Right Immediate [Quad] Z22-form (dscri FRT,FRA,SH)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_ImmUnsigned_16_21}},
-	{DSCRICC, 0xfc0003ff, 0xec0000c5, 0x0, // DFP Shift Significand Right Immediate [Quad] Z22-form (dscri. FRT,FRA,SH)
-		[5]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_ImmUnsigned_16_21}},
-	{LXSDX, 0xfc0007fe, 0x7c000498, 0x0, // Load VSX Scalar Doubleword Indexed XX1-form (lxsdx XT,RA,RB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LXSIWAX, 0xfc0007fe, 0x7c000098, 0x0, // Load VSX Scalar as Integer Word Algebraic Indexed XX1-form (lxsiwax XT,RA,RB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LXSIWZX, 0xfc0007fe, 0x7c000018, 0x0, // Load VSX Scalar as Integer Word and Zero Indexed XX1-form (lxsiwzx XT,RA,RB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LXSSPX, 0xfc0007fe, 0x7c000418, 0x0, // Load VSX Scalar Single-Precision Indexed XX1-form (lxsspx XT,RA,RB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LXVD2X, 0xfc0007fe, 0x7c000698, 0x0, // Load VSX Vector Doubleword*2 Indexed XX1-form (lxvd2x XT,RA,RB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LXVDSX, 0xfc0007fe, 0x7c000298, 0x0, // Load VSX Vector Doubleword & Splat Indexed XX1-form (lxvdsx XT,RA,RB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LXVW4X, 0xfc0007fe, 0x7c000618, 0x0, // Load VSX Vector Word*4 Indexed XX1-form (lxvw4x XT,RA,RB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LXVH8X, 0xfc0007fe, 0x7c000658, 0x0, // Load VSX Vector Halfword*8 Indexed XX1-form (lxvh8x XT,RA,RB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LXVB16X, 0xfc0007fe, 0x7c0006d8, 0x0, // Load VSX Vector Byte*16 Indexed XX1-form (lxvb16x XT,RA,RB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LXV, 0xfc000007, 0xf4000001, 0x0, // Load VSX Vector DQ-form (lxv XT,DQ(RA))
-		[5]*argField{ap_VecSReg_28_28_6_10, ap_Offset_16_27_shift4, ap_Reg_11_15}},
-	{LXVL, 0xfc0007fe, 0x7c00021a, 0x0, // Load VSX Vector with Length X-form (lxvl XT,RA,RB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LXVLL, 0xfc0007fe, 0x7c00025a, 0x0, // Load VSX Vector Left-justified with Length X-form (lxvll XT,RA,RB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LXVX, 0xfc0007be, 0x7c000218, 0x40, // Load VSX Vector Indexed X-form (lxvx XT,RA,RB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STXSDX, 0xfc0007fe, 0x7c000598, 0x0, // Store VSX Scalar Doubleword Indexed XX1-form (stxsdx XS,RA,RB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STXSIWX, 0xfc0007fe, 0x7c000118, 0x0, // Store VSX Scalar as Integer Word Indexed XX1-form (stxsiwx XS,RA,RB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STXSSPX, 0xfc0007fe, 0x7c000518, 0x0, // Store VSX Scalar Single-Precision Indexed XX1-form (stxsspx XS,RA,RB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STXVD2X, 0xfc0007fe, 0x7c000798, 0x0, // Store VSX Vector Doubleword*2 Indexed XX1-form (stxvd2x XS,RA,RB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STXVW4X, 0xfc0007fe, 0x7c000718, 0x0, // Store VSX Vector Word*4 Indexed XX1-form (stxvw4x XS,RA,RB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STXVH8X, 0xfc0007fe, 0x7c000758, 0x0, // Store VSX Vector Halfword*4 Indexed XX1-form (stxvh8x XS,RA,RB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STXVB16X, 0xfc0007fe, 0x7c0007d8, 0x0, // Store VSX Vector Byte*16 Indexed XX1-form (stxvb16x XS,RA,RB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STXV, 0xfc000007, 0xf4000005, 0x0, // Store VSX Vector DQ-form (stxv XS,DQ(RA))
-		[5]*argField{ap_VecSReg_28_28_6_10, ap_Offset_16_27_shift4, ap_Reg_11_15}},
-	{STXVL, 0xfc0007fe, 0x7c00031a, 0x0, // Store VSX Vector with Length X-form (stxvl XS,RA,RB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STXVLL, 0xfc0007fe, 0x7c00035a, 0x0, // Store VSX Vector Left-justified with Length X-form (stxvll XS,RA,RB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STXVX, 0xfc0007fe, 0x7c000318, 0x0, // Store VSX Vector Indexed X-form (stxvx XS,RA,RB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{XSABSDP, 0xfc0007fc, 0xf0000564, 0x1f0000, // VSX Scalar Absolute Value Double-Precision XX2-form (xsabsdp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSADDDP, 0xfc0007f8, 0xf0000100, 0x0, // VSX Scalar Add Double-Precision XX3-form (xsadddp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XSADDSP, 0xfc0007f8, 0xf0000000, 0x0, // VSX Scalar Add Single-Precision XX3-form (xsaddsp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XSCMPODP, 0xfc0007f8, 0xf0000158, 0x600001, // VSX Scalar Compare Ordered Double-Precision XX3-form (xscmpodp BF,XA,XB)
-		[5]*argField{ap_CondRegField_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XSCMPUDP, 0xfc0007f8, 0xf0000118, 0x600001, // VSX Scalar Compare Unordered Double-Precision XX3-form (xscmpudp BF,XA,XB)
-		[5]*argField{ap_CondRegField_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XSCPSGNDP, 0xfc0007f8, 0xf0000580, 0x0, // VSX Scalar Copy Sign Double-Precision XX3-form (xscpsgndp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XSCVDPSP, 0xfc0007fc, 0xf0000424, 0x1f0000, // VSX Scalar round Double-Precision to single-precision and Convert to Single-Precision format XX2-form (xscvdpsp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSCVDPSPN, 0xfc0007fc, 0xf000042c, 0x1f0000, // VSX Scalar Convert Scalar Single-Precision to Vector Single-Precision format Non-signalling XX2-form (xscvdpspn XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSCVDPSXDS, 0xfc0007fc, 0xf0000560, 0x1f0000, // VSX Scalar truncate Double-Precision to integer and Convert to Signed Integer Doubleword format with Saturate XX2-form (xscvdpsxds XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSCVDPSXWS, 0xfc0007fc, 0xf0000160, 0x1f0000, // VSX Scalar truncate Double-Precision to integer and Convert to Signed Integer Word format with Saturate XX2-form (xscvdpsxws XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSCVDPUXDS, 0xfc0007fc, 0xf0000520, 0x1f0000, // VSX Scalar truncate Double-Precision integer and Convert to Unsigned Integer Doubleword format with Saturate XX2-form (xscvdpuxds XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSCVDPUXWS, 0xfc0007fc, 0xf0000120, 0x1f0000, // VSX Scalar truncate Double-Precision to integer and Convert to Unsigned Integer Word format with Saturate XX2-form (xscvdpuxws XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSCVSPDP, 0xfc0007fc, 0xf0000524, 0x1f0000, // VSX Scalar Convert Single-Precision to Double-Precision format XX2-form (xscvspdp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSCVSPDPN, 0xfc0007fc, 0xf000052c, 0x1f0000, // VSX Scalar Convert Single-Precision to Double-Precision format Non-signalling XX2-form (xscvspdpn XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSCVSXDDP, 0xfc0007fc, 0xf00005e0, 0x1f0000, // VSX Scalar Convert Signed Integer Doubleword to floating-point format and round to Double-Precision format XX2-form (xscvsxddp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSCVSXDSP, 0xfc0007fc, 0xf00004e0, 0x1f0000, // VSX Scalar Convert Signed Integer Doubleword to floating-point format and round to Single-Precision XX2-form (xscvsxdsp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSCVUXDDP, 0xfc0007fc, 0xf00005a0, 0x1f0000, // VSX Scalar Convert Unsigned Integer Doubleword to floating-point format and round to Double-Precision format XX2-form (xscvuxddp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSCVUXDSP, 0xfc0007fc, 0xf00004a0, 0x1f0000, // VSX Scalar Convert Unsigned Integer Doubleword to floating-point format and round to Single-Precision XX2-form (xscvuxdsp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSDIVDP, 0xfc0007f8, 0xf00001c0, 0x0, // VSX Scalar Divide Double-Precision XX3-form (xsdivdp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XSDIVSP, 0xfc0007f8, 0xf00000c0, 0x0, // VSX Scalar Divide Single-Precision XX3-form (xsdivsp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XSMADDADP, 0xfc0007f8, 0xf0000108, 0x0, // VSX Scalar Multiply-Add Double-Precision XX3-form (xsmaddadp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XSMADDASP, 0xfc0007f8, 0xf0000008, 0x0, // VSX Scalar Multiply-Add Single-Precision XX3-form (xsmaddasp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XSMAXDP, 0xfc0007f8, 0xf0000500, 0x0, // VSX Scalar Maximum Double-Precision XX3-form (xsmaxdp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XSMINDP, 0xfc0007f8, 0xf0000540, 0x0, // VSX Scalar Minimum Double-Precision XX3-form (xsmindp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XSMSUBADP, 0xfc0007f8, 0xf0000188, 0x0, // VSX Scalar Multiply-Subtract Double-Precision XX3-form (xsmsubadp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XSMSUBASP, 0xfc0007f8, 0xf0000088, 0x0, // VSX Scalar Multiply-Subtract Single-Precision XX3-form (xsmsubasp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XSMULDP, 0xfc0007f8, 0xf0000180, 0x0, // VSX Scalar Multiply Double-Precision XX3-form (xsmuldp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XSMULSP, 0xfc0007f8, 0xf0000080, 0x0, // VSX Scalar Multiply Single-Precision XX3-form (xsmulsp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XSNABSDP, 0xfc0007fc, 0xf00005a4, 0x1f0000, // VSX Scalar Negative Absolute Value Double-Precision XX2-form (xsnabsdp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSNEGDP, 0xfc0007fc, 0xf00005e4, 0x1f0000, // VSX Scalar Negate Double-Precision XX2-form (xsnegdp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSNMADDADP, 0xfc0007f8, 0xf0000508, 0x0, // VSX Scalar Negative Multiply-Add Double-Precision XX3-form (xsnmaddadp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XSNMADDASP, 0xfc0007f8, 0xf0000408, 0x0, // VSX Scalar Negative Multiply-Add Single-Precision XX3-form (xsnmaddasp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XSNMSUBADP, 0xfc0007f8, 0xf0000588, 0x0, // VSX Scalar Negative Multiply-Subtract Double-Precision XX3-form (xsnmsubadp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XSNMSUBASP, 0xfc0007f8, 0xf0000488, 0x0, // VSX Scalar Negative Multiply-Subtract Single-Precision XX3-form (xsnmsubasp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XSRDPI, 0xfc0007fc, 0xf0000124, 0x1f0000, // VSX Scalar Round to Double-Precision Integer using round to Nearest Away XX2-form (xsrdpi XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSRDPIC, 0xfc0007fc, 0xf00001ac, 0x1f0000, // VSX Scalar Round to Double-Precision Integer exact using Current rounding mode XX2-form (xsrdpic XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSRDPIM, 0xfc0007fc, 0xf00001e4, 0x1f0000, // VSX Scalar Round to Double-Precision Integer using round toward -Infinity XX2-form (xsrdpim XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSRDPIP, 0xfc0007fc, 0xf00001a4, 0x1f0000, // VSX Scalar Round to Double-Precision Integer using round toward +Infinity XX2-form (xsrdpip XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSRDPIZ, 0xfc0007fc, 0xf0000164, 0x1f0000, // VSX Scalar Round to Double-Precision Integer using round toward Zero XX2-form (xsrdpiz XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSREDP, 0xfc0007fc, 0xf0000168, 0x1f0000, // VSX Scalar Reciprocal Estimate Double-Precision XX2-form (xsredp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSRESP, 0xfc0007fc, 0xf0000068, 0x1f0000, // VSX Scalar Reciprocal Estimate Single-Precision XX2-form (xsresp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSRSP, 0xfc0007fc, 0xf0000464, 0x1f0000, // VSX Scalar Round to Single-Precision XX2-form (xsrsp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSRSQRTEDP, 0xfc0007fc, 0xf0000128, 0x1f0000, // VSX Scalar Reciprocal Square Root Estimate Double-Precision XX2-form (xsrsqrtedp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSRSQRTESP, 0xfc0007fc, 0xf0000028, 0x1f0000, // VSX Scalar Reciprocal Square Root Estimate Single-Precision XX2-form (xsrsqrtesp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSSQRTDP, 0xfc0007fc, 0xf000012c, 0x1f0000, // VSX Scalar Square Root Double-Precision XX2-form (xssqrtdp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSSQRTSP, 0xfc0007fc, 0xf000002c, 0x1f0000, // VSX Scalar Square Root Single-Precision XX-form (xssqrtsp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XSSUBDP, 0xfc0007f8, 0xf0000140, 0x0, // VSX Scalar Subtract Double-Precision XX3-form (xssubdp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XSSUBSP, 0xfc0007f8, 0xf0000040, 0x0, // VSX Scalar Subtract Single-Precision XX3-form (xssubsp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XSTDIVDP, 0xfc0007f8, 0xf00001e8, 0x600001, // VSX Scalar Test for software Divide Double-Precision XX3-form (xstdivdp BF,XA,XB)
-		[5]*argField{ap_CondRegField_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XSTSQRTDP, 0xfc0007fc, 0xf00001a8, 0x7f0001, // VSX Scalar Test for software Square Root Double-Precision XX2-form (xstsqrtdp BF,XB)
-		[5]*argField{ap_CondRegField_6_8, ap_VecSReg_30_30_16_20}},
-	{XVABSDP, 0xfc0007fc, 0xf0000764, 0x1f0000, // VSX Vector Absolute Value Double-Precision XX2-form (xvabsdp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVABSSP, 0xfc0007fc, 0xf0000664, 0x1f0000, // VSX Vector Absolute Value Single-Precision XX2-form (xvabssp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVADDDP, 0xfc0007f8, 0xf0000300, 0x0, // VSX Vector Add Double-Precision XX3-form (xvadddp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVADDSP, 0xfc0007f8, 0xf0000200, 0x0, // VSX Vector Add Single-Precision XX3-form (xvaddsp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVCMPEQDP, 0xfc0007f8, 0xf0000318, 0x0, // VSX Vector Compare Equal To Double-Precision [ & Record ] XX3-form (xvcmpeqdp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVCMPEQDPCC, 0xfc0007f8, 0xf0000718, 0x0, // VSX Vector Compare Equal To Double-Precision [ & Record ] XX3-form (xvcmpeqdp. XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVCMPEQSP, 0xfc0007f8, 0xf0000218, 0x0, // VSX Vector Compare Equal To Single-Precision [ & Record ] XX3-form (xvcmpeqsp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVCMPEQSPCC, 0xfc0007f8, 0xf0000618, 0x0, // VSX Vector Compare Equal To Single-Precision [ & Record ] XX3-form (xvcmpeqsp. XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVCMPGEDP, 0xfc0007f8, 0xf0000398, 0x0, // VSX Vector Compare Greater Than or Equal To Double-Precision [ & Record ] XX3-form (xvcmpgedp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVCMPGEDPCC, 0xfc0007f8, 0xf0000798, 0x0, // VSX Vector Compare Greater Than or Equal To Double-Precision [ & Record ] XX3-form (xvcmpgedp. XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVCMPGESP, 0xfc0007f8, 0xf0000298, 0x0, // VSX Vector Compare Greater Than or Equal To Single-Precision [ & record CR6 ] XX3-form (xvcmpgesp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVCMPGESPCC, 0xfc0007f8, 0xf0000698, 0x0, // VSX Vector Compare Greater Than or Equal To Single-Precision [ & record CR6 ] XX3-form (xvcmpgesp. XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVCMPGTDP, 0xfc0007f8, 0xf0000358, 0x0, // VSX Vector Compare Greater Than Double-Precision [ & record CR6 ] XX3-form (xvcmpgtdp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVCMPGTDPCC, 0xfc0007f8, 0xf0000758, 0x0, // VSX Vector Compare Greater Than Double-Precision [ & record CR6 ] XX3-form (xvcmpgtdp. XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVCMPGTSP, 0xfc0007f8, 0xf0000258, 0x0, // VSX Vector Compare Greater Than Single-Precision [ & record CR6 ] XX3-form (xvcmpgtsp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVCMPGTSPCC, 0xfc0007f8, 0xf0000658, 0x0, // VSX Vector Compare Greater Than Single-Precision [ & record CR6 ] XX3-form (xvcmpgtsp. XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVCPSGNDP, 0xfc0007f8, 0xf0000780, 0x0, // VSX Vector Copy Sign Double-Precision XX3-form (xvcpsgndp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVCPSGNSP, 0xfc0007f8, 0xf0000680, 0x0, // VSX Vector Copy Sign Single-Precision XX3-form (xvcpsgnsp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVCVDPSP, 0xfc0007fc, 0xf0000624, 0x1f0000, // VSX Vector round Double-Precision to single-precision and Convert to Single-Precision format XX2-form (xvcvdpsp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVCVDPSXDS, 0xfc0007fc, 0xf0000760, 0x1f0000, // VSX Vector truncate Double-Precision to integer and Convert to Signed Integer Doubleword format with Saturate XX2-form (xvcvdpsxds XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVCVDPSXWS, 0xfc0007fc, 0xf0000360, 0x1f0000, // VSX Vector truncate Double-Precision to integer and Convert to Signed Integer Word format with Saturate XX2-form (xvcvdpsxws XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVCVDPUXDS, 0xfc0007fc, 0xf0000720, 0x1f0000, // VSX Vector truncate Double-Precision to integer and Convert to Unsigned Integer Doubleword format with Saturate XX2-form (xvcvdpuxds XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVCVDPUXWS, 0xfc0007fc, 0xf0000320, 0x1f0000, // VSX Vector truncate Double-Precision to integer and Convert to Unsigned Integer Word format with Saturate XX2-form (xvcvdpuxws XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVCVSPDP, 0xfc0007fc, 0xf0000724, 0x1f0000, // VSX Vector Convert Single-Precision to Double-Precision format XX2-form (xvcvspdp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVCVSPSXDS, 0xfc0007fc, 0xf0000660, 0x1f0000, // VSX Vector truncate Single-Precision to integer and Convert to Signed Integer Doubleword format with Saturate XX2-form (xvcvspsxds XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVCVSPSXWS, 0xfc0007fc, 0xf0000260, 0x1f0000, // VSX Vector truncate Single-Precision to integer and Convert to Signed Integer Word format with Saturate XX2-form (xvcvspsxws XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVCVSPUXDS, 0xfc0007fc, 0xf0000620, 0x1f0000, // VSX Vector truncate Single-Precision to integer and Convert to Unsigned Integer Doubleword format with Saturate XX2-form (xvcvspuxds XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVCVSPUXWS, 0xfc0007fc, 0xf0000220, 0x1f0000, // VSX Vector truncate Single-Precision to integer and Convert to Unsigned Integer Word format with Saturate XX2-form (xvcvspuxws XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVCVSXDDP, 0xfc0007fc, 0xf00007e0, 0x1f0000, // VSX Vector Convert and round Signed Integer Doubleword to Double-Precision format XX2-form (xvcvsxddp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVCVSXDSP, 0xfc0007fc, 0xf00006e0, 0x1f0000, // VSX Vector Convert and round Signed Integer Doubleword to Single-Precision format XX2-form (xvcvsxdsp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVCVSXWDP, 0xfc0007fc, 0xf00003e0, 0x1f0000, // VSX Vector Convert Signed Integer Word to Double-Precision format XX2-form (xvcvsxwdp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVCVSXWSP, 0xfc0007fc, 0xf00002e0, 0x1f0000, // VSX Vector Convert and round Signed Integer Word to Single-Precision format XX2-form (xvcvsxwsp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVCVUXDDP, 0xfc0007fc, 0xf00007a0, 0x1f0000, // VSX Vector Convert and round Unsigned Integer Doubleword to Double-Precision format XX2-form (xvcvuxddp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVCVUXDSP, 0xfc0007fc, 0xf00006a0, 0x1f0000, // VSX Vector Convert and round Unsigned Integer Doubleword to Single-Precision format XX2-form (xvcvuxdsp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVCVUXWDP, 0xfc0007fc, 0xf00003a0, 0x1f0000, // VSX Vector Convert and round Unsigned Integer Word to Double-Precision format XX2-form (xvcvuxwdp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVCVUXWSP, 0xfc0007fc, 0xf00002a0, 0x1f0000, // VSX Vector Convert and round Unsigned Integer Word to Single-Precision format XX2-form (xvcvuxwsp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVDIVDP, 0xfc0007f8, 0xf00003c0, 0x0, // VSX Vector Divide Double-Precision XX3-form (xvdivdp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVDIVSP, 0xfc0007f8, 0xf00002c0, 0x0, // VSX Vector Divide Single-Precision XX3-form (xvdivsp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVMADDADP, 0xfc0007f8, 0xf0000308, 0x0, // VSX Vector Multiply-Add Double-Precision XX3-form (xvmaddadp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVMADDASP, 0xfc0007f8, 0xf0000208, 0x0, // VSX Vector Multiply-Add Single-Precision XX3-form (xvmaddasp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVMAXDP, 0xfc0007f8, 0xf0000700, 0x0, // VSX Vector Maximum Double-Precision XX3-form (xvmaxdp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVMAXSP, 0xfc0007f8, 0xf0000600, 0x0, // VSX Vector Maximum Single-Precision XX3-form (xvmaxsp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVMINDP, 0xfc0007f8, 0xf0000740, 0x0, // VSX Vector Minimum Double-Precision XX3-form (xvmindp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVMINSP, 0xfc0007f8, 0xf0000640, 0x0, // VSX Vector Minimum Single-Precision XX3-form (xvminsp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVMSUBADP, 0xfc0007f8, 0xf0000388, 0x0, // VSX Vector Multiply-Subtract Double-Precision XX3-form (xvmsubadp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVMSUBASP, 0xfc0007f8, 0xf0000288, 0x0, // VSX Vector Multiply-Subtract Single-Precision XX3-form (xvmsubasp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVMULDP, 0xfc0007f8, 0xf0000380, 0x0, // VSX Vector Multiply Double-Precision XX3-form (xvmuldp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVMULSP, 0xfc0007f8, 0xf0000280, 0x0, // VSX Vector Multiply Single-Precision XX3-form (xvmulsp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVNABSDP, 0xfc0007fc, 0xf00007a4, 0x1f0000, // VSX Vector Negative Absolute Value Double-Precision XX2-form (xvnabsdp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVNABSSP, 0xfc0007fc, 0xf00006a4, 0x1f0000, // VSX Vector Negative Absolute Value Single-Precision XX2-form (xvnabssp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVNEGDP, 0xfc0007fc, 0xf00007e4, 0x1f0000, // VSX Vector Negate Double-Precision XX2-form (xvnegdp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVNEGSP, 0xfc0007fc, 0xf00006e4, 0x1f0000, // VSX Vector Negate Single-Precision XX2-form (xvnegsp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVNMADDADP, 0xfc0007f8, 0xf0000708, 0x0, // VSX Vector Negative Multiply-Add Double-Precision XX3-form (xvnmaddadp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVNMADDASP, 0xfc0007f8, 0xf0000608, 0x0, // VSX Vector Negative Multiply-Add Single-Precision XX3-form (xvnmaddasp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVNMSUBADP, 0xfc0007f8, 0xf0000788, 0x0, // VSX Vector Negative Multiply-Subtract Double-Precision XX3-form (xvnmsubadp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVNMSUBASP, 0xfc0007f8, 0xf0000688, 0x0, // VSX Vector Negative Multiply-Subtract Single-Precision XX3-form (xvnmsubasp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVRDPI, 0xfc0007fc, 0xf0000324, 0x1f0000, // VSX Vector Round to Double-Precision Integer using round to Nearest Away XX2-form (xvrdpi XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVRDPIC, 0xfc0007fc, 0xf00003ac, 0x1f0000, // VSX Vector Round to Double-Precision Integer Exact using Current rounding mode XX2-form (xvrdpic XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVRDPIM, 0xfc0007fc, 0xf00003e4, 0x1f0000, // VSX Vector Round to Double-Precision Integer using round toward -Infinity XX2-form (xvrdpim XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVRDPIP, 0xfc0007fc, 0xf00003a4, 0x1f0000, // VSX Vector Round to Double-Precision Integer using round toward +Infinity XX2-form (xvrdpip XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVRDPIZ, 0xfc0007fc, 0xf0000364, 0x1f0000, // VSX Vector Round to Double-Precision Integer using round toward Zero XX2-form (xvrdpiz XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVREDP, 0xfc0007fc, 0xf0000368, 0x1f0000, // VSX Vector Reciprocal Estimate Double-Precision XX2-form (xvredp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVRESP, 0xfc0007fc, 0xf0000268, 0x1f0000, // VSX Vector Reciprocal Estimate Single-Precision XX2-form (xvresp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVRSPI, 0xfc0007fc, 0xf0000224, 0x1f0000, // VSX Vector Round to Single-Precision Integer using round to Nearest Away XX2-form (xvrspi XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVRSPIC, 0xfc0007fc, 0xf00002ac, 0x1f0000, // VSX Vector Round to Single-Precision Integer Exact using Current rounding mode XX2-form (xvrspic XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVRSPIM, 0xfc0007fc, 0xf00002e4, 0x1f0000, // VSX Vector Round to Single-Precision Integer using round toward -Infinity XX2-form (xvrspim XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVRSPIP, 0xfc0007fc, 0xf00002a4, 0x1f0000, // VSX Vector Round to Single-Precision Integer using round toward +Infinity XX2-form (xvrspip XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVRSPIZ, 0xfc0007fc, 0xf0000264, 0x1f0000, // VSX Vector Round to Single-Precision Integer using round toward Zero XX2-form (xvrspiz XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVRSQRTEDP, 0xfc0007fc, 0xf0000328, 0x1f0000, // VSX Vector Reciprocal Square Root Estimate Double-Precision XX2-form (xvrsqrtedp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVRSQRTESP, 0xfc0007fc, 0xf0000228, 0x1f0000, // VSX Vector Reciprocal Square Root Estimate Single-Precision XX2-form (xvrsqrtesp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVSQRTDP, 0xfc0007fc, 0xf000032c, 0x1f0000, // VSX Vector Square Root Double-Precision XX2-form (xvsqrtdp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVSQRTSP, 0xfc0007fc, 0xf000022c, 0x1f0000, // VSX Vector Square Root Single-Precision XX2-form (xvsqrtsp XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XVSUBDP, 0xfc0007f8, 0xf0000340, 0x0, // VSX Vector Subtract Double-Precision XX3-form (xvsubdp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVSUBSP, 0xfc0007f8, 0xf0000240, 0x0, // VSX Vector Subtract Single-Precision XX3-form (xvsubsp XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVTDIVDP, 0xfc0007f8, 0xf00003e8, 0x600001, // VSX Vector Test for software Divide Double-Precision XX3-form (xvtdivdp BF,XA,XB)
-		[5]*argField{ap_CondRegField_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVTDIVSP, 0xfc0007f8, 0xf00002e8, 0x600001, // VSX Vector Test for software Divide Single-Precision XX3-form (xvtdivsp BF,XA,XB)
-		[5]*argField{ap_CondRegField_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XVTSQRTDP, 0xfc0007fc, 0xf00003a8, 0x7f0001, // VSX Vector Test for software Square Root Double-Precision XX2-form (xvtsqrtdp BF,XB)
-		[5]*argField{ap_CondRegField_6_8, ap_VecSReg_30_30_16_20}},
-	{XVTSQRTSP, 0xfc0007fc, 0xf00002a8, 0x7f0001, // VSX Vector Test for software Square Root Single-Precision XX2-form (xvtsqrtsp BF,XB)
-		[5]*argField{ap_CondRegField_6_8, ap_VecSReg_30_30_16_20}},
-	{XXLAND, 0xfc0007f8, 0xf0000410, 0x0, // VSX Logical AND XX3-form (xxland XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XXLANDC, 0xfc0007f8, 0xf0000450, 0x0, // VSX Logical AND with Complement XX3-form (xxlandc XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XXLEQV, 0xfc0007f8, 0xf00005d0, 0x0, // VSX Logical Equivalence XX3-form (xxleqv XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XXLNAND, 0xfc0007f8, 0xf0000590, 0x0, // VSX Logical NAND XX3-form (xxlnand XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XXLORC, 0xfc0007f8, 0xf0000550, 0x0, // VSX Logical OR with Complement XX3-form (xxlorc XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XXLNOR, 0xfc0007f8, 0xf0000510, 0x0, // VSX Logical NOR XX3-form (xxlnor XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XXLOR, 0xfc0007f8, 0xf0000490, 0x0, // VSX Logical OR XX3-form (xxlor XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XXLXOR, 0xfc0007f8, 0xf00004d0, 0x0, // VSX Logical XOR XX3-form (xxlxor XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XXMRGHW, 0xfc0007f8, 0xf0000090, 0x0, // VSX Merge High Word XX3-form (xxmrghw XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XXMRGLW, 0xfc0007f8, 0xf0000190, 0x0, // VSX Merge Low Word XX3-form (xxmrglw XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XXPERMDI, 0xfc0004f8, 0xf0000050, 0x0, // VSX Permute Doubleword Immediate XX3-form (xxpermdi XT,XA,XB,DM)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20, ap_ImmUnsigned_22_23}},
-	{XXPERM, 0xfc0007f8, 0xf00000d0, 0x0, // VSX Permute XX3-form (xxperm XT,XA,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
-	{XXSEL, 0xfc000030, 0xf0000030, 0x0, // VSX Select XX4-form (xxsel XT,XA,XB,XC)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20, ap_VecSReg_28_28_21_25}},
-	{XXSLDWI, 0xfc0004f8, 0xf0000010, 0x0, // VSX Shift Left Double by Word Immediate XX3-form (xxsldwi XT,XA,XB,SHW)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20, ap_ImmUnsigned_22_23}},
-	{XXSPLTW, 0xfc0007fc, 0xf0000290, 0x1c0000, // VSX Splat Word XX2-form (xxspltw XT,XB,UIM)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20, ap_ImmUnsigned_14_15}},
-	{XXBRD, 0xfc1f07fc, 0xf017076c, 0x0, // VSX Vector Byte-Reverse Doubleword XX2-form (xxbrd XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XXBRW, 0xfc1f07fc, 0xf00f076c, 0x0, // VSX Vector Byte-Reverse Word XX2-form (xxbrw XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{XXBRH, 0xfc1f07fc, 0xf007076c, 0x0, // VSX Vector Byte-Reverse Halfword XX2-form (xxbrh XT,XB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
-	{BRINC, 0xfc0007ff, 0x1000020f, 0x0, // Bit Reversed Increment EVX-form (brinc RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVABS, 0xfc0007ff, 0x10000208, 0xf800, // Vector Absolute Value EVX-form (evabs RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EVADDIW, 0xfc0007ff, 0x10000202, 0x0, // Vector Add Immediate Word EVX-form (evaddiw RT,RB,UI)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20, ap_ImmUnsigned_11_15}},
-	{EVADDSMIAAW, 0xfc0007ff, 0x100004c9, 0xf800, // Vector Add Signed, Modulo, Integer to Accumulator Word EVX-form (evaddsmiaaw RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EVADDSSIAAW, 0xfc0007ff, 0x100004c1, 0xf800, // Vector Add Signed, Saturate, Integer to Accumulator Word EVX-form (evaddssiaaw RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EVADDUMIAAW, 0xfc0007ff, 0x100004c8, 0xf800, // Vector Add Unsigned, Modulo, Integer to Accumulator Word EVX-form (evaddumiaaw RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EVADDUSIAAW, 0xfc0007ff, 0x100004c0, 0xf800, // Vector Add Unsigned, Saturate, Integer to Accumulator Word EVX-form (evaddusiaaw RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EVADDW, 0xfc0007ff, 0x10000200, 0x0, // Vector Add Word EVX-form (evaddw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVAND, 0xfc0007ff, 0x10000211, 0x0, // Vector AND EVX-form (evand RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVCMPEQ, 0xfc0007ff, 0x10000234, 0x600000, // Vector Compare Equal EVX-form (evcmpeq BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVANDC, 0xfc0007ff, 0x10000212, 0x0, // Vector AND with Complement EVX-form (evandc RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVCMPGTS, 0xfc0007ff, 0x10000231, 0x600000, // Vector Compare Greater Than Signed EVX-form (evcmpgts BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVCMPGTU, 0xfc0007ff, 0x10000230, 0x600000, // Vector Compare Greater Than Unsigned EVX-form (evcmpgtu BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVCMPLTU, 0xfc0007ff, 0x10000232, 0x600000, // Vector Compare Less Than Unsigned EVX-form (evcmpltu BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVCMPLTS, 0xfc0007ff, 0x10000233, 0x600000, // Vector Compare Less Than Signed EVX-form (evcmplts BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVCNTLSW, 0xfc0007ff, 0x1000020e, 0xf800, // Vector Count Leading Signed Bits Word EVX-form (evcntlsw RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EVCNTLZW, 0xfc0007ff, 0x1000020d, 0xf800, // Vector Count Leading Zeros Word EVX-form (evcntlzw RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EVDIVWS, 0xfc0007ff, 0x100004c6, 0x0, // Vector Divide Word Signed EVX-form (evdivws RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVDIVWU, 0xfc0007ff, 0x100004c7, 0x0, // Vector Divide Word Unsigned EVX-form (evdivwu RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVEQV, 0xfc0007ff, 0x10000219, 0x0, // Vector Equivalent EVX-form (eveqv RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVEXTSB, 0xfc0007ff, 0x1000020a, 0xf800, // Vector Extend Sign Byte EVX-form (evextsb RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EVEXTSH, 0xfc0007ff, 0x1000020b, 0xf800, // Vector Extend Sign Halfword EVX-form (evextsh RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EVLDD, 0xfc0007ff, 0x10000301, 0x0, // Vector Load Double Word into Double Word EVX-form (evldd RT,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_Reg_11_15}},
-	{EVLDH, 0xfc0007ff, 0x10000305, 0x0, // Vector Load Double into Four Halfwords EVX-form (evldh RT,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_Reg_11_15}},
-	{EVLDDX, 0xfc0007ff, 0x10000300, 0x0, // Vector Load Double Word into Double Word Indexed EVX-form (evlddx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVLDHX, 0xfc0007ff, 0x10000304, 0x0, // Vector Load Double into Four Halfwords Indexed EVX-form (evldhx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVLDW, 0xfc0007ff, 0x10000303, 0x0, // Vector Load Double into Two Words EVX-form (evldw RT,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_Reg_11_15}},
-	{EVLHHESPLAT, 0xfc0007ff, 0x10000309, 0x0, // Vector Load Halfword into Halfwords Even and Splat EVX-form (evlhhesplat RT,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_Reg_11_15}},
-	{EVLDWX, 0xfc0007ff, 0x10000302, 0x0, // Vector Load Double into Two Words Indexed EVX-form (evldwx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVLHHESPLATX, 0xfc0007ff, 0x10000308, 0x0, // Vector Load Halfword into Halfwords Even and Splat Indexed EVX-form (evlhhesplatx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVLHHOSSPLAT, 0xfc0007ff, 0x1000030f, 0x0, // Vector Load Halfword into Halfword Odd Signed and Splat EVX-form (evlhhossplat RT,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_Reg_11_15}},
-	{EVLHHOUSPLAT, 0xfc0007ff, 0x1000030d, 0x0, // Vector Load Halfword into Halfword Odd Unsigned and Splat EVX-form (evlhhousplat RT,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_Reg_11_15}},
-	{EVLHHOSSPLATX, 0xfc0007ff, 0x1000030e, 0x0, // Vector Load Halfword into Halfword Odd Signed and Splat Indexed EVX-form (evlhhossplatx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVLHHOUSPLATX, 0xfc0007ff, 0x1000030c, 0x0, // Vector Load Halfword into Halfword Odd Unsigned and Splat Indexed EVX-form (evlhhousplatx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVLWHE, 0xfc0007ff, 0x10000311, 0x0, // Vector Load Word into Two Halfwords Even EVX-form (evlwhe RT,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_Reg_11_15}},
-	{EVLWHOS, 0xfc0007ff, 0x10000317, 0x0, // Vector Load Word into Two Halfwords Odd Signed (with sign extension) EVX-form (evlwhos RT,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_Reg_11_15}},
-	{EVLWHEX, 0xfc0007ff, 0x10000310, 0x0, // Vector Load Word into Two Halfwords Even Indexed EVX-form (evlwhex RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVLWHOSX, 0xfc0007ff, 0x10000316, 0x0, // Vector Load Word into Two Halfwords Odd Signed Indexed (with sign extension) EVX-form (evlwhosx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVLWHOU, 0xfc0007ff, 0x10000315, 0x0, // Vector Load Word into Two Halfwords Odd Unsigned (zero-extended) EVX-form (evlwhou RT,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_Reg_11_15}},
-	{EVLWHSPLAT, 0xfc0007ff, 0x1000031d, 0x0, // Vector Load Word into Two Halfwords and Splat EVX-form (evlwhsplat RT,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_Reg_11_15}},
-	{EVLWHOUX, 0xfc0007ff, 0x10000314, 0x0, // Vector Load Word into Two Halfwords Odd Unsigned Indexed (zero-extended) EVX-form (evlwhoux RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVLWHSPLATX, 0xfc0007ff, 0x1000031c, 0x0, // Vector Load Word into Two Halfwords and Splat Indexed EVX-form (evlwhsplatx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVLWWSPLAT, 0xfc0007ff, 0x10000319, 0x0, // Vector Load Word into Word and Splat EVX-form (evlwwsplat RT,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_Reg_11_15}},
-	{EVMERGEHI, 0xfc0007ff, 0x1000022c, 0x0, // Vector Merge High EVX-form (evmergehi RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVLWWSPLATX, 0xfc0007ff, 0x10000318, 0x0, // Vector Load Word into Word and Splat Indexed EVX-form (evlwwsplatx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMERGELO, 0xfc0007ff, 0x1000022d, 0x0, // Vector Merge Low EVX-form (evmergelo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMERGEHILO, 0xfc0007ff, 0x1000022e, 0x0, // Vector Merge High/Low EVX-form (evmergehilo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHEGSMFAA, 0xfc0007ff, 0x1000052b, 0x0, // Vector Multiply Halfwords, Even, Guarded, Signed, Modulo, Fractional and Accumulate EVX-form (evmhegsmfaa RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMERGELOHI, 0xfc0007ff, 0x1000022f, 0x0, // Vector Merge Low/High EVX-form (evmergelohi RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHEGSMFAN, 0xfc0007ff, 0x100005ab, 0x0, // Vector Multiply Halfwords, Even, Guarded, Signed, Modulo, Fractional and Accumulate Negative EVX-form (evmhegsmfan RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHEGSMIAA, 0xfc0007ff, 0x10000529, 0x0, // Vector Multiply Halfwords, Even, Guarded, Signed, Modulo, Integer and Accumulate EVX-form (evmhegsmiaa RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHEGUMIAA, 0xfc0007ff, 0x10000528, 0x0, // Vector Multiply Halfwords, Even, Guarded, Unsigned, Modulo, Integer and Accumulate EVX-form (evmhegumiaa RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHEGSMIAN, 0xfc0007ff, 0x100005a9, 0x0, // Vector Multiply Halfwords, Even, Guarded, Signed, Modulo, Integer and Accumulate Negative EVX-form (evmhegsmian RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHEGUMIAN, 0xfc0007ff, 0x100005a8, 0x0, // Vector Multiply Halfwords, Even, Guarded, Unsigned, Modulo, Integer and Accumulate Negative EVX-form (evmhegumian RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHESMF, 0xfc0007ff, 0x1000040b, 0x0, // Vector Multiply Halfwords, Even, Signed, Modulo, Fractional EVX-form (evmhesmf RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHESMFAAW, 0xfc0007ff, 0x1000050b, 0x0, // Vector Multiply Halfwords, Even, Signed, Modulo, Fractional and Accumulate into Words EVX-form (evmhesmfaaw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHESMFA, 0xfc0007ff, 0x1000042b, 0x0, // Vector Multiply Halfwords, Even, Signed, Modulo, Fractional to Accumulator EVX-form (evmhesmfa RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHESMFANW, 0xfc0007ff, 0x1000058b, 0x0, // Vector Multiply Halfwords, Even, Signed, Modulo, Fractional and Accumulate Negative into Words EVX-form (evmhesmfanw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHESMI, 0xfc0007ff, 0x10000409, 0x0, // Vector Multiply Halfwords, Even, Signed, Modulo, Integer EVX-form (evmhesmi RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHESMIAAW, 0xfc0007ff, 0x10000509, 0x0, // Vector Multiply Halfwords, Even, Signed, Modulo, Integer and Accumulate into Words EVX-form (evmhesmiaaw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHESMIA, 0xfc0007ff, 0x10000429, 0x0, // Vector Multiply Halfwords, Even, Signed, Modulo, Integer to Accumulator EVX-form (evmhesmia RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHESMIANW, 0xfc0007ff, 0x10000589, 0x0, // Vector Multiply Halfwords, Even, Signed, Modulo, Integer and Accumulate Negative into Words EVX-form (evmhesmianw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHESSF, 0xfc0007ff, 0x10000403, 0x0, // Vector Multiply Halfwords, Even, Signed, Saturate, Fractional EVX-form (evmhessf RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHESSFA, 0xfc0007ff, 0x10000423, 0x0, // Vector Multiply Halfwords, Even, Signed, Saturate, Fractional to Accumulator EVX-form (evmhessfa RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHESSFAAW, 0xfc0007ff, 0x10000503, 0x0, // Vector Multiply Halfwords, Even, Signed, Saturate, Fractional and Accumulate into Words EVX-form (evmhessfaaw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHESSFANW, 0xfc0007ff, 0x10000583, 0x0, // Vector Multiply Halfwords, Even, Signed, Saturate, Fractional and Accumulate Negative into Words EVX-form (evmhessfanw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHESSIAAW, 0xfc0007ff, 0x10000501, 0x0, // Vector Multiply Halfwords, Even, Signed, Saturate, Integer and Accumulate into Words EVX-form (evmhessiaaw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHESSIANW, 0xfc0007ff, 0x10000581, 0x0, // Vector Multiply Halfwords, Even, Signed, Saturate, Integer and Accumulate Negative into Words EVX-form (evmhessianw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHEUMI, 0xfc0007ff, 0x10000408, 0x0, // Vector Multiply Halfwords, Even, Unsigned, Modulo, Integer EVX-form (evmheumi RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHEUMIAAW, 0xfc0007ff, 0x10000508, 0x0, // Vector Multiply Halfwords, Even, Unsigned, Modulo, Integer and Accumulate into Words EVX-form (evmheumiaaw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHEUMIA, 0xfc0007ff, 0x10000428, 0x0, // Vector Multiply Halfwords, Even, Unsigned, Modulo, Integer to Accumulator EVX-form (evmheumia RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHEUMIANW, 0xfc0007ff, 0x10000588, 0x0, // Vector Multiply Halfwords, Even, Unsigned, Modulo, Integer and Accumulate Negative into Words EVX-form (evmheumianw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHEUSIAAW, 0xfc0007ff, 0x10000500, 0x0, // Vector Multiply Halfwords, Even, Unsigned, Saturate, Integer and Accumulate into Words EVX-form (evmheusiaaw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHEUSIANW, 0xfc0007ff, 0x10000580, 0x0, // Vector Multiply Halfwords, Even, Unsigned, Saturate, Integer and Accumulate Negative into Words EVX-form (evmheusianw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOGSMFAA, 0xfc0007ff, 0x1000052f, 0x0, // Vector Multiply Halfwords, Odd, Guarded, Signed, Modulo, Fractional and Accumulate EVX-form (evmhogsmfaa RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOGSMIAA, 0xfc0007ff, 0x1000052d, 0x0, // Vector Multiply Halfwords, Odd, Guarded, Signed, Modulo, Integer and Accumulate EVX-form (evmhogsmiaa RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOGSMFAN, 0xfc0007ff, 0x100005af, 0x0, // Vector Multiply Halfwords, Odd, Guarded, Signed, Modulo, Fractional and Accumulate Negative EVX-form (evmhogsmfan RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOGSMIAN, 0xfc0007ff, 0x100005ad, 0x0, // Vector Multiply Halfwords, Odd, Guarded, Signed, Modulo, Integer and Accumulate Negative EVX-form (evmhogsmian RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOGUMIAA, 0xfc0007ff, 0x1000052c, 0x0, // Vector Multiply Halfwords, Odd, Guarded, Unsigned, Modulo, Integer and Accumulate EVX-form (evmhogumiaa RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOSMF, 0xfc0007ff, 0x1000040f, 0x0, // Vector Multiply Halfwords, Odd, Signed, Modulo, Fractional EVX-form (evmhosmf RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOGUMIAN, 0xfc0007ff, 0x100005ac, 0x0, // Vector Multiply Halfwords, Odd, Guarded, Unsigned, Modulo, Integer and Accumulate Negative EVX-form (evmhogumian RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOSMFA, 0xfc0007ff, 0x1000042f, 0x0, // Vector Multiply Halfwords, Odd, Signed, Modulo, Fractional to Accumulator EVX-form (evmhosmfa RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOSMFAAW, 0xfc0007ff, 0x1000050f, 0x0, // Vector Multiply Halfwords, Odd, Signed, Modulo, Fractional and Accumulate into Words EVX-form (evmhosmfaaw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOSMI, 0xfc0007ff, 0x1000040d, 0x0, // Vector Multiply Halfwords, Odd, Signed, Modulo, Integer EVX-form (evmhosmi RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOSMFANW, 0xfc0007ff, 0x1000058f, 0x0, // Vector Multiply Halfwords, Odd, Signed, Modulo, Fractional and Accumulate Negative into Words EVX-form (evmhosmfanw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOSMIA, 0xfc0007ff, 0x1000042d, 0x0, // Vector Multiply Halfwords, Odd, Signed, Modulo, Integer to Accumulator EVX-form (evmhosmia RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOSMIAAW, 0xfc0007ff, 0x1000050d, 0x0, // Vector Multiply Halfwords, Odd, Signed, Modulo, Integer and Accumulate into Words EVX-form (evmhosmiaaw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOSMIANW, 0xfc0007ff, 0x1000058d, 0x0, // Vector Multiply Halfwords, Odd, Signed, Modulo, Integer and Accumulate Negative into Words EVX-form (evmhosmianw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOSSF, 0xfc0007ff, 0x10000407, 0x0, // Vector Multiply Halfwords, Odd, Signed, Saturate, Fractional EVX-form (evmhossf RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOSSFA, 0xfc0007ff, 0x10000427, 0x0, // Vector Multiply Halfwords, Odd, Signed, Saturate, Fractional to Accumulator EVX-form (evmhossfa RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOSSFAAW, 0xfc0007ff, 0x10000507, 0x0, // Vector Multiply Halfwords, Odd, Signed, Saturate, Fractional and Accumulate into Words EVX-form (evmhossfaaw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOSSFANW, 0xfc0007ff, 0x10000587, 0x0, // Vector Multiply Halfwords, Odd, Signed, Saturate, Fractional and Accumulate Negative into Words EVX-form (evmhossfanw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOSSIAAW, 0xfc0007ff, 0x10000505, 0x0, // Vector Multiply Halfwords, Odd, Signed, Saturate, Integer and Accumulate into Words EVX-form (evmhossiaaw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOUMI, 0xfc0007ff, 0x1000040c, 0x0, // Vector Multiply Halfwords, Odd, Unsigned, Modulo, Integer EVX-form (evmhoumi RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOSSIANW, 0xfc0007ff, 0x10000585, 0x0, // Vector Multiply Halfwords, Odd, Signed, Saturate, Integer and Accumulate Negative into Words EVX-form (evmhossianw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOUMIA, 0xfc0007ff, 0x1000042c, 0x0, // Vector Multiply Halfwords, Odd, Unsigned, Modulo, Integer to Accumulator EVX-form (evmhoumia RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOUMIAAW, 0xfc0007ff, 0x1000050c, 0x0, // Vector Multiply Halfwords, Odd, Unsigned, Modulo, Integer and Accumulate into Words EVX-form (evmhoumiaaw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOUSIAAW, 0xfc0007ff, 0x10000504, 0x0, // Vector Multiply Halfwords, Odd, Unsigned, Saturate, Integer and Accumulate into Words EVX-form (evmhousiaaw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOUMIANW, 0xfc0007ff, 0x1000058c, 0x0, // Vector Multiply Halfwords, Odd, Unsigned, Modulo, Integer and Accumulate Negative into Words EVX-form (evmhoumianw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMHOUSIANW, 0xfc0007ff, 0x10000584, 0x0, // Vector Multiply Halfwords, Odd, Unsigned, Saturate, Integer and Accumulate Negative into Words EVX-form (evmhousianw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMRA, 0xfc0007ff, 0x100004c4, 0xf800, // Initialize Accumulator EVX-form (evmra RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EVMWHSMF, 0xfc0007ff, 0x1000044f, 0x0, // Vector Multiply Word High Signed, Modulo, Fractional EVX-form (evmwhsmf RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWHSMI, 0xfc0007ff, 0x1000044d, 0x0, // Vector Multiply Word High Signed, Modulo, Integer EVX-form (evmwhsmi RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWHSMFA, 0xfc0007ff, 0x1000046f, 0x0, // Vector Multiply Word High Signed, Modulo, Fractional to Accumulator EVX-form (evmwhsmfa RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWHSMIA, 0xfc0007ff, 0x1000046d, 0x0, // Vector Multiply Word High Signed, Modulo, Integer to Accumulator EVX-form (evmwhsmia RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWHSSF, 0xfc0007ff, 0x10000447, 0x0, // Vector Multiply Word High Signed, Saturate, Fractional EVX-form (evmwhssf RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWHUMI, 0xfc0007ff, 0x1000044c, 0x0, // Vector Multiply Word High Unsigned, Modulo, Integer EVX-form (evmwhumi RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWHSSFA, 0xfc0007ff, 0x10000467, 0x0, // Vector Multiply Word High Signed, Saturate, Fractional to Accumulator EVX-form (evmwhssfa RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWHUMIA, 0xfc0007ff, 0x1000046c, 0x0, // Vector Multiply Word High Unsigned, Modulo, Integer to Accumulator EVX-form (evmwhumia RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWLSMIAAW, 0xfc0007ff, 0x10000549, 0x0, // Vector Multiply Word Low Signed, Modulo, Integer and Accumulate into Words EVX-form (evmwlsmiaaw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWLSSIAAW, 0xfc0007ff, 0x10000541, 0x0, // Vector Multiply Word Low Signed, Saturate, Integer and Accumulate into Words EVX-form (evmwlssiaaw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWLSMIANW, 0xfc0007ff, 0x100005c9, 0x0, // Vector Multiply Word Low Signed, Modulo, Integer and Accumulate Negative in Words EVX-form (evmwlsmianw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWLSSIANW, 0xfc0007ff, 0x100005c1, 0x0, // Vector Multiply Word Low Signed, Saturate, Integer and Accumulate Negative in Words EVX-form (evmwlssianw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWLUMI, 0xfc0007ff, 0x10000448, 0x0, // Vector Multiply Word Low Unsigned, Modulo, Integer EVX-form (evmwlumi RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWLUMIAAW, 0xfc0007ff, 0x10000548, 0x0, // Vector Multiply Word Low Unsigned, Modulo, Integer and Accumulate into Words EVX-form (evmwlumiaaw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWLUMIA, 0xfc0007ff, 0x10000468, 0x0, // Vector Multiply Word Low Unsigned, Modulo, Integer to Accumulator EVX-form (evmwlumia RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWLUMIANW, 0xfc0007ff, 0x100005c8, 0x0, // Vector Multiply Word Low Unsigned, Modulo, Integer and Accumulate Negative in Words EVX-form (evmwlumianw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWLUSIAAW, 0xfc0007ff, 0x10000540, 0x0, // Vector Multiply Word Low Unsigned, Saturate, Integer and Accumulate into Words EVX-form (evmwlusiaaw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWSMF, 0xfc0007ff, 0x1000045b, 0x0, // Vector Multiply Word Signed, Modulo, Fractional EVX-form (evmwsmf RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWLUSIANW, 0xfc0007ff, 0x100005c0, 0x0, // Vector Multiply Word Low Unsigned, Saturate, Integer and Accumulate Negative in Words EVX-form (evmwlusianw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWSMFA, 0xfc0007ff, 0x1000047b, 0x0, // Vector Multiply Word Signed, Modulo, Fractional to Accumulator EVX-form (evmwsmfa RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWSMFAA, 0xfc0007ff, 0x1000055b, 0x0, // Vector Multiply Word Signed, Modulo, Fractional and Accumulate EVX-form (evmwsmfaa RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWSMI, 0xfc0007ff, 0x10000459, 0x0, // Vector Multiply Word Signed, Modulo, Integer EVX-form (evmwsmi RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWSMIAA, 0xfc0007ff, 0x10000559, 0x0, // Vector Multiply Word Signed, Modulo, Integer and Accumulate EVX-form (evmwsmiaa RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWSMFAN, 0xfc0007ff, 0x100005db, 0x0, // Vector Multiply Word Signed, Modulo, Fractional and Accumulate Negative EVX-form (evmwsmfan RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWSMIA, 0xfc0007ff, 0x10000479, 0x0, // Vector Multiply Word Signed, Modulo, Integer to Accumulator EVX-form (evmwsmia RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWSMIAN, 0xfc0007ff, 0x100005d9, 0x0, // Vector Multiply Word Signed, Modulo, Integer and Accumulate Negative EVX-form (evmwsmian RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWSSF, 0xfc0007ff, 0x10000453, 0x0, // Vector Multiply Word Signed, Saturate, Fractional EVX-form (evmwssf RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWSSFA, 0xfc0007ff, 0x10000473, 0x0, // Vector Multiply Word Signed, Saturate, Fractional to Accumulator EVX-form (evmwssfa RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWSSFAA, 0xfc0007ff, 0x10000553, 0x0, // Vector Multiply Word Signed, Saturate, Fractional and Accumulate EVX-form (evmwssfaa RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWUMI, 0xfc0007ff, 0x10000458, 0x0, // Vector Multiply Word Unsigned, Modulo, Integer EVX-form (evmwumi RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWSSFAN, 0xfc0007ff, 0x100005d3, 0x0, // Vector Multiply Word Signed, Saturate, Fractional and Accumulate Negative EVX-form (evmwssfan RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWUMIA, 0xfc0007ff, 0x10000478, 0x0, // Vector Multiply Word Unsigned, Modulo, Integer to Accumulator EVX-form (evmwumia RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWUMIAA, 0xfc0007ff, 0x10000558, 0x0, // Vector Multiply Word Unsigned, Modulo, Integer and Accumulate EVX-form (evmwumiaa RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVNAND, 0xfc0007ff, 0x1000021e, 0x0, // Vector NAND EVX-form (evnand RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVMWUMIAN, 0xfc0007ff, 0x100005d8, 0x0, // Vector Multiply Word Unsigned, Modulo, Integer and Accumulate Negative EVX-form (evmwumian RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVNEG, 0xfc0007ff, 0x10000209, 0xf800, // Vector Negate EVX-form (evneg RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EVNOR, 0xfc0007ff, 0x10000218, 0x0, // Vector NOR EVX-form (evnor RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVORC, 0xfc0007ff, 0x1000021b, 0x0, // Vector OR with Complement EVX-form (evorc RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVOR, 0xfc0007ff, 0x10000217, 0x0, // Vector OR EVX-form (evor RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVRLW, 0xfc0007ff, 0x10000228, 0x0, // Vector Rotate Left Word EVX-form (evrlw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVRLWI, 0xfc0007ff, 0x1000022a, 0x0, // Vector Rotate Left Word Immediate EVX-form (evrlwi RT,RA,UI)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_ImmUnsigned_16_20}},
-	{EVSEL, 0xfc0007f8, 0x10000278, 0x0, // Vector Select EVS-form (evsel RT,RA,RB,BFA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20, ap_CondRegField_29_31}},
-	{EVRNDW, 0xfc0007ff, 0x1000020c, 0xf800, // Vector Round Word EVX-form (evrndw RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EVSLW, 0xfc0007ff, 0x10000224, 0x0, // Vector Shift Left Word EVX-form (evslw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVSPLATFI, 0xfc0007ff, 0x1000022b, 0xf800, // Vector Splat Fractional Immediate EVX-form (evsplatfi RT,SI)
-		[5]*argField{ap_Reg_6_10, ap_ImmSigned_11_15}},
-	{EVSRWIS, 0xfc0007ff, 0x10000223, 0x0, // Vector Shift Right Word Immediate Signed EVX-form (evsrwis RT,RA,UI)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_ImmUnsigned_16_20}},
-	{EVSLWI, 0xfc0007ff, 0x10000226, 0x0, // Vector Shift Left Word Immediate EVX-form (evslwi RT,RA,UI)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_ImmUnsigned_16_20}},
-	{EVSPLATI, 0xfc0007ff, 0x10000229, 0xf800, // Vector Splat Immediate EVX-form (evsplati RT,SI)
-		[5]*argField{ap_Reg_6_10, ap_ImmSigned_11_15}},
-	{EVSRWIU, 0xfc0007ff, 0x10000222, 0x0, // Vector Shift Right Word Immediate Unsigned EVX-form (evsrwiu RT,RA,UI)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_ImmUnsigned_16_20}},
-	{EVSRWS, 0xfc0007ff, 0x10000221, 0x0, // Vector Shift Right Word Signed EVX-form (evsrws RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVSTDD, 0xfc0007ff, 0x10000321, 0x0, // Vector Store Double of Double EVX-form (evstdd RS,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_Reg_11_15}},
-	{EVSRWU, 0xfc0007ff, 0x10000220, 0x0, // Vector Shift Right Word Unsigned EVX-form (evsrwu RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVSTDDX, 0xfc0007ff, 0x10000320, 0x0, // Vector Store Double of Double Indexed EVX-form (evstddx RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVSTDH, 0xfc0007ff, 0x10000325, 0x0, // Vector Store Double of Four Halfwords EVX-form (evstdh RS,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_Reg_11_15}},
-	{EVSTDW, 0xfc0007ff, 0x10000323, 0x0, // Vector Store Double of Two Words EVX-form (evstdw RS,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_Reg_11_15}},
-	{EVSTDHX, 0xfc0007ff, 0x10000324, 0x0, // Vector Store Double of Four Halfwords Indexed EVX-form (evstdhx RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVSTDWX, 0xfc0007ff, 0x10000322, 0x0, // Vector Store Double of Two Words Indexed EVX-form (evstdwx RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVSTWHE, 0xfc0007ff, 0x10000331, 0x0, // Vector Store Word of Two Halfwords from Even EVX-form (evstwhe RS,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_Reg_11_15}},
-	{EVSTWHO, 0xfc0007ff, 0x10000335, 0x0, // Vector Store Word of Two Halfwords from Odd EVX-form (evstwho RS,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_Reg_11_15}},
-	{EVSTWWE, 0xfc0007ff, 0x10000339, 0x0, // Vector Store Word of Word from Even EVX-form (evstwwe RS,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_Reg_11_15}},
-	{EVSTWHEX, 0xfc0007ff, 0x10000330, 0x0, // Vector Store Word of Two Halfwords from Even Indexed EVX-form (evstwhex RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVSTWHOX, 0xfc0007ff, 0x10000334, 0x0, // Vector Store Word of Two Halfwords from Odd Indexed EVX-form (evstwhox RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVSTWWEX, 0xfc0007ff, 0x10000338, 0x0, // Vector Store Word of Word from Even Indexed EVX-form (evstwwex RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVSTWWO, 0xfc0007ff, 0x1000033d, 0x0, // Vector Store Word of Word from Odd EVX-form (evstwwo RS,D(RA))
-		[5]*argField{ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_Reg_11_15}},
-	{EVSUBFSMIAAW, 0xfc0007ff, 0x100004cb, 0xf800, // Vector Subtract Signed, Modulo, Integer to Accumulator Word EVX-form (evsubfsmiaaw RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EVSTWWOX, 0xfc0007ff, 0x1000033c, 0x0, // Vector Store Word of Word from Odd Indexed EVX-form (evstwwox RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVSUBFSSIAAW, 0xfc0007ff, 0x100004c3, 0xf800, // Vector Subtract Signed, Saturate, Integer to Accumulator Word EVX-form (evsubfssiaaw RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EVSUBFUMIAAW, 0xfc0007ff, 0x100004ca, 0xf800, // Vector Subtract Unsigned, Modulo, Integer to Accumulator Word EVX-form (evsubfumiaaw RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EVSUBFUSIAAW, 0xfc0007ff, 0x100004c2, 0xf800, // Vector Subtract Unsigned, Saturate, Integer to Accumulator Word EVX-form (evsubfusiaaw RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EVSUBFW, 0xfc0007ff, 0x10000204, 0x0, // Vector Subtract from Word EVX-form (evsubfw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVSUBIFW, 0xfc0007ff, 0x10000206, 0x0, // Vector Subtract Immediate from Word EVX-form (evsubifw RT,UI,RB)
-		[5]*argField{ap_Reg_6_10, ap_ImmUnsigned_11_15, ap_Reg_16_20}},
-	{EVXOR, 0xfc0007ff, 0x10000216, 0x0, // Vector XOR EVX-form (evxor RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVFSABS, 0xfc0007ff, 0x10000284, 0xf800, // Vector Floating-Point Single-Precision Absolute Value EVX-form (evfsabs RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EVFSNABS, 0xfc0007ff, 0x10000285, 0xf800, // Vector Floating-Point Single-Precision Negative Absolute Value EVX-form (evfsnabs RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EVFSNEG, 0xfc0007ff, 0x10000286, 0xf800, // Vector Floating-Point Single-Precision Negate EVX-form (evfsneg RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EVFSADD, 0xfc0007ff, 0x10000280, 0x0, // Vector Floating-Point Single-Precision Add EVX-form (evfsadd RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVFSMUL, 0xfc0007ff, 0x10000288, 0x0, // Vector Floating-Point Single-Precision Multiply EVX-form (evfsmul RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVFSSUB, 0xfc0007ff, 0x10000281, 0x0, // Vector Floating-Point Single-Precision Subtract EVX-form (evfssub RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVFSDIV, 0xfc0007ff, 0x10000289, 0x0, // Vector Floating-Point Single-Precision Divide EVX-form (evfsdiv RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVFSCMPGT, 0xfc0007ff, 0x1000028c, 0x600000, // Vector Floating-Point Single-Precision Compare Greater Than EVX-form (evfscmpgt BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVFSCMPLT, 0xfc0007ff, 0x1000028d, 0x600000, // Vector Floating-Point Single-Precision Compare Less Than EVX-form (evfscmplt BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVFSCMPEQ, 0xfc0007ff, 0x1000028e, 0x600000, // Vector Floating-Point Single-Precision Compare Equal EVX-form (evfscmpeq BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVFSTSTGT, 0xfc0007ff, 0x1000029c, 0x600000, // Vector Floating-Point Single-Precision Test Greater Than EVX-form (evfststgt BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVFSTSTLT, 0xfc0007ff, 0x1000029d, 0x600000, // Vector Floating-Point Single-Precision Test Less Than EVX-form (evfststlt BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVFSTSTEQ, 0xfc0007ff, 0x1000029e, 0x600000, // Vector Floating-Point Single-Precision Test Equal EVX-form (evfststeq BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVFSCFSI, 0xfc0007ff, 0x10000291, 0x1f0000, // Vector Convert Floating-Point Single-Precision from Signed Integer EVX-form (evfscfsi RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EVFSCFSF, 0xfc0007ff, 0x10000293, 0x1f0000, // Vector Convert Floating-Point Single-Precision from Signed Fraction EVX-form (evfscfsf RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EVFSCFUI, 0xfc0007ff, 0x10000290, 0x1f0000, // Vector Convert Floating-Point Single-Precision from Unsigned Integer EVX-form (evfscfui RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EVFSCFUF, 0xfc0007ff, 0x10000292, 0x1f0000, // Vector Convert Floating-Point Single-Precision from Unsigned Fraction EVX-form (evfscfuf RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EVFSCTSI, 0xfc0007ff, 0x10000295, 0x1f0000, // Vector Convert Floating-Point Single-Precision to Signed Integer EVX-form (evfsctsi RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EVFSCTUI, 0xfc0007ff, 0x10000294, 0x1f0000, // Vector Convert Floating-Point Single-Precision to Unsigned Integer EVX-form (evfsctui RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EVFSCTSIZ, 0xfc0007ff, 0x1000029a, 0x1f0000, // Vector Convert Floating-Point Single-Precision to Signed Integer with Round toward Zero EVX-form (evfsctsiz RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EVFSCTUIZ, 0xfc0007ff, 0x10000298, 0x1f0000, // Vector Convert Floating-Point Single-Precision to Unsigned Integer with Round toward Zero EVX-form (evfsctuiz RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EVFSCTSF, 0xfc0007ff, 0x10000297, 0x1f0000, // Vector Convert Floating-Point Single-Precision to Signed Fraction EVX-form (evfsctsf RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EVFSCTUF, 0xfc0007ff, 0x10000296, 0x1f0000, // Vector Convert Floating-Point Single-Precision to Unsigned Fraction EVX-form (evfsctuf RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFSABS, 0xfc0007ff, 0x100002c4, 0xf800, // Floating-Point Single-Precision Absolute Value EVX-form (efsabs RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EFSNEG, 0xfc0007ff, 0x100002c6, 0xf800, // Floating-Point Single-Precision Negate EVX-form (efsneg RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EFSNABS, 0xfc0007ff, 0x100002c5, 0xf800, // Floating-Point Single-Precision Negative Absolute Value EVX-form (efsnabs RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EFSADD, 0xfc0007ff, 0x100002c0, 0x0, // Floating-Point Single-Precision Add EVX-form (efsadd RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EFSMUL, 0xfc0007ff, 0x100002c8, 0x0, // Floating-Point Single-Precision Multiply EVX-form (efsmul RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EFSSUB, 0xfc0007ff, 0x100002c1, 0x0, // Floating-Point Single-Precision Subtract EVX-form (efssub RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EFSDIV, 0xfc0007ff, 0x100002c9, 0x0, // Floating-Point Single-Precision Divide EVX-form (efsdiv RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EFSCMPGT, 0xfc0007ff, 0x100002cc, 0x600000, // Floating-Point Single-Precision Compare Greater Than EVX-form (efscmpgt BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{EFSCMPLT, 0xfc0007ff, 0x100002cd, 0x600000, // Floating-Point Single-Precision Compare Less Than EVX-form (efscmplt BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{EFSCMPEQ, 0xfc0007ff, 0x100002ce, 0x600000, // Floating-Point Single-Precision Compare Equal EVX-form (efscmpeq BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{EFSTSTGT, 0xfc0007ff, 0x100002dc, 0x600000, // Floating-Point Single-Precision Test Greater Than EVX-form (efststgt BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{EFSTSTLT, 0xfc0007ff, 0x100002dd, 0x600000, // Floating-Point Single-Precision Test Less Than EVX-form (efststlt BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{EFSTSTEQ, 0xfc0007ff, 0x100002de, 0x600000, // Floating-Point Single-Precision Test Equal EVX-form (efststeq BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{EFSCFSI, 0xfc0007ff, 0x100002d1, 0x1f0000, // Convert Floating-Point Single-Precision from Signed Integer EVX-form (efscfsi RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFSCFSF, 0xfc0007ff, 0x100002d3, 0x1f0000, // Convert Floating-Point Single-Precision from Signed Fraction EVX-form (efscfsf RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFSCTSI, 0xfc0007ff, 0x100002d5, 0x1f0000, // Convert Floating-Point Single-Precision to Signed Integer EVX-form (efsctsi RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFSCFUI, 0xfc0007ff, 0x100002d0, 0x1f0000, // Convert Floating-Point Single-Precision from Unsigned Integer EVX-form (efscfui RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFSCFUF, 0xfc0007ff, 0x100002d2, 0x1f0000, // Convert Floating-Point Single-Precision from Unsigned Fraction EVX-form (efscfuf RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFSCTUI, 0xfc0007ff, 0x100002d4, 0x1f0000, // Convert Floating-Point Single-Precision to Unsigned Integer EVX-form (efsctui RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFSCTSIZ, 0xfc0007ff, 0x100002da, 0x1f0000, // Convert Floating-Point Single-Precision to Signed Integer with Round toward Zero EVX-form (efsctsiz RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFSCTSF, 0xfc0007ff, 0x100002d7, 0x1f0000, // Convert Floating-Point Single-Precision to Signed Fraction EVX-form (efsctsf RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFSCTUIZ, 0xfc0007ff, 0x100002d8, 0x1f0000, // Convert Floating-Point Single-Precision to Unsigned Integer with Round toward Zero EVX-form (efsctuiz RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFSCTUF, 0xfc0007ff, 0x100002d6, 0x1f0000, // Convert Floating-Point Single-Precision to Unsigned Fraction EVX-form (efsctuf RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFDABS, 0xfc0007ff, 0x100002e4, 0xf800, // Floating-Point Double-Precision Absolute Value EVX-form (efdabs RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EFDNEG, 0xfc0007ff, 0x100002e6, 0xf800, // Floating-Point Double-Precision Negate EVX-form (efdneg RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EFDNABS, 0xfc0007ff, 0x100002e5, 0xf800, // Floating-Point Double-Precision Negative Absolute Value EVX-form (efdnabs RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{EFDADD, 0xfc0007ff, 0x100002e0, 0x0, // Floating-Point Double-Precision Add EVX-form (efdadd RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EFDMUL, 0xfc0007ff, 0x100002e8, 0x0, // Floating-Point Double-Precision Multiply EVX-form (efdmul RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EFDSUB, 0xfc0007ff, 0x100002e1, 0x0, // Floating-Point Double-Precision Subtract EVX-form (efdsub RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EFDDIV, 0xfc0007ff, 0x100002e9, 0x0, // Floating-Point Double-Precision Divide EVX-form (efddiv RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EFDCMPGT, 0xfc0007ff, 0x100002ec, 0x600000, // Floating-Point Double-Precision Compare Greater Than EVX-form (efdcmpgt BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{EFDCMPEQ, 0xfc0007ff, 0x100002ee, 0x600000, // Floating-Point Double-Precision Compare Equal EVX-form (efdcmpeq BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{EFDCMPLT, 0xfc0007ff, 0x100002ed, 0x600000, // Floating-Point Double-Precision Compare Less Than EVX-form (efdcmplt BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{EFDTSTGT, 0xfc0007ff, 0x100002fc, 0x600000, // Floating-Point Double-Precision Test Greater Than EVX-form (efdtstgt BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{EFDTSTLT, 0xfc0007ff, 0x100002fd, 0x600000, // Floating-Point Double-Precision Test Less Than EVX-form (efdtstlt BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{EFDCFSI, 0xfc0007ff, 0x100002f1, 0x1f0000, // Convert Floating-Point Double-Precision from Signed Integer EVX-form (efdcfsi RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFDTSTEQ, 0xfc0007ff, 0x100002fe, 0x600000, // Floating-Point Double-Precision Test Equal EVX-form (efdtsteq BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{EFDCFUI, 0xfc0007ff, 0x100002f0, 0x1f0000, // Convert Floating-Point Double-Precision from Unsigned Integer EVX-form (efdcfui RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFDCFSID, 0xfc0007ff, 0x100002e3, 0x1f0000, // Convert Floating-Point Double-Precision from Signed Integer Doubleword EVX-form (efdcfsid RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFDCFSF, 0xfc0007ff, 0x100002f3, 0x1f0000, // Convert Floating-Point Double-Precision from Signed Fraction EVX-form (efdcfsf RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFDCFUF, 0xfc0007ff, 0x100002f2, 0x1f0000, // Convert Floating-Point Double-Precision from Unsigned Fraction EVX-form (efdcfuf RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFDCFUID, 0xfc0007ff, 0x100002e2, 0x1f0000, // Convert Floating-Point Double-Precision from Unsigned Integer Doubleword EVX-form (efdcfuid RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFDCTSI, 0xfc0007ff, 0x100002f5, 0x1f0000, // Convert Floating-Point Double-Precision to Signed Integer EVX-form (efdctsi RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFDCTUI, 0xfc0007ff, 0x100002f4, 0x1f0000, // Convert Floating-Point Double-Precision to Unsigned Integer EVX-form (efdctui RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFDCTSIDZ, 0xfc0007ff, 0x100002eb, 0x1f0000, // Convert Floating-Point Double-Precision to Signed Integer Doubleword with Round toward Zero EVX-form (efdctsidz RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFDCTUIDZ, 0xfc0007ff, 0x100002ea, 0x1f0000, // Convert Floating-Point Double-Precision to Unsigned Integer Doubleword with Round toward Zero EVX-form (efdctuidz RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFDCTSIZ, 0xfc0007ff, 0x100002fa, 0x1f0000, // Convert Floating-Point Double-Precision to Signed Integer with Round toward Zero EVX-form (efdctsiz RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFDCTSF, 0xfc0007ff, 0x100002f7, 0x1f0000, // Convert Floating-Point Double-Precision to Signed Fraction EVX-form (efdctsf RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFDCTUF, 0xfc0007ff, 0x100002f6, 0x1f0000, // Convert Floating-Point Double-Precision to Unsigned Fraction EVX-form (efdctuf RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFDCTUIZ, 0xfc0007ff, 0x100002f8, 0x1f0000, // Convert Floating-Point Double-Precision to Unsigned Integer with Round toward Zero EVX-form (efdctuiz RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFDCFS, 0xfc0007ff, 0x100002ef, 0x1f0000, // Floating-Point Double-Precision Convert from Single-Precision EVX-form (efdcfs RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{EFSCFD, 0xfc0007ff, 0x100002cf, 0x1f0000, // Floating-Point Single-Precision Convert from Double-Precision EVX-form (efscfd RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{DLMZB, 0xfc0007ff, 0x7c00009c, 0x0, // Determine Leftmost Zero Byte X-form (dlmzb RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{DLMZBCC, 0xfc0007ff, 0x7c00009d, 0x0, // Determine Leftmost Zero Byte X-form (dlmzb. RA,RS,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{MACCHW, 0xfc0007ff, 0x10000158, 0x0, // Multiply Accumulate Cross Halfword to Word Modulo Signed XO-form (macchw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACCHWCC, 0xfc0007ff, 0x10000159, 0x0, // Multiply Accumulate Cross Halfword to Word Modulo Signed XO-form (macchw. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACCHWO, 0xfc0007ff, 0x10000558, 0x0, // Multiply Accumulate Cross Halfword to Word Modulo Signed XO-form (macchwo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACCHWOCC, 0xfc0007ff, 0x10000559, 0x0, // Multiply Accumulate Cross Halfword to Word Modulo Signed XO-form (macchwo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACCHWS, 0xfc0007ff, 0x100001d8, 0x0, // Multiply Accumulate Cross Halfword to Word Saturate Signed XO-form (macchws RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACCHWSCC, 0xfc0007ff, 0x100001d9, 0x0, // Multiply Accumulate Cross Halfword to Word Saturate Signed XO-form (macchws. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACCHWSO, 0xfc0007ff, 0x100005d8, 0x0, // Multiply Accumulate Cross Halfword to Word Saturate Signed XO-form (macchwso RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACCHWSOCC, 0xfc0007ff, 0x100005d9, 0x0, // Multiply Accumulate Cross Halfword to Word Saturate Signed XO-form (macchwso. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACCHWU, 0xfc0007ff, 0x10000118, 0x0, // Multiply Accumulate Cross Halfword to Word Modulo Unsigned XO-form (macchwu RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACCHWUCC, 0xfc0007ff, 0x10000119, 0x0, // Multiply Accumulate Cross Halfword to Word Modulo Unsigned XO-form (macchwu. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACCHWUO, 0xfc0007ff, 0x10000518, 0x0, // Multiply Accumulate Cross Halfword to Word Modulo Unsigned XO-form (macchwuo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACCHWUOCC, 0xfc0007ff, 0x10000519, 0x0, // Multiply Accumulate Cross Halfword to Word Modulo Unsigned XO-form (macchwuo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACCHWSU, 0xfc0007ff, 0x10000198, 0x0, // Multiply Accumulate Cross Halfword to Word Saturate Unsigned XO-form (macchwsu RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACCHWSUCC, 0xfc0007ff, 0x10000199, 0x0, // Multiply Accumulate Cross Halfword to Word Saturate Unsigned XO-form (macchwsu. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACCHWSUO, 0xfc0007ff, 0x10000598, 0x0, // Multiply Accumulate Cross Halfword to Word Saturate Unsigned XO-form (macchwsuo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACCHWSUOCC, 0xfc0007ff, 0x10000599, 0x0, // Multiply Accumulate Cross Halfword to Word Saturate Unsigned XO-form (macchwsuo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACHHW, 0xfc0007ff, 0x10000058, 0x0, // Multiply Accumulate High Halfword to Word Modulo Signed XO-form (machhw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACHHWCC, 0xfc0007ff, 0x10000059, 0x0, // Multiply Accumulate High Halfword to Word Modulo Signed XO-form (machhw. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACHHWO, 0xfc0007ff, 0x10000458, 0x0, // Multiply Accumulate High Halfword to Word Modulo Signed XO-form (machhwo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACHHWOCC, 0xfc0007ff, 0x10000459, 0x0, // Multiply Accumulate High Halfword to Word Modulo Signed XO-form (machhwo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACHHWS, 0xfc0007ff, 0x100000d8, 0x0, // Multiply Accumulate High Halfword to Word Saturate Signed XO-form (machhws RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACHHWSCC, 0xfc0007ff, 0x100000d9, 0x0, // Multiply Accumulate High Halfword to Word Saturate Signed XO-form (machhws. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACHHWSO, 0xfc0007ff, 0x100004d8, 0x0, // Multiply Accumulate High Halfword to Word Saturate Signed XO-form (machhwso RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACHHWSOCC, 0xfc0007ff, 0x100004d9, 0x0, // Multiply Accumulate High Halfword to Word Saturate Signed XO-form (machhwso. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACHHWU, 0xfc0007ff, 0x10000018, 0x0, // Multiply Accumulate High Halfword to Word Modulo Unsigned XO-form (machhwu RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACHHWUCC, 0xfc0007ff, 0x10000019, 0x0, // Multiply Accumulate High Halfword to Word Modulo Unsigned XO-form (machhwu. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACHHWUO, 0xfc0007ff, 0x10000418, 0x0, // Multiply Accumulate High Halfword to Word Modulo Unsigned XO-form (machhwuo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACHHWUOCC, 0xfc0007ff, 0x10000419, 0x0, // Multiply Accumulate High Halfword to Word Modulo Unsigned XO-form (machhwuo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACHHWSU, 0xfc0007ff, 0x10000098, 0x0, // Multiply Accumulate High Halfword to Word Saturate Unsigned XO-form (machhwsu RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACHHWSUCC, 0xfc0007ff, 0x10000099, 0x0, // Multiply Accumulate High Halfword to Word Saturate Unsigned XO-form (machhwsu. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACHHWSUO, 0xfc0007ff, 0x10000498, 0x0, // Multiply Accumulate High Halfword to Word Saturate Unsigned XO-form (machhwsuo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACHHWSUOCC, 0xfc0007ff, 0x10000499, 0x0, // Multiply Accumulate High Halfword to Word Saturate Unsigned XO-form (machhwsuo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACLHW, 0xfc0007ff, 0x10000358, 0x0, // Multiply Accumulate Low Halfword to Word Modulo Signed XO-form (maclhw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACLHWCC, 0xfc0007ff, 0x10000359, 0x0, // Multiply Accumulate Low Halfword to Word Modulo Signed XO-form (maclhw. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACLHWO, 0xfc0007ff, 0x10000758, 0x0, // Multiply Accumulate Low Halfword to Word Modulo Signed XO-form (maclhwo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACLHWOCC, 0xfc0007ff, 0x10000759, 0x0, // Multiply Accumulate Low Halfword to Word Modulo Signed XO-form (maclhwo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACLHWS, 0xfc0007ff, 0x100003d8, 0x0, // Multiply Accumulate Low Halfword to Word Saturate Signed XO-form (maclhws RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACLHWSCC, 0xfc0007ff, 0x100003d9, 0x0, // Multiply Accumulate Low Halfword to Word Saturate Signed XO-form (maclhws. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACLHWSO, 0xfc0007ff, 0x100007d8, 0x0, // Multiply Accumulate Low Halfword to Word Saturate Signed XO-form (maclhwso RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACLHWSOCC, 0xfc0007ff, 0x100007d9, 0x0, // Multiply Accumulate Low Halfword to Word Saturate Signed XO-form (maclhwso. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACLHWU, 0xfc0007ff, 0x10000318, 0x0, // Multiply Accumulate Low Halfword to Word Modulo Unsigned XO-form (maclhwu RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACLHWUCC, 0xfc0007ff, 0x10000319, 0x0, // Multiply Accumulate Low Halfword to Word Modulo Unsigned XO-form (maclhwu. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACLHWUO, 0xfc0007ff, 0x10000718, 0x0, // Multiply Accumulate Low Halfword to Word Modulo Unsigned XO-form (maclhwuo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACLHWUOCC, 0xfc0007ff, 0x10000719, 0x0, // Multiply Accumulate Low Halfword to Word Modulo Unsigned XO-form (maclhwuo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULCHW, 0xfc0007ff, 0x10000150, 0x0, // Multiply Cross Halfword to Word Signed X-form (mulchw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULCHWCC, 0xfc0007ff, 0x10000151, 0x0, // Multiply Cross Halfword to Word Signed X-form (mulchw. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACLHWSU, 0xfc0007ff, 0x10000398, 0x0, // Multiply Accumulate Low Halfword to Word Saturate Unsigned XO-form (maclhwsu RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACLHWSUCC, 0xfc0007ff, 0x10000399, 0x0, // Multiply Accumulate Low Halfword to Word Saturate Unsigned XO-form (maclhwsu. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACLHWSUO, 0xfc0007ff, 0x10000798, 0x0, // Multiply Accumulate Low Halfword to Word Saturate Unsigned XO-form (maclhwsuo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MACLHWSUOCC, 0xfc0007ff, 0x10000799, 0x0, // Multiply Accumulate Low Halfword to Word Saturate Unsigned XO-form (maclhwsuo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULCHWU, 0xfc0007ff, 0x10000110, 0x0, // Multiply Cross Halfword to Word Unsigned X-form (mulchwu RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULCHWUCC, 0xfc0007ff, 0x10000111, 0x0, // Multiply Cross Halfword to Word Unsigned X-form (mulchwu. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULHHW, 0xfc0007ff, 0x10000050, 0x0, // Multiply High Halfword to Word Signed X-form (mulhhw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULHHWCC, 0xfc0007ff, 0x10000051, 0x0, // Multiply High Halfword to Word Signed X-form (mulhhw. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULLHW, 0xfc0007ff, 0x10000350, 0x0, // Multiply Low Halfword to Word Signed X-form (mullhw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULLHWCC, 0xfc0007ff, 0x10000351, 0x0, // Multiply Low Halfword to Word Signed X-form (mullhw. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULHHWU, 0xfc0007ff, 0x10000010, 0x0, // Multiply High Halfword to Word Unsigned X-form (mulhhwu RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULHHWUCC, 0xfc0007ff, 0x10000011, 0x0, // Multiply High Halfword to Word Unsigned X-form (mulhhwu. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULLHWU, 0xfc0007ff, 0x10000310, 0x0, // Multiply Low Halfword to Word Unsigned X-form (mullhwu RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MULLHWUCC, 0xfc0007ff, 0x10000311, 0x0, // Multiply Low Halfword to Word Unsigned X-form (mullhwu. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{NMACCHW, 0xfc0007ff, 0x1000015c, 0x0, // Negative Multiply Accumulate Cross Halfword to Word Modulo Signed XO-form (nmacchw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{NMACCHWCC, 0xfc0007ff, 0x1000015d, 0x0, // Negative Multiply Accumulate Cross Halfword to Word Modulo Signed XO-form (nmacchw. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{NMACCHWO, 0xfc0007ff, 0x1000055c, 0x0, // Negative Multiply Accumulate Cross Halfword to Word Modulo Signed XO-form (nmacchwo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{NMACCHWOCC, 0xfc0007ff, 0x1000055d, 0x0, // Negative Multiply Accumulate Cross Halfword to Word Modulo Signed XO-form (nmacchwo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{NMACCHWS, 0xfc0007ff, 0x100001dc, 0x0, // Negative Multiply Accumulate Cross Halfword to Word Saturate Signed XO-form (nmacchws RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{NMACCHWSCC, 0xfc0007ff, 0x100001dd, 0x0, // Negative Multiply Accumulate Cross Halfword to Word Saturate Signed XO-form (nmacchws. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{NMACCHWSO, 0xfc0007ff, 0x100005dc, 0x0, // Negative Multiply Accumulate Cross Halfword to Word Saturate Signed XO-form (nmacchwso RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{NMACCHWSOCC, 0xfc0007ff, 0x100005dd, 0x0, // Negative Multiply Accumulate Cross Halfword to Word Saturate Signed XO-form (nmacchwso. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{NMACHHW, 0xfc0007ff, 0x1000005c, 0x0, // Negative Multiply Accumulate High Halfword to Word Modulo Signed XO-form (nmachhw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{NMACHHWCC, 0xfc0007ff, 0x1000005d, 0x0, // Negative Multiply Accumulate High Halfword to Word Modulo Signed XO-form (nmachhw. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{NMACHHWO, 0xfc0007ff, 0x1000045c, 0x0, // Negative Multiply Accumulate High Halfword to Word Modulo Signed XO-form (nmachhwo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{NMACHHWOCC, 0xfc0007ff, 0x1000045d, 0x0, // Negative Multiply Accumulate High Halfword to Word Modulo Signed XO-form (nmachhwo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{NMACHHWS, 0xfc0007ff, 0x100000dc, 0x0, // Negative Multiply Accumulate High Halfword to Word Saturate Signed XO-form (nmachhws RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{NMACHHWSCC, 0xfc0007ff, 0x100000dd, 0x0, // Negative Multiply Accumulate High Halfword to Word Saturate Signed XO-form (nmachhws. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{NMACHHWSO, 0xfc0007ff, 0x100004dc, 0x0, // Negative Multiply Accumulate High Halfword to Word Saturate Signed XO-form (nmachhwso RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{NMACHHWSOCC, 0xfc0007ff, 0x100004dd, 0x0, // Negative Multiply Accumulate High Halfword to Word Saturate Signed XO-form (nmachhwso. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{NMACLHW, 0xfc0007ff, 0x1000035c, 0x0, // Negative Multiply Accumulate Low Halfword to Word Modulo Signed XO-form (nmaclhw RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{NMACLHWCC, 0xfc0007ff, 0x1000035d, 0x0, // Negative Multiply Accumulate Low Halfword to Word Modulo Signed XO-form (nmaclhw. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{NMACLHWO, 0xfc0007ff, 0x1000075c, 0x0, // Negative Multiply Accumulate Low Halfword to Word Modulo Signed XO-form (nmaclhwo RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{NMACLHWOCC, 0xfc0007ff, 0x1000075d, 0x0, // Negative Multiply Accumulate Low Halfword to Word Modulo Signed XO-form (nmaclhwo. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{NMACLHWS, 0xfc0007ff, 0x100003dc, 0x0, // Negative Multiply Accumulate Low Halfword to Word Saturate Signed XO-form (nmaclhws RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{NMACLHWSCC, 0xfc0007ff, 0x100003dd, 0x0, // Negative Multiply Accumulate Low Halfword to Word Saturate Signed XO-form (nmaclhws. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{NMACLHWSO, 0xfc0007ff, 0x100007dc, 0x0, // Negative Multiply Accumulate Low Halfword to Word Saturate Signed XO-form (nmaclhwso RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{NMACLHWSOCC, 0xfc0007ff, 0x100007dd, 0x0, // Negative Multiply Accumulate Low Halfword to Word Saturate Signed XO-form (nmaclhwso. RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{ICBI, 0xfc0007fe, 0x7c0007ac, 0x3e00001, // Instruction Cache Block Invalidate X-form (icbi RA,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_16_20}},
-	{ICBT, 0xfc0007fe, 0x7c00002c, 0x2000001, // Instruction Cache Block Touch X-form (icbt CT, RA, RB)
-		[5]*argField{ap_ImmUnsigned_7_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DCBA, 0xfc0007fe, 0x7c0005ec, 0x3e00001, // Data Cache Block Allocate X-form (dcba RA,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_16_20}},
-	{DCBT, 0xfc0007fe, 0x7c00022c, 0x1, // Data Cache Block Touch X-form (dcbt RA,RB,TH)
-		[5]*argField{ap_Reg_11_15, ap_Reg_16_20, ap_ImmUnsigned_6_10}},
-	{DCBT, 0xfc0007fe, 0x7c00022c, 0x1, // Data Cache Block Touch X-form (dcbt TH,RA,RB)
-		[5]*argField{ap_ImmUnsigned_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DCBTST, 0xfc0007fe, 0x7c0001ec, 0x1, // Data Cache Block Touch for Store X-form (dcbtst RA,RB,TH)
-		[5]*argField{ap_Reg_11_15, ap_Reg_16_20, ap_ImmUnsigned_6_10}},
-	{DCBTST, 0xfc0007fe, 0x7c0001ec, 0x1, // Data Cache Block Touch for Store X-form (dcbtst TH,RA,RB)
-		[5]*argField{ap_ImmUnsigned_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DCBZ, 0xfc0007fe, 0x7c0007ec, 0x3e00001, // Data Cache Block set to Zero X-form (dcbz RA,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_16_20}},
-	{DCBST, 0xfc0007fe, 0x7c00006c, 0x3e00001, // Data Cache Block Store X-form (dcbst RA,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_16_20}},
-	{DCBF, 0xfc0007fe, 0x7c0000ac, 0x3800001, // Data Cache Block Flush X-form (dcbf RA,RB,L)
-		[5]*argField{ap_Reg_11_15, ap_Reg_16_20, ap_ImmUnsigned_9_10}},
-	{ISYNC, 0xfc0007fe, 0x4c00012c, 0x3fff801, // Instruction Synchronize XL-form (isync)
-		[5]*argField{}},
-	{LBARX, 0xfc0007ff, 0x7c000068, 0x0, // Load Byte And Reserve Indexed X-form [Category: Phased-In] (lbarx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LBARX, 0xfc0007fe, 0x7c000068, 0x0, // Load Byte And Reserve Indexed X-form [Category: Phased-In] (lbarx RT,RA,RB,EH)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20, ap_ImmUnsigned_31_31}},
-	{LHARX, 0xfc0007ff, 0x7c0000e8, 0x0, // Load Halfword And Reserve Indexed X-form [Category: Phased-In] (lharx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LHARX, 0xfc0007fe, 0x7c0000e8, 0x0, // Load Halfword And Reserve Indexed X-form [Category: Phased-In] (lharx RT,RA,RB,EH)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20, ap_ImmUnsigned_31_31}},
-	{LWARX, 0xfc0007ff, 0x7c000028, 0x0, // Load Word And Reserve Indexed X-form (lwarx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LWARX, 0xfc0007ff, 0x7c000028, 0x0, // Load Word And Reserve Indexed X-form (lwarx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LWARX, 0xfc0007fe, 0x7c000028, 0x0, // Load Word And Reserve Indexed X-form (lwarx RT,RA,RB,EH)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20, ap_ImmUnsigned_31_31}},
-	{STBCXCC, 0xfc0007ff, 0x7c00056d, 0x0, // Store Byte Conditional Indexed X-form [Category: Phased-In] (stbcx. RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STHCXCC, 0xfc0007ff, 0x7c0005ad, 0x0, // Store Halfword Conditional Indexed X-form [Category: Phased-In] (sthcx. RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STWCXCC, 0xfc0007ff, 0x7c00012d, 0x0, // Store Word Conditional Indexed X-form (stwcx. RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LDARX, 0xfc0007ff, 0x7c0000a8, 0x0, // Load Doubleword And Reserve Indexed X-form (ldarx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LDARX, 0xfc0007fe, 0x7c0000a8, 0x0, // Load Doubleword And Reserve Indexed X-form (ldarx RT,RA,RB,EH)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20, ap_ImmUnsigned_31_31}},
-	{STDCXCC, 0xfc0007ff, 0x7c0001ad, 0x0, // Store Doubleword Conditional Indexed X-form (stdcx. RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LQARX, 0xfc0007ff, 0x7c000228, 0x0, // Load Quadword And Reserve Indexed X-form (lqarx RTp,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LQARX, 0xfc0007fe, 0x7c000228, 0x0, // Load Quadword And Reserve Indexed X-form (lqarx RTp,RA,RB,EH)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20, ap_ImmUnsigned_31_31}},
-	{STQCXCC, 0xfc0007ff, 0x7c00016d, 0x0, // Store Quadword Conditional Indexed X-form (stqcx. RSp,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{SYNC, 0xfc0007fe, 0x7c0004ac, 0x390f801, // Synchronize X-form (sync L, E)
-		[5]*argField{ap_ImmUnsigned_9_10, ap_ImmUnsigned_12_15}},
-	{EIEIO, 0xfc0007fe, 0x7c0006ac, 0x3fff801, // Enforce In-order Execution of I/O X-form (eieio)
-		[5]*argField{}},
-	{MBAR, 0xfc0007fe, 0x7c0006ac, 0x1ff801, // Memory Barrier X-form (mbar MO)
-		[5]*argField{ap_ImmUnsigned_6_10}},
-	{WAIT, 0xfc0007fe, 0x7c00007c, 0x39ff801, // Wait X-form (wait WC)
-		[5]*argField{ap_ImmUnsigned_9_10}},
-	{TBEGINCC, 0xfc0007ff, 0x7c00051d, 0x1dff800, // Transaction Begin X-form (tbegin. R)
-		[5]*argField{ap_ImmUnsigned_10_10}},
-	{TENDCC, 0xfc0007ff, 0x7c00055d, 0x1fff800, // Transaction End X-form (tend. A)
-		[5]*argField{ap_ImmUnsigned_6_6}},
-	{TABORTCC, 0xfc0007ff, 0x7c00071d, 0x3e0f800, // Transaction Abort X-form (tabort. RA)
-		[5]*argField{ap_Reg_11_15}},
-	{TABORTWCCC, 0xfc0007ff, 0x7c00061d, 0x0, // Transaction Abort Word Conditional X-form (tabortwc. TO,RA,RB)
-		[5]*argField{ap_ImmUnsigned_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{TABORTWCICC, 0xfc0007ff, 0x7c00069d, 0x0, // Transaction Abort Word Conditional Immediate X-form (tabortwci. TO,RA,SI)
-		[5]*argField{ap_ImmUnsigned_6_10, ap_Reg_11_15, ap_ImmSigned_16_20}},
-	{TABORTDCCC, 0xfc0007ff, 0x7c00065d, 0x0, // Transaction Abort Doubleword Conditional X-form (tabortdc. TO,RA,RB)
-		[5]*argField{ap_ImmUnsigned_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{TABORTDCICC, 0xfc0007ff, 0x7c0006dd, 0x0, // Transaction Abort Doubleword Conditional Immediate X-form (tabortdci. TO,RA, SI)
-		[5]*argField{ap_ImmUnsigned_6_10, ap_Reg_11_15, ap_ImmSigned_16_20}},
-	{TSRCC, 0xfc0007ff, 0x7c0005dd, 0x3dff800, // Transaction Suspend or Resume X-form (tsr. L)
-		[5]*argField{ap_ImmUnsigned_10_10}},
-	{TCHECK, 0xfc0007fe, 0x7c00059c, 0x7ff801, // Transaction Check X-form (tcheck BF)
-		[5]*argField{ap_CondRegField_6_8}},
-	{MFTB, 0xfc0007fe, 0x7c0002e6, 0x1, // Move From Time Base XFX-form (mftb RT,TBR)
-		[5]*argField{ap_Reg_6_10, ap_SpReg_16_20_11_15}},
-	{RFEBB, 0xfc0007fe, 0x4c000124, 0x3fff001, // Return from Event-Based Branch XL-form (rfebb S)
-		[5]*argField{ap_ImmUnsigned_20_20}},
-	{LBDX, 0xfc0007fe, 0x7c000406, 0x1, // Load Byte with Decoration Indexed X-form (lbdx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LHDX, 0xfc0007fe, 0x7c000446, 0x1, // Load Halfword with Decoration Indexed X-form (lhdx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LWDX, 0xfc0007fe, 0x7c000486, 0x1, // Load Word with Decoration Indexed X-form (lwdx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LDDX, 0xfc0007fe, 0x7c0004c6, 0x1, // Load Doubleword with Decoration Indexed X-form (lddx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LFDDX, 0xfc0007fe, 0x7c000646, 0x1, // Load Floating Doubleword with Decoration Indexed X-form (lfddx FRT,RA,RB)
-		[5]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STBDX, 0xfc0007fe, 0x7c000506, 0x1, // Store Byte with Decoration Indexed X-form (stbdx RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STHDX, 0xfc0007fe, 0x7c000546, 0x1, // Store Halfword with Decoration Indexed X-form (sthdx RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STWDX, 0xfc0007fe, 0x7c000586, 0x1, // Store Word with Decoration Indexed X-form (stwdx RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STDDX, 0xfc0007fe, 0x7c0005c6, 0x1, // Store Doubleword with Decoration Indexed X-form (stddx RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STFDDX, 0xfc0007fe, 0x7c000746, 0x1, // Store Floating Doubleword with Decoration Indexed X-form (stfddx FRS,RA,RB)
-		[5]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DSN, 0xfc0007fe, 0x7c0003c6, 0x3e00001, // Decorated Storage Notify X-form (dsn RA,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_16_20}},
-	{ECIWX, 0xfc0007fe, 0x7c00026c, 0x1, // External Control In Word Indexed X-form (eciwx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{ECOWX, 0xfc0007fe, 0x7c00036c, 0x1, // External Control Out Word Indexed X-form (ecowx RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{SC, 0xfc000002, 0x44000002, 0x3fff01d, // System Call SC-form (sc LEV)
-		[5]*argField{ap_ImmUnsigned_20_26}},
-	{RFID, 0xfc0007fe, 0x4c000024, 0x3fff801, // Return From Interrupt Doubleword XL-form (rfid)
-		[5]*argField{}},
-	{HRFID, 0xfc0007fe, 0x4c000224, 0x3fff801, // Hypervisor Return From Interrupt Doubleword XL-form (hrfid)
-		[5]*argField{}},
-	{DOZE, 0xfc0007fe, 0x4c000324, 0x3fff801, // Doze XL-form (doze)
-		[5]*argField{}},
-	{NAP, 0xfc0007fe, 0x4c000364, 0x3fff801, // Nap XL-form (nap)
-		[5]*argField{}},
-	{SLEEP, 0xfc0007fe, 0x4c0003a4, 0x3fff801, // Sleep XL-form (sleep)
-		[5]*argField{}},
-	{RVWINKLE, 0xfc0007fe, 0x4c0003e4, 0x3fff801, // Rip Van Winkle XL-form (rvwinkle)
-		[5]*argField{}},
-	{LBZCIX, 0xfc0007fe, 0x7c0006aa, 0x1, // Load Byte and Zero Caching Inhibited Indexed X-form (lbzcix RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LWZCIX, 0xfc0007fe, 0x7c00062a, 0x1, // Load Word and Zero Caching Inhibited Indexed X-form (lwzcix RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LHZCIX, 0xfc0007fe, 0x7c00066a, 0x1, // Load Halfword and Zero Caching Inhibited Indexed X-form (lhzcix RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LDCIX, 0xfc0007fe, 0x7c0006ea, 0x1, // Load Doubleword Caching Inhibited Indexed X-form (ldcix RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STBCIX, 0xfc0007fe, 0x7c0007aa, 0x1, // Store Byte Caching Inhibited Indexed X-form (stbcix RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STWCIX, 0xfc0007fe, 0x7c00072a, 0x1, // Store Word Caching Inhibited Indexed X-form (stwcix RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STHCIX, 0xfc0007fe, 0x7c00076a, 0x1, // Store Halfword Caching Inhibited Indexed X-form (sthcix RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STDCIX, 0xfc0007fe, 0x7c0007ea, 0x1, // Store Doubleword Caching Inhibited Indexed X-form (stdcix RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{TRECLAIMCC, 0xfc0007ff, 0x7c00075d, 0x3e0f800, // Transaction Reclaim X-form (treclaim. RA)
-		[5]*argField{ap_Reg_11_15}},
-	{TRECHKPTCC, 0xfc0007ff, 0x7c0007dd, 0x3fff800, // Transaction Recheckpoint X-form (trechkpt.)
-		[5]*argField{}},
-	{MTSPR, 0xfc0007fe, 0x7c0003a6, 0x1, // Move To Special Purpose Register XFX-form (mtspr SPR,RS)
-		[5]*argField{ap_SpReg_16_20_11_15, ap_Reg_6_10}},
-	{MFSPR, 0xfc0007fe, 0x7c0002a6, 0x1, // Move From Special Purpose Register XFX-form (mfspr RT,SPR)
-		[5]*argField{ap_Reg_6_10, ap_SpReg_16_20_11_15}},
-	{MTMSR, 0xfc0007fe, 0x7c000124, 0x1ef801, // Move To Machine State Register X-form (mtmsr RS,L)
-		[5]*argField{ap_Reg_6_10, ap_ImmUnsigned_15_15}},
-	{MTMSRD, 0xfc0007fe, 0x7c000164, 0x1ef801, // Move To Machine State Register Doubleword X-form (mtmsrd RS,L)
-		[5]*argField{ap_Reg_6_10, ap_ImmUnsigned_15_15}},
-	{MFMSR, 0xfc0007fe, 0x7c0000a6, 0x1ff801, // Move From Machine State Register X-form (mfmsr RT)
-		[5]*argField{ap_Reg_6_10}},
-	{SLBIE, 0xfc0007fe, 0x7c000364, 0x3ff0001, // SLB Invalidate Entry X-form (slbie RB)
-		[5]*argField{ap_Reg_16_20}},
-	{SLBIA, 0xfc0007fe, 0x7c0003e4, 0x31ff801, // SLB Invalidate All X-form (slbia IH)
-		[5]*argField{ap_ImmUnsigned_8_10}},
-	{SLBMTE, 0xfc0007fe, 0x7c000324, 0x1f0001, // SLB Move To Entry X-form (slbmte RS,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{SLBMFEV, 0xfc0007fe, 0x7c0006a6, 0x1f0001, // SLB Move From Entry VSID X-form (slbmfev RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{SLBMFEE, 0xfc0007fe, 0x7c000726, 0x1f0001, // SLB Move From Entry ESID X-form (slbmfee RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{SLBFEECC, 0xfc0007ff, 0x7c0007a7, 0x1f0000, // SLB Find Entry ESID X-form (slbfee. RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{MTSR, 0xfc0007fe, 0x7c0001a4, 0x10f801, // Move To Segment Register X-form (mtsr SR,RS)
-		[5]*argField{ap_SpReg_12_15, ap_Reg_6_10}},
-	{MTSRIN, 0xfc0007fe, 0x7c0001e4, 0x1f0001, // Move To Segment Register Indirect X-form (mtsrin RS,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{MFSR, 0xfc0007fe, 0x7c0004a6, 0x10f801, // Move From Segment Register X-form (mfsr RT,SR)
-		[5]*argField{ap_Reg_6_10, ap_SpReg_12_15}},
-	{MFSRIN, 0xfc0007fe, 0x7c000526, 0x1f0001, // Move From Segment Register Indirect X-form (mfsrin RT,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_16_20}},
-	{TLBIE, 0xfc0007fe, 0x7c000264, 0x1f0001, // TLB Invalidate Entry X-form (tlbie RB,RS)
-		[5]*argField{ap_Reg_16_20, ap_Reg_6_10}},
-	{TLBIEL, 0xfc0007fe, 0x7c000224, 0x3ff0001, // TLB Invalidate Entry Local X-form (tlbiel RB)
-		[5]*argField{ap_Reg_16_20}},
-	{TLBIA, 0xfc0007fe, 0x7c0002e4, 0x3fff801, // TLB Invalidate All X-form (tlbia)
-		[5]*argField{}},
-	{TLBSYNC, 0xfc0007fe, 0x7c00046c, 0x3fff801, // TLB Synchronize X-form (tlbsync)
-		[5]*argField{}},
-	{MSGSND, 0xfc0007fe, 0x7c00019c, 0x3ff0001, // Message Send X-form (msgsnd RB)
-		[5]*argField{ap_Reg_16_20}},
-	{MSGCLR, 0xfc0007fe, 0x7c0001dc, 0x3ff0001, // Message Clear X-form (msgclr RB)
-		[5]*argField{ap_Reg_16_20}},
-	{MSGSNDP, 0xfc0007fe, 0x7c00011c, 0x3ff0001, // Message Send Privileged X-form (msgsndp RB)
-		[5]*argField{ap_Reg_16_20}},
-	{MSGCLRP, 0xfc0007fe, 0x7c00015c, 0x3ff0001, // Message Clear Privileged X-form (msgclrp RB)
-		[5]*argField{ap_Reg_16_20}},
-	{MTTMR, 0xfc0007fe, 0x7c0003dc, 0x1, // Move To Thread Management Register XFX-form (mttmr TMR,RS)
-		[5]*argField{ap_SpReg_16_20_11_15, ap_Reg_6_10}},
-	{SC, 0xfc000002, 0x44000002, 0x3fffffd, // System Call SC-form (sc)
-		[5]*argField{}},
-	{RFI, 0xfc0007fe, 0x4c000064, 0x3fff801, // Return From Interrupt XL-form (rfi)
-		[5]*argField{}},
-	{RFCI, 0xfc0007fe, 0x4c000066, 0x3fff801, // Return From Critical Interrupt XL-form (rfci)
-		[5]*argField{}},
-	{RFDI, 0xfc0007fe, 0x4c00004e, 0x3fff801, // Return From Debug Interrupt X-form (rfdi)
-		[5]*argField{}},
-	{RFMCI, 0xfc0007fe, 0x4c00004c, 0x3fff801, // Return From Machine Check Interrupt XL-form (rfmci)
-		[5]*argField{}},
-	{RFGI, 0xfc0007fe, 0x4c0000cc, 0x3fff801, // Return From Guest Interrupt XL-form (rfgi)
-		[5]*argField{}},
-	{EHPRIV, 0xfc0007fe, 0x7c00021c, 0x1, // Embedded Hypervisor Privilege XL-form (ehpriv OC)
-		[5]*argField{ap_ImmUnsigned_6_20}},
-	{MTSPR, 0xfc0007fe, 0x7c0003a6, 0x1, // Move To Special Purpose Register XFX-form (mtspr SPR,RS)
-		[5]*argField{ap_SpReg_16_20_11_15, ap_Reg_6_10}},
-	{MFSPR, 0xfc0007fe, 0x7c0002a6, 0x1, // Move From Special Purpose Register XFX-form (mfspr RT,SPR)
-		[5]*argField{ap_Reg_6_10, ap_SpReg_16_20_11_15}},
-	{MTDCR, 0xfc0007fe, 0x7c000386, 0x1, // Move To Device Control Register XFX-form (mtdcr DCRN,RS)
-		[5]*argField{ap_SpReg_16_20_11_15, ap_Reg_6_10}},
-	{MTDCRX, 0xfc0007fe, 0x7c000306, 0xf801, // Move To Device Control Register Indexed X-form (mtdcrx RA,RS)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10}},
-	{MFDCR, 0xfc0007fe, 0x7c000286, 0x1, // Move From Device Control Register XFX-form (mfdcr RT,DCRN)
-		[5]*argField{ap_Reg_6_10, ap_SpReg_16_20_11_15}},
-	{MFDCRX, 0xfc0007fe, 0x7c000206, 0xf801, // Move From Device Control Register Indexed X-form (mfdcrx RT,RA)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15}},
-	{MTMSR, 0xfc0007fe, 0x7c000124, 0x1ff801, // Move To Machine State Register X-form (mtmsr RS)
-		[5]*argField{ap_Reg_6_10}},
-	{MFMSR, 0xfc0007fe, 0x7c0000a6, 0x1ff801, // Move From Machine State Register X-form (mfmsr RT)
-		[5]*argField{ap_Reg_6_10}},
-	{WRTEE, 0xfc0007fe, 0x7c000106, 0x1ff801, // Write MSR External Enable X-form (wrtee RS)
-		[5]*argField{ap_Reg_6_10}},
-	{WRTEEI, 0xfc0007fe, 0x7c000146, 0x3ff7801, // Write MSR External Enable Immediate X-form (wrteei E)
-		[5]*argField{ap_ImmUnsigned_16_16}},
-	{LBEPX, 0xfc0007fe, 0x7c0000be, 0x1, // Load Byte by External Process ID Indexed X-form (lbepx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LHEPX, 0xfc0007fe, 0x7c00023e, 0x1, // Load Halfword by External Process ID Indexed X-form (lhepx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LWEPX, 0xfc0007fe, 0x7c00003e, 0x1, // Load Word by External Process ID Indexed X-form (lwepx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LDEPX, 0xfc0007fe, 0x7c00003a, 0x1, // Load Doubleword by External Process ID Indexed X-form (ldepx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STBEPX, 0xfc0007fe, 0x7c0001be, 0x1, // Store Byte by External Process ID Indexed X-form (stbepx RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STHEPX, 0xfc0007fe, 0x7c00033e, 0x1, // Store Halfword by External Process ID Indexed X-form (sthepx RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STWEPX, 0xfc0007fe, 0x7c00013e, 0x1, // Store Word by External Process ID Indexed X-form (stwepx RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STDEPX, 0xfc0007fe, 0x7c00013a, 0x1, // Store Doubleword by External Process ID Indexed X-form (stdepx RS,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DCBSTEP, 0xfc0007fe, 0x7c00007e, 0x3e00001, // Data Cache Block Store by External PID X-form (dcbstep RA,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_16_20}},
-	{DCBTEP, 0xfc0007fe, 0x7c00027e, 0x1, // Data Cache Block Touch by External PID X-form (dcbtep TH,RA,RB)
-		[5]*argField{ap_ImmUnsigned_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DCBFEP, 0xfc0007fe, 0x7c0000fe, 0x3800001, // Data Cache Block Flush by External PID X-form (dcbfep RA,RB,L)
-		[5]*argField{ap_Reg_11_15, ap_Reg_16_20, ap_ImmUnsigned_9_10}},
-	{DCBTSTEP, 0xfc0007fe, 0x7c0001fe, 0x1, // Data Cache Block Touch for Store by External PID X-form (dcbtstep TH,RA,RB)
-		[5]*argField{ap_ImmUnsigned_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{ICBIEP, 0xfc0007fe, 0x7c0007be, 0x3e00001, // Instruction Cache Block Invalidate by External PID X-form (icbiep RA,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_16_20}},
-	{DCBZEP, 0xfc0007fe, 0x7c0007fe, 0x3e00001, // Data Cache Block set to Zero by External PID X-form (dcbzep RA,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_16_20}},
-	{LFDEPX, 0xfc0007fe, 0x7c0004be, 0x1, // Load Floating-Point Double by External Process ID Indexed X-form (lfdepx FRT,RA,RB)
-		[5]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STFDEPX, 0xfc0007fe, 0x7c0005be, 0x1, // Store Floating-Point Double by External Process ID Indexed X-form (stfdepx FRS,RA,RB)
-		[5]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVLDDEPX, 0xfc0007fe, 0x7c00063e, 0x1, // Vector Load Doubleword into Doubleword by External Process ID Indexed EVX-form (evlddepx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{EVSTDDEPX, 0xfc0007fe, 0x7c00073e, 0x1, // Vector Store Doubleword into Doubleword by External Process ID Indexed EVX-form (evstddepx RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LVEPX, 0xfc0007fe, 0x7c00024e, 0x1, // Load Vector by External Process ID Indexed X-form (lvepx VRT,RA,RB)
-		[5]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{LVEPXL, 0xfc0007fe, 0x7c00020e, 0x1, // Load Vector by External Process ID Indexed LRU X-form (lvepxl VRT,RA,RB)
-		[5]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STVEPX, 0xfc0007fe, 0x7c00064e, 0x1, // Store Vector by External Process ID Indexed X-form (stvepx VRS,RA,RB)
-		[5]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{STVEPXL, 0xfc0007fe, 0x7c00060e, 0x1, // Store Vector by External Process ID Indexed LRU X-form (stvepxl VRS,RA,RB)
-		[5]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DCBI, 0xfc0007fe, 0x7c0003ac, 0x3e00001, // Data Cache Block Invalidate X-form (dcbi RA,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_16_20}},
-	{DCBLQCC, 0xfc0007ff, 0x7c00034d, 0x2000000, // Data Cache Block Lock Query X-form (dcblq. CT,RA,RB)
-		[5]*argField{ap_ImmUnsigned_7_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{ICBLQCC, 0xfc0007ff, 0x7c00018d, 0x2000000, // Instruction Cache Block Lock Query X-form (icblq. CT,RA,RB)
-		[5]*argField{ap_ImmUnsigned_7_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DCBTLS, 0xfc0007fe, 0x7c00014c, 0x2000001, // Data Cache Block Touch and Lock Set X-form (dcbtls CT,RA,RB)
-		[5]*argField{ap_ImmUnsigned_7_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DCBTSTLS, 0xfc0007fe, 0x7c00010c, 0x2000001, // Data Cache Block Touch for Store and Lock Set X-form (dcbtstls CT,RA,RB)
-		[5]*argField{ap_ImmUnsigned_7_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{ICBTLS, 0xfc0007fe, 0x7c0003cc, 0x2000001, // Instruction Cache Block Touch and Lock Set X-form (icbtls CT,RA,RB)
-		[5]*argField{ap_ImmUnsigned_7_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{ICBLC, 0xfc0007fe, 0x7c0001cc, 0x2000001, // Instruction Cache Block Lock Clear X-form (icblc CT,RA,RB)
-		[5]*argField{ap_ImmUnsigned_7_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{DCBLC, 0xfc0007fe, 0x7c00030c, 0x2000001, // Data Cache Block Lock Clear X-form (dcblc CT,RA,RB)
-		[5]*argField{ap_ImmUnsigned_7_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{TLBIVAX, 0xfc0007fe, 0x7c000624, 0x3e00001, // TLB Invalidate Virtual Address Indexed X-form (tlbivax RA,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_16_20}},
-	{TLBILX, 0xfc0007fe, 0x7c000024, 0x3800001, // TLB Invalidate Local Indexed X-form (tlbilx RA,RB])
-		[5]*argField{ap_Reg_11_15, ap_Reg_16_20}},
-	{TLBSX, 0xfc0007fe, 0x7c000724, 0x3e00001, // TLB Search Indexed X-form (tlbsx RA,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_16_20}},
-	{TLBSRXCC, 0xfc0007ff, 0x7c0006a5, 0x3e00000, // TLB Search and Reserve Indexed X-form (tlbsrx. RA,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_16_20}},
-	{TLBRE, 0xfc0007fe, 0x7c000764, 0x3fff801, // TLB Read Entry X-form (tlbre)
-		[5]*argField{}},
-	{TLBSYNC, 0xfc0007fe, 0x7c00046c, 0x3fff801, // TLB Synchronize X-form (tlbsync)
-		[5]*argField{}},
-	{TLBWE, 0xfc0007fe, 0x7c0007a4, 0x3fff801, // TLB Write Entry X-form (tlbwe)
-		[5]*argField{}},
-	{DNH, 0xfc0007fe, 0x4c00018c, 0x1, // Debugger Notify Halt XFX-form (dnh DUI,DUIS)
-		[5]*argField{ap_ImmUnsigned_6_10, ap_ImmUnsigned_11_20}},
-	{MSGSND, 0xfc0007fe, 0x7c00019c, 0x3ff0001, // Message Send X-form (msgsnd RB)
-		[5]*argField{ap_Reg_16_20}},
-	{MSGCLR, 0xfc0007fe, 0x7c0001dc, 0x3ff0001, // Message Clear X-form (msgclr RB)
-		[5]*argField{ap_Reg_16_20}},
-	{DCI, 0xfc0007fe, 0x7c00038c, 0x21ff801, // Data Cache Invalidate X-form (dci CT)
-		[5]*argField{ap_ImmUnsigned_7_10}},
-	{ICI, 0xfc0007fe, 0x7c00078c, 0x21ff801, // Instruction Cache Invalidate X-form (ici CT)
-		[5]*argField{ap_ImmUnsigned_7_10}},
-	{DCREAD, 0xfc0007fe, 0x7c0003cc, 0x1, // Data Cache Read X-form (dcread RT,RA,RB)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{ICREAD, 0xfc0007fe, 0x7c0007cc, 0x3e00001, // Instruction Cache Read X-form (icread RA,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_16_20}},
-	{MFPMR, 0xfc0007fe, 0x7c00029c, 0x1, // Move From Performance Monitor Register XFX-form (mfpmr RT,PMRN)
-		[5]*argField{ap_Reg_6_10, ap_SpReg_11_20}},
-	{MTPMR, 0xfc0007fe, 0x7c00039c, 0x1, // Move To Performance Monitor Register XFX-form (mtpmr PMRN,RS)
-		[5]*argField{ap_SpReg_11_20, ap_Reg_6_10}},
-	{ADDEX, 0xfc0001fe, 0x7c000154, 0x1, // Add Extended using alternate carry bit Z23-form (addex RT,RA,RB,CY)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20, ap_ImmUnsigned_21_22}},
-	{DARN, 0xfc0007fe, 0x7c0005e6, 0x1cf801, // Deliver A Random Number X-form (darn RT,L)
-		[5]*argField{ap_Reg_6_10, ap_ImmUnsigned_14_15}},
-	{MADDHD, 0xfc00003f, 0x10000030, 0x0, // Multiply-Add High Doubleword VA-form (maddhd RT,RA,RB,RC)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20, ap_Reg_21_25}},
-	{MADDHDU, 0xfc00003f, 0x10000031, 0x0, // Multiply-Add High Doubleword Unsigned VA-form (maddhdu RT,RA,RB,RC)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20, ap_Reg_21_25}},
-	{MADDLD, 0xfc00003f, 0x10000033, 0x0, // Multiply-Add Low Doubleword VA-form (maddld RT,RA,RB,RC)
-		[5]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20, ap_Reg_21_25}},
-	{CMPRB, 0xfc0007fe, 0x7c000180, 0x400001, // Compare Ranged Byte X-form (cmprb BF,L,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_ImmUnsigned_10_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{CMPEQB, 0xfc0007fe, 0x7c0001c0, 0x600001, // Compare Equal Byte X-form (cmpeqb BF,RA,RB)
-		[5]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
-	{BPERMD, 0xfc0007fe, 0x7c0001f8, 0x1, // Bit Permute Doubleword X-form (bpermd RA,RS,RB])
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
-	{EXTSWSLI, 0xfc0007fd, 0x7c0006f4, 0x0, // Extend-Sign Word and Shift Left Immediate XS-form (extswsli RA,RS,SH)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_30_30_16_20}},
-	{EXTSWSLICC, 0xfc0007fd, 0x7c0006f5, 0x0, // Extend-Sign Word and Shift Left Immediate XS-form (extswsli. RA,RS,SH)
-		[5]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_30_30_16_20}},
-	{MFVSRD, 0xfc0007fe, 0x7c000066, 0xf800, // Move From VSR Doubleword X-form (mfvsrd RA,XS)
-		[5]*argField{ap_Reg_11_15, ap_VecSReg_31_31_6_10}},
-	{MFVSRLD, 0xfc0007fe, 0x7c000266, 0xf800, // Move From VSR Lower Doubleword X-form (mfvsrld RA,XS)
-		[5]*argField{ap_Reg_11_15, ap_VecSReg_31_31_6_10}},
-	{MFVSRWZ, 0xfc0007fe, 0x7c0000e6, 0xf800, // Move From VSR Word and Zero X-form (mfvsrwz RA,XS)
-		[5]*argField{ap_Reg_11_15, ap_VecSReg_31_31_6_10}},
-	{MTVSRD, 0xfc0007fe, 0x7c000166, 0xf800, // Move To VSR Doubleword X-form (mtvsrd XT,RA)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15}},
-	{MTVSRWA, 0xfc0007fe, 0x7c0001a6, 0xf800, // Move To VSR Word Algebraic X-form (mtvsrwa XT,RA)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15}},
-	{MTVSRWZ, 0xfc0007fe, 0x7c0001e6, 0xf800, // Move To VSR Word and Zero X-form (mtvsrwz XT,RA)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15}},
-	{MTVSRDD, 0xfc0007fe, 0x7c000366, 0x0, // Move To VSR Double Doubleword X-form (mtvsrdd XT,RA,RB)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
-	{MTVSRWS, 0xfc0007fe, 0x7c000326, 0xf800, // Move To VSR Word & Splat X-form (mtvsrws XT,RA)
-		[5]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15}},
-	{MCRXRX, 0xfc0007fe, 0x7c000480, 0x7ff801, // Move to CR from XER Extended X-form (mcrxrx BF)
-		[5]*argField{ap_CondRegField_6_8}},
-	{COPY, 0xfc2007fe, 0x7c20060c, 0x3c00001, // Copy X-form (copy RA,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_16_20}},
-	{PASTECC, 0xfc2007ff, 0x7c20070d, 0x3c00000, // Paste X-form (paste. RA,RB)
-		[5]*argField{ap_Reg_11_15, ap_Reg_16_20}},
+	{BRD, 0xfc0007fe00000000, 0x7c00017600000000, 0xf80100000000, // Byte-Reverse Doubleword X-form (brd RA,RS)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10}},
+	{BRH, 0xfc0007fe00000000, 0x7c0001b600000000, 0xf80100000000, // Byte-Reverse Halfword X-form (brh RA,RS)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10}},
+	{BRW, 0xfc0007fe00000000, 0x7c00013600000000, 0xf80100000000, // Byte-Reverse Word X-form (brw RA,RS)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10}},
+	{CFUGED, 0xfc0007fe00000000, 0x7c0001b800000000, 0x100000000, // Centrifuge Doubleword X-form (cfuged RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{CNTLZDM, 0xfc0007fe00000000, 0x7c00007600000000, 0x100000000, // Count Leading Zeros Doubleword under bit Mask X-form (cntlzdm RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{CNTTZDM, 0xfc0007fe00000000, 0x7c00047600000000, 0x100000000, // Count Trailing Zeros Doubleword under bit Mask X-form (cnttzdm RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{DCFFIXQQ, 0xfc1f07fe00000000, 0xfc0007c400000000, 0x100000000, // DFP Convert From Fixed Quadword Quad X-form (dcffixqq FRTp,VRB)
+		[6]*argField{ap_FPReg_6_10, ap_VecReg_16_20}},
+	{DCTFIXQQ, 0xfc1f07fe00000000, 0xfc0107c400000000, 0x100000000, // DFP Convert To Fixed Quadword Quad X-form (dctfixqq VRT,FRBp)
+		[6]*argField{ap_VecReg_6_10, ap_FPReg_16_20}},
+	{LXVKQ, 0xfc1f07fe00000000, 0xf01f02d000000000, 0x0, // Load VSX Vector Special Value Quadword X-form (lxvkq XT,UIM)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_ImmUnsigned_16_20}},
+	{LXVP, 0xfc00000f00000000, 0x1800000000000000, 0x0, // Load VSX Vector Paired DQ-form (lxvp XTp,DQ(RA))
+		[6]*argField{ap_VecSpReg_10_10_6_9, ap_Offset_16_27_shift4, ap_Reg_11_15}},
+	{LXVPX, 0xfc0007fe00000000, 0x7c00029a00000000, 0x100000000, // Load VSX Vector Paired Indexed X-form (lxvpx XTp,RA,RB)
+		[6]*argField{ap_VecSpReg_10_10_6_9, ap_Reg_11_15, ap_Reg_16_20}},
+	{LXVRBX, 0xfc0007fe00000000, 0x7c00001a00000000, 0x0, // Load VSX Vector Rightmost Byte Indexed X-form (lxvrbx XT,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LXVRDX, 0xfc0007fe00000000, 0x7c0000da00000000, 0x0, // Load VSX Vector Rightmost Doubleword Indexed X-form (lxvrdx XT,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LXVRHX, 0xfc0007fe00000000, 0x7c00005a00000000, 0x0, // Load VSX Vector Rightmost Halfword Indexed X-form (lxvrhx XT,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LXVRWX, 0xfc0007fe00000000, 0x7c00009a00000000, 0x0, // Load VSX Vector Rightmost Word Indexed X-form (lxvrwx XT,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MTVSRBM, 0xfc1f07ff00000000, 0x1010064200000000, 0x0, // Move to VSR Byte Mask VX-form (mtvsrbm VRT,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_16_20}},
+	{MTVSRBMI, 0xfc00003e00000000, 0x1000001400000000, 0x0, // Move To VSR Byte Mask Immediate DX-form (mtvsrbmi VRT,bm)
+		[6]*argField{ap_VecReg_6_10, ap_ImmUnsigned_16_25_11_15_31_31}},
+	{MTVSRDM, 0xfc1f07ff00000000, 0x1013064200000000, 0x0, // Move to VSR Doubleword Mask VX-form (mtvsrdm VRT,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_16_20}},
+	{MTVSRHM, 0xfc1f07ff00000000, 0x1011064200000000, 0x0, // Move to VSR Halfword Mask VX-form (mtvsrhm VRT,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_16_20}},
+	{MTVSRQM, 0xfc1f07ff00000000, 0x1014064200000000, 0x0, // Move to VSR Quadword Mask VX-form (mtvsrqm VRT,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_16_20}},
+	{MTVSRWM, 0xfc1f07ff00000000, 0x1012064200000000, 0x0, // Move to VSR Word Mask VX-form (mtvsrwm VRT,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_16_20}},
+	{PADDI, 0xff800000fc000000, 0x600000038000000, 0x6c000000000000, // Prefixed Add Immediate MLS:D-form (paddi RT,RA,SI,R)
+		[6]*argField{ap_Reg_38_42, ap_Reg_43_47, ap_ImmSigned_14_31_48_63, ap_ImmUnsigned_11_11}},
+	{PDEPD, 0xfc0007fe00000000, 0x7c00013800000000, 0x100000000, // Parallel Bits Deposit Doubleword X-form (pdepd RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{PEXTD, 0xfc0007fe00000000, 0x7c00017800000000, 0x100000000, // Parallel Bits Extract Doubleword X-form (pextd RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{PLBZ, 0xff800000fc000000, 0x600000088000000, 0x6c000000000000, // Prefixed Load Byte and Zero MLS:D-form (plbz RT,D(RA),R)
+		[6]*argField{ap_Reg_38_42, ap_Offset_14_31_48_63, ap_Reg_43_47, ap_ImmUnsigned_11_11}},
+	{PLD, 0xff800000fc000000, 0x4000000e4000000, 0x6c000000000000, // Prefixed Load Doubleword 8LS:D-form (pld RT,D(RA),R)
+		[6]*argField{ap_Reg_38_42, ap_Offset_14_31_48_63, ap_Reg_43_47, ap_ImmUnsigned_11_11}},
+	{PLFD, 0xff800000fc000000, 0x6000000c8000000, 0x6c000000000000, // Prefixed Load Floating-Point Double MLS:D-form (plfd FRT,D(RA),R)
+		[6]*argField{ap_FPReg_38_42, ap_Offset_14_31_48_63, ap_Reg_43_47, ap_ImmUnsigned_11_11}},
+	{PLFS, 0xff800000fc000000, 0x6000000c0000000, 0x6c000000000000, // Prefixed Load Floating-Point Single MLS:D-form (plfs FRT,D(RA),R)
+		[6]*argField{ap_FPReg_38_42, ap_Offset_14_31_48_63, ap_Reg_43_47, ap_ImmUnsigned_11_11}},
+	{PLHA, 0xff800000fc000000, 0x6000000a8000000, 0x6c000000000000, // Prefixed Load Halfword Algebraic MLS:D-form (plha RT,D(RA),R)
+		[6]*argField{ap_Reg_38_42, ap_Offset_14_31_48_63, ap_Reg_43_47, ap_ImmUnsigned_11_11}},
+	{PLHZ, 0xff800000fc000000, 0x6000000a0000000, 0x6c000000000000, // Prefixed Load Halfword and Zero MLS:D-form (plhz RT,D(RA),R)
+		[6]*argField{ap_Reg_38_42, ap_Offset_14_31_48_63, ap_Reg_43_47, ap_ImmUnsigned_11_11}},
+	{PLQ, 0xff800000fc000000, 0x4000000e0000000, 0x6c000000000000, // Prefixed Load Quadword 8LS:D-form (plq RTp,D(RA),R)
+		[6]*argField{ap_Reg_38_42, ap_Offset_14_31_48_63, ap_Reg_43_47, ap_ImmUnsigned_11_11}},
+	{PLWA, 0xff800000fc000000, 0x4000000a4000000, 0x6c000000000000, // Prefixed Load Word Algebraic 8LS:D-form (plwa RT,D(RA),R)
+		[6]*argField{ap_Reg_38_42, ap_Offset_14_31_48_63, ap_Reg_43_47, ap_ImmUnsigned_11_11}},
+	{PLWZ, 0xff800000fc000000, 0x600000080000000, 0x6c000000000000, // Prefixed Load Word and Zero MLS:D-form (plwz RT,D(RA),R)
+		[6]*argField{ap_Reg_38_42, ap_Offset_14_31_48_63, ap_Reg_43_47, ap_ImmUnsigned_11_11}},
+	{PLXSD, 0xff800000fc000000, 0x4000000a8000000, 0x6c000000000000, // Prefixed Load VSX Scalar Doubleword 8LS:D-form (plxsd VRT,D(RA),R)
+		[6]*argField{ap_VecReg_38_42, ap_Offset_14_31_48_63, ap_Reg_43_47, ap_ImmUnsigned_11_11}},
+	{PLXSSP, 0xff800000fc000000, 0x4000000ac000000, 0x6c000000000000, // Prefixed Load VSX Scalar Single-Precision 8LS:D-form (plxssp VRT,D(RA),R)
+		[6]*argField{ap_VecReg_38_42, ap_Offset_14_31_48_63, ap_Reg_43_47, ap_ImmUnsigned_11_11}},
+	{PLXV, 0xff800000f8000000, 0x4000000c8000000, 0x6c000000000000, // Prefixed Load VSX Vector 8LS:D-form (plxv XT,D(RA),R)
+		[6]*argField{ap_VecSReg_37_37_38_42, ap_Offset_14_31_48_63, ap_Reg_43_47, ap_ImmUnsigned_11_11}},
+	{PLXVP, 0xff800000fc000000, 0x4000000e8000000, 0x6c000000000000, // Prefixed Load VSX Vector Paired 8LS:D-form (plxvp XTp,D(RA),R)
+		[6]*argField{ap_VecSpReg_42_42_38_41, ap_Offset_14_31_48_63, ap_Reg_43_47, ap_ImmUnsigned_11_11}},
+	{PMXVBF16GER2, 0xfff00000fc0007f8, 0x7900000ec000198, 0xf3f0000000000, // Prefixed Masked VSX Vector bfloat16 GER (Rank-2 Update) MMIRR:XX3-form (pmxvbf16ger2 AT,XA,XB,XMSK,YMSK,PMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_31, ap_ImmUnsigned_16_17}},
+	{PMXVBF16GER2NN, 0xfff00000fc0007f8, 0x7900000ec000790, 0xf3f0000000000, // Prefixed Masked VSX Vector bfloat16 GER (Rank-2 Update) Negative multiply, Negative accumulate MMIRR:XX3-form (pmxvbf16ger2nn AT,XA,XB,XMSK,YMSK,PMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_31, ap_ImmUnsigned_16_17}},
+	{PMXVBF16GER2NP, 0xfff00000fc0007f8, 0x7900000ec000390, 0xf3f0000000000, // Prefixed Masked VSX Vector bfloat16 GER (Rank-2 Update) Negative multiply, Positive accumulate MMIRR:XX3-form (pmxvbf16ger2np AT,XA,XB,XMSK,YMSK,PMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_31, ap_ImmUnsigned_16_17}},
+	{PMXVBF16GER2PN, 0xfff00000fc0007f8, 0x7900000ec000590, 0xf3f0000000000, // Prefixed Masked VSX Vector bfloat16 GER (Rank-2 Update) Positive multiply, Negative accumulate MMIRR:XX3-form (pmxvbf16ger2pn AT,XA,XB,XMSK,YMSK,PMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_31, ap_ImmUnsigned_16_17}},
+	{PMXVBF16GER2PP, 0xfff00000fc0007f8, 0x7900000ec000190, 0xf3f0000000000, // Prefixed Masked VSX Vector bfloat16 GER (Rank-2 Update) Positive multiply, Positive accumulate MMIRR:XX3-form (pmxvbf16ger2pp AT,XA,XB,XMSK,YMSK,PMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_31, ap_ImmUnsigned_16_17}},
+	{PMXVF16GER2, 0xfff00000fc0007f8, 0x7900000ec000098, 0xf3f0000000000, // Prefixed Masked VSX Vector 16-bit Floating-Point GER (rank-2 update) MMIRR:XX3-form (pmxvf16ger2 AT,XA,XB,XMSK,YMSK,PMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_31, ap_ImmUnsigned_16_17}},
+	{PMXVF16GER2NN, 0xfff00000fc0007f8, 0x7900000ec000690, 0xf3f0000000000, // Prefixed Masked VSX Vector 16-bit Floating-Point GER (rank-2 update) Negative multiply, Negative accumulate MMIRR:XX3-form (pmxvf16ger2nn AT,XA,XB,XMSK,YMSK,PMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_31, ap_ImmUnsigned_16_17}},
+	{PMXVF16GER2NP, 0xfff00000fc0007f8, 0x7900000ec000290, 0xf3f0000000000, // Prefixed Masked VSX Vector 16-bit Floating-Point GER (rank-2 update) Negative multiply, Positive accumulate MMIRR:XX3-form (pmxvf16ger2np AT,XA,XB,XMSK,YMSK,PMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_31, ap_ImmUnsigned_16_17}},
+	{PMXVF16GER2PN, 0xfff00000fc0007f8, 0x7900000ec000490, 0xf3f0000000000, // Prefixed Masked VSX Vector 16-bit Floating-Point GER (rank-2 update) Positive multiply, Negative accumulate MMIRR:XX3-form (pmxvf16ger2pn AT,XA,XB,XMSK,YMSK,PMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_31, ap_ImmUnsigned_16_17}},
+	{PMXVF16GER2PP, 0xfff00000fc0007f8, 0x7900000ec000090, 0xf3f0000000000, // Prefixed Masked VSX Vector 16-bit Floating-Point GER (rank-2 update) Positive multiply, Positive accumulate MMIRR:XX3-form (pmxvf16ger2pp AT,XA,XB,XMSK,YMSK,PMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_31, ap_ImmUnsigned_16_17}},
+	{PMXVF32GER, 0xfff00000fc0007f8, 0x7900000ec0000d8, 0xfff0000000000, // Prefixed Masked VSX Vector 32-bit Floating-Point GER (rank-1 update) MMIRR:XX3-form (pmxvf32ger AT,XA,XB,XMSK,YMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_31}},
+	{PMXVF32GERNN, 0xfff00000fc0007f8, 0x7900000ec0006d0, 0xfff0000000000, // Prefixed Masked VSX Vector 32-bit Floating-Point GER (rank-1 update) Negative multiply, Negative accumulate MMIRR:XX3-form (pmxvf32gernn AT,XA,XB,XMSK,YMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_31}},
+	{PMXVF32GERNP, 0xfff00000fc0007f8, 0x7900000ec0002d0, 0xfff0000000000, // Prefixed Masked VSX Vector 32-bit Floating-Point GER (rank-1 update) Negative multiply, Positive accumulate MMIRR:XX3-form (pmxvf32gernp AT,XA,XB,XMSK,YMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_31}},
+	{PMXVF32GERPN, 0xfff00000fc0007f8, 0x7900000ec0004d0, 0xfff0000000000, // Prefixed Masked VSX Vector 32-bit Floating-Point GER (rank-1 update) Positive multiply, Negative accumulate MMIRR:XX3-form (pmxvf32gerpn AT,XA,XB,XMSK,YMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_31}},
+	{PMXVF32GERPP, 0xfff00000fc0007f8, 0x7900000ec0000d0, 0xfff0000000000, // Prefixed Masked VSX Vector 32-bit Floating-Point GER (rank-1 update) Positive multiply, Positive accumulate MMIRR:XX3-form (pmxvf32gerpp AT,XA,XB,XMSK,YMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_31}},
+	{PMXVF64GER, 0xfff00000fc0007f8, 0x7900000ec0001d8, 0xfff0300000000, // Prefixed Masked VSX Vector 64-bit Floating-Point GER (rank-1 update) MMIRR:XX3-form (pmxvf64ger AT,XAp,XB,XMSK,YMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_29}},
+	{PMXVF64GERNN, 0xfff00000fc0007f8, 0x7900000ec0007d0, 0xfff0300000000, // Prefixed Masked VSX Vector 64-bit Floating-Point GER (rank-1 update) Negative multiply, Negative accumulate MMIRR:XX3-form (pmxvf64gernn AT,XAp,XB,XMSK,YMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_29}},
+	{PMXVF64GERNP, 0xfff00000fc0007f8, 0x7900000ec0003d0, 0xfff0300000000, // Prefixed Masked VSX Vector 64-bit Floating-Point GER (rank-1 update) Negative multiply, Positive accumulate MMIRR:XX3-form (pmxvf64gernp AT,XAp,XB,XMSK,YMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_29}},
+	{PMXVF64GERPN, 0xfff00000fc0007f8, 0x7900000ec0005d0, 0xfff0300000000, // Prefixed Masked VSX Vector 64-bit Floating-Point GER (rank-1 update) Positive multiply, Negative accumulate MMIRR:XX3-form (pmxvf64gerpn AT,XAp,XB,XMSK,YMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_29}},
+	{PMXVF64GERPP, 0xfff00000fc0007f8, 0x7900000ec0001d0, 0xfff0300000000, // Prefixed Masked VSX Vector 64-bit Floating-Point GER (rank-1 update) Positive multiply, Positive accumulate MMIRR:XX3-form (pmxvf64gerpp AT,XAp,XB,XMSK,YMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_29}},
+	{PMXVI16GER2, 0xfff00000fc0007f8, 0x7900000ec000258, 0xf3f0000000000, // Prefixed Masked VSX Vector 16-bit Signed Integer GER (rank-2 update) MMIRR:XX3-form (pmxvi16ger2 AT,XA,XB,XMSK,YMSK,PMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_31, ap_ImmUnsigned_16_17}},
+	{PMXVI16GER2PP, 0xfff00000fc0007f8, 0x7900000ec000358, 0xf3f0000000000, // Prefixed Masked VSX Vector 16-bit Signed Integer GER (rank-2 update) Positive multiply, Positive accumulate MMIRR:XX3-form (pmxvi16ger2pp AT,XA,XB,XMSK,YMSK,PMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_31, ap_ImmUnsigned_16_17}},
+	{PMXVI16GER2S, 0xfff00000fc0007f8, 0x7900000ec000158, 0xf3f0000000000, // Prefixed Masked VSX Vector 16-bit Signed Integer GER (rank-2 update) with Saturation MMIRR:XX3-form (pmxvi16ger2s AT,XA,XB,XMSK,YMSK,PMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_31, ap_ImmUnsigned_16_17}},
+	{PMXVI16GER2SPP, 0xfff00000fc0007f8, 0x7900000ec000150, 0xf3f0000000000, // Prefixed Masked VSX Vector 16-bit Signed Integer GER (rank-2 update) with Saturation Positive multiply, Positive accumulate MMIRR:XX3-form (pmxvi16ger2spp AT,XA,XB,XMSK,YMSK,PMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_31, ap_ImmUnsigned_16_17}},
+	{PMXVI4GER8, 0xfff00000fc0007f8, 0x7900000ec000118, 0xf000000000000, // Prefixed Masked VSX Vector 4-bit Signed Integer GER (rank-8 update) MMIRR:XX3-form (pmxvi4ger8 AT,XA,XB,XMSK,YMSK,PMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_31, ap_ImmUnsigned_16_23}},
+	{PMXVI4GER8PP, 0xfff00000fc0007f8, 0x7900000ec000110, 0xf000000000000, // Prefixed Masked VSX Vector 4-bit Signed Integer GER (rank-8 update) Positive multiply, Positive accumulate MMIRR:XX3-form (pmxvi4ger8pp AT,XA,XB,XMSK,YMSK,PMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_31, ap_ImmUnsigned_16_23}},
+	{PMXVI8GER4, 0xfff00000fc0007f8, 0x7900000ec000018, 0xf0f0000000000, // Prefixed Masked VSX Vector 8-bit Signed/Unsigned Integer GER (rank-4 update) MMIRR:XX3-form (pmxvi8ger4 AT,XA,XB,XMSK,YMSK,PMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_31, ap_ImmUnsigned_16_19}},
+	{PMXVI8GER4PP, 0xfff00000fc0007f8, 0x7900000ec000010, 0xf0f0000000000, // Prefixed Masked VSX Vector 8-bit Signed/Unsigned Integer GER (rank-4 update) Positive multiply, Positive accumulate MMIRR:XX3-form (pmxvi8ger4pp AT,XA,XB,XMSK,YMSK,PMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_31, ap_ImmUnsigned_16_19}},
+	{PMXVI8GER4SPP, 0xfff00000fc0007f8, 0x7900000ec000318, 0xf0f0000000000, // Prefixed Masked VSX Vector 8-bit Signed/Unsigned Integer GER (rank-4 update) with Saturate Positive multiply, Positive accumulate MMIRR:XX3-form (pmxvi8ger4spp AT,XA,XB,XMSK,YMSK,PMSK)
+		[6]*argField{ap_MMAReg_38_40, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_ImmUnsigned_24_27, ap_ImmUnsigned_28_31, ap_ImmUnsigned_16_19}},
+	{PNOP, 0xfff3fffe00000000, 0x700000000000000, 0xc000100000000, // Prefixed Nop MRR:*-form (pnop)
+		[6]*argField{}},
+	{PSTB, 0xff800000fc000000, 0x600000098000000, 0x6c000000000000, // Prefixed Store Byte MLS:D-form (pstb RS,D(RA),R)
+		[6]*argField{ap_Reg_38_42, ap_Offset_14_31_48_63, ap_Reg_43_47, ap_ImmUnsigned_11_11}},
+	{PSTD, 0xff800000fc000000, 0x4000000f4000000, 0x6c000000000000, // Prefixed Store Doubleword 8LS:D-form (pstd RS,D(RA),R)
+		[6]*argField{ap_Reg_38_42, ap_Offset_14_31_48_63, ap_Reg_43_47, ap_ImmUnsigned_11_11}},
+	{PSTFD, 0xff800000fc000000, 0x6000000d8000000, 0x6c000000000000, // Prefixed Store Floating-Point Double MLS:D-form (pstfd FRS,D(RA),R)
+		[6]*argField{ap_FPReg_38_42, ap_Offset_14_31_48_63, ap_Reg_43_47, ap_ImmUnsigned_11_11}},
+	{PSTFS, 0xff800000fc000000, 0x6000000d0000000, 0x6c000000000000, // Prefixed Store Floating-Point Single MLS:D-form (pstfs FRS,D(RA),R)
+		[6]*argField{ap_FPReg_38_42, ap_Offset_14_31_48_63, ap_Reg_43_47, ap_ImmUnsigned_11_11}},
+	{PSTH, 0xff800000fc000000, 0x6000000b0000000, 0x6c000000000000, // Prefixed Store Halfword MLS:D-form (psth RS,D(RA),R)
+		[6]*argField{ap_Reg_38_42, ap_Offset_14_31_48_63, ap_Reg_43_47, ap_ImmUnsigned_11_11}},
+	{PSTQ, 0xff800000fc000000, 0x4000000f0000000, 0x6c000000000000, // Prefixed Store Quadword 8LS:D-form (pstq RSp,D(RA),R)
+		[6]*argField{ap_Reg_38_42, ap_Offset_14_31_48_63, ap_Reg_43_47, ap_ImmUnsigned_11_11}},
+	{PSTW, 0xff800000fc000000, 0x600000090000000, 0x6c000000000000, // Prefixed Store Word MLS:D-form (pstw RS,D(RA),R)
+		[6]*argField{ap_Reg_38_42, ap_Offset_14_31_48_63, ap_Reg_43_47, ap_ImmUnsigned_11_11}},
+	{PSTXSD, 0xff800000fc000000, 0x4000000b8000000, 0x6c000000000000, // Prefixed Store VSX Scalar Doubleword 8LS:D-form (pstxsd VRS,D(RA),R)
+		[6]*argField{ap_VecReg_38_42, ap_Offset_14_31_48_63, ap_Reg_43_47, ap_ImmUnsigned_11_11}},
+	{PSTXSSP, 0xff800000fc000000, 0x4000000bc000000, 0x6c000000000000, // Prefixed Store VSX Scalar Single-Precision 8LS:D-form (pstxssp VRS,D(RA),R)
+		[6]*argField{ap_VecReg_38_42, ap_Offset_14_31_48_63, ap_Reg_43_47, ap_ImmUnsigned_11_11}},
+	{PSTXV, 0xff800000f8000000, 0x4000000d8000000, 0x6c000000000000, // Prefixed Store VSX Vector 8LS:D-form (pstxv XS,D(RA),R)
+		[6]*argField{ap_VecSReg_37_37_38_42, ap_Offset_14_31_48_63, ap_Reg_43_47, ap_ImmUnsigned_11_11}},
+	{PSTXVP, 0xff800000fc000000, 0x4000000f8000000, 0x6c000000000000, // Prefixed Store VSX Vector Paired 8LS:D-form (pstxvp XSp,D(RA),R)
+		[6]*argField{ap_VecSpReg_42_42_38_41, ap_Offset_14_31_48_63, ap_Reg_43_47, ap_ImmUnsigned_11_11}},
+	{SETBC, 0xfc0007fe00000000, 0x7c00030000000000, 0xf80100000000, // Set Boolean Condition X-form (setbc RT,BI)
+		[6]*argField{ap_Reg_6_10, ap_CondRegBit_11_15}},
+	{SETBCR, 0xfc0007fe00000000, 0x7c00034000000000, 0xf80100000000, // Set Boolean Condition Reverse X-form (setbcr RT,BI)
+		[6]*argField{ap_Reg_6_10, ap_CondRegBit_11_15}},
+	{SETNBC, 0xfc0007fe00000000, 0x7c00038000000000, 0xf80100000000, // Set Negative Boolean Condition X-form (setnbc RT,BI)
+		[6]*argField{ap_Reg_6_10, ap_CondRegBit_11_15}},
+	{SETNBCR, 0xfc0007fe00000000, 0x7c0003c000000000, 0xf80100000000, // Set Negative Boolean Condition Reverse X-form (setnbcr RT,BI)
+		[6]*argField{ap_Reg_6_10, ap_CondRegBit_11_15}},
+	{STXVP, 0xfc00000f00000000, 0x1800000100000000, 0x0, // Store VSX Vector Paired DQ-form (stxvp XSp,DQ(RA))
+		[6]*argField{ap_VecSpReg_10_10_6_9, ap_Offset_16_27_shift4, ap_Reg_11_15}},
+	{STXVPX, 0xfc0007fe00000000, 0x7c00039a00000000, 0x100000000, // Store VSX Vector Paired Indexed X-form (stxvpx XSp,RA,RB)
+		[6]*argField{ap_VecSpReg_10_10_6_9, ap_Reg_11_15, ap_Reg_16_20}},
+	{STXVRBX, 0xfc0007fe00000000, 0x7c00011a00000000, 0x0, // Store VSX Vector Rightmost Byte Indexed X-form (stxvrbx XS,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STXVRDX, 0xfc0007fe00000000, 0x7c0001da00000000, 0x0, // Store VSX Vector Rightmost Doubleword Indexed X-form (stxvrdx XS,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STXVRHX, 0xfc0007fe00000000, 0x7c00015a00000000, 0x0, // Store VSX Vector Rightmost Halfword Indexed X-form (stxvrhx XS,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STXVRWX, 0xfc0007fe00000000, 0x7c00019a00000000, 0x0, // Store VSX Vector Rightmost Word Indexed X-form (stxvrwx XS,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{VCFUGED, 0xfc0007ff00000000, 0x1000054d00000000, 0x0, // Vector Centrifuge Doubleword VX-form (vcfuged VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCLRLB, 0xfc0007ff00000000, 0x1000018d00000000, 0x0, // Vector Clear Leftmost Bytes VX-form (vclrlb VRT,VRA,RB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_Reg_16_20}},
+	{VCLRRB, 0xfc0007ff00000000, 0x100001cd00000000, 0x0, // Vector Clear Rightmost Bytes VX-form (vclrrb VRT,VRA,RB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_Reg_16_20}},
+	{VCLZDM, 0xfc0007ff00000000, 0x1000078400000000, 0x0, // Vector Count Leading Zeros Doubleword under bit Mask VX-form (vclzdm VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPEQUQ, 0xfc0007ff00000000, 0x100001c700000000, 0x0, // Vector Compare Equal Quadword VC-form (vcmpequq VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPEQUQCC, 0xfc0007ff00000000, 0x100005c700000000, 0x0, // Vector Compare Equal Quadword VC-form (vcmpequq. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPGTSQ, 0xfc0007ff00000000, 0x1000038700000000, 0x0, // Vector Compare Greater Than Signed Quadword VC-form (vcmpgtsq VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPGTSQCC, 0xfc0007ff00000000, 0x1000078700000000, 0x0, // Vector Compare Greater Than Signed Quadword VC-form (vcmpgtsq. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPGTUQ, 0xfc0007ff00000000, 0x1000028700000000, 0x0, // Vector Compare Greater Than Unsigned Quadword VC-form (vcmpgtuq VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPGTUQCC, 0xfc0007ff00000000, 0x1000068700000000, 0x0, // Vector Compare Greater Than Unsigned Quadword VC-form (vcmpgtuq. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPSQ, 0xfc0007ff00000000, 0x1000014100000000, 0x60000000000000, // Vector Compare Signed Quadword VX-form (vcmpsq BF,VRA,VRB)
+		[6]*argField{ap_CondRegField_6_8, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPUQ, 0xfc0007ff00000000, 0x1000010100000000, 0x60000000000000, // Vector Compare Unsigned Quadword VX-form (vcmpuq BF,VRA,VRB)
+		[6]*argField{ap_CondRegField_6_8, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCNTMBB, 0xfc1e07ff00000000, 0x1018064200000000, 0x0, // Vector Count Mask Bits Byte VX-form (vcntmbb RT,VRB,MP)
+		[6]*argField{ap_Reg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_15_15}},
+	{VCNTMBD, 0xfc1e07ff00000000, 0x101e064200000000, 0x0, // Vector Count Mask Bits Doubleword VX-form (vcntmbd RT,VRB,MP)
+		[6]*argField{ap_Reg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_15_15}},
+	{VCNTMBH, 0xfc1e07ff00000000, 0x101a064200000000, 0x0, // Vector Count Mask Bits Halfword VX-form (vcntmbh RT,VRB,MP)
+		[6]*argField{ap_Reg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_15_15}},
+	{VCNTMBW, 0xfc1e07ff00000000, 0x101c064200000000, 0x0, // Vector Count Mask Bits Word VX-form (vcntmbw RT,VRB,MP)
+		[6]*argField{ap_Reg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_15_15}},
+	{VCTZDM, 0xfc0007ff00000000, 0x100007c400000000, 0x0, // Vector Count Trailing Zeros Doubleword under bit Mask VX-form (vctzdm VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VDIVESD, 0xfc0007ff00000000, 0x100003cb00000000, 0x0, // Vector Divide Extended Signed Doubleword VX-form (vdivesd VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VDIVESQ, 0xfc0007ff00000000, 0x1000030b00000000, 0x0, // Vector Divide Extended Signed Quadword VX-form (vdivesq VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VDIVESW, 0xfc0007ff00000000, 0x1000038b00000000, 0x0, // Vector Divide Extended Signed Word VX-form (vdivesw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VDIVEUD, 0xfc0007ff00000000, 0x100002cb00000000, 0x0, // Vector Divide Extended Unsigned Doubleword VX-form (vdiveud VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VDIVEUQ, 0xfc0007ff00000000, 0x1000020b00000000, 0x0, // Vector Divide Extended Unsigned Quadword VX-form (vdiveuq VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VDIVEUW, 0xfc0007ff00000000, 0x1000028b00000000, 0x0, // Vector Divide Extended Unsigned Word VX-form (vdiveuw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VDIVSD, 0xfc0007ff00000000, 0x100001cb00000000, 0x0, // Vector Divide Signed Doubleword VX-form (vdivsd VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VDIVSQ, 0xfc0007ff00000000, 0x1000010b00000000, 0x0, // Vector Divide Signed Quadword VX-form (vdivsq VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VDIVSW, 0xfc0007ff00000000, 0x1000018b00000000, 0x0, // Vector Divide Signed Word VX-form (vdivsw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VDIVUD, 0xfc0007ff00000000, 0x100000cb00000000, 0x0, // Vector Divide Unsigned Doubleword VX-form (vdivud VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VDIVUQ, 0xfc0007ff00000000, 0x1000000b00000000, 0x0, // Vector Divide Unsigned Quadword VX-form (vdivuq VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VDIVUW, 0xfc0007ff00000000, 0x1000008b00000000, 0x0, // Vector Divide Unsigned Word VX-form (vdivuw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VEXPANDBM, 0xfc1f07ff00000000, 0x1000064200000000, 0x0, // Vector Expand Byte Mask VX-form (vexpandbm VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VEXPANDDM, 0xfc1f07ff00000000, 0x1003064200000000, 0x0, // Vector Expand Doubleword Mask VX-form (vexpanddm VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VEXPANDHM, 0xfc1f07ff00000000, 0x1001064200000000, 0x0, // Vector Expand Halfword Mask VX-form (vexpandhm VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VEXPANDQM, 0xfc1f07ff00000000, 0x1004064200000000, 0x0, // Vector Expand Quadword Mask VX-form (vexpandqm VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VEXPANDWM, 0xfc1f07ff00000000, 0x1002064200000000, 0x0, // Vector Expand Word Mask VX-form (vexpandwm VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VEXTDDVLX, 0xfc00003f00000000, 0x1000001e00000000, 0x0, // Vector Extract Double Doubleword to VSR using GPR-specified Left-Index VA-form (vextddvlx VRT,VRA,VRB,RC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_Reg_21_25}},
+	{VEXTDDVRX, 0xfc00003f00000000, 0x1000001f00000000, 0x0, // Vector Extract Double Doubleword to VSR using GPR-specified Right-Index VA-form (vextddvrx VRT,VRA,VRB,RC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_Reg_21_25}},
+	{VEXTDUBVLX, 0xfc00003f00000000, 0x1000001800000000, 0x0, // Vector Extract Double Unsigned Byte to VSR using GPR-specified Left-Index VA-form (vextdubvlx VRT,VRA,VRB,RC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_Reg_21_25}},
+	{VEXTDUBVRX, 0xfc00003f00000000, 0x1000001900000000, 0x0, // Vector Extract Double Unsigned Byte to VSR using GPR-specified Right-Index VA-form (vextdubvrx VRT,VRA,VRB,RC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_Reg_21_25}},
+	{VEXTDUHVLX, 0xfc00003f00000000, 0x1000001a00000000, 0x0, // Vector Extract Double Unsigned Halfword to VSR using GPR-specified Left-Index VA-form (vextduhvlx VRT,VRA,VRB,RC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_Reg_21_25}},
+	{VEXTDUHVRX, 0xfc00003f00000000, 0x1000001b00000000, 0x0, // Vector Extract Double Unsigned Halfword to VSR using GPR-specified Right-Index VA-form (vextduhvrx VRT,VRA,VRB,RC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_Reg_21_25}},
+	{VEXTDUWVLX, 0xfc00003f00000000, 0x1000001c00000000, 0x0, // Vector Extract Double Unsigned Word to VSR using GPR-specified Left-Index VA-form (vextduwvlx VRT,VRA,VRB,RC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_Reg_21_25}},
+	{VEXTDUWVRX, 0xfc00003f00000000, 0x1000001d00000000, 0x0, // Vector Extract Double Unsigned Word to VSR using GPR-specified Right-Index VA-form (vextduwvrx VRT,VRA,VRB,RC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_Reg_21_25}},
+	{VEXTRACTBM, 0xfc1f07ff00000000, 0x1008064200000000, 0x0, // Vector Extract Byte Mask VX-form (vextractbm RT,VRB)
+		[6]*argField{ap_Reg_6_10, ap_VecReg_16_20}},
+	{VEXTRACTDM, 0xfc1f07ff00000000, 0x100b064200000000, 0x0, // Vector Extract Doubleword Mask VX-form (vextractdm RT,VRB)
+		[6]*argField{ap_Reg_6_10, ap_VecReg_16_20}},
+	{VEXTRACTHM, 0xfc1f07ff00000000, 0x1009064200000000, 0x0, // Vector Extract Halfword Mask VX-form (vextracthm RT,VRB)
+		[6]*argField{ap_Reg_6_10, ap_VecReg_16_20}},
+	{VEXTRACTQM, 0xfc1f07ff00000000, 0x100c064200000000, 0x0, // Vector Extract Quadword Mask VX-form (vextractqm RT,VRB)
+		[6]*argField{ap_Reg_6_10, ap_VecReg_16_20}},
+	{VEXTRACTWM, 0xfc1f07ff00000000, 0x100a064200000000, 0x0, // Vector Extract Word Mask VX-form (vextractwm RT,VRB)
+		[6]*argField{ap_Reg_6_10, ap_VecReg_16_20}},
+	{VEXTSD2Q, 0xfc1f07ff00000000, 0x101b060200000000, 0x0, // Vector Extend Sign Doubleword to Quadword VX-form (vextsd2q VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VGNB, 0xfc0007ff00000000, 0x100004cc00000000, 0x18000000000000, // Vector Gather every Nth Bit VX-form (vgnb RT,VRB,N)
+		[6]*argField{ap_Reg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_13_15}},
+	{VINSBLX, 0xfc0007ff00000000, 0x1000020f00000000, 0x0, // Vector Insert Byte from GPR using GPR-specified Left-Index VX-form (vinsblx VRT,RA,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{VINSBRX, 0xfc0007ff00000000, 0x1000030f00000000, 0x0, // Vector Insert Byte from GPR using GPR-specified Right-Index VX-form (vinsbrx VRT,RA,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{VINSBVLX, 0xfc0007ff00000000, 0x1000000f00000000, 0x0, // Vector Insert Byte from VSR using GPR-specified Left-Index VX-form (vinsbvlx VRT,RA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_VecReg_16_20}},
+	{VINSBVRX, 0xfc0007ff00000000, 0x1000010f00000000, 0x0, // Vector Insert Byte from VSR using GPR-specified Right-Index VX-form (vinsbvrx VRT,RA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_VecReg_16_20}},
+	{VINSD, 0xfc0007ff00000000, 0x100001cf00000000, 0x10000000000000, // Vector Insert Doubleword from GPR using immediate-specified index VX-form (vinsd VRT,RB,UIM)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_16_20, ap_ImmUnsigned_12_15}},
+	{VINSDLX, 0xfc0007ff00000000, 0x100002cf00000000, 0x0, // Vector Insert Doubleword from GPR using GPR-specified Left-Index VX-form (vinsdlx VRT,RA,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{VINSDRX, 0xfc0007ff00000000, 0x100003cf00000000, 0x0, // Vector Insert Doubleword from GPR using GPR-specified Right-Index VX-form (vinsdrx VRT,RA,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{VINSHLX, 0xfc0007ff00000000, 0x1000024f00000000, 0x0, // Vector Insert Halfword from GPR using GPR-specified Left-Index VX-form (vinshlx VRT,RA,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{VINSHRX, 0xfc0007ff00000000, 0x1000034f00000000, 0x0, // Vector Insert Halfword from GPR using GPR-specified Right-Index VX-form (vinshrx VRT,RA,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{VINSHVLX, 0xfc0007ff00000000, 0x1000004f00000000, 0x0, // Vector Insert Halfword from VSR using GPR-specified Left-Index VX-form (vinshvlx VRT,RA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_VecReg_16_20}},
+	{VINSHVRX, 0xfc0007ff00000000, 0x1000014f00000000, 0x0, // Vector Insert Halfword from VSR using GPR-specified Right-Index VX-form (vinshvrx VRT,RA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_VecReg_16_20}},
+	{VINSW, 0xfc0007ff00000000, 0x100000cf00000000, 0x10000000000000, // Vector Insert Word from GPR using immediate-specified index VX-form (vinsw VRT,RB,UIM)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_16_20, ap_ImmUnsigned_12_15}},
+	{VINSWLX, 0xfc0007ff00000000, 0x1000028f00000000, 0x0, // Vector Insert Word from GPR using GPR-specified Left-Index VX-form (vinswlx VRT,RA,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{VINSWRX, 0xfc0007ff00000000, 0x1000038f00000000, 0x0, // Vector Insert Word from GPR using GPR-specified Right-Index VX-form (vinswrx VRT,RA,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{VINSWVLX, 0xfc0007ff00000000, 0x1000008f00000000, 0x0, // Vector Insert Word from VSR using GPR-specified Left-Index VX-form (vinswvlx VRT,RA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_VecReg_16_20}},
+	{VINSWVRX, 0xfc0007ff00000000, 0x1000018f00000000, 0x0, // Vector Insert Word from VSR using GPR-specified Left-Index VX-form (vinswvrx VRT,RA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_VecReg_16_20}},
+	{VMODSD, 0xfc0007ff00000000, 0x100007cb00000000, 0x0, // Vector Modulo Signed Doubleword VX-form (vmodsd VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMODSQ, 0xfc0007ff00000000, 0x1000070b00000000, 0x0, // Vector Modulo Signed Quadword VX-form (vmodsq VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMODSW, 0xfc0007ff00000000, 0x1000078b00000000, 0x0, // Vector Modulo Signed Word VX-form (vmodsw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMODUD, 0xfc0007ff00000000, 0x100006cb00000000, 0x0, // Vector Modulo Unsigned Doubleword VX-form (vmodud VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMODUQ, 0xfc0007ff00000000, 0x1000060b00000000, 0x0, // Vector Modulo Unsigned Quadword VX-form (vmoduq VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMODUW, 0xfc0007ff00000000, 0x1000068b00000000, 0x0, // Vector Modulo Unsigned Word VX-form (vmoduw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMSUMCUD, 0xfc00003f00000000, 0x1000001700000000, 0x0, // Vector Multiply-Sum & write Carry-out Unsigned Doubleword VA-form (vmsumcud VRT,VRA,VRB,VRC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
+	{VMULESD, 0xfc0007ff00000000, 0x100003c800000000, 0x0, // Vector Multiply Even Signed Doubleword VX-form (vmulesd VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMULEUD, 0xfc0007ff00000000, 0x100002c800000000, 0x0, // Vector Multiply Even Unsigned Doubleword VX-form (vmuleud VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMULHSD, 0xfc0007ff00000000, 0x100003c900000000, 0x0, // Vector Multiply High Signed Doubleword VX-form (vmulhsd VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMULHSW, 0xfc0007ff00000000, 0x1000038900000000, 0x0, // Vector Multiply High Signed Word VX-form (vmulhsw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMULHUD, 0xfc0007ff00000000, 0x100002c900000000, 0x0, // Vector Multiply High Unsigned Doubleword VX-form (vmulhud VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMULHUW, 0xfc0007ff00000000, 0x1000028900000000, 0x0, // Vector Multiply High Unsigned Word VX-form (vmulhuw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMULLD, 0xfc0007ff00000000, 0x100001c900000000, 0x0, // Vector Multiply Low Doubleword VX-form (vmulld VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMULOSD, 0xfc0007ff00000000, 0x100001c800000000, 0x0, // Vector Multiply Odd Signed Doubleword VX-form (vmulosd VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMULOUD, 0xfc0007ff00000000, 0x100000c800000000, 0x0, // Vector Multiply Odd Unsigned Doubleword VX-form (vmuloud VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VPDEPD, 0xfc0007ff00000000, 0x100005cd00000000, 0x0, // Vector Parallel Bits Deposit Doubleword VX-form (vpdepd VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VPEXTD, 0xfc0007ff00000000, 0x1000058d00000000, 0x0, // Vector Parallel Bits Extract Doubleword VX-form (vpextd VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VRLQ, 0xfc0007ff00000000, 0x1000000500000000, 0x0, // Vector Rotate Left Quadword VX-form (vrlq VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VRLQMI, 0xfc0007ff00000000, 0x1000004500000000, 0x0, // Vector Rotate Left Quadword then Mask Insert VX-form (vrlqmi VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VRLQNM, 0xfc0007ff00000000, 0x1000014500000000, 0x0, // Vector Rotate Left Quadword then AND with Mask VX-form (vrlqnm VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSLDBI, 0xfc00063f00000000, 0x1000001600000000, 0x0, // Vector Shift Left Double by Bit Immediate VN-form (vsldbi VRT,VRA,VRB,SH)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_ImmUnsigned_23_25}},
+	{VSLQ, 0xfc0007ff00000000, 0x1000010500000000, 0x0, // Vector Shift Left Quadword VX-form (vslq VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSRAQ, 0xfc0007ff00000000, 0x1000030500000000, 0x0, // Vector Shift Right Algebraic Quadword VX-form (vsraq VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSRDBI, 0xfc00063f00000000, 0x1000021600000000, 0x0, // Vector Shift Right Double by Bit Immediate VN-form (vsrdbi VRT,VRA,VRB,SH)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_ImmUnsigned_23_25}},
+	{VSRQ, 0xfc0007ff00000000, 0x1000020500000000, 0x0, // Vector Shift Right Quadword VX-form (vsrq VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSTRIBL, 0xfc1f07ff00000000, 0x1000000d00000000, 0x0, // Vector String Isolate Byte Left-justified VX-form (vstribl VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VSTRIBLCC, 0xfc1f07ff00000000, 0x1000040d00000000, 0x0, // Vector String Isolate Byte Left-justified VX-form (vstribl. VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VSTRIBR, 0xfc1f07ff00000000, 0x1001000d00000000, 0x0, // Vector String Isolate Byte Right-justified VX-form (vstribr VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VSTRIBRCC, 0xfc1f07ff00000000, 0x1001040d00000000, 0x0, // Vector String Isolate Byte Right-justified VX-form (vstribr. VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VSTRIHL, 0xfc1f07ff00000000, 0x1002000d00000000, 0x0, // Vector String Isolate Halfword Left-justified VX-form (vstrihl VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VSTRIHLCC, 0xfc1f07ff00000000, 0x1002040d00000000, 0x0, // Vector String Isolate Halfword Left-justified VX-form (vstrihl. VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VSTRIHR, 0xfc1f07ff00000000, 0x1003000d00000000, 0x0, // Vector String Isolate Halfword Right-justified VX-form (vstrihr VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VSTRIHRCC, 0xfc1f07ff00000000, 0x1003040d00000000, 0x0, // Vector String Isolate Halfword Right-justified VX-form (vstrihr. VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{XSCMPEQQP, 0xfc0007fe00000000, 0xfc00008800000000, 0x100000000, // VSX Scalar Compare Equal Quad-Precision X-form (xscmpeqqp VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSCMPGEQP, 0xfc0007fe00000000, 0xfc00018800000000, 0x100000000, // VSX Scalar Compare Greater Than or Equal Quad-Precision X-form (xscmpgeqp VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSCMPGTQP, 0xfc0007fe00000000, 0xfc0001c800000000, 0x100000000, // VSX Scalar Compare Greater Than Quad-Precision X-form (xscmpgtqp VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSCVQPSQZ, 0xfc1f07fe00000000, 0xfc08068800000000, 0x100000000, // VSX Scalar Convert with round to zero Quad-Precision to Signed Quadword X-form (xscvqpsqz VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{XSCVQPUQZ, 0xfc1f07fe00000000, 0xfc00068800000000, 0x100000000, // VSX Scalar Convert with round to zero Quad-Precision to Unsigned Quadword X-form (xscvqpuqz VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{XSCVSQQP, 0xfc1f07fe00000000, 0xfc0b068800000000, 0x100000000, // VSX Scalar Convert with round Signed Quadword to Quad-Precision X-form (xscvsqqp VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{XSCVUQQP, 0xfc1f07fe00000000, 0xfc03068800000000, 0x100000000, // VSX Scalar Convert with round Unsigned Quadword to Quad-Precision X-form (xscvuqqp VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{XSMAXCQP, 0xfc0007fe00000000, 0xfc00054800000000, 0x100000000, // VSX Scalar Maximum Type-C Quad-Precision X-form (xsmaxcqp VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSMINCQP, 0xfc0007fe00000000, 0xfc0005c800000000, 0x100000000, // VSX Scalar Minimum Type-C Quad-Precision X-form (xsmincqp VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XVBF16GER2, 0xfc0007f800000000, 0xec00019800000000, 0x60000100000000, // VSX Vector bfloat16 GER (Rank-2 Update) XX3-form (xvbf16ger2 AT,XA,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVBF16GER2NN, 0xfc0007f800000000, 0xec00079000000000, 0x60000100000000, // VSX Vector bfloat16 GER (Rank-2 Update) Negative multiply, Negative accumulate XX3-form (xvbf16ger2nn AT,XA,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVBF16GER2NP, 0xfc0007f800000000, 0xec00039000000000, 0x60000100000000, // VSX Vector bfloat16 GER (Rank-2 Update) Negative multiply, Positive accumulate XX3-form (xvbf16ger2np AT,XA,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVBF16GER2PN, 0xfc0007f800000000, 0xec00059000000000, 0x60000100000000, // VSX Vector bfloat16 GER (Rank-2 Update) Positive multiply, Negative accumulate XX3-form (xvbf16ger2pn AT,XA,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVBF16GER2PP, 0xfc0007f800000000, 0xec00019000000000, 0x60000100000000, // VSX Vector bfloat16 GER (Rank-2 Update) Positive multiply, Positive accumulate XX3-form (xvbf16ger2pp AT,XA,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVCVBF16SPN, 0xfc1f07fc00000000, 0xf010076c00000000, 0x0, // VSX Vector Convert bfloat16 to Single-Precision format XX2-form (xvcvbf16spn XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVCVSPBF16, 0xfc1f07fc00000000, 0xf011076c00000000, 0x0, // VSX Vector Convert with round Single-Precision to bfloat16 format XX2-form (xvcvspbf16 XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVF16GER2, 0xfc0007f800000000, 0xec00009800000000, 0x60000100000000, // VSX Vector 16-bit Floating-Point GER (rank-2 update) XX3-form (xvf16ger2 AT,XA,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVF16GER2NN, 0xfc0007f800000000, 0xec00069000000000, 0x60000100000000, // VSX Vector 16-bit Floating-Point GER (rank-2 update) Negative multiply, Negative accumulate XX3-form (xvf16ger2nn AT,XA,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVF16GER2NP, 0xfc0007f800000000, 0xec00029000000000, 0x60000100000000, // VSX Vector 16-bit Floating-Point GER (rank-2 update) Negative multiply, Positive accumulate XX3-form (xvf16ger2np AT,XA,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVF16GER2PN, 0xfc0007f800000000, 0xec00049000000000, 0x60000100000000, // VSX Vector 16-bit Floating-Point GER (rank-2 update) Positive multiply, Negative accumulate XX3-form (xvf16ger2pn AT,XA,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVF16GER2PP, 0xfc0007f800000000, 0xec00009000000000, 0x60000100000000, // VSX Vector 16-bit Floating-Point GER (rank-2 update) Positive multiply, Positive accumulate XX3-form (xvf16ger2pp AT,XA,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVF32GER, 0xfc0007f800000000, 0xec0000d800000000, 0x60000100000000, // VSX Vector 32-bit Floating-Point GER (rank-1 update) XX3-form (xvf32ger AT,XA,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVF32GERNN, 0xfc0007f800000000, 0xec0006d000000000, 0x60000100000000, // VSX Vector 32-bit Floating-Point GER (rank-1 update) Negative multiply, Negative accumulate XX3-form (xvf32gernn AT,XA,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVF32GERNP, 0xfc0007f800000000, 0xec0002d000000000, 0x60000100000000, // VSX Vector 32-bit Floating-Point GER (rank-1 update) Negative multiply, Positive accumulate XX3-form (xvf32gernp AT,XA,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVF32GERPN, 0xfc0007f800000000, 0xec0004d000000000, 0x60000100000000, // VSX Vector 32-bit Floating-Point GER (rank-1 update) Positive multiply, Negative accumulate XX3-form (xvf32gerpn AT,XA,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVF32GERPP, 0xfc0007f800000000, 0xec0000d000000000, 0x60000100000000, // VSX Vector 32-bit Floating-Point GER (rank-1 update) Positive multiply, Positive accumulate XX3-form (xvf32gerpp AT,XA,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVF64GER, 0xfc0007f800000000, 0xec0001d800000000, 0x60000100000000, // VSX Vector 64-bit Floating-Point GER (rank-1 update) XX3-form (xvf64ger AT,XAp,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVF64GERNN, 0xfc0007f800000000, 0xec0007d000000000, 0x60000100000000, // VSX Vector 64-bit Floating-Point GER (rank-1 update) Negative multiply, Negative accumulate XX3-form (xvf64gernn AT,XAp,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVF64GERNP, 0xfc0007f800000000, 0xec0003d000000000, 0x60000100000000, // VSX Vector 64-bit Floating-Point GER (rank-1 update) Negative multiply, Positive accumulate XX3-form (xvf64gernp AT,XAp,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVF64GERPN, 0xfc0007f800000000, 0xec0005d000000000, 0x60000100000000, // VSX Vector 64-bit Floating-Point GER (rank-1 update) Positive multiply, Negative accumulate XX3-form (xvf64gerpn AT,XAp,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVF64GERPP, 0xfc0007f800000000, 0xec0001d000000000, 0x60000100000000, // VSX Vector 64-bit Floating-Point GER (rank-1 update) Positive multiply, Positive accumulate XX3-form (xvf64gerpp AT,XAp,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVI16GER2, 0xfc0007f800000000, 0xec00025800000000, 0x60000100000000, // VSX Vector 16-bit Signed Integer GER (rank-2 update) XX3-form (xvi16ger2 AT,XA,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVI16GER2PP, 0xfc0007f800000000, 0xec00035800000000, 0x60000100000000, // VSX Vector 16-bit Signed Integer GER (rank-2 update) Positive multiply, Positive accumulate XX3-form (xvi16ger2pp AT,XA,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVI16GER2S, 0xfc0007f800000000, 0xec00015800000000, 0x60000100000000, // VSX Vector 16-bit Signed Integer GER (rank-2 update) with Saturation XX3-form (xvi16ger2s AT,XA,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVI16GER2SPP, 0xfc0007f800000000, 0xec00015000000000, 0x60000100000000, // VSX Vector 16-bit Signed Integer GER (rank-2 update) with Saturation Positive multiply, Positive accumulate XX3-form (xvi16ger2spp AT,XA,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVI4GER8, 0xfc0007f800000000, 0xec00011800000000, 0x60000100000000, // VSX Vector 4-bit Signed Integer GER (rank-8 update) XX3-form (xvi4ger8 AT,XA,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVI4GER8PP, 0xfc0007f800000000, 0xec00011000000000, 0x60000100000000, // VSX Vector 4-bit Signed Integer GER (rank-8 update) Positive multiply, Positive accumulate XX3-form (xvi4ger8pp AT,XA,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVI8GER4, 0xfc0007f800000000, 0xec00001800000000, 0x60000100000000, // VSX Vector 8-bit Signed/Unsigned Integer GER (rank-4 update) XX3-form (xvi8ger4 AT,XA,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVI8GER4PP, 0xfc0007f800000000, 0xec00001000000000, 0x60000100000000, // VSX Vector 8-bit Signed/Unsigned Integer GER (rank-4 update) Positive multiply, Positive accumulate XX3-form (xvi8ger4pp AT,XA,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVI8GER4SPP, 0xfc0007f800000000, 0xec00031800000000, 0x60000100000000, // VSX Vector 8-bit Signed/Unsigned Integer GER (rank-4 update) with Saturate Positive multiply, Positive accumulate XX3-form (xvi8ger4spp AT,XA,XB)
+		[6]*argField{ap_MMAReg_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVTLSBB, 0xfc1f07fc00000000, 0xf002076c00000000, 0x60000100000000, // VSX Vector Test Least-Significant Bit by Byte XX2-form (xvtlsbb BF,XB)
+		[6]*argField{ap_CondRegField_6_8, ap_VecSReg_30_30_16_20}},
+	{XXBLENDVB, 0xfff00000fc000030, 0x500000084000000, 0xfffff00000000, // VSX Vector Blend Variable Byte 8RR:XX4-form (xxblendvb XT,XA,XB,XC)
+		[6]*argField{ap_VecSReg_63_63_38_42, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_VecSReg_60_60_53_57}},
+	{XXBLENDVD, 0xfff00000fc000030, 0x500000084000030, 0xfffff00000000, // VSX Vector Blend Variable Doubleword 8RR:XX4-form (xxblendvd XT,XA,XB,XC)
+		[6]*argField{ap_VecSReg_63_63_38_42, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_VecSReg_60_60_53_57}},
+	{XXBLENDVH, 0xfff00000fc000030, 0x500000084000010, 0xfffff00000000, // VSX Vector Blend Variable Halfword 8RR:XX4-form (xxblendvh XT,XA,XB,XC)
+		[6]*argField{ap_VecSReg_63_63_38_42, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_VecSReg_60_60_53_57}},
+	{XXBLENDVW, 0xfff00000fc000030, 0x500000084000020, 0xfffff00000000, // VSX Vector Blend Variable Word 8RR:XX4-form (xxblendvw XT,XA,XB,XC)
+		[6]*argField{ap_VecSReg_63_63_38_42, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_VecSReg_60_60_53_57}},
+	{XXEVAL, 0xfff00000fc000030, 0x500000088000010, 0xfff0000000000, // VSX Vector Evaluate 8RR-XX4-form (xxeval XT,XA,XB,XC,IMM)
+		[6]*argField{ap_VecSReg_63_63_38_42, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_VecSReg_60_60_53_57, ap_ImmUnsigned_24_31}},
+	{XXGENPCVBM, 0xfc0007fe00000000, 0xf000072800000000, 0x0, // VSX Vector Generate PCV from Byte Mask X-form (xxgenpcvbm XT,VRB,IMM)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecReg_16_20, ap_ImmUnsigned_11_15}},
+	{XXGENPCVDM, 0xfc0007fe00000000, 0xf000076a00000000, 0x0, // VSX Vector Generate PCV from Doubleword Mask X-form (xxgenpcvdm XT,VRB,IMM)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecReg_16_20, ap_ImmUnsigned_11_15}},
+	{XXGENPCVHM, 0xfc0007fe00000000, 0xf000072a00000000, 0x0, // VSX Vector Generate PCV from Halfword Mask X-form (xxgenpcvhm XT,VRB,IMM)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecReg_16_20, ap_ImmUnsigned_11_15}},
+	{XXGENPCVWM, 0xfc0007fe00000000, 0xf000076800000000, 0x0, // VSX Vector Generate PCV from Word Mask X-form (xxgenpcvwm XT,VRB,IMM)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecReg_16_20, ap_ImmUnsigned_11_15}},
+	{XXMFACC, 0xfc1f07fe00000000, 0x7c00016200000000, 0x60f80100000000, // VSX Move From Accumulator X-form (xxmfacc AS)
+		[6]*argField{ap_MMAReg_6_8}},
+	{XXMTACC, 0xfc1f07fe00000000, 0x7c01016200000000, 0x60f80100000000, // VSX Move To Accumulator X-form (xxmtacc AT)
+		[6]*argField{ap_MMAReg_6_8}},
+	{XXPERMX, 0xfff00000fc000030, 0x500000088000000, 0xffff800000000, // VSX Vector Permute Extended 8RR:XX4-form (xxpermx XT,XA,XB,XC,UIM)
+		[6]*argField{ap_VecSReg_63_63_38_42, ap_VecSReg_61_61_43_47, ap_VecSReg_62_62_48_52, ap_VecSReg_60_60_53_57, ap_ImmUnsigned_29_31}},
+	{XXSETACCZ, 0xfc1f07fe00000000, 0x7c03016200000000, 0x60f80100000000, // VSX Set Accumulator to Zero X-form (xxsetaccz AT)
+		[6]*argField{ap_MMAReg_6_8}},
+	{XXSPLTI32DX, 0xfff00000fc1c0000, 0x500000080000000, 0xf000000000000, // VSX Vector Splat Immediate32 Doubleword Indexed 8RR:D-form (xxsplti32dx XT,IX,IMM32)
+		[6]*argField{ap_VecSReg_47_47_38_42, ap_ImmUnsigned_46_46, ap_ImmUnsigned_16_31_48_63}},
+	{XXSPLTIDP, 0xfff00000fc1e0000, 0x500000080040000, 0xf000000000000, // VSX Vector Splat Immediate Double-Precision 8RR:D-form (xxspltidp XT,IMM32)
+		[6]*argField{ap_VecSReg_47_47_38_42, ap_ImmUnsigned_16_31_48_63}},
+	{XXSPLTIW, 0xfff00000fc1e0000, 0x500000080060000, 0xf000000000000, // VSX Vector Splat Immediate Word 8RR:D-form (xxspltiw XT,IMM32)
+		[6]*argField{ap_VecSReg_47_47_38_42, ap_ImmUnsigned_16_31_48_63}},
+	{MSGCLRU, 0xfc0007fe00000000, 0x7c0000dc00000000, 0x3ff000100000000, // Ultravisor Message Clear X-form (msgclru RB)
+		[6]*argField{ap_Reg_16_20}},
+	{MSGSNDU, 0xfc0007fe00000000, 0x7c00009c00000000, 0x3ff000100000000, // Ultravisor Message SendX-form (msgsndu RB)
+		[6]*argField{ap_Reg_16_20}},
+	{URFID, 0xfc0007fe00000000, 0x4c00026400000000, 0x3fff80100000000, // Ultravisor Return From Interrupt Doubleword XL-form (urfid)
+		[6]*argField{}},
+	{ADDEX, 0xfc0001fe00000000, 0x7c00015400000000, 0x100000000, // Add Extended using alternate carry bit Z23-form (addex RT,RA,RB,CY)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20, ap_ImmUnsigned_21_22}},
+	{MFFSCDRN, 0xfc1f07fe00000000, 0xfc14048e00000000, 0x100000000, // Move From FPSCR Control & Set DRN X-form (mffscdrn FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{MFFSCDRNI, 0xfc1f07fe00000000, 0xfc15048e00000000, 0xc00100000000, // Move From FPSCR Control & Set DRN Immediate X-form (mffscdrni FRT,DRM)
+		[6]*argField{ap_FPReg_6_10, ap_ImmUnsigned_18_20}},
+	{MFFSCE, 0xfc1f07fe00000000, 0xfc01048e00000000, 0xf80100000000, // Move From FPSCR & Clear Enables X-form (mffsce FRT)
+		[6]*argField{ap_FPReg_6_10}},
+	{MFFSCRN, 0xfc1f07fe00000000, 0xfc16048e00000000, 0x100000000, // Move From FPSCR Control & Set RN X-form (mffscrn FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{MFFSCRNI, 0xfc1f07fe00000000, 0xfc17048e00000000, 0xe00100000000, // Move From FPSCR Control & Set RN Immediate X-form (mffscrni FRT,RM)
+		[6]*argField{ap_FPReg_6_10, ap_ImmUnsigned_19_20}},
+	{MFFSL, 0xfc1f07fe00000000, 0xfc18048e00000000, 0xf80100000000, // Move From FPSCR Lightweight X-form (mffsl FRT)
+		[6]*argField{ap_FPReg_6_10}},
+	{SLBIAG, 0xfc0007fe00000000, 0x7c0006a400000000, 0x1ef80100000000, // SLB Invalidate All Global X-form (slbiag RS, L)
+		[6]*argField{ap_Reg_6_10, ap_ImmUnsigned_15_15}},
+	{VMSUMUDM, 0xfc00003f00000000, 0x1000002300000000, 0x0, // Vector Multiply-Sum Unsigned Doubleword Modulo VA-form (vmsumudm VRT,VRA,VRB,VRC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
+	{ADDPCIS, 0xfc00003e00000000, 0x4c00000400000000, 0x0, // Add PC Immediate Shifted DX-form (addpcis RT,D)
+		[6]*argField{ap_Reg_6_10, ap_ImmSigned_16_25_11_15_31_31}},
+	{BCDCFNCC, 0xfc1f05ff00000000, 0x1007058100000000, 0x0, // Decimal Convert From National VX-form (bcdcfn. VRT,VRB,PS)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_22_22}},
+	{BCDCFSQCC, 0xfc1f05ff00000000, 0x1002058100000000, 0x0, // Decimal Convert From Signed Quadword VX-form (bcdcfsq. VRT,VRB,PS)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_22_22}},
+	{BCDCFZCC, 0xfc1f05ff00000000, 0x1006058100000000, 0x0, // Decimal Convert From Zoned VX-form (bcdcfz. VRT,VRB,PS)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_22_22}},
+	{BCDCPSGNCC, 0xfc0007ff00000000, 0x1000034100000000, 0x0, // Decimal Copy Sign VX-form (bcdcpsgn. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{BCDCTNCC, 0xfc1f05ff00000000, 0x1005058100000000, 0x20000000000, // Decimal Convert To National VX-form (bcdctn. VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{BCDCTSQCC, 0xfc1f05ff00000000, 0x1000058100000000, 0x20000000000, // Decimal Convert To Signed Quadword VX-form (bcdctsq. VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{BCDCTZCC, 0xfc1f05ff00000000, 0x1004058100000000, 0x0, // Decimal Convert To Zoned VX-form (bcdctz. VRT,VRB,PS)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_22_22}},
+	{BCDSCC, 0xfc0005ff00000000, 0x100004c100000000, 0x0, // Decimal Shift VX-form (bcds. VRT,VRA,VRB,PS)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_ImmUnsigned_22_22}},
+	{BCDSETSGNCC, 0xfc1f05ff00000000, 0x101f058100000000, 0x0, // Decimal Set Sign VX-form (bcdsetsgn. VRT,VRB,PS)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_22_22}},
+	{BCDSRCC, 0xfc0005ff00000000, 0x100005c100000000, 0x0, // Decimal Shift and Round VX-form (bcdsr. VRT,VRA,VRB,PS)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_ImmUnsigned_22_22}},
+	{BCDTRUNCCC, 0xfc0005ff00000000, 0x1000050100000000, 0x0, // Decimal Truncate VX-form (bcdtrunc. VRT,VRA,VRB,PS)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_ImmUnsigned_22_22}},
+	{BCDUSCC, 0xfc0005ff00000000, 0x1000048100000000, 0x20000000000, // Decimal Unsigned Shift VX-form (bcdus. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{BCDUTRUNCCC, 0xfc0005ff00000000, 0x1000054100000000, 0x20000000000, // Decimal Unsigned Truncate VX-form (bcdutrunc. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{CMPEQB, 0xfc0007fe00000000, 0x7c0001c000000000, 0x60000100000000, // Compare Equal Byte X-form (cmpeqb BF,RA,RB)
+		[6]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
+	{CMPRB, 0xfc0007fe00000000, 0x7c00018000000000, 0x40000100000000, // Compare Ranged Byte X-form (cmprb BF,L,RA,RB)
+		[6]*argField{ap_CondRegField_6_8, ap_ImmUnsigned_10_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{CNTTZD, 0xfc0007ff00000000, 0x7c00047400000000, 0xf80000000000, // Count Trailing Zeros Doubleword X-form (cnttzd RA,RS)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10}},
+	{CNTTZDCC, 0xfc0007ff00000000, 0x7c00047500000000, 0xf80000000000, // Count Trailing Zeros Doubleword X-form (cnttzd. RA,RS)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10}},
+	{CNTTZW, 0xfc0007ff00000000, 0x7c00043400000000, 0xf80000000000, // Count Trailing Zeros Word X-form (cnttzw RA,RS)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10}},
+	{CNTTZWCC, 0xfc0007ff00000000, 0x7c00043500000000, 0xf80000000000, // Count Trailing Zeros Word X-form (cnttzw. RA,RS)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10}},
+	{COPY, 0xfc2007fe00000000, 0x7c20060c00000000, 0x3c0000100000000, // Copy X-form (copy RA,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_16_20}},
+	{CPABORT, 0xfc0007fe00000000, 0x7c00068c00000000, 0x3fff80100000000, // Copy-Paste Abort X-form (cpabort)
+		[6]*argField{}},
+	{DARN, 0xfc0007fe00000000, 0x7c0005e600000000, 0x1cf80100000000, // Deliver A Random Number X-form (darn RT,L)
+		[6]*argField{ap_Reg_6_10, ap_ImmUnsigned_14_15}},
+	{DTSTSFI, 0xfc0007fe00000000, 0xec00054600000000, 0x40000100000000, // DFP Test Significance Immediate X-form (dtstsfi BF,UIM,FRB)
+		[6]*argField{ap_CondRegField_6_8, ap_ImmUnsigned_10_15, ap_FPReg_16_20}},
+	{DTSTSFIQ, 0xfc0007fe00000000, 0xfc00054600000000, 0x40000100000000, // DFP Test Significance Immediate Quad X-form (dtstsfiq BF,UIM,FRBp)
+		[6]*argField{ap_CondRegField_6_8, ap_ImmUnsigned_10_15, ap_FPReg_16_20}},
+	{EXTSWSLI, 0xfc0007fd00000000, 0x7c0006f400000000, 0x0, // Extend Sign Word and Shift Left Immediate XS-form (extswsli RA,RS,SH)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_30_30_16_20}},
+	{EXTSWSLICC, 0xfc0007fd00000000, 0x7c0006f500000000, 0x0, // Extend Sign Word and Shift Left Immediate XS-form (extswsli. RA,RS,SH)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_30_30_16_20}},
+	{LDAT, 0xfc0007fe00000000, 0x7c0004cc00000000, 0x100000000, // Load Doubleword ATomic X-form (ldat RT,RA,FC)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_ImmUnsigned_16_20}},
+	{LWAT, 0xfc0007fe00000000, 0x7c00048c00000000, 0x100000000, // Load Word ATomic X-form (lwat RT,RA,FC)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_ImmUnsigned_16_20}},
+	{LXSD, 0xfc00000300000000, 0xe400000200000000, 0x0, // Load VSX Scalar Doubleword DS-form (lxsd VRT,DS(RA))
+		[6]*argField{ap_VecReg_6_10, ap_Offset_16_29_shift2, ap_Reg_11_15}},
+	{LXSIBZX, 0xfc0007fe00000000, 0x7c00061a00000000, 0x0, // Load VSX Scalar as Integer Byte & Zero Indexed X-form (lxsibzx XT,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LXSIHZX, 0xfc0007fe00000000, 0x7c00065a00000000, 0x0, // Load VSX Scalar as Integer Halfword & Zero Indexed X-form (lxsihzx XT,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LXSSP, 0xfc00000300000000, 0xe400000300000000, 0x0, // Load VSX Scalar Single-Precision DS-form (lxssp VRT,DS(RA))
+		[6]*argField{ap_VecReg_6_10, ap_Offset_16_29_shift2, ap_Reg_11_15}},
+	{LXV, 0xfc00000700000000, 0xf400000100000000, 0x0, // Load VSX Vector DQ-form (lxv XT,DQ(RA))
+		[6]*argField{ap_VecSReg_28_28_6_10, ap_Offset_16_27_shift4, ap_Reg_11_15}},
+	{LXVB16X, 0xfc0007fe00000000, 0x7c0006d800000000, 0x0, // Load VSX Vector Byte*16 Indexed X-form (lxvb16x XT,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LXVH8X, 0xfc0007fe00000000, 0x7c00065800000000, 0x0, // Load VSX Vector Halfword*8 Indexed X-form (lxvh8x XT,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LXVL, 0xfc0007fe00000000, 0x7c00021a00000000, 0x0, // Load VSX Vector with Length X-form (lxvl XT,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LXVLL, 0xfc0007fe00000000, 0x7c00025a00000000, 0x0, // Load VSX Vector with Length Left-justified X-form (lxvll XT,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LXVWSX, 0xfc0007fe00000000, 0x7c0002d800000000, 0x0, // Load VSX Vector Word & Splat Indexed X-form (lxvwsx XT,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LXVX, 0xfc0007be00000000, 0x7c00021800000000, 0x4000000000, // Load VSX Vector Indexed X-form (lxvx XT,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MADDHD, 0xfc00003f00000000, 0x1000003000000000, 0x0, // Multiply-Add High Doubleword VA-form (maddhd RT,RA,RB,RC)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20, ap_Reg_21_25}},
+	{MADDHDU, 0xfc00003f00000000, 0x1000003100000000, 0x0, // Multiply-Add High Doubleword Unsigned VA-form (maddhdu RT,RA,RB,RC)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20, ap_Reg_21_25}},
+	{MADDLD, 0xfc00003f00000000, 0x1000003300000000, 0x0, // Multiply-Add Low Doubleword VA-form (maddld RT,RA,RB,RC)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20, ap_Reg_21_25}},
+	{MCRXRX, 0xfc0007fe00000000, 0x7c00048000000000, 0x7ff80100000000, // Move to CR from XER Extended X-form (mcrxrx BF)
+		[6]*argField{ap_CondRegField_6_8}},
+	{MFVSRLD, 0xfc0007fe00000000, 0x7c00026600000000, 0xf80000000000, // Move From VSR Lower Doubleword X-form (mfvsrld RA,XS)
+		[6]*argField{ap_Reg_11_15, ap_VecSReg_31_31_6_10}},
+	{MODSD, 0xfc0007fe00000000, 0x7c00061200000000, 0x100000000, // Modulo Signed Doubleword X-form (modsd RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MODSW, 0xfc0007fe00000000, 0x7c00061600000000, 0x100000000, // Modulo Signed Word X-form (modsw RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MODUD, 0xfc0007fe00000000, 0x7c00021200000000, 0x100000000, // Modulo Unsigned Doubleword X-form (modud RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MODUW, 0xfc0007fe00000000, 0x7c00021600000000, 0x100000000, // Modulo Unsigned Word X-form (moduw RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MSGSYNC, 0xfc0007fe00000000, 0x7c0006ec00000000, 0x3fff80100000000, // Message Synchronize X-form (msgsync)
+		[6]*argField{}},
+	{MTVSRDD, 0xfc0007fe00000000, 0x7c00036600000000, 0x0, // Move To VSR Double Doubleword X-form (mtvsrdd XT,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MTVSRWS, 0xfc0007fe00000000, 0x7c00032600000000, 0xf80000000000, // Move To VSR Word & Splat X-form (mtvsrws XT,RA)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15}},
+	{PASTECC, 0xfc0007ff00000000, 0x7c00070d00000000, 0x3c0000000000000, // Paste X-form (paste. RA,RB,L)
+		[6]*argField{ap_Reg_11_15, ap_Reg_16_20, ap_ImmUnsigned_10_10}},
+	{SETB, 0xfc0007fe00000000, 0x7c00010000000000, 0x3f80100000000, // Set Boolean X-form (setb RT,BFA)
+		[6]*argField{ap_Reg_6_10, ap_CondRegField_11_13}},
+	{SLBIEG, 0xfc0007fe00000000, 0x7c0003a400000000, 0x1f000100000000, // SLB Invalidate Entry Global X-form (slbieg RS,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_16_20}},
+	{SLBSYNC, 0xfc0007fe00000000, 0x7c0002a400000000, 0x3fff80100000000, // SLB Synchronize X-form (slbsync)
+		[6]*argField{}},
+	{STDAT, 0xfc0007fe00000000, 0x7c0005cc00000000, 0x100000000, // Store Doubleword ATomic X-form (stdat RS,RA,FC)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_ImmUnsigned_16_20}},
+	{STOP, 0xfc0007fe00000000, 0x4c0002e400000000, 0x3fff80100000000, // Stop XL-form (stop)
+		[6]*argField{}},
+	{STWAT, 0xfc0007fe00000000, 0x7c00058c00000000, 0x100000000, // Store Word ATomic X-form (stwat RS,RA,FC)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_ImmUnsigned_16_20}},
+	{STXSD, 0xfc00000300000000, 0xf400000200000000, 0x0, // Store VSX Scalar Doubleword DS-form (stxsd VRS,DS(RA))
+		[6]*argField{ap_VecReg_6_10, ap_Offset_16_29_shift2, ap_Reg_11_15}},
+	{STXSIBX, 0xfc0007fe00000000, 0x7c00071a00000000, 0x0, // Store VSX Scalar as Integer Byte Indexed X-form (stxsibx XS,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STXSIHX, 0xfc0007fe00000000, 0x7c00075a00000000, 0x0, // Store VSX Scalar as Integer Halfword Indexed X-form (stxsihx XS,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STXSSP, 0xfc00000300000000, 0xf400000300000000, 0x0, // Store VSX Scalar Single DS-form (stxssp VRS,DS(RA))
+		[6]*argField{ap_VecReg_6_10, ap_Offset_16_29_shift2, ap_Reg_11_15}},
+	{STXV, 0xfc00000700000000, 0xf400000500000000, 0x0, // Store VSX Vector DQ-form (stxv XS,DQ(RA))
+		[6]*argField{ap_VecSReg_28_28_6_10, ap_Offset_16_27_shift4, ap_Reg_11_15}},
+	{STXVB16X, 0xfc0007fe00000000, 0x7c0007d800000000, 0x0, // Store VSX Vector Byte*16 Indexed X-form (stxvb16x XS,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STXVH8X, 0xfc0007fe00000000, 0x7c00075800000000, 0x0, // Store VSX Vector Halfword*8 Indexed X-form (stxvh8x XS,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STXVL, 0xfc0007fe00000000, 0x7c00031a00000000, 0x0, // Store VSX Vector with Length X-form (stxvl XS,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STXVLL, 0xfc0007fe00000000, 0x7c00035a00000000, 0x0, // Store VSX Vector with Length Left-justified X-form (stxvll XS,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STXVX, 0xfc0007fe00000000, 0x7c00031800000000, 0x0, // Store VSX Vector Indexed X-form (stxvx XS,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{VABSDUB, 0xfc0007ff00000000, 0x1000040300000000, 0x0, // Vector Absolute Difference Unsigned Byte VX-form (vabsdub VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VABSDUH, 0xfc0007ff00000000, 0x1000044300000000, 0x0, // Vector Absolute Difference Unsigned Halfword VX-form (vabsduh VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VABSDUW, 0xfc0007ff00000000, 0x1000048300000000, 0x0, // Vector Absolute Difference Unsigned Word VX-form (vabsduw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VBPERMD, 0xfc0007ff00000000, 0x100005cc00000000, 0x0, // Vector Bit Permute Doubleword VX-form (vbpermd VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCLZLSBB, 0xfc1f07ff00000000, 0x1000060200000000, 0x0, // Vector Count Leading Zero Least-Significant Bits Byte VX-form (vclzlsbb RT,VRB)
+		[6]*argField{ap_Reg_6_10, ap_VecReg_16_20}},
+	{VCMPNEB, 0xfc0007ff00000000, 0x1000000700000000, 0x0, // Vector Compare Not Equal Byte VC-form (vcmpneb VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPNEBCC, 0xfc0007ff00000000, 0x1000040700000000, 0x0, // Vector Compare Not Equal Byte VC-form (vcmpneb. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPNEH, 0xfc0007ff00000000, 0x1000004700000000, 0x0, // Vector Compare Not Equal Halfword VC-form (vcmpneh VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPNEHCC, 0xfc0007ff00000000, 0x1000044700000000, 0x0, // Vector Compare Not Equal Halfword VC-form (vcmpneh. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPNEW, 0xfc0007ff00000000, 0x1000008700000000, 0x0, // Vector Compare Not Equal Word VC-form (vcmpnew VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPNEWCC, 0xfc0007ff00000000, 0x1000048700000000, 0x0, // Vector Compare Not Equal Word VC-form (vcmpnew. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPNEZB, 0xfc0007ff00000000, 0x1000010700000000, 0x0, // Vector Compare Not Equal or Zero Byte VC-form (vcmpnezb VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPNEZBCC, 0xfc0007ff00000000, 0x1000050700000000, 0x0, // Vector Compare Not Equal or Zero Byte VC-form (vcmpnezb. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPNEZH, 0xfc0007ff00000000, 0x1000014700000000, 0x0, // Vector Compare Not Equal or Zero Halfword VC-form (vcmpnezh VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPNEZHCC, 0xfc0007ff00000000, 0x1000054700000000, 0x0, // Vector Compare Not Equal or Zero Halfword VC-form (vcmpnezh. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPNEZW, 0xfc0007ff00000000, 0x1000018700000000, 0x0, // Vector Compare Not Equal or Zero Word VC-form (vcmpnezw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPNEZWCC, 0xfc0007ff00000000, 0x1000058700000000, 0x0, // Vector Compare Not Equal or Zero Word VC-form (vcmpnezw. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCTZB, 0xfc1f07ff00000000, 0x101c060200000000, 0x0, // Vector Count Trailing Zeros Byte VX-form (vctzb VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VCTZD, 0xfc1f07ff00000000, 0x101f060200000000, 0x0, // Vector Count Trailing Zeros Doubleword VX-form (vctzd VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VCTZH, 0xfc1f07ff00000000, 0x101d060200000000, 0x0, // Vector Count Trailing Zeros Halfword VX-form (vctzh VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VCTZLSBB, 0xfc1f07ff00000000, 0x1001060200000000, 0x0, // Vector Count Trailing Zero Least-Significant Bits Byte VX-form (vctzlsbb RT,VRB)
+		[6]*argField{ap_Reg_6_10, ap_VecReg_16_20}},
+	{VCTZW, 0xfc1f07ff00000000, 0x101e060200000000, 0x0, // Vector Count Trailing Zeros Word VX-form (vctzw VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VEXTRACTD, 0xfc0007ff00000000, 0x100002cd00000000, 0x10000000000000, // Vector Extract Doubleword to VSR using immediate-specified index VX-form (vextractd VRT,VRB,UIM)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_12_15}},
+	{VEXTRACTUB, 0xfc0007ff00000000, 0x1000020d00000000, 0x10000000000000, // Vector Extract Unsigned Byte to VSR using immediate-specified index VX-form (vextractub VRT,VRB,UIM)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_12_15}},
+	{VEXTRACTUH, 0xfc0007ff00000000, 0x1000024d00000000, 0x10000000000000, // Vector Extract Unsigned Halfword to VSR using immediate-specified index VX-form (vextractuh VRT,VRB,UIM)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_12_15}},
+	{VEXTRACTUW, 0xfc0007ff00000000, 0x1000028d00000000, 0x10000000000000, // Vector Extract Unsigned Word to VSR using immediate-specified index VX-form (vextractuw VRT,VRB,UIM)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_12_15}},
+	{VEXTSB2D, 0xfc1f07ff00000000, 0x1018060200000000, 0x0, // Vector Extend Sign Byte To Doubleword VX-form (vextsb2d VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VEXTSB2W, 0xfc1f07ff00000000, 0x1010060200000000, 0x0, // Vector Extend Sign Byte To Word VX-form (vextsb2w VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VEXTSH2D, 0xfc1f07ff00000000, 0x1019060200000000, 0x0, // Vector Extend Sign Halfword To Doubleword VX-form (vextsh2d VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VEXTSH2W, 0xfc1f07ff00000000, 0x1011060200000000, 0x0, // Vector Extend Sign Halfword To Word VX-form (vextsh2w VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VEXTSW2D, 0xfc1f07ff00000000, 0x101a060200000000, 0x0, // Vector Extend Sign Word To Doubleword VX-form (vextsw2d VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VEXTUBLX, 0xfc0007ff00000000, 0x1000060d00000000, 0x0, // Vector Extract Unsigned Byte to GPR using GPR-specified Left-Index VX-form (vextublx RT,RA,VRB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_VecReg_16_20}},
+	{VEXTUBRX, 0xfc0007ff00000000, 0x1000070d00000000, 0x0, // Vector Extract Unsigned Byte to GPR using GPR-specified Right-Index VX-form (vextubrx RT,RA,VRB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_VecReg_16_20}},
+	{VEXTUHLX, 0xfc0007ff00000000, 0x1000064d00000000, 0x0, // Vector Extract Unsigned Halfword to GPR using GPR-specified Left-Index VX-form (vextuhlx RT,RA,VRB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_VecReg_16_20}},
+	{VEXTUHRX, 0xfc0007ff00000000, 0x1000074d00000000, 0x0, // Vector Extract Unsigned Halfword to GPR using GPR-specified Right-Index VX-form (vextuhrx RT,RA,VRB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_VecReg_16_20}},
+	{VEXTUWLX, 0xfc0007ff00000000, 0x1000068d00000000, 0x0, // Vector Extract Unsigned Word to GPR using GPR-specified Left-Index VX-form (vextuwlx RT,RA,VRB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_VecReg_16_20}},
+	{VEXTUWRX, 0xfc0007ff00000000, 0x1000078d00000000, 0x0, // Vector Extract Unsigned Word to GPR using GPR-specified Right-Index VX-form (vextuwrx RT,RA,VRB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_VecReg_16_20}},
+	{VINSERTB, 0xfc0007ff00000000, 0x1000030d00000000, 0x10000000000000, // Vector Insert Byte from VSR using immediate-specified index VX-form (vinsertb VRT,VRB,UIM)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_12_15}},
+	{VINSERTD, 0xfc0007ff00000000, 0x100003cd00000000, 0x10000000000000, // Vector Insert Doubleword from VSR using immediate-specified index VX-form (vinsertd VRT,VRB,UIM)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_12_15}},
+	{VINSERTH, 0xfc0007ff00000000, 0x1000034d00000000, 0x10000000000000, // Vector Insert Halfword from VSR using immediate-specified index VX-form (vinserth VRT,VRB,UIM)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_12_15}},
+	{VINSERTW, 0xfc0007ff00000000, 0x1000038d00000000, 0x10000000000000, // Vector Insert Word from VSR using immediate-specified index VX-form (vinsertw VRT,VRB,UIM)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_12_15}},
+	{VMUL10CUQ, 0xfc0007ff00000000, 0x1000000100000000, 0xf80000000000, // Vector Multiply-by-10 & write Carry-out Unsigned Quadword VX-form (vmul10cuq VRT,VRA)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15}},
+	{VMUL10ECUQ, 0xfc0007ff00000000, 0x1000004100000000, 0x0, // Vector Multiply-by-10 Extended & write Carry-out Unsigned Quadword VX-form (vmul10ecuq VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMUL10EUQ, 0xfc0007ff00000000, 0x1000024100000000, 0x0, // Vector Multiply-by-10 Extended Unsigned Quadword VX-form (vmul10euq VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMUL10UQ, 0xfc0007ff00000000, 0x1000020100000000, 0xf80000000000, // Vector Multiply-by-10 Unsigned Quadword VX-form (vmul10uq VRT,VRA)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15}},
+	{VNEGD, 0xfc1f07ff00000000, 0x1007060200000000, 0x0, // Vector Negate Doubleword VX-form (vnegd VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VNEGW, 0xfc1f07ff00000000, 0x1006060200000000, 0x0, // Vector Negate Word VX-form (vnegw VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VPERMR, 0xfc00003f00000000, 0x1000003b00000000, 0x0, // Vector Permute Right-indexed VA-form (vpermr VRT,VRA,VRB,VRC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
+	{VPRTYBD, 0xfc1f07ff00000000, 0x1009060200000000, 0x0, // Vector Parity Byte Doubleword VX-form (vprtybd VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VPRTYBQ, 0xfc1f07ff00000000, 0x100a060200000000, 0x0, // Vector Parity Byte Quadword VX-form (vprtybq VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VPRTYBW, 0xfc1f07ff00000000, 0x1008060200000000, 0x0, // Vector Parity Byte Word VX-form (vprtybw VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VRLDMI, 0xfc0007ff00000000, 0x100000c500000000, 0x0, // Vector Rotate Left Doubleword then Mask Insert VX-form (vrldmi VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VRLDNM, 0xfc0007ff00000000, 0x100001c500000000, 0x0, // Vector Rotate Left Doubleword then AND with Mask VX-form (vrldnm VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VRLWMI, 0xfc0007ff00000000, 0x1000008500000000, 0x0, // Vector Rotate Left Word then Mask Insert VX-form (vrlwmi VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VRLWNM, 0xfc0007ff00000000, 0x1000018500000000, 0x0, // Vector Rotate Left Word then AND with Mask VX-form (vrlwnm VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSLV, 0xfc0007ff00000000, 0x1000074400000000, 0x0, // Vector Shift Left Variable VX-form (vslv VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSRV, 0xfc0007ff00000000, 0x1000070400000000, 0x0, // Vector Shift Right Variable VX-form (vsrv VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{WAIT, 0xfc0007fe00000000, 0x7c00003c00000000, 0x9cf80100000000, // Wait X-form (wait WC,PL)
+		[6]*argField{ap_ImmUnsigned_9_10, ap_ImmUnsigned_14_15}},
+	{XSABSQP, 0xfc1f07fe00000000, 0xfc00064800000000, 0x100000000, // VSX Scalar Absolute Quad-Precision X-form (xsabsqp VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{XSADDQP, 0xfc0007ff00000000, 0xfc00000800000000, 0x0, // VSX Scalar Add Quad-Precision [using round to Odd] X-form (xsaddqp VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSADDQPO, 0xfc0007ff00000000, 0xfc00000900000000, 0x0, // VSX Scalar Add Quad-Precision [using round to Odd] X-form (xsaddqpo VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSCMPEQDP, 0xfc0007f800000000, 0xf000001800000000, 0x0, // VSX Scalar Compare Equal Double-Precision XX3-form (xscmpeqdp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSCMPEXPDP, 0xfc0007f800000000, 0xf00001d800000000, 0x60000100000000, // VSX Scalar Compare Exponents Double-Precision XX3-form (xscmpexpdp BF,XA,XB)
+		[6]*argField{ap_CondRegField_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSCMPEXPQP, 0xfc0007fe00000000, 0xfc00014800000000, 0x60000100000000, // VSX Scalar Compare Exponents Quad-Precision X-form (xscmpexpqp BF,VRA,VRB)
+		[6]*argField{ap_CondRegField_6_8, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSCMPGEDP, 0xfc0007f800000000, 0xf000009800000000, 0x0, // VSX Scalar Compare Greater Than or Equal Double-Precision XX3-form (xscmpgedp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSCMPGTDP, 0xfc0007f800000000, 0xf000005800000000, 0x0, // VSX Scalar Compare Greater Than Double-Precision XX3-form (xscmpgtdp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSCMPOQP, 0xfc0007fe00000000, 0xfc00010800000000, 0x60000100000000, // VSX Scalar Compare Ordered Quad-Precision X-form (xscmpoqp BF,VRA,VRB)
+		[6]*argField{ap_CondRegField_6_8, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSCMPUQP, 0xfc0007fe00000000, 0xfc00050800000000, 0x60000100000000, // VSX Scalar Compare Unordered Quad-Precision X-form (xscmpuqp BF,VRA,VRB)
+		[6]*argField{ap_CondRegField_6_8, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSCPSGNQP, 0xfc0007fe00000000, 0xfc0000c800000000, 0x100000000, // VSX Scalar Copy Sign Quad-Precision X-form (xscpsgnqp VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSCVDPHP, 0xfc1f07fc00000000, 0xf011056c00000000, 0x0, // VSX Scalar Convert with round Double-Precision to Half-Precision format XX2-form (xscvdphp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSCVDPQP, 0xfc1f07fe00000000, 0xfc16068800000000, 0x100000000, // VSX Scalar Convert Double-Precision to Quad-Precision format X-form (xscvdpqp VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{XSCVHPDP, 0xfc1f07fc00000000, 0xf010056c00000000, 0x0, // VSX Scalar Convert Half-Precision to Double-Precision format XX2-form (xscvhpdp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSCVQPDP, 0xfc1f07ff00000000, 0xfc14068800000000, 0x0, // VSX Scalar Convert with round Quad-Precision to Double-Precision format [using round to Odd] X-form (xscvqpdp VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{XSCVQPDPO, 0xfc1f07ff00000000, 0xfc14068900000000, 0x0, // VSX Scalar Convert with round Quad-Precision to Double-Precision format [using round to Odd] X-form (xscvqpdpo VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{XSCVQPSDZ, 0xfc1f07fe00000000, 0xfc19068800000000, 0x100000000, // VSX Scalar Convert with round to zero Quad-Precision to Signed Doubleword format X-form (xscvqpsdz VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{XSCVQPSWZ, 0xfc1f07fe00000000, 0xfc09068800000000, 0x100000000, // VSX Scalar Convert with round to zero Quad-Precision to Signed Word format X-form (xscvqpswz VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{XSCVQPUDZ, 0xfc1f07fe00000000, 0xfc11068800000000, 0x100000000, // VSX Scalar Convert with round to zero Quad-Precision to Unsigned Doubleword format X-form (xscvqpudz VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{XSCVQPUWZ, 0xfc1f07fe00000000, 0xfc01068800000000, 0x100000000, // VSX Scalar Convert with round to zero Quad-Precision to Unsigned Word format X-form (xscvqpuwz VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{XSCVSDQP, 0xfc1f07fe00000000, 0xfc0a068800000000, 0x100000000, // VSX Scalar Convert Signed Doubleword to Quad-Precision format X-form (xscvsdqp VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{XSCVUDQP, 0xfc1f07fe00000000, 0xfc02068800000000, 0x100000000, // VSX Scalar Convert Unsigned Doubleword to Quad-Precision format X-form (xscvudqp VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{XSDIVQP, 0xfc0007ff00000000, 0xfc00044800000000, 0x0, // VSX Scalar Divide Quad-Precision [using round to Odd] X-form (xsdivqp VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSDIVQPO, 0xfc0007ff00000000, 0xfc00044900000000, 0x0, // VSX Scalar Divide Quad-Precision [using round to Odd] X-form (xsdivqpo VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSIEXPDP, 0xfc0007fe00000000, 0xf000072c00000000, 0x0, // VSX Scalar Insert Exponent Double-Precision X-form (xsiexpdp XT,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{XSIEXPQP, 0xfc0007fe00000000, 0xfc0006c800000000, 0x100000000, // VSX Scalar Insert Exponent Quad-Precision X-form (xsiexpqp VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSMADDQP, 0xfc0007ff00000000, 0xfc00030800000000, 0x0, // VSX Scalar Multiply-Add Quad-Precision [using round to Odd] X-form (xsmaddqp VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSMADDQPO, 0xfc0007ff00000000, 0xfc00030900000000, 0x0, // VSX Scalar Multiply-Add Quad-Precision [using round to Odd] X-form (xsmaddqpo VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSMAXCDP, 0xfc0007f800000000, 0xf000040000000000, 0x0, // VSX Scalar Maximum Type-C Double-Precision XX3-form (xsmaxcdp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSMAXJDP, 0xfc0007f800000000, 0xf000048000000000, 0x0, // VSX Scalar Maximum Type-J Double-Precision XX3-form (xsmaxjdp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSMINCDP, 0xfc0007f800000000, 0xf000044000000000, 0x0, // VSX Scalar Minimum Type-C Double-Precision XX3-form (xsmincdp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSMINJDP, 0xfc0007f800000000, 0xf00004c000000000, 0x0, // VSX Scalar Minimum Type-J Double-Precision XX3-form (xsminjdp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSMSUBQP, 0xfc0007ff00000000, 0xfc00034800000000, 0x0, // VSX Scalar Multiply-Subtract Quad-Precision [using round to Odd] X-form (xsmsubqp VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSMSUBQPO, 0xfc0007ff00000000, 0xfc00034900000000, 0x0, // VSX Scalar Multiply-Subtract Quad-Precision [using round to Odd] X-form (xsmsubqpo VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSMULQP, 0xfc0007ff00000000, 0xfc00004800000000, 0x0, // VSX Scalar Multiply Quad-Precision [using round to Odd] X-form (xsmulqp VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSMULQPO, 0xfc0007ff00000000, 0xfc00004900000000, 0x0, // VSX Scalar Multiply Quad-Precision [using round to Odd] X-form (xsmulqpo VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSNABSQP, 0xfc1f07fe00000000, 0xfc08064800000000, 0x0, // VSX Scalar Negative Absolute Quad-Precision X-form (xsnabsqp VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{XSNEGQP, 0xfc1f07fe00000000, 0xfc10064800000000, 0x100000000, // VSX Scalar Negate Quad-Precision X-form (xsnegqp VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{XSNMADDQP, 0xfc0007ff00000000, 0xfc00038800000000, 0x0, // VSX Scalar Negative Multiply-Add Quad-Precision [using round to Odd] X-form (xsnmaddqp VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSNMADDQPO, 0xfc0007ff00000000, 0xfc00038900000000, 0x0, // VSX Scalar Negative Multiply-Add Quad-Precision [using round to Odd] X-form (xsnmaddqpo VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSNMSUBQP, 0xfc0007ff00000000, 0xfc0003c800000000, 0x0, // VSX Scalar Negative Multiply-Subtract Quad-Precision [using round to Odd] X-form (xsnmsubqp VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSNMSUBQPO, 0xfc0007ff00000000, 0xfc0003c900000000, 0x0, // VSX Scalar Negative Multiply-Subtract Quad-Precision [using round to Odd] X-form (xsnmsubqpo VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSRQPI, 0xfc0001ff00000000, 0xfc00000a00000000, 0x1e000000000000, // VSX Scalar Round to Quad-Precision Integer [with Inexact] Z23-form (xsrqpi R,VRT,VRB,RMC)
+		[6]*argField{ap_ImmUnsigned_15_15, ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_21_22}},
+	{XSRQPIX, 0xfc0001ff00000000, 0xfc00000b00000000, 0x1e000000000000, // VSX Scalar Round to Quad-Precision Integer [with Inexact] Z23-form (xsrqpix R,VRT,VRB,RMC)
+		[6]*argField{ap_ImmUnsigned_15_15, ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_21_22}},
+	{XSRQPXP, 0xfc0001fe00000000, 0xfc00004a00000000, 0x1e000100000000, // VSX Scalar Round Quad-Precision to Double-Extended Precision Z23-form (xsrqpxp R,VRT,VRB,RMC)
+		[6]*argField{ap_ImmUnsigned_15_15, ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_21_22}},
+	{XSSQRTQP, 0xfc1f07ff00000000, 0xfc1b064800000000, 0x0, // VSX Scalar Square Root Quad-Precision [using round to Odd] X-form (xssqrtqp VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{XSSQRTQPO, 0xfc1f07ff00000000, 0xfc1b064900000000, 0x0, // VSX Scalar Square Root Quad-Precision [using round to Odd] X-form (xssqrtqpo VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{XSSUBQP, 0xfc0007ff00000000, 0xfc00040800000000, 0x0, // VSX Scalar Subtract Quad-Precision [using round to Odd] X-form (xssubqp VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSSUBQPO, 0xfc0007ff00000000, 0xfc00040900000000, 0x0, // VSX Scalar Subtract Quad-Precision [using round to Odd] X-form (xssubqpo VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{XSTSTDCDP, 0xfc0007fc00000000, 0xf00005a800000000, 0x100000000, // VSX Scalar Test Data Class Double-Precision XX2-form (xststdcdp BF,XB,DCMX)
+		[6]*argField{ap_CondRegField_6_8, ap_VecSReg_30_30_16_20, ap_ImmUnsigned_9_15}},
+	{XSTSTDCQP, 0xfc0007fe00000000, 0xfc00058800000000, 0x100000000, // VSX Scalar Test Data Class Quad-Precision X-form (xststdcqp BF,VRB,DCMX)
+		[6]*argField{ap_CondRegField_6_8, ap_VecReg_16_20, ap_ImmUnsigned_9_15}},
+	{XSTSTDCSP, 0xfc0007fc00000000, 0xf00004a800000000, 0x100000000, // VSX Scalar Test Data Class Single-Precision XX2-form (xststdcsp BF,XB,DCMX)
+		[6]*argField{ap_CondRegField_6_8, ap_VecSReg_30_30_16_20, ap_ImmUnsigned_9_15}},
+	{XSXEXPDP, 0xfc1f07fc00000000, 0xf000056c00000000, 0x100000000, // VSX Scalar Extract Exponent Double-Precision XX2-form (xsxexpdp RT,XB)
+		[6]*argField{ap_Reg_6_10, ap_VecSReg_30_30_16_20}},
+	{XSXEXPQP, 0xfc1f07fe00000000, 0xfc02064800000000, 0x100000000, // VSX Scalar Extract Exponent Quad-Precision X-form (xsxexpqp VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{XSXSIGDP, 0xfc1f07fc00000000, 0xf001056c00000000, 0x100000000, // VSX Scalar Extract Significand Double-Precision XX2-form (xsxsigdp RT,XB)
+		[6]*argField{ap_Reg_6_10, ap_VecSReg_30_30_16_20}},
+	{XSXSIGQP, 0xfc1f07fe00000000, 0xfc12064800000000, 0x100000000, // VSX Scalar Extract Significand Quad-Precision X-form (xsxsigqp VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{XVCVHPSP, 0xfc1f07fc00000000, 0xf018076c00000000, 0x0, // VSX Vector Convert Half-Precision to Single-Precision format XX2-form (xvcvhpsp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVCVSPHP, 0xfc1f07fc00000000, 0xf019076c00000000, 0x0, // VSX Vector Convert with round Single-Precision to Half-Precision format XX2-form (xvcvsphp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVIEXPDP, 0xfc0007f800000000, 0xf00007c000000000, 0x0, // VSX Vector Insert Exponent Double-Precision XX3-form (xviexpdp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVIEXPSP, 0xfc0007f800000000, 0xf00006c000000000, 0x0, // VSX Vector Insert Exponent Single-Precision XX3-form (xviexpsp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVTSTDCDP, 0xfc0007b800000000, 0xf00007a800000000, 0x0, // VSX Vector Test Data Class Double-Precision XX2-form (xvtstdcdp XT,XB,DCMX)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20, ap_ImmUnsigned_25_25_29_29_11_15}},
+	{XVTSTDCSP, 0xfc0007b800000000, 0xf00006a800000000, 0x0, // VSX Vector Test Data Class Single-Precision XX2-form (xvtstdcsp XT,XB,DCMX)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20, ap_ImmUnsigned_25_25_29_29_11_15}},
+	{XVXEXPDP, 0xfc1f07fc00000000, 0xf000076c00000000, 0x0, // VSX Vector Extract Exponent Double-Precision XX2-form (xvxexpdp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVXEXPSP, 0xfc1f07fc00000000, 0xf008076c00000000, 0x0, // VSX Vector Extract Exponent Single-Precision XX2-form (xvxexpsp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVXSIGDP, 0xfc1f07fc00000000, 0xf001076c00000000, 0x0, // VSX Vector Extract Significand Double-Precision XX2-form (xvxsigdp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVXSIGSP, 0xfc1f07fc00000000, 0xf009076c00000000, 0x0, // VSX Vector Extract Significand Single-Precision XX2-form (xvxsigsp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XXBRD, 0xfc1f07fc00000000, 0xf017076c00000000, 0x0, // VSX Vector Byte-Reverse Doubleword XX2-form (xxbrd XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XXBRH, 0xfc1f07fc00000000, 0xf007076c00000000, 0x0, // VSX Vector Byte-Reverse Halfword XX2-form (xxbrh XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XXBRQ, 0xfc1f07fc00000000, 0xf01f076c00000000, 0x0, // VSX Vector Byte-Reverse Quadword XX2-form (xxbrq XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XXBRW, 0xfc1f07fc00000000, 0xf00f076c00000000, 0x0, // VSX Vector Byte-Reverse Word XX2-form (xxbrw XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XXEXTRACTUW, 0xfc0007fc00000000, 0xf000029400000000, 0x10000000000000, // VSX Vector Extract Unsigned Word XX2-form (xxextractuw XT,XB,UIM)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20, ap_ImmUnsigned_12_15}},
+	{XXINSERTW, 0xfc0007fc00000000, 0xf00002d400000000, 0x10000000000000, // VSX Vector Insert Word XX2-form (xxinsertw XT,XB,UIM)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20, ap_ImmUnsigned_12_15}},
+	{XXPERM, 0xfc0007f800000000, 0xf00000d000000000, 0x0, // VSX Vector Permute XX3-form (xxperm XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XXPERMR, 0xfc0007f800000000, 0xf00001d000000000, 0x0, // VSX Vector Permute Right-indexed XX3-form (xxpermr XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XXSPLTIB, 0xfc1807fe00000000, 0xf00002d000000000, 0x0, // VSX Vector Splat Immediate Byte X-form (xxspltib XT,IMM8)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_ImmUnsigned_13_20}},
+	{BCDADDCC, 0xfc0005ff00000000, 0x1000040100000000, 0x0, // Decimal Add Modulo VX-form (bcdadd. VRT,VRA,VRB,PS)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_ImmUnsigned_22_22}},
+	{BCDSUBCC, 0xfc0005ff00000000, 0x1000044100000000, 0x0, // Decimal Subtract Modulo VX-form (bcdsub. VRT,VRA,VRB,PS)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_ImmUnsigned_22_22}},
+	{BCTAR, 0xfc0007ff00000000, 0x4c00046000000000, 0xe00000000000, // Branch Conditional to Branch Target Address Register XL-form (bctar BO,BI,BH)
+		[6]*argField{ap_ImmUnsigned_6_10, ap_CondRegBit_11_15, ap_ImmUnsigned_19_20}},
+	{BCTARL, 0xfc0007ff00000000, 0x4c00046100000000, 0xe00000000000, // Branch Conditional to Branch Target Address Register XL-form (bctarl BO,BI,BH)
+		[6]*argField{ap_ImmUnsigned_6_10, ap_CondRegBit_11_15, ap_ImmUnsigned_19_20}},
+	{CLRBHRB, 0xfc0007fe00000000, 0x7c00035c00000000, 0x3fff80100000000, // Clear BHRB X-form (clrbhrb)
+		[6]*argField{}},
+	{FMRGEW, 0xfc0007fe00000000, 0xfc00078c00000000, 0x100000000, // Floating Merge Even Word X-form (fmrgew FRT,FRA,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{FMRGOW, 0xfc0007fe00000000, 0xfc00068c00000000, 0x100000000, // Floating Merge Odd Word X-form (fmrgow FRT,FRA,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{ICBT, 0xfc0007fe00000000, 0x7c00002c00000000, 0x200000100000000, // Instruction Cache Block Touch X-form (icbt CT, RA, RB)
+		[6]*argField{ap_ImmUnsigned_7_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LQARX, 0xfc0007fe00000000, 0x7c00022800000000, 0x0, // Load Quadword And Reserve Indexed X-form (lqarx RTp,RA,RB,EH)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20, ap_ImmUnsigned_31_31}},
+	{LXSIWAX, 0xfc0007fe00000000, 0x7c00009800000000, 0x0, // Load VSX Scalar as Integer Word Algebraic Indexed X-form (lxsiwax XT,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LXSIWZX, 0xfc0007fe00000000, 0x7c00001800000000, 0x0, // Load VSX Scalar as Integer Word & Zero Indexed X-form (lxsiwzx XT,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LXSSPX, 0xfc0007fe00000000, 0x7c00041800000000, 0x0, // Load VSX Scalar Single-Precision Indexed X-form (lxsspx XT,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MFBHRBE, 0xfc0007fe00000000, 0x7c00025c00000000, 0x100000000, // Move From BHRB XFX-form (mfbhrbe RT,BHRBE)
+		[6]*argField{ap_Reg_6_10, ap_SpReg_11_20}},
+	{MFVSRD, 0xfc0007fe00000000, 0x7c00006600000000, 0xf80000000000, // Move From VSR Doubleword X-form (mfvsrd RA,XS)
+		[6]*argField{ap_Reg_11_15, ap_VecSReg_31_31_6_10}},
+	{MFVSRWZ, 0xfc0007fe00000000, 0x7c0000e600000000, 0xf80000000000, // Move From VSR Word and Zero X-form (mfvsrwz RA,XS)
+		[6]*argField{ap_Reg_11_15, ap_VecSReg_31_31_6_10}},
+	{MSGCLR, 0xfc0007fe00000000, 0x7c0001dc00000000, 0x3ff000100000000, // Message Clear X-form (msgclr RB)
+		[6]*argField{ap_Reg_16_20}},
+	{MSGCLRP, 0xfc0007fe00000000, 0x7c00015c00000000, 0x3ff000100000000, // Message Clear Privileged X-form (msgclrp RB)
+		[6]*argField{ap_Reg_16_20}},
+	{MSGSND, 0xfc0007fe00000000, 0x7c00019c00000000, 0x3ff000100000000, // Message Send X-form (msgsnd RB)
+		[6]*argField{ap_Reg_16_20}},
+	{MSGSNDP, 0xfc0007fe00000000, 0x7c00011c00000000, 0x3ff000100000000, // Message Send Privileged X-form (msgsndp RB)
+		[6]*argField{ap_Reg_16_20}},
+	{MTVSRD, 0xfc0007fe00000000, 0x7c00016600000000, 0xf80000000000, // Move To VSR Doubleword X-form (mtvsrd XT,RA)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15}},
+	{MTVSRWA, 0xfc0007fe00000000, 0x7c0001a600000000, 0xf80000000000, // Move To VSR Word Algebraic X-form (mtvsrwa XT,RA)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15}},
+	{MTVSRWZ, 0xfc0007fe00000000, 0x7c0001e600000000, 0xf80000000000, // Move To VSR Word and Zero X-form (mtvsrwz XT,RA)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15}},
+	{RFEBB, 0xfc0007fe00000000, 0x4c00012400000000, 0x3fff00100000000, // Return from Event Based Branch XL-form (rfebb S)
+		[6]*argField{ap_ImmUnsigned_20_20}},
+	{STQCXCC, 0xfc0007ff00000000, 0x7c00016d00000000, 0x0, // Store Quadword Conditional Indexed X-form (stqcx. RSp,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STXSIWX, 0xfc0007fe00000000, 0x7c00011800000000, 0x0, // Store VSX Scalar as Integer Word Indexed X-form (stxsiwx XS,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STXSSPX, 0xfc0007fe00000000, 0x7c00051800000000, 0x0, // Store VSX Scalar Single-Precision Indexed X-form (stxsspx XS,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{VADDCUQ, 0xfc0007ff00000000, 0x1000014000000000, 0x0, // Vector Add & write Carry Unsigned Quadword VX-form (vaddcuq VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VADDECUQ, 0xfc00003f00000000, 0x1000003d00000000, 0x0, // Vector Add Extended & write Carry Unsigned Quadword VA-form (vaddecuq VRT,VRA,VRB,VRC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
+	{VADDEUQM, 0xfc00003f00000000, 0x1000003c00000000, 0x0, // Vector Add Extended Unsigned Quadword Modulo VA-form (vaddeuqm VRT,VRA,VRB,VRC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
+	{VADDUDM, 0xfc0007ff00000000, 0x100000c000000000, 0x0, // Vector Add Unsigned Doubleword Modulo VX-form (vaddudm VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VADDUQM, 0xfc0007ff00000000, 0x1000010000000000, 0x0, // Vector Add Unsigned Quadword Modulo VX-form (vadduqm VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VBPERMQ, 0xfc0007ff00000000, 0x1000054c00000000, 0x0, // Vector Bit Permute Quadword VX-form (vbpermq VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCIPHER, 0xfc0007ff00000000, 0x1000050800000000, 0x0, // Vector AES Cipher VX-form (vcipher VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCIPHERLAST, 0xfc0007ff00000000, 0x1000050900000000, 0x0, // Vector AES Cipher Last VX-form (vcipherlast VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCLZB, 0xfc0007ff00000000, 0x1000070200000000, 0x1f000000000000, // Vector Count Leading Zeros Byte VX-form (vclzb VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VCLZD, 0xfc0007ff00000000, 0x100007c200000000, 0x1f000000000000, // Vector Count Leading Zeros Doubleword VX-form (vclzd VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VCLZH, 0xfc0007ff00000000, 0x1000074200000000, 0x1f000000000000, // Vector Count Leading Zeros Halfword VX-form (vclzh VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VCLZW, 0xfc0007ff00000000, 0x1000078200000000, 0x1f000000000000, // Vector Count Leading Zeros Word VX-form (vclzw VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VCMPEQUD, 0xfc0007ff00000000, 0x100000c700000000, 0x0, // Vector Compare Equal Unsigned Doubleword VC-form (vcmpequd VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPEQUDCC, 0xfc0007ff00000000, 0x100004c700000000, 0x0, // Vector Compare Equal Unsigned Doubleword VC-form (vcmpequd. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPGTSD, 0xfc0007ff00000000, 0x100003c700000000, 0x0, // Vector Compare Greater Than Signed Doubleword VC-form (vcmpgtsd VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPGTSDCC, 0xfc0007ff00000000, 0x100007c700000000, 0x0, // Vector Compare Greater Than Signed Doubleword VC-form (vcmpgtsd. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPGTUD, 0xfc0007ff00000000, 0x100002c700000000, 0x0, // Vector Compare Greater Than Unsigned Doubleword VC-form (vcmpgtud VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPGTUDCC, 0xfc0007ff00000000, 0x100006c700000000, 0x0, // Vector Compare Greater Than Unsigned Doubleword VC-form (vcmpgtud. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VEQV, 0xfc0007ff00000000, 0x1000068400000000, 0x0, // Vector Logical Equivalence VX-form (veqv VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VGBBD, 0xfc0007ff00000000, 0x1000050c00000000, 0x1f000000000000, // Vector Gather Bits by Bytes by Doubleword VX-form (vgbbd VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VMAXSD, 0xfc0007ff00000000, 0x100001c200000000, 0x0, // Vector Maximum Signed Doubleword VX-form (vmaxsd VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMAXUD, 0xfc0007ff00000000, 0x100000c200000000, 0x0, // Vector Maximum Unsigned Doubleword VX-form (vmaxud VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMINSD, 0xfc0007ff00000000, 0x100003c200000000, 0x0, // Vector Minimum Signed Doubleword VX-form (vminsd VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMINUD, 0xfc0007ff00000000, 0x100002c200000000, 0x0, // Vector Minimum Unsigned Doubleword VX-form (vminud VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMRGEW, 0xfc0007ff00000000, 0x1000078c00000000, 0x0, // Vector Merge Even Word VX-form (vmrgew VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMRGOW, 0xfc0007ff00000000, 0x1000068c00000000, 0x0, // Vector Merge Odd Word VX-form (vmrgow VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMULESW, 0xfc0007ff00000000, 0x1000038800000000, 0x0, // Vector Multiply Even Signed Word VX-form (vmulesw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMULEUW, 0xfc0007ff00000000, 0x1000028800000000, 0x0, // Vector Multiply Even Unsigned Word VX-form (vmuleuw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMULOSW, 0xfc0007ff00000000, 0x1000018800000000, 0x0, // Vector Multiply Odd Signed Word VX-form (vmulosw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMULOUW, 0xfc0007ff00000000, 0x1000008800000000, 0x0, // Vector Multiply Odd Unsigned Word VX-form (vmulouw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMULUWM, 0xfc0007ff00000000, 0x1000008900000000, 0x0, // Vector Multiply Unsigned Word Modulo VX-form (vmuluwm VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VNAND, 0xfc0007ff00000000, 0x1000058400000000, 0x0, // Vector Logical NAND VX-form (vnand VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VNCIPHER, 0xfc0007ff00000000, 0x1000054800000000, 0x0, // Vector AES Inverse Cipher VX-form (vncipher VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VNCIPHERLAST, 0xfc0007ff00000000, 0x1000054900000000, 0x0, // Vector AES Inverse Cipher Last VX-form (vncipherlast VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VORC, 0xfc0007ff00000000, 0x1000054400000000, 0x0, // Vector Logical OR with Complement VX-form (vorc VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VPERMXOR, 0xfc00003f00000000, 0x1000002d00000000, 0x0, // Vector Permute & Exclusive-OR VA-form (vpermxor VRT,VRA,VRB,VRC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
+	{VPKSDSS, 0xfc0007ff00000000, 0x100005ce00000000, 0x0, // Vector Pack Signed Doubleword Signed Saturate VX-form (vpksdss VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VPKSDUS, 0xfc0007ff00000000, 0x1000054e00000000, 0x0, // Vector Pack Signed Doubleword Unsigned Saturate VX-form (vpksdus VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VPKUDUM, 0xfc0007ff00000000, 0x1000044e00000000, 0x0, // Vector Pack Unsigned Doubleword Unsigned Modulo VX-form (vpkudum VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VPKUDUS, 0xfc0007ff00000000, 0x100004ce00000000, 0x0, // Vector Pack Unsigned Doubleword Unsigned Saturate VX-form (vpkudus VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VPMSUMB, 0xfc0007ff00000000, 0x1000040800000000, 0x0, // Vector Polynomial Multiply-Sum Byte VX-form (vpmsumb VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VPMSUMD, 0xfc0007ff00000000, 0x100004c800000000, 0x0, // Vector Polynomial Multiply-Sum Doubleword VX-form (vpmsumd VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VPMSUMH, 0xfc0007ff00000000, 0x1000044800000000, 0x0, // Vector Polynomial Multiply-Sum Halfword VX-form (vpmsumh VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VPMSUMW, 0xfc0007ff00000000, 0x1000048800000000, 0x0, // Vector Polynomial Multiply-Sum Word VX-form (vpmsumw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VPOPCNTB, 0xfc0007ff00000000, 0x1000070300000000, 0x1f000000000000, // Vector Population Count Byte VX-form (vpopcntb VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VPOPCNTD, 0xfc0007ff00000000, 0x100007c300000000, 0x1f000000000000, // Vector Population Count Doubleword VX-form (vpopcntd VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VPOPCNTH, 0xfc0007ff00000000, 0x1000074300000000, 0x1f000000000000, // Vector Population Count Halfword VX-form (vpopcnth VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VPOPCNTW, 0xfc0007ff00000000, 0x1000078300000000, 0x1f000000000000, // Vector Population Count Word VX-form (vpopcntw VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VRLD, 0xfc0007ff00000000, 0x100000c400000000, 0x0, // Vector Rotate Left Doubleword VX-form (vrld VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSBOX, 0xfc0007ff00000000, 0x100005c800000000, 0xf80000000000, // Vector AES SubBytes VX-form (vsbox VRT,VRA)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15}},
+	{VSHASIGMAD, 0xfc0007ff00000000, 0x100006c200000000, 0x0, // Vector SHA-512 Sigma Doubleword VX-form (vshasigmad VRT,VRA,ST,SIX)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_ImmUnsigned_16_16, ap_ImmUnsigned_17_20}},
+	{VSHASIGMAW, 0xfc0007ff00000000, 0x1000068200000000, 0x0, // Vector SHA-256 Sigma Word VX-form (vshasigmaw VRT,VRA,ST,SIX)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_ImmUnsigned_16_16, ap_ImmUnsigned_17_20}},
+	{VSLD, 0xfc0007ff00000000, 0x100005c400000000, 0x0, // Vector Shift Left Doubleword VX-form (vsld VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSRAD, 0xfc0007ff00000000, 0x100003c400000000, 0x0, // Vector Shift Right Algebraic Doubleword VX-form (vsrad VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSRD, 0xfc0007ff00000000, 0x100006c400000000, 0x0, // Vector Shift Right Doubleword VX-form (vsrd VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSUBCUQ, 0xfc0007ff00000000, 0x1000054000000000, 0x0, // Vector Subtract & write Carry-out Unsigned Quadword VX-form (vsubcuq VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSUBECUQ, 0xfc00003f00000000, 0x1000003f00000000, 0x0, // Vector Subtract Extended & write Carry-out Unsigned Quadword VA-form (vsubecuq VRT,VRA,VRB,VRC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
+	{VSUBEUQM, 0xfc00003f00000000, 0x1000003e00000000, 0x0, // Vector Subtract Extended Unsigned Quadword Modulo VA-form (vsubeuqm VRT,VRA,VRB,VRC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
+	{VSUBUDM, 0xfc0007ff00000000, 0x100004c000000000, 0x0, // Vector Subtract Unsigned Doubleword Modulo VX-form (vsubudm VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSUBUQM, 0xfc0007ff00000000, 0x1000050000000000, 0x0, // Vector Subtract Unsigned Quadword Modulo VX-form (vsubuqm VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VUPKHSW, 0xfc0007ff00000000, 0x1000064e00000000, 0x1f000000000000, // Vector Unpack High Signed Word VX-form (vupkhsw VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VUPKLSW, 0xfc0007ff00000000, 0x100006ce00000000, 0x1f000000000000, // Vector Unpack Low Signed Word VX-form (vupklsw VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{XSADDSP, 0xfc0007f800000000, 0xf000000000000000, 0x0, // VSX Scalar Add Single-Precision XX3-form (xsaddsp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSCVDPSPN, 0xfc0007fc00000000, 0xf000042c00000000, 0x1f000000000000, // VSX Scalar Convert Scalar Single-Precision to Vector Single-Precision format Non-signalling XX2-form (xscvdpspn XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSCVSPDPN, 0xfc0007fc00000000, 0xf000052c00000000, 0x1f000000000000, // VSX Scalar Convert Single-Precision to Double-Precision format Non-signalling XX2-form (xscvspdpn XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSCVSXDSP, 0xfc0007fc00000000, 0xf00004e000000000, 0x1f000000000000, // VSX Scalar Convert with round Signed Doubleword to Single-Precision format XX2-form (xscvsxdsp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSCVUXDSP, 0xfc0007fc00000000, 0xf00004a000000000, 0x1f000000000000, // VSX Scalar Convert with round Unsigned Doubleword to Single-Precision XX2-form (xscvuxdsp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSDIVSP, 0xfc0007f800000000, 0xf00000c000000000, 0x0, // VSX Scalar Divide Single-Precision XX3-form (xsdivsp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSMADDASP, 0xfc0007f800000000, 0xf000000800000000, 0x0, // VSX Scalar Multiply-Add Type-A Single-Precision XX3-form (xsmaddasp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSMADDMSP, 0xfc0007f800000000, 0xf000004800000000, 0x0, // VSX Scalar Multiply-Add Type-M Single-Precision XX3-form (xsmaddmsp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSMSUBASP, 0xfc0007f800000000, 0xf000008800000000, 0x0, // VSX Scalar Multiply-Subtract Type-A Single-Precision XX3-form (xsmsubasp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSMSUBMSP, 0xfc0007f800000000, 0xf00000c800000000, 0x0, // VSX Scalar Multiply-Subtract Type-M Single-Precision XX3-form (xsmsubmsp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSMULSP, 0xfc0007f800000000, 0xf000008000000000, 0x0, // VSX Scalar Multiply Single-Precision XX3-form (xsmulsp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSNMADDASP, 0xfc0007f800000000, 0xf000040800000000, 0x0, // VSX Scalar Negative Multiply-Add Type-A Single-Precision XX3-form (xsnmaddasp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSNMADDMSP, 0xfc0007f800000000, 0xf000044800000000, 0x0, // VSX Scalar Negative Multiply-Add Type-M Single-Precision XX3-form (xsnmaddmsp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSNMSUBASP, 0xfc0007f800000000, 0xf000048800000000, 0x0, // VSX Scalar Negative Multiply-Subtract Type-A Single-Precision XX3-form (xsnmsubasp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSNMSUBMSP, 0xfc0007f800000000, 0xf00004c800000000, 0x0, // VSX Scalar Negative Multiply-Subtract Type-M Single-Precision XX3-form (xsnmsubmsp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSRESP, 0xfc0007fc00000000, 0xf000006800000000, 0x1f000000000000, // VSX Scalar Reciprocal Estimate Single-Precision XX2-form (xsresp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSRSP, 0xfc0007fc00000000, 0xf000046400000000, 0x1f000000000000, // VSX Scalar Round to Single-Precision XX2-form (xsrsp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSRSQRTESP, 0xfc0007fc00000000, 0xf000002800000000, 0x1f000000000000, // VSX Scalar Reciprocal Square Root Estimate Single-Precision XX2-form (xsrsqrtesp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSSQRTSP, 0xfc0007fc00000000, 0xf000002c00000000, 0x1f000000000000, // VSX Scalar Square Root Single-Precision XX2-form (xssqrtsp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSSUBSP, 0xfc0007f800000000, 0xf000004000000000, 0x0, // VSX Scalar Subtract Single-Precision XX3-form (xssubsp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XXLEQV, 0xfc0007f800000000, 0xf00005d000000000, 0x0, // VSX Vector Logical Equivalence XX3-form (xxleqv XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XXLNAND, 0xfc0007f800000000, 0xf000059000000000, 0x0, // VSX Vector Logical NAND XX3-form (xxlnand XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XXLORC, 0xfc0007f800000000, 0xf000055000000000, 0x0, // VSX Vector Logical OR with Complement XX3-form (xxlorc XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{ADDG6S, 0xfc0003fe00000000, 0x7c00009400000000, 0x40100000000, // Add and Generate Sixes XO-form (addg6s RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{BPERMD, 0xfc0007fe00000000, 0x7c0001f800000000, 0x100000000, // Bit Permute Doubleword X-form (bpermd RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{CBCDTD, 0xfc0007fe00000000, 0x7c00027400000000, 0xf80100000000, // Convert Binary Coded Decimal To Declets X-form (cbcdtd RA, RS)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10}},
+	{CDTBCD, 0xfc0007fe00000000, 0x7c00023400000000, 0xf80100000000, // Convert Declets To Binary Coded Decimal X-form (cdtbcd RA, RS)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10}},
+	{DCFFIX, 0xfc0007ff00000000, 0xec00064400000000, 0x1f000000000000, // DFP Convert From Fixed X-form (dcffix FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DCFFIXCC, 0xfc0007ff00000000, 0xec00064500000000, 0x1f000000000000, // DFP Convert From Fixed X-form (dcffix. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DIVDE, 0xfc0007ff00000000, 0x7c00035200000000, 0x0, // Divide Doubleword Extended XO-form (divde RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVDECC, 0xfc0007ff00000000, 0x7c00035300000000, 0x0, // Divide Doubleword Extended XO-form (divde. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVDEO, 0xfc0007ff00000000, 0x7c00075200000000, 0x0, // Divide Doubleword Extended XO-form (divdeo RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVDEOCC, 0xfc0007ff00000000, 0x7c00075300000000, 0x0, // Divide Doubleword Extended XO-form (divdeo. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVDEU, 0xfc0007ff00000000, 0x7c00031200000000, 0x0, // Divide Doubleword Extended Unsigned XO-form (divdeu RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVDEUCC, 0xfc0007ff00000000, 0x7c00031300000000, 0x0, // Divide Doubleword Extended Unsigned XO-form (divdeu. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVDEUO, 0xfc0007ff00000000, 0x7c00071200000000, 0x0, // Divide Doubleword Extended Unsigned XO-form (divdeuo RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVDEUOCC, 0xfc0007ff00000000, 0x7c00071300000000, 0x0, // Divide Doubleword Extended Unsigned XO-form (divdeuo. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVWE, 0xfc0007ff00000000, 0x7c00035600000000, 0x0, // Divide Word Extended XO-form (divwe RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVWECC, 0xfc0007ff00000000, 0x7c00035700000000, 0x0, // Divide Word Extended XO-form (divwe. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVWEO, 0xfc0007ff00000000, 0x7c00075600000000, 0x0, // Divide Word Extended XO-form (divweo RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVWEOCC, 0xfc0007ff00000000, 0x7c00075700000000, 0x0, // Divide Word Extended XO-form (divweo. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVWEU, 0xfc0007ff00000000, 0x7c00031600000000, 0x0, // Divide Word Extended Unsigned XO-form (divweu RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVWEUCC, 0xfc0007ff00000000, 0x7c00031700000000, 0x0, // Divide Word Extended Unsigned XO-form (divweu. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVWEUO, 0xfc0007ff00000000, 0x7c00071600000000, 0x0, // Divide Word Extended Unsigned XO-form (divweuo RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVWEUOCC, 0xfc0007ff00000000, 0x7c00071700000000, 0x0, // Divide Word Extended Unsigned XO-form (divweuo. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{FCFIDS, 0xfc0007ff00000000, 0xec00069c00000000, 0x1f000000000000, // Floating Convert with round Signed Doubleword to Single-Precision format X-form (fcfids FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FCFIDSCC, 0xfc0007ff00000000, 0xec00069d00000000, 0x1f000000000000, // Floating Convert with round Signed Doubleword to Single-Precision format X-form (fcfids. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FCFIDU, 0xfc0007ff00000000, 0xfc00079c00000000, 0x1f000000000000, // Floating Convert with round Unsigned Doubleword to Double-Precision format X-form (fcfidu FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FCFIDUCC, 0xfc0007ff00000000, 0xfc00079d00000000, 0x1f000000000000, // Floating Convert with round Unsigned Doubleword to Double-Precision format X-form (fcfidu. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FCFIDUS, 0xfc0007ff00000000, 0xec00079c00000000, 0x1f000000000000, // Floating Convert with round Unsigned Doubleword to Single-Precision format X-form (fcfidus FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FCFIDUSCC, 0xfc0007ff00000000, 0xec00079d00000000, 0x1f000000000000, // Floating Convert with round Unsigned Doubleword to Single-Precision format X-form (fcfidus. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FCTIDU, 0xfc0007ff00000000, 0xfc00075c00000000, 0x1f000000000000, // Floating Convert with round Double-Precision To Unsigned Doubleword format X-form (fctidu FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FCTIDUCC, 0xfc0007ff00000000, 0xfc00075d00000000, 0x1f000000000000, // Floating Convert with round Double-Precision To Unsigned Doubleword format X-form (fctidu. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FCTIDUZ, 0xfc0007ff00000000, 0xfc00075e00000000, 0x1f000000000000, // Floating Convert with truncate Double-Precision To Unsigned Doubleword format X-form (fctiduz FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FCTIDUZCC, 0xfc0007ff00000000, 0xfc00075f00000000, 0x1f000000000000, // Floating Convert with truncate Double-Precision To Unsigned Doubleword format X-form (fctiduz. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FCTIWU, 0xfc0007ff00000000, 0xfc00011c00000000, 0x1f000000000000, // Floating Convert with round Double-Precision To Unsigned Word format X-form (fctiwu FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FCTIWUCC, 0xfc0007ff00000000, 0xfc00011d00000000, 0x1f000000000000, // Floating Convert with round Double-Precision To Unsigned Word format X-form (fctiwu. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FCTIWUZ, 0xfc0007ff00000000, 0xfc00011e00000000, 0x1f000000000000, // Floating Convert with truncate Double-Precision To Unsigned Word format X-form (fctiwuz FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FCTIWUZCC, 0xfc0007ff00000000, 0xfc00011f00000000, 0x1f000000000000, // Floating Convert with truncate Double-Precision To Unsigned Word format X-form (fctiwuz. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FTDIV, 0xfc0007fe00000000, 0xfc00010000000000, 0x60000100000000, // Floating Test for software Divide X-form (ftdiv BF,FRA,FRB)
+		[6]*argField{ap_CondRegField_6_8, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{FTSQRT, 0xfc0007fe00000000, 0xfc00014000000000, 0x7f000100000000, // Floating Test for software Square Root X-form (ftsqrt BF,FRB)
+		[6]*argField{ap_CondRegField_6_8, ap_FPReg_16_20}},
+	{LBARX, 0xfc0007fe00000000, 0x7c00006800000000, 0x0, // Load Byte And Reserve Indexed X-form (lbarx RT,RA,RB,EH)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20, ap_ImmUnsigned_31_31}},
+	{LDBRX, 0xfc0007fe00000000, 0x7c00042800000000, 0x100000000, // Load Doubleword Byte-Reverse Indexed X-form (ldbrx RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LFIWZX, 0xfc0007fe00000000, 0x7c0006ee00000000, 0x100000000, // Load Floating-Point as Integer Word & Zero Indexed X-form (lfiwzx FRT,RA,RB)
+		[6]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LHARX, 0xfc0007fe00000000, 0x7c0000e800000000, 0x0, // Load Halfword And Reserve Indexed Xform (lharx RT,RA,RB,EH)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20, ap_ImmUnsigned_31_31}},
+	{LXSDX, 0xfc0007fe00000000, 0x7c00049800000000, 0x0, // Load VSX Scalar Doubleword Indexed X-form (lxsdx XT,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LXVD2X, 0xfc0007fe00000000, 0x7c00069800000000, 0x0, // Load VSX Vector Doubleword*2 Indexed X-form (lxvd2x XT,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LXVDSX, 0xfc0007fe00000000, 0x7c00029800000000, 0x0, // Load VSX Vector Doubleword & Splat Indexed X-form (lxvdsx XT,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LXVW4X, 0xfc0007fe00000000, 0x7c00061800000000, 0x0, // Load VSX Vector Word*4 Indexed X-form (lxvw4x XT,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{POPCNTD, 0xfc0007fe00000000, 0x7c0003f400000000, 0xf80100000000, // Population Count Doubleword X-form (popcntd RA, RS)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10}},
+	{POPCNTW, 0xfc0007fe00000000, 0x7c0002f400000000, 0xf80100000000, // Population Count Words X-form (popcntw RA, RS)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10}},
+	{STBCXCC, 0xfc0007ff00000000, 0x7c00056d00000000, 0x0, // Store Byte Conditional Indexed X-form (stbcx. RS,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STDBRX, 0xfc0007fe00000000, 0x7c00052800000000, 0x100000000, // Store Doubleword Byte-Reverse Indexed X-form (stdbrx RS,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STHCXCC, 0xfc0007ff00000000, 0x7c0005ad00000000, 0x0, // Store Halfword Conditional Indexed X-form (sthcx. RS,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STXSDX, 0xfc0007fe00000000, 0x7c00059800000000, 0x0, // Store VSX Scalar Doubleword Indexed X-form (stxsdx XS,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STXVD2X, 0xfc0007fe00000000, 0x7c00079800000000, 0x0, // Store VSX Vector Doubleword*2 Indexed X-form (stxvd2x XS,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STXVW4X, 0xfc0007fe00000000, 0x7c00071800000000, 0x0, // Store VSX Vector Word*4 Indexed X-form (stxvw4x XS,RA,RB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{XSABSDP, 0xfc0007fc00000000, 0xf000056400000000, 0x1f000000000000, // VSX Scalar Absolute Double-Precision XX2-form (xsabsdp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSADDDP, 0xfc0007f800000000, 0xf000010000000000, 0x0, // VSX Scalar Add Double-Precision XX3-form (xsadddp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSCMPODP, 0xfc0007f800000000, 0xf000015800000000, 0x60000100000000, // VSX Scalar Compare Ordered Double-Precision XX3-form (xscmpodp BF,XA,XB)
+		[6]*argField{ap_CondRegField_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSCMPUDP, 0xfc0007f800000000, 0xf000011800000000, 0x60000100000000, // VSX Scalar Compare Unordered Double-Precision XX3-form (xscmpudp BF,XA,XB)
+		[6]*argField{ap_CondRegField_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSCPSGNDP, 0xfc0007f800000000, 0xf000058000000000, 0x0, // VSX Scalar Copy Sign Double-Precision XX3-form (xscpsgndp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSCVDPSP, 0xfc0007fc00000000, 0xf000042400000000, 0x1f000000000000, // VSX Scalar Convert with round Double-Precision to Single-Precision format XX2-form (xscvdpsp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSCVDPSXDS, 0xfc0007fc00000000, 0xf000056000000000, 0x1f000000000000, // VSX Scalar Convert with round to zero Double-Precision to Signed Doubleword format XX2-form (xscvdpsxds XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSCVDPSXWS, 0xfc0007fc00000000, 0xf000016000000000, 0x1f000000000000, // VSX Scalar Convert with round to zero Double-Precision to Signed Word format XX2-form (xscvdpsxws XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSCVDPUXDS, 0xfc0007fc00000000, 0xf000052000000000, 0x1f000000000000, // VSX Scalar Convert with round to zero Double-Precision to Unsigned Doubleword format XX2-form (xscvdpuxds XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSCVDPUXWS, 0xfc0007fc00000000, 0xf000012000000000, 0x1f000000000000, // VSX Scalar Convert with round to zero Double-Precision to Unsigned Word format XX2-form (xscvdpuxws XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSCVSPDP, 0xfc0007fc00000000, 0xf000052400000000, 0x1f000000000000, // VSX Scalar Convert Single-Precision to Double-Precision format XX2-form (xscvspdp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSCVSXDDP, 0xfc0007fc00000000, 0xf00005e000000000, 0x1f000000000000, // VSX Scalar Convert with round Signed Doubleword to Double-Precision format XX2-form (xscvsxddp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSCVUXDDP, 0xfc0007fc00000000, 0xf00005a000000000, 0x1f000000000000, // VSX Scalar Convert with round Unsigned Doubleword to Double-Precision format XX2-form (xscvuxddp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSDIVDP, 0xfc0007f800000000, 0xf00001c000000000, 0x0, // VSX Scalar Divide Double-Precision XX3-form (xsdivdp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSMADDADP, 0xfc0007f800000000, 0xf000010800000000, 0x0, // VSX Scalar Multiply-Add Type-A Double-Precision XX3-form (xsmaddadp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSMADDMDP, 0xfc0007f800000000, 0xf000014800000000, 0x0, // VSX Scalar Multiply-Add Type-M Double-Precision XX3-form (xsmaddmdp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSMAXDP, 0xfc0007f800000000, 0xf000050000000000, 0x0, // VSX Scalar Maximum Double-Precision XX3-form (xsmaxdp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSMINDP, 0xfc0007f800000000, 0xf000054000000000, 0x0, // VSX Scalar Minimum Double-Precision XX3-form (xsmindp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSMSUBADP, 0xfc0007f800000000, 0xf000018800000000, 0x0, // VSX Scalar Multiply-Subtract Type-A Double-Precision XX3-form (xsmsubadp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSMSUBMDP, 0xfc0007f800000000, 0xf00001c800000000, 0x0, // VSX Scalar Multiply-Subtract Type-M Double-Precision XX3-form (xsmsubmdp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSMULDP, 0xfc0007f800000000, 0xf000018000000000, 0x0, // VSX Scalar Multiply Double-Precision XX3-form (xsmuldp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSNABSDP, 0xfc0007fc00000000, 0xf00005a400000000, 0x1f000000000000, // VSX Scalar Negative Absolute Double-Precision XX2-form (xsnabsdp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSNEGDP, 0xfc0007fc00000000, 0xf00005e400000000, 0x1f000000000000, // VSX Scalar Negate Double-Precision XX2-form (xsnegdp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSNMADDADP, 0xfc0007f800000000, 0xf000050800000000, 0x0, // VSX Scalar Negative Multiply-Add Type-A Double-Precision XX3-form (xsnmaddadp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSNMADDMDP, 0xfc0007f800000000, 0xf000054800000000, 0x0, // VSX Scalar Negative Multiply-Add Type-M Double-Precision XX3-form (xsnmaddmdp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSNMSUBADP, 0xfc0007f800000000, 0xf000058800000000, 0x0, // VSX Scalar Negative Multiply-Subtract Type-A Double-Precision XX3-form (xsnmsubadp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSNMSUBMDP, 0xfc0007f800000000, 0xf00005c800000000, 0x0, // VSX Scalar Negative Multiply-Subtract Type-M Double-Precision XX3-form (xsnmsubmdp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSRDPI, 0xfc0007fc00000000, 0xf000012400000000, 0x1f000000000000, // VSX Scalar Round to Double-Precision Integer using round to Nearest Away XX2-form (xsrdpi XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSRDPIC, 0xfc0007fc00000000, 0xf00001ac00000000, 0x1f000000000000, // VSX Scalar Round to Double-Precision Integer exact using Current rounding mode XX2-form (xsrdpic XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSRDPIM, 0xfc0007fc00000000, 0xf00001e400000000, 0x1f000000000000, // VSX Scalar Round to Double-Precision Integer using round toward -Infinity XX2-form (xsrdpim XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSRDPIP, 0xfc0007fc00000000, 0xf00001a400000000, 0x1f000000000000, // VSX Scalar Round to Double-Precision Integer using round toward +Infinity XX2-form (xsrdpip XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSRDPIZ, 0xfc0007fc00000000, 0xf000016400000000, 0x1f000000000000, // VSX Scalar Round to Double-Precision Integer using round toward Zero XX2-form (xsrdpiz XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSREDP, 0xfc0007fc00000000, 0xf000016800000000, 0x1f000000000000, // VSX Scalar Reciprocal Estimate Double-Precision XX2-form (xsredp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSRSQRTEDP, 0xfc0007fc00000000, 0xf000012800000000, 0x1f000000000000, // VSX Scalar Reciprocal Square Root Estimate Double-Precision XX2-form (xsrsqrtedp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSSQRTDP, 0xfc0007fc00000000, 0xf000012c00000000, 0x1f000000000000, // VSX Scalar Square Root Double-Precision XX2-form (xssqrtdp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XSSUBDP, 0xfc0007f800000000, 0xf000014000000000, 0x0, // VSX Scalar Subtract Double-Precision XX3-form (xssubdp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSTDIVDP, 0xfc0007f800000000, 0xf00001e800000000, 0x60000100000000, // VSX Scalar Test for software Divide Double-Precision XX3-form (xstdivdp BF,XA,XB)
+		[6]*argField{ap_CondRegField_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XSTSQRTDP, 0xfc0007fc00000000, 0xf00001a800000000, 0x7f000100000000, // VSX Scalar Test for software Square Root Double-Precision XX2-form (xstsqrtdp BF,XB)
+		[6]*argField{ap_CondRegField_6_8, ap_VecSReg_30_30_16_20}},
+	{XVABSDP, 0xfc0007fc00000000, 0xf000076400000000, 0x1f000000000000, // VSX Vector Absolute Value Double-Precision XX2-form (xvabsdp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVABSSP, 0xfc0007fc00000000, 0xf000066400000000, 0x1f000000000000, // VSX Vector Absolute Value Single-Precision XX2-form (xvabssp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVADDDP, 0xfc0007f800000000, 0xf000030000000000, 0x0, // VSX Vector Add Double-Precision XX3-form (xvadddp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVADDSP, 0xfc0007f800000000, 0xf000020000000000, 0x0, // VSX Vector Add Single-Precision XX3-form (xvaddsp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVCMPEQDP, 0xfc0007f800000000, 0xf000031800000000, 0x0, // VSX Vector Compare Equal To Double-Precision XX3-form (xvcmpeqdp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVCMPEQDPCC, 0xfc0007f800000000, 0xf000071800000000, 0x0, // VSX Vector Compare Equal To Double-Precision XX3-form (xvcmpeqdp. XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVCMPEQSP, 0xfc0007f800000000, 0xf000021800000000, 0x0, // VSX Vector Compare Equal To Single-Precision XX3-form (xvcmpeqsp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVCMPEQSPCC, 0xfc0007f800000000, 0xf000061800000000, 0x0, // VSX Vector Compare Equal To Single-Precision XX3-form (xvcmpeqsp. XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVCMPGEDP, 0xfc0007f800000000, 0xf000039800000000, 0x0, // VSX Vector Compare Greater Than or Equal To Double-Precision XX3-form (xvcmpgedp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVCMPGEDPCC, 0xfc0007f800000000, 0xf000079800000000, 0x0, // VSX Vector Compare Greater Than or Equal To Double-Precision XX3-form (xvcmpgedp. XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVCMPGESP, 0xfc0007f800000000, 0xf000029800000000, 0x0, // VSX Vector Compare Greater Than or Equal To Single-Precision XX3-form (xvcmpgesp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVCMPGESPCC, 0xfc0007f800000000, 0xf000069800000000, 0x0, // VSX Vector Compare Greater Than or Equal To Single-Precision XX3-form (xvcmpgesp. XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVCMPGTDP, 0xfc0007f800000000, 0xf000035800000000, 0x0, // VSX Vector Compare Greater Than Double-Precision XX3-form (xvcmpgtdp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVCMPGTDPCC, 0xfc0007f800000000, 0xf000075800000000, 0x0, // VSX Vector Compare Greater Than Double-Precision XX3-form (xvcmpgtdp. XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVCMPGTSP, 0xfc0007f800000000, 0xf000025800000000, 0x0, // VSX Vector Compare Greater Than Single-Precision XX3-form (xvcmpgtsp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVCMPGTSPCC, 0xfc0007f800000000, 0xf000065800000000, 0x0, // VSX Vector Compare Greater Than Single-Precision XX3-form (xvcmpgtsp. XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVCPSGNDP, 0xfc0007f800000000, 0xf000078000000000, 0x0, // VSX Vector Copy Sign Double-Precision XX3-form (xvcpsgndp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVCPSGNSP, 0xfc0007f800000000, 0xf000068000000000, 0x0, // VSX Vector Copy Sign Single-Precision XX3-form (xvcpsgnsp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVCVDPSP, 0xfc0007fc00000000, 0xf000062400000000, 0x1f000000000000, // VSX Vector Convert with round Double-Precision to Single-Precision format XX2-form (xvcvdpsp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVCVDPSXDS, 0xfc0007fc00000000, 0xf000076000000000, 0x1f000000000000, // VSX Vector Convert with round to zero Double-Precision to Signed Doubleword format XX2-form (xvcvdpsxds XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVCVDPSXWS, 0xfc0007fc00000000, 0xf000036000000000, 0x1f000000000000, // VSX Vector Convert with round to zero Double-Precision to Signed Word format XX2-form (xvcvdpsxws XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVCVDPUXDS, 0xfc0007fc00000000, 0xf000072000000000, 0x1f000000000000, // VSX Vector Convert with round to zero Double-Precision to Unsigned Doubleword format XX2-form (xvcvdpuxds XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVCVDPUXWS, 0xfc0007fc00000000, 0xf000032000000000, 0x1f000000000000, // VSX Vector Convert with round to zero Double-Precision to Unsigned Word format XX2-form (xvcvdpuxws XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVCVSPDP, 0xfc0007fc00000000, 0xf000072400000000, 0x1f000000000000, // VSX Vector Convert Single-Precision to Double-Precision format XX2-form (xvcvspdp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVCVSPSXDS, 0xfc0007fc00000000, 0xf000066000000000, 0x1f000000000000, // VSX Vector Convert with round to zero Single-Precision to Signed Doubleword format XX2-form (xvcvspsxds XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVCVSPSXWS, 0xfc0007fc00000000, 0xf000026000000000, 0x1f000000000000, // VSX Vector Convert with round to zero Single-Precision to Signed Word format XX2-form (xvcvspsxws XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVCVSPUXDS, 0xfc0007fc00000000, 0xf000062000000000, 0x1f000000000000, // VSX Vector Convert with round to zero Single-Precision to Unsigned Doubleword format XX2-form (xvcvspuxds XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVCVSPUXWS, 0xfc0007fc00000000, 0xf000022000000000, 0x1f000000000000, // VSX Vector Convert with round to zero Single-Precision to Unsigned Word format XX2-form (xvcvspuxws XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVCVSXDDP, 0xfc0007fc00000000, 0xf00007e000000000, 0x1f000000000000, // VSX Vector Convert with round Signed Doubleword to Double-Precision format XX2-form (xvcvsxddp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVCVSXDSP, 0xfc0007fc00000000, 0xf00006e000000000, 0x1f000000000000, // VSX Vector Convert with round Signed Doubleword to Single-Precision format XX2-form (xvcvsxdsp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVCVSXWDP, 0xfc0007fc00000000, 0xf00003e000000000, 0x1f000000000000, // VSX Vector Convert Signed Word to Double-Precision format XX2-form (xvcvsxwdp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVCVSXWSP, 0xfc0007fc00000000, 0xf00002e000000000, 0x1f000000000000, // VSX Vector Convert with round Signed Word to Single-Precision format XX2-form (xvcvsxwsp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVCVUXDDP, 0xfc0007fc00000000, 0xf00007a000000000, 0x1f000000000000, // VSX Vector Convert with round Unsigned Doubleword to Double-Precision format XX2-form (xvcvuxddp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVCVUXDSP, 0xfc0007fc00000000, 0xf00006a000000000, 0x1f000000000000, // VSX Vector Convert with round Unsigned Doubleword to Single-Precision format XX2-form (xvcvuxdsp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVCVUXWDP, 0xfc0007fc00000000, 0xf00003a000000000, 0x1f000000000000, // VSX Vector Convert Unsigned Word to Double-Precision format XX2-form (xvcvuxwdp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVCVUXWSP, 0xfc0007fc00000000, 0xf00002a000000000, 0x1f000000000000, // VSX Vector Convert with round Unsigned Word to Single-Precision format XX2-form (xvcvuxwsp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVDIVDP, 0xfc0007f800000000, 0xf00003c000000000, 0x0, // VSX Vector Divide Double-Precision XX3-form (xvdivdp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVDIVSP, 0xfc0007f800000000, 0xf00002c000000000, 0x0, // VSX Vector Divide Single-Precision XX3-form (xvdivsp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVMADDADP, 0xfc0007f800000000, 0xf000030800000000, 0x0, // VSX Vector Multiply-Add Type-A Double-Precision XX3-form (xvmaddadp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVMADDASP, 0xfc0007f800000000, 0xf000020800000000, 0x0, // VSX Vector Multiply-Add Type-A Single-Precision XX3-form (xvmaddasp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVMADDMDP, 0xfc0007f800000000, 0xf000034800000000, 0x0, // VSX Vector Multiply-Add Type-M Double-Precision XX3-form (xvmaddmdp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVMADDMSP, 0xfc0007f800000000, 0xf000024800000000, 0x0, // VSX Vector Multiply-Add Type-M Single-Precision XX3-form (xvmaddmsp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVMAXDP, 0xfc0007f800000000, 0xf000070000000000, 0x0, // VSX Vector Maximum Double-Precision XX3-form (xvmaxdp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVMAXSP, 0xfc0007f800000000, 0xf000060000000000, 0x0, // VSX Vector Maximum Single-Precision XX3-form (xvmaxsp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVMINDP, 0xfc0007f800000000, 0xf000074000000000, 0x0, // VSX Vector Minimum Double-Precision XX3-form (xvmindp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVMINSP, 0xfc0007f800000000, 0xf000064000000000, 0x0, // VSX Vector Minimum Single-Precision XX3-form (xvminsp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVMSUBADP, 0xfc0007f800000000, 0xf000038800000000, 0x0, // VSX Vector Multiply-Subtract Type-A Double-Precision XX3-form (xvmsubadp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVMSUBASP, 0xfc0007f800000000, 0xf000028800000000, 0x0, // VSX Vector Multiply-Subtract Type-A Single-Precision XX3-form (xvmsubasp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVMSUBMDP, 0xfc0007f800000000, 0xf00003c800000000, 0x0, // VSX Vector Multiply-Subtract Type-M Double-Precision XX3-form (xvmsubmdp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVMSUBMSP, 0xfc0007f800000000, 0xf00002c800000000, 0x0, // VSX Vector Multiply-Subtract Type-M Single-Precision XX3-form (xvmsubmsp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVMULDP, 0xfc0007f800000000, 0xf000038000000000, 0x0, // VSX Vector Multiply Double-Precision XX3-form (xvmuldp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVMULSP, 0xfc0007f800000000, 0xf000028000000000, 0x0, // VSX Vector Multiply Single-Precision XX3-form (xvmulsp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVNABSDP, 0xfc0007fc00000000, 0xf00007a400000000, 0x1f000000000000, // VSX Vector Negative Absolute Double-Precision XX2-form (xvnabsdp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVNABSSP, 0xfc0007fc00000000, 0xf00006a400000000, 0x1f000000000000, // VSX Vector Negative Absolute Single-Precision XX2-form (xvnabssp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVNEGDP, 0xfc0007fc00000000, 0xf00007e400000000, 0x1f000000000000, // VSX Vector Negate Double-Precision XX2-form (xvnegdp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVNEGSP, 0xfc0007fc00000000, 0xf00006e400000000, 0x1f000000000000, // VSX Vector Negate Single-Precision XX2-form (xvnegsp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVNMADDADP, 0xfc0007f800000000, 0xf000070800000000, 0x0, // VSX Vector Negative Multiply-Add Type-A Double-Precision XX3-form (xvnmaddadp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVNMADDASP, 0xfc0007f800000000, 0xf000060800000000, 0x0, // VSX Vector Negative Multiply-Add Type-A Single-Precision XX3-form (xvnmaddasp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVNMADDMDP, 0xfc0007f800000000, 0xf000074800000000, 0x0, // VSX Vector Negative Multiply-Add Type-M Double-Precision XX3-form (xvnmaddmdp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVNMADDMSP, 0xfc0007f800000000, 0xf000064800000000, 0x0, // VSX Vector Negative Multiply-Add Type-M Single-Precision XX3-form (xvnmaddmsp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVNMSUBADP, 0xfc0007f800000000, 0xf000078800000000, 0x0, // VSX Vector Negative Multiply-Subtract Type-A Double-Precision XX3-form (xvnmsubadp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVNMSUBASP, 0xfc0007f800000000, 0xf000068800000000, 0x0, // VSX Vector Negative Multiply-Subtract Type-A Single-Precision XX3-form (xvnmsubasp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVNMSUBMDP, 0xfc0007f800000000, 0xf00007c800000000, 0x0, // VSX Vector Negative Multiply-Subtract Type-M Double-Precision XX3-form (xvnmsubmdp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVNMSUBMSP, 0xfc0007f800000000, 0xf00006c800000000, 0x0, // VSX Vector Negative Multiply-Subtract Type-M Single-Precision XX3-form (xvnmsubmsp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVRDPI, 0xfc0007fc00000000, 0xf000032400000000, 0x1f000000000000, // VSX Vector Round to Double-Precision Integer using round to Nearest Away XX2-form (xvrdpi XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVRDPIC, 0xfc0007fc00000000, 0xf00003ac00000000, 0x1f000000000000, // VSX Vector Round to Double-Precision Integer Exact using Current rounding mode XX2-form (xvrdpic XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVRDPIM, 0xfc0007fc00000000, 0xf00003e400000000, 0x1f000000000000, // VSX Vector Round to Double-Precision Integer using round toward -Infinity XX2-form (xvrdpim XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVRDPIP, 0xfc0007fc00000000, 0xf00003a400000000, 0x1f000000000000, // VSX Vector Round to Double-Precision Integer using round toward +Infinity XX2-form (xvrdpip XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVRDPIZ, 0xfc0007fc00000000, 0xf000036400000000, 0x1f000000000000, // VSX Vector Round to Double-Precision Integer using round toward Zero XX2-form (xvrdpiz XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVREDP, 0xfc0007fc00000000, 0xf000036800000000, 0x1f000000000000, // VSX Vector Reciprocal Estimate Double-Precision XX2-form (xvredp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVRESP, 0xfc0007fc00000000, 0xf000026800000000, 0x1f000000000000, // VSX Vector Reciprocal Estimate Single-Precision XX2-form (xvresp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVRSPI, 0xfc0007fc00000000, 0xf000022400000000, 0x1f000000000000, // VSX Vector Round to Single-Precision Integer using round to Nearest Away XX2-form (xvrspi XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVRSPIC, 0xfc0007fc00000000, 0xf00002ac00000000, 0x1f000000000000, // VSX Vector Round to Single-Precision Integer Exact using Current rounding mode XX2-form (xvrspic XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVRSPIM, 0xfc0007fc00000000, 0xf00002e400000000, 0x1f000000000000, // VSX Vector Round to Single-Precision Integer using round toward -Infinity XX2-form (xvrspim XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVRSPIP, 0xfc0007fc00000000, 0xf00002a400000000, 0x1f000000000000, // VSX Vector Round to Single-Precision Integer using round toward +Infinity XX2-form (xvrspip XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVRSPIZ, 0xfc0007fc00000000, 0xf000026400000000, 0x1f000000000000, // VSX Vector Round to Single-Precision Integer using round toward Zero XX2-form (xvrspiz XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVRSQRTEDP, 0xfc0007fc00000000, 0xf000032800000000, 0x1f000000000000, // VSX Vector Reciprocal Square Root Estimate Double-Precision XX2-form (xvrsqrtedp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVRSQRTESP, 0xfc0007fc00000000, 0xf000022800000000, 0x1f000000000000, // VSX Vector Reciprocal Square Root Estimate Single-Precision XX2-form (xvrsqrtesp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVSQRTDP, 0xfc0007fc00000000, 0xf000032c00000000, 0x1f000000000000, // VSX Vector Square Root Double-Precision XX2-form (xvsqrtdp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVSQRTSP, 0xfc0007fc00000000, 0xf000022c00000000, 0x1f000000000000, // VSX Vector Square Root Single-Precision XX2-form (xvsqrtsp XT,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20}},
+	{XVSUBDP, 0xfc0007f800000000, 0xf000034000000000, 0x0, // VSX Vector Subtract Double-Precision XX3-form (xvsubdp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVSUBSP, 0xfc0007f800000000, 0xf000024000000000, 0x0, // VSX Vector Subtract Single-Precision XX3-form (xvsubsp XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVTDIVDP, 0xfc0007f800000000, 0xf00003e800000000, 0x60000100000000, // VSX Vector Test for software Divide Double-Precision XX3-form (xvtdivdp BF,XA,XB)
+		[6]*argField{ap_CondRegField_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVTDIVSP, 0xfc0007f800000000, 0xf00002e800000000, 0x60000100000000, // VSX Vector Test for software Divide Single-Precision XX3-form (xvtdivsp BF,XA,XB)
+		[6]*argField{ap_CondRegField_6_8, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XVTSQRTDP, 0xfc0007fc00000000, 0xf00003a800000000, 0x7f000100000000, // VSX Vector Test for software Square Root Double-Precision XX2-form (xvtsqrtdp BF,XB)
+		[6]*argField{ap_CondRegField_6_8, ap_VecSReg_30_30_16_20}},
+	{XVTSQRTSP, 0xfc0007fc00000000, 0xf00002a800000000, 0x7f000100000000, // VSX Vector Test for software Square Root Single-Precision XX2-form (xvtsqrtsp BF,XB)
+		[6]*argField{ap_CondRegField_6_8, ap_VecSReg_30_30_16_20}},
+	{XXLAND, 0xfc0007f800000000, 0xf000041000000000, 0x0, // VSX Vector Logical AND XX3-form (xxland XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XXLANDC, 0xfc0007f800000000, 0xf000045000000000, 0x0, // VSX Vector Logical AND with Complement XX3-form (xxlandc XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XXLNOR, 0xfc0007f800000000, 0xf000051000000000, 0x0, // VSX Vector Logical NOR XX3-form (xxlnor XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XXLOR, 0xfc0007f800000000, 0xf000049000000000, 0x0, // VSX Vector Logical OR XX3-form (xxlor XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XXLXOR, 0xfc0007f800000000, 0xf00004d000000000, 0x0, // VSX Vector Logical XOR XX3-form (xxlxor XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XXMRGHW, 0xfc0007f800000000, 0xf000009000000000, 0x0, // VSX Vector Merge High Word XX3-form (xxmrghw XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XXMRGLW, 0xfc0007f800000000, 0xf000019000000000, 0x0, // VSX Vector Merge Low Word XX3-form (xxmrglw XT,XA,XB)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20}},
+	{XXPERMDI, 0xfc0004f800000000, 0xf000005000000000, 0x0, // VSX Vector Permute Doubleword Immediate XX3-form (xxpermdi XT,XA,XB,DM)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20, ap_ImmUnsigned_22_23}},
+	{XXSEL, 0xfc00003000000000, 0xf000003000000000, 0x0, // VSX Vector Select XX4-form (xxsel XT,XA,XB,XC)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20, ap_VecSReg_28_28_21_25}},
+	{XXSLDWI, 0xfc0004f800000000, 0xf000001000000000, 0x0, // VSX Vector Shift Left Double by Word Immediate XX3-form (xxsldwi XT,XA,XB,SHW)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_29_29_11_15, ap_VecSReg_30_30_16_20, ap_ImmUnsigned_22_23}},
+	{XXSPLTW, 0xfc0007fc00000000, 0xf000029000000000, 0x1c000000000000, // VSX Vector Splat Word XX2-form (xxspltw XT,XB,UIM)
+		[6]*argField{ap_VecSReg_31_31_6_10, ap_VecSReg_30_30_16_20, ap_ImmUnsigned_14_15}},
+	{CMPB, 0xfc0007fe00000000, 0x7c0003f800000000, 0x100000000, // Compare Bytes X-form (cmpb RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{DADD, 0xfc0007ff00000000, 0xec00000400000000, 0x0, // DFP Add X-form (dadd FRT,FRA,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DADDCC, 0xfc0007ff00000000, 0xec00000500000000, 0x0, // DFP Add X-form (dadd. FRT,FRA,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DADDQ, 0xfc0007ff00000000, 0xfc00000400000000, 0x0, // DFP Add Quad X-form (daddq FRTp,FRAp,FRBp)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DADDQCC, 0xfc0007ff00000000, 0xfc00000500000000, 0x0, // DFP Add Quad X-form (daddq. FRTp,FRAp,FRBp)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DCFFIXQ, 0xfc0007ff00000000, 0xfc00064400000000, 0x1f000000000000, // DFP Convert From Fixed Quad X-form (dcffixq FRTp,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DCFFIXQCC, 0xfc0007ff00000000, 0xfc00064500000000, 0x1f000000000000, // DFP Convert From Fixed Quad X-form (dcffixq. FRTp,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DCMPO, 0xfc0007fe00000000, 0xec00010400000000, 0x60000100000000, // DFP Compare Ordered X-form (dcmpo BF,FRA,FRB)
+		[6]*argField{ap_CondRegField_6_8, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DCMPOQ, 0xfc0007fe00000000, 0xfc00010400000000, 0x60000100000000, // DFP Compare Ordered Quad X-form (dcmpoq BF,FRAp,FRBp)
+		[6]*argField{ap_CondRegField_6_8, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DCMPU, 0xfc0007fe00000000, 0xec00050400000000, 0x60000100000000, // DFP Compare Unordered X-form (dcmpu BF,FRA,FRB)
+		[6]*argField{ap_CondRegField_6_8, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DCMPUQ, 0xfc0007fe00000000, 0xfc00050400000000, 0x60000100000000, // DFP Compare Unordered Quad X-form (dcmpuq BF,FRAp,FRBp)
+		[6]*argField{ap_CondRegField_6_8, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DCTDP, 0xfc0007ff00000000, 0xec00020400000000, 0x1f000000000000, // DFP Convert To DFP Long X-form (dctdp FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DCTDPCC, 0xfc0007ff00000000, 0xec00020500000000, 0x1f000000000000, // DFP Convert To DFP Long X-form (dctdp. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DCTFIX, 0xfc0007ff00000000, 0xec00024400000000, 0x1f000000000000, // DFP Convert To Fixed X-form (dctfix FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DCTFIXCC, 0xfc0007ff00000000, 0xec00024500000000, 0x1f000000000000, // DFP Convert To Fixed X-form (dctfix. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DCTFIXQ, 0xfc0007ff00000000, 0xfc00024400000000, 0x1f000000000000, // DFP Convert To Fixed Quad X-form (dctfixq FRT,FRBp)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DCTFIXQCC, 0xfc0007ff00000000, 0xfc00024500000000, 0x1f000000000000, // DFP Convert To Fixed Quad X-form (dctfixq. FRT,FRBp)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DCTQPQ, 0xfc0007ff00000000, 0xfc00020400000000, 0x1f000000000000, // DFP Convert To DFP Extended X-form (dctqpq FRTp,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DCTQPQCC, 0xfc0007ff00000000, 0xfc00020500000000, 0x1f000000000000, // DFP Convert To DFP Extended X-form (dctqpq. FRTp,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DDEDPD, 0xfc0007ff00000000, 0xec00028400000000, 0x7000000000000, // DFP Decode DPD To BCD X-form (ddedpd SP,FRT,FRB)
+		[6]*argField{ap_ImmUnsigned_11_12, ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DDEDPDCC, 0xfc0007ff00000000, 0xec00028500000000, 0x7000000000000, // DFP Decode DPD To BCD X-form (ddedpd. SP,FRT,FRB)
+		[6]*argField{ap_ImmUnsigned_11_12, ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DDEDPDQ, 0xfc0007ff00000000, 0xfc00028400000000, 0x7000000000000, // DFP Decode DPD To BCD Quad X-form (ddedpdq SP,FRTp,FRBp)
+		[6]*argField{ap_ImmUnsigned_11_12, ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DDEDPDQCC, 0xfc0007ff00000000, 0xfc00028500000000, 0x7000000000000, // DFP Decode DPD To BCD Quad X-form (ddedpdq. SP,FRTp,FRBp)
+		[6]*argField{ap_ImmUnsigned_11_12, ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DDIV, 0xfc0007ff00000000, 0xec00044400000000, 0x0, // DFP Divide X-form (ddiv FRT,FRA,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DDIVCC, 0xfc0007ff00000000, 0xec00044500000000, 0x0, // DFP Divide X-form (ddiv. FRT,FRA,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DDIVQ, 0xfc0007ff00000000, 0xfc00044400000000, 0x0, // DFP Divide Quad X-form (ddivq FRTp,FRAp,FRBp)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DDIVQCC, 0xfc0007ff00000000, 0xfc00044500000000, 0x0, // DFP Divide Quad X-form (ddivq. FRTp,FRAp,FRBp)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DENBCD, 0xfc0007ff00000000, 0xec00068400000000, 0xf000000000000, // DFP Encode BCD To DPD X-form (denbcd S,FRT,FRB)
+		[6]*argField{ap_ImmUnsigned_11_11, ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DENBCDCC, 0xfc0007ff00000000, 0xec00068500000000, 0xf000000000000, // DFP Encode BCD To DPD X-form (denbcd. S,FRT,FRB)
+		[6]*argField{ap_ImmUnsigned_11_11, ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DENBCDQ, 0xfc0007ff00000000, 0xfc00068400000000, 0xf000000000000, // DFP Encode BCD To DPD Quad X-form (denbcdq S,FRTp,FRBp)
+		[6]*argField{ap_ImmUnsigned_11_11, ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DENBCDQCC, 0xfc0007ff00000000, 0xfc00068500000000, 0xf000000000000, // DFP Encode BCD To DPD Quad X-form (denbcdq. S,FRTp,FRBp)
+		[6]*argField{ap_ImmUnsigned_11_11, ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DIEX, 0xfc0007ff00000000, 0xec0006c400000000, 0x0, // DFP Insert Biased Exponent X-form (diex FRT,FRA,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DIEXCC, 0xfc0007ff00000000, 0xec0006c500000000, 0x0, // DFP Insert Biased Exponent X-form (diex. FRT,FRA,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DIEXQCC, 0xfc0007ff00000000, 0xfc0006c500000000, 0x0, // DFP Insert Biased Exponent Quad X-form (diexq. FRTp,FRA,FRBp)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DIEXQ, 0xfc0007fe00000000, 0xfc0006c400000000, 0x0, // DFP Insert Biased Exponent Quad X-form (diexq FRTp,FRA,FRBp)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DMUL, 0xfc0007ff00000000, 0xec00004400000000, 0x0, // DFP Multiply X-form (dmul FRT,FRA,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DMULCC, 0xfc0007ff00000000, 0xec00004500000000, 0x0, // DFP Multiply X-form (dmul. FRT,FRA,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DMULQ, 0xfc0007ff00000000, 0xfc00004400000000, 0x0, // DFP Multiply Quad X-form (dmulq FRTp,FRAp,FRBp)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DMULQCC, 0xfc0007ff00000000, 0xfc00004500000000, 0x0, // DFP Multiply Quad X-form (dmulq. FRTp,FRAp,FRBp)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DQUA, 0xfc0001ff00000000, 0xec00000600000000, 0x0, // DFP Quantize Z23-form (dqua FRT,FRA,FRB,RMC)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
+	{DQUACC, 0xfc0001ff00000000, 0xec00000700000000, 0x0, // DFP Quantize Z23-form (dqua. FRT,FRA,FRB,RMC)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
+	{DQUAI, 0xfc0001ff00000000, 0xec00008600000000, 0x0, // DFP Quantize Immediate Z23-form (dquai TE,FRT,FRB,RMC)
+		[6]*argField{ap_ImmSigned_11_15, ap_FPReg_6_10, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
+	{DQUAICC, 0xfc0001ff00000000, 0xec00008700000000, 0x0, // DFP Quantize Immediate Z23-form (dquai. TE,FRT,FRB,RMC)
+		[6]*argField{ap_ImmSigned_11_15, ap_FPReg_6_10, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
+	{DQUAIQ, 0xfc0001ff00000000, 0xfc00008600000000, 0x0, // DFP Quantize Immediate Quad Z23-form (dquaiq TE,FRTp,FRBp,RMC)
+		[6]*argField{ap_ImmSigned_11_15, ap_FPReg_6_10, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
+	{DQUAIQCC, 0xfc0001ff00000000, 0xfc00008700000000, 0x0, // DFP Quantize Immediate Quad Z23-form (dquaiq. TE,FRTp,FRBp,RMC)
+		[6]*argField{ap_ImmSigned_11_15, ap_FPReg_6_10, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
+	{DQUAQ, 0xfc0001ff00000000, 0xfc00000600000000, 0x0, // DFP Quantize Quad Z23-form (dquaq FRTp,FRAp,FRBp,RMC)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
+	{DQUAQCC, 0xfc0001ff00000000, 0xfc00000700000000, 0x0, // DFP Quantize Quad Z23-form (dquaq. FRTp,FRAp,FRBp,RMC)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
+	{DRDPQ, 0xfc0007ff00000000, 0xfc00060400000000, 0x1f000000000000, // DFP Round To DFP Long X-form (drdpq FRTp,FRBp)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DRDPQCC, 0xfc0007ff00000000, 0xfc00060500000000, 0x1f000000000000, // DFP Round To DFP Long X-form (drdpq. FRTp,FRBp)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DRINTN, 0xfc0001ff00000000, 0xec0001c600000000, 0x1e000000000000, // DFP Round To FP Integer Without Inexact Z23-form (drintn R,FRT,FRB,RMC)
+		[6]*argField{ap_ImmUnsigned_15_15, ap_FPReg_6_10, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
+	{DRINTNCC, 0xfc0001ff00000000, 0xec0001c700000000, 0x1e000000000000, // DFP Round To FP Integer Without Inexact Z23-form (drintn. R,FRT,FRB,RMC)
+		[6]*argField{ap_ImmUnsigned_15_15, ap_FPReg_6_10, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
+	{DRINTNQ, 0xfc0001ff00000000, 0xfc0001c600000000, 0x1e000000000000, // DFP Round To FP Integer Without Inexact Quad Z23-form (drintnq R,FRTp,FRBp,RMC)
+		[6]*argField{ap_ImmUnsigned_15_15, ap_FPReg_6_10, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
+	{DRINTNQCC, 0xfc0001ff00000000, 0xfc0001c700000000, 0x1e000000000000, // DFP Round To FP Integer Without Inexact Quad Z23-form (drintnq. R,FRTp,FRBp,RMC)
+		[6]*argField{ap_ImmUnsigned_15_15, ap_FPReg_6_10, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
+	{DRINTX, 0xfc0001ff00000000, 0xec0000c600000000, 0x1e000000000000, // DFP Round To FP Integer With Inexact Z23-form (drintx R,FRT,FRB,RMC)
+		[6]*argField{ap_ImmUnsigned_15_15, ap_FPReg_6_10, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
+	{DRINTXCC, 0xfc0001ff00000000, 0xec0000c700000000, 0x1e000000000000, // DFP Round To FP Integer With Inexact Z23-form (drintx. R,FRT,FRB,RMC)
+		[6]*argField{ap_ImmUnsigned_15_15, ap_FPReg_6_10, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
+	{DRINTXQ, 0xfc0001ff00000000, 0xfc0000c600000000, 0x1e000000000000, // DFP Round To FP Integer With Inexact Quad Z23-form (drintxq R,FRTp,FRBp,RMC)
+		[6]*argField{ap_ImmUnsigned_15_15, ap_FPReg_6_10, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
+	{DRINTXQCC, 0xfc0001ff00000000, 0xfc0000c700000000, 0x1e000000000000, // DFP Round To FP Integer With Inexact Quad Z23-form (drintxq. R,FRTp,FRBp,RMC)
+		[6]*argField{ap_ImmUnsigned_15_15, ap_FPReg_6_10, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
+	{DRRND, 0xfc0001ff00000000, 0xec00004600000000, 0x0, // DFP Reround Z23-form (drrnd FRT,FRA,FRB,RMC)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
+	{DRRNDCC, 0xfc0001ff00000000, 0xec00004700000000, 0x0, // DFP Reround Z23-form (drrnd. FRT,FRA,FRB,RMC)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
+	{DRRNDQ, 0xfc0001ff00000000, 0xfc00004600000000, 0x0, // DFP Reround Quad Z23-form (drrndq FRTp,FRA,FRBp,RMC)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
+	{DRRNDQCC, 0xfc0001ff00000000, 0xfc00004700000000, 0x0, // DFP Reround Quad Z23-form (drrndq. FRTp,FRA,FRBp,RMC)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20, ap_ImmUnsigned_21_22}},
+	{DRSP, 0xfc0007ff00000000, 0xec00060400000000, 0x1f000000000000, // DFP Round To DFP Short X-form (drsp FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DRSPCC, 0xfc0007ff00000000, 0xec00060500000000, 0x1f000000000000, // DFP Round To DFP Short X-form (drsp. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DSCLI, 0xfc0003ff00000000, 0xec00008400000000, 0x0, // DFP Shift Significand Left Immediate Z22-form (dscli FRT,FRA,SH)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_ImmUnsigned_16_21}},
+	{DSCLICC, 0xfc0003ff00000000, 0xec00008500000000, 0x0, // DFP Shift Significand Left Immediate Z22-form (dscli. FRT,FRA,SH)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_ImmUnsigned_16_21}},
+	{DSCLIQ, 0xfc0003ff00000000, 0xfc00008400000000, 0x0, // DFP Shift Significand Left Immediate Quad Z22-form (dscliq FRTp,FRAp,SH)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_ImmUnsigned_16_21}},
+	{DSCLIQCC, 0xfc0003ff00000000, 0xfc00008500000000, 0x0, // DFP Shift Significand Left Immediate Quad Z22-form (dscliq. FRTp,FRAp,SH)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_ImmUnsigned_16_21}},
+	{DSCRI, 0xfc0003ff00000000, 0xec0000c400000000, 0x0, // DFP Shift Significand Right Immediate Z22-form (dscri FRT,FRA,SH)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_ImmUnsigned_16_21}},
+	{DSCRICC, 0xfc0003ff00000000, 0xec0000c500000000, 0x0, // DFP Shift Significand Right Immediate Z22-form (dscri. FRT,FRA,SH)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_ImmUnsigned_16_21}},
+	{DSCRIQ, 0xfc0003ff00000000, 0xfc0000c400000000, 0x0, // DFP Shift Significand Right Immediate Quad Z22-form (dscriq FRTp,FRAp,SH)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_ImmUnsigned_16_21}},
+	{DSCRIQCC, 0xfc0003ff00000000, 0xfc0000c500000000, 0x0, // DFP Shift Significand Right Immediate Quad Z22-form (dscriq. FRTp,FRAp,SH)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_ImmUnsigned_16_21}},
+	{DSUB, 0xfc0007ff00000000, 0xec00040400000000, 0x0, // DFP Subtract X-form (dsub FRT,FRA,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DSUBCC, 0xfc0007ff00000000, 0xec00040500000000, 0x0, // DFP Subtract X-form (dsub. FRT,FRA,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DSUBQ, 0xfc0007ff00000000, 0xfc00040400000000, 0x0, // DFP Subtract Quad X-form (dsubq FRTp,FRAp,FRBp)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DSUBQCC, 0xfc0007ff00000000, 0xfc00040500000000, 0x0, // DFP Subtract Quad X-form (dsubq. FRTp,FRAp,FRBp)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DTSTDC, 0xfc0003fe00000000, 0xec00018400000000, 0x60000100000000, // DFP Test Data Class Z22-form (dtstdc BF,FRA,DCM)
+		[6]*argField{ap_CondRegField_6_8, ap_FPReg_11_15, ap_ImmUnsigned_16_21}},
+	{DTSTDCQ, 0xfc0003fe00000000, 0xfc00018400000000, 0x60000100000000, // DFP Test Data Class Quad Z22-form (dtstdcq BF,FRAp,DCM)
+		[6]*argField{ap_CondRegField_6_8, ap_FPReg_11_15, ap_ImmUnsigned_16_21}},
+	{DTSTDG, 0xfc0003fe00000000, 0xec0001c400000000, 0x60000100000000, // DFP Test Data Group Z22-form (dtstdg BF,FRA,DGM)
+		[6]*argField{ap_CondRegField_6_8, ap_FPReg_11_15, ap_ImmUnsigned_16_21}},
+	{DTSTDGQ, 0xfc0003fe00000000, 0xfc0001c400000000, 0x60000100000000, // DFP Test Data Group Quad Z22-form (dtstdgq BF,FRAp,DGM)
+		[6]*argField{ap_CondRegField_6_8, ap_FPReg_11_15, ap_ImmUnsigned_16_21}},
+	{DTSTEX, 0xfc0007fe00000000, 0xec00014400000000, 0x60000100000000, // DFP Test Exponent X-form (dtstex BF,FRA,FRB)
+		[6]*argField{ap_CondRegField_6_8, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DTSTEXQ, 0xfc0007fe00000000, 0xfc00014400000000, 0x60000100000000, // DFP Test Exponent Quad X-form (dtstexq BF,FRAp,FRBp)
+		[6]*argField{ap_CondRegField_6_8, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DTSTSF, 0xfc0007fe00000000, 0xec00054400000000, 0x60000100000000, // DFP Test Significance X-form (dtstsf BF,FRA,FRB)
+		[6]*argField{ap_CondRegField_6_8, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DTSTSFQ, 0xfc0007fe00000000, 0xfc00054400000000, 0x60000100000000, // DFP Test Significance Quad X-form (dtstsfq BF,FRA,FRBp)
+		[6]*argField{ap_CondRegField_6_8, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{DXEX, 0xfc0007ff00000000, 0xec0002c400000000, 0x1f000000000000, // DFP Extract Biased Exponent X-form (dxex FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DXEXCC, 0xfc0007ff00000000, 0xec0002c500000000, 0x1f000000000000, // DFP Extract Biased Exponent X-form (dxex. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DXEXQ, 0xfc0007ff00000000, 0xfc0002c400000000, 0x1f000000000000, // DFP Extract Biased Exponent Quad X-form (dxexq FRT,FRBp)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{DXEXQCC, 0xfc0007ff00000000, 0xfc0002c500000000, 0x1f000000000000, // DFP Extract Biased Exponent Quad X-form (dxexq. FRT,FRBp)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FCPSGN, 0xfc0007ff00000000, 0xfc00001000000000, 0x0, // Floating Copy Sign X-form (fcpsgn FRT, FRA, FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{FCPSGNCC, 0xfc0007ff00000000, 0xfc00001100000000, 0x0, // Floating Copy Sign X-form (fcpsgn. FRT, FRA, FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{LBZCIX, 0xfc0007fe00000000, 0x7c0006aa00000000, 0x100000000, // Load Byte & Zero Caching Inhibited Indexed X-form (lbzcix RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LDCIX, 0xfc0007fe00000000, 0x7c0006ea00000000, 0x100000000, // Load Doubleword Caching Inhibited Indexed X-form (ldcix RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LFDP, 0xfc00000300000000, 0xe400000000000000, 0x0, // Load Floating-Point Double Pair DS-form (lfdp FRTp,DS(RA))
+		[6]*argField{ap_FPReg_6_10, ap_Offset_16_29_shift2, ap_Reg_11_15}},
+	{LFDPX, 0xfc0007fe00000000, 0x7c00062e00000000, 0x100000000, // Load Floating-Point Double Pair Indexed X-form (lfdpx FRTp,RA,RB)
+		[6]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LFIWAX, 0xfc0007fe00000000, 0x7c0006ae00000000, 0x100000000, // Load Floating-Point as Integer Word Algebraic Indexed X-form (lfiwax FRT,RA,RB)
+		[6]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LHZCIX, 0xfc0007fe00000000, 0x7c00066a00000000, 0x100000000, // Load Halfword & Zero Caching Inhibited Indexed X-form (lhzcix RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LWZCIX, 0xfc0007fe00000000, 0x7c00062a00000000, 0x100000000, // Load Word & Zero Caching Inhibited Indexed X-form (lwzcix RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{PRTYD, 0xfc0007fe00000000, 0x7c00017400000000, 0xf80100000000, // Parity Doubleword X-form (prtyd RA,RS)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10}},
+	{PRTYW, 0xfc0007fe00000000, 0x7c00013400000000, 0xf80100000000, // Parity Word X-form (prtyw RA,RS)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10}},
+	{SLBFEECC, 0xfc0007ff00000000, 0x7c0007a700000000, 0x1f000000000000, // SLB Find Entry ESID X-form (slbfee. RT,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_16_20}},
+	{STBCIX, 0xfc0007fe00000000, 0x7c0007aa00000000, 0x100000000, // Store Byte Caching Inhibited Indexed X-form (stbcix RS,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STDCIX, 0xfc0007fe00000000, 0x7c0007ea00000000, 0x100000000, // Store Doubleword Caching Inhibited Indexed X-form (stdcix RS,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STFDP, 0xfc00000300000000, 0xf400000000000000, 0x0, // Store Floating-Point Double Pair DS-form (stfdp FRSp,DS(RA))
+		[6]*argField{ap_FPReg_6_10, ap_Offset_16_29_shift2, ap_Reg_11_15}},
+	{STFDPX, 0xfc0007fe00000000, 0x7c00072e00000000, 0x100000000, // Store Floating-Point Double Pair Indexed X-form (stfdpx FRSp,RA,RB)
+		[6]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STHCIX, 0xfc0007fe00000000, 0x7c00076a00000000, 0x100000000, // Store Halfword Caching Inhibited Indexed X-form (sthcix RS,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STWCIX, 0xfc0007fe00000000, 0x7c00072a00000000, 0x100000000, // Store Word Caching Inhibited Indexed X-form (stwcix RS,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{ISEL, 0xfc00003e00000000, 0x7c00001e00000000, 0x100000000, // Integer Select A-form (isel RT,RA,RB,BC)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20, ap_CondRegBit_21_25}},
+	{LVEBX, 0xfc0007fe00000000, 0x7c00000e00000000, 0x100000000, // Load Vector Element Byte Indexed X-form (lvebx VRT,RA,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LVEHX, 0xfc0007fe00000000, 0x7c00004e00000000, 0x100000000, // Load Vector Element Halfword Indexed X-form (lvehx VRT,RA,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LVEWX, 0xfc0007fe00000000, 0x7c00008e00000000, 0x100000000, // Load Vector Element Word Indexed X-form (lvewx VRT,RA,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LVSL, 0xfc0007fe00000000, 0x7c00000c00000000, 0x100000000, // Load Vector for Shift Left Indexed X-form (lvsl VRT,RA,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LVSR, 0xfc0007fe00000000, 0x7c00004c00000000, 0x100000000, // Load Vector for Shift Right Indexed X-form (lvsr VRT,RA,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LVX, 0xfc0007fe00000000, 0x7c0000ce00000000, 0x100000000, // Load Vector Indexed X-form (lvx VRT,RA,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LVXL, 0xfc0007fe00000000, 0x7c0002ce00000000, 0x100000000, // Load Vector Indexed Last X-form (lvxl VRT,RA,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MFVSCR, 0xfc0007ff00000000, 0x1000060400000000, 0x1ff80000000000, // Move From Vector Status and Control Register VX-form (mfvscr VRT)
+		[6]*argField{ap_VecReg_6_10}},
+	{MTVSCR, 0xfc0007ff00000000, 0x1000064400000000, 0x3ff000000000000, // Move To Vector Status and Control Register VX-form (mtvscr VRB)
+		[6]*argField{ap_VecReg_16_20}},
+	{STVEBX, 0xfc0007fe00000000, 0x7c00010e00000000, 0x100000000, // Store Vector Element Byte Indexed X-form (stvebx VRS,RA,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STVEHX, 0xfc0007fe00000000, 0x7c00014e00000000, 0x100000000, // Store Vector Element Halfword Indexed X-form (stvehx VRS,RA,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STVEWX, 0xfc0007fe00000000, 0x7c00018e00000000, 0x100000000, // Store Vector Element Word Indexed X-form (stvewx VRS,RA,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STVX, 0xfc0007fe00000000, 0x7c0001ce00000000, 0x100000000, // Store Vector Indexed X-form (stvx VRS,RA,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STVXL, 0xfc0007fe00000000, 0x7c0003ce00000000, 0x100000000, // Store Vector Indexed Last X-form (stvxl VRS,RA,RB)
+		[6]*argField{ap_VecReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{TLBIEL, 0xfc0007fe00000000, 0x7c00022400000000, 0x10000100000000, // TLB Invalidate Entry Local X-form (tlbiel RB,RS,RIC,PRS,R)
+		[6]*argField{ap_Reg_16_20, ap_Reg_6_10, ap_ImmUnsigned_12_13, ap_ImmUnsigned_14_14, ap_ImmUnsigned_15_15}},
+	{VADDCUW, 0xfc0007ff00000000, 0x1000018000000000, 0x0, // Vector Add & write Carry Unsigned Word VX-form (vaddcuw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VADDFP, 0xfc0007ff00000000, 0x1000000a00000000, 0x0, // Vector Add Floating-Point VX-form (vaddfp VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VADDSBS, 0xfc0007ff00000000, 0x1000030000000000, 0x0, // Vector Add Signed Byte Saturate VX-form (vaddsbs VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VADDSHS, 0xfc0007ff00000000, 0x1000034000000000, 0x0, // Vector Add Signed Halfword Saturate VX-form (vaddshs VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VADDSWS, 0xfc0007ff00000000, 0x1000038000000000, 0x0, // Vector Add Signed Word Saturate VX-form (vaddsws VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VADDUBM, 0xfc0007ff00000000, 0x1000000000000000, 0x0, // Vector Add Unsigned Byte Modulo VX-form (vaddubm VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VADDUBS, 0xfc0007ff00000000, 0x1000020000000000, 0x0, // Vector Add Unsigned Byte Saturate VX-form (vaddubs VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VADDUHM, 0xfc0007ff00000000, 0x1000004000000000, 0x0, // Vector Add Unsigned Halfword Modulo VX-form (vadduhm VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VADDUHS, 0xfc0007ff00000000, 0x1000024000000000, 0x0, // Vector Add Unsigned Halfword Saturate VX-form (vadduhs VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VADDUWM, 0xfc0007ff00000000, 0x1000008000000000, 0x0, // Vector Add Unsigned Word Modulo VX-form (vadduwm VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VADDUWS, 0xfc0007ff00000000, 0x1000028000000000, 0x0, // Vector Add Unsigned Word Saturate VX-form (vadduws VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VAND, 0xfc0007ff00000000, 0x1000040400000000, 0x0, // Vector Logical AND VX-form (vand VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VANDC, 0xfc0007ff00000000, 0x1000044400000000, 0x0, // Vector Logical AND with Complement VX-form (vandc VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VAVGSB, 0xfc0007ff00000000, 0x1000050200000000, 0x0, // Vector Average Signed Byte VX-form (vavgsb VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VAVGSH, 0xfc0007ff00000000, 0x1000054200000000, 0x0, // Vector Average Signed Halfword VX-form (vavgsh VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VAVGSW, 0xfc0007ff00000000, 0x1000058200000000, 0x0, // Vector Average Signed Word VX-form (vavgsw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VAVGUB, 0xfc0007ff00000000, 0x1000040200000000, 0x0, // Vector Average Unsigned Byte VX-form (vavgub VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VAVGUH, 0xfc0007ff00000000, 0x1000044200000000, 0x0, // Vector Average Unsigned Halfword VX-form (vavguh VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VAVGUW, 0xfc0007ff00000000, 0x1000048200000000, 0x0, // Vector Average Unsigned Word VX-form (vavguw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCFSX, 0xfc0007ff00000000, 0x1000034a00000000, 0x0, // Vector Convert with round to nearest From Signed Word to floating-point format VX-form (vcfsx VRT,VRB,UIM)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_11_15}},
+	{VCFUX, 0xfc0007ff00000000, 0x1000030a00000000, 0x0, // Vector Convert with round to nearest From Unsigned Word to floating-point format VX-form (vcfux VRT,VRB,UIM)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_11_15}},
+	{VCMPBFP, 0xfc0007ff00000000, 0x100003c600000000, 0x0, // Vector Compare Bounds Floating-Point VC-form (vcmpbfp VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPBFPCC, 0xfc0007ff00000000, 0x100007c600000000, 0x0, // Vector Compare Bounds Floating-Point VC-form (vcmpbfp. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPEQFP, 0xfc0007ff00000000, 0x100000c600000000, 0x0, // Vector Compare Equal Floating-Point VC-form (vcmpeqfp VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPEQFPCC, 0xfc0007ff00000000, 0x100004c600000000, 0x0, // Vector Compare Equal Floating-Point VC-form (vcmpeqfp. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPEQUB, 0xfc0007ff00000000, 0x1000000600000000, 0x0, // Vector Compare Equal Unsigned Byte VC-form (vcmpequb VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPEQUBCC, 0xfc0007ff00000000, 0x1000040600000000, 0x0, // Vector Compare Equal Unsigned Byte VC-form (vcmpequb. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPEQUH, 0xfc0007ff00000000, 0x1000004600000000, 0x0, // Vector Compare Equal Unsigned Halfword VC-form (vcmpequh VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPEQUHCC, 0xfc0007ff00000000, 0x1000044600000000, 0x0, // Vector Compare Equal Unsigned Halfword VC-form (vcmpequh. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPEQUW, 0xfc0007ff00000000, 0x1000008600000000, 0x0, // Vector Compare Equal Unsigned Word VC-form (vcmpequw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPEQUWCC, 0xfc0007ff00000000, 0x1000048600000000, 0x0, // Vector Compare Equal Unsigned Word VC-form (vcmpequw. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPGEFP, 0xfc0007ff00000000, 0x100001c600000000, 0x0, // Vector Compare Greater Than or Equal Floating-Point VC-form (vcmpgefp VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPGEFPCC, 0xfc0007ff00000000, 0x100005c600000000, 0x0, // Vector Compare Greater Than or Equal Floating-Point VC-form (vcmpgefp. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPGTFP, 0xfc0007ff00000000, 0x100002c600000000, 0x0, // Vector Compare Greater Than Floating-Point VC-form (vcmpgtfp VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPGTFPCC, 0xfc0007ff00000000, 0x100006c600000000, 0x0, // Vector Compare Greater Than Floating-Point VC-form (vcmpgtfp. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPGTSB, 0xfc0007ff00000000, 0x1000030600000000, 0x0, // Vector Compare Greater Than Signed Byte VC-form (vcmpgtsb VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPGTSBCC, 0xfc0007ff00000000, 0x1000070600000000, 0x0, // Vector Compare Greater Than Signed Byte VC-form (vcmpgtsb. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPGTSH, 0xfc0007ff00000000, 0x1000034600000000, 0x0, // Vector Compare Greater Than Signed Halfword VC-form (vcmpgtsh VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPGTSHCC, 0xfc0007ff00000000, 0x1000074600000000, 0x0, // Vector Compare Greater Than Signed Halfword VC-form (vcmpgtsh. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPGTSW, 0xfc0007ff00000000, 0x1000038600000000, 0x0, // Vector Compare Greater Than Signed Word VC-form (vcmpgtsw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPGTSWCC, 0xfc0007ff00000000, 0x1000078600000000, 0x0, // Vector Compare Greater Than Signed Word VC-form (vcmpgtsw. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPGTUB, 0xfc0007ff00000000, 0x1000020600000000, 0x0, // Vector Compare Greater Than Unsigned Byte VC-form (vcmpgtub VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPGTUBCC, 0xfc0007ff00000000, 0x1000060600000000, 0x0, // Vector Compare Greater Than Unsigned Byte VC-form (vcmpgtub. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPGTUH, 0xfc0007ff00000000, 0x1000024600000000, 0x0, // Vector Compare Greater Than Unsigned Halfword VC-form (vcmpgtuh VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPGTUHCC, 0xfc0007ff00000000, 0x1000064600000000, 0x0, // Vector Compare Greater Than Unsigned Halfword VC-form (vcmpgtuh. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPGTUW, 0xfc0007ff00000000, 0x1000028600000000, 0x0, // Vector Compare Greater Than Unsigned Word VC-form (vcmpgtuw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCMPGTUWCC, 0xfc0007ff00000000, 0x1000068600000000, 0x0, // Vector Compare Greater Than Unsigned Word VC-form (vcmpgtuw. VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VCTSXS, 0xfc0007ff00000000, 0x100003ca00000000, 0x0, // Vector Convert with round to zero from floating-point To Signed Word format Saturate VX-form (vctsxs VRT,VRB,UIM)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_11_15}},
+	{VCTUXS, 0xfc0007ff00000000, 0x1000038a00000000, 0x0, // Vector Convert with round to zero from floating-point To Unsigned Word format Saturate VX-form (vctuxs VRT,VRB,UIM)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_11_15}},
+	{VEXPTEFP, 0xfc0007ff00000000, 0x1000018a00000000, 0x1f000000000000, // Vector 2 Raised to the Exponent Estimate Floating-Point VX-form (vexptefp VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VLOGEFP, 0xfc0007ff00000000, 0x100001ca00000000, 0x1f000000000000, // Vector Log Base 2 Estimate Floating-Point VX-form (vlogefp VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VMADDFP, 0xfc00003f00000000, 0x1000002e00000000, 0x0, // Vector Multiply-Add Floating-Point VA-form (vmaddfp VRT,VRA,VRC,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_21_25, ap_VecReg_16_20}},
+	{VMAXFP, 0xfc0007ff00000000, 0x1000040a00000000, 0x0, // Vector Maximum Floating-Point VX-form (vmaxfp VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMAXSB, 0xfc0007ff00000000, 0x1000010200000000, 0x0, // Vector Maximum Signed Byte VX-form (vmaxsb VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMAXSH, 0xfc0007ff00000000, 0x1000014200000000, 0x0, // Vector Maximum Signed Halfword VX-form (vmaxsh VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMAXSW, 0xfc0007ff00000000, 0x1000018200000000, 0x0, // Vector Maximum Signed Word VX-form (vmaxsw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMAXUB, 0xfc0007ff00000000, 0x1000000200000000, 0x0, // Vector Maximum Unsigned Byte VX-form (vmaxub VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMAXUH, 0xfc0007ff00000000, 0x1000004200000000, 0x0, // Vector Maximum Unsigned Halfword VX-form (vmaxuh VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMAXUW, 0xfc0007ff00000000, 0x1000008200000000, 0x0, // Vector Maximum Unsigned Word VX-form (vmaxuw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMHADDSHS, 0xfc00003f00000000, 0x1000002000000000, 0x0, // Vector Multiply-High-Add Signed Halfword Saturate VA-form (vmhaddshs VRT,VRA,VRB,VRC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
+	{VMHRADDSHS, 0xfc00003f00000000, 0x1000002100000000, 0x0, // Vector Multiply-High-Round-Add Signed Halfword Saturate VA-form (vmhraddshs VRT,VRA,VRB,VRC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
+	{VMINFP, 0xfc0007ff00000000, 0x1000044a00000000, 0x0, // Vector Minimum Floating-Point VX-form (vminfp VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMINSB, 0xfc0007ff00000000, 0x1000030200000000, 0x0, // Vector Minimum Signed Byte VX-form (vminsb VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMINSH, 0xfc0007ff00000000, 0x1000034200000000, 0x0, // Vector Minimum Signed Halfword VX-form (vminsh VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMINSW, 0xfc0007ff00000000, 0x1000038200000000, 0x0, // Vector Minimum Signed Word VX-form (vminsw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMINUB, 0xfc0007ff00000000, 0x1000020200000000, 0x0, // Vector Minimum Unsigned Byte VX-form (vminub VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMINUH, 0xfc0007ff00000000, 0x1000024200000000, 0x0, // Vector Minimum Unsigned Halfword VX-form (vminuh VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMINUW, 0xfc0007ff00000000, 0x1000028200000000, 0x0, // Vector Minimum Unsigned Word VX-form (vminuw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMLADDUHM, 0xfc00003f00000000, 0x1000002200000000, 0x0, // Vector Multiply-Low-Add Unsigned Halfword Modulo VA-form (vmladduhm VRT,VRA,VRB,VRC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
+	{VMRGHB, 0xfc0007ff00000000, 0x1000000c00000000, 0x0, // Vector Merge High Byte VX-form (vmrghb VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMRGHH, 0xfc0007ff00000000, 0x1000004c00000000, 0x0, // Vector Merge High Halfword VX-form (vmrghh VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMRGHW, 0xfc0007ff00000000, 0x1000008c00000000, 0x0, // Vector Merge High Word VX-form (vmrghw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMRGLB, 0xfc0007ff00000000, 0x1000010c00000000, 0x0, // Vector Merge Low Byte VX-form (vmrglb VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMRGLH, 0xfc0007ff00000000, 0x1000014c00000000, 0x0, // Vector Merge Low Halfword VX-form (vmrglh VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMRGLW, 0xfc0007ff00000000, 0x1000018c00000000, 0x0, // Vector Merge Low Word VX-form (vmrglw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMSUMMBM, 0xfc00003f00000000, 0x1000002500000000, 0x0, // Vector Multiply-Sum Mixed Byte Modulo VA-form (vmsummbm VRT,VRA,VRB,VRC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
+	{VMSUMSHM, 0xfc00003f00000000, 0x1000002800000000, 0x0, // Vector Multiply-Sum Signed Halfword Modulo VA-form (vmsumshm VRT,VRA,VRB,VRC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
+	{VMSUMSHS, 0xfc00003f00000000, 0x1000002900000000, 0x0, // Vector Multiply-Sum Signed Halfword Saturate VA-form (vmsumshs VRT,VRA,VRB,VRC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
+	{VMSUMUBM, 0xfc00003f00000000, 0x1000002400000000, 0x0, // Vector Multiply-Sum Unsigned Byte Modulo VA-form (vmsumubm VRT,VRA,VRB,VRC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
+	{VMSUMUHM, 0xfc00003f00000000, 0x1000002600000000, 0x0, // Vector Multiply-Sum Unsigned Halfword Modulo VA-form (vmsumuhm VRT,VRA,VRB,VRC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
+	{VMSUMUHS, 0xfc00003f00000000, 0x1000002700000000, 0x0, // Vector Multiply-Sum Unsigned Halfword Saturate VA-form (vmsumuhs VRT,VRA,VRB,VRC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
+	{VMULESB, 0xfc0007ff00000000, 0x1000030800000000, 0x0, // Vector Multiply Even Signed Byte VX-form (vmulesb VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMULESH, 0xfc0007ff00000000, 0x1000034800000000, 0x0, // Vector Multiply Even Signed Halfword VX-form (vmulesh VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMULEUB, 0xfc0007ff00000000, 0x1000020800000000, 0x0, // Vector Multiply Even Unsigned Byte VX-form (vmuleub VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMULEUH, 0xfc0007ff00000000, 0x1000024800000000, 0x0, // Vector Multiply Even Unsigned Halfword VX-form (vmuleuh VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMULOSB, 0xfc0007ff00000000, 0x1000010800000000, 0x0, // Vector Multiply Odd Signed Byte VX-form (vmulosb VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMULOSH, 0xfc0007ff00000000, 0x1000014800000000, 0x0, // Vector Multiply Odd Signed Halfword VX-form (vmulosh VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMULOUB, 0xfc0007ff00000000, 0x1000000800000000, 0x0, // Vector Multiply Odd Unsigned Byte VX-form (vmuloub VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VMULOUH, 0xfc0007ff00000000, 0x1000004800000000, 0x0, // Vector Multiply Odd Unsigned Halfword VX-form (vmulouh VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VNMSUBFP, 0xfc00003f00000000, 0x1000002f00000000, 0x0, // Vector Negative Multiply-Subtract Floating-Point VA-form (vnmsubfp VRT,VRA,VRC,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_21_25, ap_VecReg_16_20}},
+	{VNOR, 0xfc0007ff00000000, 0x1000050400000000, 0x0, // Vector Logical NOR VX-form (vnor VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VOR, 0xfc0007ff00000000, 0x1000048400000000, 0x0, // Vector Logical OR VX-form (vor VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VPERM, 0xfc00003f00000000, 0x1000002b00000000, 0x0, // Vector Permute VA-form (vperm VRT,VRA,VRB,VRC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
+	{VPKPX, 0xfc0007ff00000000, 0x1000030e00000000, 0x0, // Vector Pack Pixel VX-form (vpkpx VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VPKSHSS, 0xfc0007ff00000000, 0x1000018e00000000, 0x0, // Vector Pack Signed Halfword Signed Saturate VX-form (vpkshss VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VPKSHUS, 0xfc0007ff00000000, 0x1000010e00000000, 0x0, // Vector Pack Signed Halfword Unsigned Saturate VX-form (vpkshus VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VPKSWSS, 0xfc0007ff00000000, 0x100001ce00000000, 0x0, // Vector Pack Signed Word Signed Saturate VX-form (vpkswss VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VPKSWUS, 0xfc0007ff00000000, 0x1000014e00000000, 0x0, // Vector Pack Signed Word Unsigned Saturate VX-form (vpkswus VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VPKUHUM, 0xfc0007ff00000000, 0x1000000e00000000, 0x0, // Vector Pack Unsigned Halfword Unsigned Modulo VX-form (vpkuhum VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VPKUHUS, 0xfc0007ff00000000, 0x1000008e00000000, 0x0, // Vector Pack Unsigned Halfword Unsigned Saturate VX-form (vpkuhus VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VPKUWUM, 0xfc0007ff00000000, 0x1000004e00000000, 0x0, // Vector Pack Unsigned Word Unsigned Modulo VX-form (vpkuwum VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VPKUWUS, 0xfc0007ff00000000, 0x100000ce00000000, 0x0, // Vector Pack Unsigned Word Unsigned Saturate VX-form (vpkuwus VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VREFP, 0xfc0007ff00000000, 0x1000010a00000000, 0x1f000000000000, // Vector Reciprocal Estimate Floating-Point VX-form (vrefp VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VRFIM, 0xfc0007ff00000000, 0x100002ca00000000, 0x1f000000000000, // Vector Round to Floating-Point Integer toward -Infinity VX-form (vrfim VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VRFIN, 0xfc0007ff00000000, 0x1000020a00000000, 0x1f000000000000, // Vector Round to Floating-Point Integer Nearest VX-form (vrfin VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VRFIP, 0xfc0007ff00000000, 0x1000028a00000000, 0x1f000000000000, // Vector Round to Floating-Point Integer toward +Infinity VX-form (vrfip VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VRFIZ, 0xfc0007ff00000000, 0x1000024a00000000, 0x1f000000000000, // Vector Round to Floating-Point Integer toward Zero VX-form (vrfiz VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VRLB, 0xfc0007ff00000000, 0x1000000400000000, 0x0, // Vector Rotate Left Byte VX-form (vrlb VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VRLH, 0xfc0007ff00000000, 0x1000004400000000, 0x0, // Vector Rotate Left Halfword VX-form (vrlh VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VRLW, 0xfc0007ff00000000, 0x1000008400000000, 0x0, // Vector Rotate Left Word VX-form (vrlw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VRSQRTEFP, 0xfc0007ff00000000, 0x1000014a00000000, 0x1f000000000000, // Vector Reciprocal Square Root Estimate Floating-Point VX-form (vrsqrtefp VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VSEL, 0xfc00003f00000000, 0x1000002a00000000, 0x0, // Vector Select VA-form (vsel VRT,VRA,VRB,VRC)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_VecReg_21_25}},
+	{VSL, 0xfc0007ff00000000, 0x100001c400000000, 0x0, // Vector Shift Left VX-form (vsl VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSLB, 0xfc0007ff00000000, 0x1000010400000000, 0x0, // Vector Shift Left Byte VX-form (vslb VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSLDOI, 0xfc00003f00000000, 0x1000002c00000000, 0x40000000000, // Vector Shift Left Double by Octet Immediate VA-form (vsldoi VRT,VRA,VRB,SHB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20, ap_ImmUnsigned_22_25}},
+	{VSLH, 0xfc0007ff00000000, 0x1000014400000000, 0x0, // Vector Shift Left Halfword VX-form (vslh VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSLO, 0xfc0007ff00000000, 0x1000040c00000000, 0x0, // Vector Shift Left by Octet VX-form (vslo VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSLW, 0xfc0007ff00000000, 0x1000018400000000, 0x0, // Vector Shift Left Word VX-form (vslw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSPLTB, 0xfc0007ff00000000, 0x1000020c00000000, 0x10000000000000, // Vector Splat Byte VX-form (vspltb VRT,VRB,UIM)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_12_15}},
+	{VSPLTH, 0xfc0007ff00000000, 0x1000024c00000000, 0x18000000000000, // Vector Splat Halfword VX-form (vsplth VRT,VRB,UIM)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_13_15}},
+	{VSPLTISB, 0xfc0007ff00000000, 0x1000030c00000000, 0xf80000000000, // Vector Splat Immediate Signed Byte VX-form (vspltisb VRT,SIM)
+		[6]*argField{ap_VecReg_6_10, ap_ImmSigned_11_15}},
+	{VSPLTISH, 0xfc0007ff00000000, 0x1000034c00000000, 0xf80000000000, // Vector Splat Immediate Signed Halfword VX-form (vspltish VRT,SIM)
+		[6]*argField{ap_VecReg_6_10, ap_ImmSigned_11_15}},
+	{VSPLTISW, 0xfc0007ff00000000, 0x1000038c00000000, 0xf80000000000, // Vector Splat Immediate Signed Word VX-form (vspltisw VRT,SIM)
+		[6]*argField{ap_VecReg_6_10, ap_ImmSigned_11_15}},
+	{VSPLTW, 0xfc0007ff00000000, 0x1000028c00000000, 0x1c000000000000, // Vector Splat Word VX-form (vspltw VRT,VRB,UIM)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20, ap_ImmUnsigned_14_15}},
+	{VSR, 0xfc0007ff00000000, 0x100002c400000000, 0x0, // Vector Shift Right VX-form (vsr VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSRAB, 0xfc0007ff00000000, 0x1000030400000000, 0x0, // Vector Shift Right Algebraic Byte VX-form (vsrab VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSRAH, 0xfc0007ff00000000, 0x1000034400000000, 0x0, // Vector Shift Right Algebraic Halfword VX-form (vsrah VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSRAW, 0xfc0007ff00000000, 0x1000038400000000, 0x0, // Vector Shift Right Algebraic Word VX-form (vsraw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSRB, 0xfc0007ff00000000, 0x1000020400000000, 0x0, // Vector Shift Right Byte VX-form (vsrb VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSRH, 0xfc0007ff00000000, 0x1000024400000000, 0x0, // Vector Shift Right Halfword VX-form (vsrh VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSRO, 0xfc0007ff00000000, 0x1000044c00000000, 0x0, // Vector Shift Right by Octet VX-form (vsro VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSRW, 0xfc0007ff00000000, 0x1000028400000000, 0x0, // Vector Shift Right Word VX-form (vsrw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSUBCUW, 0xfc0007ff00000000, 0x1000058000000000, 0x0, // Vector Subtract & Write Carry-out Unsigned Word VX-form (vsubcuw VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSUBFP, 0xfc0007ff00000000, 0x1000004a00000000, 0x0, // Vector Subtract Floating-Point VX-form (vsubfp VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSUBSBS, 0xfc0007ff00000000, 0x1000070000000000, 0x0, // Vector Subtract Signed Byte Saturate VX-form (vsubsbs VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSUBSHS, 0xfc0007ff00000000, 0x1000074000000000, 0x0, // Vector Subtract Signed Halfword Saturate VX-form (vsubshs VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSUBSWS, 0xfc0007ff00000000, 0x1000078000000000, 0x0, // Vector Subtract Signed Word Saturate VX-form (vsubsws VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSUBUBM, 0xfc0007ff00000000, 0x1000040000000000, 0x0, // Vector Subtract Unsigned Byte Modulo VX-form (vsububm VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSUBUBS, 0xfc0007ff00000000, 0x1000060000000000, 0x0, // Vector Subtract Unsigned Byte Saturate VX-form (vsububs VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSUBUHM, 0xfc0007ff00000000, 0x1000044000000000, 0x0, // Vector Subtract Unsigned Halfword Modulo VX-form (vsubuhm VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSUBUHS, 0xfc0007ff00000000, 0x1000064000000000, 0x0, // Vector Subtract Unsigned Halfword Saturate VX-form (vsubuhs VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSUBUWM, 0xfc0007ff00000000, 0x1000048000000000, 0x0, // Vector Subtract Unsigned Word Modulo VX-form (vsubuwm VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSUBUWS, 0xfc0007ff00000000, 0x1000068000000000, 0x0, // Vector Subtract Unsigned Word Saturate VX-form (vsubuws VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSUM2SWS, 0xfc0007ff00000000, 0x1000068800000000, 0x0, // Vector Sum across Half Signed Word Saturate VX-form (vsum2sws VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSUM4SBS, 0xfc0007ff00000000, 0x1000070800000000, 0x0, // Vector Sum across Quarter Signed Byte Saturate VX-form (vsum4sbs VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSUM4SHS, 0xfc0007ff00000000, 0x1000064800000000, 0x0, // Vector Sum across Quarter Signed Halfword Saturate VX-form (vsum4shs VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSUM4UBS, 0xfc0007ff00000000, 0x1000060800000000, 0x0, // Vector Sum across Quarter Unsigned Byte Saturate VX-form (vsum4ubs VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VSUMSWS, 0xfc0007ff00000000, 0x1000078800000000, 0x0, // Vector Sum across Signed Word Saturate VX-form (vsumsws VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{VUPKHPX, 0xfc0007ff00000000, 0x1000034e00000000, 0x1f000000000000, // Vector Unpack High Pixel VX-form (vupkhpx VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VUPKHSB, 0xfc0007ff00000000, 0x1000020e00000000, 0x1f000000000000, // Vector Unpack High Signed Byte VX-form (vupkhsb VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VUPKHSH, 0xfc0007ff00000000, 0x1000024e00000000, 0x1f000000000000, // Vector Unpack High Signed Halfword VX-form (vupkhsh VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VUPKLPX, 0xfc0007ff00000000, 0x100003ce00000000, 0x1f000000000000, // Vector Unpack Low Pixel VX-form (vupklpx VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VUPKLSB, 0xfc0007ff00000000, 0x1000028e00000000, 0x1f000000000000, // Vector Unpack Low Signed Byte VX-form (vupklsb VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VUPKLSH, 0xfc0007ff00000000, 0x100002ce00000000, 0x1f000000000000, // Vector Unpack Low Signed Halfword VX-form (vupklsh VRT,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_16_20}},
+	{VXOR, 0xfc0007ff00000000, 0x100004c400000000, 0x0, // Vector Logical XOR VX-form (vxor VRT,VRA,VRB)
+		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
+	{FRE, 0xfc00003f00000000, 0xfc00003000000000, 0x1f07c000000000, // Floating Reciprocal Estimate A-form (fre FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FRECC, 0xfc00003f00000000, 0xfc00003100000000, 0x1f07c000000000, // Floating Reciprocal Estimate A-form (fre. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FRIM, 0xfc0007ff00000000, 0xfc0003d000000000, 0x1f000000000000, // Floating Round to Integer Minus X-form (frim FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FRIMCC, 0xfc0007ff00000000, 0xfc0003d100000000, 0x1f000000000000, // Floating Round to Integer Minus X-form (frim. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FRIN, 0xfc0007ff00000000, 0xfc00031000000000, 0x1f000000000000, // Floating Round to Integer Nearest X-form (frin FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FRINCC, 0xfc0007ff00000000, 0xfc00031100000000, 0x1f000000000000, // Floating Round to Integer Nearest X-form (frin. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FRIP, 0xfc0007ff00000000, 0xfc00039000000000, 0x1f000000000000, // Floating Round to Integer Plus X-form (frip FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FRIPCC, 0xfc0007ff00000000, 0xfc00039100000000, 0x1f000000000000, // Floating Round to Integer Plus X-form (frip. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FRIZ, 0xfc0007ff00000000, 0xfc00035000000000, 0x1f000000000000, // Floating Round to Integer Toward Zero X-form (friz FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FRIZCC, 0xfc0007ff00000000, 0xfc00035100000000, 0x1f000000000000, // Floating Round to Integer Toward Zero X-form (friz. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FRSQRTES, 0xfc00003f00000000, 0xec00003400000000, 0x1f07c000000000, // Floating Reciprocal Square Root Estimate Single A-form (frsqrtes FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FRSQRTESCC, 0xfc00003f00000000, 0xec00003500000000, 0x1f07c000000000, // Floating Reciprocal Square Root Estimate Single A-form (frsqrtes. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{HRFID, 0xfc0007fe00000000, 0x4c00022400000000, 0x3fff80100000000, // Return From Interrupt Doubleword Hypervisor XL-form (hrfid)
+		[6]*argField{}},
+	{POPCNTB, 0xfc0007fe00000000, 0x7c0000f400000000, 0xf80100000000, // Population Count Bytes X-form (popcntb RA, RS)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10}},
+	{MFOCRF, 0xfc1007fe00000000, 0x7c10002600000000, 0x80100000000, // Move From One Condition Register Field XFX-form (mfocrf RT,FXM)
+		[6]*argField{ap_Reg_6_10, ap_ImmUnsigned_12_19}},
+	{MTOCRF, 0xfc1007fe00000000, 0x7c10012000000000, 0x80100000000, // Move To One Condition Register Field XFX-form (mtocrf FXM,RS)
+		[6]*argField{ap_ImmUnsigned_12_19, ap_Reg_6_10}},
+	{SLBMFEE, 0xfc0007fe00000000, 0x7c00072600000000, 0x1e000100000000, // SLB Move From Entry ESID X-form (slbmfee RT,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_16_20}},
+	{SLBMFEV, 0xfc0007fe00000000, 0x7c0006a600000000, 0x1e000100000000, // SLB Move From Entry VSID X-form (slbmfev RT,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_16_20}},
+	{SLBMTE, 0xfc0007fe00000000, 0x7c00032400000000, 0x1f000100000000, // SLB Move To Entry X-form (slbmte RS,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_16_20}},
+	{RFSCV, 0xfc0007fe00000000, 0x4c0000a400000000, 0x3fff80100000000, // Return From System Call Vectored XL-form (rfscv)
+		[6]*argField{}},
+	{SCV, 0xfc00000300000000, 0x4400000100000000, 0x3fff01c00000000, // System Call Vectored SC-form (scv LEV)
+		[6]*argField{ap_ImmUnsigned_20_26}},
+	{LQ, 0xfc00000000000000, 0xe000000000000000, 0xf00000000, // Load Quadword DQ-form (lq RTp,DQ(RA))
+		[6]*argField{ap_Reg_6_10, ap_Offset_16_27_shift4, ap_Reg_11_15}},
+	{STQ, 0xfc00000300000000, 0xf800000200000000, 0x0, // Store Quadword DS-form (stq RSp,DS(RA))
+		[6]*argField{ap_Reg_6_10, ap_Offset_16_29_shift2, ap_Reg_11_15}},
+	{CNTLZD, 0xfc0007ff00000000, 0x7c00007400000000, 0xf80000000000, // Count Leading Zeros Doubleword X-form (cntlzd RA,RS)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10}},
+	{CNTLZDCC, 0xfc0007ff00000000, 0x7c00007500000000, 0xf80000000000, // Count Leading Zeros Doubleword X-form (cntlzd. RA,RS)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10}},
+	{DCBF, 0xfc0007fe00000000, 0x7c0000ac00000000, 0x300000100000000, // Data Cache Block Flush X-form (dcbf RA,RB,L)
+		[6]*argField{ap_Reg_11_15, ap_Reg_16_20, ap_ImmUnsigned_8_10}},
+	{DCBST, 0xfc0007fe00000000, 0x7c00006c00000000, 0x3e0000100000000, // Data Cache Block Store X-form (dcbst RA,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_16_20}},
+	{DCBT, 0xfc0007fe00000000, 0x7c00022c00000000, 0x100000000, // Data Cache Block Touch X-form (dcbt RA,RB,TH)
+		[6]*argField{ap_Reg_11_15, ap_Reg_16_20, ap_ImmUnsigned_6_10}},
+	{DCBTST, 0xfc0007fe00000000, 0x7c0001ec00000000, 0x100000000, // Data Cache Block Touch for Store X-form (dcbtst RA,RB,TH)
+		[6]*argField{ap_Reg_11_15, ap_Reg_16_20, ap_ImmUnsigned_6_10}},
+	{DIVD, 0xfc0007ff00000000, 0x7c0003d200000000, 0x0, // Divide Doubleword XO-form (divd RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVDCC, 0xfc0007ff00000000, 0x7c0003d300000000, 0x0, // Divide Doubleword XO-form (divd. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVDO, 0xfc0007ff00000000, 0x7c0007d200000000, 0x0, // Divide Doubleword XO-form (divdo RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVDOCC, 0xfc0007ff00000000, 0x7c0007d300000000, 0x0, // Divide Doubleword XO-form (divdo. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVDU, 0xfc0007ff00000000, 0x7c00039200000000, 0x0, // Divide Doubleword Unsigned XO-form (divdu RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVDUCC, 0xfc0007ff00000000, 0x7c00039300000000, 0x0, // Divide Doubleword Unsigned XO-form (divdu. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVDUO, 0xfc0007ff00000000, 0x7c00079200000000, 0x0, // Divide Doubleword Unsigned XO-form (divduo RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVDUOCC, 0xfc0007ff00000000, 0x7c00079300000000, 0x0, // Divide Doubleword Unsigned XO-form (divduo. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVW, 0xfc0007ff00000000, 0x7c0003d600000000, 0x0, // Divide Word XO-form (divw RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVWCC, 0xfc0007ff00000000, 0x7c0003d700000000, 0x0, // Divide Word XO-form (divw. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVWO, 0xfc0007ff00000000, 0x7c0007d600000000, 0x0, // Divide Word XO-form (divwo RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVWOCC, 0xfc0007ff00000000, 0x7c0007d700000000, 0x0, // Divide Word XO-form (divwo. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVWU, 0xfc0007ff00000000, 0x7c00039600000000, 0x0, // Divide Word Unsigned XO-form (divwu RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVWUCC, 0xfc0007ff00000000, 0x7c00039700000000, 0x0, // Divide Word Unsigned XO-form (divwu. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVWUO, 0xfc0007ff00000000, 0x7c00079600000000, 0x0, // Divide Word Unsigned XO-form (divwuo RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{DIVWUOCC, 0xfc0007ff00000000, 0x7c00079700000000, 0x0, // Divide Word Unsigned XO-form (divwuo. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{EIEIO, 0xfc0007fe00000000, 0x7c0006ac00000000, 0x3fff80100000000, // Enforce In-order Execution of I/O X-form (eieio)
+		[6]*argField{}},
+	{EXTSB, 0xfc0007ff00000000, 0x7c00077400000000, 0xf80000000000, // Extend Sign Byte X-form (extsb RA,RS)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10}},
+	{EXTSBCC, 0xfc0007ff00000000, 0x7c00077500000000, 0xf80000000000, // Extend Sign Byte X-form (extsb. RA,RS)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10}},
+	{EXTSW, 0xfc0007ff00000000, 0x7c0007b400000000, 0xf80000000000, // Extend Sign Word X-form (extsw RA,RS)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10}},
+	{EXTSWCC, 0xfc0007ff00000000, 0x7c0007b500000000, 0xf80000000000, // Extend Sign Word X-form (extsw. RA,RS)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10}},
+	{FADDS, 0xfc00003f00000000, 0xec00002a00000000, 0x7c000000000, // Floating Add Single A-form (fadds FRT,FRA,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{FADDSCC, 0xfc00003f00000000, 0xec00002b00000000, 0x7c000000000, // Floating Add Single A-form (fadds. FRT,FRA,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{FCFID, 0xfc0007ff00000000, 0xfc00069c00000000, 0x1f000000000000, // Floating Convert with round Signed Doubleword to Double-Precision format X-form (fcfid FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FCFIDCC, 0xfc0007ff00000000, 0xfc00069d00000000, 0x1f000000000000, // Floating Convert with round Signed Doubleword to Double-Precision format X-form (fcfid. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FCTID, 0xfc0007ff00000000, 0xfc00065c00000000, 0x1f000000000000, // Floating Convert with round Double-Precision To Signed Doubleword format X-form (fctid FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FCTIDCC, 0xfc0007ff00000000, 0xfc00065d00000000, 0x1f000000000000, // Floating Convert with round Double-Precision To Signed Doubleword format X-form (fctid. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FCTIDZ, 0xfc0007ff00000000, 0xfc00065e00000000, 0x1f000000000000, // Floating Convert with truncate Double-Precision To Signed Doubleword format X-form (fctidz FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FCTIDZCC, 0xfc0007ff00000000, 0xfc00065f00000000, 0x1f000000000000, // Floating Convert with truncate Double-Precision To Signed Doubleword format X-form (fctidz. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FDIVS, 0xfc00003f00000000, 0xec00002400000000, 0x7c000000000, // Floating Divide Single A-form (fdivs FRT,FRA,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{FDIVSCC, 0xfc00003f00000000, 0xec00002500000000, 0x7c000000000, // Floating Divide Single A-form (fdivs. FRT,FRA,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{FMADDS, 0xfc00003f00000000, 0xec00003a00000000, 0x0, // Floating Multiply-Add Single A-form (fmadds FRT,FRA,FRC,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
+	{FMADDSCC, 0xfc00003f00000000, 0xec00003b00000000, 0x0, // Floating Multiply-Add Single A-form (fmadds. FRT,FRA,FRC,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
+	{FMSUBS, 0xfc00003f00000000, 0xec00003800000000, 0x0, // Floating Multiply-Subtract Single A-form (fmsubs FRT,FRA,FRC,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
+	{FMSUBSCC, 0xfc00003f00000000, 0xec00003900000000, 0x0, // Floating Multiply-Subtract Single A-form (fmsubs. FRT,FRA,FRC,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
+	{FMULS, 0xfc00003f00000000, 0xec00003200000000, 0xf80000000000, // Floating Multiply Single A-form (fmuls FRT,FRA,FRC)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25}},
+	{FMULSCC, 0xfc00003f00000000, 0xec00003300000000, 0xf80000000000, // Floating Multiply Single A-form (fmuls. FRT,FRA,FRC)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25}},
+	{FNMADDS, 0xfc00003f00000000, 0xec00003e00000000, 0x0, // Floating Negative Multiply-Add Single A-form (fnmadds FRT,FRA,FRC,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
+	{FNMADDSCC, 0xfc00003f00000000, 0xec00003f00000000, 0x0, // Floating Negative Multiply-Add Single A-form (fnmadds. FRT,FRA,FRC,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
+	{FNMSUBS, 0xfc00003f00000000, 0xec00003c00000000, 0x0, // Floating Negative Multiply-Subtract Single A-form (fnmsubs FRT,FRA,FRC,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
+	{FNMSUBSCC, 0xfc00003f00000000, 0xec00003d00000000, 0x0, // Floating Negative Multiply-Subtract Single A-form (fnmsubs. FRT,FRA,FRC,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
+	{FRES, 0xfc00003f00000000, 0xec00003000000000, 0x1f07c000000000, // Floating Reciprocal Estimate Single A-form (fres FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FRESCC, 0xfc00003f00000000, 0xec00003100000000, 0x1f07c000000000, // Floating Reciprocal Estimate Single A-form (fres. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FRSQRTE, 0xfc00003f00000000, 0xfc00003400000000, 0x1f07c000000000, // Floating Reciprocal Square Root Estimate A-form (frsqrte FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FRSQRTECC, 0xfc00003f00000000, 0xfc00003500000000, 0x1f07c000000000, // Floating Reciprocal Square Root Estimate A-form (frsqrte. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FSEL, 0xfc00003f00000000, 0xfc00002e00000000, 0x0, // Floating Select A-form (fsel FRT,FRA,FRC,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
+	{FSELCC, 0xfc00003f00000000, 0xfc00002f00000000, 0x0, // Floating Select A-form (fsel. FRT,FRA,FRC,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
+	{FSQRTS, 0xfc00003f00000000, 0xec00002c00000000, 0x1f07c000000000, // Floating Square Root Single A-form (fsqrts FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FSQRTSCC, 0xfc00003f00000000, 0xec00002d00000000, 0x1f07c000000000, // Floating Square Root Single A-form (fsqrts. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FSUBS, 0xfc00003f00000000, 0xec00002800000000, 0x7c000000000, // Floating Subtract Single A-form (fsubs FRT,FRA,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{FSUBSCC, 0xfc00003f00000000, 0xec00002900000000, 0x7c000000000, // Floating Subtract Single A-form (fsubs. FRT,FRA,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{ICBI, 0xfc0007fe00000000, 0x7c0007ac00000000, 0x3e0000100000000, // Instruction Cache Block Invalidate X-form (icbi RA,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_16_20}},
+	{LD, 0xfc00000300000000, 0xe800000000000000, 0x0, // Load Doubleword DS-form (ld RT,DS(RA))
+		[6]*argField{ap_Reg_6_10, ap_Offset_16_29_shift2, ap_Reg_11_15}},
+	{LDARX, 0xfc0007fe00000000, 0x7c0000a800000000, 0x0, // Load Doubleword And Reserve Indexed X-form (ldarx RT,RA,RB,EH)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20, ap_ImmUnsigned_31_31}},
+	{LDU, 0xfc00000300000000, 0xe800000100000000, 0x0, // Load Doubleword with Update DS-form (ldu RT,DS(RA))
+		[6]*argField{ap_Reg_6_10, ap_Offset_16_29_shift2, ap_Reg_11_15}},
+	{LDUX, 0xfc0007fe00000000, 0x7c00006a00000000, 0x100000000, // Load Doubleword with Update Indexed X-form (ldux RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LDX, 0xfc0007fe00000000, 0x7c00002a00000000, 0x100000000, // Load Doubleword Indexed X-form (ldx RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LWA, 0xfc00000300000000, 0xe800000200000000, 0x0, // Load Word Algebraic DS-form (lwa RT,DS(RA))
+		[6]*argField{ap_Reg_6_10, ap_Offset_16_29_shift2, ap_Reg_11_15}},
+	{LWARX, 0xfc0007fe00000000, 0x7c00002800000000, 0x0, // Load Word & Reserve Indexed X-form (lwarx RT,RA,RB,EH)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20, ap_ImmUnsigned_31_31}},
+	{LWAUX, 0xfc0007fe00000000, 0x7c0002ea00000000, 0x100000000, // Load Word Algebraic with Update Indexed X-form (lwaux RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LWAX, 0xfc0007fe00000000, 0x7c0002aa00000000, 0x100000000, // Load Word Algebraic Indexed X-form (lwax RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MFTB, 0xfc0007fe00000000, 0x7c0002e600000000, 0x100000000, // Move From Time Base XFX-form (mftb RT,TBR)
+		[6]*argField{ap_Reg_6_10, ap_SpReg_16_20_11_15}},
+	{MTMSRD, 0xfc0007fe00000000, 0x7c00016400000000, 0x1ef80100000000, // Move To MSR Doubleword X-form (mtmsrd RS,L)
+		[6]*argField{ap_Reg_6_10, ap_ImmUnsigned_15_15}},
+	{MULHD, 0xfc0003ff00000000, 0x7c00009200000000, 0x40000000000, // Multiply High Doubleword XO-form (mulhd RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MULHDCC, 0xfc0003ff00000000, 0x7c00009300000000, 0x40000000000, // Multiply High Doubleword XO-form (mulhd. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MULHDU, 0xfc0003ff00000000, 0x7c00001200000000, 0x40000000000, // Multiply High Doubleword Unsigned XO-form (mulhdu RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MULHDUCC, 0xfc0003ff00000000, 0x7c00001300000000, 0x40000000000, // Multiply High Doubleword Unsigned XO-form (mulhdu. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MULHW, 0xfc0003ff00000000, 0x7c00009600000000, 0x40000000000, // Multiply High Word XO-form (mulhw RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MULHWCC, 0xfc0003ff00000000, 0x7c00009700000000, 0x40000000000, // Multiply High Word XO-form (mulhw. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MULHWU, 0xfc0003ff00000000, 0x7c00001600000000, 0x40000000000, // Multiply High Word Unsigned XO-form (mulhwu RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MULHWUCC, 0xfc0003ff00000000, 0x7c00001700000000, 0x40000000000, // Multiply High Word Unsigned XO-form (mulhwu. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MULLD, 0xfc0007ff00000000, 0x7c0001d200000000, 0x0, // Multiply Low Doubleword XO-form (mulld RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MULLDCC, 0xfc0007ff00000000, 0x7c0001d300000000, 0x0, // Multiply Low Doubleword XO-form (mulld. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MULLDO, 0xfc0007ff00000000, 0x7c0005d200000000, 0x0, // Multiply Low Doubleword XO-form (mulldo RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MULLDOCC, 0xfc0007ff00000000, 0x7c0005d300000000, 0x0, // Multiply Low Doubleword XO-form (mulldo. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{RFID, 0xfc0007fe00000000, 0x4c00002400000000, 0x3fff80100000000, // Return from Interrupt Doubleword XL-form (rfid)
+		[6]*argField{}},
+	{RLDCL, 0xfc00001f00000000, 0x7800001000000000, 0x0, // Rotate Left Doubleword then Clear Left MDS-form (rldcl RA,RS,RB,MB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20, ap_ImmUnsigned_26_26_21_25}},
+	{RLDCLCC, 0xfc00001f00000000, 0x7800001100000000, 0x0, // Rotate Left Doubleword then Clear Left MDS-form (rldcl. RA,RS,RB,MB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20, ap_ImmUnsigned_26_26_21_25}},
+	{RLDCR, 0xfc00001f00000000, 0x7800001200000000, 0x0, // Rotate Left Doubleword then Clear Right MDS-form (rldcr RA,RS,RB,ME)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20, ap_ImmUnsigned_26_26_21_25}},
+	{RLDCRCC, 0xfc00001f00000000, 0x7800001300000000, 0x0, // Rotate Left Doubleword then Clear Right MDS-form (rldcr. RA,RS,RB,ME)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20, ap_ImmUnsigned_26_26_21_25}},
+	{RLDIC, 0xfc00001d00000000, 0x7800000800000000, 0x0, // Rotate Left Doubleword Immediate then Clear MD-form (rldic RA,RS,SH,MB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_30_30_16_20, ap_ImmUnsigned_26_26_21_25}},
+	{RLDICCC, 0xfc00001d00000000, 0x7800000900000000, 0x0, // Rotate Left Doubleword Immediate then Clear MD-form (rldic. RA,RS,SH,MB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_30_30_16_20, ap_ImmUnsigned_26_26_21_25}},
+	{RLDICL, 0xfc00001d00000000, 0x7800000000000000, 0x0, // Rotate Left Doubleword Immediate then Clear Left MD-form (rldicl RA,RS,SH,MB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_30_30_16_20, ap_ImmUnsigned_26_26_21_25}},
+	{RLDICLCC, 0xfc00001d00000000, 0x7800000100000000, 0x0, // Rotate Left Doubleword Immediate then Clear Left MD-form (rldicl. RA,RS,SH,MB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_30_30_16_20, ap_ImmUnsigned_26_26_21_25}},
+	{RLDICR, 0xfc00001d00000000, 0x7800000400000000, 0x0, // Rotate Left Doubleword Immediate then Clear Right MD-form (rldicr RA,RS,SH,ME)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_30_30_16_20, ap_ImmUnsigned_26_26_21_25}},
+	{RLDICRCC, 0xfc00001d00000000, 0x7800000500000000, 0x0, // Rotate Left Doubleword Immediate then Clear Right MD-form (rldicr. RA,RS,SH,ME)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_30_30_16_20, ap_ImmUnsigned_26_26_21_25}},
+	{RLDIMI, 0xfc00001d00000000, 0x7800000c00000000, 0x0, // Rotate Left Doubleword Immediate then Mask Insert MD-form (rldimi RA,RS,SH,MB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_30_30_16_20, ap_ImmUnsigned_26_26_21_25}},
+	{RLDIMICC, 0xfc00001d00000000, 0x7800000d00000000, 0x0, // Rotate Left Doubleword Immediate then Mask Insert MD-form (rldimi. RA,RS,SH,MB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_30_30_16_20, ap_ImmUnsigned_26_26_21_25}},
+	{SC, 0xfc00000200000000, 0x4400000200000000, 0x3fff01d00000000, // System Call SC-form (sc LEV)
+		[6]*argField{ap_ImmUnsigned_20_26}},
+	{SLBIA, 0xfc0007fe00000000, 0x7c0003e400000000, 0x31ff80100000000, // SLB Invalidate All X-form (slbia IH)
+		[6]*argField{ap_ImmUnsigned_8_10}},
+	{SLBIE, 0xfc0007fe00000000, 0x7c00036400000000, 0x3ff000100000000, // SLB Invalidate Entry X-form (slbie RB)
+		[6]*argField{ap_Reg_16_20}},
+	{SLD, 0xfc0007ff00000000, 0x7c00003600000000, 0x0, // Shift Left Doubleword X-form (sld RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{SLDCC, 0xfc0007ff00000000, 0x7c00003700000000, 0x0, // Shift Left Doubleword X-form (sld. RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{SRAD, 0xfc0007ff00000000, 0x7c00063400000000, 0x0, // Shift Right Algebraic Doubleword X-form (srad RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{SRADCC, 0xfc0007ff00000000, 0x7c00063500000000, 0x0, // Shift Right Algebraic Doubleword X-form (srad. RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{SRADI, 0xfc0007fd00000000, 0x7c00067400000000, 0x0, // Shift Right Algebraic Doubleword Immediate XS-form (sradi RA,RS,SH)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_30_30_16_20}},
+	{SRADICC, 0xfc0007fd00000000, 0x7c00067500000000, 0x0, // Shift Right Algebraic Doubleword Immediate XS-form (sradi. RA,RS,SH)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_30_30_16_20}},
+	{SRD, 0xfc0007ff00000000, 0x7c00043600000000, 0x0, // Shift Right Doubleword X-form (srd RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{SRDCC, 0xfc0007ff00000000, 0x7c00043700000000, 0x0, // Shift Right Doubleword X-form (srd. RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{STD, 0xfc00000300000000, 0xf800000000000000, 0x0, // Store Doubleword DS-form (std RS,DS(RA))
+		[6]*argField{ap_Reg_6_10, ap_Offset_16_29_shift2, ap_Reg_11_15}},
+	{STDCXCC, 0xfc0007ff00000000, 0x7c0001ad00000000, 0x0, // Store Doubleword Conditional Indexed X-form (stdcx. RS,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STDU, 0xfc00000300000000, 0xf800000100000000, 0x0, // Store Doubleword with Update DS-form (stdu RS,DS(RA))
+		[6]*argField{ap_Reg_6_10, ap_Offset_16_29_shift2, ap_Reg_11_15}},
+	{STDUX, 0xfc0007fe00000000, 0x7c00016a00000000, 0x100000000, // Store Doubleword with Update Indexed X-form (stdux RS,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STDX, 0xfc0007fe00000000, 0x7c00012a00000000, 0x100000000, // Store Doubleword Indexed X-form (stdx RS,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STFIWX, 0xfc0007fe00000000, 0x7c0007ae00000000, 0x100000000, // Store Floating-Point as Integer Word Indexed X-form (stfiwx FRS,RA,RB)
+		[6]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STWCXCC, 0xfc0007ff00000000, 0x7c00012d00000000, 0x0, // Store Word Conditional Indexed X-form (stwcx. RS,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{SUBF, 0xfc0007ff00000000, 0x7c00005000000000, 0x0, // Subtract From XO-form (subf RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{SUBFCC, 0xfc0007ff00000000, 0x7c00005100000000, 0x0, // Subtract From XO-form (subf. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{SUBFO, 0xfc0007ff00000000, 0x7c00045000000000, 0x0, // Subtract From XO-form (subfo RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{SUBFOCC, 0xfc0007ff00000000, 0x7c00045100000000, 0x0, // Subtract From XO-form (subfo. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{TD, 0xfc0007fe00000000, 0x7c00008800000000, 0x100000000, // Trap Doubleword X-form (td TO,RA,RB)
+		[6]*argField{ap_ImmUnsigned_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{TDI, 0xfc00000000000000, 0x800000000000000, 0x0, // Trap Doubleword Immediate D-form (tdi TO,RA,SI)
+		[6]*argField{ap_ImmUnsigned_6_10, ap_Reg_11_15, ap_ImmSigned_16_31}},
+	{TLBSYNC, 0xfc0007fe00000000, 0x7c00046c00000000, 0x3fff80100000000, // TLB Synchronize X-form (tlbsync)
+		[6]*argField{}},
+	{FCTIW, 0xfc0007ff00000000, 0xfc00001c00000000, 0x1f000000000000, // Floating Convert with round Double-Precision To Signed Word format X-form (fctiw FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FCTIWCC, 0xfc0007ff00000000, 0xfc00001d00000000, 0x1f000000000000, // Floating Convert with round Double-Precision To Signed Word format X-form (fctiw. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FCTIWZ, 0xfc0007ff00000000, 0xfc00001e00000000, 0x1f000000000000, // Floating Convert with truncate Double-Precision To Signed Word fomat X-form (fctiwz FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FCTIWZCC, 0xfc0007ff00000000, 0xfc00001f00000000, 0x1f000000000000, // Floating Convert with truncate Double-Precision To Signed Word fomat X-form (fctiwz. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FSQRT, 0xfc00003f00000000, 0xfc00002c00000000, 0x1f07c000000000, // Floating Square Root A-form (fsqrt FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FSQRTCC, 0xfc00003f00000000, 0xfc00002d00000000, 0x1f07c000000000, // Floating Square Root A-form (fsqrt. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{ADD, 0xfc0007ff00000000, 0x7c00021400000000, 0x0, // Add XO-form (add RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{ADDCC, 0xfc0007ff00000000, 0x7c00021500000000, 0x0, // Add XO-form (add. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{ADDO, 0xfc0007ff00000000, 0x7c00061400000000, 0x0, // Add XO-form (addo RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{ADDOCC, 0xfc0007ff00000000, 0x7c00061500000000, 0x0, // Add XO-form (addo. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{ADDC, 0xfc0007ff00000000, 0x7c00001400000000, 0x0, // Add Carrying XO-form (addc RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{ADDCCC, 0xfc0007ff00000000, 0x7c00001500000000, 0x0, // Add Carrying XO-form (addc. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{ADDCO, 0xfc0007ff00000000, 0x7c00041400000000, 0x0, // Add Carrying XO-form (addco RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{ADDCOCC, 0xfc0007ff00000000, 0x7c00041500000000, 0x0, // Add Carrying XO-form (addco. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{ADDE, 0xfc0007ff00000000, 0x7c00011400000000, 0x0, // Add Extended XO-form (adde RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{ADDECC, 0xfc0007ff00000000, 0x7c00011500000000, 0x0, // Add Extended XO-form (adde. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{ADDEO, 0xfc0007ff00000000, 0x7c00051400000000, 0x0, // Add Extended XO-form (addeo RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{ADDEOCC, 0xfc0007ff00000000, 0x7c00051500000000, 0x0, // Add Extended XO-form (addeo. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LI, 0xfc1f000000000000, 0x3800000000000000, 0x0, // Add Immediate D-form (li RT,SI)
+		[6]*argField{ap_Reg_6_10, ap_ImmSigned_16_31}},
+	{ADDI, 0xfc00000000000000, 0x3800000000000000, 0x0, // Add Immediate D-form (addi RT,RA,SI)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_ImmSigned_16_31}},
+	{ADDIC, 0xfc00000000000000, 0x3000000000000000, 0x0, // Add Immediate Carrying D-formy (addic RT,RA,SI)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_ImmSigned_16_31}},
+	{ADDICCC, 0xfc00000000000000, 0x3400000000000000, 0x0, // Add Immediate Carrying and Record D-form (addic. RT,RA,SI)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_ImmSigned_16_31}},
+	{LIS, 0xfc1f000000000000, 0x3c00000000000000, 0x0, // Add Immediate Shifted D-form (lis RT,SI)
+		[6]*argField{ap_Reg_6_10, ap_ImmSigned_16_31}},
+	{ADDIS, 0xfc00000000000000, 0x3c00000000000000, 0x0, // Add Immediate Shifted D-form (addis RT,RA,SI)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_ImmSigned_16_31}},
+	{ADDME, 0xfc0007ff00000000, 0x7c0001d400000000, 0xf80000000000, // Add to Minus One Extended XO-form (addme RT,RA)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15}},
+	{ADDMECC, 0xfc0007ff00000000, 0x7c0001d500000000, 0xf80000000000, // Add to Minus One Extended XO-form (addme. RT,RA)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15}},
+	{ADDMEO, 0xfc0007ff00000000, 0x7c0005d400000000, 0xf80000000000, // Add to Minus One Extended XO-form (addmeo RT,RA)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15}},
+	{ADDMEOCC, 0xfc0007ff00000000, 0x7c0005d500000000, 0xf80000000000, // Add to Minus One Extended XO-form (addmeo. RT,RA)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15}},
+	{ADDZE, 0xfc0007ff00000000, 0x7c00019400000000, 0xf80000000000, // Add to Zero Extended XO-form (addze RT,RA)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15}},
+	{ADDZECC, 0xfc0007ff00000000, 0x7c00019500000000, 0xf80000000000, // Add to Zero Extended XO-form (addze. RT,RA)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15}},
+	{ADDZEO, 0xfc0007ff00000000, 0x7c00059400000000, 0xf80000000000, // Add to Zero Extended XO-form (addzeo RT,RA)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15}},
+	{ADDZEOCC, 0xfc0007ff00000000, 0x7c00059500000000, 0xf80000000000, // Add to Zero Extended XO-form (addzeo. RT,RA)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15}},
+	{AND, 0xfc0007ff00000000, 0x7c00003800000000, 0x0, // AND X-form (and RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{ANDCC, 0xfc0007ff00000000, 0x7c00003900000000, 0x0, // AND X-form (and. RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{ANDC, 0xfc0007ff00000000, 0x7c00007800000000, 0x0, // AND with Complement X-form (andc RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{ANDCCC, 0xfc0007ff00000000, 0x7c00007900000000, 0x0, // AND with Complement X-form (andc. RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{ANDICC, 0xfc00000000000000, 0x7000000000000000, 0x0, // AND Immediate D-form (andi. RA,RS,UI)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_16_31}},
+	{ANDISCC, 0xfc00000000000000, 0x7400000000000000, 0x0, // AND Immediate Shifted D-form (andis. RA,RS,UI)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_16_31}},
+	{B, 0xfc00000300000000, 0x4800000000000000, 0x0, // Branch I-form (b target_addr)
+		[6]*argField{ap_PCRel_6_29_shift2}},
+	{BA, 0xfc00000300000000, 0x4800000200000000, 0x0, // Branch I-form (ba target_addr)
+		[6]*argField{ap_Label_6_29_shift2}},
+	{BL, 0xfc00000300000000, 0x4800000100000000, 0x0, // Branch I-form (bl target_addr)
+		[6]*argField{ap_PCRel_6_29_shift2}},
+	{BLA, 0xfc00000300000000, 0x4800000300000000, 0x0, // Branch I-form (bla target_addr)
+		[6]*argField{ap_Label_6_29_shift2}},
+	{BC, 0xfc00000300000000, 0x4000000000000000, 0x0, // Branch Conditional B-form (bc BO,BI,target_addr)
+		[6]*argField{ap_ImmUnsigned_6_10, ap_CondRegBit_11_15, ap_PCRel_16_29_shift2}},
+	{BCA, 0xfc00000300000000, 0x4000000200000000, 0x0, // Branch Conditional B-form (bca BO,BI,target_addr)
+		[6]*argField{ap_ImmUnsigned_6_10, ap_CondRegBit_11_15, ap_Label_16_29_shift2}},
+	{BCL, 0xfc00000300000000, 0x4000000100000000, 0x0, // Branch Conditional B-form (bcl BO,BI,target_addr)
+		[6]*argField{ap_ImmUnsigned_6_10, ap_CondRegBit_11_15, ap_PCRel_16_29_shift2}},
+	{BCLA, 0xfc00000300000000, 0x4000000300000000, 0x0, // Branch Conditional B-form (bcla BO,BI,target_addr)
+		[6]*argField{ap_ImmUnsigned_6_10, ap_CondRegBit_11_15, ap_Label_16_29_shift2}},
+	{BCCTR, 0xfc0007ff00000000, 0x4c00042000000000, 0xe00000000000, // Branch Conditional to Count Register XL-form (bcctr BO,BI,BH)
+		[6]*argField{ap_ImmUnsigned_6_10, ap_CondRegBit_11_15, ap_ImmUnsigned_19_20}},
+	{BCCTRL, 0xfc0007ff00000000, 0x4c00042100000000, 0xe00000000000, // Branch Conditional to Count Register XL-form (bcctrl BO,BI,BH)
+		[6]*argField{ap_ImmUnsigned_6_10, ap_CondRegBit_11_15, ap_ImmUnsigned_19_20}},
+	{BCLR, 0xfc0007ff00000000, 0x4c00002000000000, 0xe00000000000, // Branch Conditional to Link Register XL-form (bclr BO,BI,BH)
+		[6]*argField{ap_ImmUnsigned_6_10, ap_CondRegBit_11_15, ap_ImmUnsigned_19_20}},
+	{BCLRL, 0xfc0007ff00000000, 0x4c00002100000000, 0xe00000000000, // Branch Conditional to Link Register XL-form (bclrl BO,BI,BH)
+		[6]*argField{ap_ImmUnsigned_6_10, ap_CondRegBit_11_15, ap_ImmUnsigned_19_20}},
+	{CMPW, 0xfc2007fe00000000, 0x7c00000000000000, 0x40000100000000, // Compare X-form (cmpw BF,RA,RB)
+		[6]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
+	{CMPD, 0xfc2007fe00000000, 0x7c20000000000000, 0x40000100000000, // Compare X-form (cmpd BF,RA,RB)
+		[6]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
+	{CMP, 0xfc0007fe00000000, 0x7c00000000000000, 0x40000100000000, // Compare X-form (cmp BF,L,RA,RB)
+		[6]*argField{ap_CondRegField_6_8, ap_ImmUnsigned_10_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{CMPWI, 0xfc20000000000000, 0x2c00000000000000, 0x40000000000000, // Compare Immediate D-form (cmpwi BF,RA,SI)
+		[6]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_ImmSigned_16_31}},
+	{CMPDI, 0xfc20000000000000, 0x2c20000000000000, 0x40000000000000, // Compare Immediate D-form (cmpdi BF,RA,SI)
+		[6]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_ImmSigned_16_31}},
+	{CMPI, 0xfc00000000000000, 0x2c00000000000000, 0x40000000000000, // Compare Immediate D-form (cmpi BF,L,RA,SI)
+		[6]*argField{ap_CondRegField_6_8, ap_ImmUnsigned_10_10, ap_Reg_11_15, ap_ImmSigned_16_31}},
+	{CMPLW, 0xfc2007fe00000000, 0x7c00004000000000, 0x40000100000000, // Compare Logical X-form (cmplw BF,RA,RB)
+		[6]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
+	{CMPLD, 0xfc2007fe00000000, 0x7c20004000000000, 0x40000100000000, // Compare Logical X-form (cmpld BF,RA,RB)
+		[6]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_Reg_16_20}},
+	{CMPL, 0xfc0007fe00000000, 0x7c00004000000000, 0x40000100000000, // Compare Logical X-form (cmpl BF,L,RA,RB)
+		[6]*argField{ap_CondRegField_6_8, ap_ImmUnsigned_10_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{CMPLWI, 0xfc20000000000000, 0x2800000000000000, 0x40000000000000, // Compare Logical Immediate D-form (cmplwi BF,RA,UI)
+		[6]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_ImmUnsigned_16_31}},
+	{CMPLDI, 0xfc20000000000000, 0x2820000000000000, 0x40000000000000, // Compare Logical Immediate D-form (cmpldi BF,RA,UI)
+		[6]*argField{ap_CondRegField_6_8, ap_Reg_11_15, ap_ImmUnsigned_16_31}},
+	{CMPLI, 0xfc00000000000000, 0x2800000000000000, 0x40000000000000, // Compare Logical Immediate D-form (cmpli BF,L,RA,UI)
+		[6]*argField{ap_CondRegField_6_8, ap_ImmUnsigned_10_10, ap_Reg_11_15, ap_ImmUnsigned_16_31}},
+	{CNTLZW, 0xfc0007ff00000000, 0x7c00003400000000, 0xf80000000000, // Count Leading Zeros Word X-form (cntlzw RA,RS)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10}},
+	{CNTLZWCC, 0xfc0007ff00000000, 0x7c00003500000000, 0xf80000000000, // Count Leading Zeros Word X-form (cntlzw. RA,RS)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10}},
+	{CRAND, 0xfc0007fe00000000, 0x4c00020200000000, 0x100000000, // Condition Register AND XL-form (crand BT,BA,BB)
+		[6]*argField{ap_CondRegBit_6_10, ap_CondRegBit_11_15, ap_CondRegBit_16_20}},
+	{CRANDC, 0xfc0007fe00000000, 0x4c00010200000000, 0x100000000, // Condition Register AND with Complement XL-form (crandc BT,BA,BB)
+		[6]*argField{ap_CondRegBit_6_10, ap_CondRegBit_11_15, ap_CondRegBit_16_20}},
+	{CREQV, 0xfc0007fe00000000, 0x4c00024200000000, 0x100000000, // Condition Register Equivalent XL-form (creqv BT,BA,BB)
+		[6]*argField{ap_CondRegBit_6_10, ap_CondRegBit_11_15, ap_CondRegBit_16_20}},
+	{CRNAND, 0xfc0007fe00000000, 0x4c0001c200000000, 0x100000000, // Condition Register NAND XL-form (crnand BT,BA,BB)
+		[6]*argField{ap_CondRegBit_6_10, ap_CondRegBit_11_15, ap_CondRegBit_16_20}},
+	{CRNOR, 0xfc0007fe00000000, 0x4c00004200000000, 0x100000000, // Condition Register NOR XL-form (crnor BT,BA,BB)
+		[6]*argField{ap_CondRegBit_6_10, ap_CondRegBit_11_15, ap_CondRegBit_16_20}},
+	{CROR, 0xfc0007fe00000000, 0x4c00038200000000, 0x100000000, // Condition Register OR XL-form (cror BT,BA,BB)
+		[6]*argField{ap_CondRegBit_6_10, ap_CondRegBit_11_15, ap_CondRegBit_16_20}},
+	{CRORC, 0xfc0007fe00000000, 0x4c00034200000000, 0x100000000, // Condition Register OR with Complement XL-form (crorc BT,BA,BB)
+		[6]*argField{ap_CondRegBit_6_10, ap_CondRegBit_11_15, ap_CondRegBit_16_20}},
+	{CRXOR, 0xfc0007fe00000000, 0x4c00018200000000, 0x100000000, // Condition Register XOR XL-form (crxor BT,BA,BB)
+		[6]*argField{ap_CondRegBit_6_10, ap_CondRegBit_11_15, ap_CondRegBit_16_20}},
+	{DCBZ, 0xfc0007fe00000000, 0x7c0007ec00000000, 0x3e0000100000000, // Data Cache Block set to Zero X-form (dcbz RA,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_16_20}},
+	{EQV, 0xfc0007ff00000000, 0x7c00023800000000, 0x0, // Equivalent X-form (eqv RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{EQVCC, 0xfc0007ff00000000, 0x7c00023900000000, 0x0, // Equivalent X-form (eqv. RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{EXTSH, 0xfc0007ff00000000, 0x7c00073400000000, 0xf80000000000, // Extend Sign Halfword X-form (extsh RA,RS)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10}},
+	{EXTSHCC, 0xfc0007ff00000000, 0x7c00073500000000, 0xf80000000000, // Extend Sign Halfword X-form (extsh. RA,RS)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10}},
+	{FABS, 0xfc0007ff00000000, 0xfc00021000000000, 0x1f000000000000, // Floating Absolute Value X-form (fabs FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FABSCC, 0xfc0007ff00000000, 0xfc00021100000000, 0x1f000000000000, // Floating Absolute Value X-form (fabs. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FADD, 0xfc00003f00000000, 0xfc00002a00000000, 0x7c000000000, // Floating Add A-form (fadd FRT,FRA,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{FADDCC, 0xfc00003f00000000, 0xfc00002b00000000, 0x7c000000000, // Floating Add A-form (fadd. FRT,FRA,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{FCMPO, 0xfc0007fe00000000, 0xfc00004000000000, 0x60000100000000, // Floating Compare Ordered X-form (fcmpo BF,FRA,FRB)
+		[6]*argField{ap_CondRegField_6_8, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{FCMPU, 0xfc0007fe00000000, 0xfc00000000000000, 0x60000100000000, // Floating Compare Unordered X-form (fcmpu BF,FRA,FRB)
+		[6]*argField{ap_CondRegField_6_8, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{FDIV, 0xfc00003f00000000, 0xfc00002400000000, 0x7c000000000, // Floating Divide A-form (fdiv FRT,FRA,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{FDIVCC, 0xfc00003f00000000, 0xfc00002500000000, 0x7c000000000, // Floating Divide A-form (fdiv. FRT,FRA,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{FMADD, 0xfc00003f00000000, 0xfc00003a00000000, 0x0, // Floating Multiply-Add A-form (fmadd FRT,FRA,FRC,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
+	{FMADDCC, 0xfc00003f00000000, 0xfc00003b00000000, 0x0, // Floating Multiply-Add A-form (fmadd. FRT,FRA,FRC,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
+	{FMR, 0xfc0007ff00000000, 0xfc00009000000000, 0x1f000000000000, // Floating Move Register X-form (fmr FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FMRCC, 0xfc0007ff00000000, 0xfc00009100000000, 0x1f000000000000, // Floating Move Register X-form (fmr. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FMSUB, 0xfc00003f00000000, 0xfc00003800000000, 0x0, // Floating Multiply-Subtract A-form (fmsub FRT,FRA,FRC,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
+	{FMSUBCC, 0xfc00003f00000000, 0xfc00003900000000, 0x0, // Floating Multiply-Subtract A-form (fmsub. FRT,FRA,FRC,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
+	{FMUL, 0xfc00003f00000000, 0xfc00003200000000, 0xf80000000000, // Floating Multiply A-form (fmul FRT,FRA,FRC)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25}},
+	{FMULCC, 0xfc00003f00000000, 0xfc00003300000000, 0xf80000000000, // Floating Multiply A-form (fmul. FRT,FRA,FRC)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25}},
+	{FNABS, 0xfc0007ff00000000, 0xfc00011000000000, 0x1f000000000000, // Floating Negative Absolute Value X-form (fnabs FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FNABSCC, 0xfc0007ff00000000, 0xfc00011100000000, 0x1f000000000000, // Floating Negative Absolute Value X-form (fnabs. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FNEG, 0xfc0007ff00000000, 0xfc00005000000000, 0x1f000000000000, // Floating Negate X-form (fneg FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FNEGCC, 0xfc0007ff00000000, 0xfc00005100000000, 0x1f000000000000, // Floating Negate X-form (fneg. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FNMADD, 0xfc00003f00000000, 0xfc00003e00000000, 0x0, // Floating Negative Multiply-Add A-form (fnmadd FRT,FRA,FRC,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
+	{FNMADDCC, 0xfc00003f00000000, 0xfc00003f00000000, 0x0, // Floating Negative Multiply-Add A-form (fnmadd. FRT,FRA,FRC,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
+	{FNMSUB, 0xfc00003f00000000, 0xfc00003c00000000, 0x0, // Floating Negative Multiply-Subtract A-form (fnmsub FRT,FRA,FRC,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
+	{FNMSUBCC, 0xfc00003f00000000, 0xfc00003d00000000, 0x0, // Floating Negative Multiply-Subtract A-form (fnmsub. FRT,FRA,FRC,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_21_25, ap_FPReg_16_20}},
+	{FRSP, 0xfc0007ff00000000, 0xfc00001800000000, 0x1f000000000000, // Floating Round to Single-Precision X-form (frsp FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FRSPCC, 0xfc0007ff00000000, 0xfc00001900000000, 0x1f000000000000, // Floating Round to Single-Precision X-form (frsp. FRT,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_16_20}},
+	{FSUB, 0xfc00003f00000000, 0xfc00002800000000, 0x7c000000000, // Floating Subtract A-form (fsub FRT,FRA,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{FSUBCC, 0xfc00003f00000000, 0xfc00002900000000, 0x7c000000000, // Floating Subtract A-form (fsub. FRT,FRA,FRB)
+		[6]*argField{ap_FPReg_6_10, ap_FPReg_11_15, ap_FPReg_16_20}},
+	{ISYNC, 0xfc0007fe00000000, 0x4c00012c00000000, 0x3fff80100000000, // Instruction Synchronize XL-form (isync)
+		[6]*argField{}},
+	{LBZ, 0xfc00000000000000, 0x8800000000000000, 0x0, // Load Byte and Zero D-form (lbz RT,D(RA))
+		[6]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
+	{LBZU, 0xfc00000000000000, 0x8c00000000000000, 0x0, // Load Byte and Zero with Update D-form (lbzu RT,D(RA))
+		[6]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
+	{LBZUX, 0xfc0007fe00000000, 0x7c0000ee00000000, 0x100000000, // Load Byte and Zero with Update Indexed X-form (lbzux RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LBZX, 0xfc0007fe00000000, 0x7c0000ae00000000, 0x100000000, // Load Byte and Zero Indexed X-form (lbzx RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LFD, 0xfc00000000000000, 0xc800000000000000, 0x0, // Load Floating-Point Double D-form (lfd FRT,D(RA))
+		[6]*argField{ap_FPReg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
+	{LFDU, 0xfc00000000000000, 0xcc00000000000000, 0x0, // Load Floating-Point Double with Update D-form (lfdu FRT,D(RA))
+		[6]*argField{ap_FPReg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
+	{LFDUX, 0xfc0007fe00000000, 0x7c0004ee00000000, 0x100000000, // Load Floating-Point Double with Update Indexed X-form (lfdux FRT,RA,RB)
+		[6]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LFDX, 0xfc0007fe00000000, 0x7c0004ae00000000, 0x100000000, // Load Floating-Point Double Indexed X-form (lfdx FRT,RA,RB)
+		[6]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LFS, 0xfc00000000000000, 0xc000000000000000, 0x0, // Load Floating-Point Single D-form (lfs FRT,D(RA))
+		[6]*argField{ap_FPReg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
+	{LFSU, 0xfc00000000000000, 0xc400000000000000, 0x0, // Load Floating-Point Single with Update D-form (lfsu FRT,D(RA))
+		[6]*argField{ap_FPReg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
+	{LFSUX, 0xfc0007fe00000000, 0x7c00046e00000000, 0x100000000, // Load Floating-Point Single with Update Indexed X-form (lfsux FRT,RA,RB)
+		[6]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LFSX, 0xfc0007fe00000000, 0x7c00042e00000000, 0x100000000, // Load Floating-Point Single Indexed X-form (lfsx FRT,RA,RB)
+		[6]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LHA, 0xfc00000000000000, 0xa800000000000000, 0x0, // Load Halfword Algebraic D-form (lha RT,D(RA))
+		[6]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
+	{LHAU, 0xfc00000000000000, 0xac00000000000000, 0x0, // Load Halfword Algebraic with Update D-form (lhau RT,D(RA))
+		[6]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
+	{LHAUX, 0xfc0007fe00000000, 0x7c0002ee00000000, 0x100000000, // Load Halfword Algebraic with Update Indexed X-form (lhaux RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LHAX, 0xfc0007fe00000000, 0x7c0002ae00000000, 0x100000000, // Load Halfword Algebraic Indexed X-form (lhax RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LHBRX, 0xfc0007fe00000000, 0x7c00062c00000000, 0x100000000, // Load Halfword Byte-Reverse Indexed X-form (lhbrx RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LHZ, 0xfc00000000000000, 0xa000000000000000, 0x0, // Load Halfword and Zero D-form (lhz RT,D(RA))
+		[6]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
+	{LHZU, 0xfc00000000000000, 0xa400000000000000, 0x0, // Load Halfword and Zero with Update D-form (lhzu RT,D(RA))
+		[6]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
+	{LHZUX, 0xfc0007fe00000000, 0x7c00026e00000000, 0x100000000, // Load Halfword and Zero with Update Indexed X-form (lhzux RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LHZX, 0xfc0007fe00000000, 0x7c00022e00000000, 0x100000000, // Load Halfword and Zero Indexed X-form (lhzx RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LMW, 0xfc00000000000000, 0xb800000000000000, 0x0, // Load Multiple Word D-form (lmw RT,D(RA))
+		[6]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
+	{LSWI, 0xfc0007fe00000000, 0x7c0004aa00000000, 0x100000000, // Load String Word Immediate X-form (lswi RT,RA,NB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_ImmUnsigned_16_20}},
+	{LSWX, 0xfc0007fe00000000, 0x7c00042a00000000, 0x100000000, // Load String Word Indexed X-form (lswx RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LWBRX, 0xfc0007fe00000000, 0x7c00042c00000000, 0x100000000, // Load Word Byte-Reverse Indexed X-form (lwbrx RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LWZ, 0xfc00000000000000, 0x8000000000000000, 0x0, // Load Word and Zero D-form (lwz RT,D(RA))
+		[6]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
+	{LWZU, 0xfc00000000000000, 0x8400000000000000, 0x0, // Load Word and Zero with Update D-form (lwzu RT,D(RA))
+		[6]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
+	{LWZUX, 0xfc0007fe00000000, 0x7c00006e00000000, 0x100000000, // Load Word and Zero with Update Indexed X-form (lwzux RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{LWZX, 0xfc0007fe00000000, 0x7c00002e00000000, 0x100000000, // Load Word and Zero Indexed X-form (lwzx RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MCRF, 0xfc0007fe00000000, 0x4c00000000000000, 0x63f80100000000, // Move Condition Register Field XL-form (mcrf BF,BFA)
+		[6]*argField{ap_CondRegField_6_8, ap_CondRegField_11_13}},
+	{MCRFS, 0xfc0007fe00000000, 0xfc00008000000000, 0x63f80100000000, // Move to Condition Register from FPSCR X-form (mcrfs BF,BFA)
+		[6]*argField{ap_CondRegField_6_8, ap_CondRegField_11_13}},
+	{MFCR, 0xfc1007fe00000000, 0x7c00002600000000, 0xff80100000000, // Move From Condition Register XFX-form (mfcr RT)
+		[6]*argField{ap_Reg_6_10}},
+	{MFFS, 0xfc1f07ff00000000, 0xfc00048e00000000, 0xf80000000000, // Move From FPSCR X-form (mffs FRT)
+		[6]*argField{ap_FPReg_6_10}},
+	{MFFSCC, 0xfc1f07ff00000000, 0xfc00048f00000000, 0xf80000000000, // Move From FPSCR X-form (mffs. FRT)
+		[6]*argField{ap_FPReg_6_10}},
+	{MFMSR, 0xfc0007fe00000000, 0x7c0000a600000000, 0x1ff80100000000, // Move From MSR X-form (mfmsr RT)
+		[6]*argField{ap_Reg_6_10}},
+	{MFSPR, 0xfc0007fe00000000, 0x7c0002a600000000, 0x100000000, // Move From Special Purpose Register XFX-form (mfspr RT,SPR)
+		[6]*argField{ap_Reg_6_10, ap_SpReg_16_20_11_15}},
+	{MTCRF, 0xfc1007fe00000000, 0x7c00012000000000, 0x80100000000, // Move To Condition Register Fields XFX-form (mtcrf FXM,RS)
+		[6]*argField{ap_ImmUnsigned_12_19, ap_Reg_6_10}},
+	{MTFSB0, 0xfc0007ff00000000, 0xfc00008c00000000, 0x1ff80000000000, // Move To FPSCR Bit 0 X-form (mtfsb0 BT)
+		[6]*argField{ap_ImmUnsigned_6_10}},
+	{MTFSB0CC, 0xfc0007ff00000000, 0xfc00008d00000000, 0x1ff80000000000, // Move To FPSCR Bit 0 X-form (mtfsb0. BT)
+		[6]*argField{ap_ImmUnsigned_6_10}},
+	{MTFSB1, 0xfc0007ff00000000, 0xfc00004c00000000, 0x1ff80000000000, // Move To FPSCR Bit 1 X-form (mtfsb1 BT)
+		[6]*argField{ap_ImmUnsigned_6_10}},
+	{MTFSB1CC, 0xfc0007ff00000000, 0xfc00004d00000000, 0x1ff80000000000, // Move To FPSCR Bit 1 X-form (mtfsb1. BT)
+		[6]*argField{ap_ImmUnsigned_6_10}},
+	{MTFSF, 0xfc0007ff00000000, 0xfc00058e00000000, 0x0, // Move To FPSCR Fields XFL-form (mtfsf FLM,FRB,L,W)
+		[6]*argField{ap_ImmUnsigned_7_14, ap_FPReg_16_20, ap_ImmUnsigned_6_6, ap_ImmUnsigned_15_15}},
+	{MTFSFCC, 0xfc0007ff00000000, 0xfc00058f00000000, 0x0, // Move To FPSCR Fields XFL-form (mtfsf. FLM,FRB,L,W)
+		[6]*argField{ap_ImmUnsigned_7_14, ap_FPReg_16_20, ap_ImmUnsigned_6_6, ap_ImmUnsigned_15_15}},
+	{MTFSFI, 0xfc0007ff00000000, 0xfc00010c00000000, 0x7e080000000000, // Move To FPSCR Field Immediate X-form (mtfsfi BF,U,W)
+		[6]*argField{ap_ImmUnsigned_6_8, ap_ImmUnsigned_16_19, ap_ImmUnsigned_15_15}},
+	{MTFSFICC, 0xfc0007ff00000000, 0xfc00010d00000000, 0x7e080000000000, // Move To FPSCR Field Immediate X-form (mtfsfi. BF,U,W)
+		[6]*argField{ap_ImmUnsigned_6_8, ap_ImmUnsigned_16_19, ap_ImmUnsigned_15_15}},
+	{MTMSR, 0xfc0007fe00000000, 0x7c00012400000000, 0x1ef80100000000, // Move To MSR X-form (mtmsr RS,L)
+		[6]*argField{ap_Reg_6_10, ap_ImmUnsigned_15_15}},
+	{MTSPR, 0xfc0007fe00000000, 0x7c0003a600000000, 0x100000000, // Move To Special Purpose Register XFX-form (mtspr SPR,RS)
+		[6]*argField{ap_SpReg_16_20_11_15, ap_Reg_6_10}},
+	{MULLI, 0xfc00000000000000, 0x1c00000000000000, 0x0, // Multiply Low Immediate D-form (mulli RT,RA,SI)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_ImmSigned_16_31}},
+	{MULLW, 0xfc0007ff00000000, 0x7c0001d600000000, 0x0, // Multiply Low Word XO-form (mullw RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MULLWCC, 0xfc0007ff00000000, 0x7c0001d700000000, 0x0, // Multiply Low Word XO-form (mullw. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MULLWO, 0xfc0007ff00000000, 0x7c0005d600000000, 0x0, // Multiply Low Word XO-form (mullwo RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{MULLWOCC, 0xfc0007ff00000000, 0x7c0005d700000000, 0x0, // Multiply Low Word XO-form (mullwo. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{NAND, 0xfc0007ff00000000, 0x7c0003b800000000, 0x0, // NAND X-form (nand RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{NANDCC, 0xfc0007ff00000000, 0x7c0003b900000000, 0x0, // NAND X-form (nand. RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{NEG, 0xfc0007ff00000000, 0x7c0000d000000000, 0xf80000000000, // Negate XO-form (neg RT,RA)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15}},
+	{NEGCC, 0xfc0007ff00000000, 0x7c0000d100000000, 0xf80000000000, // Negate XO-form (neg. RT,RA)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15}},
+	{NEGO, 0xfc0007ff00000000, 0x7c0004d000000000, 0xf80000000000, // Negate XO-form (nego RT,RA)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15}},
+	{NEGOCC, 0xfc0007ff00000000, 0x7c0004d100000000, 0xf80000000000, // Negate XO-form (nego. RT,RA)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15}},
+	{NOR, 0xfc0007ff00000000, 0x7c0000f800000000, 0x0, // NOR X-form (nor RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{NORCC, 0xfc0007ff00000000, 0x7c0000f900000000, 0x0, // NOR X-form (nor. RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{OR, 0xfc0007ff00000000, 0x7c00037800000000, 0x0, // OR X-form (or RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{ORCC, 0xfc0007ff00000000, 0x7c00037900000000, 0x0, // OR X-form (or. RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{ORC, 0xfc0007ff00000000, 0x7c00033800000000, 0x0, // OR with Complement X-form (orc RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{ORCCC, 0xfc0007ff00000000, 0x7c00033900000000, 0x0, // OR with Complement X-form (orc. RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{NOP, 0xffffffff00000000, 0x6000000000000000, 0x0, // OR Immediate D-form (nop)
+		[6]*argField{}},
+	{ORI, 0xfc00000000000000, 0x6000000000000000, 0x0, // OR Immediate D-form (ori RA,RS,UI)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_16_31}},
+	{ORIS, 0xfc00000000000000, 0x6400000000000000, 0x0, // OR Immediate Shifted D-form (oris RA,RS,UI)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_16_31}},
+	{RLWIMI, 0xfc00000100000000, 0x5000000000000000, 0x0, // Rotate Left Word Immediate then Mask Insert M-form (rlwimi RA,RS,SH,MB,ME)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_ImmUnsigned_21_25, ap_ImmUnsigned_26_30}},
+	{RLWIMICC, 0xfc00000100000000, 0x5000000100000000, 0x0, // Rotate Left Word Immediate then Mask Insert M-form (rlwimi. RA,RS,SH,MB,ME)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_ImmUnsigned_21_25, ap_ImmUnsigned_26_30}},
+	{RLWINM, 0xfc00000100000000, 0x5400000000000000, 0x0, // Rotate Left Word Immediate then AND with Mask M-form (rlwinm RA,RS,SH,MB,ME)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_ImmUnsigned_21_25, ap_ImmUnsigned_26_30}},
+	{RLWINMCC, 0xfc00000100000000, 0x5400000100000000, 0x0, // Rotate Left Word Immediate then AND with Mask M-form (rlwinm. RA,RS,SH,MB,ME)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_16_20, ap_ImmUnsigned_21_25, ap_ImmUnsigned_26_30}},
+	{RLWNM, 0xfc00000100000000, 0x5c00000000000000, 0x0, // Rotate Left Word then AND with Mask M-form (rlwnm RA,RS,RB,MB,ME)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20, ap_ImmUnsigned_21_25, ap_ImmUnsigned_26_30}},
+	{RLWNMCC, 0xfc00000100000000, 0x5c00000100000000, 0x0, // Rotate Left Word then AND with Mask M-form (rlwnm. RA,RS,RB,MB,ME)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20, ap_ImmUnsigned_21_25, ap_ImmUnsigned_26_30}},
+	{SLW, 0xfc0007ff00000000, 0x7c00003000000000, 0x0, // Shift Left Word X-form (slw RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{SLWCC, 0xfc0007ff00000000, 0x7c00003100000000, 0x0, // Shift Left Word X-form (slw. RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{SRAW, 0xfc0007ff00000000, 0x7c00063000000000, 0x0, // Shift Right Algebraic Word X-form (sraw RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{SRAWCC, 0xfc0007ff00000000, 0x7c00063100000000, 0x0, // Shift Right Algebraic Word X-form (sraw. RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{SRAWI, 0xfc0007ff00000000, 0x7c00067000000000, 0x0, // Shift Right Algebraic Word Immediate X-form (srawi RA,RS,SH)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_16_20}},
+	{SRAWICC, 0xfc0007ff00000000, 0x7c00067100000000, 0x0, // Shift Right Algebraic Word Immediate X-form (srawi. RA,RS,SH)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_16_20}},
+	{SRW, 0xfc0007ff00000000, 0x7c00043000000000, 0x0, // Shift Right Word X-form (srw RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{SRWCC, 0xfc0007ff00000000, 0x7c00043100000000, 0x0, // Shift Right Word X-form (srw. RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{STB, 0xfc00000000000000, 0x9800000000000000, 0x0, // Store Byte D-form (stb RS,D(RA))
+		[6]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
+	{STBU, 0xfc00000000000000, 0x9c00000000000000, 0x0, // Store Byte with Update D-form (stbu RS,D(RA))
+		[6]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
+	{STBUX, 0xfc0007fe00000000, 0x7c0001ee00000000, 0x100000000, // Store Byte with Update Indexed X-form (stbux RS,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STBX, 0xfc0007fe00000000, 0x7c0001ae00000000, 0x100000000, // Store Byte Indexed X-form (stbx RS,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STFD, 0xfc00000000000000, 0xd800000000000000, 0x0, // Store Floating-Point Double D-form (stfd FRS,D(RA))
+		[6]*argField{ap_FPReg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
+	{STFDU, 0xfc00000000000000, 0xdc00000000000000, 0x0, // Store Floating-Point Double with Update D-form (stfdu FRS,D(RA))
+		[6]*argField{ap_FPReg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
+	{STFDUX, 0xfc0007fe00000000, 0x7c0005ee00000000, 0x100000000, // Store Floating-Point Double with Update Indexed X-form (stfdux FRS,RA,RB)
+		[6]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STFDX, 0xfc0007fe00000000, 0x7c0005ae00000000, 0x100000000, // Store Floating-Point Double Indexed X-form (stfdx FRS,RA,RB)
+		[6]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STFS, 0xfc00000000000000, 0xd000000000000000, 0x0, // Store Floating-Point Single D-form (stfs FRS,D(RA))
+		[6]*argField{ap_FPReg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
+	{STFSU, 0xfc00000000000000, 0xd400000000000000, 0x0, // Store Floating-Point Single with Update D-form (stfsu FRS,D(RA))
+		[6]*argField{ap_FPReg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
+	{STFSUX, 0xfc0007fe00000000, 0x7c00056e00000000, 0x100000000, // Store Floating-Point Single with Update Indexed X-form (stfsux FRS,RA,RB)
+		[6]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STFSX, 0xfc0007fe00000000, 0x7c00052e00000000, 0x100000000, // Store Floating-Point Single Indexed X-form (stfsx FRS,RA,RB)
+		[6]*argField{ap_FPReg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STH, 0xfc00000000000000, 0xb000000000000000, 0x0, // Store Halfword D-form (sth RS,D(RA))
+		[6]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
+	{STHBRX, 0xfc0007fe00000000, 0x7c00072c00000000, 0x100000000, // Store Halfword Byte-Reverse Indexed X-form (sthbrx RS,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STHU, 0xfc00000000000000, 0xb400000000000000, 0x0, // Store Halfword with Update D-form (sthu RS,D(RA))
+		[6]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
+	{STHUX, 0xfc0007fe00000000, 0x7c00036e00000000, 0x100000000, // Store Halfword with Update Indexed X-form (sthux RS,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STHX, 0xfc0007fe00000000, 0x7c00032e00000000, 0x100000000, // Store Halfword Indexed X-form (sthx RS,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STMW, 0xfc00000000000000, 0xbc00000000000000, 0x0, // Store Multiple Word D-form (stmw RS,D(RA))
+		[6]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
+	{STSWI, 0xfc0007fe00000000, 0x7c0005aa00000000, 0x100000000, // Store String Word Immediate X-form (stswi RS,RA,NB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_ImmUnsigned_16_20}},
+	{STSWX, 0xfc0007fe00000000, 0x7c00052a00000000, 0x100000000, // Store String Word Indexed X-form (stswx RS,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STW, 0xfc00000000000000, 0x9000000000000000, 0x0, // Store Word D-form (stw RS,D(RA))
+		[6]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
+	{STWBRX, 0xfc0007fe00000000, 0x7c00052c00000000, 0x100000000, // Store Word Byte-Reverse Indexed X-form (stwbrx RS,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STWU, 0xfc00000000000000, 0x9400000000000000, 0x0, // Store Word with Update D-form (stwu RS,D(RA))
+		[6]*argField{ap_Reg_6_10, ap_Offset_16_31, ap_Reg_11_15}},
+	{STWUX, 0xfc0007fe00000000, 0x7c00016e00000000, 0x100000000, // Store Word with Update Indexed X-form (stwux RS,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{STWX, 0xfc0007fe00000000, 0x7c00012e00000000, 0x100000000, // Store Word Indexed X-form (stwx RS,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{SUBFC, 0xfc0007ff00000000, 0x7c00001000000000, 0x0, // Subtract From Carrying XO-form (subfc RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{SUBFCCC, 0xfc0007ff00000000, 0x7c00001100000000, 0x0, // Subtract From Carrying XO-form (subfc. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{SUBFCO, 0xfc0007ff00000000, 0x7c00041000000000, 0x0, // Subtract From Carrying XO-form (subfco RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{SUBFCOCC, 0xfc0007ff00000000, 0x7c00041100000000, 0x0, // Subtract From Carrying XO-form (subfco. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{SUBFE, 0xfc0007ff00000000, 0x7c00011000000000, 0x0, // Subtract From Extended XO-form (subfe RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{SUBFECC, 0xfc0007ff00000000, 0x7c00011100000000, 0x0, // Subtract From Extended XO-form (subfe. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{SUBFEO, 0xfc0007ff00000000, 0x7c00051000000000, 0x0, // Subtract From Extended XO-form (subfeo RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{SUBFEOCC, 0xfc0007ff00000000, 0x7c00051100000000, 0x0, // Subtract From Extended XO-form (subfeo. RT,RA,RB)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{SUBFIC, 0xfc00000000000000, 0x2000000000000000, 0x0, // Subtract From Immediate Carrying D-form (subfic RT,RA,SI)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15, ap_ImmSigned_16_31}},
+	{SUBFME, 0xfc0007ff00000000, 0x7c0001d000000000, 0xf80000000000, // Subtract From Minus One Extended XO-form (subfme RT,RA)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15}},
+	{SUBFMECC, 0xfc0007ff00000000, 0x7c0001d100000000, 0xf80000000000, // Subtract From Minus One Extended XO-form (subfme. RT,RA)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15}},
+	{SUBFMEO, 0xfc0007ff00000000, 0x7c0005d000000000, 0xf80000000000, // Subtract From Minus One Extended XO-form (subfmeo RT,RA)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15}},
+	{SUBFMEOCC, 0xfc0007ff00000000, 0x7c0005d100000000, 0xf80000000000, // Subtract From Minus One Extended XO-form (subfmeo. RT,RA)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15}},
+	{SUBFZE, 0xfc0007ff00000000, 0x7c00019000000000, 0xf80000000000, // Subtract From Zero Extended XO-form (subfze RT,RA)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15}},
+	{SUBFZECC, 0xfc0007ff00000000, 0x7c00019100000000, 0xf80000000000, // Subtract From Zero Extended XO-form (subfze. RT,RA)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15}},
+	{SUBFZEO, 0xfc0007ff00000000, 0x7c00059000000000, 0xf80000000000, // Subtract From Zero Extended XO-form (subfzeo RT,RA)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15}},
+	{SUBFZEOCC, 0xfc0007ff00000000, 0x7c00059100000000, 0xf80000000000, // Subtract From Zero Extended XO-form (subfzeo. RT,RA)
+		[6]*argField{ap_Reg_6_10, ap_Reg_11_15}},
+	{SYNC, 0xfc0007fe00000000, 0x7c0004ac00000000, 0x31cf80100000000, // Synchronize X-form (sync L,SC)
+		[6]*argField{ap_ImmUnsigned_8_10, ap_ImmUnsigned_14_15}},
+	{TLBIE, 0xfc0007fe00000000, 0x7c00026400000000, 0x10000100000000, // TLB Invalidate Entry X-form (tlbie RB,RS,RIC,PRS,R)
+		[6]*argField{ap_Reg_16_20, ap_Reg_6_10, ap_ImmUnsigned_12_13, ap_ImmUnsigned_14_14, ap_ImmUnsigned_15_15}},
+	{TW, 0xfc0007fe00000000, 0x7c00000800000000, 0x100000000, // Trap Word X-form (tw TO,RA,RB)
+		[6]*argField{ap_ImmUnsigned_6_10, ap_Reg_11_15, ap_Reg_16_20}},
+	{TWI, 0xfc00000000000000, 0xc00000000000000, 0x0, // Trap Word Immediate D-form (twi TO,RA,SI)
+		[6]*argField{ap_ImmUnsigned_6_10, ap_Reg_11_15, ap_ImmSigned_16_31}},
+	{XOR, 0xfc0007ff00000000, 0x7c00027800000000, 0x0, // XOR X-form (xor RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{XORCC, 0xfc0007ff00000000, 0x7c00027900000000, 0x0, // XOR X-form (xor. RA,RS,RB)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_Reg_16_20}},
+	{XORI, 0xfc00000000000000, 0x6800000000000000, 0x0, // XOR Immediate D-form (xori RA,RS,UI)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_16_31}},
+	{XORIS, 0xfc00000000000000, 0x6c00000000000000, 0x0, // XOR Immediate Shifted D-form (xoris RA,RS,UI)
+		[6]*argField{ap_Reg_11_15, ap_Reg_6_10, ap_ImmUnsigned_16_31}},
 }
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 69d10d074a..93d30db335 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -18,8 +18,8 @@ github.com/google/pprof/third_party/svgpan
 # github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639
 ## explicit
 github.com/ianlancetaylor/demangle
-# golang.org/x/arch v0.0.0-20210308155006-05f8f0431f72
-## explicit; go 1.11
+# golang.org/x/arch v0.0.0-20210502124803-cbf565b21d1e
+## explicit; go 1.17
 golang.org/x/arch/arm/armasm
 golang.org/x/arch/arm64/arm64asm
 golang.org/x/arch/ppc64/ppc64asm
-- 
GitLab


From 30674ae91b7fa20b9f68e1e79d8d7cd8ead495cd Mon Sep 17 00:00:00 2001
From: Lynn Boger <laboger@linux.vnet.ibm.com>
Date: Fri, 30 Apr 2021 10:21:18 -0500
Subject: [PATCH 1918/2400] cmd/dist: disable misc/cgo/testsanitizers on
 ppc64le

A while back in this release the sanitizer tests were enabled
for ppc64le, where previously they were never run. This
uncovered some errors in these tests on ppc64le. One linker
fix was made but there are still bugs in how tsan is made to
work within the code, especially in how signals are enabled
with cgo.

Some attempts were made to make this work but intermittent
failures continue to happen with the Trybots so I am just
going to disable this test for ppc64le within cmd/dist.

Updates #45040

Change-Id: I5392368ccecd4079ef568d0c645c9f7c94016d99
Reviewed-on: https://go-review.googlesource.com/c/go/+/315430
Run-TryBot: Lynn Boger <laboger@linux.vnet.ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/dist/test.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go
index 8b1ec458ed..33fabd3554 100644
--- a/src/cmd/dist/test.go
+++ b/src/cmd/dist/test.go
@@ -749,8 +749,9 @@ func (t *tester) registerTests() {
 		if gohostos == "linux" && goarch == "amd64" {
 			t.registerTest("testasan", "../misc/cgo/testasan", "go", "run", ".")
 		}
-		if goos == "linux" {
+		if goos == "linux" && goarch != "ppc64le" {
 			// because syscall.SysProcAttri struct used in misc/cgo/testsanitizers is only built on linux.
+			// Some inconsistent failures happen on ppc64le so disable for now.
 			t.registerHostTest("testsanitizers", "../misc/cgo/testsanitizers", "misc/cgo/testsanitizers", ".")
 		}
 		if t.hasBash() && goos != "android" && !t.iOS() && gohostos != "windows" {
-- 
GitLab


From 9ed736ac2a99aa2e7ef7d8bed3b01ca8b20a6f80 Mon Sep 17 00:00:00 2001
From: Lynn Boger <laboger@linux.vnet.ibm.com>
Date: Thu, 29 Apr 2021 16:07:25 -0500
Subject: [PATCH 1919/2400] cmd/link/internal: fix use of DynlinkingGo with
 ppc64le trampolines

When creating programs with large text sections on ppc64le,
trampolines are needed for calls that are too far; however
they are not created if the code is generated such that the TOC
register r2 is initialized and maintained in the code because
then the external linker can create the trampolines. Previously
the function DynlinkingGo was used to determine this but in the
case where plugins are used, this could return true even though
r2 is not valid.

To fix this problem I've added a new function r2Valid which returns
true when the build options indicate that the r2 is
initialized and maintained. Because of the ways that
DynlinkingGo is used I wanted to maintain its previous
behavior.

Fixes #45850

Change-Id: I6d902eba6ad41757aa6474948b79acdbd479cb38
Reviewed-on: https://go-review.googlesource.com/c/go/+/315289
Trust: Lynn Boger <laboger@linux.vnet.ibm.com>
Run-TryBot: Lynn Boger <laboger@linux.vnet.ibm.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/link/internal/ppc64/asm.go | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/cmd/link/internal/ppc64/asm.go b/src/cmd/link/internal/ppc64/asm.go
index 06385026d9..b877864b75 100644
--- a/src/cmd/link/internal/ppc64/asm.go
+++ b/src/cmd/link/internal/ppc64/asm.go
@@ -651,6 +651,16 @@ func archrelocaddr(ldr *loader.Loader, target *ld.Target, syms *ld.ArchSyms, r l
 	return int64(o2)<<32 | int64(o1)
 }
 
+// Determine if the code was compiled so that the TOC register R2 is initialized and maintained
+func r2Valid(ctxt *ld.Link) bool {
+	switch ctxt.BuildMode {
+	case ld.BuildModeCArchive, ld.BuildModeCShared, ld.BuildModePIE, ld.BuildModeShared, ld.BuildModePlugin:
+		return true
+	}
+	// -linkshared option
+	return ctxt.IsSharedGoLink()
+}
+
 // resolve direct jump relocation r in s, and add trampoline if necessary
 func trampoline(ctxt *ld.Link, ldr *loader.Loader, ri int, rs, s loader.Sym) {
 
@@ -658,7 +668,7 @@ func trampoline(ctxt *ld.Link, ldr *loader.Loader, ri int, rs, s loader.Sym) {
 	// For internal linking, trampolines are always created for long calls.
 	// For external linking, the linker can insert a call stub to handle a long call, but depends on having the TOC address in
 	// r2.  For those build modes with external linking where the TOC address is not maintained in r2, trampolines must be created.
-	if ctxt.IsExternal() && (ctxt.DynlinkingGo() || ctxt.BuildMode == ld.BuildModeCArchive || ctxt.BuildMode == ld.BuildModeCShared || ctxt.BuildMode == ld.BuildModePIE) {
+	if ctxt.IsExternal() && r2Valid(ctxt) {
 		// No trampolines needed since r2 contains the TOC
 		return
 	}
@@ -712,7 +722,7 @@ func trampoline(ctxt *ld.Link, ldr *loader.Loader, ri int, rs, s loader.Sym) {
 				}
 			}
 			if ldr.SymType(tramp) == 0 {
-				if ctxt.DynlinkingGo() || ctxt.BuildMode == ld.BuildModeCArchive || ctxt.BuildMode == ld.BuildModeCShared || ctxt.BuildMode == ld.BuildModePIE {
+				if r2Valid(ctxt) {
 					// Should have returned for above cases
 					ctxt.Errorf(s, "unexpected trampoline for shared or dynamic linking")
 				} else {
-- 
GitLab


From 844e1fc6f1d0dacd92534dba7f8d71f377017742 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Mon, 3 May 2021 02:19:10 +0700
Subject: [PATCH 1920/2400] cmd/compile: make typecheckaste correctly report
 invalid use of "..."

Currently, when "..." argument is passed to non-variadic function, the
compiler may skip that check, but continue checking whether the number
of arguments matches the function signature.

That causes the sanity check which was added in CL 255241 trigger.

Instead, we should report an invalid use of "...", which matches the
behavior of new type checker and go/types.

Fixes #45913

Change-Id: Icbb254052cbcd756bbd41f966c2c8e316c44420f
Reviewed-on: https://go-review.googlesource.com/c/go/+/315796
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/typecheck/typecheck.go |  5 +++++
 test/ddd1.go                                    |  2 +-
 test/fixedbugs/issue45913.go                    | 17 +++++++++++++++++
 3 files changed, 23 insertions(+), 1 deletion(-)
 create mode 100644 test/fixedbugs/issue45913.go

diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 1650144375..4c5472137a 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -1330,6 +1330,9 @@ func typecheckaste(op ir.Op, call ir.Node, isddd bool, tstruct *types.Type, nl i
 	n1 := tstruct.NumFields()
 	n2 := len(nl)
 	if !hasddd(tstruct) {
+		if isddd {
+			goto invalidddd
+		}
 		if n2 > n1 {
 			goto toomany
 		}
@@ -1395,6 +1398,8 @@ func typecheckaste(op ir.Op, call ir.Node, isddd bool, tstruct *types.Type, nl i
 	if i < len(nl) {
 		goto toomany
 	}
+
+invalidddd:
 	if isddd {
 		if call != nil {
 			base.Errorf("invalid use of ... in call to %v", call)
diff --git a/test/ddd1.go b/test/ddd1.go
index 01b9c0eadb..ad49b347f4 100644
--- a/test/ddd1.go
+++ b/test/ddd1.go
@@ -29,7 +29,7 @@ var (
 	_ = sum(tuple())
 	_ = sum(tuple()...) // ERROR "multiple-value"
 	_ = sum3(tuple())
-	_ = sum3(tuple()...) // ERROR "multiple-value"
+	_ = sum3(tuple()...) // ERROR "multiple-value" ERROR "invalid use of .*[.][.][.]"
 )
 
 type T []T
diff --git a/test/fixedbugs/issue45913.go b/test/fixedbugs/issue45913.go
new file mode 100644
index 0000000000..aa86028c51
--- /dev/null
+++ b/test/fixedbugs/issue45913.go
@@ -0,0 +1,17 @@
+// errorcheck
+
+// Copyright 2021 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 (
+	"fmt"
+)
+
+func f(s1, s2 string) { fmt.Printf("%s %s", s1, s2) }
+
+func main() {
+	f([2]string{"a", "b"}...) // ERROR "invalid use of .*[.][.][.]|cannot use [.][.][.] in call to non-variadic"
+}
-- 
GitLab


From 8327d2150f97528dc6a3090ddee99db0e9872212 Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Fri, 30 Apr 2021 19:45:11 -0400
Subject: [PATCH 1921/2400] cmd/compile: add traceback argument info to ABI0
 assembly functions

For ABI0 assembly functions that have Go declarations, generate
traceback argument info and attach it to the assembly functions.
So we can print argument in tracebacks if e.g. assembly function
panics.

Only do this for ABI0 functions, as for ABIInternal assembly
functions it is likely that they never spill arguments to memory.

Change-Id: I7e601ccd9aded5e6af2f02be975bf81ff9948f4d
Reviewed-on: https://go-review.googlesource.com/c/go/+/315870
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/gc/compile.go |  6 +++
 src/cmd/compile/internal/ssagen/ssa.go | 38 +++++++------
 src/cmd/internal/obj/plist.go          | 75 +++++++++++++++-----------
 3 files changed, 71 insertions(+), 48 deletions(-)

diff --git a/src/cmd/compile/internal/gc/compile.go b/src/cmd/compile/internal/gc/compile.go
index a71684a859..a7380510d1 100644
--- a/src/cmd/compile/internal/gc/compile.go
+++ b/src/cmd/compile/internal/gc/compile.go
@@ -13,10 +13,12 @@ import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/liveness"
+	"cmd/compile/internal/objw"
 	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/compile/internal/walk"
+	"cmd/internal/obj"
 )
 
 // "Portable" code generation.
@@ -47,6 +49,10 @@ func enqueueFunc(fn *ir.Func) {
 		a := ssagen.AbiForBodylessFuncStackMap(fn)
 		abiInfo := a.ABIAnalyzeFuncType(fn.Type().FuncType()) // abiInfo has spill/home locations for wrapper
 		liveness.WriteFuncMap(fn, abiInfo)
+		if fn.ABI == obj.ABI0 {
+			x := ssagen.EmitArgInfo(fn, abiInfo)
+			objw.Global(x, int32(len(x.P)), obj.RODATA|obj.LOCAL)
+		}
 		return
 	}
 
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 0d4e3264ba..b8f84f5712 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -6563,15 +6563,27 @@ func (s *State) DebugFriendlySetPosFrom(v *ssa.Value) {
 }
 
 // emit argument info (locations on stack) for traceback.
-func emitArgInfo(e *ssafn, pp *objw.Progs) {
+func emitArgInfo(e *ssafn, f *ssa.Func, pp *objw.Progs) {
 	ft := e.curfn.Type()
 	if ft.NumRecvs() == 0 && ft.NumParams() == 0 {
 		return
 	}
 
-	x := base.Ctxt.Lookup(fmt.Sprintf("%s.arginfo%d", e.curfn.LSym.Name, e.curfn.LSym.ABI()))
+	x := EmitArgInfo(e.curfn, f.OwnAux.ABIInfo())
 	e.curfn.LSym.Func().ArgInfo = x
 
+	// Emit a funcdata pointing at the arg info data.
+	p := pp.Prog(obj.AFUNCDATA)
+	p.From.SetConst(objabi.FUNCDATA_ArgInfo)
+	p.To.Type = obj.TYPE_MEM
+	p.To.Name = obj.NAME_EXTERN
+	p.To.Sym = x
+}
+
+// emit argument info (locations on stack) of f for traceback.
+func EmitArgInfo(f *ir.Func, abiInfo *abi.ABIParamResultInfo) *obj.LSym {
+	x := base.Ctxt.Lookup(fmt.Sprintf("%s.arginfo%d", f.LSym.Name, f.ABI))
+
 	PtrSize := int64(types.PtrSize)
 
 	isAggregate := func(t *types.Type) bool {
@@ -6696,27 +6708,19 @@ func emitArgInfo(e *ssafn, pp *objw.Progs) {
 	}
 
 	c := true
-outer:
-	for _, fs := range &types.RecvsParams {
-		for _, a := range fs(ft).Fields().Slice() {
-			if !c {
-				writebyte(_dotdotdot)
-				break outer
-			}
-			c = visitType(a.Offset, a.Type, 0)
+	for _, a := range abiInfo.InParams() {
+		if !c {
+			writebyte(_dotdotdot)
+			break
 		}
+		c = visitType(a.FrameOffset(abiInfo), a.Type, 0)
 	}
 	writebyte(_endSeq)
 	if wOff > maxLen {
 		base.Fatalf("ArgInfo too large")
 	}
 
-	// Emit a funcdata pointing at the arg info data.
-	p := pp.Prog(obj.AFUNCDATA)
-	p.From.SetConst(objabi.FUNCDATA_ArgInfo)
-	p.To.Type = obj.TYPE_MEM
-	p.To.Name = obj.NAME_EXTERN
-	p.To.Sym = x
+	return x
 }
 
 // genssa appends entries to pp for each instruction in f.
@@ -6727,7 +6731,7 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 	e := f.Frontend().(*ssafn)
 
 	s.livenessMap, s.partLiveArgs = liveness.Compute(e.curfn, f, e.stkptrsize, pp)
-	emitArgInfo(e, pp)
+	emitArgInfo(e, f, pp)
 
 	openDeferInfo := e.curfn.LSym.Func().OpenCodedDeferInfo
 	if openDeferInfo != nil {
diff --git a/src/cmd/internal/obj/plist.go b/src/cmd/internal/obj/plist.go
index 54b035bb96..6beb4dd94c 100644
--- a/src/cmd/internal/obj/plist.go
+++ b/src/cmd/internal/obj/plist.go
@@ -75,38 +75,51 @@ func Flushplist(ctxt *Link, plist *Plist, newprog ProgAlloc, myimportpath string
 		newprog = ctxt.NewProg
 	}
 
-	// Add reference to Go arguments for C or assembly functions without them.
-	for _, s := range text {
-		if !strings.HasPrefix(s.Name, "\"\".") {
-			continue
-		}
-		if s.ABIWrapper() {
-			// Don't create an args_stackmap symbol reference for an ABI
-			// wrapper function
-			continue
-		}
-		// The current args_stackmap generation in the compiler assumes
-		// that the function in question is ABI0, so avoid introducing
-		// an args_stackmap reference if the func is not ABI0 (better to
-		// have no stackmap than an incorrect/lying stackmap).
-		if s.ABI() != ABI0 {
-			continue
-		}
-		found := false
-		for p := s.Func().Text; p != nil; p = p.Link {
-			if p.As == AFUNCDATA && p.From.Type == TYPE_CONST && p.From.Offset == objabi.FUNCDATA_ArgsPointerMaps {
-				found = true
-				break
+	// Add reference to Go arguments for assembly functions without them.
+	if ctxt.IsAsm {
+		for _, s := range text {
+			if !strings.HasPrefix(s.Name, "\"\".") {
+				continue
+			}
+			// The current args_stackmap generation in the compiler assumes
+			// that the function in question is ABI0, so avoid introducing
+			// an args_stackmap reference if the func is not ABI0 (better to
+			// have no stackmap than an incorrect/lying stackmap).
+			if s.ABI() != ABI0 {
+				continue
+			}
+			foundArgMap, foundArgInfo := false, false
+			for p := s.Func().Text; p != nil; p = p.Link {
+				if p.As == AFUNCDATA && p.From.Type == TYPE_CONST {
+					if p.From.Offset == objabi.FUNCDATA_ArgsPointerMaps {
+						foundArgMap = true
+					}
+					if p.From.Offset == objabi.FUNCDATA_ArgInfo {
+						foundArgInfo = true
+					}
+					if foundArgMap && foundArgInfo {
+						break
+					}
+				}
+			}
+			if !foundArgMap {
+				p := Appendp(s.Func().Text, newprog)
+				p.As = AFUNCDATA
+				p.From.Type = TYPE_CONST
+				p.From.Offset = objabi.FUNCDATA_ArgsPointerMaps
+				p.To.Type = TYPE_MEM
+				p.To.Name = NAME_EXTERN
+				p.To.Sym = ctxt.LookupDerived(s, s.Name+".args_stackmap")
+			}
+			if !foundArgInfo {
+				p := Appendp(s.Func().Text, newprog)
+				p.As = AFUNCDATA
+				p.From.Type = TYPE_CONST
+				p.From.Offset = objabi.FUNCDATA_ArgInfo
+				p.To.Type = TYPE_MEM
+				p.To.Name = NAME_EXTERN
+				p.To.Sym = ctxt.LookupDerived(s, fmt.Sprintf("%s.arginfo%d", s.Name, s.ABI()))
 			}
-		}
-		if !found {
-			p := Appendp(s.Func().Text, newprog)
-			p.As = AFUNCDATA
-			p.From.Type = TYPE_CONST
-			p.From.Offset = objabi.FUNCDATA_ArgsPointerMaps
-			p.To.Type = TYPE_MEM
-			p.To.Name = NAME_EXTERN
-			p.To.Sym = ctxt.LookupDerived(s, s.Name+".args_stackmap")
 		}
 	}
 
-- 
GitLab


From be1da9cdeecba15d0f68b4dcc145bcc77c0c4ace Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Sat, 1 May 2021 15:00:03 -0400
Subject: [PATCH 1922/2400] cmd/link: unify text segment write

Currently we have two code paths of writing the text segment. They
are semantically the same:

- if we split text sections, we write all ".text" sections as
  text and the the rest as data.
- if we do not split text sections, we write the first section
  as text and the rest as data. The first section is named ".text"
  and is the only one in this case.

Unify the code.

Change-Id: Ic639eed625615be3c8a8d41f5b47e901552f587a
Reviewed-on: https://go-review.googlesource.com/c/go/+/316049
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/ld/asmb.go   | 23 ++++++-----------------
 src/cmd/link/internal/ld/lib.go    |  3 ---
 src/cmd/link/internal/ppc64/obj.go | 13 ++++++-------
 3 files changed, 12 insertions(+), 27 deletions(-)

diff --git a/src/cmd/link/internal/ld/asmb.go b/src/cmd/link/internal/ld/asmb.go
index fda0439455..3754669555 100644
--- a/src/cmd/link/internal/ld/asmb.go
+++ b/src/cmd/link/internal/ld/asmb.go
@@ -29,8 +29,6 @@ func asmb(ctxt *Link) {
 	}
 
 	var wg sync.WaitGroup
-	sect := Segtext.Sections[0]
-	offset := sect.Vaddr - Segtext.Vaddr + Segtext.Fileoff
 	f := func(ctxt *Link, out *OutBuf, start, length int64) {
 		pad := thearch.CodePad
 		if pad == nil {
@@ -39,23 +37,14 @@ func asmb(ctxt *Link) {
 		CodeblkPad(ctxt, out, start, length, pad)
 	}
 
-	if !thearch.WriteTextBlocks {
-		writeParallel(&wg, f, ctxt, offset, sect.Vaddr, sect.Length)
-		for _, sect := range Segtext.Sections[1:] {
-			offset := sect.Vaddr - Segtext.Vaddr + Segtext.Fileoff
+	for _, sect := range Segtext.Sections {
+		offset := sect.Vaddr - Segtext.Vaddr + Segtext.Fileoff
+		// Handle text sections with Codeblk
+		if sect.Name == ".text" {
+			writeParallel(&wg, f, ctxt, offset, sect.Vaddr, sect.Length)
+		} else {
 			writeParallel(&wg, datblk, ctxt, offset, sect.Vaddr, sect.Length)
 		}
-	} else {
-		// TODO why can't we handle all sections this way?
-		for _, sect := range Segtext.Sections {
-			offset := sect.Vaddr - Segtext.Vaddr + Segtext.Fileoff
-			// Handle additional text sections with Codeblk
-			if sect.Name == ".text" {
-				writeParallel(&wg, f, ctxt, offset, sect.Vaddr, sect.Length)
-			} else {
-				writeParallel(&wg, datblk, ctxt, offset, sect.Vaddr, sect.Length)
-			}
-		}
 	}
 
 	if Segrodata.Filelen > 0 {
diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index fd687df9ef..e8f001ba8e 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -203,9 +203,6 @@ type Arch struct {
 	// are padded with zeros.
 	CodePad []byte
 
-	// Set to true to write all text blocks in with CodeBlkWrite
-	WriteTextBlocks bool
-
 	// Plan 9 variables.
 	Plan9Magic  uint32
 	Plan9_64Bit bool
diff --git a/src/cmd/link/internal/ppc64/obj.go b/src/cmd/link/internal/ppc64/obj.go
index f56fa76b5b..b6d5ad92af 100644
--- a/src/cmd/link/internal/ppc64/obj.go
+++ b/src/cmd/link/internal/ppc64/obj.go
@@ -44,13 +44,12 @@ func Init() (*sys.Arch, ld.Arch) {
 	}
 
 	theArch := ld.Arch{
-		Funcalign:       funcAlign,
-		Maxalign:        maxAlign,
-		Minalign:        minAlign,
-		Dwarfregsp:      dwarfRegSP,
-		Dwarfreglr:      dwarfRegLR,
-		TrampLimit:      0x1c00000,
-		WriteTextBlocks: true,
+		Funcalign:  funcAlign,
+		Maxalign:   maxAlign,
+		Minalign:   minAlign,
+		Dwarfregsp: dwarfRegSP,
+		Dwarfreglr: dwarfRegLR,
+		TrampLimit: 0x1c00000,
 
 		Adddynrel:        adddynrel,
 		Archinit:         archinit,
-- 
GitLab


From 7b768d43d0f0e3e734369496bb1caa409d4bd0bb Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Fri, 30 Apr 2021 17:23:35 -0700
Subject: [PATCH 1923/2400] math: replace float32/64 extrema with exact
 expressions

Follow-up on https://golang.org/cl/315170.

Updates #44057.
Updates #44058.

Change-Id: I0b071e8ee7a1c97aae2436945cc9583cde3b40b0
Reviewed-on: https://go-review.googlesource.com/c/go/+/315969
Trust: Robert Griesemer <gri@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 api/except.txt    | 1 +
 src/math/const.go | 8 ++++----
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/api/except.txt b/api/except.txt
index f5a7aa854e..14fe7785fa 100644
--- a/api/except.txt
+++ b/api/except.txt
@@ -1,5 +1,6 @@
 pkg encoding/json, method (*RawMessage) MarshalJSON() ([]uint8, error)
 pkg math, const MaxFloat64 = 1.79769e+308  // 179769313486231570814527423731704356798100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+pkg math, const SmallestNonzeroFloat32 = 1.4013e-45  // 17516230804060213386546619791123951641/12500000000000000000000000000000000000000000000000000000000000000000000000000000000
 pkg math, const SmallestNonzeroFloat64 = 4.94066e-324  // 4940656458412465441765687928682213723651/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
 pkg math/big, const MaxBase = 36
 pkg math/big, type Word uintptr
diff --git a/src/math/const.go b/src/math/const.go
index 441b295ed4..31954b0cae 100644
--- a/src/math/const.go
+++ b/src/math/const.go
@@ -28,11 +28,11 @@ const (
 // Max is the largest finite value representable by the type.
 // SmallestNonzero is the smallest positive, non-zero value representable by the type.
 const (
-	MaxFloat32             = 3.40282346638528859811704183484516925440e+38  // 2**127 * (2**24 - 1) / 2**23
-	SmallestNonzeroFloat32 = 1.401298464324817070923729583289916131280e-45 // 1 / 2**(127 - 1 + 23)
+	MaxFloat32             = 0x1p127 * (1 + (1 - 0x1p-23)) // 3.40282346638528859811704183484516925440e+38
+	SmallestNonzeroFloat32 = 0x1p-126 * 0x1p-23            // 1.401298464324817070923729583289916131280e-45
 
-	MaxFloat64             = 1.79769313486231570814527423731704356798070e+308   // 2**1023 * (2**53 - 1) / 2**52
-	SmallestNonzeroFloat64 = 4.9406564584124654417656879286822137236505980e-324 // 1 / 2**(1023 - 1 + 52)
+	MaxFloat64             = 0x1p1023 * (1 + (1 - 0x1p-52)) // 1.79769313486231570814527423731704356798070e+308
+	SmallestNonzeroFloat64 = 0x1p-1022 * 0x1p-52            // 4.9406564584124654417656879286822137236505980e-324
 )
 
 // Integer limit values.
-- 
GitLab


From d75fbac54d34484041a5ecb0b65f298b821cd963 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Sat, 1 May 2021 13:57:00 -0700
Subject: [PATCH 1924/2400] cmd/compile:  add edge from lock rank edge from
 forceGC to traceStackTab

This edge can happen when forcegchelper() calls
goparkunlock(&forcegc.lock, ...) while holding the forcegc lock.
goparkunlock() eventually calls park_m(). In park_m(), traceGoPark()
(which leads to (*traceStackTable).put() and acquires the traceStackTab
lock) can be called before the forcegc lock is released.

Fixes #45774

Change-Id: If0fceab596712eb9ec0b9b47326778bc0ff80913
Reviewed-on: https://go-review.googlesource.com/c/go/+/316029
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Trust: Carlos Amedee <carlos@golang.org>
---
 src/runtime/lockrank.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/lockrank.go b/src/runtime/lockrank.go
index b600c2132b..dde9f7c21a 100644
--- a/src/runtime/lockrank.go
+++ b/src/runtime/lockrank.go
@@ -217,7 +217,7 @@ var lockPartialOrder [][]lockRank = [][]lockRank{
 	lockRankGcBitsArenas:  {lockRankSysmon, lockRankScavenge, lockRankAssistQueue, lockRankCpuprof, lockRankSched, lockRankAllg, lockRankTimers, lockRankItab, lockRankReflectOffs, lockRankHchan, lockRankNotifyList, lockRankTraceBuf, lockRankTraceStrings},
 	lockRankRoot:          {},
 	lockRankTrace:         {lockRankSysmon, lockRankScavenge, lockRankForcegc, lockRankAssistQueue, lockRankSweep, lockRankSched, lockRankHchan, lockRankTraceBuf, lockRankTraceStrings, lockRankRoot},
-	lockRankTraceStackTab: {lockRankScavenge, lockRankSweepWaiters, lockRankAssistQueue, lockRankSweep, lockRankSched, lockRankAllg, lockRankTimers, lockRankHchan, lockRankFin, lockRankNotifyList, lockRankTraceBuf, lockRankTraceStrings, lockRankRoot, lockRankTrace},
+	lockRankTraceStackTab: {lockRankScavenge, lockRankForcegc, lockRankSweepWaiters, lockRankAssistQueue, lockRankSweep, lockRankSched, lockRankAllg, lockRankTimers, lockRankHchan, lockRankFin, lockRankNotifyList, lockRankTraceBuf, lockRankTraceStrings, lockRankRoot, lockRankTrace},
 	lockRankNetpollInit:   {lockRankTimers},
 
 	lockRankRwmutexW: {},
-- 
GitLab


From 472f519fe26652af2fcef6121e259d7f193b27cf Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Mon, 3 May 2021 09:32:22 -0400
Subject: [PATCH 1925/2400] cmd/compile/internal/ssagen: fix misleading comment

Fix up a slightly stale comment in the part of ssa generation that
zeros ambiguously live variables: with the advent of the register ABI,
the ir.Func "Dcl" slice is no longer entirely sorted by frame offset,
although this is still the case for the local vars in Dcl.

Change-Id: I633f43d16f0d4e0b444193a6edb6b2aa1154eea7
Reviewed-on: https://go-review.googlesource.com/c/go/+/316309
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssagen/ssa.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index b8f84f5712..85ebf62e98 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -7148,7 +7148,8 @@ func defframe(s *State, e *ssafn, f *ssa.Func) {
 	// keep track of which helper registers have been zeroed.
 	var state uint32
 
-	// Iterate through declarations. They are sorted in decreasing Xoffset order.
+	// Iterate through declarations. Autos are sorted in decreasing
+	// frame offset order.
 	for _, n := range e.curfn.Dcl {
 		if !n.Needzero() {
 			continue
-- 
GitLab


From 169155d61ede128caa8452bdff3ce9995287c138 Mon Sep 17 00:00:00 2001
From: Alessandro Arzilli <alessandro.arzilli@gmail.com>
Date: Sat, 1 May 2021 18:45:57 +0200
Subject: [PATCH 1926/2400] cmd/compile: preserve argument order in debug_info

When regabi is used sorting by stack offset will not preserve the order
of function arguments. Trust that variables are already ordered
correctly when creating debug_info entries.

Fixes #45720

Change-Id: I1dbdd185975273f70244a23302d34f082347603d
Reviewed-on: https://go-review.googlesource.com/c/go/+/315280
Reviewed-by: Than McIntosh <thanm@google.com>
Trust: Jeremy Faller <jeremy@golang.org>
---
 src/cmd/compile/internal/dwarfgen/scope.go | 28 +++++++++++++++++++---
 1 file changed, 25 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/dwarfgen/scope.go b/src/cmd/compile/internal/dwarfgen/scope.go
index 4957e24e44..b4ae69e96f 100644
--- a/src/cmd/compile/internal/dwarfgen/scope.go
+++ b/src/cmd/compile/internal/dwarfgen/scope.go
@@ -36,7 +36,7 @@ func assembleScopes(fnsym *obj.LSym, fn *ir.Func, dwarfVars []*dwarf.Var, varSco
 		dwarfScopes[i+1].Parent = int32(parent)
 	}
 
-	scopeVariables(dwarfVars, varScopes, dwarfScopes)
+	scopeVariables(dwarfVars, varScopes, dwarfScopes, fnsym.ABI() != obj.ABI0)
 	if fnsym.Func().Text != nil {
 		scopePCs(fnsym, fn.Marks, dwarfScopes)
 	}
@@ -44,8 +44,12 @@ func assembleScopes(fnsym *obj.LSym, fn *ir.Func, dwarfVars []*dwarf.Var, varSco
 }
 
 // scopeVariables assigns DWARF variable records to their scopes.
-func scopeVariables(dwarfVars []*dwarf.Var, varScopes []ir.ScopeID, dwarfScopes []dwarf.Scope) {
-	sort.Stable(varsByScopeAndOffset{dwarfVars, varScopes})
+func scopeVariables(dwarfVars []*dwarf.Var, varScopes []ir.ScopeID, dwarfScopes []dwarf.Scope, regabi bool) {
+	if regabi {
+		sort.Stable(varsByScope{dwarfVars, varScopes})
+	} else {
+		sort.Stable(varsByScopeAndOffset{dwarfVars, varScopes})
+	}
 
 	i0 := 0
 	for i := range dwarfVars {
@@ -112,3 +116,21 @@ func (v varsByScopeAndOffset) Swap(i, j int) {
 	v.vars[i], v.vars[j] = v.vars[j], v.vars[i]
 	v.scopes[i], v.scopes[j] = v.scopes[j], v.scopes[i]
 }
+
+type varsByScope struct {
+	vars   []*dwarf.Var
+	scopes []ir.ScopeID
+}
+
+func (v varsByScope) Len() int {
+	return len(v.vars)
+}
+
+func (v varsByScope) Less(i, j int) bool {
+	return v.scopes[i] < v.scopes[j]
+}
+
+func (v varsByScope) Swap(i, j int) {
+	v.vars[i], v.vars[j] = v.vars[j], v.vars[i]
+	v.scopes[i], v.scopes[j] = v.scopes[j], v.scopes[i]
+}
-- 
GitLab


From b5842308892e0c4f9e772a42d5826f6f62f57be3 Mon Sep 17 00:00:00 2001
From: Roland Shoemaker <roland@golang.org>
Date: Mon, 26 Apr 2021 20:10:56 -0700
Subject: [PATCH 1927/2400] net/http: use relative path in Location redirect

If the cleaned path did not match the requested path, ServeMux.Handler
would return a Location header which reflected the hostname in the
request, possibly leading to an incorrect redirect. Instead the
Location header should be relative, like the other cases in
ServeMux.Handler.

Change-Id: I2c220d925e708061bc128f0bdc96cca7a32764d3
Reviewed-on: https://go-review.googlesource.com/c/go/+/313950
Trust: Roland Shoemaker <roland@golang.org>
Trust: Katie Hockman <katie@golang.org>
Run-TryBot: Roland Shoemaker <roland@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
---
 src/net/http/serve_test.go | 17 +++++++++++++++++
 src/net/http/server.go     |  5 ++---
 2 files changed, 19 insertions(+), 3 deletions(-)

diff --git a/src/net/http/serve_test.go b/src/net/http/serve_test.go
index f8687416fe..a9714682c7 100644
--- a/src/net/http/serve_test.go
+++ b/src/net/http/serve_test.go
@@ -6507,3 +6507,20 @@ func TestDisableKeepAliveUpgrade(t *testing.T) {
 		t.Fatalf("unexpected value read from body:\ngot: %q\nwant: %q", b, "hello")
 	}
 }
+
+func TestMuxRedirectRelative(t *testing.T) {
+	setParallel(t)
+	req, err := ReadRequest(bufio.NewReader(strings.NewReader("GET http://example.com HTTP/1.1\r\nHost: test\r\n\r\n")))
+	if err != nil {
+		t.Errorf("%s", err)
+	}
+	mux := NewServeMux()
+	resp := httptest.NewRecorder()
+	mux.ServeHTTP(resp, req)
+	if got, want := resp.Header().Get("Location"), "/"; got != want {
+		t.Errorf("Location header expected %q; got %q", want, got)
+	}
+	if got, want := resp.Code, StatusMovedPermanently; got != want {
+		t.Errorf("Expected response code %d; got %d", want, got)
+	}
+}
diff --git a/src/net/http/server.go b/src/net/http/server.go
index e52a78e652..4e73508973 100644
--- a/src/net/http/server.go
+++ b/src/net/http/server.go
@@ -2404,9 +2404,8 @@ func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string) {
 
 	if path != r.URL.Path {
 		_, pattern = mux.handler(host, path)
-		url := *r.URL
-		url.Path = path
-		return RedirectHandler(url.String(), StatusMovedPermanently), pattern
+		u := &url.URL{Path: path, RawQuery: r.URL.RawQuery}
+		return RedirectHandler(u.String(), StatusMovedPermanently), pattern
 	}
 
 	return mux.handler(host, r.URL.Path)
-- 
GitLab


From 90ec25773523ac2c5e075f1e5d7519ee08201b8c Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Fri, 23 Apr 2021 21:49:08 -0400
Subject: [PATCH 1928/2400] cmd/compile: make the stack allocator more careful
 about register args.

Assignment between input parameters causes them to have more than
one "Name", and running this backwards from names to values can end
up confusing (conflating) parameter spill slots.

Around 105a6e9518, this cases a stack overflow running
go test -race encoding/pem
because two slice parameters spill (incorrectly) into the same
stack slots (in the AB?I-defined parameter spill area).

This also tickles a failure in cue, which turned out to be
easier to isolate.

Fixes #45851.
Updates #40724.

Change-Id: I39c56815bd6abb652f1ccbe83c47f4f373a125c3
Reviewed-on: https://go-review.googlesource.com/c/go/+/313212
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/expand_calls.go |  6 +-
 src/cmd/compile/internal/ssa/stackalloc.go   | 39 +++++++++++
 test/fixedbugs/issue45851.go                 | 68 ++++++++++++++++++++
 3 files changed, 112 insertions(+), 1 deletion(-)
 create mode 100644 test/fixedbugs/issue45851.go

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index 4d5376b344..133959204a 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -6,6 +6,7 @@ package ssa
 
 import (
 	"cmd/compile/internal/abi"
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
@@ -1601,7 +1602,10 @@ func (x *expandState) newArgToMemOrRegs(baseArg, toReplace *Value, offset int64,
 			x.f.OwnAux.abiInfo.String())
 		panic(fmt.Errorf("Op/Type mismatch, op=%s, type=%s", op.String(), t.String()))
 	}
-	aux := &AuxNameOffset{baseArg.Aux.(*ir.Name), baseArg.AuxInt + offset}
+	if baseArg.AuxInt != 0 {
+		base.Fatalf("BaseArg %s bound to registers has non-zero AuxInt", baseArg.LongString())
+	}
+	aux := &AuxNameOffset{baseArg.Aux.(*ir.Name), offset}
 	if toReplace != nil && toReplace.Block == baseArg.Block {
 		toReplace.reset(op)
 		toReplace.Aux = aux
diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go
index 8fe18e5f02..d962579122 100644
--- a/src/cmd/compile/internal/ssa/stackalloc.go
+++ b/src/cmd/compile/internal/ssa/stackalloc.go
@@ -145,6 +145,26 @@ func (s *stackAllocState) stackalloc() {
 		// Note: not "range f.NamedValues" above, because
 		// that would be nondeterministic.
 		for _, v := range f.NamedValues[name] {
+			if v.Op == OpArgIntReg || v.Op == OpArgFloatReg {
+				aux := v.Aux.(*AuxNameOffset)
+				// Never let an arg be bound to a differently named thing.
+				if name.N != aux.Name || name.Off != aux.Offset {
+					if f.pass.debug > stackDebug {
+						fmt.Printf("stackalloc register arg %s skipping name %s\n", v, name)
+					}
+					continue
+				}
+			} else if name.N.Class == ir.PPARAM && v.Op != OpArg {
+				// PPARAM's only bind to OpArg
+				if f.pass.debug > stackDebug {
+					fmt.Printf("stackalloc PPARAM name %s skipping non-Arg %s\n", name, v)
+				}
+				continue
+			}
+
+			if f.pass.debug > stackDebug {
+				fmt.Printf("stackalloc value %s to name %s\n", v, name)
+			}
 			names[v.ID] = name
 		}
 	}
@@ -165,6 +185,25 @@ func (s *stackAllocState) stackalloc() {
 			f.setHome(v, loc)
 			continue
 		}
+		// You might think this below would be the right idea, but you would be wrong.
+		// It almost works; as of 105a6e9518 - 2021-04-23,
+		// GOSSAHASH=11011011001011111 == cmd/compile/internal/noder.(*noder).embedded
+		// is compiled incorrectly.  I believe the cause is one of those SSA-to-registers
+		// puzzles that the register allocator untangles; in the event that a register
+		// parameter does not end up bound to a name, "fixing" it is a bad idea.
+		//
+		//if f.DebugTest {
+		//	if v.Op == OpArgIntReg || v.Op == OpArgFloatReg {
+		//		aux := v.Aux.(*AuxNameOffset)
+		//		loc := LocalSlot{N: aux.Name, Type: v.Type, Off: aux.Offset}
+		//		if f.pass.debug > stackDebug {
+		//			fmt.Printf("stackalloc Op%s %s to %s\n", v.Op, v, loc)
+		//		}
+		//		names[v.ID] = loc
+		//		continue
+		//	}
+		//}
+
 	}
 
 	// For each type, we keep track of all the stack slots we
diff --git a/test/fixedbugs/issue45851.go b/test/fixedbugs/issue45851.go
new file mode 100644
index 0000000000..b137071e4f
--- /dev/null
+++ b/test/fixedbugs/issue45851.go
@@ -0,0 +1,68 @@
+// run
+
+// Copyright 2021 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.
+
+// This tickles a stack-allocation bug when the register ABI is enabled.
+// The original report was from cue, internal/core/adt/equality.go,
+// function equalVertex.
+
+// In the failing case, something bad gets passed to equalTerminal.
+
+package main
+
+import "fmt"
+
+type Kind uint16
+type Flag uint16
+
+const (
+	allKinds Kind = 1
+	TopKind  Kind = (allKinds - 1)
+)
+type Value interface {
+	Kind() Kind
+}
+type Vertex struct {
+	BaseValue Value
+	name string
+}
+func (v *Vertex) Kind() Kind {
+	return TopKind
+}
+
+func main() {
+	vA := &Vertex{name:"vA",}
+	vB := &Vertex{name:"vB",}
+	vX := &Vertex{name:"vX",}
+	vA.BaseValue = vX
+	vB.BaseValue = vX
+	_ = equalVertex(vA, vB, Flag(1))
+}
+
+var foo string
+
+//go:noinline
+func (v *Vertex) IsClosedStruct() bool {
+	return true
+}
+
+func equalVertex(x *Vertex, v Value, flags Flag) bool {
+	y, ok := v.(*Vertex)
+	if !ok {
+		return false
+	}
+	v, ok1 := x.BaseValue.(Value)
+	w, ok2 := y.BaseValue.(Value)
+	if !ok1 && !ok2 {
+		return true // both are struct or list.
+	}
+	return equalTerminal(v, w, flags)
+}
+
+//go:noinline
+func equalTerminal(x Value, y Value, flags Flag) bool {
+	foo = fmt.Sprintf("EQclosed %s %s %d\n", x.(*Vertex).name, y.(*Vertex).name, flags)
+	return true
+}
-- 
GitLab


From 7f9febd4a19a02bd25e40c63289268e9c062701e Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Mon, 3 May 2021 14:10:23 +0700
Subject: [PATCH 1929/2400] cmd/compile: fix linux-amd64-noopt builder

CL 312214 added unsafe.{Add,Slice}, which may appears in expression that
evaluating requires function calls. "mayCall" does not handle that
case, causing linux-amd64-noopt builder failed.

Fixes #45917

Change-Id: I900aefb702122480be621355def3d2c20eadbe70
Reviewed-on: https://go-review.googlesource.com/c/go/+/316170
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/walk/walk.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index 904587295a..fe2c62cd4f 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -308,7 +308,8 @@ func mayCall(n ir.Node) bool {
 		default:
 			base.FatalfAt(n.Pos(), "mayCall %+v", n)
 
-		case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER:
+		case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER,
+			ir.OUNSAFEADD, ir.OUNSAFESLICE:
 			return true
 
 		case ir.OINDEX, ir.OSLICE, ir.OSLICEARR, ir.OSLICE3, ir.OSLICE3ARR, ir.OSLICESTR,
-- 
GitLab


From 8a4b7294af226f2628edc0ef2a7c45ecff6e06ff Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Mon, 3 May 2021 13:24:27 -0400
Subject: [PATCH 1930/2400] cmd/compile: fix possible nil deref added in CL
 270943

In the event allocSpan returned a nil, this would crash.
Cleaned up the code and comments slightly, too.

Change-Id: I6231d4b4c14218e6956b4a97a205adc3206f59ec
Reviewed-on: https://go-review.googlesource.com/c/go/+/316429
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/mheap.go | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/src/runtime/mheap.go b/src/runtime/mheap.go
index 952c0b21b0..84c00ce8f8 100644
--- a/src/runtime/mheap.go
+++ b/src/runtime/mheap.go
@@ -897,7 +897,8 @@ func (s spanAllocType) manual() bool {
 // spanclass indicates the span's size class and scannability.
 //
 // If needzero is true, the memory for the returned span will be zeroed.
-// The boolean returned indicates whether the returned span is zeroed.
+// The boolean returned indicates whether the returned span contains zeroes,
+// either because this was requested, or because it was already zeroed.
 func (h *mheap) alloc(npages uintptr, spanclass spanClass, needzero bool) (*mspan, bool) {
 	// Don't do any operations that lock the heap on the G stack.
 	// It might trigger stack growth, and the stack growth code needs
@@ -912,14 +913,15 @@ func (h *mheap) alloc(npages uintptr, spanclass spanClass, needzero bool) (*mspa
 		s = h.allocSpan(npages, spanAllocHeap, spanclass)
 	})
 
+	if s == nil {
+		return nil, false
+	}
 	isZeroed := s.needzero == 0
-	if s != nil {
-		if needzero && s.needzero != 0 {
-			memclrNoHeapPointers(unsafe.Pointer(s.base()), s.npages<<_PageShift)
-			isZeroed = true
-		}
-		s.needzero = 0
+	if needzero && !isZeroed {
+		memclrNoHeapPointers(unsafe.Pointer(s.base()), s.npages<<_PageShift)
+		isZeroed = true
 	}
+	s.needzero = 0
 	return s, isZeroed
 }
 
-- 
GitLab


From a144af91364cc9b4928ad80bdb7529b28a803508 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Mon, 3 May 2021 02:10:46 -0400
Subject: [PATCH 1931/2400] cmd: update x/term to pull in CL 316112

Even though x/term is now lazy, this has no overall effect (yet) on
the contents of cmd/go.sum, because the dependency that would be
pruned out (an old version of x/sys) is still transitively required
through x/crypto, x/sys, and/or x/tools.

Once those modules are also lazy (CL 316109, CL 316111, and CL 315570
respectively), the extra go.sum entries for x/sys will drop out.

For #36460
Updates #36905

Change-Id: I79e715328f7c417ea20ae8fe4f8e0e3eb71ee6c7
Reviewed-on: https://go-review.googlesource.com/c/go/+/316250
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 src/cmd/go.mod                                |   2 +-
 src/cmd/go.sum                                |   4 +-
 src/cmd/vendor/golang.org/x/term/term.go      |   4 +-
 .../vendor/golang.org/x/term/term_solaris.go  | 111 ------------------
 src/cmd/vendor/golang.org/x/term/term_unix.go |   4 +-
 .../golang.org/x/term/term_unix_linux.go      |  10 --
 .../{term_unix_aix.go => term_unix_other.go}  |   5 +-
 .../vendor/golang.org/x/term/term_unix_zos.go |  10 --
 src/cmd/vendor/modules.txt                    |   4 +-
 9 files changed, 13 insertions(+), 141 deletions(-)
 delete mode 100644 src/cmd/vendor/golang.org/x/term/term_solaris.go
 delete mode 100644 src/cmd/vendor/golang.org/x/term/term_unix_linux.go
 rename src/cmd/vendor/golang.org/x/term/{term_unix_aix.go => term_unix_other.go} (63%)
 delete mode 100644 src/cmd/vendor/golang.org/x/term/term_unix_zos.go

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index 96f709081f..c9ae30f284 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -9,7 +9,7 @@ require (
 	golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 // indirect
 	golang.org/x/mod v0.4.3-0.20210409134425-858fdbee9c24
 	golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57 // indirect
-	golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d
+	golang.org/x/term v0.0.0-20210503060354-a79de5458b56
 	golang.org/x/tools v0.1.1-0.20210422170518-f946a157eefe
 	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
 )
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 9c702d0d33..84c91e5cfd 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -30,8 +30,8 @@ golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57 h1:F5Gozwx4I1xtr/sr/8CFbb57i
 golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d h1:SZxvLBoTP5yHO3Frd4z4vrF+DBX9vMVanchswa69toE=
-golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210503060354-a79de5458b56 h1:b8jxX3zqjpqb2LklXPzKSGJhzyxCOZSz8ncv8Nv+y7w=
+golang.org/x/term v0.0.0-20210503060354-a79de5458b56/go.mod h1:tfny5GFUkzUvx4ps4ajbZsCe5lw1metzhBm9T3x7oIY=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
diff --git a/src/cmd/vendor/golang.org/x/term/term.go b/src/cmd/vendor/golang.org/x/term/term.go
index 2a4ccf8012..1f6a38fad2 100644
--- a/src/cmd/vendor/golang.org/x/term/term.go
+++ b/src/cmd/vendor/golang.org/x/term/term.go
@@ -7,11 +7,11 @@
 //
 // Putting a terminal into raw mode is the most common requirement:
 //
-// 	oldState, err := term.MakeRaw(0)
+// 	oldState, err := term.MakeRaw(int(os.Stdin.Fd()))
 // 	if err != nil {
 // 	        panic(err)
 // 	}
-// 	defer term.Restore(0, oldState)
+// 	defer term.Restore(int(os.Stdin.Fd()), oldState)
 package term
 
 // State contains the state of a terminal.
diff --git a/src/cmd/vendor/golang.org/x/term/term_solaris.go b/src/cmd/vendor/golang.org/x/term/term_solaris.go
deleted file mode 100644
index b9da29744b..0000000000
--- a/src/cmd/vendor/golang.org/x/term/term_solaris.go
+++ /dev/null
@@ -1,111 +0,0 @@
-// Copyright 2019 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 term
-
-import (
-	"io"
-	"syscall"
-
-	"golang.org/x/sys/unix"
-)
-
-// State contains the state of a terminal.
-type state struct {
-	termios unix.Termios
-}
-
-func isTerminal(fd int) bool {
-	_, err := unix.IoctlGetTermio(fd, unix.TCGETA)
-	return err == nil
-}
-
-func readPassword(fd int) ([]byte, error) {
-	// see also: http://src.illumos.org/source/xref/illumos-gate/usr/src/lib/libast/common/uwin/getpass.c
-	val, err := unix.IoctlGetTermios(fd, unix.TCGETS)
-	if err != nil {
-		return nil, err
-	}
-	oldState := *val
-
-	newState := oldState
-	newState.Lflag &^= syscall.ECHO
-	newState.Lflag |= syscall.ICANON | syscall.ISIG
-	newState.Iflag |= syscall.ICRNL
-	err = unix.IoctlSetTermios(fd, unix.TCSETS, &newState)
-	if err != nil {
-		return nil, err
-	}
-
-	defer unix.IoctlSetTermios(fd, unix.TCSETS, &oldState)
-
-	var buf [16]byte
-	var ret []byte
-	for {
-		n, err := syscall.Read(fd, buf[:])
-		if err != nil {
-			return nil, err
-		}
-		if n == 0 {
-			if len(ret) == 0 {
-				return nil, io.EOF
-			}
-			break
-		}
-		if buf[n-1] == '\n' {
-			n--
-		}
-		ret = append(ret, buf[:n]...)
-		if n < len(buf) {
-			break
-		}
-	}
-
-	return ret, nil
-}
-
-func makeRaw(fd int) (*State, error) {
-	// see http://cr.illumos.org/~webrev/andy_js/1060/
-	termios, err := unix.IoctlGetTermios(fd, unix.TCGETS)
-	if err != nil {
-		return nil, err
-	}
-
-	oldState := State{state{termios: *termios}}
-
-	termios.Iflag &^= unix.IGNBRK | unix.BRKINT | unix.PARMRK | unix.ISTRIP | unix.INLCR | unix.IGNCR | unix.ICRNL | unix.IXON
-	termios.Oflag &^= unix.OPOST
-	termios.Lflag &^= unix.ECHO | unix.ECHONL | unix.ICANON | unix.ISIG | unix.IEXTEN
-	termios.Cflag &^= unix.CSIZE | unix.PARENB
-	termios.Cflag |= unix.CS8
-	termios.Cc[unix.VMIN] = 1
-	termios.Cc[unix.VTIME] = 0
-
-	if err := unix.IoctlSetTermios(fd, unix.TCSETS, termios); err != nil {
-		return nil, err
-	}
-
-	return &oldState, nil
-}
-
-func restore(fd int, oldState *State) error {
-	return unix.IoctlSetTermios(fd, unix.TCSETS, &oldState.termios)
-}
-
-func getState(fd int) (*State, error) {
-	termios, err := unix.IoctlGetTermios(fd, unix.TCGETS)
-	if err != nil {
-		return nil, err
-	}
-
-	return &State{state{termios: *termios}}, nil
-}
-
-func getSize(fd int) (width, height int, err error) {
-	ws, err := unix.IoctlGetWinsize(fd, unix.TIOCGWINSZ)
-	if err != nil {
-		return 0, 0, err
-	}
-	return int(ws.Col), int(ws.Row), nil
-}
diff --git a/src/cmd/vendor/golang.org/x/term/term_unix.go b/src/cmd/vendor/golang.org/x/term/term_unix.go
index 6849b6ee5b..a4e31ab1b2 100644
--- a/src/cmd/vendor/golang.org/x/term/term_unix.go
+++ b/src/cmd/vendor/golang.org/x/term/term_unix.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || zos
-// +build aix darwin dragonfly freebsd linux netbsd openbsd zos
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos
+// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos
 
 package term
 
diff --git a/src/cmd/vendor/golang.org/x/term/term_unix_linux.go b/src/cmd/vendor/golang.org/x/term/term_unix_linux.go
deleted file mode 100644
index 2d5efd26ad..0000000000
--- a/src/cmd/vendor/golang.org/x/term/term_unix_linux.go
+++ /dev/null
@@ -1,10 +0,0 @@
-// Copyright 2019 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 term
-
-import "golang.org/x/sys/unix"
-
-const ioctlReadTermios = unix.TCGETS
-const ioctlWriteTermios = unix.TCSETS
diff --git a/src/cmd/vendor/golang.org/x/term/term_unix_aix.go b/src/cmd/vendor/golang.org/x/term/term_unix_other.go
similarity index 63%
rename from src/cmd/vendor/golang.org/x/term/term_unix_aix.go
rename to src/cmd/vendor/golang.org/x/term/term_unix_other.go
index 2d5efd26ad..1e8955c934 100644
--- a/src/cmd/vendor/golang.org/x/term/term_unix_aix.go
+++ b/src/cmd/vendor/golang.org/x/term/term_unix_other.go
@@ -1,7 +1,10 @@
-// Copyright 2019 The Go Authors. All rights reserved.
+// Copyright 2021 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.
 
+//go:build aix || linux || solaris || zos
+// +build aix linux solaris zos
+
 package term
 
 import "golang.org/x/sys/unix"
diff --git a/src/cmd/vendor/golang.org/x/term/term_unix_zos.go b/src/cmd/vendor/golang.org/x/term/term_unix_zos.go
deleted file mode 100644
index b85ab89989..0000000000
--- a/src/cmd/vendor/golang.org/x/term/term_unix_zos.go
+++ /dev/null
@@ -1,10 +0,0 @@
-// Copyright 2020 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 term
-
-import "golang.org/x/sys/unix"
-
-const ioctlReadTermios = unix.TCGETS
-const ioctlWriteTermios = unix.TCSETS
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 93d30db335..473febea68 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -45,8 +45,8 @@ golang.org/x/sys/internal/unsafeheader
 golang.org/x/sys/plan9
 golang.org/x/sys/unix
 golang.org/x/sys/windows
-# golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d
-## explicit; go 1.11
+# golang.org/x/term v0.0.0-20210503060354-a79de5458b56
+## explicit; go 1.17
 golang.org/x/term
 # golang.org/x/tools v0.1.1-0.20210422170518-f946a157eefe
 ## explicit; go 1.12
-- 
GitLab


From 791854700db17ad11f75a61176967e35196714ed Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Mon, 3 May 2021 02:19:20 -0400
Subject: [PATCH 1932/2400] all: update x/net to pull in CL 316129

As a side effect, this also upgrades x/sys to the version currently
required by the latest x/net.

Because x/net is now lazy, it no longer requires checksums for
older-than-selected versions of x/sys, x/term, and x/text.

For #36460
Updates #36905

Change-Id: I242815e202aa7d482fc3983a6717bece10ea8111
Reviewed-on: https://go-review.googlesource.com/c/go/+/316251
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 src/cmd/go.mod                                |   2 +-
 src/cmd/go.sum                                |   3 +-
 .../x/sys/unix/fcntl_linux_32bit.go           |   4 +-
 .../golang.org/x/sys/unix/ioctl_linux.go      | 196 ++++
 .../golang.org/x/sys/unix/syscall_darwin.go   |  11 +
 .../golang.org/x/sys/unix/syscall_linux.go    | 176 +---
 .../x/sys/unix/syscall_linux_ppc.go           | 272 ++++++
 .../x/sys/unix/zerrors_linux_ppc.go           | 860 ++++++++++++++++++
 .../x/sys/unix/zerrors_zos_s390x.go           |   6 +
 .../x/sys/unix/zsyscall_linux_ppc.go          | 762 ++++++++++++++++
 .../x/sys/unix/zsysnum_linux_ppc.go           | 433 +++++++++
 .../x/sys/unix/ztypes_darwin_386.go           |   7 +
 .../x/sys/unix/ztypes_darwin_amd64.go         |   7 +
 .../x/sys/unix/ztypes_darwin_arm.go           |   7 +
 .../x/sys/unix/ztypes_darwin_arm64.go         |   7 +
 .../golang.org/x/sys/unix/ztypes_linux.go     |  15 +
 .../golang.org/x/sys/unix/ztypes_linux_ppc.go | 627 +++++++++++++
 src/cmd/vendor/modules.txt                    |   2 +-
 src/go.mod                                    |   6 +-
 src/go.sum                                    |  16 +-
 .../golang.org/x/net/http/httpguts/httplex.go |  10 +-
 .../golang.org/x/net/idna/idna10.0.0.go       | 113 ++-
 src/vendor/golang.org/x/net/idna/idna9.0.0.go |  93 +-
 src/vendor/golang.org/x/net/route/route.go    |  35 +-
 src/vendor/modules.txt                        |   8 +-
 25 files changed, 3406 insertions(+), 272 deletions(-)
 create mode 100644 src/cmd/vendor/golang.org/x/sys/unix/ioctl_linux.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_ppc.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go
 create mode 100644 src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index c9ae30f284..ef231b1e3c 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -8,7 +8,7 @@ require (
 	golang.org/x/arch v0.0.0-20210502124803-cbf565b21d1e
 	golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 // indirect
 	golang.org/x/mod v0.4.3-0.20210409134425-858fdbee9c24
-	golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57 // indirect
+	golang.org/x/sys v0.0.0-20210423082822-04245dca01da // indirect
 	golang.org/x/term v0.0.0-20210503060354-a79de5458b56
 	golang.org/x/tools v0.1.1-0.20210422170518-f946a157eefe
 	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 84c91e5cfd..b03cb37203 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -26,8 +26,9 @@ golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57 h1:F5Gozwx4I1xtr/sr/8CFbb57iKi3297KFs0QDbGN60A=
 golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da h1:b3NXsE2LusjYGGjL5bxEVZZORm/YEFFrWFjR8eFrw/c=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210503060354-a79de5458b56 h1:b8jxX3zqjpqb2LklXPzKSGJhzyxCOZSz8ncv8Nv+y7w=
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/fcntl_linux_32bit.go b/src/cmd/vendor/golang.org/x/sys/unix/fcntl_linux_32bit.go
index cb0dfbd09a..29d44808b1 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/fcntl_linux_32bit.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/fcntl_linux_32bit.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (linux && 386) || (linux && arm) || (linux && mips) || (linux && mipsle)
-// +build linux,386 linux,arm linux,mips linux,mipsle
+//go:build (linux && 386) || (linux && arm) || (linux && mips) || (linux && mipsle) || (linux && ppc)
+// +build linux,386 linux,arm linux,mips linux,mipsle linux,ppc
 
 package unix
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ioctl_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/ioctl_linux.go
new file mode 100644
index 0000000000..48773f730a
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ioctl_linux.go
@@ -0,0 +1,196 @@
+// Copyright 2021 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 unix
+
+import (
+	"runtime"
+	"unsafe"
+)
+
+// IoctlRetInt performs an ioctl operation specified by req on a device
+// associated with opened file descriptor fd, and returns a non-negative
+// integer that is returned by the ioctl syscall.
+func IoctlRetInt(fd int, req uint) (int, error) {
+	ret, _, err := Syscall(SYS_IOCTL, uintptr(fd), uintptr(req), 0)
+	if err != 0 {
+		return 0, err
+	}
+	return int(ret), nil
+}
+
+func IoctlGetUint32(fd int, req uint) (uint32, error) {
+	var value uint32
+	err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
+	return value, err
+}
+
+func IoctlGetRTCTime(fd int) (*RTCTime, error) {
+	var value RTCTime
+	err := ioctl(fd, RTC_RD_TIME, uintptr(unsafe.Pointer(&value)))
+	return &value, err
+}
+
+func IoctlSetRTCTime(fd int, value *RTCTime) error {
+	err := ioctl(fd, RTC_SET_TIME, uintptr(unsafe.Pointer(value)))
+	runtime.KeepAlive(value)
+	return err
+}
+
+func IoctlGetRTCWkAlrm(fd int) (*RTCWkAlrm, error) {
+	var value RTCWkAlrm
+	err := ioctl(fd, RTC_WKALM_RD, uintptr(unsafe.Pointer(&value)))
+	return &value, err
+}
+
+func IoctlSetRTCWkAlrm(fd int, value *RTCWkAlrm) error {
+	err := ioctl(fd, RTC_WKALM_SET, uintptr(unsafe.Pointer(value)))
+	runtime.KeepAlive(value)
+	return err
+}
+
+type ifreqEthtool struct {
+	name [IFNAMSIZ]byte
+	data unsafe.Pointer
+}
+
+// IoctlGetEthtoolDrvinfo fetches ethtool driver information for the network
+// device specified by ifname.
+func IoctlGetEthtoolDrvinfo(fd int, ifname string) (*EthtoolDrvinfo, error) {
+	// Leave room for terminating NULL byte.
+	if len(ifname) >= IFNAMSIZ {
+		return nil, EINVAL
+	}
+
+	value := EthtoolDrvinfo{
+		Cmd: ETHTOOL_GDRVINFO,
+	}
+	ifreq := ifreqEthtool{
+		data: unsafe.Pointer(&value),
+	}
+	copy(ifreq.name[:], ifname)
+	err := ioctl(fd, SIOCETHTOOL, uintptr(unsafe.Pointer(&ifreq)))
+	runtime.KeepAlive(ifreq)
+	return &value, err
+}
+
+// IoctlGetWatchdogInfo fetches information about a watchdog device from the
+// Linux watchdog API. For more information, see:
+// https://www.kernel.org/doc/html/latest/watchdog/watchdog-api.html.
+func IoctlGetWatchdogInfo(fd int) (*WatchdogInfo, error) {
+	var value WatchdogInfo
+	err := ioctl(fd, WDIOC_GETSUPPORT, uintptr(unsafe.Pointer(&value)))
+	return &value, err
+}
+
+// IoctlWatchdogKeepalive issues a keepalive ioctl to a watchdog device. For
+// more information, see:
+// https://www.kernel.org/doc/html/latest/watchdog/watchdog-api.html.
+func IoctlWatchdogKeepalive(fd int) error {
+	return ioctl(fd, WDIOC_KEEPALIVE, 0)
+}
+
+// IoctlFileCloneRange performs an FICLONERANGE ioctl operation to clone the
+// range of data conveyed in value to the file associated with the file
+// descriptor destFd. See the ioctl_ficlonerange(2) man page for details.
+func IoctlFileCloneRange(destFd int, value *FileCloneRange) error {
+	err := ioctl(destFd, FICLONERANGE, uintptr(unsafe.Pointer(value)))
+	runtime.KeepAlive(value)
+	return err
+}
+
+// IoctlFileClone performs an FICLONE ioctl operation to clone the entire file
+// associated with the file description srcFd to the file associated with the
+// file descriptor destFd. See the ioctl_ficlone(2) man page for details.
+func IoctlFileClone(destFd, srcFd int) error {
+	return ioctl(destFd, FICLONE, uintptr(srcFd))
+}
+
+type FileDedupeRange struct {
+	Src_offset uint64
+	Src_length uint64
+	Reserved1  uint16
+	Reserved2  uint32
+	Info       []FileDedupeRangeInfo
+}
+
+type FileDedupeRangeInfo struct {
+	Dest_fd       int64
+	Dest_offset   uint64
+	Bytes_deduped uint64
+	Status        int32
+	Reserved      uint32
+}
+
+// IoctlFileDedupeRange performs an FIDEDUPERANGE ioctl operation to share the
+// range of data conveyed in value from the file associated with the file
+// descriptor srcFd to the value.Info destinations. See the
+// ioctl_fideduperange(2) man page for details.
+func IoctlFileDedupeRange(srcFd int, value *FileDedupeRange) error {
+	buf := make([]byte, SizeofRawFileDedupeRange+
+		len(value.Info)*SizeofRawFileDedupeRangeInfo)
+	rawrange := (*RawFileDedupeRange)(unsafe.Pointer(&buf[0]))
+	rawrange.Src_offset = value.Src_offset
+	rawrange.Src_length = value.Src_length
+	rawrange.Dest_count = uint16(len(value.Info))
+	rawrange.Reserved1 = value.Reserved1
+	rawrange.Reserved2 = value.Reserved2
+
+	for i := range value.Info {
+		rawinfo := (*RawFileDedupeRangeInfo)(unsafe.Pointer(
+			uintptr(unsafe.Pointer(&buf[0])) + uintptr(SizeofRawFileDedupeRange) +
+				uintptr(i*SizeofRawFileDedupeRangeInfo)))
+		rawinfo.Dest_fd = value.Info[i].Dest_fd
+		rawinfo.Dest_offset = value.Info[i].Dest_offset
+		rawinfo.Bytes_deduped = value.Info[i].Bytes_deduped
+		rawinfo.Status = value.Info[i].Status
+		rawinfo.Reserved = value.Info[i].Reserved
+	}
+
+	err := ioctl(srcFd, FIDEDUPERANGE, uintptr(unsafe.Pointer(&buf[0])))
+
+	// Output
+	for i := range value.Info {
+		rawinfo := (*RawFileDedupeRangeInfo)(unsafe.Pointer(
+			uintptr(unsafe.Pointer(&buf[0])) + uintptr(SizeofRawFileDedupeRange) +
+				uintptr(i*SizeofRawFileDedupeRangeInfo)))
+		value.Info[i].Dest_fd = rawinfo.Dest_fd
+		value.Info[i].Dest_offset = rawinfo.Dest_offset
+		value.Info[i].Bytes_deduped = rawinfo.Bytes_deduped
+		value.Info[i].Status = rawinfo.Status
+		value.Info[i].Reserved = rawinfo.Reserved
+	}
+
+	return err
+}
+
+func IoctlHIDGetDesc(fd int, value *HIDRawReportDescriptor) error {
+	err := ioctl(fd, HIDIOCGRDESC, uintptr(unsafe.Pointer(value)))
+	runtime.KeepAlive(value)
+	return err
+}
+
+func IoctlHIDGetRawInfo(fd int) (*HIDRawDevInfo, error) {
+	var value HIDRawDevInfo
+	err := ioctl(fd, HIDIOCGRAWINFO, uintptr(unsafe.Pointer(&value)))
+	return &value, err
+}
+
+func IoctlHIDGetRawName(fd int) (string, error) {
+	var value [_HIDIOCGRAWNAME_LEN]byte
+	err := ioctl(fd, _HIDIOCGRAWNAME, uintptr(unsafe.Pointer(&value[0])))
+	return ByteSliceToString(value[:]), err
+}
+
+func IoctlHIDGetRawPhys(fd int) (string, error) {
+	var value [_HIDIOCGRAWPHYS_LEN]byte
+	err := ioctl(fd, _HIDIOCGRAWPHYS, uintptr(unsafe.Pointer(&value[0])))
+	return ByteSliceToString(value[:]), err
+}
+
+func IoctlHIDGetRawUniq(fd int) (string, error) {
+	var value [_HIDIOCGRAWUNIQ_LEN]byte
+	err := ioctl(fd, _HIDIOCGRAWUNIQ, uintptr(unsafe.Pointer(&value[0])))
+	return ByteSliceToString(value[:]), err
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.go
index 1223d7aed1..9945e5f965 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.go
@@ -378,6 +378,17 @@ func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err e
 	return
 }
 
+func GetsockoptIPMreqn(fd, level, opt int) (*IPMreqn, error) {
+	var value IPMreqn
+	vallen := _Socklen(SizeofIPMreqn)
+	errno := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
+	return &value, errno
+}
+
+func SetsockoptIPMreqn(fd, level, opt int, mreq *IPMreqn) (err error) {
+	return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq))
+}
+
 // GetsockoptXucred is a getsockopt wrapper that returns an Xucred struct.
 // The usual level and opt are SOL_LOCAL and LOCAL_PEERCRED, respectively.
 func GetsockoptXucred(fd, level, opt int) (*Xucred, error) {
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go
index 44ea96e39c..4263953bee 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go
@@ -70,167 +70,7 @@ func Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) {
 
 // ioctl itself should not be exposed directly, but additional get/set
 // functions for specific types are permissible.
-
-// IoctlRetInt performs an ioctl operation specified by req on a device
-// associated with opened file descriptor fd, and returns a non-negative
-// integer that is returned by the ioctl syscall.
-func IoctlRetInt(fd int, req uint) (int, error) {
-	ret, _, err := Syscall(SYS_IOCTL, uintptr(fd), uintptr(req), 0)
-	if err != 0 {
-		return 0, err
-	}
-	return int(ret), nil
-}
-
-func IoctlSetRTCTime(fd int, value *RTCTime) error {
-	err := ioctl(fd, RTC_SET_TIME, uintptr(unsafe.Pointer(value)))
-	runtime.KeepAlive(value)
-	return err
-}
-
-func IoctlSetRTCWkAlrm(fd int, value *RTCWkAlrm) error {
-	err := ioctl(fd, RTC_WKALM_SET, uintptr(unsafe.Pointer(value)))
-	runtime.KeepAlive(value)
-	return err
-}
-
-func IoctlGetUint32(fd int, req uint) (uint32, error) {
-	var value uint32
-	err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
-	return value, err
-}
-
-func IoctlGetRTCTime(fd int) (*RTCTime, error) {
-	var value RTCTime
-	err := ioctl(fd, RTC_RD_TIME, uintptr(unsafe.Pointer(&value)))
-	return &value, err
-}
-
-// IoctlGetWatchdogInfo fetches information about a watchdog device from the
-// Linux watchdog API. For more information, see:
-// https://www.kernel.org/doc/html/latest/watchdog/watchdog-api.html.
-func IoctlGetWatchdogInfo(fd int) (*WatchdogInfo, error) {
-	var value WatchdogInfo
-	err := ioctl(fd, WDIOC_GETSUPPORT, uintptr(unsafe.Pointer(&value)))
-	return &value, err
-}
-
-func IoctlGetRTCWkAlrm(fd int) (*RTCWkAlrm, error) {
-	var value RTCWkAlrm
-	err := ioctl(fd, RTC_WKALM_RD, uintptr(unsafe.Pointer(&value)))
-	return &value, err
-}
-
-// IoctlFileCloneRange performs an FICLONERANGE ioctl operation to clone the
-// range of data conveyed in value to the file associated with the file
-// descriptor destFd. See the ioctl_ficlonerange(2) man page for details.
-func IoctlFileCloneRange(destFd int, value *FileCloneRange) error {
-	err := ioctl(destFd, FICLONERANGE, uintptr(unsafe.Pointer(value)))
-	runtime.KeepAlive(value)
-	return err
-}
-
-// IoctlFileClone performs an FICLONE ioctl operation to clone the entire file
-// associated with the file description srcFd to the file associated with the
-// file descriptor destFd. See the ioctl_ficlone(2) man page for details.
-func IoctlFileClone(destFd, srcFd int) error {
-	return ioctl(destFd, FICLONE, uintptr(srcFd))
-}
-
-type FileDedupeRange struct {
-	Src_offset uint64
-	Src_length uint64
-	Reserved1  uint16
-	Reserved2  uint32
-	Info       []FileDedupeRangeInfo
-}
-
-type FileDedupeRangeInfo struct {
-	Dest_fd       int64
-	Dest_offset   uint64
-	Bytes_deduped uint64
-	Status        int32
-	Reserved      uint32
-}
-
-// IoctlFileDedupeRange performs an FIDEDUPERANGE ioctl operation to share the
-// range of data conveyed in value from the file associated with the file
-// descriptor srcFd to the value.Info destinations. See the
-// ioctl_fideduperange(2) man page for details.
-func IoctlFileDedupeRange(srcFd int, value *FileDedupeRange) error {
-	buf := make([]byte, SizeofRawFileDedupeRange+
-		len(value.Info)*SizeofRawFileDedupeRangeInfo)
-	rawrange := (*RawFileDedupeRange)(unsafe.Pointer(&buf[0]))
-	rawrange.Src_offset = value.Src_offset
-	rawrange.Src_length = value.Src_length
-	rawrange.Dest_count = uint16(len(value.Info))
-	rawrange.Reserved1 = value.Reserved1
-	rawrange.Reserved2 = value.Reserved2
-
-	for i := range value.Info {
-		rawinfo := (*RawFileDedupeRangeInfo)(unsafe.Pointer(
-			uintptr(unsafe.Pointer(&buf[0])) + uintptr(SizeofRawFileDedupeRange) +
-				uintptr(i*SizeofRawFileDedupeRangeInfo)))
-		rawinfo.Dest_fd = value.Info[i].Dest_fd
-		rawinfo.Dest_offset = value.Info[i].Dest_offset
-		rawinfo.Bytes_deduped = value.Info[i].Bytes_deduped
-		rawinfo.Status = value.Info[i].Status
-		rawinfo.Reserved = value.Info[i].Reserved
-	}
-
-	err := ioctl(srcFd, FIDEDUPERANGE, uintptr(unsafe.Pointer(&buf[0])))
-
-	// Output
-	for i := range value.Info {
-		rawinfo := (*RawFileDedupeRangeInfo)(unsafe.Pointer(
-			uintptr(unsafe.Pointer(&buf[0])) + uintptr(SizeofRawFileDedupeRange) +
-				uintptr(i*SizeofRawFileDedupeRangeInfo)))
-		value.Info[i].Dest_fd = rawinfo.Dest_fd
-		value.Info[i].Dest_offset = rawinfo.Dest_offset
-		value.Info[i].Bytes_deduped = rawinfo.Bytes_deduped
-		value.Info[i].Status = rawinfo.Status
-		value.Info[i].Reserved = rawinfo.Reserved
-	}
-
-	return err
-}
-
-// IoctlWatchdogKeepalive issues a keepalive ioctl to a watchdog device. For
-// more information, see:
-// https://www.kernel.org/doc/html/latest/watchdog/watchdog-api.html.
-func IoctlWatchdogKeepalive(fd int) error {
-	return ioctl(fd, WDIOC_KEEPALIVE, 0)
-}
-
-func IoctlHIDGetDesc(fd int, value *HIDRawReportDescriptor) error {
-	err := ioctl(fd, HIDIOCGRDESC, uintptr(unsafe.Pointer(value)))
-	runtime.KeepAlive(value)
-	return err
-}
-
-func IoctlHIDGetRawInfo(fd int) (*HIDRawDevInfo, error) {
-	var value HIDRawDevInfo
-	err := ioctl(fd, HIDIOCGRAWINFO, uintptr(unsafe.Pointer(&value)))
-	return &value, err
-}
-
-func IoctlHIDGetRawName(fd int) (string, error) {
-	var value [_HIDIOCGRAWNAME_LEN]byte
-	err := ioctl(fd, _HIDIOCGRAWNAME, uintptr(unsafe.Pointer(&value[0])))
-	return ByteSliceToString(value[:]), err
-}
-
-func IoctlHIDGetRawPhys(fd int) (string, error) {
-	var value [_HIDIOCGRAWPHYS_LEN]byte
-	err := ioctl(fd, _HIDIOCGRAWPHYS, uintptr(unsafe.Pointer(&value[0])))
-	return ByteSliceToString(value[:]), err
-}
-
-func IoctlHIDGetRawUniq(fd int) (string, error) {
-	var value [_HIDIOCGRAWUNIQ_LEN]byte
-	err := ioctl(fd, _HIDIOCGRAWUNIQ, uintptr(unsafe.Pointer(&value[0])))
-	return ByteSliceToString(value[:]), err
-}
+// These are defined in ioctl.go and ioctl_linux.go.
 
 //sys	Linkat(olddirfd int, oldpath string, newdirfd int, newpath string, flags int) (err error)
 
@@ -857,16 +697,19 @@ type SockaddrVM struct {
 	// CID and Port specify a context ID and port address for a VM socket.
 	// Guests have a unique CID, and hosts may have a well-known CID of:
 	//  - VMADDR_CID_HYPERVISOR: refers to the hypervisor process.
+	//  - VMADDR_CID_LOCAL: refers to local communication (loopback).
 	//  - VMADDR_CID_HOST: refers to other processes on the host.
-	CID  uint32
-	Port uint32
-	raw  RawSockaddrVM
+	CID   uint32
+	Port  uint32
+	Flags uint8
+	raw   RawSockaddrVM
 }
 
 func (sa *SockaddrVM) sockaddr() (unsafe.Pointer, _Socklen, error) {
 	sa.raw.Family = AF_VSOCK
 	sa.raw.Port = sa.Port
 	sa.raw.Cid = sa.CID
+	sa.raw.Flags = sa.Flags
 
 	return unsafe.Pointer(&sa.raw), SizeofSockaddrVM, nil
 }
@@ -1171,8 +1014,9 @@ func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) {
 	case AF_VSOCK:
 		pp := (*RawSockaddrVM)(unsafe.Pointer(rsa))
 		sa := &SockaddrVM{
-			CID:  pp.Cid,
-			Port: pp.Port,
+			CID:   pp.Cid,
+			Port:  pp.Port,
+			Flags: pp.Flags,
 		}
 		return sa, nil
 	case AF_BLUETOOTH:
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_ppc.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_ppc.go
new file mode 100644
index 0000000000..7e65e088d2
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux_ppc.go
@@ -0,0 +1,272 @@
+// Copyright 2021 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.
+
+//go:build linux && ppc
+// +build linux
+// +build ppc
+
+package unix
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+//sys	dup2(oldfd int, newfd int) (err error)
+//sysnb	EpollCreate(size int) (fd int, err error)
+//sys	EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error)
+//sys	Fchown(fd int, uid int, gid int) (err error)
+//sys	Fstat(fd int, stat *Stat_t) (err error) = SYS_FSTAT64
+//sys	Fstatat(dirfd int, path string, stat *Stat_t, flags int) (err error) = SYS_FSTATAT64
+//sys	Ftruncate(fd int, length int64) (err error) = SYS_FTRUNCATE64
+//sysnb	Getegid() (egid int)
+//sysnb	Geteuid() (euid int)
+//sysnb	Getgid() (gid int)
+//sysnb	Getuid() (uid int)
+//sysnb	InotifyInit() (fd int, err error)
+//sys	Ioperm(from int, num int, on int) (err error)
+//sys	Iopl(level int) (err error)
+//sys	Lchown(path string, uid int, gid int) (err error)
+//sys	Listen(s int, n int) (err error)
+//sys	Lstat(path string, stat *Stat_t) (err error) = SYS_LSTAT64
+//sys	Pause() (err error)
+//sys	Pread(fd int, p []byte, offset int64) (n int, err error) = SYS_PREAD64
+//sys	Pwrite(fd int, p []byte, offset int64) (n int, err error) = SYS_PWRITE64
+//sys	Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error)
+//sys	Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error) = SYS__NEWSELECT
+//sys	sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) = SYS_SENDFILE64
+//sys	setfsgid(gid int) (prev int, err error)
+//sys	setfsuid(uid int) (prev int, err error)
+//sysnb	Setregid(rgid int, egid int) (err error)
+//sysnb	Setresgid(rgid int, egid int, sgid int) (err error)
+//sysnb	Setresuid(ruid int, euid int, suid int) (err error)
+//sysnb	Setreuid(ruid int, euid int) (err error)
+//sys	Shutdown(fd int, how int) (err error)
+//sys	Splice(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int, err error)
+//sys	Stat(path string, stat *Stat_t) (err error) = SYS_STAT64
+//sys	Truncate(path string, length int64) (err error) = SYS_TRUNCATE64
+//sys	Ustat(dev int, ubuf *Ustat_t) (err error)
+//sys	accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error)
+//sys	accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error)
+//sys	bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error)
+//sys	connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error)
+//sysnb	getgroups(n int, list *_Gid_t) (nn int, err error)
+//sysnb	setgroups(n int, list *_Gid_t) (err error)
+//sys	getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error)
+//sys	setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error)
+//sysnb	socket(domain int, typ int, proto int) (fd int, err error)
+//sysnb	socketpair(domain int, typ int, proto int, fd *[2]int32) (err error)
+//sysnb	getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error)
+//sysnb	getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error)
+//sys	recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error)
+//sys	sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error)
+//sys	recvmsg(s int, msg *Msghdr, flags int) (n int, err error)
+//sys	sendmsg(s int, msg *Msghdr, flags int) (n int, err error)
+
+//sys	futimesat(dirfd int, path string, times *[2]Timeval) (err error)
+//sysnb	Gettimeofday(tv *Timeval) (err error)
+//sysnb	Time(t *Time_t) (tt Time_t, err error)
+//sys	Utime(path string, buf *Utimbuf) (err error)
+//sys	utimes(path string, times *[2]Timeval) (err error)
+
+func Fadvise(fd int, offset int64, length int64, advice int) (err error) {
+	_, _, e1 := Syscall6(SYS_FADVISE64_64, uintptr(fd), uintptr(advice), uintptr(offset>>32), uintptr(offset), uintptr(length>>32), uintptr(length))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func seek(fd int, offset int64, whence int) (int64, syscall.Errno) {
+	var newoffset int64
+	offsetLow := uint32(offset & 0xffffffff)
+	offsetHigh := uint32((offset >> 32) & 0xffffffff)
+	_, _, err := Syscall6(SYS__LLSEEK, uintptr(fd), uintptr(offsetHigh), uintptr(offsetLow), uintptr(unsafe.Pointer(&newoffset)), uintptr(whence), 0)
+	return newoffset, err
+}
+
+func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
+	newoffset, errno := seek(fd, offset, whence)
+	if errno != 0 {
+		return 0, errno
+	}
+	return newoffset, nil
+}
+
+func Fstatfs(fd int, buf *Statfs_t) (err error) {
+	_, _, e := Syscall(SYS_FSTATFS64, uintptr(fd), unsafe.Sizeof(*buf), uintptr(unsafe.Pointer(buf)))
+	if e != 0 {
+		err = e
+	}
+	return
+}
+
+func Statfs(path string, buf *Statfs_t) (err error) {
+	pathp, err := BytePtrFromString(path)
+	if err != nil {
+		return err
+	}
+	_, _, e := Syscall(SYS_STATFS64, uintptr(unsafe.Pointer(pathp)), unsafe.Sizeof(*buf), uintptr(unsafe.Pointer(buf)))
+	if e != 0 {
+		err = e
+	}
+	return
+}
+
+//sys	mmap2(addr uintptr, length uintptr, prot int, flags int, fd int, pageOffset uintptr) (xaddr uintptr, err error)
+
+func mmap(addr uintptr, length uintptr, prot int, flags int, fd int, offset int64) (xaddr uintptr, err error) {
+	page := uintptr(offset / 4096)
+	if offset != int64(page)*4096 {
+		return 0, EINVAL
+	}
+	return mmap2(addr, length, prot, flags, fd, page)
+}
+
+func setTimespec(sec, nsec int64) Timespec {
+	return Timespec{Sec: int32(sec), Nsec: int32(nsec)}
+}
+
+func setTimeval(sec, usec int64) Timeval {
+	return Timeval{Sec: int32(sec), Usec: int32(usec)}
+}
+
+type rlimit32 struct {
+	Cur uint32
+	Max uint32
+}
+
+//sysnb	getrlimit(resource int, rlim *rlimit32) (err error) = SYS_UGETRLIMIT
+
+const rlimInf32 = ^uint32(0)
+const rlimInf64 = ^uint64(0)
+
+func Getrlimit(resource int, rlim *Rlimit) (err error) {
+	err = prlimit(0, resource, nil, rlim)
+	if err != ENOSYS {
+		return err
+	}
+
+	rl := rlimit32{}
+	err = getrlimit(resource, &rl)
+	if err != nil {
+		return
+	}
+
+	if rl.Cur == rlimInf32 {
+		rlim.Cur = rlimInf64
+	} else {
+		rlim.Cur = uint64(rl.Cur)
+	}
+
+	if rl.Max == rlimInf32 {
+		rlim.Max = rlimInf64
+	} else {
+		rlim.Max = uint64(rl.Max)
+	}
+	return
+}
+
+//sysnb	setrlimit(resource int, rlim *rlimit32) (err error) = SYS_SETRLIMIT
+
+func Setrlimit(resource int, rlim *Rlimit) (err error) {
+	err = prlimit(0, resource, rlim, nil)
+	if err != ENOSYS {
+		return err
+	}
+
+	rl := rlimit32{}
+	if rlim.Cur == rlimInf64 {
+		rl.Cur = rlimInf32
+	} else if rlim.Cur < uint64(rlimInf32) {
+		rl.Cur = uint32(rlim.Cur)
+	} else {
+		return EINVAL
+	}
+	if rlim.Max == rlimInf64 {
+		rl.Max = rlimInf32
+	} else if rlim.Max < uint64(rlimInf32) {
+		rl.Max = uint32(rlim.Max)
+	} else {
+		return EINVAL
+	}
+
+	return setrlimit(resource, &rl)
+}
+
+func (r *PtraceRegs) PC() uint32 { return r.Nip }
+
+func (r *PtraceRegs) SetPC(pc uint32) { r.Nip = pc }
+
+func (iov *Iovec) SetLen(length int) {
+	iov.Len = uint32(length)
+}
+
+func (msghdr *Msghdr) SetControllen(length int) {
+	msghdr.Controllen = uint32(length)
+}
+
+func (msghdr *Msghdr) SetIovlen(length int) {
+	msghdr.Iovlen = uint32(length)
+}
+
+func (cmsg *Cmsghdr) SetLen(length int) {
+	cmsg.Len = uint32(length)
+}
+
+//sysnb	pipe(p *[2]_C_int) (err error)
+
+func Pipe(p []int) (err error) {
+	if len(p) != 2 {
+		return EINVAL
+	}
+	var pp [2]_C_int
+	err = pipe(&pp)
+	p[0] = int(pp[0])
+	p[1] = int(pp[1])
+	return
+}
+
+//sysnb	pipe2(p *[2]_C_int, flags int) (err error)
+
+func Pipe2(p []int, flags int) (err error) {
+	if len(p) != 2 {
+		return EINVAL
+	}
+	var pp [2]_C_int
+	err = pipe2(&pp, flags)
+	p[0] = int(pp[0])
+	p[1] = int(pp[1])
+	return
+}
+
+//sys	poll(fds *PollFd, nfds int, timeout int) (n int, err error)
+
+func Poll(fds []PollFd, timeout int) (n int, err error) {
+	if len(fds) == 0 {
+		return poll(nil, 0, timeout)
+	}
+	return poll(&fds[0], len(fds), timeout)
+}
+
+//sys	syncFileRange2(fd int, flags int, off int64, n int64) (err error) = SYS_SYNC_FILE_RANGE2
+
+func SyncFileRange(fd int, off int64, n int64, flags int) error {
+	// The sync_file_range and sync_file_range2 syscalls differ only in the
+	// order of their arguments.
+	return syncFileRange2(fd, flags, off, n)
+}
+
+//sys	kexecFileLoad(kernelFd int, initrdFd int, cmdlineLen int, cmdline string, flags int) (err error)
+
+func KexecFileLoad(kernelFd int, initrdFd int, cmdline string, flags int) error {
+	cmdlineLen := len(cmdline)
+	if cmdlineLen > 0 {
+		// Account for the additional NULL byte added by
+		// BytePtrFromString in kexecFileLoad. The kexec_file_load
+		// syscall expects a NULL-terminated string.
+		cmdlineLen++
+	}
+	return kexecFileLoad(kernelFd, initrdFd, cmdlineLen, cmdline, flags)
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go
new file mode 100644
index 0000000000..d9530e5fbf
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go
@@ -0,0 +1,860 @@
+// mkerrors.sh -Wall -Werror -static -I/tmp/include
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+//go:build ppc && linux
+// +build ppc,linux
+
+// Code generated by cmd/cgo -godefs; DO NOT EDIT.
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go
+
+package unix
+
+import "syscall"
+
+const (
+	B1000000                         = 0x17
+	B115200                          = 0x11
+	B1152000                         = 0x18
+	B1500000                         = 0x19
+	B2000000                         = 0x1a
+	B230400                          = 0x12
+	B2500000                         = 0x1b
+	B3000000                         = 0x1c
+	B3500000                         = 0x1d
+	B4000000                         = 0x1e
+	B460800                          = 0x13
+	B500000                          = 0x14
+	B57600                           = 0x10
+	B576000                          = 0x15
+	B921600                          = 0x16
+	BLKBSZGET                        = 0x40041270
+	BLKBSZSET                        = 0x80041271
+	BLKFLSBUF                        = 0x20001261
+	BLKFRAGET                        = 0x20001265
+	BLKFRASET                        = 0x20001264
+	BLKGETSIZE                       = 0x20001260
+	BLKGETSIZE64                     = 0x40041272
+	BLKPBSZGET                       = 0x2000127b
+	BLKRAGET                         = 0x20001263
+	BLKRASET                         = 0x20001262
+	BLKROGET                         = 0x2000125e
+	BLKROSET                         = 0x2000125d
+	BLKRRPART                        = 0x2000125f
+	BLKSECTGET                       = 0x20001267
+	BLKSECTSET                       = 0x20001266
+	BLKSSZGET                        = 0x20001268
+	BOTHER                           = 0x1f
+	BS1                              = 0x8000
+	BSDLY                            = 0x8000
+	CBAUD                            = 0xff
+	CBAUDEX                          = 0x0
+	CIBAUD                           = 0xff0000
+	CLOCAL                           = 0x8000
+	CR1                              = 0x1000
+	CR2                              = 0x2000
+	CR3                              = 0x3000
+	CRDLY                            = 0x3000
+	CREAD                            = 0x800
+	CS6                              = 0x100
+	CS7                              = 0x200
+	CS8                              = 0x300
+	CSIZE                            = 0x300
+	CSTOPB                           = 0x400
+	ECHOCTL                          = 0x40
+	ECHOE                            = 0x2
+	ECHOK                            = 0x4
+	ECHOKE                           = 0x1
+	ECHONL                           = 0x10
+	ECHOPRT                          = 0x20
+	EFD_CLOEXEC                      = 0x80000
+	EFD_NONBLOCK                     = 0x800
+	EPOLL_CLOEXEC                    = 0x80000
+	EXTPROC                          = 0x10000000
+	FF1                              = 0x4000
+	FFDLY                            = 0x4000
+	FICLONE                          = 0x80049409
+	FICLONERANGE                     = 0x8020940d
+	FLUSHO                           = 0x800000
+	FS_IOC_ENABLE_VERITY             = 0x80806685
+	FS_IOC_GETFLAGS                  = 0x40046601
+	FS_IOC_GET_ENCRYPTION_NONCE      = 0x4010661b
+	FS_IOC_GET_ENCRYPTION_POLICY     = 0x800c6615
+	FS_IOC_GET_ENCRYPTION_PWSALT     = 0x80106614
+	FS_IOC_SETFLAGS                  = 0x80046602
+	FS_IOC_SET_ENCRYPTION_POLICY     = 0x400c6613
+	F_GETLK                          = 0xc
+	F_GETLK64                        = 0xc
+	F_GETOWN                         = 0x9
+	F_RDLCK                          = 0x0
+	F_SETLK                          = 0xd
+	F_SETLK64                        = 0xd
+	F_SETLKW                         = 0xe
+	F_SETLKW64                       = 0xe
+	F_SETOWN                         = 0x8
+	F_UNLCK                          = 0x2
+	F_WRLCK                          = 0x1
+	HIDIOCGRAWINFO                   = 0x40084803
+	HIDIOCGRDESC                     = 0x50044802
+	HIDIOCGRDESCSIZE                 = 0x40044801
+	HUPCL                            = 0x4000
+	ICANON                           = 0x100
+	IEXTEN                           = 0x400
+	IN_CLOEXEC                       = 0x80000
+	IN_NONBLOCK                      = 0x800
+	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
+	ISIG                             = 0x80
+	IUCLC                            = 0x1000
+	IXOFF                            = 0x400
+	IXON                             = 0x200
+	MAP_ANON                         = 0x20
+	MAP_ANONYMOUS                    = 0x20
+	MAP_DENYWRITE                    = 0x800
+	MAP_EXECUTABLE                   = 0x1000
+	MAP_GROWSDOWN                    = 0x100
+	MAP_HUGETLB                      = 0x40000
+	MAP_LOCKED                       = 0x80
+	MAP_NONBLOCK                     = 0x10000
+	MAP_NORESERVE                    = 0x40
+	MAP_POPULATE                     = 0x8000
+	MAP_STACK                        = 0x20000
+	MAP_SYNC                         = 0x80000
+	MCL_CURRENT                      = 0x2000
+	MCL_FUTURE                       = 0x4000
+	MCL_ONFAULT                      = 0x8000
+	NFDBITS                          = 0x20
+	NL2                              = 0x200
+	NL3                              = 0x300
+	NLDLY                            = 0x300
+	NOFLSH                           = 0x80000000
+	NS_GET_NSTYPE                    = 0x2000b703
+	NS_GET_OWNER_UID                 = 0x2000b704
+	NS_GET_PARENT                    = 0x2000b702
+	NS_GET_USERNS                    = 0x2000b701
+	OLCUC                            = 0x4
+	ONLCR                            = 0x2
+	O_APPEND                         = 0x400
+	O_ASYNC                          = 0x2000
+	O_CLOEXEC                        = 0x80000
+	O_CREAT                          = 0x40
+	O_DIRECT                         = 0x20000
+	O_DIRECTORY                      = 0x4000
+	O_DSYNC                          = 0x1000
+	O_EXCL                           = 0x80
+	O_FSYNC                          = 0x101000
+	O_LARGEFILE                      = 0x10000
+	O_NDELAY                         = 0x800
+	O_NOATIME                        = 0x40000
+	O_NOCTTY                         = 0x100
+	O_NOFOLLOW                       = 0x8000
+	O_NONBLOCK                       = 0x800
+	O_PATH                           = 0x200000
+	O_RSYNC                          = 0x101000
+	O_SYNC                           = 0x101000
+	O_TMPFILE                        = 0x404000
+	O_TRUNC                          = 0x200
+	PARENB                           = 0x1000
+	PARODD                           = 0x2000
+	PENDIN                           = 0x20000000
+	PERF_EVENT_IOC_DISABLE           = 0x20002401
+	PERF_EVENT_IOC_ENABLE            = 0x20002400
+	PERF_EVENT_IOC_ID                = 0x40042407
+	PERF_EVENT_IOC_MODIFY_ATTRIBUTES = 0x8004240b
+	PERF_EVENT_IOC_PAUSE_OUTPUT      = 0x80042409
+	PERF_EVENT_IOC_PERIOD            = 0x80082404
+	PERF_EVENT_IOC_QUERY_BPF         = 0xc004240a
+	PERF_EVENT_IOC_REFRESH           = 0x20002402
+	PERF_EVENT_IOC_RESET             = 0x20002403
+	PERF_EVENT_IOC_SET_BPF           = 0x80042408
+	PERF_EVENT_IOC_SET_FILTER        = 0x80042406
+	PERF_EVENT_IOC_SET_OUTPUT        = 0x20002405
+	PPPIOCATTACH                     = 0x8004743d
+	PPPIOCATTCHAN                    = 0x80047438
+	PPPIOCBRIDGECHAN                 = 0x80047435
+	PPPIOCCONNECT                    = 0x8004743a
+	PPPIOCDETACH                     = 0x8004743c
+	PPPIOCDISCONN                    = 0x20007439
+	PPPIOCGASYNCMAP                  = 0x40047458
+	PPPIOCGCHAN                      = 0x40047437
+	PPPIOCGDEBUG                     = 0x40047441
+	PPPIOCGFLAGS                     = 0x4004745a
+	PPPIOCGIDLE                      = 0x4008743f
+	PPPIOCGIDLE32                    = 0x4008743f
+	PPPIOCGIDLE64                    = 0x4010743f
+	PPPIOCGL2TPSTATS                 = 0x40487436
+	PPPIOCGMRU                       = 0x40047453
+	PPPIOCGRASYNCMAP                 = 0x40047455
+	PPPIOCGUNIT                      = 0x40047456
+	PPPIOCGXASYNCMAP                 = 0x40207450
+	PPPIOCSACTIVE                    = 0x80087446
+	PPPIOCSASYNCMAP                  = 0x80047457
+	PPPIOCSCOMPRESS                  = 0x800c744d
+	PPPIOCSDEBUG                     = 0x80047440
+	PPPIOCSFLAGS                     = 0x80047459
+	PPPIOCSMAXCID                    = 0x80047451
+	PPPIOCSMRRU                      = 0x8004743b
+	PPPIOCSMRU                       = 0x80047452
+	PPPIOCSNPMODE                    = 0x8008744b
+	PPPIOCSPASS                      = 0x80087447
+	PPPIOCSRASYNCMAP                 = 0x80047454
+	PPPIOCSXASYNCMAP                 = 0x8020744f
+	PPPIOCUNBRIDGECHAN               = 0x20007434
+	PPPIOCXFERUNIT                   = 0x2000744e
+	PROT_SAO                         = 0x10
+	PR_SET_PTRACER_ANY               = 0xffffffff
+	PTRACE_GETEVRREGS                = 0x14
+	PTRACE_GETFPREGS                 = 0xe
+	PTRACE_GETREGS64                 = 0x16
+	PTRACE_GETVRREGS                 = 0x12
+	PTRACE_GETVSRREGS                = 0x1b
+	PTRACE_GET_DEBUGREG              = 0x19
+	PTRACE_SETEVRREGS                = 0x15
+	PTRACE_SETFPREGS                 = 0xf
+	PTRACE_SETREGS64                 = 0x17
+	PTRACE_SETVRREGS                 = 0x13
+	PTRACE_SETVSRREGS                = 0x1c
+	PTRACE_SET_DEBUGREG              = 0x1a
+	PTRACE_SINGLEBLOCK               = 0x100
+	PTRACE_SYSEMU                    = 0x1d
+	PTRACE_SYSEMU_SINGLESTEP         = 0x1e
+	PT_CCR                           = 0x26
+	PT_CTR                           = 0x23
+	PT_DAR                           = 0x29
+	PT_DSCR                          = 0x2c
+	PT_DSISR                         = 0x2a
+	PT_FPR0                          = 0x30
+	PT_FPR31                         = 0x6e
+	PT_FPSCR                         = 0x71
+	PT_LNK                           = 0x24
+	PT_MQ                            = 0x27
+	PT_MSR                           = 0x21
+	PT_NIP                           = 0x20
+	PT_ORIG_R3                       = 0x22
+	PT_R0                            = 0x0
+	PT_R1                            = 0x1
+	PT_R10                           = 0xa
+	PT_R11                           = 0xb
+	PT_R12                           = 0xc
+	PT_R13                           = 0xd
+	PT_R14                           = 0xe
+	PT_R15                           = 0xf
+	PT_R16                           = 0x10
+	PT_R17                           = 0x11
+	PT_R18                           = 0x12
+	PT_R19                           = 0x13
+	PT_R2                            = 0x2
+	PT_R20                           = 0x14
+	PT_R21                           = 0x15
+	PT_R22                           = 0x16
+	PT_R23                           = 0x17
+	PT_R24                           = 0x18
+	PT_R25                           = 0x19
+	PT_R26                           = 0x1a
+	PT_R27                           = 0x1b
+	PT_R28                           = 0x1c
+	PT_R29                           = 0x1d
+	PT_R3                            = 0x3
+	PT_R30                           = 0x1e
+	PT_R31                           = 0x1f
+	PT_R4                            = 0x4
+	PT_R5                            = 0x5
+	PT_R6                            = 0x6
+	PT_R7                            = 0x7
+	PT_R8                            = 0x8
+	PT_R9                            = 0x9
+	PT_REGS_COUNT                    = 0x2c
+	PT_RESULT                        = 0x2b
+	PT_TRAP                          = 0x28
+	PT_XER                           = 0x25
+	RLIMIT_AS                        = 0x9
+	RLIMIT_MEMLOCK                   = 0x8
+	RLIMIT_NOFILE                    = 0x7
+	RLIMIT_NPROC                     = 0x6
+	RLIMIT_RSS                       = 0x5
+	RNDADDENTROPY                    = 0x80085203
+	RNDADDTOENTCNT                   = 0x80045201
+	RNDCLEARPOOL                     = 0x20005206
+	RNDGETENTCNT                     = 0x40045200
+	RNDGETPOOL                       = 0x40085202
+	RNDRESEEDCRNG                    = 0x20005207
+	RNDZAPENTCNT                     = 0x20005204
+	RTC_AIE_OFF                      = 0x20007002
+	RTC_AIE_ON                       = 0x20007001
+	RTC_ALM_READ                     = 0x40247008
+	RTC_ALM_SET                      = 0x80247007
+	RTC_EPOCH_READ                   = 0x4004700d
+	RTC_EPOCH_SET                    = 0x8004700e
+	RTC_IRQP_READ                    = 0x4004700b
+	RTC_IRQP_SET                     = 0x8004700c
+	RTC_PIE_OFF                      = 0x20007006
+	RTC_PIE_ON                       = 0x20007005
+	RTC_PLL_GET                      = 0x401c7011
+	RTC_PLL_SET                      = 0x801c7012
+	RTC_RD_TIME                      = 0x40247009
+	RTC_SET_TIME                     = 0x8024700a
+	RTC_UIE_OFF                      = 0x20007004
+	RTC_UIE_ON                       = 0x20007003
+	RTC_VL_CLR                       = 0x20007014
+	RTC_VL_READ                      = 0x40047013
+	RTC_WIE_OFF                      = 0x20007010
+	RTC_WIE_ON                       = 0x2000700f
+	RTC_WKALM_RD                     = 0x40287010
+	RTC_WKALM_SET                    = 0x8028700f
+	SCM_TIMESTAMPING                 = 0x25
+	SCM_TIMESTAMPING_OPT_STATS       = 0x36
+	SCM_TIMESTAMPING_PKTINFO         = 0x3a
+	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TXTIME                       = 0x3d
+	SCM_WIFI_STATUS                  = 0x29
+	SFD_CLOEXEC                      = 0x80000
+	SFD_NONBLOCK                     = 0x800
+	SIOCATMARK                       = 0x8905
+	SIOCGPGRP                        = 0x8904
+	SIOCGSTAMPNS_NEW                 = 0x40108907
+	SIOCGSTAMP_NEW                   = 0x40108906
+	SIOCINQ                          = 0x4004667f
+	SIOCOUTQ                         = 0x40047473
+	SIOCSPGRP                        = 0x8902
+	SOCK_CLOEXEC                     = 0x80000
+	SOCK_DGRAM                       = 0x2
+	SOCK_NONBLOCK                    = 0x800
+	SOCK_STREAM                      = 0x1
+	SOL_SOCKET                       = 0x1
+	SO_ACCEPTCONN                    = 0x1e
+	SO_ATTACH_BPF                    = 0x32
+	SO_ATTACH_REUSEPORT_CBPF         = 0x33
+	SO_ATTACH_REUSEPORT_EBPF         = 0x34
+	SO_BINDTODEVICE                  = 0x19
+	SO_BINDTOIFINDEX                 = 0x3e
+	SO_BPF_EXTENSIONS                = 0x30
+	SO_BROADCAST                     = 0x6
+	SO_BSDCOMPAT                     = 0xe
+	SO_BUSY_POLL                     = 0x2e
+	SO_BUSY_POLL_BUDGET              = 0x46
+	SO_CNX_ADVICE                    = 0x35
+	SO_COOKIE                        = 0x39
+	SO_DETACH_REUSEPORT_BPF          = 0x44
+	SO_DOMAIN                        = 0x27
+	SO_DONTROUTE                     = 0x5
+	SO_ERROR                         = 0x4
+	SO_INCOMING_CPU                  = 0x31
+	SO_INCOMING_NAPI_ID              = 0x38
+	SO_KEEPALIVE                     = 0x9
+	SO_LINGER                        = 0xd
+	SO_LOCK_FILTER                   = 0x2c
+	SO_MARK                          = 0x24
+	SO_MAX_PACING_RATE               = 0x2f
+	SO_MEMINFO                       = 0x37
+	SO_NOFCS                         = 0x2b
+	SO_OOBINLINE                     = 0xa
+	SO_PASSCRED                      = 0x14
+	SO_PASSSEC                       = 0x22
+	SO_PEEK_OFF                      = 0x2a
+	SO_PEERCRED                      = 0x15
+	SO_PEERGROUPS                    = 0x3b
+	SO_PEERSEC                       = 0x1f
+	SO_PREFER_BUSY_POLL              = 0x45
+	SO_PROTOCOL                      = 0x26
+	SO_RCVBUF                        = 0x8
+	SO_RCVBUFFORCE                   = 0x21
+	SO_RCVLOWAT                      = 0x10
+	SO_RCVTIMEO                      = 0x12
+	SO_RCVTIMEO_NEW                  = 0x42
+	SO_RCVTIMEO_OLD                  = 0x12
+	SO_REUSEADDR                     = 0x2
+	SO_REUSEPORT                     = 0xf
+	SO_RXQ_OVFL                      = 0x28
+	SO_SECURITY_AUTHENTICATION       = 0x16
+	SO_SECURITY_ENCRYPTION_NETWORK   = 0x18
+	SO_SECURITY_ENCRYPTION_TRANSPORT = 0x17
+	SO_SELECT_ERR_QUEUE              = 0x2d
+	SO_SNDBUF                        = 0x7
+	SO_SNDBUFFORCE                   = 0x20
+	SO_SNDLOWAT                      = 0x11
+	SO_SNDTIMEO                      = 0x13
+	SO_SNDTIMEO_NEW                  = 0x43
+	SO_SNDTIMEO_OLD                  = 0x13
+	SO_TIMESTAMPING                  = 0x25
+	SO_TIMESTAMPING_NEW              = 0x41
+	SO_TIMESTAMPING_OLD              = 0x25
+	SO_TIMESTAMPNS                   = 0x23
+	SO_TIMESTAMPNS_NEW               = 0x40
+	SO_TIMESTAMPNS_OLD               = 0x23
+	SO_TIMESTAMP_NEW                 = 0x3f
+	SO_TXTIME                        = 0x3d
+	SO_TYPE                          = 0x3
+	SO_WIFI_STATUS                   = 0x29
+	SO_ZEROCOPY                      = 0x3c
+	TAB1                             = 0x400
+	TAB2                             = 0x800
+	TAB3                             = 0xc00
+	TABDLY                           = 0xc00
+	TCFLSH                           = 0x2000741f
+	TCGETA                           = 0x40147417
+	TCGETS                           = 0x402c7413
+	TCSAFLUSH                        = 0x2
+	TCSBRK                           = 0x2000741d
+	TCSBRKP                          = 0x5425
+	TCSETA                           = 0x80147418
+	TCSETAF                          = 0x8014741c
+	TCSETAW                          = 0x80147419
+	TCSETS                           = 0x802c7414
+	TCSETSF                          = 0x802c7416
+	TCSETSW                          = 0x802c7415
+	TCXONC                           = 0x2000741e
+	TFD_CLOEXEC                      = 0x80000
+	TFD_NONBLOCK                     = 0x800
+	TIOCCBRK                         = 0x5428
+	TIOCCONS                         = 0x541d
+	TIOCEXCL                         = 0x540c
+	TIOCGDEV                         = 0x40045432
+	TIOCGETC                         = 0x40067412
+	TIOCGETD                         = 0x5424
+	TIOCGETP                         = 0x40067408
+	TIOCGEXCL                        = 0x40045440
+	TIOCGICOUNT                      = 0x545d
+	TIOCGISO7816                     = 0x40285442
+	TIOCGLCKTRMIOS                   = 0x5456
+	TIOCGLTC                         = 0x40067474
+	TIOCGPGRP                        = 0x40047477
+	TIOCGPKT                         = 0x40045438
+	TIOCGPTLCK                       = 0x40045439
+	TIOCGPTN                         = 0x40045430
+	TIOCGPTPEER                      = 0x20005441
+	TIOCGRS485                       = 0x542e
+	TIOCGSERIAL                      = 0x541e
+	TIOCGSID                         = 0x5429
+	TIOCGSOFTCAR                     = 0x5419
+	TIOCGWINSZ                       = 0x40087468
+	TIOCINQ                          = 0x4004667f
+	TIOCLINUX                        = 0x541c
+	TIOCMBIC                         = 0x5417
+	TIOCMBIS                         = 0x5416
+	TIOCMGET                         = 0x5415
+	TIOCMIWAIT                       = 0x545c
+	TIOCMSET                         = 0x5418
+	TIOCM_CAR                        = 0x40
+	TIOCM_CD                         = 0x40
+	TIOCM_CTS                        = 0x20
+	TIOCM_DSR                        = 0x100
+	TIOCM_LOOP                       = 0x8000
+	TIOCM_OUT1                       = 0x2000
+	TIOCM_OUT2                       = 0x4000
+	TIOCM_RI                         = 0x80
+	TIOCM_RNG                        = 0x80
+	TIOCM_SR                         = 0x10
+	TIOCM_ST                         = 0x8
+	TIOCNOTTY                        = 0x5422
+	TIOCNXCL                         = 0x540d
+	TIOCOUTQ                         = 0x40047473
+	TIOCPKT                          = 0x5420
+	TIOCSBRK                         = 0x5427
+	TIOCSCTTY                        = 0x540e
+	TIOCSERCONFIG                    = 0x5453
+	TIOCSERGETLSR                    = 0x5459
+	TIOCSERGETMULTI                  = 0x545a
+	TIOCSERGSTRUCT                   = 0x5458
+	TIOCSERGWILD                     = 0x5454
+	TIOCSERSETMULTI                  = 0x545b
+	TIOCSERSWILD                     = 0x5455
+	TIOCSER_TEMT                     = 0x1
+	TIOCSETC                         = 0x80067411
+	TIOCSETD                         = 0x5423
+	TIOCSETN                         = 0x8006740a
+	TIOCSETP                         = 0x80067409
+	TIOCSIG                          = 0x80045436
+	TIOCSISO7816                     = 0xc0285443
+	TIOCSLCKTRMIOS                   = 0x5457
+	TIOCSLTC                         = 0x80067475
+	TIOCSPGRP                        = 0x80047476
+	TIOCSPTLCK                       = 0x80045431
+	TIOCSRS485                       = 0x542f
+	TIOCSSERIAL                      = 0x541f
+	TIOCSSOFTCAR                     = 0x541a
+	TIOCSTART                        = 0x2000746e
+	TIOCSTI                          = 0x5412
+	TIOCSTOP                         = 0x2000746f
+	TIOCSWINSZ                       = 0x80087467
+	TIOCVHANGUP                      = 0x5437
+	TOSTOP                           = 0x400000
+	TUNATTACHFILTER                  = 0x800854d5
+	TUNDETACHFILTER                  = 0x800854d6
+	TUNGETDEVNETNS                   = 0x200054e3
+	TUNGETFEATURES                   = 0x400454cf
+	TUNGETFILTER                     = 0x400854db
+	TUNGETIFF                        = 0x400454d2
+	TUNGETSNDBUF                     = 0x400454d3
+	TUNGETVNETBE                     = 0x400454df
+	TUNGETVNETHDRSZ                  = 0x400454d7
+	TUNGETVNETLE                     = 0x400454dd
+	TUNSETCARRIER                    = 0x800454e2
+	TUNSETDEBUG                      = 0x800454c9
+	TUNSETFILTEREBPF                 = 0x400454e1
+	TUNSETGROUP                      = 0x800454ce
+	TUNSETIFF                        = 0x800454ca
+	TUNSETIFINDEX                    = 0x800454da
+	TUNSETLINK                       = 0x800454cd
+	TUNSETNOCSUM                     = 0x800454c8
+	TUNSETOFFLOAD                    = 0x800454d0
+	TUNSETOWNER                      = 0x800454cc
+	TUNSETPERSIST                    = 0x800454cb
+	TUNSETQUEUE                      = 0x800454d9
+	TUNSETSNDBUF                     = 0x800454d4
+	TUNSETSTEERINGEBPF               = 0x400454e0
+	TUNSETTXFILTER                   = 0x800454d1
+	TUNSETVNETBE                     = 0x800454de
+	TUNSETVNETHDRSZ                  = 0x800454d8
+	TUNSETVNETLE                     = 0x800454dc
+	UBI_IOCATT                       = 0x80186f40
+	UBI_IOCDET                       = 0x80046f41
+	UBI_IOCEBCH                      = 0x80044f02
+	UBI_IOCEBER                      = 0x80044f01
+	UBI_IOCEBISMAP                   = 0x40044f05
+	UBI_IOCEBMAP                     = 0x80084f03
+	UBI_IOCEBUNMAP                   = 0x80044f04
+	UBI_IOCMKVOL                     = 0x80986f00
+	UBI_IOCRMVOL                     = 0x80046f01
+	UBI_IOCRNVOL                     = 0x91106f03
+	UBI_IOCRPEB                      = 0x80046f04
+	UBI_IOCRSVOL                     = 0x800c6f02
+	UBI_IOCSETVOLPROP                = 0x80104f06
+	UBI_IOCSPEB                      = 0x80046f05
+	UBI_IOCVOLCRBLK                  = 0x80804f07
+	UBI_IOCVOLRMBLK                  = 0x20004f08
+	UBI_IOCVOLUP                     = 0x80084f00
+	VDISCARD                         = 0x10
+	VEOF                             = 0x4
+	VEOL                             = 0x6
+	VEOL2                            = 0x8
+	VMIN                             = 0x5
+	VREPRINT                         = 0xb
+	VSTART                           = 0xd
+	VSTOP                            = 0xe
+	VSUSP                            = 0xc
+	VSWTC                            = 0x9
+	VT1                              = 0x10000
+	VTDLY                            = 0x10000
+	VTIME                            = 0x7
+	VWERASE                          = 0xa
+	WDIOC_GETBOOTSTATUS              = 0x40045702
+	WDIOC_GETPRETIMEOUT              = 0x40045709
+	WDIOC_GETSTATUS                  = 0x40045701
+	WDIOC_GETSUPPORT                 = 0x40285700
+	WDIOC_GETTEMP                    = 0x40045703
+	WDIOC_GETTIMELEFT                = 0x4004570a
+	WDIOC_GETTIMEOUT                 = 0x40045707
+	WDIOC_KEEPALIVE                  = 0x40045705
+	WDIOC_SETOPTIONS                 = 0x40045704
+	WORDSIZE                         = 0x20
+	XCASE                            = 0x4000
+	XTABS                            = 0xc00
+	_HIDIOCGRAWNAME                  = 0x40804804
+	_HIDIOCGRAWPHYS                  = 0x40404805
+	_HIDIOCGRAWUNIQ                  = 0x40404808
+)
+
+// Errors
+const (
+	EADDRINUSE      = syscall.Errno(0x62)
+	EADDRNOTAVAIL   = syscall.Errno(0x63)
+	EADV            = syscall.Errno(0x44)
+	EAFNOSUPPORT    = syscall.Errno(0x61)
+	EALREADY        = syscall.Errno(0x72)
+	EBADE           = syscall.Errno(0x34)
+	EBADFD          = syscall.Errno(0x4d)
+	EBADMSG         = syscall.Errno(0x4a)
+	EBADR           = syscall.Errno(0x35)
+	EBADRQC         = syscall.Errno(0x38)
+	EBADSLT         = syscall.Errno(0x39)
+	EBFONT          = syscall.Errno(0x3b)
+	ECANCELED       = syscall.Errno(0x7d)
+	ECHRNG          = syscall.Errno(0x2c)
+	ECOMM           = syscall.Errno(0x46)
+	ECONNABORTED    = syscall.Errno(0x67)
+	ECONNREFUSED    = syscall.Errno(0x6f)
+	ECONNRESET      = syscall.Errno(0x68)
+	EDEADLK         = syscall.Errno(0x23)
+	EDEADLOCK       = syscall.Errno(0x3a)
+	EDESTADDRREQ    = syscall.Errno(0x59)
+	EDOTDOT         = syscall.Errno(0x49)
+	EDQUOT          = syscall.Errno(0x7a)
+	EHOSTDOWN       = syscall.Errno(0x70)
+	EHOSTUNREACH    = syscall.Errno(0x71)
+	EHWPOISON       = syscall.Errno(0x85)
+	EIDRM           = syscall.Errno(0x2b)
+	EILSEQ          = syscall.Errno(0x54)
+	EINPROGRESS     = syscall.Errno(0x73)
+	EISCONN         = syscall.Errno(0x6a)
+	EISNAM          = syscall.Errno(0x78)
+	EKEYEXPIRED     = syscall.Errno(0x7f)
+	EKEYREJECTED    = syscall.Errno(0x81)
+	EKEYREVOKED     = syscall.Errno(0x80)
+	EL2HLT          = syscall.Errno(0x33)
+	EL2NSYNC        = syscall.Errno(0x2d)
+	EL3HLT          = syscall.Errno(0x2e)
+	EL3RST          = syscall.Errno(0x2f)
+	ELIBACC         = syscall.Errno(0x4f)
+	ELIBBAD         = syscall.Errno(0x50)
+	ELIBEXEC        = syscall.Errno(0x53)
+	ELIBMAX         = syscall.Errno(0x52)
+	ELIBSCN         = syscall.Errno(0x51)
+	ELNRNG          = syscall.Errno(0x30)
+	ELOOP           = syscall.Errno(0x28)
+	EMEDIUMTYPE     = syscall.Errno(0x7c)
+	EMSGSIZE        = syscall.Errno(0x5a)
+	EMULTIHOP       = syscall.Errno(0x48)
+	ENAMETOOLONG    = syscall.Errno(0x24)
+	ENAVAIL         = syscall.Errno(0x77)
+	ENETDOWN        = syscall.Errno(0x64)
+	ENETRESET       = syscall.Errno(0x66)
+	ENETUNREACH     = syscall.Errno(0x65)
+	ENOANO          = syscall.Errno(0x37)
+	ENOBUFS         = syscall.Errno(0x69)
+	ENOCSI          = syscall.Errno(0x32)
+	ENODATA         = syscall.Errno(0x3d)
+	ENOKEY          = syscall.Errno(0x7e)
+	ENOLCK          = syscall.Errno(0x25)
+	ENOLINK         = syscall.Errno(0x43)
+	ENOMEDIUM       = syscall.Errno(0x7b)
+	ENOMSG          = syscall.Errno(0x2a)
+	ENONET          = syscall.Errno(0x40)
+	ENOPKG          = syscall.Errno(0x41)
+	ENOPROTOOPT     = syscall.Errno(0x5c)
+	ENOSR           = syscall.Errno(0x3f)
+	ENOSTR          = syscall.Errno(0x3c)
+	ENOSYS          = syscall.Errno(0x26)
+	ENOTCONN        = syscall.Errno(0x6b)
+	ENOTEMPTY       = syscall.Errno(0x27)
+	ENOTNAM         = syscall.Errno(0x76)
+	ENOTRECOVERABLE = syscall.Errno(0x83)
+	ENOTSOCK        = syscall.Errno(0x58)
+	ENOTSUP         = syscall.Errno(0x5f)
+	ENOTUNIQ        = syscall.Errno(0x4c)
+	EOPNOTSUPP      = syscall.Errno(0x5f)
+	EOVERFLOW       = syscall.Errno(0x4b)
+	EOWNERDEAD      = syscall.Errno(0x82)
+	EPFNOSUPPORT    = syscall.Errno(0x60)
+	EPROTO          = syscall.Errno(0x47)
+	EPROTONOSUPPORT = syscall.Errno(0x5d)
+	EPROTOTYPE      = syscall.Errno(0x5b)
+	EREMCHG         = syscall.Errno(0x4e)
+	EREMOTE         = syscall.Errno(0x42)
+	EREMOTEIO       = syscall.Errno(0x79)
+	ERESTART        = syscall.Errno(0x55)
+	ERFKILL         = syscall.Errno(0x84)
+	ESHUTDOWN       = syscall.Errno(0x6c)
+	ESOCKTNOSUPPORT = syscall.Errno(0x5e)
+	ESRMNT          = syscall.Errno(0x45)
+	ESTALE          = syscall.Errno(0x74)
+	ESTRPIPE        = syscall.Errno(0x56)
+	ETIME           = syscall.Errno(0x3e)
+	ETIMEDOUT       = syscall.Errno(0x6e)
+	ETOOMANYREFS    = syscall.Errno(0x6d)
+	EUCLEAN         = syscall.Errno(0x75)
+	EUNATCH         = syscall.Errno(0x31)
+	EUSERS          = syscall.Errno(0x57)
+	EXFULL          = syscall.Errno(0x36)
+)
+
+// Signals
+const (
+	SIGBUS    = syscall.Signal(0x7)
+	SIGCHLD   = syscall.Signal(0x11)
+	SIGCLD    = syscall.Signal(0x11)
+	SIGCONT   = syscall.Signal(0x12)
+	SIGIO     = syscall.Signal(0x1d)
+	SIGPOLL   = syscall.Signal(0x1d)
+	SIGPROF   = syscall.Signal(0x1b)
+	SIGPWR    = syscall.Signal(0x1e)
+	SIGSTKFLT = syscall.Signal(0x10)
+	SIGSTOP   = syscall.Signal(0x13)
+	SIGSYS    = syscall.Signal(0x1f)
+	SIGTSTP   = syscall.Signal(0x14)
+	SIGTTIN   = syscall.Signal(0x15)
+	SIGTTOU   = syscall.Signal(0x16)
+	SIGURG    = syscall.Signal(0x17)
+	SIGUSR1   = syscall.Signal(0xa)
+	SIGUSR2   = syscall.Signal(0xc)
+	SIGVTALRM = syscall.Signal(0x1a)
+	SIGWINCH  = syscall.Signal(0x1c)
+	SIGXCPU   = syscall.Signal(0x18)
+	SIGXFSZ   = syscall.Signal(0x19)
+)
+
+// Error table
+var errorList = [...]struct {
+	num  syscall.Errno
+	name string
+	desc string
+}{
+	{1, "EPERM", "operation not permitted"},
+	{2, "ENOENT", "no such file or directory"},
+	{3, "ESRCH", "no such process"},
+	{4, "EINTR", "interrupted system call"},
+	{5, "EIO", "input/output error"},
+	{6, "ENXIO", "no such device or address"},
+	{7, "E2BIG", "argument list too long"},
+	{8, "ENOEXEC", "exec format error"},
+	{9, "EBADF", "bad file descriptor"},
+	{10, "ECHILD", "no child processes"},
+	{11, "EAGAIN", "resource temporarily unavailable"},
+	{12, "ENOMEM", "cannot allocate memory"},
+	{13, "EACCES", "permission denied"},
+	{14, "EFAULT", "bad address"},
+	{15, "ENOTBLK", "block device required"},
+	{16, "EBUSY", "device or resource busy"},
+	{17, "EEXIST", "file exists"},
+	{18, "EXDEV", "invalid cross-device link"},
+	{19, "ENODEV", "no such device"},
+	{20, "ENOTDIR", "not a directory"},
+	{21, "EISDIR", "is a directory"},
+	{22, "EINVAL", "invalid argument"},
+	{23, "ENFILE", "too many open files in system"},
+	{24, "EMFILE", "too many open files"},
+	{25, "ENOTTY", "inappropriate ioctl for device"},
+	{26, "ETXTBSY", "text file busy"},
+	{27, "EFBIG", "file too large"},
+	{28, "ENOSPC", "no space left on device"},
+	{29, "ESPIPE", "illegal seek"},
+	{30, "EROFS", "read-only file system"},
+	{31, "EMLINK", "too many links"},
+	{32, "EPIPE", "broken pipe"},
+	{33, "EDOM", "numerical argument out of domain"},
+	{34, "ERANGE", "numerical result out of range"},
+	{35, "EDEADLK", "resource deadlock avoided"},
+	{36, "ENAMETOOLONG", "file name too long"},
+	{37, "ENOLCK", "no locks available"},
+	{38, "ENOSYS", "function not implemented"},
+	{39, "ENOTEMPTY", "directory not empty"},
+	{40, "ELOOP", "too many levels of symbolic links"},
+	{42, "ENOMSG", "no message of desired type"},
+	{43, "EIDRM", "identifier removed"},
+	{44, "ECHRNG", "channel number out of range"},
+	{45, "EL2NSYNC", "level 2 not synchronized"},
+	{46, "EL3HLT", "level 3 halted"},
+	{47, "EL3RST", "level 3 reset"},
+	{48, "ELNRNG", "link number out of range"},
+	{49, "EUNATCH", "protocol driver not attached"},
+	{50, "ENOCSI", "no CSI structure available"},
+	{51, "EL2HLT", "level 2 halted"},
+	{52, "EBADE", "invalid exchange"},
+	{53, "EBADR", "invalid request descriptor"},
+	{54, "EXFULL", "exchange full"},
+	{55, "ENOANO", "no anode"},
+	{56, "EBADRQC", "invalid request code"},
+	{57, "EBADSLT", "invalid slot"},
+	{58, "EDEADLOCK", "file locking deadlock error"},
+	{59, "EBFONT", "bad font file format"},
+	{60, "ENOSTR", "device not a stream"},
+	{61, "ENODATA", "no data available"},
+	{62, "ETIME", "timer expired"},
+	{63, "ENOSR", "out of streams resources"},
+	{64, "ENONET", "machine is not on the network"},
+	{65, "ENOPKG", "package not installed"},
+	{66, "EREMOTE", "object is remote"},
+	{67, "ENOLINK", "link has been severed"},
+	{68, "EADV", "advertise error"},
+	{69, "ESRMNT", "srmount error"},
+	{70, "ECOMM", "communication error on send"},
+	{71, "EPROTO", "protocol error"},
+	{72, "EMULTIHOP", "multihop attempted"},
+	{73, "EDOTDOT", "RFS specific error"},
+	{74, "EBADMSG", "bad message"},
+	{75, "EOVERFLOW", "value too large for defined data type"},
+	{76, "ENOTUNIQ", "name not unique on network"},
+	{77, "EBADFD", "file descriptor in bad state"},
+	{78, "EREMCHG", "remote address changed"},
+	{79, "ELIBACC", "can not access a needed shared library"},
+	{80, "ELIBBAD", "accessing a corrupted shared library"},
+	{81, "ELIBSCN", ".lib section in a.out corrupted"},
+	{82, "ELIBMAX", "attempting to link in too many shared libraries"},
+	{83, "ELIBEXEC", "cannot exec a shared library directly"},
+	{84, "EILSEQ", "invalid or incomplete multibyte or wide character"},
+	{85, "ERESTART", "interrupted system call should be restarted"},
+	{86, "ESTRPIPE", "streams pipe error"},
+	{87, "EUSERS", "too many users"},
+	{88, "ENOTSOCK", "socket operation on non-socket"},
+	{89, "EDESTADDRREQ", "destination address required"},
+	{90, "EMSGSIZE", "message too long"},
+	{91, "EPROTOTYPE", "protocol wrong type for socket"},
+	{92, "ENOPROTOOPT", "protocol not available"},
+	{93, "EPROTONOSUPPORT", "protocol not supported"},
+	{94, "ESOCKTNOSUPPORT", "socket type not supported"},
+	{95, "ENOTSUP", "operation not supported"},
+	{96, "EPFNOSUPPORT", "protocol family not supported"},
+	{97, "EAFNOSUPPORT", "address family not supported by protocol"},
+	{98, "EADDRINUSE", "address already in use"},
+	{99, "EADDRNOTAVAIL", "cannot assign requested address"},
+	{100, "ENETDOWN", "network is down"},
+	{101, "ENETUNREACH", "network is unreachable"},
+	{102, "ENETRESET", "network dropped connection on reset"},
+	{103, "ECONNABORTED", "software caused connection abort"},
+	{104, "ECONNRESET", "connection reset by peer"},
+	{105, "ENOBUFS", "no buffer space available"},
+	{106, "EISCONN", "transport endpoint is already connected"},
+	{107, "ENOTCONN", "transport endpoint is not connected"},
+	{108, "ESHUTDOWN", "cannot send after transport endpoint shutdown"},
+	{109, "ETOOMANYREFS", "too many references: cannot splice"},
+	{110, "ETIMEDOUT", "connection timed out"},
+	{111, "ECONNREFUSED", "connection refused"},
+	{112, "EHOSTDOWN", "host is down"},
+	{113, "EHOSTUNREACH", "no route to host"},
+	{114, "EALREADY", "operation already in progress"},
+	{115, "EINPROGRESS", "operation now in progress"},
+	{116, "ESTALE", "stale file handle"},
+	{117, "EUCLEAN", "structure needs cleaning"},
+	{118, "ENOTNAM", "not a XENIX named type file"},
+	{119, "ENAVAIL", "no XENIX semaphores available"},
+	{120, "EISNAM", "is a named type file"},
+	{121, "EREMOTEIO", "remote I/O error"},
+	{122, "EDQUOT", "disk quota exceeded"},
+	{123, "ENOMEDIUM", "no medium found"},
+	{124, "EMEDIUMTYPE", "wrong medium type"},
+	{125, "ECANCELED", "operation canceled"},
+	{126, "ENOKEY", "required key not available"},
+	{127, "EKEYEXPIRED", "key has expired"},
+	{128, "EKEYREVOKED", "key has been revoked"},
+	{129, "EKEYREJECTED", "key was rejected by service"},
+	{130, "EOWNERDEAD", "owner died"},
+	{131, "ENOTRECOVERABLE", "state not recoverable"},
+	{132, "ERFKILL", "operation not possible due to RF-kill"},
+	{133, "EHWPOISON", "memory page has hardware error"},
+}
+
+// Signal table
+var signalList = [...]struct {
+	num  syscall.Signal
+	name string
+	desc string
+}{
+	{1, "SIGHUP", "hangup"},
+	{2, "SIGINT", "interrupt"},
+	{3, "SIGQUIT", "quit"},
+	{4, "SIGILL", "illegal instruction"},
+	{5, "SIGTRAP", "trace/breakpoint trap"},
+	{6, "SIGABRT", "aborted"},
+	{7, "SIGBUS", "bus error"},
+	{8, "SIGFPE", "floating point exception"},
+	{9, "SIGKILL", "killed"},
+	{10, "SIGUSR1", "user defined signal 1"},
+	{11, "SIGSEGV", "segmentation fault"},
+	{12, "SIGUSR2", "user defined signal 2"},
+	{13, "SIGPIPE", "broken pipe"},
+	{14, "SIGALRM", "alarm clock"},
+	{15, "SIGTERM", "terminated"},
+	{16, "SIGSTKFLT", "stack fault"},
+	{17, "SIGCHLD", "child exited"},
+	{18, "SIGCONT", "continued"},
+	{19, "SIGSTOP", "stopped (signal)"},
+	{20, "SIGTSTP", "stopped"},
+	{21, "SIGTTIN", "stopped (tty input)"},
+	{22, "SIGTTOU", "stopped (tty output)"},
+	{23, "SIGURG", "urgent I/O condition"},
+	{24, "SIGXCPU", "CPU time limit exceeded"},
+	{25, "SIGXFSZ", "file size limit exceeded"},
+	{26, "SIGVTALRM", "virtual timer expired"},
+	{27, "SIGPROF", "profiling timer expired"},
+	{28, "SIGWINCH", "window changed"},
+	{29, "SIGIO", "I/O possible"},
+	{30, "SIGPWR", "power failure"},
+	{31, "SIGSYS", "bad system call"},
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go
index c8c7909038..4e87b4bebd 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go
@@ -164,6 +164,12 @@ const (
 	MAP_PRIVATE                     = 0x1 // changes are private
 	MAP_SHARED                      = 0x2 // changes are shared
 	MAP_FIXED                       = 0x4 // place exactly
+	MCAST_JOIN_GROUP                = 40
+	MCAST_LEAVE_GROUP               = 41
+	MCAST_JOIN_SOURCE_GROUP         = 42
+	MCAST_LEAVE_SOURCE_GROUP        = 43
+	MCAST_BLOCK_SOURCE              = 44
+	MCAST_UNBLOCK_SOURCE            = 45
 	MS_SYNC                         = 0x1 // msync - synchronous writes
 	MS_ASYNC                        = 0x2 // asynchronous writes
 	MS_INVALIDATE                   = 0x4 // invalidate mappings
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc.go
new file mode 100644
index 0000000000..927cf1a00f
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc.go
@@ -0,0 +1,762 @@
+// go run mksyscall.go -b32 -tags linux,ppc syscall_linux.go syscall_linux_ppc.go
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+//go:build linux && ppc
+// +build linux,ppc
+
+package unix
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+var _ syscall.Errno
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func fanotifyMark(fd int, flags uint, mask uint64, dirFd int, pathname *byte) (err error) {
+	_, _, e1 := Syscall6(SYS_FANOTIFY_MARK, uintptr(fd), uintptr(flags), uintptr(mask>>32), uintptr(mask), uintptr(dirFd), uintptr(unsafe.Pointer(pathname)))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fallocate(fd int, mode uint32, off int64, len int64) (err error) {
+	_, _, e1 := Syscall6(SYS_FALLOCATE, uintptr(fd), uintptr(mode), uintptr(off>>32), uintptr(off), uintptr(len>>32), uintptr(len))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Tee(rfd int, wfd int, len int, flags int) (n int64, err error) {
+	r0, r1, e1 := Syscall6(SYS_TEE, uintptr(rfd), uintptr(wfd), uintptr(len), uintptr(flags), 0, 0)
+	n = int64(int64(r0)<<32 | int64(r1))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func dup2(oldfd int, newfd int) (err error) {
+	_, _, e1 := Syscall(SYS_DUP2, uintptr(oldfd), uintptr(newfd), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func EpollCreate(size int) (fd int, err error) {
+	r0, _, e1 := RawSyscall(SYS_EPOLL_CREATE, uintptr(size), 0, 0)
+	fd = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(events) > 0 {
+		_p0 = unsafe.Pointer(&events[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall6(SYS_EPOLL_WAIT, uintptr(epfd), uintptr(_p0), uintptr(len(events)), uintptr(msec), 0, 0)
+	n = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fchown(fd int, uid int, gid int) (err error) {
+	_, _, e1 := Syscall(SYS_FCHOWN, uintptr(fd), uintptr(uid), uintptr(gid))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fstat(fd int, stat *Stat_t) (err error) {
+	_, _, e1 := Syscall(SYS_FSTAT64, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fstatat(dirfd int, path string, stat *Stat_t, flags int) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := Syscall6(SYS_FSTATAT64, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Ftruncate(fd int, length int64) (err error) {
+	_, _, e1 := Syscall(SYS_FTRUNCATE64, uintptr(fd), uintptr(length>>32), uintptr(length))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Getegid() (egid int) {
+	r0, _ := RawSyscallNoError(SYS_GETEGID, 0, 0, 0)
+	egid = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Geteuid() (euid int) {
+	r0, _ := RawSyscallNoError(SYS_GETEUID, 0, 0, 0)
+	euid = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Getgid() (gid int) {
+	r0, _ := RawSyscallNoError(SYS_GETGID, 0, 0, 0)
+	gid = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Getuid() (uid int) {
+	r0, _ := RawSyscallNoError(SYS_GETUID, 0, 0, 0)
+	uid = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func InotifyInit() (fd int, err error) {
+	r0, _, e1 := RawSyscall(SYS_INOTIFY_INIT, 0, 0, 0)
+	fd = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Ioperm(from int, num int, on int) (err error) {
+	_, _, e1 := Syscall(SYS_IOPERM, uintptr(from), uintptr(num), uintptr(on))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Iopl(level int) (err error) {
+	_, _, e1 := Syscall(SYS_IOPL, uintptr(level), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Lchown(path string, uid int, gid int) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := Syscall(SYS_LCHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Listen(s int, n int) (err error) {
+	_, _, e1 := Syscall(SYS_LISTEN, uintptr(s), uintptr(n), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Lstat(path string, stat *Stat_t) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := Syscall(SYS_LSTAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Pause() (err error) {
+	_, _, e1 := Syscall(SYS_PAUSE, 0, 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Pread(fd int, p []byte, offset int64) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(p) > 0 {
+		_p0 = unsafe.Pointer(&p[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall6(SYS_PREAD64, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset>>32), uintptr(offset), 0)
+	n = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(p) > 0 {
+		_p0 = unsafe.Pointer(&p[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall6(SYS_PWRITE64, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset>>32), uintptr(offset), 0)
+	n = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(oldpath)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(newpath)
+	if err != nil {
+		return
+	}
+	_, _, e1 := Syscall6(SYS_RENAMEAT, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error) {
+	r0, _, e1 := Syscall6(SYS__NEWSELECT, uintptr(nfd), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
+	n = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
+	r0, _, e1 := Syscall6(SYS_SENDFILE64, uintptr(outfd), uintptr(infd), uintptr(unsafe.Pointer(offset)), uintptr(count), 0, 0)
+	written = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func setfsgid(gid int) (prev int, err error) {
+	r0, _, e1 := Syscall(SYS_SETFSGID, uintptr(gid), 0, 0)
+	prev = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func setfsuid(uid int) (prev int, err error) {
+	r0, _, e1 := Syscall(SYS_SETFSUID, uintptr(uid), 0, 0)
+	prev = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Setregid(rgid int, egid int) (err error) {
+	_, _, e1 := RawSyscall(SYS_SETREGID, uintptr(rgid), uintptr(egid), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Setresgid(rgid int, egid int, sgid int) (err error) {
+	_, _, e1 := RawSyscall(SYS_SETRESGID, uintptr(rgid), uintptr(egid), uintptr(sgid))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Setresuid(ruid int, euid int, suid int) (err error) {
+	_, _, e1 := RawSyscall(SYS_SETRESUID, uintptr(ruid), uintptr(euid), uintptr(suid))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Setreuid(ruid int, euid int) (err error) {
+	_, _, e1 := RawSyscall(SYS_SETREUID, uintptr(ruid), uintptr(euid), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Shutdown(fd int, how int) (err error) {
+	_, _, e1 := Syscall(SYS_SHUTDOWN, uintptr(fd), uintptr(how), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Splice(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int, err error) {
+	r0, _, e1 := Syscall6(SYS_SPLICE, uintptr(rfd), uintptr(unsafe.Pointer(roff)), uintptr(wfd), uintptr(unsafe.Pointer(woff)), uintptr(len), uintptr(flags))
+	n = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Stat(path string, stat *Stat_t) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := Syscall(SYS_STAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Truncate(path string, length int64) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := Syscall(SYS_TRUNCATE64, uintptr(unsafe.Pointer(_p0)), uintptr(length>>32), uintptr(length))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Ustat(dev int, ubuf *Ustat_t) (err error) {
+	_, _, e1 := Syscall(SYS_USTAT, uintptr(dev), uintptr(unsafe.Pointer(ubuf)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
+	r0, _, e1 := Syscall(SYS_ACCEPT, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	fd = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) {
+	r0, _, e1 := Syscall6(SYS_ACCEPT4, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
+	fd = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
+	_, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
+	_, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func getgroups(n int, list *_Gid_t) (nn int, err error) {
+	r0, _, e1 := RawSyscall(SYS_GETGROUPS, uintptr(n), uintptr(unsafe.Pointer(list)), 0)
+	nn = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func setgroups(n int, list *_Gid_t) (err error) {
+	_, _, e1 := RawSyscall(SYS_SETGROUPS, uintptr(n), uintptr(unsafe.Pointer(list)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
+	_, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
+	_, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func socket(domain int, typ int, proto int) (fd int, err error) {
+	r0, _, e1 := RawSyscall(SYS_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto))
+	fd = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
+	_, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
+	_, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
+	_, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(p) > 0 {
+		_p0 = unsafe.Pointer(&p[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall6(SYS_RECVFROM, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
+	n = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
+	var _p0 unsafe.Pointer
+	if len(buf) > 0 {
+		_p0 = unsafe.Pointer(&buf[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	_, _, e1 := Syscall6(SYS_SENDTO, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
+	r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
+	n = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
+	r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
+	n = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func futimesat(dirfd int, path string, times *[2]Timeval) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := Syscall(SYS_FUTIMESAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Gettimeofday(tv *Timeval) (err error) {
+	_, _, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tv)), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Time(t *Time_t) (tt Time_t, err error) {
+	r0, _, e1 := RawSyscall(SYS_TIME, uintptr(unsafe.Pointer(t)), 0, 0)
+	tt = Time_t(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Utime(path string, buf *Utimbuf) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := Syscall(SYS_UTIME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(buf)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func utimes(path string, times *[2]Timeval) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func mmap2(addr uintptr, length uintptr, prot int, flags int, fd int, pageOffset uintptr) (xaddr uintptr, err error) {
+	r0, _, e1 := Syscall6(SYS_MMAP2, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flags), uintptr(fd), uintptr(pageOffset))
+	xaddr = uintptr(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func getrlimit(resource int, rlim *rlimit32) (err error) {
+	_, _, e1 := RawSyscall(SYS_UGETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func setrlimit(resource int, rlim *rlimit32) (err error) {
+	_, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func pipe(p *[2]_C_int) (err error) {
+	_, _, e1 := RawSyscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func poll(fds *PollFd, nfds int, timeout int) (n int, err error) {
+	r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
+	n = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func syncFileRange2(fd int, flags int, off int64, n int64) (err error) {
+	_, _, e1 := Syscall6(SYS_SYNC_FILE_RANGE2, uintptr(fd), uintptr(flags), uintptr(off>>32), uintptr(off), uintptr(n>>32), uintptr(n))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func kexecFileLoad(kernelFd int, initrdFd int, cmdlineLen int, cmdline string, flags int) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(cmdline)
+	if err != nil {
+		return
+	}
+	_, _, e1 := Syscall6(SYS_KEXEC_FILE_LOAD, uintptr(kernelFd), uintptr(initrdFd), uintptr(cmdlineLen), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go
new file mode 100644
index 0000000000..7693656a6b
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go
@@ -0,0 +1,433 @@
+// go run linux/mksysnum.go -Wall -Werror -static -I/tmp/include /tmp/include/asm/unistd.h
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+//go:build ppc && linux
+// +build ppc,linux
+
+package unix
+
+const (
+	SYS_RESTART_SYSCALL              = 0
+	SYS_EXIT                         = 1
+	SYS_FORK                         = 2
+	SYS_READ                         = 3
+	SYS_WRITE                        = 4
+	SYS_OPEN                         = 5
+	SYS_CLOSE                        = 6
+	SYS_WAITPID                      = 7
+	SYS_CREAT                        = 8
+	SYS_LINK                         = 9
+	SYS_UNLINK                       = 10
+	SYS_EXECVE                       = 11
+	SYS_CHDIR                        = 12
+	SYS_TIME                         = 13
+	SYS_MKNOD                        = 14
+	SYS_CHMOD                        = 15
+	SYS_LCHOWN                       = 16
+	SYS_BREAK                        = 17
+	SYS_OLDSTAT                      = 18
+	SYS_LSEEK                        = 19
+	SYS_GETPID                       = 20
+	SYS_MOUNT                        = 21
+	SYS_UMOUNT                       = 22
+	SYS_SETUID                       = 23
+	SYS_GETUID                       = 24
+	SYS_STIME                        = 25
+	SYS_PTRACE                       = 26
+	SYS_ALARM                        = 27
+	SYS_OLDFSTAT                     = 28
+	SYS_PAUSE                        = 29
+	SYS_UTIME                        = 30
+	SYS_STTY                         = 31
+	SYS_GTTY                         = 32
+	SYS_ACCESS                       = 33
+	SYS_NICE                         = 34
+	SYS_FTIME                        = 35
+	SYS_SYNC                         = 36
+	SYS_KILL                         = 37
+	SYS_RENAME                       = 38
+	SYS_MKDIR                        = 39
+	SYS_RMDIR                        = 40
+	SYS_DUP                          = 41
+	SYS_PIPE                         = 42
+	SYS_TIMES                        = 43
+	SYS_PROF                         = 44
+	SYS_BRK                          = 45
+	SYS_SETGID                       = 46
+	SYS_GETGID                       = 47
+	SYS_SIGNAL                       = 48
+	SYS_GETEUID                      = 49
+	SYS_GETEGID                      = 50
+	SYS_ACCT                         = 51
+	SYS_UMOUNT2                      = 52
+	SYS_LOCK                         = 53
+	SYS_IOCTL                        = 54
+	SYS_FCNTL                        = 55
+	SYS_MPX                          = 56
+	SYS_SETPGID                      = 57
+	SYS_ULIMIT                       = 58
+	SYS_OLDOLDUNAME                  = 59
+	SYS_UMASK                        = 60
+	SYS_CHROOT                       = 61
+	SYS_USTAT                        = 62
+	SYS_DUP2                         = 63
+	SYS_GETPPID                      = 64
+	SYS_GETPGRP                      = 65
+	SYS_SETSID                       = 66
+	SYS_SIGACTION                    = 67
+	SYS_SGETMASK                     = 68
+	SYS_SSETMASK                     = 69
+	SYS_SETREUID                     = 70
+	SYS_SETREGID                     = 71
+	SYS_SIGSUSPEND                   = 72
+	SYS_SIGPENDING                   = 73
+	SYS_SETHOSTNAME                  = 74
+	SYS_SETRLIMIT                    = 75
+	SYS_GETRLIMIT                    = 76
+	SYS_GETRUSAGE                    = 77
+	SYS_GETTIMEOFDAY                 = 78
+	SYS_SETTIMEOFDAY                 = 79
+	SYS_GETGROUPS                    = 80
+	SYS_SETGROUPS                    = 81
+	SYS_SELECT                       = 82
+	SYS_SYMLINK                      = 83
+	SYS_OLDLSTAT                     = 84
+	SYS_READLINK                     = 85
+	SYS_USELIB                       = 86
+	SYS_SWAPON                       = 87
+	SYS_REBOOT                       = 88
+	SYS_READDIR                      = 89
+	SYS_MMAP                         = 90
+	SYS_MUNMAP                       = 91
+	SYS_TRUNCATE                     = 92
+	SYS_FTRUNCATE                    = 93
+	SYS_FCHMOD                       = 94
+	SYS_FCHOWN                       = 95
+	SYS_GETPRIORITY                  = 96
+	SYS_SETPRIORITY                  = 97
+	SYS_PROFIL                       = 98
+	SYS_STATFS                       = 99
+	SYS_FSTATFS                      = 100
+	SYS_IOPERM                       = 101
+	SYS_SOCKETCALL                   = 102
+	SYS_SYSLOG                       = 103
+	SYS_SETITIMER                    = 104
+	SYS_GETITIMER                    = 105
+	SYS_STAT                         = 106
+	SYS_LSTAT                        = 107
+	SYS_FSTAT                        = 108
+	SYS_OLDUNAME                     = 109
+	SYS_IOPL                         = 110
+	SYS_VHANGUP                      = 111
+	SYS_IDLE                         = 112
+	SYS_VM86                         = 113
+	SYS_WAIT4                        = 114
+	SYS_SWAPOFF                      = 115
+	SYS_SYSINFO                      = 116
+	SYS_IPC                          = 117
+	SYS_FSYNC                        = 118
+	SYS_SIGRETURN                    = 119
+	SYS_CLONE                        = 120
+	SYS_SETDOMAINNAME                = 121
+	SYS_UNAME                        = 122
+	SYS_MODIFY_LDT                   = 123
+	SYS_ADJTIMEX                     = 124
+	SYS_MPROTECT                     = 125
+	SYS_SIGPROCMASK                  = 126
+	SYS_CREATE_MODULE                = 127
+	SYS_INIT_MODULE                  = 128
+	SYS_DELETE_MODULE                = 129
+	SYS_GET_KERNEL_SYMS              = 130
+	SYS_QUOTACTL                     = 131
+	SYS_GETPGID                      = 132
+	SYS_FCHDIR                       = 133
+	SYS_BDFLUSH                      = 134
+	SYS_SYSFS                        = 135
+	SYS_PERSONALITY                  = 136
+	SYS_AFS_SYSCALL                  = 137
+	SYS_SETFSUID                     = 138
+	SYS_SETFSGID                     = 139
+	SYS__LLSEEK                      = 140
+	SYS_GETDENTS                     = 141
+	SYS__NEWSELECT                   = 142
+	SYS_FLOCK                        = 143
+	SYS_MSYNC                        = 144
+	SYS_READV                        = 145
+	SYS_WRITEV                       = 146
+	SYS_GETSID                       = 147
+	SYS_FDATASYNC                    = 148
+	SYS__SYSCTL                      = 149
+	SYS_MLOCK                        = 150
+	SYS_MUNLOCK                      = 151
+	SYS_MLOCKALL                     = 152
+	SYS_MUNLOCKALL                   = 153
+	SYS_SCHED_SETPARAM               = 154
+	SYS_SCHED_GETPARAM               = 155
+	SYS_SCHED_SETSCHEDULER           = 156
+	SYS_SCHED_GETSCHEDULER           = 157
+	SYS_SCHED_YIELD                  = 158
+	SYS_SCHED_GET_PRIORITY_MAX       = 159
+	SYS_SCHED_GET_PRIORITY_MIN       = 160
+	SYS_SCHED_RR_GET_INTERVAL        = 161
+	SYS_NANOSLEEP                    = 162
+	SYS_MREMAP                       = 163
+	SYS_SETRESUID                    = 164
+	SYS_GETRESUID                    = 165
+	SYS_QUERY_MODULE                 = 166
+	SYS_POLL                         = 167
+	SYS_NFSSERVCTL                   = 168
+	SYS_SETRESGID                    = 169
+	SYS_GETRESGID                    = 170
+	SYS_PRCTL                        = 171
+	SYS_RT_SIGRETURN                 = 172
+	SYS_RT_SIGACTION                 = 173
+	SYS_RT_SIGPROCMASK               = 174
+	SYS_RT_SIGPENDING                = 175
+	SYS_RT_SIGTIMEDWAIT              = 176
+	SYS_RT_SIGQUEUEINFO              = 177
+	SYS_RT_SIGSUSPEND                = 178
+	SYS_PREAD64                      = 179
+	SYS_PWRITE64                     = 180
+	SYS_CHOWN                        = 181
+	SYS_GETCWD                       = 182
+	SYS_CAPGET                       = 183
+	SYS_CAPSET                       = 184
+	SYS_SIGALTSTACK                  = 185
+	SYS_SENDFILE                     = 186
+	SYS_GETPMSG                      = 187
+	SYS_PUTPMSG                      = 188
+	SYS_VFORK                        = 189
+	SYS_UGETRLIMIT                   = 190
+	SYS_READAHEAD                    = 191
+	SYS_MMAP2                        = 192
+	SYS_TRUNCATE64                   = 193
+	SYS_FTRUNCATE64                  = 194
+	SYS_STAT64                       = 195
+	SYS_LSTAT64                      = 196
+	SYS_FSTAT64                      = 197
+	SYS_PCICONFIG_READ               = 198
+	SYS_PCICONFIG_WRITE              = 199
+	SYS_PCICONFIG_IOBASE             = 200
+	SYS_MULTIPLEXER                  = 201
+	SYS_GETDENTS64                   = 202
+	SYS_PIVOT_ROOT                   = 203
+	SYS_FCNTL64                      = 204
+	SYS_MADVISE                      = 205
+	SYS_MINCORE                      = 206
+	SYS_GETTID                       = 207
+	SYS_TKILL                        = 208
+	SYS_SETXATTR                     = 209
+	SYS_LSETXATTR                    = 210
+	SYS_FSETXATTR                    = 211
+	SYS_GETXATTR                     = 212
+	SYS_LGETXATTR                    = 213
+	SYS_FGETXATTR                    = 214
+	SYS_LISTXATTR                    = 215
+	SYS_LLISTXATTR                   = 216
+	SYS_FLISTXATTR                   = 217
+	SYS_REMOVEXATTR                  = 218
+	SYS_LREMOVEXATTR                 = 219
+	SYS_FREMOVEXATTR                 = 220
+	SYS_FUTEX                        = 221
+	SYS_SCHED_SETAFFINITY            = 222
+	SYS_SCHED_GETAFFINITY            = 223
+	SYS_TUXCALL                      = 225
+	SYS_SENDFILE64                   = 226
+	SYS_IO_SETUP                     = 227
+	SYS_IO_DESTROY                   = 228
+	SYS_IO_GETEVENTS                 = 229
+	SYS_IO_SUBMIT                    = 230
+	SYS_IO_CANCEL                    = 231
+	SYS_SET_TID_ADDRESS              = 232
+	SYS_FADVISE64                    = 233
+	SYS_EXIT_GROUP                   = 234
+	SYS_LOOKUP_DCOOKIE               = 235
+	SYS_EPOLL_CREATE                 = 236
+	SYS_EPOLL_CTL                    = 237
+	SYS_EPOLL_WAIT                   = 238
+	SYS_REMAP_FILE_PAGES             = 239
+	SYS_TIMER_CREATE                 = 240
+	SYS_TIMER_SETTIME                = 241
+	SYS_TIMER_GETTIME                = 242
+	SYS_TIMER_GETOVERRUN             = 243
+	SYS_TIMER_DELETE                 = 244
+	SYS_CLOCK_SETTIME                = 245
+	SYS_CLOCK_GETTIME                = 246
+	SYS_CLOCK_GETRES                 = 247
+	SYS_CLOCK_NANOSLEEP              = 248
+	SYS_SWAPCONTEXT                  = 249
+	SYS_TGKILL                       = 250
+	SYS_UTIMES                       = 251
+	SYS_STATFS64                     = 252
+	SYS_FSTATFS64                    = 253
+	SYS_FADVISE64_64                 = 254
+	SYS_RTAS                         = 255
+	SYS_SYS_DEBUG_SETCONTEXT         = 256
+	SYS_MIGRATE_PAGES                = 258
+	SYS_MBIND                        = 259
+	SYS_GET_MEMPOLICY                = 260
+	SYS_SET_MEMPOLICY                = 261
+	SYS_MQ_OPEN                      = 262
+	SYS_MQ_UNLINK                    = 263
+	SYS_MQ_TIMEDSEND                 = 264
+	SYS_MQ_TIMEDRECEIVE              = 265
+	SYS_MQ_NOTIFY                    = 266
+	SYS_MQ_GETSETATTR                = 267
+	SYS_KEXEC_LOAD                   = 268
+	SYS_ADD_KEY                      = 269
+	SYS_REQUEST_KEY                  = 270
+	SYS_KEYCTL                       = 271
+	SYS_WAITID                       = 272
+	SYS_IOPRIO_SET                   = 273
+	SYS_IOPRIO_GET                   = 274
+	SYS_INOTIFY_INIT                 = 275
+	SYS_INOTIFY_ADD_WATCH            = 276
+	SYS_INOTIFY_RM_WATCH             = 277
+	SYS_SPU_RUN                      = 278
+	SYS_SPU_CREATE                   = 279
+	SYS_PSELECT6                     = 280
+	SYS_PPOLL                        = 281
+	SYS_UNSHARE                      = 282
+	SYS_SPLICE                       = 283
+	SYS_TEE                          = 284
+	SYS_VMSPLICE                     = 285
+	SYS_OPENAT                       = 286
+	SYS_MKDIRAT                      = 287
+	SYS_MKNODAT                      = 288
+	SYS_FCHOWNAT                     = 289
+	SYS_FUTIMESAT                    = 290
+	SYS_FSTATAT64                    = 291
+	SYS_UNLINKAT                     = 292
+	SYS_RENAMEAT                     = 293
+	SYS_LINKAT                       = 294
+	SYS_SYMLINKAT                    = 295
+	SYS_READLINKAT                   = 296
+	SYS_FCHMODAT                     = 297
+	SYS_FACCESSAT                    = 298
+	SYS_GET_ROBUST_LIST              = 299
+	SYS_SET_ROBUST_LIST              = 300
+	SYS_MOVE_PAGES                   = 301
+	SYS_GETCPU                       = 302
+	SYS_EPOLL_PWAIT                  = 303
+	SYS_UTIMENSAT                    = 304
+	SYS_SIGNALFD                     = 305
+	SYS_TIMERFD_CREATE               = 306
+	SYS_EVENTFD                      = 307
+	SYS_SYNC_FILE_RANGE2             = 308
+	SYS_FALLOCATE                    = 309
+	SYS_SUBPAGE_PROT                 = 310
+	SYS_TIMERFD_SETTIME              = 311
+	SYS_TIMERFD_GETTIME              = 312
+	SYS_SIGNALFD4                    = 313
+	SYS_EVENTFD2                     = 314
+	SYS_EPOLL_CREATE1                = 315
+	SYS_DUP3                         = 316
+	SYS_PIPE2                        = 317
+	SYS_INOTIFY_INIT1                = 318
+	SYS_PERF_EVENT_OPEN              = 319
+	SYS_PREADV                       = 320
+	SYS_PWRITEV                      = 321
+	SYS_RT_TGSIGQUEUEINFO            = 322
+	SYS_FANOTIFY_INIT                = 323
+	SYS_FANOTIFY_MARK                = 324
+	SYS_PRLIMIT64                    = 325
+	SYS_SOCKET                       = 326
+	SYS_BIND                         = 327
+	SYS_CONNECT                      = 328
+	SYS_LISTEN                       = 329
+	SYS_ACCEPT                       = 330
+	SYS_GETSOCKNAME                  = 331
+	SYS_GETPEERNAME                  = 332
+	SYS_SOCKETPAIR                   = 333
+	SYS_SEND                         = 334
+	SYS_SENDTO                       = 335
+	SYS_RECV                         = 336
+	SYS_RECVFROM                     = 337
+	SYS_SHUTDOWN                     = 338
+	SYS_SETSOCKOPT                   = 339
+	SYS_GETSOCKOPT                   = 340
+	SYS_SENDMSG                      = 341
+	SYS_RECVMSG                      = 342
+	SYS_RECVMMSG                     = 343
+	SYS_ACCEPT4                      = 344
+	SYS_NAME_TO_HANDLE_AT            = 345
+	SYS_OPEN_BY_HANDLE_AT            = 346
+	SYS_CLOCK_ADJTIME                = 347
+	SYS_SYNCFS                       = 348
+	SYS_SENDMMSG                     = 349
+	SYS_SETNS                        = 350
+	SYS_PROCESS_VM_READV             = 351
+	SYS_PROCESS_VM_WRITEV            = 352
+	SYS_FINIT_MODULE                 = 353
+	SYS_KCMP                         = 354
+	SYS_SCHED_SETATTR                = 355
+	SYS_SCHED_GETATTR                = 356
+	SYS_RENAMEAT2                    = 357
+	SYS_SECCOMP                      = 358
+	SYS_GETRANDOM                    = 359
+	SYS_MEMFD_CREATE                 = 360
+	SYS_BPF                          = 361
+	SYS_EXECVEAT                     = 362
+	SYS_SWITCH_ENDIAN                = 363
+	SYS_USERFAULTFD                  = 364
+	SYS_MEMBARRIER                   = 365
+	SYS_MLOCK2                       = 378
+	SYS_COPY_FILE_RANGE              = 379
+	SYS_PREADV2                      = 380
+	SYS_PWRITEV2                     = 381
+	SYS_KEXEC_FILE_LOAD              = 382
+	SYS_STATX                        = 383
+	SYS_PKEY_ALLOC                   = 384
+	SYS_PKEY_FREE                    = 385
+	SYS_PKEY_MPROTECT                = 386
+	SYS_RSEQ                         = 387
+	SYS_IO_PGETEVENTS                = 388
+	SYS_SEMGET                       = 393
+	SYS_SEMCTL                       = 394
+	SYS_SHMGET                       = 395
+	SYS_SHMCTL                       = 396
+	SYS_SHMAT                        = 397
+	SYS_SHMDT                        = 398
+	SYS_MSGGET                       = 399
+	SYS_MSGSND                       = 400
+	SYS_MSGRCV                       = 401
+	SYS_MSGCTL                       = 402
+	SYS_CLOCK_GETTIME64              = 403
+	SYS_CLOCK_SETTIME64              = 404
+	SYS_CLOCK_ADJTIME64              = 405
+	SYS_CLOCK_GETRES_TIME64          = 406
+	SYS_CLOCK_NANOSLEEP_TIME64       = 407
+	SYS_TIMER_GETTIME64              = 408
+	SYS_TIMER_SETTIME64              = 409
+	SYS_TIMERFD_GETTIME64            = 410
+	SYS_TIMERFD_SETTIME64            = 411
+	SYS_UTIMENSAT_TIME64             = 412
+	SYS_PSELECT6_TIME64              = 413
+	SYS_PPOLL_TIME64                 = 414
+	SYS_IO_PGETEVENTS_TIME64         = 416
+	SYS_RECVMMSG_TIME64              = 417
+	SYS_MQ_TIMEDSEND_TIME64          = 418
+	SYS_MQ_TIMEDRECEIVE_TIME64       = 419
+	SYS_SEMTIMEDOP_TIME64            = 420
+	SYS_RT_SIGTIMEDWAIT_TIME64       = 421
+	SYS_FUTEX_TIME64                 = 422
+	SYS_SCHED_RR_GET_INTERVAL_TIME64 = 423
+	SYS_PIDFD_SEND_SIGNAL            = 424
+	SYS_IO_URING_SETUP               = 425
+	SYS_IO_URING_ENTER               = 426
+	SYS_IO_URING_REGISTER            = 427
+	SYS_OPEN_TREE                    = 428
+	SYS_MOVE_MOUNT                   = 429
+	SYS_FSOPEN                       = 430
+	SYS_FSCONFIG                     = 431
+	SYS_FSMOUNT                      = 432
+	SYS_FSPICK                       = 433
+	SYS_PIDFD_OPEN                   = 434
+	SYS_CLONE3                       = 435
+	SYS_CLOSE_RANGE                  = 436
+	SYS_OPENAT2                      = 437
+	SYS_PIDFD_GETFD                  = 438
+	SYS_FACCESSAT2                   = 439
+	SYS_PROCESS_MADVISE              = 440
+	SYS_EPOLL_PWAIT2                 = 441
+)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_386.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_386.go
index 54db433355..883b64a272 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_386.go
@@ -221,6 +221,12 @@ type IPMreq struct {
 	Interface [4]byte /* in_addr */
 }
 
+type IPMreqn struct {
+	Multiaddr [4]byte /* in_addr */
+	Address   [4]byte /* in_addr */
+	Ifindex   int32
+}
+
 type IPv6Mreq struct {
 	Multiaddr [16]byte /* in6_addr */
 	Interface uint32
@@ -272,6 +278,7 @@ const (
 	SizeofLinger           = 0x8
 	SizeofIovec            = 0x8
 	SizeofIPMreq           = 0x8
+	SizeofIPMreqn          = 0xc
 	SizeofIPv6Mreq         = 0x14
 	SizeofMsghdr           = 0x1c
 	SizeofCmsghdr          = 0xc
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go
index eb73e52fb6..2673e6c590 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go
@@ -233,6 +233,12 @@ type IPMreq struct {
 	Interface [4]byte /* in_addr */
 }
 
+type IPMreqn struct {
+	Multiaddr [4]byte /* in_addr */
+	Address   [4]byte /* in_addr */
+	Ifindex   int32
+}
+
 type IPv6Mreq struct {
 	Multiaddr [16]byte /* in6_addr */
 	Interface uint32
@@ -285,6 +291,7 @@ const (
 	SizeofLinger           = 0x8
 	SizeofIovec            = 0x10
 	SizeofIPMreq           = 0x8
+	SizeofIPMreqn          = 0xc
 	SizeofIPv6Mreq         = 0x14
 	SizeofMsghdr           = 0x30
 	SizeofCmsghdr          = 0xc
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm.go
index 8606d654e5..eef5133857 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm.go
@@ -221,6 +221,12 @@ type IPMreq struct {
 	Interface [4]byte /* in_addr */
 }
 
+type IPMreqn struct {
+	Multiaddr [4]byte /* in_addr */
+	Address   [4]byte /* in_addr */
+	Ifindex   int32
+}
+
 type IPv6Mreq struct {
 	Multiaddr [16]byte /* in6_addr */
 	Interface uint32
@@ -272,6 +278,7 @@ const (
 	SizeofLinger           = 0x8
 	SizeofIovec            = 0x8
 	SizeofIPMreq           = 0x8
+	SizeofIPMreqn          = 0xc
 	SizeofIPv6Mreq         = 0x14
 	SizeofMsghdr           = 0x1c
 	SizeofCmsghdr          = 0xc
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go
index dcb51f8404..1465cbcffe 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go
@@ -233,6 +233,12 @@ type IPMreq struct {
 	Interface [4]byte /* in_addr */
 }
 
+type IPMreqn struct {
+	Multiaddr [4]byte /* in_addr */
+	Address   [4]byte /* in_addr */
+	Ifindex   int32
+}
+
 type IPv6Mreq struct {
 	Multiaddr [16]byte /* in6_addr */
 	Interface uint32
@@ -285,6 +291,7 @@ const (
 	SizeofLinger           = 0x8
 	SizeofIovec            = 0x10
 	SizeofIPMreq           = 0x8
+	SizeofIPMreqn          = 0xc
 	SizeofIPv6Mreq         = 0x14
 	SizeofMsghdr           = 0x30
 	SizeofCmsghdr          = 0xc
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go
index c769e73cd6..3bfc6f7323 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go
@@ -3698,6 +3698,21 @@ const (
 	ETHTOOL_A_TUNNEL_INFO_MAX                 = 0x2
 )
 
+type EthtoolDrvinfo struct {
+	Cmd          uint32
+	Driver       [32]byte
+	Version      [32]byte
+	Fw_version   [32]byte
+	Bus_info     [32]byte
+	Erom_version [32]byte
+	Reserved2    [12]byte
+	N_priv_flags uint32
+	N_stats      uint32
+	Testinfo_len uint32
+	Eedump_len   uint32
+	Regdump_len  uint32
+}
+
 type (
 	HIDRawReportDescriptor struct {
 		Size  uint32
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go
new file mode 100644
index 0000000000..af7a72017e
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go
@@ -0,0 +1,627 @@
+// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+//go:build ppc && linux
+// +build ppc,linux
+
+package unix
+
+const (
+	SizeofPtr  = 0x4
+	SizeofLong = 0x4
+)
+
+type (
+	_C_long int32
+)
+
+type Timespec struct {
+	Sec  int32
+	Nsec int32
+}
+
+type Timeval struct {
+	Sec  int32
+	Usec int32
+}
+
+type Timex struct {
+	Modes     uint32
+	Offset    int32
+	Freq      int32
+	Maxerror  int32
+	Esterror  int32
+	Status    int32
+	Constant  int32
+	Precision int32
+	Tolerance int32
+	Time      Timeval
+	Tick      int32
+	Ppsfreq   int32
+	Jitter    int32
+	Shift     int32
+	Stabil    int32
+	Jitcnt    int32
+	Calcnt    int32
+	Errcnt    int32
+	Stbcnt    int32
+	Tai       int32
+	_         [44]byte
+}
+
+type Time_t int32
+
+type Tms struct {
+	Utime  int32
+	Stime  int32
+	Cutime int32
+	Cstime int32
+}
+
+type Utimbuf struct {
+	Actime  int32
+	Modtime int32
+}
+
+type Rusage struct {
+	Utime    Timeval
+	Stime    Timeval
+	Maxrss   int32
+	Ixrss    int32
+	Idrss    int32
+	Isrss    int32
+	Minflt   int32
+	Majflt   int32
+	Nswap    int32
+	Inblock  int32
+	Oublock  int32
+	Msgsnd   int32
+	Msgrcv   int32
+	Nsignals int32
+	Nvcsw    int32
+	Nivcsw   int32
+}
+
+type Stat_t struct {
+	Dev     uint64
+	Ino     uint64
+	Mode    uint32
+	Nlink   uint32
+	Uid     uint32
+	Gid     uint32
+	Rdev    uint64
+	_       uint16
+	_       [4]byte
+	Size    int64
+	Blksize int32
+	_       [4]byte
+	Blocks  int64
+	Atim    Timespec
+	Mtim    Timespec
+	Ctim    Timespec
+	_       uint32
+	_       uint32
+}
+
+type Dirent struct {
+	Ino    uint64
+	Off    int64
+	Reclen uint16
+	Type   uint8
+	Name   [256]uint8
+	_      [5]byte
+}
+
+type Flock_t struct {
+	Type   int16
+	Whence int16
+	_      [4]byte
+	Start  int64
+	Len    int64
+	Pid    int32
+	_      [4]byte
+}
+
+type DmNameList struct {
+	Dev  uint64
+	Next uint32
+	Name [0]byte
+	_    [4]byte
+}
+
+const (
+	FADV_DONTNEED = 0x4
+	FADV_NOREUSE  = 0x5
+)
+
+type RawSockaddr struct {
+	Family uint16
+	Data   [14]uint8
+}
+
+type RawSockaddrAny struct {
+	Addr RawSockaddr
+	Pad  [96]uint8
+}
+
+type Iovec struct {
+	Base *byte
+	Len  uint32
+}
+
+type Msghdr struct {
+	Name       *byte
+	Namelen    uint32
+	Iov        *Iovec
+	Iovlen     uint32
+	Control    *byte
+	Controllen uint32
+	Flags      int32
+}
+
+type Cmsghdr struct {
+	Len   uint32
+	Level int32
+	Type  int32
+}
+
+const (
+	SizeofIovec   = 0x8
+	SizeofMsghdr  = 0x1c
+	SizeofCmsghdr = 0xc
+)
+
+const (
+	SizeofSockFprog = 0x8
+)
+
+type PtraceRegs struct {
+	Gpr       [32]uint32
+	Nip       uint32
+	Msr       uint32
+	Orig_gpr3 uint32
+	Ctr       uint32
+	Link      uint32
+	Xer       uint32
+	Ccr       uint32
+	Mq        uint32
+	Trap      uint32
+	Dar       uint32
+	Dsisr     uint32
+	Result    uint32
+}
+
+type FdSet struct {
+	Bits [32]int32
+}
+
+type Sysinfo_t struct {
+	Uptime    int32
+	Loads     [3]uint32
+	Totalram  uint32
+	Freeram   uint32
+	Sharedram uint32
+	Bufferram uint32
+	Totalswap uint32
+	Freeswap  uint32
+	Procs     uint16
+	Pad       uint16
+	Totalhigh uint32
+	Freehigh  uint32
+	Unit      uint32
+	_         [8]uint8
+}
+
+type Ustat_t struct {
+	Tfree  int32
+	Tinode uint32
+	Fname  [6]uint8
+	Fpack  [6]uint8
+}
+
+type EpollEvent struct {
+	Events uint32
+	_      int32
+	Fd     int32
+	Pad    int32
+}
+
+const (
+	POLLRDHUP = 0x2000
+)
+
+type Sigset_t struct {
+	Val [32]uint32
+}
+
+const _C__NSIG = 0x41
+
+type Termios struct {
+	Iflag  uint32
+	Oflag  uint32
+	Cflag  uint32
+	Lflag  uint32
+	Cc     [19]uint8
+	Line   uint8
+	Ispeed uint32
+	Ospeed uint32
+}
+
+type Taskstats struct {
+	Version                   uint16
+	Ac_exitcode               uint32
+	Ac_flag                   uint8
+	Ac_nice                   uint8
+	_                         [4]byte
+	Cpu_count                 uint64
+	Cpu_delay_total           uint64
+	Blkio_count               uint64
+	Blkio_delay_total         uint64
+	Swapin_count              uint64
+	Swapin_delay_total        uint64
+	Cpu_run_real_total        uint64
+	Cpu_run_virtual_total     uint64
+	Ac_comm                   [32]uint8
+	Ac_sched                  uint8
+	Ac_pad                    [3]uint8
+	_                         [4]byte
+	Ac_uid                    uint32
+	Ac_gid                    uint32
+	Ac_pid                    uint32
+	Ac_ppid                   uint32
+	Ac_btime                  uint32
+	_                         [4]byte
+	Ac_etime                  uint64
+	Ac_utime                  uint64
+	Ac_stime                  uint64
+	Ac_minflt                 uint64
+	Ac_majflt                 uint64
+	Coremem                   uint64
+	Virtmem                   uint64
+	Hiwater_rss               uint64
+	Hiwater_vm                uint64
+	Read_char                 uint64
+	Write_char                uint64
+	Read_syscalls             uint64
+	Write_syscalls            uint64
+	Read_bytes                uint64
+	Write_bytes               uint64
+	Cancelled_write_bytes     uint64
+	Nvcsw                     uint64
+	Nivcsw                    uint64
+	Ac_utimescaled            uint64
+	Ac_stimescaled            uint64
+	Cpu_scaled_run_real_total uint64
+	Freepages_count           uint64
+	Freepages_delay_total     uint64
+	Thrashing_count           uint64
+	Thrashing_delay_total     uint64
+	Ac_btime64                uint64
+}
+
+type cpuMask uint32
+
+const (
+	_NCPUBITS = 0x20
+)
+
+const (
+	CBitFieldMaskBit0  = 0x8000000000000000
+	CBitFieldMaskBit1  = 0x4000000000000000
+	CBitFieldMaskBit2  = 0x2000000000000000
+	CBitFieldMaskBit3  = 0x1000000000000000
+	CBitFieldMaskBit4  = 0x800000000000000
+	CBitFieldMaskBit5  = 0x400000000000000
+	CBitFieldMaskBit6  = 0x200000000000000
+	CBitFieldMaskBit7  = 0x100000000000000
+	CBitFieldMaskBit8  = 0x80000000000000
+	CBitFieldMaskBit9  = 0x40000000000000
+	CBitFieldMaskBit10 = 0x20000000000000
+	CBitFieldMaskBit11 = 0x10000000000000
+	CBitFieldMaskBit12 = 0x8000000000000
+	CBitFieldMaskBit13 = 0x4000000000000
+	CBitFieldMaskBit14 = 0x2000000000000
+	CBitFieldMaskBit15 = 0x1000000000000
+	CBitFieldMaskBit16 = 0x800000000000
+	CBitFieldMaskBit17 = 0x400000000000
+	CBitFieldMaskBit18 = 0x200000000000
+	CBitFieldMaskBit19 = 0x100000000000
+	CBitFieldMaskBit20 = 0x80000000000
+	CBitFieldMaskBit21 = 0x40000000000
+	CBitFieldMaskBit22 = 0x20000000000
+	CBitFieldMaskBit23 = 0x10000000000
+	CBitFieldMaskBit24 = 0x8000000000
+	CBitFieldMaskBit25 = 0x4000000000
+	CBitFieldMaskBit26 = 0x2000000000
+	CBitFieldMaskBit27 = 0x1000000000
+	CBitFieldMaskBit28 = 0x800000000
+	CBitFieldMaskBit29 = 0x400000000
+	CBitFieldMaskBit30 = 0x200000000
+	CBitFieldMaskBit31 = 0x100000000
+	CBitFieldMaskBit32 = 0x80000000
+	CBitFieldMaskBit33 = 0x40000000
+	CBitFieldMaskBit34 = 0x20000000
+	CBitFieldMaskBit35 = 0x10000000
+	CBitFieldMaskBit36 = 0x8000000
+	CBitFieldMaskBit37 = 0x4000000
+	CBitFieldMaskBit38 = 0x2000000
+	CBitFieldMaskBit39 = 0x1000000
+	CBitFieldMaskBit40 = 0x800000
+	CBitFieldMaskBit41 = 0x400000
+	CBitFieldMaskBit42 = 0x200000
+	CBitFieldMaskBit43 = 0x100000
+	CBitFieldMaskBit44 = 0x80000
+	CBitFieldMaskBit45 = 0x40000
+	CBitFieldMaskBit46 = 0x20000
+	CBitFieldMaskBit47 = 0x10000
+	CBitFieldMaskBit48 = 0x8000
+	CBitFieldMaskBit49 = 0x4000
+	CBitFieldMaskBit50 = 0x2000
+	CBitFieldMaskBit51 = 0x1000
+	CBitFieldMaskBit52 = 0x800
+	CBitFieldMaskBit53 = 0x400
+	CBitFieldMaskBit54 = 0x200
+	CBitFieldMaskBit55 = 0x100
+	CBitFieldMaskBit56 = 0x80
+	CBitFieldMaskBit57 = 0x40
+	CBitFieldMaskBit58 = 0x20
+	CBitFieldMaskBit59 = 0x10
+	CBitFieldMaskBit60 = 0x8
+	CBitFieldMaskBit61 = 0x4
+	CBitFieldMaskBit62 = 0x2
+	CBitFieldMaskBit63 = 0x1
+)
+
+type SockaddrStorage struct {
+	Family uint16
+	_      [122]uint8
+	_      uint32
+}
+
+type HDGeometry struct {
+	Heads     uint8
+	Sectors   uint8
+	Cylinders uint16
+	Start     uint32
+}
+
+type Statfs_t struct {
+	Type    int32
+	Bsize   int32
+	Blocks  uint64
+	Bfree   uint64
+	Bavail  uint64
+	Files   uint64
+	Ffree   uint64
+	Fsid    Fsid
+	Namelen int32
+	Frsize  int32
+	Flags   int32
+	Spare   [4]int32
+	_       [4]byte
+}
+
+type TpacketHdr struct {
+	Status  uint32
+	Len     uint32
+	Snaplen uint32
+	Mac     uint16
+	Net     uint16
+	Sec     uint32
+	Usec    uint32
+}
+
+const (
+	SizeofTpacketHdr = 0x18
+)
+
+type RTCPLLInfo struct {
+	Ctrl    int32
+	Value   int32
+	Max     int32
+	Min     int32
+	Posmult int32
+	Negmult int32
+	Clock   int32
+}
+
+type BlkpgPartition struct {
+	Start   int64
+	Length  int64
+	Pno     int32
+	Devname [64]uint8
+	Volname [64]uint8
+	_       [4]byte
+}
+
+const (
+	BLKPG = 0x20001269
+)
+
+type XDPUmemReg struct {
+	Addr     uint64
+	Len      uint64
+	Size     uint32
+	Headroom uint32
+	Flags    uint32
+	_        [4]byte
+}
+
+type CryptoUserAlg struct {
+	Name        [64]uint8
+	Driver_name [64]uint8
+	Module_name [64]uint8
+	Type        uint32
+	Mask        uint32
+	Refcnt      uint32
+	Flags       uint32
+}
+
+type CryptoStatAEAD struct {
+	Type         [64]uint8
+	Encrypt_cnt  uint64
+	Encrypt_tlen uint64
+	Decrypt_cnt  uint64
+	Decrypt_tlen uint64
+	Err_cnt      uint64
+}
+
+type CryptoStatAKCipher struct {
+	Type         [64]uint8
+	Encrypt_cnt  uint64
+	Encrypt_tlen uint64
+	Decrypt_cnt  uint64
+	Decrypt_tlen uint64
+	Verify_cnt   uint64
+	Sign_cnt     uint64
+	Err_cnt      uint64
+}
+
+type CryptoStatCipher struct {
+	Type         [64]uint8
+	Encrypt_cnt  uint64
+	Encrypt_tlen uint64
+	Decrypt_cnt  uint64
+	Decrypt_tlen uint64
+	Err_cnt      uint64
+}
+
+type CryptoStatCompress struct {
+	Type            [64]uint8
+	Compress_cnt    uint64
+	Compress_tlen   uint64
+	Decompress_cnt  uint64
+	Decompress_tlen uint64
+	Err_cnt         uint64
+}
+
+type CryptoStatHash struct {
+	Type      [64]uint8
+	Hash_cnt  uint64
+	Hash_tlen uint64
+	Err_cnt   uint64
+}
+
+type CryptoStatKPP struct {
+	Type                      [64]uint8
+	Setsecret_cnt             uint64
+	Generate_public_key_cnt   uint64
+	Compute_shared_secret_cnt uint64
+	Err_cnt                   uint64
+}
+
+type CryptoStatRNG struct {
+	Type          [64]uint8
+	Generate_cnt  uint64
+	Generate_tlen uint64
+	Seed_cnt      uint64
+	Err_cnt       uint64
+}
+
+type CryptoStatLarval struct {
+	Type [64]uint8
+}
+
+type CryptoReportLarval struct {
+	Type [64]uint8
+}
+
+type CryptoReportHash struct {
+	Type       [64]uint8
+	Blocksize  uint32
+	Digestsize uint32
+}
+
+type CryptoReportCipher struct {
+	Type        [64]uint8
+	Blocksize   uint32
+	Min_keysize uint32
+	Max_keysize uint32
+}
+
+type CryptoReportBlkCipher struct {
+	Type        [64]uint8
+	Geniv       [64]uint8
+	Blocksize   uint32
+	Min_keysize uint32
+	Max_keysize uint32
+	Ivsize      uint32
+}
+
+type CryptoReportAEAD struct {
+	Type        [64]uint8
+	Geniv       [64]uint8
+	Blocksize   uint32
+	Maxauthsize uint32
+	Ivsize      uint32
+}
+
+type CryptoReportComp struct {
+	Type [64]uint8
+}
+
+type CryptoReportRNG struct {
+	Type     [64]uint8
+	Seedsize uint32
+}
+
+type CryptoReportAKCipher struct {
+	Type [64]uint8
+}
+
+type CryptoReportKPP struct {
+	Type [64]uint8
+}
+
+type CryptoReportAcomp struct {
+	Type [64]uint8
+}
+
+type LoopInfo struct {
+	Number           int32
+	Device           uint32
+	Inode            uint32
+	Rdevice          uint32
+	Offset           int32
+	Encrypt_type     int32
+	Encrypt_key_size int32
+	Flags            int32
+	Name             [64]uint8
+	Encrypt_key      [32]uint8
+	Init             [2]uint32
+	Reserved         [4]uint8
+}
+
+type TIPCSubscr struct {
+	Seq     TIPCServiceRange
+	Timeout uint32
+	Filter  uint32
+	Handle  [8]uint8
+}
+
+type TIPCSIOCLNReq struct {
+	Peer     uint32
+	Id       uint32
+	Linkname [68]uint8
+}
+
+type TIPCSIOCNodeIDReq struct {
+	Peer uint32
+	Id   [16]uint8
+}
+
+type PPSKInfo struct {
+	Assert_sequence uint32
+	Clear_sequence  uint32
+	Assert_tu       PPSKTime
+	Clear_tu        PPSKTime
+	Current_mode    int32
+	_               [4]byte
+}
+
+const (
+	PPS_GETPARAMS = 0x400470a1
+	PPS_SETPARAMS = 0x800470a2
+	PPS_GETCAP    = 0x400470a3
+	PPS_FETCH     = 0xc00470a4
+)
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 473febea68..0ee84f4cf8 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -39,7 +39,7 @@ golang.org/x/mod/sumdb/dirhash
 golang.org/x/mod/sumdb/note
 golang.org/x/mod/sumdb/tlog
 golang.org/x/mod/zip
-# golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57
+# golang.org/x/sys v0.0.0-20210423082822-04245dca01da
 ## explicit; go 1.12
 golang.org/x/sys/internal/unsafeheader
 golang.org/x/sys/plan9
diff --git a/src/go.mod b/src/go.mod
index 89ad19d288..59fa194bab 100644
--- a/src/go.mod
+++ b/src/go.mod
@@ -4,7 +4,7 @@ go 1.17
 
 require (
 	golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83
-	golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4
-	golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57 // indirect
-	golang.org/x/text v0.3.6-0.20210227105805-e3aa4adf54f6 // indirect
+	golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420
+	golang.org/x/sys v0.0.0-20210423082822-04245dca01da // indirect
+	golang.org/x/text v0.3.6 // indirect
 )
diff --git a/src/go.sum b/src/go.sum
index 034d8506f4..bfb07129bb 100644
--- a/src/go.sum
+++ b/src/go.sum
@@ -2,18 +2,14 @@ golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACk
 golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 h1:/ZScEX8SfEmUGRHs0gxpqteO5nfNW6axyZbBdw9A12g=
 golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4 h1:4nGaVu0QrbjT/AK2PRLuQfQuh6DJve+pELhqTdAj3x0=
-golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
+golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420 h1:a8jGStKg0XqKDlKqjLrXn0ioF5MH36pT7Z0BRTqLhbk=
+golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57 h1:F5Gozwx4I1xtr/sr/8CFbb57iKi3297KFs0QDbGN60A=
-golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da h1:b3NXsE2LusjYGGjL5bxEVZZORm/YEFFrWFjR8eFrw/c=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.6-0.20210227105805-e3aa4adf54f6 h1:lmoh2ZlEN/VfIYVdeta6HbTPLqajF5r8riIp1MACt2A=
-golang.org/x/text v0.3.6-0.20210227105805-e3aa4adf54f6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6 h1:aRYxNxv6iGQlyVaZmk6ZgYEDa+Jg18DxebPSrd6bg1M=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
diff --git a/src/vendor/golang.org/x/net/http/httpguts/httplex.go b/src/vendor/golang.org/x/net/http/httpguts/httplex.go
index e7de24ee64..c79aa73f28 100644
--- a/src/vendor/golang.org/x/net/http/httpguts/httplex.go
+++ b/src/vendor/golang.org/x/net/http/httpguts/httplex.go
@@ -137,11 +137,13 @@ func trimOWS(x string) string {
 // contains token amongst its comma-separated tokens, ASCII
 // case-insensitively.
 func headerValueContainsToken(v string, token string) bool {
-	v = trimOWS(v)
-	if comma := strings.IndexByte(v, ','); comma != -1 {
-		return tokenEqual(trimOWS(v[:comma]), token) || headerValueContainsToken(v[comma+1:], token)
+	for comma := strings.IndexByte(v, ','); comma != -1; comma = strings.IndexByte(v, ',') {
+		if tokenEqual(trimOWS(v[:comma]), token) {
+			return true
+		}
+		v = v[comma+1:]
 	}
-	return tokenEqual(v, token)
+	return tokenEqual(trimOWS(v), token)
 }
 
 // lowerASCII returns the ASCII lowercase version of b.
diff --git a/src/vendor/golang.org/x/net/idna/idna10.0.0.go b/src/vendor/golang.org/x/net/idna/idna10.0.0.go
index 7e69ee1b22..5208ba6cb8 100644
--- a/src/vendor/golang.org/x/net/idna/idna10.0.0.go
+++ b/src/vendor/golang.org/x/net/idna/idna10.0.0.go
@@ -67,15 +67,14 @@ func Transitional(transitional bool) Option {
 
 // VerifyDNSLength sets whether a Profile should fail if any of the IDN parts
 // are longer than allowed by the RFC.
+//
+// This option corresponds to the VerifyDnsLength flag in UTS #46.
 func VerifyDNSLength(verify bool) Option {
 	return func(o *options) { o.verifyDNSLength = verify }
 }
 
 // RemoveLeadingDots removes leading label separators. Leading runes that map to
 // dots, such as U+3002 IDEOGRAPHIC FULL STOP, are removed as well.
-//
-// This is the behavior suggested by the UTS #46 and is adopted by some
-// browsers.
 func RemoveLeadingDots(remove bool) Option {
 	return func(o *options) { o.removeLeadingDots = remove }
 }
@@ -83,6 +82,8 @@ func RemoveLeadingDots(remove bool) Option {
 // ValidateLabels sets whether to check the mandatory label validation criteria
 // as defined in Section 5.4 of RFC 5891. This includes testing for correct use
 // of hyphens ('-'), normalization, validity of runes, and the context rules.
+// In particular, ValidateLabels also sets the CheckHyphens and CheckJoiners flags
+// in UTS #46.
 func ValidateLabels(enable bool) Option {
 	return func(o *options) {
 		// Don't override existing mappings, but set one that at least checks
@@ -91,25 +92,48 @@ func ValidateLabels(enable bool) Option {
 			o.mapping = normalize
 		}
 		o.trie = trie
-		o.validateLabels = enable
-		o.fromPuny = validateFromPunycode
+		o.checkJoiners = enable
+		o.checkHyphens = enable
+		if enable {
+			o.fromPuny = validateFromPunycode
+		} else {
+			o.fromPuny = nil
+		}
+	}
+}
+
+// CheckHyphens sets whether to check for correct use of hyphens ('-') in
+// labels. Most web browsers do not have this option set, since labels such as
+// "r3---sn-apo3qvuoxuxbt-j5pe" are in common use.
+//
+// This option corresponds to the CheckHyphens flag in UTS #46.
+func CheckHyphens(enable bool) Option {
+	return func(o *options) { o.checkHyphens = enable }
+}
+
+// CheckJoiners sets whether to check the ContextJ rules as defined in Appendix
+// A of RFC 5892, concerning the use of joiner runes.
+//
+// This option corresponds to the CheckJoiners flag in UTS #46.
+func CheckJoiners(enable bool) Option {
+	return func(o *options) {
+		o.trie = trie
+		o.checkJoiners = enable
 	}
 }
 
 // StrictDomainName limits the set of permissible ASCII characters to those
 // allowed in domain names as defined in RFC 1034 (A-Z, a-z, 0-9 and the
-// hyphen). This is set by default for MapForLookup and ValidateForRegistration.
+// hyphen). This is set by default for MapForLookup and ValidateForRegistration,
+// but is only useful if ValidateLabels is set.
 //
 // This option is useful, for instance, for browsers that allow characters
 // outside this range, for example a '_' (U+005F LOW LINE). See
-// http://www.rfc-editor.org/std/std3.txt for more details This option
-// corresponds to the UseSTD3ASCIIRules option in UTS #46.
+// http://www.rfc-editor.org/std/std3.txt for more details.
+//
+// This option corresponds to the UseSTD3ASCIIRules flag in UTS #46.
 func StrictDomainName(use bool) Option {
-	return func(o *options) {
-		o.trie = trie
-		o.useSTD3Rules = use
-		o.fromPuny = validateFromPunycode
-	}
+	return func(o *options) { o.useSTD3Rules = use }
 }
 
 // NOTE: the following options pull in tables. The tables should not be linked
@@ -117,6 +141,8 @@ func StrictDomainName(use bool) Option {
 
 // BidiRule enables the Bidi rule as defined in RFC 5893. Any application
 // that relies on proper validation of labels should include this rule.
+//
+// This option corresponds to the CheckBidi flag in UTS #46.
 func BidiRule() Option {
 	return func(o *options) { o.bidirule = bidirule.ValidString }
 }
@@ -152,7 +178,8 @@ func MapForLookup() Option {
 type options struct {
 	transitional      bool
 	useSTD3Rules      bool
-	validateLabels    bool
+	checkHyphens      bool
+	checkJoiners      bool
 	verifyDNSLength   bool
 	removeLeadingDots bool
 
@@ -225,8 +252,11 @@ func (p *Profile) String() string {
 	if p.useSTD3Rules {
 		s += ":UseSTD3Rules"
 	}
-	if p.validateLabels {
-		s += ":ValidateLabels"
+	if p.checkHyphens {
+		s += ":CheckHyphens"
+	}
+	if p.checkJoiners {
+		s += ":CheckJoiners"
 	}
 	if p.verifyDNSLength {
 		s += ":VerifyDNSLength"
@@ -254,26 +284,29 @@ var (
 
 	punycode = &Profile{}
 	lookup   = &Profile{options{
-		transitional:   true,
-		useSTD3Rules:   true,
-		validateLabels: true,
-		trie:           trie,
-		fromPuny:       validateFromPunycode,
-		mapping:        validateAndMap,
-		bidirule:       bidirule.ValidString,
+		transitional: true,
+		useSTD3Rules: true,
+		checkHyphens: true,
+		checkJoiners: true,
+		trie:         trie,
+		fromPuny:     validateFromPunycode,
+		mapping:      validateAndMap,
+		bidirule:     bidirule.ValidString,
 	}}
 	display = &Profile{options{
-		useSTD3Rules:   true,
-		validateLabels: true,
-		trie:           trie,
-		fromPuny:       validateFromPunycode,
-		mapping:        validateAndMap,
-		bidirule:       bidirule.ValidString,
+		useSTD3Rules: true,
+		checkHyphens: true,
+		checkJoiners: true,
+		trie:         trie,
+		fromPuny:     validateFromPunycode,
+		mapping:      validateAndMap,
+		bidirule:     bidirule.ValidString,
 	}}
 	registration = &Profile{options{
 		useSTD3Rules:    true,
-		validateLabels:  true,
 		verifyDNSLength: true,
+		checkHyphens:    true,
+		checkJoiners:    true,
 		trie:            trie,
 		fromPuny:        validateFromPunycode,
 		mapping:         validateRegistration,
@@ -340,7 +373,7 @@ func (p *Profile) process(s string, toASCII bool) (string, error) {
 			}
 			isBidi = isBidi || bidirule.DirectionString(u) != bidi.LeftToRight
 			labels.set(u)
-			if err == nil && p.validateLabels {
+			if err == nil && p.fromPuny != nil {
 				err = p.fromPuny(p, u)
 			}
 			if err == nil {
@@ -681,16 +714,18 @@ func (p *Profile) validateLabel(s string) (err error) {
 		}
 		return nil
 	}
-	if !p.validateLabels {
-		return nil
-	}
-	trie := p.trie // p.validateLabels is only set if trie is set.
-	if len(s) > 4 && s[2] == '-' && s[3] == '-' {
-		return &labelError{s, "V2"}
+	if p.checkHyphens {
+		if len(s) > 4 && s[2] == '-' && s[3] == '-' {
+			return &labelError{s, "V2"}
+		}
+		if s[0] == '-' || s[len(s)-1] == '-' {
+			return &labelError{s, "V3"}
+		}
 	}
-	if s[0] == '-' || s[len(s)-1] == '-' {
-		return &labelError{s, "V3"}
+	if !p.checkJoiners {
+		return nil
 	}
+	trie := p.trie // p.checkJoiners is only set if trie is set.
 	// TODO: merge the use of this in the trie.
 	v, sz := trie.lookupString(s)
 	x := info(v)
diff --git a/src/vendor/golang.org/x/net/idna/idna9.0.0.go b/src/vendor/golang.org/x/net/idna/idna9.0.0.go
index 7c7456374c..55f718f127 100644
--- a/src/vendor/golang.org/x/net/idna/idna9.0.0.go
+++ b/src/vendor/golang.org/x/net/idna/idna9.0.0.go
@@ -66,15 +66,14 @@ func Transitional(transitional bool) Option {
 
 // VerifyDNSLength sets whether a Profile should fail if any of the IDN parts
 // are longer than allowed by the RFC.
+//
+// This option corresponds to the VerifyDnsLength flag in UTS #46.
 func VerifyDNSLength(verify bool) Option {
 	return func(o *options) { o.verifyDNSLength = verify }
 }
 
 // RemoveLeadingDots removes leading label separators. Leading runes that map to
 // dots, such as U+3002 IDEOGRAPHIC FULL STOP, are removed as well.
-//
-// This is the behavior suggested by the UTS #46 and is adopted by some
-// browsers.
 func RemoveLeadingDots(remove bool) Option {
 	return func(o *options) { o.removeLeadingDots = remove }
 }
@@ -82,6 +81,8 @@ func RemoveLeadingDots(remove bool) Option {
 // ValidateLabels sets whether to check the mandatory label validation criteria
 // as defined in Section 5.4 of RFC 5891. This includes testing for correct use
 // of hyphens ('-'), normalization, validity of runes, and the context rules.
+// In particular, ValidateLabels also sets the CheckHyphens and CheckJoiners flags
+// in UTS #46.
 func ValidateLabels(enable bool) Option {
 	return func(o *options) {
 		// Don't override existing mappings, but set one that at least checks
@@ -90,25 +91,48 @@ func ValidateLabels(enable bool) Option {
 			o.mapping = normalize
 		}
 		o.trie = trie
-		o.validateLabels = enable
-		o.fromPuny = validateFromPunycode
+		o.checkJoiners = enable
+		o.checkHyphens = enable
+		if enable {
+			o.fromPuny = validateFromPunycode
+		} else {
+			o.fromPuny = nil
+		}
+	}
+}
+
+// CheckHyphens sets whether to check for correct use of hyphens ('-') in
+// labels. Most web browsers do not have this option set, since labels such as
+// "r3---sn-apo3qvuoxuxbt-j5pe" are in common use.
+//
+// This option corresponds to the CheckHyphens flag in UTS #46.
+func CheckHyphens(enable bool) Option {
+	return func(o *options) { o.checkHyphens = enable }
+}
+
+// CheckJoiners sets whether to check the ContextJ rules as defined in Appendix
+// A of RFC 5892, concerning the use of joiner runes.
+//
+// This option corresponds to the CheckJoiners flag in UTS #46.
+func CheckJoiners(enable bool) Option {
+	return func(o *options) {
+		o.trie = trie
+		o.checkJoiners = enable
 	}
 }
 
 // StrictDomainName limits the set of permissable ASCII characters to those
 // allowed in domain names as defined in RFC 1034 (A-Z, a-z, 0-9 and the
-// hyphen). This is set by default for MapForLookup and ValidateForRegistration.
+// hyphen). This is set by default for MapForLookup and ValidateForRegistration,
+// but is only useful if ValidateLabels is set.
 //
 // This option is useful, for instance, for browsers that allow characters
 // outside this range, for example a '_' (U+005F LOW LINE). See
-// http://www.rfc-editor.org/std/std3.txt for more details This option
-// corresponds to the UseSTD3ASCIIRules option in UTS #46.
+// http://www.rfc-editor.org/std/std3.txt for more details.
+//
+// This option corresponds to the UseSTD3ASCIIRules flag in UTS #46.
 func StrictDomainName(use bool) Option {
-	return func(o *options) {
-		o.trie = trie
-		o.useSTD3Rules = use
-		o.fromPuny = validateFromPunycode
-	}
+	return func(o *options) { o.useSTD3Rules = use }
 }
 
 // NOTE: the following options pull in tables. The tables should not be linked
@@ -116,6 +140,8 @@ func StrictDomainName(use bool) Option {
 
 // BidiRule enables the Bidi rule as defined in RFC 5893. Any application
 // that relies on proper validation of labels should include this rule.
+//
+// This option corresponds to the CheckBidi flag in UTS #46.
 func BidiRule() Option {
 	return func(o *options) { o.bidirule = bidirule.ValidString }
 }
@@ -152,7 +178,8 @@ func MapForLookup() Option {
 type options struct {
 	transitional      bool
 	useSTD3Rules      bool
-	validateLabels    bool
+	checkHyphens      bool
+	checkJoiners      bool
 	verifyDNSLength   bool
 	removeLeadingDots bool
 
@@ -225,8 +252,11 @@ func (p *Profile) String() string {
 	if p.useSTD3Rules {
 		s += ":UseSTD3Rules"
 	}
-	if p.validateLabels {
-		s += ":ValidateLabels"
+	if p.checkHyphens {
+		s += ":CheckHyphens"
+	}
+	if p.checkJoiners {
+		s += ":CheckJoiners"
 	}
 	if p.verifyDNSLength {
 		s += ":VerifyDNSLength"
@@ -255,9 +285,10 @@ var (
 	punycode = &Profile{}
 	lookup   = &Profile{options{
 		transitional:      true,
-		useSTD3Rules:      true,
-		validateLabels:    true,
 		removeLeadingDots: true,
+		useSTD3Rules:      true,
+		checkHyphens:      true,
+		checkJoiners:      true,
 		trie:              trie,
 		fromPuny:          validateFromPunycode,
 		mapping:           validateAndMap,
@@ -265,8 +296,9 @@ var (
 	}}
 	display = &Profile{options{
 		useSTD3Rules:      true,
-		validateLabels:    true,
 		removeLeadingDots: true,
+		checkHyphens:      true,
+		checkJoiners:      true,
 		trie:              trie,
 		fromPuny:          validateFromPunycode,
 		mapping:           validateAndMap,
@@ -274,8 +306,9 @@ var (
 	}}
 	registration = &Profile{options{
 		useSTD3Rules:    true,
-		validateLabels:  true,
 		verifyDNSLength: true,
+		checkHyphens:    true,
+		checkJoiners:    true,
 		trie:            trie,
 		fromPuny:        validateFromPunycode,
 		mapping:         validateRegistration,
@@ -339,7 +372,7 @@ func (p *Profile) process(s string, toASCII bool) (string, error) {
 				continue
 			}
 			labels.set(u)
-			if err == nil && p.validateLabels {
+			if err == nil && p.fromPuny != nil {
 				err = p.fromPuny(p, u)
 			}
 			if err == nil {
@@ -629,16 +662,18 @@ func (p *Profile) validateLabel(s string) error {
 	if p.bidirule != nil && !p.bidirule(s) {
 		return &labelError{s, "B"}
 	}
-	if !p.validateLabels {
-		return nil
-	}
-	trie := p.trie // p.validateLabels is only set if trie is set.
-	if len(s) > 4 && s[2] == '-' && s[3] == '-' {
-		return &labelError{s, "V2"}
+	if p.checkHyphens {
+		if len(s) > 4 && s[2] == '-' && s[3] == '-' {
+			return &labelError{s, "V2"}
+		}
+		if s[0] == '-' || s[len(s)-1] == '-' {
+			return &labelError{s, "V3"}
+		}
 	}
-	if s[0] == '-' || s[len(s)-1] == '-' {
-		return &labelError{s, "V3"}
+	if !p.checkJoiners {
+		return nil
 	}
+	trie := p.trie // p.checkJoiners is only set if trie is set.
 	// TODO: merge the use of this in the trie.
 	v, sz := trie.lookupString(s)
 	x := info(v)
diff --git a/src/vendor/golang.org/x/net/route/route.go b/src/vendor/golang.org/x/net/route/route.go
index e3d6da0549..fd0019ecc5 100644
--- a/src/vendor/golang.org/x/net/route/route.go
+++ b/src/vendor/golang.org/x/net/route/route.go
@@ -108,17 +108,28 @@ const (
 // an interface index or a set of interface flags. In most cases, zero
 // means a wildcard.
 func FetchRIB(af int, typ RIBType, arg int) ([]byte, error) {
-	mib := [6]int32{sysCTL_NET, sysAF_ROUTE, 0, int32(af), int32(typ), int32(arg)}
-	n := uintptr(0)
-	if err := sysctl(mib[:], nil, &n, nil, 0); err != nil {
-		return nil, os.NewSyscallError("sysctl", err)
+	try := 0
+	for {
+		try++
+		mib := [6]int32{sysCTL_NET, sysAF_ROUTE, 0, int32(af), int32(typ), int32(arg)}
+		n := uintptr(0)
+		if err := sysctl(mib[:], nil, &n, nil, 0); err != nil {
+			return nil, os.NewSyscallError("sysctl", err)
+		}
+		if n == 0 {
+			return nil, nil
+		}
+		b := make([]byte, n)
+		if err := sysctl(mib[:], &b[0], &n, nil, 0); err != nil {
+			// If the sysctl failed because the data got larger
+			// between the two sysctl calls, try a few times
+			// before failing. (golang.org/issue/45736).
+			const maxTries = 3
+			if err == syscall.ENOMEM && try < maxTries {
+				continue
+			}
+			return nil, os.NewSyscallError("sysctl", err)
+		}
+		return b[:n], nil
 	}
-	if n == 0 {
-		return nil, nil
-	}
-	b := make([]byte, n)
-	if err := sysctl(mib[:], &b[0], &n, nil, 0); err != nil {
-		return nil, os.NewSyscallError("sysctl", err)
-	}
-	return b[:n], nil
 }
diff --git a/src/vendor/modules.txt b/src/vendor/modules.txt
index d849d6553c..8f411a06e3 100644
--- a/src/vendor/modules.txt
+++ b/src/vendor/modules.txt
@@ -8,8 +8,8 @@ golang.org/x/crypto/curve25519
 golang.org/x/crypto/hkdf
 golang.org/x/crypto/internal/subtle
 golang.org/x/crypto/poly1305
-# golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4
-## explicit; go 1.11
+# golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420
+## explicit; go 1.17
 golang.org/x/net/dns/dnsmessage
 golang.org/x/net/http/httpguts
 golang.org/x/net/http/httpproxy
@@ -18,10 +18,10 @@ golang.org/x/net/idna
 golang.org/x/net/lif
 golang.org/x/net/nettest
 golang.org/x/net/route
-# golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57
+# golang.org/x/sys v0.0.0-20210423082822-04245dca01da
 ## explicit; go 1.12
 golang.org/x/sys/cpu
-# golang.org/x/text v0.3.6-0.20210227105805-e3aa4adf54f6
+# golang.org/x/text v0.3.6
 ## explicit; go 1.11
 golang.org/x/text/secure/bidirule
 golang.org/x/text/transform
-- 
GitLab


From 9f347035ef46c5f275fedf23893e0883b3b24035 Mon Sep 17 00:00:00 2001
From: Dmitri Shuralyov <dmitshur@golang.org>
Date: Thu, 29 Apr 2021 16:44:58 -0400
Subject: [PATCH 1933/2400] cmd/api: disallow silent API additions after
 api/go1.n.txt is created

At this time, the golang.org/s/release process arranges such that the
api/go1.n.txt file is created when a Go 1.N Beta 1 release is being cut.
The API check is currently configured so that tests don't fail visibly
even if api/go1.n.txt becomes a subset of the actual API additions in
the upcoming Go 1.N release as long as 'go version' has "devel" in it.
The first time that 'go version' output drops the "devel" substring
during testing is after the release-branch.go1.N branch is created
as part of the process to cut a Go 1.N Release Candidate 1 release.

The month or so between Beta 1 and RC 1 is well into the freeze and
deliberate API changes are rare and very intentional. There seems to
be agreement that it's healthy to make the API check stricter during
that time period. Doing so will ensure that api/go1.n.txt cannot get
stale after creation without anyone noticing, and may catch CLs that
don't have the intended diff on the API.

This CL changes behavior to be simple and clear: from the moment
an api/go1.n.txt file corresponding to the current Go version in
development is added to the tree, silent API additions stop being
permitted.

This CL also moves the magical "override the value of -allow_new flag
if runtime.Version() contains 'devel' string" behavior from cmd/api
command to the run.go script that calls it, making the CLI of cmd/api
itself less surprising.

Fixes #43956.

Change-Id: I89468207573f7ccdbc9f12625dcdd3ef2bcf8f10
Reviewed-on: https://go-review.googlesource.com/c/go/+/315350
Run-TryBot: Dmitri Shuralyov <dmitshur@golang.org>
Trust: Dmitri Shuralyov <dmitshur@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Alexander Rakoczy <alex@golang.org>
---
 src/cmd/api/goapi.go |  3 +--
 src/cmd/api/run.go   | 36 ++++++++++++++++++++++++++++++++++++
 2 files changed, 37 insertions(+), 2 deletions(-)

diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index efc2696f8f..b07a238d67 100644
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -215,8 +215,7 @@ func main() {
 	}
 	optional := fileFeatures(*nextFile)
 	exception := fileFeatures(*exceptFile)
-	fail = !compareAPI(bw, features, required, optional, exception,
-		*allowNew && strings.Contains(runtime.Version(), "devel"))
+	fail = !compareAPI(bw, features, required, optional, exception, *allowNew)
 }
 
 // export emits the exported package features.
diff --git a/src/cmd/api/run.go b/src/cmd/api/run.go
index 8c9fb723a5..81979de191 100644
--- a/src/cmd/api/run.go
+++ b/src/cmd/api/run.go
@@ -10,8 +10,11 @@
 package main
 
 import (
+	"errors"
 	"fmt"
 	exec "internal/execabs"
+	"internal/goversion"
+	"io/fs"
 	"log"
 	"os"
 	"path/filepath"
@@ -43,6 +46,7 @@ func main() {
 	apiDir := filepath.Join(goroot, "api")
 	out, err := exec.Command(goCmd(), "tool", "api",
 		"-c", findAPIDirFiles(apiDir),
+		allowNew(apiDir),
 		"-next", filepath.Join(apiDir, "next.txt"),
 		"-except", filepath.Join(apiDir, "except.txt")).CombinedOutput()
 	if err != nil {
@@ -71,3 +75,35 @@ func findAPIDirFiles(apiDir string) string {
 	}
 	return strings.Join(apiFiles, ",")
 }
+
+// allowNew returns the -allow_new flag to use for the 'go tool api' invocation.
+func allowNew(apiDir string) string {
+	// Verify that the api/go1.n.txt for previous Go version exists.
+	// It definitely should, otherwise it's a signal that the logic below may be outdated.
+	if _, err := os.Stat(filepath.Join(apiDir, fmt.Sprintf("go1.%d.txt", goversion.Version-1))); err != nil {
+		log.Fatalln("Problem with api file for previous release:", err)
+	}
+
+	// See whether the api/go1.n.txt for this Go version has been created.
+	// (As of April 2021, it gets created during the release of the first Beta.)
+	_, err := os.Stat(filepath.Join(apiDir, fmt.Sprintf("go1.%d.txt", goversion.Version)))
+	if errors.Is(err, fs.ErrNotExist) {
+		// It doesn't exist, so we're in development or before Beta 1.
+		// At this stage, unmentioned API additions are deemed okay.
+		// (They will be quietly shown in API check output, but the test won't fail).
+		return "-allow_new=true"
+	} else if err == nil {
+		// The api/go1.n.txt for this Go version has been created,
+		// so we're definitely past Beta 1 in the release cycle.
+		//
+		// From this point, enforce that api/go1.n.txt is an accurate and complete
+		// representation of what's going into the release by failing API check if
+		// there are API additions (a month into the freeze, there shouldn't be many).
+		//
+		// See golang.org/issue/43956.
+		return "-allow_new=false"
+	} else {
+		log.Fatal(err)
+	}
+	panic("unreachable")
+}
-- 
GitLab


From ddb648fdf6c21e7e56a2252df3e3913a212ca4ab Mon Sep 17 00:00:00 2001
From: Eddie Scholtz <escholtz@google.com>
Date: Wed, 21 Apr 2021 11:11:02 -0600
Subject: [PATCH 1934/2400] archive/zip: add File.OpenRaw, Writer.CreateRaw,
 Writer.Copy

These new methods provide support for cases where performance is a
primary concern. For example, copying files from an existing zip to a
new zip without incurring the decompression and compression overhead.
Using an optimized, external compression method and writing the output
to a zip archive. And compressing file contents in parallel and then
sequentially writing the compressed bytes to a zip archive.

TestWriterCopy is copied verbatim from https://github.com/rsc/zipmerge

Fixes #34974

Change-Id: Iade5bc245ba34cdbb86364bf59f79f38bb9e2eb6
Reviewed-on: https://go-review.googlesource.com/c/go/+/312310
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Carlos Amedee <carlos@golang.org>
---
 src/archive/zip/reader.go      | 115 +++++++++++++++-------
 src/archive/zip/reader_test.go | 165 ++++++++++++++++++++++++++++++-
 src/archive/zip/struct.go      |  14 ++-
 src/archive/zip/writer.go      | 135 +++++++++++++++++++++----
 src/archive/zip/writer_test.go | 173 ++++++++++++++++++++++++++++++++-
 5 files changed, 541 insertions(+), 61 deletions(-)

diff --git a/src/archive/zip/reader.go b/src/archive/zip/reader.go
index 18f9833db0..808cf274ca 100644
--- a/src/archive/zip/reader.go
+++ b/src/archive/zip/reader.go
@@ -52,12 +52,9 @@ type File struct {
 	FileHeader
 	zip          *Reader
 	zipr         io.ReaderAt
-	zipsize      int64
 	headerOffset int64
-}
-
-func (f *File) hasDataDescriptor() bool {
-	return f.Flags&0x8 != 0
+	zip64        bool  // zip64 extended information extra field presence
+	descErr      error // error reading the data descriptor during init
 }
 
 // OpenReader will open the Zip file specified by name and return a ReadCloser.
@@ -112,7 +109,7 @@ func (z *Reader) init(r io.ReaderAt, size int64) error {
 	// a bad one, and then only report an ErrFormat or UnexpectedEOF if
 	// the file count modulo 65536 is incorrect.
 	for {
-		f := &File{zip: z, zipr: r, zipsize: size}
+		f := &File{zip: z, zipr: r}
 		err = readDirectoryHeader(f, buf)
 		if err == ErrFormat || err == io.ErrUnexpectedEOF {
 			break
@@ -120,6 +117,7 @@ func (z *Reader) init(r io.ReaderAt, size int64) error {
 		if err != nil {
 			return err
 		}
+		f.readDataDescriptor()
 		z.File = append(z.File, f)
 	}
 	if uint16(len(z.File)) != uint16(end.directoryRecords) { // only compare 16 bits here
@@ -180,26 +178,68 @@ func (f *File) Open() (io.ReadCloser, error) {
 		return nil, ErrAlgorithm
 	}
 	var rc io.ReadCloser = dcomp(r)
-	var desr io.Reader
-	if f.hasDataDescriptor() {
-		desr = io.NewSectionReader(f.zipr, f.headerOffset+bodyOffset+size, dataDescriptorLen)
-	}
 	rc = &checksumReader{
 		rc:   rc,
 		hash: crc32.NewIEEE(),
 		f:    f,
-		desr: desr,
 	}
 	return rc, nil
 }
 
+// OpenRaw returns a Reader that provides access to the File's contents without
+// decompression.
+func (f *File) OpenRaw() (io.Reader, error) {
+	bodyOffset, err := f.findBodyOffset()
+	if err != nil {
+		return nil, err
+	}
+	r := io.NewSectionReader(f.zipr, f.headerOffset+bodyOffset, int64(f.CompressedSize64))
+	return r, nil
+}
+
+func (f *File) readDataDescriptor() {
+	if !f.hasDataDescriptor() {
+		return
+	}
+
+	bodyOffset, err := f.findBodyOffset()
+	if err != nil {
+		f.descErr = err
+		return
+	}
+
+	// In section 4.3.9.2 of the spec: "However ZIP64 format MAY be used
+	// regardless of the size of a file.  When extracting, if the zip64
+	// extended information extra field is present for the file the
+	// compressed and uncompressed sizes will be 8 byte values."
+	//
+	// Historically, this package has used the compressed and uncompressed
+	// sizes from the central directory to determine if the package is
+	// zip64.
+	//
+	// For this case we allow either the extra field or sizes to determine
+	// the data descriptor length.
+	zip64 := f.zip64 || f.isZip64()
+	n := int64(dataDescriptorLen)
+	if zip64 {
+		n = dataDescriptor64Len
+	}
+	size := int64(f.CompressedSize64)
+	r := io.NewSectionReader(f.zipr, f.headerOffset+bodyOffset+size, n)
+	dd, err := readDataDescriptor(r, zip64)
+	if err != nil {
+		f.descErr = err
+		return
+	}
+	f.CRC32 = dd.crc32
+}
+
 type checksumReader struct {
 	rc    io.ReadCloser
 	hash  hash.Hash32
 	nread uint64 // number of bytes read so far
 	f     *File
-	desr  io.Reader // if non-nil, where to read the data descriptor
-	err   error     // sticky error
+	err   error // sticky error
 }
 
 func (r *checksumReader) Stat() (fs.FileInfo, error) {
@@ -220,12 +260,12 @@ func (r *checksumReader) Read(b []byte) (n int, err error) {
 		if r.nread != r.f.UncompressedSize64 {
 			return 0, io.ErrUnexpectedEOF
 		}
-		if r.desr != nil {
-			if err1 := readDataDescriptor(r.desr, r.f); err1 != nil {
-				if err1 == io.EOF {
+		if r.f.hasDataDescriptor() {
+			if r.f.descErr != nil {
+				if r.f.descErr == io.EOF {
 					err = io.ErrUnexpectedEOF
 				} else {
-					err = err1
+					err = r.f.descErr
 				}
 			} else if r.hash.Sum32() != r.f.CRC32 {
 				err = ErrChecksum
@@ -336,6 +376,8 @@ parseExtras:
 
 		switch fieldTag {
 		case zip64ExtraID:
+			f.zip64 = true
+
 			// update directory values from the zip64 extra block.
 			// They should only be consulted if the sizes read earlier
 			// are maxed out.
@@ -435,8 +477,9 @@ parseExtras:
 	return nil
 }
 
-func readDataDescriptor(r io.Reader, f *File) error {
-	var buf [dataDescriptorLen]byte
+func readDataDescriptor(r io.Reader, zip64 bool) (*dataDescriptor, error) {
+	// Create enough space for the largest possible size
+	var buf [dataDescriptor64Len]byte
 
 	// The spec says: "Although not originally assigned a
 	// signature, the value 0x08074b50 has commonly been adopted
@@ -446,10 +489,9 @@ func readDataDescriptor(r io.Reader, f *File) error {
 	// descriptors and should account for either case when reading
 	// ZIP files to ensure compatibility."
 	//
-	// dataDescriptorLen includes the size of the signature but
-	// first read just those 4 bytes to see if it exists.
+	// First read just those 4 bytes to see if the signature exists.
 	if _, err := io.ReadFull(r, buf[:4]); err != nil {
-		return err
+		return nil, err
 	}
 	off := 0
 	maybeSig := readBuf(buf[:4])
@@ -458,21 +500,28 @@ func readDataDescriptor(r io.Reader, f *File) error {
 		// bytes.
 		off += 4
 	}
-	if _, err := io.ReadFull(r, buf[off:12]); err != nil {
-		return err
+
+	end := dataDescriptorLen - 4
+	if zip64 {
+		end = dataDescriptor64Len - 4
 	}
-	b := readBuf(buf[:12])
-	if b.uint32() != f.CRC32 {
-		return ErrChecksum
+	if _, err := io.ReadFull(r, buf[off:end]); err != nil {
+		return nil, err
 	}
+	b := readBuf(buf[:end])
 
-	// The two sizes that follow here can be either 32 bits or 64 bits
-	// but the spec is not very clear on this and different
-	// interpretations has been made causing incompatibilities. We
-	// already have the sizes from the central directory so we can
-	// just ignore these.
+	out := &dataDescriptor{
+		crc32: b.uint32(),
+	}
 
-	return nil
+	if zip64 {
+		out.compressedSize = b.uint64()
+		out.uncompressedSize = b.uint64()
+	} else {
+		out.compressedSize = uint64(b.uint32())
+		out.uncompressedSize = uint64(b.uint32())
+	}
+	return out, nil
 }
 
 func readDirectoryEnd(r io.ReaderAt, size int64) (dir *directoryEnd, err error) {
diff --git a/src/archive/zip/reader_test.go b/src/archive/zip/reader_test.go
index 6ee62ef997..35e681ec69 100644
--- a/src/archive/zip/reader_test.go
+++ b/src/archive/zip/reader_test.go
@@ -499,9 +499,15 @@ func TestReader(t *testing.T) {
 func readTestZip(t *testing.T, zt ZipTest) {
 	var z *Reader
 	var err error
+	var raw []byte
 	if zt.Source != nil {
 		rat, size := zt.Source()
 		z, err = NewReader(rat, size)
+		raw = make([]byte, size)
+		if _, err := rat.ReadAt(raw, 0); err != nil {
+			t.Errorf("ReadAt error=%v", err)
+			return
+		}
 	} else {
 		path := filepath.Join("testdata", zt.Name)
 		if zt.Obscured {
@@ -519,6 +525,12 @@ func readTestZip(t *testing.T, zt ZipTest) {
 			defer rc.Close()
 			z = &rc.Reader
 		}
+		var err2 error
+		raw, err2 = os.ReadFile(path)
+		if err2 != nil {
+			t.Errorf("ReadFile(%s) error=%v", path, err2)
+			return
+		}
 	}
 	if err != zt.Error {
 		t.Errorf("error=%v, want %v", err, zt.Error)
@@ -545,7 +557,7 @@ func readTestZip(t *testing.T, zt ZipTest) {
 
 	// test read of each file
 	for i, ft := range zt.File {
-		readTestFile(t, zt, ft, z.File[i])
+		readTestFile(t, zt, ft, z.File[i], raw)
 	}
 	if t.Failed() {
 		return
@@ -557,7 +569,7 @@ func readTestZip(t *testing.T, zt ZipTest) {
 	for i := 0; i < 5; i++ {
 		for j, ft := range zt.File {
 			go func(j int, ft ZipTestFile) {
-				readTestFile(t, zt, ft, z.File[j])
+				readTestFile(t, zt, ft, z.File[j], raw)
 				done <- true
 			}(j, ft)
 			n++
@@ -574,7 +586,7 @@ func equalTimeAndZone(t1, t2 time.Time) bool {
 	return t1.Equal(t2) && name1 == name2 && offset1 == offset2
 }
 
-func readTestFile(t *testing.T, zt ZipTest, ft ZipTestFile, f *File) {
+func readTestFile(t *testing.T, zt ZipTest, ft ZipTestFile, f *File, raw []byte) {
 	if f.Name != ft.Name {
 		t.Errorf("name=%q, want %q", f.Name, ft.Name)
 	}
@@ -594,6 +606,31 @@ func readTestFile(t *testing.T, zt ZipTest, ft ZipTestFile, f *File) {
 		t.Errorf("%v: UncompressedSize=%#x does not match UncompressedSize64=%#x", f.Name, size, f.UncompressedSize64)
 	}
 
+	// Check that OpenRaw returns the correct byte segment
+	rw, err := f.OpenRaw()
+	if err != nil {
+		t.Errorf("%v: OpenRaw error=%v", f.Name, err)
+		return
+	}
+	start, err := f.DataOffset()
+	if err != nil {
+		t.Errorf("%v: DataOffset error=%v", f.Name, err)
+		return
+	}
+	got, err := io.ReadAll(rw)
+	if err != nil {
+		t.Errorf("%v: OpenRaw ReadAll error=%v", f.Name, err)
+		return
+	}
+	end := uint64(start) + f.CompressedSize64
+	want := raw[start:end]
+	if !bytes.Equal(got, want) {
+		t.Logf("got %q", got)
+		t.Logf("want %q", want)
+		t.Errorf("%v: OpenRaw returned unexpected bytes", f.Name)
+		return
+	}
+
 	r, err := f.Open()
 	if err != nil {
 		t.Errorf("%v", err)
@@ -1166,3 +1203,125 @@ func TestCVE202127919(t *testing.T) {
 		t.Errorf("Error reading file: %v", err)
 	}
 }
+
+func TestReadDataDescriptor(t *testing.T) {
+	tests := []struct {
+		desc    string
+		in      []byte
+		zip64   bool
+		want    *dataDescriptor
+		wantErr error
+	}{{
+		desc: "valid 32 bit with signature",
+		in: []byte{
+			0x50, 0x4b, 0x07, 0x08, // signature
+			0x00, 0x01, 0x02, 0x03, // crc32
+			0x04, 0x05, 0x06, 0x07, // compressed size
+			0x08, 0x09, 0x0a, 0x0b, // uncompressed size
+		},
+		want: &dataDescriptor{
+			crc32:            0x03020100,
+			compressedSize:   0x07060504,
+			uncompressedSize: 0x0b0a0908,
+		},
+	}, {
+		desc: "valid 32 bit without signature",
+		in: []byte{
+			0x00, 0x01, 0x02, 0x03, // crc32
+			0x04, 0x05, 0x06, 0x07, // compressed size
+			0x08, 0x09, 0x0a, 0x0b, // uncompressed size
+		},
+		want: &dataDescriptor{
+			crc32:            0x03020100,
+			compressedSize:   0x07060504,
+			uncompressedSize: 0x0b0a0908,
+		},
+	}, {
+		desc: "valid 64 bit with signature",
+		in: []byte{
+			0x50, 0x4b, 0x07, 0x08, // signature
+			0x00, 0x01, 0x02, 0x03, // crc32
+			0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, // compressed size
+			0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, // uncompressed size
+		},
+		zip64: true,
+		want: &dataDescriptor{
+			crc32:            0x03020100,
+			compressedSize:   0x0b0a090807060504,
+			uncompressedSize: 0x131211100f0e0d0c,
+		},
+	}, {
+		desc: "valid 64 bit without signature",
+		in: []byte{
+			0x00, 0x01, 0x02, 0x03, // crc32
+			0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, // compressed size
+			0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, // uncompressed size
+		},
+		zip64: true,
+		want: &dataDescriptor{
+			crc32:            0x03020100,
+			compressedSize:   0x0b0a090807060504,
+			uncompressedSize: 0x131211100f0e0d0c,
+		},
+	}, {
+		desc: "invalid 32 bit with signature",
+		in: []byte{
+			0x50, 0x4b, 0x07, 0x08, // signature
+			0x00, 0x01, 0x02, 0x03, // crc32
+			0x04, 0x05, // unexpected end
+		},
+		wantErr: io.ErrUnexpectedEOF,
+	}, {
+		desc: "invalid 32 bit without signature",
+		in: []byte{
+			0x00, 0x01, 0x02, 0x03, // crc32
+			0x04, 0x05, // unexpected end
+		},
+		wantErr: io.ErrUnexpectedEOF,
+	}, {
+		desc: "invalid 64 bit with signature",
+		in: []byte{
+			0x50, 0x4b, 0x07, 0x08, // signature
+			0x00, 0x01, 0x02, 0x03, // crc32
+			0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, // compressed size
+			0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, // unexpected end
+		},
+		zip64:   true,
+		wantErr: io.ErrUnexpectedEOF,
+	}, {
+		desc: "invalid 64 bit without signature",
+		in: []byte{
+			0x00, 0x01, 0x02, 0x03, // crc32
+			0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, // compressed size
+			0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, // unexpected end
+		},
+		zip64:   true,
+		wantErr: io.ErrUnexpectedEOF,
+	}}
+
+	for _, test := range tests {
+		t.Run(test.desc, func(t *testing.T) {
+			r := bytes.NewReader(test.in)
+
+			desc, err := readDataDescriptor(r, test.zip64)
+			if err != test.wantErr {
+				t.Fatalf("got err %v; want nil", err)
+			}
+			if test.want == nil {
+				return
+			}
+			if desc == nil {
+				t.Fatalf("got nil DataDescriptor; want non-nil")
+			}
+			if desc.crc32 != test.want.crc32 {
+				t.Errorf("got CRC32 %#x; want %#x", desc.crc32, test.want.crc32)
+			}
+			if desc.compressedSize != test.want.compressedSize {
+				t.Errorf("got CompressedSize %#x; want %#x", desc.compressedSize, test.want.compressedSize)
+			}
+			if desc.uncompressedSize != test.want.uncompressedSize {
+				t.Errorf("got UncompressedSize %#x; want %#x", desc.uncompressedSize, test.want.uncompressedSize)
+			}
+		})
+	}
+}
diff --git a/src/archive/zip/struct.go b/src/archive/zip/struct.go
index 3dc0c50122..ff9f605eb6 100644
--- a/src/archive/zip/struct.go
+++ b/src/archive/zip/struct.go
@@ -42,7 +42,7 @@ const (
 	directoryHeaderLen       = 46         // + filename + extra + comment
 	directoryEndLen          = 22         // + comment
 	dataDescriptorLen        = 16         // four uint32: descriptor signature, crc32, compressed size, size
-	dataDescriptor64Len      = 24         // descriptor with 8 byte sizes
+	dataDescriptor64Len      = 24         // two uint32: signature, crc32 | two uint64: compressed size, size
 	directory64LocLen        = 20         //
 	directory64EndLen        = 56         // + extra
 
@@ -315,6 +315,10 @@ func (h *FileHeader) isZip64() bool {
 	return h.CompressedSize64 >= uint32max || h.UncompressedSize64 >= uint32max
 }
 
+func (f *FileHeader) hasDataDescriptor() bool {
+	return f.Flags&0x8 != 0
+}
+
 func msdosModeToFileMode(m uint32) (mode fs.FileMode) {
 	if m&msdosDir != 0 {
 		mode = fs.ModeDir | 0777
@@ -386,3 +390,11 @@ func unixModeToFileMode(m uint32) fs.FileMode {
 	}
 	return mode
 }
+
+// dataDescriptor holds the data descriptor that optionally follows the file
+// contents in the zip file.
+type dataDescriptor struct {
+	crc32            uint32
+	compressedSize   uint64
+	uncompressedSize uint64
+}
diff --git a/src/archive/zip/writer.go b/src/archive/zip/writer.go
index cdc534eaf0..3b23cc3391 100644
--- a/src/archive/zip/writer.go
+++ b/src/archive/zip/writer.go
@@ -37,6 +37,7 @@ type Writer struct {
 type header struct {
 	*FileHeader
 	offset uint64
+	raw    bool
 }
 
 // NewWriter returns a new Writer writing a zip file to w.
@@ -245,22 +246,31 @@ func detectUTF8(s string) (valid, require bool) {
 	return true, require
 }
 
+// prepare performs the bookkeeping operations required at the start of
+// CreateHeader and CreateRaw.
+func (w *Writer) prepare(fh *FileHeader) error {
+	if w.last != nil && !w.last.closed {
+		if err := w.last.close(); err != nil {
+			return err
+		}
+	}
+	if len(w.dir) > 0 && w.dir[len(w.dir)-1].FileHeader == fh {
+		// See https://golang.org/issue/11144 confusion.
+		return errors.New("archive/zip: invalid duplicate FileHeader")
+	}
+	return nil
+}
+
 // CreateHeader adds a file to the zip archive using the provided FileHeader
 // for the file metadata. Writer takes ownership of fh and may mutate
 // its fields. The caller must not modify fh after calling CreateHeader.
 //
 // This returns a Writer to which the file contents should be written.
 // The file's contents must be written to the io.Writer before the next
-// call to Create, CreateHeader, or Close.
+// call to Create, CreateHeader, CreateRaw, or Close.
 func (w *Writer) CreateHeader(fh *FileHeader) (io.Writer, error) {
-	if w.last != nil && !w.last.closed {
-		if err := w.last.close(); err != nil {
-			return nil, err
-		}
-	}
-	if len(w.dir) > 0 && w.dir[len(w.dir)-1].FileHeader == fh {
-		// See https://golang.org/issue/11144 confusion.
-		return nil, errors.New("archive/zip: invalid duplicate FileHeader")
+	if err := w.prepare(fh); err != nil {
+		return nil, err
 	}
 
 	// The ZIP format has a sad state of affairs regarding character encoding.
@@ -365,7 +375,7 @@ func (w *Writer) CreateHeader(fh *FileHeader) (io.Writer, error) {
 		ow = fw
 	}
 	w.dir = append(w.dir, h)
-	if err := writeHeader(w.cw, fh); err != nil {
+	if err := writeHeader(w.cw, h); err != nil {
 		return nil, err
 	}
 	// If we're creating a directory, fw is nil.
@@ -373,7 +383,7 @@ func (w *Writer) CreateHeader(fh *FileHeader) (io.Writer, error) {
 	return ow, nil
 }
 
-func writeHeader(w io.Writer, h *FileHeader) error {
+func writeHeader(w io.Writer, h *header) error {
 	const maxUint16 = 1<<16 - 1
 	if len(h.Name) > maxUint16 {
 		return errLongName
@@ -390,9 +400,20 @@ func writeHeader(w io.Writer, h *FileHeader) error {
 	b.uint16(h.Method)
 	b.uint16(h.ModifiedTime)
 	b.uint16(h.ModifiedDate)
-	b.uint32(0) // since we are writing a data descriptor crc32,
-	b.uint32(0) // compressed size,
-	b.uint32(0) // and uncompressed size should be zero
+	// In raw mode (caller does the compression), the values are either
+	// written here or in the trailing data descriptor based on the header
+	// flags.
+	if h.raw && !h.hasDataDescriptor() {
+		b.uint32(h.CRC32)
+		b.uint32(uint32(min64(h.CompressedSize64, uint32max)))
+		b.uint32(uint32(min64(h.UncompressedSize64, uint32max)))
+	} else {
+		// When this package handle the compression, these values are
+		// always written to the trailing data descriptor.
+		b.uint32(0) // crc32
+		b.uint32(0) // compressed size
+		b.uint32(0) // uncompressed size
+	}
 	b.uint16(uint16(len(h.Name)))
 	b.uint16(uint16(len(h.Extra)))
 	if _, err := w.Write(buf[:]); err != nil {
@@ -405,6 +426,65 @@ func writeHeader(w io.Writer, h *FileHeader) error {
 	return err
 }
 
+func min64(x, y uint64) uint64 {
+	if x < y {
+		return x
+	}
+	return y
+}
+
+// CreateRaw adds a file to the zip archive using the provided FileHeader and
+// returns a Writer to which the file contents should be written. The file's
+// contents must be written to the io.Writer before the next call to Create,
+// CreateHeader, CreateRaw, or Close.
+//
+// In contrast to CreateHeader, the bytes passed to Writer are not compressed.
+func (w *Writer) CreateRaw(fh *FileHeader) (io.Writer, error) {
+	if err := w.prepare(fh); err != nil {
+		return nil, err
+	}
+
+	fh.CompressedSize = uint32(min64(fh.CompressedSize64, uint32max))
+	fh.UncompressedSize = uint32(min64(fh.UncompressedSize64, uint32max))
+
+	h := &header{
+		FileHeader: fh,
+		offset:     uint64(w.cw.count),
+		raw:        true,
+	}
+	w.dir = append(w.dir, h)
+	if err := writeHeader(w.cw, h); err != nil {
+		return nil, err
+	}
+
+	if strings.HasSuffix(fh.Name, "/") {
+		w.last = nil
+		return dirWriter{}, nil
+	}
+
+	fw := &fileWriter{
+		header: h,
+		zipw:   w.cw,
+	}
+	w.last = fw
+	return fw, nil
+}
+
+// Copy copies the file f (obtained from a Reader) into w. It copies the raw
+// form directly bypassing decompression, compression, and validation.
+func (w *Writer) Copy(f *File) error {
+	r, err := f.OpenRaw()
+	if err != nil {
+		return err
+	}
+	fw, err := w.CreateRaw(&f.FileHeader)
+	if err != nil {
+		return err
+	}
+	_, err = io.Copy(fw, r)
+	return err
+}
+
 // RegisterCompressor registers or overrides a custom compressor for a specific
 // method ID. If a compressor for a given method is not found, Writer will
 // default to looking up the compressor at the package level.
@@ -446,6 +526,9 @@ func (w *fileWriter) Write(p []byte) (int, error) {
 	if w.closed {
 		return 0, errors.New("zip: write to closed file")
 	}
+	if w.raw {
+		return w.zipw.Write(p)
+	}
 	w.crc32.Write(p)
 	return w.rawCount.Write(p)
 }
@@ -455,6 +538,9 @@ func (w *fileWriter) close() error {
 		return errors.New("zip: file closed twice")
 	}
 	w.closed = true
+	if w.raw {
+		return w.writeDataDescriptor()
+	}
 	if err := w.comp.Close(); err != nil {
 		return err
 	}
@@ -474,26 +560,33 @@ func (w *fileWriter) close() error {
 		fh.UncompressedSize = uint32(fh.UncompressedSize64)
 	}
 
+	return w.writeDataDescriptor()
+}
+
+func (w *fileWriter) writeDataDescriptor() error {
+	if !w.hasDataDescriptor() {
+		return nil
+	}
 	// Write data descriptor. This is more complicated than one would
 	// think, see e.g. comments in zipfile.c:putextended() and
 	// http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=7073588.
 	// The approach here is to write 8 byte sizes if needed without
 	// adding a zip64 extra in the local header (too late anyway).
 	var buf []byte
-	if fh.isZip64() {
+	if w.isZip64() {
 		buf = make([]byte, dataDescriptor64Len)
 	} else {
 		buf = make([]byte, dataDescriptorLen)
 	}
 	b := writeBuf(buf)
 	b.uint32(dataDescriptorSignature) // de-facto standard, required by OS X
-	b.uint32(fh.CRC32)
-	if fh.isZip64() {
-		b.uint64(fh.CompressedSize64)
-		b.uint64(fh.UncompressedSize64)
+	b.uint32(w.CRC32)
+	if w.isZip64() {
+		b.uint64(w.CompressedSize64)
+		b.uint64(w.UncompressedSize64)
 	} else {
-		b.uint32(fh.CompressedSize)
-		b.uint32(fh.UncompressedSize)
+		b.uint32(w.CompressedSize)
+		b.uint32(w.UncompressedSize)
 	}
 	_, err := w.zipw.Write(buf)
 	return err
diff --git a/src/archive/zip/writer_test.go b/src/archive/zip/writer_test.go
index 3fa8bef055..97c6c52979 100644
--- a/src/archive/zip/writer_test.go
+++ b/src/archive/zip/writer_test.go
@@ -6,8 +6,10 @@ package zip
 
 import (
 	"bytes"
+	"compress/flate"
 	"encoding/binary"
 	"fmt"
+	"hash/crc32"
 	"io"
 	"io/fs"
 	"math/rand"
@@ -365,6 +367,171 @@ func TestWriterDirAttributes(t *testing.T) {
 	}
 }
 
+func TestWriterCopy(t *testing.T) {
+	// make a zip file
+	buf := new(bytes.Buffer)
+	w := NewWriter(buf)
+	for _, wt := range writeTests {
+		testCreate(t, w, &wt)
+	}
+	if err := w.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	// read it back
+	src, err := NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for i, wt := range writeTests {
+		testReadFile(t, src.File[i], &wt)
+	}
+
+	// make a new zip file copying the old compressed data.
+	buf2 := new(bytes.Buffer)
+	dst := NewWriter(buf2)
+	for _, f := range src.File {
+		if err := dst.Copy(f); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := dst.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	// read the new one back
+	r, err := NewReader(bytes.NewReader(buf2.Bytes()), int64(buf2.Len()))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for i, wt := range writeTests {
+		testReadFile(t, r.File[i], &wt)
+	}
+}
+
+func TestWriterCreateRaw(t *testing.T) {
+	files := []struct {
+		name             string
+		content          []byte
+		method           uint16
+		flags            uint16
+		crc32            uint32
+		uncompressedSize uint64
+		compressedSize   uint64
+	}{
+		{
+			name:    "small store w desc",
+			content: []byte("gophers"),
+			method:  Store,
+			flags:   0x8,
+		},
+		{
+			name:    "small deflate wo desc",
+			content: bytes.Repeat([]byte("abcdefg"), 2048),
+			method:  Deflate,
+		},
+	}
+
+	// write a zip file
+	archive := new(bytes.Buffer)
+	w := NewWriter(archive)
+
+	for i := range files {
+		f := &files[i]
+		f.crc32 = crc32.ChecksumIEEE(f.content)
+		size := uint64(len(f.content))
+		f.uncompressedSize = size
+		f.compressedSize = size
+
+		var compressedContent []byte
+		if f.method == Deflate {
+			var buf bytes.Buffer
+			w, err := flate.NewWriter(&buf, flate.BestSpeed)
+			if err != nil {
+				t.Fatalf("flate.NewWriter err = %v", err)
+			}
+			_, err = w.Write(f.content)
+			if err != nil {
+				t.Fatalf("flate Write err = %v", err)
+			}
+			err = w.Close()
+			if err != nil {
+				t.Fatalf("flate Writer.Close err = %v", err)
+			}
+			compressedContent = buf.Bytes()
+			f.compressedSize = uint64(len(compressedContent))
+		}
+
+		h := &FileHeader{
+			Name:               f.name,
+			Method:             f.method,
+			Flags:              f.flags,
+			CRC32:              f.crc32,
+			CompressedSize64:   f.compressedSize,
+			UncompressedSize64: f.uncompressedSize,
+		}
+		w, err := w.CreateRaw(h)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if compressedContent != nil {
+			_, err = w.Write(compressedContent)
+		} else {
+			_, err = w.Write(f.content)
+		}
+		if err != nil {
+			t.Fatalf("%s Write got %v; want nil", f.name, err)
+		}
+	}
+
+	if err := w.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	// read it back
+	r, err := NewReader(bytes.NewReader(archive.Bytes()), int64(archive.Len()))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for i, want := range files {
+		got := r.File[i]
+		if got.Name != want.name {
+			t.Errorf("got Name %s; want %s", got.Name, want.name)
+		}
+		if got.Method != want.method {
+			t.Errorf("%s: got Method %#x; want %#x", want.name, got.Method, want.method)
+		}
+		if got.Flags != want.flags {
+			t.Errorf("%s: got Flags %#x; want %#x", want.name, got.Flags, want.flags)
+		}
+		if got.CRC32 != want.crc32 {
+			t.Errorf("%s: got CRC32 %#x; want %#x", want.name, got.CRC32, want.crc32)
+		}
+		if got.CompressedSize64 != want.compressedSize {
+			t.Errorf("%s: got CompressedSize64 %d; want %d", want.name, got.CompressedSize64, want.compressedSize)
+		}
+		if got.UncompressedSize64 != want.uncompressedSize {
+			t.Errorf("%s: got UncompressedSize64 %d; want %d", want.name, got.UncompressedSize64, want.uncompressedSize)
+		}
+
+		r, err := got.Open()
+		if err != nil {
+			t.Errorf("%s: Open err = %v", got.Name, err)
+			continue
+		}
+
+		buf, err := io.ReadAll(r)
+		if err != nil {
+			t.Errorf("%s: ReadAll err = %v", got.Name, err)
+			continue
+		}
+
+		if !bytes.Equal(buf, want.content) {
+			t.Errorf("%v: ReadAll returned unexpected bytes", got.Name)
+		}
+	}
+}
+
 func testCreate(t *testing.T, w *Writer, wt *WriteTest) {
 	header := &FileHeader{
 		Name:   wt.Name,
@@ -390,15 +557,15 @@ func testReadFile(t *testing.T, f *File, wt *WriteTest) {
 	testFileMode(t, f, wt.Mode)
 	rc, err := f.Open()
 	if err != nil {
-		t.Fatal("opening:", err)
+		t.Fatalf("opening %s: %v", f.Name, err)
 	}
 	b, err := io.ReadAll(rc)
 	if err != nil {
-		t.Fatal("reading:", err)
+		t.Fatalf("reading %s: %v", f.Name, err)
 	}
 	err = rc.Close()
 	if err != nil {
-		t.Fatal("closing:", err)
+		t.Fatalf("closing %s: %v", f.Name, err)
 	}
 	if !bytes.Equal(b, wt.Data) {
 		t.Errorf("File contents %q, want %q", b, wt.Data)
-- 
GitLab


From ed5ebd32b3b8f66515522e8f09bc9dc023c0901c Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Mon, 26 Apr 2021 09:14:12 -0700
Subject: [PATCH 1935/2400] os: update some docs to reference fs.ErrFoo instead
 of os.ErrFoo

Change-Id: I8b771f407028406a6ec9a1f2500c806054961267
Reviewed-on: https://go-review.googlesource.com/c/go/+/313569
Trust: Brad Fitzpatrick <bradfitz@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/os/error.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/os/error.go b/src/os/error.go
index 704a6fb29e..fe8f2a8446 100644
--- a/src/os/error.go
+++ b/src/os/error.go
@@ -78,7 +78,7 @@ func NewSyscallError(syscall string, err error) error {
 // well as some syscall errors.
 //
 // This function predates errors.Is. It only supports errors returned by
-// the os package. New code should use errors.Is(err, os.ErrExist).
+// the os package. New code should use errors.Is(err, fs.ErrExist).
 func IsExist(err error) bool {
 	return underlyingErrorIs(err, ErrExist)
 }
@@ -88,7 +88,7 @@ func IsExist(err error) bool {
 // ErrNotExist as well as some syscall errors.
 //
 // This function predates errors.Is. It only supports errors returned by
-// the os package. New code should use errors.Is(err, os.ErrNotExist).
+// the os package. New code should use errors.Is(err, fs.ErrNotExist).
 func IsNotExist(err error) bool {
 	return underlyingErrorIs(err, ErrNotExist)
 }
@@ -98,7 +98,7 @@ func IsNotExist(err error) bool {
 // as some syscall errors.
 //
 // This function predates errors.Is. It only supports errors returned by
-// the os package. New code should use errors.Is(err, os.ErrPermission).
+// the os package. New code should use errors.Is(err, fs.ErrPermission).
 func IsPermission(err error) bool {
 	return underlyingErrorIs(err, ErrPermission)
 }
-- 
GitLab


From e8eb1d82690c5c70df770df41ca237e5756f21d5 Mon Sep 17 00:00:00 2001
From: Colin Arnott <colin@urandom.co.uk>
Date: Thu, 6 Aug 2020 02:57:15 +0000
Subject: [PATCH 1936/2400] math: add MaxUint, MinInt, MaxInt

Since we have int8 to int64 min max and uint8 to uint64 max constants,
we should probably have some for the word size types too. This change
also adds tests to validate the correctness of all integer limit
values.

Fixes #28538

Change-Id: Idd25782e98d16c2abedf39959b7b66e9c4c0c98b
Reviewed-on: https://go-review.googlesource.com/c/go/+/247058
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Robert Griesemer <gri@golang.org>
---
 src/math/const.go      |  5 +++++
 src/math/const_test.go | 47 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 52 insertions(+)
 create mode 100644 src/math/const_test.go

diff --git a/src/math/const.go b/src/math/const.go
index 31954b0cae..5ea935fb42 100644
--- a/src/math/const.go
+++ b/src/math/const.go
@@ -37,6 +37,10 @@ const (
 
 // Integer limit values.
 const (
+	intSize = 32 << (^uint(0) >> 63) // 32 or 64
+
+	MaxInt    = 1<<(intSize-1) - 1
+	MinInt    = -1 << (intSize - 1)
 	MaxInt8   = 1<<7 - 1
 	MinInt8   = -1 << 7
 	MaxInt16  = 1<<15 - 1
@@ -45,6 +49,7 @@ const (
 	MinInt32  = -1 << 31
 	MaxInt64  = 1<<63 - 1
 	MinInt64  = -1 << 63
+	MaxUint   = 1<<intSize - 1
 	MaxUint8  = 1<<8 - 1
 	MaxUint16 = 1<<16 - 1
 	MaxUint32 = 1<<32 - 1
diff --git a/src/math/const_test.go b/src/math/const_test.go
new file mode 100644
index 0000000000..170ba6aa09
--- /dev/null
+++ b/src/math/const_test.go
@@ -0,0 +1,47 @@
+// Copyright 2021 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 math_test
+
+import (
+	"testing"
+
+	. "math"
+)
+
+func TestMaxUint(t *testing.T) {
+	if v := uint(MaxUint); v+1 != 0 {
+		t.Errorf("MaxUint should wrap around to zero: %d", v+1)
+	}
+	if v := uint8(MaxUint8); v+1 != 0 {
+		t.Errorf("MaxUint8 should wrap around to zero: %d", v+1)
+	}
+	if v := uint16(MaxUint16); v+1 != 0 {
+		t.Errorf("MaxUint16 should wrap around to zero: %d", v+1)
+	}
+	if v := uint32(MaxUint32); v+1 != 0 {
+		t.Errorf("MaxUint32 should wrap around to zero: %d", v+1)
+	}
+	if v := uint64(MaxUint64); v+1 != 0 {
+		t.Errorf("MaxUint64 should wrap around to zero: %d", v+1)
+	}
+}
+
+func TestMaxInt(t *testing.T) {
+	if v := int(MaxInt); v+1 != MinInt {
+		t.Errorf("MaxInt should wrap around to MinInt: %d", v+1)
+	}
+	if v := int8(MaxInt8); v+1 != MinInt8 {
+		t.Errorf("MaxInt8 should wrap around to MinInt8: %d", v+1)
+	}
+	if v := int16(MaxInt16); v+1 != MinInt16 {
+		t.Errorf("MaxInt16 should wrap around to MinInt16: %d", v+1)
+	}
+	if v := int32(MaxInt32); v+1 != MinInt32 {
+		t.Errorf("MaxInt32 should wrap around to MinInt32: %d", v+1)
+	}
+	if v := int64(MaxInt64); v+1 != MinInt64 {
+		t.Errorf("MaxInt64 should wrap around to MinInt64: %d", v+1)
+	}
+}
-- 
GitLab


From 731a015ab8c8f44c7196123fd65b184a63d6835a Mon Sep 17 00:00:00 2001
From: Cherry Zhang <cherryyz@google.com>
Date: Mon, 3 May 2021 18:17:38 -0400
Subject: [PATCH 1937/2400] internal/syscall/unix: use internal/abi.FuncPC for
 syscall wrapper

Following CL 313230, this is for internal/syscall/unix package.

Updates #45702.

Change-Id: Ie6d8c1923dfeae56896212393c5c2a6e257648d2
Reviewed-on: https://go-review.googlesource.com/c/go/+/316649
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/internal/syscall/unix/getentropy_darwin.go | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/internal/syscall/unix/getentropy_darwin.go b/src/internal/syscall/unix/getentropy_darwin.go
index 6da6f84d95..e1a410a454 100644
--- a/src/internal/syscall/unix/getentropy_darwin.go
+++ b/src/internal/syscall/unix/getentropy_darwin.go
@@ -5,6 +5,7 @@
 package unix
 
 import (
+	"internal/abi"
 	"syscall"
 	"unsafe"
 )
@@ -15,7 +16,7 @@ func libc_getentropy_trampoline()
 
 // GetEntropy calls the macOS getentropy system call.
 func GetEntropy(p []byte) error {
-	_, _, errno := syscall_syscall(funcPC(libc_getentropy_trampoline),
+	_, _, errno := syscall_syscall(abi.FuncPCABI0(libc_getentropy_trampoline),
 		uintptr(unsafe.Pointer(&p[0])),
 		uintptr(len(p)),
 		0)
@@ -27,6 +28,3 @@ func GetEntropy(p []byte) error {
 
 //go:linkname syscall_syscall syscall.syscall
 func syscall_syscall(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno)
-
-//go:linkname funcPC runtime.funcPC
-func funcPC(f interface{}) uintptr
-- 
GitLab


From 496d7c691481966fd6ea806205aa025698a172af Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Mon, 3 May 2021 16:32:52 -0700
Subject: [PATCH 1938/2400] text/template: add lock for Template.tmpl to fix
 data race

This adds a new lock protecting "tmpl".

This is a copy of https://golang.org/cl/257817 by Andreas Fleig,
updated for current tip, and updated to start running the
html/template TestEscapeRace test.

Thanks to @bep for providing the test case.

Fixes #39807

Change-Id: Ic8874484290283a49116812eeaffb8608346dc70
Reviewed-on: https://go-review.googlesource.com/c/go/+/316669
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 src/html/template/exec_test.go |  2 --
 src/text/template/exec.go      |  9 ++++----
 src/text/template/exec_test.go | 38 ++++++++++++++++++++++++++++++++++
 src/text/template/template.go  |  9 ++++++++
 4 files changed, 51 insertions(+), 7 deletions(-)

diff --git a/src/html/template/exec_test.go b/src/html/template/exec_test.go
index 7d1bef1782..888587335d 100644
--- a/src/html/template/exec_test.go
+++ b/src/html/template/exec_test.go
@@ -1720,8 +1720,6 @@ var v = "v";
 `
 
 func TestEscapeRace(t *testing.T) {
-	t.Skip("this test currently fails with -race; see issue #39807")
-
 	tmpl := New("")
 	_, err := tmpl.New("templ.html").Parse(raceText)
 	if err != nil {
diff --git a/src/text/template/exec.go b/src/text/template/exec.go
index f1305a29a0..5ad3b4ec58 100644
--- a/src/text/template/exec.go
+++ b/src/text/template/exec.go
@@ -179,10 +179,7 @@ func errRecover(errp *error) {
 // A template may be executed safely in parallel, although if parallel
 // executions share a Writer the output may be interleaved.
 func (t *Template) ExecuteTemplate(wr io.Writer, name string, data interface{}) error {
-	var tmpl *Template
-	if t.common != nil {
-		tmpl = t.tmpl[name]
-	}
+	tmpl := t.Lookup(name)
 	if tmpl == nil {
 		return fmt.Errorf("template: no template %q associated with template %q", name, t.name)
 	}
@@ -230,6 +227,8 @@ func (t *Template) DefinedTemplates() string {
 		return ""
 	}
 	var b strings.Builder
+	t.muTmpl.RLock()
+	defer t.muTmpl.RUnlock()
 	for name, tmpl := range t.tmpl {
 		if tmpl.Tree == nil || tmpl.Root == nil {
 			continue
@@ -401,7 +400,7 @@ func (s *state) walkRange(dot reflect.Value, r *parse.RangeNode) {
 
 func (s *state) walkTemplate(dot reflect.Value, t *parse.TemplateNode) {
 	s.at(t)
-	tmpl := s.tmpl.tmpl[t.Name]
+	tmpl := s.tmpl.Lookup(t.Name)
 	if tmpl == nil {
 		s.errorf("template %q not defined", t.Name)
 	}
diff --git a/src/text/template/exec_test.go b/src/text/template/exec_test.go
index 255b111b34..e73fce4fa8 100644
--- a/src/text/template/exec_test.go
+++ b/src/text/template/exec_test.go
@@ -12,6 +12,7 @@ import (
 	"io"
 	"reflect"
 	"strings"
+	"sync"
 	"testing"
 )
 
@@ -1732,3 +1733,40 @@ func TestIssue43065(t *testing.T) {
 		t.Errorf("%s", err)
 	}
 }
+
+// Issue 39807: data race in html/template & text/template
+func TestIssue39807(t *testing.T) {
+	var wg sync.WaitGroup
+
+	tplFoo, err := New("foo").Parse(`{{ template "bar" . }}`)
+	if err != nil {
+		t.Error(err)
+	}
+
+	tplBar, err := New("bar").Parse("bar")
+	if err != nil {
+		t.Error(err)
+	}
+
+	gofuncs := 10
+	numTemplates := 10
+
+	for i := 1; i <= gofuncs; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < numTemplates; j++ {
+				_, err := tplFoo.AddParseTree(tplBar.Name(), tplBar.Tree)
+				if err != nil {
+					t.Error(err)
+				}
+				err = tplFoo.Execute(io.Discard, nil)
+				if err != nil {
+					t.Error(err)
+				}
+			}
+		}()
+	}
+
+	wg.Wait()
+}
diff --git a/src/text/template/template.go b/src/text/template/template.go
index ec26eb4c50..fd74d45e9b 100644
--- a/src/text/template/template.go
+++ b/src/text/template/template.go
@@ -13,6 +13,7 @@ import (
 // common holds the information shared by related templates.
 type common struct {
 	tmpl   map[string]*Template // Map from name to defined templates.
+	muTmpl sync.RWMutex         // protects tmpl
 	option option
 	// We use two maps, one for parsing and one for execution.
 	// This separation makes the API cleaner since it doesn't
@@ -88,6 +89,8 @@ func (t *Template) Clone() (*Template, error) {
 	if t.common == nil {
 		return nt, nil
 	}
+	t.muTmpl.RLock()
+	defer t.muTmpl.RUnlock()
 	for k, v := range t.tmpl {
 		if k == t.name {
 			nt.tmpl[t.name] = nt
@@ -124,6 +127,8 @@ func (t *Template) copy(c *common) *Template {
 // its definition. If it has been defined and already has that name, the existing
 // definition is replaced; otherwise a new template is created, defined, and returned.
 func (t *Template) AddParseTree(name string, tree *parse.Tree) (*Template, error) {
+	t.muTmpl.Lock()
+	defer t.muTmpl.Unlock()
 	t.init()
 	nt := t
 	if name != t.name {
@@ -142,6 +147,8 @@ func (t *Template) Templates() []*Template {
 		return nil
 	}
 	// Return a slice so we don't expose the map.
+	t.muTmpl.RLock()
+	defer t.muTmpl.RUnlock()
 	m := make([]*Template, 0, len(t.tmpl))
 	for _, v := range t.tmpl {
 		m = append(m, v)
@@ -182,6 +189,8 @@ func (t *Template) Lookup(name string) *Template {
 	if t.common == nil {
 		return nil
 	}
+	t.muTmpl.RLock()
+	defer t.muTmpl.RUnlock()
 	return t.tmpl[name]
 }
 
-- 
GitLab


From 2422c5eae5dc6539b4b7657ef7bfe58a65acb61d Mon Sep 17 00:00:00 2001
From: Colin Arnott <colin@urandom.co.uk>
Date: Thu, 9 Jul 2020 07:06:46 +0000
Subject: [PATCH 1939/2400] sync/atomic: add (*Value).Swap and
 (*Value).CompareAndSwap

The functions SwapPointer and CompareAndSwapPointer can be used to
interact with unsafe.Pointer, however generally it is prefered to work
with Value, due to its safer interface. As such, they have been added
along with glue logic to maintain invariants Value guarantees.

To meet these guarantees, the current implementation duplicates much of
the Store function. Some of this is due to inexperience with concurrency
and desire for correctness, but the lack of generic programming
functionality does not help.

Fixes #39351

Change-Id: I1aa394b1e70944736ac1e19de49fe861e1e46fba
Reviewed-on: https://go-review.googlesource.com/c/go/+/241678
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/sync/atomic/value.go      | 129 ++++++++++++++++++++++++++++---
 src/sync/atomic/value_test.go | 139 ++++++++++++++++++++++++++++++++++
 2 files changed, 257 insertions(+), 11 deletions(-)

diff --git a/src/sync/atomic/value.go b/src/sync/atomic/value.go
index eab7e70c9b..61f81d8fd3 100644
--- a/src/sync/atomic/value.go
+++ b/src/sync/atomic/value.go
@@ -25,7 +25,7 @@ type ifaceWords struct {
 
 // Load returns the value set by the most recent Store.
 // It returns nil if there has been no call to Store for this Value.
-func (v *Value) Load() (x interface{}) {
+func (v *Value) Load() (val interface{}) {
 	vp := (*ifaceWords)(unsafe.Pointer(v))
 	typ := LoadPointer(&vp.typ)
 	if typ == nil || uintptr(typ) == ^uintptr(0) {
@@ -33,21 +33,21 @@ func (v *Value) Load() (x interface{}) {
 		return nil
 	}
 	data := LoadPointer(&vp.data)
-	xp := (*ifaceWords)(unsafe.Pointer(&x))
-	xp.typ = typ
-	xp.data = data
+	vlp := (*ifaceWords)(unsafe.Pointer(&val))
+	vlp.typ = typ
+	vlp.data = data
 	return
 }
 
 // Store sets the value of the Value to x.
 // All calls to Store for a given Value must use values of the same concrete type.
 // Store of an inconsistent type panics, as does Store(nil).
-func (v *Value) Store(x interface{}) {
-	if x == nil {
+func (v *Value) Store(val interface{}) {
+	if val == nil {
 		panic("sync/atomic: store of nil value into Value")
 	}
 	vp := (*ifaceWords)(unsafe.Pointer(v))
-	xp := (*ifaceWords)(unsafe.Pointer(&x))
+	vlp := (*ifaceWords)(unsafe.Pointer(&val))
 	for {
 		typ := LoadPointer(&vp.typ)
 		if typ == nil {
@@ -61,8 +61,8 @@ func (v *Value) Store(x interface{}) {
 				continue
 			}
 			// Complete first store.
-			StorePointer(&vp.data, xp.data)
-			StorePointer(&vp.typ, xp.typ)
+			StorePointer(&vp.data, vlp.data)
+			StorePointer(&vp.typ, vlp.typ)
 			runtime_procUnpin()
 			return
 		}
@@ -73,14 +73,121 @@ func (v *Value) Store(x interface{}) {
 			continue
 		}
 		// First store completed. Check type and overwrite data.
-		if typ != xp.typ {
+		if typ != vlp.typ {
 			panic("sync/atomic: store of inconsistently typed value into Value")
 		}
-		StorePointer(&vp.data, xp.data)
+		StorePointer(&vp.data, vlp.data)
 		return
 	}
 }
 
+// Swap stores new into Value and returns the previous value. It returns nil if
+// the Value is empty.
+//
+// All calls to Swap for a given Value must use values of the same concrete
+// type. Swap of an inconsistent type panics, as does Swap(nil).
+func (v *Value) Swap(new interface{}) (old interface{}) {
+	if new == nil {
+		panic("sync/atomic: swap of nil value into Value")
+	}
+	vp := (*ifaceWords)(unsafe.Pointer(v))
+	np := (*ifaceWords)(unsafe.Pointer(&new))
+	for {
+		typ := LoadPointer(&vp.typ)
+		if typ == nil {
+			// Attempt to start first store.
+			// Disable preemption so that other goroutines can use
+			// active spin wait to wait for completion; and so that
+			// GC does not see the fake type accidentally.
+			runtime_procPin()
+			if !CompareAndSwapPointer(&vp.typ, nil, unsafe.Pointer(^uintptr(0))) {
+				runtime_procUnpin()
+				continue
+			}
+			// Complete first store.
+			StorePointer(&vp.data, np.data)
+			StorePointer(&vp.typ, np.typ)
+			runtime_procUnpin()
+			return nil
+		}
+		if uintptr(typ) == ^uintptr(0) {
+			// First store in progress. Wait.
+			// Since we disable preemption around the first store,
+			// we can wait with active spinning.
+			continue
+		}
+		// First store completed. Check type and overwrite data.
+		if typ != np.typ {
+			panic("sync/atomic: swap of inconsistently typed value into Value")
+		}
+		op := (*ifaceWords)(unsafe.Pointer(&old))
+		op.typ, op.data = np.typ, SwapPointer(&vp.data, np.data)
+		return old
+	}
+}
+
+// CompareAndSwapPointer executes the compare-and-swap operation for the Value.
+//
+// All calls to CompareAndSwap for a given Value must use values of the same
+// concrete type. CompareAndSwap of an inconsistent type panics, as does
+// CompareAndSwap(old, nil).
+func (v *Value) CompareAndSwap(old, new interface{}) (swapped bool) {
+	if new == nil {
+		panic("sync/atomic: compare and swap of nil value into Value")
+	}
+	vp := (*ifaceWords)(unsafe.Pointer(v))
+	np := (*ifaceWords)(unsafe.Pointer(&new))
+	op := (*ifaceWords)(unsafe.Pointer(&old))
+	if op.typ != nil && np.typ != op.typ {
+		panic("sync/atomic: compare and swap of inconsistently typed values")
+	}
+	for {
+		typ := LoadPointer(&vp.typ)
+		if typ == nil {
+			if old != nil {
+				return false
+			}
+			// Attempt to start first store.
+			// Disable preemption so that other goroutines can use
+			// active spin wait to wait for completion; and so that
+			// GC does not see the fake type accidentally.
+			runtime_procPin()
+			if !CompareAndSwapPointer(&vp.typ, nil, unsafe.Pointer(^uintptr(0))) {
+				runtime_procUnpin()
+				continue
+			}
+			// Complete first store.
+			StorePointer(&vp.data, np.data)
+			StorePointer(&vp.typ, np.typ)
+			runtime_procUnpin()
+			return true
+		}
+		if uintptr(typ) == ^uintptr(0) {
+			// First store in progress. Wait.
+			// Since we disable preemption around the first store,
+			// we can wait with active spinning.
+			continue
+		}
+		// First store completed. Check type and overwrite data.
+		if typ != np.typ {
+			panic("sync/atomic: compare and swap of inconsistently typed value into Value")
+		}
+		// Compare old and current via runtime equality check.
+		// This allows value types to be compared, something
+		// not offered by the package functions.
+		// CompareAndSwapPointer below only ensures vp.data
+		// has not changed since LoadPointer.
+		data := LoadPointer(&vp.data)
+		var i interface{}
+		(*ifaceWords)(unsafe.Pointer(&i)).typ = typ
+		(*ifaceWords)(unsafe.Pointer(&i)).data = data
+		if i != old {
+			return false
+		}
+		return CompareAndSwapPointer(&vp.data, data, np.data)
+	}
+}
+
 // Disable/enable preemption, implemented in runtime.
 func runtime_procPin()
 func runtime_procUnpin()
diff --git a/src/sync/atomic/value_test.go b/src/sync/atomic/value_test.go
index f289766340..a5e717d6e0 100644
--- a/src/sync/atomic/value_test.go
+++ b/src/sync/atomic/value_test.go
@@ -7,6 +7,9 @@ package atomic_test
 import (
 	"math/rand"
 	"runtime"
+	"strconv"
+	"sync"
+	"sync/atomic"
 	. "sync/atomic"
 	"testing"
 )
@@ -133,3 +136,139 @@ func BenchmarkValueRead(b *testing.B) {
 		}
 	})
 }
+
+var Value_SwapTests = []struct {
+	init interface{}
+	new  interface{}
+	want interface{}
+	err  interface{}
+}{
+	{init: nil, new: nil, err: "sync/atomic: swap of nil value into Value"},
+	{init: nil, new: true, want: nil, err: nil},
+	{init: true, new: "", err: "sync/atomic: swap of inconsistently typed value into Value"},
+	{init: true, new: false, want: true, err: nil},
+}
+
+func TestValue_Swap(t *testing.T) {
+	for i, tt := range Value_SwapTests {
+		t.Run(strconv.Itoa(i), func(t *testing.T) {
+			var v Value
+			if tt.init != nil {
+				v.Store(tt.init)
+			}
+			defer func() {
+				err := recover()
+				switch {
+				case tt.err == nil && err != nil:
+					t.Errorf("should not panic, got %v", err)
+				case tt.err != nil && err == nil:
+					t.Errorf("should panic %v, got <nil>", tt.err)
+				}
+			}()
+			if got := v.Swap(tt.new); got != tt.want {
+				t.Errorf("got %v, want %v", got, tt.want)
+			}
+			if got := v.Load(); got != tt.new {
+				t.Errorf("got %v, want %v", got, tt.new)
+			}
+		})
+	}
+}
+
+func TestValueSwapConcurrent(t *testing.T) {
+	var v Value
+	var count uint64
+	var g sync.WaitGroup
+	var m, n uint64 = 10000, 10000
+	if testing.Short() {
+		m = 1000
+		n = 1000
+	}
+	for i := uint64(0); i < m*n; i += n {
+		i := i
+		g.Add(1)
+		go func() {
+			var c uint64
+			for new := i; new < i+n; new++ {
+				if old := v.Swap(new); old != nil {
+					c += old.(uint64)
+				}
+			}
+			atomic.AddUint64(&count, c)
+			g.Done()
+		}()
+	}
+	g.Wait()
+	if want, got := (m*n-1)*(m*n)/2, count+v.Load().(uint64); got != want {
+		t.Errorf("sum from 0 to %d was %d, want %v", m*n-1, got, want)
+	}
+}
+
+var heapA, heapB = struct{ uint }{0}, struct{ uint }{0}
+
+var Value_CompareAndSwapTests = []struct {
+	init interface{}
+	new  interface{}
+	old  interface{}
+	want bool
+	err  interface{}
+}{
+	{init: nil, new: nil, old: nil, err: "sync/atomic: compare and swap of nil value into Value"},
+	{init: nil, new: true, old: "", err: "sync/atomic: compare and swap of inconsistently typed values into Value"},
+	{init: nil, new: true, old: true, want: false, err: nil},
+	{init: nil, new: true, old: nil, want: true, err: nil},
+	{init: true, new: "", err: "sync/atomic: compare and swap of inconsistently typed value into Value"},
+	{init: true, new: true, old: false, want: false, err: nil},
+	{init: true, new: true, old: true, want: true, err: nil},
+	{init: heapA, new: struct{ uint }{1}, old: heapB, want: true, err: nil},
+}
+
+func TestValue_CompareAndSwap(t *testing.T) {
+	for i, tt := range Value_CompareAndSwapTests {
+		t.Run(strconv.Itoa(i), func(t *testing.T) {
+			var v Value
+			if tt.init != nil {
+				v.Store(tt.init)
+			}
+			defer func() {
+				err := recover()
+				switch {
+				case tt.err == nil && err != nil:
+					t.Errorf("got %v, wanted no panic", err)
+				case tt.err != nil && err == nil:
+					t.Errorf("did not panic, want %v", tt.err)
+				}
+			}()
+			if got := v.CompareAndSwap(tt.old, tt.new); got != tt.want {
+				t.Errorf("got %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestValueCompareAndSwapConcurrent(t *testing.T) {
+	var v Value
+	var w sync.WaitGroup
+	v.Store(0)
+	m, n := 1000, 100
+	if testing.Short() {
+		m = 100
+		n = 100
+	}
+	for i := 0; i < m; i++ {
+		i := i
+		w.Add(1)
+		go func() {
+			for j := i; j < m*n; runtime.Gosched() {
+				if v.CompareAndSwap(j, j+1) {
+					j += m
+				}
+			}
+			w.Done()
+		}()
+	}
+	w.Wait()
+	if stop := v.Load().(int); stop != m*n {
+		t.Errorf("did not get to %v, stopped at %v", m*n, stop)
+	}
+}
-- 
GitLab


From e3769299cd3484e018e0e2a6e1b95c2b18ce4f41 Mon Sep 17 00:00:00 2001
From: Joe Tsai <joetsai@digital-static.net>
Date: Wed, 28 Apr 2021 17:39:46 -0700
Subject: [PATCH 1940/2400] strconv: add QuotedPrefix

QuotedPrefix is similar to Unquote, but returns the quoted string verbatim
and ignores any data after the quoted string.

Fixes #45033

Change-Id: I9f69fe9e3e45cbe9e63581cf1b457facb625045d
Reviewed-on: https://go-review.googlesource.com/c/go/+/314775
Trust: Joe Tsai <joetsai@digital-static.net>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/strconv/bytealg.go           |   6 +-
 src/strconv/bytealg_bootstrap.go |   8 +-
 src/strconv/quote.go             | 161 +++++++++++++++++++++----------
 src/strconv/quote_test.go        |  63 +++++++-----
 4 files changed, 153 insertions(+), 85 deletions(-)

diff --git a/src/strconv/bytealg.go b/src/strconv/bytealg.go
index 9780c28ef3..a2bb12c5f2 100644
--- a/src/strconv/bytealg.go
+++ b/src/strconv/bytealg.go
@@ -9,7 +9,7 @@ package strconv
 
 import "internal/bytealg"
 
-// contains reports whether the string contains the byte c.
-func contains(s string, c byte) bool {
-	return bytealg.IndexByteString(s, c) != -1
+// index returns the index of the first instance of c in s, or -1 if missing.
+func index(s string, c byte) int {
+	return bytealg.IndexByteString(s, c)
 }
diff --git a/src/strconv/bytealg_bootstrap.go b/src/strconv/bytealg_bootstrap.go
index 875a0eb147..0ed79f4de7 100644
--- a/src/strconv/bytealg_bootstrap.go
+++ b/src/strconv/bytealg_bootstrap.go
@@ -7,12 +7,12 @@
 
 package strconv
 
-// contains reports whether the string contains the byte c.
-func contains(s string, c byte) bool {
+// index returns the index of the first instance of c in s, or -1 if missing.
+func index(s string, c byte) int {
 	for i := 0; i < len(s); i++ {
 		if s[i] == c {
-			return true
+			return i
 		}
 	}
-	return false
+	return -1
 }
diff --git a/src/strconv/quote.go b/src/strconv/quote.go
index db0dbb288b..b3bbb1612b 100644
--- a/src/strconv/quote.go
+++ b/src/strconv/quote.go
@@ -15,6 +15,11 @@ const (
 	upperhex = "0123456789ABCDEF"
 )
 
+// contains reports whether the string contains the byte c.
+func contains(s string, c byte) bool {
+	return index(s, c) != -1
+}
+
 func quoteWith(s string, quote byte, ASCIIonly, graphicOnly bool) string {
 	return string(appendQuotedWith(make([]byte, 0, 3*len(s)/2), s, quote, ASCIIonly, graphicOnly))
 }
@@ -359,80 +364,132 @@ func UnquoteChar(s string, quote byte) (value rune, multibyte bool, tail string,
 	return
 }
 
+// QuotedPrefix returns the quoted string (as understood by Unquote) at the prefix of s.
+// If s does not start with a valid quoted string, QuotedPrefix returns an error.
+func QuotedPrefix(s string) (string, error) {
+	out, _, err := unquote(s, false)
+	return out, err
+}
+
 // Unquote interprets s as a single-quoted, double-quoted,
 // or backquoted Go string literal, returning the string value
 // that s quotes.  (If s is single-quoted, it would be a Go
 // character literal; Unquote returns the corresponding
 // one-character string.)
 func Unquote(s string) (string, error) {
-	n := len(s)
-	if n < 2 {
+	out, rem, err := unquote(s, true)
+	if len(rem) > 0 {
 		return "", ErrSyntax
 	}
-	quote := s[0]
-	if quote != s[n-1] {
-		return "", ErrSyntax
+	return out, err
+}
+
+// unquote parses a quoted string at the start of the input,
+// returning the parsed prefix, the remaining suffix, and any parse errors.
+// If unescape is true, the parsed prefix is unescaped,
+// otherwise the input prefix is provided verbatim.
+func unquote(in string, unescape bool) (out, rem string, err error) {
+	// Determine the quote form and optimistically find the terminating quote.
+	if len(in) < 2 {
+		return "", in, ErrSyntax
+	}
+	quote := in[0]
+	end := index(in[1:], quote)
+	if end < 0 {
+		return "", in, ErrSyntax
 	}
-	s = s[1 : n-1]
+	end += 2 // position after terminating quote; may be wrong if escape sequences are present
 
-	if quote == '`' {
-		if contains(s, '`') {
-			return "", ErrSyntax
+	switch quote {
+	case '`':
+		switch {
+		case !unescape:
+			out = in[:end] // include quotes
+		case !contains(in[:end], '\r'):
+			out = in[len("`") : end-len("`")] // exclude quotes
+		default:
+			// Carriage return characters ('\r') inside raw string literals
+			// are discarded from the raw string value.
+			buf := make([]byte, 0, end-len("`")-len("\r")-len("`"))
+			for i := len("`"); i < end-len("`"); i++ {
+				if in[i] != '\r' {
+					buf = append(buf, in[i])
+				}
+			}
+			out = string(buf)
 		}
-		if contains(s, '\r') {
-			// -1 because we know there is at least one \r to remove.
-			buf := make([]byte, 0, len(s)-1)
-			for i := 0; i < len(s); i++ {
-				if s[i] != '\r' {
-					buf = append(buf, s[i])
+		// NOTE: Prior implementations did not verify that raw strings consist
+		// of valid UTF-8 characters and we continue to not verify it as such.
+		// The Go specification does not explicitly require valid UTF-8,
+		// but only mention that it is implicitly valid for Go source code
+		// (which must be valid UTF-8).
+		return out, in[end:], nil
+	case '"', '\'':
+		// Handle quoted strings without any escape sequences.
+		if !contains(in[:end], '\\') && !contains(in[:end], '\n') {
+			var valid bool
+			switch quote {
+			case '"':
+				valid = utf8.ValidString(in[len(`"`) : end-len(`"`)])
+			case '\'':
+				r, n := utf8.DecodeRuneInString(in[len("'") : end-len("'")])
+				valid = len("'")+n+len("'") == end && (r != utf8.RuneError || n != 1)
+			}
+			if valid {
+				out = in[:end]
+				if unescape {
+					out = out[1 : end-1] // exclude quotes
 				}
+				return out, in[end:], nil
 			}
-			return string(buf), nil
 		}
-		return s, nil
-	}
-	if quote != '"' && quote != '\'' {
-		return "", ErrSyntax
-	}
-	if contains(s, '\n') {
-		return "", ErrSyntax
-	}
 
-	// Is it trivial? Avoid allocation.
-	if !contains(s, '\\') && !contains(s, quote) {
-		switch quote {
-		case '"':
-			if utf8.ValidString(s) {
-				return s, nil
+		// Handle quoted strings with escape sequences.
+		var buf []byte
+		in0 := in
+		in = in[1:] // skip starting quote
+		if unescape {
+			buf = make([]byte, 0, 3*end/2) // try to avoid more allocations
+		}
+		for len(in) > 0 && in[0] != quote {
+			// Process the next character,
+			// rejecting any unescaped newline characters which are invalid.
+			r, multibyte, rem, err := UnquoteChar(in, quote)
+			if in[0] == '\n' || err != nil {
+				return "", in0, ErrSyntax
 			}
-		case '\'':
-			r, size := utf8.DecodeRuneInString(s)
-			if size == len(s) && (r != utf8.RuneError || size != 1) {
-				return s, nil
+			in = rem
+
+			// Append the character if unescaping the input.
+			if unescape {
+				if r < utf8.RuneSelf || !multibyte {
+					buf = append(buf, byte(r))
+				} else {
+					var arr [utf8.UTFMax]byte
+					n := utf8.EncodeRune(arr[:], r)
+					buf = append(buf, arr[:n]...)
+				}
 			}
-		}
-	}
 
-	var runeTmp [utf8.UTFMax]byte
-	buf := make([]byte, 0, 3*len(s)/2) // Try to avoid more allocations.
-	for len(s) > 0 {
-		c, multibyte, ss, err := UnquoteChar(s, quote)
-		if err != nil {
-			return "", err
+			// Single quoted strings must be a single character.
+			if quote == '\'' {
+				break
+			}
 		}
-		s = ss
-		if c < utf8.RuneSelf || !multibyte {
-			buf = append(buf, byte(c))
-		} else {
-			n := utf8.EncodeRune(runeTmp[:], c)
-			buf = append(buf, runeTmp[:n]...)
+
+		// Verify that the string ends with a terminating quote.
+		if !(len(in) > 0 && in[0] == quote) {
+			return "", in0, ErrSyntax
 		}
-		if quote == '\'' && len(s) != 0 {
-			// single-quoted must be single character
-			return "", ErrSyntax
+		in = in[1:] // skip terminating quote
+
+		if unescape {
+			return string(buf), in, nil
 		}
+		return in0[:len(in0)-len(in)], in, nil
+	default:
+		return "", in, ErrSyntax
 	}
-	return string(buf), nil
 }
 
 // bsearch16 returns the smallest i such that a[i] >= x.
diff --git a/src/strconv/quote_test.go b/src/strconv/quote_test.go
index f1faf137bd..4750be2740 100644
--- a/src/strconv/quote_test.go
+++ b/src/strconv/quote_test.go
@@ -6,6 +6,7 @@ package strconv_test
 
 import (
 	. "strconv"
+	"strings"
 	"testing"
 	"unicode"
 )
@@ -297,6 +298,7 @@ var misquoted = []string{
 	`"\z"`,
 	"`",
 	"`xxx",
+	"``x\r",
 	"`\"",
 	`"\'"`,
 	`'\"'`,
@@ -307,22 +309,13 @@ var misquoted = []string{
 
 func TestUnquote(t *testing.T) {
 	for _, tt := range unquotetests {
-		if out, err := Unquote(tt.in); err != nil || out != tt.out {
-			t.Errorf("Unquote(%#q) = %q, %v want %q, nil", tt.in, out, err, tt.out)
-		}
+		testUnquote(t, tt.in, tt.out, nil)
 	}
-
-	// run the quote tests too, backward
 	for _, tt := range quotetests {
-		if in, err := Unquote(tt.out); in != tt.in {
-			t.Errorf("Unquote(%#q) = %q, %v, want %q, nil", tt.out, in, err, tt.in)
-		}
+		testUnquote(t, tt.out, tt.in, nil)
 	}
-
 	for _, s := range misquoted {
-		if out, err := Unquote(s); out != "" || err != ErrSyntax {
-			t.Errorf("Unquote(%#q) = %q, %v want %q, %v", s, out, err, "", ErrSyntax)
-		}
+		testUnquote(t, s, "", ErrSyntax)
 	}
 }
 
@@ -333,26 +326,44 @@ func TestUnquoteInvalidUTF8(t *testing.T) {
 
 		// one of:
 		want    string
-		wantErr string
+		wantErr error
 	}{
 		{in: `"foo"`, want: "foo"},
-		{in: `"foo`, wantErr: "invalid syntax"},
+		{in: `"foo`, wantErr: ErrSyntax},
 		{in: `"` + "\xc0" + `"`, want: "\xef\xbf\xbd"},
 		{in: `"a` + "\xc0" + `"`, want: "a\xef\xbf\xbd"},
 		{in: `"\t` + "\xc0" + `"`, want: "\t\xef\xbf\xbd"},
 	}
-	for i, tt := range tests {
-		got, err := Unquote(tt.in)
-		var gotErr string
-		if err != nil {
-			gotErr = err.Error()
-		}
-		if gotErr != tt.wantErr {
-			t.Errorf("%d. Unquote(%q) = err %v; want %q", i, tt.in, err, tt.wantErr)
-		}
-		if tt.wantErr == "" && err == nil && got != tt.want {
-			t.Errorf("%d. Unquote(%q) = %02x; want %02x", i, tt.in, []byte(got), []byte(tt.want))
-		}
+	for _, tt := range tests {
+		testUnquote(t, tt.in, tt.want, tt.wantErr)
+	}
+}
+
+func testUnquote(t *testing.T, in, want string, wantErr error) {
+	// Test Unquote.
+	got, gotErr := Unquote(in)
+	if got != want || gotErr != wantErr {
+		t.Errorf("Unquote(%q) = (%q, %v), want (%q, %v)", in, got, gotErr, want, wantErr)
+	}
+
+	// Test QuotedPrefix.
+	// Adding an arbitrary suffix should not change the result of QuotedPrefix
+	// assume that the suffix doesn't accidentally terminate a truncated input.
+	if gotErr == nil {
+		want = in
+	}
+	suffix := "\n\r\\\"`'" // special characters for quoted strings
+	if len(in) > 0 {
+		suffix = strings.ReplaceAll(suffix, in[:1], "")
+	}
+	in += suffix
+	got, gotErr = QuotedPrefix(in)
+	if gotErr == nil && wantErr != nil {
+		_, wantErr = Unquote(got) // original input had trailing junk, reparse with only valid prefix
+		want = got
+	}
+	if got != want || gotErr != wantErr {
+		t.Errorf("QuotedPrefix(%q) = (%q, %v), want (%q, %v)", in, got, gotErr, want, wantErr)
 	}
 }
 
-- 
GitLab


From 138d2c9b88d9e3d5adcebf9cb7c356b43d6a9782 Mon Sep 17 00:00:00 2001
From: EndlessCheng <loli.con@qq.com>
Date: Tue, 4 May 2021 01:00:37 +0000
Subject: [PATCH 1941/2400] strconv: fix a typo

Change-Id: I17911dc95fb2126b41dc95f8839c4b3fa8f35d12
GitHub-Last-Rev: 88e120329301bd73db39e1081737a83f49a5672b
GitHub-Pull-Request: golang/go#45933
Reviewed-on: https://go-review.googlesource.com/c/go/+/316689
Reviewed-by: Robert Griesemer <gri@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/strconv/atoi.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/strconv/atoi.go b/src/strconv/atoi.go
index f6c4efaef6..c9ba0383b3 100644
--- a/src/strconv/atoi.go
+++ b/src/strconv/atoi.go
@@ -143,7 +143,7 @@ func ParseUint(s string, base int, bitSize int) (uint64, error) {
 
 		n1 := n + uint64(d)
 		if n1 < n || n1 > maxVal {
-			// n+v overflows
+			// n+d overflows
 			return maxVal, rangeError(fnParseUint, s0)
 		}
 		n = n1
-- 
GitLab


From 45600bcd614f5855060b18b189f7e126fedfe637 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Sun, 2 May 2021 13:22:48 +0200
Subject: [PATCH 1942/2400] os, syscall: use wait6 to avoid wait/kill race on
 netbsd

Follow CL 23967 and CL 24021 which did the same on linux and freebsd,
respectively.

Updates #13987
Updates #16028

Change-Id: I95b13d8ddde4cea1ef4fb7d655f1ad1a219d13aa
Reviewed-on: https://go-review.googlesource.com/c/go/+/315281
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/os/wait_unimp.go                | 4 ++--
 src/os/wait_wait6.go                | 4 ++--
 src/syscall/zerrors_netbsd_386.go   | 1 +
 src/syscall/zerrors_netbsd_amd64.go | 1 +
 src/syscall/zerrors_netbsd_arm.go   | 1 +
 src/syscall/zerrors_netbsd_arm64.go | 1 +
 src/syscall/zsysnum_netbsd_386.go   | 1 +
 src/syscall/zsysnum_netbsd_amd64.go | 1 +
 src/syscall/zsysnum_netbsd_arm.go   | 1 +
 src/syscall/zsysnum_netbsd_arm64.go | 1 +
 10 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/src/os/wait_unimp.go b/src/os/wait_unimp.go
index 07b5b6b66b..9bb85da802 100644
--- a/src/os/wait_unimp.go
+++ b/src/os/wait_unimp.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build aix || darwin || (js && wasm) || netbsd || openbsd || solaris
-// +build aix darwin js,wasm netbsd openbsd solaris
+//go:build aix || darwin || (js && wasm) || openbsd || solaris
+// +build aix darwin js,wasm openbsd solaris
 
 package os
 
diff --git a/src/os/wait_wait6.go b/src/os/wait_wait6.go
index 51193401f9..45b370a802 100644
--- a/src/os/wait_wait6.go
+++ b/src/os/wait_wait6.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build dragonfly || freebsd
-// +build dragonfly freebsd
+//go:build dragonfly || freebsd || netbsd
+// +build dragonfly freebsd netbsd
 
 package os
 
diff --git a/src/syscall/zerrors_netbsd_386.go b/src/syscall/zerrors_netbsd_386.go
index 6a58946a4a..934e9ef073 100644
--- a/src/syscall/zerrors_netbsd_386.go
+++ b/src/syscall/zerrors_netbsd_386.go
@@ -1427,6 +1427,7 @@ const (
 	WALTSIG                           = 0x4
 	WCLONE                            = 0x4
 	WCOREFLAG                         = 0x80
+	WEXITED                           = 0x20
 	WNOHANG                           = 0x1
 	WNOWAIT                           = 0x10000
 	WNOZOMBIE                         = 0x20000
diff --git a/src/syscall/zerrors_netbsd_amd64.go b/src/syscall/zerrors_netbsd_amd64.go
index f5c5c2f49c..0f5ad61a9f 100644
--- a/src/syscall/zerrors_netbsd_amd64.go
+++ b/src/syscall/zerrors_netbsd_amd64.go
@@ -1417,6 +1417,7 @@ const (
 	WALTSIG                           = 0x4
 	WCLONE                            = 0x4
 	WCOREFLAG                         = 0x80
+	WEXITED                           = 0x20
 	WNOHANG                           = 0x1
 	WNOWAIT                           = 0x10000
 	WNOZOMBIE                         = 0x20000
diff --git a/src/syscall/zerrors_netbsd_arm.go b/src/syscall/zerrors_netbsd_arm.go
index c9d4579b41..9d8678750d 100644
--- a/src/syscall/zerrors_netbsd_arm.go
+++ b/src/syscall/zerrors_netbsd_arm.go
@@ -1403,6 +1403,7 @@ const (
 	WALTSIG                           = 0x4
 	WCLONE                            = 0x4
 	WCOREFLAG                         = 0x80
+	WEXITED                           = 0x20
 	WNOHANG                           = 0x1
 	WNOWAIT                           = 0x10000
 	WNOZOMBIE                         = 0x20000
diff --git a/src/syscall/zerrors_netbsd_arm64.go b/src/syscall/zerrors_netbsd_arm64.go
index e35bff7f3e..7adb72f7ed 100644
--- a/src/syscall/zerrors_netbsd_arm64.go
+++ b/src/syscall/zerrors_netbsd_arm64.go
@@ -1417,6 +1417,7 @@ const (
 	WALTSIG                           = 0x4
 	WCLONE                            = 0x4
 	WCOREFLAG                         = 0x80
+	WEXITED                           = 0x20
 	WNOHANG                           = 0x1
 	WNOWAIT                           = 0x10000
 	WNOZOMBIE                         = 0x20000
diff --git a/src/syscall/zsysnum_netbsd_386.go b/src/syscall/zsysnum_netbsd_386.go
index 4ff8d80341..fd0c329951 100644
--- a/src/syscall/zsysnum_netbsd_386.go
+++ b/src/syscall/zsysnum_netbsd_386.go
@@ -271,4 +271,5 @@ const (
 	SYS_POSIX_SPAWN          = 474 // { int|sys||posix_spawn(pid_t *pid, const char *path, const struct posix_spawn_file_actions *file_actions, const struct posix_spawnattr *attrp, char *const *argv, char *const *envp); }
 	SYS_RECVMMSG             = 475 // { int|sys||recvmmsg(int s, struct mmsghdr *mmsg, unsigned int vlen, unsigned int flags, struct timespec *timeout); }
 	SYS_SENDMMSG             = 476 // { int|sys||sendmmsg(int s, struct mmsghdr *mmsg, unsigned int vlen, unsigned int flags); }
+	SYS_WAIT6                = 481 // { int|sys||wait6(idtype_t idtype, id_t id, int *status, int options, struct wrusage *wru, siginfo_t *info); }
 )
diff --git a/src/syscall/zsysnum_netbsd_amd64.go b/src/syscall/zsysnum_netbsd_amd64.go
index 929da07604..03f2cd3bd3 100644
--- a/src/syscall/zsysnum_netbsd_amd64.go
+++ b/src/syscall/zsysnum_netbsd_amd64.go
@@ -271,4 +271,5 @@ const (
 	SYS_POSIX_SPAWN          = 474 // { int|sys||posix_spawn(pid_t *pid, const char *path, const struct posix_spawn_file_actions *file_actions, const struct posix_spawnattr *attrp, char *const *argv, char *const *envp); }
 	SYS_RECVMMSG             = 475 // { int|sys||recvmmsg(int s, struct mmsghdr *mmsg, unsigned int vlen, unsigned int flags, struct timespec *timeout); }
 	SYS_SENDMMSG             = 476 // { int|sys||sendmmsg(int s, struct mmsghdr *mmsg, unsigned int vlen, unsigned int flags); }
+	SYS_WAIT6                = 481 // { int|sys||wait6(idtype_t idtype, id_t id, int *status, int options, struct wrusage *wru, siginfo_t *info); }
 )
diff --git a/src/syscall/zsysnum_netbsd_arm.go b/src/syscall/zsysnum_netbsd_arm.go
index 998238518b..7b356e7102 100644
--- a/src/syscall/zsysnum_netbsd_arm.go
+++ b/src/syscall/zsysnum_netbsd_arm.go
@@ -271,4 +271,5 @@ const (
 	SYS_POSIX_SPAWN          = 474 // { int|sys||posix_spawn(pid_t *pid, const char *path, const struct posix_spawn_file_actions *file_actions, const struct posix_spawnattr *attrp, char *const *argv, char *const *envp); }
 	SYS_RECVMMSG             = 475 // { int|sys||recvmmsg(int s, struct mmsghdr *mmsg, unsigned int vlen, unsigned int flags, struct timespec *timeout); }
 	SYS_SENDMMSG             = 476 // { int|sys||sendmmsg(int s, struct mmsghdr *mmsg, unsigned int vlen, unsigned int flags); }
+	SYS_WAIT6                = 481 // { int|sys||wait6(idtype_t idtype, id_t id, int *status, int options, struct wrusage *wru, siginfo_t *info); }
 )
diff --git a/src/syscall/zsysnum_netbsd_arm64.go b/src/syscall/zsysnum_netbsd_arm64.go
index b3f5034390..3f57ec4d89 100644
--- a/src/syscall/zsysnum_netbsd_arm64.go
+++ b/src/syscall/zsysnum_netbsd_arm64.go
@@ -271,4 +271,5 @@ const (
 	SYS_POSIX_SPAWN          = 474 // { int|sys||posix_spawn(pid_t *pid, const char *path, const struct posix_spawn_file_actions *file_actions, const struct posix_spawnattr *attrp, char *const *argv, char *const *envp); }
 	SYS_RECVMMSG             = 475 // { int|sys||recvmmsg(int s, struct mmsghdr *mmsg, unsigned int vlen, unsigned int flags, struct timespec *timeout); }
 	SYS_SENDMMSG             = 476 // { int|sys||sendmmsg(int s, struct mmsghdr *mmsg, unsigned int vlen, unsigned int flags); }
+	SYS_WAIT6                = 481 // { int|sys||wait6(idtype_t idtype, id_t id, int *status, int options, struct wrusage *wru, siginfo_t *info); }
 )
-- 
GitLab


From 830e63a7a330577bfb51404f38beb1b47ceae6b6 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Sat, 1 May 2021 15:36:34 +0200
Subject: [PATCH 1943/2400] syscall: add //go:build lines to assembly files

Change-Id: Ie296af523d70def269f9fb2ae35dfd2893abb2d9
Reviewed-on: https://go-review.googlesource.com/c/go/+/315275
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/syscall/asm9_unix1_amd64.s  | 5 +++--
 src/syscall/asm9_unix2_amd64.s  | 5 +++--
 src/syscall/asm_linux_mips64x.s | 1 +
 src/syscall/asm_linux_mipsx.s   | 1 +
 src/syscall/asm_linux_ppc64x.s  | 1 +
 src/syscall/asm_unix_386.s      | 5 +++--
 src/syscall/asm_unix_amd64.s    | 5 +++--
 7 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/src/syscall/asm9_unix1_amd64.s b/src/syscall/asm9_unix1_amd64.s
index f2ae87d623..e4609d075c 100644
--- a/src/syscall/asm9_unix1_amd64.s
+++ b/src/syscall/asm9_unix1_amd64.s
@@ -1,9 +1,10 @@
-// +build netbsd
-
 // Copyright 2016 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.
 
+//go:build netbsd
+// +build netbsd
+
 #include "textflag.h"
 #include "funcdata.h"
 
diff --git a/src/syscall/asm9_unix2_amd64.s b/src/syscall/asm9_unix2_amd64.s
index 6633c12529..7e5e3c52ad 100644
--- a/src/syscall/asm9_unix2_amd64.s
+++ b/src/syscall/asm9_unix2_amd64.s
@@ -1,9 +1,10 @@
-// +build dragonfly freebsd
-
 // Copyright 2016 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.
 
+//go:build dragonfly || freebsd
+// +build dragonfly freebsd
+
 #include "textflag.h"
 #include "funcdata.h"
 
diff --git a/src/syscall/asm_linux_mips64x.s b/src/syscall/asm_linux_mips64x.s
index b3ae59023d..d18a7b8944 100644
--- a/src/syscall/asm_linux_mips64x.s
+++ b/src/syscall/asm_linux_mips64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (mips64 || mips64le)
 // +build linux
 // +build mips64 mips64le
 
diff --git a/src/syscall/asm_linux_mipsx.s b/src/syscall/asm_linux_mipsx.s
index ee436490b2..cafa6a35c7 100644
--- a/src/syscall/asm_linux_mipsx.s
+++ b/src/syscall/asm_linux_mipsx.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (mips || mipsle)
 // +build linux
 // +build mips mipsle
 
diff --git a/src/syscall/asm_linux_ppc64x.s b/src/syscall/asm_linux_ppc64x.s
index 8be0d68d70..eac7272f1d 100644
--- a/src/syscall/asm_linux_ppc64x.s
+++ b/src/syscall/asm_linux_ppc64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (ppc64 || ppc64le)
 // +build linux
 // +build ppc64 ppc64le
 
diff --git a/src/syscall/asm_unix_386.s b/src/syscall/asm_unix_386.s
index f262cd3adb..9f9b7f362d 100644
--- a/src/syscall/asm_unix_386.s
+++ b/src/syscall/asm_unix_386.s
@@ -1,9 +1,10 @@
-// +build netbsd freebsd
-
 // Copyright 2009 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.
 
+//go:build freebsd || netbsd
+// +build freebsd netbsd
+
 #include "textflag.h"
 #include "funcdata.h"
 
diff --git a/src/syscall/asm_unix_amd64.s b/src/syscall/asm_unix_amd64.s
index aa03eb96a0..c53e1a42b6 100644
--- a/src/syscall/asm_unix_amd64.s
+++ b/src/syscall/asm_unix_amd64.s
@@ -1,9 +1,10 @@
-// +build netbsd freebsd dragonfly
-
 // Copyright 2009 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.
 
+//go:build dragonfly || freebsd || netbsd
+// +build dragonfly freebsd netbsd
+
 #include "textflag.h"
 #include "funcdata.h"
 
-- 
GitLab


From 0921211403731b5a8a38e2d2c647c288240e5b29 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Mon, 19 Apr 2021 23:00:24 -0400
Subject: [PATCH 1944/2400] cmd/compile: preserve/translate names for
 parameters

This is part of getting debugging into good shape
with the register ABI.  (This may generate a backport
for 1.16, there was some regression there as well.)

This is not necessarily fully-baked yet; my goal is to
make it work "well enough" for actual debugging, then
revisit the metrics, which are currently ignorant
of registers used for passing parameters (currently,
rejects them as a valid option).

Updates #40724.

Change-Id: Ib649adf39f947b7b54895c5bf181cf48ca4d38a0
Reviewed-on: https://go-review.googlesource.com/c/go/+/311689
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/expand_calls.go | 153 +++++++++++++++----
 1 file changed, 126 insertions(+), 27 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index 133959204a..39d0b61c2e 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -575,6 +575,77 @@ func (x *expandState) rewriteDereference(b *Block, base, a, mem *Value, offset,
 	return mem
 }
 
+var indexNames [1]string = [1]string{"[0]"}
+
+// pathTo returns the selection path to the leaf type at offset within container.
+// e.g. len(thing.field[0]) => ".field[0].len"
+// this is for purposes of generating names ultimately fed to a debugger.
+func (x *expandState) pathTo(container, leaf *types.Type, offset int64) string {
+	if container == leaf || offset == 0 && container.Size() == leaf.Size() {
+		return ""
+	}
+	path := ""
+outer:
+	for {
+		switch container.Kind() {
+		case types.TARRAY:
+			container = container.Elem()
+			if container.Size() == 0 {
+				return path
+			}
+			i := offset / container.Size()
+			offset = offset % container.Size()
+			// If a future compiler/ABI supports larger SSA/Arg-able arrays, expand indexNames.
+			path = path + indexNames[i]
+			continue
+		case types.TSTRUCT:
+			for i := 0; i < container.NumFields(); i++ {
+				fld := container.Field(i)
+				if fld.Offset+fld.Type.Size() > offset {
+					offset -= fld.Offset
+					path += "." + fld.Sym.Name
+					container = fld.Type
+					continue outer
+				}
+			}
+			return path
+		case types.TINT64, types.TUINT64:
+			if container.Width == x.regSize {
+				return path
+			}
+			if offset == x.hiOffset {
+				return path + ".hi"
+			}
+			return path + ".lo"
+		case types.TINTER:
+			if offset != 0 {
+				return path + ".data"
+			}
+			if container.IsEmptyInterface() {
+				return path + ".type"
+			}
+			return path + ".itab"
+
+		case types.TSLICE:
+			if offset == 2*x.regSize {
+				return path + ".cap"
+			}
+			fallthrough
+		case types.TSTRING:
+			if offset == 0 {
+				return path + ".ptr"
+			}
+			return path + ".len"
+		case types.TCOMPLEX64, types.TCOMPLEX128:
+			if offset == 0 {
+				return path + ".real"
+			}
+			return path + ".imag"
+		}
+		return path
+	}
+}
+
 // decomposeArg is a helper for storeArgOrLoad.
 // It decomposes a Load or an Arg into smaller parts and returns the new mem.
 // If the type does not match one of the expected aggregate types, it returns nil instead.
@@ -591,6 +662,11 @@ func (x *expandState) rewriteDereference(b *Block, base, a, mem *Value, offset,
 func (x *expandState) decomposeArg(pos src.XPos, b *Block, source, mem *Value, t *types.Type, storeOffset int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
 
 	pa := x.prAssignForArg(source)
+	var locs []LocalSlot
+	for _, s := range x.namedSelects[source] {
+		locs = append(locs, x.f.Names[s.locIndex])
+	}
+
 	if len(pa.Registers) > 0 {
 		// Handle the in-registers case directly
 		rts, offs := pa.RegisterTypesAndOffsets()
@@ -604,12 +680,21 @@ func (x *expandState) decomposeArg(pos src.XPos, b *Block, source, mem *Value, t
 			}
 			panic(fmt.Errorf("offset %d of requested register %d should be zero, source=%s", offs[loadRegOffset], loadRegOffset, source.LongString()))
 		}
+
+		if x.debug {
+			x.Printf("decompose arg %s has %d locs\n", source.LongString(), len(locs))
+		}
+
 		for i := loadRegOffset; i < last; i++ {
 			rt := rts[i]
 			off := offs[i]
 			w := x.commonArgs[selKey{source, off, rt.Width, rt}]
 			if w == nil {
 				w = x.newArgToMemOrRegs(source, w, off, i, rt, pos)
+				suffix := x.pathTo(source.Type, rt, off)
+				if suffix != "" {
+					x.splitSlotsIntoNames(locs, suffix, off, rt, w)
+				}
 			}
 			if t.IsPtrShaped() {
 				// Preserve the original store type. This ensures pointer type
@@ -631,7 +716,7 @@ func (x *expandState) decomposeArg(pos src.XPos, b *Block, source, mem *Value, t
 		elemRO := x.regWidth(elem)
 		for i := int64(0); i < u.NumElem(); i++ {
 			elemOff := i * elem.Size()
-			mem = storeOneArg(x, pos, b, source, mem, elem, elemOff, storeOffset+elemOff, loadRegOffset, storeRc.next(elem))
+			mem = storeOneArg(x, pos, b, locs, indexNames[i], source, mem, elem, elemOff, storeOffset+elemOff, loadRegOffset, storeRc.next(elem))
 			loadRegOffset += elemRO
 			pos = pos.WithNotStmt()
 		}
@@ -639,7 +724,7 @@ func (x *expandState) decomposeArg(pos src.XPos, b *Block, source, mem *Value, t
 	case types.TSTRUCT:
 		for i := 0; i < u.NumFields(); i++ {
 			fld := u.Field(i)
-			mem = storeOneArg(x, pos, b, source, mem, fld.Type, fld.Offset, storeOffset+fld.Offset, loadRegOffset, storeRc.next(fld.Type))
+			mem = storeOneArg(x, pos, b, locs, "."+fld.Sym.Name, source, mem, fld.Type, fld.Offset, storeOffset+fld.Offset, loadRegOffset, storeRc.next(fld.Type))
 			loadRegOffset += x.regWidth(fld.Type)
 			pos = pos.WithNotStmt()
 		}
@@ -649,24 +734,36 @@ func (x *expandState) decomposeArg(pos src.XPos, b *Block, source, mem *Value, t
 			break
 		}
 		tHi, tLo := x.intPairTypes(t.Kind())
-		mem = storeOneArg(x, pos, b, source, mem, tHi, x.hiOffset, storeOffset+x.hiOffset, loadRegOffset+x.hiRo, storeRc.plus(x.hiRo))
+		mem = storeOneArg(x, pos, b, locs, ".hi", source, mem, tHi, x.hiOffset, storeOffset+x.hiOffset, loadRegOffset+x.hiRo, storeRc.plus(x.hiRo))
 		pos = pos.WithNotStmt()
-		return storeOneArg(x, pos, b, source, mem, tLo, x.lowOffset, storeOffset+x.lowOffset, loadRegOffset+x.loRo, storeRc.plus(x.loRo))
+		return storeOneArg(x, pos, b, locs, ".lo", source, mem, tLo, x.lowOffset, storeOffset+x.lowOffset, loadRegOffset+x.loRo, storeRc.plus(x.loRo))
 	case types.TINTER:
-		return storeTwoArg(x, pos, b, source, mem, x.typs.Uintptr, x.typs.BytePtr, 0, storeOffset, loadRegOffset, storeRc)
+		sfx := ".itab"
+		if u.IsEmptyInterface() {
+			sfx = ".type"
+		}
+		return storeTwoArg(x, pos, b, locs, sfx, ".idata", source, mem, x.typs.Uintptr, x.typs.BytePtr, 0, storeOffset, loadRegOffset, storeRc)
 	case types.TSTRING:
-		return storeTwoArg(x, pos, b, source, mem, x.typs.BytePtr, x.typs.Int, 0, storeOffset, loadRegOffset, storeRc)
+		return storeTwoArg(x, pos, b, locs, ".ptr", ".len", source, mem, x.typs.BytePtr, x.typs.Int, 0, storeOffset, loadRegOffset, storeRc)
 	case types.TCOMPLEX64:
-		return storeTwoArg(x, pos, b, source, mem, x.typs.Float32, x.typs.Float32, 0, storeOffset, loadRegOffset, storeRc)
+		return storeTwoArg(x, pos, b, locs, ".real", ".imag", source, mem, x.typs.Float32, x.typs.Float32, 0, storeOffset, loadRegOffset, storeRc)
 	case types.TCOMPLEX128:
-		return storeTwoArg(x, pos, b, source, mem, x.typs.Float64, x.typs.Float64, 0, storeOffset, loadRegOffset, storeRc)
+		return storeTwoArg(x, pos, b, locs, ".real", ".imag", source, mem, x.typs.Float64, x.typs.Float64, 0, storeOffset, loadRegOffset, storeRc)
 	case types.TSLICE:
-		mem = storeOneArg(x, pos, b, source, mem, x.typs.BytePtr, 0, storeOffset, loadRegOffset, storeRc.next(x.typs.BytePtr))
-		return storeTwoArg(x, pos, b, source, mem, x.typs.Int, x.typs.Int, x.ptrSize, storeOffset+x.ptrSize, loadRegOffset+RO_slice_len, storeRc)
+		mem = storeOneArg(x, pos, b, locs, ".ptr", source, mem, x.typs.BytePtr, 0, storeOffset, loadRegOffset, storeRc.next(x.typs.BytePtr))
+		return storeTwoArg(x, pos, b, locs, ".len", ".cap", source, mem, x.typs.Int, x.typs.Int, x.ptrSize, storeOffset+x.ptrSize, loadRegOffset+RO_slice_len, storeRc)
 	}
 	return nil
 }
 
+func (x *expandState) splitSlotsIntoNames(locs []LocalSlot, suffix string, off int64, rt *types.Type, w *Value) {
+	wlocs := x.splitSlots(locs, suffix, off, rt)
+	for _, l := range wlocs {
+		x.f.NamedValues[l] = append(x.f.NamedValues[l], w)
+	}
+	x.f.Names = append(x.f.Names, wlocs...)
+}
+
 // decomposeLoad is a helper for storeArgOrLoad.
 // It decomposes a Load  into smaller parts and returns the new mem.
 // If the type does not match one of the expected aggregate types, it returns nil instead.
@@ -729,7 +826,7 @@ func (x *expandState) decomposeLoad(pos src.XPos, b *Block, source, mem *Value,
 // storeOneArg creates a decomposed (one step) arg that is then stored.
 // pos and b locate the store instruction, source is the "base" of the value input,
 // mem is the input mem, t is the type in question, and offArg and offStore are the offsets from the respective bases.
-func storeOneArg(x *expandState, pos src.XPos, b *Block, source, mem *Value, t *types.Type, argOffset, storeOffset int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
+func storeOneArg(x *expandState, pos src.XPos, b *Block, locs []LocalSlot, suffix string, source, mem *Value, t *types.Type, argOffset, storeOffset int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
 	if x.debug {
 		x.indent(3)
 		defer x.indent(-3)
@@ -739,6 +836,7 @@ func storeOneArg(x *expandState, pos src.XPos, b *Block, source, mem *Value, t *
 	w := x.commonArgs[selKey{source, argOffset, t.Width, t}]
 	if w == nil {
 		w = x.newArgToMemOrRegs(source, w, argOffset, loadRegOffset, t, pos)
+		x.splitSlotsIntoNames(locs, suffix, argOffset, t, w)
 	}
 	return x.storeArgOrLoad(pos, b, w, mem, t, storeOffset, loadRegOffset, storeRc)
 }
@@ -750,11 +848,11 @@ func storeOneLoad(x *expandState, pos src.XPos, b *Block, source, mem *Value, t
 	return x.storeArgOrLoad(pos, b, w, mem, t, offStore, loadRegOffset, storeRc)
 }
 
-func storeTwoArg(x *expandState, pos src.XPos, b *Block, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
-	mem = storeOneArg(x, pos, b, source, mem, t1, offArg, offStore, loadRegOffset, storeRc.next(t1))
+func storeTwoArg(x *expandState, pos src.XPos, b *Block, locs []LocalSlot, suffix1 string, suffix2 string, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
+	mem = storeOneArg(x, pos, b, locs, suffix1, source, mem, t1, offArg, offStore, loadRegOffset, storeRc.next(t1))
 	pos = pos.WithNotStmt()
 	t1Size := t1.Size()
-	return storeOneArg(x, pos, b, source, mem, t2, offArg+t1Size, offStore+t1Size, loadRegOffset+1, storeRc)
+	return storeOneArg(x, pos, b, locs, suffix2, source, mem, t2, offArg+t1Size, offStore+t1Size, loadRegOffset+1, storeRc)
 }
 
 // storeTwoLoad creates a pair of decomposed (one step) loads that are then stored.
@@ -1067,6 +1165,18 @@ func expandCalls(f *Func) {
 		x.Printf("\nexpandsCalls(%s)\n", f.Name)
 	}
 
+	for i, name := range f.Names {
+		t := name.Type
+		if x.isAlreadyExpandedAggregateType(t) {
+			for j, v := range f.NamedValues[name] {
+				if v.Op == OpSelectN || v.Op == OpArg && x.isAlreadyExpandedAggregateType(v.Type) {
+					ns := x.namedSelects[v]
+					x.namedSelects[v] = append(ns, namedVal{locIndex: i, valIndex: j})
+				}
+			}
+		}
+	}
+
 	// TODO if too slow, whole program iteration can be replaced w/ slices of appropriate values, accumulated in first loop here.
 
 	// Step 0: rewrite the calls to convert args to calls into stores/register movement.
@@ -1151,18 +1261,6 @@ func expandCalls(f *Func) {
 		}
 	}
 
-	for i, name := range f.Names {
-		t := name.Type
-		if x.isAlreadyExpandedAggregateType(t) {
-			for j, v := range f.NamedValues[name] {
-				if v.Op == OpSelectN || v.Op == OpArg && x.isAlreadyExpandedAggregateType(v.Type) {
-					ns := x.namedSelects[v]
-					x.namedSelects[v] = append(ns, namedVal{locIndex: i, valIndex: j})
-				}
-			}
-		}
-	}
-
 	// Step 1: any stores of aggregates remaining are believed to be sourced from call results or args.
 	// Decompose those stores into a series of smaller stores, adding selection ops as necessary.
 	for _, b := range f.Blocks {
@@ -1386,8 +1484,9 @@ func expandCalls(f *Func) {
 			}
 			continue
 		}
-		// Not-leaf types that had debug locations need to lose them.
 		if ns, ok := x.namedSelects[v]; ok {
+			// Not-leaf types that had debug locations need to lose them.
+
 			toDelete = append(toDelete, ns...)
 		}
 	}
-- 
GitLab


From 5e4f9b077f27c79a69677b7c15dbfd157b1698a4 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Mon, 3 May 2021 08:55:57 -0700
Subject: [PATCH 1945/2400] cmd/compile: when compiling with -N, avoid entry
 block

Lots of constant SSA values we put in the entry block so that
CSE can easily combine them. With -N, however, we don't run CSE, so
putting values in the entry block only serves to extend their lifetime
for no benefit.

Fixes #45897. The number of live SSA values per block goes from >5K to 22.
Memory use goes from ~3GB to ~400MB.

Change-Id: I620b423611790a900e0d4cd270eac5dbdddf2a2b
Reviewed-on: https://go-review.googlesource.com/c/go/+/316369
Trust: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/ssagen/ssa.go | 32 ++++++++++++++++++--------
 1 file changed, 22 insertions(+), 10 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 85ebf62e98..c65e738188 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -1161,39 +1161,51 @@ func (s *state) newValue4I(op ssa.Op, t *types.Type, aux int64, arg0, arg1, arg2
 	return s.curBlock.NewValue4I(s.peekPos(), op, t, aux, arg0, arg1, arg2, arg3)
 }
 
+func (s *state) entryBlock() *ssa.Block {
+	b := s.f.Entry
+	if base.Flag.N > 0 && s.curBlock != nil {
+		// If optimizations are off, allocate in current block instead. Since with -N
+		// we're not doing the CSE or tighten passes, putting lots of stuff in the
+		// entry block leads to O(n^2) entries in the live value map during regalloc.
+		// See issue 45897.
+		b = s.curBlock
+	}
+	return b
+}
+
 // entryNewValue0 adds a new value with no arguments to the entry block.
 func (s *state) entryNewValue0(op ssa.Op, t *types.Type) *ssa.Value {
-	return s.f.Entry.NewValue0(src.NoXPos, op, t)
+	return s.entryBlock().NewValue0(src.NoXPos, op, t)
 }
 
 // entryNewValue0A adds a new value with no arguments and an aux value to the entry block.
 func (s *state) entryNewValue0A(op ssa.Op, t *types.Type, aux ssa.Aux) *ssa.Value {
-	return s.f.Entry.NewValue0A(src.NoXPos, op, t, aux)
+	return s.entryBlock().NewValue0A(src.NoXPos, op, t, aux)
 }
 
 // entryNewValue1 adds a new value with one argument to the entry block.
 func (s *state) entryNewValue1(op ssa.Op, t *types.Type, arg *ssa.Value) *ssa.Value {
-	return s.f.Entry.NewValue1(src.NoXPos, op, t, arg)
+	return s.entryBlock().NewValue1(src.NoXPos, op, t, arg)
 }
 
 // entryNewValue1 adds a new value with one argument and an auxint value to the entry block.
 func (s *state) entryNewValue1I(op ssa.Op, t *types.Type, auxint int64, arg *ssa.Value) *ssa.Value {
-	return s.f.Entry.NewValue1I(src.NoXPos, op, t, auxint, arg)
+	return s.entryBlock().NewValue1I(src.NoXPos, op, t, auxint, arg)
 }
 
 // entryNewValue1A adds a new value with one argument and an aux value to the entry block.
 func (s *state) entryNewValue1A(op ssa.Op, t *types.Type, aux ssa.Aux, arg *ssa.Value) *ssa.Value {
-	return s.f.Entry.NewValue1A(src.NoXPos, op, t, aux, arg)
+	return s.entryBlock().NewValue1A(src.NoXPos, op, t, aux, arg)
 }
 
 // entryNewValue2 adds a new value with two arguments to the entry block.
 func (s *state) entryNewValue2(op ssa.Op, t *types.Type, arg0, arg1 *ssa.Value) *ssa.Value {
-	return s.f.Entry.NewValue2(src.NoXPos, op, t, arg0, arg1)
+	return s.entryBlock().NewValue2(src.NoXPos, op, t, arg0, arg1)
 }
 
 // entryNewValue2A adds a new value with two arguments and an aux value to the entry block.
 func (s *state) entryNewValue2A(op ssa.Op, t *types.Type, aux ssa.Aux, arg0, arg1 *ssa.Value) *ssa.Value {
-	return s.f.Entry.NewValue2A(src.NoXPos, op, t, aux, arg0, arg1)
+	return s.entryBlock().NewValue2A(src.NoXPos, op, t, aux, arg0, arg1)
 }
 
 // const* routines add a new const value to the entry block.
@@ -4766,9 +4778,9 @@ func (s *state) openDeferSave(n ir.Node, t *types.Type, val *ssa.Value) *ssa.Val
 		// declared in the entry block, so that it will be live for the
 		// defer exit code (which will actually access it only if the
 		// associated defer call has been activated).
-		s.defvars[s.f.Entry.ID][memVar] = s.entryNewValue1A(ssa.OpVarDef, types.TypeMem, argTemp, s.defvars[s.f.Entry.ID][memVar])
-		s.defvars[s.f.Entry.ID][memVar] = s.entryNewValue1A(ssa.OpVarLive, types.TypeMem, argTemp, s.defvars[s.f.Entry.ID][memVar])
-		addrArgTemp = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(argTemp.Type()), argTemp, s.sp, s.defvars[s.f.Entry.ID][memVar])
+		s.defvars[s.f.Entry.ID][memVar] = s.f.Entry.NewValue1A(src.NoXPos, ssa.OpVarDef, types.TypeMem, argTemp, s.defvars[s.f.Entry.ID][memVar])
+		s.defvars[s.f.Entry.ID][memVar] = s.f.Entry.NewValue1A(src.NoXPos, ssa.OpVarLive, types.TypeMem, argTemp, s.defvars[s.f.Entry.ID][memVar])
+		addrArgTemp = s.f.Entry.NewValue2A(src.NoXPos, ssa.OpLocalAddr, types.NewPtr(argTemp.Type()), argTemp, s.sp, s.defvars[s.f.Entry.ID][memVar])
 	} else {
 		// Special case if we're still in the entry block. We can't use
 		// the above code, since s.defvars[s.f.Entry.ID] isn't defined
-- 
GitLab


From 86e42c2fbfe14c41746fe5cfc5c8bda94bb4bc4e Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Tue, 9 Mar 2021 23:27:48 -0500
Subject: [PATCH 1946/2400] cmd/go: suppress SSH password prompts when fetching
 modules or repos

We were already setting GIT_SSH_COMMAND (if unset) to explicitly
include 'ControlMaster=no' in order to disable connection pooling.
Now we also set 'BatchMode=yes' to suppress password prompts for
password-protected keys.

While we're here, we also set GCM_INTERACTIVE=never to suppress
similar prompts from the Git Credential Manager for Windows.

Fixes #44904

Change-Id: Iebb050079ff7dd54d5b944c459ae212e9e6f2579
Reviewed-on: https://go-review.googlesource.com/c/go/+/300157
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 doc/go1.17.html                     | 11 +++++++++++
 src/cmd/go/internal/get/get.go      | 16 +++++++++++++---
 src/cmd/go/internal/modload/init.go |  6 +++++-
 3 files changed, 29 insertions(+), 4 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 0521f9fd91..6aa9d5b876 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -138,6 +138,17 @@ Do not send CLs removing the interior tags from such phrases.
   module root when invoked within the <code>vendor</code> tree.
 </p>
 
+<h4 id="password-prompts">Password prompts</h4>
+
+<p><!-- golang.org/issue/44904 -->
+  The <code>go</code> command by default now suppresses SSH password prompts and
+  Git Credential Manager prompts when fetching Git repositories using SSH, as it
+  already did previously for other Git password prompts. Users authenticating to
+  private Git repos with password-protected SSH may configure
+  an <code>ssh-agent</code> to enable the <code>go</code> command to use
+  password-protected SSH keys.
+</p>
+
 <h2 id="runtime">Runtime</h2>
 
 <p>
diff --git a/src/cmd/go/internal/get/get.go b/src/cmd/go/internal/get/get.go
index 4c57ee3518..c28bce8cfc 100644
--- a/src/cmd/go/internal/get/get.go
+++ b/src/cmd/go/internal/get/get.go
@@ -126,7 +126,7 @@ func runGet(ctx context.Context, cmd *base.Command, args []string) {
 		base.Fatalf("go get: -insecure flag is no longer supported; use GOINSECURE instead")
 	}
 
-	// Disable any prompting for passwords by Git.
+	// Disable any prompting for passwords by Git itself.
 	// Only has an effect for 2.3.0 or later, but avoiding
 	// the prompt in earlier versions is just too hard.
 	// If user has explicitly set GIT_TERMINAL_PROMPT=1, keep
@@ -136,7 +136,10 @@ func runGet(ctx context.Context, cmd *base.Command, args []string) {
 		os.Setenv("GIT_TERMINAL_PROMPT", "0")
 	}
 
-	// Disable any ssh connection pooling by Git.
+	// Also disable prompting for passwords by the 'ssh' subprocess spawned by
+	// Git, because apparently GIT_TERMINAL_PROMPT isn't sufficient to do that.
+	// Adding '-o BatchMode=yes' should do the trick.
+	//
 	// If a Git subprocess forks a child into the background to cache a new connection,
 	// that child keeps stdout/stderr open. After the Git subprocess exits,
 	// os /exec expects to be able to read from the stdout/stderr pipe
@@ -150,7 +153,14 @@ func runGet(ctx context.Context, cmd *base.Command, args []string) {
 	// assume they know what they are doing and don't step on it.
 	// But default to turning off ControlMaster.
 	if os.Getenv("GIT_SSH") == "" && os.Getenv("GIT_SSH_COMMAND") == "" {
-		os.Setenv("GIT_SSH_COMMAND", "ssh -o ControlMaster=no")
+		os.Setenv("GIT_SSH_COMMAND", "ssh -o ControlMaster=no -o BatchMode=yes")
+	}
+
+	// And one more source of Git prompts: the Git Credential Manager Core for Windows.
+	//
+	// See https://github.com/microsoft/Git-Credential-Manager-Core/blob/master/docs/environment.md#gcm_interactive.
+	if os.Getenv("GCM_INTERACTIVE") == "" {
+		os.Setenv("GCM_INTERACTIVE", "never")
 	}
 
 	// Phase 1. Download/update.
diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index 88d647d9ea..99c0c2b981 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -163,7 +163,11 @@ func Init() {
 	// assume they know what they are doing and don't step on it.
 	// But default to turning off ControlMaster.
 	if os.Getenv("GIT_SSH") == "" && os.Getenv("GIT_SSH_COMMAND") == "" {
-		os.Setenv("GIT_SSH_COMMAND", "ssh -o ControlMaster=no")
+		os.Setenv("GIT_SSH_COMMAND", "ssh -o ControlMaster=no -o BatchMode=yes")
+	}
+
+	if os.Getenv("GCM_INTERACTIVE") == "" {
+		os.Setenv("GCM_INTERACTIVE", "never")
 	}
 
 	if modRoot != "" {
-- 
GitLab


From 1bbe78bb6da26f43fb0d06194f659ae7b6314e86 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Mon, 3 May 2021 14:38:53 -0400
Subject: [PATCH 1947/2400] cmd: update x/mod to pull in CL 316113

Even though x/mod is now lazy, this has no immediate effect on the
size of cmd/go.sum: all of the existing dependencies are still pulled
in via the dependency on x/tools, which is itself not yet lazy (that's
CL 315570).

For #36460
Updates #36905

Change-Id: I7bce5fe2596a2d71e4df08f5d5f4cb8dcdb8512c
Reviewed-on: https://go-review.googlesource.com/c/go/+/316489
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Alexander Rakoczy <alex@golang.org>
---
 src/cmd/go.mod             | 2 +-
 src/cmd/go.sum             | 4 ++--
 src/cmd/vendor/modules.txt | 4 ++--
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index ef231b1e3c..7629ef7dda 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -7,7 +7,7 @@ require (
 	github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639 // indirect
 	golang.org/x/arch v0.0.0-20210502124803-cbf565b21d1e
 	golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 // indirect
-	golang.org/x/mod v0.4.3-0.20210409134425-858fdbee9c24
+	golang.org/x/mod v0.4.3-0.20210503183026-4435ecfe4815
 	golang.org/x/sys v0.0.0-20210423082822-04245dca01da // indirect
 	golang.org/x/term v0.0.0-20210503060354-a79de5458b56
 	golang.org/x/tools v0.1.1-0.20210422170518-f946a157eefe
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index b03cb37203..77ad1ae05f 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -13,8 +13,8 @@ golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 h1:/ZScEX8SfEmUGRHs0gxpqteO5nfNW6axyZbBdw9A12g=
 golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.4.3-0.20210409134425-858fdbee9c24 h1:XWBCOnD7qf8cYkORdr1AfVspwadsirSDgThkrje7nWs=
-golang.org/x/mod v0.4.3-0.20210409134425-858fdbee9c24/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.3-0.20210503183026-4435ecfe4815 h1:9nyskUepGPcX93addfTsdRqsQ7rSWIdQOdWVcsWAYv0=
+golang.org/x/mod v0.4.3-0.20210503183026-4435ecfe4815/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 0ee84f4cf8..0576d2a26c 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -28,8 +28,8 @@ golang.org/x/arch/x86/x86asm
 ## explicit; go 1.11
 golang.org/x/crypto/ed25519
 golang.org/x/crypto/ed25519/internal/edwards25519
-# golang.org/x/mod v0.4.3-0.20210409134425-858fdbee9c24
-## explicit; go 1.12
+# golang.org/x/mod v0.4.3-0.20210503183026-4435ecfe4815
+## explicit; go 1.17
 golang.org/x/mod/internal/lazyregexp
 golang.org/x/mod/modfile
 golang.org/x/mod/module
-- 
GitLab


From 8e38b80b64e53b08fcde3f8596941237488e3158 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Mon, 3 May 2021 16:00:40 -0400
Subject: [PATCH 1948/2400] cmd: update x/text to pull in CL 315571

Because x/text is now lazy, the go.sum file no longer needs a checksum
for the go.mod file for the outdated x/tools required by x/text.

For #36460
Updates #36905

Change-Id: Id7395e61909af3889c1615dc33139e5bb45504c5
Reviewed-on: https://go-review.googlesource.com/c/go/+/316490
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Alexander Rakoczy <alex@golang.org>
---
 src/go.mod             | 2 +-
 src/go.sum             | 5 ++---
 src/vendor/modules.txt | 4 ++--
 3 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/src/go.mod b/src/go.mod
index 59fa194bab..7cddf04200 100644
--- a/src/go.mod
+++ b/src/go.mod
@@ -6,5 +6,5 @@ require (
 	golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83
 	golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420
 	golang.org/x/sys v0.0.0-20210423082822-04245dca01da // indirect
-	golang.org/x/text v0.3.6 // indirect
+	golang.org/x/text v0.3.7-0.20210503195748-5c7c50ebbd4f // indirect
 )
diff --git a/src/go.sum b/src/go.sum
index bfb07129bb..08db672f19 100644
--- a/src/go.sum
+++ b/src/go.sum
@@ -10,6 +10,5 @@ golang.org/x/sys v0.0.0-20210423082822-04245dca01da h1:b3NXsE2LusjYGGjL5bxEVZZOR
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.6 h1:aRYxNxv6iGQlyVaZmk6ZgYEDa+Jg18DxebPSrd6bg1M=
-golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/text v0.3.7-0.20210503195748-5c7c50ebbd4f h1:yQJrRE0hDxDFmZLlRaw+3vusO4fwNHgHIjUOMO7bHYI=
+golang.org/x/text v0.3.7-0.20210503195748-5c7c50ebbd4f/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
diff --git a/src/vendor/modules.txt b/src/vendor/modules.txt
index 8f411a06e3..01a0a33f8c 100644
--- a/src/vendor/modules.txt
+++ b/src/vendor/modules.txt
@@ -21,8 +21,8 @@ golang.org/x/net/route
 # golang.org/x/sys v0.0.0-20210423082822-04245dca01da
 ## explicit; go 1.12
 golang.org/x/sys/cpu
-# golang.org/x/text v0.3.6
-## explicit; go 1.11
+# golang.org/x/text v0.3.7-0.20210503195748-5c7c50ebbd4f
+## explicit; go 1.17
 golang.org/x/text/secure/bidirule
 golang.org/x/text/transform
 golang.org/x/text/unicode/bidi
-- 
GitLab


From 0816511d3b861a802fd6c04292ad6debd3db1831 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Mon, 3 May 2021 16:06:07 -0400
Subject: [PATCH 1949/2400] all: update x/crypto to pull in CL 316109

Because x/crypto is now lazy, this removes the remaining checksums for
older-than-selected dependencies from src/go.sum.

It also removes a significant fraction of the irrelevant checksums
from src/cmd/go.sum.

For #36460
Updates #36905

Change-Id: I33af5fc638aa1d1c66df3a1d86542912e95a7f50
Reviewed-on: https://go-review.googlesource.com/c/go/+/316451
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Alexander Rakoczy <alex@golang.org>
---
 src/cmd/go.mod                                |  2 +-
 src/cmd/go.sum                                |  6 +--
 src/cmd/vendor/modules.txt                    |  4 +-
 src/go.mod                                    |  2 +-
 src/go.sum                                    | 10 +---
 .../golang.org/x/crypto/cryptobyte/asn1.go    | 52 +++++++++++++++++++
 .../x/crypto/poly1305/sum_ppc64le.s           | 18 +++----
 src/vendor/modules.txt                        |  4 +-
 8 files changed, 71 insertions(+), 27 deletions(-)

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index 7629ef7dda..2956eed0d7 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -6,7 +6,7 @@ require (
 	github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5
 	github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639 // indirect
 	golang.org/x/arch v0.0.0-20210502124803-cbf565b21d1e
-	golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 // indirect
+	golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e // indirect
 	golang.org/x/mod v0.4.3-0.20210503183026-4435ecfe4815
 	golang.org/x/sys v0.0.0-20210423082822-04245dca01da // indirect
 	golang.org/x/term v0.0.0-20210503060354-a79de5458b56
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 77ad1ae05f..20b95eac85 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -10,8 +10,8 @@ golang.org/x/arch v0.0.0-20210502124803-cbf565b21d1e h1:pv3V0NlNSh5Q6AX/StwGLBjc
 golang.org/x/arch v0.0.0-20210502124803-cbf565b21d1e/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 h1:/ZScEX8SfEmUGRHs0gxpqteO5nfNW6axyZbBdw9A12g=
-golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
+golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e h1:8foAy0aoO5GkqCvAEJ4VC4P3zksTg4X4aJCDpZzmgQI=
+golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.3-0.20210503183026-4435ecfe4815 h1:9nyskUepGPcX93addfTsdRqsQ7rSWIdQOdWVcsWAYv0=
 golang.org/x/mod v0.4.3-0.20210503183026-4435ecfe4815/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
@@ -22,14 +22,12 @@ golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da h1:b3NXsE2LusjYGGjL5bxEVZZORm/YEFFrWFjR8eFrw/c=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210503060354-a79de5458b56 h1:b8jxX3zqjpqb2LklXPzKSGJhzyxCOZSz8ncv8Nv+y7w=
 golang.org/x/term v0.0.0-20210503060354-a79de5458b56/go.mod h1:tfny5GFUkzUvx4ps4ajbZsCe5lw1metzhBm9T3x7oIY=
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 0576d2a26c..537b800740 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -24,8 +24,8 @@ golang.org/x/arch/arm/armasm
 golang.org/x/arch/arm64/arm64asm
 golang.org/x/arch/ppc64/ppc64asm
 golang.org/x/arch/x86/x86asm
-# golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83
-## explicit; go 1.11
+# golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e
+## explicit; go 1.17
 golang.org/x/crypto/ed25519
 golang.org/x/crypto/ed25519/internal/edwards25519
 # golang.org/x/mod v0.4.3-0.20210503183026-4435ecfe4815
diff --git a/src/go.mod b/src/go.mod
index 7cddf04200..8402cf12aa 100644
--- a/src/go.mod
+++ b/src/go.mod
@@ -3,7 +3,7 @@ module std
 go 1.17
 
 require (
-	golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83
+	golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e
 	golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420
 	golang.org/x/sys v0.0.0-20210423082822-04245dca01da // indirect
 	golang.org/x/text v0.3.7-0.20210503195748-5c7c50ebbd4f // indirect
diff --git a/src/go.sum b/src/go.sum
index 08db672f19..5f93c1cd49 100644
--- a/src/go.sum
+++ b/src/go.sum
@@ -1,14 +1,8 @@
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 h1:/ZScEX8SfEmUGRHs0gxpqteO5nfNW6axyZbBdw9A12g=
-golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e h1:8foAy0aoO5GkqCvAEJ4VC4P3zksTg4X4aJCDpZzmgQI=
+golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
 golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420 h1:a8jGStKg0XqKDlKqjLrXn0ioF5MH36pT7Z0BRTqLhbk=
 golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da h1:b3NXsE2LusjYGGjL5bxEVZZORm/YEFFrWFjR8eFrw/c=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.7-0.20210503195748-5c7c50ebbd4f h1:yQJrRE0hDxDFmZLlRaw+3vusO4fwNHgHIjUOMO7bHYI=
 golang.org/x/text v0.3.7-0.20210503195748-5c7c50ebbd4f/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
diff --git a/src/vendor/golang.org/x/crypto/cryptobyte/asn1.go b/src/vendor/golang.org/x/crypto/cryptobyte/asn1.go
index d3596ee66f..83c776de08 100644
--- a/src/vendor/golang.org/x/crypto/cryptobyte/asn1.go
+++ b/src/vendor/golang.org/x/crypto/cryptobyte/asn1.go
@@ -117,6 +117,19 @@ func (b *Builder) AddASN1GeneralizedTime(t time.Time) {
 	})
 }
 
+// AddASN1UTCTime appends a DER-encoded ASN.1 UTCTime.
+func (b *Builder) AddASN1UTCTime(t time.Time) {
+	b.AddASN1(asn1.UTCTime, func(c *Builder) {
+		// As utilized by the X.509 profile, UTCTime can only
+		// represent the years 1950 through 2049.
+		if t.Year() < 1950 || t.Year() >= 2050 {
+			b.err = fmt.Errorf("cryptobyte: cannot represent %v as a UTCTime", t)
+			return
+		}
+		c.AddBytes([]byte(t.Format(defaultUTCTimeFormatStr)))
+	})
+}
+
 // AddASN1BitString appends a DER-encoded ASN.1 BIT STRING. This does not
 // support BIT STRINGs that are not a whole number of bytes.
 func (b *Builder) AddASN1BitString(data []byte) {
@@ -466,6 +479,45 @@ func (s *String) ReadASN1GeneralizedTime(out *time.Time) bool {
 	return true
 }
 
+const defaultUTCTimeFormatStr = "060102150405Z0700"
+
+// ReadASN1UTCTime decodes an ASN.1 UTCTime into out and advances.
+// It reports whether the read was successful.
+func (s *String) ReadASN1UTCTime(out *time.Time) bool {
+	var bytes String
+	if !s.ReadASN1(&bytes, asn1.UTCTime) {
+		return false
+	}
+	t := string(bytes)
+
+	formatStr := defaultUTCTimeFormatStr
+	var err error
+	res, err := time.Parse(formatStr, t)
+	if err != nil {
+		// Fallback to minute precision if we can't parse second
+		// precision. If we are following X.509 or X.690 we shouldn't
+		// support this, but we do.
+		formatStr = "0601021504Z0700"
+		res, err = time.Parse(formatStr, t)
+	}
+	if err != nil {
+		return false
+	}
+
+	if serialized := res.Format(formatStr); serialized != t {
+		return false
+	}
+
+	if res.Year() >= 2050 {
+		// UTCTime interprets the low order digits 50-99 as 1950-99.
+		// This only applies to its use in the X.509 profile.
+		// See https://tools.ietf.org/html/rfc5280#section-4.1.2.5.1
+		res = res.AddDate(-100, 0, 0)
+	}
+	*out = res
+	return true
+}
+
 // ReadASN1BitString decodes an ASN.1 BIT STRING into out and advances.
 // It reports whether the read was successful.
 func (s *String) ReadASN1BitString(out *encoding_asn1.BitString) bool {
diff --git a/src/vendor/golang.org/x/crypto/poly1305/sum_ppc64le.s b/src/vendor/golang.org/x/crypto/poly1305/sum_ppc64le.s
index 5cd7494b21..3cede539dc 100644
--- a/src/vendor/golang.org/x/crypto/poly1305/sum_ppc64le.s
+++ b/src/vendor/golang.org/x/crypto/poly1305/sum_ppc64le.s
@@ -82,7 +82,7 @@ multiply:
 	BGE loop
 
 bytes_between_0_and_15:
-	CMP  $0, R5
+	CMP  R5, $0
 	BEQ  done
 	MOVD $0, R16 // h0
 	MOVD $0, R17 // h1
@@ -122,7 +122,7 @@ just1:
 	// Exactly 8
 	MOVD (R4), R16
 
-	CMP $0, R17
+	CMP R17, $0
 
 	// Check if we've already set R17; if not
 	// set 1 to indicate end of msg.
@@ -151,7 +151,7 @@ less4:
 	ADD   $2, R4
 
 less2:
-	CMP   $0, R5
+	CMP   R5, $0
 	BEQ   insert1
 	MOVBZ (R4), R21
 	SLD   R22, R21, R21
@@ -166,12 +166,12 @@ insert1:
 
 carry:
 	// Add new values to h0, h1, h2
-	ADDC R16, R8
-	ADDE R17, R9
-	ADDE $0, R10
-	MOVD $16, R5
-	ADD  R5, R4
-	BR   multiply
+	ADDC  R16, R8
+	ADDE  R17, R9
+	ADDZE R10, R10
+	MOVD  $16, R5
+	ADD   R5, R4
+	BR    multiply
 
 done:
 	// Save h0, h1, h2 in state
diff --git a/src/vendor/modules.txt b/src/vendor/modules.txt
index 01a0a33f8c..8658b7da15 100644
--- a/src/vendor/modules.txt
+++ b/src/vendor/modules.txt
@@ -1,5 +1,5 @@
-# golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83
-## explicit; go 1.11
+# golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e
+## explicit; go 1.17
 golang.org/x/crypto/chacha20
 golang.org/x/crypto/chacha20poly1305
 golang.org/x/crypto/cryptobyte
-- 
GitLab


From eab0c46af7331484a7d5837cad68d9d01890b90f Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Mon, 3 May 2021 00:17:56 -0400
Subject: [PATCH 1950/2400] cmd/go/internal/modload: remove outdated comments
 and redundant tests

The outdated comment in modfile.go was missed in CL 315409.

Upon a closer look at the test case in mod_go_version_vendor.txt, it
is almost completely redundant with the new test in
mod_vendor_goversion.txt. Make it completely redundant and remove it.

Updates #36876

Change-Id: Ibcd1f6b426460aaafbd6dc0be93078547904572b
Reviewed-on: https://go-review.googlesource.com/c/go/+/316209
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modload/modfile.go        |  3 --
 .../testdata/script/mod_go_version_vendor.txt | 38 -------------------
 .../testdata/script/mod_vendor_goversion.txt  | 23 +++++++++--
 3 files changed, 19 insertions(+), 45 deletions(-)
 delete mode 100644 src/cmd/go/testdata/script/mod_go_version_vendor.txt

diff --git a/src/cmd/go/internal/modload/modfile.go b/src/cmd/go/internal/modload/modfile.go
index 7595db7755..bafff3e080 100644
--- a/src/cmd/go/internal/modload/modfile.go
+++ b/src/cmd/go/internal/modload/modfile.go
@@ -501,9 +501,6 @@ func goModSummary(m module.Version) (*modFileSummary, error) {
 		// return the full list of modules from modules.txt.
 		readVendorList()
 
-		// TODO(#36876): Load the "go" version from vendor/modules.txt and store it
-		// in rawGoVersion with the appropriate key.
-
 		// We don't know what versions the vendored module actually relies on,
 		// so assume that it requires everything.
 		summary.require = vendorList
diff --git a/src/cmd/go/testdata/script/mod_go_version_vendor.txt b/src/cmd/go/testdata/script/mod_go_version_vendor.txt
deleted file mode 100644
index 6364e17daa..0000000000
--- a/src/cmd/go/testdata/script/mod_go_version_vendor.txt
+++ /dev/null
@@ -1,38 +0,0 @@
-# Regression test for https://golang.org/issue/45109:
-# Dependencies that use post-1.11 Go features should build
-# when compiled as vendored dependencies of Go 1.16 modules.
-
-[short] skip
-
-go mod edit -replace=example.com/use113@v0.1.0=./use113
-
-go mod vendor
-! grep 1.13 vendor/modules.txt  # TODO(#36876): record dependency versions.
-go build .
-
-
-# In Go 1.16 and earlier, 'go mod vendor' did not record dependency versions.
-# That still should not cause a build failure.
-
-go mod edit -go=1.16
-go mod vendor
-! grep 1.13 vendor/modules.txt
-go build .
-
--- go.mod --
-module example.com/foo
-
-go 1.16
--- foo.go --
-package foo
-
-import _ "example.com/use113"
-
--- use113/go.mod --
-module example.com/use113
-
-go 1.13
--- use113/use113.go --
-package use113
-
-const x = 1_000
diff --git a/src/cmd/go/testdata/script/mod_vendor_goversion.txt b/src/cmd/go/testdata/script/mod_vendor_goversion.txt
index 7bc67ef30f..aa4cb41171 100644
--- a/src/cmd/go/testdata/script/mod_vendor_goversion.txt
+++ b/src/cmd/go/testdata/script/mod_vendor_goversion.txt
@@ -11,25 +11,40 @@ go build example.net/need117
 stderr '^bad114[/\\]bad114.go:15:2: duplicate method Y$'
 
 
-# With a vendor/modules.txt lacking language versions, the world is topsy-turvy.
-# Things that ought to build shouldn't, and things that shouldn't build do.
+# With a vendor/modules.txt lacking language versions, the world is topsy-turvy,
+# because we have to guess a uniform version for everything.
+#
+# We always guess Go 1.16, because that was the last version for which
+# 'go mod vendor' failed to record dependency versions, and it has most of
+# the language features added since modules were introduced in Go 1.11.
+#
+# Even so, modules that declare 'go 1.17' and use 1.17 features spuriously fail
+# to build, and modules that declare an older version and use features from a
+# newer one spuriously build (instead of failing as they ought to).
 
 go mod vendor
-go build example.net/bad114
+
+! grep 1.17 vendor/modules.txt
 ! go build example.net/need117
 stderr '^vendor[/\\]example\.net[/\\]need117[/\\]need117.go:5:18: .*\n\tconversion of slices to array pointers only supported as of -lang=go1\.17'
 
+! grep 1.13 vendor/modules.txt
+go build example.net/bad114
+
 
 # Upgrading the main module to 1.17 adds version annotations.
 # Then everything is once again consistent with the non-vendored world.
 
 go mod edit -go=1.17
 go mod vendor
+
+grep '^## explicit; go 1.17$' vendor/modules.txt
 go build example.net/need117
+
+grep '^## explicit; go 1.13$' vendor/modules.txt
 ! go build example.net/bad114
 stderr '^vendor[/\\]example\.net[/\\]bad114[/\\]bad114.go:15:2: duplicate method Y$'
 
-
 -- go.mod --
 module example.net/m
 
-- 
GitLab


From 62d424d794e7543e84f4b6ddd7acc8e39c6c6380 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Mon, 3 May 2021 16:11:24 -0400
Subject: [PATCH 1951/2400] cmd: update x/tools to pull in CL 315570

Since x/tools is now lazy, this removes a significant fraction of
otherwise-irrelevant dependencies from the go.sum file.

The remaining extraneous go.sum lines come from the dependency on
github.com/google/pprof. Since that module is outside of the Go
project proper, I do not plan to submit a PR to make it lazy until
after the Go 1.17 release.

For #36460
Updates #36905

Change-Id: I214492cf931fca797817124ecdcbccd4ebb7505b
Reviewed-on: https://go-review.googlesource.com/c/go/+/316452
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Alexander Rakoczy <alex@golang.org>
---
 src/cmd/go.mod             |  2 +-
 src/cmd/go.sum             | 25 ++-----------------------
 src/cmd/vendor/modules.txt |  4 ++--
 3 files changed, 5 insertions(+), 26 deletions(-)

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index 2956eed0d7..79224db999 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -10,6 +10,6 @@ require (
 	golang.org/x/mod v0.4.3-0.20210503183026-4435ecfe4815
 	golang.org/x/sys v0.0.0-20210423082822-04245dca01da // indirect
 	golang.org/x/term v0.0.0-20210503060354-a79de5458b56
-	golang.org/x/tools v0.1.1-0.20210422170518-f946a157eefe
+	golang.org/x/tools v0.1.1-0.20210503200558-19b1717ea5eb
 	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
 )
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 20b95eac85..4ae0261d1c 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -5,39 +5,18 @@ github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5 h1:zIaiqGYDQwa4HVx5wG
 github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
 github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639 h1:mV02weKRL81bEnm8A0HT1/CAelMQDBuQIfLw8n+d6xI=
 github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
-github.com/yuin/goldmark v1.3.3/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
 golang.org/x/arch v0.0.0-20210502124803-cbf565b21d1e h1:pv3V0NlNSh5Q6AX/StwGLBjcLS7UN4m4Gq+V+uSecqM=
 golang.org/x/arch v0.0.0-20210502124803-cbf565b21d1e/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e h1:8foAy0aoO5GkqCvAEJ4VC4P3zksTg4X4aJCDpZzmgQI=
 golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
-golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.3-0.20210503183026-4435ecfe4815 h1:9nyskUepGPcX93addfTsdRqsQ7rSWIdQOdWVcsWAYv0=
 golang.org/x/mod v0.4.3-0.20210503183026-4435ecfe4815/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da h1:b3NXsE2LusjYGGjL5bxEVZZORm/YEFFrWFjR8eFrw/c=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210503060354-a79de5458b56 h1:b8jxX3zqjpqb2LklXPzKSGJhzyxCOZSz8ncv8Nv+y7w=
 golang.org/x/term v0.0.0-20210503060354-a79de5458b56/go.mod h1:tfny5GFUkzUvx4ps4ajbZsCe5lw1metzhBm9T3x7oIY=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.1.1-0.20210422170518-f946a157eefe h1:HNJiwGJfGFN64PAg8ZAP2gPPqlFQb/RLlE4lNoozcrw=
-golang.org/x/tools v0.1.1-0.20210422170518-f946a157eefe/go.mod h1:q7cPXv+8VGj9Sx5ckHx2nzMtCSaZFrowzWpjN/cwVb8=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/tools v0.1.1-0.20210503200558-19b1717ea5eb h1:6lugOWRUqRgNSUsUg8YnMqSUlUXSGsJG2dEv9T6BxwQ=
+golang.org/x/tools v0.1.1-0.20210503200558-19b1717ea5eb/go.mod h1:sH/Eidr0EddymY8HZSakBo32zU3fG5ovDq874hJLjVg=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 537b800740..e9644883fc 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -48,8 +48,8 @@ golang.org/x/sys/windows
 # golang.org/x/term v0.0.0-20210503060354-a79de5458b56
 ## explicit; go 1.17
 golang.org/x/term
-# golang.org/x/tools v0.1.1-0.20210422170518-f946a157eefe
-## explicit; go 1.12
+# golang.org/x/tools v0.1.1-0.20210503200558-19b1717ea5eb
+## explicit; go 1.17
 golang.org/x/tools/cover
 golang.org/x/tools/go/analysis
 golang.org/x/tools/go/analysis/internal/analysisflags
-- 
GitLab


From 371ea545c015627ffac2139338ea63acda4c1523 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Fri, 8 Jan 2021 12:21:08 -0800
Subject: [PATCH 1952/2400] net/url: avoid string concatenation in resolvePath
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

ame                  old time/op    new time/op    delta
String-12               8.09µs ± 7%    8.20µs ± 5%     ~     (p=0.347 n=20+19)
ResolvePath-12           223ns ± 8%     170ns ± 7%  -23.84%  (p=0.000 n=20+19)
QueryEscape/#00-12      72.9ns ± 5%    73.6ns ± 6%     ~     (p=0.337 n=20+20)
QueryEscape/#01-12       467ns ± 5%     467ns ± 7%     ~     (p=0.612 n=19+20)
QueryEscape/#02-12       257ns ± 8%     262ns ± 8%     ~     (p=0.080 n=20+20)
QueryEscape/#03-12       553ns ±12%     568ns ± 8%   +2.73%  (p=0.048 n=20+19)
QueryEscape/#04-12      4.45µs ± 7%    4.52µs ± 5%     ~     (p=0.163 n=20+20)
PathEscape/#00-12        119ns ± 9%     121ns ± 6%     ~     (p=0.140 n=20+20)
PathEscape/#01-12        458ns ± 7%     483ns ± 4%   +5.49%  (p=0.000 n=20+20)
PathEscape/#02-12        255ns ± 7%     257ns ± 7%     ~     (p=0.560 n=20+20)
PathEscape/#03-12        556ns ± 8%     559ns ± 8%     ~     (p=0.799 n=20+20)
PathEscape/#04-12       4.14µs ± 6%    4.28µs ± 8%   +3.30%  (p=0.003 n=20+20)
QueryUnescape/#00-12    72.2ns ± 8%    74.9ns ± 5%   +3.66%  (p=0.006 n=20+19)
QueryUnescape/#01-12     223ns ± 7%     230ns ± 8%   +2.84%  (p=0.016 n=20+20)
QueryUnescape/#02-12     200ns ± 7%     203ns ±10%     ~     (p=0.533 n=20+20)
QueryUnescape/#03-12     480ns ± 7%     500ns ± 8%   +4.15%  (p=0.006 n=20+20)
QueryUnescape/#04-12    2.61µs ± 8%    2.70µs ± 7%   +3.39%  (p=0.009 n=20+20)
PathUnescape/#00-12     74.6ns ± 6%    75.4ns ± 6%     ~     (p=0.425 n=20+20)
PathUnescape/#01-12      226ns ± 3%     227ns ± 8%     ~     (p=0.453 n=15+20)
PathUnescape/#02-12      202ns ±11%     202ns ± 6%     ~     (p=0.963 n=20+20)
PathUnescape/#03-12      484ns ± 9%     494ns ± 9%     ~     (p=0.078 n=20+19)
PathUnescape/#04-12     2.60µs ± 6%    2.61µs ± 8%     ~     (p=0.776 n=20+19)
Split-12                6.47ns ± 0%    6.47ns ± 0%     ~     (p=0.760 n=18+18)

name                  old alloc/op   new alloc/op   delta
String-12               1.50kB ± 0%    1.50kB ± 0%     ~     (all equal)
ResolvePath-12           24.0B ± 0%     16.0B ± 0%  -33.33%  (p=0.000 n=20+20)
QueryEscape/#00-12       8.00B ± 0%     8.00B ± 0%     ~     (all equal)
QueryEscape/#01-12       64.0B ± 0%     64.0B ± 0%     ~     (all equal)
QueryEscape/#02-12       32.0B ± 0%     32.0B ± 0%     ~     (all equal)
QueryEscape/#03-12       64.0B ± 0%     64.0B ± 0%     ~     (all equal)
QueryEscape/#04-12        832B ± 0%      832B ± 0%     ~     (all equal)
PathEscape/#00-12        16.0B ± 0%     16.0B ± 0%     ~     (all equal)
PathEscape/#01-12        64.0B ± 0%     64.0B ± 0%     ~     (all equal)
PathEscape/#02-12        32.0B ± 0%     32.0B ± 0%     ~     (all equal)
PathEscape/#03-12        64.0B ± 0%     64.0B ± 0%     ~     (all equal)
PathEscape/#04-12         704B ± 0%      704B ± 0%     ~     (all equal)
QueryUnescape/#00-12     8.00B ± 0%     8.00B ± 0%     ~     (all equal)
QueryUnescape/#01-12     24.0B ± 0%     24.0B ± 0%     ~     (all equal)
QueryUnescape/#02-12     24.0B ± 0%     24.0B ± 0%     ~     (all equal)
QueryUnescape/#03-12     64.0B ± 0%     64.0B ± 0%     ~     (all equal)
QueryUnescape/#04-12      320B ± 0%      320B ± 0%     ~     (all equal)
PathUnescape/#00-12      8.00B ± 0%     8.00B ± 0%     ~     (all equal)
PathUnescape/#01-12      24.0B ± 0%     24.0B ± 0%     ~     (all equal)
PathUnescape/#02-12      24.0B ± 0%     24.0B ± 0%     ~     (all equal)
PathUnescape/#03-12      64.0B ± 0%     64.0B ± 0%     ~     (all equal)
PathUnescape/#04-12       320B ± 0%      320B ± 0%     ~     (all equal)

name                  old allocs/op  new allocs/op  delta
String-12                 63.0 ± 0%      63.0 ± 0%     ~     (all equal)
ResolvePath-12            3.00 ± 0%      2.00 ± 0%  -33.33%  (p=0.000 n=20+20)
QueryEscape/#00-12        1.00 ± 0%      1.00 ± 0%     ~     (all equal)
QueryEscape/#01-12        1.00 ± 0%      1.00 ± 0%     ~     (all equal)
QueryEscape/#02-12        1.00 ± 0%      1.00 ± 0%     ~     (all equal)
QueryEscape/#03-12        1.00 ± 0%      1.00 ± 0%     ~     (all equal)
QueryEscape/#04-12        2.00 ± 0%      2.00 ± 0%     ~     (all equal)
PathEscape/#00-12         1.00 ± 0%      1.00 ± 0%     ~     (all equal)
PathEscape/#01-12         1.00 ± 0%      1.00 ± 0%     ~     (all equal)
PathEscape/#02-12         1.00 ± 0%      1.00 ± 0%     ~     (all equal)
PathEscape/#03-12         1.00 ± 0%      1.00 ± 0%     ~     (all equal)
PathEscape/#04-12         2.00 ± 0%      2.00 ± 0%     ~     (all equal)
QueryUnescape/#00-12      1.00 ± 0%      1.00 ± 0%     ~     (all equal)
QueryUnescape/#01-12      1.00 ± 0%      1.00 ± 0%     ~     (all equal)
QueryUnescape/#02-12      1.00 ± 0%      1.00 ± 0%     ~     (all equal)
QueryUnescape/#03-12      1.00 ± 0%      1.00 ± 0%     ~     (all equal)
QueryUnescape/#04-12      1.00 ± 0%      1.00 ± 0%     ~     (all equal)
PathUnescape/#00-12       1.00 ± 0%      1.00 ± 0%     ~     (all equal)
PathUnescape/#01-12       1.00 ± 0%      1.00 ± 0%     ~     (all equal)
PathUnescape/#02-12       1.00 ± 0%      1.00 ± 0%     ~     (all equal)
PathUnescape/#03-12       1.00 ± 0%      1.00 ± 0%     ~     (all equal)
PathUnescape/#04-12       1.00 ± 0%      1.00 ± 0%     ~     (all equal)

Fixes #43587

Change-Id: I66c47e78e92555180ce3554a2d4a21038362c41e
Reviewed-on: https://go-review.googlesource.com/c/go/+/282673
Trust: Ian Lance Taylor <iant@golang.org>
Trust: Daniel Martí <mvdan@mvdan.cc>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/net/url/url.go | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/net/url/url.go b/src/net/url/url.go
index a4d7c03a87..73bef22e45 100644
--- a/src/net/url/url.go
+++ b/src/net/url/url.go
@@ -1015,6 +1015,8 @@ func resolvePath(base, ref string) string {
 	)
 	first := true
 	remaining := full
+	// We want to return a leading '/', so write it now.
+	dst.WriteByte('/')
 	for i >= 0 {
 		i = strings.IndexByte(remaining, '/')
 		if i < 0 {
@@ -1029,10 +1031,12 @@ func resolvePath(base, ref string) string {
 		}
 
 		if elem == ".." {
-			str := dst.String()
+			// Ignore the leading '/' we already wrote.
+			str := dst.String()[1:]
 			index := strings.LastIndexByte(str, '/')
 
 			dst.Reset()
+			dst.WriteByte('/')
 			if index == -1 {
 				first = true
 			} else {
@@ -1051,7 +1055,12 @@ func resolvePath(base, ref string) string {
 		dst.WriteByte('/')
 	}
 
-	return "/" + strings.TrimPrefix(dst.String(), "/")
+	// We wrote an initial '/', but we don't want two.
+	r := dst.String()
+	if len(r) > 1 && r[1] == '/' {
+		r = r[1:]
+	}
+	return r
 }
 
 // IsAbs reports whether the URL is absolute.
-- 
GitLab


From 10d625d5b41f17c118da18a592c683e60fcdcb3b Mon Sep 17 00:00:00 2001
From: Ariel Mashraki <ariel@mashraki.co.il>
Date: Tue, 20 Apr 2021 16:15:29 +0300
Subject: [PATCH 1953/2400] database/sql: add NullInt16 and NullByte

Fixes #40082

Change-Id: I01cd4d0e23c0376a6ee6e0b196c9f840cd662325
Reviewed-on: https://go-review.googlesource.com/c/go/+/311572
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Daniel Theophanes <kardianos@gmail.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/database/sql/fakedb_test.go |  8 ++++-
 src/database/sql/sql.go         | 54 +++++++++++++++++++++++++++++++++
 src/database/sql/sql_test.go    | 24 +++++++++++++++
 3 files changed, 85 insertions(+), 1 deletion(-)

diff --git a/src/database/sql/fakedb_test.go b/src/database/sql/fakedb_test.go
index 72e16e05b1..4b68f1cba9 100644
--- a/src/database/sql/fakedb_test.go
+++ b/src/database/sql/fakedb_test.go
@@ -1186,9 +1186,11 @@ func converterForType(typ string) driver.ValueConverter {
 		return driver.Bool
 	case "nullbool":
 		return driver.Null{Converter: driver.Bool}
+	case "byte", "int16":
+		return driver.NotNull{Converter: driver.DefaultParameterConverter}
 	case "int32":
 		return driver.Int32
-	case "nullint32":
+	case "nullbyte", "nullint32", "nullint16":
 		return driver.Null{Converter: driver.DefaultParameterConverter}
 	case "string":
 		return driver.NotNull{Converter: fakeDriverString{}}
@@ -1222,6 +1224,10 @@ func colTypeToReflectType(typ string) reflect.Type {
 		return reflect.TypeOf(false)
 	case "nullbool":
 		return reflect.TypeOf(NullBool{})
+	case "int16":
+		return reflect.TypeOf(int16(0))
+	case "nullint16":
+		return reflect.TypeOf(NullInt16{})
 	case "int32":
 		return reflect.TypeOf(int32(0))
 	case "nullint32":
diff --git a/src/database/sql/sql.go b/src/database/sql/sql.go
index 61b5018f0b..68fb392e0d 100644
--- a/src/database/sql/sql.go
+++ b/src/database/sql/sql.go
@@ -260,6 +260,60 @@ func (n NullInt32) Value() (driver.Value, error) {
 	return int64(n.Int32), nil
 }
 
+// NullInt16 represents an int16 that may be null.
+// NullInt16 implements the Scanner interface so
+// it can be used as a scan destination, similar to NullString.
+type NullInt16 struct {
+	Int16 int16
+	Valid bool // Valid is true if Int16 is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (n *NullInt16) Scan(value interface{}) error {
+	if value == nil {
+		n.Int16, n.Valid = 0, false
+		return nil
+	}
+	err := convertAssign(&n.Int16, value)
+	n.Valid = err == nil
+	return err
+}
+
+// Value implements the driver Valuer interface.
+func (n NullInt16) Value() (driver.Value, error) {
+	if !n.Valid {
+		return nil, nil
+	}
+	return int64(n.Int16), nil
+}
+
+// NullByte represents a byte that may be null.
+// NullByte implements the Scanner interface so
+// it can be used as a scan destination, similar to NullString.
+type NullByte struct {
+	Byte  byte
+	Valid bool // Valid is true if Byte is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (n *NullByte) Scan(value interface{}) error {
+	if value == nil {
+		n.Byte, n.Valid = 0, false
+		return nil
+	}
+	err := convertAssign(&n.Byte, value)
+	n.Valid = err == nil
+	return err
+}
+
+// Value implements the driver Valuer interface.
+func (n NullByte) Value() (driver.Value, error) {
+	if !n.Valid {
+		return nil, nil
+	}
+	return int64(n.Byte), nil
+}
+
 // NullFloat64 represents a float64 that may be null.
 // NullFloat64 implements the Scanner interface so
 // it can be used as a scan destination, similar to NullString.
diff --git a/src/database/sql/sql_test.go b/src/database/sql/sql_test.go
index 94af39c207..80f63e877d 100644
--- a/src/database/sql/sql_test.go
+++ b/src/database/sql/sql_test.go
@@ -1819,6 +1819,30 @@ func TestNullInt32Param(t *testing.T) {
 	nullTestRun(t, spec)
 }
 
+func TestNullInt16Param(t *testing.T) {
+	spec := nullTestSpec{"nullint16", "int16", [6]nullTestRow{
+		{NullInt16{31, true}, 1, NullInt16{31, true}},
+		{NullInt16{-22, false}, 1, NullInt16{0, false}},
+		{22, 1, NullInt16{22, true}},
+		{NullInt16{33, true}, 1, NullInt16{33, true}},
+		{NullInt16{222, false}, 1, NullInt16{0, false}},
+		{0, NullInt16{31, false}, nil},
+	}}
+	nullTestRun(t, spec)
+}
+
+func TestNullByteParam(t *testing.T) {
+	spec := nullTestSpec{"nullbyte", "byte", [6]nullTestRow{
+		{NullByte{31, true}, 1, NullByte{31, true}},
+		{NullByte{0, false}, 1, NullByte{0, false}},
+		{22, 1, NullByte{22, true}},
+		{NullByte{33, true}, 1, NullByte{33, true}},
+		{NullByte{222, false}, 1, NullByte{0, false}},
+		{0, NullByte{31, false}, nil},
+	}}
+	nullTestRun(t, spec)
+}
+
 func TestNullFloat64Param(t *testing.T) {
 	spec := nullTestSpec{"nullfloat64", "float64", [6]nullTestRow{
 		{NullFloat64{31.2, true}, 1, NullFloat64{31.2, true}},
-- 
GitLab


From d83baa1aa22d074b44d8b705e1d8dafa30ecceb1 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Mon, 3 May 2021 18:11:55 +0000
Subject: [PATCH 1954/2400] cmd/dist,cmd/go: set GOTRACEBACK to "system" for
 testing

If we're testing through dist, we're testing the implementation of Go,
so we're interested in any package failing with potential runtime
issues. In these cases, we'd like to have as much relevant detail as
possible, but currently runtime stack frames and goroutines are
suppressed due to the default GOTRACEBACK setting.

So, try to set GOTRACEBACK to system if it's unset. Check if it's unset
first so we don't override the user asking for a lower or higher level.

This change was brought up in the context of #45916, since there's an
apparent deadlock (or something!) in the runtime that appears when
running other code, but it's difficult to see exactly where it's
blocked. However, this change is very generally useful.

This change also runs scripted tests with GOTRACEBACK=system, upgrading
from GOTRACEBACK=all. Often, script tests can trigger failures deep in
the runtime in interesting ways because they start many individual Go
processes, so being able to identify points of interest in the runtime
is quite useful.

For #45916.

Change-Id: I3d50658d0d0090fb4c9182b87200d266c7f8f915
Reviewed-on: https://go-review.googlesource.com/c/go/+/316469
Trust: Michael Knyszek <mknyszek@google.com>
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 src/cmd/dist/test.go      | 28 ++++++++++++++++++++++++++++
 src/cmd/go/script_test.go |  2 +-
 2 files changed, 29 insertions(+), 1 deletion(-)

diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go
index 33fabd3554..50bf80ba59 100644
--- a/src/cmd/dist/test.go
+++ b/src/cmd/dist/test.go
@@ -42,6 +42,7 @@ func cmdtest() {
 	if noRebuild {
 		t.rebuild = false
 	}
+
 	t.run()
 }
 
@@ -117,6 +118,21 @@ func (t *tester) run() {
 		}
 	}
 
+	// Set GOTRACEBACK to system if the user didn't set a level explicitly.
+	// Since we're running tests for Go, we want as much detail as possible
+	// if something goes wrong.
+	//
+	// Set it before running any commands just in case something goes wrong.
+	if ok := isEnvSet("GOTRACEBACK"); !ok {
+		if err := os.Setenv("GOTRACEBACK", "system"); err != nil {
+			if t.keepGoing {
+				log.Printf("Failed to set GOTRACEBACK: %v", err)
+			} else {
+				fatalf("Failed to set GOTRACEBACK: %v", err)
+			}
+		}
+	}
+
 	if t.rebuild {
 		t.out("Building packages and commands.")
 		// Force rebuild the whole toolchain.
@@ -1664,3 +1680,15 @@ func isUnsupportedVMASize(w *work) bool {
 	unsupportedVMA := []byte("unsupported VMA range")
 	return w.dt.name == "race" && bytes.Contains(w.out, unsupportedVMA)
 }
+
+// isEnvSet reports whether the environment variable evar is
+// set in the environment.
+func isEnvSet(evar string) bool {
+	evarEq := evar + "="
+	for _, e := range os.Environ() {
+		if strings.HasPrefix(e, evarEq) {
+			return true
+		}
+	}
+	return false
+}
diff --git a/src/cmd/go/script_test.go b/src/cmd/go/script_test.go
index 2274335a75..327eaff445 100644
--- a/src/cmd/go/script_test.go
+++ b/src/cmd/go/script_test.go
@@ -170,7 +170,7 @@ func (ts *testScript) setup() {
 		"GOPRIVATE=",
 		"GOROOT=" + testGOROOT,
 		"GOROOT_FINAL=" + os.Getenv("GOROOT_FINAL"), // causes spurious rebuilds and breaks the "stale" built-in if not propagated
-		"GOTRACEBACK=all",
+		"GOTRACEBACK=system",
 		"TESTGO_GOROOT=" + testGOROOT,
 		"GOSUMDB=" + testSumDBVerifierKey,
 		"GONOPROXY=",
-- 
GitLab


From da7496d84128be85a4db5b6fdf9029c48c867211 Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Wed, 28 Apr 2021 16:47:41 -0500
Subject: [PATCH 1955/2400] os/signal: increase test timeouts on ppc64*/linux

TestSignalTrace can take a bit longer to run on some
ppc64{,le} machines. I was only able to reproduce the
timeout reliably on a POWER8/ppc64le ubuntu 16.04 host.

Bump the timeout to 5 seconds.  This should be more than
sufficient for a test which occasionally takes a bit
longer to run on these builders.

Fixes #45773

Change-Id: I4177bb986561f714aabfa5b0ca44b1c90b1cd94f
Reviewed-on: https://go-review.googlesource.com/c/go/+/315049
Run-TryBot: Paul Murphy <murp@ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Trust: Lynn Boger <laboger@linux.vnet.ibm.com>
---
 src/os/signal/signal_test.go | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/os/signal/signal_test.go b/src/os/signal/signal_test.go
index 4c19281e91..cea68742d2 100644
--- a/src/os/signal/signal_test.go
+++ b/src/os/signal/signal_test.go
@@ -18,6 +18,7 @@ import (
 	"runtime"
 	"runtime/trace"
 	"strconv"
+	"strings"
 	"sync"
 	"syscall"
 	"testing"
@@ -47,6 +48,13 @@ func init() {
 		//
 		// See https://golang.org/issue/33174.
 		settleTime = 11 * time.Second
+	} else if runtime.GOOS == "linux" && strings.HasPrefix(runtime.GOARCH, "ppc64") {
+		// Older linux kernels seem to have some hiccups delivering the signal
+		// in a timely manner on ppc64 and ppc64le. When running on a
+		// ppc64le/ubuntu 16.04/linux 4.4 host the time can vary quite
+		// substantially even on a idle system. 5 seconds is twice any value
+		// observed when running 10000 tests on such a system.
+		settleTime = 5 * time.Second
 	} else if s := os.Getenv("GO_TEST_TIMEOUT_SCALE"); s != "" {
 		if scale, err := strconv.Atoi(s); err == nil {
 			settleTime *= time.Duration(scale)
-- 
GitLab


From e15d1f4e641641363b8791c2caecc06a43c1c615 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Fri, 16 Apr 2021 21:50:46 -0400
Subject: [PATCH 1956/2400] internal/buildcfg: set Error instead of panicking

All build environment validation sets Error except for the
GOEXPERIMENT parser, which panics. Change it to also set Error so that
a bad GOEXPERIMENT doesn't cause everything that imports
internal/buildcfg to panic on init.

Change-Id: Ie9a506ef0978ecb410f2dcd784638f2167354175
Reviewed-on: https://go-review.googlesource.com/c/go/+/310970
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/internal/buildcfg/exp.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/internal/buildcfg/exp.go b/src/internal/buildcfg/exp.go
index ef769b5415..2435a79dce 100644
--- a/src/internal/buildcfg/exp.go
+++ b/src/internal/buildcfg/exp.go
@@ -108,10 +108,10 @@ func parseExperiments() goexperiment.Flags {
 	}
 	// Check regabi dependencies.
 	if flags.RegabiG && !flags.RegabiWrappers {
-		panic("GOEXPERIMENT regabig requires regabiwrappers")
+		Error = fmt.Errorf("GOEXPERIMENT regabig requires regabiwrappers")
 	}
 	if flags.RegabiArgs && !(flags.RegabiWrappers && flags.RegabiG && flags.RegabiReflect && flags.RegabiDefer) {
-		panic("GOEXPERIMENT regabiargs requires regabiwrappers,regabig,regabireflect,regabidefer")
+		Error = fmt.Errorf("GOEXPERIMENT regabiargs requires regabiwrappers,regabig,regabireflect,regabidefer")
 	}
 	return flags
 }
-- 
GitLab


From 8c3d217d89e718a5d9b7d8f4b1336907f15ea50c Mon Sep 17 00:00:00 2001
From: Richard Miller <miller.research@gmail.com>
Date: Tue, 4 May 2021 17:43:26 +0100
Subject: [PATCH 1957/2400] os: skip TestExecutableDeleted on plan9

This test deletes the running executable file, which is not safe
on Plan 9. The test was working by accident prior to commit 02ab8d1,
which must have changed the page reference ordering just enough to
cause a new demand page-in after deletion of the file.

Fixes #45941

Change-Id: Ic13d8032c21cee603e3afc3c5c4da6093fc37bf4
Reviewed-on: https://go-review.googlesource.com/c/go/+/316829
Reviewed-by: David du Colombier <0intro@gmail.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Trust: David du Colombier <0intro@gmail.com>
Run-TryBot: David du Colombier <0intro@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/os/executable_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/os/executable_test.go b/src/os/executable_test.go
index 9ff6327149..719d6a61c3 100644
--- a/src/os/executable_test.go
+++ b/src/os/executable_test.go
@@ -90,8 +90,8 @@ func init() {
 func TestExecutableDeleted(t *testing.T) {
 	testenv.MustHaveExec(t)
 	switch runtime.GOOS {
-	case "windows":
-		t.Skip("windows does not support deleting running binary")
+	case "windows", "plan9":
+		t.Skipf("%v does not support deleting running binary", runtime.GOOS)
 	case "openbsd", "freebsd", "aix":
 		t.Skipf("%v does not support reading deleted binary name", runtime.GOOS)
 	}
-- 
GitLab


From f62739b8611a0f1c96e59eb6574422562bb46233 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Tue, 4 May 2021 13:24:11 -0400
Subject: [PATCH 1958/2400] cmd/compile: establish regabi name/value mapping
 for small in-params

When the expand_calls phase in the SSA backend lowers prolog OpArg
values into OpArgIntReg/OpArgFloatReg values, we don't always record
the assocation between the new lowered value and the parameter name.

This patch handles the simple case where a given parameter fits into
exactly one register; in this scenario it makes sense to manufacture a
new pseudo-slot for the value that points to the param, and install
the slot/value mapping in the NamedValues table for the function. More
work will be needed to deal with params that span multiple registers;
that will need to be addressed in a subsequent patch.

This change improves the parameter error rate "optargorder" benchmark
by about 7-8% (when run on the optargorder binary).

Updates #45945.

Change-Id: Ic9adbe20b6f91145d49651348818f0f5cba92b18
Reviewed-on: https://go-review.googlesource.com/c/go/+/316890
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ssa/expand_calls.go | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index 39d0b61c2e..2852753bee 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -1714,6 +1714,21 @@ func (x *expandState) newArgToMemOrRegs(baseArg, toReplace *Value, offset int64,
 	} else {
 		w = baseArg.Block.NewValue0IA(pos, op, t, auxInt, aux)
 	}
+	// If we are creating an OpArgIntReg/OpArgFloatReg that
+	// corresponds to an in-param that fits entirely in a register,
+	// then enter it into the name/value table. The LocalSlot
+	// is somewhat fictitious, since there is no incoming live
+	// memory version of the parameter, but we need an entry in
+	// NamedValues in order for ssa debug tracking to include
+	// the value in the tracking analysis.
+	if len(pa.Registers) == 1 {
+		loc := LocalSlot{N: aux.Name, Type: t, Off: 0}
+		values, ok := x.f.NamedValues[loc]
+		if !ok {
+			x.f.Names = append(x.f.Names, loc)
+		}
+		x.f.NamedValues[loc] = append(values, w)
+	}
 	x.commonArgs[key] = w
 	if toReplace != nil {
 		toReplace.copyOf(w)
-- 
GitLab


From 10a082aa70fb58d92fc85769983d42110d61fad1 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Tue, 4 May 2021 15:57:45 -0400
Subject: [PATCH 1959/2400] cmd/go: update x/mod to fix "//indirect" comment
 editing

Fixes #45932

Change-Id: I043aecb6224348faf54c1d41fdbc00aa566089c2
Reviewed-on: https://go-review.googlesource.com/c/go/+/316751
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go.mod                                |  2 +-
 src/cmd/go.sum                                |  2 ++
 .../testdata/script/mod_indirect_nospace.txt  | 32 +++++++++++++++++++
 .../vendor/golang.org/x/mod/modfile/rule.go   |  4 +--
 .../vendor/golang.org/x/mod/module/module.go  |  2 +-
 src/cmd/vendor/modules.txt                    |  2 +-
 6 files changed, 39 insertions(+), 5 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/mod_indirect_nospace.txt

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index 79224db999..ebcfba62e5 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -7,7 +7,7 @@ require (
 	github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639 // indirect
 	golang.org/x/arch v0.0.0-20210502124803-cbf565b21d1e
 	golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e // indirect
-	golang.org/x/mod v0.4.3-0.20210503183026-4435ecfe4815
+	golang.org/x/mod v0.4.3-0.20210504181020-67f1c1edc27a
 	golang.org/x/sys v0.0.0-20210423082822-04245dca01da // indirect
 	golang.org/x/term v0.0.0-20210503060354-a79de5458b56
 	golang.org/x/tools v0.1.1-0.20210503200558-19b1717ea5eb
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 4ae0261d1c..38cd527efc 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -11,6 +11,8 @@ golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e h1:8foAy0aoO5GkqCvAEJ4VC4
 golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
 golang.org/x/mod v0.4.3-0.20210503183026-4435ecfe4815 h1:9nyskUepGPcX93addfTsdRqsQ7rSWIdQOdWVcsWAYv0=
 golang.org/x/mod v0.4.3-0.20210503183026-4435ecfe4815/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
+golang.org/x/mod v0.4.3-0.20210504181020-67f1c1edc27a h1:wbpC/7Wbo5WFVox32n+KjhRRLmTLq8YW/wRlL2iVAhk=
+golang.org/x/mod v0.4.3-0.20210504181020-67f1c1edc27a/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
 golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da h1:b3NXsE2LusjYGGjL5bxEVZZORm/YEFFrWFjR8eFrw/c=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
diff --git a/src/cmd/go/testdata/script/mod_indirect_nospace.txt b/src/cmd/go/testdata/script/mod_indirect_nospace.txt
new file mode 100644
index 0000000000..f4fb6a8c1b
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_indirect_nospace.txt
@@ -0,0 +1,32 @@
+# https://golang.org/issue/45932: "indirect" comments missing spaces
+# should not be corrupted when the comment is removed.
+
+go mod tidy
+cmp go.mod go.mod.direct
+
+-- go.mod --
+module example.net/m
+
+go 1.16
+
+require example.net/x v0.1.0 //indirect
+
+replace example.net/x v0.1.0 => ./x
+-- go.mod.direct --
+module example.net/m
+
+go 1.16
+
+require example.net/x v0.1.0
+
+replace example.net/x v0.1.0 => ./x
+-- m.go --
+package m
+import _ "example.net/x"
+
+-- x/go.mod --
+module example.net/x
+
+go 1.16
+-- x/x.go --
+package x
diff --git a/src/cmd/vendor/golang.org/x/mod/modfile/rule.go b/src/cmd/vendor/golang.org/x/mod/modfile/rule.go
index 3f603fa60f..d8242de280 100644
--- a/src/cmd/vendor/golang.org/x/mod/modfile/rule.go
+++ b/src/cmd/vendor/golang.org/x/mod/modfile/rule.go
@@ -505,8 +505,8 @@ func setIndirect(line *Line, indirect bool) {
 	}
 
 	// Removing comment.
-	f := strings.Fields(line.Suffix[0].Token)
-	if len(f) == 2 {
+	f := strings.TrimSpace(strings.TrimPrefix(line.Suffix[0].Token, string(slashSlash)))
+	if f == "indirect" {
 		// Remove whole comment.
 		line.Suffix = nil
 		return
diff --git a/src/cmd/vendor/golang.org/x/mod/module/module.go b/src/cmd/vendor/golang.org/x/mod/module/module.go
index cf69ff657a..ba97ac356e 100644
--- a/src/cmd/vendor/golang.org/x/mod/module/module.go
+++ b/src/cmd/vendor/golang.org/x/mod/module/module.go
@@ -393,7 +393,7 @@ func checkPath(path string, kind pathKind) error {
 	if path == "" {
 		return fmt.Errorf("empty string")
 	}
-	if path[0] == '-' {
+	if path[0] == '-' && kind != filePath {
 		return fmt.Errorf("leading dash")
 	}
 	if strings.Contains(path, "//") {
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index e9644883fc..a5dd28b7dc 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -28,7 +28,7 @@ golang.org/x/arch/x86/x86asm
 ## explicit; go 1.17
 golang.org/x/crypto/ed25519
 golang.org/x/crypto/ed25519/internal/edwards25519
-# golang.org/x/mod v0.4.3-0.20210503183026-4435ecfe4815
+# golang.org/x/mod v0.4.3-0.20210504181020-67f1c1edc27a
 ## explicit; go 1.17
 golang.org/x/mod/internal/lazyregexp
 golang.org/x/mod/modfile
-- 
GitLab


From d19e5493bd764e26a0662c06c858033a24eaa415 Mon Sep 17 00:00:00 2001
From: Dmitri Shuralyov <dmitshur@golang.org>
Date: Tue, 4 May 2021 12:53:52 -0400
Subject: [PATCH 1960/2400] doc/go1.17: require macOS 10.13 or later

For #44513.
For #23011.

Change-Id: Ic092e38da3601a43d7e2110f500db4a6a6f845f5
Reviewed-on: https://go-review.googlesource.com/c/go/+/316889
Trust: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Alexander Rakoczy <alex@golang.org>
Reviewed-by: Carlos Amedee <carlos@golang.org>
---
 doc/go1.17.html | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 6aa9d5b876..7993663838 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -31,8 +31,16 @@ Do not send CLs removing the interior tags from such phrases.
 
 <h2 id="ports">Ports</h2>
 
+<h3 id="darwin">Darwin</h3>
+
+<p><!-- golang.org/issue/23011 -->
+  As <a href="go1.16#darwin">announced</a> in the Go 1.16 release
+  notes, Go 1.17 requires macOS 10.13 High Sierra or later; support
+  for previous versions has been discontinued.
+</p>
+
 <p>
-  TODO: complete this section, or delete if not needed
+  TODO: complete the Ports section
 </p>
 
 <h2 id="tools">Tools</h2>
-- 
GitLab


From cd28ca3a4e130c88dd8f2d198050620b11d22ce4 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Tue, 4 May 2021 16:00:08 +0000
Subject: [PATCH 1961/2400] runtime: abort when receiving a signal on a non-Go
 thread on Windows

Currently if a signal lands on a non-Go thread that's handled by the Go
handler, Go will emit a message. However, unlike everywhere else in the
runtime, Go will not abort the process after, and the signal handler
will try to continue executing.

This leads to cascading failures and possibly even memory corruption.

For #45638.

Change-Id: I546f4e82f339d555bed295528d819ac883b92bc6
Reviewed-on: https://go-review.googlesource.com/c/go/+/316809
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/runtime/sys_windows_386.s   | 4 +++-
 src/runtime/sys_windows_amd64.s | 2 ++
 src/runtime/sys_windows_arm.s   | 4 ++--
 src/runtime/sys_windows_arm64.s | 4 +++-
 4 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/src/runtime/sys_windows_386.s b/src/runtime/sys_windows_386.s
index 64b12859ae..0b3933502a 100644
--- a/src/runtime/sys_windows_386.s
+++ b/src/runtime/sys_windows_386.s
@@ -58,7 +58,9 @@ TEXT	runtime·badsignal2(SB),NOSPLIT,$24
 	MOVL	DX, 12(SP)
 	MOVL	$0, 16(SP) // overlapped
 	CALL	*runtime·_WriteFile(SB)
-	MOVL	BP, SI
+
+	// Does not return.
+	CALL	runtime·abort(SB)
 	RET
 
 // faster get/set last error
diff --git a/src/runtime/sys_windows_amd64.s b/src/runtime/sys_windows_amd64.s
index e5e2083be2..e7782846b2 100644
--- a/src/runtime/sys_windows_amd64.s
+++ b/src/runtime/sys_windows_amd64.s
@@ -96,6 +96,8 @@ TEXT runtime·badsignal2(SB),NOSPLIT|NOFRAME,$48
 	MOVQ	runtime·_WriteFile(SB), AX
 	CALL	AX
 
+	// Does not return.
+	CALL	runtime·abort(SB)
 	RET
 
 // faster get/set last error
diff --git a/src/runtime/sys_windows_arm.s b/src/runtime/sys_windows_arm.s
index 189d2f6780..48f8c7dedf 100644
--- a/src/runtime/sys_windows_arm.s
+++ b/src/runtime/sys_windows_arm.s
@@ -97,8 +97,8 @@ TEXT runtime·badsignal2(SB),NOSPLIT|NOFRAME,$0
 	MOVW	runtime·_WriteFile(SB), R12
 	BL	(R12)
 
-	MOVW	R4, R13			// restore SP
-	MOVM.IA.W (R13), [R4, R15]	// pop {r4, pc}
+	// Does not return.
+	B	runtime·abort(SB)
 
 TEXT runtime·getlasterror(SB),NOSPLIT,$0
 	MRC	15, 0, R0, C13, C0, 2
diff --git a/src/runtime/sys_windows_arm64.s b/src/runtime/sys_windows_arm64.s
index 33ac091e12..7a2e11f5ae 100644
--- a/src/runtime/sys_windows_arm64.s
+++ b/src/runtime/sys_windows_arm64.s
@@ -117,7 +117,9 @@ TEXT runtime·badsignal2(SB),NOSPLIT,$16-0
 	MOVD	runtime·_WriteFile(SB), R12
 	SUB	$16, RSP	// skip over saved frame pointer below RSP
 	BL	(R12)
-	ADD	$16, RSP
+
+	// Does not return.
+	B	runtime·abort(SB)
 
 	RET
 
-- 
GitLab


From 6a6aa3278356e850f7530e75e857f539bf8cb51e Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Tue, 4 May 2021 16:37:29 -0400
Subject: [PATCH 1962/2400] cmd/go: add a test that reproduces the internal
 error in #45952

For #45952

Change-Id: I90e895e2fd10bccd947f9ee5133f942fea218a07
Reviewed-on: https://go-review.googlesource.com/c/go/+/316753
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 .../go/testdata/script/mod_tidy_newroot.txt   | 66 +++++++++++++++++++
 1 file changed, 66 insertions(+)
 create mode 100644 src/cmd/go/testdata/script/mod_tidy_newroot.txt

diff --git a/src/cmd/go/testdata/script/mod_tidy_newroot.txt b/src/cmd/go/testdata/script/mod_tidy_newroot.txt
new file mode 100644
index 0000000000..db23a21e5b
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_tidy_newroot.txt
@@ -0,0 +1,66 @@
+# https://golang.org/issue/45952: 'go mod tidy' in an eager module failed due
+# to an erroneous check on root completeness.
+#
+# Per the issue report:
+# > It may have to do with:
+# >
+# > package A imports package B in go.mod, which imports package C in its own go.mod
+# > package A drops direct dependency on package B …
+#
+# We infer from that that package C is still needed by some other indirect
+# dependency, and must be at a higher version than what is required by that
+# dependency (or else no new root would be needed). An additional package D
+# in its own module satisfies that condition, reproducing the bug.
+
+! go mod tidy
+stderr 'internal error'
+
+-- go.mod --
+module example.net/a
+
+go 1.16
+
+require (
+	example.net/b v0.1.0
+	example.net/d v0.1.0
+)
+
+replace (
+	example.net/b v0.1.0 => ./b
+	example.net/c v0.1.0 => ./c
+	example.net/c v0.2.0 => ./c
+	example.net/d v0.1.0 => ./d
+)
+-- a.go --
+package a
+
+import _ "example.net/d"
+
+-- b/go.mod --
+module example.net/b
+
+go 1.16
+
+require example.net/c v0.2.0
+-- b/b.go --
+package b
+
+import _ "example.net/c"
+
+-- c/go.mod --
+module example.net/c
+
+go 1.16
+-- c/c.go --
+package c
+
+-- d/go.mod --
+module example.net/d
+
+go 1.16
+
+require example.net/c v0.1.0
+-- d/d.go --
+package d
+
+import _ "example.net/c"
-- 
GitLab


From 62a87f64b97d27e79d53a84e9006425aa234d7e6 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Tue, 4 May 2021 16:41:13 -0400
Subject: [PATCH 1963/2400] cmd/go/internal/modload: only check root-promotion
 during tidy for lazy modules

In a lazy module, it is important that tidyRoots does not add any new
roots because the dependencies of non-roots are pruned out.

In an eager module, that property is not important (and does not hold
in general) because no dependencies are ever pruned out.

Fixes #45952

Change-Id: I5c95b5696b7112b9219e38af04e0dece7fb6e202
Reviewed-on: https://go-review.googlesource.com/c/go/+/316754
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modload/load.go           | 18 ++++++++++-------
 .../go/testdata/script/mod_tidy_newroot.txt   | 20 +++++++++++++++++--
 2 files changed, 29 insertions(+), 9 deletions(-)

diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index f434b399d8..c811029ab5 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -1065,13 +1065,17 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 			ld.errorf("go: %v\n", err)
 		}
 
-		// We continuously add tidy roots to ld.requirements during loading, so at
-		// this point the tidy roots should be a subset of the roots of
-		// ld.requirements. If not, there is a bug in the loading loop above.
-		for _, m := range rs.rootModules {
-			if v, ok := ld.requirements.rootSelected(m.Path); !ok || v != m.Version {
-				ld.errorf("go: internal error: a requirement on %v is needed but was not added during package loading\n", m)
-				base.ExitIfErrors()
+		if ld.requirements.depth == lazy {
+			// We continuously add tidy roots to ld.requirements during loading, so at
+			// this point the tidy roots should be a subset of the roots of
+			// ld.requirements, ensuring that no new dependencies are brought inside
+			// the lazy-loading horizon.
+			// If that is not the case, there is a bug in the loading loop above.
+			for _, m := range rs.rootModules {
+				if v, ok := ld.requirements.rootSelected(m.Path); !ok || v != m.Version {
+					ld.errorf("go: internal error: a requirement on %v is needed but was not added during package loading\n", m)
+					base.ExitIfErrors()
+				}
 			}
 		}
 		ld.requirements = rs
diff --git a/src/cmd/go/testdata/script/mod_tidy_newroot.txt b/src/cmd/go/testdata/script/mod_tidy_newroot.txt
index db23a21e5b..3abd5ef08a 100644
--- a/src/cmd/go/testdata/script/mod_tidy_newroot.txt
+++ b/src/cmd/go/testdata/script/mod_tidy_newroot.txt
@@ -12,8 +12,8 @@
 # dependency (or else no new root would be needed). An additional package D
 # in its own module satisfies that condition, reproducing the bug.
 
-! go mod tidy
-stderr 'internal error'
+go mod tidy
+cmp go.mod go.mod.tidy
 
 -- go.mod --
 module example.net/a
@@ -25,6 +25,22 @@ require (
 	example.net/d v0.1.0
 )
 
+replace (
+	example.net/b v0.1.0 => ./b
+	example.net/c v0.1.0 => ./c
+	example.net/c v0.2.0 => ./c
+	example.net/d v0.1.0 => ./d
+)
+-- go.mod.tidy --
+module example.net/a
+
+go 1.16
+
+require (
+	example.net/c v0.2.0 // indirect
+	example.net/d v0.1.0
+)
+
 replace (
 	example.net/b v0.1.0 => ./b
 	example.net/c v0.1.0 => ./c
-- 
GitLab


From cb0658e624e33ca3e96036dbdd48b1282acb189d Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 4 May 2021 15:07:37 -0700
Subject: [PATCH 1964/2400] go/types: expose more API under -tags=typeparams

Updates #44933.

Change-Id: I0c4c2a54f67b47771f4fa59f11c47fa7b0dde799
Reviewed-on: https://go-review.googlesource.com/c/go/+/317029
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/go/types/api_typeparams.go | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/src/go/types/api_typeparams.go b/src/go/types/api_typeparams.go
index 108e526fbf..639bc3b3bf 100644
--- a/src/go/types/api_typeparams.go
+++ b/src/go/types/api_typeparams.go
@@ -11,7 +11,11 @@ import (
 	"go/ast"
 )
 
-type Inferred = _Inferred
+type (
+	Inferred  = _Inferred
+	Sum       = _Sum
+	TypeParam = _TypeParam
+)
 
 func GetInferred(info *Info) map[ast.Expr]Inferred {
 	return info._Inferred
@@ -20,3 +24,16 @@ func GetInferred(info *Info) map[ast.Expr]Inferred {
 func SetInferred(info *Info, inferred map[ast.Expr]Inferred) {
 	info._Inferred = inferred
 }
+
+func NewSum(types []Type) Type { return _NewSum(types) }
+
+func (s *Signature) TParams() []*TypeName           { return s._TParams() }
+func (s *Signature) SetTParams(tparams []*TypeName) { s._SetTParams(tparams) }
+
+func (t *Interface) HasTypeList() bool  { return t._HasTypeList() }
+func (t *Interface) IsComparable() bool { return t._IsComparable() }
+func (t *Interface) IsConstraint() bool { return t._IsConstraint() }
+
+func (t *Named) TParams() []*TypeName { return t._TParams() }
+func (t *Named) TArgs() []Type        { return t._TArgs() }
+func (t *Named) SetTArgs(args []Type) { t._SetTArgs(args) }
-- 
GitLab


From 137be7712f479dc820ef56c818913a98fa24b80e Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Mon, 19 Apr 2021 12:20:18 -0700
Subject: [PATCH 1965/2400] embed/internal/embedtest: add test for embedded
 path starting with dash

Fixes #45447

Change-Id: I1b1a0a844ee4345ced1a007bbe53db035183175f
Reviewed-on: https://go-review.googlesource.com/c/go/+/311529
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/embed/internal/embedtest/embed_test.go                    | 4 ++--
 src/embed/internal/embedtest/testdata/-not-hidden/fortune.txt | 2 ++
 2 files changed, 4 insertions(+), 2 deletions(-)
 create mode 100644 src/embed/internal/embedtest/testdata/-not-hidden/fortune.txt

diff --git a/src/embed/internal/embedtest/embed_test.go b/src/embed/internal/embedtest/embed_test.go
index 43ae5c7e05..2d50f5e01f 100644
--- a/src/embed/internal/embedtest/embed_test.go
+++ b/src/embed/internal/embedtest/embed_test.go
@@ -102,12 +102,12 @@ func TestHidden(t *testing.T) {
 	t.Logf("//go:embed testdata")
 
 	testDir(t, dir, "testdata",
-		"ascii.txt", "glass.txt", "hello.txt", "i/", "ken.txt")
+		"-not-hidden/", "ascii.txt", "glass.txt", "hello.txt", "i/", "ken.txt")
 
 	t.Logf("//go:embed testdata/*")
 
 	testDir(t, star, "testdata",
-		".hidden/", "_hidden/", "ascii.txt", "glass.txt", "hello.txt", "i/", "ken.txt")
+		"-not-hidden/", ".hidden/", "_hidden/", "ascii.txt", "glass.txt", "hello.txt", "i/", "ken.txt")
 
 	testDir(t, star, "testdata/.hidden",
 		"fortune.txt", "more/") // but not .more or _more
diff --git a/src/embed/internal/embedtest/testdata/-not-hidden/fortune.txt b/src/embed/internal/embedtest/testdata/-not-hidden/fortune.txt
new file mode 100644
index 0000000000..31f2013f94
--- /dev/null
+++ b/src/embed/internal/embedtest/testdata/-not-hidden/fortune.txt
@@ -0,0 +1,2 @@
+WARNING: terminal is not fully functional
+ -  (press RETURN)
-- 
GitLab


From bb5e45219af69135c389c6b68f9a67207bb32e05 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Tue, 4 May 2021 20:54:25 -0400
Subject: [PATCH 1966/2400] cmd/go.sum: remove untidy checksums
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

I missed the 'go mod tidy' step in CL 316751 because I forgot to run
the cmd/internal/moddeps test in long mode. 😞

Updates #45932

Change-Id: Ic3f9b303ad5798ecd8cb044d4b8c766aa820bf69
Reviewed-on: https://go-review.googlesource.com/c/go/+/317129
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Reviewed-by: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go.sum | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 38cd527efc..1f64b4aae3 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -9,8 +9,6 @@ golang.org/x/arch v0.0.0-20210502124803-cbf565b21d1e h1:pv3V0NlNSh5Q6AX/StwGLBjc
 golang.org/x/arch v0.0.0-20210502124803-cbf565b21d1e/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
 golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e h1:8foAy0aoO5GkqCvAEJ4VC4P3zksTg4X4aJCDpZzmgQI=
 golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
-golang.org/x/mod v0.4.3-0.20210503183026-4435ecfe4815 h1:9nyskUepGPcX93addfTsdRqsQ7rSWIdQOdWVcsWAYv0=
-golang.org/x/mod v0.4.3-0.20210503183026-4435ecfe4815/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
 golang.org/x/mod v0.4.3-0.20210504181020-67f1c1edc27a h1:wbpC/7Wbo5WFVox32n+KjhRRLmTLq8YW/wRlL2iVAhk=
 golang.org/x/mod v0.4.3-0.20210504181020-67f1c1edc27a/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
 golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-- 
GitLab


From 4df662fb373480b5055e645120558bb536fae42c Mon Sep 17 00:00:00 2001
From: Philipp Sauter <sauterp@protonmail.com>
Date: Sun, 8 Nov 2020 22:12:38 +0100
Subject: [PATCH 1967/2400] cmd/go: don't crash when running "go version" in
 deleted directory

If the go command is executed on Linux in a deleted directory,
it fails. This behavior is reasonable for commands which depend on
the CWD, but it's unexpected for commands like `go version`.
This change delays initialization of a global CWD variable.

Fixed #34499

Change-Id: I7302fb84a3b7f5f149a123d277abd5b9b5bc95b2
Reviewed-on: https://go-review.googlesource.com/c/go/+/268261
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Trust: Bryan C. Mills <bcmills@google.com>
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/go_test.go                  | 22 ++++++++++++++++++++++
 src/cmd/go/internal/base/path.go       | 26 ++++++++++++++++----------
 src/cmd/go/internal/envcmd/env.go      |  2 +-
 src/cmd/go/internal/fsys/fsys.go       |  2 +-
 src/cmd/go/internal/get/get.go         |  2 +-
 src/cmd/go/internal/load/flag.go       |  2 +-
 src/cmd/go/internal/load/pkg.go        |  8 ++++----
 src/cmd/go/internal/modload/init.go    | 14 +++++++-------
 src/cmd/go/internal/modload/load.go    |  6 +++---
 src/cmd/go/internal/search/search.go   |  2 +-
 src/cmd/go/internal/test/cover.go      |  4 ++--
 src/cmd/go/internal/test/test.go       |  8 ++++----
 src/cmd/go/internal/test/testflag.go   | 25 ++++++++++++++++---------
 src/cmd/go/internal/work/action.go     |  6 +++---
 src/cmd/go/internal/work/build_test.go |  3 ++-
 src/cmd/go/internal/work/exec.go       |  4 ++--
 src/cmd/go/internal/work/gc.go         |  2 +-
 src/cmd/go/internal/work/gccgo.go      | 10 +++++-----
 src/cmd/go/internal/work/init.go       |  2 +-
 19 files changed, 93 insertions(+), 57 deletions(-)

diff --git a/src/cmd/go/go_test.go b/src/cmd/go/go_test.go
index 5a657bcfca..ff397a1995 100644
--- a/src/cmd/go/go_test.go
+++ b/src/cmd/go/go_test.go
@@ -2832,3 +2832,25 @@ func TestCoverpkgTestOnly(t *testing.T) {
 	tg.grepStderrNot("no packages being tested depend on matches", "bad match message")
 	tg.grepStdout("coverage: 100", "no coverage")
 }
+
+// Regression test for golang.org/issue/34499: version command should not crash
+// when executed in a deleted directory on Linux.
+func TestExecInDeletedDir(t *testing.T) {
+	// The crash has only been reproduced on Linux.
+	if runtime.GOOS == "windows" || runtime.GOOS == "plan9" {
+		t.Skip()
+	}
+	tg := testgo(t)
+	defer tg.cleanup()
+
+	wd, err := os.Getwd()
+	tg.check(err)
+	tg.makeTempdir()
+	tg.check(os.Chdir(tg.tempdir))
+	defer func() { tg.check(os.Chdir(wd)) }()
+
+	tg.check(os.Remove(tg.tempdir))
+
+	// `go version` should not fail
+	tg.run("version")
+}
diff --git a/src/cmd/go/internal/base/path.go b/src/cmd/go/internal/base/path.go
index cb4adbde42..4d8715ef5f 100644
--- a/src/cmd/go/internal/base/path.go
+++ b/src/cmd/go/internal/base/path.go
@@ -8,21 +8,27 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 )
 
-func getwd() string {
-	wd, err := os.Getwd()
-	if err != nil {
-		Fatalf("cannot determine current directory: %v", err)
-	}
-	return wd
-}
+var cwd string
+var cwdOnce sync.Once
 
-var Cwd = getwd()
+// Cwd returns the current working directory at the time of the first call.
+func Cwd() string {
+	cwdOnce.Do(func() {
+		var err error
+		cwd, err = os.Getwd()
+		if err != nil {
+			Fatalf("cannot determine current directory: %v", err)
+		}
+	})
+	return cwd
+}
 
 // ShortPath returns an absolute or relative name for path, whatever is shorter.
 func ShortPath(path string) string {
-	if rel, err := filepath.Rel(Cwd, path); err == nil && len(rel) < len(path) {
+	if rel, err := filepath.Rel(Cwd(), path); err == nil && len(rel) < len(path) {
 		return rel
 	}
 	return path
@@ -33,7 +39,7 @@ func ShortPath(path string) string {
 func RelPaths(paths []string) []string {
 	var out []string
 	for _, p := range paths {
-		rel, err := filepath.Rel(Cwd, p)
+		rel, err := filepath.Rel(Cwd(), p)
 		if err == nil && len(rel) < len(p) {
 			p = rel
 		}
diff --git a/src/cmd/go/internal/envcmd/env.go b/src/cmd/go/internal/envcmd/env.go
index 8dbb8af1e7..b30c37ab27 100644
--- a/src/cmd/go/internal/envcmd/env.go
+++ b/src/cmd/go/internal/envcmd/env.go
@@ -200,7 +200,7 @@ func runEnv(ctx context.Context, cmd *base.Command, args []string) {
 	env := cfg.CmdEnv
 	env = append(env, ExtraEnvVars()...)
 
-	if err := fsys.Init(base.Cwd); err != nil {
+	if err := fsys.Init(base.Cwd()); err != nil {
 		base.Fatalf("go: %v", err)
 	}
 
diff --git a/src/cmd/go/internal/fsys/fsys.go b/src/cmd/go/internal/fsys/fsys.go
index ae10946fb1..0b806027e6 100644
--- a/src/cmd/go/internal/fsys/fsys.go
+++ b/src/cmd/go/internal/fsys/fsys.go
@@ -44,7 +44,7 @@ func (n *node) isDeleted() bool {
 
 // TODO(matloob): encapsulate these in an io/fs-like interface
 var overlay map[string]*node // path -> file or directory node
-var cwd string               // copy of base.Cwd to avoid dependency
+var cwd string               // copy of base.Cwd() to avoid dependency
 
 // Canonicalize a path for looking it up in the overlay.
 // Important: filepath.Join(cwd, path) doesn't always produce
diff --git a/src/cmd/go/internal/get/get.go b/src/cmd/go/internal/get/get.go
index c28bce8cfc..3c16dc3040 100644
--- a/src/cmd/go/internal/get/get.go
+++ b/src/cmd/go/internal/get/get.go
@@ -258,7 +258,7 @@ func download(arg string, parent *load.Package, stk *load.ImportStack, mode int)
 	load1 := func(path string, mode int) *load.Package {
 		if parent == nil {
 			mode := 0 // don't do module or vendor resolution
-			return load.LoadImport(context.TODO(), load.PackageOpts{}, path, base.Cwd, nil, stk, nil, mode)
+			return load.LoadImport(context.TODO(), load.PackageOpts{}, path, base.Cwd(), nil, stk, nil, mode)
 		}
 		return load.LoadImport(context.TODO(), load.PackageOpts{}, path, parent.Dir, parent, stk, nil, mode|load.ResolveModule)
 	}
diff --git a/src/cmd/go/internal/load/flag.go b/src/cmd/go/internal/load/flag.go
index 7534e65f54..440cb86134 100644
--- a/src/cmd/go/internal/load/flag.go
+++ b/src/cmd/go/internal/load/flag.go
@@ -34,7 +34,7 @@ type ppfValue struct {
 
 // Set is called each time the flag is encountered on the command line.
 func (f *PerPackageFlag) Set(v string) error {
-	return f.set(v, base.Cwd)
+	return f.set(v, base.Cwd())
 }
 
 // set is the implementation of Set, taking a cwd (current working directory) for easier testing.
diff --git a/src/cmd/go/internal/load/pkg.go b/src/cmd/go/internal/load/pkg.go
index 2d91d10583..153399d83e 100644
--- a/src/cmd/go/internal/load/pkg.go
+++ b/src/cmd/go/internal/load/pkg.go
@@ -603,7 +603,7 @@ func ReloadPackageNoFlags(arg string, stk *ImportStack) *Package {
 		})
 		packageDataCache.Delete(p.ImportPath)
 	}
-	return LoadImport(context.TODO(), PackageOpts{}, arg, base.Cwd, nil, stk, nil, 0)
+	return LoadImport(context.TODO(), PackageOpts{}, arg, base.Cwd(), nil, stk, nil, 0)
 }
 
 // dirToImportPath returns the pseudo-import path we use for a package
@@ -991,7 +991,7 @@ func (pre *preload) preloadMatches(ctx context.Context, opts PackageOpts, matche
 			case pre.sema <- struct{}{}:
 				go func(pkg string) {
 					mode := 0 // don't use vendoring or module import resolution
-					bp, loaded, err := loadPackageData(ctx, pkg, "", base.Cwd, "", false, mode)
+					bp, loaded, err := loadPackageData(ctx, pkg, "", base.Cwd(), "", false, mode)
 					<-pre.sema
 					if bp != nil && loaded && err == nil && !opts.IgnoreImports {
 						pre.preloadImports(ctx, opts, bp.Imports, bp)
@@ -2456,7 +2456,7 @@ func PackagesAndErrors(ctx context.Context, opts PackageOpts, patterns []string)
 			if pkg == "" {
 				panic(fmt.Sprintf("ImportPaths returned empty package for pattern %s", m.Pattern()))
 			}
-			p := loadImport(ctx, opts, pre, pkg, base.Cwd, nil, &stk, nil, 0)
+			p := loadImport(ctx, opts, pre, pkg, base.Cwd(), nil, &stk, nil, 0)
 			p.Match = append(p.Match, m.Pattern())
 			p.Internal.CmdlinePkg = true
 			if m.IsLiteral() {
@@ -2670,7 +2670,7 @@ func GoFilesPackage(ctx context.Context, opts PackageOpts, gofiles []string) *Pa
 
 	var err error
 	if dir == "" {
-		dir = base.Cwd
+		dir = base.Cwd()
 	}
 	dir, err = filepath.Abs(dir)
 	if err != nil {
diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index 99c0c2b981..5cdea12cd3 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -135,7 +135,7 @@ func Init() {
 		return
 	}
 
-	if err := fsys.Init(base.Cwd); err != nil {
+	if err := fsys.Init(base.Cwd()); err != nil {
 		base.Fatalf("go: %v", err)
 	}
 
@@ -179,7 +179,7 @@ func Init() {
 		}
 		modRoot = ""
 	} else {
-		modRoot = findModuleRoot(base.Cwd)
+		modRoot = findModuleRoot(base.Cwd())
 		if modRoot == "" {
 			if cfg.ModFile != "" {
 				base.Fatalf("go: cannot find main module, but -modfile was set.\n\t-modfile cannot be used to set the module root directory.")
@@ -276,7 +276,7 @@ func WillBeEnabled() bool {
 		return false
 	}
 
-	if modRoot := findModuleRoot(base.Cwd); modRoot == "" {
+	if modRoot := findModuleRoot(base.Cwd()); modRoot == "" {
 		// GO111MODULE is 'auto', and we can't find a module root.
 		// Stay in GOPATH mode.
 		return false
@@ -335,8 +335,8 @@ func die() {
 	if cfg.Getenv("GO111MODULE") == "off" {
 		base.Fatalf("go: modules disabled by GO111MODULE=off; see 'go help modules'")
 	}
-	if dir, name := findAltConfig(base.Cwd); dir != "" {
-		rel, err := filepath.Rel(base.Cwd, dir)
+	if dir, name := findAltConfig(base.Cwd()); dir != "" {
+		rel, err := filepath.Rel(base.Cwd(), dir)
 		if err != nil {
 			rel = dir
 		}
@@ -479,7 +479,7 @@ func loadModFile(ctx context.Context) (rs *Requirements, needCommit bool) {
 // exactly the same as in the legacy configuration (for example, we can't get
 // packages at multiple versions from the same module).
 func CreateModFile(ctx context.Context, modPath string) {
-	modRoot = base.Cwd
+	modRoot = base.Cwd()
 	Init()
 	modFilePath := ModFilePath()
 	if _, err := fsys.Stat(modFilePath); err == nil {
@@ -646,7 +646,7 @@ func initTarget(m module.Version) {
 	Target = m
 	targetPrefix = m.Path
 
-	if rel := search.InDir(base.Cwd, cfg.GOROOTsrc); rel != "" {
+	if rel := search.InDir(base.Cwd(), cfg.GOROOTsrc); rel != "" {
 		targetInGorootSrc = true
 		if m.Path == "std" {
 			// The "std" module in GOROOT/src is the Go standard library. Unlike other
diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index c811029ab5..f30ac6e0c8 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -407,7 +407,7 @@ func matchLocalDirs(ctx context.Context, m *search.Match, rs *Requirements) {
 		dir := filepath.Dir(filepath.Clean(m.Pattern()[:i+3]))
 		absDir := dir
 		if !filepath.IsAbs(dir) {
-			absDir = filepath.Join(base.Cwd, dir)
+			absDir = filepath.Join(base.Cwd(), dir)
 		}
 		if search.InDir(absDir, cfg.GOROOTsrc) == "" && search.InDir(absDir, ModRoot()) == "" && pathInModuleCache(ctx, absDir, rs) == "" {
 			m.Dirs = []string{}
@@ -425,7 +425,7 @@ func resolveLocalPackage(ctx context.Context, dir string, rs *Requirements) (str
 	if filepath.IsAbs(dir) {
 		absDir = filepath.Clean(dir)
 	} else {
-		absDir = filepath.Join(base.Cwd, dir)
+		absDir = filepath.Join(base.Cwd(), dir)
 	}
 
 	bp, err := cfg.BuildContext.ImportDir(absDir, 0)
@@ -632,7 +632,7 @@ func DirImportPath(ctx context.Context, dir string) string {
 	LoadModFile(ctx) // Sets targetPrefix.
 
 	if !filepath.IsAbs(dir) {
-		dir = filepath.Join(base.Cwd, dir)
+		dir = filepath.Join(base.Cwd(), dir)
 	} else {
 		dir = filepath.Clean(dir)
 	}
diff --git a/src/cmd/go/internal/search/search.go b/src/cmd/go/internal/search/search.go
index f1152080a7..a0c806a259 100644
--- a/src/cmd/go/internal/search/search.go
+++ b/src/cmd/go/internal/search/search.go
@@ -445,7 +445,7 @@ func ImportPathsQuiet(patterns []string) []*Match {
 			for i, dir := range m.Dirs {
 				absDir := dir
 				if !filepath.IsAbs(dir) {
-					absDir = filepath.Join(base.Cwd, dir)
+					absDir = filepath.Join(base.Cwd(), dir)
 				}
 				if bp, _ := cfg.BuildContext.ImportDir(absDir, build.FindOnly); bp.ImportPath != "" && bp.ImportPath != "." {
 					m.Pkgs[i] = bp.ImportPath
diff --git a/src/cmd/go/internal/test/cover.go b/src/cmd/go/internal/test/cover.go
index 9841791552..657d22a6b4 100644
--- a/src/cmd/go/internal/test/cover.go
+++ b/src/cmd/go/internal/test/cover.go
@@ -26,8 +26,8 @@ func initCoverProfile() {
 	if testCoverProfile == "" || testC {
 		return
 	}
-	if !filepath.IsAbs(testCoverProfile) && testOutputDir != "" {
-		testCoverProfile = filepath.Join(testOutputDir, testCoverProfile)
+	if !filepath.IsAbs(testCoverProfile) {
+		testCoverProfile = filepath.Join(testOutputDir.getAbs(), testCoverProfile)
 	}
 
 	// No mutex - caller's responsibility to call with no racing goroutines.
diff --git a/src/cmd/go/internal/test/test.go b/src/cmd/go/internal/test/test.go
index c2f8aed004..59ea1ef544 100644
--- a/src/cmd/go/internal/test/test.go
+++ b/src/cmd/go/internal/test/test.go
@@ -486,7 +486,7 @@ var (
 	testJSON         bool                              // -json flag
 	testList         string                            // -list flag
 	testO            string                            // -o flag
-	testOutputDir    = base.Cwd                        // -outputdir flag
+	testOutputDir    outputdirFlag                     // -outputdir flag
 	testShuffle      shuffleFlag                       // -shuffle flag
 	testTimeout      time.Duration                     // -timeout flag
 	testV            bool                              // -v flag
@@ -710,7 +710,7 @@ func runTest(ctx context.Context, cmd *base.Command, args []string) {
 		match := make([]func(*load.Package) bool, len(testCoverPaths))
 		matched := make([]bool, len(testCoverPaths))
 		for i := range testCoverPaths {
-			match[i] = load.MatchPackage(testCoverPaths[i], base.Cwd)
+			match[i] = load.MatchPackage(testCoverPaths[i], base.Cwd())
 		}
 
 		// Select for coverage all dependencies matching the testCoverPaths patterns.
@@ -945,11 +945,11 @@ func builderTest(b *work.Builder, ctx context.Context, pkgOpts load.PackageOpts,
 	var installAction, cleanAction *work.Action
 	if testC || testNeedBinary() {
 		// -c or profiling flag: create action to copy binary to ./test.out.
-		target := filepath.Join(base.Cwd, testBinary+cfg.ExeSuffix)
+		target := filepath.Join(base.Cwd(), testBinary+cfg.ExeSuffix)
 		if testO != "" {
 			target = testO
 			if !filepath.IsAbs(target) {
-				target = filepath.Join(base.Cwd, target)
+				target = filepath.Join(base.Cwd(), target)
 			}
 		}
 		if target == os.DevNull {
diff --git a/src/cmd/go/internal/test/testflag.go b/src/cmd/go/internal/test/testflag.go
index 6ed96a36d0..08f1efa2c0 100644
--- a/src/cmd/go/internal/test/testflag.go
+++ b/src/cmd/go/internal/test/testflag.go
@@ -62,7 +62,7 @@ func init() {
 	cf.String("memprofilerate", "", "")
 	cf.StringVar(&testMutexProfile, "mutexprofile", "", "")
 	cf.String("mutexprofilefraction", "", "")
-	cf.Var(outputdirFlag{&testOutputDir}, "outputdir", "")
+	cf.Var(&testOutputDir, "outputdir", "")
 	cf.Int("parallel", 0, "")
 	cf.String("run", "", "")
 	cf.Bool("short", false, "")
@@ -71,7 +71,7 @@ func init() {
 	cf.BoolVar(&testV, "v", false, "")
 	cf.Var(&testShuffle, "shuffle", "")
 
-	for name, _ := range passFlagToTest {
+	for name := range passFlagToTest {
 		cf.Var(cf.Lookup(name).Value, "test."+name, "")
 	}
 }
@@ -128,19 +128,26 @@ func (f stringFlag) Set(value string) error {
 // outputdirFlag implements the -outputdir flag.
 // It interprets an empty value as the working directory of the 'go' command.
 type outputdirFlag struct {
-	resolved *string
+	abs string
 }
 
-func (f outputdirFlag) String() string { return *f.resolved }
-func (f outputdirFlag) Set(value string) (err error) {
+func (f *outputdirFlag) String() string {
+	return f.abs
+}
+func (f *outputdirFlag) Set(value string) (err error) {
 	if value == "" {
-		// The empty string implies the working directory of the 'go' command.
-		*f.resolved = base.Cwd
+		f.abs = ""
 	} else {
-		*f.resolved, err = filepath.Abs(value)
+		f.abs, err = filepath.Abs(value)
 	}
 	return err
 }
+func (f *outputdirFlag) getAbs() string {
+	if f.abs == "" {
+		return base.Cwd()
+	}
+	return f.abs
+}
 
 // vetFlag implements the special parsing logic for the -vet flag:
 // a comma-separated list, with a distinguished value "off" and
@@ -404,7 +411,7 @@ func testFlags(args []string) (packageNames, passToTest []string) {
 	// command. Set it explicitly if it is needed due to some other flag that
 	// requests output.
 	if testProfile() != "" && !outputDirSet {
-		injectedFlags = append(injectedFlags, "-test.outputdir="+testOutputDir)
+		injectedFlags = append(injectedFlags, "-test.outputdir="+testOutputDir.getAbs())
 	}
 
 	// If the user is explicitly passing -help or -h, show output
diff --git a/src/cmd/go/internal/work/action.go b/src/cmd/go/internal/work/action.go
index 9d141ae233..69940cb001 100644
--- a/src/cmd/go/internal/work/action.go
+++ b/src/cmd/go/internal/work/action.go
@@ -344,7 +344,7 @@ func readpkglist(shlibpath string) (pkgs []*load.Package) {
 			if strings.HasPrefix(t, "pkgpath ") {
 				t = strings.TrimPrefix(t, "pkgpath ")
 				t = strings.TrimSuffix(t, ";")
-				pkgs = append(pkgs, load.LoadImportWithFlags(t, base.Cwd, nil, &stk, nil, 0))
+				pkgs = append(pkgs, load.LoadImportWithFlags(t, base.Cwd(), nil, &stk, nil, 0))
 			}
 		}
 	} else {
@@ -355,7 +355,7 @@ func readpkglist(shlibpath string) (pkgs []*load.Package) {
 		scanner := bufio.NewScanner(bytes.NewBuffer(pkglistbytes))
 		for scanner.Scan() {
 			t := scanner.Text()
-			pkgs = append(pkgs, load.LoadImportWithFlags(t, base.Cwd, nil, &stk, nil, 0))
+			pkgs = append(pkgs, load.LoadImportWithFlags(t, base.Cwd(), nil, &stk, nil, 0))
 		}
 	}
 	return
@@ -776,7 +776,7 @@ func (b *Builder) linkSharedAction(mode, depMode BuildMode, shlib string, a1 *Ac
 					}
 				}
 				var stk load.ImportStack
-				p := load.LoadImportWithFlags(pkg, base.Cwd, nil, &stk, nil, 0)
+				p := load.LoadImportWithFlags(pkg, base.Cwd(), nil, &stk, nil, 0)
 				if p.Error != nil {
 					base.Fatalf("load %s: %v", pkg, p.Error)
 				}
diff --git a/src/cmd/go/internal/work/build_test.go b/src/cmd/go/internal/work/build_test.go
index eaf2639e9e..600fc3083f 100644
--- a/src/cmd/go/internal/work/build_test.go
+++ b/src/cmd/go/internal/work/build_test.go
@@ -173,10 +173,11 @@ func TestSharedLibName(t *testing.T) {
 				if err != nil {
 					t.Fatal(err)
 				}
+				cwd := base.Cwd()
 				oldGopath := cfg.BuildContext.GOPATH
 				defer func() {
 					cfg.BuildContext.GOPATH = oldGopath
-					os.Chdir(base.Cwd)
+					os.Chdir(cwd)
 					err := os.RemoveAll(tmpGopath)
 					if err != nil {
 						t.Error(err)
diff --git a/src/cmd/go/internal/work/exec.go b/src/cmd/go/internal/work/exec.go
index 994c4dafcf..b506b83656 100644
--- a/src/cmd/go/internal/work/exec.go
+++ b/src/cmd/go/internal/work/exec.go
@@ -2377,7 +2377,7 @@ func (b *Builder) gccld(a *Action, p *load.Package, objdir, outfile string, flag
 
 	cmdargs := []interface{}{cmd, "-o", outfile, objs, flags}
 	dir := p.Dir
-	out, err := b.runOut(a, base.Cwd, b.cCompilerEnv(), cmdargs...)
+	out, err := b.runOut(a, base.Cwd(), b.cCompilerEnv(), cmdargs...)
 
 	if len(out) > 0 {
 		// Filter out useless linker warnings caused by bugs outside Go.
@@ -2991,7 +2991,7 @@ func (b *Builder) dynimport(a *Action, p *load.Package, objdir, importGo, cgoExe
 	if p.Standard && p.ImportPath == "runtime/cgo" {
 		cgoflags = []string{"-dynlinker"} // record path to dynamic linker
 	}
-	return b.run(a, base.Cwd, p.ImportPath, b.cCompilerEnv(), cfg.BuildToolexec, cgoExe, "-dynpackage", p.Name, "-dynimport", dynobj, "-dynout", importGo, cgoflags)
+	return b.run(a, base.Cwd(), p.ImportPath, b.cCompilerEnv(), cfg.BuildToolexec, cgoExe, "-dynpackage", p.Name, "-dynimport", dynobj, "-dynout", importGo, cgoflags)
 }
 
 // Run SWIG on all SWIG input files.
diff --git a/src/cmd/go/internal/work/gc.go b/src/cmd/go/internal/work/gc.go
index 9adcf3035f..85da4f89f9 100644
--- a/src/cmd/go/internal/work/gc.go
+++ b/src/cmd/go/internal/work/gc.go
@@ -197,7 +197,7 @@ func (gcToolchain) gc(b *Builder, a *Action, archive string, importcfg, embedcfg
 		args = append(args, f)
 	}
 
-	output, err = b.runOut(a, base.Cwd, nil, args...)
+	output, err = b.runOut(a, base.Cwd(), nil, args...)
 	return ofile, output, err
 }
 
diff --git a/src/cmd/go/internal/work/gccgo.go b/src/cmd/go/internal/work/gccgo.go
index b58c8aa885..1499536932 100644
--- a/src/cmd/go/internal/work/gccgo.go
+++ b/src/cmd/go/internal/work/gccgo.go
@@ -102,7 +102,7 @@ func (tools gccgoToolchain) gc(b *Builder, a *Action, archive string, importcfg,
 
 	if b.gccSupportsFlag(args[:1], "-ffile-prefix-map=a=b") {
 		if cfg.BuildTrimpath {
-			args = append(args, "-ffile-prefix-map="+base.Cwd+"=.")
+			args = append(args, "-ffile-prefix-map="+base.Cwd()+"=.")
 			args = append(args, "-ffile-prefix-map="+b.WorkDir+"=/tmp/go-build")
 		}
 		if fsys.OverlayFile != "" {
@@ -114,9 +114,9 @@ func (tools gccgoToolchain) gc(b *Builder, a *Action, archive string, importcfg,
 				}
 				toPath := absPath
 				// gccgo only applies the last matching rule, so also handle the case where
-				// BuildTrimpath is true and the path is relative to base.Cwd.
-				if cfg.BuildTrimpath && str.HasFilePathPrefix(toPath, base.Cwd) {
-					toPath = "." + toPath[len(base.Cwd):]
+				// BuildTrimpath is true and the path is relative to base.Cwd().
+				if cfg.BuildTrimpath && str.HasFilePathPrefix(toPath, base.Cwd()) {
+					toPath = "." + toPath[len(base.Cwd()):]
 				}
 				args = append(args, "-ffile-prefix-map="+overlayPath+"="+toPath)
 			}
@@ -572,7 +572,7 @@ func (tools gccgoToolchain) cc(b *Builder, a *Action, ofile, cfile string) error
 	}
 	defs = tools.maybePIC(defs)
 	if b.gccSupportsFlag(compiler, "-ffile-prefix-map=a=b") {
-		defs = append(defs, "-ffile-prefix-map="+base.Cwd+"=.")
+		defs = append(defs, "-ffile-prefix-map="+base.Cwd()+"=.")
 		defs = append(defs, "-ffile-prefix-map="+b.WorkDir+"=/tmp/go-build")
 	} else if b.gccSupportsFlag(compiler, "-fdebug-prefix-map=a=b") {
 		defs = append(defs, "-fdebug-prefix-map="+b.WorkDir+"=/tmp/go-build")
diff --git a/src/cmd/go/internal/work/init.go b/src/cmd/go/internal/work/init.go
index ca7e04d280..37a3e2d0ff 100644
--- a/src/cmd/go/internal/work/init.go
+++ b/src/cmd/go/internal/work/init.go
@@ -23,7 +23,7 @@ func BuildInit() {
 	modload.Init()
 	instrumentInit()
 	buildModeInit()
-	if err := fsys.Init(base.Cwd); err != nil {
+	if err := fsys.Init(base.Cwd()); err != nil {
 		base.Fatalf("go: %v", err)
 	}
 
-- 
GitLab


From 66ce8aa88d144338868b0d3ab8c895608a460750 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Tue, 4 May 2021 16:18:56 -0400
Subject: [PATCH 1968/2400] cmd/compile: handle degenerate entry blocks in -N
 debug gen

The code that created DWARF debug var locations for input parameters
in the non-optimized case for regabi was not doing the right thing for
degenerate functions with infinite loops. Detect these cases and don't
try to emit the normal location data.

Fixes #45948.

Change-Id: I2717fc4bac2e03d5d850a6ec8a09ed05fed0c896
Reviewed-on: https://go-review.googlesource.com/c/go/+/316752
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ssa/debug.go | 12 +++++++++---
 test/fixedbugs/issue45948.go          | 16 ++++++++++++++++
 2 files changed, 25 insertions(+), 3 deletions(-)
 create mode 100644 test/fixedbugs/issue45948.go

diff --git a/src/cmd/compile/internal/ssa/debug.go b/src/cmd/compile/internal/ssa/debug.go
index ee522f41ef..2f379c9e2c 100644
--- a/src/cmd/compile/internal/ssa/debug.go
+++ b/src/cmd/compile/internal/ssa/debug.go
@@ -1362,9 +1362,6 @@ func BuildFuncDebugNoOptimized(ctxt *obj.Link, f *Func, loggingEnabled bool, sta
 	// Locate the value corresponding to the last spill of
 	// an input register.
 	afterPrologVal := locatePrologEnd(f)
-	if afterPrologVal == ID(-1) {
-		panic(fmt.Sprintf("internal error: f=%s: can't locate after prolog value", f.Name))
-	}
 
 	// Walk the input params again and process the register-resident elements.
 	pidx := 0
@@ -1381,6 +1378,15 @@ func BuildFuncDebugNoOptimized(ctxt *obj.Link, f *Func, loggingEnabled bool, sta
 		slid := len(fd.VarSlots)
 		fd.VarSlots = append(fd.VarSlots, []SlotID{SlotID(slid)})
 
+		if afterPrologVal == ID(-1) {
+			// This can happen for degenerate functions with infinite
+			// loops such as that in issue 45948. In such cases, leave
+			// the var/slot set up for the param, but don't try to
+			// emit a location list.
+			pidx++
+			continue
+		}
+
 		// 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.
diff --git a/test/fixedbugs/issue45948.go b/test/fixedbugs/issue45948.go
new file mode 100644
index 0000000000..37f8e70e2b
--- /dev/null
+++ b/test/fixedbugs/issue45948.go
@@ -0,0 +1,16 @@
+// compile -N
+
+// Copyright 2021 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.
+
+// Issue 45948: assert in debug generation for degenerate
+// function with infinite loop.
+
+package p
+
+func f(p int) {
+L:
+	goto L
+
+}
-- 
GitLab


From caf4c9434b0c9b3f27e1c5e620b2acb0e46a74bb Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Tue, 4 May 2021 20:38:24 -0400
Subject: [PATCH 1969/2400] cmd/compile: debug trace output for -N variable
 location gen

Add some rudimentary debug trace output for -N location list
generation if "-d=ssa/locationlists" is set.

Updates #45948.

Change-Id: If1a95730538a6e7def7ebe1ece1a71da8e5f0975
Reviewed-on: https://go-review.googlesource.com/c/go/+/317089
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/ssa/debug.go | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/src/cmd/compile/internal/ssa/debug.go b/src/cmd/compile/internal/ssa/debug.go
index 2f379c9e2c..0ca435e515 100644
--- a/src/cmd/compile/internal/ssa/debug.go
+++ b/src/cmd/compile/internal/ssa/debug.go
@@ -1356,6 +1356,12 @@ func BuildFuncDebugNoOptimized(ctxt *obj.Link, f *Func, loggingEnabled bool, sta
 		return &fd
 	}
 
+	state := debugState{f: f}
+
+	if loggingEnabled {
+		state.logf("generating -N reg param loc lists for func %q\n", f.Name)
+	}
+
 	// Allocate location lists.
 	fd.LocationLists = make([][]byte, numRegParams)
 
@@ -1383,6 +1389,9 @@ func BuildFuncDebugNoOptimized(ctxt *obj.Link, f *Func, loggingEnabled bool, sta
 			// loops such as that in issue 45948. In such cases, leave
 			// the var/slot set up for the param, but don't try to
 			// emit a location list.
+			if loggingEnabled {
+				state.logf("locatePrologEnd failed, skipping %v\n", n)
+			}
 			pidx++
 			continue
 		}
@@ -1396,6 +1405,9 @@ func BuildFuncDebugNoOptimized(ctxt *obj.Link, f *Func, loggingEnabled bool, sta
 			pidx++
 			continue
 		}
+		if loggingEnabled {
+			state.logf("param %v:\n  [<entry>, %d]:\n", n, afterPrologVal)
+		}
 		rtypes, _ := inp.RegisterTypesAndOffsets()
 		padding := make([]uint64, 0, 32)
 		padding = inp.ComputePadding(padding)
@@ -1408,15 +1420,24 @@ func BuildFuncDebugNoOptimized(ctxt *obj.Link, f *Func, loggingEnabled bool, sta
 				list = append(list, dwarf.DW_OP_regx)
 				list = dwarf.AppendUleb128(list, uint64(dwreg))
 			}
+			if loggingEnabled {
+				state.logf("    piece %d -> dwreg %d", k, dwreg)
+			}
 			if len(inp.Registers) > 1 {
 				list = append(list, dwarf.DW_OP_piece)
 				ts := rtypes[k].Width
 				list = dwarf.AppendUleb128(list, uint64(ts))
 				if padding[k] > 0 {
+					if loggingEnabled {
+						state.logf(" [pad %d bytes]", padding[k])
+					}
 					list = append(list, dwarf.DW_OP_piece)
 					list = dwarf.AppendUleb128(list, padding[k])
 				}
 			}
+			if loggingEnabled {
+				state.logf("\n")
+			}
 		}
 		// fill in length of location expression element
 		ctxt.Arch.ByteOrder.PutUint16(list[sizeIdx:], uint16(len(list)-sizeIdx-2))
@@ -1436,6 +1457,10 @@ func BuildFuncDebugNoOptimized(ctxt *obj.Link, f *Func, loggingEnabled bool, sta
 			list = append(list, dwarf.DW_OP_fbreg)
 			list = dwarf.AppendSleb128(list, int64(soff))
 		}
+		if loggingEnabled {
+			state.logf("  [%d, <end>): stackOffset=%d\n", afterPrologVal, soff)
+		}
+
 		// fill in size
 		ctxt.Arch.ByteOrder.PutUint16(list[sizeIdx:], uint16(len(list)-sizeIdx-2))
 
-- 
GitLab


From 9e0facd26ecefa5a3aa5bfd9e4034fe6d4b2f64e Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 28 Apr 2021 16:14:12 -0700
Subject: [PATCH 1970/2400] cmd/compile/internal/types2: implement
 types2.Instantiate

Instantiation support for imports. This is experimental
but it also doesn't affect Go 1.17 as this code is not
executed unless we enable generics (in the parser).

Change-Id: If2da09ac3a557ec6a180707a53f75f3ce354f3e9
Reviewed-on: https://go-review.googlesource.com/c/go/+/314773
Trust: Robert Griesemer <gri@golang.org>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 .../compile/internal/types2/instantiate.go    | 63 +++++++++++++++++++
 src/cmd/compile/internal/types2/subst.go      | 31 +++++----
 2 files changed, 83 insertions(+), 11 deletions(-)
 create mode 100644 src/cmd/compile/internal/types2/instantiate.go

diff --git a/src/cmd/compile/internal/types2/instantiate.go b/src/cmd/compile/internal/types2/instantiate.go
new file mode 100644
index 0000000000..0df52e851c
--- /dev/null
+++ b/src/cmd/compile/internal/types2/instantiate.go
@@ -0,0 +1,63 @@
+// Copyright 2021 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 types2
+
+import (
+	"cmd/compile/internal/syntax"
+	"fmt"
+)
+
+// Instantiate instantiates the type typ with the given type arguments.
+// typ must be a *Named or a *Signature type, it must be generic, and
+// its number of type parameters must match the number of provided type
+// arguments. The result is a new, instantiated (not generic) type of
+// the same kind (either a *Named or a *Signature). The type arguments
+// are not checked against the constraints of the type parameters.
+// Any methods attached to a *Named are simply copied; they are not
+// instantiated.
+func Instantiate(pos syntax.Pos, typ Type, targs []Type) (res Type) {
+	// TODO(gri) This code is basically identical to the prolog
+	//           in Checker.instantiate. Factor.
+	var tparams []*TypeName
+	switch t := typ.(type) {
+	case *Named:
+		tparams = t.tparams
+	case *Signature:
+		tparams = t.tparams
+		defer func() {
+			// If we had an unexpected failure somewhere don't panic below when
+			// asserting res.(*Signature). Check for *Signature in case Typ[Invalid]
+			// is returned.
+			if _, ok := res.(*Signature); !ok {
+				return
+			}
+			// If the signature doesn't use its type parameters, subst
+			// will not make a copy. In that case, make a copy now (so
+			// we can set tparams to nil w/o causing side-effects).
+			if t == res {
+				copy := *t
+				res = &copy
+			}
+			// After instantiating a generic signature, it is not generic
+			// anymore; we need to set tparams to nil.
+			res.(*Signature).tparams = nil
+		}()
+
+	default:
+		panic(fmt.Sprintf("%v: cannot instantiate %v", pos, typ))
+	}
+
+	// the number of supplied types must match the number of type parameters
+	if len(targs) != len(tparams) {
+		panic(fmt.Sprintf("%v: got %d arguments but %d type parameters", pos, len(targs), len(tparams)))
+	}
+
+	if len(tparams) == 0 {
+		return typ // nothing to do (minor optimization)
+	}
+
+	smap := makeSubstMap(tparams, targs)
+	return (*Checker)(nil).subst(pos, typ, smap)
+}
diff --git a/src/cmd/compile/internal/types2/subst.go b/src/cmd/compile/internal/types2/subst.go
index d089317f7d..c8e428c183 100644
--- a/src/cmd/compile/internal/types2/subst.go
+++ b/src/cmd/compile/internal/types2/subst.go
@@ -308,6 +308,9 @@ func (subst *subster) typ(typ Type) Type {
 		embeddeds, ecopied := subst.typeList(t.embeddeds)
 		if mcopied || types != t.types || ecopied {
 			iface := &Interface{methods: methods, types: types, embeddeds: embeddeds}
+			if subst.check == nil {
+				panic("internal error: cannot instantiate interfaces yet")
+			}
 			subst.check.posMap[iface] = subst.check.posMap[t] // satisfy completeInterface requirement
 			subst.check.completeInterface(nopos, iface)
 			return iface
@@ -327,12 +330,14 @@ func (subst *subster) typ(typ Type) Type {
 		}
 
 	case *Named:
-		subst.check.indent++
-		defer func() {
-			subst.check.indent--
-		}()
-		dump := func(format string, args ...interface{}) {
-			if subst.check.conf.Trace {
+		// dump is for debugging
+		dump := func(string, ...interface{}) {}
+		if subst.check != nil && subst.check.conf.Trace {
+			subst.check.indent++
+			defer func() {
+				subst.check.indent--
+			}()
+			dump = func(format string, args ...interface{}) {
 				subst.check.trace(subst.pos, format, args...)
 			}
 		}
@@ -377,17 +382,21 @@ func (subst *subster) typ(typ Type) Type {
 		// before creating a new named type, check if we have this one already
 		h := instantiatedHash(t, new_targs)
 		dump(">>> new type hash: %s", h)
-		if named, found := subst.check.typMap[h]; found {
-			dump(">>> found %s", named)
-			subst.cache[t] = named
-			return named
+		if subst.check != nil {
+			if named, found := subst.check.typMap[h]; found {
+				dump(">>> found %s", named)
+				subst.cache[t] = named
+				return named
+			}
 		}
 
 		// create a new named type and populate caches to avoid endless recursion
 		tname := NewTypeName(subst.pos, t.obj.pkg, t.obj.name, nil)
 		named := subst.check.newNamed(tname, t, t.underlying, t.tparams, t.methods) // method signatures are updated lazily
 		named.targs = new_targs
-		subst.check.typMap[h] = named
+		if subst.check != nil {
+			subst.check.typMap[h] = named
+		}
 		subst.cache[t] = named
 
 		// do the substitution
-- 
GitLab


From 4c9791299d418c7434bebe59a9a481b7a246e33b Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Wed, 5 May 2021 04:01:52 +1000
Subject: [PATCH 1971/2400] runtime: remove redundant save_g call in mcall for
 arm

The setg call a few lines earlier has already performed the same iscgo check
and called save_g if necessary.

Change-Id: I6e7c44cef4e0397d6001a3d5b7e334cdfbc3ce22
Reviewed-on: https://go-review.googlesource.com/c/go/+/316929
Trust: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/asm_arm.s | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/runtime/asm_arm.s b/src/runtime/asm_arm.s
index f468b77ee3..e779fc8f84 100644
--- a/src/runtime/asm_arm.s
+++ b/src/runtime/asm_arm.s
@@ -252,9 +252,6 @@ TEXT runtime·mcall(SB),NOSPLIT|NOFRAME,$0-4
 	CMP	g, R1
 	B.NE	2(PC)
 	B	runtime·badmcall(SB)
-	MOVB	runtime·iscgo(SB), R11
-	CMP	$0, R11
-	BL.NE	runtime·save_g(SB)
 	MOVW	fn+0(FP), R0
 	MOVW	(g_sched+gobuf_sp)(g), R13
 	SUB	$8, R13
-- 
GitLab


From f34fe8e370f8bd910640fa49bb4d93e910145193 Mon Sep 17 00:00:00 2001
From: Alexander Rakoczy <alex@golang.org>
Date: Wed, 5 May 2021 10:48:13 -0400
Subject: [PATCH 1972/2400] all: update vendored dependencies for Go 1.17

The Go 1.17 freeze has begun. This is a time to update all
golang.org/x/...  module versions that contribute packages to the std
and cmd modules in the standard library to latest master versions.

	updatestd --branch master --goroot=$HOME/development/goroot
	> go version
	go version devel go1.17-4c9791299d Wed May 5 09:00:06 2021 +0000 linux/amd64
	> go env GOROOT
	/home/rakoczy/development/goroot
	> go version -m /home/rakoczy/go/bin/bundle
	/home/rakoczy/go/bin/bundle: devel +c584f42dcf Tue Feb 23 18:39:53 2021 +0000
		path	golang.org/x/tools/cmd/bundle
		mod	golang.org/x/tools	v0.1.0	h1:po9/4sTYwZU9lPhi1tOrb4hCv3qrhiQ77LZfGa2OjwY=
		dep	golang.org/x/mod	v0.3.0	h1:RM4zey1++hCTbCVQfnWeKs9/IEsaBLA8vTkd0WVtmH4=
		dep	golang.org/x/sys	v0.0.0-20210119212857-b64e53b001e4	h1:myAQVi0cGEoqQVR5POX+8RR2mrocKqNN1hmeMqhX27k=
		dep	golang.org/x/xerrors	v0.0.0-20200804184101-5ec99f83aff1	h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=

	skipping github.com/chzyer/logex (out of scope, it's not a golang.org/x dependency)
	skipping github.com/chzyer/readline (out of scope, it's not a golang.org/x dependency)
	skipping github.com/chzyer/test (out of scope, it's not a golang.org/x dependency)
	skipping github.com/google/pprof (out of scope, it's not a golang.org/x dependency)
	skipping github.com/ianlancetaylor/demangle (out of scope, it's not a golang.org/x dependency)
	skipping github.com/yuin/goldmark (out of scope, it's not a golang.org/x dependency)
	skipping rsc.io/pdf (out of scope, it's not a golang.org/x dependency)
	updating module cmd in /home/rakoczy/development/goroot/src/cmd
	> go mod edit -go=1.17
	> go get -d golang.org/x/arch@cbf565b21d1e6f86b3114f28f516032b201c97fa golang.org/x/crypto@e9a32991a82ef02a1e74f495dcc0785239782bfe golang.org/x/mod@67f1c1edc27ada9b0cffe84ccdd4db2d4ff56edf golang.org/x/net@0287a6fb4125c2b83c66560a2677a4ee69a13903 golang.org/x/sync@036812b2e83c0ddf193dd5a34e034151da389d09 golang.org/x/sys@0981d6026fa6241c75c6949829b5bd7a2574ad55 golang.org/x/term@a79de5458b56c188f4fc267a58014ac25fec956a golang.org/x/text@5c7c50ebbd4f5b0d53b9b2fcdbeb92ffb732a06e golang.org/x/tools@7cab0ef2e9a592f6a73e7a1969ba89d38515e143 golang.org/x/xerrors@5ec99f83aff198f5fbd629d6c8d8eb38a04218ca
	go: downloading golang.org/x/mod v0.4.3-0.20210504181020-67f1c1edc27a
	go: downloading golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e
	go: downloading golang.org/x/net v0.0.0-20210505024714-0287a6fb4125
	go: downloading golang.org/x/sys v0.0.0-20210503173754-0981d6026fa6
	go: downloading golang.org/x/text v0.3.7-0.20210503195748-5c7c50ebbd4f
	go: downloading golang.org/x/tools v0.1.1-0.20210505014545-7cab0ef2e9a5
	go get: upgraded golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4 => v0.0.0-20210505024714-0287a6fb4125
	go get: upgraded golang.org/x/sys v0.0.0-20210423082822-04245dca01da => v0.0.0-20210503173754-0981d6026fa6
	go get: upgraded golang.org/x/text v0.3.3 => v0.3.7-0.20210503195748-5c7c50ebbd4f
	go get: upgraded golang.org/x/tools v0.1.1-0.20210503200558-19b1717ea5eb => v0.1.1-0.20210505014545-7cab0ef2e9a5
	> go mod tidy
	> go mod vendor

	updating module std in /home/rakoczy/development/goroot/src
	> go mod edit -go=1.17
	> go get -d golang.org/x/crypto@e9a32991a82ef02a1e74f495dcc0785239782bfe golang.org/x/net@0287a6fb4125c2b83c66560a2677a4ee69a13903 golang.org/x/sys@0981d6026fa6241c75c6949829b5bd7a2574ad55 golang.org/x/term@a79de5458b56c188f4fc267a58014ac25fec956a golang.org/x/text@5c7c50ebbd4f5b0d53b9b2fcdbeb92ffb732a06e golang.org/x/tools@7cab0ef2e9a592f6a73e7a1969ba89d38515e143
	go get: upgraded golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420 => v0.0.0-20210505024714-0287a6fb4125
	go get: upgraded golang.org/x/sys v0.0.0-20210423082822-04245dca01da => v0.0.0-20210503173754-0981d6026fa6
	go get: upgraded golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1 => v0.0.0-20210503060354-a79de5458b56
	go get: upgraded golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e => v0.1.1-0.20210505014545-7cab0ef2e9a5
	> go mod tidy
	> go mod vendor

	updating bundles in /home/rakoczy/development/goroot/src
	> go generate -run=bundle std cmd

For #36905

Change-Id: Ie145bba93125f0b4212df94216e05ec08c4fe534
Reviewed-on: https://go-review.googlesource.com/c/go/+/315831
Trust: Alexander Rakoczy <alex@golang.org>
Run-TryBot: Alexander Rakoczy <alex@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Heschi Kreinick <heschi@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go.mod                                |   4 +-
 src/cmd/go.sum                                |   8 +-
 .../golang.org/x/sys/unix/asm_aix_ppc64.s     |   1 +
 .../golang.org/x/sys/unix/asm_linux_386.s     |   1 +
 .../golang.org/x/sys/unix/asm_linux_amd64.s   |   1 +
 .../golang.org/x/sys/unix/asm_linux_arm.s     |   1 +
 .../golang.org/x/sys/unix/asm_linux_arm64.s   |   1 +
 .../golang.org/x/sys/unix/asm_linux_mips64x.s |   1 +
 .../golang.org/x/sys/unix/asm_linux_mipsx.s   |   1 +
 .../golang.org/x/sys/unix/asm_linux_ppc64x.s  |   1 +
 .../golang.org/x/sys/unix/asm_linux_riscv64.s |   4 +-
 .../golang.org/x/sys/unix/asm_linux_s390x.s   |   3 +-
 .../x/sys/unix/asm_openbsd_mips64.s           |   1 +
 .../golang.org/x/sys/unix/asm_solaris_amd64.s |   1 +
 src/cmd/vendor/golang.org/x/sys/unix/fdset.go |   4 +-
 .../golang.org/x/sys/unix/syscall_illumos.go  |  51 +++++++-
 .../golang.org/x/sys/unix/syscall_linux.go    |   6 +-
 .../x/sys/unix/syscall_zos_s390x.go           |  52 +++++++-
 .../golang.org/x/sys/unix/zerrors_linux.go    |  23 +++-
 .../x/sys/unix/zerrors_linux_s390x.go         |   2 +
 .../x/sys/unix/zerrors_zos_s390x.go           |  22 ++++
 .../x/sys/unix/zsyscall_darwin_386.1_13.s     |   1 +
 .../x/sys/unix/zsyscall_darwin_386.s          |   1 +
 .../x/sys/unix/zsyscall_darwin_amd64.1_13.s   |   1 +
 .../x/sys/unix/zsyscall_darwin_amd64.s        |   1 +
 .../x/sys/unix/zsyscall_darwin_arm.1_13.s     |   1 +
 .../x/sys/unix/zsyscall_darwin_arm.s          |   1 +
 .../x/sys/unix/zsyscall_darwin_arm64.1_13.s   |   1 +
 .../x/sys/unix/zsyscall_darwin_arm64.s        |   1 +
 .../x/sys/unix/zsyscall_zos_s390x.go          |  42 ++++++-
 .../x/sys/unix/zsysnum_linux_386.go           |   1 +
 .../x/sys/unix/zsysnum_linux_amd64.go         |   1 +
 .../x/sys/unix/zsysnum_linux_arm.go           |   1 +
 .../x/sys/unix/zsysnum_linux_arm64.go         |   1 +
 .../x/sys/unix/zsysnum_linux_mips.go          |   1 +
 .../x/sys/unix/zsysnum_linux_mips64.go        |   1 +
 .../x/sys/unix/zsysnum_linux_mips64le.go      |   1 +
 .../x/sys/unix/zsysnum_linux_mipsle.go        |   1 +
 .../x/sys/unix/zsysnum_linux_ppc.go           |   1 +
 .../x/sys/unix/zsysnum_linux_ppc64.go         |   1 +
 .../x/sys/unix/zsysnum_linux_ppc64le.go       |   1 +
 .../x/sys/unix/zsysnum_linux_riscv64.go       |   1 +
 .../x/sys/unix/zsysnum_linux_s390x.go         |   1 +
 .../x/sys/unix/zsysnum_linux_sparc64.go       |   1 +
 .../x/sys/unix/ztypes_illumos_amd64.go        |   4 +-
 .../golang.org/x/sys/unix/ztypes_linux.go     |  15 ++-
 .../golang.org/x/sys/unix/ztypes_zos_s390x.go |   4 +
 src/cmd/vendor/modules.txt                    |   6 +-
 src/go.mod                                    |   4 +-
 src/go.sum                                    |   8 +-
 src/net/http/h2_bundle.go                     | 119 +++++++++++-------
 .../golang.org/x/sys/cpu/asm_aix_ppc64.s      |   1 +
 src/vendor/golang.org/x/sys/cpu/cpu_arm64.s   |   1 +
 src/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go |   4 +
 .../golang.org/x/sys/cpu/cpu_gccgo_x86.go     |   6 +
 src/vendor/golang.org/x/sys/cpu/cpu_s390x.s   |   1 +
 src/vendor/golang.org/x/sys/cpu/cpu_x86.go    |  10 +-
 src/vendor/golang.org/x/sys/cpu/cpu_x86.s     |  25 ++++
 src/vendor/modules.txt                        |   6 +-
 59 files changed, 383 insertions(+), 84 deletions(-)

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index ebcfba62e5..a15cbe070a 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -8,8 +8,8 @@ require (
 	golang.org/x/arch v0.0.0-20210502124803-cbf565b21d1e
 	golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e // indirect
 	golang.org/x/mod v0.4.3-0.20210504181020-67f1c1edc27a
-	golang.org/x/sys v0.0.0-20210423082822-04245dca01da // indirect
+	golang.org/x/sys v0.0.0-20210503173754-0981d6026fa6 // indirect
 	golang.org/x/term v0.0.0-20210503060354-a79de5458b56
-	golang.org/x/tools v0.1.1-0.20210503200558-19b1717ea5eb
+	golang.org/x/tools v0.1.1-0.20210505014545-7cab0ef2e9a5
 	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
 )
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 1f64b4aae3..8a7ad4290a 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -12,11 +12,11 @@ golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e/go.mod h1:P+XmwS30IXTQdn5
 golang.org/x/mod v0.4.3-0.20210504181020-67f1c1edc27a h1:wbpC/7Wbo5WFVox32n+KjhRRLmTLq8YW/wRlL2iVAhk=
 golang.org/x/mod v0.4.3-0.20210504181020-67f1c1edc27a/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
 golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da h1:b3NXsE2LusjYGGjL5bxEVZZORm/YEFFrWFjR8eFrw/c=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210503173754-0981d6026fa6 h1:cdsMqa2nXzqlgs183pHxtvoVwU7CyzaCTAUOg94af4c=
+golang.org/x/sys v0.0.0-20210503173754-0981d6026fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20210503060354-a79de5458b56 h1:b8jxX3zqjpqb2LklXPzKSGJhzyxCOZSz8ncv8Nv+y7w=
 golang.org/x/term v0.0.0-20210503060354-a79de5458b56/go.mod h1:tfny5GFUkzUvx4ps4ajbZsCe5lw1metzhBm9T3x7oIY=
-golang.org/x/tools v0.1.1-0.20210503200558-19b1717ea5eb h1:6lugOWRUqRgNSUsUg8YnMqSUlUXSGsJG2dEv9T6BxwQ=
-golang.org/x/tools v0.1.1-0.20210503200558-19b1717ea5eb/go.mod h1:sH/Eidr0EddymY8HZSakBo32zU3fG5ovDq874hJLjVg=
+golang.org/x/tools v0.1.1-0.20210505014545-7cab0ef2e9a5 h1:ImcI7RFHWLu2QWpFDXaReu0j+sQAHIy65vUFZImXiqY=
+golang.org/x/tools v0.1.1-0.20210505014545-7cab0ef2e9a5/go.mod h1:sH/Eidr0EddymY8HZSakBo32zU3fG5ovDq874hJLjVg=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_aix_ppc64.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_aix_ppc64.s
index 6b4027b33f..db9171c2e4 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_aix_ppc64.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/asm_aix_ppc64.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build gc
 // +build gc
 
 #include "textflag.h"
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_386.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_386.s
index 0655ecbfbb..8fd101d071 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_386.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_386.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build gc
 // +build gc
 
 #include "textflag.h"
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_amd64.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_amd64.s
index bc3fb6ac3e..7ed38e43c6 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_amd64.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_amd64.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build gc
 // +build gc
 
 #include "textflag.h"
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_arm.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_arm.s
index 55b13c7ba4..8ef1d51402 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_arm.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_arm.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build gc
 // +build gc
 
 #include "textflag.h"
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_arm64.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_arm64.s
index 22a83d8e3f..98ae02760d 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_arm64.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_arm64.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && arm64 && gc
 // +build linux
 // +build arm64
 // +build gc
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_mips64x.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_mips64x.s
index dc222b90ce..21231d2ce1 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_mips64x.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_mips64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (mips64 || mips64le) && gc
 // +build linux
 // +build mips64 mips64le
 // +build gc
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_mipsx.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_mipsx.s
index d333f13cff..6783b26c60 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_mipsx.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_mipsx.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (mips || mipsle) && gc
 // +build linux
 // +build mips mipsle
 // +build gc
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s
index 459a629c27..19d4989344 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (ppc64 || ppc64le) && gc
 // +build linux
 // +build ppc64 ppc64le
 // +build gc
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_riscv64.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_riscv64.s
index 04d38497c6..e42eb81d58 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_riscv64.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_riscv64.s
@@ -2,7 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build riscv64,gc
+//go:build riscv64 && gc
+// +build riscv64
+// +build gc
 
 #include "textflag.h"
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_s390x.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_s390x.s
index cc303989e1..c46aab3395 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_s390x.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_s390x.s
@@ -2,8 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build s390x
+//go:build linux && s390x && gc
 // +build linux
+// +build s390x
 // +build gc
 
 #include "textflag.h"
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_mips64.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_mips64.s
index 47c93fcb6c..5e7a1169c0 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_mips64.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_mips64.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build gc
 // +build gc
 
 #include "textflag.h"
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/asm_solaris_amd64.s b/src/cmd/vendor/golang.org/x/sys/unix/asm_solaris_amd64.s
index 1f2c755a72..f8c5394c1a 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/asm_solaris_amd64.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/asm_solaris_amd64.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build gc
 // +build gc
 
 #include "textflag.h"
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/fdset.go b/src/cmd/vendor/golang.org/x/sys/unix/fdset.go
index b1e07b2202..a8068f94f2 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/fdset.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/fdset.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
-// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos
+// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos
 
 package unix
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_illumos.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_illumos.go
index c5c58806ca..8c53576835 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_illumos.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_illumos.go
@@ -1,4 +1,4 @@
-// Copyright 2009 The Go Authors. All rights reserved.
+// Copyright 2021 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.
 
@@ -10,6 +10,8 @@
 package unix
 
 import (
+	"fmt"
+	"runtime"
 	"unsafe"
 )
 
@@ -127,3 +129,50 @@ func Getmsg(fd int, cl []byte, data []byte) (retCl []byte, retData []byte, flags
 	}
 	return retCl, retData, flags, nil
 }
+
+func IoctlSetIntRetInt(fd int, req uint, arg int) (int, error) {
+	return ioctlRet(fd, req, uintptr(arg))
+}
+
+func IoctlSetString(fd int, req uint, val string) error {
+	bs := make([]byte, len(val)+1)
+	copy(bs[:len(bs)-1], val)
+	err := ioctl(fd, req, uintptr(unsafe.Pointer(&bs[0])))
+	runtime.KeepAlive(&bs[0])
+	return err
+}
+
+// Lifreq Helpers
+
+func (l *Lifreq) SetName(name string) error {
+	if len(name) >= len(l.Name) {
+		return fmt.Errorf("name cannot be more than %d characters", len(l.Name)-1)
+	}
+	for i := range name {
+		l.Name[i] = int8(name[i])
+	}
+	return nil
+}
+
+func (l *Lifreq) SetLifruInt(d int) {
+	*(*int)(unsafe.Pointer(&l.Lifru[0])) = d
+}
+
+func (l *Lifreq) GetLifruInt() int {
+	return *(*int)(unsafe.Pointer(&l.Lifru[0]))
+}
+
+func IoctlLifreq(fd int, req uint, l *Lifreq) error {
+	return ioctl(fd, req, uintptr(unsafe.Pointer(l)))
+}
+
+// Strioctl Helpers
+
+func (s *Strioctl) SetInt(i int) {
+	s.Len = int32(unsafe.Sizeof(i))
+	s.Dp = (*int8)(unsafe.Pointer(&i))
+}
+
+func IoctlSetStrioctlRetInt(fd int, req uint, s *Strioctl) (int, error) {
+	return ioctlRet(fd, req, uintptr(unsafe.Pointer(s)))
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go
index 4263953bee..2dd7c8e34a 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go
@@ -1151,7 +1151,11 @@ func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) {
 func Accept(fd int) (nfd int, sa Sockaddr, err error) {
 	var rsa RawSockaddrAny
 	var len _Socklen = SizeofSockaddrAny
-	nfd, err = accept(fd, &rsa, &len)
+	// Try accept4 first for Android, then try accept for kernel older than 2.6.28
+	nfd, err = accept4(fd, &rsa, &len, 0)
+	if err == ENOSYS {
+		nfd, err = accept(fd, &rsa, &len)
+	}
 	if err != nil {
 		return
 	}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go
index 13f58d2b2f..1ffd8bfcfb 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go
@@ -222,6 +222,8 @@ func (cmsg *Cmsghdr) SetLen(length int) {
 //sys   Creat(path string, mode uint32) (fd int, err error) = SYS___CREAT_A
 //sys	Dup(oldfd int) (fd int, err error)
 //sys	Dup2(oldfd int, newfd int) (err error)
+//sys	Errno2() (er2 int) = SYS___ERRNO2
+//sys	Err2ad() (eadd *int) = SYS___ERR2AD
 //sys	Exit(code int)
 //sys	Fchdir(fd int) (err error)
 //sys	Fchmod(fd int, mode uint32) (err error)
@@ -245,10 +247,12 @@ func Fstat(fd int, stat *Stat_t) (err error) {
 //sys   Poll(fds []PollFd, timeout int) (n int, err error) = SYS_POLL
 //sys   Times(tms *Tms) (ticks uintptr, err error) = SYS_TIMES
 //sys   W_Getmntent(buff *byte, size int) (lastsys int, err error) = SYS_W_GETMNTENT
+//sys   W_Getmntent_A(buff *byte, size int) (lastsys int, err error) = SYS___W_GETMNTENT_A
 
-//sys   Mount(path string, filesystem string, fstype string, mtm uint32, parmlen int32, parm string) (err error) = SYS___MOUNT_A
-//sys   Unmount(filesystem string, mtm int) (err error) = SYS___UMOUNT_A
+//sys   mount_LE(path string, filesystem string, fstype string, mtm uint32, parmlen int32, parm string) (err error) = SYS___MOUNT_A
+//sys   unmount(filesystem string, mtm int) (err error) = SYS___UMOUNT_A
 //sys   Chroot(path string) (err error) = SYS___CHROOT_A
+//sys   Select(nmsgsfds int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (ret int, err error) = SYS_SELECT
 //sysnb Uname(buf *Utsname) (err error) = SYS___UNAME_A
 
 func Ptsname(fd int) (name string, err error) {
@@ -1779,3 +1783,47 @@ func SetNonblock(fd int, nonblocking bool) (err error) {
 func Exec(argv0 string, argv []string, envv []string) error {
 	return syscall.Exec(argv0, argv, envv)
 }
+
+func Mount(source string, target string, fstype string, flags uintptr, data string) (err error) {
+	if needspace := 8 - len(fstype); needspace <= 0 {
+		fstype = fstype[:8]
+	} else {
+		fstype += "        "[:needspace]
+	}
+	return mount_LE(target, source, fstype, uint32(flags), int32(len(data)), data)
+}
+
+func Unmount(name string, mtm int) (err error) {
+	// mountpoint is always a full path and starts with a '/'
+	// check if input string is not a mountpoint but a filesystem name
+	if name[0] != '/' {
+		return unmount(name, mtm)
+	}
+	// treat name as mountpoint
+	b2s := func(arr []byte) string {
+		nulli := bytes.IndexByte(arr, 0)
+		if nulli == -1 {
+			return string(arr)
+		} else {
+			return string(arr[:nulli])
+		}
+	}
+	var buffer struct {
+		header W_Mnth
+		fsinfo [64]W_Mntent
+	}
+	fsCount, err := W_Getmntent_A((*byte)(unsafe.Pointer(&buffer)), int(unsafe.Sizeof(buffer)))
+	if err != nil {
+		return err
+	}
+	if fsCount == 0 {
+		return EINVAL
+	}
+	for i := 0; i < fsCount; i++ {
+		if b2s(buffer.fsinfo[i].Mountpoint[:]) == name {
+			err = unmount(b2s(buffer.fsinfo[i].Fsname[:]), mtm)
+			break
+		}
+	}
+	return err
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux.go
index 35de419c6d..47572aaa69 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux.go
@@ -166,13 +166,16 @@ const (
 	BPF_ALU64                                   = 0x7
 	BPF_AND                                     = 0x50
 	BPF_ARSH                                    = 0xc0
+	BPF_ATOMIC                                  = 0xc0
 	BPF_B                                       = 0x10
 	BPF_BUILD_ID_SIZE                           = 0x14
 	BPF_CALL                                    = 0x80
+	BPF_CMPXCHG                                 = 0xf1
 	BPF_DIV                                     = 0x30
 	BPF_DW                                      = 0x18
 	BPF_END                                     = 0xd0
 	BPF_EXIT                                    = 0x90
+	BPF_FETCH                                   = 0x1
 	BPF_FROM_BE                                 = 0x8
 	BPF_FROM_LE                                 = 0x0
 	BPF_FS_MAGIC                                = 0xcafe4a11
@@ -240,6 +243,7 @@ const (
 	BPF_W                                       = 0x0
 	BPF_X                                       = 0x8
 	BPF_XADD                                    = 0xc0
+	BPF_XCHG                                    = 0xe1
 	BPF_XOR                                     = 0xa0
 	BRKINT                                      = 0x2
 	BS0                                         = 0x0
@@ -490,9 +494,9 @@ const (
 	DM_UUID_FLAG                                = 0x4000
 	DM_UUID_LEN                                 = 0x81
 	DM_VERSION                                  = 0xc138fd00
-	DM_VERSION_EXTRA                            = "-ioctl (2020-10-01)"
+	DM_VERSION_EXTRA                            = "-ioctl (2021-02-01)"
 	DM_VERSION_MAJOR                            = 0x4
-	DM_VERSION_MINOR                            = 0x2b
+	DM_VERSION_MINOR                            = 0x2c
 	DM_VERSION_PATCHLEVEL                       = 0x0
 	DT_BLK                                      = 0x6
 	DT_CHR                                      = 0x2
@@ -860,6 +864,7 @@ const (
 	FS_IOC_GET_ENCRYPTION_KEY_STATUS            = 0xc080661a
 	FS_IOC_GET_ENCRYPTION_POLICY_EX             = 0xc0096616
 	FS_IOC_MEASURE_VERITY                       = 0xc0046686
+	FS_IOC_READ_VERITY_METADATA                 = 0xc0286687
 	FS_IOC_REMOVE_ENCRYPTION_KEY                = 0xc0406618
 	FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS      = 0xc0406619
 	FS_KEY_DESCRIPTOR_SIZE                      = 0x8
@@ -875,6 +880,9 @@ const (
 	FS_VERITY_FL                                = 0x100000
 	FS_VERITY_HASH_ALG_SHA256                   = 0x1
 	FS_VERITY_HASH_ALG_SHA512                   = 0x2
+	FS_VERITY_METADATA_TYPE_DESCRIPTOR          = 0x2
+	FS_VERITY_METADATA_TYPE_MERKLE_TREE         = 0x1
+	FS_VERITY_METADATA_TYPE_SIGNATURE           = 0x3
 	FUTEXFS_SUPER_MAGIC                         = 0xbad1dea
 	F_ADD_SEALS                                 = 0x409
 	F_DUPFD                                     = 0x0
@@ -1673,6 +1681,10 @@ const (
 	PERF_FLAG_PID_CGROUP                        = 0x4
 	PERF_MAX_CONTEXTS_PER_STACK                 = 0x8
 	PERF_MAX_STACK_DEPTH                        = 0x7f
+	PERF_MEM_BLK_ADDR                           = 0x4
+	PERF_MEM_BLK_DATA                           = 0x2
+	PERF_MEM_BLK_NA                             = 0x1
+	PERF_MEM_BLK_SHIFT                          = 0x28
 	PERF_MEM_LOCK_LOCKED                        = 0x2
 	PERF_MEM_LOCK_NA                            = 0x1
 	PERF_MEM_LOCK_SHIFT                         = 0x18
@@ -1736,12 +1748,14 @@ const (
 	PERF_RECORD_MISC_GUEST_USER                 = 0x5
 	PERF_RECORD_MISC_HYPERVISOR                 = 0x3
 	PERF_RECORD_MISC_KERNEL                     = 0x1
+	PERF_RECORD_MISC_MMAP_BUILD_ID              = 0x4000
 	PERF_RECORD_MISC_MMAP_DATA                  = 0x2000
 	PERF_RECORD_MISC_PROC_MAP_PARSE_TIMEOUT     = 0x1000
 	PERF_RECORD_MISC_SWITCH_OUT                 = 0x2000
 	PERF_RECORD_MISC_SWITCH_OUT_PREEMPT         = 0x4000
 	PERF_RECORD_MISC_USER                       = 0x2
 	PERF_SAMPLE_BRANCH_PLM_ALL                  = 0x7
+	PERF_SAMPLE_WEIGHT_TYPE                     = 0x1004000
 	PIPEFS_MAGIC                                = 0x50495045
 	PPC_CMM_MAGIC                               = 0xc7571590
 	PPPIOCGNPMODE                               = 0xc008744c
@@ -1995,6 +2009,10 @@ const (
 	RTCF_NAT                                    = 0x800000
 	RTCF_VALVE                                  = 0x200000
 	RTC_AF                                      = 0x20
+	RTC_FEATURE_ALARM                           = 0x0
+	RTC_FEATURE_ALARM_RES_MINUTE                = 0x1
+	RTC_FEATURE_CNT                             = 0x3
+	RTC_FEATURE_NEED_WEEK_DAY                   = 0x2
 	RTC_IRQF                                    = 0x80
 	RTC_MAX_FREQ                                = 0x2000
 	RTC_PF                                      = 0x40
@@ -2068,6 +2086,7 @@ const (
 	RTM_F_LOOKUP_TABLE                          = 0x1000
 	RTM_F_NOTIFY                                = 0x100
 	RTM_F_OFFLOAD                               = 0x4000
+	RTM_F_OFFLOAD_FAILED                        = 0x20000000
 	RTM_F_PREFIX                                = 0x800
 	RTM_F_TRAP                                  = 0x8000
 	RTM_GETACTION                               = 0x32
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
index a508392d25..6d30e6fd84 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
@@ -212,6 +212,8 @@ const (
 	PTRACE_POKE_SYSTEM_CALL          = 0x5008
 	PTRACE_PROT                      = 0x15
 	PTRACE_SINGLEBLOCK               = 0xc
+	PTRACE_SYSEMU                    = 0x1f
+	PTRACE_SYSEMU_SINGLESTEP         = 0x20
 	PTRACE_TE_ABORT_RAND             = 0x5011
 	PT_ACR0                          = 0x90
 	PT_ACR1                          = 0x94
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go
index 4e87b4bebd..fc7d0506f6 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go
@@ -67,24 +67,43 @@ const (
 	IPPORT_RESERVED                 = 1024
 	IPPORT_USERRESERVED             = 5000
 	IPPROTO_AH                      = 51
+	SOL_AH                          = 51
 	IPPROTO_DSTOPTS                 = 60
+	SOL_DSTOPTS                     = 60
 	IPPROTO_EGP                     = 8
+	SOL_EGP                         = 8
 	IPPROTO_ESP                     = 50
+	SOL_ESP                         = 50
 	IPPROTO_FRAGMENT                = 44
+	SOL_FRAGMENT                    = 44
 	IPPROTO_GGP                     = 2
+	SOL_GGP                         = 2
 	IPPROTO_HOPOPTS                 = 0
+	SOL_HOPOPTS                     = 0
 	IPPROTO_ICMP                    = 1
+	SOL_ICMP                        = 1
 	IPPROTO_ICMPV6                  = 58
+	SOL_ICMPV6                      = 58
 	IPPROTO_IDP                     = 22
+	SOL_IDP                         = 22
 	IPPROTO_IP                      = 0
+	SOL_IP                          = 0
 	IPPROTO_IPV6                    = 41
+	SOL_IPV6                        = 41
 	IPPROTO_MAX                     = 256
+	SOL_MAX                         = 256
 	IPPROTO_NONE                    = 59
+	SOL_NONE                        = 59
 	IPPROTO_PUP                     = 12
+	SOL_PUP                         = 12
 	IPPROTO_RAW                     = 255
+	SOL_RAW                         = 255
 	IPPROTO_ROUTING                 = 43
+	SOL_ROUTING                     = 43
 	IPPROTO_TCP                     = 6
+	SOL_TCP                         = 6
 	IPPROTO_UDP                     = 17
+	SOL_UDP                         = 17
 	IPV6_ADDR_PREFERENCES           = 32
 	IPV6_CHECKSUM                   = 19
 	IPV6_DONTFRAG                   = 29
@@ -186,6 +205,7 @@ const (
 	MTM_SYNCHONLY                   = 0x00000200
 	MTM_REMOUNT                     = 0x00000100
 	MTM_NOSECURITY                  = 0x00000080
+	NFDBITS                         = 0x20
 	O_ACCMODE                       = 0x03
 	O_APPEND                        = 0x08
 	O_ASYNCSIG                      = 0x0200
@@ -359,6 +379,8 @@ const (
 	S_IFMST                         = 0x00FF0000
 	TCP_KEEPALIVE                   = 0x8
 	TCP_NODELAY                     = 0x1
+	TCP_INFO                        = 0xb
+	TCP_USER_TIMEOUT                = 0x1
 	TIOCGWINSZ                      = 0x4008a368
 	TIOCSWINSZ                      = 0x8008a367
 	TIOCSBRK                        = 0x2000a77b
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.1_13.s b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.1_13.s
index 00da1ebfca..1c73a1921d 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.1_13.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.1_13.s
@@ -1,6 +1,7 @@
 // go run mkasm_darwin.go 386
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build go1.13
 // +build go1.13
 
 #include "textflag.h"
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.s b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.s
index 1c53979a10..8cc7928d92 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.s
@@ -1,6 +1,7 @@
 // go run mkasm_darwin.go 386
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build go1.12
 // +build go1.12
 
 #include "textflag.h"
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.1_13.s b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.1_13.s
index d671e8311f..ab59833fcd 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.1_13.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.1_13.s
@@ -1,6 +1,7 @@
 // go run mkasm_darwin.go amd64
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build go1.13
 // +build go1.13
 
 #include "textflag.h"
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s
index c77bd6e20b..b8f316e676 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s
@@ -1,6 +1,7 @@
 // go run mkasm_darwin.go amd64
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build go1.12
 // +build go1.12
 
 #include "textflag.h"
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.1_13.s b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.1_13.s
index 488e55707a..0cc80ad87e 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.1_13.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.1_13.s
@@ -1,6 +1,7 @@
 // go run mkasm_darwin.go arm
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build go1.13
 // +build go1.13
 
 #include "textflag.h"
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.s b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.s
index 5eec5f1d95..a99f9c1113 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.s
@@ -1,6 +1,7 @@
 // go run mkasm_darwin.go arm
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build go1.12
 // +build go1.12
 
 #include "textflag.h"
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.1_13.s b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.1_13.s
index b29dabb0f0..a5f96ffb07 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.1_13.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.1_13.s
@@ -1,6 +1,7 @@
 // go run mkasm_darwin.go arm64
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build go1.13
 // +build go1.13
 
 #include "textflag.h"
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s
index 53c402bf68..e30a697407 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s
@@ -1,6 +1,7 @@
 // go run mkasm_darwin.go arm64
 // Code generated by the command above; DO NOT EDIT.
 
+//go:build go1.12
 // +build go1.12
 
 #include "textflag.h"
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_zos_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_zos_s390x.go
index 8285ab8419..f2079457c6 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_zos_s390x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_zos_s390x.go
@@ -364,6 +364,22 @@ func Dup2(oldfd int, newfd int) (err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func Errno2() (er2 int) {
+	uer2, _, _ := syscall_syscall(SYS___ERRNO2, 0, 0, 0)
+	er2 = int(uer2)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Err2ad() (eadd *int) {
+	ueadd, _, _ := syscall_syscall(SYS___ERR2AD, 0, 0, 0)
+	eadd = (*int)(unsafe.Pointer(ueadd))
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Exit(code int) {
 	syscall_syscall(SYS_EXIT, uintptr(code), 0, 0)
 	return
@@ -531,7 +547,18 @@ func W_Getmntent(buff *byte, size int) (lastsys int, err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func Mount(path string, filesystem string, fstype string, mtm uint32, parmlen int32, parm string) (err error) {
+func W_Getmntent_A(buff *byte, size int) (lastsys int, err error) {
+	r0, _, e1 := syscall_syscall(SYS___W_GETMNTENT_A, uintptr(unsafe.Pointer(buff)), uintptr(size), 0)
+	lastsys = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func mount_LE(path string, filesystem string, fstype string, mtm uint32, parmlen int32, parm string) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
 	if err != nil {
@@ -561,7 +588,7 @@ func Mount(path string, filesystem string, fstype string, mtm uint32, parmlen in
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func Unmount(filesystem string, mtm int) (err error) {
+func unmount(filesystem string, mtm int) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(filesystem)
 	if err != nil {
@@ -1215,3 +1242,14 @@ func utimes(path string, timeval *[2]Timeval) (err error) {
 	}
 	return
 }
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Select(nmsgsfds int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (ret int, err error) {
+	r0, _, e1 := syscall_syscall6(SYS_SELECT, uintptr(nmsgsfds), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
index 8e53597134..fbc59b7fdd 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
@@ -438,4 +438,5 @@ const (
 	SYS_FACCESSAT2                   = 439
 	SYS_PROCESS_MADVISE              = 440
 	SYS_EPOLL_PWAIT2                 = 441
+	SYS_MOUNT_SETATTR                = 442
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
index d7dceb769b..04d16d771e 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
@@ -360,4 +360,5 @@ const (
 	SYS_FACCESSAT2             = 439
 	SYS_PROCESS_MADVISE        = 440
 	SYS_EPOLL_PWAIT2           = 441
+	SYS_MOUNT_SETATTR          = 442
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
index 04093a69fd..3b1c105137 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
@@ -402,4 +402,5 @@ const (
 	SYS_FACCESSAT2                   = 439
 	SYS_PROCESS_MADVISE              = 440
 	SYS_EPOLL_PWAIT2                 = 441
+	SYS_MOUNT_SETATTR                = 442
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
index 48f94f135d..3198adcf77 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
@@ -305,4 +305,5 @@ const (
 	SYS_FACCESSAT2             = 439
 	SYS_PROCESS_MADVISE        = 440
 	SYS_EPOLL_PWAIT2           = 441
+	SYS_MOUNT_SETATTR          = 442
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
index 499978c3e4..c877ec6e68 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
@@ -423,4 +423,5 @@ const (
 	SYS_FACCESSAT2                   = 4439
 	SYS_PROCESS_MADVISE              = 4440
 	SYS_EPOLL_PWAIT2                 = 4441
+	SYS_MOUNT_SETATTR                = 4442
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
index 10d1db2be0..b5f2903729 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
@@ -353,4 +353,5 @@ const (
 	SYS_FACCESSAT2             = 5439
 	SYS_PROCESS_MADVISE        = 5440
 	SYS_EPOLL_PWAIT2           = 5441
+	SYS_MOUNT_SETATTR          = 5442
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
index 208d5dcd5a..46077689ab 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
@@ -353,4 +353,5 @@ const (
 	SYS_FACCESSAT2             = 5439
 	SYS_PROCESS_MADVISE        = 5440
 	SYS_EPOLL_PWAIT2           = 5441
+	SYS_MOUNT_SETATTR          = 5442
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
index f8250602eb..80e6696b39 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
@@ -423,4 +423,5 @@ const (
 	SYS_FACCESSAT2                   = 4439
 	SYS_PROCESS_MADVISE              = 4440
 	SYS_EPOLL_PWAIT2                 = 4441
+	SYS_MOUNT_SETATTR                = 4442
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go
index 7693656a6b..b9d697ffb1 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go
@@ -430,4 +430,5 @@ const (
 	SYS_FACCESSAT2                   = 439
 	SYS_PROCESS_MADVISE              = 440
 	SYS_EPOLL_PWAIT2                 = 441
+	SYS_MOUNT_SETATTR                = 442
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
index d5ed3ff510..08edc54d35 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
@@ -402,4 +402,5 @@ const (
 	SYS_FACCESSAT2             = 439
 	SYS_PROCESS_MADVISE        = 440
 	SYS_EPOLL_PWAIT2           = 441
+	SYS_MOUNT_SETATTR          = 442
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
index e29b4424c2..33b33b0834 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
@@ -402,4 +402,5 @@ const (
 	SYS_FACCESSAT2             = 439
 	SYS_PROCESS_MADVISE        = 440
 	SYS_EPOLL_PWAIT2           = 441
+	SYS_MOUNT_SETATTR          = 442
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
index 41deed6c3a..66c8a8e09e 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
@@ -304,4 +304,5 @@ const (
 	SYS_FACCESSAT2             = 439
 	SYS_PROCESS_MADVISE        = 440
 	SYS_EPOLL_PWAIT2           = 441
+	SYS_MOUNT_SETATTR          = 442
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
index 8e53a9e8ce..aea5760cea 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
@@ -367,4 +367,5 @@ const (
 	SYS_FACCESSAT2             = 439
 	SYS_PROCESS_MADVISE        = 440
 	SYS_EPOLL_PWAIT2           = 441
+	SYS_MOUNT_SETATTR          = 442
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
index 596e5bc7d3..488ca848d1 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
@@ -381,4 +381,5 @@ const (
 	SYS_FACCESSAT2             = 439
 	SYS_PROCESS_MADVISE        = 440
 	SYS_EPOLL_PWAIT2           = 441
+	SYS_MOUNT_SETATTR          = 442
 )
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_illumos_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_illumos_amd64.go
index 1137a5a1f4..236f37ef6f 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_illumos_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_illumos_amd64.go
@@ -25,14 +25,14 @@ type strbuf struct {
 	Buf    *int8
 }
 
-type strioctl struct {
+type Strioctl struct {
 	Cmd    int32
 	Timout int32
 	Len    int32
 	Dp     *int8
 }
 
-type lifreq struct {
+type Lifreq struct {
 	Name   [32]int8
 	Lifru1 [4]byte
 	Type   uint32
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go
index 3bfc6f7323..087323591e 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go
@@ -1016,7 +1016,10 @@ const (
 	PERF_SAMPLE_PHYS_ADDR                 = 0x80000
 	PERF_SAMPLE_AUX                       = 0x100000
 	PERF_SAMPLE_CGROUP                    = 0x200000
-	PERF_SAMPLE_MAX                       = 0x1000000
+	PERF_SAMPLE_DATA_PAGE_SIZE            = 0x400000
+	PERF_SAMPLE_CODE_PAGE_SIZE            = 0x800000
+	PERF_SAMPLE_WEIGHT_STRUCT             = 0x1000000
+	PERF_SAMPLE_MAX                       = 0x2000000
 	PERF_SAMPLE_BRANCH_USER_SHIFT         = 0x0
 	PERF_SAMPLE_BRANCH_KERNEL_SHIFT       = 0x1
 	PERF_SAMPLE_BRANCH_HV_SHIFT           = 0x2
@@ -3126,7 +3129,8 @@ const (
 	DEVLINK_ATTR_REMOTE_RELOAD_STATS                   = 0xa1
 	DEVLINK_ATTR_RELOAD_ACTION_INFO                    = 0xa2
 	DEVLINK_ATTR_RELOAD_ACTION_STATS                   = 0xa3
-	DEVLINK_ATTR_MAX                                   = 0xa3
+	DEVLINK_ATTR_PORT_PCI_SF_NUMBER                    = 0xa4
+	DEVLINK_ATTR_MAX                                   = 0xa4
 	DEVLINK_DPIPE_FIELD_MAPPING_TYPE_NONE              = 0x0
 	DEVLINK_DPIPE_FIELD_MAPPING_TYPE_IFINDEX           = 0x1
 	DEVLINK_DPIPE_MATCH_TYPE_FIELD_EXACT               = 0x0
@@ -3140,7 +3144,9 @@ const (
 	DEVLINK_RESOURCE_UNIT_ENTRY                        = 0x0
 	DEVLINK_PORT_FUNCTION_ATTR_UNSPEC                  = 0x0
 	DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR                 = 0x1
-	DEVLINK_PORT_FUNCTION_ATTR_MAX                     = 0x1
+	DEVLINK_PORT_FN_ATTR_STATE                         = 0x2
+	DEVLINK_PORT_FN_ATTR_OPSTATE                       = 0x3
+	DEVLINK_PORT_FUNCTION_ATTR_MAX                     = 0x3
 )
 
 type FsverityDigest struct {
@@ -3509,7 +3515,8 @@ const (
 	ETHTOOL_A_LINKMODES_DUPLEX                = 0x6
 	ETHTOOL_A_LINKMODES_MASTER_SLAVE_CFG      = 0x7
 	ETHTOOL_A_LINKMODES_MASTER_SLAVE_STATE    = 0x8
-	ETHTOOL_A_LINKMODES_MAX                   = 0x8
+	ETHTOOL_A_LINKMODES_LANES                 = 0x9
+	ETHTOOL_A_LINKMODES_MAX                   = 0x9
 	ETHTOOL_A_LINKSTATE_UNSPEC                = 0x0
 	ETHTOOL_A_LINKSTATE_HEADER                = 0x1
 	ETHTOOL_A_LINKSTATE_LINK                  = 0x2
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go
index 8bffde78e5..4ab638cb94 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go
@@ -347,6 +347,10 @@ type Dirent struct {
 	Name   [256]byte
 }
 
+type FdSet struct {
+	Bits [64]int32
+}
+
 // This struct is packed on z/OS so it can't be used directly.
 type Flock_t struct {
 	Type   int16
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index a5dd28b7dc..6b19ec3aea 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -39,8 +39,8 @@ golang.org/x/mod/sumdb/dirhash
 golang.org/x/mod/sumdb/note
 golang.org/x/mod/sumdb/tlog
 golang.org/x/mod/zip
-# golang.org/x/sys v0.0.0-20210423082822-04245dca01da
-## explicit; go 1.12
+# golang.org/x/sys v0.0.0-20210503173754-0981d6026fa6
+## explicit; go 1.17
 golang.org/x/sys/internal/unsafeheader
 golang.org/x/sys/plan9
 golang.org/x/sys/unix
@@ -48,7 +48,7 @@ golang.org/x/sys/windows
 # golang.org/x/term v0.0.0-20210503060354-a79de5458b56
 ## explicit; go 1.17
 golang.org/x/term
-# golang.org/x/tools v0.1.1-0.20210503200558-19b1717ea5eb
+# golang.org/x/tools v0.1.1-0.20210505014545-7cab0ef2e9a5
 ## explicit; go 1.17
 golang.org/x/tools/cover
 golang.org/x/tools/go/analysis
diff --git a/src/go.mod b/src/go.mod
index 8402cf12aa..a3ceb05890 100644
--- a/src/go.mod
+++ b/src/go.mod
@@ -4,7 +4,7 @@ go 1.17
 
 require (
 	golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e
-	golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420
-	golang.org/x/sys v0.0.0-20210423082822-04245dca01da // indirect
+	golang.org/x/net v0.0.0-20210505024714-0287a6fb4125
+	golang.org/x/sys v0.0.0-20210503173754-0981d6026fa6 // indirect
 	golang.org/x/text v0.3.7-0.20210503195748-5c7c50ebbd4f // indirect
 )
diff --git a/src/go.sum b/src/go.sum
index 5f93c1cd49..27513a350d 100644
--- a/src/go.sum
+++ b/src/go.sum
@@ -1,8 +1,8 @@
 golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e h1:8foAy0aoO5GkqCvAEJ4VC4P3zksTg4X4aJCDpZzmgQI=
 golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
-golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420 h1:a8jGStKg0XqKDlKqjLrXn0ioF5MH36pT7Z0BRTqLhbk=
-golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da h1:b3NXsE2LusjYGGjL5bxEVZZORm/YEFFrWFjR8eFrw/c=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/net v0.0.0-20210505024714-0287a6fb4125 h1:Ugb8sMTWuWRC3+sz5WeN/4kejDx9BvIwnPUiJBjJE+8=
+golang.org/x/net v0.0.0-20210505024714-0287a6fb4125/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/sys v0.0.0-20210503173754-0981d6026fa6 h1:cdsMqa2nXzqlgs183pHxtvoVwU7CyzaCTAUOg94af4c=
+golang.org/x/sys v0.0.0-20210503173754-0981d6026fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/text v0.3.7-0.20210503195748-5c7c50ebbd4f h1:yQJrRE0hDxDFmZLlRaw+3vusO4fwNHgHIjUOMO7bHYI=
 golang.org/x/text v0.3.7-0.20210503195748-5c7c50ebbd4f/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
diff --git a/src/net/http/h2_bundle.go b/src/net/http/h2_bundle.go
index ad311946d5..fd540ff255 100644
--- a/src/net/http/h2_bundle.go
+++ b/src/net/http/h2_bundle.go
@@ -755,61 +755,69 @@ func (p *http2clientConnPool) getClientConn(req *Request, addr string, dialOnMis
 		// It gets its own connection.
 		http2traceGetConn(req, addr)
 		const singleUse = true
-		cc, err := p.t.dialClientConn(addr, singleUse)
+		cc, err := p.t.dialClientConn(req.Context(), addr, singleUse)
 		if err != nil {
 			return nil, err
 		}
 		return cc, nil
 	}
-	p.mu.Lock()
-	for _, cc := range p.conns[addr] {
-		if st := cc.idleState(); st.canTakeNewRequest {
-			if p.shouldTraceGetConn(st) {
-				http2traceGetConn(req, addr)
+	for {
+		p.mu.Lock()
+		for _, cc := range p.conns[addr] {
+			if st := cc.idleState(); st.canTakeNewRequest {
+				if p.shouldTraceGetConn(st) {
+					http2traceGetConn(req, addr)
+				}
+				p.mu.Unlock()
+				return cc, nil
 			}
+		}
+		if !dialOnMiss {
 			p.mu.Unlock()
-			return cc, nil
+			return nil, http2ErrNoCachedConn
 		}
-	}
-	if !dialOnMiss {
+		http2traceGetConn(req, addr)
+		call := p.getStartDialLocked(req.Context(), addr)
 		p.mu.Unlock()
-		return nil, http2ErrNoCachedConn
+		<-call.done
+		if http2shouldRetryDial(call, req) {
+			continue
+		}
+		return call.res, call.err
 	}
-	http2traceGetConn(req, addr)
-	call := p.getStartDialLocked(addr)
-	p.mu.Unlock()
-	<-call.done
-	return call.res, call.err
 }
 
 // dialCall is an in-flight Transport dial call to a host.
 type http2dialCall struct {
-	_    http2incomparable
-	p    *http2clientConnPool
+	_ http2incomparable
+	p *http2clientConnPool
+	// the context associated with the request
+	// that created this dialCall
+	ctx  context.Context
 	done chan struct{}    // closed when done
 	res  *http2ClientConn // valid after done is closed
 	err  error            // valid after done is closed
 }
 
 // requires p.mu is held.
-func (p *http2clientConnPool) getStartDialLocked(addr string) *http2dialCall {
+func (p *http2clientConnPool) getStartDialLocked(ctx context.Context, addr string) *http2dialCall {
 	if call, ok := p.dialing[addr]; ok {
 		// A dial is already in-flight. Don't start another.
 		return call
 	}
-	call := &http2dialCall{p: p, done: make(chan struct{})}
+	call := &http2dialCall{p: p, done: make(chan struct{}), ctx: ctx}
 	if p.dialing == nil {
 		p.dialing = make(map[string]*http2dialCall)
 	}
 	p.dialing[addr] = call
-	go call.dial(addr)
+	go call.dial(call.ctx, addr)
 	return call
 }
 
 // run in its own goroutine.
-func (c *http2dialCall) dial(addr string) {
+func (c *http2dialCall) dial(ctx context.Context, addr string) {
 	const singleUse = false // shared conn
-	c.res, c.err = c.p.t.dialClientConn(addr, singleUse)
+	c.res, c.err = c.p.t.dialClientConn(ctx, addr, singleUse)
 	close(c.done)
 
 	c.p.mu.Lock()
@@ -954,6 +962,31 @@ func (p http2noDialClientConnPool) GetClientConn(req *Request, addr string) (*ht
 	return p.getClientConn(req, addr, http2noDialOnMiss)
 }
 
+// shouldRetryDial reports whether the current request should
+// retry dialing after the call finished unsuccessfully, for example
+// if the dial was canceled because of a context cancellation or
+// deadline expiry.
+func http2shouldRetryDial(call *http2dialCall, req *Request) bool {
+	if call.err == nil {
+		// No error, no need to retry
+		return false
+	}
+	if call.ctx == req.Context() {
+		// If the call has the same context as the request, the dial
+		// should not be retried, since any cancellation will have come
+		// from this request.
+		return false
+	}
+	if !errors.Is(call.err, context.Canceled) && !errors.Is(call.err, context.DeadlineExceeded) {
+		// If the call error is not because of a context cancellation or a deadline expiry,
+		// the dial should not be retried.
+		return false
+	}
+	// Only retry if the error is a context cancellation error or deadline expiry
+	// and the context associated with the call was canceled or expired.
+	return call.ctx.Err() != nil
+}
+
 // Buffer chunks are allocated from a pool to reduce pressure on GC.
 // The maximum wasted space per dataBuffer is 2x the largest size class,
 // which happens when the dataBuffer has multiple chunks and there is
@@ -7084,12 +7117,12 @@ func http2canRetryError(err error) bool {
 	return false
 }
 
-func (t *http2Transport) dialClientConn(addr string, singleUse bool) (*http2ClientConn, error) {
+func (t *http2Transport) dialClientConn(ctx context.Context, addr string, singleUse bool) (*http2ClientConn, error) {
 	host, _, err := net.SplitHostPort(addr)
 	if err != nil {
 		return nil, err
 	}
-	tconn, err := t.dialTLS()("tcp", addr, t.newTLSConfig(host))
+	tconn, err := t.dialTLS(ctx)("tcp", addr, t.newTLSConfig(host))
 	if err != nil {
 		return nil, err
 	}
@@ -7110,34 +7143,28 @@ func (t *http2Transport) newTLSConfig(host string) *tls.Config {
 	return cfg
 }
 
-func (t *http2Transport) dialTLS() func(string, string, *tls.Config) (net.Conn, error) {
+func (t *http2Transport) dialTLS(ctx context.Context) func(string, string, *tls.Config) (net.Conn, error) {
 	if t.DialTLS != nil {
 		return t.DialTLS
 	}
-	return t.dialTLSDefault
-}
-
-func (t *http2Transport) dialTLSDefault(network, addr string, cfg *tls.Config) (net.Conn, error) {
-	cn, err := tls.Dial(network, addr, cfg)
-	if err != nil {
-		return nil, err
-	}
-	if err := cn.Handshake(); err != nil {
-		return nil, err
-	}
-	if !cfg.InsecureSkipVerify {
-		if err := cn.VerifyHostname(cfg.ServerName); err != nil {
+	return func(network, addr string, cfg *tls.Config) (net.Conn, error) {
+		dialer := &tls.Dialer{
+			Config: cfg,
+		}
+		cn, err := dialer.DialContext(ctx, network, addr)
+		if err != nil {
 			return nil, err
 		}
+		tlsCn := cn.(*tls.Conn) // DialContext comment promises this will always succeed
+		state := tlsCn.ConnectionState()
+		if p := state.NegotiatedProtocol; p != http2NextProtoTLS {
+			return nil, fmt.Errorf("http2: unexpected ALPN protocol %q; want %q", p, http2NextProtoTLS)
+		}
+		if !state.NegotiatedProtocolIsMutual {
+			return nil, errors.New("http2: could not negotiate protocol mutually")
+		}
+		return cn, nil
 	}
-	state := cn.ConnectionState()
-	if p := state.NegotiatedProtocol; p != http2NextProtoTLS {
-		return nil, fmt.Errorf("http2: unexpected ALPN protocol %q; want %q", p, http2NextProtoTLS)
-	}
-	if !state.NegotiatedProtocolIsMutual {
-		return nil, errors.New("http2: could not negotiate protocol mutually")
-	}
-	return cn, nil
 }
 
 // disableKeepAlives reports whether connections should be closed as
diff --git a/src/vendor/golang.org/x/sys/cpu/asm_aix_ppc64.s b/src/vendor/golang.org/x/sys/cpu/asm_aix_ppc64.s
index 6b4027b33f..db9171c2e4 100644
--- a/src/vendor/golang.org/x/sys/cpu/asm_aix_ppc64.s
+++ b/src/vendor/golang.org/x/sys/cpu/asm_aix_ppc64.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build gc
 // +build gc
 
 #include "textflag.h"
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_arm64.s b/src/vendor/golang.org/x/sys/cpu/cpu_arm64.s
index cfc08c9794..c61f95a05a 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_arm64.s
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_arm64.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build gc
 // +build gc
 
 #include "textflag.h"
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go b/src/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go
index fa7cdb9bcd..3298a87e98 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go
@@ -15,3 +15,7 @@ func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32)
 // xgetbv with ecx = 0 is implemented in cpu_x86.s for gc compiler
 // and in cpu_gccgo.c for gccgo.
 func xgetbv() (eax, edx uint32)
+
+// darwinSupportsAVX512 is implemented in cpu_x86.s for gc compiler
+// and in cpu_gccgo_x86.go for gccgo.
+func darwinSupportsAVX512() bool
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go b/src/vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go
index 8478a6d597..863d415ab4 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go
@@ -25,3 +25,9 @@ func xgetbv() (eax, edx uint32) {
 	gccgoXgetbv(&a, &d)
 	return a, d
 }
+
+// gccgo doesn't build on Darwin, per:
+// https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/gcc.rb#L76
+func darwinSupportsAVX512() bool {
+	return false
+}
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_s390x.s b/src/vendor/golang.org/x/sys/cpu/cpu_s390x.s
index 964946df95..96f81e2097 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_s390x.s
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_s390x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build gc
 // +build gc
 
 #include "textflag.h"
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_x86.go b/src/vendor/golang.org/x/sys/cpu/cpu_x86.go
index fd380c0a71..54ca4667fb 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_x86.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_x86.go
@@ -87,8 +87,14 @@ func archInit() {
 		// Check if XMM and YMM registers have OS support.
 		osSupportsAVX = isSet(1, eax) && isSet(2, eax)
 
-		// Check if OPMASK and ZMM registers have OS support.
-		osSupportsAVX512 = osSupportsAVX && isSet(5, eax) && isSet(6, eax) && isSet(7, eax)
+		if runtime.GOOS == "darwin" {
+			// Check darwin commpage for AVX512 support. Necessary because:
+			// https://github.com/apple/darwin-xnu/blob/0a798f6738bc1db01281fc08ae024145e84df927/osfmk/i386/fpu.c#L175-L201
+			osSupportsAVX512 = osSupportsAVX && darwinSupportsAVX512()
+		} else {
+			// Check if OPMASK and ZMM registers have OS support.
+			osSupportsAVX512 = osSupportsAVX && isSet(5, eax) && isSet(6, eax) && isSet(7, eax)
+		}
 	}
 
 	X86.HasAVX = isSet(28, ecx1) && osSupportsAVX
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_x86.s b/src/vendor/golang.org/x/sys/cpu/cpu_x86.s
index 2f557a5887..b748ba52f7 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_x86.s
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_x86.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (386 || amd64 || amd64p32) && gc
 // +build 386 amd64 amd64p32
 // +build gc
 
@@ -25,3 +26,27 @@ TEXT ·xgetbv(SB),NOSPLIT,$0-8
 	MOVL AX, eax+0(FP)
 	MOVL DX, edx+4(FP)
 	RET
+
+// func darwinSupportsAVX512() bool
+TEXT ·darwinSupportsAVX512(SB), NOSPLIT, $0-1
+    MOVB    $0, ret+0(FP) // default to false
+#ifdef GOOS_darwin   // return if not darwin
+#ifdef GOARCH_amd64  // return if not amd64
+// These values from:
+// https://github.com/apple/darwin-xnu/blob/xnu-4570.1.46/osfmk/i386/cpu_capabilities.h
+#define commpage64_base_address         0x00007fffffe00000
+#define commpage64_cpu_capabilities64   (commpage64_base_address+0x010)
+#define commpage64_version              (commpage64_base_address+0x01E)
+#define hasAVX512F                      0x0000004000000000
+    MOVQ    $commpage64_version, BX
+    CMPW    (BX), $13  // cpu_capabilities64 undefined in versions < 13
+    JL      no_avx512
+    MOVQ    $commpage64_cpu_capabilities64, BX
+    MOVQ    $hasAVX512F, CX
+    TESTQ   (BX), CX
+    JZ      no_avx512
+    MOVB    $1, ret+0(FP)
+no_avx512:
+#endif
+#endif
+    RET
diff --git a/src/vendor/modules.txt b/src/vendor/modules.txt
index 8658b7da15..5b939af60d 100644
--- a/src/vendor/modules.txt
+++ b/src/vendor/modules.txt
@@ -8,7 +8,7 @@ golang.org/x/crypto/curve25519
 golang.org/x/crypto/hkdf
 golang.org/x/crypto/internal/subtle
 golang.org/x/crypto/poly1305
-# golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420
+# golang.org/x/net v0.0.0-20210505024714-0287a6fb4125
 ## explicit; go 1.17
 golang.org/x/net/dns/dnsmessage
 golang.org/x/net/http/httpguts
@@ -18,8 +18,8 @@ golang.org/x/net/idna
 golang.org/x/net/lif
 golang.org/x/net/nettest
 golang.org/x/net/route
-# golang.org/x/sys v0.0.0-20210423082822-04245dca01da
-## explicit; go 1.12
+# golang.org/x/sys v0.0.0-20210503173754-0981d6026fa6
+## explicit; go 1.17
 golang.org/x/sys/cpu
 # golang.org/x/text v0.3.7-0.20210503195748-5c7c50ebbd4f
 ## explicit; go 1.17
-- 
GitLab


From 3b304ce7fe35b9d1e8cf0b0518ed2550c361a010 Mon Sep 17 00:00:00 2001
From: Andy Pan <panjf2000@gmail.com>
Date: Fri, 23 Apr 2021 21:25:06 +0800
Subject: [PATCH 1973/2400] runtime: implement runqdrain() for GC mark worker
 goroutines

Revive CL 310149

Change-Id: Ib4714ea5b2ade32c0f66edff841a79d8212bd79a
Reviewed-on: https://go-review.googlesource.com/c/go/+/313009
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Michael Pratt <mpratt@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
Trust: Michael Pratt <mpratt@google.com>
Trust: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/mgc.go      | 12 ++++--------
 src/runtime/proc.go     | 41 +++++++++++++++++++++++++++++++++++++++++
 src/runtime/runtime2.go |  3 +++
 3 files changed, 48 insertions(+), 8 deletions(-)

diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index 601593087d..4585663535 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -1273,15 +1273,11 @@ func gcBgMarkWorker() {
 					// everything out of the run
 					// queue so it can run
 					// somewhere else.
-					lock(&sched.lock)
-					for {
-						gp, _ := runqget(pp)
-						if gp == nil {
-							break
-						}
-						globrunqput(gp)
+					if drainQ, n := runqdrain(pp); n > 0 {
+						lock(&sched.lock)
+						globrunqputbatch(&drainQ, int32(n))
+						unlock(&sched.lock)
 					}
-					unlock(&sched.lock)
 				}
 				// Go back to draining, this time
 				// without preemption.
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 480afd07dd..d9f8c65530 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -5729,6 +5729,8 @@ func globrunqputhead(gp *g) {
 // Put a batch of runnable goroutines on the global runnable queue.
 // This clears *batch.
 // sched.lock must be held.
+// May run during STW, so write barriers are not allowed.
+//go:nowritebarrierrec
 func globrunqputbatch(batch *gQueue, n int32) {
 	assertLockHeld(&sched.lock)
 
@@ -6044,6 +6046,45 @@ func runqget(_p_ *p) (gp *g, inheritTime bool) {
 	}
 }
 
+// runqdrain drains the local runnable queue of _p_ and returns all goroutines in it.
+// Executed only by the owner P.
+func runqdrain(_p_ *p) (drainQ gQueue, n uint32) {
+	oldNext := _p_.runnext
+	if oldNext != 0 && _p_.runnext.cas(oldNext, 0) {
+		drainQ.pushBack(oldNext.ptr())
+		n++
+	}
+
+retry:
+	h := atomic.LoadAcq(&_p_.runqhead) // load-acquire, synchronize with other consumers
+	t := _p_.runqtail
+	qn := t - h
+	if qn == 0 {
+		return
+	}
+	if qn > uint32(len(_p_.runq)) { // read inconsistent h and t
+		goto retry
+	}
+
+	if !atomic.CasRel(&_p_.runqhead, h, h+qn) { // cas-release, commits consume
+		goto retry
+	}
+
+	// We've inverted the order in which it gets G's from the local P's runnable queue
+	// and then advances the head pointer because we don't want to mess up the statuses of G's
+	// while runqdrain() and runqsteal() are running in parallel.
+	// Thus we should advance the head pointer before draining the local P into a gQueue,
+	// so that we can update any gp.schedlink only after we take the full ownership of G,
+	// meanwhile, other P's can't access to all G's in local P's runnable queue and steal them.
+	// See https://groups.google.com/g/golang-dev/c/0pTKxEKhHSc/m/6Q85QjdVBQAJ for more details.
+	for i := uint32(0); i < qn; i++ {
+		gp := _p_.runq[(h+i)%uint32(len(_p_.runq))].ptr()
+		drainQ.pushBack(gp)
+		n++
+	}
+	return
+}
+
 // Grabs a batch of goroutines from _p_'s runnable queue into batch.
 // Batch is a ring buffer starting at batchHead.
 // Returns number of grabbed goroutines.
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index 7fc7174334..0e0eb0b728 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -633,6 +633,9 @@ type p struct {
 	// unit and eliminates the (potentially large) scheduling
 	// latency that otherwise arises from adding the ready'd
 	// goroutines to the end of the run queue.
+	//
+	// Note that while other P's may atomically CAS this to zero,
+	// only the owner P can CAS it to a valid G.
 	runnext guintptr
 
 	// Available G's (status == Gdead)
-- 
GitLab


From 69368cece5a50056fbfc58010dd6e6ec585611e1 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Fri, 30 Apr 2021 10:47:24 -0700
Subject: [PATCH 1974/2400] cmd/compile/internal/types2: make TestManual work
 for directories

If no source argument is provided, test testdata/manual.go2
instead.

Remove testdata/check/tmp/go2 in favor of testdata/manual.go2.

These changes affect testing only.

Change-Id: I49aba4d8fc4cc5964911e38c55b4c5d013710aeb
Reviewed-on: https://go-review.googlesource.com/c/go/+/315769
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/check_test.go | 85 ++++++++++++-------
 .../internal/types2/testdata/check/tmp.go2    | 17 ----
 .../internal/types2/testdata/manual.go2       |  8 ++
 3 files changed, 64 insertions(+), 46 deletions(-)
 delete mode 100644 src/cmd/compile/internal/types2/testdata/check/tmp.go2
 create mode 100644 src/cmd/compile/internal/types2/testdata/manual.go2

diff --git a/src/cmd/compile/internal/types2/check_test.go b/src/cmd/compile/internal/types2/check_test.go
index a3a0eea0cc..41b0c54702 100644
--- a/src/cmd/compile/internal/types2/check_test.go
+++ b/src/cmd/compile/internal/types2/check_test.go
@@ -96,7 +96,7 @@ func asGoVersion(s string) string {
 	return ""
 }
 
-func checkFiles(t *testing.T, filenames []string, goVersion string, colDelta uint, manual bool) {
+func testFiles(t *testing.T, filenames []string, colDelta uint, manual bool) {
 	if len(filenames) == 0 {
 		t.Fatal("no source files")
 	}
@@ -114,6 +114,7 @@ func checkFiles(t *testing.T, filenames []string, goVersion string, colDelta uin
 	}
 
 	// if no Go version is given, consider the package name
+	goVersion := *goVersion
 	if goVersion == "" {
 		goVersion = asGoVersion(pkgName)
 	}
@@ -239,35 +240,54 @@ func checkFiles(t *testing.T, filenames []string, goVersion string, colDelta uin
 	}
 }
 
-// TestManual is for manual testing of input files, provided as a list
-// of arguments after the test arguments (and a separating "--"). For
-// instance, to check the files foo.go and bar.go, use:
+// TestManual is for manual testing of a package - either provided
+// as a list of filenames belonging to the package, or a directory
+// name containing the package files - after the test arguments
+// (and a separating "--"). For instance, to test the package made
+// of the files foo.go and bar.go, use:
 //
 // 	go test -run Manual -- foo.go bar.go
 //
-// Provide the -verify flag to verify errors against ERROR comments in
-// the input files rather than having a list of errors reported.
-// The accepted Go language version can be controlled with the -lang flag.
+// If no source arguments are provided, the file testdata/manual.go2
+// is used instead.
+// Provide the -verify flag to verify errors against ERROR comments
+// in the input files rather than having a list of errors reported.
+// The accepted Go language version can be controlled with the -lang
+// flag.
 func TestManual(t *testing.T) {
+	testenv.MustHaveGoBuild(t)
+
 	filenames := flag.Args()
 	if len(filenames) == 0 {
-		return
+		filenames = []string{filepath.FromSlash("testdata/manual.go2")}
 	}
-	testenv.MustHaveGoBuild(t)
+
+	info, err := os.Stat(filenames[0])
+	if err != nil {
+		t.Fatalf("TestManual: %v", err)
+	}
+
 	DefPredeclaredTestFuncs()
-	checkFiles(t, filenames, *goVersion, 0, true)
+	if info.IsDir() {
+		if len(filenames) > 1 {
+			t.Fatal("TestManual: must have only one directory argument")
+		}
+		testDir(t, filenames[0], 0, true)
+	} else {
+		testFiles(t, filenames, 0, true)
+	}
 }
 
 // TODO(gri) go/types has extra TestLongConstants and TestIndexRepresentability tests
 
-func TestCheck(t *testing.T)     { DefPredeclaredTestFuncs(); testDir(t, "check", 75) } // TODO(gri) narrow column tolerance
-func TestExamples(t *testing.T)  { testDir(t, "examples", 0) }
-func TestFixedbugs(t *testing.T) { testDir(t, "fixedbugs", 0) }
+func TestCheck(t *testing.T)     { DefPredeclaredTestFuncs(); testDirFiles(t, "testdata/check", 75, false) } // TODO(gri) narrow column tolerance
+func TestExamples(t *testing.T)  { testDirFiles(t, "testdata/examples", 0, false) }
+func TestFixedbugs(t *testing.T) { testDirFiles(t, "testdata/fixedbugs", 0, false) }
 
-func testDir(t *testing.T, dir string, colDelta uint) {
+func testDirFiles(t *testing.T, dir string, colDelta uint, manual bool) {
 	testenv.MustHaveGoBuild(t)
+	dir = filepath.FromSlash(dir)
 
-	dir = filepath.Join("testdata", dir)
 	fis, err := os.ReadDir(dir)
 	if err != nil {
 		t.Error(err)
@@ -277,23 +297,30 @@ func testDir(t *testing.T, dir string, colDelta uint) {
 	for _, fi := range fis {
 		path := filepath.Join(dir, fi.Name())
 
-		// if fi is a directory, its files make up a single package
-		var filenames []string
+		// If fi is a directory, its files make up a single package.
 		if fi.IsDir() {
-			fis, err := os.ReadDir(path)
-			if err != nil {
-				t.Error(err)
-				continue
-			}
-			for _, fi := range fis {
-				filenames = append(filenames, filepath.Join(path, fi.Name()))
-			}
+			testDir(t, path, colDelta, manual)
 		} else {
-			filenames = []string{path}
+			t.Run(filepath.Base(path), func(t *testing.T) {
+				testFiles(t, []string{path}, colDelta, manual)
+			})
 		}
+	}
+}
+
+func testDir(t *testing.T, dir string, colDelta uint, manual bool) {
+	fis, err := os.ReadDir(dir)
+	if err != nil {
+		t.Error(err)
+		return
+	}
 
-		t.Run(filepath.Base(path), func(t *testing.T) {
-			checkFiles(t, filenames, *goVersion, colDelta, false)
-		})
+	var filenames []string
+	for _, fi := range fis {
+		filenames = append(filenames, filepath.Join(dir, fi.Name()))
 	}
+
+	t.Run(filepath.Base(dir), func(t *testing.T) {
+		testFiles(t, filenames, colDelta, manual)
+	})
 }
diff --git a/src/cmd/compile/internal/types2/testdata/check/tmp.go2 b/src/cmd/compile/internal/types2/testdata/check/tmp.go2
deleted file mode 100644
index dae78caff8..0000000000
--- a/src/cmd/compile/internal/types2/testdata/check/tmp.go2
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright 2020 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.
-
-// This file is meant as "dumping ground" for debugging code.
-
-package p
-
-// fun test case
-type C[P interface{m()}] P
-
-func (r C[P]) m() { r.m() }
-
-func f[T interface{m(); n()}](x T) {
-	y := C[T](x)
-	y.m()
-}
diff --git a/src/cmd/compile/internal/types2/testdata/manual.go2 b/src/cmd/compile/internal/types2/testdata/manual.go2
new file mode 100644
index 0000000000..efe13cf8bc
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/manual.go2
@@ -0,0 +1,8 @@
+// Copyright 2021 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.
+
+// This file is tested when running "go test -run Manual"
+// without source arguments. Use for one-off debugging.
+
+package p
-- 
GitLab


From 18e666bad75362ef7d031ebf557effdc42dd290f Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Wed, 5 May 2021 11:24:24 -0400
Subject: [PATCH 1975/2400] cmd/go: skip TestExecInDeletedDir on aix and
 solaris-based platforms

They empirically do not seem to support deleting the current working
directory.

Updates #34499

Change-Id: I705cdf8b545fbb837d5b75d2904a7c2a89276fa5
Reviewed-on: https://go-review.googlesource.com/c/go/+/317249
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/go/go_test.go | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/cmd/go/go_test.go b/src/cmd/go/go_test.go
index ff397a1995..a059a6dd90 100644
--- a/src/cmd/go/go_test.go
+++ b/src/cmd/go/go_test.go
@@ -2836,9 +2836,11 @@ func TestCoverpkgTestOnly(t *testing.T) {
 // Regression test for golang.org/issue/34499: version command should not crash
 // when executed in a deleted directory on Linux.
 func TestExecInDeletedDir(t *testing.T) {
-	// The crash has only been reproduced on Linux.
-	if runtime.GOOS == "windows" || runtime.GOOS == "plan9" {
-		t.Skip()
+	switch runtime.GOOS {
+	case "windows", "plan9",
+		"aix",                // Fails with "device busy".
+		"solaris", "illumos": // Fails with "invalid argument".
+		t.Skipf("%v does not support removing the current working directory", runtime.GOOS)
 	}
 	tg := testgo(t)
 	defer tg.cleanup()
-- 
GitLab


From d0583b131a1c4c99249aa1b158492cd99d7ee904 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Mon, 3 May 2021 01:59:13 -0400
Subject: [PATCH 1976/2400] cmd/go: spot-check the explicit requirements of
 root module dependencies when loading packages from them

For #36460

Change-Id: I725ef5445b2bac7af827fb38373e8cd6dbad2d09
Reviewed-on: https://go-review.googlesource.com/c/go/+/316249
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modload/buildlist.go      | 112 +++++++++++++++---
 .../testdata/script/mod_lazy_consistency.txt  |  95 +++++++++++++++
 2 files changed, 188 insertions(+), 19 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/mod_lazy_consistency.txt

diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index 7820fcf6f1..7a0cea405e 100644
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -665,6 +665,8 @@ func updateLazyRoots(ctx context.Context, direct map[string]bool, rs *Requiremen
 	roots := rs.rootModules
 	rootsUpgraded := false
 
+	spotCheckRoot := map[module.Version]bool{}
+
 	// “The selected version of the module providing each package marked with
 	// either pkgInAll or pkgIsRoot is included as a root.”
 	needSort := false
@@ -710,26 +712,36 @@ func updateLazyRoots(ctx context.Context, direct map[string]bool, rs *Requiremen
 			// relevant to consumers of the main module either), and its dependencies
 			// should already be in the module graph — included in the dependencies of
 			// the package that imported it.
-
-			if go117LazyTODO {
-				// It is possible that one of the packages we just imported came from a
-				// module with an incomplete or erroneous go.mod file — for example,
-				// perhaps the author forgot to 'git add' their updated go.mod file
-				// after adding a new package import. If that happens, ideally we want
-				// to detect the missing requirements and fix them up here.
-				//
-				// However, we should ignore transitive dependencies of external tests:
-				// the go.mod file for the module containing the test itself is expected
-				// to provide all of the relevant dependencies, and we explicitly don't
-				// want to pull in requirements on *irrelevant* requirements that happen
-				// to occur in the go.mod files for these transitive-test-only
-				// dependencies.
-			}
-
 			continue
 		}
 
-		if _, ok := rs.rootSelected(pkg.mod.Path); !ok {
+		if _, ok := rs.rootSelected(pkg.mod.Path); ok {
+			// It is possible that the main module's go.mod file is incomplete or
+			// otherwise erroneous — for example, perhaps the author forgot to 'git
+			// add' their updated go.mod file after adding a new package import, or
+			// perhaps they made an edit to the go.mod file using a third-party tool
+			// ('git merge'?) that doesn't maintain consistency for module
+			// dependencies. If that happens, ideally we want to detect the missing
+			// requirements and fix them up here.
+			//
+			// However, we also need to be careful not to be too aggressive. For
+			// transitive dependencies of external tests, the go.mod file for the
+			// module containing the test itself is expected to provide all of the
+			// relevant dependencies, and we explicitly don't want to pull in
+			// requirements on *irrelevant* requirements that happen to occur in the
+			// go.mod files for these transitive-test-only dependencies. (See the test
+			// in mod_lazy_test_horizon.txt for a concrete example.
+			//
+			// The “goldilocks zone” seems to be to spot-check exactly the same
+			// modules that we promote to explicit roots: namely, those that provide
+			// packages transitively imported by the main module, and those that
+			// provide roots of the package-import graph. That will catch erroneous
+			// edits to the main module's go.mod file and inconsistent requirements in
+			// dependencies that provide imported packages, but will ignore erroneous
+			// or misleading requirements in dependencies that aren't obviously
+			// relevant to the packages in the main module.
+			spotCheckRoot[pkg.mod] = true
+		} else {
 			roots = append(roots, pkg.mod)
 			rootsUpgraded = true
 			// The roots slice was initially sorted because rs.rootModules was sorted,
@@ -774,8 +786,31 @@ func updateLazyRoots(ctx context.Context, direct map[string]bool, rs *Requiremen
 		} else {
 			// Since none of the roots have been upgraded, we have no reason to
 			// suspect that they are inconsistent with the requirements of any other
-			// roots. Only look at the full module graph if we've already loaded it.
-			mg, _ = rs.graph.Load().(*ModuleGraph) // May be nil.
+			// roots. Only look at the full module graph if we've already loaded it;
+			// otherwise, just spot-check the explicit requirements of the roots from
+			// which we loaded packages.
+			if rs.graph.Load() != nil {
+				// We've already loaded the full module graph, which includes the
+				// requirements of all of the root modules — even the transitive
+				// requirements, if they are eager!
+				mg, _ = rs.Graph(ctx)
+			} else if cfg.BuildMod == "vendor" {
+				// We can't spot-check the requirements of other modules because we
+				// don't in general have their go.mod files available in the vendor
+				// directory. (Fortunately this case is impossible, because mg.graph is
+				// always non-nil in vendor mode!)
+				panic("internal error: rs.graph is unexpectedly nil with -mod=vendor")
+			} else if !spotCheckRoots(ctx, rs, spotCheckRoot) {
+				// We spot-checked the explicit requirements of the roots that are
+				// relevant to the packages we've loaded. Unfortunately, they're
+				// inconsistent in some way; we need to load the full module graph
+				// so that we can fix the roots properly.
+				var err error
+				mg, err = rs.Graph(ctx)
+				if err != nil {
+					return rs, err
+				}
+			}
 		}
 
 		roots = make([]module.Version, 0, len(rs.rootModules))
@@ -835,6 +870,45 @@ func updateLazyRoots(ctx context.Context, direct map[string]bool, rs *Requiremen
 	return newRequirements(lazy, roots, direct), nil
 }
 
+// spotCheckRoots reports whether the versions of the roots in rs satisfy the
+// explicit requirements of the modules in mods.
+func spotCheckRoots(ctx context.Context, rs *Requirements, mods map[module.Version]bool) bool {
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	work := par.NewQueue(runtime.GOMAXPROCS(0))
+	for m := range mods {
+		m := m
+		work.Add(func() {
+			if ctx.Err() != nil {
+				return
+			}
+
+			summary, err := goModSummary(m)
+			if err != nil {
+				cancel()
+				return
+			}
+
+			for _, r := range summary.require {
+				if v, ok := rs.rootSelected(r.Path); ok && cmpVersion(v, r.Version) < 0 {
+					cancel()
+					return
+				}
+			}
+		})
+	}
+	<-work.Idle()
+
+	if ctx.Err() != nil {
+		// Either we failed a spot-check, or the caller no longer cares about our
+		// answer anyway.
+		return false
+	}
+
+	return true
+}
+
 // tidyEagerRoots returns a minimal set of root requirements that maintains the
 // selected version of every module that provided a package in pkgs, and
 // includes the selected version of every such module in direct as a root.
diff --git a/src/cmd/go/testdata/script/mod_lazy_consistency.txt b/src/cmd/go/testdata/script/mod_lazy_consistency.txt
new file mode 100644
index 0000000000..1bf3e31bfe
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_lazy_consistency.txt
@@ -0,0 +1,95 @@
+# If the root requirements in a lazy module are inconsistent
+# (for example, due to a bad hand-edit or git merge),
+# they can go unnoticed as long as the module with the violated
+# requirement is not used.
+# When we load a package from that module, we should spot-check its
+# requirements and either emit an error or update the go.mod file.
+
+cp go.mod go.mod.orig
+
+
+# If we load package x from x.1, we only check the requirements of x,
+# which are fine: loading succeeds.
+
+go list -deps ./usex
+stdout '^example.net/x$'
+cmp go.mod go.mod.orig
+
+
+# However, if we load needx2, we should load the requirements of needx2.
+# Those requirements indicate x.2, not x.1, so the module graph is
+# inconsistent and needs to be fixed.
+
+! go list -deps ./useneedx2
+stderr '^go: updates to go.mod needed; to update it:\n\tgo mod tidy$'
+
+! go list -deps example.net/needx2
+stderr '^go: updates to go.mod needed; to update it:\n\tgo mod tidy$'
+
+
+# The command printed in the error message should fix the problem.
+
+go mod tidy
+go list -deps ./useneedx2
+stdout '^example.net/m/useneedx2$'
+stdout '^example.net/needx2$'
+stdout '^example.net/x$'
+
+go list -m all
+stdout '^example.net/needx2 v0\.1\.0 '
+stdout '^example.net/x v0\.2\.0 '
+
+
+-- go.mod --
+module example.net/m
+
+go 1.17
+
+require (
+	example.net/needx2 v0.1.0
+	example.net/x v0.1.0
+)
+
+replace (
+	example.net/needx2 v0.1.0 => ./needx2.1
+	example.net/x v0.1.0 => ./x.1
+	example.net/x v0.2.0 => ./x.2
+)
+-- useneedx2/useneedx2.go --
+package useneedx2
+
+import _ "example.net/needx2"
+-- usex/usex.go --
+package usex
+
+import _ "example.net/x"
+
+-- x.1/go.mod --
+module example.com/x
+
+go 1.17
+-- x.1/x.go --
+package x
+
+-- x.2/go.mod --
+module example.com/x
+
+go 1.17
+-- x.2/x.go --
+package x
+
+const AddedInV2 = true
+
+-- needx2.1/go.mod --
+module example.com/x
+
+go 1.17
+
+require example.net/x v0.2.0
+-- needx2.1/needx2.go --
+// Package needx2 needs x v0.2.0 or higher.
+package needx2
+
+import "example.net/x"
+
+var _ = x.AddedInV2
-- 
GitLab


From 95dde3f0290b0df797770afc899ae977ed89833e Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Wed, 5 May 2021 09:23:52 +0700
Subject: [PATCH 1977/2400] cmd/compile: do not substitute OGOTO inside a
 closure when inlining

The inlsubst already does the same thing for OLABEL, so we must do the
same thing for OGOTO. Otherwise, new inlined OGOTO node will be
associated with non-existed label.

Fixes #45947

Change-Id: I40eef095f57fd3438c38a0b5d9751d5d7ebf759e
Reviewed-on: https://go-review.googlesource.com/c/go/+/316931
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
---
 src/cmd/compile/internal/inline/inl.go |  4 ++++
 test/fixedbugs/issue45947.go           | 16 ++++++++++++++++
 2 files changed, 20 insertions(+)
 create mode 100644 test/fixedbugs/issue45947.go

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 339ea77509..e07bb3b324 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -1394,6 +1394,10 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 		return ir.NewBlockStmt(base.Pos, init)
 
 	case ir.OGOTO:
+		if subst.newclofn != nil {
+			// Don't do special substitutions if inside a closure
+			break
+		}
 		n := n.(*ir.BranchStmt)
 		m := ir.Copy(n).(*ir.BranchStmt)
 		m.SetPos(subst.updatedPos(m.Pos()))
diff --git a/test/fixedbugs/issue45947.go b/test/fixedbugs/issue45947.go
new file mode 100644
index 0000000000..4086449340
--- /dev/null
+++ b/test/fixedbugs/issue45947.go
@@ -0,0 +1,16 @@
+// compile
+
+// Copyright 2021 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 p
+
+func f() {
+	_ = func() func() {
+		return func() {
+		l:
+			goto l
+		}
+	}()
+}
-- 
GitLab


From 784ef4c53135644d70f3476a4bd90010b9acff66 Mon Sep 17 00:00:00 2001
From: Katie Hockman <katie@golang.org>
Date: Mon, 26 Apr 2021 18:46:22 -0400
Subject: [PATCH 1978/2400] net/http: ignore directory path when parsing
 multipart forms

Fixes #45789

Change-Id: Id588f5dbbecf5fbfb54e957c53903aaa900171f2
Reviewed-on: https://go-review.googlesource.com/c/go/+/313809
Trust: Katie Hockman <katie@golang.org>
Run-TryBot: Katie Hockman <katie@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Roland Shoemaker <roland@golang.org>
---
 src/mime/multipart/multipart.go | 14 +++++++++++---
 src/net/http/request_test.go    | 23 +++++++++++++++++++++++
 2 files changed, 34 insertions(+), 3 deletions(-)

diff --git a/src/mime/multipart/multipart.go b/src/mime/multipart/multipart.go
index cb8bf39338..81bf722d4e 100644
--- a/src/mime/multipart/multipart.go
+++ b/src/mime/multipart/multipart.go
@@ -20,6 +20,7 @@ import (
 	"mime"
 	"mime/quotedprintable"
 	"net/textproto"
+	"path/filepath"
 	"strings"
 )
 
@@ -67,13 +68,20 @@ func (p *Part) FormName() string {
 	return p.dispositionParams["name"]
 }
 
-// FileName returns the filename parameter of the Part's
-// Content-Disposition header.
+// FileName returns the filename parameter of the Part's Content-Disposition
+// header. If not empty, the filename is passed through filepath.Base (which is
+// platform dependent) before being returned.
 func (p *Part) FileName() string {
 	if p.dispositionParams == nil {
 		p.parseContentDisposition()
 	}
-	return p.dispositionParams["filename"]
+	filename := p.dispositionParams["filename"]
+	if filename == "" {
+		return ""
+	}
+	// RFC 7578, Section 4.2 requires that if a filename is provided, the
+	// directory path information must not be used.
+	return filepath.Base(filename)
 }
 
 func (p *Part) parseContentDisposition() {
diff --git a/src/net/http/request_test.go b/src/net/http/request_test.go
index 07b3d6a1c7..952828b395 100644
--- a/src/net/http/request_test.go
+++ b/src/net/http/request_test.go
@@ -245,6 +245,29 @@ func TestParseMultipartForm(t *testing.T) {
 	}
 }
 
+// Issue 45789: multipart form should not include directory path in filename
+func TestParseMultipartFormFilename(t *testing.T) {
+	postData :=
+		`--xxx
+Content-Disposition: form-data; name="file"; filename="../usr/foobar.txt/"
+Content-Type: text/plain
+
+--xxx--
+`
+	req := &Request{
+		Method: "POST",
+		Header: Header{"Content-Type": {`multipart/form-data; boundary=xxx`}},
+		Body:   io.NopCloser(strings.NewReader(postData)),
+	}
+	_, hdr, err := req.FormFile("file")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if hdr.Filename != "foobar.txt" {
+		t.Errorf("expected only the last element of the path, got %q", hdr.Filename)
+	}
+}
+
 // Issue #40430: Test that if maxMemory for ParseMultipartForm when combined with
 // the payload size and the internal leeway buffer size of 10MiB overflows, that we
 // correctly return an error.
-- 
GitLab


From 40d5e6d4e28eba538ec124d0e437dead63b0206e Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 5 May 2021 11:54:51 -0700
Subject: [PATCH 1979/2400] cmd/compile/internal/types2: fix potential bugs in
 santitizer pass

Change-Id: I88c5e1f620d0f3546ac9ac7b6a4b881772a38449
Reviewed-on: https://go-review.googlesource.com/c/go/+/317329
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/types2/sanitize.go | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/types2/sanitize.go b/src/cmd/compile/internal/types2/sanitize.go
index 8b8bc72d85..64a2dedc7d 100644
--- a/src/cmd/compile/internal/types2/sanitize.go
+++ b/src/cmd/compile/internal/types2/sanitize.go
@@ -67,13 +67,17 @@ func sanitizeInfo(info *Info) {
 type sanitizer map[Type]Type
 
 func (s sanitizer) typ(typ Type) Type {
+	if typ == nil {
+		return nil
+	}
+
 	if t, found := s[typ]; found {
 		return t
 	}
 	s[typ] = typ
 
 	switch t := typ.(type) {
-	case nil, *Basic, *bottom, *top:
+	case *Basic, *bottom, *top:
 		// nothing to do
 
 	case *Array:
@@ -107,10 +111,14 @@ func (s sanitizer) typ(typ Type) Type {
 
 	case *Interface:
 		s.funcList(t.methods)
-		s.typ(t.types)
+		if types := s.typ(t.types); types != t.types {
+			t.types = types
+		}
 		s.typeList(t.embeddeds)
 		s.funcList(t.allMethods)
-		s.typ(t.allTypes)
+		if allTypes := s.typ(t.allTypes); allTypes != t.allTypes {
+			t.allTypes = allTypes
+		}
 
 	case *Map:
 		if key := s.typ(t.key); key != t.key {
-- 
GitLab


From 543e0983204d401c012ed4693f0e69956d357886 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 5 May 2021 15:01:37 -0400
Subject: [PATCH 1980/2400] go/types: fix potential bugs in santitizer pass

This is a port of CL 317329 to go/types.

Change-Id: I1ba65284c91044f0ceed536da4149ef25e1f9502
Reviewed-on: https://go-review.googlesource.com/c/go/+/317291
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/sanitize.go | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/go/types/sanitize.go b/src/go/types/sanitize.go
index 3429867321..b905972d36 100644
--- a/src/go/types/sanitize.go
+++ b/src/go/types/sanitize.go
@@ -67,13 +67,17 @@ func sanitizeInfo(info *Info) {
 type sanitizer map[Type]Type
 
 func (s sanitizer) typ(typ Type) Type {
+	if typ == nil {
+		return nil
+	}
+
 	if t, found := s[typ]; found {
 		return t
 	}
 	s[typ] = typ
 
 	switch t := typ.(type) {
-	case nil, *Basic, *bottom, *top:
+	case *Basic, *bottom, *top:
 		// nothing to do
 
 	case *Array:
@@ -107,10 +111,14 @@ func (s sanitizer) typ(typ Type) Type {
 
 	case *Interface:
 		s.funcList(t.methods)
-		s.typ(t.types)
+		if types := s.typ(t.types); types != t.types {
+			t.types = types
+		}
 		s.typeList(t.embeddeds)
 		s.funcList(t.allMethods)
-		s.typ(t.allTypes)
+		if allTypes := s.typ(t.allTypes); allTypes != t.allTypes {
+			t.allTypes = allTypes
+		}
 
 	case *Map:
 		if key := s.typ(t.key); key != t.key {
-- 
GitLab


From b0c49ae9f59d233526f8934262c5bbbe14d4358d Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Mon, 5 Apr 2021 21:45:16 +0200
Subject: [PATCH 1981/2400] crypto/ed25519: replace internal/edwards25519 with
 filippo.io/edwards25519
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This change replaces the crypto/ed25519/internal/edwards25519 package
with code from filippo.io/edwards25519, a significantly faster, safer,
well tested (over 1600 lines of new tests, 99% test coverage), and
better documented (600 lines of new comments) implementation.

Some highlights:

* an unsaturated 51-bit limb field implementation optimized for 64-bit
  architectures and math/bits.Mul64 intrinsics

* more efficient variable time scalar multiplication using multi-width
  non-adjacent form with a larger lookup table for fixed-base

* a safe math/big.Int-like API for the Scalar, Point, and field.Element
  types with fully abstracted reduction invariants

* a test suite including a testing/quick fuzzer that explores edge case
  values that would be impossible to hit randomly, and systematic tests
  for arguments and receiver aliasing

* point decoding rules that strictly match the original logic of
  crypto/ed25519/internal/edwards25519, to avoid consensus issues

* AssemblyPolicy-compliant assembly cores for arm64 and amd64, the
  former under 20 lines, and the latter generated by a program based on
  github.com/mmcloughlin/avo that can be reviewed line-by-line against
  the generic implementation

Intel(R) Core(TM) i5-7400 CPU @ 3.00GHz

name              old time/op    new time/op    delta
KeyGeneration-4     59.5µs ± 1%    26.1µs ± 1%  -56.20%  (p=0.000 n=10+10)
NewKeyFromSeed-4    59.3µs ± 1%    25.8µs ± 1%  -56.48%  (p=0.000 n=9+10)
Signing-4           60.4µs ± 1%    31.4µs ± 1%  -48.05%  (p=0.000 n=10+10)
Verification-4       169µs ± 1%      73µs ± 2%  -56.55%  (p=0.000 n=10+10)

Apple M1

name              old time/op    new time/op    delta
KeyGeneration-8     35.1µs ± 0%    20.2µs ± 2%  -42.46%  (p=0.000 n=8+10)
NewKeyFromSeed-8    35.1µs ± 0%    20.0µs ± 1%  -42.93%  (p=0.000 n=8+9)
Signing-8           36.2µs ± 0%    25.6µs ± 1%  -29.25%  (p=0.000 n=8+9)
Verification-8      96.1µs ± 0%    57.6µs ± 1%  -40.14%  (p=0.000 n=10+10)

The code in this CL is a copy of the filippo.io/edwards25519 module at
version v1.0.0-beta.3.0.20210405211453-c6be47d67779 with only the
following functions removed as irrelevant to crypto/ed25519:

- (*Point).BytesMontgomery()
- (*Point).MultByCofactor()
- (*Scalar).Invert()
- (*Point).MultiScalarMult()
- (*Point).VarTimeMultiScalarMult()

This codebase took a long journey outside the standard library before
making its way back here. Its oldest parts started as a faster field
implementation rewrite by George Tankersley almost four years ago,
eventually submitted as CL 71950 but never merged. That code was then
merged into github.com/gtank/ristretto255, which also started as an
internal/edwards25519 fork. There it was worked on by me, George, and
Henry de Valence as a backend for our Go ristretto255 implementation.
Finally, I extracted the edwards25519 code into a reusable package as
filippo.io/edwards25519.

Now, we're ready for the standard library to become the source of truth
for this code again, while filippo.io/edwards25519 will become a
re-packaged and extended version for external use, since we don't want
to expose unsafe curve operations in x/crypto or the standard library.

Submitted under the Google CLA on behalf of:

- Henry de Valence
  https://github.com/gtank/ristretto255/issues/34
- George Tankersley
  https://golang.org/cl/71950
  https://github.com/gtank/ristretto255-private/issues/28
- Luke Champine
  https://github.com/FiloSottile/edwards25519/pull/7
- Adrian Hamelink
  https://github.com/FiloSottile/edwards25519/pull/12

Changes 32506b5 and 18c803c are trivial and don't require a CLA.

The full history of this code since diverging from internal/edwards25519
is available at https://github.com/FiloSottile/edwards25519, and
summarized below.

+ c6be47d - edwards25519: update TestScalarSetBytesWithClamping <Filippo Valsorda>
+ c882e8e - edwards25519: rewrite amd64 assembly with avo <Filippo Valsorda>
+ 8eb02eb - edwards25519: refactor feMulGeneric and feSquareGeneric <Filippo Valsorda>
+ 8afd860 - edwards25519: remove Go 1.12 compatibility hack <Filippo Valsorda>
+ 1765c13 - edwards25519: don't clobber BP in amd64 assembly <Filippo Valsorda>
+ b73a7c8 - edwards25519: fix ScalarMult when receiver is not the identity (FiloSottile/edwards25519#12) <Adrian Hamelink>
+ 32a46d7 - edwards25519: document why this can't implement X25519 <Filippo Valsorda>
+ c547797 - edwards25519: make SqrtRatio slightly more efficient <Filippo Valsorda>
+ 700f4f4 - edwards25519: panic if an uninitialized Point is used <Filippo Valsorda>
+ d791cf8 - edwards25519: use testing.AllocsPerRun for TestAllocations <Filippo Valsorda>
+ 8cc8037 - edwards25519: smooth a couple test coverage rough edges <Filippo Valsorda>
+ 9063a14 - edwards25519: test that operations cause zero heap allocations <Filippo Valsorda>
+ 6944ac7 - edwards25519: relax the limb schedule slightly <Filippo Valsorda>
+ 21ebdac - edwards25519: rewrite carryPropagate in arm64 assembly <Filippo Valsorda>
+ a260082 - edwards25519: merge carryPropagate[12] <Filippo Valsorda>
+ dbe1792 - edwards25519: add TestScalarSetBytesWithClamping <Filippo Valsorda>
+ c1fe95a - edwards25519: add MultByCofactor <Filippo Valsorda>
+ 132d95c - edwards25519: sprinkle on-curve checks around tests <Filippo Valsorda>
+ ffb3e31 - edwards25519: specify the behavior of Invert(0) and I.BytesMontgomery() <Filippo Valsorda>
+ 9e6a931 - edwards25519: add (*Scalar).MultiplyAdd <lukechampine>
+ 3b045f3 - edwards25519: outline (*Point).Bytes (FiloSottile/edwards25519#6) <Luke Champine>
+ ec6f8a6 - edwards25519: make (*Scalar).SetCanonicalBytes return the receiver <Filippo Valsorda>
+ 77d7b31 - edwards25519: add (*Point).BytesMontgomery <Filippo Valsorda>
+ 6e8d645 - edwards25519: implement (*Point).Bytes and (*Point).SetBytes <Filippo Valsorda>
+ 1c833da - edwards25519: clarify ScalarBaseMult docs <Filippo Valsorda>
+ 3a13cf1 - edwards25519: apply gc build tag <Filippo Valsorda>
+ 90c35a7 - edwards25519: hide FieldElement and (*Point).ExtendedCoords <Filippo Valsorda>
+ 498fb1e - edwards25519: replace FillBytes with Bytes, again <Filippo Valsorda>
+ 9c7303a - edwards25519: remove (*Point).Identity and (*Point).Generator <Filippo Valsorda>
+ 2e52ce2 - edwards25519: drop unused (*Scalar).Zero <Filippo Valsorda>
+ 7c14a36 - edwards25519: rename FromBytes to SetBytes <Filippo Valsorda>
+ e3d0e45 - edwards25519: ensure only test files import math/big <Filippo Valsorda>
+ daa2507 - edwards25519: minor doc and string touch-ups <Filippo Valsorda>
+ e8698cd - edwards25519: implement (*Scalar).FromBytesWithClamping <Filippo Valsorda>
+ f28d75a - edwards25519: change constructors <Filippo Valsorda>
+ 36d8598 - edwards25519: test the invariant that Scalars are always reduced <Filippo Valsorda>
+ feed48c - edwards25519: cleanup the FieldElement API <Filippo Valsorda>
+ f6ee187 - edwards25519: make Point opaque <Filippo Valsorda>
+ 176388b - edwards25519: cleanup Scalar API to match ristretto255 <Filippo Valsorda>
+ c5c2e9e - edwards25519: rename ProjP3 to Point and unexport other point types <Filippo Valsorda>
+ 8542076 - edwards25519: add Scalar aliasing test <Filippo Valsorda>
+ 1a86a9c - edwards25519: make Scalar opaque <Filippo Valsorda>
+ 07a7683 - edwards25519: hide some more exposed symbols <Filippo Valsorda>
+ d3569cb - all: flatten the package and make FieldElement opaque <Filippo Valsorda>
+ 6f5f582 - all: expose edwards25519, base, and scalar packages <Filippo Valsorda>
+ 7ab4a68 - all: ensure compatibility with older Go versions <Filippo Valsorda>
+ e9b8baa - internal/radix51: implement (*FieldElement).Mul32 <Filippo Valsorda>
+ eac4de5 - internal/radix51: restructure according to golang.org/wiki/TargetSpecific <Filippo Valsorda>
+ 32506b5 - internal/radix51: fix !amd64 build (lightReduce -> carryPropagate) (gtank/ristretto255#29) <Sunny Aggarwal>
+ d64d989 - internal/scalar: fix FromUniformBytes <Filippo Valsorda>
+ 044bb44 - internal/scalar: address review comments <Filippo Valsorda>
+ 7dba54f - all: apply suggestions from code review <Filippo Valsorda>
+ 94bd1d9 - ristretto255: expose scalar multiplication APIs <Filippo Valsorda>
+ 5bd5476 - internal/edwards25519: fix shadowing of B in TestAddSubNegOnBasePoint <Filippo Valsorda>
+ 66bf647 - internal/scalar: replace FromBytes/IsCanonical with FromUniformBytes/FromCanonicalBytes <Filippo Valsorda>
+ 024f3f7 - internal/edwards25519,internal/scalar: apply some Go style touches <Filippo Valsorda>
+ 5e0c5c6 - internal/scalar: add scalar inversion <Henry de Valence>
+ 74fd625 - internal/ed25519: rearrange VartimeDoubleBaseMul args <Henry de Valence>
+ 81ae7ea - internal/ed25519: add benchmarks for scalar mul <Henry de Valence>
+ 9f1f939 - internal/ed25519: add variable-time multiscalar mul <Henry de Valence>
+ 7a96974 - internal/ed25519: add vartime double-base scmul <Henry de Valence>
+ 2bc256c - internal/ed25519: add precomputed NAF table for basepoint <Henry de Valence>
+ a0f0b96 - internal/ed25519: lower quickcheck size for point ops <Henry de Valence>
+ 2f385a1 - internal/ed25519: implement MultiscalarMul <Henry de Valence>
+ 8ae211b - internal/ed25519: implement BasepointMul <Henry de Valence>
+ 7b4858d - internal/ed25519: extract common test variables <Henry de Valence>
+ 16e7c48 - internal/ed25519: add a basepoint multiple table. <Henry de Valence>
+ 988e521 - internal/ed25519: add constant-time variable-base scmul. <Henry de Valence>
+ b695f6b - internal/ed25519: move basepoint constant & correct it <Henry de Valence>
+ ddd014e - internal/scalar: fix high bit check <Henry de Valence>
+ c88ea89 - internal/scalar: make casts clearer <Henry de Valence>
+ b75f989 - internal/scalar: add invariant checks on Scalar digits <Henry de Valence>
+ 36216ca - internal/scalar: use one scMulAdd for Sub <Henry de Valence>
+ 8bf40f3 - internal/scalar: fix constant-time signed radix 16 implementation <Henry de Valence>
+ e6d9ef6 - Update internal/radix51/fe_test.go <Filippo Valsorda>
+ 3aa63de - Update internal/radix51/fe_test.go <Filippo Valsorda>
+ 3e66ff0 - Update internal/radix51/fe_test.go <Filippo Valsorda>
+ 94e6c15 - internal/ed25519: add TODO note and doc ref <Henry de Valence>
+ 3647548 - internal/ed25519: rename twoD to D2 <Henry de Valence>
+ 1cf853c - internal/ed25519: add lookup tables for scalar mul. <Henry de Valence>
+ 3af304a - internal/radix51: add a conditional swap <Henry de Valence>
+ 4673217 - ristretto255: use multi-model arithmetic <Henry de Valence>
+ cca757a - internal/ed25519: remove single-model code <Henry de Valence>
+ d26e77b - internal/ed25519: add addition for Edwards points <Henry de Valence>
+ e0fbb35 - internal/ed25519: use twoD <Henry de Valence>
+ fd9b37b - internal/ed25519: add tests for multi-model point types. <Henry de Valence>
+ dacabb0 - internal/ed25519: add multi-model point types. <Henry de Valence>
+ dddc72e - internal/scalar: add constant-time signed radix 16 <Henry de Valence>
+ 92cdb35 - internal/scalar: add non-adjacent form <Henry de Valence>
+ d147963 - internal/scalar: don't zero memory that is about to be copied over <George Tankersley>
+ 8da186c - internal/scalar: add scalar field implementation <George Tankersley>
+ f38e583 - internal/radix51: add a "weird" testing/quick generation strategy <Filippo Valsorda>
+ 6454f61 - Move comment inside function <Henry de Valence>
+ 1983365 - implement Add, Sub, Neg for ed25519 and ristretto255 points. <Henry de Valence>
+ 9f25562 - internal/group: rename to internal/edwards25519 <Filippo Valsorda>
+ 48e66d3 - internal/group: restore ScalarMult code <Filippo Valsorda>
+ 0078d66 - internal/radix51: rename lightReduce to carryPropagate and touch up docs <Filippo Valsorda>
+ 05f4107 - internal/radix51: add benchmarks <Filippo Valsorda>
+ fd36334 - internal/radix51: test that operations don't exceed bounds <Filippo Valsorda>
+ 703421d - internal/radix51: make Generate produce random light-reduced elements <Filippo Valsorda>
+ f8d8297 - internal/radix51: simplify lightReduce <Filippo Valsorda>
+ 413120f - internal/radix51: minor tests cleanup <Filippo Valsorda>
+ abc8c5a - internal/radix51: make reduction an invariant and unexport Reduce <Filippo Valsorda>
+ 4fd198d - internal/radix51: actually apply go:noescape <Filippo Valsorda>
+ 18c803c - all: fix typos <Dimitris Apostolou>
+ bbfe059 - internal/radix51: test field encoding roundtrip with fixed vectors <George Tankersley>
+ c428b18 - internal/radix51: rename AppendBytes to Bytes <Filippo Valsorda>
+ c59bc1a - internal/radix51: rewrite FromBytes and AppendBytes with encoding/binary <Filippo Valsorda>
+ 57c0cd5 - internal/radix51: add docs and some light readability refactors <Filippo Valsorda>
+ cb1b734 - internal/radix51: remove unused (and a bit broken) SetInt <Filippo Valsorda>
+ beb8abd - internal/radix51: refactor ToBig and FromBig <Filippo Valsorda>
+ 87c0a53 - internal/radix51: replace ToBytes with AppendBytes <Filippo Valsorda>
+ b7e1e45 - internal/radix51: fix aliasing bug in CondNeg (gtank/ristretto255#21) <George Tankersley>
+ ed3748d - internal/radix51: actually, uhm, check the result of TestAliasing <Filippo Valsorda>
+ ec0e293 - radix51: change API of FromBytes and ToBytes to use slices <George Tankersley>
+ 29f6815 - internal/radix51: test all combinations of argument and receiver aliasing <Filippo Valsorda>
+ cd53d90 - internal/radix51: add property-based tests that multiplication distributes over addition <Henry de Valence>
+ c3bc45f - radix51: use go1.12 intrinsics for 128-bit multiplications <George Tankersley>
+ 7e7043e - internal/radix51: define a mask64Bits constant <Filippo Valsorda>
+ 4fdd06d - internal/group: set Z to 1, not 0 in FromAffine <Filippo Valsorda>
+ ffa7be7 - internal/group: fix typo <Filippo Valsorda>
+ 1f452ac - internal/group: derive twoD from D <Filippo Valsorda>
+ 2424c78 - internal/radix51: add MinusOne <Filippo Valsorda>
+ 76978fc - internal/group: make conversion APIs caller-allocated <Filippo Valsorda>
+ d17d202 - internal/group: rewrite DoubleZ1 because stack is cheaper than mental state <Filippo Valsorda>
+ 72b97c1 - internal: make all APIs chainable <Filippo Valsorda>
+ 993d979 - internal/radix51: make all APIs not consider the receiver an input <Filippo Valsorda>
+ b2a1d7d - all: refactor field API to be methods based <Filippo Valsorda>
+ cdf9b90 - internal/radix51: add constant time field operations <Filippo Valsorda>
+ e490a48 - internal/radix51: remove FeEqual <Filippo Valsorda>
+ 2de114c - internal/radix51: remove FeCSwap <Filippo Valsorda>
+ 08b80c1 - make things more generally presentable <George Tankersley>
+ 2178536 - Cache the field representation of d <George Tankersley>
+ 4135059 - Remove 32-bit code and update license. <George Tankersley>
+ 5d95cb3 - Use Bits() for FeToBig. <George Tankersley>
+ 146e33c - Implement ScalarMult using Montgomery pattern and dedicated extended-coordinates doubling. This will be slow. <George Tankersley>
+ 12a673a - use faster FeFromBig & a horrible assortment of other random changes <George Tankersley>
+ 901f40c - group logic WIP <George Tankersley>
+ a9c89cd - add equality for field elements <George Tankersley>
+ 214873b - Add radix51 FieldElement implementation <George Tankersley>
+ 8fd5cae - Implement an elliptic.Curve for ed25519 <George Tankersley>

Change-Id: Ifbcdd13e8b6304f9906c0ef2b73f1fdc493a7dfa
Co-authored-by: George Tankersley <george.tankersley@gmail.com>
Co-authored-by: Henry de Valence <hdevalence@hdevalence.ca>
Reviewed-on: https://go-review.googlesource.com/c/go/+/276272
Run-TryBot: Filippo Valsorda <filippo@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Filippo Valsorda <filippo@golang.org>
Trust: Katie Hockman <katie@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
---
 .../compile/internal/types2/stdlib_test.go    |    7 +
 src/cmd/internal/moddeps/moddeps_test.go      |    6 +
 src/crypto/ed25519/ed25519.go                 |  127 +-
 src/crypto/ed25519/ed25519_test.go            |   36 +-
 .../ed25519/internal/edwards25519/const.go    | 1422 ------------
 .../ed25519/internal/edwards25519/doc.go      |   22 +
 .../internal/edwards25519/edwards25519.go     | 2000 +++--------------
 .../edwards25519/edwards25519_test.go         |  299 +++
 .../edwards25519/field/_asm/fe_amd64_asm.go   |  294 +++
 .../internal/edwards25519/field/_asm/go.mod   |    5 +
 .../internal/edwards25519/field/_asm/go.sum   |   31 +
 .../ed25519/internal/edwards25519/field/fe.go |  416 ++++
 .../edwards25519/field/fe_alias_test.go       |  126 ++
 .../internal/edwards25519/field/fe_amd64.go   |   13 +
 .../internal/edwards25519/field/fe_amd64.s    |  378 ++++
 .../edwards25519/field/fe_amd64_noasm.go      |   12 +
 .../internal/edwards25519/field/fe_arm64.go   |   16 +
 .../internal/edwards25519/field/fe_arm64.s    |   42 +
 .../edwards25519/field/fe_arm64_noasm.go      |   12 +
 .../edwards25519/field/fe_bench_test.go       |   36 +
 .../internal/edwards25519/field/fe_generic.go |  264 +++
 .../internal/edwards25519/field/fe_test.go    |  558 +++++
 .../ed25519/internal/edwards25519/scalar.go   | 1025 +++++++++
 .../edwards25519/scalar_alias_test.go         |   93 +
 .../internal/edwards25519/scalar_test.go      |  233 ++
 .../internal/edwards25519/scalarmult.go       |  214 ++
 .../internal/edwards25519/scalarmult_test.go  |  209 ++
 .../ed25519/internal/edwards25519/tables.go   |  129 ++
 .../internal/edwards25519/tables_test.go      |  119 +
 src/go/build/deps_test.go                     |    3 +-
 src/go/types/stdlib_test.go                   |    7 +
 31 files changed, 4948 insertions(+), 3206 deletions(-)
 delete mode 100644 src/crypto/ed25519/internal/edwards25519/const.go
 create mode 100644 src/crypto/ed25519/internal/edwards25519/doc.go
 create mode 100644 src/crypto/ed25519/internal/edwards25519/edwards25519_test.go
 create mode 100644 src/crypto/ed25519/internal/edwards25519/field/_asm/fe_amd64_asm.go
 create mode 100644 src/crypto/ed25519/internal/edwards25519/field/_asm/go.mod
 create mode 100644 src/crypto/ed25519/internal/edwards25519/field/_asm/go.sum
 create mode 100644 src/crypto/ed25519/internal/edwards25519/field/fe.go
 create mode 100644 src/crypto/ed25519/internal/edwards25519/field/fe_alias_test.go
 create mode 100644 src/crypto/ed25519/internal/edwards25519/field/fe_amd64.go
 create mode 100644 src/crypto/ed25519/internal/edwards25519/field/fe_amd64.s
 create mode 100644 src/crypto/ed25519/internal/edwards25519/field/fe_amd64_noasm.go
 create mode 100644 src/crypto/ed25519/internal/edwards25519/field/fe_arm64.go
 create mode 100644 src/crypto/ed25519/internal/edwards25519/field/fe_arm64.s
 create mode 100644 src/crypto/ed25519/internal/edwards25519/field/fe_arm64_noasm.go
 create mode 100644 src/crypto/ed25519/internal/edwards25519/field/fe_bench_test.go
 create mode 100644 src/crypto/ed25519/internal/edwards25519/field/fe_generic.go
 create mode 100644 src/crypto/ed25519/internal/edwards25519/field/fe_test.go
 create mode 100644 src/crypto/ed25519/internal/edwards25519/scalar.go
 create mode 100644 src/crypto/ed25519/internal/edwards25519/scalar_alias_test.go
 create mode 100644 src/crypto/ed25519/internal/edwards25519/scalar_test.go
 create mode 100644 src/crypto/ed25519/internal/edwards25519/scalarmult.go
 create mode 100644 src/crypto/ed25519/internal/edwards25519/scalarmult_test.go
 create mode 100644 src/crypto/ed25519/internal/edwards25519/tables.go
 create mode 100644 src/crypto/ed25519/internal/edwards25519/tables_test.go

diff --git a/src/cmd/compile/internal/types2/stdlib_test.go b/src/cmd/compile/internal/types2/stdlib_test.go
index c04f5e1c46..7d6753e5c2 100644
--- a/src/cmd/compile/internal/types2/stdlib_test.go
+++ b/src/cmd/compile/internal/types2/stdlib_test.go
@@ -301,6 +301,13 @@ func (w *walker) walk(dir string) {
 		return
 	}
 
+	// skip submodules, which might not be vendored
+	for _, f := range files {
+		if f.Name() == "go.mod" {
+			return
+		}
+	}
+
 	// apply pkgh to the files in directory dir
 	// but ignore files directly under $GOROOT/src (might be temporary test files).
 	if dir != filepath.Join(runtime.GOROOT(), "src") {
diff --git a/src/cmd/internal/moddeps/moddeps_test.go b/src/cmd/internal/moddeps/moddeps_test.go
index 62687403ec..ba574f4004 100644
--- a/src/cmd/internal/moddeps/moddeps_test.go
+++ b/src/cmd/internal/moddeps/moddeps_test.go
@@ -422,6 +422,12 @@ func findGorootModules(t *testing.T) []gorootModule {
 				// running time of this test anyway.)
 				return filepath.SkipDir
 			}
+			if strings.HasPrefix(info.Name(), "_") || strings.HasPrefix(info.Name(), ".") {
+				// _ and . prefixed directories can be used for internal modules
+				// without a vendor directory that don't contribute to the build
+				// but might be used for example as code generators.
+				return filepath.SkipDir
+			}
 			if info.IsDir() || info.Name() != "go.mod" {
 				return nil
 			}
diff --git a/src/crypto/ed25519/ed25519.go b/src/crypto/ed25519/ed25519.go
index 6f59bb5cff..09c5269d0c 100644
--- a/src/crypto/ed25519/ed25519.go
+++ b/src/crypto/ed25519/ed25519.go
@@ -12,9 +12,6 @@
 // 8032 private key as the “seed”.
 package ed25519
 
-// This code is a port of the public domain, “ref10” implementation of ed25519
-// from SUPERCOP.
-
 import (
 	"bytes"
 	"crypto"
@@ -128,20 +125,14 @@ func newKeyFromSeed(privateKey, seed []byte) {
 		panic("ed25519: bad seed length: " + strconv.Itoa(l))
 	}
 
-	digest := sha512.Sum512(seed)
-	digest[0] &= 248
-	digest[31] &= 127
-	digest[31] |= 64
+	h := sha512.Sum512(seed)
+	s := edwards25519.NewScalar().SetBytesWithClamping(h[:32])
+	A := (&edwards25519.Point{}).ScalarBaseMult(s)
 
-	var A edwards25519.ExtendedGroupElement
-	var hBytes [32]byte
-	copy(hBytes[:], digest[:])
-	edwards25519.GeScalarMultBase(&A, &hBytes)
-	var publicKeyBytes [32]byte
-	A.ToBytes(&publicKeyBytes)
+	publicKey := A.Bytes()
 
 	copy(privateKey, seed)
-	copy(privateKey[32:], publicKeyBytes[:])
+	copy(privateKey[32:], publicKey)
 }
 
 // Sign signs the message with privateKey and returns a signature. It will
@@ -158,44 +149,33 @@ func sign(signature, privateKey, message []byte) {
 	if l := len(privateKey); l != PrivateKeySize {
 		panic("ed25519: bad private key length: " + strconv.Itoa(l))
 	}
+	seed, publicKey := privateKey[:SeedSize], privateKey[SeedSize:]
+
+	h := sha512.Sum512(seed)
+	s := edwards25519.NewScalar().SetBytesWithClamping(h[:32])
+	prefix := h[32:]
+
+	mh := sha512.New()
+	mh.Write(prefix)
+	mh.Write(message)
+	messageDigest := make([]byte, 0, sha512.Size)
+	messageDigest = mh.Sum(messageDigest)
+	r := edwards25519.NewScalar().SetUniformBytes(messageDigest)
+
+	R := (&edwards25519.Point{}).ScalarBaseMult(r)
 
-	h := sha512.New()
-	h.Write(privateKey[:32])
-
-	var digest1, messageDigest, hramDigest [64]byte
-	var expandedSecretKey [32]byte
-	h.Sum(digest1[:0])
-	copy(expandedSecretKey[:], digest1[:])
-	expandedSecretKey[0] &= 248
-	expandedSecretKey[31] &= 63
-	expandedSecretKey[31] |= 64
-
-	h.Reset()
-	h.Write(digest1[32:])
-	h.Write(message)
-	h.Sum(messageDigest[:0])
-
-	var messageDigestReduced [32]byte
-	edwards25519.ScReduce(&messageDigestReduced, &messageDigest)
-	var R edwards25519.ExtendedGroupElement
-	edwards25519.GeScalarMultBase(&R, &messageDigestReduced)
-
-	var encodedR [32]byte
-	R.ToBytes(&encodedR)
-
-	h.Reset()
-	h.Write(encodedR[:])
-	h.Write(privateKey[32:])
-	h.Write(message)
-	h.Sum(hramDigest[:0])
-	var hramDigestReduced [32]byte
-	edwards25519.ScReduce(&hramDigestReduced, &hramDigest)
-
-	var s [32]byte
-	edwards25519.ScMulAdd(&s, &hramDigestReduced, &expandedSecretKey, &messageDigestReduced)
-
-	copy(signature[:], encodedR[:])
-	copy(signature[32:], s[:])
+	kh := sha512.New()
+	kh.Write(R.Bytes())
+	kh.Write(publicKey)
+	kh.Write(message)
+	hramDigest := make([]byte, 0, sha512.Size)
+	hramDigest = kh.Sum(hramDigest)
+	k := edwards25519.NewScalar().SetUniformBytes(hramDigest)
+
+	S := edwards25519.NewScalar().MultiplyAdd(k, s, r)
+
+	copy(signature[:32], R.Bytes())
+	copy(signature[32:], S.Bytes())
 }
 
 // Verify reports whether sig is a valid signature of message by publicKey. It
@@ -209,38 +189,27 @@ func Verify(publicKey PublicKey, message, sig []byte) bool {
 		return false
 	}
 
-	var A edwards25519.ExtendedGroupElement
-	var publicKeyBytes [32]byte
-	copy(publicKeyBytes[:], publicKey)
-	if !A.FromBytes(&publicKeyBytes) {
+	A, err := (&edwards25519.Point{}).SetBytes(publicKey)
+	if err != nil {
 		return false
 	}
-	edwards25519.FeNeg(&A.X, &A.X)
-	edwards25519.FeNeg(&A.T, &A.T)
-
-	h := sha512.New()
-	h.Write(sig[:32])
-	h.Write(publicKey[:])
-	h.Write(message)
-	var digest [64]byte
-	h.Sum(digest[:0])
-
-	var hReduced [32]byte
-	edwards25519.ScReduce(&hReduced, &digest)
-
-	var R edwards25519.ProjectiveGroupElement
-	var s [32]byte
-	copy(s[:], sig[32:])
-
-	// https://tools.ietf.org/html/rfc8032#section-5.1.7 requires that s be in
-	// the range [0, order) in order to prevent signature malleability.
-	if !edwards25519.ScMinimal(&s) {
+
+	kh := sha512.New()
+	kh.Write(sig[:32])
+	kh.Write(publicKey)
+	kh.Write(message)
+	hramDigest := make([]byte, 0, sha512.Size)
+	hramDigest = kh.Sum(hramDigest)
+	k := edwards25519.NewScalar().SetUniformBytes(hramDigest)
+
+	S, err := edwards25519.NewScalar().SetCanonicalBytes(sig[32:])
+	if err != nil {
 		return false
 	}
 
-	edwards25519.GeDoubleScalarMultVartime(&R, &hReduced, &A, &s)
+	// [S]B = R + [k]A --> [k](-A) + [S]B = R
+	minusA := (&edwards25519.Point{}).Negate(A)
+	R := (&edwards25519.Point{}).VarTimeDoubleScalarBaseMult(k, minusA, S)
 
-	var checkR [32]byte
-	R.ToBytes(&checkR)
-	return bytes.Equal(sig[:32], checkR[:])
+	return bytes.Equal(sig[:32], R.Bytes())
 }
diff --git a/src/crypto/ed25519/ed25519_test.go b/src/crypto/ed25519/ed25519_test.go
index adb09e409a..ba9970e23e 100644
--- a/src/crypto/ed25519/ed25519_test.go
+++ b/src/crypto/ed25519/ed25519_test.go
@@ -9,7 +9,6 @@ import (
 	"bytes"
 	"compress/gzip"
 	"crypto"
-	"crypto/ed25519/internal/edwards25519"
 	"crypto/rand"
 	"encoding/hex"
 	"os"
@@ -26,24 +25,6 @@ func (zeroReader) Read(buf []byte) (int, error) {
 	return len(buf), nil
 }
 
-func TestUnmarshalMarshal(t *testing.T) {
-	pub, _, _ := GenerateKey(rand.Reader)
-
-	var A edwards25519.ExtendedGroupElement
-	var pubBytes [32]byte
-	copy(pubBytes[:], pub)
-	if !A.FromBytes(&pubBytes) {
-		t.Fatalf("ExtendedGroupElement.FromBytes failed")
-	}
-
-	var pub2 [32]byte
-	A.ToBytes(&pub2)
-
-	if pubBytes != pub2 {
-		t.Errorf("FromBytes(%v)->ToBytes does not round-trip, got %x\n", pubBytes, pub2)
-	}
-}
-
 func TestSignVerify(t *testing.T) {
 	var zero zeroReader
 	public, private, _ := GenerateKey(zero)
@@ -204,6 +185,21 @@ func TestMalleability(t *testing.T) {
 	}
 }
 
+func TestAllocations(t *testing.T) {
+	if allocs := testing.AllocsPerRun(100, func() {
+		seed := make([]byte, SeedSize)
+		message := []byte("Hello, world!")
+		priv := NewKeyFromSeed(seed)
+		pub := priv.Public().(PublicKey)
+		signature := Sign(priv, message)
+		if !Verify(pub, message, signature) {
+			t.Fatal("signature didn't verify")
+		}
+	}); allocs > 0 {
+		t.Errorf("expected zero allocations, got %0.1v", allocs)
+	}
+}
+
 func BenchmarkKeyGeneration(b *testing.B) {
 	var zero zeroReader
 	for i := 0; i < b.N; i++ {
@@ -215,7 +211,6 @@ func BenchmarkKeyGeneration(b *testing.B) {
 
 func BenchmarkNewKeyFromSeed(b *testing.B) {
 	seed := make([]byte, SeedSize)
-	b.ReportAllocs()
 	for i := 0; i < b.N; i++ {
 		_ = NewKeyFromSeed(seed)
 	}
@@ -228,7 +223,6 @@ func BenchmarkSigning(b *testing.B) {
 		b.Fatal(err)
 	}
 	message := []byte("Hello, world!")
-	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		Sign(priv, message)
diff --git a/src/crypto/ed25519/internal/edwards25519/const.go b/src/crypto/ed25519/internal/edwards25519/const.go
deleted file mode 100644
index e39f086c1d..0000000000
--- a/src/crypto/ed25519/internal/edwards25519/const.go
+++ /dev/null
@@ -1,1422 +0,0 @@
-// Copyright 2016 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 edwards25519
-
-// These values are from the public domain, “ref10” implementation of ed25519
-// from SUPERCOP.
-
-// d is a constant in the Edwards curve equation.
-var d = FieldElement{
-	-10913610, 13857413, -15372611, 6949391, 114729, -8787816, -6275908, -3247719, -18696448, -12055116,
-}
-
-// d2 is 2*d.
-var d2 = FieldElement{
-	-21827239, -5839606, -30745221, 13898782, 229458, 15978800, -12551817, -6495438, 29715968, 9444199,
-}
-
-// SqrtM1 is the square-root of -1 in the field.
-var SqrtM1 = FieldElement{
-	-32595792, -7943725, 9377950, 3500415, 12389472, -272473, -25146209, -2005654, 326686, 11406482,
-}
-
-// A is a constant in the Montgomery-form of curve25519.
-var A = FieldElement{
-	486662, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-}
-
-// bi contains precomputed multiples of the base-point. See the Ed25519 paper
-// for a discussion about how these values are used.
-var bi = [8]PreComputedGroupElement{
-	{
-		FieldElement{25967493, -14356035, 29566456, 3660896, -12694345, 4014787, 27544626, -11754271, -6079156, 2047605},
-		FieldElement{-12545711, 934262, -2722910, 3049990, -727428, 9406986, 12720692, 5043384, 19500929, -15469378},
-		FieldElement{-8738181, 4489570, 9688441, -14785194, 10184609, -12363380, 29287919, 11864899, -24514362, -4438546},
-	},
-	{
-		FieldElement{15636291, -9688557, 24204773, -7912398, 616977, -16685262, 27787600, -14772189, 28944400, -1550024},
-		FieldElement{16568933, 4717097, -11556148, -1102322, 15682896, -11807043, 16354577, -11775962, 7689662, 11199574},
-		FieldElement{30464156, -5976125, -11779434, -15670865, 23220365, 15915852, 7512774, 10017326, -17749093, -9920357},
-	},
-	{
-		FieldElement{10861363, 11473154, 27284546, 1981175, -30064349, 12577861, 32867885, 14515107, -15438304, 10819380},
-		FieldElement{4708026, 6336745, 20377586, 9066809, -11272109, 6594696, -25653668, 12483688, -12668491, 5581306},
-		FieldElement{19563160, 16186464, -29386857, 4097519, 10237984, -4348115, 28542350, 13850243, -23678021, -15815942},
-	},
-	{
-		FieldElement{5153746, 9909285, 1723747, -2777874, 30523605, 5516873, 19480852, 5230134, -23952439, -15175766},
-		FieldElement{-30269007, -3463509, 7665486, 10083793, 28475525, 1649722, 20654025, 16520125, 30598449, 7715701},
-		FieldElement{28881845, 14381568, 9657904, 3680757, -20181635, 7843316, -31400660, 1370708, 29794553, -1409300},
-	},
-	{
-		FieldElement{-22518993, -6692182, 14201702, -8745502, -23510406, 8844726, 18474211, -1361450, -13062696, 13821877},
-		FieldElement{-6455177, -7839871, 3374702, -4740862, -27098617, -10571707, 31655028, -7212327, 18853322, -14220951},
-		FieldElement{4566830, -12963868, -28974889, -12240689, -7602672, -2830569, -8514358, -10431137, 2207753, -3209784},
-	},
-	{
-		FieldElement{-25154831, -4185821, 29681144, 7868801, -6854661, -9423865, -12437364, -663000, -31111463, -16132436},
-		FieldElement{25576264, -2703214, 7349804, -11814844, 16472782, 9300885, 3844789, 15725684, 171356, 6466918},
-		FieldElement{23103977, 13316479, 9739013, -16149481, 817875, -15038942, 8965339, -14088058, -30714912, 16193877},
-	},
-	{
-		FieldElement{-33521811, 3180713, -2394130, 14003687, -16903474, -16270840, 17238398, 4729455, -18074513, 9256800},
-		FieldElement{-25182317, -4174131, 32336398, 5036987, -21236817, 11360617, 22616405, 9761698, -19827198, 630305},
-		FieldElement{-13720693, 2639453, -24237460, -7406481, 9494427, -5774029, -6554551, -15960994, -2449256, -14291300},
-	},
-	{
-		FieldElement{-3151181, -5046075, 9282714, 6866145, -31907062, -863023, -18940575, 15033784, 25105118, -7894876},
-		FieldElement{-24326370, 15950226, -31801215, -14592823, -11662737, -5090925, 1573892, -2625887, 2198790, -15804619},
-		FieldElement{-3099351, 10324967, -2241613, 7453183, -5446979, -2735503, -13812022, -16236442, -32461234, -12290683},
-	},
-}
-
-// base contains precomputed multiples of the base-point. See the Ed25519 paper
-// for a discussion about how these values are used.
-var base = [32][8]PreComputedGroupElement{
-	{
-		{
-			FieldElement{25967493, -14356035, 29566456, 3660896, -12694345, 4014787, 27544626, -11754271, -6079156, 2047605},
-			FieldElement{-12545711, 934262, -2722910, 3049990, -727428, 9406986, 12720692, 5043384, 19500929, -15469378},
-			FieldElement{-8738181, 4489570, 9688441, -14785194, 10184609, -12363380, 29287919, 11864899, -24514362, -4438546},
-		},
-		{
-			FieldElement{-12815894, -12976347, -21581243, 11784320, -25355658, -2750717, -11717903, -3814571, -358445, -10211303},
-			FieldElement{-21703237, 6903825, 27185491, 6451973, -29577724, -9554005, -15616551, 11189268, -26829678, -5319081},
-			FieldElement{26966642, 11152617, 32442495, 15396054, 14353839, -12752335, -3128826, -9541118, -15472047, -4166697},
-		},
-		{
-			FieldElement{15636291, -9688557, 24204773, -7912398, 616977, -16685262, 27787600, -14772189, 28944400, -1550024},
-			FieldElement{16568933, 4717097, -11556148, -1102322, 15682896, -11807043, 16354577, -11775962, 7689662, 11199574},
-			FieldElement{30464156, -5976125, -11779434, -15670865, 23220365, 15915852, 7512774, 10017326, -17749093, -9920357},
-		},
-		{
-			FieldElement{-17036878, 13921892, 10945806, -6033431, 27105052, -16084379, -28926210, 15006023, 3284568, -6276540},
-			FieldElement{23599295, -8306047, -11193664, -7687416, 13236774, 10506355, 7464579, 9656445, 13059162, 10374397},
-			FieldElement{7798556, 16710257, 3033922, 2874086, 28997861, 2835604, 32406664, -3839045, -641708, -101325},
-		},
-		{
-			FieldElement{10861363, 11473154, 27284546, 1981175, -30064349, 12577861, 32867885, 14515107, -15438304, 10819380},
-			FieldElement{4708026, 6336745, 20377586, 9066809, -11272109, 6594696, -25653668, 12483688, -12668491, 5581306},
-			FieldElement{19563160, 16186464, -29386857, 4097519, 10237984, -4348115, 28542350, 13850243, -23678021, -15815942},
-		},
-		{
-			FieldElement{-15371964, -12862754, 32573250, 4720197, -26436522, 5875511, -19188627, -15224819, -9818940, -12085777},
-			FieldElement{-8549212, 109983, 15149363, 2178705, 22900618, 4543417, 3044240, -15689887, 1762328, 14866737},
-			FieldElement{-18199695, -15951423, -10473290, 1707278, -17185920, 3916101, -28236412, 3959421, 27914454, 4383652},
-		},
-		{
-			FieldElement{5153746, 9909285, 1723747, -2777874, 30523605, 5516873, 19480852, 5230134, -23952439, -15175766},
-			FieldElement{-30269007, -3463509, 7665486, 10083793, 28475525, 1649722, 20654025, 16520125, 30598449, 7715701},
-			FieldElement{28881845, 14381568, 9657904, 3680757, -20181635, 7843316, -31400660, 1370708, 29794553, -1409300},
-		},
-		{
-			FieldElement{14499471, -2729599, -33191113, -4254652, 28494862, 14271267, 30290735, 10876454, -33154098, 2381726},
-			FieldElement{-7195431, -2655363, -14730155, 462251, -27724326, 3941372, -6236617, 3696005, -32300832, 15351955},
-			FieldElement{27431194, 8222322, 16448760, -3907995, -18707002, 11938355, -32961401, -2970515, 29551813, 10109425},
-		},
-	},
-	{
-		{
-			FieldElement{-13657040, -13155431, -31283750, 11777098, 21447386, 6519384, -2378284, -1627556, 10092783, -4764171},
-			FieldElement{27939166, 14210322, 4677035, 16277044, -22964462, -12398139, -32508754, 12005538, -17810127, 12803510},
-			FieldElement{17228999, -15661624, -1233527, 300140, -1224870, -11714777, 30364213, -9038194, 18016357, 4397660},
-		},
-		{
-			FieldElement{-10958843, -7690207, 4776341, -14954238, 27850028, -15602212, -26619106, 14544525, -17477504, 982639},
-			FieldElement{29253598, 15796703, -2863982, -9908884, 10057023, 3163536, 7332899, -4120128, -21047696, 9934963},
-			FieldElement{5793303, 16271923, -24131614, -10116404, 29188560, 1206517, -14747930, 4559895, -30123922, -10897950},
-		},
-		{
-			FieldElement{-27643952, -11493006, 16282657, -11036493, 28414021, -15012264, 24191034, 4541697, -13338309, 5500568},
-			FieldElement{12650548, -1497113, 9052871, 11355358, -17680037, -8400164, -17430592, 12264343, 10874051, 13524335},
-			FieldElement{25556948, -3045990, 714651, 2510400, 23394682, -10415330, 33119038, 5080568, -22528059, 5376628},
-		},
-		{
-			FieldElement{-26088264, -4011052, -17013699, -3537628, -6726793, 1920897, -22321305, -9447443, 4535768, 1569007},
-			FieldElement{-2255422, 14606630, -21692440, -8039818, 28430649, 8775819, -30494562, 3044290, 31848280, 12543772},
-			FieldElement{-22028579, 2943893, -31857513, 6777306, 13784462, -4292203, -27377195, -2062731, 7718482, 14474653},
-		},
-		{
-			FieldElement{2385315, 2454213, -22631320, 46603, -4437935, -15680415, 656965, -7236665, 24316168, -5253567},
-			FieldElement{13741529, 10911568, -33233417, -8603737, -20177830, -1033297, 33040651, -13424532, -20729456, 8321686},
-			FieldElement{21060490, -2212744, 15712757, -4336099, 1639040, 10656336, 23845965, -11874838, -9984458, 608372},
-		},
-		{
-			FieldElement{-13672732, -15087586, -10889693, -7557059, -6036909, 11305547, 1123968, -6780577, 27229399, 23887},
-			FieldElement{-23244140, -294205, -11744728, 14712571, -29465699, -2029617, 12797024, -6440308, -1633405, 16678954},
-			FieldElement{-29500620, 4770662, -16054387, 14001338, 7830047, 9564805, -1508144, -4795045, -17169265, 4904953},
-		},
-		{
-			FieldElement{24059557, 14617003, 19037157, -15039908, 19766093, -14906429, 5169211, 16191880, 2128236, -4326833},
-			FieldElement{-16981152, 4124966, -8540610, -10653797, 30336522, -14105247, -29806336, 916033, -6882542, -2986532},
-			FieldElement{-22630907, 12419372, -7134229, -7473371, -16478904, 16739175, 285431, 2763829, 15736322, 4143876},
-		},
-		{
-			FieldElement{2379352, 11839345, -4110402, -5988665, 11274298, 794957, 212801, -14594663, 23527084, -16458268},
-			FieldElement{33431127, -11130478, -17838966, -15626900, 8909499, 8376530, -32625340, 4087881, -15188911, -14416214},
-			FieldElement{1767683, 7197987, -13205226, -2022635, -13091350, 448826, 5799055, 4357868, -4774191, -16323038},
-		},
-	},
-	{
-		{
-			FieldElement{6721966, 13833823, -23523388, -1551314, 26354293, -11863321, 23365147, -3949732, 7390890, 2759800},
-			FieldElement{4409041, 2052381, 23373853, 10530217, 7676779, -12885954, 21302353, -4264057, 1244380, -12919645},
-			FieldElement{-4421239, 7169619, 4982368, -2957590, 30256825, -2777540, 14086413, 9208236, 15886429, 16489664},
-		},
-		{
-			FieldElement{1996075, 10375649, 14346367, 13311202, -6874135, -16438411, -13693198, 398369, -30606455, -712933},
-			FieldElement{-25307465, 9795880, -2777414, 14878809, -33531835, 14780363, 13348553, 12076947, -30836462, 5113182},
-			FieldElement{-17770784, 11797796, 31950843, 13929123, -25888302, 12288344, -30341101, -7336386, 13847711, 5387222},
-		},
-		{
-			FieldElement{-18582163, -3416217, 17824843, -2340966, 22744343, -10442611, 8763061, 3617786, -19600662, 10370991},
-			FieldElement{20246567, -14369378, 22358229, -543712, 18507283, -10413996, 14554437, -8746092, 32232924, 16763880},
-			FieldElement{9648505, 10094563, 26416693, 14745928, -30374318, -6472621, 11094161, 15689506, 3140038, -16510092},
-		},
-		{
-			FieldElement{-16160072, 5472695, 31895588, 4744994, 8823515, 10365685, -27224800, 9448613, -28774454, 366295},
-			FieldElement{19153450, 11523972, -11096490, -6503142, -24647631, 5420647, 28344573, 8041113, 719605, 11671788},
-			FieldElement{8678025, 2694440, -6808014, 2517372, 4964326, 11152271, -15432916, -15266516, 27000813, -10195553},
-		},
-		{
-			FieldElement{-15157904, 7134312, 8639287, -2814877, -7235688, 10421742, 564065, 5336097, 6750977, -14521026},
-			FieldElement{11836410, -3979488, 26297894, 16080799, 23455045, 15735944, 1695823, -8819122, 8169720, 16220347},
-			FieldElement{-18115838, 8653647, 17578566, -6092619, -8025777, -16012763, -11144307, -2627664, -5990708, -14166033},
-		},
-		{
-			FieldElement{-23308498, -10968312, 15213228, -10081214, -30853605, -11050004, 27884329, 2847284, 2655861, 1738395},
-			FieldElement{-27537433, -14253021, -25336301, -8002780, -9370762, 8129821, 21651608, -3239336, -19087449, -11005278},
-			FieldElement{1533110, 3437855, 23735889, 459276, 29970501, 11335377, 26030092, 5821408, 10478196, 8544890},
-		},
-		{
-			FieldElement{32173121, -16129311, 24896207, 3921497, 22579056, -3410854, 19270449, 12217473, 17789017, -3395995},
-			FieldElement{-30552961, -2228401, -15578829, -10147201, 13243889, 517024, 15479401, -3853233, 30460520, 1052596},
-			FieldElement{-11614875, 13323618, 32618793, 8175907, -15230173, 12596687, 27491595, -4612359, 3179268, -9478891},
-		},
-		{
-			FieldElement{31947069, -14366651, -4640583, -15339921, -15125977, -6039709, -14756777, -16411740, 19072640, -9511060},
-			FieldElement{11685058, 11822410, 3158003, -13952594, 33402194, -4165066, 5977896, -5215017, 473099, 5040608},
-			FieldElement{-20290863, 8198642, -27410132, 11602123, 1290375, -2799760, 28326862, 1721092, -19558642, -3131606},
-		},
-	},
-	{
-		{
-			FieldElement{7881532, 10687937, 7578723, 7738378, -18951012, -2553952, 21820786, 8076149, -27868496, 11538389},
-			FieldElement{-19935666, 3899861, 18283497, -6801568, -15728660, -11249211, 8754525, 7446702, -5676054, 5797016},
-			FieldElement{-11295600, -3793569, -15782110, -7964573, 12708869, -8456199, 2014099, -9050574, -2369172, -5877341},
-		},
-		{
-			FieldElement{-22472376, -11568741, -27682020, 1146375, 18956691, 16640559, 1192730, -3714199, 15123619, 10811505},
-			FieldElement{14352098, -3419715, -18942044, 10822655, 32750596, 4699007, -70363, 15776356, -28886779, -11974553},
-			FieldElement{-28241164, -8072475, -4978962, -5315317, 29416931, 1847569, -20654173, -16484855, 4714547, -9600655},
-		},
-		{
-			FieldElement{15200332, 8368572, 19679101, 15970074, -31872674, 1959451, 24611599, -4543832, -11745876, 12340220},
-			FieldElement{12876937, -10480056, 33134381, 6590940, -6307776, 14872440, 9613953, 8241152, 15370987, 9608631},
-			FieldElement{-4143277, -12014408, 8446281, -391603, 4407738, 13629032, -7724868, 15866074, -28210621, -8814099},
-		},
-		{
-			FieldElement{26660628, -15677655, 8393734, 358047, -7401291, 992988, -23904233, 858697, 20571223, 8420556},
-			FieldElement{14620715, 13067227, -15447274, 8264467, 14106269, 15080814, 33531827, 12516406, -21574435, -12476749},
-			FieldElement{236881, 10476226, 57258, -14677024, 6472998, 2466984, 17258519, 7256740, 8791136, 15069930},
-		},
-		{
-			FieldElement{1276410, -9371918, 22949635, -16322807, -23493039, -5702186, 14711875, 4874229, -30663140, -2331391},
-			FieldElement{5855666, 4990204, -13711848, 7294284, -7804282, 1924647, -1423175, -7912378, -33069337, 9234253},
-			FieldElement{20590503, -9018988, 31529744, -7352666, -2706834, 10650548, 31559055, -11609587, 18979186, 13396066},
-		},
-		{
-			FieldElement{24474287, 4968103, 22267082, 4407354, 24063882, -8325180, -18816887, 13594782, 33514650, 7021958},
-			FieldElement{-11566906, -6565505, -21365085, 15928892, -26158305, 4315421, -25948728, -3916677, -21480480, 12868082},
-			FieldElement{-28635013, 13504661, 19988037, -2132761, 21078225, 6443208, -21446107, 2244500, -12455797, -8089383},
-		},
-		{
-			FieldElement{-30595528, 13793479, -5852820, 319136, -25723172, -6263899, 33086546, 8957937, -15233648, 5540521},
-			FieldElement{-11630176, -11503902, -8119500, -7643073, 2620056, 1022908, -23710744, -1568984, -16128528, -14962807},
-			FieldElement{23152971, 775386, 27395463, 14006635, -9701118, 4649512, 1689819, 892185, -11513277, -15205948},
-		},
-		{
-			FieldElement{9770129, 9586738, 26496094, 4324120, 1556511, -3550024, 27453819, 4763127, -19179614, 5867134},
-			FieldElement{-32765025, 1927590, 31726409, -4753295, 23962434, -16019500, 27846559, 5931263, -29749703, -16108455},
-			FieldElement{27461885, -2977536, 22380810, 1815854, -23033753, -3031938, 7283490, -15148073, -19526700, 7734629},
-		},
-	},
-	{
-		{
-			FieldElement{-8010264, -9590817, -11120403, 6196038, 29344158, -13430885, 7585295, -3176626, 18549497, 15302069},
-			FieldElement{-32658337, -6171222, -7672793, -11051681, 6258878, 13504381, 10458790, -6418461, -8872242, 8424746},
-			FieldElement{24687205, 8613276, -30667046, -3233545, 1863892, -1830544, 19206234, 7134917, -11284482, -828919},
-		},
-		{
-			FieldElement{11334899, -9218022, 8025293, 12707519, 17523892, -10476071, 10243738, -14685461, -5066034, 16498837},
-			FieldElement{8911542, 6887158, -9584260, -6958590, 11145641, -9543680, 17303925, -14124238, 6536641, 10543906},
-			FieldElement{-28946384, 15479763, -17466835, 568876, -1497683, 11223454, -2669190, -16625574, -27235709, 8876771},
-		},
-		{
-			FieldElement{-25742899, -12566864, -15649966, -846607, -33026686, -796288, -33481822, 15824474, -604426, -9039817},
-			FieldElement{10330056, 70051, 7957388, -9002667, 9764902, 15609756, 27698697, -4890037, 1657394, 3084098},
-			FieldElement{10477963, -7470260, 12119566, -13250805, 29016247, -5365589, 31280319, 14396151, -30233575, 15272409},
-		},
-		{
-			FieldElement{-12288309, 3169463, 28813183, 16658753, 25116432, -5630466, -25173957, -12636138, -25014757, 1950504},
-			FieldElement{-26180358, 9489187, 11053416, -14746161, -31053720, 5825630, -8384306, -8767532, 15341279, 8373727},
-			FieldElement{28685821, 7759505, -14378516, -12002860, -31971820, 4079242, 298136, -10232602, -2878207, 15190420},
-		},
-		{
-			FieldElement{-32932876, 13806336, -14337485, -15794431, -24004620, 10940928, 8669718, 2742393, -26033313, -6875003},
-			FieldElement{-1580388, -11729417, -25979658, -11445023, -17411874, -10912854, 9291594, -16247779, -12154742, 6048605},
-			FieldElement{-30305315, 14843444, 1539301, 11864366, 20201677, 1900163, 13934231, 5128323, 11213262, 9168384},
-		},
-		{
-			FieldElement{-26280513, 11007847, 19408960, -940758, -18592965, -4328580, -5088060, -11105150, 20470157, -16398701},
-			FieldElement{-23136053, 9282192, 14855179, -15390078, -7362815, -14408560, -22783952, 14461608, 14042978, 5230683},
-			FieldElement{29969567, -2741594, -16711867, -8552442, 9175486, -2468974, 21556951, 3506042, -5933891, -12449708},
-		},
-		{
-			FieldElement{-3144746, 8744661, 19704003, 4581278, -20430686, 6830683, -21284170, 8971513, -28539189, 15326563},
-			FieldElement{-19464629, 10110288, -17262528, -3503892, -23500387, 1355669, -15523050, 15300988, -20514118, 9168260},
-			FieldElement{-5353335, 4488613, -23803248, 16314347, 7780487, -15638939, -28948358, 9601605, 33087103, -9011387},
-		},
-		{
-			FieldElement{-19443170, -15512900, -20797467, -12445323, -29824447, 10229461, -27444329, -15000531, -5996870, 15664672},
-			FieldElement{23294591, -16632613, -22650781, -8470978, 27844204, 11461195, 13099750, -2460356, 18151676, 13417686},
-			FieldElement{-24722913, -4176517, -31150679, 5988919, -26858785, 6685065, 1661597, -12551441, 15271676, -15452665},
-		},
-	},
-	{
-		{
-			FieldElement{11433042, -13228665, 8239631, -5279517, -1985436, -725718, -18698764, 2167544, -6921301, -13440182},
-			FieldElement{-31436171, 15575146, 30436815, 12192228, -22463353, 9395379, -9917708, -8638997, 12215110, 12028277},
-			FieldElement{14098400, 6555944, 23007258, 5757252, -15427832, -12950502, 30123440, 4617780, -16900089, -655628},
-		},
-		{
-			FieldElement{-4026201, -15240835, 11893168, 13718664, -14809462, 1847385, -15819999, 10154009, 23973261, -12684474},
-			FieldElement{-26531820, -3695990, -1908898, 2534301, -31870557, -16550355, 18341390, -11419951, 32013174, -10103539},
-			FieldElement{-25479301, 10876443, -11771086, -14625140, -12369567, 1838104, 21911214, 6354752, 4425632, -837822},
-		},
-		{
-			FieldElement{-10433389, -14612966, 22229858, -3091047, -13191166, 776729, -17415375, -12020462, 4725005, 14044970},
-			FieldElement{19268650, -7304421, 1555349, 8692754, -21474059, -9910664, 6347390, -1411784, -19522291, -16109756},
-			FieldElement{-24864089, 12986008, -10898878, -5558584, -11312371, -148526, 19541418, 8180106, 9282262, 10282508},
-		},
-		{
-			FieldElement{-26205082, 4428547, -8661196, -13194263, 4098402, -14165257, 15522535, 8372215, 5542595, -10702683},
-			FieldElement{-10562541, 14895633, 26814552, -16673850, -17480754, -2489360, -2781891, 6993761, -18093885, 10114655},
-			FieldElement{-20107055, -929418, 31422704, 10427861, -7110749, 6150669, -29091755, -11529146, 25953725, -106158},
-		},
-		{
-			FieldElement{-4234397, -8039292, -9119125, 3046000, 2101609, -12607294, 19390020, 6094296, -3315279, 12831125},
-			FieldElement{-15998678, 7578152, 5310217, 14408357, -33548620, -224739, 31575954, 6326196, 7381791, -2421839},
-			FieldElement{-20902779, 3296811, 24736065, -16328389, 18374254, 7318640, 6295303, 8082724, -15362489, 12339664},
-		},
-		{
-			FieldElement{27724736, 2291157, 6088201, -14184798, 1792727, 5857634, 13848414, 15768922, 25091167, 14856294},
-			FieldElement{-18866652, 8331043, 24373479, 8541013, -701998, -9269457, 12927300, -12695493, -22182473, -9012899},
-			FieldElement{-11423429, -5421590, 11632845, 3405020, 30536730, -11674039, -27260765, 13866390, 30146206, 9142070},
-		},
-		{
-			FieldElement{3924129, -15307516, -13817122, -10054960, 12291820, -668366, -27702774, 9326384, -8237858, 4171294},
-			FieldElement{-15921940, 16037937, 6713787, 16606682, -21612135, 2790944, 26396185, 3731949, 345228, -5462949},
-			FieldElement{-21327538, 13448259, 25284571, 1143661, 20614966, -8849387, 2031539, -12391231, -16253183, -13582083},
-		},
-		{
-			FieldElement{31016211, -16722429, 26371392, -14451233, -5027349, 14854137, 17477601, 3842657, 28012650, -16405420},
-			FieldElement{-5075835, 9368966, -8562079, -4600902, -15249953, 6970560, -9189873, 16292057, -8867157, 3507940},
-			FieldElement{29439664, 3537914, 23333589, 6997794, -17555561, -11018068, -15209202, -15051267, -9164929, 6580396},
-		},
-	},
-	{
-		{
-			FieldElement{-12185861, -7679788, 16438269, 10826160, -8696817, -6235611, 17860444, -9273846, -2095802, 9304567},
-			FieldElement{20714564, -4336911, 29088195, 7406487, 11426967, -5095705, 14792667, -14608617, 5289421, -477127},
-			FieldElement{-16665533, -10650790, -6160345, -13305760, 9192020, -1802462, 17271490, 12349094, 26939669, -3752294},
-		},
-		{
-			FieldElement{-12889898, 9373458, 31595848, 16374215, 21471720, 13221525, -27283495, -12348559, -3698806, 117887},
-			FieldElement{22263325, -6560050, 3984570, -11174646, -15114008, -566785, 28311253, 5358056, -23319780, 541964},
-			FieldElement{16259219, 3261970, 2309254, -15534474, -16885711, -4581916, 24134070, -16705829, -13337066, -13552195},
-		},
-		{
-			FieldElement{9378160, -13140186, -22845982, -12745264, 28198281, -7244098, -2399684, -717351, 690426, 14876244},
-			FieldElement{24977353, -314384, -8223969, -13465086, 28432343, -1176353, -13068804, -12297348, -22380984, 6618999},
-			FieldElement{-1538174, 11685646, 12944378, 13682314, -24389511, -14413193, 8044829, -13817328, 32239829, -5652762},
-		},
-		{
-			FieldElement{-18603066, 4762990, -926250, 8885304, -28412480, -3187315, 9781647, -10350059, 32779359, 5095274},
-			FieldElement{-33008130, -5214506, -32264887, -3685216, 9460461, -9327423, -24601656, 14506724, 21639561, -2630236},
-			FieldElement{-16400943, -13112215, 25239338, 15531969, 3987758, -4499318, -1289502, -6863535, 17874574, 558605},
-		},
-		{
-			FieldElement{-13600129, 10240081, 9171883, 16131053, -20869254, 9599700, 33499487, 5080151, 2085892, 5119761},
-			FieldElement{-22205145, -2519528, -16381601, 414691, -25019550, 2170430, 30634760, -8363614, -31999993, -5759884},
-			FieldElement{-6845704, 15791202, 8550074, -1312654, 29928809, -12092256, 27534430, -7192145, -22351378, 12961482},
-		},
-		{
-			FieldElement{-24492060, -9570771, 10368194, 11582341, -23397293, -2245287, 16533930, 8206996, -30194652, -5159638},
-			FieldElement{-11121496, -3382234, 2307366, 6362031, -135455, 8868177, -16835630, 7031275, 7589640, 8945490},
-			FieldElement{-32152748, 8917967, 6661220, -11677616, -1192060, -15793393, 7251489, -11182180, 24099109, -14456170},
-		},
-		{
-			FieldElement{5019558, -7907470, 4244127, -14714356, -26933272, 6453165, -19118182, -13289025, -6231896, -10280736},
-			FieldElement{10853594, 10721687, 26480089, 5861829, -22995819, 1972175, -1866647, -10557898, -3363451, -6441124},
-			FieldElement{-17002408, 5906790, 221599, -6563147, 7828208, -13248918, 24362661, -2008168, -13866408, 7421392},
-		},
-		{
-			FieldElement{8139927, -6546497, 32257646, -5890546, 30375719, 1886181, -21175108, 15441252, 28826358, -4123029},
-			FieldElement{6267086, 9695052, 7709135, -16603597, -32869068, -1886135, 14795160, -7840124, 13746021, -1742048},
-			FieldElement{28584902, 7787108, -6732942, -15050729, 22846041, -7571236, -3181936, -363524, 4771362, -8419958},
-		},
-	},
-	{
-		{
-			FieldElement{24949256, 6376279, -27466481, -8174608, -18646154, -9930606, 33543569, -12141695, 3569627, 11342593},
-			FieldElement{26514989, 4740088, 27912651, 3697550, 19331575, -11472339, 6809886, 4608608, 7325975, -14801071},
-			FieldElement{-11618399, -14554430, -24321212, 7655128, -1369274, 5214312, -27400540, 10258390, -17646694, -8186692},
-		},
-		{
-			FieldElement{11431204, 15823007, 26570245, 14329124, 18029990, 4796082, -31446179, 15580664, 9280358, -3973687},
-			FieldElement{-160783, -10326257, -22855316, -4304997, -20861367, -13621002, -32810901, -11181622, -15545091, 4387441},
-			FieldElement{-20799378, 12194512, 3937617, -5805892, -27154820, 9340370, -24513992, 8548137, 20617071, -7482001},
-		},
-		{
-			FieldElement{-938825, -3930586, -8714311, 16124718, 24603125, -6225393, -13775352, -11875822, 24345683, 10325460},
-			FieldElement{-19855277, -1568885, -22202708, 8714034, 14007766, 6928528, 16318175, -1010689, 4766743, 3552007},
-			FieldElement{-21751364, -16730916, 1351763, -803421, -4009670, 3950935, 3217514, 14481909, 10988822, -3994762},
-		},
-		{
-			FieldElement{15564307, -14311570, 3101243, 5684148, 30446780, -8051356, 12677127, -6505343, -8295852, 13296005},
-			FieldElement{-9442290, 6624296, -30298964, -11913677, -4670981, -2057379, 31521204, 9614054, -30000824, 12074674},
-			FieldElement{4771191, -135239, 14290749, -13089852, 27992298, 14998318, -1413936, -1556716, 29832613, -16391035},
-		},
-		{
-			FieldElement{7064884, -7541174, -19161962, -5067537, -18891269, -2912736, 25825242, 5293297, -27122660, 13101590},
-			FieldElement{-2298563, 2439670, -7466610, 1719965, -27267541, -16328445, 32512469, -5317593, -30356070, -4190957},
-			FieldElement{-30006540, 10162316, -33180176, 3981723, -16482138, -13070044, 14413974, 9515896, 19568978, 9628812},
-		},
-		{
-			FieldElement{33053803, 199357, 15894591, 1583059, 27380243, -4580435, -17838894, -6106839, -6291786, 3437740},
-			FieldElement{-18978877, 3884493, 19469877, 12726490, 15913552, 13614290, -22961733, 70104, 7463304, 4176122},
-			FieldElement{-27124001, 10659917, 11482427, -16070381, 12771467, -6635117, -32719404, -5322751, 24216882, 5944158},
-		},
-		{
-			FieldElement{8894125, 7450974, -2664149, -9765752, -28080517, -12389115, 19345746, 14680796, 11632993, 5847885},
-			FieldElement{26942781, -2315317, 9129564, -4906607, 26024105, 11769399, -11518837, 6367194, -9727230, 4782140},
-			FieldElement{19916461, -4828410, -22910704, -11414391, 25606324, -5972441, 33253853, 8220911, 6358847, -1873857},
-		},
-		{
-			FieldElement{801428, -2081702, 16569428, 11065167, 29875704, 96627, 7908388, -4480480, -13538503, 1387155},
-			FieldElement{19646058, 5720633, -11416706, 12814209, 11607948, 12749789, 14147075, 15156355, -21866831, 11835260},
-			FieldElement{19299512, 1155910, 28703737, 14890794, 2925026, 7269399, 26121523, 15467869, -26560550, 5052483},
-		},
-	},
-	{
-		{
-			FieldElement{-3017432, 10058206, 1980837, 3964243, 22160966, 12322533, -6431123, -12618185, 12228557, -7003677},
-			FieldElement{32944382, 14922211, -22844894, 5188528, 21913450, -8719943, 4001465, 13238564, -6114803, 8653815},
-			FieldElement{22865569, -4652735, 27603668, -12545395, 14348958, 8234005, 24808405, 5719875, 28483275, 2841751},
-		},
-		{
-			FieldElement{-16420968, -1113305, -327719, -12107856, 21886282, -15552774, -1887966, -315658, 19932058, -12739203},
-			FieldElement{-11656086, 10087521, -8864888, -5536143, -19278573, -3055912, 3999228, 13239134, -4777469, -13910208},
-			FieldElement{1382174, -11694719, 17266790, 9194690, -13324356, 9720081, 20403944, 11284705, -14013818, 3093230},
-		},
-		{
-			FieldElement{16650921, -11037932, -1064178, 1570629, -8329746, 7352753, -302424, 16271225, -24049421, -6691850},
-			FieldElement{-21911077, -5927941, -4611316, -5560156, -31744103, -10785293, 24123614, 15193618, -21652117, -16739389},
-			FieldElement{-9935934, -4289447, -25279823, 4372842, 2087473, 10399484, 31870908, 14690798, 17361620, 11864968},
-		},
-		{
-			FieldElement{-11307610, 6210372, 13206574, 5806320, -29017692, -13967200, -12331205, -7486601, -25578460, -16240689},
-			FieldElement{14668462, -12270235, 26039039, 15305210, 25515617, 4542480, 10453892, 6577524, 9145645, -6443880},
-			FieldElement{5974874, 3053895, -9433049, -10385191, -31865124, 3225009, -7972642, 3936128, -5652273, -3050304},
-		},
-		{
-			FieldElement{30625386, -4729400, -25555961, -12792866, -20484575, 7695099, 17097188, -16303496, -27999779, 1803632},
-			FieldElement{-3553091, 9865099, -5228566, 4272701, -5673832, -16689700, 14911344, 12196514, -21405489, 7047412},
-			FieldElement{20093277, 9920966, -11138194, -5343857, 13161587, 12044805, -32856851, 4124601, -32343828, -10257566},
-		},
-		{
-			FieldElement{-20788824, 14084654, -13531713, 7842147, 19119038, -13822605, 4752377, -8714640, -21679658, 2288038},
-			FieldElement{-26819236, -3283715, 29965059, 3039786, -14473765, 2540457, 29457502, 14625692, -24819617, 12570232},
-			FieldElement{-1063558, -11551823, 16920318, 12494842, 1278292, -5869109, -21159943, -3498680, -11974704, 4724943},
-		},
-		{
-			FieldElement{17960970, -11775534, -4140968, -9702530, -8876562, -1410617, -12907383, -8659932, -29576300, 1903856},
-			FieldElement{23134274, -14279132, -10681997, -1611936, 20684485, 15770816, -12989750, 3190296, 26955097, 14109738},
-			FieldElement{15308788, 5320727, -30113809, -14318877, 22902008, 7767164, 29425325, -11277562, 31960942, 11934971},
-		},
-		{
-			FieldElement{-27395711, 8435796, 4109644, 12222639, -24627868, 14818669, 20638173, 4875028, 10491392, 1379718},
-			FieldElement{-13159415, 9197841, 3875503, -8936108, -1383712, -5879801, 33518459, 16176658, 21432314, 12180697},
-			FieldElement{-11787308, 11500838, 13787581, -13832590, -22430679, 10140205, 1465425, 12689540, -10301319, -13872883},
-		},
-	},
-	{
-		{
-			FieldElement{5414091, -15386041, -21007664, 9643570, 12834970, 1186149, -2622916, -1342231, 26128231, 6032912},
-			FieldElement{-26337395, -13766162, 32496025, -13653919, 17847801, -12669156, 3604025, 8316894, -25875034, -10437358},
-			FieldElement{3296484, 6223048, 24680646, -12246460, -23052020, 5903205, -8862297, -4639164, 12376617, 3188849},
-		},
-		{
-			FieldElement{29190488, -14659046, 27549113, -1183516, 3520066, -10697301, 32049515, -7309113, -16109234, -9852307},
-			FieldElement{-14744486, -9309156, 735818, -598978, -20407687, -5057904, 25246078, -15795669, 18640741, -960977},
-			FieldElement{-6928835, -16430795, 10361374, 5642961, 4910474, 12345252, -31638386, -494430, 10530747, 1053335},
-		},
-		{
-			FieldElement{-29265967, -14186805, -13538216, -12117373, -19457059, -10655384, -31462369, -2948985, 24018831, 15026644},
-			FieldElement{-22592535, -3145277, -2289276, 5953843, -13440189, 9425631, 25310643, 13003497, -2314791, -15145616},
-			FieldElement{-27419985, -603321, -8043984, -1669117, -26092265, 13987819, -27297622, 187899, -23166419, -2531735},
-		},
-		{
-			FieldElement{-21744398, -13810475, 1844840, 5021428, -10434399, -15911473, 9716667, 16266922, -5070217, 726099},
-			FieldElement{29370922, -6053998, 7334071, -15342259, 9385287, 2247707, -13661962, -4839461, 30007388, -15823341},
-			FieldElement{-936379, 16086691, 23751945, -543318, -1167538, -5189036, 9137109, 730663, 9835848, 4555336},
-		},
-		{
-			FieldElement{-23376435, 1410446, -22253753, -12899614, 30867635, 15826977, 17693930, 544696, -11985298, 12422646},
-			FieldElement{31117226, -12215734, -13502838, 6561947, -9876867, -12757670, -5118685, -4096706, 29120153, 13924425},
-			FieldElement{-17400879, -14233209, 19675799, -2734756, -11006962, -5858820, -9383939, -11317700, 7240931, -237388},
-		},
-		{
-			FieldElement{-31361739, -11346780, -15007447, -5856218, -22453340, -12152771, 1222336, 4389483, 3293637, -15551743},
-			FieldElement{-16684801, -14444245, 11038544, 11054958, -13801175, -3338533, -24319580, 7733547, 12796905, -6335822},
-			FieldElement{-8759414, -10817836, -25418864, 10783769, -30615557, -9746811, -28253339, 3647836, 3222231, -11160462},
-		},
-		{
-			FieldElement{18606113, 1693100, -25448386, -15170272, 4112353, 10045021, 23603893, -2048234, -7550776, 2484985},
-			FieldElement{9255317, -3131197, -12156162, -1004256, 13098013, -9214866, 16377220, -2102812, -19802075, -3034702},
-			FieldElement{-22729289, 7496160, -5742199, 11329249, 19991973, -3347502, -31718148, 9936966, -30097688, -10618797},
-		},
-		{
-			FieldElement{21878590, -5001297, 4338336, 13643897, -3036865, 13160960, 19708896, 5415497, -7360503, -4109293},
-			FieldElement{27736861, 10103576, 12500508, 8502413, -3413016, -9633558, 10436918, -1550276, -23659143, -8132100},
-			FieldElement{19492550, -12104365, -29681976, -852630, -3208171, 12403437, 30066266, 8367329, 13243957, 8709688},
-		},
-	},
-	{
-		{
-			FieldElement{12015105, 2801261, 28198131, 10151021, 24818120, -4743133, -11194191, -5645734, 5150968, 7274186},
-			FieldElement{2831366, -12492146, 1478975, 6122054, 23825128, -12733586, 31097299, 6083058, 31021603, -9793610},
-			FieldElement{-2529932, -2229646, 445613, 10720828, -13849527, -11505937, -23507731, 16354465, 15067285, -14147707},
-		},
-		{
-			FieldElement{7840942, 14037873, -33364863, 15934016, -728213, -3642706, 21403988, 1057586, -19379462, -12403220},
-			FieldElement{915865, -16469274, 15608285, -8789130, -24357026, 6060030, -17371319, 8410997, -7220461, 16527025},
-			FieldElement{32922597, -556987, 20336074, -16184568, 10903705, -5384487, 16957574, 52992, 23834301, 6588044},
-		},
-		{
-			FieldElement{32752030, 11232950, 3381995, -8714866, 22652988, -10744103, 17159699, 16689107, -20314580, -1305992},
-			FieldElement{-4689649, 9166776, -25710296, -10847306, 11576752, 12733943, 7924251, -2752281, 1976123, -7249027},
-			FieldElement{21251222, 16309901, -2983015, -6783122, 30810597, 12967303, 156041, -3371252, 12331345, -8237197},
-		},
-		{
-			FieldElement{8651614, -4477032, -16085636, -4996994, 13002507, 2950805, 29054427, -5106970, 10008136, -4667901},
-			FieldElement{31486080, 15114593, -14261250, 12951354, 14369431, -7387845, 16347321, -13662089, 8684155, -10532952},
-			FieldElement{19443825, 11385320, 24468943, -9659068, -23919258, 2187569, -26263207, -6086921, 31316348, 14219878},
-		},
-		{
-			FieldElement{-28594490, 1193785, 32245219, 11392485, 31092169, 15722801, 27146014, 6992409, 29126555, 9207390},
-			FieldElement{32382935, 1110093, 18477781, 11028262, -27411763, -7548111, -4980517, 10843782, -7957600, -14435730},
-			FieldElement{2814918, 7836403, 27519878, -7868156, -20894015, -11553689, -21494559, 8550130, 28346258, 1994730},
-		},
-		{
-			FieldElement{-19578299, 8085545, -14000519, -3948622, 2785838, -16231307, -19516951, 7174894, 22628102, 8115180},
-			FieldElement{-30405132, 955511, -11133838, -15078069, -32447087, -13278079, -25651578, 3317160, -9943017, 930272},
-			FieldElement{-15303681, -6833769, 28856490, 1357446, 23421993, 1057177, 24091212, -1388970, -22765376, -10650715},
-		},
-		{
-			FieldElement{-22751231, -5303997, -12907607, -12768866, -15811511, -7797053, -14839018, -16554220, -1867018, 8398970},
-			FieldElement{-31969310, 2106403, -4736360, 1362501, 12813763, 16200670, 22981545, -6291273, 18009408, -15772772},
-			FieldElement{-17220923, -9545221, -27784654, 14166835, 29815394, 7444469, 29551787, -3727419, 19288549, 1325865},
-		},
-		{
-			FieldElement{15100157, -15835752, -23923978, -1005098, -26450192, 15509408, 12376730, -3479146, 33166107, -8042750},
-			FieldElement{20909231, 13023121, -9209752, 16251778, -5778415, -8094914, 12412151, 10018715, 2213263, -13878373},
-			FieldElement{32529814, -11074689, 30361439, -16689753, -9135940, 1513226, 22922121, 6382134, -5766928, 8371348},
-		},
-	},
-	{
-		{
-			FieldElement{9923462, 11271500, 12616794, 3544722, -29998368, -1721626, 12891687, -8193132, -26442943, 10486144},
-			FieldElement{-22597207, -7012665, 8587003, -8257861, 4084309, -12970062, 361726, 2610596, -23921530, -11455195},
-			FieldElement{5408411, -1136691, -4969122, 10561668, 24145918, 14240566, 31319731, -4235541, 19985175, -3436086},
-		},
-		{
-			FieldElement{-13994457, 16616821, 14549246, 3341099, 32155958, 13648976, -17577068, 8849297, 65030, 8370684},
-			FieldElement{-8320926, -12049626, 31204563, 5839400, -20627288, -1057277, -19442942, 6922164, 12743482, -9800518},
-			FieldElement{-2361371, 12678785, 28815050, 4759974, -23893047, 4884717, 23783145, 11038569, 18800704, 255233},
-		},
-		{
-			FieldElement{-5269658, -1773886, 13957886, 7990715, 23132995, 728773, 13393847, 9066957, 19258688, -14753793},
-			FieldElement{-2936654, -10827535, -10432089, 14516793, -3640786, 4372541, -31934921, 2209390, -1524053, 2055794},
-			FieldElement{580882, 16705327, 5468415, -2683018, -30926419, -14696000, -7203346, -8994389, -30021019, 7394435},
-		},
-		{
-			FieldElement{23838809, 1822728, -15738443, 15242727, 8318092, -3733104, -21672180, -3492205, -4821741, 14799921},
-			FieldElement{13345610, 9759151, 3371034, -16137791, 16353039, 8577942, 31129804, 13496856, -9056018, 7402518},
-			FieldElement{2286874, -4435931, -20042458, -2008336, -13696227, 5038122, 11006906, -15760352, 8205061, 1607563},
-		},
-		{
-			FieldElement{14414086, -8002132, 3331830, -3208217, 22249151, -5594188, 18364661, -2906958, 30019587, -9029278},
-			FieldElement{-27688051, 1585953, -10775053, 931069, -29120221, -11002319, -14410829, 12029093, 9944378, 8024},
-			FieldElement{4368715, -3709630, 29874200, -15022983, -20230386, -11410704, -16114594, -999085, -8142388, 5640030},
-		},
-		{
-			FieldElement{10299610, 13746483, 11661824, 16234854, 7630238, 5998374, 9809887, -16694564, 15219798, -14327783},
-			FieldElement{27425505, -5719081, 3055006, 10660664, 23458024, 595578, -15398605, -1173195, -18342183, 9742717},
-			FieldElement{6744077, 2427284, 26042789, 2720740, -847906, 1118974, 32324614, 7406442, 12420155, 1994844},
-		},
-		{
-			FieldElement{14012521, -5024720, -18384453, -9578469, -26485342, -3936439, -13033478, -10909803, 24319929, -6446333},
-			FieldElement{16412690, -4507367, 10772641, 15929391, -17068788, -4658621, 10555945, -10484049, -30102368, -4739048},
-			FieldElement{22397382, -7767684, -9293161, -12792868, 17166287, -9755136, -27333065, 6199366, 21880021, -12250760},
-		},
-		{
-			FieldElement{-4283307, 5368523, -31117018, 8163389, -30323063, 3209128, 16557151, 8890729, 8840445, 4957760},
-			FieldElement{-15447727, 709327, -6919446, -10870178, -29777922, 6522332, -21720181, 12130072, -14796503, 5005757},
-			FieldElement{-2114751, -14308128, 23019042, 15765735, -25269683, 6002752, 10183197, -13239326, -16395286, -2176112},
-		},
-	},
-	{
-		{
-			FieldElement{-19025756, 1632005, 13466291, -7995100, -23640451, 16573537, -32013908, -3057104, 22208662, 2000468},
-			FieldElement{3065073, -1412761, -25598674, -361432, -17683065, -5703415, -8164212, 11248527, -3691214, -7414184},
-			FieldElement{10379208, -6045554, 8877319, 1473647, -29291284, -12507580, 16690915, 2553332, -3132688, 16400289},
-		},
-		{
-			FieldElement{15716668, 1254266, -18472690, 7446274, -8448918, 6344164, -22097271, -7285580, 26894937, 9132066},
-			FieldElement{24158887, 12938817, 11085297, -8177598, -28063478, -4457083, -30576463, 64452, -6817084, -2692882},
-			FieldElement{13488534, 7794716, 22236231, 5989356, 25426474, -12578208, 2350710, -3418511, -4688006, 2364226},
-		},
-		{
-			FieldElement{16335052, 9132434, 25640582, 6678888, 1725628, 8517937, -11807024, -11697457, 15445875, -7798101},
-			FieldElement{29004207, -7867081, 28661402, -640412, -12794003, -7943086, 31863255, -4135540, -278050, -15759279},
-			FieldElement{-6122061, -14866665, -28614905, 14569919, -10857999, -3591829, 10343412, -6976290, -29828287, -10815811},
-		},
-		{
-			FieldElement{27081650, 3463984, 14099042, -4517604, 1616303, -6205604, 29542636, 15372179, 17293797, 960709},
-			FieldElement{20263915, 11434237, -5765435, 11236810, 13505955, -10857102, -16111345, 6493122, -19384511, 7639714},
-			FieldElement{-2830798, -14839232, 25403038, -8215196, -8317012, -16173699, 18006287, -16043750, 29994677, -15808121},
-		},
-		{
-			FieldElement{9769828, 5202651, -24157398, -13631392, -28051003, -11561624, -24613141, -13860782, -31184575, 709464},
-			FieldElement{12286395, 13076066, -21775189, -1176622, -25003198, 4057652, -32018128, -8890874, 16102007, 13205847},
-			FieldElement{13733362, 5599946, 10557076, 3195751, -5557991, 8536970, -25540170, 8525972, 10151379, 10394400},
-		},
-		{
-			FieldElement{4024660, -16137551, 22436262, 12276534, -9099015, -2686099, 19698229, 11743039, -33302334, 8934414},
-			FieldElement{-15879800, -4525240, -8580747, -2934061, 14634845, -698278, -9449077, 3137094, -11536886, 11721158},
-			FieldElement{17555939, -5013938, 8268606, 2331751, -22738815, 9761013, 9319229, 8835153, -9205489, -1280045},
-		},
-		{
-			FieldElement{-461409, -7830014, 20614118, 16688288, -7514766, -4807119, 22300304, 505429, 6108462, -6183415},
-			FieldElement{-5070281, 12367917, -30663534, 3234473, 32617080, -8422642, 29880583, -13483331, -26898490, -7867459},
-			FieldElement{-31975283, 5726539, 26934134, 10237677, -3173717, -605053, 24199304, 3795095, 7592688, -14992079},
-		},
-		{
-			FieldElement{21594432, -14964228, 17466408, -4077222, 32537084, 2739898, 6407723, 12018833, -28256052, 4298412},
-			FieldElement{-20650503, -11961496, -27236275, 570498, 3767144, -1717540, 13891942, -1569194, 13717174, 10805743},
-			FieldElement{-14676630, -15644296, 15287174, 11927123, 24177847, -8175568, -796431, 14860609, -26938930, -5863836},
-		},
-	},
-	{
-		{
-			FieldElement{12962541, 5311799, -10060768, 11658280, 18855286, -7954201, 13286263, -12808704, -4381056, 9882022},
-			FieldElement{18512079, 11319350, -20123124, 15090309, 18818594, 5271736, -22727904, 3666879, -23967430, -3299429},
-			FieldElement{-6789020, -3146043, 16192429, 13241070, 15898607, -14206114, -10084880, -6661110, -2403099, 5276065},
-		},
-		{
-			FieldElement{30169808, -5317648, 26306206, -11750859, 27814964, 7069267, 7152851, 3684982, 1449224, 13082861},
-			FieldElement{10342826, 3098505, 2119311, 193222, 25702612, 12233820, 23697382, 15056736, -21016438, -8202000},
-			FieldElement{-33150110, 3261608, 22745853, 7948688, 19370557, -15177665, -26171976, 6482814, -10300080, -11060101},
-		},
-		{
-			FieldElement{32869458, -5408545, 25609743, 15678670, -10687769, -15471071, 26112421, 2521008, -22664288, 6904815},
-			FieldElement{29506923, 4457497, 3377935, -9796444, -30510046, 12935080, 1561737, 3841096, -29003639, -6657642},
-			FieldElement{10340844, -6630377, -18656632, -2278430, 12621151, -13339055, 30878497, -11824370, -25584551, 5181966},
-		},
-		{
-			FieldElement{25940115, -12658025, 17324188, -10307374, -8671468, 15029094, 24396252, -16450922, -2322852, -12388574},
-			FieldElement{-21765684, 9916823, -1300409, 4079498, -1028346, 11909559, 1782390, 12641087, 20603771, -6561742},
-			FieldElement{-18882287, -11673380, 24849422, 11501709, 13161720, -4768874, 1925523, 11914390, 4662781, 7820689},
-		},
-		{
-			FieldElement{12241050, -425982, 8132691, 9393934, 32846760, -1599620, 29749456, 12172924, 16136752, 15264020},
-			FieldElement{-10349955, -14680563, -8211979, 2330220, -17662549, -14545780, 10658213, 6671822, 19012087, 3772772},
-			FieldElement{3753511, -3421066, 10617074, 2028709, 14841030, -6721664, 28718732, -15762884, 20527771, 12988982},
-		},
-		{
-			FieldElement{-14822485, -5797269, -3707987, 12689773, -898983, -10914866, -24183046, -10564943, 3299665, -12424953},
-			FieldElement{-16777703, -15253301, -9642417, 4978983, 3308785, 8755439, 6943197, 6461331, -25583147, 8991218},
-			FieldElement{-17226263, 1816362, -1673288, -6086439, 31783888, -8175991, -32948145, 7417950, -30242287, 1507265},
-		},
-		{
-			FieldElement{29692663, 6829891, -10498800, 4334896, 20945975, -11906496, -28887608, 8209391, 14606362, -10647073},
-			FieldElement{-3481570, 8707081, 32188102, 5672294, 22096700, 1711240, -33020695, 9761487, 4170404, -2085325},
-			FieldElement{-11587470, 14855945, -4127778, -1531857, -26649089, 15084046, 22186522, 16002000, -14276837, -8400798},
-		},
-		{
-			FieldElement{-4811456, 13761029, -31703877, -2483919, -3312471, 7869047, -7113572, -9620092, 13240845, 10965870},
-			FieldElement{-7742563, -8256762, -14768334, -13656260, -23232383, 12387166, 4498947, 14147411, 29514390, 4302863},
-			FieldElement{-13413405, -12407859, 20757302, -13801832, 14785143, 8976368, -5061276, -2144373, 17846988, -13971927},
-		},
-	},
-	{
-		{
-			FieldElement{-2244452, -754728, -4597030, -1066309, -6247172, 1455299, -21647728, -9214789, -5222701, 12650267},
-			FieldElement{-9906797, -16070310, 21134160, 12198166, -27064575, 708126, 387813, 13770293, -19134326, 10958663},
-			FieldElement{22470984, 12369526, 23446014, -5441109, -21520802, -9698723, -11772496, -11574455, -25083830, 4271862},
-		},
-		{
-			FieldElement{-25169565, -10053642, -19909332, 15361595, -5984358, 2159192, 75375, -4278529, -32526221, 8469673},
-			FieldElement{15854970, 4148314, -8893890, 7259002, 11666551, 13824734, -30531198, 2697372, 24154791, -9460943},
-			FieldElement{15446137, -15806644, 29759747, 14019369, 30811221, -9610191, -31582008, 12840104, 24913809, 9815020},
-		},
-		{
-			FieldElement{-4709286, -5614269, -31841498, -12288893, -14443537, 10799414, -9103676, 13438769, 18735128, 9466238},
-			FieldElement{11933045, 9281483, 5081055, -5183824, -2628162, -4905629, -7727821, -10896103, -22728655, 16199064},
-			FieldElement{14576810, 379472, -26786533, -8317236, -29426508, -10812974, -102766, 1876699, 30801119, 2164795},
-		},
-		{
-			FieldElement{15995086, 3199873, 13672555, 13712240, -19378835, -4647646, -13081610, -15496269, -13492807, 1268052},
-			FieldElement{-10290614, -3659039, -3286592, 10948818, 23037027, 3794475, -3470338, -12600221, -17055369, 3565904},
-			FieldElement{29210088, -9419337, -5919792, -4952785, 10834811, -13327726, -16512102, -10820713, -27162222, -14030531},
-		},
-		{
-			FieldElement{-13161890, 15508588, 16663704, -8156150, -28349942, 9019123, -29183421, -3769423, 2244111, -14001979},
-			FieldElement{-5152875, -3800936, -9306475, -6071583, 16243069, 14684434, -25673088, -16180800, 13491506, 4641841},
-			FieldElement{10813417, 643330, -19188515, -728916, 30292062, -16600078, 27548447, -7721242, 14476989, -12767431},
-		},
-		{
-			FieldElement{10292079, 9984945, 6481436, 8279905, -7251514, 7032743, 27282937, -1644259, -27912810, 12651324},
-			FieldElement{-31185513, -813383, 22271204, 11835308, 10201545, 15351028, 17099662, 3988035, 21721536, -3148940},
-			FieldElement{10202177, -6545839, -31373232, -9574638, -32150642, -8119683, -12906320, 3852694, 13216206, 14842320},
-		},
-		{
-			FieldElement{-15815640, -10601066, -6538952, -7258995, -6984659, -6581778, -31500847, 13765824, -27434397, 9900184},
-			FieldElement{14465505, -13833331, -32133984, -14738873, -27443187, 12990492, 33046193, 15796406, -7051866, -8040114},
-			FieldElement{30924417, -8279620, 6359016, -12816335, 16508377, 9071735, -25488601, 15413635, 9524356, -7018878},
-		},
-		{
-			FieldElement{12274201, -13175547, 32627641, -1785326, 6736625, 13267305, 5237659, -5109483, 15663516, 4035784},
-			FieldElement{-2951309, 8903985, 17349946, 601635, -16432815, -4612556, -13732739, -15889334, -22258478, 4659091},
-			FieldElement{-16916263, -4952973, -30393711, -15158821, 20774812, 15897498, 5736189, 15026997, -2178256, -13455585},
-		},
-	},
-	{
-		{
-			FieldElement{-8858980, -2219056, 28571666, -10155518, -474467, -10105698, -3801496, 278095, 23440562, -290208},
-			FieldElement{10226241, -5928702, 15139956, 120818, -14867693, 5218603, 32937275, 11551483, -16571960, -7442864},
-			FieldElement{17932739, -12437276, -24039557, 10749060, 11316803, 7535897, 22503767, 5561594, -3646624, 3898661},
-		},
-		{
-			FieldElement{7749907, -969567, -16339731, -16464, -25018111, 15122143, -1573531, 7152530, 21831162, 1245233},
-			FieldElement{26958459, -14658026, 4314586, 8346991, -5677764, 11960072, -32589295, -620035, -30402091, -16716212},
-			FieldElement{-12165896, 9166947, 33491384, 13673479, 29787085, 13096535, 6280834, 14587357, -22338025, 13987525},
-		},
-		{
-			FieldElement{-24349909, 7778775, 21116000, 15572597, -4833266, -5357778, -4300898, -5124639, -7469781, -2858068},
-			FieldElement{9681908, -6737123, -31951644, 13591838, -6883821, 386950, 31622781, 6439245, -14581012, 4091397},
-			FieldElement{-8426427, 1470727, -28109679, -1596990, 3978627, -5123623, -19622683, 12092163, 29077877, -14741988},
-		},
-		{
-			FieldElement{5269168, -6859726, -13230211, -8020715, 25932563, 1763552, -5606110, -5505881, -20017847, 2357889},
-			FieldElement{32264008, -15407652, -5387735, -1160093, -2091322, -3946900, 23104804, -12869908, 5727338, 189038},
-			FieldElement{14609123, -8954470, -6000566, -16622781, -14577387, -7743898, -26745169, 10942115, -25888931, -14884697},
-		},
-		{
-			FieldElement{20513500, 5557931, -15604613, 7829531, 26413943, -2019404, -21378968, 7471781, 13913677, -5137875},
-			FieldElement{-25574376, 11967826, 29233242, 12948236, -6754465, 4713227, -8940970, 14059180, 12878652, 8511905},
-			FieldElement{-25656801, 3393631, -2955415, -7075526, -2250709, 9366908, -30223418, 6812974, 5568676, -3127656},
-		},
-		{
-			FieldElement{11630004, 12144454, 2116339, 13606037, 27378885, 15676917, -17408753, -13504373, -14395196, 8070818},
-			FieldElement{27117696, -10007378, -31282771, -5570088, 1127282, 12772488, -29845906, 10483306, -11552749, -1028714},
-			FieldElement{10637467, -5688064, 5674781, 1072708, -26343588, -6982302, -1683975, 9177853, -27493162, 15431203},
-		},
-		{
-			FieldElement{20525145, 10892566, -12742472, 12779443, -29493034, 16150075, -28240519, 14943142, -15056790, -7935931},
-			FieldElement{-30024462, 5626926, -551567, -9981087, 753598, 11981191, 25244767, -3239766, -3356550, 9594024},
-			FieldElement{-23752644, 2636870, -5163910, -10103818, 585134, 7877383, 11345683, -6492290, 13352335, -10977084},
-		},
-		{
-			FieldElement{-1931799, -5407458, 3304649, -12884869, 17015806, -4877091, -29783850, -7752482, -13215537, -319204},
-			FieldElement{20239939, 6607058, 6203985, 3483793, -18386976, -779229, -20723742, 15077870, -22750759, 14523817},
-			FieldElement{27406042, -6041657, 27423596, -4497394, 4996214, 10002360, -28842031, -4545494, -30172742, -4805667},
-		},
-	},
-	{
-		{
-			FieldElement{11374242, 12660715, 17861383, -12540833, 10935568, 1099227, -13886076, -9091740, -27727044, 11358504},
-			FieldElement{-12730809, 10311867, 1510375, 10778093, -2119455, -9145702, 32676003, 11149336, -26123651, 4985768},
-			FieldElement{-19096303, 341147, -6197485, -239033, 15756973, -8796662, -983043, 13794114, -19414307, -15621255},
-		},
-		{
-			FieldElement{6490081, 11940286, 25495923, -7726360, 8668373, -8751316, 3367603, 6970005, -1691065, -9004790},
-			FieldElement{1656497, 13457317, 15370807, 6364910, 13605745, 8362338, -19174622, -5475723, -16796596, -5031438},
-			FieldElement{-22273315, -13524424, -64685, -4334223, -18605636, -10921968, -20571065, -7007978, -99853, -10237333},
-		},
-		{
-			FieldElement{17747465, 10039260, 19368299, -4050591, -20630635, -16041286, 31992683, -15857976, -29260363, -5511971},
-			FieldElement{31932027, -4986141, -19612382, 16366580, 22023614, 88450, 11371999, -3744247, 4882242, -10626905},
-			FieldElement{29796507, 37186, 19818052, 10115756, -11829032, 3352736, 18551198, 3272828, -5190932, -4162409},
-		},
-		{
-			FieldElement{12501286, 4044383, -8612957, -13392385, -32430052, 5136599, -19230378, -3529697, 330070, -3659409},
-			FieldElement{6384877, 2899513, 17807477, 7663917, -2358888, 12363165, 25366522, -8573892, -271295, 12071499},
-			FieldElement{-8365515, -4042521, 25133448, -4517355, -6211027, 2265927, -32769618, 1936675, -5159697, 3829363},
-		},
-		{
-			FieldElement{28425966, -5835433, -577090, -4697198, -14217555, 6870930, 7921550, -6567787, 26333140, 14267664},
-			FieldElement{-11067219, 11871231, 27385719, -10559544, -4585914, -11189312, 10004786, -8709488, -21761224, 8930324},
-			FieldElement{-21197785, -16396035, 25654216, -1725397, 12282012, 11008919, 1541940, 4757911, -26491501, -16408940},
-		},
-		{
-			FieldElement{13537262, -7759490, -20604840, 10961927, -5922820, -13218065, -13156584, 6217254, -15943699, 13814990},
-			FieldElement{-17422573, 15157790, 18705543, 29619, 24409717, -260476, 27361681, 9257833, -1956526, -1776914},
-			FieldElement{-25045300, -10191966, 15366585, 15166509, -13105086, 8423556, -29171540, 12361135, -18685978, 4578290},
-		},
-		{
-			FieldElement{24579768, 3711570, 1342322, -11180126, -27005135, 14124956, -22544529, 14074919, 21964432, 8235257},
-			FieldElement{-6528613, -2411497, 9442966, -5925588, 12025640, -1487420, -2981514, -1669206, 13006806, 2355433},
-			FieldElement{-16304899, -13605259, -6632427, -5142349, 16974359, -10911083, 27202044, 1719366, 1141648, -12796236},
-		},
-		{
-			FieldElement{-12863944, -13219986, -8318266, -11018091, -6810145, -4843894, 13475066, -3133972, 32674895, 13715045},
-			FieldElement{11423335, -5468059, 32344216, 8962751, 24989809, 9241752, -13265253, 16086212, -28740881, -15642093},
-			FieldElement{-1409668, 12530728, -6368726, 10847387, 19531186, -14132160, -11709148, 7791794, -27245943, 4383347},
-		},
-	},
-	{
-		{
-			FieldElement{-28970898, 5271447, -1266009, -9736989, -12455236, 16732599, -4862407, -4906449, 27193557, 6245191},
-			FieldElement{-15193956, 5362278, -1783893, 2695834, 4960227, 12840725, 23061898, 3260492, 22510453, 8577507},
-			FieldElement{-12632451, 11257346, -32692994, 13548177, -721004, 10879011, 31168030, 13952092, -29571492, -3635906},
-		},
-		{
-			FieldElement{3877321, -9572739, 32416692, 5405324, -11004407, -13656635, 3759769, 11935320, 5611860, 8164018},
-			FieldElement{-16275802, 14667797, 15906460, 12155291, -22111149, -9039718, 32003002, -8832289, 5773085, -8422109},
-			FieldElement{-23788118, -8254300, 1950875, 8937633, 18686727, 16459170, -905725, 12376320, 31632953, 190926},
-		},
-		{
-			FieldElement{-24593607, -16138885, -8423991, 13378746, 14162407, 6901328, -8288749, 4508564, -25341555, -3627528},
-			FieldElement{8884438, -5884009, 6023974, 10104341, -6881569, -4941533, 18722941, -14786005, -1672488, 827625},
-			FieldElement{-32720583, -16289296, -32503547, 7101210, 13354605, 2659080, -1800575, -14108036, -24878478, 1541286},
-		},
-		{
-			FieldElement{2901347, -1117687, 3880376, -10059388, -17620940, -3612781, -21802117, -3567481, 20456845, -1885033},
-			FieldElement{27019610, 12299467, -13658288, -1603234, -12861660, -4861471, -19540150, -5016058, 29439641, 15138866},
-			FieldElement{21536104, -6626420, -32447818, -10690208, -22408077, 5175814, -5420040, -16361163, 7779328, 109896},
-		},
-		{
-			FieldElement{30279744, 14648750, -8044871, 6425558, 13639621, -743509, 28698390, 12180118, 23177719, -554075},
-			FieldElement{26572847, 3405927, -31701700, 12890905, -19265668, 5335866, -6493768, 2378492, 4439158, -13279347},
-			FieldElement{-22716706, 3489070, -9225266, -332753, 18875722, -1140095, 14819434, -12731527, -17717757, -5461437},
-		},
-		{
-			FieldElement{-5056483, 16566551, 15953661, 3767752, -10436499, 15627060, -820954, 2177225, 8550082, -15114165},
-			FieldElement{-18473302, 16596775, -381660, 15663611, 22860960, 15585581, -27844109, -3582739, -23260460, -8428588},
-			FieldElement{-32480551, 15707275, -8205912, -5652081, 29464558, 2713815, -22725137, 15860482, -21902570, 1494193},
-		},
-		{
-			FieldElement{-19562091, -14087393, -25583872, -9299552, 13127842, 759709, 21923482, 16529112, 8742704, 12967017},
-			FieldElement{-28464899, 1553205, 32536856, -10473729, -24691605, -406174, -8914625, -2933896, -29903758, 15553883},
-			FieldElement{21877909, 3230008, 9881174, 10539357, -4797115, 2841332, 11543572, 14513274, 19375923, -12647961},
-		},
-		{
-			FieldElement{8832269, -14495485, 13253511, 5137575, 5037871, 4078777, 24880818, -6222716, 2862653, 9455043},
-			FieldElement{29306751, 5123106, 20245049, -14149889, 9592566, 8447059, -2077124, -2990080, 15511449, 4789663},
-			FieldElement{-20679756, 7004547, 8824831, -9434977, -4045704, -3750736, -5754762, 108893, 23513200, 16652362},
-		},
-	},
-	{
-		{
-			FieldElement{-33256173, 4144782, -4476029, -6579123, 10770039, -7155542, -6650416, -12936300, -18319198, 10212860},
-			FieldElement{2756081, 8598110, 7383731, -6859892, 22312759, -1105012, 21179801, 2600940, -9988298, -12506466},
-			FieldElement{-24645692, 13317462, -30449259, -15653928, 21365574, -10869657, 11344424, 864440, -2499677, -16710063},
-		},
-		{
-			FieldElement{-26432803, 6148329, -17184412, -14474154, 18782929, -275997, -22561534, 211300, 2719757, 4940997},
-			FieldElement{-1323882, 3911313, -6948744, 14759765, -30027150, 7851207, 21690126, 8518463, 26699843, 5276295},
-			FieldElement{-13149873, -6429067, 9396249, 365013, 24703301, -10488939, 1321586, 149635, -15452774, 7159369},
-		},
-		{
-			FieldElement{9987780, -3404759, 17507962, 9505530, 9731535, -2165514, 22356009, 8312176, 22477218, -8403385},
-			FieldElement{18155857, -16504990, 19744716, 9006923, 15154154, -10538976, 24256460, -4864995, -22548173, 9334109},
-			FieldElement{2986088, -4911893, 10776628, -3473844, 10620590, -7083203, -21413845, 14253545, -22587149, 536906},
-		},
-		{
-			FieldElement{4377756, 8115836, 24567078, 15495314, 11625074, 13064599, 7390551, 10589625, 10838060, -15420424},
-			FieldElement{-19342404, 867880, 9277171, -3218459, -14431572, -1986443, 19295826, -15796950, 6378260, 699185},
-			FieldElement{7895026, 4057113, -7081772, -13077756, -17886831, -323126, -716039, 15693155, -5045064, -13373962},
-		},
-		{
-			FieldElement{-7737563, -5869402, -14566319, -7406919, 11385654, 13201616, 31730678, -10962840, -3918636, -9669325},
-			FieldElement{10188286, -15770834, -7336361, 13427543, 22223443, 14896287, 30743455, 7116568, -21786507, 5427593},
-			FieldElement{696102, 13206899, 27047647, -10632082, 15285305, -9853179, 10798490, -4578720, 19236243, 12477404},
-		},
-		{
-			FieldElement{-11229439, 11243796, -17054270, -8040865, -788228, -8167967, -3897669, 11180504, -23169516, 7733644},
-			FieldElement{17800790, -14036179, -27000429, -11766671, 23887827, 3149671, 23466177, -10538171, 10322027, 15313801},
-			FieldElement{26246234, 11968874, 32263343, -5468728, 6830755, -13323031, -15794704, -101982, -24449242, 10890804},
-		},
-		{
-			FieldElement{-31365647, 10271363, -12660625, -6267268, 16690207, -13062544, -14982212, 16484931, 25180797, -5334884},
-			FieldElement{-586574, 10376444, -32586414, -11286356, 19801893, 10997610, 2276632, 9482883, 316878, 13820577},
-			FieldElement{-9882808, -4510367, -2115506, 16457136, -11100081, 11674996, 30756178, -7515054, 30696930, -3712849},
-		},
-		{
-			FieldElement{32988917, -9603412, 12499366, 7910787, -10617257, -11931514, -7342816, -9985397, -32349517, 7392473},
-			FieldElement{-8855661, 15927861, 9866406, -3649411, -2396914, -16655781, -30409476, -9134995, 25112947, -2926644},
-			FieldElement{-2504044, -436966, 25621774, -5678772, 15085042, -5479877, -24884878, -13526194, 5537438, -13914319},
-		},
-	},
-	{
-		{
-			FieldElement{-11225584, 2320285, -9584280, 10149187, -33444663, 5808648, -14876251, -1729667, 31234590, 6090599},
-			FieldElement{-9633316, 116426, 26083934, 2897444, -6364437, -2688086, 609721, 15878753, -6970405, -9034768},
-			FieldElement{-27757857, 247744, -15194774, -9002551, 23288161, -10011936, -23869595, 6503646, 20650474, 1804084},
-		},
-		{
-			FieldElement{-27589786, 15456424, 8972517, 8469608, 15640622, 4439847, 3121995, -10329713, 27842616, -202328},
-			FieldElement{-15306973, 2839644, 22530074, 10026331, 4602058, 5048462, 28248656, 5031932, -11375082, 12714369},
-			FieldElement{20807691, -7270825, 29286141, 11421711, -27876523, -13868230, -21227475, 1035546, -19733229, 12796920},
-		},
-		{
-			FieldElement{12076899, -14301286, -8785001, -11848922, -25012791, 16400684, -17591495, -12899438, 3480665, -15182815},
-			FieldElement{-32361549, 5457597, 28548107, 7833186, 7303070, -11953545, -24363064, -15921875, -33374054, 2771025},
-			FieldElement{-21389266, 421932, 26597266, 6860826, 22486084, -6737172, -17137485, -4210226, -24552282, 15673397},
-		},
-		{
-			FieldElement{-20184622, 2338216, 19788685, -9620956, -4001265, -8740893, -20271184, 4733254, 3727144, -12934448},
-			FieldElement{6120119, 814863, -11794402, -622716, 6812205, -15747771, 2019594, 7975683, 31123697, -10958981},
-			FieldElement{30069250, -11435332, 30434654, 2958439, 18399564, -976289, 12296869, 9204260, -16432438, 9648165},
-		},
-		{
-			FieldElement{32705432, -1550977, 30705658, 7451065, -11805606, 9631813, 3305266, 5248604, -26008332, -11377501},
-			FieldElement{17219865, 2375039, -31570947, -5575615, -19459679, 9219903, 294711, 15298639, 2662509, -16297073},
-			FieldElement{-1172927, -7558695, -4366770, -4287744, -21346413, -8434326, 32087529, -1222777, 32247248, -14389861},
-		},
-		{
-			FieldElement{14312628, 1221556, 17395390, -8700143, -4945741, -8684635, -28197744, -9637817, -16027623, -13378845},
-			FieldElement{-1428825, -9678990, -9235681, 6549687, -7383069, -468664, 23046502, 9803137, 17597934, 2346211},
-			FieldElement{18510800, 15337574, 26171504, 981392, -22241552, 7827556, -23491134, -11323352, 3059833, -11782870},
-		},
-		{
-			FieldElement{10141598, 6082907, 17829293, -1947643, 9830092, 13613136, -25556636, -5544586, -33502212, 3592096},
-			FieldElement{33114168, -15889352, -26525686, -13343397, 33076705, 8716171, 1151462, 1521897, -982665, -6837803},
-			FieldElement{-32939165, -4255815, 23947181, -324178, -33072974, -12305637, -16637686, 3891704, 26353178, 693168},
-		},
-		{
-			FieldElement{30374239, 1595580, -16884039, 13186931, 4600344, 406904, 9585294, -400668, 31375464, 14369965},
-			FieldElement{-14370654, -7772529, 1510301, 6434173, -18784789, -6262728, 32732230, -13108839, 17901441, 16011505},
-			FieldElement{18171223, -11934626, -12500402, 15197122, -11038147, -15230035, -19172240, -16046376, 8764035, 12309598},
-		},
-	},
-	{
-		{
-			FieldElement{5975908, -5243188, -19459362, -9681747, -11541277, 14015782, -23665757, 1228319, 17544096, -10593782},
-			FieldElement{5811932, -1715293, 3442887, -2269310, -18367348, -8359541, -18044043, -15410127, -5565381, 12348900},
-			FieldElement{-31399660, 11407555, 25755363, 6891399, -3256938, 14872274, -24849353, 8141295, -10632534, -585479},
-		},
-		{
-			FieldElement{-12675304, 694026, -5076145, 13300344, 14015258, -14451394, -9698672, -11329050, 30944593, 1130208},
-			FieldElement{8247766, -6710942, -26562381, -7709309, -14401939, -14648910, 4652152, 2488540, 23550156, -271232},
-			FieldElement{17294316, -3788438, 7026748, 15626851, 22990044, 113481, 2267737, -5908146, -408818, -137719},
-		},
-		{
-			FieldElement{16091085, -16253926, 18599252, 7340678, 2137637, -1221657, -3364161, 14550936, 3260525, -7166271},
-			FieldElement{-4910104, -13332887, 18550887, 10864893, -16459325, -7291596, -23028869, -13204905, -12748722, 2701326},
-			FieldElement{-8574695, 16099415, 4629974, -16340524, -20786213, -6005432, -10018363, 9276971, 11329923, 1862132},
-		},
-		{
-			FieldElement{14763076, -15903608, -30918270, 3689867, 3511892, 10313526, -21951088, 12219231, -9037963, -940300},
-			FieldElement{8894987, -3446094, 6150753, 3013931, 301220, 15693451, -31981216, -2909717, -15438168, 11595570},
-			FieldElement{15214962, 3537601, -26238722, -14058872, 4418657, -15230761, 13947276, 10730794, -13489462, -4363670},
-		},
-		{
-			FieldElement{-2538306, 7682793, 32759013, 263109, -29984731, -7955452, -22332124, -10188635, 977108, 699994},
-			FieldElement{-12466472, 4195084, -9211532, 550904, -15565337, 12917920, 19118110, -439841, -30534533, -14337913},
-			FieldElement{31788461, -14507657, 4799989, 7372237, 8808585, -14747943, 9408237, -10051775, 12493932, -5409317},
-		},
-		{
-			FieldElement{-25680606, 5260744, -19235809, -6284470, -3695942, 16566087, 27218280, 2607121, 29375955, 6024730},
-			FieldElement{842132, -2794693, -4763381, -8722815, 26332018, -12405641, 11831880, 6985184, -9940361, 2854096},
-			FieldElement{-4847262, -7969331, 2516242, -5847713, 9695691, -7221186, 16512645, 960770, 12121869, 16648078},
-		},
-		{
-			FieldElement{-15218652, 14667096, -13336229, 2013717, 30598287, -464137, -31504922, -7882064, 20237806, 2838411},
-			FieldElement{-19288047, 4453152, 15298546, -16178388, 22115043, -15972604, 12544294, -13470457, 1068881, -12499905},
-			FieldElement{-9558883, -16518835, 33238498, 13506958, 30505848, -1114596, -8486907, -2630053, 12521378, 4845654},
-		},
-		{
-			FieldElement{-28198521, 10744108, -2958380, 10199664, 7759311, -13088600, 3409348, -873400, -6482306, -12885870},
-			FieldElement{-23561822, 6230156, -20382013, 10655314, -24040585, -11621172, 10477734, -1240216, -3113227, 13974498},
-			FieldElement{12966261, 15550616, -32038948, -1615346, 21025980, -629444, 5642325, 7188737, 18895762, 12629579},
-		},
-	},
-	{
-		{
-			FieldElement{14741879, -14946887, 22177208, -11721237, 1279741, 8058600, 11758140, 789443, 32195181, 3895677},
-			FieldElement{10758205, 15755439, -4509950, 9243698, -4879422, 6879879, -2204575, -3566119, -8982069, 4429647},
-			FieldElement{-2453894, 15725973, -20436342, -10410672, -5803908, -11040220, -7135870, -11642895, 18047436, -15281743},
-		},
-		{
-			FieldElement{-25173001, -11307165, 29759956, 11776784, -22262383, -15820455, 10993114, -12850837, -17620701, -9408468},
-			FieldElement{21987233, 700364, -24505048, 14972008, -7774265, -5718395, 32155026, 2581431, -29958985, 8773375},
-			FieldElement{-25568350, 454463, -13211935, 16126715, 25240068, 8594567, 20656846, 12017935, -7874389, -13920155},
-		},
-		{
-			FieldElement{6028182, 6263078, -31011806, -11301710, -818919, 2461772, -31841174, -5468042, -1721788, -2776725},
-			FieldElement{-12278994, 16624277, 987579, -5922598, 32908203, 1248608, 7719845, -4166698, 28408820, 6816612},
-			FieldElement{-10358094, -8237829, 19549651, -12169222, 22082623, 16147817, 20613181, 13982702, -10339570, 5067943},
-		},
-		{
-			FieldElement{-30505967, -3821767, 12074681, 13582412, -19877972, 2443951, -19719286, 12746132, 5331210, -10105944},
-			FieldElement{30528811, 3601899, -1957090, 4619785, -27361822, -15436388, 24180793, -12570394, 27679908, -1648928},
-			FieldElement{9402404, -13957065, 32834043, 10838634, -26580150, -13237195, 26653274, -8685565, 22611444, -12715406},
-		},
-		{
-			FieldElement{22190590, 1118029, 22736441, 15130463, -30460692, -5991321, 19189625, -4648942, 4854859, 6622139},
-			FieldElement{-8310738, -2953450, -8262579, -3388049, -10401731, -271929, 13424426, -3567227, 26404409, 13001963},
-			FieldElement{-31241838, -15415700, -2994250, 8939346, 11562230, -12840670, -26064365, -11621720, -15405155, 11020693},
-		},
-		{
-			FieldElement{1866042, -7949489, -7898649, -10301010, 12483315, 13477547, 3175636, -12424163, 28761762, 1406734},
-			FieldElement{-448555, -1777666, 13018551, 3194501, -9580420, -11161737, 24760585, -4347088, 25577411, -13378680},
-			FieldElement{-24290378, 4759345, -690653, -1852816, 2066747, 10693769, -29595790, 9884936, -9368926, 4745410},
-		},
-		{
-			FieldElement{-9141284, 6049714, -19531061, -4341411, -31260798, 9944276, -15462008, -11311852, 10931924, -11931931},
-			FieldElement{-16561513, 14112680, -8012645, 4817318, -8040464, -11414606, -22853429, 10856641, -20470770, 13434654},
-			FieldElement{22759489, -10073434, -16766264, -1871422, 13637442, -10168091, 1765144, -12654326, 28445307, -5364710},
-		},
-		{
-			FieldElement{29875063, 12493613, 2795536, -3786330, 1710620, 15181182, -10195717, -8788675, 9074234, 1167180},
-			FieldElement{-26205683, 11014233, -9842651, -2635485, -26908120, 7532294, -18716888, -9535498, 3843903, 9367684},
-			FieldElement{-10969595, -6403711, 9591134, 9582310, 11349256, 108879, 16235123, 8601684, -139197, 4242895},
-		},
-	},
-	{
-		{
-			FieldElement{22092954, -13191123, -2042793, -11968512, 32186753, -11517388, -6574341, 2470660, -27417366, 16625501},
-			FieldElement{-11057722, 3042016, 13770083, -9257922, 584236, -544855, -7770857, 2602725, -27351616, 14247413},
-			FieldElement{6314175, -10264892, -32772502, 15957557, -10157730, 168750, -8618807, 14290061, 27108877, -1180880},
-		},
-		{
-			FieldElement{-8586597, -7170966, 13241782, 10960156, -32991015, -13794596, 33547976, -11058889, -27148451, 981874},
-			FieldElement{22833440, 9293594, -32649448, -13618667, -9136966, 14756819, -22928859, -13970780, -10479804, -16197962},
-			FieldElement{-7768587, 3326786, -28111797, 10783824, 19178761, 14905060, 22680049, 13906969, -15933690, 3797899},
-		},
-		{
-			FieldElement{21721356, -4212746, -12206123, 9310182, -3882239, -13653110, 23740224, -2709232, 20491983, -8042152},
-			FieldElement{9209270, -15135055, -13256557, -6167798, -731016, 15289673, 25947805, 15286587, 30997318, -6703063},
-			FieldElement{7392032, 16618386, 23946583, -8039892, -13265164, -1533858, -14197445, -2321576, 17649998, -250080},
-		},
-		{
-			FieldElement{-9301088, -14193827, 30609526, -3049543, -25175069, -1283752, -15241566, -9525724, -2233253, 7662146},
-			FieldElement{-17558673, 1763594, -33114336, 15908610, -30040870, -12174295, 7335080, -8472199, -3174674, 3440183},
-			FieldElement{-19889700, -5977008, -24111293, -9688870, 10799743, -16571957, 40450, -4431835, 4862400, 1133},
-		},
-		{
-			FieldElement{-32856209, -7873957, -5422389, 14860950, -16319031, 7956142, 7258061, 311861, -30594991, -7379421},
-			FieldElement{-3773428, -1565936, 28985340, 7499440, 24445838, 9325937, 29727763, 16527196, 18278453, 15405622},
-			FieldElement{-4381906, 8508652, -19898366, -3674424, -5984453, 15149970, -13313598, 843523, -21875062, 13626197},
-		},
-		{
-			FieldElement{2281448, -13487055, -10915418, -2609910, 1879358, 16164207, -10783882, 3953792, 13340839, 15928663},
-			FieldElement{31727126, -7179855, -18437503, -8283652, 2875793, -16390330, -25269894, -7014826, -23452306, 5964753},
-			FieldElement{4100420, -5959452, -17179337, 6017714, -18705837, 12227141, -26684835, 11344144, 2538215, -7570755},
-		},
-		{
-			FieldElement{-9433605, 6123113, 11159803, -2156608, 30016280, 14966241, -20474983, 1485421, -629256, -15958862},
-			FieldElement{-26804558, 4260919, 11851389, 9658551, -32017107, 16367492, -20205425, -13191288, 11659922, -11115118},
-			FieldElement{26180396, 10015009, -30844224, -8581293, 5418197, 9480663, 2231568, -10170080, 33100372, -1306171},
-		},
-		{
-			FieldElement{15121113, -5201871, -10389905, 15427821, -27509937, -15992507, 21670947, 4486675, -5931810, -14466380},
-			FieldElement{16166486, -9483733, -11104130, 6023908, -31926798, -1364923, 2340060, -16254968, -10735770, -10039824},
-			FieldElement{28042865, -3557089, -12126526, 12259706, -3717498, -6945899, 6766453, -8689599, 18036436, 5803270},
-		},
-	},
-	{
-		{
-			FieldElement{-817581, 6763912, 11803561, 1585585, 10958447, -2671165, 23855391, 4598332, -6159431, -14117438},
-			FieldElement{-31031306, -14256194, 17332029, -2383520, 31312682, -5967183, 696309, 50292, -20095739, 11763584},
-			FieldElement{-594563, -2514283, -32234153, 12643980, 12650761, 14811489, 665117, -12613632, -19773211, -10713562},
-		},
-		{
-			FieldElement{30464590, -11262872, -4127476, -12734478, 19835327, -7105613, -24396175, 2075773, -17020157, 992471},
-			FieldElement{18357185, -6994433, 7766382, 16342475, -29324918, 411174, 14578841, 8080033, -11574335, -10601610},
-			FieldElement{19598397, 10334610, 12555054, 2555664, 18821899, -10339780, 21873263, 16014234, 26224780, 16452269},
-		},
-		{
-			FieldElement{-30223925, 5145196, 5944548, 16385966, 3976735, 2009897, -11377804, -7618186, -20533829, 3698650},
-			FieldElement{14187449, 3448569, -10636236, -10810935, -22663880, -3433596, 7268410, -10890444, 27394301, 12015369},
-			FieldElement{19695761, 16087646, 28032085, 12999827, 6817792, 11427614, 20244189, -1312777, -13259127, -3402461},
-		},
-		{
-			FieldElement{30860103, 12735208, -1888245, -4699734, -16974906, 2256940, -8166013, 12298312, -8550524, -10393462},
-			FieldElement{-5719826, -11245325, -1910649, 15569035, 26642876, -7587760, -5789354, -15118654, -4976164, 12651793},
-			FieldElement{-2848395, 9953421, 11531313, -5282879, 26895123, -12697089, -13118820, -16517902, 9768698, -2533218},
-		},
-		{
-			FieldElement{-24719459, 1894651, -287698, -4704085, 15348719, -8156530, 32767513, 12765450, 4940095, 10678226},
-			FieldElement{18860224, 15980149, -18987240, -1562570, -26233012, -11071856, -7843882, 13944024, -24372348, 16582019},
-			FieldElement{-15504260, 4970268, -29893044, 4175593, -20993212, -2199756, -11704054, 15444560, -11003761, 7989037},
-		},
-		{
-			FieldElement{31490452, 5568061, -2412803, 2182383, -32336847, 4531686, -32078269, 6200206, -19686113, -14800171},
-			FieldElement{-17308668, -15879940, -31522777, -2831, -32887382, 16375549, 8680158, -16371713, 28550068, -6857132},
-			FieldElement{-28126887, -5688091, 16837845, -1820458, -6850681, 12700016, -30039981, 4364038, 1155602, 5988841},
-		},
-		{
-			FieldElement{21890435, -13272907, -12624011, 12154349, -7831873, 15300496, 23148983, -4470481, 24618407, 8283181},
-			FieldElement{-33136107, -10512751, 9975416, 6841041, -31559793, 16356536, 3070187, -7025928, 1466169, 10740210},
-			FieldElement{-1509399, -15488185, -13503385, -10655916, 32799044, 909394, -13938903, -5779719, -32164649, -15327040},
-		},
-		{
-			FieldElement{3960823, -14267803, -28026090, -15918051, -19404858, 13146868, 15567327, 951507, -3260321, -573935},
-			FieldElement{24740841, 5052253, -30094131, 8961361, 25877428, 6165135, -24368180, 14397372, -7380369, -6144105},
-			FieldElement{-28888365, 3510803, -28103278, -1158478, -11238128, -10631454, -15441463, -14453128, -1625486, -6494814},
-		},
-	},
-	{
-		{
-			FieldElement{793299, -9230478, 8836302, -6235707, -27360908, -2369593, 33152843, -4885251, -9906200, -621852},
-			FieldElement{5666233, 525582, 20782575, -8038419, -24538499, 14657740, 16099374, 1468826, -6171428, -15186581},
-			FieldElement{-4859255, -3779343, -2917758, -6748019, 7778750, 11688288, -30404353, -9871238, -1558923, -9863646},
-		},
-		{
-			FieldElement{10896332, -7719704, 824275, 472601, -19460308, 3009587, 25248958, 14783338, -30581476, -15757844},
-			FieldElement{10566929, 12612572, -31944212, 11118703, -12633376, 12362879, 21752402, 8822496, 24003793, 14264025},
-			FieldElement{27713862, -7355973, -11008240, 9227530, 27050101, 2504721, 23886875, -13117525, 13958495, -5732453},
-		},
-		{
-			FieldElement{-23481610, 4867226, -27247128, 3900521, 29838369, -8212291, -31889399, -10041781, 7340521, -15410068},
-			FieldElement{4646514, -8011124, -22766023, -11532654, 23184553, 8566613, 31366726, -1381061, -15066784, -10375192},
-			FieldElement{-17270517, 12723032, -16993061, 14878794, 21619651, -6197576, 27584817, 3093888, -8843694, 3849921},
-		},
-		{
-			FieldElement{-9064912, 2103172, 25561640, -15125738, -5239824, 9582958, 32477045, -9017955, 5002294, -15550259},
-			FieldElement{-12057553, -11177906, 21115585, -13365155, 8808712, -12030708, 16489530, 13378448, -25845716, 12741426},
-			FieldElement{-5946367, 10645103, -30911586, 15390284, -3286982, -7118677, 24306472, 15852464, 28834118, -7646072},
-		},
-		{
-			FieldElement{-17335748, -9107057, -24531279, 9434953, -8472084, -583362, -13090771, 455841, 20461858, 5491305},
-			FieldElement{13669248, -16095482, -12481974, -10203039, -14569770, -11893198, -24995986, 11293807, -28588204, -9421832},
-			FieldElement{28497928, 6272777, -33022994, 14470570, 8906179, -1225630, 18504674, -14165166, 29867745, -8795943},
-		},
-		{
-			FieldElement{-16207023, 13517196, -27799630, -13697798, 24009064, -6373891, -6367600, -13175392, 22853429, -4012011},
-			FieldElement{24191378, 16712145, -13931797, 15217831, 14542237, 1646131, 18603514, -11037887, 12876623, -2112447},
-			FieldElement{17902668, 4518229, -411702, -2829247, 26878217, 5258055, -12860753, 608397, 16031844, 3723494},
-		},
-		{
-			FieldElement{-28632773, 12763728, -20446446, 7577504, 33001348, -13017745, 17558842, -7872890, 23896954, -4314245},
-			FieldElement{-20005381, -12011952, 31520464, 605201, 2543521, 5991821, -2945064, 7229064, -9919646, -8826859},
-			FieldElement{28816045, 298879, -28165016, -15920938, 19000928, -1665890, -12680833, -2949325, -18051778, -2082915},
-		},
-		{
-			FieldElement{16000882, -344896, 3493092, -11447198, -29504595, -13159789, 12577740, 16041268, -19715240, 7847707},
-			FieldElement{10151868, 10572098, 27312476, 7922682, 14825339, 4723128, -32855931, -6519018, -10020567, 3852848},
-			FieldElement{-11430470, 15697596, -21121557, -4420647, 5386314, 15063598, 16514493, -15932110, 29330899, -15076224},
-		},
-	},
-	{
-		{
-			FieldElement{-25499735, -4378794, -15222908, -6901211, 16615731, 2051784, 3303702, 15490, -27548796, 12314391},
-			FieldElement{15683520, -6003043, 18109120, -9980648, 15337968, -5997823, -16717435, 15921866, 16103996, -3731215},
-			FieldElement{-23169824, -10781249, 13588192, -1628807, -3798557, -1074929, -19273607, 5402699, -29815713, -9841101},
-		},
-		{
-			FieldElement{23190676, 2384583, -32714340, 3462154, -29903655, -1529132, -11266856, 8911517, -25205859, 2739713},
-			FieldElement{21374101, -3554250, -33524649, 9874411, 15377179, 11831242, -33529904, 6134907, 4931255, 11987849},
-			FieldElement{-7732, -2978858, -16223486, 7277597, 105524, -322051, -31480539, 13861388, -30076310, 10117930},
-		},
-		{
-			FieldElement{-29501170, -10744872, -26163768, 13051539, -25625564, 5089643, -6325503, 6704079, 12890019, 15728940},
-			FieldElement{-21972360, -11771379, -951059, -4418840, 14704840, 2695116, 903376, -10428139, 12885167, 8311031},
-			FieldElement{-17516482, 5352194, 10384213, -13811658, 7506451, 13453191, 26423267, 4384730, 1888765, -5435404},
-		},
-		{
-			FieldElement{-25817338, -3107312, -13494599, -3182506, 30896459, -13921729, -32251644, -12707869, -19464434, -3340243},
-			FieldElement{-23607977, -2665774, -526091, 4651136, 5765089, 4618330, 6092245, 14845197, 17151279, -9854116},
-			FieldElement{-24830458, -12733720, -15165978, 10367250, -29530908, -265356, 22825805, -7087279, -16866484, 16176525},
-		},
-		{
-			FieldElement{-23583256, 6564961, 20063689, 3798228, -4740178, 7359225, 2006182, -10363426, -28746253, -10197509},
-			FieldElement{-10626600, -4486402, -13320562, -5125317, 3432136, -6393229, 23632037, -1940610, 32808310, 1099883},
-			FieldElement{15030977, 5768825, -27451236, -2887299, -6427378, -15361371, -15277896, -6809350, 2051441, -15225865},
-		},
-		{
-			FieldElement{-3362323, -7239372, 7517890, 9824992, 23555850, 295369, 5148398, -14154188, -22686354, 16633660},
-			FieldElement{4577086, -16752288, 13249841, -15304328, 19958763, -14537274, 18559670, -10759549, 8402478, -9864273},
-			FieldElement{-28406330, -1051581, -26790155, -907698, -17212414, -11030789, 9453451, -14980072, 17983010, 9967138},
-		},
-		{
-			FieldElement{-25762494, 6524722, 26585488, 9969270, 24709298, 1220360, -1677990, 7806337, 17507396, 3651560},
-			FieldElement{-10420457, -4118111, 14584639, 15971087, -15768321, 8861010, 26556809, -5574557, -18553322, -11357135},
-			FieldElement{2839101, 14284142, 4029895, 3472686, 14402957, 12689363, -26642121, 8459447, -5605463, -7621941},
-		},
-		{
-			FieldElement{-4839289, -3535444, 9744961, 2871048, 25113978, 3187018, -25110813, -849066, 17258084, -7977739},
-			FieldElement{18164541, -10595176, -17154882, -1542417, 19237078, -9745295, 23357533, -15217008, 26908270, 12150756},
-			FieldElement{-30264870, -7647865, 5112249, -7036672, -1499807, -6974257, 43168, -5537701, -32302074, 16215819},
-		},
-	},
-	{
-		{
-			FieldElement{-6898905, 9824394, -12304779, -4401089, -31397141, -6276835, 32574489, 12532905, -7503072, -8675347},
-			FieldElement{-27343522, -16515468, -27151524, -10722951, 946346, 16291093, 254968, 7168080, 21676107, -1943028},
-			FieldElement{21260961, -8424752, -16831886, -11920822, -23677961, 3968121, -3651949, -6215466, -3556191, -7913075},
-		},
-		{
-			FieldElement{16544754, 13250366, -16804428, 15546242, -4583003, 12757258, -2462308, -8680336, -18907032, -9662799},
-			FieldElement{-2415239, -15577728, 18312303, 4964443, -15272530, -12653564, 26820651, 16690659, 25459437, -4564609},
-			FieldElement{-25144690, 11425020, 28423002, -11020557, -6144921, -15826224, 9142795, -2391602, -6432418, -1644817},
-		},
-		{
-			FieldElement{-23104652, 6253476, 16964147, -3768872, -25113972, -12296437, -27457225, -16344658, 6335692, 7249989},
-			FieldElement{-30333227, 13979675, 7503222, -12368314, -11956721, -4621693, -30272269, 2682242, 25993170, -12478523},
-			FieldElement{4364628, 5930691, 32304656, -10044554, -8054781, 15091131, 22857016, -10598955, 31820368, 15075278},
-		},
-		{
-			FieldElement{31879134, -8918693, 17258761, 90626, -8041836, -4917709, 24162788, -9650886, -17970238, 12833045},
-			FieldElement{19073683, 14851414, -24403169, -11860168, 7625278, 11091125, -19619190, 2074449, -9413939, 14905377},
-			FieldElement{24483667, -11935567, -2518866, -11547418, -1553130, 15355506, -25282080, 9253129, 27628530, -7555480},
-		},
-		{
-			FieldElement{17597607, 8340603, 19355617, 552187, 26198470, -3176583, 4593324, -9157582, -14110875, 15297016},
-			FieldElement{510886, 14337390, -31785257, 16638632, 6328095, 2713355, -20217417, -11864220, 8683221, 2921426},
-			FieldElement{18606791, 11874196, 27155355, -5281482, -24031742, 6265446, -25178240, -1278924, 4674690, 13890525},
-		},
-		{
-			FieldElement{13609624, 13069022, -27372361, -13055908, 24360586, 9592974, 14977157, 9835105, 4389687, 288396},
-			FieldElement{9922506, -519394, 13613107, 5883594, -18758345, -434263, -12304062, 8317628, 23388070, 16052080},
-			FieldElement{12720016, 11937594, -31970060, -5028689, 26900120, 8561328, -20155687, -11632979, -14754271, -10812892},
-		},
-		{
-			FieldElement{15961858, 14150409, 26716931, -665832, -22794328, 13603569, 11829573, 7467844, -28822128, 929275},
-			FieldElement{11038231, -11582396, -27310482, -7316562, -10498527, -16307831, -23479533, -9371869, -21393143, 2465074},
-			FieldElement{20017163, -4323226, 27915242, 1529148, 12396362, 15675764, 13817261, -9658066, 2463391, -4622140},
-		},
-		{
-			FieldElement{-16358878, -12663911, -12065183, 4996454, -1256422, 1073572, 9583558, 12851107, 4003896, 12673717},
-			FieldElement{-1731589, -15155870, -3262930, 16143082, 19294135, 13385325, 14741514, -9103726, 7903886, 2348101},
-			FieldElement{24536016, -16515207, 12715592, -3862155, 1511293, 10047386, -3842346, -7129159, -28377538, 10048127},
-		},
-	},
-	{
-		{
-			FieldElement{-12622226, -6204820, 30718825, 2591312, -10617028, 12192840, 18873298, -7297090, -32297756, 15221632},
-			FieldElement{-26478122, -11103864, 11546244, -1852483, 9180880, 7656409, -21343950, 2095755, 29769758, 6593415},
-			FieldElement{-31994208, -2907461, 4176912, 3264766, 12538965, -868111, 26312345, -6118678, 30958054, 8292160},
-		},
-		{
-			FieldElement{31429822, -13959116, 29173532, 15632448, 12174511, -2760094, 32808831, 3977186, 26143136, -3148876},
-			FieldElement{22648901, 1402143, -22799984, 13746059, 7936347, 365344, -8668633, -1674433, -3758243, -2304625},
-			FieldElement{-15491917, 8012313, -2514730, -12702462, -23965846, -10254029, -1612713, -1535569, -16664475, 8194478},
-		},
-		{
-			FieldElement{27338066, -7507420, -7414224, 10140405, -19026427, -6589889, 27277191, 8855376, 28572286, 3005164},
-			FieldElement{26287124, 4821776, 25476601, -4145903, -3764513, -15788984, -18008582, 1182479, -26094821, -13079595},
-			FieldElement{-7171154, 3178080, 23970071, 6201893, -17195577, -4489192, -21876275, -13982627, 32208683, -1198248},
-		},
-		{
-			FieldElement{-16657702, 2817643, -10286362, 14811298, 6024667, 13349505, -27315504, -10497842, -27672585, -11539858},
-			FieldElement{15941029, -9405932, -21367050, 8062055, 31876073, -238629, -15278393, -1444429, 15397331, -4130193},
-			FieldElement{8934485, -13485467, -23286397, -13423241, -32446090, 14047986, 31170398, -1441021, -27505566, 15087184},
-		},
-		{
-			FieldElement{-18357243, -2156491, 24524913, -16677868, 15520427, -6360776, -15502406, 11461896, 16788528, -5868942},
-			FieldElement{-1947386, 16013773, 21750665, 3714552, -17401782, -16055433, -3770287, -10323320, 31322514, -11615635},
-			FieldElement{21426655, -5650218, -13648287, -5347537, -28812189, -4920970, -18275391, -14621414, 13040862, -12112948},
-		},
-		{
-			FieldElement{11293895, 12478086, -27136401, 15083750, -29307421, 14748872, 14555558, -13417103, 1613711, 4896935},
-			FieldElement{-25894883, 15323294, -8489791, -8057900, 25967126, -13425460, 2825960, -4897045, -23971776, -11267415},
-			FieldElement{-15924766, -5229880, -17443532, 6410664, 3622847, 10243618, 20615400, 12405433, -23753030, -8436416},
-		},
-		{
-			FieldElement{-7091295, 12556208, -20191352, 9025187, -17072479, 4333801, 4378436, 2432030, 23097949, -566018},
-			FieldElement{4565804, -16025654, 20084412, -7842817, 1724999, 189254, 24767264, 10103221, -18512313, 2424778},
-			FieldElement{366633, -11976806, 8173090, -6890119, 30788634, 5745705, -7168678, 1344109, -3642553, 12412659},
-		},
-		{
-			FieldElement{-24001791, 7690286, 14929416, -168257, -32210835, -13412986, 24162697, -15326504, -3141501, 11179385},
-			FieldElement{18289522, -14724954, 8056945, 16430056, -21729724, 7842514, -6001441, -1486897, -18684645, -11443503},
-			FieldElement{476239, 6601091, -6152790, -9723375, 17503545, -4863900, 27672959, 13403813, 11052904, 5219329},
-		},
-	},
-	{
-		{
-			FieldElement{20678546, -8375738, -32671898, 8849123, -5009758, 14574752, 31186971, -3973730, 9014762, -8579056},
-			FieldElement{-13644050, -10350239, -15962508, 5075808, -1514661, -11534600, -33102500, 9160280, 8473550, -3256838},
-			FieldElement{24900749, 14435722, 17209120, -15292541, -22592275, 9878983, -7689309, -16335821, -24568481, 11788948},
-		},
-		{
-			FieldElement{-3118155, -11395194, -13802089, 14797441, 9652448, -6845904, -20037437, 10410733, -24568470, -1458691},
-			FieldElement{-15659161, 16736706, -22467150, 10215878, -9097177, 7563911, 11871841, -12505194, -18513325, 8464118},
-			FieldElement{-23400612, 8348507, -14585951, -861714, -3950205, -6373419, 14325289, 8628612, 33313881, -8370517},
-		},
-		{
-			FieldElement{-20186973, -4967935, 22367356, 5271547, -1097117, -4788838, -24805667, -10236854, -8940735, -5818269},
-			FieldElement{-6948785, -1795212, -32625683, -16021179, 32635414, -7374245, 15989197, -12838188, 28358192, -4253904},
-			FieldElement{-23561781, -2799059, -32351682, -1661963, -9147719, 10429267, -16637684, 4072016, -5351664, 5596589},
-		},
-		{
-			FieldElement{-28236598, -3390048, 12312896, 6213178, 3117142, 16078565, 29266239, 2557221, 1768301, 15373193},
-			FieldElement{-7243358, -3246960, -4593467, -7553353, -127927, -912245, -1090902, -4504991, -24660491, 3442910},
-			FieldElement{-30210571, 5124043, 14181784, 8197961, 18964734, -11939093, 22597931, 7176455, -18585478, 13365930},
-		},
-		{
-			FieldElement{-7877390, -1499958, 8324673, 4690079, 6261860, 890446, 24538107, -8570186, -9689599, -3031667},
-			FieldElement{25008904, -10771599, -4305031, -9638010, 16265036, 15721635, 683793, -11823784, 15723479, -15163481},
-			FieldElement{-9660625, 12374379, -27006999, -7026148, -7724114, -12314514, 11879682, 5400171, 519526, -1235876},
-		},
-		{
-			FieldElement{22258397, -16332233, -7869817, 14613016, -22520255, -2950923, -20353881, 7315967, 16648397, 7605640},
-			FieldElement{-8081308, -8464597, -8223311, 9719710, 19259459, -15348212, 23994942, -5281555, -9468848, 4763278},
-			FieldElement{-21699244, 9220969, -15730624, 1084137, -25476107, -2852390, 31088447, -7764523, -11356529, 728112},
-		},
-		{
-			FieldElement{26047220, -11751471, -6900323, -16521798, 24092068, 9158119, -4273545, -12555558, -29365436, -5498272},
-			FieldElement{17510331, -322857, 5854289, 8403524, 17133918, -3112612, -28111007, 12327945, 10750447, 10014012},
-			FieldElement{-10312768, 3936952, 9156313, -8897683, 16498692, -994647, -27481051, -666732, 3424691, 7540221},
-		},
-		{
-			FieldElement{30322361, -6964110, 11361005, -4143317, 7433304, 4989748, -7071422, -16317219, -9244265, 15258046},
-			FieldElement{13054562, -2779497, 19155474, 469045, -12482797, 4566042, 5631406, 2711395, 1062915, -5136345},
-			FieldElement{-19240248, -11254599, -29509029, -7499965, -5835763, 13005411, -6066489, 12194497, 32960380, 1459310},
-		},
-	},
-	{
-		{
-			FieldElement{19852034, 7027924, 23669353, 10020366, 8586503, -6657907, 394197, -6101885, 18638003, -11174937},
-			FieldElement{31395534, 15098109, 26581030, 8030562, -16527914, -5007134, 9012486, -7584354, -6643087, -5442636},
-			FieldElement{-9192165, -2347377, -1997099, 4529534, 25766844, 607986, -13222, 9677543, -32294889, -6456008},
-		},
-		{
-			FieldElement{-2444496, -149937, 29348902, 8186665, 1873760, 12489863, -30934579, -7839692, -7852844, -8138429},
-			FieldElement{-15236356, -15433509, 7766470, 746860, 26346930, -10221762, -27333451, 10754588, -9431476, 5203576},
-			FieldElement{31834314, 14135496, -770007, 5159118, 20917671, -16768096, -7467973, -7337524, 31809243, 7347066},
-		},
-		{
-			FieldElement{-9606723, -11874240, 20414459, 13033986, 13716524, -11691881, 19797970, -12211255, 15192876, -2087490},
-			FieldElement{-12663563, -2181719, 1168162, -3804809, 26747877, -14138091, 10609330, 12694420, 33473243, -13382104},
-			FieldElement{33184999, 11180355, 15832085, -11385430, -1633671, 225884, 15089336, -11023903, -6135662, 14480053},
-		},
-		{
-			FieldElement{31308717, -5619998, 31030840, -1897099, 15674547, -6582883, 5496208, 13685227, 27595050, 8737275},
-			FieldElement{-20318852, -15150239, 10933843, -16178022, 8335352, -7546022, -31008351, -12610604, 26498114, 66511},
-			FieldElement{22644454, -8761729, -16671776, 4884562, -3105614, -13559366, 30540766, -4286747, -13327787, -7515095},
-		},
-		{
-			FieldElement{-28017847, 9834845, 18617207, -2681312, -3401956, -13307506, 8205540, 13585437, -17127465, 15115439},
-			FieldElement{23711543, -672915, 31206561, -8362711, 6164647, -9709987, -33535882, -1426096, 8236921, 16492939},
-			FieldElement{-23910559, -13515526, -26299483, -4503841, 25005590, -7687270, 19574902, 10071562, 6708380, -6222424},
-		},
-		{
-			FieldElement{2101391, -4930054, 19702731, 2367575, -15427167, 1047675, 5301017, 9328700, 29955601, -11678310},
-			FieldElement{3096359, 9271816, -21620864, -15521844, -14847996, -7592937, -25892142, -12635595, -9917575, 6216608},
-			FieldElement{-32615849, 338663, -25195611, 2510422, -29213566, -13820213, 24822830, -6146567, -26767480, 7525079},
-		},
-		{
-			FieldElement{-23066649, -13985623, 16133487, -7896178, -3389565, 778788, -910336, -2782495, -19386633, 11994101},
-			FieldElement{21691500, -13624626, -641331, -14367021, 3285881, -3483596, -25064666, 9718258, -7477437, 13381418},
-			FieldElement{18445390, -4202236, 14979846, 11622458, -1727110, -3582980, 23111648, -6375247, 28535282, 15779576},
-		},
-		{
-			FieldElement{30098053, 3089662, -9234387, 16662135, -21306940, 11308411, -14068454, 12021730, 9955285, -16303356},
-			FieldElement{9734894, -14576830, -7473633, -9138735, 2060392, 11313496, -18426029, 9924399, 20194861, 13380996},
-			FieldElement{-26378102, -7965207, -22167821, 15789297, -18055342, -6168792, -1984914, 15707771, 26342023, 10146099},
-		},
-	},
-	{
-		{
-			FieldElement{-26016874, -219943, 21339191, -41388, 19745256, -2878700, -29637280, 2227040, 21612326, -545728},
-			FieldElement{-13077387, 1184228, 23562814, -5970442, -20351244, -6348714, 25764461, 12243797, -20856566, 11649658},
-			FieldElement{-10031494, 11262626, 27384172, 2271902, 26947504, -15997771, 39944, 6114064, 33514190, 2333242},
-		},
-		{
-			FieldElement{-21433588, -12421821, 8119782, 7219913, -21830522, -9016134, -6679750, -12670638, 24350578, -13450001},
-			FieldElement{-4116307, -11271533, -23886186, 4843615, -30088339, 690623, -31536088, -10406836, 8317860, 12352766},
-			FieldElement{18200138, -14475911, -33087759, -2696619, -23702521, -9102511, -23552096, -2287550, 20712163, 6719373},
-		},
-		{
-			FieldElement{26656208, 6075253, -7858556, 1886072, -28344043, 4262326, 11117530, -3763210, 26224235, -3297458},
-			FieldElement{-17168938, -14854097, -3395676, -16369877, -19954045, 14050420, 21728352, 9493610, 18620611, -16428628},
-			FieldElement{-13323321, 13325349, 11432106, 5964811, 18609221, 6062965, -5269471, -9725556, -30701573, -16479657},
-		},
-		{
-			FieldElement{-23860538, -11233159, 26961357, 1640861, -32413112, -16737940, 12248509, -5240639, 13735342, 1934062},
-			FieldElement{25089769, 6742589, 17081145, -13406266, 21909293, -16067981, -15136294, -3765346, -21277997, 5473616},
-			FieldElement{31883677, -7961101, 1083432, -11572403, 22828471, 13290673, -7125085, 12469656, 29111212, -5451014},
-		},
-		{
-			FieldElement{24244947, -15050407, -26262976, 2791540, -14997599, 16666678, 24367466, 6388839, -10295587, 452383},
-			FieldElement{-25640782, -3417841, 5217916, 16224624, 19987036, -4082269, -24236251, -5915248, 15766062, 8407814},
-			FieldElement{-20406999, 13990231, 15495425, 16395525, 5377168, 15166495, -8917023, -4388953, -8067909, 2276718},
-		},
-		{
-			FieldElement{30157918, 12924066, -17712050, 9245753, 19895028, 3368142, -23827587, 5096219, 22740376, -7303417},
-			FieldElement{2041139, -14256350, 7783687, 13876377, -25946985, -13352459, 24051124, 13742383, -15637599, 13295222},
-			FieldElement{33338237, -8505733, 12532113, 7977527, 9106186, -1715251, -17720195, -4612972, -4451357, -14669444},
-		},
-		{
-			FieldElement{-20045281, 5454097, -14346548, 6447146, 28862071, 1883651, -2469266, -4141880, 7770569, 9620597},
-			FieldElement{23208068, 7979712, 33071466, 8149229, 1758231, -10834995, 30945528, -1694323, -33502340, -14767970},
-			FieldElement{1439958, -16270480, -1079989, -793782, 4625402, 10647766, -5043801, 1220118, 30494170, -11440799},
-		},
-		{
-			FieldElement{-5037580, -13028295, -2970559, -3061767, 15640974, -6701666, -26739026, 926050, -1684339, -13333647},
-			FieldElement{13908495, -3549272, 30919928, -6273825, -21521863, 7989039, 9021034, 9078865, 3353509, 4033511},
-			FieldElement{-29663431, -15113610, 32259991, -344482, 24295849, -12912123, 23161163, 8839127, 27485041, 7356032},
-		},
-	},
-	{
-		{
-			FieldElement{9661027, 705443, 11980065, -5370154, -1628543, 14661173, -6346142, 2625015, 28431036, -16771834},
-			FieldElement{-23839233, -8311415, -25945511, 7480958, -17681669, -8354183, -22545972, 14150565, 15970762, 4099461},
-			FieldElement{29262576, 16756590, 26350592, -8793563, 8529671, -11208050, 13617293, -9937143, 11465739, 8317062},
-		},
-		{
-			FieldElement{-25493081, -6962928, 32500200, -9419051, -23038724, -2302222, 14898637, 3848455, 20969334, -5157516},
-			FieldElement{-20384450, -14347713, -18336405, 13884722, -33039454, 2842114, -21610826, -3649888, 11177095, 14989547},
-			FieldElement{-24496721, -11716016, 16959896, 2278463, 12066309, 10137771, 13515641, 2581286, -28487508, 9930240},
-		},
-		{
-			FieldElement{-17751622, -2097826, 16544300, -13009300, -15914807, -14949081, 18345767, -13403753, 16291481, -5314038},
-			FieldElement{-33229194, 2553288, 32678213, 9875984, 8534129, 6889387, -9676774, 6957617, 4368891, 9788741},
-			FieldElement{16660756, 7281060, -10830758, 12911820, 20108584, -8101676, -21722536, -8613148, 16250552, -11111103},
-		},
-		{
-			FieldElement{-19765507, 2390526, -16551031, 14161980, 1905286, 6414907, 4689584, 10604807, -30190403, 4782747},
-			FieldElement{-1354539, 14736941, -7367442, -13292886, 7710542, -14155590, -9981571, 4383045, 22546403, 437323},
-			FieldElement{31665577, -12180464, -16186830, 1491339, -18368625, 3294682, 27343084, 2786261, -30633590, -14097016},
-		},
-		{
-			FieldElement{-14467279, -683715, -33374107, 7448552, 19294360, 14334329, -19690631, 2355319, -19284671, -6114373},
-			FieldElement{15121312, -15796162, 6377020, -6031361, -10798111, -12957845, 18952177, 15496498, -29380133, 11754228},
-			FieldElement{-2637277, -13483075, 8488727, -14303896, 12728761, -1622493, 7141596, 11724556, 22761615, -10134141},
-		},
-		{
-			FieldElement{16918416, 11729663, -18083579, 3022987, -31015732, -13339659, -28741185, -12227393, 32851222, 11717399},
-			FieldElement{11166634, 7338049, -6722523, 4531520, -29468672, -7302055, 31474879, 3483633, -1193175, -4030831},
-			FieldElement{-185635, 9921305, 31456609, -13536438, -12013818, 13348923, 33142652, 6546660, -19985279, -3948376},
-		},
-		{
-			FieldElement{-32460596, 11266712, -11197107, -7899103, 31703694, 3855903, -8537131, -12833048, -30772034, -15486313},
-			FieldElement{-18006477, 12709068, 3991746, -6479188, -21491523, -10550425, -31135347, -16049879, 10928917, 3011958},
-			FieldElement{-6957757, -15594337, 31696059, 334240, 29576716, 14796075, -30831056, -12805180, 18008031, 10258577},
-		},
-		{
-			FieldElement{-22448644, 15655569, 7018479, -4410003, -30314266, -1201591, -1853465, 1367120, 25127874, 6671743},
-			FieldElement{29701166, -14373934, -10878120, 9279288, -17568, 13127210, 21382910, 11042292, 25838796, 4642684},
-			FieldElement{-20430234, 14955537, -24126347, 8124619, -5369288, -5990470, 30468147, -13900640, 18423289, 4177476},
-		},
-	},
-}
diff --git a/src/crypto/ed25519/internal/edwards25519/doc.go b/src/crypto/ed25519/internal/edwards25519/doc.go
new file mode 100644
index 0000000000..ff31cd23da
--- /dev/null
+++ b/src/crypto/ed25519/internal/edwards25519/doc.go
@@ -0,0 +1,22 @@
+// Copyright (c) 2021 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 edwards25519 implements group logic for the twisted Edwards curve
+//
+//     -x^2 + y^2 = 1 + -(121665/121666)*x^2*y^2
+//
+// This is better known as the Edwards curve equivalent to Curve25519, and is
+// the curve used by the Ed25519 signature scheme.
+//
+// Most users don't need this package, and should instead use crypto/ed25519 for
+// signatures, golang.org/x/crypto/curve25519 for Diffie-Hellman, or
+// github.com/gtank/ristretto255 for prime order group logic.
+//
+// However, developers who do need to interact with low-level edwards25519
+// operations can use filippo.io/edwards25519, an extended version of this
+// package repackaged as an importable module.
+//
+// (Note that filippo.io/edwards25519 and github.com/gtank/ristretto255 are not
+// maintained by the Go team and are not covered by the Go 1 Compatibility Promise.)
+package edwards25519
diff --git a/src/crypto/ed25519/internal/edwards25519/edwards25519.go b/src/crypto/ed25519/internal/edwards25519/edwards25519.go
index b091481b77..313e6c281c 100644
--- a/src/crypto/ed25519/internal/edwards25519/edwards25519.go
+++ b/src/crypto/ed25519/internal/edwards25519/edwards25519.go
@@ -1,1793 +1,427 @@
-// Copyright 2016 The Go Authors. All rights reserved.
+// Copyright (c) 2017 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 edwards25519
 
-import "encoding/binary"
+import (
+	"crypto/ed25519/internal/edwards25519/field"
+	"errors"
+)
 
-// This code is a port of the public domain, “ref10” implementation of ed25519
-// from SUPERCOP.
+// Point types.
 
-// FieldElement represents an element of the field GF(2^255 - 19).  An element
-// t, entries t[0]...t[9], represents the integer t[0]+2^26 t[1]+2^51 t[2]+2^77
-// t[3]+2^102 t[4]+...+2^230 t[9].  Bounds on each t[i] vary depending on
-// context.
-type FieldElement [10]int32
-
-var zero FieldElement
-
-func FeZero(fe *FieldElement) {
-	copy(fe[:], zero[:])
+type projP1xP1 struct {
+	X, Y, Z, T field.Element
 }
 
-func FeOne(fe *FieldElement) {
-	FeZero(fe)
-	fe[0] = 1
+type projP2 struct {
+	X, Y, Z field.Element
 }
 
-func FeAdd(dst, a, b *FieldElement) {
-	dst[0] = a[0] + b[0]
-	dst[1] = a[1] + b[1]
-	dst[2] = a[2] + b[2]
-	dst[3] = a[3] + b[3]
-	dst[4] = a[4] + b[4]
-	dst[5] = a[5] + b[5]
-	dst[6] = a[6] + b[6]
-	dst[7] = a[7] + b[7]
-	dst[8] = a[8] + b[8]
-	dst[9] = a[9] + b[9]
-}
+// Point represents a point on the edwards25519 curve.
+//
+// This type works similarly to math/big.Int, and all arguments and receivers
+// are allowed to alias.
+//
+// The zero value is NOT valid, and it may be used only as a receiver.
+type Point struct {
+	// The point is internally represented in extended coordinates (X, Y, Z, T)
+	// where x = X/Z, y = Y/Z, and xy = T/Z per https://eprint.iacr.org/2008/522.
+	x, y, z, t field.Element
 
-func FeSub(dst, a, b *FieldElement) {
-	dst[0] = a[0] - b[0]
-	dst[1] = a[1] - b[1]
-	dst[2] = a[2] - b[2]
-	dst[3] = a[3] - b[3]
-	dst[4] = a[4] - b[4]
-	dst[5] = a[5] - b[5]
-	dst[6] = a[6] - b[6]
-	dst[7] = a[7] - b[7]
-	dst[8] = a[8] - b[8]
-	dst[9] = a[9] - b[9]
+	// Make the type not comparable (i.e. used with == or as a map key), as
+	// equivalent points can be represented by different Go values.
+	_ incomparable
 }
 
-func FeCopy(dst, src *FieldElement) {
-	copy(dst[:], src[:])
-}
+type incomparable [0]func()
 
-// Replace (f,g) with (g,g) if b == 1;
-// replace (f,g) with (f,g) if b == 0.
-//
-// Preconditions: b in {0,1}.
-func FeCMove(f, g *FieldElement, b int32) {
-	b = -b
-	f[0] ^= b & (f[0] ^ g[0])
-	f[1] ^= b & (f[1] ^ g[1])
-	f[2] ^= b & (f[2] ^ g[2])
-	f[3] ^= b & (f[3] ^ g[3])
-	f[4] ^= b & (f[4] ^ g[4])
-	f[5] ^= b & (f[5] ^ g[5])
-	f[6] ^= b & (f[6] ^ g[6])
-	f[7] ^= b & (f[7] ^ g[7])
-	f[8] ^= b & (f[8] ^ g[8])
-	f[9] ^= b & (f[9] ^ g[9])
+func checkInitialized(points ...*Point) {
+	for _, p := range points {
+		if p.x == (field.Element{}) && p.y == (field.Element{}) {
+			panic("edwards25519: use of uninitialized Point")
+		}
+	}
 }
 
-func load3(in []byte) int64 {
-	var r int64
-	r = int64(in[0])
-	r |= int64(in[1]) << 8
-	r |= int64(in[2]) << 16
-	return r
+type projCached struct {
+	YplusX, YminusX, Z, T2d field.Element
 }
 
-func load4(in []byte) int64 {
-	var r int64
-	r = int64(in[0])
-	r |= int64(in[1]) << 8
-	r |= int64(in[2]) << 16
-	r |= int64(in[3]) << 24
-	return r
+type affineCached struct {
+	YplusX, YminusX, T2d field.Element
 }
 
-func FeFromBytes(dst *FieldElement, src *[32]byte) {
-	h0 := load4(src[:])
-	h1 := load3(src[4:]) << 6
-	h2 := load3(src[7:]) << 5
-	h3 := load3(src[10:]) << 3
-	h4 := load3(src[13:]) << 2
-	h5 := load4(src[16:])
-	h6 := load3(src[20:]) << 7
-	h7 := load3(src[23:]) << 5
-	h8 := load3(src[26:]) << 4
-	h9 := (load3(src[29:]) & 8388607) << 2
-
-	FeCombine(dst, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9)
-}
+// Constructors.
 
-// FeToBytes marshals h to s.
-// Preconditions:
-//   |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
-//
-// Write p=2^255-19; q=floor(h/p).
-// Basic claim: q = floor(2^(-255)(h + 19 2^(-25)h9 + 2^(-1))).
-//
-// Proof:
-//   Have |h|<=p so |q|<=1 so |19^2 2^(-255) q|<1/4.
-//   Also have |h-2^230 h9|<2^230 so |19 2^(-255)(h-2^230 h9)|<1/4.
-//
-//   Write y=2^(-1)-19^2 2^(-255)q-19 2^(-255)(h-2^230 h9).
-//   Then 0<y<1.
-//
-//   Write r=h-pq.
-//   Have 0<=r<=p-1=2^255-20.
-//   Thus 0<=r+19(2^-255)r<r+19(2^-255)2^255<=2^255-1.
-//
-//   Write x=r+19(2^-255)r+y.
-//   Then 0<x<2^255 so floor(2^(-255)x) = 0 so floor(q+2^(-255)x) = q.
-//
-//   Have q+2^(-255)x = 2^(-255)(h + 19 2^(-25) h9 + 2^(-1))
-//   so floor(2^(-255)(h + 19 2^(-25) h9 + 2^(-1))) = q.
-func FeToBytes(s *[32]byte, h *FieldElement) {
-	var carry [10]int32
-
-	q := (19*h[9] + (1 << 24)) >> 25
-	q = (h[0] + q) >> 26
-	q = (h[1] + q) >> 25
-	q = (h[2] + q) >> 26
-	q = (h[3] + q) >> 25
-	q = (h[4] + q) >> 26
-	q = (h[5] + q) >> 25
-	q = (h[6] + q) >> 26
-	q = (h[7] + q) >> 25
-	q = (h[8] + q) >> 26
-	q = (h[9] + q) >> 25
-
-	// Goal: Output h-(2^255-19)q, which is between 0 and 2^255-20.
-	h[0] += 19 * q
-	// Goal: Output h-2^255 q, which is between 0 and 2^255-20.
-
-	carry[0] = h[0] >> 26
-	h[1] += carry[0]
-	h[0] -= carry[0] << 26
-	carry[1] = h[1] >> 25
-	h[2] += carry[1]
-	h[1] -= carry[1] << 25
-	carry[2] = h[2] >> 26
-	h[3] += carry[2]
-	h[2] -= carry[2] << 26
-	carry[3] = h[3] >> 25
-	h[4] += carry[3]
-	h[3] -= carry[3] << 25
-	carry[4] = h[4] >> 26
-	h[5] += carry[4]
-	h[4] -= carry[4] << 26
-	carry[5] = h[5] >> 25
-	h[6] += carry[5]
-	h[5] -= carry[5] << 25
-	carry[6] = h[6] >> 26
-	h[7] += carry[6]
-	h[6] -= carry[6] << 26
-	carry[7] = h[7] >> 25
-	h[8] += carry[7]
-	h[7] -= carry[7] << 25
-	carry[8] = h[8] >> 26
-	h[9] += carry[8]
-	h[8] -= carry[8] << 26
-	carry[9] = h[9] >> 25
-	h[9] -= carry[9] << 25
-	// h10 = carry9
-
-	// Goal: Output h[0]+...+2^255 h10-2^255 q, which is between 0 and 2^255-20.
-	// Have h[0]+...+2^230 h[9] between 0 and 2^255-1;
-	// evidently 2^255 h10-2^255 q = 0.
-	// Goal: Output h[0]+...+2^230 h[9].
-
-	s[0] = byte(h[0] >> 0)
-	s[1] = byte(h[0] >> 8)
-	s[2] = byte(h[0] >> 16)
-	s[3] = byte((h[0] >> 24) | (h[1] << 2))
-	s[4] = byte(h[1] >> 6)
-	s[5] = byte(h[1] >> 14)
-	s[6] = byte((h[1] >> 22) | (h[2] << 3))
-	s[7] = byte(h[2] >> 5)
-	s[8] = byte(h[2] >> 13)
-	s[9] = byte((h[2] >> 21) | (h[3] << 5))
-	s[10] = byte(h[3] >> 3)
-	s[11] = byte(h[3] >> 11)
-	s[12] = byte((h[3] >> 19) | (h[4] << 6))
-	s[13] = byte(h[4] >> 2)
-	s[14] = byte(h[4] >> 10)
-	s[15] = byte(h[4] >> 18)
-	s[16] = byte(h[5] >> 0)
-	s[17] = byte(h[5] >> 8)
-	s[18] = byte(h[5] >> 16)
-	s[19] = byte((h[5] >> 24) | (h[6] << 1))
-	s[20] = byte(h[6] >> 7)
-	s[21] = byte(h[6] >> 15)
-	s[22] = byte((h[6] >> 23) | (h[7] << 3))
-	s[23] = byte(h[7] >> 5)
-	s[24] = byte(h[7] >> 13)
-	s[25] = byte((h[7] >> 21) | (h[8] << 4))
-	s[26] = byte(h[8] >> 4)
-	s[27] = byte(h[8] >> 12)
-	s[28] = byte((h[8] >> 20) | (h[9] << 6))
-	s[29] = byte(h[9] >> 2)
-	s[30] = byte(h[9] >> 10)
-	s[31] = byte(h[9] >> 18)
+func (v *projP2) Zero() *projP2 {
+	v.X.Zero()
+	v.Y.One()
+	v.Z.One()
+	return v
 }
 
-func FeIsNegative(f *FieldElement) byte {
-	var s [32]byte
-	FeToBytes(&s, f)
-	return s[0] & 1
-}
+// identity is the point at infinity.
+var identity, _ = new(Point).SetBytes([]byte{
+	1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})
 
-func FeIsNonZero(f *FieldElement) int32 {
-	var s [32]byte
-	FeToBytes(&s, f)
-	var x uint8
-	for _, b := range s {
-		x |= b
-	}
-	x |= x >> 4
-	x |= x >> 2
-	x |= x >> 1
-	return int32(x & 1)
+// NewIdentityPoint returns a new Point set to the identity.
+func NewIdentityPoint() *Point {
+	return new(Point).Set(identity)
 }
 
-// FeNeg sets h = -f
-//
-// Preconditions:
-//    |f| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
-//
-// Postconditions:
-//    |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
-func FeNeg(h, f *FieldElement) {
-	h[0] = -f[0]
-	h[1] = -f[1]
-	h[2] = -f[2]
-	h[3] = -f[3]
-	h[4] = -f[4]
-	h[5] = -f[5]
-	h[6] = -f[6]
-	h[7] = -f[7]
-	h[8] = -f[8]
-	h[9] = -f[9]
-}
+// generator is the canonical curve basepoint. See TestGenerator for the
+// correspondence of this encoding with the values in RFC 8032.
+var generator, _ = new(Point).SetBytes([]byte{
+	0x58, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
+	0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
+	0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
+	0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66})
 
-func FeCombine(h *FieldElement, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9 int64) {
-	var c0, c1, c2, c3, c4, c5, c6, c7, c8, c9 int64
-
-	/*
-	  |h0| <= (1.1*1.1*2^52*(1+19+19+19+19)+1.1*1.1*2^50*(38+38+38+38+38))
-	    i.e. |h0| <= 1.2*2^59; narrower ranges for h2, h4, h6, h8
-	  |h1| <= (1.1*1.1*2^51*(1+1+19+19+19+19+19+19+19+19))
-	    i.e. |h1| <= 1.5*2^58; narrower ranges for h3, h5, h7, h9
-	*/
-
-	c0 = (h0 + (1 << 25)) >> 26
-	h1 += c0
-	h0 -= c0 << 26
-	c4 = (h4 + (1 << 25)) >> 26
-	h5 += c4
-	h4 -= c4 << 26
-	/* |h0| <= 2^25 */
-	/* |h4| <= 2^25 */
-	/* |h1| <= 1.51*2^58 */
-	/* |h5| <= 1.51*2^58 */
-
-	c1 = (h1 + (1 << 24)) >> 25
-	h2 += c1
-	h1 -= c1 << 25
-	c5 = (h5 + (1 << 24)) >> 25
-	h6 += c5
-	h5 -= c5 << 25
-	/* |h1| <= 2^24; from now on fits into int32 */
-	/* |h5| <= 2^24; from now on fits into int32 */
-	/* |h2| <= 1.21*2^59 */
-	/* |h6| <= 1.21*2^59 */
-
-	c2 = (h2 + (1 << 25)) >> 26
-	h3 += c2
-	h2 -= c2 << 26
-	c6 = (h6 + (1 << 25)) >> 26
-	h7 += c6
-	h6 -= c6 << 26
-	/* |h2| <= 2^25; from now on fits into int32 unchanged */
-	/* |h6| <= 2^25; from now on fits into int32 unchanged */
-	/* |h3| <= 1.51*2^58 */
-	/* |h7| <= 1.51*2^58 */
-
-	c3 = (h3 + (1 << 24)) >> 25
-	h4 += c3
-	h3 -= c3 << 25
-	c7 = (h7 + (1 << 24)) >> 25
-	h8 += c7
-	h7 -= c7 << 25
-	/* |h3| <= 2^24; from now on fits into int32 unchanged */
-	/* |h7| <= 2^24; from now on fits into int32 unchanged */
-	/* |h4| <= 1.52*2^33 */
-	/* |h8| <= 1.52*2^33 */
-
-	c4 = (h4 + (1 << 25)) >> 26
-	h5 += c4
-	h4 -= c4 << 26
-	c8 = (h8 + (1 << 25)) >> 26
-	h9 += c8
-	h8 -= c8 << 26
-	/* |h4| <= 2^25; from now on fits into int32 unchanged */
-	/* |h8| <= 2^25; from now on fits into int32 unchanged */
-	/* |h5| <= 1.01*2^24 */
-	/* |h9| <= 1.51*2^58 */
-
-	c9 = (h9 + (1 << 24)) >> 25
-	h0 += c9 * 19
-	h9 -= c9 << 25
-	/* |h9| <= 2^24; from now on fits into int32 unchanged */
-	/* |h0| <= 1.8*2^37 */
-
-	c0 = (h0 + (1 << 25)) >> 26
-	h1 += c0
-	h0 -= c0 << 26
-	/* |h0| <= 2^25; from now on fits into int32 unchanged */
-	/* |h1| <= 1.01*2^24 */
-
-	h[0] = int32(h0)
-	h[1] = int32(h1)
-	h[2] = int32(h2)
-	h[3] = int32(h3)
-	h[4] = int32(h4)
-	h[5] = int32(h5)
-	h[6] = int32(h6)
-	h[7] = int32(h7)
-	h[8] = int32(h8)
-	h[9] = int32(h9)
+// NewGeneratorPoint returns a new Point set to the canonical generator.
+func NewGeneratorPoint() *Point {
+	return new(Point).Set(generator)
 }
 
-// FeMul calculates h = f * g
-// Can overlap h with f or g.
-//
-// Preconditions:
-//    |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
-//    |g| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
-//
-// Postconditions:
-//    |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
-//
-// Notes on implementation strategy:
-//
-// Using schoolbook multiplication.
-// Karatsuba would save a little in some cost models.
-//
-// Most multiplications by 2 and 19 are 32-bit precomputations;
-// cheaper than 64-bit postcomputations.
-//
-// There is one remaining multiplication by 19 in the carry chain;
-// one *19 precomputation can be merged into this,
-// but the resulting data flow is considerably less clean.
-//
-// There are 12 carries below.
-// 10 of them are 2-way parallelizable and vectorizable.
-// Can get away with 11 carries, but then data flow is much deeper.
-//
-// With tighter constraints on inputs, can squeeze carries into int32.
-func FeMul(h, f, g *FieldElement) {
-	f0 := int64(f[0])
-	f1 := int64(f[1])
-	f2 := int64(f[2])
-	f3 := int64(f[3])
-	f4 := int64(f[4])
-	f5 := int64(f[5])
-	f6 := int64(f[6])
-	f7 := int64(f[7])
-	f8 := int64(f[8])
-	f9 := int64(f[9])
-
-	f1_2 := int64(2 * f[1])
-	f3_2 := int64(2 * f[3])
-	f5_2 := int64(2 * f[5])
-	f7_2 := int64(2 * f[7])
-	f9_2 := int64(2 * f[9])
-
-	g0 := int64(g[0])
-	g1 := int64(g[1])
-	g2 := int64(g[2])
-	g3 := int64(g[3])
-	g4 := int64(g[4])
-	g5 := int64(g[5])
-	g6 := int64(g[6])
-	g7 := int64(g[7])
-	g8 := int64(g[8])
-	g9 := int64(g[9])
-
-	g1_19 := int64(19 * g[1]) /* 1.4*2^29 */
-	g2_19 := int64(19 * g[2]) /* 1.4*2^30; still ok */
-	g3_19 := int64(19 * g[3])
-	g4_19 := int64(19 * g[4])
-	g5_19 := int64(19 * g[5])
-	g6_19 := int64(19 * g[6])
-	g7_19 := int64(19 * g[7])
-	g8_19 := int64(19 * g[8])
-	g9_19 := int64(19 * g[9])
-
-	h0 := f0*g0 + f1_2*g9_19 + f2*g8_19 + f3_2*g7_19 + f4*g6_19 + f5_2*g5_19 + f6*g4_19 + f7_2*g3_19 + f8*g2_19 + f9_2*g1_19
-	h1 := f0*g1 + f1*g0 + f2*g9_19 + f3*g8_19 + f4*g7_19 + f5*g6_19 + f6*g5_19 + f7*g4_19 + f8*g3_19 + f9*g2_19
-	h2 := f0*g2 + f1_2*g1 + f2*g0 + f3_2*g9_19 + f4*g8_19 + f5_2*g7_19 + f6*g6_19 + f7_2*g5_19 + f8*g4_19 + f9_2*g3_19
-	h3 := f0*g3 + f1*g2 + f2*g1 + f3*g0 + f4*g9_19 + f5*g8_19 + f6*g7_19 + f7*g6_19 + f8*g5_19 + f9*g4_19
-	h4 := f0*g4 + f1_2*g3 + f2*g2 + f3_2*g1 + f4*g0 + f5_2*g9_19 + f6*g8_19 + f7_2*g7_19 + f8*g6_19 + f9_2*g5_19
-	h5 := f0*g5 + f1*g4 + f2*g3 + f3*g2 + f4*g1 + f5*g0 + f6*g9_19 + f7*g8_19 + f8*g7_19 + f9*g6_19
-	h6 := f0*g6 + f1_2*g5 + f2*g4 + f3_2*g3 + f4*g2 + f5_2*g1 + f6*g0 + f7_2*g9_19 + f8*g8_19 + f9_2*g7_19
-	h7 := f0*g7 + f1*g6 + f2*g5 + f3*g4 + f4*g3 + f5*g2 + f6*g1 + f7*g0 + f8*g9_19 + f9*g8_19
-	h8 := f0*g8 + f1_2*g7 + f2*g6 + f3_2*g5 + f4*g4 + f5_2*g3 + f6*g2 + f7_2*g1 + f8*g0 + f9_2*g9_19
-	h9 := f0*g9 + f1*g8 + f2*g7 + f3*g6 + f4*g5 + f5*g4 + f6*g3 + f7*g2 + f8*g1 + f9*g0
-
-	FeCombine(h, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9)
+func (v *projCached) Zero() *projCached {
+	v.YplusX.One()
+	v.YminusX.One()
+	v.Z.One()
+	v.T2d.Zero()
+	return v
 }
 
-func feSquare(f *FieldElement) (h0, h1, h2, h3, h4, h5, h6, h7, h8, h9 int64) {
-	f0 := int64(f[0])
-	f1 := int64(f[1])
-	f2 := int64(f[2])
-	f3 := int64(f[3])
-	f4 := int64(f[4])
-	f5 := int64(f[5])
-	f6 := int64(f[6])
-	f7 := int64(f[7])
-	f8 := int64(f[8])
-	f9 := int64(f[9])
-	f0_2 := int64(2 * f[0])
-	f1_2 := int64(2 * f[1])
-	f2_2 := int64(2 * f[2])
-	f3_2 := int64(2 * f[3])
-	f4_2 := int64(2 * f[4])
-	f5_2 := int64(2 * f[5])
-	f6_2 := int64(2 * f[6])
-	f7_2 := int64(2 * f[7])
-	f5_38 := 38 * f5 // 1.31*2^30
-	f6_19 := 19 * f6 // 1.31*2^30
-	f7_38 := 38 * f7 // 1.31*2^30
-	f8_19 := 19 * f8 // 1.31*2^30
-	f9_38 := 38 * f9 // 1.31*2^30
-
-	h0 = f0*f0 + f1_2*f9_38 + f2_2*f8_19 + f3_2*f7_38 + f4_2*f6_19 + f5*f5_38
-	h1 = f0_2*f1 + f2*f9_38 + f3_2*f8_19 + f4*f7_38 + f5_2*f6_19
-	h2 = f0_2*f2 + f1_2*f1 + f3_2*f9_38 + f4_2*f8_19 + f5_2*f7_38 + f6*f6_19
-	h3 = f0_2*f3 + f1_2*f2 + f4*f9_38 + f5_2*f8_19 + f6*f7_38
-	h4 = f0_2*f4 + f1_2*f3_2 + f2*f2 + f5_2*f9_38 + f6_2*f8_19 + f7*f7_38
-	h5 = f0_2*f5 + f1_2*f4 + f2_2*f3 + f6*f9_38 + f7_2*f8_19
-	h6 = f0_2*f6 + f1_2*f5_2 + f2_2*f4 + f3_2*f3 + f7_2*f9_38 + f8*f8_19
-	h7 = f0_2*f7 + f1_2*f6 + f2_2*f5 + f3_2*f4 + f8*f9_38
-	h8 = f0_2*f8 + f1_2*f7_2 + f2_2*f6 + f3_2*f5_2 + f4*f4 + f9*f9_38
-	h9 = f0_2*f9 + f1_2*f8 + f2_2*f7 + f3_2*f6 + f4_2*f5
-
-	return
+func (v *affineCached) Zero() *affineCached {
+	v.YplusX.One()
+	v.YminusX.One()
+	v.T2d.Zero()
+	return v
 }
 
-// FeSquare calculates h = f*f. Can overlap h with f.
-//
-// Preconditions:
-//    |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
-//
-// Postconditions:
-//    |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
-func FeSquare(h, f *FieldElement) {
-	h0, h1, h2, h3, h4, h5, h6, h7, h8, h9 := feSquare(f)
-	FeCombine(h, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9)
+// Assignments.
+
+// Set sets v = u, and returns v.
+func (v *Point) Set(u *Point) *Point {
+	*v = *u
+	return v
 }
 
-// FeSquare2 sets h = 2 * f * f
-//
-// Can overlap h with f.
-//
-// Preconditions:
-//    |f| bounded by 1.65*2^26,1.65*2^25,1.65*2^26,1.65*2^25,etc.
-//
-// Postconditions:
-//    |h| bounded by 1.01*2^25,1.01*2^24,1.01*2^25,1.01*2^24,etc.
-// See fe_mul.c for discussion of implementation strategy.
-func FeSquare2(h, f *FieldElement) {
-	h0, h1, h2, h3, h4, h5, h6, h7, h8, h9 := feSquare(f)
-
-	h0 += h0
-	h1 += h1
-	h2 += h2
-	h3 += h3
-	h4 += h4
-	h5 += h5
-	h6 += h6
-	h7 += h7
-	h8 += h8
-	h9 += h9
-
-	FeCombine(h, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9)
+// Encoding.
+
+// Bytes returns the canonical 32-byte encoding of v, according to RFC 8032,
+// Section 5.1.2.
+func (v *Point) Bytes() []byte {
+	// This function is outlined to make the allocations inline in the caller
+	// rather than happen on the heap.
+	var buf [32]byte
+	return v.bytes(&buf)
 }
 
-func FeInvert(out, z *FieldElement) {
-	var t0, t1, t2, t3 FieldElement
-	var i int
+func (v *Point) bytes(buf *[32]byte) []byte {
+	checkInitialized(v)
 
-	FeSquare(&t0, z)        // 2^1
-	FeSquare(&t1, &t0)      // 2^2
-	for i = 1; i < 2; i++ { // 2^3
-		FeSquare(&t1, &t1)
-	}
-	FeMul(&t1, z, &t1)      // 2^3 + 2^0
-	FeMul(&t0, &t0, &t1)    // 2^3 + 2^1 + 2^0
-	FeSquare(&t2, &t0)      // 2^4 + 2^2 + 2^1
-	FeMul(&t1, &t1, &t2)    // 2^4 + 2^3 + 2^2 + 2^1 + 2^0
-	FeSquare(&t2, &t1)      // 5,4,3,2,1
-	for i = 1; i < 5; i++ { // 9,8,7,6,5
-		FeSquare(&t2, &t2)
-	}
-	FeMul(&t1, &t2, &t1)     // 9,8,7,6,5,4,3,2,1,0
-	FeSquare(&t2, &t1)       // 10..1
-	for i = 1; i < 10; i++ { // 19..10
-		FeSquare(&t2, &t2)
-	}
-	FeMul(&t2, &t2, &t1)     // 19..0
-	FeSquare(&t3, &t2)       // 20..1
-	for i = 1; i < 20; i++ { // 39..20
-		FeSquare(&t3, &t3)
-	}
-	FeMul(&t2, &t3, &t2)     // 39..0
-	FeSquare(&t2, &t2)       // 40..1
-	for i = 1; i < 10; i++ { // 49..10
-		FeSquare(&t2, &t2)
-	}
-	FeMul(&t1, &t2, &t1)     // 49..0
-	FeSquare(&t2, &t1)       // 50..1
-	for i = 1; i < 50; i++ { // 99..50
-		FeSquare(&t2, &t2)
-	}
-	FeMul(&t2, &t2, &t1)      // 99..0
-	FeSquare(&t3, &t2)        // 100..1
-	for i = 1; i < 100; i++ { // 199..100
-		FeSquare(&t3, &t3)
-	}
-	FeMul(&t2, &t3, &t2)     // 199..0
-	FeSquare(&t2, &t2)       // 200..1
-	for i = 1; i < 50; i++ { // 249..50
-		FeSquare(&t2, &t2)
-	}
-	FeMul(&t1, &t2, &t1)    // 249..0
-	FeSquare(&t1, &t1)      // 250..1
-	for i = 1; i < 5; i++ { // 254..5
-		FeSquare(&t1, &t1)
-	}
-	FeMul(out, &t1, &t0) // 254..5,3,1,0
+	var zInv, x, y field.Element
+	zInv.Invert(&v.z)       // zInv = 1 / Z
+	x.Multiply(&v.x, &zInv) // x = X / Z
+	y.Multiply(&v.y, &zInv) // y = Y / Z
+
+	out := copyFieldElement(buf, &y)
+	out[31] |= byte(x.IsNegative() << 7)
+	return out
 }
 
-func fePow22523(out, z *FieldElement) {
-	var t0, t1, t2 FieldElement
-	var i int
+var feOne = new(field.Element).One()
 
-	FeSquare(&t0, z)
-	for i = 1; i < 1; i++ {
-		FeSquare(&t0, &t0)
-	}
-	FeSquare(&t1, &t0)
-	for i = 1; i < 2; i++ {
-		FeSquare(&t1, &t1)
-	}
-	FeMul(&t1, z, &t1)
-	FeMul(&t0, &t0, &t1)
-	FeSquare(&t0, &t0)
-	for i = 1; i < 1; i++ {
-		FeSquare(&t0, &t0)
-	}
-	FeMul(&t0, &t1, &t0)
-	FeSquare(&t1, &t0)
-	for i = 1; i < 5; i++ {
-		FeSquare(&t1, &t1)
-	}
-	FeMul(&t0, &t1, &t0)
-	FeSquare(&t1, &t0)
-	for i = 1; i < 10; i++ {
-		FeSquare(&t1, &t1)
-	}
-	FeMul(&t1, &t1, &t0)
-	FeSquare(&t2, &t1)
-	for i = 1; i < 20; i++ {
-		FeSquare(&t2, &t2)
-	}
-	FeMul(&t1, &t2, &t1)
-	FeSquare(&t1, &t1)
-	for i = 1; i < 10; i++ {
-		FeSquare(&t1, &t1)
-	}
-	FeMul(&t0, &t1, &t0)
-	FeSquare(&t1, &t0)
-	for i = 1; i < 50; i++ {
-		FeSquare(&t1, &t1)
-	}
-	FeMul(&t1, &t1, &t0)
-	FeSquare(&t2, &t1)
-	for i = 1; i < 100; i++ {
-		FeSquare(&t2, &t2)
-	}
-	FeMul(&t1, &t2, &t1)
-	FeSquare(&t1, &t1)
-	for i = 1; i < 50; i++ {
-		FeSquare(&t1, &t1)
+// SetBytes sets v = x, where x is a 32-byte encoding of v. If x does not
+// represent a valid point on the curve, SetBytes returns nil and an error and
+// the receiver is unchanged. Otherwise, SetBytes returns v.
+//
+// Note that SetBytes accepts all non-canonical encodings of valid points.
+// That is, it follows decoding rules that match most implementations in
+// the ecosystem rather than RFC 8032.
+func (v *Point) SetBytes(x []byte) (*Point, error) {
+	// Specifically, the non-canonical encodings that are accepted are
+	//   1) the ones where the field element is not reduced (see the
+	//      (*field.Element).SetBytes docs) and
+	//   2) the ones where the x-coordinate is zero and the sign bit is set.
+	//
+	// This is consistent with crypto/ed25519/internal/edwards25519. Read more
+	// at https://hdevalence.ca/blog/2020-10-04-its-25519am, specifically the
+	// "Canonical A, R" section.
+
+	if len(x) != 32 {
+		return nil, errors.New("edwards25519: invalid point encoding length")
 	}
-	FeMul(&t0, &t1, &t0)
-	FeSquare(&t0, &t0)
-	for i = 1; i < 2; i++ {
-		FeSquare(&t0, &t0)
+	y := new(field.Element).SetBytes(x)
+
+	// -x² + y² = 1 + dx²y²
+	// x² + dx²y² = x²(dy² + 1) = y² - 1
+	// x² = (y² - 1) / (dy² + 1)
+
+	// u = y² - 1
+	y2 := new(field.Element).Square(y)
+	u := new(field.Element).Subtract(y2, feOne)
+
+	// v = dy² + 1
+	vv := new(field.Element).Multiply(y2, d)
+	vv = vv.Add(vv, feOne)
+
+	// x = +√(u/v)
+	xx, wasSquare := new(field.Element).SqrtRatio(u, vv)
+	if wasSquare == 0 {
+		return nil, errors.New("edwards25519: invalid point encoding")
 	}
-	FeMul(out, &t0, z)
-}
 
-// Group elements are members of the elliptic curve -x^2 + y^2 = 1 + d * x^2 *
-// y^2 where d = -121665/121666.
-//
-// Several representations are used:
-//   ProjectiveGroupElement: (X:Y:Z) satisfying x=X/Z, y=Y/Z
-//   ExtendedGroupElement: (X:Y:Z:T) satisfying x=X/Z, y=Y/Z, XY=ZT
-//   CompletedGroupElement: ((X:Z),(Y:T)) satisfying x=X/Z, y=Y/T
-//   PreComputedGroupElement: (y+x,y-x,2dxy)
-
-type ProjectiveGroupElement struct {
-	X, Y, Z FieldElement
-}
+	// Select the negative square root if the sign bit is set.
+	xxNeg := new(field.Element).Negate(xx)
+	xx = xx.Select(xxNeg, xx, int(x[31]>>7))
 
-type ExtendedGroupElement struct {
-	X, Y, Z, T FieldElement
+	v.x.Set(xx)
+	v.y.Set(y)
+	v.z.One()
+	v.t.Multiply(xx, y) // xy = T / Z
+
+	return v, nil
 }
 
-type CompletedGroupElement struct {
-	X, Y, Z, T FieldElement
+func copyFieldElement(buf *[32]byte, v *field.Element) []byte {
+	copy(buf[:], v.Bytes())
+	return buf[:]
 }
 
-type PreComputedGroupElement struct {
-	yPlusX, yMinusX, xy2d FieldElement
+// Conversions.
+
+func (v *projP2) FromP1xP1(p *projP1xP1) *projP2 {
+	v.X.Multiply(&p.X, &p.T)
+	v.Y.Multiply(&p.Y, &p.Z)
+	v.Z.Multiply(&p.Z, &p.T)
+	return v
 }
 
-type CachedGroupElement struct {
-	yPlusX, yMinusX, Z, T2d FieldElement
+func (v *projP2) FromP3(p *Point) *projP2 {
+	v.X.Set(&p.x)
+	v.Y.Set(&p.y)
+	v.Z.Set(&p.z)
+	return v
 }
 
-func (p *ProjectiveGroupElement) Zero() {
-	FeZero(&p.X)
-	FeOne(&p.Y)
-	FeOne(&p.Z)
+func (v *Point) fromP1xP1(p *projP1xP1) *Point {
+	v.x.Multiply(&p.X, &p.T)
+	v.y.Multiply(&p.Y, &p.Z)
+	v.z.Multiply(&p.Z, &p.T)
+	v.t.Multiply(&p.X, &p.Y)
+	return v
 }
 
-func (p *ProjectiveGroupElement) Double(r *CompletedGroupElement) {
-	var t0 FieldElement
-
-	FeSquare(&r.X, &p.X)
-	FeSquare(&r.Z, &p.Y)
-	FeSquare2(&r.T, &p.Z)
-	FeAdd(&r.Y, &p.X, &p.Y)
-	FeSquare(&t0, &r.Y)
-	FeAdd(&r.Y, &r.Z, &r.X)
-	FeSub(&r.Z, &r.Z, &r.X)
-	FeSub(&r.X, &t0, &r.Y)
-	FeSub(&r.T, &r.T, &r.Z)
+func (v *Point) fromP2(p *projP2) *Point {
+	v.x.Multiply(&p.X, &p.Z)
+	v.y.Multiply(&p.Y, &p.Z)
+	v.z.Square(&p.Z)
+	v.t.Multiply(&p.X, &p.Y)
+	return v
 }
 
-func (p *ProjectiveGroupElement) ToBytes(s *[32]byte) {
-	var recip, x, y FieldElement
+// d is a constant in the curve equation.
+var d = new(field.Element).SetBytes([]byte{
+	0xa3, 0x78, 0x59, 0x13, 0xca, 0x4d, 0xeb, 0x75,
+	0xab, 0xd8, 0x41, 0x41, 0x4d, 0x0a, 0x70, 0x00,
+	0x98, 0xe8, 0x79, 0x77, 0x79, 0x40, 0xc7, 0x8c,
+	0x73, 0xfe, 0x6f, 0x2b, 0xee, 0x6c, 0x03, 0x52})
+var d2 = new(field.Element).Add(d, d)
 
-	FeInvert(&recip, &p.Z)
-	FeMul(&x, &p.X, &recip)
-	FeMul(&y, &p.Y, &recip)
-	FeToBytes(s, &y)
-	s[31] ^= FeIsNegative(&x) << 7
+func (v *projCached) FromP3(p *Point) *projCached {
+	v.YplusX.Add(&p.y, &p.x)
+	v.YminusX.Subtract(&p.y, &p.x)
+	v.Z.Set(&p.z)
+	v.T2d.Multiply(&p.t, d2)
+	return v
 }
 
-func (p *ExtendedGroupElement) Zero() {
-	FeZero(&p.X)
-	FeOne(&p.Y)
-	FeOne(&p.Z)
-	FeZero(&p.T)
-}
+func (v *affineCached) FromP3(p *Point) *affineCached {
+	v.YplusX.Add(&p.y, &p.x)
+	v.YminusX.Subtract(&p.y, &p.x)
+	v.T2d.Multiply(&p.t, d2)
 
-func (p *ExtendedGroupElement) Double(r *CompletedGroupElement) {
-	var q ProjectiveGroupElement
-	p.ToProjective(&q)
-	q.Double(r)
+	var invZ field.Element
+	invZ.Invert(&p.z)
+	v.YplusX.Multiply(&v.YplusX, &invZ)
+	v.YminusX.Multiply(&v.YminusX, &invZ)
+	v.T2d.Multiply(&v.T2d, &invZ)
+	return v
 }
 
-func (p *ExtendedGroupElement) ToCached(r *CachedGroupElement) {
-	FeAdd(&r.yPlusX, &p.Y, &p.X)
-	FeSub(&r.yMinusX, &p.Y, &p.X)
-	FeCopy(&r.Z, &p.Z)
-	FeMul(&r.T2d, &p.T, &d2)
-}
+// (Re)addition and subtraction.
 
-func (p *ExtendedGroupElement) ToProjective(r *ProjectiveGroupElement) {
-	FeCopy(&r.X, &p.X)
-	FeCopy(&r.Y, &p.Y)
-	FeCopy(&r.Z, &p.Z)
+// Add sets v = p + q, and returns v.
+func (v *Point) Add(p, q *Point) *Point {
+	checkInitialized(p, q)
+	qCached := new(projCached).FromP3(q)
+	result := new(projP1xP1).Add(p, qCached)
+	return v.fromP1xP1(result)
 }
 
-func (p *ExtendedGroupElement) ToBytes(s *[32]byte) {
-	var recip, x, y FieldElement
-
-	FeInvert(&recip, &p.Z)
-	FeMul(&x, &p.X, &recip)
-	FeMul(&y, &p.Y, &recip)
-	FeToBytes(s, &y)
-	s[31] ^= FeIsNegative(&x) << 7
+// Subtract sets v = p - q, and returns v.
+func (v *Point) Subtract(p, q *Point) *Point {
+	checkInitialized(p, q)
+	qCached := new(projCached).FromP3(q)
+	result := new(projP1xP1).Sub(p, qCached)
+	return v.fromP1xP1(result)
 }
 
-func (p *ExtendedGroupElement) FromBytes(s *[32]byte) bool {
-	var u, v, v3, vxx, check FieldElement
-
-	FeFromBytes(&p.Y, s)
-	FeOne(&p.Z)
-	FeSquare(&u, &p.Y)
-	FeMul(&v, &u, &d)
-	FeSub(&u, &u, &p.Z) // u = y^2-1
-	FeAdd(&v, &v, &p.Z) // v = dy^2+1
-
-	FeSquare(&v3, &v)
-	FeMul(&v3, &v3, &v) // v3 = v^3
-	FeSquare(&p.X, &v3)
-	FeMul(&p.X, &p.X, &v)
-	FeMul(&p.X, &p.X, &u) // x = uv^7
-
-	fePow22523(&p.X, &p.X) // x = (uv^7)^((q-5)/8)
-	FeMul(&p.X, &p.X, &v3)
-	FeMul(&p.X, &p.X, &u) // x = uv^3(uv^7)^((q-5)/8)
-
-	var tmpX, tmp2 [32]byte
-
-	FeSquare(&vxx, &p.X)
-	FeMul(&vxx, &vxx, &v)
-	FeSub(&check, &vxx, &u) // vx^2-u
-	if FeIsNonZero(&check) == 1 {
-		FeAdd(&check, &vxx, &u) // vx^2+u
-		if FeIsNonZero(&check) == 1 {
-			return false
-		}
-		FeMul(&p.X, &p.X, &SqrtM1)
+func (v *projP1xP1) Add(p *Point, q *projCached) *projP1xP1 {
+	var YplusX, YminusX, PP, MM, TT2d, ZZ2 field.Element
 
-		FeToBytes(&tmpX, &p.X)
-		for i, v := range tmpX {
-			tmp2[31-i] = v
-		}
-	}
+	YplusX.Add(&p.y, &p.x)
+	YminusX.Subtract(&p.y, &p.x)
 
-	if FeIsNegative(&p.X) != (s[31] >> 7) {
-		FeNeg(&p.X, &p.X)
-	}
+	PP.Multiply(&YplusX, &q.YplusX)
+	MM.Multiply(&YminusX, &q.YminusX)
+	TT2d.Multiply(&p.t, &q.T2d)
+	ZZ2.Multiply(&p.z, &q.Z)
 
-	FeMul(&p.T, &p.X, &p.Y)
-	return true
-}
+	ZZ2.Add(&ZZ2, &ZZ2)
 
-func (p *CompletedGroupElement) ToProjective(r *ProjectiveGroupElement) {
-	FeMul(&r.X, &p.X, &p.T)
-	FeMul(&r.Y, &p.Y, &p.Z)
-	FeMul(&r.Z, &p.Z, &p.T)
+	v.X.Subtract(&PP, &MM)
+	v.Y.Add(&PP, &MM)
+	v.Z.Add(&ZZ2, &TT2d)
+	v.T.Subtract(&ZZ2, &TT2d)
+	return v
 }
 
-func (p *CompletedGroupElement) ToExtended(r *ExtendedGroupElement) {
-	FeMul(&r.X, &p.X, &p.T)
-	FeMul(&r.Y, &p.Y, &p.Z)
-	FeMul(&r.Z, &p.Z, &p.T)
-	FeMul(&r.T, &p.X, &p.Y)
-}
+func (v *projP1xP1) Sub(p *Point, q *projCached) *projP1xP1 {
+	var YplusX, YminusX, PP, MM, TT2d, ZZ2 field.Element
 
-func (p *PreComputedGroupElement) Zero() {
-	FeOne(&p.yPlusX)
-	FeOne(&p.yMinusX)
-	FeZero(&p.xy2d)
-}
+	YplusX.Add(&p.y, &p.x)
+	YminusX.Subtract(&p.y, &p.x)
 
-func geAdd(r *CompletedGroupElement, p *ExtendedGroupElement, q *CachedGroupElement) {
-	var t0 FieldElement
-
-	FeAdd(&r.X, &p.Y, &p.X)
-	FeSub(&r.Y, &p.Y, &p.X)
-	FeMul(&r.Z, &r.X, &q.yPlusX)
-	FeMul(&r.Y, &r.Y, &q.yMinusX)
-	FeMul(&r.T, &q.T2d, &p.T)
-	FeMul(&r.X, &p.Z, &q.Z)
-	FeAdd(&t0, &r.X, &r.X)
-	FeSub(&r.X, &r.Z, &r.Y)
-	FeAdd(&r.Y, &r.Z, &r.Y)
-	FeAdd(&r.Z, &t0, &r.T)
-	FeSub(&r.T, &t0, &r.T)
-}
+	PP.Multiply(&YplusX, &q.YminusX) // flipped sign
+	MM.Multiply(&YminusX, &q.YplusX) // flipped sign
+	TT2d.Multiply(&p.t, &q.T2d)
+	ZZ2.Multiply(&p.z, &q.Z)
 
-func geSub(r *CompletedGroupElement, p *ExtendedGroupElement, q *CachedGroupElement) {
-	var t0 FieldElement
-
-	FeAdd(&r.X, &p.Y, &p.X)
-	FeSub(&r.Y, &p.Y, &p.X)
-	FeMul(&r.Z, &r.X, &q.yMinusX)
-	FeMul(&r.Y, &r.Y, &q.yPlusX)
-	FeMul(&r.T, &q.T2d, &p.T)
-	FeMul(&r.X, &p.Z, &q.Z)
-	FeAdd(&t0, &r.X, &r.X)
-	FeSub(&r.X, &r.Z, &r.Y)
-	FeAdd(&r.Y, &r.Z, &r.Y)
-	FeSub(&r.Z, &t0, &r.T)
-	FeAdd(&r.T, &t0, &r.T)
-}
+	ZZ2.Add(&ZZ2, &ZZ2)
 
-func geMixedAdd(r *CompletedGroupElement, p *ExtendedGroupElement, q *PreComputedGroupElement) {
-	var t0 FieldElement
-
-	FeAdd(&r.X, &p.Y, &p.X)
-	FeSub(&r.Y, &p.Y, &p.X)
-	FeMul(&r.Z, &r.X, &q.yPlusX)
-	FeMul(&r.Y, &r.Y, &q.yMinusX)
-	FeMul(&r.T, &q.xy2d, &p.T)
-	FeAdd(&t0, &p.Z, &p.Z)
-	FeSub(&r.X, &r.Z, &r.Y)
-	FeAdd(&r.Y, &r.Z, &r.Y)
-	FeAdd(&r.Z, &t0, &r.T)
-	FeSub(&r.T, &t0, &r.T)
+	v.X.Subtract(&PP, &MM)
+	v.Y.Add(&PP, &MM)
+	v.Z.Subtract(&ZZ2, &TT2d) // flipped sign
+	v.T.Add(&ZZ2, &TT2d)      // flipped sign
+	return v
 }
 
-func geMixedSub(r *CompletedGroupElement, p *ExtendedGroupElement, q *PreComputedGroupElement) {
-	var t0 FieldElement
-
-	FeAdd(&r.X, &p.Y, &p.X)
-	FeSub(&r.Y, &p.Y, &p.X)
-	FeMul(&r.Z, &r.X, &q.yMinusX)
-	FeMul(&r.Y, &r.Y, &q.yPlusX)
-	FeMul(&r.T, &q.xy2d, &p.T)
-	FeAdd(&t0, &p.Z, &p.Z)
-	FeSub(&r.X, &r.Z, &r.Y)
-	FeAdd(&r.Y, &r.Z, &r.Y)
-	FeSub(&r.Z, &t0, &r.T)
-	FeAdd(&r.T, &t0, &r.T)
-}
+func (v *projP1xP1) AddAffine(p *Point, q *affineCached) *projP1xP1 {
+	var YplusX, YminusX, PP, MM, TT2d, Z2 field.Element
 
-func slide(r *[256]int8, a *[32]byte) {
-	for i := range r {
-		r[i] = int8(1 & (a[i>>3] >> uint(i&7)))
-	}
+	YplusX.Add(&p.y, &p.x)
+	YminusX.Subtract(&p.y, &p.x)
 
-	for i := range r {
-		if r[i] != 0 {
-			for b := 1; b <= 6 && i+b < 256; b++ {
-				if r[i+b] != 0 {
-					if r[i]+(r[i+b]<<uint(b)) <= 15 {
-						r[i] += r[i+b] << uint(b)
-						r[i+b] = 0
-					} else if r[i]-(r[i+b]<<uint(b)) >= -15 {
-						r[i] -= r[i+b] << uint(b)
-						for k := i + b; k < 256; k++ {
-							if r[k] == 0 {
-								r[k] = 1
-								break
-							}
-							r[k] = 0
-						}
-					} else {
-						break
-					}
-				}
-			}
-		}
-	}
-}
+	PP.Multiply(&YplusX, &q.YplusX)
+	MM.Multiply(&YminusX, &q.YminusX)
+	TT2d.Multiply(&p.t, &q.T2d)
 
-// GeDoubleScalarMultVartime sets r = a*A + b*B
-// where a = a[0]+256*a[1]+...+256^31 a[31].
-// and b = b[0]+256*b[1]+...+256^31 b[31].
-// B is the Ed25519 base point (x,4/5) with x positive.
-func GeDoubleScalarMultVartime(r *ProjectiveGroupElement, a *[32]byte, A *ExtendedGroupElement, b *[32]byte) {
-	var aSlide, bSlide [256]int8
-	var Ai [8]CachedGroupElement // A,3A,5A,7A,9A,11A,13A,15A
-	var t CompletedGroupElement
-	var u, A2 ExtendedGroupElement
-	var i int
-
-	slide(&aSlide, a)
-	slide(&bSlide, b)
-
-	A.ToCached(&Ai[0])
-	A.Double(&t)
-	t.ToExtended(&A2)
-
-	for i := 0; i < 7; i++ {
-		geAdd(&t, &A2, &Ai[i])
-		t.ToExtended(&u)
-		u.ToCached(&Ai[i+1])
-	}
+	Z2.Add(&p.z, &p.z)
 
-	r.Zero()
+	v.X.Subtract(&PP, &MM)
+	v.Y.Add(&PP, &MM)
+	v.Z.Add(&Z2, &TT2d)
+	v.T.Subtract(&Z2, &TT2d)
+	return v
+}
 
-	for i = 255; i >= 0; i-- {
-		if aSlide[i] != 0 || bSlide[i] != 0 {
-			break
-		}
-	}
+func (v *projP1xP1) SubAffine(p *Point, q *affineCached) *projP1xP1 {
+	var YplusX, YminusX, PP, MM, TT2d, Z2 field.Element
 
-	for ; i >= 0; i-- {
-		r.Double(&t)
+	YplusX.Add(&p.y, &p.x)
+	YminusX.Subtract(&p.y, &p.x)
 
-		if aSlide[i] > 0 {
-			t.ToExtended(&u)
-			geAdd(&t, &u, &Ai[aSlide[i]/2])
-		} else if aSlide[i] < 0 {
-			t.ToExtended(&u)
-			geSub(&t, &u, &Ai[(-aSlide[i])/2])
-		}
+	PP.Multiply(&YplusX, &q.YminusX) // flipped sign
+	MM.Multiply(&YminusX, &q.YplusX) // flipped sign
+	TT2d.Multiply(&p.t, &q.T2d)
 
-		if bSlide[i] > 0 {
-			t.ToExtended(&u)
-			geMixedAdd(&t, &u, &bi[bSlide[i]/2])
-		} else if bSlide[i] < 0 {
-			t.ToExtended(&u)
-			geMixedSub(&t, &u, &bi[(-bSlide[i])/2])
-		}
+	Z2.Add(&p.z, &p.z)
 
-		t.ToProjective(r)
-	}
+	v.X.Subtract(&PP, &MM)
+	v.Y.Add(&PP, &MM)
+	v.Z.Subtract(&Z2, &TT2d) // flipped sign
+	v.T.Add(&Z2, &TT2d)      // flipped sign
+	return v
 }
 
-// equal returns 1 if b == c and 0 otherwise, assuming that b and c are
-// non-negative.
-func equal(b, c int32) int32 {
-	x := uint32(b ^ c)
-	x--
-	return int32(x >> 31)
-}
+// Doubling.
 
-// negative returns 1 if b < 0 and 0 otherwise.
-func negative(b int32) int32 {
-	return (b >> 31) & 1
-}
+func (v *projP1xP1) Double(p *projP2) *projP1xP1 {
+	var XX, YY, ZZ2, XplusYsq field.Element
 
-func PreComputedGroupElementCMove(t, u *PreComputedGroupElement, b int32) {
-	FeCMove(&t.yPlusX, &u.yPlusX, b)
-	FeCMove(&t.yMinusX, &u.yMinusX, b)
-	FeCMove(&t.xy2d, &u.xy2d, b)
-}
+	XX.Square(&p.X)
+	YY.Square(&p.Y)
+	ZZ2.Square(&p.Z)
+	ZZ2.Add(&ZZ2, &ZZ2)
+	XplusYsq.Add(&p.X, &p.Y)
+	XplusYsq.Square(&XplusYsq)
 
-func selectPoint(t *PreComputedGroupElement, pos int32, b int32) {
-	var minusT PreComputedGroupElement
-	bNegative := negative(b)
-	bAbs := b - (((-bNegative) & b) << 1)
+	v.Y.Add(&YY, &XX)
+	v.Z.Subtract(&YY, &XX)
 
-	t.Zero()
-	for i := int32(0); i < 8; i++ {
-		PreComputedGroupElementCMove(t, &base[pos][i], equal(bAbs, i+1))
-	}
-	FeCopy(&minusT.yPlusX, &t.yMinusX)
-	FeCopy(&minusT.yMinusX, &t.yPlusX)
-	FeNeg(&minusT.xy2d, &t.xy2d)
-	PreComputedGroupElementCMove(t, &minusT, bNegative)
+	v.X.Subtract(&XplusYsq, &v.Y)
+	v.T.Subtract(&ZZ2, &v.Z)
+	return v
 }
 
-// GeScalarMultBase computes h = a*B, where
-//   a = a[0]+256*a[1]+...+256^31 a[31]
-//   B is the Ed25519 base point (x,4/5) with x positive.
-//
-// Preconditions:
-//   a[31] <= 127
-func GeScalarMultBase(h *ExtendedGroupElement, a *[32]byte) {
-	var e [64]int8
-
-	for i, v := range a {
-		e[2*i] = int8(v & 15)
-		e[2*i+1] = int8((v >> 4) & 15)
-	}
+// Negation.
 
-	// each e[i] is between 0 and 15 and e[63] is between 0 and 7.
+// Negate sets v = -p, and returns v.
+func (v *Point) Negate(p *Point) *Point {
+	checkInitialized(p)
+	v.x.Negate(&p.x)
+	v.y.Set(&p.y)
+	v.z.Set(&p.z)
+	v.t.Negate(&p.t)
+	return v
+}
 
-	carry := int8(0)
-	for i := 0; i < 63; i++ {
-		e[i] += carry
-		carry = (e[i] + 8) >> 4
-		e[i] -= carry << 4
-	}
-	e[63] += carry
-	// each e[i] is between -8 and 8.
-
-	h.Zero()
-	var t PreComputedGroupElement
-	var r CompletedGroupElement
-	for i := int32(1); i < 64; i += 2 {
-		selectPoint(&t, i/2, int32(e[i]))
-		geMixedAdd(&r, h, &t)
-		r.ToExtended(h)
-	}
+// Equal returns 1 if v is equivalent to u, and 0 otherwise.
+func (v *Point) Equal(u *Point) int {
+	checkInitialized(v, u)
 
-	var s ProjectiveGroupElement
-
-	h.Double(&r)
-	r.ToProjective(&s)
-	s.Double(&r)
-	r.ToProjective(&s)
-	s.Double(&r)
-	r.ToProjective(&s)
-	s.Double(&r)
-	r.ToExtended(h)
-
-	for i := int32(0); i < 64; i += 2 {
-		selectPoint(&t, i/2, int32(e[i]))
-		geMixedAdd(&r, h, &t)
-		r.ToExtended(h)
-	}
+	var t1, t2, t3, t4 field.Element
+	t1.Multiply(&v.x, &u.z)
+	t2.Multiply(&u.x, &v.z)
+	t3.Multiply(&v.y, &u.z)
+	t4.Multiply(&u.y, &v.z)
+
+	return t1.Equal(&t2) & t3.Equal(&t4)
 }
 
-// The scalars are GF(2^252 + 27742317777372353535851937790883648493).
+// Constant-time operations
 
-// Input:
-//   a[0]+256*a[1]+...+256^31*a[31] = a
-//   b[0]+256*b[1]+...+256^31*b[31] = b
-//   c[0]+256*c[1]+...+256^31*c[31] = c
-//
-// Output:
-//   s[0]+256*s[1]+...+256^31*s[31] = (ab+c) mod l
-//   where l = 2^252 + 27742317777372353535851937790883648493.
-func ScMulAdd(s, a, b, c *[32]byte) {
-	a0 := 2097151 & load3(a[:])
-	a1 := 2097151 & (load4(a[2:]) >> 5)
-	a2 := 2097151 & (load3(a[5:]) >> 2)
-	a3 := 2097151 & (load4(a[7:]) >> 7)
-	a4 := 2097151 & (load4(a[10:]) >> 4)
-	a5 := 2097151 & (load3(a[13:]) >> 1)
-	a6 := 2097151 & (load4(a[15:]) >> 6)
-	a7 := 2097151 & (load3(a[18:]) >> 3)
-	a8 := 2097151 & load3(a[21:])
-	a9 := 2097151 & (load4(a[23:]) >> 5)
-	a10 := 2097151 & (load3(a[26:]) >> 2)
-	a11 := (load4(a[28:]) >> 7)
-	b0 := 2097151 & load3(b[:])
-	b1 := 2097151 & (load4(b[2:]) >> 5)
-	b2 := 2097151 & (load3(b[5:]) >> 2)
-	b3 := 2097151 & (load4(b[7:]) >> 7)
-	b4 := 2097151 & (load4(b[10:]) >> 4)
-	b5 := 2097151 & (load3(b[13:]) >> 1)
-	b6 := 2097151 & (load4(b[15:]) >> 6)
-	b7 := 2097151 & (load3(b[18:]) >> 3)
-	b8 := 2097151 & load3(b[21:])
-	b9 := 2097151 & (load4(b[23:]) >> 5)
-	b10 := 2097151 & (load3(b[26:]) >> 2)
-	b11 := (load4(b[28:]) >> 7)
-	c0 := 2097151 & load3(c[:])
-	c1 := 2097151 & (load4(c[2:]) >> 5)
-	c2 := 2097151 & (load3(c[5:]) >> 2)
-	c3 := 2097151 & (load4(c[7:]) >> 7)
-	c4 := 2097151 & (load4(c[10:]) >> 4)
-	c5 := 2097151 & (load3(c[13:]) >> 1)
-	c6 := 2097151 & (load4(c[15:]) >> 6)
-	c7 := 2097151 & (load3(c[18:]) >> 3)
-	c8 := 2097151 & load3(c[21:])
-	c9 := 2097151 & (load4(c[23:]) >> 5)
-	c10 := 2097151 & (load3(c[26:]) >> 2)
-	c11 := (load4(c[28:]) >> 7)
-	var carry [23]int64
-
-	s0 := c0 + a0*b0
-	s1 := c1 + a0*b1 + a1*b0
-	s2 := c2 + a0*b2 + a1*b1 + a2*b0
-	s3 := c3 + a0*b3 + a1*b2 + a2*b1 + a3*b0
-	s4 := c4 + a0*b4 + a1*b3 + a2*b2 + a3*b1 + a4*b0
-	s5 := c5 + a0*b5 + a1*b4 + a2*b3 + a3*b2 + a4*b1 + a5*b0
-	s6 := c6 + a0*b6 + a1*b5 + a2*b4 + a3*b3 + a4*b2 + a5*b1 + a6*b0
-	s7 := c7 + a0*b7 + a1*b6 + a2*b5 + a3*b4 + a4*b3 + a5*b2 + a6*b1 + a7*b0
-	s8 := c8 + a0*b8 + a1*b7 + a2*b6 + a3*b5 + a4*b4 + a5*b3 + a6*b2 + a7*b1 + a8*b0
-	s9 := c9 + a0*b9 + a1*b8 + a2*b7 + a3*b6 + a4*b5 + a5*b4 + a6*b3 + a7*b2 + a8*b1 + a9*b0
-	s10 := c10 + a0*b10 + a1*b9 + a2*b8 + a3*b7 + a4*b6 + a5*b5 + a6*b4 + a7*b3 + a8*b2 + a9*b1 + a10*b0
-	s11 := c11 + a0*b11 + a1*b10 + a2*b9 + a3*b8 + a4*b7 + a5*b6 + a6*b5 + a7*b4 + a8*b3 + a9*b2 + a10*b1 + a11*b0
-	s12 := a1*b11 + a2*b10 + a3*b9 + a4*b8 + a5*b7 + a6*b6 + a7*b5 + a8*b4 + a9*b3 + a10*b2 + a11*b1
-	s13 := a2*b11 + a3*b10 + a4*b9 + a5*b8 + a6*b7 + a7*b6 + a8*b5 + a9*b4 + a10*b3 + a11*b2
-	s14 := a3*b11 + a4*b10 + a5*b9 + a6*b8 + a7*b7 + a8*b6 + a9*b5 + a10*b4 + a11*b3
-	s15 := a4*b11 + a5*b10 + a6*b9 + a7*b8 + a8*b7 + a9*b6 + a10*b5 + a11*b4
-	s16 := a5*b11 + a6*b10 + a7*b9 + a8*b8 + a9*b7 + a10*b6 + a11*b5
-	s17 := a6*b11 + a7*b10 + a8*b9 + a9*b8 + a10*b7 + a11*b6
-	s18 := a7*b11 + a8*b10 + a9*b9 + a10*b8 + a11*b7
-	s19 := a8*b11 + a9*b10 + a10*b9 + a11*b8
-	s20 := a9*b11 + a10*b10 + a11*b9
-	s21 := a10*b11 + a11*b10
-	s22 := a11 * b11
-	s23 := int64(0)
-
-	carry[0] = (s0 + (1 << 20)) >> 21
-	s1 += carry[0]
-	s0 -= carry[0] << 21
-	carry[2] = (s2 + (1 << 20)) >> 21
-	s3 += carry[2]
-	s2 -= carry[2] << 21
-	carry[4] = (s4 + (1 << 20)) >> 21
-	s5 += carry[4]
-	s4 -= carry[4] << 21
-	carry[6] = (s6 + (1 << 20)) >> 21
-	s7 += carry[6]
-	s6 -= carry[6] << 21
-	carry[8] = (s8 + (1 << 20)) >> 21
-	s9 += carry[8]
-	s8 -= carry[8] << 21
-	carry[10] = (s10 + (1 << 20)) >> 21
-	s11 += carry[10]
-	s10 -= carry[10] << 21
-	carry[12] = (s12 + (1 << 20)) >> 21
-	s13 += carry[12]
-	s12 -= carry[12] << 21
-	carry[14] = (s14 + (1 << 20)) >> 21
-	s15 += carry[14]
-	s14 -= carry[14] << 21
-	carry[16] = (s16 + (1 << 20)) >> 21
-	s17 += carry[16]
-	s16 -= carry[16] << 21
-	carry[18] = (s18 + (1 << 20)) >> 21
-	s19 += carry[18]
-	s18 -= carry[18] << 21
-	carry[20] = (s20 + (1 << 20)) >> 21
-	s21 += carry[20]
-	s20 -= carry[20] << 21
-	carry[22] = (s22 + (1 << 20)) >> 21
-	s23 += carry[22]
-	s22 -= carry[22] << 21
-
-	carry[1] = (s1 + (1 << 20)) >> 21
-	s2 += carry[1]
-	s1 -= carry[1] << 21
-	carry[3] = (s3 + (1 << 20)) >> 21
-	s4 += carry[3]
-	s3 -= carry[3] << 21
-	carry[5] = (s5 + (1 << 20)) >> 21
-	s6 += carry[5]
-	s5 -= carry[5] << 21
-	carry[7] = (s7 + (1 << 20)) >> 21
-	s8 += carry[7]
-	s7 -= carry[7] << 21
-	carry[9] = (s9 + (1 << 20)) >> 21
-	s10 += carry[9]
-	s9 -= carry[9] << 21
-	carry[11] = (s11 + (1 << 20)) >> 21
-	s12 += carry[11]
-	s11 -= carry[11] << 21
-	carry[13] = (s13 + (1 << 20)) >> 21
-	s14 += carry[13]
-	s13 -= carry[13] << 21
-	carry[15] = (s15 + (1 << 20)) >> 21
-	s16 += carry[15]
-	s15 -= carry[15] << 21
-	carry[17] = (s17 + (1 << 20)) >> 21
-	s18 += carry[17]
-	s17 -= carry[17] << 21
-	carry[19] = (s19 + (1 << 20)) >> 21
-	s20 += carry[19]
-	s19 -= carry[19] << 21
-	carry[21] = (s21 + (1 << 20)) >> 21
-	s22 += carry[21]
-	s21 -= carry[21] << 21
-
-	s11 += s23 * 666643
-	s12 += s23 * 470296
-	s13 += s23 * 654183
-	s14 -= s23 * 997805
-	s15 += s23 * 136657
-	s16 -= s23 * 683901
-	s23 = 0
-
-	s10 += s22 * 666643
-	s11 += s22 * 470296
-	s12 += s22 * 654183
-	s13 -= s22 * 997805
-	s14 += s22 * 136657
-	s15 -= s22 * 683901
-	s22 = 0
-
-	s9 += s21 * 666643
-	s10 += s21 * 470296
-	s11 += s21 * 654183
-	s12 -= s21 * 997805
-	s13 += s21 * 136657
-	s14 -= s21 * 683901
-	s21 = 0
-
-	s8 += s20 * 666643
-	s9 += s20 * 470296
-	s10 += s20 * 654183
-	s11 -= s20 * 997805
-	s12 += s20 * 136657
-	s13 -= s20 * 683901
-	s20 = 0
-
-	s7 += s19 * 666643
-	s8 += s19 * 470296
-	s9 += s19 * 654183
-	s10 -= s19 * 997805
-	s11 += s19 * 136657
-	s12 -= s19 * 683901
-	s19 = 0
-
-	s6 += s18 * 666643
-	s7 += s18 * 470296
-	s8 += s18 * 654183
-	s9 -= s18 * 997805
-	s10 += s18 * 136657
-	s11 -= s18 * 683901
-	s18 = 0
-
-	carry[6] = (s6 + (1 << 20)) >> 21
-	s7 += carry[6]
-	s6 -= carry[6] << 21
-	carry[8] = (s8 + (1 << 20)) >> 21
-	s9 += carry[8]
-	s8 -= carry[8] << 21
-	carry[10] = (s10 + (1 << 20)) >> 21
-	s11 += carry[10]
-	s10 -= carry[10] << 21
-	carry[12] = (s12 + (1 << 20)) >> 21
-	s13 += carry[12]
-	s12 -= carry[12] << 21
-	carry[14] = (s14 + (1 << 20)) >> 21
-	s15 += carry[14]
-	s14 -= carry[14] << 21
-	carry[16] = (s16 + (1 << 20)) >> 21
-	s17 += carry[16]
-	s16 -= carry[16] << 21
-
-	carry[7] = (s7 + (1 << 20)) >> 21
-	s8 += carry[7]
-	s7 -= carry[7] << 21
-	carry[9] = (s9 + (1 << 20)) >> 21
-	s10 += carry[9]
-	s9 -= carry[9] << 21
-	carry[11] = (s11 + (1 << 20)) >> 21
-	s12 += carry[11]
-	s11 -= carry[11] << 21
-	carry[13] = (s13 + (1 << 20)) >> 21
-	s14 += carry[13]
-	s13 -= carry[13] << 21
-	carry[15] = (s15 + (1 << 20)) >> 21
-	s16 += carry[15]
-	s15 -= carry[15] << 21
-
-	s5 += s17 * 666643
-	s6 += s17 * 470296
-	s7 += s17 * 654183
-	s8 -= s17 * 997805
-	s9 += s17 * 136657
-	s10 -= s17 * 683901
-	s17 = 0
-
-	s4 += s16 * 666643
-	s5 += s16 * 470296
-	s6 += s16 * 654183
-	s7 -= s16 * 997805
-	s8 += s16 * 136657
-	s9 -= s16 * 683901
-	s16 = 0
-
-	s3 += s15 * 666643
-	s4 += s15 * 470296
-	s5 += s15 * 654183
-	s6 -= s15 * 997805
-	s7 += s15 * 136657
-	s8 -= s15 * 683901
-	s15 = 0
-
-	s2 += s14 * 666643
-	s3 += s14 * 470296
-	s4 += s14 * 654183
-	s5 -= s14 * 997805
-	s6 += s14 * 136657
-	s7 -= s14 * 683901
-	s14 = 0
-
-	s1 += s13 * 666643
-	s2 += s13 * 470296
-	s3 += s13 * 654183
-	s4 -= s13 * 997805
-	s5 += s13 * 136657
-	s6 -= s13 * 683901
-	s13 = 0
-
-	s0 += s12 * 666643
-	s1 += s12 * 470296
-	s2 += s12 * 654183
-	s3 -= s12 * 997805
-	s4 += s12 * 136657
-	s5 -= s12 * 683901
-	s12 = 0
-
-	carry[0] = (s0 + (1 << 20)) >> 21
-	s1 += carry[0]
-	s0 -= carry[0] << 21
-	carry[2] = (s2 + (1 << 20)) >> 21
-	s3 += carry[2]
-	s2 -= carry[2] << 21
-	carry[4] = (s4 + (1 << 20)) >> 21
-	s5 += carry[4]
-	s4 -= carry[4] << 21
-	carry[6] = (s6 + (1 << 20)) >> 21
-	s7 += carry[6]
-	s6 -= carry[6] << 21
-	carry[8] = (s8 + (1 << 20)) >> 21
-	s9 += carry[8]
-	s8 -= carry[8] << 21
-	carry[10] = (s10 + (1 << 20)) >> 21
-	s11 += carry[10]
-	s10 -= carry[10] << 21
-
-	carry[1] = (s1 + (1 << 20)) >> 21
-	s2 += carry[1]
-	s1 -= carry[1] << 21
-	carry[3] = (s3 + (1 << 20)) >> 21
-	s4 += carry[3]
-	s3 -= carry[3] << 21
-	carry[5] = (s5 + (1 << 20)) >> 21
-	s6 += carry[5]
-	s5 -= carry[5] << 21
-	carry[7] = (s7 + (1 << 20)) >> 21
-	s8 += carry[7]
-	s7 -= carry[7] << 21
-	carry[9] = (s9 + (1 << 20)) >> 21
-	s10 += carry[9]
-	s9 -= carry[9] << 21
-	carry[11] = (s11 + (1 << 20)) >> 21
-	s12 += carry[11]
-	s11 -= carry[11] << 21
-
-	s0 += s12 * 666643
-	s1 += s12 * 470296
-	s2 += s12 * 654183
-	s3 -= s12 * 997805
-	s4 += s12 * 136657
-	s5 -= s12 * 683901
-	s12 = 0
-
-	carry[0] = s0 >> 21
-	s1 += carry[0]
-	s0 -= carry[0] << 21
-	carry[1] = s1 >> 21
-	s2 += carry[1]
-	s1 -= carry[1] << 21
-	carry[2] = s2 >> 21
-	s3 += carry[2]
-	s2 -= carry[2] << 21
-	carry[3] = s3 >> 21
-	s4 += carry[3]
-	s3 -= carry[3] << 21
-	carry[4] = s4 >> 21
-	s5 += carry[4]
-	s4 -= carry[4] << 21
-	carry[5] = s5 >> 21
-	s6 += carry[5]
-	s5 -= carry[5] << 21
-	carry[6] = s6 >> 21
-	s7 += carry[6]
-	s6 -= carry[6] << 21
-	carry[7] = s7 >> 21
-	s8 += carry[7]
-	s7 -= carry[7] << 21
-	carry[8] = s8 >> 21
-	s9 += carry[8]
-	s8 -= carry[8] << 21
-	carry[9] = s9 >> 21
-	s10 += carry[9]
-	s9 -= carry[9] << 21
-	carry[10] = s10 >> 21
-	s11 += carry[10]
-	s10 -= carry[10] << 21
-	carry[11] = s11 >> 21
-	s12 += carry[11]
-	s11 -= carry[11] << 21
-
-	s0 += s12 * 666643
-	s1 += s12 * 470296
-	s2 += s12 * 654183
-	s3 -= s12 * 997805
-	s4 += s12 * 136657
-	s5 -= s12 * 683901
-	s12 = 0
-
-	carry[0] = s0 >> 21
-	s1 += carry[0]
-	s0 -= carry[0] << 21
-	carry[1] = s1 >> 21
-	s2 += carry[1]
-	s1 -= carry[1] << 21
-	carry[2] = s2 >> 21
-	s3 += carry[2]
-	s2 -= carry[2] << 21
-	carry[3] = s3 >> 21
-	s4 += carry[3]
-	s3 -= carry[3] << 21
-	carry[4] = s4 >> 21
-	s5 += carry[4]
-	s4 -= carry[4] << 21
-	carry[5] = s5 >> 21
-	s6 += carry[5]
-	s5 -= carry[5] << 21
-	carry[6] = s6 >> 21
-	s7 += carry[6]
-	s6 -= carry[6] << 21
-	carry[7] = s7 >> 21
-	s8 += carry[7]
-	s7 -= carry[7] << 21
-	carry[8] = s8 >> 21
-	s9 += carry[8]
-	s8 -= carry[8] << 21
-	carry[9] = s9 >> 21
-	s10 += carry[9]
-	s9 -= carry[9] << 21
-	carry[10] = s10 >> 21
-	s11 += carry[10]
-	s10 -= carry[10] << 21
-
-	s[0] = byte(s0 >> 0)
-	s[1] = byte(s0 >> 8)
-	s[2] = byte((s0 >> 16) | (s1 << 5))
-	s[3] = byte(s1 >> 3)
-	s[4] = byte(s1 >> 11)
-	s[5] = byte((s1 >> 19) | (s2 << 2))
-	s[6] = byte(s2 >> 6)
-	s[7] = byte((s2 >> 14) | (s3 << 7))
-	s[8] = byte(s3 >> 1)
-	s[9] = byte(s3 >> 9)
-	s[10] = byte((s3 >> 17) | (s4 << 4))
-	s[11] = byte(s4 >> 4)
-	s[12] = byte(s4 >> 12)
-	s[13] = byte((s4 >> 20) | (s5 << 1))
-	s[14] = byte(s5 >> 7)
-	s[15] = byte((s5 >> 15) | (s6 << 6))
-	s[16] = byte(s6 >> 2)
-	s[17] = byte(s6 >> 10)
-	s[18] = byte((s6 >> 18) | (s7 << 3))
-	s[19] = byte(s7 >> 5)
-	s[20] = byte(s7 >> 13)
-	s[21] = byte(s8 >> 0)
-	s[22] = byte(s8 >> 8)
-	s[23] = byte((s8 >> 16) | (s9 << 5))
-	s[24] = byte(s9 >> 3)
-	s[25] = byte(s9 >> 11)
-	s[26] = byte((s9 >> 19) | (s10 << 2))
-	s[27] = byte(s10 >> 6)
-	s[28] = byte((s10 >> 14) | (s11 << 7))
-	s[29] = byte(s11 >> 1)
-	s[30] = byte(s11 >> 9)
-	s[31] = byte(s11 >> 17)
+// Select sets v to a if cond == 1 and to b if cond == 0.
+func (v *projCached) Select(a, b *projCached, cond int) *projCached {
+	v.YplusX.Select(&a.YplusX, &b.YplusX, cond)
+	v.YminusX.Select(&a.YminusX, &b.YminusX, cond)
+	v.Z.Select(&a.Z, &b.Z, cond)
+	v.T2d.Select(&a.T2d, &b.T2d, cond)
+	return v
 }
 
-// Input:
-//   s[0]+256*s[1]+...+256^63*s[63] = s
-//
-// Output:
-//   s[0]+256*s[1]+...+256^31*s[31] = s mod l
-//   where l = 2^252 + 27742317777372353535851937790883648493.
-func ScReduce(out *[32]byte, s *[64]byte) {
-	s0 := 2097151 & load3(s[:])
-	s1 := 2097151 & (load4(s[2:]) >> 5)
-	s2 := 2097151 & (load3(s[5:]) >> 2)
-	s3 := 2097151 & (load4(s[7:]) >> 7)
-	s4 := 2097151 & (load4(s[10:]) >> 4)
-	s5 := 2097151 & (load3(s[13:]) >> 1)
-	s6 := 2097151 & (load4(s[15:]) >> 6)
-	s7 := 2097151 & (load3(s[18:]) >> 3)
-	s8 := 2097151 & load3(s[21:])
-	s9 := 2097151 & (load4(s[23:]) >> 5)
-	s10 := 2097151 & (load3(s[26:]) >> 2)
-	s11 := 2097151 & (load4(s[28:]) >> 7)
-	s12 := 2097151 & (load4(s[31:]) >> 4)
-	s13 := 2097151 & (load3(s[34:]) >> 1)
-	s14 := 2097151 & (load4(s[36:]) >> 6)
-	s15 := 2097151 & (load3(s[39:]) >> 3)
-	s16 := 2097151 & load3(s[42:])
-	s17 := 2097151 & (load4(s[44:]) >> 5)
-	s18 := 2097151 & (load3(s[47:]) >> 2)
-	s19 := 2097151 & (load4(s[49:]) >> 7)
-	s20 := 2097151 & (load4(s[52:]) >> 4)
-	s21 := 2097151 & (load3(s[55:]) >> 1)
-	s22 := 2097151 & (load4(s[57:]) >> 6)
-	s23 := (load4(s[60:]) >> 3)
-
-	s11 += s23 * 666643
-	s12 += s23 * 470296
-	s13 += s23 * 654183
-	s14 -= s23 * 997805
-	s15 += s23 * 136657
-	s16 -= s23 * 683901
-	s23 = 0
-
-	s10 += s22 * 666643
-	s11 += s22 * 470296
-	s12 += s22 * 654183
-	s13 -= s22 * 997805
-	s14 += s22 * 136657
-	s15 -= s22 * 683901
-	s22 = 0
-
-	s9 += s21 * 666643
-	s10 += s21 * 470296
-	s11 += s21 * 654183
-	s12 -= s21 * 997805
-	s13 += s21 * 136657
-	s14 -= s21 * 683901
-	s21 = 0
-
-	s8 += s20 * 666643
-	s9 += s20 * 470296
-	s10 += s20 * 654183
-	s11 -= s20 * 997805
-	s12 += s20 * 136657
-	s13 -= s20 * 683901
-	s20 = 0
-
-	s7 += s19 * 666643
-	s8 += s19 * 470296
-	s9 += s19 * 654183
-	s10 -= s19 * 997805
-	s11 += s19 * 136657
-	s12 -= s19 * 683901
-	s19 = 0
-
-	s6 += s18 * 666643
-	s7 += s18 * 470296
-	s8 += s18 * 654183
-	s9 -= s18 * 997805
-	s10 += s18 * 136657
-	s11 -= s18 * 683901
-	s18 = 0
-
-	var carry [17]int64
-
-	carry[6] = (s6 + (1 << 20)) >> 21
-	s7 += carry[6]
-	s6 -= carry[6] << 21
-	carry[8] = (s8 + (1 << 20)) >> 21
-	s9 += carry[8]
-	s8 -= carry[8] << 21
-	carry[10] = (s10 + (1 << 20)) >> 21
-	s11 += carry[10]
-	s10 -= carry[10] << 21
-	carry[12] = (s12 + (1 << 20)) >> 21
-	s13 += carry[12]
-	s12 -= carry[12] << 21
-	carry[14] = (s14 + (1 << 20)) >> 21
-	s15 += carry[14]
-	s14 -= carry[14] << 21
-	carry[16] = (s16 + (1 << 20)) >> 21
-	s17 += carry[16]
-	s16 -= carry[16] << 21
-
-	carry[7] = (s7 + (1 << 20)) >> 21
-	s8 += carry[7]
-	s7 -= carry[7] << 21
-	carry[9] = (s9 + (1 << 20)) >> 21
-	s10 += carry[9]
-	s9 -= carry[9] << 21
-	carry[11] = (s11 + (1 << 20)) >> 21
-	s12 += carry[11]
-	s11 -= carry[11] << 21
-	carry[13] = (s13 + (1 << 20)) >> 21
-	s14 += carry[13]
-	s13 -= carry[13] << 21
-	carry[15] = (s15 + (1 << 20)) >> 21
-	s16 += carry[15]
-	s15 -= carry[15] << 21
-
-	s5 += s17 * 666643
-	s6 += s17 * 470296
-	s7 += s17 * 654183
-	s8 -= s17 * 997805
-	s9 += s17 * 136657
-	s10 -= s17 * 683901
-	s17 = 0
-
-	s4 += s16 * 666643
-	s5 += s16 * 470296
-	s6 += s16 * 654183
-	s7 -= s16 * 997805
-	s8 += s16 * 136657
-	s9 -= s16 * 683901
-	s16 = 0
-
-	s3 += s15 * 666643
-	s4 += s15 * 470296
-	s5 += s15 * 654183
-	s6 -= s15 * 997805
-	s7 += s15 * 136657
-	s8 -= s15 * 683901
-	s15 = 0
-
-	s2 += s14 * 666643
-	s3 += s14 * 470296
-	s4 += s14 * 654183
-	s5 -= s14 * 997805
-	s6 += s14 * 136657
-	s7 -= s14 * 683901
-	s14 = 0
-
-	s1 += s13 * 666643
-	s2 += s13 * 470296
-	s3 += s13 * 654183
-	s4 -= s13 * 997805
-	s5 += s13 * 136657
-	s6 -= s13 * 683901
-	s13 = 0
-
-	s0 += s12 * 666643
-	s1 += s12 * 470296
-	s2 += s12 * 654183
-	s3 -= s12 * 997805
-	s4 += s12 * 136657
-	s5 -= s12 * 683901
-	s12 = 0
-
-	carry[0] = (s0 + (1 << 20)) >> 21
-	s1 += carry[0]
-	s0 -= carry[0] << 21
-	carry[2] = (s2 + (1 << 20)) >> 21
-	s3 += carry[2]
-	s2 -= carry[2] << 21
-	carry[4] = (s4 + (1 << 20)) >> 21
-	s5 += carry[4]
-	s4 -= carry[4] << 21
-	carry[6] = (s6 + (1 << 20)) >> 21
-	s7 += carry[6]
-	s6 -= carry[6] << 21
-	carry[8] = (s8 + (1 << 20)) >> 21
-	s9 += carry[8]
-	s8 -= carry[8] << 21
-	carry[10] = (s10 + (1 << 20)) >> 21
-	s11 += carry[10]
-	s10 -= carry[10] << 21
-
-	carry[1] = (s1 + (1 << 20)) >> 21
-	s2 += carry[1]
-	s1 -= carry[1] << 21
-	carry[3] = (s3 + (1 << 20)) >> 21
-	s4 += carry[3]
-	s3 -= carry[3] << 21
-	carry[5] = (s5 + (1 << 20)) >> 21
-	s6 += carry[5]
-	s5 -= carry[5] << 21
-	carry[7] = (s7 + (1 << 20)) >> 21
-	s8 += carry[7]
-	s7 -= carry[7] << 21
-	carry[9] = (s9 + (1 << 20)) >> 21
-	s10 += carry[9]
-	s9 -= carry[9] << 21
-	carry[11] = (s11 + (1 << 20)) >> 21
-	s12 += carry[11]
-	s11 -= carry[11] << 21
-
-	s0 += s12 * 666643
-	s1 += s12 * 470296
-	s2 += s12 * 654183
-	s3 -= s12 * 997805
-	s4 += s12 * 136657
-	s5 -= s12 * 683901
-	s12 = 0
-
-	carry[0] = s0 >> 21
-	s1 += carry[0]
-	s0 -= carry[0] << 21
-	carry[1] = s1 >> 21
-	s2 += carry[1]
-	s1 -= carry[1] << 21
-	carry[2] = s2 >> 21
-	s3 += carry[2]
-	s2 -= carry[2] << 21
-	carry[3] = s3 >> 21
-	s4 += carry[3]
-	s3 -= carry[3] << 21
-	carry[4] = s4 >> 21
-	s5 += carry[4]
-	s4 -= carry[4] << 21
-	carry[5] = s5 >> 21
-	s6 += carry[5]
-	s5 -= carry[5] << 21
-	carry[6] = s6 >> 21
-	s7 += carry[6]
-	s6 -= carry[6] << 21
-	carry[7] = s7 >> 21
-	s8 += carry[7]
-	s7 -= carry[7] << 21
-	carry[8] = s8 >> 21
-	s9 += carry[8]
-	s8 -= carry[8] << 21
-	carry[9] = s9 >> 21
-	s10 += carry[9]
-	s9 -= carry[9] << 21
-	carry[10] = s10 >> 21
-	s11 += carry[10]
-	s10 -= carry[10] << 21
-	carry[11] = s11 >> 21
-	s12 += carry[11]
-	s11 -= carry[11] << 21
-
-	s0 += s12 * 666643
-	s1 += s12 * 470296
-	s2 += s12 * 654183
-	s3 -= s12 * 997805
-	s4 += s12 * 136657
-	s5 -= s12 * 683901
-	s12 = 0
-
-	carry[0] = s0 >> 21
-	s1 += carry[0]
-	s0 -= carry[0] << 21
-	carry[1] = s1 >> 21
-	s2 += carry[1]
-	s1 -= carry[1] << 21
-	carry[2] = s2 >> 21
-	s3 += carry[2]
-	s2 -= carry[2] << 21
-	carry[3] = s3 >> 21
-	s4 += carry[3]
-	s3 -= carry[3] << 21
-	carry[4] = s4 >> 21
-	s5 += carry[4]
-	s4 -= carry[4] << 21
-	carry[5] = s5 >> 21
-	s6 += carry[5]
-	s5 -= carry[5] << 21
-	carry[6] = s6 >> 21
-	s7 += carry[6]
-	s6 -= carry[6] << 21
-	carry[7] = s7 >> 21
-	s8 += carry[7]
-	s7 -= carry[7] << 21
-	carry[8] = s8 >> 21
-	s9 += carry[8]
-	s8 -= carry[8] << 21
-	carry[9] = s9 >> 21
-	s10 += carry[9]
-	s9 -= carry[9] << 21
-	carry[10] = s10 >> 21
-	s11 += carry[10]
-	s10 -= carry[10] << 21
-
-	out[0] = byte(s0 >> 0)
-	out[1] = byte(s0 >> 8)
-	out[2] = byte((s0 >> 16) | (s1 << 5))
-	out[3] = byte(s1 >> 3)
-	out[4] = byte(s1 >> 11)
-	out[5] = byte((s1 >> 19) | (s2 << 2))
-	out[6] = byte(s2 >> 6)
-	out[7] = byte((s2 >> 14) | (s3 << 7))
-	out[8] = byte(s3 >> 1)
-	out[9] = byte(s3 >> 9)
-	out[10] = byte((s3 >> 17) | (s4 << 4))
-	out[11] = byte(s4 >> 4)
-	out[12] = byte(s4 >> 12)
-	out[13] = byte((s4 >> 20) | (s5 << 1))
-	out[14] = byte(s5 >> 7)
-	out[15] = byte((s5 >> 15) | (s6 << 6))
-	out[16] = byte(s6 >> 2)
-	out[17] = byte(s6 >> 10)
-	out[18] = byte((s6 >> 18) | (s7 << 3))
-	out[19] = byte(s7 >> 5)
-	out[20] = byte(s7 >> 13)
-	out[21] = byte(s8 >> 0)
-	out[22] = byte(s8 >> 8)
-	out[23] = byte((s8 >> 16) | (s9 << 5))
-	out[24] = byte(s9 >> 3)
-	out[25] = byte(s9 >> 11)
-	out[26] = byte((s9 >> 19) | (s10 << 2))
-	out[27] = byte(s10 >> 6)
-	out[28] = byte((s10 >> 14) | (s11 << 7))
-	out[29] = byte(s11 >> 1)
-	out[30] = byte(s11 >> 9)
-	out[31] = byte(s11 >> 17)
+// Select sets v to a if cond == 1 and to b if cond == 0.
+func (v *affineCached) Select(a, b *affineCached, cond int) *affineCached {
+	v.YplusX.Select(&a.YplusX, &b.YplusX, cond)
+	v.YminusX.Select(&a.YminusX, &b.YminusX, cond)
+	v.T2d.Select(&a.T2d, &b.T2d, cond)
+	return v
 }
 
-// order is the order of Curve25519 in little-endian form.
-var order = [4]uint64{0x5812631a5cf5d3ed, 0x14def9dea2f79cd6, 0, 0x1000000000000000}
-
-// ScMinimal returns true if the given scalar is less than the order of the
-// curve.
-func ScMinimal(scalar *[32]byte) bool {
-	for i := 3; ; i-- {
-		v := binary.LittleEndian.Uint64(scalar[i*8:])
-		if v > order[i] {
-			return false
-		} else if v < order[i] {
-			break
-		} else if i == 0 {
-			return false
-		}
-	}
+// CondNeg negates v if cond == 1 and leaves it unchanged if cond == 0.
+func (v *projCached) CondNeg(cond int) *projCached {
+	v.YplusX.Swap(&v.YminusX, cond)
+	v.T2d.Select(new(field.Element).Negate(&v.T2d), &v.T2d, cond)
+	return v
+}
 
-	return true
+// CondNeg negates v if cond == 1 and leaves it unchanged if cond == 0.
+func (v *affineCached) CondNeg(cond int) *affineCached {
+	v.YplusX.Swap(&v.YminusX, cond)
+	v.T2d.Select(new(field.Element).Negate(&v.T2d), &v.T2d, cond)
+	return v
 }
diff --git a/src/crypto/ed25519/internal/edwards25519/edwards25519_test.go b/src/crypto/ed25519/internal/edwards25519/edwards25519_test.go
new file mode 100644
index 0000000000..ac7c78c086
--- /dev/null
+++ b/src/crypto/ed25519/internal/edwards25519/edwards25519_test.go
@@ -0,0 +1,299 @@
+// Copyright (c) 2019 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 edwards25519
+
+import (
+	"crypto/ed25519/internal/edwards25519/field"
+	"encoding/hex"
+	"reflect"
+	"testing"
+)
+
+var B = NewGeneratorPoint()
+var I = NewIdentityPoint()
+
+func checkOnCurve(t *testing.T, points ...*Point) {
+	t.Helper()
+	for i, p := range points {
+		var XX, YY, ZZ, ZZZZ field.Element
+		XX.Square(&p.x)
+		YY.Square(&p.y)
+		ZZ.Square(&p.z)
+		ZZZZ.Square(&ZZ)
+		// -x² + y² = 1 + dx²y²
+		// -(X/Z)² + (Y/Z)² = 1 + d(X/Z)²(Y/Z)²
+		// (-X² + Y²)/Z² = 1 + (dX²Y²)/Z⁴
+		// (-X² + Y²)*Z² = Z⁴ + dX²Y²
+		var lhs, rhs field.Element
+		lhs.Subtract(&YY, &XX).Multiply(&lhs, &ZZ)
+		rhs.Multiply(d, &XX).Multiply(&rhs, &YY).Add(&rhs, &ZZZZ)
+		if lhs.Equal(&rhs) != 1 {
+			t.Errorf("X, Y, and Z do not specify a point on the curve\nX = %v\nY = %v\nZ = %v", p.x, p.y, p.z)
+		}
+		// xy = T/Z
+		lhs.Multiply(&p.x, &p.y)
+		rhs.Multiply(&p.z, &p.t)
+		if lhs.Equal(&rhs) != 1 {
+			t.Errorf("point %d is not valid\nX = %v\nY = %v\nZ = %v", i, p.x, p.y, p.z)
+		}
+	}
+}
+
+func TestGenerator(t *testing.T) {
+	// These are the coordinates of B from RFC 8032, Section 5.1, converted to
+	// little endian hex.
+	x := "1ad5258f602d56c9b2a7259560c72c695cdcd6fd31e2a4c0fe536ecdd3366921"
+	y := "5866666666666666666666666666666666666666666666666666666666666666"
+	if got := hex.EncodeToString(B.x.Bytes()); got != x {
+		t.Errorf("wrong B.x: got %s, expected %s", got, x)
+	}
+	if got := hex.EncodeToString(B.y.Bytes()); got != y {
+		t.Errorf("wrong B.y: got %s, expected %s", got, y)
+	}
+	if B.z.Equal(feOne) != 1 {
+		t.Errorf("wrong B.z: got %v, expected 1", B.z)
+	}
+	// Check that t is correct.
+	checkOnCurve(t, B)
+}
+
+func TestAddSubNegOnBasePoint(t *testing.T) {
+	checkLhs, checkRhs := &Point{}, &Point{}
+
+	checkLhs.Add(B, B)
+	tmpP2 := new(projP2).FromP3(B)
+	tmpP1xP1 := new(projP1xP1).Double(tmpP2)
+	checkRhs.fromP1xP1(tmpP1xP1)
+	if checkLhs.Equal(checkRhs) != 1 {
+		t.Error("B + B != [2]B")
+	}
+	checkOnCurve(t, checkLhs, checkRhs)
+
+	checkLhs.Subtract(B, B)
+	Bneg := new(Point).Negate(B)
+	checkRhs.Add(B, Bneg)
+	if checkLhs.Equal(checkRhs) != 1 {
+		t.Error("B - B != B + (-B)")
+	}
+	if I.Equal(checkLhs) != 1 {
+		t.Error("B - B != 0")
+	}
+	if I.Equal(checkRhs) != 1 {
+		t.Error("B + (-B) != 0")
+	}
+	checkOnCurve(t, checkLhs, checkRhs, Bneg)
+}
+
+func TestComparable(t *testing.T) {
+	if reflect.TypeOf(Point{}).Comparable() {
+		t.Error("Point is unexpectedly comparable")
+	}
+}
+
+func TestInvalidEncodings(t *testing.T) {
+	// An invalid point, that also happens to have y > p.
+	invalid := "efffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f"
+	p := NewGeneratorPoint()
+	if out, err := p.SetBytes(decodeHex(invalid)); err == nil {
+		t.Error("expected error for invalid point")
+	} else if out != nil {
+		t.Error("SetBytes did not return nil on an invalid encoding")
+	} else if p.Equal(B) != 1 {
+		t.Error("the Point was modified while decoding an invalid encoding")
+	}
+	checkOnCurve(t, p)
+}
+
+func TestNonCanonicalPoints(t *testing.T) {
+	type test struct {
+		name                string
+		encoding, canonical string
+	}
+	tests := []test{
+		// Points with x = 0 and the sign bit set. With x = 0 the curve equation
+		// gives y² = 1, so y = ±1. 1 has two valid encodings.
+		{
+			"y=1,sign-",
+			"0100000000000000000000000000000000000000000000000000000000000080",
+			"0100000000000000000000000000000000000000000000000000000000000000",
+		},
+		{
+			"y=p+1,sign-",
+			"eeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+			"0100000000000000000000000000000000000000000000000000000000000000",
+		},
+		{
+			"y=p-1,sign-",
+			"ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+			"ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+		},
+
+		// Non-canonical y encodings with values 2²⁵⁵-19 (p) to 2²⁵⁵-1 (p+18).
+		{
+			"y=p,sign+",
+			"edffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+			"0000000000000000000000000000000000000000000000000000000000000000",
+		},
+		{
+			"y=p,sign-",
+			"edffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+			"0000000000000000000000000000000000000000000000000000000000000080",
+		},
+		{
+			"y=p+1,sign+",
+			"eeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+			"0100000000000000000000000000000000000000000000000000000000000000",
+		},
+		// "y=p+1,sign-" is already tested above.
+		// p+2 is not a valid y-coordinate.
+		{
+			"y=p+3,sign+",
+			"f0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+			"0300000000000000000000000000000000000000000000000000000000000000",
+		},
+		{
+			"y=p+3,sign-",
+			"f0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+			"0300000000000000000000000000000000000000000000000000000000000080",
+		},
+		{
+			"y=p+4,sign+",
+			"f1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+			"0400000000000000000000000000000000000000000000000000000000000000",
+		},
+		{
+			"y=p+4,sign-",
+			"f1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+			"0400000000000000000000000000000000000000000000000000000000000080",
+		},
+		{
+			"y=p+5,sign+",
+			"f2ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+			"0500000000000000000000000000000000000000000000000000000000000000",
+		},
+		{
+			"y=p+5,sign-",
+			"f2ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+			"0500000000000000000000000000000000000000000000000000000000000080",
+		},
+		{
+			"y=p+6,sign+",
+			"f3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+			"0600000000000000000000000000000000000000000000000000000000000000",
+		},
+		{
+			"y=p+6,sign-",
+			"f3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+			"0600000000000000000000000000000000000000000000000000000000000080",
+		},
+		// p+7 is not a valid y-coordinate.
+		// p+8 is not a valid y-coordinate.
+		{
+			"y=p+9,sign+",
+			"f6ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+			"0900000000000000000000000000000000000000000000000000000000000000",
+		},
+		{
+			"y=p+9,sign-",
+			"f6ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+			"0900000000000000000000000000000000000000000000000000000000000080",
+		},
+		{
+			"y=p+10,sign+",
+			"f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+			"0a00000000000000000000000000000000000000000000000000000000000000",
+		},
+		{
+			"y=p+10,sign-",
+			"f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+			"0a00000000000000000000000000000000000000000000000000000000000080",
+		},
+		// p+11 is not a valid y-coordinate.
+		// p+12 is not a valid y-coordinate.
+		// p+13 is not a valid y-coordinate.
+		{
+			"y=p+14,sign+",
+			"fbffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+			"0e00000000000000000000000000000000000000000000000000000000000000",
+		},
+		{
+			"y=p+14,sign-",
+			"fbffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+			"0e00000000000000000000000000000000000000000000000000000000000080",
+		},
+		{
+			"y=p+15,sign+",
+			"fcffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+			"0f00000000000000000000000000000000000000000000000000000000000000",
+		},
+		{
+			"y=p+15,sign-",
+			"fcffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+			"0f00000000000000000000000000000000000000000000000000000000000080",
+		},
+		{
+			"y=p+16,sign+",
+			"fdffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+			"1000000000000000000000000000000000000000000000000000000000000000",
+		},
+		{
+			"y=p+16,sign-",
+			"fdffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+			"1000000000000000000000000000000000000000000000000000000000000080",
+		},
+		// p+17 is not a valid y-coordinate.
+		{
+			"y=p+18,sign+",
+			"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+			"1200000000000000000000000000000000000000000000000000000000000000",
+		},
+		{
+			"y=p+18,sign-",
+			"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+			"1200000000000000000000000000000000000000000000000000000000000080",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			p1, err := new(Point).SetBytes(decodeHex(tt.encoding))
+			if err != nil {
+				t.Fatalf("error decoding non-canonical point: %v", err)
+			}
+			p2, err := new(Point).SetBytes(decodeHex(tt.canonical))
+			if err != nil {
+				t.Fatalf("error decoding canonical point: %v", err)
+			}
+			if p1.Equal(p2) != 1 {
+				t.Errorf("equivalent points are not equal: %v, %v", p1, p2)
+			}
+			if encoding := hex.EncodeToString(p1.Bytes()); encoding != tt.canonical {
+				t.Errorf("re-encoding does not match canonical; got %q, expected %q", encoding, tt.canonical)
+			}
+			checkOnCurve(t, p1, p2)
+		})
+	}
+}
+
+var testAllocationsSink byte
+
+func TestAllocations(t *testing.T) {
+	if allocs := testing.AllocsPerRun(100, func() {
+		p := NewIdentityPoint()
+		p.Add(p, NewGeneratorPoint())
+		s := NewScalar()
+		testAllocationsSink ^= s.Bytes()[0]
+		testAllocationsSink ^= p.Bytes()[0]
+	}); allocs > 0 {
+		t.Errorf("expected zero allocations, got %0.1v", allocs)
+	}
+}
+
+func decodeHex(s string) []byte {
+	b, err := hex.DecodeString(s)
+	if err != nil {
+		panic(err)
+	}
+	return b
+}
diff --git a/src/crypto/ed25519/internal/edwards25519/field/_asm/fe_amd64_asm.go b/src/crypto/ed25519/internal/edwards25519/field/_asm/fe_amd64_asm.go
new file mode 100644
index 0000000000..fbc0cce22c
--- /dev/null
+++ b/src/crypto/ed25519/internal/edwards25519/field/_asm/fe_amd64_asm.go
@@ -0,0 +1,294 @@
+// Copyright (c) 2021 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 (
+	"fmt"
+
+	. "github.com/mmcloughlin/avo/build"
+	. "github.com/mmcloughlin/avo/gotypes"
+	. "github.com/mmcloughlin/avo/operand"
+	. "github.com/mmcloughlin/avo/reg"
+)
+
+//go:generate go run . -out ../fe_amd64.s -stubs ../fe_amd64.go -pkg field
+
+func main() {
+	Package("crypto/ed25519/internal/edwards25519/field")
+	ConstraintExpr("amd64,gc,!purego")
+	feMul()
+	feSquare()
+	Generate()
+}
+
+type namedComponent struct {
+	Component
+	name string
+}
+
+func (c namedComponent) String() string { return c.name }
+
+type uint128 struct {
+	name   string
+	hi, lo GPVirtual
+}
+
+func (c uint128) String() string { return c.name }
+
+func feSquare() {
+	TEXT("feSquare", NOSPLIT, "func(out, a *Element)")
+	Doc("feSquare sets out = a * a. It works like feSquareGeneric.")
+	Pragma("noescape")
+
+	a := Dereference(Param("a"))
+	l0 := namedComponent{a.Field("l0"), "l0"}
+	l1 := namedComponent{a.Field("l1"), "l1"}
+	l2 := namedComponent{a.Field("l2"), "l2"}
+	l3 := namedComponent{a.Field("l3"), "l3"}
+	l4 := namedComponent{a.Field("l4"), "l4"}
+
+	// r0 = l0×l0 + 19×2×(l1×l4 + l2×l3)
+	r0 := uint128{"r0", GP64(), GP64()}
+	mul64(r0, 1, l0, l0)
+	addMul64(r0, 38, l1, l4)
+	addMul64(r0, 38, l2, l3)
+
+	// r1 = 2×l0×l1 + 19×2×l2×l4 + 19×l3×l3
+	r1 := uint128{"r1", GP64(), GP64()}
+	mul64(r1, 2, l0, l1)
+	addMul64(r1, 38, l2, l4)
+	addMul64(r1, 19, l3, l3)
+
+	// r2 = = 2×l0×l2 + l1×l1 + 19×2×l3×l4
+	r2 := uint128{"r2", GP64(), GP64()}
+	mul64(r2, 2, l0, l2)
+	addMul64(r2, 1, l1, l1)
+	addMul64(r2, 38, l3, l4)
+
+	// r3 = = 2×l0×l3 + 2×l1×l2 + 19×l4×l4
+	r3 := uint128{"r3", GP64(), GP64()}
+	mul64(r3, 2, l0, l3)
+	addMul64(r3, 2, l1, l2)
+	addMul64(r3, 19, l4, l4)
+
+	// r4 = = 2×l0×l4 + 2×l1×l3 + l2×l2
+	r4 := uint128{"r4", GP64(), GP64()}
+	mul64(r4, 2, l0, l4)
+	addMul64(r4, 2, l1, l3)
+	addMul64(r4, 1, l2, l2)
+
+	Comment("First reduction chain")
+	maskLow51Bits := GP64()
+	MOVQ(Imm((1<<51)-1), maskLow51Bits)
+	c0, r0lo := shiftRightBy51(&r0)
+	c1, r1lo := shiftRightBy51(&r1)
+	c2, r2lo := shiftRightBy51(&r2)
+	c3, r3lo := shiftRightBy51(&r3)
+	c4, r4lo := shiftRightBy51(&r4)
+	maskAndAdd(r0lo, maskLow51Bits, c4, 19)
+	maskAndAdd(r1lo, maskLow51Bits, c0, 1)
+	maskAndAdd(r2lo, maskLow51Bits, c1, 1)
+	maskAndAdd(r3lo, maskLow51Bits, c2, 1)
+	maskAndAdd(r4lo, maskLow51Bits, c3, 1)
+
+	Comment("Second reduction chain (carryPropagate)")
+	// c0 = r0 >> 51
+	MOVQ(r0lo, c0)
+	SHRQ(Imm(51), c0)
+	// c1 = r1 >> 51
+	MOVQ(r1lo, c1)
+	SHRQ(Imm(51), c1)
+	// c2 = r2 >> 51
+	MOVQ(r2lo, c2)
+	SHRQ(Imm(51), c2)
+	// c3 = r3 >> 51
+	MOVQ(r3lo, c3)
+	SHRQ(Imm(51), c3)
+	// c4 = r4 >> 51
+	MOVQ(r4lo, c4)
+	SHRQ(Imm(51), c4)
+	maskAndAdd(r0lo, maskLow51Bits, c4, 19)
+	maskAndAdd(r1lo, maskLow51Bits, c0, 1)
+	maskAndAdd(r2lo, maskLow51Bits, c1, 1)
+	maskAndAdd(r3lo, maskLow51Bits, c2, 1)
+	maskAndAdd(r4lo, maskLow51Bits, c3, 1)
+
+	Comment("Store output")
+	out := Dereference(Param("out"))
+	Store(r0lo, out.Field("l0"))
+	Store(r1lo, out.Field("l1"))
+	Store(r2lo, out.Field("l2"))
+	Store(r3lo, out.Field("l3"))
+	Store(r4lo, out.Field("l4"))
+
+	RET()
+}
+
+func feMul() {
+	TEXT("feMul", NOSPLIT, "func(out, a, b *Element)")
+	Doc("feMul sets out = a * b. It works like feMulGeneric.")
+	Pragma("noescape")
+
+	a := Dereference(Param("a"))
+	a0 := namedComponent{a.Field("l0"), "a0"}
+	a1 := namedComponent{a.Field("l1"), "a1"}
+	a2 := namedComponent{a.Field("l2"), "a2"}
+	a3 := namedComponent{a.Field("l3"), "a3"}
+	a4 := namedComponent{a.Field("l4"), "a4"}
+
+	b := Dereference(Param("b"))
+	b0 := namedComponent{b.Field("l0"), "b0"}
+	b1 := namedComponent{b.Field("l1"), "b1"}
+	b2 := namedComponent{b.Field("l2"), "b2"}
+	b3 := namedComponent{b.Field("l3"), "b3"}
+	b4 := namedComponent{b.Field("l4"), "b4"}
+
+	// r0 = a0×b0 + 19×(a1×b4 + a2×b3 + a3×b2 + a4×b1)
+	r0 := uint128{"r0", GP64(), GP64()}
+	mul64(r0, 1, a0, b0)
+	addMul64(r0, 19, a1, b4)
+	addMul64(r0, 19, a2, b3)
+	addMul64(r0, 19, a3, b2)
+	addMul64(r0, 19, a4, b1)
+
+	// r1 = a0×b1 + a1×b0 + 19×(a2×b4 + a3×b3 + a4×b2)
+	r1 := uint128{"r1", GP64(), GP64()}
+	mul64(r1, 1, a0, b1)
+	addMul64(r1, 1, a1, b0)
+	addMul64(r1, 19, a2, b4)
+	addMul64(r1, 19, a3, b3)
+	addMul64(r1, 19, a4, b2)
+
+	// r2 = a0×b2 + a1×b1 + a2×b0 + 19×(a3×b4 + a4×b3)
+	r2 := uint128{"r2", GP64(), GP64()}
+	mul64(r2, 1, a0, b2)
+	addMul64(r2, 1, a1, b1)
+	addMul64(r2, 1, a2, b0)
+	addMul64(r2, 19, a3, b4)
+	addMul64(r2, 19, a4, b3)
+
+	// r3 = a0×b3 + a1×b2 + a2×b1 + a3×b0 + 19×a4×b4
+	r3 := uint128{"r3", GP64(), GP64()}
+	mul64(r3, 1, a0, b3)
+	addMul64(r3, 1, a1, b2)
+	addMul64(r3, 1, a2, b1)
+	addMul64(r3, 1, a3, b0)
+	addMul64(r3, 19, a4, b4)
+
+	// r4 = a0×b4 + a1×b3 + a2×b2 + a3×b1 + a4×b0
+	r4 := uint128{"r4", GP64(), GP64()}
+	mul64(r4, 1, a0, b4)
+	addMul64(r4, 1, a1, b3)
+	addMul64(r4, 1, a2, b2)
+	addMul64(r4, 1, a3, b1)
+	addMul64(r4, 1, a4, b0)
+
+	Comment("First reduction chain")
+	maskLow51Bits := GP64()
+	MOVQ(Imm((1<<51)-1), maskLow51Bits)
+	c0, r0lo := shiftRightBy51(&r0)
+	c1, r1lo := shiftRightBy51(&r1)
+	c2, r2lo := shiftRightBy51(&r2)
+	c3, r3lo := shiftRightBy51(&r3)
+	c4, r4lo := shiftRightBy51(&r4)
+	maskAndAdd(r0lo, maskLow51Bits, c4, 19)
+	maskAndAdd(r1lo, maskLow51Bits, c0, 1)
+	maskAndAdd(r2lo, maskLow51Bits, c1, 1)
+	maskAndAdd(r3lo, maskLow51Bits, c2, 1)
+	maskAndAdd(r4lo, maskLow51Bits, c3, 1)
+
+	Comment("Second reduction chain (carryPropagate)")
+	// c0 = r0 >> 51
+	MOVQ(r0lo, c0)
+	SHRQ(Imm(51), c0)
+	// c1 = r1 >> 51
+	MOVQ(r1lo, c1)
+	SHRQ(Imm(51), c1)
+	// c2 = r2 >> 51
+	MOVQ(r2lo, c2)
+	SHRQ(Imm(51), c2)
+	// c3 = r3 >> 51
+	MOVQ(r3lo, c3)
+	SHRQ(Imm(51), c3)
+	// c4 = r4 >> 51
+	MOVQ(r4lo, c4)
+	SHRQ(Imm(51), c4)
+	maskAndAdd(r0lo, maskLow51Bits, c4, 19)
+	maskAndAdd(r1lo, maskLow51Bits, c0, 1)
+	maskAndAdd(r2lo, maskLow51Bits, c1, 1)
+	maskAndAdd(r3lo, maskLow51Bits, c2, 1)
+	maskAndAdd(r4lo, maskLow51Bits, c3, 1)
+
+	Comment("Store output")
+	out := Dereference(Param("out"))
+	Store(r0lo, out.Field("l0"))
+	Store(r1lo, out.Field("l1"))
+	Store(r2lo, out.Field("l2"))
+	Store(r3lo, out.Field("l3"))
+	Store(r4lo, out.Field("l4"))
+
+	RET()
+}
+
+// mul64 sets r to i * aX * bX.
+func mul64(r uint128, i int, aX, bX namedComponent) {
+	switch i {
+	case 1:
+		Comment(fmt.Sprintf("%s = %s×%s", r, aX, bX))
+		Load(aX, RAX)
+	case 2:
+		Comment(fmt.Sprintf("%s = 2×%s×%s", r, aX, bX))
+		Load(aX, RAX)
+		SHLQ(Imm(1), RAX)
+	default:
+		panic("unsupported i value")
+	}
+	MULQ(mustAddr(bX)) // RDX, RAX = RAX * bX
+	MOVQ(RAX, r.lo)
+	MOVQ(RDX, r.hi)
+}
+
+// addMul64 sets r to r + i * aX * bX.
+func addMul64(r uint128, i uint64, aX, bX namedComponent) {
+	switch i {
+	case 1:
+		Comment(fmt.Sprintf("%s += %s×%s", r, aX, bX))
+		Load(aX, RAX)
+	default:
+		Comment(fmt.Sprintf("%s += %d×%s×%s", r, i, aX, bX))
+		IMUL3Q(Imm(i), Load(aX, GP64()), RAX)
+	}
+	MULQ(mustAddr(bX)) // RDX, RAX = RAX * bX
+	ADDQ(RAX, r.lo)
+	ADCQ(RDX, r.hi)
+}
+
+// shiftRightBy51 returns r >> 51 and r.lo.
+//
+// After this function is called, the uint128 may not be used anymore.
+func shiftRightBy51(r *uint128) (out, lo GPVirtual) {
+	out = r.hi
+	lo = r.lo
+	SHLQ(Imm(64-51), r.lo, r.hi)
+	r.lo, r.hi = nil, nil // make sure the uint128 is unusable
+	return
+}
+
+// maskAndAdd sets r = r&mask + c*i.
+func maskAndAdd(r, mask, c GPVirtual, i uint64) {
+	ANDQ(mask, r)
+	if i != 1 {
+		IMUL3Q(Imm(i), c, c)
+	}
+	ADDQ(c, r)
+}
+
+func mustAddr(c Component) Op {
+	b, err := c.Resolve()
+	if err != nil {
+		panic(err)
+	}
+	return b.Addr
+}
diff --git a/src/crypto/ed25519/internal/edwards25519/field/_asm/go.mod b/src/crypto/ed25519/internal/edwards25519/field/_asm/go.mod
new file mode 100644
index 0000000000..1127ade877
--- /dev/null
+++ b/src/crypto/ed25519/internal/edwards25519/field/_asm/go.mod
@@ -0,0 +1,5 @@
+module asm
+
+go 1.16
+
+require github.com/mmcloughlin/avo v0.2.0
diff --git a/src/crypto/ed25519/internal/edwards25519/field/_asm/go.sum b/src/crypto/ed25519/internal/edwards25519/field/_asm/go.sum
new file mode 100644
index 0000000000..dae47774ac
--- /dev/null
+++ b/src/crypto/ed25519/internal/edwards25519/field/_asm/go.sum
@@ -0,0 +1,31 @@
+github.com/mmcloughlin/avo v0.2.0 h1:6vhoSaKtxb6f4RiH+LK2qL6GSMpFzhEwJYTTSZNy09w=
+github.com/mmcloughlin/avo v0.2.0/go.mod h1:5tidO2Z9Z7N6X7UMcGg+1KTj51O8OxYDCMHxCZTVpEA=
+github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+golang.org/x/arch v0.0.0-20210405154355-08b684f594a5/go.mod h1:flIaEI6LNU6xOCD5PaJvn9wGP0agmIOqjrtsKGRguv4=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/mod v0.3.0 h1:RM4zey1++hCTbCVQfnWeKs9/IEsaBLA8vTkd0WVtmH4=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57 h1:F5Gozwx4I1xtr/sr/8CFbb57iKi3297KFs0QDbGN60A=
+golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.0 h1:po9/4sTYwZU9lPhi1tOrb4hCv3qrhiQ77LZfGa2OjwY=
+golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=
diff --git a/src/crypto/ed25519/internal/edwards25519/field/fe.go b/src/crypto/ed25519/internal/edwards25519/field/fe.go
new file mode 100644
index 0000000000..dbe86599b3
--- /dev/null
+++ b/src/crypto/ed25519/internal/edwards25519/field/fe.go
@@ -0,0 +1,416 @@
+// Copyright (c) 2017 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 field implements fast arithmetic modulo 2^255-19.
+package field
+
+import (
+	"crypto/subtle"
+	"encoding/binary"
+	"math/bits"
+)
+
+// Element represents an element of the field GF(2^255-19). Note that this
+// is not a cryptographically secure group, and should only be used to interact
+// with edwards25519.Point coordinates.
+//
+// This type works similarly to math/big.Int, and all arguments and receivers
+// are allowed to alias.
+//
+// The zero value is a valid zero element.
+type Element struct {
+	// An element t represents the integer
+	//     t.l0 + t.l1*2^51 + t.l2*2^102 + t.l3*2^153 + t.l4*2^204
+	//
+	// Between operations, all limbs are expected to be lower than 2^52.
+	l0 uint64
+	l1 uint64
+	l2 uint64
+	l3 uint64
+	l4 uint64
+}
+
+const maskLow51Bits uint64 = (1 << 51) - 1
+
+var feZero = &Element{0, 0, 0, 0, 0}
+
+// Zero sets v = 0, and returns v.
+func (v *Element) Zero() *Element {
+	*v = *feZero
+	return v
+}
+
+var feOne = &Element{1, 0, 0, 0, 0}
+
+// One sets v = 1, and returns v.
+func (v *Element) One() *Element {
+	*v = *feOne
+	return v
+}
+
+// reduce reduces v modulo 2^255 - 19 and returns it.
+func (v *Element) reduce() *Element {
+	v.carryPropagate()
+
+	// After the light reduction we now have a field element representation
+	// v < 2^255 + 2^13 * 19, but need v < 2^255 - 19.
+
+	// If v >= 2^255 - 19, then v + 19 >= 2^255, which would overflow 2^255 - 1,
+	// generating a carry. That is, c will be 0 if v < 2^255 - 19, and 1 otherwise.
+	c := (v.l0 + 19) >> 51
+	c = (v.l1 + c) >> 51
+	c = (v.l2 + c) >> 51
+	c = (v.l3 + c) >> 51
+	c = (v.l4 + c) >> 51
+
+	// If v < 2^255 - 19 and c = 0, this will be a no-op. Otherwise, it's
+	// effectively applying the reduction identity to the carry.
+	v.l0 += 19 * c
+
+	v.l1 += v.l0 >> 51
+	v.l0 = v.l0 & maskLow51Bits
+	v.l2 += v.l1 >> 51
+	v.l1 = v.l1 & maskLow51Bits
+	v.l3 += v.l2 >> 51
+	v.l2 = v.l2 & maskLow51Bits
+	v.l4 += v.l3 >> 51
+	v.l3 = v.l3 & maskLow51Bits
+	// no additional carry
+	v.l4 = v.l4 & maskLow51Bits
+
+	return v
+}
+
+// Add sets v = a + b, and returns v.
+func (v *Element) Add(a, b *Element) *Element {
+	v.l0 = a.l0 + b.l0
+	v.l1 = a.l1 + b.l1
+	v.l2 = a.l2 + b.l2
+	v.l3 = a.l3 + b.l3
+	v.l4 = a.l4 + b.l4
+	// Using the generic implementation here is actually faster than the
+	// assembly. Probably because the body of this function is so simple that
+	// the compiler can figure out better optimizations by inlining the carry
+	// propagation.
+	return v.carryPropagateGeneric()
+}
+
+// Subtract sets v = a - b, and returns v.
+func (v *Element) Subtract(a, b *Element) *Element {
+	// We first add 2 * p, to guarantee the subtraction won't underflow, and
+	// then subtract b (which can be up to 2^255 + 2^13 * 19).
+	v.l0 = (a.l0 + 0xFFFFFFFFFFFDA) - b.l0
+	v.l1 = (a.l1 + 0xFFFFFFFFFFFFE) - b.l1
+	v.l2 = (a.l2 + 0xFFFFFFFFFFFFE) - b.l2
+	v.l3 = (a.l3 + 0xFFFFFFFFFFFFE) - b.l3
+	v.l4 = (a.l4 + 0xFFFFFFFFFFFFE) - b.l4
+	return v.carryPropagate()
+}
+
+// Negate sets v = -a, and returns v.
+func (v *Element) Negate(a *Element) *Element {
+	return v.Subtract(feZero, a)
+}
+
+// Invert sets v = 1/z mod p, and returns v.
+//
+// If z == 0, Invert returns v = 0.
+func (v *Element) Invert(z *Element) *Element {
+	// Inversion is implemented as exponentiation with exponent p − 2. It uses the
+	// same sequence of 255 squarings and 11 multiplications as [Curve25519].
+	var z2, z9, z11, z2_5_0, z2_10_0, z2_20_0, z2_50_0, z2_100_0, t Element
+
+	z2.Square(z)             // 2
+	t.Square(&z2)            // 4
+	t.Square(&t)             // 8
+	z9.Multiply(&t, z)       // 9
+	z11.Multiply(&z9, &z2)   // 11
+	t.Square(&z11)           // 22
+	z2_5_0.Multiply(&t, &z9) // 31 = 2^5 - 2^0
+
+	t.Square(&z2_5_0) // 2^6 - 2^1
+	for i := 0; i < 4; i++ {
+		t.Square(&t) // 2^10 - 2^5
+	}
+	z2_10_0.Multiply(&t, &z2_5_0) // 2^10 - 2^0
+
+	t.Square(&z2_10_0) // 2^11 - 2^1
+	for i := 0; i < 9; i++ {
+		t.Square(&t) // 2^20 - 2^10
+	}
+	z2_20_0.Multiply(&t, &z2_10_0) // 2^20 - 2^0
+
+	t.Square(&z2_20_0) // 2^21 - 2^1
+	for i := 0; i < 19; i++ {
+		t.Square(&t) // 2^40 - 2^20
+	}
+	t.Multiply(&t, &z2_20_0) // 2^40 - 2^0
+
+	t.Square(&t) // 2^41 - 2^1
+	for i := 0; i < 9; i++ {
+		t.Square(&t) // 2^50 - 2^10
+	}
+	z2_50_0.Multiply(&t, &z2_10_0) // 2^50 - 2^0
+
+	t.Square(&z2_50_0) // 2^51 - 2^1
+	for i := 0; i < 49; i++ {
+		t.Square(&t) // 2^100 - 2^50
+	}
+	z2_100_0.Multiply(&t, &z2_50_0) // 2^100 - 2^0
+
+	t.Square(&z2_100_0) // 2^101 - 2^1
+	for i := 0; i < 99; i++ {
+		t.Square(&t) // 2^200 - 2^100
+	}
+	t.Multiply(&t, &z2_100_0) // 2^200 - 2^0
+
+	t.Square(&t) // 2^201 - 2^1
+	for i := 0; i < 49; i++ {
+		t.Square(&t) // 2^250 - 2^50
+	}
+	t.Multiply(&t, &z2_50_0) // 2^250 - 2^0
+
+	t.Square(&t) // 2^251 - 2^1
+	t.Square(&t) // 2^252 - 2^2
+	t.Square(&t) // 2^253 - 2^3
+	t.Square(&t) // 2^254 - 2^4
+	t.Square(&t) // 2^255 - 2^5
+
+	return v.Multiply(&t, &z11) // 2^255 - 21
+}
+
+// Set sets v = a, and returns v.
+func (v *Element) Set(a *Element) *Element {
+	*v = *a
+	return v
+}
+
+// SetBytes sets v to x, which must be a 32-byte little-endian encoding.
+//
+// Consistent with RFC 7748, the most significant bit (the high bit of the
+// last byte) is ignored, and non-canonical values (2^255-19 through 2^255-1)
+// are accepted. Note that this is laxer than specified by RFC 8032.
+func (v *Element) SetBytes(x []byte) *Element {
+	if len(x) != 32 {
+		panic("edwards25519: invalid field element input size")
+	}
+
+	// Bits 0:51 (bytes 0:8, bits 0:64, shift 0, mask 51).
+	v.l0 = binary.LittleEndian.Uint64(x[0:8])
+	v.l0 &= maskLow51Bits
+	// Bits 51:102 (bytes 6:14, bits 48:112, shift 3, mask 51).
+	v.l1 = binary.LittleEndian.Uint64(x[6:14]) >> 3
+	v.l1 &= maskLow51Bits
+	// Bits 102:153 (bytes 12:20, bits 96:160, shift 6, mask 51).
+	v.l2 = binary.LittleEndian.Uint64(x[12:20]) >> 6
+	v.l2 &= maskLow51Bits
+	// Bits 153:204 (bytes 19:27, bits 152:216, shift 1, mask 51).
+	v.l3 = binary.LittleEndian.Uint64(x[19:27]) >> 1
+	v.l3 &= maskLow51Bits
+	// Bits 204:251 (bytes 24:32, bits 192:256, shift 12, mask 51).
+	// Note: not bytes 25:33, shift 4, to avoid overread.
+	v.l4 = binary.LittleEndian.Uint64(x[24:32]) >> 12
+	v.l4 &= maskLow51Bits
+
+	return v
+}
+
+// Bytes returns the canonical 32-byte little-endian encoding of v.
+func (v *Element) Bytes() []byte {
+	// This function is outlined to make the allocations inline in the caller
+	// rather than happen on the heap.
+	var out [32]byte
+	return v.bytes(&out)
+}
+
+func (v *Element) bytes(out *[32]byte) []byte {
+	t := *v
+	t.reduce()
+
+	var buf [8]byte
+	for i, l := range [5]uint64{t.l0, t.l1, t.l2, t.l3, t.l4} {
+		bitsOffset := i * 51
+		binary.LittleEndian.PutUint64(buf[:], l<<uint(bitsOffset%8))
+		for i, bb := range buf {
+			off := bitsOffset/8 + i
+			if off >= len(out) {
+				break
+			}
+			out[off] |= bb
+		}
+	}
+
+	return out[:]
+}
+
+// Equal returns 1 if v and u are equal, and 0 otherwise.
+func (v *Element) Equal(u *Element) int {
+	sa, sv := u.Bytes(), v.Bytes()
+	return subtle.ConstantTimeCompare(sa, sv)
+}
+
+// mask64Bits returns 0xffffffff if cond is 1, and 0 otherwise.
+func mask64Bits(cond int) uint64 { return ^(uint64(cond) - 1) }
+
+// Select sets v to a if cond == 1, and to b if cond == 0.
+func (v *Element) Select(a, b *Element, cond int) *Element {
+	m := mask64Bits(cond)
+	v.l0 = (m & a.l0) | (^m & b.l0)
+	v.l1 = (m & a.l1) | (^m & b.l1)
+	v.l2 = (m & a.l2) | (^m & b.l2)
+	v.l3 = (m & a.l3) | (^m & b.l3)
+	v.l4 = (m & a.l4) | (^m & b.l4)
+	return v
+}
+
+// Swap swaps v and u if cond == 1 or leaves them unchanged if cond == 0, and returns v.
+func (v *Element) Swap(u *Element, cond int) {
+	m := mask64Bits(cond)
+	t := m & (v.l0 ^ u.l0)
+	v.l0 ^= t
+	u.l0 ^= t
+	t = m & (v.l1 ^ u.l1)
+	v.l1 ^= t
+	u.l1 ^= t
+	t = m & (v.l2 ^ u.l2)
+	v.l2 ^= t
+	u.l2 ^= t
+	t = m & (v.l3 ^ u.l3)
+	v.l3 ^= t
+	u.l3 ^= t
+	t = m & (v.l4 ^ u.l4)
+	v.l4 ^= t
+	u.l4 ^= t
+}
+
+// IsNegative returns 1 if v is negative, and 0 otherwise.
+func (v *Element) IsNegative() int {
+	return int(v.Bytes()[0] & 1)
+}
+
+// Absolute sets v to |u|, and returns v.
+func (v *Element) Absolute(u *Element) *Element {
+	return v.Select(new(Element).Negate(u), u, u.IsNegative())
+}
+
+// Multiply sets v = x * y, and returns v.
+func (v *Element) Multiply(x, y *Element) *Element {
+	feMul(v, x, y)
+	return v
+}
+
+// Square sets v = x * x, and returns v.
+func (v *Element) Square(x *Element) *Element {
+	feSquare(v, x)
+	return v
+}
+
+// Mult32 sets v = x * y, and returns v.
+func (v *Element) Mult32(x *Element, y uint32) *Element {
+	x0lo, x0hi := mul51(x.l0, y)
+	x1lo, x1hi := mul51(x.l1, y)
+	x2lo, x2hi := mul51(x.l2, y)
+	x3lo, x3hi := mul51(x.l3, y)
+	x4lo, x4hi := mul51(x.l4, y)
+	v.l0 = x0lo + 19*x4hi // carried over per the reduction identity
+	v.l1 = x1lo + x0hi
+	v.l2 = x2lo + x1hi
+	v.l3 = x3lo + x2hi
+	v.l4 = x4lo + x3hi
+	// The hi portions are going to be only 32 bits, plus any previous excess,
+	// so we can skip the carry propagation.
+	return v
+}
+
+// mul51 returns lo + hi * 2⁵¹ = a * b.
+func mul51(a uint64, b uint32) (lo uint64, hi uint64) {
+	mh, ml := bits.Mul64(a, uint64(b))
+	lo = ml & maskLow51Bits
+	hi = (mh << 13) | (ml >> 51)
+	return
+}
+
+// Pow22523 set v = x^((p-5)/8), and returns v. (p-5)/8 is 2^252-3.
+func (v *Element) Pow22523(x *Element) *Element {
+	var t0, t1, t2 Element
+
+	t0.Square(x)             // x^2
+	t1.Square(&t0)           // x^4
+	t1.Square(&t1)           // x^8
+	t1.Multiply(x, &t1)      // x^9
+	t0.Multiply(&t0, &t1)    // x^11
+	t0.Square(&t0)           // x^22
+	t0.Multiply(&t1, &t0)    // x^31
+	t1.Square(&t0)           // x^62
+	for i := 1; i < 5; i++ { // x^992
+		t1.Square(&t1)
+	}
+	t0.Multiply(&t1, &t0)     // x^1023 -> 1023 = 2^10 - 1
+	t1.Square(&t0)            // 2^11 - 2
+	for i := 1; i < 10; i++ { // 2^20 - 2^10
+		t1.Square(&t1)
+	}
+	t1.Multiply(&t1, &t0)     // 2^20 - 1
+	t2.Square(&t1)            // 2^21 - 2
+	for i := 1; i < 20; i++ { // 2^40 - 2^20
+		t2.Square(&t2)
+	}
+	t1.Multiply(&t2, &t1)     // 2^40 - 1
+	t1.Square(&t1)            // 2^41 - 2
+	for i := 1; i < 10; i++ { // 2^50 - 2^10
+		t1.Square(&t1)
+	}
+	t0.Multiply(&t1, &t0)     // 2^50 - 1
+	t1.Square(&t0)            // 2^51 - 2
+	for i := 1; i < 50; i++ { // 2^100 - 2^50
+		t1.Square(&t1)
+	}
+	t1.Multiply(&t1, &t0)      // 2^100 - 1
+	t2.Square(&t1)             // 2^101 - 2
+	for i := 1; i < 100; i++ { // 2^200 - 2^100
+		t2.Square(&t2)
+	}
+	t1.Multiply(&t2, &t1)     // 2^200 - 1
+	t1.Square(&t1)            // 2^201 - 2
+	for i := 1; i < 50; i++ { // 2^250 - 2^50
+		t1.Square(&t1)
+	}
+	t0.Multiply(&t1, &t0)     // 2^250 - 1
+	t0.Square(&t0)            // 2^251 - 2
+	t0.Square(&t0)            // 2^252 - 4
+	return v.Multiply(&t0, x) // 2^252 - 3 -> x^(2^252-3)
+}
+
+// sqrtM1 is 2^((p-1)/4), which squared is equal to -1 by Euler's Criterion.
+var sqrtM1 = &Element{1718705420411056, 234908883556509,
+	2233514472574048, 2117202627021982, 765476049583133}
+
+// SqrtRatio sets r to the non-negative square root of the ratio of u and v.
+//
+// If u/v is square, SqrtRatio returns r and 1. If u/v is not square, SqrtRatio
+// sets r according to Section 4.3 of draft-irtf-cfrg-ristretto255-decaf448-00,
+// and returns r and 0.
+func (r *Element) SqrtRatio(u, v *Element) (rr *Element, wasSquare int) {
+	var a, b Element
+
+	// r = (u * v3) * (u * v7)^((p-5)/8)
+	v2 := a.Square(v)
+	uv3 := b.Multiply(u, b.Multiply(v2, v))
+	uv7 := a.Multiply(uv3, a.Square(v2))
+	r.Multiply(uv3, r.Pow22523(uv7))
+
+	check := a.Multiply(v, a.Square(r)) // check = v * r^2
+
+	uNeg := b.Negate(u)
+	correctSignSqrt := check.Equal(u)
+	flippedSignSqrt := check.Equal(uNeg)
+	flippedSignSqrtI := check.Equal(uNeg.Multiply(uNeg, sqrtM1))
+
+	rPrime := b.Multiply(r, sqrtM1) // r_prime = SQRT_M1 * r
+	// r = CT_SELECT(r_prime IF flipped_sign_sqrt | flipped_sign_sqrt_i ELSE r)
+	r.Select(rPrime, r, flippedSignSqrt|flippedSignSqrtI)
+
+	r.Absolute(r) // Choose the nonnegative square root.
+	return r, correctSignSqrt | flippedSignSqrt
+}
diff --git a/src/crypto/ed25519/internal/edwards25519/field/fe_alias_test.go b/src/crypto/ed25519/internal/edwards25519/field/fe_alias_test.go
new file mode 100644
index 0000000000..5ad81df013
--- /dev/null
+++ b/src/crypto/ed25519/internal/edwards25519/field/fe_alias_test.go
@@ -0,0 +1,126 @@
+// Copyright (c) 2019 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 field
+
+import (
+	"testing"
+	"testing/quick"
+)
+
+func checkAliasingOneArg(f func(v, x *Element) *Element) func(v, x Element) bool {
+	return func(v, x Element) bool {
+		x1, v1 := x, x
+
+		// Calculate a reference f(x) without aliasing.
+		if out := f(&v, &x); out != &v && isInBounds(out) {
+			return false
+		}
+
+		// Test aliasing the argument and the receiver.
+		if out := f(&v1, &v1); out != &v1 || v1 != v {
+			return false
+		}
+
+		// Ensure the arguments was not modified.
+		return x == x1
+	}
+}
+
+func checkAliasingTwoArgs(f func(v, x, y *Element) *Element) func(v, x, y Element) bool {
+	return func(v, x, y Element) bool {
+		x1, y1, v1 := x, y, Element{}
+
+		// Calculate a reference f(x, y) without aliasing.
+		if out := f(&v, &x, &y); out != &v && isInBounds(out) {
+			return false
+		}
+
+		// Test aliasing the first argument and the receiver.
+		v1 = x
+		if out := f(&v1, &v1, &y); out != &v1 || v1 != v {
+			return false
+		}
+		// Test aliasing the second argument and the receiver.
+		v1 = y
+		if out := f(&v1, &x, &v1); out != &v1 || v1 != v {
+			return false
+		}
+
+		// Calculate a reference f(x, x) without aliasing.
+		if out := f(&v, &x, &x); out != &v {
+			return false
+		}
+
+		// Test aliasing the first argument and the receiver.
+		v1 = x
+		if out := f(&v1, &v1, &x); out != &v1 || v1 != v {
+			return false
+		}
+		// Test aliasing the second argument and the receiver.
+		v1 = x
+		if out := f(&v1, &x, &v1); out != &v1 || v1 != v {
+			return false
+		}
+		// Test aliasing both arguments and the receiver.
+		v1 = x
+		if out := f(&v1, &v1, &v1); out != &v1 || v1 != v {
+			return false
+		}
+
+		// Ensure the arguments were not modified.
+		return x == x1 && y == y1
+	}
+}
+
+// TestAliasing checks that receivers and arguments can alias each other without
+// leading to incorrect results. That is, it ensures that it's safe to write
+//
+//     v.Invert(v)
+//
+// or
+//
+//     v.Add(v, v)
+//
+// without any of the inputs getting clobbered by the output being written.
+func TestAliasing(t *testing.T) {
+	type target struct {
+		name     string
+		oneArgF  func(v, x *Element) *Element
+		twoArgsF func(v, x, y *Element) *Element
+	}
+	for _, tt := range []target{
+		{name: "Absolute", oneArgF: (*Element).Absolute},
+		{name: "Invert", oneArgF: (*Element).Invert},
+		{name: "Negate", oneArgF: (*Element).Negate},
+		{name: "Set", oneArgF: (*Element).Set},
+		{name: "Square", oneArgF: (*Element).Square},
+		{name: "Multiply", twoArgsF: (*Element).Multiply},
+		{name: "Add", twoArgsF: (*Element).Add},
+		{name: "Subtract", twoArgsF: (*Element).Subtract},
+		{
+			name: "Select0",
+			twoArgsF: func(v, x, y *Element) *Element {
+				return (*Element).Select(v, x, y, 0)
+			},
+		},
+		{
+			name: "Select1",
+			twoArgsF: func(v, x, y *Element) *Element {
+				return (*Element).Select(v, x, y, 1)
+			},
+		},
+	} {
+		var err error
+		switch {
+		case tt.oneArgF != nil:
+			err = quick.Check(checkAliasingOneArg(tt.oneArgF), &quick.Config{MaxCountScale: 1 << 8})
+		case tt.twoArgsF != nil:
+			err = quick.Check(checkAliasingTwoArgs(tt.twoArgsF), &quick.Config{MaxCountScale: 1 << 8})
+		}
+		if err != nil {
+			t.Errorf("%v: %v", tt.name, err)
+		}
+	}
+}
diff --git a/src/crypto/ed25519/internal/edwards25519/field/fe_amd64.go b/src/crypto/ed25519/internal/edwards25519/field/fe_amd64.go
new file mode 100644
index 0000000000..44dc8e8caf
--- /dev/null
+++ b/src/crypto/ed25519/internal/edwards25519/field/fe_amd64.go
@@ -0,0 +1,13 @@
+// Code generated by command: go run fe_amd64_asm.go -out ../fe_amd64.s -stubs ../fe_amd64.go -pkg field. DO NOT EDIT.
+
+// +build amd64,gc,!purego
+
+package field
+
+// feMul sets out = a * b. It works like feMulGeneric.
+//go:noescape
+func feMul(out *Element, a *Element, b *Element)
+
+// feSquare sets out = a * a. It works like feSquareGeneric.
+//go:noescape
+func feSquare(out *Element, a *Element)
diff --git a/src/crypto/ed25519/internal/edwards25519/field/fe_amd64.s b/src/crypto/ed25519/internal/edwards25519/field/fe_amd64.s
new file mode 100644
index 0000000000..0aa1e86d98
--- /dev/null
+++ b/src/crypto/ed25519/internal/edwards25519/field/fe_amd64.s
@@ -0,0 +1,378 @@
+// Code generated by command: go run fe_amd64_asm.go -out ../fe_amd64.s -stubs ../fe_amd64.go -pkg field. DO NOT EDIT.
+
+// +build amd64,gc,!purego
+
+#include "textflag.h"
+
+// func feMul(out *Element, a *Element, b *Element)
+TEXT ·feMul(SB), NOSPLIT, $0-24
+	MOVQ a+8(FP), CX
+	MOVQ b+16(FP), BX
+
+	// r0 = a0×b0
+	MOVQ (CX), AX
+	MULQ (BX)
+	MOVQ AX, DI
+	MOVQ DX, SI
+
+	// r0 += 19×a1×b4
+	MOVQ   8(CX), AX
+	IMUL3Q $0x13, AX, AX
+	MULQ   32(BX)
+	ADDQ   AX, DI
+	ADCQ   DX, SI
+
+	// r0 += 19×a2×b3
+	MOVQ   16(CX), AX
+	IMUL3Q $0x13, AX, AX
+	MULQ   24(BX)
+	ADDQ   AX, DI
+	ADCQ   DX, SI
+
+	// r0 += 19×a3×b2
+	MOVQ   24(CX), AX
+	IMUL3Q $0x13, AX, AX
+	MULQ   16(BX)
+	ADDQ   AX, DI
+	ADCQ   DX, SI
+
+	// r0 += 19×a4×b1
+	MOVQ   32(CX), AX
+	IMUL3Q $0x13, AX, AX
+	MULQ   8(BX)
+	ADDQ   AX, DI
+	ADCQ   DX, SI
+
+	// r1 = a0×b1
+	MOVQ (CX), AX
+	MULQ 8(BX)
+	MOVQ AX, R9
+	MOVQ DX, R8
+
+	// r1 += a1×b0
+	MOVQ 8(CX), AX
+	MULQ (BX)
+	ADDQ AX, R9
+	ADCQ DX, R8
+
+	// r1 += 19×a2×b4
+	MOVQ   16(CX), AX
+	IMUL3Q $0x13, AX, AX
+	MULQ   32(BX)
+	ADDQ   AX, R9
+	ADCQ   DX, R8
+
+	// r1 += 19×a3×b3
+	MOVQ   24(CX), AX
+	IMUL3Q $0x13, AX, AX
+	MULQ   24(BX)
+	ADDQ   AX, R9
+	ADCQ   DX, R8
+
+	// r1 += 19×a4×b2
+	MOVQ   32(CX), AX
+	IMUL3Q $0x13, AX, AX
+	MULQ   16(BX)
+	ADDQ   AX, R9
+	ADCQ   DX, R8
+
+	// r2 = a0×b2
+	MOVQ (CX), AX
+	MULQ 16(BX)
+	MOVQ AX, R11
+	MOVQ DX, R10
+
+	// r2 += a1×b1
+	MOVQ 8(CX), AX
+	MULQ 8(BX)
+	ADDQ AX, R11
+	ADCQ DX, R10
+
+	// r2 += a2×b0
+	MOVQ 16(CX), AX
+	MULQ (BX)
+	ADDQ AX, R11
+	ADCQ DX, R10
+
+	// r2 += 19×a3×b4
+	MOVQ   24(CX), AX
+	IMUL3Q $0x13, AX, AX
+	MULQ   32(BX)
+	ADDQ   AX, R11
+	ADCQ   DX, R10
+
+	// r2 += 19×a4×b3
+	MOVQ   32(CX), AX
+	IMUL3Q $0x13, AX, AX
+	MULQ   24(BX)
+	ADDQ   AX, R11
+	ADCQ   DX, R10
+
+	// r3 = a0×b3
+	MOVQ (CX), AX
+	MULQ 24(BX)
+	MOVQ AX, R13
+	MOVQ DX, R12
+
+	// r3 += a1×b2
+	MOVQ 8(CX), AX
+	MULQ 16(BX)
+	ADDQ AX, R13
+	ADCQ DX, R12
+
+	// r3 += a2×b1
+	MOVQ 16(CX), AX
+	MULQ 8(BX)
+	ADDQ AX, R13
+	ADCQ DX, R12
+
+	// r3 += a3×b0
+	MOVQ 24(CX), AX
+	MULQ (BX)
+	ADDQ AX, R13
+	ADCQ DX, R12
+
+	// r3 += 19×a4×b4
+	MOVQ   32(CX), AX
+	IMUL3Q $0x13, AX, AX
+	MULQ   32(BX)
+	ADDQ   AX, R13
+	ADCQ   DX, R12
+
+	// r4 = a0×b4
+	MOVQ (CX), AX
+	MULQ 32(BX)
+	MOVQ AX, R15
+	MOVQ DX, R14
+
+	// r4 += a1×b3
+	MOVQ 8(CX), AX
+	MULQ 24(BX)
+	ADDQ AX, R15
+	ADCQ DX, R14
+
+	// r4 += a2×b2
+	MOVQ 16(CX), AX
+	MULQ 16(BX)
+	ADDQ AX, R15
+	ADCQ DX, R14
+
+	// r4 += a3×b1
+	MOVQ 24(CX), AX
+	MULQ 8(BX)
+	ADDQ AX, R15
+	ADCQ DX, R14
+
+	// r4 += a4×b0
+	MOVQ 32(CX), AX
+	MULQ (BX)
+	ADDQ AX, R15
+	ADCQ DX, R14
+
+	// First reduction chain
+	MOVQ   $0x0007ffffffffffff, AX
+	SHLQ   $0x0d, DI, SI
+	SHLQ   $0x0d, R9, R8
+	SHLQ   $0x0d, R11, R10
+	SHLQ   $0x0d, R13, R12
+	SHLQ   $0x0d, R15, R14
+	ANDQ   AX, DI
+	IMUL3Q $0x13, R14, R14
+	ADDQ   R14, DI
+	ANDQ   AX, R9
+	ADDQ   SI, R9
+	ANDQ   AX, R11
+	ADDQ   R8, R11
+	ANDQ   AX, R13
+	ADDQ   R10, R13
+	ANDQ   AX, R15
+	ADDQ   R12, R15
+
+	// Second reduction chain (carryPropagate)
+	MOVQ   DI, SI
+	SHRQ   $0x33, SI
+	MOVQ   R9, R8
+	SHRQ   $0x33, R8
+	MOVQ   R11, R10
+	SHRQ   $0x33, R10
+	MOVQ   R13, R12
+	SHRQ   $0x33, R12
+	MOVQ   R15, R14
+	SHRQ   $0x33, R14
+	ANDQ   AX, DI
+	IMUL3Q $0x13, R14, R14
+	ADDQ   R14, DI
+	ANDQ   AX, R9
+	ADDQ   SI, R9
+	ANDQ   AX, R11
+	ADDQ   R8, R11
+	ANDQ   AX, R13
+	ADDQ   R10, R13
+	ANDQ   AX, R15
+	ADDQ   R12, R15
+
+	// Store output
+	MOVQ out+0(FP), AX
+	MOVQ DI, (AX)
+	MOVQ R9, 8(AX)
+	MOVQ R11, 16(AX)
+	MOVQ R13, 24(AX)
+	MOVQ R15, 32(AX)
+	RET
+
+// func feSquare(out *Element, a *Element)
+TEXT ·feSquare(SB), NOSPLIT, $0-16
+	MOVQ a+8(FP), CX
+
+	// r0 = l0×l0
+	MOVQ (CX), AX
+	MULQ (CX)
+	MOVQ AX, SI
+	MOVQ DX, BX
+
+	// r0 += 38×l1×l4
+	MOVQ   8(CX), AX
+	IMUL3Q $0x26, AX, AX
+	MULQ   32(CX)
+	ADDQ   AX, SI
+	ADCQ   DX, BX
+
+	// r0 += 38×l2×l3
+	MOVQ   16(CX), AX
+	IMUL3Q $0x26, AX, AX
+	MULQ   24(CX)
+	ADDQ   AX, SI
+	ADCQ   DX, BX
+
+	// r1 = 2×l0×l1
+	MOVQ (CX), AX
+	SHLQ $0x01, AX
+	MULQ 8(CX)
+	MOVQ AX, R8
+	MOVQ DX, DI
+
+	// r1 += 38×l2×l4
+	MOVQ   16(CX), AX
+	IMUL3Q $0x26, AX, AX
+	MULQ   32(CX)
+	ADDQ   AX, R8
+	ADCQ   DX, DI
+
+	// r1 += 19×l3×l3
+	MOVQ   24(CX), AX
+	IMUL3Q $0x13, AX, AX
+	MULQ   24(CX)
+	ADDQ   AX, R8
+	ADCQ   DX, DI
+
+	// r2 = 2×l0×l2
+	MOVQ (CX), AX
+	SHLQ $0x01, AX
+	MULQ 16(CX)
+	MOVQ AX, R10
+	MOVQ DX, R9
+
+	// r2 += l1×l1
+	MOVQ 8(CX), AX
+	MULQ 8(CX)
+	ADDQ AX, R10
+	ADCQ DX, R9
+
+	// r2 += 38×l3×l4
+	MOVQ   24(CX), AX
+	IMUL3Q $0x26, AX, AX
+	MULQ   32(CX)
+	ADDQ   AX, R10
+	ADCQ   DX, R9
+
+	// r3 = 2×l0×l3
+	MOVQ (CX), AX
+	SHLQ $0x01, AX
+	MULQ 24(CX)
+	MOVQ AX, R12
+	MOVQ DX, R11
+
+	// r3 += 2×l1×l2
+	MOVQ   8(CX), AX
+	IMUL3Q $0x02, AX, AX
+	MULQ   16(CX)
+	ADDQ   AX, R12
+	ADCQ   DX, R11
+
+	// r3 += 19×l4×l4
+	MOVQ   32(CX), AX
+	IMUL3Q $0x13, AX, AX
+	MULQ   32(CX)
+	ADDQ   AX, R12
+	ADCQ   DX, R11
+
+	// r4 = 2×l0×l4
+	MOVQ (CX), AX
+	SHLQ $0x01, AX
+	MULQ 32(CX)
+	MOVQ AX, R14
+	MOVQ DX, R13
+
+	// r4 += 2×l1×l3
+	MOVQ   8(CX), AX
+	IMUL3Q $0x02, AX, AX
+	MULQ   24(CX)
+	ADDQ   AX, R14
+	ADCQ   DX, R13
+
+	// r4 += l2×l2
+	MOVQ 16(CX), AX
+	MULQ 16(CX)
+	ADDQ AX, R14
+	ADCQ DX, R13
+
+	// First reduction chain
+	MOVQ   $0x0007ffffffffffff, AX
+	SHLQ   $0x0d, SI, BX
+	SHLQ   $0x0d, R8, DI
+	SHLQ   $0x0d, R10, R9
+	SHLQ   $0x0d, R12, R11
+	SHLQ   $0x0d, R14, R13
+	ANDQ   AX, SI
+	IMUL3Q $0x13, R13, R13
+	ADDQ   R13, SI
+	ANDQ   AX, R8
+	ADDQ   BX, R8
+	ANDQ   AX, R10
+	ADDQ   DI, R10
+	ANDQ   AX, R12
+	ADDQ   R9, R12
+	ANDQ   AX, R14
+	ADDQ   R11, R14
+
+	// Second reduction chain (carryPropagate)
+	MOVQ   SI, BX
+	SHRQ   $0x33, BX
+	MOVQ   R8, DI
+	SHRQ   $0x33, DI
+	MOVQ   R10, R9
+	SHRQ   $0x33, R9
+	MOVQ   R12, R11
+	SHRQ   $0x33, R11
+	MOVQ   R14, R13
+	SHRQ   $0x33, R13
+	ANDQ   AX, SI
+	IMUL3Q $0x13, R13, R13
+	ADDQ   R13, SI
+	ANDQ   AX, R8
+	ADDQ   BX, R8
+	ANDQ   AX, R10
+	ADDQ   DI, R10
+	ANDQ   AX, R12
+	ADDQ   R9, R12
+	ANDQ   AX, R14
+	ADDQ   R11, R14
+
+	// Store output
+	MOVQ out+0(FP), AX
+	MOVQ SI, (AX)
+	MOVQ R8, 8(AX)
+	MOVQ R10, 16(AX)
+	MOVQ R12, 24(AX)
+	MOVQ R14, 32(AX)
+	RET
diff --git a/src/crypto/ed25519/internal/edwards25519/field/fe_amd64_noasm.go b/src/crypto/ed25519/internal/edwards25519/field/fe_amd64_noasm.go
new file mode 100644
index 0000000000..ddb6c9b8f7
--- /dev/null
+++ b/src/crypto/ed25519/internal/edwards25519/field/fe_amd64_noasm.go
@@ -0,0 +1,12 @@
+// Copyright (c) 2019 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.
+
+//go:build !amd64 || !gc || purego
+// +build !amd64 !gc purego
+
+package field
+
+func feMul(v, x, y *Element) { feMulGeneric(v, x, y) }
+
+func feSquare(v, x *Element) { feSquareGeneric(v, x) }
diff --git a/src/crypto/ed25519/internal/edwards25519/field/fe_arm64.go b/src/crypto/ed25519/internal/edwards25519/field/fe_arm64.go
new file mode 100644
index 0000000000..af459ef515
--- /dev/null
+++ b/src/crypto/ed25519/internal/edwards25519/field/fe_arm64.go
@@ -0,0 +1,16 @@
+// Copyright (c) 2020 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.
+
+//go:build arm64 && gc && !purego
+// +build arm64,gc,!purego
+
+package field
+
+//go:noescape
+func carryPropagate(v *Element)
+
+func (v *Element) carryPropagate() *Element {
+	carryPropagate(v)
+	return v
+}
diff --git a/src/crypto/ed25519/internal/edwards25519/field/fe_arm64.s b/src/crypto/ed25519/internal/edwards25519/field/fe_arm64.s
new file mode 100644
index 0000000000..751ab2ada3
--- /dev/null
+++ b/src/crypto/ed25519/internal/edwards25519/field/fe_arm64.s
@@ -0,0 +1,42 @@
+// Copyright (c) 2020 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.
+
+// +build arm64,gc,!purego
+
+#include "textflag.h"
+
+// carryPropagate works exactly like carryPropagateGeneric and uses the
+// same AND, ADD, and LSR+MADD instructions emitted by the compiler, but
+// avoids loading R0-R4 twice and uses LDP and STP.
+//
+// See https://golang.org/issues/43145 for the main compiler issue.
+//
+// func carryPropagate(v *Element)
+TEXT ·carryPropagate(SB),NOFRAME|NOSPLIT,$0-8
+	MOVD v+0(FP), R20
+
+	LDP 0(R20), (R0, R1)
+	LDP 16(R20), (R2, R3)
+	MOVD 32(R20), R4
+
+	AND $0x7ffffffffffff, R0, R10
+	AND $0x7ffffffffffff, R1, R11
+	AND $0x7ffffffffffff, R2, R12
+	AND $0x7ffffffffffff, R3, R13
+	AND $0x7ffffffffffff, R4, R14
+
+	ADD R0>>51, R11, R11
+	ADD R1>>51, R12, R12
+	ADD R2>>51, R13, R13
+	ADD R3>>51, R14, R14
+	// R4>>51 * 19 + R10 -> R10
+	LSR $51, R4, R21
+	MOVD $19, R22
+	MADD R22, R10, R21, R10
+
+	STP (R10, R11), 0(R20)
+	STP (R12, R13), 16(R20)
+	MOVD R14, 32(R20)
+
+	RET
diff --git a/src/crypto/ed25519/internal/edwards25519/field/fe_arm64_noasm.go b/src/crypto/ed25519/internal/edwards25519/field/fe_arm64_noasm.go
new file mode 100644
index 0000000000..234a5b2e5d
--- /dev/null
+++ b/src/crypto/ed25519/internal/edwards25519/field/fe_arm64_noasm.go
@@ -0,0 +1,12 @@
+// Copyright (c) 2021 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.
+
+//go:build !arm64 || !gc || purego
+// +build !arm64 !gc purego
+
+package field
+
+func (v *Element) carryPropagate() *Element {
+	return v.carryPropagateGeneric()
+}
diff --git a/src/crypto/ed25519/internal/edwards25519/field/fe_bench_test.go b/src/crypto/ed25519/internal/edwards25519/field/fe_bench_test.go
new file mode 100644
index 0000000000..77dc06cf98
--- /dev/null
+++ b/src/crypto/ed25519/internal/edwards25519/field/fe_bench_test.go
@@ -0,0 +1,36 @@
+// Copyright (c) 2019 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 field
+
+import "testing"
+
+func BenchmarkAdd(b *testing.B) {
+	var x, y Element
+	x.One()
+	y.Add(feOne, feOne)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		x.Add(&x, &y)
+	}
+}
+
+func BenchmarkMultiply(b *testing.B) {
+	var x, y Element
+	x.One()
+	y.Add(feOne, feOne)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		x.Multiply(&x, &y)
+	}
+}
+
+func BenchmarkMult32(b *testing.B) {
+	var x Element
+	x.One()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		x.Mult32(&x, 0xaa42aa42)
+	}
+}
diff --git a/src/crypto/ed25519/internal/edwards25519/field/fe_generic.go b/src/crypto/ed25519/internal/edwards25519/field/fe_generic.go
new file mode 100644
index 0000000000..bccf8511ac
--- /dev/null
+++ b/src/crypto/ed25519/internal/edwards25519/field/fe_generic.go
@@ -0,0 +1,264 @@
+// Copyright (c) 2017 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 field
+
+import "math/bits"
+
+// uint128 holds a 128-bit number as two 64-bit limbs, for use with the
+// bits.Mul64 and bits.Add64 intrinsics.
+type uint128 struct {
+	lo, hi uint64
+}
+
+// mul64 returns a * b.
+func mul64(a, b uint64) uint128 {
+	hi, lo := bits.Mul64(a, b)
+	return uint128{lo, hi}
+}
+
+// addMul64 returns v + a * b.
+func addMul64(v uint128, a, b uint64) uint128 {
+	hi, lo := bits.Mul64(a, b)
+	lo, c := bits.Add64(lo, v.lo, 0)
+	hi, _ = bits.Add64(hi, v.hi, c)
+	return uint128{lo, hi}
+}
+
+// shiftRightBy51 returns a >> 51. a is assumed to be at most 115 bits.
+func shiftRightBy51(a uint128) uint64 {
+	return (a.hi << (64 - 51)) | (a.lo >> 51)
+}
+
+func feMulGeneric(v, a, b *Element) {
+	a0 := a.l0
+	a1 := a.l1
+	a2 := a.l2
+	a3 := a.l3
+	a4 := a.l4
+
+	b0 := b.l0
+	b1 := b.l1
+	b2 := b.l2
+	b3 := b.l3
+	b4 := b.l4
+
+	// Limb multiplication works like pen-and-paper columnar multiplication, but
+	// with 51-bit limbs instead of digits.
+	//
+	//                          a4   a3   a2   a1   a0  x
+	//                          b4   b3   b2   b1   b0  =
+	//                         ------------------------
+	//                        a4b0 a3b0 a2b0 a1b0 a0b0  +
+	//                   a4b1 a3b1 a2b1 a1b1 a0b1       +
+	//              a4b2 a3b2 a2b2 a1b2 a0b2            +
+	//         a4b3 a3b3 a2b3 a1b3 a0b3                 +
+	//    a4b4 a3b4 a2b4 a1b4 a0b4                      =
+	//   ----------------------------------------------
+	//      r8   r7   r6   r5   r4   r3   r2   r1   r0
+	//
+	// We can then use the reduction identity (a * 2²⁵⁵ + b = a * 19 + b) to
+	// reduce the limbs that would overflow 255 bits. r5 * 2²⁵⁵ becomes 19 * r5,
+	// r6 * 2³⁰⁶ becomes 19 * r6 * 2⁵¹, etc.
+	//
+	// Reduction can be carried out simultaneously to multiplication. For
+	// example, we do not compute r5: whenever the result of a multiplication
+	// belongs to r5, like a1b4, we multiply it by 19 and add the result to r0.
+	//
+	//            a4b0    a3b0    a2b0    a1b0    a0b0  +
+	//            a3b1    a2b1    a1b1    a0b1 19×a4b1  +
+	//            a2b2    a1b2    a0b2 19×a4b2 19×a3b2  +
+	//            a1b3    a0b3 19×a4b3 19×a3b3 19×a2b3  +
+	//            a0b4 19×a4b4 19×a3b4 19×a2b4 19×a1b4  =
+	//           --------------------------------------
+	//              r4      r3      r2      r1      r0
+	//
+	// Finally we add up the columns into wide, overlapping limbs.
+
+	a1_19 := a1 * 19
+	a2_19 := a2 * 19
+	a3_19 := a3 * 19
+	a4_19 := a4 * 19
+
+	// r0 = a0×b0 + 19×(a1×b4 + a2×b3 + a3×b2 + a4×b1)
+	r0 := mul64(a0, b0)
+	r0 = addMul64(r0, a1_19, b4)
+	r0 = addMul64(r0, a2_19, b3)
+	r0 = addMul64(r0, a3_19, b2)
+	r0 = addMul64(r0, a4_19, b1)
+
+	// r1 = a0×b1 + a1×b0 + 19×(a2×b4 + a3×b3 + a4×b2)
+	r1 := mul64(a0, b1)
+	r1 = addMul64(r1, a1, b0)
+	r1 = addMul64(r1, a2_19, b4)
+	r1 = addMul64(r1, a3_19, b3)
+	r1 = addMul64(r1, a4_19, b2)
+
+	// r2 = a0×b2 + a1×b1 + a2×b0 + 19×(a3×b4 + a4×b3)
+	r2 := mul64(a0, b2)
+	r2 = addMul64(r2, a1, b1)
+	r2 = addMul64(r2, a2, b0)
+	r2 = addMul64(r2, a3_19, b4)
+	r2 = addMul64(r2, a4_19, b3)
+
+	// r3 = a0×b3 + a1×b2 + a2×b1 + a3×b0 + 19×a4×b4
+	r3 := mul64(a0, b3)
+	r3 = addMul64(r3, a1, b2)
+	r3 = addMul64(r3, a2, b1)
+	r3 = addMul64(r3, a3, b0)
+	r3 = addMul64(r3, a4_19, b4)
+
+	// r4 = a0×b4 + a1×b3 + a2×b2 + a3×b1 + a4×b0
+	r4 := mul64(a0, b4)
+	r4 = addMul64(r4, a1, b3)
+	r4 = addMul64(r4, a2, b2)
+	r4 = addMul64(r4, a3, b1)
+	r4 = addMul64(r4, a4, b0)
+
+	// After the multiplication, we need to reduce (carry) the five coefficients
+	// to obtain a result with limbs that are at most slightly larger than 2⁵¹,
+	// to respect the Element invariant.
+	//
+	// Overall, the reduction works the same as carryPropagate, except with
+	// wider inputs: we take the carry for each coefficient by shifting it right
+	// by 51, and add it to the limb above it. The top carry is multiplied by 19
+	// according to the reduction identity and added to the lowest limb.
+	//
+	// The largest coefficient (r0) will be at most 111 bits, which guarantees
+	// that all carries are at most 111 - 51 = 60 bits, which fits in a uint64.
+	//
+	//     r0 = a0×b0 + 19×(a1×b4 + a2×b3 + a3×b2 + a4×b1)
+	//     r0 < 2⁵²×2⁵² + 19×(2⁵²×2⁵² + 2⁵²×2⁵² + 2⁵²×2⁵² + 2⁵²×2⁵²)
+	//     r0 < (1 + 19 × 4) × 2⁵² × 2⁵²
+	//     r0 < 2⁷ × 2⁵² × 2⁵²
+	//     r0 < 2¹¹¹
+	//
+	// Moreover, the top coefficient (r4) is at most 107 bits, so c4 is at most
+	// 56 bits, and c4 * 19 is at most 61 bits, which again fits in a uint64 and
+	// allows us to easily apply the reduction identity.
+	//
+	//     r4 = a0×b4 + a1×b3 + a2×b2 + a3×b1 + a4×b0
+	//     r4 < 5 × 2⁵² × 2⁵²
+	//     r4 < 2¹⁰⁷
+	//
+
+	c0 := shiftRightBy51(r0)
+	c1 := shiftRightBy51(r1)
+	c2 := shiftRightBy51(r2)
+	c3 := shiftRightBy51(r3)
+	c4 := shiftRightBy51(r4)
+
+	rr0 := r0.lo&maskLow51Bits + c4*19
+	rr1 := r1.lo&maskLow51Bits + c0
+	rr2 := r2.lo&maskLow51Bits + c1
+	rr3 := r3.lo&maskLow51Bits + c2
+	rr4 := r4.lo&maskLow51Bits + c3
+
+	// Now all coefficients fit into 64-bit registers but are still too large to
+	// be passed around as a Element. We therefore do one last carry chain,
+	// where the carries will be small enough to fit in the wiggle room above 2⁵¹.
+	*v = Element{rr0, rr1, rr2, rr3, rr4}
+	v.carryPropagate()
+}
+
+func feSquareGeneric(v, a *Element) {
+	l0 := a.l0
+	l1 := a.l1
+	l2 := a.l2
+	l3 := a.l3
+	l4 := a.l4
+
+	// Squaring works precisely like multiplication above, but thanks to its
+	// symmetry we get to group a few terms together.
+	//
+	//                          l4   l3   l2   l1   l0  x
+	//                          l4   l3   l2   l1   l0  =
+	//                         ------------------------
+	//                        l4l0 l3l0 l2l0 l1l0 l0l0  +
+	//                   l4l1 l3l1 l2l1 l1l1 l0l1       +
+	//              l4l2 l3l2 l2l2 l1l2 l0l2            +
+	//         l4l3 l3l3 l2l3 l1l3 l0l3                 +
+	//    l4l4 l3l4 l2l4 l1l4 l0l4                      =
+	//   ----------------------------------------------
+	//      r8   r7   r6   r5   r4   r3   r2   r1   r0
+	//
+	//            l4l0    l3l0    l2l0    l1l0    l0l0  +
+	//            l3l1    l2l1    l1l1    l0l1 19×l4l1  +
+	//            l2l2    l1l2    l0l2 19×l4l2 19×l3l2  +
+	//            l1l3    l0l3 19×l4l3 19×l3l3 19×l2l3  +
+	//            l0l4 19×l4l4 19×l3l4 19×l2l4 19×l1l4  =
+	//           --------------------------------------
+	//              r4      r3      r2      r1      r0
+	//
+	// With precomputed 2×, 19×, and 2×19× terms, we can compute each limb with
+	// only three Mul64 and four Add64, instead of five and eight.
+
+	l0_2 := l0 * 2
+	l1_2 := l1 * 2
+
+	l1_38 := l1 * 38
+	l2_38 := l2 * 38
+	l3_38 := l3 * 38
+
+	l3_19 := l3 * 19
+	l4_19 := l4 * 19
+
+	// r0 = l0×l0 + 19×(l1×l4 + l2×l3 + l3×l2 + l4×l1) = l0×l0 + 19×2×(l1×l4 + l2×l3)
+	r0 := mul64(l0, l0)
+	r0 = addMul64(r0, l1_38, l4)
+	r0 = addMul64(r0, l2_38, l3)
+
+	// r1 = l0×l1 + l1×l0 + 19×(l2×l4 + l3×l3 + l4×l2) = 2×l0×l1 + 19×2×l2×l4 + 19×l3×l3
+	r1 := mul64(l0_2, l1)
+	r1 = addMul64(r1, l2_38, l4)
+	r1 = addMul64(r1, l3_19, l3)
+
+	// r2 = l0×l2 + l1×l1 + l2×l0 + 19×(l3×l4 + l4×l3) = 2×l0×l2 + l1×l1 + 19×2×l3×l4
+	r2 := mul64(l0_2, l2)
+	r2 = addMul64(r2, l1, l1)
+	r2 = addMul64(r2, l3_38, l4)
+
+	// r3 = l0×l3 + l1×l2 + l2×l1 + l3×l0 + 19×l4×l4 = 2×l0×l3 + 2×l1×l2 + 19×l4×l4
+	r3 := mul64(l0_2, l3)
+	r3 = addMul64(r3, l1_2, l2)
+	r3 = addMul64(r3, l4_19, l4)
+
+	// r4 = l0×l4 + l1×l3 + l2×l2 + l3×l1 + l4×l0 = 2×l0×l4 + 2×l1×l3 + l2×l2
+	r4 := mul64(l0_2, l4)
+	r4 = addMul64(r4, l1_2, l3)
+	r4 = addMul64(r4, l2, l2)
+
+	c0 := shiftRightBy51(r0)
+	c1 := shiftRightBy51(r1)
+	c2 := shiftRightBy51(r2)
+	c3 := shiftRightBy51(r3)
+	c4 := shiftRightBy51(r4)
+
+	rr0 := r0.lo&maskLow51Bits + c4*19
+	rr1 := r1.lo&maskLow51Bits + c0
+	rr2 := r2.lo&maskLow51Bits + c1
+	rr3 := r3.lo&maskLow51Bits + c2
+	rr4 := r4.lo&maskLow51Bits + c3
+
+	*v = Element{rr0, rr1, rr2, rr3, rr4}
+	v.carryPropagate()
+}
+
+// carryPropagate brings the limbs below 52 bits by applying the reduction
+// identity (a * 2²⁵⁵ + b = a * 19 + b) to the l4 carry.
+func (v *Element) carryPropagateGeneric() *Element {
+	c0 := v.l0 >> 51
+	c1 := v.l1 >> 51
+	c2 := v.l2 >> 51
+	c3 := v.l3 >> 51
+	c4 := v.l4 >> 51
+
+	v.l0 = v.l0&maskLow51Bits + c4*19
+	v.l1 = v.l1&maskLow51Bits + c0
+	v.l2 = v.l2&maskLow51Bits + c1
+	v.l3 = v.l3&maskLow51Bits + c2
+	v.l4 = v.l4&maskLow51Bits + c3
+
+	return v
+}
diff --git a/src/crypto/ed25519/internal/edwards25519/field/fe_test.go b/src/crypto/ed25519/internal/edwards25519/field/fe_test.go
new file mode 100644
index 0000000000..b484459ff2
--- /dev/null
+++ b/src/crypto/ed25519/internal/edwards25519/field/fe_test.go
@@ -0,0 +1,558 @@
+// Copyright (c) 2017 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 field
+
+import (
+	"bytes"
+	"crypto/rand"
+	"encoding/hex"
+	"io"
+	"math/big"
+	"math/bits"
+	mathrand "math/rand"
+	"reflect"
+	"testing"
+	"testing/quick"
+)
+
+func (v Element) String() string {
+	return hex.EncodeToString(v.Bytes())
+}
+
+// quickCheckConfig1024 will make each quickcheck test run (1024 * -quickchecks)
+// times. The default value of -quickchecks is 100.
+var quickCheckConfig1024 = &quick.Config{MaxCountScale: 1 << 10}
+
+func generateFieldElement(rand *mathrand.Rand) Element {
+	const maskLow52Bits = (1 << 52) - 1
+	return Element{
+		rand.Uint64() & maskLow52Bits,
+		rand.Uint64() & maskLow52Bits,
+		rand.Uint64() & maskLow52Bits,
+		rand.Uint64() & maskLow52Bits,
+		rand.Uint64() & maskLow52Bits,
+	}
+}
+
+// weirdLimbs can be combined to generate a range of edge-case field elements.
+// 0 and -1 are intentionally more weighted, as they combine well.
+var (
+	weirdLimbs51 = []uint64{
+		0, 0, 0, 0,
+		1,
+		19 - 1,
+		19,
+		0x2aaaaaaaaaaaa,
+		0x5555555555555,
+		(1 << 51) - 20,
+		(1 << 51) - 19,
+		(1 << 51) - 1, (1 << 51) - 1,
+		(1 << 51) - 1, (1 << 51) - 1,
+	}
+	weirdLimbs52 = []uint64{
+		0, 0, 0, 0, 0, 0,
+		1,
+		19 - 1,
+		19,
+		0x2aaaaaaaaaaaa,
+		0x5555555555555,
+		(1 << 51) - 20,
+		(1 << 51) - 19,
+		(1 << 51) - 1, (1 << 51) - 1,
+		(1 << 51) - 1, (1 << 51) - 1,
+		(1 << 51) - 1, (1 << 51) - 1,
+		1 << 51,
+		(1 << 51) + 1,
+		(1 << 52) - 19,
+		(1 << 52) - 1,
+	}
+)
+
+func generateWeirdFieldElement(rand *mathrand.Rand) Element {
+	return Element{
+		weirdLimbs52[rand.Intn(len(weirdLimbs52))],
+		weirdLimbs51[rand.Intn(len(weirdLimbs51))],
+		weirdLimbs51[rand.Intn(len(weirdLimbs51))],
+		weirdLimbs51[rand.Intn(len(weirdLimbs51))],
+		weirdLimbs51[rand.Intn(len(weirdLimbs51))],
+	}
+}
+
+func (Element) Generate(rand *mathrand.Rand, size int) reflect.Value {
+	if rand.Intn(2) == 0 {
+		return reflect.ValueOf(generateWeirdFieldElement(rand))
+	}
+	return reflect.ValueOf(generateFieldElement(rand))
+}
+
+// isInBounds returns whether the element is within the expected bit size bounds
+// after a light reduction.
+func isInBounds(x *Element) bool {
+	return bits.Len64(x.l0) <= 52 &&
+		bits.Len64(x.l1) <= 52 &&
+		bits.Len64(x.l2) <= 52 &&
+		bits.Len64(x.l3) <= 52 &&
+		bits.Len64(x.l4) <= 52
+}
+
+func TestMultiplyDistributesOverAdd(t *testing.T) {
+	multiplyDistributesOverAdd := func(x, y, z Element) bool {
+		// Compute t1 = (x+y)*z
+		t1 := new(Element)
+		t1.Add(&x, &y)
+		t1.Multiply(t1, &z)
+
+		// Compute t2 = x*z + y*z
+		t2 := new(Element)
+		t3 := new(Element)
+		t2.Multiply(&x, &z)
+		t3.Multiply(&y, &z)
+		t2.Add(t2, t3)
+
+		return t1.Equal(t2) == 1 && isInBounds(t1) && isInBounds(t2)
+	}
+
+	if err := quick.Check(multiplyDistributesOverAdd, quickCheckConfig1024); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestMul64to128(t *testing.T) {
+	a := uint64(5)
+	b := uint64(5)
+	r := mul64(a, b)
+	if r.lo != 0x19 || r.hi != 0 {
+		t.Errorf("lo-range wide mult failed, got %d + %d*(2**64)", r.lo, r.hi)
+	}
+
+	a = uint64(18014398509481983) // 2^54 - 1
+	b = uint64(18014398509481983) // 2^54 - 1
+	r = mul64(a, b)
+	if r.lo != 0xff80000000000001 || r.hi != 0xfffffffffff {
+		t.Errorf("hi-range wide mult failed, got %d + %d*(2**64)", r.lo, r.hi)
+	}
+
+	a = uint64(1125899906842661)
+	b = uint64(2097155)
+	r = mul64(a, b)
+	r = addMul64(r, a, b)
+	r = addMul64(r, a, b)
+	r = addMul64(r, a, b)
+	r = addMul64(r, a, b)
+	if r.lo != 16888498990613035 || r.hi != 640 {
+		t.Errorf("wrong answer: %d + %d*(2**64)", r.lo, r.hi)
+	}
+}
+
+func TestSetBytesRoundTrip(t *testing.T) {
+	f1 := func(in [32]byte, fe Element) bool {
+		fe.SetBytes(in[:])
+
+		// Mask the most significant bit as it's ignored by SetBytes. (Now
+		// instead of earlier so we check the masking in SetBytes is working.)
+		in[len(in)-1] &= (1 << 7) - 1
+
+		return bytes.Equal(in[:], fe.Bytes()) && isInBounds(&fe)
+	}
+	if err := quick.Check(f1, nil); err != nil {
+		t.Errorf("failed bytes->FE->bytes round-trip: %v", err)
+	}
+
+	f2 := func(fe, r Element) bool {
+		r.SetBytes(fe.Bytes())
+
+		// Intentionally not using Equal not to go through Bytes again.
+		// Calling reduce because both Generate and SetBytes can produce
+		// non-canonical representations.
+		fe.reduce()
+		r.reduce()
+		return fe == r
+	}
+	if err := quick.Check(f2, nil); err != nil {
+		t.Errorf("failed FE->bytes->FE round-trip: %v", err)
+	}
+
+	// Check some fixed vectors from dalek
+	type feRTTest struct {
+		fe Element
+		b  []byte
+	}
+	var tests = []feRTTest{
+		{
+			fe: Element{358744748052810, 1691584618240980, 977650209285361, 1429865912637724, 560044844278676},
+			b:  []byte{74, 209, 69, 197, 70, 70, 161, 222, 56, 226, 229, 19, 112, 60, 25, 92, 187, 74, 222, 56, 50, 153, 51, 233, 40, 74, 57, 6, 160, 185, 213, 31},
+		},
+		{
+			fe: Element{84926274344903, 473620666599931, 365590438845504, 1028470286882429, 2146499180330972},
+			b:  []byte{199, 23, 106, 112, 61, 77, 216, 79, 186, 60, 11, 118, 13, 16, 103, 15, 42, 32, 83, 250, 44, 57, 204, 198, 78, 199, 253, 119, 146, 172, 3, 122},
+		},
+	}
+
+	for _, tt := range tests {
+		b := tt.fe.Bytes()
+		if !bytes.Equal(b, tt.b) || new(Element).SetBytes(tt.b).Equal(&tt.fe) != 1 {
+			t.Errorf("Failed fixed roundtrip: %v", tt)
+		}
+	}
+}
+
+func swapEndianness(buf []byte) []byte {
+	for i := 0; i < len(buf)/2; i++ {
+		buf[i], buf[len(buf)-i-1] = buf[len(buf)-i-1], buf[i]
+	}
+	return buf
+}
+
+func TestBytesBigEquivalence(t *testing.T) {
+	f1 := func(in [32]byte, fe, fe1 Element) bool {
+		fe.SetBytes(in[:])
+
+		in[len(in)-1] &= (1 << 7) - 1 // mask the most significant bit
+		b := new(big.Int).SetBytes(swapEndianness(in[:]))
+		fe1.fromBig(b)
+
+		if fe != fe1 {
+			return false
+		}
+
+		buf := make([]byte, 32) // pad with zeroes
+		copy(buf, swapEndianness(fe1.toBig().Bytes()))
+
+		return bytes.Equal(fe.Bytes(), buf) && isInBounds(&fe) && isInBounds(&fe1)
+	}
+	if err := quick.Check(f1, nil); err != nil {
+		t.Error(err)
+	}
+}
+
+// fromBig sets v = n, and returns v. The bit length of n must not exceed 256.
+func (v *Element) fromBig(n *big.Int) *Element {
+	if n.BitLen() > 32*8 {
+		panic("edwards25519: invalid field element input size")
+	}
+
+	buf := make([]byte, 0, 32)
+	for _, word := range n.Bits() {
+		for i := 0; i < bits.UintSize; i += 8 {
+			if len(buf) >= cap(buf) {
+				break
+			}
+			buf = append(buf, byte(word))
+			word >>= 8
+		}
+	}
+
+	return v.SetBytes(buf[:32])
+}
+
+func (v *Element) fromDecimal(s string) *Element {
+	n, ok := new(big.Int).SetString(s, 10)
+	if !ok {
+		panic("not a valid decimal: " + s)
+	}
+	return v.fromBig(n)
+}
+
+// toBig returns v as a big.Int.
+func (v *Element) toBig() *big.Int {
+	buf := v.Bytes()
+
+	words := make([]big.Word, 32*8/bits.UintSize)
+	for n := range words {
+		for i := 0; i < bits.UintSize; i += 8 {
+			if len(buf) == 0 {
+				break
+			}
+			words[n] |= big.Word(buf[0]) << big.Word(i)
+			buf = buf[1:]
+		}
+	}
+
+	return new(big.Int).SetBits(words)
+}
+
+func TestDecimalConstants(t *testing.T) {
+	sqrtM1String := "19681161376707505956807079304988542015446066515923890162744021073123829784752"
+	if exp := new(Element).fromDecimal(sqrtM1String); sqrtM1.Equal(exp) != 1 {
+		t.Errorf("sqrtM1 is %v, expected %v", sqrtM1, exp)
+	}
+	// d is in the parent package, and we don't want to expose d or fromDecimal.
+	// dString := "37095705934669439343138083508754565189542113879843219016388785533085940283555"
+	// if exp := new(Element).fromDecimal(dString); d.Equal(exp) != 1 {
+	// 	t.Errorf("d is %v, expected %v", d, exp)
+	// }
+}
+
+func TestSetBytesRoundTripEdgeCases(t *testing.T) {
+	// TODO: values close to 0, close to 2^255-19, between 2^255-19 and 2^255-1,
+	// and between 2^255 and 2^256-1. Test both the documented SetBytes
+	// behavior, and that Bytes reduces them.
+}
+
+// Tests self-consistency between Multiply and Square.
+func TestConsistency(t *testing.T) {
+	var x Element
+	var x2, x2sq Element
+
+	x = Element{1, 1, 1, 1, 1}
+	x2.Multiply(&x, &x)
+	x2sq.Square(&x)
+
+	if x2 != x2sq {
+		t.Fatalf("all ones failed\nmul: %x\nsqr: %x\n", x2, x2sq)
+	}
+
+	var bytes [32]byte
+
+	_, err := io.ReadFull(rand.Reader, bytes[:])
+	if err != nil {
+		t.Fatal(err)
+	}
+	x.SetBytes(bytes[:])
+
+	x2.Multiply(&x, &x)
+	x2sq.Square(&x)
+
+	if x2 != x2sq {
+		t.Fatalf("all ones failed\nmul: %x\nsqr: %x\n", x2, x2sq)
+	}
+}
+
+func TestEqual(t *testing.T) {
+	x := Element{1, 1, 1, 1, 1}
+	y := Element{5, 4, 3, 2, 1}
+
+	eq := x.Equal(&x)
+	if eq != 1 {
+		t.Errorf("wrong about equality")
+	}
+
+	eq = x.Equal(&y)
+	if eq != 0 {
+		t.Errorf("wrong about inequality")
+	}
+}
+
+func TestInvert(t *testing.T) {
+	x := Element{1, 1, 1, 1, 1}
+	one := Element{1, 0, 0, 0, 0}
+	var xinv, r Element
+
+	xinv.Invert(&x)
+	r.Multiply(&x, &xinv)
+	r.reduce()
+
+	if one != r {
+		t.Errorf("inversion identity failed, got: %x", r)
+	}
+
+	var bytes [32]byte
+
+	_, err := io.ReadFull(rand.Reader, bytes[:])
+	if err != nil {
+		t.Fatal(err)
+	}
+	x.SetBytes(bytes[:])
+
+	xinv.Invert(&x)
+	r.Multiply(&x, &xinv)
+	r.reduce()
+
+	if one != r {
+		t.Errorf("random inversion identity failed, got: %x for field element %x", r, x)
+	}
+
+	zero := Element{}
+	x.Set(&zero)
+	if xx := xinv.Invert(&x); xx != &xinv {
+		t.Errorf("inverting zero did not return the receiver")
+	} else if xinv.Equal(&zero) != 1 {
+		t.Errorf("inverting zero did not return zero")
+	}
+}
+
+func TestSelectSwap(t *testing.T) {
+	a := Element{358744748052810, 1691584618240980, 977650209285361, 1429865912637724, 560044844278676}
+	b := Element{84926274344903, 473620666599931, 365590438845504, 1028470286882429, 2146499180330972}
+
+	var c, d Element
+
+	c.Select(&a, &b, 1)
+	d.Select(&a, &b, 0)
+
+	if c.Equal(&a) != 1 || d.Equal(&b) != 1 {
+		t.Errorf("Select failed")
+	}
+
+	c.Swap(&d, 0)
+
+	if c.Equal(&a) != 1 || d.Equal(&b) != 1 {
+		t.Errorf("Swap failed")
+	}
+
+	c.Swap(&d, 1)
+
+	if c.Equal(&b) != 1 || d.Equal(&a) != 1 {
+		t.Errorf("Swap failed")
+	}
+}
+
+func TestMult32(t *testing.T) {
+	mult32EquivalentToMul := func(x Element, y uint32) bool {
+		t1 := new(Element)
+		for i := 0; i < 100; i++ {
+			t1.Mult32(&x, y)
+		}
+
+		ty := new(Element)
+		ty.l0 = uint64(y)
+
+		t2 := new(Element)
+		for i := 0; i < 100; i++ {
+			t2.Multiply(&x, ty)
+		}
+
+		return t1.Equal(t2) == 1 && isInBounds(t1) && isInBounds(t2)
+	}
+
+	if err := quick.Check(mult32EquivalentToMul, quickCheckConfig1024); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestSqrtRatio(t *testing.T) {
+	// From draft-irtf-cfrg-ristretto255-decaf448-00, Appendix A.4.
+	type test struct {
+		u, v      string
+		wasSquare int
+		r         string
+	}
+	var tests = []test{
+		// If u is 0, the function is defined to return (0, TRUE), even if v
+		// is zero. Note that where used in this package, the denominator v
+		// is never zero.
+		{
+			"0000000000000000000000000000000000000000000000000000000000000000",
+			"0000000000000000000000000000000000000000000000000000000000000000",
+			1, "0000000000000000000000000000000000000000000000000000000000000000",
+		},
+		// 0/1 == 0²
+		{
+			"0000000000000000000000000000000000000000000000000000000000000000",
+			"0100000000000000000000000000000000000000000000000000000000000000",
+			1, "0000000000000000000000000000000000000000000000000000000000000000",
+		},
+		// If u is non-zero and v is zero, defined to return (0, FALSE).
+		{
+			"0100000000000000000000000000000000000000000000000000000000000000",
+			"0000000000000000000000000000000000000000000000000000000000000000",
+			0, "0000000000000000000000000000000000000000000000000000000000000000",
+		},
+		// 2/1 is not square in this field.
+		{
+			"0200000000000000000000000000000000000000000000000000000000000000",
+			"0100000000000000000000000000000000000000000000000000000000000000",
+			0, "3c5ff1b5d8e4113b871bd052f9e7bcd0582804c266ffb2d4f4203eb07fdb7c54",
+		},
+		// 4/1 == 2²
+		{
+			"0400000000000000000000000000000000000000000000000000000000000000",
+			"0100000000000000000000000000000000000000000000000000000000000000",
+			1, "0200000000000000000000000000000000000000000000000000000000000000",
+		},
+		// 1/4 == (2⁻¹)² == (2^(p-2))² per Euler's theorem
+		{
+			"0100000000000000000000000000000000000000000000000000000000000000",
+			"0400000000000000000000000000000000000000000000000000000000000000",
+			1, "f6ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff3f",
+		},
+	}
+
+	for i, tt := range tests {
+		u := new(Element).SetBytes(decodeHex(tt.u))
+		v := new(Element).SetBytes(decodeHex(tt.v))
+		want := new(Element).SetBytes(decodeHex(tt.r))
+		got, wasSquare := new(Element).SqrtRatio(u, v)
+		if got.Equal(want) == 0 || wasSquare != tt.wasSquare {
+			t.Errorf("%d: got (%v, %v), want (%v, %v)", i, got, wasSquare, want, tt.wasSquare)
+		}
+	}
+}
+
+func TestCarryPropagate(t *testing.T) {
+	asmLikeGeneric := func(a [5]uint64) bool {
+		t1 := &Element{a[0], a[1], a[2], a[3], a[4]}
+		t2 := &Element{a[0], a[1], a[2], a[3], a[4]}
+
+		t1.carryPropagate()
+		t2.carryPropagateGeneric()
+
+		if *t1 != *t2 {
+			t.Logf("got: %#v,\nexpected: %#v", t1, t2)
+		}
+
+		return *t1 == *t2 && isInBounds(t2)
+	}
+
+	if err := quick.Check(asmLikeGeneric, quickCheckConfig1024); err != nil {
+		t.Error(err)
+	}
+
+	if !asmLikeGeneric([5]uint64{0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff}) {
+		t.Errorf("failed for {0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff}")
+	}
+}
+
+func TestFeSquare(t *testing.T) {
+	asmLikeGeneric := func(a Element) bool {
+		t1 := a
+		t2 := a
+
+		feSquareGeneric(&t1, &t1)
+		feSquare(&t2, &t2)
+
+		if t1 != t2 {
+			t.Logf("got: %#v,\nexpected: %#v", t1, t2)
+		}
+
+		return t1 == t2 && isInBounds(&t2)
+	}
+
+	if err := quick.Check(asmLikeGeneric, quickCheckConfig1024); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestFeMul(t *testing.T) {
+	asmLikeGeneric := func(a, b Element) bool {
+		a1 := a
+		a2 := a
+		b1 := b
+		b2 := b
+
+		feMulGeneric(&a1, &a1, &b1)
+		feMul(&a2, &a2, &b2)
+
+		if a1 != a2 || b1 != b2 {
+			t.Logf("got: %#v,\nexpected: %#v", a1, a2)
+			t.Logf("got: %#v,\nexpected: %#v", b1, b2)
+		}
+
+		return a1 == a2 && isInBounds(&a2) &&
+			b1 == b2 && isInBounds(&b2)
+	}
+
+	if err := quick.Check(asmLikeGeneric, quickCheckConfig1024); err != nil {
+		t.Error(err)
+	}
+}
+
+func decodeHex(s string) []byte {
+	b, err := hex.DecodeString(s)
+	if err != nil {
+		panic(err)
+	}
+	return b
+}
diff --git a/src/crypto/ed25519/internal/edwards25519/scalar.go b/src/crypto/ed25519/internal/edwards25519/scalar.go
new file mode 100644
index 0000000000..889acaa0f1
--- /dev/null
+++ b/src/crypto/ed25519/internal/edwards25519/scalar.go
@@ -0,0 +1,1025 @@
+// Copyright (c) 2016 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 edwards25519
+
+import (
+	"crypto/subtle"
+	"encoding/binary"
+	"errors"
+)
+
+// A Scalar is an integer modulo
+//
+//     l = 2^252 + 27742317777372353535851937790883648493
+//
+// which is the prime order of the edwards25519 group.
+//
+// This type works similarly to math/big.Int, and all arguments and
+// receivers are allowed to alias.
+//
+// The zero value is a valid zero element.
+type Scalar struct {
+	// s is the Scalar value in little-endian. The value is always reduced
+	// between operations.
+	s [32]byte
+}
+
+var (
+	scZero = Scalar{[32]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}
+
+	scOne = Scalar{[32]byte{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}
+
+	scMinusOne = Scalar{[32]byte{236, 211, 245, 92, 26, 99, 18, 88, 214, 156, 247, 162, 222, 249, 222, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16}}
+)
+
+// NewScalar returns a new zero Scalar.
+func NewScalar() *Scalar {
+	return &Scalar{}
+}
+
+// MultiplyAdd sets s = x * y + z mod l, and returns s.
+func (s *Scalar) MultiplyAdd(x, y, z *Scalar) *Scalar {
+	scMulAdd(&s.s, &x.s, &y.s, &z.s)
+	return s
+}
+
+// Add sets s = x + y mod l, and returns s.
+func (s *Scalar) Add(x, y *Scalar) *Scalar {
+	// s = 1 * x + y mod l
+	scMulAdd(&s.s, &scOne.s, &x.s, &y.s)
+	return s
+}
+
+// Subtract sets s = x - y mod l, and returns s.
+func (s *Scalar) Subtract(x, y *Scalar) *Scalar {
+	// s = -1 * y + x mod l
+	scMulAdd(&s.s, &scMinusOne.s, &y.s, &x.s)
+	return s
+}
+
+// Negate sets s = -x mod l, and returns s.
+func (s *Scalar) Negate(x *Scalar) *Scalar {
+	// s = -1 * x + 0 mod l
+	scMulAdd(&s.s, &scMinusOne.s, &x.s, &scZero.s)
+	return s
+}
+
+// Multiply sets s = x * y mod l, and returns s.
+func (s *Scalar) Multiply(x, y *Scalar) *Scalar {
+	// s = x * y + 0 mod l
+	scMulAdd(&s.s, &x.s, &y.s, &scZero.s)
+	return s
+}
+
+// Set sets s = x, and returns s.
+func (s *Scalar) Set(x *Scalar) *Scalar {
+	*s = *x
+	return s
+}
+
+// SetUniformBytes sets s to an uniformly distributed value given 64 uniformly
+// distributed random bytes.
+func (s *Scalar) SetUniformBytes(x []byte) *Scalar {
+	if len(x) != 64 {
+		panic("edwards25519: invalid SetUniformBytes input length")
+	}
+	var wideBytes [64]byte
+	copy(wideBytes[:], x[:])
+	scReduce(&s.s, &wideBytes)
+	return s
+}
+
+// SetCanonicalBytes sets s = x, where x is a 32-byte little-endian encoding of
+// s, and returns s. If x is not a canonical encoding of s, SetCanonicalBytes
+// returns nil and an error, and the receiver is unchanged.
+func (s *Scalar) SetCanonicalBytes(x []byte) (*Scalar, error) {
+	if len(x) != 32 {
+		return nil, errors.New("invalid scalar length")
+	}
+	ss := &Scalar{}
+	copy(ss.s[:], x)
+	if !isReduced(ss) {
+		return nil, errors.New("invalid scalar encoding")
+	}
+	s.s = ss.s
+	return s, nil
+}
+
+// isReduced returns whether the given scalar is reduced modulo l.
+func isReduced(s *Scalar) bool {
+	for i := len(s.s) - 1; i >= 0; i-- {
+		switch {
+		case s.s[i] > scMinusOne.s[i]:
+			return false
+		case s.s[i] < scMinusOne.s[i]:
+			return true
+		}
+	}
+	return true
+}
+
+// SetBytesWithClamping applies the buffer pruning described in RFC 8032,
+// Section 5.1.5 (also known as clamping) and sets s to the result. The input
+// must be 32 bytes, and it is not modified.
+//
+// Note that since Scalar values are always reduced modulo the prime order of
+// the curve, the resulting value will not preserve any of the cofactor-clearing
+// properties that clamping is meant to provide. It will however work as
+// expected as long as it is applied to points on the prime order subgroup, like
+// in Ed25519. In fact, it is lost to history why RFC 8032 adopted the
+// irrelevant RFC 7748 clamping, but it is now required for compatibility.
+func (s *Scalar) SetBytesWithClamping(x []byte) *Scalar {
+	// The description above omits the purpose of the high bits of the clamping
+	// for brevity, but those are also lost to reductions, and are also
+	// irrelevant to edwards25519 as they protect against a specific
+	// implementation bug that was once observed in a generic Montgomery ladder.
+	if len(x) != 32 {
+		panic("edwards25519: invalid SetBytesWithClamping input length")
+	}
+	var wideBytes [64]byte
+	copy(wideBytes[:], x[:])
+	wideBytes[0] &= 248
+	wideBytes[31] &= 63
+	wideBytes[31] |= 64
+	scReduce(&s.s, &wideBytes)
+	return s
+}
+
+// Bytes returns the canonical 32-byte little-endian encoding of s.
+func (s *Scalar) Bytes() []byte {
+	buf := make([]byte, 32)
+	copy(buf, s.s[:])
+	return buf
+}
+
+// Equal returns 1 if s and t are equal, and 0 otherwise.
+func (s *Scalar) Equal(t *Scalar) int {
+	return subtle.ConstantTimeCompare(s.s[:], t.s[:])
+}
+
+// scMulAdd and scReduce are ported from the public domain, “ref10”
+// implementation of ed25519 from SUPERCOP.
+
+func load3(in []byte) int64 {
+	r := int64(in[0])
+	r |= int64(in[1]) << 8
+	r |= int64(in[2]) << 16
+	return r
+}
+
+func load4(in []byte) int64 {
+	r := int64(in[0])
+	r |= int64(in[1]) << 8
+	r |= int64(in[2]) << 16
+	r |= int64(in[3]) << 24
+	return r
+}
+
+// Input:
+//   a[0]+256*a[1]+...+256^31*a[31] = a
+//   b[0]+256*b[1]+...+256^31*b[31] = b
+//   c[0]+256*c[1]+...+256^31*c[31] = c
+//
+// Output:
+//   s[0]+256*s[1]+...+256^31*s[31] = (ab+c) mod l
+//   where l = 2^252 + 27742317777372353535851937790883648493.
+func scMulAdd(s, a, b, c *[32]byte) {
+	a0 := 2097151 & load3(a[:])
+	a1 := 2097151 & (load4(a[2:]) >> 5)
+	a2 := 2097151 & (load3(a[5:]) >> 2)
+	a3 := 2097151 & (load4(a[7:]) >> 7)
+	a4 := 2097151 & (load4(a[10:]) >> 4)
+	a5 := 2097151 & (load3(a[13:]) >> 1)
+	a6 := 2097151 & (load4(a[15:]) >> 6)
+	a7 := 2097151 & (load3(a[18:]) >> 3)
+	a8 := 2097151 & load3(a[21:])
+	a9 := 2097151 & (load4(a[23:]) >> 5)
+	a10 := 2097151 & (load3(a[26:]) >> 2)
+	a11 := (load4(a[28:]) >> 7)
+	b0 := 2097151 & load3(b[:])
+	b1 := 2097151 & (load4(b[2:]) >> 5)
+	b2 := 2097151 & (load3(b[5:]) >> 2)
+	b3 := 2097151 & (load4(b[7:]) >> 7)
+	b4 := 2097151 & (load4(b[10:]) >> 4)
+	b5 := 2097151 & (load3(b[13:]) >> 1)
+	b6 := 2097151 & (load4(b[15:]) >> 6)
+	b7 := 2097151 & (load3(b[18:]) >> 3)
+	b8 := 2097151 & load3(b[21:])
+	b9 := 2097151 & (load4(b[23:]) >> 5)
+	b10 := 2097151 & (load3(b[26:]) >> 2)
+	b11 := (load4(b[28:]) >> 7)
+	c0 := 2097151 & load3(c[:])
+	c1 := 2097151 & (load4(c[2:]) >> 5)
+	c2 := 2097151 & (load3(c[5:]) >> 2)
+	c3 := 2097151 & (load4(c[7:]) >> 7)
+	c4 := 2097151 & (load4(c[10:]) >> 4)
+	c5 := 2097151 & (load3(c[13:]) >> 1)
+	c6 := 2097151 & (load4(c[15:]) >> 6)
+	c7 := 2097151 & (load3(c[18:]) >> 3)
+	c8 := 2097151 & load3(c[21:])
+	c9 := 2097151 & (load4(c[23:]) >> 5)
+	c10 := 2097151 & (load3(c[26:]) >> 2)
+	c11 := (load4(c[28:]) >> 7)
+	var carry [23]int64
+
+	s0 := c0 + a0*b0
+	s1 := c1 + a0*b1 + a1*b0
+	s2 := c2 + a0*b2 + a1*b1 + a2*b0
+	s3 := c3 + a0*b3 + a1*b2 + a2*b1 + a3*b0
+	s4 := c4 + a0*b4 + a1*b3 + a2*b2 + a3*b1 + a4*b0
+	s5 := c5 + a0*b5 + a1*b4 + a2*b3 + a3*b2 + a4*b1 + a5*b0
+	s6 := c6 + a0*b6 + a1*b5 + a2*b4 + a3*b3 + a4*b2 + a5*b1 + a6*b0
+	s7 := c7 + a0*b7 + a1*b6 + a2*b5 + a3*b4 + a4*b3 + a5*b2 + a6*b1 + a7*b0
+	s8 := c8 + a0*b8 + a1*b7 + a2*b6 + a3*b5 + a4*b4 + a5*b3 + a6*b2 + a7*b1 + a8*b0
+	s9 := c9 + a0*b9 + a1*b8 + a2*b7 + a3*b6 + a4*b5 + a5*b4 + a6*b3 + a7*b2 + a8*b1 + a9*b0
+	s10 := c10 + a0*b10 + a1*b9 + a2*b8 + a3*b7 + a4*b6 + a5*b5 + a6*b4 + a7*b3 + a8*b2 + a9*b1 + a10*b0
+	s11 := c11 + a0*b11 + a1*b10 + a2*b9 + a3*b8 + a4*b7 + a5*b6 + a6*b5 + a7*b4 + a8*b3 + a9*b2 + a10*b1 + a11*b0
+	s12 := a1*b11 + a2*b10 + a3*b9 + a4*b8 + a5*b7 + a6*b6 + a7*b5 + a8*b4 + a9*b3 + a10*b2 + a11*b1
+	s13 := a2*b11 + a3*b10 + a4*b9 + a5*b8 + a6*b7 + a7*b6 + a8*b5 + a9*b4 + a10*b3 + a11*b2
+	s14 := a3*b11 + a4*b10 + a5*b9 + a6*b8 + a7*b7 + a8*b6 + a9*b5 + a10*b4 + a11*b3
+	s15 := a4*b11 + a5*b10 + a6*b9 + a7*b8 + a8*b7 + a9*b6 + a10*b5 + a11*b4
+	s16 := a5*b11 + a6*b10 + a7*b9 + a8*b8 + a9*b7 + a10*b6 + a11*b5
+	s17 := a6*b11 + a7*b10 + a8*b9 + a9*b8 + a10*b7 + a11*b6
+	s18 := a7*b11 + a8*b10 + a9*b9 + a10*b8 + a11*b7
+	s19 := a8*b11 + a9*b10 + a10*b9 + a11*b8
+	s20 := a9*b11 + a10*b10 + a11*b9
+	s21 := a10*b11 + a11*b10
+	s22 := a11 * b11
+	s23 := int64(0)
+
+	carry[0] = (s0 + (1 << 20)) >> 21
+	s1 += carry[0]
+	s0 -= carry[0] << 21
+	carry[2] = (s2 + (1 << 20)) >> 21
+	s3 += carry[2]
+	s2 -= carry[2] << 21
+	carry[4] = (s4 + (1 << 20)) >> 21
+	s5 += carry[4]
+	s4 -= carry[4] << 21
+	carry[6] = (s6 + (1 << 20)) >> 21
+	s7 += carry[6]
+	s6 -= carry[6] << 21
+	carry[8] = (s8 + (1 << 20)) >> 21
+	s9 += carry[8]
+	s8 -= carry[8] << 21
+	carry[10] = (s10 + (1 << 20)) >> 21
+	s11 += carry[10]
+	s10 -= carry[10] << 21
+	carry[12] = (s12 + (1 << 20)) >> 21
+	s13 += carry[12]
+	s12 -= carry[12] << 21
+	carry[14] = (s14 + (1 << 20)) >> 21
+	s15 += carry[14]
+	s14 -= carry[14] << 21
+	carry[16] = (s16 + (1 << 20)) >> 21
+	s17 += carry[16]
+	s16 -= carry[16] << 21
+	carry[18] = (s18 + (1 << 20)) >> 21
+	s19 += carry[18]
+	s18 -= carry[18] << 21
+	carry[20] = (s20 + (1 << 20)) >> 21
+	s21 += carry[20]
+	s20 -= carry[20] << 21
+	carry[22] = (s22 + (1 << 20)) >> 21
+	s23 += carry[22]
+	s22 -= carry[22] << 21
+
+	carry[1] = (s1 + (1 << 20)) >> 21
+	s2 += carry[1]
+	s1 -= carry[1] << 21
+	carry[3] = (s3 + (1 << 20)) >> 21
+	s4 += carry[3]
+	s3 -= carry[3] << 21
+	carry[5] = (s5 + (1 << 20)) >> 21
+	s6 += carry[5]
+	s5 -= carry[5] << 21
+	carry[7] = (s7 + (1 << 20)) >> 21
+	s8 += carry[7]
+	s7 -= carry[7] << 21
+	carry[9] = (s9 + (1 << 20)) >> 21
+	s10 += carry[9]
+	s9 -= carry[9] << 21
+	carry[11] = (s11 + (1 << 20)) >> 21
+	s12 += carry[11]
+	s11 -= carry[11] << 21
+	carry[13] = (s13 + (1 << 20)) >> 21
+	s14 += carry[13]
+	s13 -= carry[13] << 21
+	carry[15] = (s15 + (1 << 20)) >> 21
+	s16 += carry[15]
+	s15 -= carry[15] << 21
+	carry[17] = (s17 + (1 << 20)) >> 21
+	s18 += carry[17]
+	s17 -= carry[17] << 21
+	carry[19] = (s19 + (1 << 20)) >> 21
+	s20 += carry[19]
+	s19 -= carry[19] << 21
+	carry[21] = (s21 + (1 << 20)) >> 21
+	s22 += carry[21]
+	s21 -= carry[21] << 21
+
+	s11 += s23 * 666643
+	s12 += s23 * 470296
+	s13 += s23 * 654183
+	s14 -= s23 * 997805
+	s15 += s23 * 136657
+	s16 -= s23 * 683901
+	s23 = 0
+
+	s10 += s22 * 666643
+	s11 += s22 * 470296
+	s12 += s22 * 654183
+	s13 -= s22 * 997805
+	s14 += s22 * 136657
+	s15 -= s22 * 683901
+	s22 = 0
+
+	s9 += s21 * 666643
+	s10 += s21 * 470296
+	s11 += s21 * 654183
+	s12 -= s21 * 997805
+	s13 += s21 * 136657
+	s14 -= s21 * 683901
+	s21 = 0
+
+	s8 += s20 * 666643
+	s9 += s20 * 470296
+	s10 += s20 * 654183
+	s11 -= s20 * 997805
+	s12 += s20 * 136657
+	s13 -= s20 * 683901
+	s20 = 0
+
+	s7 += s19 * 666643
+	s8 += s19 * 470296
+	s9 += s19 * 654183
+	s10 -= s19 * 997805
+	s11 += s19 * 136657
+	s12 -= s19 * 683901
+	s19 = 0
+
+	s6 += s18 * 666643
+	s7 += s18 * 470296
+	s8 += s18 * 654183
+	s9 -= s18 * 997805
+	s10 += s18 * 136657
+	s11 -= s18 * 683901
+	s18 = 0
+
+	carry[6] = (s6 + (1 << 20)) >> 21
+	s7 += carry[6]
+	s6 -= carry[6] << 21
+	carry[8] = (s8 + (1 << 20)) >> 21
+	s9 += carry[8]
+	s8 -= carry[8] << 21
+	carry[10] = (s10 + (1 << 20)) >> 21
+	s11 += carry[10]
+	s10 -= carry[10] << 21
+	carry[12] = (s12 + (1 << 20)) >> 21
+	s13 += carry[12]
+	s12 -= carry[12] << 21
+	carry[14] = (s14 + (1 << 20)) >> 21
+	s15 += carry[14]
+	s14 -= carry[14] << 21
+	carry[16] = (s16 + (1 << 20)) >> 21
+	s17 += carry[16]
+	s16 -= carry[16] << 21
+
+	carry[7] = (s7 + (1 << 20)) >> 21
+	s8 += carry[7]
+	s7 -= carry[7] << 21
+	carry[9] = (s9 + (1 << 20)) >> 21
+	s10 += carry[9]
+	s9 -= carry[9] << 21
+	carry[11] = (s11 + (1 << 20)) >> 21
+	s12 += carry[11]
+	s11 -= carry[11] << 21
+	carry[13] = (s13 + (1 << 20)) >> 21
+	s14 += carry[13]
+	s13 -= carry[13] << 21
+	carry[15] = (s15 + (1 << 20)) >> 21
+	s16 += carry[15]
+	s15 -= carry[15] << 21
+
+	s5 += s17 * 666643
+	s6 += s17 * 470296
+	s7 += s17 * 654183
+	s8 -= s17 * 997805
+	s9 += s17 * 136657
+	s10 -= s17 * 683901
+	s17 = 0
+
+	s4 += s16 * 666643
+	s5 += s16 * 470296
+	s6 += s16 * 654183
+	s7 -= s16 * 997805
+	s8 += s16 * 136657
+	s9 -= s16 * 683901
+	s16 = 0
+
+	s3 += s15 * 666643
+	s4 += s15 * 470296
+	s5 += s15 * 654183
+	s6 -= s15 * 997805
+	s7 += s15 * 136657
+	s8 -= s15 * 683901
+	s15 = 0
+
+	s2 += s14 * 666643
+	s3 += s14 * 470296
+	s4 += s14 * 654183
+	s5 -= s14 * 997805
+	s6 += s14 * 136657
+	s7 -= s14 * 683901
+	s14 = 0
+
+	s1 += s13 * 666643
+	s2 += s13 * 470296
+	s3 += s13 * 654183
+	s4 -= s13 * 997805
+	s5 += s13 * 136657
+	s6 -= s13 * 683901
+	s13 = 0
+
+	s0 += s12 * 666643
+	s1 += s12 * 470296
+	s2 += s12 * 654183
+	s3 -= s12 * 997805
+	s4 += s12 * 136657
+	s5 -= s12 * 683901
+	s12 = 0
+
+	carry[0] = (s0 + (1 << 20)) >> 21
+	s1 += carry[0]
+	s0 -= carry[0] << 21
+	carry[2] = (s2 + (1 << 20)) >> 21
+	s3 += carry[2]
+	s2 -= carry[2] << 21
+	carry[4] = (s4 + (1 << 20)) >> 21
+	s5 += carry[4]
+	s4 -= carry[4] << 21
+	carry[6] = (s6 + (1 << 20)) >> 21
+	s7 += carry[6]
+	s6 -= carry[6] << 21
+	carry[8] = (s8 + (1 << 20)) >> 21
+	s9 += carry[8]
+	s8 -= carry[8] << 21
+	carry[10] = (s10 + (1 << 20)) >> 21
+	s11 += carry[10]
+	s10 -= carry[10] << 21
+
+	carry[1] = (s1 + (1 << 20)) >> 21
+	s2 += carry[1]
+	s1 -= carry[1] << 21
+	carry[3] = (s3 + (1 << 20)) >> 21
+	s4 += carry[3]
+	s3 -= carry[3] << 21
+	carry[5] = (s5 + (1 << 20)) >> 21
+	s6 += carry[5]
+	s5 -= carry[5] << 21
+	carry[7] = (s7 + (1 << 20)) >> 21
+	s8 += carry[7]
+	s7 -= carry[7] << 21
+	carry[9] = (s9 + (1 << 20)) >> 21
+	s10 += carry[9]
+	s9 -= carry[9] << 21
+	carry[11] = (s11 + (1 << 20)) >> 21
+	s12 += carry[11]
+	s11 -= carry[11] << 21
+
+	s0 += s12 * 666643
+	s1 += s12 * 470296
+	s2 += s12 * 654183
+	s3 -= s12 * 997805
+	s4 += s12 * 136657
+	s5 -= s12 * 683901
+	s12 = 0
+
+	carry[0] = s0 >> 21
+	s1 += carry[0]
+	s0 -= carry[0] << 21
+	carry[1] = s1 >> 21
+	s2 += carry[1]
+	s1 -= carry[1] << 21
+	carry[2] = s2 >> 21
+	s3 += carry[2]
+	s2 -= carry[2] << 21
+	carry[3] = s3 >> 21
+	s4 += carry[3]
+	s3 -= carry[3] << 21
+	carry[4] = s4 >> 21
+	s5 += carry[4]
+	s4 -= carry[4] << 21
+	carry[5] = s5 >> 21
+	s6 += carry[5]
+	s5 -= carry[5] << 21
+	carry[6] = s6 >> 21
+	s7 += carry[6]
+	s6 -= carry[6] << 21
+	carry[7] = s7 >> 21
+	s8 += carry[7]
+	s7 -= carry[7] << 21
+	carry[8] = s8 >> 21
+	s9 += carry[8]
+	s8 -= carry[8] << 21
+	carry[9] = s9 >> 21
+	s10 += carry[9]
+	s9 -= carry[9] << 21
+	carry[10] = s10 >> 21
+	s11 += carry[10]
+	s10 -= carry[10] << 21
+	carry[11] = s11 >> 21
+	s12 += carry[11]
+	s11 -= carry[11] << 21
+
+	s0 += s12 * 666643
+	s1 += s12 * 470296
+	s2 += s12 * 654183
+	s3 -= s12 * 997805
+	s4 += s12 * 136657
+	s5 -= s12 * 683901
+	s12 = 0
+
+	carry[0] = s0 >> 21
+	s1 += carry[0]
+	s0 -= carry[0] << 21
+	carry[1] = s1 >> 21
+	s2 += carry[1]
+	s1 -= carry[1] << 21
+	carry[2] = s2 >> 21
+	s3 += carry[2]
+	s2 -= carry[2] << 21
+	carry[3] = s3 >> 21
+	s4 += carry[3]
+	s3 -= carry[3] << 21
+	carry[4] = s4 >> 21
+	s5 += carry[4]
+	s4 -= carry[4] << 21
+	carry[5] = s5 >> 21
+	s6 += carry[5]
+	s5 -= carry[5] << 21
+	carry[6] = s6 >> 21
+	s7 += carry[6]
+	s6 -= carry[6] << 21
+	carry[7] = s7 >> 21
+	s8 += carry[7]
+	s7 -= carry[7] << 21
+	carry[8] = s8 >> 21
+	s9 += carry[8]
+	s8 -= carry[8] << 21
+	carry[9] = s9 >> 21
+	s10 += carry[9]
+	s9 -= carry[9] << 21
+	carry[10] = s10 >> 21
+	s11 += carry[10]
+	s10 -= carry[10] << 21
+
+	s[0] = byte(s0 >> 0)
+	s[1] = byte(s0 >> 8)
+	s[2] = byte((s0 >> 16) | (s1 << 5))
+	s[3] = byte(s1 >> 3)
+	s[4] = byte(s1 >> 11)
+	s[5] = byte((s1 >> 19) | (s2 << 2))
+	s[6] = byte(s2 >> 6)
+	s[7] = byte((s2 >> 14) | (s3 << 7))
+	s[8] = byte(s3 >> 1)
+	s[9] = byte(s3 >> 9)
+	s[10] = byte((s3 >> 17) | (s4 << 4))
+	s[11] = byte(s4 >> 4)
+	s[12] = byte(s4 >> 12)
+	s[13] = byte((s4 >> 20) | (s5 << 1))
+	s[14] = byte(s5 >> 7)
+	s[15] = byte((s5 >> 15) | (s6 << 6))
+	s[16] = byte(s6 >> 2)
+	s[17] = byte(s6 >> 10)
+	s[18] = byte((s6 >> 18) | (s7 << 3))
+	s[19] = byte(s7 >> 5)
+	s[20] = byte(s7 >> 13)
+	s[21] = byte(s8 >> 0)
+	s[22] = byte(s8 >> 8)
+	s[23] = byte((s8 >> 16) | (s9 << 5))
+	s[24] = byte(s9 >> 3)
+	s[25] = byte(s9 >> 11)
+	s[26] = byte((s9 >> 19) | (s10 << 2))
+	s[27] = byte(s10 >> 6)
+	s[28] = byte((s10 >> 14) | (s11 << 7))
+	s[29] = byte(s11 >> 1)
+	s[30] = byte(s11 >> 9)
+	s[31] = byte(s11 >> 17)
+}
+
+// Input:
+//   s[0]+256*s[1]+...+256^63*s[63] = s
+//
+// Output:
+//   s[0]+256*s[1]+...+256^31*s[31] = s mod l
+//   where l = 2^252 + 27742317777372353535851937790883648493.
+func scReduce(out *[32]byte, s *[64]byte) {
+	s0 := 2097151 & load3(s[:])
+	s1 := 2097151 & (load4(s[2:]) >> 5)
+	s2 := 2097151 & (load3(s[5:]) >> 2)
+	s3 := 2097151 & (load4(s[7:]) >> 7)
+	s4 := 2097151 & (load4(s[10:]) >> 4)
+	s5 := 2097151 & (load3(s[13:]) >> 1)
+	s6 := 2097151 & (load4(s[15:]) >> 6)
+	s7 := 2097151 & (load3(s[18:]) >> 3)
+	s8 := 2097151 & load3(s[21:])
+	s9 := 2097151 & (load4(s[23:]) >> 5)
+	s10 := 2097151 & (load3(s[26:]) >> 2)
+	s11 := 2097151 & (load4(s[28:]) >> 7)
+	s12 := 2097151 & (load4(s[31:]) >> 4)
+	s13 := 2097151 & (load3(s[34:]) >> 1)
+	s14 := 2097151 & (load4(s[36:]) >> 6)
+	s15 := 2097151 & (load3(s[39:]) >> 3)
+	s16 := 2097151 & load3(s[42:])
+	s17 := 2097151 & (load4(s[44:]) >> 5)
+	s18 := 2097151 & (load3(s[47:]) >> 2)
+	s19 := 2097151 & (load4(s[49:]) >> 7)
+	s20 := 2097151 & (load4(s[52:]) >> 4)
+	s21 := 2097151 & (load3(s[55:]) >> 1)
+	s22 := 2097151 & (load4(s[57:]) >> 6)
+	s23 := (load4(s[60:]) >> 3)
+
+	s11 += s23 * 666643
+	s12 += s23 * 470296
+	s13 += s23 * 654183
+	s14 -= s23 * 997805
+	s15 += s23 * 136657
+	s16 -= s23 * 683901
+	s23 = 0
+
+	s10 += s22 * 666643
+	s11 += s22 * 470296
+	s12 += s22 * 654183
+	s13 -= s22 * 997805
+	s14 += s22 * 136657
+	s15 -= s22 * 683901
+	s22 = 0
+
+	s9 += s21 * 666643
+	s10 += s21 * 470296
+	s11 += s21 * 654183
+	s12 -= s21 * 997805
+	s13 += s21 * 136657
+	s14 -= s21 * 683901
+	s21 = 0
+
+	s8 += s20 * 666643
+	s9 += s20 * 470296
+	s10 += s20 * 654183
+	s11 -= s20 * 997805
+	s12 += s20 * 136657
+	s13 -= s20 * 683901
+	s20 = 0
+
+	s7 += s19 * 666643
+	s8 += s19 * 470296
+	s9 += s19 * 654183
+	s10 -= s19 * 997805
+	s11 += s19 * 136657
+	s12 -= s19 * 683901
+	s19 = 0
+
+	s6 += s18 * 666643
+	s7 += s18 * 470296
+	s8 += s18 * 654183
+	s9 -= s18 * 997805
+	s10 += s18 * 136657
+	s11 -= s18 * 683901
+	s18 = 0
+
+	var carry [17]int64
+
+	carry[6] = (s6 + (1 << 20)) >> 21
+	s7 += carry[6]
+	s6 -= carry[6] << 21
+	carry[8] = (s8 + (1 << 20)) >> 21
+	s9 += carry[8]
+	s8 -= carry[8] << 21
+	carry[10] = (s10 + (1 << 20)) >> 21
+	s11 += carry[10]
+	s10 -= carry[10] << 21
+	carry[12] = (s12 + (1 << 20)) >> 21
+	s13 += carry[12]
+	s12 -= carry[12] << 21
+	carry[14] = (s14 + (1 << 20)) >> 21
+	s15 += carry[14]
+	s14 -= carry[14] << 21
+	carry[16] = (s16 + (1 << 20)) >> 21
+	s17 += carry[16]
+	s16 -= carry[16] << 21
+
+	carry[7] = (s7 + (1 << 20)) >> 21
+	s8 += carry[7]
+	s7 -= carry[7] << 21
+	carry[9] = (s9 + (1 << 20)) >> 21
+	s10 += carry[9]
+	s9 -= carry[9] << 21
+	carry[11] = (s11 + (1 << 20)) >> 21
+	s12 += carry[11]
+	s11 -= carry[11] << 21
+	carry[13] = (s13 + (1 << 20)) >> 21
+	s14 += carry[13]
+	s13 -= carry[13] << 21
+	carry[15] = (s15 + (1 << 20)) >> 21
+	s16 += carry[15]
+	s15 -= carry[15] << 21
+
+	s5 += s17 * 666643
+	s6 += s17 * 470296
+	s7 += s17 * 654183
+	s8 -= s17 * 997805
+	s9 += s17 * 136657
+	s10 -= s17 * 683901
+	s17 = 0
+
+	s4 += s16 * 666643
+	s5 += s16 * 470296
+	s6 += s16 * 654183
+	s7 -= s16 * 997805
+	s8 += s16 * 136657
+	s9 -= s16 * 683901
+	s16 = 0
+
+	s3 += s15 * 666643
+	s4 += s15 * 470296
+	s5 += s15 * 654183
+	s6 -= s15 * 997805
+	s7 += s15 * 136657
+	s8 -= s15 * 683901
+	s15 = 0
+
+	s2 += s14 * 666643
+	s3 += s14 * 470296
+	s4 += s14 * 654183
+	s5 -= s14 * 997805
+	s6 += s14 * 136657
+	s7 -= s14 * 683901
+	s14 = 0
+
+	s1 += s13 * 666643
+	s2 += s13 * 470296
+	s3 += s13 * 654183
+	s4 -= s13 * 997805
+	s5 += s13 * 136657
+	s6 -= s13 * 683901
+	s13 = 0
+
+	s0 += s12 * 666643
+	s1 += s12 * 470296
+	s2 += s12 * 654183
+	s3 -= s12 * 997805
+	s4 += s12 * 136657
+	s5 -= s12 * 683901
+	s12 = 0
+
+	carry[0] = (s0 + (1 << 20)) >> 21
+	s1 += carry[0]
+	s0 -= carry[0] << 21
+	carry[2] = (s2 + (1 << 20)) >> 21
+	s3 += carry[2]
+	s2 -= carry[2] << 21
+	carry[4] = (s4 + (1 << 20)) >> 21
+	s5 += carry[4]
+	s4 -= carry[4] << 21
+	carry[6] = (s6 + (1 << 20)) >> 21
+	s7 += carry[6]
+	s6 -= carry[6] << 21
+	carry[8] = (s8 + (1 << 20)) >> 21
+	s9 += carry[8]
+	s8 -= carry[8] << 21
+	carry[10] = (s10 + (1 << 20)) >> 21
+	s11 += carry[10]
+	s10 -= carry[10] << 21
+
+	carry[1] = (s1 + (1 << 20)) >> 21
+	s2 += carry[1]
+	s1 -= carry[1] << 21
+	carry[3] = (s3 + (1 << 20)) >> 21
+	s4 += carry[3]
+	s3 -= carry[3] << 21
+	carry[5] = (s5 + (1 << 20)) >> 21
+	s6 += carry[5]
+	s5 -= carry[5] << 21
+	carry[7] = (s7 + (1 << 20)) >> 21
+	s8 += carry[7]
+	s7 -= carry[7] << 21
+	carry[9] = (s9 + (1 << 20)) >> 21
+	s10 += carry[9]
+	s9 -= carry[9] << 21
+	carry[11] = (s11 + (1 << 20)) >> 21
+	s12 += carry[11]
+	s11 -= carry[11] << 21
+
+	s0 += s12 * 666643
+	s1 += s12 * 470296
+	s2 += s12 * 654183
+	s3 -= s12 * 997805
+	s4 += s12 * 136657
+	s5 -= s12 * 683901
+	s12 = 0
+
+	carry[0] = s0 >> 21
+	s1 += carry[0]
+	s0 -= carry[0] << 21
+	carry[1] = s1 >> 21
+	s2 += carry[1]
+	s1 -= carry[1] << 21
+	carry[2] = s2 >> 21
+	s3 += carry[2]
+	s2 -= carry[2] << 21
+	carry[3] = s3 >> 21
+	s4 += carry[3]
+	s3 -= carry[3] << 21
+	carry[4] = s4 >> 21
+	s5 += carry[4]
+	s4 -= carry[4] << 21
+	carry[5] = s5 >> 21
+	s6 += carry[5]
+	s5 -= carry[5] << 21
+	carry[6] = s6 >> 21
+	s7 += carry[6]
+	s6 -= carry[6] << 21
+	carry[7] = s7 >> 21
+	s8 += carry[7]
+	s7 -= carry[7] << 21
+	carry[8] = s8 >> 21
+	s9 += carry[8]
+	s8 -= carry[8] << 21
+	carry[9] = s9 >> 21
+	s10 += carry[9]
+	s9 -= carry[9] << 21
+	carry[10] = s10 >> 21
+	s11 += carry[10]
+	s10 -= carry[10] << 21
+	carry[11] = s11 >> 21
+	s12 += carry[11]
+	s11 -= carry[11] << 21
+
+	s0 += s12 * 666643
+	s1 += s12 * 470296
+	s2 += s12 * 654183
+	s3 -= s12 * 997805
+	s4 += s12 * 136657
+	s5 -= s12 * 683901
+	s12 = 0
+
+	carry[0] = s0 >> 21
+	s1 += carry[0]
+	s0 -= carry[0] << 21
+	carry[1] = s1 >> 21
+	s2 += carry[1]
+	s1 -= carry[1] << 21
+	carry[2] = s2 >> 21
+	s3 += carry[2]
+	s2 -= carry[2] << 21
+	carry[3] = s3 >> 21
+	s4 += carry[3]
+	s3 -= carry[3] << 21
+	carry[4] = s4 >> 21
+	s5 += carry[4]
+	s4 -= carry[4] << 21
+	carry[5] = s5 >> 21
+	s6 += carry[5]
+	s5 -= carry[5] << 21
+	carry[6] = s6 >> 21
+	s7 += carry[6]
+	s6 -= carry[6] << 21
+	carry[7] = s7 >> 21
+	s8 += carry[7]
+	s7 -= carry[7] << 21
+	carry[8] = s8 >> 21
+	s9 += carry[8]
+	s8 -= carry[8] << 21
+	carry[9] = s9 >> 21
+	s10 += carry[9]
+	s9 -= carry[9] << 21
+	carry[10] = s10 >> 21
+	s11 += carry[10]
+	s10 -= carry[10] << 21
+
+	out[0] = byte(s0 >> 0)
+	out[1] = byte(s0 >> 8)
+	out[2] = byte((s0 >> 16) | (s1 << 5))
+	out[3] = byte(s1 >> 3)
+	out[4] = byte(s1 >> 11)
+	out[5] = byte((s1 >> 19) | (s2 << 2))
+	out[6] = byte(s2 >> 6)
+	out[7] = byte((s2 >> 14) | (s3 << 7))
+	out[8] = byte(s3 >> 1)
+	out[9] = byte(s3 >> 9)
+	out[10] = byte((s3 >> 17) | (s4 << 4))
+	out[11] = byte(s4 >> 4)
+	out[12] = byte(s4 >> 12)
+	out[13] = byte((s4 >> 20) | (s5 << 1))
+	out[14] = byte(s5 >> 7)
+	out[15] = byte((s5 >> 15) | (s6 << 6))
+	out[16] = byte(s6 >> 2)
+	out[17] = byte(s6 >> 10)
+	out[18] = byte((s6 >> 18) | (s7 << 3))
+	out[19] = byte(s7 >> 5)
+	out[20] = byte(s7 >> 13)
+	out[21] = byte(s8 >> 0)
+	out[22] = byte(s8 >> 8)
+	out[23] = byte((s8 >> 16) | (s9 << 5))
+	out[24] = byte(s9 >> 3)
+	out[25] = byte(s9 >> 11)
+	out[26] = byte((s9 >> 19) | (s10 << 2))
+	out[27] = byte(s10 >> 6)
+	out[28] = byte((s10 >> 14) | (s11 << 7))
+	out[29] = byte(s11 >> 1)
+	out[30] = byte(s11 >> 9)
+	out[31] = byte(s11 >> 17)
+}
+
+// nonAdjacentForm computes a width-w non-adjacent form for this scalar.
+//
+// w must be between 2 and 8, or nonAdjacentForm will panic.
+func (s *Scalar) nonAdjacentForm(w uint) [256]int8 {
+	// This implementation is adapted from the one
+	// in curve25519-dalek and is documented there:
+	// https://github.com/dalek-cryptography/curve25519-dalek/blob/f630041af28e9a405255f98a8a93adca18e4315b/src/scalar.rs#L800-L871
+	if s.s[31] > 127 {
+		panic("scalar has high bit set illegally")
+	}
+	if w < 2 {
+		panic("w must be at least 2 by the definition of NAF")
+	} else if w > 8 {
+		panic("NAF digits must fit in int8")
+	}
+
+	var naf [256]int8
+	var digits [5]uint64
+
+	for i := 0; i < 4; i++ {
+		digits[i] = binary.LittleEndian.Uint64(s.s[i*8:])
+	}
+
+	width := uint64(1 << w)
+	windowMask := uint64(width - 1)
+
+	pos := uint(0)
+	carry := uint64(0)
+	for pos < 256 {
+		indexU64 := pos / 64
+		indexBit := pos % 64
+		var bitBuf uint64
+		if indexBit < 64-w {
+			// This window's bits are contained in a single u64
+			bitBuf = digits[indexU64] >> indexBit
+		} else {
+			// Combine the current 64 bits with bits from the next 64
+			bitBuf = (digits[indexU64] >> indexBit) | (digits[1+indexU64] << (64 - indexBit))
+		}
+
+		// Add carry into the current window
+		window := carry + (bitBuf & windowMask)
+
+		if window&1 == 0 {
+			// If the window value is even, preserve the carry and continue.
+			// Why is the carry preserved?
+			// If carry == 0 and window & 1 == 0,
+			//    then the next carry should be 0
+			// If carry == 1 and window & 1 == 0,
+			//    then bit_buf & 1 == 1 so the next carry should be 1
+			pos += 1
+			continue
+		}
+
+		if window < width/2 {
+			carry = 0
+			naf[pos] = int8(window)
+		} else {
+			carry = 1
+			naf[pos] = int8(window) - int8(width)
+		}
+
+		pos += w
+	}
+	return naf
+}
+
+func (s *Scalar) signedRadix16() [64]int8 {
+	if s.s[31] > 127 {
+		panic("scalar has high bit set illegally")
+	}
+
+	var digits [64]int8
+
+	// Compute unsigned radix-16 digits:
+	for i := 0; i < 32; i++ {
+		digits[2*i] = int8(s.s[i] & 15)
+		digits[2*i+1] = int8((s.s[i] >> 4) & 15)
+	}
+
+	// Recenter coefficients:
+	for i := 0; i < 63; i++ {
+		carry := (digits[i] + 8) >> 4
+		digits[i] -= carry << 4
+		digits[i+1] += carry
+	}
+
+	return digits
+}
diff --git a/src/crypto/ed25519/internal/edwards25519/scalar_alias_test.go b/src/crypto/ed25519/internal/edwards25519/scalar_alias_test.go
new file mode 100644
index 0000000000..18d800d556
--- /dev/null
+++ b/src/crypto/ed25519/internal/edwards25519/scalar_alias_test.go
@@ -0,0 +1,93 @@
+// Copyright (c) 2019 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 edwards25519
+
+import (
+	"testing"
+	"testing/quick"
+)
+
+func TestScalarAliasing(t *testing.T) {
+	checkAliasingOneArg := func(f func(v, x *Scalar) *Scalar, v, x Scalar) bool {
+		x1, v1 := x, x
+
+		// Calculate a reference f(x) without aliasing.
+		if out := f(&v, &x); out != &v || !isReduced(out) {
+			return false
+		}
+
+		// Test aliasing the argument and the receiver.
+		if out := f(&v1, &v1); out != &v1 || v1 != v || !isReduced(out) {
+			return false
+		}
+
+		// Ensure the arguments was not modified.
+		return x == x1
+	}
+
+	checkAliasingTwoArgs := func(f func(v, x, y *Scalar) *Scalar, v, x, y Scalar) bool {
+		x1, y1, v1 := x, y, Scalar{}
+
+		// Calculate a reference f(x, y) without aliasing.
+		if out := f(&v, &x, &y); out != &v || !isReduced(out) {
+			return false
+		}
+
+		// Test aliasing the first argument and the receiver.
+		v1 = x
+		if out := f(&v1, &v1, &y); out != &v1 || v1 != v || !isReduced(out) {
+			return false
+		}
+		// Test aliasing the second argument and the receiver.
+		v1 = y
+		if out := f(&v1, &x, &v1); out != &v1 || v1 != v || !isReduced(out) {
+			return false
+		}
+
+		// Calculate a reference f(x, x) without aliasing.
+		if out := f(&v, &x, &x); out != &v || !isReduced(out) {
+			return false
+		}
+
+		// Test aliasing the first argument and the receiver.
+		v1 = x
+		if out := f(&v1, &v1, &x); out != &v1 || v1 != v || !isReduced(out) {
+			return false
+		}
+		// Test aliasing the second argument and the receiver.
+		v1 = x
+		if out := f(&v1, &x, &v1); out != &v1 || v1 != v || !isReduced(out) {
+			return false
+		}
+		// Test aliasing both arguments and the receiver.
+		v1 = x
+		if out := f(&v1, &v1, &v1); out != &v1 || v1 != v || !isReduced(out) {
+			return false
+		}
+
+		// Ensure the arguments were not modified.
+		return x == x1 && y == y1
+	}
+
+	for name, f := range map[string]interface{}{
+		"Negate": func(v, x Scalar) bool {
+			return checkAliasingOneArg((*Scalar).Negate, v, x)
+		},
+		"Multiply": func(v, x, y Scalar) bool {
+			return checkAliasingTwoArgs((*Scalar).Multiply, v, x, y)
+		},
+		"Add": func(v, x, y Scalar) bool {
+			return checkAliasingTwoArgs((*Scalar).Add, v, x, y)
+		},
+		"Subtract": func(v, x, y Scalar) bool {
+			return checkAliasingTwoArgs((*Scalar).Subtract, v, x, y)
+		},
+	} {
+		err := quick.Check(f, &quick.Config{MaxCountScale: 1 << 5})
+		if err != nil {
+			t.Errorf("%v: %v", name, err)
+		}
+	}
+}
diff --git a/src/crypto/ed25519/internal/edwards25519/scalar_test.go b/src/crypto/ed25519/internal/edwards25519/scalar_test.go
new file mode 100644
index 0000000000..704caffc5c
--- /dev/null
+++ b/src/crypto/ed25519/internal/edwards25519/scalar_test.go
@@ -0,0 +1,233 @@
+// Copyright (c) 2019 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 edwards25519
+
+import (
+	"bytes"
+	"encoding/hex"
+	"math/big"
+	mathrand "math/rand"
+	"reflect"
+	"testing"
+	"testing/quick"
+)
+
+// Generate returns a valid (reduced modulo l) Scalar with a distribution
+// weighted towards high, low, and edge values.
+func (Scalar) Generate(rand *mathrand.Rand, size int) reflect.Value {
+	s := scZero
+	diceRoll := rand.Intn(100)
+	switch {
+	case diceRoll == 0:
+	case diceRoll == 1:
+		s = scOne
+	case diceRoll == 2:
+		s = scMinusOne
+	case diceRoll < 5:
+		// Generate a low scalar in [0, 2^125).
+		rand.Read(s.s[:16])
+		s.s[15] &= (1 << 5) - 1
+	case diceRoll < 10:
+		// Generate a high scalar in [2^252, 2^252 + 2^124).
+		s.s[31] = 1 << 4
+		rand.Read(s.s[:16])
+		s.s[15] &= (1 << 4) - 1
+	default:
+		// Generate a valid scalar in [0, l) by returning [0, 2^252) which has a
+		// negligibly different distribution (the former has a 2^-127.6 chance
+		// of being out of the latter range).
+		rand.Read(s.s[:])
+		s.s[31] &= (1 << 4) - 1
+	}
+	return reflect.ValueOf(s)
+}
+
+// quickCheckConfig1024 will make each quickcheck test run (1024 * -quickchecks)
+// times. The default value of -quickchecks is 100.
+var quickCheckConfig1024 = &quick.Config{MaxCountScale: 1 << 10}
+
+func TestScalarGenerate(t *testing.T) {
+	f := func(sc Scalar) bool {
+		return isReduced(&sc)
+	}
+	if err := quick.Check(f, quickCheckConfig1024); err != nil {
+		t.Errorf("generated unreduced scalar: %v", err)
+	}
+}
+
+func TestScalarSetCanonicalBytes(t *testing.T) {
+	f1 := func(in [32]byte, sc Scalar) bool {
+		// Mask out top 4 bits to guarantee value falls in [0, l).
+		in[len(in)-1] &= (1 << 4) - 1
+		if _, err := sc.SetCanonicalBytes(in[:]); err != nil {
+			return false
+		}
+		return bytes.Equal(in[:], sc.Bytes()) && isReduced(&sc)
+	}
+	if err := quick.Check(f1, quickCheckConfig1024); err != nil {
+		t.Errorf("failed bytes->scalar->bytes round-trip: %v", err)
+	}
+
+	f2 := func(sc1, sc2 Scalar) bool {
+		if _, err := sc2.SetCanonicalBytes(sc1.Bytes()); err != nil {
+			return false
+		}
+		return sc1 == sc2
+	}
+	if err := quick.Check(f2, quickCheckConfig1024); err != nil {
+		t.Errorf("failed scalar->bytes->scalar round-trip: %v", err)
+	}
+
+	b := scMinusOne.s
+	b[31] += 1
+	s := scOne
+	if out, err := s.SetCanonicalBytes(b[:]); err == nil {
+		t.Errorf("SetCanonicalBytes worked on a non-canonical value")
+	} else if s != scOne {
+		t.Errorf("SetCanonicalBytes modified its receiver")
+	} else if out != nil {
+		t.Errorf("SetCanonicalBytes did not return nil with an error")
+	}
+}
+
+func TestScalarSetUniformBytes(t *testing.T) {
+	mod, _ := new(big.Int).SetString("27742317777372353535851937790883648493", 10)
+	mod.Add(mod, new(big.Int).Lsh(big.NewInt(1), 252))
+	f := func(in [64]byte, sc Scalar) bool {
+		sc.SetUniformBytes(in[:])
+		if !isReduced(&sc) {
+			return false
+		}
+		scBig := bigIntFromLittleEndianBytes(sc.s[:])
+		inBig := bigIntFromLittleEndianBytes(in[:])
+		return inBig.Mod(inBig, mod).Cmp(scBig) == 0
+	}
+	if err := quick.Check(f, quickCheckConfig1024); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestScalarSetBytesWithClamping(t *testing.T) {
+	// Generated with libsodium.js 1.0.18 crypto_scalarmult_ed25519_base.
+
+	random := "633d368491364dc9cd4c1bf891b1d59460face1644813240a313e61f2c88216e"
+	s := new(Scalar).SetBytesWithClamping(decodeHex(random))
+	p := new(Point).ScalarBaseMult(s)
+	want := "1d87a9026fd0126a5736fe1628c95dd419172b5b618457e041c9c861b2494a94"
+	if got := hex.EncodeToString(p.Bytes()); got != want {
+		t.Errorf("random: got %q, want %q", got, want)
+	}
+
+	zero := "0000000000000000000000000000000000000000000000000000000000000000"
+	s = new(Scalar).SetBytesWithClamping(decodeHex(zero))
+	p = new(Point).ScalarBaseMult(s)
+	want = "693e47972caf527c7883ad1b39822f026f47db2ab0e1919955b8993aa04411d1"
+	if got := hex.EncodeToString(p.Bytes()); got != want {
+		t.Errorf("zero: got %q, want %q", got, want)
+	}
+
+	one := "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+	s = new(Scalar).SetBytesWithClamping(decodeHex(one))
+	p = new(Point).ScalarBaseMult(s)
+	want = "12e9a68b73fd5aacdbcaf3e88c46fea6ebedb1aa84eed1842f07f8edab65e3a7"
+	if got := hex.EncodeToString(p.Bytes()); got != want {
+		t.Errorf("one: got %q, want %q", got, want)
+	}
+}
+
+func bigIntFromLittleEndianBytes(b []byte) *big.Int {
+	bb := make([]byte, len(b))
+	for i := range b {
+		bb[i] = b[len(b)-i-1]
+	}
+	return new(big.Int).SetBytes(bb)
+}
+
+func TestScalarMultiplyDistributesOverAdd(t *testing.T) {
+	multiplyDistributesOverAdd := func(x, y, z Scalar) bool {
+		// Compute t1 = (x+y)*z
+		var t1 Scalar
+		t1.Add(&x, &y)
+		t1.Multiply(&t1, &z)
+
+		// Compute t2 = x*z + y*z
+		var t2 Scalar
+		var t3 Scalar
+		t2.Multiply(&x, &z)
+		t3.Multiply(&y, &z)
+		t2.Add(&t2, &t3)
+
+		return t1 == t2 && isReduced(&t1) && isReduced(&t3)
+	}
+
+	if err := quick.Check(multiplyDistributesOverAdd, quickCheckConfig1024); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestScalarAddLikeSubNeg(t *testing.T) {
+	addLikeSubNeg := func(x, y Scalar) bool {
+		// Compute t1 = x - y
+		var t1 Scalar
+		t1.Subtract(&x, &y)
+
+		// Compute t2 = -y + x
+		var t2 Scalar
+		t2.Negate(&y)
+		t2.Add(&t2, &x)
+
+		return t1 == t2 && isReduced(&t1)
+	}
+
+	if err := quick.Check(addLikeSubNeg, quickCheckConfig1024); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestScalarNonAdjacentForm(t *testing.T) {
+	s := Scalar{[32]byte{
+		0x1a, 0x0e, 0x97, 0x8a, 0x90, 0xf6, 0x62, 0x2d,
+		0x37, 0x47, 0x02, 0x3f, 0x8a, 0xd8, 0x26, 0x4d,
+		0xa7, 0x58, 0xaa, 0x1b, 0x88, 0xe0, 0x40, 0xd1,
+		0x58, 0x9e, 0x7b, 0x7f, 0x23, 0x76, 0xef, 0x09,
+	}}
+	expectedNaf := [256]int8{
+		0, 13, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, -9, 0, 0, 0, 0, -11, 0, 0, 0, 0, 3, 0, 0, 0, 0, 1,
+		0, 0, 0, 0, 9, 0, 0, 0, 0, -5, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 11, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0,
+		-9, 0, 0, 0, 0, 0, -3, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 9, 0,
+		0, 0, 0, -15, 0, 0, 0, 0, -7, 0, 0, 0, 0, -9, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, -3, 0,
+		0, 0, 0, -11, 0, 0, 0, 0, -7, 0, 0, 0, 0, -13, 0, 0, 0, 0, 11, 0, 0, 0, 0, -9, 0, 0, 0, 0, 0, 1, 0, 0,
+		0, 0, 0, -15, 0, 0, 0, 0, 1, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 13, 0, 0, 0,
+		0, 0, 0, 11, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, -9, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 7,
+		0, 0, 0, 0, 0, -15, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 15, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
+	}
+
+	sNaf := s.nonAdjacentForm(5)
+
+	for i := 0; i < 256; i++ {
+		if expectedNaf[i] != sNaf[i] {
+			t.Errorf("Wrong digit at position %d, got %d, expected %d", i, sNaf[i], expectedNaf[i])
+		}
+	}
+}
+
+type notZeroScalar Scalar
+
+func (notZeroScalar) Generate(rand *mathrand.Rand, size int) reflect.Value {
+	var s Scalar
+	for s == scZero {
+		s = Scalar{}.Generate(rand, size).Interface().(Scalar)
+	}
+	return reflect.ValueOf(notZeroScalar(s))
+}
+
+func TestScalarEqual(t *testing.T) {
+	if scOne.Equal(&scMinusOne) == 1 {
+		t.Errorf("scOne.Equal(&scMinusOne) is true")
+	}
+	if scMinusOne.Equal(&scMinusOne) == 0 {
+		t.Errorf("scMinusOne.Equal(&scMinusOne) is false")
+	}
+}
diff --git a/src/crypto/ed25519/internal/edwards25519/scalarmult.go b/src/crypto/ed25519/internal/edwards25519/scalarmult.go
new file mode 100644
index 0000000000..f7ca3cef99
--- /dev/null
+++ b/src/crypto/ed25519/internal/edwards25519/scalarmult.go
@@ -0,0 +1,214 @@
+// Copyright (c) 2019 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 edwards25519
+
+import "sync"
+
+// basepointTable is a set of 32 affineLookupTables, where table i is generated
+// from 256i * basepoint. It is precomputed the first time it's used.
+func basepointTable() *[32]affineLookupTable {
+	basepointTablePrecomp.initOnce.Do(func() {
+		p := NewGeneratorPoint()
+		for i := 0; i < 32; i++ {
+			basepointTablePrecomp.table[i].FromP3(p)
+			for j := 0; j < 8; j++ {
+				p.Add(p, p)
+			}
+		}
+	})
+	return &basepointTablePrecomp.table
+}
+
+var basepointTablePrecomp struct {
+	table    [32]affineLookupTable
+	initOnce sync.Once
+}
+
+// ScalarBaseMult sets v = x * B, where B is the canonical generator, and
+// returns v.
+//
+// The scalar multiplication is done in constant time.
+func (v *Point) ScalarBaseMult(x *Scalar) *Point {
+	basepointTable := basepointTable()
+
+	// Write x = sum(x_i * 16^i) so  x*B = sum( B*x_i*16^i )
+	// as described in the Ed25519 paper
+	//
+	// Group even and odd coefficients
+	// x*B     = x_0*16^0*B + x_2*16^2*B + ... + x_62*16^62*B
+	//         + x_1*16^1*B + x_3*16^3*B + ... + x_63*16^63*B
+	// x*B     = x_0*16^0*B + x_2*16^2*B + ... + x_62*16^62*B
+	//    + 16*( x_1*16^0*B + x_3*16^2*B + ... + x_63*16^62*B)
+	//
+	// We use a lookup table for each i to get x_i*16^(2*i)*B
+	// and do four doublings to multiply by 16.
+	digits := x.signedRadix16()
+
+	multiple := &affineCached{}
+	tmp1 := &projP1xP1{}
+	tmp2 := &projP2{}
+
+	// Accumulate the odd components first
+	v.Set(NewIdentityPoint())
+	for i := 1; i < 64; i += 2 {
+		basepointTable[i/2].SelectInto(multiple, digits[i])
+		tmp1.AddAffine(v, multiple)
+		v.fromP1xP1(tmp1)
+	}
+
+	// Multiply by 16
+	tmp2.FromP3(v)       // tmp2 =    v in P2 coords
+	tmp1.Double(tmp2)    // tmp1 =  2*v in P1xP1 coords
+	tmp2.FromP1xP1(tmp1) // tmp2 =  2*v in P2 coords
+	tmp1.Double(tmp2)    // tmp1 =  4*v in P1xP1 coords
+	tmp2.FromP1xP1(tmp1) // tmp2 =  4*v in P2 coords
+	tmp1.Double(tmp2)    // tmp1 =  8*v in P1xP1 coords
+	tmp2.FromP1xP1(tmp1) // tmp2 =  8*v in P2 coords
+	tmp1.Double(tmp2)    // tmp1 = 16*v in P1xP1 coords
+	v.fromP1xP1(tmp1)    // now v = 16*(odd components)
+
+	// Accumulate the even components
+	for i := 0; i < 64; i += 2 {
+		basepointTable[i/2].SelectInto(multiple, digits[i])
+		tmp1.AddAffine(v, multiple)
+		v.fromP1xP1(tmp1)
+	}
+
+	return v
+}
+
+// ScalarMult sets v = x * q, and returns v.
+//
+// The scalar multiplication is done in constant time.
+func (v *Point) ScalarMult(x *Scalar, q *Point) *Point {
+	checkInitialized(q)
+
+	var table projLookupTable
+	table.FromP3(q)
+
+	// Write x = sum(x_i * 16^i)
+	// so  x*Q = sum( Q*x_i*16^i )
+	//         = Q*x_0 + 16*(Q*x_1 + 16*( ... + Q*x_63) ... )
+	//           <------compute inside out---------
+	//
+	// We use the lookup table to get the x_i*Q values
+	// and do four doublings to compute 16*Q
+	digits := x.signedRadix16()
+
+	// Unwrap first loop iteration to save computing 16*identity
+	multiple := &projCached{}
+	tmp1 := &projP1xP1{}
+	tmp2 := &projP2{}
+	table.SelectInto(multiple, digits[63])
+
+	v.Set(NewIdentityPoint())
+	tmp1.Add(v, multiple) // tmp1 = x_63*Q in P1xP1 coords
+	for i := 62; i >= 0; i-- {
+		tmp2.FromP1xP1(tmp1) // tmp2 =    (prev) in P2 coords
+		tmp1.Double(tmp2)    // tmp1 =  2*(prev) in P1xP1 coords
+		tmp2.FromP1xP1(tmp1) // tmp2 =  2*(prev) in P2 coords
+		tmp1.Double(tmp2)    // tmp1 =  4*(prev) in P1xP1 coords
+		tmp2.FromP1xP1(tmp1) // tmp2 =  4*(prev) in P2 coords
+		tmp1.Double(tmp2)    // tmp1 =  8*(prev) in P1xP1 coords
+		tmp2.FromP1xP1(tmp1) // tmp2 =  8*(prev) in P2 coords
+		tmp1.Double(tmp2)    // tmp1 = 16*(prev) in P1xP1 coords
+		v.fromP1xP1(tmp1)    //    v = 16*(prev) in P3 coords
+		table.SelectInto(multiple, digits[i])
+		tmp1.Add(v, multiple) // tmp1 = x_i*Q + 16*(prev) in P1xP1 coords
+	}
+	v.fromP1xP1(tmp1)
+	return v
+}
+
+// basepointNafTable is the nafLookupTable8 for the basepoint.
+// It is precomputed the first time it's used.
+func basepointNafTable() *nafLookupTable8 {
+	basepointNafTablePrecomp.initOnce.Do(func() {
+		basepointNafTablePrecomp.table.FromP3(NewGeneratorPoint())
+	})
+	return &basepointNafTablePrecomp.table
+}
+
+var basepointNafTablePrecomp struct {
+	table    nafLookupTable8
+	initOnce sync.Once
+}
+
+// VarTimeDoubleScalarBaseMult sets v = a * A + b * B, where B is the canonical
+// generator, and returns v.
+//
+// Execution time depends on the inputs.
+func (v *Point) VarTimeDoubleScalarBaseMult(a *Scalar, A *Point, b *Scalar) *Point {
+	checkInitialized(A)
+
+	// Similarly to the single variable-base approach, we compute
+	// digits and use them with a lookup table.  However, because
+	// we are allowed to do variable-time operations, we don't
+	// need constant-time lookups or constant-time digit
+	// computations.
+	//
+	// So we use a non-adjacent form of some width w instead of
+	// radix 16.  This is like a binary representation (one digit
+	// for each binary place) but we allow the digits to grow in
+	// magnitude up to 2^{w-1} so that the nonzero digits are as
+	// sparse as possible.  Intuitively, this "condenses" the
+	// "mass" of the scalar onto sparse coefficients (meaning
+	// fewer additions).
+
+	basepointNafTable := basepointNafTable()
+	var aTable nafLookupTable5
+	aTable.FromP3(A)
+	// Because the basepoint is fixed, we can use a wider NAF
+	// corresponding to a bigger table.
+	aNaf := a.nonAdjacentForm(5)
+	bNaf := b.nonAdjacentForm(8)
+
+	// Find the first nonzero coefficient.
+	i := 255
+	for j := i; j >= 0; j-- {
+		if aNaf[j] != 0 || bNaf[j] != 0 {
+			break
+		}
+	}
+
+	multA := &projCached{}
+	multB := &affineCached{}
+	tmp1 := &projP1xP1{}
+	tmp2 := &projP2{}
+	tmp2.Zero()
+
+	// Move from high to low bits, doubling the accumulator
+	// at each iteration and checking whether there is a nonzero
+	// coefficient to look up a multiple of.
+	for ; i >= 0; i-- {
+		tmp1.Double(tmp2)
+
+		// Only update v if we have a nonzero coeff to add in.
+		if aNaf[i] > 0 {
+			v.fromP1xP1(tmp1)
+			aTable.SelectInto(multA, aNaf[i])
+			tmp1.Add(v, multA)
+		} else if aNaf[i] < 0 {
+			v.fromP1xP1(tmp1)
+			aTable.SelectInto(multA, -aNaf[i])
+			tmp1.Sub(v, multA)
+		}
+
+		if bNaf[i] > 0 {
+			v.fromP1xP1(tmp1)
+			basepointNafTable.SelectInto(multB, bNaf[i])
+			tmp1.AddAffine(v, multB)
+		} else if bNaf[i] < 0 {
+			v.fromP1xP1(tmp1)
+			basepointNafTable.SelectInto(multB, -bNaf[i])
+			tmp1.SubAffine(v, multB)
+		}
+
+		tmp2.FromP1xP1(tmp1)
+	}
+
+	v.fromP2(tmp2)
+	return v
+}
diff --git a/src/crypto/ed25519/internal/edwards25519/scalarmult_test.go b/src/crypto/ed25519/internal/edwards25519/scalarmult_test.go
new file mode 100644
index 0000000000..c2027f5ddb
--- /dev/null
+++ b/src/crypto/ed25519/internal/edwards25519/scalarmult_test.go
@@ -0,0 +1,209 @@
+// Copyright (c) 2019 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 edwards25519
+
+import (
+	"testing"
+	"testing/quick"
+)
+
+var (
+	// quickCheckConfig32 will make each quickcheck test run (32 * -quickchecks)
+	// times. The default value of -quickchecks is 100.
+	quickCheckConfig32 = &quick.Config{MaxCountScale: 1 << 5}
+
+	// a random scalar generated using dalek.
+	dalekScalar = Scalar{[32]byte{219, 106, 114, 9, 174, 249, 155, 89, 69, 203, 201, 93, 92, 116, 234, 187, 78, 115, 103, 172, 182, 98, 62, 103, 187, 136, 13, 100, 248, 110, 12, 4}}
+	// the above, times the edwards25519 basepoint.
+	dalekScalarBasepoint, _ = new(Point).SetBytes([]byte{0xf4, 0xef, 0x7c, 0xa, 0x34, 0x55, 0x7b, 0x9f, 0x72, 0x3b, 0xb6, 0x1e, 0xf9, 0x46, 0x9, 0x91, 0x1c, 0xb9, 0xc0, 0x6c, 0x17, 0x28, 0x2d, 0x8b, 0x43, 0x2b, 0x5, 0x18, 0x6a, 0x54, 0x3e, 0x48})
+)
+
+func TestScalarMultSmallScalars(t *testing.T) {
+	var z Scalar
+	var p Point
+	p.ScalarMult(&z, B)
+	if I.Equal(&p) != 1 {
+		t.Error("0*B != 0")
+	}
+	checkOnCurve(t, &p)
+
+	z = Scalar{[32]byte{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}
+	p.ScalarMult(&z, B)
+	if B.Equal(&p) != 1 {
+		t.Error("1*B != 1")
+	}
+	checkOnCurve(t, &p)
+}
+
+func TestScalarMultVsDalek(t *testing.T) {
+	var p Point
+	p.ScalarMult(&dalekScalar, B)
+	if dalekScalarBasepoint.Equal(&p) != 1 {
+		t.Error("Scalar mul does not match dalek")
+	}
+	checkOnCurve(t, &p)
+}
+
+func TestBaseMultVsDalek(t *testing.T) {
+	var p Point
+	p.ScalarBaseMult(&dalekScalar)
+	if dalekScalarBasepoint.Equal(&p) != 1 {
+		t.Error("Scalar mul does not match dalek")
+	}
+	checkOnCurve(t, &p)
+}
+
+func TestVarTimeDoubleBaseMultVsDalek(t *testing.T) {
+	var p Point
+	var z Scalar
+	p.VarTimeDoubleScalarBaseMult(&dalekScalar, B, &z)
+	if dalekScalarBasepoint.Equal(&p) != 1 {
+		t.Error("VarTimeDoubleScalarBaseMult fails with b=0")
+	}
+	checkOnCurve(t, &p)
+	p.VarTimeDoubleScalarBaseMult(&z, B, &dalekScalar)
+	if dalekScalarBasepoint.Equal(&p) != 1 {
+		t.Error("VarTimeDoubleScalarBaseMult fails with a=0")
+	}
+	checkOnCurve(t, &p)
+}
+
+func TestScalarMultDistributesOverAdd(t *testing.T) {
+	scalarMultDistributesOverAdd := func(x, y Scalar) bool {
+		var z Scalar
+		z.Add(&x, &y)
+		var p, q, r, check Point
+		p.ScalarMult(&x, B)
+		q.ScalarMult(&y, B)
+		r.ScalarMult(&z, B)
+		check.Add(&p, &q)
+		checkOnCurve(t, &p, &q, &r, &check)
+		return check.Equal(&r) == 1
+	}
+
+	if err := quick.Check(scalarMultDistributesOverAdd, quickCheckConfig32); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestScalarMultNonIdentityPoint(t *testing.T) {
+	// Check whether p.ScalarMult and q.ScalaBaseMult give the same,
+	// when p and q are originally set to the base point.
+
+	scalarMultNonIdentityPoint := func(x Scalar) bool {
+		var p, q Point
+		p.Set(B)
+		q.Set(B)
+
+		p.ScalarMult(&x, B)
+		q.ScalarBaseMult(&x)
+
+		checkOnCurve(t, &p, &q)
+
+		return p.Equal(&q) == 1
+	}
+
+	if err := quick.Check(scalarMultNonIdentityPoint, quickCheckConfig32); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestBasepointTableGeneration(t *testing.T) {
+	// The basepoint table is 32 affineLookupTables,
+	// corresponding to (16^2i)*B for table i.
+	basepointTable := basepointTable()
+
+	tmp1 := &projP1xP1{}
+	tmp2 := &projP2{}
+	tmp3 := &Point{}
+	tmp3.Set(B)
+	table := make([]affineLookupTable, 32)
+	for i := 0; i < 32; i++ {
+		// Build the table
+		table[i].FromP3(tmp3)
+		// Assert equality with the hardcoded one
+		if table[i] != basepointTable[i] {
+			t.Errorf("Basepoint table %d does not match", i)
+		}
+
+		// Set p = (16^2)*p = 256*p = 2^8*p
+		tmp2.FromP3(tmp3)
+		for j := 0; j < 7; j++ {
+			tmp1.Double(tmp2)
+			tmp2.FromP1xP1(tmp1)
+		}
+		tmp1.Double(tmp2)
+		tmp3.fromP1xP1(tmp1)
+		checkOnCurve(t, tmp3)
+	}
+}
+
+func TestScalarMultMatchesBaseMult(t *testing.T) {
+	scalarMultMatchesBaseMult := func(x Scalar) bool {
+		var p, q Point
+		p.ScalarMult(&x, B)
+		q.ScalarBaseMult(&x)
+		checkOnCurve(t, &p, &q)
+		return p.Equal(&q) == 1
+	}
+
+	if err := quick.Check(scalarMultMatchesBaseMult, quickCheckConfig32); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestBasepointNafTableGeneration(t *testing.T) {
+	var table nafLookupTable8
+	table.FromP3(B)
+
+	if table != *basepointNafTable() {
+		t.Error("BasepointNafTable does not match")
+	}
+}
+
+func TestVarTimeDoubleBaseMultMatchesBaseMult(t *testing.T) {
+	varTimeDoubleBaseMultMatchesBaseMult := func(x, y Scalar) bool {
+		var p, q1, q2, check Point
+
+		p.VarTimeDoubleScalarBaseMult(&x, B, &y)
+
+		q1.ScalarBaseMult(&x)
+		q2.ScalarBaseMult(&y)
+		check.Add(&q1, &q2)
+
+		checkOnCurve(t, &p, &check, &q1, &q2)
+		return p.Equal(&check) == 1
+	}
+
+	if err := quick.Check(varTimeDoubleBaseMultMatchesBaseMult, quickCheckConfig32); err != nil {
+		t.Error(err)
+	}
+}
+
+// Benchmarks.
+
+func BenchmarkScalarBaseMult(t *testing.B) {
+	var p Point
+
+	for i := 0; i < t.N; i++ {
+		p.ScalarBaseMult(&dalekScalar)
+	}
+}
+
+func BenchmarkScalarMult(t *testing.B) {
+	var p Point
+
+	for i := 0; i < t.N; i++ {
+		p.ScalarMult(&dalekScalar, B)
+	}
+}
+
+func BenchmarkVarTimeDoubleScalarBaseMult(t *testing.B) {
+	var p Point
+
+	for i := 0; i < t.N; i++ {
+		p.VarTimeDoubleScalarBaseMult(&dalekScalar, B, &dalekScalar)
+	}
+}
diff --git a/src/crypto/ed25519/internal/edwards25519/tables.go b/src/crypto/ed25519/internal/edwards25519/tables.go
new file mode 100644
index 0000000000..beec956bf7
--- /dev/null
+++ b/src/crypto/ed25519/internal/edwards25519/tables.go
@@ -0,0 +1,129 @@
+// Copyright (c) 2019 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 edwards25519
+
+import (
+	"crypto/subtle"
+)
+
+// A dynamic lookup table for variable-base, constant-time scalar muls.
+type projLookupTable struct {
+	points [8]projCached
+}
+
+// A precomputed lookup table for fixed-base, constant-time scalar muls.
+type affineLookupTable struct {
+	points [8]affineCached
+}
+
+// A dynamic lookup table for variable-base, variable-time scalar muls.
+type nafLookupTable5 struct {
+	points [8]projCached
+}
+
+// A precomputed lookup table for fixed-base, variable-time scalar muls.
+type nafLookupTable8 struct {
+	points [64]affineCached
+}
+
+// Constructors.
+
+// Builds a lookup table at runtime. Fast.
+func (v *projLookupTable) FromP3(q *Point) {
+	// Goal: v.points[i] = (i+1)*Q, i.e., Q, 2Q, ..., 8Q
+	// This allows lookup of -8Q, ..., -Q, 0, Q, ..., 8Q
+	v.points[0].FromP3(q)
+	tmpP3 := Point{}
+	tmpP1xP1 := projP1xP1{}
+	for i := 0; i < 7; i++ {
+		// Compute (i+1)*Q as Q + i*Q and convert to a ProjCached
+		// This is needlessly complicated because the API has explicit
+		// recievers instead of creating stack objects and relying on RVO
+		v.points[i+1].FromP3(tmpP3.fromP1xP1(tmpP1xP1.Add(q, &v.points[i])))
+	}
+}
+
+// This is not optimised for speed; fixed-base tables should be precomputed.
+func (v *affineLookupTable) FromP3(q *Point) {
+	// Goal: v.points[i] = (i+1)*Q, i.e., Q, 2Q, ..., 8Q
+	// This allows lookup of -8Q, ..., -Q, 0, Q, ..., 8Q
+	v.points[0].FromP3(q)
+	tmpP3 := Point{}
+	tmpP1xP1 := projP1xP1{}
+	for i := 0; i < 7; i++ {
+		// Compute (i+1)*Q as Q + i*Q and convert to AffineCached
+		v.points[i+1].FromP3(tmpP3.fromP1xP1(tmpP1xP1.AddAffine(q, &v.points[i])))
+	}
+}
+
+// Builds a lookup table at runtime. Fast.
+func (v *nafLookupTable5) FromP3(q *Point) {
+	// Goal: v.points[i] = (2*i+1)*Q, i.e., Q, 3Q, 5Q, ..., 15Q
+	// This allows lookup of -15Q, ..., -3Q, -Q, 0, Q, 3Q, ..., 15Q
+	v.points[0].FromP3(q)
+	q2 := Point{}
+	q2.Add(q, q)
+	tmpP3 := Point{}
+	tmpP1xP1 := projP1xP1{}
+	for i := 0; i < 7; i++ {
+		v.points[i+1].FromP3(tmpP3.fromP1xP1(tmpP1xP1.Add(&q2, &v.points[i])))
+	}
+}
+
+// This is not optimised for speed; fixed-base tables should be precomputed.
+func (v *nafLookupTable8) FromP3(q *Point) {
+	v.points[0].FromP3(q)
+	q2 := Point{}
+	q2.Add(q, q)
+	tmpP3 := Point{}
+	tmpP1xP1 := projP1xP1{}
+	for i := 0; i < 63; i++ {
+		v.points[i+1].FromP3(tmpP3.fromP1xP1(tmpP1xP1.AddAffine(&q2, &v.points[i])))
+	}
+}
+
+// Selectors.
+
+// Set dest to x*Q, where -8 <= x <= 8, in constant time.
+func (v *projLookupTable) SelectInto(dest *projCached, x int8) {
+	// Compute xabs = |x|
+	xmask := x >> 7
+	xabs := uint8((x + xmask) ^ xmask)
+
+	dest.Zero()
+	for j := 1; j <= 8; j++ {
+		// Set dest = j*Q if |x| = j
+		cond := subtle.ConstantTimeByteEq(xabs, uint8(j))
+		dest.Select(&v.points[j-1], dest, cond)
+	}
+	// Now dest = |x|*Q, conditionally negate to get x*Q
+	dest.CondNeg(int(xmask & 1))
+}
+
+// Set dest to x*Q, where -8 <= x <= 8, in constant time.
+func (v *affineLookupTable) SelectInto(dest *affineCached, x int8) {
+	// Compute xabs = |x|
+	xmask := x >> 7
+	xabs := uint8((x + xmask) ^ xmask)
+
+	dest.Zero()
+	for j := 1; j <= 8; j++ {
+		// Set dest = j*Q if |x| = j
+		cond := subtle.ConstantTimeByteEq(xabs, uint8(j))
+		dest.Select(&v.points[j-1], dest, cond)
+	}
+	// Now dest = |x|*Q, conditionally negate to get x*Q
+	dest.CondNeg(int(xmask & 1))
+}
+
+// Given odd x with 0 < x < 2^4, return x*Q (in variable time).
+func (v *nafLookupTable5) SelectInto(dest *projCached, x int8) {
+	*dest = v.points[x/2]
+}
+
+// Given odd x with 0 < x < 2^7, return x*Q (in variable time).
+func (v *nafLookupTable8) SelectInto(dest *affineCached, x int8) {
+	*dest = v.points[x/2]
+}
diff --git a/src/crypto/ed25519/internal/edwards25519/tables_test.go b/src/crypto/ed25519/internal/edwards25519/tables_test.go
new file mode 100644
index 0000000000..b5d161ad49
--- /dev/null
+++ b/src/crypto/ed25519/internal/edwards25519/tables_test.go
@@ -0,0 +1,119 @@
+// Copyright (c) 2019 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 edwards25519
+
+import (
+	"testing"
+)
+
+func TestProjLookupTable(t *testing.T) {
+	var table projLookupTable
+	table.FromP3(B)
+
+	var tmp1, tmp2, tmp3 projCached
+	table.SelectInto(&tmp1, 6)
+	table.SelectInto(&tmp2, -2)
+	table.SelectInto(&tmp3, -4)
+	// Expect T1 + T2 + T3 = identity
+
+	var accP1xP1 projP1xP1
+	accP3 := NewIdentityPoint()
+
+	accP1xP1.Add(accP3, &tmp1)
+	accP3.fromP1xP1(&accP1xP1)
+	accP1xP1.Add(accP3, &tmp2)
+	accP3.fromP1xP1(&accP1xP1)
+	accP1xP1.Add(accP3, &tmp3)
+	accP3.fromP1xP1(&accP1xP1)
+
+	if accP3.Equal(I) != 1 {
+		t.Errorf("Consistency check on ProjLookupTable.SelectInto failed!  %x %x %x", tmp1, tmp2, tmp3)
+	}
+}
+
+func TestAffineLookupTable(t *testing.T) {
+	var table affineLookupTable
+	table.FromP3(B)
+
+	var tmp1, tmp2, tmp3 affineCached
+	table.SelectInto(&tmp1, 3)
+	table.SelectInto(&tmp2, -7)
+	table.SelectInto(&tmp3, 4)
+	// Expect T1 + T2 + T3 = identity
+
+	var accP1xP1 projP1xP1
+	accP3 := NewIdentityPoint()
+
+	accP1xP1.AddAffine(accP3, &tmp1)
+	accP3.fromP1xP1(&accP1xP1)
+	accP1xP1.AddAffine(accP3, &tmp2)
+	accP3.fromP1xP1(&accP1xP1)
+	accP1xP1.AddAffine(accP3, &tmp3)
+	accP3.fromP1xP1(&accP1xP1)
+
+	if accP3.Equal(I) != 1 {
+		t.Errorf("Consistency check on ProjLookupTable.SelectInto failed!  %x %x %x", tmp1, tmp2, tmp3)
+	}
+}
+
+func TestNafLookupTable5(t *testing.T) {
+	var table nafLookupTable5
+	table.FromP3(B)
+
+	var tmp1, tmp2, tmp3, tmp4 projCached
+	table.SelectInto(&tmp1, 9)
+	table.SelectInto(&tmp2, 11)
+	table.SelectInto(&tmp3, 7)
+	table.SelectInto(&tmp4, 13)
+	// Expect T1 + T2 = T3 + T4
+
+	var accP1xP1 projP1xP1
+	lhs := NewIdentityPoint()
+	rhs := NewIdentityPoint()
+
+	accP1xP1.Add(lhs, &tmp1)
+	lhs.fromP1xP1(&accP1xP1)
+	accP1xP1.Add(lhs, &tmp2)
+	lhs.fromP1xP1(&accP1xP1)
+
+	accP1xP1.Add(rhs, &tmp3)
+	rhs.fromP1xP1(&accP1xP1)
+	accP1xP1.Add(rhs, &tmp4)
+	rhs.fromP1xP1(&accP1xP1)
+
+	if lhs.Equal(rhs) != 1 {
+		t.Errorf("Consistency check on nafLookupTable5 failed")
+	}
+}
+
+func TestNafLookupTable8(t *testing.T) {
+	var table nafLookupTable8
+	table.FromP3(B)
+
+	var tmp1, tmp2, tmp3, tmp4 affineCached
+	table.SelectInto(&tmp1, 49)
+	table.SelectInto(&tmp2, 11)
+	table.SelectInto(&tmp3, 35)
+	table.SelectInto(&tmp4, 25)
+	// Expect T1 + T2 = T3 + T4
+
+	var accP1xP1 projP1xP1
+	lhs := NewIdentityPoint()
+	rhs := NewIdentityPoint()
+
+	accP1xP1.AddAffine(lhs, &tmp1)
+	lhs.fromP1xP1(&accP1xP1)
+	accP1xP1.AddAffine(lhs, &tmp2)
+	lhs.fromP1xP1(&accP1xP1)
+
+	accP1xP1.AddAffine(rhs, &tmp3)
+	rhs.fromP1xP1(&accP1xP1)
+	accP1xP1.AddAffine(rhs, &tmp4)
+	rhs.fromP1xP1(&accP1xP1)
+
+	if lhs.Equal(rhs) != 1 {
+		t.Errorf("Consistency check on nafLookupTable8 failed")
+	}
+}
diff --git a/src/go/build/deps_test.go b/src/go/build/deps_test.go
index 9cdfb898ba..bb6d92f89a 100644
--- a/src/go/build/deps_test.go
+++ b/src/go/build/deps_test.go
@@ -392,6 +392,8 @@ var depsRules = `
 	< crypto
 	< crypto/subtle
 	< crypto/internal/subtle
+	< crypto/ed25519/internal/edwards25519/field
+	< crypto/ed25519/internal/edwards25519
 	< crypto/cipher
 	< crypto/aes, crypto/des, crypto/hmac, crypto/md5, crypto/rc4,
 	  crypto/sha1, crypto/sha256, crypto/sha512
@@ -403,7 +405,6 @@ var depsRules = `
 	CRYPTO, FMT, math/big
 	< crypto/rand
 	< crypto/internal/randutil
-	< crypto/ed25519/internal/edwards25519
 	< crypto/ed25519
 	< encoding/asn1
 	< golang.org/x/crypto/cryptobyte/asn1
diff --git a/src/go/types/stdlib_test.go b/src/go/types/stdlib_test.go
index 29f71137df..b565956e08 100644
--- a/src/go/types/stdlib_test.go
+++ b/src/go/types/stdlib_test.go
@@ -306,6 +306,13 @@ func (w *walker) walk(dir string) {
 		return
 	}
 
+	// skip submodules, which might not be vendored
+	for _, f := range files {
+		if f.Name() == "go.mod" {
+			return
+		}
+	}
+
 	// apply pkgh to the files in directory dir
 	// but ignore files directly under $GOROOT/src (might be temporary test files).
 	if dir != filepath.Join(runtime.GOROOT(), "src") {
-- 
GitLab


From 15557af207f67e30a90977c5882e83103df54d49 Mon Sep 17 00:00:00 2001
From: Dmitri Shuralyov <dmitshur@golang.org>
Date: Wed, 5 May 2021 13:06:49 -0400
Subject: [PATCH 1982/2400] doc/go1.17: fill in Go 1.17 release note TODOs
 using relnote

For #44513.

Change-Id: I8e0b044ebe39e3406c96f219eb921518f047be3e
Reviewed-on: https://go-review.googlesource.com/c/go/+/317273
Trust: Dmitri Shuralyov <dmitshur@golang.org>
Run-TryBot: Dmitri Shuralyov <dmitshur@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Heschi Kreinick <heschi@google.com>
---
 doc/go1.17.html | 287 ++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 266 insertions(+), 21 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 7993663838..9f33486869 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -46,7 +46,7 @@ Do not send CLs removing the interior tags from such phrases.
 <h2 id="tools">Tools</h2>
 
 <p>
-  TODO: complete this section, or delete if not needed
+  TODO: complete the Tools section
 </p>
 
 <h3 id="go-command">Go command</h3>
@@ -157,28 +157,46 @@ Do not send CLs removing the interior tags from such phrases.
   password-protected SSH keys.
 </p>
 
+<p><!-- CL 249759 -->
+  TODO: <a href="https://golang.org/cl/249759">https://golang.org/cl/249759</a>: cmd/cover: replace code using optimized golang.org/x/tools/cover
+</p>
+
+<h3 id="vet">Vet</h3>
+
+<p><!-- CL 299532 -->
+  TODO: <a href="https://golang.org/cl/299532">https://golang.org/cl/299532</a>: cmd/vet: bring in sigchanyzer to report unbuffered channels to signal.Notify
+</p>
+
+<p>
+  TODO: complete the Vet section
+</p>
+
 <h2 id="runtime">Runtime</h2>
 
+<p><!-- CL 304470 -->
+  TODO: <a href="https://golang.org/cl/304470">https://golang.org/cl/304470</a>: cmd/compile, runtime: add metadata for argument printing in traceback
+</p>
+
 <p>
-  TODO: complete this section, or delete if not needed
+  TODO: complete the Runtime section
 </p>
 
 <h2 id="compiler">Compiler</h2>
 
 <p>
-  TODO: complete this section, or delete if not needed
+  TODO: complete the Compiler section, or delete if not needed
 </p>
 
 <h2 id="linker">Linker</h2>
 
 <p>
-  TODO: complete this section, or delete if not needed
+  TODO: complete the Linker section, or delete if not needed
 </p>
 
 <h2 id="library">Core library</h2>
 
 <p>
-  TODO: complete this section
+  TODO: complete the Core library section
 </p>
 
 <h3 id="crypto/tls"><a href="/pkg/crypto/tls">crypto/tls</a></h3>
@@ -201,10 +219,10 @@ Do not send CLs removing the interior tags from such phrases.
 <h3 id="runtime/cgo"><a href="/pkg/runtime/cgo">Cgo</a></h3>
 
 <p>
-The <a href="/pkg/runtime/cgo">runtime/cgo</a> package now provides a
-new facility that allows to turn any Go values to a safe representation
-that can be used to pass values between C and Go safely. See
-<a href="/pkg/runtime/cgo#Handle">runtime/cgo.Handle</a> for more information.
+  The <a href="/pkg/runtime/cgo">runtime/cgo</a> package now provides a
+  new facility that allows to turn any Go values to a safe representation
+  that can be used to pass values between C and Go safely. See
+  <a href="/pkg/runtime/cgo#Handle">runtime/cgo.Handle</a> for more information.
 </p>
 
 <h3 id="minor_library_changes">Minor changes to the library</h3>
@@ -215,24 +233,251 @@ that can be used to pass values between C and Go safely. See
   in mind.
 </p>
 
+<dl id="archive/zip"><dt><a href="/pkg/archive/zip/">archive/zip</a></dt>
+  <dd>
+    <p><!-- CL 312310 -->
+      TODO: <a href="https://golang.org/cl/312310">https://golang.org/cl/312310</a>: add File.OpenRaw, Writer.CreateRaw, Writer.Copy
+    </p>
+  </dd>
+</dl><!-- archive/zip -->
+
+<dl id="bufio, bytes, strings"><dt><a href="/pkg/bufio, bytes, strings/">bufio, bytes, strings</a></dt>
+  <dd>
+    <p><!-- CL 280492 -->
+      TODO: <a href="https://golang.org/cl/280492">https://golang.org/cl/280492</a>: handle negative runes in WriteRune
+    </p>
+  </dd>
+</dl><!-- bufio, bytes, strings -->
+
+<dl id="compress/lzw"><dt><a href="/pkg/compress/lzw/">compress/lzw</a></dt>
+  <dd>
+    <p><!-- CL 273667 -->
+      TODO: <a href="https://golang.org/cl/273667">https://golang.org/cl/273667</a>: add Reset method to Reader and Writer
+    </p>
+  </dd>
+</dl><!-- compress/lzw -->
+
+<dl id="crypto/rsa"><dt><a href="/pkg/crypto/rsa/">crypto/rsa</a></dt>
+  <dd>
+    <p><!-- CL 302230 -->
+      TODO: <a href="https://golang.org/cl/302230">https://golang.org/cl/302230</a>: fix salt length calculation with PSSSaltLengthAuto
+    </p>
+  </dd>
+</dl><!-- crypto/rsa -->
+
+<dl id="database/sql"><dt><a href="/pkg/database/sql/">database/sql</a></dt>
+  <dd>
+    <p><!-- CL 258360 -->
+      TODO: <a href="https://golang.org/cl/258360">https://golang.org/cl/258360</a>: close driver.Connector if it implements io.Closer
+    </p>
+
+    <p><!-- CL 311572 -->
+      TODO: <a href="https://golang.org/cl/311572">https://golang.org/cl/311572</a>: add NullInt16 and NullByte
+    </p>
+  </dd>
+</dl><!-- database/sql -->
+
+<dl id="encoding/binary"><dt><a href="/pkg/encoding/binary/">encoding/binary</a></dt>
+  <dd>
+    <p><!-- CL 299531 -->
+      TODO: <a href="https://golang.org/cl/299531">https://golang.org/cl/299531</a>: limit bytes read by Uvarint to &lt;= 10
+    </p>
+  </dd>
+</dl><!-- encoding/binary -->
+
+<dl id="flag"><dt><a href="/pkg/flag/">flag</a></dt>
+  <dd>
+    <p><!-- CL 271788 -->
+      TODO: <a href="https://golang.org/cl/271788">https://golang.org/cl/271788</a>: panic if flag name begins with - or contains =
+    </p>
+  </dd>
+</dl><!-- flag -->
+
+<dl id="io/fs"><dt><a href="/pkg/io/fs/">io/fs</a></dt>
+  <dd>
+    <p><!-- CL 293649 -->
+      TODO: <a href="https://golang.org/cl/293649">https://golang.org/cl/293649</a>: implement FileInfoToDirEntry
+    </p>
+  </dd>
+</dl><!-- io/fs -->
+
+<dl id="math"><dt><a href="/pkg/math/">math</a></dt>
+  <dd>
+    <p><!-- CL 247058 -->
+      TODO: <a href="https://golang.org/cl/247058">https://golang.org/cl/247058</a>: add MaxUint, MinInt, MaxInt
+    </p>
+  </dd>
+</dl><!-- math -->
+
+<dl id="mime"><dt><a href="/pkg/mime/">mime</a></dt>
+  <dd>
+    <p><!-- CL 305230 -->
+      TODO: <a href="https://golang.org/cl/305230">https://golang.org/cl/305230</a>: support reading shared mime-info database on unix systems
+    </p>
+  </dd>
+</dl><!-- mime -->
+
+<dl id="net"><dt><a href="/pkg/net/">net</a></dt>
+  <dd>
+    <p><!-- CL 272668 -->
+      TODO: <a href="https://golang.org/cl/272668">https://golang.org/cl/272668</a>: add IP.IsPrivate
+    </p>
+
+    <p><!-- CL 301709 -->
+      TODO: <a href="https://golang.org/cl/301709">https://golang.org/cl/301709</a>: make go resolver aware of network parameter
+    </p>
+
+    <p><!-- CL 307030 -->
+      TODO: <a href="https://golang.org/cl/307030">https://golang.org/cl/307030</a>: make ErrClosed and ParseError implement net.Error
+    </p>
+  </dd>
+</dl><!-- net -->
+
 <dl id="net/http"><dt><a href="/pkg/net/http/">net/http</a></dt>
-  <p>
-    The <a href="/pkg/net/http/"><code>net/http</code></a> package now uses the new
-    <a href="/pkg/crypto/tls#Conn.HandshakeContext"><code>(*tls.Conn).HandshakeContext</code></a>
-    with the <a href="/pkg/net/http/#Request"><code>Request</code></a> context
-    when performing TLS handshakes in the client or server.
-  </p>
+  <dd>
+    <p><!-- CL 295370 -->
+      The <a href="/pkg/net/http/"><code>net/http</code></a> package now uses the new
+      <a href="/pkg/crypto/tls#Conn.HandshakeContext"><code>(*tls.Conn).HandshakeContext</code></a>
+      with the <a href="/pkg/net/http/#Request"><code>Request</code></a> context
+      when performing TLS handshakes in the client or server.
+    </p>
+
+    <p><!-- CL 235437 -->
+      TODO: <a href="https://golang.org/cl/235437">https://golang.org/cl/235437</a>: add to deadlines only when positive
+    </p>
+
+    <p><!-- CL 308952 -->
+      TODO: <a href="https://golang.org/cl/308952">https://golang.org/cl/308952</a>: make ReadRequest return an error when requests have multiple Host headers
+    </p>
+  </dd>
 </dl><!-- net/http -->
 
+<dl id="net/http/httptest"><dt><a href="/pkg/net/http/httptest/">net/http/httptest</a></dt>
+  <dd>
+    <p><!-- CL 308950 -->
+      TODO: <a href="https://golang.org/cl/308950">https://golang.org/cl/308950</a>: panic on non-3 digit (XXX) status code in Recorder.WriteHeader
+    </p>
+  </dd>
+</dl><!-- net/http/httptest -->
+
+<dl id="net/url"><dt><a href="/pkg/net/url/">net/url</a></dt>
+  <dd>
+    <p><!-- CL 314850 -->
+      TODO: <a href="https://golang.org/cl/314850">https://golang.org/cl/314850</a>: add Values.Has
+    </p>
+  </dd>
+</dl><!-- net/url -->
+
+<dl id="os"><dt><a href="/pkg/os/">os</a></dt>
+  <dd>
+    <p><!-- CL 268020 -->
+      TODO: <a href="https://golang.org/cl/268020">https://golang.org/cl/268020</a>: avoid allocation in File.WriteString
+    </p>
+  </dd>
+</dl><!-- os -->
+
+<dl id="reflect"><dt><a href="/pkg/reflect/">reflect</a></dt>
+  <dd>
+    <p><!-- CL 266197 -->
+      TODO: <a href="https://golang.org/cl/266197">https://golang.org/cl/266197</a>: add Method.IsExported and StructField.IsExported methods
+    </p>
+
+    <p><!-- CL 281233 -->
+      TODO: <a href="https://golang.org/cl/281233">https://golang.org/cl/281233</a>: add VisibleFields function
+    </p>
+
+    <p><!-- CL 284136 -->
+      TODO: <a href="https://golang.org/cl/284136">https://golang.org/cl/284136</a>: panic if ArrayOf is called with negative length
+    </p>
+  </dd>
+</dl><!-- reflect -->
+
+<dl id="spec"><dt><a href="/pkg/spec/">spec</a></dt>
+  <dd>
+    <p><!-- CL 216424 -->
+      TODO: <a href="https://golang.org/cl/216424">https://golang.org/cl/216424</a>: allow conversion from slice to array ptr
+    </p>
+  </dd>
+</dl><!-- spec -->
+
+<dl id="strconv"><dt><a href="/pkg/strconv/">strconv</a></dt>
+  <dd>
+    <p><!-- CL 170079 -->
+      TODO: <a href="https://golang.org/cl/170079">https://golang.org/cl/170079</a>: implement Ryū-like algorithm for fixed precision ftoa
+    </p>
+
+    <p><!-- CL 170080 -->
+      TODO: <a href="https://golang.org/cl/170080">https://golang.org/cl/170080</a>: Implement Ryū algorithm for ftoa shortest mode
+    </p>
+
+    <p><!-- CL 314775 -->
+      TODO: <a href="https://golang.org/cl/314775">https://golang.org/cl/314775</a>: add QuotedPrefix
+    </p>
+  </dd>
+</dl><!-- strconv -->
+
+<dl id="sync/atomic"><dt><a href="/pkg/sync/atomic/">sync/atomic</a></dt>
+  <dd>
+    <p><!-- CL 241678 -->
+      TODO: <a href="https://golang.org/cl/241678">https://golang.org/cl/241678</a>: add (*Value).Swap and (*Value).CompareAndSwap
+    </p>
+  </dd>
+</dl><!-- sync/atomic -->
+
+<dl id="syscall"><dt><a href="/pkg/syscall/">syscall</a></dt>
+  <dd>
+    <p><!-- CL 295371 -->
+      TODO: <a href="https://golang.org/cl/295371">https://golang.org/cl/295371</a>: do not overflow key memory in GetQueuedCompletionStatus
+    </p>
+
+    <p><!-- CL 313653 -->
+      TODO: <a href="https://golang.org/cl/313653">https://golang.org/cl/313653</a>: restore signal mask after setting foreground process group
+    </p>
+  </dd>
+</dl><!-- syscall -->
+
+<dl id="testing"><dt><a href="/pkg/testing/">testing</a></dt>
+  <dd>
+    <p><!-- CL 310033 -->
+      TODO: <a href="https://golang.org/cl/310033">https://golang.org/cl/310033</a>: add -shuffle=off|on|N to alter the execution order of tests and benchmarks
+    </p>
+  </dd>
+</dl><!-- testing -->
+
+<dl id="text/template/parse"><dt><a href="/pkg/text/template/parse/">text/template/parse</a></dt>
+  <dd>
+    <p><!-- CL 301493 -->
+      TODO: <a href="https://golang.org/cl/301493">https://golang.org/cl/301493</a>: add a mode to skip func-check on parsing
+    </p>
+  </dd>
+</dl><!-- text/template/parse -->
+
 <dl id="time"><dt><a href="/pkg/time/">time</a></dt>
   <dd>
     <p><!-- CL 260858 -->
-    time.Time now has a <a href="/pkg/time/#Time.GoString">GoString</a>
-    method that will return a more useful value for times when printed with
-    the <code>"%#v"</code> format specifier in the fmt package.
+      time.Time now has a <a href="/pkg/time/#Time.GoString">GoString</a>
+      method that will return a more useful value for times when printed with
+      the <code>"%#v"</code> format specifier in the fmt package.
+    </p>
+
+    <p><!-- CL 264077 -->
+      TODO: <a href="https://golang.org/cl/264077">https://golang.org/cl/264077</a>: add Time.IsDST() to check if its Location is in Daylight Savings Time
+    </p>
+
+    <p><!-- CL 293349 -->
+      TODO: <a href="https://golang.org/cl/293349">https://golang.org/cl/293349</a>: add Time.Unix{Milli,Micro} and to-Time helpers UnixMicro, UnixMilli
+    </p>
+
+    <p><!-- CL 300996 -->
+      TODO: <a href="https://golang.org/cl/300996">https://golang.org/cl/300996</a>: support &#34;,&#34; as separator for fractional seconds
     </p>
   </dd>
 </dl><!-- time -->
-<p>
-  TODO: complete this section
-</p>
+
+<dl id="unicode"><dt><a href="/pkg/unicode/">unicode</a></dt>
+  <dd>
+    <p><!-- CL 280493 -->
+      TODO: <a href="https://golang.org/cl/280493">https://golang.org/cl/280493</a>: correctly handle negative runes
+    </p>
+  </dd>
+</dl><!-- unicode -->
-- 
GitLab


From cf73f1a8e40f44c0d3c69d63a5815861d685a845 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Fri, 30 Apr 2021 16:58:56 -0400
Subject: [PATCH 1983/2400] go/parser: don't parse a nil IndexExpr.Index

When parsing type parameters, an empty type instantiation was parsed as
an IndexExpr with nil Index. This should be considered a breaking change
to parsing: ast.Walk previously assumed that Index was non-nil.

Back out the nil check in ast.Walk, and for now pack an empty argument
list as a non-nil ListExpr with nil Elems.

Alternatives considered:
 - Parsing the entire index expression as a BadExpr: this led to
   inferior errors while type checking.
 - Parsing the Index as a BadExpr: this seems reasonable, but encodes
   strictly less information into the AST.

We may want to opt for one of these alternatives in the future, but for
now let's just fix the breaking change.

Change-Id: I93f2b89641692ac014b8ee98bfa031ed3477afb8
Reviewed-on: https://go-review.googlesource.com/c/go/+/315851
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/ast/walk.go                         | 6 +-----
 src/go/internal/typeparams/notypeparams.go | 2 --
 src/go/internal/typeparams/typeparams.go   | 5 ++++-
 src/go/parser/parser.go                    | 1 +
 4 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/src/go/ast/walk.go b/src/go/ast/walk.go
index ac1395fafd..9224264e29 100644
--- a/src/go/ast/walk.go
+++ b/src/go/ast/walk.go
@@ -112,11 +112,7 @@ func Walk(v Visitor, node Node) {
 
 	case *IndexExpr:
 		Walk(v, n.X)
-		// n.Index may be nil for invalid type instantiation expressions, e.g.
-		// var x T[].
-		if n.Index != nil {
-			Walk(v, n.Index)
-		}
+		Walk(v, n.Index)
 
 	case *SliceExpr:
 		Walk(v, n.X)
diff --git a/src/go/internal/typeparams/notypeparams.go b/src/go/internal/typeparams/notypeparams.go
index a8c25ac2b1..2ceafaac1c 100644
--- a/src/go/internal/typeparams/notypeparams.go
+++ b/src/go/internal/typeparams/notypeparams.go
@@ -15,8 +15,6 @@ const Enabled = false
 
 func PackExpr(list []ast.Expr) ast.Expr {
 	switch len(list) {
-	case 0:
-		return nil
 	case 1:
 		return list[0]
 	default:
diff --git a/src/go/internal/typeparams/typeparams.go b/src/go/internal/typeparams/typeparams.go
index 66f66afb28..871e95d998 100644
--- a/src/go/internal/typeparams/typeparams.go
+++ b/src/go/internal/typeparams/typeparams.go
@@ -17,7 +17,10 @@ const Enabled = true
 func PackExpr(list []ast.Expr) ast.Expr {
 	switch len(list) {
 	case 0:
-		return nil
+		// Return an empty ListExpr here, rather than nil, as IndexExpr.Index must
+		// never be nil.
+		// TODO(rFindley) would a BadExpr be more appropriate here?
+		return &ast.ListExpr{}
 	case 1:
 		return list[0]
 	default:
diff --git a/src/go/parser/parser.go b/src/go/parser/parser.go
index 36a044e3a2..3965641713 100644
--- a/src/go/parser/parser.go
+++ b/src/go/parser/parser.go
@@ -1095,6 +1095,7 @@ func (p *parser) parseChanType() *ast.ChanType {
 }
 
 func (p *parser) parseTypeInstance(typ ast.Expr) ast.Expr {
+	assert(p.parseTypeParams(), "parseTypeInstance while not parsing type params")
 	if p.trace {
 		defer un(trace(p, "TypeInstance"))
 	}
-- 
GitLab


From 43c390a1fabfa5eb81529f399bb4d1875f1ca35d Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Wed, 5 May 2021 21:32:04 -0400
Subject: [PATCH 1984/2400] crypto/ed25519: skip allocations test on -noopt
 builder

Without optimizations, there will be unexpected allocations.

Change-Id: I90dc2636279b7fda7689eabc763251c4cdd25874
Reviewed-on: https://go-review.googlesource.com/c/go/+/317370
Trust: Filippo Valsorda <filippo@golang.org>
Run-TryBot: Filippo Valsorda <filippo@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/crypto/ed25519/ed25519_test.go                           | 3 +++
 .../ed25519/internal/edwards25519/edwards25519_test.go       | 5 +++++
 2 files changed, 8 insertions(+)

diff --git a/src/crypto/ed25519/ed25519_test.go b/src/crypto/ed25519/ed25519_test.go
index ba9970e23e..8a973b36ea 100644
--- a/src/crypto/ed25519/ed25519_test.go
+++ b/src/crypto/ed25519/ed25519_test.go
@@ -186,6 +186,9 @@ func TestMalleability(t *testing.T) {
 }
 
 func TestAllocations(t *testing.T) {
+	if strings.HasSuffix(os.Getenv("GO_BUILDER_NAME"), "-noopt") {
+		t.Skip("skipping allocations test without relevant optimizations")
+	}
 	if allocs := testing.AllocsPerRun(100, func() {
 		seed := make([]byte, SeedSize)
 		message := []byte("Hello, world!")
diff --git a/src/crypto/ed25519/internal/edwards25519/edwards25519_test.go b/src/crypto/ed25519/internal/edwards25519/edwards25519_test.go
index ac7c78c086..8031256525 100644
--- a/src/crypto/ed25519/internal/edwards25519/edwards25519_test.go
+++ b/src/crypto/ed25519/internal/edwards25519/edwards25519_test.go
@@ -7,7 +7,9 @@ package edwards25519
 import (
 	"crypto/ed25519/internal/edwards25519/field"
 	"encoding/hex"
+	"os"
 	"reflect"
+	"strings"
 	"testing"
 )
 
@@ -279,6 +281,9 @@ func TestNonCanonicalPoints(t *testing.T) {
 var testAllocationsSink byte
 
 func TestAllocations(t *testing.T) {
+	if strings.HasSuffix(os.Getenv("GO_BUILDER_NAME"), "-noopt") {
+		t.Skip("skipping allocations test without relevant optimizations")
+	}
 	if allocs := testing.AllocsPerRun(100, func() {
 		p := NewIdentityPoint()
 		p.Add(p, NewGeneratorPoint())
-- 
GitLab


From 1108cbe60b87196ce739ff8bce08c9862d6b61f0 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Fri, 30 Apr 2021 23:10:26 -0400
Subject: [PATCH 1985/2400] crypto/ecdsa,crypto/elliptic: improve tests and
 benchmarks

Ensured all tests and benchmarks run over all curves.

Change-Id: Idcbe14a50c60ff6c2cd56793bced6b428d049c39
Reviewed-on: https://go-review.googlesource.com/c/go/+/315272
Trust: Filippo Valsorda <filippo@golang.org>
Trust: Katie Hockman <katie@golang.org>
Run-TryBot: Filippo Valsorda <filippo@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
Reviewed-by: Roland Shoemaker <roland@golang.org>
---
 src/crypto/ecdsa/ecdsa_s390x.go      |   6 +
 src/crypto/ecdsa/ecdsa_s390x_test.go |  19 +-
 src/crypto/ecdsa/ecdsa_test.go       | 284 +++++------
 src/crypto/elliptic/elliptic_test.go | 703 +++++----------------------
 src/crypto/elliptic/fuzz_test.go     |   1 -
 src/crypto/elliptic/p224_test.go     | 315 ++++++++++++
 src/crypto/elliptic/p256_test.go     | 155 ++++++
 7 files changed, 752 insertions(+), 731 deletions(-)
 create mode 100644 src/crypto/elliptic/p256_test.go

diff --git a/src/crypto/ecdsa/ecdsa_s390x.go b/src/crypto/ecdsa/ecdsa_s390x.go
index 0a1d73e7a4..1480d1bf6f 100644
--- a/src/crypto/ecdsa/ecdsa_s390x.go
+++ b/src/crypto/ecdsa/ecdsa_s390x.go
@@ -21,12 +21,18 @@ import (
 //go:noescape
 func kdsa(fc uint64, params *[4096]byte) (errn uint64)
 
+// testingDisableKDSA forces the generic fallback path. It must only be set in tests.
+var testingDisableKDSA bool
+
 // canUseKDSA checks if KDSA instruction is available, and if it is, it checks
 // the name of the curve to see if it matches the curves supported(P-256, P-384, P-521).
 // Then, based on the curve name, a function code and a block size will be assigned.
 // If KDSA instruction is not available or if the curve is not supported, canUseKDSA
 // will set ok to false.
 func canUseKDSA(c elliptic.Curve) (functionCode uint64, blockSize int, ok bool) {
+	if testingDisableKDSA {
+		return 0, 0, false
+	}
 	if !cpu.S390X.HasECDSA {
 		return 0, 0, false
 	}
diff --git a/src/crypto/ecdsa/ecdsa_s390x_test.go b/src/crypto/ecdsa/ecdsa_s390x_test.go
index e8b16b3668..f5633fb8a6 100644
--- a/src/crypto/ecdsa/ecdsa_s390x_test.go
+++ b/src/crypto/ecdsa/ecdsa_s390x_test.go
@@ -13,6 +13,9 @@ import (
 )
 
 func TestNoAsm(t *testing.T) {
+	testingDisableKDSA = true
+	defer func() { testingDisableKDSA = false }()
+
 	curves := [...]elliptic.Curve{
 		elliptic.P256(),
 		elliptic.P384(),
@@ -20,15 +23,11 @@ func TestNoAsm(t *testing.T) {
 	}
 
 	for _, curve := range curves {
-		// override the name of the curve to stop the assembly path being taken
-		params := *curve.Params()
-		name := params.Name
-		params.Name = name + "_GENERIC_OVERRIDE"
-
-		testKeyGeneration(t, &params, name)
-		testSignAndVerify(t, &params, name)
-		testNonceSafety(t, &params, name)
-		testINDCCA(t, &params, name)
-		testNegativeInputs(t, &params, name)
+		name := curve.Params().Name
+		t.Run(name, func(t *testing.T) { testKeyGeneration(t, curve) })
+		t.Run(name, func(t *testing.T) { testSignAndVerify(t, curve) })
+		t.Run(name, func(t *testing.T) { testNonceSafety(t, curve) })
+		t.Run(name, func(t *testing.T) { testINDCCA(t, curve) })
+		t.Run(name, func(t *testing.T) { testNegativeInputs(t, curve) })
 	}
 }
diff --git a/src/crypto/ecdsa/ecdsa_test.go b/src/crypto/ecdsa/ecdsa_test.go
index 0c1ff6d200..556818acf4 100644
--- a/src/crypto/ecdsa/ecdsa_test.go
+++ b/src/crypto/ecdsa/ecdsa_test.go
@@ -21,216 +21,148 @@ import (
 	"testing"
 )
 
-func testKeyGeneration(t *testing.T, c elliptic.Curve, tag string) {
-	priv, err := GenerateKey(c, rand.Reader)
-	if err != nil {
-		t.Errorf("%s: error: %s", tag, err)
-		return
+func testAllCurves(t *testing.T, f func(*testing.T, elliptic.Curve)) {
+	tests := []struct {
+		name  string
+		curve elliptic.Curve
+	}{
+		{"P256", elliptic.P256()},
+		{"P224", elliptic.P224()},
+		{"P384", elliptic.P384()},
+		{"P521", elliptic.P521()},
 	}
-	if !c.IsOnCurve(priv.PublicKey.X, priv.PublicKey.Y) {
-		t.Errorf("%s: public key invalid: %s", tag, err)
-	}
-}
-
-func TestKeyGeneration(t *testing.T) {
-	testKeyGeneration(t, elliptic.P224(), "p224")
 	if testing.Short() {
-		return
+		tests = tests[:1]
+	}
+	for _, test := range tests {
+		curve := test.curve
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			f(t, curve)
+		})
 	}
-	testKeyGeneration(t, elliptic.P256(), "p256")
-	testKeyGeneration(t, elliptic.P384(), "p384")
-	testKeyGeneration(t, elliptic.P521(), "p521")
-}
-
-func BenchmarkSignP256(b *testing.B) {
-	b.ResetTimer()
-	p256 := elliptic.P256()
-	hashed := []byte("testing")
-	priv, _ := GenerateKey(p256, rand.Reader)
-
-	b.ReportAllocs()
-	b.ResetTimer()
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			_, _, _ = Sign(rand.Reader, priv, hashed)
-		}
-	})
 }
 
-func BenchmarkSignP384(b *testing.B) {
-	b.ResetTimer()
-	p384 := elliptic.P384()
-	hashed := []byte("testing")
-	priv, _ := GenerateKey(p384, rand.Reader)
-
-	b.ReportAllocs()
-	b.ResetTimer()
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			_, _, _ = Sign(rand.Reader, priv, hashed)
-		}
-	})
+func TestKeyGeneration(t *testing.T) {
+	testAllCurves(t, testKeyGeneration)
 }
 
-func BenchmarkVerifyP256(b *testing.B) {
-	b.ResetTimer()
-	p256 := elliptic.P256()
-	hashed := []byte("testing")
-	priv, _ := GenerateKey(p256, rand.Reader)
-	r, s, _ := Sign(rand.Reader, priv, hashed)
-
-	b.ReportAllocs()
-	b.ResetTimer()
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			Verify(&priv.PublicKey, hashed, r, s)
-		}
-	})
+func testKeyGeneration(t *testing.T, c elliptic.Curve) {
+	priv, err := GenerateKey(c, rand.Reader)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !c.IsOnCurve(priv.PublicKey.X, priv.PublicKey.Y) {
+		t.Errorf("public key invalid: %s", err)
+	}
 }
 
-func BenchmarkKeyGeneration(b *testing.B) {
-	b.ResetTimer()
-	p256 := elliptic.P256()
-
-	b.ReportAllocs()
-	b.ResetTimer()
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			GenerateKey(p256, rand.Reader)
-		}
-	})
+func TestSignAndVerify(t *testing.T) {
+	testAllCurves(t, testSignAndVerify)
 }
 
-func testSignAndVerify(t *testing.T, c elliptic.Curve, tag string) {
+func testSignAndVerify(t *testing.T, c elliptic.Curve) {
 	priv, _ := GenerateKey(c, rand.Reader)
 
 	hashed := []byte("testing")
 	r, s, err := Sign(rand.Reader, priv, hashed)
 	if err != nil {
-		t.Errorf("%s: error signing: %s", tag, err)
+		t.Errorf("error signing: %s", err)
 		return
 	}
 
 	if !Verify(&priv.PublicKey, hashed, r, s) {
-		t.Errorf("%s: Verify failed", tag)
+		t.Errorf("Verify failed")
 	}
 
 	hashed[0] ^= 0xff
 	if Verify(&priv.PublicKey, hashed, r, s) {
-		t.Errorf("%s: Verify always works!", tag)
+		t.Errorf("Verify always works!")
 	}
 }
 
-func TestSignAndVerify(t *testing.T) {
-	testSignAndVerify(t, elliptic.P224(), "p224")
-	if testing.Short() {
-		return
-	}
-	testSignAndVerify(t, elliptic.P256(), "p256")
-	testSignAndVerify(t, elliptic.P384(), "p384")
-	testSignAndVerify(t, elliptic.P521(), "p521")
+func TestSignAndVerifyASN1(t *testing.T) {
+	testAllCurves(t, testSignAndVerifyASN1)
 }
 
-func testSignAndVerifyASN1(t *testing.T, c elliptic.Curve, tag string) {
+func testSignAndVerifyASN1(t *testing.T, c elliptic.Curve) {
 	priv, _ := GenerateKey(c, rand.Reader)
 
 	hashed := []byte("testing")
 	sig, err := SignASN1(rand.Reader, priv, hashed)
 	if err != nil {
-		t.Errorf("%s: error signing: %s", tag, err)
+		t.Errorf("error signing: %s", err)
 		return
 	}
 
 	if !VerifyASN1(&priv.PublicKey, hashed, sig) {
-		t.Errorf("%s: VerifyASN1 failed", tag)
+		t.Errorf("VerifyASN1 failed")
 	}
 
 	hashed[0] ^= 0xff
 	if VerifyASN1(&priv.PublicKey, hashed, sig) {
-		t.Errorf("%s: VerifyASN1 always works!", tag)
+		t.Errorf("VerifyASN1 always works!")
 	}
 }
 
-func TestSignAndVerifyASN1(t *testing.T) {
-	testSignAndVerifyASN1(t, elliptic.P224(), "p224")
-	if testing.Short() {
-		return
-	}
-	testSignAndVerifyASN1(t, elliptic.P256(), "p256")
-	testSignAndVerifyASN1(t, elliptic.P384(), "p384")
-	testSignAndVerifyASN1(t, elliptic.P521(), "p521")
+func TestNonceSafety(t *testing.T) {
+	testAllCurves(t, testNonceSafety)
 }
 
-func testNonceSafety(t *testing.T, c elliptic.Curve, tag string) {
+func testNonceSafety(t *testing.T, c elliptic.Curve) {
 	priv, _ := GenerateKey(c, rand.Reader)
 
 	hashed := []byte("testing")
 	r0, s0, err := Sign(zeroReader, priv, hashed)
 	if err != nil {
-		t.Errorf("%s: error signing: %s", tag, err)
+		t.Errorf("error signing: %s", err)
 		return
 	}
 
 	hashed = []byte("testing...")
 	r1, s1, err := Sign(zeroReader, priv, hashed)
 	if err != nil {
-		t.Errorf("%s: error signing: %s", tag, err)
+		t.Errorf("error signing: %s", err)
 		return
 	}
 
 	if s0.Cmp(s1) == 0 {
 		// This should never happen.
-		t.Errorf("%s: the signatures on two different messages were the same", tag)
+		t.Errorf("the signatures on two different messages were the same")
 	}
 
 	if r0.Cmp(r1) == 0 {
-		t.Errorf("%s: the nonce used for two different messages was the same", tag)
+		t.Errorf("the nonce used for two different messages was the same")
 	}
 }
 
-func TestNonceSafety(t *testing.T) {
-	testNonceSafety(t, elliptic.P224(), "p224")
-	if testing.Short() {
-		return
-	}
-	testNonceSafety(t, elliptic.P256(), "p256")
-	testNonceSafety(t, elliptic.P384(), "p384")
-	testNonceSafety(t, elliptic.P521(), "p521")
+func TestINDCCA(t *testing.T) {
+	testAllCurves(t, testINDCCA)
 }
 
-func testINDCCA(t *testing.T, c elliptic.Curve, tag string) {
+func testINDCCA(t *testing.T, c elliptic.Curve) {
 	priv, _ := GenerateKey(c, rand.Reader)
 
 	hashed := []byte("testing")
 	r0, s0, err := Sign(rand.Reader, priv, hashed)
 	if err != nil {
-		t.Errorf("%s: error signing: %s", tag, err)
+		t.Errorf("error signing: %s", err)
 		return
 	}
 
 	r1, s1, err := Sign(rand.Reader, priv, hashed)
 	if err != nil {
-		t.Errorf("%s: error signing: %s", tag, err)
+		t.Errorf("error signing: %s", err)
 		return
 	}
 
 	if s0.Cmp(s1) == 0 {
-		t.Errorf("%s: two signatures of the same message produced the same result", tag)
+		t.Errorf("two signatures of the same message produced the same result")
 	}
 
 	if r0.Cmp(r1) == 0 {
-		t.Errorf("%s: two signatures of the same message produced the same nonce", tag)
-	}
-}
-
-func TestINDCCA(t *testing.T) {
-	testINDCCA(t, elliptic.P224(), "p224")
-	if testing.Short() {
-		return
+		t.Errorf("two signatures of the same message produced the same nonce")
 	}
-	testINDCCA(t, elliptic.P256(), "p256")
-	testINDCCA(t, elliptic.P384(), "p384")
-	testINDCCA(t, elliptic.P521(), "p521")
 }
 
 func fromHex(s string) *big.Int {
@@ -351,10 +283,14 @@ func TestVectors(t *testing.T) {
 	}
 }
 
-func testNegativeInputs(t *testing.T, curve elliptic.Curve, tag string) {
+func TestNegativeInputs(t *testing.T) {
+	testAllCurves(t, testNegativeInputs)
+}
+
+func testNegativeInputs(t *testing.T, curve elliptic.Curve) {
 	key, err := GenerateKey(curve, rand.Reader)
 	if err != nil {
-		t.Errorf("failed to generate key for %q", tag)
+		t.Errorf("failed to generate key")
 	}
 
 	var hash [32]byte
@@ -363,35 +299,103 @@ func testNegativeInputs(t *testing.T, curve elliptic.Curve, tag string) {
 	r.Neg(r)
 
 	if Verify(&key.PublicKey, hash[:], r, r) {
-		t.Errorf("bogus signature accepted for %q", tag)
+		t.Errorf("bogus signature accepted")
 	}
 }
 
-func TestNegativeInputs(t *testing.T) {
-	testNegativeInputs(t, elliptic.P224(), "p224")
-	testNegativeInputs(t, elliptic.P256(), "p256")
-	testNegativeInputs(t, elliptic.P384(), "p384")
-	testNegativeInputs(t, elliptic.P521(), "p521")
+func TestZeroHashSignature(t *testing.T) {
+	testAllCurves(t, testZeroHashSignature)
 }
 
-func TestZeroHashSignature(t *testing.T) {
+func testZeroHashSignature(t *testing.T, curve elliptic.Curve) {
 	zeroHash := make([]byte, 64)
 
-	for _, curve := range []elliptic.Curve{elliptic.P224(), elliptic.P256(), elliptic.P384(), elliptic.P521()} {
-		privKey, err := GenerateKey(curve, rand.Reader)
+	privKey, err := GenerateKey(curve, rand.Reader)
+	if err != nil {
+		panic(err)
+	}
+
+	// Sign a hash consisting of all zeros.
+	r, s, err := Sign(rand.Reader, privKey, zeroHash)
+	if err != nil {
+		panic(err)
+	}
+
+	// Confirm that it can be verified.
+	if !Verify(&privKey.PublicKey, zeroHash, r, s) {
+		t.Errorf("zero hash signature verify failed for %T", curve)
+	}
+}
+
+func benchmarkAllCurves(t *testing.B, f func(*testing.B, elliptic.Curve)) {
+	tests := []struct {
+		name  string
+		curve elliptic.Curve
+	}{
+		{"P256", elliptic.P256()},
+		{"P224", elliptic.P224()},
+		{"P384", elliptic.P384()},
+		{"P521", elliptic.P521()},
+	}
+	for _, test := range tests {
+		curve := test.curve
+		t.Run(test.name, func(t *testing.B) {
+			f(t, curve)
+		})
+	}
+}
+
+func BenchmarkSign(b *testing.B) {
+	benchmarkAllCurves(b, func(b *testing.B, curve elliptic.Curve) {
+		priv, err := GenerateKey(curve, rand.Reader)
 		if err != nil {
-			panic(err)
+			b.Fatal(err)
 		}
+		hashed := []byte("testing")
+
+		b.ReportAllocs()
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			sig, err := SignASN1(rand.Reader, priv, hashed)
+			if err != nil {
+				b.Fatal(err)
+			}
+			// Prevent the compiler from optimizing out the operation.
+			hashed[0] = sig[0]
+		}
+	})
+}
 
-		// Sign a hash consisting of all zeros.
-		r, s, err := Sign(rand.Reader, privKey, zeroHash)
+func BenchmarkVerify(b *testing.B) {
+	benchmarkAllCurves(b, func(b *testing.B, curve elliptic.Curve) {
+		priv, err := GenerateKey(curve, rand.Reader)
+		if err != nil {
+			b.Fatal(err)
+		}
+		hashed := []byte("testing")
+		r, s, err := Sign(rand.Reader, priv, hashed)
 		if err != nil {
-			panic(err)
+			b.Fatal(err)
 		}
 
-		// Confirm that it can be verified.
-		if !Verify(&privKey.PublicKey, zeroHash, r, s) {
-			t.Errorf("zero hash signature verify failed for %T", curve)
+		b.ReportAllocs()
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			if !Verify(&priv.PublicKey, hashed, r, s) {
+				b.Fatal("verify failed")
+			}
 		}
-	}
+	})
+}
+
+func BenchmarkGenerateKey(b *testing.B) {
+	benchmarkAllCurves(b, func(b *testing.B, curve elliptic.Curve) {
+		b.ReportAllocs()
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			if _, err := GenerateKey(curve, rand.Reader); err != nil {
+				b.Fatal(err)
+			}
+		}
+	})
 }
diff --git a/src/crypto/elliptic/elliptic_test.go b/src/crypto/elliptic/elliptic_test.go
index e80e7731aa..0d43b736f9 100644
--- a/src/crypto/elliptic/elliptic_test.go
+++ b/src/crypto/elliptic/elliptic_test.go
@@ -8,414 +8,60 @@ import (
 	"bytes"
 	"crypto/rand"
 	"encoding/hex"
-	"fmt"
 	"math/big"
 	"testing"
 )
 
-func TestOnCurve(t *testing.T) {
-	p224 := P224()
-	if !p224.IsOnCurve(p224.Params().Gx, p224.Params().Gy) {
-		t.Errorf("FAIL")
-	}
-}
-
-func TestOffCurve(t *testing.T) {
-	p224 := P224()
-	x, y := new(big.Int).SetInt64(1), new(big.Int).SetInt64(1)
-	if p224.IsOnCurve(x, y) {
-		t.Errorf("FAIL: point off curve is claimed to be on the curve")
+func testAllCurves(t *testing.T, f func(*testing.T, Curve)) {
+	tests := []struct {
+		name  string
+		curve Curve
+	}{
+		{"P256", P256()},
+		{"P256/Params", P256().Params()},
+		{"P224", P224()},
+		{"P224/Params", P224().Params()},
+		{"P384", P384()},
+		{"P384/Params", P384().Params()},
+		{"P521", P521()},
+		{"P521/Params", P521().Params()},
 	}
-	b := Marshal(p224, x, y)
-	x1, y1 := Unmarshal(p224, b)
-	if x1 != nil || y1 != nil {
-		t.Errorf("FAIL: unmarshaling a point not on the curve succeeded")
+	if testing.Short() {
+		tests = tests[:1]
 	}
-}
-
-type baseMultTest struct {
-	k    string
-	x, y string
-}
-
-var p224BaseMultTests = []baseMultTest{
-	{
-		"1",
-		"b70e0cbd6bb4bf7f321390b94a03c1d356c21122343280d6115c1d21",
-		"bd376388b5f723fb4c22dfe6cd4375a05a07476444d5819985007e34",
-	},
-	{
-		"2",
-		"706a46dc76dcb76798e60e6d89474788d16dc18032d268fd1a704fa6",
-		"1c2b76a7bc25e7702a704fa986892849fca629487acf3709d2e4e8bb",
-	},
-	{
-		"3",
-		"df1b1d66a551d0d31eff822558b9d2cc75c2180279fe0d08fd896d04",
-		"a3f7f03cadd0be444c0aa56830130ddf77d317344e1af3591981a925",
-	},
-	{
-		"4",
-		"ae99feebb5d26945b54892092a8aee02912930fa41cd114e40447301",
-		"482580a0ec5bc47e88bc8c378632cd196cb3fa058a7114eb03054c9",
-	},
-	{
-		"5",
-		"31c49ae75bce7807cdff22055d94ee9021fedbb5ab51c57526f011aa",
-		"27e8bff1745635ec5ba0c9f1c2ede15414c6507d29ffe37e790a079b",
-	},
-	{
-		"6",
-		"1f2483f82572251fca975fea40db821df8ad82a3c002ee6c57112408",
-		"89faf0ccb750d99b553c574fad7ecfb0438586eb3952af5b4b153c7e",
-	},
-	{
-		"7",
-		"db2f6be630e246a5cf7d99b85194b123d487e2d466b94b24a03c3e28",
-		"f3a30085497f2f611ee2517b163ef8c53b715d18bb4e4808d02b963",
-	},
-	{
-		"8",
-		"858e6f9cc6c12c31f5df124aa77767b05c8bc021bd683d2b55571550",
-		"46dcd3ea5c43898c5c5fc4fdac7db39c2f02ebee4e3541d1e78047a",
-	},
-	{
-		"9",
-		"2fdcccfee720a77ef6cb3bfbb447f9383117e3daa4a07e36ed15f78d",
-		"371732e4f41bf4f7883035e6a79fcedc0e196eb07b48171697517463",
-	},
-	{
-		"10",
-		"aea9e17a306517eb89152aa7096d2c381ec813c51aa880e7bee2c0fd",
-		"39bb30eab337e0a521b6cba1abe4b2b3a3e524c14a3fe3eb116b655f",
-	},
-	{
-		"11",
-		"ef53b6294aca431f0f3c22dc82eb9050324f1d88d377e716448e507c",
-		"20b510004092e96636cfb7e32efded8265c266dfb754fa6d6491a6da",
-	},
-	{
-		"12",
-		"6e31ee1dc137f81b056752e4deab1443a481033e9b4c93a3044f4f7a",
-		"207dddf0385bfdeab6e9acda8da06b3bbef224a93ab1e9e036109d13",
-	},
-	{
-		"13",
-		"34e8e17a430e43289793c383fac9774247b40e9ebd3366981fcfaeca",
-		"252819f71c7fb7fbcb159be337d37d3336d7feb963724fdfb0ecb767",
-	},
-	{
-		"14",
-		"a53640c83dc208603ded83e4ecf758f24c357d7cf48088b2ce01e9fa",
-		"d5814cd724199c4a5b974a43685fbf5b8bac69459c9469bc8f23ccaf",
-	},
-	{
-		"15",
-		"baa4d8635511a7d288aebeedd12ce529ff102c91f97f867e21916bf9",
-		"979a5f4759f80f4fb4ec2e34f5566d595680a11735e7b61046127989",
-	},
-	{
-		"16",
-		"b6ec4fe1777382404ef679997ba8d1cc5cd8e85349259f590c4c66d",
-		"3399d464345906b11b00e363ef429221f2ec720d2f665d7dead5b482",
-	},
-	{
-		"17",
-		"b8357c3a6ceef288310e17b8bfeff9200846ca8c1942497c484403bc",
-		"ff149efa6606a6bd20ef7d1b06bd92f6904639dce5174db6cc554a26",
-	},
-	{
-		"18",
-		"c9ff61b040874c0568479216824a15eab1a838a797d189746226e4cc",
-		"ea98d60e5ffc9b8fcf999fab1df7e7ef7084f20ddb61bb045a6ce002",
-	},
-	{
-		"19",
-		"a1e81c04f30ce201c7c9ace785ed44cc33b455a022f2acdbc6cae83c",
-		"dcf1f6c3db09c70acc25391d492fe25b4a180babd6cea356c04719cd",
-	},
-	{
-		"20",
-		"fcc7f2b45df1cd5a3c0c0731ca47a8af75cfb0347e8354eefe782455",
-		"d5d7110274cba7cdee90e1a8b0d394c376a5573db6be0bf2747f530",
-	},
-	{
-		"112233445566778899",
-		"61f077c6f62ed802dad7c2f38f5c67f2cc453601e61bd076bb46179e",
-		"2272f9e9f5933e70388ee652513443b5e289dd135dcc0d0299b225e4",
-	},
-	{
-		"112233445566778899112233445566778899",
-		"29895f0af496bfc62b6ef8d8a65c88c613949b03668aab4f0429e35",
-		"3ea6e53f9a841f2019ec24bde1a75677aa9b5902e61081c01064de93",
-	},
-	{
-		"6950511619965839450988900688150712778015737983940691968051900319680",
-		"ab689930bcae4a4aa5f5cb085e823e8ae30fd365eb1da4aba9cf0379",
-		"3345a121bbd233548af0d210654eb40bab788a03666419be6fbd34e7",
-	},
-	{
-		"13479972933410060327035789020509431695094902435494295338570602119423",
-		"bdb6a8817c1f89da1c2f3dd8e97feb4494f2ed302a4ce2bc7f5f4025",
-		"4c7020d57c00411889462d77a5438bb4e97d177700bf7243a07f1680",
-	},
-	{
-		"13479971751745682581351455311314208093898607229429740618390390702079",
-		"d58b61aa41c32dd5eba462647dba75c5d67c83606c0af2bd928446a9",
-		"d24ba6a837be0460dd107ae77725696d211446c5609b4595976b16bd",
-	},
-	{
-		"13479972931865328106486971546324465392952975980343228160962702868479",
-		"dc9fa77978a005510980e929a1485f63716df695d7a0c18bb518df03",
-		"ede2b016f2ddffc2a8c015b134928275ce09e5661b7ab14ce0d1d403",
-	},
-	{
-		"11795773708834916026404142434151065506931607341523388140225443265536",
-		"499d8b2829cfb879c901f7d85d357045edab55028824d0f05ba279ba",
-		"bf929537b06e4015919639d94f57838fa33fc3d952598dcdbb44d638",
-	},
-	{
-		"784254593043826236572847595991346435467177662189391577090",
-		"8246c999137186632c5f9eddf3b1b0e1764c5e8bd0e0d8a554b9cb77",
-		"e80ed8660bc1cb17ac7d845be40a7a022d3306f116ae9f81fea65947",
-	},
-	{
-		"13479767645505654746623887797783387853576174193480695826442858012671",
-		"6670c20afcceaea672c97f75e2e9dd5c8460e54bb38538ebb4bd30eb",
-		"f280d8008d07a4caf54271f993527d46ff3ff46fd1190a3f1faa4f74",
-	},
-	{
-		"205688069665150753842126177372015544874550518966168735589597183",
-		"eca934247425cfd949b795cb5ce1eff401550386e28d1a4c5a8eb",
-		"d4c01040dba19628931bc8855370317c722cbd9ca6156985f1c2e9ce",
-	},
-	{
-		"13479966930919337728895168462090683249159702977113823384618282123295",
-		"ef353bf5c73cd551b96d596fbc9a67f16d61dd9fe56af19de1fba9cd",
-		"21771b9cdce3e8430c09b3838be70b48c21e15bc09ee1f2d7945b91f",
-	},
-	{
-		"50210731791415612487756441341851895584393717453129007497216",
-		"4036052a3091eb481046ad3289c95d3ac905ca0023de2c03ecd451cf",
-		"d768165a38a2b96f812586a9d59d4136035d9c853a5bf2e1c86a4993",
-	},
-	{
-		"26959946667150639794667015087019625940457807714424391721682722368041",
-		"fcc7f2b45df1cd5a3c0c0731ca47a8af75cfb0347e8354eefe782455",
-		"f2a28eefd8b345832116f1e574f2c6b2c895aa8c24941f40d8b80ad1",
-	},
-	{
-		"26959946667150639794667015087019625940457807714424391721682722368042",
-		"a1e81c04f30ce201c7c9ace785ed44cc33b455a022f2acdbc6cae83c",
-		"230e093c24f638f533dac6e2b6d01da3b5e7f45429315ca93fb8e634",
-	},
-	{
-		"26959946667150639794667015087019625940457807714424391721682722368043",
-		"c9ff61b040874c0568479216824a15eab1a838a797d189746226e4cc",
-		"156729f1a003647030666054e208180f8f7b0df2249e44fba5931fff",
-	},
-	{
-		"26959946667150639794667015087019625940457807714424391721682722368044",
-		"b8357c3a6ceef288310e17b8bfeff9200846ca8c1942497c484403bc",
-		"eb610599f95942df1082e4f9426d086fb9c6231ae8b24933aab5db",
-	},
-	{
-		"26959946667150639794667015087019625940457807714424391721682722368045",
-		"b6ec4fe1777382404ef679997ba8d1cc5cd8e85349259f590c4c66d",
-		"cc662b9bcba6f94ee4ff1c9c10bd6ddd0d138df2d099a282152a4b7f",
-	},
-	{
-		"26959946667150639794667015087019625940457807714424391721682722368046",
-		"baa4d8635511a7d288aebeedd12ce529ff102c91f97f867e21916bf9",
-		"6865a0b8a607f0b04b13d1cb0aa992a5a97f5ee8ca1849efb9ed8678",
-	},
-	{
-		"26959946667150639794667015087019625940457807714424391721682722368047",
-		"a53640c83dc208603ded83e4ecf758f24c357d7cf48088b2ce01e9fa",
-		"2a7eb328dbe663b5a468b5bc97a040a3745396ba636b964370dc3352",
-	},
-	{
-		"26959946667150639794667015087019625940457807714424391721682722368048",
-		"34e8e17a430e43289793c383fac9774247b40e9ebd3366981fcfaeca",
-		"dad7e608e380480434ea641cc82c82cbc92801469c8db0204f13489a",
-	},
-	{
-		"26959946667150639794667015087019625940457807714424391721682722368049",
-		"6e31ee1dc137f81b056752e4deab1443a481033e9b4c93a3044f4f7a",
-		"df82220fc7a4021549165325725f94c3410ddb56c54e161fc9ef62ee",
-	},
-	{
-		"26959946667150639794667015087019625940457807714424391721682722368050",
-		"ef53b6294aca431f0f3c22dc82eb9050324f1d88d377e716448e507c",
-		"df4aefffbf6d1699c930481cd102127c9a3d992048ab05929b6e5927",
-	},
-	{
-		"26959946667150639794667015087019625940457807714424391721682722368051",
-		"aea9e17a306517eb89152aa7096d2c381ec813c51aa880e7bee2c0fd",
-		"c644cf154cc81f5ade49345e541b4d4b5c1adb3eb5c01c14ee949aa2",
-	},
-	{
-		"26959946667150639794667015087019625940457807714424391721682722368052",
-		"2fdcccfee720a77ef6cb3bfbb447f9383117e3daa4a07e36ed15f78d",
-		"c8e8cd1b0be40b0877cfca1958603122f1e6914f84b7e8e968ae8b9e",
-	},
-	{
-		"26959946667150639794667015087019625940457807714424391721682722368053",
-		"858e6f9cc6c12c31f5df124aa77767b05c8bc021bd683d2b55571550",
-		"fb9232c15a3bc7673a3a03b0253824c53d0fd1411b1cabe2e187fb87",
-	},
-	{
-		"26959946667150639794667015087019625940457807714424391721682722368054",
-		"db2f6be630e246a5cf7d99b85194b123d487e2d466b94b24a03c3e28",
-		"f0c5cff7ab680d09ee11dae84e9c1072ac48ea2e744b1b7f72fd469e",
-	},
-	{
-		"26959946667150639794667015087019625940457807714424391721682722368055",
-		"1f2483f82572251fca975fea40db821df8ad82a3c002ee6c57112408",
-		"76050f3348af2664aac3a8b05281304ebc7a7914c6ad50a4b4eac383",
-	},
-	{
-		"26959946667150639794667015087019625940457807714424391721682722368056",
-		"31c49ae75bce7807cdff22055d94ee9021fedbb5ab51c57526f011aa",
-		"d817400e8ba9ca13a45f360e3d121eaaeb39af82d6001c8186f5f866",
-	},
-	{
-		"26959946667150639794667015087019625940457807714424391721682722368057",
-		"ae99feebb5d26945b54892092a8aee02912930fa41cd114e40447301",
-		"fb7da7f5f13a43b81774373c879cd32d6934c05fa758eeb14fcfab38",
-	},
-	{
-		"26959946667150639794667015087019625940457807714424391721682722368058",
-		"df1b1d66a551d0d31eff822558b9d2cc75c2180279fe0d08fd896d04",
-		"5c080fc3522f41bbb3f55a97cfecf21f882ce8cbb1e50ca6e67e56dc",
-	},
-	{
-		"26959946667150639794667015087019625940457807714424391721682722368059",
-		"706a46dc76dcb76798e60e6d89474788d16dc18032d268fd1a704fa6",
-		"e3d4895843da188fd58fb0567976d7b50359d6b78530c8f62d1b1746",
-	},
-	{
-		"26959946667150639794667015087019625940457807714424391721682722368060",
-		"b70e0cbd6bb4bf7f321390b94a03c1d356c21122343280d6115c1d21",
-		"42c89c774a08dc04b3dd201932bc8a5ea5f8b89bbb2a7e667aff81cd",
-	},
-}
-
-type scalarMultTest struct {
-	k          string
-	xIn, yIn   string
-	xOut, yOut string
-}
-
-var p256MultTests = []scalarMultTest{
-	{
-		"2a265f8bcbdcaf94d58519141e578124cb40d64a501fba9c11847b28965bc737",
-		"023819813ac969847059028ea88a1f30dfbcde03fc791d3a252c6b41211882ea",
-		"f93e4ae433cc12cf2a43fc0ef26400c0e125508224cdb649380f25479148a4ad",
-		"4d4de80f1534850d261075997e3049321a0864082d24a917863366c0724f5ae3",
-		"a22d2b7f7818a3563e0f7a76c9bf0921ac55e06e2e4d11795b233824b1db8cc0",
-	},
-	{
-		"313f72ff9fe811bf573176231b286a3bdb6f1b14e05c40146590727a71c3bccd",
-		"cc11887b2d66cbae8f4d306627192522932146b42f01d3c6f92bd5c8ba739b06",
-		"a2f08a029cd06b46183085bae9248b0ed15b70280c7ef13a457f5af382426031",
-		"831c3f6b5f762d2f461901577af41354ac5f228c2591f84f8a6e51e2e3f17991",
-		"93f90934cd0ef2c698cc471c60a93524e87ab31ca2412252337f364513e43684",
-	},
-}
-
-func TestBaseMult(t *testing.T) {
-	p224 := P224()
-	for i, e := range p224BaseMultTests {
-		k, ok := new(big.Int).SetString(e.k, 10)
-		if !ok {
-			t.Errorf("%d: bad value for k: %s", i, e.k)
-		}
-		x, y := p224.ScalarBaseMult(k.Bytes())
-		if fmt.Sprintf("%x", x) != e.x || fmt.Sprintf("%x", y) != e.y {
-			t.Errorf("%d: bad output for k=%s: got (%x, %x), want (%s, %s)", i, e.k, x, y, e.x, e.y)
-		}
-		if testing.Short() && i > 5 {
-			break
-		}
+	for _, test := range tests {
+		curve := test.curve
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			f(t, curve)
+		})
 	}
 }
 
-func TestGenericBaseMult(t *testing.T) {
-	// We use the P224 CurveParams directly in order to test the generic implementation.
-	p224 := P224().Params()
-	for i, e := range p224BaseMultTests {
-		k, ok := new(big.Int).SetString(e.k, 10)
-		if !ok {
-			t.Errorf("%d: bad value for k: %s", i, e.k)
-		}
-		x, y := p224.ScalarBaseMult(k.Bytes())
-		if fmt.Sprintf("%x", x) != e.x || fmt.Sprintf("%x", y) != e.y {
-			t.Errorf("%d: bad output for k=%s: got (%x, %x), want (%s, %s)", i, e.k, x, y, e.x, e.y)
-		}
-		if testing.Short() && i > 5 {
-			break
+func TestOnCurve(t *testing.T) {
+	testAllCurves(t, func(t *testing.T, curve Curve) {
+		if !curve.IsOnCurve(curve.Params().Gx, curve.Params().Gy) {
+			t.Error("basepoint is not on the curve")
 		}
-	}
+	})
 }
 
-func TestP256BaseMult(t *testing.T) {
-	p256 := P256()
-	p256Generic := p256.Params()
-
-	scalars := make([]*big.Int, 0, len(p224BaseMultTests)+1)
-	for _, e := range p224BaseMultTests {
-		k, _ := new(big.Int).SetString(e.k, 10)
-		scalars = append(scalars, k)
-	}
-	k := new(big.Int).SetInt64(1)
-	k.Lsh(k, 500)
-	scalars = append(scalars, k)
-
-	for i, k := range scalars {
-		x, y := p256.ScalarBaseMult(k.Bytes())
-		x2, y2 := p256Generic.ScalarBaseMult(k.Bytes())
-		if x.Cmp(x2) != 0 || y.Cmp(y2) != 0 {
-			t.Errorf("#%d: got (%x, %x), want (%x, %x)", i, x, y, x2, y2)
+func TestOffCurve(t *testing.T) {
+	testAllCurves(t, func(t *testing.T, curve Curve) {
+		x, y := new(big.Int).SetInt64(1), new(big.Int).SetInt64(1)
+		if curve.IsOnCurve(x, y) {
+			t.Errorf("point off curve is claimed to be on the curve")
 		}
-
-		if testing.Short() && i > 5 {
-			break
+		b := Marshal(curve, x, y)
+		x1, y1 := Unmarshal(curve, b)
+		if x1 != nil || y1 != nil {
+			t.Errorf("unmarshaling a point not on the curve succeeded")
 		}
-	}
+	})
 }
 
-func TestP256Mult(t *testing.T) {
-	p256 := P256()
-	p256Generic := p256.Params()
-
-	for i, e := range p224BaseMultTests {
-		x, _ := new(big.Int).SetString(e.x, 16)
-		y, _ := new(big.Int).SetString(e.y, 16)
-		k, _ := new(big.Int).SetString(e.k, 10)
-
-		xx, yy := p256.ScalarMult(x, y, k.Bytes())
-		xx2, yy2 := p256Generic.ScalarMult(x, y, k.Bytes())
-		if xx.Cmp(xx2) != 0 || yy.Cmp(yy2) != 0 {
-			t.Errorf("#%d: got (%x, %x), want (%x, %x)", i, xx, yy, xx2, yy2)
-		}
-		if testing.Short() && i > 5 {
-			break
-		}
-	}
-
-	for i, e := range p256MultTests {
-		x, _ := new(big.Int).SetString(e.xIn, 16)
-		y, _ := new(big.Int).SetString(e.yIn, 16)
-		k, _ := new(big.Int).SetString(e.k, 16)
-		expectedX, _ := new(big.Int).SetString(e.xOut, 16)
-		expectedY, _ := new(big.Int).SetString(e.yOut, 16)
-
-		xx, yy := p256.ScalarMult(x, y, k.Bytes())
-		if xx.Cmp(expectedX) != 0 || yy.Cmp(expectedY) != 0 {
-			t.Errorf("#%d: got (%x, %x), want (%x, %x)", i, xx, yy, expectedX, expectedY)
-		}
-	}
+func TestInfinity(t *testing.T) {
+	testAllCurves(t, testInfinity)
 }
 
 func testInfinity(t *testing.T, curve Curve) {
@@ -455,199 +101,66 @@ func testInfinity(t *testing.T, curve Curve) {
 	}
 }
 
-func TestInfinity(t *testing.T) {
-	tests := []struct {
-		name  string
-		curve Curve
-	}{
-		{"P-224", P224()},
-		{"P-256", P256()},
-		{"P-256/Generic", P256().Params()},
-		{"P-384", P384()},
-		{"P-521", P521()},
-	}
-	if testing.Short() {
-		tests = tests[:1]
-	}
-	for _, test := range tests {
-		curve := test.curve
-		t.Run(test.name, func(t *testing.T) {
-			testInfinity(t, curve)
-		})
-	}
-}
-
-type synthCombinedMult struct {
-	Curve
-}
-
-func (s synthCombinedMult) CombinedMult(bigX, bigY *big.Int, baseScalar, scalar []byte) (x, y *big.Int) {
-	x1, y1 := s.ScalarBaseMult(baseScalar)
-	x2, y2 := s.ScalarMult(bigX, bigY, scalar)
-	return s.Add(x1, y1, x2, y2)
-}
-
-func TestCombinedMult(t *testing.T) {
-	type combinedMult interface {
-		Curve
-		CombinedMult(bigX, bigY *big.Int, baseScalar, scalar []byte) (x, y *big.Int)
-	}
-
-	p256, ok := P256().(combinedMult)
-	if !ok {
-		p256 = &synthCombinedMult{P256()}
-	}
-
-	gx := p256.Params().Gx
-	gy := p256.Params().Gy
-
-	zero := make([]byte, 32)
-	one := make([]byte, 32)
-	one[31] = 1
-	two := make([]byte, 32)
-	two[31] = 2
-
-	// 0×G + 0×G = ∞
-	x, y := p256.CombinedMult(gx, gy, zero, zero)
-	if x.Sign() != 0 || y.Sign() != 0 {
-		t.Errorf("0×G + 0×G = (%d, %d), should be ∞", x, y)
-	}
-
-	// 1×G + 0×G = G
-	x, y = p256.CombinedMult(gx, gy, one, zero)
-	if x.Cmp(gx) != 0 || y.Cmp(gy) != 0 {
-		t.Errorf("1×G + 0×G = (%d, %d), should be (%d, %d)", x, y, gx, gy)
-	}
-
-	// 0×G + 1×G = G
-	x, y = p256.CombinedMult(gx, gy, zero, one)
-	if x.Cmp(gx) != 0 || y.Cmp(gy) != 0 {
-		t.Errorf("0×G + 1×G = (%d, %d), should be (%d, %d)", x, y, gx, gy)
-	}
-
-	// 1×G + 1×G = 2×G
-	x, y = p256.CombinedMult(gx, gy, one, one)
-	ggx, ggy := p256.ScalarBaseMult(two)
-	if x.Cmp(ggx) != 0 || y.Cmp(ggy) != 0 {
-		t.Errorf("1×G + 1×G = (%d, %d), should be (%d, %d)", x, y, ggx, ggy)
-	}
-
-	minusOne := new(big.Int).Sub(p256.Params().N, big.NewInt(1))
-	// 1×G + (-1)×G = ∞
-	x, y = p256.CombinedMult(gx, gy, one, minusOne.Bytes())
-	if x.Sign() != 0 || y.Sign() != 0 {
-		t.Errorf("1×G + (-1)×G = (%d, %d), should be ∞", x, y)
-	}
-}
-
-func BenchmarkBaseMult(b *testing.B) {
-	b.ResetTimer()
-	p224 := P224()
-	e := p224BaseMultTests[25]
-	k, _ := new(big.Int).SetString(e.k, 10)
-	b.ReportAllocs()
-	b.StartTimer()
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			p224.ScalarBaseMult(k.Bytes())
+func TestMarshal(t *testing.T) {
+	testAllCurves(t, func(t *testing.T, curve Curve) {
+		_, x, y, err := GenerateKey(curve, rand.Reader)
+		if err != nil {
+			t.Fatal(err)
 		}
-	})
-}
-
-func BenchmarkBaseMultP256(b *testing.B) {
-	b.ResetTimer()
-	p256 := P256()
-	e := p224BaseMultTests[25]
-	k, _ := new(big.Int).SetString(e.k, 10)
-	b.ReportAllocs()
-	b.StartTimer()
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			p256.ScalarBaseMult(k.Bytes())
+		serialized := Marshal(curve, x, y)
+		xx, yy := Unmarshal(curve, serialized)
+		if xx == nil {
+			t.Fatal("failed to unmarshal")
 		}
-	})
-}
-
-func BenchmarkScalarMultP256(b *testing.B) {
-	b.ResetTimer()
-	p256 := P256()
-	_, x, y, _ := GenerateKey(p256, rand.Reader)
-	priv, _, _, _ := GenerateKey(p256, rand.Reader)
-
-	b.ReportAllocs()
-	b.StartTimer()
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			p256.ScalarMult(x, y, priv)
+		if xx.Cmp(x) != 0 || yy.Cmp(y) != 0 {
+			t.Fatal("unmarshal returned different values")
 		}
 	})
 }
 
-func TestMarshal(t *testing.T) {
-	p224 := P224()
-	_, x, y, err := GenerateKey(p224, rand.Reader)
-	if err != nil {
-		t.Error(err)
-		return
-	}
-	serialized := Marshal(p224, x, y)
-	xx, yy := Unmarshal(p224, serialized)
-	if xx == nil {
-		t.Error("failed to unmarshal")
-		return
-	}
-	if xx.Cmp(x) != 0 || yy.Cmp(y) != 0 {
-		t.Error("unmarshal returned different values")
-		return
-	}
-}
-
-func TestP224Overflow(t *testing.T) {
-	// This tests for a specific bug in the P224 implementation.
-	p224 := P224()
-	pointData, _ := hex.DecodeString("049B535B45FB0A2072398A6831834624C7E32CCFD5A4B933BCEAF77F1DD945E08BBE5178F5EDF5E733388F196D2A631D2E075BB16CBFEEA15B")
-	x, y := Unmarshal(p224, pointData)
-	if !p224.IsOnCurve(x, y) {
-		t.Error("P224 failed to validate a correct point")
-	}
+func TestUnmarshalToLargeCoordinates(t *testing.T) {
+	// See https://golang.org/issues/20482.
+	testAllCurves(t, testUnmarshalToLargeCoordinates)
 }
 
-// See https://golang.org/issues/20482
-func TestUnmarshalToLargeCoordinates(t *testing.T) {
-	curve := P256()
+func testUnmarshalToLargeCoordinates(t *testing.T, curve Curve) {
 	p := curve.Params().P
-
-	invalidX, invalidY := make([]byte, 65), make([]byte, 65)
-	invalidX[0], invalidY[0] = 4, 4 // uncompressed encoding
+	byteLen := (p.BitLen() + 7) / 8
 
 	// Set x to be greater than curve's parameter P – specifically, to P+5.
 	// Set y to mod_sqrt(x^3 - 3x + B)) so that (x mod P = 5 , y) is on the
 	// curve.
 	x := new(big.Int).Add(p, big.NewInt(5))
-	y, _ := new(big.Int).SetString("31468013646237722594854082025316614106172411895747863909393730389177298123724", 10)
+	y := curve.Params().polynomial(x)
+	y.ModSqrt(y, p)
 
-	copy(invalidX[1:], x.Bytes())
-	copy(invalidX[33:], y.Bytes())
+	invalid := make([]byte, byteLen*2+1)
+	invalid[0] = 4 // uncompressed encoding
+	x.FillBytes(invalid[1 : 1+byteLen])
+	y.FillBytes(invalid[1+byteLen:])
 
-	if X, Y := Unmarshal(curve, invalidX); X != nil || Y != nil {
+	if X, Y := Unmarshal(curve, invalid); X != nil || Y != nil {
 		t.Errorf("Unmarshal accepts invalid X coordinate")
 	}
 
-	// This is a point on the curve with a small y value, small enough that we can add p and still be within 32 bytes.
-	x, _ = new(big.Int).SetString("31931927535157963707678568152204072984517581467226068221761862915403492091210", 10)
-	y, _ = new(big.Int).SetString("5208467867388784005506817585327037698770365050895731383201516607147", 10)
-	y.Add(y, p)
+	if curve == p256 {
+		// This is a point on the curve with a small y value, small enough that
+		// we can add p and still be within 32 bytes.
+		x, _ = new(big.Int).SetString("31931927535157963707678568152204072984517581467226068221761862915403492091210", 10)
+		y, _ = new(big.Int).SetString("5208467867388784005506817585327037698770365050895731383201516607147", 10)
+		y.Add(y, p)
 
-	if p.Cmp(y) > 0 || y.BitLen() != 256 {
-		t.Fatal("y not within expected range")
-	}
+		if p.Cmp(y) > 0 || y.BitLen() != 256 {
+			t.Fatal("y not within expected range")
+		}
 
-	// marshal
-	copy(invalidY[1:], x.Bytes())
-	copy(invalidY[33:], y.Bytes())
+		// marshal
+		x.FillBytes(invalid[1 : 1+byteLen])
+		y.FillBytes(invalid[1+byteLen:])
 
-	if X, Y := Unmarshal(curve, invalidY); X != nil || Y != nil {
-		t.Errorf("Unmarshal accepts invalid Y coordinate")
+		if X, Y := Unmarshal(curve, invalid); X != nil || Y != nil {
+			t.Errorf("Unmarshal accepts invalid Y coordinate")
+		}
 	}
 }
 
@@ -677,27 +190,14 @@ func TestMarshalCompressed(t *testing.T) {
 		t.Skip("skipping other curves on short test")
 	}
 
-	t.Run("P-224", func(t *testing.T) {
-		_, x, y, err := GenerateKey(P224(), rand.Reader)
+	testAllCurves(t, func(t *testing.T, curve Curve) {
+		_, x, y, err := GenerateKey(curve, rand.Reader)
 		if err != nil {
 			t.Fatal(err)
 		}
-		testMarshalCompressed(t, P224(), x, y, nil)
-	})
-	t.Run("P-384", func(t *testing.T) {
-		_, x, y, err := GenerateKey(P384(), rand.Reader)
-		if err != nil {
-			t.Fatal(err)
-		}
-		testMarshalCompressed(t, P384(), x, y, nil)
-	})
-	t.Run("P-521", func(t *testing.T) {
-		_, x, y, err := GenerateKey(P521(), rand.Reader)
-		if err != nil {
-			t.Fatal(err)
-		}
-		testMarshalCompressed(t, P521(), x, y, nil)
+		testMarshalCompressed(t, curve, x, y, nil)
 	})
+
 }
 
 func testMarshalCompressed(t *testing.T, curve Curve, x, y *big.Int, want []byte) {
@@ -721,3 +221,46 @@ func testMarshalCompressed(t *testing.T, curve Curve, x, y *big.Int, want []byte
 		t.Errorf("point did not round-trip correctly: got (%v, %v), want (%v, %v)", X, Y, x, y)
 	}
 }
+
+func benchmarkAllCurves(t *testing.B, f func(*testing.B, Curve)) {
+	tests := []struct {
+		name  string
+		curve Curve
+	}{
+		{"P256", P256()},
+		{"P224", P224()},
+		{"P384", P384()},
+		{"P521", P521()},
+	}
+	for _, test := range tests {
+		curve := test.curve
+		t.Run(test.name, func(t *testing.B) {
+			f(t, curve)
+		})
+	}
+}
+
+func BenchmarkScalarBaseMult(b *testing.B) {
+	benchmarkAllCurves(b, func(b *testing.B, curve Curve) {
+		priv, _, _, _ := GenerateKey(curve, rand.Reader)
+		b.ReportAllocs()
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			x, _ := curve.ScalarBaseMult(priv)
+			// Prevent the compiler from optimizing out the operation.
+			priv[0] ^= byte(x.Bits()[0])
+		}
+	})
+}
+
+func BenchmarkScalarMult(b *testing.B) {
+	benchmarkAllCurves(b, func(b *testing.B, curve Curve) {
+		_, x, y, _ := GenerateKey(curve, rand.Reader)
+		priv, _, _, _ := GenerateKey(curve, rand.Reader)
+		b.ReportAllocs()
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			x, y = curve.ScalarMult(x, y, priv)
+		}
+	})
+}
diff --git a/src/crypto/elliptic/fuzz_test.go b/src/crypto/elliptic/fuzz_test.go
index f5c9841a12..8ff3bf3cc2 100644
--- a/src/crypto/elliptic/fuzz_test.go
+++ b/src/crypto/elliptic/fuzz_test.go
@@ -14,7 +14,6 @@ import (
 )
 
 func TestFuzz(t *testing.T) {
-
 	p256 := P256()
 	p256Generic := p256.Params()
 
diff --git a/src/crypto/elliptic/p224_test.go b/src/crypto/elliptic/p224_test.go
index c3141b6ab4..b213b273d2 100644
--- a/src/crypto/elliptic/p224_test.go
+++ b/src/crypto/elliptic/p224_test.go
@@ -5,6 +5,8 @@
 package elliptic
 
 import (
+	"encoding/hex"
+	"fmt"
 	"math/big"
 	"math/bits"
 	"math/rand"
@@ -312,3 +314,316 @@ func TestP224Invert(t *testing.T) {
 		t.Errorf("p224Invert(a) * a = %x, expected 1", out)
 	}
 }
+
+type baseMultTest struct {
+	k    string
+	x, y string
+}
+
+var p224BaseMultTests = []baseMultTest{
+	{
+		"1",
+		"b70e0cbd6bb4bf7f321390b94a03c1d356c21122343280d6115c1d21",
+		"bd376388b5f723fb4c22dfe6cd4375a05a07476444d5819985007e34",
+	},
+	{
+		"2",
+		"706a46dc76dcb76798e60e6d89474788d16dc18032d268fd1a704fa6",
+		"1c2b76a7bc25e7702a704fa986892849fca629487acf3709d2e4e8bb",
+	},
+	{
+		"3",
+		"df1b1d66a551d0d31eff822558b9d2cc75c2180279fe0d08fd896d04",
+		"a3f7f03cadd0be444c0aa56830130ddf77d317344e1af3591981a925",
+	},
+	{
+		"4",
+		"ae99feebb5d26945b54892092a8aee02912930fa41cd114e40447301",
+		"482580a0ec5bc47e88bc8c378632cd196cb3fa058a7114eb03054c9",
+	},
+	{
+		"5",
+		"31c49ae75bce7807cdff22055d94ee9021fedbb5ab51c57526f011aa",
+		"27e8bff1745635ec5ba0c9f1c2ede15414c6507d29ffe37e790a079b",
+	},
+	{
+		"6",
+		"1f2483f82572251fca975fea40db821df8ad82a3c002ee6c57112408",
+		"89faf0ccb750d99b553c574fad7ecfb0438586eb3952af5b4b153c7e",
+	},
+	{
+		"7",
+		"db2f6be630e246a5cf7d99b85194b123d487e2d466b94b24a03c3e28",
+		"f3a30085497f2f611ee2517b163ef8c53b715d18bb4e4808d02b963",
+	},
+	{
+		"8",
+		"858e6f9cc6c12c31f5df124aa77767b05c8bc021bd683d2b55571550",
+		"46dcd3ea5c43898c5c5fc4fdac7db39c2f02ebee4e3541d1e78047a",
+	},
+	{
+		"9",
+		"2fdcccfee720a77ef6cb3bfbb447f9383117e3daa4a07e36ed15f78d",
+		"371732e4f41bf4f7883035e6a79fcedc0e196eb07b48171697517463",
+	},
+	{
+		"10",
+		"aea9e17a306517eb89152aa7096d2c381ec813c51aa880e7bee2c0fd",
+		"39bb30eab337e0a521b6cba1abe4b2b3a3e524c14a3fe3eb116b655f",
+	},
+	{
+		"11",
+		"ef53b6294aca431f0f3c22dc82eb9050324f1d88d377e716448e507c",
+		"20b510004092e96636cfb7e32efded8265c266dfb754fa6d6491a6da",
+	},
+	{
+		"12",
+		"6e31ee1dc137f81b056752e4deab1443a481033e9b4c93a3044f4f7a",
+		"207dddf0385bfdeab6e9acda8da06b3bbef224a93ab1e9e036109d13",
+	},
+	{
+		"13",
+		"34e8e17a430e43289793c383fac9774247b40e9ebd3366981fcfaeca",
+		"252819f71c7fb7fbcb159be337d37d3336d7feb963724fdfb0ecb767",
+	},
+	{
+		"14",
+		"a53640c83dc208603ded83e4ecf758f24c357d7cf48088b2ce01e9fa",
+		"d5814cd724199c4a5b974a43685fbf5b8bac69459c9469bc8f23ccaf",
+	},
+	{
+		"15",
+		"baa4d8635511a7d288aebeedd12ce529ff102c91f97f867e21916bf9",
+		"979a5f4759f80f4fb4ec2e34f5566d595680a11735e7b61046127989",
+	},
+	{
+		"16",
+		"b6ec4fe1777382404ef679997ba8d1cc5cd8e85349259f590c4c66d",
+		"3399d464345906b11b00e363ef429221f2ec720d2f665d7dead5b482",
+	},
+	{
+		"17",
+		"b8357c3a6ceef288310e17b8bfeff9200846ca8c1942497c484403bc",
+		"ff149efa6606a6bd20ef7d1b06bd92f6904639dce5174db6cc554a26",
+	},
+	{
+		"18",
+		"c9ff61b040874c0568479216824a15eab1a838a797d189746226e4cc",
+		"ea98d60e5ffc9b8fcf999fab1df7e7ef7084f20ddb61bb045a6ce002",
+	},
+	{
+		"19",
+		"a1e81c04f30ce201c7c9ace785ed44cc33b455a022f2acdbc6cae83c",
+		"dcf1f6c3db09c70acc25391d492fe25b4a180babd6cea356c04719cd",
+	},
+	{
+		"20",
+		"fcc7f2b45df1cd5a3c0c0731ca47a8af75cfb0347e8354eefe782455",
+		"d5d7110274cba7cdee90e1a8b0d394c376a5573db6be0bf2747f530",
+	},
+	{
+		"112233445566778899",
+		"61f077c6f62ed802dad7c2f38f5c67f2cc453601e61bd076bb46179e",
+		"2272f9e9f5933e70388ee652513443b5e289dd135dcc0d0299b225e4",
+	},
+	{
+		"112233445566778899112233445566778899",
+		"29895f0af496bfc62b6ef8d8a65c88c613949b03668aab4f0429e35",
+		"3ea6e53f9a841f2019ec24bde1a75677aa9b5902e61081c01064de93",
+	},
+	{
+		"6950511619965839450988900688150712778015737983940691968051900319680",
+		"ab689930bcae4a4aa5f5cb085e823e8ae30fd365eb1da4aba9cf0379",
+		"3345a121bbd233548af0d210654eb40bab788a03666419be6fbd34e7",
+	},
+	{
+		"13479972933410060327035789020509431695094902435494295338570602119423",
+		"bdb6a8817c1f89da1c2f3dd8e97feb4494f2ed302a4ce2bc7f5f4025",
+		"4c7020d57c00411889462d77a5438bb4e97d177700bf7243a07f1680",
+	},
+	{
+		"13479971751745682581351455311314208093898607229429740618390390702079",
+		"d58b61aa41c32dd5eba462647dba75c5d67c83606c0af2bd928446a9",
+		"d24ba6a837be0460dd107ae77725696d211446c5609b4595976b16bd",
+	},
+	{
+		"13479972931865328106486971546324465392952975980343228160962702868479",
+		"dc9fa77978a005510980e929a1485f63716df695d7a0c18bb518df03",
+		"ede2b016f2ddffc2a8c015b134928275ce09e5661b7ab14ce0d1d403",
+	},
+	{
+		"11795773708834916026404142434151065506931607341523388140225443265536",
+		"499d8b2829cfb879c901f7d85d357045edab55028824d0f05ba279ba",
+		"bf929537b06e4015919639d94f57838fa33fc3d952598dcdbb44d638",
+	},
+	{
+		"784254593043826236572847595991346435467177662189391577090",
+		"8246c999137186632c5f9eddf3b1b0e1764c5e8bd0e0d8a554b9cb77",
+		"e80ed8660bc1cb17ac7d845be40a7a022d3306f116ae9f81fea65947",
+	},
+	{
+		"13479767645505654746623887797783387853576174193480695826442858012671",
+		"6670c20afcceaea672c97f75e2e9dd5c8460e54bb38538ebb4bd30eb",
+		"f280d8008d07a4caf54271f993527d46ff3ff46fd1190a3f1faa4f74",
+	},
+	{
+		"205688069665150753842126177372015544874550518966168735589597183",
+		"eca934247425cfd949b795cb5ce1eff401550386e28d1a4c5a8eb",
+		"d4c01040dba19628931bc8855370317c722cbd9ca6156985f1c2e9ce",
+	},
+	{
+		"13479966930919337728895168462090683249159702977113823384618282123295",
+		"ef353bf5c73cd551b96d596fbc9a67f16d61dd9fe56af19de1fba9cd",
+		"21771b9cdce3e8430c09b3838be70b48c21e15bc09ee1f2d7945b91f",
+	},
+	{
+		"50210731791415612487756441341851895584393717453129007497216",
+		"4036052a3091eb481046ad3289c95d3ac905ca0023de2c03ecd451cf",
+		"d768165a38a2b96f812586a9d59d4136035d9c853a5bf2e1c86a4993",
+	},
+	{
+		"26959946667150639794667015087019625940457807714424391721682722368041",
+		"fcc7f2b45df1cd5a3c0c0731ca47a8af75cfb0347e8354eefe782455",
+		"f2a28eefd8b345832116f1e574f2c6b2c895aa8c24941f40d8b80ad1",
+	},
+	{
+		"26959946667150639794667015087019625940457807714424391721682722368042",
+		"a1e81c04f30ce201c7c9ace785ed44cc33b455a022f2acdbc6cae83c",
+		"230e093c24f638f533dac6e2b6d01da3b5e7f45429315ca93fb8e634",
+	},
+	{
+		"26959946667150639794667015087019625940457807714424391721682722368043",
+		"c9ff61b040874c0568479216824a15eab1a838a797d189746226e4cc",
+		"156729f1a003647030666054e208180f8f7b0df2249e44fba5931fff",
+	},
+	{
+		"26959946667150639794667015087019625940457807714424391721682722368044",
+		"b8357c3a6ceef288310e17b8bfeff9200846ca8c1942497c484403bc",
+		"eb610599f95942df1082e4f9426d086fb9c6231ae8b24933aab5db",
+	},
+	{
+		"26959946667150639794667015087019625940457807714424391721682722368045",
+		"b6ec4fe1777382404ef679997ba8d1cc5cd8e85349259f590c4c66d",
+		"cc662b9bcba6f94ee4ff1c9c10bd6ddd0d138df2d099a282152a4b7f",
+	},
+	{
+		"26959946667150639794667015087019625940457807714424391721682722368046",
+		"baa4d8635511a7d288aebeedd12ce529ff102c91f97f867e21916bf9",
+		"6865a0b8a607f0b04b13d1cb0aa992a5a97f5ee8ca1849efb9ed8678",
+	},
+	{
+		"26959946667150639794667015087019625940457807714424391721682722368047",
+		"a53640c83dc208603ded83e4ecf758f24c357d7cf48088b2ce01e9fa",
+		"2a7eb328dbe663b5a468b5bc97a040a3745396ba636b964370dc3352",
+	},
+	{
+		"26959946667150639794667015087019625940457807714424391721682722368048",
+		"34e8e17a430e43289793c383fac9774247b40e9ebd3366981fcfaeca",
+		"dad7e608e380480434ea641cc82c82cbc92801469c8db0204f13489a",
+	},
+	{
+		"26959946667150639794667015087019625940457807714424391721682722368049",
+		"6e31ee1dc137f81b056752e4deab1443a481033e9b4c93a3044f4f7a",
+		"df82220fc7a4021549165325725f94c3410ddb56c54e161fc9ef62ee",
+	},
+	{
+		"26959946667150639794667015087019625940457807714424391721682722368050",
+		"ef53b6294aca431f0f3c22dc82eb9050324f1d88d377e716448e507c",
+		"df4aefffbf6d1699c930481cd102127c9a3d992048ab05929b6e5927",
+	},
+	{
+		"26959946667150639794667015087019625940457807714424391721682722368051",
+		"aea9e17a306517eb89152aa7096d2c381ec813c51aa880e7bee2c0fd",
+		"c644cf154cc81f5ade49345e541b4d4b5c1adb3eb5c01c14ee949aa2",
+	},
+	{
+		"26959946667150639794667015087019625940457807714424391721682722368052",
+		"2fdcccfee720a77ef6cb3bfbb447f9383117e3daa4a07e36ed15f78d",
+		"c8e8cd1b0be40b0877cfca1958603122f1e6914f84b7e8e968ae8b9e",
+	},
+	{
+		"26959946667150639794667015087019625940457807714424391721682722368053",
+		"858e6f9cc6c12c31f5df124aa77767b05c8bc021bd683d2b55571550",
+		"fb9232c15a3bc7673a3a03b0253824c53d0fd1411b1cabe2e187fb87",
+	},
+	{
+		"26959946667150639794667015087019625940457807714424391721682722368054",
+		"db2f6be630e246a5cf7d99b85194b123d487e2d466b94b24a03c3e28",
+		"f0c5cff7ab680d09ee11dae84e9c1072ac48ea2e744b1b7f72fd469e",
+	},
+	{
+		"26959946667150639794667015087019625940457807714424391721682722368055",
+		"1f2483f82572251fca975fea40db821df8ad82a3c002ee6c57112408",
+		"76050f3348af2664aac3a8b05281304ebc7a7914c6ad50a4b4eac383",
+	},
+	{
+		"26959946667150639794667015087019625940457807714424391721682722368056",
+		"31c49ae75bce7807cdff22055d94ee9021fedbb5ab51c57526f011aa",
+		"d817400e8ba9ca13a45f360e3d121eaaeb39af82d6001c8186f5f866",
+	},
+	{
+		"26959946667150639794667015087019625940457807714424391721682722368057",
+		"ae99feebb5d26945b54892092a8aee02912930fa41cd114e40447301",
+		"fb7da7f5f13a43b81774373c879cd32d6934c05fa758eeb14fcfab38",
+	},
+	{
+		"26959946667150639794667015087019625940457807714424391721682722368058",
+		"df1b1d66a551d0d31eff822558b9d2cc75c2180279fe0d08fd896d04",
+		"5c080fc3522f41bbb3f55a97cfecf21f882ce8cbb1e50ca6e67e56dc",
+	},
+	{
+		"26959946667150639794667015087019625940457807714424391721682722368059",
+		"706a46dc76dcb76798e60e6d89474788d16dc18032d268fd1a704fa6",
+		"e3d4895843da188fd58fb0567976d7b50359d6b78530c8f62d1b1746",
+	},
+	{
+		"26959946667150639794667015087019625940457807714424391721682722368060",
+		"b70e0cbd6bb4bf7f321390b94a03c1d356c21122343280d6115c1d21",
+		"42c89c774a08dc04b3dd201932bc8a5ea5f8b89bbb2a7e667aff81cd",
+	},
+}
+
+func TestP224BaseMult(t *testing.T) {
+	p224 := P224()
+	for i, e := range p224BaseMultTests {
+		k, ok := new(big.Int).SetString(e.k, 10)
+		if !ok {
+			t.Errorf("%d: bad value for k: %s", i, e.k)
+		}
+		x, y := p224.ScalarBaseMult(k.Bytes())
+		if fmt.Sprintf("%x", x) != e.x || fmt.Sprintf("%x", y) != e.y {
+			t.Errorf("%d: bad output for k=%s: got (%x, %x), want (%s, %s)", i, e.k, x, y, e.x, e.y)
+		}
+		if testing.Short() && i > 5 {
+			break
+		}
+	}
+}
+
+func TestP224GenericBaseMult(t *testing.T) {
+	// We use the P224 CurveParams directly in order to test the generic implementation.
+	p224 := P224().Params()
+	for i, e := range p224BaseMultTests {
+		k, ok := new(big.Int).SetString(e.k, 10)
+		if !ok {
+			t.Errorf("%d: bad value for k: %s", i, e.k)
+		}
+		x, y := p224.ScalarBaseMult(k.Bytes())
+		if fmt.Sprintf("%x", x) != e.x || fmt.Sprintf("%x", y) != e.y {
+			t.Errorf("%d: bad output for k=%s: got (%x, %x), want (%s, %s)", i, e.k, x, y, e.x, e.y)
+		}
+		if testing.Short() && i > 5 {
+			break
+		}
+	}
+}
+
+func TestP224Overflow(t *testing.T) {
+	// This tests for a specific bug in the P224 implementation.
+	p224 := P224()
+	pointData, _ := hex.DecodeString("049B535B45FB0A2072398A6831834624C7E32CCFD5A4B933BCEAF77F1DD945E08BBE5178F5EDF5E733388F196D2A631D2E075BB16CBFEEA15B")
+	x, y := Unmarshal(p224, pointData)
+	if !p224.IsOnCurve(x, y) {
+		t.Error("P224 failed to validate a correct point")
+	}
+}
diff --git a/src/crypto/elliptic/p256_test.go b/src/crypto/elliptic/p256_test.go
new file mode 100644
index 0000000000..1435f5e1a5
--- /dev/null
+++ b/src/crypto/elliptic/p256_test.go
@@ -0,0 +1,155 @@
+// Copyright 2021 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 elliptic
+
+import (
+	"math/big"
+	"testing"
+)
+
+type scalarMultTest struct {
+	k          string
+	xIn, yIn   string
+	xOut, yOut string
+}
+
+var p256MultTests = []scalarMultTest{
+	{
+		"2a265f8bcbdcaf94d58519141e578124cb40d64a501fba9c11847b28965bc737",
+		"023819813ac969847059028ea88a1f30dfbcde03fc791d3a252c6b41211882ea",
+		"f93e4ae433cc12cf2a43fc0ef26400c0e125508224cdb649380f25479148a4ad",
+		"4d4de80f1534850d261075997e3049321a0864082d24a917863366c0724f5ae3",
+		"a22d2b7f7818a3563e0f7a76c9bf0921ac55e06e2e4d11795b233824b1db8cc0",
+	},
+	{
+		"313f72ff9fe811bf573176231b286a3bdb6f1b14e05c40146590727a71c3bccd",
+		"cc11887b2d66cbae8f4d306627192522932146b42f01d3c6f92bd5c8ba739b06",
+		"a2f08a029cd06b46183085bae9248b0ed15b70280c7ef13a457f5af382426031",
+		"831c3f6b5f762d2f461901577af41354ac5f228c2591f84f8a6e51e2e3f17991",
+		"93f90934cd0ef2c698cc471c60a93524e87ab31ca2412252337f364513e43684",
+	},
+}
+
+func TestP256BaseMult(t *testing.T) {
+	p256 := P256()
+	p256Generic := p256.Params()
+
+	scalars := make([]*big.Int, 0, len(p224BaseMultTests)+1)
+	for _, e := range p224BaseMultTests {
+		k, _ := new(big.Int).SetString(e.k, 10)
+		scalars = append(scalars, k)
+	}
+	k := new(big.Int).SetInt64(1)
+	k.Lsh(k, 500)
+	scalars = append(scalars, k)
+
+	for i, k := range scalars {
+		x, y := p256.ScalarBaseMult(k.Bytes())
+		x2, y2 := p256Generic.ScalarBaseMult(k.Bytes())
+		if x.Cmp(x2) != 0 || y.Cmp(y2) != 0 {
+			t.Errorf("#%d: got (%x, %x), want (%x, %x)", i, x, y, x2, y2)
+		}
+
+		if testing.Short() && i > 5 {
+			break
+		}
+	}
+}
+
+func TestP256Mult(t *testing.T) {
+	p256 := P256()
+	p256Generic := p256.Params()
+
+	for i, e := range p224BaseMultTests {
+		x, _ := new(big.Int).SetString(e.x, 16)
+		y, _ := new(big.Int).SetString(e.y, 16)
+		k, _ := new(big.Int).SetString(e.k, 10)
+
+		xx, yy := p256.ScalarMult(x, y, k.Bytes())
+		xx2, yy2 := p256Generic.ScalarMult(x, y, k.Bytes())
+		if xx.Cmp(xx2) != 0 || yy.Cmp(yy2) != 0 {
+			t.Errorf("#%d: got (%x, %x), want (%x, %x)", i, xx, yy, xx2, yy2)
+		}
+		if testing.Short() && i > 5 {
+			break
+		}
+	}
+
+	for i, e := range p256MultTests {
+		x, _ := new(big.Int).SetString(e.xIn, 16)
+		y, _ := new(big.Int).SetString(e.yIn, 16)
+		k, _ := new(big.Int).SetString(e.k, 16)
+		expectedX, _ := new(big.Int).SetString(e.xOut, 16)
+		expectedY, _ := new(big.Int).SetString(e.yOut, 16)
+
+		xx, yy := p256.ScalarMult(x, y, k.Bytes())
+		if xx.Cmp(expectedX) != 0 || yy.Cmp(expectedY) != 0 {
+			t.Errorf("#%d: got (%x, %x), want (%x, %x)", i, xx, yy, expectedX, expectedY)
+		}
+	}
+}
+
+type synthCombinedMult struct {
+	Curve
+}
+
+func (s synthCombinedMult) CombinedMult(bigX, bigY *big.Int, baseScalar, scalar []byte) (x, y *big.Int) {
+	x1, y1 := s.ScalarBaseMult(baseScalar)
+	x2, y2 := s.ScalarMult(bigX, bigY, scalar)
+	return s.Add(x1, y1, x2, y2)
+}
+
+func TestP256CombinedMult(t *testing.T) {
+	type combinedMult interface {
+		Curve
+		CombinedMult(bigX, bigY *big.Int, baseScalar, scalar []byte) (x, y *big.Int)
+	}
+
+	p256, ok := P256().(combinedMult)
+	if !ok {
+		p256 = &synthCombinedMult{P256()}
+	}
+
+	gx := p256.Params().Gx
+	gy := p256.Params().Gy
+
+	zero := make([]byte, 32)
+	one := make([]byte, 32)
+	one[31] = 1
+	two := make([]byte, 32)
+	two[31] = 2
+
+	// 0×G + 0×G = ∞
+	x, y := p256.CombinedMult(gx, gy, zero, zero)
+	if x.Sign() != 0 || y.Sign() != 0 {
+		t.Errorf("0×G + 0×G = (%d, %d), should be ∞", x, y)
+	}
+
+	// 1×G + 0×G = G
+	x, y = p256.CombinedMult(gx, gy, one, zero)
+	if x.Cmp(gx) != 0 || y.Cmp(gy) != 0 {
+		t.Errorf("1×G + 0×G = (%d, %d), should be (%d, %d)", x, y, gx, gy)
+	}
+
+	// 0×G + 1×G = G
+	x, y = p256.CombinedMult(gx, gy, zero, one)
+	if x.Cmp(gx) != 0 || y.Cmp(gy) != 0 {
+		t.Errorf("0×G + 1×G = (%d, %d), should be (%d, %d)", x, y, gx, gy)
+	}
+
+	// 1×G + 1×G = 2×G
+	x, y = p256.CombinedMult(gx, gy, one, one)
+	ggx, ggy := p256.ScalarBaseMult(two)
+	if x.Cmp(ggx) != 0 || y.Cmp(ggy) != 0 {
+		t.Errorf("1×G + 1×G = (%d, %d), should be (%d, %d)", x, y, ggx, ggy)
+	}
+
+	minusOne := new(big.Int).Sub(p256.Params().N, big.NewInt(1))
+	// 1×G + (-1)×G = ∞
+	x, y = p256.CombinedMult(gx, gy, one, minusOne.Bytes())
+	if x.Sign() != 0 || y.Sign() != 0 {
+		t.Errorf("1×G + (-1)×G = (%d, %d), should be ∞", x, y)
+	}
+}
-- 
GitLab


From b4ca1cec69f8248b77d8d8ce019943ced5235ed0 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Tue, 9 Mar 2021 20:43:49 -0500
Subject: [PATCH 1986/2400] cmd/compile: set unsayable "names" for regabi
 testing triggers

This disables the "testing names" for method names and
trailing input types passed to closure/interface/other calls.
The logic using the names remains, so that editing the change
to enable local testing is not too hard.

Also fixes broken build tag in reflect/abi_test.go

Updates #44816.

Change-Id: I3d222d2473c98d04ab6f1122ede9fea70c994af1
Reviewed-on: https://go-review.googlesource.com/c/go/+/300150
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
---
 src/cmd/compile/internal/ssagen/ssa.go |  7 ++--
 src/reflect/abi_test.go                |  7 +++-
 test/abi/fibish2.go                    | 40 --------------------
 test/abi/fibish2.out                   |  1 -
 test/abi/methods.go                    | 52 --------------------------
 test/abi/methods.out                   |  2 -
 6 files changed, 9 insertions(+), 100 deletions(-)
 delete mode 100644 test/abi/fibish2.go
 delete mode 100644 test/abi/fibish2.out
 delete mode 100644 test/abi/methods.go
 delete mode 100644 test/abi/methods.out

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index c65e738188..75973c46a6 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -223,9 +223,10 @@ func AbiForBodylessFuncStackMap(fn *ir.Func) *abi.ABIConfig {
 	return ssaConfig.ABI0.Copy() // No idea what races will result, be safe
 }
 
-// TODO (NLT 2021-04-15) This must be changed to a name that cannot match; it may be helpful to other register ABI work to keep the trigger-logic
-const magicNameDotSuffix = ".MagicMethodNameForTestingRegisterABI"
-const magicLastTypeName = "MagicLastTypeNameForTestingRegisterABI"
+// These are disabled but remain ready for use in case they are needed for the next regabi port.
+// TODO if they are not needed for 1.18 / next register abi port, delete them.
+const magicNameDotSuffix = ".*disabled*MagicMethodNameForTestingRegisterABI"
+const magicLastTypeName = "*disabled*MagicLastTypeNameForTestingRegisterABI"
 
 // abiForFunc implements ABI policy for a function, but does not return a copy of the ABI.
 // Passing a nil function returns the default ABI based on experiment configuration.
diff --git a/src/reflect/abi_test.go b/src/reflect/abi_test.go
index 224143c9bf..1a2a48b5ed 100644
--- a/src/reflect/abi_test.go
+++ b/src/reflect/abi_test.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build goexperiment.regabi
-//go:build goexperiment.regabi
+//go:build goexperiment.regabireflect
+// +build goexperiment.regabireflect
 
 package reflect_test
 
@@ -16,6 +16,9 @@ import (
 	"testing/quick"
 )
 
+// As of early May 2021 this is no longer necessary for amd64,
+// but it remains in case this is needed for the next register abi port.
+// TODO (1.18) If enabling register ABI on additional architectures turns out not to need this, remove it.
 type MagicLastTypeNameForTestingRegisterABI struct{}
 
 func TestMethodValueCallABI(t *testing.T) {
diff --git a/test/abi/fibish2.go b/test/abi/fibish2.go
deleted file mode 100644
index 388aabc8b0..0000000000
--- a/test/abi/fibish2.go
+++ /dev/null
@@ -1,40 +0,0 @@
-// run
-
-//go:build !wasm
-// +build !wasm
-
-// Copyright 2021 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 "fmt"
-
-// Test that register results are correctly returned (and passed)
-
-type MagicLastTypeNameForTestingRegisterABI func(int, MagicLastTypeNameForTestingRegisterABI) int
-
-//go:registerparams
-//go:noinline
-func minus(decrement int) MagicLastTypeNameForTestingRegisterABI {
-	return MagicLastTypeNameForTestingRegisterABI(func(x int, _ MagicLastTypeNameForTestingRegisterABI) int { return x - decrement })
-}
-
-//go:noinline
-func f(x int, sub1 MagicLastTypeNameForTestingRegisterABI) (int, int) {
-
-	if x < 3 {
-		return 0, x
-	}
-
-	a, b := f(sub1(sub1(x, sub1), sub1), sub1)
-	c, d := f(sub1(x, sub1), sub1)
-	return a + d, b + c
-}
-
-func main() {
-	x := 40
-	a, b := f(x, minus(1))
-	fmt.Printf("f(%d)=%d,%d\n", x, a, b)
-}
diff --git a/test/abi/fibish2.out b/test/abi/fibish2.out
deleted file mode 100644
index 9bd80c32c9..0000000000
--- a/test/abi/fibish2.out
+++ /dev/null
@@ -1 +0,0 @@
-f(40)=39088169,126491972
diff --git a/test/abi/methods.go b/test/abi/methods.go
deleted file mode 100644
index 3dcd3e327a..0000000000
--- a/test/abi/methods.go
+++ /dev/null
@@ -1,52 +0,0 @@
-// run
-
-//go:build !wasm
-// +build !wasm
-
-// Copyright 2021 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 (
-	"fmt"
-)
-
-type toobig struct {
-	a, b, c string
-}
-
-//go:registerparams
-//go:noinline
-func (x *toobig) MagicMethodNameForTestingRegisterABI(y toobig, z toobig) toobig {
-	return toobig{x.a, y.b, z.c}
-}
-
-type AnInterface interface {
-	MagicMethodNameForTestingRegisterABI(y toobig, z toobig) toobig
-}
-
-//go:registerparams
-//go:noinline
-func I(a, b, c string) toobig {
-	return toobig{a, b, c}
-}
-
-// AnIid prevents the compiler from figuring out what the interface really is.
-//go:noinline
-func AnIid(x AnInterface) AnInterface {
-	return x
-}
-
-var tmp toobig
-
-func main() {
-	x := I("Ahoy", "1,", "2")
-	y := I("3", "there,", "4")
-	z := I("5", "6,", "Matey")
-	tmp = x.MagicMethodNameForTestingRegisterABI(y, z)
-	fmt.Println(tmp.a, tmp.b, tmp.c)
-	tmp = AnIid(&x).MagicMethodNameForTestingRegisterABI(y, z)
-	fmt.Println(tmp.a, tmp.b, tmp.c)
-}
diff --git a/test/abi/methods.out b/test/abi/methods.out
deleted file mode 100644
index 5a72b0edf7..0000000000
--- a/test/abi/methods.out
+++ /dev/null
@@ -1,2 +0,0 @@
-Ahoy there, Matey
-Ahoy there, Matey
-- 
GitLab


From ba0f8ce50fd982fe6e51f77c515660fffdebe40c Mon Sep 17 00:00:00 2001
From: sivchari <shibuuuu5@gmail.com>
Date: Thu, 6 May 2021 07:40:22 +0000
Subject: [PATCH 1987/2400] runtime: gofmt proc_test.go

Change-Id: I09a2be64e96fe85d84560728814af74b234d7210
GitHub-Last-Rev: bc881ea0022326fcc35e0356a79634fde00efd2a
GitHub-Pull-Request: golang/go#45929
Reviewed-on: https://go-review.googlesource.com/c/go/+/316409
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Michael Pratt <mpratt@google.com>
---
 src/runtime/proc_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/proc_test.go b/src/runtime/proc_test.go
index 01152dff76..53cafe8907 100644
--- a/src/runtime/proc_test.go
+++ b/src/runtime/proc_test.go
@@ -734,7 +734,7 @@ func BenchmarkCreateGoroutinesSingle(b *testing.B) {
 	var wg sync.WaitGroup
 	wg.Add(b.N)
 	for i := 0; i < b.N; i++ {
-		go func(){
+		go func() {
 			wg.Done()
 		}()
 	}
-- 
GitLab


From 0e7a7a68cd2a29895eae345ce56145b780d4a06c Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 5 May 2021 11:22:58 -0400
Subject: [PATCH 1988/2400] text/template/parse: rename DeferFuncCheck to
 SkipFuncCheck
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The proposal as accepted in #34652 named the bit SkipFuncCheck.
It was renamed to DeferFuncCheck during the code review on a suggestion by Rob,
along with a comment to “defer type checking functions until template is executed,”
but this description is not accurate: the package has never type-checked functions,
only verified their existence. And the effect of the bit in this package is to eliminate
this check entirely, not to defer it to some later time.

I was writing code using this new bit and was very confused about when the
"type checking" was being deferred to and how to stop that entirely,
since in my use case I wanted no checks at all. What I wanted is what the bit does,
it just wasn't named accurately.

Rename back to SkipFuncCheck.

Change-Id: I8e62099c8a904ed04521eb5b86155290f6d5b12f
Reviewed-on: https://go-review.googlesource.com/c/go/+/317269
Trust: Russ Cox <rsc@golang.org>
Trust: Daniel Martí <mvdan@mvdan.cc>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Rob Pike <r@golang.org>
---
 api/next.txt                          | 4 ++--
 src/text/template/parse/parse.go      | 6 +++---
 src/text/template/parse/parse_test.go | 6 +++---
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/api/next.txt b/api/next.txt
index a6471c7f3a..9e996005c6 100644
--- a/api/next.txt
+++ b/api/next.txt
@@ -90,8 +90,8 @@ pkg syscall (windows-amd64), type SysProcAttr struct, AdditionalInheritedHandles
 pkg syscall (windows-amd64), type SysProcAttr struct, ParentProcess Handle
 pkg testing, method (*B) Setenv(string, string)
 pkg testing, method (*T) Setenv(string, string)
-pkg text/template/parse, const DeferFuncCheck = 2
-pkg text/template/parse, const DeferFuncCheck Mode
+pkg text/template/parse, const SkipFuncCheck = 2
+pkg text/template/parse, const SkipFuncCheck Mode
 pkg time, func UnixMicro(int64) Time
 pkg time, func UnixMilli(int64) Time
 pkg time, method (*Time) IsDST() bool
diff --git a/src/text/template/parse/parse.go b/src/text/template/parse/parse.go
index ff1358b001..1a63961c13 100644
--- a/src/text/template/parse/parse.go
+++ b/src/text/template/parse/parse.go
@@ -38,8 +38,8 @@ type Tree struct {
 type Mode uint
 
 const (
-	ParseComments  Mode = 1 << iota // parse comments and add them to AST
-	DeferFuncCheck                  // defer type checking functions until template is executed
+	ParseComments Mode = 1 << iota // parse comments and add them to AST
+	SkipFuncCheck                  // do not check that functions are defined
 )
 
 // Copy returns a copy of the Tree. Any parsing state is discarded.
@@ -690,7 +690,7 @@ func (t *Tree) operand() Node {
 func (t *Tree) term() Node {
 	switch token := t.nextNonSpace(); token.typ {
 	case itemIdentifier:
-		checkFunc := t.Mode&DeferFuncCheck == 0
+		checkFunc := t.Mode&SkipFuncCheck == 0
 		if checkFunc && !t.hasFunction(token.val) {
 			t.errorf("function %q not defined", token.val)
 		}
diff --git a/src/text/template/parse/parse_test.go b/src/text/template/parse/parse_test.go
index c4585f6912..9b1be272e5 100644
--- a/src/text/template/parse/parse_test.go
+++ b/src/text/template/parse/parse_test.go
@@ -379,12 +379,12 @@ func TestParseWithComments(t *testing.T) {
 	}
 }
 
-func TestDeferFuncCheck(t *testing.T) {
+func TestSkipFuncCheck(t *testing.T) {
 	oldTextFormat := textFormat
 	textFormat = "%q"
 	defer func() { textFormat = oldTextFormat }()
-	tr := New("defer func check")
-	tr.Mode = DeferFuncCheck
+	tr := New("skip func check")
+	tr.Mode = SkipFuncCheck
 	tmpl, err := tr.Parse("{{fn 1 2}}", "", "", make(map[string]*Tree))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
-- 
GitLab


From d2fd503f687ca686cb8fbee0b29e64ba529038fe Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 5 May 2021 21:13:24 -0400
Subject: [PATCH 1989/2400] text/template: fix type bug in eq

{{eq .x 0}} where .x is a nil interface{} should be false, not a type error.

Similarly, {{eq .x .x}} should succeed, not panic in reflect.

Fixes #45982.

Change-Id: I90aba82bb2f1a9e162bde1290c94f5028f56f412
Reviewed-on: https://go-review.googlesource.com/c/go/+/317470
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Rob Pike <r@golang.org>
---
 src/text/template/exec_test.go | 19 +++++++++++--------
 src/text/template/funcs.go     |  6 ++++--
 2 files changed, 15 insertions(+), 10 deletions(-)

diff --git a/src/text/template/exec_test.go b/src/text/template/exec_test.go
index e73fce4fa8..ef521645a7 100644
--- a/src/text/template/exec_test.go
+++ b/src/text/template/exec_test.go
@@ -1201,8 +1201,11 @@ var cmpTests = []cmpTest{
 	{"eq .Ptr .NilPtr", "false", true},
 	{"eq .NilPtr .NilPtr", "true", true},
 	{"eq .Iface1 .Iface1", "true", true},
-	{"eq .Iface1 .Iface2", "false", true},
-	{"eq .Iface2 .Iface2", "true", true},
+	{"eq .Iface1 .NilIface", "false", true},
+	{"eq .NilIface .NilIface", "true", true},
+	{"eq .NilIface .Iface1", "false", true},
+	{"eq .NilIface 0", "false", true},
+	{"eq 0 .NilIface", "false", true},
 	// Errors
 	{"eq `xy` 1", "", false},       // Different types.
 	{"eq 2 2.0", "", false},        // Different types.
@@ -1217,12 +1220,12 @@ var cmpTests = []cmpTest{
 func TestComparison(t *testing.T) {
 	b := new(bytes.Buffer)
 	var cmpStruct = struct {
-		Uthree, Ufour  uint
-		NegOne, Three  int
-		Ptr, NilPtr    *int
-		Map            map[int]int
-		V1, V2         V
-		Iface1, Iface2 fmt.Stringer
+		Uthree, Ufour    uint
+		NegOne, Three    int
+		Ptr, NilPtr      *int
+		Map              map[int]int
+		V1, V2           V
+		Iface1, NilIface fmt.Stringer
 	}{
 		Uthree: 3,
 		Ufour:  4,
diff --git a/src/text/template/funcs.go b/src/text/template/funcs.go
index 9dd332c068..fff833ed29 100644
--- a/src/text/template/funcs.go
+++ b/src/text/template/funcs.go
@@ -478,7 +478,9 @@ func eq(arg1 reflect.Value, arg2 ...reflect.Value) (bool, error) {
 			case k1 == uintKind && k2 == intKind:
 				truth = arg.Int() >= 0 && arg1.Uint() == uint64(arg.Int())
 			default:
-				return false, errBadComparison
+				if arg1 != zero && arg != zero {
+					return false, errBadComparison
+				}
 			}
 		} else {
 			switch k1 {
@@ -495,7 +497,7 @@ func eq(arg1 reflect.Value, arg2 ...reflect.Value) (bool, error) {
 			case uintKind:
 				truth = arg1.Uint() == arg.Uint()
 			default:
-				if arg == zero {
+				if arg == zero || arg1 == zero {
 					truth = arg1 == arg
 				} else {
 					if t2 := arg.Type(); !t2.Comparable() {
-- 
GitLab


From 54e20b505d370210f05ab567c0d19e9bb51db8a3 Mon Sep 17 00:00:00 2001
From: Dmitri Shuralyov <dmitshur@golang.org>
Date: Wed, 5 May 2021 19:27:51 -0400
Subject: [PATCH 1990/2400] doc/go1.17: document fixes for negative rune
 handling

CL 317273 accidentally grouped a fix for bufio, bytes, strings
packages into a single entry, but they should be separate ones.

Fix that, and document these negative rune handling fixes.

The list of fixed functions in package unicode was computed by
taking the functions covered by the new TestNegativeRunes test,
and including those that fail when tested with Go 1.16.3.

For #44513.
Updates #43254.

Change-Id: I6f387327f83ae52543526dbdcdd0bb5775c678bd
Reviewed-on: https://go-review.googlesource.com/c/go/+/317469
Reviewed-by: David Benjamin <davidben@google.com>
Reviewed-by: Alexander Rakoczy <alex@golang.org>
Trust: Alexander Rakoczy <alex@golang.org>
Trust: Dmitri Shuralyov <dmitshur@golang.org>
Run-TryBot: Alexander Rakoczy <alex@golang.org>
---
 doc/go1.17.html | 41 +++++++++++++++++++++++++++++++++++++----
 1 file changed, 37 insertions(+), 4 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 9f33486869..9328211c9a 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -241,13 +241,25 @@ Do not send CLs removing the interior tags from such phrases.
   </dd>
 </dl><!-- archive/zip -->
 
-<dl id="bufio, bytes, strings"><dt><a href="/pkg/bufio, bytes, strings/">bufio, bytes, strings</a></dt>
+<dl id="bufio"><dt><a href="/pkg/bufio/">bufio</a></dt>
   <dd>
     <p><!-- CL 280492 -->
-      TODO: <a href="https://golang.org/cl/280492">https://golang.org/cl/280492</a>: handle negative runes in WriteRune
+      The <a href="/pkg/bufio/#Writer.WriteRune"><code>Writer.WriteRune</code></a> method
+      now writes the replacement character U+FFFD for negative rune values,
+      as it does for other invalid runes.
     </p>
   </dd>
-</dl><!-- bufio, bytes, strings -->
+</dl><!-- bufio -->
+
+<dl id="bytes"><dt><a href="/pkg/bytes/">bytes</a></dt>
+  <dd>
+    <p><!-- CL 280492 -->
+      The <a href="/pkg/bytes/#Buffer.WriteRune"><code>Buffer.WriteRune</code></a> method
+      now writes the replacement character U+FFFD for negative rune values,
+      as it does for other invalid runes.
+    </p>
+  </dd>
+</dl><!-- bytes -->
 
 <dl id="compress/lzw"><dt><a href="/pkg/compress/lzw/">compress/lzw</a></dt>
   <dd>
@@ -416,6 +428,16 @@ Do not send CLs removing the interior tags from such phrases.
   </dd>
 </dl><!-- strconv -->
 
+<dl id="strings"><dt><a href="/pkg/strings/">strings</a></dt>
+  <dd>
+    <p><!-- CL 280492 -->
+      The <a href="/pkg/strings/#Builder.WriteRune"><code>Builder.WriteRune</code></a> method
+      now writes the replacement character U+FFFD for negative rune values,
+      as it does for other invalid runes.
+    </p>
+  </dd>
+</dl><!-- strings -->
+
 <dl id="sync/atomic"><dt><a href="/pkg/sync/atomic/">sync/atomic</a></dt>
   <dd>
     <p><!-- CL 241678 -->
@@ -477,7 +499,18 @@ Do not send CLs removing the interior tags from such phrases.
 <dl id="unicode"><dt><a href="/pkg/unicode/">unicode</a></dt>
   <dd>
     <p><!-- CL 280493 -->
-      TODO: <a href="https://golang.org/cl/280493">https://golang.org/cl/280493</a>: correctly handle negative runes
+      The <a href="/pkg/unicode/#Is"><code>Is</code></a>,
+      <a href="/pkg/unicode/#IsGraphic"><code>IsGraphic</code></a>,
+      <a href="/pkg/unicode/#IsLetter"><code>IsLetter</code></a>,
+      <a href="/pkg/unicode/#IsLower"><code>IsLower</code></a>,
+      <a href="/pkg/unicode/#IsMark"><code>IsMark</code></a>,
+      <a href="/pkg/unicode/#IsNumber"><code>IsNumber</code></a>,
+      <a href="/pkg/unicode/#IsPrint"><code>IsPrint</code></a>,
+      <a href="/pkg/unicode/#IsPunct"><code>IsPunct</code></a>,
+      <a href="/pkg/unicode/#IsSpace"><code>IsSpace</code></a>,
+      <a href="/pkg/unicode/#IsSymbol"><code>IsSymbol</code></a>, and
+      <a href="/pkg/unicode/#IsUpper"><code>IsUpper</code></a> functions
+      now return <code>false</code> on negative rune values, as they do for other invalid runes.
     </p>
   </dd>
 </dl><!-- unicode -->
-- 
GitLab


From 6c591f79b0b5327549bd4e94970f7a279efb4ab0 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Sun, 2 May 2021 11:27:03 -0700
Subject: [PATCH 1991/2400] math/big: check for excessive exponents in
 Rat.SetString

Found by oss-fuzz https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=33284

Fixes #45910.

Change-Id: I61e7b04dbd80343420b57eede439e361c0f7b79c
Reviewed-on: https://go-review.googlesource.com/c/go/+/316149
Trust: Robert Griesemer <gri@golang.org>
Trust: Katie Hockman <katie@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/math/big/ratconv.go      | 15 ++++++++-------
 src/math/big/ratconv_test.go | 25 +++++++++++++++++++++++++
 2 files changed, 33 insertions(+), 7 deletions(-)

diff --git a/src/math/big/ratconv.go b/src/math/big/ratconv.go
index 941139e72d..ac3c8bd11f 100644
--- a/src/math/big/ratconv.go
+++ b/src/math/big/ratconv.go
@@ -51,7 +51,8 @@ func (z *Rat) Scan(s fmt.ScanState, ch rune) error {
 // An optional base-10 ``e'' or base-2 ``p'' (or their upper-case variants)
 // exponent may be provided as well, except for hexadecimal floats which
 // only accept an (optional) ``p'' exponent (because an ``e'' or ``E'' cannot
-// be distinguished from a mantissa digit).
+// be distinguished from a mantissa digit). If the exponent's absolute value
+// is too large, the operation may fail.
 // The entire string, not just a prefix, must be valid for success. If the
 // operation failed, the value of z is undefined but the returned value is nil.
 func (z *Rat) SetString(s string) (*Rat, bool) {
@@ -169,6 +170,9 @@ func (z *Rat) SetString(s string) (*Rat, bool) {
 		if n < 0 {
 			n = -n
 		}
+		if n > 1e6 {
+			return nil, false // avoid excessively large exponents
+		}
 		pow5 := z.b.abs.expNN(natFive, nat(nil).setWord(Word(n)), nil) // use underlying array of z.b.abs
 		if exp5 > 0 {
 			z.a.abs = z.a.abs.mul(z.a.abs, pow5)
@@ -181,15 +185,12 @@ func (z *Rat) SetString(s string) (*Rat, bool) {
 	}
 
 	// apply exp2 contributions
+	if exp2 < -1e7 || exp2 > 1e7 {
+		return nil, false // avoid excessively large exponents
+	}
 	if exp2 > 0 {
-		if int64(uint(exp2)) != exp2 {
-			panic("exponent too large")
-		}
 		z.a.abs = z.a.abs.shl(z.a.abs, uint(exp2))
 	} else if exp2 < 0 {
-		if int64(uint(-exp2)) != -exp2 {
-			panic("exponent too large")
-		}
 		z.b.abs = z.b.abs.shl(z.b.abs, uint(-exp2))
 	}
 
diff --git a/src/math/big/ratconv_test.go b/src/math/big/ratconv_test.go
index ba0d1ba9e1..15d206cb38 100644
--- a/src/math/big/ratconv_test.go
+++ b/src/math/big/ratconv_test.go
@@ -589,3 +589,28 @@ func TestIssue31184(t *testing.T) {
 		}
 	}
 }
+
+func TestIssue45910(t *testing.T) {
+	var x Rat
+	for _, test := range []struct {
+		input string
+		want  bool
+	}{
+		{"1e-1000001", false},
+		{"1e-1000000", true},
+		{"1e+1000000", true},
+		{"1e+1000001", false},
+
+		{"0p1000000000000", true},
+		{"1p-10000001", false},
+		{"1p-10000000", true},
+		{"1p+10000000", true},
+		{"1p+10000001", false},
+		{"1.770p02041010010011001001", false}, // test case from issue
+	} {
+		_, got := x.SetString(test.input)
+		if got != test.want {
+			t.Errorf("SetString(%s) got ok = %v; want %v", test.input, got, test.want)
+		}
+	}
+}
-- 
GitLab


From 5f9fe47deaceaa3688fcd549c888e8cfdaa1dc1a Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Thu, 6 May 2021 12:21:04 -0400
Subject: [PATCH 1992/2400] CONTRIBUTORS: change my name

Change-Id: I4fd1cf673f5dddb8a2cedd575ad6fcc070c70e86
Reviewed-on: https://go-review.googlesource.com/c/go/+/317590
Trust: Cherry Mui <cherryyz@google.com>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
---
 CONTRIBUTORS | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CONTRIBUTORS b/CONTRIBUTORS
index 56e3da4274..6c7262adb1 100644
--- a/CONTRIBUTORS
+++ b/CONTRIBUTORS
@@ -466,7 +466,7 @@ Charlotte Brandhorst-Satzkorn <catzkorn@gmail.com>
 Chauncy Cullitan <chauncyc@google.com>
 Chen Zhidong <njutczd@gmail.com>
 Chen Zhihan <energiehund@gmail.com>
-Cherry Zhang <cherryyz@google.com>
+Cherry Mui <cherryyz@google.com>
 Chew Choon Keat <choonkeat@gmail.com>
 Chiawen Chen <golopot@gmail.com>
 Chirag Sukhala <cchirag77@gmail.com>
-- 
GitLab


From 51ff3a6965b3fc40aceebe90eaf15a8a1a00a452 Mon Sep 17 00:00:00 2001
From: Roland Shoemaker <roland@golang.org>
Date: Mon, 30 Nov 2020 15:56:01 -0800
Subject: [PATCH 1993/2400] crypto/x509: rewrite certificate parser
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replaces the encoding/asn1 certificate parser with a
x/crypto/cryptobyte based parser. This provides a significant increase
in performance, mostly due to a reduction of lots of small allocs,
as well as almost entirely removing reflection.

Since this is a rather large rewrite only the certificate parser is
replaced, leaving the parsers for CSRs, CRLs, etc for follow-up work.
Since some of the functions that the other parsers use are replaced
with cryptobyte versions, they still get a not insignificant performance
boost.

name                           old time/op    new time/op    delta
ParseCertificate/ecdsa_leaf-8    44.6µs ± 9%    12.7µs ± 4%  -71.58%  (p=0.000 n=20+18)
ParseCertificate/rsa_leaf-8      46.4µs ± 4%    13.2µs ± 2%  -71.49%  (p=0.000 n=18+19)

name                           old allocs/op  new allocs/op  delta
ParseCertificate/ecdsa_leaf-8       501 ± 0%       164 ± 0%  -67.27%  (p=0.000 n=20+20)
ParseCertificate/rsa_leaf-8         545 ± 0%       182 ± 0%  -66.61%  (p=0.000 n=20+20)

Fixes #21118
Fixes #44237

Change-Id: Id653f6ae5e405c3cbf0c5c48abb30aa831e30107
Reviewed-on: https://go-review.googlesource.com/c/go/+/274234
Trust: Roland Shoemaker <roland@golang.org>
Run-TryBot: Roland Shoemaker <roland@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
---
 src/crypto/x509/parser.go    | 1005 ++++++++++++++++++++++++++++++++++
 src/crypto/x509/x509.go      |  672 -----------------------
 src/crypto/x509/x509_test.go |  179 ++++++
 3 files changed, 1184 insertions(+), 672 deletions(-)
 create mode 100644 src/crypto/x509/parser.go

diff --git a/src/crypto/x509/parser.go b/src/crypto/x509/parser.go
new file mode 100644
index 0000000000..578227ab8e
--- /dev/null
+++ b/src/crypto/x509/parser.go
@@ -0,0 +1,1005 @@
+// Copyright 2021 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 x509
+
+import (
+	"bytes"
+	"crypto/dsa"
+	"crypto/ecdsa"
+	"crypto/ed25519"
+	"crypto/elliptic"
+	"crypto/rsa"
+	"crypto/x509/pkix"
+	"encoding/asn1"
+	"errors"
+	"fmt"
+	"math/big"
+	"net"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+	"unicode/utf16"
+	"unicode/utf8"
+
+	"golang.org/x/crypto/cryptobyte"
+	cbasn1 "golang.org/x/crypto/cryptobyte/asn1"
+	cryptobyte_asn1 "golang.org/x/crypto/cryptobyte/asn1"
+)
+
+// isPrintable reports whether the given b is in the ASN.1 PrintableString set.
+// This is a simplified version of encoding/asn1.isPrintable.
+func isPrintable(b byte) bool {
+	return 'a' <= b && b <= 'z' ||
+		'A' <= b && b <= 'Z' ||
+		'0' <= b && b <= '9' ||
+		'\'' <= b && b <= ')' ||
+		'+' <= b && b <= '/' ||
+		b == ' ' ||
+		b == ':' ||
+		b == '=' ||
+		b == '?' ||
+		// This is technically not allowed in a PrintableString.
+		// However, x509 certificates with wildcard strings don't
+		// always use the correct string type so we permit it.
+		b == '*' ||
+		// This is not technically allowed either. However, not
+		// only is it relatively common, but there are also a
+		// handful of CA certificates that contain it. At least
+		// one of which will not expire until 2027.
+		b == '&'
+}
+
+// parseASN1String parses the ASN.1 string types T61String, PrintableString,
+// UTF8String, BMPString, and IA5String. This is mostly copied from the
+// respective encoding/asn1.parse... methods, rather than just increasing
+// the API surface of that package.
+func parseASN1String(tag cbasn1.Tag, value []byte) (string, error) {
+	switch tag {
+	case cbasn1.T61String:
+		return string(value), nil
+	case cbasn1.PrintableString:
+		for _, b := range value {
+			if !isPrintable(b) {
+				return "", errors.New("invalid PrintableString")
+			}
+		}
+		return string(value), nil
+	case cbasn1.UTF8String:
+		if !utf8.Valid(value) {
+			return "", errors.New("invalid UTF-8 string")
+		}
+		return string(value), nil
+	case cbasn1.Tag(asn1.TagBMPString):
+		if len(value)%2 != 0 {
+			return "", errors.New("invalid BMPString")
+		}
+
+		// Strip terminator if present.
+		if l := len(value); l >= 2 && value[l-1] == 0 && value[l-2] == 0 {
+			value = value[:l-2]
+		}
+
+		s := make([]uint16, 0, len(value)/2)
+		for len(value) > 0 {
+			s = append(s, uint16(value[0])<<8+uint16(value[1]))
+			value = value[2:]
+		}
+
+		return string(utf16.Decode(s)), nil
+	case cbasn1.IA5String:
+		s := string(value)
+		if isIA5String(s) != nil {
+			return "", errors.New("invalid IA5String")
+		}
+		return s, nil
+	}
+	return "", fmt.Errorf("unsupported string type: %v", tag)
+}
+
+// parseName parses a DER encoded Name as defined in RFC 5280. We may
+// want to export this function in the future for use in crypto/tls.
+func parseName(raw cryptobyte.String) (*pkix.RDNSequence, error) {
+	if !raw.ReadASN1(&raw, cbasn1.SEQUENCE) {
+		return nil, errors.New("x509: invalid RDNSequence")
+	}
+
+	var rdnSeq pkix.RDNSequence
+	for !raw.Empty() {
+		var rdnSet pkix.RelativeDistinguishedNameSET
+		var set cryptobyte.String
+		if !raw.ReadASN1(&set, cbasn1.SET) {
+			return nil, errors.New("x509: invalid RDNSequence")
+		}
+		for !set.Empty() {
+			var atav cryptobyte.String
+			if !set.ReadASN1(&atav, cbasn1.SEQUENCE) {
+				return nil, errors.New("x509: invalid RDNSequence: invalid attribute")
+			}
+			var attr pkix.AttributeTypeAndValue
+			if !atav.ReadASN1ObjectIdentifier(&attr.Type) {
+				return nil, errors.New("x509: invalid RDNSequence: invalid attribute type")
+			}
+			var rawValue cryptobyte.String
+			var valueTag cbasn1.Tag
+			if !atav.ReadAnyASN1(&rawValue, &valueTag) {
+				return nil, errors.New("x509: invalid RDNSequence: invalid attribute value")
+			}
+			var err error
+			attr.Value, err = parseASN1String(valueTag, rawValue)
+			if err != nil {
+				return nil, fmt.Errorf("x509: invalid RDNSequence: invalid attribute value: %s", err)
+			}
+			rdnSet = append(rdnSet, attr)
+		}
+
+		rdnSeq = append(rdnSeq, rdnSet)
+	}
+
+	return &rdnSeq, nil
+}
+
+func parseAI(der cryptobyte.String) (pkix.AlgorithmIdentifier, error) {
+	ai := pkix.AlgorithmIdentifier{}
+	if !der.ReadASN1ObjectIdentifier(&ai.Algorithm) {
+		return ai, errors.New("x509: malformed OID")
+	}
+	if der.Empty() {
+		return ai, nil
+	}
+	var params cryptobyte.String
+	var tag cbasn1.Tag
+	if !der.ReadAnyASN1Element(&params, &tag) {
+		return ai, errors.New("x509: malformed parameters")
+	}
+	ai.Parameters.Tag = int(tag)
+	ai.Parameters.FullBytes = params
+	return ai, nil
+}
+
+func parseValidity(der cryptobyte.String) (time.Time, time.Time, error) {
+	extract := func() (time.Time, error) {
+		var t time.Time
+		switch {
+		case der.PeekASN1Tag(cbasn1.UTCTime):
+			// TODO(rolandshoemaker): once #45411 is fixed, the following code
+			// should be replaced with a call to der.ReadASN1UTCTime.
+			var utc cryptobyte.String
+			if !der.ReadASN1(&utc, cbasn1.UTCTime) {
+				return t, errors.New("x509: malformed UTCTime")
+			}
+			s := string(utc)
+
+			formatStr := "0601021504Z0700"
+			var err error
+			t, err = time.Parse(formatStr, s)
+			if err != nil {
+				formatStr = "060102150405Z0700"
+				t, err = time.Parse(formatStr, s)
+			}
+			if err != nil {
+				return t, err
+			}
+
+			if serialized := t.Format(formatStr); serialized != s {
+				return t, errors.New("x509: malformed UTCTime")
+			}
+
+			if t.Year() >= 2050 {
+				// UTCTime only encodes times prior to 2050. See https://tools.ietf.org/html/rfc5280#section-4.1.2.5.1
+				t = t.AddDate(-100, 0, 0)
+			}
+		case der.PeekASN1Tag(cbasn1.GeneralizedTime):
+			if !der.ReadASN1GeneralizedTime(&t) {
+				return t, errors.New("x509: malformed GeneralizedTime")
+			}
+		default:
+			return t, errors.New("x509: unsupported time format")
+		}
+		return t, nil
+	}
+
+	notBefore, err := extract()
+	if err != nil {
+		return time.Time{}, time.Time{}, err
+	}
+	notAfter, err := extract()
+	if err != nil {
+		return time.Time{}, time.Time{}, err
+	}
+
+	return notBefore, notAfter, nil
+}
+
+func parseExtension(der cryptobyte.String) (pkix.Extension, error) {
+	var ext pkix.Extension
+	if !der.ReadASN1ObjectIdentifier(&ext.Id) {
+		return ext, errors.New("x509: malformed extention OID field")
+	}
+	if der.PeekASN1Tag(cbasn1.BOOLEAN) {
+		if !der.ReadASN1Boolean(&ext.Critical) {
+			return ext, errors.New("x509: malformed extention critical field")
+		}
+	}
+	var val cryptobyte.String
+	if !der.ReadASN1(&val, cbasn1.OCTET_STRING) {
+		return ext, errors.New("x509: malformed extention value field")
+	}
+	ext.Value = val
+	return ext, nil
+}
+
+func parsePublicKey(algo PublicKeyAlgorithm, keyData *publicKeyInfo) (interface{}, error) {
+	der := cryptobyte.String(keyData.PublicKey.RightAlign())
+	switch algo {
+	case RSA:
+		// RSA public keys must have a NULL in the parameters.
+		// See RFC 3279, Section 2.3.1.
+		if !bytes.Equal(keyData.Algorithm.Parameters.FullBytes, asn1.NullBytes) {
+			return nil, errors.New("x509: RSA key missing NULL parameters")
+		}
+
+		p := &pkcs1PublicKey{N: new(big.Int)}
+		if !der.ReadASN1(&der, cbasn1.SEQUENCE) {
+			return nil, errors.New("x509: invalid RSA public key")
+		}
+		if !der.ReadASN1Integer(p.N) {
+			return nil, errors.New("x509: invalid RSA modulus")
+		}
+		if !der.ReadASN1Integer(&p.E) {
+			return nil, errors.New("x509: invalid RSA public exponent")
+		}
+
+		if p.N.Sign() <= 0 {
+			return nil, errors.New("x509: RSA modulus is not a positive number")
+		}
+		if p.E <= 0 {
+			return nil, errors.New("x509: RSA public exponent is not a positive number")
+		}
+
+		pub := &rsa.PublicKey{
+			E: p.E,
+			N: p.N,
+		}
+		return pub, nil
+	case ECDSA:
+		paramsDer := cryptobyte.String(keyData.Algorithm.Parameters.FullBytes)
+		namedCurveOID := new(asn1.ObjectIdentifier)
+		if !paramsDer.ReadASN1ObjectIdentifier(namedCurveOID) {
+			return nil, errors.New("x509: invalid ECDSA parameters")
+		}
+		namedCurve := namedCurveFromOID(*namedCurveOID)
+		if namedCurve == nil {
+			return nil, errors.New("x509: unsupported elliptic curve")
+		}
+		x, y := elliptic.Unmarshal(namedCurve, der)
+		if x == nil {
+			return nil, errors.New("x509: failed to unmarshal elliptic curve point")
+		}
+		pub := &ecdsa.PublicKey{
+			Curve: namedCurve,
+			X:     x,
+			Y:     y,
+		}
+		return pub, nil
+	case Ed25519:
+		// RFC 8410, Section 3
+		// > For all of the OIDs, the parameters MUST be absent.
+		if len(keyData.Algorithm.Parameters.FullBytes) != 0 {
+			return nil, errors.New("x509: Ed25519 key encoded with illegal parameters")
+		}
+		if len(der) != ed25519.PublicKeySize {
+			return nil, errors.New("x509: wrong Ed25519 public key size")
+		}
+		return ed25519.PublicKey(der), nil
+	case DSA:
+		y := new(big.Int)
+		if !der.ReadASN1Integer(y) {
+			return nil, errors.New("x509: invalid DSA public key")
+		}
+		pub := &dsa.PublicKey{
+			Y: y,
+			Parameters: dsa.Parameters{
+				P: new(big.Int),
+				Q: new(big.Int),
+				G: new(big.Int),
+			},
+		}
+		paramsDer := cryptobyte.String(keyData.Algorithm.Parameters.FullBytes)
+		if !paramsDer.ReadASN1(&paramsDer, cbasn1.SEQUENCE) ||
+			!paramsDer.ReadASN1Integer(pub.Parameters.P) ||
+			!paramsDer.ReadASN1Integer(pub.Parameters.Q) ||
+			!paramsDer.ReadASN1Integer(pub.Parameters.G) {
+			return nil, errors.New("x509: invalid DSA parameters")
+		}
+		if pub.Y.Sign() <= 0 || pub.Parameters.P.Sign() <= 0 ||
+			pub.Parameters.Q.Sign() <= 0 || pub.Parameters.G.Sign() <= 0 {
+			return nil, errors.New("x509: zero or negative DSA parameter")
+		}
+		return pub, nil
+	default:
+		return nil, nil
+	}
+}
+
+func parseKeyUsageExtension(der cryptobyte.String) (KeyUsage, error) {
+	var usageBits asn1.BitString
+	if !der.ReadASN1BitString(&usageBits) {
+		return 0, errors.New("x509: invalid key usage")
+	}
+
+	var usage int
+	for i := 0; i < 9; i++ {
+		if usageBits.At(i) != 0 {
+			usage |= 1 << uint(i)
+		}
+	}
+	return KeyUsage(usage), nil
+}
+
+func parseBasicConstraintsExtension(der cryptobyte.String) (bool, int, error) {
+	var isCA bool
+	if !der.ReadASN1(&der, cbasn1.SEQUENCE) {
+		return false, 0, errors.New("x509: invalid basic constraints a")
+	}
+	if der.PeekASN1Tag(cbasn1.BOOLEAN) {
+		if !der.ReadASN1Boolean(&isCA) {
+			return false, 0, errors.New("x509: invalid basic constraints b")
+		}
+	}
+	maxPathLen := -1
+	if !der.Empty() && der.PeekASN1Tag(cbasn1.INTEGER) {
+		if !der.ReadASN1Integer(&maxPathLen) {
+			return false, 0, errors.New("x509: invalid basic constraints c")
+		}
+	}
+
+	// TODO: map out.MaxPathLen to 0 if it has the -1 default value? (Issue 19285)
+	return isCA, maxPathLen, nil
+}
+
+func forEachSAN(der cryptobyte.String, callback func(tag int, data []byte) error) error {
+	if !der.ReadASN1(&der, cbasn1.SEQUENCE) {
+		return errors.New("x509: invalid subject alternative names")
+	}
+	for !der.Empty() {
+		var san cryptobyte.String
+		var tag cbasn1.Tag
+		if !der.ReadAnyASN1(&san, &tag) {
+			return errors.New("x509: invalid subject alternative name")
+		}
+		if err := callback(int(tag^0x80), san); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func parseSANExtension(der cryptobyte.String) (dnsNames, emailAddresses []string, ipAddresses []net.IP, uris []*url.URL, err error) {
+	err = forEachSAN(der, func(tag int, data []byte) error {
+		switch tag {
+		case nameTypeEmail:
+			email := string(data)
+			if err := isIA5String(email); err != nil {
+				return errors.New("x509: SAN rfc822Name is malformed")
+			}
+			emailAddresses = append(emailAddresses, email)
+		case nameTypeDNS:
+			name := string(data)
+			if err := isIA5String(name); err != nil {
+				return errors.New("x509: SAN dNSName is malformed")
+			}
+			dnsNames = append(dnsNames, string(name))
+		case nameTypeURI:
+			uriStr := string(data)
+			if err := isIA5String(uriStr); err != nil {
+				return errors.New("x509: SAN uniformResourceIdentifier is malformed")
+			}
+			uri, err := url.Parse(uriStr)
+			if err != nil {
+				return fmt.Errorf("x509: cannot parse URI %q: %s", uriStr, err)
+			}
+			if len(uri.Host) > 0 {
+				if _, ok := domainToReverseLabels(uri.Host); !ok {
+					return fmt.Errorf("x509: cannot parse URI %q: invalid domain", uriStr)
+				}
+			}
+			uris = append(uris, uri)
+		case nameTypeIP:
+			switch len(data) {
+			case net.IPv4len, net.IPv6len:
+				ipAddresses = append(ipAddresses, data)
+			default:
+				return errors.New("x509: cannot parse IP address of length " + strconv.Itoa(len(data)))
+			}
+		}
+
+		return nil
+	})
+
+	return
+}
+
+func parseExtKeyUsageExtension(der cryptobyte.String) ([]ExtKeyUsage, []asn1.ObjectIdentifier, error) {
+	var extKeyUsages []ExtKeyUsage
+	var unknownUsages []asn1.ObjectIdentifier
+	if !der.ReadASN1(&der, cbasn1.SEQUENCE) {
+		return nil, nil, errors.New("x509: invalid extended key usages")
+	}
+	for !der.Empty() {
+		var eku asn1.ObjectIdentifier
+		if !der.ReadASN1ObjectIdentifier(&eku) {
+			return nil, nil, errors.New("x509: invalid extended key usages")
+		}
+		if extKeyUsage, ok := extKeyUsageFromOID(eku); ok {
+			extKeyUsages = append(extKeyUsages, extKeyUsage)
+		} else {
+			unknownUsages = append(unknownUsages, eku)
+		}
+	}
+	return extKeyUsages, unknownUsages, nil
+}
+
+func parseCertificatePoliciesExtension(der cryptobyte.String) ([]asn1.ObjectIdentifier, error) {
+	var oids []asn1.ObjectIdentifier
+	if !der.ReadASN1(&der, cbasn1.SEQUENCE) {
+		return nil, errors.New("x509: invalid certificate policies")
+	}
+	for !der.Empty() {
+		var cp cryptobyte.String
+		if !der.ReadASN1(&cp, cbasn1.SEQUENCE) {
+			return nil, errors.New("x509: invalid certificate policies")
+		}
+		var oid asn1.ObjectIdentifier
+		if !cp.ReadASN1ObjectIdentifier(&oid) {
+			return nil, errors.New("x509: invalid certificate policies")
+		}
+		oids = append(oids, oid)
+	}
+
+	return oids, nil
+}
+
+// isValidIPMask reports whether mask consists of zero or more 1 bits, followed by zero bits.
+func isValidIPMask(mask []byte) bool {
+	seenZero := false
+
+	for _, b := range mask {
+		if seenZero {
+			if b != 0 {
+				return false
+			}
+
+			continue
+		}
+
+		switch b {
+		case 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe:
+			seenZero = true
+		case 0xff:
+		default:
+			return false
+		}
+	}
+
+	return true
+}
+
+func parseNameConstraintsExtension(out *Certificate, e pkix.Extension) (unhandled bool, err error) {
+	// RFC 5280, 4.2.1.10
+
+	// NameConstraints ::= SEQUENCE {
+	//      permittedSubtrees       [0]     GeneralSubtrees OPTIONAL,
+	//      excludedSubtrees        [1]     GeneralSubtrees OPTIONAL }
+	//
+	// GeneralSubtrees ::= SEQUENCE SIZE (1..MAX) OF GeneralSubtree
+	//
+	// GeneralSubtree ::= SEQUENCE {
+	//      base                    GeneralName,
+	//      minimum         [0]     BaseDistance DEFAULT 0,
+	//      maximum         [1]     BaseDistance OPTIONAL }
+	//
+	// BaseDistance ::= INTEGER (0..MAX)
+
+	outer := cryptobyte.String(e.Value)
+	var toplevel, permitted, excluded cryptobyte.String
+	var havePermitted, haveExcluded bool
+	if !outer.ReadASN1(&toplevel, cryptobyte_asn1.SEQUENCE) ||
+		!outer.Empty() ||
+		!toplevel.ReadOptionalASN1(&permitted, &havePermitted, cryptobyte_asn1.Tag(0).ContextSpecific().Constructed()) ||
+		!toplevel.ReadOptionalASN1(&excluded, &haveExcluded, cryptobyte_asn1.Tag(1).ContextSpecific().Constructed()) ||
+		!toplevel.Empty() {
+		return false, errors.New("x509: invalid NameConstraints extension")
+	}
+
+	if !havePermitted && !haveExcluded || len(permitted) == 0 && len(excluded) == 0 {
+		// From RFC 5280, Section 4.2.1.10:
+		//   “either the permittedSubtrees field
+		//   or the excludedSubtrees MUST be
+		//   present”
+		return false, errors.New("x509: empty name constraints extension")
+	}
+
+	getValues := func(subtrees cryptobyte.String) (dnsNames []string, ips []*net.IPNet, emails, uriDomains []string, err error) {
+		for !subtrees.Empty() {
+			var seq, value cryptobyte.String
+			var tag cryptobyte_asn1.Tag
+			if !subtrees.ReadASN1(&seq, cryptobyte_asn1.SEQUENCE) ||
+				!seq.ReadAnyASN1(&value, &tag) {
+				return nil, nil, nil, nil, fmt.Errorf("x509: invalid NameConstraints extension")
+			}
+
+			var (
+				dnsTag   = cryptobyte_asn1.Tag(2).ContextSpecific()
+				emailTag = cryptobyte_asn1.Tag(1).ContextSpecific()
+				ipTag    = cryptobyte_asn1.Tag(7).ContextSpecific()
+				uriTag   = cryptobyte_asn1.Tag(6).ContextSpecific()
+			)
+
+			switch tag {
+			case dnsTag:
+				domain := string(value)
+				if err := isIA5String(domain); err != nil {
+					return nil, nil, nil, nil, errors.New("x509: invalid constraint value: " + err.Error())
+				}
+
+				trimmedDomain := domain
+				if len(trimmedDomain) > 0 && trimmedDomain[0] == '.' {
+					// constraints can have a leading
+					// period to exclude the domain
+					// itself, but that's not valid in a
+					// normal domain name.
+					trimmedDomain = trimmedDomain[1:]
+				}
+				if _, ok := domainToReverseLabels(trimmedDomain); !ok {
+					return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse dnsName constraint %q", domain)
+				}
+				dnsNames = append(dnsNames, domain)
+
+			case ipTag:
+				l := len(value)
+				var ip, mask []byte
+
+				switch l {
+				case 8:
+					ip = value[:4]
+					mask = value[4:]
+
+				case 32:
+					ip = value[:16]
+					mask = value[16:]
+
+				default:
+					return nil, nil, nil, nil, fmt.Errorf("x509: IP constraint contained value of length %d", l)
+				}
+
+				if !isValidIPMask(mask) {
+					return nil, nil, nil, nil, fmt.Errorf("x509: IP constraint contained invalid mask %x", mask)
+				}
+
+				ips = append(ips, &net.IPNet{IP: net.IP(ip), Mask: net.IPMask(mask)})
+
+			case emailTag:
+				constraint := string(value)
+				if err := isIA5String(constraint); err != nil {
+					return nil, nil, nil, nil, errors.New("x509: invalid constraint value: " + err.Error())
+				}
+
+				// If the constraint contains an @ then
+				// it specifies an exact mailbox name.
+				if strings.Contains(constraint, "@") {
+					if _, ok := parseRFC2821Mailbox(constraint); !ok {
+						return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse rfc822Name constraint %q", constraint)
+					}
+				} else {
+					// Otherwise it's a domain name.
+					domain := constraint
+					if len(domain) > 0 && domain[0] == '.' {
+						domain = domain[1:]
+					}
+					if _, ok := domainToReverseLabels(domain); !ok {
+						return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse rfc822Name constraint %q", constraint)
+					}
+				}
+				emails = append(emails, constraint)
+
+			case uriTag:
+				domain := string(value)
+				if err := isIA5String(domain); err != nil {
+					return nil, nil, nil, nil, errors.New("x509: invalid constraint value: " + err.Error())
+				}
+
+				if net.ParseIP(domain) != nil {
+					return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse URI constraint %q: cannot be IP address", domain)
+				}
+
+				trimmedDomain := domain
+				if len(trimmedDomain) > 0 && trimmedDomain[0] == '.' {
+					// constraints can have a leading
+					// period to exclude the domain itself,
+					// but that's not valid in a normal
+					// domain name.
+					trimmedDomain = trimmedDomain[1:]
+				}
+				if _, ok := domainToReverseLabels(trimmedDomain); !ok {
+					return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse URI constraint %q", domain)
+				}
+				uriDomains = append(uriDomains, domain)
+
+			default:
+				unhandled = true
+			}
+		}
+
+		return dnsNames, ips, emails, uriDomains, nil
+	}
+
+	if out.PermittedDNSDomains, out.PermittedIPRanges, out.PermittedEmailAddresses, out.PermittedURIDomains, err = getValues(permitted); err != nil {
+		return false, err
+	}
+	if out.ExcludedDNSDomains, out.ExcludedIPRanges, out.ExcludedEmailAddresses, out.ExcludedURIDomains, err = getValues(excluded); err != nil {
+		return false, err
+	}
+	out.PermittedDNSDomainsCritical = e.Critical
+
+	return unhandled, nil
+}
+
+func processExtensions(out *Certificate) error {
+	var err error
+	for _, e := range out.Extensions {
+		unhandled := false
+
+		if len(e.Id) == 4 && e.Id[0] == 2 && e.Id[1] == 5 && e.Id[2] == 29 {
+			switch e.Id[3] {
+			case 15:
+				out.KeyUsage, err = parseKeyUsageExtension(e.Value)
+				if err != nil {
+					return err
+				}
+			case 19:
+				out.IsCA, out.MaxPathLen, err = parseBasicConstraintsExtension(e.Value)
+				if err != nil {
+					return err
+				}
+				out.BasicConstraintsValid = true
+				out.MaxPathLenZero = out.MaxPathLen == 0
+			case 17:
+				out.DNSNames, out.EmailAddresses, out.IPAddresses, out.URIs, err = parseSANExtension(e.Value)
+				if err != nil {
+					return err
+				}
+
+				if len(out.DNSNames) == 0 && len(out.EmailAddresses) == 0 && len(out.IPAddresses) == 0 && len(out.URIs) == 0 {
+					// If we didn't parse anything then we do the critical check, below.
+					unhandled = true
+				}
+
+			case 30:
+				unhandled, err = parseNameConstraintsExtension(out, e)
+				if err != nil {
+					return err
+				}
+
+			case 31:
+				// RFC 5280, 4.2.1.13
+
+				// CRLDistributionPoints ::= SEQUENCE SIZE (1..MAX) OF DistributionPoint
+				//
+				// DistributionPoint ::= SEQUENCE {
+				//     distributionPoint       [0]     DistributionPointName OPTIONAL,
+				//     reasons                 [1]     ReasonFlags OPTIONAL,
+				//     cRLIssuer               [2]     GeneralNames OPTIONAL }
+				//
+				// DistributionPointName ::= CHOICE {
+				//     fullName                [0]     GeneralNames,
+				//     nameRelativeToCRLIssuer [1]     RelativeDistinguishedName }
+				val := cryptobyte.String(e.Value)
+				if !val.ReadASN1(&val, cbasn1.SEQUENCE) {
+					return errors.New("x509: invalid CRL distribution points")
+				}
+				for !val.Empty() {
+					var dpDER cryptobyte.String
+					if !val.ReadASN1(&dpDER, cbasn1.SEQUENCE) {
+						return errors.New("x509: invalid CRL distribution point")
+					}
+					var dpNameDER cryptobyte.String
+					var dpNamePresent bool
+					if !dpDER.ReadOptionalASN1(&dpNameDER, &dpNamePresent, cbasn1.Tag(0).Constructed().ContextSpecific()) {
+						return errors.New("x509: invalid CRL distribution point")
+					}
+					if !dpNamePresent {
+						continue
+					}
+					if !dpNameDER.ReadASN1(&dpNameDER, cbasn1.Tag(0).Constructed().ContextSpecific()) {
+						return errors.New("x509: invalid CRL distribution point")
+					}
+					for !dpNameDER.Empty() {
+						if !dpNameDER.PeekASN1Tag(cbasn1.Tag(6).ContextSpecific()) {
+							break
+						}
+						var uri cryptobyte.String
+						if !dpNameDER.ReadASN1(&uri, cbasn1.Tag(6).ContextSpecific()) {
+							return errors.New("x509: invalid CRL distribution point")
+						}
+						out.CRLDistributionPoints = append(out.CRLDistributionPoints, string(uri))
+					}
+				}
+
+			case 35:
+				// RFC 5280, 4.2.1.1
+				val := cryptobyte.String(e.Value)
+				var akid cryptobyte.String
+				if !val.ReadASN1(&akid, cbasn1.SEQUENCE) {
+					return errors.New("x509: invalid authority key identifier")
+				}
+				if !akid.ReadASN1(&akid, cbasn1.Tag(0).ContextSpecific()) {
+					return errors.New("x509: invalid authority key identifier")
+				}
+				out.AuthorityKeyId = akid
+			case 37:
+				out.ExtKeyUsage, out.UnknownExtKeyUsage, err = parseExtKeyUsageExtension(e.Value)
+				if err != nil {
+					return err
+				}
+			case 14:
+				// RFC 5280, 4.2.1.2
+				val := cryptobyte.String(e.Value)
+				var skid cryptobyte.String
+				if !val.ReadASN1(&skid, cbasn1.OCTET_STRING) {
+					return errors.New("x509: invalid subject key identifier")
+				}
+				out.SubjectKeyId = skid
+			case 32:
+				out.PolicyIdentifiers, err = parseCertificatePoliciesExtension(e.Value)
+				if err != nil {
+					return err
+				}
+			default:
+				// Unknown extensions are recorded if critical.
+				unhandled = true
+			}
+		} else if e.Id.Equal(oidExtensionAuthorityInfoAccess) {
+			// RFC 5280 4.2.2.1: Authority Information Access
+			val := cryptobyte.String(e.Value)
+			if !val.ReadASN1(&val, cbasn1.SEQUENCE) {
+				return errors.New("x509: invalid authority info access")
+			}
+			for !val.Empty() {
+				var aiaDER cryptobyte.String
+				if !val.ReadASN1(&aiaDER, cbasn1.SEQUENCE) {
+					return errors.New("x509: invalid authority info access")
+				}
+				var method asn1.ObjectIdentifier
+				if !aiaDER.ReadASN1ObjectIdentifier(&method) {
+					return errors.New("x509: invalid authority info access")
+				}
+				if !aiaDER.PeekASN1Tag(cbasn1.Tag(6).ContextSpecific()) {
+					continue
+				}
+				if !aiaDER.ReadASN1(&aiaDER, cbasn1.Tag(6).ContextSpecific()) {
+					return errors.New("x509: invalid authority info access")
+				}
+				switch {
+				case method.Equal(oidAuthorityInfoAccessOcsp):
+					out.OCSPServer = append(out.OCSPServer, string(aiaDER))
+				case method.Equal(oidAuthorityInfoAccessIssuers):
+					out.IssuingCertificateURL = append(out.IssuingCertificateURL, string(aiaDER))
+				}
+			}
+		} else {
+			// Unknown extensions are recorded if critical.
+			unhandled = true
+		}
+
+		if e.Critical && unhandled {
+			out.UnhandledCriticalExtensions = append(out.UnhandledCriticalExtensions, e.Id)
+		}
+	}
+
+	return nil
+}
+
+func parseCertificate(der []byte) (*Certificate, error) {
+	cert := &Certificate{}
+
+	input := cryptobyte.String(der)
+	// we read the SEQUENCE including length and tag bytes so that
+	// we can populate Certificate.Raw, before unwrapping the
+	// SEQUENCE so it can be operated on
+	if !input.ReadASN1Element(&input, cbasn1.SEQUENCE) {
+		return nil, errors.New("x509: malformed certificate")
+	}
+	cert.Raw = input
+	if !input.ReadASN1(&input, cbasn1.SEQUENCE) {
+		return nil, errors.New("x509: malformed certificate")
+	}
+
+	var tbs cryptobyte.String
+	// do the same trick again as above to extract the raw
+	// bytes for Certificate.RawTBSCertificate
+	if !input.ReadASN1Element(&tbs, cbasn1.SEQUENCE) {
+		return nil, errors.New("x509: malformed tbs certificate")
+	}
+	cert.RawTBSCertificate = tbs
+	if !tbs.ReadASN1(&tbs, cbasn1.SEQUENCE) {
+		return nil, errors.New("x509: malformed tbs certificate")
+	}
+
+	if !tbs.ReadOptionalASN1Integer(&cert.Version, cbasn1.Tag(0).Constructed().ContextSpecific(), 0) {
+		return nil, errors.New("x509: malformed version")
+	}
+	if cert.Version < 0 {
+		return nil, errors.New("x509: malformed version")
+	}
+	// for backwards compat reasons Version is one-indexed,
+	// rather than zero-indexed as defined in 5280
+	cert.Version++
+	if cert.Version > 3 {
+		return nil, errors.New("x509: invalid version")
+	}
+
+	serial := new(big.Int)
+	if !tbs.ReadASN1Integer(serial) {
+		return nil, errors.New("x509: malformed serial number")
+	}
+	// we ignore the presence of negative serial numbers because
+	// of their prevalence, despite them being invalid
+	// TODO(rolandshoemaker): revist this decision, there are currently
+	// only 10 trusted certificates with negative serial numbers
+	// according to censys.io.
+	cert.SerialNumber = serial
+
+	var sigAISeq cryptobyte.String
+	if !tbs.ReadASN1(&sigAISeq, cbasn1.SEQUENCE) {
+		return nil, errors.New("x509: malformed signature algorithm identifier")
+	}
+	// Before parsing the inner algorithm identifier, extract
+	// the outer algorithm identifier and make sure that they
+	// match.
+	var outerSigAISeq cryptobyte.String
+	if !input.ReadASN1(&outerSigAISeq, cbasn1.SEQUENCE) {
+		return nil, errors.New("x509: malformed algorithm identifier")
+	}
+	if !bytes.Equal(outerSigAISeq, sigAISeq) {
+		return nil, errors.New("x509: inner and outer signature algorithm identifiers don't match")
+	}
+	sigAI, err := parseAI(sigAISeq)
+	if err != nil {
+		return nil, err
+	}
+	cert.SignatureAlgorithm = getSignatureAlgorithmFromAI(sigAI)
+
+	var issuerSeq cryptobyte.String
+	if !tbs.ReadASN1Element(&issuerSeq, cbasn1.SEQUENCE) {
+		return nil, errors.New("x509: malformed issuer")
+	}
+	cert.RawIssuer = issuerSeq
+	issuerRDNs, err := parseName(issuerSeq)
+	if err != nil {
+		return nil, err
+	}
+	cert.Issuer.FillFromRDNSequence(issuerRDNs)
+
+	var validity cryptobyte.String
+	if !tbs.ReadASN1(&validity, cbasn1.SEQUENCE) {
+		return nil, errors.New("x509: malformed validity")
+	}
+	cert.NotBefore, cert.NotAfter, err = parseValidity(validity)
+	if err != nil {
+		return nil, err
+	}
+
+	var subjectSeq cryptobyte.String
+	if !tbs.ReadASN1Element(&subjectSeq, cbasn1.SEQUENCE) {
+		return nil, errors.New("x509: malformed issuer")
+	}
+	cert.RawSubject = subjectSeq
+	subjectRDNs, err := parseName(subjectSeq)
+	if err != nil {
+		return nil, err
+	}
+	cert.Subject.FillFromRDNSequence(subjectRDNs)
+
+	var spki cryptobyte.String
+	if !tbs.ReadASN1Element(&spki, cbasn1.SEQUENCE) {
+		return nil, errors.New("x509: malformed spki")
+	}
+	cert.RawSubjectPublicKeyInfo = spki
+	if !spki.ReadASN1(&spki, cbasn1.SEQUENCE) {
+		return nil, errors.New("x509: malformed spki")
+	}
+	var pkAISeq cryptobyte.String
+	if !spki.ReadASN1(&pkAISeq, cbasn1.SEQUENCE) {
+		return nil, errors.New("x509: malformed public key algorithm identifier")
+	}
+	pkAI, err := parseAI(pkAISeq)
+	if err != nil {
+		return nil, err
+	}
+	cert.PublicKeyAlgorithm = getPublicKeyAlgorithmFromOID(pkAI.Algorithm)
+	var spk asn1.BitString
+	if !spki.ReadASN1BitString(&spk) {
+		return nil, errors.New("x509: malformed subjectPublicKey")
+	}
+	cert.PublicKey, err = parsePublicKey(cert.PublicKeyAlgorithm, &publicKeyInfo{
+		Algorithm: pkAI,
+		PublicKey: spk,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	if cert.Version > 1 {
+		if !tbs.SkipOptionalASN1(cbasn1.Tag(1).Constructed().ContextSpecific()) {
+			return nil, errors.New("x509: malformed issuerUniqueID")
+		}
+		if !tbs.SkipOptionalASN1(cbasn1.Tag(2).Constructed().ContextSpecific()) {
+			return nil, errors.New("x509: malformed subjectUniqueID")
+		}
+		if cert.Version == 3 {
+			var extensions cryptobyte.String
+			var present bool
+			if !tbs.ReadOptionalASN1(&extensions, &present, cbasn1.Tag(3).Constructed().ContextSpecific()) {
+				return nil, errors.New("x509: malformed extensions")
+			}
+			if present {
+				if !extensions.ReadASN1(&extensions, cbasn1.SEQUENCE) {
+					return nil, errors.New("x509: malformed extensions")
+				}
+				for !extensions.Empty() {
+					var extension cryptobyte.String
+					if !extensions.ReadASN1(&extension, cbasn1.SEQUENCE) {
+						return nil, errors.New("x509: malformed extension")
+					}
+					ext, err := parseExtension(extension)
+					if err != nil {
+						return nil, err
+					}
+					cert.Extensions = append(cert.Extensions, ext)
+				}
+				err = processExtensions(cert)
+				if err != nil {
+					return nil, err
+				}
+			}
+		}
+	}
+
+	var signature asn1.BitString
+	if !input.ReadASN1BitString(&signature) {
+		return nil, errors.New("x509: malformed signature")
+	}
+	cert.Signature = signature.RightAlign()
+
+	return cert, nil
+}
+
+// ParseCertificate parses a single certificate from the given ASN.1 DER data.
+func ParseCertificate(der []byte) (*Certificate, error) {
+	cert, err := parseCertificate(der)
+	if err != nil {
+		return nil, err
+	}
+	if len(der) != len(cert.Raw) {
+		return nil, errors.New("x509: trailing data")
+	}
+	return cert, err
+}
+
+// ParseCertificates parses one or more certificates from the given ASN.1 DER
+// data. The certificates must be concatenated with no intermediate padding.
+func ParseCertificates(der []byte) ([]*Certificate, error) {
+	var certs []*Certificate
+	for len(der) > 0 {
+		cert, err := parseCertificate(der)
+		if err != nil {
+			return nil, err
+		}
+		certs = append(certs, cert)
+		der = der[len(cert.Raw):]
+	}
+	return certs, nil
+}
diff --git a/src/crypto/x509/x509.go b/src/crypto/x509/x509.go
index 8c0299b11e..ff37b361d7 100644
--- a/src/crypto/x509/x509.go
+++ b/src/crypto/x509/x509.go
@@ -8,7 +8,6 @@ package x509
 import (
 	"bytes"
 	"crypto"
-	"crypto/dsa"
 	"crypto/ecdsa"
 	"crypto/ed25519"
 	"crypto/elliptic"
@@ -24,7 +23,6 @@ import (
 	"net"
 	"net/url"
 	"strconv"
-	"strings"
 	"time"
 	"unicode"
 
@@ -914,676 +912,6 @@ type distributionPointName struct {
 	RelativeName pkix.RDNSequence `asn1:"optional,tag:1"`
 }
 
-func parsePublicKey(algo PublicKeyAlgorithm, keyData *publicKeyInfo) (interface{}, error) {
-	asn1Data := keyData.PublicKey.RightAlign()
-	switch algo {
-	case RSA:
-		// RSA public keys must have a NULL in the parameters.
-		// See RFC 3279, Section 2.3.1.
-		if !bytes.Equal(keyData.Algorithm.Parameters.FullBytes, asn1.NullBytes) {
-			return nil, errors.New("x509: RSA key missing NULL parameters")
-		}
-
-		p := new(pkcs1PublicKey)
-		rest, err := asn1.Unmarshal(asn1Data, p)
-		if err != nil {
-			return nil, err
-		}
-		if len(rest) != 0 {
-			return nil, errors.New("x509: trailing data after RSA public key")
-		}
-
-		if p.N.Sign() <= 0 {
-			return nil, errors.New("x509: RSA modulus is not a positive number")
-		}
-		if p.E <= 0 {
-			return nil, errors.New("x509: RSA public exponent is not a positive number")
-		}
-
-		pub := &rsa.PublicKey{
-			E: p.E,
-			N: p.N,
-		}
-		return pub, nil
-	case DSA:
-		var p *big.Int
-		rest, err := asn1.Unmarshal(asn1Data, &p)
-		if err != nil {
-			return nil, err
-		}
-		if len(rest) != 0 {
-			return nil, errors.New("x509: trailing data after DSA public key")
-		}
-		paramsData := keyData.Algorithm.Parameters.FullBytes
-		params := new(dsaAlgorithmParameters)
-		rest, err = asn1.Unmarshal(paramsData, params)
-		if err != nil {
-			return nil, err
-		}
-		if len(rest) != 0 {
-			return nil, errors.New("x509: trailing data after DSA parameters")
-		}
-		if p.Sign() <= 0 || params.P.Sign() <= 0 || params.Q.Sign() <= 0 || params.G.Sign() <= 0 {
-			return nil, errors.New("x509: zero or negative DSA parameter")
-		}
-		pub := &dsa.PublicKey{
-			Parameters: dsa.Parameters{
-				P: params.P,
-				Q: params.Q,
-				G: params.G,
-			},
-			Y: p,
-		}
-		return pub, nil
-	case ECDSA:
-		paramsData := keyData.Algorithm.Parameters.FullBytes
-		namedCurveOID := new(asn1.ObjectIdentifier)
-		rest, err := asn1.Unmarshal(paramsData, namedCurveOID)
-		if err != nil {
-			return nil, errors.New("x509: failed to parse ECDSA parameters as named curve")
-		}
-		if len(rest) != 0 {
-			return nil, errors.New("x509: trailing data after ECDSA parameters")
-		}
-		namedCurve := namedCurveFromOID(*namedCurveOID)
-		if namedCurve == nil {
-			return nil, errors.New("x509: unsupported elliptic curve")
-		}
-		x, y := elliptic.Unmarshal(namedCurve, asn1Data)
-		if x == nil {
-			return nil, errors.New("x509: failed to unmarshal elliptic curve point")
-		}
-		pub := &ecdsa.PublicKey{
-			Curve: namedCurve,
-			X:     x,
-			Y:     y,
-		}
-		return pub, nil
-	case Ed25519:
-		// RFC 8410, Section 3
-		// > For all of the OIDs, the parameters MUST be absent.
-		if len(keyData.Algorithm.Parameters.FullBytes) != 0 {
-			return nil, errors.New("x509: Ed25519 key encoded with illegal parameters")
-		}
-		if len(asn1Data) != ed25519.PublicKeySize {
-			return nil, errors.New("x509: wrong Ed25519 public key size")
-		}
-		pub := make([]byte, ed25519.PublicKeySize)
-		copy(pub, asn1Data)
-		return ed25519.PublicKey(pub), nil
-	default:
-		return nil, nil
-	}
-}
-
-func forEachSAN(extension []byte, callback func(tag int, data []byte) error) error {
-	// RFC 5280, 4.2.1.6
-
-	// SubjectAltName ::= GeneralNames
-	//
-	// GeneralNames ::= SEQUENCE SIZE (1..MAX) OF GeneralName
-	//
-	// GeneralName ::= CHOICE {
-	//      otherName                       [0]     OtherName,
-	//      rfc822Name                      [1]     IA5String,
-	//      dNSName                         [2]     IA5String,
-	//      x400Address                     [3]     ORAddress,
-	//      directoryName                   [4]     Name,
-	//      ediPartyName                    [5]     EDIPartyName,
-	//      uniformResourceIdentifier       [6]     IA5String,
-	//      iPAddress                       [7]     OCTET STRING,
-	//      registeredID                    [8]     OBJECT IDENTIFIER }
-	var seq asn1.RawValue
-	rest, err := asn1.Unmarshal(extension, &seq)
-	if err != nil {
-		return err
-	} else if len(rest) != 0 {
-		return errors.New("x509: trailing data after X.509 extension")
-	}
-	if !seq.IsCompound || seq.Tag != 16 || seq.Class != 0 {
-		return asn1.StructuralError{Msg: "bad SAN sequence"}
-	}
-
-	rest = seq.Bytes
-	for len(rest) > 0 {
-		var v asn1.RawValue
-		rest, err = asn1.Unmarshal(rest, &v)
-		if err != nil {
-			return err
-		}
-
-		if err := callback(v.Tag, v.Bytes); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func parseSANExtension(value []byte) (dnsNames, emailAddresses []string, ipAddresses []net.IP, uris []*url.URL, err error) {
-	err = forEachSAN(value, func(tag int, data []byte) error {
-		switch tag {
-		case nameTypeEmail:
-			email := string(data)
-			if err := isIA5String(email); err != nil {
-				return errors.New("x509: SAN rfc822Name is malformed")
-			}
-			emailAddresses = append(emailAddresses, email)
-		case nameTypeDNS:
-			name := string(data)
-			if err := isIA5String(name); err != nil {
-				return errors.New("x509: SAN dNSName is malformed")
-			}
-			dnsNames = append(dnsNames, string(name))
-		case nameTypeURI:
-			uriStr := string(data)
-			if err := isIA5String(uriStr); err != nil {
-				return errors.New("x509: SAN uniformResourceIdentifier is malformed")
-			}
-			uri, err := url.Parse(uriStr)
-			if err != nil {
-				return fmt.Errorf("x509: cannot parse URI %q: %s", uriStr, err)
-			}
-			if len(uri.Host) > 0 {
-				if _, ok := domainToReverseLabels(uri.Host); !ok {
-					return fmt.Errorf("x509: cannot parse URI %q: invalid domain", uriStr)
-				}
-			}
-			uris = append(uris, uri)
-		case nameTypeIP:
-			switch len(data) {
-			case net.IPv4len, net.IPv6len:
-				ipAddresses = append(ipAddresses, data)
-			default:
-				return errors.New("x509: cannot parse IP address of length " + strconv.Itoa(len(data)))
-			}
-		}
-
-		return nil
-	})
-
-	return
-}
-
-// isValidIPMask reports whether mask consists of zero or more 1 bits, followed by zero bits.
-func isValidIPMask(mask []byte) bool {
-	seenZero := false
-
-	for _, b := range mask {
-		if seenZero {
-			if b != 0 {
-				return false
-			}
-
-			continue
-		}
-
-		switch b {
-		case 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe:
-			seenZero = true
-		case 0xff:
-		default:
-			return false
-		}
-	}
-
-	return true
-}
-
-func parseNameConstraintsExtension(out *Certificate, e pkix.Extension) (unhandled bool, err error) {
-	// RFC 5280, 4.2.1.10
-
-	// NameConstraints ::= SEQUENCE {
-	//      permittedSubtrees       [0]     GeneralSubtrees OPTIONAL,
-	//      excludedSubtrees        [1]     GeneralSubtrees OPTIONAL }
-	//
-	// GeneralSubtrees ::= SEQUENCE SIZE (1..MAX) OF GeneralSubtree
-	//
-	// GeneralSubtree ::= SEQUENCE {
-	//      base                    GeneralName,
-	//      minimum         [0]     BaseDistance DEFAULT 0,
-	//      maximum         [1]     BaseDistance OPTIONAL }
-	//
-	// BaseDistance ::= INTEGER (0..MAX)
-
-	outer := cryptobyte.String(e.Value)
-	var toplevel, permitted, excluded cryptobyte.String
-	var havePermitted, haveExcluded bool
-	if !outer.ReadASN1(&toplevel, cryptobyte_asn1.SEQUENCE) ||
-		!outer.Empty() ||
-		!toplevel.ReadOptionalASN1(&permitted, &havePermitted, cryptobyte_asn1.Tag(0).ContextSpecific().Constructed()) ||
-		!toplevel.ReadOptionalASN1(&excluded, &haveExcluded, cryptobyte_asn1.Tag(1).ContextSpecific().Constructed()) ||
-		!toplevel.Empty() {
-		return false, errors.New("x509: invalid NameConstraints extension")
-	}
-
-	if !havePermitted && !haveExcluded || len(permitted) == 0 && len(excluded) == 0 {
-		// From RFC 5280, Section 4.2.1.10:
-		//   “either the permittedSubtrees field
-		//   or the excludedSubtrees MUST be
-		//   present”
-		return false, errors.New("x509: empty name constraints extension")
-	}
-
-	getValues := func(subtrees cryptobyte.String) (dnsNames []string, ips []*net.IPNet, emails, uriDomains []string, err error) {
-		for !subtrees.Empty() {
-			var seq, value cryptobyte.String
-			var tag cryptobyte_asn1.Tag
-			if !subtrees.ReadASN1(&seq, cryptobyte_asn1.SEQUENCE) ||
-				!seq.ReadAnyASN1(&value, &tag) {
-				return nil, nil, nil, nil, fmt.Errorf("x509: invalid NameConstraints extension")
-			}
-
-			var (
-				dnsTag   = cryptobyte_asn1.Tag(2).ContextSpecific()
-				emailTag = cryptobyte_asn1.Tag(1).ContextSpecific()
-				ipTag    = cryptobyte_asn1.Tag(7).ContextSpecific()
-				uriTag   = cryptobyte_asn1.Tag(6).ContextSpecific()
-			)
-
-			switch tag {
-			case dnsTag:
-				domain := string(value)
-				if err := isIA5String(domain); err != nil {
-					return nil, nil, nil, nil, errors.New("x509: invalid constraint value: " + err.Error())
-				}
-
-				trimmedDomain := domain
-				if len(trimmedDomain) > 0 && trimmedDomain[0] == '.' {
-					// constraints can have a leading
-					// period to exclude the domain
-					// itself, but that's not valid in a
-					// normal domain name.
-					trimmedDomain = trimmedDomain[1:]
-				}
-				if _, ok := domainToReverseLabels(trimmedDomain); !ok {
-					return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse dnsName constraint %q", domain)
-				}
-				dnsNames = append(dnsNames, domain)
-
-			case ipTag:
-				l := len(value)
-				var ip, mask []byte
-
-				switch l {
-				case 8:
-					ip = value[:4]
-					mask = value[4:]
-
-				case 32:
-					ip = value[:16]
-					mask = value[16:]
-
-				default:
-					return nil, nil, nil, nil, fmt.Errorf("x509: IP constraint contained value of length %d", l)
-				}
-
-				if !isValidIPMask(mask) {
-					return nil, nil, nil, nil, fmt.Errorf("x509: IP constraint contained invalid mask %x", mask)
-				}
-
-				ips = append(ips, &net.IPNet{IP: net.IP(ip), Mask: net.IPMask(mask)})
-
-			case emailTag:
-				constraint := string(value)
-				if err := isIA5String(constraint); err != nil {
-					return nil, nil, nil, nil, errors.New("x509: invalid constraint value: " + err.Error())
-				}
-
-				// If the constraint contains an @ then
-				// it specifies an exact mailbox name.
-				if strings.Contains(constraint, "@") {
-					if _, ok := parseRFC2821Mailbox(constraint); !ok {
-						return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse rfc822Name constraint %q", constraint)
-					}
-				} else {
-					// Otherwise it's a domain name.
-					domain := constraint
-					if len(domain) > 0 && domain[0] == '.' {
-						domain = domain[1:]
-					}
-					if _, ok := domainToReverseLabels(domain); !ok {
-						return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse rfc822Name constraint %q", constraint)
-					}
-				}
-				emails = append(emails, constraint)
-
-			case uriTag:
-				domain := string(value)
-				if err := isIA5String(domain); err != nil {
-					return nil, nil, nil, nil, errors.New("x509: invalid constraint value: " + err.Error())
-				}
-
-				if net.ParseIP(domain) != nil {
-					return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse URI constraint %q: cannot be IP address", domain)
-				}
-
-				trimmedDomain := domain
-				if len(trimmedDomain) > 0 && trimmedDomain[0] == '.' {
-					// constraints can have a leading
-					// period to exclude the domain itself,
-					// but that's not valid in a normal
-					// domain name.
-					trimmedDomain = trimmedDomain[1:]
-				}
-				if _, ok := domainToReverseLabels(trimmedDomain); !ok {
-					return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse URI constraint %q", domain)
-				}
-				uriDomains = append(uriDomains, domain)
-
-			default:
-				unhandled = true
-			}
-		}
-
-		return dnsNames, ips, emails, uriDomains, nil
-	}
-
-	if out.PermittedDNSDomains, out.PermittedIPRanges, out.PermittedEmailAddresses, out.PermittedURIDomains, err = getValues(permitted); err != nil {
-		return false, err
-	}
-	if out.ExcludedDNSDomains, out.ExcludedIPRanges, out.ExcludedEmailAddresses, out.ExcludedURIDomains, err = getValues(excluded); err != nil {
-		return false, err
-	}
-	out.PermittedDNSDomainsCritical = e.Critical
-
-	return unhandled, nil
-}
-
-func parseCertificate(in *certificate) (*Certificate, error) {
-	out := new(Certificate)
-	out.Raw = in.Raw
-	out.RawTBSCertificate = in.TBSCertificate.Raw
-	out.RawSubjectPublicKeyInfo = in.TBSCertificate.PublicKey.Raw
-	out.RawSubject = in.TBSCertificate.Subject.FullBytes
-	out.RawIssuer = in.TBSCertificate.Issuer.FullBytes
-
-	out.Signature = in.SignatureValue.RightAlign()
-	out.SignatureAlgorithm =
-		getSignatureAlgorithmFromAI(in.TBSCertificate.SignatureAlgorithm)
-
-	out.PublicKeyAlgorithm =
-		getPublicKeyAlgorithmFromOID(in.TBSCertificate.PublicKey.Algorithm.Algorithm)
-	var err error
-	out.PublicKey, err = parsePublicKey(out.PublicKeyAlgorithm, &in.TBSCertificate.PublicKey)
-	if err != nil {
-		return nil, err
-	}
-
-	out.Version = in.TBSCertificate.Version + 1
-	out.SerialNumber = in.TBSCertificate.SerialNumber
-
-	var issuer, subject pkix.RDNSequence
-	if rest, err := asn1.Unmarshal(in.TBSCertificate.Subject.FullBytes, &subject); err != nil {
-		return nil, err
-	} else if len(rest) != 0 {
-		return nil, errors.New("x509: trailing data after X.509 subject")
-	}
-	if rest, err := asn1.Unmarshal(in.TBSCertificate.Issuer.FullBytes, &issuer); err != nil {
-		return nil, err
-	} else if len(rest) != 0 {
-		return nil, errors.New("x509: trailing data after X.509 issuer")
-	}
-
-	out.Issuer.FillFromRDNSequence(&issuer)
-	out.Subject.FillFromRDNSequence(&subject)
-
-	out.NotBefore = in.TBSCertificate.Validity.NotBefore
-	out.NotAfter = in.TBSCertificate.Validity.NotAfter
-
-	for _, e := range in.TBSCertificate.Extensions {
-		out.Extensions = append(out.Extensions, e)
-		unhandled := false
-
-		if len(e.Id) == 4 && e.Id[0] == 2 && e.Id[1] == 5 && e.Id[2] == 29 {
-			switch e.Id[3] {
-			case 15:
-				out.KeyUsage, err = parseKeyUsageExtension(e.Value)
-				if err != nil {
-					return nil, err
-				}
-			case 19:
-				out.IsCA, out.MaxPathLen, err = parseBasicConstraintsExtension(e.Value)
-				if err != nil {
-					return nil, err
-				}
-				out.BasicConstraintsValid = true
-				out.MaxPathLenZero = out.MaxPathLen == 0
-			case 17:
-				out.DNSNames, out.EmailAddresses, out.IPAddresses, out.URIs, err = parseSANExtension(e.Value)
-				if err != nil {
-					return nil, err
-				}
-
-				if len(out.DNSNames) == 0 && len(out.EmailAddresses) == 0 && len(out.IPAddresses) == 0 && len(out.URIs) == 0 {
-					// If we didn't parse anything then we do the critical check, below.
-					unhandled = true
-				}
-
-			case 30:
-				unhandled, err = parseNameConstraintsExtension(out, e)
-				if err != nil {
-					return nil, err
-				}
-
-			case 31:
-				// RFC 5280, 4.2.1.13
-
-				// CRLDistributionPoints ::= SEQUENCE SIZE (1..MAX) OF DistributionPoint
-				//
-				// DistributionPoint ::= SEQUENCE {
-				//     distributionPoint       [0]     DistributionPointName OPTIONAL,
-				//     reasons                 [1]     ReasonFlags OPTIONAL,
-				//     cRLIssuer               [2]     GeneralNames OPTIONAL }
-				//
-				// DistributionPointName ::= CHOICE {
-				//     fullName                [0]     GeneralNames,
-				//     nameRelativeToCRLIssuer [1]     RelativeDistinguishedName }
-
-				var cdp []distributionPoint
-				if rest, err := asn1.Unmarshal(e.Value, &cdp); err != nil {
-					return nil, err
-				} else if len(rest) != 0 {
-					return nil, errors.New("x509: trailing data after X.509 CRL distribution point")
-				}
-
-				for _, dp := range cdp {
-					// Per RFC 5280, 4.2.1.13, one of distributionPoint or cRLIssuer may be empty.
-					if len(dp.DistributionPoint.FullName) == 0 {
-						continue
-					}
-
-					for _, fullName := range dp.DistributionPoint.FullName {
-						if fullName.Tag == 6 {
-							out.CRLDistributionPoints = append(out.CRLDistributionPoints, string(fullName.Bytes))
-						}
-					}
-				}
-
-			case 35:
-				// RFC 5280, 4.2.1.1
-				var a authKeyId
-				if rest, err := asn1.Unmarshal(e.Value, &a); err != nil {
-					return nil, err
-				} else if len(rest) != 0 {
-					return nil, errors.New("x509: trailing data after X.509 authority key-id")
-				}
-				out.AuthorityKeyId = a.Id
-
-			case 37:
-				out.ExtKeyUsage, out.UnknownExtKeyUsage, err = parseExtKeyUsageExtension(e.Value)
-				if err != nil {
-					return nil, err
-				}
-			case 14:
-				out.SubjectKeyId, err = parseSubjectKeyIdExtension(e.Value)
-				if err != nil {
-					return nil, err
-				}
-			case 32:
-				out.PolicyIdentifiers, err = parseCertificatePoliciesExtension(e.Value)
-				if err != nil {
-					return nil, err
-				}
-			default:
-				// Unknown extensions are recorded if critical.
-				unhandled = true
-			}
-		} else if e.Id.Equal(oidExtensionAuthorityInfoAccess) {
-			// RFC 5280 4.2.2.1: Authority Information Access
-			var aia []authorityInfoAccess
-			if rest, err := asn1.Unmarshal(e.Value, &aia); err != nil {
-				return nil, err
-			} else if len(rest) != 0 {
-				return nil, errors.New("x509: trailing data after X.509 authority information")
-			}
-
-			for _, v := range aia {
-				// GeneralName: uniformResourceIdentifier [6] IA5String
-				if v.Location.Tag != 6 {
-					continue
-				}
-				if v.Method.Equal(oidAuthorityInfoAccessOcsp) {
-					out.OCSPServer = append(out.OCSPServer, string(v.Location.Bytes))
-				} else if v.Method.Equal(oidAuthorityInfoAccessIssuers) {
-					out.IssuingCertificateURL = append(out.IssuingCertificateURL, string(v.Location.Bytes))
-				}
-			}
-		} else {
-			// Unknown extensions are recorded if critical.
-			unhandled = true
-		}
-
-		if e.Critical && unhandled {
-			out.UnhandledCriticalExtensions = append(out.UnhandledCriticalExtensions, e.Id)
-		}
-	}
-
-	return out, nil
-}
-
-// parseKeyUsageExtension parses id-ce-keyUsage (2.5.29.15) from RFC 5280
-// Section 4.2.1.3
-func parseKeyUsageExtension(ext []byte) (KeyUsage, error) {
-	var usageBits asn1.BitString
-	if rest, err := asn1.Unmarshal(ext, &usageBits); err != nil {
-		return 0, err
-	} else if len(rest) != 0 {
-		return 0, errors.New("x509: trailing data after X.509 KeyUsage")
-	}
-
-	var usage int
-	for i := 0; i < 9; i++ {
-		if usageBits.At(i) != 0 {
-			usage |= 1 << uint(i)
-		}
-	}
-	return KeyUsage(usage), nil
-}
-
-// parseBasicConstraintsExtension parses id-ce-basicConstraints (2.5.29.19)
-// from RFC 5280 Section 4.2.1.9
-func parseBasicConstraintsExtension(ext []byte) (isCA bool, maxPathLen int, err error) {
-	var constraints basicConstraints
-	if rest, err := asn1.Unmarshal(ext, &constraints); err != nil {
-		return false, 0, err
-	} else if len(rest) != 0 {
-		return false, 0, errors.New("x509: trailing data after X.509 BasicConstraints")
-	}
-
-	// TODO: map out.MaxPathLen to 0 if it has the -1 default value? (Issue 19285)
-	return constraints.IsCA, constraints.MaxPathLen, nil
-}
-
-// parseExtKeyUsageExtension parses id-ce-extKeyUsage (2.5.29.37) from
-// RFC 5280 Section 4.2.1.12
-func parseExtKeyUsageExtension(ext []byte) ([]ExtKeyUsage, []asn1.ObjectIdentifier, error) {
-	var keyUsage []asn1.ObjectIdentifier
-	if rest, err := asn1.Unmarshal(ext, &keyUsage); err != nil {
-		return nil, nil, err
-	} else if len(rest) != 0 {
-		return nil, nil, errors.New("x509: trailing data after X.509 ExtendedKeyUsage")
-	}
-
-	var extKeyUsages []ExtKeyUsage
-	var unknownUsages []asn1.ObjectIdentifier
-	for _, u := range keyUsage {
-		if extKeyUsage, ok := extKeyUsageFromOID(u); ok {
-			extKeyUsages = append(extKeyUsages, extKeyUsage)
-		} else {
-			unknownUsages = append(unknownUsages, u)
-		}
-	}
-	return extKeyUsages, unknownUsages, nil
-}
-
-// parseSubjectKeyIdExtension parses id-ce-subjectKeyIdentifier (2.5.29.14)
-// from RFC 5280 Section 4.2.1.2
-func parseSubjectKeyIdExtension(ext []byte) ([]byte, error) {
-	var keyid []byte
-	if rest, err := asn1.Unmarshal(ext, &keyid); err != nil {
-		return nil, err
-	} else if len(rest) != 0 {
-		return nil, errors.New("x509: trailing data after X.509 key-id")
-	}
-	return keyid, nil
-}
-
-func parseCertificatePoliciesExtension(ext []byte) ([]asn1.ObjectIdentifier, error) {
-	var policies []policyInformation
-	if rest, err := asn1.Unmarshal(ext, &policies); err != nil {
-		return nil, err
-	} else if len(rest) != 0 {
-		return nil, errors.New("x509: trailing data after X.509 certificate policies")
-	}
-	oids := make([]asn1.ObjectIdentifier, len(policies))
-	for i, policy := range policies {
-		oids[i] = policy.Policy
-	}
-	return oids, nil
-}
-
-// ParseCertificate parses a single certificate from the given ASN.1 DER data.
-func ParseCertificate(asn1Data []byte) (*Certificate, error) {
-	var cert certificate
-	rest, err := asn1.Unmarshal(asn1Data, &cert)
-	if err != nil {
-		return nil, err
-	}
-	if len(rest) > 0 {
-		return nil, asn1.SyntaxError{Msg: "trailing data"}
-	}
-
-	return parseCertificate(&cert)
-}
-
-// ParseCertificates parses one or more certificates from the given ASN.1 DER
-// data. The certificates must be concatenated with no intermediate padding.
-func ParseCertificates(asn1Data []byte) ([]*Certificate, error) {
-	var v []*certificate
-
-	for len(asn1Data) > 0 {
-		cert := new(certificate)
-		var err error
-		asn1Data, err = asn1.Unmarshal(asn1Data, cert)
-		if err != nil {
-			return nil, err
-		}
-		v = append(v, cert)
-	}
-
-	ret := make([]*Certificate, len(v))
-	for i, ci := range v {
-		cert, err := parseCertificate(ci)
-		if err != nil {
-			return nil, err
-		}
-		ret[i] = cert
-	}
-
-	return ret, nil
-}
-
 func reverseBitsInAByte(in byte) byte {
 	b1 := in>>4 | in<<4
 	b2 := b1>>2&0x33 | b1<<2&0xcc
diff --git a/src/crypto/x509/x509_test.go b/src/crypto/x509/x509_test.go
index 51dda16815..802bce0f9a 100644
--- a/src/crypto/x509/x509_test.go
+++ b/src/crypto/x509/x509_test.go
@@ -2995,3 +2995,182 @@ func TestCertificateRequestRoundtripFields(t *testing.T) {
 		t.Fatalf("Unexpected URIs: got %v, want %v", out.URIs, in.URIs)
 	}
 }
+
+func BenchmarkParseCertificate(b *testing.B) {
+	cases := []struct {
+		name string
+		pem  string
+	}{
+		{
+			name: "ecdsa leaf",
+			pem: `-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----`,
+		},
+		{
+			name: "rsa leaf",
+			pem: `-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----`,
+		},
+	}
+	for _, c := range cases {
+		b.Run(c.name, func(b *testing.B) {
+			pemBlock, _ := pem.Decode([]byte(c.pem))
+			b.ReportAllocs()
+			b.ResetTimer()
+			for i := 0; i < b.N; i++ {
+				_, err := ParseCertificate(pemBlock.Bytes)
+				if err != nil {
+					b.Fatal(err)
+				}
+			}
+		})
+	}
+}
+
+func TestParseCertificateRawEquals(t *testing.T) {
+	p, _ := pem.Decode([]byte(pemCertificate))
+	cert, err := ParseCertificate(p.Bytes)
+	if err != nil {
+		t.Fatalf("failed to parse certificate: %s", err)
+	}
+	if !bytes.Equal(p.Bytes, cert.Raw) {
+		t.Fatalf("unexpected Certificate.Raw\ngot: %x\nwant: %x\n", cert.Raw, p.Bytes)
+	}
+	fmt.Printf("in:  %x\nout: %x\n", p.Bytes, cert.Raw)
+}
+
+// mismatchingSigAlgIDPEM contains a certificate where the Certificate
+// signatureAlgorithm and the TBSCertificate signature contain
+// mismatching OIDs
+const mismatchingSigAlgIDPEM = `-----BEGIN CERTIFICATE-----
+MIIBBzCBrqADAgECAgEAMAoGCCqGSM49BAMCMAAwIhgPMDAwMTAxMDEwMDAwMDBa
+GA8wMDAxMDEwMTAwMDAwMFowADBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOqV
+EDuVXxwZgIU3+dOwv1SsMu0xuV48hf7xmK8n7sAMYgllB+96DnPqBeboJj4snYnx
+0AcE0PDVQ1l4Z3YXsQWjFTATMBEGA1UdEQEB/wQHMAWCA2FzZDAKBggqhkjOPQQD
+AwNIADBFAiBi1jz/T2HT5nAfrD7zsgR+68qh7Erc6Q4qlxYBOgKG4QIhAOtjIn+Q
+tA+bq+55P3ntxTOVRq0nv1mwnkjwt9cQR9Fn
+-----END CERTIFICATE-----`
+
+// mismatchingSigAlgParamPEM contains a certificate where the Certificate
+// signatureAlgorithm and the TBSCertificate signature contain
+// mismatching parameters
+const mismatchingSigAlgParamPEM = `-----BEGIN CERTIFICATE-----
+MIIBCTCBrqADAgECAgEAMAoGCCqGSM49BAMCMAAwIhgPMDAwMTAxMDEwMDAwMDBa
+GA8wMDAxMDEwMTAwMDAwMFowADBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOqV
+EDuVXxwZgIU3+dOwv1SsMu0xuV48hf7xmK8n7sAMYgllB+96DnPqBeboJj4snYnx
+0AcE0PDVQ1l4Z3YXsQWjFTATMBEGA1UdEQEB/wQHMAWCA2FzZDAMBggqhkjOPQQD
+AgUAA0gAMEUCIGLWPP9PYdPmcB+sPvOyBH7ryqHsStzpDiqXFgE6AobhAiEA62Mi
+f5C0D5ur7nk/ee3FM5VGrSe/WbCeSPC31xBH0Wc=
+-----END CERTIFICATE-----`
+
+func TestSigAlgMismatch(t *testing.T) {
+	for _, certPEM := range []string{mismatchingSigAlgIDPEM, mismatchingSigAlgParamPEM} {
+		b, _ := pem.Decode([]byte(certPEM))
+		if b == nil {
+			t.Fatalf("couldn't decode test certificate")
+		}
+		_, err := ParseCertificate(b.Bytes)
+		if err == nil {
+			t.Fatalf("expected ParseCertificate to fail")
+		}
+		expected := "x509: inner and outer signature algorithm identifiers don't match"
+		if err.Error() != expected {
+			t.Errorf("unexpected error from ParseCertificate: got %q, want %q", err.Error(), expected)
+		}
+	}
+}
-- 
GitLab


From 402f177efc5d03c11ac6fd25ebd1f42b0b7ec30c Mon Sep 17 00:00:00 2001
From: Lynn Boger <laboger@linux.vnet.ibm.com>
Date: Wed, 5 May 2021 14:33:18 -0500
Subject: [PATCH 1994/2400] cmd/compile: fix intrinsic setting for mul64, add64
 on ppc64le
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

I found a performance regression between the runtime.Hash
benchmarks when comparing Go 1.16 to latest on ppc64le. This
was due to the addition of Mul64 to runtime/internal/math
with the comments that this should be treated as an intrinsic
on platforms where available. However this is was not being
intrinsified on ppc64le because the code in ssagen/ssa.go didn't
correctly specify ppc64le. It had the argument for ArchPPC64
but should have also included ArchPPC64LE.

Treating Mul64 as an intrinsic shows this improvement, and these
results are better than Go 1.16:

Hash5        27.0ns ± 0%     14.0ns ± 0%   -48.1
Hash16       26.6ns ± 0%     14.0ns ± 0%   -47.3
Hash64       50.7ns ± 0%     17.9ns ± 0%   -64.6
Hash1024      500ns ± 0%       99ns ± 0%   -80.1
Hash65536    30.6µs ± 0%      4.0µs ± 0%   -86

Many of the Map related benchmarks in the runtime package also showed
improvement once Mul64 is intrinsified.

Change-Id: I3b5ce637b1620348d81a30cfc359c97ab63aae0f
Reviewed-on: https://go-review.googlesource.com/c/go/+/317303
Run-TryBot: Lynn Boger <laboger@linux.vnet.ibm.com>
Reviewed-by: Paul Murphy <murp@ibm.com>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ssagen/ssa.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 75973c46a6..2abd70169e 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -4536,14 +4536,14 @@ func InitTables() {
 			return s.newValue2(ssa.OpMul64uhilo, types.NewTuple(types.Types[types.TUINT64], types.Types[types.TUINT64]), args[0], args[1])
 		},
 		sys.AMD64, sys.ARM64, sys.PPC64, sys.S390X, sys.MIPS64)
-	alias("math/bits", "Mul", "math/bits", "Mul64", sys.ArchAMD64, sys.ArchARM64, sys.ArchPPC64, sys.ArchS390X, sys.ArchMIPS64, sys.ArchMIPS64LE)
-	alias("runtime/internal/math", "Mul64", "math/bits", "Mul64", sys.ArchAMD64, sys.ArchARM64, sys.ArchPPC64, sys.ArchS390X, sys.ArchMIPS64, sys.ArchMIPS64LE)
+	alias("math/bits", "Mul", "math/bits", "Mul64", sys.ArchAMD64, sys.ArchARM64, sys.ArchPPC64, sys.ArchPPC64LE, sys.ArchS390X, sys.ArchMIPS64, sys.ArchMIPS64LE)
+	alias("runtime/internal/math", "Mul64", "math/bits", "Mul64", sys.ArchAMD64, sys.ArchARM64, sys.ArchPPC64, sys.ArchPPC64LE, sys.ArchS390X, sys.ArchMIPS64, sys.ArchMIPS64LE)
 	addF("math/bits", "Add64",
 		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue3(ssa.OpAdd64carry, types.NewTuple(types.Types[types.TUINT64], types.Types[types.TUINT64]), args[0], args[1], args[2])
 		},
 		sys.AMD64, sys.ARM64, sys.PPC64, sys.S390X)
-	alias("math/bits", "Add", "math/bits", "Add64", sys.ArchAMD64, sys.ArchARM64, sys.ArchPPC64, sys.ArchS390X)
+	alias("math/bits", "Add", "math/bits", "Add64", sys.ArchAMD64, sys.ArchARM64, sys.ArchPPC64, sys.ArchPPC64LE, sys.ArchS390X)
 	addF("math/bits", "Sub64",
 		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue3(ssa.OpSub64borrow, types.NewTuple(types.Types[types.TUINT64], types.Types[types.TUINT64]), args[0], args[1], args[2])
-- 
GitLab


From 90d6bbbe42c15d444c1da0a1c293192d6f735a8e Mon Sep 17 00:00:00 2001
From: Roland Shoemaker <roland@golang.org>
Date: Tue, 2 Feb 2021 12:58:30 -0800
Subject: [PATCH 1995/2400] crypto/tls: enforce ALPN overlap when negotiated on
 both sides

During the TLS handshake if the server doesn't support any of the
application protocols requested by the client, send the
no_application_protocol alert and abort the handshake on the server
side. This enforces the requirements of RFC 7301.

Change-Id: Iced2bb5c6efc607497de1c40ee3de9c2b393fa5d
Reviewed-on: https://go-review.googlesource.com/c/go/+/289209
Trust: Roland Shoemaker <roland@golang.org>
Trust: Katie Hockman <katie@golang.org>
Run-TryBot: Roland Shoemaker <roland@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
---
 doc/go1.17.html                               |   7 ++
 src/crypto/tls/common.go                      |   6 +-
 src/crypto/tls/handshake_client_test.go       |  50 +++++++++
 src/crypto/tls/handshake_server.go            |  13 ++-
 src/crypto/tls/handshake_server_test.go       |  20 +++-
 src/crypto/tls/handshake_server_tls13.go      |  12 ++-
 .../tls/testdata/Server-TLSv12-ALPN-NoMatch   |  85 +--------------
 .../testdata/Server-TLSv12-ALPN-NotConfigured |  91 ++++++++++++++++
 .../tls/testdata/Server-TLSv13-ALPN-NoMatch   |  99 +++--------------
 .../testdata/Server-TLSv13-ALPN-NotConfigured | 100 ++++++++++++++++++
 10 files changed, 303 insertions(+), 180 deletions(-)
 create mode 100644 src/crypto/tls/testdata/Server-TLSv12-ALPN-NotConfigured
 create mode 100644 src/crypto/tls/testdata/Server-TLSv13-ALPN-NotConfigured

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 9328211c9a..f317006278 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -216,6 +216,13 @@ Do not send CLs removing the interior tags from such phrases.
   has no effect.
 </p>
 
+<p><!-- CL 289209 -->
+  When <a href="/pkg/crypto/tls#Config">Config.NextProtos</a> is set, servers now
+  enforce that there is an overlap between the configured protocols and the protocols
+  advertised by the client, if any. If there is no overlap the connection is closed
+  with the <code>no_application_protocol</code> alert, as required by RFC 7301.
+</p>
+
 <h3 id="runtime/cgo"><a href="/pkg/runtime/cgo">Cgo</a></h3>
 
 <p>
diff --git a/src/crypto/tls/common.go b/src/crypto/tls/common.go
index 5b68742975..23cebf2b03 100644
--- a/src/crypto/tls/common.go
+++ b/src/crypto/tls/common.go
@@ -618,7 +618,11 @@ type Config struct {
 	RootCAs *x509.CertPool
 
 	// NextProtos is a list of supported application level protocols, in
-	// order of preference.
+	// order of preference. If both peers support ALPN, the selected
+	// protocol will be one from this list, and the connection will fail
+	// if there is no mutually supported protocol. If NextProtos is empty
+	// or the peer doesn't support ALPN, the connection will succeed and
+	// ConnectionState.NegotiatedProtocol will be empty."
 	NextProtos []string
 
 	// ServerName is used to verify the hostname on the returned
diff --git a/src/crypto/tls/handshake_client_test.go b/src/crypto/tls/handshake_client_test.go
index f499cf3970..b6eb488a4d 100644
--- a/src/crypto/tls/handshake_client_test.go
+++ b/src/crypto/tls/handshake_client_test.go
@@ -1224,6 +1224,56 @@ func TestHandshakeClientALPNMatch(t *testing.T) {
 	runClientTestTLS13(t, test)
 }
 
+func TestServerSelectingUnconfiguredApplicationProtocol(t *testing.T) {
+	// This checks that the server can't select an application protocol that the
+	// client didn't offer.
+
+	c, s := localPipe(t)
+	errChan := make(chan error, 1)
+
+	go func() {
+		client := Client(c, &Config{
+			ServerName:   "foo",
+			CipherSuites: []uint16{TLS_RSA_WITH_AES_128_GCM_SHA256},
+			NextProtos:   []string{"http", "something-else"},
+		})
+		errChan <- client.Handshake()
+	}()
+
+	var header [5]byte
+	if _, err := io.ReadFull(s, header[:]); err != nil {
+		t.Fatal(err)
+	}
+	recordLen := int(header[3])<<8 | int(header[4])
+
+	record := make([]byte, recordLen)
+	if _, err := io.ReadFull(s, record); err != nil {
+		t.Fatal(err)
+	}
+
+	serverHello := &serverHelloMsg{
+		vers:         VersionTLS12,
+		random:       make([]byte, 32),
+		cipherSuite:  TLS_RSA_WITH_AES_128_GCM_SHA256,
+		alpnProtocol: "how-about-this",
+	}
+	serverHelloBytes := serverHello.marshal()
+
+	s.Write([]byte{
+		byte(recordTypeHandshake),
+		byte(VersionTLS12 >> 8),
+		byte(VersionTLS12 & 0xff),
+		byte(len(serverHelloBytes) >> 8),
+		byte(len(serverHelloBytes)),
+	})
+	s.Write(serverHelloBytes)
+	s.Close()
+
+	if err := <-errChan; !strings.Contains(err.Error(), "server selected unadvertised ALPN protocol") {
+		t.Fatalf("Expected error about unconfigured cipher suite but got %q", err)
+	}
+}
+
 // sctsBase64 contains data from `openssl s_client -serverinfo 18 -connect ritter.vg:443`
 const sctsBase64 = "ABIBaQFnAHUApLkJkLQYWBSHuxOizGdwCjw1mAT5G9+443fNDsgN3BAAAAFHl5nuFgAABAMARjBEAiAcS4JdlW5nW9sElUv2zvQyPoZ6ejKrGGB03gjaBZFMLwIgc1Qbbn+hsH0RvObzhS+XZhr3iuQQJY8S9G85D9KeGPAAdgBo9pj4H2SCvjqM7rkoHUz8cVFdZ5PURNEKZ6y7T0/7xAAAAUeX4bVwAAAEAwBHMEUCIDIhFDgG2HIuADBkGuLobU5a4dlCHoJLliWJ1SYT05z6AiEAjxIoZFFPRNWMGGIjskOTMwXzQ1Wh2e7NxXE1kd1J0QsAdgDuS723dc5guuFCaR+r4Z5mow9+X7By2IMAxHuJeqj9ywAAAUhcZIqHAAAEAwBHMEUCICmJ1rBT09LpkbzxtUC+Hi7nXLR0J+2PmwLp+sJMuqK+AiEAr0NkUnEVKVhAkccIFpYDqHOlZaBsuEhWWrYpg2RtKp0="
 
diff --git a/src/crypto/tls/handshake_server.go b/src/crypto/tls/handshake_server.go
index 5a572a9db1..65a2bf403f 100644
--- a/src/crypto/tls/handshake_server.go
+++ b/src/crypto/tls/handshake_server.go
@@ -217,11 +217,14 @@ func (hs *serverHandshakeState) processClientHello() error {
 		c.serverName = hs.clientHello.serverName
 	}
 
-	if len(hs.clientHello.alpnProtocols) > 0 {
-		if selectedProto := mutualProtocol(hs.clientHello.alpnProtocols, c.config.NextProtos); selectedProto != "" {
-			hs.hello.alpnProtocol = selectedProto
-			c.clientProtocol = selectedProto
-		}
+	if len(c.config.NextProtos) > 0 && len(hs.clientHello.alpnProtocols) > 0 {
+		selectedProto := mutualProtocol(hs.clientHello.alpnProtocols, c.config.NextProtos)
+		if selectedProto == "" {
+			c.sendAlert(alertNoApplicationProtocol)
+			return fmt.Errorf("tls: client requested unsupported application protocols (%s)", hs.clientHello.alpnProtocols)
+		}
+		hs.hello.alpnProtocol = selectedProto
+		c.clientProtocol = selectedProto
 	}
 
 	hs.cert, err = c.config.getCertificate(clientHelloInfo(hs.ctx, c, hs.clientHello))
diff --git a/src/crypto/tls/handshake_server_test.go b/src/crypto/tls/handshake_server_test.go
index 4c2d319fb1..1ba716eef0 100644
--- a/src/crypto/tls/handshake_server_test.go
+++ b/src/crypto/tls/handshake_server_test.go
@@ -920,13 +920,27 @@ func TestHandshakeServerALPNNoMatch(t *testing.T) {
 		name: "ALPN-NoMatch",
 		// Note that this needs OpenSSL 1.0.2 because that is the first
 		// version that supports the -alpn flag.
+		command:                       []string{"openssl", "s_client", "-alpn", "proto2,proto1", "-cipher", "ECDHE-RSA-CHACHA20-POLY1305", "-ciphersuites", "TLS_CHACHA20_POLY1305_SHA256"},
+		config:                        config,
+		expectHandshakeErrorIncluding: "client requested unsupported application protocol",
+	}
+	runServerTestTLS12(t, test)
+	runServerTestTLS13(t, test)
+}
+
+func TestHandshakeServerALPNNotConfigured(t *testing.T) {
+	config := testConfig.Clone()
+	config.NextProtos = nil
+
+	test := &serverTest{
+		name: "ALPN-NotConfigured",
+		// Note that this needs OpenSSL 1.0.2 because that is the first
+		// version that supports the -alpn flag.
 		command: []string{"openssl", "s_client", "-alpn", "proto2,proto1", "-cipher", "ECDHE-RSA-CHACHA20-POLY1305", "-ciphersuites", "TLS_CHACHA20_POLY1305_SHA256"},
 		config:  config,
 		validate: func(state ConnectionState) error {
-			// Rather than reject the connection, Go doesn't select
-			// a protocol when there is no overlap.
 			if state.NegotiatedProtocol != "" {
-				return fmt.Errorf("Got protocol %q, wanted ''", state.NegotiatedProtocol)
+				return fmt.Errorf("Got protocol %q, wanted nothing", state.NegotiatedProtocol)
 			}
 			return nil
 		},
diff --git a/src/crypto/tls/handshake_server_tls13.go b/src/crypto/tls/handshake_server_tls13.go
index c7837d2955..9c17577fd4 100644
--- a/src/crypto/tls/handshake_server_tls13.go
+++ b/src/crypto/tls/handshake_server_tls13.go
@@ -11,6 +11,7 @@ import (
 	"crypto/hmac"
 	"crypto/rsa"
 	"errors"
+	"fmt"
 	"hash"
 	"io"
 	"sync/atomic"
@@ -567,11 +568,14 @@ func (hs *serverHandshakeStateTLS13) sendServerParameters() error {
 
 	encryptedExtensions := new(encryptedExtensionsMsg)
 
-	if len(hs.clientHello.alpnProtocols) > 0 {
-		if selectedProto := mutualProtocol(hs.clientHello.alpnProtocols, c.config.NextProtos); selectedProto != "" {
-			encryptedExtensions.alpnProtocol = selectedProto
-			c.clientProtocol = selectedProto
+	if len(c.config.NextProtos) > 0 && len(hs.clientHello.alpnProtocols) > 0 {
+		selectedProto := mutualProtocol(hs.clientHello.alpnProtocols, c.config.NextProtos)
+		if selectedProto == "" {
+			c.sendAlert(alertNoApplicationProtocol)
+			return fmt.Errorf("tls: client requested unsupported application protocols (%s)", hs.clientHello.alpnProtocols)
 		}
+		encryptedExtensions.alpnProtocol = selectedProto
+		c.clientProtocol = selectedProto
 	}
 
 	hs.transcript.Write(encryptedExtensions.marshal())
diff --git a/src/crypto/tls/testdata/Server-TLSv12-ALPN-NoMatch b/src/crypto/tls/testdata/Server-TLSv12-ALPN-NoMatch
index fdfb175463..2d8a2eb8e8 100644
--- a/src/crypto/tls/testdata/Server-TLSv12-ALPN-NoMatch
+++ b/src/crypto/tls/testdata/Server-TLSv12-ALPN-NoMatch
@@ -1,7 +1,7 @@
 >>> Flow 1 (client to server)
-00000000  16 03 01 00 9d 01 00 00  99 03 03 7f fc 15 86 d1  |................|
-00000010  83 09 78 47 8d cd 7b 88  b3 86 52 27 bc da bc 8d  |..xG..{...R'....|
-00000020  0e 5d 35 44 21 17 7b d9  67 b9 fb 00 00 04 cc a8  |.]5D!.{.g.......|
+00000000  16 03 01 00 9d 01 00 00  99 03 03 24 15 a8 f2 f5  |...........$....|
+00000010  53 02 78 f0 4c f7 82 3c  68 7d a0 b1 9a 0f 29 32  |S.x.L..<h}....)2|
+00000020  9c 38 cc e7 92 95 63 f2  30 53 46 00 00 04 cc a8  |.8....c.0SF.....|
 00000030  00 ff 01 00 00 6c 00 0b  00 04 03 00 01 02 00 0a  |.....l..........|
 00000040  00 0c 00 0a 00 1d 00 17  00 1e 00 19 00 18 00 23  |...............#|
 00000050  00 00 00 10 00 10 00 0e  06 70 72 6f 74 6f 32 06  |.........proto2.|
@@ -11,81 +11,4 @@
 00000090  03 03 02 03 03 01 02 01  03 02 02 02 04 02 05 02  |................|
 000000a0  06 02                                             |..|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 3b 02 00 00  37 03 03 00 00 00 00 00  |....;...7.......|
-00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000020  00 00 00 44 4f 57 4e 47  52 44 01 00 cc a8 00 00  |...DOWNGRD......|
-00000030  0f 00 23 00 00 ff 01 00  01 00 00 0b 00 02 01 00  |..#.............|
-00000040  16 03 03 02 59 0b 00 02  55 00 02 52 00 02 4f 30  |....Y...U..R..O0|
-00000050  82 02 4b 30 82 01 b4 a0  03 02 01 02 02 09 00 e8  |..K0............|
-00000060  f0 9d 3f e2 5b ea a6 30  0d 06 09 2a 86 48 86 f7  |..?.[..0...*.H..|
-00000070  0d 01 01 0b 05 00 30 1f  31 0b 30 09 06 03 55 04  |......0.1.0...U.|
-00000080  0a 13 02 47 6f 31 10 30  0e 06 03 55 04 03 13 07  |...Go1.0...U....|
-00000090  47 6f 20 52 6f 6f 74 30  1e 17 0d 31 36 30 31 30  |Go Root0...16010|
-000000a0  31 30 30 30 30 30 30 5a  17 0d 32 35 30 31 30 31  |1000000Z..250101|
-000000b0  30 30 30 30 30 30 5a 30  1a 31 0b 30 09 06 03 55  |000000Z0.1.0...U|
-000000c0  04 0a 13 02 47 6f 31 0b  30 09 06 03 55 04 03 13  |....Go1.0...U...|
-000000d0  02 47 6f 30 81 9f 30 0d  06 09 2a 86 48 86 f7 0d  |.Go0..0...*.H...|
-000000e0  01 01 01 05 00 03 81 8d  00 30 81 89 02 81 81 00  |.........0......|
-000000f0  db 46 7d 93 2e 12 27 06  48 bc 06 28 21 ab 7e c4  |.F}...'.H..(!.~.|
-00000100  b6 a2 5d fe 1e 52 45 88  7a 36 47 a5 08 0d 92 42  |..]..RE.z6G....B|
-00000110  5b c2 81 c0 be 97 79 98  40 fb 4f 6d 14 fd 2b 13  |[.....y.@.Om..+.|
-00000120  8b c2 a5 2e 67 d8 d4 09  9e d6 22 38 b7 4a 0b 74  |....g....."8.J.t|
-00000130  73 2b c2 34 f1 d1 93 e5  96 d9 74 7b f3 58 9f 6c  |s+.4......t{.X.l|
-00000140  61 3c c0 b0 41 d4 d9 2b  2b 24 23 77 5b 1c 3b bd  |a<..A..++$#w[.;.|
-00000150  75 5d ce 20 54 cf a1 63  87 1d 1e 24 c4 f3 1d 1a  |u]. T..c...$....|
-00000160  50 8b aa b6 14 43 ed 97  a7 75 62 f4 14 c8 52 d7  |P....C...ub...R.|
-00000170  02 03 01 00 01 a3 81 93  30 81 90 30 0e 06 03 55  |........0..0...U|
-00000180  1d 0f 01 01 ff 04 04 03  02 05 a0 30 1d 06 03 55  |...........0...U|
-00000190  1d 25 04 16 30 14 06 08  2b 06 01 05 05 07 03 01  |.%..0...+.......|
-000001a0  06 08 2b 06 01 05 05 07  03 02 30 0c 06 03 55 1d  |..+.......0...U.|
-000001b0  13 01 01 ff 04 02 30 00  30 19 06 03 55 1d 0e 04  |......0.0...U...|
-000001c0  12 04 10 9f 91 16 1f 43  43 3e 49 a6 de 6d b6 80  |.......CC>I..m..|
-000001d0  d7 9f 60 30 1b 06 03 55  1d 23 04 14 30 12 80 10  |..`0...U.#..0...|
-000001e0  48 13 49 4d 13 7e 16 31  bb a3 01 d5 ac ab 6e 7b  |H.IM.~.1......n{|
-000001f0  30 19 06 03 55 1d 11 04  12 30 10 82 0e 65 78 61  |0...U....0...exa|
-00000200  6d 70 6c 65 2e 67 6f 6c  61 6e 67 30 0d 06 09 2a  |mple.golang0...*|
-00000210  86 48 86 f7 0d 01 01 0b  05 00 03 81 81 00 9d 30  |.H.............0|
-00000220  cc 40 2b 5b 50 a0 61 cb  ba e5 53 58 e1 ed 83 28  |.@+[P.a...SX...(|
-00000230  a9 58 1a a9 38 a4 95 a1  ac 31 5a 1a 84 66 3d 43  |.X..8....1Z..f=C|
-00000240  d3 2d d9 0b f2 97 df d3  20 64 38 92 24 3a 00 bc  |.-...... d8.$:..|
-00000250  cf 9c 7d b7 40 20 01 5f  aa d3 16 61 09 a2 76 fd  |..}.@ ._...a..v.|
-00000260  13 c3 cc e1 0c 5c ee b1  87 82 f1 6c 04 ed 73 bb  |.....\.....l..s.|
-00000270  b3 43 77 8d 0c 1c f1 0f  a1 d8 40 83 61 c9 4c 72  |.Cw.......@.a.Lr|
-00000280  2b 9d ae db 46 06 06 4d  f4 c1 b3 3e c0 d1 bd 42  |+...F..M...>...B|
-00000290  d4 db fe 3d 13 60 84 5c  21 d3 3b e9 fa e7 16 03  |...=.`.\!.;.....|
-000002a0  03 00 ac 0c 00 00 a8 03  00 1d 20 2f e5 7d a3 47  |.......... /.}.G|
-000002b0  cd 62 43 15 28 da ac 5f  bb 29 07 30 ff f6 84 af  |.bC.(.._.).0....|
-000002c0  c4 cf c2 ed 90 99 5f 58  cb 3b 74 08 04 00 80 b8  |......_X.;t.....|
-000002d0  a8 88 ac 85 ea 59 ac f1  41 e8 2d a2 76 3c 3b 4f  |.....Y..A.-.v<;O|
-000002e0  58 90 b7 03 74 4b 7a a7  5a 65 ea 08 9c cf e9 4d  |X...tKz.Ze.....M|
-000002f0  b4 8a ef f3 e1 d8 0a 83  0f 50 29 0b 59 77 90 e9  |.........P).Yw..|
-00000300  f3 e8 ca 6c b5 da e5 2b  95 47 e7 ed ff d6 3b 30  |...l...+.G....;0|
-00000310  45 61 2c af 5c 8c 4c df  bd c4 dc 28 dd d2 31 fa  |Ea,.\.L....(..1.|
-00000320  be 65 2b a4 cd 7c 41 29  4c 99 07 97 5c 2a 3c a7  |.e+..|A)L...\*<.|
-00000330  4d 9c ed 72 eb a1 a4 9e  db eb a0 cf c7 c2 b1 3b  |M..r...........;|
-00000340  5a d9 f8 f8 8e d5 07 81  f6 65 aa 0d 4f 4d 11 16  |Z........e..OM..|
-00000350  03 03 00 04 0e 00 00 00                           |........|
->>> Flow 3 (client to server)
-00000000  16 03 03 00 25 10 00 00  21 20 5f d2 13 b1 79 f6  |....%...! _...y.|
-00000010  f3 2a 21 f5 89 a3 22 29  73 30 14 60 1d 1e 77 8a  |.*!...")s0.`..w.|
-00000020  f4 1a 92 3f b0 04 06 98  1a 1e 14 03 03 00 01 01  |...?............|
-00000030  16 03 03 00 20 63 10 89  c0 c0 56 37 40 8c e8 5e  |.... c....V7@..^|
-00000040  7f f0 f0 e3 a0 8e d5 20  33 5f dd c3 16 e8 eb 6c  |....... 3_.....l|
-00000050  c3 a8 75 6d dc                                    |..um.|
->>> Flow 4 (server to client)
-00000000  16 03 03 00 8b 04 00 00  87 00 00 00 00 00 81 50  |...............P|
-00000010  46 ad c1 db a8 38 86 7b  2b bb fd d0 c3 42 3e 00  |F....8.{+....B>.|
-00000020  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 94  |................|
-00000030  6f e0 18 83 51 ed 14 ef  68 ca 42 c5 4c e3 f1 12  |o...Q...h.B.L...|
-00000040  a1 17 a6 ee 99 af e8 06  65 d0 6d c1 4f ce 92 7c  |........e.m.O..||
-00000050  40 df 41 c1 90 e3 e0 d8  a1 95 da 38 25 26 ea b5  |@.A........8%&..|
-00000060  ca a9 42 5f 8c 55 d4 d2  73 a6 a2 b6 22 49 38 16  |..B_.U..s..."I8.|
-00000070  ec 70 52 f9 c0 12 18 9e  9b 4d e3 6d 49 b7 3b c0  |.pR......M.mI.;.|
-00000080  e9 53 9d 06 96 fc a9 06  8c 2a 7a c5 7d 48 47 ef  |.S.......*z.}HG.|
-00000090  14 03 03 00 01 01 16 03  03 00 20 19 27 38 37 bf  |.......... .'87.|
-000000a0  07 4e 2f 77 b9 73 4b dd  c8 f8 4c c5 f1 35 86 2b  |.N/w.sK...L..5.+|
-000000b0  97 7e 0f 89 4b bf db 81  76 8a 41 17 03 03 00 1d  |.~..K...v.A.....|
-000000c0  6d b8 c3 eb b1 5a f3 06  97 04 61 fc 82 74 5d a0  |m....Z....a..t].|
-000000d0  73 57 75 6e 66 53 3e 12  5e 0d 60 31 52 15 03 03  |sWunfS>.^.`1R...|
-000000e0  00 12 e4 93 fb 7b cb ee  d6 70 ac af 5f 8b 82 9b  |.....{...p.._...|
-000000f0  e5 0b 68 9c                                       |..h.|
+00000000  15 03 03 00 02 02 78                              |......x|
diff --git a/src/crypto/tls/testdata/Server-TLSv12-ALPN-NotConfigured b/src/crypto/tls/testdata/Server-TLSv12-ALPN-NotConfigured
new file mode 100644
index 0000000000..e1c991b227
--- /dev/null
+++ b/src/crypto/tls/testdata/Server-TLSv12-ALPN-NotConfigured
@@ -0,0 +1,91 @@
+>>> Flow 1 (client to server)
+00000000  16 03 01 00 9d 01 00 00  99 03 03 92 d8 d4 4f 2e  |..............O.|
+00000010  82 ad e9 4f a2 c3 f7 23  da 2e dc 23 c0 87 fc 33  |...O...#...#...3|
+00000020  14 63 f1 da 98 a8 af 70  3a 7e f3 00 00 04 cc a8  |.c.....p:~......|
+00000030  00 ff 01 00 00 6c 00 0b  00 04 03 00 01 02 00 0a  |.....l..........|
+00000040  00 0c 00 0a 00 1d 00 17  00 1e 00 19 00 18 00 23  |...............#|
+00000050  00 00 00 10 00 10 00 0e  06 70 72 6f 74 6f 32 06  |.........proto2.|
+00000060  70 72 6f 74 6f 31 00 16  00 00 00 17 00 00 00 0d  |proto1..........|
+00000070  00 30 00 2e 04 03 05 03  06 03 08 07 08 08 08 09  |.0..............|
+00000080  08 0a 08 0b 08 04 08 05  08 06 04 01 05 01 06 01  |................|
+00000090  03 03 02 03 03 01 02 01  03 02 02 02 04 02 05 02  |................|
+000000a0  06 02                                             |..|
+>>> Flow 2 (server to client)
+00000000  16 03 03 00 3b 02 00 00  37 03 03 00 00 00 00 00  |....;...7.......|
+00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
+00000020  00 00 00 44 4f 57 4e 47  52 44 01 00 cc a8 00 00  |...DOWNGRD......|
+00000030  0f 00 23 00 00 ff 01 00  01 00 00 0b 00 02 01 00  |..#.............|
+00000040  16 03 03 02 59 0b 00 02  55 00 02 52 00 02 4f 30  |....Y...U..R..O0|
+00000050  82 02 4b 30 82 01 b4 a0  03 02 01 02 02 09 00 e8  |..K0............|
+00000060  f0 9d 3f e2 5b ea a6 30  0d 06 09 2a 86 48 86 f7  |..?.[..0...*.H..|
+00000070  0d 01 01 0b 05 00 30 1f  31 0b 30 09 06 03 55 04  |......0.1.0...U.|
+00000080  0a 13 02 47 6f 31 10 30  0e 06 03 55 04 03 13 07  |...Go1.0...U....|
+00000090  47 6f 20 52 6f 6f 74 30  1e 17 0d 31 36 30 31 30  |Go Root0...16010|
+000000a0  31 30 30 30 30 30 30 5a  17 0d 32 35 30 31 30 31  |1000000Z..250101|
+000000b0  30 30 30 30 30 30 5a 30  1a 31 0b 30 09 06 03 55  |000000Z0.1.0...U|
+000000c0  04 0a 13 02 47 6f 31 0b  30 09 06 03 55 04 03 13  |....Go1.0...U...|
+000000d0  02 47 6f 30 81 9f 30 0d  06 09 2a 86 48 86 f7 0d  |.Go0..0...*.H...|
+000000e0  01 01 01 05 00 03 81 8d  00 30 81 89 02 81 81 00  |.........0......|
+000000f0  db 46 7d 93 2e 12 27 06  48 bc 06 28 21 ab 7e c4  |.F}...'.H..(!.~.|
+00000100  b6 a2 5d fe 1e 52 45 88  7a 36 47 a5 08 0d 92 42  |..]..RE.z6G....B|
+00000110  5b c2 81 c0 be 97 79 98  40 fb 4f 6d 14 fd 2b 13  |[.....y.@.Om..+.|
+00000120  8b c2 a5 2e 67 d8 d4 09  9e d6 22 38 b7 4a 0b 74  |....g....."8.J.t|
+00000130  73 2b c2 34 f1 d1 93 e5  96 d9 74 7b f3 58 9f 6c  |s+.4......t{.X.l|
+00000140  61 3c c0 b0 41 d4 d9 2b  2b 24 23 77 5b 1c 3b bd  |a<..A..++$#w[.;.|
+00000150  75 5d ce 20 54 cf a1 63  87 1d 1e 24 c4 f3 1d 1a  |u]. T..c...$....|
+00000160  50 8b aa b6 14 43 ed 97  a7 75 62 f4 14 c8 52 d7  |P....C...ub...R.|
+00000170  02 03 01 00 01 a3 81 93  30 81 90 30 0e 06 03 55  |........0..0...U|
+00000180  1d 0f 01 01 ff 04 04 03  02 05 a0 30 1d 06 03 55  |...........0...U|
+00000190  1d 25 04 16 30 14 06 08  2b 06 01 05 05 07 03 01  |.%..0...+.......|
+000001a0  06 08 2b 06 01 05 05 07  03 02 30 0c 06 03 55 1d  |..+.......0...U.|
+000001b0  13 01 01 ff 04 02 30 00  30 19 06 03 55 1d 0e 04  |......0.0...U...|
+000001c0  12 04 10 9f 91 16 1f 43  43 3e 49 a6 de 6d b6 80  |.......CC>I..m..|
+000001d0  d7 9f 60 30 1b 06 03 55  1d 23 04 14 30 12 80 10  |..`0...U.#..0...|
+000001e0  48 13 49 4d 13 7e 16 31  bb a3 01 d5 ac ab 6e 7b  |H.IM.~.1......n{|
+000001f0  30 19 06 03 55 1d 11 04  12 30 10 82 0e 65 78 61  |0...U....0...exa|
+00000200  6d 70 6c 65 2e 67 6f 6c  61 6e 67 30 0d 06 09 2a  |mple.golang0...*|
+00000210  86 48 86 f7 0d 01 01 0b  05 00 03 81 81 00 9d 30  |.H.............0|
+00000220  cc 40 2b 5b 50 a0 61 cb  ba e5 53 58 e1 ed 83 28  |.@+[P.a...SX...(|
+00000230  a9 58 1a a9 38 a4 95 a1  ac 31 5a 1a 84 66 3d 43  |.X..8....1Z..f=C|
+00000240  d3 2d d9 0b f2 97 df d3  20 64 38 92 24 3a 00 bc  |.-...... d8.$:..|
+00000250  cf 9c 7d b7 40 20 01 5f  aa d3 16 61 09 a2 76 fd  |..}.@ ._...a..v.|
+00000260  13 c3 cc e1 0c 5c ee b1  87 82 f1 6c 04 ed 73 bb  |.....\.....l..s.|
+00000270  b3 43 77 8d 0c 1c f1 0f  a1 d8 40 83 61 c9 4c 72  |.Cw.......@.a.Lr|
+00000280  2b 9d ae db 46 06 06 4d  f4 c1 b3 3e c0 d1 bd 42  |+...F..M...>...B|
+00000290  d4 db fe 3d 13 60 84 5c  21 d3 3b e9 fa e7 16 03  |...=.`.\!.;.....|
+000002a0  03 00 ac 0c 00 00 a8 03  00 1d 20 2f e5 7d a3 47  |.......... /.}.G|
+000002b0  cd 62 43 15 28 da ac 5f  bb 29 07 30 ff f6 84 af  |.bC.(.._.).0....|
+000002c0  c4 cf c2 ed 90 99 5f 58  cb 3b 74 08 04 00 80 8c  |......_X.;t.....|
+000002d0  cb 8c f6 6c dd 02 5f c9  13 7e c2 26 26 41 7a 1a  |...l.._..~.&&Az.|
+000002e0  25 c7 3e 22 11 30 32 c0  67 a5 53 32 1e 32 21 cb  |%.>".02.g.S2.2!.|
+000002f0  ff 0a b7 e1 7a 98 26 e9  bf 05 30 f6 13 38 ee 1d  |....z.&...0..8..|
+00000300  90 56 a6 0d e0 65 a8 02  0e 08 3e c0 31 ff dd fa  |.V...e....>.1...|
+00000310  05 3a 22 7c f8 ce 65 43  0c b6 c4 9a e4 ed 22 eb  |.:"|..eC......".|
+00000320  c4 46 b2 3d 1d 9c c1 e7  d4 6a 79 4f cf 8f 1c 45  |.F.=.....jyO...E|
+00000330  52 51 b3 d1 a4 0d 0d df  4e 19 15 e6 af 2e 5a d5  |RQ......N.....Z.|
+00000340  8a 2e 3c 48 8a f7 86 e5  53 0e 35 9a 8a c6 dd 16  |..<H....S.5.....|
+00000350  03 03 00 04 0e 00 00 00                           |........|
+>>> Flow 3 (client to server)
+00000000  16 03 03 00 25 10 00 00  21 20 b7 d6 2f 99 8f c7  |....%...! ../...|
+00000010  bc 48 b8 4f 01 f8 2c ff  75 e5 fe 10 c6 2d 2d d5  |.H.O..,.u....--.|
+00000020  43 2b c3 14 cb d0 b2 7a  e9 71 14 03 03 00 01 01  |C+.....z.q......|
+00000030  16 03 03 00 20 c9 88 f1  a0 1a 9b 8a 14 00 33 f0  |.... .........3.|
+00000040  e8 01 f3 c2 66 06 98 44  4d 35 89 8f 1b 65 d0 cf  |....f..DM5...e..|
+00000050  eb 7d 9f b1 df                                    |.}...|
+>>> Flow 4 (server to client)
+00000000  16 03 03 00 8b 04 00 00  87 00 00 00 00 00 81 50  |...............P|
+00000010  46 ad c1 db a8 38 86 7b  2b bb fd d0 c3 42 3e 00  |F....8.{+....B>.|
+00000020  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 94  |................|
+00000030  6f e0 18 83 51 ed 14 ef  68 ca 42 c5 4c 76 fb ec  |o...Q...h.B.Lv..|
+00000040  0d 89 48 e7 19 98 64 df  59 8f df 50 ce 28 e8 3c  |..H...d.Y..P.(.<|
+00000050  b6 f8 5a ae bc 6b 2e a2  d6 23 05 f6 7f 36 ea 55  |..Z..k...#...6.U|
+00000060  13 54 9e 9c 31 df d0 56  00 1f a7 6a b2 49 38 16  |.T..1..V...j.I8.|
+00000070  7f d0 78 12 95 86 11 ca  98 63 07 4a 81 a5 d3 bd  |..x......c.J....|
+00000080  dc 9e 54 9c 25 f2 55 d5  fd cf 36 94 99 e0 c5 82  |..T.%.U...6.....|
+00000090  14 03 03 00 01 01 16 03  03 00 20 e6 d9 c2 bb ca  |.......... .....|
+000000a0  02 d3 79 a4 fb b0 00 7d  e2 47 46 d3 e7 b4 fe be  |..y....}.GF.....|
+000000b0  b3 8f c4 98 b7 f7 25 bc  cc 3f a8 17 03 03 00 1d  |......%..?......|
+000000c0  ad f3 27 a0 c4 a4 5b 7b  40 11 a4 35 e6 10 03 63  |..'...[{@..5...c|
+000000d0  13 d3 1c ce 75 8f 09 8b  85 6c 93 b1 9f 15 03 03  |....u....l......|
+000000e0  00 12 79 0c dd 21 72 68  b8 30 45 5d 45 39 a9 c4  |..y..!rh.0E]E9..|
+000000f0  a6 d7 12 99                                       |....|
diff --git a/src/crypto/tls/testdata/Server-TLSv13-ALPN-NoMatch b/src/crypto/tls/testdata/Server-TLSv13-ALPN-NoMatch
index 0b5dc9b1c6..b51ff258c5 100644
--- a/src/crypto/tls/testdata/Server-TLSv13-ALPN-NoMatch
+++ b/src/crypto/tls/testdata/Server-TLSv13-ALPN-NoMatch
@@ -1,9 +1,9 @@
 >>> Flow 1 (client to server)
-00000000  16 03 01 00 e2 01 00 00  de 03 03 ea ab 77 e1 48  |.............w.H|
-00000010  64 70 23 5c af b3 a7 3d  60 93 a0 30 0a 8c 98 61  |dp#\...=`..0...a|
-00000020  3a ab bc a9 11 c1 2f f5  ed d7 63 20 d4 29 26 9d  |:...../...c .)&.|
-00000030  64 37 72 d1 2c 7d 09 3b  94 67 f9 1c 19 c3 7e 17  |d7r.,}.;.g....~.|
-00000040  ec 80 5f 09 38 c1 15 4d  59 45 5c c3 00 04 13 03  |.._.8..MYE\.....|
+00000000  16 03 01 00 e2 01 00 00  de 03 03 9f 73 81 5f 56  |............s._V|
+00000010  a9 02 5f 8c 33 db dc 2a  92 d0 5e 7c e9 e6 01 d7  |.._.3..*..^|....|
+00000020  67 b6 bb 74 da bb d0 c1  11 08 20 20 9f bd d6 f8  |g..t......  ....|
+00000030  d7 8c e5 32 15 1d 4a 4c  36 ce 72 90 cb 68 ca dc  |...2..JL6.r..h..|
+00000040  ea b3 57 93 9a 12 e6 0e  9a bd 91 1a 00 04 13 03  |..W.............|
 00000050  00 ff 01 00 00 91 00 0b  00 04 03 00 01 02 00 0a  |................|
 00000060  00 0c 00 0a 00 1d 00 17  00 1e 00 19 00 18 00 23  |...............#|
 00000070  00 00 00 10 00 10 00 0e  06 70 72 6f 74 6f 32 06  |.........proto2.|
@@ -11,90 +11,17 @@
 00000090  00 1e 00 1c 04 03 05 03  06 03 08 07 08 08 08 09  |................|
 000000a0  08 0a 08 0b 08 04 08 05  08 06 04 01 05 01 06 01  |................|
 000000b0  00 2b 00 03 02 03 04 00  2d 00 02 01 01 00 33 00  |.+......-.....3.|
-000000c0  26 00 24 00 1d 00 20 68  64 e8 c1 4a c5 d5 b8 91  |&.$... hd..J....|
-000000d0  a0 20 c7 aa 8a 41 90 d6  d0 5e ed 6c ed e4 77 aa  |. ...A...^.l..w.|
-000000e0  ec 33 93 e3 d5 b7 55                              |.3....U|
+000000c0  26 00 24 00 1d 00 20 79  79 04 d3 03 58 93 22 5d  |&.$... yy...X."]|
+000000d0  06 69 1a 03 11 4e 65 e5  30 85 29 02 22 c8 11 6d  |.i...Ne.0.)."..m|
+000000e0  21 86 d4 4d 58 93 74                              |!..MX.t|
 >>> Flow 2 (server to client)
 00000000  16 03 03 00 7a 02 00 00  76 03 03 00 00 00 00 00  |....z...v.......|
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000020  00 00 00 00 00 00 00 00  00 00 00 20 d4 29 26 9d  |........... .)&.|
-00000030  64 37 72 d1 2c 7d 09 3b  94 67 f9 1c 19 c3 7e 17  |d7r.,}.;.g....~.|
-00000040  ec 80 5f 09 38 c1 15 4d  59 45 5c c3 13 03 00 00  |.._.8..MYE\.....|
+00000020  00 00 00 00 00 00 00 00  00 00 00 20 9f bd d6 f8  |........... ....|
+00000030  d7 8c e5 32 15 1d 4a 4c  36 ce 72 90 cb 68 ca dc  |...2..JL6.r..h..|
+00000040  ea b3 57 93 9a 12 e6 0e  9a bd 91 1a 13 03 00 00  |..W.............|
 00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 2f  |..+.....3.$... /|
 00000060  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 00000070  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74 14  |.........._X.;t.|
-00000080  03 03 00 01 01 17 03 03  00 17 c0 d3 a2 c3 42 b4  |..............B.|
-00000090  39 f1 b6 f1 0a ac f3 76  dd 36 15 eb d7 3b 3f 63  |9......v.6...;?c|
-000000a0  0b 17 03 03 02 6d f2 02  6d 15 de 46 b3 30 ef 57  |.....m..m..F.0.W|
-000000b0  e5 a3 35 11 5c c3 b4 2e  ad 74 ca db d2 90 eb b4  |..5.\....t......|
-000000c0  ba 14 7e b0 65 68 e8 31  76 2a 28 e4 be bb d1 c3  |..~.eh.1v*(.....|
-000000d0  45 cb ba 07 eb 27 d9 5e  4a 45 52 10 62 f0 8f b2  |E....'.^JER.b...|
-000000e0  7c ad 0f 63 5c 39 f7 6e  f2 68 3e bc fd ec fe fa  ||..c\9.n.h>.....|
-000000f0  9b ba 45 96 2b 94 27 34  2c 78 c8 5f 40 e3 f9 20  |..E.+.'4,x._@.. |
-00000100  51 15 3d dc 70 d1 50 7c  26 6b 51 3f 47 61 0b e6  |Q.=.p.P|&kQ?Ga..|
-00000110  04 ee 49 19 27 f0 91 c5  0f 15 0a 90 a6 0c 14 f2  |..I.'...........|
-00000120  2f f1 42 28 be a0 7a ce  16 14 bf ff 34 34 a8 d8  |/.B(..z.....44..|
-00000130  61 e6 26 6a 00 62 a0 82  53 c6 27 30 89 81 8d fb  |a.&j.b..S.'0....|
-00000140  9e 97 bc a0 ce 2f a1 e2  bf 9e fe d2 cc 11 4e 00  |...../........N.|
-00000150  89 d1 e8 3b ab 58 e4 66  0a 87 00 b1 c1 a0 2d b0  |...;.X.f......-.|
-00000160  96 b3 13 9b d3 c0 16 6b  87 e8 e3 9e 6c 30 1b 67  |.......k....l0.g|
-00000170  c1 53 a5 4b 55 44 4e 27  6e ea 7c 7d 9f 44 b4 ca  |.S.KUDN'n.|}.D..|
-00000180  15 6f e5 d1 7f 18 e4 12  66 2d d5 a2 47 0c 73 26  |.o......f-..G.s&|
-00000190  b0 bf 93 5b 46 9c 3f 78  69 05 a1 38 0f 61 ea d6  |...[F.?xi..8.a..|
-000001a0  61 97 80 c5 72 be 6d be  2d e5 a2 9e d8 b3 bf 8d  |a...r.m.-.......|
-000001b0  a4 53 ba 6d fe c8 8d ac  c1 4a 6e 76 bf 72 1e 5a  |.S.m.....Jnv.r.Z|
-000001c0  0a 51 f3 c8 1f 11 91 36  f0 f5 ba 68 e8 69 c3 77  |.Q.....6...h.i.w|
-000001d0  52 63 dc b3 93 80 0d fd  9a 7d 7f f8 47 f8 62 2a  |Rc.......}..G.b*|
-000001e0  3d 4f 1b 46 9f cb 07 b6  96 00 b1 08 e7 32 50 41  |=O.F.........2PA|
-000001f0  83 da 20 c2 b0 c0 33 33  3f f2 f9 84 f0 64 9f 37  |.. ...33?....d.7|
-00000200  4b b6 7b ab 2e e9 50 8b  6a 61 da 12 51 54 13 25  |K.{...P.ja..QT.%|
-00000210  46 5d 90 06 ef 88 4e be  64 67 80 02 1f 25 9c 28  |F]....N.dg...%.(|
-00000220  07 b3 24 2b 10 81 c1 72  7c 94 97 b3 5a 16 bc cf  |..$+...r|...Z...|
-00000230  52 44 41 2c d7 ba e9 9f  4c d7 28 e6 b7 bb b0 fd  |RDA,....L.(.....|
-00000240  17 b2 0b 83 33 ed 2f c7  2d 42 37 fd 0a d0 4b c7  |....3./.-B7...K.|
-00000250  97 61 17 d6 cd cd 0f e0  0d dd ab 40 fb 00 4d 81  |.a.........@..M.|
-00000260  da 7d 1d 0e 48 d9 a7 6c  ba 2a 21 49 18 0f a4 7c  |.}..H..l.*!I...||
-00000270  af 0d 1b ca 94 f1 6c 78  59 ad 50 e4 1c 7b 37 45  |......lxY.P..{7E|
-00000280  e8 1b 73 ad 96 8d 98 d6  07 26 07 fd a8 e6 8c 39  |..s......&.....9|
-00000290  f1 5a 10 ef 04 97 fe d3  be cb f2 c1 5b 27 e8 d0  |.Z..........['..|
-000002a0  f9 b3 16 b9 82 6d e8 be  54 c7 cf 44 a4 8a fd 75  |.....m..T..D...u|
-000002b0  96 2a f1 65 2b d3 8f f5  86 a3 bf 12 74 c1 e4 d8  |.*.e+.......t...|
-000002c0  a9 db c9 43 05 07 b1 51  dc 20 29 d0 c0 9a 6d 10  |...C...Q. )...m.|
-000002d0  83 5f 87 a6 ab 03 58 43  1f 35 1c af dd 37 10 1b  |._....XC.5...7..|
-000002e0  16 50 52 e5 3c f5 3c ae  4f 92 7e dc 47 2e b3 9c  |.PR.<.<.O.~.G...|
-000002f0  1f d2 a0 31 8b 32 21 35  52 af bd f1 0b 2c 4e 6f  |...1.2!5R....,No|
-00000300  59 32 d8 db d6 9f b8 bd  bc a0 3b 77 41 43 46 fb  |Y2........;wACF.|
-00000310  2b 0e 82 17 03 03 00 99  0a 63 cd 1f fa 90 4d 95  |+........c....M.|
-00000320  17 d8 81 36 5c 62 17 33  6c 8d 9d 9f 26 3e 3a 2f  |...6\b.3l...&>:/|
-00000330  65 84 23 56 46 25 f6 1c  dd ea 6f 21 b4 05 d8 19  |e.#VF%....o!....|
-00000340  a3 c9 4b b1 03 78 39 32  00 97 6c d5 6e e3 ff 45  |..K..x92..l.n..E|
-00000350  ac 2a 10 71 21 ad d3 b9  73 b7 77 0e a8 79 fd 50  |.*.q!...s.w..y.P|
-00000360  a9 f1 41 39 2d 05 3d 92  3c 69 0a d7 7d 11 da f0  |..A9-.=.<i..}...|
-00000370  fe 83 a6 c8 79 96 33 9c  df 12 1c 39 90 da d3 94  |....y.3....9....|
-00000380  7e 4a 5d 1c 31 b2 5c ea  33 2c 40 56 3a 80 86 0c  |~J].1.\.3,@V:...|
-00000390  93 bf 0f 56 b6 67 2e 4c  7f 9f 0c d5 58 9f 9d d6  |...V.g.L....X...|
-000003a0  db e1 74 13 eb 7c a6 a5  1a 65 64 37 66 74 68 3a  |..t..|...ed7fth:|
-000003b0  73 17 03 03 00 35 53 63  0b ce 12 f7 f5 39 1d 20  |s....5Sc.....9. |
-000003c0  41 89 5f a0 d2 fa 84 a3  2b e2 95 f4 9b e8 14 66  |A._.....+......f|
-000003d0  2c c7 01 ad e9 ba 6c 11  86 c9 00 93 49 c1 af 30  |,.....l.....I..0|
-000003e0  13 a7 59 16 a2 32 43 63  eb c2 64 17 03 03 00 93  |..Y..2Cc..d.....|
-000003f0  20 da 02 66 ca 8d fa b5  4d 6a 0d e7 c6 a9 7b e2  | ..f....Mj....{.|
-00000400  1c e8 61 c4 59 a2 30 f4  1b 27 c9 05 2e a1 33 93  |..a.Y.0..'....3.|
-00000410  43 8a 70 15 9b 26 19 e3  0a a6 31 d9 ce 46 f7 78  |C.p..&....1..F.x|
-00000420  bd 88 c4 ff 73 eb a0 3c  42 01 b0 6d 55 2c 61 7b  |....s..<B..mU,a{|
-00000430  d6 87 2f 50 6e 64 ae 73  69 a2 04 dc ec 3a e7 a5  |../Pnd.si....:..|
-00000440  5c 24 df eb e8 bc 7b b9  df 3e a4 d8 26 1a ff 4b  |\$....{..>..&..K|
-00000450  a6 ce 93 36 ea a1 fd d9  78 61 a3 0e 08 72 da 03  |...6....xa...r..|
-00000460  5d 0c 27 48 75 61 25 ef  77 39 39 e5 8e 87 2e 86  |].'Hua%.w99.....|
-00000470  d5 70 d3 3b f4 b4 75 b1  44 d1 5f fe 9c d8 18 7d  |.p.;..u.D._....}|
-00000480  f9 89 20                                          |.. |
->>> Flow 3 (client to server)
-00000000  14 03 03 00 01 01 17 03  03 00 35 a8 ab 13 71 ec  |..........5...q.|
-00000010  af a7 4a 48 65 6d 02 ea  8a 0f d1 4d 2a 97 b6 11  |..JHem.....M*...|
-00000020  6d 53 5f be a4 b3 a7 20  d4 d3 aa 90 62 30 26 3f  |mS_.... ....b0&?|
-00000030  be c8 ed fc 6f 44 cc a5  3a 7f 4d 95 51 ed dc 80  |....oD..:.M.Q...|
->>> Flow 4 (server to client)
-00000000  17 03 03 00 1e 6a f5 e4  df 1b 2a 5a 87 68 b1 a7  |.....j....*Z.h..|
-00000010  1d b8 ef 04 b4 ac b9 50  b3 95 1c 12 d7 44 ca 46  |.......P.....D.F|
-00000020  ea 26 2a 17 03 03 00 13  a4 6b 4d 27 81 62 b0 3c  |.&*......kM'.b.<|
-00000030  d0 be d1 34 46 4c 7b 6c  71 24 d8                 |...4FL{lq$.|
+00000080  03 03 00 01 01 17 03 03  00 13 7c ab 7f dd 94 cf  |..........|.....|
+00000090  d7 98 34 16 75 02 63 37  fa 4f 19 4e 18           |..4.u.c7.O.N.|
diff --git a/src/crypto/tls/testdata/Server-TLSv13-ALPN-NotConfigured b/src/crypto/tls/testdata/Server-TLSv13-ALPN-NotConfigured
new file mode 100644
index 0000000000..e0830d30f7
--- /dev/null
+++ b/src/crypto/tls/testdata/Server-TLSv13-ALPN-NotConfigured
@@ -0,0 +1,100 @@
+>>> Flow 1 (client to server)
+00000000  16 03 01 00 e2 01 00 00  de 03 03 9f 49 a7 46 f8  |............I.F.|
+00000010  72 04 47 a1 8e 4f 89 c3  cd 89 92 2f 7a 8a 07 37  |r.G..O...../z..7|
+00000020  8c 25 10 42 26 07 8b a2  71 3e 92 20 4c 83 1b 70  |.%.B&...q>. L..p|
+00000030  45 c3 79 68 c3 83 a7 05  c2 22 06 c6 91 da 8b 96  |E.yh....."......|
+00000040  4c 9d 89 c2 ec b8 49 87  17 3f 6c ae 00 04 13 03  |L.....I..?l.....|
+00000050  00 ff 01 00 00 91 00 0b  00 04 03 00 01 02 00 0a  |................|
+00000060  00 0c 00 0a 00 1d 00 17  00 1e 00 19 00 18 00 23  |...............#|
+00000070  00 00 00 10 00 10 00 0e  06 70 72 6f 74 6f 32 06  |.........proto2.|
+00000080  70 72 6f 74 6f 31 00 16  00 00 00 17 00 00 00 0d  |proto1..........|
+00000090  00 1e 00 1c 04 03 05 03  06 03 08 07 08 08 08 09  |................|
+000000a0  08 0a 08 0b 08 04 08 05  08 06 04 01 05 01 06 01  |................|
+000000b0  00 2b 00 03 02 03 04 00  2d 00 02 01 01 00 33 00  |.+......-.....3.|
+000000c0  26 00 24 00 1d 00 20 f4  91 87 6a ac cd 25 5e f1  |&.$... ...j..%^.|
+000000d0  0d 25 fb af a4 d4 fb 16  32 63 af 04 2d 21 d7 2f  |.%......2c..-!./|
+000000e0  61 f2 c2 d4 c4 6c 2b                              |a....l+|
+>>> Flow 2 (server to client)
+00000000  16 03 03 00 7a 02 00 00  76 03 03 00 00 00 00 00  |....z...v.......|
+00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
+00000020  00 00 00 00 00 00 00 00  00 00 00 20 4c 83 1b 70  |........... L..p|
+00000030  45 c3 79 68 c3 83 a7 05  c2 22 06 c6 91 da 8b 96  |E.yh....."......|
+00000040  4c 9d 89 c2 ec b8 49 87  17 3f 6c ae 13 03 00 00  |L.....I..?l.....|
+00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 2f  |..+.....3.$... /|
+00000060  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
+00000070  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74 14  |.........._X.;t.|
+00000080  03 03 00 01 01 17 03 03  00 17 60 79 16 61 4f 6c  |..........`y.aOl|
+00000090  9e 2e ce fd cc f5 29 67  38 e7 53 67 92 b1 5f 9d  |......)g8.Sg.._.|
+000000a0  db 17 03 03 02 6d 54 d9  d6 a1 8e c2 1b 70 3f 3d  |.....mT......p?=|
+000000b0  a2 2e 0f a5 37 96 e1 68  66 69 cc f8 e9 06 4d bc  |....7..hfi....M.|
+000000c0  c2 9a 6e 0f ea d4 73 59  6a 59 28 79 7f 44 0c 32  |..n...sYjY(y.D.2|
+000000d0  29 22 51 d1 fb 00 c7 33  44 8b 19 71 98 8a 03 44  |)"Q....3D..q...D|
+000000e0  e0 95 ad 8f 91 66 e6 15  b8 99 b3 f8 2f 02 e9 a0  |.....f....../...|
+000000f0  4a 25 ec 3f 36 56 0c eb  0a a3 e0 d3 79 a1 b3 9e  |J%.?6V......y...|
+00000100  dc 42 08 76 a4 c3 55 91  06 11 e7 0c 94 dd 71 fc  |.B.v..U.......q.|
+00000110  bf 8a 87 d2 97 07 a3 b9  36 7e 58 ff ef b3 a3 f4  |........6~X.....|
+00000120  6e f1 23 d6 50 e3 23 d3  dc e7 20 ce 9d 84 17 cf  |n.#.P.#... .....|
+00000130  2d 5f b1 f9 8d 36 41 7d  ba 3b 93 63 2f bc be f0  |-_...6A}.;.c/...|
+00000140  a1 3a bb 5f b3 99 03 13  fb d2 2c 1a 8c cc 32 02  |.:._......,...2.|
+00000150  ef 93 b4 58 a8 f8 b1 42  52 24 c2 73 01 cb 5a fb  |...X...BR$.s..Z.|
+00000160  9f fc 38 08 d7 f9 0d d7  20 fa dc 8b 1a 8c 73 0f  |..8..... .....s.|
+00000170  f8 79 b2 84 e1 49 2d 8e  6d 46 16 38 0e 02 2a 2c  |.y...I-.mF.8..*,|
+00000180  f4 44 89 da f1 7a 01 55  9e 93 a8 d6 d5 f5 72 28  |.D...z.U......r(|
+00000190  47 2b 4f 17 7e a5 01 fd  ad 85 e0 6d f9 82 e8 cd  |G+O.~......m....|
+000001a0  09 18 84 8c 9d 4f 4e a1  43 ff d6 3d 55 05 fc 56  |.....ON.C..=U..V|
+000001b0  e6 d6 b6 61 4a c7 c7 9c  62 64 26 1d 33 1e 4f d5  |...aJ...bd&.3.O.|
+000001c0  5e ee 1f a9 ad 24 e4 7f  05 cc 02 7a f7 e0 c2 ce  |^....$.....z....|
+000001d0  b8 11 c9 a1 fd c5 d8 0e  ef f8 c9 6a 2d 49 30 63  |...........j-I0c|
+000001e0  e3 9b 43 bf 87 e1 5f 55  39 fa 80 ec 84 55 59 5d  |..C..._U9....UY]|
+000001f0  52 76 4c f4 70 eb 43 6a  b2 07 d5 29 4c 58 39 04  |RvL.p.Cj...)LX9.|
+00000200  46 42 70 8d 28 61 7c d5  7a 3a 2e a0 9f 74 49 2d  |FBp.(a|.z:...tI-|
+00000210  33 8d 39 18 70 8d 3c 50  4f 62 07 77 2d 15 1f 4b  |3.9.p.<POb.w-..K|
+00000220  22 01 c6 cb ac 2f 2d 9a  cf a6 9b 0e 24 99 41 64  |"..../-.....$.Ad|
+00000230  3e f2 9f 5f 17 7b d7 b8  3c b6 6d 24 5b 91 8c 13  |>.._.{..<.m$[...|
+00000240  1a 40 4e 80 7f 44 12 57  c9 03 57 c6 9b 54 0d 39  |.@N..D.W..W..T.9|
+00000250  91 88 72 3e c8 f9 18 eb  34 7c 0a eb 2d c8 56 1c  |..r>....4|..-.V.|
+00000260  84 8a 62 a2 3a 0a 52 b8  5a b6 5d 54 78 ae 05 b2  |..b.:.R.Z.]Tx...|
+00000270  f4 6c 2d 5e 92 94 6b f3  1e 93 13 1a 65 74 60 e3  |.l-^..k.....et`.|
+00000280  dd 15 36 62 2b 71 b1 bb  59 19 08 af 8e 9b d0 47  |..6b+q..Y......G|
+00000290  05 7b a3 89 ac 68 cf a0  32 ba 4a 2b 9e 5f a5 dc  |.{...h..2.J+._..|
+000002a0  b3 00 79 a8 1c f6 11 b8  6d 9c 51 b7 f1 f6 b2 13  |..y.....m.Q.....|
+000002b0  56 57 4e ac 97 ff 5a b8  52 33 0c c1 3d 52 81 6e  |VWN...Z.R3..=R.n|
+000002c0  85 ba b2 04 4b eb 41 aa  03 ff ae 63 93 72 3a 5f  |....K.A....c.r:_|
+000002d0  65 81 f9 6a 2a e4 70 f8  b3 59 31 51 62 ad 25 24  |e..j*.p..Y1Qb.%$|
+000002e0  82 0c b5 ad 7c 87 21 97  07 c0 c1 6d f0 22 97 0d  |....|.!....m."..|
+000002f0  28 cf a7 4d 74 d2 9c ac  d7 15 83 26 f7 2f 76 d4  |(..Mt......&./v.|
+00000300  ad cf e7 ef 1c f4 3e 1f  b4 f4 4f 76 6a 98 15 01  |......>...Ovj...|
+00000310  cd 17 8b 17 03 03 00 99  0b 15 9d 16 c6 2a 52 53  |.............*RS|
+00000320  33 d7 01 db 8a 49 1d d6  83 b7 28 a4 07 f0 73 5e  |3....I....(...s^|
+00000330  60 03 2c 6f 3f e0 88 a1  76 22 d6 23 0a df ca 86  |`.,o?...v".#....|
+00000340  b0 44 b9 1d 9a d7 53 f2  2b 57 a1 65 01 d4 e7 b4  |.D....S.+W.e....|
+00000350  9e 22 00 d2 20 da cd 55  7d 61 86 86 19 81 f9 ed  |.".. ..U}a......|
+00000360  f8 af c4 69 54 1d 35 0a  6f 9e 69 40 13 08 82 dd  |...iT.5.o.i@....|
+00000370  59 11 31 f2 81 a7 4b f1  bd d9 f2 5c 29 22 16 49  |Y.1...K....\)".I|
+00000380  86 62 8c a8 b8 89 58 96  cc d1 e4 e8 5e ef 6c b7  |.b....X.....^.l.|
+00000390  00 71 3d ab 92 b8 78 56  a7 25 5e a0 c4 d8 8c 02  |.q=...xV.%^.....|
+000003a0  c4 c8 eb d3 be 68 21 05  5c 5f 9c b0 ec 20 99 ff  |.....h!.\_... ..|
+000003b0  00 17 03 03 00 35 c9 c1  5e 25 1c b9 64 8e c2 fd  |.....5..^%..d...|
+000003c0  50 87 48 e6 02 36 75 31  67 f6 82 3c 94 79 7d 0b  |P.H..6u1g..<.y}.|
+000003d0  cb 83 b1 f4 e1 00 5f a6  b6 2c 2d 63 40 ab 98 f9  |......_..,-c@...|
+000003e0  e3 8e 4a 7e d4 77 3d 55  90 10 75 17 03 03 00 93  |..J~.w=U..u.....|
+000003f0  47 c4 6e 19 29 c2 5e d5  93 b7 c2 cc 46 a9 49 9d  |G.n.).^.....F.I.|
+00000400  8a 3b 9a 35 bb 45 22 13  b6 eb c9 ec ba 44 3c 24  |.;.5.E"......D<$|
+00000410  f2 ed bd 76 11 cc af 00  b3 89 63 5d 79 32 cc d7  |...v......c]y2..|
+00000420  5c 34 f3 5e 64 36 92 5d  ac ac 33 74 f4 3d c4 b8  |\4.^d6.]..3t.=..|
+00000430  4d ac d0 49 4e 59 1c 16  74 8c 43 94 4b 13 b9 22  |M..INY..t.C.K.."|
+00000440  de d7 ee 30 09 63 f3 32  5f a2 9d a1 20 ea ee 91  |...0.c.2_... ...|
+00000450  ca d8 01 33 df 43 19 69  63 ee 6a 2c 80 99 ad f0  |...3.C.ic.j,....|
+00000460  5e 20 b6 b6 81 28 b6 9d  4a 9a 91 30 30 04 c1 70  |^ ...(..J..00..p|
+00000470  68 54 1e e0 72 00 4c fd  23 a8 41 a2 6a ab a3 01  |hT..r.L.#.A.j...|
+00000480  7a 40 1a                                          |z@.|
+>>> Flow 3 (client to server)
+00000000  14 03 03 00 01 01 17 03  03 00 35 20 1f 0d 20 a8  |..........5 .. .|
+00000010  34 c4 dc fa f9 d6 2b fe  01 eb f1 54 f0 14 c2 2d  |4.....+....T...-|
+00000020  bb 59 db 04 96 f2 18 8b  bd 7e b0 38 b7 15 b5 d8  |.Y.......~.8....|
+00000030  6b f2 80 25 40 f6 97 67  fb 9e 5a 5c ad 33 c6 5f  |k..%@..g..Z\.3._|
+>>> Flow 4 (server to client)
+00000000  17 03 03 00 1e 3a 8a fc  60 3a 99 ee b6 01 b7 fe  |.....:..`:......|
+00000010  54 a9 2d 34 28 ae af 3b  6a bd e0 32 6b df 87 fe  |T.-4(..;j..2k...|
+00000020  d0 97 8d 17 03 03 00 13  c6 89 d5 ae 4c fa d5 71  |............L..q|
+00000030  66 6e 07 b5 9b 00 e8 50  7e b9 5f                 |fn.....P~._|
-- 
GitLab


From f39997b2bebd54416bfb437fa1484fd8a5f43abb Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Thu, 6 May 2021 12:24:32 -0400
Subject: [PATCH 1996/2400] cmd/link: split large text sections on Darwin/ARM64
 when external linking

The Darwin linker does not like text sections that are larger
than the jump limit (even if we already inserted trampolines).
Split the text section to multiple smaller sections.

Now external linking very large binaries works on Darwin/ARM64.

Updates #40492.

Change-Id: I584f1ec673170c5e4d2dc1e00c701964d6f14333
Reviewed-on: https://go-review.googlesource.com/c/go/+/316050
Trust: Cherry Mui <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/ld/data.go    | 63 +++++++++++++++++++----------
 src/cmd/link/internal/ld/ld_test.go | 22 ++++++----
 src/cmd/link/internal/ld/macho.go   |  6 ++-
 src/cmd/link/internal/ld/main.go    |  2 +-
 4 files changed, 61 insertions(+), 32 deletions(-)

diff --git a/src/cmd/link/internal/ld/data.go b/src/cmd/link/internal/ld/data.go
index 1c3af94692..6659e95cc1 100644
--- a/src/cmd/link/internal/ld/data.go
+++ b/src/cmd/link/internal/ld/data.go
@@ -67,7 +67,7 @@ func isRuntimeDepPkg(pkg string) bool {
 // Estimate the max size needed to hold any new trampolines created for this function. This
 // is used to determine when the section can be split if it becomes too large, to ensure that
 // the trampolines are in the same section as the function that uses them.
-func maxSizeTrampolinesPPC64(ldr *loader.Loader, s loader.Sym, isTramp bool) uint64 {
+func maxSizeTrampolines(ctxt *Link, ldr *loader.Loader, s loader.Sym, isTramp bool) uint64 {
 	// If thearch.Trampoline is nil, then trampoline support is not available on this arch.
 	// A trampoline does not need any dependent trampolines.
 	if thearch.Trampoline == nil || isTramp {
@@ -82,8 +82,14 @@ func maxSizeTrampolinesPPC64(ldr *loader.Loader, s loader.Sym, isTramp bool) uin
 			n++
 		}
 	}
-	// Trampolines in ppc64 are 4 instructions.
-	return n * 16
+
+	if ctxt.IsPPC64() {
+		return n * 16 // Trampolines in PPC64 are 4 instructions.
+	}
+	if ctxt.IsARM64() {
+		return n * 12 // Trampolines in ARM64 are 3 instructions.
+	}
+	panic("unreachable")
 }
 
 // detect too-far jumps in function s, and add trampolines if necessary
@@ -2348,15 +2354,11 @@ func assignAddress(ctxt *Link, sect *sym.Section, n int, s loader.Sym, va uint64
 		funcsize = uint64(ldr.SymSize(s))
 	}
 
-	// On ppc64x a text section should not be larger than 2^26 bytes due to the size of
-	// call target offset field in the bl instruction.  Splitting into smaller text
-	// sections smaller than this limit allows the GNU linker to modify the long calls
-	// appropriately. The limit allows for the space needed for tables inserted by the linker.
-	//
-	// If this function doesn't fit in the current text section, then create a new one.
+	// If we need to split text sections, and this function doesn't fit in the current
+	// section, then create a new one.
 	//
 	// Only break at outermost syms.
-	if ctxt.Arch.InFamily(sys.PPC64) && ldr.OuterSym(s) == 0 && ctxt.IsExternal() && big {
+	if big && splitTextSections(ctxt) && ldr.OuterSym(s) == 0 {
 		// For debugging purposes, allow text size limit to be cranked down,
 		// so as to stress test the code that handles multiple text sections.
 		var textSizelimit uint64 = thearch.TrampLimit
@@ -2367,18 +2369,22 @@ func assignAddress(ctxt *Link, sect *sym.Section, n int, s loader.Sym, va uint64
 		// Sanity check: make sure the limit is larger than any
 		// individual text symbol.
 		if funcsize > textSizelimit {
-			panic(fmt.Sprintf("error: ppc64 text size limit %d less than text symbol %s size of %d", textSizelimit, ldr.SymName(s), funcsize))
+			panic(fmt.Sprintf("error: text size limit %d less than text symbol %s size of %d", textSizelimit, ldr.SymName(s), funcsize))
 		}
 
-		if va-sect.Vaddr+funcsize+maxSizeTrampolinesPPC64(ldr, s, isTramp) > textSizelimit {
-			// Align the next text section to the worst case function alignment likely
-			// to be encountered when processing function symbols. The start address
-			// is rounded against the final alignment of the text section later on in
-			// (*Link).address. This may happen due to usage of PCALIGN directives
-			// larger than Funcalign, or usage of ISA 3.1 prefixed instructions
-			// (see ISA 3.1 Book I 1.9).
-			const ppc64maxFuncalign = 64
-			va = uint64(Rnd(int64(va), ppc64maxFuncalign))
+		if va-sect.Vaddr+funcsize+maxSizeTrampolines(ctxt, ldr, s, isTramp) > textSizelimit {
+			sectAlign := int32(thearch.Funcalign)
+			if ctxt.IsPPC64() {
+				// Align the next text section to the worst case function alignment likely
+				// to be encountered when processing function symbols. The start address
+				// is rounded against the final alignment of the text section later on in
+				// (*Link).address. This may happen due to usage of PCALIGN directives
+				// larger than Funcalign, or usage of ISA 3.1 prefixed instructions
+				// (see ISA 3.1 Book I 1.9).
+				const ppc64maxFuncalign = 64
+				sectAlign = ppc64maxFuncalign
+				va = uint64(Rnd(int64(va), ppc64maxFuncalign))
+			}
 
 			// Set the length for the previous text section
 			sect.Length = va - sect.Vaddr
@@ -2387,7 +2393,7 @@ func assignAddress(ctxt *Link, sect *sym.Section, n int, s loader.Sym, va uint64
 			sect = addsection(ctxt.loader, ctxt.Arch, &Segtext, ".text", 05)
 
 			sect.Vaddr = va
-			sect.Align = ppc64maxFuncalign
+			sect.Align = sectAlign
 			ldr.SetSymSect(s, sect)
 
 			// Create a symbol for the start of the secondary text sections
@@ -2400,7 +2406,7 @@ func assignAddress(ctxt *Link, sect *sym.Section, n int, s loader.Sym, va uint64
 				ntext.SetType(sym.STEXT)
 				ntext.SetSize(int64(MINFUNC))
 				ntext.SetOnList(true)
-				ntext.SetAlign(ppc64maxFuncalign)
+				ntext.SetAlign(sectAlign)
 				ctxt.tramps = append(ctxt.tramps, ntext.Sym())
 
 				ntext.SetValue(int64(va))
@@ -2429,6 +2435,19 @@ func assignAddress(ctxt *Link, sect *sym.Section, n int, s loader.Sym, va uint64
 	return sect, n, va
 }
 
+// Return whether we may need to split text sections.
+//
+// On PPC64x whem external linking a text section should not be larger than 2^25 bytes
+// due to the size of call target offset field in the bl instruction.  Splitting into
+// smaller text sections smaller than this limit allows the system linker to modify the long
+// calls appropriately. The limit allows for the space needed for tables inserted by the
+// linker.
+//
+// The same applies to Darwin/ARM64, with 2^27 byte threshold.
+func splitTextSections(ctxt *Link) bool {
+	return (ctxt.IsPPC64() || (ctxt.IsARM64() && ctxt.IsDarwin())) && ctxt.IsExternal()
+}
+
 // address assigns virtual addresses to all segments and sections and
 // returns all segments in file order.
 func (ctxt *Link) address() []*sym.Segment {
diff --git a/src/cmd/link/internal/ld/ld_test.go b/src/cmd/link/internal/ld/ld_test.go
index f3725cbc6a..ca764632c3 100644
--- a/src/cmd/link/internal/ld/ld_test.go
+++ b/src/cmd/link/internal/ld/ld_test.go
@@ -131,10 +131,16 @@ func TestArchiveBuildInvokeWithExec(t *testing.T) {
 	}
 }
 
-func TestPPC64LargeTextSectionSplitting(t *testing.T) {
-	// The behavior we're checking for is of interest only on ppc64.
-	if !strings.HasPrefix(runtime.GOARCH, "ppc64") {
-		t.Skip("test useful only for ppc64")
+func TestLargeTextSectionSplitting(t *testing.T) {
+	switch runtime.GOARCH {
+	case "ppc64", "ppc64le":
+	case "arm64":
+		if runtime.GOOS == "darwin" {
+			break
+		}
+		fallthrough
+	default:
+		t.Skipf("text section splitting is not done in %s/%s", runtime.GOOS, runtime.GOARCH)
 	}
 
 	testenv.MustHaveGoBuild(t)
@@ -142,13 +148,13 @@ func TestPPC64LargeTextSectionSplitting(t *testing.T) {
 	t.Parallel()
 	dir := t.TempDir()
 
-	// NB: the use of -ldflags=-debugppc64textsize=1048576 tells the linker to
+	// NB: the use of -ldflags=-debugtextsize=1048576 tells the linker to
 	// split text sections at a size threshold of 1M instead of the
-	// architected limit of 67M. The choice of building cmd/go is
-	// arbitrary; we just need something sufficiently large that uses
+	// architected limit of 67M or larger. The choice of building cmd/go
+	// is arbitrary; we just need something sufficiently large that uses
 	// external linking.
 	exe := filepath.Join(dir, "go.exe")
-	out, eerr := exec.Command(testenv.GoToolPath(t), "build", "-o", exe, "-ldflags=-linkmode=external -debugppc64textsize=1048576", "cmd/go").CombinedOutput()
+	out, eerr := exec.Command(testenv.GoToolPath(t), "build", "-o", exe, "-ldflags=-linkmode=external -debugtextsize=1048576", "cmd/go").CombinedOutput()
 	if eerr != nil {
 		t.Fatalf("build failure: %s\n%s\n", eerr, string(out))
 	}
diff --git a/src/cmd/link/internal/ld/macho.go b/src/cmd/link/internal/ld/macho.go
index 000bb0b853..642113cf07 100644
--- a/src/cmd/link/internal/ld/macho.go
+++ b/src/cmd/link/internal/ld/macho.go
@@ -1241,7 +1241,11 @@ func machoEmitReloc(ctxt *Link) {
 
 	relocSect(ctxt, Segtext.Sections[0], ctxt.Textp)
 	for _, sect := range Segtext.Sections[1:] {
-		relocSect(ctxt, sect, ctxt.datap)
+		if sect.Name == ".text" {
+			relocSect(ctxt, sect, ctxt.Textp)
+		} else {
+			relocSect(ctxt, sect, ctxt.datap)
+		}
 	}
 	for _, sect := range Segrelrodata.Sections {
 		relocSect(ctxt, sect, ctxt.datap)
diff --git a/src/cmd/link/internal/ld/main.go b/src/cmd/link/internal/ld/main.go
index 52dfe91993..adb39d0607 100644
--- a/src/cmd/link/internal/ld/main.go
+++ b/src/cmd/link/internal/ld/main.go
@@ -88,7 +88,7 @@ var (
 	flag8             bool // use 64-bit addresses in symbol table
 	flagInterpreter   = flag.String("I", "", "use `linker` as ELF dynamic linker")
 	FlagDebugTramp    = flag.Int("debugtramp", 0, "debug trampolines")
-	FlagDebugTextSize = flag.Int("debugppc64textsize", 0, "debug PPC64 text section max")
+	FlagDebugTextSize = flag.Int("debugtextsize", 0, "debug text section max size")
 	FlagStrictDups    = flag.Int("strictdups", 0, "sanity check duplicate symbol contents during object file reading (1=warn 2=err).")
 	FlagRound         = flag.Int("R", -1, "set address rounding `quantum`")
 	FlagTextAddr      = flag.Int64("T", -1, "set text segment `address`")
-- 
GitLab


From 4dbad795100bc0f5f9419bbb44b1ff0beb60a88c Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Thu, 6 May 2021 12:24:20 -0400
Subject: [PATCH 1997/2400] runtime: call unlockOSThread directly in Windows
 syscall functions

Windows syscall functions (e.g. syscall.Syscall9) are defined as
cgo_unsafe_args (because it takes the address of one argument and
use that to access all arguments) which makes them ABI0. In some
case we may need ABI wrappers for them. Because those functions
have a large number of arguments, the wrapper can take a
non-trivial amount of stack frame, causing nosplit overflow when
inlining is disabled. The overflow call chain involves
deferreturn.

This CL changes a deferred call to unlockOSThread to a direct
call. If the syscall functions panics, it is likely a fatal error
anyway.

Fixes #45698.

Change-Id: I280be826644de1205f9c8f5efaa4ec5e1b4eebc1
Reviewed-on: https://go-review.googlesource.com/c/go/+/316650
Trust: Cherry Mui <cherryyz@google.com>
Run-TryBot: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/syscall_windows.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/runtime/syscall_windows.go b/src/runtime/syscall_windows.go
index 6521bb2c41..6b9195bcd5 100644
--- a/src/runtime/syscall_windows.go
+++ b/src/runtime/syscall_windows.go
@@ -482,12 +482,12 @@ func syscall_Syscall6(fn, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err ui
 //go:cgo_unsafe_args
 func syscall_Syscall9(fn, nargs, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2, err uintptr) {
 	lockOSThread()
-	defer unlockOSThread()
 	c := &getg().m.syscall
 	c.fn = fn
 	c.n = nargs
 	c.args = uintptr(noescape(unsafe.Pointer(&a1)))
 	cgocall(asmstdcallAddr, unsafe.Pointer(c))
+	unlockOSThread()
 	return c.r1, c.r2, c.err
 }
 
@@ -496,12 +496,12 @@ func syscall_Syscall9(fn, nargs, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1
 //go:cgo_unsafe_args
 func syscall_Syscall12(fn, nargs, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12 uintptr) (r1, r2, err uintptr) {
 	lockOSThread()
-	defer unlockOSThread()
 	c := &getg().m.syscall
 	c.fn = fn
 	c.n = nargs
 	c.args = uintptr(noescape(unsafe.Pointer(&a1)))
 	cgocall(asmstdcallAddr, unsafe.Pointer(c))
+	unlockOSThread()
 	return c.r1, c.r2, c.err
 }
 
@@ -510,12 +510,12 @@ func syscall_Syscall12(fn, nargs, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
 //go:cgo_unsafe_args
 func syscall_Syscall15(fn, nargs, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) {
 	lockOSThread()
-	defer unlockOSThread()
 	c := &getg().m.syscall
 	c.fn = fn
 	c.n = nargs
 	c.args = uintptr(noescape(unsafe.Pointer(&a1)))
 	cgocall(asmstdcallAddr, unsafe.Pointer(c))
+	unlockOSThread()
 	return c.r1, c.r2, c.err
 }
 
@@ -524,11 +524,11 @@ func syscall_Syscall15(fn, nargs, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
 //go:cgo_unsafe_args
 func syscall_Syscall18(fn, nargs, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18 uintptr) (r1, r2, err uintptr) {
 	lockOSThread()
-	defer unlockOSThread()
 	c := &getg().m.syscall
 	c.fn = fn
 	c.n = nargs
 	c.args = uintptr(noescape(unsafe.Pointer(&a1)))
 	cgocall(asmstdcallAddr, unsafe.Pointer(c))
+	unlockOSThread()
 	return c.r1, c.r2, c.err
 }
-- 
GitLab


From a11a1711b085e5035d42cde49f88bbbab8b36550 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 5 May 2021 23:03:22 -0400
Subject: [PATCH 1998/2400] go/types: expose types.Info.Inferred with
 -tags=typeparams

Our workaround to get and set types.Info._Inferred makes it harder to
experiment with the new APIs in x/tools.

Instead, just make a copy of the types.Info struct, so that the Inferred
field is accessible when the typeparams build tag is set.

This is a trivially safe change: the only change when not building with
-tags=typeparams is that types.Info._Inferred is removed, and accessing
inferred type information goes through an additional layer of
indirection.

For #46003

Change-Id: I38f2bbb2c80aed28be31d0fe762ccead970476ca
Reviewed-on: https://go-review.googlesource.com/c/go/+/317549
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/api.go                 |  96 +------------------------
 src/go/types/api_notypeparams.go    | 104 ++++++++++++++++++++++++++++
 src/go/types/api_typeparams.go      |  30 +++++---
 src/go/types/api_typeparams_test.go |   4 +-
 src/go/types/check.go               |   2 +-
 src/go/types/sanitize.go            |   5 +-
 6 files changed, 133 insertions(+), 108 deletions(-)
 create mode 100644 src/go/types/api_notypeparams.go

diff --git a/src/go/types/api.go b/src/go/types/api.go
index da23c8c52a..ed62a785d6 100644
--- a/src/go/types/api.go
+++ b/src/go/types/api.go
@@ -160,101 +160,7 @@ func srcimporter_setUsesCgo(conf *Config) {
 	conf.go115UsesCgo = true
 }
 
-// Info holds result type information for a type-checked package.
-// Only the information for which a map is provided is collected.
-// If the package has type errors, the collected information may
-// be incomplete.
-type Info struct {
-	// Types maps expressions to their types, and for constant
-	// expressions, also their values. Invalid expressions are
-	// omitted.
-	//
-	// For (possibly parenthesized) identifiers denoting built-in
-	// functions, the recorded signatures are call-site specific:
-	// if the call result is not a constant, the recorded type is
-	// an argument-specific signature. Otherwise, the recorded type
-	// is invalid.
-	//
-	// The Types map does not record the type of every identifier,
-	// only those that appear where an arbitrary expression is
-	// permitted. For instance, the identifier f in a selector
-	// expression x.f is found only in the Selections map, the
-	// identifier z in a variable declaration 'var z int' is found
-	// only in the Defs map, and identifiers denoting packages in
-	// qualified identifiers are collected in the Uses map.
-	Types map[ast.Expr]TypeAndValue
-
-	// _Inferred maps calls of parameterized functions that use
-	// type inference to the _Inferred type arguments and signature
-	// of the function called. The recorded "call" expression may be
-	// an *ast.CallExpr (as in f(x)), or an *ast.IndexExpr (s in f[T]).
-	_Inferred map[ast.Expr]_Inferred
-
-	// Defs maps identifiers to the objects they define (including
-	// package names, dots "." of dot-imports, and blank "_" identifiers).
-	// For identifiers that do not denote objects (e.g., the package name
-	// in package clauses, or symbolic variables t in t := x.(type) of
-	// type switch headers), the corresponding objects are nil.
-	//
-	// For an embedded field, Defs returns the field *Var it defines.
-	//
-	// Invariant: Defs[id] == nil || Defs[id].Pos() == id.Pos()
-	Defs map[*ast.Ident]Object
-
-	// Uses maps identifiers to the objects they denote.
-	//
-	// For an embedded field, Uses returns the *TypeName it denotes.
-	//
-	// Invariant: Uses[id].Pos() != id.Pos()
-	Uses map[*ast.Ident]Object
-
-	// Implicits maps nodes to their implicitly declared objects, if any.
-	// The following node and object types may appear:
-	//
-	//     node               declared object
-	//
-	//     *ast.ImportSpec    *PkgName for imports without renames
-	//     *ast.CaseClause    type-specific *Var for each type switch case clause (incl. default)
-	//     *ast.Field         anonymous parameter *Var (incl. unnamed results)
-	//
-	Implicits map[ast.Node]Object
-
-	// Selections maps selector expressions (excluding qualified identifiers)
-	// to their corresponding selections.
-	Selections map[*ast.SelectorExpr]*Selection
-
-	// Scopes maps ast.Nodes to the scopes they define. Package scopes are not
-	// associated with a specific node but with all files belonging to a package.
-	// Thus, the package scope can be found in the type-checked Package object.
-	// Scopes nest, with the Universe scope being the outermost scope, enclosing
-	// the package scope, which contains (one or more) files scopes, which enclose
-	// function scopes which in turn enclose statement and function literal scopes.
-	// Note that even though package-level functions are declared in the package
-	// scope, the function scopes are embedded in the file scope of the file
-	// containing the function declaration.
-	//
-	// The following node types may appear in Scopes:
-	//
-	//     *ast.File
-	//     *ast.FuncType
-	//     *ast.BlockStmt
-	//     *ast.IfStmt
-	//     *ast.SwitchStmt
-	//     *ast.TypeSwitchStmt
-	//     *ast.CaseClause
-	//     *ast.CommClause
-	//     *ast.ForStmt
-	//     *ast.RangeStmt
-	//
-	Scopes map[ast.Node]*Scope
-
-	// InitOrder is the list of package-level initializers in the order in which
-	// they must be executed. Initializers referring to variables related by an
-	// initialization dependency appear in topological order, the others appear
-	// in source order. Variables without an initialization expression do not
-	// appear in this list.
-	InitOrder []*Initializer
-}
+// The Info struct is found in api_notypeparams.go and api_typeparams.go.
 
 // TypeOf returns the type of expression e, or nil if not found.
 // Precondition: the Types, Uses and Defs maps are populated.
diff --git a/src/go/types/api_notypeparams.go b/src/go/types/api_notypeparams.go
new file mode 100644
index 0000000000..9f7cb7eccf
--- /dev/null
+++ b/src/go/types/api_notypeparams.go
@@ -0,0 +1,104 @@
+// Copyright 2021 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.
+
+//go:build !typeparams
+// +build !typeparams
+
+package types
+
+import "go/ast"
+
+// Info holds result type information for a type-checked package.
+// Only the information for which a map is provided is collected.
+// If the package has type errors, the collected information may
+// be incomplete.
+type Info struct {
+	// Types maps expressions to their types, and for constant
+	// expressions, also their values. Invalid expressions are
+	// omitted.
+	//
+	// For (possibly parenthesized) identifiers denoting built-in
+	// functions, the recorded signatures are call-site specific:
+	// if the call result is not a constant, the recorded type is
+	// an argument-specific signature. Otherwise, the recorded type
+	// is invalid.
+	//
+	// The Types map does not record the type of every identifier,
+	// only those that appear where an arbitrary expression is
+	// permitted. For instance, the identifier f in a selector
+	// expression x.f is found only in the Selections map, the
+	// identifier z in a variable declaration 'var z int' is found
+	// only in the Defs map, and identifiers denoting packages in
+	// qualified identifiers are collected in the Uses map.
+	Types map[ast.Expr]TypeAndValue
+
+	// Defs maps identifiers to the objects they define (including
+	// package names, dots "." of dot-imports, and blank "_" identifiers).
+	// For identifiers that do not denote objects (e.g., the package name
+	// in package clauses, or symbolic variables t in t := x.(type) of
+	// type switch headers), the corresponding objects are nil.
+	//
+	// For an embedded field, Defs returns the field *Var it defines.
+	//
+	// Invariant: Defs[id] == nil || Defs[id].Pos() == id.Pos()
+	Defs map[*ast.Ident]Object
+
+	// Uses maps identifiers to the objects they denote.
+	//
+	// For an embedded field, Uses returns the *TypeName it denotes.
+	//
+	// Invariant: Uses[id].Pos() != id.Pos()
+	Uses map[*ast.Ident]Object
+
+	// Implicits maps nodes to their implicitly declared objects, if any.
+	// The following node and object types may appear:
+	//
+	//     node               declared object
+	//
+	//     *ast.ImportSpec    *PkgName for imports without renames
+	//     *ast.CaseClause    type-specific *Var for each type switch case clause (incl. default)
+	//     *ast.Field         anonymous parameter *Var (incl. unnamed results)
+	//
+	Implicits map[ast.Node]Object
+
+	// Selections maps selector expressions (excluding qualified identifiers)
+	// to their corresponding selections.
+	Selections map[*ast.SelectorExpr]*Selection
+
+	// Scopes maps ast.Nodes to the scopes they define. Package scopes are not
+	// associated with a specific node but with all files belonging to a package.
+	// Thus, the package scope can be found in the type-checked Package object.
+	// Scopes nest, with the Universe scope being the outermost scope, enclosing
+	// the package scope, which contains (one or more) files scopes, which enclose
+	// function scopes which in turn enclose statement and function literal scopes.
+	// Note that even though package-level functions are declared in the package
+	// scope, the function scopes are embedded in the file scope of the file
+	// containing the function declaration.
+	//
+	// The following node types may appear in Scopes:
+	//
+	//     *ast.File
+	//     *ast.FuncType
+	//     *ast.BlockStmt
+	//     *ast.IfStmt
+	//     *ast.SwitchStmt
+	//     *ast.TypeSwitchStmt
+	//     *ast.CaseClause
+	//     *ast.CommClause
+	//     *ast.ForStmt
+	//     *ast.RangeStmt
+	//
+	Scopes map[ast.Node]*Scope
+
+	// InitOrder is the list of package-level initializers in the order in which
+	// they must be executed. Initializers referring to variables related by an
+	// initialization dependency appear in topological order, the others appear
+	// in source order. Variables without an initialization expression do not
+	// appear in this list.
+	InitOrder []*Initializer
+}
+
+func getInferred(info *Info) map[ast.Expr]_Inferred {
+	return nil
+}
diff --git a/src/go/types/api_typeparams.go b/src/go/types/api_typeparams.go
index 639bc3b3bf..ed744c4dba 100644
--- a/src/go/types/api_typeparams.go
+++ b/src/go/types/api_typeparams.go
@@ -17,14 +17,6 @@ type (
 	TypeParam = _TypeParam
 )
 
-func GetInferred(info *Info) map[ast.Expr]Inferred {
-	return info._Inferred
-}
-
-func SetInferred(info *Info, inferred map[ast.Expr]Inferred) {
-	info._Inferred = inferred
-}
-
 func NewSum(types []Type) Type { return _NewSum(types) }
 
 func (s *Signature) TParams() []*TypeName           { return s._TParams() }
@@ -37,3 +29,25 @@ func (t *Interface) IsConstraint() bool { return t._IsConstraint() }
 func (t *Named) TParams() []*TypeName { return t._TParams() }
 func (t *Named) TArgs() []Type        { return t._TArgs() }
 func (t *Named) SetTArgs(args []Type) { t._SetTArgs(args) }
+
+// Info is documented in api_notypeparams.go.
+type Info struct {
+	Types map[ast.Expr]TypeAndValue
+
+	// Inferred maps calls of parameterized functions that use type inference to
+	// the Inferred type arguments and signature of the function called. The
+	// recorded "call" expression may be an *ast.CallExpr (as in f(x)), or an
+	// *ast.IndexExpr (s in f[T]).
+	Inferred map[ast.Expr]_Inferred
+
+	Defs       map[*ast.Ident]Object
+	Uses       map[*ast.Ident]Object
+	Implicits  map[ast.Node]Object
+	Selections map[*ast.SelectorExpr]*Selection
+	Scopes     map[ast.Node]*Scope
+	InitOrder  []*Initializer
+}
+
+func getInferred(info *Info) map[ast.Expr]_Inferred {
+	return info.Inferred
+}
diff --git a/src/go/types/api_typeparams_test.go b/src/go/types/api_typeparams_test.go
index e6cccf8691..15c9bf09f9 100644
--- a/src/go/types/api_typeparams_test.go
+++ b/src/go/types/api_typeparams_test.go
@@ -88,7 +88,7 @@ func TestInferredInfo(t *testing.T) {
 
 	for _, test := range tests {
 		info := Info{}
-		SetInferred(&info, make(map[ast.Expr]Inferred))
+		info.Inferred = make(map[ast.Expr]Inferred)
 		name, err := mayTypecheck(t, "InferredInfo", test.src, &info)
 		if err != nil {
 			t.Errorf("package %s: %v", name, err)
@@ -98,7 +98,7 @@ func TestInferredInfo(t *testing.T) {
 		// look for inferred type arguments and signature
 		var targs []Type
 		var sig *Signature
-		for call, inf := range GetInferred(&info) {
+		for call, inf := range info.Inferred {
 			var fun ast.Expr
 			switch x := call.(type) {
 			case *ast.CallExpr:
diff --git a/src/go/types/check.go b/src/go/types/check.go
index 1f64d3e3c3..25ea4906be 100644
--- a/src/go/types/check.go
+++ b/src/go/types/check.go
@@ -411,7 +411,7 @@ func (check *Checker) recordCommaOkTypes(x ast.Expr, a [2]Type) {
 func (check *Checker) recordInferred(call ast.Expr, targs []Type, sig *Signature) {
 	assert(call != nil)
 	assert(sig != nil)
-	if m := check._Inferred; m != nil {
+	if m := getInferred(check.Info); m != nil {
 		m[call] = _Inferred{targs, sig}
 	}
 }
diff --git a/src/go/types/sanitize.go b/src/go/types/sanitize.go
index b905972d36..5970ab38c7 100644
--- a/src/go/types/sanitize.go
+++ b/src/go/types/sanitize.go
@@ -24,7 +24,8 @@ func sanitizeInfo(info *Info) {
 		}
 	}
 
-	for e, inf := range info._Inferred {
+	inferred := getInferred(info)
+	for e, inf := range inferred {
 		changed := false
 		for i, targ := range inf.Targs {
 			if typ := s.typ(targ); typ != targ {
@@ -37,7 +38,7 @@ func sanitizeInfo(info *Info) {
 			changed = true
 		}
 		if changed {
-			info._Inferred[e] = inf
+			inferred[e] = inf
 		}
 	}
 
-- 
GitLab


From 9524e93adf9807ab3c23d09a6b8c0aa8dd98f9ab Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 6 May 2021 09:01:07 -0400
Subject: [PATCH 1999/2400] go/types: add a test case for issue 45985

The fix for #45985 is a little subtle. Start by committing the (bad)
test case.

For #45985

Change-Id: Ia6625818e9b1c5e869b2c2f724f817c13c9944d1
Reviewed-on: https://go-review.googlesource.com/c/go/+/317471
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/infer.go                          |  4 ++--
 src/go/types/testdata/fixedbugs/issue45985.go2 | 14 ++++++++++++++
 2 files changed, 16 insertions(+), 2 deletions(-)
 create mode 100644 src/go/types/testdata/fixedbugs/issue45985.go2

diff --git a/src/go/types/infer.go b/src/go/types/infer.go
index da3a521870..5d49351e1f 100644
--- a/src/go/types/infer.go
+++ b/src/go/types/infer.go
@@ -398,7 +398,7 @@ func (check *Checker) inferB(tparams []*TypeName, targs []Type, report bool) (ty
 		if sbound != nil {
 			if !u.unify(typ, sbound) {
 				if report {
-					check.errorf(tpar, 0, "%s does not match %s", tpar, sbound)
+					check.errorf(tpar, _Todo, "%s does not match %s", tpar, sbound)
 				}
 				return nil, 0
 			}
@@ -412,7 +412,7 @@ func (check *Checker) inferB(tparams []*TypeName, targs []Type, report bool) (ty
 	// was given, unification produced the type list [int, []C, *A]. We eliminate the
 	// remaining type parameters by substituting the type parameters in this type list
 	// until nothing changes anymore.
-	types, index = u.x.types()
+	types, _ = u.x.types()
 	if debug {
 		for i, targ := range targs {
 			assert(targ == nil || types[i] == targ)
diff --git a/src/go/types/testdata/fixedbugs/issue45985.go2 b/src/go/types/testdata/fixedbugs/issue45985.go2
new file mode 100644
index 0000000000..550b9c6712
--- /dev/null
+++ b/src/go/types/testdata/fixedbugs/issue45985.go2
@@ -0,0 +1,14 @@
+// Copyright 2021 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 issue45985
+
+// TODO(rFindley): this error should be on app[int] below.
+func app[S /* ERROR "type S = S does not match" */ interface{ type []T }, T any](s S, e T) S {
+    return append(s, e)
+}
+
+func _() {
+	_ = app[int]
+}
-- 
GitLab


From d2b03111c44db5808ef5248470bf95fe7ea35ebc Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 6 May 2021 20:36:10 -0400
Subject: [PATCH 2000/2400] go/types,cmd/compile/internal/types2: unskip std
 and cmd in TestStdlib

CL 276272 accidentally skipped everything in TestStdlib while trying to
skip nested submodules of std and cmd.

For now, narrow the skip to just the problematic submodule rather than
trying to generalize. We can re-evaluate if it becomes a pattern to
vendor submodules in this way.

Fixes #46027

Change-Id: Ib355ff80dfbf17c3cf37d128a2f48d4216305267
Reviewed-on: https://go-review.googlesource.com/c/go/+/317869
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/types2/stdlib_test.go | 10 +++-------
 src/go/types/stdlib_test.go                    | 10 +++-------
 2 files changed, 6 insertions(+), 14 deletions(-)

diff --git a/src/cmd/compile/internal/types2/stdlib_test.go b/src/cmd/compile/internal/types2/stdlib_test.go
index 7d6753e5c2..cde35c17b6 100644
--- a/src/cmd/compile/internal/types2/stdlib_test.go
+++ b/src/cmd/compile/internal/types2/stdlib_test.go
@@ -204,6 +204,9 @@ func TestStdKen(t *testing.T) {
 // Package paths of excluded packages.
 var excluded = map[string]bool{
 	"builtin": true,
+
+	// See #46027: some imports are missing for this submodule.
+	"crypto/ed25519/internal/edwards25519/field/_asm": true,
 }
 
 // typecheck typechecks the given package files.
@@ -301,13 +304,6 @@ func (w *walker) walk(dir string) {
 		return
 	}
 
-	// skip submodules, which might not be vendored
-	for _, f := range files {
-		if f.Name() == "go.mod" {
-			return
-		}
-	}
-
 	// apply pkgh to the files in directory dir
 	// but ignore files directly under $GOROOT/src (might be temporary test files).
 	if dir != filepath.Join(runtime.GOROOT(), "src") {
diff --git a/src/go/types/stdlib_test.go b/src/go/types/stdlib_test.go
index b565956e08..3dea8dcf1e 100644
--- a/src/go/types/stdlib_test.go
+++ b/src/go/types/stdlib_test.go
@@ -200,6 +200,9 @@ func TestStdKen(t *testing.T) {
 // Package paths of excluded packages.
 var excluded = map[string]bool{
 	"builtin": true,
+
+	// See #46027: some imports are missing for this submodule.
+	"crypto/ed25519/internal/edwards25519/field/_asm": true,
 }
 
 // typecheck typechecks the given package files.
@@ -306,13 +309,6 @@ func (w *walker) walk(dir string) {
 		return
 	}
 
-	// skip submodules, which might not be vendored
-	for _, f := range files {
-		if f.Name() == "go.mod" {
-			return
-		}
-	}
-
 	// apply pkgh to the files in directory dir
 	// but ignore files directly under $GOROOT/src (might be temporary test files).
 	if dir != filepath.Join(runtime.GOROOT(), "src") {
-- 
GitLab


From 832c70e33d8265116f0abce436215b8e9ee4bb08 Mon Sep 17 00:00:00 2001
From: Andy Pan <panjf2000@gmail.com>
Date: Thu, 6 May 2021 23:15:37 +0800
Subject: [PATCH 2001/2400] internal/poll: cast off the last reference of
 SplicePipe in test

Updates #45059

Change-Id: I9f377abcc7b77136ae6cf4896b968f73c758b559
Reviewed-on: https://go-review.googlesource.com/c/go/+/317510
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/internal/poll/splice_linux_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/internal/poll/splice_linux_test.go b/src/internal/poll/splice_linux_test.go
index 3629ef1b20..280468c7e7 100644
--- a/src/internal/poll/splice_linux_test.go
+++ b/src/internal/poll/splice_linux_test.go
@@ -46,6 +46,7 @@ func TestSplicePipePool(t *testing.T) {
 		poll.PutPipe(p)
 	}
 	ps = nil
+	p = nil
 
 	// Exploit the timeout of "go test" as a timer for the subsequent verification.
 	timeout := 5 * time.Minute
-- 
GitLab


From f5423ea615b94455e4f6b9cbee491b492bf2e1fe Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 6 May 2021 14:46:40 -0700
Subject: [PATCH 2002/2400] cmd/compile/internal/types2: add test case for
 issue 45985

This is a port of https://golang.org/cl/317471.

Updates #45985.

Change-Id: I539d0fa6f9a77eb2fc169a21c5db9921f8eceb03
Reviewed-on: https://go-review.googlesource.com/c/go/+/317732
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/cmd/compile/internal/types2/infer.go           |  2 +-
 .../types2/testdata/fixedbugs/issue45985.go2       | 14 ++++++++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)
 create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue45985.go2

diff --git a/src/cmd/compile/internal/types2/infer.go b/src/cmd/compile/internal/types2/infer.go
index c136823fd8..f37d7f6477 100644
--- a/src/cmd/compile/internal/types2/infer.go
+++ b/src/cmd/compile/internal/types2/infer.go
@@ -417,7 +417,7 @@ func (check *Checker) inferB(tparams []*TypeName, targs []Type, report bool) (ty
 	// was given, unification produced the type list [int, []C, *A]. We eliminate the
 	// remaining type parameters by substituting the type parameters in this type list
 	// until nothing changes anymore.
-	types, index = u.x.types()
+	types, _ = u.x.types()
 	if debug {
 		for i, targ := range targs {
 			assert(targ == nil || types[i] == targ)
diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue45985.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue45985.go2
new file mode 100644
index 0000000000..7678e348ef
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue45985.go2
@@ -0,0 +1,14 @@
+// Copyright 2021 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 issue45985
+
+// TODO(gri): this error should be on app[int] below.
+func app[S /* ERROR "type S = S does not match" */ interface{ type []T }, T any](s S, e T) S {
+    return append(s, e)
+}
+
+func _() {
+	_ = app[int]
+}
-- 
GitLab


From bdb804466568c79e488a7b16f6ffd045f2dc6dfa Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Thu, 6 May 2021 16:16:19 -0400
Subject: [PATCH 2003/2400] cmd/link: don't include arginfo symbols in symbol
 table

We recently add arginfo symbols for traceback argument metadata.
Like other metadata symbols (GC bitmaps, opendefer info, etc.),
skip arginfo symbols for symbol table as well.

Fixes #45971.

Change-Id: I7a126b75f70ec88e2170e9a274d968762c7bce56
Reviewed-on: https://go-review.googlesource.com/c/go/+/317769
Trust: Cherry Mui <cherryyz@google.com>
Run-TryBot: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/ld/symtab.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/cmd/link/internal/ld/symtab.go b/src/cmd/link/internal/ld/symtab.go
index 3b4fda0c89..00f557875a 100644
--- a/src/cmd/link/internal/ld/symtab.go
+++ b/src/cmd/link/internal/ld/symtab.go
@@ -585,7 +585,9 @@ func (ctxt *Link) symtab(pcln *pclntab) []sym.SymKind {
 			strings.HasPrefix(name, "gclocals."),
 			strings.HasPrefix(name, "gclocals·"),
 			ldr.SymType(s) == sym.SGOFUNC && s != symgofunc,
-			strings.HasSuffix(name, ".opendefer"):
+			strings.HasSuffix(name, ".opendefer"),
+			strings.HasSuffix(name, ".arginfo0"),
+			strings.HasSuffix(name, ".arginfo1"):
 			symGroupType[s] = sym.SGOFUNC
 			ldr.SetAttrNotInSymbolTable(s, true)
 			ldr.SetCarrierSym(s, symgofunc)
-- 
GitLab


From a0eb662d85fd4815dfec3093e8205b9aed462507 Mon Sep 17 00:00:00 2001
From: Dmitri Shuralyov <dmitshur@golang.org>
Date: Thu, 6 May 2021 22:52:51 +0000
Subject: [PATCH 2004/2400] doc/go1.17: move language specification TODO to the
 right place

It was misplaced by the relnote tool.

Also add a TODO for CL 312212, per discussion in golang.org/issue/46020.

For #44513.
For #46020.

Change-Id: I8d766df969f85c351ead18df3e45adb6fb27b7a0
Reviewed-on: https://go-review.googlesource.com/c/go/+/317829
Trust: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Carlos Amedee <carlos@golang.org>
---
 doc/go1.17.html | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index f317006278..785092a8dd 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -25,8 +25,12 @@ Do not send CLs removing the interior tags from such phrases.
 
 <h2 id="language">Changes to the language</h2>
 
-<p>
-  TODO: complete this section
+<p><!-- CL 216424 -->
+  TODO: <a href="https://golang.org/cl/216424">https://golang.org/cl/216424</a>: allow conversion from slice to array ptr
+</p>
+
+<p><!-- CL 312212 -->
+  TODO: <a href="https://golang.org/cl/312212">https://golang.org/cl/312212</a>: add unsafe.Add and unsafe.Slice
 </p>
 
 <h2 id="ports">Ports</h2>
@@ -411,14 +415,6 @@ Do not send CLs removing the interior tags from such phrases.
   </dd>
 </dl><!-- reflect -->
 
-<dl id="spec"><dt><a href="/pkg/spec/">spec</a></dt>
-  <dd>
-    <p><!-- CL 216424 -->
-      TODO: <a href="https://golang.org/cl/216424">https://golang.org/cl/216424</a>: allow conversion from slice to array ptr
-    </p>
-  </dd>
-</dl><!-- spec -->
-
 <dl id="strconv"><dt><a href="/pkg/strconv/">strconv</a></dt>
   <dd>
     <p><!-- CL 170079 -->
-- 
GitLab


From 9bfa6f75d54a63c8c56cfb5c04d10937b27c4738 Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" <murp@ibm.com>
Date: Tue, 9 Mar 2021 16:55:16 -0600
Subject: [PATCH 2005/2400] cmd/internal/obj: consolidate MOVB cases with other
 MOV ops on ppc64

We can consolidate MOVB load handling with other MOV* loads. Only
Optab.Size bytes are copied from the slice returned by asmout. Thus,
we can an unconditionally append an extsb operation to the slice
modified by asmout. This extra instruction will only be copied into
the final instruction stream if Optab.Size is 4 bytes larger, as is
the case with MOVB loads.

This removes three extra special cases when loading a signed
byte.

Change-Id: I71f5324551a06a2c3fa28177109aafbe27f3e4cd
Reviewed-on: https://go-review.googlesource.com/c/go/+/314849
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
Reviewed-by: Carlos Eduardo Seo <carlos.seo@linaro.org>
Run-TryBot: Paul Murphy <murp@ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Carlos Eduardo Seo <carlos.seo@linaro.org>
---
 src/cmd/internal/obj/ppc64/asm9.go | 47 ++++++------------------------
 1 file changed, 9 insertions(+), 38 deletions(-)

diff --git a/src/cmd/internal/obj/ppc64/asm9.go b/src/cmd/internal/obj/ppc64/asm9.go
index 051663601a..69f967acfd 100644
--- a/src/cmd/internal/obj/ppc64/asm9.go
+++ b/src/cmd/internal/obj/ppc64/asm9.go
@@ -195,7 +195,7 @@ var optab = []Optab{
 	{as: AFMUL, a1: C_FREG, a2: C_FREG, a6: C_FREG, type_: 32, size: 4},
 
 	{as: AMOVBU, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
-	{as: AMOVBU, a1: C_SOREG, a6: C_REG, type_: 9, size: 8},
+	{as: AMOVBU, a1: C_SOREG, a6: C_REG, type_: 8, size: 8},
 
 	{as: AMOVBZU, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVBZU, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
@@ -203,9 +203,9 @@ var optab = []Optab{
 	{as: AMOVHBR, a1: C_REG, a6: C_ZOREG, type_: 44, size: 4},
 	{as: AMOVHBR, a1: C_ZOREG, a6: C_REG, type_: 45, size: 4},
 
-	{as: AMOVB, a1: C_ADDR, a6: C_REG, type_: 76, size: 12},
-	{as: AMOVB, a1: C_LOREG, a6: C_REG, type_: 37, size: 12},
-	{as: AMOVB, a1: C_SOREG, a6: C_REG, type_: 9, size: 8},
+	{as: AMOVB, a1: C_ADDR, a6: C_REG, type_: 75, size: 12},
+	{as: AMOVB, a1: C_LOREG, a6: C_REG, type_: 36, size: 12},
+	{as: AMOVB, a1: C_SOREG, a6: C_REG, type_: 8, size: 8},
 	{as: AMOVB, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 	{as: AMOVB, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 	{as: AMOVB, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
@@ -2477,7 +2477,7 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 			o1 = AOP_IRR(inst, uint32(p.From.Reg), uint32(r), uint32(v))
 		}
 
-	case 8: /* mov soreg, r ==> lbz/lhz/lwz o(r) */
+	case 8: /* mov soreg, r ==> lbz/lhz/lwz o(r), lbz o(r) + extsb r,r */
 		r := int(p.From.Reg)
 
 		if r == 0 {
@@ -2501,21 +2501,7 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 			o1 = AOP_IRR(inst, uint32(p.To.Reg), uint32(r), uint32(v))
 		}
 
-	case 9: /* movb soreg, r ==> lbz o(r),r2; extsb r2,r2 */
-		r := int(p.From.Reg)
-
-		if r == 0 {
-			r = c.getimpliedreg(&p.From, p)
-		}
-		v := c.regoff(&p.From)
-		if p.From.Type == obj.TYPE_MEM && p.From.Index != 0 {
-			if v != 0 {
-				c.ctxt.Diag("illegal indexed instruction\n%v", p)
-			}
-			o1 = AOP_RRR(c.oploadx(p.As), uint32(p.To.Reg), uint32(p.From.Index), uint32(r))
-		} else {
-			o1 = AOP_IRR(c.opload(p.As), uint32(p.To.Reg), uint32(r), uint32(v))
-		}
+		// Sign extend MOVB operations. This is ignored for other cases (o.size == 4).
 		o2 = LOP_RRR(OP_EXTSB, uint32(p.To.Reg), uint32(p.To.Reg), 0)
 
 	case 10: /* sub Ra,[Rb],Rd => subf Rd,Ra,Rb */
@@ -3050,7 +3036,7 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(v)))
 		o2 = AOP_IRR(inst, uint32(p.From.Reg), REGTMP, uint32(v))
 
-	case 36: /* mov bz/h/hz lext/lauto/lreg,r ==> lbz/lha/lhz etc */
+	case 36: /* mov b/bz/h/hz lext/lauto/lreg,r ==> lbz+extsb/lbz/lha/lhz etc */
 		v := c.regoff(&p.From)
 
 		r := int(p.From.Reg)
@@ -3060,15 +3046,7 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(v)))
 		o2 = AOP_IRR(c.opload(p.As), uint32(p.To.Reg), REGTMP, uint32(v))
 
-	case 37: /* movb lext/lauto/lreg,r ==> lbz o(reg),r; extsb r */
-		v := c.regoff(&p.From)
-
-		r := int(p.From.Reg)
-		if r == 0 {
-			r = c.getimpliedreg(&p.From, p)
-		}
-		o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(v)))
-		o2 = AOP_IRR(c.opload(p.As), uint32(p.To.Reg), REGTMP, uint32(v))
+		// Sign extend MOVB operations. This is ignored for other cases (o.size == 8).
 		o3 = LOP_RRR(OP_EXTSB, uint32(p.To.Reg), uint32(p.To.Reg), 0)
 
 	case 40: /* word */
@@ -3457,14 +3435,7 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 			o1, o2 = c.symbolAccess(p.From.Sym, v, p.To.Reg, inst)
 		}
 
-	case 76:
-		v := c.vregoff(&p.From)
-		// Offsets in DS form loads must be a multiple of 4
-		inst := c.opload(p.As)
-		if c.opform(inst) == DS_FORM && v&0x3 != 0 {
-			log.Fatalf("invalid offset for DS form load/store %v", p)
-		}
-		o1, o2 = c.symbolAccess(p.From.Sym, v, p.To.Reg, inst)
+		// Sign extend MOVB operations. This is ignored for other cases (o.size == 8).
 		o3 = LOP_RRR(OP_EXTSB, uint32(p.To.Reg), uint32(p.To.Reg), 0)
 
 	case 79:
-- 
GitLab


From b44c78b8c318f6b871f26d14d877245bc860ae62 Mon Sep 17 00:00:00 2001
From: Joe Tsai <joetsai@digital-static.net>
Date: Fri, 7 May 2021 10:34:28 -0700
Subject: [PATCH 2006/2400] doc/go1.17: fill in TODO for strconv package

Updates #46021

Change-Id: Iaed26b5a1defa6c5d00fb7a3998db56d2f1b96b1
Reviewed-on: https://go-review.googlesource.com/c/go/+/318010
Trust: Joe Tsai <joetsai@digital-static.net>
Trust: Joe Tsai <thebrokentoaster@gmail.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 doc/go1.17.html | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 785092a8dd..a2e0f9454b 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -426,7 +426,10 @@ Do not send CLs removing the interior tags from such phrases.
     </p>
 
     <p><!-- CL 314775 -->
-      TODO: <a href="https://golang.org/cl/314775">https://golang.org/cl/314775</a>: add QuotedPrefix
+      The new <a href="/pkg/strconv/#QuotedPrefix"><code>QuotedPrefix</code></a> function
+      returns the quoted string (as understood by
+      <a href="/pkg/strconv/#Unquote"><code>Unquote</code></a>)
+      at the start of input.
     </p>
   </dd>
 </dl><!-- strconv -->
-- 
GitLab


From af6123a865546c8735acc64c344a4e02bd561c0d Mon Sep 17 00:00:00 2001
From: Emmanuel T Odeke <emmanuel@orijtech.com>
Date: Thu, 6 May 2021 22:15:11 -0700
Subject: [PATCH 2007/2400] doc/go1.17: document encoding/binary.Uvarint max
 read of 10 bytes

Updates #41185
For #44513.
Fixes #46009

Change-Id: I60f4d891b897809765acc0aace037c78e95bb4f7
Reviewed-on: https://go-review.googlesource.com/c/go/+/317929
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Keith Randall <khr@golang.org>
---
 doc/go1.17.html | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index a2e0f9454b..3cd324e0ab 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -303,7 +303,10 @@ Do not send CLs removing the interior tags from such phrases.
 <dl id="encoding/binary"><dt><a href="/pkg/encoding/binary/">encoding/binary</a></dt>
   <dd>
     <p><!-- CL 299531 -->
-      TODO: <a href="https://golang.org/cl/299531">https://golang.org/cl/299531</a>: limit bytes read by Uvarint to &lt;= 10
+      <code>binary.Uvarint</code> will stop reading after <code>10 bytes</code> to avoid
+      wasted computations. If more than <code>10 bytes</code> are needed, the byte count returned is <code>-11</code>.
+      <br />
+      Previous Go versions could return larger negative counts when reading incorrectly encoded varints.
     </p>
   </dd>
 </dl><!-- encoding/binary -->
-- 
GitLab


From d80d1427a8119eed6e668caba4314140edbcb4b8 Mon Sep 17 00:00:00 2001
From: Joe Tsai <joetsai@digital-static.net>
Date: Fri, 7 May 2021 10:41:24 -0700
Subject: [PATCH 2008/2400] doc/go1.17: fill in TODO for reflect package

Updates #46019

Change-Id: I3025927d949ff72535542e89b83dd830e969c255
Reviewed-on: https://go-review.googlesource.com/c/go/+/318011
Trust: Joe Tsai <joetsai@digital-static.net>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 doc/go1.17.html | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 3cd324e0ab..894b8ae133 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -405,7 +405,13 @@ Do not send CLs removing the interior tags from such phrases.
 <dl id="reflect"><dt><a href="/pkg/reflect/">reflect</a></dt>
   <dd>
     <p><!-- CL 266197 -->
-      TODO: <a href="https://golang.org/cl/266197">https://golang.org/cl/266197</a>: add Method.IsExported and StructField.IsExported methods
+      The new
+      <a href="/pkg/reflect/#StructField.IsExported"><code>StructField.IsExported</code></a>
+      and
+      <a href="/pkg/reflect/#Method.IsExported"><code>Method.IsExported</code></a>
+      methods report whether a struct field or type method is exported.
+      They provide a more readable alternative to checking whether <code>PkgPath</code>
+      is empty.
     </p>
 
     <p><!-- CL 281233 -->
-- 
GitLab


From 3980c4db192783c6aefa0a5978e553046c9c7dea Mon Sep 17 00:00:00 2001
From: Joe Tsai <joetsai@digital-static.net>
Date: Fri, 7 May 2021 10:47:47 -0700
Subject: [PATCH 2009/2400] doc/go1.17: fill in TODO for compress/lzw package

Fixes #46005

Change-Id: I80ca21eb64d245749af62506ba960dbc1726c6c4
Reviewed-on: https://go-review.googlesource.com/c/go/+/318012
Trust: Joe Tsai <joetsai@digital-static.net>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 doc/go1.17.html | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 894b8ae133..cf856a1e73 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -275,7 +275,11 @@ Do not send CLs removing the interior tags from such phrases.
 <dl id="compress/lzw"><dt><a href="/pkg/compress/lzw/">compress/lzw</a></dt>
   <dd>
     <p><!-- CL 273667 -->
-      TODO: <a href="https://golang.org/cl/273667">https://golang.org/cl/273667</a>: add Reset method to Reader and Writer
+      The new
+      <a href="/pkg/compress/lzw/#Reader.Reset"><code>Reader.Reset</code></a>
+      and
+      <a href="/pkg/compress/lzw/#Writer.Reset"><code>Writer.Reset</code></a>
+      methods allow reuse of a <code>Reader</code> or <code>Writer</code>.
     </p>
   </dd>
 </dl><!-- compress/lzw -->
-- 
GitLab


From f24eac47710b0170fd45611ab1867e87701e0a95 Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Mon, 26 Apr 2021 14:32:23 -0700
Subject: [PATCH 2010/2400] cmd/compile:  improving the documentation of
 various fields and functions

This is only changes to comments, so should be fine to go into 1.17.

Change-Id: I01e28dc76b03fb3ca846d976f8ac84bc2acb2ea2
Reviewed-on: https://go-review.googlesource.com/c/go/+/318009
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/inline/inl.go        |  8 +++---
 src/cmd/compile/internal/ir/func.go           |  5 +++-
 src/cmd/compile/internal/typecheck/func.go    |  7 ++---
 src/cmd/compile/internal/typecheck/iimport.go |  5 ++++
 .../compile/internal/typecheck/typecheck.go   |  2 ++
 src/cmd/compile/internal/types/sym.go         |  8 ++++--
 src/cmd/compile/internal/types/type.go        | 27 ++++++++++++-------
 7 files changed, 42 insertions(+), 20 deletions(-)

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index e07bb3b324..a6829e9835 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -53,8 +53,8 @@ const (
 	inlineBigFunctionMaxCost = 20   // Max cost of inlinee when inlining into a "big" function.
 )
 
+// InlinePackage finds functions that can be inlined and clones them before walk expands them.
 func InlinePackage() {
-	// Find functions that can be inlined and clone them before walk expands them.
 	ir.VisitFuncsBottomUp(typecheck.Target.Decls, func(list []*ir.Func, recursive bool) {
 		numfns := numNonClosures(list)
 		for _, n := range list {
@@ -74,8 +74,8 @@ func InlinePackage() {
 }
 
 // CanInline determines whether fn is inlineable.
-// If so, CanInline saves fn->nbody in fn->inl and substitutes it with a copy.
-// fn and ->nbody will already have been typechecked.
+// If so, CanInline saves copies of fn.Body and fn.Dcl in fn.Inl.
+// fn and fn.Body will already have been typechecked.
 func CanInline(fn *ir.Func) {
 	if fn.Nname == nil {
 		base.Fatalf("CanInline no nname %+v", fn)
@@ -520,7 +520,7 @@ func inlcopy(n ir.Node) ir.Node {
 	return edit(n)
 }
 
-// Inlcalls/nodelist/node walks fn's statements and expressions and substitutes any
+// InlineCalls/inlnode walks fn's statements and expressions and substitutes any
 // calls made to inlineable functions. This is the external entry point.
 func InlineCalls(fn *ir.Func) {
 	savefn := ir.CurFunc
diff --git a/src/cmd/compile/internal/ir/func.go b/src/cmd/compile/internal/ir/func.go
index 385866b3c8..20fe965711 100644
--- a/src/cmd/compile/internal/ir/func.go
+++ b/src/cmd/compile/internal/ir/func.go
@@ -160,7 +160,10 @@ func (f *Func) LinksymABI(abi obj.ABI) *obj.LSym { return f.Nname.LinksymABI(abi
 type Inline struct {
 	Cost int32 // heuristic cost of inlining this function
 
-	// Copies of Func.Dcl and Nbody for use during inlining.
+	// Copies of Func.Dcl and Func.Body for use during inlining. Copies are
+	// needed because the function's dcl/body may be changed by later compiler
+	// transformations. These fields are also populated when a function from
+	// another package is imported.
 	Dcl  []*Name
 	Body []Node
 }
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index e154c39269..f381e1dbdc 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -105,8 +105,9 @@ func PartialCallType(n *ir.SelectorExpr) *types.Type {
 // typechecking an inline body, as opposed to the body of a real function.
 var inTypeCheckInl bool
 
-// Lazy typechecking of imported bodies. For local functions, CanInline will set ->typecheck
-// because they're a copy of an already checked body.
+// ImportedBody returns immediately if the inlining information for fn is
+// populated. Otherwise, fn must be an imported function. If so, ImportedBody
+// loads in the dcls and body for fn, and typechecks as needed.
 func ImportedBody(fn *ir.Func) {
 	if fn.Inl.Body != nil {
 		return
@@ -180,7 +181,7 @@ func fnpkg(fn *ir.Name) *types.Pkg {
 	return fn.Sym().Pkg
 }
 
-// closurename generates a new unique name for a closure within
+// ClosureName generates a new unique name for a closure within
 // outerfunc.
 func ClosureName(outerfunc *ir.Func) *types.Sym {
 	outer := "glob."
diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 00f6a6e483..a5ddbb5a74 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -42,6 +42,9 @@ var (
 	inlineImporter = map[*types.Sym]iimporterAndOffset{}
 )
 
+// expandDecl returns immediately if n is already a Name node. Otherwise, n should
+// be an Ident node, and expandDecl reads in the definition of the specified
+// identifier from the appropriate package.
 func expandDecl(n ir.Node) ir.Node {
 	if n, ok := n.(*ir.Name); ok {
 		return n
@@ -61,6 +64,8 @@ func expandDecl(n ir.Node) ir.Node {
 	return r.doDecl(n.Sym())
 }
 
+// ImportBody reads in the dcls and body of an imported function (which should not
+// yet have been read in).
 func ImportBody(fn *ir.Func) {
 	if fn.Inl.Body != nil {
 		base.Fatalf("%v already has inline body", fn)
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 4c5472137a..95f7b50259 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -66,6 +66,8 @@ func FuncBody(n *ir.Func) {
 
 var importlist []*ir.Func
 
+// AllImportedBodies reads in the bodies of all imported functions and typechecks
+// them, if needed.
 func AllImportedBodies() {
 	for _, n := range importlist {
 		if n.Inl != nil {
diff --git a/src/cmd/compile/internal/types/sym.go b/src/cmd/compile/internal/types/sym.go
index 9a32a01a1a..534cf7e237 100644
--- a/src/cmd/compile/internal/types/sym.go
+++ b/src/cmd/compile/internal/types/sym.go
@@ -32,8 +32,12 @@ type Sym struct {
 	Pkg  *Pkg
 	Name string // object name
 
-	// saved and restored by Pushdcl/Popdcl
-	Def        Object   // definition: ONAME OTYPE OPACK or OLITERAL
+	// Def, Block, and Lastlineno are saved and restored by Pushdcl/Popdcl.
+
+	// The unique ONAME, OTYPE, OPACK, or OLITERAL node that this symbol is
+	// bound to within the current scope. (Most parts of the compiler should
+	// prefer passing the Node directly, rather than relying on this field.)
+	Def        Object
 	Block      int32    // blocknumber to catch redeclaration
 	Lastlineno src.XPos // last declaration for diagnostic
 
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 88fc409733..1a9aa6916a 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -11,9 +11,9 @@ import (
 	"sync"
 )
 
-// IRNode represents an ir.Node, but without needing to import cmd/compile/internal/ir,
+// Object represents an ir.Node, but without needing to import cmd/compile/internal/ir,
 // which would cause an import cycle. The uses in other packages must type assert
-// values of type IRNode to ir.Node or a more specific type.
+// values of type Object to ir.Node or a more specific type.
 type Object interface {
 	Pos() src.XPos
 	Sym() *Sym
@@ -157,12 +157,15 @@ type Type struct {
 	// Width is the width of this Type in bytes.
 	Width int64 // valid if Align > 0
 
-	methods    Fields
+	// list of base methods (excluding embedding)
+	methods Fields
+	// list of all methods (including embedding)
 	allMethods Fields
 
 	// canonical OTYPE node for a named type (should be an ir.Name node with same sym)
-	nod        Object
-	underlying *Type // original type (type literal or predefined type)
+	nod Object
+	// the underlying type (type literal or predeclared type) for a defined type
+	underlying *Type
 
 	// Cache of composite types, with this type being the element type.
 	cache struct {
@@ -423,8 +426,11 @@ type Slice struct {
 	Elem *Type // element type
 }
 
-// A Field represents a field in a struct or a method in an interface or
-// associated with a named type.
+// A Field is a (Sym, Type) pairing along with some other information, and,
+// depending on the context, is used to represent:
+//  - a field in a struct
+//  - a method in an interface or associated with a named type
+//  - a function parameter
 type Field struct {
 	flags bitset8
 
@@ -1656,9 +1662,10 @@ var (
 )
 
 // NewNamed returns a new named type for the given type name. obj should be an
-// ir.Name. The new type is incomplete, and the underlying type should be set
-// later via SetUnderlying(). References to the type are maintained until the type
-// is filled in, so those references can be updated when the type is complete.
+// ir.Name. The new type is incomplete (marked as TFORW kind), and the underlying
+// type should be set later via SetUnderlying(). References to the type are
+// maintained until the type is filled in, so those references can be updated when
+// the type is complete.
 func NewNamed(obj Object) *Type {
 	t := New(TFORW)
 	t.sym = obj.Sym()
-- 
GitLab


From b211fe005860db3ceff5fd56af9951d6d1f44325 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Fri, 7 May 2021 14:14:39 -0700
Subject: [PATCH 2011/2400] cmd/compile: remove bit operations that modify
 memory directly
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

These operations (BT{S,R,C}{Q,L}modify) are quite a bit slower than
other ways of doing the same thing.

Without the BTxmodify operations, there are two fallback ways the compiler
performs these operations: AND/OR/XOR operations directly on memory, or
load-BTx-write sequences. The compiler kinda chooses one arbitrarily
depending on rewrite rule application order. Currently, it uses
load-BTx-write for the Const benchmarks and AND/OR/XOR directly to memory
for the non-Const benchmarks. TBD, someone might investigate which of
the two fallback strategies is really better. For now, they are both
better than BTx ops.

name              old time/op  new time/op  delta
BitSet-8          1.09µs ± 2%  0.64µs ± 5%  -41.60%  (p=0.000 n=9+10)
BitClear-8        1.15µs ± 3%  0.68µs ± 6%  -41.00%  (p=0.000 n=10+10)
BitToggle-8       1.18µs ± 4%  0.73µs ± 2%  -38.36%  (p=0.000 n=10+8)
BitSetConst-8     37.0ns ± 7%  25.8ns ± 2%  -30.24%  (p=0.000 n=10+10)
BitClearConst-8   30.7ns ± 2%  25.0ns ±12%  -18.46%  (p=0.000 n=10+10)
BitToggleConst-8  36.9ns ± 1%  23.8ns ± 3%  -35.46%  (p=0.000 n=9+10)

Fixes #45790
Update #45242

Change-Id: Ie33a72dc139f261af82db15d446cd0855afb4e59
Reviewed-on: https://go-review.googlesource.com/c/go/+/318149
Trust: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ben Shi <powerman1st@163.com>
---
 src/cmd/compile/internal/amd64/ssa.go        |    4 +-
 src/cmd/compile/internal/ssa/gen/AMD64.rules |   56 +-
 src/cmd/compile/internal/ssa/gen/AMD64Ops.go |   19 -
 src/cmd/compile/internal/ssa/opGen.go        |  186 ---
 src/cmd/compile/internal/ssa/rewriteAMD64.go | 1221 +-----------------
 src/cmd/compile/internal/test/bench_test.go  |   60 +
 test/codegen/bits.go                         |   12 -
 7 files changed, 127 insertions(+), 1431 deletions(-)

diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index 6a478de2a0..ca5f36e775 100644
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -756,7 +756,6 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 	case ssa.OpAMD64MOVQstore, ssa.OpAMD64MOVSSstore, ssa.OpAMD64MOVSDstore, ssa.OpAMD64MOVLstore, ssa.OpAMD64MOVWstore, ssa.OpAMD64MOVBstore, ssa.OpAMD64MOVOstore,
-		ssa.OpAMD64BTCQmodify, ssa.OpAMD64BTCLmodify, ssa.OpAMD64BTRQmodify, ssa.OpAMD64BTRLmodify, ssa.OpAMD64BTSQmodify, ssa.OpAMD64BTSLmodify,
 		ssa.OpAMD64ADDQmodify, ssa.OpAMD64SUBQmodify, ssa.OpAMD64ANDQmodify, ssa.OpAMD64ORQmodify, ssa.OpAMD64XORQmodify,
 		ssa.OpAMD64ADDLmodify, ssa.OpAMD64SUBLmodify, ssa.OpAMD64ANDLmodify, ssa.OpAMD64ORLmodify, ssa.OpAMD64XORLmodify:
 		p := s.Prog(v.Op.Asm())
@@ -804,8 +803,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		}
 		fallthrough
 	case ssa.OpAMD64ANDQconstmodify, ssa.OpAMD64ANDLconstmodify, ssa.OpAMD64ORQconstmodify, ssa.OpAMD64ORLconstmodify,
-		ssa.OpAMD64BTCQconstmodify, ssa.OpAMD64BTCLconstmodify, ssa.OpAMD64BTSQconstmodify, ssa.OpAMD64BTSLconstmodify,
-		ssa.OpAMD64BTRQconstmodify, ssa.OpAMD64BTRLconstmodify, ssa.OpAMD64XORQconstmodify, ssa.OpAMD64XORLconstmodify:
+		ssa.OpAMD64XORQconstmodify, ssa.OpAMD64XORLconstmodify:
 		sc := v.AuxValAndOff()
 		off := sc.Off64()
 		val := sc.Val64()
diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules
index 7a88a488c0..ec91ea1513 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64.rules
+++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules
@@ -624,14 +624,6 @@
 // Recognize bit setting (a |= 1<<b) and toggling (a ^= 1<<b)
 (OR(Q|L) (SHL(Q|L) (MOV(Q|L)const [1]) y) x) => (BTS(Q|L) x y)
 (XOR(Q|L) (SHL(Q|L) (MOV(Q|L)const [1]) y) x) => (BTC(Q|L) x y)
-(ORLmodify [off] {sym} ptr s:(SHLL (MOVLconst [1]) <t> x) mem) =>
-	(BTSLmodify [off] {sym} ptr (ANDLconst <t> [31] x) mem)
-(ORQmodify [off] {sym} ptr s:(SHLQ (MOVQconst [1]) <t> x) mem) =>
-	(BTSQmodify [off] {sym} ptr (ANDQconst <t> [63] x) mem)
-(XORLmodify [off] {sym} ptr s:(SHLL (MOVLconst [1]) <t> x) mem) =>
-	(BTCLmodify [off] {sym} ptr (ANDLconst <t> [31] x) mem)
-(XORQmodify [off] {sym} ptr s:(SHLQ (MOVQconst [1]) <t> x) mem) =>
-	(BTCQmodify [off] {sym} ptr (ANDQconst <t> [63] x) mem)
 
 // Convert ORconst into BTS, if the code gets smaller, with boundary being
 // (ORL $40,AX is 3 bytes, ORL $80,AX is 6 bytes).
@@ -654,10 +646,6 @@
     => (BTRQconst [int8(log64(^c))] x)
 (ANDL (MOVLconst [c]) x) && isUint32PowerOfTwo(int64(^c)) && uint64(^c) >= 128
     => (BTRLconst [int8(log32(^c))] x)
-(ANDLmodify [off] {sym} ptr (NOTL s:(SHLL (MOVLconst [1]) <t> x)) mem) =>
-	(BTRLmodify [off] {sym} ptr (ANDLconst <t> [31] x) mem)
-(ANDQmodify [off] {sym} ptr (NOTQ s:(SHLQ (MOVQconst [1]) <t> x)) mem) =>
-	(BTRQmodify [off] {sym} ptr (ANDQconst <t> [63] x) mem)
 
 // Special-case bit patterns on first/last bit.
 // generic.rules changes ANDs of high-part/low-part masks into a couple of shifts,
@@ -1126,14 +1114,14 @@
 	((ADD|SUB|MUL|DIV)SSload [off1+off2] {sym} val base mem)
 ((ADD|SUB|MUL|DIV)SDload [off1] {sym} val (ADDQconst [off2] base) mem) && is32Bit(int64(off1)+int64(off2)) =>
 	((ADD|SUB|MUL|DIV)SDload [off1+off2] {sym} val base mem)
-((ADD|AND|OR|XOR|BTC|BTR|BTS)Qconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem) && ValAndOff(valoff1).canAdd32(off2) =>
-	((ADD|AND|OR|XOR|BTC|BTR|BTS)Qconstmodify [ValAndOff(valoff1).addOffset32(off2)] {sym} base mem)
-((ADD|AND|OR|XOR|BTC|BTR|BTS)Lconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem) && ValAndOff(valoff1).canAdd32(off2) =>
-	((ADD|AND|OR|XOR|BTC|BTR|BTS)Lconstmodify [ValAndOff(valoff1).addOffset32(off2)] {sym} base mem)
-((ADD|SUB|AND|OR|XOR|BTC|BTR|BTS)Qmodify [off1] {sym} (ADDQconst [off2] base) val mem) && is32Bit(int64(off1)+int64(off2)) =>
-	((ADD|SUB|AND|OR|XOR|BTC|BTR|BTS)Qmodify [off1+off2] {sym} base val mem)
-((ADD|SUB|AND|OR|XOR|BTC|BTR|BTS)Lmodify [off1] {sym} (ADDQconst [off2] base) val mem) && is32Bit(int64(off1)+int64(off2)) =>
-	((ADD|SUB|AND|OR|XOR|BTC|BTR|BTS)Lmodify [off1+off2] {sym} base val mem)
+((ADD|AND|OR|XOR)Qconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem) && ValAndOff(valoff1).canAdd32(off2) =>
+	((ADD|AND|OR|XOR)Qconstmodify [ValAndOff(valoff1).addOffset32(off2)] {sym} base mem)
+((ADD|AND|OR|XOR)Lconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem) && ValAndOff(valoff1).canAdd32(off2) =>
+	((ADD|AND|OR|XOR)Lconstmodify [ValAndOff(valoff1).addOffset32(off2)] {sym} base mem)
+((ADD|SUB|AND|OR|XOR)Qmodify [off1] {sym} (ADDQconst [off2] base) val mem) && is32Bit(int64(off1)+int64(off2)) =>
+	((ADD|SUB|AND|OR|XOR)Qmodify [off1+off2] {sym} base val mem)
+((ADD|SUB|AND|OR|XOR)Lmodify [off1] {sym} (ADDQconst [off2] base) val mem) && is32Bit(int64(off1)+int64(off2)) =>
+	((ADD|SUB|AND|OR|XOR)Lmodify [off1+off2] {sym} base val mem)
 
 // Fold constants into stores.
 (MOVQstore [off] {sym} ptr (MOVQconst [c]) mem) && validVal(c) =>
@@ -1181,18 +1169,18 @@
 ((ADD|SUB|MUL|DIV)SDload [off1] {sym1} val (LEAQ [off2] {sym2} base) mem)
 	&& is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) =>
 	((ADD|SUB|MUL|DIV)SDload [off1+off2] {mergeSym(sym1,sym2)} val base mem)
-((ADD|AND|OR|XOR|BTC|BTR|BTS)Qconstmodify [valoff1] {sym1} (LEAQ [off2] {sym2} base) mem)
+((ADD|AND|OR|XOR)Qconstmodify [valoff1] {sym1} (LEAQ [off2] {sym2} base) mem)
 	&& ValAndOff(valoff1).canAdd32(off2) && canMergeSym(sym1, sym2) =>
-	((ADD|AND|OR|XOR|BTC|BTR|BTS)Qconstmodify [ValAndOff(valoff1).addOffset32(off2)] {mergeSym(sym1,sym2)} base mem)
-((ADD|AND|OR|XOR|BTC|BTR|BTS)Lconstmodify [valoff1] {sym1} (LEAQ [off2] {sym2} base) mem)
+	((ADD|AND|OR|XOR)Qconstmodify [ValAndOff(valoff1).addOffset32(off2)] {mergeSym(sym1,sym2)} base mem)
+((ADD|AND|OR|XOR)Lconstmodify [valoff1] {sym1} (LEAQ [off2] {sym2} base) mem)
 	&& ValAndOff(valoff1).canAdd32(off2) && canMergeSym(sym1, sym2) =>
-	((ADD|AND|OR|XOR|BTC|BTR|BTS)Lconstmodify [ValAndOff(valoff1).addOffset32(off2)] {mergeSym(sym1,sym2)} base mem)
-((ADD|SUB|AND|OR|XOR|BTC|BTR|BTS)Qmodify [off1] {sym1} (LEAQ [off2] {sym2} base) val mem)
+	((ADD|AND|OR|XOR)Lconstmodify [ValAndOff(valoff1).addOffset32(off2)] {mergeSym(sym1,sym2)} base mem)
+((ADD|SUB|AND|OR|XOR)Qmodify [off1] {sym1} (LEAQ [off2] {sym2} base) val mem)
 	&& is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) =>
-	((ADD|SUB|AND|OR|XOR|BTC|BTR|BTS)Qmodify [off1+off2] {mergeSym(sym1,sym2)} base val mem)
-((ADD|SUB|AND|OR|XOR|BTC|BTR|BTS)Lmodify [off1] {sym1} (LEAQ [off2] {sym2} base) val mem)
+	((ADD|SUB|AND|OR|XOR)Qmodify [off1+off2] {mergeSym(sym1,sym2)} base val mem)
+((ADD|SUB|AND|OR|XOR)Lmodify [off1] {sym1} (LEAQ [off2] {sym2} base) val mem)
 	&& is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) =>
-	((ADD|SUB|AND|OR|XOR|BTC|BTR|BTS)Lmodify [off1+off2] {mergeSym(sym1,sym2)} base val mem)
+	((ADD|SUB|AND|OR|XOR)Lmodify [off1+off2] {mergeSym(sym1,sym2)} base val mem)
 
 // fold LEAQs together
 (LEAQ [off1] {sym1} (LEAQ [off2] {sym2} x)) && is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) =>
@@ -2078,13 +2066,9 @@
 (MOVLstore {sym} [off] ptr y:((ADD|AND|OR|XOR)Lload x [off] {sym} ptr mem) mem) && y.Uses==1 && clobber(y) => ((ADD|AND|OR|XOR)Lmodify [off] {sym} ptr x mem)
 (MOVLstore {sym} [off] ptr y:((ADD|SUB|AND|OR|XOR)L l:(MOVLload [off] {sym} ptr mem) x) mem) && y.Uses==1 && l.Uses==1 && clobber(y, l) =>
 	((ADD|SUB|AND|OR|XOR)Lmodify [off] {sym} ptr x mem)
-(MOVLstore {sym} [off] ptr y:((BTC|BTR|BTS)L l:(MOVLload [off] {sym} ptr mem) <t> x) mem) && y.Uses==1 && l.Uses==1 && clobber(y, l) =>
-	((BTC|BTR|BTS)Lmodify [off] {sym} ptr (ANDLconst <t> [31] x) mem)
 (MOVQstore {sym} [off] ptr y:((ADD|AND|OR|XOR)Qload x [off] {sym} ptr mem) mem) && y.Uses==1 && clobber(y) => ((ADD|AND|OR|XOR)Qmodify [off] {sym} ptr x mem)
 (MOVQstore {sym} [off] ptr y:((ADD|SUB|AND|OR|XOR)Q l:(MOVQload [off] {sym} ptr mem) x) mem) && y.Uses==1 && l.Uses==1 && clobber(y, l) =>
 	((ADD|SUB|AND|OR|XOR)Qmodify [off] {sym} ptr x mem)
-(MOVQstore {sym} [off] ptr y:((BTC|BTR|BTS)Q l:(MOVQload [off] {sym} ptr mem) <t> x) mem) && y.Uses==1 && l.Uses==1 && clobber(y, l) =>
-	((BTC|BTR|BTS)Qmodify [off] {sym} ptr (ANDQconst <t> [63] x) mem)
 
 // Merge ADDQconst and LEAQ into atomic loads.
 (MOV(Q|L|B)atomicload [off1] {sym} (ADDQconst [off2] ptr) mem) && is32Bit(int64(off1)+int64(off2)) =>
@@ -2138,12 +2122,12 @@
 (MOVWQZX (MOVBQZX x)) => (MOVBQZX x)
 (MOVBQZX (MOVBQZX x)) => (MOVBQZX x)
 
-(MOVQstore [off] {sym} ptr a:((ADD|AND|OR|XOR|BTC|BTR|BTS)Qconst [c] l:(MOVQload [off] {sym} ptr2 mem)) mem)
+(MOVQstore [off] {sym} ptr a:((ADD|AND|OR|XOR)Qconst [c] l:(MOVQload [off] {sym} ptr2 mem)) mem)
 	&& isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a) =>
-	((ADD|AND|OR|XOR|BTC|BTR|BTS)Qconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
-(MOVLstore [off] {sym} ptr a:((ADD|AND|OR|XOR|BTC|BTR|BTS)Lconst [c] l:(MOVLload [off] {sym} ptr2 mem)) mem)
+	((ADD|AND|OR|XOR)Qconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
+(MOVLstore [off] {sym} ptr a:((ADD|AND|OR|XOR)Lconst [c] l:(MOVLload [off] {sym} ptr2 mem)) mem)
 	&& isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a) =>
-	((ADD|AND|OR|XOR|BTC|BTR|BTS)Lconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
+	((ADD|AND|OR|XOR)Lconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
 
 // float <-> int register moves, with no conversion.
 // These come up when compiling math.{Float{32,64}bits,Float{32,64}frombits}.
diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
index af53cc4f9d..67b3293903 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
+++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go
@@ -362,25 +362,6 @@ func init() {
 		{name: "BTSLconst", argLength: 1, reg: gp11, asm: "BTSL", resultInArg0: true, clobberFlags: true, aux: "Int8"}, // set bit auxint in arg0, 0 <= auxint < 32
 		{name: "BTSQconst", argLength: 1, reg: gp11, asm: "BTSQ", resultInArg0: true, clobberFlags: true, aux: "Int8"}, // set bit auxint in arg0, 0 <= auxint < 64
 
-		// direct bit operation on memory operand
-		//
-		// Note that these operations do not mask the bit offset (arg1), and will write beyond their expected
-		// bounds if that argument is larger than 64/32 (for BT*Q and BT*L, respectively). If the compiler
-		// cannot prove that arg1 is in range, it must be explicitly masked (see e.g. the patterns that produce
-		// BT*modify from (MOVstore (BT* (MOVLload ptr mem) x) mem)).
-		{name: "BTCQmodify", argLength: 3, reg: gpstore, asm: "BTCQ", aux: "SymOff", typ: "Mem", clobberFlags: true, faultOnNilArg0: true, symEffect: "Read,Write"},     // complement bit arg1 in 64-bit arg0+auxint+aux, arg2=mem
-		{name: "BTCLmodify", argLength: 3, reg: gpstore, asm: "BTCL", aux: "SymOff", typ: "Mem", clobberFlags: true, faultOnNilArg0: true, symEffect: "Read,Write"},     // complement bit arg1 in 32-bit arg0+auxint+aux, arg2=mem
-		{name: "BTSQmodify", argLength: 3, reg: gpstore, asm: "BTSQ", aux: "SymOff", typ: "Mem", clobberFlags: true, faultOnNilArg0: true, symEffect: "Read,Write"},     // set bit arg1 in 64-bit arg0+auxint+aux, arg2=mem
-		{name: "BTSLmodify", argLength: 3, reg: gpstore, asm: "BTSL", aux: "SymOff", typ: "Mem", clobberFlags: true, faultOnNilArg0: true, symEffect: "Read,Write"},     // set bit arg1 in 32-bit arg0+auxint+aux, arg2=mem
-		{name: "BTRQmodify", argLength: 3, reg: gpstore, asm: "BTRQ", aux: "SymOff", typ: "Mem", clobberFlags: true, faultOnNilArg0: true, symEffect: "Read,Write"},     // reset bit arg1 in 64-bit arg0+auxint+aux, arg2=mem
-		{name: "BTRLmodify", argLength: 3, reg: gpstore, asm: "BTRL", aux: "SymOff", typ: "Mem", clobberFlags: true, faultOnNilArg0: true, symEffect: "Read,Write"},     // reset bit arg1 in 32-bit arg0+auxint+aux, arg2=mem
-		{name: "BTCQconstmodify", argLength: 2, reg: gpstoreconst, asm: "BTCQ", aux: "SymValAndOff", clobberFlags: true, faultOnNilArg0: true, symEffect: "Read,Write"}, // complement bit ValAndOff(AuxInt).Val() in 64-bit arg0+ValAndOff(AuxInt).Off()+aux, arg1=mem
-		{name: "BTCLconstmodify", argLength: 2, reg: gpstoreconst, asm: "BTCL", aux: "SymValAndOff", clobberFlags: true, faultOnNilArg0: true, symEffect: "Read,Write"}, // complement bit ValAndOff(AuxInt).Val() in 32-bit arg0+ValAndOff(AuxInt).Off()+aux, arg1=mem
-		{name: "BTSQconstmodify", argLength: 2, reg: gpstoreconst, asm: "BTSQ", aux: "SymValAndOff", clobberFlags: true, faultOnNilArg0: true, symEffect: "Read,Write"}, // set bit ValAndOff(AuxInt).Val() in 64-bit arg0+ValAndOff(AuxInt).Off()+aux, arg1=mem
-		{name: "BTSLconstmodify", argLength: 2, reg: gpstoreconst, asm: "BTSL", aux: "SymValAndOff", clobberFlags: true, faultOnNilArg0: true, symEffect: "Read,Write"}, // set bit ValAndOff(AuxInt).Val() in 32-bit arg0+ValAndOff(AuxInt).Off()+aux, arg1=mem
-		{name: "BTRQconstmodify", argLength: 2, reg: gpstoreconst, asm: "BTRQ", aux: "SymValAndOff", clobberFlags: true, faultOnNilArg0: true, symEffect: "Read,Write"}, // reset bit ValAndOff(AuxInt).Val() in 64-bit arg0+ValAndOff(AuxInt).Off()+aux, arg1=mem
-		{name: "BTRLconstmodify", argLength: 2, reg: gpstoreconst, asm: "BTRL", aux: "SymValAndOff", clobberFlags: true, faultOnNilArg0: true, symEffect: "Read,Write"}, // reset bit ValAndOff(AuxInt).Val() in 32-bit arg0+ValAndOff(AuxInt).Off()+aux, arg1=mem
-
 		{name: "TESTQ", argLength: 2, reg: gp2flags, commutative: true, asm: "TESTQ", typ: "Flags"}, // (arg0 & arg1) compare to 0
 		{name: "TESTL", argLength: 2, reg: gp2flags, commutative: true, asm: "TESTL", typ: "Flags"}, // (arg0 & arg1) compare to 0
 		{name: "TESTW", argLength: 2, reg: gp2flags, commutative: true, asm: "TESTW", typ: "Flags"}, // (arg0 & arg1) compare to 0
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index 51cb0881b8..1c37fbe0db 100644
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -692,18 +692,6 @@ const (
 	OpAMD64BTRQconst
 	OpAMD64BTSLconst
 	OpAMD64BTSQconst
-	OpAMD64BTCQmodify
-	OpAMD64BTCLmodify
-	OpAMD64BTSQmodify
-	OpAMD64BTSLmodify
-	OpAMD64BTRQmodify
-	OpAMD64BTRLmodify
-	OpAMD64BTCQconstmodify
-	OpAMD64BTCLconstmodify
-	OpAMD64BTSQconstmodify
-	OpAMD64BTSLconstmodify
-	OpAMD64BTRQconstmodify
-	OpAMD64BTRLconstmodify
 	OpAMD64TESTQ
 	OpAMD64TESTL
 	OpAMD64TESTW
@@ -8521,180 +8509,6 @@ var opcodeTable = [...]opInfo{
 			},
 		},
 	},
-	{
-		name:           "BTCQmodify",
-		auxType:        auxSymOff,
-		argLen:         3,
-		clobberFlags:   true,
-		faultOnNilArg0: true,
-		symEffect:      SymRead | SymWrite,
-		asm:            x86.ABTCQ,
-		reg: regInfo{
-			inputs: []inputInfo{
-				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
-			},
-		},
-	},
-	{
-		name:           "BTCLmodify",
-		auxType:        auxSymOff,
-		argLen:         3,
-		clobberFlags:   true,
-		faultOnNilArg0: true,
-		symEffect:      SymRead | SymWrite,
-		asm:            x86.ABTCL,
-		reg: regInfo{
-			inputs: []inputInfo{
-				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
-			},
-		},
-	},
-	{
-		name:           "BTSQmodify",
-		auxType:        auxSymOff,
-		argLen:         3,
-		clobberFlags:   true,
-		faultOnNilArg0: true,
-		symEffect:      SymRead | SymWrite,
-		asm:            x86.ABTSQ,
-		reg: regInfo{
-			inputs: []inputInfo{
-				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
-			},
-		},
-	},
-	{
-		name:           "BTSLmodify",
-		auxType:        auxSymOff,
-		argLen:         3,
-		clobberFlags:   true,
-		faultOnNilArg0: true,
-		symEffect:      SymRead | SymWrite,
-		asm:            x86.ABTSL,
-		reg: regInfo{
-			inputs: []inputInfo{
-				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
-			},
-		},
-	},
-	{
-		name:           "BTRQmodify",
-		auxType:        auxSymOff,
-		argLen:         3,
-		clobberFlags:   true,
-		faultOnNilArg0: true,
-		symEffect:      SymRead | SymWrite,
-		asm:            x86.ABTRQ,
-		reg: regInfo{
-			inputs: []inputInfo{
-				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
-			},
-		},
-	},
-	{
-		name:           "BTRLmodify",
-		auxType:        auxSymOff,
-		argLen:         3,
-		clobberFlags:   true,
-		faultOnNilArg0: true,
-		symEffect:      SymRead | SymWrite,
-		asm:            x86.ABTRL,
-		reg: regInfo{
-			inputs: []inputInfo{
-				{1, 49151},      // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R15
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
-			},
-		},
-	},
-	{
-		name:           "BTCQconstmodify",
-		auxType:        auxSymValAndOff,
-		argLen:         2,
-		clobberFlags:   true,
-		faultOnNilArg0: true,
-		symEffect:      SymRead | SymWrite,
-		asm:            x86.ABTCQ,
-		reg: regInfo{
-			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
-			},
-		},
-	},
-	{
-		name:           "BTCLconstmodify",
-		auxType:        auxSymValAndOff,
-		argLen:         2,
-		clobberFlags:   true,
-		faultOnNilArg0: true,
-		symEffect:      SymRead | SymWrite,
-		asm:            x86.ABTCL,
-		reg: regInfo{
-			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
-			},
-		},
-	},
-	{
-		name:           "BTSQconstmodify",
-		auxType:        auxSymValAndOff,
-		argLen:         2,
-		clobberFlags:   true,
-		faultOnNilArg0: true,
-		symEffect:      SymRead | SymWrite,
-		asm:            x86.ABTSQ,
-		reg: regInfo{
-			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
-			},
-		},
-	},
-	{
-		name:           "BTSLconstmodify",
-		auxType:        auxSymValAndOff,
-		argLen:         2,
-		clobberFlags:   true,
-		faultOnNilArg0: true,
-		symEffect:      SymRead | SymWrite,
-		asm:            x86.ABTSL,
-		reg: regInfo{
-			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
-			},
-		},
-	},
-	{
-		name:           "BTRQconstmodify",
-		auxType:        auxSymValAndOff,
-		argLen:         2,
-		clobberFlags:   true,
-		faultOnNilArg0: true,
-		symEffect:      SymRead | SymWrite,
-		asm:            x86.ABTRQ,
-		reg: regInfo{
-			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
-			},
-		},
-	},
-	{
-		name:           "BTRLconstmodify",
-		auxType:        auxSymValAndOff,
-		argLen:         2,
-		clobberFlags:   true,
-		faultOnNilArg0: true,
-		symEffect:      SymRead | SymWrite,
-		asm:            x86.ABTRL,
-		reg: regInfo{
-			inputs: []inputInfo{
-				{0, 4295032831}, // AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 g R15 SB
-			},
-		},
-	},
 	{
 		name:        "TESTQ",
 		argLen:      2,
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index 0b98b9ddf6..efb5d27145 100644
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -68,44 +68,20 @@ func rewriteValueAMD64(v *Value) bool {
 		return rewriteValueAMD64_OpAMD64BSFQ(v)
 	case OpAMD64BTCLconst:
 		return rewriteValueAMD64_OpAMD64BTCLconst(v)
-	case OpAMD64BTCLconstmodify:
-		return rewriteValueAMD64_OpAMD64BTCLconstmodify(v)
-	case OpAMD64BTCLmodify:
-		return rewriteValueAMD64_OpAMD64BTCLmodify(v)
 	case OpAMD64BTCQconst:
 		return rewriteValueAMD64_OpAMD64BTCQconst(v)
-	case OpAMD64BTCQconstmodify:
-		return rewriteValueAMD64_OpAMD64BTCQconstmodify(v)
-	case OpAMD64BTCQmodify:
-		return rewriteValueAMD64_OpAMD64BTCQmodify(v)
 	case OpAMD64BTLconst:
 		return rewriteValueAMD64_OpAMD64BTLconst(v)
 	case OpAMD64BTQconst:
 		return rewriteValueAMD64_OpAMD64BTQconst(v)
 	case OpAMD64BTRLconst:
 		return rewriteValueAMD64_OpAMD64BTRLconst(v)
-	case OpAMD64BTRLconstmodify:
-		return rewriteValueAMD64_OpAMD64BTRLconstmodify(v)
-	case OpAMD64BTRLmodify:
-		return rewriteValueAMD64_OpAMD64BTRLmodify(v)
 	case OpAMD64BTRQconst:
 		return rewriteValueAMD64_OpAMD64BTRQconst(v)
-	case OpAMD64BTRQconstmodify:
-		return rewriteValueAMD64_OpAMD64BTRQconstmodify(v)
-	case OpAMD64BTRQmodify:
-		return rewriteValueAMD64_OpAMD64BTRQmodify(v)
 	case OpAMD64BTSLconst:
 		return rewriteValueAMD64_OpAMD64BTSLconst(v)
-	case OpAMD64BTSLconstmodify:
-		return rewriteValueAMD64_OpAMD64BTSLconstmodify(v)
-	case OpAMD64BTSLmodify:
-		return rewriteValueAMD64_OpAMD64BTSLmodify(v)
 	case OpAMD64BTSQconst:
 		return rewriteValueAMD64_OpAMD64BTSQconst(v)
-	case OpAMD64BTSQconstmodify:
-		return rewriteValueAMD64_OpAMD64BTSQconstmodify(v)
-	case OpAMD64BTSQmodify:
-		return rewriteValueAMD64_OpAMD64BTSQmodify(v)
 	case OpAMD64CMOVLCC:
 		return rewriteValueAMD64_OpAMD64CMOVLCC(v)
 	case OpAMD64CMOVLCS:
@@ -3002,36 +2978,6 @@ func rewriteValueAMD64_OpAMD64ANDLmodify(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
-	b := v.Block
-	// match: (ANDLmodify [off] {sym} ptr (NOTL s:(SHLL (MOVLconst [1]) <t> x)) mem)
-	// result: (BTRLmodify [off] {sym} ptr (ANDLconst <t> [31] x) mem)
-	for {
-		off := auxIntToInt32(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		ptr := v_0
-		if v_1.Op != OpAMD64NOTL {
-			break
-		}
-		s := v_1.Args[0]
-		if s.Op != OpAMD64SHLL {
-			break
-		}
-		t := s.Type
-		x := s.Args[1]
-		s_0 := s.Args[0]
-		if s_0.Op != OpAMD64MOVLconst || auxIntToInt32(s_0.AuxInt) != 1 {
-			break
-		}
-		mem := v_2
-		v.reset(OpAMD64BTRLmodify)
-		v.AuxInt = int32ToAuxInt(off)
-		v.Aux = symToAux(sym)
-		v0 := b.NewValue0(v.Pos, OpAMD64ANDLconst, t)
-		v0.AuxInt = int32ToAuxInt(31)
-		v0.AddArg(x)
-		v.AddArg3(ptr, v0, mem)
-		return true
-	}
 	// match: (ANDLmodify [off1] {sym} (ADDQconst [off2] base) val mem)
 	// cond: is32Bit(int64(off1)+int64(off2))
 	// result: (ANDLmodify [off1+off2] {sym} base val mem)
@@ -3411,36 +3357,6 @@ func rewriteValueAMD64_OpAMD64ANDQmodify(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
-	b := v.Block
-	// match: (ANDQmodify [off] {sym} ptr (NOTQ s:(SHLQ (MOVQconst [1]) <t> x)) mem)
-	// result: (BTRQmodify [off] {sym} ptr (ANDQconst <t> [63] x) mem)
-	for {
-		off := auxIntToInt32(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		ptr := v_0
-		if v_1.Op != OpAMD64NOTQ {
-			break
-		}
-		s := v_1.Args[0]
-		if s.Op != OpAMD64SHLQ {
-			break
-		}
-		t := s.Type
-		x := s.Args[1]
-		s_0 := s.Args[0]
-		if s_0.Op != OpAMD64MOVQconst || auxIntToInt64(s_0.AuxInt) != 1 {
-			break
-		}
-		mem := v_2
-		v.reset(OpAMD64BTRQmodify)
-		v.AuxInt = int32ToAuxInt(off)
-		v.Aux = symToAux(sym)
-		v0 := b.NewValue0(v.Pos, OpAMD64ANDQconst, t)
-		v0.AuxInt = int32ToAuxInt(63)
-		v0.AddArg(x)
-		v.AddArg3(ptr, v0, mem)
-		return true
-	}
 	// match: (ANDQmodify [off1] {sym} (ADDQconst [off2] base) val mem)
 	// cond: is32Bit(int64(off1)+int64(off2))
 	// result: (ANDQmodify [off1+off2] {sym} base val mem)
@@ -3581,105 +3497,6 @@ func rewriteValueAMD64_OpAMD64BTCLconst(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64BTCLconstmodify(v *Value) bool {
-	v_1 := v.Args[1]
-	v_0 := v.Args[0]
-	// match: (BTCLconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
-	// cond: ValAndOff(valoff1).canAdd32(off2)
-	// result: (BTCLconstmodify [ValAndOff(valoff1).addOffset32(off2)] {sym} base mem)
-	for {
-		valoff1 := auxIntToValAndOff(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		if v_0.Op != OpAMD64ADDQconst {
-			break
-		}
-		off2 := auxIntToInt32(v_0.AuxInt)
-		base := v_0.Args[0]
-		mem := v_1
-		if !(ValAndOff(valoff1).canAdd32(off2)) {
-			break
-		}
-		v.reset(OpAMD64BTCLconstmodify)
-		v.AuxInt = valAndOffToAuxInt(ValAndOff(valoff1).addOffset32(off2))
-		v.Aux = symToAux(sym)
-		v.AddArg2(base, mem)
-		return true
-	}
-	// match: (BTCLconstmodify [valoff1] {sym1} (LEAQ [off2] {sym2} base) mem)
-	// cond: ValAndOff(valoff1).canAdd32(off2) && canMergeSym(sym1, sym2)
-	// result: (BTCLconstmodify [ValAndOff(valoff1).addOffset32(off2)] {mergeSym(sym1,sym2)} base mem)
-	for {
-		valoff1 := auxIntToValAndOff(v.AuxInt)
-		sym1 := auxToSym(v.Aux)
-		if v_0.Op != OpAMD64LEAQ {
-			break
-		}
-		off2 := auxIntToInt32(v_0.AuxInt)
-		sym2 := auxToSym(v_0.Aux)
-		base := v_0.Args[0]
-		mem := v_1
-		if !(ValAndOff(valoff1).canAdd32(off2) && canMergeSym(sym1, sym2)) {
-			break
-		}
-		v.reset(OpAMD64BTCLconstmodify)
-		v.AuxInt = valAndOffToAuxInt(ValAndOff(valoff1).addOffset32(off2))
-		v.Aux = symToAux(mergeSym(sym1, sym2))
-		v.AddArg2(base, mem)
-		return true
-	}
-	return false
-}
-func rewriteValueAMD64_OpAMD64BTCLmodify(v *Value) bool {
-	v_2 := v.Args[2]
-	v_1 := v.Args[1]
-	v_0 := v.Args[0]
-	// match: (BTCLmodify [off1] {sym} (ADDQconst [off2] base) val mem)
-	// cond: is32Bit(int64(off1)+int64(off2))
-	// result: (BTCLmodify [off1+off2] {sym} base val mem)
-	for {
-		off1 := auxIntToInt32(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		if v_0.Op != OpAMD64ADDQconst {
-			break
-		}
-		off2 := auxIntToInt32(v_0.AuxInt)
-		base := v_0.Args[0]
-		val := v_1
-		mem := v_2
-		if !(is32Bit(int64(off1) + int64(off2))) {
-			break
-		}
-		v.reset(OpAMD64BTCLmodify)
-		v.AuxInt = int32ToAuxInt(off1 + off2)
-		v.Aux = symToAux(sym)
-		v.AddArg3(base, val, mem)
-		return true
-	}
-	// match: (BTCLmodify [off1] {sym1} (LEAQ [off2] {sym2} base) val mem)
-	// cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
-	// result: (BTCLmodify [off1+off2] {mergeSym(sym1,sym2)} base val mem)
-	for {
-		off1 := auxIntToInt32(v.AuxInt)
-		sym1 := auxToSym(v.Aux)
-		if v_0.Op != OpAMD64LEAQ {
-			break
-		}
-		off2 := auxIntToInt32(v_0.AuxInt)
-		sym2 := auxToSym(v_0.Aux)
-		base := v_0.Args[0]
-		val := v_1
-		mem := v_2
-		if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
-			break
-		}
-		v.reset(OpAMD64BTCLmodify)
-		v.AuxInt = int32ToAuxInt(off1 + off2)
-		v.Aux = symToAux(mergeSym(sym1, sym2))
-		v.AddArg3(base, val, mem)
-		return true
-	}
-	return false
-}
 func rewriteValueAMD64_OpAMD64BTCQconst(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (BTCQconst [c] (XORQconst [d] x))
@@ -3732,105 +3549,6 @@ func rewriteValueAMD64_OpAMD64BTCQconst(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64BTCQconstmodify(v *Value) bool {
-	v_1 := v.Args[1]
-	v_0 := v.Args[0]
-	// match: (BTCQconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
-	// cond: ValAndOff(valoff1).canAdd32(off2)
-	// result: (BTCQconstmodify [ValAndOff(valoff1).addOffset32(off2)] {sym} base mem)
-	for {
-		valoff1 := auxIntToValAndOff(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		if v_0.Op != OpAMD64ADDQconst {
-			break
-		}
-		off2 := auxIntToInt32(v_0.AuxInt)
-		base := v_0.Args[0]
-		mem := v_1
-		if !(ValAndOff(valoff1).canAdd32(off2)) {
-			break
-		}
-		v.reset(OpAMD64BTCQconstmodify)
-		v.AuxInt = valAndOffToAuxInt(ValAndOff(valoff1).addOffset32(off2))
-		v.Aux = symToAux(sym)
-		v.AddArg2(base, mem)
-		return true
-	}
-	// match: (BTCQconstmodify [valoff1] {sym1} (LEAQ [off2] {sym2} base) mem)
-	// cond: ValAndOff(valoff1).canAdd32(off2) && canMergeSym(sym1, sym2)
-	// result: (BTCQconstmodify [ValAndOff(valoff1).addOffset32(off2)] {mergeSym(sym1,sym2)} base mem)
-	for {
-		valoff1 := auxIntToValAndOff(v.AuxInt)
-		sym1 := auxToSym(v.Aux)
-		if v_0.Op != OpAMD64LEAQ {
-			break
-		}
-		off2 := auxIntToInt32(v_0.AuxInt)
-		sym2 := auxToSym(v_0.Aux)
-		base := v_0.Args[0]
-		mem := v_1
-		if !(ValAndOff(valoff1).canAdd32(off2) && canMergeSym(sym1, sym2)) {
-			break
-		}
-		v.reset(OpAMD64BTCQconstmodify)
-		v.AuxInt = valAndOffToAuxInt(ValAndOff(valoff1).addOffset32(off2))
-		v.Aux = symToAux(mergeSym(sym1, sym2))
-		v.AddArg2(base, mem)
-		return true
-	}
-	return false
-}
-func rewriteValueAMD64_OpAMD64BTCQmodify(v *Value) bool {
-	v_2 := v.Args[2]
-	v_1 := v.Args[1]
-	v_0 := v.Args[0]
-	// match: (BTCQmodify [off1] {sym} (ADDQconst [off2] base) val mem)
-	// cond: is32Bit(int64(off1)+int64(off2))
-	// result: (BTCQmodify [off1+off2] {sym} base val mem)
-	for {
-		off1 := auxIntToInt32(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		if v_0.Op != OpAMD64ADDQconst {
-			break
-		}
-		off2 := auxIntToInt32(v_0.AuxInt)
-		base := v_0.Args[0]
-		val := v_1
-		mem := v_2
-		if !(is32Bit(int64(off1) + int64(off2))) {
-			break
-		}
-		v.reset(OpAMD64BTCQmodify)
-		v.AuxInt = int32ToAuxInt(off1 + off2)
-		v.Aux = symToAux(sym)
-		v.AddArg3(base, val, mem)
-		return true
-	}
-	// match: (BTCQmodify [off1] {sym1} (LEAQ [off2] {sym2} base) val mem)
-	// cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
-	// result: (BTCQmodify [off1+off2] {mergeSym(sym1,sym2)} base val mem)
-	for {
-		off1 := auxIntToInt32(v.AuxInt)
-		sym1 := auxToSym(v.Aux)
-		if v_0.Op != OpAMD64LEAQ {
-			break
-		}
-		off2 := auxIntToInt32(v_0.AuxInt)
-		sym2 := auxToSym(v_0.Aux)
-		base := v_0.Args[0]
-		val := v_1
-		mem := v_2
-		if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
-			break
-		}
-		v.reset(OpAMD64BTCQmodify)
-		v.AuxInt = int32ToAuxInt(off1 + off2)
-		v.Aux = symToAux(mergeSym(sym1, sym2))
-		v.AddArg3(base, val, mem)
-		return true
-	}
-	return false
-}
 func rewriteValueAMD64_OpAMD64BTLconst(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (BTLconst [c] (SHRQconst [d] x))
@@ -4065,105 +3783,6 @@ func rewriteValueAMD64_OpAMD64BTRLconst(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64BTRLconstmodify(v *Value) bool {
-	v_1 := v.Args[1]
-	v_0 := v.Args[0]
-	// match: (BTRLconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
-	// cond: ValAndOff(valoff1).canAdd32(off2)
-	// result: (BTRLconstmodify [ValAndOff(valoff1).addOffset32(off2)] {sym} base mem)
-	for {
-		valoff1 := auxIntToValAndOff(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		if v_0.Op != OpAMD64ADDQconst {
-			break
-		}
-		off2 := auxIntToInt32(v_0.AuxInt)
-		base := v_0.Args[0]
-		mem := v_1
-		if !(ValAndOff(valoff1).canAdd32(off2)) {
-			break
-		}
-		v.reset(OpAMD64BTRLconstmodify)
-		v.AuxInt = valAndOffToAuxInt(ValAndOff(valoff1).addOffset32(off2))
-		v.Aux = symToAux(sym)
-		v.AddArg2(base, mem)
-		return true
-	}
-	// match: (BTRLconstmodify [valoff1] {sym1} (LEAQ [off2] {sym2} base) mem)
-	// cond: ValAndOff(valoff1).canAdd32(off2) && canMergeSym(sym1, sym2)
-	// result: (BTRLconstmodify [ValAndOff(valoff1).addOffset32(off2)] {mergeSym(sym1,sym2)} base mem)
-	for {
-		valoff1 := auxIntToValAndOff(v.AuxInt)
-		sym1 := auxToSym(v.Aux)
-		if v_0.Op != OpAMD64LEAQ {
-			break
-		}
-		off2 := auxIntToInt32(v_0.AuxInt)
-		sym2 := auxToSym(v_0.Aux)
-		base := v_0.Args[0]
-		mem := v_1
-		if !(ValAndOff(valoff1).canAdd32(off2) && canMergeSym(sym1, sym2)) {
-			break
-		}
-		v.reset(OpAMD64BTRLconstmodify)
-		v.AuxInt = valAndOffToAuxInt(ValAndOff(valoff1).addOffset32(off2))
-		v.Aux = symToAux(mergeSym(sym1, sym2))
-		v.AddArg2(base, mem)
-		return true
-	}
-	return false
-}
-func rewriteValueAMD64_OpAMD64BTRLmodify(v *Value) bool {
-	v_2 := v.Args[2]
-	v_1 := v.Args[1]
-	v_0 := v.Args[0]
-	// match: (BTRLmodify [off1] {sym} (ADDQconst [off2] base) val mem)
-	// cond: is32Bit(int64(off1)+int64(off2))
-	// result: (BTRLmodify [off1+off2] {sym} base val mem)
-	for {
-		off1 := auxIntToInt32(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		if v_0.Op != OpAMD64ADDQconst {
-			break
-		}
-		off2 := auxIntToInt32(v_0.AuxInt)
-		base := v_0.Args[0]
-		val := v_1
-		mem := v_2
-		if !(is32Bit(int64(off1) + int64(off2))) {
-			break
-		}
-		v.reset(OpAMD64BTRLmodify)
-		v.AuxInt = int32ToAuxInt(off1 + off2)
-		v.Aux = symToAux(sym)
-		v.AddArg3(base, val, mem)
-		return true
-	}
-	// match: (BTRLmodify [off1] {sym1} (LEAQ [off2] {sym2} base) val mem)
-	// cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
-	// result: (BTRLmodify [off1+off2] {mergeSym(sym1,sym2)} base val mem)
-	for {
-		off1 := auxIntToInt32(v.AuxInt)
-		sym1 := auxToSym(v.Aux)
-		if v_0.Op != OpAMD64LEAQ {
-			break
-		}
-		off2 := auxIntToInt32(v_0.AuxInt)
-		sym2 := auxToSym(v_0.Aux)
-		base := v_0.Args[0]
-		val := v_1
-		mem := v_2
-		if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
-			break
-		}
-		v.reset(OpAMD64BTRLmodify)
-		v.AuxInt = int32ToAuxInt(off1 + off2)
-		v.Aux = symToAux(mergeSym(sym1, sym2))
-		v.AddArg3(base, val, mem)
-		return true
-	}
-	return false
-}
 func rewriteValueAMD64_OpAMD64BTRQconst(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (BTRQconst [c] (BTSQconst [c] x))
@@ -4242,105 +3861,6 @@ func rewriteValueAMD64_OpAMD64BTRQconst(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64BTRQconstmodify(v *Value) bool {
-	v_1 := v.Args[1]
-	v_0 := v.Args[0]
-	// match: (BTRQconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
-	// cond: ValAndOff(valoff1).canAdd32(off2)
-	// result: (BTRQconstmodify [ValAndOff(valoff1).addOffset32(off2)] {sym} base mem)
-	for {
-		valoff1 := auxIntToValAndOff(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		if v_0.Op != OpAMD64ADDQconst {
-			break
-		}
-		off2 := auxIntToInt32(v_0.AuxInt)
-		base := v_0.Args[0]
-		mem := v_1
-		if !(ValAndOff(valoff1).canAdd32(off2)) {
-			break
-		}
-		v.reset(OpAMD64BTRQconstmodify)
-		v.AuxInt = valAndOffToAuxInt(ValAndOff(valoff1).addOffset32(off2))
-		v.Aux = symToAux(sym)
-		v.AddArg2(base, mem)
-		return true
-	}
-	// match: (BTRQconstmodify [valoff1] {sym1} (LEAQ [off2] {sym2} base) mem)
-	// cond: ValAndOff(valoff1).canAdd32(off2) && canMergeSym(sym1, sym2)
-	// result: (BTRQconstmodify [ValAndOff(valoff1).addOffset32(off2)] {mergeSym(sym1,sym2)} base mem)
-	for {
-		valoff1 := auxIntToValAndOff(v.AuxInt)
-		sym1 := auxToSym(v.Aux)
-		if v_0.Op != OpAMD64LEAQ {
-			break
-		}
-		off2 := auxIntToInt32(v_0.AuxInt)
-		sym2 := auxToSym(v_0.Aux)
-		base := v_0.Args[0]
-		mem := v_1
-		if !(ValAndOff(valoff1).canAdd32(off2) && canMergeSym(sym1, sym2)) {
-			break
-		}
-		v.reset(OpAMD64BTRQconstmodify)
-		v.AuxInt = valAndOffToAuxInt(ValAndOff(valoff1).addOffset32(off2))
-		v.Aux = symToAux(mergeSym(sym1, sym2))
-		v.AddArg2(base, mem)
-		return true
-	}
-	return false
-}
-func rewriteValueAMD64_OpAMD64BTRQmodify(v *Value) bool {
-	v_2 := v.Args[2]
-	v_1 := v.Args[1]
-	v_0 := v.Args[0]
-	// match: (BTRQmodify [off1] {sym} (ADDQconst [off2] base) val mem)
-	// cond: is32Bit(int64(off1)+int64(off2))
-	// result: (BTRQmodify [off1+off2] {sym} base val mem)
-	for {
-		off1 := auxIntToInt32(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		if v_0.Op != OpAMD64ADDQconst {
-			break
-		}
-		off2 := auxIntToInt32(v_0.AuxInt)
-		base := v_0.Args[0]
-		val := v_1
-		mem := v_2
-		if !(is32Bit(int64(off1) + int64(off2))) {
-			break
-		}
-		v.reset(OpAMD64BTRQmodify)
-		v.AuxInt = int32ToAuxInt(off1 + off2)
-		v.Aux = symToAux(sym)
-		v.AddArg3(base, val, mem)
-		return true
-	}
-	// match: (BTRQmodify [off1] {sym1} (LEAQ [off2] {sym2} base) val mem)
-	// cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
-	// result: (BTRQmodify [off1+off2] {mergeSym(sym1,sym2)} base val mem)
-	for {
-		off1 := auxIntToInt32(v.AuxInt)
-		sym1 := auxToSym(v.Aux)
-		if v_0.Op != OpAMD64LEAQ {
-			break
-		}
-		off2 := auxIntToInt32(v_0.AuxInt)
-		sym2 := auxToSym(v_0.Aux)
-		base := v_0.Args[0]
-		val := v_1
-		mem := v_2
-		if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
-			break
-		}
-		v.reset(OpAMD64BTRQmodify)
-		v.AuxInt = int32ToAuxInt(off1 + off2)
-		v.Aux = symToAux(mergeSym(sym1, sym2))
-		v.AddArg3(base, val, mem)
-		return true
-	}
-	return false
-}
 func rewriteValueAMD64_OpAMD64BTSLconst(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (BTSLconst [c] (BTRLconst [c] x))
@@ -4404,108 +3924,9 @@ func rewriteValueAMD64_OpAMD64BTSLconst(v *Value) bool {
 		if v_0.Op != OpAMD64MOVLconst {
 			break
 		}
-		d := auxIntToInt32(v_0.AuxInt)
-		v.reset(OpAMD64MOVLconst)
-		v.AuxInt = int32ToAuxInt(d | (1 << uint32(c)))
-		return true
-	}
-	return false
-}
-func rewriteValueAMD64_OpAMD64BTSLconstmodify(v *Value) bool {
-	v_1 := v.Args[1]
-	v_0 := v.Args[0]
-	// match: (BTSLconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
-	// cond: ValAndOff(valoff1).canAdd32(off2)
-	// result: (BTSLconstmodify [ValAndOff(valoff1).addOffset32(off2)] {sym} base mem)
-	for {
-		valoff1 := auxIntToValAndOff(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		if v_0.Op != OpAMD64ADDQconst {
-			break
-		}
-		off2 := auxIntToInt32(v_0.AuxInt)
-		base := v_0.Args[0]
-		mem := v_1
-		if !(ValAndOff(valoff1).canAdd32(off2)) {
-			break
-		}
-		v.reset(OpAMD64BTSLconstmodify)
-		v.AuxInt = valAndOffToAuxInt(ValAndOff(valoff1).addOffset32(off2))
-		v.Aux = symToAux(sym)
-		v.AddArg2(base, mem)
-		return true
-	}
-	// match: (BTSLconstmodify [valoff1] {sym1} (LEAQ [off2] {sym2} base) mem)
-	// cond: ValAndOff(valoff1).canAdd32(off2) && canMergeSym(sym1, sym2)
-	// result: (BTSLconstmodify [ValAndOff(valoff1).addOffset32(off2)] {mergeSym(sym1,sym2)} base mem)
-	for {
-		valoff1 := auxIntToValAndOff(v.AuxInt)
-		sym1 := auxToSym(v.Aux)
-		if v_0.Op != OpAMD64LEAQ {
-			break
-		}
-		off2 := auxIntToInt32(v_0.AuxInt)
-		sym2 := auxToSym(v_0.Aux)
-		base := v_0.Args[0]
-		mem := v_1
-		if !(ValAndOff(valoff1).canAdd32(off2) && canMergeSym(sym1, sym2)) {
-			break
-		}
-		v.reset(OpAMD64BTSLconstmodify)
-		v.AuxInt = valAndOffToAuxInt(ValAndOff(valoff1).addOffset32(off2))
-		v.Aux = symToAux(mergeSym(sym1, sym2))
-		v.AddArg2(base, mem)
-		return true
-	}
-	return false
-}
-func rewriteValueAMD64_OpAMD64BTSLmodify(v *Value) bool {
-	v_2 := v.Args[2]
-	v_1 := v.Args[1]
-	v_0 := v.Args[0]
-	// match: (BTSLmodify [off1] {sym} (ADDQconst [off2] base) val mem)
-	// cond: is32Bit(int64(off1)+int64(off2))
-	// result: (BTSLmodify [off1+off2] {sym} base val mem)
-	for {
-		off1 := auxIntToInt32(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		if v_0.Op != OpAMD64ADDQconst {
-			break
-		}
-		off2 := auxIntToInt32(v_0.AuxInt)
-		base := v_0.Args[0]
-		val := v_1
-		mem := v_2
-		if !(is32Bit(int64(off1) + int64(off2))) {
-			break
-		}
-		v.reset(OpAMD64BTSLmodify)
-		v.AuxInt = int32ToAuxInt(off1 + off2)
-		v.Aux = symToAux(sym)
-		v.AddArg3(base, val, mem)
-		return true
-	}
-	// match: (BTSLmodify [off1] {sym1} (LEAQ [off2] {sym2} base) val mem)
-	// cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
-	// result: (BTSLmodify [off1+off2] {mergeSym(sym1,sym2)} base val mem)
-	for {
-		off1 := auxIntToInt32(v.AuxInt)
-		sym1 := auxToSym(v.Aux)
-		if v_0.Op != OpAMD64LEAQ {
-			break
-		}
-		off2 := auxIntToInt32(v_0.AuxInt)
-		sym2 := auxToSym(v_0.Aux)
-		base := v_0.Args[0]
-		val := v_1
-		mem := v_2
-		if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
-			break
-		}
-		v.reset(OpAMD64BTSLmodify)
-		v.AuxInt = int32ToAuxInt(off1 + off2)
-		v.Aux = symToAux(mergeSym(sym1, sym2))
-		v.AddArg3(base, val, mem)
+		d := auxIntToInt32(v_0.AuxInt)
+		v.reset(OpAMD64MOVLconst)
+		v.AuxInt = int32ToAuxInt(d | (1 << uint32(c)))
 		return true
 	}
 	return false
@@ -4588,105 +4009,6 @@ func rewriteValueAMD64_OpAMD64BTSQconst(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64BTSQconstmodify(v *Value) bool {
-	v_1 := v.Args[1]
-	v_0 := v.Args[0]
-	// match: (BTSQconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
-	// cond: ValAndOff(valoff1).canAdd32(off2)
-	// result: (BTSQconstmodify [ValAndOff(valoff1).addOffset32(off2)] {sym} base mem)
-	for {
-		valoff1 := auxIntToValAndOff(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		if v_0.Op != OpAMD64ADDQconst {
-			break
-		}
-		off2 := auxIntToInt32(v_0.AuxInt)
-		base := v_0.Args[0]
-		mem := v_1
-		if !(ValAndOff(valoff1).canAdd32(off2)) {
-			break
-		}
-		v.reset(OpAMD64BTSQconstmodify)
-		v.AuxInt = valAndOffToAuxInt(ValAndOff(valoff1).addOffset32(off2))
-		v.Aux = symToAux(sym)
-		v.AddArg2(base, mem)
-		return true
-	}
-	// match: (BTSQconstmodify [valoff1] {sym1} (LEAQ [off2] {sym2} base) mem)
-	// cond: ValAndOff(valoff1).canAdd32(off2) && canMergeSym(sym1, sym2)
-	// result: (BTSQconstmodify [ValAndOff(valoff1).addOffset32(off2)] {mergeSym(sym1,sym2)} base mem)
-	for {
-		valoff1 := auxIntToValAndOff(v.AuxInt)
-		sym1 := auxToSym(v.Aux)
-		if v_0.Op != OpAMD64LEAQ {
-			break
-		}
-		off2 := auxIntToInt32(v_0.AuxInt)
-		sym2 := auxToSym(v_0.Aux)
-		base := v_0.Args[0]
-		mem := v_1
-		if !(ValAndOff(valoff1).canAdd32(off2) && canMergeSym(sym1, sym2)) {
-			break
-		}
-		v.reset(OpAMD64BTSQconstmodify)
-		v.AuxInt = valAndOffToAuxInt(ValAndOff(valoff1).addOffset32(off2))
-		v.Aux = symToAux(mergeSym(sym1, sym2))
-		v.AddArg2(base, mem)
-		return true
-	}
-	return false
-}
-func rewriteValueAMD64_OpAMD64BTSQmodify(v *Value) bool {
-	v_2 := v.Args[2]
-	v_1 := v.Args[1]
-	v_0 := v.Args[0]
-	// match: (BTSQmodify [off1] {sym} (ADDQconst [off2] base) val mem)
-	// cond: is32Bit(int64(off1)+int64(off2))
-	// result: (BTSQmodify [off1+off2] {sym} base val mem)
-	for {
-		off1 := auxIntToInt32(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		if v_0.Op != OpAMD64ADDQconst {
-			break
-		}
-		off2 := auxIntToInt32(v_0.AuxInt)
-		base := v_0.Args[0]
-		val := v_1
-		mem := v_2
-		if !(is32Bit(int64(off1) + int64(off2))) {
-			break
-		}
-		v.reset(OpAMD64BTSQmodify)
-		v.AuxInt = int32ToAuxInt(off1 + off2)
-		v.Aux = symToAux(sym)
-		v.AddArg3(base, val, mem)
-		return true
-	}
-	// match: (BTSQmodify [off1] {sym1} (LEAQ [off2] {sym2} base) val mem)
-	// cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
-	// result: (BTSQmodify [off1+off2] {mergeSym(sym1,sym2)} base val mem)
-	for {
-		off1 := auxIntToInt32(v.AuxInt)
-		sym1 := auxToSym(v.Aux)
-		if v_0.Op != OpAMD64LEAQ {
-			break
-		}
-		off2 := auxIntToInt32(v_0.AuxInt)
-		sym2 := auxToSym(v_0.Aux)
-		base := v_0.Args[0]
-		val := v_1
-		mem := v_2
-		if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
-			break
-		}
-		v.reset(OpAMD64BTSQmodify)
-		v.AuxInt = int32ToAuxInt(off1 + off2)
-		v.Aux = symToAux(mergeSym(sym1, sym2))
-		v.AddArg3(base, val, mem)
-		return true
-	}
-	return false
-}
 func rewriteValueAMD64_OpAMD64CMOVLCC(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
@@ -12783,214 +12105,43 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
 		ptr := v_0
-		y := v_1
-		if y.Op != OpAMD64XORL {
-			break
-		}
-		_ = y.Args[1]
-		y_0 := y.Args[0]
-		y_1 := y.Args[1]
-		for _i0 := 0; _i0 <= 1; _i0, y_0, y_1 = _i0+1, y_1, y_0 {
-			l := y_0
-			if l.Op != OpAMD64MOVLload || auxIntToInt32(l.AuxInt) != off || auxToSym(l.Aux) != sym {
-				continue
-			}
-			mem := l.Args[1]
-			if ptr != l.Args[0] {
-				continue
-			}
-			x := y_1
-			if mem != v_2 || !(y.Uses == 1 && l.Uses == 1 && clobber(y, l)) {
-				continue
-			}
-			v.reset(OpAMD64XORLmodify)
-			v.AuxInt = int32ToAuxInt(off)
-			v.Aux = symToAux(sym)
-			v.AddArg3(ptr, x, mem)
-			return true
-		}
-		break
-	}
-	// match: (MOVLstore {sym} [off] ptr y:(BTCL l:(MOVLload [off] {sym} ptr mem) <t> x) mem)
-	// cond: y.Uses==1 && l.Uses==1 && clobber(y, l)
-	// result: (BTCLmodify [off] {sym} ptr (ANDLconst <t> [31] x) mem)
-	for {
-		off := auxIntToInt32(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		ptr := v_0
-		y := v_1
-		if y.Op != OpAMD64BTCL {
-			break
-		}
-		t := y.Type
-		x := y.Args[1]
-		l := y.Args[0]
-		if l.Op != OpAMD64MOVLload || auxIntToInt32(l.AuxInt) != off || auxToSym(l.Aux) != sym {
-			break
-		}
-		mem := l.Args[1]
-		if ptr != l.Args[0] || mem != v_2 || !(y.Uses == 1 && l.Uses == 1 && clobber(y, l)) {
-			break
-		}
-		v.reset(OpAMD64BTCLmodify)
-		v.AuxInt = int32ToAuxInt(off)
-		v.Aux = symToAux(sym)
-		v0 := b.NewValue0(l.Pos, OpAMD64ANDLconst, t)
-		v0.AuxInt = int32ToAuxInt(31)
-		v0.AddArg(x)
-		v.AddArg3(ptr, v0, mem)
-		return true
-	}
-	// match: (MOVLstore {sym} [off] ptr y:(BTRL l:(MOVLload [off] {sym} ptr mem) <t> x) mem)
-	// cond: y.Uses==1 && l.Uses==1 && clobber(y, l)
-	// result: (BTRLmodify [off] {sym} ptr (ANDLconst <t> [31] x) mem)
-	for {
-		off := auxIntToInt32(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		ptr := v_0
-		y := v_1
-		if y.Op != OpAMD64BTRL {
-			break
-		}
-		t := y.Type
-		x := y.Args[1]
-		l := y.Args[0]
-		if l.Op != OpAMD64MOVLload || auxIntToInt32(l.AuxInt) != off || auxToSym(l.Aux) != sym {
-			break
-		}
-		mem := l.Args[1]
-		if ptr != l.Args[0] || mem != v_2 || !(y.Uses == 1 && l.Uses == 1 && clobber(y, l)) {
-			break
-		}
-		v.reset(OpAMD64BTRLmodify)
-		v.AuxInt = int32ToAuxInt(off)
-		v.Aux = symToAux(sym)
-		v0 := b.NewValue0(l.Pos, OpAMD64ANDLconst, t)
-		v0.AuxInt = int32ToAuxInt(31)
-		v0.AddArg(x)
-		v.AddArg3(ptr, v0, mem)
-		return true
-	}
-	// match: (MOVLstore {sym} [off] ptr y:(BTSL l:(MOVLload [off] {sym} ptr mem) <t> x) mem)
-	// cond: y.Uses==1 && l.Uses==1 && clobber(y, l)
-	// result: (BTSLmodify [off] {sym} ptr (ANDLconst <t> [31] x) mem)
-	for {
-		off := auxIntToInt32(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		ptr := v_0
-		y := v_1
-		if y.Op != OpAMD64BTSL {
-			break
-		}
-		t := y.Type
-		x := y.Args[1]
-		l := y.Args[0]
-		if l.Op != OpAMD64MOVLload || auxIntToInt32(l.AuxInt) != off || auxToSym(l.Aux) != sym {
-			break
-		}
-		mem := l.Args[1]
-		if ptr != l.Args[0] || mem != v_2 || !(y.Uses == 1 && l.Uses == 1 && clobber(y, l)) {
-			break
-		}
-		v.reset(OpAMD64BTSLmodify)
-		v.AuxInt = int32ToAuxInt(off)
-		v.Aux = symToAux(sym)
-		v0 := b.NewValue0(l.Pos, OpAMD64ANDLconst, t)
-		v0.AuxInt = int32ToAuxInt(31)
-		v0.AddArg(x)
-		v.AddArg3(ptr, v0, mem)
-		return true
-	}
-	// match: (MOVLstore [off] {sym} ptr a:(ADDLconst [c] l:(MOVLload [off] {sym} ptr2 mem)) mem)
-	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
-	// result: (ADDLconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
-	for {
-		off := auxIntToInt32(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		ptr := v_0
-		a := v_1
-		if a.Op != OpAMD64ADDLconst {
-			break
-		}
-		c := auxIntToInt32(a.AuxInt)
-		l := a.Args[0]
-		if l.Op != OpAMD64MOVLload || auxIntToInt32(l.AuxInt) != off || auxToSym(l.Aux) != sym {
-			break
-		}
-		mem := l.Args[1]
-		ptr2 := l.Args[0]
-		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)) {
-			break
-		}
-		v.reset(OpAMD64ADDLconstmodify)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
-		v.Aux = symToAux(sym)
-		v.AddArg2(ptr, mem)
-		return true
-	}
-	// match: (MOVLstore [off] {sym} ptr a:(ANDLconst [c] l:(MOVLload [off] {sym} ptr2 mem)) mem)
-	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
-	// result: (ANDLconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
-	for {
-		off := auxIntToInt32(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		ptr := v_0
-		a := v_1
-		if a.Op != OpAMD64ANDLconst {
-			break
-		}
-		c := auxIntToInt32(a.AuxInt)
-		l := a.Args[0]
-		if l.Op != OpAMD64MOVLload || auxIntToInt32(l.AuxInt) != off || auxToSym(l.Aux) != sym {
-			break
-		}
-		mem := l.Args[1]
-		ptr2 := l.Args[0]
-		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)) {
-			break
-		}
-		v.reset(OpAMD64ANDLconstmodify)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
-		v.Aux = symToAux(sym)
-		v.AddArg2(ptr, mem)
-		return true
-	}
-	// match: (MOVLstore [off] {sym} ptr a:(ORLconst [c] l:(MOVLload [off] {sym} ptr2 mem)) mem)
-	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
-	// result: (ORLconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
-	for {
-		off := auxIntToInt32(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		ptr := v_0
-		a := v_1
-		if a.Op != OpAMD64ORLconst {
-			break
-		}
-		c := auxIntToInt32(a.AuxInt)
-		l := a.Args[0]
-		if l.Op != OpAMD64MOVLload || auxIntToInt32(l.AuxInt) != off || auxToSym(l.Aux) != sym {
+		y := v_1
+		if y.Op != OpAMD64XORL {
 			break
 		}
-		mem := l.Args[1]
-		ptr2 := l.Args[0]
-		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)) {
-			break
+		_ = y.Args[1]
+		y_0 := y.Args[0]
+		y_1 := y.Args[1]
+		for _i0 := 0; _i0 <= 1; _i0, y_0, y_1 = _i0+1, y_1, y_0 {
+			l := y_0
+			if l.Op != OpAMD64MOVLload || auxIntToInt32(l.AuxInt) != off || auxToSym(l.Aux) != sym {
+				continue
+			}
+			mem := l.Args[1]
+			if ptr != l.Args[0] {
+				continue
+			}
+			x := y_1
+			if mem != v_2 || !(y.Uses == 1 && l.Uses == 1 && clobber(y, l)) {
+				continue
+			}
+			v.reset(OpAMD64XORLmodify)
+			v.AuxInt = int32ToAuxInt(off)
+			v.Aux = symToAux(sym)
+			v.AddArg3(ptr, x, mem)
+			return true
 		}
-		v.reset(OpAMD64ORLconstmodify)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
-		v.Aux = symToAux(sym)
-		v.AddArg2(ptr, mem)
-		return true
+		break
 	}
-	// match: (MOVLstore [off] {sym} ptr a:(XORLconst [c] l:(MOVLload [off] {sym} ptr2 mem)) mem)
+	// match: (MOVLstore [off] {sym} ptr a:(ADDLconst [c] l:(MOVLload [off] {sym} ptr2 mem)) mem)
 	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
-	// result: (XORLconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
+	// result: (ADDLconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
 		ptr := v_0
 		a := v_1
-		if a.Op != OpAMD64XORLconst {
+		if a.Op != OpAMD64ADDLconst {
 			break
 		}
 		c := auxIntToInt32(a.AuxInt)
@@ -13003,24 +12154,24 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
 		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)) {
 			break
 		}
-		v.reset(OpAMD64XORLconstmodify)
+		v.reset(OpAMD64ADDLconstmodify)
 		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
 	}
-	// match: (MOVLstore [off] {sym} ptr a:(BTCLconst [c] l:(MOVLload [off] {sym} ptr2 mem)) mem)
+	// match: (MOVLstore [off] {sym} ptr a:(ANDLconst [c] l:(MOVLload [off] {sym} ptr2 mem)) mem)
 	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
-	// result: (BTCLconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
+	// result: (ANDLconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
 		ptr := v_0
 		a := v_1
-		if a.Op != OpAMD64BTCLconst {
+		if a.Op != OpAMD64ANDLconst {
 			break
 		}
-		c := auxIntToInt8(a.AuxInt)
+		c := auxIntToInt32(a.AuxInt)
 		l := a.Args[0]
 		if l.Op != OpAMD64MOVLload || auxIntToInt32(l.AuxInt) != off || auxToSym(l.Aux) != sym {
 			break
@@ -13030,24 +12181,24 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
 		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)) {
 			break
 		}
-		v.reset(OpAMD64BTCLconstmodify)
+		v.reset(OpAMD64ANDLconstmodify)
 		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
 	}
-	// match: (MOVLstore [off] {sym} ptr a:(BTRLconst [c] l:(MOVLload [off] {sym} ptr2 mem)) mem)
+	// match: (MOVLstore [off] {sym} ptr a:(ORLconst [c] l:(MOVLload [off] {sym} ptr2 mem)) mem)
 	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
-	// result: (BTRLconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
+	// result: (ORLconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
 		ptr := v_0
 		a := v_1
-		if a.Op != OpAMD64BTRLconst {
+		if a.Op != OpAMD64ORLconst {
 			break
 		}
-		c := auxIntToInt8(a.AuxInt)
+		c := auxIntToInt32(a.AuxInt)
 		l := a.Args[0]
 		if l.Op != OpAMD64MOVLload || auxIntToInt32(l.AuxInt) != off || auxToSym(l.Aux) != sym {
 			break
@@ -13057,24 +12208,24 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
 		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)) {
 			break
 		}
-		v.reset(OpAMD64BTRLconstmodify)
+		v.reset(OpAMD64ORLconstmodify)
 		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
 		return true
 	}
-	// match: (MOVLstore [off] {sym} ptr a:(BTSLconst [c] l:(MOVLload [off] {sym} ptr2 mem)) mem)
+	// match: (MOVLstore [off] {sym} ptr a:(XORLconst [c] l:(MOVLload [off] {sym} ptr2 mem)) mem)
 	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
-	// result: (BTSLconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
+	// result: (XORLconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
 	for {
 		off := auxIntToInt32(v.AuxInt)
 		sym := auxToSym(v.Aux)
 		ptr := v_0
 		a := v_1
-		if a.Op != OpAMD64BTSLconst {
+		if a.Op != OpAMD64XORLconst {
 			break
 		}
-		c := auxIntToInt8(a.AuxInt)
+		c := auxIntToInt32(a.AuxInt)
 		l := a.Args[0]
 		if l.Op != OpAMD64MOVLload || auxIntToInt32(l.AuxInt) != off || auxToSym(l.Aux) != sym {
 			break
@@ -13084,7 +12235,7 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
 		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)) {
 			break
 		}
-		v.reset(OpAMD64BTSLconstmodify)
+		v.reset(OpAMD64XORLconstmodify)
 		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
 		v.Aux = symToAux(sym)
 		v.AddArg2(ptr, mem)
@@ -13639,7 +12790,6 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
-	b := v.Block
 	// match: (MOVQstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
 	// cond: is32Bit(int64(off1)+int64(off2))
 	// result: (MOVQstore [off1+off2] {sym} ptr val mem)
@@ -14005,96 +13155,6 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
 		}
 		break
 	}
-	// match: (MOVQstore {sym} [off] ptr y:(BTCQ l:(MOVQload [off] {sym} ptr mem) <t> x) mem)
-	// cond: y.Uses==1 && l.Uses==1 && clobber(y, l)
-	// result: (BTCQmodify [off] {sym} ptr (ANDQconst <t> [63] x) mem)
-	for {
-		off := auxIntToInt32(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		ptr := v_0
-		y := v_1
-		if y.Op != OpAMD64BTCQ {
-			break
-		}
-		t := y.Type
-		x := y.Args[1]
-		l := y.Args[0]
-		if l.Op != OpAMD64MOVQload || auxIntToInt32(l.AuxInt) != off || auxToSym(l.Aux) != sym {
-			break
-		}
-		mem := l.Args[1]
-		if ptr != l.Args[0] || mem != v_2 || !(y.Uses == 1 && l.Uses == 1 && clobber(y, l)) {
-			break
-		}
-		v.reset(OpAMD64BTCQmodify)
-		v.AuxInt = int32ToAuxInt(off)
-		v.Aux = symToAux(sym)
-		v0 := b.NewValue0(l.Pos, OpAMD64ANDQconst, t)
-		v0.AuxInt = int32ToAuxInt(63)
-		v0.AddArg(x)
-		v.AddArg3(ptr, v0, mem)
-		return true
-	}
-	// match: (MOVQstore {sym} [off] ptr y:(BTRQ l:(MOVQload [off] {sym} ptr mem) <t> x) mem)
-	// cond: y.Uses==1 && l.Uses==1 && clobber(y, l)
-	// result: (BTRQmodify [off] {sym} ptr (ANDQconst <t> [63] x) mem)
-	for {
-		off := auxIntToInt32(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		ptr := v_0
-		y := v_1
-		if y.Op != OpAMD64BTRQ {
-			break
-		}
-		t := y.Type
-		x := y.Args[1]
-		l := y.Args[0]
-		if l.Op != OpAMD64MOVQload || auxIntToInt32(l.AuxInt) != off || auxToSym(l.Aux) != sym {
-			break
-		}
-		mem := l.Args[1]
-		if ptr != l.Args[0] || mem != v_2 || !(y.Uses == 1 && l.Uses == 1 && clobber(y, l)) {
-			break
-		}
-		v.reset(OpAMD64BTRQmodify)
-		v.AuxInt = int32ToAuxInt(off)
-		v.Aux = symToAux(sym)
-		v0 := b.NewValue0(l.Pos, OpAMD64ANDQconst, t)
-		v0.AuxInt = int32ToAuxInt(63)
-		v0.AddArg(x)
-		v.AddArg3(ptr, v0, mem)
-		return true
-	}
-	// match: (MOVQstore {sym} [off] ptr y:(BTSQ l:(MOVQload [off] {sym} ptr mem) <t> x) mem)
-	// cond: y.Uses==1 && l.Uses==1 && clobber(y, l)
-	// result: (BTSQmodify [off] {sym} ptr (ANDQconst <t> [63] x) mem)
-	for {
-		off := auxIntToInt32(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		ptr := v_0
-		y := v_1
-		if y.Op != OpAMD64BTSQ {
-			break
-		}
-		t := y.Type
-		x := y.Args[1]
-		l := y.Args[0]
-		if l.Op != OpAMD64MOVQload || auxIntToInt32(l.AuxInt) != off || auxToSym(l.Aux) != sym {
-			break
-		}
-		mem := l.Args[1]
-		if ptr != l.Args[0] || mem != v_2 || !(y.Uses == 1 && l.Uses == 1 && clobber(y, l)) {
-			break
-		}
-		v.reset(OpAMD64BTSQmodify)
-		v.AuxInt = int32ToAuxInt(off)
-		v.Aux = symToAux(sym)
-		v0 := b.NewValue0(l.Pos, OpAMD64ANDQconst, t)
-		v0.AuxInt = int32ToAuxInt(63)
-		v0.AddArg(x)
-		v.AddArg3(ptr, v0, mem)
-		return true
-	}
 	// match: (MOVQstore [off] {sym} ptr a:(ADDQconst [c] l:(MOVQload [off] {sym} ptr2 mem)) mem)
 	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
 	// result: (ADDQconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
@@ -14203,87 +13263,6 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
 		v.AddArg2(ptr, mem)
 		return true
 	}
-	// match: (MOVQstore [off] {sym} ptr a:(BTCQconst [c] l:(MOVQload [off] {sym} ptr2 mem)) mem)
-	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
-	// result: (BTCQconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
-	for {
-		off := auxIntToInt32(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		ptr := v_0
-		a := v_1
-		if a.Op != OpAMD64BTCQconst {
-			break
-		}
-		c := auxIntToInt8(a.AuxInt)
-		l := a.Args[0]
-		if l.Op != OpAMD64MOVQload || auxIntToInt32(l.AuxInt) != off || auxToSym(l.Aux) != sym {
-			break
-		}
-		mem := l.Args[1]
-		ptr2 := l.Args[0]
-		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)) {
-			break
-		}
-		v.reset(OpAMD64BTCQconstmodify)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
-		v.Aux = symToAux(sym)
-		v.AddArg2(ptr, mem)
-		return true
-	}
-	// match: (MOVQstore [off] {sym} ptr a:(BTRQconst [c] l:(MOVQload [off] {sym} ptr2 mem)) mem)
-	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
-	// result: (BTRQconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
-	for {
-		off := auxIntToInt32(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		ptr := v_0
-		a := v_1
-		if a.Op != OpAMD64BTRQconst {
-			break
-		}
-		c := auxIntToInt8(a.AuxInt)
-		l := a.Args[0]
-		if l.Op != OpAMD64MOVQload || auxIntToInt32(l.AuxInt) != off || auxToSym(l.Aux) != sym {
-			break
-		}
-		mem := l.Args[1]
-		ptr2 := l.Args[0]
-		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)) {
-			break
-		}
-		v.reset(OpAMD64BTRQconstmodify)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
-		v.Aux = symToAux(sym)
-		v.AddArg2(ptr, mem)
-		return true
-	}
-	// match: (MOVQstore [off] {sym} ptr a:(BTSQconst [c] l:(MOVQload [off] {sym} ptr2 mem)) mem)
-	// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)
-	// result: (BTSQconstmodify {sym} [makeValAndOff(int32(c),off)] ptr mem)
-	for {
-		off := auxIntToInt32(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		ptr := v_0
-		a := v_1
-		if a.Op != OpAMD64BTSQconst {
-			break
-		}
-		c := auxIntToInt8(a.AuxInt)
-		l := a.Args[0]
-		if l.Op != OpAMD64MOVQload || auxIntToInt32(l.AuxInt) != off || auxToSym(l.Aux) != sym {
-			break
-		}
-		mem := l.Args[1]
-		ptr2 := l.Args[0]
-		if mem != v_2 || !(isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && clobber(l, a)) {
-			break
-		}
-		v.reset(OpAMD64BTSQconstmodify)
-		v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(c), off))
-		v.Aux = symToAux(sym)
-		v.AddArg2(ptr, mem)
-		return true
-	}
 	// match: (MOVQstore [off] {sym} ptr (MOVQf2i val) mem)
 	// result: (MOVSDstore [off] {sym} ptr val mem)
 	for {
@@ -18477,33 +17456,6 @@ func rewriteValueAMD64_OpAMD64ORLmodify(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
-	b := v.Block
-	// match: (ORLmodify [off] {sym} ptr s:(SHLL (MOVLconst [1]) <t> x) mem)
-	// result: (BTSLmodify [off] {sym} ptr (ANDLconst <t> [31] x) mem)
-	for {
-		off := auxIntToInt32(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		ptr := v_0
-		s := v_1
-		if s.Op != OpAMD64SHLL {
-			break
-		}
-		t := s.Type
-		x := s.Args[1]
-		s_0 := s.Args[0]
-		if s_0.Op != OpAMD64MOVLconst || auxIntToInt32(s_0.AuxInt) != 1 {
-			break
-		}
-		mem := v_2
-		v.reset(OpAMD64BTSLmodify)
-		v.AuxInt = int32ToAuxInt(off)
-		v.Aux = symToAux(sym)
-		v0 := b.NewValue0(v.Pos, OpAMD64ANDLconst, t)
-		v0.AuxInt = int32ToAuxInt(31)
-		v0.AddArg(x)
-		v.AddArg3(ptr, v0, mem)
-		return true
-	}
 	// match: (ORLmodify [off1] {sym} (ADDQconst [off2] base) val mem)
 	// cond: is32Bit(int64(off1)+int64(off2))
 	// result: (ORLmodify [off1+off2] {sym} base val mem)
@@ -20179,33 +19131,6 @@ func rewriteValueAMD64_OpAMD64ORQmodify(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
-	b := v.Block
-	// match: (ORQmodify [off] {sym} ptr s:(SHLQ (MOVQconst [1]) <t> x) mem)
-	// result: (BTSQmodify [off] {sym} ptr (ANDQconst <t> [63] x) mem)
-	for {
-		off := auxIntToInt32(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		ptr := v_0
-		s := v_1
-		if s.Op != OpAMD64SHLQ {
-			break
-		}
-		t := s.Type
-		x := s.Args[1]
-		s_0 := s.Args[0]
-		if s_0.Op != OpAMD64MOVQconst || auxIntToInt64(s_0.AuxInt) != 1 {
-			break
-		}
-		mem := v_2
-		v.reset(OpAMD64BTSQmodify)
-		v.AuxInt = int32ToAuxInt(off)
-		v.Aux = symToAux(sym)
-		v0 := b.NewValue0(v.Pos, OpAMD64ANDQconst, t)
-		v0.AuxInt = int32ToAuxInt(63)
-		v0.AddArg(x)
-		v.AddArg3(ptr, v0, mem)
-		return true
-	}
 	// match: (ORQmodify [off1] {sym} (ADDQconst [off2] base) val mem)
 	// cond: is32Bit(int64(off1)+int64(off2))
 	// result: (ORQmodify [off1+off2] {sym} base val mem)
@@ -28295,33 +27220,6 @@ func rewriteValueAMD64_OpAMD64XORLmodify(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
-	b := v.Block
-	// match: (XORLmodify [off] {sym} ptr s:(SHLL (MOVLconst [1]) <t> x) mem)
-	// result: (BTCLmodify [off] {sym} ptr (ANDLconst <t> [31] x) mem)
-	for {
-		off := auxIntToInt32(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		ptr := v_0
-		s := v_1
-		if s.Op != OpAMD64SHLL {
-			break
-		}
-		t := s.Type
-		x := s.Args[1]
-		s_0 := s.Args[0]
-		if s_0.Op != OpAMD64MOVLconst || auxIntToInt32(s_0.AuxInt) != 1 {
-			break
-		}
-		mem := v_2
-		v.reset(OpAMD64BTCLmodify)
-		v.AuxInt = int32ToAuxInt(off)
-		v.Aux = symToAux(sym)
-		v0 := b.NewValue0(v.Pos, OpAMD64ANDLconst, t)
-		v0.AuxInt = int32ToAuxInt(31)
-		v0.AddArg(x)
-		v.AddArg3(ptr, v0, mem)
-		return true
-	}
 	// match: (XORLmodify [off1] {sym} (ADDQconst [off2] base) val mem)
 	// cond: is32Bit(int64(off1)+int64(off2))
 	// result: (XORLmodify [off1+off2] {sym} base val mem)
@@ -28690,33 +27588,6 @@ func rewriteValueAMD64_OpAMD64XORQmodify(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
-	b := v.Block
-	// match: (XORQmodify [off] {sym} ptr s:(SHLQ (MOVQconst [1]) <t> x) mem)
-	// result: (BTCQmodify [off] {sym} ptr (ANDQconst <t> [63] x) mem)
-	for {
-		off := auxIntToInt32(v.AuxInt)
-		sym := auxToSym(v.Aux)
-		ptr := v_0
-		s := v_1
-		if s.Op != OpAMD64SHLQ {
-			break
-		}
-		t := s.Type
-		x := s.Args[1]
-		s_0 := s.Args[0]
-		if s_0.Op != OpAMD64MOVQconst || auxIntToInt64(s_0.AuxInt) != 1 {
-			break
-		}
-		mem := v_2
-		v.reset(OpAMD64BTCQmodify)
-		v.AuxInt = int32ToAuxInt(off)
-		v.Aux = symToAux(sym)
-		v0 := b.NewValue0(v.Pos, OpAMD64ANDQconst, t)
-		v0.AuxInt = int32ToAuxInt(63)
-		v0.AddArg(x)
-		v.AddArg3(ptr, v0, mem)
-		return true
-	}
 	// match: (XORQmodify [off1] {sym} (ADDQconst [off2] base) val mem)
 	// cond: is32Bit(int64(off1)+int64(off2))
 	// result: (XORQmodify [off1+off2] {sym} base val mem)
diff --git a/src/cmd/compile/internal/test/bench_test.go b/src/cmd/compile/internal/test/bench_test.go
index 3fffe57d08..4724600091 100644
--- a/src/cmd/compile/internal/test/bench_test.go
+++ b/src/cmd/compile/internal/test/bench_test.go
@@ -62,3 +62,63 @@ func BenchmarkConstModify(b *testing.B) {
 		}
 	}
 }
+
+func BenchmarkBitSet(b *testing.B) {
+	const N = 64 * 8
+	a := make([]uint64, N/64)
+	for i := 0; i < b.N; i++ {
+		for j := uint64(0); j < N; j++ {
+			a[j/64] |= 1 << (j % 64)
+		}
+	}
+}
+
+func BenchmarkBitClear(b *testing.B) {
+	const N = 64 * 8
+	a := make([]uint64, N/64)
+	for i := 0; i < b.N; i++ {
+		for j := uint64(0); j < N; j++ {
+			a[j/64] &^= 1 << (j % 64)
+		}
+	}
+}
+
+func BenchmarkBitToggle(b *testing.B) {
+	const N = 64 * 8
+	a := make([]uint64, N/64)
+	for i := 0; i < b.N; i++ {
+		for j := uint64(0); j < N; j++ {
+			a[j/64] ^= 1 << (j % 64)
+		}
+	}
+}
+
+func BenchmarkBitSetConst(b *testing.B) {
+	const N = 64
+	a := make([]uint64, N)
+	for i := 0; i < b.N; i++ {
+		for j := range a {
+			a[j] |= 1 << 37
+		}
+	}
+}
+
+func BenchmarkBitClearConst(b *testing.B) {
+	const N = 64
+	a := make([]uint64, N)
+	for i := 0; i < b.N; i++ {
+		for j := range a {
+			a[j] &^= 1 << 37
+		}
+	}
+}
+
+func BenchmarkBitToggleConst(b *testing.B) {
+	const N = 64
+	a := make([]uint64, N)
+	for i := 0; i < b.N; i++ {
+		for j := range a {
+			a[j] ^= 1 << 37
+		}
+	}
+}
diff --git a/test/codegen/bits.go b/test/codegen/bits.go
index 2bd92dd51b..8117a62307 100644
--- a/test/codegen/bits.go
+++ b/test/codegen/bits.go
@@ -270,18 +270,6 @@ func bitOpOnMem(a []uint32, b, c, d uint32) {
 	a[1] |= 220
 	// amd64:`XORL\s[$]240,\s8\([A-Z][A-Z0-9]+\)`
 	a[2] ^= 240
-	// amd64:`BTRL\s[$]15,\s12\([A-Z][A-Z0-9]+\)`,-`ANDL`
-	a[3] &= 0xffff7fff
-	// amd64:`BTSL\s[$]14,\s16\([A-Z][A-Z0-9]+\)`,-`ORL`
-	a[4] |= 0x4000
-	// amd64:`BTCL\s[$]13,\s20\([A-Z][A-Z0-9]+\)`,-`XORL`
-	a[5] ^= 0x2000
-	// amd64:`BTRL\s[A-Z][A-Z0-9]+,\s24\([A-Z][A-Z0-9]+\)`
-	a[6] &^= 1 << (b & 31)
-	// amd64:`BTSL\s[A-Z][A-Z0-9]+,\s28\([A-Z][A-Z0-9]+\)`
-	a[7] |= 1 << (c & 31)
-	// amd64:`BTCL\s[A-Z][A-Z0-9]+,\s32\([A-Z][A-Z0-9]+\)`
-	a[8] ^= 1 << (d & 31)
 }
 
 func bitcheckMostNegative(b uint8) bool {
-- 
GitLab


From 02ce4118219dc51a14680a0c5fa24cf6e73deeed Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Thu, 29 Apr 2021 13:36:08 -0400
Subject: [PATCH 2012/2400] crypto/x509: remove GODEBUG=x509ignoreCN=0 flag
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Common Name and NameConstraintsWithoutSANs are no more.

Fixes #24151 ᕕ(ᐛ)ᕗ

Change-Id: I15058f2a64f981c69e9ee620d3fab00f68967e49
Reviewed-on: https://go-review.googlesource.com/c/go/+/315209
Trust: Filippo Valsorda <filippo@golang.org>
Trust: Katie Hockman <katie@golang.org>
Reviewed-by: Roland Shoemaker <roland@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
---
 src/crypto/x509/name_constraints_test.go | 30 +----------
 src/crypto/x509/verify.go                | 64 +++--------------------
 src/crypto/x509/verify_test.go           | 66 ------------------------
 3 files changed, 9 insertions(+), 151 deletions(-)

diff --git a/src/crypto/x509/name_constraints_test.go b/src/crypto/x509/name_constraints_test.go
index 3826c82c38..c59a7dc1a6 100644
--- a/src/crypto/x509/name_constraints_test.go
+++ b/src/crypto/x509/name_constraints_test.go
@@ -614,7 +614,8 @@ var nameConstraintsTests = []nameConstraintsTest{
 		},
 	},
 
-	// #30: without SANs, a certificate with a CN is rejected in a constrained chain.
+	// #30: without SANs, a certificate with a CN is still accepted in a
+	// constrained chain, since we ignore the CN in VerifyHostname.
 	{
 		roots: []constraintsSpec{
 			{
@@ -630,7 +631,6 @@ var nameConstraintsTests = []nameConstraintsTest{
 			sans: []string{},
 			cn:   "foo.com",
 		},
-		expectedError: "leaf doesn't have a SAN extension",
 	},
 
 	// #31: IPv6 addresses work in constraints: roots can permit them as
@@ -1595,26 +1595,6 @@ var nameConstraintsTests = []nameConstraintsTest{
 			cn:   "foo.bar",
 		},
 	},
-
-	// #85: without SANs, a certificate with a valid CN is accepted in a
-	// constrained chain if x509ignoreCN is set.
-	{
-		roots: []constraintsSpec{
-			{
-				ok: []string{"dns:foo.com", "dns:.foo.com"},
-			},
-		},
-		intermediates: [][]constraintsSpec{
-			{
-				{},
-			},
-		},
-		leaf: leafSpec{
-			sans: []string{},
-			cn:   "foo.com",
-		},
-		ignoreCN: true,
-	},
 }
 
 func makeConstraintsCACert(constraints constraintsSpec, name string, key *ecdsa.PrivateKey, parent *Certificate, parentKey *ecdsa.PrivateKey) (*Certificate, error) {
@@ -1865,10 +1845,6 @@ func parseEKUs(ekuStrs []string) (ekus []ExtKeyUsage, unknowns []asn1.ObjectIden
 }
 
 func TestConstraintCases(t *testing.T) {
-	defer func(savedIgnoreCN bool) {
-		ignoreCN = savedIgnoreCN
-	}(ignoreCN)
-
 	privateKeys := sync.Pool{
 		New: func() interface{} {
 			priv, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
@@ -1960,7 +1936,6 @@ func TestConstraintCases(t *testing.T) {
 			}
 		}
 
-		ignoreCN = test.ignoreCN
 		verifyOpts := VerifyOptions{
 			Roots:         rootPool,
 			Intermediates: intermediatePool,
@@ -1999,7 +1974,6 @@ func TestConstraintCases(t *testing.T) {
 		for _, key := range keys {
 			privateKeys.Put(key)
 		}
-		keys = keys[:0]
 	}
 }
 
diff --git a/src/crypto/x509/verify.go b/src/crypto/x509/verify.go
index 2432d9bb86..9ef11466a4 100644
--- a/src/crypto/x509/verify.go
+++ b/src/crypto/x509/verify.go
@@ -10,7 +10,6 @@ import (
 	"fmt"
 	"net"
 	"net/url"
-	"os"
 	"reflect"
 	"runtime"
 	"strings"
@@ -18,9 +17,6 @@ import (
 	"unicode/utf8"
 )
 
-// ignoreCN disables interpreting Common Name as a hostname. See issue 24151.
-var ignoreCN = !strings.Contains(os.Getenv("GODEBUG"), "x509ignoreCN=0")
-
 type InvalidReason int
 
 const (
@@ -43,14 +39,7 @@ const (
 	// NameMismatch results when the subject name of a parent certificate
 	// does not match the issuer name in the child.
 	NameMismatch
-	// NameConstraintsWithoutSANs results when a leaf certificate doesn't
-	// contain a Subject Alternative Name extension, but a CA certificate
-	// contains name constraints, and the Common Name can be interpreted as
-	// a hostname.
-	//
-	// This error is only returned when legacy Common Name matching is enabled
-	// by setting the GODEBUG environment variable to "x509ignoreCN=1". This
-	// setting might be removed in the future.
+	// NameConstraintsWithoutSANs is a legacy error and is no longer returned.
 	NameConstraintsWithoutSANs
 	// UnconstrainedName results when a CA certificate contains permitted
 	// name constraints, but leaf certificate contains a name of an
@@ -110,15 +99,7 @@ func (h HostnameError) Error() string {
 	c := h.Certificate
 
 	if !c.hasSANExtension() && matchHostnames(c.Subject.CommonName, h.Host) {
-		if !ignoreCN && !validHostnamePattern(c.Subject.CommonName) {
-			// This would have validated, if it weren't for the validHostname check on Common Name.
-			return "x509: Common Name is not a valid hostname: " + c.Subject.CommonName
-		}
-		if ignoreCN && validHostnamePattern(c.Subject.CommonName) {
-			// This would have validated if x509ignoreCN=0 were set.
-			return "x509: certificate relies on legacy Common Name field, " +
-				"use SANs or temporarily enable Common Name matching with GODEBUG=x509ignoreCN=0"
-		}
+		return "x509: certificate relies on legacy Common Name field, use SANs instead"
 	}
 
 	var valid string
@@ -134,11 +115,7 @@ func (h HostnameError) Error() string {
 			valid += san.String()
 		}
 	} else {
-		if c.commonNameAsHostname() {
-			valid = c.Subject.CommonName
-		} else {
-			valid = strings.Join(c.DNSNames, ", ")
-		}
+		valid = strings.Join(c.DNSNames, ", ")
 	}
 
 	if len(valid) == 0 {
@@ -620,15 +597,8 @@ func (c *Certificate) isValid(certType int, currentChain []*Certificate, opts *V
 		leaf = currentChain[0]
 	}
 
-	checkNameConstraints := (certType == intermediateCertificate || certType == rootCertificate) && c.hasNameConstraints()
-	if checkNameConstraints && leaf.commonNameAsHostname() {
-		// This is the deprecated, legacy case of depending on the commonName as
-		// a hostname. We don't enforce name constraints against the CN, but
-		// VerifyHostname will look for hostnames in there if there are no SANs.
-		// In order to ensure VerifyHostname will not accept an unchecked name,
-		// return an error here.
-		return CertificateInvalidError{c, NameConstraintsWithoutSANs, ""}
-	} else if checkNameConstraints && leaf.hasSANExtension() {
+	if (certType == intermediateCertificate || certType == rootCertificate) &&
+		c.hasNameConstraints() && leaf.hasSANExtension() {
 		err := forEachSAN(leaf.getSANExtension(), func(tag int, data []byte) error {
 			switch tag {
 			case nameTypeEmail:
@@ -960,18 +930,6 @@ func validHostname(host string, isPattern bool) bool {
 	return true
 }
 
-// commonNameAsHostname reports whether the Common Name field should be
-// considered the hostname that the certificate is valid for. This is a legacy
-// behavior, disabled by default or if the Subject Alt Name extension is present.
-//
-// It applies the strict validHostname check to the Common Name field, so that
-// certificates without SANs can still be validated against CAs with name
-// constraints if there is no risk the CN would be matched as a hostname.
-// See NameConstraintsWithoutSANs and issue 24151.
-func (c *Certificate) commonNameAsHostname() bool {
-	return !ignoreCN && !c.hasSANExtension() && validHostnamePattern(c.Subject.CommonName)
-}
-
 func matchExactly(hostA, hostB string) bool {
 	if hostA == "" || hostA == "." || hostB == "" || hostB == "." {
 		return false
@@ -1046,10 +1004,7 @@ func toLowerCaseASCII(in string) string {
 // against the DNSNames field. If the names are valid hostnames, the certificate
 // fields can have a wildcard as the left-most label.
 //
-// The legacy Common Name field is ignored unless it's a valid hostname, the
-// certificate doesn't have any Subject Alternative Names, and the GODEBUG
-// environment variable is set to "x509ignoreCN=0". Support for Common Name is
-// deprecated will be entirely removed in the future.
+// Note that the legacy Common Name field is ignored.
 func (c *Certificate) VerifyHostname(h string) error {
 	// IP addresses may be written in [ ].
 	candidateIP := h
@@ -1067,15 +1022,10 @@ func (c *Certificate) VerifyHostname(h string) error {
 		return HostnameError{c, candidateIP}
 	}
 
-	names := c.DNSNames
-	if c.commonNameAsHostname() {
-		names = []string{c.Subject.CommonName}
-	}
-
 	candidateName := toLowerCaseASCII(h) // Save allocations inside the loop.
 	validCandidateName := validHostnameInput(candidateName)
 
-	for _, match := range names {
+	for _, match := range c.DNSNames {
 		// Ideally, we'd only match valid hostnames according to RFC 6125 like
 		// browsers (more or less) do, but in practice Go is used in a wider
 		// array of contexts and can't even assume DNS resolution. Instead,
diff --git a/src/crypto/x509/verify_test.go b/src/crypto/x509/verify_test.go
index 8e0a7bef47..9954a670da 100644
--- a/src/crypto/x509/verify_test.go
+++ b/src/crypto/x509/verify_test.go
@@ -30,7 +30,6 @@ type verifyTest struct {
 	systemSkip    bool
 	systemLax     bool
 	keyUsages     []ExtKeyUsage
-	ignoreCN      bool
 
 	errorCallback  func(*testing.T, error)
 	expectedChains [][]string
@@ -297,8 +296,6 @@ var verifyTests = []verifyTest{
 		errorCallback: expectNotAuthorizedError,
 	},
 	{
-		// If any SAN extension is present (even one without any DNS
-		// names), the CN should be ignored.
 		name:        "IgnoreCNWithSANs",
 		leaf:        ignoreCNWithSANLeaf,
 		dnsName:     "foo.example.com",
@@ -325,7 +322,6 @@ var verifyTests = []verifyTest{
 		// verify error.
 		name:          "CriticalExtLeaf",
 		leaf:          criticalExtLeafWithExt,
-		dnsName:       "example.com",
 		intermediates: []string{criticalExtIntermediate},
 		roots:         []string{criticalExtRoot},
 		currentTime:   1486684488,
@@ -338,7 +334,6 @@ var verifyTests = []verifyTest{
 		// cause a verify error.
 		name:          "CriticalExtIntermediate",
 		leaf:          criticalExtLeaf,
-		dnsName:       "example.com",
 		intermediates: []string{criticalExtIntermediateWithExt},
 		roots:         []string{criticalExtRoot},
 		currentTime:   1486684488,
@@ -347,18 +342,6 @@ var verifyTests = []verifyTest{
 		errorCallback: expectUnhandledCriticalExtension,
 	},
 	{
-		// Test that invalid CN are ignored.
-		name:        "InvalidCN",
-		leaf:        invalidCNWithoutSAN,
-		dnsName:     "foo,invalid",
-		roots:       []string{invalidCNRoot},
-		currentTime: 1540000000,
-		systemSkip:  true, // does not chain to a system root
-
-		errorCallback: expectHostnameError("Common Name is not a valid hostname"),
-	},
-	{
-		// Test that valid CN are respected.
 		name:        "ValidCN",
 		leaf:        validCNWithoutSAN,
 		dnsName:     "foo.example.com",
@@ -366,42 +349,6 @@ var verifyTests = []verifyTest{
 		currentTime: 1540000000,
 		systemSkip:  true, // does not chain to a system root
 
-		expectedChains: [][]string{
-			{"foo.example.com", "Test root"},
-		},
-	},
-	// Replicate CN tests with ignoreCN = true
-	{
-		name:        "IgnoreCNWithSANs/ignoreCN",
-		leaf:        ignoreCNWithSANLeaf,
-		dnsName:     "foo.example.com",
-		roots:       []string{ignoreCNWithSANRoot},
-		currentTime: 1486684488,
-		systemSkip:  true, // does not chain to a system root
-		ignoreCN:    true,
-
-		errorCallback: expectHostnameError("certificate is not valid for any names"),
-	},
-	{
-		name:        "InvalidCN/ignoreCN",
-		leaf:        invalidCNWithoutSAN,
-		dnsName:     "foo,invalid",
-		roots:       []string{invalidCNRoot},
-		currentTime: 1540000000,
-		systemSkip:  true, // does not chain to a system root
-		ignoreCN:    true,
-
-		errorCallback: expectHostnameError("certificate is not valid for any names"),
-	},
-	{
-		name:        "ValidCN/ignoreCN",
-		leaf:        validCNWithoutSAN,
-		dnsName:     "foo.example.com",
-		roots:       []string{invalidCNRoot},
-		currentTime: 1540000000,
-		systemSkip:  true, // does not chain to a system root
-		ignoreCN:    true,
-
 		errorCallback: expectHostnameError("certificate relies on legacy Common Name field"),
 	},
 	{
@@ -503,9 +450,6 @@ func certificateFromPEM(pemBytes string) (*Certificate, error) {
 }
 
 func testVerify(t *testing.T, test verifyTest, useSystemRoots bool) {
-	defer func(savedIgnoreCN bool) { ignoreCN = savedIgnoreCN }(ignoreCN)
-
-	ignoreCN = test.ignoreCN
 	opts := VerifyOptions{
 		Intermediates: NewCertPool(),
 		DNSName:       test.dnsName,
@@ -1589,16 +1533,6 @@ oCGMjNwwCgYIKoZIzj0EAwIDRwAwRAIgDSiwgIn8g1lpruYH0QD1GYeoWVunfmrI
 XzZZl0eW/ugCICgOfXeZ2GGy3wIC0352BaC3a8r5AAb2XSGNe+e9wNN6
 -----END CERTIFICATE-----`
 
-const invalidCNWithoutSAN = `-----BEGIN CERTIFICATE-----
-MIIBJDCBywIUB7q8t9mrDAL+UB1OFaMN5BEWFKIwCgYIKoZIzj0EAwIwFDESMBAG
-A1UECwwJVGVzdCByb290MB4XDTE4MDcxMTE4MzUyMVoXDTI4MDcwODE4MzUyMVow
-FjEUMBIGA1UEAwwLZm9vLGludmFsaWQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC
-AASnpnwiM6dHfwiTLV9hNS7aRWd28pdzGLABEkoa1bdvQTy7BWn0Bl3/6yunhQtM
-90VOgUB6qcYdu7rZuSazylCQMAoGCCqGSM49BAMCA0gAMEUCIQCFlnW2cjxnEqB/
-hgSB0t3IZ1DXX4XAVFT85mtFCJPTKgIgYIY+1iimTtrdbpWJzAB2eBwDgIWmWgvr
-xfOcLt/vbvo=
------END CERTIFICATE-----`
-
 const validCNWithoutSAN = `-----BEGIN CERTIFICATE-----
 MIIBJzCBzwIUB7q8t9mrDAL+UB1OFaMN5BEWFKQwCgYIKoZIzj0EAwIwFDESMBAG
 A1UECwwJVGVzdCByb290MB4XDTE4MDcxMTE4NDcyNFoXDTI4MDcwODE4NDcyNFow
-- 
GitLab


From 9d0819b27ca248f9949e7cf6bf7cb9fe7cf574e8 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Wed, 28 Apr 2021 01:37:09 -0400
Subject: [PATCH 2013/2400] crypto/tls: make cipher suite preference ordering
 automatic

We now have a (well, two, depending on AES hardware support) universal
cipher suite preference order, based on their security and performance.
Peer and application lists are now treated as filters (and AES hardware
support hints) that are applied to this universal order.

This removes a complex and nuanced decision from the application's
responsibilities, one which we are better equipped to make and which
applications usually don't need to have an opinion about. It also lets
us worry less about what suites we support or enable, because we can be
confident that bad ones won't be selected over good ones.

This also moves 3DES suites to InsecureCipherSuites(), even if they are
not disabled by default. Just because we can keep them as a last resort
it doesn't mean they are secure. Thankfully we had not promised that
Insecure means disabled by default.

Notable test changes:

  - TestCipherSuiteCertPreferenceECDSA was testing that we'd pick the
    right certificate regardless of CipherSuite ordering, which is now
    completely ignored, as tested by TestCipherSuitePreference. Removed.

  - The openssl command of TestHandshakeServerExportKeyingMaterial was
    broken for TLS 1.0 in CL 262857, but its golden file was not
    regenerated, so the test kept passing. It now broke because the
    selected suite from the ones in the golden file changed.

  - In TestAESCipherReordering, "server strongly prefers AES-GCM" is
    removed because there is no way for a server to express a strong
    preference anymore; "client prefers AES-GCM and AES-CBC over ChaCha"
    switched to ChaCha20 when the server lacks AES hardware; and finally
    "client supports multiple AES-GCM" changed to always prefer AES-128
    per the universal preference list.

    * this is going back on an explicit decision from CL 262857, and
      while that client order is weird and does suggest a strong dislike
      for ChaCha20, we have a strong dislike for software AES, so it
      didn't feel worth making the logic more complex

  - All Client-* golden files had to be regenerated because the
    ClientHello cipher suites have changed.
    (Even when Config.CipherSuites was limited to one suite, the TLS 1.3
    default order changed.)

Fixes #45430
Fixes #41476 (as 3DES is now always the last resort)

Change-Id: If5f5d356c0f8d1f1c7542fb06644a478d6bad1e5
Reviewed-on: https://go-review.googlesource.com/c/go/+/314609
Run-TryBot: Filippo Valsorda <filippo@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Roland Shoemaker <roland@golang.org>
Trust: Filippo Valsorda <filippo@golang.org>
---
 src/crypto/tls/cipher_suites.go               | 259 +++++++--
 src/crypto/tls/common.go                      | 161 +-----
 src/crypto/tls/handshake_client.go            |  36 +-
 src/crypto/tls/handshake_server.go            |  35 +-
 src/crypto/tls/handshake_server_test.go       | 171 ++----
 src/crypto/tls/handshake_server_tls13.go      |  25 +-
 src/crypto/tls/handshake_test.go              |  12 +-
 src/crypto/tls/key_agreement.go               |  19 +
 .../Client-TLSv10-ClientCert-ECDSA-ECDSA      |  92 +--
 .../Client-TLSv10-ClientCert-ECDSA-RSA        |  88 +--
 .../Client-TLSv10-ClientCert-RSA-ECDSA        |  94 +--
 .../testdata/Client-TLSv10-ClientCert-RSA-RSA |  88 +--
 .../testdata/Client-TLSv10-ECDHE-ECDSA-AES    |  72 +--
 .../tls/testdata/Client-TLSv10-ECDHE-RSA-AES  |  70 +--
 .../Client-TLSv10-ExportKeyingMaterial        |  70 +--
 src/crypto/tls/testdata/Client-TLSv10-RSA-RC4 |  38 +-
 .../testdata/Client-TLSv11-ECDHE-ECDSA-AES    |  74 +--
 .../tls/testdata/Client-TLSv11-ECDHE-RSA-AES  |  70 +--
 src/crypto/tls/testdata/Client-TLSv11-RSA-RC4 |  38 +-
 .../testdata/Client-TLSv12-AES128-GCM-SHA256  |  42 +-
 .../tls/testdata/Client-TLSv12-AES128-SHA256  |  56 +-
 .../testdata/Client-TLSv12-AES256-GCM-SHA384  |  42 +-
 src/crypto/tls/testdata/Client-TLSv12-ALPN    |  60 +-
 .../Client-TLSv12-ClientCert-ECDSA-ECDSA      |  94 +--
 .../Client-TLSv12-ClientCert-ECDSA-RSA        |  86 +--
 .../testdata/Client-TLSv12-ClientCert-Ed25519 |  70 +--
 ...nt-TLSv12-ClientCert-RSA-AES256-GCM-SHA384 |  82 +--
 .../Client-TLSv12-ClientCert-RSA-ECDSA        | 100 ++--
 .../testdata/Client-TLSv12-ClientCert-RSA-RSA |  82 +--
 .../Client-TLSv12-ClientCert-RSA-RSAPKCS1v15  |  82 +--
 .../Client-TLSv12-ClientCert-RSA-RSAPSS       |  82 +--
 .../testdata/Client-TLSv12-ECDHE-ECDSA-AES    |  72 +--
 .../Client-TLSv12-ECDHE-ECDSA-AES-GCM         |  66 +--
 .../Client-TLSv12-ECDHE-ECDSA-AES128-SHA256   |  80 +--
 ...lient-TLSv12-ECDHE-ECDSA-AES256-GCM-SHA384 |  68 +--
 ...lient-TLSv12-ECDHE-ECDSA-CHACHA20-POLY1305 |  58 +-
 .../tls/testdata/Client-TLSv12-ECDHE-RSA-AES  |  70 +--
 .../Client-TLSv12-ECDHE-RSA-AES128-SHA256     |  78 +--
 .../Client-TLSv12-ECDHE-RSA-CHACHA20-POLY1305 |  54 +-
 src/crypto/tls/testdata/Client-TLSv12-Ed25519 |  52 +-
 .../Client-TLSv12-ExportKeyingMaterial        |  60 +-
 .../tls/testdata/Client-TLSv12-P256-ECDHE     |  68 +--
 src/crypto/tls/testdata/Client-TLSv12-RSA-RC4 |  38 +-
 .../testdata/Client-TLSv12-RenegotiateOnce    | 356 ++++++------
 .../testdata/Client-TLSv12-RenegotiateTwice   | 546 +++++++++---------
 .../Client-TLSv12-RenegotiateTwiceRejected    | 362 ++++++------
 .../Client-TLSv12-RenegotiationRejected       |  66 +--
 src/crypto/tls/testdata/Client-TLSv12-SCT     |  60 +-
 .../tls/testdata/Client-TLSv12-X25519-ECDHE   |  64 +-
 .../tls/testdata/Client-TLSv13-AES128-SHA256  | 146 ++---
 .../tls/testdata/Client-TLSv13-AES256-SHA384  | 150 ++---
 src/crypto/tls/testdata/Client-TLSv13-ALPN    | 150 ++---
 .../testdata/Client-TLSv13-CHACHA20-SHA256    | 146 ++---
 .../Client-TLSv13-ClientCert-ECDSA-RSA        | 246 ++++----
 .../testdata/Client-TLSv13-ClientCert-Ed25519 | 212 +++----
 .../Client-TLSv13-ClientCert-RSA-ECDSA        | 236 ++++----
 .../Client-TLSv13-ClientCert-RSA-RSAPSS       | 254 ++++----
 src/crypto/tls/testdata/Client-TLSv13-ECDSA   | 140 ++---
 src/crypto/tls/testdata/Client-TLSv13-Ed25519 | 104 ++--
 .../Client-TLSv13-ExportKeyingMaterial        | 148 ++---
 .../testdata/Client-TLSv13-HelloRetryRequest  | 158 ++---
 .../tls/testdata/Client-TLSv13-KeyUpdate      | 164 +++---
 .../tls/testdata/Client-TLSv13-P256-ECDHE     | 150 ++---
 .../tls/testdata/Client-TLSv13-X25519-ECDHE   | 148 ++---
 .../Server-TLSv10-ExportKeyingMaterial        |  82 +--
 ...rver-TLSv12-CipherSuiteCertPreferenceECDSA |  88 ---
 ...Server-TLSv12-CipherSuiteCertPreferenceRSA |  92 ---
 src/crypto/tls/tls_test.go                    | 147 ++++-
 68 files changed, 3754 insertions(+), 3815 deletions(-)
 delete mode 100644 src/crypto/tls/testdata/Server-TLSv12-CipherSuiteCertPreferenceECDSA
 delete mode 100644 src/crypto/tls/testdata/Server-TLSv12-CipherSuiteCertPreferenceRSA

diff --git a/src/crypto/tls/cipher_suites.go b/src/crypto/tls/cipher_suites.go
index 9a356758fb..4bf06468c6 100644
--- a/src/crypto/tls/cipher_suites.go
+++ b/src/crypto/tls/cipher_suites.go
@@ -13,9 +13,10 @@ import (
 	"crypto/rc4"
 	"crypto/sha1"
 	"crypto/sha256"
-	"crypto/x509"
 	"fmt"
 	"hash"
+	"internal/cpu"
+	"runtime"
 
 	"golang.org/x/crypto/chacha20poly1305"
 )
@@ -46,10 +47,10 @@ var (
 // InsecureCipherSuites.
 //
 // The list is sorted by ID. Note that the default cipher suites selected by
-// this package might depend on logic that can't be captured by a static list.
+// this package might depend on logic that can't be captured by a static list,
+// and might not match those returned by this function.
 func CipherSuites() []*CipherSuite {
 	return []*CipherSuite{
-		{TLS_RSA_WITH_3DES_EDE_CBC_SHA, "TLS_RSA_WITH_3DES_EDE_CBC_SHA", supportedUpToTLS12, false},
 		{TLS_RSA_WITH_AES_128_CBC_SHA, "TLS_RSA_WITH_AES_128_CBC_SHA", supportedUpToTLS12, false},
 		{TLS_RSA_WITH_AES_256_CBC_SHA, "TLS_RSA_WITH_AES_256_CBC_SHA", supportedUpToTLS12, false},
 		{TLS_RSA_WITH_AES_128_GCM_SHA256, "TLS_RSA_WITH_AES_128_GCM_SHA256", supportedOnlyTLS12, false},
@@ -61,7 +62,6 @@ func CipherSuites() []*CipherSuite {
 
 		{TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA", supportedUpToTLS12, false},
 		{TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA", supportedUpToTLS12, false},
-		{TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA, "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA", supportedUpToTLS12, false},
 		{TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA", supportedUpToTLS12, false},
 		{TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA", supportedUpToTLS12, false},
 		{TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256", supportedOnlyTLS12, false},
@@ -79,13 +79,15 @@ func CipherSuites() []*CipherSuite {
 // Most applications should not use the cipher suites in this list, and should
 // only use those returned by CipherSuites.
 func InsecureCipherSuites() []*CipherSuite {
-	// RC4 suites are broken because RC4 is.
-	// CBC-SHA256 suites have no Lucky13 countermeasures.
+	// This list includes RC4, CBC_SHA256, and 3DES cipher suites. See
+	// cipherSuitesPreferenceOrder for details.
 	return []*CipherSuite{
 		{TLS_RSA_WITH_RC4_128_SHA, "TLS_RSA_WITH_RC4_128_SHA", supportedUpToTLS12, true},
+		{TLS_RSA_WITH_3DES_EDE_CBC_SHA, "TLS_RSA_WITH_3DES_EDE_CBC_SHA", supportedUpToTLS12, true},
 		{TLS_RSA_WITH_AES_128_CBC_SHA256, "TLS_RSA_WITH_AES_128_CBC_SHA256", supportedOnlyTLS12, true},
 		{TLS_ECDHE_ECDSA_WITH_RC4_128_SHA, "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA", supportedUpToTLS12, true},
 		{TLS_ECDHE_RSA_WITH_RC4_128_SHA, "TLS_ECDHE_RSA_WITH_RC4_128_SHA", supportedUpToTLS12, true},
+		{TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA, "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA", supportedUpToTLS12, true},
 		{TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256", supportedOnlyTLS12, true},
 		{TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256", supportedOnlyTLS12, true},
 	}
@@ -108,25 +110,6 @@ func CipherSuiteName(id uint16) string {
 	return fmt.Sprintf("0x%04X", id)
 }
 
-// a keyAgreement implements the client and server side of a TLS key agreement
-// protocol by generating and processing key exchange messages.
-type keyAgreement interface {
-	// On the server side, the first two methods are called in order.
-
-	// In the case that the key agreement protocol doesn't use a
-	// ServerKeyExchange message, generateServerKeyExchange can return nil,
-	// nil.
-	generateServerKeyExchange(*Config, *Certificate, *clientHelloMsg, *serverHelloMsg) (*serverKeyExchangeMsg, error)
-	processClientKeyExchange(*Config, *Certificate, *clientKeyExchangeMsg, uint16) ([]byte, error)
-
-	// On the client side, the next two methods are called in order.
-
-	// This method may not be called if the server doesn't send a
-	// ServerKeyExchange message.
-	processServerKeyExchange(*Config, *clientHelloMsg, *serverHelloMsg, *x509.Certificate, *serverKeyExchangeMsg) error
-	generateClientKeyExchange(*Config, *clientHelloMsg, *x509.Certificate) ([]byte, *clientKeyExchangeMsg, error)
-}
-
 const (
 	// suiteECDHE indicates that the cipher suite involves elliptic curve
 	// Diffie-Hellman. This means that it should only be selected when the
@@ -144,12 +127,10 @@ const (
 	// suiteSHA384 indicates that the cipher suite uses SHA384 as the
 	// handshake hash.
 	suiteSHA384
-	// suiteDefaultOff indicates that this cipher suite is not included by
-	// default.
-	suiteDefaultOff
 )
 
-// A cipherSuite is a specific combination of key agreement, cipher and MAC function.
+// A cipherSuite is a TLS 1.0–1.2 cipher suite, and defines the key exchange
+// mechanism, as well as the cipher+MAC pair or the AEAD.
 type cipherSuite struct {
 	id uint16
 	// the lengths, in bytes, of the key material needed for each component.
@@ -164,37 +145,33 @@ type cipherSuite struct {
 	aead   func(key, fixedNonce []byte) aead
 }
 
-var cipherSuites = []*cipherSuite{
-	// Ciphersuite order is chosen so that ECDHE comes before plain RSA and
-	// AEADs are the top preference.
+var cipherSuites = []*cipherSuite{ // TODO: replace with a map, since the order doesn't matter.
 	{TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305, 32, 0, 12, ecdheRSAKA, suiteECDHE | suiteTLS12, nil, nil, aeadChaCha20Poly1305},
 	{TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305, 32, 0, 12, ecdheECDSAKA, suiteECDHE | suiteECSign | suiteTLS12, nil, nil, aeadChaCha20Poly1305},
 	{TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, 16, 0, 4, ecdheRSAKA, suiteECDHE | suiteTLS12, nil, nil, aeadAESGCM},
 	{TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, 16, 0, 4, ecdheECDSAKA, suiteECDHE | suiteECSign | suiteTLS12, nil, nil, aeadAESGCM},
 	{TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, 32, 0, 4, ecdheRSAKA, suiteECDHE | suiteTLS12 | suiteSHA384, nil, nil, aeadAESGCM},
 	{TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, 32, 0, 4, ecdheECDSAKA, suiteECDHE | suiteECSign | suiteTLS12 | suiteSHA384, nil, nil, aeadAESGCM},
-	{TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, 16, 32, 16, ecdheRSAKA, suiteECDHE | suiteTLS12 | suiteDefaultOff, cipherAES, macSHA256, nil},
+	{TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, 16, 32, 16, ecdheRSAKA, suiteECDHE | suiteTLS12, cipherAES, macSHA256, nil},
 	{TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, 16, 20, 16, ecdheRSAKA, suiteECDHE, cipherAES, macSHA1, nil},
-	{TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, 16, 32, 16, ecdheECDSAKA, suiteECDHE | suiteECSign | suiteTLS12 | suiteDefaultOff, cipherAES, macSHA256, nil},
+	{TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, 16, 32, 16, ecdheECDSAKA, suiteECDHE | suiteECSign | suiteTLS12, cipherAES, macSHA256, nil},
 	{TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, 16, 20, 16, ecdheECDSAKA, suiteECDHE | suiteECSign, cipherAES, macSHA1, nil},
 	{TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, 32, 20, 16, ecdheRSAKA, suiteECDHE, cipherAES, macSHA1, nil},
 	{TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, 32, 20, 16, ecdheECDSAKA, suiteECDHE | suiteECSign, cipherAES, macSHA1, nil},
 	{TLS_RSA_WITH_AES_128_GCM_SHA256, 16, 0, 4, rsaKA, suiteTLS12, nil, nil, aeadAESGCM},
 	{TLS_RSA_WITH_AES_256_GCM_SHA384, 32, 0, 4, rsaKA, suiteTLS12 | suiteSHA384, nil, nil, aeadAESGCM},
-	{TLS_RSA_WITH_AES_128_CBC_SHA256, 16, 32, 16, rsaKA, suiteTLS12 | suiteDefaultOff, cipherAES, macSHA256, nil},
+	{TLS_RSA_WITH_AES_128_CBC_SHA256, 16, 32, 16, rsaKA, suiteTLS12, cipherAES, macSHA256, nil},
 	{TLS_RSA_WITH_AES_128_CBC_SHA, 16, 20, 16, rsaKA, 0, cipherAES, macSHA1, nil},
 	{TLS_RSA_WITH_AES_256_CBC_SHA, 32, 20, 16, rsaKA, 0, cipherAES, macSHA1, nil},
 	{TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA, 24, 20, 8, ecdheRSAKA, suiteECDHE, cipher3DES, macSHA1, nil},
 	{TLS_RSA_WITH_3DES_EDE_CBC_SHA, 24, 20, 8, rsaKA, 0, cipher3DES, macSHA1, nil},
-
-	// RC4-based cipher suites are disabled by default.
-	{TLS_RSA_WITH_RC4_128_SHA, 16, 20, 0, rsaKA, suiteDefaultOff, cipherRC4, macSHA1, nil},
-	{TLS_ECDHE_RSA_WITH_RC4_128_SHA, 16, 20, 0, ecdheRSAKA, suiteECDHE | suiteDefaultOff, cipherRC4, macSHA1, nil},
-	{TLS_ECDHE_ECDSA_WITH_RC4_128_SHA, 16, 20, 0, ecdheECDSAKA, suiteECDHE | suiteECSign | suiteDefaultOff, cipherRC4, macSHA1, nil},
+	{TLS_RSA_WITH_RC4_128_SHA, 16, 20, 0, rsaKA, 0, cipherRC4, macSHA1, nil},
+	{TLS_ECDHE_RSA_WITH_RC4_128_SHA, 16, 20, 0, ecdheRSAKA, suiteECDHE, cipherRC4, macSHA1, nil},
+	{TLS_ECDHE_ECDSA_WITH_RC4_128_SHA, 16, 20, 0, ecdheECDSAKA, suiteECDHE | suiteECSign, cipherRC4, macSHA1, nil},
 }
 
-// selectCipherSuite returns the first cipher suite from ids which is also in
-// supportedIDs and passes the ok filter.
+// selectCipherSuite returns the first TLS 1.0–1.2 cipher suite from ids which
+// is also in supportedIDs and passes the ok filter.
 func selectCipherSuite(ids, supportedIDs []uint16, ok func(*cipherSuite) bool) *cipherSuite {
 	for _, id := range ids {
 		candidate := cipherSuiteByID(id)
@@ -220,12 +197,208 @@ type cipherSuiteTLS13 struct {
 	hash   crypto.Hash
 }
 
-var cipherSuitesTLS13 = []*cipherSuiteTLS13{
+var cipherSuitesTLS13 = []*cipherSuiteTLS13{ // TODO: replace with a map.
 	{TLS_AES_128_GCM_SHA256, 16, aeadAESGCMTLS13, crypto.SHA256},
 	{TLS_CHACHA20_POLY1305_SHA256, 32, aeadChaCha20Poly1305, crypto.SHA256},
 	{TLS_AES_256_GCM_SHA384, 32, aeadAESGCMTLS13, crypto.SHA384},
 }
 
+// cipherSuitesPreferenceOrder is the order in which we'll select (on the
+// server) or advertise (on the client) TLS 1.0–1.2 cipher suites.
+//
+// Cipher suites are filtered but not reordered based on the application and
+// peer's preferences, meaning we'll never select a suite lower in this list if
+// any higher one is available. This makes it more defensible to keep weaker
+// cipher suites enabled, especially on the server side where we get the last
+// word, since there are no known downgrade attacks on cipher suites selection.
+//
+// The list is sorted by applying the following priority rules, stopping at the
+// first (most important) applicable one:
+//
+//   - Anything else comes before RC4
+//
+//       RC4 has practically exploitable biases. See https://www.rc4nomore.com.
+//
+//   - Anything else comes before CBC_SHA256
+//
+//       SHA-256 variants of the CBC ciphersuites don't implement any Lucky13
+//       countermeasures. See http://www.isg.rhul.ac.uk/tls/Lucky13.html and
+//       https://www.imperialviolet.org/2013/02/04/luckythirteen.html.
+//
+//   - Anything else comes before 3DES
+//
+//       3DES has 64-bit blocks, which makes it fundamentally susceptible to
+//       birthday attacks. See https://sweet32.info.
+//
+//   - ECDHE comes before anything else
+//
+//       Once we got the broken stuff out of the way, the most important
+//       property a cipher suite can have is forward secrecy. We don't
+//       implement FFDHE, so that means ECDHE.
+//
+//   - AEADs come before CBC ciphers
+//
+//       Even with Lucky13 countermeasures, MAC-then-Encrypt CBC cipher suites
+//       are fundamentally fragile, and suffered from an endless sequence of
+//       padding oracle attacks. See https://eprint.iacr.org/2015/1129,
+//       https://www.imperialviolet.org/2014/12/08/poodleagain.html, and
+//       https://blog.cloudflare.com/yet-another-padding-oracle-in-openssl-cbc-ciphersuites/.
+//
+//   - AES comes before ChaCha20
+//
+//       When AES hardware is available, AES-128-GCM and AES-256-GCM are faster
+//       than ChaCha20Poly1305.
+//
+//       When AES hardware is not available, AES-128-GCM is one or more of: much
+//       slower, way more complex, and less safe (because not constant time)
+//       than ChaCha20Poly1305.
+//
+//       We use this list if we think both peers have AES hardware, and
+//       cipherSuitesPreferenceOrderNoAES otherwise.
+//
+//   - AES-128 comes before AES-256
+//
+//       The only potential advantages of AES-256 are better multi-target
+//       margins, and hypothetical post-quantum properties. Neither apply to
+//       TLS, and AES-256 is slower due to its four extra rounds (which don't
+//       contribute to the advantages above).
+//
+//   - ECDSA comes before RSA
+//
+//       The relative order of ECDSA and RSA cipher suites doesn't matter,
+//       as they depend on the certificate. Pick one to get a stable order.
+//
+var cipherSuitesPreferenceOrder = []uint16{
+	// AEADs w/ ECDHE
+	TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+	TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+	TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305, TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
+
+	// CBC w/ ECDHE
+	TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
+	TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
+
+	// AEADs w/o ECDHE
+	TLS_RSA_WITH_AES_128_GCM_SHA256,
+	TLS_RSA_WITH_AES_256_GCM_SHA384,
+
+	// CBC w/o ECDHE
+	TLS_RSA_WITH_AES_128_CBC_SHA,
+	TLS_RSA_WITH_AES_256_CBC_SHA,
+
+	// 3DES
+	TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
+	TLS_RSA_WITH_3DES_EDE_CBC_SHA,
+
+	// CBC_SHA256
+	TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,
+	TLS_RSA_WITH_AES_128_CBC_SHA256,
+
+	// RC4
+	TLS_ECDHE_ECDSA_WITH_RC4_128_SHA, TLS_ECDHE_RSA_WITH_RC4_128_SHA,
+	TLS_RSA_WITH_RC4_128_SHA,
+}
+
+var cipherSuitesPreferenceOrderNoAES = []uint16{
+	// ChaCha20Poly1305
+	TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305, TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
+
+	// AES-GCM w/ ECDHE
+	TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+	TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+
+	// The rest of cipherSuitesPreferenceOrder.
+	TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
+	TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
+	TLS_RSA_WITH_AES_128_GCM_SHA256,
+	TLS_RSA_WITH_AES_256_GCM_SHA384,
+	TLS_RSA_WITH_AES_128_CBC_SHA,
+	TLS_RSA_WITH_AES_256_CBC_SHA,
+	TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
+	TLS_RSA_WITH_3DES_EDE_CBC_SHA,
+	TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,
+	TLS_RSA_WITH_AES_128_CBC_SHA256,
+	TLS_ECDHE_ECDSA_WITH_RC4_128_SHA, TLS_ECDHE_RSA_WITH_RC4_128_SHA,
+	TLS_RSA_WITH_RC4_128_SHA,
+}
+
+// disabledCipherSuites are not used unless explicitly listed in
+// Config.CipherSuites. They MUST be at the end of cipherSuitesPreferenceOrder.
+var disabledCipherSuites = []uint16{
+	// CBC_SHA256
+	TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,
+	TLS_RSA_WITH_AES_128_CBC_SHA256,
+
+	// RC4
+	TLS_ECDHE_ECDSA_WITH_RC4_128_SHA, TLS_ECDHE_RSA_WITH_RC4_128_SHA,
+	TLS_RSA_WITH_RC4_128_SHA,
+}
+
+var (
+	defaultCipherSuitesLen = len(cipherSuitesPreferenceOrder) - len(disabledCipherSuites)
+	defaultCipherSuites    = cipherSuitesPreferenceOrder[:defaultCipherSuitesLen]
+)
+
+// defaultCipherSuitesTLS13 is also the preference order, since there are no
+// disabled by default TLS 1.3 cipher suites. The same AES vs ChaCha20 logic as
+// cipherSuitesPreferenceOrder applies.
+var defaultCipherSuitesTLS13 = []uint16{
+	TLS_AES_128_GCM_SHA256,
+	TLS_AES_256_GCM_SHA384,
+	TLS_CHACHA20_POLY1305_SHA256,
+}
+
+var defaultCipherSuitesTLS13NoAES = []uint16{
+	TLS_CHACHA20_POLY1305_SHA256,
+	TLS_AES_128_GCM_SHA256,
+	TLS_AES_256_GCM_SHA384,
+}
+
+var (
+	hasGCMAsmAMD64 = cpu.X86.HasAES && cpu.X86.HasPCLMULQDQ
+	hasGCMAsmARM64 = cpu.ARM64.HasAES && cpu.ARM64.HasPMULL
+	// Keep in sync with crypto/aes/cipher_s390x.go.
+	hasGCMAsmS390X = cpu.S390X.HasAES && cpu.S390X.HasAESCBC && cpu.S390X.HasAESCTR &&
+		(cpu.S390X.HasGHASH || cpu.S390X.HasAESGCM)
+
+	hasAESGCMHardwareSupport = runtime.GOARCH == "amd64" && hasGCMAsmAMD64 ||
+		runtime.GOARCH == "arm64" && hasGCMAsmARM64 ||
+		runtime.GOARCH == "s390x" && hasGCMAsmS390X
+)
+
+var aesgcmCiphers = map[uint16]bool{
+	// TLS 1.2
+	TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256:   true,
+	TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384:   true,
+	TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256: true,
+	TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384: true,
+	// TLS 1.3
+	TLS_AES_128_GCM_SHA256: true,
+	TLS_AES_256_GCM_SHA384: true,
+}
+
+var nonAESGCMAEADCiphers = map[uint16]bool{
+	// TLS 1.2
+	TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305:   true,
+	TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305: true,
+	// TLS 1.3
+	TLS_CHACHA20_POLY1305_SHA256: true,
+}
+
+// aesgcmPreferred returns whether the first known cipher in the preference list
+// is an AES-GCM cipher, implying the peer has hardware support for it.
+func aesgcmPreferred(ciphers []uint16) bool {
+	for _, cID := range ciphers {
+		if c := cipherSuiteByID(cID); c != nil {
+			return aesgcmCiphers[cID]
+		}
+		if c := cipherSuiteTLS13ByID(cID); c != nil {
+			return aesgcmCiphers[cID]
+		}
+	}
+	return false
+}
+
 func cipherRC4(key, iv []byte, isRead bool) interface{} {
 	cipher, _ := rc4.NewCipher(key)
 	return cipher
diff --git a/src/crypto/tls/common.go b/src/crypto/tls/common.go
index 23cebf2b03..77957ef82b 100644
--- a/src/crypto/tls/common.go
+++ b/src/crypto/tls/common.go
@@ -18,11 +18,8 @@ import (
 	"crypto/x509"
 	"errors"
 	"fmt"
-	"internal/cpu"
 	"io"
 	"net"
-	"runtime"
-	"sort"
 	"strings"
 	"sync"
 	"time"
@@ -648,17 +645,21 @@ type Config struct {
 	// testing or in combination with VerifyConnection or VerifyPeerCertificate.
 	InsecureSkipVerify bool
 
-	// CipherSuites is a list of supported cipher suites for TLS versions up to
-	// TLS 1.2. If CipherSuites is nil, a default list of secure cipher suites
-	// is used, with a preference order based on hardware performance. The
-	// default cipher suites might change over Go versions. Note that TLS 1.3
-	// ciphersuites are not configurable.
+	// CipherSuites is a list of enabled TLS 1.0–1.2 cipher suites. The order of
+	// the list is ignored. Note that TLS 1.3 ciphersuites are not configurable.
+	//
+	// If CipherSuites is nil, a safe default list is used. The default cipher
+	// suites might change over time.
 	CipherSuites []uint16
 
-	// PreferServerCipherSuites controls whether the server selects the
-	// client's most preferred ciphersuite, or the server's most preferred
-	// ciphersuite. If true then the server's preference, as expressed in
-	// the order of elements in CipherSuites, is used.
+	// PreferServerCipherSuites is a legacy field and has no effect.
+	//
+	// It used to control whether the server would follow the client's or the
+	// server's preference. Servers now select the best mutually supported
+	// cipher suite based on logic that takes into account inferred client
+	// hardware, server hardware, and security.
+	//
+	// Deprected: PreferServerCipherSuites is ignored.
 	PreferServerCipherSuites bool
 
 	// SessionTicketsDisabled may be set to true to disable session ticket and
@@ -950,11 +951,10 @@ func (c *Config) time() time.Time {
 }
 
 func (c *Config) cipherSuites() []uint16 {
-	s := c.CipherSuites
-	if s == nil {
-		s = defaultCipherSuites()
+	if c.CipherSuites != nil {
+		return c.CipherSuites
 	}
-	return s
+	return defaultCipherSuites
 }
 
 var supportedVersions = []uint16{
@@ -1444,87 +1444,6 @@ func defaultConfig() *Config {
 	return &emptyConfig
 }
 
-var (
-	once                        sync.Once
-	varDefaultCipherSuites      []uint16
-	varDefaultCipherSuitesTLS13 []uint16
-)
-
-func defaultCipherSuites() []uint16 {
-	once.Do(initDefaultCipherSuites)
-	return varDefaultCipherSuites
-}
-
-func defaultCipherSuitesTLS13() []uint16 {
-	once.Do(initDefaultCipherSuites)
-	return varDefaultCipherSuitesTLS13
-}
-
-var (
-	hasGCMAsmAMD64 = cpu.X86.HasAES && cpu.X86.HasPCLMULQDQ
-	hasGCMAsmARM64 = cpu.ARM64.HasAES && cpu.ARM64.HasPMULL
-	// Keep in sync with crypto/aes/cipher_s390x.go.
-	hasGCMAsmS390X = cpu.S390X.HasAES && cpu.S390X.HasAESCBC && cpu.S390X.HasAESCTR && (cpu.S390X.HasGHASH || cpu.S390X.HasAESGCM)
-
-	hasAESGCMHardwareSupport = runtime.GOARCH == "amd64" && hasGCMAsmAMD64 ||
-		runtime.GOARCH == "arm64" && hasGCMAsmARM64 ||
-		runtime.GOARCH == "s390x" && hasGCMAsmS390X
-)
-
-func initDefaultCipherSuites() {
-	var topCipherSuites []uint16
-
-	if hasAESGCMHardwareSupport {
-		// If AES-GCM hardware is provided then prioritise AES-GCM
-		// cipher suites.
-		topCipherSuites = []uint16{
-			TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
-			TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
-			TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
-			TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
-			TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
-			TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
-		}
-		varDefaultCipherSuitesTLS13 = []uint16{
-			TLS_AES_128_GCM_SHA256,
-			TLS_CHACHA20_POLY1305_SHA256,
-			TLS_AES_256_GCM_SHA384,
-		}
-	} else {
-		// Without AES-GCM hardware, we put the ChaCha20-Poly1305
-		// cipher suites first.
-		topCipherSuites = []uint16{
-			TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
-			TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
-			TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
-			TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
-			TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
-			TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
-		}
-		varDefaultCipherSuitesTLS13 = []uint16{
-			TLS_CHACHA20_POLY1305_SHA256,
-			TLS_AES_128_GCM_SHA256,
-			TLS_AES_256_GCM_SHA384,
-		}
-	}
-
-	varDefaultCipherSuites = make([]uint16, 0, len(cipherSuites))
-	varDefaultCipherSuites = append(varDefaultCipherSuites, topCipherSuites...)
-
-NextCipherSuite:
-	for _, suite := range cipherSuites {
-		if suite.flags&suiteDefaultOff != 0 {
-			continue
-		}
-		for _, existing := range varDefaultCipherSuites {
-			if existing == suite.id {
-				continue NextCipherSuite
-			}
-		}
-		varDefaultCipherSuites = append(varDefaultCipherSuites, suite.id)
-	}
-}
-
 func unexpectedMessageError(wanted, got interface{}) error {
 	return fmt.Errorf("tls: received unexpected handshake message of type %T when waiting for %T", got, wanted)
 }
@@ -1537,51 +1456,3 @@ func isSupportedSignatureAlgorithm(sigAlg SignatureScheme, supportedSignatureAlg
 	}
 	return false
 }
-
-var aesgcmCiphers = map[uint16]bool{
-	// 1.2
-	TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256:   true,
-	TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384:   true,
-	TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256: true,
-	TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384: true,
-	// 1.3
-	TLS_AES_128_GCM_SHA256: true,
-	TLS_AES_256_GCM_SHA384: true,
-}
-
-var nonAESGCMAEADCiphers = map[uint16]bool{
-	// 1.2
-	TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305:   true,
-	TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305: true,
-	// 1.3
-	TLS_CHACHA20_POLY1305_SHA256: true,
-}
-
-// aesgcmPreferred returns whether the first valid cipher in the preference list
-// is an AES-GCM cipher, implying the peer has hardware support for it.
-func aesgcmPreferred(ciphers []uint16) bool {
-	for _, cID := range ciphers {
-		c := cipherSuiteByID(cID)
-		if c == nil {
-			c13 := cipherSuiteTLS13ByID(cID)
-			if c13 == nil {
-				continue
-			}
-			return aesgcmCiphers[cID]
-		}
-		return aesgcmCiphers[cID]
-	}
-	return false
-}
-
-// deprioritizeAES reorders cipher preference lists by rearranging
-// adjacent AEAD ciphers such that AES-GCM based ciphers are moved
-// after other AEAD ciphers. It returns a fresh slice.
-func deprioritizeAES(ciphers []uint16) []uint16 {
-	reordered := make([]uint16, len(ciphers))
-	copy(reordered, ciphers)
-	sort.SliceStable(reordered, func(i, j int) bool {
-		return nonAESGCMAEADCiphers[reordered[i]] && aesgcmCiphers[reordered[j]]
-	})
-	return reordered
-}
diff --git a/src/crypto/tls/handshake_client.go b/src/crypto/tls/handshake_client.go
index 92e33e7169..13a7f3442c 100644
--- a/src/crypto/tls/handshake_client.go
+++ b/src/crypto/tls/handshake_client.go
@@ -84,22 +84,24 @@ func (c *Conn) makeClientHello() (*clientHelloMsg, ecdheParameters, error) {
 		hello.secureRenegotiation = c.clientFinished[:]
 	}
 
-	possibleCipherSuites := config.cipherSuites()
-	hello.cipherSuites = make([]uint16, 0, len(possibleCipherSuites))
+	preferenceOrder := cipherSuitesPreferenceOrder
+	if !hasAESGCMHardwareSupport {
+		preferenceOrder = cipherSuitesPreferenceOrderNoAES
+	}
+	configCipherSuites := config.cipherSuites()
+	hello.cipherSuites = make([]uint16, 0, len(configCipherSuites))
 
-	for _, suiteId := range possibleCipherSuites {
-		for _, suite := range cipherSuites {
-			if suite.id != suiteId {
-				continue
-			}
-			// Don't advertise TLS 1.2-only cipher suites unless
-			// we're attempting TLS 1.2.
-			if hello.vers < VersionTLS12 && suite.flags&suiteTLS12 != 0 {
-				break
-			}
-			hello.cipherSuites = append(hello.cipherSuites, suiteId)
-			break
+	for _, suiteId := range preferenceOrder {
+		suite := mutualCipherSuite(configCipherSuites, suiteId)
+		if suite == nil {
+			continue
 		}
+		// Don't advertise TLS 1.2-only cipher suites unless
+		// we're attempting TLS 1.2.
+		if hello.vers < VersionTLS12 && suite.flags&suiteTLS12 != 0 {
+			continue
+		}
+		hello.cipherSuites = append(hello.cipherSuites, suiteId)
 	}
 
 	_, err := io.ReadFull(config.rand(), hello.random)
@@ -120,7 +122,11 @@ func (c *Conn) makeClientHello() (*clientHelloMsg, ecdheParameters, error) {
 
 	var params ecdheParameters
 	if hello.supportedVersions[0] == VersionTLS13 {
-		hello.cipherSuites = append(hello.cipherSuites, defaultCipherSuitesTLS13()...)
+		if hasAESGCMHardwareSupport {
+			hello.cipherSuites = append(hello.cipherSuites, defaultCipherSuitesTLS13...)
+		} else {
+			hello.cipherSuites = append(hello.cipherSuites, defaultCipherSuitesTLS13NoAES...)
+		}
 
 		curveID := config.curvePreferences()[0]
 		if _, ok := curveForCurveID(curveID); curveID != X25519 && !ok {
diff --git a/src/crypto/tls/handshake_server.go b/src/crypto/tls/handshake_server.go
index 65a2bf403f..b231981e09 100644
--- a/src/crypto/tls/handshake_server.go
+++ b/src/crypto/tls/handshake_server.go
@@ -302,30 +302,23 @@ func supportsECDHE(c *Config, supportedCurves []CurveID, supportedPoints []uint8
 func (hs *serverHandshakeState) pickCipherSuite() error {
 	c := hs.c
 
-	var preferenceList, supportedList []uint16
-	if c.config.PreferServerCipherSuites {
-		preferenceList = c.config.cipherSuites()
-		supportedList = hs.clientHello.cipherSuites
-
-		// If the client does not seem to have hardware support for AES-GCM,
-		// and the application did not specify a cipher suite preference order,
-		// prefer other AEAD ciphers even if we prioritized AES-GCM ciphers
-		// by default.
-		if c.config.CipherSuites == nil && !aesgcmPreferred(hs.clientHello.cipherSuites) {
-			preferenceList = deprioritizeAES(preferenceList)
-		}
-	} else {
-		preferenceList = hs.clientHello.cipherSuites
-		supportedList = c.config.cipherSuites()
-
-		// If we don't have hardware support for AES-GCM, prefer other AEAD
-		// ciphers even if the client prioritized AES-GCM.
-		if !hasAESGCMHardwareSupport {
-			preferenceList = deprioritizeAES(preferenceList)
+	preferenceOrder := cipherSuitesPreferenceOrder
+	if !hasAESGCMHardwareSupport || !aesgcmPreferred(hs.clientHello.cipherSuites) {
+		preferenceOrder = cipherSuitesPreferenceOrderNoAES
+	}
+
+	configCipherSuites := c.config.cipherSuites()
+	preferenceList := make([]uint16, 0, len(configCipherSuites))
+	for _, suiteID := range preferenceOrder {
+		for _, id := range configCipherSuites {
+			if id == suiteID {
+				preferenceList = append(preferenceList, id)
+				break
+			}
 		}
 	}
 
-	hs.suite = selectCipherSuite(preferenceList, supportedList, hs.cipherSuiteOk)
+	hs.suite = selectCipherSuite(preferenceList, hs.clientHello.cipherSuites, hs.cipherSuiteOk)
 	if hs.suite == nil {
 		c.sendAlert(alertHandshakeFailure)
 		return errors.New("tls: no cipher suite supported by both client and server")
diff --git a/src/crypto/tls/handshake_server_test.go b/src/crypto/tls/handshake_server_test.go
index 1ba716eef0..4483838045 100644
--- a/src/crypto/tls/handshake_server_test.go
+++ b/src/crypto/tls/handshake_server_test.go
@@ -397,30 +397,30 @@ func TestVersion(t *testing.T) {
 
 func TestCipherSuitePreference(t *testing.T) {
 	serverConfig := &Config{
-		CipherSuites: []uint16{TLS_RSA_WITH_RC4_128_SHA, TLS_RSA_WITH_AES_128_CBC_SHA, TLS_ECDHE_RSA_WITH_RC4_128_SHA},
+		CipherSuites: []uint16{TLS_RSA_WITH_RC4_128_SHA, TLS_AES_128_GCM_SHA256,
+			TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256},
 		Certificates: testConfig.Certificates,
-		MaxVersion:   VersionTLS11,
+		MaxVersion:   VersionTLS12,
+		GetConfigForClient: func(chi *ClientHelloInfo) (*Config, error) {
+			if chi.CipherSuites[0] != TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 {
+				t.Error("the advertised order should not depend on Config.CipherSuites")
+			}
+			if len(chi.CipherSuites) != 2+len(defaultCipherSuitesTLS13) {
+				t.Error("the advertised TLS 1.2 suites should be filtered by Config.CipherSuites")
+			}
+			return nil, nil
+		},
 	}
 	clientConfig := &Config{
-		CipherSuites:       []uint16{TLS_RSA_WITH_AES_128_CBC_SHA, TLS_RSA_WITH_RC4_128_SHA},
+		CipherSuites:       []uint16{TLS_RSA_WITH_AES_128_CBC_SHA, TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256},
 		InsecureSkipVerify: true,
 	}
 	state, _, err := testHandshake(t, clientConfig, serverConfig)
 	if err != nil {
 		t.Fatalf("handshake failed: %s", err)
 	}
-	if state.CipherSuite != TLS_RSA_WITH_AES_128_CBC_SHA {
-		// By default the server should use the client's preference.
-		t.Fatalf("Client's preference was not used, got %x", state.CipherSuite)
-	}
-
-	serverConfig.PreferServerCipherSuites = true
-	state, _, err = testHandshake(t, clientConfig, serverConfig)
-	if err != nil {
-		t.Fatalf("handshake failed: %s", err)
-	}
-	if state.CipherSuite != TLS_RSA_WITH_RC4_128_SHA {
-		t.Fatalf("Server's preference was not used, got %x", state.CipherSuite)
+	if state.CipherSuite != TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 {
+		t.Error("the preference order should not depend on Config.CipherSuites")
 	}
 }
 
@@ -1050,37 +1050,6 @@ func TestHandshakeServerEmptyCertificates(t *testing.T) {
 	testClientHelloFailure(t, serverConfig, clientHello, "no certificates")
 }
 
-// TestCipherSuiteCertPreferance ensures that we select an RSA ciphersuite with
-// an RSA certificate and an ECDSA ciphersuite with an ECDSA certificate.
-func TestCipherSuiteCertPreferenceECDSA(t *testing.T) {
-	config := testConfig.Clone()
-	config.CipherSuites = []uint16{TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA}
-	config.PreferServerCipherSuites = true
-
-	test := &serverTest{
-		name:   "CipherSuiteCertPreferenceRSA",
-		config: config,
-	}
-	runServerTestTLS12(t, test)
-
-	config = testConfig.Clone()
-	config.CipherSuites = []uint16{TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA}
-	config.Certificates = []Certificate{
-		{
-			Certificate: [][]byte{testECDSACertificate},
-			PrivateKey:  testECDSAPrivateKey,
-		},
-	}
-	config.BuildNameToCertificate()
-	config.PreferServerCipherSuites = true
-
-	test = &serverTest{
-		name:   "CipherSuiteCertPreferenceECDSA",
-		config: config,
-	}
-	runServerTestTLS12(t, test)
-}
-
 func TestServerResumption(t *testing.T) {
 	sessionFilePath := tempFile("")
 	defer os.Remove(sessionFilePath)
@@ -1178,7 +1147,7 @@ func TestFallbackSCSV(t *testing.T) {
 func TestHandshakeServerExportKeyingMaterial(t *testing.T) {
 	test := &serverTest{
 		name:    "ExportKeyingMaterial",
-		command: []string{"openssl", "s_client", "-cipher", "ECDHE-RSA-CHACHA20-POLY1305", "-ciphersuites", "TLS_CHACHA20_POLY1305_SHA256"},
+		command: []string{"openssl", "s_client", "-cipher", "ECDHE-RSA-AES256-SHA", "-ciphersuites", "TLS_CHACHA20_POLY1305_SHA256"},
 		config:  testConfig.Clone(),
 		validate: func(state ConnectionState) error {
 			if km, err := state.ExportKeyingMaterial("test", nil, 42); err != nil {
@@ -1699,15 +1668,14 @@ func TestMultipleCertificates(t *testing.T) {
 
 func TestAESCipherReordering(t *testing.T) {
 	currentAESSupport := hasAESGCMHardwareSupport
-	defer func() { hasAESGCMHardwareSupport = currentAESSupport; initDefaultCipherSuites() }()
+	defer func() { hasAESGCMHardwareSupport = currentAESSupport }()
 
 	tests := []struct {
-		name                     string
-		clientCiphers            []uint16
-		serverHasAESGCM          bool
-		preferServerCipherSuites bool
-		serverCiphers            []uint16
-		expectedCipher           uint16
+		name            string
+		clientCiphers   []uint16
+		serverHasAESGCM bool
+		serverCiphers   []uint16
+		expectedCipher  uint16
 	}{
 		{
 			name: "server has hardware AES, client doesn't (pick ChaCha)",
@@ -1716,25 +1684,8 @@ func TestAESCipherReordering(t *testing.T) {
 				TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
 				TLS_RSA_WITH_AES_128_CBC_SHA,
 			},
-			serverHasAESGCM:          true,
-			preferServerCipherSuites: true,
-			expectedCipher:           TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
-		},
-		{
-			name: "server strongly prefers AES-GCM, client doesn't (pick AES-GCM)",
-			clientCiphers: []uint16{
-				TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
-				TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
-				TLS_RSA_WITH_AES_128_CBC_SHA,
-			},
-			serverHasAESGCM:          true,
-			preferServerCipherSuites: true,
-			serverCiphers: []uint16{
-				TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
-				TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
-				TLS_RSA_WITH_AES_128_CBC_SHA,
-			},
-			expectedCipher: TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+			serverHasAESGCM: true,
+			expectedCipher:  TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
 		},
 		{
 			name: "client prefers AES-GCM, server doesn't have hardware AES (pick ChaCha)",
@@ -1778,14 +1729,14 @@ func TestAESCipherReordering(t *testing.T) {
 			expectedCipher:  TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
 		},
 		{
-			name: "client prefers AES-GCM and AES-CBC over ChaCha, server doesn't have hardware AES (pick AES-GCM)",
+			name: "client prefers AES-GCM and AES-CBC over ChaCha, server doesn't have hardware AES (pick ChaCha)",
 			clientCiphers: []uint16{
 				TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
 				TLS_RSA_WITH_AES_128_CBC_SHA,
 				TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
 			},
 			serverHasAESGCM: false,
-			expectedCipher:  TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+			expectedCipher:  TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
 		},
 		{
 			name: "client prefers AES-GCM over ChaCha and sends GREASE, server doesn't have hardware AES (pick ChaCha)",
@@ -1799,7 +1750,7 @@ func TestAESCipherReordering(t *testing.T) {
 			expectedCipher:  TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
 		},
 		{
-			name: "client supports multiple AES-GCM, server doesn't have hardware AES and doesn't support ChaCha (pick corrent AES-GCM)",
+			name: "client supports multiple AES-GCM, server doesn't have hardware AES and doesn't support ChaCha (AES-GCM)",
 			clientCiphers: []uint16{
 				TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
 				TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
@@ -1810,19 +1761,30 @@ func TestAESCipherReordering(t *testing.T) {
 				TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
 				TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
 			},
-			expectedCipher: TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+			expectedCipher: TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+		},
+		{
+			name: "client prefers AES-GCM, server has hardware but doesn't support AES (pick ChaCha)",
+			clientCiphers: []uint16{
+				TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+				TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
+				TLS_RSA_WITH_AES_128_CBC_SHA,
+			},
+			serverHasAESGCM: true,
+			serverCiphers: []uint16{
+				TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
+			},
+			expectedCipher: TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
 		},
 	}
 
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			hasAESGCMHardwareSupport = tc.serverHasAESGCM
-			initDefaultCipherSuites()
 			hs := &serverHandshakeState{
 				c: &Conn{
 					config: &Config{
-						PreferServerCipherSuites: tc.preferServerCipherSuites,
-						CipherSuites:             tc.serverCiphers,
+						CipherSuites: tc.serverCiphers,
 					},
 					vers: VersionTLS12,
 				},
@@ -1847,16 +1809,15 @@ func TestAESCipherReordering(t *testing.T) {
 	}
 }
 
-func TestAESCipherReordering13(t *testing.T) {
+func TestAESCipherReorderingTLS13(t *testing.T) {
 	currentAESSupport := hasAESGCMHardwareSupport
-	defer func() { hasAESGCMHardwareSupport = currentAESSupport; initDefaultCipherSuites() }()
+	defer func() { hasAESGCMHardwareSupport = currentAESSupport }()
 
 	tests := []struct {
-		name                     string
-		clientCiphers            []uint16
-		serverHasAESGCM          bool
-		preferServerCipherSuites bool
-		expectedCipher           uint16
+		name            string
+		clientCiphers   []uint16
+		serverHasAESGCM bool
+		expectedCipher  uint16
 	}{
 		{
 			name: "server has hardware AES, client doesn't (pick ChaCha)",
@@ -1864,9 +1825,8 @@ func TestAESCipherReordering13(t *testing.T) {
 				TLS_CHACHA20_POLY1305_SHA256,
 				TLS_AES_128_GCM_SHA256,
 			},
-			serverHasAESGCM:          true,
-			preferServerCipherSuites: true,
-			expectedCipher:           TLS_CHACHA20_POLY1305_SHA256,
+			serverHasAESGCM: true,
+			expectedCipher:  TLS_CHACHA20_POLY1305_SHA256,
 		},
 		{
 			name: "neither server nor client have hardware AES (pick ChaCha)",
@@ -1874,37 +1834,25 @@ func TestAESCipherReordering13(t *testing.T) {
 				TLS_CHACHA20_POLY1305_SHA256,
 				TLS_AES_128_GCM_SHA256,
 			},
-			serverHasAESGCM:          false,
-			preferServerCipherSuites: true,
-			expectedCipher:           TLS_CHACHA20_POLY1305_SHA256,
+			serverHasAESGCM: false,
+			expectedCipher:  TLS_CHACHA20_POLY1305_SHA256,
 		},
 		{
-			name: "client prefers AES, server doesn't have hardware, prefer server ciphers (pick ChaCha)",
+			name: "client prefers AES, server doesn't have hardware (pick ChaCha)",
 			clientCiphers: []uint16{
 				TLS_AES_128_GCM_SHA256,
 				TLS_CHACHA20_POLY1305_SHA256,
 			},
-			serverHasAESGCM:          false,
-			preferServerCipherSuites: true,
-			expectedCipher:           TLS_CHACHA20_POLY1305_SHA256,
+			serverHasAESGCM: false,
+			expectedCipher:  TLS_CHACHA20_POLY1305_SHA256,
 		},
 		{
-			name: "client prefers AES and sends GREASE, server doesn't have hardware, prefer server ciphers (pick ChaCha)",
+			name: "client prefers AES and sends GREASE, server doesn't have hardware (pick ChaCha)",
 			clientCiphers: []uint16{
 				0x0A0A, // GREASE value
 				TLS_AES_128_GCM_SHA256,
 				TLS_CHACHA20_POLY1305_SHA256,
 			},
-			serverHasAESGCM:          false,
-			preferServerCipherSuites: true,
-			expectedCipher:           TLS_CHACHA20_POLY1305_SHA256,
-		},
-		{
-			name: "client prefers AES, server doesn't (pick ChaCha)",
-			clientCiphers: []uint16{
-				TLS_AES_128_GCM_SHA256,
-				TLS_CHACHA20_POLY1305_SHA256,
-			},
 			serverHasAESGCM: false,
 			expectedCipher:  TLS_CHACHA20_POLY1305_SHA256,
 		},
@@ -1932,13 +1880,10 @@ func TestAESCipherReordering13(t *testing.T) {
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			hasAESGCMHardwareSupport = tc.serverHasAESGCM
-			initDefaultCipherSuites()
 			hs := &serverHandshakeStateTLS13{
 				c: &Conn{
-					config: &Config{
-						PreferServerCipherSuites: tc.preferServerCipherSuites,
-					},
-					vers: VersionTLS13,
+					config: &Config{},
+					vers:   VersionTLS13,
 				},
 				clientHello: &clientHelloMsg{
 					cipherSuites:       tc.clientCiphers,
diff --git a/src/crypto/tls/handshake_server_tls13.go b/src/crypto/tls/handshake_server_tls13.go
index 9c17577fd4..c375ec4246 100644
--- a/src/crypto/tls/handshake_server_tls13.go
+++ b/src/crypto/tls/handshake_server_tls13.go
@@ -150,29 +150,12 @@ func (hs *serverHandshakeStateTLS13) processClientHello() error {
 	hs.hello.sessionId = hs.clientHello.sessionId
 	hs.hello.compressionMethod = compressionNone
 
-	var preferenceList, supportedList []uint16
-	if c.config.PreferServerCipherSuites {
-		preferenceList = defaultCipherSuitesTLS13()
-		supportedList = hs.clientHello.cipherSuites
-
-		// If the client does not seem to have hardware support for AES-GCM,
-		// prefer other AEAD ciphers even if we prioritized AES-GCM ciphers
-		// by default.
-		if !aesgcmPreferred(hs.clientHello.cipherSuites) {
-			preferenceList = deprioritizeAES(preferenceList)
-		}
-	} else {
-		preferenceList = hs.clientHello.cipherSuites
-		supportedList = defaultCipherSuitesTLS13()
-
-		// If we don't have hardware support for AES-GCM, prefer other AEAD
-		// ciphers even if the client prioritized AES-GCM.
-		if !hasAESGCMHardwareSupport {
-			preferenceList = deprioritizeAES(preferenceList)
-		}
+	preferenceList := defaultCipherSuitesTLS13
+	if !hasAESGCMHardwareSupport || !aesgcmPreferred(hs.clientHello.cipherSuites) {
+		preferenceList = defaultCipherSuitesTLS13NoAES
 	}
 	for _, suiteID := range preferenceList {
-		hs.suite = mutualCipherSuiteTLS13(supportedList, suiteID)
+		hs.suite = mutualCipherSuiteTLS13(hs.clientHello.cipherSuites, suiteID)
 		if hs.suite != nil {
 			break
 		}
diff --git a/src/crypto/tls/handshake_test.go b/src/crypto/tls/handshake_test.go
index d9ff9fe948..9bfb1177f2 100644
--- a/src/crypto/tls/handshake_test.go
+++ b/src/crypto/tls/handshake_test.go
@@ -335,15 +335,9 @@ func TestMain(m *testing.M) {
 }
 
 func runMain(m *testing.M) int {
-	// TLS 1.3 cipher suites preferences are not configurable and change based
-	// on the architecture. Force them to the version with AES acceleration for
-	// test consistency.
-	once.Do(initDefaultCipherSuites)
-	varDefaultCipherSuitesTLS13 = []uint16{
-		TLS_AES_128_GCM_SHA256,
-		TLS_CHACHA20_POLY1305_SHA256,
-		TLS_AES_256_GCM_SHA384,
-	}
+	// Cipher suites preferences change based on the architecture. Force them to
+	// the version without AES acceleration for test consistency.
+	hasAESGCMHardwareSupport = false
 
 	// Set up localPipe.
 	l, err := net.Listen("tcp", "127.0.0.1:0")
diff --git a/src/crypto/tls/key_agreement.go b/src/crypto/tls/key_agreement.go
index 7e6534bd46..8cfbd734f1 100644
--- a/src/crypto/tls/key_agreement.go
+++ b/src/crypto/tls/key_agreement.go
@@ -15,6 +15,25 @@ import (
 	"io"
 )
 
+// a keyAgreement implements the client and server side of a TLS key agreement
+// protocol by generating and processing key exchange messages.
+type keyAgreement interface {
+	// On the server side, the first two methods are called in order.
+
+	// In the case that the key agreement protocol doesn't use a
+	// ServerKeyExchange message, generateServerKeyExchange can return nil,
+	// nil.
+	generateServerKeyExchange(*Config, *Certificate, *clientHelloMsg, *serverHelloMsg) (*serverKeyExchangeMsg, error)
+	processClientKeyExchange(*Config, *Certificate, *clientKeyExchangeMsg, uint16) ([]byte, error)
+
+	// On the client side, the next two methods are called in order.
+
+	// This method may not be called if the server doesn't send a
+	// ServerKeyExchange message.
+	processServerKeyExchange(*Config, *clientHelloMsg, *serverHelloMsg, *x509.Certificate, *serverKeyExchangeMsg) error
+	generateClientKeyExchange(*Config, *clientHelloMsg, *x509.Certificate) ([]byte, *clientKeyExchangeMsg, error)
+}
+
 var errClientKeyExchange = errors.New("tls: invalid ClientKeyExchange message")
 var errServerKeyExchange = errors.New("tls: invalid ServerKeyExchange message")
 
diff --git a/src/crypto/tls/testdata/Client-TLSv10-ClientCert-ECDSA-ECDSA b/src/crypto/tls/testdata/Client-TLSv10-ClientCert-ECDSA-ECDSA
index 9de3f1437b..c7fa530b92 100644
--- a/src/crypto/tls/testdata/Client-TLSv10-ClientCert-ECDSA-ECDSA
+++ b/src/crypto/tls/testdata/Client-TLSv10-ClientCert-ECDSA-ECDSA
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 01 00 59 02 00 00  55 03 01 94 1f ba 79 da  |....Y...U.....y.|
-00000010  4b 58 3e 08 2c c5 31 36  a4 7e 32 bf e1 a0 f7 71  |KX>.,.16.~2....q|
-00000020  01 48 63 3c 5f cb 08 7a  25 80 c7 20 35 0c c0 8b  |.Hc<_..z%.. 5...|
-00000030  df 30 fc dc 3d f1 48 96  0d b6 ff a8 cd 35 29 57  |.0..=.H......5)W|
-00000040  7d 3f c2 9d e2 32 b1 c2  4c 05 5e 3b c0 09 00 00  |}?...2..L.^;....|
+00000000  16 03 01 00 59 02 00 00  55 03 01 92 4c b7 e6 07  |....Y...U...L...|
+00000010  09 b4 4a 47 6a 29 c7 79  18 0d 43 37 86 26 21 5a  |..JGj).y..C7.&!Z|
+00000020  25 35 db 5f ae d0 20 0d  85 67 f7 20 75 e5 cb 25  |%5._.. ..g. u..%|
+00000030  4b 5d 95 87 78 00 fc 3f  78 26 e8 77 b5 0d d4 0e  |K]..x..?x&.w....|
+00000040  54 06 66 b4 14 dc 6b db  f2 af f3 2a c0 09 00 00  |T.f...k....*....|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  01 02 0e 0b 00 02 0a 00  02 07 00 02 04 30 82 02  |.............0..|
 00000070  00 30 82 01 62 02 09 00  b8 bf 2d 47 a0 d2 eb f4  |.0..b.....-G....|
@@ -55,18 +55,18 @@
 00000240  13 83 0d 94 06 bb d4 37  7a f6 ec 7a c9 86 2e dd  |.......7z..z....|
 00000250  d7 11 69 7f 85 7c 56 de  fb 31 78 2b e4 c7 78 0d  |..i..|V..1x+..x.|
 00000260  ae cb be 9e 4e 36 24 31  7b 6a 0f 39 95 12 07 8f  |....N6$1{j.9....|
-00000270  2a 16 03 01 00 b5 0c 00  00 b1 03 00 1d 20 1a 74  |*............ .t|
-00000280  c4 96 9e 65 45 9a 0a 01  7c ed 7b 51 01 d8 ba 5b  |...eE...|.{Q...[|
-00000290  3e 2f b1 4b 36 69 e8 47  75 7e 27 be b3 2f 00 8b  |>/.K6i.Gu~'../..|
-000002a0  30 81 88 02 42 01 cb 20  d9 1e ae 05 6f 1f 37 ce  |0...B.. ....o.7.|
-000002b0  dc 38 20 2f 8f 52 9a 92  f6 80 d6 f9 97 99 a5 8b  |.8 /.R..........|
-000002c0  6e 73 0b 95 a4 4e 82 67  bd 1a 34 d9 5c 4e b4 d7  |ns...N.g..4.\N..|
-000002d0  35 e6 45 81 14 23 9c 4e  5a 4c 1b 93 fd 7f 43 18  |5.E..#.NZL....C.|
-000002e0  db 54 4b e0 d1 d3 fa 02  42 00 ab 8e 34 d5 c2 04  |.TK.....B...4...|
-000002f0  d0 a4 44 b1 b3 25 a0 af  c8 80 b3 88 ae da b3 c6  |..D..%..........|
-00000300  4f 57 ae 31 54 c6 d9 ee  4e 21 56 01 cc b9 6a e9  |OW.1T...N!V...j.|
-00000310  e9 7e 62 2a 64 0e a4 a0  79 1e a3 64 52 70 b1 a5  |.~b*d...y..dRp..|
-00000320  19 2c a4 6d 4b 3b a3 63  ed 56 2f 16 03 01 00 0a  |.,.mK;.c.V/.....|
+00000270  2a 16 03 01 00 b5 0c 00  00 b1 03 00 1d 20 d7 b5  |*............ ..|
+00000280  51 8e b5 01 4f 02 2f 43  11 2b de 94 7d 82 e6 49  |Q...O./C.+..}..I|
+00000290  1b a6 ee a0 7f 12 35 a2  3a 62 46 ce 07 25 00 8b  |......5.:bF..%..|
+000002a0  30 81 88 02 42 00 83 45  db 03 db b9 74 ce 77 35  |0...B..E....t.w5|
+000002b0  1b e5 76 18 dc 3a d3 ee  32 18 f3 16 a6 c3 62 be  |..v..:..2.....b.|
+000002c0  46 47 40 80 2d a0 08 c5  1e 5a 4a 42 69 8c ee e5  |FG@.-....ZJBi...|
+000002d0  70 b5 71 30 2f 54 32 54  5f 5b 26 62 e1 81 52 9e  |p.q0/T2T_[&b..R.|
+000002e0  49 70 d4 81 e4 76 f1 02  42 01 70 f6 87 84 bb 58  |Ip...v..B.p....X|
+000002f0  5d e4 a1 72 87 d5 35 53  99 9c 3f 30 2b 80 7e c9  |]..r..5S..?0+.~.|
+00000300  79 eb d8 97 3c 82 ff 37  a5 8d 36 bc 27 c1 51 58  |y...<..7..6.'.QX|
+00000310  e6 2a 48 05 bf 9b a4 a5  b1 7f 77 b8 d9 3e 37 c6  |.*H.......w..>7.|
+00000320  67 ad ef 8c 72 ea f6 ba  bb af 00 16 03 01 00 0a  |g...r...........|
 00000330  0d 00 00 06 03 01 02 40  00 00 16 03 01 00 04 0e  |.......@........|
 00000340  00 00 00                                          |...|
 >>> Flow 3 (client to server)
@@ -105,30 +105,30 @@
 00000200  e4 fa cc b1 8a ce e2 23  a0 87 f0 e1 67 51 eb 16  |.......#....gQ..|
 00000210  03 01 00 25 10 00 00 21  20 2f e5 7d a3 47 cd 62  |...%...! /.}.G.b|
 00000220  43 15 28 da ac 5f bb 29  07 30 ff f6 84 af c4 cf  |C.(.._.).0......|
-00000230  c2 ed 90 99 5f 58 cb 3b  74 16 03 01 00 90 0f 00  |...._X.;t.......|
-00000240  00 8c 00 8a 30 81 87 02  42 01 89 0f 43 df a8 34  |....0...B...C..4|
-00000250  dd d7 c9 d4 2b 8d ec 29  77 7b 64 d0 0e 8c e8 2b  |....+..)w{d....+|
-00000260  e3 25 1c ed 0a 1b 05 e0  66 42 37 c0 e6 fa 3e 81  |.%......fB7...>.|
-00000270  ec e1 06 99 f4 62 3f ea  55 79 ae 68 56 9e e3 3c  |.....b?.Uy.hV..<|
-00000280  83 ba 9b 1c 65 b9 eb a6  e7 f7 4e 02 41 61 2c 52  |....e.....N.Aa,R|
-00000290  4c 48 92 b0 93 d8 31 58  c3 90 b0 e3 7d 55 94 fc  |LH....1X....}U..|
-000002a0  70 bf 18 42 51 73 d0 45  17 2e 0e 00 b0 12 76 0d  |p..BQs.E......v.|
-000002b0  35 78 cb fd 34 60 36 ff  ed 19 ef 0a 1e 21 cc 4c  |5x..4`6......!.L|
-000002c0  9a ff a0 f7 cf 72 03 cd  00 bb 73 0d 1d e5 14 03  |.....r....s.....|
-000002d0  01 00 01 01 16 03 01 00  30 69 76 1f 5b 81 5f 62  |........0iv.[._b|
-000002e0  cf d5 d9 2c 19 71 80 d0  2a 97 8a 89 21 7f 6d 02  |...,.q..*...!.m.|
-000002f0  b6 01 a4 ed fe 18 9f 34  ae 95 f6 a1 29 0b 9a 1c  |.......4....)...|
-00000300  04 b6 ce c7 d1 0c 5a b5  3f                       |......Z.?|
+00000230  c2 ed 90 99 5f 58 cb 3b  74 16 03 01 00 91 0f 00  |...._X.;t.......|
+00000240  00 8d 00 8b 30 81 88 02  42 01 f0 c3 b2 6e e2 a3  |....0...B....n..|
+00000250  cd 76 02 7a d5 b5 66 fa  b6 66 4e 4b a0 17 d6 bd  |.v.z..f..fNK....|
+00000260  ec f6 8c 1f f9 b4 32 18  a9 ba 66 a8 67 a4 fa c8  |......2...f.g...|
+00000270  f7 73 5f 22 fb f2 22 e2  4d a1 f6 30 a2 55 76 51  |.s_"..".M..0.UvQ|
+00000280  b7 61 7d 13 68 0a 89 9d  34 31 46 02 42 01 fa 8b  |.a}.h...41F.B...|
+00000290  61 f6 91 8e 88 ca 84 e6  33 e0 da 92 7e ee 21 1c  |a.......3...~.!.|
+000002a0  df 47 c2 5d 07 d8 ae 1b  04 58 f9 50 16 13 74 ea  |.G.].....X.P..t.|
+000002b0  04 cc 18 2d 2b 9a 08 89  24 e8 b8 01 bb c6 84 6c  |...-+...$......l|
+000002c0  e6 9a c6 8a 44 74 1c 3a  79 0c e9 3c 11 ba 1b 14  |....Dt.:y..<....|
+000002d0  03 01 00 01 01 16 03 01  00 30 1d 4b df 00 de 1c  |.........0.K....|
+000002e0  b5 30 7b ea 64 a0 09 89  8c c5 be fc 9b 07 7e 45  |.0{.d.........~E|
+000002f0  27 00 e7 78 da 3e a3 04  97 87 b0 c2 17 32 01 91  |'..x.>.......2..|
+00000300  6e 66 7b dd 9e 28 bc cc  66 65                    |nf{..(..fe|
 >>> Flow 4 (server to client)
-00000000  14 03 01 00 01 01 16 03  01 00 30 7d 4b fc 73 20  |..........0}K.s |
-00000010  e4 ac c4 39 15 79 e3 89  e1 24 ce 28 30 e5 f1 87  |...9.y...$.(0...|
-00000020  cd c0 cc 39 a8 77 3b 06  a5 f9 b0 a1 3d 54 53 3b  |...9.w;.....=TS;|
-00000030  53 ec ac b2 ea 24 1b 2d  6a ef c3                 |S....$.-j..|
+00000000  14 03 01 00 01 01 16 03  01 00 30 51 68 ca 97 63  |..........0Qh..c|
+00000010  c6 c0 24 1c 87 20 70 ac  f7 47 16 45 44 17 cc 92  |..$.. p..G.ED...|
+00000020  b3 6d 8b fa d1 3c b8 10  d7 da e4 a7 35 3c a2 d0  |.m...<......5<..|
+00000030  da 4b 50 e4 89 94 4b bc  20 6b e3                 |.KP...K. k.|
 >>> Flow 5 (client to server)
-00000000  17 03 01 00 20 9d 57 d2  4b 5b 7e 7d 7c 28 f7 8e  |.... .W.K[~}|(..|
-00000010  00 0a b6 1c 3c 6b df 4d  06 c0 f8 db 86 2e 8f 8e  |....<k.M........|
-00000020  28 a9 ab 6c c2 17 03 01  00 20 b4 4e cc 55 14 1c  |(..l..... .N.U..|
-00000030  64 a4 3d 69 1a dc 3b 12  8e d8 15 f2 31 3a 71 1f  |d.=i..;.....1:q.|
-00000040  eb fe c3 b3 22 f7 2c 6e  01 e9 15 03 01 00 20 2a  |....".,n...... *|
-00000050  2e 34 ca 96 e5 a3 a0 53  c4 0c e2 0a b1 14 a3 c8  |.4.....S........|
-00000060  a5 db 72 09 31 25 11 11  2f ce 61 3a 55 48 0c     |..r.1%../.a:UH.|
+00000000  17 03 01 00 20 fc fa 90  90 d0 51 0d 35 0f 6a 6d  |.... .....Q.5.jm|
+00000010  c2 32 ec 92 46 9f d7 e9  66 37 02 2a f6 c6 2e e2  |.2..F...f7.*....|
+00000020  13 aa fa fa d3 17 03 01  00 20 45 a9 36 19 7d a8  |......... E.6.}.|
+00000030  44 4c 8b aa 4e 47 c8 79  0c 97 a5 20 fa 6f 1f f7  |DL..NG.y... .o..|
+00000040  d3 bc d7 6d c2 67 23 c8  d6 05 15 03 01 00 20 f1  |...m.g#....... .|
+00000050  f1 ed f9 fc c2 f6 61 c8  42 9d c9 8a b0 d0 de d3  |......a.B.......|
+00000060  42 c7 04 64 eb 9e eb 58  3b c3 7d 0d 4d 16 d4     |B..d...X;.}.M..|
diff --git a/src/crypto/tls/testdata/Client-TLSv10-ClientCert-ECDSA-RSA b/src/crypto/tls/testdata/Client-TLSv10-ClientCert-ECDSA-RSA
index 754b76ece9..81e5191925 100644
--- a/src/crypto/tls/testdata/Client-TLSv10-ClientCert-ECDSA-RSA
+++ b/src/crypto/tls/testdata/Client-TLSv10-ClientCert-ECDSA-RSA
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 01 00 59 02 00 00  55 03 01 97 0c 7e fc 7f  |....Y...U....~..|
-00000010  96 47 02 21 a7 19 45 a5  79 5c 5e fc c2 15 b3 fa  |.G.!..E.y\^.....|
-00000020  84 98 7d 67 65 c8 48 58  a1 5d 67 20 ad 2a c6 b3  |..}ge.HX.]g .*..|
-00000030  a4 17 82 12 4a c5 97 af  12 6b 7d f6 9e 49 f1 38  |....J....k}..I.8|
-00000040  d0 56 76 bc 81 23 ad 3a  3e 7f bc 2d c0 13 00 00  |.Vv..#.:>..-....|
+00000000  16 03 01 00 59 02 00 00  55 03 01 ca 72 6a a1 69  |....Y...U...rj.i|
+00000010  18 a4 f8 76 4a c3 5c e8  d5 c1 fb 06 c6 9a 14 67  |...vJ.\........g|
+00000020  ce e4 f6 52 67 ab 64 48  28 5a 63 20 55 ea ff 87  |...Rg.dH(Zc U...|
+00000030  5a 78 5c cb 21 af 83 a5  ed 1b d3 2c 39 81 e5 ca  |Zx\.!......,9...|
+00000040  63 d2 5c 57 27 1d d0 f9  41 40 43 b0 c0 13 00 00  |c.\W'...A@C.....|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  01 02 59 0b 00 02 55 00  02 52 00 02 4f 30 82 02  |..Y...U..R..O0..|
 00000070  4b 30 82 01 b4 a0 03 02  01 02 02 09 00 e8 f0 9d  |K0..............|
@@ -60,17 +60,17 @@
 00000290  77 8d 0c 1c f1 0f a1 d8  40 83 61 c9 4c 72 2b 9d  |w.......@.a.Lr+.|
 000002a0  ae db 46 06 06 4d f4 c1  b3 3e c0 d1 bd 42 d4 db  |..F..M...>...B..|
 000002b0  fe 3d 13 60 84 5c 21 d3  3b e9 fa e7 16 03 01 00  |.=.`.\!.;.......|
-000002c0  aa 0c 00 00 a6 03 00 1d  20 a4 24 f7 67 e3 da fa  |........ .$.g...|
-000002d0  10 33 95 b4 46 00 c0 3c  cd 74 12 e4 a3 3b 01 70  |.3..F..<.t...;.p|
-000002e0  fb 98 01 9a e9 2d d0 18  7b 00 80 ce c5 7b 4b 87  |.....-..{....{K.|
-000002f0  cd bc 5d 63 09 7e d4 ce  09 53 7a 1b e5 b4 10 54  |..]c.~...Sz....T|
-00000300  89 52 ac 82 9c 78 88 ed  e8 1a 8c 3a 7a 2c 9a c5  |.R...x.....:z,..|
-00000310  2b 97 1c 79 43 bd b1 ee  93 6f 4c 4d fc 3c 47 91  |+..yC....oLM.<G.|
-00000320  a6 ac ad be a9 39 12 98  40 f7 6a a3 e7 21 76 90  |.....9..@.j..!v.|
-00000330  c9 80 2b bc 80 3f 7e 60  59 7d cd 38 84 a8 53 2a  |..+..?~`Y}.8..S*|
-00000340  92 24 08 8f 84 da cd 9a  86 80 10 05 8f 1b fd 86  |.$..............|
-00000350  93 b6 ef 13 70 e5 6a d5  0e a5 bf 80 bf 50 a8 d4  |....p.j......P..|
-00000360  87 99 b8 d6 f0 4f 45 d5  e6 8b e1 16 03 01 00 0a  |.....OE.........|
+000002c0  aa 0c 00 00 a6 03 00 1d  20 e8 a5 9c e4 73 3d 75  |........ ....s=u|
+000002d0  0c 3e f2 de 21 9c 0f 91  b4 fd 94 f0 27 f6 d9 7d  |.>..!.......'..}|
+000002e0  cd 0c 4c 50 b0 47 db dd  12 00 80 04 c0 be d5 bb  |..LP.G..........|
+000002f0  e8 e2 a2 2e d9 2e 75 fa  b6 07 d0 f7 75 52 fb 2f  |......u.....uR./|
+00000300  50 cd 43 68 bd 42 11 6d  d6 9f a3 d1 00 fd a9 14  |P.Ch.B.m........|
+00000310  0c 2a dd 76 ea 73 21 52  00 3a 83 cf d7 07 c7 bd  |.*.v.s!R.:......|
+00000320  78 21 ce 35 80 b3 06 22  f1 96 a7 20 41 f8 aa 61  |x!.5..."... A..a|
+00000330  94 b4 77 d4 d9 92 f2 66  c5 1c d1 82 f3 b9 e2 9d  |..w....f........|
+00000340  a9 30 1c e2 4e ec 0d 32  3d 0d 61 22 c8 e5 95 9f  |.0..N..2=.a"....|
+00000350  cf 3e fc a8 c5 c3 f8 45  45 29 ea a7 e7 b7 a6 17  |.>.....EE)......|
+00000360  9e 5f 83 d4 b3 f0 da 31  73 94 f2 16 03 01 00 0a  |._.....1s.......|
 00000370  0d 00 00 06 03 01 02 40  00 00 16 03 01 00 04 0e  |.......@........|
 00000380  00 00 00                                          |...|
 >>> Flow 3 (client to server)
@@ -110,29 +110,29 @@
 00000210  03 01 00 25 10 00 00 21  20 2f e5 7d a3 47 cd 62  |...%...! /.}.G.b|
 00000220  43 15 28 da ac 5f bb 29  07 30 ff f6 84 af c4 cf  |C.(.._.).0......|
 00000230  c2 ed 90 99 5f 58 cb 3b  74 16 03 01 00 91 0f 00  |...._X.;t.......|
-00000240  00 8d 00 8b 30 81 88 02  42 01 71 f3 c4 3a 85 08  |....0...B.q..:..|
-00000250  3b 18 26 48 5c 3f c3 8a  4f e9 d7 29 48 59 1a 35  |;.&H\?..O..)HY.5|
-00000260  ee b3 0d 5e 29 03 1d 34  95 0e 40 73 85 13 14 d0  |...^)..4..@s....|
-00000270  fb fb 96 77 21 fb d8 43  d7 e2 bf 2c 95 7b 75 5d  |...w!..C...,.{u]|
-00000280  59 15 81 71 d2 b6 82 96  d9 cc 78 02 42 01 d3 51  |Y..q......x.B..Q|
-00000290  af 25 d0 f8 a4 e2 e7 8e  7e 46 56 53 8f d1 09 f6  |.%......~FVS....|
-000002a0  76 88 5a 42 83 89 92 7b  c7 e4 40 9c 3d 05 ac 43  |v.ZB...{..@.=..C|
-000002b0  bf 6e 24 14 fe 36 f8 43  a6 90 8e a1 bd e2 92 84  |.n$..6.C........|
-000002c0  60 e3 92 34 1c 7b 53 d5  57 6d 23 32 12 a8 23 14  |`..4.{S.Wm#2..#.|
-000002d0  03 01 00 01 01 16 03 01  00 30 6f 06 c7 84 fa 7f  |.........0o.....|
-000002e0  c9 66 a9 6f 26 37 45 db  42 c8 8f 63 c3 5b 05 07  |.f.o&7E.B..c.[..|
-000002f0  ef 07 41 be 71 60 35 d3  16 8f 92 f6 89 cb c7 dc  |..A.q`5.........|
-00000300  4e 45 61 99 31 45 66 40  36 86                    |NEa.1Ef@6.|
+00000240  00 8d 00 8b 30 81 88 02  42 00 9a b9 f6 98 e3 ed  |....0...B.......|
+00000250  ed 0d a3 0e 54 51 9f 73  d4 87 40 4e a9 39 4b 2d  |....TQ.s..@N.9K-|
+00000260  2a b9 4d 8d e3 46 c3 b6  39 f2 ca a9 c9 0f 79 c1  |*.M..F..9.....y.|
+00000270  0c 90 6f de 58 97 72 fc  a8 c1 4c 12 aa a4 85 57  |..o.X.r...L....W|
+00000280  50 7c a0 02 8a 12 c5 80  aa b6 39 02 42 00 9c b7  |P|........9.B...|
+00000290  95 b4 04 83 5b 3a e1 ac  da 78 86 11 f5 30 75 4a  |....[:...x...0uJ|
+000002a0  25 67 6c fd ef 5a d8 56  d3 60 93 cf 65 07 2b 1f  |%gl..Z.V.`..e.+.|
+000002b0  a9 40 a8 ba cd 0e 41 2d  10 43 a4 61 93 b7 0a 11  |.@....A-.C.a....|
+000002c0  78 d1 72 2b 20 07 49 5a  76 02 17 57 87 78 c7 14  |x.r+ .IZv..W.x..|
+000002d0  03 01 00 01 01 16 03 01  00 30 93 de 1b 64 0e 56  |.........0...d.V|
+000002e0  d9 a8 da f7 37 cb ac ac  3e f5 e2 f9 87 19 f2 79  |....7...>......y|
+000002f0  24 76 19 a4 a2 41 d6 9e  7d ca aa 3e 1d d7 22 dd  |$v...A..}..>..".|
+00000300  05 aa dd 74 03 db fd a2  de ee                    |...t......|
 >>> Flow 4 (server to client)
-00000000  14 03 01 00 01 01 16 03  01 00 30 d3 83 ac 08 7f  |..........0.....|
-00000010  a1 91 51 7c b7 99 6f 24  cd b1 cd 31 7b 12 20 47  |..Q|..o$...1{. G|
-00000020  66 08 22 f6 28 ea 81 fe  92 b5 c8 40 60 bc 5b 19  |f.".(......@`.[.|
-00000030  e0 2b d1 26 fd 4c 12 22  c5 13 9a                 |.+.&.L."...|
+00000000  14 03 01 00 01 01 16 03  01 00 30 4d 4f d6 67 05  |..........0MO.g.|
+00000010  32 8c 16 cb 19 35 b3 b9  02 d8 5e 24 b6 c8 b7 3a  |2....5....^$...:|
+00000020  17 34 98 77 e1 73 e0 cd  a9 30 a8 15 60 8c f4 9a  |.4.w.s...0..`...|
+00000030  dc cf 7a fd 86 85 1c 2b  33 21 e8                 |..z....+3!.|
 >>> Flow 5 (client to server)
-00000000  17 03 01 00 20 79 06 89  7e e0 17 9a e3 dc 4c ee  |.... y..~.....L.|
-00000010  70 63 13 bc 27 f5 43 fa  f8 90 49 d9 89 43 7a 15  |pc..'.C...I..Cz.|
-00000020  d4 e2 a8 e6 3e 17 03 01  00 20 ea 84 0e 21 62 d5  |....>.... ...!b.|
-00000030  ee 26 5e fc 3e 0c 83 3b  91 01 c4 a7 8e 9b c4 1a  |.&^.>..;........|
-00000040  86 f8 a0 44 21 44 2f 31  cf a1 15 03 01 00 20 c6  |...D!D/1...... .|
-00000050  11 f1 65 ea f3 39 d1 d2  ac 95 1f 81 36 ae db b1  |..e..9......6...|
-00000060  88 a8 42 25 86 ec 1b c1  7e 12 60 a9 6b 7f 66     |..B%....~.`.k.f|
+00000000  17 03 01 00 20 b8 c5 17  b7 92 d8 93 7a b2 fd 4f  |.... .......z..O|
+00000010  15 d1 db b9 47 54 00 a0  f6 77 92 03 a8 89 e5 ba  |....GT...w......|
+00000020  cc eb d9 bd 27 17 03 01  00 20 57 d5 9a f6 36 b2  |....'.... W...6.|
+00000030  57 ba cd 64 77 36 b9 74  fb bd 95 51 03 61 e8 45  |W..dw6.t...Q.a.E|
+00000040  cb b8 35 f0 05 17 b3 08  c6 cb 15 03 01 00 20 28  |..5........... (|
+00000050  43 03 ab 3f e2 f5 d0 33  4c 7f 50 a4 ee 7b 46 e6  |C..?...3L.P..{F.|
+00000060  12 76 d0 fd c3 99 5c 63  a4 04 ea 4b e3 bd 99     |.v....\c...K...|
diff --git a/src/crypto/tls/testdata/Client-TLSv10-ClientCert-RSA-ECDSA b/src/crypto/tls/testdata/Client-TLSv10-ClientCert-RSA-ECDSA
index 641ab1bd15..3ee661ecec 100644
--- a/src/crypto/tls/testdata/Client-TLSv10-ClientCert-RSA-ECDSA
+++ b/src/crypto/tls/testdata/Client-TLSv10-ClientCert-RSA-ECDSA
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 01 00 59 02 00 00  55 03 01 3b 4c b9 76 d2  |....Y...U..;L.v.|
-00000010  c3 d1 ea 81 71 1a 10 e1  b1 69 5c 54 c2 df 17 0a  |....q....i\T....|
-00000020  de 41 cb d1 69 c3 9a da  90 fd 25 20 1e 02 11 16  |.A..i.....% ....|
-00000030  ab 66 13 56 3d 94 00 a9  80 7c d8 57 12 99 1c 5f  |.f.V=....|.W..._|
-00000040  7a b2 02 8c 23 f3 76 b8  59 5e 16 dd c0 09 00 00  |z...#.v.Y^......|
+00000000  16 03 01 00 59 02 00 00  55 03 01 b4 ff c0 49 36  |....Y...U.....I6|
+00000010  1d 31 9a a7 f6 33 f5 16  78 d7 10 9e 19 eb 1d 67  |.1...3..x......g|
+00000020  20 39 f8 73 7e 27 e2 dc  d1 ab 03 20 79 64 67 f7  | 9.s~'..... ydg.|
+00000030  8b c8 97 f0 b4 87 0e 2d  4b 22 6c ed 92 48 85 52  |.......-K"l..H.R|
+00000040  eb 57 56 a8 cf 19 9f 4d  e3 38 5e a0 c0 09 00 00  |.WV....M.8^.....|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  01 02 0e 0b 00 02 0a 00  02 07 00 02 04 30 82 02  |.............0..|
 00000070  00 30 82 01 62 02 09 00  b8 bf 2d 47 a0 d2 eb f4  |.0..b.....-G....|
@@ -55,20 +55,20 @@
 00000240  13 83 0d 94 06 bb d4 37  7a f6 ec 7a c9 86 2e dd  |.......7z..z....|
 00000250  d7 11 69 7f 85 7c 56 de  fb 31 78 2b e4 c7 78 0d  |..i..|V..1x+..x.|
 00000260  ae cb be 9e 4e 36 24 31  7b 6a 0f 39 95 12 07 8f  |....N6$1{j.9....|
-00000270  2a 16 03 01 00 b5 0c 00  00 b1 03 00 1d 20 16 64  |*............ .d|
-00000280  ca 24 70 6f 61 2f 9e 2d  43 0a 73 ac 67 f0 7a e5  |.$poa/.-C.s.g.z.|
-00000290  c7 4e c4 1f ad 13 0d eb  df ff 0d ff a3 27 00 8b  |.N...........'..|
-000002a0  30 81 88 02 42 01 1a 33  8b 88 78 ed 5c c1 56 0d  |0...B..3..x.\.V.|
-000002b0  75 51 69 a0 e7 45 6d ae  b0 67 55 3f be 23 3e 92  |uQi..Em..gU?.#>.|
-000002c0  fe 26 68 a2 30 84 2f b3  33 66 f6 dd 71 67 99 5e  |.&h.0./.3f..qg.^|
-000002d0  1c 6f bf 87 ed 33 a0 87  69 f6 35 65 8d cb 3a 7e  |.o...3..i.5e..:~|
-000002e0  95 a7 a4 40 54 cb 97 02  42 00 a3 fe 50 34 68 9f  |...@T...B...P4h.|
-000002f0  f2 43 98 23 e4 24 ad 36  e9 d3 e0 75 2c 11 46 6c  |.C.#.$.6...u,.Fl|
-00000300  48 33 c5 bc 2d 04 ff cc  bb ec 38 ec f4 b3 55 31  |H3..-.....8...U1|
-00000310  8a 6e 38 a5 6d a0 9c fc  f6 98 75 48 c6 79 53 de  |.n8.m.....uH.yS.|
-00000320  dd 91 49 f0 b6 32 83 45  61 89 4e 16 03 01 00 0a  |..I..2.Ea.N.....|
-00000330  0d 00 00 06 03 01 02 40  00 00 16 03 01 00 04 0e  |.......@........|
-00000340  00 00 00                                          |...|
+00000270  2a 16 03 01 00 b4 0c 00  00 b0 03 00 1d 20 ec 38  |*............ .8|
+00000280  f7 41 d0 f3 f4 6a ca 47  18 74 f1 22 2c 47 ee 39  |.A...j.G.t.",G.9|
+00000290  c9 a2 db 64 05 01 ae 5d  08 65 53 7f 24 78 00 8a  |...d...].eS.$x..|
+000002a0  30 81 87 02 41 64 39 65  56 fa d4 69 e7 c5 a5 32  |0...Ad9eV..i...2|
+000002b0  4c 52 55 96 fe 01 cd 41  3c 18 ed df fd 09 c3 89  |LRU....A<.......|
+000002c0  80 bd 88 9e d7 a1 85 16  d1 a4 5a f0 9a 76 e9 2f  |..........Z..v./|
+000002d0  d2 a4 42 a4 89 98 6c 87  64 b1 49 4e 6a 68 d2 43  |..B...l.d.INjh.C|
+000002e0  41 a2 c7 a6 2f f7 02 42  01 6c bb 32 c0 47 7e 08  |A.../..B.l.2.G~.|
+000002f0  6b 7a 44 18 b7 5d 4c 4d  6d 80 92 bb e5 65 98 1b  |kzD..]LMm....e..|
+00000300  d7 a6 a3 1b b5 f3 46 1a  e7 e0 89 04 40 b0 29 aa  |......F.....@.).|
+00000310  fe 85 6a 9a 4b 18 75 ab  00 52 71 54 41 8d eb 31  |..j.K.u..RqTA..1|
+00000320  47 69 9b 9d dc 3b 1b 3e  76 27 16 03 01 00 0a 0d  |Gi...;.>v'......|
+00000330  00 00 06 03 01 02 40 00  00 16 03 01 00 04 0e 00  |......@.........|
+00000340  00 00                                             |..|
 >>> Flow 3 (client to server)
 00000000  16 03 01 01 fd 0b 00 01  f9 00 01 f6 00 01 f3 30  |...............0|
 00000010  82 01 ef 30 82 01 58 a0  03 02 01 02 02 10 5c 19  |...0..X.......\.|
@@ -105,29 +105,29 @@
 00000200  e5 35 16 03 01 00 25 10  00 00 21 20 2f e5 7d a3  |.5....%...! /.}.|
 00000210  47 cd 62 43 15 28 da ac  5f bb 29 07 30 ff f6 84  |G.bC.(.._.).0...|
 00000220  af c4 cf c2 ed 90 99 5f  58 cb 3b 74 16 03 01 00  |......._X.;t....|
-00000230  86 0f 00 00 82 00 80 90  68 a8 2f 6f 2b 70 e4 25  |........h./o+p.%|
-00000240  7d fb b7 85 db 44 ec 1a  ad 6d 84 fb 95 21 fa 24  |}....D...m...!.$|
-00000250  7b 31 6a 97 4f 06 ee 87  22 c3 7c 81 70 ed e3 2a  |{1j.O...".|.p..*|
-00000260  d5 2c d1 4e 6d f0 12 52  2f 98 05 08 af 41 fa 87  |.,.Nm..R/....A..|
-00000270  d1 62 98 6c 06 47 ec 7a  44 e0 7d ae 7a 7d ef 1b  |.b.l.G.zD.}.z}..|
-00000280  d5 2c fa 1b 70 a3 fb 9a  5d 8c 60 b4 44 6a e5 b8  |.,..p...].`.Dj..|
-00000290  80 4c 29 fc f1 2d f1 11  46 81 c4 01 e4 11 2e 05  |.L)..-..F.......|
-000002a0  cb 2b ca d9 4a 14 39 06  93 77 19 db 80 03 82 38  |.+..J.9..w.....8|
-000002b0  e5 c1 0f 11 17 47 a7 14  03 01 00 01 01 16 03 01  |.....G..........|
-000002c0  00 30 a6 68 28 50 75 6d  eb f4 32 c8 a3 57 3f b1  |.0.h(Pum..2..W?.|
-000002d0  37 84 8e 7e 1d 1d 93 7d  9f ec ff ac 1c 8d bf 30  |7..~...}.......0|
-000002e0  d2 b0 0f 3f 02 c3 ef ac  a3 62 94 26 1c 8f 7e 8d  |...?.....b.&..~.|
-000002f0  74 99                                             |t.|
+00000230  86 0f 00 00 82 00 80 05  7e 70 eb cb ef e3 d9 6f  |........~p.....o|
+00000240  59 29 b5 da f2 07 f5 42  62 4e 74 9b cf 00 e1 5c  |Y).....BbNt....\|
+00000250  69 a5 67 3a b0 b2 ca f2  10 ed 1c b4 81 5d 7d 9e  |i.g:.........]}.|
+00000260  1a 45 69 42 13 c5 b0 86  dc 3d 60 e5 cf fd ae 0f  |.EiB.....=`.....|
+00000270  17 bb 4a ed d7 06 eb f1  6d 47 98 b7 e8 87 eb 3c  |..J.....mG.....<|
+00000280  12 55 2c 06 de 55 48 c7  59 85 cb 62 d6 e7 1d 05  |.U,..UH.Y..b....|
+00000290  1e 6d 69 84 cd 16 8e dd  ed 5b 5a 2f f2 97 b7 78  |.mi......[Z/...x|
+000002a0  93 c1 fb 75 26 c8 b5 58  43 17 c7 52 54 20 4f 7d  |...u&..XC..RT O}|
+000002b0  7c 46 89 65 fe 51 29 14  03 01 00 01 01 16 03 01  ||F.e.Q).........|
+000002c0  00 30 d9 59 e6 7e c0 a6  2a af 36 0c 2e cf 0f 42  |.0.Y.~..*.6....B|
+000002d0  54 d4 41 c6 3c f8 84 d9  2a a6 82 94 22 2d ac ae  |T.A.<...*..."-..|
+000002e0  d9 f7 68 22 f6 f0 2e 56  c1 97 80 73 0d b3 f0 70  |..h"...V...s...p|
+000002f0  49 78                                             |Ix|
 >>> Flow 4 (server to client)
-00000000  14 03 01 00 01 01 16 03  01 00 30 80 3e 0d 50 13  |..........0.>.P.|
-00000010  5f 00 ba 2e 47 46 5d 63  1b 72 a8 02 24 1c 3e 1f  |_...GF]c.r..$.>.|
-00000020  ed e2 3a 45 d7 7d 3a f2  33 97 c3 ab 13 9b 0e 4a  |..:E.}:.3......J|
-00000030  04 f0 08 48 ab d3 46 0b  40 7d 5c                 |...H..F.@}\|
+00000000  14 03 01 00 01 01 16 03  01 00 30 06 19 79 49 41  |..........0..yIA|
+00000010  f9 9c 75 84 73 95 96 bd  1e 25 56 a9 49 ed 8e 38  |..u.s....%V.I..8|
+00000020  34 40 60 dc f0 2d f3 6c  cf 5b 80 84 2b 81 db 5f  |4@`..-.l.[..+.._|
+00000030  f4 27 03 ad b8 8d 80 0c  99 69 6f                 |.'.......io|
 >>> Flow 5 (client to server)
-00000000  17 03 01 00 20 f7 32 e7  36 4f 77 2f 4a 05 fd 27  |.... .2.6Ow/J..'|
-00000010  19 57 52 f7 8a 0c 7f fb  14 78 b2 06 bf ca 86 73  |.WR......x.....s|
-00000020  32 13 33 04 91 17 03 01  00 20 7e e4 fe c5 6d f7  |2.3...... ~...m.|
-00000030  d4 69 30 57 89 a0 76 70  40 a7 b5 17 74 2f 5d 16  |.i0W..vp@...t/].|
-00000040  c1 19 30 73 f8 37 c4 10  5b b7 15 03 01 00 20 08  |..0s.7..[..... .|
-00000050  41 5e 0b 9f 36 23 bd 9a  09 f7 58 9d a3 d7 26 3a  |A^..6#....X...&:|
-00000060  f4 5e 6b bf 9c d4 6f 0c  d3 9e cd de cb 95 57     |.^k...o.......W|
+00000000  17 03 01 00 20 20 67 bd  ff 84 9b 0e 58 f3 45 1e  |....  g.....X.E.|
+00000010  7a 25 d5 ae f0 26 4b 42  c7 f3 a5 77 7b 2f 42 21  |z%...&KB...w{/B!|
+00000020  2e c6 c9 81 23 17 03 01  00 20 69 1c 2a b9 05 16  |....#.... i.*...|
+00000030  8b 71 3a c2 18 76 bd 25  1f de 83 e9 14 e2 a3 5c  |.q:..v.%.......\|
+00000040  9b 33 ee 14 39 da e2 e7  a3 a7 15 03 01 00 20 e9  |.3..9......... .|
+00000050  dc 16 0c 13 56 7a e5 fd  ce b9 4f d1 c7 20 3f ca  |....Vz....O.. ?.|
+00000060  72 20 15 f7 11 81 fe 88  ab 90 4c dc 0b a5 11     |r ........L....|
diff --git a/src/crypto/tls/testdata/Client-TLSv10-ClientCert-RSA-RSA b/src/crypto/tls/testdata/Client-TLSv10-ClientCert-RSA-RSA
index c46a9670e8..980f93328f 100644
--- a/src/crypto/tls/testdata/Client-TLSv10-ClientCert-RSA-RSA
+++ b/src/crypto/tls/testdata/Client-TLSv10-ClientCert-RSA-RSA
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 01 00 59 02 00 00  55 03 01 97 fe 7f 92 37  |....Y...U......7|
-00000010  67 99 e0 d8 62 a9 31 80  bd 1f 31 8e 7d 0b 08 0a  |g...b.1...1.}...|
-00000020  de a5 82 a2 f2 d0 c1 35  66 34 6e 20 39 46 b1 b0  |.......5f4n 9F..|
-00000030  6e 2d 0e fe 8c 48 ea ab  1c c4 49 ee f4 21 cf cb  |n-...H....I..!..|
-00000040  2a 20 57 78 18 99 a1 b9  7f 88 4f 64 c0 13 00 00  |* Wx......Od....|
+00000000  16 03 01 00 59 02 00 00  55 03 01 4d 6d 71 59 6b  |....Y...U..MmqYk|
+00000010  cd 8c 6e b0 11 bf 4a 9e  25 90 12 cc ac b4 3f be  |..n...J.%.....?.|
+00000020  86 1b 13 47 a6 be 3d a0  8f 0b 77 20 6b b5 57 6d  |...G..=...w k.Wm|
+00000030  39 74 b0 9d b4 ae 2e 72  7e 90 d2 ab ed 32 fa 65  |9t.....r~....2.e|
+00000040  ed 85 63 d2 16 ef 47 af  a6 37 17 88 c0 13 00 00  |..c...G..7......|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  01 02 59 0b 00 02 55 00  02 52 00 02 4f 30 82 02  |..Y...U..R..O0..|
 00000070  4b 30 82 01 b4 a0 03 02  01 02 02 09 00 e8 f0 9d  |K0..............|
@@ -60,17 +60,17 @@
 00000290  77 8d 0c 1c f1 0f a1 d8  40 83 61 c9 4c 72 2b 9d  |w.......@.a.Lr+.|
 000002a0  ae db 46 06 06 4d f4 c1  b3 3e c0 d1 bd 42 d4 db  |..F..M...>...B..|
 000002b0  fe 3d 13 60 84 5c 21 d3  3b e9 fa e7 16 03 01 00  |.=.`.\!.;.......|
-000002c0  aa 0c 00 00 a6 03 00 1d  20 07 80 79 40 4b b1 0e  |........ ..y@K..|
-000002d0  05 ce e4 ca 9d f5 d7 ad  a6 98 f2 40 f9 b9 66 a8  |...........@..f.|
-000002e0  04 6e ae b5 da 99 67 09  69 00 80 01 4a f2 c1 c9  |.n....g.i...J...|
-000002f0  2f 46 4f b8 9e 8b 2c c4  a1 32 44 3c dc 2c 5e b9  |/FO...,..2D<.,^.|
-00000300  76 5f 41 20 23 1b 82 dd  ec 37 b4 24 68 6d a7 39  |v_A #....7.$hm.9|
-00000310  4f f2 e5 97 09 75 64 2a  64 16 b8 99 04 8a 74 77  |O....ud*d.....tw|
-00000320  19 bb 12 5f 27 f6 41 09  f7 2e 1c 33 80 3b 01 57  |..._'.A....3.;.W|
-00000330  5c f9 20 6e 0c 48 76 59  e1 8b 1f bb 2a 33 1a 28  |\. n.HvY....*3.(|
-00000340  a0 5a 05 44 94 eb 35 62  5e ae 7f e4 01 76 b6 b4  |.Z.D..5b^....v..|
-00000350  64 91 bf 25 09 ff 88 8a  af 73 00 d0 7e ea 0f ca  |d..%.....s..~...|
-00000360  4a 2b d4 6f 02 26 98 28  5a ed 11 16 03 01 00 0a  |J+.o.&.(Z.......|
+000002c0  aa 0c 00 00 a6 03 00 1d  20 96 0b 2f 57 e1 1e 07  |........ ../W...|
+000002d0  e0 7f a4 91 67 97 d0 a0  19 d3 9a b2 49 79 f9 5f  |....g.......Iy._|
+000002e0  7f b5 65 d4 3a 89 92 8f  11 00 80 08 29 72 0b f7  |..e.:.......)r..|
+000002f0  7b 68 38 5e 47 15 89 f1  ee be f3 a9 26 a4 9c 6d  |{h8^G.......&..m|
+00000300  2c 2a ff f0 d6 2d 25 a5  b0 93 66 7d 8c fb fe a5  |,*...-%...f}....|
+00000310  3b cc b6 71 f4 1b 55 c4  ef 08 73 b1 49 47 2c e6  |;..q..U...s.IG,.|
+00000320  a1 ef 53 ca bb 15 e3 25  ea e7 48 44 18 88 e1 d2  |..S....%..HD....|
+00000330  3b e9 f6 92 61 5e 5c 06  44 83 37 6c e6 b6 26 32  |;...a^\.D.7l..&2|
+00000340  fd d6 00 fc 87 a2 37 e3  84 d2 ad 2d 99 0d e1 ba  |......7....-....|
+00000350  bb 2f 3b 0b dd 56 5c c2  14 af 86 58 2c 8b f8 64  |./;..V\....X,..d|
+00000360  75 ab d3 35 41 59 fa fe  a5 48 26 16 03 01 00 0a  |u..5AY...H&.....|
 00000370  0d 00 00 06 03 01 02 40  00 00 16 03 01 00 04 0e  |.......@........|
 00000380  00 00 00                                          |...|
 >>> Flow 3 (client to server)
@@ -109,29 +109,29 @@
 00000200  e5 35 16 03 01 00 25 10  00 00 21 20 2f e5 7d a3  |.5....%...! /.}.|
 00000210  47 cd 62 43 15 28 da ac  5f bb 29 07 30 ff f6 84  |G.bC.(.._.).0...|
 00000220  af c4 cf c2 ed 90 99 5f  58 cb 3b 74 16 03 01 00  |......._X.;t....|
-00000230  86 0f 00 00 82 00 80 81  aa 68 1f a9 a4 de f1 4d  |.........h.....M|
-00000240  30 9a fe e6 a5 f6 f6 18  b6 3e d2 c7 f1 e6 77 e3  |0........>....w.|
-00000250  6a cd 61 01 81 3a 02 31  a5 aa d6 db b6 02 9d 4b  |j.a..:.1.......K|
-00000260  f5 78 50 c3 95 fe 43 88  33 3a 95 32 bc e8 02 1a  |.xP...C.3:.2....|
-00000270  e6 f4 d5 54 b9 fc e0 4a  4e f0 92 21 35 4b de c8  |...T...JN..!5K..|
-00000280  a4 b0 01 c3 ca 3a 87 ed  cb 21 1c ce c2 14 7b 8d  |.....:...!....{.|
-00000290  90 68 b9 21 49 13 dd cd  e7 68 83 41 7c 84 6a 75  |.h.!I....h.A|.ju|
-000002a0  76 ee 19 8b fa d5 a6 57  3d a7 f1 f1 6f 11 ca 77  |v......W=...o..w|
-000002b0  95 0e b5 c7 3d 99 d4 14  03 01 00 01 01 16 03 01  |....=...........|
-000002c0  00 30 5e be 40 82 f8 db  05 20 23 45 a4 42 48 e8  |.0^.@.... #E.BH.|
-000002d0  06 69 eb 4c ef 79 53 52  4a 5a 3a ba cc d6 99 59  |.i.L.ySRJZ:....Y|
-000002e0  4d c2 b0 34 0f 14 68 03  93 8b a4 95 7e cf 26 f8  |M..4..h.....~.&.|
-000002f0  5c 8a                                             |\.|
+00000230  86 0f 00 00 82 00 80 8f  5d a5 27 13 09 5e 49 5f  |........].'..^I_|
+00000240  ff fd d6 88 75 83 cc 74  f3 e1 af 44 76 6a 35 16  |....u..t...Dvj5.|
+00000250  e8 36 5f b7 dc 21 69 77  61 12 c5 69 f7 0d 98 1f  |.6_..!iwa..i....|
+00000260  d5 15 f1 e8 88 c5 30 e8  b5 c3 2a e5 26 93 cc a4  |......0...*.&...|
+00000270  eb 31 c6 d7 f5 f4 7c d5  f7 a2 3f 1f 75 cd b2 b2  |.1....|...?.u...|
+00000280  82 3a 03 8c 5e 15 0a d2  98 b8 65 cb 5f d5 db d0  |.:..^.....e._...|
+00000290  b6 36 8c 89 7e 48 fa 3a  9f 9a bd c1 48 e7 d6 20  |.6..~H.:....H.. |
+000002a0  ef 45 5b 24 32 04 58 82  b3 7b 42 fd fe ba 78 32  |.E[$2.X..{B...x2|
+000002b0  2a f5 b7 81 33 da db 14  03 01 00 01 01 16 03 01  |*...3...........|
+000002c0  00 30 5f 96 98 94 17 6d  ff 84 72 d3 63 fd 14 59  |.0_....m..r.c..Y|
+000002d0  eb bf 5f 3e 8f dc f1 c1  dc 77 8a 33 f6 2e a2 4a  |.._>.....w.3...J|
+000002e0  15 d1 2e a4 ec 0d 3c 0b  18 07 09 6c 0d 09 34 2e  |......<....l..4.|
+000002f0  a4 6f                                             |.o|
 >>> Flow 4 (server to client)
-00000000  14 03 01 00 01 01 16 03  01 00 30 ef 9b 5c da 0a  |..........0..\..|
-00000010  2e c4 79 fa ea 8a 9c 78  4a 1f 08 77 56 73 6e fa  |..y....xJ..wVsn.|
-00000020  3a 5b 3c cd cd e9 0c a8  bb 59 9e 22 ab 67 2c 03  |:[<......Y.".g,.|
-00000030  de ad 7c e4 cb 85 d7 8f  c1 1c e3                 |..|........|
+00000000  14 03 01 00 01 01 16 03  01 00 30 b7 4a 5c 0c e6  |..........0.J\..|
+00000010  7c d9 43 7c e7 b4 2f d7  b5 c6 5e 36 c7 87 dd 82  ||.C|../...^6....|
+00000020  da d3 b2 4e 05 ae f5 8c  b0 4d db c2 53 62 55 73  |...N.....M..SbUs|
+00000030  8c 2a 1b d5 df e4 7c a4  cf db 8b                 |.*....|....|
 >>> Flow 5 (client to server)
-00000000  17 03 01 00 20 48 1a 1a  1c 6c 7d 6c 2a e0 b2 e3  |.... H...l}l*...|
-00000010  b3 9f ec 39 a8 cd 9a f9  a2 3e 2d 46 3b cf 17 ed  |...9.....>-F;...|
-00000020  70 99 ce d7 3c 17 03 01  00 20 69 27 e9 89 78 e6  |p...<.... i'..x.|
-00000030  64 c0 a9 40 4f 0d 97 53  b2 2e 15 f3 2b 54 3b 77  |d..@O..S....+T;w|
-00000040  f2 24 2c 94 dc b3 8b f0  c4 ce 15 03 01 00 20 1b  |.$,........... .|
-00000050  50 55 83 d8 6b b4 04 b2  f0 2d 1c 9c 0d fa de 58  |PU..k....-.....X|
-00000060  cd 0a 1d 55 d6 36 f4 a4  fb cc 55 c5 b1 f3 d3     |...U.6....U....|
+00000000  17 03 01 00 20 b9 26 60  87 38 9c d9 c4 65 17 8e  |.... .&`.8...e..|
+00000010  3c 7f 1a b4 23 cd 27 fd  4e 92 ee 0e f2 11 dc e2  |<...#.'.N.......|
+00000020  23 e4 26 f3 55 17 03 01  00 20 5e 89 33 21 f0 dc  |#.&.U.... ^.3!..|
+00000030  e8 4f 33 1c 66 56 99 38  a5 4c 0e 0e 93 41 b7 48  |.O3.fV.8.L...A.H|
+00000040  5d ce 49 d0 d2 8a 56 a6  2d 68 15 03 01 00 20 05  |].I...V.-h.... .|
+00000050  e0 ed f9 c2 56 ec 64 e5  e7 0b f4 8a e2 41 96 9e  |....V.d......A..|
+00000060  ed 94 c8 95 69 d7 ce 2d  0e bb 5b 18 5f 30 52     |....i..-..[._0R|
diff --git a/src/crypto/tls/testdata/Client-TLSv10-ECDHE-ECDSA-AES b/src/crypto/tls/testdata/Client-TLSv10-ECDHE-ECDSA-AES
index 7d6683c026..6fc506f099 100644
--- a/src/crypto/tls/testdata/Client-TLSv10-ECDHE-ECDSA-AES
+++ b/src/crypto/tls/testdata/Client-TLSv10-ECDHE-ECDSA-AES
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 01 00 59 02 00 00  55 03 01 a7 ea 63 8c 7d  |....Y...U....c.}|
-00000010  54 70 04 d5 5e a2 2e 8b  75 4f 17 c8 a8 8c 3d bc  |Tp..^...uO....=.|
-00000020  08 aa 82 48 85 ed 1a ff  42 e1 54 20 3b 77 9d 32  |...H....B.T ;w.2|
-00000030  4d 60 f2 81 f8 20 aa d2  b0 eb ea 7c 6a 39 52 20  |M`... .....|j9R |
-00000040  94 4a 2a 88 05 8a fe 6c  50 5c 95 39 c0 09 00 00  |.J*....lP\.9....|
+00000000  16 03 01 00 59 02 00 00  55 03 01 a3 4e 79 27 af  |....Y...U...Ny'.|
+00000010  c8 a3 15 a4 c2 7a 54 58  54 0e 0d 93 c2 ff e1 f9  |.....zTXT.......|
+00000020  55 ab 2c ea 32 cf d2 47  2e d7 8e 20 49 08 d1 66  |U.,.2..G... I..f|
+00000030  9b 9e aa af c9 90 95 ec  cb 64 2e 3d f6 27 d5 f6  |.........d.=.'..|
+00000040  23 10 d5 6e 50 5f bc 89  fe c7 d7 de c0 09 00 00  |#..nP_..........|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  01 02 0e 0b 00 02 0a 00  02 07 00 02 04 30 82 02  |.............0..|
 00000070  00 30 82 01 62 02 09 00  b8 bf 2d 47 a0 d2 eb f4  |.0..b.....-G....|
@@ -55,37 +55,37 @@
 00000240  13 83 0d 94 06 bb d4 37  7a f6 ec 7a c9 86 2e dd  |.......7z..z....|
 00000250  d7 11 69 7f 85 7c 56 de  fb 31 78 2b e4 c7 78 0d  |..i..|V..1x+..x.|
 00000260  ae cb be 9e 4e 36 24 31  7b 6a 0f 39 95 12 07 8f  |....N6$1{j.9....|
-00000270  2a 16 03 01 00 b5 0c 00  00 b1 03 00 1d 20 3a 1f  |*............ :.|
-00000280  18 e9 f2 09 3e 79 4b a0  62 73 ef 87 0d ea 90 51  |....>yK.bs.....Q|
-00000290  7f 9d d2 79 59 e4 11 7f  69 f7 a9 d7 78 7f 00 8b  |...yY...i...x...|
-000002a0  30 81 88 02 42 01 65 ac  eb e6 b0 86 73 95 a4 27  |0...B.e.....s..'|
-000002b0  e3 82 55 cf 88 16 80 c2  68 4b 39 77 2a b1 a9 d3  |..U.....hK9w*...|
-000002c0  08 d5 ac 77 ce 5b 16 73  2c ad b5 57 2a 7a 75 34  |...w.[.s,..W*zu4|
-000002d0  ec 99 23 bd df b2 27 36  5a 4b 40 e0 d3 b0 d2 31  |..#...'6ZK@....1|
-000002e0  9b c7 9e 0a cb 5b 69 02  42 00 88 d7 5a 6a 9e 4c  |.....[i.B...Zj.L|
-000002f0  c5 7b 2c 8e 93 3b 75 27  b4 00 11 88 ba cf 99 8c  |.{,..;u'........|
-00000300  e5 f2 60 22 de f2 fe 86  a6 48 86 9c 40 31 08 75  |..`".....H..@1.u|
-00000310  aa bc 5d 6d fa 2e a4 a9  a1 0d fc e1 d9 5a a1 60  |..]m.........Z.`|
-00000320  93 b9 69 c7 c2 3e f5 a9  cb 31 41 16 03 01 00 04  |..i..>...1A.....|
+00000270  2a 16 03 01 00 b5 0c 00  00 b1 03 00 1d 20 4a 7c  |*............ J||
+00000280  0a 86 8a 81 f2 60 4a 3c  ac d7 7d 3b fc 00 a5 b4  |.....`J<..};....|
+00000290  85 45 45 45 fb 09 53 d7  4a cf 24 9d c8 1a 00 8b  |.EEE..S.J.$.....|
+000002a0  30 81 88 02 42 01 7a c9  c0 76 8c 26 98 63 4e a3  |0...B.z..v.&.cN.|
+000002b0  ad 4f 4e a3 d7 c7 d6 4a  69 28 cf d2 7b 0b 36 fb  |.ON....Ji(..{.6.|
+000002c0  a3 ae 2f e1 83 ea ea 4a  b7 2d ef a8 2d 13 96 e4  |../....J.-..-...|
+000002d0  73 83 66 70 5e 5c d9 5a  d1 1c d1 33 18 0b b3 30  |s.fp^\.Z...3...0|
+000002e0  2a 21 d7 78 d8 70 18 02  42 00 c4 ab 80 33 8f f1  |*!.x.p..B....3..|
+000002f0  c2 74 1b 58 2f 59 d4 27  a1 19 42 bf 14 ea a8 a2  |.t.X/Y.'..B.....|
+00000300  cb bf 96 2d 60 7b 84 40  cc 31 f5 c4 e8 51 87 b8  |...-`{.@.1...Q..|
+00000310  7b 47 ec c4 c0 4a 9b 09  59 1e f8 b5 9a e1 45 a4  |{G...J..Y.....E.|
+00000320  a1 9b ee 78 55 f8 f5 fa  1a fb c5 16 03 01 00 04  |...xU...........|
 00000330  0e 00 00 00                                       |....|
 >>> Flow 3 (client to server)
 00000000  16 03 01 00 25 10 00 00  21 20 2f e5 7d a3 47 cd  |....%...! /.}.G.|
 00000010  62 43 15 28 da ac 5f bb  29 07 30 ff f6 84 af c4  |bC.(.._.).0.....|
 00000020  cf c2 ed 90 99 5f 58 cb  3b 74 14 03 01 00 01 01  |....._X.;t......|
-00000030  16 03 01 00 30 30 25 15  82 a1 7f 11 32 13 52 17  |....00%.....2.R.|
-00000040  b8 bd 5b b9 1e 69 88 0b  b3 5f 12 40 e3 4b 03 cb  |..[..i..._.@.K..|
-00000050  cd 07 3c 43 4f ab f7 5d  2c 6a a3 02 a9 64 d0 77  |..<CO..],j...d.w|
-00000060  27 dc 4a ae 8a                                    |'.J..|
+00000030  16 03 01 00 30 b0 5e 4a  8a 07 e3 86 43 05 16 68  |....0.^J....C..h|
+00000040  0e d1 58 a6 05 49 e9 a6  42 89 2c 3f 33 68 8b 26  |..X..I..B.,?3h.&|
+00000050  23 21 3b 62 ab 7a 21 74  d8 49 15 03 b3 1e c6 53  |#!;b.z!t.I.....S|
+00000060  74 1e 1c 4e 0f                                    |t..N.|
 >>> Flow 4 (server to client)
-00000000  14 03 01 00 01 01 16 03  01 00 30 b5 3e 18 97 a1  |..........0.>...|
-00000010  ca 2e 7f 5f b9 72 cb aa  d4 f6 85 86 d3 27 40 13  |..._.r.......'@.|
-00000020  e3 99 35 13 67 a8 9e 6e  bb 63 15 97 96 42 e4 b3  |..5.g..n.c...B..|
-00000030  fc 15 ee b7 d8 cb a2 64  3d 55 b8                 |.......d=U.|
+00000000  14 03 01 00 01 01 16 03  01 00 30 64 4b 3c 1a e3  |..........0dK<..|
+00000010  7d bb bb bb 64 d8 51 c3  eb 92 65 65 58 35 dd 7b  |}...d.Q...eeX5.{|
+00000020  d2 fd f0 0c c1 10 71 a5  a8 f7 14 84 69 b4 81 18  |......q.....i...|
+00000030  1e 0d d3 19 b6 23 72 1a  a7 43 0e                 |.....#r..C.|
 >>> Flow 5 (client to server)
-00000000  17 03 01 00 20 12 6c bf  f2 39 2d e6 ad a8 38 d5  |.... .l..9-...8.|
-00000010  1c ea 5b 79 e5 c7 4a 41  eb 58 70 f0 7d f7 60 e7  |..[y..JA.Xp.}.`.|
-00000020  ee 77 98 75 f2 17 03 01  00 20 ac 5e 6d b0 81 0b  |.w.u..... .^m...|
-00000030  14 ca c2 70 53 d8 6d 55  49 63 da 8a 61 66 80 2d  |...pS.mUIc..af.-|
-00000040  e4 7c 2e 60 1f eb 3c f2  27 66 15 03 01 00 20 7a  |.|.`..<.'f.... z|
-00000050  2b 80 f8 00 0f 06 f5 6e  fe b7 b7 6b 12 6c 8d 8e  |+......n...k.l..|
-00000060  c4 11 23 2b a2 bb 16 93  b4 e0 e0 fd 8c 42 db     |..#+.........B.|
+00000000  17 03 01 00 20 c3 e6 70  2c 44 4f 04 0c fb 0b 7f  |.... ..p,DO.....|
+00000010  1d 2c ef 4d cc c3 21 ba  a2 db 74 76 46 ea 00 40  |.,.M..!...tvF..@|
+00000020  54 2d 4a fe 59 17 03 01  00 20 0c 6b 39 0d b5 f3  |T-J.Y.... .k9...|
+00000030  ed 7e d0 de 01 18 0c 32  4e 59 93 46 d3 c5 4f c0  |.~.....2NY.F..O.|
+00000040  f5 fd f1 d2 79 07 7d 07  b0 24 15 03 01 00 20 1d  |....y.}..$.... .|
+00000050  f7 53 a2 e7 3f 88 87 35  01 6e a5 b1 d6 81 37 5b  |.S..?..5.n....7[|
+00000060  a7 64 4c 29 f4 71 59 a1  36 c1 1a 24 93 31 7d     |.dL).qY.6..$.1}|
diff --git a/src/crypto/tls/testdata/Client-TLSv10-ECDHE-RSA-AES b/src/crypto/tls/testdata/Client-TLSv10-ECDHE-RSA-AES
index c0e842d155..24da556b25 100644
--- a/src/crypto/tls/testdata/Client-TLSv10-ECDHE-RSA-AES
+++ b/src/crypto/tls/testdata/Client-TLSv10-ECDHE-RSA-AES
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 01 00 59 02 00 00  55 03 01 16 f4 24 01 94  |....Y...U....$..|
-00000010  68 d2 0f 15 4d d6 65 54  84 73 ab 2c b2 11 c5 64  |h...M.eT.s.,...d|
-00000020  d8 93 66 50 cd b0 f0 ab  11 5c 72 20 b1 13 c1 f5  |..fP.....\r ....|
-00000030  63 ed 70 0b 21 52 85 36  84 99 1d b6 bb dc d3 1c  |c.p.!R.6........|
-00000040  b3 76 13 d9 ef 47 c4 c0  18 57 23 3b c0 13 00 00  |.v...G...W#;....|
+00000000  16 03 01 00 59 02 00 00  55 03 01 63 68 ea 52 0b  |....Y...U..ch.R.|
+00000010  dc 68 c7 d0 75 3e 7d 6f  0b 8c cb 25 48 b0 bb df  |.h..u>}o...%H...|
+00000020  7a 56 93 a9 d5 4f 0c 3a  e2 37 ab 20 1f 0f a4 d3  |zV...O.:.7. ....|
+00000030  b4 f6 66 6f 39 6f 62 fb  6a 1f 41 09 4b 02 5c 15  |..fo9ob.j.A.K.\.|
+00000040  a0 ba cb a6 f9 bd 3b ec  cb 76 6e ea c0 13 00 00  |......;..vn.....|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  01 02 59 0b 00 02 55 00  02 52 00 02 4f 30 82 02  |..Y...U..R..O0..|
 00000070  4b 30 82 01 b4 a0 03 02  01 02 02 09 00 e8 f0 9d  |K0..............|
@@ -60,36 +60,36 @@
 00000290  77 8d 0c 1c f1 0f a1 d8  40 83 61 c9 4c 72 2b 9d  |w.......@.a.Lr+.|
 000002a0  ae db 46 06 06 4d f4 c1  b3 3e c0 d1 bd 42 d4 db  |..F..M...>...B..|
 000002b0  fe 3d 13 60 84 5c 21 d3  3b e9 fa e7 16 03 01 00  |.=.`.\!.;.......|
-000002c0  aa 0c 00 00 a6 03 00 1d  20 7e aa 30 94 7b fb 09  |........ ~.0.{..|
-000002d0  b5 55 ce b3 e9 e0 5b 55  82 f4 e6 7c d0 e4 57 eb  |.U....[U...|..W.|
-000002e0  9b ec 82 48 d6 0e 2a bb  16 00 80 80 da c5 75 4f  |...H..*.......uO|
-000002f0  82 95 ee 47 28 af 09 08  d5 13 68 33 5d 91 dd 13  |...G(.....h3]...|
-00000300  43 84 e9 54 d9 e7 39 7c  38 74 d5 92 8f 46 37 86  |C..T..9|8t...F7.|
-00000310  44 68 ae c7 3a ad e1 33  5f cd d8 c6 a5 7c 5e 83  |Dh..:..3_....|^.|
-00000320  44 ba b1 09 44 ec 42 7f  41 80 d6 b6 4c 6d ae 24  |D...D.B.A...Lm.$|
-00000330  a9 3b 53 87 2f 3b 3a 1f  da 87 2b 7d cf 9e ed a5  |.;S./;:...+}....|
-00000340  04 54 ad c2 3c 7b 21 60  55 67 41 47 60 02 1e 62  |.T..<{!`UgAG`..b|
-00000350  bb 9f ee 2c 6e 79 20 6e  65 e2 d0 ae 73 70 3e a7  |...,ny ne...sp>.|
-00000360  3f 74 96 8e 2a 6e a6 7e  7a e0 e4 16 03 01 00 04  |?t..*n.~z.......|
+000002c0  aa 0c 00 00 a6 03 00 1d  20 04 9f 8b 4f 13 83 26  |........ ...O..&|
+000002d0  a3 cf 08 6e 59 bf b5 49  b8 ff 95 94 21 8d 2a 56  |...nY..I....!.*V|
+000002e0  2e 4b be ad ac 89 6e 52  4d 00 80 5f 63 93 43 a2  |.K....nRM.._c.C.|
+000002f0  a6 fb 53 b0 ac 93 3f 55  1d c1 0f 71 1e 96 ba 9f  |..S...?U...q....|
+00000300  86 19 f3 83 7d 90 ce 06  24 9a 60 69 f0 35 24 5d  |....}...$.`i.5$]|
+00000310  9d ce 49 0d 6f ba 31 59  3c f2 64 27 66 76 0e f1  |..I.o.1Y<.d'fv..|
+00000320  33 eb b8 70 61 d3 0c 93  a3 62 c7 5e c2 06 9d 48  |3..pa....b.^...H|
+00000330  16 2e a6 62 50 18 f6 c0  79 c2 09 f3 d5 74 bf db  |...bP...y....t..|
+00000340  b8 d4 25 06 a7 be 4a b0  62 82 86 d0 00 86 5e a2  |..%...J.b.....^.|
+00000350  34 49 9b 37 37 9a b6 eb  cc b9 8b 17 1f 29 4b a3  |4I.77........)K.|
+00000360  51 e3 c3 e8 3e 6e df c4  1d e5 48 16 03 01 00 04  |Q...>n....H.....|
 00000370  0e 00 00 00                                       |....|
 >>> Flow 3 (client to server)
 00000000  16 03 01 00 25 10 00 00  21 20 2f e5 7d a3 47 cd  |....%...! /.}.G.|
 00000010  62 43 15 28 da ac 5f bb  29 07 30 ff f6 84 af c4  |bC.(.._.).0.....|
 00000020  cf c2 ed 90 99 5f 58 cb  3b 74 14 03 01 00 01 01  |....._X.;t......|
-00000030  16 03 01 00 30 5a cb 36  c8 1c 43 a8 e1 88 db c9  |....0Z.6..C.....|
-00000040  ae 78 b0 af 97 e4 c3 f6  25 51 8e 4d 57 94 ee ca  |.x......%Q.MW...|
-00000050  a4 8b 3f 4d 17 75 34 58  c3 fa a6 6f d4 e5 ae 3a  |..?M.u4X...o...:|
-00000060  cb 5a cb 11 ef                                    |.Z...|
+00000030  16 03 01 00 30 a6 3a 66  02 e6 09 6a dd 68 56 bc  |....0.:f...j.hV.|
+00000040  aa ec 82 c4 69 9b b9 45  44 ec e2 c2 5b 49 5d 9b  |....i..ED...[I].|
+00000050  f8 0e 81 1e 23 9e 13 72  d1 d2 0c 24 01 4f 35 aa  |....#..r...$.O5.|
+00000060  27 fc b3 cc 08                                    |'....|
 >>> Flow 4 (server to client)
-00000000  14 03 01 00 01 01 16 03  01 00 30 96 92 50 6f f0  |..........0..Po.|
-00000010  d1 ff 7c 39 fb 75 0c 8b  c9 d7 29 7d 9d 32 4c 19  |..|9.u....)}.2L.|
-00000020  2e 93 ea 11 87 07 fc 5a  7d 3c 30 e1 bd 64 7f 90  |.......Z}<0..d..|
-00000030  fd 70 1d 50 eb ec f2 d6  de 09 61                 |.p.P......a|
+00000000  14 03 01 00 01 01 16 03  01 00 30 0e 25 d7 a9 c0  |..........0.%...|
+00000010  18 3b bf 55 c0 47 3a 95  2d cb 6f c2 2c de e3 94  |.;.U.G:.-.o.,...|
+00000020  32 d3 eb e2 b6 6b 5f 42  9c 1e 47 d6 76 0c eb 95  |2....k_B..G.v...|
+00000030  fd 2d c3 9a ee ee 83 87  e8 8d 83                 |.-.........|
 >>> Flow 5 (client to server)
-00000000  17 03 01 00 20 fd a4 ba  f1 78 a9 a2 45 d3 d2 5a  |.... ....x..E..Z|
-00000010  1e 41 6b 89 8d bd a4 21  69 03 a1 7c b8 56 ff df  |.Ak....!i..|.V..|
-00000020  67 bc 85 5e 21 17 03 01  00 20 a7 6d 4c 11 d0 f3  |g..^!.... .mL...|
-00000030  7d e2 f0 69 18 7c 42 71  78 e4 3b 71 7d 13 27 bb  |}..i.|Bqx.;q}.'.|
-00000040  79 fd d7 b2 d7 28 ca 92  83 f1 15 03 01 00 20 10  |y....(........ .|
-00000050  b3 79 d4 1d 70 db b7 6c  f2 15 05 3c 4d 65 ba ec  |.y..p..l...<Me..|
-00000060  e8 0e 6a ba 88 90 53 2e  6e 29 9c 56 9f 52 5e     |..j...S.n).V.R^|
+00000000  17 03 01 00 20 ba b0 c4  22 ee 52 81 ca 55 97 4d  |.... ...".R..U.M|
+00000010  39 16 b9 37 bf df 7b d1  ae 4b 47 ac 10 12 a9 77  |9..7..{..KG....w|
+00000020  69 50 f3 60 13 17 03 01  00 20 90 d5 17 e4 96 38  |iP.`..... .....8|
+00000030  cd f7 30 6e 19 45 4e 32  ad 5f 1b 00 bf 22 9d c2  |..0n.EN2._..."..|
+00000040  16 30 fe 92 c7 fc 91 38  29 30 15 03 01 00 20 c0  |.0.....8)0.... .|
+00000050  02 ff 81 82 c9 25 c6 b0  06 ee 18 61 19 c8 d2 20  |.....%.....a... |
+00000060  d8 4e 7b a4 a5 57 17 64  4d ad 1e 1e 16 1e 52     |.N{..W.dM.....R|
diff --git a/src/crypto/tls/testdata/Client-TLSv10-ExportKeyingMaterial b/src/crypto/tls/testdata/Client-TLSv10-ExportKeyingMaterial
index 1c65914281..6a40d83279 100644
--- a/src/crypto/tls/testdata/Client-TLSv10-ExportKeyingMaterial
+++ b/src/crypto/tls/testdata/Client-TLSv10-ExportKeyingMaterial
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 01 00 59 02 00 00  55 03 01 7a a4 22 4f 19  |....Y...U..z."O.|
-00000010  54 37 47 cb e5 dd b4 54  86 9e 9e d6 3f f1 bd ca  |T7G....T....?...|
-00000020  9a 3e 16 3c 7e 1a 29 22  0d c8 95 20 ac 85 42 c1  |.>.<~.)"... ..B.|
-00000030  e7 f3 38 62 38 24 a8 24  d2 67 bd 0d 06 44 74 cf  |..8b8$.$.g...Dt.|
-00000040  3d a4 37 17 bc 8c 5d 41  9f 5a 74 69 c0 13 00 00  |=.7...]A.Zti....|
+00000000  16 03 01 00 59 02 00 00  55 03 01 05 31 9d 41 04  |....Y...U...1.A.|
+00000010  c0 d4 34 1a fc 0f 63 26  47 d6 13 7f a0 d8 aa bf  |..4...c&G.......|
+00000020  28 92 04 80 02 75 58 e6  01 e1 30 20 3c fc b0 02  |(....uX...0 <...|
+00000030  8b a4 9e 9e b2 5c 17 3c  48 0b 96 6f 15 80 d5 38  |.....\.<H..o...8|
+00000040  25 a2 f8 fb 6b fd 47 27  c2 53 6c 60 c0 13 00 00  |%...k.G'.Sl`....|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  01 02 59 0b 00 02 55 00  02 52 00 02 4f 30 82 02  |..Y...U..R..O0..|
 00000070  4b 30 82 01 b4 a0 03 02  01 02 02 09 00 e8 f0 9d  |K0..............|
@@ -60,36 +60,36 @@
 00000290  77 8d 0c 1c f1 0f a1 d8  40 83 61 c9 4c 72 2b 9d  |w.......@.a.Lr+.|
 000002a0  ae db 46 06 06 4d f4 c1  b3 3e c0 d1 bd 42 d4 db  |..F..M...>...B..|
 000002b0  fe 3d 13 60 84 5c 21 d3  3b e9 fa e7 16 03 01 00  |.=.`.\!.;.......|
-000002c0  aa 0c 00 00 a6 03 00 1d  20 71 52 12 72 a7 56 0b  |........ qR.r.V.|
-000002d0  51 81 af 9f e1 95 43 44  54 0e 9e 3d cc 6f 3c 4c  |Q.....CDT..=.o<L|
-000002e0  d7 9c e4 ae d5 ad 13 8b  28 00 80 46 29 b1 46 71  |........(..F).Fq|
-000002f0  ba 0a 3d be 29 0f 57 43  02 05 4e 49 a4 5b cd 39  |..=.).WC..NI.[.9|
-00000300  1c 44 6d 84 02 60 84 b6  7f ff 4e d8 0e e7 16 5a  |.Dm..`....N....Z|
-00000310  dd 3b 5a e0 e5 d0 b6 2c  fb 95 35 94 a0 b6 97 24  |.;Z....,..5....$|
-00000320  92 d7 b1 71 78 ee 15 6f  b2 47 fd c7 a6 a4 94 eb  |...qx..o.G......|
-00000330  44 61 9f 96 83 1d 89 a6  62 d9 9e 5b b2 3d 69 9d  |Da......b..[.=i.|
-00000340  59 c5 a4 4e e0 33 69 0c  56 6f 86 6c 6b e5 be c4  |Y..N.3i.Vo.lk...|
-00000350  ed e4 39 53 f3 fd ea 60  d2 b7 d9 5e 90 fd a3 3e  |..9S...`...^...>|
-00000360  cb 59 5d 81 da 58 07 83  e7 af 25 16 03 01 00 04  |.Y]..X....%.....|
+000002c0  aa 0c 00 00 a6 03 00 1d  20 a4 50 9a 0d c7 2a 1b  |........ .P...*.|
+000002d0  f6 d4 78 49 68 ac 5f 8b  e7 78 68 05 4b f8 c6 b3  |..xIh._..xh.K...|
+000002e0  eb 28 79 96 d5 e6 aa c1  54 00 80 22 66 ec fd 14  |.(y.....T.."f...|
+000002f0  83 7b 03 86 14 75 84 a4  a6 d0 ee d3 d0 f7 95 d8  |.{...u..........|
+00000300  43 48 a4 eb 83 af 96 ac  cf e8 65 20 05 c3 18 9a  |CH........e ....|
+00000310  54 63 f5 2f b7 17 06 e0  2a b3 65 6a 2f cc cd 93  |Tc./....*.ej/...|
+00000320  1e b3 5a 4d 09 da 70 b0  12 46 60 11 e4 9f ee 9f  |..ZM..p..F`.....|
+00000330  3b 6f ef df bc db 69 22  5e e8 4c 41 d6 b7 7b 06  |;o....i"^.LA..{.|
+00000340  b6 99 1c 6d 01 5a 61 7c  4e 3a af 3e 01 7e 46 bd  |...m.Za|N:.>.~F.|
+00000350  c8 15 28 ba 7f b3 d6 9d  95 74 04 36 6c 38 16 86  |..(......t.6l8..|
+00000360  d2 1d 8a 85 d1 21 5c 33  17 50 a1 16 03 01 00 04  |.....!\3.P......|
 00000370  0e 00 00 00                                       |....|
 >>> Flow 3 (client to server)
 00000000  16 03 01 00 25 10 00 00  21 20 2f e5 7d a3 47 cd  |....%...! /.}.G.|
 00000010  62 43 15 28 da ac 5f bb  29 07 30 ff f6 84 af c4  |bC.(.._.).0.....|
 00000020  cf c2 ed 90 99 5f 58 cb  3b 74 14 03 01 00 01 01  |....._X.;t......|
-00000030  16 03 01 00 30 c3 26 49  92 5a 8c d0 da 48 ba 60  |....0.&I.Z...H.`|
-00000040  29 c0 5c d5 44 04 11 7a  25 b5 d6 9f a4 cf fe bf  |).\.D..z%.......|
-00000050  33 a7 ba c2 96 2b 4d c1  fb dc 4c ba b8 2b 6f 20  |3....+M...L..+o |
-00000060  2d 2a 02 ee 17                                    |-*...|
+00000030  16 03 01 00 30 f0 15 ea  81 0f a6 22 0a cd a5 a1  |....0......"....|
+00000040  38 4a da 1b 6c 81 19 d5  35 b7 af e9 ec 16 4d 98  |8J..l...5.....M.|
+00000050  21 c2 0e f7 0b fb ff d8  1e 2d 8b 04 56 82 48 c4  |!........-..V.H.|
+00000060  e5 f9 38 8c d2                                    |..8..|
 >>> Flow 4 (server to client)
-00000000  14 03 01 00 01 01 16 03  01 00 30 f4 4e 0a ea 58  |..........0.N..X|
-00000010  18 c6 9d 5f aa 5d f0 03  d4 63 0d e7 83 cb a8 18  |..._.]...c......|
-00000020  06 fa b6 82 da df 16 89  5c 8b 5d 92 87 b1 42 da  |........\.]...B.|
-00000030  cd 2a ee dc 43 08 f1 0d  1f 18 5c                 |.*..C.....\|
+00000000  14 03 01 00 01 01 16 03  01 00 30 f0 b5 a3 bb bb  |..........0.....|
+00000010  9d 85 7d 6f e7 a9 17 31  65 74 82 69 56 a9 33 21  |..}o...1et.iV.3!|
+00000020  16 9d 75 3a 28 88 a5 c2  a9 e1 a7 43 6e 03 26 96  |..u:(......Cn.&.|
+00000030  37 4b de 63 be 49 cb c8  d4 a2 b6                 |7K.c.I.....|
 >>> Flow 5 (client to server)
-00000000  17 03 01 00 20 e6 95 10  e0 98 07 9f 2b 42 06 b8  |.... .......+B..|
-00000010  2a 6c 5d 4a 95 2a 2c 17  d5 cc 68 42 18 bd 72 58  |*l]J.*,...hB..rX|
-00000020  c1 39 73 05 75 17 03 01  00 20 d4 ae 70 ee a0 ed  |.9s.u.... ..p...|
-00000030  3e dd f9 aa 93 03 ff f5  a4 f6 f3 0d e7 a6 59 a9  |>.............Y.|
-00000040  40 b4 f6 ad a5 46 0b eb  ee 0e 15 03 01 00 20 7c  |@....F........ ||
-00000050  1a 29 f3 49 60 47 2e 52  ec 00 4a 62 44 30 93 5f  |.).I`G.R..JbD0._|
-00000060  df 73 2f 44 65 3f 77 c1  3d 04 32 c8 bb 86 ed     |.s/De?w.=.2....|
+00000000  17 03 01 00 20 a9 9c 8f  74 ce f9 77 bc b3 86 2e  |.... ...t..w....|
+00000010  a5 8e 94 3d 08 a6 96 bf  25 0b 10 c4 66 c2 59 9a  |...=....%...f.Y.|
+00000020  4a 1a b4 77 12 17 03 01  00 20 03 72 60 38 58 88  |J..w..... .r`8X.|
+00000030  86 20 20 3f 18 52 c5 ca  55 3c 04 04 c7 e1 74 6f  |.  ?.R..U<....to|
+00000040  ca 1f cd 27 64 f2 51 12  9c ee 15 03 01 00 20 30  |...'d.Q....... 0|
+00000050  71 2a 78 bf 8b d5 11 7c  63 11 c7 25 0e 56 25 ce  |q*x....|c..%.V%.|
+00000060  24 d5 d7 de a0 ba c7 ba  e6 dc db 8e e3 93 a6     |$..............|
diff --git a/src/crypto/tls/testdata/Client-TLSv10-RSA-RC4 b/src/crypto/tls/testdata/Client-TLSv10-RSA-RC4
index 1fe13b9f97..dcc18ad01d 100644
--- a/src/crypto/tls/testdata/Client-TLSv10-RSA-RC4
+++ b/src/crypto/tls/testdata/Client-TLSv10-RSA-RC4
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 01 00 51 02 00 00  4d 03 01 5a 4f 78 41 d5  |....Q...M..ZOxA.|
-00000010  86 2f d2 0a c6 05 bc c9  8e cc bd b2 39 ac a5 78  |./..........9..x|
-00000020  e3 e5 31 b9 cb 01 af cb  ca fc 88 20 c9 61 c6 91  |..1........ .a..|
-00000030  b2 e5 70 df ca d0 41 a8  20 61 ab 08 f6 dc fe c0  |..p...A. a......|
-00000040  cc ea 1e 80 89 02 6a 26  ea f0 c8 71 00 05 00 00  |......j&...q....|
+00000000  16 03 01 00 51 02 00 00  4d 03 01 2a 09 26 d2 61  |....Q...M..*.&.a|
+00000010  ac 38 91 3d 18 3f f7 a9  3c 34 91 b0 b1 e1 29 68  |.8.=.?..<4....)h|
+00000020  dd cb b9 a9 d8 39 0b 64  c6 93 7d 20 ea 51 ff 63  |.....9.d..} .Q.c|
+00000030  97 03 b2 6f a3 d6 55 0d  64 65 2a 5d 3a fe e9 3e  |...o..U.de*]:..>|
+00000040  47 c1 7d c5 d8 03 c6 22  19 2f 6c 5a 00 05 00 00  |G.}...."./lZ....|
 00000050  05 ff 01 00 01 00 16 03  01 02 59 0b 00 02 55 00  |..........Y...U.|
 00000060  02 52 00 02 4f 30 82 02  4b 30 82 01 b4 a0 03 02  |.R..O0..K0......|
 00000070  01 02 02 09 00 e8 f0 9d  3f e2 5b ea a6 30 0d 06  |........?.[..0..|
@@ -70,15 +70,15 @@
 00000060  c5 70 0f 08 83 48 e9 48  ef 6e 50 8b 05 7e e5 84  |.p...H.H.nP..~..|
 00000070  25 fa 55 c7 ae 31 02 27  00 ef 3f 98 86 20 12 89  |%.U..1.'..?.. ..|
 00000080  91 59 28 b4 f7 d7 af d2  69 61 35 14 03 01 00 01  |.Y(.....ia5.....|
-00000090  01 16 03 01 00 24 48 fd  e6 fc 4a 94 33 82 22 ff  |.....$H...J.3.".|
-000000a0  af c3 44 98 d2 c6 4e 8a  39 43 dd 4b 2a 11 2b 4e  |..D...N.9C.K*.+N|
-000000b0  5b d9 a4 fc 6c 95 d7 69  05 f9                    |[...l..i..|
+00000090  01 16 03 01 00 24 29 ee  6c 54 d6 21 5e 31 30 9e  |.....$).lT.!^10.|
+000000a0  fd 02 69 bb 32 c2 9e ad  28 b1 2d 94 49 0a 12 0c  |..i.2...(.-.I...|
+000000b0  a1 12 b0 98 a6 33 eb 63  2b e4                    |.....3.c+.|
 >>> Flow 4 (server to client)
-00000000  14 03 01 00 01 01 16 03  01 00 24 61 d2 68 5e 12  |..........$a.h^.|
-00000010  91 6e 7f fe bf b7 42 58  e9 06 38 09 c1 16 34 e5  |.n....BX..8...4.|
-00000020  a1 46 d6 cf 23 ca 48 c1  ed 76 f9 48 a1 9a 2a     |.F..#.H..v.H..*|
+00000000  14 03 01 00 01 01 16 03  01 00 24 32 3e 45 f2 3a  |..........$2>E.:|
+00000010  01 05 50 db 37 25 f6 b5  67 8e 38 3d f5 ba b7 90  |..P.7%..g.8=....|
+00000020  e0 05 a8 cb e0 33 1a 79  ab 44 86 d5 0c fd 86     |.....3.y.D.....|
 >>> Flow 5 (client to server)
-00000000  17 03 01 00 1a 3a e1 39  7c fe 25 50 dc 66 3f b6  |.....:.9|.%P.f?.|
-00000010  6f fd 79 3b 12 83 af 89  b1 c5 f6 75 56 ad a1 15  |o.y;.......uV...|
-00000020  03 01 00 16 07 d1 d3 7a  54 1c 71 0b c8 64 10 46  |.......zT.q..d.F|
-00000030  30 d0 bf df 75 a6 dc 10  b1 d1                    |0...u.....|
+00000000  17 03 01 00 1a ac 0c 1f  12 4e d4 31 10 dd c1 04  |.........N.1....|
+00000010  8b 55 a2 2e a5 f4 e4 80  aa 23 7e bd 79 b0 ee 15  |.U.......#~.y...|
+00000020  03 01 00 16 fa d9 ff 50  7d 41 01 2a d2 13 ee 33  |.......P}A.*...3|
+00000030  52 ab 20 c5 e7 73 81 5d  81 60                    |R. ..s.].`|
diff --git a/src/crypto/tls/testdata/Client-TLSv11-ECDHE-ECDSA-AES b/src/crypto/tls/testdata/Client-TLSv11-ECDHE-ECDSA-AES
index 9d18cd62f7..92cdc4c024 100644
--- a/src/crypto/tls/testdata/Client-TLSv11-ECDHE-ECDSA-AES
+++ b/src/crypto/tls/testdata/Client-TLSv11-ECDHE-ECDSA-AES
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 02 00 59 02 00 00  55 03 02 23 a8 e7 14 3f  |....Y...U..#...?|
-00000010  64 61 3c ee 80 a2 94 84  ab b8 66 76 30 84 06 78  |da<.......fv0..x|
-00000020  96 ba a7 d3 1e 81 1b 16  64 76 88 20 3d 21 21 b3  |........dv. =!!.|
-00000030  45 dd fe cb 5b d7 9a 86  39 ee 4f f8 60 eb 95 ea  |E...[...9.O.`...|
-00000040  ab 64 48 14 74 16 fd e9  47 07 66 60 c0 09 00 00  |.dH.t...G.f`....|
+00000000  16 03 02 00 59 02 00 00  55 03 02 bf ac 6b 91 53  |....Y...U....k.S|
+00000010  dc 1f d6 ee 0e 71 d6 a4  f5 a2 7c f0 10 69 41 dd  |.....q....|..iA.|
+00000020  4a b7 30 53 e6 28 07 31  34 8f e5 20 59 d1 bd e1  |J.0S.(.14.. Y...|
+00000030  20 44 c4 05 07 e9 07 90  5d de 08 73 72 55 04 a6  | D......]..srU..|
+00000040  11 20 bf 32 e0 dd 46 d4  1d ed 45 62 c0 09 00 00  |. .2..F...Eb....|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  02 02 0e 0b 00 02 0a 00  02 07 00 02 04 30 82 02  |.............0..|
 00000070  00 30 82 01 62 02 09 00  b8 bf 2d 47 a0 d2 eb f4  |.0..b.....-G....|
@@ -55,39 +55,39 @@
 00000240  13 83 0d 94 06 bb d4 37  7a f6 ec 7a c9 86 2e dd  |.......7z..z....|
 00000250  d7 11 69 7f 85 7c 56 de  fb 31 78 2b e4 c7 78 0d  |..i..|V..1x+..x.|
 00000260  ae cb be 9e 4e 36 24 31  7b 6a 0f 39 95 12 07 8f  |....N6$1{j.9....|
-00000270  2a 16 03 02 00 b4 0c 00  00 b0 03 00 1d 20 a7 a4  |*............ ..|
-00000280  33 20 48 6a 74 8e 07 fc  c0 b6 10 61 84 d6 67 d1  |3 Hjt......a..g.|
-00000290  ae cf 65 36 4d d5 13 a1  07 fc 1f aa 77 44 00 8a  |..e6M.......wD..|
-000002a0  30 81 87 02 42 01 02 5b  f9 4a af 8d 0a d5 a3 de  |0...B..[.J......|
-000002b0  11 62 d8 f1 db 49 7a 0c  34 3e 2d 61 f9 6f 6b c2  |.b...Iz.4>-a.ok.|
-000002c0  1d 32 4b 88 93 9b 22 b0  3d 09 c3 93 9e 25 31 d6  |.2K...".=....%1.|
-000002d0  5f 06 3a f0 4a 61 0b 06  03 5d 6c 0e b3 5e 48 5a  |_.:.Ja...]l..^HZ|
-000002e0  f0 5b 21 48 58 8f b2 02  41 1c 57 f1 51 04 d6 f8  |.[!HX...A.W.Q...|
-000002f0  a2 51 e6 e6 3e e0 99 63  aa d2 1c 7b 92 be 44 ec  |.Q..>..c...{..D.|
-00000300  86 c3 31 fa e7 9b 98 1a  59 a5 93 3e a9 73 f0 ec  |..1.....Y..>.s..|
-00000310  03 22 37 19 db 78 30 27  ab bf 52 07 6c 3a 79 f5  |."7..x0'..R.l:y.|
-00000320  ad 70 59 76 84 44 f0 47  e0 3d 16 03 02 00 04 0e  |.pYv.D.G.=......|
-00000330  00 00 00                                          |...|
+00000270  2a 16 03 02 00 b5 0c 00  00 b1 03 00 1d 20 ab ea  |*............ ..|
+00000280  ff 17 1e b1 ef f6 22 03  40 8b e1 1a fa ab 01 cf  |......".@.......|
+00000290  0f f0 b0 6d 43 3c 1f 03  a1 d6 4a 9d 79 43 00 8b  |...mC<....J.yC..|
+000002a0  30 81 88 02 42 00 a1 b4  50 4b 9b a3 a5 ec ef dc  |0...B...PK......|
+000002b0  bf c1 a2 65 24 2a 6c aa  ab 26 01 ed d1 ad 2e 37  |...e$*l..&.....7|
+000002c0  4f f5 8b ff 98 ac ef 15  3e d9 46 07 a3 d2 35 de  |O.......>.F...5.|
+000002d0  91 bc 3d a0 1f f1 68 55  28 ef 60 ad 13 05 ac 65  |..=...hU(.`....e|
+000002e0  e5 67 02 3f 85 8b 1b 02  42 01 26 3f fc 62 e3 93  |.g.?....B.&?.b..|
+000002f0  8e fa fb 93 0f 0b ff 68  25 46 ea 71 16 ae 6e d4  |.......h%F.q..n.|
+00000300  36 9e 48 2c 77 2b d8 f5  f6 1d 69 68 ed 28 8f e7  |6.H,w+....ih.(..|
+00000310  79 7e 78 56 52 ff e8 62  fc e2 bd 2e c7 e8 9f 3f  |y~xVR..b.......?|
+00000320  93 47 d2 62 6c f6 5c 0e  a2 b8 fe 16 03 02 00 04  |.G.bl.\.........|
+00000330  0e 00 00 00                                       |....|
 >>> Flow 3 (client to server)
 00000000  16 03 02 00 25 10 00 00  21 20 2f e5 7d a3 47 cd  |....%...! /.}.G.|
 00000010  62 43 15 28 da ac 5f bb  29 07 30 ff f6 84 af c4  |bC.(.._.).0.....|
 00000020  cf c2 ed 90 99 5f 58 cb  3b 74 14 03 02 00 01 01  |....._X.;t......|
 00000030  16 03 02 00 40 00 00 00  00 00 00 00 00 00 00 00  |....@...........|
-00000040  00 00 00 00 00 ef 0f 92  ac 11 fe 97 1a 46 69 e4  |.............Fi.|
-00000050  b3 26 8d d7 92 46 02 25  5b 2e 86 3e 96 3d 64 ed  |.&...F.%[..>.=d.|
-00000060  37 92 dd ae a5 a6 9f 03  f0 c2 42 78 9f b9 78 ac  |7.........Bx..x.|
-00000070  97 ab 82 25 e2                                    |...%.|
+00000040  00 00 00 00 00 0f 55 37  4b 93 d5 ce b1 1c 6f a3  |......U7K.....o.|
+00000050  6d 56 32 f5 de 19 f6 a3  15 b0 6a 90 06 92 60 ca  |mV2.......j...`.|
+00000060  ec 0e 2b d4 24 16 0a 26  f3 bd 3d ca c5 9f d2 9b  |..+.$..&..=.....|
+00000070  79 2f af b6 b0                                    |y/...|
 >>> Flow 4 (server to client)
-00000000  14 03 02 00 01 01 16 03  02 00 40 df a9 23 37 74  |..........@..#7t|
-00000010  47 d8 98 87 53 b4 0a 4d  b0 a5 fb cb d6 37 c8 7c  |G...S..M.....7.||
-00000020  61 95 81 ef b3 63 78 2b  53 c2 86 fc 39 df c4 5f  |a....cx+S...9.._|
-00000030  e4 4b af 1d fe bc 4c fe  1b 6a 28 c3 46 6f 24 94  |.K....L..j(.Fo$.|
-00000040  a8 bf ef ce e8 e8 ad 2c  d9 10 32                 |.......,..2|
+00000000  14 03 02 00 01 01 16 03  02 00 40 4d e3 a9 af 51  |..........@M...Q|
+00000010  f5 d1 cd 04 f1 cf c5 48  0f 2e 0b 6e 57 4c 11 28  |.......H...nWL.(|
+00000020  dd 89 19 14 98 8e 2e 92  db 3c a4 0f 85 32 90 7e  |.........<...2.~|
+00000030  49 13 17 a0 85 fa c6 25  79 24 13 90 86 dc ec 45  |I......%y$.....E|
+00000040  7c 74 35 92 e4 89 04 c2  51 27 66                 ||t5.....Q'f|
 >>> Flow 5 (client to server)
 00000000  17 03 02 00 30 00 00 00  00 00 00 00 00 00 00 00  |....0...........|
-00000010  00 00 00 00 00 34 50 ce  9c 7f f5 2d a2 c1 e4 5c  |.....4P....-...\|
-00000020  fa d1 a0 f4 38 e8 4f 51  54 36 07 da f1 af 6d ef  |....8.OQT6....m.|
-00000030  b8 b0 bc bc a6 15 03 02  00 30 00 00 00 00 00 00  |.........0......|
-00000040  00 00 00 00 00 00 00 00  00 00 0b d4 8e e8 69 64  |..............id|
-00000050  53 38 7c 72 d8 1d 9f d5  8a 83 74 a7 37 6b e2 c0  |S8|r......t.7k..|
-00000060  8f 26 e7 5d 0e 06 ae e0  db fb                    |.&.]......|
+00000010  00 00 00 00 00 f9 ac 17  1f 08 b7 80 fb 70 87 e2  |.............p..|
+00000020  53 00 27 60 78 6c 80 5b  57 e7 70 72 8a e3 1b 32  |S.'`xl.[W.pr...2|
+00000030  8c f0 67 82 82 15 03 02  00 30 00 00 00 00 00 00  |..g......0......|
+00000040  00 00 00 00 00 00 00 00  00 00 01 e1 86 47 7f 65  |.............G.e|
+00000050  a9 d2 1c 22 7d 99 7c 41  dc 17 f5 16 40 5b b3 7f  |..."}.|A....@[..|
+00000060  cc 0b 97 41 0c ae 1f 0c  39 e0                    |...A....9.|
diff --git a/src/crypto/tls/testdata/Client-TLSv11-ECDHE-RSA-AES b/src/crypto/tls/testdata/Client-TLSv11-ECDHE-RSA-AES
index 4cc9610faa..b2b7ecb165 100644
--- a/src/crypto/tls/testdata/Client-TLSv11-ECDHE-RSA-AES
+++ b/src/crypto/tls/testdata/Client-TLSv11-ECDHE-RSA-AES
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 02 00 59 02 00 00  55 03 02 6e ff 3b 26 66  |....Y...U..n.;&f|
-00000010  7c 32 3f 42 fd 92 7c 12  db 26 b2 45 6e 28 b9 49  ||2?B..|..&.En(.I|
-00000020  86 6b 00 54 92 3b 65 a6  02 6d 94 20 ea 44 db 5c  |.k.T.;e..m. .D.\|
-00000030  d1 39 35 b2 ea 1c 6d 3e  94 bb 47 60 25 1e 9c 74  |.95...m>..G`%..t|
-00000040  e7 bd 54 cc 2b 36 14 6a  12 54 5b 6c c0 13 00 00  |..T.+6.j.T[l....|
+00000000  16 03 02 00 59 02 00 00  55 03 02 95 6e 24 5a ab  |....Y...U...n$Z.|
+00000010  ae 3c 73 52 9d 31 63 50  cf f9 50 99 3c e4 94 22  |.<sR.1cP..P.<.."|
+00000020  5b 6f 0e f8 e3 a8 64 4c  d2 8c 00 20 8b 2d 25 47  |[o....dL... .-%G|
+00000030  f9 74 41 93 b1 82 b5 c5  fc 3e 42 c9 35 fc 68 27  |.tA......>B.5.h'|
+00000040  c4 2b 35 0f f8 1c e3 28  e6 8a 59 dc c0 13 00 00  |.+5....(..Y.....|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  02 02 59 0b 00 02 55 00  02 52 00 02 4f 30 82 02  |..Y...U..R..O0..|
 00000070  4b 30 82 01 b4 a0 03 02  01 02 02 09 00 e8 f0 9d  |K0..............|
@@ -60,38 +60,38 @@
 00000290  77 8d 0c 1c f1 0f a1 d8  40 83 61 c9 4c 72 2b 9d  |w.......@.a.Lr+.|
 000002a0  ae db 46 06 06 4d f4 c1  b3 3e c0 d1 bd 42 d4 db  |..F..M...>...B..|
 000002b0  fe 3d 13 60 84 5c 21 d3  3b e9 fa e7 16 03 02 00  |.=.`.\!.;.......|
-000002c0  aa 0c 00 00 a6 03 00 1d  20 82 3b d2 56 dd cd d8  |........ .;.V...|
-000002d0  e1 98 a7 90 d1 08 2d 37  dc e8 21 cd 29 af 29 a5  |......-7..!.).).|
-000002e0  78 8e 59 9e 4c ac c9 d2  4b 00 80 25 20 91 4e 0d  |x.Y.L...K..% .N.|
-000002f0  74 12 9e 1c 98 fb 5f 4b  ad fd c8 68 df 6b 82 98  |t....._K...h.k..|
-00000300  a8 7c ee 17 44 47 91 2a  42 c1 82 d0 ce aa cd f8  |.|..DG.*B.......|
-00000310  69 1e 85 79 27 fe ef 5a  a2 e1 35 30 9a 2d c6 b0  |i..y'..Z..50.-..|
-00000320  43 84 39 7f 8d 68 09 d6  6c 1a 84 0f c0 9a c0 9f  |C.9..h..l.......|
-00000330  64 56 cb fc 32 f2 4a a3  26 e8 c2 5f d7 16 3e 7c  |dV..2.J.&.._..>||
-00000340  4e 8b 89 f8 7f f4 c2 26  fe 01 cd 48 b6 61 9c 93  |N......&...H.a..|
-00000350  1a bc a1 d1 01 c5 bf ef  43 b4 ca 86 62 37 b4 99  |........C...b7..|
-00000360  54 69 db 74 51 92 92 dd  c1 b1 75 16 03 02 00 04  |Ti.tQ.....u.....|
+000002c0  aa 0c 00 00 a6 03 00 1d  20 b5 75 ee e5 26 6b c0  |........ .u..&k.|
+000002d0  af 34 8a 24 f7 c5 25 58  29 38 4c 08 d3 a2 0c 48  |.4.$..%X)8L....H|
+000002e0  18 eb a0 5b e8 64 62 62  78 00 80 d0 1c 9c 11 1a  |...[.dbbx.......|
+000002f0  58 4c 46 5f 18 03 d7 d7  76 47 d5 56 7a bb bd 95  |XLF_....vG.Vz...|
+00000300  16 46 e8 0b 28 6e df 15  65 1a f6 95 fb 4a 6c 42  |.F..(n..e....JlB|
+00000310  1b 4c 5c 30 c5 de d0 83  08 d3 2e 4d 59 7e 7b 1b  |.L\0.......MY~{.|
+00000320  20 9e b5 19 76 fe a3 dd  87 04 f4 9a 3e 3c c0 4a  | ...v.......><.J|
+00000330  16 7f e3 4e 9a 1f 0a 36  1d f5 09 b4 88 09 b1 1b  |...N...6........|
+00000340  9b 60 97 dc d7 ea 97 f4  d6 06 16 45 98 ee 5c 39  |.`.........E..\9|
+00000350  62 3f 7c 82 7b c3 52 59  01 d4 89 8c a6 e2 d5 eb  |b?|.{.RY........|
+00000360  e8 30 a6 78 49 1e ec a5  92 ad 24 16 03 02 00 04  |.0.xI.....$.....|
 00000370  0e 00 00 00                                       |....|
 >>> Flow 3 (client to server)
 00000000  16 03 02 00 25 10 00 00  21 20 2f e5 7d a3 47 cd  |....%...! /.}.G.|
 00000010  62 43 15 28 da ac 5f bb  29 07 30 ff f6 84 af c4  |bC.(.._.).0.....|
 00000020  cf c2 ed 90 99 5f 58 cb  3b 74 14 03 02 00 01 01  |....._X.;t......|
 00000030  16 03 02 00 40 00 00 00  00 00 00 00 00 00 00 00  |....@...........|
-00000040  00 00 00 00 00 c5 bf e6  b3 86 12 92 df 68 fa 75  |.............h.u|
-00000050  79 5f ee fe 60 91 d1 fd  8a 48 3b 97 b4 da 7f 58  |y_..`....H;....X|
-00000060  3e 7e 40 d7 93 1d 6b e2  0e 2a a4 45 20 e0 9d f9  |>~@...k..*.E ...|
-00000070  b6 5e b1 f1 4f                                    |.^..O|
+00000040  00 00 00 00 00 28 ab ed  77 d3 56 29 a8 4a 38 c8  |.....(..w.V).J8.|
+00000050  64 1c a5 d9 4e f9 6b 0e  fa 82 42 ad 0d be 15 69  |d...N.k...B....i|
+00000060  9a ff 79 64 db 8f 3e 16  b3 86 93 82 6f 78 c4 2e  |..yd..>.....ox..|
+00000070  7c 54 6c 4f 90                                    ||TlO.|
 >>> Flow 4 (server to client)
-00000000  14 03 02 00 01 01 16 03  02 00 40 bf 58 92 80 02  |..........@.X...|
-00000010  75 91 40 30 35 e0 16 76  f4 97 bd 77 46 a3 a3 4e  |u.@05..v...wF..N|
-00000020  f1 be 53 eb b8 56 45 b1  71 c9 f8 a9 bf c6 9a 00  |..S..VE.q.......|
-00000030  83 46 91 88 d5 7b 72 95  27 33 80 43 3f 3e f6 60  |.F...{r.'3.C?>.`|
-00000040  c6 55 90 6a 87 8e 7d 48  27 e2 40                 |.U.j..}H'.@|
+00000000  14 03 02 00 01 01 16 03  02 00 40 15 e9 c5 15 59  |..........@....Y|
+00000010  b3 0d 46 22 0c ae a6 41  02 b4 f3 da 11 dc 85 79  |..F"...A.......y|
+00000020  bb d9 3f 23 38 51 24 1a  08 b5 a0 63 dc 4b 86 50  |..?#8Q$....c.K.P|
+00000030  ef b2 32 07 fd b5 e1 01  06 19 42 ce ba 69 ab 1a  |..2.......B..i..|
+00000040  c9 bb db 7d d0 9f f9 7c  f2 6c 18                 |...}...|.l.|
 >>> Flow 5 (client to server)
 00000000  17 03 02 00 30 00 00 00  00 00 00 00 00 00 00 00  |....0...........|
-00000010  00 00 00 00 00 f5 6b bc  6d 2c 70 b1 c0 f0 ab 78  |......k.m,p....x|
-00000020  44 c9 97 f6 59 ef 15 e4  05 cf e0 55 ee a4 68 8c  |D...Y......U..h.|
-00000030  86 57 82 bd 84 15 03 02  00 30 00 00 00 00 00 00  |.W.......0......|
-00000040  00 00 00 00 00 00 00 00  00 00 ef b2 a9 a5 bb a3  |................|
-00000050  6e e5 d1 2b ef 83 1d 11  de 29 d2 30 2c fc 78 73  |n..+.....).0,.xs|
-00000060  6b 6e 0a d2 55 67 5c d4  58 b3                    |kn..Ug\.X.|
+00000010  00 00 00 00 00 67 ef de  df a4 91 69 58 b8 3f 06  |.....g.....iX.?.|
+00000020  c4 05 4e ad 88 9b c5 12  35 cf 63 39 3a 61 e9 4c  |..N.....5.c9:a.L|
+00000030  49 22 93 f4 10 15 03 02  00 30 00 00 00 00 00 00  |I".......0......|
+00000040  00 00 00 00 00 00 00 00  00 00 00 2a 5a ba 39 7e  |...........*Z.9~|
+00000050  a8 be 2e 72 f3 ba 7e 0a  32 b5 8c d8 f5 1b 93 6c  |...r..~.2......l|
+00000060  3e 35 d8 ba cc f3 9f f4  19 74                    |>5.......t|
diff --git a/src/crypto/tls/testdata/Client-TLSv11-RSA-RC4 b/src/crypto/tls/testdata/Client-TLSv11-RSA-RC4
index 9dae5dd6d2..aeba311f51 100644
--- a/src/crypto/tls/testdata/Client-TLSv11-RSA-RC4
+++ b/src/crypto/tls/testdata/Client-TLSv11-RSA-RC4
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 02 00 51 02 00 00  4d 03 02 96 ca 2a e7 23  |....Q...M....*.#|
-00000010  af 2e 45 62 15 fa 5a 84  bc aa 7c 79 03 1b 37 69  |..Eb..Z...|y..7i|
-00000020  a0 77 ce 03 81 b7 e5 7d  31 34 6e 20 93 83 5d 7c  |.w.....}14n ..]||
-00000030  e8 c7 48 f9 67 ec 97 b1  27 b6 de de 89 07 5a cf  |..H.g...'.....Z.|
-00000040  44 77 48 4b e9 62 43 e3  87 fd de 87 00 05 00 00  |DwHK.bC.........|
+00000000  16 03 02 00 51 02 00 00  4d 03 02 82 5b 12 ac 33  |....Q...M...[..3|
+00000010  08 d4 28 8c 91 6e 52 c4  c6 09 13 24 bf 42 d2 37  |..(..nR....$.B.7|
+00000020  6d 78 60 b0 ea bd 9e b3  08 99 43 20 05 5a 93 f9  |mx`.......C .Z..|
+00000030  a4 39 43 4f c4 e3 27 20  7d 4c fa 7a 28 c1 c7 33  |.9CO..' }L.z(..3|
+00000040  72 fa 14 b8 ba c3 89 b0  a5 54 a3 7c 00 05 00 00  |r........T.|....|
 00000050  05 ff 01 00 01 00 16 03  02 02 59 0b 00 02 55 00  |..........Y...U.|
 00000060  02 52 00 02 4f 30 82 02  4b 30 82 01 b4 a0 03 02  |.R..O0..K0......|
 00000070  01 02 02 09 00 e8 f0 9d  3f e2 5b ea a6 30 0d 06  |........?.[..0..|
@@ -70,15 +70,15 @@
 00000060  c5 70 0f 08 83 48 e9 48  ef 6e 50 8b 05 7e e5 84  |.p...H.H.nP..~..|
 00000070  25 fa 55 c7 ae 31 02 27  00 ef 3f 98 86 20 12 89  |%.U..1.'..?.. ..|
 00000080  91 59 28 b4 f7 d7 af d2  69 61 35 14 03 02 00 01  |.Y(.....ia5.....|
-00000090  01 16 03 02 00 24 33 5d  7f cb 6e 36 19 8b db 35  |.....$3]..n6...5|
-000000a0  88 16 87 7a 9d 5a 51 27  51 13 17 64 0e 57 d5 e1  |...z.ZQ'Q..d.W..|
-000000b0  6e 34 8d e6 99 a8 38 b2  e7 3a                    |n4....8..:|
+00000090  01 16 03 02 00 24 e1 1a  bf e9 fd 4c fb 56 41 82  |.....$.....L.VA.|
+000000a0  c2 48 fc ca d9 d5 ec 2a  0a ee 63 25 e0 5f 53 cf  |.H.....*..c%._S.|
+000000b0  24 ff fe da 6f f5 8b 61  b7 b9                    |$...o..a..|
 >>> Flow 4 (server to client)
-00000000  14 03 02 00 01 01 16 03  02 00 24 e0 8b 90 9b 83  |..........$.....|
-00000010  f5 3d 00 e9 cf 7b 1d 75  cf c8 16 f2 29 8d de 0b  |.=...{.u....)...|
-00000020  75 82 b1 c4 6e 1c 1f ab  e9 90 74 31 99 f2 ad     |u...n.....t1...|
+00000000  14 03 02 00 01 01 16 03  02 00 24 99 2c e7 fa d0  |..........$.,...|
+00000010  29 d9 92 07 39 56 b0 0c  ad 23 30 c8 d7 0b 38 da  |)...9V...#0...8.|
+00000020  6f d3 c7 f9 66 d2 ec 8c  52 85 cb db a6 22 50     |o...f...R...."P|
 >>> Flow 5 (client to server)
-00000000  17 03 02 00 1a ca 2a 95  13 de 40 0d af 44 a4 aa  |......*...@..D..|
-00000010  9a 35 d7 38 c7 9f 74 4f  3a bf d1 9c cd 9e ee 15  |.5.8..tO:.......|
-00000020  03 02 00 16 d3 a4 32 78  a9 00 1b 7a 48 3e 7c 2b  |......2x...zH>|+|
-00000030  f9 3b 92 32 20 0b f4 16  39 18                    |.;.2 ...9.|
+00000000  17 03 02 00 1a 9f 70 c4  77 f3 0a a8 e0 1a 75 87  |......p.w.....u.|
+00000010  ab 2a f1 23 52 79 9f 5c  8e af 5d ba 27 45 f9 15  |.*.#Ry.\..].'E..|
+00000020  03 02 00 16 f0 28 f3 71  a0 97 6b ba 7e 97 81 85  |.....(.q..k.~...|
+00000030  11 59 1b c9 fa a0 48 32  e9 65                    |.Y....H2.e|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-AES128-GCM-SHA256 b/src/crypto/tls/testdata/Client-TLSv12-AES128-GCM-SHA256
index 4412f53c90..ce928728b4 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-AES128-GCM-SHA256
+++ b/src/crypto/tls/testdata/Client-TLSv12-AES128-GCM-SHA256
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 51 02 00 00  4d 03 03 1d be be 1e eb  |....Q...M.......|
-00000010  59 2c d5 07 b9 7a 64 47  95 84 ef cf d9 3e 82 4c  |Y,...zdG.....>.L|
-00000020  00 c0 0a 69 8a 01 2a b3  42 78 02 20 5e 32 5c 88  |...i..*.Bx. ^2\.|
-00000030  50 ed d5 44 41 4f bf a9  4e 49 83 5d aa 7c 2e 5d  |P..DAO..NI.].|.]|
-00000040  85 e8 64 92 5e 49 5d 8a  d0 0e 89 eb 00 9c 00 00  |..d.^I].........|
+00000000  16 03 03 00 51 02 00 00  4d 03 03 a4 26 bb e9 70  |....Q...M...&..p|
+00000010  57 4e ec f8 ea 23 01 75  c3 f3 a9 d4 d6 e8 71 2b  |WN...#.u......q+|
+00000020  01 5e c0 73 19 2b b9 d8  8e 3e d1 20 c8 c3 0a 22  |.^.s.+...>. ..."|
+00000030  7b ee cd 2e c9 e8 95 db  90 db 70 f5 59 e6 90 65  |{.........p.Y..e|
+00000040  35 87 a6 d4 bb dd 85 34  43 e8 66 49 00 9c 00 00  |5......4C.fI....|
 00000050  05 ff 01 00 01 00 16 03  03 02 59 0b 00 02 55 00  |..........Y...U.|
 00000060  02 52 00 02 4f 30 82 02  4b 30 82 01 b4 a0 03 02  |.R..O0..K0......|
 00000070  01 02 02 09 00 e8 f0 9d  3f e2 5b ea a6 30 0d 06  |........?.[..0..|
@@ -70,17 +70,17 @@
 00000060  c5 70 0f 08 83 48 e9 48  ef 6e 50 8b 05 7e e5 84  |.p...H.H.nP..~..|
 00000070  25 fa 55 c7 ae 31 02 27  00 ef 3f 98 86 20 12 89  |%.U..1.'..?.. ..|
 00000080  91 59 28 b4 f7 d7 af d2  69 61 35 14 03 03 00 01  |.Y(.....ia5.....|
-00000090  01 16 03 03 00 28 00 00  00 00 00 00 00 00 69 38  |.....(........i8|
-000000a0  97 84 2e 77 5c b8 58 82  b5 78 85 2e f3 7b 92 81  |...w\.X..x...{..|
-000000b0  00 72 91 23 41 ae 59 6c  18 64 f0 62 f2 c9        |.r.#A.Yl.d.b..|
+00000090  01 16 03 03 00 28 00 00  00 00 00 00 00 00 64 6c  |.....(........dl|
+000000a0  08 78 1d 03 0c ed dd 01  30 d4 fb 7c 3f 24 45 cc  |.x......0..|?$E.|
+000000b0  f6 b2 e3 42 07 93 8f 34  a8 21 d1 b0 08 e3        |...B...4.!....|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 28 37 f7 98 2f 78  |..........(7../x|
-00000010  54 85 5f 2e cb a9 b7 bf  4b 2d 62 06 e2 32 cd 18  |T._.....K-b..2..|
-00000020  de f5 54 c8 e0 54 2d c5  b4 98 07 7e c7 b7 79 a0  |..T..T-....~..y.|
-00000030  75 af 5c                                          |u.\|
+00000000  14 03 03 00 01 01 16 03  03 00 28 75 9b 91 cd 7d  |..........(u...}|
+00000010  8d f7 3c a0 d6 5e d4 f2  24 1a 0a f3 04 b1 d9 0b  |..<..^..$.......|
+00000020  1d 31 ca 1c 8b e7 38 c0  8e 7d 12 19 89 33 28 4d  |.1....8..}...3(M|
+00000030  83 28 b6                                          |.(.|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 1e 00 00 00  00 00 00 00 01 78 c1 c0  |.............x..|
-00000010  7d 1b a8 b2 80 0e a3 64  cf e0 fa 71 9d 37 5d 32  |}......d...q.7]2|
-00000020  8d 36 38 15 03 03 00 1a  00 00 00 00 00 00 00 02  |.68.............|
-00000030  c2 f3 41 1a 2c a4 4f 48  fa 61 14 40 60 51 e5 99  |..A.,.OH.a.@`Q..|
-00000040  c6 e5                                             |..|
+00000000  17 03 03 00 1e 00 00 00  00 00 00 00 01 7d fe 53  |.............}.S|
+00000010  73 aa ca 3d f3 27 b7 01  56 9e e7 c9 6d 79 2a 97  |s..=.'..V...my*.|
+00000020  b2 21 42 15 03 03 00 1a  00 00 00 00 00 00 00 02  |.!B.............|
+00000030  de bd 3e 9e 8f c0 98 ec  bd b4 9b 89 90 a2 26 a8  |..>...........&.|
+00000040  28 97                                             |(.|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-AES128-SHA256 b/src/crypto/tls/testdata/Client-TLSv12-AES128-SHA256
index d7568843b4..15394c7e34 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-AES128-SHA256
+++ b/src/crypto/tls/testdata/Client-TLSv12-AES128-SHA256
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 51 02 00 00  4d 03 03 c3 41 d7 9c 1b  |....Q...M...A...|
-00000010  9a ff f8 17 af 41 df 8d  96 70 bb b8 f6 9a 4c a2  |.....A...p....L.|
-00000020  03 25 31 2c 58 fa 05 5b  12 85 6a 20 18 3c 34 d6  |.%1,X..[..j .<4.|
-00000030  08 44 46 a5 5c b1 40 0d  38 33 c0 2d ea a6 46 53  |.DF.\.@.83.-..FS|
-00000040  0e 09 39 6f 11 35 02 63  cf 21 74 c2 00 3c 00 00  |..9o.5.c.!t..<..|
+00000000  16 03 03 00 51 02 00 00  4d 03 03 8a a8 2c 00 d8  |....Q...M....,..|
+00000010  d8 87 53 14 1e 7b ff ca  19 a2 6d bc 47 6f 73 12  |..S..{....m.Gos.|
+00000020  0d 54 6e 33 21 80 01 86  f8 81 9f 20 46 f6 8c e8  |.Tn3!...... F...|
+00000030  8b 90 02 b2 da e2 83 3a  2a 0f b3 f7 96 2b f8 96  |.......:*....+..|
+00000040  56 77 39 52 9e a1 bd 74  1e 2e b1 b0 00 3c 00 00  |Vw9R...t.....<..|
 00000050  05 ff 01 00 01 00 16 03  03 02 59 0b 00 02 55 00  |..........Y...U.|
 00000060  02 52 00 02 4f 30 82 02  4b 30 82 01 b4 a0 03 02  |.R..O0..K0......|
 00000070  01 02 02 09 00 e8 f0 9d  3f e2 5b ea a6 30 0d 06  |........?.[..0..|
@@ -71,25 +71,25 @@
 00000070  25 fa 55 c7 ae 31 02 27  00 ef 3f 98 86 20 12 89  |%.U..1.'..?.. ..|
 00000080  91 59 28 b4 f7 d7 af d2  69 61 35 14 03 03 00 01  |.Y(.....ia5.....|
 00000090  01 16 03 03 00 50 00 00  00 00 00 00 00 00 00 00  |.....P..........|
-000000a0  00 00 00 00 00 00 88 20  99 51 5e fb 72 79 7f f8  |....... .Q^.ry..|
-000000b0  b2 a9 56 96 a3 03 1d a0  e0 38 1a be 4c ea 80 f9  |..V......8..L...|
-000000c0  c0 ef 45 81 91 7f b9 1b  f7 91 3b 4e 05 87 d6 73  |..E.......;N...s|
-000000d0  c0 27 94 50 4f 00 ee c1  02 af 5f 6f 4c a5 0e 5b  |.'.PO....._oL..[|
-000000e0  6c 76 87 28 b4 bf                                 |lv.(..|
+000000a0  00 00 00 00 00 00 8f d8  ac 7f ec 16 9e d8 e9 f2  |................|
+000000b0  ce 30 51 dc 87 e0 f9 80  57 66 d9 87 20 77 3a b1  |.0Q.....Wf.. w:.|
+000000c0  43 db fc 36 f5 64 6e 96  e9 b8 e2 ab bb 00 48 36  |C..6.dn.......H6|
+000000d0  60 9c 5a 7c 38 3f 13 e1  9c ef d9 15 96 91 56 e2  |`.Z|8?........V.|
+000000e0  87 2e 23 1a 98 40                                 |..#..@|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 50 93 14 a5 13 16  |..........P.....|
-00000010  d7 af 14 81 94 33 2d ae  f7 7a b1 b1 a5 38 fb e8  |.....3-..z...8..|
-00000020  c8 38 b3 ce f1 eb 70 e7  84 b6 fc 25 25 32 a9 09  |.8....p....%%2..|
-00000030  d1 0d 2d 59 57 6d d0 42  e8 c1 81 92 d0 af fb 5a  |..-YWm.B.......Z|
-00000040  08 7e 0f 3d 10 e5 42 6d  27 cd 8c 32 b2 20 4b 0a  |.~.=..Bm'..2. K.|
-00000050  75 76 ed 08 54 fe 74 94  72 35 9e                 |uv..T.t.r5.|
+00000000  14 03 03 00 01 01 16 03  03 00 50 80 01 08 cc d8  |..........P.....|
+00000010  08 a8 81 20 b2 bb 5b 50  79 74 4a b5 10 c4 7a 30  |... ..[PytJ...z0|
+00000020  6c 46 d6 e5 36 6e 4d cc  e5 0c 2c ab 3b de 92 45  |lF..6nM...,.;..E|
+00000030  ee 20 58 a9 0f 03 26 3e  6c 05 a7 ef f2 7c a7 9b  |. X...&>l....|..|
+00000040  57 c0 20 8d d0 69 0e b0  5a cc e6 26 5f e2 c3 24  |W. ..i..Z..&_..$|
+00000050  c4 db df 20 03 08 e1 aa  59 2b d2                 |... ....Y+.|
 >>> Flow 5 (client to server)
 00000000  17 03 03 00 40 00 00 00  00 00 00 00 00 00 00 00  |....@...........|
-00000010  00 00 00 00 00 53 91 38  34 33 20 94 0d 76 d7 72  |.....S.843 ..v.r|
-00000020  48 f3 17 34 01 ae 0e 89  db 60 f1 4e 64 a5 cf 0c  |H..4.....`.Nd...|
-00000030  32 52 3f a0 18 f8 c5 57  ed 3a d1 41 19 81 cf 0a  |2R?....W.:.A....|
-00000040  f2 d8 90 4b ba 15 03 03  00 40 00 00 00 00 00 00  |...K.....@......|
-00000050  00 00 00 00 00 00 00 00  00 00 05 2b 31 3c 1b a2  |...........+1<..|
-00000060  11 87 5f 0f 49 72 bb 67  e6 75 18 9c b1 f4 6c ed  |.._.Ir.g.u....l.|
-00000070  4d 01 58 35 30 43 44 e8  ee 1d f2 81 9d 67 6d 77  |M.X50CD......gmw|
-00000080  1e 36 61 7f f3 32 3d 60  73 6d                    |.6a..2=`sm|
+00000010  00 00 00 00 00 a2 dd a6  ff 57 60 80 dd 97 cf 20  |.........W`.... |
+00000020  10 04 60 80 53 17 37 ce  ce 39 b6 21 f4 06 61 aa  |..`.S.7..9.!..a.|
+00000030  49 7b f0 d5 e0 72 4c 6f  38 d2 ab af 1c 94 bd 5b  |I{...rLo8......[|
+00000040  1b ee 8a 9b e3 15 03 03  00 40 00 00 00 00 00 00  |.........@......|
+00000050  00 00 00 00 00 00 00 00  00 00 ba 18 32 e7 6d f5  |............2.m.|
+00000060  fa 2e 61 55 cc fe 3c 4d  19 fd 84 6d c4 2a 46 92  |..aU..<M...m.*F.|
+00000070  ae b7 f3 67 c8 3c ce cd  b0 66 de ee 5d 3f 07 3b  |...g.<...f..]?.;|
+00000080  a9 85 a1 93 1f 98 f7 95  c9 ac                    |..........|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-AES256-GCM-SHA384 b/src/crypto/tls/testdata/Client-TLSv12-AES256-GCM-SHA384
index 2f552cbb62..766bf95067 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-AES256-GCM-SHA384
+++ b/src/crypto/tls/testdata/Client-TLSv12-AES256-GCM-SHA384
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 51 02 00 00  4d 03 03 2b 59 94 f3 9e  |....Q...M..+Y...|
-00000010  23 ae d3 58 82 1f 2e be  38 1d 14 e4 4c a4 b8 ed  |#..X....8...L...|
-00000020  95 08 b9 44 60 02 4b 0b  a9 6e ae 20 9b 43 e5 2a  |...D`.K..n. .C.*|
-00000030  0f 08 8e a4 c1 c0 15 79  9f af a5 ab a3 67 9d 09  |.......y.....g..|
-00000040  23 0e 8e 96 a9 aa 7d 26  74 d8 0c 9a 00 9d 00 00  |#.....}&t.......|
+00000000  16 03 03 00 51 02 00 00  4d 03 03 de 7a 77 5b eb  |....Q...M...zw[.|
+00000010  fa 84 a0 ac ba 3b ca 25  dc b3 c0 06 44 da 31 5c  |.....;.%....D.1\|
+00000020  27 e0 4e af be 47 07 5a  a5 ab 20 20 72 b2 67 0c  |'.N..G.Z..  r.g.|
+00000030  7e 71 5d e3 55 89 91 27  7f 65 ac 71 c6 e8 a5 4a  |~q].U..'.e.q...J|
+00000040  ae e1 a2 0d 3f a6 62 08  17 7e 26 fd 00 9d 00 00  |....?.b..~&.....|
 00000050  05 ff 01 00 01 00 16 03  03 02 59 0b 00 02 55 00  |..........Y...U.|
 00000060  02 52 00 02 4f 30 82 02  4b 30 82 01 b4 a0 03 02  |.R..O0..K0......|
 00000070  01 02 02 09 00 e8 f0 9d  3f e2 5b ea a6 30 0d 06  |........?.[..0..|
@@ -70,17 +70,17 @@
 00000060  c5 70 0f 08 83 48 e9 48  ef 6e 50 8b 05 7e e5 84  |.p...H.H.nP..~..|
 00000070  25 fa 55 c7 ae 31 02 27  00 ef 3f 98 86 20 12 89  |%.U..1.'..?.. ..|
 00000080  91 59 28 b4 f7 d7 af d2  69 61 35 14 03 03 00 01  |.Y(.....ia5.....|
-00000090  01 16 03 03 00 28 00 00  00 00 00 00 00 00 59 fc  |.....(........Y.|
-000000a0  aa b1 84 ab 09 82 00 88  8e e4 82 6e cd 24 9f b5  |...........n.$..|
-000000b0  01 95 d3 c3 f4 a2 16 54  25 91 77 76 fc f0        |.......T%.wv..|
+00000090  01 16 03 03 00 28 00 00  00 00 00 00 00 00 0b 7d  |.....(.........}|
+000000a0  83 0f 79 e2 4b ef d3 0e  ff 57 d2 55 cd ea e9 be  |..y.K....W.U....|
+000000b0  8b 38 1e 33 b0 6a eb e3  aa 51 52 82 e6 15        |.8.3.j...QR...|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 28 67 ac 20 d9 b6  |..........(g. ..|
-00000010  a9 f0 ec f6 7b 34 31 3a  5e 06 20 0f 5b 32 86 1b  |....{41:^. .[2..|
-00000020  da 5a c5 54 47 d0 ad 4f  95 2c b5 1f 17 3f ec 17  |.Z.TG..O.,...?..|
-00000030  a3 01 fc                                          |...|
+00000000  14 03 03 00 01 01 16 03  03 00 28 1a a3 bb d4 c4  |..........(.....|
+00000010  53 c7 5c 09 8c fb e7 51  41 73 d5 76 ef e6 40 9a  |S.\....QAs.v..@.|
+00000020  06 27 c6 e8 9f 1b 25 f5  d1 7b 39 b7 74 ab e8 83  |.'....%..{9.t...|
+00000030  26 f6 40                                          |&.@|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 1e 00 00 00  00 00 00 00 01 6c 9c 0a  |.............l..|
-00000010  ae 0b 40 57 8b 24 6d 09  77 ae 2f 14 be 06 26 9e  |..@W.$m.w./...&.|
-00000020  0a bf 18 15 03 03 00 1a  00 00 00 00 00 00 00 02  |................|
-00000030  32 50 20 68 3d 05 68 ed  0c ac 7a db 24 21 7e e0  |2P h=.h...z.$!~.|
-00000040  9e f0                                             |..|
+00000000  17 03 03 00 1e 00 00 00  00 00 00 00 01 1c 0d 06  |................|
+00000010  d2 25 8a 06 d9 b4 d6 76  89 1c c6 b7 22 9f 44 63  |.%.....v....".Dc|
+00000020  a3 f9 89 15 03 03 00 1a  00 00 00 00 00 00 00 02  |................|
+00000030  cb 34 e8 4b f7 b1 ab 1a  74 60 2c 2d cf a4 7d 9f  |.4.K....t`,-..}.|
+00000040  f4 b4                                             |..|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-ALPN b/src/crypto/tls/testdata/Client-TLSv12-ALPN
index 358b211fc1..8b9a510c4c 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-ALPN
+++ b/src/crypto/tls/testdata/Client-TLSv12-ALPN
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 8f 00 05 00 05  01 00 00 00 00 00 0a 00  |................|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -18,11 +18,11 @@
 00000100  bb 29 07 30 ff f6 84 af  c4 cf c2 ed 90 99 5f 58  |.).0.........._X|
 00000110  cb 3b 74                                          |.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 66 02 00 00  62 03 03 95 14 55 52 0b  |....f...b....UR.|
-00000010  e7 c1 15 6b dc 19 3b 17  9e bb 6a b7 61 82 dc 59  |...k..;...j.a..Y|
-00000020  d3 a4 7c e1 c3 83 cc e2  e5 56 e0 20 3c 82 0d 54  |..|......V. <..T|
-00000030  2b 78 fe 50 cb 4e c1 69  d7 6f b3 9f ac 2e 27 c8  |+x.P.N.i.o....'.|
-00000040  c6 7a 70 27 1e 14 67 43  4c f1 7d d7 cc a8 00 00  |.zp'..gCL.}.....|
+00000000  16 03 03 00 66 02 00 00  62 03 03 2d b3 e1 a8 44  |....f...b..-...D|
+00000010  c6 3e 20 b9 50 49 ab b8  48 c3 bf d6 f3 7b 2e 0a  |.> .PI..H....{..|
+00000020  8c 49 ba e5 8e 54 5e 02  59 01 75 20 f0 a0 60 c2  |.I...T^.Y.u ..`.|
+00000030  81 df 62 f9 f8 7d 3c 3c  ee 1e 0c 1d c2 11 58 7f  |..b..}<<......X.|
+00000040  e0 dc b1 6c 17 9e 19 60  ca c2 40 84 cc a8 00 00  |...l...`..@.....|
 00000050  1a ff 01 00 01 00 00 0b  00 04 03 00 01 02 00 10  |................|
 00000060  00 09 00 07 06 70 72 6f  74 6f 31 16 03 03 02 59  |.....proto1....Y|
 00000070  0b 00 02 55 00 02 52 00  02 4f 30 82 02 4b 30 82  |...U..R..O0..K0.|
@@ -63,31 +63,31 @@
 000002a0  1c f1 0f a1 d8 40 83 61  c9 4c 72 2b 9d ae db 46  |.....@.a.Lr+...F|
 000002b0  06 06 4d f4 c1 b3 3e c0  d1 bd 42 d4 db fe 3d 13  |..M...>...B...=.|
 000002c0  60 84 5c 21 d3 3b e9 fa  e7 16 03 03 00 ac 0c 00  |`.\!.;..........|
-000002d0  00 a8 03 00 1d 20 c3 e3  43 9c 5d 0f 09 61 ae 18  |..... ..C.]..a..|
-000002e0  66 05 b1 7d c1 9f e5 26  9c a7 97 d6 1f 9a 7c ff  |f..}...&......|.|
-000002f0  8c 34 a1 32 a2 35 08 04  00 80 6c 50 a1 80 d9 20  |.4.2.5....lP... |
-00000300  56 08 da d9 5b 77 4d ad  43 66 71 15 ec fe db 02  |V...[wM.Cfq.....|
-00000310  fb 40 d8 8d 67 22 e2 1b  ec 8d b9 4e ba 65 01 8b  |.@..g".....N.e..|
-00000320  70 e0 83 bc 06 1b 14 8f  07 cf a6 08 58 c3 77 94  |p...........X.w.|
-00000330  0f 94 53 62 54 6c 1f 92  22 9d ae f8 5a ad d5 f3  |..SbTl.."...Z...|
-00000340  8a f7 e6 93 8c 0e 48 1b  23 89 d8 bd e9 5c 50 cd  |......H.#....\P.|
-00000350  07 3d 7e 8e b0 d6 65 44  58 62 03 a1 d9 94 72 f0  |.=~...eDXb....r.|
-00000360  25 a9 e0 c1 be ac 32 05  59 f7 7f 6e 13 23 70 5a  |%.....2.Y..n.#pZ|
-00000370  65 ba a2 d7 da 3c a2 9e  6b 13 16 03 03 00 04 0e  |e....<..k.......|
+000002d0  00 a8 03 00 1d 20 7b 47  ec ef 4d 39 ec 65 b9 7c  |..... {G..M9.e.||
+000002e0  08 da b5 41 0d 62 0b 52  29 24 25 3d 39 21 ed d3  |...A.b.R)$%=9!..|
+000002f0  30 37 0c 15 66 49 08 04  00 80 4b 01 8e 80 78 ed  |07..fI....K...x.|
+00000300  d1 44 e5 98 a4 43 9a 73  b7 dc 67 72 83 29 f3 e3  |.D...C.s..gr.)..|
+00000310  5b 72 ee d6 36 12 db bf  ab d6 86 fd a8 54 a5 a0  |[r..6........T..|
+00000320  0e 76 ca ea a7 f5 f2 e1  87 94 a7 c5 d8 69 b7 58  |.v...........i.X|
+00000330  d2 f0 10 08 8c 08 ac bd  aa 60 f5 45 20 15 77 71  |.........`.E .wq|
+00000340  5a bb 2a 8b 0a 4b a3 08  71 88 82 01 3c bc 54 ba  |Z.*..K..q...<.T.|
+00000350  f4 42 7a 08 64 d7 57 5b  dc ea 6a 72 e1 7d ca 96  |.Bz.d.W[..jr.}..|
+00000360  d9 89 eb 60 9e d2 a4 f5  cb d5 45 d1 4d 09 4e 18  |...`......E.M.N.|
+00000370  a2 4f 0f 59 97 a1 5f 7f  65 4f 16 03 03 00 04 0e  |.O.Y.._.eO......|
 00000380  00 00 00                                          |...|
 >>> Flow 3 (client to server)
 00000000  16 03 03 00 25 10 00 00  21 20 2f e5 7d a3 47 cd  |....%...! /.}.G.|
 00000010  62 43 15 28 da ac 5f bb  29 07 30 ff f6 84 af c4  |bC.(.._.).0.....|
 00000020  cf c2 ed 90 99 5f 58 cb  3b 74 14 03 03 00 01 01  |....._X.;t......|
-00000030  16 03 03 00 20 5e 91 45  7d ab 7c b7 6f 57 a6 d0  |.... ^.E}.|.oW..|
-00000040  17 83 cb 40 1b 76 6b 5e  80 39 03 2f 6d 2f 10 8e  |...@.vk^.9./m/..|
-00000050  74 33 12 54 8d                                    |t3.T.|
+00000030  16 03 03 00 20 b9 f7 58  6f d3 29 b8 41 35 06 b7  |.... ..Xo.).A5..|
+00000040  55 85 c1 f0 63 fe 4f 5f  87 01 cc 67 0b f1 4c b4  |U...c.O_...g..L.|
+00000050  ca 92 bd c0 6d                                    |....m|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 20 f1 3c 7a 28 eb  |.......... .<z(.|
-00000010  0a b1 bf 42 28 de 07 83  76 c6 2c 94 b7 d5 ef f3  |...B(...v.,.....|
-00000020  0b 9c 0c 2e d3 ab 8a a9  03 d2 c0                 |...........|
+00000000  14 03 03 00 01 01 16 03  03 00 20 68 92 93 84 bd  |.......... h....|
+00000010  0e de 33 1b db ca 54 b8  a0 2f 53 c5 76 de d2 c5  |..3...T../S.v...|
+00000020  7a 54 bb db 0c 08 86 79  d2 6c 58                 |zT.....y.lX|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 16 dc f6 18  54 22 e0 9c 08 bf db a8  |........T"......|
-00000010  62 2a 64 9e 06 43 0f 22  18 0e 34 15 03 03 00 12  |b*d..C."..4.....|
-00000020  20 2f f4 76 cd dc 82 eb  30 f9 e0 42 6b 29 16 ed  | /.v....0..Bk)..|
-00000030  7c f0                                             ||.|
+00000000  17 03 03 00 16 79 38 07  9b be 83 44 9a 3e 11 1a  |.....y8....D.>..|
+00000010  99 2f f2 4e 33 84 0b c7  8e ed c3 15 03 03 00 12  |./.N3...........|
+00000020  ca bd 7e 59 04 8c e0 52  80 1e 56 1e af c1 5f 61  |..~Y...R..V..._a|
+00000030  6c 6a                                             |lj|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-ClientCert-ECDSA-ECDSA b/src/crypto/tls/testdata/Client-TLSv12-ClientCert-ECDSA-ECDSA
index e40999fb85..e1fb8a8e76 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-ClientCert-ECDSA-ECDSA
+++ b/src/crypto/tls/testdata/Client-TLSv12-ClientCert-ECDSA-ECDSA
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 59 02 00 00  55 03 03 08 a4 b1 ad 21  |....Y...U......!|
-00000010  3a 60 7a d3 3b 60 67 48  5d de da ff 3f a8 55 a9  |:`z.;`gH]...?.U.|
-00000020  c4 72 69 32 12 c1 d1 4e  d4 78 e1 20 6e 9f ed 1e  |.ri2...N.x. n...|
-00000030  50 9a 31 e2 ae e2 6a f4  01 cc 94 21 25 73 f3 a5  |P.1...j....!%s..|
-00000040  f6 28 b3 c6 6b c1 b3 2d  fc 0c d3 66 c0 09 00 00  |.(..k..-...f....|
+00000000  16 03 03 00 59 02 00 00  55 03 03 36 60 84 12 26  |....Y...U..6`..&|
+00000010  51 e4 32 33 26 ef c3 31  bf ea ac 27 0f c3 fb cb  |Q.23&..1...'....|
+00000020  05 89 af df 56 a9 3f 14  6e 5e 2c 20 ad 6e 60 2d  |....V.?.n^, .n`-|
+00000030  94 aa e5 73 22 eb 68 92  77 1c 6c cb f4 5a 14 f2  |...s".h.w.l..Z..|
+00000040  29 85 88 aa 2e 56 2a ad  80 e1 f0 b1 c0 09 00 00  |)....V*.........|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  03 02 0e 0b 00 02 0a 00  02 07 00 02 04 30 82 02  |.............0..|
 00000070  00 30 82 01 62 02 09 00  b8 bf 2d 47 a0 d2 eb f4  |.0..b.....-G....|
@@ -55,18 +55,18 @@
 00000240  13 83 0d 94 06 bb d4 37  7a f6 ec 7a c9 86 2e dd  |.......7z..z....|
 00000250  d7 11 69 7f 85 7c 56 de  fb 31 78 2b e4 c7 78 0d  |..i..|V..1x+..x.|
 00000260  ae cb be 9e 4e 36 24 31  7b 6a 0f 39 95 12 07 8f  |....N6$1{j.9....|
-00000270  2a 16 03 03 00 b7 0c 00  00 b3 03 00 1d 20 ec f3  |*............ ..|
-00000280  2b 3b be 93 68 53 f2 ab  6c 97 5a fa 9b 8c bf eb  |+;..hS..l.Z.....|
-00000290  37 6f af d7 b8 02 f3 8c  0b f9 75 29 11 32 04 03  |7o........u).2..|
-000002a0  00 8b 30 81 88 02 42 01  9d 90 aa b3 19 d2 9d cf  |..0...B.........|
-000002b0  92 c1 64 05 89 db d0 dd  80 f3 a4 7e 09 ec 36 22  |..d........~..6"|
-000002c0  95 79 c4 36 0e 21 80 7d  4b 72 a5 38 a4 b0 a7 5f  |.y.6.!.}Kr.8..._|
-000002d0  fb ae f7 66 23 82 91 c2  f8 95 df 60 ce dc e8 1a  |...f#......`....|
-000002e0  3f 2b 2c fa 5e 58 67 98  78 02 42 00 fa 88 7f ae  |?+,.^Xg.x.B.....|
-000002f0  00 55 2c a1 c2 47 ed c8  11 74 64 e7 c6 30 63 fb  |.U,..G...td..0c.|
-00000300  bb 42 2a 02 9b 80 60 88  e7 3f af 17 a3 7f 1e f6  |.B*...`..?......|
-00000310  31 9c 1f 8c 89 e5 a0 b1  01 2a 4e d8 d2 1e 9f 11  |1........*N.....|
-00000320  f5 e3 35 38 3e b0 da 30  f1 fb ed e5 d1 16 03 03  |..58>..0........|
+00000270  2a 16 03 03 00 b7 0c 00  00 b3 03 00 1d 20 87 2c  |*............ .,|
+00000280  f2 fd 8e b9 3d 5f 1c c8  bb 04 f5 1e 01 a8 ba d8  |....=_..........|
+00000290  b6 8e 61 78 15 9e 3b a7  da 96 8e 77 d7 70 04 03  |..ax..;....w.p..|
+000002a0  00 8b 30 81 88 02 42 01  dc e2 26 f9 18 39 da 7d  |..0...B...&..9.}|
+000002b0  bd a1 30 c6 6f dd cd aa  a0 4f 71 cf 42 76 61 ba  |..0.o....Oq.Bva.|
+000002c0  e7 9f 09 b5 05 f2 76 c7  db 2a 93 83 3b 0b 3a cf  |......v..*..;.:.|
+000002d0  60 96 24 c8 af de 2c db  5a 29 1c 62 67 28 e9 d7  |`.$...,.Z).bg(..|
+000002e0  57 5f 54 18 cc bf ee d1  d9 02 42 01 04 cf 67 0b  |W_T.......B...g.|
+000002f0  62 2c c2 17 a3 f4 f1 32  0f c5 b9 ae 3b 52 36 2b  |b,.....2....;R6+|
+00000300  f0 c0 60 49 08 e0 bf f5  7c 09 13 e4 b8 ba 08 c7  |..`I....|.......|
+00000310  ea 74 a0 f5 88 45 e4 35  f1 c5 4e df fe 45 bc ca  |.t...E.5..N..E..|
+00000320  9c 5f c8 84 66 13 8f b3  c9 7e b2 ba d6 16 03 03  |._..f....~......|
 00000330  00 3a 0d 00 00 36 03 01  02 40 00 2e 04 03 05 03  |.:...6...@......|
 00000340  06 03 08 07 08 08 08 09  08 0a 08 0b 08 04 08 05  |................|
 00000350  08 06 04 01 05 01 06 01  03 03 02 03 03 01 02 01  |................|
@@ -108,32 +108,32 @@
 00000200  e4 fa cc b1 8a ce e2 23  a0 87 f0 e1 67 51 eb 16  |.......#....gQ..|
 00000210  03 03 00 25 10 00 00 21  20 2f e5 7d a3 47 cd 62  |...%...! /.}.G.b|
 00000220  43 15 28 da ac 5f bb 29  07 30 ff f6 84 af c4 cf  |C.(.._.).0......|
-00000230  c2 ed 90 99 5f 58 cb 3b  74 16 03 03 00 93 0f 00  |...._X.;t.......|
-00000240  00 8f 04 03 00 8b 30 81  88 02 42 01 e6 0a ff de  |......0...B.....|
-00000250  af a6 d2 7a 5f 4e f8 eb  c8 19 74 53 5c e8 bc 2d  |...z_N....tS\..-|
-00000260  72 24 11 d2 11 ec ec cd  a1 9c 3d 10 a2 de f8 8b  |r$........=.....|
-00000270  22 98 d3 33 c2 13 3b 93  89 ae ca a6 a8 94 70 fe  |"..3..;.......p.|
-00000280  76 2f 04 bc ac fb 66 79  3b 76 7f 6d 96 02 42 01  |v/....fy;v.m..B.|
-00000290  df f6 30 14 7c 7e a1 0b  f6 b8 8b d7 75 b8 bd 0e  |..0.|~......u...|
-000002a0  63 8a bd 8b ec 75 70 db  d9 37 d7 53 f3 8b a2 ae  |c....up..7.S....|
-000002b0  60 96 69 74 eb bb 3d a6  9a 7d 46 51 73 ff 78 cf  |`.it..=..}FQs.x.|
-000002c0  7f 49 d9 27 5e 9f f9 d2  11 cc 0e e4 dc 04 fe d5  |.I.'^...........|
-000002d0  d2 14 03 03 00 01 01 16  03 03 00 40 00 00 00 00  |...........@....|
-000002e0  00 00 00 00 00 00 00 00  00 00 00 00 7a db 34 e9  |............z.4.|
-000002f0  98 f8 c1 f0 38 c3 33 22  5c c3 45 b0 a3 10 3c 77  |....8.3"\.E...<w|
-00000300  7f d2 06 c5 f8 13 b6 f4  ee 7e 53 0b 07 0b c3 c9  |.........~S.....|
-00000310  89 9a a9 bb 3b af 79 09  59 ce 10 41              |....;.y.Y..A|
+00000230  c2 ed 90 99 5f 58 cb 3b  74 16 03 03 00 92 0f 00  |...._X.;t.......|
+00000240  00 8e 04 03 00 8a 30 81  87 02 42 01 8f ff aa 8c  |......0...B.....|
+00000250  bd 0c 94 39 34 e5 39 7b  d2 12 26 8e 94 4a fd 68  |...94.9{..&..J.h|
+00000260  f2 f5 5b 30 69 e1 42 3a  74 cd 9a 37 75 5c d2 a6  |..[0i.B:t..7u\..|
+00000270  c9 7b b1 83 c1 d9 c5 55  1a af 3d 19 64 02 43 c0  |.{.....U..=.d.C.|
+00000280  0a 1c 0e ff f4 42 85 fb  d1 aa a2 52 1a 02 41 2f  |.....B.....R..A/|
+00000290  c6 23 d7 37 f1 36 75 0c  0f b4 49 14 c4 b4 d9 28  |.#.7.6u...I....(|
+000002a0  c1 00 2d e4 d6 93 fd a0  f5 59 4e 45 0c a4 28 d4  |..-......YNE..(.|
+000002b0  dc aa 7b 0b 28 29 12 94  f6 db 8c 23 af 81 7e ab  |..{.().....#..~.|
+000002c0  fd 12 ba 11 27 b2 10 87  89 61 9f 5d 6d 18 79 c5  |....'....a.]m.y.|
+000002d0  14 03 03 00 01 01 16 03  03 00 40 00 00 00 00 00  |..........@.....|
+000002e0  00 00 00 00 00 00 00 00  00 00 00 2d 3e 6e 02 fb  |...........->n..|
+000002f0  50 cc 37 62 77 17 08 ef  71 e6 06 23 82 ba 97 b7  |P.7bw...q..#....|
+00000300  0f 38 f9 5e 05 63 4c c9  04 6e bd e4 78 76 32 3b  |.8.^.cL..n..xv2;|
+00000310  3a a7 9b de 30 ca ed fb  17 dc 40                 |:...0.....@|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 40 18 c0 f3 96 7b  |..........@....{|
-00000010  45 91 6d 5b 1c 67 4f 37  74 b7 db 72 45 57 09 25  |E.m[.gO7t..rEW.%|
-00000020  4a 14 68 4d 78 6c c7 15  6a b1 57 e6 ff 53 c4 58  |J.hMxl..j.W..S.X|
-00000030  41 c5 6b 08 3c 5a 8c b9  04 d0 27 62 ee a6 e3 36  |A.k.<Z....'b...6|
-00000040  96 87 db 09 e3 88 d9 a2  0f 7d 9a                 |.........}.|
+00000000  14 03 03 00 01 01 16 03  03 00 40 19 62 a8 82 26  |..........@.b..&|
+00000010  0f 0c 84 b4 31 6a 5d 12  65 dc b9 bc de 5c cb 77  |....1j].e....\.w|
+00000020  5d 04 7e a8 10 1a a5 05  e5 ca 04 68 a2 81 ef f5  |].~........h....|
+00000030  ae 4e bd f1 f3 ba 3f 6a  81 ae 71 9a 2f 31 e2 79  |.N....?j..q./1.y|
+00000040  f1 4d 6c 0e a4 be 4b f7  80 6f 97                 |.Ml...K..o.|
 >>> Flow 5 (client to server)
 00000000  17 03 03 00 30 00 00 00  00 00 00 00 00 00 00 00  |....0...........|
-00000010  00 00 00 00 00 a6 c2 ef  07 bb 38 4a e4 8f 0c 12  |..........8J....|
-00000020  19 1a 96 62 22 57 57 a2  b5 b3 06 70 95 28 a7 f7  |...b"WW....p.(..|
-00000030  0d 42 69 37 7f 15 03 03  00 30 00 00 00 00 00 00  |.Bi7.....0......|
-00000040  00 00 00 00 00 00 00 00  00 00 04 ed 3e 68 40 eb  |............>h@.|
-00000050  a0 7e 57 da 27 e7 f5 e8  6c e5 6d 58 c8 a5 18 47  |.~W.'...l.mX...G|
-00000060  92 5a 43 90 de 07 9e 9a  3b cc                    |.ZC.....;.|
+00000010  00 00 00 00 00 e9 f4 51  fe c1 02 35 de 6e 72 c3  |.......Q...5.nr.|
+00000020  58 f3 01 4a f0 9d f2 34  df fc 0e 93 ef 46 2e 45  |X..J...4.....F.E|
+00000030  5e 60 43 52 33 15 03 03  00 30 00 00 00 00 00 00  |^`CR3....0......|
+00000040  00 00 00 00 00 00 00 00  00 00 ac 82 d6 47 42 40  |.............GB@|
+00000050  d6 6c 6d e3 b6 c6 4a b7  83 ce 6f 3f 33 ad e7 eb  |.lm...J...o?3...|
+00000060  bf 59 82 50 8a 18 e3 13  46 6c                    |.Y.P....Fl|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-ClientCert-ECDSA-RSA b/src/crypto/tls/testdata/Client-TLSv12-ClientCert-ECDSA-RSA
index f5fae453a8..7ae186dd84 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-ClientCert-ECDSA-RSA
+++ b/src/crypto/tls/testdata/Client-TLSv12-ClientCert-ECDSA-RSA
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 59 02 00 00  55 03 03 be ba ac 2a 81  |....Y...U.....*.|
-00000010  33 b1 6e 4d 8b 9b 29 f9  16 86 bc cd b2 03 50 72  |3.nM..).......Pr|
-00000020  91 9a 93 f9 e1 d6 27 55  8b b8 6c 20 84 c2 21 9e  |......'U..l ..!.|
-00000030  60 aa b3 f0 ec 2f 66 0d  59 31 02 08 9e 68 68 c0  |`..../f.Y1...hh.|
-00000040  58 9a 8e 6c 25 ce 4d e3  3f 9d dc 91 c0 2f 00 00  |X..l%.M.?..../..|
+00000000  16 03 03 00 59 02 00 00  55 03 03 2a 52 95 57 8c  |....Y...U..*R.W.|
+00000010  55 3f d7 82 f0 3f af 57  a1 82 86 00 3a 6b c0 07  |U?...?.W....:k..|
+00000020  4d c3 0e 80 cc 37 2d 51  f4 d3 e2 20 4a f6 c9 8a  |M....7-Q... J...|
+00000030  d2 98 4a ff 22 66 11 da  6f 9a a0 17 b9 96 b0 86  |..J."f..o.......|
+00000040  29 e0 39 86 0a 00 42 78  30 60 61 99 c0 2f 00 00  |).9...Bx0`a../..|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  03 02 59 0b 00 02 55 00  02 52 00 02 4f 30 82 02  |..Y...U..R..O0..|
 00000070  4b 30 82 01 b4 a0 03 02  01 02 02 09 00 e8 f0 9d  |K0..............|
@@ -60,17 +60,17 @@
 00000290  77 8d 0c 1c f1 0f a1 d8  40 83 61 c9 4c 72 2b 9d  |w.......@.a.Lr+.|
 000002a0  ae db 46 06 06 4d f4 c1  b3 3e c0 d1 bd 42 d4 db  |..F..M...>...B..|
 000002b0  fe 3d 13 60 84 5c 21 d3  3b e9 fa e7 16 03 03 00  |.=.`.\!.;.......|
-000002c0  ac 0c 00 00 a8 03 00 1d  20 82 89 54 65 64 97 8d  |........ ..Ted..|
-000002d0  e8 63 a2 5b 4f 16 56 7c  cf 8b 0a 75 46 52 7e b6  |.c.[O.V|...uFR~.|
-000002e0  99 2a e9 52 1f 11 46 85  36 08 04 00 80 cd a5 84  |.*.R..F.6.......|
-000002f0  ff 9a 79 b5 04 85 88 fb  1e 1c d6 6b 78 e8 4d a5  |..y........kx.M.|
-00000300  10 38 25 8e 8d de 71 51  b5 fd a6 2a f8 8b 5c 6d  |.8%...qQ...*..\m|
-00000310  1e 88 f7 d8 12 24 ff f7  7e dd 05 1c bf 71 7d 4f  |.....$..~....q}O|
-00000320  26 2f 2e 27 d8 e1 a8 8b  d2 42 2b a6 d9 4e e6 60  |&/.'.....B+..N.`|
-00000330  48 57 38 5d 3b f3 94 74  2c 8f ba e0 84 54 1c c0  |HW8];..t,....T..|
-00000340  10 51 a0 31 1a d0 ec 72  01 f1 d3 65 73 c7 40 25  |.Q.1...r...es.@%|
-00000350  af cd 10 18 29 2c 1a 52  e0 c9 a6 de 85 8c 96 e6  |....),.R........|
-00000360  7d 85 0a 64 86 59 39 25  8f 8c 36 4c 37 16 03 03  |}..d.Y9%..6L7...|
+000002c0  ac 0c 00 00 a8 03 00 1d  20 fa 3a 8f b7 50 10 38  |........ .:..P.8|
+000002d0  04 9d fb c4 e4 76 6d 93  86 b2 8a d7 5b 8f 8d 45  |.....vm.....[..E|
+000002e0  41 b7 ba 54 bc cc 7b 07  3c 08 04 00 80 a1 14 65  |A..T..{.<......e|
+000002f0  f6 48 29 ba 08 86 52 65  dd 08 ef b8 b8 77 ef fd  |.H)...Re.....w..|
+00000300  8a ca dc 37 f8 69 fa 04  69 73 84 07 b2 45 f0 a2  |...7.i..is...E..|
+00000310  8c 69 f7 7c 4c 5c 95 c5  66 80 ad 93 04 67 4b 3d  |.i.|L\..f....gK=|
+00000320  f8 53 a9 33 b3 c0 40 17  62 34 f0 f3 1e d2 23 93  |.S.3..@.b4....#.|
+00000330  29 52 bc f4 f0 72 58 b9  76 9c 7b 54 b0 d5 d1 ab  |)R...rX.v.{T....|
+00000340  b3 1b ae f7 f3 46 6a 07  7f f4 91 ee 46 d6 85 43  |.....Fj.....F..C|
+00000350  ea c6 f9 f5 47 89 85 39  72 35 af b4 03 e9 a2 ea  |....G..9r5......|
+00000360  a8 19 09 ea b3 d2 c2 38  59 65 d1 2c 18 16 03 03  |.......8Ye.,....|
 00000370  00 3a 0d 00 00 36 03 01  02 40 00 2e 04 03 05 03  |.:...6...@......|
 00000380  06 03 08 07 08 08 08 09  08 0a 08 0b 08 04 08 05  |................|
 00000390  08 06 04 01 05 01 06 01  03 03 02 03 03 01 02 01  |................|
@@ -112,28 +112,28 @@
 00000200  e4 fa cc b1 8a ce e2 23  a0 87 f0 e1 67 51 eb 16  |.......#....gQ..|
 00000210  03 03 00 25 10 00 00 21  20 2f e5 7d a3 47 cd 62  |...%...! /.}.G.b|
 00000220  43 15 28 da ac 5f bb 29  07 30 ff f6 84 af c4 cf  |C.(.._.).0......|
-00000230  c2 ed 90 99 5f 58 cb 3b  74 16 03 03 00 92 0f 00  |...._X.;t.......|
-00000240  00 8e 04 03 00 8a 30 81  87 02 41 72 16 75 7d 08  |......0...Ar.u}.|
-00000250  42 7b 33 e7 59 51 ef 3c  54 e7 81 e4 10 31 ab 5d  |B{3.YQ.<T....1.]|
-00000260  df 17 52 e0 a9 9f b5 43  e0 33 0e 52 b2 19 a2 a8  |..R....C.3.R....|
-00000270  0b b9 8b e3 0b 51 1d 65  c9 7b 7c 67 66 d4 98 77  |.....Q.e.{|gf..w|
-00000280  34 06 07 fc 8f 84 85 36  c3 fd f9 12 02 42 01 ad  |4......6.....B..|
-00000290  a7 25 ed c2 e8 2d c0 a3  12 0b 79 b2 32 e2 c3 70  |.%...-....y.2..p|
-000002a0  2b 5d 99 1b 24 45 60 68  8b b3 28 5c 96 1a 26 89  |+]..$E`h..(\..&.|
-000002b0  24 53 20 f5 fc 6f 98 b1  64 0b ba f5 ad ea 1e 33  |$S ..o..d......3|
-000002c0  4f 64 fd 43 37 80 24 f0  7d e3 7d 63 76 7e 60 e3  |Od.C7.$.}.}cv~`.|
-000002d0  14 03 03 00 01 01 16 03  03 00 28 00 00 00 00 00  |..........(.....|
-000002e0  00 00 00 27 0b ff 3a 92  88 b6 86 86 0e c2 f5 94  |...'..:.........|
-000002f0  d5 29 a4 6d 95 12 e1 d8  ec d9 a4 3c 1c db 52 76  |.).m.......<..Rv|
-00000300  2a 72 29                                          |*r)|
+00000230  c2 ed 90 99 5f 58 cb 3b  74 16 03 03 00 91 0f 00  |...._X.;t.......|
+00000240  00 8d 04 03 00 89 30 81  86 02 41 63 34 72 b4 70  |......0...Ac4r.p|
+00000250  45 46 9c 3c 06 2c f5 ab  d4 dd a7 91 69 9c 65 0f  |EF.<.,......i.e.|
+00000260  4b d9 2d 90 3d d1 f2 4d  2a 6a 43 4f a7 fd b5 22  |K.-.=..M*jCO..."|
+00000270  83 61 e2 14 33 8c bc 8a  81 52 a1 f4 69 a7 12 c9  |.a..3....R..i...|
+00000280  c3 28 69 85 6d c1 b0 5d  d3 5e ac 4e 02 41 35 cd  |.(i.m..].^.N.A5.|
+00000290  3b c3 f6 ea 9e df 2a a1  ea 80 55 40 d2 13 d3 ff  |;.....*...U@....|
+000002a0  b2 59 bb a0 c7 10 67 6e  9b dc 6c 3c 97 08 07 e0  |.Y....gn..l<....|
+000002b0  db da 79 6b 0e 6c a0 23  13 b1 02 32 ab ee 62 69  |..yk.l.#...2..bi|
+000002c0  f9 d5 7f 24 2e 26 94 36  a4 36 53 63 dd 90 20 14  |...$.&.6.6Sc.. .|
+000002d0  03 03 00 01 01 16 03 03  00 28 00 00 00 00 00 00  |.........(......|
+000002e0  00 00 a7 30 0e b0 f7 ba  51 35 c9 4c c2 24 90 5e  |...0....Q5.L.$.^|
+000002f0  b2 59 57 5d 96 9d ad d1  1e 7d b0 35 09 9c c5 49  |.YW].....}.5...I|
+00000300  bd 82                                             |..|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 28 b8 e9 dd 30 75  |..........(...0u|
-00000010  40 7d 71 76 db 9a 95 92  81 02 3a 9e 36 d5 15 ca  |@}qv......:.6...|
-00000020  5d 63 a1 0f 8c 53 c9 1c  37 56 b2 0d 54 15 a2 dc  |]c...S..7V..T...|
-00000030  03 d6 2e                                          |...|
+00000000  14 03 03 00 01 01 16 03  03 00 28 09 ff 53 e8 0f  |..........(..S..|
+00000010  ad 86 30 ca 96 54 da 72  45 13 7a cd 51 f6 b3 a5  |..0..T.rE.z.Q...|
+00000020  27 4c 7c 26 81 6d 76 6f  19 8e f3 13 77 49 59 73  |'L|&.mvo....wIYs|
+00000030  4e 98 3e                                          |N.>|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 1e 00 00 00  00 00 00 00 01 01 85 96  |................|
-00000010  67 b2 4b d3 e3 27 80 9f  2d a8 f4 bf 47 91 58 6e  |g.K..'..-...G.Xn|
-00000020  47 d8 98 15 03 03 00 1a  00 00 00 00 00 00 00 02  |G...............|
-00000030  36 54 82 d1 a2 0f 2a c3  53 f6 09 d0 5c 78 46 97  |6T....*.S...\xF.|
-00000040  20 41                                             | A|
+00000000  17 03 03 00 1e 00 00 00  00 00 00 00 01 99 7b 4c  |..............{L|
+00000010  1d 0a b1 89 0d ac fa a7  39 eb 9a ff 8f 06 60 d1  |........9.....`.|
+00000020  88 e8 ef 15 03 03 00 1a  00 00 00 00 00 00 00 02  |................|
+00000030  99 42 7f c8 35 79 f3 a0  10 5c 05 25 c1 ac ab aa  |.B..5y...\.%....|
+00000040  d5 9e                                             |..|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-ClientCert-Ed25519 b/src/crypto/tls/testdata/Client-TLSv12-ClientCert-Ed25519
index e415b126e5..9ecd8e3ac3 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-ClientCert-Ed25519
+++ b/src/crypto/tls/testdata/Client-TLSv12-ClientCert-Ed25519
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 59 02 00 00  55 03 03 1c 50 4e 50 35  |....Y...U...PNP5|
-00000010  51 02 a9 62 ba 82 a5 d3  fa 40 4e f3 28 9b 50 a6  |Q..b.....@N.(.P.|
-00000020  f0 75 30 e9 fe be a3 42  1d 1c f5 20 9e 88 46 57  |.u0....B... ..FW|
-00000030  c5 b4 a3 a3 fc 88 bb e0  1c 5e ea 77 a0 75 93 5a  |.........^.w.u.Z|
-00000040  6d 4c c7 57 6f 3a 05 af  3f 3f ac 75 cc a8 00 00  |mL.Wo:..??.u....|
+00000000  16 03 03 00 59 02 00 00  55 03 03 5c 37 b1 d2 6c  |....Y...U..\7..l|
+00000010  bc dd 26 8c 4e f7 04 80  09 3c fd 76 23 d4 52 16  |..&.N....<.v#.R.|
+00000020  df 0e 79 ab f4 cf 8c f3  61 31 c6 20 7d 7a 1d 8f  |..y.....a1. }z..|
+00000030  09 3e 2b 25 04 7f 0f 0a  a7 0c 03 fd 9c 09 f3 5d  |.>+%...........]|
+00000040  96 75 f8 da 5b 6b 1b fb  ca d7 ec 7a cc a8 00 00  |.u..[k.....z....|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  03 02 59 0b 00 02 55 00  02 52 00 02 4f 30 82 02  |..Y...U..R..O0..|
 00000070  4b 30 82 01 b4 a0 03 02  01 02 02 09 00 e8 f0 9d  |K0..............|
@@ -60,17 +60,17 @@
 00000290  77 8d 0c 1c f1 0f a1 d8  40 83 61 c9 4c 72 2b 9d  |w.......@.a.Lr+.|
 000002a0  ae db 46 06 06 4d f4 c1  b3 3e c0 d1 bd 42 d4 db  |..F..M...>...B..|
 000002b0  fe 3d 13 60 84 5c 21 d3  3b e9 fa e7 16 03 03 00  |.=.`.\!.;.......|
-000002c0  ac 0c 00 00 a8 03 00 1d  20 82 c1 f5 7b 68 eb 7a  |........ ...{h.z|
-000002d0  cf 02 c9 95 28 4b 31 76  a9 84 93 a9 1f 5b f4 2a  |....(K1v.....[.*|
-000002e0  5c a5 31 94 5f f0 e0 ed  2e 08 04 00 80 7a 99 38  |\.1._........z.8|
-000002f0  7f d0 25 4b bf a9 e0 2b  db ce 17 9d 30 4b 82 9e  |..%K...+....0K..|
-00000300  b1 50 84 fc dd b0 a8 5c  39 20 00 40 5b 92 dc 7c  |.P.....\9 .@[..||
-00000310  25 3b 53 7d 5a 4b ad 05  6f 3a 4f e5 84 b6 3a e2  |%;S}ZK..o:O...:.|
-00000320  fb bf cb c8 94 39 a5 28  ad c8 5f 94 53 90 0e 61  |.....9.(.._.S..a|
-00000330  af f2 92 2c 3b ec 3c bf  1d d3 8b a5 65 58 5b bf  |...,;.<.....eX[.|
-00000340  5a 21 3d cd 40 7c 9e 1d  e9 62 3c 67 71 7c ec b4  |Z!=.@|...b<gq|..|
-00000350  25 d0 4a 6a 85 1d c4 e8  44 d6 25 1a 2c 29 ae d7  |%.Jj....D.%.,)..|
-00000360  d7 24 fb 5a 62 f7 50 52  12 1b c7 3e b0 16 03 03  |.$.Zb.PR...>....|
+000002c0  ac 0c 00 00 a8 03 00 1d  20 aa c7 43 e7 1e 3b 2b  |........ ..C..;+|
+000002d0  28 c2 68 aa 83 cc 85 63  68 c4 b8 4d fb 18 fa b9  |(.h....ch..M....|
+000002e0  3e 9a f2 7c 04 33 7f 48  6b 08 04 00 80 28 28 c7  |>..|.3.Hk....((.|
+000002f0  84 79 65 11 07 43 7a ce  f1 d6 cb 0e fe 6a 24 2c  |.ye..Cz......j$,|
+00000300  f3 f0 e5 9c 80 a6 c7 41  c7 51 f2 84 be 6e 58 df  |.......A.Q...nX.|
+00000310  f2 d2 d4 d9 62 08 c8 35  75 b9 8e 49 c2 98 b0 9d  |....b..5u..I....|
+00000320  32 aa db bf 03 c1 61 83  f7 20 d7 ec 07 27 5e 45  |2.....a.. ...'^E|
+00000330  dc d6 92 4c a1 4f 4e 7c  53 c5 ca 42 48 40 0f 83  |...L.ON|S..BH@..|
+00000340  fc 9d 60 a1 7c 43 d1 f5  f8 3f fe 50 3f d0 03 bc  |..`.|C...?.P?...|
+00000350  3e 8b ac 69 8f ae b6 9a  c8 d4 98 84 30 f1 79 9b  |>..i........0.y.|
+00000360  af 5d 4e 41 2a 7c 46 22  df 46 42 74 f6 16 03 03  |.]NA*|F".FBt....|
 00000370  00 3a 0d 00 00 36 03 01  02 40 00 2e 04 03 05 03  |.:...6...@......|
 00000380  06 03 08 07 08 08 08 09  08 0a 08 0b 08 04 08 05  |................|
 00000390  08 06 04 01 05 01 06 01  03 03 02 03 03 01 02 01  |................|
@@ -100,20 +100,20 @@
 00000140  08 16 03 03 00 25 10 00  00 21 20 2f e5 7d a3 47  |.....%...! /.}.G|
 00000150  cd 62 43 15 28 da ac 5f  bb 29 07 30 ff f6 84 af  |.bC.(.._.).0....|
 00000160  c4 cf c2 ed 90 99 5f 58  cb 3b 74 16 03 03 00 48  |......_X.;t....H|
-00000170  0f 00 00 44 08 07 00 40  af a6 03 14 53 7a 4f 75  |...D...@....SzOu|
-00000180  9d cc 2f e3 e7 2a 51 16  16 b0 1d 28 e0 2a 59 f0  |../..*Q....(.*Y.|
-00000190  3c df cc 18 dd b8 ef d1  9f 9d 03 8e 59 00 27 d1  |<...........Y.'.|
-000001a0  39 2f 3b 33 53 1f b2 f0  22 1d 06 f6 50 0b a7 98  |9/;3S..."...P...|
-000001b0  cc fa 78 53 bf 8e ff 0b  14 03 03 00 01 01 16 03  |..xS............|
-000001c0  03 00 20 e5 81 3e a3 34  29 52 14 19 49 cf 04 82  |.. ..>.4)R..I...|
-000001d0  8b e7 83 aa 6c db 96 ec  97 29 b4 a3 db 87 21 2e  |....l....)....!.|
-000001e0  a5 c0 66                                          |..f|
+00000170  0f 00 00 44 08 07 00 40  07 e0 a5 14 ca cf 31 d7  |...D...@......1.|
+00000180  99 96 c7 c7 d8 d8 a7 f7  82 e7 c6 c0 12 5d 91 5a  |.............].Z|
+00000190  bc eb 4a c0 59 c6 5b 7b  03 df 2a ff 48 ca 55 d8  |..J.Y.[{..*.H.U.|
+000001a0  3e 10 c1 94 2c 03 b2 e7  16 83 4d e5 5a 3d 8a 48  |>...,.....M.Z=.H|
+000001b0  2f e5 c4 59 de 6f 47 05  14 03 03 00 01 01 16 03  |/..Y.oG.........|
+000001c0  03 00 20 ae 35 81 df 88  0e a3 2e 67 3f 33 02 3d  |.. .5......g?3.=|
+000001d0  b8 7e 47 db cb be 05 c7  ba 43 dc 5b 52 3b 4b ca  |.~G......C.[R;K.|
+000001e0  c0 dc 78                                          |..x|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 20 84 67 d4 ce cf  |.......... .g...|
-00000010  fb 54 2c dc f7 53 31 8a  aa 03 60 37 3d 33 f2 79  |.T,..S1...`7=3.y|
-00000020  d0 65 2e 3f 0e f9 1a d3  6e 6d 8e                 |.e.?....nm.|
+00000000  14 03 03 00 01 01 16 03  03 00 20 63 23 49 7c 83  |.......... c#I|.|
+00000010  1a 8b cd 48 02 e7 86 4d  ab 8b 3c 4f 40 27 a6 48  |...H...M..<O@'.H|
+00000020  95 d5 80 8a 7a e0 56 0b  e6 34 70                 |....z.V..4p|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 16 e5 b7 4c  92 05 fc 81 cf 11 ef cd  |.......L........|
-00000010  0f 4b df ef a1 54 ae 26  4e ec aa 15 03 03 00 12  |.K...T.&N.......|
-00000020  0a f3 5b 06 63 84 a6 eb  d4 73 94 db fe d8 e0 ae  |..[.c....s......|
-00000030  d6 fc                                             |..|
+00000000  17 03 03 00 16 aa b4 5b  75 04 96 c5 4a e3 2a fb  |.......[u...J.*.|
+00000010  be 29 32 9e c5 e4 15 bd  38 df 69 15 03 03 00 12  |.)2.....8.i.....|
+00000020  50 4d b6 c0 95 e6 5a db  f2 b7 ea 02 cb 3e 01 ea  |PM....Z......>..|
+00000030  35 0d                                             |5.|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-ClientCert-RSA-AES256-GCM-SHA384 b/src/crypto/tls/testdata/Client-TLSv12-ClientCert-RSA-AES256-GCM-SHA384
index 3975b072c9..35ec3471e6 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-ClientCert-RSA-AES256-GCM-SHA384
+++ b/src/crypto/tls/testdata/Client-TLSv12-ClientCert-RSA-AES256-GCM-SHA384
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 59 02 00 00  55 03 03 d4 20 b3 4c 6a  |....Y...U... .Lj|
-00000010  69 44 3f f7 ab 15 35 85  ca 71 02 b0 70 18 8e d6  |iD?...5..q..p...|
-00000020  61 d5 34 08 42 de cf a1  57 32 96 20 8c b4 72 dd  |a.4.B...W2. ..r.|
-00000030  63 93 e6 13 9d 4a ec 75  d9 a1 a6 9e 5e 02 f5 63  |c....J.u....^..c|
-00000040  29 1a 78 9f 94 9f 6c 58  b5 91 ae 63 c0 30 00 00  |).x...lX...c.0..|
+00000000  16 03 03 00 59 02 00 00  55 03 03 16 f7 21 0a 97  |....Y...U....!..|
+00000010  89 11 ec c3 c4 05 41 79  72 60 40 6d ec 78 90 26  |......Ayr`@m.x.&|
+00000020  0c a4 f8 5d d5 27 e9 70  bb 40 21 20 b0 bb 98 5d  |...].'.p.@! ...]|
+00000030  a2 27 08 1e 4a fe f9 e1  cf a5 79 d3 eb c6 40 f7  |.'..J.....y...@.|
+00000040  ee 4f 0b fa a1 bb 09 62  07 24 30 b7 c0 30 00 00  |.O.....b.$0..0..|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  03 02 59 0b 00 02 55 00  02 52 00 02 4f 30 82 02  |..Y...U..R..O0..|
 00000070  4b 30 82 01 b4 a0 03 02  01 02 02 09 00 e8 f0 9d  |K0..............|
@@ -60,17 +60,17 @@
 00000290  77 8d 0c 1c f1 0f a1 d8  40 83 61 c9 4c 72 2b 9d  |w.......@.a.Lr+.|
 000002a0  ae db 46 06 06 4d f4 c1  b3 3e c0 d1 bd 42 d4 db  |..F..M...>...B..|
 000002b0  fe 3d 13 60 84 5c 21 d3  3b e9 fa e7 16 03 03 00  |.=.`.\!.;.......|
-000002c0  ac 0c 00 00 a8 03 00 1d  20 a2 bd 95 3e 0c 9f ad  |........ ...>...|
-000002d0  11 59 e0 6a c1 21 0c 6c  86 cc f1 ce bd a0 30 5d  |.Y.j.!.l......0]|
-000002e0  53 1e 75 f9 55 af 49 7b  31 08 04 00 80 d4 8b 11  |S.u.U.I{1.......|
-000002f0  ca 22 14 79 a3 e8 b6 c7  d0 d6 1b 17 42 93 47 30  |.".y........B.G0|
-00000300  ab 50 0e c9 0c 92 88 96  b4 63 4e 4e ac 7f dd c8  |.P.......cNN....|
-00000310  8f 85 07 5b 95 c5 0a c0  4e 6d 4f 51 ba d8 d7 db  |...[....NmOQ....|
-00000320  14 70 80 4f 68 d9 b4 39  e7 48 27 21 76 4c 79 a4  |.p.Oh..9.H'!vLy.|
-00000330  60 91 d7 2f 75 69 04 1a  da 71 ff b8 4d 78 d8 e7  |`../ui...q..Mx..|
-00000340  ca f2 f2 1e 71 21 b3 a0  44 a7 6c 99 16 a1 c9 f8  |....q!..D.l.....|
-00000350  f0 de e8 99 12 7b 3d a2  e3 15 fa 63 62 e9 1b 72  |.....{=....cb..r|
-00000360  c8 bb 27 38 4a 48 66 1d  dd fb ef 6f d1 16 03 03  |..'8JHf....o....|
+000002c0  ac 0c 00 00 a8 03 00 1d  20 39 1f 7e 66 c8 20 24  |........ 9.~f. $|
+000002d0  cf 8e 51 f6 bf 2a 01 a9  3b 51 19 f1 9d 32 b6 fa  |..Q..*..;Q...2..|
+000002e0  05 3b 90 c9 a3 8b 49 92  2a 08 04 00 80 da 65 ad  |.;....I.*.....e.|
+000002f0  fa f9 d5 f6 d7 13 34 d2  ab ac ea 57 37 69 c6 b1  |......4....W7i..|
+00000300  91 ee 89 b7 04 6b 17 fb  80 23 df df ef a1 62 9b  |.....k...#....b.|
+00000310  e4 0a 4e ca b0 35 b2 d3  2a cf 4f c1 e3 d9 37 78  |..N..5..*.O...7x|
+00000320  aa c8 59 f8 25 c7 43 51  19 6c c7 50 90 a4 2c 92  |..Y.%.CQ.l.P..,.|
+00000330  01 0e 8d ff f0 88 4b af  1d 03 ee 51 8b 18 e4 ee  |......K....Q....|
+00000340  35 48 16 e7 4c 26 1d d8  af 91 b1 75 38 b5 65 42  |5H..L&.....u8.eB|
+00000350  8e 60 c7 f9 25 a7 85 35  72 41 6f f6 c4 61 1d c0  |.`..%..5rAo..a..|
+00000360  c8 cf da ae 31 5e 2e d6  9c ca f1 d6 31 16 03 03  |....1^......1...|
 00000370  00 3a 0d 00 00 36 03 01  02 40 00 2e 04 03 05 03  |.:...6...@......|
 00000380  06 03 08 07 08 08 08 09  08 0a 08 0b 08 04 08 05  |................|
 00000390  08 06 04 01 05 01 06 01  03 03 02 03 03 01 02 01  |................|
@@ -112,26 +112,26 @@
 00000200  e5 35 16 03 03 00 25 10  00 00 21 20 2f e5 7d a3  |.5....%...! /.}.|
 00000210  47 cd 62 43 15 28 da ac  5f bb 29 07 30 ff f6 84  |G.bC.(.._.).0...|
 00000220  af c4 cf c2 ed 90 99 5f  58 cb 3b 74 16 03 03 00  |......._X.;t....|
-00000230  88 0f 00 00 84 08 04 00  80 2e bf 05 22 82 a7 d6  |............"...|
-00000240  e9 08 ff 9b 10 d3 4a 6c  c4 73 5c 78 88 05 0c 15  |......Jl.s\x....|
-00000250  b7 8c 78 49 64 2d 58 67  ef 8f db c0 67 fa 32 6e  |..xId-Xg....g.2n|
-00000260  65 45 90 a0 69 5c fb ba  e0 16 1c d4 81 1d 24 89  |eE..i\........$.|
-00000270  35 27 14 15 19 0b 86 ee  6a f2 b4 a5 27 61 5f 1f  |5'......j...'a_.|
-00000280  cc 47 7c 01 ed a9 ff ed  61 45 3f 53 1c 82 c8 cd  |.G|.....aE?S....|
-00000290  48 e4 89 82 12 d7 d2 ff  fa 32 b3 e6 9d ce 75 75  |H........2....uu|
-000002a0  d1 cd b2 a8 56 a6 a6 63  da 8d ed 27 13 01 9a 56  |....V..c...'...V|
-000002b0  a2 26 b4 6c af 27 f6 4f  1b 14 03 03 00 01 01 16  |.&.l.'.O........|
-000002c0  03 03 00 28 00 00 00 00  00 00 00 00 f0 e8 32 33  |...(..........23|
-000002d0  50 df 73 17 3c 58 f2 c9  30 2e 5d e9 00 4f 4b 33  |P.s.<X..0.]..OK3|
-000002e0  22 12 f7 f0 62 d0 62 3e  ed 36 b8 58              |"...b.b>.6.X|
+00000230  88 0f 00 00 84 08 04 00  80 56 1c 58 51 d8 51 bc  |.........V.XQ.Q.|
+00000240  8e 4b b8 24 64 85 81 d2  26 9b 38 bf 13 19 e7 0a  |.K.$d...&.8.....|
+00000250  f7 94 e8 b5 94 bf 6f ae  f2 07 1a 46 24 38 7b 8b  |......o....F$8{.|
+00000260  2f a6 da 91 1a 5f 7d 3f  cf c4 1b 14 9c 44 8e 6a  |/...._}?.....D.j|
+00000270  6b c8 c4 60 c6 15 e6 f2  c0 45 e7 46 c4 32 06 b1  |k..`.....E.F.2..|
+00000280  46 5e 25 1d ba f7 d8 81  b0 6b 50 40 81 b1 93 89  |F^%......kP@....|
+00000290  cb 90 ae 10 b1 db 08 99  e6 0e 8f 17 0f 4d a7 a7  |.............M..|
+000002a0  f5 42 8a be ca d6 75 c4  32 44 22 ab df cf 22 f7  |.B....u.2D"...".|
+000002b0  58 d9 9f 52 c2 04 c0 81  59 14 03 03 00 01 01 16  |X..R....Y.......|
+000002c0  03 03 00 28 00 00 00 00  00 00 00 00 eb 5a 97 41  |...(.........Z.A|
+000002d0  1d da 2b 81 da 7a b7 9a  f8 5e fe 50 75 e5 a4 6a  |..+..z...^.Pu..j|
+000002e0  21 90 b7 3d 4e bc 44 cf  86 8f cd c3              |!..=N.D.....|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 28 14 ce b1 86 0e  |..........(.....|
-00000010  9f ce 73 25 44 b7 3e a9  25 db a8 93 d9 39 33 75  |..s%D.>.%....93u|
-00000020  2f a9 7f 97 6a 76 28 fe  e2 84 5f 1e 84 66 b4 c8  |/...jv(..._..f..|
-00000030  45 e7 64                                          |E.d|
+00000000  14 03 03 00 01 01 16 03  03 00 28 93 a5 d4 a8 16  |..........(.....|
+00000010  4e a2 b2 c3 b9 ce dd 0e  57 49 7c eb 92 e4 e7 e3  |N.......WI|.....|
+00000020  a8 55 3a 56 54 53 92 b8  ce 15 e3 c3 c2 da 52 01  |.U:VTS........R.|
+00000030  6f 35 fd                                          |o5.|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 1e 00 00 00  00 00 00 00 01 3b 17 73  |.............;.s|
-00000010  78 d6 3a b4 6d 3a 61 52  f6 a5 8c dd 18 3e ff 04  |x.:.m:aR.....>..|
-00000020  d9 3f 22 15 03 03 00 1a  00 00 00 00 00 00 00 02  |.?".............|
-00000030  32 8d 5d 07 14 a9 d2 1c  dd 1e 2f 3d 89 a9 8f 1d  |2.]......./=....|
-00000040  08 0f                                             |..|
+00000000  17 03 03 00 1e 00 00 00  00 00 00 00 01 5b 20 4f  |.............[ O|
+00000010  e9 3f 09 28 6e 88 5d 1d  57 90 2c 35 74 37 d1 df  |.?.(n.].W.,5t7..|
+00000020  aa 39 9b 15 03 03 00 1a  00 00 00 00 00 00 00 02  |.9..............|
+00000030  bb e3 77 62 e5 c9 78 f4  a5 09 93 b0 20 9a 1b a4  |..wb..x..... ...|
+00000040  48 44                                             |HD|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-ClientCert-RSA-ECDSA b/src/crypto/tls/testdata/Client-TLSv12-ClientCert-RSA-ECDSA
index 2d608a7824..110f689f8e 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-ClientCert-RSA-ECDSA
+++ b/src/crypto/tls/testdata/Client-TLSv12-ClientCert-RSA-ECDSA
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 59 02 00 00  55 03 03 3c ba b1 d8 8d  |....Y...U..<....|
-00000010  f5 52 f4 a4 70 fc 12 54  20 85 eb 23 bc b8 0b e0  |.R..p..T ..#....|
-00000020  80 b6 ab 9b c5 34 84 57  bc ae 95 20 e3 51 8d 40  |.....4.W... .Q.@|
-00000030  93 cc 9f e4 fd 77 82 c8  12 54 6a 23 08 db ff e5  |.....w...Tj#....|
-00000040  87 8d 72 41 60 51 6a 11  5f 0a 9a d2 c0 09 00 00  |..rA`Qj._.......|
+00000000  16 03 03 00 59 02 00 00  55 03 03 68 dc 2e 5e 8e  |....Y...U..h..^.|
+00000010  80 38 0e 65 a3 b0 f6 a0  c0 8f 1e 62 ef 1d 5a 54  |.8.e.......b..ZT|
+00000020  82 dc 9c 68 77 88 57 dd  f3 9d c2 20 4e 56 dd 44  |...hw.W.... NV.D|
+00000030  a0 46 67 4c 09 2b d5 e6  fe 15 fb b3 8e 19 ef a3  |.FgL.+..........|
+00000040  8e 5c a9 70 00 cf 96 d7  3b 8b c9 64 c0 09 00 00  |.\.p....;..d....|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  03 02 0e 0b 00 02 0a 00  02 07 00 02 04 30 82 02  |.............0..|
 00000070  00 30 82 01 62 02 09 00  b8 bf 2d 47 a0 d2 eb f4  |.0..b.....-G....|
@@ -55,23 +55,23 @@
 00000240  13 83 0d 94 06 bb d4 37  7a f6 ec 7a c9 86 2e dd  |.......7z..z....|
 00000250  d7 11 69 7f 85 7c 56 de  fb 31 78 2b e4 c7 78 0d  |..i..|V..1x+..x.|
 00000260  ae cb be 9e 4e 36 24 31  7b 6a 0f 39 95 12 07 8f  |....N6$1{j.9....|
-00000270  2a 16 03 03 00 b7 0c 00  00 b3 03 00 1d 20 86 f3  |*............ ..|
-00000280  1e c5 fb 1f 91 44 0e e5  e4 3e 0a cd 75 a2 fb 4c  |.....D...>..u..L|
-00000290  a2 b9 07 f7 33 ce cc cd  61 a5 8c ba 6a 35 04 03  |....3...a...j5..|
-000002a0  00 8b 30 81 88 02 42 01  f4 8d 4f 3e c8 73 b5 b4  |..0...B...O>.s..|
-000002b0  b5 2b ac 2a 27 68 56 a1  45 ce b6 1d c6 37 ce de  |.+.*'hV.E....7..|
-000002c0  bd 96 90 5e e2 1c c8 84  b2 84 57 25 81 d4 c3 7a  |...^......W%...z|
-000002d0  db b2 3d 24 2b 17 3a 4a  7e 92 1a bb 0c fb b6 05  |..=$+.:J~.......|
-000002e0  cd 0e 85 4c 3d 4b 24 2a  2a 02 42 00 f6 91 d6 82  |...L=K$**.B.....|
-000002f0  9e 81 98 5f 64 59 ce 16  85 fc 65 19 0c 50 ca ea  |..._dY....e..P..|
-00000300  8a ba 1e 61 a8 71 cf 2c  eb 94 24 ac 34 75 6e 5c  |...a.q.,..$.4un\|
-00000310  dc 92 ba b8 bd 42 75 ef  6d 67 5f 06 5c e3 6c c2  |.....Bu.mg_.\.l.|
-00000320  aa 5e 29 25 66 00 68 c8  5d 9c 6f bb e0 16 03 03  |.^)%f.h.].o.....|
-00000330  00 3a 0d 00 00 36 03 01  02 40 00 2e 04 03 05 03  |.:...6...@......|
-00000340  06 03 08 07 08 08 08 09  08 0a 08 0b 08 04 08 05  |................|
-00000350  08 06 04 01 05 01 06 01  03 03 02 03 03 01 02 01  |................|
-00000360  03 02 02 02 04 02 05 02  06 02 00 00 16 03 03 00  |................|
-00000370  04 0e 00 00 00                                    |.....|
+00000270  2a 16 03 03 00 b6 0c 00  00 b2 03 00 1d 20 24 d0  |*............ $.|
+00000280  e5 11 4c 95 2c 96 58 62  01 df 20 c8 24 ce 29 a2  |..L.,.Xb.. .$.).|
+00000290  1a 3e 97 e2 df 29 49 e6  3a e8 c2 d3 72 49 04 03  |.>...)I.:...rI..|
+000002a0  00 8a 30 81 87 02 41 71  15 8d 50 f6 69 40 d7 cd  |..0...Aq..P.i@..|
+000002b0  da c9 c3 ee 37 c2 5f c3  89 62 23 e0 ef 37 f9 9e  |....7._..b#..7..|
+000002c0  2a 26 85 10 56 28 08 de  49 3b fa 03 f3 14 4b 3a  |*&..V(..I;....K:|
+000002d0  b2 3d de 84 d2 08 8d 4e  59 3e 80 8f 6a 44 af 6f  |.=.....NY>..jD.o|
+000002e0  be ee 08 ae 35 40 42 bc  02 42 00 f3 e9 89 a5 7f  |....5@B..B......|
+000002f0  9c 50 7c 07 34 e4 cf f0  2b 0f cf f7 68 57 fa fd  |.P|.4...+...hW..|
+00000300  2f 52 04 f8 90 7b 97 eb  c3 e0 cc 68 f7 bf 22 21  |/R...{.....h.."!|
+00000310  62 b3 51 c8 a4 30 38 c5  88 46 df 55 21 21 d0 4f  |b.Q..08..F.U!!.O|
+00000320  6f 95 7b 5f 5a c6 98 dd  2d d1 0a 95 16 03 03 00  |o.{_Z...-.......|
+00000330  3a 0d 00 00 36 03 01 02  40 00 2e 04 03 05 03 06  |:...6...@.......|
+00000340  03 08 07 08 08 08 09 08  0a 08 0b 08 04 08 05 08  |................|
+00000350  06 04 01 05 01 06 01 03  03 02 03 03 01 02 01 03  |................|
+00000360  02 02 02 04 02 05 02 06  02 00 00 16 03 03 00 04  |................|
+00000370  0e 00 00 00                                       |....|
 >>> Flow 3 (client to server)
 00000000  16 03 03 01 fd 0b 00 01  f9 00 01 f6 00 01 f3 30  |...............0|
 00000010  82 01 ef 30 82 01 58 a0  03 02 01 02 02 10 5c 19  |...0..X.......\.|
@@ -108,31 +108,31 @@
 00000200  e5 35 16 03 03 00 25 10  00 00 21 20 2f e5 7d a3  |.5....%...! /.}.|
 00000210  47 cd 62 43 15 28 da ac  5f bb 29 07 30 ff f6 84  |G.bC.(.._.).0...|
 00000220  af c4 cf c2 ed 90 99 5f  58 cb 3b 74 16 03 03 00  |......._X.;t....|
-00000230  88 0f 00 00 84 08 04 00  80 53 85 ea dc a6 86 2d  |.........S.....-|
-00000240  e7 8c 0b 68 f9 57 7f f5  77 d8 fe 35 28 91 e7 2f  |...h.W..w..5(../|
-00000250  8a 2c 36 cf d7 8c 9f 3d  f2 e2 99 41 11 b2 3c a2  |.,6....=...A..<.|
-00000260  5e f3 68 1f b5 d4 f8 90  8a e2 5e 02 48 00 2b eb  |^.h.......^.H.+.|
-00000270  f0 e6 8c 28 af 11 80 82  ea 35 06 fd 0a 5f d7 1a  |...(.....5..._..|
-00000280  e9 63 29 08 8c aa 18 1e  7c 08 81 21 c8 aa 86 b1  |.c).....|..!....|
-00000290  cf 94 db f6 8d 15 dc cc  ae cf 41 2c 32 b1 3f 0c  |..........A,2.?.|
-000002a0  96 0e 5c ed 82 74 cc fc  35 f4 38 80 29 00 c1 3a  |..\..t..5.8.)..:|
-000002b0  70 d4 07 07 9c 49 9e 7b  91 14 03 03 00 01 01 16  |p....I.{........|
+00000230  88 0f 00 00 84 08 04 00  80 84 38 78 4d dd 9f 84  |..........8xM...|
+00000240  ae cb b8 2f e9 f3 76 66  41 56 f6 ed a5 fb 8b f2  |.../..vfAV......|
+00000250  43 0f 27 56 9e 7d a8 06  3e 8f ad b0 17 d5 d6 52  |C.'V.}..>......R|
+00000260  f4 88 e5 af 55 5b 55 fc  26 c1 a9 d5 a9 34 2b 50  |....U[U.&....4+P|
+00000270  96 09 db 59 cc f4 e8 cf  84 6f 9d b1 fd 3b a4 66  |...Y.....o...;.f|
+00000280  66 43 74 6d 4f e5 52 2c  22 2d c9 4c 67 3d ff 3d  |fCtmO.R,"-.Lg=.=|
+00000290  c2 79 b3 b1 85 56 08 cc  02 7c 53 a7 be 39 04 21  |.y...V...|S..9.!|
+000002a0  fb db fe ff 1b a6 c7 7a  e9 4c 11 c3 34 a6 7c 4f  |.......z.L..4.|O|
+000002b0  23 61 d9 47 b0 6c ae cb  72 14 03 03 00 01 01 16  |#a.G.l..r.......|
 000002c0  03 03 00 40 00 00 00 00  00 00 00 00 00 00 00 00  |...@............|
-000002d0  00 00 00 00 f3 da dc d7  12 d6 f6 19 75 a8 02 68  |............u..h|
-000002e0  57 0e e1 90 75 d1 fc b8  32 a3 34 16 d6 8d 2a f5  |W...u...2.4...*.|
-000002f0  65 f2 a7 67 2c 2c a4 73  6a b6 f2 ad 2d 7f 8a ce  |e..g,,.sj...-...|
-00000300  a7 12 16 97                                       |....|
+000002d0  00 00 00 00 d3 95 4a 65  d9 8e 3d 9c 2b 18 67 aa  |......Je..=.+.g.|
+000002e0  e0 d7 a6 dd fb af 42 06  0d 56 cc 3d 12 3e 7e 95  |......B..V.=.>~.|
+000002f0  18 6e 97 d6 cc 84 eb 90  a1 c3 b6 6e 3c 42 d1 2e  |.n.........n<B..|
+00000300  7a dc 41 81                                       |z.A.|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 40 dc 11 a1 a2 fb  |..........@.....|
-00000010  55 0c 9e e0 e2 55 1a ca  cd 5b df 1f 39 9e 08 51  |U....U...[..9..Q|
-00000020  bd 6b 72 40 93 f8 23 7a  32 9d 85 18 20 b7 39 b0  |.kr@..#z2... .9.|
-00000030  03 d3 10 6a 8e 66 6d e6  d5 38 03 c6 e5 b8 dc d7  |...j.fm..8......|
-00000040  3c 27 1d d2 a9 59 f9 18  7d 15 90                 |<'...Y..}..|
+00000000  14 03 03 00 01 01 16 03  03 00 40 71 ee 1d 4f 55  |..........@q..OU|
+00000010  b4 47 3d 26 52 5a 00 a5  ce 0e 31 6c 2d 09 95 df  |.G=&RZ....1l-...|
+00000020  fb 74 30 89 32 3d 47 29  58 ee 61 70 74 18 8c 01  |.t0.2=G)X.apt...|
+00000030  e3 16 d7 6e 3d a1 30 75  61 b8 99 e4 c5 82 82 d5  |...n=.0ua.......|
+00000040  75 f6 e1 b4 f8 97 77 92  00 64 06                 |u.....w..d.|
 >>> Flow 5 (client to server)
 00000000  17 03 03 00 30 00 00 00  00 00 00 00 00 00 00 00  |....0...........|
-00000010  00 00 00 00 00 c2 92 ee  96 31 60 90 d5 ee a6 1c  |.........1`.....|
-00000020  ed 3c 03 40 8c e7 0c db  7f b0 11 dc 7e 58 e1 aa  |.<.@........~X..|
-00000030  4c d7 68 2a 91 15 03 03  00 30 00 00 00 00 00 00  |L.h*.....0......|
-00000040  00 00 00 00 00 00 00 00  00 00 b6 61 51 ac 66 a5  |...........aQ.f.|
-00000050  d1 ef d3 ee c8 d3 48 72  d5 e0 ef 7d ca 6a ec b2  |......Hr...}.j..|
-00000060  77 ff 2d a8 32 6d be 6e  a7 42                    |w.-.2m.n.B|
+00000010  00 00 00 00 00 e2 68 77  75 6a f8 3c 3d 2c 96 52  |......hwuj.<=,.R|
+00000020  2d fc d5 3b d3 17 c0 29  df 99 f1 09 23 13 9f 89  |-..;...)....#...|
+00000030  dd 21 15 23 36 15 03 03  00 30 00 00 00 00 00 00  |.!.#6....0......|
+00000040  00 00 00 00 00 00 00 00  00 00 37 4e ac 91 80 02  |..........7N....|
+00000050  4f 4a 9f b4 3c 0e 24 87  c8 d0 41 24 ce 01 e2 bb  |OJ..<.$...A$....|
+00000060  18 af bc ce 09 4b 41 f6  db 08                    |.....KA...|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-ClientCert-RSA-RSA b/src/crypto/tls/testdata/Client-TLSv12-ClientCert-RSA-RSA
index cdc71041fb..cbc4bcc311 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-ClientCert-RSA-RSA
+++ b/src/crypto/tls/testdata/Client-TLSv12-ClientCert-RSA-RSA
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 59 02 00 00  55 03 03 f3 28 ca c9 ac  |....Y...U...(...|
-00000010  29 bb 15 80 56 d2 37 09  fa 7d 23 04 d4 79 e7 1d  |)...V.7..}#..y..|
-00000020  bb 4e c5 60 c8 44 39 02  6a e9 e0 20 b5 ae 39 87  |.N.`.D9.j.. ..9.|
-00000030  4e 24 2f 33 02 fe 72 d6  2a 4d 0c 8c da 36 7b 28  |N$/3..r.*M...6{(|
-00000040  3c 06 aa b2 60 68 91 7a  ae d8 7b e2 c0 2f 00 00  |<...`h.z..{../..|
+00000000  16 03 03 00 59 02 00 00  55 03 03 b6 96 f2 bc ed  |....Y...U.......|
+00000010  1b 14 73 de 12 10 cc e9  4d f2 c7 8b 46 d8 63 55  |..s.....M...F.cU|
+00000020  8f 04 33 ec 89 b5 70 93  01 1c f2 20 72 82 e1 16  |..3...p.... r...|
+00000030  9c 0e 70 25 84 2c 09 a6  4f 19 c0 ed 44 d6 98 13  |..p%.,..O...D...|
+00000040  97 f6 19 08 d4 b6 d3 ad  82 96 ef db c0 2f 00 00  |............./..|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  03 02 59 0b 00 02 55 00  02 52 00 02 4f 30 82 02  |..Y...U..R..O0..|
 00000070  4b 30 82 01 b4 a0 03 02  01 02 02 09 00 e8 f0 9d  |K0..............|
@@ -60,17 +60,17 @@
 00000290  77 8d 0c 1c f1 0f a1 d8  40 83 61 c9 4c 72 2b 9d  |w.......@.a.Lr+.|
 000002a0  ae db 46 06 06 4d f4 c1  b3 3e c0 d1 bd 42 d4 db  |..F..M...>...B..|
 000002b0  fe 3d 13 60 84 5c 21 d3  3b e9 fa e7 16 03 03 00  |.=.`.\!.;.......|
-000002c0  ac 0c 00 00 a8 03 00 1d  20 d4 df 5d 10 ee ba a6  |........ ..]....|
-000002d0  51 d7 1b fb bf ed bc d6  b9 34 44 e7 af 23 0e 9b  |Q........4D..#..|
-000002e0  45 af ba 7a 89 63 03 a9  4c 08 04 00 80 30 2c 0f  |E..z.c..L....0,.|
-000002f0  2e d9 e4 1d c2 90 01 1c  cc cf d4 fe 06 6d c3 aa  |.............m..|
-00000300  59 d9 d9 bc 16 2f 2c b1  be 90 a3 93 a7 be bc 4d  |Y..../,........M|
-00000310  d8 f4 ac 21 36 59 a8 21  94 ef d3 c4 53 14 34 18  |...!6Y.!....S.4.|
-00000320  c9 10 d5 77 fd 1e ad 15  0f 23 d7 73 90 7a c0 7b  |...w.....#.s.z.{|
-00000330  b3 b2 e2 df 15 42 35 ce  38 05 52 02 77 b7 b2 2b  |.....B5.8.R.w..+|
-00000340  6b 88 6a ce d4 20 99 9d  e4 fe e8 38 1e 01 b7 78  |k.j.. .....8...x|
-00000350  3c ea ac 8e ef 2f 7e e8  22 08 78 42 b7 db 84 80  |<..../~.".xB....|
-00000360  8c 61 8a c5 cc d7 1f 6a  8d 5c 1d 2d 0d 16 03 03  |.a.....j.\.-....|
+000002c0  ac 0c 00 00 a8 03 00 1d  20 21 1b d1 91 16 9c c1  |........ !......|
+000002d0  51 52 39 07 6b 6d ab 07  28 f7 d0 ae 02 13 5e 73  |QR9.km..(.....^s|
+000002e0  5b 51 30 96 27 57 56 e5  37 08 04 00 80 6a 13 82  |[Q0.'WV.7....j..|
+000002f0  97 81 ea 32 51 cb cb 8e  3b ee e5 dd 4f 80 20 50  |...2Q...;...O. P|
+00000300  c9 f0 19 9b d5 1b ae 21  f7 e6 24 4e a3 22 ec b9  |.......!..$N."..|
+00000310  25 6e 77 19 12 08 16 8a  c7 c1 db 29 e9 be 05 55  |%nw........)...U|
+00000320  09 c1 6e 44 c3 d7 bd 18  80 c8 1f 42 53 3b e6 09  |..nD.......BS;..|
+00000330  00 29 20 c4 94 04 97 6f  f7 e6 f4 3b 66 77 2f e5  |.) ....o...;fw/.|
+00000340  de 96 6f c3 67 c5 ce 4b  5e 4b 0e 90 02 fc 32 7f  |..o.g..K^K....2.|
+00000350  71 f4 63 76 37 57 75 30  fb 1b f5 99 98 5f c3 b1  |q.cv7Wu0....._..|
+00000360  fb e3 76 ad 8e 2f 7a 72  86 ed 34 18 98 16 03 03  |..v../zr..4.....|
 00000370  00 3a 0d 00 00 36 03 01  02 40 00 2e 04 03 05 03  |.:...6...@......|
 00000380  06 03 08 07 08 08 08 09  08 0a 08 0b 08 04 08 05  |................|
 00000390  08 06 04 01 05 01 06 01  03 03 02 03 03 01 02 01  |................|
@@ -112,26 +112,26 @@
 00000200  e5 35 16 03 03 00 25 10  00 00 21 20 2f e5 7d a3  |.5....%...! /.}.|
 00000210  47 cd 62 43 15 28 da ac  5f bb 29 07 30 ff f6 84  |G.bC.(.._.).0...|
 00000220  af c4 cf c2 ed 90 99 5f  58 cb 3b 74 16 03 03 00  |......._X.;t....|
-00000230  88 0f 00 00 84 08 04 00  80 b8 96 b3 c8 66 a9 fb  |.............f..|
-00000240  da 1b 82 65 9d 57 e5 e5  e5 60 c9 43 df 6e 99 53  |...e.W...`.C.n.S|
-00000250  45 95 b8 58 d1 19 05 50  e1 a7 3c e8 07 ad 57 09  |E..X...P..<...W.|
-00000260  9c 95 13 ea 80 24 53 56  b1 13 2d 59 9d e9 60 0f  |.....$SV..-Y..`.|
-00000270  75 97 d3 4f 82 3a b5 41  3e 90 75 ea 28 97 00 e7  |u..O.:.A>.u.(...|
-00000280  74 c9 04 1d d0 16 ba 40  75 9c ae a0 bd 00 b1 a9  |t......@u.......|
-00000290  86 d5 1a f2 30 45 72 99  ea b2 eb 61 b1 63 72 c5  |....0Er....a.cr.|
-000002a0  ad b1 60 a8 fa bd 95 95  17 03 4c 8e 87 4b 44 e5  |..`.......L..KD.|
-000002b0  ec f3 e0 48 33 b8 a9 74  78 14 03 03 00 01 01 16  |...H3..tx.......|
-000002c0  03 03 00 28 00 00 00 00  00 00 00 00 e6 a6 db ee  |...(............|
-000002d0  7d fb 48 9f 81 a6 78 6a  db a1 9a bb c8 da 7b b2  |}.H...xj......{.|
-000002e0  6a 01 66 fb 85 a7 2f 35  40 77 b6 b2              |j.f.../5@w..|
+00000230  88 0f 00 00 84 08 04 00  80 90 53 1e fc 7c 63 b0  |..........S..|c.|
+00000240  98 c5 19 40 fb 4f cf c3  53 51 81 68 54 c7 49 38  |...@.O..SQ.hT.I8|
+00000250  0c 41 f0 12 7d a6 e4 8a  4e 77 97 49 5a 07 7d 30  |.A..}...Nw.IZ.}0|
+00000260  fa df 77 2f 51 cf 37 65  07 0b 2c 91 15 43 1d c9  |..w/Q.7e..,..C..|
+00000270  69 46 e2 26 66 72 98 ec  62 1a 22 ae e8 3e 3a 28  |iF.&fr..b."..>:(|
+00000280  17 83 b9 74 57 59 a2 ec  31 95 17 1f c3 ec 9a 01  |...tWY..1.......|
+00000290  f2 d4 07 d5 ee d5 0e f2  f4 75 3b d6 b8 df aa ad  |.........u;.....|
+000002a0  0b 87 37 30 43 7e c1 b1  e1 0d 7e 90 3d 87 9d 93  |..70C~....~.=...|
+000002b0  d7 06 57 18 5c 12 c2 32  0d 14 03 03 00 01 01 16  |..W.\..2........|
+000002c0  03 03 00 28 00 00 00 00  00 00 00 00 ff 2a ae f8  |...(.........*..|
+000002d0  c9 1c bd 3f 62 0e 68 42  e7 96 ec ee c0 fa 71 34  |...?b.hB......q4|
+000002e0  f1 e2 67 76 82 cf c3 2a  fb b2 5a c1              |..gv...*..Z.|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 28 b3 9c 30 b6 a2  |..........(..0..|
-00000010  cb cf 75 38 10 e7 80 39  0e 87 39 9c d9 da 2c 53  |..u8...9..9...,S|
-00000020  1a 64 2d 33 ff 21 25 e9  3c f2 ec 6d a4 59 f4 30  |.d-3.!%.<..m.Y.0|
-00000030  ea 41 24                                          |.A$|
+00000000  14 03 03 00 01 01 16 03  03 00 28 da 70 e7 aa 1b  |..........(.p...|
+00000010  6c 66 cb 9b 07 d9 4e 87  6f 87 60 fb 46 f5 e9 33  |lf....N.o.`.F..3|
+00000020  48 59 ff 3e b5 bf 0b 0c  b2 39 79 64 f6 3c 2e 95  |HY.>.....9yd.<..|
+00000030  04 51 87                                          |.Q.|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 1e 00 00 00  00 00 00 00 01 65 72 8f  |.............er.|
-00000010  4a 5f 08 c1 f9 37 5d 30  bc c6 e6 5f a8 23 35 69  |J_...7]0..._.#5i|
-00000020  d3 3c 7a 15 03 03 00 1a  00 00 00 00 00 00 00 02  |.<z.............|
-00000030  b0 48 2e 2e ed 4d 9c db  3a fc ff e6 57 83 fc 90  |.H...M..:...W...|
-00000040  aa 78                                             |.x|
+00000000  17 03 03 00 1e 00 00 00  00 00 00 00 01 21 29 d2  |.............!).|
+00000010  27 05 2d b4 a2 bf ea f2  96 8a 61 c9 91 75 9f 0f  |'.-.......a..u..|
+00000020  50 4a 76 15 03 03 00 1a  00 00 00 00 00 00 00 02  |PJv.............|
+00000030  a9 40 eb 86 b2 f0 85 a2  75 bc 4e 09 8c c9 ca 31  |.@......u.N....1|
+00000040  e5 49                                             |.I|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-ClientCert-RSA-RSAPKCS1v15 b/src/crypto/tls/testdata/Client-TLSv12-ClientCert-RSA-RSAPKCS1v15
index 26308fc9df..b8ecfffb91 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-ClientCert-RSA-RSAPKCS1v15
+++ b/src/crypto/tls/testdata/Client-TLSv12-ClientCert-RSA-RSAPKCS1v15
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 59 02 00 00  55 03 03 97 f2 cb de f1  |....Y...U.......|
-00000010  bb cf 9a 6c 6d 7e e2 94  af 9d 0b ed 02 cf fc b2  |...lm~..........|
-00000020  80 b2 7b 41 2c a6 83 e7  52 62 93 20 63 23 7f 48  |..{A,...Rb. c#.H|
-00000030  be c1 7f d3 75 34 fe 3a  ad 27 f5 99 b0 73 91 df  |....u4.:.'...s..|
-00000040  b3 e9 82 95 cd 1b f9 08  b6 3d 4f 9b c0 2f 00 00  |.........=O../..|
+00000000  16 03 03 00 59 02 00 00  55 03 03 ad e1 a7 5e 0b  |....Y...U.....^.|
+00000010  b8 bd 9d 05 c2 8e 6c f2  ea 7d a1 c8 32 cc d1 74  |......l..}..2..t|
+00000020  ba 86 75 98 33 27 39 c3  0a 6f 49 20 2b 37 9a 0f  |..u.3'9..oI +7..|
+00000030  9b de 1f 1d 5f 2b 45 29  6c 9b 33 c6 bc c1 15 a4  |...._+E)l.3.....|
+00000040  19 9b 70 6c 15 eb 4a 92  92 5f b7 6b c0 2f 00 00  |..pl..J.._.k./..|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  03 02 59 0b 00 02 55 00  02 52 00 02 4f 30 82 02  |..Y...U..R..O0..|
 00000070  4b 30 82 01 b4 a0 03 02  01 02 02 09 00 e8 f0 9d  |K0..............|
@@ -60,17 +60,17 @@
 00000290  77 8d 0c 1c f1 0f a1 d8  40 83 61 c9 4c 72 2b 9d  |w.......@.a.Lr+.|
 000002a0  ae db 46 06 06 4d f4 c1  b3 3e c0 d1 bd 42 d4 db  |..F..M...>...B..|
 000002b0  fe 3d 13 60 84 5c 21 d3  3b e9 fa e7 16 03 03 00  |.=.`.\!.;.......|
-000002c0  ac 0c 00 00 a8 03 00 1d  20 f8 3a 6c 5b 6f 88 48  |........ .:l[o.H|
-000002d0  19 c5 a2 e7 4a d9 6d 21  56 23 63 1b 1f 95 aa bc  |....J.m!V#c.....|
-000002e0  33 ac aa 3b bb f8 35 ba  1a 04 01 00 80 98 6d 7b  |3..;..5.......m{|
-000002f0  7d 40 13 81 6b 70 ec ac  60 ee 1d 3e 37 36 bc f4  |}@..kp..`..>76..|
-00000300  c1 9f 3c 13 b7 06 3d 38  be 4f 8c 3e e2 2e f2 b5  |..<...=8.O.>....|
-00000310  de 16 ec a0 5b 64 00 5c  c3 50 cc 79 a2 f7 e0 8d  |....[d.\.P.y....|
-00000320  68 e6 6b 1b b8 57 a4 15  d0 2c d7 4a be 97 26 26  |h.k..W...,.J..&&|
-00000330  8c 5c 4e 26 36 96 48 b5  0f 88 7b 37 43 e4 d1 24  |.\N&6.H...{7C..$|
-00000340  01 3c 70 38 99 c6 e2 2f  66 e7 db 57 30 f2 72 d0  |.<p8.../f..W0.r.|
-00000350  17 fd ad 09 a7 bd ee de  ca fd 57 15 de 25 b6 1f  |..........W..%..|
-00000360  ed 45 86 22 83 4e 64 54  56 17 1f 81 4f 16 03 03  |.E.".NdTV...O...|
+000002c0  ac 0c 00 00 a8 03 00 1d  20 ba ad fb 1e 28 95 96  |........ ....(..|
+000002d0  f3 62 9d 97 87 0f fd fc  a9 91 a2 4b 8d 69 ec 8f  |.b.........K.i..|
+000002e0  7d 49 08 6e fe 7d b3 5b  03 04 01 00 80 86 57 23  |}I.n.}.[......W#|
+000002f0  58 bb 9a 50 d8 bb 99 d9  f5 cc 66 43 38 f0 14 8a  |X..P......fC8...|
+00000300  cb 6d 8b c0 83 52 f8 53  75 94 07 e3 12 2c 10 bb  |.m...R.Su....,..|
+00000310  f3 9b 74 84 1f 11 f3 06  c3 f4 df db f0 1e 0a cd  |..t.............|
+00000320  1b 45 18 44 88 67 79 ca  3e 6e 2b 73 c2 10 84 d8  |.E.D.gy.>n+s....|
+00000330  7b c5 2e 81 7d 53 19 46  09 35 35 8b 66 8a a8 cc  |{...}S.F.55.f...|
+00000340  20 ba 20 15 9f d1 27 9c  6b 3c bb 48 79 4a 7e 11  | . ...'.k<.HyJ~.|
+00000350  da e3 26 5b 3a 95 da 4d  bd 86 3e 8c 97 55 7c 22  |..&[:..M..>..U|"|
+00000360  a1 d3 88 61 ae e1 3b 51  25 c6 01 7e 10 16 03 03  |...a..;Q%..~....|
 00000370  00 0c 0d 00 00 08 01 01  00 02 04 01 00 00 16 03  |................|
 00000380  03 00 04 0e 00 00 00                              |.......|
 >>> Flow 3 (client to server)
@@ -109,26 +109,26 @@
 00000200  e5 35 16 03 03 00 25 10  00 00 21 20 2f e5 7d a3  |.5....%...! /.}.|
 00000210  47 cd 62 43 15 28 da ac  5f bb 29 07 30 ff f6 84  |G.bC.(.._.).0...|
 00000220  af c4 cf c2 ed 90 99 5f  58 cb 3b 74 16 03 03 00  |......._X.;t....|
-00000230  88 0f 00 00 84 04 01 00  80 a8 12 9d 84 c2 17 0a  |................|
-00000240  03 ae bd 87 9a b6 6f 65  2f 7a 04 1f 69 2a 41 f4  |......oe/z..i*A.|
-00000250  d0 9a 4d a4 5b 6e d2 d3  42 c3 77 4f 04 28 ce e6  |..M.[n..B.wO.(..|
-00000260  d4 25 c5 81 1b 78 91 e9  1e 93 90 57 b2 58 6f 26  |.%...x.....W.Xo&|
-00000270  ed 20 15 62 ff e9 c6 c1  52 4a 9a 05 a6 cd 17 22  |. .b....RJ....."|
-00000280  75 c8 81 da a4 96 af c6  83 b5 5c 81 93 59 44 26  |u.........\..YD&|
-00000290  5b 03 59 9d ab 93 ee c7  37 61 74 e7 4a 22 1c ec  |[.Y.....7at.J"..|
-000002a0  96 fb a2 c9 ea 2d 4b 8d  d3 a7 e4 60 57 10 be b7  |.....-K....`W...|
-000002b0  60 80 4f ee 8e 21 6b a2  13 14 03 03 00 01 01 16  |`.O..!k.........|
-000002c0  03 03 00 28 00 00 00 00  00 00 00 00 16 82 4a c0  |...(..........J.|
-000002d0  98 7b 62 3e 9b da a9 ac  31 f2 32 a9 23 13 2f e3  |.{b>....1.2.#./.|
-000002e0  77 c9 1e ca 39 9f 4c 8a  10 58 33 67              |w...9.L..X3g|
+00000230  88 0f 00 00 84 04 01 00  80 12 a4 42 13 85 6f 92  |...........B..o.|
+00000240  6d 26 5d 05 3c b7 80 ab  a9 e0 74 3d 89 67 79 a0  |m&].<.....t=.gy.|
+00000250  9f e1 a9 20 d8 82 e2 22  99 38 03 fe 32 d9 1f c7  |... ...".8..2...|
+00000260  39 1e 27 31 59 05 eb aa  bc 2c 10 eb f0 82 65 65  |9.'1Y....,....ee|
+00000270  ce b2 e9 83 67 21 43 03  19 2d 14 9f c3 db bc dc  |....g!C..-......|
+00000280  59 66 95 d7 4e 09 3c f0  f2 4a 39 f7 db c4 0c 4e  |Yf..N.<..J9....N|
+00000290  73 e2 d6 59 f1 bc 06 d8  75 df 32 b7 f1 b4 01 98  |s..Y....u.2.....|
+000002a0  4f 93 43 a3 a6 09 da cd  1c ee 26 65 ab d1 2a 56  |O.C.......&e..*V|
+000002b0  74 32 24 46 27 f3 d9 6a  df 14 03 03 00 01 01 16  |t2$F'..j........|
+000002c0  03 03 00 28 00 00 00 00  00 00 00 00 68 27 5e 44  |...(........h'^D|
+000002d0  d7 73 26 f6 51 86 01 f5  f3 5d 61 a0 05 cd c3 00  |.s&.Q....]a.....|
+000002e0  85 6f ea 56 85 1e 7a c3  4c d3 6d 64              |.o.V..z.L.md|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 28 8e 56 d0 9c 38  |..........(.V..8|
-00000010  4f d9 df 12 9b dd 96 05  94 77 2f 6d 24 a8 cb 56  |O........w/m$..V|
-00000020  91 f9 bc ec 00 b5 cc 71  c4 f4 36 42 be 68 37 78  |.......q..6B.h7x|
-00000030  8f 6e 8c                                          |.n.|
+00000000  14 03 03 00 01 01 16 03  03 00 28 81 f3 33 d8 2a  |..........(..3.*|
+00000010  57 45 53 2c ee 68 8b 79  ed 07 dc 90 c3 a7 84 38  |WES,.h.y.......8|
+00000020  8c 33 03 e9 c6 51 04 b2  73 8a 8b 81 12 eb 6c 5f  |.3...Q..s.....l_|
+00000030  a3 8f 5e                                          |..^|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 1e 00 00 00  00 00 00 00 01 1c 19 9e  |................|
-00000010  a5 40 f6 d7 8b 80 23 8a  0b fa 14 65 08 6a 3c 66  |.@....#....e.j<f|
-00000020  07 c4 d2 15 03 03 00 1a  00 00 00 00 00 00 00 02  |................|
-00000030  16 7c e2 68 a5 d4 df 64  f4 1c 7d 17 b6 14 0a 4c  |.|.h...d..}....L|
-00000040  40 8e                                             |@.|
+00000000  17 03 03 00 1e 00 00 00  00 00 00 00 01 e5 c6 d7  |................|
+00000010  4d e0 d1 0c ff a0 66 c4  71 53 af 7e 16 01 3d 2e  |M.....f.qS.~..=.|
+00000020  6c ab 90 15 03 03 00 1a  00 00 00 00 00 00 00 02  |l...............|
+00000030  92 12 87 24 c8 7e 74 23  df f7 23 49 01 9a dd 3b  |...$.~t#..#I...;|
+00000040  2c 68                                             |,h|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-ClientCert-RSA-RSAPSS b/src/crypto/tls/testdata/Client-TLSv12-ClientCert-RSA-RSAPSS
index 3f740807f6..de05fec53e 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-ClientCert-RSA-RSAPSS
+++ b/src/crypto/tls/testdata/Client-TLSv12-ClientCert-RSA-RSAPSS
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 59 02 00 00  55 03 03 29 bc e2 fe ae  |....Y...U..)....|
-00000010  0a db 37 e6 39 d5 48 24  3d 0f e5 d7 6b a3 69 dd  |..7.9.H$=...k.i.|
-00000020  ce 09 fd 28 03 c2 7e 38  db c9 ec 20 d2 5e 3f 94  |...(..~8... .^?.|
-00000030  b0 2c 5e 4c 77 c2 94 c3  f2 a9 d0 91 4f 96 45 0e  |.,^Lw.......O.E.|
-00000040  d3 34 fc 9f e0 a5 e6 fc  1e 8a c1 00 c0 2f 00 00  |.4.........../..|
+00000000  16 03 03 00 59 02 00 00  55 03 03 61 fe 1e 35 33  |....Y...U..a..53|
+00000010  4b b4 dd 9b 0f 55 58 f4  0c c5 b2 73 51 7b 84 e7  |K....UX....sQ{..|
+00000020  25 f7 8f 12 5a 12 11 e1  7b e6 52 20 ad 86 a9 f9  |%...Z...{.R ....|
+00000030  7f 6a 30 da 79 23 c3 c4  dc 88 f6 19 1d cc 16 8b  |.j0.y#..........|
+00000040  96 74 84 ce 53 56 65 e2  cb 94 61 0c c0 2f 00 00  |.t..SVe...a../..|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  03 02 66 0b 00 02 62 00  02 5f 00 02 5c 30 82 02  |..f...b.._..\0..|
 00000070  58 30 82 01 8d a0 03 02  01 02 02 11 00 f2 99 26  |X0.............&|
@@ -61,17 +61,17 @@
 000002a0  11 89 66 79 d1 8e 88 0e  0b a0 9e 30 2a c0 67 ef  |..fy.......0*.g.|
 000002b0  ca 46 02 88 e9 53 81 22  69 22 97 ad 80 93 d4 f7  |.F...S."i"......|
 000002c0  dd 70 14 24 d7 70 0a 46  a1 16 03 03 00 ac 0c 00  |.p.$.p.F........|
-000002d0  00 a8 03 00 1d 20 9e e4  39 3a b3 d5 f9 51 16 d4  |..... ..9:...Q..|
-000002e0  a8 e1 0a 6d ad 3c ca 01  97 d6 a1 ce 03 2a 67 4a  |...m.<.......*gJ|
-000002f0  49 06 eb ed c6 24 08 04  00 80 b3 b7 9e fd 97 9b  |I....$..........|
-00000300  b0 d6 35 89 21 53 ff a8  4b 59 59 26 37 ac 2f 36  |..5.!S..KYY&7./6|
-00000310  27 3d 5a 04 3f 50 ed 36  e0 5f 1a d7 1b 36 47 94  |'=Z.?P.6._...6G.|
-00000320  45 ec 8c 0b 8f 0f fc df  ec 3c 56 f0 d0 28 45 94  |E........<V..(E.|
-00000330  96 c7 35 bb 42 31 a6 6e  eb 27 cf cf 7e 21 cf 2f  |..5.B1.n.'..~!./|
-00000340  a1 90 5d 2b 32 23 b3 de  40 a7 b6 56 c1 73 29 56  |..]+2#..@..V.s)V|
-00000350  3d 73 fe 34 b2 0b 58 97  16 e6 a1 1c 47 0e 24 a7  |=s.4..X.....G.$.|
-00000360  0d c9 a0 51 70 82 b1 d1  a6 a1 bc b4 49 77 c4 c4  |...Qp.......Iw..|
-00000370  87 ae c8 49 e6 80 ae d0  dd ca 16 03 03 00 0c 0d  |...I............|
+000002d0  00 a8 03 00 1d 20 e0 90  02 58 37 69 79 d6 78 e5  |..... ...X7iy.x.|
+000002e0  1d c6 7e a0 c6 38 1b ff  47 72 d6 c2 52 cb 6c 52  |..~..8..Gr..R.lR|
+000002f0  36 7e 03 c3 35 1d 08 04  00 80 79 5f 23 fd b1 ee  |6~..5.....y_#...|
+00000300  ac 62 c8 72 09 52 1f 9a  0f ac 95 3e 4e e4 97 d2  |.b.r.R.....>N...|
+00000310  a3 04 ae 19 3f 25 ad 3e  b7 78 1f d9 79 5f c8 26  |....?%.>.x..y_.&|
+00000320  f0 26 e5 ee 54 46 4a 05  84 15 01 4f 7a 7e 60 bd  |.&..TFJ....Oz~`.|
+00000330  86 74 78 d7 7c 86 91 2b  4f 76 b6 aa 78 27 c8 21  |.tx.|..+Ov..x'.!|
+00000340  7e df 88 2f 26 f0 9d 3c  a2 e8 95 f6 9f 5a a4 5e  |~../&..<.....Z.^|
+00000350  18 dc cd 0d 70 e8 85 b7  e5 57 f6 c2 f4 33 28 1c  |....p....W...3(.|
+00000360  58 7b 94 b0 9e ee d8 b3  42 b5 f3 63 78 a1 30 f3  |X{......B..cx.0.|
+00000370  f7 e4 5e 72 64 6f 80 32  70 4e 16 03 03 00 0c 0d  |..^rdo.2pN......|
 00000380  00 00 08 01 01 00 02 08  04 00 00 16 03 03 00 04  |................|
 00000390  0e 00 00 00                                       |....|
 >>> Flow 3 (client to server)
@@ -117,26 +117,26 @@
 00000270  10 00 00 21 20 2f e5 7d  a3 47 cd 62 43 15 28 da  |...! /.}.G.bC.(.|
 00000280  ac 5f bb 29 07 30 ff f6  84 af c4 cf c2 ed 90 99  |._.).0..........|
 00000290  5f 58 cb 3b 74 16 03 03  00 88 0f 00 00 84 08 04  |_X.;t...........|
-000002a0  00 80 a6 6b 99 15 5e 97  33 4f a8 0e 59 af 15 22  |...k..^.3O..Y.."|
-000002b0  f3 6e be 02 6e e4 20 d5  81 c0 b4 74 5a e2 20 32  |.n..n. ....tZ. 2|
-000002c0  2b 7f 9c e6 94 32 4d 30  bf 93 86 9b 75 4d f1 9f  |+....2M0....uM..|
-000002d0  e4 48 28 00 27 fa 7c 45  2e fe d7 0b dc 03 c4 6b  |.H(.'.|E.......k|
-000002e0  42 ad a2 32 d7 9d ea d6  52 05 3f ed 87 fd b9 9d  |B..2....R.?.....|
-000002f0  58 fd d6 9f 28 6d 45 07  de 5b 4a 8e f4 4d 19 0b  |X...(mE..[J..M..|
-00000300  cf 4e 64 75 73 ae cd e9  ae f9 af 27 d0 b9 eb 4c  |.Ndus......'...L|
-00000310  98 ad 66 6d 4e bf 2c 39  87 f3 72 3e 4e bc a1 8f  |..fmN.,9..r>N...|
-00000320  a8 1e 14 03 03 00 01 01  16 03 03 00 28 00 00 00  |............(...|
-00000330  00 00 00 00 00 04 3c cc  ae cd 19 52 6b 1e 0e cc  |......<....Rk...|
-00000340  dd a9 ac 2f 2a c6 94 4c  09 f3 ee 2f b5 5a 13 1e  |.../*..L.../.Z..|
-00000350  4f 54 a0 ae c2                                    |OT...|
+000002a0  00 80 b2 c4 60 82 75 ca  be 40 dc 28 ec 6d 14 6f  |....`.u..@.(.m.o|
+000002b0  6c 88 ca 9a d7 ae ce 94  26 a7 10 ad d8 c3 b9 a6  |l.......&.......|
+000002c0  48 4e 01 7d ee 6e f8 e0  15 d9 72 c4 79 8d ac 25  |HN.}.n....r.y..%|
+000002d0  37 29 83 fc e6 f1 2e 4f  76 49 6a 36 b9 1e b4 58  |7).....OvIj6...X|
+000002e0  a2 3e f7 ff 96 5e d9 17  f2 40 05 1f ec bb 5b f5  |.>...^...@....[.|
+000002f0  28 86 d2 fc 0e 7e 70 3a  3d 90 4c 46 a5 3e bc 57  |(....~p:=.LF.>.W|
+00000300  24 4c ee 35 23 99 6f 21  12 db ba d8 3a 5f 37 1f  |$L.5#.o!....:_7.|
+00000310  da 3d c2 c9 bf b6 11 8b  b9 b9 43 0b 52 ff 6d 2a  |.=........C.R.m*|
+00000320  74 a7 14 03 03 00 01 01  16 03 03 00 28 00 00 00  |t...........(...|
+00000330  00 00 00 00 00 34 bd 90  a0 3f 1c 0c 11 5c 8a e4  |.....4...?...\..|
+00000340  28 82 c4 57 59 73 fd a4  dc a9 91 4b df 2a c6 b5  |(..WYs.....K.*..|
+00000350  f0 6e cf 41 70                                    |.n.Ap|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 28 6d 44 cb 35 8b  |..........(mD.5.|
-00000010  15 5c f9 f8 1e ae 4f 8c  8c d9 90 9e 6c cf 13 f6  |.\....O.....l...|
-00000020  12 29 f5 f7 d6 ff da e2  48 7d 68 ec ad 1a 6c 39  |.)......H}h...l9|
-00000030  c5 77 6c                                          |.wl|
+00000000  14 03 03 00 01 01 16 03  03 00 28 e2 44 81 59 e4  |..........(.D.Y.|
+00000010  6c cf e2 e7 04 78 61 02  36 29 2c 5c c4 6f 13 0b  |l....xa.6),\.o..|
+00000020  29 ba 74 b0 13 e8 8f 67  39 b5 ea d1 9d 99 d2 f6  |).t....g9.......|
+00000030  f7 32 be                                          |.2.|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 1e 00 00 00  00 00 00 00 01 2a ce da  |.............*..|
-00000010  11 1c 7d 49 0d aa 44 d4  d6 d4 7f 64 2b 49 47 20  |..}I..D....d+IG |
-00000020  5a 21 bb 15 03 03 00 1a  00 00 00 00 00 00 00 02  |Z!..............|
-00000030  fc 10 75 a7 22 f9 74 1c  3a d2 b2 a8 04 2d 37 5f  |..u.".t.:....-7_|
-00000040  c2 76                                             |.v|
+00000000  17 03 03 00 1e 00 00 00  00 00 00 00 01 5c 7b 38  |.............\{8|
+00000010  46 af 57 57 05 5a c5 cb  83 f3 fd 17 d4 c3 2e 93  |F.WW.Z..........|
+00000020  d7 70 52 15 03 03 00 1a  00 00 00 00 00 00 00 02  |.pR.............|
+00000030  df 2b d8 62 ec 97 c6 ab  be d4 7f c9 91 f4 fe 55  |.+.b...........U|
+00000040  ac bd                                             |..|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-ECDHE-ECDSA-AES b/src/crypto/tls/testdata/Client-TLSv12-ECDHE-ECDSA-AES
index 95781c6853..d21e9b3704 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-ECDHE-ECDSA-AES
+++ b/src/crypto/tls/testdata/Client-TLSv12-ECDHE-ECDSA-AES
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 59 02 00 00  55 03 03 eb a2 77 eb b6  |....Y...U....w..|
-00000010  1e e4 5c 2c ed 5a dc 93  1b 7e 8a 75 a1 8c ac a6  |..\,.Z...~.u....|
-00000020  69 13 f6 f6 a4 69 07 93  99 cf 12 20 37 d7 f8 26  |i....i..... 7..&|
-00000030  46 ea 3a 21 03 d0 25 0f  22 84 8d 24 2f 98 3d 42  |F.:!..%."..$/.=B|
-00000040  eb 47 1d de 0c 12 ab 95  7a 55 46 f7 c0 09 00 00  |.G......zUF.....|
+00000000  16 03 03 00 59 02 00 00  55 03 03 ec 4a 6a f8 c5  |....Y...U...Jj..|
+00000010  42 65 f9 d3 4f 65 6f 14  6b bd ae a9 82 5d 06 9b  |Be..Oeo.k....]..|
+00000020  9d 03 bb 67 eb ba 52 70  74 c3 01 20 f2 ef 69 54  |...g..Rpt.. ..iT|
+00000030  1f 4b 79 f7 5b d5 08 b4  18 4c af 8e 55 58 45 22  |.Ky.[....L..UXE"|
+00000040  c1 c9 6f cf 36 67 45 20  c7 c5 3a af c0 09 00 00  |..o.6gE ..:.....|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  03 02 0e 0b 00 02 0a 00  02 07 00 02 04 30 82 02  |.............0..|
 00000070  00 30 82 01 62 02 09 00  b8 bf 2d 47 a0 d2 eb f4  |.0..b.....-G....|
@@ -55,39 +55,39 @@
 00000240  13 83 0d 94 06 bb d4 37  7a f6 ec 7a c9 86 2e dd  |.......7z..z....|
 00000250  d7 11 69 7f 85 7c 56 de  fb 31 78 2b e4 c7 78 0d  |..i..|V..1x+..x.|
 00000260  ae cb be 9e 4e 36 24 31  7b 6a 0f 39 95 12 07 8f  |....N6$1{j.9....|
-00000270  2a 16 03 03 00 b7 0c 00  00 b3 03 00 1d 20 90 68  |*............ .h|
-00000280  81 8b 1d 7f d5 69 36 d3  4e 63 40 fa 3a 21 ee a4  |.....i6.Nc@.:!..|
-00000290  c7 b4 09 bc 34 51 89 df  d5 d2 79 51 34 32 04 03  |....4Q....yQ42..|
-000002a0  00 8b 30 81 88 02 42 01  b4 69 6b 1c e6 35 99 81  |..0...B..ik..5..|
-000002b0  fb aa cb b4 2d e9 e0 48  6a 6c 5e 14 54 77 b7 9d  |....-..Hjl^.Tw..|
-000002c0  df a3 c2 1b 53 8c d2 46  6d 2e ae 83 3a db 7c 86  |....S..Fm...:.|.|
-000002d0  4a 45 c7 51 cd 30 d6 8c  f5 4f ea 37 cb 1e 27 18  |JE.Q.0...O.7..'.|
-000002e0  ba df d5 5f 11 ae 0e af  75 02 42 01 2b 37 2e 6d  |..._....u.B.+7.m|
-000002f0  7c 11 57 b7 b7 8b 90 73  cd e0 c9 38 3c ee aa d5  ||.W....s...8<...|
-00000300  f2 cd ff b9 66 6a be 62  70 74 ee a4 f4 e3 fb 4f  |....fj.bpt.....O|
-00000310  ed 2e d5 a7 b5 a4 53 c8  1b 17 9e e9 48 e1 dd a6  |......S.....H...|
-00000320  e8 6a 05 cf 73 b2 85 11  13 37 be e0 26 16 03 03  |.j..s....7..&...|
+00000270  2a 16 03 03 00 b7 0c 00  00 b3 03 00 1d 20 7f e5  |*............ ..|
+00000280  3b 03 9e 6a 77 11 1b 0f  bc 4a db 44 7c 3b 81 1c  |;..jw....J.D|;..|
+00000290  03 8b 15 a6 f3 16 a0 58  5b 13 c5 1e d2 2c 04 03  |.......X[....,..|
+000002a0  00 8b 30 81 88 02 42 00  cc 7c 76 94 81 89 8f 25  |..0...B..|v....%|
+000002b0  16 e2 a0 0d 80 4f 7a 8f  8c 83 23 53 23 45 9c c1  |.....Oz...#S#E..|
+000002c0  39 e3 0c c2 1b 4d f3 78  cd ea b9 c8 d4 b6 30 bb  |9....M.x......0.|
+000002d0  ff d7 ad 6c b2 fd 62 4d  8a 05 19 cf 58 ec 81 17  |...l..bM....X...|
+000002e0  21 7c 71 a1 d7 ad 87 11  8d 02 42 01 a2 9e c8 e4  |!|q.......B.....|
+000002f0  04 7c 75 22 df 14 97 94  8a 1b a1 34 95 95 dd 4c  |.|u".......4...L|
+00000300  9f 1a c7 c7 96 db ef 87  82 27 9a 27 3a 3d 75 26  |.........'.':=u&|
+00000310  04 47 66 eb 55 60 9f 93  4e b2 09 14 fa 71 5b 3f  |.Gf.U`..N....q[?|
+00000320  33 37 3f 0c f2 5c 4f 1e  cc fa b1 6f 70 16 03 03  |37?..\O....op...|
 00000330  00 04 0e 00 00 00                                 |......|
 >>> Flow 3 (client to server)
 00000000  16 03 03 00 25 10 00 00  21 20 2f e5 7d a3 47 cd  |....%...! /.}.G.|
 00000010  62 43 15 28 da ac 5f bb  29 07 30 ff f6 84 af c4  |bC.(.._.).0.....|
 00000020  cf c2 ed 90 99 5f 58 cb  3b 74 14 03 03 00 01 01  |....._X.;t......|
 00000030  16 03 03 00 40 00 00 00  00 00 00 00 00 00 00 00  |....@...........|
-00000040  00 00 00 00 00 7f 83 b7  cd 14 66 fb c3 2a f9 9f  |..........f..*..|
-00000050  79 ec 40 e5 dd 15 46 f3  25 8d dd b2 8e d5 78 97  |y.@...F.%.....x.|
-00000060  e5 d6 4e 1a 2e 35 21 b2  aa ac 28 6f 2c 36 a6 6e  |..N..5!...(o,6.n|
-00000070  44 92 84 1b b9                                    |D....|
+00000040  00 00 00 00 00 d6 67 cb  d5 7c 95 9b 16 e2 3b 86  |......g..|....;.|
+00000050  22 bd 8c c7 40 36 9b b6  7e 0a 77 78 38 14 37 3c  |"...@6..~.wx8.7<|
+00000060  48 42 37 a7 07 31 bb 57  c4 e9 f5 e5 a7 58 71 f8  |HB7..1.W.....Xq.|
+00000070  82 f7 12 97 72                                    |....r|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 40 db ee f8 c1 0e  |..........@.....|
-00000010  7f 23 b4 cb e6 db 03 2a  fb 68 40 78 85 03 9e dc  |.#.....*.h@x....|
-00000020  ac f8 f0 b5 65 8d 7c 01  4a ce 86 29 a9 c5 c3 b2  |....e.|.J..)....|
-00000030  12 8d d1 58 af e7 21 75  e4 be f3 c0 03 55 f8 bb  |...X..!u.....U..|
-00000040  71 bd 85 ee 46 87 a0 32  75 ee 4c                 |q...F..2u.L|
+00000000  14 03 03 00 01 01 16 03  03 00 40 56 45 5c a3 b3  |..........@VE\..|
+00000010  64 43 54 7f b5 90 1a 34  ab 2b 68 25 49 41 bf 78  |dCT....4.+h%IA.x|
+00000020  50 b0 66 35 20 76 e1 d0  5c 8a 82 2e 03 83 cf c6  |P.f5 v..\.......|
+00000030  b7 48 3d 2c c4 cf f5 31  c1 ab 9a 3b 09 3a 75 e3  |.H=,...1...;.:u.|
+00000040  b2 05 fa d9 79 cc 1b 0e  30 44 e1                 |....y...0D.|
 >>> Flow 5 (client to server)
 00000000  17 03 03 00 30 00 00 00  00 00 00 00 00 00 00 00  |....0...........|
-00000010  00 00 00 00 00 48 95 f8  a1 0e a7 d0 50 dd cf 8f  |.....H......P...|
-00000020  c4 af ec 49 89 bf 5d 8b  a0 d0 60 7b 38 5a 83 e4  |...I..]...`{8Z..|
-00000030  72 47 7f 81 bd 15 03 03  00 30 00 00 00 00 00 00  |rG.......0......|
-00000040  00 00 00 00 00 00 00 00  00 00 48 06 f1 30 61 dd  |..........H..0a.|
-00000050  e2 97 aa 9c 5f a7 07 bb  44 a4 fb d6 6a 7c aa f5  |...._...D...j|..|
-00000060  16 ae 38 1a 98 e5 f5 28  c2 57                    |..8....(.W|
+00000010  00 00 00 00 00 76 5f 1f  ec 55 ec f4 87 06 91 b4  |.....v_..U......|
+00000020  ba 71 4f 7f 9c ce e1 c7  e6 3d 75 05 fd ba 98 c4  |.qO......=u.....|
+00000030  d0 39 24 b8 d4 15 03 03  00 30 00 00 00 00 00 00  |.9$......0......|
+00000040  00 00 00 00 00 00 00 00  00 00 e8 4e 09 a1 5f db  |...........N.._.|
+00000050  91 d5 5b e8 6a 86 7a 6c  7d 4a e1 94 8a 7d 99 52  |..[.j.zl}J...}.R|
+00000060  e6 5d d8 35 7c a0 68 8f  09 f9                    |.].5|.h...|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-ECDHE-ECDSA-AES-GCM b/src/crypto/tls/testdata/Client-TLSv12-ECDHE-ECDSA-AES-GCM
index 7214747d15..02bad39f16 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-ECDHE-ECDSA-AES-GCM
+++ b/src/crypto/tls/testdata/Client-TLSv12-ECDHE-ECDSA-AES-GCM
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 59 02 00 00  55 03 03 c9 a1 8b 70 59  |....Y...U.....pY|
-00000010  8b 88 41 56 b7 bc 9a 1f  50 57 46 7d 79 d8 ef b2  |..AV....PWF}y...|
-00000020  15 3f ad ad bb 48 09 ce  e1 c2 2c 20 84 43 65 e7  |.?...H...., .Ce.|
-00000030  3f 2f d8 13 9a 79 ac 54  ee b9 13 a1 7c a7 05 f7  |?/...y.T....|...|
-00000040  c8 b4 fc bd 20 40 17 ca  15 cd 91 1e c0 2b 00 00  |.... @.......+..|
+00000000  16 03 03 00 59 02 00 00  55 03 03 d4 97 12 a8 e7  |....Y...U.......|
+00000010  be a9 2d 80 f0 db 01 49  07 04 f4 d1 02 db 3d 4a  |..-....I......=J|
+00000020  f0 af 31 38 39 d7 4c 1a  d3 74 71 20 0f a3 76 14  |..189.L..tq ..v.|
+00000030  73 ff 25 1b ef 29 b3 5e  0b 8f fe ee a6 19 d3 31  |s.%..).^.......1|
+00000040  5d 2e 71 ab 74 58 e9 d6  c5 9b f4 93 c0 2b 00 00  |].q.tX.......+..|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  03 02 0e 0b 00 02 0a 00  02 07 00 02 04 30 82 02  |.............0..|
 00000070  00 30 82 01 62 02 09 00  b8 bf 2d 47 a0 d2 eb f4  |.0..b.....-G....|
@@ -55,34 +55,34 @@
 00000240  13 83 0d 94 06 bb d4 37  7a f6 ec 7a c9 86 2e dd  |.......7z..z....|
 00000250  d7 11 69 7f 85 7c 56 de  fb 31 78 2b e4 c7 78 0d  |..i..|V..1x+..x.|
 00000260  ae cb be 9e 4e 36 24 31  7b 6a 0f 39 95 12 07 8f  |....N6$1{j.9....|
-00000270  2a 16 03 03 00 b7 0c 00  00 b3 03 00 1d 20 58 f9  |*............ X.|
-00000280  2e 03 90 fa 3d 33 0d 3e  e1 3a b1 5a 45 ec 5c ee  |....=3.>.:.ZE.\.|
-00000290  9f 47 51 4b 93 89 33 11  e0 63 86 fd b2 3b 04 03  |.GQK..3..c...;..|
-000002a0  00 8b 30 81 88 02 42 01  c2 fa 7b f8 ed 6b a5 0f  |..0...B...{..k..|
-000002b0  33 87 02 35 5b 8e 5d 31  5e 92 df c2 90 ae 58 24  |3..5[.]1^.....X$|
-000002c0  43 0f ba e3 b8 77 12 7a  97 c3 77 15 62 d3 f2 cc  |C....w.z..w.b...|
-000002d0  10 cd a9 be b6 b2 37 93  b1 ce 8b b2 6c fa 93 74  |......7.....l..t|
-000002e0  5e 14 8e ba 9e d7 66 48  b8 02 42 01 8e 9a 10 1d  |^.....fH..B.....|
-000002f0  7d e0 d3 cf 0d d0 3c bc  34 1c 16 20 85 50 03 3f  |}.....<.4.. .P.?|
-00000300  e1 6d a3 a0 d4 6e d8 fd  7e df b4 c1 84 29 c3 68  |.m...n..~....).h|
-00000310  c2 01 dd 77 fc 2c a5 8f  3b 74 c6 e4 32 20 b7 a0  |...w.,..;t..2 ..|
-00000320  8c 1b 2d 93 6a 9c 8a ed  21 b5 9a e0 cb 16 03 03  |..-.j...!.......|
+00000270  2a 16 03 03 00 b7 0c 00  00 b3 03 00 1d 20 a8 15  |*............ ..|
+00000280  13 40 df f8 dc 39 f0 af  90 53 a8 34 a9 61 68 c8  |.@...9...S.4.ah.|
+00000290  ad be 4f 02 0e d2 83 fd  2e 35 bf 8c 8e 13 04 03  |..O......5......|
+000002a0  00 8b 30 81 88 02 42 00  bc 69 df 5b ec 9f 17 ff  |..0...B..i.[....|
+000002b0  e6 e5 24 71 f6 2b a5 88  40 78 12 ef f3 dc 25 a9  |..$q.+..@x....%.|
+000002c0  7c 89 24 0d c7 46 b2 db  ae 72 b4 2a 87 87 fe 7e  ||.$..F...r.*...~|
+000002d0  22 8f e6 d4 c4 7b 61 14  c3 04 39 98 87 6f 1f 54  |"....{a...9..o.T|
+000002e0  e0 50 16 0b 52 8e d6 1e  0a 02 42 00 b7 40 26 a8  |.P..R.....B..@&.|
+000002f0  11 09 77 ec 36 e5 88 26  6d 83 6f e7 c3 b1 98 c3  |..w.6..&m.o.....|
+00000300  4b 83 92 48 65 31 87 68  ee 49 25 ec 95 59 82 b5  |K..He1.h.I%..Y..|
+00000310  93 92 c8 17 d6 d9 1c 99  60 48 1b 18 50 b4 e7 df  |........`H..P...|
+00000320  ed 75 1a f2 08 e8 3d 93  99 27 ef 4d e3 16 03 03  |.u....=..'.M....|
 00000330  00 04 0e 00 00 00                                 |......|
 >>> Flow 3 (client to server)
 00000000  16 03 03 00 25 10 00 00  21 20 2f e5 7d a3 47 cd  |....%...! /.}.G.|
 00000010  62 43 15 28 da ac 5f bb  29 07 30 ff f6 84 af c4  |bC.(.._.).0.....|
 00000020  cf c2 ed 90 99 5f 58 cb  3b 74 14 03 03 00 01 01  |....._X.;t......|
-00000030  16 03 03 00 28 00 00 00  00 00 00 00 00 c2 14 2d  |....(..........-|
-00000040  fc d7 a2 cb 18 b9 2a ae  38 70 b7 78 7c 88 97 d3  |......*.8p.x|...|
-00000050  ff 7f df 12 23 96 ab 4d  6c 5c 67 72 c4           |....#..Ml\gr.|
+00000030  16 03 03 00 28 00 00 00  00 00 00 00 00 30 f1 a9  |....(........0..|
+00000040  4a 7e 86 a1 5d b7 db 2f  c6 e2 ec 36 41 83 66 75  |J~..]../...6A.fu|
+00000050  a3 6c 7d e7 61 36 ac f7  76 f8 8e d8 81           |.l}.a6..v....|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 28 2a dd b3 5b c6  |..........(*..[.|
-00000010  76 e7 c0 ac 8c 70 77 d6  d8 4e 79 4a 04 3d 91 a9  |v....pw..NyJ.=..|
-00000020  ad 79 ef c9 22 78 17 9e  ef b0 03 c8 e6 85 b7 8c  |.y.."x..........|
-00000030  e5 74 95                                          |.t.|
+00000000  14 03 03 00 01 01 16 03  03 00 28 2c 78 86 13 dc  |..........(,x...|
+00000010  a4 b9 bf ad 50 45 a3 d9  b3 df 33 a2 79 b1 1b 25  |....PE....3.y..%|
+00000020  12 94 97 99 07 6b 52 c4  52 64 ab 89 40 8c 93 4a  |.....kR.Rd..@..J|
+00000030  e3 cc d9                                          |...|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 1e 00 00 00  00 00 00 00 01 84 b5 0f  |................|
-00000010  1f ed f9 4c 0d a1 f3 7b  8e 23 87 65 b1 39 98 50  |...L...{.#.e.9.P|
-00000020  3d ff 1b 15 03 03 00 1a  00 00 00 00 00 00 00 02  |=...............|
-00000030  aa 34 cc f1 4a d3 de 4c  42 bc 2c 0f 3e 71 af 6b  |.4..J..LB.,.>q.k|
-00000040  3c fc                                             |<.|
+00000000  17 03 03 00 1e 00 00 00  00 00 00 00 01 fa 9e 8b  |................|
+00000010  92 8c f5 32 e6 d4 11 46  b4 73 62 56 f6 83 15 6f  |...2...F.sbV...o|
+00000020  ce de 2d 15 03 03 00 1a  00 00 00 00 00 00 00 02  |..-.............|
+00000030  93 24 68 83 67 b6 f9 27  b5 26 52 78 5d f3 c9 d2  |.$h.g..'.&Rx]...|
+00000040  26 a0                                             |&.|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-ECDHE-ECDSA-AES128-SHA256 b/src/crypto/tls/testdata/Client-TLSv12-ECDHE-ECDSA-AES128-SHA256
index 96f6218a35..4946fe4ec5 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-ECDHE-ECDSA-AES128-SHA256
+++ b/src/crypto/tls/testdata/Client-TLSv12-ECDHE-ECDSA-AES128-SHA256
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 59 02 00 00  55 03 03 87 87 6f ce 44  |....Y...U....o.D|
-00000010  94 5f 2f cc 94 03 50 68  a7 4f 37 70 8a d4 cf e3  |._/...Ph.O7p....|
-00000020  23 7f 11 f5 93 c7 3f 96  87 49 45 20 9c d4 96 b2  |#.....?..IE ....|
-00000030  dc 8c 16 c5 fb cc 2f 8e  0e a5 ef a3 ea cf 57 d0  |....../.......W.|
-00000040  09 70 bd 16 c4 d9 e4 1b  a0 40 f7 f3 c0 23 00 00  |.p.......@...#..|
+00000000  16 03 03 00 59 02 00 00  55 03 03 d1 af 88 61 b7  |....Y...U.....a.|
+00000010  b3 01 16 1a 44 26 1c a1  4f 2d 8a f6 9c f2 7e 1a  |....D&..O-....~.|
+00000020  1f ce cb dd 5b f0 c6 2f  16 5e 4a 20 b3 c7 ae 3f  |....[../.^J ...?|
+00000030  de d0 d8 9e 48 3e 87 23  f0 9d 43 10 50 3c 66 8b  |....H>.#..C.P<f.|
+00000040  7f d2 9b 4f f5 e4 b3 53  db d6 65 d0 c0 23 00 00  |...O...S..e..#..|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  03 02 0e 0b 00 02 0a 00  02 07 00 02 04 30 82 02  |.............0..|
 00000070  00 30 82 01 62 02 09 00  b8 bf 2d 47 a0 d2 eb f4  |.0..b.....-G....|
@@ -55,43 +55,43 @@
 00000240  13 83 0d 94 06 bb d4 37  7a f6 ec 7a c9 86 2e dd  |.......7z..z....|
 00000250  d7 11 69 7f 85 7c 56 de  fb 31 78 2b e4 c7 78 0d  |..i..|V..1x+..x.|
 00000260  ae cb be 9e 4e 36 24 31  7b 6a 0f 39 95 12 07 8f  |....N6$1{j.9....|
-00000270  2a 16 03 03 00 b6 0c 00  00 b2 03 00 1d 20 3f a6  |*............ ?.|
-00000280  d1 0d ae 8d c0 06 14 ca  da 2c 69 1c f1 84 c4 dd  |.........,i.....|
-00000290  14 f4 0e a6 ce b5 d6 37  9d 9f a5 ba 7b 74 04 03  |.......7....{t..|
-000002a0  00 8a 30 81 87 02 42 00  b5 2b 9a 32 9d af b9 cc  |..0...B..+.2....|
-000002b0  0d b6 f1 9b 87 35 af d7  dc 04 0f 1b 04 d7 fa 62  |.....5.........b|
-000002c0  20 bd 2c 31 41 17 e7 c0  ea 22 78 e4 de 37 14 a8  | .,1A...."x..7..|
-000002d0  f9 f3 f1 3e 0c 55 59 b3  e3 0e 31 26 ce d0 c1 19  |...>.UY...1&....|
-000002e0  b8 17 07 2a 23 98 7b 17  0f 02 41 41 d5 51 80 4d  |...*#.{...AA.Q.M|
-000002f0  8a 14 56 b1 39 7b 8b 37  24 ef e0 ec 43 44 5a cc  |..V.9{.7$...CDZ.|
-00000300  9b ab dc 63 e7 cc 7b 29  c0 66 ae 9c 23 c5 1b 98  |...c..{).f..#...|
-00000310  6e 35 64 97 12 43 16 73  a6 6b c8 09 2c 26 7c f5  |n5d..C.s.k..,&|.|
-00000320  b1 1f 9f 55 04 9e 53 33  c1 89 7a d0 16 03 03 00  |...U..S3..z.....|
+00000270  2a 16 03 03 00 b6 0c 00  00 b2 03 00 1d 20 dc 43  |*............ .C|
+00000280  15 b7 95 81 41 bf e2 bd  56 82 23 46 05 29 05 95  |....A...V.#F.)..|
+00000290  ae 67 08 38 9f 10 70 25  21 92 b4 a0 82 4e 04 03  |.g.8..p%!....N..|
+000002a0  00 8a 30 81 87 02 41 5d  ca d6 a2 fd e3 e2 be 2f  |..0...A]......./|
+000002b0  69 b5 7d 5c a3 2b 36 4c  8b 81 05 89 12 e1 30 26  |i.}\.+6L......0&|
+000002c0  fa ae 82 b9 4f 8e ba ac  ee 7b 62 d5 60 f8 df a4  |....O....{b.`...|
+000002d0  c1 a1 15 73 f8 fb 0b 47  64 b3 34 4a 44 02 a6 32  |...s...Gd.4JD..2|
+000002e0  bc 0d 7b a5 c1 84 cf 77  02 42 01 f3 e5 7f d1 47  |..{....w.B.....G|
+000002f0  bc be 0a ec cd d6 4f 2c  26 5a 95 d3 0f 9b c3 c6  |......O,&Z......|
+00000300  05 b5 5e d7 f6 ca 64 17  94 aa a5 e6 b1 88 57 21  |..^...d.......W!|
+00000310  f8 da 02 de 32 8c ea 5b  7c 36 c9 93 e1 96 38 93  |....2..[|6....8.|
+00000320  9b f9 e5 44 47 a6 74 fa  0e 5f 8f 22 16 03 03 00  |...DG.t.._."....|
 00000330  04 0e 00 00 00                                    |.....|
 >>> Flow 3 (client to server)
 00000000  16 03 03 00 25 10 00 00  21 20 2f e5 7d a3 47 cd  |....%...! /.}.G.|
 00000010  62 43 15 28 da ac 5f bb  29 07 30 ff f6 84 af c4  |bC.(.._.).0.....|
 00000020  cf c2 ed 90 99 5f 58 cb  3b 74 14 03 03 00 01 01  |....._X.;t......|
 00000030  16 03 03 00 50 00 00 00  00 00 00 00 00 00 00 00  |....P...........|
-00000040  00 00 00 00 00 d3 72 3f  9d 37 ba 97 55 83 b4 f0  |......r?.7..U...|
-00000050  ad 0b f0 48 98 16 05 f1  b5 6e da a4 79 e4 d9 8e  |...H.....n..y...|
-00000060  62 af b9 a1 d1 a4 5c 04  d2 b1 86 32 af 64 ac 89  |b.....\....2.d..|
-00000070  d3 47 5f 61 ae f4 21 5b  8d 4b ff 74 c1 b8 9c de  |.G_a..![.K.t....|
-00000080  fd 74 a0 99 c1                                    |.t...|
+00000040  00 00 00 00 00 85 db ae  c1 37 85 25 3d ee 5f f5  |.........7.%=._.|
+00000050  12 95 df ee 29 4a f7 3a  80 ca bd c2 b3 d8 f3 8c  |....)J.:........|
+00000060  56 62 d2 68 13 1d 73 51  09 93 a3 b9 43 4a 2c 0f  |Vb.h..sQ....CJ,.|
+00000070  bf 3c 96 76 08 a9 17 68  e2 9a 3f 39 e7 04 76 f8  |.<.v...h..?9..v.|
+00000080  8f fe e8 f5 ce                                    |.....|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 50 09 3b 3e 7e 2e  |..........P.;>~.|
-00000010  d8 46 04 ac b0 3d c9 7e  ec 28 8c bd 6c 0f a8 b5  |.F...=.~.(..l...|
-00000020  af 8c 86 ed 64 81 6c d4  98 9e 56 2a 48 0d 03 40  |....d.l...V*H..@|
-00000030  64 3e 25 58 6f 03 6a 4e  be a2 11 6f 6f e7 2f c2  |d>%Xo.jN...oo./.|
-00000040  8f 78 c4 11 a1 07 21 91  9d 34 01 08 39 0d 07 d2  |.x....!..4..9...|
-00000050  d4 a2 cc 2f 25 ea ee 8d  8b 91 f9                 |.../%......|
+00000000  14 03 03 00 01 01 16 03  03 00 50 fa 85 cc bc dd  |..........P.....|
+00000010  0e 16 86 b1 5c 51 8a b9  cc 78 cd cd 64 5d 23 ca  |....\Q...x..d]#.|
+00000020  59 84 b3 42 dd ae a7 98  43 05 21 4f 35 43 75 5c  |Y..B....C.!O5Cu\|
+00000030  13 c8 e0 b6 66 0f 55 32  69 7a 8b 8f cd c2 37 38  |....f.U2iz....78|
+00000040  f6 fa 0b 66 cf 46 91 3e  9f f5 43 44 f5 c7 2b e1  |...f.F.>..CD..+.|
+00000050  39 3a f7 3c f2 03 c4 85  dc 58 66                 |9:.<.....Xf|
 >>> Flow 5 (client to server)
 00000000  17 03 03 00 40 00 00 00  00 00 00 00 00 00 00 00  |....@...........|
-00000010  00 00 00 00 00 1d 76 4c  fb 46 f8 02 9a bc 07 8d  |......vL.F......|
-00000020  b0 52 40 44 58 da ad be  3c a6 d7 44 0f 59 98 f3  |.R@DX...<..D.Y..|
-00000030  ae 5c d2 04 bb 07 ee f6  99 9d 2c 14 44 3b 90 bc  |.\........,.D;..|
-00000040  2b e9 bc 37 59 15 03 03  00 40 00 00 00 00 00 00  |+..7Y....@......|
-00000050  00 00 00 00 00 00 00 00  00 00 c4 ef 97 87 35 a2  |..............5.|
-00000060  2f cc c2 6f 3d d5 f5 6f  fd 74 56 50 37 f8 10 e8  |/..o=..o.tVP7...|
-00000070  36 f5 fb 6f 7b 5d 20 07  0d 2f 72 46 a7 3a e0 de  |6..o{] ../rF.:..|
-00000080  39 b3 76 0e 4f c0 e7 85  4b bb                    |9.v.O...K.|
+00000010  00 00 00 00 00 44 e6 99  40 ae 12 bc d9 92 c5 ae  |.....D..@.......|
+00000020  fb 4d 5f 64 7a 77 0f 80  8e a4 be d0 ba ba 41 b1  |.M_dzw........A.|
+00000030  0d 40 e9 0e 50 32 dc 35  2d 5e 5c 8a ef 20 75 80  |.@..P2.5-^\.. u.|
+00000040  a0 e5 9c 61 49 15 03 03  00 40 00 00 00 00 00 00  |...aI....@......|
+00000050  00 00 00 00 00 00 00 00  00 00 57 91 40 2a a5 f7  |..........W.@*..|
+00000060  9f 29 0f 02 8e 50 ac 4b  2e 55 9a 78 72 f0 d7 c5  |.)...P.K.U.xr...|
+00000070  3b f2 cd 28 4d 8b 49 d8  50 a6 22 96 de df 16 d6  |;..(M.I.P.".....|
+00000080  61 4b 23 5c 5d de a1 0a  5b 16                    |aK#\]...[.|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-ECDHE-ECDSA-AES256-GCM-SHA384 b/src/crypto/tls/testdata/Client-TLSv12-ECDHE-ECDSA-AES256-GCM-SHA384
index 90a1639e99..14af5ae75f 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-ECDHE-ECDSA-AES256-GCM-SHA384
+++ b/src/crypto/tls/testdata/Client-TLSv12-ECDHE-ECDSA-AES256-GCM-SHA384
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 59 02 00 00  55 03 03 b8 16 bd ae 15  |....Y...U.......|
-00000010  a3 33 52 cc 60 dc 6c fe  7c f3 82 b9 1e 13 ab 87  |.3R.`.l.|.......|
-00000020  22 d8 c3 38 dc 8a 76 bb  a0 a3 fd 20 8a d1 92 d1  |"..8..v.... ....|
-00000030  d6 f3 76 e0 e2 76 32 95  32 a0 eb 5b dc e4 42 81  |..v..v2.2..[..B.|
-00000040  14 bb 58 ab b8 e8 9d ee  fa 32 58 05 c0 2c 00 00  |..X......2X..,..|
+00000000  16 03 03 00 59 02 00 00  55 03 03 bb 8a 66 ee 44  |....Y...U....f.D|
+00000010  42 dc 59 c7 a7 7b a8 57  8e 63 21 f0 4e 31 f4 5c  |B.Y..{.W.c!.N1.\|
+00000020  1d d3 42 e5 de eb 8c 78  3a 01 01 20 9b 89 05 d6  |..B....x:.. ....|
+00000030  d2 07 38 8b 4c 5f 6d 62  9f 43 a0 cd d3 40 0f 77  |..8.L_mb.C...@.w|
+00000040  17 ff 43 4a 5c b3 8c 83  b7 4b c7 e7 c0 2c 00 00  |..CJ\....K...,..|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  03 02 0e 0b 00 02 0a 00  02 07 00 02 04 30 82 02  |.............0..|
 00000070  00 30 82 01 62 02 09 00  b8 bf 2d 47 a0 d2 eb f4  |.0..b.....-G....|
@@ -55,34 +55,34 @@
 00000240  13 83 0d 94 06 bb d4 37  7a f6 ec 7a c9 86 2e dd  |.......7z..z....|
 00000250  d7 11 69 7f 85 7c 56 de  fb 31 78 2b e4 c7 78 0d  |..i..|V..1x+..x.|
 00000260  ae cb be 9e 4e 36 24 31  7b 6a 0f 39 95 12 07 8f  |....N6$1{j.9....|
-00000270  2a 16 03 03 00 b6 0c 00  00 b2 03 00 1d 20 5c 9b  |*............ \.|
-00000280  9b 29 5c 83 36 b8 20 47  2b 04 0d 1b ab f5 f7 81  |.)\.6. G+.......|
-00000290  aa 89 b4 93 37 aa 28 4e  44 e1 22 26 b6 46 04 03  |....7.(ND."&.F..|
-000002a0  00 8a 30 81 87 02 42 01  2c 87 df 1f 07 86 36 c8  |..0...B.,.....6.|
-000002b0  f6 aa 41 c1 8e 99 6e 12  08 5f e2 62 4b 3a 9b ad  |..A...n.._.bK:..|
-000002c0  e8 26 1c 95 f9 62 c6 f6  c7 e4 f7 db 3b 23 e5 4f  |.&...b......;#.O|
-000002d0  03 a1 c6 89 74 cb bd 2a  4e 47 3f 0f bf 28 bb 6d  |....t..*NG?..(.m|
-000002e0  c0 c6 53 4c 02 0b 9a 30  2d 02 41 0c 6f 26 a5 4c  |..SL...0-.A.o&.L|
-000002f0  b6 6c 8c ab 82 32 19 a0  f0 1b 41 2d 9d 1d 12 1b  |.l...2....A-....|
-00000300  91 62 6a 3d 17 92 79 f6  59 45 21 2f 6b d0 cb 7b  |.bj=..y.YE!/k..{|
-00000310  22 b3 79 80 90 90 81 97  06 c8 59 fd 8b 40 f9 ec  |".y.......Y..@..|
-00000320  80 58 db fc 5e a2 67 9a  96 01 53 d4 16 03 03 00  |.X..^.g...S.....|
-00000330  04 0e 00 00 00                                    |.....|
+00000270  2a 16 03 03 00 b7 0c 00  00 b3 03 00 1d 20 fd 71  |*............ .q|
+00000280  c1 3a 6a a3 69 6a 34 f3  02 c5 1d e5 db 63 f4 eb  |.:j.ij4......c..|
+00000290  97 4c 70 bc b3 4e 9d 2c  2f b2 b9 9d ac 3f 04 03  |.Lp..N.,/....?..|
+000002a0  00 8b 30 81 88 02 42 01  bd 9d ad 24 37 b9 60 55  |..0...B....$7.`U|
+000002b0  e4 cc bc 49 c3 88 3b ed  ac e4 42 8e fa 81 01 d9  |...I..;...B.....|
+000002c0  39 4c f0 1c 7d 39 a2 81  8a e1 17 0e 8d 37 76 96  |9L..}9.......7v.|
+000002d0  37 13 3a 1e 2e fd 0d 0a  3c 90 9d 43 3d 06 c0 b1  |7.:.....<..C=...|
+000002e0  4e 07 3e c3 9f f2 43 40  0b 02 42 01 d6 d0 20 ad  |N.>...C@..B... .|
+000002f0  48 09 c0 9b 5d c8 84 46  3b 98 37 9b 5a 91 4a 07  |H...]..F;.7.Z.J.|
+00000300  79 68 71 92 76 dc 70 0f  5c 44 7e 81 c3 c6 3f 19  |yhq.v.p.\D~...?.|
+00000310  f4 0f 6a 0b aa cc bb 65  e7 34 b5 e9 67 2d 32 98  |..j....e.4..g-2.|
+00000320  1c f6 76 4c 96 73 df 21  d6 e1 ea 34 86 16 03 03  |..vL.s.!...4....|
+00000330  00 04 0e 00 00 00                                 |......|
 >>> Flow 3 (client to server)
 00000000  16 03 03 00 25 10 00 00  21 20 2f e5 7d a3 47 cd  |....%...! /.}.G.|
 00000010  62 43 15 28 da ac 5f bb  29 07 30 ff f6 84 af c4  |bC.(.._.).0.....|
 00000020  cf c2 ed 90 99 5f 58 cb  3b 74 14 03 03 00 01 01  |....._X.;t......|
-00000030  16 03 03 00 28 00 00 00  00 00 00 00 00 17 be e6  |....(...........|
-00000040  ba 39 2d 82 38 6e 09 2c  1c ef d5 1f ad 8e e0 47  |.9-.8n.,.......G|
-00000050  2d bc 74 f8 3b ed 86 89  9e e9 a5 01 40           |-.t.;.......@|
+00000030  16 03 03 00 28 00 00 00  00 00 00 00 00 27 fd 98  |....(........'..|
+00000040  47 79 56 f9 e8 0e fd 18  c2 8f 2d 32 51 f7 19 b5  |GyV.......-2Q...|
+00000050  ab 2f 81 ed b6 cf 6f b5  65 81 81 f1 44           |./....o.e...D|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 28 42 3b b0 5e 66  |..........(B;.^f|
-00000010  3e ef a5 3d 49 64 42 34  b1 21 d6 43 d3 f6 f5 84  |>..=IdB4.!.C....|
-00000020  21 96 b4 7b ed 73 b5 23  b6 40 cf 86 ab 71 59 58  |!..{.s.#.@...qYX|
-00000030  3a bf 79                                          |:.y|
+00000000  14 03 03 00 01 01 16 03  03 00 28 a9 b7 63 61 57  |..........(..caW|
+00000010  54 57 f0 b2 60 58 e3 dc  6e e1 40 3e 67 b4 99 8f  |TW..`X..n.@>g...|
+00000020  e9 6b 11 f1 1a 54 bd c1  d3 b9 5b 01 12 27 a4 0b  |.k...T....[..'..|
+00000030  e9 ec 01                                          |...|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 1e 00 00 00  00 00 00 00 01 8d 3c f7  |..............<.|
-00000010  9e da 91 15 35 10 5f a4  29 32 3f 6a 8c 1d bc 13  |....5._.)2?j....|
-00000020  8a 35 2b 15 03 03 00 1a  00 00 00 00 00 00 00 02  |.5+.............|
-00000030  1f b3 e3 e3 24 ac 7a a6  ee 81 e7 cc 9e 70 34 2c  |....$.z......p4,|
-00000040  d2 28                                             |.(|
+00000000  17 03 03 00 1e 00 00 00  00 00 00 00 01 e0 8a 6e  |...............n|
+00000010  62 5d e3 db 99 10 d2 53  b6 21 2e 79 31 cf 71 1d  |b].....S.!.y1.q.|
+00000020  34 71 2a 15 03 03 00 1a  00 00 00 00 00 00 00 02  |4q*.............|
+00000030  e7 4a 8d b9 2f 1b b1 70  72 da 7f d8 fa 4f 9f d6  |.J../..pr....O..|
+00000040  ca f3                                             |..|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-ECDHE-ECDSA-CHACHA20-POLY1305 b/src/crypto/tls/testdata/Client-TLSv12-ECDHE-ECDSA-CHACHA20-POLY1305
index 1b3c37be24..3113b3c6e5 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-ECDHE-ECDSA-CHACHA20-POLY1305
+++ b/src/crypto/tls/testdata/Client-TLSv12-ECDHE-ECDSA-CHACHA20-POLY1305
@@ -4,7 +4,7 @@
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 08 cc a9  |................|
-00000050  13 01 13 03 13 02 01 00  00 7b 00 05 00 05 01 00  |.........{......|
+00000050  13 03 13 01 13 02 01 00  00 7b 00 05 00 05 01 00  |.........{......|
 00000060  00 00 00 00 0a 00 0a 00  08 00 1d 00 17 00 18 00  |................|
 00000070  19 00 0b 00 02 01 00 00  0d 00 1a 00 18 08 04 04  |................|
 00000080  03 08 07 08 05 08 06 04  01 05 01 06 01 05 03 06  |................|
@@ -14,11 +14,11 @@
 000000c0  ac 5f bb 29 07 30 ff f6  84 af c4 cf c2 ed 90 99  |._.).0..........|
 000000d0  5f 58 cb 3b 74                                    |_X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 59 02 00 00  55 03 03 ea 73 50 31 e4  |....Y...U...sP1.|
-00000010  7a c7 e2 05 23 a0 22 e3  1a cd 6d b5 0f e7 f2 5e  |z...#."...m....^|
-00000020  d6 cb 6c 70 05 04 a9 63  4a a3 fc 20 a2 c5 68 f2  |..lp...cJ.. ..h.|
-00000030  9b 56 6e 83 66 c1 7f 85  02 b6 6d 37 12 0f 12 5a  |.Vn.f.....m7...Z|
-00000040  41 7e c3 c9 44 85 3c 00  50 6f c7 f9 cc a9 00 00  |A~..D.<.Po......|
+00000000  16 03 03 00 59 02 00 00  55 03 03 e1 cc 3c 49 04  |....Y...U....<I.|
+00000010  bb 5b 18 c7 44 8f 52 62  d9 74 84 94 fa 61 3f 12  |.[..D.Rb.t...a?.|
+00000020  c8 23 50 0b 8a 5c 81 23  c2 9d 3d 20 1f b2 67 b0  |.#P..\.#..= ..g.|
+00000030  e9 2d a9 ed 35 4e ab b9  73 59 32 2f 49 ed 1e 60  |.-..5N..sY2/I..`|
+00000040  4c 31 11 6e 27 79 e0 62  e0 e4 ca 16 cc a9 00 00  |L1.n'y.b........|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  03 02 0e 0b 00 02 0a 00  02 07 00 02 04 30 82 02  |.............0..|
 00000070  00 30 82 01 62 02 09 00  b8 bf 2d 47 a0 d2 eb f4  |.0..b.....-G....|
@@ -53,32 +53,32 @@
 00000240  13 83 0d 94 06 bb d4 37  7a f6 ec 7a c9 86 2e dd  |.......7z..z....|
 00000250  d7 11 69 7f 85 7c 56 de  fb 31 78 2b e4 c7 78 0d  |..i..|V..1x+..x.|
 00000260  ae cb be 9e 4e 36 24 31  7b 6a 0f 39 95 12 07 8f  |....N6$1{j.9....|
-00000270  2a 16 03 03 00 b7 0c 00  00 b3 03 00 1d 20 a4 6a  |*............ .j|
-00000280  0d ab f2 7c 1a 31 2a 7d  51 b7 fe 69 cd 59 f5 c1  |...|.1*}Q..i.Y..|
-00000290  10 94 a0 b2 6f 6f c4 48  48 9b 20 1e 46 2a 04 03  |....oo.HH. .F*..|
-000002a0  00 8b 30 81 88 02 42 00  84 2a 96 88 a4 7a 86 7f  |..0...B..*...z..|
-000002b0  cf 86 20 37 17 de 54 0c  c2 89 5e 27 f4 3b a4 ec  |.. 7..T...^'.;..|
-000002c0  ce 25 34 4e c7 a8 7d f5  56 6d 96 2c d0 53 ae 42  |.%4N..}.Vm.,.S.B|
-000002d0  b5 87 a9 20 9c 4f c9 67  7e ca f6 fc 2f 61 72 35  |... .O.g~.../ar5|
-000002e0  78 fe 54 32 1e a1 90 88  c2 02 42 01 a6 7b 98 de  |x.T2......B..{..|
-000002f0  fd 01 4b 4a 8f 1a e8 18  dd 07 bb 0b 38 41 7f 22  |..KJ........8A."|
-00000300  62 3b 7e 37 67 b7 18 46  a7 32 43 1b c9 a9 8a a6  |b;~7g..F.2C.....|
-00000310  d7 8a 2f 7b c5 14 f3 33  96 fe 0a fc 22 d0 a5 02  |../{...3...."...|
-00000320  37 a5 31 5f b9 6b d2 3b  f6 d0 d1 7b a1 16 03 03  |7.1_.k.;...{....|
-00000330  00 04 0e 00 00 00                                 |......|
+00000270  2a 16 03 03 00 b6 0c 00  00 b2 03 00 1d 20 cc a1  |*............ ..|
+00000280  4d a4 b1 22 86 e5 91 9b  e2 1a 28 c6 66 06 1a 89  |M.."......(.f...|
+00000290  a9 62 23 93 09 54 ae 67  a8 ab 18 ac 67 37 04 03  |.b#..T.g....g7..|
+000002a0  00 8a 30 81 87 02 42 01  f0 46 f3 3f 13 a7 1d 84  |..0...B..F.?....|
+000002b0  73 65 9e 91 16 6c 3d 8f  21 ab 17 db 24 34 21 8c  |se...l=.!...$4!.|
+000002c0  a9 e1 9b a6 17 c8 0d 7a  b4 8e f0 46 cd c5 b9 b2  |.......z...F....|
+000002d0  5e 64 7f 9f 9d 03 14 7a  23 5d 55 70 ae d1 ff 08  |^d.....z#]Up....|
+000002e0  e8 70 f5 5d 55 90 74 04  0d 02 41 09 ca 7d 60 ea  |.p.]U.t...A..}`.|
+000002f0  13 17 42 e8 53 e7 c5 31  15 4a 58 14 d6 54 f5 40  |..B.S..1.JX..T.@|
+00000300  a1 aa fe 4b 13 f5 29 04  05 cc 12 26 e2 b7 e5 a6  |...K..)....&....|
+00000310  90 7c 5e 66 2f ed 41 7c  97 a1 72 87 5e 46 5a 5b  |.|^f/.A|..r.^FZ[|
+00000320  1b d1 7b 3c 34 ba 3f 47  7d a9 84 33 16 03 03 00  |..{<4.?G}..3....|
+00000330  04 0e 00 00 00                                    |.....|
 >>> Flow 3 (client to server)
 00000000  16 03 03 00 25 10 00 00  21 20 2f e5 7d a3 47 cd  |....%...! /.}.G.|
 00000010  62 43 15 28 da ac 5f bb  29 07 30 ff f6 84 af c4  |bC.(.._.).0.....|
 00000020  cf c2 ed 90 99 5f 58 cb  3b 74 14 03 03 00 01 01  |....._X.;t......|
-00000030  16 03 03 00 20 f5 a0 28  0a 7e d4 8b a2 b6 e1 af  |.... ..(.~......|
-00000040  83 e2 50 e8 fc 7e f0 59  21 ed 3d 0d a8 ef a9 b1  |..P..~.Y!.=.....|
-00000050  5a 13 2a 1b 2c                                    |Z.*.,|
+00000030  16 03 03 00 20 7f ab 78  f0 a6 b6 57 bd c3 b9 32  |.... ..x...W...2|
+00000040  96 3f 7c 9d a0 4d dc 74  c9 e8 1a 88 c4 b2 10 27  |.?|..M.t.......'|
+00000050  e3 9c 1e 9b e1                                    |.....|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 20 44 15 68 4d e0  |.......... D.hM.|
-00000010  3b 34 c5 77 b2 25 f2 e9  35 75 08 f5 a9 53 c9 65  |;4.w.%..5u...S.e|
-00000020  19 36 49 fe 43 e4 f5 48  ac 7c d7                 |.6I.C..H.|.|
+00000000  14 03 03 00 01 01 16 03  03 00 20 0c b7 0c 47 8e  |.......... ...G.|
+00000010  40 6b 9f 9c d2 cd 24 25  db 12 e8 0c 50 be f3 98  |@k....$%....P...|
+00000020  4a 6f f9 42 58 07 b9 64  d0 00 91                 |Jo.BX..d...|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 16 f7 fd 2a  83 90 01 f3 d2 82 dc bd  |.......*........|
-00000010  6c 33 31 a3 92 0f a4 f5  9c fa f4 15 03 03 00 12  |l31.............|
-00000020  9e 60 18 02 f1 0d 2f f5  5f 68 69 ae 62 93 04 6a  |.`..../._hi.b..j|
-00000030  41 f0                                             |A.|
+00000000  17 03 03 00 16 1d 32 1c  ef 0b 1f a4 ba 39 a3 63  |......2......9.c|
+00000010  04 29 e5 67 1e bb 5a 6e  c7 3c c1 15 03 03 00 12  |.).g..Zn.<......|
+00000020  0e 0b 0f 49 30 fe d4 c3  35 85 e3 db 6e 65 e3 2d  |...I0...5...ne.-|
+00000030  d1 1d                                             |..|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-ECDHE-RSA-AES b/src/crypto/tls/testdata/Client-TLSv12-ECDHE-RSA-AES
index eff5b979f9..ea6c7872ec 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-ECDHE-RSA-AES
+++ b/src/crypto/tls/testdata/Client-TLSv12-ECDHE-RSA-AES
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 59 02 00 00  55 03 03 f1 07 97 47 f7  |....Y...U.....G.|
-00000010  b8 42 f5 ce 2b b5 ec 5a  d3 74 f1 fa 1f ea ec 6d  |.B..+..Z.t.....m|
-00000020  49 4e cf 2e 47 8b 2e 80  9b 8a ed 20 89 ca 35 4a  |IN..G...... ..5J|
-00000030  f4 35 5e b7 ed b2 96 ad  e1 66 1d 43 9d 07 ba ed  |.5^......f.C....|
-00000040  ff 9d 47 65 c8 7d 91 32  4b 88 4d 83 c0 13 00 00  |..Ge.}.2K.M.....|
+00000000  16 03 03 00 59 02 00 00  55 03 03 1e 2f 6f fa 02  |....Y...U.../o..|
+00000010  44 3e 0d d0 3e b5 e6 0c  a2 d6 aa 04 5b ba 93 39  |D>..>.......[..9|
+00000020  29 dd e7 7e b8 11 f9 85  97 a5 e4 20 9c 64 e9 47  |)..~....... .d.G|
+00000030  cb 7c 0c 77 9d 83 5a c4  e8 05 62 40 95 8e 8e aa  |.|.w..Z...b@....|
+00000040  39 bb 24 8f b7 29 75 77  18 66 60 29 c0 13 00 00  |9.$..)uw.f`)....|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  03 02 59 0b 00 02 55 00  02 52 00 02 4f 30 82 02  |..Y...U..R..O0..|
 00000070  4b 30 82 01 b4 a0 03 02  01 02 02 09 00 e8 f0 9d  |K0..............|
@@ -60,38 +60,38 @@
 00000290  77 8d 0c 1c f1 0f a1 d8  40 83 61 c9 4c 72 2b 9d  |w.......@.a.Lr+.|
 000002a0  ae db 46 06 06 4d f4 c1  b3 3e c0 d1 bd 42 d4 db  |..F..M...>...B..|
 000002b0  fe 3d 13 60 84 5c 21 d3  3b e9 fa e7 16 03 03 00  |.=.`.\!.;.......|
-000002c0  ac 0c 00 00 a8 03 00 1d  20 78 22 92 20 a9 be 78  |........ x". ..x|
-000002d0  12 0f e6 83 13 3d 13 91  16 11 ca 26 9f b7 37 d5  |.....=.....&..7.|
-000002e0  f0 97 f9 f2 01 fd 08 4f  42 08 04 00 80 2c f1 4e  |.......OB....,.N|
-000002f0  79 63 f2 d9 54 1c 0c 56  fd 56 4d e0 37 ee 5d bb  |yc..T..V.VM.7.].|
-00000300  22 90 fd ee d9 0f e6 d9  85 41 b9 8d d6 76 5f 05  |"........A...v_.|
-00000310  1b 8c d7 4e c5 e8 4e 69  b9 5d de 73 c0 ed 4f 3e  |...N..Ni.].s..O>|
-00000320  09 9d b0 10 d6 61 87 d8  f9 c2 5b 48 f9 ef dd 65  |.....a....[H...e|
-00000330  e6 f8 b0 d2 71 f6 e9 ae  b1 c0 ea 90 dc 33 c6 72  |....q........3.r|
-00000340  3e 9f 31 d4 ae 78 23 54  7a 4f 02 69 72 c1 06 2f  |>.1..x#TzO.ir../|
-00000350  3f 3c 7b f2 d8 17 40 a6  95 6d 46 62 6b 54 f1 cf  |?<{...@..mFbkT..|
-00000360  60 08 63 89 f7 a5 2a 52  3b 0e 0c d6 34 16 03 03  |`.c...*R;...4...|
+000002c0  ac 0c 00 00 a8 03 00 1d  20 92 ed 81 60 d9 51 c2  |........ ...`.Q.|
+000002d0  00 3d 99 84 82 c5 83 67  60 b3 11 59 0c c5 5d ff  |.=.....g`..Y..].|
+000002e0  d6 28 79 68 2d 73 7f 84  40 08 04 00 80 b6 a0 4b  |.(yh-s..@......K|
+000002f0  3d fb e1 e6 76 cc ae e3  59 d0 1c 50 5c 09 5d 80  |=...v...Y..P\.].|
+00000300  c2 58 0d 36 d7 1a 78 e3  c2 66 73 3a 14 06 37 6f  |.X.6..x..fs:..7o|
+00000310  3a 95 2e 2a eb cc e5 e3  f7 30 eb 0d 33 04 51 6e  |:..*.....0..3.Qn|
+00000320  06 86 8f 53 6d fd 97 75  b3 13 2e 4e ee 8f 03 68  |...Sm..u...N...h|
+00000330  23 32 83 96 af 01 ed b0  21 a7 13 06 47 f4 08 b9  |#2......!...G...|
+00000340  8a 47 cc 12 99 20 c6 31  77 28 2c 2e d6 a0 20 8c  |.G... .1w(,... .|
+00000350  e6 67 c7 70 23 ed 98 9c  c9 47 1c e0 37 95 42 aa  |.g.p#....G..7.B.|
+00000360  c2 19 1b 55 09 5c 58 fb  ef 67 a9 b5 65 16 03 03  |...U.\X..g..e...|
 00000370  00 04 0e 00 00 00                                 |......|
 >>> Flow 3 (client to server)
 00000000  16 03 03 00 25 10 00 00  21 20 2f e5 7d a3 47 cd  |....%...! /.}.G.|
 00000010  62 43 15 28 da ac 5f bb  29 07 30 ff f6 84 af c4  |bC.(.._.).0.....|
 00000020  cf c2 ed 90 99 5f 58 cb  3b 74 14 03 03 00 01 01  |....._X.;t......|
 00000030  16 03 03 00 40 00 00 00  00 00 00 00 00 00 00 00  |....@...........|
-00000040  00 00 00 00 00 96 55 d3  bd a1 b6 de 93 68 19 ed  |......U......h..|
-00000050  4a 3a cc 42 7c c4 41 1e  b5 37 65 d5 84 10 60 3d  |J:.B|.A..7e...`=|
-00000060  e9 57 29 28 79 54 da 6c  1b 36 6b b1 75 f4 bb 32  |.W)(yT.l.6k.u..2|
-00000070  47 8d de c8 7d                                    |G...}|
+00000040  00 00 00 00 00 dd 81 23  e0 a3 01 33 bb 87 0d 93  |.......#...3....|
+00000050  b2 61 16 01 e3 87 e0 05  cc b0 ec 15 56 df ff 9c  |.a..........V...|
+00000060  e6 9c 6a 57 79 8a 0b 86  f9 fb 60 3f ca 0d ef f2  |..jWy.....`?....|
+00000070  81 c0 5e 22 bf                                    |..^".|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 40 db ed ec 54 4a  |..........@...TJ|
-00000010  20 d8 a7 ee 12 04 e2 e4  95 b4 a4 a7 e1 80 c8 40  | ..............@|
-00000020  81 00 6d 3e 58 26 7c d4  26 84 86 ee b4 fc c5 50  |..m>X&|.&......P|
-00000030  46 31 e7 4c 1e fd ed 10  7e 72 45 18 43 db 4c 0d  |F1.L....~rE.C.L.|
-00000040  b5 49 6c 31 04 f0 85 a7  f8 02 e1                 |.Il1.......|
+00000000  14 03 03 00 01 01 16 03  03 00 40 d4 d3 ba 7f 4c  |..........@....L|
+00000010  1a ee d9 ca 66 a0 5b d7  08 78 5d 5c fd 17 32 71  |....f.[..x]\..2q|
+00000020  7f 8c 2e eb 80 bc 82 0f  0c ed 71 ac 34 59 71 d1  |..........q.4Yq.|
+00000030  aa d3 fd 0c 50 7d 4b 1b  01 5d 4c 03 9f 6c 16 8f  |....P}K..]L..l..|
+00000040  5d f7 8d c0 4b 3f 01 96  23 40 22                 |]...K?..#@"|
 >>> Flow 5 (client to server)
 00000000  17 03 03 00 30 00 00 00  00 00 00 00 00 00 00 00  |....0...........|
-00000010  00 00 00 00 00 90 f7 06  a7 05 8d de 51 21 88 95  |............Q!..|
-00000020  47 61 fb 8d a9 c9 6d 59  ca 92 8d 07 8b 9d 82 4e  |Ga....mY.......N|
-00000030  fd e9 ae 3d b0 15 03 03  00 30 00 00 00 00 00 00  |...=.....0......|
-00000040  00 00 00 00 00 00 00 00  00 00 12 77 0c 5f 12 4b  |...........w._.K|
-00000050  96 ab 64 58 6e f5 82 09  6c 18 ae 1f a2 fb 0a 3b  |..dXn...l......;|
-00000060  71 17 25 8b c8 72 d0 13  fb e8                    |q.%..r....|
+00000010  00 00 00 00 00 36 49 0e  f6 26 13 f7 69 15 54 27  |.....6I..&..i.T'|
+00000020  5a e6 f2 fb 7d ad e0 30  d3 cd ed 08 24 74 5f 77  |Z...}..0....$t_w|
+00000030  f7 8b 3f bf 94 15 03 03  00 30 00 00 00 00 00 00  |..?......0......|
+00000040  00 00 00 00 00 00 00 00  00 00 28 09 ed 2f d8 6f  |..........(../.o|
+00000050  95 fc db 9e ec d8 81 7e  a4 d4 8e c5 ec d3 24 bc  |.......~......$.|
+00000060  ab 52 e6 01 75 98 b9 e5  9f d9                    |.R..u.....|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-ECDHE-RSA-AES128-SHA256 b/src/crypto/tls/testdata/Client-TLSv12-ECDHE-RSA-AES128-SHA256
index 4f8f49eb6a..88d0d01483 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-ECDHE-RSA-AES128-SHA256
+++ b/src/crypto/tls/testdata/Client-TLSv12-ECDHE-RSA-AES128-SHA256
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 59 02 00 00  55 03 03 9e d4 c1 3e c6  |....Y...U.....>.|
-00000010  3d 44 eb a7 b8 c5 c8 e0  ab 16 06 83 67 5e b2 d6  |=D..........g^..|
-00000020  67 50 4b f3 24 17 97 19  76 7e 71 20 5a 2b dc 15  |gPK.$...v~q Z+..|
-00000030  87 37 be bb c7 9c 38 cd  3e 55 4e 33 32 a0 01 1b  |.7....8.>UN32...|
-00000040  79 13 87 6a 19 09 42 4c  fb 59 97 a8 c0 27 00 00  |y..j..BL.Y...'..|
+00000000  16 03 03 00 59 02 00 00  55 03 03 e6 04 5e a9 bb  |....Y...U....^..|
+00000010  23 56 bd cc e7 72 9f 10  b1 fc 23 48 22 19 cb 27  |#V...r....#H"..'|
+00000020  3e c4 22 ec b9 7a 9c 81  60 c5 55 20 b9 7f 8a 0e  |>."..z..`.U ....|
+00000030  6b d6 cf cb 35 85 52 f3  9f 28 00 87 22 88 6d 7c  |k...5.R..(..".m||
+00000040  35 0e f6 af 7c 28 b4 71  cc 46 c1 b5 c0 27 00 00  |5...|(.q.F...'..|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  03 02 59 0b 00 02 55 00  02 52 00 02 4f 30 82 02  |..Y...U..R..O0..|
 00000070  4b 30 82 01 b4 a0 03 02  01 02 02 09 00 e8 f0 9d  |K0..............|
@@ -60,42 +60,42 @@
 00000290  77 8d 0c 1c f1 0f a1 d8  40 83 61 c9 4c 72 2b 9d  |w.......@.a.Lr+.|
 000002a0  ae db 46 06 06 4d f4 c1  b3 3e c0 d1 bd 42 d4 db  |..F..M...>...B..|
 000002b0  fe 3d 13 60 84 5c 21 d3  3b e9 fa e7 16 03 03 00  |.=.`.\!.;.......|
-000002c0  ac 0c 00 00 a8 03 00 1d  20 57 62 97 e9 c8 c6 17  |........ Wb.....|
-000002d0  73 d2 9e 31 a6 f8 be 03  65 86 af 6b e2 64 bf 7c  |s..1....e..k.d.||
-000002e0  4a f1 b9 fb 84 21 10 76  66 08 04 00 80 2d 08 24  |J....!.vf....-.$|
-000002f0  06 2a a3 c5 28 c4 22 5b  fe 79 4f 91 56 9e 40 6f  |.*..(."[.yO.V.@o|
-00000300  e6 0c e8 70 e0 35 9e 55  91 51 86 ec ad ff 6b 3f  |...p.5.U.Q....k?|
-00000310  a7 19 fa 6f 74 47 8a 86  04 b5 8a f0 0a d5 e5 5f  |...otG........._|
-00000320  ea 30 cc 79 77 3d ac 99  da 41 7f 25 3b da cd da  |.0.yw=...A.%;...|
-00000330  aa 4e 2a 54 b5 d3 13 4f  e4 e9 cb 76 86 fb 0b b5  |.N*T...O...v....|
-00000340  0d a3 be ab d2 e6 6e f6  77 7c 60 a7 50 56 43 60  |......n.w|`.PVC`|
-00000350  95 ba 95 c4 b5 1a 8d 6a  f7 a5 9f 03 27 93 9f 23  |.......j....'..#|
-00000360  44 27 88 f0 d5 51 0f ba  43 84 5c 02 14 16 03 03  |D'...Q..C.\.....|
+000002c0  ac 0c 00 00 a8 03 00 1d  20 55 af 53 a0 54 77 df  |........ U.S.Tw.|
+000002d0  ca 8f 49 1a 4d d0 9b 24  a6 a9 2b b2 2a 33 46 b8  |..I.M..$..+.*3F.|
+000002e0  01 d6 4e fd fb c1 e4 e6  64 08 04 00 80 5c da 2f  |..N.....d....\./|
+000002f0  01 2b 10 b9 e9 35 f2 b1  2a 28 4f 78 58 7b 3d 9a  |.+...5..*(OxX{=.|
+00000300  13 e4 7c 77 41 95 fa 7a  90 1f eb f5 20 55 7c 76  |..|wA..z.... U|v|
+00000310  dd c5 66 08 88 eb ba 17  f0 de f3 0c a5 a6 3c 21  |..f...........<!|
+00000320  52 89 25 b1 4d 86 e3 0b  8a 14 dc 8b a6 76 41 25  |R.%.M........vA%|
+00000330  9e d3 20 b6 61 8a 26 8b  0d b7 cb 98 ac 45 e0 3b  |.. .a.&......E.;|
+00000340  6f d6 b2 52 8b a2 31 63  c8 44 1d 2a 3a c1 35 87  |o..R..1c.D.*:.5.|
+00000350  7a 7b 2a fa dd ab d3 48  9b e2 fa e1 93 7c 09 f7  |z{*....H.....|..|
+00000360  e1 72 83 f8 23 07 30 3a  4a 4f 56 97 1b 16 03 03  |.r..#.0:JOV.....|
 00000370  00 04 0e 00 00 00                                 |......|
 >>> Flow 3 (client to server)
 00000000  16 03 03 00 25 10 00 00  21 20 2f e5 7d a3 47 cd  |....%...! /.}.G.|
 00000010  62 43 15 28 da ac 5f bb  29 07 30 ff f6 84 af c4  |bC.(.._.).0.....|
 00000020  cf c2 ed 90 99 5f 58 cb  3b 74 14 03 03 00 01 01  |....._X.;t......|
 00000030  16 03 03 00 50 00 00 00  00 00 00 00 00 00 00 00  |....P...........|
-00000040  00 00 00 00 00 02 19 fd  3e 06 0d 12 0d 03 42 da  |........>.....B.|
-00000050  76 6f e2 e3 96 eb 42 d9  96 b7 0b ae d6 a0 06 fa  |vo....B.........|
-00000060  57 4e ff 62 85 dd 3f ab  63 f9 73 87 8d 71 6a c6  |WN.b..?.c.s..qj.|
-00000070  f4 ef ce f5 55 5b d2 1f  b5 33 fd 12 32 bd 5e 1e  |....U[...3..2.^.|
-00000080  d5 32 91 9a ae                                    |.2...|
+00000040  00 00 00 00 00 91 c1 82  23 f0 03 79 83 38 ef d0  |........#..y.8..|
+00000050  73 71 9b 7d 55 5e 53 3b  d3 cf 86 48 60 2f 42 97  |sq.}U^S;...H`/B.|
+00000060  63 e8 4b 20 4c 92 3e 2f  aa b3 32 46 8a 96 69 42  |c.K L.>/..2F..iB|
+00000070  96 9a 4b bd 04 f2 3d b6  5f f9 37 4f a4 3d f1 cb  |..K...=._.7O.=..|
+00000080  d5 57 fc 5e 8e                                    |.W.^.|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 50 77 80 95 42 a3  |..........Pw..B.|
-00000010  2b 1c 16 0f 3b f4 78 2a  bd ab 6e d1 33 1e 0e a5  |+...;.x*..n.3...|
-00000020  c7 f4 e9 92 82 00 da 44  0f b6 4e f9 1f ef 67 3b  |.......D..N...g;|
-00000030  de 5c dc 93 07 68 99 1a  70 7f 92 a7 d7 da f3 60  |.\...h..p......`|
-00000040  cf d5 f1 f0 5e 75 68 a1  0b 32 eb d2 96 de e6 34  |....^uh..2.....4|
-00000050  c3 e3 26 43 1f a2 8d e7  1b fc 76                 |..&C......v|
+00000000  14 03 03 00 01 01 16 03  03 00 50 e1 91 69 dc 7b  |..........P..i.{|
+00000010  5f a4 c7 7a 8f ba bb 8d  98 c3 0e 3f 10 f1 3e 3f  |_..z.......?..>?|
+00000020  37 6f 11 81 3f c5 7c 22  6f 22 a3 94 ae 3a 77 17  |7o..?.|"o"...:w.|
+00000030  a2 7b cc 8e 5e 6e 9b 4b  98 fd 16 f8 46 9e 78 19  |.{..^n.K....F.x.|
+00000040  43 e6 da e3 05 9a 0a 49  b0 09 c7 e5 4b 41 dc b4  |C......I....KA..|
+00000050  c0 81 9b 46 7e dd c3 64  2e f8 6e                 |...F~..d..n|
 >>> Flow 5 (client to server)
 00000000  17 03 03 00 40 00 00 00  00 00 00 00 00 00 00 00  |....@...........|
-00000010  00 00 00 00 00 f8 35 11  b8 23 cf d9 ec a7 d3 b9  |......5..#......|
-00000020  60 1e 34 01 20 49 73 ec  72 78 58 24 3b fc a8 42  |`.4. Is.rxX$;..B|
-00000030  b2 a9 69 69 40 65 5a c2  8b 9f 0b 0e 70 ab ac 22  |..ii@eZ.....p.."|
-00000040  1a ac d6 04 06 15 03 03  00 40 00 00 00 00 00 00  |.........@......|
-00000050  00 00 00 00 00 00 00 00  00 00 fe ed 19 a0 84 06  |................|
-00000060  8b f0 e8 4e 30 7a 3c 89  a0 a8 59 74 a5 92 73 f3  |...N0z<...Yt..s.|
-00000070  df 1b f0 c6 5a 95 d5 1c  b6 57 4a 1b 8f 24 59 87  |....Z....WJ..$Y.|
-00000080  b4 2b 7f 6f 89 03 e8 6d  e5 d9                    |.+.o...m..|
+00000010  00 00 00 00 00 65 4c 71  31 d4 47 4d 0b 81 1f 75  |.....eLq1.GM...u|
+00000020  b6 71 64 4a e6 a8 80 a1  f1 e2 0a 14 77 af a4 c6  |.qdJ........w...|
+00000030  1d 6a 7d 79 6a 15 a1 0e  86 6c 8e e1 32 64 0b 5d  |.j}yj....l..2d.]|
+00000040  af e0 f5 05 91 15 03 03  00 40 00 00 00 00 00 00  |.........@......|
+00000050  00 00 00 00 00 00 00 00  00 00 ca 46 1b 95 2a 41  |...........F..*A|
+00000060  ce dc 30 d6 e0 cf 2f 2b  1f 61 81 33 a4 58 e7 af  |..0.../+.a.3.X..|
+00000070  90 9c 15 42 9b ab 26 64  d1 39 46 45 6b 74 b9 c4  |...B..&d.9FEkt..|
+00000080  21 d9 ef 2d 69 51 dc e7  8a 6b                    |!..-iQ...k|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-ECDHE-RSA-CHACHA20-POLY1305 b/src/crypto/tls/testdata/Client-TLSv12-ECDHE-RSA-CHACHA20-POLY1305
index 38fb4a0be7..2c2cb455d1 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-ECDHE-RSA-CHACHA20-POLY1305
+++ b/src/crypto/tls/testdata/Client-TLSv12-ECDHE-RSA-CHACHA20-POLY1305
@@ -4,7 +4,7 @@
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 08 cc a8  |................|
-00000050  13 01 13 03 13 02 01 00  00 7b 00 05 00 05 01 00  |.........{......|
+00000050  13 03 13 01 13 02 01 00  00 7b 00 05 00 05 01 00  |.........{......|
 00000060  00 00 00 00 0a 00 0a 00  08 00 1d 00 17 00 18 00  |................|
 00000070  19 00 0b 00 02 01 00 00  0d 00 1a 00 18 08 04 04  |................|
 00000080  03 08 07 08 05 08 06 04  01 05 01 06 01 05 03 06  |................|
@@ -14,11 +14,11 @@
 000000c0  ac 5f bb 29 07 30 ff f6  84 af c4 cf c2 ed 90 99  |._.).0..........|
 000000d0  5f 58 cb 3b 74                                    |_X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 59 02 00 00  55 03 03 4e fb dc 04 6f  |....Y...U..N...o|
-00000010  5a 52 37 a3 55 58 26 e5  cd a0 67 4c 0f 87 1a 3a  |ZR7.UX&...gL...:|
-00000020  f6 84 33 2f 2e 52 d0 48  7c 5b 64 20 6e d0 bc ca  |..3/.R.H|[d n...|
-00000030  c9 a5 87 8d 99 c5 ec 85  84 89 f0 22 ab 63 55 f4  |...........".cU.|
-00000040  70 d7 02 93 b5 fe d7 38  fb c1 b2 da cc a8 00 00  |p......8........|
+00000000  16 03 03 00 59 02 00 00  55 03 03 2a 76 db 4b d5  |....Y...U..*v.K.|
+00000010  10 f3 21 f2 4b 29 a2 2e  7a 7d 0b 86 c4 af 60 95  |..!.K)..z}....`.|
+00000020  5b 11 84 27 8a 59 7f af  a0 27 de 20 02 f7 dc 9b  |[..'.Y...'. ....|
+00000030  63 8e 2e da 48 b5 73 81  8e 76 13 da dd 2e 17 2b  |c...H.s..v.....+|
+00000040  ff 18 ad d7 9d f3 44 ed  b6 60 0e 42 cc a8 00 00  |......D..`.B....|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  03 02 59 0b 00 02 55 00  02 52 00 02 4f 30 82 02  |..Y...U..R..O0..|
 00000070  4b 30 82 01 b4 a0 03 02  01 02 02 09 00 e8 f0 9d  |K0..............|
@@ -58,31 +58,31 @@
 00000290  77 8d 0c 1c f1 0f a1 d8  40 83 61 c9 4c 72 2b 9d  |w.......@.a.Lr+.|
 000002a0  ae db 46 06 06 4d f4 c1  b3 3e c0 d1 bd 42 d4 db  |..F..M...>...B..|
 000002b0  fe 3d 13 60 84 5c 21 d3  3b e9 fa e7 16 03 03 00  |.=.`.\!.;.......|
-000002c0  ac 0c 00 00 a8 03 00 1d  20 fc 4b 92 ab d2 cb 4f  |........ .K....O|
-000002d0  61 aa 86 12 1a 1d 75 be  31 dd b8 ee 6c a6 db bd  |a.....u.1...l...|
-000002e0  0b ea b2 d5 27 49 42 eb  5a 08 04 00 80 02 ad 71  |....'IB.Z......q|
-000002f0  e2 e8 f6 44 3c a6 18 6f  76 ee 9a eb 0e d9 ff cb  |...D<..ov.......|
-00000300  6d 1e 64 dd 29 1d 8c c8  f6 14 40 c0 12 46 74 4c  |m.d.).....@..FtL|
-00000310  41 2d 71 5f 9c b7 86 0b  fc 66 1e 14 cb 26 d0 d7  |A-q_.....f...&..|
-00000320  21 b4 bd c2 04 38 77 90  6a f0 01 18 bd 1c 17 45  |!....8w.j......E|
-00000330  7e 38 46 4c 2e 97 ba 11  01 1f 20 cc df f2 6b 5b  |~8FL...... ...k[|
-00000340  a7 29 c0 52 52 9c 2f 23  bd 1c 72 c2 f2 99 d1 dc  |.).RR./#..r.....|
-00000350  6a 6c ac 8e 87 8a 00 74  47 2e 99 8d 3f 79 04 60  |jl.....tG...?y.`|
-00000360  5e dc ba 86 1c f4 f9 03  22 38 96 a7 b3 16 03 03  |^......."8......|
+000002c0  ac 0c 00 00 a8 03 00 1d  20 0d c3 c2 b5 73 da 39  |........ ....s.9|
+000002d0  82 e5 8c 18 0d 8d 16 c2  a5 e7 3e 39 fd 25 00 18  |..........>9.%..|
+000002e0  25 16 c0 a7 6e c6 dd bb  01 08 04 00 80 b3 bd 01  |%...n...........|
+000002f0  ae dd b1 c8 2a 5d 0e 66  6d 1e b3 92 f4 01 63 59  |....*].fm.....cY|
+00000300  0c c1 62 df 75 8f 4f 19  5a cf 2f 63 79 d0 06 31  |..b.u.O.Z./cy..1|
+00000310  c0 60 6a 4f db 70 18 bd  80 8b 30 94 40 dd 13 39  |.`jO.p....0.@..9|
+00000320  4f db 2b 54 a4 97 f7 ef  a5 a3 ff f5 14 3d e2 2d  |O.+T.........=.-|
+00000330  0c 0e 71 4a bd a8 59 48  ab 06 55 53 45 2a ee 3e  |..qJ..YH..USE*.>|
+00000340  65 1f 47 ee 8d e3 f6 4e  2e b1 4c d0 af 50 15 02  |e.G....N..L..P..|
+00000350  5e 84 fe 76 d5 f3 c5 fb  2a 91 44 f0 92 32 ee ea  |^..v....*.D..2..|
+00000360  a0 26 77 5c 94 88 24 e3  2f 75 e3 fd b7 16 03 03  |.&w\..$./u......|
 00000370  00 04 0e 00 00 00                                 |......|
 >>> Flow 3 (client to server)
 00000000  16 03 03 00 25 10 00 00  21 20 2f e5 7d a3 47 cd  |....%...! /.}.G.|
 00000010  62 43 15 28 da ac 5f bb  29 07 30 ff f6 84 af c4  |bC.(.._.).0.....|
 00000020  cf c2 ed 90 99 5f 58 cb  3b 74 14 03 03 00 01 01  |....._X.;t......|
-00000030  16 03 03 00 20 0a 17 ee  70 8c 50 24 7c 00 b9 6f  |.... ...p.P$|..o|
-00000040  82 71 ed 2b 8c 0b 4b ff  bb 38 bc 12 7e 0c a5 3e  |.q.+..K..8..~..>|
-00000050  71 a2 ad f8 52                                    |q...R|
+00000030  16 03 03 00 20 0b 58 fe  b5 63 ac 28 f8 34 d6 72  |.... .X..c.(.4.r|
+00000040  1a a3 ec 26 91 70 07 8d  6a 3a 3b 3a 94 5e a3 fa  |...&.p..j:;:.^..|
+00000050  6e 92 3a 15 65                                    |n.:.e|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 20 e9 87 55 12 a8  |.......... ..U..|
-00000010  ad 68 42 0c 60 12 be 2f  2c e5 00 2d 01 cf 86 a2  |.hB.`../,..-....|
-00000020  1b 06 b3 86 bf 88 48 73  7a d3 cc                 |......Hsz..|
+00000000  14 03 03 00 01 01 16 03  03 00 20 01 fa e1 2f 29  |.......... .../)|
+00000010  ee f6 d4 e8 22 b6 e0 8f  82 37 81 83 1b 03 4d 5f  |...."....7....M_|
+00000020  00 80 cb eb 9a 3a 01 c7  aa e9 9a                 |.....:.....|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 16 96 75 4c  c6 ba b1 ad ae 2f 44 9d  |......uL...../D.|
-00000010  10 c3 ef e5 dc fb 0a 3e  af 6b 6a 15 03 03 00 12  |.......>.kj.....|
-00000020  30 13 8f e5 a1 0f 38 67  b9 53 4e 6a 66 ec ee 45  |0.....8g.SNjf..E|
-00000030  c2 b2                                             |..|
+00000000  17 03 03 00 16 43 6a e8  f2 ca f9 4f 3c 6d ff 5e  |.....Cj....O<m.^|
+00000010  f3 19 eb ee 96 1c d8 68  c5 53 86 15 03 03 00 12  |.......h.S......|
+00000020  c2 72 4e 3c 33 93 fa f3  21 32 bb fd e3 c4 ef 1a  |.rN<3...!2......|
+00000030  46 df                                             |F.|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-Ed25519 b/src/crypto/tls/testdata/Client-TLSv12-Ed25519
index 35513adb84..72d564f44a 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-Ed25519
+++ b/src/crypto/tls/testdata/Client-TLSv12-Ed25519
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 59 02 00 00  55 03 03 66 49 2a a6 a4  |....Y...U..fI*..|
-00000010  75 60 58 bb 5f 5e 82 cd  e5 c0 9f 6d a4 fd 39 3b  |u`X._^.....m..9;|
-00000020  d9 17 80 14 89 ea 51 c1  b0 43 d6 20 b2 6b 72 81  |......Q..C. .kr.|
-00000030  f6 63 20 22 e2 b6 d2 61  aa 87 b6 67 ae 56 78 44  |.c "...a...g.VxD|
-00000040  5d 10 8c cf ea 32 cf 9e  92 e5 59 70 cc a9 00 00  |]....2....Yp....|
+00000000  16 03 03 00 59 02 00 00  55 03 03 6c 5f 04 9e a6  |....Y...U..l_...|
+00000010  c6 41 0c ee a2 2c af 45  f0 bc de 67 2d 20 1c 9c  |.A...,.E...g- ..|
+00000020  82 33 fd 86 86 b3 50 04  77 ec da 20 f3 09 fb 8c  |.3....P.w.. ....|
+00000030  79 83 f9 82 58 b9 76 bb  d3 58 44 3d 52 0c 37 ae  |y...X.v..XD=R.7.|
+00000040  18 98 84 9a 56 af 5d 2b  68 68 c7 30 cc a9 00 00  |....V.]+hh.0....|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  03 01 3c 0b 00 01 38 00  01 35 00 01 32 30 82 01  |..<...8..5..20..|
 00000070  2e 30 81 e1 a0 03 02 01  02 02 10 0f 43 1c 42 57  |.0..........C.BW|
@@ -42,27 +42,27 @@
 00000170  90 95 39 e5 0d c1 55 ff  2c 16 b7 1d fc ab 7d 4d  |..9...U.,.....}M|
 00000180  d4 e0 93 13 d0 a9 42 e0  b6 6b fe 5d 67 48 d7 9f  |......B..k.]gH..|
 00000190  50 bc 6c cd 4b 03 83 7c  f2 08 58 cd ac cf 0c 16  |P.l.K..|..X.....|
-000001a0  03 03 00 6c 0c 00 00 68  03 00 1d 20 c4 8c b8 a2  |...l...h... ....|
-000001b0  32 92 b8 22 1f 4c f1 96  00 64 35 47 4e f8 3d 08  |2..".L...d5GN.=.|
-000001c0  83 12 fe 95 a8 e4 8e c9  30 27 5c 39 08 07 00 40  |........0'\9...@|
-000001d0  7f 90 cf e0 87 69 e3 50  e6 fa 5e 28 a1 0f 79 0a  |.....i.P..^(..y.|
-000001e0  6e cf f4 87 e8 2f 55 b2  dd cb 5e 8f 9a 14 bd c2  |n..../U...^.....|
-000001f0  2b 2b 2d ed 72 40 23 5d  6d f4 89 3a ff 09 82 ec  |++-.r@#]m..:....|
-00000200  b6 4b 27 9a 08 ea e9 73  94 b4 31 1f e1 39 86 0e  |.K'....s..1..9..|
+000001a0  03 03 00 6c 0c 00 00 68  03 00 1d 20 a7 28 ef 3e  |...l...h... .(.>|
+000001b0  1c 65 9f 8e 9a 80 0b 7d  ac 9c ce d6 1e 97 54 30  |.e.....}......T0|
+000001c0  53 9b e6 0c 61 e0 ea 9c  ae 70 f2 78 08 07 00 40  |S...a....p.x...@|
+000001d0  0c 49 38 23 a0 75 28 fb  ec 71 a4 89 79 45 d1 ca  |.I8#.u(..q..yE..|
+000001e0  83 6f 5d dd 01 d4 c6 63  53 5d 6e 8f 06 09 80 a1  |.o]....cS]n.....|
+000001f0  f7 ef af 2d 29 af aa 10  86 1c 18 19 3f be bb 90  |...-).......?...|
+00000200  0e c3 9d 1e 6e 60 49 7f  fc c8 42 61 89 c2 e3 04  |....n`I...Ba....|
 00000210  16 03 03 00 04 0e 00 00  00                       |.........|
 >>> Flow 3 (client to server)
 00000000  16 03 03 00 25 10 00 00  21 20 2f e5 7d a3 47 cd  |....%...! /.}.G.|
 00000010  62 43 15 28 da ac 5f bb  29 07 30 ff f6 84 af c4  |bC.(.._.).0.....|
 00000020  cf c2 ed 90 99 5f 58 cb  3b 74 14 03 03 00 01 01  |....._X.;t......|
-00000030  16 03 03 00 20 8f 97 36  bd 59 ef 8e 2f 11 28 b0  |.... ..6.Y../.(.|
-00000040  d7 20 79 bf 04 07 45 f9  89 de b0 c7 55 1a ad 80  |. y...E.....U...|
-00000050  0f 8c ef 1d c6                                    |.....|
+00000030  16 03 03 00 20 b2 7f b6  1b 9c ec bf 2e ae a5 70  |.... ..........p|
+00000040  d5 33 9b 63 02 66 77 7d  00 ec 86 e4 bb d4 57 68  |.3.c.fw}......Wh|
+00000050  49 2a d3 be e7                                    |I*...|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 20 47 6c 1f 86 47  |.......... Gl..G|
-00000010  72 03 94 e0 43 f8 e5 ca  03 7d f5 d5 dd 70 05 f5  |r...C....}...p..|
-00000020  98 5d 51 b4 11 49 71 7a  fd 37 9a                 |.]Q..Iqz.7.|
+00000000  14 03 03 00 01 01 16 03  03 00 20 4c 7d ef ed ea  |.......... L}...|
+00000010  ab 8d 4f 38 46 6e 8f 56  b4 1d f2 1f 2c df 57 c0  |..O8Fn.V....,.W.|
+00000020  f9 8a c2 71 f8 6d df b7  c7 1e 23                 |...q.m....#|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 16 b7 a2 f5  8e 7c d3 7d 61 af 29 1c  |.........|.}a.).|
-00000010  77 0c 8d b4 5b d3 be 77  a6 a5 99 15 03 03 00 12  |w...[..w........|
-00000020  d8 23 dc a8 99 fe 1c 6e  f2 2f 41 8e df 40 11 4f  |.#.....n./A..@.O|
-00000030  6b 92                                             |k.|
+00000000  17 03 03 00 16 26 f1 7c  ee c8 3a 61 b0 f7 5a bd  |.....&.|..:a..Z.|
+00000010  b7 61 61 60 69 db cd ea  10 ee 63 15 03 03 00 12  |.aa`i.....c.....|
+00000020  22 c0 65 a4 5d 0e 48 9c  56 f8 54 17 82 5f 29 97  |".e.].H.V.T.._).|
+00000030  be 6b                                             |.k|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-ExportKeyingMaterial b/src/crypto/tls/testdata/Client-TLSv12-ExportKeyingMaterial
index c900aa6d5e..adf1f72daf 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-ExportKeyingMaterial
+++ b/src/crypto/tls/testdata/Client-TLSv12-ExportKeyingMaterial
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 59 02 00 00  55 03 03 7c c1 7b 30 03  |....Y...U..|.{0.|
-00000010  3c d7 63 5f 47 1c b1 13  56 56 b4 fd 55 e2 27 3e  |<.c_G...VV..U.'>|
-00000020  39 bb ce 9b 5b 2c 1e 17  33 e1 da 20 65 8b 26 42  |9...[,..3.. e.&B|
-00000030  a4 38 29 c7 9a 25 13 fc  1d 69 cb 10 63 c6 26 fc  |.8)..%...i..c.&.|
-00000040  f4 46 64 31 28 06 b3 a5  a4 c2 f6 5a cc a8 00 00  |.Fd1(......Z....|
+00000000  16 03 03 00 59 02 00 00  55 03 03 79 92 2e 86 bc  |....Y...U..y....|
+00000010  c0 b7 56 2a 25 58 75 b3  25 ac 58 1d 8d 8e d5 87  |..V*%Xu.%.X.....|
+00000020  2d 67 8e 6e d4 d4 b6 67  b1 42 96 20 91 75 0b fa  |-g.n...g.B. .u..|
+00000030  d0 6f ab 91 4a c3 15 07  1d 6c 8e e5 55 f2 26 aa  |.o..J....l..U.&.|
+00000040  4d 5c 57 3b 93 a6 fc 46  c9 f6 80 1e cc a8 00 00  |M\W;...F........|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  03 02 59 0b 00 02 55 00  02 52 00 02 4f 30 82 02  |..Y...U..R..O0..|
 00000070  4b 30 82 01 b4 a0 03 02  01 02 02 09 00 e8 f0 9d  |K0..............|
@@ -60,31 +60,31 @@
 00000290  77 8d 0c 1c f1 0f a1 d8  40 83 61 c9 4c 72 2b 9d  |w.......@.a.Lr+.|
 000002a0  ae db 46 06 06 4d f4 c1  b3 3e c0 d1 bd 42 d4 db  |..F..M...>...B..|
 000002b0  fe 3d 13 60 84 5c 21 d3  3b e9 fa e7 16 03 03 00  |.=.`.\!.;.......|
-000002c0  ac 0c 00 00 a8 03 00 1d  20 f7 a2 97 2f 50 e4 e2  |........ .../P..|
-000002d0  fa ef 80 67 78 1c aa 6c  03 aa 05 3b 6f 98 97 11  |...gx..l...;o...|
-000002e0  7e 55 3d 50 f3 a9 9b 21  65 08 04 00 80 34 4a 4b  |~U=P...!e....4JK|
-000002f0  4b 6e 86 01 1b 6b 8e 3e  84 01 75 b8 05 c3 b2 52  |Kn...k.>..u....R|
-00000300  16 ee ac 61 83 dd 09 32  d5 55 6a 5d d6 6b 4a 1a  |...a...2.Uj].kJ.|
-00000310  2b f7 09 33 6f 3d 4f c1  e3 aa 03 27 fe af cd 6d  |+..3o=O....'...m|
-00000320  b8 76 00 02 42 98 e6 f6  b7 ed fb 35 35 29 23 b1  |.v..B......55)#.|
-00000330  4d 48 0a ba a1 1b e3 8e  a2 cb 80 11 ec 92 20 df  |MH............ .|
-00000340  1f a4 5e 5d 70 85 8e 5d  85 62 81 1f b3 3a 0d 8d  |..^]p..].b...:..|
-00000350  9a 07 d3 99 a5 3c 6c c2  52 08 f0 be 50 ed d2 4d  |.....<l.R...P..M|
-00000360  44 ed e7 40 06 64 4e 17  fe 4a 0e 1b d6 16 03 03  |D..@.dN..J......|
+000002c0  ac 0c 00 00 a8 03 00 1d  20 5f 3c a6 bb 4e 32 85  |........ _<..N2.|
+000002d0  69 4b 23 df 18 9c 07 ac  0b a8 dd 9b 59 33 00 02  |iK#.........Y3..|
+000002e0  99 de 4e 66 1e 04 3b ce  4b 08 04 00 80 82 41 7c  |..Nf..;.K.....A||
+000002f0  7b b8 ee d4 23 08 c3 23  8d b1 ea 27 43 e7 8e f1  |{...#..#...'C...|
+00000300  7b 87 b0 88 ab f7 b1 15  2e 45 c5 50 e7 cd 05 31  |{........E.P...1|
+00000310  bf 99 30 c8 ff 6a 23 ec  9d e5 c8 09 fa ec 50 a8  |..0..j#.......P.|
+00000320  fa b3 54 b7 c5 61 99 f6  94 12 e6 34 4a 59 e3 dd  |..T..a.....4JY..|
+00000330  e5 7f f4 88 c9 2a 4c 09  65 d9 75 a6 ce 12 96 82  |.....*L.e.u.....|
+00000340  a2 36 f2 5e 93 f2 4e 1c  05 91 a7 5a 67 36 e9 3d  |.6.^..N....Zg6.=|
+00000350  33 cd 6a 77 9c 8d 14 95  80 41 61 bd 80 ed 7b 51  |3.jw.....Aa...{Q|
+00000360  cf 76 87 4d ac dc 5f c1  5d 52 a7 f9 51 16 03 03  |.v.M.._.]R..Q...|
 00000370  00 04 0e 00 00 00                                 |......|
 >>> Flow 3 (client to server)
 00000000  16 03 03 00 25 10 00 00  21 20 2f e5 7d a3 47 cd  |....%...! /.}.G.|
 00000010  62 43 15 28 da ac 5f bb  29 07 30 ff f6 84 af c4  |bC.(.._.).0.....|
 00000020  cf c2 ed 90 99 5f 58 cb  3b 74 14 03 03 00 01 01  |....._X.;t......|
-00000030  16 03 03 00 20 30 8b ea  ef 6c 35 97 5b 26 5f ef  |.... 0...l5.[&_.|
-00000040  bc 28 fd e9 23 73 bb b3  ae 41 0c be 5f 83 a5 f7  |.(..#s...A.._...|
-00000050  96 07 8d 81 67                                    |....g|
+00000030  16 03 03 00 20 bc c3 7c  c2 cc a4 4e 8f d0 79 7a  |.... ..|...N..yz|
+00000040  a4 7d 4c 3d 17 8c 19 93  4f 49 03 50 f6 71 4d 16  |.}L=....OI.P.qM.|
+00000050  97 bb 18 88 67                                    |....g|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 20 29 fa a8 de f2  |.......... )....|
-00000010  8f 94 16 fc be 84 93 e9  34 98 c2 44 08 9b 2e 37  |........4..D...7|
-00000020  1f 41 61 53 fa 9c 23 ff  d8 6d c3                 |.AaS..#..m.|
+00000000  14 03 03 00 01 01 16 03  03 00 20 00 c4 8a f9 1e  |.......... .....|
+00000010  c0 66 ab ef 39 ae 41 7a  05 9c e3 06 e4 4d 00 bb  |.f..9.Az.....M..|
+00000020  d4 ef 21 71 a3 54 23 fe  db 4a 86                 |..!q.T#..J.|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 16 ab 6d 32  1c 16 cc 29 b1 21 4c b1  |......m2...).!L.|
-00000010  74 4c 50 e3 1f c5 f1 05  6a 8a 92 15 03 03 00 12  |tLP.....j.......|
-00000020  18 88 3d 23 81 d7 ba c5  1e 9a c4 3a 1b c8 cd 5b  |..=#.......:...[|
-00000030  c5 fa                                             |..|
+00000000  17 03 03 00 16 0c d3 9a  f5 1d f4 5f b2 45 c7 7c  |..........._.E.||
+00000010  38 59 6e df 6e 59 d5 94  8b a9 bb 15 03 03 00 12  |8Yn.nY..........|
+00000020  9e 74 a5 0e c1 7f 33 52  be 17 f6 f5 4d 9f 3d d1  |.t....3R....M.=.|
+00000030  b5 65                                             |.e|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-P256-ECDHE b/src/crypto/tls/testdata/Client-TLSv12-P256-ECDHE
index d75b670e1d..3331435315 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-P256-ECDHE
+++ b/src/crypto/tls/testdata/Client-TLSv12-P256-ECDHE
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 96 00 05 00 05  01 00 00 00 00 00 0a 00  |................|
 00000090  04 00 02 00 17 00 0b 00  02 01 00 00 0d 00 1a 00  |................|
 000000a0  18 08 04 04 03 08 07 08  05 08 06 04 01 05 01 06  |................|
@@ -18,11 +18,11 @@
 00000100  07 9f 6c 4b 5b 83 56 e2  32 42 e9 58 b6 d7 49 a6  |..lK[.V.2B.X..I.|
 00000110  b5 68 1a 41 03 56 6b dc  5a 89                    |.h.A.Vk.Z.|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 59 02 00 00  55 03 03 b8 7d f5 69 c3  |....Y...U...}.i.|
-00000010  6a ca 8b df f3 30 2c 39  47 2e 74 2e 4f 89 4c 1e  |j....0,9G.t.O.L.|
-00000020  f0 eb 10 0e 06 1d 2c 4e  de 2e 8f 20 6c a0 5b 66  |......,N... l.[f|
-00000030  fc a6 05 df 29 6b ce 72  92 e7 d7 78 f5 46 38 f9  |....)k.r...x.F8.|
-00000040  91 1c 9a 08 4c b1 9a 41  e5 0c d2 cd c0 2f 00 00  |....L..A...../..|
+00000000  16 03 03 00 59 02 00 00  55 03 03 0b f0 3e a1 66  |....Y...U....>.f|
+00000010  13 35 53 83 59 3c 9e 2a  0f 0b b0 9a 42 de e4 f1  |.5S.Y<.*....B...|
+00000020  8a 2d 34 ef 15 fe 28 55  42 d8 bf 20 aa 27 5c 5f  |.-4...(UB.. .'\_|
+00000030  24 59 17 ef 43 f3 18 f8  40 97 8f 1a 6a f4 e4 4a  |$Y..C...@...j..J|
+00000040  a3 b7 11 39 01 bd 98 8c  61 08 d9 50 c0 2f 00 00  |...9....a..P./..|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  03 02 59 0b 00 02 55 00  02 52 00 02 4f 30 82 02  |..Y...U..R..O0..|
 00000070  4b 30 82 01 b4 a0 03 02  01 02 02 09 00 e8 f0 9d  |K0..............|
@@ -62,19 +62,19 @@
 00000290  77 8d 0c 1c f1 0f a1 d8  40 83 61 c9 4c 72 2b 9d  |w.......@.a.Lr+.|
 000002a0  ae db 46 06 06 4d f4 c1  b3 3e c0 d1 bd 42 d4 db  |..F..M...>...B..|
 000002b0  fe 3d 13 60 84 5c 21 d3  3b e9 fa e7 16 03 03 00  |.=.`.\!.;.......|
-000002c0  cd 0c 00 00 c9 03 00 17  41 04 3e 87 67 8b 87 08  |........A.>.g...|
-000002d0  fe 4e 4c c3 6b 42 4b 97  ad f4 1c 83 35 72 db 4f  |.NL.kBK.....5r.O|
-000002e0  39 83 ea 14 69 bb 8c 87  58 c5 a4 a8 8c d7 9d af  |9...i...X.......|
-000002f0  7a 5e 58 59 31 4d f2 01  4a 23 51 24 1b 04 0c e3  |z^XY1M..J#Q$....|
-00000300  94 9e 1b 6c ad aa 83 fd  2d 36 08 04 00 80 ab e9  |...l....-6......|
-00000310  ff 6d 7a cd 3b a7 da ff  d5 bd 27 49 68 53 f5 45  |.mz.;.....'IhS.E|
-00000320  c3 dd 5b a2 99 fb 8f 24  37 49 d3 08 87 d1 06 98  |..[....$7I......|
-00000330  39 72 25 78 b3 05 fb a2  c9 ac f9 c8 f7 fc ea 8a  |9r%x............|
-00000340  98 ce 78 83 64 f6 e0 c7  44 62 af a7 d5 26 df f1  |..x.d...Db...&..|
-00000350  2c cc ce 11 8b 03 4a e1  81 54 3f e1 6e 52 c9 1a  |,.....J..T?.nR..|
-00000360  d8 95 52 e0 3f a5 e3 c8  12 9a c7 57 5d 46 7a ce  |..R.?......W]Fz.|
-00000370  56 8a 90 0f 0d 1b ba 58  cf 1c a3 4b 39 5a 08 ee  |V......X...K9Z..|
-00000380  8a 61 bb 0f 7d f7 0e f2  1f 73 e0 c8 6f 54 16 03  |.a..}....s..oT..|
+000002c0  cd 0c 00 00 c9 03 00 17  41 04 79 6a df 70 26 49  |........A.yj.p&I|
+000002d0  c0 5a 39 fc 7c 80 d1 2c  cd 76 d0 4c 6f a7 7d bc  |.Z9.|..,.v.Lo.}.|
+000002e0  32 c6 54 c6 76 58 e2 0f  3f 33 ad 92 61 33 11 16  |2.T.vX..?3..a3..|
+000002f0  d7 42 a8 ba 2a 8f 22 2a  eb 88 3e 74 78 2a 67 de  |.B..*."*..>tx*g.|
+00000300  39 75 63 2c 1d 2e da 33  77 a5 08 04 00 80 61 f5  |9uc,...3w.....a.|
+00000310  ed 56 5b f1 dd 78 a0 c4  8a 9b ac 28 c5 91 0c bd  |.V[..x.....(....|
+00000320  f1 d5 c1 f6 31 2e 8c c3  d5 84 3a 15 e8 6d f1 bc  |....1.....:..m..|
+00000330  9e a6 04 fd 95 2f 51 60  2f c6 ff 99 cf 38 24 bf  |...../Q`/....8$.|
+00000340  a4 32 a2 1f a1 6b bd 27  98 00 14 23 0d 12 66 67  |.2...k.'...#..fg|
+00000350  48 33 92 51 e7 e7 3c f5  ef 13 ca 46 3c 39 53 70  |H3.Q..<....F<9Sp|
+00000360  41 78 4a 02 70 87 48 ce  b0 31 02 33 0b 06 78 b9  |AxJ.p.H..1.3..x.|
+00000370  87 0b 07 e0 f7 15 c8 3e  27 a1 a3 20 24 9e 20 93  |.......>'.. $. .|
+00000380  7f b5 53 7b 18 88 96 87  2b df 02 ba 0c d8 16 03  |..S{....+.......|
 00000390  03 00 04 0e 00 00 00                              |.......|
 >>> Flow 3 (client to server)
 00000000  16 03 03 00 46 10 00 00  42 41 04 1e 18 37 ef 0d  |....F...BA...7..|
@@ -82,17 +82,17 @@
 00000020  a7 24 20 3e b2 56 1c ce  97 28 5e f8 2b 2d 4f 9e  |.$ >.V...(^.+-O.|
 00000030  f1 07 9f 6c 4b 5b 83 56  e2 32 42 e9 58 b6 d7 49  |...lK[.V.2B.X..I|
 00000040  a6 b5 68 1a 41 03 56 6b  dc 5a 89 14 03 03 00 01  |..h.A.Vk.Z......|
-00000050  01 16 03 03 00 28 00 00  00 00 00 00 00 00 b8 16  |.....(..........|
-00000060  ce 7d df 64 13 07 9e d8  37 bb 3f 9c 9e 2b 3c 0e  |.}.d....7.?..+<.|
-00000070  26 a7 9d 32 e5 44 b8 d6  66 bc 05 7b 27 7a        |&..2.D..f..{'z|
+00000050  01 16 03 03 00 28 00 00  00 00 00 00 00 00 c1 90  |.....(..........|
+00000060  a0 8b 53 87 a8 e3 56 4c  5c ad 5f dc 00 af 29 5f  |..S...VL\._...)_|
+00000070  11 53 7d 49 25 f8 74 16  dc 84 5f 3b c6 24        |.S}I%.t..._;.$|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 28 c0 73 5c 27 1b  |..........(.s\'.|
-00000010  19 d0 66 68 ea c5 ad 7d  a8 03 37 d2 9a ff 00 c4  |..fh...}..7.....|
-00000020  70 65 98 3b 88 59 c0 ca  e3 c0 d6 32 0e 8d 15 3c  |pe.;.Y.....2...<|
-00000030  e2 c3 f3                                          |...|
+00000000  14 03 03 00 01 01 16 03  03 00 28 00 f9 b2 51 85  |..........(...Q.|
+00000010  72 7e ec 79 72 59 90 ae  69 51 79 61 10 3b 4e 4b  |r~.yrY..iQya.;NK|
+00000020  45 d6 a5 9a c0 1a 69 c9  9f 1c ee cd ad 6a e8 ea  |E.....i......j..|
+00000030  c4 9e f1                                          |...|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 1e 00 00 00  00 00 00 00 01 28 ef 47  |.............(.G|
-00000010  ad 7f 40 4b 34 78 f3 1e  01 a7 f4 20 0a d5 c1 41  |..@K4x..... ...A|
-00000020  f7 be 41 15 03 03 00 1a  00 00 00 00 00 00 00 02  |..A.............|
-00000030  fb fc eb 14 f2 a6 e7 2e  80 d6 93 31 25 01 e9 d2  |...........1%...|
-00000040  c3 ae                                             |..|
+00000000  17 03 03 00 1e 00 00 00  00 00 00 00 01 86 5a 45  |..............ZE|
+00000010  24 60 90 dc bc b3 f6 61  6f db 60 02 99 f9 e2 93  |$`.....ao.`.....|
+00000020  07 85 0d 15 03 03 00 1a  00 00 00 00 00 00 00 02  |................|
+00000030  36 86 b0 60 b5 5d dd 28  64 c6 5b c7 ed 01 07 b1  |6..`.].(d.[.....|
+00000040  12 39                                             |.9|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-RSA-RC4 b/src/crypto/tls/testdata/Client-TLSv12-RSA-RC4
index ab2c4eb14d..12fb594c04 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-RSA-RC4
+++ b/src/crypto/tls/testdata/Client-TLSv12-RSA-RC4
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 51 02 00 00  4d 03 03 34 50 1f 52 15  |....Q...M..4P.R.|
-00000010  85 c7 85 2c 4d a9 b2 0c  49 e5 a3 ea 57 21 96 39  |...,M...I...W!.9|
-00000020  db c9 97 b6 c4 d0 81 9a  39 a3 e8 20 59 f5 b9 db  |........9.. Y...|
-00000030  58 2e ef 1c b3 85 96 27  6a 23 71 3f 5c 72 ce cf  |X......'j#q?\r..|
-00000040  c5 b7 fe 05 00 f4 65 06  54 c1 2e 7c 00 05 00 00  |......e.T..|....|
+00000000  16 03 03 00 51 02 00 00  4d 03 03 b0 e7 ee 09 45  |....Q...M......E|
+00000010  36 f1 7a 92 be 9e d8 9d  ae cd c1 4e b2 12 94 3e  |6.z........N...>|
+00000020  6c 34 71 ed 5f e0 97 7f  25 e4 dd 20 f4 43 01 03  |l4q._...%.. .C..|
+00000030  88 33 26 7f 48 c1 f2 d1  4d d3 f8 1a bd 86 4c 50  |.3&.H...M.....LP|
+00000040  18 89 dc 08 99 f1 51 c5  84 be b9 fd 00 05 00 00  |......Q.........|
 00000050  05 ff 01 00 01 00 16 03  03 02 59 0b 00 02 55 00  |..........Y...U.|
 00000060  02 52 00 02 4f 30 82 02  4b 30 82 01 b4 a0 03 02  |.R..O0..K0......|
 00000070  01 02 02 09 00 e8 f0 9d  3f e2 5b ea a6 30 0d 06  |........?.[..0..|
@@ -70,15 +70,15 @@
 00000060  c5 70 0f 08 83 48 e9 48  ef 6e 50 8b 05 7e e5 84  |.p...H.H.nP..~..|
 00000070  25 fa 55 c7 ae 31 02 27  00 ef 3f 98 86 20 12 89  |%.U..1.'..?.. ..|
 00000080  91 59 28 b4 f7 d7 af d2  69 61 35 14 03 03 00 01  |.Y(.....ia5.....|
-00000090  01 16 03 03 00 24 ab 48  84 ae 77 f9 8b 82 44 52  |.....$.H..w...DR|
-000000a0  3e 65 94 27 cc f2 08 a7  f2 e5 21 0c 02 d0 89 ac  |>e.'......!.....|
-000000b0  50 be 69 57 c9 7c a0 f2  7f 6d                    |P.iW.|...m|
+00000090  01 16 03 03 00 24 08 65  01 80 0d 59 b8 ac 0f 09  |.....$.e...Y....|
+000000a0  bf 61 31 32 e0 74 e9 f4  72 e3 2c 79 11 4d b2 a2  |.a12.t..r.,y.M..|
+000000b0  55 65 94 c8 cd 0a 61 99  07 b8                    |Ue....a...|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 24 61 94 21 65 0f  |..........$a.!e.|
-00000010  10 ba 0c a6 d9 e3 08 54  86 ae f9 64 c7 e7 f4 4b  |.......T...d...K|
-00000020  aa f5 19 ca 2a 0d 50 88  85 42 32 14 04 29 d9     |....*.P..B2..).|
+00000000  14 03 03 00 01 01 16 03  03 00 24 04 20 46 cd fb  |..........$. F..|
+00000010  6c 46 9c 47 21 03 fe 9b  a4 c6 da 2c 71 2f db 92  |lF.G!......,q/..|
+00000020  40 da 7d 46 2e e4 9c 81  86 89 7f 53 46 91 28     |@.}F.......SF.(|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 1a cb 1d 43  67 de 7a 20 c7 ed 46 99  |.......Cg.z ..F.|
-00000010  86 1f b9 61 9f c6 34 9a  07 37 3c 94 45 b4 40 15  |...a..4..7<.E.@.|
-00000020  03 03 00 16 4e ac d3 12  23 b4 33 bc 5b 03 91 7e  |....N...#.3.[..~|
-00000030  d9 d0 7f d7 48 3e 8c 16  16 ec                    |....H>....|
+00000000  17 03 03 00 1a 89 2b 2e  49 21 19 b7 d0 df 85 da  |......+.I!......|
+00000010  b8 a7 f3 73 5f fe 44 e5  0c a1 af 16 74 93 bc 15  |...s_.D.....t...|
+00000020  03 03 00 16 5f 9e 64 d0  91 50 34 44 cf f6 1f e0  |...._.d..P4D....|
+00000030  e0 13 b9 67 da 5c 99 16  f1 b3                    |...g.\....|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-RenegotiateOnce b/src/crypto/tls/testdata/Client-TLSv12-RenegotiateOnce
index 48a99eda15..06752dea01 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-RenegotiateOnce
+++ b/src/crypto/tls/testdata/Client-TLSv12-RenegotiateOnce
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 59 02 00 00  55 03 03 f1 d8 72 0c 79  |....Y...U....r.y|
-00000010  e2 ca 92 11 1c 30 cc 45  00 9b ea 3d a3 ed 23 d5  |.....0.E...=..#.|
-00000020  22 f0 da 9c 03 32 7b c3  13 d3 df 20 8f 7a 61 43  |"....2{.... .zaC|
-00000030  cb 72 46 5e c1 39 78 42  32 97 cc 2b 90 2e 53 59  |.rF^.9xB2..+..SY|
-00000040  31 38 ec 7b 2b 8a f3 80  e0 03 f0 0e cc a8 00 00  |18.{+...........|
+00000000  16 03 03 00 59 02 00 00  55 03 03 5b 4b bb c4 39  |....Y...U..[K..9|
+00000010  fb 45 5c 54 03 30 0f 71  c3 2e 48 25 33 fd 6d 40  |.E\T.0.q..H%3.m@|
+00000020  18 6e 75 43 66 9e 08 fb  6a a1 f8 20 34 3c c4 2a  |.nuCf...j.. 4<.*|
+00000030  b5 9b 65 b0 cd b9 fc ce  cf 51 f8 cc a1 5d 00 ed  |..e......Q...]..|
+00000040  49 5b 43 9a ff c4 cf 6b  d8 2a ea e5 cc a8 00 00  |I[C....k.*......|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  03 02 59 0b 00 02 55 00  02 52 00 02 4f 30 82 02  |..Y...U..R..O0..|
 00000070  4b 30 82 01 b4 a0 03 02  01 02 02 09 00 e8 f0 9d  |K0..............|
@@ -60,185 +60,185 @@
 00000290  77 8d 0c 1c f1 0f a1 d8  40 83 61 c9 4c 72 2b 9d  |w.......@.a.Lr+.|
 000002a0  ae db 46 06 06 4d f4 c1  b3 3e c0 d1 bd 42 d4 db  |..F..M...>...B..|
 000002b0  fe 3d 13 60 84 5c 21 d3  3b e9 fa e7 16 03 03 00  |.=.`.\!.;.......|
-000002c0  ac 0c 00 00 a8 03 00 1d  20 96 cb 1d cd f6 2f ff  |........ ...../.|
-000002d0  fe 32 ef d6 18 a2 6b 57  66 cd 3d 50 42 56 dc a4  |.2....kWf.=PBV..|
-000002e0  5f fe e4 91 ce d1 17 34  3c 08 04 00 80 b1 47 de  |_......4<.....G.|
-000002f0  b3 19 b0 fd 02 35 eb 3c  a1 04 d3 6b 53 84 20 c7  |.....5.<...kS. .|
-00000300  08 4b 96 12 23 ae bf ca  a8 83 1d 90 16 ae d3 7c  |.K..#..........||
-00000310  fa 1b b4 f0 bb bb 4e 3f  70 13 2f 40 6c d4 76 61  |......N?p./@l.va|
-00000320  5b 23 85 3f e7 37 ef e1  55 47 8d 01 e1 24 22 7f  |[#.?.7..UG...$".|
-00000330  a4 2c 6f 97 47 5f d6 69  bf b4 db 4b b8 a1 ad 66  |.,o.G_.i...K...f|
-00000340  5f d5 5d b6 06 ac 93 ed  d7 06 cb b5 a4 d4 4b a7  |_.]...........K.|
-00000350  7b de f7 73 60 af ad 23  f4 6a f1 bf 2a ee 5b 4e  |{..s`..#.j..*.[N|
-00000360  83 94 d7 95 3b e5 5e a5  3d 1a 0a 7a 9e 16 03 03  |....;.^.=..z....|
+000002c0  ac 0c 00 00 a8 03 00 1d  20 76 c4 f4 ec a2 d6 c1  |........ v......|
+000002d0  b1 d8 b0 41 71 8a ee e9  8a 17 06 90 6b 0c 05 66  |...Aq.......k..f|
+000002e0  54 d8 a6 ad 50 95 11 f0  03 08 04 00 80 46 0b da  |T...P........F..|
+000002f0  0b 0c 6c 1a 2e a2 7e 28  40 1b 40 9a b4 5c 36 88  |..l...~(@.@..\6.|
+00000300  c1 ad cd 45 be 23 17 a6  98 e5 11 fe a8 78 c6 21  |...E.#.......x.!|
+00000310  17 a6 a8 7d ce 28 c4 ef  51 76 f8 b1 b1 75 31 04  |...}.(..Qv...u1.|
+00000320  b9 14 bc 3b bf 59 50 b8  e1 ad c6 86 45 3c e1 70  |...;.YP.....E<.p|
+00000330  fb cd 69 8c 0a 5f f6 2d  bd 10 95 30 ed 4c 9a 47  |..i.._.-...0.L.G|
+00000340  73 8b 39 72 00 0a 7e 8f  a9 42 27 01 6f 3d 37 f9  |s.9r..~..B'.o=7.|
+00000350  7d d4 1b a2 6a 07 37 dc  5e 6c 8b b1 d5 75 3a 9b  |}...j.7.^l...u:.|
+00000360  d1 45 c5 d8 e0 90 f0 62  3d d5 01 00 9e 16 03 03  |.E.....b=.......|
 00000370  00 04 0e 00 00 00                                 |......|
 >>> Flow 3 (client to server)
 00000000  16 03 03 00 25 10 00 00  21 20 2f e5 7d a3 47 cd  |....%...! /.}.G.|
 00000010  62 43 15 28 da ac 5f bb  29 07 30 ff f6 84 af c4  |bC.(.._.).0.....|
 00000020  cf c2 ed 90 99 5f 58 cb  3b 74 14 03 03 00 01 01  |....._X.;t......|
-00000030  16 03 03 00 20 f2 6f 2e  79 5c db 90 b8 2e cf 59  |.... .o.y\.....Y|
-00000040  0a 56 69 86 f1 71 0c ff  a9 7c 0b a0 e7 c9 8d 17  |.Vi..q...|......|
-00000050  65 ad a5 6c 82                                    |e..l.|
+00000030  16 03 03 00 20 bb f4 78  64 23 f7 31 50 42 3d 97  |.... ..xd#.1PB=.|
+00000040  8f 73 89 b9 90 8f 74 b6  e4 7d 58 27 65 25 59 8a  |.s....t..}X'e%Y.|
+00000050  5a 8d 8f fa bd                                    |Z....|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 20 d5 90 08 84 71  |.......... ....q|
-00000010  bc 09 48 be ad 59 11 76  c6 39 bb 94 8c 60 80 29  |..H..Y.v.9...`.)|
-00000020  44 1a 0d fe 5c 00 4c bc  47 3c 1e                 |D...\.L.G<.|
+00000000  14 03 03 00 01 01 16 03  03 00 20 0a 43 74 53 47  |.......... .CtSG|
+00000010  41 4b 0a f1 f7 75 51 a9  22 c9 e0 5c 53 90 6b d7  |AK...uQ."..\S.k.|
+00000020  97 18 c6 ef c3 85 32 f5  7c 26 97                 |......2.|&.|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 16 42 cd 1c  e5 91 35 b0 c1 4d df e4  |.....B....5..M..|
-00000010  b0 ca f3 8a 7a 41 85 31  7a 7d 59                 |....zA.1z}Y|
+00000000  17 03 03 00 16 8e 83 1a  32 53 02 1c fa 84 89 4f  |........2S.....O|
+00000010  25 fb 5f 85 4f bd ee ae  9f 0f ea                 |%._.O......|
 >>> Flow 6 (server to client)
-00000000  16 03 03 00 14 3b 0f 40  64 9f ff 8f b9 85 18 af  |.....;.@d.......|
-00000010  b4 bc e7 33 8a 9b 03 de  ed                       |...3.....|
+00000000  16 03 03 00 14 96 76 32  c4 6d e6 23 bf 21 a8 09  |......v2.m.#.!..|
+00000010  a3 8b 69 98 cd c3 c9 ce  73                       |..i.....s|
 >>> Flow 7 (client to server)
-00000000  16 03 03 01 16 17 a7 61  5b 22 97 6e eb dd 43 84  |.......a[".n..C.|
-00000010  b9 ac 15 c2 76 7d 1f c0  e3 46 11 af c0 59 7d cc  |....v}...F...Y}.|
-00000020  d4 5d 02 90 28 bb b3 7c  85 76 46 34 7c bf 2b bf  |.]..(..|.vF4|.+.|
-00000030  c4 e9 e1 46 b0 15 7e af  c1 03 4a 17 b3 7a 03 cd  |...F..~...J..z..|
-00000040  e0 90 b1 1b 59 ac 1f 33  b0 41 c3 47 ee 58 af 5b  |....Y..3.A.G.X.[|
-00000050  5b c4 7a 92 02 e2 34 8d  cd 70 20 c4 59 5e 25 f2  |[.z...4..p .Y^%.|
-00000060  28 b1 f2 a5 e0 c4 f9 d0  ae cc 2b 1e ea d4 5a fe  |(.........+...Z.|
-00000070  62 97 bc d7 57 94 5c b8  ce 4c 62 1a e5 29 02 1e  |b...W.\..Lb..)..|
-00000080  0e 68 1d 8a 17 f9 47 55  ac 65 cf 13 88 d3 95 0d  |.h....GU.e......|
-00000090  d7 e0 d8 03 f8 f6 6f 9c  5b de 5c 80 c3 34 7e 82  |......o.[.\..4~.|
-000000a0  5c 8b c4 a3 99 c8 1e f0  f2 e5 6e 73 40 62 31 8e  |\.........ns@b1.|
-000000b0  3b 08 62 ba a8 b9 18 c4  84 a0 b4 9f 68 81 2f ae  |;.b.........h./.|
-000000c0  8d 7c cc 54 ba 4a ec 26  a5 8a 9b a7 bd 36 17 2c  |.|.T.J.&.....6.,|
-000000d0  52 69 4c 57 81 64 e6 34  88 27 81 d2 32 eb d2 8d  |RiLW.d.4.'..2...|
-000000e0  4d 8d c1 8b 14 b3 07 19  63 f8 d6 4a 9a 7d 3f c1  |M.......c..J.}?.|
-000000f0  af 18 72 f7 2d c8 7e 82  52 28 51 80 59 0c 9b 9f  |..r.-.~.R(Q.Y...|
-00000100  ac 40 69 25 0e 6d d7 4a  72 b5 18 f8 78 b9 52 c3  |.@i%.m.Jr...x.R.|
-00000110  d6 32 6c 7d 29 70 a8 33  18 d0 4b                 |.2l})p.3..K|
+00000000  16 03 03 01 16 72 5b d9  30 b2 b0 91 e2 3d 2b 12  |.....r[.0....=+.|
+00000010  2c c9 43 f1 67 ae 54 ee  ce a1 15 12 12 9a 27 46  |,.C.g.T.......'F|
+00000020  7e 47 90 d4 f2 7d b9 98  ec f8 61 b8 84 52 9f 21  |~G...}....a..R.!|
+00000030  c1 83 6a ce 1a 68 fc 5b  25 42 f3 8f 55 ee 92 45  |..j..h.[%B..U..E|
+00000040  af a4 d1 c4 a6 b5 0e 58  3d 70 76 98 ec 47 af 6f  |.......X=pv..G.o|
+00000050  e3 4f 9f ef 52 a3 aa 33  75 83 f6 57 33 a8 dc f5  |.O..R..3u..W3...|
+00000060  36 49 09 1c 72 31 c1 43  52 64 4a b5 ca ce 06 f5  |6I..r1.CRdJ.....|
+00000070  91 18 90 85 f0 c9 96 4f  bf 4c de 9e 50 a2 1c de  |.......O.L..P...|
+00000080  86 51 1f 0b 73 e1 df 1d  2d 90 6d 7f a2 f1 28 e8  |.Q..s...-.m...(.|
+00000090  5f 2a 78 2d 8e ab f2 05  19 85 4e 92 a8 cf cd 16  |_*x-......N.....|
+000000a0  1e df 1d 51 ee 8b ba 72  cd ac d2 01 4b 84 46 62  |...Q...r....K.Fb|
+000000b0  1c 28 4d 3f 44 c1 62 12  13 4f f8 73 f4 da c0 98  |.(M?D.b..O.s....|
+000000c0  14 da 31 6a 48 0d 1d bb  24 6c ef 0f 98 c0 3c 86  |..1jH...$l....<.|
+000000d0  c6 d6 8e ab bd 20 bd 06  e9 ba aa ce 3a 88 25 95  |..... ......:.%.|
+000000e0  54 15 fb c6 49 c7 98 ff  27 92 c0 60 6a 3c f8 26  |T...I...'..`j<.&|
+000000f0  fd 28 ac c4 8f 5c 4f 15  24 10 45 3c 07 3d 3f 50  |.(...\O.$.E<.=?P|
+00000100  e5 db cf 78 bd b0 d2 24  a2 4b 3e a6 9c 2d 3b 0d  |...x...$.K>..-;.|
+00000110  d8 1b 86 88 dc 0c 3c 9c  16 cf ea                 |......<....|
 >>> Flow 8 (server to client)
-00000000  16 03 03 00 81 8b e2 a1  f5 15 55 13 f6 f2 fa 95  |..........U.....|
-00000010  3b bb 0f 3d 3e 9b 3c b1  60 cb 69 7f 63 62 2d 9b  |;..=>.<.`.i.cb-.|
-00000020  20 47 3a 7d 5e d0 98 38  49 c3 94 f8 1d 56 1d 69  | G:}^..8I....V.i|
-00000030  27 65 bc ca 63 22 65 61  60 67 49 35 f0 eb 83 1b  |'e..c"ea`gI5....|
-00000040  44 c4 f0 91 64 5a 81 b5  06 4b 3e 3a ef 3b 5c b0  |D...dZ...K>:.;\.|
-00000050  81 b4 36 df f3 0d a3 0a  1c 40 03 fa 81 48 42 70  |..6......@...HBp|
-00000060  bf 4c b3 6b 67 19 7b 83  05 a1 31 a3 1c 79 49 2c  |.L.kg.{...1..yI,|
-00000070  1f 58 bc 7d 98 4e 5b 64  44 3d 3c 43 fb 77 c7 7c  |.X.}.N[dD=<C.w.||
-00000080  65 aa 0a 3d 49 a1 16 03  03 02 69 de 2a 3b 96 9f  |e..=I.....i.*;..|
-00000090  21 b4 5d de 2b b6 c5 03  ec ab 79 35 eb da 8b 1f  |!.].+.....y5....|
-000000a0  f8 c4 58 7c d1 af 3d 6e  f9 73 63 2b dc 2e a5 4f  |..X|..=n.sc+...O|
-000000b0  88 93 24 5e d7 2a ab 0a  a5 0f bf 5d 2d 74 9c 19  |..$^.*.....]-t..|
-000000c0  3a 97 88 f7 17 25 ad 6a  81 3a f1 e3 bb 4c 7a b6  |:....%.j.:...Lz.|
-000000d0  4c b0 f3 25 e5 66 06 14  b0 a3 3d 3a 25 36 4c e1  |L..%.f....=:%6L.|
-000000e0  62 25 fc ac 22 7b 25 0d  f9 5f 5b a6 1b 7f b9 14  |b%.."{%.._[.....|
-000000f0  4d 71 81 6b de 9d 6a 40  80 ba 88 20 60 c6 e2 50  |Mq.k..j@... `..P|
-00000100  c6 a6 3d 01 ee 04 dc ad  3c 95 a7 ef a7 dd 3a 6c  |..=.....<.....:l|
-00000110  0f f2 c2 c2 e0 fc 3c d2  75 88 ad 1a 23 94 2a 69  |......<.u...#.*i|
-00000120  28 66 c2 8a 5c 34 69 da  cc 5d 13 dd 86 fc 66 13  |(f..\4i..]....f.|
-00000130  de c2 c6 86 6d 4a b4 ea  b0 99 61 38 72 1e 7f 36  |....mJ....a8r..6|
-00000140  df 32 4b a7 12 23 8f f3  d1 8d d7 2f d1 65 67 4f  |.2K..#...../.egO|
-00000150  10 07 03 6a b2 87 aa a4  b0 41 c9 20 f4 84 5e b7  |...j.....A. ..^.|
-00000160  5e 4d 47 d4 7f 6c 8d 2e  a5 bb 7d 07 1b 5b e5 50  |^MG..l....}..[.P|
-00000170  5d 27 c0 8b f8 5e a7 a8  ef d7 f3 b0 6d 07 7a 9b  |]'...^......m.z.|
-00000180  1d 54 5a 18 c7 4f 6f b8  92 44 16 ec 92 43 1a 1a  |.TZ..Oo..D...C..|
-00000190  a8 d0 a3 40 25 b0 ff 35  9c b7 4c f9 cd 06 59 a6  |...@%..5..L...Y.|
-000001a0  25 ca 4a b7 34 31 0a 23  29 3a 09 8b 7b 05 15 b0  |%.J.41.#):..{...|
-000001b0  67 ae 1b 8b f4 67 16 e0  c1 67 a1 58 09 c9 10 f0  |g....g...g.X....|
-000001c0  f0 62 02 52 14 6d 02 3d  e6 ab 16 fb 7f 38 69 7c  |.b.R.m.=.....8i||
-000001d0  d1 f3 db 69 3c cd 78 28  b2 fa 94 1c a0 2f b7 bb  |...i<.x(...../..|
-000001e0  31 4f f6 56 2a 98 5a d1  bf 5d e4 0d ec 8f 47 42  |1O.V*.Z..]....GB|
-000001f0  62 a6 59 39 77 d8 bd 11  71 64 b4 2b 65 2a 10 5d  |b.Y9w...qd.+e*.]|
-00000200  46 51 bf 8d b6 13 df 61  b8 1e 37 ad fc c0 86 a9  |FQ.....a..7.....|
-00000210  b4 09 2f 33 8e 93 4a 5b  32 f4 f9 7d 01 a8 b8 09  |../3..J[2..}....|
-00000220  8e da 90 8f a7 fb 82 76  fd 6b 7e 93 57 13 e1 99  |.......v.k~.W...|
-00000230  cb b8 12 0a da c2 62 0e  0c 65 53 d4 5b 75 c2 22  |......b..eS.[u."|
-00000240  3f 91 5c e6 c4 12 48 78  c4 6d 2c 1f 45 dc a2 a1  |?.\...Hx.m,.E...|
-00000250  73 cf 69 97 8b 64 42 d5  22 06 de 04 4b 8c f5 5f  |s.i..dB."...K.._|
-00000260  d6 97 1a 73 4f 4e d2 55  e1 8d 8c 21 fd 7f 26 1c  |...sON.U...!..&.|
-00000270  53 9f 69 c9 01 11 be 4e  d0 ab 78 56 af bb 0a 0f  |S.i....N..xV....|
-00000280  73 cb c5 d2 07 4a 16 a0  71 9f dd 46 17 0e 86 5e  |s....J..q..F...^|
-00000290  e2 90 34 7d af b1 86 6c  e3 33 cf ff 2f bf ea 8e  |..4}...l.3../...|
-000002a0  62 7e 7f b9 f7 c4 1b 4c  61 b6 8d 6f a9 b4 56 27  |b~.....La..o..V'|
-000002b0  0a 0d fa d7 d9 ce 6a 1a  e3 4e 4d f8 04 c8 74 75  |......j..NM...tu|
-000002c0  07 6f 38 96 c7 04 df a4  e0 6a 08 c5 5b 93 b7 c1  |.o8......j..[...|
-000002d0  fb 4d 4f 01 67 3c 8b 03  93 f7 46 c2 db 2f 41 2d  |.MO.g<....F../A-|
-000002e0  e1 d6 dd 39 d5 0c dc 6a  10 c2 50 fe 34 64 79 9a  |...9...j..P.4dy.|
-000002f0  5e 88 35 89 16 03 03 00  bc d1 42 6c 11 23 45 dd  |^.5.......Bl.#E.|
-00000300  41 9e 81 0a 3d d1 c1 99  6f 91 b5 16 96 e6 d3 eb  |A...=...o.......|
-00000310  9b 8f c3 30 14 7f 19 d5  9a fa ea 9c de 53 23 7c  |...0.........S#||
-00000320  d8 49 d2 c5 e7 7c ff 96  22 0a 57 fc 11 ed b9 ca  |.I...|..".W.....|
-00000330  2e 18 a5 30 7e 3a d2 86  70 de 48 28 83 a1 3b 65  |...0~:..p.H(..;e|
-00000340  67 b9 2e 89 87 92 0e eb  b5 70 1d 36 7b 98 4b 8e  |g........p.6{.K.|
-00000350  12 49 db 85 18 dc e1 f4  51 a9 bb e4 5c ae 56 31  |.I......Q...\.V1|
-00000360  c1 56 84 bb e5 42 ec d1  41 e7 a7 4e 08 d7 5f 1d  |.V...B..A..N.._.|
-00000370  67 9a ed 10 b6 80 ff ea  36 70 ac a0 a9 ec 4a e3  |g.......6p....J.|
-00000380  37 ae bf f3 bd a9 aa 3f  b0 14 f6 0b 05 18 09 dd  |7......?........|
-00000390  29 b4 97 55 88 24 59 ce  5b 42 e2 b5 1f 04 76 f3  |)..U.$Y.[B....v.|
-000003a0  f1 c0 49 7d 47 ef 5e 6c  c3 ed 30 2c a0 a1 df c6  |..I}G.^l..0,....|
-000003b0  12 13 22 8b 65 16 03 03  00 4a 3e 6c f8 63 5b 93  |..".e....J>l.c[.|
-000003c0  f0 c6 3a 58 e0 6c 6b 70  46 d0 be 6f 13 34 7a 30  |..:X.lkpF..o.4z0|
-000003d0  e6 e4 b2 fd 39 ee 79 b1  7e 73 5e 9b 2d d9 3f 4f  |....9.y.~s^.-.?O|
-000003e0  61 d5 53 37 79 57 15 a3  3a 7c b7 02 cc 76 25 1d  |a.S7yW..:|...v%.|
-000003f0  96 8b dd 9e 32 8b 1a 9e  37 b1 1a b8 f2 4f ef 3c  |....2...7....O.<|
-00000400  78 e1 b9 07 16 03 03 00  14 bf da c1 d4 16 fd 48  |x..............H|
-00000410  a9 ad 59 6d 8c dc e1 6c  fd 73 ca 9c 1b           |..Ym...l.s...|
+00000000  16 03 03 00 81 2e c9 cd  ad df 75 cf b6 8d 7f 8c  |..........u.....|
+00000010  c6 bb 5b e6 2b 40 a0 36  45 13 ae 93 f1 04 bf f3  |..[.+@.6E.......|
+00000020  62 bd c8 62 d9 cf 05 a3  4c e9 37 af 35 a6 83 8e  |b..b....L.7.5...|
+00000030  71 46 b8 2a 5b 02 3b 81  d5 15 b8 17 72 c4 1e 00  |qF.*[.;.....r...|
+00000040  78 d9 4a 04 a7 b3 5b 80  bd 1f 88 ba fa 22 b5 0e  |x.J...[......"..|
+00000050  ca 44 55 27 c0 67 ce 37  4c 9a 9a d7 77 da 58 35  |.DU'.g.7L...w.X5|
+00000060  83 b3 39 90 8d e2 7f 08  2e cc 5a 8e 5e a8 c3 bb  |..9.......Z.^...|
+00000070  db e5 a2 56 56 04 37 13  f3 b1 71 2d ea 0a 56 00  |...VV.7...q-..V.|
+00000080  6e 8d 8b 20 79 30 16 03  03 02 69 76 4b a4 c6 5e  |n.. y0....ivK..^|
+00000090  0a a2 3c 89 24 f6 93 94  25 4e 0b 8a d2 33 2f 03  |..<.$...%N...3/.|
+000000a0  ab 20 22 33 ad 84 6d aa  31 6b 5a 10 0e 42 1b dd  |. "3..m.1kZ..B..|
+000000b0  35 9b a0 dc 31 f8 65 91  c4 14 78 2e 74 2e 1d 46  |5...1.e...x.t..F|
+000000c0  3a 66 41 f0 a3 9a 4e ae  bc 9b 55 f9 d1 9c c5 6e  |:fA...N...U....n|
+000000d0  38 24 19 15 fb e6 c3 85  de ef f0 97 a2 a1 db ed  |8$..............|
+000000e0  b8 d0 05 ae 93 77 d7 45  50 a5 4e 8a 83 84 07 fb  |.....w.EP.N.....|
+000000f0  3a 80 c6 69 3c 6e b2 e3  e0 97 f7 03 93 76 dd 32  |:..i<n.......v.2|
+00000100  0c 5d a2 e6 1f 82 90 8b  dd 93 06 ef eb b7 e0 74  |.].............t|
+00000110  1a 7d 8f 37 c2 c1 41 9c  30 74 ca 37 17 5e 71 a0  |.}.7..A.0t.7.^q.|
+00000120  cb d6 00 47 9d 14 93 aa  fe 57 56 10 ae 88 13 65  |...G.....WV....e|
+00000130  f4 6c 20 4e f9 14 87 73  36 5e d5 20 93 34 db 87  |.l N...s6^. .4..|
+00000140  e7 f8 84 6e 36 9d 60 20  b5 8f 47 33 84 94 22 e1  |...n6.` ..G3..".|
+00000150  5d c6 1c 35 39 61 71 47  90 a9 b4 c6 5e 31 58 d1  |]..59aqG....^1X.|
+00000160  40 d8 22 22 23 c2 53 e3  75 1f 98 1c cc 7f 2d 11  |@.""#.S.u.....-.|
+00000170  31 5e 49 a1 2c d9 c8 db  6e 4e 9d da 57 e1 c9 32  |1^I.,...nN..W..2|
+00000180  03 6c f0 9b df c2 03 d5  b7 e2 04 77 e8 87 bc 14  |.l.........w....|
+00000190  73 66 b0 fb d1 d6 26 0c  36 90 2c 20 43 16 c6 68  |sf....&.6., C..h|
+000001a0  6c c0 ee be 2c da 6f 4f  95 1e cf a0 31 e8 40 48  |l...,.oO....1.@H|
+000001b0  88 61 26 7b 53 5b 42 14  2a 89 a3 1e 03 01 16 9d  |.a&{S[B.*.......|
+000001c0  41 6d de 60 75 1d 36 12  cd 16 8b 1c 93 da 17 79  |Am.`u.6........y|
+000001d0  4b d2 1d 78 64 da 6c cc  5c 7c e3 f9 4d 70 a2 07  |K..xd.l.\|..Mp..|
+000001e0  b4 24 33 de 19 bc d2 1a  43 42 f4 26 8b c0 81 e4  |.$3.....CB.&....|
+000001f0  a3 32 97 09 ec 6f 39 d7  ca c9 c5 ee 38 fd 91 dd  |.2...o9.....8...|
+00000200  c4 dc 3c 53 38 60 c7 b6  60 c6 a9 ff ae 81 e9 8c  |..<S8`..`.......|
+00000210  ea 49 19 3f fe 0e 8e b8  e6 7c ec 4b 63 66 d8 7a  |.I.?.....|.Kcf.z|
+00000220  82 51 7f 24 51 ae ad 91  5d 0e 2c aa ee fa 9f d3  |.Q.$Q...].,.....|
+00000230  22 1a 8b 8d 12 48 bb 3a  7c ea f0 09 af 1a 7e 7e  |"....H.:|.....~~|
+00000240  47 74 b9 b9 1f 97 8e 64  62 52 ae 08 d5 f1 13 cb  |Gt.....dbR......|
+00000250  51 64 b0 6a 33 1f 48 78  c1 91 91 91 a7 75 29 cb  |Qd.j3.Hx.....u).|
+00000260  32 60 96 d4 27 3f a4 8f  12 e9 5d 79 4d fd f9 19  |2`..'?....]yM...|
+00000270  b8 f7 39 d8 53 e5 45 96  0f c6 4f f2 27 c6 e6 07  |..9.S.E...O.'...|
+00000280  40 47 29 94 b9 6a 38 9e  24 bf 9e 92 f6 67 3f e3  |@G)..j8.$....g?.|
+00000290  48 0f 3b 3a d7 7b 14 4e  34 a3 8a 25 b4 a2 d6 15  |H.;:.{.N4..%....|
+000002a0  3f 38 9e ba fa 7e 33 fd  a4 4c ed e7 58 93 65 7d  |?8...~3..L..X.e}|
+000002b0  90 48 fc 70 7e 10 a5 d0  0a ec 96 c4 cf 26 ae 94  |.H.p~........&..|
+000002c0  d7 3f 92 40 2f ad ed c8  bb 69 b1 3e 0b ab 4f 4e  |.?.@/....i.>..ON|
+000002d0  73 91 a6 05 2b a7 89 e8  63 28 39 51 53 8d 2c 5e  |s...+...c(9QS.,^|
+000002e0  c8 64 90 c3 b7 2d ee 00  aa 7f 38 ca 57 ab b8 aa  |.d...-....8.W...|
+000002f0  93 12 af c5 16 03 03 00  bc 0e 58 31 64 e6 68 e6  |..........X1d.h.|
+00000300  10 81 2f 79 e3 49 3a d9  cc 70 09 7e b6 b5 61 c4  |../y.I:..p.~..a.|
+00000310  92 16 22 d0 e5 af b8 b8  91 2e 72 7c cf 95 cb ef  |..".......r|....|
+00000320  14 81 73 33 34 98 65 1b  69 db 2c 9d eb 1c ce be  |..s34.e.i.,.....|
+00000330  1f ce 48 b4 22 8d f0 6e  48 21 8e aa af 83 43 d2  |..H."..nH!....C.|
+00000340  65 54 0f 57 6b ce b1 24  ef 09 bf 7f 23 92 35 07  |eT.Wk..$....#.5.|
+00000350  55 2f 2f e7 b7 d7 72 d2  7c 5f 71 d6 20 9a 68 e8  |U//...r.|_q. .h.|
+00000360  1b 90 0b 13 f7 37 e2 35  0d fc 04 ea 32 50 2d 04  |.....7.5....2P-.|
+00000370  72 1a db d9 71 e1 4e d1  76 7c c3 f5 22 97 92 c5  |r...q.N.v|.."...|
+00000380  61 19 e0 40 b1 14 de 37  9d 8e e7 fd fe 2b 28 97  |a..@...7.....+(.|
+00000390  91 77 8f a7 d4 b1 db bc  a2 78 65 5c a8 8d 41 21  |.w.......xe\..A!|
+000003a0  0e 56 6b ac 0b da a9 dd  b1 51 84 19 20 ab e5 eb  |.Vk......Q.. ...|
+000003b0  f2 52 8d 48 a2 16 03 03  00 4a 69 44 32 65 c2 09  |.R.H.....JiD2e..|
+000003c0  9c c1 d6 66 06 29 c3 a6  c3 10 2e d9 9e d6 0a d3  |...f.)..........|
+000003d0  06 a3 d2 d2 67 52 bd 19  26 a8 ef 08 ed 9f 2b e8  |....gR..&.....+.|
+000003e0  96 ea 08 b7 46 a2 36 e3  c1 84 4b c2 a2 b5 34 9c  |....F.6...K...4.|
+000003f0  83 ea 94 51 e6 ca 9c 0b  e1 e3 86 13 b7 1b 1f 4e  |...Q...........N|
+00000400  ee a1 10 70 16 03 03 00  14 5a 1c c1 14 fd d9 ff  |...p.....Z......|
+00000410  e3 46 ac 89 3b b3 e1 8e  6b 90 41 44 1f           |.F..;...k.AD.|
 >>> Flow 9 (client to server)
-00000000  16 03 03 02 69 11 1e 53  9b b7 57 6d ea 89 bb 37  |....i..S..Wm...7|
-00000010  1b c6 01 bd 27 db fa 17  cc 5d 20 be ee 5b a9 64  |....'....] ..[.d|
-00000020  48 4e 4a 4c 82 65 8e 3d  42 d6 ce 5c a8 50 d4 fa  |HNJL.e.=B..\.P..|
-00000030  0f 02 b2 19 90 b5 4e ae  6c e9 d6 b7 b8 64 ca 0e  |......N.l....d..|
-00000040  09 2d a9 7b ab 0f b8 83  97 b6 e0 eb bf 03 5a 1c  |.-.{..........Z.|
-00000050  e7 16 31 67 30 46 60 26  df 19 cf 5f fa 40 36 43  |..1g0F`&..._.@6C|
-00000060  91 d5 7c 2f 5f 29 74 03  e0 90 cd 55 25 e5 1e fe  |..|/_)t....U%...|
-00000070  6b 13 ec 58 29 b0 f4 a3  b2 8d ba 4e 3b f1 11 d8  |k..X)......N;...|
-00000080  85 49 50 b9 e0 03 89 a1  0f da ce 57 83 aa 4a 8c  |.IP........W..J.|
-00000090  3b 15 d5 10 47 01 22 32  4f 78 87 69 4c bf a6 6e  |;...G."2Ox.iL..n|
-000000a0  d4 e6 a5 1e fa 5b ff b0  38 a5 fa 83 1d 45 c5 18  |.....[..8....E..|
-000000b0  72 65 91 6c 41 d2 21 be  5b 1d e9 f5 19 eb d0 5a  |re.lA.!.[......Z|
-000000c0  7e 0d 81 c9 ca f0 97 9e  cc 9b 5c 77 6b 9c 15 d3  |~.........\wk...|
-000000d0  bd 43 4d 42 e5 f9 82 a9  d6 f2 44 93 ae 74 a3 fd  |.CMB......D..t..|
-000000e0  c5 1f 15 13 a0 ea d2 f3  4c 4c ea 2d fe 3b 6e 7b  |........LL.-.;n{|
-000000f0  f4 11 f7 2e 7d 45 26 a0  d9 29 4e 4d ec 90 e2 3e  |....}E&..)NM...>|
-00000100  51 52 dd 6e e1 b5 77 b1  a2 f5 17 b5 34 7f e8 8f  |QR.n..w.....4...|
-00000110  38 9c d6 1c b5 6c 2d 99  00 a1 41 95 15 c5 e5 bf  |8....l-...A.....|
-00000120  c1 67 fb ea 53 6c a8 85  8c c4 a6 74 e3 dc f7 90  |.g..Sl.....t....|
-00000130  b8 cc 99 39 1a a1 c6 51  db 65 e9 b8 ad 2b 1f 35  |...9...Q.e...+.5|
-00000140  b5 90 ae f7 af c2 d0 a9  92 eb 63 21 24 4f 5e 62  |..........c!$O^b|
-00000150  ba 69 ce 1a c8 41 79 db  c0 6c ef bc cf 19 4a 2c  |.i...Ay..l....J,|
-00000160  e0 66 6e 72 97 2d 75 e5  ee 14 82 e8 26 98 fe c4  |.fnr.-u.....&...|
-00000170  8a 17 c4 fb 48 2a d7 7e  d9 3e 5b f9 d4 7d 0e da  |....H*.~.>[..}..|
-00000180  56 44 5e 33 9d 5f 97 ab  d1 60 a8 ee 3d 16 6a 2a  |VD^3._...`..=.j*|
-00000190  33 b1 7d e2 e6 86 cd 88  ac e1 48 49 4e 19 a2 b0  |3.}.......HIN...|
-000001a0  16 53 ec ff b8 a4 f7 35  2d a7 7a 04 86 66 42 52  |.S.....5-.z..fBR|
-000001b0  51 3d 21 62 c5 35 9c e5  cb f9 bf 7b d1 12 b0 18  |Q=!b.5.....{....|
-000001c0  7b 6f 88 d9 ef d2 1a 45  3e 51 ac 3e c8 87 8c 47  |{o.....E>Q.>...G|
-000001d0  08 d0 90 b5 66 f6 4e c3  75 74 68 c8 7d 14 3a 2b  |....f.N.uth.}.:+|
-000001e0  83 7d 12 78 37 9e 11 02  3d 63 ba 78 b6 ba 6d 26  |.}.x7...=c.x..m&|
-000001f0  30 b0 bf a9 23 1e 83 aa  3d a8 02 5b 77 5f 2a 95  |0...#...=..[w_*.|
-00000200  d0 b9 c8 22 a3 a9 fe b0  32 99 8a 46 67 10 b3 d9  |..."....2..Fg...|
-00000210  3e 84 02 ec a2 68 7e 69  db 51 99 37 ee 49 66 0b  |>....h~i.Q.7.If.|
-00000220  af e1 cd b0 25 74 dc ce  29 ed 70 1c 3a bb f2 99  |....%t..).p.:...|
-00000230  03 86 6d af 3f 78 4a 86  70 b8 85 15 02 91 be f6  |..m.?xJ.p.......|
-00000240  4f f2 73 98 00 c6 76 20  c2 19 c6 e9 6c d0 e5 09  |O.s...v ....l...|
-00000250  5c 12 c8 1c a1 3d b7 41  18 26 cb ea d0 92 61 53  |\....=.A.&....aS|
-00000260  06 7c f8 5e a8 27 de 76  4e 83 49 2a ab 82 16 03  |.|.^.'.vN.I*....|
-00000270  03 00 35 4f b7 51 7c c8  51 25 a4 58 de 8b 4a e2  |..5O.Q|.Q%.X..J.|
-00000280  97 cc 48 d0 4d be 9b 8a  44 3b 22 43 b9 82 a4 a5  |..H.M...D;"C....|
-00000290  76 38 0b ae 91 d3 20 75  18 50 f3 1b eb 11 fd 86  |v8.... u.P......|
-000002a0  4a 1a f1 e8 2a f8 e0 60  16 03 03 00 98 ae e6 1b  |J...*..`........|
-000002b0  b1 00 f9 14 93 55 be 63  ea 5b 5e d4 18 37 6b 14  |.....U.c.[^..7k.|
-000002c0  5c 8e fb 82 51 e1 57 24  b7 4a 8b 55 74 79 70 55  |\...Q.W$.J.UtypU|
-000002d0  de 33 82 14 0a 39 0d 91  92 9a 11 c0 4a dd 12 49  |.3...9......J..I|
-000002e0  ea 1a 41 df fd f2 4a 79  c3 0a d5 93 5c ea 82 ff  |..A...Jy....\...|
-000002f0  16 4a 20 91 25 34 5d 72  9d ea 0e 40 dd 6d 86 fd  |.J .%4]r...@.m..|
-00000300  e9 d1 d9 db 61 e6 62 17  6b 09 47 c4 a7 32 1c 22  |....a.b.k.G..2."|
-00000310  f6 e4 41 2a 3e 2b d0 c3  92 56 c5 b8 5f 6d 25 44  |..A*>+...V.._m%D|
-00000320  81 e7 1a ed 70 6a a6 94  89 d1 ad 8d d1 c0 df a2  |....pj..........|
-00000330  26 6f 20 0b 0e 51 15 dd  05 86 36 88 72 3f e1 5d  |&o ..Q....6.r?.]|
-00000340  da 9d d3 76 e4 14 03 03  00 11 52 70 cd 84 39 32  |...v......Rp..92|
-00000350  7c c0 58 53 9b 32 00 96  14 b6 57 16 03 03 00 20  ||.XS.2....W.... |
-00000360  98 94 aa 9f 77 71 42 3e  48 e8 74 8e 27 60 54 c2  |....wqB>H.t.'`T.|
-00000370  55 ac 52 99 37 21 f3 1e  30 93 5f 71 06 19 e5 1c  |U.R.7!..0._q....|
+00000000  16 03 03 02 69 c8 db 54  92 d3 ea 2f 24 47 f9 24  |....i..T.../$G.$|
+00000010  53 c1 d4 6a e8 dd 1d 71  d6 fb 2c 7e 3a 41 75 f6  |S..j...q..,~:Au.|
+00000020  0c 08 70 b6 f9 0a 12 4b  0d 3d 34 03 a9 36 9e f1  |..p....K.=4..6..|
+00000030  c7 93 dc 51 e4 15 3d fd  a7 67 28 24 32 fe ff d3  |...Q..=..g($2...|
+00000040  cd 69 d6 4a 5d 11 78 3b  aa 07 8d 1e c4 97 22 34  |.i.J].x;......"4|
+00000050  df 03 f2 37 fd 4f 76 c3  04 a6 a6 0f 35 1c 0f 13  |...7.Ov.....5...|
+00000060  7e 0a b9 5e 47 d2 9a 8c  d8 a3 f4 7a e4 92 5f 12  |~..^G......z.._.|
+00000070  a6 20 fb 51 16 af eb 55  d0 23 4e b5 f9 e8 cc 33  |. .Q...U.#N....3|
+00000080  bd d1 52 27 21 96 06 05  67 fa 68 0e ab 2c 84 05  |..R'!...g.h..,..|
+00000090  c9 97 6a db 69 57 a8 5c  55 a9 e1 cf 33 01 28 9a  |..j.iW.\U...3.(.|
+000000a0  76 09 64 a4 a3 31 36 13  72 27 0c 85 e9 59 47 27  |v.d..16.r'...YG'|
+000000b0  89 07 ee e2 e0 68 a6 f0  fa d5 c3 8b 2f 75 68 d0  |.....h....../uh.|
+000000c0  8e d8 fe ae 1d 0d af 0b  40 3d 9f ec 85 03 24 20  |........@=....$ |
+000000d0  c5 11 30 aa 25 ee 2c 86  42 ae 4f 0d 6b 18 70 1d  |..0.%.,.B.O.k.p.|
+000000e0  5f ae 1e cf 99 a7 0e c8  9b b3 63 58 cd b6 7d be  |_.........cX..}.|
+000000f0  01 43 96 37 87 45 5f 2f  aa 9c 12 48 ef 3b c8 d9  |.C.7.E_/...H.;..|
+00000100  60 20 26 69 68 56 48 aa  64 59 9e 41 ed 7e 8d c3  |` &ihVH.dY.A.~..|
+00000110  0f cd 0e 19 7a 76 89 95  f8 20 68 cd f9 81 e9 a0  |....zv... h.....|
+00000120  21 ff 60 e5 0f 6d dd 73  d2 19 1e 2a 76 f7 9a 46  |!.`..m.s...*v..F|
+00000130  5d d5 6b b2 19 28 c2 ac  9c e0 35 c8 d2 2a 53 fa  |].k..(....5..*S.|
+00000140  3e 58 9e f2 05 7e 6b ce  51 6d 3d 2a ce 2e 9b 59  |>X...~k.Qm=*...Y|
+00000150  aa d4 8d cc ad 1f 82 e7  ca 5a ef a6 87 d5 41 0b  |.........Z....A.|
+00000160  8d 27 6d 09 4d 40 c3 26  a3 a9 91 dd 1b 37 5d ff  |.'m.M@.&.....7].|
+00000170  8f c3 c7 b1 bf be f5 d1  19 4d 93 86 a7 5f 5e 8f  |.........M..._^.|
+00000180  14 34 82 50 76 25 42 04  b8 4b d3 da 15 ee 60 d1  |.4.Pv%B..K....`.|
+00000190  35 56 4c 63 0d ba 64 13  4f 3d 12 87 84 5a 45 41  |5VLc..d.O=...ZEA|
+000001a0  14 b6 6f 91 c4 b9 4f 97  c1 10 d6 3e b3 99 21 18  |..o...O....>..!.|
+000001b0  c3 91 82 e4 b6 91 3e bb  01 89 9a f0 60 ac 8e 7d  |......>.....`..}|
+000001c0  cf c2 f9 b4 4f da 40 e3  5e 83 a1 8f b4 fa 28 aa  |....O.@.^.....(.|
+000001d0  c9 ae 7b 8f 7d c9 d1 f8  7b b2 b5 3f 0a 9b 00 9e  |..{.}...{..?....|
+000001e0  1d fa 59 ff 39 b7 85 4d  2a b9 b8 67 03 df a0 f9  |..Y.9..M*..g....|
+000001f0  f1 7e 9d 27 1c 55 a9 76  44 9e f1 13 78 7d 34 4d  |.~.'.U.vD...x}4M|
+00000200  c9 23 07 e6 db 93 d7 70  3c 1b 5d 89 ed 8d 3d 43  |.#.....p<.]...=C|
+00000210  2e 89 f6 14 83 ff 87 db  26 a5 9a cd 98 5d 32 24  |........&....]2$|
+00000220  70 d2 e0 72 a7 6f a4 b4  2b 37 db 7e 39 4f d7 37  |p..r.o..+7.~9O.7|
+00000230  ea 68 b5 98 33 0e 23 21  3f 43 b3 ff 18 8e df 85  |.h..3.#!?C......|
+00000240  ba 15 48 3a fe 09 9b b6  27 40 d4 60 a8 3e 55 a3  |..H:....'@.`.>U.|
+00000250  75 c9 32 38 b5 21 46 ab  41 99 24 e6 09 3f 64 e6  |u.28.!F.A.$..?d.|
+00000260  09 40 cb 93 25 ab 1a 90  c7 d5 a6 40 36 a0 16 03  |.@..%......@6...|
+00000270  03 00 35 0f c7 e4 c3 16  c0 4f 7f 25 04 06 63 e7  |..5......O.%..c.|
+00000280  79 79 f9 4f c9 66 ca cd  ba e3 af 4a 50 a3 3d c3  |yy.O.f.....JP.=.|
+00000290  79 0c 71 d9 2f df 93 79  30 8f 6b 0f 54 f9 be 07  |y.q./..y0.k.T...|
+000002a0  f3 d6 9b c0 2a 3a 0a a1  16 03 03 00 98 b8 f1 fc  |....*:..........|
+000002b0  87 62 e9 6b 40 fd 50 ac  b7 fa 52 69 51 66 ae 9b  |.b.k@.P...RiQf..|
+000002c0  05 7e f2 38 73 27 d8 0c  2a 53 37 30 62 76 5d e9  |.~.8s'..*S70bv].|
+000002d0  fd 95 c6 14 d2 9d 34 13  e9 4c a5 7c c0 b6 e0 c4  |......4..L.|....|
+000002e0  97 ef 01 c0 f9 38 39 ee  17 c0 20 01 76 4f a7 10  |.....89... .vO..|
+000002f0  b0 45 9d c7 c3 cd a9 47  14 4a ed 00 1f 06 70 5b  |.E.....G.J....p[|
+00000300  f5 04 8b 77 ad af 1e 77  7a 9d cc fc a4 1f d2 8d  |...w...wz.......|
+00000310  8f e3 31 d3 3c de e6 85  f3 3d c0 ae 78 f7 22 c6  |..1.<....=..x.".|
+00000320  ec 2e a2 f0 5f ed 95 33  54 8c 89 35 c9 e4 25 4b  |...._..3T..5..%K|
+00000330  84 5e 31 83 04 d0 f1 67  69 73 8b 7f 24 ae e0 87  |.^1....gis..$...|
+00000340  6b f7 ba f0 23 14 03 03  00 11 7a c7 6a 32 2b 9b  |k...#.....z.j2+.|
+00000350  25 c2 d2 ee 37 b2 8d 7b  f2 90 6d 16 03 03 00 20  |%...7..{..m.... |
+00000360  c1 1c 9d 18 a9 41 92 fc  05 19 93 7c 7e 2f b2 39  |.....A.....|~/.9|
+00000370  8c 76 4b 29 5a 67 cc f5  55 9f c0 e3 8f ad ee 3c  |.vK)Zg..U......<|
 >>> Flow 10 (server to client)
-00000000  14 03 03 00 11 45 8e f9  74 04 d0 44 c6 94 80 60  |.....E..t..D...`|
-00000010  c1 50 7d b2 64 76 16 03  03 00 20 d5 65 8a b9 26  |.P}.dv.... .e..&|
-00000020  54 70 26 de c6 8a 8f 61  a3 b1 9e 8b 49 40 f7 24  |Tp&....a....I@.$|
-00000030  4f 75 e0 94 e6 e7 68 51  38 8a 37 17 03 03 00 19  |Ou....hQ8.7.....|
-00000040  42 7e 5a e2 46 7b ba 7d  0d 07 20 2a c0 56 fe aa  |B~Z.F{.}.. *.V..|
-00000050  01 eb ca d2 29 1d ff 85  10                       |....)....|
+00000000  14 03 03 00 11 49 66 13  ec 09 83 0d 47 82 45 61  |.....If.....G.Ea|
+00000010  06 14 cc f5 da 41 16 03  03 00 20 34 d4 0c bd 86  |.....A.... 4....|
+00000020  6d ef a9 b6 97 68 e6 88  84 ed 1c 9d a1 8d 2b c9  |m....h........+.|
+00000030  2f 45 75 5b e5 6a 08 72  71 a9 c6 17 03 03 00 19  |/Eu[.j.rq.......|
+00000040  e8 83 4c f5 19 ea d1 ef  e3 27 25 f9 af d2 f0 a6  |..L......'%.....|
+00000050  b3 62 15 66 ec 72 ce 4e  e2                       |.b.f.r.N.|
 >>> Flow 11 (client to server)
-00000000  15 03 03 00 12 1d 01 c7  d5 d5 d1 ce 8c 52 15 8f  |.............R..|
-00000010  75 1e 97 fa 38 5c 65                              |u...8\e|
+00000000  15 03 03 00 12 2e 39 ba  ca ad 7c a9 ae 3f 6a 78  |......9...|..?jx|
+00000010  b6 31 d2 d0 4e 1f dc                              |.1..N..|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-RenegotiateTwice b/src/crypto/tls/testdata/Client-TLSv12-RenegotiateTwice
index 006e2d7cef..20aa6c9fcf 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-RenegotiateTwice
+++ b/src/crypto/tls/testdata/Client-TLSv12-RenegotiateTwice
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 59 02 00 00  55 03 03 47 d0 f5 d9 f0  |....Y...U..G....|
-00000010  59 d1 bf 28 d0 39 36 c0  bc d1 25 fd 5a 63 18 06  |Y..(.96...%.Zc..|
-00000020  1e 8a 5c a6 6f d0 f9 b4  02 23 e1 20 df a0 2a 74  |..\.o....#. ..*t|
-00000030  1a 52 8b d9 90 01 c2 86  69 12 b8 13 58 aa 59 b0  |.R......i...X.Y.|
-00000040  66 79 ff 01 9b 9a 72 1c  a6 83 e6 91 cc a8 00 00  |fy....r.........|
+00000000  16 03 03 00 59 02 00 00  55 03 03 68 39 1d 0e 5a  |....Y...U..h9..Z|
+00000010  22 ba 13 5f b6 c1 52 5d  13 e5 07 18 aa ec 24 0f  |".._..R]......$.|
+00000020  c9 56 3a 83 a1 32 a1 7f  02 e8 7b 20 31 e2 f8 c4  |.V:..2....{ 1...|
+00000030  5b c2 57 9a 1d a4 6f a7  9c 1c 93 b1 9f 19 c3 cb  |[.W...o.........|
+00000040  e1 73 87 1b a8 88 d9 4c  67 2f 44 aa cc a8 00 00  |.s.....Lg/D.....|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  03 02 59 0b 00 02 55 00  02 52 00 02 4f 30 82 02  |..Y...U..R..O0..|
 00000070  4b 30 82 01 b4 a0 03 02  01 02 02 09 00 e8 f0 9d  |K0..............|
@@ -60,284 +60,284 @@
 00000290  77 8d 0c 1c f1 0f a1 d8  40 83 61 c9 4c 72 2b 9d  |w.......@.a.Lr+.|
 000002a0  ae db 46 06 06 4d f4 c1  b3 3e c0 d1 bd 42 d4 db  |..F..M...>...B..|
 000002b0  fe 3d 13 60 84 5c 21 d3  3b e9 fa e7 16 03 03 00  |.=.`.\!.;.......|
-000002c0  ac 0c 00 00 a8 03 00 1d  20 20 97 bd 85 2f cb 85  |........  .../..|
-000002d0  be a8 9c e3 ae 6b 23 a5  5b 18 65 5c f5 cc 24 2b  |.....k#.[.e\..$+|
-000002e0  34 2c 5f c8 4d e9 86 35  0b 08 04 00 80 d2 b6 ee  |4,_.M..5........|
-000002f0  86 76 aa 1d 9c 1c ee ef  0e 59 63 1d ec f1 cf a1  |.v.......Yc.....|
-00000300  f3 5b 6d da 99 9c 40 07  bf 28 ad 72 cd 80 6c 9d  |.[m...@..(.r..l.|
-00000310  bf a2 20 33 2d d0 67 ef  90 28 88 2b d0 8e c6 9d  |.. 3-.g..(.+....|
-00000320  87 7a 18 8f 80 ce 25 92  13 8d ef 38 0a 14 f9 67  |.z....%....8...g|
-00000330  88 94 ef af 97 d2 21 90  9e 24 2f af 1e bb fa 10  |......!..$/.....|
-00000340  4c a7 9f f5 27 63 e6 d8  1a 86 53 c6 3c 15 a8 6c  |L...'c....S.<..l|
-00000350  b9 bc 8f c4 38 1a 4b 34  36 ec af b2 1e d0 bf 58  |....8.K46......X|
-00000360  74 36 ad fb e4 f0 fd 9d  6d 01 cf 51 6c 16 03 03  |t6......m..Ql...|
+000002c0  ac 0c 00 00 a8 03 00 1d  20 57 22 18 98 ed 7f 12  |........ W".....|
+000002d0  e7 e3 83 6b 42 82 ff 49  54 f8 0b 7d 93 3d 11 42  |...kB..IT..}.=.B|
+000002e0  67 cf 89 47 77 31 c5 59  4a 08 04 00 80 69 d4 13  |g..Gw1.YJ....i..|
+000002f0  f8 1c 68 9d 40 10 c8 aa  e6 44 0e 14 b9 38 6e ca  |..h.@....D...8n.|
+00000300  a9 50 05 4a ce a0 03 ea  02 92 e4 5a ed 42 6f 70  |.P.J.......Z.Bop|
+00000310  e1 c1 99 49 a4 34 20 6b  5e 14 e8 a1 d3 27 ff 0d  |...I.4 k^....'..|
+00000320  0c d7 47 49 1e 8f 8a 3a  62 1d c9 81 3c 5f a3 16  |..GI...:b...<_..|
+00000330  16 34 a0 53 a7 01 1d 09  f7 d9 d4 62 b2 0a 1c 1f  |.4.S.......b....|
+00000340  b2 e5 24 1b 7e 78 35 43  ed 47 f8 62 53 2d 04 ec  |..$.~x5C.G.bS-..|
+00000350  81 b5 68 11 3a 2d ee 88  ef 86 eb 71 d0 5e 31 42  |..h.:-.....q.^1B|
+00000360  57 6d b6 f2 be 32 4c 38  f8 2a 93 2f db 16 03 03  |Wm...2L8.*./....|
 00000370  00 04 0e 00 00 00                                 |......|
 >>> Flow 3 (client to server)
 00000000  16 03 03 00 25 10 00 00  21 20 2f e5 7d a3 47 cd  |....%...! /.}.G.|
 00000010  62 43 15 28 da ac 5f bb  29 07 30 ff f6 84 af c4  |bC.(.._.).0.....|
 00000020  cf c2 ed 90 99 5f 58 cb  3b 74 14 03 03 00 01 01  |....._X.;t......|
-00000030  16 03 03 00 20 e8 d5 df  da 49 9a 94 10 30 90 81  |.... ....I...0..|
-00000040  c6 19 54 d4 0d e2 0d e0  d9 a3 c0 21 7f a6 d1 cc  |..T........!....|
-00000050  ea 75 2e 17 01                                    |.u...|
+00000030  16 03 03 00 20 2a 03 0a  58 36 31 ec 26 df e5 7c  |.... *..X61.&..||
+00000040  88 b5 d1 f7 6d fc 4b 0a  91 54 4a e7 8c 83 a3 54  |....m.K..TJ....T|
+00000050  0a 10 5b ff 69                                    |..[.i|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 20 f3 92 03 fb 7b  |.......... ....{|
-00000010  0f 32 0b 5b dd 9e eb c3  26 2c 92 4d 58 35 a8 96  |.2.[....&,.MX5..|
-00000020  74 d6 d8 0f 61 b2 7d b6  8d ec e6                 |t...a.}....|
+00000000  14 03 03 00 01 01 16 03  03 00 20 27 b0 69 0c 67  |.......... '.i.g|
+00000010  c7 3a ec c1 aa 02 20 cf  f9 e8 22 86 3b d3 e1 4f  |.:.... ...".;..O|
+00000020  bc fd 04 40 19 77 bf bd  38 28 56                 |...@.w..8(V|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 16 ab 69 44  d0 fe 95 93 ae f9 1b d7  |......iD........|
-00000010  33 6c 59 a5 41 cc d2 1b  ca 2c 63                 |3lY.A....,c|
+00000000  17 03 03 00 16 8a 2c 24  1b b8 53 01 54 c8 bd f3  |......,$..S.T...|
+00000010  e1 ec a9 ab 83 a0 66 a9  29 1c 4e                 |......f.).N|
 >>> Flow 6 (server to client)
-00000000  16 03 03 00 14 99 96 92  c4 82 c8 27 77 a6 f4 ca  |...........'w...|
-00000010  e5 5b ff 78 bc 54 b6 d7  cd                       |.[.x.T...|
+00000000  16 03 03 00 14 c5 e3 03  06 89 d8 47 1a 66 18 0e  |...........G.f..|
+00000010  8d 36 c5 f4 30 80 7e 72  a2                       |.6..0.~r.|
 >>> Flow 7 (client to server)
-00000000  16 03 03 01 16 d9 6a 26  33 e5 d8 df 32 d1 f5 84  |......j&3...2...|
-00000010  1f 37 7f 07 6a ae be 20  84 20 dc 28 31 8e 46 32  |.7..j.. . .(1.F2|
-00000020  0b 96 c8 22 28 fb 98 d9  8e 6f 6d 97 66 55 e2 1e  |..."(....om.fU..|
-00000030  b5 b8 e4 9b 52 25 28 c2  72 cb 9e 14 4c ba 58 6c  |....R%(.r...L.Xl|
-00000040  3b 33 da 56 db fe 14 d3  4c b4 ce a9 57 64 ae 4e  |;3.V....L...Wd.N|
-00000050  5f c5 a7 e6 f4 01 51 d7  81 f4 1d ca fa 3f 86 e7  |_.....Q......?..|
-00000060  9f 64 28 6e 3f e4 ef 79  77 20 64 45 ed a2 16 e1  |.d(n?..yw dE....|
-00000070  b4 63 99 9f 62 6d b7 6d  f4 ad 1f fe d9 de 00 84  |.c..bm.m........|
-00000080  4b bb 0c bc c8 82 a8 1d  8a ac f6 10 2d 5d d4 c7  |K...........-]..|
-00000090  37 f8 fc 89 24 ea c4 b8  87 f4 f4 f0 4b cd db e2  |7...$.......K...|
-000000a0  15 03 95 1e c1 10 7c e8  6d 99 6c e0 bc e1 0a a5  |......|.m.l.....|
-000000b0  d8 36 eb 59 93 6d 1c 96  1c 61 1b 11 36 04 58 6b  |.6.Y.m...a..6.Xk|
-000000c0  c5 b0 fb 8e 9f 21 4a 25  a1 59 ee 5d 1b e3 e3 98  |.....!J%.Y.]....|
-000000d0  71 0a d8 3f 18 f2 b2 1c  6f ec 6d 87 13 b9 d3 25  |q..?....o.m....%|
-000000e0  53 c1 00 78 be 99 82 f6  27 05 24 01 10 1c 59 19  |S..x....'.$...Y.|
-000000f0  94 6a af 7e e5 ae c5 03  14 04 e2 fe 5e 59 e8 e0  |.j.~........^Y..|
-00000100  45 3d af c0 40 ea 84 0a  13 9c d3 0f d4 69 3f 3e  |E=..@........i?>|
-00000110  97 83 ac b5 b9 07 56 9a  19 44 ca                 |......V..D.|
+00000000  16 03 03 01 16 7e eb a3  b5 ea 58 e3 4a 26 35 7d  |.....~....X.J&5}|
+00000010  54 15 93 74 e8 e4 63 34  38 d9 e0 02 3d 28 f8 98  |T..t..c48...=(..|
+00000020  0f 24 6b ca 08 7f b6 77  68 ec 85 c3 4a 6b 69 c3  |.$k....wh...Jki.|
+00000030  8d 8e 1b 8b 41 11 9b 0d  d1 c8 99 2b c9 d2 4c f1  |....A......+..L.|
+00000040  fd 82 e5 35 ba a3 3b f3  6d 47 82 45 08 e7 02 bb  |...5..;.mG.E....|
+00000050  10 a6 7b 76 83 78 e0 aa  5a 78 24 59 1c db ae a3  |..{v.x..Zx$Y....|
+00000060  37 20 b3 12 98 48 68 d3  b3 72 9f 4f d4 de 50 b4  |7 ...Hh..r.O..P.|
+00000070  4a c1 37 93 e0 55 ae e8  37 2a 40 de ac 30 e1 1d  |J.7..U..7*@..0..|
+00000080  f0 03 19 8c af 77 f5 26  98 af a8 a8 d2 72 6c 68  |.....w.&.....rlh|
+00000090  75 00 32 10 e6 3f 91 a8  24 a7 d8 05 23 04 52 23  |u.2..?..$...#.R#|
+000000a0  e7 e6 83 ac 37 1b 36 a7  ca d4 7e d5 21 4c ab 38  |....7.6...~.!L.8|
+000000b0  23 cb 7c a9 f4 66 26 5e  7f 3e d6 ab 7a ac 34 38  |#.|..f&^.>..z.48|
+000000c0  95 16 df e2 e4 cf 3a 62  82 78 cb 71 32 06 6d 07  |......:b.x.q2.m.|
+000000d0  84 91 0c e9 d0 63 88 9e  d1 b5 f0 fb 43 2b 07 0b  |.....c......C+..|
+000000e0  32 d7 20 af b8 76 17 da  ee cc e6 03 bb 7a 0b f2  |2. ..v.......z..|
+000000f0  61 4f db 7f a3 66 b0 05  a8 88 b8 0b b3 6e 9c df  |aO...f.......n..|
+00000100  48 8b 7e eb 42 cd ea eb  1d bb 63 a0 e4 ee df 21  |H.~.B.....c....!|
+00000110  20 67 11 26 dd f1 47 1b  15 2b a0                 | g.&..G..+.|
 >>> Flow 8 (server to client)
-00000000  16 03 03 00 81 4b d8 09  ef 6a 5b a2 c2 e0 2c b3  |.....K...j[...,.|
-00000010  fa e9 21 b3 64 c7 51 8d  d4 14 14 ba 7b 2f f8 1a  |..!.d.Q.....{/..|
-00000020  e9 f8 7a 69 8b 0b b4 5f  26 c5 b6 2e dd c9 90 04  |..zi..._&.......|
-00000030  7d af fd 56 f7 9a 0d 56  09 6c 74 48 49 74 90 71  |}..V...V.ltHIt.q|
-00000040  e1 ee 66 4c 1a da 66 43  50 fa 94 2c 84 21 10 f0  |..fL..fCP..,.!..|
-00000050  00 85 a7 c2 ea 73 19 52  b7 f2 2a e8 17 17 23 67  |.....s.R..*...#g|
-00000060  b6 80 d6 3f e0 a1 ed 81  66 89 0a 0d 48 9f 7f dc  |...?....f...H...|
-00000070  79 c4 27 9b c0 b8 68 ef  2a 5b ab df 8f 82 d6 ff  |y.'...h.*[......|
-00000080  84 38 f8 a4 f2 98 16 03  03 02 69 1f c6 1c dc 85  |.8........i.....|
-00000090  f1 66 8d 7f 7f aa 36 cd  c6 d4 cc 38 c8 8d 98 75  |.f....6....8...u|
-000000a0  92 d2 db b4 49 0c 09 cc  af e6 5b 07 64 76 34 c8  |....I.....[.dv4.|
-000000b0  41 49 85 5e b4 68 ac 35  04 72 00 70 33 f7 5f a7  |AI.^.h.5.r.p3._.|
-000000c0  84 40 34 03 2f 89 25 06  a1 50 dc ea d7 c4 29 57  |.@4./.%..P....)W|
-000000d0  f9 5b 57 63 14 02 1e 74  db 5d 02 cf c4 f1 89 f6  |.[Wc...t.]......|
-000000e0  6a 77 ce 87 5c 3a 61 b8  7d 02 f0 0e 6e 85 2a 51  |jw..\:a.}...n.*Q|
-000000f0  d8 ad 4a 9f 65 04 4c 00  d0 35 76 01 dc 03 cf ca  |..J.e.L..5v.....|
-00000100  6b 11 83 9e 70 33 82 f6  cb eb 4c da 44 76 89 ab  |k...p3....L.Dv..|
-00000110  d4 65 01 e6 08 7b 2a 3d  49 02 39 85 e8 ff 53 fd  |.e...{*=I.9...S.|
-00000120  d0 ce 2a f0 11 3c 02 8f  bd b8 2f ea 81 a1 64 10  |..*..<..../...d.|
-00000130  7b c2 8b 72 f3 32 7b 36  80 13 17 8b 83 dc ce 3a  |{..r.2{6.......:|
-00000140  29 44 06 66 c9 c3 83 cc  28 38 c5 02 7c 3d b6 30  |)D.f....(8..|=.0|
-00000150  55 07 a0 08 bb b3 e1 1e  a8 a5 74 60 51 be ee dd  |U.........t`Q...|
-00000160  aa 83 09 e9 f3 c7 a5 1e  20 fc 6d d5 82 af f5 b6  |........ .m.....|
-00000170  5b 23 dd 81 ce 78 5a 3c  92 c3 96 e1 aa e5 ad 24  |[#...xZ<.......$|
-00000180  da 89 41 44 8b 0b 42 df  e5 28 11 8e 9a e0 06 51  |..AD..B..(.....Q|
-00000190  80 93 15 31 ec 8c 3e 60  92 ab a5 ec 25 5c c5 10  |...1..>`....%\..|
-000001a0  ac 0f 01 1b c4 36 d5 f0  52 c7 0b f7 9b 40 9b c0  |.....6..R....@..|
-000001b0  18 ad 1c eb 49 ed 8e 27  b6 35 b4 20 e0 e6 df 04  |....I..'.5. ....|
-000001c0  69 d6 b5 56 04 30 d4 3d  b0 9f e6 21 66 e7 97 cb  |i..V.0.=...!f...|
-000001d0  2f bd b2 b2 c1 be 4b 4f  6e 88 60 a1 cb eb b4 86  |/.....KOn.`.....|
-000001e0  92 07 da 3c fa 8b 1a de  1c e7 6b c0 53 70 e7 ee  |...<......k.Sp..|
-000001f0  2f 70 4f e0 2a a3 b4 dc  af 64 4f 5a 44 f9 ff fc  |/pO.*....dOZD...|
-00000200  7f 2f 7e 22 13 47 ed f4  ec 0c fa 01 21 e3 c1 d6  |./~".G......!...|
-00000210  c7 53 f4 de 6c 91 c5 85  bd 3c a7 f3 d6 e7 f3 31  |.S..l....<.....1|
-00000220  13 59 b7 ee 0b f7 6a 88  76 94 ab 45 41 9e ab d7  |.Y....j.v..EA...|
-00000230  71 59 7e 45 ed 4d a0 12  4a 81 6a 15 05 a9 21 94  |qY~E.M..J.j...!.|
-00000240  40 f0 1d aa 7e b3 d4 6d  a6 ff 46 94 e6 d0 16 46  |@...~..m..F....F|
-00000250  60 ac c5 15 94 d5 f7 76  1e 8b 90 e6 17 ff 5c 21  |`......v......\!|
-00000260  d0 f9 98 25 0f 98 8b 6c  0f 2c 2a 92 0a f0 90 3d  |...%...l.,*....=|
-00000270  ef 9a 40 67 21 83 f7 5c  95 24 97 f6 45 51 81 4c  |..@g!..\.$..EQ.L|
-00000280  4b e1 64 0a f5 dd 02 fd  8d 21 d1 ef f8 96 70 4b  |K.d......!....pK|
-00000290  58 aa 3c f9 b1 f1 e9 fd  31 ea fc 68 4b c9 fa 79  |X.<.....1..hK..y|
-000002a0  6d 2e 54 d7 1c 9d 5d 62  fc 43 2f cb 6a 48 4d 2e  |m.T...]b.C/.jHM.|
-000002b0  07 71 7b f2 b3 e6 08 8b  13 ca f0 e9 c1 d2 cc 7a  |.q{............z|
-000002c0  9a 49 e9 7b aa e8 bb d2  cf 97 73 b8 9a 3f 8b 01  |.I.{......s..?..|
-000002d0  b9 cf c6 81 fd 99 fc c9  43 08 35 2c a0 fb 38 32  |........C.5,..82|
-000002e0  8b d8 5b d4 20 41 a0 57  e6 34 c1 d8 66 6e 16 e7  |..[. A.W.4..fn..|
-000002f0  78 4f e8 58 16 03 03 00  bc d3 91 f3 88 2f ec 1c  |xO.X........./..|
-00000300  da 94 cb b0 69 70 a2 41  4c fd 40 0d a0 97 01 34  |....ip.AL.@....4|
-00000310  35 83 e6 3f a8 b0 c9 26  8d f1 8a c1 f6 a6 ab a4  |5..?...&........|
-00000320  63 65 5a 10 38 d2 87 a7  8d ae ca 9e c6 23 7e c6  |ceZ.8........#~.|
-00000330  c8 45 37 e8 7c 4b 40 5a  5b 68 19 bb 36 83 81 41  |.E7.|K@Z[h..6..A|
-00000340  b2 fe 7c 39 7e 9f 95 3a  45 2e 9f 96 35 26 81 73  |..|9~..:E...5&.s|
-00000350  4d 0f c3 09 61 32 eb 64  4b 46 76 c1 0e ca cf 02  |M...a2.dKFv.....|
-00000360  6a f3 75 f3 bf aa b0 f8  43 e3 6b d1 c4 27 3e fe  |j.u.....C.k..'>.|
-00000370  06 a2 49 e4 bb 56 c5 c0  5d 36 81 06 97 ed ff a2  |..I..V..]6......|
-00000380  99 78 43 0a c5 20 df a3  ac b7 8f 61 a2 ff 48 66  |.xC.. .....a..Hf|
-00000390  ea c1 b6 57 38 fc 36 7c  dd 30 b5 ce 58 b1 18 82  |...W8.6|.0..X...|
-000003a0  e5 2a 54 d8 4d da f1 fc  98 06 97 43 d5 dc d9 3e  |.*T.M......C...>|
-000003b0  d4 f8 a3 76 9c 16 03 03  00 4a 78 c0 f2 02 60 a4  |...v.....Jx...`.|
-000003c0  8e 9a cd 31 30 e9 16 df  ce 98 bb 95 50 a0 05 48  |...10.......P..H|
-000003d0  6c c2 ce c5 e2 77 f2 4a  d0 45 80 97 98 d4 38 d1  |l....w.J.E....8.|
-000003e0  90 04 91 48 cb 52 40 d3  a4 cb 8d 68 dc 64 9c 07  |...H.R@....h.d..|
-000003f0  cb 8c b9 3b f8 44 fe 47  69 67 fb 2d ab 44 db d0  |...;.D.Gig.-.D..|
-00000400  58 55 83 81 16 03 03 00  14 51 82 e0 57 8e cb 4a  |XU.......Q..W..J|
-00000410  d4 59 6e 58 f7 6d 44 3f  f5 83 64 52 51           |.YnX.mD?..dRQ|
+00000000  16 03 03 00 81 60 70 d6  32 5a 0a 8f df ed cd f2  |.....`p.2Z......|
+00000010  d7 bf d0 da fd 53 63 65  bf f5 26 83 0c f5 6e e9  |.....Sce..&...n.|
+00000020  78 9b 03 7b 17 5f f4 d2  af 2a a3 85 13 92 be 00  |x..{._...*......|
+00000030  93 3f b3 f1 cb 04 aa 55  f8 ed c8 e6 9c 32 08 79  |.?.....U.....2.y|
+00000040  86 84 ef ac 72 bd 93 07  9c ca d2 e7 74 dd 51 a0  |....r.......t.Q.|
+00000050  6d 0e d3 32 3c 33 9d 58  aa 46 a9 ff 22 08 bc 2c  |m..2<3.X.F.."..,|
+00000060  de 81 aa a8 5a 3c f8 36  93 d3 12 06 79 61 1f 71  |....Z<.6....ya.q|
+00000070  5f 45 d7 99 b2 55 10 22  db 56 d9 39 64 57 ad c3  |_E...U.".V.9dW..|
+00000080  59 a9 bd cb f2 22 16 03  03 02 69 34 e7 f2 7a bc  |Y...."....i4..z.|
+00000090  0b 90 72 a3 3b 6b 38 a3  f8 7a 19 39 ff b4 d6 8c  |..r.;k8..z.9....|
+000000a0  c9 92 4f a3 23 1a f0 89  bb 01 e4 b2 24 f7 db 3d  |..O.#.......$..=|
+000000b0  f4 4b 02 75 d0 ca 3c ed  e8 d9 13 61 c5 61 4e 7c  |.K.u..<....a.aN||
+000000c0  fe b9 49 69 63 cc 23 5f  9b 23 85 ec 86 e5 17 28  |..Iic.#_.#.....(|
+000000d0  8a 1e 0c 45 e5 4d c2 be  66 92 47 88 28 ec 52 eb  |...E.M..f.G.(.R.|
+000000e0  72 e5 30 89 58 8d 15 2b  98 eb cd e2 18 7c 53 f2  |r.0.X..+.....|S.|
+000000f0  89 ba 71 a5 91 20 64 17  7c 56 f1 01 8a 52 17 66  |..q.. d.|V...R.f|
+00000100  ef d7 bc 5b ff 54 53 13  2e 80 53 4c 84 6d a2 20  |...[.TS...SL.m. |
+00000110  0f e6 3d 33 90 7a 5b 1a  50 29 ce 1e af 74 a5 b3  |..=3.z[.P)...t..|
+00000120  0e 29 c8 e5 c1 50 b6 5d  c8 bb e4 b5 f5 6b 04 a8  |.)...P.].....k..|
+00000130  24 a6 a8 cc 77 7c 72 d5  b1 f3 6a 1c 2e d7 7e e0  |$...w|r...j...~.|
+00000140  4c 46 3f 26 61 2e 54 7d  ab d8 d6 ec 1e b0 0d d1  |LF?&a.T}........|
+00000150  02 57 00 7f 29 aa d3 1d  a4 40 73 d7 21 12 76 58  |.W..)....@s.!.vX|
+00000160  7d 79 a5 c1 d2 57 63 48  0e 63 5f 24 49 8a 57 ba  |}y...WcH.c_$I.W.|
+00000170  26 1c 39 4a f8 b3 89 79  e2 be 4e 8e 37 ae 16 75  |&.9J...y..N.7..u|
+00000180  42 5e 2e 9b 14 d5 b3 06  5f b9 c8 f7 16 8f eb 1c  |B^......_.......|
+00000190  48 0a da 1e b3 4a 78 f7  f8 b4 35 bf 7d 3f c5 8d  |H....Jx...5.}?..|
+000001a0  fa 7d c0 b7 52 af d3 13  de 96 39 76 fd 49 80 55  |.}..R.....9v.I.U|
+000001b0  bb b3 0f 5b 0c 84 4d 8b  da 62 8a 20 4b a1 28 28  |...[..M..b. K.((|
+000001c0  3d 74 cc 34 9d 95 8e af  c0 05 a2 5c 73 9d 73 d8  |=t.4.......\s.s.|
+000001d0  6c 4e 77 25 c5 8c 22 07  c6 b9 55 47 0c b2 12 73  |lNw%.."...UG...s|
+000001e0  2e f5 95 f7 28 c3 e4 24  2c fd 05 ac e2 3e df 93  |....(..$,....>..|
+000001f0  5a 28 66 aa d4 86 8a 48  e2 c8 69 01 18 90 54 10  |Z(f....H..i...T.|
+00000200  67 80 a1 be a8 9a 7f f3  17 ee dc 83 06 7a 70 6c  |g............zpl|
+00000210  59 c2 2d 8f ff 79 a7 e5  e2 f2 f3 f3 5b 44 42 25  |Y.-..y......[DB%|
+00000220  a3 8c a0 83 07 5c f6 73  e9 bd f5 6b 86 89 b4 11  |.....\.s...k....|
+00000230  7b 9a 28 52 4f 55 70 4a  75 00 73 cc 84 fa 4a ef  |{.(ROUpJu.s...J.|
+00000240  f8 8a 8d f9 18 e2 bc 13  48 cb 80 4d 6f fc d7 23  |........H..Mo..#|
+00000250  3a 9c 6c fd 46 27 94 8a  3d 9d fb 17 f5 06 4d a1  |:.l.F'..=.....M.|
+00000260  18 75 a7 9b 08 f8 47 b5  52 b4 19 4b b7 0f a4 e0  |.u....G.R..K....|
+00000270  78 f8 8b a4 cc eb d3 85  e1 ad 21 29 0f c7 09 28  |x.........!)...(|
+00000280  3f 21 12 6c fd 76 05 13  10 a0 c1 ce ba 7c e8 6f  |?!.l.v.......|.o|
+00000290  e9 99 67 0a 9d 3a 7f f1  a6 8a 53 56 f1 09 22 21  |..g..:....SV.."!|
+000002a0  24 23 6e bc 77 fc 56 3b  31 15 58 1b e9 03 a1 bf  |$#n.w.V;1.X.....|
+000002b0  0a 06 a0 fb 47 77 b7 ad  01 db ee 6a bc a4 a1 77  |....Gw.....j...w|
+000002c0  6f 3e 70 84 4c a6 21 ec  ff fa f0 f0 68 ee 7d b1  |o>p.L.!.....h.}.|
+000002d0  e6 37 f1 1c aa 43 c7 b9  0e c4 52 7d 54 d8 f7 c5  |.7...C....R}T...|
+000002e0  16 21 99 89 cb 02 d0 54  b8 0e 91 2e 58 25 32 6e  |.!.....T....X%2n|
+000002f0  fa ae 62 c9 16 03 03 00  bc 0c 2f 7e 22 d8 7f 21  |..b......./~"..!|
+00000300  0c 1a ec e1 37 72 3f 03  1d cc 73 f9 63 95 cd 47  |....7r?...s.c..G|
+00000310  66 17 60 8c da b4 35 a2  44 b1 d8 d1 1c 98 5b 8b  |f.`...5.D.....[.|
+00000320  c8 9b c8 cb c4 15 0d 8d  08 1e 7c 3a 6b 20 3a f1  |..........|:k :.|
+00000330  d1 86 ae 08 bb fd 74 c5  62 9a 50 74 07 96 10 0e  |......t.b.Pt....|
+00000340  e0 e4 a4 da c4 9d d1 f4  15 97 7d 21 0f 6f cb 39  |..........}!.o.9|
+00000350  8e 4e 40 1a 2a 7f 15 88  94 52 bc fd 61 b8 37 d1  |.N@.*....R..a.7.|
+00000360  48 62 bc 53 a3 a6 62 ec  0e c3 1f 82 67 19 71 fa  |Hb.S..b.....g.q.|
+00000370  99 16 c3 cf d6 82 44 36  9e 0b f0 41 12 ca 7b 67  |......D6...A..{g|
+00000380  c3 a6 2d f7 13 14 0f d1  16 f9 2a 5a dd 43 45 c6  |..-.......*Z.CE.|
+00000390  c0 f4 17 36 64 11 fc ed  e6 66 b6 0c e2 3d fb 72  |...6d....f...=.r|
+000003a0  93 27 46 20 db 1b 24 f9  69 a0 c7 71 e2 27 6a 93  |.'F ..$.i..q.'j.|
+000003b0  36 73 71 10 bd 16 03 03  00 4a cb 15 91 9c 22 96  |6sq......J....".|
+000003c0  f0 c8 b9 4d 9a 6c b0 eb  1a c5 d4 06 12 89 44 1b  |...M.l........D.|
+000003d0  52 cd fb 32 3f 2c 25 f4  d3 88 0f e4 9c 18 91 59  |R..2?,%........Y|
+000003e0  42 98 a8 65 35 62 f7 ce  fa a3 56 46 c5 b1 da ac  |B..e5b....VF....|
+000003f0  9e 4e de 8d 14 fc 3c f3  94 74 50 99 1d 65 6b a6  |.N....<..tP..ek.|
+00000400  a9 38 93 9f 16 03 03 00  14 d7 5b 68 ca 4c 80 92  |.8........[h.L..|
+00000410  f8 13 5d fe 14 22 6f 9a  42 3a 27 de c8           |..].."o.B:'..|
 >>> Flow 9 (client to server)
-00000000  16 03 03 02 69 96 85 13  d5 b1 07 ec bb 1c c1 be  |....i...........|
-00000010  a3 42 10 c8 e0 ec f8 f1  67 29 d5 52 ef bb 32 e8  |.B......g).R..2.|
-00000020  7b e5 a7 3f ab 71 2d 74  20 f7 8a a7 1f bf 7c 4b  |{..?.q-t .....|K|
-00000030  8b 95 db 07 3c ad 86 5e  b3 98 32 e9 5a ce 96 08  |....<..^..2.Z...|
-00000040  c5 64 44 27 fb bc 44 29  49 44 32 3f 64 e8 86 1b  |.dD'..D)ID2?d...|
-00000050  54 63 74 3d a1 99 4d 4a  3e 5a 76 71 39 81 de df  |Tct=..MJ>Zvq9...|
-00000060  90 e4 f6 ac 96 15 0b 70  ad 7e 8a 1d 69 86 65 6e  |.......p.~..i.en|
-00000070  63 bf fb f2 6f 21 d5 66  ad f1 b1 09 05 04 f9 09  |c...o!.f........|
-00000080  0e 0c 12 74 c1 cd f1 5e  fa f1 1b cd 3b 2b 13 8f  |...t...^....;+..|
-00000090  fb f6 fd b0 ca ea 73 1b  38 ad db 6b fd 29 34 db  |......s.8..k.)4.|
-000000a0  51 4a 44 97 a7 2f 2a 98  d6 cc d5 c4 b9 17 23 ab  |QJD../*.......#.|
-000000b0  09 27 15 a5 35 3b 2b 7e  b2 3b fd 12 1b 11 90 4d  |.'..5;+~.;.....M|
-000000c0  81 1b 84 bb fd 72 09 31  5e 78 0e f6 b6 60 44 bb  |.....r.1^x...`D.|
-000000d0  6c 06 72 0b ba ba 60 f6  c1 cb 7e 45 a9 25 44 3d  |l.r...`...~E.%D=|
-000000e0  ba da 71 99 bb 79 b3 73  ef eb c2 cc 07 87 76 f5  |..q..y.s......v.|
-000000f0  e9 7c d9 47 8c fc 7d b7  a0 70 72 04 1e 3d 9b 2f  |.|.G..}..pr..=./|
-00000100  85 9f c8 2f d9 20 4e 00  97 d6 dd dc ae a1 04 96  |.../. N.........|
-00000110  83 e1 4f f3 0d ad 9c ce  5f e7 7b 88 7a b7 d2 ce  |..O....._.{.z...|
-00000120  0a 61 95 d2 78 e3 45 a8  10 5e d9 ae d2 e1 22 bf  |.a..x.E..^....".|
-00000130  59 9c 4a 2c 28 fb c1 b6  89 3b 65 8c 94 a9 f0 7c  |Y.J,(....;e....||
-00000140  86 98 8f 22 c4 18 47 e4  f0 b9 42 dd 34 ab 2a 8e  |..."..G...B.4.*.|
-00000150  fc 8f ce 09 ec 6f 57 6b  d1 ab 32 fd 84 e2 9f 7e  |.....oWk..2....~|
-00000160  f5 b7 5d 26 aa 37 da e9  f3 18 6f 56 74 03 ff 1e  |..]&.7....oVt...|
-00000170  87 95 fb 93 57 2e 32 fb  b3 cf d2 0d 42 02 4f 6a  |....W.2.....B.Oj|
-00000180  9e de ee 6a e6 7e e5 d2  ba cb 00 5d ff b4 6d 7f  |...j.~.....]..m.|
-00000190  23 5e 93 be e9 3a c1 b4  78 30 53 90 07 e4 a7 af  |#^...:..x0S.....|
-000001a0  da e1 29 7d 50 a5 76 ec  a8 5e 96 50 45 26 c4 9d  |..)}P.v..^.PE&..|
-000001b0  c1 99 98 c6 1a bf 93 c1  63 b3 0a 2d af c8 29 7d  |........c..-..)}|
-000001c0  ef b2 d3 8f aa 93 fb be  39 c0 a1 65 51 e8 6e c4  |........9..eQ.n.|
-000001d0  45 cb 2a 52 b7 ec e0 48  c0 b2 cc c7 72 12 18 e0  |E.*R...H....r...|
-000001e0  c7 9f fa 09 97 95 16 9f  f4 5d 70 c5 d6 7f 23 d5  |.........]p...#.|
-000001f0  53 98 d0 80 50 9b 52 46  11 d4 97 ea 47 26 f5 6f  |S...P.RF....G&.o|
-00000200  66 7b 8a cc f8 8d 70 c7  ec fa 72 de ba ac d4 b2  |f{....p...r.....|
-00000210  be 7d d8 78 44 dd de 66  53 26 f4 c0 8a 67 61 cb  |.}.xD..fS&...ga.|
-00000220  46 34 3d 6f 9e 9b dc ee  4a b9 5c 67 2b d9 87 2a  |F4=o....J.\g+..*|
-00000230  35 42 1c 3e b8 08 c9 32  13 a6 6f fc 4d cc be dd  |5B.>...2..o.M...|
-00000240  ad 76 19 1c 2d b3 6e 04  a1 17 05 93 b9 69 27 42  |.v..-.n......i'B|
-00000250  23 13 7b c0 f1 53 9c b5  1d 8e 5c f6 40 7e 5a e9  |#.{..S....\.@~Z.|
-00000260  20 dd 18 7a 0c f2 7b 5a  ec 3d 4e 3b 29 b2 16 03  | ..z..{Z.=N;)...|
-00000270  03 00 35 15 15 54 38 4e  87 f1 c1 9a 90 b2 74 df  |..5..T8N......t.|
-00000280  72 34 aa 0b 41 f3 df b4  c5 fd 50 00 2a 36 a8 d5  |r4..A.....P.*6..|
-00000290  c4 49 ac b8 58 3e 89 48  cb a9 4e b1 a9 0f ee 51  |.I..X>.H..N....Q|
-000002a0  37 d3 60 ca 23 76 68 0b  16 03 03 00 98 53 3c 0e  |7.`.#vh......S<.|
-000002b0  d5 3b d3 78 9f 47 5d 9e  1b b6 04 5f d4 04 66 55  |.;.x.G]...._..fU|
-000002c0  68 bd d7 ab 54 b7 e5 9a  12 9b 0c 1d 75 7b c7 35  |h...T.......u{.5|
-000002d0  e3 9e 9d a0 8f 61 7a 32  d1 a7 23 2a b6 ba 48 7c  |.....az2..#*..H||
-000002e0  1a 62 66 61 b4 3d e8 e3  a9 4e 85 7a 8d 5b f3 69  |.bfa.=...N.z.[.i|
-000002f0  c8 bc 0a 8a c7 e4 df 78  9b a8 cf 1d 37 14 90 a5  |.......x....7...|
-00000300  a8 ce f7 1f e7 a3 e5 d8  97 be 95 fd d3 c0 d0 81  |................|
-00000310  bf a6 e1 b3 6b 29 ee c6  16 3c 4c 68 6e b4 42 72  |....k)...<Lhn.Br|
-00000320  84 a0 97 0f 0e b2 44 0c  4f c6 df 04 b7 bf d8 e7  |......D.O.......|
-00000330  08 af 33 35 56 ed 6b cc  42 a8 9f 8e 59 9c 9c 32  |..35V.k.B...Y..2|
-00000340  29 77 87 6e d6 14 03 03  00 11 97 7a db d1 50 96  |)w.n.......z..P.|
-00000350  68 b7 04 90 79 fd f3 79  ed f3 de 16 03 03 00 20  |h...y..y....... |
-00000360  16 57 80 e9 30 65 46 29  74 09 32 70 13 1f f8 5d  |.W..0eF)t.2p...]|
-00000370  54 3f 14 4b af a1 51 b3  cd 1f e6 01 d6 68 11 fc  |T?.K..Q......h..|
+00000000  16 03 03 02 69 aa 39 9e  c8 e7 89 97 7f 22 3c 28  |....i.9......"<(|
+00000010  76 ac d9 48 51 e0 cd 22  53 a1 6d e7 b4 00 27 7d  |v..HQ.."S.m...'}|
+00000020  89 4b f0 54 d8 39 d0 a3  fc 35 a6 36 4b 3c eb 3a  |.K.T.9...5.6K<.:|
+00000030  00 b0 c1 17 9d c8 13 a5  58 ba 16 9e cb 21 50 dd  |........X....!P.|
+00000040  8a e0 2d 57 dd a6 bf 4d  6e b3 21 3b 46 f4 c3 77  |..-W...Mn.!;F..w|
+00000050  a1 86 07 c7 db e9 0a cb  2d 0f ff b5 1b ad 6b c4  |........-.....k.|
+00000060  c4 a4 4e 14 cf cb b2 6c  07 65 17 d2 db 30 e9 ec  |..N....l.e...0..|
+00000070  41 4e 78 26 12 27 08 a6  a7 84 39 c0 4b e7 4b 23  |ANx&.'....9.K.K#|
+00000080  2f ca ff 1e 41 9a e8 44  fc 5d a0 34 4e ca a8 6d  |/...A..D.].4N..m|
+00000090  31 51 57 c9 7e d1 0a 42  22 f2 b4 f9 a7 f9 28 d8  |1QW.~..B".....(.|
+000000a0  2a dd 19 0d 90 8b e1 78  b1 1c da 3a bb 5e 05 54  |*......x...:.^.T|
+000000b0  0d 0e f8 73 ed 01 e2 e4  d4 c1 f8 fa c3 d6 6f 42  |...s..........oB|
+000000c0  cc cb 99 99 97 18 b0 fb  ab 51 42 66 45 67 b6 29  |.........QBfEg.)|
+000000d0  02 60 ab 74 30 db f6 16  8a 8f 8e 9c cc d5 47 fa  |.`.t0.........G.|
+000000e0  f5 af 94 4f b1 94 40 57  ab 85 59 e4 3e cc c5 a0  |...O..@W..Y.>...|
+000000f0  61 b7 64 f9 dc 96 40 ae  fb 4c 57 39 9e 9a 23 8e  |a.d...@..LW9..#.|
+00000100  c9 36 6c 75 11 c7 6e 54  c3 1c e9 25 6a a0 f8 bb  |.6lu..nT...%j...|
+00000110  6b 5c ca 5c 06 6c 03 88  01 27 4c 89 02 e6 b6 1a  |k\.\.l...'L.....|
+00000120  92 99 4d 15 c1 1a aa 58  20 49 d7 4a f9 09 34 1e  |..M....X I.J..4.|
+00000130  d7 d8 31 79 9f d8 b3 a0  76 ba 96 77 77 77 5b 80  |..1y....v..www[.|
+00000140  88 ab a0 90 c7 5f 3d 82  e1 23 29 6e 3a 4d 9b f0  |....._=..#)n:M..|
+00000150  7b 6a b1 9d 78 ba 4c 7e  02 1f a0 73 3e 91 cf 75  |{j..x.L~...s>..u|
+00000160  c6 52 2d c6 79 be 85 65  0e e4 73 39 fe 53 6d e0  |.R-.y..e..s9.Sm.|
+00000170  a3 18 d5 69 80 ca f1 c8  ad f5 f4 fb b5 40 2e f8  |...i.........@..|
+00000180  30 82 ca 2c 46 6a ab a6  b2 83 9f a8 95 95 30 e3  |0..,Fj........0.|
+00000190  e3 30 6d f5 7c 83 96 af  12 d8 d6 d6 f9 6a ad bd  |.0m.|........j..|
+000001a0  bb 96 83 99 99 d8 6d 20  0e e1 be da 58 05 44 88  |......m ....X.D.|
+000001b0  a6 07 47 84 d4 77 fc 9b  fb d7 ac 60 70 0b e7 76  |..G..w.....`p..v|
+000001c0  13 c7 38 d9 3d 60 eb a6  9f a5 6d fc 5c d5 f6 2f  |..8.=`....m.\../|
+000001d0  31 02 38 65 8d be 04 06  84 95 86 b1 84 d9 ce c7  |1.8e............|
+000001e0  30 b9 d3 85 9f 1b 12 0f  5c 0e d6 8d e3 a0 15 04  |0.......\.......|
+000001f0  03 62 9d 52 7b e7 f4 13  aa 02 64 d9 d4 4b fd 6f  |.b.R{.....d..K.o|
+00000200  de ea 4a aa 91 60 e7 78  af 84 b5 9d c3 d2 c6 3a  |..J..`.x.......:|
+00000210  2a 9f 9b c6 8d 9e 5e 2c  90 6c d3 9d c1 be 96 5a  |*.....^,.l.....Z|
+00000220  60 d8 73 6c 49 50 c8 03  ec 58 73 bc b3 8c 30 c1  |`.slIP...Xs...0.|
+00000230  f4 a2 7d 74 3d 8d 7e 64  c1 a7 b6 24 13 06 72 1b  |..}t=.~d...$..r.|
+00000240  d0 87 22 af df 2a e7 fe  57 fa db e7 00 ba 74 35  |.."..*..W.....t5|
+00000250  16 34 20 3f 75 69 35 5f  64 7e 26 56 7c 93 05 4e  |.4 ?ui5_d~&V|..N|
+00000260  42 65 b8 bf 59 8e 82 13  f1 d0 05 95 c2 3d 16 03  |Be..Y........=..|
+00000270  03 00 35 99 1d 52 84 73  d6 e7 90 f6 41 9e 69 07  |..5..R.s....A.i.|
+00000280  39 0b bc b6 c7 f4 f2 a0  93 80 b9 c7 bb b4 a6 06  |9...............|
+00000290  50 5b 5d 75 97 cf c5 dc  2d 07 3d 8f 9e ae fa bf  |P[]u....-.=.....|
+000002a0  5b 6b 3e 98 02 fd e4 7d  16 03 03 00 98 80 ac e9  |[k>....}........|
+000002b0  4e e0 f8 b5 8c c2 2e 84  ec e0 3b eb b7 a0 14 2d  |N.........;....-|
+000002c0  ff d2 bf 35 14 20 06 00  2e 48 c7 f8 a3 fd 4f 50  |...5. ...H....OP|
+000002d0  4a 04 3e c7 07 50 90 72  29 f0 5c ac e1 fd 9d 3f  |J.>..P.r).\....?|
+000002e0  42 99 77 32 a9 79 24 7f  9e cc 84 1c d0 db 87 1c  |B.w2.y$.........|
+000002f0  3c 9a ae e3 45 e5 67 83  5f 75 e9 27 f3 ef 8a 15  |<...E.g._u.'....|
+00000300  88 2b 3f cc 6f 6f a4 78  d5 b2 96 3e 72 d4 c8 43  |.+?.oo.x...>r..C|
+00000310  98 a7 60 ae 38 8e fe 21  49 5b c2 80 d6 ef 6f 9b  |..`.8..!I[....o.|
+00000320  08 18 07 c2 64 00 a1 a0  09 8b b4 b7 eb 0c 68 30  |....d.........h0|
+00000330  26 87 f9 99 85 63 35 81  5a e4 31 19 9e f8 b8 7b  |&....c5.Z.1....{|
+00000340  81 aa 24 ff cd 14 03 03  00 11 84 c7 e1 8f 74 66  |..$...........tf|
+00000350  e6 bd 14 55 a8 d3 67 30  2d c4 fb 16 03 03 00 20  |...U..g0-...... |
+00000360  3a 63 a5 86 f3 78 f1 62  18 77 f7 25 71 52 56 17  |:c...x.b.w.%qRV.|
+00000370  d2 a5 e4 fa bc bb 44 07  85 37 cb 36 84 c7 6a 97  |......D..7.6..j.|
 >>> Flow 10 (server to client)
-00000000  14 03 03 00 11 1b a8 a8  a9 c6 a8 85 60 bc 14 0d  |............`...|
-00000010  86 ce a5 0f 45 17 16 03  03 00 20 cb 3a 73 db 55  |....E..... .:s.U|
-00000020  05 7e 3e 4b 6d d0 eb ca  68 39 bf 71 ba 6c e5 0c  |.~>Km...h9.q.l..|
-00000030  a7 90 d6 c1 b8 55 87 c6  20 40 35 17 03 03 00 19  |.....U.. @5.....|
-00000040  28 50 71 7c f0 7c 1e 61  fb de 5d d1 bb 77 f6 c8  |(Pq|.|.a..]..w..|
-00000050  a4 76 8d ab d4 c2 fe 27  96 16 03 03 00 14 e4 7e  |.v.....'.......~|
-00000060  51 bb 26 a8 9c 0c b0 25  7a 57 b9 98 c2 20 5a 50  |Q.&....%zW... ZP|
-00000070  07 ca                                             |..|
+00000000  14 03 03 00 11 9e 99 89  2d 10 21 a1 38 04 77 1a  |........-.!.8.w.|
+00000010  f8 1d b4 01 d1 9f 16 03  03 00 20 2a cb 67 8b 1b  |.......... *.g..|
+00000020  44 26 41 7b c4 6d a1 f4  cb ee 15 87 01 65 18 5a  |D&A{.m.......e.Z|
+00000030  c7 2d 10 e4 91 01 cb 22  e8 92 1a 17 03 03 00 19  |.-....."........|
+00000040  1a 46 a0 9a c5 1a 27 0c  e2 f9 03 55 3a e8 43 a7  |.F....'....U:.C.|
+00000050  d7 47 a5 95 6a e7 a1 12  69 16 03 03 00 14 d6 e0  |.G..j...i.......|
+00000060  1d 89 e0 c2 9a 52 d5 bc  d4 08 3e f6 81 dd 57 a2  |.....R....>...W.|
+00000070  25 f6                                             |%.|
 >>> Flow 11 (client to server)
-00000000  16 03 03 01 16 66 3c 1a  62 c3 4a f9 e4 66 01 d4  |.....f<.b.J..f..|
-00000010  f7 e8 5a fb 95 c4 40 33  d4 af 61 78 d6 54 91 2b  |..Z...@3..ax.T.+|
-00000020  62 72 d5 7b b8 2c 71 11  4e 0c 2d 79 6d 41 b1 9e  |br.{.,q.N.-ymA..|
-00000030  df 59 d8 e0 5c 72 98 b5  29 55 1e 9b 01 a5 af 2c  |.Y..\r..)U.....,|
-00000040  c3 87 4b f0 c8 ca 4d 56  fb 3a 7e 04 e5 b6 4f 6d  |..K...MV.:~...Om|
-00000050  1e 53 26 5d af fb 17 ee  97 87 45 2f df 1b 21 80  |.S&]......E/..!.|
-00000060  21 81 2b 18 2d 2d e9 3c  c4 01 32 91 b7 88 27 9e  |!.+.--.<..2...'.|
-00000070  26 40 e7 6a 27 c5 a0 b4  a3 ed 4d 4b a4 e3 0b c7  |&@.j'.....MK....|
-00000080  49 42 ca ef e9 16 5c 98  8d ab fc 7d 00 83 03 89  |IB....\....}....|
-00000090  a4 97 1e 3f 9e d8 ba c5  f5 2a 0b 0a ed a0 a5 59  |...?.....*.....Y|
-000000a0  27 03 36 7e 94 d8 9a 3c  fc f6 f6 52 b6 a7 fa 36  |'.6~...<...R...6|
-000000b0  04 83 2f e7 99 e5 1c 56  27 48 13 a0 59 ca ca 3b  |../....V'H..Y..;|
-000000c0  36 2d 25 e8 6f 6a cb 07  74 f8 1b 7d ba 3e 6e e1  |6-%.oj..t..}.>n.|
-000000d0  1d 3e 93 c6 23 f4 eb bf  ad 62 21 1a da 53 e1 13  |.>..#....b!..S..|
-000000e0  0a 3a 9c 57 48 d5 ee d3  72 af c3 74 fc 74 67 7d  |.:.WH...r..t.tg}|
-000000f0  b4 76 fc 21 55 67 49 92  fc 71 5d 42 69 d6 01 b5  |.v.!UgI..q]Bi...|
-00000100  83 4e b8 cd f9 ed 28 41  ae 95 2f d6 69 b0 d3 b8  |.N....(A../.i...|
-00000110  bd 06 d6 00 74 44 c9 47  aa 8e 1d                 |....tD.G...|
+00000000  16 03 03 01 16 27 50 ce  c0 8e 5a e2 54 55 cb c0  |.....'P...Z.TU..|
+00000010  08 c7 20 87 7e 78 c6 da  a6 7a 62 fd 7f f5 87 b3  |.. .~x...zb.....|
+00000020  83 a0 c8 70 ab 57 9b ca  bf 4c 07 06 f1 89 b9 b6  |...p.W...L......|
+00000030  24 f0 ae 72 e1 36 31 9f  74 ed 06 ad 44 3b 51 2c  |$..r.61.t...D;Q,|
+00000040  ed f0 c2 d8 9b 27 d2 9a  ec 44 88 80 7c 5a d0 66  |.....'...D..|Z.f|
+00000050  3d 84 e3 7c 24 89 b9 dd  8c eb 86 cd ce 69 0d e3  |=..|$........i..|
+00000060  97 ee ad 74 53 7f 9c f0  05 31 43 2a 8c 09 c4 11  |...tS....1C*....|
+00000070  46 3e 82 2c 3c 69 91 d1  eb 4b 8a ab a9 cb 24 00  |F>.,<i...K....$.|
+00000080  00 25 bd 26 d3 85 19 ff  3b 2b 92 3f 43 b0 9f 24  |.%.&....;+.?C..$|
+00000090  59 4f 3d a6 ce 65 27 5c  75 47 92 7b 4a d3 ca 55  |YO=..e'\uG.{J..U|
+000000a0  38 00 ac 37 0c 6e 2d 04  bc 6e fe 3a 9a 43 b6 7f  |8..7.n-..n.:.C..|
+000000b0  18 c1 a6 ce 49 b4 61 d3  97 8d a2 c9 fb fb cd 23  |....I.a........#|
+000000c0  f6 2f 0c 0b 2a b8 31 9e  fd ff 9f 44 1e 33 c3 23  |./..*.1....D.3.#|
+000000d0  bf 09 d2 de 90 b6 61 9c  33 33 33 46 bc 00 7e 16  |......a.333F..~.|
+000000e0  3c bd 82 2d 31 51 5b 11  87 ec 7f 25 d8 95 f9 9c  |<..-1Q[....%....|
+000000f0  df 00 54 40 f3 c1 08 fa  ef ba bc 5d b1 96 ae 8f  |..T@.......]....|
+00000100  35 0e 43 b2 50 c7 7e c4  b2 71 2e 40 3a b7 90 2b  |5.C.P.~..q.@:..+|
+00000110  81 ac 00 14 9d da d8 ca  5e 25 62                 |........^%b|
 >>> Flow 12 (server to client)
-00000000  16 03 03 00 81 d3 99 6f  14 2b a1 f4 d7 45 c9 94  |.......o.+...E..|
-00000010  69 0b b3 72 f4 2c 2e 5c  80 96 09 20 2f 63 a1 e4  |i..r.,.\... /c..|
-00000020  8b df d7 22 11 71 bd 17  db da 2d c6 78 e8 9a 95  |...".q....-.x...|
-00000030  6b 39 34 a2 13 7f 39 77  8b e5 1b 6c 4b 20 79 40  |k94...9w...lK y@|
-00000040  a1 d9 69 89 b1 e2 60 8a  75 88 ae 83 b9 4f 42 a4  |..i...`.u....OB.|
-00000050  c9 c7 44 ac 0d 3f 1c ca  49 f9 a7 05 e2 c7 05 cd  |..D..?..I.......|
-00000060  30 30 d2 f9 c2 87 60 33  3b 25 d0 e0 5e c2 bd 98  |00....`3;%..^...|
-00000070  9c 51 d8 38 c9 ef 04 f4  39 30 50 b6 35 53 f6 95  |.Q.8....90P.5S..|
-00000080  eb 5d 67 05 62 9a 16 03  03 02 69 39 94 a1 8d 01  |.]g.b.....i9....|
-00000090  37 64 c6 be bb 9c 22 9d  56 e8 68 ab 0f 7a 3a e7  |7d....".V.h..z:.|
-000000a0  2d 26 b7 ba 3e 54 38 b3  32 9d 7b d7 43 c4 d2 b3  |-&..>T8.2.{.C...|
-000000b0  9a 84 62 73 03 7a f2 68  ec 3e 41 d2 68 c9 22 1a  |..bs.z.h.>A.h.".|
-000000c0  e9 4d 9c e8 80 6a a9 9e  6a bd 67 5d 77 97 8b f7  |.M...j..j.g]w...|
-000000d0  32 cb 3a cb c2 c0 a1 40  7e 63 81 5f 19 a5 71 20  |2.:....@~c._..q |
-000000e0  c3 76 88 ae 5c d4 bd 54  08 e7 7e e7 77 7e 3d 91  |.v..\..T..~.w~=.|
-000000f0  b5 40 f7 7e 95 d5 e3 f2  e5 4a 57 f6 d9 94 df 07  |.@.~.....JW.....|
-00000100  56 45 09 c4 bc 65 05 04  57 f4 00 c5 91 4c dc 4d  |VE...e..W....L.M|
-00000110  a0 1e c6 e2 37 35 d0 5a  e9 79 ce f5 91 6d 3e 39  |....75.Z.y...m>9|
-00000120  c3 68 6a 76 6d f3 29 1d  e0 ef b2 20 3e 2a ac 11  |.hjvm.).... >*..|
-00000130  7e 11 2d a3 84 60 94 b5  8e 3a e6 4b 34 70 aa f8  |~.-..`...:.K4p..|
-00000140  e3 f9 0f 2c a4 bf 5b 27  7e c9 5e 6f c0 11 b4 ff  |...,..['~.^o....|
-00000150  53 6b 98 ee 20 77 87 87  fc 8e 30 1b 8f 74 29 af  |Sk.. w....0..t).|
-00000160  a2 c7 e8 c1 da e5 d7 0f  70 ec 27 23 46 3f 16 b1  |........p.'#F?..|
-00000170  59 bd 43 76 09 1d 8c f4  eb 17 10 a5 c1 1a e0 c6  |Y.Cv............|
-00000180  45 e2 d2 dc 6d f4 9a 87  36 ef 71 18 5c 1d e7 7c  |E...m...6.q.\..||
-00000190  40 d6 4c 16 ee 58 75 d7  56 9f 2e 17 80 1d 74 1c  |@.L..Xu.V.....t.|
-000001a0  fd 86 7c 2b 05 ac ef 07  18 a3 98 73 fa 9c 16 6c  |..|+.......s...l|
-000001b0  14 95 37 91 1e a2 c7 47  a8 87 11 35 30 d8 ed 60  |..7....G...50..`|
-000001c0  ba 65 ee 66 2b 1f db 67  c2 d0 71 26 3d ae 17 94  |.e.f+..g..q&=...|
-000001d0  f0 f6 65 01 bb 1d 85 7e  b3 d8 2c f1 96 c5 d5 e0  |..e....~..,.....|
-000001e0  97 a4 3e df 97 ff 8f 4b  e3 72 49 c4 5b 87 4e 06  |..>....K.rI.[.N.|
-000001f0  93 11 75 04 7b 80 9d 1c  a7 85 a3 2c f1 16 8a b9  |..u.{......,....|
-00000200  78 6b 27 1e 9a e3 86 eb  f9 42 95 10 02 d5 b6 01  |xk'......B......|
-00000210  b3 94 04 63 49 50 9e 11  71 07 aa a1 d6 9d d1 db  |...cIP..q.......|
-00000220  f4 ea 2e bb fa ca 1e 00  53 75 70 de 0a 72 eb 55  |........Sup..r.U|
-00000230  ab b7 ff 30 ad 5e 7e 13  90 75 42 5d 07 07 21 0f  |...0.^~..uB]..!.|
-00000240  db a6 f4 61 9c bf 31 34  e4 98 bb c4 ac 41 2d 76  |...a..14.....A-v|
-00000250  fb 6c 30 b0 e2 98 5f ed  d9 a8 42 d7 75 a1 bc 36  |.l0..._...B.u..6|
-00000260  f2 3e c5 ac 50 ae c7 2e  42 35 6c 1a 47 aa 1f 0a  |.>..P...B5l.G...|
-00000270  2f ff 6e 0a a5 c4 b5 a5  92 3f 54 d0 4e 62 6e 3e  |/.n......?T.Nbn>|
-00000280  cb 07 2d 4d 1a fb 94 5b  f8 d0 5b 26 34 2b 1b 26  |..-M...[..[&4+.&|
-00000290  8c dd 91 a7 66 21 89 d0  11 24 a5 5f 99 ae 62 84  |....f!...$._..b.|
-000002a0  34 9c d2 45 71 74 8c 68  db 8b ad 6f df 08 35 38  |4..Eqt.h...o..58|
-000002b0  ed 5c 3b 3e 55 a1 c3 16  b6 61 f4 4d 6d d0 2a 5d  |.\;>U....a.Mm.*]|
-000002c0  10 fb 64 c9 6f 87 6f 3d  ff d1 a0 97 64 b4 12 f9  |..d.o.o=....d...|
-000002d0  2a a8 46 59 1b e4 6b d8  c9 3e ac 14 00 4f 1a e6  |*.FY..k..>...O..|
-000002e0  26 9b 86 32 a3 9b 37 eb  c1 cf 9a 70 16 2e 4a b0  |&..2..7....p..J.|
-000002f0  6e e5 fc c2 16 03 03 00  bc bf c4 ea e0 dc be fe  |n...............|
-00000300  33 7f ef 2b d9 50 f7 87  d5 30 2b 09 bb 63 1e 4c  |3..+.P...0+..c.L|
-00000310  9c 3c a9 10 4e 04 e1 85  29 44 f9 ea 32 61 12 6e  |.<..N...)D..2a.n|
-00000320  63 0f d9 e7 e9 c8 81 a0  eb 4e fe 90 bf f4 f4 af  |c........N......|
-00000330  22 66 21 86 dc 2c f6 ed  b1 be eb b1 ac 14 f5 ce  |"f!..,..........|
-00000340  6c b9 a8 45 e4 3f 09 d1  b1 f3 69 f7 df c4 f0 6c  |l..E.?....i....l|
-00000350  48 f6 15 80 8a b8 b0 39  0e e9 22 9a 5c 72 f9 fa  |H......9..".\r..|
-00000360  95 01 9d ca e4 68 ef 72  e2 34 28 a5 04 5d d2 30  |.....h.r.4(..].0|
-00000370  c6 33 80 a8 f1 8f fb 6c  ec 15 c3 7c 68 7c a2 2e  |.3.....l...|h|..|
-00000380  4d ba 64 af fb f5 b8 f7  6b 6b 8c 5c 56 dc dd 69  |M.d.....kk.\V..i|
-00000390  39 d8 73 75 e3 be 17 09  3f 80 ed cc 12 5b ca d9  |9.su....?....[..|
-000003a0  e6 e2 50 88 41 0b 39 8e  84 6f fb 6a c3 8e 4f fc  |..P.A.9..o.j..O.|
-000003b0  dc 18 ca 02 18 16 03 03  00 14 5e ac 52 4d 0b 89  |..........^.RM..|
-000003c0  33 7d fe 1c d9 b5 1d 1c  2b 6d d4 4f 12 33        |3}......+m.O.3|
+00000000  16 03 03 00 81 37 3a f4  1b 6a 43 d2 6a 02 02 33  |.....7:..jC.j..3|
+00000010  b9 d5 9a 5c d1 3b 52 73  f2 27 a6 c0 f0 9b dd f3  |...\.;Rs.'......|
+00000020  d7 cd 89 ec 21 e0 d3 2f  4d 6c b0 cf 50 a7 39 43  |....!../Ml..P.9C|
+00000030  c2 56 d2 f8 45 d7 3c a6  b6 b9 06 3f ca a7 f8 37  |.V..E.<....?...7|
+00000040  4c 89 01 49 82 5f 27 15  3c bf f0 86 7c 1a 84 03  |L..I._'.<...|...|
+00000050  5a 90 77 03 01 fd b8 60  2a be cc 60 c6 54 b5 ec  |Z.w....`*..`.T..|
+00000060  c1 5d 6b e6 f0 2c 8c e6  7e e3 b6 c3 8b 63 3c 69  |.]k..,..~....c<i|
+00000070  ac 2c 9a 24 a7 77 5f 0c  36 08 68 6c 8b 76 f1 80  |.,.$.w_.6.hl.v..|
+00000080  4a bf f7 e6 15 5b 16 03  03 02 69 a1 ce a6 de 44  |J....[....i....D|
+00000090  cf d6 f7 88 f4 da 01 06  2b e5 cf 54 8d f6 78 ab  |........+..T..x.|
+000000a0  53 c5 ea d9 97 4b 94 22  24 9b 98 ba ba ee 42 9d  |S....K."$.....B.|
+000000b0  c3 e4 12 e3 be 35 24 86  3d 38 a0 6e b7 e6 cf dc  |.....5$.=8.n....|
+000000c0  e7 5c e1 0d 7c 05 bb 63  7c 8b c4 a4 db 9a 85 a4  |.\..|..c|.......|
+000000d0  ba d6 d4 79 38 79 01 52  2d cf c1 c7 6e 09 64 ff  |...y8y.R-...n.d.|
+000000e0  e9 b6 3e f2 a0 2b 4c 91  3f e2 fe 1a 40 4b 14 ea  |..>..+L.?...@K..|
+000000f0  77 8f 40 1c a2 96 7c d3  ce 34 5e d8 13 5a 82 33  |w.@...|..4^..Z.3|
+00000100  41 59 fa d9 81 1c 85 41  9c 61 b9 ca d5 46 e2 77  |AY.....A.a...F.w|
+00000110  3d a9 50 4f 11 b1 34 aa  ae fd e5 ec fe 12 e6 10  |=.PO..4.........|
+00000120  36 84 fb 25 f8 a4 6f 44  e3 ac 89 67 e4 9a 02 c4  |6..%..oD...g....|
+00000130  8f a9 4a d0 f4 64 e2 de  da 80 02 60 cb a9 2d e0  |..J..d.....`..-.|
+00000140  fa d9 b9 ee 43 e1 3e ed  79 79 6b 21 62 3d 6f b0  |....C.>.yyk!b=o.|
+00000150  77 53 db 26 60 e1 d6 ff  a7 01 2b b7 f0 49 df b8  |wS.&`.....+..I..|
+00000160  bc d9 ac 77 80 f8 53 66  16 8d 3a 8d 63 fa 12 e1  |...w..Sf..:.c...|
+00000170  ed f7 8b c0 40 46 16 70  e3 db f3 38 87 9f 11 eb  |....@F.p...8....|
+00000180  0b f5 b3 44 e4 16 e1 ed  85 e6 67 d5 35 60 20 99  |...D......g.5` .|
+00000190  7d bd 9f 65 b9 52 68 6c  6b 83 f9 06 e3 a7 3e 0f  |}..e.Rhlk.....>.|
+000001a0  9e 7c a5 ac 87 7a 45 53  a5 3f 27 5b 99 a9 34 c2  |.|...zES.?'[..4.|
+000001b0  5a 44 9a 30 08 30 c6 ff  60 8a a5 72 f7 49 d3 7c  |ZD.0.0..`..r.I.||
+000001c0  1f f9 8b 74 a0 b1 c8 65  84 6d 91 86 ab 1e 82 3b  |...t...e.m.....;|
+000001d0  d5 c4 bb 06 b3 31 61 bb  0e 65 3e 18 4d 0c c1 c1  |.....1a..e>.M...|
+000001e0  9d 7f ea ad cf 53 2e 9c  1c 7e aa c8 84 9e 0d ce  |.....S...~......|
+000001f0  91 53 3c d4 05 7e 57 d1  8b 55 ea e4 6e 57 90 4c  |.S<..~W..U..nW.L|
+00000200  bb 74 9c 87 1c 6a 89 cf  2c 50 8d 04 04 e6 18 c8  |.t...j..,P......|
+00000210  0c 9f 38 84 f4 f4 94 8d  33 2b a1 27 0b 5c 6a 2a  |..8.....3+.'.\j*|
+00000220  0c 13 b7 07 b7 a0 c9 e5  3c 9d 5a 7e 96 c9 53 fc  |........<.Z~..S.|
+00000230  ff c4 3a 8f 16 1f 2d 64  50 1d 13 c3 55 fb af d2  |..:...-dP...U...|
+00000240  0e f9 e6 18 e3 62 ce 6a  8f 96 ff 00 0e fe 27 53  |.....b.j......'S|
+00000250  70 57 53 2d fd f3 02 c7  fe b3 19 49 88 27 7e a2  |pWS-.......I.'~.|
+00000260  42 7b 22 d0 77 4e e5 04  aa 0d b6 9d b9 48 97 ab  |B{".wN.......H..|
+00000270  33 e7 14 97 65 82 f9 2c  dc 71 9e 4b eb ed 42 73  |3...e..,.q.K..Bs|
+00000280  c6 c8 93 8a 3a 24 bd f9  b4 6a 95 c1 1b 22 1d f5  |....:$...j..."..|
+00000290  c8 33 c5 38 1e a7 2e 91  68 35 4c 0a 37 57 ac e2  |.3.8....h5L.7W..|
+000002a0  c9 37 9e d9 1c b8 76 73  c2 d2 0c d0 c4 a1 c0 d5  |.7....vs........|
+000002b0  72 39 bf 03 f7 8d db e0  8f fe e2 d6 d0 d4 cc bb  |r9..............|
+000002c0  7d 78 c6 c5 13 a8 4e 45  1e 66 60 77 fe 26 4d 18  |}x....NE.f`w.&M.|
+000002d0  90 e8 e1 0c 5b 2b 25 9b  ee 6d 76 3f f6 23 a2 26  |....[+%..mv?.#.&|
+000002e0  52 8d a9 4e 7f ed 8e e2  6d 7c b4 eb 25 46 54 27  |R..N....m|..%FT'|
+000002f0  e2 2d 2c 59 16 03 03 00  bc 6e c1 fb 66 55 ca ea  |.-,Y.....n..fU..|
+00000300  56 62 78 2f fd c4 ff da  78 dd e7 4d 34 59 a5 8f  |Vbx/....x..M4Y..|
+00000310  05 ab ac 7f 80 35 f6 de  9d 3f fe 4b d4 79 07 3b  |.....5...?.K.y.;|
+00000320  c0 8d 02 b8 1a 28 b5 eb  9b 55 6c 26 12 8d 38 01  |.....(...Ul&..8.|
+00000330  55 ed 28 68 aa 48 13 61  d3 fe 29 f0 fe 18 4e ae  |U.(h.H.a..)...N.|
+00000340  6e f9 47 7c 65 91 f9 5e  17 80 68 fd 19 4d ed 17  |n.G|e..^..h..M..|
+00000350  7f 11 c4 15 5d 4b fc ea  a7 5c df 76 a0 08 2e 15  |....]K...\.v....|
+00000360  d1 c6 ae 7b 0d 1f 79 d7  0c 59 6b 53 46 b6 c0 2b  |...{..y..YkSF..+|
+00000370  ce 09 39 12 7a df f6 7d  a2 4b 86 2a df ab b8 7c  |..9.z..}.K.*...||
+00000380  07 10 3c 34 cd 15 4c ac  68 a4 28 8a f8 fc 30 a4  |..<4..L.h.(...0.|
+00000390  4f 15 77 b4 91 ca 02 ee  bb 64 36 90 1b 4b 9d 2b  |O.w......d6..K.+|
+000003a0  72 e7 dc 10 bd 83 97 18  3c 56 68 58 c9 e3 22 df  |r.......<VhX..".|
+000003b0  33 43 81 7d 5f 16 03 03  00 14 a8 eb 40 73 19 19  |3C.}_.......@s..|
+000003c0  22 10 63 ed f0 6d 73 8c  f4 bd f9 ba ad 2e        |".c..ms.......|
 >>> Flow 13 (client to server)
-00000000  16 03 03 00 35 a4 b8 43  07 6e 71 c9 b4 fa e1 9c  |....5..C.nq.....|
-00000010  a7 9d 0b 47 d8 ea 8b bd  ea c2 f5 bf 36 fa 88 95  |...G........6...|
-00000020  3b 98 b3 7e 19 21 9b 0f  58 76 e8 de 5b 24 d3 b5  |;..~.!..Xv..[$..|
-00000030  81 bd 11 ce 86 02 b0 d1  3b ac 14 03 03 00 11 3f  |........;......?|
-00000040  4e a4 96 06 71 44 5f 57  30 5e 1a bc 22 8d 42 97  |N...qD_W0^..".B.|
-00000050  16 03 03 00 20 23 e7 90  a5 0a 32 b4 69 06 d7 77  |.... #....2.i..w|
-00000060  df ef f6 2f b8 d8 22 39  08 4f 39 02 e0 7f 62 93  |.../.."9.O9...b.|
-00000070  02 b9 8e a5 b6                                    |.....|
+00000000  16 03 03 00 35 67 14 4b  ca 21 7f d2 82 1d 2e b3  |....5g.K.!......|
+00000010  1a 82 ae 2d d9 d6 7c 76  94 78 d4 ec 0e 4d fe 5c  |...-..|v.x...M.\|
+00000020  d5 56 5e 6d 32 f4 a0 64  50 1e f6 e4 32 28 92 80  |.V^m2..dP...2(..|
+00000030  d4 15 1c d5 f6 52 fc ca  c0 e7 14 03 03 00 11 df  |.....R..........|
+00000040  9d f3 d1 64 92 92 7e 11  77 64 e5 67 01 33 49 17  |...d..~.wd.g.3I.|
+00000050  16 03 03 00 20 c8 0f d9  d2 c8 b7 d6 a5 ac 2c 33  |.... .........,3|
+00000060  f8 77 8f b1 df db 16 de  43 6c e6 5a eb a0 6e ff  |.w......Cl.Z..n.|
+00000070  be 1d 69 ab 30                                    |..i.0|
 >>> Flow 14 (server to client)
-00000000  14 03 03 00 11 0e 2d 1e  73 95 29 15 86 03 a2 da  |......-.s.).....|
-00000010  6c f4 d2 02 2c 57 16 03  03 00 20 cd a2 f5 b6 da  |l...,W.... .....|
-00000020  0c 35 45 96 54 c3 96 5d  d8 e6 03 49 7b 5c d4 6f  |.5E.T..]...I{\.o|
-00000030  02 da 27 9e 2f a7 09 57  1b de 7b 17 03 03 00 19  |..'./..W..{.....|
-00000040  18 06 7d aa 5c 93 a9 b3  d3 14 0b 76 78 a2 57 73  |..}.\......vx.Ws|
-00000050  2f a3 4f 66 c4 b3 ee 21  95                       |/.Of...!.|
+00000000  14 03 03 00 11 6e 2c 51  c5 dd fa 70 2a 34 e0 cc  |.....n,Q...p*4..|
+00000010  3c 9f b8 66 15 e6 16 03  03 00 20 78 02 96 c6 24  |<..f...... x...$|
+00000020  57 ca 4a 60 47 68 f6 5a  13 8b 3b ce 90 60 d2 e3  |W.J`Gh.Z..;..`..|
+00000030  1b d8 ab 1c df d4 5e c2  8d 5c 5b 17 03 03 00 19  |......^..\[.....|
+00000040  b7 15 fb 91 10 48 ae 25  0c cd 4f 06 fa 2a 59 49  |.....H.%..O..*YI|
+00000050  2f 18 5e 7e 36 1b 2e cb  3a                       |/.^~6...:|
 >>> Flow 15 (client to server)
-00000000  15 03 03 00 12 55 f7 2f  b2 a2 e7 59 6c f6 a9 2d  |.....U./...Yl..-|
-00000010  d1 17 88 01 49 c6 f2                              |....I..|
+00000000  15 03 03 00 12 c3 ff f7  b3 dc d4 b3 f5 d4 7c a3  |..............|.|
+00000010  18 db 08 a2 50 ad 75                              |....P.u|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-RenegotiateTwiceRejected b/src/crypto/tls/testdata/Client-TLSv12-RenegotiateTwiceRejected
index 441fa0fd2a..784bcef92e 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-RenegotiateTwiceRejected
+++ b/src/crypto/tls/testdata/Client-TLSv12-RenegotiateTwiceRejected
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 59 02 00 00  55 03 03 bb ec 39 c5 f2  |....Y...U....9..|
-00000010  dd a8 26 56 80 09 60 f5  d8 0a 93 6d 08 c4 30 c2  |..&V..`....m..0.|
-00000020  cf 0c 44 86 49 a3 19 84  20 38 98 20 0d 8b 81 b5  |..D.I... 8. ....|
-00000030  a7 42 37 27 1b 9c be 36  8f 9b 49 31 4f 73 67 a7  |.B7'...6..I1Osg.|
-00000040  78 9f 46 e5 9e 3b 45 ff  e9 16 11 ca cc a8 00 00  |x.F..;E.........|
+00000000  16 03 03 00 59 02 00 00  55 03 03 96 8a 79 30 8b  |....Y...U....y0.|
+00000010  13 f5 d3 1c 09 45 76 83  d7 2e e5 ad e3 ee e1 c4  |.....Ev.........|
+00000020  d4 b4 4c 37 93 cb 90 e1  9a 5e 52 20 fb 25 91 ea  |..L7.....^R .%..|
+00000030  1a 96 b6 fb 1f 0c a8 62  06 a0 fe 51 68 c0 fb a5  |.......b...Qh...|
+00000040  f1 05 28 02 be dc 87 31  e6 ff 90 1a cc a8 00 00  |..(....1........|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  03 02 59 0b 00 02 55 00  02 52 00 02 4f 30 82 02  |..Y...U..R..O0..|
 00000070  4b 30 82 01 b4 a0 03 02  01 02 02 09 00 e8 f0 9d  |K0..............|
@@ -60,188 +60,188 @@
 00000290  77 8d 0c 1c f1 0f a1 d8  40 83 61 c9 4c 72 2b 9d  |w.......@.a.Lr+.|
 000002a0  ae db 46 06 06 4d f4 c1  b3 3e c0 d1 bd 42 d4 db  |..F..M...>...B..|
 000002b0  fe 3d 13 60 84 5c 21 d3  3b e9 fa e7 16 03 03 00  |.=.`.\!.;.......|
-000002c0  ac 0c 00 00 a8 03 00 1d  20 2f ad 87 a5 c9 9e c7  |........ /......|
-000002d0  f6 f1 05 9a 44 97 57 34  6b 3a 30 54 4c 0e 47 5e  |....D.W4k:0TL.G^|
-000002e0  16 d3 c9 c2 25 a8 47 e5  63 08 04 00 80 9f 54 b4  |....%.G.c.....T.|
-000002f0  c1 aa bb 15 07 5c b1 52  ef bd 26 fa ec ce 70 31  |.....\.R..&...p1|
-00000300  90 fb f5 4d d2 26 0c 64  6f b3 9f 7f 27 c7 a5 b2  |...M.&.do...'...|
-00000310  d1 6d cf 0e 9c 91 e3 c4  20 f7 e3 ae 95 ff 6d ce  |.m...... .....m.|
-00000320  80 b5 30 89 6c a2 dd 31  26 5b 24 19 7a 30 f7 43  |..0.l..1&[$.z0.C|
-00000330  71 a8 e9 1a 27 ee 46 86  44 56 b1 f3 2e e1 bd d5  |q...'.F.DV......|
-00000340  79 99 34 0c 9b 01 e6 bb  0f ad 96 4a 68 0f 10 79  |y.4........Jh..y|
-00000350  e9 91 7f 06 e6 02 32 ba  8c b6 a2 0c 4b 6d 09 f6  |......2.....Km..|
-00000360  28 8f 94 e8 10 e1 ca 48  6c de 56 c2 5c 16 03 03  |(......Hl.V.\...|
+000002c0  ac 0c 00 00 a8 03 00 1d  20 ad 8e 56 2a c0 d0 7c  |........ ..V*..||
+000002d0  e1 cb 6b 20 0b 3e 53 33  28 25 37 42 5b 13 3c d5  |..k .>S3(%7B[.<.|
+000002e0  26 98 9e 0f df 45 6d 27  67 08 04 00 80 72 49 21  |&....Em'g....rI!|
+000002f0  f0 02 02 a3 7c e1 2a 18  d0 d0 21 8e 50 17 ad 0c  |....|.*...!.P...|
+00000300  3c a2 6d 65 b5 cb bc 7f  9e 7d 7f e2 36 3d b6 c8  |<.me.....}..6=..|
+00000310  df 7e b9 28 ab 01 99 2a  68 a4 be 46 11 94 9f 8c  |.~.(...*h..F....|
+00000320  67 02 92 1e 3c 51 78 f3  7a 35 ed f4 bb 8b fe b3  |g...<Qx.z5......|
+00000330  8c 32 aa c1 05 4f 99 68  b0 8a 75 65 1d e6 d6 6a  |.2...O.h..ue...j|
+00000340  61 65 aa 00 01 6b 29 06  99 d4 5b c7 c3 d2 0c 17  |ae...k)...[.....|
+00000350  74 59 d4 ee 99 b8 ef 5b  53 ff 33 df 9e 05 49 4f  |tY.....[S.3...IO|
+00000360  31 c6 95 81 67 c2 52 8a  0c e9 6a 46 22 16 03 03  |1...g.R...jF"...|
 00000370  00 04 0e 00 00 00                                 |......|
 >>> Flow 3 (client to server)
 00000000  16 03 03 00 25 10 00 00  21 20 2f e5 7d a3 47 cd  |....%...! /.}.G.|
 00000010  62 43 15 28 da ac 5f bb  29 07 30 ff f6 84 af c4  |bC.(.._.).0.....|
 00000020  cf c2 ed 90 99 5f 58 cb  3b 74 14 03 03 00 01 01  |....._X.;t......|
-00000030  16 03 03 00 20 d5 77 86  8e 32 60 6b 0f 0f 36 33  |.... .w..2`k..63|
-00000040  89 fe 51 b8 69 3a 1f 37  b3 d1 eb 43 ab e0 f6 db  |..Q.i:.7...C....|
-00000050  8b 9d 3c 0d 9a                                    |..<..|
+00000030  16 03 03 00 20 b8 c8 5d  3d b8 b8 2b c7 06 94 ec  |.... ..]=..+....|
+00000040  cc 92 01 22 3d cd 38 d8  aa 9f 1f 18 ef a0 ee 59  |..."=.8........Y|
+00000050  c0 3b 04 56 49                                    |.;.VI|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 20 ed 78 35 a3 71  |.......... .x5.q|
-00000010  34 a9 40 b2 be 15 dc a9  10 86 e0 de 94 23 e9 51  |4.@..........#.Q|
-00000020  2c 01 1e 34 19 07 53 20  59 ac f9                 |,..4..S Y..|
+00000000  14 03 03 00 01 01 16 03  03 00 20 be 6c dd f4 ef  |.......... .l...|
+00000010  71 1d 9c a7 24 ef 74 81  c4 01 1e e0 ef ac 78 90  |q...$.t.......x.|
+00000020  4e 51 fd 8a ca 83 e7 57  95 07 fa                 |NQ.....W...|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 16 f3 a2 5f  da 1c 09 70 76 af 14 83  |......._...pv...|
-00000010  e5 7f 6f c9 9a 61 7f d9  e6 86 3c                 |..o..a....<|
+00000000  17 03 03 00 16 35 96 43  38 06 49 b1 3f 01 ae 85  |.....5.C8.I.?...|
+00000010  1a ee 4b 2b fe c0 75 76  b6 4a b0                 |..K+..uv.J.|
 >>> Flow 6 (server to client)
-00000000  16 03 03 00 14 71 23 15  46 93 87 94 38 01 d0 1b  |.....q#.F...8...|
-00000010  1a 34 db 58 17 d0 ac 62  87                       |.4.X...b.|
+00000000  16 03 03 00 14 df 6c d7  78 02 f5 a7 cb d8 2f fb  |......l.x...../.|
+00000010  04 dc 30 bc 28 51 f9 ec  b8                       |..0.(Q...|
 >>> Flow 7 (client to server)
-00000000  16 03 03 01 16 46 70 b5  5f 98 fc af a8 cb d6 7c  |.....Fp._......||
-00000010  8c 1e 60 c3 68 25 20 7b  95 9a 0c 04 b3 2c 52 b2  |..`.h% {.....,R.|
-00000020  30 f9 db cf 64 48 0a 46  9b 7a 11 76 11 5c 22 0c  |0...dH.F.z.v.\".|
-00000030  ef fa e6 6e a1 90 29 b3  64 aa ff 4d cb 7d 4d 91  |...n..).d..M.}M.|
-00000040  c0 05 99 a0 3d 25 b2 1e  7c c4 d2 94 6b bf f0 f7  |....=%..|...k...|
-00000050  0f 6a 3b 4c 66 c7 8a 26  9e 4f 79 68 50 5c f9 92  |.j;Lf..&.OyhP\..|
-00000060  97 e1 a5 86 aa f2 e9 d5  8a a1 96 a7 37 82 71 7d  |............7.q}|
-00000070  7d 7e b6 77 a3 3d 84 40  58 0d 66 cd 52 6c 9b 18  |}~.w.=.@X.f.Rl..|
-00000080  e2 c4 f0 dc 3d 9e 0e b8  49 ca 64 f3 71 c5 24 34  |....=...I.d.q.$4|
-00000090  e7 ca c3 87 f6 b9 2c 6a  95 12 4d 9d 4a 4d fe 8a  |......,j..M.JM..|
-000000a0  51 16 6e c9 00 64 c0 d1  da ae e6 14 66 d2 a8 80  |Q.n..d......f...|
-000000b0  35 ae 86 f6 64 f8 56 87  8a 40 46 43 ae d1 d1 fb  |5...d.V..@FC....|
-000000c0  64 1d 00 a1 3d e9 d9 7a  b5 fb 71 2a db 76 5a 74  |d...=..z..q*.vZt|
-000000d0  03 c3 79 df e6 90 e9 7e  de f9 0e 70 7a 65 3c 68  |..y....~...pze<h|
-000000e0  4f 2e c0 b8 13 e6 9d 1b  86 b8 65 57 fa dc 46 a7  |O.........eW..F.|
-000000f0  26 ba c3 64 fa b3 6f d5  e8 98 1f 10 d5 a5 1f 3e  |&..d..o........>|
-00000100  cc f9 8d a6 56 37 0d ff  92 8f 1b 36 b3 3d 0b f5  |....V7.....6.=..|
-00000110  5b fb fb 1e 4d c8 cb 84  39 5b 87                 |[...M...9[.|
+00000000  16 03 03 01 16 8c 2a 91  5b 60 aa 44 e7 b7 7e b8  |......*.[`.D..~.|
+00000010  ee c2 3e f3 c4 2f 6a 75  8e 25 07 5a 5c 42 81 fd  |..>../ju.%.Z\B..|
+00000020  65 4c 2a fb a9 80 f0 ba  33 1b 06 a8 79 a8 15 8e  |eL*.....3...y...|
+00000030  3a c4 08 95 a5 23 f0 ba  fb 43 58 26 84 b5 9d 17  |:....#...CX&....|
+00000040  03 e5 e7 08 ce 8b 79 9c  5e fb c6 6e a6 b8 12 cf  |......y.^..n....|
+00000050  b9 6e 4a 2a 90 d0 6b 65  93 bf 41 31 25 7f 3a 7c  |.nJ*..ke..A1%.:||
+00000060  75 1f d6 4e 22 d3 90 7b  71 14 57 c6 b6 89 ef 79  |u..N"..{q.W....y|
+00000070  74 7e 63 79 b9 63 d6 ef  02 b7 54 4b 53 0e 7f 70  |t~cy.c....TKS..p|
+00000080  8a 34 b1 85 98 ae a7 05  b8 41 9d 49 a3 ca eb 7d  |.4.......A.I...}|
+00000090  8b 64 e7 5d ca 11 71 93  e0 ff 6e 43 37 b4 e9 ec  |.d.]..q...nC7...|
+000000a0  23 6f d6 c6 bc cb ef a2  0b d0 4b ba 4f 40 b0 4b  |#o........K.O@.K|
+000000b0  ec 57 cb 8a 10 ae fe cd  14 70 42 a0 b9 1c 81 f6  |.W.......pB.....|
+000000c0  d2 79 47 31 4a b8 aa ac  89 98 cf ae 4e 8f 3d 36  |.yG1J.......N.=6|
+000000d0  c5 41 0e d8 e6 f3 88 2a  19 e5 e7 71 e2 2f 32 93  |.A.....*...q./2.|
+000000e0  ae 05 95 25 8f ec 4e 10  25 7e 53 60 6e c2 f2 72  |...%..N.%~S`n..r|
+000000f0  fc 7a 69 c1 93 e9 b8 2e  94 f3 19 31 5b 23 7c fd  |.zi........1[#|.|
+00000100  04 5d 59 ca 00 cc 37 0b  05 0d 50 10 50 3f b0 86  |.]Y...7...P.P?..|
+00000110  84 d4 fc 6a 0a 94 dc ba  88 fe ad                 |...j.......|
 >>> Flow 8 (server to client)
-00000000  16 03 03 00 81 25 44 f6  91 ed d5 01 fa 88 d6 74  |.....%D........t|
-00000010  f7 cd 6d ba 85 76 1d bd  ef 7b 31 51 db b4 42 a3  |..m..v...{1Q..B.|
-00000020  0a 89 3f 47 dc ca 18 39  84 5d 5a 4e d2 cd ba 75  |..?G...9.]ZN...u|
-00000030  b9 75 53 28 8c 85 6e 84  02 39 0a d2 59 ee ac 2f  |.uS(..n..9..Y../|
-00000040  fe a3 e4 fb 8c a1 72 e3  9f 28 8b 13 92 a8 5b 70  |......r..(....[p|
-00000050  24 f0 1b 6d 19 aa f1 b2  bf 8a 1f e2 3a 3e 3f e2  |$..m........:>?.|
-00000060  57 16 12 9e e8 21 11 66  b9 96 71 36 46 e1 2e fc  |W....!.f..q6F...|
-00000070  1e 40 a2 e2 6a 4d 4b 91  7a 50 0b d0 87 d1 04 16  |.@..jMK.zP......|
-00000080  2f 47 4d f2 c9 68 16 03  03 02 69 9a 28 7b f7 fc  |/GM..h....i.({..|
-00000090  8b e7 2b 40 88 1c 30 c1  5a f6 1d 51 a9 a8 5e 70  |..+@..0.Z..Q..^p|
-000000a0  73 1c 43 a7 3c 11 7e d5  92 78 b1 4f fd 5d 55 c6  |s.C.<.~..x.O.]U.|
-000000b0  5a ef 83 88 b2 e2 33 2a  27 cd 2e e8 d2 f4 2b d4  |Z.....3*'.....+.|
-000000c0  d5 b0 35 54 f6 a1 9c 07  75 10 8b 5d b9 dc bb 83  |..5T....u..]....|
-000000d0  76 43 f6 7e 70 2f 7c fe  8e 64 ca 00 65 df a4 e1  |vC.~p/|..d..e...|
-000000e0  a9 ad 71 79 d6 83 21 f6  9c 1b 88 d4 bb 51 3c 8a  |..qy..!......Q<.|
-000000f0  8c e5 c2 13 30 bd 6b 60  29 01 3e a0 cc 19 69 54  |....0.k`).>...iT|
-00000100  f0 2d dd a9 a1 24 a3 cc  13 9b 9a 8b f5 06 88 a9  |.-...$..........|
-00000110  9d ec c1 6f 0c b2 dd b3  60 be 23 ee 67 26 2d 65  |...o....`.#.g&-e|
-00000120  b1 99 9a 5b 92 c5 06 79  47 c6 4d 39 36 83 3b 4b  |...[...yG.M96.;K|
-00000130  96 f0 03 41 5c f9 fa 7c  3e d5 bf 67 1c a3 cf 6f  |...A\..|>..g...o|
-00000140  26 98 e0 2a 2d 64 60 c2  71 b1 b3 35 ba 8a 38 00  |&..*-d`.q..5..8.|
-00000150  88 cf 5a a5 2b 89 83 f3  04 ad 24 97 fa 34 69 fd  |..Z.+.....$..4i.|
-00000160  d7 70 00 09 ce 0f 60 f7  84 7d e3 5e 19 a9 1b dd  |.p....`..}.^....|
-00000170  45 3f 34 ae d4 c5 5c 1f  32 81 69 ea 22 44 1d c6  |E?4...\.2.i."D..|
-00000180  a3 ca 99 c5 44 09 76 cb  e2 ed 2e fd 23 09 d4 ea  |....D.v.....#...|
-00000190  62 cf cb 93 88 02 ca 8c  90 05 c9 0e 8d ff 8f e1  |b...............|
-000001a0  2d ef 52 1c ed 01 53 ef  a6 ee 11 11 b7 2b c8 b4  |-.R...S......+..|
-000001b0  6e 32 8c 54 7a 2b 19 e1  32 3e d0 92 87 81 76 04  |n2.Tz+..2>....v.|
-000001c0  c0 fd 99 3b 04 00 fb 76  d7 ed b0 81 e3 81 8c 1f  |...;...v........|
-000001d0  2b a0 59 d6 41 cd 8d 7d  b6 62 9d ab 60 33 24 f5  |+.Y.A..}.b..`3$.|
-000001e0  ec 70 8b b2 46 60 8f 53  c8 a3 f1 47 df e0 e8 b0  |.p..F`.S...G....|
-000001f0  9a cf 61 d4 d0 f5 0b b6  cd 85 47 1b b2 26 7d f2  |..a.......G..&}.|
-00000200  0a 32 af 5c 25 2a cc d2  66 9a 36 a1 68 95 34 18  |.2.\%*..f.6.h.4.|
-00000210  2d 9a 5a 62 a7 39 be 00  70 59 63 38 6a f9 53 b7  |-.Zb.9..pYc8j.S.|
-00000220  6d dd d4 cd c4 d2 12 b0  67 06 b5 d3 28 06 e4 43  |m.......g...(..C|
-00000230  98 b5 13 9f 1a d5 5e 07  70 f9 96 3c 66 a0 60 d6  |......^.p..<f.`.|
-00000240  79 1f 67 98 0b 38 ab 5a  1c 6f b0 31 e9 d9 6e 58  |y.g..8.Z.o.1..nX|
-00000250  28 c4 c5 82 9f 57 12 ae  35 12 c5 5c 29 f9 50 93  |(....W..5..\).P.|
-00000260  07 d8 e4 b8 36 5a 1e 10  a9 ee 33 5d ce 9c fe b8  |....6Z....3]....|
-00000270  78 11 99 2a 88 9d ce 49  6f 1c 73 41 65 5f c2 d5  |x..*...Io.sAe_..|
-00000280  46 a7 25 27 bc 3d 69 25  04 3a 37 ee e6 8a c0 d8  |F.%'.=i%.:7.....|
-00000290  e8 72 7a a9 21 03 9a 63  c9 f5 16 76 c4 11 b9 12  |.rz.!..c...v....|
-000002a0  03 cf ec 91 a0 6b 90 24  ba 0b f6 f2 4a 41 0d 9f  |.....k.$....JA..|
-000002b0  32 23 a3 df 3c ff c3 44  01 9c 77 5a 01 3f 00 d0  |2#..<..D..wZ.?..|
-000002c0  44 4d 48 23 58 9f 18 99  97 9c 32 7f cb 40 bb 35  |DMH#X.....2..@.5|
-000002d0  1f b8 06 07 28 7d 39 5a  47 66 12 95 30 07 24 b1  |....(}9ZGf..0.$.|
-000002e0  81 bc ea c0 6d 10 15 82  5f fe 68 50 1d aa 61 19  |....m..._.hP..a.|
-000002f0  c9 47 7c dc 16 03 03 00  bc e8 5f 40 20 1a cd d8  |.G|......._@ ...|
-00000300  5b b7 1e db 9d c0 10 96  e2 11 86 bc 0c e1 5f bd  |[............._.|
-00000310  9c cc 70 37 85 87 94 3c  cd 7d 0a c3 56 1e 18 9a  |..p7...<.}..V...|
-00000320  dc 21 4b e6 e1 63 c0 e6  2e 32 69 96 7e a0 cf cc  |.!K..c...2i.~...|
-00000330  58 74 a9 31 97 c1 e4 87  79 7f e7 7e 94 32 93 8d  |Xt.1....y..~.2..|
-00000340  31 97 51 27 26 cf ac e9  f9 34 ae 3e 1d f0 e9 5a  |1.Q'&....4.>...Z|
-00000350  71 82 05 10 8e be 0b 83  39 44 28 45 c6 e1 4a 85  |q.......9D(E..J.|
-00000360  c0 bf 3f 80 9b 61 97 82  d1 54 37 5f bc b2 f7 1f  |..?..a...T7_....|
-00000370  a1 ef 0f c5 be 74 96 3b  e8 89 30 3f d7 06 18 77  |.....t.;..0?...w|
-00000380  ed 3b aa 6e df 0c 15 e1  3e b1 36 ae 85 23 7d 9a  |.;.n....>.6..#}.|
-00000390  17 c3 f4 91 3a ac b1 64  03 a9 59 19 89 c2 d9 ad  |....:..d..Y.....|
-000003a0  82 d7 8e 85 36 cb 81 61  0d 3a 24 a1 84 55 37 bb  |....6..a.:$..U7.|
-000003b0  13 80 61 38 ef 16 03 03  00 4a 88 8d 13 b9 32 18  |..a8.....J....2.|
-000003c0  3c e2 72 b5 5c 0b 81 87  a0 ef 87 53 89 b1 f4 8b  |<.r.\......S....|
-000003d0  6a 87 68 c4 7d 59 2c 44  46 bb b1 40 8e 0a 45 4e  |j.h.}Y,DF..@..EN|
-000003e0  b8 a1 ba 72 bb 71 f9 52  55 c7 44 cd b3 56 82 68  |...r.q.RU.D..V.h|
-000003f0  8c 57 39 58 0b 40 12 4f  5d a2 91 3a ab 68 55 19  |.W9X.@.O]..:.hU.|
-00000400  26 dc ed 30 16 03 03 00  14 52 f8 53 d9 fc a6 a3  |&..0.....R.S....|
-00000410  89 c4 5a 2d 66 46 17 16  c3 bb f9 3c ca           |..Z-fF.....<.|
+00000000  16 03 03 00 81 41 25 27  5b 76 24 a0 4f f0 bf ca  |.....A%'[v$.O...|
+00000010  c4 4f f8 7c c6 e8 2a d4  d1 ed f1 b8 34 84 d6 d5  |.O.|..*.....4...|
+00000020  93 20 70 7d 8e 75 c5 16  a8 ff 5c e6 de 16 ea 96  |. p}.u....\.....|
+00000030  3f 86 3b bd 6d fa 96 3d  27 18 34 b8 18 86 ee 65  |?.;.m..='.4....e|
+00000040  7f f2 cc 7a b9 f8 2e 5a  32 f3 16 e2 a2 27 fd 4b  |...z...Z2....'.K|
+00000050  31 19 e6 81 d9 ef 02 10  ac b6 55 d3 0b e2 b0 09  |1.........U.....|
+00000060  56 ea 50 5a 96 b3 ff 07  78 48 df 77 3f 15 c9 ff  |V.PZ....xH.w?...|
+00000070  a7 24 af 28 ec 99 1a c9  36 09 16 9c 7c 5a c0 85  |.$.(....6...|Z..|
+00000080  7c 93 e4 61 2e 5b 16 03  03 02 69 ef 17 31 d5 9c  ||..a.[....i..1..|
+00000090  bc 09 f9 b7 75 e2 c8 ea  93 6f b7 49 e3 0e af bb  |....u....o.I....|
+000000a0  84 d6 3b 20 e2 89 13 6f  7a d1 73 a7 cb d5 03 b2  |..; ...oz.s.....|
+000000b0  20 40 40 76 d9 5d 3b 23  cb 48 ba 3c 1b e7 5d de  | @@v.];#.H.<..].|
+000000c0  16 be 82 91 39 d0 b4 83  3e 4c b8 a0 66 56 47 6c  |....9...>L..fVGl|
+000000d0  08 03 b1 0f be 3f d3 5e  7e b4 40 db db 5b ce 61  |.....?.^~.@..[.a|
+000000e0  d9 dc 02 7d ea df ea 43  08 2c b0 1c af 76 8f d3  |...}...C.,...v..|
+000000f0  cd af 51 cd 17 df 70 58  90 bd 83 aa 4b e5 fe cd  |..Q...pX....K...|
+00000100  90 30 e0 b5 d0 95 49 c2  10 06 8c 5a dd a2 37 ad  |.0....I....Z..7.|
+00000110  d5 d1 0e 73 c7 92 a9 ab  67 51 da 9d a4 62 6d a6  |...s....gQ...bm.|
+00000120  d7 89 22 2b 97 59 ad 02  65 e9 1d 48 44 07 c9 c0  |.."+.Y..e..HD...|
+00000130  c4 1f 7f da 64 0c 35 19  16 b3 70 41 d8 61 c3 47  |....d.5...pA.a.G|
+00000140  59 4d c2 e6 07 86 55 92  b9 98 8e 5c 86 d2 d5 51  |YM....U....\...Q|
+00000150  6a 50 19 99 75 0a cf 6e  49 cc 8a 76 b5 2b 20 48  |jP..u..nI..v.+ H|
+00000160  2b 11 d4 54 a2 ea 98 ce  d8 56 22 c8 f8 eb e5 25  |+..T.....V"....%|
+00000170  c8 cf ec 86 95 09 51 7e  18 89 bb 8f d4 66 b8 44  |......Q~.....f.D|
+00000180  c2 78 f4 4d ad eb 2d 79  f8 f6 02 4f d2 35 d4 71  |.x.M..-y...O.5.q|
+00000190  b3 ae e6 7d f6 45 6c 99  07 57 3c 01 bb c1 fb f1  |...}.El..W<.....|
+000001a0  1a ac ba 92 b6 60 52 63  8b 21 eb bf 77 02 c6 29  |.....`Rc.!..w..)|
+000001b0  7f 10 f7 11 ac a2 90 a9  8b 47 da c1 2c 41 c9 da  |.........G..,A..|
+000001c0  3f 18 ab be f0 eb 20 98  80 c6 d2 14 9e 8e d3 41  |?..... ........A|
+000001d0  c3 37 ab 12 5b cc d0 25  bd af 16 49 4e 89 a1 92  |.7..[..%...IN...|
+000001e0  d1 09 49 59 dc cf f8 6c  73 02 cb 72 6d 28 6e 28  |..IY...ls..rm(n(|
+000001f0  c5 a8 84 20 e6 f8 1b ad  c1 6c 8f b0 30 b2 49 84  |... .....l..0.I.|
+00000200  22 42 7d ec e1 c7 ab 29  de 1c 84 1f cf 59 c6 80  |"B}....).....Y..|
+00000210  7e 13 13 d7 c5 e5 f2 e0  3b 9d 81 c9 3f 86 21 27  |~.......;...?.!'|
+00000220  d7 c8 45 c1 25 f6 19 8d  0a f6 e9 5a 9b d5 64 a1  |..E.%......Z..d.|
+00000230  e4 6d fe 6a cf d1 c3 1b  d4 ea d9 1f 6b dc f9 a7  |.m.j........k...|
+00000240  e9 d2 6c 31 19 db e1 f4  f8 82 6e 8b da fd b1 fd  |..l1......n.....|
+00000250  0a 56 84 73 db 25 5f bb  12 61 70 de 67 34 28 1c  |.V.s.%_..ap.g4(.|
+00000260  c3 e6 eb 81 c8 94 55 ca  52 25 e8 72 bf a1 c5 88  |......U.R%.r....|
+00000270  b8 ce 72 8d 64 6c 38 d9  19 07 f3 51 51 91 84 f2  |..r.dl8....QQ...|
+00000280  c4 76 7f 8b 57 09 71 94  38 aa f1 64 51 6f 62 50  |.v..W.q.8..dQobP|
+00000290  c8 50 68 82 b9 54 b1 28  54 99 21 26 7d 75 c7 c7  |.Ph..T.(T.!&}u..|
+000002a0  79 e7 65 93 72 a4 39 2d  4c ec ba b2 4c 92 ae ee  |y.e.r.9-L...L...|
+000002b0  34 a2 22 2f f9 b9 75 a9  27 77 63 2d ac 27 87 ce  |4."/..u.'wc-.'..|
+000002c0  ee 37 c0 c7 c1 b6 4c 13  d7 78 97 64 dc af ea 0d  |.7....L..x.d....|
+000002d0  7c 12 0e 7b 0b 26 77 01  e4 1c 24 e8 9f fc 19 2f  ||..{.&w...$..../|
+000002e0  46 a2 81 3d 0d c7 16 7e  49 25 b4 c1 0f 0a 71 05  |F..=...~I%....q.|
+000002f0  25 eb 53 e4 16 03 03 00  bc 0b 79 2d c6 0a 63 68  |%.S.......y-..ch|
+00000300  f0 21 37 d0 42 4a 0f 2f  7d 2f a0 7d 3d c3 94 c4  |.!7.BJ./}/.}=...|
+00000310  36 f5 a6 db e1 ad 0f 94  07 67 57 54 d4 57 86 50  |6........gWT.W.P|
+00000320  a2 e1 78 09 f2 e3 7b bc  6d 1b c0 fe 16 eb d3 ef  |..x...{.m.......|
+00000330  fb ec 22 44 ee 2f 78 99  84 e2 c1 4c f7 0d 4f bc  |.."D./x....L..O.|
+00000340  ca 57 be de 5f 52 08 33  b0 e1 1d 7b 45 9e 5d 17  |.W.._R.3...{E.].|
+00000350  41 2c 10 43 44 18 84 38  f3 0b 6a a1 76 bf 75 c9  |A,.CD..8..j.v.u.|
+00000360  56 b2 53 4c 98 39 c0 6f  30 13 96 8a 27 59 12 03  |V.SL.9.o0...'Y..|
+00000370  60 64 ce 28 54 c0 03 f4  c4 d1 df 94 e3 6e 43 61  |`d.(T........nCa|
+00000380  fa 43 40 e5 05 3b 26 dc  c4 41 bd 73 c3 9e a0 db  |.C@..;&..A.s....|
+00000390  fb c9 50 b4 4a d9 2d 71  cf e8 ff 3d 17 9e 29 35  |..P.J.-q...=..)5|
+000003a0  61 6c ab 11 ac 21 fa 90  6b 75 1f 0a 9d 30 3f 13  |al...!..ku...0?.|
+000003b0  fa c3 97 7a 74 16 03 03  00 4a 3d ca 3b 3d c8 6f  |...zt....J=.;=.o|
+000003c0  44 4e 53 3d 05 27 97 aa  bd 58 33 d6 ad 4a 34 71  |DNS=.'...X3..J4q|
+000003d0  22 d9 36 96 17 a5 ba 6b  b3 20 2e da 64 65 14 c7  |".6....k. ..de..|
+000003e0  6a c7 07 39 55 db bb ad  e2 49 84 09 5e 78 88 b5  |j..9U....I..^x..|
+000003f0  4b d5 23 fa 17 c5 f2 b8  2a c6 e5 1e 15 47 01 36  |K.#.....*....G.6|
+00000400  ef 7f 0a 14 16 03 03 00  14 28 e3 58 7e b9 36 d6  |.........(.X~.6.|
+00000410  ef 65 c8 bc fb 10 57 3d  48 70 7f 68 7d           |.e....W=Hp.h}|
 >>> Flow 9 (client to server)
-00000000  16 03 03 02 69 fe 0d 45  cb 57 12 fa 9e 10 d7 b3  |....i..E.W......|
-00000010  a5 dd 33 0e 39 41 77 63  8e 99 e0 5b b9 5e 94 0a  |..3.9Awc...[.^..|
-00000020  48 b2 6b e9 61 ab f2 74  6b 5e a3 f9 3f 9c 29 0b  |H.k.a..tk^..?.).|
-00000030  6b 34 29 92 d8 c8 2c 61  84 f2 3b 0f c2 5c e5 19  |k4)...,a..;..\..|
-00000040  6a f0 e2 03 e3 93 a6 1e  4e 87 79 6b 07 dc 18 d2  |j.......N.yk....|
-00000050  9a 25 be f3 d6 ab 2a be  f8 68 65 68 92 8a 80 04  |.%....*..heh....|
-00000060  26 eb 62 ae 6b bc 81 27  82 76 25 e0 6b ac 04 e9  |&.b.k..'.v%.k...|
-00000070  67 68 13 f6 7b 7e 24 c2  75 27 8a c9 3a 7a 2f aa  |gh..{~$.u'..:z/.|
-00000080  a2 37 d9 73 97 bc 4b 09  ba 1b 2c ba 08 85 c6 82  |.7.s..K...,.....|
-00000090  50 a3 e0 00 6e a8 7c 14  ab 38 ae c4 82 ee 05 4b  |P...n.|..8.....K|
-000000a0  9a c0 19 62 1e de ef 7f  8c a4 a0 0e 29 0f b4 09  |...b........)...|
-000000b0  f1 b9 39 ae 09 1b 6e 6f  ee 3d 31 72 70 09 51 44  |..9...no.=1rp.QD|
-000000c0  1c 33 64 6d ae 8d da a5  e0 7b a3 49 19 2c 3f dd  |.3dm.....{.I.,?.|
-000000d0  6b 1e d1 a7 bb 8a 13 8c  e9 aa 5f b3 fd 88 89 5a  |k........._....Z|
-000000e0  4a 30 dd d0 1e 6a 8c 8a  0d 35 82 01 64 c1 42 ff  |J0...j...5..d.B.|
-000000f0  60 ac 3d 62 bf 31 3e ab  42 7e b0 da 4a cc 9c d8  |`.=b.1>.B~..J...|
-00000100  0e 92 97 a2 40 48 48 ce  66 49 bd 1b 8a ee ed 46  |....@HH.fI.....F|
-00000110  18 98 b9 43 b8 76 e8 93  07 3c 38 6e c2 cd 9c ce  |...C.v...<8n....|
-00000120  e2 38 f0 d7 ee ad c7 4a  c4 ed 3b fd 2e f2 9b 43  |.8.....J..;....C|
-00000130  6c fe 75 d7 4d 61 2a c5  16 e2 3d af 98 5b 76 f5  |l.u.Ma*...=..[v.|
-00000140  3e 96 b9 81 b3 cb 0c 91  89 44 6e d6 66 c4 f2 dd  |>........Dn.f...|
-00000150  c9 21 09 91 95 f2 99 29  62 54 44 03 b0 fe 84 bb  |.!.....)bTD.....|
-00000160  96 86 c4 ca 6e 7f c9 f9  1a 80 38 42 7d 54 b3 6f  |....n.....8B}T.o|
-00000170  2a 2d c3 19 54 60 3f fb  00 95 65 6a 85 4b a2 8f  |*-..T`?...ej.K..|
-00000180  6a 3d 38 61 e9 36 c2 25  92 3b 53 f2 ea bb 60 42  |j=8a.6.%.;S...`B|
-00000190  ab 83 83 c0 2e 95 6d 5a  19 61 9f b3 29 ee b2 52  |......mZ.a..)..R|
-000001a0  5f 27 16 46 d9 ad 62 45  d5 81 9a 93 ef a1 4f e7  |_'.F..bE......O.|
-000001b0  0e e0 71 bf cd 49 68 e7  13 f1 71 59 8c f5 2d 05  |..q..Ih...qY..-.|
-000001c0  5d 65 c4 6e 2c 91 c5 d3  40 c4 2f df c8 f6 59 55  |]e.n,...@./...YU|
-000001d0  05 6b c1 b7 59 15 8e b8  85 1b 75 dd 44 9e b7 f3  |.k..Y.....u.D...|
-000001e0  00 73 bf c6 93 d4 43 27  bd 60 79 1a 28 93 2d 64  |.s....C'.`y.(.-d|
-000001f0  fb 2f 77 a6 79 22 54 f3  c3 3c 3f cd 4d ea 79 3b  |./w.y"T..<?.M.y;|
-00000200  aa 4c e6 86 55 8d e0 5c  ce 00 1e d4 fa ab bb de  |.L..U..\........|
-00000210  8f 41 95 15 d3 6a 21 02  cb 4a f5 b6 2d 8c da 99  |.A...j!..J..-...|
-00000220  93 1f 9f 81 cf 77 f8 01  0a ab 77 03 5c a3 bd 3a  |.....w....w.\..:|
-00000230  ba 07 51 17 50 06 c9 51  f8 f1 ec 3f 60 44 df 1b  |..Q.P..Q...?`D..|
-00000240  06 05 bd 8f 17 99 00 73  38 e5 bb fb 08 1b e7 ea  |.......s8.......|
-00000250  b5 36 e0 4e 67 d9 11 90  5e d9 8e 63 7b f9 03 4b  |.6.Ng...^..c{..K|
-00000260  ef cd 4d 2c d9 4b eb 8a  bb 62 85 03 16 e2 16 03  |..M,.K...b......|
-00000270  03 00 35 d1 39 57 66 1b  70 63 8f 6a b4 1d 5f 5e  |..5.9Wf.pc.j.._^|
-00000280  dd 31 7e 5b 0e e3 d5 98  90 8b 60 33 0c 10 7c 01  |.1~[......`3..|.|
-00000290  4c 40 88 e9 a3 8c 61 ab  dc 4a e2 ce 0a fc 56 7b  |L@....a..J....V{|
-000002a0  ef e3 19 60 62 18 97 7c  16 03 03 00 98 2f 65 76  |...`b..|...../ev|
-000002b0  15 2e 76 82 e8 70 6d c4  17 72 e7 30 9c 14 af d4  |..v..pm..r.0....|
-000002c0  0f 1e ec b5 5c 80 31 dc  15 fc 81 06 20 f1 e5 99  |....\.1..... ...|
-000002d0  67 c6 eb cc 77 57 2c 55  85 dc f9 9f 6f 19 7a d0  |g...wW,U....o.z.|
-000002e0  a0 45 17 b9 8c e4 19 46  ef dc 28 e1 e7 87 93 e0  |.E.....F..(.....|
-000002f0  c5 83 70 28 23 90 b9 c2  53 a3 67 d8 09 1f 47 0e  |..p(#...S.g...G.|
-00000300  a3 de bf a3 07 2d e7 3b  a5 e9 11 c4 30 59 fb cd  |.....-.;....0Y..|
-00000310  5d 6a d0 47 6f 43 a4 bd  2f 56 67 7d b2 c8 f5 2a  |]j.GoC../Vg}...*|
-00000320  9b ce ea 10 ec 83 f8 bc  87 19 c8 97 a9 ee 80 3c  |...............<|
-00000330  cb de 1a 22 60 ed 77 f7  57 5f 20 54 62 ca b0 e7  |..."`.w.W_ Tb...|
-00000340  75 a0 ba fc 32 14 03 03  00 11 86 a9 6a 14 1a 4c  |u...2.......j..L|
-00000350  1d 21 1f 3c c2 19 85 02  88 f5 f6 16 03 03 00 20  |.!.<........... |
-00000360  03 f9 fc ed cf 15 ed 86  d2 69 49 d7 e2 01 06 96  |.........iI.....|
-00000370  42 74 89 3f bf 98 56 0f  c1 1b 61 b6 36 3b ae 87  |Bt.?..V...a.6;..|
+00000000  16 03 03 02 69 d8 c1 81  7e a9 d7 70 97 62 c7 68  |....i...~..p.b.h|
+00000010  df 02 01 9d cc dc 38 d0  d6 bb 48 03 1d 0b be 73  |......8...H....s|
+00000020  b3 1a 88 91 a0 1b 55 91  51 a5 d7 54 58 c4 ea 50  |......U.Q..TX..P|
+00000030  e5 67 b1 60 78 b6 e2 7f  d7 6c b4 76 d7 24 fd af  |.g.`x....l.v.$..|
+00000040  f6 68 90 8c de 71 cd 15  4f d0 c8 f6 ba 89 ce 05  |.h...q..O.......|
+00000050  be 35 e8 9e 7a 8b 8d 0d  23 d4 5a bd 3a 9e d0 bf  |.5..z...#.Z.:...|
+00000060  80 08 f5 ad 7d 84 f1 8a  16 de 97 6b b2 75 8e 49  |....}......k.u.I|
+00000070  0f d7 8b 10 57 f7 21 1f  c0 87 de 06 c5 ae ae dd  |....W.!.........|
+00000080  9c 22 92 a1 6c c7 46 8d  e2 be 43 32 9c be 47 6b  |."..l.F...C2..Gk|
+00000090  4d 2a 60 f0 b6 3a 09 16  d6 16 a1 92 4a 2d 2d 72  |M*`..:......J--r|
+000000a0  00 8f 40 7c 3e a9 61 be  35 c8 f8 48 b4 1c 90 61  |..@|>.a.5..H...a|
+000000b0  90 c5 aa f8 ae aa d4 8a  15 74 b2 5d aa 24 cf 45  |.........t.].$.E|
+000000c0  ef 02 bd 29 b9 50 b4 fe  83 05 fa 4a a5 82 10 28  |...).P.....J...(|
+000000d0  b7 ab c3 ca c3 65 bb 51  a4 7c ac 57 03 78 28 e3  |.....e.Q.|.W.x(.|
+000000e0  91 9f c1 ce 02 08 70 84  8c 11 1f ae 35 a5 06 12  |......p.....5...|
+000000f0  f8 78 5b 38 0a 11 c8 1c  2d 1b 0c 21 66 d9 41 b2  |.x[8....-..!f.A.|
+00000100  ed 66 3c 47 f2 dc ab c1  59 7d 65 df bb 80 37 1c  |.f<G....Y}e...7.|
+00000110  5e 9b 41 e1 1d 5f b5 24  e4 77 61 3b e8 36 93 03  |^.A.._.$.wa;.6..|
+00000120  6d 87 17 e9 d7 77 35 b1  83 a3 b9 80 4d 40 20 82  |m....w5.....M@ .|
+00000130  94 36 53 94 ad 6b b3 ad  0a 70 fd 11 ce 81 56 ca  |.6S..k...p....V.|
+00000140  c2 5d 16 69 e3 59 7e 37  3b cd f3 54 1e b8 5e 1a  |.].i.Y~7;..T..^.|
+00000150  64 3f bf c6 ba ff fa b5  bf 4b c2 8e 5a 4d 43 1f  |d?.......K..ZMC.|
+00000160  8e 50 bc 7a 82 13 c7 25  aa b4 a8 97 45 49 12 25  |.P.z...%....EI.%|
+00000170  f5 4d 52 df 90 e5 74 0f  a0 d2 fd c3 6f bd 41 ed  |.MR...t.....o.A.|
+00000180  ff 78 e8 97 f2 e2 d1 5b  7c e6 27 01 16 27 1d b6  |.x.....[|.'..'..|
+00000190  8a cf c6 5b 8d b3 d8 8e  0c ee 2a d5 21 f6 4b d3  |...[......*.!.K.|
+000001a0  5a 74 7e 3d c6 fb 0e 35  97 de e7 52 c0 b2 c3 37  |Zt~=...5...R...7|
+000001b0  94 28 41 e0 3b 65 56 f1  4f 60 03 48 88 1d db fc  |.(A.;eV.O`.H....|
+000001c0  60 9f 33 e1 4d 37 eb 22  36 b2 76 ae 1c 3d 1c 5e  |`.3.M7."6.v..=.^|
+000001d0  3a c5 5b 00 eb 72 8b 54  ba 76 d1 71 77 5f 76 54  |:.[..r.T.v.qw_vT|
+000001e0  5f fd 0e d1 3a 50 ad b1  55 4a db 6d bf 2f 33 90  |_...:P..UJ.m./3.|
+000001f0  fc 42 de cd e4 a9 dd 11  25 d1 9f 56 1e 8a 2b 5c  |.B......%..V..+\|
+00000200  6c ed e7 51 84 42 6b ab  7d 77 b4 95 c3 75 b3 24  |l..Q.Bk.}w...u.$|
+00000210  ce 70 b0 e1 63 7f ec b0  ea 6a a4 a1 d5 e8 3e 96  |.p..c....j....>.|
+00000220  65 99 40 46 73 c8 e1 6e  86 65 92 bf 3d 92 a3 4f  |e.@Fs..n.e..=..O|
+00000230  37 6d bb 80 33 a5 7d aa  d3 a9 37 77 a6 4e 5b d6  |7m..3.}...7w.N[.|
+00000240  f3 f9 b2 42 75 18 1f 5a  58 f3 08 35 bc f4 2b 93  |...Bu..ZX..5..+.|
+00000250  62 0b 8a 83 f9 44 d0 e1  1a 44 b2 66 45 6f de b3  |b....D...D.fEo..|
+00000260  d2 ec 34 ac 15 89 76 b4  da dd 95 ca 44 5b 16 03  |..4...v.....D[..|
+00000270  03 00 35 39 e8 06 21 47  85 b5 53 96 03 0b 08 3b  |..59..!G..S....;|
+00000280  d2 9d 55 1f 23 4f 3a c0  be 4f e0 e0 0a f1 65 6f  |..U.#O:..O....eo|
+00000290  78 22 c4 10 6b d0 96 dc  04 78 e8 d3 95 f6 9a 78  |x"..k....x.....x|
+000002a0  09 f2 42 d3 79 57 99 c4  16 03 03 00 98 37 6b 75  |..B.yW.......7ku|
+000002b0  79 17 fa 67 7f 94 2e aa  88 61 91 97 dc 10 1e e6  |y..g.....a......|
+000002c0  6d 6d fa d5 64 17 f4 ec  ba 01 43 99 88 e2 a7 13  |mm..d.....C.....|
+000002d0  e0 9e 6a e9 97 c7 b3 ec  b9 c9 72 51 3d 01 eb c0  |..j.......rQ=...|
+000002e0  03 0f 08 48 90 27 36 6b  bd e7 0d 4e 41 6a ef 11  |...H.'6k...NAj..|
+000002f0  42 5b ae d1 16 ec 8f b7  47 a2 f5 b4 6a d4 32 bb  |B[......G...j.2.|
+00000300  0c cc 4f 2a e0 be 44 47  c8 77 09 f5 78 4b d6 ec  |..O*..DG.w..xK..|
+00000310  87 95 dc e1 74 75 54 af  45 bb 7a f5 2e f7 ac 3d  |....tuT.E.z....=|
+00000320  d1 b2 31 5a c0 24 c7 7c  25 36 62 a7 48 73 66 44  |..1Z.$.|%6b.HsfD|
+00000330  c1 78 47 f3 48 c5 a0 f7  66 3e 78 27 2c 3c dc 83  |.xG.H...f>x',<..|
+00000340  f5 6c e1 09 31 14 03 03  00 11 79 32 99 fd 2d 8d  |.l..1.....y2..-.|
+00000350  14 33 fd 1b 1b a8 3d 99  4b 0a b7 16 03 03 00 20  |.3....=.K...... |
+00000360  76 25 53 83 f2 c5 bf a6  fa 2e d3 5a 62 67 5b 1d  |v%S........Zbg[.|
+00000370  23 9a 9c b3 16 01 3f 6a  e9 4c ea e1 d4 d1 09 42  |#.....?j.L.....B|
 >>> Flow 10 (server to client)
-00000000  14 03 03 00 11 00 e4 ef  62 c1 c0 72 f3 98 4d 5a  |........b..r..MZ|
-00000010  6a c8 7e 29 92 b8 16 03  03 00 20 ff 7e fc cb b5  |j.~)...... .~...|
-00000020  07 5f ea 8a 89 2a 46 1b  c6 33 41 fe f9 f4 1e 3a  |._...*F..3A....:|
-00000030  9d 8b 1d 8f 9b 7b 89 07  b4 e8 59 17 03 03 00 19  |.....{....Y.....|
-00000040  a3 ba 0c 9b 54 cd 59 6a  e1 db 33 80 38 a9 95 a1  |....T.Yj..3.8...|
-00000050  95 5b a5 5f ad 3c d0 52  f7 16 03 03 00 14 e6 22  |.[._.<.R......."|
-00000060  84 a7 02 10 1e ee 58 88  a5 b8 e8 bf 0a 9b 61 46  |......X.......aF|
-00000070  0c ae                                             |..|
+00000000  14 03 03 00 11 a7 38 2a  4e 04 a5 b7 df d6 05 bb  |......8*N.......|
+00000010  b5 93 38 bc 9e 62 16 03  03 00 20 f3 d3 e1 7d 80  |..8..b.... ...}.|
+00000020  41 ce 05 99 92 c7 47 fe  b5 08 3b 78 9d ae b0 5f  |A.....G...;x..._|
+00000030  2c ed bd 0b 90 e0 94 9e  0b b0 a5 17 03 03 00 19  |,...............|
+00000040  27 f0 6a 55 af 3f c1 82  85 1a 6b 28 e1 cd dc 59  |'.jU.?....k(...Y|
+00000050  43 be c7 18 16 30 08 b2  9e 16 03 03 00 14 c1 c5  |C....0..........|
+00000060  64 ef 72 4f 6c 96 f1 f6  5b 70 29 e4 59 36 0a cd  |d.rOl...[p).Y6..|
+00000070  d2 a3                                             |..|
 >>> Flow 11 (client to server)
-00000000  15 03 03 00 12 7f 90 91  7b 93 4e 24 25 5e cb 35  |........{.N$%^.5|
-00000010  2c eb ee 29 6a b3 a3 15  03 03 00 12 3d b7 30 fe  |,..)j.......=.0.|
-00000020  63 90 c3 2d 17 a0 e1 ed  8d bb a4 f6 f6 17        |c..-..........|
+00000000  15 03 03 00 12 af 73 0e  40 39 dd 1e 04 99 3e 10  |......s.@9....>.|
+00000010  c9 62 b3 78 77 9b 56 15  03 03 00 12 25 8b 87 29  |.b.xw.V.....%..)|
+00000020  82 d0 9f 5e 9a 27 bd c1  bf b7 a2 f0 92 ac        |...^.'........|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-RenegotiationRejected b/src/crypto/tls/testdata/Client-TLSv12-RenegotiationRejected
index 3502977efa..f7a7668a8f 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-RenegotiationRejected
+++ b/src/crypto/tls/testdata/Client-TLSv12-RenegotiationRejected
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 59 02 00 00  55 03 03 9c d0 eb d6 42  |....Y...U......B|
-00000010  2e ff 6e 5a 19 33 6d 12  97 56 56 2b f5 1b 86 c8  |..nZ.3m..VV+....|
-00000020  38 83 59 37 ac 17 46 ed  73 53 43 20 e4 94 9b 71  |8.Y7..F.sSC ...q|
-00000030  f4 94 d9 d9 3a a1 e1 99  1e b4 a5 55 46 88 e0 0a  |....:......UF...|
-00000040  af 0a 0e ff 81 10 e2 e0  63 21 ae 2a cc a8 00 00  |........c!.*....|
+00000000  16 03 03 00 59 02 00 00  55 03 03 a3 55 d2 e2 bd  |....Y...U...U...|
+00000010  94 8f 04 51 26 1c a6 61  b1 ed 05 e2 39 44 33 05  |...Q&..a....9D3.|
+00000020  79 14 b7 1f 89 1e bb ba  53 0d 12 20 09 29 6d 26  |y.......S.. .)m&|
+00000030  04 70 4a 5d 01 90 f2 c6  28 df 11 6a 64 23 ec 9e  |.pJ]....(..jd#..|
+00000040  9f 2b 15 33 dc 88 26 35  3a b0 86 92 cc a8 00 00  |.+.3..&5:.......|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  03 02 59 0b 00 02 55 00  02 52 00 02 4f 30 82 02  |..Y...U..R..O0..|
 00000070  4b 30 82 01 b4 a0 03 02  01 02 02 09 00 e8 f0 9d  |K0..............|
@@ -60,36 +60,36 @@
 00000290  77 8d 0c 1c f1 0f a1 d8  40 83 61 c9 4c 72 2b 9d  |w.......@.a.Lr+.|
 000002a0  ae db 46 06 06 4d f4 c1  b3 3e c0 d1 bd 42 d4 db  |..F..M...>...B..|
 000002b0  fe 3d 13 60 84 5c 21 d3  3b e9 fa e7 16 03 03 00  |.=.`.\!.;.......|
-000002c0  ac 0c 00 00 a8 03 00 1d  20 9b 89 08 0d ea c2 d3  |........ .......|
-000002d0  4f 73 77 a0 e3 0e 1a 68  13 2c 5c a5 ec 39 75 1b  |Osw....h.,\..9u.|
-000002e0  c2 95 fe b8 fe 58 f4 bb  16 08 04 00 80 d4 e8 d3  |.....X..........|
-000002f0  d4 5b 1f ee ff 60 f5 86  b1 f4 06 c0 a8 ab 90 b0  |.[...`..........|
-00000300  26 15 d5 4e 3f d6 a5 e2  a3 3a e0 0f 9a 92 bd 96  |&..N?....:......|
-00000310  9d 98 15 f3 95 82 a9 5d  9f 1d 9b 4f 2e 77 58 40  |.......]...O.wX@|
-00000320  58 3d fd 8f a6 09 1c fa  61 77 2e 87 df e7 76 8b  |X=......aw....v.|
-00000330  bf f1 dd 29 f8 70 c0 6d  db e5 a0 55 92 77 44 75  |...).p.m...U.wDu|
-00000340  d9 95 a6 17 67 93 47 8e  1f 61 50 65 31 94 d3 79  |....g.G..aPe1..y|
-00000350  5f 25 a6 f0 3e 19 9a c8  ad b9 1a af 5b 50 2c 97  |_%..>.......[P,.|
-00000360  78 1e 71 3a e0 fa 7c 44  1e d1 32 56 4e 16 03 03  |x.q:..|D..2VN...|
+000002c0  ac 0c 00 00 a8 03 00 1d  20 43 6b 44 5b 79 c9 38  |........ CkD[y.8|
+000002d0  dc e4 ab fa 88 fa e6 06  89 b1 4e ff ab 8d d6 f7  |..........N.....|
+000002e0  21 b4 ff 9d a0 c8 54 cc  63 08 04 00 80 cd f4 d6  |!.....T.c.......|
+000002f0  c8 ad 03 e7 f0 e8 f4 c9  f0 e6 28 db cd 3b 7c bf  |..........(..;|.|
+00000300  05 af 3d fe c1 f9 f1 7a  ec 41 bf 1f a8 95 6d ee  |..=....z.A....m.|
+00000310  e6 92 cb c0 ff fd c1 ed  86 b0 59 45 3e 2d 1d 66  |..........YE>-.f|
+00000320  56 d1 9f e2 b7 79 ac aa  81 6d b0 42 36 96 80 4d  |V....y...m.B6..M|
+00000330  ca 36 29 1b 65 03 73 3f  85 ec 59 cb b4 a5 a0 c0  |.6).e.s?..Y.....|
+00000340  0c 16 ad e2 6b 35 3c ab  1e da 69 19 7d a2 63 a7  |....k5<...i.}.c.|
+00000350  69 2a d2 3f 12 17 bf 4c  ed 8a f7 75 fe ce d4 2b  |i*.?...L...u...+|
+00000360  4d 35 bf 65 d6 9e 01 69  a8 0a 73 26 34 16 03 03  |M5.e...i..s&4...|
 00000370  00 04 0e 00 00 00                                 |......|
 >>> Flow 3 (client to server)
 00000000  16 03 03 00 25 10 00 00  21 20 2f e5 7d a3 47 cd  |....%...! /.}.G.|
 00000010  62 43 15 28 da ac 5f bb  29 07 30 ff f6 84 af c4  |bC.(.._.).0.....|
 00000020  cf c2 ed 90 99 5f 58 cb  3b 74 14 03 03 00 01 01  |....._X.;t......|
-00000030  16 03 03 00 20 88 fe 97  82 bd a7 99 c6 a6 2f c1  |.... ........./.|
-00000040  1a a8 54 8c e5 c6 39 0a  6b 07 9b 1a 05 f4 fb e3  |..T...9.k.......|
-00000050  67 f5 c8 6e 17                                    |g..n.|
+00000030  16 03 03 00 20 b8 d8 22  20 8d 69 23 05 34 eb 69  |.... .." .i#.4.i|
+00000040  92 a0 a9 6c cd 94 3b 72  49 91 72 8e 65 79 ca 62  |...l..;rI.r.ey.b|
+00000050  14 cf da 2e b6                                    |.....|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 20 3b 6d ac 1c 8b  |.......... ;m...|
-00000010  1b 46 3a 4e 03 75 51 9e  99 6e 5a a8 4f 07 91 a3  |.F:N.uQ..nZ.O...|
-00000020  18 2c bf 88 92 17 e5 13  65 a3 6c                 |.,......e.l|
+00000000  14 03 03 00 01 01 16 03  03 00 20 31 25 d4 c7 92  |.......... 1%...|
+00000010  16 0b 92 2d a2 20 8b b2  c7 96 a6 b7 b6 b3 82 3a  |...-. .........:|
+00000020  4d a1 a8 96 29 fb 99 e9  ea 04 6c                 |M...).....l|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 16 c7 94 fc  be 3d 73 fd ec ce b2 f6  |.........=s.....|
-00000010  bf 17 bf 52 3e b4 98 39  43 c0 0a                 |...R>..9C..|
+00000000  17 03 03 00 16 8b 92 f3  f8 99 bf a3 7c c4 03 d8  |............|...|
+00000010  4d e7 1b ad 50 e1 99 17  33 68 e2                 |M...P...3h.|
 >>> Flow 6 (server to client)
-00000000  16 03 03 00 14 cf 01 f5  e6 eb 60 e3 49 c4 fb 84  |..........`.I...|
-00000010  e1 11 69 e1 91 c0 02 d2  e3                       |..i......|
+00000000  16 03 03 00 14 91 99 15  68 ae 92 52 bd 13 75 45  |........h..R..uE|
+00000010  6d a9 f0 2d ee f5 c3 9b  e7                       |m..-.....|
 >>> Flow 7 (client to server)
-00000000  15 03 03 00 12 4d 7f de  01 23 f7 3f 0d e6 1a f1  |.....M...#.?....|
-00000010  19 a2 cd 58 1a 25 f5 15  03 03 00 12 95 78 52 00  |...X.%.......xR.|
-00000020  65 aa 6d 77 5a 66 d5 95  c4 5a 9b 1b 05 b2        |e.mwZf...Z....|
+00000000  15 03 03 00 12 be 8b 4b  a6 a7 7a 62 45 32 ff db  |.......K..zbE2..|
+00000010  07 ad a0 1b 46 9d c9 15  03 03 00 12 16 da d4 86  |....F...........|
+00000020  4f c8 26 5a d0 34 82 fe  47 34 ae 31 db a7        |O.&Z.4..G4.1..|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-SCT b/src/crypto/tls/testdata/Client-TLSv12-SCT
index d12e263e15..8492ee94c4 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-SCT
+++ b/src/crypto/tls/testdata/Client-TLSv12-SCT
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,11 +16,11 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 01 c6 02 00 01  c2 03 03 d8 a9 75 cc 9a  |.............u..|
-00000010  81 df 5a a0 3b ba 51 74  52 50 72 08 35 02 35 77  |..Z.;.QtRPr.5.5w|
-00000020  28 ff 44 e6 d9 c6 8b f8  54 67 b4 20 62 80 60 cc  |(.D.....Tg. b.`.|
-00000030  09 90 52 66 75 72 a2 c5  dc 8d 18 ce 9a d5 7e cd  |..Rfur........~.|
-00000040  a5 36 2a 2e 65 72 6f f0  dd b0 8c 14 cc a8 00 01  |.6*.ero.........|
+00000000  16 03 03 01 c6 02 00 01  c2 03 03 b0 59 eb bc ae  |............Y...|
+00000010  f3 42 03 d1 fe 2c 7d 6f  0e ff e4 0c 9e 13 00 b9  |.B...,}o........|
+00000020  46 99 e2 84 49 64 a9 05  05 8a fb 20 16 12 dc b7  |F...Id..... ....|
+00000030  e0 09 a2 a6 56 83 43 54  de 40 53 47 43 f0 2f c9  |....V.CT.@SGC./.|
+00000040  2d 92 5e a0 9d a3 6a c4  55 17 01 cb cc a8 00 01  |-.^...j.U.......|
 00000050  7a 00 12 01 69 01 67 00  75 00 a4 b9 09 90 b4 18  |z...i.g.u.......|
 00000060  58 14 87 bb 13 a2 cc 67  70 0a 3c 35 98 04 f9 1b  |X......gp.<5....|
 00000070  df b8 e3 77 cd 0e c8 0d  dc 10 00 00 01 47 97 99  |...w.........G..|
@@ -83,31 +83,31 @@
 00000400  1c f1 0f a1 d8 40 83 61  c9 4c 72 2b 9d ae db 46  |.....@.a.Lr+...F|
 00000410  06 06 4d f4 c1 b3 3e c0  d1 bd 42 d4 db fe 3d 13  |..M...>...B...=.|
 00000420  60 84 5c 21 d3 3b e9 fa  e7 16 03 03 00 ac 0c 00  |`.\!.;..........|
-00000430  00 a8 03 00 1d 20 cd 2a  10 ee 97 4a 83 7b 0e 6d  |..... .*...J.{.m|
-00000440  e7 00 5a ce bc d8 1c 57  fa f6 ec 52 0d 0f be 6d  |..Z....W...R...m|
-00000450  c8 5d 27 3c 8c 1b 08 04  00 80 a9 4c bb 3a 0a d7  |.]'<.......L.:..|
-00000460  db 72 3d 88 49 a6 0b f7  dc d5 e1 d0 07 e8 6c fa  |.r=.I.........l.|
-00000470  b0 5e 0b 13 27 29 6f 1f  1e b9 05 60 16 cc ea 7b  |.^..')o....`...{|
-00000480  46 d7 12 58 03 43 b0 fe  8e 7b 83 3b ee 11 78 8c  |F..X.C...{.;..x.|
-00000490  60 0f 9c 76 63 60 01 78  a0 9b 19 b9 32 99 a9 9d  |`..vc`.x....2...|
-000004a0  42 b8 1f f1 8b 87 07 32  fa 5e 74 d5 3e 5e ba 21  |B......2.^t.>^.!|
-000004b0  ff 63 b7 c6 68 bc b3 f9  52 1a ea 23 c7 f2 ec ff  |.c..h...R..#....|
-000004c0  d4 10 0d f8 76 2f bc 0d  e5 12 7f ee d3 8d 9e 6b  |....v/.........k|
-000004d0  5e 22 78 d6 fa 5e 6a 53  16 44 16 03 03 00 04 0e  |^"x..^jS.D......|
+00000430  00 a8 03 00 1d 20 4c 46  c9 9f ed 2e 81 0f 8c 4b  |..... LF.......K|
+00000440  bc 05 53 74 c6 c8 76 99  21 94 1b 8f 93 c6 64 ce  |..St..v.!.....d.|
+00000450  e9 9d 6b 1d 66 51 08 04  00 80 09 9e c2 21 89 93  |..k.fQ.......!..|
+00000460  1f c5 2e 2c fa 67 7b 42  23 e1 e0 67 5c 6d e9 1e  |...,.g{B#..g\m..|
+00000470  e8 a2 ac d7 cf f4 12 98  f6 e6 3d 51 0c 2c 29 ad  |..........=Q.,).|
+00000480  f8 8e 24 2a a3 99 2e f3  b2 a7 fe a9 6c e9 00 d8  |..$*........l...|
+00000490  6a 7f 41 12 84 a0 d6 19  38 b1 5a 13 b6 71 cf bd  |j.A.....8.Z..q..|
+000004a0  e2 6e 04 01 c8 cd 83 12  71 85 ae bc 94 b1 e4 4d  |.n......q......M|
+000004b0  a5 5f 9e a5 5d 95 76 fe  f5 d6 a9 f0 4c 07 c9 6e  |._..].v.....L..n|
+000004c0  fc 4a 56 2b 56 4e 9c ec  2c fe bc 9c 9e 57 f3 90  |.JV+VN..,....W..|
+000004d0  c6 6e 77 5a cf 8c 1a 15  cd 90 16 03 03 00 04 0e  |.nwZ............|
 000004e0  00 00 00                                          |...|
 >>> Flow 3 (client to server)
 00000000  16 03 03 00 25 10 00 00  21 20 2f e5 7d a3 47 cd  |....%...! /.}.G.|
 00000010  62 43 15 28 da ac 5f bb  29 07 30 ff f6 84 af c4  |bC.(.._.).0.....|
 00000020  cf c2 ed 90 99 5f 58 cb  3b 74 14 03 03 00 01 01  |....._X.;t......|
-00000030  16 03 03 00 20 5c 1a 1b  0e 7e 83 4f 9b f6 8e 9f  |.... \...~.O....|
-00000040  ca 95 86 c3 7b 60 73 d3  8d 3c 6d 18 6a eb 70 a3  |....{`s..<m.j.p.|
-00000050  d9 08 f7 77 a3                                    |...w.|
+00000030  16 03 03 00 20 19 bf ac  05 d4 bb 8a 6d 11 f4 98  |.... .......m...|
+00000040  0d af 78 57 49 74 5c 44  45 9e 2c 92 26 b9 10 b5  |..xWIt\DE.,.&...|
+00000050  6d 5f 24 bc a6                                    |m_$..|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 20 1f a2 50 dd c5  |.......... ..P..|
-00000010  ba 96 4a 63 e1 cc b6 45  77 09 c1 49 cb 5f eb 4b  |..Jc...Ew..I._.K|
-00000020  38 9b b1 40 1c af b1 a2  dc 7c ba                 |8..@.....|.|
+00000000  14 03 03 00 01 01 16 03  03 00 20 69 3a c4 9c ee  |.......... i:...|
+00000010  91 6b bc 33 39 82 64 c2  0a f0 a4 dd 85 16 3c ce  |.k.39.d.......<.|
+00000020  39 c4 98 37 77 47 1e c2  c6 d8 f6                 |9..7wG.....|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 16 e7 54 f6  bf 56 39 57 c4 b2 ac f2  |......T..V9W....|
-00000010  b1 f4 b1 2f ad ae d7 87  21 ff 1c 15 03 03 00 12  |.../....!.......|
-00000020  5d b6 56 77 55 99 b6 7b  a4 0b d8 8e 8d 93 b6 35  |].VwU..{.......5|
-00000030  ce 9a                                             |..|
+00000000  17 03 03 00 16 92 25 9b  97 11 08 71 63 b2 c1 35  |......%....qc..5|
+00000010  14 3b e7 15 f6 05 67 51  46 db ba 15 03 03 00 12  |.;....gQF.......|
+00000020  b2 53 a1 ec a8 cf 79 7d  f8 86 70 05 e5 81 a1 6c  |.S....y}..p....l|
+00000030  41 ab                                             |A.|
diff --git a/src/crypto/tls/testdata/Client-TLSv12-X25519-ECDHE b/src/crypto/tls/testdata/Client-TLSv12-X25519-ECDHE
index d58a32f2b3..3d3de611d0 100644
--- a/src/crypto/tls/testdata/Client-TLSv12-X25519-ECDHE
+++ b/src/crypto/tls/testdata/Client-TLSv12-X25519-ECDHE
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 75 00 05 00 05  01 00 00 00 00 00 0a 00  |...u............|
 00000090  04 00 02 00 1d 00 0b 00  02 01 00 00 0d 00 1a 00  |................|
 000000a0  18 08 04 04 03 08 07 08  05 08 06 04 01 05 01 06  |................|
@@ -16,11 +16,11 @@
 000000e0  43 15 28 da ac 5f bb 29  07 30 ff f6 84 af c4 cf  |C.(.._.).0......|
 000000f0  c2 ed 90 99 5f 58 cb 3b  74                       |...._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 59 02 00 00  55 03 03 e0 c7 ce be 3a  |....Y...U......:|
-00000010  a6 34 5f b7 c5 ec f1 f3  09 df 4d db 39 60 71 93  |.4_.......M.9`q.|
-00000020  db 7c 30 e0 81 93 f0 19  57 6b 6b 20 9e 4b e2 1e  |.|0.....Wkk .K..|
-00000030  27 8d d3 f6 0c f3 3d bc  67 3e 79 33 fd c9 cc 55  |'.....=.g>y3...U|
-00000040  36 55 a5 aa 89 94 fe b2  51 cf 24 56 c0 2f 00 00  |6U......Q.$V./..|
+00000000  16 03 03 00 59 02 00 00  55 03 03 f7 79 97 18 3c  |....Y...U...y..<|
+00000010  fa 52 c6 d2 6b 1e de a5  60 da d5 e2 0b f6 23 a8  |.R..k...`.....#.|
+00000020  48 94 e8 1f fb b9 76 43  94 e8 98 20 31 a5 85 d5  |H.....vC... 1...|
+00000030  2f c4 93 b1 ae aa 50 bc  14 9e 57 79 18 85 cd ef  |/.....P...Wy....|
+00000040  b4 f0 42 c9 6c b1 86 c1  03 27 ca df c0 2f 00 00  |..B.l....'.../..|
 00000050  0d ff 01 00 01 00 00 0b  00 04 03 00 01 02 16 03  |................|
 00000060  03 02 59 0b 00 02 55 00  02 52 00 02 4f 30 82 02  |..Y...U..R..O0..|
 00000070  4b 30 82 01 b4 a0 03 02  01 02 02 09 00 e8 f0 9d  |K0..............|
@@ -60,33 +60,33 @@
 00000290  77 8d 0c 1c f1 0f a1 d8  40 83 61 c9 4c 72 2b 9d  |w.......@.a.Lr+.|
 000002a0  ae db 46 06 06 4d f4 c1  b3 3e c0 d1 bd 42 d4 db  |..F..M...>...B..|
 000002b0  fe 3d 13 60 84 5c 21 d3  3b e9 fa e7 16 03 03 00  |.=.`.\!.;.......|
-000002c0  ac 0c 00 00 a8 03 00 1d  20 9b 73 58 2f 9a aa 8b  |........ .sX/...|
-000002d0  3e 80 1c b1 8e e5 d4 54  c2 d0 b1 94 16 86 e2 4b  |>......T.......K|
-000002e0  9c ab d7 ce 2c e5 26 20  04 08 04 00 80 d8 c0 18  |....,.& ........|
-000002f0  90 8e 06 d8 d6 4c af a1  ae 5e ca 4b a1 18 bb 31  |.....L...^.K...1|
-00000300  f5 3a 75 c3 d7 73 69 a7  e0 0f 8e f2 c5 92 0a bd  |.:u..si.........|
-00000310  7f 91 36 6c 01 c3 eb 08  9a 3b 25 2c bd 86 88 05  |..6l.....;%,....|
-00000320  64 e0 38 5b 75 01 10 1f  1b d5 34 09 04 2e 34 6d  |d.8[u.....4...4m|
-00000330  71 d2 6c b6 f3 7a 1e ed  a9 9d 28 60 13 fc 02 6f  |q.l..z....(`...o|
-00000340  f6 17 99 52 7b 19 60 e5  a6 11 d4 b3 4c 52 03 b5  |...R{.`.....LR..|
-00000350  3e 28 91 c6 66 87 25 df  10 c6 cf b9 5f 92 0e d7  |>(..f.%....._...|
-00000360  b6 19 f0 19 b9 f6 e9 e9  24 74 35 3b c6 16 03 03  |........$t5;....|
+000002c0  ac 0c 00 00 a8 03 00 1d  20 90 95 bd 82 cf 8a cc  |........ .......|
+000002d0  08 b4 09 09 8d 59 2d 03  7a bb 92 4a c4 5c 08 4d  |.....Y-.z..J.\.M|
+000002e0  42 a3 ba cb 9a 43 ae f0  22 08 04 00 80 a0 97 ac  |B....C..".......|
+000002f0  01 a5 c8 7b 4c 73 7e 70  7a 9a fc 9d 71 2f fe 67  |...{Ls~pz...q/.g|
+00000300  ca dd 6b 43 db 64 0f 64  52 e7 d3 5d 6d b2 7c 50  |..kC.d.dR..]m.|P|
+00000310  74 7e 80 d5 22 77 3f fb  c2 e8 dc 92 37 4f 1e 1e  |t~.."w?.....7O..|
+00000320  e7 13 f2 01 33 80 32 66  4f c2 17 8e ec 4f ed 4a  |....3.2fO....O.J|
+00000330  15 6c e8 86 ec df d5 46  6c a5 43 0d 40 fe a0 c8  |.l.....Fl.C.@...|
+00000340  65 b4 76 46 b8 36 2c da  87 7c 60 87 db 39 4c 2e  |e.vF.6,..|`..9L.|
+00000350  0f e4 72 32 11 26 99 7e  c8 7a c0 bc 9c a7 29 57  |..r2.&.~.z....)W|
+00000360  9d 27 37 4e ec c5 bb fd  a1 3c f3 66 63 16 03 03  |.'7N.....<.fc...|
 00000370  00 04 0e 00 00 00                                 |......|
 >>> Flow 3 (client to server)
 00000000  16 03 03 00 25 10 00 00  21 20 2f e5 7d a3 47 cd  |....%...! /.}.G.|
 00000010  62 43 15 28 da ac 5f bb  29 07 30 ff f6 84 af c4  |bC.(.._.).0.....|
 00000020  cf c2 ed 90 99 5f 58 cb  3b 74 14 03 03 00 01 01  |....._X.;t......|
-00000030  16 03 03 00 28 00 00 00  00 00 00 00 00 01 e4 5a  |....(..........Z|
-00000040  e9 dc dd 98 cd 5f d2 d2  eb 84 12 c9 96 ca 91 d7  |....._..........|
-00000050  ae f4 db 44 a4 37 f3 a3  b2 8d db ed 3d           |...D.7......=|
+00000030  16 03 03 00 28 00 00 00  00 00 00 00 00 81 b1 2c  |....(..........,|
+00000040  a2 3b 38 34 a6 66 57 02  e3 67 1b ee 73 95 50 de  |.;84.fW..g..s.P.|
+00000050  dd 5a fd 4e 0d ee b7 a6  46 1a 34 61 73           |.Z.N....F.4as|
 >>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 28 c2 2d 32 ba 46  |..........(.-2.F|
-00000010  27 8d 87 13 7f b9 49 04  64 2f 6e cc 32 81 f8 3c  |'.....I.d/n.2..<|
-00000020  7f 0f 19 13 5c 11 33 a1  05 5f 91 bc 97 30 64 84  |....\.3.._...0d.|
-00000030  57 69 90                                          |Wi.|
+00000000  14 03 03 00 01 01 16 03  03 00 28 2f a9 80 36 d8  |..........(/..6.|
+00000010  d0 74 e4 39 46 04 88 8e  91 ea fd 96 ed 1f 89 9f  |.t.9F...........|
+00000020  a4 e9 24 0e ca 48 2b 5c  5d f1 cc 57 ce 92 1a ad  |..$..H+\]..W....|
+00000030  b9 10 11                                          |...|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 1e 00 00 00  00 00 00 00 01 fd 0f a5  |................|
-00000010  74 98 c4 98 ee 67 74 d4  c1 d4 fe d3 c7 e2 1b 2c  |t....gt........,|
-00000020  e5 3c be 15 03 03 00 1a  00 00 00 00 00 00 00 02  |.<..............|
-00000030  f8 d4 60 41 13 6a 9c e3  0e 56 e2 ab 96 45 7e 06  |..`A.j...V...E~.|
-00000040  87 63                                             |.c|
+00000000  17 03 03 00 1e 00 00 00  00 00 00 00 01 da be 68  |...............h|
+00000010  97 b4 a4 72 d0 ed 75 66  6a a9 6f 39 8a 08 a9 db  |...r..ufj.o9....|
+00000020  de 4d e1 15 03 03 00 1a  00 00 00 00 00 00 00 02  |.M..............|
+00000030  14 90 0e 1d 26 5c 18 c6  5c 93 66 c4 90 78 a8 91  |....&\..\.f..x..|
+00000040  cb fd                                             |..|
diff --git a/src/crypto/tls/testdata/Client-TLSv13-AES128-SHA256 b/src/crypto/tls/testdata/Client-TLSv13-AES128-SHA256
index 4273484ca7..f8a733e3c2 100644
--- a/src/crypto/tls/testdata/Client-TLSv13-AES128-SHA256
+++ b/src/crypto/tls/testdata/Client-TLSv13-AES128-SHA256
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,75 +16,75 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 7a 02 00 00  76 03 03 f7 30 f3 d1 e7  |....z...v...0...|
-00000010  eb 94 97 a2 c6 d5 be 74  e0 6c 08 80 2f ad 11 6b  |.......t.l../..k|
-00000020  b3 ce 22 59 06 a9 eb 41  9c 97 a8 20 00 00 00 00  |.."Y...A... ....|
+00000000  16 03 03 00 7a 02 00 00  76 03 03 f1 4c f4 16 24  |....z...v...L..$|
+00000010  e5 c6 b5 ce 72 08 3b 33  9f 1f 1f 80 2c 10 0b 34  |....r.;3....,..4|
+00000020  01 99 85 ba b0 3c 85 50  3d bf 73 20 00 00 00 00  |.....<.P=.s ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 01 00 00  |................|
-00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 c0  |..+.....3.$... .|
-00000060  47 7e ad a1 41 53 e5 25  ec 74 46 bc 9e 80 08 3b  |G~..AS.%.tF....;|
-00000070  0b f5 7e fb 71 1f 00 d5  4b 27 51 22 4a 5e 5f 14  |..~.q...K'Q"J^_.|
-00000080  03 03 00 01 01 17 03 03  00 17 e9 e8 56 00 26 9e  |............V.&.|
-00000090  92 60 84 6c 07 3d b1 ef  e4 63 51 ba 48 ee d7 fe  |.`.l.=...cQ.H...|
-000000a0  57 17 03 03 02 6d 2e d4  bb bf a2 e8 3b 84 47 2e  |W....m......;.G.|
-000000b0  22 66 c1 98 ea 11 6b a3  4d 1b 64 c0 02 32 76 9b  |"f....k.M.d..2v.|
-000000c0  29 8a 4a 96 68 5b d1 fd  a0 0f a6 9b 70 20 c7 08  |).J.h[......p ..|
-000000d0  7b 25 07 d1 54 8c b1 bb  4e ba 32 65 2c 1e 16 29  |{%..T...N.2e,..)|
-000000e0  e7 d2 df e3 84 60 e1 43  07 99 35 4d 95 7c 27 96  |.....`.C..5M.|'.|
-000000f0  be f4 bf 0a e9 3b 9d 60  7a 6e 34 82 1f 03 ca 17  |.....;.`zn4.....|
-00000100  ac d1 a1 b5 dc 3f 20 7b  42 f6 94 43 60 ff 3f 1b  |.....? {B..C`.?.|
-00000110  b1 2e 2d 71 55 07 fb 65  40 56 59 82 1e 31 83 c9  |..-qU..e@VY..1..|
-00000120  35 6c 28 ad c1 bd 88 55  1b b6 1e 89 af 64 7f 11  |5l(....U.....d..|
-00000130  53 80 3a 62 ef 34 a7 d0  ce 38 9b 19 d6 5f 78 0d  |S.:b.4...8..._x.|
-00000140  66 73 b2 bd b6 a6 f8 70  c8 40 f9 aa a2 86 f4 48  |fs.....p.@.....H|
-00000150  0d 6c 54 67 c6 3c 91 97  ff 94 4d 9a 01 d5 e1 c9  |.lTg.<....M.....|
-00000160  8f 27 d3 8d b3 72 cd 34  eb 7a 6d 48 84 f3 8b 84  |.'...r.4.zmH....|
-00000170  34 d2 68 bd 26 bc 6d e5  46 41 cc 86 d4 7a b6 31  |4.h.&.m.FA...z.1|
-00000180  05 b3 bc a4 fe e1 5c d4  eb 8b fe 64 0e be 89 c4  |......\....d....|
-00000190  ce e0 49 a0 ba 7a 83 b6  fb 31 17 42 fd b4 e3 59  |..I..z...1.B...Y|
-000001a0  48 df f6 a8 e4 5c d1 77  77 cb c2 31 85 8a 26 65  |H....\.ww..1..&e|
-000001b0  20 fa 05 90 ae 66 95 7a  75 4b bc 93 15 dd a0 13  | ....f.zuK......|
-000001c0  61 d5 99 fb b2 27 bd ec  fd 10 b5 d2 c7 18 ac b9  |a....'..........|
-000001d0  bd bc 35 72 d0 42 6c f7  5a e0 67 46 45 10 f7 50  |..5r.Bl.Z.gFE..P|
-000001e0  e4 14 47 ac 39 5a 05 38  b9 25 4a 43 fa 57 b2 51  |..G.9Z.8.%JC.W.Q|
-000001f0  b7 3e f7 ef d5 b5 de 2e  2f 5c d0 d7 00 23 ac 4b  |.>....../\...#.K|
-00000200  65 8d 6c f4 ab 6f ef 1e  c2 66 c5 b2 cb 1a 51 4c  |e.l..o...f....QL|
-00000210  ef 96 8f 28 65 2f 50 9c  91 1f 73 87 fc 81 db 90  |...(e/P...s.....|
-00000220  16 69 00 06 98 6b 00 33  41 e1 e6 12 89 cb c9 f3  |.i...k.3A.......|
-00000230  23 2c 28 83 00 ca 4f 42  f5 26 bc 94 39 3b 18 31  |#,(...OB.&..9;.1|
-00000240  41 a9 19 4a 60 e8 de 8f  1d d0 e8 96 77 c0 49 bd  |A..J`.......w.I.|
-00000250  a2 98 bd b1 0a 6f bd 27  79 1d c4 33 50 37 a8 eb  |.....o.'y..3P7..|
-00000260  a5 4e 59 87 58 cd f0 a0  34 4e 2b 9d ee 03 e4 8a  |.NY.X...4N+.....|
-00000270  24 94 86 11 e1 94 f0 2b  3e 27 9a 92 1c 17 d3 96  |$......+>'......|
-00000280  c0 71 ab ee 75 5f 99 ca  0e 42 65 5d ed 48 0c 7a  |.q..u_...Be].H.z|
-00000290  95 8a d9 da f7 60 ee de  46 f2 f4 7a d6 ce 38 41  |.....`..F..z..8A|
-000002a0  fa e8 1f 3e 77 be 02 53  0c 33 96 5b 0d 38 bb 08  |...>w..S.3.[.8..|
-000002b0  5e 92 1a 81 f1 be c7 9a  e2 02 80 09 3b b7 62 b0  |^...........;.b.|
-000002c0  7c a7 85 3a d9 52 34 23  4f a3 04 e7 35 98 9e 18  ||..:.R4#O...5...|
-000002d0  13 0b 71 12 6d a4 2e 11  bf 39 8c 94 ef 15 96 27  |..q.m....9.....'|
-000002e0  9e be 81 d9 55 5a 8b 14  c5 49 dd 6e 6e 7b 6b c2  |....UZ...I.nn{k.|
-000002f0  f3 7d ef 24 88 b9 eb a6  15 3e aa a8 3e eb 37 54  |.}.$.....>..>.7T|
-00000300  fc 86 9f 51 30 5f 9c a5  fc 7a af f6 1b a5 a4 27  |...Q0_...z.....'|
-00000310  51 78 f7 17 03 03 00 99  79 14 63 10 91 cd 73 f5  |Qx......y.c...s.|
-00000320  a8 62 c3 92 a3 04 c2 3d  58 5e d3 6e 93 eb 9b b1  |.b.....=X^.n....|
-00000330  11 f0 3c c6 96 9f c6 c8  9b de 2c d5 12 c2 bd d1  |..<.......,.....|
-00000340  2a 68 89 4a 07 1e 23 d2  45 ca a1 0f 92 71 b7 f7  |*h.J..#.E....q..|
-00000350  d0 2f 2a be d0 5e 0c 5d  13 8f b0 7f df b8 52 2e  |./*..^.]......R.|
-00000360  7a 5e c8 eb 84 06 46 81  d0 f7 09 18 52 fb ce fd  |z^....F.....R...|
-00000370  22 d8 74 71 e8 7d 41 5f  3a 5d e5 f9 bb e6 99 03  |".tq.}A_:]......|
-00000380  32 d1 58 e8 5a 58 d8 b2  39 61 01 33 72 7d d2 11  |2.X.ZX..9a.3r}..|
-00000390  8f f7 58 55 c8 f2 64 63  33 9b 78 36 bf 9b 8b 40  |..XU..dc3.x6...@|
-000003a0  8c ec 7b a2 bb 51 ed b1  fe 74 c2 c9 1f b4 2b cb  |..{..Q...t....+.|
-000003b0  fd 17 03 03 00 35 75 46  88 74 06 9b 5e 88 c2 0d  |.....5uF.t..^...|
-000003c0  fc 7d 29 bd 6c 1c 23 2f  06 3f 14 b1 55 e4 98 b1  |.}).l.#/.?..U...|
-000003d0  ed c3 9a ed ea be 29 60  15 ac 80 c7 a8 f7 9b ce  |......)`........|
-000003e0  f3 79 b3 be ad ff ab b4  a7 45 57                 |.y.......EW|
+00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 69  |..+.....3.$... i|
+00000060  94 3b 83 cd 1f 93 53 53  82 de 14 cb 76 2a 19 62  |.;....SS....v*.b|
+00000070  0f f8 9e d1 e3 e0 a9 d5  23 ac 07 64 53 27 4b 14  |........#..dS'K.|
+00000080  03 03 00 01 01 17 03 03  00 17 ef 24 2c ea 6f 05  |...........$,.o.|
+00000090  c2 07 7a d2 12 30 ce 01  f4 96 b8 dc e6 c2 27 02  |..z..0........'.|
+000000a0  bd 17 03 03 02 6d 99 2b  cb 79 43 01 66 24 eb f1  |.....m.+.yC.f$..|
+000000b0  14 d2 ea 1e 57 67 81 e3  a0 9c 99 1b 1f d5 f0 c7  |....Wg..........|
+000000c0  78 48 61 01 42 25 85 0b  cd a1 b1 75 3c 50 01 cc  |xHa.B%.....u<P..|
+000000d0  69 09 22 a5 fb db 43 76  2f 4e 34 4e 14 a3 e4 89  |i."...Cv/N4N....|
+000000e0  f7 d7 cd 66 da b3 1d fd  f0 98 60 18 41 09 a5 22  |...f......`.A.."|
+000000f0  6d c9 21 bc c3 cd 53 ca  c3 a5 d7 24 57 b4 f5 bc  |m.!...S....$W...|
+00000100  ec b1 48 70 12 55 a5 a6  01 10 68 0f c4 e5 de 89  |..Hp.U....h.....|
+00000110  f9 0d ab 48 92 d4 12 d7  75 77 c3 2f ae 2f 6f 58  |...H....uw././oX|
+00000120  2d 6e ad 72 43 dc ce 4b  c9 74 3d eb db da 37 2c  |-n.rC..K.t=...7,|
+00000130  1e a2 86 c4 b3 64 69 f6  84 ce 52 b5 32 c6 b9 c2  |.....di...R.2...|
+00000140  49 2d 08 f9 d4 9a 29 09  5b 71 09 81 a3 19 c2 4d  |I-....).[q.....M|
+00000150  8c 48 2c e3 c6 cb 81 d4  7f 10 b3 c8 2b 21 ad 83  |.H,.........+!..|
+00000160  97 d2 bd 11 90 39 1e f4  de 65 e2 e8 e8 c7 ce f9  |.....9...e......|
+00000170  6d ad b0 60 5c 4b 59 c4  96 ce b3 a1 83 b2 7c 71  |m..`\KY.......|q|
+00000180  74 e6 a9 a7 89 bf 8d 0d  6c 8d b5 04 33 38 ff 68  |t.......l...38.h|
+00000190  42 0e 84 da d2 b2 16 29  83 66 82 a9 2a d2 67 1b  |B......).f..*.g.|
+000001a0  18 a6 7d e3 f1 d3 f1 b4  cc 6c 14 e2 cd 2d 96 7b  |..}......l...-.{|
+000001b0  76 dd b0 1d 24 7f ea c0  14 24 d7 37 00 7c cd e3  |v...$....$.7.|..|
+000001c0  20 33 a4 3a 22 2a be 3e  e8 f8 7c 0d 3e 51 f7 6b  | 3.:"*.>..|.>Q.k|
+000001d0  ce f3 51 cf 7e ae 55 40  bb ab 0e 40 6b d9 8a 3b  |..Q.~.U@...@k..;|
+000001e0  d5 f2 1f 76 6a 05 9b 87  e2 3b db fa cc e8 93 8a  |...vj....;......|
+000001f0  d9 ba 2b 63 77 77 62 f1  22 ce 11 a9 26 b5 e8 a2  |..+cwwb."...&...|
+00000200  ec 3f 98 44 01 27 d7 e1  39 26 33 e3 86 00 60 f7  |.?.D.'..9&3...`.|
+00000210  a7 91 07 45 f8 3f 78 dc  88 71 30 26 0c f9 0d 51  |...E.?x..q0&...Q|
+00000220  2a c5 ce 33 ac b7 91 a9  74 2e 46 68 80 6e 62 cd  |*..3....t.Fh.nb.|
+00000230  2d 5e 43 fe bd d1 37 07  71 85 5d c7 38 17 50 3a  |-^C...7.q.].8.P:|
+00000240  1c 5e 9f cf 1e 3c 96 d0  26 5d 4c 82 78 a8 69 e7  |.^...<..&]L.x.i.|
+00000250  d3 9a 81 e5 85 66 c3 d9  74 a1 82 9d fb 24 81 13  |.....f..t....$..|
+00000260  0d ce cb 43 61 3c 3a a7  d1 80 7f 1d 41 d8 62 43  |...Ca<:.....A.bC|
+00000270  c6 08 5d 91 05 ed 2c 50  04 42 8c db 2a 11 61 96  |..]...,P.B..*.a.|
+00000280  9b d2 1d 40 af 83 ed 93  06 ba 65 22 0a a5 e8 a6  |...@......e"....|
+00000290  b9 4a 63 6f c0 ac da 72  10 24 c6 ed 08 86 c8 a1  |.Jco...r.$......|
+000002a0  92 5e d0 d8 8b 04 b7 43  50 0b 03 41 3f f9 96 16  |.^.....CP..A?...|
+000002b0  a3 c8 09 e8 ac 91 b2 45  d5 58 5f 41 05 7c b3 88  |.......E.X_A.|..|
+000002c0  7a 59 cd 1a 00 86 29 72  77 a5 19 43 32 79 fc d6  |zY....)rw..C2y..|
+000002d0  d7 e9 81 08 e3 d9 d9 56  39 59 7c 1e d3 10 3e a4  |.......V9Y|...>.|
+000002e0  c6 80 d3 8b 9b 36 51 c5  d3 14 64 a6 65 e2 1a 26  |.....6Q...d.e..&|
+000002f0  c4 a8 31 07 bb 58 8c 9b  d8 7d 86 fd 54 6c c9 ae  |..1..X...}..Tl..|
+00000300  7d 88 4b 13 0f 52 10 41  d6 be 01 32 f2 42 47 0f  |}.K..R.A...2.BG.|
+00000310  7a 8c 7e 17 03 03 00 99  8b ce c4 db 9c 9c 88 e3  |z.~.............|
+00000320  88 58 de 8f 10 e9 fb 4a  c7 26 96 60 48 84 2c b1  |.X.....J.&.`H.,.|
+00000330  2b 6c 35 70 8a d7 39 91  51 d7 3f db 81 f0 41 07  |+l5p..9.Q.?...A.|
+00000340  a2 c9 c1 74 76 62 58 f1  cb e2 50 48 57 bb 6e 3d  |...tvbX...PHW.n=|
+00000350  ee ee 4a 53 e7 3c 66 aa  e3 d9 c1 f1 74 1a 93 b9  |..JS.<f.....t...|
+00000360  44 90 f6 a5 a4 da f5 6b  75 01 38 52 8f 9c ab 01  |D......ku.8R....|
+00000370  78 88 a6 cc 65 15 61 a8  8c cc 14 59 07 ea 6f 25  |x...e.a....Y..o%|
+00000380  5c 86 89 16 eb e7 da 20  82 d7 96 e4 78 7a c3 36  |\...... ....xz.6|
+00000390  b3 5c e7 17 1b 07 30 a2  72 ca a2 f3 dc 7e 45 c9  |.\....0.r....~E.|
+000003a0  7f 94 f8 a1 7b bb 2a 30  d7 bc 51 03 fb e6 2a fa  |....{.*0..Q...*.|
+000003b0  17 17 03 03 00 35 c1 a0  76 b6 35 4b 5c 26 94 c6  |.....5..v.5K\&..|
+000003c0  ba b1 7b b1 13 00 f2 2c  17 ed ac ab 47 9a a1 8d  |..{....,....G...|
+000003d0  3a 1c 78 44 14 a1 04 31  3d eb 9a 8d bb 2f 73 46  |:.xD...1=..../sF|
+000003e0  cb 5c f6 86 81 fa 56 fb  39 8c 55                 |.\....V.9.U|
 >>> Flow 3 (client to server)
-00000000  14 03 03 00 01 01 17 03  03 00 35 b5 22 19 23 49  |..........5.".#I|
-00000010  48 33 a5 f3 b2 72 2b 31  ab 89 27 f9 eb 1b b7 b1  |H3...r+1..'.....|
-00000020  bc 2b 99 9e 73 24 42 c4  2a 68 2c 76 e1 45 61 09  |.+..s$B.*h,v.Ea.|
-00000030  18 c7 44 45 9a 05 86 4c  90 c1 41 c6 fd 6a c2 95  |..DE...L..A..j..|
-00000040  17 03 03 00 17 ee 18 4e  d9 94 15 50 a9 99 4a 82  |.......N...P..J.|
-00000050  10 13 26 7b 74 10 db ef  fe b8 96 f6 17 03 03 00  |..&{t...........|
-00000060  13 2a 4c 52 8d c3 c5 af  d0 cd 5a 7d 0d a5 59 90  |.*LR......Z}..Y.|
-00000070  ce 59 3b af                                       |.Y;.|
+00000000  14 03 03 00 01 01 17 03  03 00 35 97 2c 39 3a a5  |..........5.,9:.|
+00000010  32 33 e5 74 43 97 98 ef  ef 30 de 27 8b f7 b5 ab  |23.tC....0.'....|
+00000020  dd af 87 7c a5 5e 76 cf  50 2a 03 f8 94 a4 7a df  |...|.^v.P*....z.|
+00000030  14 0a 2d 39 57 3b 02 97  c5 d7 63 85 21 3f 55 27  |..-9W;....c.!?U'|
+00000040  17 03 03 00 17 7c b4 8b  82 f0 0a ec 6f fa 60 ef  |.....|......o.`.|
+00000050  4c 0a 1c 0b ad 99 c3 89  fb a4 40 2c 17 03 03 00  |L.........@,....|
+00000060  13 f2 d5 58 ba 6b ca e8  f4 14 4c 66 23 38 f2 e8  |...X.k....Lf#8..|
+00000070  ea a9 ba c1                                       |....|
diff --git a/src/crypto/tls/testdata/Client-TLSv13-AES256-SHA384 b/src/crypto/tls/testdata/Client-TLSv13-AES256-SHA384
index 7fecc79add..8ea3ed6788 100644
--- a/src/crypto/tls/testdata/Client-TLSv13-AES256-SHA384
+++ b/src/crypto/tls/testdata/Client-TLSv13-AES256-SHA384
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,77 +16,77 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 7a 02 00 00  76 03 03 dd df 8d 85 da  |....z...v.......|
-00000010  3c 99 a3 0c 01 90 5f ec  b8 3d 28 ce e4 32 c0 e8  |<....._..=(..2..|
-00000020  fe 77 03 ad 0f e1 33 1f  dc 89 cb 20 00 00 00 00  |.w....3.... ....|
+00000000  16 03 03 00 7a 02 00 00  76 03 03 71 00 90 30 07  |....z...v..q..0.|
+00000010  24 01 ae 33 b2 e8 4f 1f  9a 2c 83 e5 7b 30 1e a2  |$..3..O..,..{0..|
+00000020  8e 4a d0 df d1 ec 23 b5  ba aa 75 20 00 00 00 00  |.J....#...u ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 02 00 00  |................|
-00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 03  |..+.....3.$... .|
-00000060  6b 91 90 36 f0 54 da 66  8e 47 9b 26 9f 9f ae 30  |k..6.T.f.G.&...0|
-00000070  69 9e a2 6a 70 fb ef b2  f1 76 2b 32 90 0e 63 14  |i..jp....v+2..c.|
-00000080  03 03 00 01 01 17 03 03  00 17 46 47 2e ae ea 9b  |..........FG....|
-00000090  78 7b 0c d4 74 e2 b5 bf  7b 64 da c3 d3 c9 55 7f  |x{..t...{d....U.|
-000000a0  e3 17 03 03 02 6d a8 c1  57 27 66 9d 16 f6 4f 1b  |.....m..W'f...O.|
-000000b0  17 b6 5d 8c 3c fe f5 d5  4a d3 c6 8d e2 a8 2d d0  |..].<...J.....-.|
-000000c0  01 8d db 18 e8 c8 69 74  eb 81 9e 97 20 01 60 d5  |......it.... .`.|
-000000d0  96 d1 8f 9c de 09 ff 1d  e7 45 97 97 36 fa 89 77  |.........E..6..w|
-000000e0  88 20 30 c6 5b 42 d6 0e  85 9a 11 43 60 a1 86 34  |. 0.[B.....C`..4|
-000000f0  22 47 25 23 a5 35 87 a9  74 5d fe eb c9 70 32 44  |"G%#.5..t]...p2D|
-00000100  17 60 55 99 7a 93 b5 92  8b 66 31 ce dc e0 39 f2  |.`U.z....f1...9.|
-00000110  6a b3 db 43 5d 3f ba e5  12 12 1f 0e 3c 35 3b 72  |j..C]?......<5;r|
-00000120  9f 9d 69 d5 d6 cb ac b5  9e f4 af f5 74 68 67 f4  |..i.........thg.|
-00000130  e9 5f a4 4a d7 27 5b a5  2a 39 b7 30 49 4d 64 bb  |._.J.'[.*9.0IMd.|
-00000140  5d 89 10 ff a6 2c 42 a1  4a 2a 0c 28 c6 cd 4a e8  |]....,B.J*.(..J.|
-00000150  7d 24 d0 75 ff 61 08 3f  3b 05 ec f3 d6 61 ed 43  |}$.u.a.?;....a.C|
-00000160  08 5e 07 1c f2 15 96 22  2a c0 3c 5f 04 d1 17 82  |.^....."*.<_....|
-00000170  ea ee ee c7 49 cc 3e e4  65 15 97 6e 6f 36 24 a9  |....I.>.e..no6$.|
-00000180  27 34 3a 75 dc 07 1e 4c  f1 29 d1 e3 22 31 7d 84  |'4:u...L.).."1}.|
-00000190  a8 2a 7f 37 03 ab 13 ae  15 e2 74 50 bd 54 5b 32  |.*.7......tP.T[2|
-000001a0  ea 75 10 ed 39 5c 69 90  f6 74 09 53 c1 ce 44 49  |.u..9\i..t.S..DI|
-000001b0  64 fb f2 c6 bd 93 b2 07  06 96 94 04 a5 9e ed 67  |d..............g|
-000001c0  10 cb 01 fc 85 45 d7 22  76 3c c6 2f 14 4c 31 e1  |.....E."v<./.L1.|
-000001d0  73 81 7b 8b 6b 54 d6 34  15 d2 eb d0 03 10 c7 3d  |s.{.kT.4.......=|
-000001e0  f5 07 48 cc 72 9b e9 48  ee 13 9f 80 b5 13 86 77  |..H.r..H.......w|
-000001f0  33 91 79 6f f2 13 17 68  ca 72 6b 0d 93 9a 20 30  |3.yo...h.rk... 0|
-00000200  70 c3 30 ab 13 7e 14 39  97 4b ce c5 3d 8b 03 7f  |p.0..~.9.K..=...|
-00000210  cd 4b 67 c4 c5 79 0c bb  cd ba 17 c5 d5 15 51 cb  |.Kg..y........Q.|
-00000220  ac b7 f7 19 43 ff f5 c4  09 8c 44 67 ca e6 a1 5f  |....C.....Dg..._|
-00000230  1d 27 29 63 f2 0d 75 6d  b7 62 52 c9 1d 8e 0e 3b  |.')c..um.bR....;|
-00000240  6c cb 04 3e f7 13 74 bb  03 35 2e 4e 41 9a b7 72  |l..>..t..5.NA..r|
-00000250  15 ed 02 79 c7 bc 38 b3  65 75 0a 8e 82 dc d4 79  |...y..8.eu.....y|
-00000260  1c 10 3f 78 8c be 78 b0  73 18 cc 52 1d 3b 91 66  |..?x..x.s..R.;.f|
-00000270  33 fe 63 b2 ec 19 92 44  8f 06 4e 20 85 94 5c b4  |3.c....D..N ..\.|
-00000280  ad 22 16 a0 b3 76 03 dc  62 e9 0c ac 8c e1 67 c9  |."...v..b.....g.|
-00000290  d8 6f 40 51 b5 39 9a 61  b6 63 e0 d5 60 6a 27 78  |.o@Q.9.a.c..`j'x|
-000002a0  62 ec 94 1c 75 2c 38 f2  a6 f2 f0 c4 8f 98 ad cc  |b...u,8.........|
-000002b0  2e ce 7d 13 76 f4 4f 94  78 3f 85 cf ea 52 c4 6e  |..}.v.O.x?...R.n|
-000002c0  16 65 f9 48 5e f9 0b 07  bc 3e 38 91 06 e1 b0 76  |.e.H^....>8....v|
-000002d0  82 60 25 03 36 9c 3e 5e  54 73 8d cf df 91 19 33  |.`%.6.>^Ts.....3|
-000002e0  a7 18 96 d4 86 ea 7c 00  88 e6 a3 fe ea a1 14 db  |......|.........|
-000002f0  ae da 07 ef 1e 6f 16 bb  ad fb c0 f4 60 2f 75 5c  |.....o......`/u\|
-00000300  a4 43 a0 fc 3c d6 5e 89  cf 6e 1a c6 de 61 65 34  |.C..<.^..n...ae4|
-00000310  03 e5 cd 17 03 03 00 99  0a f3 a2 45 fe 53 22 37  |...........E.S"7|
-00000320  cd 31 9d 67 31 56 f9 99  c2 d1 bc 6d 47 de 9a e7  |.1.g1V.....mG...|
-00000330  67 c0 89 84 ac bf 27 b5  32 f0 e9 a5 9d f2 e0 ad  |g.....'.2.......|
-00000340  fd 12 6a a4 5d 50 4c b9  ed f1 f4 0e c0 c0 6c c4  |..j.]PL.......l.|
-00000350  39 9b 10 02 fa 10 64 a6  8b af 9d 6e d9 40 6d 0c  |9.....d....n.@m.|
-00000360  b0 6c b8 8d d5 b0 14 f0  ed 85 d6 66 8f 6f 61 43  |.l.........f.oaC|
-00000370  49 dd 95 08 94 2e a8 a6  19 b9 7b 6b 99 09 af 4c  |I.........{k...L|
-00000380  5f 41 48 da 10 b6 cf ee  68 b6 6e 03 d7 29 93 8e  |_AH.....h.n..)..|
-00000390  1a ab d1 ad d4 bf 33 2a  53 87 92 05 d1 1a de c0  |......3*S.......|
-000003a0  aa ef b9 9c 4d 2d f6 b1  72 60 22 80 bb 46 24 75  |....M-..r`"..F$u|
-000003b0  35 17 03 03 00 45 46 9e  b3 7f d0 82 b6 ef 45 1f  |5....EF.......E.|
-000003c0  18 6d 3b b6 23 f5 c9 f4  54 e3 08 d0 8b 30 c7 31  |.m;.#...T....0.1|
-000003d0  af 98 26 69 b7 6e 08 1d  1f be 1a 7e 5b 97 91 28  |..&i.n.....~[..(|
-000003e0  fa b7 78 05 ee 3f a1 9e  a0 79 fc 45 51 4c 96 fb  |..x..?...y.EQL..|
-000003f0  03 46 24 7d fe ec a4 40  51 d6 73                 |.F$}...@Q.s|
+00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 06  |..+.....3.$... .|
+00000060  2a 26 bd 81 c2 90 9b 17  6e d0 b5 ab 72 e6 93 ce  |*&......n...r...|
+00000070  53 6d 8c 54 b5 a4 50 91  93 32 6e 88 e6 b2 69 14  |Sm.T..P..2n...i.|
+00000080  03 03 00 01 01 17 03 03  00 17 7d 11 37 f0 18 b1  |..........}.7...|
+00000090  53 55 38 bb 12 7c e8 b3  89 bc 35 fb 2a 36 d1 0f  |SU8..|....5.*6..|
+000000a0  3a 17 03 03 02 6d a0 fa  dc 8e ac a6 90 5a 20 0e  |:....m.......Z .|
+000000b0  ee 22 89 7b 69 5b c9 1a  a1 c6 43 b9 40 f6 85 78  |.".{i[....C.@..x|
+000000c0  61 0b 14 c6 e6 3b a9 ac  4c 7a 96 9b 7b 87 d0 ce  |a....;..Lz..{...|
+000000d0  42 cc 75 9d fc 06 44 3e  e8 12 3a 94 b7 de 86 c4  |B.u...D>..:.....|
+000000e0  b5 66 e1 f5 48 21 f7 f1  58 7f 23 6c 3f 76 a0 cb  |.f..H!..X.#l?v..|
+000000f0  a7 f6 72 34 07 fa c1 55  3e 61 cf 72 c4 6c f1 ca  |..r4...U>a.r.l..|
+00000100  dd dc ec 66 3d 7b f6 cf  53 3b 28 bd 27 1b aa a6  |...f={..S;(.'...|
+00000110  28 2a ab fa 48 a5 08 67  b5 49 c7 c7 5d f8 2c ec  |(*..H..g.I..].,.|
+00000120  83 af 58 33 42 6c c1 4c  94 17 7e 36 1c a9 48 34  |..X3Bl.L..~6..H4|
+00000130  5f 26 78 f6 69 88 3a a5  1b d1 76 ad 88 63 25 33  |_&x.i.:...v..c%3|
+00000140  0d e3 d0 34 6b 7f fc 96  2b 8d 22 6f 3f 21 8a 14  |...4k...+."o?!..|
+00000150  01 e0 5c 54 6c c3 b8 12  f9 17 f5 4c ce e0 bd 10  |..\Tl......L....|
+00000160  e7 e1 29 24 73 94 c2 5e  b0 ad d3 91 9e 87 ea 23  |..)$s..^.......#|
+00000170  4d fd 8f 12 ca 87 ff 2e  93 9f 16 a8 18 e1 66 8f  |M.............f.|
+00000180  50 76 15 cd 70 5c a2 1d  91 51 e5 54 13 5f 73 d3  |Pv..p\...Q.T._s.|
+00000190  b2 6e b1 27 80 0b 3d 64  d5 fa f3 a4 fb 77 33 cb  |.n.'..=d.....w3.|
+000001a0  ac 93 54 36 2d 71 c3 9e  dd 37 02 a9 9d b0 9b ac  |..T6-q...7......|
+000001b0  f8 c5 dc 43 9b d8 db c7  d0 fb cf 69 fa 62 e4 9d  |...C.......i.b..|
+000001c0  b7 04 f8 49 d3 a7 8d bd  cf 8a e3 4a 62 cb bb 29  |...I.......Jb..)|
+000001d0  b5 db 21 80 76 eb 28 67  34 1e 40 0b 83 83 19 10  |..!.v.(g4.@.....|
+000001e0  46 8f bd 78 d6 7c 05 c2  19 82 1c e8 7d 84 f2 79  |F..x.|......}..y|
+000001f0  c4 a6 e0 f7 7e df 70 7f  42 48 9f e4 99 03 7f 9e  |....~.p.BH......|
+00000200  e8 fd 75 c3 8a 55 55 8e  08 2e 62 28 a5 16 b7 11  |..u..UU...b(....|
+00000210  d8 9a 11 48 46 ad d3 ba  4f 91 c8 fd 72 d9 df 98  |...HF...O...r...|
+00000220  1a 59 51 55 af ab 73 b9  f3 bf fe 7d 55 7d 44 54  |.YQU..s....}U}DT|
+00000230  cd bb f3 eb 6e ff 5a 09  e9 b9 c1 66 97 8e a5 7c  |....n.Z....f...||
+00000240  89 4a 51 1d 8b e4 40 fb  97 ce ef 9d 7c 02 e4 db  |.JQ...@.....|...|
+00000250  f1 ca 01 d9 05 b4 de 10  23 33 92 ff 26 3b 09 8f  |........#3..&;..|
+00000260  11 7c 37 ad fb 58 ed 7a  10 08 fd df 98 dd d6 c5  |.|7..X.z........|
+00000270  b8 fd 59 37 21 1d 6e 27  8a 56 24 45 e7 64 61 0b  |..Y7!.n'.V$E.da.|
+00000280  20 2d bc 79 89 fa 6d 7a  06 77 61 0c 60 25 e2 79  | -.y..mz.wa.`%.y|
+00000290  6a 54 9e 5b 4b 33 68 17  da 63 ba a7 f9 ad 2c 84  |jT.[K3h..c....,.|
+000002a0  52 e9 27 85 71 74 d2 5f  c9 f8 8e 67 f7 47 58 f5  |R.'.qt._...g.GX.|
+000002b0  e4 72 a7 bd 1c 94 4b 4d  13 5a 62 69 d9 6f 3a 51  |.r....KM.Zbi.o:Q|
+000002c0  f0 18 90 e5 b6 21 23 97  70 74 93 ba 9b bc dc e4  |.....!#.pt......|
+000002d0  3d 9c 52 3f 93 f0 48 05  e8 50 d0 b4 98 92 7a 18  |=.R?..H..P....z.|
+000002e0  3f 39 ba f8 f7 ee 19 b0  ce ac d0 ab 9e 83 ee 0e  |?9..............|
+000002f0  5d 2a 72 74 a8 8b 4d de  6b a9 91 ad b4 a4 26 99  |]*rt..M.k.....&.|
+00000300  4e aa 6d 48 77 83 78 78  be 96 f1 17 d6 96 74 4a  |N.mHw.xx......tJ|
+00000310  80 d1 5b 17 03 03 00 99  d9 40 96 5c fb 5d 65 69  |..[......@.\.]ei|
+00000320  db 54 a8 f6 8c b7 d3 25  8d 2d c5 f1 40 5b f2 26  |.T.....%.-..@[.&|
+00000330  f3 86 9e 61 6a a5 b9 66  b1 27 b1 20 6b 2c 64 84  |...aj..f.'. k,d.|
+00000340  3f 48 24 5d d9 90 4b d1  ed 1b 0e 05 84 7f ad 0e  |?H$]..K.........|
+00000350  e6 75 f6 f9 33 90 73 7c  88 10 d7 e9 74 41 4b c3  |.u..3.s|....tAK.|
+00000360  19 8e e1 a8 a6 7c 3c 9a  bc 69 a7 e7 bb d6 af 98  |.....|<..i......|
+00000370  f1 49 53 14 95 80 d6 95  81 5a 5e 88 2c 29 70 df  |.IS......Z^.,)p.|
+00000380  b2 df fe f3 17 03 e7 de  af 12 57 c5 7a ef 70 eb  |..........W.z.p.|
+00000390  8a c6 c3 05 de 5b 15 af  5f 54 8c 7b 23 b7 e1 f1  |.....[.._T.{#...|
+000003a0  30 b1 ed 34 4c 59 f5 68  c2 50 e8 c3 83 78 1d 1f  |0..4LY.h.P...x..|
+000003b0  eb 17 03 03 00 45 1a d4  61 ba 4a a5 1e 02 80 04  |.....E..a.J.....|
+000003c0  2a 19 11 af 8c e9 bd ab  22 6b 75 41 a8 40 de 57  |*......."kuA.@.W|
+000003d0  54 8c dc 09 cc 57 76 82  27 5e 59 0c 30 f7 9d c4  |T....Wv.'^Y.0...|
+000003e0  fe 1c 09 f2 f4 5f e0 79  ac 02 06 80 f3 60 c4 92  |....._.y.....`..|
+000003f0  cd 6a df b6 46 7c de 90  8d bb 94                 |.j..F|.....|
 >>> Flow 3 (client to server)
-00000000  14 03 03 00 01 01 17 03  03 00 45 44 15 b9 ed d8  |..........ED....|
-00000010  10 2c 88 80 79 f3 38 a4  bc 42 9b 22 09 44 d9 19  |.,..y.8..B.".D..|
-00000020  e1 0a ec 15 aa d5 15 e9  19 6d b8 6b 71 63 86 ce  |.........m.kqc..|
-00000030  e7 16 0d 8e 3f 9a 3b 52  25 1e 96 f6 d9 d1 6c dd  |....?.;R%.....l.|
-00000040  e3 20 e9 97 f9 60 81 f5  4a b2 26 b5 d3 9e 84 46  |. ...`..J.&....F|
-00000050  17 03 03 00 17 de 4a e9  44 21 88 ef ce 78 35 6d  |......J.D!...x5m|
-00000060  b2 e4 78 47 39 8d 1f fd  9b 2d a4 47 17 03 03 00  |..xG9....-.G....|
-00000070  13 98 f9 1c 9c d4 b1 42  f7 e7 a1 9b 6d b1 b1 cb  |.......B....m...|
-00000080  86 e3 c2 27                                       |...'|
+00000000  14 03 03 00 01 01 17 03  03 00 45 8c 37 d5 7e 3e  |..........E.7.~>|
+00000010  c4 24 64 8b fa fc 8d 03  a7 92 34 35 c3 2c f2 54  |.$d.......45.,.T|
+00000020  43 06 5d 8a c9 c0 e8 7d  22 d3 99 58 01 0e 44 aa  |C.]....}"..X..D.|
+00000030  3c 26 eb 68 45 14 cd bf  6c 61 bb 31 91 9d b4 57  |<&.hE...la.1...W|
+00000040  42 79 14 8c 67 c6 65 52  15 07 c8 f3 c3 9f 23 ef  |By..g.eR......#.|
+00000050  17 03 03 00 17 21 51 dd  67 e4 be f8 7c 7b 84 0d  |.....!Q.g...|{..|
+00000060  78 3c 7f ac 50 f8 34 7b  fb 38 09 d0 17 03 03 00  |x<..P.4{.8......|
+00000070  13 35 1a 52 9d de 4a 74  1f 01 70 de 05 c5 c3 b9  |.5.R..Jt..p.....|
+00000080  e6 de 9c 0f                                       |....|
diff --git a/src/crypto/tls/testdata/Client-TLSv13-ALPN b/src/crypto/tls/testdata/Client-TLSv13-ALPN
index 0ac9b36933..1d8da269de 100644
--- a/src/crypto/tls/testdata/Client-TLSv13-ALPN
+++ b/src/crypto/tls/testdata/Client-TLSv13-ALPN
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 8f 00 05 00 05  01 00 00 00 00 00 0a 00  |................|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -18,76 +18,76 @@
 00000100  bb 29 07 30 ff f6 84 af  c4 cf c2 ed 90 99 5f 58  |.).0.........._X|
 00000110  cb 3b 74                                          |.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 7a 02 00 00  76 03 03 23 c5 c4 0c 4a  |....z...v..#...J|
-00000010  d2 5f 0b f6 ea 21 7a d1  a0 7d 21 26 b5 a3 94 ca  |._...!z..}!&....|
-00000020  91 6c 13 58 60 4f 39 cc  1a f7 c0 20 00 00 00 00  |.l.X`O9.... ....|
+00000000  16 03 03 00 7a 02 00 00  76 03 03 c2 91 70 7a 7a  |....z...v....pzz|
+00000010  d4 c9 46 7a e9 44 d1 c0  92 a6 0a 43 34 08 b2 ce  |..Fz.D.....C4...|
+00000020  14 99 8f 6c f7 37 fb a1  28 00 ae 20 00 00 00 00  |...l.7..(.. ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 01 00 00  |................|
-00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 f9  |..+.....3.$... .|
-00000060  64 7e 54 8f 64 ec 3d 7c  17 f1 96 3c 44 ca cd d7  |d~T.d.=|...<D...|
-00000070  3d 92 02 06 5a f8 ab dc  f3 50 fe 5c ab 04 6b 14  |=...Z....P.\..k.|
-00000080  03 03 00 01 01 17 03 03  00 24 9f 15 ee 1e 43 26  |.........$....C&|
-00000090  31 53 01 8b a0 a7 e9 ac  96 51 a7 bc fe 46 6c 60  |1S.......Q...Fl`|
-000000a0  d1 8b c4 a9 34 cd 93 13  51 50 e9 02 f9 ce 17 03  |....4...QP......|
-000000b0  03 02 6d c3 ad 14 a8 d3  81 87 26 7d a0 60 57 2c  |..m.......&}.`W,|
-000000c0  d2 65 f5 a5 fc a8 c4 dd  2e e2 04 57 1f 94 a4 4a  |.e.........W...J|
-000000d0  3a 43 92 f4 f5 58 e9 11  d7 b1 62 0d d1 f4 d5 43  |:C...X....b....C|
-000000e0  4a c8 fa d9 28 18 ca 74  1a b2 39 e2 9b 95 40 0e  |J...(..t..9...@.|
-000000f0  63 ed 11 52 9b 61 36 0c  c3 a6 7b de 4d 68 48 55  |c..R.a6...{.MhHU|
-00000100  e2 05 e8 59 e1 df 51 08  06 a8 09 a0 d5 e7 14 e9  |...Y..Q.........|
-00000110  13 c6 a4 6d ff 7b b0 98  50 ef 81 1b 64 6f 44 c1  |...m.{..P...doD.|
-00000120  cd da 85 a0 80 0c da 54  90 8e a1 7d 4b 1d 16 fc  |.......T...}K...|
-00000130  40 ba e3 25 e3 c2 52 29  7a 23 50 2a 43 3f 7e 32  |@..%..R)z#P*C?~2|
-00000140  73 e0 5a a5 3f 09 b0 3a  b8 90 8b 36 06 ac fc ef  |s.Z.?..:...6....|
-00000150  e8 9c ba f3 fb 8e 2d ab  b3 c6 f4 d0 1d eb 7b 20  |......-.......{ |
-00000160  2b 68 1f e9 25 49 c9 2a  45 6e 2b a5 00 12 54 b2  |+h..%I.*En+...T.|
-00000170  a7 16 2f 00 72 d4 ed 7d  ea 7e cb b1 0a 03 c6 3b  |../.r..}.~.....;|
-00000180  b8 fe 97 59 6a b4 07 d3  2c b1 cc ca e8 46 24 97  |...Yj...,....F$.|
-00000190  d2 b8 a5 8e 7d 6f 78 7f  bd ee 7d 5a f6 ec 07 50  |....}ox...}Z...P|
-000001a0  00 c4 63 33 03 e5 09 44  c3 68 61 ec 5b 52 f8 67  |..c3...D.ha.[R.g|
-000001b0  66 60 fd 68 fe d7 b7 df  96 2c 1b 00 93 89 24 58  |f`.h.....,....$X|
-000001c0  20 2d 0a c1 c4 80 fc 03  8c 16 d1 83 11 a9 e7 70  | -.............p|
-000001d0  69 3f cf c2 dc 90 40 70  1a 1e d9 8e 36 02 61 57  |i?....@p....6.aW|
-000001e0  49 60 2d ba 59 76 fb 26  50 c8 db 82 b3 62 e5 d7  |I`-.Yv.&P....b..|
-000001f0  fb c6 91 9b 99 6e d2 d7  e1 8a da ec 87 e9 d8 71  |.....n.........q|
-00000200  3a 01 01 c9 9c da 3c 81  67 bc fb 30 0c 81 31 62  |:.....<.g..0..1b|
-00000210  c2 ff 1f ee db 27 e2 07  59 51 fb e2 64 89 e5 0e  |.....'..YQ..d...|
-00000220  0a 37 06 07 8a 96 34 b9  53 8d 0a ed 60 02 cb f5  |.7....4.S...`...|
-00000230  af b2 9c 77 27 2a 23 69  5f 58 cc 46 32 ab 76 df  |...w'*#i_X.F2.v.|
-00000240  1b c1 17 98 6e fb 9e 15  e0 7f e1 00 75 6d b2 cf  |....n.......um..|
-00000250  ce 6e dd 6c 00 b6 81 14  bb 06 60 b4 47 07 2a cf  |.n.l......`.G.*.|
-00000260  dc 87 72 07 7e 1d 76 fc  17 14 8a d7 5c 32 9b d2  |..r.~.v.....\2..|
-00000270  c6 45 24 d5 d0 ea a4 c6  b5 6e 63 fc c7 12 0c a7  |.E$......nc.....|
-00000280  0a 73 70 89 ce 3d 1f aa  d5 ad ba bc 16 e8 15 80  |.sp..=..........|
-00000290  14 16 84 f6 06 38 23 b7  21 ec 27 50 a8 76 cf 0c  |.....8#.!.'P.v..|
-000002a0  4f 58 f7 57 7f b3 bd 55  0c f4 53 6e 9f f4 f2 12  |OX.W...U..Sn....|
-000002b0  5b c4 e7 68 9c 17 8b 76  88 1e 42 1b 32 e0 81 4d  |[..h...v..B.2..M|
-000002c0  ce 16 73 59 74 bd 56 be  fd fe 42 21 07 bd f4 e9  |..sYt.V...B!....|
-000002d0  ff 83 f3 97 a8 9e d4 c6  3c 6f 43 9d 0b 3c dc 35  |........<oC..<.5|
-000002e0  29 e4 bd b1 75 a4 70 30  8d bd fa 25 74 6c 11 ea  |)...u.p0...%tl..|
-000002f0  44 38 b5 8f f9 7a 71 c6  f8 ea c7 2c 23 d2 29 6d  |D8...zq....,#.)m|
-00000300  dc 8f e5 f7 c6 80 3b 8d  47 da 19 da 28 26 26 e6  |......;.G...(&&.|
-00000310  0f 83 d5 e9 33 42 0b 21  f4 1c 48 c0 19 ed e6 84  |....3B.!..H.....|
-00000320  17 03 03 00 99 d6 56 fb  52 63 57 c0 61 ec 30 04  |......V.RcW.a.0.|
-00000330  0a ee 10 39 7b e4 6a 38  8b 29 9a 6c 40 88 1d a1  |...9{.j8.).l@...|
-00000340  8b 53 2b fe 47 66 75 70  5b 03 33 fc ca e6 4f 8d  |.S+.Gfup[.3...O.|
-00000350  f1 40 63 c2 24 97 b4 c8  dd b1 20 27 e0 28 03 7a  |.@c.$..... '.(.z|
-00000360  f1 cd b3 df 8a 93 39 fa  b9 f9 0e 62 4c 47 24 69  |......9....bLG$i|
-00000370  9a f3 a5 7b 0d 14 33 00  c3 ab ae 4a 46 c2 40 42  |...{..3....JF.@B|
-00000380  d7 36 c1 74 7a c6 1a 42  d2 e0 fe e6 4b 5c 96 1a  |.6.tz..B....K\..|
-00000390  24 05 13 2c ad aa 25 02  ae 1b 3a 87 a7 60 1c d4  |$..,..%...:..`..|
-000003a0  98 53 ee 33 e9 36 37 d0  97 c2 e9 2d b9 a0 ac 4f  |.S.3.67....-...O|
-000003b0  c8 82 d8 a4 28 2e e4 db  a1 8f 71 cb ee 28 17 03  |....(.....q..(..|
-000003c0  03 00 35 5d 41 7c b0 af  b5 49 e8 dc 8a 7f c8 1f  |..5]A|...I......|
-000003d0  af 70 8b c4 35 7b 7b 57  3a 49 f2 ef 75 4c 27 39  |.p..5{{W:I..uL'9|
-000003e0  bf a6 45 fd 9c 64 b2 6e  7c c0 d3 c0 c7 a6 25 2f  |..E..d.n|.....%/|
-000003f0  f7 48 6d 7c a4 33 ad 61                           |.Hm|.3.a|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 03 00 00  |................|
+00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 60  |..+.....3.$... `|
+00000060  96 62 c2 30 4e ae b6 89  f2 06 e0 4e 8e 32 27 04  |.b.0N......N.2'.|
+00000070  b5 74 80 d8 c3 f5 76 7d  0e 0e e1 8d bc 2c 2c 14  |.t....v}.....,,.|
+00000080  03 03 00 01 01 17 03 03  00 24 45 c7 50 3e a9 63  |.........$E.P>.c|
+00000090  24 0b e9 80 3f 59 bb be  23 8a 5d 46 eb ee 17 9c  |$...?Y..#.]F....|
+000000a0  70 6f 52 1f 18 f3 9f 72  d6 35 44 55 91 d2 17 03  |poR....r.5DU....|
+000000b0  03 02 6d c2 c0 1f 53 2a  0c 3c 7f 08 c3 cb 53 4e  |..m...S*.<....SN|
+000000c0  b2 f5 b3 2d a5 10 e1 97  00 89 67 db 4e df ad 75  |...-......g.N..u|
+000000d0  94 b4 56 c4 8a a3 49 41  43 a1 3f aa 9b 8e e1 8d  |..V...IAC.?.....|
+000000e0  4c 9c 36 f6 80 da 4e 7f  00 10 c0 81 3e 45 1b a0  |L.6...N.....>E..|
+000000f0  b7 7f 2c bd eb 2a 8b c4  e6 fa c8 b3 59 28 f6 b8  |..,..*......Y(..|
+00000100  0a 93 cb b3 bf 28 e7 1a  ae a0 f5 ff 3a 42 f5 64  |.....(......:B.d|
+00000110  92 2c dd c2 24 77 2f a6  7e 23 63 3f 24 16 b3 d5  |.,..$w/.~#c?$...|
+00000120  b7 df 3f 30 23 a4 aa c9  14 78 6c f2 82 45 52 df  |..?0#....xl..ER.|
+00000130  cf a1 1d 35 fd 2a 30 89  14 38 5a 23 b1 63 2c c1  |...5.*0..8Z#.c,.|
+00000140  6d 6b 07 d0 41 38 4f 4c  87 d3 bd f1 ec ed 29 52  |mk..A8OL......)R|
+00000150  3d c7 74 3d e9 d3 ce 47  1c 24 d5 78 19 c9 5e 01  |=.t=...G.$.x..^.|
+00000160  66 a0 f1 8f ea a6 c1 e4  b4 e0 c2 2e d7 d6 64 36  |f.............d6|
+00000170  c9 bc d1 27 33 6f 26 a8  c6 aa 0d bc ae f9 2e bc  |...'3o&.........|
+00000180  f1 a7 82 42 09 83 62 88  c0 9f 20 95 a9 38 50 b4  |...B..b... ..8P.|
+00000190  55 d6 e9 f4 c6 a1 e6 67  a9 5f e4 15 97 44 13 ef  |U......g._...D..|
+000001a0  d3 50 8b 61 38 5e 89 75  b1 cf 6a 6f 0c c5 26 13  |.P.a8^.u..jo..&.|
+000001b0  2c 5a 26 c9 81 98 88 cd  ec 8c 2c 99 a0 ff 55 8f  |,Z&.......,...U.|
+000001c0  3f 9b c3 3b 52 d0 a3 3a  f9 b8 f0 17 81 53 00 f3  |?..;R..:.....S..|
+000001d0  ef 72 b3 4e b9 65 28 8f  a2 48 dc dd 6b 16 61 c3  |.r.N.e(..H..k.a.|
+000001e0  4e 0e c0 1c ac 8c 40 28  27 63 66 c7 74 40 8d 93  |N.....@('cf.t@..|
+000001f0  71 e9 f6 3f d8 8d 5d c6  28 11 4f ac 55 6f 80 1b  |q..?..].(.O.Uo..|
+00000200  2e 84 05 94 e0 4f e7 63  62 65 c7 52 99 49 2f 5d  |.....O.cbe.R.I/]|
+00000210  b4 99 d3 c3 fa b9 f5 83  aa 28 2e 9d ce af 72 7f  |.........(....r.|
+00000220  57 ea 81 f3 bf b5 d7 93  3a 1f a0 83 4d 8a 91 85  |W.......:...M...|
+00000230  fe b7 a1 b3 cb 1d b1 85  9b bb 36 1b 12 9f ed 13  |..........6.....|
+00000240  09 55 31 bd ee 61 06 57  b4 07 4d c6 1e fa b9 7f  |.U1..a.W..M.....|
+00000250  c7 b6 60 70 92 b7 9a ff  80 7d da 7f 2a 62 89 be  |..`p.....}..*b..|
+00000260  79 43 d3 ae 9c f1 00 6d  68 6c a3 f6 48 6e e0 48  |yC.....mhl..Hn.H|
+00000270  97 0f 5c 44 43 9f a8 88  27 96 fc 53 a0 e1 f2 7a  |..\DC...'..S...z|
+00000280  a6 a7 d9 96 2e 3d c4 e0  d9 18 79 ec 83 c2 9b da  |.....=....y.....|
+00000290  0b d4 8b 87 c5 98 f5 8b  e7 e3 d1 bd 2b 2b 42 e2  |............++B.|
+000002a0  4b 3e 64 88 4b 72 d0 35  cc c3 e6 68 c6 f6 4f 23  |K>d.Kr.5...h..O#|
+000002b0  39 a7 94 8d f3 e6 bd cd  d5 e9 8c 53 83 a7 87 09  |9..........S....|
+000002c0  15 fe ea eb 2e 56 da 6b  d9 5b b7 b1 c5 c4 ba 65  |.....V.k.[.....e|
+000002d0  39 89 16 f5 f6 4e e6 3a  63 34 1b 5d f5 fa 6b 8d  |9....N.:c4.]..k.|
+000002e0  c3 49 07 88 12 ca 18 c5  50 da 74 44 c0 c0 33 bd  |.I......P.tD..3.|
+000002f0  2e 45 94 af e1 40 90 00  11 2d 08 7b fc e4 3b f0  |.E...@...-.{..;.|
+00000300  94 fd 5a 0c 3a f9 76 df  3b 5e a3 0d 0f e7 2d df  |..Z.:.v.;^....-.|
+00000310  fd e9 ce 45 5a 13 36 a6  18 ae 46 30 00 fc d5 e3  |...EZ.6...F0....|
+00000320  17 03 03 00 99 0e 35 b6  91 ad cd a6 62 6e 79 12  |......5.....bny.|
+00000330  53 d5 f0 78 72 c5 dd 94  00 e3 75 2c 11 a3 72 f6  |S..xr.....u,..r.|
+00000340  b7 b3 5e d9 51 79 d5 a9  1e 21 2f df 0d 53 9a c8  |..^.Qy...!/..S..|
+00000350  43 a9 58 e2 a9 3d 9a b4  b4 72 bb 62 65 4b 83 f8  |C.X..=...r.beK..|
+00000360  cd 1b 58 e0 69 d9 87 3b  8d 05 42 e1 22 23 e9 5b  |..X.i..;..B."#.[|
+00000370  3a 5a 38 17 17 fb 3a 56  de fc 56 f8 77 12 31 4a  |:Z8...:V..V.w.1J|
+00000380  c5 38 ec 69 72 54 e5 63  2a a0 1e b4 7d 86 43 29  |.8.irT.c*...}.C)|
+00000390  21 ba 56 c2 d9 1b 9f a4  c1 02 f3 83 c1 9a 56 69  |!.V...........Vi|
+000003a0  5c 9e 5f ae 94 9d 6f 03  ec 75 7a 19 98 cd a9 dd  |\._...o..uz.....|
+000003b0  4a 01 41 72 2e 60 9f ca  4c d2 27 d9 0f 4f 17 03  |J.Ar.`..L.'..O..|
+000003c0  03 00 35 5d 61 3c 07 70  2f 35 ba d0 93 44 16 bd  |..5]a<.p/5...D..|
+000003d0  73 4b a0 fb 05 52 6a cc  5a 2e f2 94 d6 77 98 03  |sK...Rj.Z....w..|
+000003e0  c3 2e 8e a9 d1 38 14 d2  cd e6 e3 b6 ad ec d6 a0  |.....8..........|
+000003f0  cf b0 58 5f 8f d3 43 4b                           |..X_..CK|
 >>> Flow 3 (client to server)
-00000000  14 03 03 00 01 01 17 03  03 00 35 3e e7 50 e1 d1  |..........5>.P..|
-00000010  4d 9f 84 fe ca 83 c4 3b  a6 86 45 c2 7e e7 af 00  |M......;..E.~...|
-00000020  db e6 23 3c 06 b8 a3 1e  36 2e ab 45 7e d8 07 8c  |..#<....6..E~...|
-00000030  66 bf 5a 0f ff e6 3f 09  a4 d3 cf 74 1c d6 cf c7  |f.Z...?....t....|
-00000040  17 03 03 00 17 4c db af  a7 f3 73 b3 84 b9 a7 d1  |.....L....s.....|
-00000050  1c 2f cb 27 d8 ba 2c c6  84 48 88 18 17 03 03 00  |./.'..,..H......|
-00000060  13 a3 41 6f fb da f5 5a  4d 85 0c e0 ff 3a fb 91  |..Ao...ZM....:..|
-00000070  e2 5e ab 96                                       |.^..|
+00000000  14 03 03 00 01 01 17 03  03 00 35 3d 0a fd 33 39  |..........5=..39|
+00000010  b6 94 43 53 ae ee 3f 4e  c6 2d a2 3a f0 ef 94 7d  |..CS..?N.-.:...}|
+00000020  32 0a b6 90 cd a1 6f 29  88 ff 3c 91 c1 e5 e5 ae  |2.....o)..<.....|
+00000030  b7 a0 0b b3 c0 e6 37 9d  06 8b d8 ae 06 c0 0e 7b  |......7........{|
+00000040  17 03 03 00 17 c2 a1 82  db df fa 54 28 79 a0 0c  |...........T(y..|
+00000050  97 8c 82 ee 22 c9 b9 35  32 7a 21 4b 17 03 03 00  |...."..52z!K....|
+00000060  13 87 2b f8 38 81 df fa  e5 2e ff e2 d2 51 3e bc  |..+.8........Q>.|
+00000070  dd d3 e8 62                                       |...b|
diff --git a/src/crypto/tls/testdata/Client-TLSv13-CHACHA20-SHA256 b/src/crypto/tls/testdata/Client-TLSv13-CHACHA20-SHA256
index 6d7b508fd3..69749f05d3 100644
--- a/src/crypto/tls/testdata/Client-TLSv13-CHACHA20-SHA256
+++ b/src/crypto/tls/testdata/Client-TLSv13-CHACHA20-SHA256
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,75 +16,75 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 7a 02 00 00  76 03 03 43 b1 e8 d9 c3  |....z...v..C....|
-00000010  22 a0 a3 08 df 7f 37 34  7a fe 7a 47 98 ee ed 51  |".....74z.zG...Q|
-00000020  c2 ae 5c c6 b1 43 3d ff  f7 91 68 20 00 00 00 00  |..\..C=...h ....|
+00000000  16 03 03 00 7a 02 00 00  76 03 03 39 b2 74 80 d8  |....z...v..9.t..|
+00000010  49 72 79 63 9b 7b da d7  cf b4 29 20 f8 80 ed d9  |Iryc.{....) ....|
+00000020  66 09 65 22 b6 27 16 c5  a7 6f 8b 20 00 00 00 00  |f.e".'...o. ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 03 00 00  |................|
-00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 63  |..+.....3.$... c|
-00000060  0f 66 ec 2d fa 67 d4 eb  94 47 8d 88 0b eb ed ec  |.f.-.g...G......|
-00000070  5b ac 22 f7 46 85 c5 1c  2b 5e e8 57 e2 d3 6f 14  |[.".F...+^.W..o.|
-00000080  03 03 00 01 01 17 03 03  00 17 d0 f8 1f 06 59 8d  |..............Y.|
-00000090  a0 40 21 8f 3e 36 3b 1d  6a 6e f7 77 44 fb b3 8e  |.@!.>6;.jn.wD...|
-000000a0  e2 17 03 03 02 6d 22 6b  63 ae 47 fd 66 f9 95 f6  |.....m"kc.G.f...|
-000000b0  63 ea e8 16 61 a3 64 82  39 82 76 1c 2c 04 9b 29  |c...a.d.9.v.,..)|
-000000c0  0f 8a ff 77 9b e6 2c ce  04 09 5f 91 f3 b6 2e 8d  |...w..,..._.....|
-000000d0  be 42 94 7e 5a 28 4b 9f  e9 7b 38 0a 3c de 90 77  |.B.~Z(K..{8.<..w|
-000000e0  c1 bf 97 bf 35 6c 77 98  4b 38 b4 8d 7f 1f 4b c0  |....5lw.K8....K.|
-000000f0  23 c5 73 08 90 fa 21 5c  cd cb 84 5b 0e 89 86 ce  |#.s...!\...[....|
-00000100  83 78 d5 1c 2b b9 b1 24  45 ad ab 9c 68 9f c2 28  |.x..+..$E...h..(|
-00000110  40 d6 c2 ac a2 0c 86 cd  75 92 43 d5 22 3f 61 9d  |@.......u.C."?a.|
-00000120  e8 56 b8 7c 71 db 25 cc  2e 74 52 74 da 6b d4 a1  |.V.|q.%..tRt.k..|
-00000130  2c 32 d2 d8 9c 74 41 9d  78 98 94 3b 87 99 8e 17  |,2...tA.x..;....|
-00000140  df df d6 c3 6d ef 58 13  5c 1e 20 2d ed 77 bd 5c  |....m.X.\. -.w.\|
-00000150  d6 5c 9a 6d 0f 19 77 e1  4f 79 b0 ed 9d 0b f5 e8  |.\.m..w.Oy......|
-00000160  42 d0 f4 90 88 97 a9 84  af 92 3c 41 fe fd 67 6e  |B.........<A..gn|
-00000170  33 77 8e 02 83 b4 6f c0  14 d2 ee 38 79 ca 45 61  |3w....o....8y.Ea|
-00000180  59 05 3b 76 4b ef 55 b9  18 43 9f c4 42 02 31 8e  |Y.;vK.U..C..B.1.|
-00000190  88 c1 b6 0b 5d c4 20 59  91 57 f3 81 b9 d0 ec 25  |....]. Y.W.....%|
-000001a0  26 72 37 e0 e0 c8 34 83  58 fe 15 bd aa 4d 49 f8  |&r7...4.X....MI.|
-000001b0  ba 8f 1d 8d 37 9c 18 88  cd 69 23 00 93 0f 64 e0  |....7....i#...d.|
-000001c0  ed 0d a7 a0 fc bd f3 7d  0b b0 50 6b cd e6 25 b8  |.......}..Pk..%.|
-000001d0  50 3a bf 37 d7 18 60 a7  de ba c7 ff b7 26 8a 20  |P:.7..`......&. |
-000001e0  ad d3 f9 5a 5f 61 37 2f  b0 9b d6 2a 4c 39 08 34  |...Z_a7/...*L9.4|
-000001f0  31 15 19 1e 72 d3 fc 72  63 0e d5 71 04 82 b3 80  |1...r..rc..q....|
-00000200  ec aa 51 0f 73 5f 2c dd  42 fd 40 b8 e3 1d 9e 31  |..Q.s_,.B.@....1|
-00000210  13 01 3b 6b 88 f2 52 17  fa 0b 9d 45 1e f2 f0 c1  |..;k..R....E....|
-00000220  5b 3f 14 23 41 e7 a2 2e  fa e4 9b 01 9b a4 99 43  |[?.#A..........C|
-00000230  32 85 fc c9 30 2a 5d ca  2a fa c5 7f 81 89 31 02  |2...0*].*.....1.|
-00000240  0a c6 89 f0 98 1b 92 08  96 d0 90 c7 18 b0 d4 e9  |................|
-00000250  5d 29 71 3b c6 2f c5 ff  2c be db f8 ef 56 d6 e0  |])q;./..,....V..|
-00000260  9b a6 21 b1 92 b1 58 26  e9 e2 3b 97 1b 95 b2 ba  |..!...X&..;.....|
-00000270  62 66 a5 df a1 a8 82 25  1e ae 85 98 94 d7 96 c5  |bf.....%........|
-00000280  3b 30 4c bd 04 23 45 3d  86 c9 7e 0e 47 5b 5f 14  |;0L..#E=..~.G[_.|
-00000290  b5 c5 29 31 1e cd a4 e0  6a b2 78 51 f0 7b b2 21  |..)1....j.xQ.{.!|
-000002a0  1f 10 0d 0d 7f 01 f1 06  4a 87 7d 4a 90 63 59 f3  |........J.}J.cY.|
-000002b0  6d 16 0f 07 9e 00 3a d2  c7 01 37 cc 39 6e 07 6e  |m.....:...7.9n.n|
-000002c0  9e 64 df 47 65 04 4c 72  59 ad 3b 3e 52 8e e4 b6  |.d.Ge.LrY.;>R...|
-000002d0  fc ba 9c f0 82 13 ba 25  11 c7 5d 38 00 cf 83 14  |.......%..]8....|
-000002e0  30 a9 72 48 d1 e8 4e 1b  ed 04 ed cf b7 5b 2e 72  |0.rH..N......[.r|
-000002f0  1c a2 03 ae 60 54 d6 cf  2f fb 11 a3 b1 8d d6 47  |....`T../......G|
-00000300  e8 9f 96 08 90 ae 3c 3c  c0 8c d8 c4 ef 30 18 ea  |......<<.....0..|
-00000310  2a 1a 15 17 03 03 00 99  85 b3 e4 18 6f 8d 34 c7  |*...........o.4.|
-00000320  3d 66 49 b8 f6 f5 aa 7a  e1 ca ba cb 48 53 15 bb  |=fI....z....HS..|
-00000330  e9 ec 74 91 c3 b5 d3 6b  bc 84 81 d8 e1 a4 31 62  |..t....k......1b|
-00000340  d5 19 6d 2f 15 4c f3 8a  3b ec 41 12 89 be d3 cc  |..m/.L..;.A.....|
-00000350  ab 08 59 a7 79 5d 77 14  ce b1 98 b4 ce 71 7b ad  |..Y.y]w......q{.|
-00000360  ba 41 3a 7f 9a f8 23 5c  c6 fb b5 7b cc eb 0e 7a  |.A:...#\...{...z|
-00000370  ee af 3d ff 4d 03 ba c2  2a af ac fd b5 e8 5b 43  |..=.M...*.....[C|
-00000380  3e 37 ef 84 3d 66 af 3c  8e 1d 0d 36 bd df 25 dc  |>7..=f.<...6..%.|
-00000390  74 89 9c e6 da 18 c4 c8  b5 6c 3c 4c a6 ac 10 28  |t........l<L...(|
-000003a0  67 c0 a7 02 6c d4 8c a1  ca 66 ec 30 65 a6 af f7  |g...l....f.0e...|
-000003b0  e3 17 03 03 00 35 46 33  9b 78 59 93 b5 3d 99 22  |.....5F3.xY..=."|
-000003c0  56 3b 26 82 9c d4 08 36  5a 07 c6 d7 5b 4f c8 d9  |V;&....6Z...[O..|
-000003d0  32 8b cd f1 e7 81 58 a8  98 b6 61 f6 9e 75 0c 52  |2.....X...a..u.R|
-000003e0  5a a1 e8 b1 97 8c 94 52  82 5e e8                 |Z......R.^.|
+00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 42  |..+.....3.$... B|
+00000060  80 fb 4a d3 49 53 a5 9f  f6 da ca 64 f8 5d 2c f5  |..J.IS.....d.],.|
+00000070  45 4d f1 a5 ec c3 c6 fc  d2 ff 56 b1 63 53 1a 14  |EM........V.cS..|
+00000080  03 03 00 01 01 17 03 03  00 17 f8 d8 e1 1a e0 c8  |................|
+00000090  75 f9 40 90 da 16 a0 41  4f 8c 23 e7 47 43 89 cf  |u.@....AO.#.GC..|
+000000a0  d4 17 03 03 02 6d d6 23  1d c6 c0 d4 5e a3 fe 2b  |.....m.#....^..+|
+000000b0  03 04 6c 88 d1 4a ac 9b  dd 90 e5 18 c5 35 9c 4a  |..l..J.......5.J|
+000000c0  f3 c4 64 e2 c2 40 62 fb  68 b3 22 37 9f f4 eb ae  |..d..@b.h."7....|
+000000d0  45 d9 a8 be f4 1e 89 16  88 b5 10 e3 5c 2e 42 15  |E...........\.B.|
+000000e0  34 24 f3 bd dd 73 6d 6b  d1 db 3e 69 b0 0a 54 e6  |4$...smk..>i..T.|
+000000f0  b7 2c b7 80 86 93 91 d5  26 02 77 bf 10 38 ee 40  |.,......&.w..8.@|
+00000100  22 4d 3f 67 02 6b f8 1c  4a ad 2b c7 f6 19 d4 36  |"M?g.k..J.+....6|
+00000110  9b ff c4 08 73 e1 48 0a  a6 e8 80 3b 88 8a c2 e8  |....s.H....;....|
+00000120  c6 4a ae da a1 4f 3b 9e  fb 80 3b 78 ca 80 42 00  |.J...O;...;x..B.|
+00000130  a4 5c 9d a0 6c 63 a7 66  e6 26 b7 14 d8 8b ba 1a  |.\..lc.f.&......|
+00000140  4b 13 81 3c e4 76 4e ac  6c 2f b4 71 e9 dc c4 c8  |K..<.vN.l/.q....|
+00000150  ef f0 61 22 f4 6b 83 ae  d8 d0 a7 c6 d9 ea 95 85  |..a".k..........|
+00000160  77 90 0f 22 a0 50 cb ff  50 a5 98 ee de e4 89 f3  |w..".P..P.......|
+00000170  20 f2 63 a2 45 3a 48 33  d5 b9 ff 5e f8 7d c5 2d  | .c.E:H3...^.}.-|
+00000180  b9 9c b2 65 bf d5 13 36  46 a5 96 9f f4 de 7c 1c  |...e...6F.....|.|
+00000190  78 3f 1a 0a 62 14 13 8e  55 7e cd 47 87 1b 7e a8  |x?..b...U~.G..~.|
+000001a0  7f 03 ec 1c d3 72 eb e5  94 d9 9d 95 d6 f5 ad 2c  |.....r.........,|
+000001b0  e9 7d 0f 2c ea 7b 1e 8e  d7 b4 f1 5d 12 be d7 cf  |.}.,.{.....]....|
+000001c0  b7 43 89 65 e9 04 0e f8  b4 b4 4d 9c 9c 42 3c 50  |.C.e......M..B<P|
+000001d0  a7 91 d0 7f c0 de fb 99  08 ce 5c fd 67 3a cb 1a  |..........\.g:..|
+000001e0  d3 1a 4c a2 2e 7d 73 01  2b 5f bb a2 86 7d 0e e0  |..L..}s.+_...}..|
+000001f0  a1 c9 06 c0 4a 0a f6 c6  c4 b5 53 51 3e 2f f4 60  |....J.....SQ>/.`|
+00000200  1d 41 55 9d c4 88 f3 76  4f 92 b5 03 98 23 6b c4  |.AU....vO....#k.|
+00000210  c3 62 bd 12 dd 3a bc 37  d0 18 64 c6 e1 2c cb 62  |.b...:.7..d..,.b|
+00000220  f6 d3 24 35 47 e7 cf 15  d3 53 9d ac 3f 97 48 c1  |..$5G....S..?.H.|
+00000230  b8 d3 a3 2c 9f cd 2b 72  bc bd a6 8a b1 54 48 7b  |...,..+r.....TH{|
+00000240  e0 b7 a2 2e 46 04 cc e5  29 1d 73 c7 67 f8 f0 d8  |....F...).s.g...|
+00000250  e0 88 f0 7b 11 ff e1 1d  95 6c 85 c4 08 72 3e 94  |...{.....l...r>.|
+00000260  92 4b 8a 58 62 04 10 83  7c 5e 65 20 a7 5d 6d 16  |.K.Xb...|^e .]m.|
+00000270  30 64 fc aa 7f 8f 06 ed  4e 3c 86 c8 10 92 fb 0d  |0d......N<......|
+00000280  7b 81 10 07 cf 30 7f 6b  11 63 60 2a 61 92 cb 74  |{....0.k.c`*a..t|
+00000290  82 a4 04 cf 23 43 21 55  45 2a 29 93 42 0f 0c f6  |....#C!UE*).B...|
+000002a0  9b 14 b5 96 09 25 1b bc  b0 7b 72 e2 6f b8 55 74  |.....%...{r.o.Ut|
+000002b0  00 bb 1c 7c b1 9b 58 63  97 bb 6d c5 fb a4 da 24  |...|..Xc..m....$|
+000002c0  1e b2 97 18 75 ab 8b a2  77 50 38 4d f8 a0 39 58  |....u...wP8M..9X|
+000002d0  8c 2d 3e ba 27 03 e9 51  87 0a 95 e0 08 40 5d e6  |.->.'..Q.....@].|
+000002e0  6a dd 10 1d 6d 8c 32 88  a8 32 ee dd 44 9c 9b b0  |j...m.2..2..D...|
+000002f0  6f f5 4b 08 60 9d 83 1e  ab 83 c0 92 10 c7 aa 90  |o.K.`...........|
+00000300  d2 b2 61 5e 12 b5 e8 ea  a7 68 59 17 a4 f4 15 f7  |..a^.....hY.....|
+00000310  dc 10 81 17 03 03 00 99  8a 61 79 8f 33 51 7b a9  |.........ay.3Q{.|
+00000320  ce 3f 82 2b bb da 40 2e  73 c8 d9 6e 7d 72 ba 94  |.?.+..@.s..n}r..|
+00000330  7d ad fb b7 ba 9c 74 00  0b c9 1d b6 8d 54 b9 48  |}.....t......T.H|
+00000340  eb 49 78 c3 1a 75 b8 16  22 5d 50 f5 4a 81 59 d3  |.Ix..u.."]P.J.Y.|
+00000350  38 79 38 c1 35 11 55 69  6b d2 86 3c 0f 12 26 57  |8y8.5.Uik..<..&W|
+00000360  f5 84 d7 dd 74 61 6f b8  08 66 e9 3c f7 43 29 a5  |....tao..f.<.C).|
+00000370  94 9e ab af 68 04 c1 6a  ae 9d 12 2d 57 e9 ff 30  |....h..j...-W..0|
+00000380  7d 80 35 65 cc df c8 65  0b a1 f9 6d 6b a5 0b df  |}.5e...e...mk...|
+00000390  0c 1a 04 0a 00 8f ac 2b  29 60 92 4e 91 d3 42 25  |.......+)`.N..B%|
+000003a0  b4 a5 0a 1a 5f 83 ec 9a  f0 0a 2c 6d 65 00 24 d3  |...._.....,me.$.|
+000003b0  e1 17 03 03 00 35 e4 72  aa 9e 6c a8 93 7b e4 49  |.....5.r..l..{.I|
+000003c0  1e 23 7c 50 18 59 00 08  3b f1 c1 5f 20 ba 51 56  |.#|P.Y..;.._ .QV|
+000003d0  fe bb 93 99 52 e6 5e 6d  26 cc 60 11 c2 a1 c8 18  |....R.^m&.`.....|
+000003e0  2e 72 bd ee 36 ca 41 25  73 f2 30                 |.r..6.A%s.0|
 >>> Flow 3 (client to server)
-00000000  14 03 03 00 01 01 17 03  03 00 35 55 88 37 f3 ee  |..........5U.7..|
-00000010  c5 1b 20 ac fe bc a3 f8  c9 59 3f 5f c0 81 40 8f  |.. ......Y?_..@.|
-00000020  1e a9 44 c8 10 16 69 8a  76 45 17 51 06 9e f0 55  |..D...i.vE.Q...U|
-00000030  a2 f2 56 98 7d a1 4d 95  5a c3 1f 51 cf 31 20 ca  |..V.}.M.Z..Q.1 .|
-00000040  17 03 03 00 17 81 2a 8e  32 29 ec 9b 92 c3 fd 98  |......*.2)......|
-00000050  64 aa 47 2a a5 0c d6 77  7f b1 8f 12 17 03 03 00  |d.G*...w........|
-00000060  13 60 8c fb 98 e1 03 b6  20 c8 45 4e d9 4b a8 17  |.`...... .EN.K..|
-00000070  10 79 5f b6                                       |.y_.|
+00000000  14 03 03 00 01 01 17 03  03 00 35 b6 c3 b9 b1 52  |..........5....R|
+00000010  88 d2 78 2b ec 1c 63 e8  d5 08 0e 4e d6 51 b9 02  |..x+..c....N.Q..|
+00000020  ba cc a8 ca b6 da 45 a9  7c 1a 18 39 47 84 db 34  |......E.|..9G..4|
+00000030  d6 05 6f e5 16 19 57 6f  65 0b 7a e7 37 b5 d3 28  |..o...Woe.z.7..(|
+00000040  17 03 03 00 17 dc b8 e2  1c aa b8 f5 cb b6 fd ba  |................|
+00000050  29 34 73 bb c6 e0 3a fc  3e fb d3 01 17 03 03 00  |)4s...:.>.......|
+00000060  13 eb 66 ab 47 38 1b 01  96 6c 59 46 c2 ad bf 2d  |..f.G8...lYF...-|
+00000070  36 22 97 19                                       |6"..|
diff --git a/src/crypto/tls/testdata/Client-TLSv13-ClientCert-ECDSA-RSA b/src/crypto/tls/testdata/Client-TLSv13-ClientCert-ECDSA-RSA
index c8e95c85df..251e339306 100644
--- a/src/crypto/tls/testdata/Client-TLSv13-ClientCert-ECDSA-RSA
+++ b/src/crypto/tls/testdata/Client-TLSv13-ClientCert-ECDSA-RSA
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,124 +16,124 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 7a 02 00 00  76 03 03 98 9a 92 3f c6  |....z...v.....?.|
-00000010  67 f5 96 5b 2f 5e 70 89  2d f6 1e ce 6f 6a e5 91  |g..[/^p.-...oj..|
-00000020  4b 4b 6f 98 cc f7 78 4a  b1 54 4a 20 00 00 00 00  |KKo...xJ.TJ ....|
+00000000  16 03 03 00 7a 02 00 00  76 03 03 ce 38 98 c9 b7  |....z...v...8...|
+00000010  f8 67 af 0d 29 52 88 a4  d0 c2 a8 10 c4 8e 80 26  |.g..)R.........&|
+00000020  43 84 0e 60 06 ce f0 b7  b1 cd 29 20 00 00 00 00  |C..`......) ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 01 00 00  |................|
-00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 58  |..+.....3.$... X|
-00000060  96 37 c3 41 35 73 13 21  fc 31 e3 09 33 48 15 be  |.7.A5s.!.1..3H..|
-00000070  31 fb 57 61 b2 c9 60 31  2d 68 83 d5 7c d1 3a 14  |1.Wa..`1-h..|.:.|
-00000080  03 03 00 01 01 17 03 03  00 17 1d ce 7d b7 ca e3  |............}...|
-00000090  10 82 cb f6 1d 52 61 41  29 57 e3 7e e5 88 5c 47  |.....RaA)W.~..\G|
-000000a0  16 17 03 03 00 42 1b 49  e1 4a d7 73 57 cd e9 b7  |.....B.I.J.sW...|
-000000b0  e2 47 d3 74 21 6a 14 1d  1b 8d f5 aa 4c 1b f8 61  |.G.t!j......L..a|
-000000c0  8c 3a e4 2e 9d ff 3f 7d  b2 4d 79 6e 1d 02 05 ce  |.:....?}.Myn....|
-000000d0  c3 ad e6 f9 2b 2b dd 75  3b 6f 3e 0b 29 07 09 74  |....++.u;o>.)..t|
-000000e0  d1 37 68 9b 8a b6 8d 2b  17 03 03 02 6d d1 1b 9f  |.7h....+....m...|
-000000f0  75 ba cf 2d 10 4b f0 4e  09 58 fa ff 06 e8 c9 d5  |u..-.K.N.X......|
-00000100  a0 51 c8 d4 6f b2 c5 c1  d5 f3 ff 12 1f 43 d8 74  |.Q..o........C.t|
-00000110  33 d9 9b e5 f3 34 26 0e  89 dc 00 54 67 17 d2 f3  |3....4&....Tg...|
-00000120  c9 9e be f8 4c 77 8a 63  b1 64 5a b4 d7 57 d2 89  |....Lw.c.dZ..W..|
-00000130  ce 68 d1 f7 93 01 6c 36  b7 c9 4d 50 d0 4b df 5e  |.h....l6..MP.K.^|
-00000140  8a bb 6c d9 54 57 9b b9  c9 ec d8 49 c7 51 3c e5  |..l.TW.....I.Q<.|
-00000150  7b fb 48 0f fd 1b dd 0f  57 d3 a8 ee f6 51 ba 78  |{.H.....W....Q.x|
-00000160  c0 60 f1 d9 c1 d2 65 b4  a7 98 99 fb 64 83 4c 2c  |.`....e.....d.L,|
-00000170  a6 e9 19 ef 0e 88 68 f8  21 a4 2b bd 95 e9 52 d5  |......h.!.+...R.|
-00000180  fb 12 d3 36 06 a2 13 f9  e2 35 6a 06 dd 49 d9 42  |...6.....5j..I.B|
-00000190  89 d9 f0 24 5c 36 b8 6d  95 35 21 b3 9c 3b ee 08  |...$\6.m.5!..;..|
-000001a0  06 06 4d aa 74 eb fc 1b  c1 fd cf 07 24 74 44 2d  |..M.t.......$tD-|
-000001b0  54 d5 c5 d3 4e c4 eb 09  6e 90 8f 3d c0 c5 1c 21  |T...N...n..=...!|
-000001c0  7c 32 1b bc 4b 85 2b f0  b0 f5 cd 61 3d dd 31 03  ||2..K.+....a=.1.|
-000001d0  5e e0 5e 06 1a 37 61 1a  58 fa ed e8 cf 0c 4f da  |^.^..7a.X.....O.|
-000001e0  73 69 42 3a f4 ed dc ad  e5 e7 9b fd 54 16 77 85  |siB:........T.w.|
-000001f0  ae 84 41 10 be 84 ad 28  ef e6 13 2a e9 9f 9f 2f  |..A....(...*.../|
-00000200  c5 d0 65 c6 f5 58 b3 39  9b 5e 07 ba 95 be 5e 75  |..e..X.9.^....^u|
-00000210  68 17 ba 9d 2a 69 6d b8  ed d4 4b 6a ce 30 b1 82  |h...*im...Kj.0..|
-00000220  ae ec 68 9a 26 13 6b 05  38 0f 38 c9 94 01 d0 0b  |..h.&.k.8.8.....|
-00000230  7b bb ca 70 86 6c e4 f1  eb 81 05 25 33 c0 3e e3  |{..p.l.....%3.>.|
-00000240  2a 25 8e 32 eb d5 03 c7  c4 d8 22 22 ef 99 5a a3  |*%.2......""..Z.|
-00000250  01 6a b5 65 9a 55 6e fb  84 83 aa 43 ae 4a 3e da  |.j.e.Un....C.J>.|
-00000260  40 7e 09 e1 3b 15 ad 33  66 5a 3d 30 62 72 86 54  |@~..;..3fZ=0br.T|
-00000270  cd a2 6a bf 82 61 17 87  84 c5 3f f3 1e 86 a2 b1  |..j..a....?.....|
-00000280  2c 1a f9 ba 8c a2 21 5b  93 b2 16 b4 81 ae 7d 98  |,.....![......}.|
-00000290  d6 db 0a 56 14 c9 f7 48  c1 c7 3c 7e 63 8e bc 50  |...V...H..<~c..P|
-000002a0  6a 64 e1 1d 04 ba d3 cc  6a 61 60 4b d2 97 d5 ba  |jd......ja`K....|
-000002b0  23 1a 69 76 86 db 96 39  04 f6 ec e9 96 79 6a 25  |#.iv...9.....yj%|
-000002c0  ff 39 dd 19 08 34 4d c3  f6 7c 91 f2 6b 3a e1 0f  |.9...4M..|..k:..|
-000002d0  66 6d 14 5d 82 21 0b e3  e0 c3 f1 a1 70 e1 2c bc  |fm.].!......p.,.|
-000002e0  fb 54 aa 85 3c a0 7c 9a  35 00 e2 a1 4f 83 3e f1  |.T..<.|.5...O.>.|
-000002f0  64 83 ab c5 e6 31 c7 00  eb 36 f1 bc 41 f3 eb d4  |d....1...6..A...|
-00000300  97 30 4d 7f d2 d1 e7 1a  9e a2 53 31 35 6a 16 d1  |.0M.......S15j..|
-00000310  65 be d7 d3 93 2a be d2  27 dc 1b 8c 09 16 30 d4  |e....*..'.....0.|
-00000320  cb eb e0 bb 42 50 ff 59  c3 81 81 36 88 09 c2 23  |....BP.Y...6...#|
-00000330  dc dd 80 63 bb 78 19 6b  6a 70 4b b5 17 bf ed 6c  |...c.x.kjpK....l|
-00000340  58 f1 15 a9 16 66 c8 45  f5 5f 99 05 b1 3b be e6  |X....f.E._...;..|
-00000350  66 d7 45 df 19 16 9d c7  dd 4d 17 03 03 00 99 38  |f.E......M.....8|
-00000360  70 9e 16 94 07 67 7c ce  90 67 99 46 5e d9 61 b5  |p....g|..g.F^.a.|
-00000370  9b b8 31 fc cc 80 a3 07  30 c9 f5 f9 90 fb e2 0d  |..1.....0.......|
-00000380  dc 93 ab de 38 25 83 f8  77 0c 94 53 75 68 c7 71  |....8%..w..Suh.q|
-00000390  72 6f 61 77 a7 d7 c7 ed  5c d3 08 18 9f 64 f4 6e  |roaw....\....d.n|
-000003a0  30 dc 05 b1 65 11 79 08  66 34 8c 06 99 a9 00 26  |0...e.y.f4.....&|
-000003b0  86 2c e4 b5 6d cf db b1  03 f0 d0 c5 c0 f5 50 04  |.,..m.........P.|
-000003c0  f7 27 97 3e 31 19 aa a8  58 c4 78 43 a9 e3 76 0d  |.'.>1...X.xC..v.|
-000003d0  98 88 20 07 11 4c d6 8a  66 31 72 2e ed 47 66 71  |.. ..L..f1r..Gfq|
-000003e0  9a 3e 9c 0d 1c 17 df ab  6a 52 b4 43 a6 c2 64 30  |.>......jR.C..d0|
-000003f0  45 08 b8 de 59 be 3a f9  17 03 03 00 35 94 9b 02  |E...Y.:.....5...|
-00000400  47 a6 e3 55 9f 95 8a 8d  35 3b bb 56 ec 10 ab dd  |G..U....5;.V....|
-00000410  a3 ca fe ad bf 25 90 76  c4 15 a0 c0 73 d5 96 96  |.....%.v....s...|
-00000420  44 bc ba e9 09 f5 8e e7  e7 7d db f2 e7 9f 99 d2  |D........}......|
-00000430  dc e7                                             |..|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 03 00 00  |................|
+00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 aa  |..+.....3.$... .|
+00000060  00 03 6d 16 04 54 48 55  4d f9 04 e8 29 ca 9c 5d  |..m..THUM...)..]|
+00000070  14 94 a2 7a 2e 0a 4e 75  12 2d 63 cf 19 81 21 14  |...z..Nu.-c...!.|
+00000080  03 03 00 01 01 17 03 03  00 17 7b 90 e1 af 77 ca  |..........{...w.|
+00000090  a1 3b a6 e0 9f ea 4b f6  3f 45 a0 78 1c fb af 51  |.;....K.?E.x...Q|
+000000a0  30 17 03 03 00 42 ff 27  8b 9c fd 65 d7 b1 d4 43  |0....B.'...e...C|
+000000b0  eb 8f c3 ca b4 57 be 35  35 75 35 cf 43 73 d6 14  |.....W.55u5.Cs..|
+000000c0  7e 2d b4 f8 31 60 1b 35  2a 38 91 32 40 8b f0 ab  |~-..1`.5*8.2@...|
+000000d0  a8 b0 dc 2b db b9 63 92  28 dc f2 c2 95 d3 4a 63  |...+..c.(.....Jc|
+000000e0  69 e7 58 0c e5 9c d5 22  17 03 03 02 6d 7c 70 9b  |i.X...."....m|p.|
+000000f0  e1 81 3a 0d 6e 7f 5c 30  2e 09 1d 82 ac 48 a6 7e  |..:.n.\0.....H.~|
+00000100  03 ce d0 ce e2 e8 9e 8b  2b ee af 1a b1 6a 3a 27  |........+....j:'|
+00000110  04 53 73 d2 d4 28 68 19  96 3a 3d 89 df 2c e3 2b  |.Ss..(h..:=..,.+|
+00000120  45 c8 5e 60 42 b0 4d f2  9c 8a 8d 83 f6 97 e0 b0  |E.^`B.M.........|
+00000130  02 39 37 46 2b 07 28 8b  e8 d8 c2 e3 ba 58 9b dc  |.97F+.(......X..|
+00000140  62 c4 e6 cb b4 97 f0 67  2b b3 40 4b 64 3e 73 3f  |b......g+.@Kd>s?|
+00000150  a1 1f 6e fe 7f ba af 7d  bd c4 7c 37 60 c0 94 d6  |..n....}..|7`...|
+00000160  bc 14 70 a9 95 a6 b7 88  9d 50 cf 9f 36 0c 38 c4  |..p......P..6.8.|
+00000170  97 ba ea 43 16 e8 fd 72  22 3c 09 4a 97 1c 97 70  |...C...r"<.J...p|
+00000180  88 6d d4 f3 9d b9 5a f3  67 f5 7b da 3e ed 1a 66  |.m....Z.g.{.>..f|
+00000190  4c 62 50 ff cd 92 08 d8  5c 2e 11 de ea 44 16 91  |LbP.....\....D..|
+000001a0  3e 44 d7 8c dd 2a b4 c7  2b 4d 40 a2 f9 7e 49 a9  |>D...*..+M@..~I.|
+000001b0  d8 51 a1 27 b3 34 75 59  04 04 cd 52 d6 37 34 e6  |.Q.'.4uY...R.74.|
+000001c0  41 32 36 45 c0 65 fb 5c  e2 21 77 7f 35 db 9d 34  |A26E.e.\.!w.5..4|
+000001d0  0d 6e 9d a7 9e 00 ec e3  3e 9c 50 50 13 5b ad b9  |.n......>.PP.[..|
+000001e0  b3 47 44 f8 9b 12 ab 50  7f a7 df 35 c5 d6 78 3c  |.GD....P...5..x<|
+000001f0  c1 04 41 db 99 18 cd 8c  05 3f 08 ae 2b 41 c9 46  |..A......?..+A.F|
+00000200  16 9a e3 a9 5b d3 9c 00  56 0e e2 d1 da 6d 6b 20  |....[...V....mk |
+00000210  65 1b 55 1f 4f b1 eb 94  c6 48 e3 50 d6 14 c5 62  |e.U.O....H.P...b|
+00000220  5e fc d2 cf df f4 68 90  c9 bb 80 54 f3 f3 a3 78  |^.....h....T...x|
+00000230  af 1f 6f ef e1 d5 64 24  04 e5 d4 59 bc 4d 7b a0  |..o...d$...Y.M{.|
+00000240  1a 23 e1 81 b7 c4 bb 52  86 f4 2a 85 d2 d0 7a ed  |.#.....R..*...z.|
+00000250  c0 5d 27 07 4b df 52 c4  ea c8 c9 9c f0 48 35 71  |.]'.K.R......H5q|
+00000260  bd 04 65 65 47 e3 21 88  ff 08 6c 6a f3 6c dd 81  |..eeG.!...lj.l..|
+00000270  3f 50 21 66 34 49 07 a0  e0 6d 80 54 77 8b 27 81  |?P!f4I...m.Tw.'.|
+00000280  4f b9 59 60 0a b0 c7 00  6a 7b 26 33 f6 5e ad 37  |O.Y`....j{&3.^.7|
+00000290  bf ea 87 e4 3c e7 b8 20  b0 89 88 ac 5a a4 af f7  |....<.. ....Z...|
+000002a0  23 3c 0a d0 ab 74 fc 49  d2 e5 51 a7 a5 4e 21 5f  |#<...t.I..Q..N!_|
+000002b0  90 9a 65 36 9f e1 e3 9e  3d 67 d6 93 f1 b8 f0 4b  |..e6....=g.....K|
+000002c0  c6 d8 ca 50 fb cc 92 ab  47 b5 8c 21 02 4a ee 42  |...P....G..!.J.B|
+000002d0  35 a3 52 41 04 94 19 cd  23 c6 33 b0 84 0d 88 97  |5.RA....#.3.....|
+000002e0  5a e0 3e 4c 6d 99 ec 6d  11 3f 19 e7 77 60 3b de  |Z.>Lm..m.?..w`;.|
+000002f0  6d 04 b8 ab bc 83 4f 51  a5 ba 56 56 d6 e3 ff 0e  |m.....OQ..VV....|
+00000300  d5 4b 75 29 6a f9 4b c6  ef fd 62 25 89 76 f1 fd  |.Ku)j.K...b%.v..|
+00000310  84 3f e9 93 63 cf eb 47  85 b1 aa a2 4c 94 6b 99  |.?..c..G....L.k.|
+00000320  98 6e 1a 19 85 0b 90 d2  9f 0f ec d4 36 1e 22 a0  |.n..........6.".|
+00000330  4e 7f a1 ae 90 15 68 8a  48 c5 06 01 aa b9 56 cb  |N.....h.H.....V.|
+00000340  e0 62 53 d8 96 56 61 1d  81 96 b8 66 ae 94 c8 5f  |.bS..Va....f..._|
+00000350  86 47 fe ca 27 8d 7f 8e  f8 74 17 03 03 00 99 ac  |.G..'....t......|
+00000360  2b 09 0b 44 a5 33 27 19  86 59 ca 75 5c df 59 fc  |+..D.3'..Y.u\.Y.|
+00000370  34 57 08 11 4f d8 1a c6  7c 76 d5 0a 36 91 f2 3a  |4W..O...|v..6..:|
+00000380  d1 96 58 64 29 3a d1 05  e3 cb 6f ea 92 4a f6 3b  |..Xd):....o..J.;|
+00000390  54 4c 16 41 99 6e 0f e9  c3 9a ac a3 59 ee fa c9  |TL.A.n......Y...|
+000003a0  4d 58 ae 23 58 58 b5 b5  d6 6a dd b4 0c 24 bf e1  |MX.#XX...j...$..|
+000003b0  d4 16 53 f2 2d e1 78 d0  ea 70 59 ac a3 e4 e4 6f  |..S.-.x..pY....o|
+000003c0  65 93 28 ad e1 64 83 11  05 42 a3 a0 11 d5 f2 af  |e.(..d...B......|
+000003d0  7e 03 93 80 82 48 e0 84  2e 1c 50 98 65 22 49 f1  |~....H....P.e"I.|
+000003e0  df 41 03 83 b2 5c 1c 56  cb b7 f3 72 04 d6 09 cf  |.A...\.V...r....|
+000003f0  f9 3a 5d e8 35 80 b6 a2  17 03 03 00 35 b4 b5 c3  |.:].5.......5...|
+00000400  43 78 3d e8 eb 66 7d 1c  36 8e a1 9f 26 ab 5a aa  |Cx=..f}.6...&.Z.|
+00000410  63 b6 2f 7a a5 f6 7d 89  1e 5d c5 a1 bf b4 3b 4a  |c./z..}..]....;J|
+00000420  89 1f 96 74 e3 c4 d8 72  57 a5 c7 99 a9 f3 77 16  |...t...rW.....w.|
+00000430  f3 25                                             |.%|
 >>> Flow 3 (client to server)
-00000000  14 03 03 00 01 01 17 03  03 02 1e 64 ba 97 ba 8d  |...........d....|
-00000010  3f 1b d5 5b c5 2e e5 b9  10 01 37 c9 5c e5 ed 39  |?..[......7.\..9|
-00000020  7f 9c 8b f8 ef 50 64 5e  30 05 16 ac 80 51 96 78  |.....Pd^0....Q.x|
-00000030  2a 50 0f 1e d8 76 ab fd  bd 7f 3b 17 7e 1d e9 f5  |*P...v....;.~...|
-00000040  03 76 1b 66 3d 15 dc f3  65 a2 aa a9 23 89 09 e9  |.v.f=...e...#...|
-00000050  dc de a6 27 fc 21 d9 97  d4 08 05 9a 1c 49 8c ee  |...'.!.......I..|
-00000060  fc bd f1 9f e2 4e 3a e3  ee 07 39 d0 34 05 cb 18  |.....N:...9.4...|
-00000070  83 2b 68 45 df 84 4b b2  c3 79 42 73 b9 f1 1c f2  |.+hE..K..yBs....|
-00000080  5f d9 5c f5 7c 4e 86 5e  97 78 ea 0a fa e7 60 68  |_.\.|N.^.x....`h|
-00000090  80 c3 17 5f e7 92 9d 6e  9a 92 37 84 92 4b 83 9c  |..._...n..7..K..|
-000000a0  fa 4c 2a 82 23 eb 67 d0  b2 cc 9e 59 8f 2c e7 bc  |.L*.#.g....Y.,..|
-000000b0  b3 4f 2a 0c 93 bf 17 b8  48 70 5e 0a 85 92 6d 2a  |.O*.....Hp^...m*|
-000000c0  ac 81 9e cd 2c 59 fc a7  e3 5b 82 d5 e3 f5 cd c2  |....,Y...[......|
-000000d0  8a 68 b8 e9 36 e2 08 0b  f7 09 9c 17 95 a3 5e 3d  |.h..6.........^=|
-000000e0  ef 7c c6 5c fe 32 9e 9d  31 c9 b7 76 5a 71 c3 d7  |.|.\.2..1..vZq..|
-000000f0  cd e3 c6 70 e5 2f 07 df  1d b4 34 56 0b ed 52 13  |...p./....4V..R.|
-00000100  bc b2 ac 66 0c 84 b0 2e  32 93 08 f2 04 91 8e e3  |...f....2.......|
-00000110  7b 7f 22 2a a9 04 50 5c  78 f1 06 c5 fd 2c 4c 77  |{."*..P\x....,Lw|
-00000120  a9 17 b5 a8 42 6d f2 0e  87 32 d3 7f be 9e 1d 09  |....Bm...2......|
-00000130  50 10 25 9d f1 a5 25 c3  c2 be 0d 8d 8e 96 5e 1c  |P.%...%.......^.|
-00000140  83 06 45 bc f0 5b 6f b5  0a 02 2a cc ce ac 7e 62  |..E..[o...*...~b|
-00000150  f0 b1 89 25 30 bc 12 d2  da f9 1d d0 46 55 97 4c  |...%0.......FU.L|
-00000160  09 39 e1 a5 1f 4d e1 aa  bd 6f 1f 0d 79 4a aa 49  |.9...M...o..yJ.I|
-00000170  73 25 dc a5 bd f7 2b 64  3c 84 ed b0 ef 13 c5 6c  |s%....+d<......l|
-00000180  16 8b 27 bf a5 3d 15 f2  4a 3b 53 ad ba e9 9e 2a  |..'..=..J;S....*|
-00000190  6d f2 44 5c 66 69 04 94  27 99 08 8e c2 7e c6 69  |m.D\fi..'....~.i|
-000001a0  f7 65 1d 0b a5 8c 35 52  0b f1 bd 59 ca d1 bf 44  |.e....5R...Y...D|
-000001b0  47 b0 7b f8 3b a0 84 55  73 c2 83 bb 9d e0 bc ed  |G.{.;..Us.......|
-000001c0  60 07 32 ce 71 b3 60 12  ef ca 28 bb 6c fb bb c7  |`.2.q.`...(.l...|
-000001d0  3e eb 05 65 a5 26 1a 6c  40 c8 b4 4e 31 12 a0 96  |>..e.&.l@..N1...|
-000001e0  19 66 86 f5 1e f8 bd 6d  f4 2e 98 60 fe ff 22 1e  |.f.....m...`..".|
-000001f0  a9 27 49 87 77 7d b4 5d  ea f8 bc 3a 10 15 84 8c  |.'I.w}.]...:....|
-00000200  cd aa 2c e8 94 93 a5 ee  db 7a d8 96 e9 d5 68 e9  |..,......z....h.|
-00000210  34 68 40 5b dd 18 dc f0  ef b7 17 72 fd 06 70 d1  |4h@[.......r..p.|
-00000220  b6 89 ae 66 40 40 f7 61  0b 17 03 03 00 a4 26 c1  |...f@@.a......&.|
-00000230  3c d9 6c 83 52 e3 5e 64  46 7f 12 1d 3d c7 7d 0f  |<.l.R.^dF...=.}.|
-00000240  a9 8f d3 45 f5 81 46 16  24 c6 c3 7e 5f e4 25 be  |...E..F.$..~_.%.|
-00000250  00 33 7a 1c 35 d4 5c 64  54 56 08 66 4d 2f 68 15  |.3z.5.\dTV.fM/h.|
-00000260  1b 71 d9 aa c9 9e e0 cc  d2 73 a9 99 41 9b 08 1f  |.q.......s..A...|
-00000270  d4 41 de e5 4f 1f 30 65  61 02 8e 6f 79 d7 47 86  |.A..O.0ea..oy.G.|
-00000280  2f e6 0e 65 9e 06 e8 98  d1 fe bc 89 b4 bc f4 9b  |/..e............|
-00000290  70 02 06 e4 9d 37 dd 1b  63 b6 06 62 1a c7 45 30  |p....7..c..b..E0|
-000002a0  9d 08 64 35 8b 96 88 9a  1e 58 2f d0 ef 44 39 04  |..d5.....X/..D9.|
-000002b0  3c bf e2 e6 c4 73 de f9  b0 10 ed 56 eb 04 bd 4e  |<....s.....V...N|
-000002c0  89 38 50 3b e7 e5 12 7c  8e 74 b2 a5 79 2d 88 7b  |.8P;...|.t..y-.{|
-000002d0  e5 1b 17 03 03 00 35 42  b2 61 24 4c 38 b5 d1 42  |......5B.a$L8..B|
-000002e0  93 12 66 c5 be 3c f0 b1  b2 6b 86 07 99 7d f3 e4  |..f..<...k...}..|
-000002f0  74 2b 43 98 38 df 70 7a  e5 f7 67 cf c3 08 23 19  |t+C.8.pz..g...#.|
-00000300  4a cf 06 26 fe 56 4a 97  4a 82 70 09 17 03 03 00  |J..&.VJ.J.p.....|
-00000310  17 9b 3f bb 09 7d 4f c9  05 42 f7 d1 a7 59 0c a7  |..?..}O..B...Y..|
-00000320  c6 9b 36 e1 46 ad 9b 89  17 03 03 00 13 ae a5 51  |..6.F..........Q|
-00000330  76 d8 3a 77 a8 a0 38 70  bf be c8 fb ff fe 53 09  |v.:w..8p......S.|
+00000000  14 03 03 00 01 01 17 03  03 02 1e 2e 1c 18 ac 6e  |...............n|
+00000010  bd d7 35 f8 21 6f 36 d7  13 94 53 3b 56 5d 03 8e  |..5.!o6...S;V]..|
+00000020  2d 92 fa cb 17 d3 75 55  13 84 9c aa be f7 34 9e  |-.....uU......4.|
+00000030  35 67 9b 90 bc 76 5d 65  c0 23 b0 04 d0 ba 15 b5  |5g...v]e.#......|
+00000040  30 70 4d 8d d2 38 73 0a  3a 58 c3 bc da a4 f5 ae  |0pM..8s.:X......|
+00000050  05 ee 0c 06 bd 06 fe ab  1b 31 cf 4d 46 63 cc ee  |.........1.MFc..|
+00000060  8f 8a 0d e9 32 50 4d a0  f6 f2 ce c5 be 41 c2 16  |....2PM......A..|
+00000070  a7 c3 b3 8a 5c 27 4a fd  37 2d 32 d9 76 25 27 12  |....\'J.7-2.v%'.|
+00000080  03 b9 e7 ef bc c8 59 e1  16 80 dc b2 16 ae 05 b6  |......Y.........|
+00000090  cf 8e 99 0d f8 ed 5a b1  bb c1 05 d5 35 fe fd 2d  |......Z.....5..-|
+000000a0  97 c6 19 d8 2d 1a a9 30  d1 4a 6d 27 45 93 5f 5d  |....-..0.Jm'E._]|
+000000b0  45 f4 98 a8 d8 88 27 8f  f2 ad 1e 24 6e c8 8f 12  |E.....'....$n...|
+000000c0  f7 32 b5 3d 3c e3 e0 32  56 4e 80 a8 5f 27 f0 d0  |.2.=<..2VN.._'..|
+000000d0  a1 c2 d0 22 2d 3a 36 0f  bd 7b 94 9f ca 8d c1 ea  |..."-:6..{......|
+000000e0  c6 1f d8 87 4a 75 bd 3e  0f ae 2f e1 78 ae 3f 00  |....Ju.>../.x.?.|
+000000f0  f4 3a 82 dd ec 3f 61 43  bf 4b f8 01 a3 32 df 13  |.:...?aC.K...2..|
+00000100  61 45 ca bb e0 9a 17 85  45 90 c6 fb 5d 79 1b 58  |aE......E...]y.X|
+00000110  54 ca 84 e9 a9 11 c4 74  82 f7 da e4 b3 4f 05 a1  |T......t.....O..|
+00000120  23 72 9f 63 b8 4c 55 e6  da 33 b9 1c b0 fe 28 72  |#r.c.LU..3....(r|
+00000130  f0 02 b6 ec 70 ae 27 d4  21 51 32 56 32 4e e7 7d  |....p.'.!Q2V2N.}|
+00000140  b8 0d 75 25 45 5c 68 83  4f e3 3e 8a 87 7c 06 81  |..u%E\h.O.>..|..|
+00000150  ac ff 23 44 0e bd e7 0a  76 64 45 c4 04 df 35 db  |..#D....vdE...5.|
+00000160  ab 8a 38 87 f5 e5 35 75  7a 92 85 3d 14 9e aa 19  |..8...5uz..=....|
+00000170  4d 94 25 8f c0 c3 37 ca  63 f3 dd 48 4a 6a 6b f5  |M.%...7.c..HJjk.|
+00000180  fa 52 67 30 ab ff 56 9f  58 bd cd 66 d4 83 85 d8  |.Rg0..V.X..f....|
+00000190  85 6c 6d 3c 56 e5 17 75  fc dc a7 3d ed 18 a1 3b  |.lm<V..u...=...;|
+000001a0  6c e6 54 95 75 38 77 77  90 34 81 cb 1c cb e9 04  |l.T.u8ww.4......|
+000001b0  c8 d2 12 04 36 a8 9b f6  9b 6a 81 8d f5 b1 e2 ca  |....6....j......|
+000001c0  31 37 27 f2 84 bd 5c 3a  1c 6c 64 83 35 94 89 ee  |17'...\:.ld.5...|
+000001d0  08 42 1d 05 52 67 e6 4d  7f bb d2 21 82 8c 15 6b  |.B..Rg.M...!...k|
+000001e0  e9 f9 6d bc b3 1f 5a df  b8 55 aa 9d f6 aa d2 7c  |..m...Z..U.....||
+000001f0  41 76 3b 1b b2 f5 b8 49  32 be bb f8 0e d3 74 be  |Av;....I2.....t.|
+00000200  eb 0d 9b e2 57 b6 ec e5  61 d7 09 80 a8 63 b4 cf  |....W...a....c..|
+00000210  bb 0a 14 9d 39 1c 08 58  22 c4 ae d5 4f 42 97 14  |....9..X"...OB..|
+00000220  71 e1 c0 a5 5e 8e 2f 89  27 17 03 03 00 a3 f0 96  |q...^./.'.......|
+00000230  d3 9e 8c 19 84 9a 42 d3  84 64 a6 89 40 6f d6 c9  |......B..d..@o..|
+00000240  50 90 bb 9d 16 90 9d fb  aa 85 28 ab 25 63 78 a9  |P.........(.%cx.|
+00000250  dd dc 35 03 73 08 26 2b  30 53 84 f8 74 66 f2 6f  |..5.s.&+0S..tf.o|
+00000260  d7 0a f0 e2 c4 10 a4 46  cf 77 ea cb b7 b7 a9 81  |.......F.w......|
+00000270  5f 09 4a 6a a5 16 a4 79  dc b0 c9 ae 5a ff 2a 7b  |_.Jj...y....Z.*{|
+00000280  3f bd 7a 15 b3 02 ad 3e  90 37 46 51 71 fc 6d d0  |?.z....>.7FQq.m.|
+00000290  9f 38 42 95 1a 88 ac 5f  83 a1 8a 59 59 62 cc 4a  |.8B...._...YYb.J|
+000002a0  57 d2 3e 1e 7e 1d c0 4d  41 23 85 5f 92 f4 63 16  |W.>.~..MA#._..c.|
+000002b0  df df 6e 3d d7 c1 e6 21  22 0f e1 13 82 29 a6 e3  |..n=...!"....)..|
+000002c0  f8 8c a4 a3 72 1d 61 c1  2a 9d a8 2d 13 8a 4f 87  |....r.a.*..-..O.|
+000002d0  91 17 03 03 00 35 9d 35  c8 ac 1e c6 46 8d e1 42  |.....5.5....F..B|
+000002e0  68 e5 79 77 64 15 e2 13  c0 70 1a 47 59 d0 1e c3  |h.ywd....p.GY...|
+000002f0  68 f7 5a fe 11 a2 3d e4  6e 2c b5 7d ea 98 e7 75  |h.Z...=.n,.}...u|
+00000300  7c 54 a4 35 9b 1f c9 ba  72 b1 94 17 03 03 00 17  ||T.5....r.......|
+00000310  a3 81 17 ac 97 a9 f0 91  b5 7a 04 38 ff fd 8e d3  |.........z.8....|
+00000320  d8 7b c4 40 7e d3 ea 17  03 03 00 13 a8 b1 06 94  |.{.@~...........|
+00000330  90 83 62 d5 be a8 23 d5  8b af 77 0d 90 13 98     |..b...#...w....|
diff --git a/src/crypto/tls/testdata/Client-TLSv13-ClientCert-Ed25519 b/src/crypto/tls/testdata/Client-TLSv13-ClientCert-Ed25519
index 26f76bc1b1..689c28750b 100644
--- a/src/crypto/tls/testdata/Client-TLSv13-ClientCert-Ed25519
+++ b/src/crypto/tls/testdata/Client-TLSv13-ClientCert-Ed25519
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,107 +16,107 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 7a 02 00 00  76 03 03 a5 5b a0 2c f5  |....z...v...[.,.|
-00000010  57 cc 49 88 64 7d ea 7c  ee 61 cf fc 94 9f d4 5c  |W.I.d}.|.a.....\|
-00000020  bb 83 80 5a f5 7c a3 fc  0a c8 61 20 00 00 00 00  |...Z.|....a ....|
+00000000  16 03 03 00 7a 02 00 00  76 03 03 4e 4c 01 f1 4e  |....z...v..NL..N|
+00000010  49 97 ec eb df ce 50 4d  1c 9c d0 35 92 10 97 0a  |I.....PM...5....|
+00000020  dd fb a8 4f 39 c6 14 21  d6 42 ac 20 00 00 00 00  |...O9..!.B. ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 01 00 00  |................|
-00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 fe  |..+.....3.$... .|
-00000060  e1 43 bd 10 b3 f6 3b 4d  7c 46 8f a3 bc 7d 08 08  |.C....;M|F...}..|
-00000070  22 ed aa 9b 7b 89 f3 87  13 7e fe 6c b0 db 3f 14  |"...{....~.l..?.|
-00000080  03 03 00 01 01 17 03 03  00 17 2b ce 52 22 34 c5  |..........+.R"4.|
-00000090  d9 2c ae d0 23 4d 0c 6e  b4 f0 c8 58 11 22 54 bb  |.,..#M.n...X."T.|
-000000a0  15 17 03 03 00 42 96 b4  72 be f0 6b d3 b0 82 7c  |.....B..r..k...||
-000000b0  dc d2 67 69 2c d4 40 a1  7a 3d 9a 39 a5 29 ca 64  |..gi,.@.z=.9.).d|
-000000c0  c5 0b d2 ba 7c c3 73 e2  93 0d 44 e3 64 ce ec b2  |....|.s...D.d...|
-000000d0  90 ae e2 df 18 f8 f5 93  5f 91 80 c2 b4 00 e7 de  |........_.......|
-000000e0  f5 3f 4d c8 de 4c 5f f0  17 03 03 02 6d c6 df 33  |.?M..L_.....m..3|
-000000f0  1e 12 40 02 7f 46 67 d8  4b 98 d7 5e f7 0a bf dc  |..@..Fg.K..^....|
-00000100  fe 3c 7f 00 2d 74 31 cb  10 35 e2 eb 16 11 d1 2f  |.<..-t1..5...../|
-00000110  10 bf 8c 4d 37 c7 1b f6  23 a3 3e 68 87 1a 50 53  |...M7...#.>h..PS|
-00000120  64 7c 0d fd 0d 06 32 93  17 85 da e0 d4 86 2c 5f  |d|....2.......,_|
-00000130  0a 91 9a fd 00 87 f1 f4  fc 18 22 a1 2e 21 44 7d  |.........."..!D}|
-00000140  6c ca 2c 0d f2 38 15 d1  9d 86 9b 67 b6 b4 06 6d  |l.,..8.....g...m|
-00000150  30 07 a8 b1 b8 7a 5d 1d  17 d0 c5 1a 40 a3 42 b5  |0....z].....@.B.|
-00000160  dc 56 c8 ec c3 c3 4e ff  5f 7c ce 27 fa a6 82 2a  |.V....N._|.'...*|
-00000170  b9 85 47 4e 0b d1 84 17  92 a6 42 86 9a 65 1c a9  |..GN......B..e..|
-00000180  45 be af a7 95 03 0b db  84 fa 5d 1b 7e 57 72 40  |E.........].~Wr@|
-00000190  ab a3 9e 46 50 3f c7 03  94 9a 4a 02 bd 9a 90 1c  |...FP?....J.....|
-000001a0  42 c9 98 e9 81 cd e8 73  a6 82 42 20 24 89 d5 8d  |B......s..B $...|
-000001b0  48 20 df d4 f4 d2 15 e4  c0 28 ee d8 2a 1b ad b8  |H .......(..*...|
-000001c0  1d a4 86 e1 b4 89 97 e8  36 63 aa 9c f4 7e 65 c6  |........6c...~e.|
-000001d0  12 86 41 54 b3 4a 79 9f  48 33 fc fc 0d f5 14 47  |..AT.Jy.H3.....G|
-000001e0  ba ae d3 20 64 37 f1 cd  9e 1b cc b2 27 68 e6 f2  |... d7......'h..|
-000001f0  95 0c 29 59 f2 15 2e 97  60 f3 8d 1b b1 65 cd 4f  |..)Y....`....e.O|
-00000200  0d a5 0a 34 59 63 20 f0  71 e6 d5 13 f2 4e dc 73  |...4Yc .q....N.s|
-00000210  5b 1a 36 d7 6a aa b0 30  f4 ff 68 ad f5 5e f0 12  |[.6.j..0..h..^..|
-00000220  0c 34 a8 4d 91 03 8e 4a  30 07 23 49 41 7a fe 19  |.4.M...J0.#IAz..|
-00000230  62 5b 6a a0 4d d5 54 a1  1f 45 91 86 b3 a1 c3 32  |b[j.M.T..E.....2|
-00000240  62 79 a8 93 b3 d4 43 0c  a8 12 10 4f f5 53 c3 3b  |by....C....O.S.;|
-00000250  d9 73 ef 42 be 1d f5 70  fd 9f ca 54 20 3a 33 c9  |.s.B...p...T :3.|
-00000260  f6 e8 55 13 b3 ab 45 c8  bb 5c 6b b9 39 a9 04 ac  |..U...E..\k.9...|
-00000270  1c 3c 5a aa b7 91 2c 0c  f6 74 ea 6b 2d e2 9a 3c  |.<Z...,..t.k-..<|
-00000280  d0 30 d8 14 e5 8c bf 06  2c d3 89 2e 0d ad df c5  |.0......,.......|
-00000290  5b 6d fa 8f 0c 64 cc 40  04 12 97 ab ab ff be d8  |[m...d.@........|
-000002a0  a6 fc 78 1d d4 18 90 bf  b4 8e ce 09 40 8c dd 8a  |..x.........@...|
-000002b0  a8 cc 86 ce 6d a8 0c f8  79 66 f6 0b 46 2b 0d 4c  |....m...yf..F+.L|
-000002c0  73 14 dd cd 2c 56 77 f7  1f 4d 85 d0 1c 16 da 26  |s...,Vw..M.....&|
-000002d0  b0 65 39 31 b5 cd f3 7a  80 52 96 6d 81 1e 65 98  |.e91...z.R.m..e.|
-000002e0  b2 a3 12 22 52 68 c5 59  19 a1 9a be 80 5c 25 57  |..."Rh.Y.....\%W|
-000002f0  9b 60 e9 95 28 4b 77 a0  70 ce 4b 5b 70 37 0a e3  |.`..(Kw.p.K[p7..|
-00000300  7e 2c c7 0e 1c 6b 3a 54  2c 0d b3 53 0c f4 12 66  |~,...k:T,..S...f|
-00000310  c6 17 04 88 f5 12 58 d8  2c 70 54 85 2b 71 ee 98  |......X.,pT.+q..|
-00000320  75 8d e4 57 7c 96 a2 44  12 77 f0 6d 8a 12 89 b3  |u..W|..D.w.m....|
-00000330  8b 85 bf 33 d9 ee de 24  b5 7d d5 cb 0d d4 9b bf  |...3...$.}......|
-00000340  c6 e3 27 44 f2 35 35 09  00 86 eb 8b 34 c4 c4 6a  |..'D.55.....4..j|
-00000350  fe 95 e9 80 58 4f 3e 99  24 f8 17 03 03 00 99 de  |....XO>.$.......|
-00000360  1b f5 7a dc 63 8d 5e 75  de 72 cf 41 ca 75 ab d9  |..z.c.^u.r.A.u..|
-00000370  55 b0 b5 81 a9 6c a9 f6  1d ea 66 dd dd 86 f5 03  |U....l....f.....|
-00000380  12 08 9d b4 07 48 eb 8b  45 f1 35 b1 31 bd 5d f3  |.....H..E.5.1.].|
-00000390  e2 34 73 9a e5 87 b7 8b  0b 8b ab 7e 05 db 56 db  |.4s........~..V.|
-000003a0  4f 4c 52 1a 3b 5d 4c 53  b1 49 40 81 5e 73 af 26  |OLR.;]LS.I@.^s.&|
-000003b0  21 e6 e3 5c 4a a6 f6 07  56 de f5 76 5c 67 d8 d5  |!..\J...V..v\g..|
-000003c0  eb f3 6a fb 6d b7 00 bc  6b 28 c9 63 4d 58 76 97  |..j.m...k(.cMXv.|
-000003d0  aa 51 2b f3 03 9c 70 3b  3e b2 a4 16 a0 a0 e0 43  |.Q+...p;>......C|
-000003e0  77 da 88 2d 48 3b 07 e2  8d a6 e2 80 85 68 ac dc  |w..-H;.......h..|
-000003f0  ce 66 2f 97 20 9e 4e 33  17 03 03 00 35 f6 ce 98  |.f/. .N3....5...|
-00000400  8b 01 f5 75 8e 98 42 02  b1 b8 90 f3 08 96 e8 5a  |...u..B........Z|
-00000410  d4 7c ef d1 62 1e b3 36  39 d9 b2 59 1f 1f cc 74  |.|..b..69..Y...t|
-00000420  f2 a8 62 11 00 28 31 fa  d9 5a 27 10 7b 93 ff de  |..b..(1..Z'.{...|
-00000430  a0 ec                                             |..|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 03 00 00  |................|
+00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 c1  |..+.....3.$... .|
+00000060  c2 ca 32 aa 48 d8 52 bc  c8 23 6d 98 18 3e 15 b6  |..2.H.R..#m..>..|
+00000070  0b 25 db f9 6f a7 e1 75  95 a1 46 d3 47 4a 0e 14  |.%..o..u..F.GJ..|
+00000080  03 03 00 01 01 17 03 03  00 17 87 10 92 da b4 9a  |................|
+00000090  03 a5 0f 73 e6 93 cb 71  1d 58 6e 5d 27 eb ee b6  |...s...q.Xn]'...|
+000000a0  c7 17 03 03 00 42 89 8d  57 16 95 5b f0 98 ad c7  |.....B..W..[....|
+000000b0  d7 94 ba 4d 7e 88 b9 8d  13 26 a6 6c 81 90 a6 1e  |...M~....&.l....|
+000000c0  2b 4e 91 70 e2 da 9d a2  0d 6f 9b 5b ee 69 58 a1  |+N.p.....o.[.iX.|
+000000d0  4c c3 59 57 28 62 b3 ed  26 15 79 db 01 8c 88 e3  |L.YW(b..&.y.....|
+000000e0  63 1f bc b0 01 c9 82 ca  17 03 03 02 6d e5 d6 77  |c...........m..w|
+000000f0  4e d3 af c3 5e 01 e9 1b  31 63 a4 84 d3 cc 2d f8  |N...^...1c....-.|
+00000100  5d 73 f9 3e 83 03 c5 c5  cd 95 00 7b f2 b5 79 fa  |]s.>.......{..y.|
+00000110  47 e5 07 89 a9 22 49 7a  7e 7e 6e d2 3b 68 e8 9c  |G...."Iz~~n.;h..|
+00000120  40 1c 86 2a 48 ee 59 8e  1c 04 8b 91 20 68 65 31  |@..*H.Y..... he1|
+00000130  e7 76 dc 6c 5a ce cb 32  d3 e8 71 7f 93 08 b5 01  |.v.lZ..2..q.....|
+00000140  84 0a b4 ec 80 68 69 9b  b3 4a 4a 4d 56 16 eb 42  |.....hi..JJMV..B|
+00000150  29 93 4d b4 76 f6 e0 15  fe 25 b1 cb 5a da 22 4b  |).M.v....%..Z."K|
+00000160  88 4c ec 66 48 09 e1 d1  0f 3e 3a ad 65 d7 d7 85  |.L.fH....>:.e...|
+00000170  1d cb 35 2c 84 60 ec a1  6d f1 60 cf c6 c7 82 1a  |..5,.`..m.`.....|
+00000180  7c 91 40 2e 3e 88 1f ff  79 2e 6e 97 c5 45 9f e1  ||.@.>...y.n..E..|
+00000190  bf 33 ad 65 df f3 ce 1a  d7 57 7e db f2 28 79 a9  |.3.e.....W~..(y.|
+000001a0  9e 4f 9e 8a ce 02 5a 18  bb f1 ac 72 5b 3f 4c 6b  |.O....Z....r[?Lk|
+000001b0  97 14 14 f9 82 8a 4f 99  21 98 db af 3e 08 ab 4f  |......O.!...>..O|
+000001c0  d8 3f f6 cc da 76 77 eb  02 39 0a 00 23 a5 e0 92  |.?...vw..9..#...|
+000001d0  01 10 3f 76 ab 1a 38 8e  f9 a1 d0 25 c3 9d 50 a4  |..?v..8....%..P.|
+000001e0  ef a5 8c f8 5d bc d9 fd  dd 25 cd 42 38 52 d1 cd  |....]....%.B8R..|
+000001f0  d2 1b fc ba 7d 8b bd 82  05 23 c3 9d 02 ff 1b 4e  |....}....#.....N|
+00000200  08 e1 f3 7c 35 15 0f e8  0e b7 8a e5 4a 2b da 45  |...|5.......J+.E|
+00000210  4a 72 9a 32 7e 55 52 65  d2 a8 32 90 53 bf 25 29  |Jr.2~URe..2.S.%)|
+00000220  1e 8d d7 a3 22 d6 40 19  95 58 a8 37 af a8 52 e7  |....".@..X.7..R.|
+00000230  79 b9 4e 61 d8 f0 7d d2  69 25 99 28 3f 31 f6 b2  |y.Na..}.i%.(?1..|
+00000240  44 65 1f 9c 41 08 17 c9  01 5d 20 ea ab fe 06 64  |De..A....] ....d|
+00000250  9a f4 d0 24 e0 b5 88 0a  2b 96 e9 71 11 a8 49 b4  |...$....+..q..I.|
+00000260  40 62 1b 45 15 47 cb a5  fc 4f 07 58 2b ef d4 5d  |@b.E.G...O.X+..]|
+00000270  df 40 38 6c 6e ca 63 c5  95 2d 79 26 86 ff 33 02  |.@8ln.c..-y&..3.|
+00000280  da 5a 85 0c 8f 7f 58 ba  ea 88 cf bc 51 92 12 86  |.Z....X.....Q...|
+00000290  f1 c1 f9 0a d0 6e cc b4  2b 16 98 ad f8 11 ad 63  |.....n..+......c|
+000002a0  82 d7 4e ea a5 ee 78 a2  9a 35 b6 b3 d9 24 cf 66  |..N...x..5...$.f|
+000002b0  03 d2 25 1f 15 37 c7 b5  8e bb 0a 40 0f 28 c2 16  |..%..7.....@.(..|
+000002c0  90 a4 61 9e dd fd b5 ad  97 39 0d 66 e7 fa 5b e2  |..a......9.f..[.|
+000002d0  c2 ef 44 5d 44 07 d6 c3  ed e2 89 6e 4c ed 79 42  |..D]D......nL.yB|
+000002e0  86 3b f4 94 0c 82 5e 52  ce 00 ab 5c 20 b4 18 db  |.;....^R...\ ...|
+000002f0  c9 fe 8b be 8d da e9 86  13 62 6b 8d 0d 57 c8 fe  |.........bk..W..|
+00000300  a6 4b 82 52 d5 d8 05 18  2f a0 43 d6 c8 89 fb e7  |.K.R..../.C.....|
+00000310  72 17 61 89 36 5b e0 aa  4d 6c 20 ee 68 db 32 e4  |r.a.6[..Ml .h.2.|
+00000320  97 9f 18 26 7c 1a cd e8  b9 05 ae fd 86 bf 0e 47  |...&|..........G|
+00000330  09 06 bd de 2d b9 50 6a  0c a6 27 04 5e aa e0 ce  |....-.Pj..'.^...|
+00000340  e7 cf 98 f9 7e 7d b9 4d  77 9a 88 3a d4 41 07 cc  |....~}.Mw..:.A..|
+00000350  87 b6 41 53 8b 8c 79 8e  07 b9 17 03 03 00 99 0b  |..AS..y.........|
+00000360  63 4e d8 79 d7 11 f2 46  00 6c 5d d2 9e 49 df 7e  |cN.y...F.l]..I.~|
+00000370  f2 96 1a 68 9d 6a 05 dc  61 45 47 a4 18 5c 65 04  |...h.j..aEG..\e.|
+00000380  00 38 d1 25 0c ff a3 a2  c0 c2 82 7f b1 1b a1 c6  |.8.%............|
+00000390  7b ac fb 71 48 b6 e4 e2  7b c4 d0 44 8e 22 d6 91  |{..qH...{..D."..|
+000003a0  99 87 a2 88 3d bb b4 80  13 57 2a 6a b0 2d 52 16  |....=....W*j.-R.|
+000003b0  d3 f2 e4 cd d0 79 9a 31  ce 68 65 b3 61 67 a0 b9  |.....y.1.he.ag..|
+000003c0  1e 6b 9f 73 dc 46 be 5e  df d7 c2 30 d5 60 b5 e5  |.k.s.F.^...0.`..|
+000003d0  60 cc 10 ae 9a f9 b6 9a  fd 14 b9 1e b7 3c 1d 3e  |`............<.>|
+000003e0  34 a6 49 d2 48 f7 24 56  29 c9 98 f1 33 b1 e5 5e  |4.I.H.$V)...3..^|
+000003f0  2c 7b bb 5f b6 53 6a c8  17 03 03 00 35 d9 af 32  |,{._.Sj.....5..2|
+00000400  1f a5 09 3f 8a 10 df a7  34 9b f8 ec 07 81 80 73  |...?....4......s|
+00000410  dc ba 09 fc 40 e4 1e df  f6 de 02 54 3c 7d ea 49  |....@......T<}.I|
+00000420  91 16 72 70 8e 1a 21 76  c6 00 0e 03 9f 0a 82 fe  |..rp..!v........|
+00000430  4c 18                                             |L.|
 >>> Flow 3 (client to server)
-00000000  14 03 03 00 01 01 17 03  03 01 50 57 2a 94 d7 c1  |..........PW*...|
-00000010  40 42 d3 aa e3 d8 b3 e4  13 ff 51 ee 8a 52 9d 9c  |@B........Q..R..|
-00000020  c4 a4 40 91 72 0f c9 4e  fe 56 22 89 ea fb 6d 05  |..@.r..N.V"...m.|
-00000030  a2 96 97 4b fa ef ec 13  b6 13 3b 69 6c 65 c0 74  |...K......;ile.t|
-00000040  e5 54 df a4 97 50 f7 85  a1 c7 fb 52 84 56 98 16  |.T...P.....R.V..|
-00000050  52 b6 eb 5a d0 72 6e 65  98 81 bb f5 2a 4c ed 1a  |R..Z.rne....*L..|
-00000060  90 e1 01 a6 2b eb e0 1d  06 ba 8a d4 47 45 90 f0  |....+.......GE..|
-00000070  91 bd c4 d7 54 ba 44 30  78 42 15 42 74 59 1c c7  |....T.D0xB.BtY..|
-00000080  56 34 39 64 8e f8 0a 0f  2b 35 0f 06 97 34 3e 5e  |V49d....+5...4>^|
-00000090  00 00 5a f0 07 0a f5 66  46 86 94 8c 0b 62 1c fd  |..Z....fF....b..|
-000000a0  cc cf fd 5d 06 96 1e 21  9e 20 d5 07 5f 5a 00 9f  |...]...!. .._Z..|
-000000b0  6f 80 36 5e aa 56 d0 07  00 20 08 55 48 fe 6c a1  |o.6^.V... .UH.l.|
-000000c0  b1 22 f3 94 54 7e 7e d5  e9 f0 71 69 01 fc bd 14  |."..T~~...qi....|
-000000d0  a1 de 38 e4 b4 02 88 3e  66 77 3b f7 aa cd 57 a3  |..8....>fw;...W.|
-000000e0  cf 6a 40 7d 93 75 79 3b  95 07 33 69 b2 8d 2a 37  |.j@}.uy;..3i..*7|
-000000f0  94 d3 8d d5 b5 8a f0 94  8d 1e b4 9e 02 4f 7d 83  |.............O}.|
-00000100  05 c6 c7 c8 a0 74 f1 88  f7 68 bf 4b e4 18 3b 6f  |.....t...h.K..;o|
-00000110  0c 6c a6 e7 75 50 b9 f6  68 2e 05 67 a3 47 df 22  |.l..uP..h..g.G."|
-00000120  fa ae c1 4f a8 3d f3 bb  dc 66 c3 b6 98 b7 8c 5b  |...O.=...f.....[|
-00000130  48 51 57 d7 43 b2 13 25  9e d5 82 6c 70 5c 42 53  |HQW.C..%...lp\BS|
-00000140  a9 e8 8a 12 26 cd 3a f8  f8 e5 97 84 55 89 09 d4  |....&.:.....U...|
-00000150  d4 20 40 d7 2d 6f 66 36  63 f6 53 17 03 03 00 59  |. @.-of6c.S....Y|
-00000160  2f f6 22 ce f3 86 f8 ee  b1 f6 49 de c8 bf 91 9c  |/.".......I.....|
-00000170  bc 2f fa 75 af 51 bc ee  b7 a5 a9 82 35 3b 83 9d  |./.u.Q......5;..|
-00000180  3d 9f 57 10 07 4b af 01  66 f0 39 dd f0 4a a7 90  |=.W..K..f.9..J..|
-00000190  f3 6c 28 97 80 0d a5 74  2d 22 a3 81 cd 64 2b 1a  |.l(....t-"...d+.|
-000001a0  d1 4e 2d 9e 8e 69 38 f8  11 9c 17 1f e6 c9 01 4e  |.N-..i8........N|
-000001b0  48 1f 80 43 26 d4 5a 82  30 17 03 03 00 35 e9 25  |H..C&.Z.0....5.%|
-000001c0  b9 01 8e 0d 51 be 9d d1  b4 2b 0a ee 36 69 85 1a  |....Q....+..6i..|
-000001d0  10 a8 ff 36 e7 21 b7 f2  54 75 ca 07 52 88 48 d0  |...6.!..Tu..R.H.|
-000001e0  ad 67 0b 92 52 70 fa 14  bc 7e 1d 43 f0 a2 7b df  |.g..Rp...~.C..{.|
-000001f0  ac 0c 19 17 03 03 00 17  98 76 d7 52 06 90 ef 00  |.........v.R....|
-00000200  21 5e ec ed 0e 35 77 ef  5c f1 32 58 33 0f 06 17  |!^...5w.\.2X3...|
-00000210  03 03 00 13 05 fb b3 c3  4d b5 a4 9c 52 ea bc d2  |........M...R...|
-00000220  86 08 26 b8 df 5c 4c                              |..&..\L|
+00000000  14 03 03 00 01 01 17 03  03 01 50 1d 6e 16 0d 4e  |..........P.n..N|
+00000010  c0 a2 41 c3 a2 84 c9 80  c0 f0 ef c0 5d 3a 3b f2  |..A.........]:;.|
+00000020  bf 1c 9e 79 d7 d3 94 0b  41 2d bc 50 eb 0f 60 f4  |...y....A-.P..`.|
+00000030  bd cd f6 03 22 7b 68 68  44 34 c9 0f 23 ca 76 6f  |...."{hhD4..#.vo|
+00000040  f2 97 38 07 43 56 7e b7  ce 67 68 67 37 34 d0 f7  |..8.CV~..ghg74..|
+00000050  c5 92 fd 65 98 b8 7e 5f  48 a8 a3 aa a8 96 65 b5  |...e..~_H.....e.|
+00000060  48 be 91 99 67 0a 37 c7  31 b4 43 ba 26 bb 87 98  |H...g.7.1.C.&...|
+00000070  3c 55 e4 63 b0 33 ca ee  0a a5 fe 36 88 ef cf f0  |<U.c.3.....6....|
+00000080  ab 6b 7d e8 f6 1f 14 12  49 f7 14 b7 12 bb d8 1e  |.k}.....I.......|
+00000090  e0 be ed 56 75 b9 ab 8a  20 75 d9 6f 45 2d 71 b3  |...Vu... u.oE-q.|
+000000a0  2f b7 cd 9c c5 16 ed 37  0e 08 15 a5 49 18 7c 13  |/......7....I.|.|
+000000b0  8e 0b 66 01 b1 8c 1d 89  d4 91 9e 5a 6b 94 f6 fa  |..f........Zk...|
+000000c0  7b a8 14 1c a7 20 55 c5  e4 0e 9d e0 5b d6 d4 b7  |{.... U.....[...|
+000000d0  1d 93 2b 7c 25 46 28 11  06 57 a3 cb 2f 4b 39 cf  |..+|%F(..W../K9.|
+000000e0  61 be 60 9a fd f1 6e e1  a2 a7 20 f2 fd 50 a2 d2  |a.`...n... ..P..|
+000000f0  17 db 16 4f 3f 8c 20 e4  4d 56 37 3b c2 42 17 cc  |...O?. .MV7;.B..|
+00000100  5d 99 06 fc 18 0d 1a 88  e8 f9 6f cf 7d 2e 57 73  |].........o.}.Ws|
+00000110  85 47 ed d0 2d b3 9a 05  cf 0c 7d e6 ed 29 95 f4  |.G..-.....}..)..|
+00000120  d5 e0 96 6a 1d 67 3e 5f  43 9f b5 f6 66 f5 84 63  |...j.g>_C...f..c|
+00000130  bd 42 a6 f8 ef 38 42 8a  d8 28 dc 55 e5 88 03 76  |.B...8B..(.U...v|
+00000140  96 ba 89 35 63 7e 6c da  39 d8 9a 27 04 ab d5 0e  |...5c~l.9..'....|
+00000150  48 89 cc 81 25 44 61 16  2c b2 69 17 03 03 00 59  |H...%Da.,.i....Y|
+00000160  81 8f 94 30 8d fc 47 13  7e 84 06 9b 4a 85 2c bb  |...0..G.~...J.,.|
+00000170  b3 a0 0d 4f 50 6a cb 0b  9b 40 ef cc 84 70 1f 69  |...OPj...@...p.i|
+00000180  b9 3e a6 c4 ba 66 eb a9  6f 78 83 7f d4 1f d8 c4  |.>...f..ox......|
+00000190  b0 f6 9b 03 29 7f b1 f8  60 40 0b 28 91 32 2c 03  |....)...`@.(.2,.|
+000001a0  aa 9e 7b fb 99 c2 11 51  1f a7 81 69 16 39 f4 52  |..{....Q...i.9.R|
+000001b0  ca d8 d0 f3 87 6f 58 ab  9a 17 03 03 00 35 de 03  |.....oX......5..|
+000001c0  88 61 50 5c 08 88 77 28  6a 1d 28 44 3d 49 8b 79  |.aP\..w(j.(D=I.y|
+000001d0  d1 a2 13 67 95 0f 7c 18  fe e2 e0 07 f1 ce b9 be  |...g..|.........|
+000001e0  79 aa 40 d6 cf 66 53 ac  15 ae 2a 14 a9 63 98 55  |y.@..fS...*..c.U|
+000001f0  96 16 6f 17 03 03 00 17  a8 ac 17 c5 eb d9 8e 77  |..o............w|
+00000200  9e 4b e0 20 c6 0c 34 b6  c3 ab c4 b6 8b b2 77 17  |.K. ..4.......w.|
+00000210  03 03 00 13 58 d4 7b 8f  ca 20 41 e3 3f d1 ae cf  |....X.{.. A.?...|
+00000220  3d e1 86 91 c0 a1 08                              |=......|
diff --git a/src/crypto/tls/testdata/Client-TLSv13-ClientCert-RSA-ECDSA b/src/crypto/tls/testdata/Client-TLSv13-ClientCert-RSA-ECDSA
index 09de5cca83..8e361eaf4f 100644
--- a/src/crypto/tls/testdata/Client-TLSv13-ClientCert-RSA-ECDSA
+++ b/src/crypto/tls/testdata/Client-TLSv13-ClientCert-RSA-ECDSA
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,119 +16,119 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 7a 02 00 00  76 03 03 cc a2 2d 09 42  |....z...v....-.B|
-00000010  f0 11 87 04 64 83 e4 d8  80 a5 0f 88 69 ae f1 d2  |....d.......i...|
-00000020  12 05 d2 08 75 15 86 b7  d8 69 e7 20 00 00 00 00  |....u....i. ....|
+00000000  16 03 03 00 7a 02 00 00  76 03 03 30 0a c5 df b0  |....z...v..0....|
+00000010  90 3a 48 4b 20 f1 89 62  be 1f 1b 64 c2 7e 69 25  |.:HK ..b...d.~i%|
+00000020  9f b7 f9 2c 86 e7 40 e7  e8 10 fa 20 00 00 00 00  |...,..@.... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 01 00 00  |................|
-00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 c9  |..+.....3.$... .|
-00000060  b4 93 8b 5b b0 ae 93 4a  01 26 0c fb db 3f 53 0b  |...[...J.&...?S.|
-00000070  04 ca 65 63 3f d7 d9 f9  fc ca ea 4c f2 08 3c 14  |..ec?......L..<.|
-00000080  03 03 00 01 01 17 03 03  00 17 85 f6 ff f8 58 7f  |..............X.|
-00000090  2a d9 e0 12 82 d6 31 64  29 70 05 24 0f 17 1e 9f  |*.....1d)p.$....|
-000000a0  dc 17 03 03 00 42 16 7b  d5 fa a6 30 94 8e a0 a7  |.....B.{...0....|
-000000b0  24 59 b9 3d 85 b0 2f d9  25 c6 5a b5 7f 51 ca 54  |$Y.=../.%.Z..Q.T|
-000000c0  4a f7 f0 72 bb dd 5e 70  14 6d 46 3f b3 86 6f c1  |J..r..^p.mF?..o.|
-000000d0  a4 5f 6d ba 97 f3 38 c0  24 4a 9f de 7b b9 49 12  |._m...8.$J..{.I.|
-000000e0  71 02 f8 bc bc 65 5a ea  17 03 03 02 22 f9 92 7e  |q....eZ....."..~|
-000000f0  34 eb b3 a4 03 8e ec 48  30 a0 9b ac a6 7b b3 a5  |4......H0....{..|
-00000100  d0 4a 89 2c 92 6a c6 04  de b2 86 72 0a f1 97 61  |.J.,.j.....r...a|
-00000110  da 70 ef 25 5a a3 f1 b3  3d 78 f1 ec 2b 8f 34 2b  |.p.%Z...=x..+.4+|
-00000120  c9 94 e7 d2 9e 2f 09 5d  7a e3 2e fc 6e e1 ef 80  |...../.]z...n...|
-00000130  e6 0c e9 3e 07 bb b7 0e  74 0c e8 19 fe 7f d8 d0  |...>....t.......|
-00000140  fa 70 03 c1 31 c2 76 51  c3 d0 ed a6 a1 0d 20 74  |.p..1.vQ...... t|
-00000150  86 15 99 51 71 f8 3d 8e  1c 8c a8 19 0a 9c ac 4a  |...Qq.=........J|
-00000160  ab 0e e6 cc 52 a0 a8 ca  d9 71 54 aa 2c 8b 6f 5b  |....R....qT.,.o[|
-00000170  f9 46 07 0d 86 40 d9 54  33 8e de 54 a5 c2 6e 36  |.F...@.T3..T..n6|
-00000180  14 0e e3 52 78 05 56 90  98 2c e1 ec 26 f6 bd 6a  |...Rx.V..,..&..j|
-00000190  e5 0b 31 e1 a4 2a 2a 96  1b d6 57 87 ac a8 07 71  |..1..**...W....q|
-000001a0  83 d9 70 1e 5e 63 9b d1  01 83 e7 c9 c8 1c 5a 34  |..p.^c........Z4|
-000001b0  05 c0 7b da 1c ca 5f 99  49 9a 04 da c9 1c 9b ed  |..{..._.I.......|
-000001c0  b4 af 9d ff 36 71 1b 3a  00 e8 6a c4 6e 47 d9 4a  |....6q.:..j.nG.J|
-000001d0  64 f5 c1 07 ab 19 c8 65  a3 33 26 99 be 53 c3 86  |d......e.3&..S..|
-000001e0  97 10 ef c1 54 8e 69 6c  b1 29 aa 7d c1 63 67 ba  |....T.il.).}.cg.|
-000001f0  d7 72 7c 74 83 58 bd 5a  a8 a8 5f 49 38 ee 1e 34  |.r|t.X.Z.._I8..4|
-00000200  c8 98 19 73 97 2d 76 e6  d7 0d 15 75 a0 98 1f 15  |...s.-v....u....|
-00000210  c9 b8 3d 3f cb 92 a1 39  4b 91 ca e0 d2 0e 38 c2  |..=?...9K.....8.|
-00000220  20 eb f2 b5 04 64 fa d8  e2 d7 2f ba 88 7e f4 37  | ....d..../..~.7|
-00000230  c1 68 c4 2f c9 54 a1 21  5d 4b e7 67 3b 2e 6a 06  |.h./.T.!]K.g;.j.|
-00000240  55 ba d4 8d fe 0e b1 b7  2d cf c2 82 ed 27 3d 5b  |U.......-....'=[|
-00000250  9b 3b 28 a9 d4 c4 3c a0  45 b1 77 37 8b f8 7e f0  |.;(...<.E.w7..~.|
-00000260  51 90 fe 7a 74 14 ac f7  59 8b ed be 79 b0 4b 89  |Q..zt...Y...y.K.|
-00000270  d9 0c 39 fe 45 9d 15 0c  a6 96 26 0d b2 29 b0 a4  |..9.E.....&..)..|
-00000280  29 62 df 4b c0 a0 05 f1  e8 8b 16 af ea 42 8b 58  |)b.K.........B.X|
-00000290  5a ae f6 28 d8 40 09 d1  1e 21 b3 c7 a8 e2 30 4a  |Z..(.@...!....0J|
-000002a0  27 e6 c4 ba ff 62 91 7b  ab 64 18 65 02 e2 10 68  |'....b.{.d.e...h|
-000002b0  87 35 c2 09 5b 23 a4 eb  96 19 a7 1e 75 85 6e 17  |.5..[#......u.n.|
-000002c0  0e bc 11 1a f5 49 05 92  f7 0e e4 c7 85 da 4e 26  |.....I........N&|
-000002d0  5b de f2 dc 36 fb dc dd  c6 42 23 0c a7 de 8d ad  |[...6....B#.....|
-000002e0  f5 2a 8b ff b4 5d c6 ca  ec e3 83 a4 1e 23 3a 2d  |.*...].......#:-|
-000002f0  1a 52 51 11 f5 3b 93 47  89 c8 fc 21 b0 a3 4f b3  |.RQ..;.G...!..O.|
-00000300  6e d2 83 ca 20 75 fc 43  43 e5 1d 5d 57 c9 7c 17  |n... u.CC..]W.|.|
-00000310  03 03 00 a4 dc 79 73 47  d4 f5 72 c9 12 46 ed 3c  |.....ysG..r..F.<|
-00000320  d0 61 20 81 a9 ad 64 f3  f1 77 7f f1 74 09 67 80  |.a ...d..w..t.g.|
-00000330  c1 08 07 9c 50 b8 7d f5  70 f5 c6 a1 5f ba 37 78  |....P.}.p..._.7x|
-00000340  58 37 e3 f4 3f 03 1d 69  6f af 2f 2b 8b 10 95 5a  |X7..?..io./+...Z|
-00000350  be a1 5c b8 42 61 65 5a  27 35 f6 b4 57 3d 3a 6b  |..\.BaeZ'5..W=:k|
-00000360  f4 e9 90 88 7b e3 7c bf  be 51 19 0e 51 53 cd 10  |....{.|..Q..QS..|
-00000370  2c 70 76 9e d1 32 28 8f  c4 6c 01 2c 46 8f 4d 14  |,pv..2(..l.,F.M.|
-00000380  21 a2 63 39 44 b3 03 0d  a3 9d a0 c8 f4 cf 5d 7e  |!.c9D.........]~|
-00000390  d2 17 05 ee 9c 5c 1a 2e  43 dc 3f 6d d9 f2 54 5d  |.....\..C.?m..T]|
-000003a0  64 ff d2 1c 21 73 66 b1  2c 21 9d 3f bf fe f8 a5  |d...!sf.,!.?....|
-000003b0  79 54 fe 8a d5 3d 5f f6  17 03 03 00 35 0f 01 eb  |yT...=_.....5...|
-000003c0  f8 46 f8 07 7a 06 69 45  e2 47 4d b0 eb 9c 82 8b  |.F..z.iE.GM.....|
-000003d0  5d d0 59 66 d1 b5 a2 7b  b2 f0 72 6f 34 8b 2c 05  |].Yf...{..ro4.,.|
-000003e0  84 53 1c 7b 24 d8 f0 cd  a3 46 d1 ed 08 22 bb e6  |.S.{$....F..."..|
-000003f0  38 98                                             |8.|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 03 00 00  |................|
+00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 94  |..+.....3.$... .|
+00000060  e8 ab 87 65 c8 dd 6f ee  b4 d6 0b bb fd 18 9a 2d  |...e..o........-|
+00000070  e4 bc c6 20 98 09 71 65  7d 54 35 73 22 99 1b 14  |... ..qe}T5s"...|
+00000080  03 03 00 01 01 17 03 03  00 17 37 b7 eb eb a2 9f  |..........7.....|
+00000090  7f 00 8c 9d a9 50 7c 0c  15 31 63 71 45 7a 3d ee  |.....P|..1cqEz=.|
+000000a0  5e 17 03 03 00 42 9f 23  07 cf d0 bc e8 bb 95 01  |^....B.#........|
+000000b0  37 94 18 2e 05 02 8a eb  0a 37 10 79 51 a9 d4 43  |7........7.yQ..C|
+000000c0  18 18 e6 00 9d 68 ff 74  f3 9c 19 bf 5e 51 0c 47  |.....h.t....^Q.G|
+000000d0  61 35 8c b2 58 5f 32 bc  88 c4 fb 5a 22 61 14 98  |a5..X_2....Z"a..|
+000000e0  28 26 8c 75 9d 1d 19 05  17 03 03 02 22 d2 2c 1a  |(&.u........".,.|
+000000f0  e5 58 0d d7 0b c4 66 b2  06 90 bc 92 0f 05 34 5d  |.X....f.......4]|
+00000100  2b 20 26 02 cc ac 90 40  a0 f1 5f 0e b9 99 7c 0f  |+ &....@.._...|.|
+00000110  c9 3e 60 0b 39 ec 6c 94  3a d4 f7 b7 49 5e c7 6e  |.>`.9.l.:...I^.n|
+00000120  df 3b cc 33 cb 32 41 53  dd 09 8e 91 97 d2 e0 06  |.;.3.2AS........|
+00000130  5e 0c 4c 49 46 18 83 fc  ac b4 f8 76 2d 18 ee 0b  |^.LIF......v-...|
+00000140  b6 4a b9 aa eb ee db 7a  aa 6d 04 84 ed 8e 15 bc  |.J.....z.m......|
+00000150  bf 6f a1 29 bc 0b 9f ba  05 a5 42 82 fd 1c 30 c9  |.o.)......B...0.|
+00000160  20 df 8e ba 28 ab 0b a2  42 09 5e e8 c1 61 d2 25  | ...(...B.^..a.%|
+00000170  fc 05 53 62 91 45 29 54  60 31 b8 4f 01 9c 7b 6a  |..Sb.E)T`1.O..{j|
+00000180  04 27 df bc e0 a0 3d b3  80 73 22 ca 9b 41 be b6  |.'....=..s"..A..|
+00000190  09 22 67 1e 54 52 ce 14  b5 56 7a ca 3f a8 3e 01  |."g.TR...Vz.?.>.|
+000001a0  d2 e4 36 18 87 f6 08 19  55 d2 ba 3c a3 c5 11 84  |..6.....U..<....|
+000001b0  62 2a 09 c6 67 de cd ab  66 12 dd 0a 23 77 18 b7  |b*..g...f...#w..|
+000001c0  73 c1 29 61 52 32 95 eb  a0 db 72 ae b7 ff 2a b2  |s.)aR2....r...*.|
+000001d0  08 f6 d7 69 32 c2 f8 8b  e1 40 a9 d0 fe 11 64 a2  |...i2....@....d.|
+000001e0  a2 dd a7 e6 a6 dd 5d 79  49 df bb c0 83 da 56 7a  |......]yI.....Vz|
+000001f0  a5 22 8e 60 df 89 48 e0  e2 e9 5f d5 fe dd ba 34  |.".`..H..._....4|
+00000200  ad 91 52 d8 2f 7e a4 73  50 e8 b7 83 e2 d9 5e 05  |..R./~.sP.....^.|
+00000210  96 08 e4 d4 bb 01 39 99  aa 1d fd 74 1b dc ca c2  |......9....t....|
+00000220  8f bb b8 bf c4 eb 00 6f  cc 70 eb 7c c7 29 e4 64  |.......o.p.|.).d|
+00000230  8c 76 a7 b5 79 ea b6 96  fe eb 8f e7 81 9b d1 d0  |.v..y...........|
+00000240  41 16 db ef 9e 55 2a 77  6c 34 54 22 48 6a ca 78  |A....U*wl4T"Hj.x|
+00000250  31 6e d2 00 7f 54 93 65  ec 28 42 66 7b 74 4d 58  |1n...T.e.(Bf{tMX|
+00000260  fe 25 74 bd 9f a4 ff f2  45 06 c6 63 1f 11 68 a4  |.%t.....E..c..h.|
+00000270  fb fe 62 2b f8 19 e3 32  2c cc 5d 71 37 21 05 82  |..b+...2,.]q7!..|
+00000280  c9 c7 30 c7 74 64 d9 f9  6b c2 ae d8 15 2b 2a 79  |..0.td..k....+*y|
+00000290  a0 2d a3 18 1f d7 20 99  96 86 52 32 cf 84 bd 73  |.-.... ...R2...s|
+000002a0  63 85 82 a3 64 fb e3 ea  1b 31 f5 df 1c 74 06 48  |c...d....1...t.H|
+000002b0  69 8a e3 f0 72 8c 59 8b  de 0b 06 02 47 54 4c 2d  |i...r.Y.....GTL-|
+000002c0  46 ac d4 f5 4d 5c fe 0d  bf af d0 37 58 82 3e d2  |F...M\.....7X.>.|
+000002d0  4e c1 7e 0f b0 21 f7 8e  2c 88 db 83 43 ed ad 5b  |N.~..!..,...C..[|
+000002e0  0f a2 ce 47 e4 3f dd 1b  71 fe f0 a7 a1 8d 8c dc  |...G.?..q.......|
+000002f0  75 e0 7a 89 f7 14 5b 37  9d 35 f6 23 91 a8 d2 1a  |u.z...[7.5.#....|
+00000300  96 07 1b 5b 9c 35 27 b8  b9 0c 92 1e cf 1b 3c 17  |...[.5'.......<.|
+00000310  03 03 00 a4 f0 59 e1 1d  62 39 69 c5 53 ae 66 85  |.....Y..b9i.S.f.|
+00000320  df ea 32 73 ca 94 e2 b5  14 d4 30 07 dd fd 2f 9a  |..2s......0.../.|
+00000330  16 fc e9 71 4a 20 b8 d2  7e 17 26 ff a9 55 56 24  |...qJ ..~.&..UV$|
+00000340  31 85 bc ea 19 1c 37 b7  fe 8b 47 5f a3 99 0f 5d  |1.....7...G_...]|
+00000350  17 92 4b 2a 4c b5 6c db  8f bb 46 ee 89 31 53 79  |..K*L.l...F..1Sy|
+00000360  aa 34 9d 9b e8 9b e7 82  55 a3 92 f6 53 53 d3 72  |.4......U...SS.r|
+00000370  17 23 33 01 e8 75 7e 8d  63 91 a0 67 8f a5 f0 15  |.#3..u~.c..g....|
+00000380  8c f5 81 e2 c4 08 ff 14  1d 96 cf ef 4e 09 18 a1  |............N...|
+00000390  2c 38 0a f7 33 f0 1d ef  9d 12 4d 8c 25 f0 80 a2  |,8..3.....M.%...|
+000003a0  aa a7 cf e4 7c e6 44 58  6d 30 70 48 55 3b b5 79  |....|.DXm0pHU;.y|
+000003b0  55 aa 03 ed 14 ea e5 ee  17 03 03 00 35 72 1a ca  |U...........5r..|
+000003c0  5c 3d 3b 75 29 cc a9 09  85 67 89 37 18 91 c0 af  |\=;u)....g.7....|
+000003d0  28 d2 0c c9 8b 05 94 04  3a 68 38 f0 c3 db 95 89  |(.......:h8.....|
+000003e0  c8 28 fc 07 4b 49 7d b6  25 36 05 53 96 e0 d9 35  |.(..KI}.%6.S...5|
+000003f0  e5 7c                                             |.||
 >>> Flow 3 (client to server)
-00000000  14 03 03 00 01 01 17 03  03 02 11 ce 65 5f 9d 1a  |............e_..|
-00000010  c6 5f 48 ea da 02 77 1d  79 b2 82 1a da c4 75 aa  |._H...w.y.....u.|
-00000020  11 af ae 1f e4 7e d7 6f  ed 75 48 56 de c8 36 05  |.....~.o.uHV..6.|
-00000030  6a 97 5e 49 49 55 25 6f  ef 3e ed 40 3f 91 9a ae  |j.^IIU%o.>.@?...|
-00000040  f4 a1 d3 02 d3 15 60 23  1b 7a 80 ef ef 60 bb 62  |......`#.z...`.b|
-00000050  a3 8d 6b 24 1a 11 7d 8e  00 76 54 69 f1 b5 df 77  |..k$..}..vTi...w|
-00000060  c0 3a a3 8d 9d a3 56 e7  4d 2d 68 fe 38 49 6d 42  |.:....V.M-h.8ImB|
-00000070  3d 2c 69 fd 8c 53 44 af  13 8b 1d cb dc 04 16 6e  |=,i..SD........n|
-00000080  5a ab 0a 00 19 cf a0 8a  ee bd 71 24 68 ee 18 2a  |Z.........q$h..*|
-00000090  ec 04 fe 0f 12 15 8e 09  e0 87 de 4e c4 2a a1 a5  |...........N.*..|
-000000a0  6d be 79 6e 25 15 11 64  8c 35 71 97 fa a4 43 e2  |m.yn%..d.5q...C.|
-000000b0  dd cd a1 da b3 75 5d d5  36 fb b4 6b 12 30 a7 f6  |.....u].6..k.0..|
-000000c0  d7 7c 72 e1 f8 6a 8b 3e  38 13 9c da ee 07 3d 6a  |.|r..j.>8.....=j|
-000000d0  f5 1b 26 73 ff 24 03 1f  ea dc f3 ed 6b c2 0d fe  |..&s.$......k...|
-000000e0  3e 03 c4 22 93 c9 9b fe  22 5c 1e fb 07 2b 1b 7f  |>.."...."\...+..|
-000000f0  34 ff c6 1b 24 32 4b b1  ee 4c 0b 08 b6 3b 1e aa  |4...$2K..L...;..|
-00000100  49 f3 04 b7 9a 42 e5 42  5a df a2 92 d3 2f 62 54  |I....B.BZ..../bT|
-00000110  e1 21 08 ee ce 64 80 48  d3 6a 15 67 8c 5e d1 ac  |.!...d.H.j.g.^..|
-00000120  a2 64 f9 10 67 2c 27 7e  10 11 d7 09 13 2f 61 a7  |.d..g,'~...../a.|
-00000130  d7 9d 2a 18 0f a8 93 c6  fc 75 5c 31 68 42 22 e6  |..*......u\1hB".|
-00000140  5c e8 4d 7d 82 73 ba 97  5c d7 6a a2 14 37 85 93  |\.M}.s..\.j..7..|
-00000150  48 a7 50 9c fc 66 7b 82  a8 b6 99 0f 8c 9e 40 b5  |H.P..f{.......@.|
-00000160  e4 4f 98 01 db 56 03 44  f9 9f 52 a3 33 ac 77 2a  |.O...V.D..R.3.w*|
-00000170  b6 0a de d5 68 a5 df 67  41 8d 4c 53 9d c4 8d b7  |....h..gA.LS....|
-00000180  2e 3d 1f 93 1c 23 e3 81  76 5a 99 7c 90 60 d8 4d  |.=...#..vZ.|.`.M|
-00000190  e4 a5 00 7d f9 2c c5 19  bc 3c a3 73 c3 83 ff 31  |...}.,...<.s...1|
-000001a0  6a 67 88 32 d3 90 7f ab  20 19 1f 55 72 e4 08 bc  |jg.2.... ..Ur...|
-000001b0  c4 d6 24 e6 00 2d 85 be  d4 9b 2c e5 7b ee 26 6b  |..$..-....,.{.&k|
-000001c0  49 ed 94 3d d6 ee fd 9d  da 39 be 02 23 aa b9 78  |I..=.....9..#..x|
-000001d0  f2 41 97 0a d9 66 15 1e  e1 a2 49 f3 09 f0 25 91  |.A...f....I...%.|
-000001e0  8a ea f5 38 87 ea 66 ae  dc d2 04 d1 02 92 ab 6c  |...8..f........l|
-000001f0  a4 1a cc 1b ba 48 d5 8e  27 c4 c5 34 08 8f c2 c8  |.....H..'..4....|
-00000200  e1 e6 a8 98 48 9c 43 6c  f1 34 ba c0 ff 8e 22 14  |....H.Cl.4....".|
-00000210  f7 f9 93 38 96 1e 73 57  28 5b 25 3e 17 03 03 00  |...8..sW([%>....|
-00000220  99 c7 8d 1d 62 23 f3 c1  31 3d 45 bc d5 59 ff 47  |....b#..1=E..Y.G|
-00000230  8e 34 3d 1d 06 cc e0 05  ea 38 87 f0 fd c3 84 53  |.4=......8.....S|
-00000240  47 6b fb 7b 9b c2 a4 f2  1f e0 61 ab 17 32 d0 57  |Gk.{......a..2.W|
-00000250  34 dd fb 42 9b ad 4c d7  20 ff b1 58 34 e0 0c b1  |4..B..L. ..X4...|
-00000260  44 0c cf d3 05 be 3b 8e  a2 d5 39 44 c8 22 64 ad  |D.....;...9D."d.|
-00000270  61 80 df 5d fd 40 0e c0  c2 41 4f a7 e5 4f b3 7f  |a..].@...AO..O..|
-00000280  0b db d6 ac fe ba c0 8b  24 8e e8 b2 d6 93 3d 12  |........$.....=.|
-00000290  75 41 85 1d b5 4a e2 e0  f8 a1 23 8f 13 24 c6 b6  |uA...J....#..$..|
-000002a0  e5 db 06 3f d8 d5 2f b5  e5 24 59 76 53 dd aa 0a  |...?../..$YvS...|
-000002b0  26 ba 72 23 63 ac 4d 5c  92 13 17 03 03 00 35 47  |&.r#c.M\......5G|
-000002c0  59 18 68 11 0a 9a 0b 66  d3 c0 26 72 da 51 0e 00  |Y.h....f..&r.Q..|
-000002d0  b0 78 8b 6a ef df 75 94  94 b0 aa 9b 77 e3 9c d8  |.x.j..u.....w...|
-000002e0  23 9d 74 ce 85 55 c0 30  4c 96 5b 59 7a f6 03 2e  |#.t..U.0L.[Yz...|
-000002f0  d8 9c 0e 11 17 03 03 00  17 74 ed 13 0b 6a 15 18  |.........t...j..|
-00000300  5e d4 5e 8a c6 e6 5c 0b  3c d0 1b 3d 68 86 2a 07  |^.^...\.<..=h.*.|
-00000310  17 03 03 00 13 6f e2 fe  a0 b8 95 d4 aa fd 11 2b  |.....o.........+|
-00000320  e8 6d 42 28 d1 ca 1c 5e                           |.mB(...^|
+00000000  14 03 03 00 01 01 17 03  03 02 11 6a 55 c4 ff 7a  |...........jU..z|
+00000010  5b c4 b7 cb 8d ad ae 53  53 3d 41 3a fc 16 44 fd  |[......SS=A:..D.|
+00000020  c8 5f 39 c3 5e 6b ee 7d  ea 88 9c a9 78 f9 dc 51  |._9.^k.}....x..Q|
+00000030  b2 90 68 7d ae 2c b7 90  6e 79 cf f4 97 50 95 87  |..h}.,..ny...P..|
+00000040  f1 f6 2c 14 bc 2b a3 68  0d e6 c8 66 2f 3b 89 72  |..,..+.h...f/;.r|
+00000050  67 4d d8 e9 8d 6a 89 2a  f9 e4 c1 b5 c0 92 16 25  |gM...j.*.......%|
+00000060  61 a6 98 ec b6 6b 52 8b  a5 80 5a 9e 6d 03 ad 42  |a....kR...Z.m..B|
+00000070  a9 46 2f d8 e5 67 c9 8d  89 f7 34 93 82 7c a3 bb  |.F/..g....4..|..|
+00000080  48 62 06 90 5c 5a aa fd  7c 71 88 24 22 f9 6a 2c  |Hb..\Z..|q.$".j,|
+00000090  d1 d9 7e 0a 4c 39 11 e8  c0 17 1d 83 64 f2 2b c6  |..~.L9......d.+.|
+000000a0  c0 81 8c 6a 39 a9 09 aa  1e 58 eb 30 88 59 4d f2  |...j9....X.0.YM.|
+000000b0  d2 64 9f 4c 90 29 c0 66  94 e3 df 12 9c 75 33 24  |.d.L.).f.....u3$|
+000000c0  fb 14 bc 70 e1 b5 de 54  28 b0 3f 01 2c 2e 5f 35  |...p...T(.?.,._5|
+000000d0  e3 01 59 2a 3f ce ca 11  bb 29 97 03 f6 f4 30 b9  |..Y*?....)....0.|
+000000e0  66 db 3c f7 06 41 7b e8  f8 af 3e 03 65 2f 5f 88  |f.<..A{...>.e/_.|
+000000f0  fd 30 45 7a c9 b4 9f bf  03 eb c9 dd 06 ac 82 06  |.0Ez............|
+00000100  e8 81 8e ea 29 45 78 5c  0f 8e 21 8a fb 0b 95 c1  |....)Ex\..!.....|
+00000110  63 e9 18 c1 9a a4 c6 7d  56 4b 9a de 96 dd 37 54  |c......}VK....7T|
+00000120  92 ef 71 42 a8 66 e7 df  e7 ea ec 4e 3c b3 8e 7d  |..qB.f.....N<..}|
+00000130  ed 92 da 86 e5 fa 51 f8  e4 b0 09 f3 06 4d 38 f1  |......Q......M8.|
+00000140  d5 5f d2 72 1e 5f c3 1e  1d fd 96 70 e7 9c ae ea  |._.r._.....p....|
+00000150  62 ce e4 a9 31 34 47 bc  f0 9f 1c c7 b6 66 f0 70  |b...14G......f.p|
+00000160  7a e1 c5 a9 76 64 d4 25  0f 56 cd 36 17 67 bd 4d  |z...vd.%.V.6.g.M|
+00000170  c7 78 d8 23 46 4b ac 46  34 1a d2 2d c5 e6 67 55  |.x.#FK.F4..-..gU|
+00000180  11 ec 8c f0 67 84 bf 89  ce 3c 71 4e 3a ab ff 22  |....g....<qN:.."|
+00000190  59 23 00 54 4b b6 9e c4  01 a1 9f e1 46 a6 a6 f3  |Y#.TK.......F...|
+000001a0  24 58 0c b4 6e 85 4c c1  8a d6 f8 02 c9 54 fb 85  |$X..n.L......T..|
+000001b0  c7 63 9b 47 28 10 a0 2d  b6 c2 83 16 71 ae a7 c2  |.c.G(..-....q...|
+000001c0  e0 dc 8b 6d 57 e0 4b a2  a8 5d 4d 8b ed 72 31 d6  |...mW.K..]M..r1.|
+000001d0  54 33 78 df bb 4a f9 58  9f 8c 2b 11 36 29 a0 f0  |T3x..J.X..+.6)..|
+000001e0  8a 95 20 d8 f1 8c 08 e1  54 0a 81 79 33 20 23 de  |.. .....T..y3 #.|
+000001f0  34 c8 2b 45 3a 59 c5 78  39 65 ea 70 e2 fe 59 4c  |4.+E:Y.x9e.p..YL|
+00000200  ed 7f 07 07 25 a7 ff fa  c9 c3 1f 33 55 c4 16 bb  |....%......3U...|
+00000210  c9 b9 e0 2e ff 94 7c de  84 30 60 d6 17 03 03 00  |......|..0`.....|
+00000220  99 53 44 d2 12 38 c4 a7  7e f5 f5 67 b3 79 cf 8a  |.SD..8..~..g.y..|
+00000230  34 0f 5d 49 0f bb 5f 30  c8 36 13 61 8d b5 b1 b0  |4.]I.._0.6.a....|
+00000240  dc 73 2f 1a 51 2f d4 8e  25 71 e1 46 af 11 96 19  |.s/.Q/..%q.F....|
+00000250  f7 fe 09 d9 6e 70 d5 fc  b9 5b 1c ae ed 06 37 af  |....np...[....7.|
+00000260  a1 bf 35 c6 6b 30 33 a2  c4 f6 c8 d4 73 34 73 8e  |..5.k03.....s4s.|
+00000270  69 08 be 91 2c 8d 01 52  30 14 b3 d3 a0 7d 8a 9d  |i...,..R0....}..|
+00000280  e9 af b2 77 64 eb 16 c1  8e 19 72 ad 4a fd d4 c9  |...wd.....r.J...|
+00000290  08 d0 54 6c f1 06 8c 70  2f e6 ef 23 23 67 96 db  |..Tl...p/..##g..|
+000002a0  5f aa 81 6c 41 17 6b f4  30 ce 00 d6 a2 d8 28 f8  |_..lA.k.0.....(.|
+000002b0  be 9f 04 94 fa e3 fa 76  d0 30 17 03 03 00 35 9b  |.......v.0....5.|
+000002c0  43 c4 8f dc b7 a1 44 4e  00 66 0a 95 a6 d7 46 79  |C.....DN.f....Fy|
+000002d0  30 2d 57 51 4e 21 a7 ed  43 e7 22 2d eb 07 9b 7d  |0-WQN!..C."-...}|
+000002e0  ea a4 ff 14 5d 97 1f d5  e8 f1 3d 8d e3 13 b6 79  |....].....=....y|
+000002f0  36 ce 83 e8 17 03 03 00  17 d5 98 a6 a3 b7 40 2b  |6.............@+|
+00000300  26 87 2f 4f 64 95 f1 2d  e0 7b e3 98 c2 81 dc 7b  |&./Od..-.{.....{|
+00000310  17 03 03 00 13 5b ab 65  e4 b1 d0 bd e9 c6 b2 3a  |.....[.e.......:|
+00000320  4b 66 ce eb 25 0c bc 7d                           |Kf..%..}|
diff --git a/src/crypto/tls/testdata/Client-TLSv13-ClientCert-RSA-RSAPSS b/src/crypto/tls/testdata/Client-TLSv13-ClientCert-RSA-RSAPSS
index 9488dd6b66..2367a39717 100644
--- a/src/crypto/tls/testdata/Client-TLSv13-ClientCert-RSA-RSAPSS
+++ b/src/crypto/tls/testdata/Client-TLSv13-ClientCert-RSA-RSAPSS
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,128 +16,128 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 7a 02 00 00  76 03 03 6d 36 ae 02 a9  |....z...v..m6...|
-00000010  74 ad e5 4d 55 b6 4a 70  c6 f5 cf d5 68 d9 2a 5f  |t..MU.Jp....h.*_|
-00000020  9b 4b 23 ce 38 9b f3 da  44 72 7d 20 00 00 00 00  |.K#.8...Dr} ....|
+00000000  16 03 03 00 7a 02 00 00  76 03 03 a9 f1 13 c3 3c  |....z...v......<|
+00000010  1c dd c9 3a a1 ad 92 92  f1 f4 16 39 be 14 64 9c  |...:.......9..d.|
+00000020  66 d8 28 cd b7 bb 40 43  ec f4 67 20 00 00 00 00  |f.(...@C..g ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 01 00 00  |................|
-00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 ba  |..+.....3.$... .|
-00000060  2a 76 cb fb 6c 6b bb 30  fb ef 87 6f e5 06 5c 6f  |*v..lk.0...o..\o|
-00000070  78 a7 44 41 93 c0 33 89  be 32 8c 0f fa 5c 43 14  |x.DA..3..2...\C.|
-00000080  03 03 00 01 01 17 03 03  00 17 ac 3e 8a 31 22 16  |...........>.1".|
-00000090  d3 69 bf 1d b5 2e 18 23  b3 21 00 17 23 a4 3f 9a  |.i.....#.!..#.?.|
-000000a0  0b 17 03 03 00 20 aa f0  51 64 b5 44 f0 28 ab 56  |..... ..Qd.D.(.V|
-000000b0  da 34 2d 62 77 4d 88 07  b6 82 ad 64 df e6 59 c9  |.4-bwM.....d..Y.|
-000000c0  91 e5 f8 f2 67 88 17 03  03 02 7a cf 2d 71 db 3f  |....g.....z.-q.?|
-000000d0  05 45 b8 68 18 1c b9 66  b6 00 f8 dc 9d ae e5 d2  |.E.h...f........|
-000000e0  a3 a8 02 5f ac e4 95 a6  fc 96 78 7b fd 0a 21 62  |..._......x{..!b|
-000000f0  ff 7c 15 2c fb f1 21 15  1e 8d 9e f9 71 62 43 e4  |.|.,..!.....qbC.|
-00000100  c9 69 e4 fe 87 f0 9d 9e  aa a4 5c d8 4e ae 3c 38  |.i........\.N.<8|
-00000110  e5 76 21 7b 03 a8 70 6f  e8 96 39 34 e7 3c b9 51  |.v!{..po..94.<.Q|
-00000120  b4 ef ce 7d 0b 1e 57 7d  62 de 47 6a 0a b0 97 6d  |...}..W}b.Gj...m|
-00000130  49 fe ae 6f c9 d6 e4 4a  54 60 3d 55 53 06 aa 28  |I..o...JT`=US..(|
-00000140  7a 3e 7b e0 d1 8a 60 45  87 81 bf fc 98 13 1e de  |z>{...`E........|
-00000150  7a 90 73 81 13 91 3a c4  da 71 74 e0 1d d5 30 55  |z.s...:..qt...0U|
-00000160  46 6a 48 c2 0c 18 91 a3  79 8e c2 b9 5b 24 88 76  |FjH.....y...[$.v|
-00000170  5f e6 8f 24 91 95 5b 0d  38 39 5b a4 f6 0e 1a b8  |_..$..[.89[.....|
-00000180  e8 2b 0d ac a8 56 10 23  54 a5 78 c9 2a cb ed 24  |.+...V.#T.x.*..$|
-00000190  58 16 1a 2f 1c b7 72 fc  da ab 56 f6 27 d1 98 39  |X../..r...V.'..9|
-000001a0  1f f9 dd e0 1f 1f 23 1a  ff 6b af e1 17 9d ec 35  |......#..k.....5|
-000001b0  de 0b 4d a4 46 5a fd 07  56 ce 72 19 76 dc 0c 06  |..M.FZ..V.r.v...|
-000001c0  99 38 ce 58 3b 9f 13 9a  d5 b7 d6 08 a6 05 4d e1  |.8.X;.........M.|
-000001d0  75 da 59 4d ab d9 28 e8  af c4 50 f0 b1 49 f8 fd  |u.YM..(...P..I..|
-000001e0  c9 11 b8 01 70 bb 49 e2  0f 26 1b cb ee c2 7b bd  |....p.I..&....{.|
-000001f0  2f 72 78 be a1 67 1d 0c  d0 bb 4e e7 40 b3 bd 8c  |/rx..g....N.@...|
-00000200  e2 f4 4f b2 c5 4c 82 49  51 00 44 17 c6 82 72 f5  |..O..L.IQ.D...r.|
-00000210  cd 55 c1 43 28 52 85 2b  5d 91 33 9c 15 34 6e ae  |.U.C(R.+].3..4n.|
-00000220  77 4e 08 0c 9c d2 ae 7f  e8 83 af 60 96 10 ae dc  |wN.........`....|
-00000230  58 6a 3b ae 15 e5 9c a8  25 f3 69 71 f7 94 9c 75  |Xj;.....%.iq...u|
-00000240  e0 b5 05 16 ae ce f4 23  20 30 aa 74 a3 63 68 76  |.......# 0.t.chv|
-00000250  f6 ec 64 e1 3d f6 0e b6  c4 7d a8 08 44 a9 96 1d  |..d.=....}..D...|
-00000260  7d c8 22 a8 df 04 2c ad  65 f1 4c 99 7d a1 cb bd  |}."...,.e.L.}...|
-00000270  b7 d4 d7 b5 ee 88 bd 15  2e 75 76 e2 72 bb 7d e6  |.........uv.r.}.|
-00000280  5b eb fc f7 96 96 f0 3c  aa b6 a8 58 92 e9 29 f6  |[......<...X..).|
-00000290  40 bf 8e 14 23 7c 45 da  e9 17 4b 32 16 11 ec 74  |@...#|E...K2...t|
-000002a0  78 d5 8c 5a 06 46 e4 dc  90 b9 44 8e d6 8a 4e 43  |x..Z.F....D...NC|
-000002b0  7f f9 60 9e a1 46 fa 16  88 ab 3c f1 1e d0 2e 00  |..`..F....<.....|
-000002c0  5d 01 e6 a7 b1 27 f7 40  26 17 f3 da fb cd 06 d1  |]....'.@&.......|
-000002d0  4e 27 75 9a 6f 0b 63 82  9c 40 07 4c 6e 0d d8 4b  |N'u.o.c..@.Ln..K|
-000002e0  f1 e6 d5 1c 41 55 72 b5  43 24 53 1e 0e a4 08 d7  |....AUr.C$S.....|
-000002f0  44 93 00 c9 8b 49 ba 7a  32 0c d8 e6 46 87 5d 62  |D....I.z2...F.]b|
-00000300  9d 4a 11 04 67 21 19 42  50 ad ad ab dd 62 0f f7  |.J..g!.BP....b..|
-00000310  0f 57 78 82 71 f6 09 9f  41 bc 8e 34 24 7c b5 d2  |.Wx.q...A..4$|..|
-00000320  5d 0c 18 fb d8 f6 62 dc  57 6a 78 2c 21 35 d8 eb  |].....b.Wjx,!5..|
-00000330  bb f8 7e 01 63 50 c1 98  88 a4 b5 63 1e c0 68 3c  |..~.cP.....c..h<|
-00000340  41 3c b8 6e 48 17 03 03  00 99 b6 09 37 a6 c2 d9  |A<.nH.......7...|
-00000350  5f 39 69 e1 0b ca 40 d8  31 5b 4b 4f c1 33 bf 1f  |_9i...@.1[KO.3..|
-00000360  db c2 8c 9c d2 14 26 96  4e aa b2 63 30 40 fa 49  |......&.N..c0@.I|
-00000370  fb 2d 66 59 70 cb c7 f8  fe 59 19 8b eb d5 5c 6c  |.-fYp....Y....\l|
-00000380  5c a0 c9 ba e6 4d d9 c3  e0 fe 00 c4 fb ab 8a f1  |\....M..........|
-00000390  2b ab 53 86 a7 86 57 01  b8 ae c4 a6 12 6b 7d f8  |+.S...W......k}.|
-000003a0  ea 2d df 37 04 01 eb 14  f4 9a d0 e7 67 46 ec 9f  |.-.7........gF..|
-000003b0  35 f8 d4 2e c6 95 91 10  0e dc 01 60 9a d6 f8 d8  |5..........`....|
-000003c0  9e c1 fd f8 2e e2 51 8a  e9 2f c3 4a 4f 01 31 52  |......Q../.JO.1R|
-000003d0  af cb 4b 52 96 4c 90 57  83 1f 11 97 d6 d6 16 74  |..KR.L.W.......t|
-000003e0  77 f8 c4 17 03 03 00 35  b0 61 57 8f 52 7e 93 b1  |w......5.aW.R~..|
-000003f0  f0 90 a1 23 09 6e 11 ff  a5 6c 38 f3 31 11 be 03  |...#.n...l8.1...|
-00000400  ad 59 65 57 1b 60 2b fc  41 98 e0 79 6d 14 26 c8  |.YeW.`+.A..ym.&.|
-00000410  fb d6 5f 00 e0 cc 70 46  a3 81 e4 3c ff           |.._...pF...<.|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 03 00 00  |................|
+00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 ff  |..+.....3.$... .|
+00000060  53 ac b3 b0 48 47 d0 1e  b1 70 eb dd 02 e5 e8 07  |S...HG...p......|
+00000070  ce c7 e0 af d7 e0 46 c7  ff f5 97 30 e5 80 5b 14  |......F....0..[.|
+00000080  03 03 00 01 01 17 03 03  00 17 0b 12 ef 6d ea 5e  |.............m.^|
+00000090  71 41 83 d6 35 9f 39 2c  f0 ab 01 e9 03 54 c6 9e  |qA..5.9,.....T..|
+000000a0  37 17 03 03 00 20 15 7a  35 f4 a6 6e 65 89 10 ae  |7.... .z5..ne...|
+000000b0  18 31 c0 0c 15 1c b8 c5  5d f3 54 0c 98 32 a4 5e  |.1......].T..2.^|
+000000c0  91 f7 03 8a 80 b9 17 03  03 02 7a fa 93 7f c6 d1  |..........z.....|
+000000d0  2f 7e 2d d6 1b b7 ff fd  96 6e a1 f7 0e 98 dc 77  |/~-......n.....w|
+000000e0  cc 6a 4e 91 3d c1 ad 4b  5c 28 ee ea a7 0a ce 8f  |.jN.=..K\(......|
+000000f0  51 dd 89 fd 5a 81 6d 21  d6 0d 35 70 84 73 8c fa  |Q...Z.m!..5p.s..|
+00000100  2e 7a e0 af ab 79 79 aa  67 2b 80 a8 b3 a8 fb 0d  |.z...yy.g+......|
+00000110  eb 87 66 d5 be 33 0b f0  80 b8 5e 21 84 be 25 fe  |..f..3....^!..%.|
+00000120  47 98 5a 26 5d c3 96 2e  c5 b8 da 9f a6 d4 ca bb  |G.Z&]...........|
+00000130  de 7f 2c 0a 28 a8 f3 41  bc a2 2e 70 f2 b3 6f a3  |..,.(..A...p..o.|
+00000140  10 0e 1f 11 af 11 50 2b  22 84 97 d7 80 f5 62 77  |......P+".....bw|
+00000150  a6 94 47 22 ef 24 c6 0e  dc 5c f5 40 08 f7 21 78  |..G".$...\.@..!x|
+00000160  ae 11 f3 d8 a5 d8 20 ac  90 73 d7 a2 e3 f0 08 57  |...... ..s.....W|
+00000170  fc 74 70 66 fd 3d 49 c7  99 37 98 5e b1 1c c4 38  |.tpf.=I..7.^...8|
+00000180  64 09 e6 70 b6 8b 00 72  2d 5b b4 70 39 d6 e9 d5  |d..p...r-[.p9...|
+00000190  dc cd 8e 01 eb 5f 34 61  d0 97 62 0b 4f 81 ed 30  |....._4a..b.O..0|
+000001a0  64 56 f2 6e 31 5e 24 e8  56 2b d6 31 54 c4 48 47  |dV.n1^$.V+.1T.HG|
+000001b0  16 00 a7 65 c1 fa ea 12  30 78 41 e7 30 2d 71 cf  |...e....0xA.0-q.|
+000001c0  b0 e9 be e4 a2 33 38 87  2d 37 14 2d 03 cf ae 87  |.....38.-7.-....|
+000001d0  9a 09 f2 ed f3 44 66 c3  8a 56 8e e4 c4 aa e9 f7  |.....Df..V......|
+000001e0  cd 75 52 1b d9 ed 66 04  13 dd dd cf 0f 44 cd 18  |.uR...f......D..|
+000001f0  68 c5 2c 4c f9 e3 d3 02  12 78 38 5c f6 96 d7 80  |h.,L.....x8\....|
+00000200  f0 83 03 fe 7a e0 35 7e  a3 ad 99 52 ec fc ee 74  |....z.5~...R...t|
+00000210  f5 09 0f ca 69 f0 fb d0  40 90 1b 46 9e 2d 62 c9  |....i...@..F.-b.|
+00000220  0f 59 b2 cc a0 4a 9b 84  14 3a 1b 51 fc e7 e8 a1  |.Y...J...:.Q....|
+00000230  26 fd 20 8c 88 6f 87 11  ae 97 76 f8 4b cc 67 1a  |&. ..o....v.K.g.|
+00000240  3e 58 65 77 77 82 06 c0  d4 41 4e 66 d2 5a 83 b1  |>Xeww....ANf.Z..|
+00000250  ee 19 5d 7b 99 34 d3 2f  6c bd 30 a3 8c 75 89 ec  |..]{.4./l.0..u..|
+00000260  cb 90 8b 89 05 b8 e4 6e  3b 60 5d 0e 19 8f d6 c7  |.......n;`].....|
+00000270  86 f0 a9 2b c7 12 4a 4c  d8 a5 e8 64 49 1d 49 99  |...+..JL...dI.I.|
+00000280  a7 80 01 f0 77 57 4a 78  3c ac 38 40 bb d2 10 24  |....wWJx<.8@...$|
+00000290  9d e2 29 b2 1e 4b 50 66  64 07 79 80 c7 81 9d e2  |..)..KPfd.y.....|
+000002a0  f5 a9 10 9a 8d 3b de 0e  21 85 13 ac 26 30 f9 e4  |.....;..!...&0..|
+000002b0  a6 f9 8f e0 3c c1 69 7e  11 4c d1 a8 4e 88 30 fc  |....<.i~.L..N.0.|
+000002c0  52 6e b0 4f b6 7e 15 9e  a5 8a 46 ca 1f ac 8e 2a  |Rn.O.~....F....*|
+000002d0  07 34 d7 c2 14 c6 c1 ed  a1 f9 1e 59 b4 b4 86 3e  |.4.........Y...>|
+000002e0  d3 d0 78 a6 07 62 d3 88  80 54 a8 2a e9 38 2e 58  |..x..b...T.*.8.X|
+000002f0  43 94 cc ed f0 46 f6 cc  4b 7a b8 f5 a2 d6 a8 36  |C....F..Kz.....6|
+00000300  e2 8e 11 fb e7 21 19 c5  fa c9 90 98 72 43 88 ac  |.....!......rC..|
+00000310  c0 56 84 9e cd b7 e5 26  d6 49 19 88 a5 12 ac 49  |.V.....&.I.....I|
+00000320  5d 77 37 2a ff 38 5a 7a  5b c8 74 5d 74 fc 22 7f  |]w7*.8Zz[.t]t.".|
+00000330  46 97 2b 34 32 fb 83 65  75 b6 8b 5c 8a b1 d4 a2  |F.+42..eu..\....|
+00000340  14 7f 46 0d 63 17 03 03  00 99 c7 79 bb 4f 88 a0  |..F.c......y.O..|
+00000350  78 be 04 ca 39 1f 1f a8  82 59 b5 dd 96 93 0d c4  |x...9....Y......|
+00000360  30 f4 22 4c e2 52 51 d4  33 b8 35 7b ed 01 19 25  |0."L.RQ.3.5{...%|
+00000370  b5 31 36 25 23 a2 51 d9  7a a9 00 72 05 34 81 62  |.16%#.Q.z..r.4.b|
+00000380  d0 df 8b 3a 65 98 4e 87  e2 29 9b 44 77 8c dd c9  |...:e.N..).Dw...|
+00000390  4c a5 de 14 97 e0 f1 2c  e8 5d 0e 8f d0 fd f6 77  |L......,.].....w|
+000003a0  c1 1f ac 79 4d 32 19 09  98 a8 f0 2f 3e d5 7e f7  |...yM2...../>.~.|
+000003b0  aa c1 f0 36 b1 8e c7 0b  ce 09 00 ac 28 64 c0 33  |...6........(d.3|
+000003c0  58 cc 48 3a 15 a4 77 24  50 67 f2 39 53 4d 63 23  |X.H:..w$Pg.9SMc#|
+000003d0  48 74 bd 0a c8 02 17 be  e4 64 af 6e 02 a9 22 92  |Ht.......d.n..".|
+000003e0  65 04 c6 17 03 03 00 35  e0 4e 15 4b 9d 53 57 c6  |e......5.N.K.SW.|
+000003f0  97 b4 9d 1a 03 39 26 b9  ca 5b 04 50 af db 52 99  |.....9&..[.P..R.|
+00000400  d9 13 40 6a 89 23 99 42  9a 91 1d d1 6c 07 a0 aa  |..@j.#.B....l...|
+00000410  05 6e 60 0b fd e7 de 32  c3 97 18 0d 9b           |.n`....2.....|
 >>> Flow 3 (client to server)
-00000000  14 03 03 00 01 01 17 03  03 02 7a 22 a3 3d 18 f8  |..........z".=..|
-00000010  a2 c7 8e 62 c3 07 99 b4  e6 bd 94 79 12 82 e9 e0  |...b.......y....|
-00000020  96 ff 5f c3 ec 34 02 2f  8d 95 2f 40 80 99 19 a3  |.._..4./../@....|
-00000030  bd 64 fd e4 0e b3 81 ad  4c 2e d9 72 d2 a3 bd 00  |.d......L..r....|
-00000040  81 42 78 5d f3 70 c3 78  0b fa cd b8 96 17 5e e7  |.Bx].p.x......^.|
-00000050  6e 03 b8 c6 ab 2b 2e 63  45 c7 b1 c9 98 71 c9 1d  |n....+.cE....q..|
-00000060  bb 7b 6e 6d c7 d5 90 b8  b2 4e 62 1a 8f cf 7d 99  |.{nm.....Nb...}.|
-00000070  52 3d 70 40 0f 0f 96 1c  ee a7 ff 29 2a 53 de d4  |R=p@.......)*S..|
-00000080  34 f9 d9 b2 33 2c 69 5e  2d f2 a7 62 dd ec 77 b1  |4...3,i^-..b..w.|
-00000090  6c 0f 61 86 8a bc 11 1f  91 ad f4 94 de 96 dd ef  |l.a.............|
-000000a0  d8 be 5e 45 50 fe af 1a  03 54 20 f6 05 8e a3 b0  |..^EP....T .....|
-000000b0  f7 31 93 f3 78 59 4d 54  50 99 a5 a1 53 81 1b 5d  |.1..xYMTP...S..]|
-000000c0  6d ea 32 e9 52 ab 83 d6  18 3f 2f 43 cd 64 ac 3f  |m.2.R....?/C.d.?|
-000000d0  11 6c 91 0d fa 86 f8 a5  12 eb 41 ac 24 2d 79 5b  |.l........A.$-y[|
-000000e0  ee 8e 02 46 f0 37 0a b1  19 c7 97 ed 97 d1 11 18  |...F.7..........|
-000000f0  df 80 8f f3 d7 61 a4 fe  6c ec b0 80 4e bc e4 52  |.....a..l...N..R|
-00000100  10 2f b1 6f 3f d4 39 08  81 f6 01 4b b4 d4 d5 20  |./.o?.9....K... |
-00000110  6b a1 be e6 cf c7 0e 95  e9 d7 00 07 63 25 1b 64  |k...........c%.d|
-00000120  4b b7 c4 79 29 84 45 45  5d 0d fe 72 2a 7e c6 bf  |K..y).EE]..r*~..|
-00000130  5a 98 ec e2 16 26 82 57  eb a6 dc ff 73 b6 e8 4c  |Z....&.W....s..L|
-00000140  87 52 e5 0a c1 6a 6f 02  69 17 17 ea e0 1c c1 07  |.R...jo.i.......|
-00000150  b4 f4 78 a7 99 39 8b 63  61 c2 7e 99 f4 64 16 d6  |..x..9.ca.~..d..|
-00000160  0a 84 9a 0f d4 f4 bd 4d  d4 4f 16 ec 19 30 a7 34  |.......M.O...0.4|
-00000170  f9 b9 60 10 39 25 ee 9d  bd 99 37 52 e6 32 a1 c9  |..`.9%....7R.2..|
-00000180  68 9b a2 4e 16 91 0e 54  54 d5 c5 77 bb 01 ba af  |h..N...TT..w....|
-00000190  97 be ea 09 85 91 69 84  4f 2c 04 f0 38 50 93 49  |......i.O,..8P.I|
-000001a0  e7 41 cb c1 d6 b6 77 59  09 7c 1e 0a 58 93 1e b4  |.A....wY.|..X...|
-000001b0  cf ed 32 85 b0 cd 6f 86  c7 94 8c 30 9d 83 a2 a0  |..2...o....0....|
-000001c0  4a de ad 8c b9 d8 58 d3  8c 34 6b 12 54 f1 28 66  |J.....X..4k.T.(f|
-000001d0  ea 55 d9 95 d0 b6 b3 aa  68 c3 31 e1 8f 1b f8 43  |.U......h.1....C|
-000001e0  51 b9 06 fc 53 69 9b 1c  e6 2c f8 b7 f0 47 4a 5a  |Q...Si...,...GJZ|
-000001f0  82 ca 27 df 0f 3d f8 79  90 8d c2 bd 27 85 74 6b  |..'..=.y....'.tk|
-00000200  9e 8b eb 74 a8 28 ba 6a  25 16 01 2c 56 3b c0 fa  |...t.(.j%..,V;..|
-00000210  91 ac af a7 c5 39 8d 2c  b1 f3 a2 c9 a5 72 c6 ff  |.....9.,.....r..|
-00000220  49 a0 78 14 5c 8c d2 71  de b9 4f 55 3a ca b6 a5  |I.x.\..q..OU:...|
-00000230  df ce bb f7 c2 d5 af 2c  c0 97 08 82 cc b4 02 26  |.......,.......&|
-00000240  c3 0c 99 39 4a df 6c d6  59 14 c4 d6 04 9d a4 92  |...9J.l.Y.......|
-00000250  d2 53 42 16 56 99 5f c2  82 a0 a8 5a 92 53 e6 b1  |.SB.V._....Z.S..|
-00000260  cd fc bc 9a b9 55 0b ae  2c 50 ce a3 bf d2 7d d2  |.....U..,P....}.|
-00000270  2b 58 ba 87 65 33 09 cf  74 51 0f 4b 4f a9 53 0d  |+X..e3..tQ.KO.S.|
-00000280  fa 60 1e ba e6 17 03 03  00 99 aa 43 d9 e2 e4 91  |.`.........C....|
-00000290  cf 65 fa 35 0e b0 21 51  9d c4 33 f5 7c 09 ff e5  |.e.5..!Q..3.|...|
-000002a0  db fd 6e 96 6d 13 7c 4c  ec 90 72 bd 54 6a 3f d8  |..n.m.|L..r.Tj?.|
-000002b0  1a a3 e2 a2 01 6b d6 50  a0 b1 d5 67 34 44 42 30  |.....k.P...g4DB0|
-000002c0  97 2e 82 07 46 04 56 0a  43 4b 9d 8c 81 64 bb 0b  |....F.V.CK...d..|
-000002d0  21 62 ea 23 0b 1c a0 c4  b2 cc 2f 51 b5 a2 9a a3  |!b.#....../Q....|
-000002e0  37 d3 0c 57 80 85 77 3b  8d 17 f1 a9 d5 ae 72 f9  |7..W..w;......r.|
-000002f0  cd 8c c4 2c fb c7 e0 f0  3a 5c d5 6a f7 8f 7e 53  |...,....:\.j..~S|
-00000300  c1 d0 7a b0 8d c9 b3 17  7c 99 df 54 d6 43 13 d5  |..z.....|..T.C..|
-00000310  78 9c 34 7e c9 11 4e e7  1c 8c f4 0f 82 89 94 61  |x.4~..N........a|
-00000320  80 d2 49 17 03 03 00 35  aa cd 97 5a a2 d3 27 78  |..I....5...Z..'x|
-00000330  d4 79 28 a7 57 dc 4f b1  2d b8 bd 3c ae ec e6 be  |.y(.W.O.-..<....|
-00000340  33 be b9 20 3b 69 22 03  31 34 7a 8d 68 39 c7 d5  |3.. ;i".14z.h9..|
-00000350  a1 a0 aa 46 15 94 93 d7  54 41 5b 6b 20 17 03 03  |...F....TA[k ...|
-00000360  00 17 f2 60 ff 91 c2 85  55 ed ab 39 6f 5d 0f 22  |...`....U..9o]."|
-00000370  45 3e 61 07 14 a3 05 f4  94 17 03 03 00 13 01 ea  |E>a.............|
-00000380  95 52 29 1c 63 71 3a 2d  73 a7 29 31 2c d0 ce 9f  |.R).cq:-s.)1,...|
-00000390  2b                                                |+|
+00000000  14 03 03 00 01 01 17 03  03 02 7a 94 78 2d 5d 5a  |..........z.x-]Z|
+00000010  3e 96 7f 19 29 51 99 f3  6e d3 a4 d5 3c 9a 3d d5  |>...)Q..n...<.=.|
+00000020  37 bc 3b 71 b3 54 83 d9  5e 9d 64 76 f9 74 7a 24  |7.;q.T..^.dv.tz$|
+00000030  e3 cb ea aa 17 f4 44 41  73 71 39 d6 9b d5 a6 a2  |......DAsq9.....|
+00000040  6a 1e 1c 02 a1 d5 e3 e8  f5 f7 07 9d 3b ea f8 6d  |j...........;..m|
+00000050  80 cf 6b 14 71 b8 bd c4  8a 07 49 31 e7 bd d5 91  |..k.q.....I1....|
+00000060  ac 80 70 25 5e f4 db 07  ed 36 c2 3a 1d ad 86 6e  |..p%^....6.:...n|
+00000070  68 1a ca 4f a1 ba c3 2f  de 49 01 fa a9 39 a6 51  |h..O.../.I...9.Q|
+00000080  3a e6 9f cf 6b 02 4e 1e  70 dd f2 10 c2 62 9b 1f  |:...k.N.p....b..|
+00000090  83 10 fa 85 52 a8 a7 08  37 9c 92 b0 9c fe 00 78  |....R...7......x|
+000000a0  0b a4 7b b5 f9 9f 87 d2  d3 07 72 b2 ab 96 9e 73  |..{.......r....s|
+000000b0  55 3c 1e 65 99 89 36 78  7e 42 8f 05 de b6 fb fc  |U<.e..6x~B......|
+000000c0  1b 34 18 e6 4d 15 6c d1  2f 2c b0 ef 00 e9 07 89  |.4..M.l./,......|
+000000d0  ca 91 d9 c1 73 bf 8f a5  a4 7d 7e cc f5 85 fb af  |....s....}~.....|
+000000e0  57 70 35 63 71 d6 78 57  13 48 27 ba a4 42 22 c2  |Wp5cq.xW.H'..B".|
+000000f0  56 f4 ae 38 39 a0 1f 57  44 57 c4 8a 70 90 30 70  |V..89..WDW..p.0p|
+00000100  ba 4a 98 29 0f aa e2 33  27 24 ee d9 e9 02 80 68  |.J.)...3'$.....h|
+00000110  4c 55 08 fb 3d 25 d6 d4  9d 83 ea 14 99 c2 77 94  |LU..=%........w.|
+00000120  f9 70 34 a8 ed 35 e6 4f  c2 75 50 63 d5 9d 9a 89  |.p4..5.O.uPc....|
+00000130  8f 2e 5b ca 6b b3 ad e7  a2 c6 f7 0c 45 08 b7 f4  |..[.k.......E...|
+00000140  58 d3 d5 54 c2 67 f3 76  fb fc 9d fe 42 43 ea 90  |X..T.g.v....BC..|
+00000150  2b 29 e7 10 2f d7 9c 04  c4 cc 89 8f a9 36 14 f6  |+)../........6..|
+00000160  fc f1 25 6c 90 12 bf c6  cd ad 46 ce 17 3b 26 fb  |..%l......F..;&.|
+00000170  c6 98 cb 6c f2 2c fd b9  2f 52 3e 56 42 78 0b 92  |...l.,../R>VBx..|
+00000180  a5 27 56 18 3d d6 26 3f  e4 a1 6f ce c8 f1 f1 7a  |.'V.=.&?..o....z|
+00000190  1f 84 66 c9 d9 8a 5c 0e  34 80 ba 58 b3 8b 7f f3  |..f...\.4..X....|
+000001a0  8a c9 6b c4 99 94 2c b7  e8 e8 9a a5 43 75 f8 e0  |..k...,.....Cu..|
+000001b0  29 1f 70 77 c7 4a 9f de  ca 92 88 7c 37 12 d9 ef  |).pw.J.....|7...|
+000001c0  2f 94 de ea d1 d9 69 6a  93 06 36 e0 68 02 53 ae  |/.....ij..6.h.S.|
+000001d0  0e 00 cd ad d3 10 a7 89  2c 53 a7 03 d9 07 3c e9  |........,S....<.|
+000001e0  0b b0 18 2e 03 88 03 5c  f4 b2 7e 59 f4 22 8c f7  |.......\..~Y."..|
+000001f0  5e d7 c7 ea ac 0f bc f7  3e 3f 75 fd 6d 9c 4c 3c  |^.......>?u.m.L<|
+00000200  41 8d f5 30 17 20 83 c3  27 83 ce 84 6a e3 75 2b  |A..0. ..'...j.u+|
+00000210  9d 7d de 2a bf 5a fb e1  2f 80 74 74 f6 09 bc 1f  |.}.*.Z../.tt....|
+00000220  be f0 59 9e ce a1 62 46  54 a4 9a 25 97 b7 cd 1a  |..Y...bFT..%....|
+00000230  0a d0 44 f6 ea a4 ed 63  e7 49 9a 4b f4 1a 39 91  |..D....c.I.K..9.|
+00000240  e6 34 e1 7b dd e7 53 ab  83 56 57 b2 89 3f 90 1f  |.4.{..S..VW..?..|
+00000250  98 c4 64 27 b5 f5 f6 57  16 ca d9 0a 33 de 24 c3  |..d'...W....3.$.|
+00000260  f3 7c 23 37 94 93 c5 1a  42 da 18 6b 24 dd 37 54  |.|#7....B..k$.7T|
+00000270  ae f3 8a 3e 10 42 20 6e  49 23 1a 0f bd 65 7e 45  |...>.B nI#...e~E|
+00000280  12 7a 64 9a 30 17 03 03  00 99 af 41 cf 95 21 1f  |.zd.0......A..!.|
+00000290  34 df 1c c7 a8 b6 ee 31  8d b3 9e 5a 59 8e c4 37  |4......1...ZY..7|
+000002a0  79 a4 d8 75 22 da 12 21  e5 de d4 ad 98 17 e2 ae  |y..u"..!........|
+000002b0  ae 9f f6 e8 29 66 d0 ac  b4 08 16 24 40 67 9d d5  |....)f.....$@g..|
+000002c0  bf a4 64 91 a1 17 82 c0  e7 77 b6 20 26 4a 70 1d  |..d......w. &Jp.|
+000002d0  c8 f8 ec 18 b7 c6 3c 81  b9 c6 04 9c 0d 37 a6 39  |......<......7.9|
+000002e0  fd 2d 99 d7 ba 41 a4 91  60 f1 1f d2 76 76 aa 47  |.-...A..`...vv.G|
+000002f0  89 0a d1 97 0b 91 20 a9  43 c9 ce 2c 84 ba 81 7a  |...... .C..,...z|
+00000300  39 91 7d 12 75 05 8e 87  b1 3f 80 8d 12 ca 8f 91  |9.}.u....?......|
+00000310  23 84 28 11 c3 81 ed 09  05 16 6e 50 57 76 ad 5c  |#.(.......nPWv.\|
+00000320  c5 92 77 17 03 03 00 35  5a d9 15 29 1f a3 f0 cf  |..w....5Z..)....|
+00000330  74 c4 1d 0c c3 fa 54 59  1e 54 06 0d 1b ce 07 00  |t.....TY.T......|
+00000340  f9 66 3d e1 75 10 cf de  cb 7d 0d d6 d1 4d 87 81  |.f=.u....}...M..|
+00000350  13 ec 2c 28 13 a5 b3 01  c7 86 3a 84 65 17 03 03  |..,(......:.e...|
+00000360  00 17 b4 e4 18 61 62 04  b3 ca 98 36 93 42 a2 be  |.....ab....6.B..|
+00000370  2c f5 18 11 bd 7d 64 70  bc 17 03 03 00 13 32 65  |,....}dp......2e|
+00000380  fa 07 3e 3c ed 9d 85 31  ba 8e 92 ea de 17 59 cd  |..><...1......Y.|
+00000390  db                                                |.|
diff --git a/src/crypto/tls/testdata/Client-TLSv13-ECDSA b/src/crypto/tls/testdata/Client-TLSv13-ECDSA
index 098f3ab3c9..dac9ef70c8 100644
--- a/src/crypto/tls/testdata/Client-TLSv13-ECDSA
+++ b/src/crypto/tls/testdata/Client-TLSv13-ECDSA
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,71 +16,71 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 7a 02 00 00  76 03 03 e8 ec ee 61 3e  |....z...v.....a>|
-00000010  c1 43 87 6d f1 61 ed d2  41 1f 7d d7 b7 c0 92 fd  |.C.m.a..A.}.....|
-00000020  34 17 85 7b c7 ff c4 56  dd 90 bd 20 00 00 00 00  |4..{...V... ....|
+00000000  16 03 03 00 7a 02 00 00  76 03 03 e3 21 e8 24 fb  |....z...v...!.$.|
+00000010  e8 fe 46 e2 54 a7 db 98  ae a4 b2 fc f8 17 99 b4  |..F.T...........|
+00000020  ed 6a aa 9c f9 ce e2 0f  f8 88 05 20 00 00 00 00  |.j......... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 01 00 00  |................|
-00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 3f  |..+.....3.$... ?|
-00000060  be 50 e7 f1 b0 30 60 dc  92 50 b8 01 4a d1 3e ff  |.P...0`..P..J.>.|
-00000070  6e f0 bd e1 17 44 d8 19  1b c6 63 43 e5 c1 58 14  |n....D....cC..X.|
-00000080  03 03 00 01 01 17 03 03  00 17 c0 b7 da 01 3e 64  |..............>d|
-00000090  6b 57 ba 21 12 79 42 8c  63 1f 45 d1 f2 10 fe 98  |kW.!.yB.c.E.....|
-000000a0  b6 17 03 03 02 22 90 87  e6 c3 ba 92 41 a2 96 00  |....."......A...|
-000000b0  c7 92 97 ab 4b 80 02 bb  02 83 19 f3 f6 36 d5 23  |....K........6.#|
-000000c0  3c c7 bd fb 97 67 86 cb  70 4c 60 9e 6c d4 7a f3  |<....g..pL`.l.z.|
-000000d0  03 a5 f1 09 d5 7e 07 74  f3 c8 e4 b8 da 44 a3 94  |.....~.t.....D..|
-000000e0  ee 4e 4a 7b ab 4e 92 03  49 04 4e cf 1b b3 0d 91  |.NJ{.N..I.N.....|
-000000f0  0f 98 51 5c 56 4d d3 a8  75 4b e0 96 d9 9e dd c8  |..Q\VM..uK......|
-00000100  81 c4 37 a0 c6 c9 ec 0f  e0 f1 ed 29 ff 5a a2 d4  |..7........).Z..|
-00000110  af 61 f7 b1 d5 ee e7 1d  7a e1 7f 33 8d 75 e6 9d  |.a......z..3.u..|
-00000120  bc 78 56 eb c5 89 d3 19  86 81 09 e1 ee 10 03 7c  |.xV............||
-00000130  a4 1b 78 17 51 a3 53 b4  67 5d 29 49 21 b2 51 7b  |..x.Q.S.g])I!.Q{|
-00000140  f5 dc fd 60 11 ee 8f 50  ea 28 b5 db 57 04 7e 3b  |...`...P.(..W.~;|
-00000150  ad 6f 29 d4 22 f3 a1 4b  52 ac b8 2b 30 0c 67 16  |.o)."..KR..+0.g.|
-00000160  e3 e0 7d a3 03 66 c4 39  70 8e c7 06 cf d2 6f 98  |..}..f.9p.....o.|
-00000170  c1 c9 f6 a9 6a 89 b4 3e  38 97 ae e4 f2 97 a4 6f  |....j..>8......o|
-00000180  e2 05 f8 e9 53 c9 ae f7  87 c3 0f 68 75 9e 07 e9  |....S......hu...|
-00000190  45 e9 0d 03 7e c8 79 56  30 77 e3 ea db 92 a2 f8  |E...~.yV0w......|
-000001a0  5e 5b ab 77 0d 9b bc 5f  51 40 6c 1b 0d ef b4 cf  |^[.w..._Q@l.....|
-000001b0  4a 3d a6 8c b6 ab ce 4f  6c 08 0e 23 f0 2a 56 07  |J=.....Ol..#.*V.|
-000001c0  f5 88 68 c3 0c fd 63 9b  e4 56 12 a6 f5 0a ed 54  |..h...c..V.....T|
-000001d0  40 30 ee 36 72 5d ca bb  5a 52 d3 84 14 c1 7e e4  |@0.6r]..ZR....~.|
-000001e0  f8 fb e9 c8 10 16 54 16  1f 72 99 8c 7a 69 87 ca  |......T..r..zi..|
-000001f0  62 53 dc cb a4 26 73 90  fb 11 3c 3c 9f 94 65 cb  |bS...&s...<<..e.|
-00000200  28 94 65 ca 56 45 a8 c1  ec 08 31 dd eb bc 17 71  |(.e.VE....1....q|
-00000210  cd 65 04 95 2e e7 e0 fb  73 fe 70 db 70 31 93 90  |.e......s.p.p1..|
-00000220  cf 47 07 ec 92 98 c1 da  fc 13 f8 8a 28 4e e8 80  |.G..........(N..|
-00000230  a8 96 c2 e2 a6 cd df d4  7f 46 4a 3b e9 dd cf a5  |.........FJ;....|
-00000240  75 d5 cc 67 35 81 d5 2e  e4 68 c4 56 1a 46 33 5a  |u..g5....h.V.F3Z|
-00000250  f2 79 32 6b 4e a0 6b 76  53 53 04 73 86 fd bd e2  |.y2kN.kvSS.s....|
-00000260  f7 f8 14 0f 0a a8 10 6d  a1 bf f8 d0 27 8d cb e8  |.......m....'...|
-00000270  a5 51 16 4b 11 a2 8a 6f  22 c5 7c bc c5 7a 0b df  |.Q.K...o".|..z..|
-00000280  70 1d c4 93 ec 87 78 12  77 e3 85 5a 3c 29 d8 f7  |p.....x.w..Z<)..|
-00000290  ab a4 c6 10 50 ed d5 2a  3f b1 84 73 1e 7f 99 eb  |....P..*?..s....|
-000002a0  31 9c 2c d2 6a 80 4a 5e  7c aa 64 e7 83 df a9 17  |1.,.j.J^|.d.....|
-000002b0  c3 4c 13 c8 c1 d7 1b f5  be c9 00 cf ec 7e a5 ab  |.L...........~..|
-000002c0  89 9c b0 72 fd f0 cb 54  17 03 03 00 a4 28 34 92  |...r...T.....(4.|
-000002d0  a7 52 92 5d a0 99 6b e6  22 c5 f6 76 86 1b 0b d6  |.R.]..k."..v....|
-000002e0  b7 a8 67 c1 04 b8 1c ac  7b 02 f5 0a 20 41 dd 43  |..g.....{... A.C|
-000002f0  25 cc 01 f9 dc 6e c7 f7  4f 67 dd b3 54 81 80 d5  |%....n..Og..T...|
-00000300  6d 45 00 42 d0 49 23 d5  12 33 e4 5f fd 58 79 81  |mE.B.I#..3._.Xy.|
-00000310  e3 df 67 6d 03 44 58 0f  76 38 c3 de ed 26 90 29  |..gm.DX.v8...&.)|
-00000320  45 92 ce 3b fa ea 98 da  ea a2 d2 cc c6 0e a8 38  |E..;...........8|
-00000330  c1 2d 92 8c 48 79 58 25  75 fd 2d 6d ef 06 32 1a  |.-..HyX%u.-m..2.|
-00000340  bb 09 fa 66 bc 06 9d c5  fb 46 94 5e b1 73 8d 05  |...f.....F.^.s..|
-00000350  e1 90 24 c3 eb 72 7f a8  b7 12 a3 3c 11 29 ea 80  |..$..r.....<.)..|
-00000360  10 4e 19 40 25 0b c9 34  70 99 e9 1a 60 17 bb 5b  |.N.@%..4p...`..[|
-00000370  1a 17 03 03 00 35 91 4b  45 15 d5 2e 33 a7 ba 9b  |.....5.KE...3...|
-00000380  64 20 bb 72 28 06 27 37  2f ac c9 c0 9e b9 d8 f3  |d .r(.'7/.......|
-00000390  86 36 d2 7d df c2 4d 95  a5 a4 4b 64 5f 1a 83 67  |.6.}..M...Kd_..g|
-000003a0  f6 6a 21 ff d0 b4 1c 65  23 62 ac                 |.j!....e#b.|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 03 00 00  |................|
+00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 a9  |..+.....3.$... .|
+00000060  5a 5c e9 b1 71 e8 a8 64  97 65 02 6b 3d 25 6f 6f  |Z\..q..d.e.k=%oo|
+00000070  9a 47 cb 4a 81 ac 89 23  22 c1 f4 3d db 77 1e 14  |.G.J...#"..=.w..|
+00000080  03 03 00 01 01 17 03 03  00 17 12 15 75 15 9f 10  |............u...|
+00000090  90 07 34 9c eb 05 d0 a1  4b 36 5b 4c 7b 26 2a 00  |..4.....K6[L{&*.|
+000000a0  29 17 03 03 02 22 85 a0  67 d7 72 57 83 19 79 12  |)...."..g.rW..y.|
+000000b0  b7 bd 37 ed ab 49 5d 15  49 2b 4f a1 b2 25 08 22  |..7..I].I+O..%."|
+000000c0  88 83 70 07 bc 8f 69 45  1b 21 36 99 f4 99 40 f8  |..p...iE.!6...@.|
+000000d0  0d 30 13 87 70 68 f6 9d  ce c7 9e 25 2c 1e 7a b5  |.0..ph.....%,.z.|
+000000e0  52 ed f8 0f f7 d9 e5 15  fc a3 47 83 0d 18 c4 de  |R.........G.....|
+000000f0  a1 a6 24 35 aa 56 d1 8b  95 07 5f 0f ba 1f 96 c3  |..$5.V...._.....|
+00000100  5b 36 cc d2 15 e6 b4 88  8f e3 7f 79 c2 24 d5 f3  |[6.........y.$..|
+00000110  a7 35 69 4e d2 2a f7 5c  08 8a c0 26 dd b9 77 5b  |.5iN.*.\...&..w[|
+00000120  96 1b 5f 03 89 07 a0 6a  b1 14 1d 02 46 08 eb 80  |.._....j....F...|
+00000130  d5 4c dc 69 63 8f 14 a1  e5 02 95 05 8a 8b c8 68  |.L.ic..........h|
+00000140  c3 d8 75 56 47 94 32 ba  67 71 ed 4b b4 62 ba 6a  |..uVG.2.gq.K.b.j|
+00000150  31 20 a7 d6 f8 8c a0 e9  e8 d2 1a 6b 85 6b b7 ee  |1 .........k.k..|
+00000160  78 e1 2e 4c 14 f0 b3 3e  b8 dc 7d af f0 9d 29 f3  |x..L...>..}...).|
+00000170  54 1d 9d dc 9e a3 9f 29  5b 33 1d f7 00 98 85 bd  |T......)[3......|
+00000180  42 39 85 75 cf fa dc f3  7e 80 14 4e a5 90 80 b6  |B9.u....~..N....|
+00000190  e3 37 d3 27 c6 7b b9 ee  32 61 a5 72 e5 2f a6 ab  |.7.'.{..2a.r./..|
+000001a0  cb 8e ac 53 4b 86 24 92  4b 77 d6 8d aa b4 37 d5  |...SK.$.Kw....7.|
+000001b0  2b b2 2f 07 23 37 4a d9  1f cc 6c 72 c6 21 5b 38  |+./.#7J...lr.![8|
+000001c0  a3 33 5c 86 50 69 34 8f  5a b8 cc 5e 82 7d 5b b2  |.3\.Pi4.Z..^.}[.|
+000001d0  5b f5 58 7f 2c 61 08 4b  3d 8b 67 09 19 01 d2 4f  |[.X.,a.K=.g....O|
+000001e0  06 62 17 4e d4 bf 88 89  bb c4 6e 14 2b 3a 50 c9  |.b.N......n.+:P.|
+000001f0  56 8a c1 0a 45 e6 67 32  f3 96 37 4b ba c2 2a 2b  |V...E.g2..7K..*+|
+00000200  84 e1 ff bb e0 ea 68 9b  98 fc 78 26 25 f6 50 25  |......h...x&%.P%|
+00000210  52 57 83 94 39 b9 a7 8d  38 43 70 a8 b7 61 a6 cf  |RW..9...8Cp..a..|
+00000220  09 77 db 3d 64 94 63 73  5b a1 6d f4 06 c1 b3 fb  |.w.=d.cs[.m.....|
+00000230  c6 9a 0b ea 9f 8e 6d 58  53 0e 13 e0 a6 21 69 7a  |......mXS....!iz|
+00000240  d3 57 32 d4 c6 32 ef 02  8e 54 1d 72 2d d6 a7 dc  |.W2..2...T.r-...|
+00000250  59 54 be 69 3f 5c 53 23  a9 f7 3e a9 e6 e7 e0 98  |YT.i?\S#..>.....|
+00000260  65 f6 74 f4 49 1c 77 0f  92 34 87 81 29 85 d1 e0  |e.t.I.w..4..)...|
+00000270  1e 4d b4 eb c2 44 43 a7  10 51 7c 5e 8e a4 b6 37  |.M...DC..Q|^...7|
+00000280  78 e8 35 02 07 3d 60 a5  01 75 01 25 f3 ff 32 ff  |x.5..=`..u.%..2.|
+00000290  34 ab a4 c3 4c ad 21 b8  91 0a d6 54 4b 7d cf c5  |4...L.!....TK}..|
+000002a0  ec 0f e5 4a 4d 75 4c ec  fc 37 2b 26 5a 73 93 70  |...JMuL..7+&Zs.p|
+000002b0  88 c7 9c cf 32 f9 ee a7  27 6e 1d 9e 36 a2 31 9e  |....2...'n..6.1.|
+000002c0  cd 0e c2 89 ef 2b 40 1a  17 03 03 00 a4 ad 19 05  |.....+@.........|
+000002d0  e6 40 5e b1 ec 69 6b 47  ef 5d d3 ee a6 94 51 85  |.@^..ikG.]....Q.|
+000002e0  d8 28 d9 df 8b d0 df 23  7e bd 98 6c 33 26 45 fa  |.(.....#~..l3&E.|
+000002f0  60 71 8b f5 71 5c 22 4e  b3 a7 01 fe 17 39 89 67  |`q..q\"N.....9.g|
+00000300  0b 70 ff 52 b9 10 9c e9  02 c0 1c 56 9d c8 45 51  |.p.R.......V..EQ|
+00000310  5a dd 86 79 6d a7 7d eb  16 c2 1a 5f 6a 3b 93 42  |Z..ym.}...._j;.B|
+00000320  13 f3 3d 8a 39 21 5f a9  7f cf 4b 1e 22 f1 a3 f8  |..=.9!_...K."...|
+00000330  5c 35 41 2a e2 91 72 4f  59 61 1c 15 be 27 6a bd  |\5A*..rOYa...'j.|
+00000340  b7 16 1f 63 97 51 d6 96  dd 81 f9 e7 fd 97 33 6e  |...c.Q........3n|
+00000350  da 5a 61 77 57 6e 3b 65  24 db b3 3a 18 7b dc f4  |.ZawWn;e$..:.{..|
+00000360  7c ff ab 43 7f 1b ae ae  b8 73 71 9e be 91 d6 56  ||..C.....sq....V|
+00000370  13 17 03 03 00 35 39 61  a3 b7 e5 1d 3d 87 92 84  |.....59a....=...|
+00000380  11 39 7d f4 ce 29 b9 4b  fd 3c 0c 5a b6 3a fa e2  |.9}..).K.<.Z.:..|
+00000390  a8 5b e6 d2 e5 7e e3 a6  33 59 e4 a8 59 95 5d b9  |.[...~..3Y..Y.].|
+000003a0  31 6d 51 90 22 be c0 3f  6e 43 f2                 |1mQ."..?nC.|
 >>> Flow 3 (client to server)
-00000000  14 03 03 00 01 01 17 03  03 00 35 10 bd 5d 23 36  |..........5..]#6|
-00000010  58 43 f4 bb 5e 4e ee 43  fd 0e a1 d9 de 81 99 54  |XC..^N.C.......T|
-00000020  de 6e 82 33 71 8a 45 a7  35 f1 cd fb 5f bf 46 20  |.n.3q.E.5..._.F |
-00000030  a5 79 d6 87 aa f4 29 51  02 f5 4e 69 ef a5 d7 d6  |.y....)Q..Ni....|
-00000040  17 03 03 00 17 21 1f 90  0b 01 63 89 6a af 53 72  |.....!....c.j.Sr|
-00000050  51 c0 11 01 7b 09 dd 40  82 dd e1 32 17 03 03 00  |Q...{..@...2....|
-00000060  13 93 5d c1 19 16 5c 17  1a 7b 92 a0 9b f5 14 57  |..]...\..{.....W|
-00000070  85 39 4a ac                                       |.9J.|
+00000000  14 03 03 00 01 01 17 03  03 00 35 50 4f ce ae a5  |..........5PO...|
+00000010  f7 b0 7e 2b 91 86 72 da  90 65 fd 1b a5 46 c6 98  |..~+..r..e...F..|
+00000020  47 90 5a f2 b8 5a 1f 18  44 19 bd ca dd 2a 15 e7  |G.Z..Z..D....*..|
+00000030  53 f5 17 e8 7d 9b f1 9a  63 ac b0 b0 df c3 0e 4c  |S...}...c......L|
+00000040  17 03 03 00 17 8b bd fb  bc fd f7 af 53 9b 8b 1a  |............S...|
+00000050  a3 e5 f6 e9 87 bd 4a 8a  1b 0e c9 d9 17 03 03 00  |......J.........|
+00000060  13 8e c6 d3 6e 04 8f 3b  d4 76 a4 c7 c8 63 a8 a8  |....n..;.v...c..|
+00000070  9e ba e7 fd                                       |....|
diff --git a/src/crypto/tls/testdata/Client-TLSv13-Ed25519 b/src/crypto/tls/testdata/Client-TLSv13-Ed25519
index 0b4a17af3a..d28474011b 100644
--- a/src/crypto/tls/testdata/Client-TLSv13-Ed25519
+++ b/src/crypto/tls/testdata/Client-TLSv13-Ed25519
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,53 +16,53 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 7a 02 00 00  76 03 03 a8 21 4e 51 6a  |....z...v...!NQj|
-00000010  ce ba 17 cc 2d 25 b3 31  59 6a 3f 81 eb e6 ac a0  |....-%.1Yj?.....|
-00000020  91 d9 ef 76 a1 5f bb 63  ab 2c 6b 20 00 00 00 00  |...v._.c.,k ....|
+00000000  16 03 03 00 7a 02 00 00  76 03 03 6f b6 d3 79 9b  |....z...v..o..y.|
+00000010  00 17 a8 46 3f e4 bc fc  08 1e 56 6c d8 63 86 f3  |...F?.....Vl.c..|
+00000020  83 1b d8 26 6d 86 d6 4c  f3 4f e1 20 00 00 00 00  |...&m..L.O. ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 01 00 00  |................|
-00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 81  |..+.....3.$... .|
-00000060  4c a8 07 aa 6b 4a f9 44  77 78 a9 57 d0 07 55 07  |L...kJ.Dwx.W..U.|
-00000070  9a c2 8e 33 bf c4 09 ee  49 51 5c fe f1 7b 30 14  |...3....IQ\..{0.|
-00000080  03 03 00 01 01 17 03 03  00 17 5a 22 a1 07 01 ea  |..........Z"....|
-00000090  97 bd 5a 59 3a 21 de 9c  45 0c 41 ff 34 45 35 ab  |..ZY:!..E.A.4E5.|
-000000a0  25 17 03 03 01 50 a1 8c  19 e7 0c 69 d3 e0 f6 53  |%....P.....i...S|
-000000b0  95 15 13 4c e3 c3 3f 35  d9 73 c9 fe 24 b0 14 5f  |...L..?5.s..$.._|
-000000c0  b6 9e 94 20 cf 80 f7 88  7c 0f be 4c 70 16 00 2a  |... ....|..Lp..*|
-000000d0  55 02 aa a9 4b 7f a7 a5  b8 46 09 9e 18 78 78 66  |U...K....F...xxf|
-000000e0  22 c2 31 19 12 f7 e4 7e  f3 26 39 7d cd 5e 74 24  |".1....~.&9}.^t$|
-000000f0  fb 75 7d b7 2c b5 fb e0  49 bd da 96 e1 c3 63 8f  |.u}.,...I.....c.|
-00000100  e3 28 43 bb 32 a7 fd 9c  ab 54 ba ce 07 4a 23 35  |.(C.2....T...J#5|
-00000110  a4 3a ff 43 40 19 ef 38  07 02 ba d6 c4 f0 bf 63  |.:.C@..8.......c|
-00000120  aa b3 ea 55 d0 e1 a9 f3  cb 04 6b 1b 8d 35 3a f8  |...U......k..5:.|
-00000130  0b 1c 40 99 fe b0 04 5f  d1 5b 3f 4b be fe b5 96  |..@...._.[?K....|
-00000140  f0 49 3d bf a5 92 f3 bd  a6 4c 47 24 f8 b5 7c 45  |.I=......LG$..|E|
-00000150  47 85 9b 08 a1 da 51 7a  ce 3f 32 66 de 89 c0 c3  |G.....Qz.?2f....|
-00000160  ac da 73 0d 15 14 18 e6  a0 7d 07 26 44 df 55 b7  |..s......}.&D.U.|
-00000170  6e 4e fa c0 f5 5e 42 3a  d9 29 d3 1d e6 cf 3c 8c  |nN...^B:.)....<.|
-00000180  6d c1 d9 f9 04 f0 57 dc  47 4e d1 e2 a1 f1 a1 c9  |m.....W.GN......|
-00000190  2e da 97 4d 65 65 04 54  e7 80 f1 88 b2 34 26 61  |...Mee.T.....4&a|
-000001a0  77 8a 1f bb 82 7f 4b ce  b3 5a 55 60 e1 3a ef 95  |w.....K..ZU`.:..|
-000001b0  bd 34 fc ef 2b 18 4b bb  8a cf ba 3a 69 43 f4 59  |.4..+.K....:iC.Y|
-000001c0  98 a1 95 a3 22 f6 b5 1a  84 83 cf cb 90 eb 28 29  |....".........()|
-000001d0  b3 84 e1 0d 37 9e 98 96  91 73 f1 7f d7 9b 71 38  |....7....s....q8|
-000001e0  6e bc 2e 60 2d 27 0c 18  fd 2a b8 76 01 33 2f 95  |n..`-'...*.v.3/.|
-000001f0  6e 0b bf 2b 26 5e 17 03  03 00 59 ed 43 2f e8 df  |n..+&^....Y.C/..|
-00000200  f3 2f 91 f3 dc 1b aa ff  d3 3b 28 1f 78 21 fb e2  |./.......;(.x!..|
-00000210  7d 6e 03 09 98 c1 23 09  d7 45 da b8 e0 5a e5 27  |}n....#..E...Z.'|
-00000220  38 9a 2f da 9b d3 04 35  f5 b9 31 b0 c0 1f 8a 1e  |8./....5..1.....|
-00000230  d8 8a 19 f1 38 af a6 74  ac e5 b4 0d 45 83 b4 59  |....8..t....E..Y|
-00000240  83 42 97 14 23 55 71 ef  66 8c 35 69 3f 2c 88 63  |.B..#Uq.f.5i?,.c|
-00000250  8d 3b 05 fe 17 03 03 00  35 47 82 ec 22 f4 86 6a  |.;......5G.."..j|
-00000260  b7 c1 d8 64 3b 42 f4 ca  5c 3d ba a3 6a ea 77 6a  |...d;B..\=..j.wj|
-00000270  d6 52 e3 b0 42 fb c2 f1  2c b1 ef 44 ed 11 29 6d  |.R..B...,..D..)m|
-00000280  2b 6f 13 0f 42 48 a0 2e  5b ba a1 93 6b de        |+o..BH..[...k.|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 03 00 00  |................|
+00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 5b  |..+.....3.$... [|
+00000060  8f 4f 5a a9 95 6b 04 07  31 d3 ed 91 8b 25 b4 7b  |.OZ..k..1....%.{|
+00000070  5c a1 0a a6 26 09 92 9b  b0 72 26 f9 0d 09 60 14  |\...&....r&...`.|
+00000080  03 03 00 01 01 17 03 03  00 17 a8 99 d3 76 1f 12  |.............v..|
+00000090  19 18 15 8e 4c 59 43 92  11 4a aa 50 98 7e 4c d9  |....LYC..J.P.~L.|
+000000a0  63 17 03 03 01 50 66 f5  d6 ce 35 0f 10 e5 ab 34  |c....Pf...5....4|
+000000b0  78 17 c6 b6 60 40 eb 53  34 9f ce 02 c4 36 51 18  |x...`@.S4....6Q.|
+000000c0  c2 b3 fb f3 98 92 d0 f2  b7 be 28 f5 c7 2d fa 1f  |..........(..-..|
+000000d0  9b 8b aa e5 45 54 6b 0e  ed 6b 44 cb d4 4d 62 b2  |....ETk..kD..Mb.|
+000000e0  30 c9 df ac cf a3 7e 43  58 1e bf 6e 5b 69 4e 48  |0.....~CX..n[iNH|
+000000f0  1c 39 49 eb 8a 0c 22 f3  70 4a 80 50 39 d6 68 29  |.9I...".pJ.P9.h)|
+00000100  d0 6d 08 20 26 39 6d 37  5a 9f 79 e9 16 e3 7e 94  |.m. &9m7Z.y...~.|
+00000110  8f 5f 9b 97 2d e1 b1 48  e4 a3 36 63 40 5a 80 93  |._..-..H..6c@Z..|
+00000120  06 27 3b 93 d9 ed 2d b1  3e 74 ed bc 38 a1 cb 17  |.';...-.>t..8...|
+00000130  06 4a 9b c1 c1 d7 7a 1c  ca ff 4d ee 91 6d d0 3c  |.J....z...M..m.<|
+00000140  c2 4b cc 33 c6 7c 76 8e  db a2 e0 fe 15 e2 ec db  |.K.3.|v.........|
+00000150  1f 5d 05 c8 5e 0e 7f 2c  7a 95 08 34 68 a2 2c 7c  |.]..^..,z..4h.,||
+00000160  04 16 92 7a c8 ec 52 2d  1a c4 7a ea 12 cd 0f b9  |...z..R-..z.....|
+00000170  7c 00 51 55 02 5b 02 7d  ec 89 af f5 6d 76 89 0e  ||.QU.[.}....mv..|
+00000180  67 42 f0 e4 67 4d 3f 70  ff 2c 64 81 1c 4a 92 1f  |gB..gM?p.,d..J..|
+00000190  26 8b a4 4f 15 18 b5 11  4a 61 df 45 53 74 fd 8d  |&..O....Ja.ESt..|
+000001a0  ff 22 32 91 af c7 7f a4  7b 62 c3 3b 30 51 b6 34  |."2.....{b.;0Q.4|
+000001b0  b6 01 21 f9 86 74 be 62  27 1a 41 1f f0 0d 8b 5c  |..!..t.b'.A....\|
+000001c0  4b 82 ea 76 23 9c 36 af  25 1f f6 2d 5f 9c 28 bd  |K..v#.6.%..-_.(.|
+000001d0  b6 d5 1e 26 8b c1 dc ac  ed 6d 10 ff 13 ed fc 08  |...&.....m......|
+000001e0  08 0a 74 1c b1 5b f8 45  e4 83 44 f2 be ce 8d ac  |..t..[.E..D.....|
+000001f0  ee ae e6 21 da c7 17 03  03 00 59 d9 b3 95 0a f7  |...!......Y.....|
+00000200  1a 1a 54 fa ab 09 38 6d  6d 53 0a ef 11 73 bc a2  |..T...8mmS...s..|
+00000210  20 03 31 48 e2 0a d1 af  56 6c ca dd 88 ba 72 3a  | .1H....Vl....r:|
+00000220  c1 e0 c5 60 44 74 d6 c9  18 23 96 2c e7 88 c8 3e  |...`Dt...#.,...>|
+00000230  02 73 c0 38 d4 bd 85 a4  bb 78 a0 ba d3 fd f1 c4  |.s.8.....x......|
+00000240  27 08 05 fb 2c 26 20 b7  1a 41 87 a6 b7 97 19 26  |'...,& ..A.....&|
+00000250  50 ed 9a e4 17 03 03 00  35 68 36 c7 78 c3 5e ff  |P.......5h6.x.^.|
+00000260  b3 92 a7 25 31 2a a2 fa  24 d9 da 69 16 03 8b db  |...%1*..$..i....|
+00000270  fe b2 3f 63 88 49 f1 14  63 7a 58 a9 6f c5 64 92  |..?c.I..czX.o.d.|
+00000280  21 84 82 d8 49 98 fb f3  f1 fd 52 83 32 97        |!...I.....R.2.|
 >>> Flow 3 (client to server)
-00000000  14 03 03 00 01 01 17 03  03 00 35 11 45 8f b2 e0  |..........5.E...|
-00000010  87 3d 09 94 93 16 19 04  3d 84 6c e5 14 5e c6 8b  |.=......=.l..^..|
-00000020  73 1a 53 4c d0 f4 11 27  0c 0d 05 c7 9d ba d0 04  |s.SL...'........|
-00000030  37 ed 8b 8a 65 34 54 b1  07 36 92 8c 8c a8 30 b7  |7...e4T..6....0.|
-00000040  17 03 03 00 17 ea fc b8  84 8d f0 9d 8e 1c 2c 65  |..............,e|
-00000050  10 a8 69 7f dd 3c a4 80  45 5d c3 38 17 03 03 00  |..i..<..E].8....|
-00000060  13 15 4b b7 23 2f 55 b0  ae d3 3f f6 68 c9 b2 ef  |..K.#/U...?.h...|
-00000070  d7 e2 18 49                                       |...I|
+00000000  14 03 03 00 01 01 17 03  03 00 35 07 7b a2 7a 4f  |..........5.{.zO|
+00000010  40 e9 a2 94 9f b7 2d 91  87 1e 37 b0 ca b7 ea 91  |@.....-...7.....|
+00000020  53 f1 bf 7d 56 6a 0c 6a  9d 07 ac 93 9c db ca ac  |S..}Vj.j........|
+00000030  43 7b eb 56 9d 6c 79 f2  72 f8 0b 8d 15 08 84 d5  |C{.V.ly.r.......|
+00000040  17 03 03 00 17 07 b3 7d  a9 56 c4 76 e5 12 97 29  |.......}.V.v...)|
+00000050  b7 99 e6 3e 08 79 2d fb  1a 5b eb 7a 17 03 03 00  |...>.y-..[.z....|
+00000060  13 66 b7 65 57 0d 54 7b  6a 34 98 a1 4e 29 d5 92  |.f.eW.T{j4..N)..|
+00000070  1e b6 52 bc                                       |..R.|
diff --git a/src/crypto/tls/testdata/Client-TLSv13-ExportKeyingMaterial b/src/crypto/tls/testdata/Client-TLSv13-ExportKeyingMaterial
index b30641131e..a0ede61c70 100644
--- a/src/crypto/tls/testdata/Client-TLSv13-ExportKeyingMaterial
+++ b/src/crypto/tls/testdata/Client-TLSv13-ExportKeyingMaterial
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,75 +16,75 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 7a 02 00 00  76 03 03 6d fb 70 07 b4  |....z...v..m.p..|
-00000010  2d 14 d1 d1 88 17 6a a3  b1 c1 e7 23 4b 06 c4 fa  |-.....j....#K...|
-00000020  4a 0e e1 2c ce 5a d5 c7  8c ab f2 20 00 00 00 00  |J..,.Z..... ....|
+00000000  16 03 03 00 7a 02 00 00  76 03 03 d6 7f ef 2d f6  |....z...v.....-.|
+00000010  82 d9 be 6d 33 80 73 c0  d4 d8 63 e9 95 a6 5b 1f  |...m3.s...c...[.|
+00000020  ce c0 ec 13 07 f4 68 7d  cc 79 18 20 00 00 00 00  |......h}.y. ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 01 00 00  |................|
-00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 4e  |..+.....3.$... N|
-00000060  fe 87 d7 81 71 25 ba 33  de 10 df 19 38 d8 af 43  |....q%.3....8..C|
-00000070  58 3f 41 2e b9 b8 cb 1c  65 a7 cd 8d 00 b1 0e 14  |X?A.....e.......|
-00000080  03 03 00 01 01 17 03 03  00 17 b3 63 09 54 ad 41  |...........c.T.A|
-00000090  24 fe 2c 81 49 c8 86 88  c2 ad ba cd 45 77 51 c0  |$.,.I.......EwQ.|
-000000a0  d5 17 03 03 02 6d 74 7d  de 53 70 5c 11 d0 a7 68  |.....mt}.Sp\...h|
-000000b0  8e 10 c9 cb cd 0c 25 ac  88 e7 17 54 8b 32 2c ee  |......%....T.2,.|
-000000c0  97 9c 3d f6 ce d1 83 70  ee c0 85 0c fc 61 ba db  |..=....p.....a..|
-000000d0  6d e0 04 26 6f b7 4e 44  4d 1c 5c 16 9a 57 4f e6  |m..&o.NDM.\..WO.|
-000000e0  52 89 27 53 88 f8 93 91  ed b2 42 b4 4c f0 58 a3  |R.'S......B.L.X.|
-000000f0  50 a7 af 2c 47 ac ad 8b  14 a0 9f d4 28 2e 7b 28  |P..,G.......(.{(|
-00000100  8e ec d1 bb 7d d9 78 fb  24 82 9f 2a ac 4e 85 83  |....}.x.$..*.N..|
-00000110  35 25 75 8f 9e 6d 4c 8a  dd 6f 9f 9a 34 93 a2 9d  |5%u..mL..o..4...|
-00000120  d0 26 4c 7b a8 72 a3 12  b9 ef 6b c8 d0 4f 44 5b  |.&L{.r....k..OD[|
-00000130  dd f1 72 3a b4 5c 7e a8  8d d4 68 bc 6d 54 2c ee  |..r:.\~...h.mT,.|
-00000140  c1 f7 78 f1 15 cd 57 b5  54 89 08 f0 d8 56 ef 8d  |..x...W.T....V..|
-00000150  14 d1 e8 fd 83 bd ab 64  c1 99 36 4e af 81 27 52  |.......d..6N..'R|
-00000160  0f 5e 31 5e c0 70 21 fb  05 40 d4 d2 71 df 0c 09  |.^1^.p!..@..q...|
-00000170  31 83 b0 71 82 84 d9 90  6b 25 5a 67 03 30 c4 80  |1..q....k%Zg.0..|
-00000180  2c 99 41 3f fa 51 ce a8  b4 b8 98 2a bc e9 cc ce  |,.A?.Q.....*....|
-00000190  f7 0c 69 a3 c3 02 dc b9  4f 00 ac 4f 29 d5 e5 df  |..i.....O..O)...|
-000001a0  df 67 3b ed 94 8e 80 3f  aa 6e a8 b7 e0 7f 4d fd  |.g;....?.n....M.|
-000001b0  95 80 54 89 57 ff d7 73  86 bd e8 98 11 d5 09 c6  |..T.W..s........|
-000001c0  ab af 1a a4 a0 cc 30 40  bc 63 dc d0 db 92 41 f5  |......0@.c....A.|
-000001d0  5c 1e f1 92 03 5b 3f 27  23 1f 9c 8e f8 8b 4f 69  |\....[?'#.....Oi|
-000001e0  0c 3d 09 e5 95 d8 ba 8c  90 cd ac 53 ed 77 8d 75  |.=.........S.w.u|
-000001f0  3a 56 b4 f3 21 a5 4e c2  6e 1f 87 74 56 69 32 95  |:V..!.N.n..tVi2.|
-00000200  29 56 07 2c 0d b3 74 47  28 6d 8f ef 56 f6 68 7f  |)V.,..tG(m..V.h.|
-00000210  25 e4 76 06 7c 82 40 11  f8 eb 3c ec 62 fa be 60  |%.v.|.@...<.b..`|
-00000220  d3 11 98 e2 d4 b1 d0 72  3d e6 4a da f0 d6 c0 42  |.......r=.J....B|
-00000230  8e a6 63 cc a1 41 e3 18  21 00 ac cc 98 f8 8d 78  |..c..A..!......x|
-00000240  ab 9b 39 16 ad 4c fd 11  15 79 0c fd 0e 87 45 d6  |..9..L...y....E.|
-00000250  81 30 bb 3a 72 89 92 c1  fa e8 ad 59 3b 8b b0 38  |.0.:r......Y;..8|
-00000260  2d c3 6e 87 a8 b8 1f 7d  a0 b3 e6 91 83 97 78 94  |-.n....}......x.|
-00000270  f0 01 66 a2 c8 89 45 8e  2e a0 7e 89 4d 7f 49 ee  |..f...E...~.M.I.|
-00000280  2a 69 c0 ec 77 db 85 df  01 d9 02 36 df 94 81 01  |*i..w......6....|
-00000290  aa 43 a2 3d 76 8c c3 21  bf 05 c3 b2 c4 28 85 65  |.C.=v..!.....(.e|
-000002a0  7b 4a ac e3 45 40 77 1d  a9 ee 1e e9 97 7c 2f 45  |{J..E@w......|/E|
-000002b0  45 18 58 47 ab 51 0f 26  eb d5 bb ac c2 8b a9 ae  |E.XG.Q.&........|
-000002c0  65 6a 91 9b 13 93 69 c6  9d bc 61 23 20 d2 ad a0  |ej....i...a# ...|
-000002d0  d3 f9 2d 32 79 e3 4b 07  90 32 9e e1 f3 13 18 b0  |..-2y.K..2......|
-000002e0  65 6e 89 a5 45 c6 a1 9b  f0 f6 d1 66 d3 e7 49 1a  |en..E......f..I.|
-000002f0  b8 e2 17 cd d0 13 9c e6  e1 77 87 a4 8b 6a d3 74  |.........w...j.t|
-00000300  0e 85 b1 2c f3 c8 a8 f3  65 b3 71 c2 bb f5 95 d7  |...,....e.q.....|
-00000310  81 78 45 17 03 03 00 99  1e 53 96 f9 b9 97 ec 53  |.xE......S.....S|
-00000320  4e 97 a9 8c 01 06 ee 6b  31 47 93 4b ac f7 b6 4a  |N......k1G.K...J|
-00000330  15 bb 28 d7 87 73 7c 1d  3b d3 6b 9d 48 77 df 09  |..(..s|.;.k.Hw..|
-00000340  c9 97 98 b6 d6 20 94 8a  ed 71 08 2d 56 af b2 b8  |..... ...q.-V...|
-00000350  20 fc d7 81 e4 53 eb 57  6a bd 9b 1c 11 4f 2e fb  | ....S.Wj....O..|
-00000360  9a 0e 65 08 69 df 28 70  a7 50 21 62 9f 63 39 db  |..e.i.(p.P!b.c9.|
-00000370  9e 73 40 5d 73 77 a7 1d  2e 79 61 fa b9 50 f0 70  |.s@]sw...ya..P.p|
-00000380  1e 71 d1 9e c6 2f 8c 4c  5f e0 b1 37 d7 c9 ab fc  |.q.../.L_..7....|
-00000390  5f 6a ca a9 9e 27 38 42  78 ba fb e6 8e c2 3f a6  |_j...'8Bx.....?.|
-000003a0  a0 c6 04 b6 d8 b7 3a 68  83 15 3b 70 f9 0a 27 4a  |......:h..;p..'J|
-000003b0  0a 17 03 03 00 35 d0 88  b7 b8 cf 81 4e 97 76 96  |.....5......N.v.|
-000003c0  c2 ed e8 15 e4 01 54 2b  1f 0e 34 08 52 6c a8 6a  |......T+..4.Rl.j|
-000003d0  cf 04 29 7b 27 fb e9 1e  d1 6c d2 28 15 03 2a 58  |..){'....l.(..*X|
-000003e0  d4 eb 67 18 83 3f d4 2a  ab 9f aa                 |..g..?.*...|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 03 00 00  |................|
+00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 00  |..+.....3.$... .|
+00000060  e9 40 7a 65 78 98 47 43  aa e1 63 fd 6b c4 21 1d  |.@zex.GC..c.k.!.|
+00000070  58 45 5f 64 a0 18 55 a0  c3 14 7d 4e 12 93 7c 14  |XE_d..U...}N..|.|
+00000080  03 03 00 01 01 17 03 03  00 17 4c 01 0b f7 e7 1b  |..........L.....|
+00000090  a9 47 84 10 3b 50 85 6e  3d 8e 52 bc 99 bf d4 35  |.G..;P.n=.R....5|
+000000a0  45 17 03 03 02 6d 8c b3  22 04 de 8b 09 e5 e7 9f  |E....m..".......|
+000000b0  d5 1f fb 8a 57 ad a7 93  4c 5f 29 46 df c3 e5 86  |....W...L_)F....|
+000000c0  66 f1 c7 6b 14 79 cf 9d  cc e1 f5 3f 31 2c dc ff  |f..k.y.....?1,..|
+000000d0  77 99 14 9e 56 12 4e a4  cb 56 5c d6 c0 5b 57 dc  |w...V.N..V\..[W.|
+000000e0  22 72 12 2d d6 a0 8a c7  90 e6 41 66 78 1a d7 a6  |"r.-......Afx...|
+000000f0  87 db f1 e3 9b 86 8c cf  94 22 cf 81 99 20 bc 19  |........."... ..|
+00000100  50 f9 fe 6c ab ea d4 a2  ee f8 17 1d ae 37 86 2a  |P..l.........7.*|
+00000110  f9 83 3c 59 d0 aa 63 22  18 d5 12 40 be f7 02 f1  |..<Y..c"...@....|
+00000120  9a bf 07 39 23 73 23 a1  66 70 b7 be 9a 24 de 30  |...9#s#.fp...$.0|
+00000130  2f 62 6e f8 d5 ee 69 a7  87 3c 73 10 4c 7c 97 42  |/bn...i..<s.L|.B|
+00000140  62 b9 d5 74 40 f0 d7 b3  74 42 73 d7 41 bc 35 43  |b..t@...tBs.A.5C|
+00000150  87 2e c5 1b e9 15 e8 5e  18 b9 6b 57 2a ee 59 7a  |.......^..kW*.Yz|
+00000160  1c a6 2b cb b4 db e8 bb  99 87 74 4a ee 57 3a 87  |..+.......tJ.W:.|
+00000170  3c 2d b9 76 41 4a 7a a5  6a fa 92 e9 80 24 08 dc  |<-.vAJz.j....$..|
+00000180  18 44 4b 59 7c 81 99 29  f2 c4 55 b6 58 71 0d 68  |.DKY|..)..U.Xq.h|
+00000190  6b 06 bd 13 2c a0 04 15  2e 49 cc 99 7f a6 b4 5d  |k...,....I.....]|
+000001a0  d3 49 a5 21 15 d7 66 2d  a2 e8 cd a7 7e 46 c4 ac  |.I.!..f-....~F..|
+000001b0  89 ae cb 58 73 42 9f dc  c3 c9 5a 13 2f 6f f7 ab  |...XsB....Z./o..|
+000001c0  04 4b 9f f1 6c c4 ac 0f  f5 eb 8d 7a ef cf 01 00  |.K..l......z....|
+000001d0  8a 02 ec 16 09 c1 e9 27  81 32 70 b1 24 d4 db 4e  |.......'.2p.$..N|
+000001e0  9e 22 65 21 a7 8f 19 d5  c6 57 78 8a fa a6 41 87  |."e!.....Wx...A.|
+000001f0  52 eb 5d ef f8 7e 3b 34  a5 31 ff 33 33 fd 85 03  |R.]..~;4.1.33...|
+00000200  e4 94 56 ef 11 c0 fe 84  f6 87 94 26 de 7c bd d1  |..V........&.|..|
+00000210  1b ea 15 34 62 e5 da bd  e6 c4 b0 74 b5 27 ad 21  |...4b......t.'.!|
+00000220  39 16 c8 be e8 41 50 7b  de fb 71 10 4c b1 f4 5a  |9....AP{..q.L..Z|
+00000230  bf ea fd 9b 86 a5 c6 e7  2f c2 13 e4 d2 cd 32 7a  |......../.....2z|
+00000240  6b ad ab 43 12 3b 45 b9  5c e4 cf 2c f9 f3 44 2c  |k..C.;E.\..,..D,|
+00000250  11 31 ce c5 65 dd ea e6  52 bd 8a 35 d0 31 d4 4f  |.1..e...R..5.1.O|
+00000260  01 24 54 e4 d2 bf 6e 79  b2 bf a8 f0 5d 9d 72 44  |.$T...ny....].rD|
+00000270  6e df 29 8a d2 cc a8 d2  ee 0c 51 50 cd 71 a6 2a  |n.).......QP.q.*|
+00000280  fe 53 2e f7 ae fa 4c 34  d0 68 31 d5 69 be 64 a5  |.S....L4.h1.i.d.|
+00000290  03 54 31 1a dc f0 9e c7  82 1f 15 d1 64 ff 79 07  |.T1.........d.y.|
+000002a0  5e 71 3a 98 3c 21 a7 8e  1e bf 2d f3 86 4b 3f 30  |^q:.<!....-..K?0|
+000002b0  73 0d 7c 5d 57 1b a9 89  2b 52 70 84 8e e6 bb fe  |s.|]W...+Rp.....|
+000002c0  b7 1f 65 6a 08 63 58 16  81 51 09 b2 79 7d 84 c0  |..ej.cX..Q..y}..|
+000002d0  6f e1 ab 92 35 16 2e 8f  5c 17 2d 5e 68 7f d4 94  |o...5...\.-^h...|
+000002e0  5a 1b 1d 6c 5f e0 36 a0  ae 54 5b e9 39 1f bc 73  |Z..l_.6..T[.9..s|
+000002f0  f9 04 80 e9 36 d2 2c de  64 ca 08 95 d0 98 4b da  |....6.,.d.....K.|
+00000300  7b 0d 7f 79 1b a0 56 6c  dd 3c 40 52 3e 7a 8f 52  |{..y..Vl.<@R>z.R|
+00000310  3c c9 2f 17 03 03 00 99  07 91 f0 6b e0 bb 6f 0b  |<./........k..o.|
+00000320  ff 08 69 bc d2 1d f1 40  d2 d7 c7 f6 c2 b3 57 d7  |..i....@......W.|
+00000330  90 00 c9 9e ef 40 b6 96  86 0d 27 8b 6f ac 54 2f  |.....@....'.o.T/|
+00000340  73 b3 b4 82 1b d3 f5 e9  41 a7 fd d5 b1 67 f7 6e  |s.......A....g.n|
+00000350  2e c1 06 34 ef a3 b9 97  4d a8 64 4f f8 48 24 5c  |...4....M.dO.H$\|
+00000360  66 f4 d7 d4 e3 ad 45 fb  4a 42 0d 19 bb a1 cc b3  |f.....E.JB......|
+00000370  88 d2 2a d7 c3 53 c4 7b  08 a5 68 dc c4 1a f6 f3  |..*..S.{..h.....|
+00000380  a1 42 48 1c c9 2b 1f fb  5d fc 49 ed ce 16 14 34  |.BH..+..].I....4|
+00000390  34 01 c9 ef e6 29 9c 81  1a 7d 7b bd 95 eb ad 5f  |4....)...}{...._|
+000003a0  ce 19 30 9c e6 ae 09 15  3c 2b 38 8b e6 97 76 4e  |..0.....<+8...vN|
+000003b0  dd 17 03 03 00 35 d2 a1  3f 22 e9 2b b6 7a d1 d8  |.....5..?".+.z..|
+000003c0  7b 87 bf d1 bf 56 0b 55  52 d0 a9 cf ae 57 6e 6f  |{....V.UR....Wno|
+000003d0  29 0c c3 f7 f3 d4 bf ff  a4 6b 49 1a 57 57 27 89  |)........kI.WW'.|
+000003e0  e0 f5 bb d2 16 85 39 40  fd 77 a3                 |......9@.w.|
 >>> Flow 3 (client to server)
-00000000  14 03 03 00 01 01 17 03  03 00 35 02 ed 34 8f 83  |..........5..4..|
-00000010  44 27 8b 71 af c1 06 33  0b 25 aa 22 85 96 41 75  |D'.q...3.%."..Au|
-00000020  4f fe 46 82 ba 95 91 4c  cc a9 99 60 5c f7 72 7f  |O.F....L...`\.r.|
-00000030  e4 1f e4 99 6a c2 25 db  d0 11 5d fc d6 28 8f 56  |....j.%...]..(.V|
-00000040  17 03 03 00 17 fe e8 cf  ed a0 7a ce 77 57 e6 aa  |..........z.wW..|
-00000050  f0 ce 6d 2f 5c e5 1f 7d  37 c8 91 cf 17 03 03 00  |..m/\..}7.......|
-00000060  13 a4 a9 4c b5 33 38 4a  1e b7 65 9d 72 85 1b 79  |...L.38J..e.r..y|
-00000070  79 87 e3 bf                                       |y...|
+00000000  14 03 03 00 01 01 17 03  03 00 35 b3 39 ad 6b 24  |..........5.9.k$|
+00000010  47 e3 9f 11 f9 7e 9a cf  41 db c8 43 ce 86 ae ce  |G....~..A..C....|
+00000020  0c af 17 42 d7 24 57 13  e6 ba a7 44 7c 72 38 aa  |...B.$W....D|r8.|
+00000030  8f fa a2 a2 9f b0 ba 43  47 20 e8 03 3c 00 ee ad  |.......CG ..<...|
+00000040  17 03 03 00 17 ff 5b 79  f8 c8 0c 7a 52 6d b0 b2  |......[y...zRm..|
+00000050  22 17 3b 5d f9 75 23 bb  27 38 35 a6 17 03 03 00  |".;].u#.'85.....|
+00000060  13 d3 94 d9 b5 8b fa dc  b6 fe 26 ca b0 52 5c ef  |..........&..R\.|
+00000070  84 e3 3c f9                                       |..<.|
diff --git a/src/crypto/tls/testdata/Client-TLSv13-HelloRetryRequest b/src/crypto/tls/testdata/Client-TLSv13-HelloRetryRequest
index 10e13ec33d..48403391bb 100644
--- a/src/crypto/tls/testdata/Client-TLSv13-HelloRetryRequest
+++ b/src/crypto/tls/testdata/Client-TLSv13-HelloRetryRequest
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 77 00 05 00 05  01 00 00 00 00 00 0a 00  |...w............|
 00000090  06 00 04 00 1d 00 17 00  0b 00 02 01 00 00 0d 00  |................|
 000000a0  1a 00 18 08 04 04 03 08  07 08 05 08 06 04 01 05  |................|
@@ -20,7 +20,7 @@
 00000010  9a 61 11 be 1d 8c 02 1e  65 b8 91 c2 a2 11 16 7a  |.a......e......z|
 00000020  bb 8c 5e 07 9e 09 e2 c8  a8 33 9c 20 00 00 00 00  |..^......3. ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 01 00 00  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 03 00 00  |................|
 00000050  0c 00 2b 00 02 03 04 00  33 00 02 00 17 14 03 03  |..+.....3.......|
 00000060  00 01 01                                          |...|
 >>> Flow 3 (client to server)
@@ -29,10 +29,10 @@
 00000020  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000030  00 20 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |. ..............|
 00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000050  00 00 00 32 cc a8 cc a9  c0 2f c0 2b c0 30 c0 2c  |...2...../.+.0.,|
-00000060  c0 27 c0 13 c0 23 c0 09  c0 14 c0 0a 00 9c 00 9d  |.'...#..........|
-00000070  00 3c 00 2f 00 35 c0 12  00 0a 00 05 c0 11 c0 07  |.<./.5..........|
-00000080  13 01 13 03 13 02 01 00  00 98 00 05 00 05 01 00  |................|
+00000050  00 00 00 32 cc a9 cc a8  c0 2b c0 2f c0 2c c0 30  |...2.....+./.,.0|
+00000060  c0 09 c0 13 c0 0a c0 14  00 9c 00 9d 00 2f 00 35  |............./.5|
+00000070  c0 12 00 0a c0 23 c0 27  00 3c c0 07 c0 11 00 05  |.....#.'.<......|
+00000080  13 03 13 01 13 02 01 00  00 98 00 05 00 05 01 00  |................|
 00000090  00 00 00 00 0a 00 06 00  04 00 1d 00 17 00 0b 00  |................|
 000000a0  02 01 00 00 0d 00 1a 00  18 08 04 04 03 08 07 08  |................|
 000000b0  05 08 06 04 01 05 01 06  01 05 03 06 03 02 01 02  |................|
@@ -44,76 +44,76 @@
 00000110  32 42 e9 58 b6 d7 49 a6  b5 68 1a 41 03 56 6b dc  |2B.X..I..h.A.Vk.|
 00000120  5a 89                                             |Z.|
 >>> Flow 4 (server to client)
-00000000  16 03 03 00 9b 02 00 00  97 03 03 b5 7c 4a c4 82  |............|J..|
-00000010  67 2c 0d e4 cf 12 5a 8c  fc 44 10 da 7e ef ec ae  |g,....Z..D..~...|
-00000020  bc 59 6c 7d 62 b1 d8 95  5d 9d 3b 20 00 00 00 00  |.Yl}b...].; ....|
+00000000  16 03 03 00 9b 02 00 00  97 03 03 1d 65 62 8f 58  |............eb.X|
+00000010  2b 99 04 1d fd cc e3 0b  46 5c 55 a9 3a 80 76 60  |+.......F\U.:.v`|
+00000020  8f 52 09 6e 48 5d 5a e3  92 da a3 20 00 00 00 00  |.R.nH]Z.... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 01 00 00  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 03 00 00  |................|
 00000050  4f 00 2b 00 02 03 04 00  33 00 45 00 17 00 41 04  |O.+.....3.E...A.|
-00000060  51 c8 a4 d2 63 ec a1 b7  72 7e 42 30 8e d2 eb b0  |Q...c...r~B0....|
-00000070  3c e0 06 d0 69 39 b7 55  ee 47 c3 b3 b6 56 2d df  |<...i9.U.G...V-.|
-00000080  3e 0c 1c 92 cf f6 c4 52  13 90 fa e6 52 13 e6 6d  |>......R....R..m|
-00000090  35 46 de 60 05 a1 85 a9  ec 86 dc da 19 4d 21 67  |5F.`.........M!g|
-000000a0  17 03 03 00 17 d7 59 69  75 49 13 ac 27 ad 1c a9  |......YiuI..'...|
-000000b0  17 68 46 77 a2 22 0a f5  6f ce 70 67 17 03 03 02  |.hFw."..o.pg....|
-000000c0  6d ee 92 51 b3 07 0f 46  be 24 a1 12 02 7e d1 d4  |m..Q...F.$...~..|
-000000d0  b1 2e f5 87 f5 96 ed 00  77 f1 ad 1b 8e cd 1d 01  |........w.......|
-000000e0  41 78 6a ff 68 9f 6d ac  fe 92 8a c5 43 d2 c9 1d  |Axj.h.m.....C...|
-000000f0  a8 d8 0f 00 7e c1 06 a9  16 ba 13 94 e7 d9 cd e1  |....~...........|
-00000100  01 fd 52 12 be b0 04 14  85 d3 06 a2 63 d7 16 7a  |..R.........c..z|
-00000110  06 5f 1f c2 31 ea 27 1a  a5 1d f6 39 d2 b1 99 8c  |._..1.'....9....|
-00000120  e0 71 32 3b ef 4e d3 1c  21 3f 30 59 5b 3e 1f 64  |.q2;.N..!?0Y[>.d|
-00000130  3c 27 35 0f ee f4 75 5c  53 38 f8 43 87 55 88 28  |<'5...u\S8.C.U.(|
-00000140  17 8f 4c 2d 73 d0 bd db  43 25 2f da fb f3 f7 b4  |..L-s...C%/.....|
-00000150  63 90 08 24 c6 b3 ae 91  00 2d 4f bd af bc 22 82  |c..$.....-O...".|
-00000160  08 ef 29 c9 49 d2 73 97  ce 6c 8d 1e a2 cb 53 ff  |..).I.s..l....S.|
-00000170  fe 9c b1 14 58 6f 45 bf  ee 93 c0 9b 96 86 54 1a  |....XoE.......T.|
-00000180  fc fe 84 c3 88 13 92 d4  d7 de 00 07 d4 f7 ef 8e  |................|
-00000190  5e 5f b0 12 c9 6a 81 df  05 e6 c3 a1 f6 8a bc 06  |^_...j..........|
-000001a0  bc 45 47 06 d4 45 70 78  f9 16 0f d2 f4 ae b5 94  |.EG..Epx........|
-000001b0  e6 ac b5 bf e3 40 d1 fe  20 07 23 f8 65 fe 57 b2  |.....@.. .#.e.W.|
-000001c0  63 a0 db 7b fa 12 25 2b  1f 1c df 66 ee c4 84 80  |c..{..%+...f....|
-000001d0  4a 95 64 3d 9f c2 e9 eb  7c 59 72 1c 52 68 fa 5a  |J.d=....|Yr.Rh.Z|
-000001e0  b3 d6 9e dc 51 d6 ac 0b  34 f1 66 42 4b 99 1d cb  |....Q...4.fBK...|
-000001f0  94 f4 08 c6 57 f9 97 87  54 9c 3b ba 4e 21 c7 b3  |....W...T.;.N!..|
-00000200  a0 d9 41 33 22 c4 3f a4  29 e4 7a 3c a1 86 e0 65  |..A3".?.).z<...e|
-00000210  f4 ff 67 c5 32 ae 16 01  67 8e 16 d7 28 5e b3 19  |..g.2...g...(^..|
-00000220  c6 18 c7 27 0d 01 8e 04  87 fb 6b f9 72 ee 00 ff  |...'......k.r...|
-00000230  25 f9 c5 dd bc 30 45 63  2d 4d 2d 9d ea 7f 54 aa  |%....0Ec-M-...T.|
-00000240  ac 9e d8 a2 ae c2 e3 64  b7 3d 54 56 67 39 e8 96  |.......d.=TVg9..|
-00000250  a5 5d fd 1e 01 2a 0c 7d  ee f1 4e fc 1b 19 f9 ef  |.]...*.}..N.....|
-00000260  60 dd e1 b2 94 f3 5f 54  d4 05 f7 86 83 6f 97 43  |`....._T.....o.C|
-00000270  4e 30 c1 49 cc 5e 98 10  5c 4e 32 84 97 70 c8 b9  |N0.I.^..\N2..p..|
-00000280  6d 0b c2 23 ab f9 e8 85  6f 0a 2a 99 e7 12 33 e8  |m..#....o.*...3.|
-00000290  f2 62 6f 65 0c 3d ff 9f  e6 15 eb 1d 24 0e e9 8a  |.boe.=......$...|
-000002a0  28 e0 09 31 23 a4 5c 2c  25 49 b4 0c 5f 18 e1 12  |(..1#.\,%I.._...|
-000002b0  82 16 6e 79 68 21 fb 5a  68 73 dd f7 2f aa e2 f9  |..nyh!.Zhs../...|
-000002c0  85 8d af c6 84 50 af 84  95 12 c8 32 a6 eb f0 93  |.....P.....2....|
-000002d0  a2 bd 97 d3 ba 76 a8 2e  a2 44 2f 98 23 ca 78 cd  |.....v...D/.#.x.|
-000002e0  7a 5f bf ab 19 00 72 b5  b3 e0 a7 b5 da 47 05 c8  |z_....r......G..|
-000002f0  44 0b 6c 7f 0b 4c 99 79  3c 47 7e e9 25 bd a8 4d  |D.l..L.y<G~.%..M|
-00000300  7a 1c 17 aa 00 dc f8 d8  98 5b 8e e4 30 9f 52 9e  |z........[..0.R.|
-00000310  d3 13 ea 82 65 8b 43 1f  05 f9 3a 86 09 e0 ed b9  |....e.C...:.....|
-00000320  8d 42 75 c7 dd 70 5d 04  c5 a4 68 04 e1 36 17 03  |.Bu..p]...h..6..|
-00000330  03 00 99 52 81 9b 5c ed  c2 08 48 13 d9 4f 0a 52  |...R..\...H..O.R|
-00000340  db 15 fc 73 66 03 85 10  b3 32 f3 e9 60 f1 c5 30  |...sf....2..`..0|
-00000350  e4 85 d8 ab 85 c7 52 f0  1e 99 88 cf b0 e1 f9 c7  |......R.........|
-00000360  c1 8a d0 ed 0f 0d 34 05  35 63 a6 52 bf 91 db f0  |......4.5c.R....|
-00000370  b2 46 fb d9 68 95 ec a7  e4 fc ff f7 f0 7f 54 db  |.F..h.........T.|
-00000380  a8 96 fe 9d 12 f0 38 3e  4f 68 ff 27 1c 25 a6 1d  |......8>Oh.'.%..|
-00000390  1f 89 9e 21 34 97 b9 7e  6e 2a c2 df 47 22 7d a6  |...!4..~n*..G"}.|
-000003a0  aa 7a 4a fd 11 b0 73 10  f5 16 8b 2c 3a af a6 7a  |.zJ...s....,:..z|
-000003b0  cc 3d 4b f0 36 43 60 db  53 2a 4e 2c 1b 2c 0a 54  |.=K.6C`.S*N,.,.T|
-000003c0  01 ff ad 7e 93 a8 d0 76  da 5a 88 88 17 03 03 00  |...~...v.Z......|
-000003d0  35 d0 36 70 7c 4c 6a 10  bd 43 50 2c 47 74 f9 ed  |5.6p|Lj..CP,Gt..|
-000003e0  9f 0b d7 33 82 74 2f fd  81 4d 08 d6 cf f4 13 4e  |...3.t/..M.....N|
-000003f0  de ec 84 bf 79 35 ee 72  8a a3 d0 61 29 94 ad 79  |....y5.r...a)..y|
-00000400  04 42 0f 2b 65 a1                                 |.B.+e.|
+00000060  1c 01 c6 9e c8 49 43 49  6f 0f 17 f3 ce 87 1a 0f  |.....ICIo.......|
+00000070  1f 2c 70 18 e4 29 f2 16  a2 e0 02 b7 9d 52 bc b9  |.,p..).......R..|
+00000080  d4 b0 1d 19 da 3a 38 f6  93 04 0b ae 5f 60 45 87  |.....:8....._`E.|
+00000090  57 80 20 27 c6 9c d4 eb  ec c0 85 df f5 aa be de  |W. '............|
+000000a0  17 03 03 00 17 d4 a9 5f  09 d3 e6 47 ad a7 7b 38  |......._...G..{8|
+000000b0  a3 b8 02 37 16 ec 03 56  df d5 8d ec 17 03 03 02  |...7...V........|
+000000c0  6d be 1b 2a 60 52 3c 01  2e 6e 7f e3 68 fa de 09  |m..*`R<..n..h...|
+000000d0  ed 5e 8f 0f a0 34 d5 0a  8b 2f 30 8f 6c 56 9e fe  |.^...4.../0.lV..|
+000000e0  e6 9a a9 f1 6e 7c 63 a7  d8 88 e2 95 fa 17 ad 0c  |....n|c.........|
+000000f0  49 20 93 18 3c ba db fc  a1 14 60 2c 77 d4 44 5f  |I ..<.....`,w.D_|
+00000100  69 9c c7 a3 b9 d0 ee e8  c5 ec 45 d3 79 d0 ee 04  |i.........E.y...|
+00000110  fd c3 6d 12 1a f2 6e 62  9f eb ff 32 88 17 4c df  |..m...nb...2..L.|
+00000120  20 4f cc f9 fd d5 7c 8b  8c c2 da 7d 8a c9 f9 27  | O....|....}...'|
+00000130  32 06 75 fe 75 e2 bb bd  6c 31 5d 32 af 36 95 39  |2.u.u...l1]2.6.9|
+00000140  92 6c 32 e5 4f b5 f7 07  9f b3 1b b8 10 a8 d9 db  |.l2.O...........|
+00000150  d3 b0 40 2f 1e e6 54 f5  35 73 7d 22 b3 6b b8 3c  |..@/..T.5s}".k.<|
+00000160  83 82 8a 75 f4 ec 18 94  57 0c de 98 41 73 61 63  |...u....W...Asac|
+00000170  5b 95 3e 4e d4 02 c3 b7  f9 4c 6f 01 c9 52 3c b9  |[.>N.....Lo..R<.|
+00000180  ad 61 83 2c 89 6d 63 40  fd d4 67 83 36 8b 9a 1c  |.a.,.mc@..g.6...|
+00000190  ca 93 16 d8 e3 91 08 d1  3f ba af cb d9 69 09 10  |........?....i..|
+000001a0  07 a7 54 9c ee a2 7d 97  ce b6 1f 31 9b 85 b0 82  |..T...}....1....|
+000001b0  fc 22 87 70 93 59 9c c9  e3 07 9b d0 c0 a4 1d d4  |.".p.Y..........|
+000001c0  2e 36 c0 72 b6 d5 2a f5  b3 fa ab fb 1a 90 05 51  |.6.r..*........Q|
+000001d0  b7 19 15 af d9 b2 5f 32  ef e6 5a 2d 4a 2c 7f a9  |......_2..Z-J,..|
+000001e0  43 cf b8 ac e4 8a f0 bf  68 90 b9 7c 1c 7e fa f0  |C.......h..|.~..|
+000001f0  bc e3 a9 4f a7 2d 3a f3  12 eb b1 93 b4 b9 1b d7  |...O.-:.........|
+00000200  81 31 db 58 c4 8e 9f 46  44 39 74 a1 a8 b0 78 0c  |.1.X...FD9t...x.|
+00000210  b9 23 6d 90 bb a8 b0 7c  e2 a3 a3 c4 e6 83 32 5d  |.#m....|......2]|
+00000220  ea 5a a4 3d 94 ca 51 3c  71 28 cf 43 27 9f 66 9b  |.Z.=..Q<q(.C'.f.|
+00000230  ec 49 0f a4 12 f5 a3 96  cd 3e 05 5b 9c d0 07 6f  |.I.......>.[...o|
+00000240  8a 11 df 2f be a7 1d 0d  9f a8 04 41 3d 5e 1b f6  |.../.......A=^..|
+00000250  b0 10 9b 6a 49 da 6c f9  6c 6e 2e 6c 9b cf f1 fe  |...jI.l.ln.l....|
+00000260  49 92 2b 16 3f 63 ef 87  71 9c da 0d 49 63 2a 4c  |I.+.?c..q...Ic*L|
+00000270  b5 82 c8 b0 75 5b 7b 89  39 cd 9a da dc 42 d1 1f  |....u[{.9....B..|
+00000280  92 61 e1 71 b9 b5 d2 40  3c 7a 4a 8d 91 1f e6 9d  |.a.q...@<zJ.....|
+00000290  79 37 71 3c dc a3 98 0b  b3 64 39 74 f1 8f 84 35  |y7q<.....d9t...5|
+000002a0  1d 6b b7 0a f9 aa 26 55  a8 39 7f 11 26 18 98 fe  |.k....&U.9..&...|
+000002b0  94 fb 5d e4 a1 2f 0f 3b  f0 b6 78 d5 87 32 73 6e  |..]../.;..x..2sn|
+000002c0  3e b1 3e 3c 19 31 7a ae  d8 73 67 96 56 9c 38 a6  |>.><.1z..sg.V.8.|
+000002d0  bc 39 1f 11 74 ad 69 c6  d2 40 0f 65 d8 ee aa 87  |.9..t.i..@.e....|
+000002e0  b3 4c 6c 1a 1d 62 4a 7a  d9 15 05 54 0d 8a 22 68  |.Ll..bJz...T.."h|
+000002f0  8e 41 22 b0 ee 41 b3 94  5d 1a 62 d8 bb ac f2 87  |.A"..A..].b.....|
+00000300  ad 91 19 e7 e1 bc 29 3b  96 8c d1 76 99 e5 82 48  |......);...v...H|
+00000310  0b 87 6a 93 3b 2c b7 c1  73 07 53 7c 1f 9f 48 dd  |..j.;,..s.S|..H.|
+00000320  71 da 55 e1 4a a3 86 d2  ff 23 b2 1d ea b0 17 03  |q.U.J....#......|
+00000330  03 00 99 75 af 84 36 54  8e 17 09 c7 2e 72 de 7d  |...u..6T.....r.}|
+00000340  29 5c 94 a9 e3 d3 d0 9b  3e a0 84 e6 cf b4 48 d8  |)\......>.....H.|
+00000350  dd 7c 8a 82 96 15 aa cb  95 38 88 9e 48 c4 bf 75  |.|.......8..H..u|
+00000360  9c f4 07 ed 5d 4d 36 8b  58 7f 9c 32 0b f9 d2 44  |....]M6.X..2...D|
+00000370  3d d6 ab 3b 3d 38 1f 8d  7e e8 b6 26 57 c9 c6 98  |=..;=8..~..&W...|
+00000380  49 4f 1e ad 5d fa 8b ca  bc ce 99 f2 d9 5b 14 54  |IO..]........[.T|
+00000390  56 0c 59 c8 22 9f 77 f1  db 92 43 c3 dd a5 29 ec  |V.Y.".w...C...).|
+000003a0  0d 79 0d b3 04 3f 4b 6b  d6 a8 da 99 64 94 78 a5  |.y...?Kk....d.x.|
+000003b0  e9 cd 7e f8 0c fb 72 d6  03 89 dd 00 13 f3 14 18  |..~...r.........|
+000003c0  ba 59 3c 04 7f 6a b5 62  37 56 2e 2d 17 03 03 00  |.Y<..j.b7V.-....|
+000003d0  35 af eb 05 4e ec ee 4b  d6 6b 03 35 d8 ba a3 cf  |5...N..K.k.5....|
+000003e0  50 c6 80 07 90 92 1c ed  1f d2 d5 12 e3 7f 74 1a  |P.............t.|
+000003f0  2c 3b 4b 6c f4 58 af 9a  1a cd 90 f4 d8 78 97 09  |,;Kl.X.......x..|
+00000400  2f f6 35 c1 29 b8                                 |/.5.).|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 35 4b f7 dd  b6 64 32 61 42 e7 b2 93  |....5K...d2aB...|
-00000010  b8 4b dd 7c 25 c6 57 5b  68 d5 f2 d9 27 85 ee cf  |.K.|%.W[h...'...|
-00000020  09 44 79 8d 8e 14 0f 84  44 e5 16 a9 bf d9 14 bb  |.Dy.....D.......|
-00000030  22 73 c7 a9 24 c1 dd 38  1e 63 17 03 03 00 17 63  |"s..$..8.c.....c|
-00000040  56 45 91 62 9c 00 4b d6  ae f4 dc 17 a2 89 55 0d  |VE.b..K.......U.|
-00000050  c3 d4 f3 12 8b bf 17 03  03 00 13 1f ac ed f8 80  |................|
-00000060  31 7f 75 9f 6c a1 48 6e  20 89 b8 45 08 33        |1.u.l.Hn ..E.3|
+00000000  17 03 03 00 35 8d 07 5a  33 f5 d1 e7 6d 71 48 45  |....5..Z3...mqHE|
+00000010  3e 2a c0 7e 66 03 77 b5  69 b1 e5 13 04 0e 0d ea  |>*.~f.w.i.......|
+00000020  6f 80 46 a1 9a 54 09 6f  a7 be b7 a3 a1 0c d4 ba  |o.F..T.o........|
+00000030  0e 7d 00 8f 1b 01 0b d4  6b 4c 17 03 03 00 17 b9  |.}......kL......|
+00000040  fd 5a 5c a1 c2 33 71 63  99 25 bd 03 a3 24 a7 b6  |.Z\..3qc.%...$..|
+00000050  e7 42 04 6a 81 c5 17 03  03 00 13 b6 4a f1 0a 26  |.B.j........J..&|
+00000060  95 e8 fb 4b d1 db 24 95  8f 65 1f 3c 5d b9        |...K..$..e.<].|
diff --git a/src/crypto/tls/testdata/Client-TLSv13-KeyUpdate b/src/crypto/tls/testdata/Client-TLSv13-KeyUpdate
index d1efba928c..ea10f66ff0 100644
--- a/src/crypto/tls/testdata/Client-TLSv13-KeyUpdate
+++ b/src/crypto/tls/testdata/Client-TLSv13-KeyUpdate
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 7b 00 05 00 05  01 00 00 00 00 00 0a 00  |...{............|
 00000090  0a 00 08 00 1d 00 17 00  18 00 19 00 0b 00 02 01  |................|
 000000a0  00 00 0d 00 1a 00 18 08  04 04 03 08 07 08 05 08  |................|
@@ -16,87 +16,87 @@
 000000e0  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
 000000f0  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74     |.........._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 7a 02 00 00  76 03 03 a2 49 b5 61 fe  |....z...v...I.a.|
-00000010  e3 52 ca 87 58 57 0f ec  bc 71 51 a9 50 7c ac 5e  |.R..XW...qQ.P|.^|
-00000020  af 4e 47 56 81 6c 92 d9  10 3d d0 20 00 00 00 00  |.NGV.l...=. ....|
+00000000  16 03 03 00 7a 02 00 00  76 03 03 86 ed 46 3d 38  |....z...v....F=8|
+00000010  c5 47 10 b5 4e ac e5 b7  d7 ba cc 23 db f5 0a f4  |.G..N......#....|
+00000020  5e d3 62 af 47 8a 23 34  59 5c db 20 00 00 00 00  |^.b.G.#4Y\. ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 01 00 00  |................|
-00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 75  |..+.....3.$... u|
-00000060  c4 ba b0 c4 9b a0 57 6a  ca e4 9c c6 eb f8 66 5a  |......Wj......fZ|
-00000070  d4 64 36 34 71 9d 6d 0f  2f 34 b8 ad b7 4a 55 14  |.d64q.m./4...JU.|
-00000080  03 03 00 01 01 17 03 03  00 17 ec 4c 36 aa 81 cf  |...........L6...|
-00000090  61 2c 2f 6c 35 e8 25 62  54 17 ae 9b 46 b0 96 f5  |a,/l5.%bT...F...|
-000000a0  0f 17 03 03 02 6d 6f 6c  27 e5 53 42 db 32 b4 2c  |.....mol'.SB.2.,|
-000000b0  6a 70 56 a7 0d 3a 7f a3  d7 fe 04 4f 0a 3e 52 8c  |jpV..:.....O.>R.|
-000000c0  52 1e 3a 26 5d 47 b1 6b  da 90 e2 74 50 0d 6e fa  |R.:&]G.k...tP.n.|
-000000d0  1b 3f 17 3b 21 f7 fa f7  c7 c3 e3 14 05 09 76 b2  |.?.;!.........v.|
-000000e0  27 66 bc 42 7e 49 4b ff  3a f1 3f a3 1a d4 9e 03  |'f.B~IK.:.?.....|
-000000f0  3f b6 a8 87 98 50 f3 d8  cb 8b a2 e9 2a ea ff bc  |?....P......*...|
-00000100  50 18 d0 57 58 c5 e9 c8  96 67 01 8b e2 a3 f4 77  |P..WX....g.....w|
-00000110  5e 1d 93 89 b6 f6 57 7d  93 b6 62 86 0a 21 18 56  |^.....W}..b..!.V|
-00000120  8c 14 25 df 47 1a b3 23  e6 99 d1 fc dc 07 0a 38  |..%.G..#.......8|
-00000130  9a 05 c8 3f 23 5c c5 d3  c4 48 fb b2 fd 9f 83 37  |...?#\...H.....7|
-00000140  1d 0c 85 9c 2b e6 ae 42  aa ad d4 5a 9e 49 89 b7  |....+..B...Z.I..|
-00000150  b0 c2 c5 ec 42 89 88 87  6e 54 3d 73 b2 f1 5f 0f  |....B...nT=s.._.|
-00000160  4b 49 3f 6b a3 8f 5f 99  bf fe af e9 25 ac 27 b7  |KI?k.._.....%.'.|
-00000170  e7 96 bb 4a c8 e8 9e f1  2c 23 c2 e7 96 ba b4 fe  |...J....,#......|
-00000180  d5 94 b5 72 82 bd 7f c2  e1 af b4 bd db c7 15 20  |...r........... |
-00000190  85 60 bb 02 f6 4b ef 09  3e a1 4e b9 77 64 0a 4a  |.`...K..>.N.wd.J|
-000001a0  2c 05 82 96 91 be 23 44  50 c1 c5 6c 05 55 51 42  |,.....#DP..l.UQB|
-000001b0  84 87 20 71 65 8d 09 86  66 fa 88 8b 54 21 44 34  |.. qe...f...T!D4|
-000001c0  df 6f ce a3 e9 12 4a e0  90 76 bb 1a f5 00 79 cb  |.o....J..v....y.|
-000001d0  d8 82 3b 88 c8 6a 5b a1  49 49 a0 c0 f7 d9 8f 89  |..;..j[.II......|
-000001e0  f2 04 59 2b 0c 6f e2 3f  b8 a8 c9 aa bf 2e 18 74  |..Y+.o.?.......t|
-000001f0  45 b5 35 34 9a bb fa 77  e8 46 b2 f8 6d 41 65 36  |E.54...w.F..mAe6|
-00000200  d9 f8 64 81 a6 50 63 b4  73 3e fb f9 b3 3e 03 3d  |..d..Pc.s>...>.=|
-00000210  d1 f4 b5 c1 ac f8 3f 4d  73 b7 da 16 8a 37 c9 a7  |......?Ms....7..|
-00000220  51 33 b1 68 69 19 0b 26  de a6 42 4d 22 a3 e8 c0  |Q3.hi..&..BM"...|
-00000230  7b 1d 66 e7 70 26 44 f7  62 3f 3d 0d e2 02 50 61  |{.f.p&D.b?=...Pa|
-00000240  db 9b 5e e4 49 e8 32 32  7a c0 03 37 a8 c6 85 80  |..^.I.22z..7....|
-00000250  4a 7e 39 b5 ba 6c cb 6f  53 e5 90 d0 0d 9c 2e e5  |J~9..l.oS.......|
-00000260  90 df 9b b1 c5 3f 16 98  a9 dd a1 b5 7a 48 04 0e  |.....?......zH..|
-00000270  15 f9 60 a7 35 0b 33 a1  93 4b 73 5f b3 46 a6 43  |..`.5.3..Ks_.F.C|
-00000280  ea a3 6e 4c fa bb 24 44  cd 48 85 c1 9f ea c2 14  |..nL..$D.H......|
-00000290  92 48 2e 35 43 30 dc e6  76 23 0b e4 2f 28 13 c1  |.H.5C0..v#../(..|
-000002a0  e1 bb 2d 9f de cf 10 8f  c3 8f 48 eb 64 eb 6d ef  |..-.......H.d.m.|
-000002b0  2a b3 c5 d6 85 db a2 05  b2 46 f8 77 aa 2c fb 14  |*........F.w.,..|
-000002c0  be 09 e7 11 33 88 cb 71  1b ca 46 cb 79 c6 99 eb  |....3..q..F.y...|
-000002d0  43 bb 59 c6 91 3b 0f 1a  76 cb c7 3b ef 07 c9 cb  |C.Y..;..v..;....|
-000002e0  3a 75 ac 14 d9 53 08 ca  4d 45 48 24 4a af 4e 94  |:u...S..MEH$J.N.|
-000002f0  0e 81 31 63 d1 f6 67 25  7d c0 dd 02 05 1b ce 38  |..1c..g%}......8|
-00000300  69 cf e7 6a bb b5 02 85  00 82 71 a6 e3 c0 33 b8  |i..j......q...3.|
-00000310  78 51 55 17 03 03 00 99  b3 5c cb a4 a3 6c e9 fa  |xQU......\...l..|
-00000320  33 25 04 21 28 66 e7 d4  22 02 8f d4 3e cc e1 20  |3%.!(f.."...>.. |
-00000330  15 5b 5a 55 14 d3 2b a5  de 7b 95 48 3c 26 68 22  |.[ZU..+..{.H<&h"|
-00000340  a3 0d c6 ac 7f ec d3 7b  fa 4d 51 20 6f 32 97 bc  |.......{.MQ o2..|
-00000350  fa 0c d6 8e bf ee 13 ca  b3 cf 00 c5 f5 87 f1 cb  |................|
-00000360  9b 63 22 e6 61 99 83 78  69 1d 03 f1 0b 66 c5 c4  |.c".a..xi....f..|
-00000370  2e 6f d8 b5 59 93 f7 40  3c 40 4e 1a 58 af b5 37  |.o..Y..@<@N.X..7|
-00000380  ce dd 83 dd b1 78 a8 ba  a3 35 f8 9f 0c 47 1e fb  |.....x...5...G..|
-00000390  aa 9b b5 5f 11 4c b9 0c  c1 a0 01 47 87 f9 e6 1f  |..._.L.....G....|
-000003a0  d5 e5 3f a7 15 4d c8 a5  79 9c e5 bc 62 6f cb cd  |..?..M..y...bo..|
-000003b0  86 17 03 03 00 35 e7 4d  67 3a 39 5b ac 13 89 cc  |.....5.Mg:9[....|
-000003c0  c4 dc 20 2b a4 b2 3c 5d  96 f1 45 17 52 12 ed 85  |.. +..<]..E.R...|
-000003d0  00 f0 7e 73 3a 6d a2 46  b8 59 7f e8 6f 46 06 e1  |..~s:m.F.Y..oF..|
-000003e0  43 c9 ca af a9 3e ca d6  42 4b 41                 |C....>..BKA|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 03 00 00  |................|
+00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 e3  |..+.....3.$... .|
+00000060  ff 35 33 31 c9 d8 5c 68  2a e5 73 98 4d 11 5b d7  |.531..\h*.s.M.[.|
+00000070  06 18 a9 dd 0e 4a 21 92  5b 15 8f bb 91 a9 6c 14  |.....J!.[.....l.|
+00000080  03 03 00 01 01 17 03 03  00 17 ea ac f8 a0 41 47  |..............AG|
+00000090  af 01 fb 51 2e ec 3b 79  f1 8a 54 2b 93 45 33 c3  |...Q..;y..T+.E3.|
+000000a0  79 17 03 03 02 6d 0e c9  a4 55 8e 8c 09 55 cd a6  |y....m...U...U..|
+000000b0  d4 dc 1e 5a de ee 56 c8  c2 ac 12 77 77 76 82 fc  |...Z..V....wwv..|
+000000c0  a6 44 cb c8 c3 16 c4 5e  bc 3f f3 3b 6c 33 f3 35  |.D.....^.?.;l3.5|
+000000d0  ed bd 8e 37 1a 25 de 7e  b3 88 71 ce f9 e5 9b a6  |...7.%.~..q.....|
+000000e0  99 11 0f 71 6b 36 11 04  66 a2 5f 74 1c c6 6a 99  |...qk6..f._t..j.|
+000000f0  49 84 d1 36 96 df 6d 2c  c5 a3 cf 5a c9 37 22 8a  |I..6..m,...Z.7".|
+00000100  72 e4 d4 25 ed 4a b1 c4  85 5a 9a f7 de 0b dd 41  |r..%.J...Z.....A|
+00000110  7d 14 63 35 2e 1c 77 6c  9e 6f 41 d1 cb 29 ca 6d  |}.c5..wl.oA..).m|
+00000120  88 1c 35 53 1b 14 24 79  84 ec 85 0d de e3 0f 2c  |..5S..$y.......,|
+00000130  23 ae 41 72 85 fb 43 36  82 ba 8f 78 79 a2 c3 95  |#.Ar..C6...xy...|
+00000140  72 19 ea 1d 2f 29 0e d5  11 85 e4 cc 8c a5 f4 8e  |r.../)..........|
+00000150  39 ba 88 8f e1 5a 54 7c  53 8b a3 1a 44 9c ae 5b  |9....ZT|S...D..[|
+00000160  1f 0e ea 06 f1 8e 5f 22  d1 ef ee e1 4c b6 1a 26  |......_"....L..&|
+00000170  db 53 96 e6 bc 0b 2f ee  b7 fa 47 af 1e 9c f6 7b  |.S..../...G....{|
+00000180  81 97 0f c3 08 9b 2c a3  de bd f7 8a 1e 13 ad de  |......,.........|
+00000190  a5 fc 5f c7 7a 53 72 e5  17 dc 0a eb 90 91 29 2e  |.._.zSr.......).|
+000001a0  7a a5 09 fd be 31 ff 81  ec a3 fc 91 41 4f cb c7  |z....1......AO..|
+000001b0  27 c3 39 8f cd 77 62 72  9a e9 e9 16 da 90 b6 6b  |'.9..wbr.......k|
+000001c0  05 70 c8 aa f5 cd 88 13  4d ff a5 a9 0f e7 d2 d3  |.p......M.......|
+000001d0  97 2b eb e1 d7 fe 74 da  fb 1e af 94 e6 52 18 48  |.+....t......R.H|
+000001e0  5b e8 c3 10 9d 76 de 17  86 67 83 4a e9 fa 30 e8  |[....v...g.J..0.|
+000001f0  46 95 f5 81 b1 a5 76 38  57 37 3a 8d df ad e7 30  |F.....v8W7:....0|
+00000200  41 b2 94 31 da 0d d6 5c  df 76 01 cd 4d c2 1b fe  |A..1...\.v..M...|
+00000210  bc 69 41 ac dd d7 dd 0a  7c 5b 31 5c c8 1e b3 14  |.iA.....|[1\....|
+00000220  39 20 51 26 6d e5 55 27  a4 9a bb fc 3d 4b 6a b0  |9 Q&m.U'....=Kj.|
+00000230  54 92 ee 33 1b 9b d5 41  fd ef 21 c6 f0 f8 90 a0  |T..3...A..!.....|
+00000240  c4 f5 86 d4 d9 c7 89 6f  67 23 37 31 44 2f 8f 55  |.......og#71D/.U|
+00000250  0a aa e1 9a ec 32 26 e2  ce 96 90 c6 f5 cc 95 79  |.....2&........y|
+00000260  da 0c b4 c1 62 d3 0a 8d  7b 83 33 8e af ff 57 c0  |....b...{.3...W.|
+00000270  5b ca 0f b5 64 10 81 43  12 86 67 cf b2 0a 53 f2  |[...d..C..g...S.|
+00000280  04 46 4f 99 ee e2 cd ce  3e 82 1f 34 43 26 f9 4c  |.FO.....>..4C&.L|
+00000290  57 b0 10 c0 37 40 9c 4f  fb 14 fa 4e 1e 4b 40 da  |W...7@.O...N.K@.|
+000002a0  cc c3 d0 d7 ee 63 18 2e  97 06 a6 49 69 07 7a 3e  |.....c.....Ii.z>|
+000002b0  da 47 68 70 b0 10 bf 8d  18 d2 14 c0 18 18 b2 61  |.Ghp...........a|
+000002c0  45 54 e8 20 34 f8 a3 74  5a 8d aa c2 63 af e8 ff  |ET. 4..tZ...c...|
+000002d0  f9 1b 33 d6 34 c2 f2 c2  3d d8 0e 32 7a 10 cc 21  |..3.4...=..2z..!|
+000002e0  02 22 a6 aa 7d 15 c3 7b  3f a2 50 5a 4e 53 ec f5  |."..}..{?.PZNS..|
+000002f0  11 dd 48 6e 7e e9 c5 94  2c c4 9a 6e 10 a6 c6 a5  |..Hn~...,..n....|
+00000300  9d e1 c5 43 e6 69 a1 91  65 50 eb e6 76 db f0 09  |...C.i..eP..v...|
+00000310  14 45 ef 17 03 03 00 99  e4 82 99 6b d8 57 ca 1b  |.E.........k.W..|
+00000320  78 98 88 ad c7 04 b7 d2  b2 d5 00 3b a9 bf 86 66  |x..........;...f|
+00000330  a7 30 72 95 29 2a 27 9f  9a 3d bd 0b e6 a0 04 22  |.0r.)*'..=....."|
+00000340  56 3d d8 08 84 a7 e7 c5  67 74 34 7d 57 1f c9 df  |V=......gt4}W...|
+00000350  71 0c 97 55 5a d9 8d 99  df 49 b5 a9 57 6d b0 c7  |q..UZ....I..Wm..|
+00000360  2d 4b 70 9d e7 e3 70 31  f0 2f 32 15 7b 67 b4 4c  |-Kp...p1./2.{g.L|
+00000370  f0 f0 4a 16 a5 37 b2 ae  9b 2a 72 7c 2e d8 22 a1  |..J..7...*r|..".|
+00000380  2b 91 f2 14 fc f9 27 fd  ca ad 27 dd 15 11 df b1  |+.....'...'.....|
+00000390  cc 4c 3a 45 3f b6 7c 53  c5 d0 82 49 1a f2 28 63  |.L:E?.|S...I..(c|
+000003a0  a2 be 6f 2f db d8 d3 76  0a 12 fa 87 14 00 11 e7  |..o/...v........|
+000003b0  1f 17 03 03 00 35 0c af  49 a1 ba 14 d4 e5 5c cf  |.....5..I.....\.|
+000003c0  c8 f7 fb 93 e3 d5 45 ac  59 ed 56 3c 1c e6 53 6a  |......E.Y.V<..Sj|
+000003d0  77 62 a3 1a 8c 55 14 b0  d8 6f dd 1c fb a4 6f 25  |wb...U...o....o%|
+000003e0  18 28 ab 9e a5 ad 6d 97  63 f4 9c                 |.(....m.c..|
 >>> Flow 3 (client to server)
-00000000  14 03 03 00 01 01 17 03  03 00 35 4d ad c5 c7 cc  |..........5M....|
-00000010  5a 34 8a f8 5f 71 83 af  fa 94 df 2a 94 a0 c4 8e  |Z4.._q.....*....|
-00000020  5e 00 f7 02 e1 30 62 a5  49 27 58 0b 1f fa 46 98  |^....0b.I'X...F.|
-00000030  f0 b8 6f 42 e3 3a 7f 26  77 b6 46 8f ab c6 5d d6  |..oB.:.&w.F...].|
-00000040  17 03 03 00 17 90 81 68  7a 48 8d 3b 59 9e 11 6f  |.......hzH.;Y..o|
-00000050  86 b5 24 e4 d9 e0 60 9f  c2 4f 3d 33              |..$...`..O=3|
+00000000  14 03 03 00 01 01 17 03  03 00 35 12 2a a7 31 42  |..........5.*.1B|
+00000010  e9 65 d6 88 9c 49 85 53  16 6c 85 bc d1 70 65 3a  |.e...I.S.l...pe:|
+00000020  aa cd d3 12 ce 69 e3 3a  63 7a 8d ed 54 df 9c 97  |.....i.:cz..T...|
+00000030  4e ef 7c 20 ce 41 ac 33  a9 3b fc 5e 35 34 65 00  |N.| .A.3.;.^54e.|
+00000040  17 03 03 00 17 11 5f 88  3b 45 0e 4e 8a 26 43 a3  |......_.;E.N.&C.|
+00000050  9e 77 10 76 8c e1 ed d3  19 f4 27 5f              |.w.v......'_|
 >>> Flow 4 (server to client)
-00000000  17 03 03 00 16 94 83 fa  cc 66 b4 60 c0 c7 6d b3  |.........f.`..m.|
-00000010  6e 8c 84 9d 89 76 61 3d  69 fd 29                 |n....va=i.)|
+00000000  17 03 03 00 16 7d 92 67  60 95 ba fa a0 5f 03 e9  |.....}.g`...._..|
+00000010  2b e6 53 ed fb 6b 4f b9  e9 09 10                 |+.S..kO....|
 >>> Flow 5 (client to server)
-00000000  17 03 03 00 16 60 cb 39  3d 7d 79 01 88 93 bd bf  |.....`.9=}y.....|
-00000010  23 3b d1 f3 a4 5e 78 ea  cd 0f 5e                 |#;...^x...^|
+00000000  17 03 03 00 16 06 17 fb  4b 33 c7 06 d5 a9 40 e8  |........K3....@.|
+00000010  c7 09 65 b2 5c 2d 45 2f  bf 45 a8                 |..e.\-E/.E.|
 >>> Flow 6 (server to client)
-00000000  17 03 03 00 1a 88 13 b4  f1 5f cc 63 1e 99 9f 85  |........._.c....|
-00000010  60 ff 0e 97 13 59 64 2a  c3 0d 2b ac ca a2 25     |`....Yd*..+...%|
+00000000  17 03 03 00 1a 04 5e c0  bb ad 6c 2f 65 61 5c 39  |......^...l/ea\9|
+00000010  a9 e2 c4 9e 0e 4c 68 d2  a9 97 8a bf 95 39 3f     |.....Lh......9?|
 >>> Flow 7 (client to server)
-00000000  17 03 03 00 1d 4f f2 48  ea b8 d6 75 8e 97 ab 54  |.....O.H...u...T|
-00000010  29 57 50 5b 59 40 59 d3  7a 3c 01 43 6a 33 30 bb  |)WP[Y@Y.z<.Cj30.|
-00000020  d4 40 17 03 03 00 13 18  fc b7 ac eb e7 52 6d f0  |.@...........Rm.|
-00000030  d4 d3 03 c6 5f 4e ea e3  7b 4e                    |...._N..{N|
+00000000  17 03 03 00 1d 1f 74 d0  fb ed fa 59 81 21 7e f0  |......t....Y.!~.|
+00000010  41 c8 6e 6b 9f b6 1a 86  ad 2e ac 9e 3d 3b 66 c9  |A.nk........=;f.|
+00000020  4a 87 17 03 03 00 13 7b  76 c4 85 c1 41 47 6d 35  |J......{v...AGm5|
+00000030  98 86 02 d5 3b e4 6b 4c  3e 7a                    |....;.kL>z|
diff --git a/src/crypto/tls/testdata/Client-TLSv13-P256-ECDHE b/src/crypto/tls/testdata/Client-TLSv13-P256-ECDHE
index e6d81184e1..db87bef8a1 100644
--- a/src/crypto/tls/testdata/Client-TLSv13-P256-ECDHE
+++ b/src/crypto/tls/testdata/Client-TLSv13-P256-ECDHE
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 96 00 05 00 05  01 00 00 00 00 00 0a 00  |................|
 00000090  04 00 02 00 17 00 0b 00  02 01 00 00 0d 00 1a 00  |................|
 000000a0  18 08 04 04 03 08 07 08  05 08 06 04 01 05 01 06  |................|
@@ -18,77 +18,77 @@
 00000100  07 9f 6c 4b 5b 83 56 e2  32 42 e9 58 b6 d7 49 a6  |..lK[.V.2B.X..I.|
 00000110  b5 68 1a 41 03 56 6b dc  5a 89                    |.h.A.Vk.Z.|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 9b 02 00 00  97 03 03 b5 3c c8 fe 64  |............<..d|
-00000010  f6 04 7d 28 a4 25 7c 1b  f5 0b e6 6d 0b f5 2f ec  |..}(.%|....m../.|
-00000020  78 c1 bd 5a cf c8 19 d9  5c 54 72 20 00 00 00 00  |x..Z....\Tr ....|
+00000000  16 03 03 00 9b 02 00 00  97 03 03 bb 03 f1 4e 88  |..............N.|
+00000010  23 9e 85 ee 32 13 db 0d  69 11 48 47 c6 c9 e5 b2  |#...2...i.HG....|
+00000020  25 9d 0c 27 87 05 3f 58  42 60 2d 20 00 00 00 00  |%..'..?XB`- ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 01 00 00  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 03 00 00  |................|
 00000050  4f 00 2b 00 02 03 04 00  33 00 45 00 17 00 41 04  |O.+.....3.E...A.|
-00000060  d7 63 55 0e 0d 7b fb 09  a9 61 92 70 2b 52 9c 38  |.cU..{...a.p+R.8|
-00000070  2d e8 2a 68 27 b7 15 3e  4a 1e 92 c8 08 7b 5c c9  |-.*h'..>J....{\.|
-00000080  8d d4 aa 97 63 42 a5 3e  4b e8 7d 37 98 d9 8c a6  |....cB.>K.}7....|
-00000090  e7 c7 45 9f 73 48 bd c3  14 82 67 5b bb 19 bd a5  |..E.sH....g[....|
-000000a0  14 03 03 00 01 01 17 03  03 00 17 67 d9 cb 2b d1  |...........g..+.|
-000000b0  d2 30 7d b3 3f c1 77 5a  6c 87 41 2c 29 83 36 19  |.0}.?.wZl.A,).6.|
-000000c0  74 38 17 03 03 02 6d ac  0c 4f fe b5 93 6a fa 9f  |t8....m..O...j..|
-000000d0  e9 76 a7 c3 8a bb 4a 64  7a 04 35 58 e6 a2 d8 7a  |.v....Jdz.5X...z|
-000000e0  cf 99 1c 60 13 1a ca c6  e6 10 11 7a f1 f4 be ec  |...`.......z....|
-000000f0  1d 2d db b1 a5 3a dd 7e  10 2b 65 ca 40 b2 5f fc  |.-...:.~.+e.@._.|
-00000100  3f c9 df 7d 26 c1 fc b7  2d 67 a1 2d a2 22 b3 40  |?..}&...-g.-.".@|
-00000110  79 d4 c8 b6 73 f7 93 8a  97 4f b7 ab b6 0c ca 14  |y...s....O......|
-00000120  3c 1e 6c 27 c0 be 01 d7  98 ef 93 78 f5 14 15 21  |<.l'.......x...!|
-00000130  4c f8 8e a6 f7 72 b2 b7  bc c2 3e 9b b7 e4 0d 15  |L....r....>.....|
-00000140  b5 69 75 e9 61 10 e4 d5  8e 60 44 88 bf 5f df f9  |.iu.a....`D.._..|
-00000150  8d 70 54 4e f6 0f 37 70  ff b8 6b c0 4f fb 61 c1  |.pTN..7p..k.O.a.|
-00000160  48 00 96 9b da 05 0f 78  7a 87 f5 b1 69 f6 4f 8e  |H......xz...i.O.|
-00000170  80 74 7b e0 e5 b7 0f ba  7d 9d 4c ff c9 d7 7c b9  |.t{.....}.L...|.|
-00000180  f0 bd dd 34 8e 77 5f 3b  48 10 10 6f ed c7 84 15  |...4.w_;H..o....|
-00000190  7a 0c 26 3e 5d 9d 58 07  02 8c e3 fa f0 6b 86 df  |z.&>].X......k..|
-000001a0  76 af 3c 13 c4 93 28 7a  17 04 98 91 26 72 5f aa  |v.<...(z....&r_.|
-000001b0  cf b2 9e 37 a9 93 12 bd  1d 92 64 b8 82 60 b0 b5  |...7......d..`..|
-000001c0  1d 2c 4e 18 24 11 3b 52  33 05 f0 3b f2 27 ed a6  |.,N.$.;R3..;.'..|
-000001d0  f6 4a 82 b6 df 05 a0 07  a3 9d 73 0a 3c 7f 02 47  |.J........s.<..G|
-000001e0  60 c8 aa 20 b4 9c cd 48  12 a3 82 fe 99 4e 0c bb  |`.. ...H.....N..|
-000001f0  ec 4f 10 75 26 99 a4 ed  5e 4a 34 51 38 88 2c 3c  |.O.u&...^J4Q8.,<|
-00000200  0b 8d f8 65 84 38 47 c8  31 30 82 71 3f 54 e3 3f  |...e.8G.10.q?T.?|
-00000210  f1 e6 2c ef a3 fe 02 34  16 58 21 55 6e 0f 95 d3  |..,....4.X!Un...|
-00000220  3e 18 e5 c4 fa 95 65 07  d8 4b 31 4b fa a7 85 74  |>.....e..K1K...t|
-00000230  6c 1c a3 7c 7b c6 20 e0  1f 28 33 6d 61 93 d0 7d  |l..|{. ..(3ma..}|
-00000240  e7 c4 5c 27 c9 d9 ca f9  fe 21 6f 7f 05 34 37 54  |..\'.....!o..47T|
-00000250  30 59 68 e1 04 36 60 52  d7 fc 4f 8c 67 f6 42 88  |0Yh..6`R..O.g.B.|
-00000260  bc 41 5f 8e 2c 05 dd 6a  b0 49 6c d8 8e 9c 9e 06  |.A_.,..j.Il.....|
-00000270  35 f9 f1 33 f2 54 b0 3f  9e bd 4f c7 48 aa a3 9e  |5..3.T.?..O.H...|
-00000280  fe 69 79 16 e0 5a ca 48  72 fe 52 4a f1 6f f1 e0  |.iy..Z.Hr.RJ.o..|
-00000290  8c fe 16 15 ce c9 87 dc  9b 66 4d 3a bb 05 21 82  |.........fM:..!.|
-000002a0  21 65 cb 7b da 06 1a 0b  53 ee 60 e4 79 0f bc 5d  |!e.{....S.`.y..]|
-000002b0  b6 52 fd 3b 33 28 97 6c  67 d7 ab 3d b0 da bb ac  |.R.;3(.lg..=....|
-000002c0  0d d9 06 81 a3 6c 1f ad  b8 05 20 63 2b c7 cb 4b  |.....l.... c+..K|
-000002d0  e2 96 6e 3d f1 9c 0a 6a  c6 01 3e 3a d0 54 c8 09  |..n=...j..>:.T..|
-000002e0  9b 17 a0 cc d6 d0 82 d1  02 a8 eb 9d 91 7e 30 b9  |.............~0.|
-000002f0  3d 5e 6d 43 fc 50 f8 9f  80 67 7a e3 33 30 cd b7  |=^mC.P...gz.30..|
-00000300  00 b3 bc 17 50 82 6c 80  67 bd c4 12 11 b1 53 22  |....P.l.g.....S"|
-00000310  96 67 07 90 d4 54 5c f1  5d ca cd f8 b5 35 94 e0  |.g...T\.]....5..|
-00000320  21 e6 58 d7 b0 32 ca 24  90 11 30 f5 2b 1d ca 3d  |!.X..2.$..0.+..=|
-00000330  6a 6d 35 fa 17 03 03 00  99 ad ab 79 79 28 a0 a9  |jm5........yy(..|
-00000340  9a cd 6d 8d 8c 92 2e 83  3d d4 be c7 50 61 f5 49  |..m.....=...Pa.I|
-00000350  97 6c ab 92 d4 a7 1a 6f  fc 5b dd 6e 73 0d bd d2  |.l.....o.[.ns...|
-00000360  09 52 9f c9 de bb 8d 09  0a 4f e0 c5 9a 08 79 4c  |.R.......O....yL|
-00000370  fc 01 b3 94 45 f6 1d bd  8d 23 62 14 14 65 4c 2a  |....E....#b..eL*|
-00000380  d9 ad 8f 76 5a 5e 9d da  68 37 c7 b1 54 1e b4 bd  |...vZ^..h7..T...|
-00000390  d3 15 b8 89 94 87 8b 17  17 0f 4c dc db a8 3b 2f  |..........L...;/|
-000003a0  e5 e2 25 d6 ec f6 f4 bb  ab d0 c5 7f 2a cb c6 57  |..%.........*..W|
-000003b0  84 50 3a e7 62 8b 76 ae  6a 06 6b 85 1c 23 f1 d1  |.P:.b.v.j.k..#..|
-000003c0  10 e2 6f 57 8c 20 7d da  2d f8 bc c5 df 4e 7c 22  |..oW. }.-....N|"|
-000003d0  d8 36 17 03 03 00 35 62  fa d4 65 7f 9a 97 5b ec  |.6....5b..e...[.|
-000003e0  25 4a 3a 43 18 08 08 fb  7f 9d 3b 73 64 9e f3 7a  |%J:C......;sd..z|
-000003f0  28 f1 a0 0e 00 7a 51 74  0e 6b 90 c6 39 7a 09 98  |(....zQt.k..9z..|
-00000400  6e d8 63 cc 1f f0 8f bc  37 66 27 a0              |n.c.....7f'.|
+00000060  85 3c 83 1b e5 02 e9 0d  89 cc c0 f7 af 1e ba af  |.<..............|
+00000070  de ad cb 8f 4d 58 04 40  c2 60 e9 41 8b 94 26 76  |....MX.@.`.A..&v|
+00000080  73 64 c3 27 e3 51 9d 5f  21 97 59 a3 02 cc 20 61  |sd.'.Q._!.Y... a|
+00000090  b7 ef cb bb d9 31 b6 b7  b1 77 ea 8d 69 13 13 48  |.....1...w..i..H|
+000000a0  14 03 03 00 01 01 17 03  03 00 17 ab ac 2e 62 de  |..............b.|
+000000b0  b6 f4 c7 35 cf b4 75 fc  a4 a5 2c 40 68 f5 48 80  |...5..u...,@h.H.|
+000000c0  d2 8b 17 03 03 02 6d a9  36 b5 10 78 1f af 79 65  |......m.6..x..ye|
+000000d0  dd ee 36 08 b9 96 e2 bf  09 53 c7 ee 12 19 1b de  |..6......S......|
+000000e0  96 25 cb a7 55 71 28 22  16 3f 4b 3e 15 a2 2e 57  |.%..Uq(".?K>...W|
+000000f0  99 85 28 b2 01 16 3a 75  ff 5e 21 39 6c be fc bd  |..(...:u.^!9l...|
+00000100  24 33 ec c7 50 83 49 91  8a ed 43 38 b5 48 cd 92  |$3..P.I...C8.H..|
+00000110  dd 9a f1 b7 90 61 3b 8f  ff b9 cf 97 3d 8e 23 8e  |.....a;.....=.#.|
+00000120  d1 78 52 b4 ba a1 75 97  32 52 e3 1f c8 43 ca b7  |.xR...u.2R...C..|
+00000130  89 46 e6 30 c2 c5 32 b3  5f a8 ea ea e2 31 d2 41  |.F.0..2._....1.A|
+00000140  23 5e 64 a2 b9 23 27 73  b2 df 77 cd 04 8b dd 37  |#^d..#'s..w....7|
+00000150  a5 77 df 0e 4f 9d 01 22  7b be 7a 0c 18 5c 8b 62  |.w..O.."{.z..\.b|
+00000160  7c 6b 7e a7 54 8c 69 97  50 d7 cf a0 a4 cb 3a 3b  ||k~.T.i.P.....:;|
+00000170  76 7b 0a de 80 d1 40 c3  05 5e b3 4e 71 cd 03 82  |v{....@..^.Nq...|
+00000180  d5 95 d0 38 ab 65 83 24  66 d2 31 2d 9e 58 16 87  |...8.e.$f.1-.X..|
+00000190  b8 ab 4c 4e 75 40 7e 3d  33 2f f4 ed 0b a8 11 1c  |..LNu@~=3/......|
+000001a0  7a a4 b0 e3 6a 73 d0 6e  e6 82 39 c1 cf 57 a4 9a  |z...js.n..9..W..|
+000001b0  8b fc bc 8e e8 6a c3 e1  b0 64 18 55 6d 19 30 25  |.....j...d.Um.0%|
+000001c0  34 f8 b1 ef cf 3c 04 08  69 10 ad 08 67 5b 8d 64  |4....<..i...g[.d|
+000001d0  eb 83 72 39 2e 56 e4 d2  e9 f2 da 40 3e 85 29 ab  |..r9.V.....@>.).|
+000001e0  5b 83 e5 b0 d2 9b eb c3  99 6e 2a f3 78 95 d4 7a  |[........n*.x..z|
+000001f0  7f bf 9c 16 55 77 43 4d  67 f7 4a 6f 40 27 a2 82  |....UwCMg.Jo@'..|
+00000200  b9 86 05 5d 90 e2 52 a2  d4 7c 7b 3e da 30 c1 aa  |...]..R..|{>.0..|
+00000210  30 2e 9a 34 c5 59 dd db  e9 25 67 da 22 47 f2 be  |0..4.Y...%g."G..|
+00000220  cc c8 5a 4e da cf ad 86  8d bd b0 68 26 69 ea 3a  |..ZN.......h&i.:|
+00000230  1c 1e 29 ae e1 09 63 88  f0 81 31 f9 70 a7 92 27  |..)...c...1.p..'|
+00000240  32 9e 3b 6f 09 5e 42 20  53 88 bf 09 8b a8 17 5c  |2.;o.^B S......\|
+00000250  24 7c 18 1f 9c 99 9b db  6d 11 26 8e 92 2c a1 b4  |$|......m.&..,..|
+00000260  5c 9f d9 0a a8 af 25 f7  84 f5 65 d1 b1 6c d8 aa  |\.....%...e..l..|
+00000270  49 c7 a6 13 47 2e 55 f4  2e de 3d 43 c1 15 8d 60  |I...G.U...=C...`|
+00000280  c1 27 59 7e 7b 14 ee 54  09 fc 99 79 c9 bf fb 45  |.'Y~{..T...y...E|
+00000290  2d 32 ed 1a 2c 84 bc f4  a2 b5 5f 4e cf 60 29 91  |-2..,....._N.`).|
+000002a0  90 b6 ab 06 8f 2d 43 a5  a5 54 0d 67 52 c2 1c fb  |.....-C..T.gR...|
+000002b0  f3 41 b7 67 b4 50 05 86  19 75 93 8b 6c c3 bf 08  |.A.g.P...u..l...|
+000002c0  64 f2 df ff 37 6d 2f 1e  3a 28 f4 ba 27 8d 61 d5  |d...7m/.:(..'.a.|
+000002d0  79 70 19 82 99 7a e5 68  f3 c1 23 da 5d e1 98 b2  |yp...z.h..#.]...|
+000002e0  69 ca 42 83 61 29 3f d9  20 51 f2 a9 ea 1c 0b 5a  |i.B.a)?. Q.....Z|
+000002f0  20 b0 af 70 cc c5 ad 72  6b 09 85 56 8a 26 86 cf  | ..p...rk..V.&..|
+00000300  4e 9a 56 97 5d 63 8d 1d  46 04 48 16 c9 1e 91 47  |N.V.]c..F.H....G|
+00000310  74 53 28 51 7e 3c 84 a1  50 d6 f3 ac 31 ce 04 18  |tS(Q~<..P...1...|
+00000320  81 38 0d c5 3d f5 d5 04  2f f0 96 9b 73 49 4c d6  |.8..=.../...sIL.|
+00000330  89 d9 b9 be 17 03 03 00  99 3a 37 ed 2d 98 80 f9  |.........:7.-...|
+00000340  d0 04 14 12 8c 63 45 cc  8d cb 29 5f 0e f0 86 ef  |.....cE...)_....|
+00000350  8d 6c d6 0f ef 66 99 91  e8 8c d7 7b 21 07 7e 96  |.l...f.....{!.~.|
+00000360  84 f8 f9 5b 1b 39 8b 4f  16 ec 5c 69 7b 18 09 5d  |...[.9.O..\i{..]|
+00000370  95 f1 f3 73 4b 8f 84 66  ee 61 85 dd fe ea 36 df  |...sK..f.a....6.|
+00000380  e5 2a 71 ec 2d 7e 47 1c  b7 79 2d 87 f8 dc 44 27  |.*q.-~G..y-...D'|
+00000390  8a f1 13 6e df ca 59 79  9b 18 01 7e 31 bd 44 f7  |...n..Yy...~1.D.|
+000003a0  8d ad 1c 97 e7 e1 b9 a6  17 d1 25 d1 b8 0d 04 bb  |..........%.....|
+000003b0  21 a4 08 db a2 08 87 5c  04 9a 11 fa c6 24 db 20  |!......\.....$. |
+000003c0  42 79 9c 97 dd 6c d2 e7  24 b4 79 47 be f3 43 87  |By...l..$.yG..C.|
+000003d0  0f 95 17 03 03 00 35 9e  7d 12 0e d6 0a e6 af a3  |......5.}.......|
+000003e0  83 dd eb 08 73 2d 43 7e  81 85 51 4c d1 ad d0 77  |....s-C~..QL...w|
+000003f0  8d 28 62 44 41 9c b0 e9  93 d7 3d 07 e4 e1 6e 4c  |.(bDA.....=...nL|
+00000400  a8 5b 4a 3f 58 3f 97 07  73 d7 5a 62              |.[J?X?..s.Zb|
 >>> Flow 3 (client to server)
-00000000  14 03 03 00 01 01 17 03  03 00 35 ba 59 57 3e a3  |..........5.YW>.|
-00000010  cd 02 7f 7c c2 16 f5 6b  ec 42 66 aa a2 7a 3d 47  |...|...k.Bf..z=G|
-00000020  43 c9 02 4b a3 72 d0 4d  fa f8 32 28 1a 19 16 6a  |C..K.r.M..2(...j|
-00000030  7c 0e 4a 75 80 94 34 fe  30 7b d0 52 15 48 10 30  ||.Ju..4.0{.R.H.0|
-00000040  17 03 03 00 17 5d de 53  df 00 21 ca 6d 69 ff 45  |.....].S..!.mi.E|
-00000050  2e 53 57 db 3f 8d d8 6c  5a e1 f8 cc 17 03 03 00  |.SW.?..lZ.......|
-00000060  13 43 d9 94 95 41 af 1d  80 a7 f2 28 2a 44 50 8d  |.C...A.....(*DP.|
-00000070  41 8f 82 09                                       |A...|
+00000000  14 03 03 00 01 01 17 03  03 00 35 df 31 1a 84 e2  |..........5.1...|
+00000010  93 54 01 f2 d1 e8 32 6c  32 91 e5 64 86 68 ad 5f  |.T....2l2..d.h._|
+00000020  aa 24 54 86 b2 39 92 24  06 65 5c 06 67 43 7d 09  |.$T..9.$.e\.gC}.|
+00000030  79 78 c6 f3 cf 6c a9 ec  38 e3 ec 81 c4 9b c5 33  |yx...l..8......3|
+00000040  17 03 03 00 17 25 ed 98  67 8f ad e8 60 ce 5b ad  |.....%..g...`.[.|
+00000050  ab 3e 67 64 e3 8d bf 98  96 a2 3d 99 17 03 03 00  |.>gd......=.....|
+00000060  13 9d 28 f2 24 fe d6 11  b0 64 d6 8a 8d c1 81 e0  |..(.$....d......|
+00000070  17 d5 a0 f3                                       |....|
diff --git a/src/crypto/tls/testdata/Client-TLSv13-X25519-ECDHE b/src/crypto/tls/testdata/Client-TLSv13-X25519-ECDHE
index 4e3eb760e6..4a43382da5 100644
--- a/src/crypto/tls/testdata/Client-TLSv13-X25519-ECDHE
+++ b/src/crypto/tls/testdata/Client-TLSv13-X25519-ECDHE
@@ -3,10 +3,10 @@
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 00000020  00 00 00 00 00 00 00 00  00 00 00 20 00 00 00 00  |........... ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a8  |.............2..|
-00000050  cc a9 c0 2f c0 2b c0 30  c0 2c c0 27 c0 13 c0 23  |.../.+.0.,.'...#|
-00000060  c0 09 c0 14 c0 0a 00 9c  00 9d 00 3c 00 2f 00 35  |...........<./.5|
-00000070  c0 12 00 0a 00 05 c0 11  c0 07 13 01 13 03 13 02  |................|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 32 cc a9  |.............2..|
+00000050  cc a8 c0 2b c0 2f c0 2c  c0 30 c0 09 c0 13 c0 0a  |...+./.,.0......|
+00000060  c0 14 00 9c 00 9d 00 2f  00 35 c0 12 00 0a c0 23  |......./.5.....#|
+00000070  c0 27 00 3c c0 07 c0 11  00 05 13 03 13 01 13 02  |.'.<............|
 00000080  01 00 00 75 00 05 00 05  01 00 00 00 00 00 0a 00  |...u............|
 00000090  04 00 02 00 1d 00 0b 00  02 01 00 00 0d 00 1a 00  |................|
 000000a0  18 08 04 04 03 08 07 08  05 08 06 04 01 05 01 06  |................|
@@ -16,75 +16,75 @@
 000000e0  43 15 28 da ac 5f bb 29  07 30 ff f6 84 af c4 cf  |C.(.._.).0......|
 000000f0  c2 ed 90 99 5f 58 cb 3b  74                       |...._X.;t|
 >>> Flow 2 (server to client)
-00000000  16 03 03 00 7a 02 00 00  76 03 03 5d 2e e6 ba 34  |....z...v..]...4|
-00000010  6c 42 bb 48 58 fe c5 f0  95 f9 34 11 04 b5 2a f4  |lB.HX.....4...*.|
-00000020  f1 16 41 db 14 a0 19 d8  43 7c 09 20 00 00 00 00  |..A.....C|. ....|
+00000000  16 03 03 00 7a 02 00 00  76 03 03 eb 1b 4e e5 65  |....z...v....N.e|
+00000010  54 ab 07 68 1c d9 32 0f  0e c2 ae a3 2a 89 37 50  |T..h..2.....*.7P|
+00000020  23 51 61 7d 68 60 34 0d  40 2f b8 20 00 00 00 00  |#Qa}h`4.@/. ....|
 00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 01 00 00  |................|
-00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 82  |..+.....3.$... .|
-00000060  de 1b d1 83 7a e1 46 cc  c7 36 15 62 48 07 6b f6  |....z.F..6.bH.k.|
-00000070  eb 0a 53 a3 34 cd 34 ee  cc 0c d0 c9 02 d5 38 14  |..S.4.4.......8.|
-00000080  03 03 00 01 01 17 03 03  00 17 3d 0c 61 12 1b 55  |..........=.a..U|
-00000090  6e f4 13 59 c8 4a e7 12  63 5d bf be 34 9f d7 2a  |n..Y.J..c]..4..*|
-000000a0  c2 17 03 03 02 6d 82 e8  43 93 e4 80 4d a7 d2 cf  |.....m..C...M...|
-000000b0  43 9d 71 8d cc 78 e8 e9  58 7e 28 53 57 6d 95 1e  |C.q..x..X~(SWm..|
-000000c0  fb 98 05 ec 66 47 d9 a1  6a b5 f4 28 09 4a 6c 4c  |....fG..j..(.JlL|
-000000d0  ee a0 1a 86 e7 29 c0 0e  d8 e0 ca 2d bb 50 e4 34  |.....).....-.P.4|
-000000e0  8d 66 be 54 b5 df 94 fc  69 0e a6 9a 76 8b 8f f5  |.f.T....i...v...|
-000000f0  a9 01 1a 1d 8d b0 ae a9  0c 10 58 13 f9 91 80 43  |..........X....C|
-00000100  69 f8 3f 03 14 8e 73 1a  ce 52 72 86 3d 60 8b 0f  |i.?...s..Rr.=`..|
-00000110  38 e7 4b 43 f0 b3 4b 12  3a a7 cd 4b ac ef 7d fb  |8.KC..K.:..K..}.|
-00000120  27 3a 38 36 ad a5 90 eb  57 80 47 99 bc c6 58 55  |':86....W.G...XU|
-00000130  15 6f 53 f7 83 ca 2b 89  ae be 23 9a 83 3c 6b b1  |.oS...+...#..<k.|
-00000140  10 67 a2 c4 65 e0 3a 25  05 4a 5b dc 10 96 93 b8  |.g..e.:%.J[.....|
-00000150  72 7b 1f 07 6d c7 48 c4  86 b5 a5 cd bf 6f d4 98  |r{..m.H......o..|
-00000160  bc 71 5b 39 36 67 9b 1a  88 a1 74 c4 7d 34 7c 1b  |.q[96g....t.}4|.|
-00000170  a7 31 c1 04 77 b7 cd 30  8e 69 6c 99 c4 9f 0b b8  |.1..w..0.il.....|
-00000180  e4 53 03 b9 86 12 61 b0  fe 0e 37 df 99 77 00 3f  |.S....a...7..w.?|
-00000190  d4 10 c9 73 eb a2 9a 00  d6 cd 6a 5e 67 ec 55 ca  |...s......j^g.U.|
-000001a0  26 89 2f 11 9d 30 8f bd  5a 68 55 20 f5 93 44 5e  |&./..0..ZhU ..D^|
-000001b0  1f f2 24 20 fa 80 94 c7  01 62 c2 95 d3 18 c6 2c  |..$ .....b.....,|
-000001c0  00 42 fa ee 32 75 27 5f  df 81 f2 14 83 30 cd 25  |.B..2u'_.....0.%|
-000001d0  1d 6c 3a c5 f5 3f 6e b7  6a f0 cf 02 f9 a3 8d da  |.l:..?n.j.......|
-000001e0  96 55 31 2c 3c ef 62 c0  19 ac 36 f3 89 44 a4 a4  |.U1,<.b...6..D..|
-000001f0  60 c3 99 b5 db 9f c7 4c  9d fb f1 77 98 dc 90 0e  |`......L...w....|
-00000200  8a e2 0e e2 6a 25 6e 84  2b d6 dc 73 57 7a 6e 1d  |....j%n.+..sWzn.|
-00000210  41 2e d0 de 45 ab 49 f0  e3 64 e4 6a 02 fa 64 6f  |A...E.I..d.j..do|
-00000220  09 22 05 b5 0c 12 b0 57  e2 61 5a 63 b1 4c a4 e5  |.".....W.aZc.L..|
-00000230  79 c4 42 17 36 f0 0c 43  04 a5 d7 7c 3f 59 17 38  |y.B.6..C...|?Y.8|
-00000240  f0 f1 2c 2d be 6c 4e 58  e5 45 c9 c2 d6 df 7b b3  |..,-.lNX.E....{.|
-00000250  08 50 db e6 a8 ae 73 f2  82 09 6e 58 07 d3 87 e4  |.P....s...nX....|
-00000260  c2 70 c6 8f 8f 13 74 09  b1 7d 1a 42 e1 d1 72 41  |.p....t..}.B..rA|
-00000270  bd 71 cc f4 6c 7f 70 a2  99 95 34 b7 2c 08 af 43  |.q..l.p...4.,..C|
-00000280  43 ec 61 66 51 73 e2 87  b3 f3 ef ee 20 f2 55 58  |C.afQs...... .UX|
-00000290  c7 1a 0c ad dd 7b 44 9f  f1 ff 5e 2b 18 63 e1 45  |.....{D...^+.c.E|
-000002a0  88 5d c1 ce cb dc 42 ec  10 03 d4 d7 ae 2f ed ce  |.]....B....../..|
-000002b0  49 01 e3 1e de b0 68 ce  25 e0 69 b1 33 37 3d 0f  |I.....h.%.i.37=.|
-000002c0  b6 96 7e cd 7e 91 fb 82  a2 b8 66 6b 9a 44 83 c7  |..~.~.....fk.D..|
-000002d0  56 86 87 a5 f2 b1 06 16  a3 43 e1 29 fe f7 26 c9  |V........C.)..&.|
-000002e0  39 ea a4 b0 62 7b d5 9e  8a 0f 89 07 f9 a0 fc 45  |9...b{.........E|
-000002f0  bf ce 70 1d 75 7f fa db  2a 5b 32 02 bb 69 cc 72  |..p.u...*[2..i.r|
-00000300  cf 24 3d 92 20 d9 2f ee  a5 9d 72 33 23 f5 99 f5  |.$=. ./...r3#...|
-00000310  b1 82 eb 17 03 03 00 99  01 f0 87 1b 28 83 73 0f  |............(.s.|
-00000320  67 c8 76 69 e7 e6 ae d4  5c fc e0 e7 1c 6b 85 de  |g.vi....\....k..|
-00000330  de a0 9e 6c 1a 7d 90 31  d8 63 92 a1 bc f3 47 54  |...l.}.1.c....GT|
-00000340  c4 00 b9 62 30 db 1d 5b  c9 d5 e5 58 67 5e ab 68  |...b0..[...Xg^.h|
-00000350  3a 41 65 11 8d 9b a2 8c  4f e7 b7 76 ca c6 ca 2e  |:Ae.....O..v....|
-00000360  2d 6b 7b d1 90 41 9f 0c  c6 a5 18 4d d2 99 49 0b  |-k{..A.....M..I.|
-00000370  24 ab c5 84 cd a1 79 0a  0f 48 f3 f6 a4 f3 44 f3  |$.....y..H....D.|
-00000380  42 cb eb 6d 7d 16 b8 42  43 37 78 d9 e3 47 ce ee  |B..m}..BC7x..G..|
-00000390  c9 4b 3d 4f 47 ab 77 15  45 59 dd 31 02 f9 f8 60  |.K=OG.w.EY.1...`|
-000003a0  41 c6 dc e2 e3 25 8f 43  dd 77 c4 ce ba b9 63 c7  |A....%.C.w....c.|
-000003b0  5e 17 03 03 00 35 2a d8  c8 91 25 bb 27 c2 fc cd  |^....5*...%.'...|
-000003c0  b3 d0 c2 57 70 39 fc 81  d7 11 01 6c 72 ca 58 19  |...Wp9.....lr.X.|
-000003d0  c1 5d 72 9e 72 dc 70 2a  3d 1f 35 1c 05 4f 51 26  |.]r.r.p*=.5..OQ&|
-000003e0  30 72 97 a5 7a 7a 0a 7b  9e 91 03                 |0r..zz.{...|
+00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 03 00 00  |................|
+00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 17  |..+.....3.$... .|
+00000060  7d df 14 8a ad 43 51 c3  c2 08 3a ea f7 e3 96 6a  |}....CQ...:....j|
+00000070  b7 8b 61 66 d9 82 c5 7b  b9 77 bc 62 6a 19 04 14  |..af...{.w.bj...|
+00000080  03 03 00 01 01 17 03 03  00 17 4e 7b b6 d1 b1 19  |..........N{....|
+00000090  0d 0c d0 d3 5a 66 44 5c  81 49 74 f3 71 3b 97 5e  |....ZfD\.It.q;.^|
+000000a0  ee 17 03 03 02 6d 00 17  b1 4d b9 f5 fc ea 48 72  |.....m...M....Hr|
+000000b0  aa a5 1c 8b fe 97 08 54  ab 2d 0a 0e f7 51 41 bf  |.......T.-...QA.|
+000000c0  7b 14 ba b7 d9 0a 30 44  db b9 06 e7 6b a9 0a 94  |{.....0D....k...|
+000000d0  49 a2 29 50 f2 7f 7e 68  91 41 ad a9 cb ee e2 bd  |I.)P..~h.A......|
+000000e0  03 fd 95 79 ea c3 77 ee  88 3b 7a 81 15 9f 17 96  |...y..w..;z.....|
+000000f0  b2 db b9 f3 26 dd 75 69  ef 12 c0 63 b0 04 63 ae  |....&.ui...c..c.|
+00000100  aa b3 67 f8 7f a5 17 cf  56 5f ee 34 2d d7 83 23  |..g.....V_.4-..#|
+00000110  84 00 4b 94 1a 76 2a 01  ce 49 0a 57 7d c8 65 7a  |..K..v*..I.W}.ez|
+00000120  d7 16 34 1c a8 37 fd 71  d4 79 08 b1 44 9f 9e a7  |..4..7.q.y..D...|
+00000130  78 ab 9d 0d c4 80 0e 81  35 75 23 59 89 1b 2c d3  |x.......5u#Y..,.|
+00000140  bc c9 86 b9 7b 22 19 30  dd cc 68 93 ab d2 98 dd  |....{".0..h.....|
+00000150  c2 9f 20 af c9 1a 87 b3  28 73 84 83 ca 98 1d 60  |.. .....(s.....`|
+00000160  df 12 19 70 80 f2 ff 20  64 b5 8c ef e2 e8 6a 5a  |...p... d.....jZ|
+00000170  df 8e ba 95 d8 2c c4 b6  4f a1 33 8c 8d a3 fc d3  |.....,..O.3.....|
+00000180  c4 4b ba b2 6d 3a f7 da  38 23 5f 03 a7 92 13 76  |.K..m:..8#_....v|
+00000190  12 73 26 17 30 e0 21 f1  16 8f a1 e5 6d f0 21 a8  |.s&.0.!.....m.!.|
+000001a0  c6 25 64 86 95 5e 6f 4d  21 f0 f3 a3 27 23 2b 4b  |.%d..^oM!...'#+K|
+000001b0  90 03 ba 6c ce 9c 20 ed  69 15 76 cb 39 bc fd 44  |...l.. .i.v.9..D|
+000001c0  10 b4 72 d5 44 9d f7 eb  a4 b0 d5 07 20 a1 6b 71  |..r.D....... .kq|
+000001d0  16 e4 f7 8f a0 d8 fa 86  db e6 ef eb 63 41 a0 17  |............cA..|
+000001e0  83 71 0d 1c 4b ec 58 c3  90 9c ea 34 79 a7 91 43  |.q..K.X....4y..C|
+000001f0  ad 3d ff 28 c8 b4 3e 7a  b6 83 53 f4 99 0b 86 bc  |.=.(..>z..S.....|
+00000200  f2 cf ae 1d a7 5c 7f 57  d9 85 95 25 33 bb 4d 79  |.....\.W...%3.My|
+00000210  25 2e 54 6d 5d 14 32 68  7d 6e 45 bd b1 e1 24 30  |%.Tm].2h}nE...$0|
+00000220  c2 1c 45 b9 a2 42 ae b5  c6 6a 56 f9 8a 12 51 f9  |..E..B...jV...Q.|
+00000230  61 a2 9d 56 98 09 8d ea  70 17 48 d8 23 48 ca 18  |a..V....p.H.#H..|
+00000240  43 1e a2 bc 88 69 3d 45  95 89 cc f0 74 8d 88 36  |C....i=E....t..6|
+00000250  5e a8 1b be 88 41 35 8d  de a9 20 23 f3 5e ab c9  |^....A5... #.^..|
+00000260  61 22 2e 86 54 2f c4 4a  60 04 c2 e3 b8 cf 1a 41  |a"..T/.J`......A|
+00000270  a6 31 ab 7a b5 07 dc 54  82 89 b1 1f 9f 62 98 bc  |.1.z...T.....b..|
+00000280  bd 39 be 23 ed d5 bc 0d  8e a6 69 14 26 39 fe ed  |.9.#......i.&9..|
+00000290  98 c8 48 36 6c 8e 9f 93  57 7a ba 33 03 35 c6 de  |..H6l...Wz.3.5..|
+000002a0  55 03 63 e8 a4 53 08 0a  b0 a7 3e a3 cb f2 df 3d  |U.c..S....>....=|
+000002b0  cd 59 df ee f6 45 2d 77  39 32 4a 1f 08 21 e7 db  |.Y...E-w92J..!..|
+000002c0  52 2a 06 86 e6 00 98 ca  9f a3 ad 0f 7f d3 25 6d  |R*............%m|
+000002d0  56 58 21 e2 39 59 56 15  74 4d 18 37 f5 40 29 db  |VX!.9YV.tM.7.@).|
+000002e0  de be 49 77 e0 2c 5c 6b  ee b1 bd 4a ea 2a 07 94  |..Iw.,\k...J.*..|
+000002f0  0f 21 7c bb 1f bd 3e ad  9e b6 95 7d 16 e8 f0 4e  |.!|...>....}...N|
+00000300  de e2 ca 9c 34 9f b8 e5  57 d5 b7 b5 8d 60 dd c2  |....4...W....`..|
+00000310  ce 47 2c 17 03 03 00 99  37 37 20 49 98 44 f6 b4  |.G,.....77 I.D..|
+00000320  58 54 ff 5e b0 05 22 8e  c6 68 9a ae 49 51 e9 f1  |XT.^.."..h..IQ..|
+00000330  71 75 cf 1a 79 da 33 f1  5f 7e a1 02 81 05 12 8b  |qu..y.3._~......|
+00000340  a3 a8 ad 87 ee f0 87 da  f1 16 80 9d 2e fa 5a 22  |..............Z"|
+00000350  a5 f5 b9 14 f5 8f 9b 35  87 ba 1a f7 c4 17 c8 f6  |.......5........|
+00000360  a1 1e 28 cd fe 03 90 9f  f0 81 d3 80 bb 4c 1a b1  |..(..........L..|
+00000370  c6 11 de 19 a1 5a 3c 73  77 f0 70 b8 d1 38 16 f3  |.....Z<sw.p..8..|
+00000380  64 d0 8e 9c fe 4d 83 48  dc 20 78 db 6a 65 3f f4  |d....M.H. x.je?.|
+00000390  0f a0 70 cc 30 bb cd 86  51 0c 20 ea 59 a5 ed e8  |..p.0...Q. .Y...|
+000003a0  72 d9 5e f3 c3 41 0b 19  f3 97 0f fc 77 42 6d 15  |r.^..A......wBm.|
+000003b0  92 17 03 03 00 35 ac 97  30 a0 8a d8 d2 e6 4a 5b  |.....5..0.....J[|
+000003c0  f5 58 32 22 63 8e 36 2e  21 a2 30 33 ae 49 55 76  |.X2"c.6.!.03.IUv|
+000003d0  cf c8 b3 3f 82 8d c3 0e  ea 22 ec 8f 65 c8 c4 0d  |...?....."..e...|
+000003e0  bf cc 6a 86 e9 32 50 db  02 93 ec                 |..j..2P....|
 >>> Flow 3 (client to server)
-00000000  14 03 03 00 01 01 17 03  03 00 35 7d 5e 95 38 a2  |..........5}^.8.|
-00000010  d3 f4 04 59 57 2a 1a 86  ac 12 8e 17 88 fb 52 25  |...YW*........R%|
-00000020  1d 19 2c c5 ac 57 c9 bf  af 07 e7 c1 4d f3 dd f0  |..,..W......M...|
-00000030  13 ad a1 73 07 32 a4 c5  7c 9e ad 5a 88 59 57 4b  |...s.2..|..Z.YWK|
-00000040  17 03 03 00 17 e2 65 4f  bd 1f bb 00 a1 6b ae a4  |......eO.....k..|
-00000050  9d d3 d2 6e 7b 62 b5 09  19 d6 8f 1b 17 03 03 00  |...n{b..........|
-00000060  13 96 de 94 2b a7 bb c5  4b 7e 02 b2 27 07 4d 49  |....+...K~..'.MI|
-00000070  32 2b 83 48                                       |2+.H|
+00000000  14 03 03 00 01 01 17 03  03 00 35 e5 27 80 72 fd  |..........5.'.r.|
+00000010  6c 0d b5 a7 14 23 08 0b  f5 54 70 8c 29 61 d0 2a  |l....#...Tp.)a.*|
+00000020  81 2d 05 83 2a 21 1e 16  94 5b 65 0d 6a ca b6 81  |.-..*!...[e.j...|
+00000030  d9 9d 3c 5c 9c fe 2b 01  a8 3b 23 fb 9e eb 2c 56  |..<\..+..;#...,V|
+00000040  17 03 03 00 17 79 fd 43  29 72 96 e0 ad fd 7e 60  |.....y.C)r....~`|
+00000050  94 51 8d 8a 6e 6a 5d 6c  f3 0d 4b 74 17 03 03 00  |.Q..nj]l..Kt....|
+00000060  13 a4 7c e1 31 71 61 82  e7 7d 28 0f 63 d7 ae 76  |..|.1qa..}(.c..v|
+00000070  9c 71 37 cd                                       |.q7.|
diff --git a/src/crypto/tls/testdata/Server-TLSv10-ExportKeyingMaterial b/src/crypto/tls/testdata/Server-TLSv10-ExportKeyingMaterial
index a5d9ee4cdb..cb3b8da823 100644
--- a/src/crypto/tls/testdata/Server-TLSv10-ExportKeyingMaterial
+++ b/src/crypto/tls/testdata/Server-TLSv10-ExportKeyingMaterial
@@ -1,11 +1,11 @@
 >>> Flow 1 (client to server)
-00000000  16 03 01 00 63 01 00 00  5f 03 01 7a df fa af 20  |....c..._..z... |
-00000010  74 5a 83 3b 91 95 b4 9b  57 d8 6b f2 88 2a 68 e8  |tZ.;....W.k..*h.|
-00000020  b8 9e e7 88 a6 c5 e7 59  08 ff 9b 00 00 12 c0 0a  |.......Y........|
-00000030  c0 14 00 39 c0 09 c0 13  00 33 00 35 00 2f 00 ff  |...9.....3.5./..|
-00000040  01 00 00 24 00 0b 00 04  03 00 01 02 00 0a 00 0c  |...$............|
-00000050  00 0a 00 1d 00 17 00 1e  00 19 00 18 00 23 00 00  |.............#..|
-00000060  00 16 00 00 00 17 00 00                           |........|
+00000000  16 03 01 00 67 01 00 00  63 03 01 41 69 16 b5 d5  |....g...c..Ai...|
+00000010  c2 9d 36 2b 95 8e e5 41  9b 92 82 27 2a cc 4e 6e  |..6+...A...'*.Nn|
+00000020  5d f1 1b 58 49 3c 95 1d  8b 61 35 00 00 04 c0 14  |]..XI<...a5.....|
+00000030  00 ff 01 00 00 36 00 00  00 0e 00 0c 00 00 09 31  |.....6.........1|
+00000040  32 37 2e 30 2e 30 2e 31  00 0b 00 04 03 00 01 02  |27.0.0.1........|
+00000050  00 0a 00 0c 00 0a 00 1d  00 17 00 1e 00 19 00 18  |................|
+00000060  00 23 00 00 00 16 00 00  00 17 00 00              |.#..........|
 >>> Flow 2 (server to client)
 00000000  16 03 01 00 3b 02 00 00  37 03 01 00 00 00 00 00  |....;...7.......|
 00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
@@ -51,43 +51,43 @@
 00000290  d4 db fe 3d 13 60 84 5c  21 d3 3b e9 fa e7 16 03  |...=.`.\!.;.....|
 000002a0  01 00 aa 0c 00 00 a6 03  00 1d 20 2f e5 7d a3 47  |.......... /.}.G|
 000002b0  cd 62 43 15 28 da ac 5f  bb 29 07 30 ff f6 84 af  |.bC.(.._.).0....|
-000002c0  c4 cf c2 ed 90 99 5f 58  cb 3b 74 00 80 bb 96 fe  |......_X.;t.....|
-000002d0  bf a0 81 24 bc 40 b4 e2  37 b1 c9 66 2d c3 c1 bb  |...$.@..7..f-...|
-000002e0  89 fb 28 23 60 76 b1 e6  2c c1 e9 06 d0 95 c5 10  |..(#`v..,.......|
-000002f0  17 ce 79 36 c2 14 e0 1d  1d 0d 0e 49 3e b9 7f 00  |..y6.......I>...|
-00000300  ad e3 1d 37 ab ce 2c 37  dc eb be aa 6c 28 33 05  |...7..,7....l(3.|
-00000310  53 fd 06 17 b4 85 b9 b8  35 1c a7 3c bb 07 3f 4b  |S.......5..<..?K|
-00000320  53 98 00 4d 8e 49 bd 35  55 64 92 d0 a0 db 05 80  |S..M.I.5Ud......|
-00000330  57 24 78 cd 10 ed ae f0  6a 83 bc b4 4d 77 79 ba  |W$x.....j...Mwy.|
-00000340  6e e7 2e 8f ac 9e 98 34  36 9d a9 27 f0 16 03 01  |n......46..'....|
+000002c0  c4 cf c2 ed 90 99 5f 58  cb 3b 74 00 80 c6 ad e2  |......_X.;t.....|
+000002d0  21 0d d7 30 42 da 08 52  d5 46 70 a3 e5 d6 40 ab  |!..0B..R.Fp...@.|
+000002e0  bf 52 f8 da a5 41 86 1d  48 e6 51 91 52 8d 3c 5d  |.R...A..H.Q.R.<]|
+000002f0  ca 36 4c 62 d1 6b c8 48  8c 99 50 89 a9 27 4b 21  |.6Lb.k.H..P..'K!|
+00000300  c9 9d a6 43 34 d2 47 a7  b3 1a 6d 98 b3 7f 37 94  |...C4.G...m...7.|
+00000310  60 ba 88 f1 b7 ed 34 2b  47 f4 80 27 d3 a0 74 6a  |`.....4+G..'..tj|
+00000320  c6 d6 49 e3 8a e5 5d f1  a7 54 8a b4 84 8d a8 6b  |..I...]..T.....k|
+00000330  3b 7a 3f eb 81 77 4b bf  be 1e ac cd aa f9 4b 79  |;z?..wK.......Ky|
+00000340  24 78 6c 67 14 13 ab f8  ad 33 7c 94 38 16 03 01  |$xlg.....3|.8...|
 00000350  00 04 0e 00 00 00                                 |......|
 >>> Flow 3 (client to server)
-00000000  16 03 01 00 25 10 00 00  21 20 00 ad c5 2b 21 7f  |....%...! ...+!.|
-00000010  8e 44 f2 f5 32 22 c8 c2  c6 de 2c 0b 7a a9 24 b6  |.D..2"....,.z.$.|
-00000020  03 20 c0 cc 79 2e 11 2f  d3 43 14 03 01 00 01 01  |. ..y../.C......|
-00000030  16 03 01 00 30 78 5c 32  72 a1 c8 3b 9c 7b 77 0b  |....0x\2r..;.{w.|
-00000040  a0 28 52 55 17 16 d5 39  89 d0 43 bf 67 29 85 6f  |.(RU...9..C.g).o|
-00000050  b5 1e 83 fa 22 96 78 e3  5c 45 5a 3d fe 2b d5 b7  |....".x.\EZ=.+..|
-00000060  3d 64 44 8c a8                                    |=dD..|
+00000000  16 03 01 00 25 10 00 00  21 20 f5 be 48 cb fb 0d  |....%...! ..H...|
+00000010  69 27 a8 ab 59 c4 9a ac  92 71 46 d1 17 7e 35 67  |i'..Y....qF..~5g|
+00000020  15 b1 ea 9f 53 48 a3 b5  f9 55 14 03 01 00 01 01  |....SH...U......|
+00000030  16 03 01 00 30 e1 79 95  7c ab 01 74 35 39 9b ce  |....0.y.|..t59..|
+00000040  79 5f 15 21 88 fc be fc  46 a9 31 ca 82 07 0c 1f  |y_.!....F.1.....|
+00000050  d8 2f 93 b5 5d 23 bf f9  10 40 bc b5 22 53 df d6  |./..]#...@.."S..|
+00000060  b1 10 b9 16 96                                    |.....|
 >>> Flow 4 (server to client)
 00000000  16 03 01 00 8b 04 00 00  87 00 00 00 00 00 81 50  |...............P|
 00000010  46 ad c1 db a8 38 86 7b  2b bb fd d0 c3 42 3e 00  |F....8.{+....B>.|
 00000020  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 94  |................|
-00000030  6d ec a4 83 51 ed 14 ef  68 ca 42 c5 4c 5f bb 3b  |m...Q...h.B.L_.;|
-00000040  9c c8 3c 7e 1c cf dc da  e4 35 83 03 13 95 82 5f  |..<~.....5....._|
-00000050  32 77 8a cf dc e9 10 65  9b 97 d4 5d ff 43 57 14  |2w.....e...].CW.|
-00000060  a3 25 e0 fa c8 26 0c ff  71 67 9b 32 2f 49 38 16  |.%...&..qg.2/I8.|
-00000070  aa ea b9 fa 99 86 4c b9  db 7a ef bc 87 43 e8 db  |......L..z...C..|
-00000080  26 27 73 76 80 77 59 c4  fb 7d 56 e9 7e 23 03 75  |&'sv.wY..}V.~#.u|
-00000090  14 03 01 00 01 01 16 03  01 00 30 80 8f 8e 11 b5  |..........0.....|
-000000a0  f4 a0 8c 4a ae 3f 25 17  66 93 1c c5 a5 10 57 e3  |...J.?%.f.....W.|
-000000b0  24 7a c1 a9 72 74 4f fd  20 5e 5b 58 4d bd 5d f0  |$z..rtO. ^[XM.].|
-000000c0  05 8e 06 61 0a 98 19 a0  a8 73 02 17 03 01 00 20  |...a.....s..... |
-000000d0  d9 dd 86 e6 55 55 df 2c  0d 1e 5f 0e 9e 1e 76 51  |....UU.,.._...vQ|
-000000e0  98 e0 2b 09 f9 44 4d 4d  22 97 0d 1e 95 7b b9 41  |..+..DMM"....{.A|
-000000f0  17 03 01 00 30 74 82 1c  35 9b 87 cd 5e 29 95 e1  |....0t..5...^)..|
-00000100  18 e3 76 32 94 b5 1b d0  06 d2 ec 49 40 24 73 d3  |..v2.......I@$s.|
-00000110  fc 5d 1a 26 59 5b 33 d8  5a 30 d5 92 30 bc 80 e0  |.].&Y[3.Z0..0...|
-00000120  ed 85 e8 14 01 15 03 01  00 20 ec 69 2f 9d 29 4f  |......... .i/.)O|
-00000130  1f 8e e6 34 f0 87 66 40  e8 13 14 02 74 c4 1d aa  |...4..f@....t...|
-00000140  65 72 43 50 6e 71 9c 2e  b6 3a                    |erCPnq...:|
+00000030  6d ec a4 83 51 ed 14 ef  68 ca 42 c5 4c d2 34 08  |m...Q...h.B.L.4.|
+00000040  0b cc b9 32 8f 21 f7 50  c4 e1 28 9b 7d 5e ed de  |...2.!.P..(.}^..|
+00000050  0a df 30 0d 16 34 6b 6d  22 3c d3 c8 b2 99 84 8e  |..0..4km"<......|
+00000060  09 6d 3c 62 d4 0f f6 37  dc 53 ae 72 40 49 38 16  |.m<b...7.S.r@I8.|
+00000070  9c 30 34 bf 6e 34 bb 54  73 33 c0 c9 8c 12 ae bc  |.04.n4.Ts3......|
+00000080  e9 a8 80 23 de d0 e5 d3  46 d8 6a 86 c7 a5 6c 61  |...#....F.j...la|
+00000090  14 03 01 00 01 01 16 03  01 00 30 27 a7 5d e7 93  |..........0'.]..|
+000000a0  54 9a 77 d5 43 aa e3 ec  21 00 fa d4 36 04 c3 82  |T.w.C...!...6...|
+000000b0  b0 b7 f5 b4 19 ce f9 58  0a b4 7f d6 bf 95 43 9d  |.......X......C.|
+000000c0  26 44 46 77 48 cd 77 82  e2 48 51 17 03 01 00 20  |&DFwH.w..HQ.... |
+000000d0  c0 9b b1 d3 9f e6 4f 55  59 17 5a dc e4 2f bc 04  |......OUY.Z../..|
+000000e0  6f eb 4d d9 22 6e 97 20  33 94 d4 91 aa 70 4d ab  |o.M."n. 3....pM.|
+000000f0  17 03 01 00 30 9b 0f 50  a8 95 f5 db 67 96 c2 3e  |....0..P....g..>|
+00000100  46 a7 41 99 d5 e2 ab 60  b1 eb 8d 68 2f 71 30 70  |F.A....`...h/q0p|
+00000110  75 cc b8 50 1a 58 3b 96  d3 5c 99 43 27 4f b1 4a  |u..P.X;..\.C'O.J|
+00000120  c8 8d 5b ab 49 15 03 01  00 20 34 a6 41 25 fd 23  |..[.I.... 4.A%.#|
+00000130  44 6d 60 7f 79 5d 27 23  f7 cb 77 d0 cd 81 c4 67  |Dm`.y]'#..w....g|
+00000140  0e 56 92 60 ac a1 32 a5  0d 94                    |.V.`..2...|
diff --git a/src/crypto/tls/testdata/Server-TLSv12-CipherSuiteCertPreferenceECDSA b/src/crypto/tls/testdata/Server-TLSv12-CipherSuiteCertPreferenceECDSA
deleted file mode 100644
index 63e0edb6b9..0000000000
--- a/src/crypto/tls/testdata/Server-TLSv12-CipherSuiteCertPreferenceECDSA
+++ /dev/null
@@ -1,88 +0,0 @@
->>> Flow 1 (client to server)
-00000000  16 03 01 00 cb 01 00 00  c7 03 03 3f 5d 09 25 4e  |...........?].%N|
-00000010  82 83 13 89 ba 89 43 d5  43 4f f1 c3 2f 08 77 39  |......C.CO../.w9|
-00000020  bf eb c7 1d 4b d6 85 c8  17 2f 83 00 00 38 c0 2c  |....K..../...8.,|
-00000030  c0 30 00 9f cc a9 cc a8  cc aa c0 2b c0 2f 00 9e  |.0.........+./..|
-00000040  c0 24 c0 28 00 6b c0 23  c0 27 00 67 c0 0a c0 14  |.$.(.k.#.'.g....|
-00000050  00 39 c0 09 c0 13 00 33  00 9d 00 9c 00 3d 00 3c  |.9.....3.....=.<|
-00000060  00 35 00 2f 00 ff 01 00  00 66 00 00 00 0e 00 0c  |.5./.....f......|
-00000070  00 00 09 31 32 37 2e 30  2e 30 2e 31 00 0b 00 04  |...127.0.0.1....|
-00000080  03 00 01 02 00 0a 00 0c  00 0a 00 1d 00 17 00 1e  |................|
-00000090  00 19 00 18 00 16 00 00  00 17 00 00 00 0d 00 30  |...............0|
-000000a0  00 2e 04 03 05 03 06 03  08 07 08 08 08 09 08 0a  |................|
-000000b0  08 0b 08 04 08 05 08 06  04 01 05 01 06 01 03 03  |................|
-000000c0  02 03 03 01 02 01 03 02  02 02 04 02 05 02 06 02  |................|
->>> Flow 2 (server to client)
-00000000  16 03 03 00 37 02 00 00  33 03 03 00 00 00 00 00  |....7...3.......|
-00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000020  00 00 00 44 4f 57 4e 47  52 44 01 00 c0 0a 00 00  |...DOWNGRD......|
-00000030  0b ff 01 00 01 00 00 0b  00 02 01 00 16 03 03 02  |................|
-00000040  0e 0b 00 02 0a 00 02 07  00 02 04 30 82 02 00 30  |...........0...0|
-00000050  82 01 62 02 09 00 b8 bf  2d 47 a0 d2 eb f4 30 09  |..b.....-G....0.|
-00000060  06 07 2a 86 48 ce 3d 04  01 30 45 31 0b 30 09 06  |..*.H.=..0E1.0..|
-00000070  03 55 04 06 13 02 41 55  31 13 30 11 06 03 55 04  |.U....AU1.0...U.|
-00000080  08 13 0a 53 6f 6d 65 2d  53 74 61 74 65 31 21 30  |...Some-State1!0|
-00000090  1f 06 03 55 04 0a 13 18  49 6e 74 65 72 6e 65 74  |...U....Internet|
-000000a0  20 57 69 64 67 69 74 73  20 50 74 79 20 4c 74 64  | Widgits Pty Ltd|
-000000b0  30 1e 17 0d 31 32 31 31  32 32 31 35 30 36 33 32  |0...121122150632|
-000000c0  5a 17 0d 32 32 31 31 32  30 31 35 30 36 33 32 5a  |Z..221120150632Z|
-000000d0  30 45 31 0b 30 09 06 03  55 04 06 13 02 41 55 31  |0E1.0...U....AU1|
-000000e0  13 30 11 06 03 55 04 08  13 0a 53 6f 6d 65 2d 53  |.0...U....Some-S|
-000000f0  74 61 74 65 31 21 30 1f  06 03 55 04 0a 13 18 49  |tate1!0...U....I|
-00000100  6e 74 65 72 6e 65 74 20  57 69 64 67 69 74 73 20  |nternet Widgits |
-00000110  50 74 79 20 4c 74 64 30  81 9b 30 10 06 07 2a 86  |Pty Ltd0..0...*.|
-00000120  48 ce 3d 02 01 06 05 2b  81 04 00 23 03 81 86 00  |H.=....+...#....|
-00000130  04 00 c4 a1 ed be 98 f9  0b 48 73 36 7e c3 16 56  |.........Hs6~..V|
-00000140  11 22 f2 3d 53 c3 3b 4d  21 3d cd 6b 75 e6 f6 b0  |.".=S.;M!=.ku...|
-00000150  dc 9a df 26 c1 bc b2 87  f0 72 32 7c b3 64 2f 1c  |...&.....r2|.d/.|
-00000160  90 bc ea 68 23 10 7e fe  e3 25 c0 48 3a 69 e0 28  |...h#.~..%.H:i.(|
-00000170  6d d3 37 00 ef 04 62 dd  0d a0 9c 70 62 83 d8 81  |m.7...b....pb...|
-00000180  d3 64 31 aa 9e 97 31 bd  96 b0 68 c0 9b 23 de 76  |.d1...1...h..#.v|
-00000190  64 3f 1a 5c 7f e9 12 0e  58 58 b6 5f 70 dd 9b d8  |d?.\....XX._p...|
-000001a0  ea d5 d7 f5 d5 cc b9 b6  9f 30 66 5b 66 9a 20 e2  |.........0f[f. .|
-000001b0  27 e5 bf fe 3b 30 09 06  07 2a 86 48 ce 3d 04 01  |'...;0...*.H.=..|
-000001c0  03 81 8c 00 30 81 88 02  42 01 88 a2 4f eb e2 45  |....0...B...O..E|
-000001d0  c5 48 7d 1b ac f5 ed 98  9d ae 47 70 c0 5e 1b b6  |.H}.......Gp.^..|
-000001e0  2f bd f1 b6 4d b7 61 40  d3 11 a2 ce ee 0b 7e 92  |/...M.a@......~.|
-000001f0  7e ff 76 9d c3 3b 7e a5  3f ce fa 10 e2 59 ec 47  |~.v..;~.?....Y.G|
-00000200  2d 7c ac da 4e 97 0e 15  a0 6f d0 02 42 01 4d fc  |-|..N....o..B.M.|
-00000210  be 67 13 9c 2d 05 0e bd  3f a3 8c 25 c1 33 13 83  |.g..-...?..%.3..|
-00000220  0d 94 06 bb d4 37 7a f6  ec 7a c9 86 2e dd d7 11  |.....7z..z......|
-00000230  69 7f 85 7c 56 de fb 31  78 2b e4 c7 78 0d ae cb  |i..|V..1x+..x...|
-00000240  be 9e 4e 36 24 31 7b 6a  0f 39 95 12 07 8f 2a 16  |..N6$1{j.9....*.|
-00000250  03 03 00 b7 0c 00 00 b3  03 00 1d 20 2f e5 7d a3  |........... /.}.|
-00000260  47 cd 62 43 15 28 da ac  5f bb 29 07 30 ff f6 84  |G.bC.(.._.).0...|
-00000270  af c4 cf c2 ed 90 99 5f  58 cb 3b 74 04 03 00 8b  |......._X.;t....|
-00000280  30 81 88 02 42 01 5c 2a  30 4f 9f dc df a8 33 06  |0...B.\*0O....3.|
-00000290  3b bc 35 46 6a 9c a3 a1  26 ec 42 29 bf 63 b3 9b  |;.5Fj...&.B).c..|
-000002a0  8c bf 7b 07 8d 28 eb 41  68 7a 8a 1b f3 de a9 dc  |..{..(.Ahz......|
-000002b0  1e d1 21 3c 4d 24 df 89  90 b6 f2 fb ad 60 d2 27  |..!<M$.......`.'|
-000002c0  96 6d a2 b6 9b 48 e6 02  42 00 f1 c8 c2 f4 ee 4a  |.m...H..B......J|
-000002d0  8f 08 c5 09 05 e9 bf 7f  aa b6 3e 56 e9 98 46 b4  |..........>V..F.|
-000002e0  b4 e5 90 72 ed af 71 0d  fb e6 39 2f d5 4b 73 ba  |...r..q...9/.Ks.|
-000002f0  85 d2 a4 bf 99 74 d7 81  eb 3e 69 4d f0 12 1e 3c  |.....t...>iM...<|
-00000300  53 ca f0 35 85 ef ff ed  cc 0f f7 16 03 03 00 04  |S..5............|
-00000310  0e 00 00 00                                       |....|
->>> Flow 3 (client to server)
-00000000  16 03 03 00 25 10 00 00  21 20 b8 a6 ed 33 20 59  |....%...! ...3 Y|
-00000010  76 0b 7c 87 53 f1 12 c1  46 d9 db 68 c0 6f d6 30  |v.|.S...F..h.o.0|
-00000020  ea e0 64 04 54 7a 4c 95  03 41 14 03 03 00 01 01  |..d.TzL..A......|
-00000030  16 03 03 00 40 c0 70 29  39 a0 8a bd 59 58 88 44  |....@.p)9...YX.D|
-00000040  ea 10 b4 79 3e 0e 72 b7  2a 03 6d 4d 5a 24 f5 c0  |...y>.r.*.mMZ$..|
-00000050  4e e5 19 f0 fb 66 ca 97  89 4b 67 dc bb 19 cd 0b  |N....f...Kg.....|
-00000060  6e 74 01 d3 a4 9a ab af  8e 44 10 99 ac ff 9e 9e  |nt.......D......|
-00000070  17 04 56 78 55                                    |..VxU|
->>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 40 00 00 00 00 00  |..........@.....|
-00000010  00 00 00 00 00 00 00 00  00 00 00 01 a0 6b 2c c5  |.............k,.|
-00000020  7e 83 70 b5 2c 8c 43 b6  8b 2e 18 2a 1d be 11 6d  |~.p.,.C....*...m|
-00000030  13 f9 ba b5 de db 01 2a  64 d9 5b 24 c9 61 a1 4d  |.......*d.[$.a.M|
-00000040  11 bb fc b1 86 61 b0 04  a9 cd 1e 17 03 03 00 40  |.....a.........@|
-00000050  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000060  d8 98 85 b4 cb 61 39 69  2f b1 1f 24 c1 5a 4f e3  |.....a9i/..$.ZO.|
-00000070  0b 20 5d 6c 3f 3f 82 3a  a3 8a b3 cf e9 41 bb 60  |. ]l??.:.....A.`|
-00000080  ed b6 67 a0 76 39 ab 93  a5 35 d0 42 b3 a7 4c 92  |..g.v9...5.B..L.|
-00000090  15 03 03 00 30 00 00 00  00 00 00 00 00 00 00 00  |....0...........|
-000000a0  00 00 00 00 00 c7 0d 06  b2 2b 73 ab ed 16 88 6f  |.........+s....o|
-000000b0  62 77 fb 48 e4 5e 6d 7e  24 02 b6 08 fa 46 c8 76  |bw.H.^m~$....F.v|
-000000c0  18 fc f4 c4 08                                    |.....|
diff --git a/src/crypto/tls/testdata/Server-TLSv12-CipherSuiteCertPreferenceRSA b/src/crypto/tls/testdata/Server-TLSv12-CipherSuiteCertPreferenceRSA
deleted file mode 100644
index 802aa1acbd..0000000000
--- a/src/crypto/tls/testdata/Server-TLSv12-CipherSuiteCertPreferenceRSA
+++ /dev/null
@@ -1,92 +0,0 @@
->>> Flow 1 (client to server)
-00000000  16 03 01 00 cb 01 00 00  c7 03 03 27 8a e9 f3 58  |...........'...X|
-00000010  5a 08 90 d6 d4 97 23 b6  a7 92 73 3a a3 3c c1 a1  |Z.....#...s:.<..|
-00000020  ca 06 23 c8 ed 4a 19 26  73 c9 62 00 00 38 c0 2c  |..#..J.&s.b..8.,|
-00000030  c0 30 00 9f cc a9 cc a8  cc aa c0 2b c0 2f 00 9e  |.0.........+./..|
-00000040  c0 24 c0 28 00 6b c0 23  c0 27 00 67 c0 0a c0 14  |.$.(.k.#.'.g....|
-00000050  00 39 c0 09 c0 13 00 33  00 9d 00 9c 00 3d 00 3c  |.9.....3.....=.<|
-00000060  00 35 00 2f 00 ff 01 00  00 66 00 00 00 0e 00 0c  |.5./.....f......|
-00000070  00 00 09 31 32 37 2e 30  2e 30 2e 31 00 0b 00 04  |...127.0.0.1....|
-00000080  03 00 01 02 00 0a 00 0c  00 0a 00 1d 00 17 00 1e  |................|
-00000090  00 19 00 18 00 16 00 00  00 17 00 00 00 0d 00 30  |...............0|
-000000a0  00 2e 04 03 05 03 06 03  08 07 08 08 08 09 08 0a  |................|
-000000b0  08 0b 08 04 08 05 08 06  04 01 05 01 06 01 03 03  |................|
-000000c0  02 03 03 01 02 01 03 02  02 02 04 02 05 02 06 02  |................|
->>> Flow 2 (server to client)
-00000000  16 03 03 00 37 02 00 00  33 03 03 00 00 00 00 00  |....7...3.......|
-00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000020  00 00 00 44 4f 57 4e 47  52 44 01 00 c0 14 00 00  |...DOWNGRD......|
-00000030  0b ff 01 00 01 00 00 0b  00 02 01 00 16 03 03 02  |................|
-00000040  59 0b 00 02 55 00 02 52  00 02 4f 30 82 02 4b 30  |Y...U..R..O0..K0|
-00000050  82 01 b4 a0 03 02 01 02  02 09 00 e8 f0 9d 3f e2  |..............?.|
-00000060  5b ea a6 30 0d 06 09 2a  86 48 86 f7 0d 01 01 0b  |[..0...*.H......|
-00000070  05 00 30 1f 31 0b 30 09  06 03 55 04 0a 13 02 47  |..0.1.0...U....G|
-00000080  6f 31 10 30 0e 06 03 55  04 03 13 07 47 6f 20 52  |o1.0...U....Go R|
-00000090  6f 6f 74 30 1e 17 0d 31  36 30 31 30 31 30 30 30  |oot0...160101000|
-000000a0  30 30 30 5a 17 0d 32 35  30 31 30 31 30 30 30 30  |000Z..2501010000|
-000000b0  30 30 5a 30 1a 31 0b 30  09 06 03 55 04 0a 13 02  |00Z0.1.0...U....|
-000000c0  47 6f 31 0b 30 09 06 03  55 04 03 13 02 47 6f 30  |Go1.0...U....Go0|
-000000d0  81 9f 30 0d 06 09 2a 86  48 86 f7 0d 01 01 01 05  |..0...*.H.......|
-000000e0  00 03 81 8d 00 30 81 89  02 81 81 00 db 46 7d 93  |.....0.......F}.|
-000000f0  2e 12 27 06 48 bc 06 28  21 ab 7e c4 b6 a2 5d fe  |..'.H..(!.~...].|
-00000100  1e 52 45 88 7a 36 47 a5  08 0d 92 42 5b c2 81 c0  |.RE.z6G....B[...|
-00000110  be 97 79 98 40 fb 4f 6d  14 fd 2b 13 8b c2 a5 2e  |..y.@.Om..+.....|
-00000120  67 d8 d4 09 9e d6 22 38  b7 4a 0b 74 73 2b c2 34  |g....."8.J.ts+.4|
-00000130  f1 d1 93 e5 96 d9 74 7b  f3 58 9f 6c 61 3c c0 b0  |......t{.X.la<..|
-00000140  41 d4 d9 2b 2b 24 23 77  5b 1c 3b bd 75 5d ce 20  |A..++$#w[.;.u]. |
-00000150  54 cf a1 63 87 1d 1e 24  c4 f3 1d 1a 50 8b aa b6  |T..c...$....P...|
-00000160  14 43 ed 97 a7 75 62 f4  14 c8 52 d7 02 03 01 00  |.C...ub...R.....|
-00000170  01 a3 81 93 30 81 90 30  0e 06 03 55 1d 0f 01 01  |....0..0...U....|
-00000180  ff 04 04 03 02 05 a0 30  1d 06 03 55 1d 25 04 16  |.......0...U.%..|
-00000190  30 14 06 08 2b 06 01 05  05 07 03 01 06 08 2b 06  |0...+.........+.|
-000001a0  01 05 05 07 03 02 30 0c  06 03 55 1d 13 01 01 ff  |......0...U.....|
-000001b0  04 02 30 00 30 19 06 03  55 1d 0e 04 12 04 10 9f  |..0.0...U.......|
-000001c0  91 16 1f 43 43 3e 49 a6  de 6d b6 80 d7 9f 60 30  |...CC>I..m....`0|
-000001d0  1b 06 03 55 1d 23 04 14  30 12 80 10 48 13 49 4d  |...U.#..0...H.IM|
-000001e0  13 7e 16 31 bb a3 01 d5  ac ab 6e 7b 30 19 06 03  |.~.1......n{0...|
-000001f0  55 1d 11 04 12 30 10 82  0e 65 78 61 6d 70 6c 65  |U....0...example|
-00000200  2e 67 6f 6c 61 6e 67 30  0d 06 09 2a 86 48 86 f7  |.golang0...*.H..|
-00000210  0d 01 01 0b 05 00 03 81  81 00 9d 30 cc 40 2b 5b  |...........0.@+[|
-00000220  50 a0 61 cb ba e5 53 58  e1 ed 83 28 a9 58 1a a9  |P.a...SX...(.X..|
-00000230  38 a4 95 a1 ac 31 5a 1a  84 66 3d 43 d3 2d d9 0b  |8....1Z..f=C.-..|
-00000240  f2 97 df d3 20 64 38 92  24 3a 00 bc cf 9c 7d b7  |.... d8.$:....}.|
-00000250  40 20 01 5f aa d3 16 61  09 a2 76 fd 13 c3 cc e1  |@ ._...a..v.....|
-00000260  0c 5c ee b1 87 82 f1 6c  04 ed 73 bb b3 43 77 8d  |.\.....l..s..Cw.|
-00000270  0c 1c f1 0f a1 d8 40 83  61 c9 4c 72 2b 9d ae db  |......@.a.Lr+...|
-00000280  46 06 06 4d f4 c1 b3 3e  c0 d1 bd 42 d4 db fe 3d  |F..M...>...B...=|
-00000290  13 60 84 5c 21 d3 3b e9  fa e7 16 03 03 00 ac 0c  |.`.\!.;.........|
-000002a0  00 00 a8 03 00 1d 20 2f  e5 7d a3 47 cd 62 43 15  |...... /.}.G.bC.|
-000002b0  28 da ac 5f bb 29 07 30  ff f6 84 af c4 cf c2 ed  |(.._.).0........|
-000002c0  90 99 5f 58 cb 3b 74 08  04 00 80 42 86 d0 0a 5b  |.._X.;t....B...[|
-000002d0  d7 97 20 4d be 16 b8 eb  51 66 28 3b f9 45 35 f5  |.. M....Qf(;.E5.|
-000002e0  de 1d 28 c9 36 63 5b 7b  f6 a7 64 79 fb 39 20 c3  |..(.6c[{..dy.9 .|
-000002f0  dd db 38 3e af 89 ce 91  f7 bd 51 b4 5e 01 d8 9b  |..8>......Q.^...|
-00000300  54 62 58 24 3b c2 43 59  a4 11 1a 2b 67 c5 5f 79  |TbX$;.CY...+g._y|
-00000310  fe 68 9d c7 e6 8b 36 8b  f9 cb 00 b0 b3 0f 52 fb  |.h....6.......R.|
-00000320  fe a5 e6 c6 26 9b d1 a2  17 4e e2 58 7f b2 80 78  |....&....N.X...x|
-00000330  10 b4 0a 47 e1 18 92 d4  a5 5a 86 06 36 ca f7 b6  |...G.....Z..6...|
-00000340  1c 83 81 0e eb 32 7d fe  06 c5 03 16 03 03 00 04  |.....2}.........|
-00000350  0e 00 00 00                                       |....|
->>> Flow 3 (client to server)
-00000000  16 03 03 00 25 10 00 00  21 20 14 7f fb 7d 0c ef  |....%...! ...}..|
-00000010  48 c4 8f 75 24 19 5f ee  5f 51 08 35 74 cf c3 ea  |H..u$._._Q.5t...|
-00000020  67 20 c4 f9 49 b2 cf 69  5a 77 14 03 03 00 01 01  |g ..I..iZw......|
-00000030  16 03 03 00 40 2b d2 f4  dc 36 98 ef 1d 43 f9 3e  |....@+...6...C.>|
-00000040  83 33 c0 71 a6 e3 ac f1  3c cc 94 e4 d0 fe 81 bc  |.3.q....<.......|
-00000050  94 56 15 eb 6a 7b 17 33  e1 a0 ef d5 7a 86 af ea  |.V..j{.3....z...|
-00000060  1f bb d5 8c 80 56 d5 e4  08 cd 68 bf c0 53 c2 56  |.....V....h..S.V|
-00000070  aa b3 38 1e 4e                                    |..8.N|
->>> Flow 4 (server to client)
-00000000  14 03 03 00 01 01 16 03  03 00 40 00 00 00 00 00  |..........@.....|
-00000010  00 00 00 00 00 00 00 00  00 00 00 45 07 c3 ba 8c  |...........E....|
-00000020  d8 9f b6 f1 6a 14 bb b1  4e 84 3f 25 6a 3d ef f6  |....j...N.?%j=..|
-00000030  88 89 1a 91 22 ef e3 ed  ba 2a a3 7c 5b db e0 1d  |...."....*.|[...|
-00000040  b5 8d 7a ed e7 ad e1 31  b2 12 f5 17 03 03 00 40  |..z....1.......@|
-00000050  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000060  a6 f3 0b 33 f7 7a 7c fb  fb b5 e6 eb 6e 0a 26 aa  |...3.z|.....n.&.|
-00000070  06 3b a6 bc 08 e5 3a b6  c9 a3 f3 77 28 93 45 08  |.;....:....w(.E.|
-00000080  1d 54 5e a3 92 cd 89 a3  e6 34 ec 52 70 c0 97 3c  |.T^......4.Rp..<|
-00000090  15 03 03 00 30 00 00 00  00 00 00 00 00 00 00 00  |....0...........|
-000000a0  00 00 00 00 00 2d 0d 96  57 b8 6f 90 1e 84 4d 35  |.....-..W.o...M5|
-000000b0  91 52 42 6b 8d a3 6b 21  22 60 1a c9 38 7f 5a ef  |.RBk..k!"`..8.Z.|
-000000c0  6e dd 84 06 79                                    |n...y|
diff --git a/src/crypto/tls/tls_test.go b/src/crypto/tls/tls_test.go
index 9995538871..d8a43add17 100644
--- a/src/crypto/tls/tls_test.go
+++ b/src/crypto/tls/tls_test.go
@@ -18,6 +18,7 @@ import (
 	"net"
 	"os"
 	"reflect"
+	"sort"
 	"strings"
 	"testing"
 	"time"
@@ -1383,7 +1384,7 @@ func TestCipherSuites(t *testing.T) {
 		}
 	}
 
-	cipherSuiteByID := func(id uint16) *CipherSuite {
+	CipherSuiteByID := func(id uint16) *CipherSuite {
 		for _, c := range CipherSuites() {
 			if c.ID == id {
 				return c
@@ -1398,15 +1399,12 @@ func TestCipherSuites(t *testing.T) {
 	}
 
 	for _, c := range cipherSuites {
-		cc := cipherSuiteByID(c.id)
+		cc := CipherSuiteByID(c.id)
 		if cc == nil {
 			t.Errorf("%#04x: no CipherSuite entry", c.id)
 			continue
 		}
 
-		if defaultOff := c.flags&suiteDefaultOff != 0; defaultOff != cc.Insecure {
-			t.Errorf("%#04x: Insecure %v, expected %v", c.id, cc.Insecure, defaultOff)
-		}
 		if tls12Only := c.flags&suiteTLS12 != 0; tls12Only && len(cc.SupportedVersions) != 1 {
 			t.Errorf("%#04x: suite is TLS 1.2 only, but SupportedVersions is %v", c.id, cc.SupportedVersions)
 		} else if !tls12Only && len(cc.SupportedVersions) != 3 {
@@ -1418,7 +1416,7 @@ func TestCipherSuites(t *testing.T) {
 		}
 	}
 	for _, c := range cipherSuitesTLS13 {
-		cc := cipherSuiteByID(c.id)
+		cc := CipherSuiteByID(c.id)
 		if cc == nil {
 			t.Errorf("%#04x: no CipherSuite entry", c.id)
 			continue
@@ -1439,6 +1437,143 @@ func TestCipherSuites(t *testing.T) {
 	if got := CipherSuiteName(0xabc); got != "0x0ABC" {
 		t.Errorf("unexpected fallback CipherSuiteName: got %q, expected 0x0ABC", got)
 	}
+
+	if len(cipherSuitesPreferenceOrder) != len(cipherSuites) {
+		t.Errorf("cipherSuitesPreferenceOrder is not the same size as cipherSuites")
+	}
+	if len(cipherSuitesPreferenceOrderNoAES) != len(cipherSuitesPreferenceOrder) {
+		t.Errorf("cipherSuitesPreferenceOrderNoAES is not the same size as cipherSuitesPreferenceOrder")
+	}
+
+	// Check that disabled suites are at the end of the preference lists, and
+	// that they are marked insecure.
+	for i, id := range disabledCipherSuites {
+		offset := len(cipherSuitesPreferenceOrder) - len(disabledCipherSuites)
+		if cipherSuitesPreferenceOrder[offset+i] != id {
+			t.Errorf("disabledCipherSuites[%d]: not at the end of cipherSuitesPreferenceOrder", i)
+		}
+		if cipherSuitesPreferenceOrderNoAES[offset+i] != id {
+			t.Errorf("disabledCipherSuites[%d]: not at the end of cipherSuitesPreferenceOrderNoAES", i)
+		}
+		c := CipherSuiteByID(id)
+		if c == nil {
+			t.Errorf("%#04x: no CipherSuite entry", id)
+			continue
+		}
+		if !c.Insecure {
+			t.Errorf("%#04x: disabled by default but not marked insecure", id)
+		}
+	}
+
+	for i, prefOrder := range [][]uint16{cipherSuitesPreferenceOrder, cipherSuitesPreferenceOrderNoAES} {
+		// Check that insecure and HTTP/2 bad cipher suites are at the end of
+		// the preference lists.
+		var sawInsecure, sawBad bool
+		for _, id := range prefOrder {
+			c := CipherSuiteByID(id)
+			if c == nil {
+				t.Errorf("%#04x: no CipherSuite entry", id)
+				continue
+			}
+
+			if c.Insecure {
+				sawInsecure = true
+			} else if sawInsecure {
+				t.Errorf("%#04x: secure suite after insecure one(s)", id)
+			}
+
+			if http2isBadCipher(id) {
+				sawBad = true
+			} else if sawBad {
+				t.Errorf("%#04x: non-bad suite after bad HTTP/2 one(s)", id)
+			}
+		}
+
+		// Check that the list is sorted according to the documented criteria.
+		isBetter := func(a, b int) bool {
+			aSuite, bSuite := cipherSuiteByID(prefOrder[a]), cipherSuiteByID(prefOrder[b])
+			aName, bName := CipherSuiteName(prefOrder[a]), CipherSuiteName(prefOrder[b])
+			// * < RC4
+			if !strings.Contains(aName, "RC4") && strings.Contains(bName, "RC4") {
+				return true
+			} else if strings.Contains(aName, "RC4") && !strings.Contains(bName, "RC4") {
+				return false
+			}
+			// * < CBC_SHA256
+			if !strings.Contains(aName, "CBC_SHA256") && strings.Contains(bName, "CBC_SHA256") {
+				return true
+			} else if strings.Contains(aName, "CBC_SHA256") && !strings.Contains(bName, "CBC_SHA256") {
+				return false
+			}
+			// * < 3DES
+			if !strings.Contains(aName, "3DES") && strings.Contains(bName, "3DES") {
+				return true
+			} else if strings.Contains(aName, "3DES") && !strings.Contains(bName, "3DES") {
+				return false
+			}
+			// ECDHE < *
+			if aSuite.flags&suiteECDHE != 0 && bSuite.flags&suiteECDHE == 0 {
+				return true
+			} else if aSuite.flags&suiteECDHE == 0 && bSuite.flags&suiteECDHE != 0 {
+				return false
+			}
+			// AEAD < CBC
+			if aSuite.aead != nil && bSuite.aead == nil {
+				return true
+			} else if aSuite.aead == nil && bSuite.aead != nil {
+				return false
+			}
+			// AES < ChaCha20
+			if strings.Contains(aName, "AES") && strings.Contains(bName, "CHACHA20") {
+				return i == 0 // true for cipherSuitesPreferenceOrder
+			} else if strings.Contains(aName, "CHACHA20") && strings.Contains(bName, "AES") {
+				return i != 0 // true for cipherSuitesPreferenceOrderNoAES
+			}
+			// AES-128 < AES-256
+			if strings.Contains(aName, "AES_128") && strings.Contains(bName, "AES_256") {
+				return true
+			} else if strings.Contains(aName, "AES_256") && strings.Contains(bName, "AES_128") {
+				return false
+			}
+			// ECDSA < RSA
+			if aSuite.flags&suiteECSign != 0 && bSuite.flags&suiteECSign == 0 {
+				return true
+			} else if aSuite.flags&suiteECSign == 0 && bSuite.flags&suiteECSign != 0 {
+				return false
+			}
+			t.Fatalf("two ciphersuites are equal by all criteria: %v and %v", aName, bName)
+			panic("unreachable")
+		}
+		if !sort.SliceIsSorted(prefOrder, isBetter) {
+			t.Error("preference order is not sorted according to the rules")
+		}
+	}
+}
+
+// http2isBadCipher is copied from net/http.
+// TODO: if it ends up exposed somewhere, use that instead.
+func http2isBadCipher(cipher uint16) bool {
+	switch cipher {
+	case TLS_RSA_WITH_RC4_128_SHA,
+		TLS_RSA_WITH_3DES_EDE_CBC_SHA,
+		TLS_RSA_WITH_AES_128_CBC_SHA,
+		TLS_RSA_WITH_AES_256_CBC_SHA,
+		TLS_RSA_WITH_AES_128_CBC_SHA256,
+		TLS_RSA_WITH_AES_128_GCM_SHA256,
+		TLS_RSA_WITH_AES_256_GCM_SHA384,
+		TLS_ECDHE_ECDSA_WITH_RC4_128_SHA,
+		TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
+		TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
+		TLS_ECDHE_RSA_WITH_RC4_128_SHA,
+		TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
+		TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
+		TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
+		TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,
+		TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256:
+		return true
+	default:
+		return false
+	}
 }
 
 type brokenSigner struct{ crypto.Signer }
-- 
GitLab


From 4c8f48ed4f3db0e3ba376e6b7a261d26b41d8dd0 Mon Sep 17 00:00:00 2001
From: Alex Brainman <alex.brainman@gmail.com>
Date: Thu, 29 Apr 2021 15:38:56 +1000
Subject: [PATCH 2014/2400] syscall: do not change stdio handle inheritance

Before the CL 288297 all Go process handles had to be made
non-inheritable - otherwise they would escape into the child process.
But now this is not necessary.

This CL stops changing inheritance flag of stdint, stdout and stderr
handles.

Fixes #44876

Change-Id: Ib8fcf8066c30282293d96c34486b01b4c04f7116
Reviewed-on: https://go-review.googlesource.com/c/go/+/316269
Trust: Alex Brainman <alex.brainman@gmail.com>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Alex Brainman <alex.brainman@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
---
 src/syscall/syscall_windows.go      |  1 -
 src/syscall/syscall_windows_test.go | 65 +++++++++++++++++++++++++++++
 2 files changed, 65 insertions(+), 1 deletion(-)

diff --git a/src/syscall/syscall_windows.go b/src/syscall/syscall_windows.go
index f9f78bd2b3..fa0b5d959a 100644
--- a/src/syscall/syscall_windows.go
+++ b/src/syscall/syscall_windows.go
@@ -472,7 +472,6 @@ var (
 
 func getStdHandle(h int) (fd Handle) {
 	r, _ := GetStdHandle(h)
-	CloseOnExec(r)
 	return r
 }
 
diff --git a/src/syscall/syscall_windows_test.go b/src/syscall/syscall_windows_test.go
index b8ec6bee39..ea8fa191dc 100644
--- a/src/syscall/syscall_windows_test.go
+++ b/src/syscall/syscall_windows_test.go
@@ -5,8 +5,12 @@
 package syscall_test
 
 import (
+	"fmt"
+	"internal/testenv"
 	"os"
+	"os/exec"
 	"path/filepath"
+	"strings"
 	"syscall"
 	"testing"
 )
@@ -71,3 +75,64 @@ func TestTOKEN_ALL_ACCESS(t *testing.T) {
 		t.Errorf("TOKEN_ALL_ACCESS = %x, want 0xF01FF", syscall.TOKEN_ALL_ACCESS)
 	}
 }
+
+func TestStdioAreInheritable(t *testing.T) {
+	testenv.MustHaveGoBuild(t)
+	testenv.MustHaveExecPath(t, "gcc")
+
+	tmpdir := t.TempDir()
+
+	// build go dll
+	const dlltext = `
+package main
+
+import "C"
+import (
+	"fmt"
+)
+
+//export HelloWorld
+func HelloWorld() {
+	fmt.Println("Hello World")
+}
+
+func main() {}
+`
+	dllsrc := filepath.Join(tmpdir, "helloworld.go")
+	err := os.WriteFile(dllsrc, []byte(dlltext), 0644)
+	if err != nil {
+		t.Fatal(err)
+	}
+	dll := filepath.Join(tmpdir, "helloworld.dll")
+	cmd := exec.Command(testenv.GoToolPath(t), "build", "-o", dll, "-buildmode", "c-shared", dllsrc)
+	out, err := testenv.CleanCmdEnv(cmd).CombinedOutput()
+	if err != nil {
+		t.Fatalf("failed to build go library: %s\n%s", err, out)
+	}
+
+	// run powershell script
+	psscript := fmt.Sprintf(`
+hostname;
+$signature = " [DllImport("%q")] public static extern void HelloWorld(); ";
+Add-Type -MemberDefinition $signature -Name World -Namespace Hello;
+[Hello.World]::HelloWorld();
+hostname;
+`, dll)
+	psscript = strings.ReplaceAll(psscript, "\n", "")
+	out, err = exec.Command("powershell", "-Command", psscript).CombinedOutput()
+	if err != nil {
+		t.Fatalf("Powershell command failed: %v: %v", err, string(out))
+	}
+
+	hostname, err := os.Hostname()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	have := strings.ReplaceAll(string(out), "\n", "")
+	have = strings.ReplaceAll(have, "\r", "")
+	want := fmt.Sprintf("%sHello World%s", hostname, hostname)
+	if have != want {
+		t.Fatalf("Powershell command output is wrong: got %q, want %q", have, want)
+	}
+}
-- 
GitLab


From 68327e1aa11457cd570bc7eaf03a0260950f27d9 Mon Sep 17 00:00:00 2001
From: Alberto Donizetti <alb.donizetti@gmail.com>
Date: Fri, 7 May 2021 19:10:28 +0200
Subject: [PATCH 2015/2400] cmd/vendor: upgrade pprof to latest

This change upgrades the vendored pprof to pick up the fix for a
serious issue that made the source view in browser mode blank
(tracked upstream as google/pprof#621).

I also had to patch pprof.go, since one of the upstream commit we
included introduced a breaking change in the file interface (the Base
method is now called ObjAddr and has a different signature).

I've manually verified that the upgrade fixes the aforementioned
issues with the source view.

Fixes #45786

Change-Id: I00659ae539a2ad603758e1f06572374d483b9ddc
Reviewed-on: https://go-review.googlesource.com/c/go/+/318049
Trust: Alberto Donizetti <alb.donizetti@gmail.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 src/cmd/go.mod                                |   2 +-
 src/cmd/go.sum                                |   4 +-
 src/cmd/pprof/pprof.go                        |   4 +-
 .../github.com/google/pprof/driver/driver.go  |   4 +-
 .../pprof/internal/binutils/binutils.go       | 188 +++++++++++---
 .../google/pprof/internal/elfexec/elfexec.go  |  96 ++++---
 .../google/pprof/internal/plugin/plugin.go    |   5 +-
 .../google/pprof/internal/report/report.go    |  15 +-
 .../google/pprof/internal/report/source.go    | 235 ++++++++++++------
 .../pprof/internal/report/source_html.go      |   7 -
 .../google/pprof/internal/report/synth.go     |  39 +++
 .../github.com/google/pprof/profile/encode.go |   2 +-
 .../github.com/google/pprof/profile/merge.go  |   1 -
 src/cmd/vendor/modules.txt                    |   2 +-
 14 files changed, 412 insertions(+), 192 deletions(-)
 create mode 100644 src/cmd/vendor/github.com/google/pprof/internal/report/synth.go

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index a15cbe070a..7a96bc6409 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -3,7 +3,7 @@ module cmd
 go 1.17
 
 require (
-	github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5
+	github.com/google/pprof v0.0.0-20210506205249-923b5ab0fc1a
 	github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639 // indirect
 	golang.org/x/arch v0.0.0-20210502124803-cbf565b21d1e
 	golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e // indirect
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 8a7ad4290a..1c6e224820 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -1,8 +1,8 @@
 github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
 github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
 github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
-github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5 h1:zIaiqGYDQwa4HVx5wGRTXbx38Pqxjemn4BP98wpzpXo=
-github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
+github.com/google/pprof v0.0.0-20210506205249-923b5ab0fc1a h1:jmAp/2PZAScNd62lTD3Mcb0Ey9FvIIJtLohPhtxZJ+Q=
+github.com/google/pprof v0.0.0-20210506205249-923b5ab0fc1a/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
 github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639 h1:mV02weKRL81bEnm8A0HT1/CAelMQDBuQIfLw8n+d6xI=
 github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
 golang.org/x/arch v0.0.0-20210502124803-cbf565b21d1e h1:pv3V0NlNSh5Q6AX/StwGLBjcLS7UN4m4Gq+V+uSecqM=
diff --git a/src/cmd/pprof/pprof.go b/src/cmd/pprof/pprof.go
index 11f91cbedb..1d10a7b41f 100644
--- a/src/cmd/pprof/pprof.go
+++ b/src/cmd/pprof/pprof.go
@@ -232,9 +232,9 @@ func (f *file) Name() string {
 	return f.name
 }
 
-func (f *file) Base() uint64 {
+func (f *file) ObjAddr(addr uint64) (uint64, error) {
 	// No support for shared libraries.
-	return 0
+	return 0, nil
 }
 
 func (f *file) BuildID() string {
diff --git a/src/cmd/vendor/github.com/google/pprof/driver/driver.go b/src/cmd/vendor/github.com/google/pprof/driver/driver.go
index e65bc2f417..fc05f919ba 100644
--- a/src/cmd/vendor/github.com/google/pprof/driver/driver.go
+++ b/src/cmd/vendor/github.com/google/pprof/driver/driver.go
@@ -159,8 +159,8 @@ type ObjFile interface {
 	// Name returns the underlying file name, if available.
 	Name() string
 
-	// Base returns the base address to use when looking up symbols in the file.
-	Base() uint64
+	// ObjAddr returns the objdump address corresponding to a runtime address.
+	ObjAddr(addr uint64) (uint64, error)
 
 	// BuildID returns the GNU build ID of the file, or an empty string.
 	BuildID() string
diff --git a/src/cmd/vendor/github.com/google/pprof/internal/binutils/binutils.go b/src/cmd/vendor/github.com/google/pprof/internal/binutils/binutils.go
index 576a6ee66a..5ed8a1f9f1 100644
--- a/src/cmd/vendor/github.com/google/pprof/internal/binutils/binutils.go
+++ b/src/cmd/vendor/github.com/google/pprof/internal/binutils/binutils.go
@@ -42,7 +42,12 @@ type Binutils struct {
 	rep *binrep
 }
 
-var objdumpLLVMVerRE = regexp.MustCompile(`LLVM version (?:(\d*)\.(\d*)\.(\d*)|.*(trunk).*)`)
+var (
+	objdumpLLVMVerRE = regexp.MustCompile(`LLVM version (?:(\d*)\.(\d*)\.(\d*)|.*(trunk).*)`)
+
+	// Defined for testing
+	elfOpen = elf.Open
+)
 
 // binrep is an immutable representation for Binutils.  It is atomically
 // replaced on every mutation to provide thread-safe access.
@@ -421,14 +426,23 @@ func (b *binrep) openMachO(name string, start, limit, offset uint64) (plugin.Obj
 }
 
 func (b *binrep) openELF(name string, start, limit, offset uint64) (plugin.ObjFile, error) {
-	ef, err := elf.Open(name)
+	ef, err := elfOpen(name)
 	if err != nil {
 		return nil, fmt.Errorf("error parsing %s: %v", name, err)
 	}
 	defer ef.Close()
 
-	var stextOffset *uint64
-	var pageAligned = func(addr uint64) bool { return addr%4096 == 0 }
+	buildID := ""
+	if f, err := os.Open(name); err == nil {
+		if id, err := elfexec.GetBuildID(f); err == nil {
+			buildID = fmt.Sprintf("%x", id)
+		}
+	}
+
+	var (
+		stextOffset *uint64
+		pageAligned = func(addr uint64) bool { return addr%4096 == 0 }
+	)
 	if strings.Contains(name, "vmlinux") || !pageAligned(start) || !pageAligned(limit) || !pageAligned(offset) {
 		// Reading all Symbols is expensive, and we only rarely need it so
 		// we don't want to do it every time. But if _stext happens to be
@@ -450,38 +464,29 @@ func (b *binrep) openELF(name string, start, limit, offset uint64) (plugin.ObjFi
 		}
 	}
 
-	var ph *elf.ProgHeader
-	// For user space executables, find the actual program segment that is
-	// associated with the given mapping. Skip this search if limit <= start.
-	// We cannot use just a check on the start address of the mapping to tell if
-	// it's a kernel / .ko module mapping, because with quipper address remapping
-	// enabled, the address would be in the lower half of the address space.
-	if stextOffset == nil && start < limit && limit < (uint64(1)<<63) {
-		ph, err = elfexec.FindProgHeaderForMapping(ef, offset, limit-start)
-		if err != nil {
-			return nil, fmt.Errorf("failed to find program header for file %q, mapping pgoff %x, memsz=%x: %v", name, offset, limit-start, err)
-		}
-	} else {
-		// For the kernel, find the program segment that includes the .text section.
-		ph = elfexec.FindTextProgHeader(ef)
-	}
-
-	base, err := elfexec.GetBase(&ef.FileHeader, ph, stextOffset, start, limit, offset)
-	if err != nil {
+	// Check that we can compute a base for the binary. This may not be the
+	// correct base value, so we don't save it. We delay computing the actual base
+	// value until we have a sample address for this mapping, so that we can
+	// correctly identify the associated program segment that is needed to compute
+	// the base.
+	if _, err := elfexec.GetBase(&ef.FileHeader, elfexec.FindTextProgHeader(ef), stextOffset, start, limit, offset); err != nil {
 		return nil, fmt.Errorf("could not identify base for %s: %v", name, err)
 	}
 
-	buildID := ""
-	if f, err := os.Open(name); err == nil {
-		if id, err := elfexec.GetBuildID(f); err == nil {
-			buildID = fmt.Sprintf("%x", id)
-		}
-	}
-	isData := ph != nil && ph.Flags&elf.PF_X == 0
 	if b.fast || (!b.addr2lineFound && !b.llvmSymbolizerFound) {
-		return &fileNM{file: file{b, name, base, buildID, isData}}, nil
+		return &fileNM{file: file{
+			b:       b,
+			name:    name,
+			buildID: buildID,
+			m:       &elfMapping{start: start, limit: limit, offset: offset, stextOffset: stextOffset},
+		}}, nil
 	}
-	return &fileAddr2Line{file: file{b, name, base, buildID, isData}}, nil
+	return &fileAddr2Line{file: file{
+		b:       b,
+		name:    name,
+		buildID: buildID,
+		m:       &elfMapping{start: start, limit: limit, offset: offset, stextOffset: stextOffset},
+	}}, nil
 }
 
 func (b *binrep) openPE(name string, start, limit, offset uint64) (plugin.ObjFile, error) {
@@ -511,21 +516,119 @@ func (b *binrep) openPE(name string, start, limit, offset uint64) (plugin.ObjFil
 	return &fileAddr2Line{file: file{b: b, name: name, base: base}}, nil
 }
 
+// elfMapping stores the parameters of a runtime mapping that are needed to
+// identify the ELF segment associated with a mapping.
+type elfMapping struct {
+	// Runtime mapping parameters.
+	start, limit, offset uint64
+	// Offset of _stext symbol. Only defined for kernel images, nil otherwise.
+	stextOffset *uint64
+}
+
 // file implements the binutils.ObjFile interface.
 type file struct {
 	b       *binrep
 	name    string
-	base    uint64
 	buildID string
-	isData  bool
+
+	baseOnce sync.Once // Ensures the base, baseErr and isData are computed once.
+	base     uint64
+	baseErr  error // Any eventual error while computing the base.
+	isData   bool
+	// Mapping information. Relevant only for ELF files, nil otherwise.
+	m *elfMapping
+}
+
+// computeBase computes the relocation base for the given binary file only if
+// the elfMapping field is set. It populates the base and isData fields and
+// returns an error.
+func (f *file) computeBase(addr uint64) error {
+	if f == nil || f.m == nil {
+		return nil
+	}
+	if addr < f.m.start || addr >= f.m.limit {
+		return fmt.Errorf("specified address %x is outside the mapping range [%x, %x] for file %q", addr, f.m.start, f.m.limit, f.name)
+	}
+	ef, err := elfOpen(f.name)
+	if err != nil {
+		return fmt.Errorf("error parsing %s: %v", f.name, err)
+	}
+	defer ef.Close()
+
+	var ph *elf.ProgHeader
+	// For user space executables, find the actual program segment that is
+	// associated with the given mapping. Skip this search if limit <= start.
+	// We cannot use just a check on the start address of the mapping to tell if
+	// it's a kernel / .ko module mapping, because with quipper address remapping
+	// enabled, the address would be in the lower half of the address space.
+	if f.m.stextOffset == nil && f.m.start < f.m.limit && f.m.limit < (uint64(1)<<63) {
+		// Get all program headers associated with the mapping.
+		headers, hasLoadables := elfexec.ProgramHeadersForMapping(ef, f.m.offset, f.m.limit-f.m.start)
+
+		// Some ELF files don't contain any loadable program segments, e.g. .ko
+		// kernel modules. It's not an error to have no header in such cases.
+		if hasLoadables {
+			ph, err = matchUniqueHeader(headers, addr-f.m.start+f.m.offset)
+			if err != nil {
+				return fmt.Errorf("failed to find program header for file %q, ELF mapping %#v, address %x: %v", f.name, *f.m, addr, err)
+			}
+		}
+	} else {
+		// For the kernel, find the program segment that includes the .text section.
+		ph = elfexec.FindTextProgHeader(ef)
+	}
+
+	base, err := elfexec.GetBase(&ef.FileHeader, ph, f.m.stextOffset, f.m.start, f.m.limit, f.m.offset)
+	if err != nil {
+		return err
+	}
+	f.base = base
+	f.isData = ph != nil && ph.Flags&elf.PF_X == 0
+	return nil
+}
+
+// matchUniqueHeader attempts to identify a unique header from the given list,
+// using the given file offset to disambiguate between multiple segments. It
+// returns an error if the header list is empty or if it cannot identify a
+// unique header.
+func matchUniqueHeader(headers []*elf.ProgHeader, fileOffset uint64) (*elf.ProgHeader, error) {
+	if len(headers) == 0 {
+		return nil, errors.New("no program header matches mapping info")
+	}
+	if len(headers) == 1 {
+		// Don't use the file offset if we already have a single header.
+		return headers[0], nil
+	}
+	// We have multiple input segments. Attempt to identify a unique one
+	// based on the given file offset.
+	var ph *elf.ProgHeader
+	for _, h := range headers {
+		if fileOffset >= h.Off && fileOffset < h.Off+h.Memsz {
+			if ph != nil {
+				// Assuming no other bugs, this can only happen if we have two or
+				// more small program segments that fit on the same page, and a
+				// segment other than the last one includes uninitialized data.
+				return nil, fmt.Errorf("found second program header (%#v) that matches file offset %x, first program header is %#v. Does first program segment contain uninitialized data?", *h, fileOffset, *ph)
+			}
+			ph = h
+		}
+	}
+	if ph == nil {
+		return nil, fmt.Errorf("no program header matches file offset %x", fileOffset)
+	}
+	return ph, nil
 }
 
 func (f *file) Name() string {
 	return f.name
 }
 
-func (f *file) Base() uint64 {
-	return f.base
+func (f *file) ObjAddr(addr uint64) (uint64, error) {
+	f.baseOnce.Do(func() { f.baseErr = f.computeBase(addr) })
+	if f.baseErr != nil {
+		return 0, f.baseErr
+	}
+	return addr - f.base, nil
 }
 
 func (f *file) BuildID() string {
@@ -533,7 +636,11 @@ func (f *file) BuildID() string {
 }
 
 func (f *file) SourceLine(addr uint64) ([]plugin.Frame, error) {
-	return []plugin.Frame{}, nil
+	f.baseOnce.Do(func() { f.baseErr = f.computeBase(addr) })
+	if f.baseErr != nil {
+		return nil, f.baseErr
+	}
+	return nil, nil
 }
 
 func (f *file) Close() error {
@@ -560,6 +667,10 @@ type fileNM struct {
 }
 
 func (f *fileNM) SourceLine(addr uint64) ([]plugin.Frame, error) {
+	f.baseOnce.Do(func() { f.baseErr = f.computeBase(addr) })
+	if f.baseErr != nil {
+		return nil, f.baseErr
+	}
 	if f.addr2linernm == nil {
 		addr2liner, err := newAddr2LinerNM(f.b.nm, f.name, f.base)
 		if err != nil {
@@ -579,9 +690,14 @@ type fileAddr2Line struct {
 	file
 	addr2liner     *addr2Liner
 	llvmSymbolizer *llvmSymbolizer
+	isData         bool
 }
 
 func (f *fileAddr2Line) SourceLine(addr uint64) ([]plugin.Frame, error) {
+	f.baseOnce.Do(func() { f.baseErr = f.computeBase(addr) })
+	if f.baseErr != nil {
+		return nil, f.baseErr
+	}
 	f.once.Do(f.init)
 	if f.llvmSymbolizer != nil {
 		return f.llvmSymbolizer.addrInfo(addr)
diff --git a/src/cmd/vendor/github.com/google/pprof/internal/elfexec/elfexec.go b/src/cmd/vendor/github.com/google/pprof/internal/elfexec/elfexec.go
index 3b3c6ee89f..2638b2db2d 100644
--- a/src/cmd/vendor/github.com/google/pprof/internal/elfexec/elfexec.go
+++ b/src/cmd/vendor/github.com/google/pprof/internal/elfexec/elfexec.go
@@ -284,83 +284,71 @@ func FindTextProgHeader(f *elf.File) *elf.ProgHeader {
 	return nil
 }
 
-// FindProgHeaderForMapping returns the loadable program segment header that is
-// fully contained in the runtime mapping with file offset pgoff and memory size
-// memsz, or an error if the segment cannot be determined. The function returns
-// a nil program header and no error if the ELF binary has no loadable segments.
-func FindProgHeaderForMapping(f *elf.File, pgoff, memsz uint64) (*elf.ProgHeader, error) {
+// ProgramHeadersForMapping returns the loadable program segment headers that
+// are fully contained in the runtime mapping with file offset pgoff and memory
+// size memsz, and if the binary includes any loadable segments.
+func ProgramHeadersForMapping(f *elf.File, pgoff, memsz uint64) ([]*elf.ProgHeader, bool) {
+	const (
+		// pageSize defines the virtual memory page size used by the loader. This
+		// value is dependent on the memory management unit of the CPU. The page
+		// size is 4KB virtually on all the architectures that we care about, so we
+		// define this metric as a constant. If we encounter architectures where
+		// page sie is not 4KB, we must try to guess the page size on the system
+		// where the profile was collected, possibly using the architecture
+		// specified in the ELF file header.
+		pageSize       = 4096
+		pageOffsetMask = pageSize - 1
+		pageMask       = ^uint64(pageOffsetMask)
+	)
 	var headers []*elf.ProgHeader
-	loadables := 0
+	hasLoadables := false
 	for _, p := range f.Progs {
+		// The segment must be fully included in the mapping.
 		if p.Type == elf.PT_LOAD && pgoff <= p.Off && p.Off+p.Memsz <= pgoff+memsz {
-			headers = append(headers, &p.ProgHeader)
+			alignedOffset := uint64(0)
+			if p.Off > (p.Vaddr & pageOffsetMask) {
+				alignedOffset = p.Off - (p.Vaddr & pageOffsetMask)
+			}
+			if alignedOffset <= pgoff {
+				headers = append(headers, &p.ProgHeader)
+			}
 		}
 		if p.Type == elf.PT_LOAD {
-			loadables++
+			hasLoadables = true
 		}
 	}
-	if len(headers) == 1 {
-		return headers[0], nil
+	if len(headers) < 2 {
+		return headers, hasLoadables
 	}
-	// Some ELF files don't contain any program segments, e.g. .ko loadable kernel
-	// modules. Don't return an error in such cases.
-	if loadables == 0 {
-		return nil, nil
-	}
-	if len(headers) == 0 {
-		return nil, fmt.Errorf("no program header matches file offset %x and memory size %x", pgoff, memsz)
-	}
-
-	// Segments are mapped page aligned. In some cases, segments may be smaller
-	// than a page, which causes the next segment to start at a file offset that
-	// is logically on the same page if we were to align file offsets by page.
-	// Example:
-	//  LOAD           0x0000000000000000 0x0000000000400000 0x0000000000400000
-	//                 0x00000000000006fc 0x00000000000006fc  R E    0x200000
-	//  LOAD           0x0000000000000e10 0x0000000000600e10 0x0000000000600e10
-	//                 0x0000000000000230 0x0000000000000238  RW     0x200000
-	//
-	// In this case, perf records the following mappings for this executable:
-	// 0 0 [0xc0]: PERF_RECORD_MMAP2 87867/87867: [0x400000(0x1000) @ 0 00:3c 512041 0]: r-xp exename
-	// 0 0 [0xc0]: PERF_RECORD_MMAP2 87867/87867: [0x600000(0x2000) @ 0 00:3c 512041 0]: rw-p exename
-	//
-	// Both mappings have file offset 0. The first mapping is one page length and
-	// it can include only the first loadable segment. Due to page alignment, the
-	// second mapping starts also at file offset 0, and it spans two pages. It can
-	// include both the first and the second loadable segments. We must return the
-	// correct program header to compute the correct base offset.
-	//
-	// We cannot use the mapping protections to distinguish between segments,
-	// because protections are not passed through to this function.
-	// We cannot use the start address to differentiate between segments, because
-	// with ASLR, the mapping start address can be any value.
-	//
-	// We use a heuristic to compute the minimum mapping size required for a
-	// segment, assuming mappings are 4k page aligned, and return the segment that
-	// matches the given mapping size.
-	const pageSize = 4096
 
+	// If we have more than one matching segments, try a strict check on the
+	// segment memory size. We use a heuristic to compute the minimum mapping size
+	// required for a segment, assuming mappings are page aligned.
 	// The memory size based heuristic makes sense only if the mapping size is a
-	// multiple of 4k page size.
+	// multiple of page size.
 	if memsz%pageSize != 0 {
-		return nil, fmt.Errorf("mapping size = %x and %d segments match the passed in mapping", memsz, len(headers))
+		return headers, hasLoadables
 	}
 
-	// Return an error if no segment, or multiple segments match the size, so we can debug.
+	// Return all found headers if we cannot narrow the selection to a single
+	// program segment.
 	var ph *elf.ProgHeader
-	pageMask := ^uint64(pageSize - 1)
 	for _, h := range headers {
 		wantSize := (h.Vaddr+h.Memsz+pageSize-1)&pageMask - (h.Vaddr & pageMask)
 		if wantSize != memsz {
 			continue
 		}
 		if ph != nil {
-			return nil, fmt.Errorf("found second program header (%#v) that matches memsz %x, first program header is %#v", *h, memsz, *ph)
+			// Found a second program header matching, so return all previously
+			// identified headers.
+			return headers, hasLoadables
 		}
 		ph = h
 	}
 	if ph == nil {
-		return nil, fmt.Errorf("found %d matching program headers, but none matches mapping size %x", len(headers), memsz)
+		// No matching header for the strict check. Return all previously identified
+		// headers.
+		return headers, hasLoadables
 	}
-	return ph, nil
+	return []*elf.ProgHeader{ph}, hasLoadables
 }
diff --git a/src/cmd/vendor/github.com/google/pprof/internal/plugin/plugin.go b/src/cmd/vendor/github.com/google/pprof/internal/plugin/plugin.go
index 3a8d0af730..a57a0b20a9 100644
--- a/src/cmd/vendor/github.com/google/pprof/internal/plugin/plugin.go
+++ b/src/cmd/vendor/github.com/google/pprof/internal/plugin/plugin.go
@@ -131,8 +131,9 @@ type ObjFile interface {
 	// Name returns the underlyinf file name, if available
 	Name() string
 
-	// Base returns the base address to use when looking up symbols in the file.
-	Base() uint64
+	// ObjAddr returns the objdump (linker) address corresponding to a runtime
+	// address, and an error.
+	ObjAddr(addr uint64) (uint64, error)
 
 	// BuildID returns the GNU build ID of the file, or an empty string.
 	BuildID() string
diff --git a/src/cmd/vendor/github.com/google/pprof/internal/report/report.go b/src/cmd/vendor/github.com/google/pprof/internal/report/report.go
index bc5685d61e..4a86554880 100644
--- a/src/cmd/vendor/github.com/google/pprof/internal/report/report.go
+++ b/src/cmd/vendor/github.com/google/pprof/internal/report/report.go
@@ -445,7 +445,7 @@ func PrintAssembly(w io.Writer, rpt *Report, obj plugin.ObjTool, maxFuncs int) e
 			return err
 		}
 
-		ns := annotateAssembly(insts, sns, s.base)
+		ns := annotateAssembly(insts, sns, s.file)
 
 		fmt.Fprintf(w, "ROUTINE ======================== %s\n", s.sym.Name[0])
 		for _, name := range s.sym.Name[1:] {
@@ -534,7 +534,6 @@ func symbolsFromBinaries(prof *profile.Profile, g *graph.Graph, rx *regexp.Regex
 			addr = *address
 		}
 		msyms, err := f.Symbols(rx, addr)
-		base := f.Base()
 		f.Close()
 		if err != nil {
 			continue
@@ -543,7 +542,6 @@ func symbolsFromBinaries(prof *profile.Profile, g *graph.Graph, rx *regexp.Regex
 			objSyms = append(objSyms,
 				&objSymbol{
 					sym:  ms,
-					base: base,
 					file: f,
 				},
 			)
@@ -558,7 +556,6 @@ func symbolsFromBinaries(prof *profile.Profile, g *graph.Graph, rx *regexp.Regex
 // added to correspond to sample addresses
 type objSymbol struct {
 	sym  *plugin.Sym
-	base uint64
 	file plugin.ObjFile
 }
 
@@ -578,8 +575,7 @@ func nodesPerSymbol(ns graph.Nodes, symbols []*objSymbol) map[*objSymbol]graph.N
 	for _, s := range symbols {
 		// Gather samples for this symbol.
 		for _, n := range ns {
-			address := n.Info.Address - s.base
-			if address >= s.sym.Start && address < s.sym.End {
+			if address, err := s.file.ObjAddr(n.Info.Address); err == nil && address >= s.sym.Start && address < s.sym.End {
 				symNodes[s] = append(symNodes[s], n)
 			}
 		}
@@ -621,7 +617,7 @@ func (a *assemblyInstruction) cumValue() int64 {
 // annotateAssembly annotates a set of assembly instructions with a
 // set of samples. It returns a set of nodes to display. base is an
 // offset to adjust the sample addresses.
-func annotateAssembly(insts []plugin.Inst, samples graph.Nodes, base uint64) []assemblyInstruction {
+func annotateAssembly(insts []plugin.Inst, samples graph.Nodes, file plugin.ObjFile) []assemblyInstruction {
 	// Add end marker to simplify printing loop.
 	insts = append(insts, plugin.Inst{
 		Addr: ^uint64(0),
@@ -645,7 +641,10 @@ func annotateAssembly(insts []plugin.Inst, samples graph.Nodes, base uint64) []a
 
 		// Sum all the samples until the next instruction (to account
 		// for samples attributed to the middle of an instruction).
-		for next := insts[ix+1].Addr; s < len(samples) && samples[s].Info.Address-base < next; s++ {
+		for next := insts[ix+1].Addr; s < len(samples); s++ {
+			if addr, err := file.ObjAddr(samples[s].Info.Address); err != nil || addr >= next {
+				break
+			}
 			sample := samples[s]
 			n.flatDiv += sample.FlatDiv
 			n.flat += sample.Flat
diff --git a/src/cmd/vendor/github.com/google/pprof/internal/report/source.go b/src/cmd/vendor/github.com/google/pprof/internal/report/source.go
index 4f841eff5d..54245e5f9e 100644
--- a/src/cmd/vendor/github.com/google/pprof/internal/report/source.go
+++ b/src/cmd/vendor/github.com/google/pprof/internal/report/source.go
@@ -132,6 +132,7 @@ func printWebSource(w io.Writer, rpt *Report, obj plugin.ObjTool) error {
 // sourcePrinter holds state needed for generating source+asm HTML listing.
 type sourcePrinter struct {
 	reader     *sourceReader
+	synth      *synthCode
 	objectTool plugin.ObjTool
 	objects    map[string]plugin.ObjFile  // Opened object files
 	sym        *regexp.Regexp             // May be nil
@@ -146,6 +147,12 @@ type sourcePrinter struct {
 	prettyNames map[string]string
 }
 
+// addrInfo holds information for an address we are interested in.
+type addrInfo struct {
+	loc *profile.Location // Always non-nil
+	obj plugin.ObjFile    // May be nil
+}
+
 // instructionInfo holds collected information for an instruction.
 type instructionInfo struct {
 	objAddr   uint64 // Address in object file (with base subtracted out)
@@ -207,6 +214,7 @@ func PrintWebList(w io.Writer, rpt *Report, obj plugin.ObjTool, maxFiles int) er
 func newSourcePrinter(rpt *Report, obj plugin.ObjTool, sourcePath string) *sourcePrinter {
 	sp := &sourcePrinter{
 		reader:      newSourceReader(sourcePath, rpt.options.TrimPath),
+		synth:       newSynthCode(rpt.prof.Mapping),
 		objectTool:  obj,
 		objects:     map[string]plugin.ObjFile{},
 		sym:         rpt.options.Symbol,
@@ -225,19 +233,21 @@ func newSourcePrinter(rpt *Report, obj plugin.ObjTool, sourcePath string) *sourc
 		}
 	}
 
-	addrs := map[uint64]bool{}
+	addrs := map[uint64]addrInfo{}
 	flat := map[uint64]int64{}
 	cum := map[uint64]int64{}
 
 	// Record an interest in the function corresponding to lines[index].
-	markInterest := func(addr uint64, lines []profile.Line, index int) {
-		fn := lines[index]
+	markInterest := func(addr uint64, loc *profile.Location, index int) {
+		fn := loc.Line[index]
 		if fn.Function == nil {
 			return
 		}
 		sp.interest[fn.Function.Name] = true
 		sp.interest[fn.Function.SystemName] = true
-		addrs[addr] = true
+		if _, ok := addrs[addr]; !ok {
+			addrs[addr] = addrInfo{loc, sp.objectFile(loc.Mapping)}
+		}
 	}
 
 	// See if sp.sym matches line.
@@ -270,15 +280,21 @@ func newSourcePrinter(rpt *Report, obj plugin.ObjTool, sourcePath string) *sourc
 				sp.prettyNames[line.Function.SystemName] = line.Function.Name
 			}
 
-			cum[loc.Address] += value
+			addr := loc.Address
+			if addr == 0 {
+				// Some profiles are missing valid addresses.
+				addr = sp.synth.address(loc)
+			}
+
+			cum[addr] += value
 			if i == 0 {
-				flat[loc.Address] += value
+				flat[addr] += value
 			}
 
-			if sp.sym == nil || (address != nil && loc.Address == *address) {
+			if sp.sym == nil || (address != nil && addr == *address) {
 				// Interested in top-level entry of stack.
 				if len(loc.Line) > 0 {
-					markInterest(loc.Address, loc.Line, len(loc.Line)-1)
+					markInterest(addr, loc, len(loc.Line)-1)
 				}
 				continue
 			}
@@ -287,7 +303,7 @@ func newSourcePrinter(rpt *Report, obj plugin.ObjTool, sourcePath string) *sourc
 			matchFile := (loc.Mapping != nil && sp.sym.MatchString(loc.Mapping.File))
 			for j, line := range loc.Line {
 				if (j == 0 && matchFile) || matches(line) {
-					markInterest(loc.Address, loc.Line, j)
+					markInterest(addr, loc, j)
 				}
 			}
 		}
@@ -306,10 +322,11 @@ func (sp *sourcePrinter) close() {
 	}
 }
 
-func (sp *sourcePrinter) expandAddresses(rpt *Report, addrs map[uint64]bool, flat map[uint64]int64) {
+func (sp *sourcePrinter) expandAddresses(rpt *Report, addrs map[uint64]addrInfo, flat map[uint64]int64) {
 	// We found interesting addresses (ones with non-zero samples) above.
 	// Get covering address ranges and disassemble the ranges.
-	ranges := sp.splitIntoRanges(rpt.prof, addrs, flat)
+	ranges, unprocessed := sp.splitIntoRanges(rpt.prof, addrs, flat)
+	sp.handleUnprocessed(addrs, unprocessed)
 
 	// Trim ranges if there are too many.
 	const maxRanges = 25
@@ -321,9 +338,18 @@ func (sp *sourcePrinter) expandAddresses(rpt *Report, addrs map[uint64]bool, fla
 	}
 
 	for _, r := range ranges {
-		base := r.obj.Base()
-		insts, err := sp.objectTool.Disasm(r.mapping.File, r.begin-base, r.end-base,
-			rpt.options.IntelSyntax)
+		objBegin, err := r.obj.ObjAddr(r.begin)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Failed to compute objdump address for range start %x: %v\n", r.begin, err)
+			continue
+		}
+		objEnd, err := r.obj.ObjAddr(r.end)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Failed to compute objdump address for range end %x: %v\n", r.end, err)
+			continue
+		}
+		base := r.begin - objBegin
+		insts, err := sp.objectTool.Disasm(r.mapping.File, objBegin, objEnd, rpt.options.IntelSyntax)
 		if err != nil {
 			// TODO(sanjay): Report that the covered addresses are missing.
 			continue
@@ -385,78 +411,115 @@ func (sp *sourcePrinter) expandAddresses(rpt *Report, addrs map[uint64]bool, fla
 				frames = lastFrames
 			}
 
-			// See if the stack contains a function we are interested in.
-			for i, f := range frames {
-				if !sp.interest[f.Func] {
-					continue
-				}
+			sp.addStack(addr, frames)
+		}
+	}
+}
 
-				// Record sub-stack under frame's file/line.
-				fname := canonicalizeFileName(f.File)
-				file := sp.files[fname]
-				if file == nil {
-					file = &sourceFile{
-						fname:    fname,
-						lines:    map[int][]sourceInst{},
-						funcName: map[int]string{},
-					}
-					sp.files[fname] = file
-				}
-				callees := frames[:i]
-				stack := make([]callID, 0, len(callees))
-				for j := len(callees) - 1; j >= 0; j-- { // Reverse so caller is first
-					stack = append(stack, callID{
-						file: callees[j].File,
-						line: callees[j].Line,
-					})
-				}
-				file.lines[f.Line] = append(file.lines[f.Line], sourceInst{addr, stack})
+func (sp *sourcePrinter) addStack(addr uint64, frames []plugin.Frame) {
+	// See if the stack contains a function we are interested in.
+	for i, f := range frames {
+		if !sp.interest[f.Func] {
+			continue
+		}
 
-				// Remember the first function name encountered per source line
-				// and assume that that line belongs to that function.
-				if _, ok := file.funcName[f.Line]; !ok {
-					file.funcName[f.Line] = f.Func
-				}
+		// Record sub-stack under frame's file/line.
+		fname := canonicalizeFileName(f.File)
+		file := sp.files[fname]
+		if file == nil {
+			file = &sourceFile{
+				fname:    fname,
+				lines:    map[int][]sourceInst{},
+				funcName: map[int]string{},
 			}
+			sp.files[fname] = file
+		}
+		callees := frames[:i]
+		stack := make([]callID, 0, len(callees))
+		for j := len(callees) - 1; j >= 0; j-- { // Reverse so caller is first
+			stack = append(stack, callID{
+				file: callees[j].File,
+				line: callees[j].Line,
+			})
+		}
+		file.lines[f.Line] = append(file.lines[f.Line], sourceInst{addr, stack})
+
+		// Remember the first function name encountered per source line
+		// and assume that that line belongs to that function.
+		if _, ok := file.funcName[f.Line]; !ok {
+			file.funcName[f.Line] = f.Func
 		}
 	}
 }
 
-// splitIntoRanges converts the set of addresses we are interested in into a set of address
-// ranges to disassemble.
-func (sp *sourcePrinter) splitIntoRanges(prof *profile.Profile, set map[uint64]bool, flat map[uint64]int64) []addressRange {
-	// List of mappings so we can stop expanding address ranges at mapping boundaries.
-	mappings := append([]*profile.Mapping{}, prof.Mapping...)
-	sort.Slice(mappings, func(i, j int) bool { return mappings[i].Start < mappings[j].Start })
+// synthAsm is the special disassembler value used for instructions without an object file.
+const synthAsm = ""
+
+// handleUnprocessed handles addresses that were skipped by splitIntoRanges because they
+// did not belong to a known object file.
+func (sp *sourcePrinter) handleUnprocessed(addrs map[uint64]addrInfo, unprocessed []uint64) {
+	// makeFrames synthesizes a []plugin.Frame list for the specified address.
+	// The result will typically have length 1, but may be longer if address corresponds
+	// to inlined calls.
+	makeFrames := func(addr uint64) []plugin.Frame {
+		loc := addrs[addr].loc
+		stack := make([]plugin.Frame, 0, len(loc.Line))
+		for _, line := range loc.Line {
+			fn := line.Function
+			if fn == nil {
+				continue
+			}
+			stack = append(stack, plugin.Frame{
+				Func: fn.Name,
+				File: fn.Filename,
+				Line: int(line.Line),
+			})
+		}
+		return stack
+	}
 
-	var result []addressRange
-	addrs := make([]uint64, 0, len(set))
-	for addr := range set {
-		addrs = append(addrs, addr)
+	for _, addr := range unprocessed {
+		frames := makeFrames(addr)
+		x := instructionInfo{
+			objAddr: addr,
+			length:  1,
+			disasm:  synthAsm,
+		}
+		if len(frames) > 0 {
+			x.file = frames[0].File
+			x.line = frames[0].Line
+		}
+		sp.insts[addr] = x
+
+		sp.addStack(addr, frames)
+	}
+}
+
+// splitIntoRanges converts the set of addresses we are interested in into a set of address
+// ranges to disassemble. It also returns the set of addresses found that did not have an
+// associated object file and were therefore not added to an address range.
+func (sp *sourcePrinter) splitIntoRanges(prof *profile.Profile, addrMap map[uint64]addrInfo, flat map[uint64]int64) ([]addressRange, []uint64) {
+	// Partition addresses into two sets: ones with a known object file, and ones without.
+	var addrs, unprocessed []uint64
+	for addr, info := range addrMap {
+		if info.obj != nil {
+			addrs = append(addrs, addr)
+		} else {
+			unprocessed = append(unprocessed, addr)
+		}
 	}
 	sort.Slice(addrs, func(i, j int) bool { return addrs[i] < addrs[j] })
 
-	mappingIndex := 0
 	const expand = 500 // How much to expand range to pick up nearby addresses.
+	var result []addressRange
 	for i, n := 0, len(addrs); i < n; {
 		begin, end := addrs[i], addrs[i]
 		sum := flat[begin]
 		i++
 
-		// Advance to mapping containing addrs[i]
-		for mappingIndex < len(mappings) && mappings[mappingIndex].Limit <= begin {
-			mappingIndex++
-		}
-		if mappingIndex >= len(mappings) {
-			// TODO(sanjay): Report missed address and its samples.
-			break
-		}
-		m := mappings[mappingIndex]
-		obj := sp.objectFile(m)
-		if obj == nil {
-			// TODO(sanjay): Report missed address and its samples.
-			continue
-		}
+		info := addrMap[begin]
+		m := info.loc.Mapping
+		obj := info.obj // Non-nil because of the partitioning done above.
 
 		// Find following addresses that are close enough to addrs[i].
 		for i < n && addrs[i] <= end+2*expand && addrs[i] < m.Limit {
@@ -479,7 +542,7 @@ func (sp *sourcePrinter) splitIntoRanges(prof *profile.Profile, set map[uint64]b
 
 		result = append(result, addressRange{begin, end, obj, m, sum})
 	}
-	return result
+	return result, unprocessed
 }
 
 func (sp *sourcePrinter) initSamples(flat, cum map[uint64]int64) {
@@ -665,9 +728,12 @@ func (sp *sourcePrinter) functions(f *sourceFile) []sourceFunction {
 	return funcs
 }
 
-// objectFile return the object for the named file, opening it if necessary.
+// objectFile return the object for the specified mapping, opening it if necessary.
 // It returns nil on error.
 func (sp *sourcePrinter) objectFile(m *profile.Mapping) plugin.ObjFile {
+	if m == nil {
+		return nil
+	}
 	if object, ok := sp.objects[m.File]; ok {
 		return object // May be nil if we detected an error earlier.
 	}
@@ -725,12 +791,28 @@ func printFunctionSourceLine(w io.Writer, lineNo int, flat, cum int64, lineConte
 		return
 	}
 
+	nestedInfo := false
+	cl := "deadsrc"
+	for _, an := range assembly {
+		if len(an.inlineCalls) > 0 || an.instruction != synthAsm {
+			nestedInfo = true
+			cl = "livesrc"
+		}
+	}
+
 	fmt.Fprintf(w,
-		"<span class=line> %6d</span> <span class=deadsrc>  %10s %10s %8s  %s </span>",
-		lineNo,
+		"<span class=line> %6d</span> <span class=%s>  %10s %10s %8s  %s </span>",
+		lineNo, cl,
 		valueOrDot(flat, rpt), valueOrDot(cum, rpt),
 		"", template.HTMLEscapeString(lineContents))
-	srcIndent := indentation(lineContents)
+	if nestedInfo {
+		srcIndent := indentation(lineContents)
+		printNested(w, srcIndent, assembly, reader, rpt)
+	}
+	fmt.Fprintln(w)
+}
+
+func printNested(w io.Writer, srcIndent int, assembly []assemblyInstruction, reader *sourceReader, rpt *Report) {
 	fmt.Fprint(w, "<span class=asm>")
 	var curCalls []callID
 	for i, an := range assembly {
@@ -763,6 +845,9 @@ func printFunctionSourceLine(w io.Writer, lineNo int, flat, cum int64, lineConte
 				template.HTMLEscapeString(filepath.Base(c.file)), c.line)
 		}
 		curCalls = an.inlineCalls
+		if an.instruction == synthAsm {
+			continue
+		}
 		text := strings.Repeat(" ", srcIndent+4+4*len(curCalls)) + an.instruction
 		fmt.Fprintf(w, " %8s %10s %10s %8x: %s <span class=unimportant>%s</span>\n",
 			"", valueOrDot(flat, rpt), valueOrDot(cum, rpt), an.address,
@@ -772,7 +857,7 @@ func printFunctionSourceLine(w io.Writer, lineNo int, flat, cum int64, lineConte
 			// would cause double-escaping of file name.
 			fileline)
 	}
-	fmt.Fprintln(w, "</span>")
+	fmt.Fprint(w, "</span>")
 }
 
 // printFunctionClosing prints the end of a function in a weblist report.
diff --git a/src/cmd/vendor/github.com/google/pprof/internal/report/source_html.go b/src/cmd/vendor/github.com/google/pprof/internal/report/source_html.go
index 26e8bdbba8..17c9f6eb94 100644
--- a/src/cmd/vendor/github.com/google/pprof/internal/report/source_html.go
+++ b/src/cmd/vendor/github.com/google/pprof/internal/report/source_html.go
@@ -40,14 +40,7 @@ h1 {
 .inlinesrc {
   color: #000066;
 }
-.deadsrc {
-cursor: pointer;
-}
-.deadsrc:hover {
-background-color: #eeeeee;
-}
 .livesrc {
-color: #0000ff;
 cursor: pointer;
 }
 .livesrc:hover {
diff --git a/src/cmd/vendor/github.com/google/pprof/internal/report/synth.go b/src/cmd/vendor/github.com/google/pprof/internal/report/synth.go
new file mode 100644
index 0000000000..7a35bbcda8
--- /dev/null
+++ b/src/cmd/vendor/github.com/google/pprof/internal/report/synth.go
@@ -0,0 +1,39 @@
+package report
+
+import (
+	"github.com/google/pprof/profile"
+)
+
+// synthCode assigns addresses to locations without an address.
+type synthCode struct {
+	next uint64
+	addr map[*profile.Location]uint64 // Synthesized address assigned to a location
+}
+
+func newSynthCode(mappings []*profile.Mapping) *synthCode {
+	// Find a larger address than any mapping.
+	s := &synthCode{next: 1}
+	for _, m := range mappings {
+		if s.next < m.Limit {
+			s.next = m.Limit
+		}
+	}
+	return s
+}
+
+// address returns the synthetic address for loc, creating one if needed.
+func (s *synthCode) address(loc *profile.Location) uint64 {
+	if loc.Address != 0 {
+		panic("can only synthesize addresses for locations without an address")
+	}
+	if addr, ok := s.addr[loc]; ok {
+		return addr
+	}
+	if s.addr == nil {
+		s.addr = map[*profile.Location]uint64{}
+	}
+	addr := s.next
+	s.next++
+	s.addr[loc] = addr
+	return addr
+}
diff --git a/src/cmd/vendor/github.com/google/pprof/profile/encode.go b/src/cmd/vendor/github.com/google/pprof/profile/encode.go
index 1e84c72d43..ab7f03ae26 100644
--- a/src/cmd/vendor/github.com/google/pprof/profile/encode.go
+++ b/src/cmd/vendor/github.com/google/pprof/profile/encode.go
@@ -308,7 +308,7 @@ func (p *Profile) postDecode() error {
 			if l.strX != 0 {
 				value, err = getString(p.stringTable, &l.strX, err)
 				labels[key] = append(labels[key], value)
-			} else if l.numX != 0 {
+			} else if l.numX != 0 || l.unitX != 0 {
 				numValues := numLabels[key]
 				units := numUnits[key]
 				if l.unitX != 0 {
diff --git a/src/cmd/vendor/github.com/google/pprof/profile/merge.go b/src/cmd/vendor/github.com/google/pprof/profile/merge.go
index 5ab6e9b9b0..9978e7330e 100644
--- a/src/cmd/vendor/github.com/google/pprof/profile/merge.go
+++ b/src/cmd/vendor/github.com/google/pprof/profile/merge.go
@@ -231,7 +231,6 @@ func (pm *profileMerger) mapLocation(src *Location) *Location {
 	}
 
 	if l, ok := pm.locationsByID[src.ID]; ok {
-		pm.locationsByID[src.ID] = l
 		return l
 	}
 
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 6b19ec3aea..5fb1c25ace 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -1,4 +1,4 @@
-# github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5
+# github.com/google/pprof v0.0.0-20210506205249-923b5ab0fc1a
 ## explicit; go 1.14
 github.com/google/pprof/driver
 github.com/google/pprof/internal/binutils
-- 
GitLab


From b38b1b2f9ae710ee2c16a103bb21644f1adbc5d3 Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Wed, 21 Apr 2021 10:55:42 -0400
Subject: [PATCH 2016/2400] cmd/compile: manage Slot array better

steals idea from CL 312093

further investigation revealed additional duplicate
slots (equivalent, but not equal), so delete those too.

Rearranged Func.Names to be addresses of slots,
create canonical addresses so that split slots
(which use those addresses to refer to their parent,
and split slots can be further split)
will preserve "equivalent slots are equal".

Removes duplicates, improves metrics for "args at entry".

Change-Id: I5bbdcb50bd33655abcab3d27ad8cdce25499faaf
Reviewed-on: https://go-review.googlesource.com/c/go/+/312292
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/config.go       |   7 -
 src/cmd/compile/internal/ssa/copyelim.go     |   2 +-
 src/cmd/compile/internal/ssa/deadcode.go     |   8 +-
 src/cmd/compile/internal/ssa/debug.go        |   6 +-
 src/cmd/compile/internal/ssa/decompose.go    | 140 ++++++++++++-------
 src/cmd/compile/internal/ssa/expand_calls.go |  40 +++---
 src/cmd/compile/internal/ssa/export_test.go  |  30 ----
 src/cmd/compile/internal/ssa/func.go         | 110 ++++++++++++++-
 src/cmd/compile/internal/ssa/layout.go       |  22 +--
 src/cmd/compile/internal/ssa/print.go        |   2 +-
 src/cmd/compile/internal/ssa/stackalloc.go   |  11 +-
 src/cmd/compile/internal/ssagen/ssa.go       |  80 +----------
 12 files changed, 238 insertions(+), 220 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go
index 4ffa047096..a8393a1999 100644
--- a/src/cmd/compile/internal/ssa/config.go
+++ b/src/cmd/compile/internal/ssa/config.go
@@ -147,13 +147,6 @@ type Frontend interface {
 
 	// Given the name for a compound type, returns the name we should use
 	// for the parts of that compound type.
-	SplitString(LocalSlot) (LocalSlot, LocalSlot)
-	SplitInterface(LocalSlot) (LocalSlot, LocalSlot)
-	SplitSlice(LocalSlot) (LocalSlot, LocalSlot, LocalSlot)
-	SplitComplex(LocalSlot) (LocalSlot, LocalSlot)
-	SplitStruct(LocalSlot, int) LocalSlot
-	SplitArray(LocalSlot) LocalSlot              // array must be length 1
-	SplitInt64(LocalSlot) (LocalSlot, LocalSlot) // returns (hi, lo)
 	SplitSlot(parent *LocalSlot, suffix string, offset int64, t *types.Type) LocalSlot
 
 	// DerefItab dereferences an itab function
diff --git a/src/cmd/compile/internal/ssa/copyelim.go b/src/cmd/compile/internal/ssa/copyelim.go
index 5954d3bec8..17f65127ee 100644
--- a/src/cmd/compile/internal/ssa/copyelim.go
+++ b/src/cmd/compile/internal/ssa/copyelim.go
@@ -26,7 +26,7 @@ func copyelim(f *Func) {
 
 	// Update named values.
 	for _, name := range f.Names {
-		values := f.NamedValues[name]
+		values := f.NamedValues[*name]
 		for i, v := range values {
 			if v.Op == OpCopy {
 				values[i] = v.Args[0]
diff --git a/src/cmd/compile/internal/ssa/deadcode.go b/src/cmd/compile/internal/ssa/deadcode.go
index 96b552ecf3..5d10dfe025 100644
--- a/src/cmd/compile/internal/ssa/deadcode.go
+++ b/src/cmd/compile/internal/ssa/deadcode.go
@@ -223,7 +223,7 @@ func deadcode(f *Func) {
 	for _, name := range f.Names {
 		j := 0
 		s.clear()
-		values := f.NamedValues[name]
+		values := f.NamedValues[*name]
 		for _, v := range values {
 			if live[v.ID] && !s.contains(v.ID) {
 				values[j] = v
@@ -232,19 +232,19 @@ func deadcode(f *Func) {
 			}
 		}
 		if j == 0 {
-			delete(f.NamedValues, name)
+			delete(f.NamedValues, *name)
 		} else {
 			f.Names[i] = name
 			i++
 			for k := len(values) - 1; k >= j; k-- {
 				values[k] = nil
 			}
-			f.NamedValues[name] = values[:j]
+			f.NamedValues[*name] = values[:j]
 		}
 	}
 	clearNames := f.Names[i:]
 	for j := range clearNames {
-		clearNames[j] = LocalSlot{}
+		clearNames[j] = nil
 	}
 	f.Names = f.Names[:i]
 
diff --git a/src/cmd/compile/internal/ssa/debug.go b/src/cmd/compile/internal/ssa/debug.go
index 0ca435e515..a2c2a2d98e 100644
--- a/src/cmd/compile/internal/ssa/debug.go
+++ b/src/cmd/compile/internal/ssa/debug.go
@@ -367,12 +367,12 @@ func BuildFuncDebug(ctxt *obj.Link, f *Func, loggingEnabled bool, stackOffset fu
 	state.slots = state.slots[:0]
 	state.vars = state.vars[:0]
 	for i, slot := range f.Names {
-		state.slots = append(state.slots, slot)
+		state.slots = append(state.slots, *slot)
 		if ir.IsSynthetic(slot.N) {
 			continue
 		}
 
-		topSlot := &slot
+		topSlot := slot
 		for topSlot.SplitOf != nil {
 			topSlot = topSlot.SplitOf
 		}
@@ -436,7 +436,7 @@ func BuildFuncDebug(ctxt *obj.Link, f *Func, loggingEnabled bool, stackOffset fu
 		if ir.IsSynthetic(slot.N) {
 			continue
 		}
-		for _, value := range f.NamedValues[slot] {
+		for _, value := range f.NamedValues[*slot] {
 			state.valueNames[value.ID] = append(state.valueNames[value.ID], SlotID(i))
 		}
 	}
diff --git a/src/cmd/compile/internal/ssa/decompose.go b/src/cmd/compile/internal/ssa/decompose.go
index ba48b6b3b9..753d69cebc 100644
--- a/src/cmd/compile/internal/ssa/decompose.go
+++ b/src/cmd/compile/internal/ssa/decompose.go
@@ -36,64 +36,65 @@ func decomposeBuiltIn(f *Func) {
 	// accumulate new LocalSlots in newNames for addition after the iteration.  This decomposition is for
 	// builtin types with leaf components, and thus there is no need to reprocess the newly create LocalSlots.
 	var toDelete []namedVal
-	var newNames []LocalSlot
+	var newNames []*LocalSlot
 	for i, name := range f.Names {
 		t := name.Type
 		switch {
 		case t.IsInteger() && t.Size() > f.Config.RegSize:
-			hiName, loName := f.fe.SplitInt64(name)
-			newNames = append(newNames, hiName, loName)
-			for j, v := range f.NamedValues[name] {
+			hiName, loName := f.SplitInt64(name)
+			newNames = maybeAppend2(f, newNames, hiName, loName)
+			for j, v := range f.NamedValues[*name] {
 				if v.Op != OpInt64Make {
 					continue
 				}
-				f.NamedValues[hiName] = append(f.NamedValues[hiName], v.Args[0])
-				f.NamedValues[loName] = append(f.NamedValues[loName], v.Args[1])
+				f.NamedValues[*hiName] = append(f.NamedValues[*hiName], v.Args[0])
+				f.NamedValues[*loName] = append(f.NamedValues[*loName], v.Args[1])
 				toDelete = append(toDelete, namedVal{i, j})
 			}
 		case t.IsComplex():
-			rName, iName := f.fe.SplitComplex(name)
-			newNames = append(newNames, rName, iName)
-			for j, v := range f.NamedValues[name] {
+			rName, iName := f.SplitComplex(name)
+			newNames = maybeAppend2(f, newNames, rName, iName)
+			for j, v := range f.NamedValues[*name] {
 				if v.Op != OpComplexMake {
 					continue
 				}
-				f.NamedValues[rName] = append(f.NamedValues[rName], v.Args[0])
-				f.NamedValues[iName] = append(f.NamedValues[iName], v.Args[1])
+				f.NamedValues[*rName] = append(f.NamedValues[*rName], v.Args[0])
+				f.NamedValues[*iName] = append(f.NamedValues[*iName], v.Args[1])
 				toDelete = append(toDelete, namedVal{i, j})
 			}
 		case t.IsString():
-			ptrName, lenName := f.fe.SplitString(name)
-			newNames = append(newNames, ptrName, lenName)
-			for j, v := range f.NamedValues[name] {
+			ptrName, lenName := f.SplitString(name)
+			newNames = maybeAppend2(f, newNames, ptrName, lenName)
+			for j, v := range f.NamedValues[*name] {
 				if v.Op != OpStringMake {
 					continue
 				}
-				f.NamedValues[ptrName] = append(f.NamedValues[ptrName], v.Args[0])
-				f.NamedValues[lenName] = append(f.NamedValues[lenName], v.Args[1])
+				f.NamedValues[*ptrName] = append(f.NamedValues[*ptrName], v.Args[0])
+				f.NamedValues[*lenName] = append(f.NamedValues[*lenName], v.Args[1])
 				toDelete = append(toDelete, namedVal{i, j})
 			}
 		case t.IsSlice():
-			ptrName, lenName, capName := f.fe.SplitSlice(name)
-			newNames = append(newNames, ptrName, lenName, capName)
-			for j, v := range f.NamedValues[name] {
+			ptrName, lenName, capName := f.SplitSlice(name)
+			newNames = maybeAppend2(f, newNames, ptrName, lenName)
+			newNames = maybeAppend(f, newNames, capName)
+			for j, v := range f.NamedValues[*name] {
 				if v.Op != OpSliceMake {
 					continue
 				}
-				f.NamedValues[ptrName] = append(f.NamedValues[ptrName], v.Args[0])
-				f.NamedValues[lenName] = append(f.NamedValues[lenName], v.Args[1])
-				f.NamedValues[capName] = append(f.NamedValues[capName], v.Args[2])
+				f.NamedValues[*ptrName] = append(f.NamedValues[*ptrName], v.Args[0])
+				f.NamedValues[*lenName] = append(f.NamedValues[*lenName], v.Args[1])
+				f.NamedValues[*capName] = append(f.NamedValues[*capName], v.Args[2])
 				toDelete = append(toDelete, namedVal{i, j})
 			}
 		case t.IsInterface():
-			typeName, dataName := f.fe.SplitInterface(name)
-			newNames = append(newNames, typeName, dataName)
-			for j, v := range f.NamedValues[name] {
+			typeName, dataName := f.SplitInterface(name)
+			newNames = maybeAppend2(f, newNames, typeName, dataName)
+			for j, v := range f.NamedValues[*name] {
 				if v.Op != OpIMake {
 					continue
 				}
-				f.NamedValues[typeName] = append(f.NamedValues[typeName], v.Args[0])
-				f.NamedValues[dataName] = append(f.NamedValues[dataName], v.Args[1])
+				f.NamedValues[*typeName] = append(f.NamedValues[*typeName], v.Args[0])
+				f.NamedValues[*dataName] = append(f.NamedValues[*dataName], v.Args[1])
 				toDelete = append(toDelete, namedVal{i, j})
 			}
 		case t.IsFloat():
@@ -107,6 +108,18 @@ func decomposeBuiltIn(f *Func) {
 	f.Names = append(f.Names, newNames...)
 }
 
+func maybeAppend(f *Func, ss []*LocalSlot, s *LocalSlot) []*LocalSlot {
+	if _, ok := f.NamedValues[*s]; !ok {
+		f.NamedValues[*s] = nil
+		return append(ss, s)
+	}
+	return ss
+}
+
+func maybeAppend2(f *Func, ss []*LocalSlot, s1, s2 *LocalSlot) []*LocalSlot {
+	return maybeAppend(f, maybeAppend(f, ss, s1), s2)
+}
+
 func decomposeBuiltInPhi(v *Value) {
 	switch {
 	case v.Type.IsInteger() && v.Type.Size() > v.Block.Func.Config.RegSize:
@@ -230,7 +243,7 @@ func decomposeUser(f *Func) {
 	}
 	// Split up named values into their components.
 	i := 0
-	var newNames []LocalSlot
+	var newNames []*LocalSlot
 	for _, name := range f.Names {
 		t := name.Type
 		switch {
@@ -250,7 +263,7 @@ func decomposeUser(f *Func) {
 // decomposeUserArrayInto creates names for the element(s) of arrays referenced
 // by name where possible, and appends those new names to slots, which is then
 // returned.
-func decomposeUserArrayInto(f *Func, name LocalSlot, slots []LocalSlot) []LocalSlot {
+func decomposeUserArrayInto(f *Func, name *LocalSlot, slots []*LocalSlot) []*LocalSlot {
 	t := name.Type
 	if t.NumElem() == 0 {
 		// TODO(khr): Not sure what to do here.  Probably nothing.
@@ -261,20 +274,20 @@ func decomposeUserArrayInto(f *Func, name LocalSlot, slots []LocalSlot) []LocalS
 		// shouldn't get here due to CanSSA
 		f.Fatalf("array not of size 1")
 	}
-	elemName := f.fe.SplitArray(name)
+	elemName := f.SplitArray(name)
 	var keep []*Value
-	for _, v := range f.NamedValues[name] {
+	for _, v := range f.NamedValues[*name] {
 		if v.Op != OpArrayMake1 {
 			keep = append(keep, v)
 			continue
 		}
-		f.NamedValues[elemName] = append(f.NamedValues[elemName], v.Args[0])
+		f.NamedValues[*elemName] = append(f.NamedValues[*elemName], v.Args[0])
 	}
 	if len(keep) == 0 {
 		// delete the name for the array as a whole
-		delete(f.NamedValues, name)
+		delete(f.NamedValues, *name)
 	} else {
-		f.NamedValues[name] = keep
+		f.NamedValues[*name] = keep
 	}
 
 	if t.Elem().IsArray() {
@@ -289,38 +302,38 @@ func decomposeUserArrayInto(f *Func, name LocalSlot, slots []LocalSlot) []LocalS
 // decomposeUserStructInto creates names for the fields(s) of structs referenced
 // by name where possible, and appends those new names to slots, which is then
 // returned.
-func decomposeUserStructInto(f *Func, name LocalSlot, slots []LocalSlot) []LocalSlot {
-	fnames := []LocalSlot{} // slots for struct in name
+func decomposeUserStructInto(f *Func, name *LocalSlot, slots []*LocalSlot) []*LocalSlot {
+	fnames := []*LocalSlot{} // slots for struct in name
 	t := name.Type
 	n := t.NumFields()
 
 	for i := 0; i < n; i++ {
-		fs := f.fe.SplitStruct(name, i)
+		fs := f.SplitStruct(name, i)
 		fnames = append(fnames, fs)
 		// arrays and structs will be decomposed further, so
 		// there's no need to record a name
 		if !fs.Type.IsArray() && !fs.Type.IsStruct() {
-			slots = append(slots, fs)
+			slots = maybeAppend(f, slots, fs)
 		}
 	}
 
 	makeOp := StructMakeOp(n)
 	var keep []*Value
 	// create named values for each struct field
-	for _, v := range f.NamedValues[name] {
+	for _, v := range f.NamedValues[*name] {
 		if v.Op != makeOp {
 			keep = append(keep, v)
 			continue
 		}
 		for i := 0; i < len(fnames); i++ {
-			f.NamedValues[fnames[i]] = append(f.NamedValues[fnames[i]], v.Args[i])
+			f.NamedValues[*fnames[i]] = append(f.NamedValues[*fnames[i]], v.Args[i])
 		}
 	}
 	if len(keep) == 0 {
 		// delete the name for the struct as a whole
-		delete(f.NamedValues, name)
+		delete(f.NamedValues, *name)
 	} else {
-		f.NamedValues[name] = keep
+		f.NamedValues[*name] = keep
 	}
 
 	// now that this f.NamedValues contains values for the struct
@@ -328,10 +341,10 @@ func decomposeUserStructInto(f *Func, name LocalSlot, slots []LocalSlot) []Local
 	for i := 0; i < n; i++ {
 		if name.Type.FieldType(i).IsStruct() {
 			slots = decomposeUserStructInto(f, fnames[i], slots)
-			delete(f.NamedValues, fnames[i])
+			delete(f.NamedValues, *fnames[i])
 		} else if name.Type.FieldType(i).IsArray() {
 			slots = decomposeUserArrayInto(f, fnames[i], slots)
-			delete(f.NamedValues, fnames[i])
+			delete(f.NamedValues, *fnames[i])
 		}
 	}
 	return slots
@@ -416,9 +429,10 @@ type namedVal struct {
 	locIndex, valIndex int // f.NamedValues[f.Names[locIndex]][valIndex] = key
 }
 
-// deleteNamedVals removes particular values with debugger names from f's naming data structures
+// deleteNamedVals removes particular values with debugger names from f's naming data structures,
+// removes all values with OpInvalid, and re-sorts the list of Names.
 func deleteNamedVals(f *Func, toDelete []namedVal) {
-	// Arrange to delete from larger indices to smaller, to ensure swap-with-end deletion does not invalid pending indices.
+	// Arrange to delete from larger indices to smaller, to ensure swap-with-end deletion does not invalidate pending indices.
 	sort.Slice(toDelete, func(i, j int) bool {
 		if toDelete[i].locIndex != toDelete[j].locIndex {
 			return toDelete[i].locIndex > toDelete[j].locIndex
@@ -430,16 +444,36 @@ func deleteNamedVals(f *Func, toDelete []namedVal) {
 	// Get rid of obsolete names
 	for _, d := range toDelete {
 		loc := f.Names[d.locIndex]
-		vals := f.NamedValues[loc]
+		vals := f.NamedValues[*loc]
 		l := len(vals) - 1
 		if l > 0 {
 			vals[d.valIndex] = vals[l]
-			f.NamedValues[loc] = vals[:l]
-		} else {
-			delete(f.NamedValues, loc)
-			l = len(f.Names) - 1
-			f.Names[d.locIndex] = f.Names[l]
-			f.Names = f.Names[:l]
+		}
+		vals[l] = nil
+		f.NamedValues[*loc] = vals[:l]
+	}
+	// Delete locations with no values attached.
+	end := len(f.Names)
+	for i := len(f.Names) - 1; i >= 0; i-- {
+		loc := f.Names[i]
+		vals := f.NamedValues[*loc]
+		last := len(vals)
+		for j := len(vals) - 1; j >= 0; j-- {
+			if vals[j].Op == OpInvalid {
+				last--
+				vals[j] = vals[last]
+				vals[last] = nil
+			}
+		}
+		if last < len(vals) {
+			f.NamedValues[*loc] = vals[:last]
+		}
+		if len(vals) == 0 {
+			delete(f.NamedValues, *loc)
+			end--
+			f.Names[i] = f.Names[end]
+			f.Names[end] = nil
 		}
 	}
+	f.Names = f.Names[:end]
 }
diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index 2852753bee..d37d06f8e7 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -243,10 +243,10 @@ func (x *expandState) offsetFrom(b *Block, from *Value, offset int64, pt *types.
 }
 
 // splitSlots splits one "field" (specified by sfx, offset, and ty) out of the LocalSlots in ls and returns the new LocalSlots this generates.
-func (x *expandState) splitSlots(ls []LocalSlot, sfx string, offset int64, ty *types.Type) []LocalSlot {
-	var locs []LocalSlot
+func (x *expandState) splitSlots(ls []*LocalSlot, sfx string, offset int64, ty *types.Type) []*LocalSlot {
+	var locs []*LocalSlot
 	for i := range ls {
-		locs = append(locs, x.f.fe.SplitSlot(&ls[i], sfx, offset, ty))
+		locs = append(locs, x.f.SplitSlot(ls[i], sfx, offset, ty))
 	}
 	return locs
 }
@@ -301,13 +301,13 @@ func (x *expandState) Printf(format string, a ...interface{}) (n int, err error)
 // It emits the code necessary to implement the leaf select operation that leads to the root.
 //
 // TODO when registers really arrive, must also decompose anything split across two registers or registers and memory.
-func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64, regOffset Abi1RO) []LocalSlot {
+func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64, regOffset Abi1RO) []*LocalSlot {
 	if x.debug {
 		x.indent(3)
 		defer x.indent(-3)
 		x.Printf("rewriteSelect(%s; %s; memOff=%d; regOff=%d)\n", leaf.LongString(), selector.LongString(), offset, regOffset)
 	}
-	var locs []LocalSlot
+	var locs []*LocalSlot
 	leafType := leaf.Type
 	if len(selector.Args) > 0 {
 		w := selector.Args[0]
@@ -477,7 +477,7 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64,
 
 	case OpStructSelect:
 		w := selector.Args[0]
-		var ls []LocalSlot
+		var ls []*LocalSlot
 		if w.Type.Kind() != types.TSTRUCT { // IData artifact
 			ls = x.rewriteSelect(leaf, w, offset, regOffset)
 		} else {
@@ -485,7 +485,7 @@ func (x *expandState) rewriteSelect(leaf *Value, selector *Value, offset int64,
 			ls = x.rewriteSelect(leaf, w, offset+w.Type.FieldOff(fldi), regOffset+x.regOffset(w.Type, fldi))
 			if w.Op != OpIData {
 				for _, l := range ls {
-					locs = append(locs, x.f.fe.SplitStruct(l, int(selector.AuxInt)))
+					locs = append(locs, x.f.SplitStruct(l, int(selector.AuxInt)))
 				}
 			}
 		}
@@ -662,7 +662,7 @@ outer:
 func (x *expandState) decomposeArg(pos src.XPos, b *Block, source, mem *Value, t *types.Type, storeOffset int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
 
 	pa := x.prAssignForArg(source)
-	var locs []LocalSlot
+	var locs []*LocalSlot
 	for _, s := range x.namedSelects[source] {
 		locs = append(locs, x.f.Names[s.locIndex])
 	}
@@ -756,12 +756,15 @@ func (x *expandState) decomposeArg(pos src.XPos, b *Block, source, mem *Value, t
 	return nil
 }
 
-func (x *expandState) splitSlotsIntoNames(locs []LocalSlot, suffix string, off int64, rt *types.Type, w *Value) {
+func (x *expandState) splitSlotsIntoNames(locs []*LocalSlot, suffix string, off int64, rt *types.Type, w *Value) {
 	wlocs := x.splitSlots(locs, suffix, off, rt)
 	for _, l := range wlocs {
-		x.f.NamedValues[l] = append(x.f.NamedValues[l], w)
+		old, ok := x.f.NamedValues[*l]
+		x.f.NamedValues[*l] = append(old, w)
+		if !ok {
+			x.f.Names = append(x.f.Names, l)
+		}
 	}
-	x.f.Names = append(x.f.Names, wlocs...)
 }
 
 // decomposeLoad is a helper for storeArgOrLoad.
@@ -826,7 +829,7 @@ func (x *expandState) decomposeLoad(pos src.XPos, b *Block, source, mem *Value,
 // storeOneArg creates a decomposed (one step) arg that is then stored.
 // pos and b locate the store instruction, source is the "base" of the value input,
 // mem is the input mem, t is the type in question, and offArg and offStore are the offsets from the respective bases.
-func storeOneArg(x *expandState, pos src.XPos, b *Block, locs []LocalSlot, suffix string, source, mem *Value, t *types.Type, argOffset, storeOffset int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
+func storeOneArg(x *expandState, pos src.XPos, b *Block, locs []*LocalSlot, suffix string, source, mem *Value, t *types.Type, argOffset, storeOffset int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
 	if x.debug {
 		x.indent(3)
 		defer x.indent(-3)
@@ -848,7 +851,7 @@ func storeOneLoad(x *expandState, pos src.XPos, b *Block, source, mem *Value, t
 	return x.storeArgOrLoad(pos, b, w, mem, t, offStore, loadRegOffset, storeRc)
 }
 
-func storeTwoArg(x *expandState, pos src.XPos, b *Block, locs []LocalSlot, suffix1 string, suffix2 string, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
+func storeTwoArg(x *expandState, pos src.XPos, b *Block, locs []*LocalSlot, suffix1 string, suffix2 string, source, mem *Value, t1, t2 *types.Type, offArg, offStore int64, loadRegOffset Abi1RO, storeRc registerCursor) *Value {
 	mem = storeOneArg(x, pos, b, locs, suffix1, source, mem, t1, offArg, offStore, loadRegOffset, storeRc.next(t1))
 	pos = pos.WithNotStmt()
 	t1Size := t1.Size()
@@ -1168,7 +1171,7 @@ func expandCalls(f *Func) {
 	for i, name := range f.Names {
 		t := name.Type
 		if x.isAlreadyExpandedAggregateType(t) {
-			for j, v := range f.NamedValues[name] {
+			for j, v := range f.NamedValues[*name] {
 				if v.Op == OpSelectN || v.Op == OpArg && x.isAlreadyExpandedAggregateType(v.Type) {
 					ns := x.namedSelects[v]
 					x.namedSelects[v] = append(ns, namedVal{locIndex: i, valIndex: j})
@@ -1477,10 +1480,10 @@ func expandCalls(f *Func) {
 		// Leaf types may have debug locations
 		if !x.isAlreadyExpandedAggregateType(v.Type) {
 			for _, l := range locs {
-				if _, ok := f.NamedValues[l]; !ok {
+				if _, ok := f.NamedValues[*l]; !ok {
 					f.Names = append(f.Names, l)
 				}
-				f.NamedValues[l] = append(f.NamedValues[l], v)
+				f.NamedValues[*l] = append(f.NamedValues[*l], v)
 			}
 			continue
 		}
@@ -1553,7 +1556,7 @@ func expandCalls(f *Func) {
 	// Step 6: elide any copies introduced.
 	// Update named values.
 	for _, name := range f.Names {
-		values := f.NamedValues[name]
+		values := f.NamedValues[*name]
 		for i, v := range values {
 			if v.Op == OpCopy {
 				a := v.Args[0]
@@ -1725,7 +1728,8 @@ func (x *expandState) newArgToMemOrRegs(baseArg, toReplace *Value, offset int64,
 		loc := LocalSlot{N: aux.Name, Type: t, Off: 0}
 		values, ok := x.f.NamedValues[loc]
 		if !ok {
-			x.f.Names = append(x.f.Names, loc)
+			ploc := x.f.localSlotAddr(loc)
+			x.f.Names = append(x.f.Names, ploc)
 		}
 		x.f.NamedValues[loc] = append(values, w)
 	}
diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go
index 32e6d09d1b..8ed8a0c4a6 100644
--- a/src/cmd/compile/internal/ssa/export_test.go
+++ b/src/cmd/compile/internal/ssa/export_test.go
@@ -73,36 +73,6 @@ func (TestFrontend) Auto(pos src.XPos, t *types.Type) *ir.Name {
 	n.Class = ir.PAUTO
 	return n
 }
-func (d TestFrontend) SplitString(s LocalSlot) (LocalSlot, LocalSlot) {
-	return LocalSlot{N: s.N, Type: testTypes.BytePtr, Off: s.Off}, LocalSlot{N: s.N, Type: testTypes.Int, Off: s.Off + 8}
-}
-func (d TestFrontend) SplitInterface(s LocalSlot) (LocalSlot, LocalSlot) {
-	return LocalSlot{N: s.N, Type: testTypes.BytePtr, Off: s.Off}, LocalSlot{N: s.N, Type: testTypes.BytePtr, Off: s.Off + 8}
-}
-func (d TestFrontend) SplitSlice(s LocalSlot) (LocalSlot, LocalSlot, LocalSlot) {
-	return LocalSlot{N: s.N, Type: s.Type.Elem().PtrTo(), Off: s.Off},
-		LocalSlot{N: s.N, Type: testTypes.Int, Off: s.Off + 8},
-		LocalSlot{N: s.N, Type: testTypes.Int, Off: s.Off + 16}
-}
-func (d TestFrontend) SplitComplex(s LocalSlot) (LocalSlot, LocalSlot) {
-	if s.Type.Size() == 16 {
-		return LocalSlot{N: s.N, Type: testTypes.Float64, Off: s.Off}, LocalSlot{N: s.N, Type: testTypes.Float64, Off: s.Off + 8}
-	}
-	return LocalSlot{N: s.N, Type: testTypes.Float32, Off: s.Off}, LocalSlot{N: s.N, Type: testTypes.Float32, Off: s.Off + 4}
-}
-func (d TestFrontend) SplitInt64(s LocalSlot) (LocalSlot, LocalSlot) {
-	if s.Type.IsSigned() {
-		return LocalSlot{N: s.N, Type: testTypes.Int32, Off: s.Off + 4}, LocalSlot{N: s.N, Type: testTypes.UInt32, Off: s.Off}
-	}
-	return LocalSlot{N: s.N, Type: testTypes.UInt32, Off: s.Off + 4}, LocalSlot{N: s.N, Type: testTypes.UInt32, Off: s.Off}
-}
-func (d TestFrontend) SplitStruct(s LocalSlot, i int) LocalSlot {
-	return LocalSlot{N: s.N, Type: s.Type.FieldType(i), Off: s.Off + s.Type.FieldOff(i)}
-}
-func (d TestFrontend) SplitArray(s LocalSlot) LocalSlot {
-	return LocalSlot{N: s.N, Type: s.Type.Elem(), Off: s.Off}
-}
-
 func (d TestFrontend) SplitSlot(parent *LocalSlot, suffix string, offset int64, t *types.Type) LocalSlot {
 	return LocalSlot{N: parent.N, Type: t, Off: offset}
 }
diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go
index 378a73a95a..fac876c23e 100644
--- a/src/cmd/compile/internal/ssa/func.go
+++ b/src/cmd/compile/internal/ssa/func.go
@@ -6,6 +6,7 @@ package ssa
 
 import (
 	"cmd/compile/internal/abi"
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
 	"cmd/internal/src"
 	"crypto/sha1"
@@ -61,7 +62,11 @@ type Func struct {
 	NamedValues map[LocalSlot][]*Value
 	// Names is a copy of NamedValues.Keys. We keep a separate list
 	// of keys to make iteration order deterministic.
-	Names []LocalSlot
+	Names []*LocalSlot
+	// Canonicalize root/top-level local slots, and canonicalize their pieces.
+	// Because LocalSlot pieces refer to their parents with a pointer, this ensures that equivalent slots really are equal.
+	CanonicalLocalSlots  map[LocalSlot]*LocalSlot
+	CanonicalLocalSplits map[LocalSlotSplitKey]*LocalSlot
 
 	// RegArgs is a slice of register-memory pairs that must be spilled and unspilled in the uncommon path of function entry.
 	RegArgs []Spill
@@ -87,10 +92,16 @@ type Func struct {
 	constants map[int64][]*Value // constants cache, keyed by constant value; users must check value's Op and Type
 }
 
+type LocalSlotSplitKey struct {
+	parent *LocalSlot
+	Off    int64       // offset of slot in N
+	Type   *types.Type // type of slot
+}
+
 // NewFunc returns a new, empty function object.
 // Caller must set f.Config and f.Cache before using f.
 func NewFunc(fe Frontend) *Func {
-	return &Func{fe: fe, NamedValues: make(map[LocalSlot][]*Value)}
+	return &Func{fe: fe, NamedValues: make(map[LocalSlot][]*Value), CanonicalLocalSlots: make(map[LocalSlot]*LocalSlot), CanonicalLocalSplits: make(map[LocalSlotSplitKey]*LocalSlot)}
 }
 
 // NumBlocks returns an integer larger than the id of any Block in the Func.
@@ -193,6 +204,101 @@ func (f *Func) retDeadcodeLiveOrderStmts(liveOrderStmts []*Value) {
 	f.Cache.deadcode.liveOrderStmts = liveOrderStmts
 }
 
+func (f *Func) localSlotAddr(slot LocalSlot) *LocalSlot {
+	a, ok := f.CanonicalLocalSlots[slot]
+	if !ok {
+		a = new(LocalSlot)
+		*a = slot // don't escape slot
+		f.CanonicalLocalSlots[slot] = a
+	}
+	return a
+}
+
+func (f *Func) SplitString(name *LocalSlot) (*LocalSlot, *LocalSlot) {
+	ptrType := types.NewPtr(types.Types[types.TUINT8])
+	lenType := types.Types[types.TINT]
+	// Split this string up into two separate variables.
+	p := f.SplitSlot(name, ".ptr", 0, ptrType)
+	l := f.SplitSlot(name, ".len", ptrType.Size(), lenType)
+	return p, l
+}
+
+func (f *Func) SplitInterface(name *LocalSlot) (*LocalSlot, *LocalSlot) {
+	n := name.N
+	u := types.Types[types.TUINTPTR]
+	t := types.NewPtr(types.Types[types.TUINT8])
+	// Split this interface up into two separate variables.
+	sfx := ".itab"
+	if n.Type().IsEmptyInterface() {
+		sfx = ".type"
+	}
+	c := f.SplitSlot(name, sfx, 0, u) // see comment in typebits.Set
+	d := f.SplitSlot(name, ".data", u.Size(), t)
+	return c, d
+}
+
+func (f *Func) SplitSlice(name *LocalSlot) (*LocalSlot, *LocalSlot, *LocalSlot) {
+	ptrType := types.NewPtr(name.Type.Elem())
+	lenType := types.Types[types.TINT]
+	p := f.SplitSlot(name, ".ptr", 0, ptrType)
+	l := f.SplitSlot(name, ".len", ptrType.Size(), lenType)
+	c := f.SplitSlot(name, ".cap", ptrType.Size()+lenType.Size(), lenType)
+	return p, l, c
+}
+
+func (f *Func) SplitComplex(name *LocalSlot) (*LocalSlot, *LocalSlot) {
+	s := name.Type.Size() / 2
+	var t *types.Type
+	if s == 8 {
+		t = types.Types[types.TFLOAT64]
+	} else {
+		t = types.Types[types.TFLOAT32]
+	}
+	r := f.SplitSlot(name, ".real", 0, t)
+	i := f.SplitSlot(name, ".imag", t.Size(), t)
+	return r, i
+}
+
+func (f *Func) SplitInt64(name *LocalSlot) (*LocalSlot, *LocalSlot) {
+	var t *types.Type
+	if name.Type.IsSigned() {
+		t = types.Types[types.TINT32]
+	} else {
+		t = types.Types[types.TUINT32]
+	}
+	if f.Config.BigEndian {
+		return f.SplitSlot(name, ".hi", 0, t), f.SplitSlot(name, ".lo", t.Size(), types.Types[types.TUINT32])
+	}
+	return f.SplitSlot(name, ".hi", t.Size(), t), f.SplitSlot(name, ".lo", 0, types.Types[types.TUINT32])
+}
+
+func (f *Func) SplitStruct(name *LocalSlot, i int) *LocalSlot {
+	st := name.Type
+	return f.SplitSlot(name, st.FieldName(i), st.FieldOff(i), st.FieldType(i))
+}
+func (f *Func) SplitArray(name *LocalSlot) *LocalSlot {
+	n := name.N
+	at := name.Type
+	if at.NumElem() != 1 {
+		base.FatalfAt(n.Pos(), "bad array size")
+	}
+	et := at.Elem()
+	return f.SplitSlot(name, "[0]", 0, et)
+}
+
+func (f *Func) SplitSlot(name *LocalSlot, sfx string, offset int64, t *types.Type) *LocalSlot {
+	lssk := LocalSlotSplitKey{name, offset, t}
+	if als, ok := f.CanonicalLocalSplits[lssk]; ok {
+		return als
+	}
+	// Note: the _ field may appear several times.  But
+	// have no fear, identically-named but distinct Autos are
+	// ok, albeit maybe confusing for a debugger.
+	ls := f.fe.SplitSlot(name, sfx, offset, t)
+	f.CanonicalLocalSplits[lssk] = &ls
+	return &ls
+}
+
 // newValue allocates a new Value with the given fields and places it at the end of b.Values.
 func (f *Func) newValue(op Op, t *types.Type, b *Block, pos src.XPos) *Value {
 	var v *Value
diff --git a/src/cmd/compile/internal/ssa/layout.go b/src/cmd/compile/internal/ssa/layout.go
index a7fd73aead..6abdb0d0c9 100644
--- a/src/cmd/compile/internal/ssa/layout.go
+++ b/src/cmd/compile/internal/ssa/layout.go
@@ -12,26 +12,10 @@ func layout(f *Func) {
 }
 
 // Register allocation may use a different order which has constraints
-// imposed by the linear-scan algorithm. Note that f.pass here is
-// regalloc, so the switch is conditional on -d=ssa/regalloc/test=N
+// imposed by the linear-scan algorithm.
 func layoutRegallocOrder(f *Func) []*Block {
-
-	switch f.pass.test {
-	case 0: // layout order
-		return layoutOrder(f)
-	case 1: // existing block order
-		return f.Blocks
-	case 2: // reverse of postorder; legal, but usually not good.
-		po := f.postorder()
-		visitOrder := make([]*Block, len(po))
-		for i, b := range po {
-			j := len(po) - i - 1
-			visitOrder[j] = b
-		}
-		return visitOrder
-	}
-
-	return nil
+	// remnant of an experiment; perhaps there will be another.
+	return layoutOrder(f)
 }
 
 func layoutOrder(f *Func) []*Block {
diff --git a/src/cmd/compile/internal/ssa/print.go b/src/cmd/compile/internal/ssa/print.go
index 36f09c3ad9..d917183c70 100644
--- a/src/cmd/compile/internal/ssa/print.go
+++ b/src/cmd/compile/internal/ssa/print.go
@@ -154,6 +154,6 @@ func fprintFunc(p funcPrinter, f *Func) {
 		p.endBlock(b)
 	}
 	for _, name := range f.Names {
-		p.named(name, f.NamedValues[name])
+		p.named(*name, f.NamedValues[*name])
 	}
 }
diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go
index d962579122..d41f3996af 100644
--- a/src/cmd/compile/internal/ssa/stackalloc.go
+++ b/src/cmd/compile/internal/ssa/stackalloc.go
@@ -141,10 +141,11 @@ func (s *stackAllocState) stackalloc() {
 		s.names = make([]LocalSlot, n)
 	}
 	names := s.names
+	empty := LocalSlot{}
 	for _, name := range f.Names {
 		// Note: not "range f.NamedValues" above, because
 		// that would be nondeterministic.
-		for _, v := range f.NamedValues[name] {
+		for _, v := range f.NamedValues[*name] {
 			if v.Op == OpArgIntReg || v.Op == OpArgFloatReg {
 				aux := v.Aux.(*AuxNameOffset)
 				// Never let an arg be bound to a differently named thing.
@@ -162,10 +163,12 @@ func (s *stackAllocState) stackalloc() {
 				continue
 			}
 
-			if f.pass.debug > stackDebug {
-				fmt.Printf("stackalloc value %s to name %s\n", v, name)
+			if names[v.ID] == empty {
+				if f.pass.debug > stackDebug {
+					fmt.Printf("stackalloc value %s to name %s\n", v, *name)
+				}
+				names[v.ID] = *name
 			}
-			names[v.ID] = name
 		}
 	}
 
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 2abd70169e..004e084f72 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -8,7 +8,6 @@ import (
 	"bufio"
 	"bytes"
 	"cmd/compile/internal/abi"
-	"encoding/binary"
 	"fmt"
 	"go/constant"
 	"html"
@@ -6463,7 +6462,8 @@ func (s *state) addNamedValue(n *ir.Name, v *ssa.Value) {
 	loc := ssa.LocalSlot{N: n, Type: n.Type(), Off: 0}
 	values, ok := s.f.NamedValues[loc]
 	if !ok {
-		s.f.Names = append(s.f.Names, loc)
+		s.f.Names = append(s.f.Names, &loc)
+		s.f.CanonicalLocalSlots[loc] = &loc
 	}
 	s.f.NamedValues[loc] = append(values, v)
 }
@@ -7552,82 +7552,6 @@ func (e *ssafn) Auto(pos src.XPos, t *types.Type) *ir.Name {
 	return typecheck.TempAt(pos, e.curfn, t) // Note: adds new auto to e.curfn.Func.Dcl list
 }
 
-func (e *ssafn) SplitString(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot) {
-	ptrType := types.NewPtr(types.Types[types.TUINT8])
-	lenType := types.Types[types.TINT]
-	// Split this string up into two separate variables.
-	p := e.SplitSlot(&name, ".ptr", 0, ptrType)
-	l := e.SplitSlot(&name, ".len", ptrType.Size(), lenType)
-	return p, l
-}
-
-func (e *ssafn) SplitInterface(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot) {
-	n := name.N
-	u := types.Types[types.TUINTPTR]
-	t := types.NewPtr(types.Types[types.TUINT8])
-	// Split this interface up into two separate variables.
-	f := ".itab"
-	if n.Type().IsEmptyInterface() {
-		f = ".type"
-	}
-	c := e.SplitSlot(&name, f, 0, u) // see comment in typebits.Set
-	d := e.SplitSlot(&name, ".data", u.Size(), t)
-	return c, d
-}
-
-func (e *ssafn) SplitSlice(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot, ssa.LocalSlot) {
-	ptrType := types.NewPtr(name.Type.Elem())
-	lenType := types.Types[types.TINT]
-	p := e.SplitSlot(&name, ".ptr", 0, ptrType)
-	l := e.SplitSlot(&name, ".len", ptrType.Size(), lenType)
-	c := e.SplitSlot(&name, ".cap", ptrType.Size()+lenType.Size(), lenType)
-	return p, l, c
-}
-
-func (e *ssafn) SplitComplex(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot) {
-	s := name.Type.Size() / 2
-	var t *types.Type
-	if s == 8 {
-		t = types.Types[types.TFLOAT64]
-	} else {
-		t = types.Types[types.TFLOAT32]
-	}
-	r := e.SplitSlot(&name, ".real", 0, t)
-	i := e.SplitSlot(&name, ".imag", t.Size(), t)
-	return r, i
-}
-
-func (e *ssafn) SplitInt64(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot) {
-	var t *types.Type
-	if name.Type.IsSigned() {
-		t = types.Types[types.TINT32]
-	} else {
-		t = types.Types[types.TUINT32]
-	}
-	if Arch.LinkArch.ByteOrder == binary.BigEndian {
-		return e.SplitSlot(&name, ".hi", 0, t), e.SplitSlot(&name, ".lo", t.Size(), types.Types[types.TUINT32])
-	}
-	return e.SplitSlot(&name, ".hi", t.Size(), t), e.SplitSlot(&name, ".lo", 0, types.Types[types.TUINT32])
-}
-
-func (e *ssafn) SplitStruct(name ssa.LocalSlot, i int) ssa.LocalSlot {
-	st := name.Type
-	// Note: the _ field may appear several times.  But
-	// have no fear, identically-named but distinct Autos are
-	// ok, albeit maybe confusing for a debugger.
-	return e.SplitSlot(&name, "."+st.FieldName(i), st.FieldOff(i), st.FieldType(i))
-}
-
-func (e *ssafn) SplitArray(name ssa.LocalSlot) ssa.LocalSlot {
-	n := name.N
-	at := name.Type
-	if at.NumElem() != 1 {
-		e.Fatalf(n.Pos(), "bad array size")
-	}
-	et := at.Elem()
-	return e.SplitSlot(&name, "[0]", 0, et)
-}
-
 func (e *ssafn) DerefItab(it *obj.LSym, offset int64) *obj.LSym {
 	return reflectdata.ITabSym(it, offset)
 }
-- 
GitLab


From ec4efa42089415b0427a4d30b317cfd7e4a0fe75 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Thu, 19 Mar 2020 17:59:45 -0400
Subject: [PATCH 2017/2400] crypto/x509: check the private key passed to
 CreateCertificate

Unfortunately, we can't improve the function signature to refer to
crypto.PrivateKey and crypto.PublicKey, even if they are both
interface{}, because it would break assignments to function types.

Fixes #37845

Change-Id: I627f2ac1e1ba98b128dac5382f9cc2524eaef378
Reviewed-on: https://go-review.googlesource.com/c/go/+/224157
Run-TryBot: Filippo Valsorda <filippo@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Filippo Valsorda <filippo@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
---
 src/crypto/x509/x509.go | 28 +++++++++++++++++++---------
 1 file changed, 19 insertions(+), 9 deletions(-)

diff --git a/src/crypto/x509/x509.go b/src/crypto/x509/x509.go
index ff37b361d7..4304ab54e1 100644
--- a/src/crypto/x509/x509.go
+++ b/src/crypto/x509/x509.go
@@ -1413,8 +1413,8 @@ func signingParamsForPublicKey(pub interface{}, requestedSigAlgo SignatureAlgori
 // just an empty SEQUENCE.
 var emptyASN1Subject = []byte{0x30, 0}
 
-// CreateCertificate creates a new X.509v3 certificate based on a template.
-// The following members of template are used:
+// CreateCertificate creates a new X.509 v3 certificate based on a template.
+// The following members of template are currently used:
 //
 //  - AuthorityKeyId
 //  - BasicConstraintsValid
@@ -1451,7 +1451,7 @@ var emptyASN1Subject = []byte{0x30, 0}
 //
 // The certificate is signed by parent. If parent is equal to template then the
 // certificate is self-signed. The parameter pub is the public key of the
-// signee and priv is the private key of the signer.
+// certificate to be generated and priv is the private key of the signer.
 //
 // The returned slice is the certificate in DER encoding.
 //
@@ -1465,7 +1465,7 @@ var emptyASN1Subject = []byte{0x30, 0}
 //
 // If SubjectKeyId from template is empty and the template is a CA, SubjectKeyId
 // will be generated from the hash of the public key.
-func CreateCertificate(rand io.Reader, template, parent *Certificate, pub, priv interface{}) (cert []byte, err error) {
+func CreateCertificate(rand io.Reader, template, parent *Certificate, pub, priv interface{}) ([]byte, error) {
 	key, ok := priv.(crypto.Signer)
 	if !ok {
 		return nil, errors.New("x509: certificate private key does not implement crypto.Signer")
@@ -1491,12 +1491,12 @@ func CreateCertificate(rand io.Reader, template, parent *Certificate, pub, priv
 
 	asn1Issuer, err := subjectBytes(parent)
 	if err != nil {
-		return
+		return nil, err
 	}
 
 	asn1Subject, err := subjectBytes(template)
 	if err != nil {
-		return
+		return nil, err
 	}
 
 	authorityKeyId := template.AuthorityKeyId
@@ -1514,9 +1514,19 @@ func CreateCertificate(rand io.Reader, template, parent *Certificate, pub, priv
 		subjectKeyId = h[:]
 	}
 
+	// Check that the signer's public key matches the private key, if available.
+	type privateKey interface {
+		Equal(crypto.PublicKey) bool
+	}
+	if privPub, ok := key.Public().(privateKey); !ok {
+		return nil, errors.New("x509: internal error: supported public key does not implement Equal")
+	} else if parent.PublicKey != nil && !privPub.Equal(parent.PublicKey) {
+		return nil, errors.New("x509: provided PrivateKey doesn't match parent's PublicKey")
+	}
+
 	extensions, err := buildCertExtensions(template, bytes.Equal(asn1Subject, emptyASN1Subject), authorityKeyId, subjectKeyId)
 	if err != nil {
-		return
+		return nil, err
 	}
 
 	encodedPublicKey := asn1.BitString{BitLength: len(publicKeyBytes) * 8, Bytes: publicKeyBytes}
@@ -1533,7 +1543,7 @@ func CreateCertificate(rand io.Reader, template, parent *Certificate, pub, priv
 
 	tbsCertContents, err := asn1.Marshal(c)
 	if err != nil {
-		return
+		return nil, err
 	}
 	c.Raw = tbsCertContents
 
@@ -1555,7 +1565,7 @@ func CreateCertificate(rand io.Reader, template, parent *Certificate, pub, priv
 	var signature []byte
 	signature, err = key.Sign(rand, signed, signerOpts)
 	if err != nil {
-		return
+		return nil, err
 	}
 
 	signedCert, err := asn1.Marshal(certificate{
-- 
GitLab


From 14c3d2aa596147bd90da298a4b2a70660786c682 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Fri, 30 Apr 2021 17:05:54 -0400
Subject: [PATCH 2018/2400] crypto/elliptic: import fiat-crypto P-521 field
 implementation
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fiat Cryptography (https://github.com/mit-plv/fiat-crypto) is a project
that produces prime order field implementations (the code that does
arithmetic modulo a prime number) based on a formally verified model.

The formal verification covers some of the most subtle and hard to test
parts of an elliptic curve implementation, like carry chains. It would
probably have prevented #20040 and #43786.

This CL imports a 64-bit implementation of the P-521 base field,
replacing the horribly slow and catastrophically variable time big.Int
CurveParams implementation.

The code in p521_fiat64.go is generated reproducibly by fiat-crypto,
building and running the Dockerfile according to the README.

The code in fiat/p521.go is a thin and idiomatic wrapper around the
fiat-crypto code. It includes an Invert method generated with the help
of github.com/mmcloughlin/addchain.

The code in elliptic/p521.go is a line-by-line port of the CurveParams
implementation. Lsh(x, N) was replaced with repeated Add(x, x) calls.
Mul(x, x) was replaced with Square(x). Mod calls were removed, as all
operations are modulo P. Likewise, Add calls to bring values back to
positive were removed. The ScalarMult ladder implementation is now
constant time, copied from p224ScalarMult. Only other notable changes
are adding a p512Point type to keep (x, y, z) together, and making
addJacobian and doubleJacobian methods on that type, with the usual
receiver semantics to save 4 allocations per step.

This amounts to a proof of concept, and is far from a mature elliptic
curve implementation. Here's a non-exhaustive list of things that need
improvement, most of which are pre-existing issues with crypto/elliptic.
Some of these can be fixed without API change, so can't.

- Marshal and Unmarshal still use the slow, variable time big.Int
  arithmetic. The Curve interface does not expose field operations, so
  we'll have to make our own abstraction.

- Point addition uses an incomplete Jacobian formula, which has variable
  time behaviors for points at infinity and equal points. There are
  better, complete formulae these days, but I wanted to keep this CL
  reviewable against the existing code.

- The scalar multiplication ladder is still heavily variable time. This
  is easy to fix and I'll do it in a follow-up CL, but I wanted to keep
  this one easier to review.

- Fundamentally, values have to go in and out of big.Int representation
  when they pass through the Curve interface, which is both slow and
  slightly variable-time.

- There is no scalar field implementation, so crypto/ecdsa ends up using
  big.Int for signing.

- Extending this to P-384 would involve either duplicating all P-521
  code, or coming up with some lower-level interfaces for the base
  field. Even better, generics, which would maybe let us save heap
  allocations due to virtual calls.

- The readability and idiomaticity of the autogenerated code can
  improve, although we have a clear abstraction and well-enforced
  contract, which makes it unlikely we'll have to resort to manually
  modifying the code. See mit-plv/fiat-crypto#949.

- We could also have a 32-bit implementation, since it's almost free to
  have fiat-crypto generate one.

Anyway, it's definitely better than CurveParams, and definitely faster.

name                   old time/op    new time/op    delta
pkg:crypto/elliptic goos:darwin goarch:arm64
ScalarBaseMult/P521-8    4.18ms ± 3%    0.86ms ± 2%  -79.50%  (p=0.000 n=10+9)
ScalarMult/P521-8        4.17ms ± 2%    0.85ms ± 6%  -79.68%  (p=0.000 n=10+10)
pkg:crypto/ecdsa goos:darwin goarch:arm64
Sign/P521-8              4.23ms ± 1%    0.94ms ± 0%  -77.70%  (p=0.000 n=9+8)
Verify/P521-8            8.31ms ± 2%    1.75ms ± 4%  -78.99%  (p=0.000 n=9+10)
GenerateKey/P521-8       4.15ms ± 2%    0.85ms ± 2%  -79.49%  (p=0.000 n=10+9)

name                   old alloc/op   new alloc/op   delta
pkg:crypto/elliptic goos:darwin goarch:arm64
ScalarBaseMult/P521-8    3.06MB ± 3%    0.00MB ± 0%  -99.97%  (p=0.000 n=10+10)
ScalarMult/P521-8        3.05MB ± 1%    0.00MB ± 0%  -99.97%  (p=0.000 n=9+10)
pkg:crypto/ecdsa goos:darwin goarch:arm64
Sign/P521-8              3.03MB ± 0%    0.01MB ± 0%  -99.74%  (p=0.000 n=10+8)
Verify/P521-8            6.06MB ± 1%    0.00MB ± 0%  -99.93%  (p=0.000 n=9+9)
GenerateKey/P521-8       3.02MB ± 0%    0.00MB ± 0%  -99.96%  (p=0.000 n=9+10)

name                   old allocs/op  new allocs/op  delta
pkg:crypto/elliptic goos:darwin goarch:arm64
ScalarBaseMult/P521-8     19.8k ± 3%      0.0k ± 0%  -99.95%  (p=0.000 n=10+10)
ScalarMult/P521-8         19.7k ± 1%      0.0k ± 0%  -99.95%  (p=0.000 n=9+10)
pkg:crypto/ecdsa goos:darwin goarch:arm64
Sign/P521-8               19.6k ± 0%      0.1k ± 0%  -99.63%  (p=0.000 n=10+10)
Verify/P521-8             39.2k ± 1%      0.1k ± 0%  -99.84%  (p=0.000 n=9+10)
GenerateKey/P521-8        19.5k ± 0%      0.0k ± 0%  -99.91%  (p=0.000 n=9+10)

Updates #40171

Change-Id: Ic898b09a2388382bf51ec007d9a79d72d44efe10
Reviewed-on: https://go-review.googlesource.com/c/go/+/315271
Run-TryBot: Filippo Valsorda <filippo@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
Trust: Katie Hockman <katie@golang.org>
Trust: Filippo Valsorda <filippo@golang.org>
---
 src/crypto/elliptic/elliptic.go               |   12 -
 src/crypto/elliptic/internal/fiat/Dockerfile  |   12 +
 src/crypto/elliptic/internal/fiat/README      |   39 +
 src/crypto/elliptic/internal/fiat/p521.go     |  197 ++
 .../elliptic/internal/fiat/p521_fiat64.go     | 1856 +++++++++++++++++
 .../elliptic/internal/fiat/p521_test.go       |   37 +
 src/crypto/elliptic/p521.go                   |  254 +++
 src/go/build/deps_test.go                     |    1 +
 8 files changed, 2396 insertions(+), 12 deletions(-)
 create mode 100644 src/crypto/elliptic/internal/fiat/Dockerfile
 create mode 100644 src/crypto/elliptic/internal/fiat/README
 create mode 100644 src/crypto/elliptic/internal/fiat/p521.go
 create mode 100644 src/crypto/elliptic/internal/fiat/p521_fiat64.go
 create mode 100644 src/crypto/elliptic/internal/fiat/p521_test.go
 create mode 100644 src/crypto/elliptic/p521.go

diff --git a/src/crypto/elliptic/elliptic.go b/src/crypto/elliptic/elliptic.go
index f93dc16419..85d105419b 100644
--- a/src/crypto/elliptic/elliptic.go
+++ b/src/crypto/elliptic/elliptic.go
@@ -390,7 +390,6 @@ func UnmarshalCompressed(curve Curve, data []byte) (x, y *big.Int) {
 
 var initonce sync.Once
 var p384 *CurveParams
-var p521 *CurveParams
 
 func initAll() {
 	initP224()
@@ -410,17 +409,6 @@ func initP384() {
 	p384.BitSize = 384
 }
 
-func initP521() {
-	// See FIPS 186-3, section D.2.5
-	p521 = &CurveParams{Name: "P-521"}
-	p521.P, _ = new(big.Int).SetString("6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151", 10)
-	p521.N, _ = new(big.Int).SetString("6864797660130609714981900799081393217269435300143305409394463459185543183397655394245057746333217197532963996371363321113864768612440380340372808892707005449", 10)
-	p521.B, _ = new(big.Int).SetString("051953eb9618e1c9a1f929a21a0b68540eea2da725b99b315f3b8b489918ef109e156193951ec7e937b1652c0bd3bb1bf073573df883d2c34f1ef451fd46b503f00", 16)
-	p521.Gx, _ = new(big.Int).SetString("c6858e06b70404e9cd9e3ecb662395b4429c648139053fb521f828af606b4d3dbaa14b5e77efe75928fe1dc127a2ffa8de3348b3c1856a429bf97e7e31c2e5bd66", 16)
-	p521.Gy, _ = new(big.Int).SetString("11839296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e662c97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650", 16)
-	p521.BitSize = 521
-}
-
 // P256 returns a Curve which implements NIST P-256 (FIPS 186-3, section D.2.3),
 // also known as secp256r1 or prime256v1. The CurveParams.Name of this Curve is
 // "P-256".
diff --git a/src/crypto/elliptic/internal/fiat/Dockerfile b/src/crypto/elliptic/internal/fiat/Dockerfile
new file mode 100644
index 0000000000..7b5ece0e30
--- /dev/null
+++ b/src/crypto/elliptic/internal/fiat/Dockerfile
@@ -0,0 +1,12 @@
+# Copyright 2021 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.
+
+FROM coqorg/coq:8.13.2
+
+RUN git clone https://github.com/mit-plv/fiat-crypto
+RUN cd fiat-crypto && git checkout c076f3550bea2bb7f4cb5766a32594b9e67694f2
+RUN cd fiat-crypto && git submodule update --init --recursive
+RUN cd fiat-crypto && eval $(opam env) && make -j4 standalone-ocaml SKIP_BEDROCK2=1
+
+ENTRYPOINT ["fiat-crypto/src/ExtractionOCaml/unsaturated_solinas"]
diff --git a/src/crypto/elliptic/internal/fiat/README b/src/crypto/elliptic/internal/fiat/README
new file mode 100644
index 0000000000..171f57a327
--- /dev/null
+++ b/src/crypto/elliptic/internal/fiat/README
@@ -0,0 +1,39 @@
+The code in this package was autogenerated by the fiat-crypto project
+at commit c076f3550 from a formally verified model.
+
+    docker build -t fiat-crypto:c076f3550 .
+    docker run fiat-crypto:c076f3550 --lang Go --no-wide-int --cmovznz-by-mul \
+        --internal-static --public-function-case camelCase --public-type-case camelCase \
+        --private-function-case camelCase --private-type-case camelCase \
+        --no-prefix-fiat --package-name fiat --doc-text-before-function-name '' \
+        --doc-prepend-header 'Code generated by Fiat Cryptography. DO NOT EDIT.' \
+        --doc-newline-before-package-declaration p521 64 9 '2^521 - 1' \
+        carry_mul carry_square carry add sub to_bytes from_bytes selectznz \
+        > p521_fiat64.go
+
+It comes under the following license.
+
+    Copyright (c) 2015-2020 The fiat-crypto Authors. All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+
+        1. Redistributions of source code must retain the above copyright
+        notice, this list of conditions and the following disclaimer.
+
+    THIS SOFTWARE IS PROVIDED BY the fiat-crypto authors "AS IS"
+    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+    THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Berkeley Software Design,
+    Inc. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The authors are listed at
+
+    https://github.com/mit-plv/fiat-crypto/blob/master/AUTHORS
diff --git a/src/crypto/elliptic/internal/fiat/p521.go b/src/crypto/elliptic/internal/fiat/p521.go
new file mode 100644
index 0000000000..dc677327e6
--- /dev/null
+++ b/src/crypto/elliptic/internal/fiat/p521.go
@@ -0,0 +1,197 @@
+// Copyright 2021 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 fiat implements prime order fields using formally verified algorithms
+// from the Fiat Cryptography project.
+package fiat
+
+import (
+	"crypto/subtle"
+	"errors"
+)
+
+// P521Element is an integer modulo 2^521 - 1.
+//
+// The zero value is a valid zero element.
+type P521Element struct {
+	// This element has the following bounds, which are tighter than
+	// the output bounds of some operations. Those operations must be
+	// followed by a carry.
+	//
+	// [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000],
+	// [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000],
+	// [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x200000000000000]
+	x [9]uint64
+}
+
+// One sets e = 1, and returns e.
+func (e *P521Element) One() *P521Element {
+	*e = P521Element{}
+	e.x[0] = 1
+	return e
+}
+
+// Equal returns 1 if e == t, and zero otherwise.
+func (e *P521Element) Equal(t *P521Element) int {
+	eBytes := e.Bytes()
+	tBytes := t.Bytes()
+	return subtle.ConstantTimeCompare(eBytes, tBytes)
+}
+
+var p521ZeroEncoding = new(P521Element).Bytes()
+
+// IsZero returns 1 if e == 0, and zero otherwise.
+func (e *P521Element) IsZero() int {
+	eBytes := e.Bytes()
+	return subtle.ConstantTimeCompare(eBytes, p521ZeroEncoding)
+}
+
+// Set sets e = t, and returns e.
+func (e *P521Element) Set(t *P521Element) *P521Element {
+	e.x = t.x
+	return e
+}
+
+// Bytes returns the 66-byte little-endian encoding of e.
+func (e *P521Element) Bytes() []byte {
+	// This function must be inlined to move the allocation to the parent and
+	// save it from escaping to the heap.
+	var out [66]byte
+	p521ToBytes(&out, &e.x)
+	return out[:]
+}
+
+// SetBytes sets e = v, where v is a little-endian 66-byte encoding, and returns
+// e. If v is not 66 bytes or it encodes a value higher than 2^521 - 1, SetBytes
+// returns nil and an error, and e is unchanged.
+func (e *P521Element) SetBytes(v []byte) (*P521Element, error) {
+	if len(v) != 66 || v[65] > 1 {
+		return nil, errors.New("invalid P-521 field encoding")
+	}
+	var in [66]byte
+	copy(in[:], v)
+	p521FromBytes(&e.x, &in)
+	return e, nil
+}
+
+// Add sets e = t1 + t2, and returns e.
+func (e *P521Element) Add(t1, t2 *P521Element) *P521Element {
+	p521Add(&e.x, &t1.x, &t2.x)
+	p521Carry(&e.x, &e.x)
+	return e
+}
+
+// Sub sets e = t1 - t2, and returns e.
+func (e *P521Element) Sub(t1, t2 *P521Element) *P521Element {
+	p521Sub(&e.x, &t1.x, &t2.x)
+	p521Carry(&e.x, &e.x)
+	return e
+}
+
+// Mul sets e = t1 * t2, and returns e.
+func (e *P521Element) Mul(t1, t2 *P521Element) *P521Element {
+	p521CarryMul(&e.x, &t1.x, &t2.x)
+	return e
+}
+
+// Square sets e = t * t, and returns e.
+func (e *P521Element) Square(t *P521Element) *P521Element {
+	p521CarrySquare(&e.x, &t.x)
+	return e
+}
+
+// Select sets e to a if cond == 1, and to b if cond == 0.
+func (v *P521Element) Select(a, b *P521Element, cond int) *P521Element {
+	p521Selectznz(&v.x, p521Uint1(cond), &b.x, &a.x)
+	return v
+}
+
+// Invert sets e = 1/t, and returns e.
+//
+// If t == 0, Invert returns e = 0.
+func (e *P521Element) Invert(t *P521Element) *P521Element {
+	// Inversion is implemented as exponentiation with exponent p − 2.
+	// The sequence of multiplications and squarings was generated with
+	// github.com/mmcloughlin/addchain v0.2.0.
+
+	var t1, t2 = new(P521Element), new(P521Element)
+
+	// _10 = 2 * 1
+	t1.Square(t)
+
+	// _11 = 1 + _10
+	t1.Mul(t, t1)
+
+	// _1100 = _11 << 2
+	t2.Square(t1)
+	t2.Square(t2)
+
+	// _1111 = _11 + _1100
+	t1.Mul(t1, t2)
+
+	// _11110000 = _1111 << 4
+	t2.Square(t1)
+	for i := 0; i < 3; i++ {
+		t2.Square(t2)
+	}
+
+	// _11111111 = _1111 + _11110000
+	t1.Mul(t1, t2)
+
+	// x16 = _11111111<<8 + _11111111
+	t2.Square(t1)
+	for i := 0; i < 7; i++ {
+		t2.Square(t2)
+	}
+	t1.Mul(t1, t2)
+
+	// x32 = x16<<16 + x16
+	t2.Square(t1)
+	for i := 0; i < 15; i++ {
+		t2.Square(t2)
+	}
+	t1.Mul(t1, t2)
+
+	// x64 = x32<<32 + x32
+	t2.Square(t1)
+	for i := 0; i < 31; i++ {
+		t2.Square(t2)
+	}
+	t1.Mul(t1, t2)
+
+	// x65 = 2*x64 + 1
+	t2.Square(t1)
+	t2.Mul(t2, t)
+
+	// x129 = x65<<64 + x64
+	for i := 0; i < 64; i++ {
+		t2.Square(t2)
+	}
+	t1.Mul(t1, t2)
+
+	// x130 = 2*x129 + 1
+	t2.Square(t1)
+	t2.Mul(t2, t)
+
+	// x259 = x130<<129 + x129
+	for i := 0; i < 129; i++ {
+		t2.Square(t2)
+	}
+	t1.Mul(t1, t2)
+
+	// x260 = 2*x259 + 1
+	t2.Square(t1)
+	t2.Mul(t2, t)
+
+	// x519 = x260<<259 + x259
+	for i := 0; i < 259; i++ {
+		t2.Square(t2)
+	}
+	t1.Mul(t1, t2)
+
+	// return x519<<2 + 1
+	t1.Square(t1)
+	t1.Square(t1)
+	return e.Mul(t1, t)
+}
diff --git a/src/crypto/elliptic/internal/fiat/p521_fiat64.go b/src/crypto/elliptic/internal/fiat/p521_fiat64.go
new file mode 100644
index 0000000000..f86283b587
--- /dev/null
+++ b/src/crypto/elliptic/internal/fiat/p521_fiat64.go
@@ -0,0 +1,1856 @@
+// Code generated by Fiat Cryptography. DO NOT EDIT.
+//
+// Autogenerated: 'fiat-crypto/src/ExtractionOCaml/unsaturated_solinas' --lang Go --no-wide-int --cmovznz-by-mul --internal-static --public-function-case camelCase --public-type-case camelCase --private-function-case camelCase --private-type-case camelCase --no-prefix-fiat --package-name fiat --doc-text-before-function-name '' --doc-prepend-header 'Code generated by Fiat Cryptography. DO NOT EDIT.' --doc-newline-before-package-declaration p521 64 9 '2^521 - 1' carry_mul carry_square carry add sub to_bytes from_bytes selectznz
+//
+// curve description: p521
+//
+// machine_wordsize = 64 (from "64")
+//
+// requested operations: carry_mul, carry_square, carry, add, sub, to_bytes, from_bytes, selectznz
+//
+// n = 9 (from "9")
+//
+// s-c = 2^521 - [(1, 1)] (from "2^521 - 1")
+//
+// tight_bounds_multiplier = 1 (from "")
+//
+//
+//
+// Computed values:
+//
+//   carry_chain = [0, 1, 2, 3, 4, 5, 6, 7, 8, 0, 1]
+//
+//   eval z = z[0] + (z[1] << 58) + (z[2] << 116) + (z[3] << 174) + (z[4] << 232) + (z[5] << 0x122) + (z[6] << 0x15c) + (z[7] << 0x196) + (z[8] << 0x1d0)
+//
+//   bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) + (z[32] << 256) + (z[33] << 0x108) + (z[34] << 0x110) + (z[35] << 0x118) + (z[36] << 0x120) + (z[37] << 0x128) + (z[38] << 0x130) + (z[39] << 0x138) + (z[40] << 0x140) + (z[41] << 0x148) + (z[42] << 0x150) + (z[43] << 0x158) + (z[44] << 0x160) + (z[45] << 0x168) + (z[46] << 0x170) + (z[47] << 0x178) + (z[48] << 0x180) + (z[49] << 0x188) + (z[50] << 0x190) + (z[51] << 0x198) + (z[52] << 0x1a0) + (z[53] << 0x1a8) + (z[54] << 0x1b0) + (z[55] << 0x1b8) + (z[56] << 0x1c0) + (z[57] << 0x1c8) + (z[58] << 0x1d0) + (z[59] << 0x1d8) + (z[60] << 0x1e0) + (z[61] << 0x1e8) + (z[62] << 0x1f0) + (z[63] << 0x1f8) + (z[64] << 2^9) + (z[65] << 0x208)
+//
+//   balance = [0x7fffffffffffffe, 0x7fffffffffffffe, 0x7fffffffffffffe, 0x7fffffffffffffe, 0x7fffffffffffffe, 0x7fffffffffffffe, 0x7fffffffffffffe, 0x7fffffffffffffe, 0x3fffffffffffffe]
+
+package fiat
+
+import "math/bits"
+
+type p521Uint1 uint8
+type p521Int1 int8
+
+// p521AddcarryxU64 is a thin wrapper around bits.Add64 that uses p521Uint1 rather than uint64
+func p521AddcarryxU64(x uint64, y uint64, carry p521Uint1) (uint64, p521Uint1) {
+	sum, carryOut := bits.Add64(x, y, uint64(carry))
+	return sum, p521Uint1(carryOut)
+}
+
+// p521SubborrowxU64 is a thin wrapper around bits.Sub64 that uses p521Uint1 rather than uint64
+func p521SubborrowxU64(x uint64, y uint64, carry p521Uint1) (uint64, p521Uint1) {
+	sum, carryOut := bits.Sub64(x, y, uint64(carry))
+	return sum, p521Uint1(carryOut)
+}
+
+// p521AddcarryxU58 is an addition with carry.
+//
+// Postconditions:
+//   out1 = (arg1 + arg2 + arg3) mod 2^58
+//   out2 = ⌊(arg1 + arg2 + arg3) / 2^58⌋
+//
+// Input Bounds:
+//   arg1: [0x0 ~> 0x1]
+//   arg2: [0x0 ~> 0x3ffffffffffffff]
+//   arg3: [0x0 ~> 0x3ffffffffffffff]
+// Output Bounds:
+//   out1: [0x0 ~> 0x3ffffffffffffff]
+//   out2: [0x0 ~> 0x1]
+func p521AddcarryxU58(out1 *uint64, out2 *p521Uint1, arg1 p521Uint1, arg2 uint64, arg3 uint64) {
+	x1 := ((uint64(arg1) + arg2) + arg3)
+	x2 := (x1 & 0x3ffffffffffffff)
+	x3 := p521Uint1((x1 >> 58))
+	*out1 = x2
+	*out2 = x3
+}
+
+// p521SubborrowxU58 is a subtraction with borrow.
+//
+// Postconditions:
+//   out1 = (-arg1 + arg2 + -arg3) mod 2^58
+//   out2 = -⌊(-arg1 + arg2 + -arg3) / 2^58⌋
+//
+// Input Bounds:
+//   arg1: [0x0 ~> 0x1]
+//   arg2: [0x0 ~> 0x3ffffffffffffff]
+//   arg3: [0x0 ~> 0x3ffffffffffffff]
+// Output Bounds:
+//   out1: [0x0 ~> 0x3ffffffffffffff]
+//   out2: [0x0 ~> 0x1]
+func p521SubborrowxU58(out1 *uint64, out2 *p521Uint1, arg1 p521Uint1, arg2 uint64, arg3 uint64) {
+	x1 := ((int64(arg2) - int64(arg1)) - int64(arg3))
+	x2 := p521Int1((x1 >> 58))
+	x3 := (uint64(x1) & 0x3ffffffffffffff)
+	*out1 = x3
+	*out2 = (0x0 - p521Uint1(x2))
+}
+
+// p521AddcarryxU57 is an addition with carry.
+//
+// Postconditions:
+//   out1 = (arg1 + arg2 + arg3) mod 2^57
+//   out2 = ⌊(arg1 + arg2 + arg3) / 2^57⌋
+//
+// Input Bounds:
+//   arg1: [0x0 ~> 0x1]
+//   arg2: [0x0 ~> 0x1ffffffffffffff]
+//   arg3: [0x0 ~> 0x1ffffffffffffff]
+// Output Bounds:
+//   out1: [0x0 ~> 0x1ffffffffffffff]
+//   out2: [0x0 ~> 0x1]
+func p521AddcarryxU57(out1 *uint64, out2 *p521Uint1, arg1 p521Uint1, arg2 uint64, arg3 uint64) {
+	x1 := ((uint64(arg1) + arg2) + arg3)
+	x2 := (x1 & 0x1ffffffffffffff)
+	x3 := p521Uint1((x1 >> 57))
+	*out1 = x2
+	*out2 = x3
+}
+
+// p521SubborrowxU57 is a subtraction with borrow.
+//
+// Postconditions:
+//   out1 = (-arg1 + arg2 + -arg3) mod 2^57
+//   out2 = -⌊(-arg1 + arg2 + -arg3) / 2^57⌋
+//
+// Input Bounds:
+//   arg1: [0x0 ~> 0x1]
+//   arg2: [0x0 ~> 0x1ffffffffffffff]
+//   arg3: [0x0 ~> 0x1ffffffffffffff]
+// Output Bounds:
+//   out1: [0x0 ~> 0x1ffffffffffffff]
+//   out2: [0x0 ~> 0x1]
+func p521SubborrowxU57(out1 *uint64, out2 *p521Uint1, arg1 p521Uint1, arg2 uint64, arg3 uint64) {
+	x1 := ((int64(arg2) - int64(arg1)) - int64(arg3))
+	x2 := p521Int1((x1 >> 57))
+	x3 := (uint64(x1) & 0x1ffffffffffffff)
+	*out1 = x3
+	*out2 = (0x0 - p521Uint1(x2))
+}
+
+// p521CmovznzU64 is a single-word conditional move.
+//
+// Postconditions:
+//   out1 = (if arg1 = 0 then arg2 else arg3)
+//
+// Input Bounds:
+//   arg1: [0x0 ~> 0x1]
+//   arg2: [0x0 ~> 0xffffffffffffffff]
+//   arg3: [0x0 ~> 0xffffffffffffffff]
+// Output Bounds:
+//   out1: [0x0 ~> 0xffffffffffffffff]
+func p521CmovznzU64(out1 *uint64, arg1 p521Uint1, arg2 uint64, arg3 uint64) {
+	x1 := (uint64(arg1) * 0xffffffffffffffff)
+	x2 := ((x1 & arg3) | ((^x1) & arg2))
+	*out1 = x2
+}
+
+// p521CarryMul multiplies two field elements and reduces the result.
+//
+// Postconditions:
+//   eval out1 mod m = (eval arg1 * eval arg2) mod m
+//
+// Input Bounds:
+//   arg1: [[0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0x600000000000000]]
+//   arg2: [[0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0x600000000000000]]
+// Output Bounds:
+//   out1: [[0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x200000000000000]]
+func p521CarryMul(out1 *[9]uint64, arg1 *[9]uint64, arg2 *[9]uint64) {
+	var x1 uint64
+	var x2 uint64
+	x2, x1 = bits.Mul64(arg1[8], (arg2[8] * 0x2))
+	var x3 uint64
+	var x4 uint64
+	x4, x3 = bits.Mul64(arg1[8], (arg2[7] * 0x2))
+	var x5 uint64
+	var x6 uint64
+	x6, x5 = bits.Mul64(arg1[8], (arg2[6] * 0x2))
+	var x7 uint64
+	var x8 uint64
+	x8, x7 = bits.Mul64(arg1[8], (arg2[5] * 0x2))
+	var x9 uint64
+	var x10 uint64
+	x10, x9 = bits.Mul64(arg1[8], (arg2[4] * 0x2))
+	var x11 uint64
+	var x12 uint64
+	x12, x11 = bits.Mul64(arg1[8], (arg2[3] * 0x2))
+	var x13 uint64
+	var x14 uint64
+	x14, x13 = bits.Mul64(arg1[8], (arg2[2] * 0x2))
+	var x15 uint64
+	var x16 uint64
+	x16, x15 = bits.Mul64(arg1[8], (arg2[1] * 0x2))
+	var x17 uint64
+	var x18 uint64
+	x18, x17 = bits.Mul64(arg1[7], (arg2[8] * 0x2))
+	var x19 uint64
+	var x20 uint64
+	x20, x19 = bits.Mul64(arg1[7], (arg2[7] * 0x2))
+	var x21 uint64
+	var x22 uint64
+	x22, x21 = bits.Mul64(arg1[7], (arg2[6] * 0x2))
+	var x23 uint64
+	var x24 uint64
+	x24, x23 = bits.Mul64(arg1[7], (arg2[5] * 0x2))
+	var x25 uint64
+	var x26 uint64
+	x26, x25 = bits.Mul64(arg1[7], (arg2[4] * 0x2))
+	var x27 uint64
+	var x28 uint64
+	x28, x27 = bits.Mul64(arg1[7], (arg2[3] * 0x2))
+	var x29 uint64
+	var x30 uint64
+	x30, x29 = bits.Mul64(arg1[7], (arg2[2] * 0x2))
+	var x31 uint64
+	var x32 uint64
+	x32, x31 = bits.Mul64(arg1[6], (arg2[8] * 0x2))
+	var x33 uint64
+	var x34 uint64
+	x34, x33 = bits.Mul64(arg1[6], (arg2[7] * 0x2))
+	var x35 uint64
+	var x36 uint64
+	x36, x35 = bits.Mul64(arg1[6], (arg2[6] * 0x2))
+	var x37 uint64
+	var x38 uint64
+	x38, x37 = bits.Mul64(arg1[6], (arg2[5] * 0x2))
+	var x39 uint64
+	var x40 uint64
+	x40, x39 = bits.Mul64(arg1[6], (arg2[4] * 0x2))
+	var x41 uint64
+	var x42 uint64
+	x42, x41 = bits.Mul64(arg1[6], (arg2[3] * 0x2))
+	var x43 uint64
+	var x44 uint64
+	x44, x43 = bits.Mul64(arg1[5], (arg2[8] * 0x2))
+	var x45 uint64
+	var x46 uint64
+	x46, x45 = bits.Mul64(arg1[5], (arg2[7] * 0x2))
+	var x47 uint64
+	var x48 uint64
+	x48, x47 = bits.Mul64(arg1[5], (arg2[6] * 0x2))
+	var x49 uint64
+	var x50 uint64
+	x50, x49 = bits.Mul64(arg1[5], (arg2[5] * 0x2))
+	var x51 uint64
+	var x52 uint64
+	x52, x51 = bits.Mul64(arg1[5], (arg2[4] * 0x2))
+	var x53 uint64
+	var x54 uint64
+	x54, x53 = bits.Mul64(arg1[4], (arg2[8] * 0x2))
+	var x55 uint64
+	var x56 uint64
+	x56, x55 = bits.Mul64(arg1[4], (arg2[7] * 0x2))
+	var x57 uint64
+	var x58 uint64
+	x58, x57 = bits.Mul64(arg1[4], (arg2[6] * 0x2))
+	var x59 uint64
+	var x60 uint64
+	x60, x59 = bits.Mul64(arg1[4], (arg2[5] * 0x2))
+	var x61 uint64
+	var x62 uint64
+	x62, x61 = bits.Mul64(arg1[3], (arg2[8] * 0x2))
+	var x63 uint64
+	var x64 uint64
+	x64, x63 = bits.Mul64(arg1[3], (arg2[7] * 0x2))
+	var x65 uint64
+	var x66 uint64
+	x66, x65 = bits.Mul64(arg1[3], (arg2[6] * 0x2))
+	var x67 uint64
+	var x68 uint64
+	x68, x67 = bits.Mul64(arg1[2], (arg2[8] * 0x2))
+	var x69 uint64
+	var x70 uint64
+	x70, x69 = bits.Mul64(arg1[2], (arg2[7] * 0x2))
+	var x71 uint64
+	var x72 uint64
+	x72, x71 = bits.Mul64(arg1[1], (arg2[8] * 0x2))
+	var x73 uint64
+	var x74 uint64
+	x74, x73 = bits.Mul64(arg1[8], arg2[0])
+	var x75 uint64
+	var x76 uint64
+	x76, x75 = bits.Mul64(arg1[7], arg2[1])
+	var x77 uint64
+	var x78 uint64
+	x78, x77 = bits.Mul64(arg1[7], arg2[0])
+	var x79 uint64
+	var x80 uint64
+	x80, x79 = bits.Mul64(arg1[6], arg2[2])
+	var x81 uint64
+	var x82 uint64
+	x82, x81 = bits.Mul64(arg1[6], arg2[1])
+	var x83 uint64
+	var x84 uint64
+	x84, x83 = bits.Mul64(arg1[6], arg2[0])
+	var x85 uint64
+	var x86 uint64
+	x86, x85 = bits.Mul64(arg1[5], arg2[3])
+	var x87 uint64
+	var x88 uint64
+	x88, x87 = bits.Mul64(arg1[5], arg2[2])
+	var x89 uint64
+	var x90 uint64
+	x90, x89 = bits.Mul64(arg1[5], arg2[1])
+	var x91 uint64
+	var x92 uint64
+	x92, x91 = bits.Mul64(arg1[5], arg2[0])
+	var x93 uint64
+	var x94 uint64
+	x94, x93 = bits.Mul64(arg1[4], arg2[4])
+	var x95 uint64
+	var x96 uint64
+	x96, x95 = bits.Mul64(arg1[4], arg2[3])
+	var x97 uint64
+	var x98 uint64
+	x98, x97 = bits.Mul64(arg1[4], arg2[2])
+	var x99 uint64
+	var x100 uint64
+	x100, x99 = bits.Mul64(arg1[4], arg2[1])
+	var x101 uint64
+	var x102 uint64
+	x102, x101 = bits.Mul64(arg1[4], arg2[0])
+	var x103 uint64
+	var x104 uint64
+	x104, x103 = bits.Mul64(arg1[3], arg2[5])
+	var x105 uint64
+	var x106 uint64
+	x106, x105 = bits.Mul64(arg1[3], arg2[4])
+	var x107 uint64
+	var x108 uint64
+	x108, x107 = bits.Mul64(arg1[3], arg2[3])
+	var x109 uint64
+	var x110 uint64
+	x110, x109 = bits.Mul64(arg1[3], arg2[2])
+	var x111 uint64
+	var x112 uint64
+	x112, x111 = bits.Mul64(arg1[3], arg2[1])
+	var x113 uint64
+	var x114 uint64
+	x114, x113 = bits.Mul64(arg1[3], arg2[0])
+	var x115 uint64
+	var x116 uint64
+	x116, x115 = bits.Mul64(arg1[2], arg2[6])
+	var x117 uint64
+	var x118 uint64
+	x118, x117 = bits.Mul64(arg1[2], arg2[5])
+	var x119 uint64
+	var x120 uint64
+	x120, x119 = bits.Mul64(arg1[2], arg2[4])
+	var x121 uint64
+	var x122 uint64
+	x122, x121 = bits.Mul64(arg1[2], arg2[3])
+	var x123 uint64
+	var x124 uint64
+	x124, x123 = bits.Mul64(arg1[2], arg2[2])
+	var x125 uint64
+	var x126 uint64
+	x126, x125 = bits.Mul64(arg1[2], arg2[1])
+	var x127 uint64
+	var x128 uint64
+	x128, x127 = bits.Mul64(arg1[2], arg2[0])
+	var x129 uint64
+	var x130 uint64
+	x130, x129 = bits.Mul64(arg1[1], arg2[7])
+	var x131 uint64
+	var x132 uint64
+	x132, x131 = bits.Mul64(arg1[1], arg2[6])
+	var x133 uint64
+	var x134 uint64
+	x134, x133 = bits.Mul64(arg1[1], arg2[5])
+	var x135 uint64
+	var x136 uint64
+	x136, x135 = bits.Mul64(arg1[1], arg2[4])
+	var x137 uint64
+	var x138 uint64
+	x138, x137 = bits.Mul64(arg1[1], arg2[3])
+	var x139 uint64
+	var x140 uint64
+	x140, x139 = bits.Mul64(arg1[1], arg2[2])
+	var x141 uint64
+	var x142 uint64
+	x142, x141 = bits.Mul64(arg1[1], arg2[1])
+	var x143 uint64
+	var x144 uint64
+	x144, x143 = bits.Mul64(arg1[1], arg2[0])
+	var x145 uint64
+	var x146 uint64
+	x146, x145 = bits.Mul64(arg1[0], arg2[8])
+	var x147 uint64
+	var x148 uint64
+	x148, x147 = bits.Mul64(arg1[0], arg2[7])
+	var x149 uint64
+	var x150 uint64
+	x150, x149 = bits.Mul64(arg1[0], arg2[6])
+	var x151 uint64
+	var x152 uint64
+	x152, x151 = bits.Mul64(arg1[0], arg2[5])
+	var x153 uint64
+	var x154 uint64
+	x154, x153 = bits.Mul64(arg1[0], arg2[4])
+	var x155 uint64
+	var x156 uint64
+	x156, x155 = bits.Mul64(arg1[0], arg2[3])
+	var x157 uint64
+	var x158 uint64
+	x158, x157 = bits.Mul64(arg1[0], arg2[2])
+	var x159 uint64
+	var x160 uint64
+	x160, x159 = bits.Mul64(arg1[0], arg2[1])
+	var x161 uint64
+	var x162 uint64
+	x162, x161 = bits.Mul64(arg1[0], arg2[0])
+	var x163 uint64
+	var x164 p521Uint1
+	x163, x164 = p521AddcarryxU64(x29, x15, 0x0)
+	var x165 uint64
+	x165, _ = p521AddcarryxU64(x30, x16, x164)
+	var x167 uint64
+	var x168 p521Uint1
+	x167, x168 = p521AddcarryxU64(x41, x163, 0x0)
+	var x169 uint64
+	x169, _ = p521AddcarryxU64(x42, x165, x168)
+	var x171 uint64
+	var x172 p521Uint1
+	x171, x172 = p521AddcarryxU64(x51, x167, 0x0)
+	var x173 uint64
+	x173, _ = p521AddcarryxU64(x52, x169, x172)
+	var x175 uint64
+	var x176 p521Uint1
+	x175, x176 = p521AddcarryxU64(x59, x171, 0x0)
+	var x177 uint64
+	x177, _ = p521AddcarryxU64(x60, x173, x176)
+	var x179 uint64
+	var x180 p521Uint1
+	x179, x180 = p521AddcarryxU64(x65, x175, 0x0)
+	var x181 uint64
+	x181, _ = p521AddcarryxU64(x66, x177, x180)
+	var x183 uint64
+	var x184 p521Uint1
+	x183, x184 = p521AddcarryxU64(x69, x179, 0x0)
+	var x185 uint64
+	x185, _ = p521AddcarryxU64(x70, x181, x184)
+	var x187 uint64
+	var x188 p521Uint1
+	x187, x188 = p521AddcarryxU64(x71, x183, 0x0)
+	var x189 uint64
+	x189, _ = p521AddcarryxU64(x72, x185, x188)
+	var x191 uint64
+	var x192 p521Uint1
+	x191, x192 = p521AddcarryxU64(x161, x187, 0x0)
+	var x193 uint64
+	x193, _ = p521AddcarryxU64(x162, x189, x192)
+	x195 := ((x191 >> 58) | ((x193 << 6) & 0xffffffffffffffff))
+	x196 := (x193 >> 58)
+	x197 := (x191 & 0x3ffffffffffffff)
+	var x198 uint64
+	var x199 p521Uint1
+	x198, x199 = p521AddcarryxU64(x75, x73, 0x0)
+	var x200 uint64
+	x200, _ = p521AddcarryxU64(x76, x74, x199)
+	var x202 uint64
+	var x203 p521Uint1
+	x202, x203 = p521AddcarryxU64(x79, x198, 0x0)
+	var x204 uint64
+	x204, _ = p521AddcarryxU64(x80, x200, x203)
+	var x206 uint64
+	var x207 p521Uint1
+	x206, x207 = p521AddcarryxU64(x85, x202, 0x0)
+	var x208 uint64
+	x208, _ = p521AddcarryxU64(x86, x204, x207)
+	var x210 uint64
+	var x211 p521Uint1
+	x210, x211 = p521AddcarryxU64(x93, x206, 0x0)
+	var x212 uint64
+	x212, _ = p521AddcarryxU64(x94, x208, x211)
+	var x214 uint64
+	var x215 p521Uint1
+	x214, x215 = p521AddcarryxU64(x103, x210, 0x0)
+	var x216 uint64
+	x216, _ = p521AddcarryxU64(x104, x212, x215)
+	var x218 uint64
+	var x219 p521Uint1
+	x218, x219 = p521AddcarryxU64(x115, x214, 0x0)
+	var x220 uint64
+	x220, _ = p521AddcarryxU64(x116, x216, x219)
+	var x222 uint64
+	var x223 p521Uint1
+	x222, x223 = p521AddcarryxU64(x129, x218, 0x0)
+	var x224 uint64
+	x224, _ = p521AddcarryxU64(x130, x220, x223)
+	var x226 uint64
+	var x227 p521Uint1
+	x226, x227 = p521AddcarryxU64(x145, x222, 0x0)
+	var x228 uint64
+	x228, _ = p521AddcarryxU64(x146, x224, x227)
+	var x230 uint64
+	var x231 p521Uint1
+	x230, x231 = p521AddcarryxU64(x77, x1, 0x0)
+	var x232 uint64
+	x232, _ = p521AddcarryxU64(x78, x2, x231)
+	var x234 uint64
+	var x235 p521Uint1
+	x234, x235 = p521AddcarryxU64(x81, x230, 0x0)
+	var x236 uint64
+	x236, _ = p521AddcarryxU64(x82, x232, x235)
+	var x238 uint64
+	var x239 p521Uint1
+	x238, x239 = p521AddcarryxU64(x87, x234, 0x0)
+	var x240 uint64
+	x240, _ = p521AddcarryxU64(x88, x236, x239)
+	var x242 uint64
+	var x243 p521Uint1
+	x242, x243 = p521AddcarryxU64(x95, x238, 0x0)
+	var x244 uint64
+	x244, _ = p521AddcarryxU64(x96, x240, x243)
+	var x246 uint64
+	var x247 p521Uint1
+	x246, x247 = p521AddcarryxU64(x105, x242, 0x0)
+	var x248 uint64
+	x248, _ = p521AddcarryxU64(x106, x244, x247)
+	var x250 uint64
+	var x251 p521Uint1
+	x250, x251 = p521AddcarryxU64(x117, x246, 0x0)
+	var x252 uint64
+	x252, _ = p521AddcarryxU64(x118, x248, x251)
+	var x254 uint64
+	var x255 p521Uint1
+	x254, x255 = p521AddcarryxU64(x131, x250, 0x0)
+	var x256 uint64
+	x256, _ = p521AddcarryxU64(x132, x252, x255)
+	var x258 uint64
+	var x259 p521Uint1
+	x258, x259 = p521AddcarryxU64(x147, x254, 0x0)
+	var x260 uint64
+	x260, _ = p521AddcarryxU64(x148, x256, x259)
+	var x262 uint64
+	var x263 p521Uint1
+	x262, x263 = p521AddcarryxU64(x17, x3, 0x0)
+	var x264 uint64
+	x264, _ = p521AddcarryxU64(x18, x4, x263)
+	var x266 uint64
+	var x267 p521Uint1
+	x266, x267 = p521AddcarryxU64(x83, x262, 0x0)
+	var x268 uint64
+	x268, _ = p521AddcarryxU64(x84, x264, x267)
+	var x270 uint64
+	var x271 p521Uint1
+	x270, x271 = p521AddcarryxU64(x89, x266, 0x0)
+	var x272 uint64
+	x272, _ = p521AddcarryxU64(x90, x268, x271)
+	var x274 uint64
+	var x275 p521Uint1
+	x274, x275 = p521AddcarryxU64(x97, x270, 0x0)
+	var x276 uint64
+	x276, _ = p521AddcarryxU64(x98, x272, x275)
+	var x278 uint64
+	var x279 p521Uint1
+	x278, x279 = p521AddcarryxU64(x107, x274, 0x0)
+	var x280 uint64
+	x280, _ = p521AddcarryxU64(x108, x276, x279)
+	var x282 uint64
+	var x283 p521Uint1
+	x282, x283 = p521AddcarryxU64(x119, x278, 0x0)
+	var x284 uint64
+	x284, _ = p521AddcarryxU64(x120, x280, x283)
+	var x286 uint64
+	var x287 p521Uint1
+	x286, x287 = p521AddcarryxU64(x133, x282, 0x0)
+	var x288 uint64
+	x288, _ = p521AddcarryxU64(x134, x284, x287)
+	var x290 uint64
+	var x291 p521Uint1
+	x290, x291 = p521AddcarryxU64(x149, x286, 0x0)
+	var x292 uint64
+	x292, _ = p521AddcarryxU64(x150, x288, x291)
+	var x294 uint64
+	var x295 p521Uint1
+	x294, x295 = p521AddcarryxU64(x19, x5, 0x0)
+	var x296 uint64
+	x296, _ = p521AddcarryxU64(x20, x6, x295)
+	var x298 uint64
+	var x299 p521Uint1
+	x298, x299 = p521AddcarryxU64(x31, x294, 0x0)
+	var x300 uint64
+	x300, _ = p521AddcarryxU64(x32, x296, x299)
+	var x302 uint64
+	var x303 p521Uint1
+	x302, x303 = p521AddcarryxU64(x91, x298, 0x0)
+	var x304 uint64
+	x304, _ = p521AddcarryxU64(x92, x300, x303)
+	var x306 uint64
+	var x307 p521Uint1
+	x306, x307 = p521AddcarryxU64(x99, x302, 0x0)
+	var x308 uint64
+	x308, _ = p521AddcarryxU64(x100, x304, x307)
+	var x310 uint64
+	var x311 p521Uint1
+	x310, x311 = p521AddcarryxU64(x109, x306, 0x0)
+	var x312 uint64
+	x312, _ = p521AddcarryxU64(x110, x308, x311)
+	var x314 uint64
+	var x315 p521Uint1
+	x314, x315 = p521AddcarryxU64(x121, x310, 0x0)
+	var x316 uint64
+	x316, _ = p521AddcarryxU64(x122, x312, x315)
+	var x318 uint64
+	var x319 p521Uint1
+	x318, x319 = p521AddcarryxU64(x135, x314, 0x0)
+	var x320 uint64
+	x320, _ = p521AddcarryxU64(x136, x316, x319)
+	var x322 uint64
+	var x323 p521Uint1
+	x322, x323 = p521AddcarryxU64(x151, x318, 0x0)
+	var x324 uint64
+	x324, _ = p521AddcarryxU64(x152, x320, x323)
+	var x326 uint64
+	var x327 p521Uint1
+	x326, x327 = p521AddcarryxU64(x21, x7, 0x0)
+	var x328 uint64
+	x328, _ = p521AddcarryxU64(x22, x8, x327)
+	var x330 uint64
+	var x331 p521Uint1
+	x330, x331 = p521AddcarryxU64(x33, x326, 0x0)
+	var x332 uint64
+	x332, _ = p521AddcarryxU64(x34, x328, x331)
+	var x334 uint64
+	var x335 p521Uint1
+	x334, x335 = p521AddcarryxU64(x43, x330, 0x0)
+	var x336 uint64
+	x336, _ = p521AddcarryxU64(x44, x332, x335)
+	var x338 uint64
+	var x339 p521Uint1
+	x338, x339 = p521AddcarryxU64(x101, x334, 0x0)
+	var x340 uint64
+	x340, _ = p521AddcarryxU64(x102, x336, x339)
+	var x342 uint64
+	var x343 p521Uint1
+	x342, x343 = p521AddcarryxU64(x111, x338, 0x0)
+	var x344 uint64
+	x344, _ = p521AddcarryxU64(x112, x340, x343)
+	var x346 uint64
+	var x347 p521Uint1
+	x346, x347 = p521AddcarryxU64(x123, x342, 0x0)
+	var x348 uint64
+	x348, _ = p521AddcarryxU64(x124, x344, x347)
+	var x350 uint64
+	var x351 p521Uint1
+	x350, x351 = p521AddcarryxU64(x137, x346, 0x0)
+	var x352 uint64
+	x352, _ = p521AddcarryxU64(x138, x348, x351)
+	var x354 uint64
+	var x355 p521Uint1
+	x354, x355 = p521AddcarryxU64(x153, x350, 0x0)
+	var x356 uint64
+	x356, _ = p521AddcarryxU64(x154, x352, x355)
+	var x358 uint64
+	var x359 p521Uint1
+	x358, x359 = p521AddcarryxU64(x23, x9, 0x0)
+	var x360 uint64
+	x360, _ = p521AddcarryxU64(x24, x10, x359)
+	var x362 uint64
+	var x363 p521Uint1
+	x362, x363 = p521AddcarryxU64(x35, x358, 0x0)
+	var x364 uint64
+	x364, _ = p521AddcarryxU64(x36, x360, x363)
+	var x366 uint64
+	var x367 p521Uint1
+	x366, x367 = p521AddcarryxU64(x45, x362, 0x0)
+	var x368 uint64
+	x368, _ = p521AddcarryxU64(x46, x364, x367)
+	var x370 uint64
+	var x371 p521Uint1
+	x370, x371 = p521AddcarryxU64(x53, x366, 0x0)
+	var x372 uint64
+	x372, _ = p521AddcarryxU64(x54, x368, x371)
+	var x374 uint64
+	var x375 p521Uint1
+	x374, x375 = p521AddcarryxU64(x113, x370, 0x0)
+	var x376 uint64
+	x376, _ = p521AddcarryxU64(x114, x372, x375)
+	var x378 uint64
+	var x379 p521Uint1
+	x378, x379 = p521AddcarryxU64(x125, x374, 0x0)
+	var x380 uint64
+	x380, _ = p521AddcarryxU64(x126, x376, x379)
+	var x382 uint64
+	var x383 p521Uint1
+	x382, x383 = p521AddcarryxU64(x139, x378, 0x0)
+	var x384 uint64
+	x384, _ = p521AddcarryxU64(x140, x380, x383)
+	var x386 uint64
+	var x387 p521Uint1
+	x386, x387 = p521AddcarryxU64(x155, x382, 0x0)
+	var x388 uint64
+	x388, _ = p521AddcarryxU64(x156, x384, x387)
+	var x390 uint64
+	var x391 p521Uint1
+	x390, x391 = p521AddcarryxU64(x25, x11, 0x0)
+	var x392 uint64
+	x392, _ = p521AddcarryxU64(x26, x12, x391)
+	var x394 uint64
+	var x395 p521Uint1
+	x394, x395 = p521AddcarryxU64(x37, x390, 0x0)
+	var x396 uint64
+	x396, _ = p521AddcarryxU64(x38, x392, x395)
+	var x398 uint64
+	var x399 p521Uint1
+	x398, x399 = p521AddcarryxU64(x47, x394, 0x0)
+	var x400 uint64
+	x400, _ = p521AddcarryxU64(x48, x396, x399)
+	var x402 uint64
+	var x403 p521Uint1
+	x402, x403 = p521AddcarryxU64(x55, x398, 0x0)
+	var x404 uint64
+	x404, _ = p521AddcarryxU64(x56, x400, x403)
+	var x406 uint64
+	var x407 p521Uint1
+	x406, x407 = p521AddcarryxU64(x61, x402, 0x0)
+	var x408 uint64
+	x408, _ = p521AddcarryxU64(x62, x404, x407)
+	var x410 uint64
+	var x411 p521Uint1
+	x410, x411 = p521AddcarryxU64(x127, x406, 0x0)
+	var x412 uint64
+	x412, _ = p521AddcarryxU64(x128, x408, x411)
+	var x414 uint64
+	var x415 p521Uint1
+	x414, x415 = p521AddcarryxU64(x141, x410, 0x0)
+	var x416 uint64
+	x416, _ = p521AddcarryxU64(x142, x412, x415)
+	var x418 uint64
+	var x419 p521Uint1
+	x418, x419 = p521AddcarryxU64(x157, x414, 0x0)
+	var x420 uint64
+	x420, _ = p521AddcarryxU64(x158, x416, x419)
+	var x422 uint64
+	var x423 p521Uint1
+	x422, x423 = p521AddcarryxU64(x27, x13, 0x0)
+	var x424 uint64
+	x424, _ = p521AddcarryxU64(x28, x14, x423)
+	var x426 uint64
+	var x427 p521Uint1
+	x426, x427 = p521AddcarryxU64(x39, x422, 0x0)
+	var x428 uint64
+	x428, _ = p521AddcarryxU64(x40, x424, x427)
+	var x430 uint64
+	var x431 p521Uint1
+	x430, x431 = p521AddcarryxU64(x49, x426, 0x0)
+	var x432 uint64
+	x432, _ = p521AddcarryxU64(x50, x428, x431)
+	var x434 uint64
+	var x435 p521Uint1
+	x434, x435 = p521AddcarryxU64(x57, x430, 0x0)
+	var x436 uint64
+	x436, _ = p521AddcarryxU64(x58, x432, x435)
+	var x438 uint64
+	var x439 p521Uint1
+	x438, x439 = p521AddcarryxU64(x63, x434, 0x0)
+	var x440 uint64
+	x440, _ = p521AddcarryxU64(x64, x436, x439)
+	var x442 uint64
+	var x443 p521Uint1
+	x442, x443 = p521AddcarryxU64(x67, x438, 0x0)
+	var x444 uint64
+	x444, _ = p521AddcarryxU64(x68, x440, x443)
+	var x446 uint64
+	var x447 p521Uint1
+	x446, x447 = p521AddcarryxU64(x143, x442, 0x0)
+	var x448 uint64
+	x448, _ = p521AddcarryxU64(x144, x444, x447)
+	var x450 uint64
+	var x451 p521Uint1
+	x450, x451 = p521AddcarryxU64(x159, x446, 0x0)
+	var x452 uint64
+	x452, _ = p521AddcarryxU64(x160, x448, x451)
+	var x454 uint64
+	var x455 p521Uint1
+	x454, x455 = p521AddcarryxU64(x195, x450, 0x0)
+	var x456 uint64
+	x456, _ = p521AddcarryxU64(x196, x452, x455)
+	x458 := ((x454 >> 58) | ((x456 << 6) & 0xffffffffffffffff))
+	x459 := (x456 >> 58)
+	x460 := (x454 & 0x3ffffffffffffff)
+	var x461 uint64
+	var x462 p521Uint1
+	x461, x462 = p521AddcarryxU64(x458, x418, 0x0)
+	var x463 uint64
+	x463, _ = p521AddcarryxU64(x459, x420, x462)
+	x465 := ((x461 >> 58) | ((x463 << 6) & 0xffffffffffffffff))
+	x466 := (x463 >> 58)
+	x467 := (x461 & 0x3ffffffffffffff)
+	var x468 uint64
+	var x469 p521Uint1
+	x468, x469 = p521AddcarryxU64(x465, x386, 0x0)
+	var x470 uint64
+	x470, _ = p521AddcarryxU64(x466, x388, x469)
+	x472 := ((x468 >> 58) | ((x470 << 6) & 0xffffffffffffffff))
+	x473 := (x470 >> 58)
+	x474 := (x468 & 0x3ffffffffffffff)
+	var x475 uint64
+	var x476 p521Uint1
+	x475, x476 = p521AddcarryxU64(x472, x354, 0x0)
+	var x477 uint64
+	x477, _ = p521AddcarryxU64(x473, x356, x476)
+	x479 := ((x475 >> 58) | ((x477 << 6) & 0xffffffffffffffff))
+	x480 := (x477 >> 58)
+	x481 := (x475 & 0x3ffffffffffffff)
+	var x482 uint64
+	var x483 p521Uint1
+	x482, x483 = p521AddcarryxU64(x479, x322, 0x0)
+	var x484 uint64
+	x484, _ = p521AddcarryxU64(x480, x324, x483)
+	x486 := ((x482 >> 58) | ((x484 << 6) & 0xffffffffffffffff))
+	x487 := (x484 >> 58)
+	x488 := (x482 & 0x3ffffffffffffff)
+	var x489 uint64
+	var x490 p521Uint1
+	x489, x490 = p521AddcarryxU64(x486, x290, 0x0)
+	var x491 uint64
+	x491, _ = p521AddcarryxU64(x487, x292, x490)
+	x493 := ((x489 >> 58) | ((x491 << 6) & 0xffffffffffffffff))
+	x494 := (x491 >> 58)
+	x495 := (x489 & 0x3ffffffffffffff)
+	var x496 uint64
+	var x497 p521Uint1
+	x496, x497 = p521AddcarryxU64(x493, x258, 0x0)
+	var x498 uint64
+	x498, _ = p521AddcarryxU64(x494, x260, x497)
+	x500 := ((x496 >> 58) | ((x498 << 6) & 0xffffffffffffffff))
+	x501 := (x498 >> 58)
+	x502 := (x496 & 0x3ffffffffffffff)
+	var x503 uint64
+	var x504 p521Uint1
+	x503, x504 = p521AddcarryxU64(x500, x226, 0x0)
+	var x505 uint64
+	x505, _ = p521AddcarryxU64(x501, x228, x504)
+	x507 := ((x503 >> 57) | ((x505 << 7) & 0xffffffffffffffff))
+	x508 := (x505 >> 57)
+	x509 := (x503 & 0x1ffffffffffffff)
+	var x510 uint64
+	var x511 p521Uint1
+	x510, x511 = p521AddcarryxU64(x197, x507, 0x0)
+	x512 := (uint64(x511) + x508)
+	x513 := ((x510 >> 58) | ((x512 << 6) & 0xffffffffffffffff))
+	x514 := (x510 & 0x3ffffffffffffff)
+	x515 := (x513 + x460)
+	x516 := p521Uint1((x515 >> 58))
+	x517 := (x515 & 0x3ffffffffffffff)
+	x518 := (uint64(x516) + x467)
+	out1[0] = x514
+	out1[1] = x517
+	out1[2] = x518
+	out1[3] = x474
+	out1[4] = x481
+	out1[5] = x488
+	out1[6] = x495
+	out1[7] = x502
+	out1[8] = x509
+}
+
+// p521CarrySquare squares a field element and reduces the result.
+//
+// Postconditions:
+//   eval out1 mod m = (eval arg1 * eval arg1) mod m
+//
+// Input Bounds:
+//   arg1: [[0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0x600000000000000]]
+// Output Bounds:
+//   out1: [[0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x200000000000000]]
+func p521CarrySquare(out1 *[9]uint64, arg1 *[9]uint64) {
+	x1 := arg1[8]
+	x2 := (x1 * 0x2)
+	x3 := (arg1[8] * 0x2)
+	x4 := arg1[7]
+	x5 := (x4 * 0x2)
+	x6 := (arg1[7] * 0x2)
+	x7 := arg1[6]
+	x8 := (x7 * 0x2)
+	x9 := (arg1[6] * 0x2)
+	x10 := arg1[5]
+	x11 := (x10 * 0x2)
+	x12 := (arg1[5] * 0x2)
+	x13 := (arg1[4] * 0x2)
+	x14 := (arg1[3] * 0x2)
+	x15 := (arg1[2] * 0x2)
+	x16 := (arg1[1] * 0x2)
+	var x17 uint64
+	var x18 uint64
+	x18, x17 = bits.Mul64(arg1[8], (x1 * 0x2))
+	var x19 uint64
+	var x20 uint64
+	x20, x19 = bits.Mul64(arg1[7], (x2 * 0x2))
+	var x21 uint64
+	var x22 uint64
+	x22, x21 = bits.Mul64(arg1[7], (x4 * 0x2))
+	var x23 uint64
+	var x24 uint64
+	x24, x23 = bits.Mul64(arg1[6], (x2 * 0x2))
+	var x25 uint64
+	var x26 uint64
+	x26, x25 = bits.Mul64(arg1[6], (x5 * 0x2))
+	var x27 uint64
+	var x28 uint64
+	x28, x27 = bits.Mul64(arg1[6], (x7 * 0x2))
+	var x29 uint64
+	var x30 uint64
+	x30, x29 = bits.Mul64(arg1[5], (x2 * 0x2))
+	var x31 uint64
+	var x32 uint64
+	x32, x31 = bits.Mul64(arg1[5], (x5 * 0x2))
+	var x33 uint64
+	var x34 uint64
+	x34, x33 = bits.Mul64(arg1[5], (x8 * 0x2))
+	var x35 uint64
+	var x36 uint64
+	x36, x35 = bits.Mul64(arg1[5], (x10 * 0x2))
+	var x37 uint64
+	var x38 uint64
+	x38, x37 = bits.Mul64(arg1[4], (x2 * 0x2))
+	var x39 uint64
+	var x40 uint64
+	x40, x39 = bits.Mul64(arg1[4], (x5 * 0x2))
+	var x41 uint64
+	var x42 uint64
+	x42, x41 = bits.Mul64(arg1[4], (x8 * 0x2))
+	var x43 uint64
+	var x44 uint64
+	x44, x43 = bits.Mul64(arg1[4], (x11 * 0x2))
+	var x45 uint64
+	var x46 uint64
+	x46, x45 = bits.Mul64(arg1[4], arg1[4])
+	var x47 uint64
+	var x48 uint64
+	x48, x47 = bits.Mul64(arg1[3], (x2 * 0x2))
+	var x49 uint64
+	var x50 uint64
+	x50, x49 = bits.Mul64(arg1[3], (x5 * 0x2))
+	var x51 uint64
+	var x52 uint64
+	x52, x51 = bits.Mul64(arg1[3], (x8 * 0x2))
+	var x53 uint64
+	var x54 uint64
+	x54, x53 = bits.Mul64(arg1[3], x12)
+	var x55 uint64
+	var x56 uint64
+	x56, x55 = bits.Mul64(arg1[3], x13)
+	var x57 uint64
+	var x58 uint64
+	x58, x57 = bits.Mul64(arg1[3], arg1[3])
+	var x59 uint64
+	var x60 uint64
+	x60, x59 = bits.Mul64(arg1[2], (x2 * 0x2))
+	var x61 uint64
+	var x62 uint64
+	x62, x61 = bits.Mul64(arg1[2], (x5 * 0x2))
+	var x63 uint64
+	var x64 uint64
+	x64, x63 = bits.Mul64(arg1[2], x9)
+	var x65 uint64
+	var x66 uint64
+	x66, x65 = bits.Mul64(arg1[2], x12)
+	var x67 uint64
+	var x68 uint64
+	x68, x67 = bits.Mul64(arg1[2], x13)
+	var x69 uint64
+	var x70 uint64
+	x70, x69 = bits.Mul64(arg1[2], x14)
+	var x71 uint64
+	var x72 uint64
+	x72, x71 = bits.Mul64(arg1[2], arg1[2])
+	var x73 uint64
+	var x74 uint64
+	x74, x73 = bits.Mul64(arg1[1], (x2 * 0x2))
+	var x75 uint64
+	var x76 uint64
+	x76, x75 = bits.Mul64(arg1[1], x6)
+	var x77 uint64
+	var x78 uint64
+	x78, x77 = bits.Mul64(arg1[1], x9)
+	var x79 uint64
+	var x80 uint64
+	x80, x79 = bits.Mul64(arg1[1], x12)
+	var x81 uint64
+	var x82 uint64
+	x82, x81 = bits.Mul64(arg1[1], x13)
+	var x83 uint64
+	var x84 uint64
+	x84, x83 = bits.Mul64(arg1[1], x14)
+	var x85 uint64
+	var x86 uint64
+	x86, x85 = bits.Mul64(arg1[1], x15)
+	var x87 uint64
+	var x88 uint64
+	x88, x87 = bits.Mul64(arg1[1], arg1[1])
+	var x89 uint64
+	var x90 uint64
+	x90, x89 = bits.Mul64(arg1[0], x3)
+	var x91 uint64
+	var x92 uint64
+	x92, x91 = bits.Mul64(arg1[0], x6)
+	var x93 uint64
+	var x94 uint64
+	x94, x93 = bits.Mul64(arg1[0], x9)
+	var x95 uint64
+	var x96 uint64
+	x96, x95 = bits.Mul64(arg1[0], x12)
+	var x97 uint64
+	var x98 uint64
+	x98, x97 = bits.Mul64(arg1[0], x13)
+	var x99 uint64
+	var x100 uint64
+	x100, x99 = bits.Mul64(arg1[0], x14)
+	var x101 uint64
+	var x102 uint64
+	x102, x101 = bits.Mul64(arg1[0], x15)
+	var x103 uint64
+	var x104 uint64
+	x104, x103 = bits.Mul64(arg1[0], x16)
+	var x105 uint64
+	var x106 uint64
+	x106, x105 = bits.Mul64(arg1[0], arg1[0])
+	var x107 uint64
+	var x108 p521Uint1
+	x107, x108 = p521AddcarryxU64(x51, x43, 0x0)
+	var x109 uint64
+	x109, _ = p521AddcarryxU64(x52, x44, x108)
+	var x111 uint64
+	var x112 p521Uint1
+	x111, x112 = p521AddcarryxU64(x61, x107, 0x0)
+	var x113 uint64
+	x113, _ = p521AddcarryxU64(x62, x109, x112)
+	var x115 uint64
+	var x116 p521Uint1
+	x115, x116 = p521AddcarryxU64(x73, x111, 0x0)
+	var x117 uint64
+	x117, _ = p521AddcarryxU64(x74, x113, x116)
+	var x119 uint64
+	var x120 p521Uint1
+	x119, x120 = p521AddcarryxU64(x105, x115, 0x0)
+	var x121 uint64
+	x121, _ = p521AddcarryxU64(x106, x117, x120)
+	x123 := ((x119 >> 58) | ((x121 << 6) & 0xffffffffffffffff))
+	x124 := (x121 >> 58)
+	x125 := (x119 & 0x3ffffffffffffff)
+	var x126 uint64
+	var x127 p521Uint1
+	x126, x127 = p521AddcarryxU64(x53, x45, 0x0)
+	var x128 uint64
+	x128, _ = p521AddcarryxU64(x54, x46, x127)
+	var x130 uint64
+	var x131 p521Uint1
+	x130, x131 = p521AddcarryxU64(x63, x126, 0x0)
+	var x132 uint64
+	x132, _ = p521AddcarryxU64(x64, x128, x131)
+	var x134 uint64
+	var x135 p521Uint1
+	x134, x135 = p521AddcarryxU64(x75, x130, 0x0)
+	var x136 uint64
+	x136, _ = p521AddcarryxU64(x76, x132, x135)
+	var x138 uint64
+	var x139 p521Uint1
+	x138, x139 = p521AddcarryxU64(x89, x134, 0x0)
+	var x140 uint64
+	x140, _ = p521AddcarryxU64(x90, x136, x139)
+	var x142 uint64
+	var x143 p521Uint1
+	x142, x143 = p521AddcarryxU64(x55, x17, 0x0)
+	var x144 uint64
+	x144, _ = p521AddcarryxU64(x56, x18, x143)
+	var x146 uint64
+	var x147 p521Uint1
+	x146, x147 = p521AddcarryxU64(x65, x142, 0x0)
+	var x148 uint64
+	x148, _ = p521AddcarryxU64(x66, x144, x147)
+	var x150 uint64
+	var x151 p521Uint1
+	x150, x151 = p521AddcarryxU64(x77, x146, 0x0)
+	var x152 uint64
+	x152, _ = p521AddcarryxU64(x78, x148, x151)
+	var x154 uint64
+	var x155 p521Uint1
+	x154, x155 = p521AddcarryxU64(x91, x150, 0x0)
+	var x156 uint64
+	x156, _ = p521AddcarryxU64(x92, x152, x155)
+	var x158 uint64
+	var x159 p521Uint1
+	x158, x159 = p521AddcarryxU64(x57, x19, 0x0)
+	var x160 uint64
+	x160, _ = p521AddcarryxU64(x58, x20, x159)
+	var x162 uint64
+	var x163 p521Uint1
+	x162, x163 = p521AddcarryxU64(x67, x158, 0x0)
+	var x164 uint64
+	x164, _ = p521AddcarryxU64(x68, x160, x163)
+	var x166 uint64
+	var x167 p521Uint1
+	x166, x167 = p521AddcarryxU64(x79, x162, 0x0)
+	var x168 uint64
+	x168, _ = p521AddcarryxU64(x80, x164, x167)
+	var x170 uint64
+	var x171 p521Uint1
+	x170, x171 = p521AddcarryxU64(x93, x166, 0x0)
+	var x172 uint64
+	x172, _ = p521AddcarryxU64(x94, x168, x171)
+	var x174 uint64
+	var x175 p521Uint1
+	x174, x175 = p521AddcarryxU64(x23, x21, 0x0)
+	var x176 uint64
+	x176, _ = p521AddcarryxU64(x24, x22, x175)
+	var x178 uint64
+	var x179 p521Uint1
+	x178, x179 = p521AddcarryxU64(x69, x174, 0x0)
+	var x180 uint64
+	x180, _ = p521AddcarryxU64(x70, x176, x179)
+	var x182 uint64
+	var x183 p521Uint1
+	x182, x183 = p521AddcarryxU64(x81, x178, 0x0)
+	var x184 uint64
+	x184, _ = p521AddcarryxU64(x82, x180, x183)
+	var x186 uint64
+	var x187 p521Uint1
+	x186, x187 = p521AddcarryxU64(x95, x182, 0x0)
+	var x188 uint64
+	x188, _ = p521AddcarryxU64(x96, x184, x187)
+	var x190 uint64
+	var x191 p521Uint1
+	x190, x191 = p521AddcarryxU64(x29, x25, 0x0)
+	var x192 uint64
+	x192, _ = p521AddcarryxU64(x30, x26, x191)
+	var x194 uint64
+	var x195 p521Uint1
+	x194, x195 = p521AddcarryxU64(x71, x190, 0x0)
+	var x196 uint64
+	x196, _ = p521AddcarryxU64(x72, x192, x195)
+	var x198 uint64
+	var x199 p521Uint1
+	x198, x199 = p521AddcarryxU64(x83, x194, 0x0)
+	var x200 uint64
+	x200, _ = p521AddcarryxU64(x84, x196, x199)
+	var x202 uint64
+	var x203 p521Uint1
+	x202, x203 = p521AddcarryxU64(x97, x198, 0x0)
+	var x204 uint64
+	x204, _ = p521AddcarryxU64(x98, x200, x203)
+	var x206 uint64
+	var x207 p521Uint1
+	x206, x207 = p521AddcarryxU64(x31, x27, 0x0)
+	var x208 uint64
+	x208, _ = p521AddcarryxU64(x32, x28, x207)
+	var x210 uint64
+	var x211 p521Uint1
+	x210, x211 = p521AddcarryxU64(x37, x206, 0x0)
+	var x212 uint64
+	x212, _ = p521AddcarryxU64(x38, x208, x211)
+	var x214 uint64
+	var x215 p521Uint1
+	x214, x215 = p521AddcarryxU64(x85, x210, 0x0)
+	var x216 uint64
+	x216, _ = p521AddcarryxU64(x86, x212, x215)
+	var x218 uint64
+	var x219 p521Uint1
+	x218, x219 = p521AddcarryxU64(x99, x214, 0x0)
+	var x220 uint64
+	x220, _ = p521AddcarryxU64(x100, x216, x219)
+	var x222 uint64
+	var x223 p521Uint1
+	x222, x223 = p521AddcarryxU64(x39, x33, 0x0)
+	var x224 uint64
+	x224, _ = p521AddcarryxU64(x40, x34, x223)
+	var x226 uint64
+	var x227 p521Uint1
+	x226, x227 = p521AddcarryxU64(x47, x222, 0x0)
+	var x228 uint64
+	x228, _ = p521AddcarryxU64(x48, x224, x227)
+	var x230 uint64
+	var x231 p521Uint1
+	x230, x231 = p521AddcarryxU64(x87, x226, 0x0)
+	var x232 uint64
+	x232, _ = p521AddcarryxU64(x88, x228, x231)
+	var x234 uint64
+	var x235 p521Uint1
+	x234, x235 = p521AddcarryxU64(x101, x230, 0x0)
+	var x236 uint64
+	x236, _ = p521AddcarryxU64(x102, x232, x235)
+	var x238 uint64
+	var x239 p521Uint1
+	x238, x239 = p521AddcarryxU64(x41, x35, 0x0)
+	var x240 uint64
+	x240, _ = p521AddcarryxU64(x42, x36, x239)
+	var x242 uint64
+	var x243 p521Uint1
+	x242, x243 = p521AddcarryxU64(x49, x238, 0x0)
+	var x244 uint64
+	x244, _ = p521AddcarryxU64(x50, x240, x243)
+	var x246 uint64
+	var x247 p521Uint1
+	x246, x247 = p521AddcarryxU64(x59, x242, 0x0)
+	var x248 uint64
+	x248, _ = p521AddcarryxU64(x60, x244, x247)
+	var x250 uint64
+	var x251 p521Uint1
+	x250, x251 = p521AddcarryxU64(x103, x246, 0x0)
+	var x252 uint64
+	x252, _ = p521AddcarryxU64(x104, x248, x251)
+	var x254 uint64
+	var x255 p521Uint1
+	x254, x255 = p521AddcarryxU64(x123, x250, 0x0)
+	var x256 uint64
+	x256, _ = p521AddcarryxU64(x124, x252, x255)
+	x258 := ((x254 >> 58) | ((x256 << 6) & 0xffffffffffffffff))
+	x259 := (x256 >> 58)
+	x260 := (x254 & 0x3ffffffffffffff)
+	var x261 uint64
+	var x262 p521Uint1
+	x261, x262 = p521AddcarryxU64(x258, x234, 0x0)
+	var x263 uint64
+	x263, _ = p521AddcarryxU64(x259, x236, x262)
+	x265 := ((x261 >> 58) | ((x263 << 6) & 0xffffffffffffffff))
+	x266 := (x263 >> 58)
+	x267 := (x261 & 0x3ffffffffffffff)
+	var x268 uint64
+	var x269 p521Uint1
+	x268, x269 = p521AddcarryxU64(x265, x218, 0x0)
+	var x270 uint64
+	x270, _ = p521AddcarryxU64(x266, x220, x269)
+	x272 := ((x268 >> 58) | ((x270 << 6) & 0xffffffffffffffff))
+	x273 := (x270 >> 58)
+	x274 := (x268 & 0x3ffffffffffffff)
+	var x275 uint64
+	var x276 p521Uint1
+	x275, x276 = p521AddcarryxU64(x272, x202, 0x0)
+	var x277 uint64
+	x277, _ = p521AddcarryxU64(x273, x204, x276)
+	x279 := ((x275 >> 58) | ((x277 << 6) & 0xffffffffffffffff))
+	x280 := (x277 >> 58)
+	x281 := (x275 & 0x3ffffffffffffff)
+	var x282 uint64
+	var x283 p521Uint1
+	x282, x283 = p521AddcarryxU64(x279, x186, 0x0)
+	var x284 uint64
+	x284, _ = p521AddcarryxU64(x280, x188, x283)
+	x286 := ((x282 >> 58) | ((x284 << 6) & 0xffffffffffffffff))
+	x287 := (x284 >> 58)
+	x288 := (x282 & 0x3ffffffffffffff)
+	var x289 uint64
+	var x290 p521Uint1
+	x289, x290 = p521AddcarryxU64(x286, x170, 0x0)
+	var x291 uint64
+	x291, _ = p521AddcarryxU64(x287, x172, x290)
+	x293 := ((x289 >> 58) | ((x291 << 6) & 0xffffffffffffffff))
+	x294 := (x291 >> 58)
+	x295 := (x289 & 0x3ffffffffffffff)
+	var x296 uint64
+	var x297 p521Uint1
+	x296, x297 = p521AddcarryxU64(x293, x154, 0x0)
+	var x298 uint64
+	x298, _ = p521AddcarryxU64(x294, x156, x297)
+	x300 := ((x296 >> 58) | ((x298 << 6) & 0xffffffffffffffff))
+	x301 := (x298 >> 58)
+	x302 := (x296 & 0x3ffffffffffffff)
+	var x303 uint64
+	var x304 p521Uint1
+	x303, x304 = p521AddcarryxU64(x300, x138, 0x0)
+	var x305 uint64
+	x305, _ = p521AddcarryxU64(x301, x140, x304)
+	x307 := ((x303 >> 57) | ((x305 << 7) & 0xffffffffffffffff))
+	x308 := (x305 >> 57)
+	x309 := (x303 & 0x1ffffffffffffff)
+	var x310 uint64
+	var x311 p521Uint1
+	x310, x311 = p521AddcarryxU64(x125, x307, 0x0)
+	x312 := (uint64(x311) + x308)
+	x313 := ((x310 >> 58) | ((x312 << 6) & 0xffffffffffffffff))
+	x314 := (x310 & 0x3ffffffffffffff)
+	x315 := (x313 + x260)
+	x316 := p521Uint1((x315 >> 58))
+	x317 := (x315 & 0x3ffffffffffffff)
+	x318 := (uint64(x316) + x267)
+	out1[0] = x314
+	out1[1] = x317
+	out1[2] = x318
+	out1[3] = x274
+	out1[4] = x281
+	out1[5] = x288
+	out1[6] = x295
+	out1[7] = x302
+	out1[8] = x309
+}
+
+// p521Carry reduces a field element.
+//
+// Postconditions:
+//   eval out1 mod m = eval arg1 mod m
+//
+// Input Bounds:
+//   arg1: [[0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0x600000000000000]]
+// Output Bounds:
+//   out1: [[0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x200000000000000]]
+func p521Carry(out1 *[9]uint64, arg1 *[9]uint64) {
+	x1 := arg1[0]
+	x2 := ((x1 >> 58) + arg1[1])
+	x3 := ((x2 >> 58) + arg1[2])
+	x4 := ((x3 >> 58) + arg1[3])
+	x5 := ((x4 >> 58) + arg1[4])
+	x6 := ((x5 >> 58) + arg1[5])
+	x7 := ((x6 >> 58) + arg1[6])
+	x8 := ((x7 >> 58) + arg1[7])
+	x9 := ((x8 >> 58) + arg1[8])
+	x10 := ((x1 & 0x3ffffffffffffff) + (x9 >> 57))
+	x11 := (uint64(p521Uint1((x10 >> 58))) + (x2 & 0x3ffffffffffffff))
+	x12 := (x10 & 0x3ffffffffffffff)
+	x13 := (x11 & 0x3ffffffffffffff)
+	x14 := (uint64(p521Uint1((x11 >> 58))) + (x3 & 0x3ffffffffffffff))
+	x15 := (x4 & 0x3ffffffffffffff)
+	x16 := (x5 & 0x3ffffffffffffff)
+	x17 := (x6 & 0x3ffffffffffffff)
+	x18 := (x7 & 0x3ffffffffffffff)
+	x19 := (x8 & 0x3ffffffffffffff)
+	x20 := (x9 & 0x1ffffffffffffff)
+	out1[0] = x12
+	out1[1] = x13
+	out1[2] = x14
+	out1[3] = x15
+	out1[4] = x16
+	out1[5] = x17
+	out1[6] = x18
+	out1[7] = x19
+	out1[8] = x20
+}
+
+// p521Add adds two field elements.
+//
+// Postconditions:
+//   eval out1 mod m = (eval arg1 + eval arg2) mod m
+//
+// Input Bounds:
+//   arg1: [[0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x200000000000000]]
+//   arg2: [[0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x200000000000000]]
+// Output Bounds:
+//   out1: [[0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0x600000000000000]]
+func p521Add(out1 *[9]uint64, arg1 *[9]uint64, arg2 *[9]uint64) {
+	x1 := (arg1[0] + arg2[0])
+	x2 := (arg1[1] + arg2[1])
+	x3 := (arg1[2] + arg2[2])
+	x4 := (arg1[3] + arg2[3])
+	x5 := (arg1[4] + arg2[4])
+	x6 := (arg1[5] + arg2[5])
+	x7 := (arg1[6] + arg2[6])
+	x8 := (arg1[7] + arg2[7])
+	x9 := (arg1[8] + arg2[8])
+	out1[0] = x1
+	out1[1] = x2
+	out1[2] = x3
+	out1[3] = x4
+	out1[4] = x5
+	out1[5] = x6
+	out1[6] = x7
+	out1[7] = x8
+	out1[8] = x9
+}
+
+// p521Sub subtracts two field elements.
+//
+// Postconditions:
+//   eval out1 mod m = (eval arg1 - eval arg2) mod m
+//
+// Input Bounds:
+//   arg1: [[0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x200000000000000]]
+//   arg2: [[0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x200000000000000]]
+// Output Bounds:
+//   out1: [[0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0xc00000000000000], [0x0 ~> 0x600000000000000]]
+func p521Sub(out1 *[9]uint64, arg1 *[9]uint64, arg2 *[9]uint64) {
+	x1 := ((0x7fffffffffffffe + arg1[0]) - arg2[0])
+	x2 := ((0x7fffffffffffffe + arg1[1]) - arg2[1])
+	x3 := ((0x7fffffffffffffe + arg1[2]) - arg2[2])
+	x4 := ((0x7fffffffffffffe + arg1[3]) - arg2[3])
+	x5 := ((0x7fffffffffffffe + arg1[4]) - arg2[4])
+	x6 := ((0x7fffffffffffffe + arg1[5]) - arg2[5])
+	x7 := ((0x7fffffffffffffe + arg1[6]) - arg2[6])
+	x8 := ((0x7fffffffffffffe + arg1[7]) - arg2[7])
+	x9 := ((0x3fffffffffffffe + arg1[8]) - arg2[8])
+	out1[0] = x1
+	out1[1] = x2
+	out1[2] = x3
+	out1[3] = x4
+	out1[4] = x5
+	out1[5] = x6
+	out1[6] = x7
+	out1[7] = x8
+	out1[8] = x9
+}
+
+// p521ToBytes serializes a field element to bytes in little-endian order.
+//
+// Postconditions:
+//   out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..65]
+//
+// Input Bounds:
+//   arg1: [[0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x200000000000000]]
+// Output Bounds:
+//   out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1]]
+func p521ToBytes(out1 *[66]uint8, arg1 *[9]uint64) {
+	var x1 uint64
+	var x2 p521Uint1
+	p521SubborrowxU58(&x1, &x2, 0x0, arg1[0], 0x3ffffffffffffff)
+	var x3 uint64
+	var x4 p521Uint1
+	p521SubborrowxU58(&x3, &x4, x2, arg1[1], 0x3ffffffffffffff)
+	var x5 uint64
+	var x6 p521Uint1
+	p521SubborrowxU58(&x5, &x6, x4, arg1[2], 0x3ffffffffffffff)
+	var x7 uint64
+	var x8 p521Uint1
+	p521SubborrowxU58(&x7, &x8, x6, arg1[3], 0x3ffffffffffffff)
+	var x9 uint64
+	var x10 p521Uint1
+	p521SubborrowxU58(&x9, &x10, x8, arg1[4], 0x3ffffffffffffff)
+	var x11 uint64
+	var x12 p521Uint1
+	p521SubborrowxU58(&x11, &x12, x10, arg1[5], 0x3ffffffffffffff)
+	var x13 uint64
+	var x14 p521Uint1
+	p521SubborrowxU58(&x13, &x14, x12, arg1[6], 0x3ffffffffffffff)
+	var x15 uint64
+	var x16 p521Uint1
+	p521SubborrowxU58(&x15, &x16, x14, arg1[7], 0x3ffffffffffffff)
+	var x17 uint64
+	var x18 p521Uint1
+	p521SubborrowxU57(&x17, &x18, x16, arg1[8], 0x1ffffffffffffff)
+	var x19 uint64
+	p521CmovznzU64(&x19, x18, uint64(0x0), 0xffffffffffffffff)
+	var x20 uint64
+	var x21 p521Uint1
+	p521AddcarryxU58(&x20, &x21, 0x0, x1, (x19 & 0x3ffffffffffffff))
+	var x22 uint64
+	var x23 p521Uint1
+	p521AddcarryxU58(&x22, &x23, x21, x3, (x19 & 0x3ffffffffffffff))
+	var x24 uint64
+	var x25 p521Uint1
+	p521AddcarryxU58(&x24, &x25, x23, x5, (x19 & 0x3ffffffffffffff))
+	var x26 uint64
+	var x27 p521Uint1
+	p521AddcarryxU58(&x26, &x27, x25, x7, (x19 & 0x3ffffffffffffff))
+	var x28 uint64
+	var x29 p521Uint1
+	p521AddcarryxU58(&x28, &x29, x27, x9, (x19 & 0x3ffffffffffffff))
+	var x30 uint64
+	var x31 p521Uint1
+	p521AddcarryxU58(&x30, &x31, x29, x11, (x19 & 0x3ffffffffffffff))
+	var x32 uint64
+	var x33 p521Uint1
+	p521AddcarryxU58(&x32, &x33, x31, x13, (x19 & 0x3ffffffffffffff))
+	var x34 uint64
+	var x35 p521Uint1
+	p521AddcarryxU58(&x34, &x35, x33, x15, (x19 & 0x3ffffffffffffff))
+	var x36 uint64
+	var x37 p521Uint1
+	p521AddcarryxU57(&x36, &x37, x35, x17, (x19 & 0x1ffffffffffffff))
+	x38 := (x34 << 6)
+	x39 := (x32 << 4)
+	x40 := (x30 << 2)
+	x41 := (x26 << 6)
+	x42 := (x24 << 4)
+	x43 := (x22 << 2)
+	x44 := (uint8(x20) & 0xff)
+	x45 := (x20 >> 8)
+	x46 := (uint8(x45) & 0xff)
+	x47 := (x45 >> 8)
+	x48 := (uint8(x47) & 0xff)
+	x49 := (x47 >> 8)
+	x50 := (uint8(x49) & 0xff)
+	x51 := (x49 >> 8)
+	x52 := (uint8(x51) & 0xff)
+	x53 := (x51 >> 8)
+	x54 := (uint8(x53) & 0xff)
+	x55 := (x53 >> 8)
+	x56 := (uint8(x55) & 0xff)
+	x57 := uint8((x55 >> 8))
+	x58 := (x43 + uint64(x57))
+	x59 := (uint8(x58) & 0xff)
+	x60 := (x58 >> 8)
+	x61 := (uint8(x60) & 0xff)
+	x62 := (x60 >> 8)
+	x63 := (uint8(x62) & 0xff)
+	x64 := (x62 >> 8)
+	x65 := (uint8(x64) & 0xff)
+	x66 := (x64 >> 8)
+	x67 := (uint8(x66) & 0xff)
+	x68 := (x66 >> 8)
+	x69 := (uint8(x68) & 0xff)
+	x70 := (x68 >> 8)
+	x71 := (uint8(x70) & 0xff)
+	x72 := uint8((x70 >> 8))
+	x73 := (x42 + uint64(x72))
+	x74 := (uint8(x73) & 0xff)
+	x75 := (x73 >> 8)
+	x76 := (uint8(x75) & 0xff)
+	x77 := (x75 >> 8)
+	x78 := (uint8(x77) & 0xff)
+	x79 := (x77 >> 8)
+	x80 := (uint8(x79) & 0xff)
+	x81 := (x79 >> 8)
+	x82 := (uint8(x81) & 0xff)
+	x83 := (x81 >> 8)
+	x84 := (uint8(x83) & 0xff)
+	x85 := (x83 >> 8)
+	x86 := (uint8(x85) & 0xff)
+	x87 := uint8((x85 >> 8))
+	x88 := (x41 + uint64(x87))
+	x89 := (uint8(x88) & 0xff)
+	x90 := (x88 >> 8)
+	x91 := (uint8(x90) & 0xff)
+	x92 := (x90 >> 8)
+	x93 := (uint8(x92) & 0xff)
+	x94 := (x92 >> 8)
+	x95 := (uint8(x94) & 0xff)
+	x96 := (x94 >> 8)
+	x97 := (uint8(x96) & 0xff)
+	x98 := (x96 >> 8)
+	x99 := (uint8(x98) & 0xff)
+	x100 := (x98 >> 8)
+	x101 := (uint8(x100) & 0xff)
+	x102 := uint8((x100 >> 8))
+	x103 := (uint8(x28) & 0xff)
+	x104 := (x28 >> 8)
+	x105 := (uint8(x104) & 0xff)
+	x106 := (x104 >> 8)
+	x107 := (uint8(x106) & 0xff)
+	x108 := (x106 >> 8)
+	x109 := (uint8(x108) & 0xff)
+	x110 := (x108 >> 8)
+	x111 := (uint8(x110) & 0xff)
+	x112 := (x110 >> 8)
+	x113 := (uint8(x112) & 0xff)
+	x114 := (x112 >> 8)
+	x115 := (uint8(x114) & 0xff)
+	x116 := uint8((x114 >> 8))
+	x117 := (x40 + uint64(x116))
+	x118 := (uint8(x117) & 0xff)
+	x119 := (x117 >> 8)
+	x120 := (uint8(x119) & 0xff)
+	x121 := (x119 >> 8)
+	x122 := (uint8(x121) & 0xff)
+	x123 := (x121 >> 8)
+	x124 := (uint8(x123) & 0xff)
+	x125 := (x123 >> 8)
+	x126 := (uint8(x125) & 0xff)
+	x127 := (x125 >> 8)
+	x128 := (uint8(x127) & 0xff)
+	x129 := (x127 >> 8)
+	x130 := (uint8(x129) & 0xff)
+	x131 := uint8((x129 >> 8))
+	x132 := (x39 + uint64(x131))
+	x133 := (uint8(x132) & 0xff)
+	x134 := (x132 >> 8)
+	x135 := (uint8(x134) & 0xff)
+	x136 := (x134 >> 8)
+	x137 := (uint8(x136) & 0xff)
+	x138 := (x136 >> 8)
+	x139 := (uint8(x138) & 0xff)
+	x140 := (x138 >> 8)
+	x141 := (uint8(x140) & 0xff)
+	x142 := (x140 >> 8)
+	x143 := (uint8(x142) & 0xff)
+	x144 := (x142 >> 8)
+	x145 := (uint8(x144) & 0xff)
+	x146 := uint8((x144 >> 8))
+	x147 := (x38 + uint64(x146))
+	x148 := (uint8(x147) & 0xff)
+	x149 := (x147 >> 8)
+	x150 := (uint8(x149) & 0xff)
+	x151 := (x149 >> 8)
+	x152 := (uint8(x151) & 0xff)
+	x153 := (x151 >> 8)
+	x154 := (uint8(x153) & 0xff)
+	x155 := (x153 >> 8)
+	x156 := (uint8(x155) & 0xff)
+	x157 := (x155 >> 8)
+	x158 := (uint8(x157) & 0xff)
+	x159 := (x157 >> 8)
+	x160 := (uint8(x159) & 0xff)
+	x161 := uint8((x159 >> 8))
+	x162 := (uint8(x36) & 0xff)
+	x163 := (x36 >> 8)
+	x164 := (uint8(x163) & 0xff)
+	x165 := (x163 >> 8)
+	x166 := (uint8(x165) & 0xff)
+	x167 := (x165 >> 8)
+	x168 := (uint8(x167) & 0xff)
+	x169 := (x167 >> 8)
+	x170 := (uint8(x169) & 0xff)
+	x171 := (x169 >> 8)
+	x172 := (uint8(x171) & 0xff)
+	x173 := (x171 >> 8)
+	x174 := (uint8(x173) & 0xff)
+	x175 := p521Uint1((x173 >> 8))
+	out1[0] = x44
+	out1[1] = x46
+	out1[2] = x48
+	out1[3] = x50
+	out1[4] = x52
+	out1[5] = x54
+	out1[6] = x56
+	out1[7] = x59
+	out1[8] = x61
+	out1[9] = x63
+	out1[10] = x65
+	out1[11] = x67
+	out1[12] = x69
+	out1[13] = x71
+	out1[14] = x74
+	out1[15] = x76
+	out1[16] = x78
+	out1[17] = x80
+	out1[18] = x82
+	out1[19] = x84
+	out1[20] = x86
+	out1[21] = x89
+	out1[22] = x91
+	out1[23] = x93
+	out1[24] = x95
+	out1[25] = x97
+	out1[26] = x99
+	out1[27] = x101
+	out1[28] = x102
+	out1[29] = x103
+	out1[30] = x105
+	out1[31] = x107
+	out1[32] = x109
+	out1[33] = x111
+	out1[34] = x113
+	out1[35] = x115
+	out1[36] = x118
+	out1[37] = x120
+	out1[38] = x122
+	out1[39] = x124
+	out1[40] = x126
+	out1[41] = x128
+	out1[42] = x130
+	out1[43] = x133
+	out1[44] = x135
+	out1[45] = x137
+	out1[46] = x139
+	out1[47] = x141
+	out1[48] = x143
+	out1[49] = x145
+	out1[50] = x148
+	out1[51] = x150
+	out1[52] = x152
+	out1[53] = x154
+	out1[54] = x156
+	out1[55] = x158
+	out1[56] = x160
+	out1[57] = x161
+	out1[58] = x162
+	out1[59] = x164
+	out1[60] = x166
+	out1[61] = x168
+	out1[62] = x170
+	out1[63] = x172
+	out1[64] = x174
+	out1[65] = uint8(x175)
+}
+
+// p521FromBytes deserializes a field element from bytes in little-endian order.
+//
+// Postconditions:
+//   eval out1 mod m = bytes_eval arg1 mod m
+//
+// Input Bounds:
+//   arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1]]
+// Output Bounds:
+//   out1: [[0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x400000000000000], [0x0 ~> 0x200000000000000]]
+func p521FromBytes(out1 *[9]uint64, arg1 *[66]uint8) {
+	x1 := (uint64(p521Uint1(arg1[65])) << 56)
+	x2 := (uint64(arg1[64]) << 48)
+	x3 := (uint64(arg1[63]) << 40)
+	x4 := (uint64(arg1[62]) << 32)
+	x5 := (uint64(arg1[61]) << 24)
+	x6 := (uint64(arg1[60]) << 16)
+	x7 := (uint64(arg1[59]) << 8)
+	x8 := arg1[58]
+	x9 := (uint64(arg1[57]) << 50)
+	x10 := (uint64(arg1[56]) << 42)
+	x11 := (uint64(arg1[55]) << 34)
+	x12 := (uint64(arg1[54]) << 26)
+	x13 := (uint64(arg1[53]) << 18)
+	x14 := (uint64(arg1[52]) << 10)
+	x15 := (uint64(arg1[51]) << 2)
+	x16 := (uint64(arg1[50]) << 52)
+	x17 := (uint64(arg1[49]) << 44)
+	x18 := (uint64(arg1[48]) << 36)
+	x19 := (uint64(arg1[47]) << 28)
+	x20 := (uint64(arg1[46]) << 20)
+	x21 := (uint64(arg1[45]) << 12)
+	x22 := (uint64(arg1[44]) << 4)
+	x23 := (uint64(arg1[43]) << 54)
+	x24 := (uint64(arg1[42]) << 46)
+	x25 := (uint64(arg1[41]) << 38)
+	x26 := (uint64(arg1[40]) << 30)
+	x27 := (uint64(arg1[39]) << 22)
+	x28 := (uint64(arg1[38]) << 14)
+	x29 := (uint64(arg1[37]) << 6)
+	x30 := (uint64(arg1[36]) << 56)
+	x31 := (uint64(arg1[35]) << 48)
+	x32 := (uint64(arg1[34]) << 40)
+	x33 := (uint64(arg1[33]) << 32)
+	x34 := (uint64(arg1[32]) << 24)
+	x35 := (uint64(arg1[31]) << 16)
+	x36 := (uint64(arg1[30]) << 8)
+	x37 := arg1[29]
+	x38 := (uint64(arg1[28]) << 50)
+	x39 := (uint64(arg1[27]) << 42)
+	x40 := (uint64(arg1[26]) << 34)
+	x41 := (uint64(arg1[25]) << 26)
+	x42 := (uint64(arg1[24]) << 18)
+	x43 := (uint64(arg1[23]) << 10)
+	x44 := (uint64(arg1[22]) << 2)
+	x45 := (uint64(arg1[21]) << 52)
+	x46 := (uint64(arg1[20]) << 44)
+	x47 := (uint64(arg1[19]) << 36)
+	x48 := (uint64(arg1[18]) << 28)
+	x49 := (uint64(arg1[17]) << 20)
+	x50 := (uint64(arg1[16]) << 12)
+	x51 := (uint64(arg1[15]) << 4)
+	x52 := (uint64(arg1[14]) << 54)
+	x53 := (uint64(arg1[13]) << 46)
+	x54 := (uint64(arg1[12]) << 38)
+	x55 := (uint64(arg1[11]) << 30)
+	x56 := (uint64(arg1[10]) << 22)
+	x57 := (uint64(arg1[9]) << 14)
+	x58 := (uint64(arg1[8]) << 6)
+	x59 := (uint64(arg1[7]) << 56)
+	x60 := (uint64(arg1[6]) << 48)
+	x61 := (uint64(arg1[5]) << 40)
+	x62 := (uint64(arg1[4]) << 32)
+	x63 := (uint64(arg1[3]) << 24)
+	x64 := (uint64(arg1[2]) << 16)
+	x65 := (uint64(arg1[1]) << 8)
+	x66 := arg1[0]
+	x67 := (x65 + uint64(x66))
+	x68 := (x64 + x67)
+	x69 := (x63 + x68)
+	x70 := (x62 + x69)
+	x71 := (x61 + x70)
+	x72 := (x60 + x71)
+	x73 := (x59 + x72)
+	x74 := (x73 & 0x3ffffffffffffff)
+	x75 := uint8((x73 >> 58))
+	x76 := (x58 + uint64(x75))
+	x77 := (x57 + x76)
+	x78 := (x56 + x77)
+	x79 := (x55 + x78)
+	x80 := (x54 + x79)
+	x81 := (x53 + x80)
+	x82 := (x52 + x81)
+	x83 := (x82 & 0x3ffffffffffffff)
+	x84 := uint8((x82 >> 58))
+	x85 := (x51 + uint64(x84))
+	x86 := (x50 + x85)
+	x87 := (x49 + x86)
+	x88 := (x48 + x87)
+	x89 := (x47 + x88)
+	x90 := (x46 + x89)
+	x91 := (x45 + x90)
+	x92 := (x91 & 0x3ffffffffffffff)
+	x93 := uint8((x91 >> 58))
+	x94 := (x44 + uint64(x93))
+	x95 := (x43 + x94)
+	x96 := (x42 + x95)
+	x97 := (x41 + x96)
+	x98 := (x40 + x97)
+	x99 := (x39 + x98)
+	x100 := (x38 + x99)
+	x101 := (x36 + uint64(x37))
+	x102 := (x35 + x101)
+	x103 := (x34 + x102)
+	x104 := (x33 + x103)
+	x105 := (x32 + x104)
+	x106 := (x31 + x105)
+	x107 := (x30 + x106)
+	x108 := (x107 & 0x3ffffffffffffff)
+	x109 := uint8((x107 >> 58))
+	x110 := (x29 + uint64(x109))
+	x111 := (x28 + x110)
+	x112 := (x27 + x111)
+	x113 := (x26 + x112)
+	x114 := (x25 + x113)
+	x115 := (x24 + x114)
+	x116 := (x23 + x115)
+	x117 := (x116 & 0x3ffffffffffffff)
+	x118 := uint8((x116 >> 58))
+	x119 := (x22 + uint64(x118))
+	x120 := (x21 + x119)
+	x121 := (x20 + x120)
+	x122 := (x19 + x121)
+	x123 := (x18 + x122)
+	x124 := (x17 + x123)
+	x125 := (x16 + x124)
+	x126 := (x125 & 0x3ffffffffffffff)
+	x127 := uint8((x125 >> 58))
+	x128 := (x15 + uint64(x127))
+	x129 := (x14 + x128)
+	x130 := (x13 + x129)
+	x131 := (x12 + x130)
+	x132 := (x11 + x131)
+	x133 := (x10 + x132)
+	x134 := (x9 + x133)
+	x135 := (x7 + uint64(x8))
+	x136 := (x6 + x135)
+	x137 := (x5 + x136)
+	x138 := (x4 + x137)
+	x139 := (x3 + x138)
+	x140 := (x2 + x139)
+	x141 := (x1 + x140)
+	out1[0] = x74
+	out1[1] = x83
+	out1[2] = x92
+	out1[3] = x100
+	out1[4] = x108
+	out1[5] = x117
+	out1[6] = x126
+	out1[7] = x134
+	out1[8] = x141
+}
+
+// p521Selectznz is a multi-limb conditional select.
+//
+// Postconditions:
+//   eval out1 = (if arg1 = 0 then eval arg2 else eval arg3)
+//
+// Input Bounds:
+//   arg1: [0x0 ~> 0x1]
+//   arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
+//   arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
+// Output Bounds:
+//   out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
+func p521Selectznz(out1 *[9]uint64, arg1 p521Uint1, arg2 *[9]uint64, arg3 *[9]uint64) {
+	var x1 uint64
+	p521CmovznzU64(&x1, arg1, arg2[0], arg3[0])
+	var x2 uint64
+	p521CmovznzU64(&x2, arg1, arg2[1], arg3[1])
+	var x3 uint64
+	p521CmovznzU64(&x3, arg1, arg2[2], arg3[2])
+	var x4 uint64
+	p521CmovznzU64(&x4, arg1, arg2[3], arg3[3])
+	var x5 uint64
+	p521CmovznzU64(&x5, arg1, arg2[4], arg3[4])
+	var x6 uint64
+	p521CmovznzU64(&x6, arg1, arg2[5], arg3[5])
+	var x7 uint64
+	p521CmovznzU64(&x7, arg1, arg2[6], arg3[6])
+	var x8 uint64
+	p521CmovznzU64(&x8, arg1, arg2[7], arg3[7])
+	var x9 uint64
+	p521CmovznzU64(&x9, arg1, arg2[8], arg3[8])
+	out1[0] = x1
+	out1[1] = x2
+	out1[2] = x3
+	out1[3] = x4
+	out1[4] = x5
+	out1[5] = x6
+	out1[6] = x7
+	out1[7] = x8
+	out1[8] = x9
+}
diff --git a/src/crypto/elliptic/internal/fiat/p521_test.go b/src/crypto/elliptic/internal/fiat/p521_test.go
new file mode 100644
index 0000000000..661bde397e
--- /dev/null
+++ b/src/crypto/elliptic/internal/fiat/p521_test.go
@@ -0,0 +1,37 @@
+// Copyright 2021 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 fiat_test
+
+import (
+	"crypto/elliptic/internal/fiat"
+	"crypto/rand"
+	"testing"
+)
+
+func p521Random(t *testing.T) *fiat.P521Element {
+	buf := make([]byte, 66)
+	if _, err := rand.Read(buf); err != nil {
+		t.Fatal(err)
+	}
+	buf[65] &= 1
+	e, err := new(fiat.P521Element).SetBytes(buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return e
+}
+
+func TestP521Invert(t *testing.T) {
+	a := p521Random(t)
+	inv := new(fiat.P521Element).Invert(a)
+	one := new(fiat.P521Element).Mul(a, inv)
+	if new(fiat.P521Element).One().Equal(one) != 1 {
+		t.Errorf("a * 1/a != 1; got %x for %x", one.Bytes(), a.Bytes())
+	}
+	inv.Invert(new(fiat.P521Element))
+	if new(fiat.P521Element).Equal(inv) != 1 {
+		t.Errorf("1/0 != 0; got %x", inv.Bytes())
+	}
+}
diff --git a/src/crypto/elliptic/p521.go b/src/crypto/elliptic/p521.go
new file mode 100644
index 0000000000..ac9de63702
--- /dev/null
+++ b/src/crypto/elliptic/p521.go
@@ -0,0 +1,254 @@
+// Copyright 2013 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 elliptic
+
+import (
+	"crypto/elliptic/internal/fiat"
+	"math/big"
+)
+
+type p521Curve struct {
+	*CurveParams
+}
+
+var p521 p521Curve
+var p521Params *CurveParams
+
+func initP521() {
+	// See FIPS 186-3, section D.2.5
+	p521.CurveParams = &CurveParams{Name: "P-521"}
+	p521.P, _ = new(big.Int).SetString("6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151", 10)
+	p521.N, _ = new(big.Int).SetString("6864797660130609714981900799081393217269435300143305409394463459185543183397655394245057746333217197532963996371363321113864768612440380340372808892707005449", 10)
+	p521.B, _ = new(big.Int).SetString("051953eb9618e1c9a1f929a21a0b68540eea2da725b99b315f3b8b489918ef109e156193951ec7e937b1652c0bd3bb1bf073573df883d2c34f1ef451fd46b503f00", 16)
+	p521.Gx, _ = new(big.Int).SetString("c6858e06b70404e9cd9e3ecb662395b4429c648139053fb521f828af606b4d3dbaa14b5e77efe75928fe1dc127a2ffa8de3348b3c1856a429bf97e7e31c2e5bd66", 16)
+	p521.Gy, _ = new(big.Int).SetString("11839296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e662c97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650", 16)
+	p521.BitSize = 521
+}
+
+func (curve p521Curve) Params() *CurveParams {
+	return curve.CurveParams
+}
+
+func (curve p521Curve) IsOnCurve(x, y *big.Int) bool {
+	x1 := bigIntToFiatP521(x)
+	y1 := bigIntToFiatP521(y)
+	b := bigIntToFiatP521(curve.B) // TODO: precompute this value.
+
+	// x³ - 3x + b.
+	x3 := new(fiat.P521Element).Square(x1)
+	x3.Mul(x3, x1)
+
+	threeX := new(fiat.P521Element).Add(x1, x1)
+	threeX.Add(threeX, x1)
+
+	x3.Sub(x3, threeX)
+	x3.Add(x3, b)
+
+	// y² = x³ - 3x + b
+	y2 := new(fiat.P521Element).Square(y1)
+
+	return x3.Equal(y2) == 1
+}
+
+type p512Point struct {
+	x, y, z *fiat.P521Element
+}
+
+func fiatP521ToBigInt(x *fiat.P521Element) *big.Int {
+	xBytes := x.Bytes()
+	for i := range xBytes[:len(xBytes)/2] {
+		xBytes[i], xBytes[len(xBytes)-i-1] = xBytes[len(xBytes)-i-1], xBytes[i]
+	}
+	return new(big.Int).SetBytes(xBytes)
+}
+
+// affineFromJacobian brings a point in Jacobian coordinates back to affine
+// coordinates, with (0, 0) representing infinity by convention. It also goes
+// back to big.Int values to match the exposed API.
+func (curve p521Curve) affineFromJacobian(p *p512Point) (x, y *big.Int) {
+	if p.z.IsZero() == 1 {
+		return new(big.Int), new(big.Int)
+	}
+
+	zinv := new(fiat.P521Element).Invert(p.z)
+	zinvsq := new(fiat.P521Element).Mul(zinv, zinv)
+
+	xx := new(fiat.P521Element).Mul(p.x, zinvsq)
+	zinvsq.Mul(zinvsq, zinv)
+	yy := new(fiat.P521Element).Mul(p.y, zinvsq)
+
+	return fiatP521ToBigInt(xx), fiatP521ToBigInt(yy)
+}
+
+func bigIntToFiatP521(x *big.Int) *fiat.P521Element {
+	xBytes := new(big.Int).Mod(x, p521.P).FillBytes(make([]byte, 66))
+	for i := range xBytes[:len(xBytes)/2] {
+		xBytes[i], xBytes[len(xBytes)-i-1] = xBytes[len(xBytes)-i-1], xBytes[i]
+	}
+	x1, err := new(fiat.P521Element).SetBytes(xBytes)
+	if err != nil {
+		// The input is reduced modulo P and encoded in a fixed size bytes
+		// slice, this should be impossible.
+		panic("internal error: bigIntToFiatP521")
+	}
+	return x1
+}
+
+// jacobianFromAffine converts (x, y) affine coordinates into (x, y, z) Jacobian
+// coordinates. It also converts from big.Int to fiat, which is necessarily a
+// messy and variable-time operation, which we can't avoid due to the exposed API.
+func (curve p521Curve) jacobianFromAffine(x, y *big.Int) *p512Point {
+	// (0, 0) is by convention the point at infinity, which can't be represented
+	// in affine coordinates, but is (0, 0, 0) in Jacobian.
+	if x.Sign() == 0 && y.Sign() == 0 {
+		return &p512Point{
+			x: new(fiat.P521Element),
+			y: new(fiat.P521Element),
+			z: new(fiat.P521Element),
+		}
+	}
+	return &p512Point{
+		x: bigIntToFiatP521(x),
+		y: bigIntToFiatP521(y),
+		z: new(fiat.P521Element).One(),
+	}
+}
+
+func (curve p521Curve) Add(x1, y1, x2, y2 *big.Int) (*big.Int, *big.Int) {
+	p1 := curve.jacobianFromAffine(x1, y1)
+	p2 := curve.jacobianFromAffine(x2, y2)
+	return curve.affineFromJacobian(p1.addJacobian(p1, p2))
+}
+
+// addJacobian sets q = p1 + p2, and returns q. The points may overlap.
+func (q *p512Point) addJacobian(p1, p2 *p512Point) *p512Point {
+	// https://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#addition-add-2007-bl
+	if p1.z.IsZero() == 1 {
+		q.x.Set(p2.x)
+		q.y.Set(p2.y)
+		q.z.Set(p2.z)
+		return q
+	}
+	if p2.z.IsZero() == 1 {
+		q.x.Set(p1.x)
+		q.y.Set(p1.y)
+		q.z.Set(p1.z)
+		return q
+	}
+
+	z1z1 := new(fiat.P521Element).Square(p1.z)
+	z2z2 := new(fiat.P521Element).Square(p2.z)
+
+	u1 := new(fiat.P521Element).Mul(p1.x, z2z2)
+	u2 := new(fiat.P521Element).Mul(p2.x, z1z1)
+	h := new(fiat.P521Element).Sub(u2, u1)
+	xEqual := h.IsZero() == 1
+	i := new(fiat.P521Element).Add(h, h)
+	i.Square(i)
+	j := new(fiat.P521Element).Mul(h, i)
+
+	s1 := new(fiat.P521Element).Mul(p1.y, p2.z)
+	s1.Mul(s1, z2z2)
+	s2 := new(fiat.P521Element).Mul(p2.y, p1.z)
+	s2.Mul(s2, z1z1)
+	r := new(fiat.P521Element).Sub(s2, s1)
+	yEqual := r.IsZero() == 1
+	if xEqual && yEqual {
+		return q.doubleJacobian(p1)
+	}
+	r.Add(r, r)
+	v := new(fiat.P521Element).Mul(u1, i)
+
+	q.x.Set(r)
+	q.x.Square(q.x)
+	q.x.Sub(q.x, j)
+	q.x.Sub(q.x, v)
+	q.x.Sub(q.x, v)
+
+	q.y.Set(r)
+	v.Sub(v, q.x)
+	q.y.Mul(q.y, v)
+	s1.Mul(s1, j)
+	s1.Add(s1, s1)
+	q.y.Sub(q.y, s1)
+
+	q.z.Add(p1.z, p2.z)
+	q.z.Square(q.z)
+	q.z.Sub(q.z, z1z1)
+	q.z.Sub(q.z, z2z2)
+	q.z.Mul(q.z, h)
+
+	return q
+}
+
+func (curve p521Curve) Double(x1, y1 *big.Int) (*big.Int, *big.Int) {
+	p := curve.jacobianFromAffine(x1, y1)
+	return curve.affineFromJacobian(p.doubleJacobian(p))
+}
+
+// doubleJacobian sets q = p + p, and returns q. The points may overlap.
+func (q *p512Point) doubleJacobian(p *p512Point) *p512Point {
+	// https://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#doubling-dbl-2001-b
+	delta := new(fiat.P521Element).Square(p.z)
+	gamma := new(fiat.P521Element).Square(p.y)
+	alpha := new(fiat.P521Element).Sub(p.x, delta)
+	alpha2 := new(fiat.P521Element).Add(p.x, delta)
+	alpha.Mul(alpha, alpha2)
+	alpha2.Set(alpha)
+	alpha.Add(alpha, alpha)
+	alpha.Add(alpha, alpha2)
+
+	beta := alpha2.Mul(p.x, gamma)
+
+	q.x.Square(alpha)
+	beta8 := new(fiat.P521Element).Add(beta, beta)
+	beta8.Add(beta8, beta8)
+	beta8.Add(beta8, beta8)
+	q.x.Sub(q.x, beta8)
+
+	q.z.Add(p.y, p.z)
+	q.z.Square(q.z)
+	q.z.Sub(q.z, gamma)
+	q.z.Sub(q.z, delta)
+
+	beta.Add(beta, beta)
+	beta.Add(beta, beta)
+	beta.Sub(beta, q.x)
+	q.y.Mul(alpha, beta)
+
+	gamma.Square(gamma)
+	gamma.Add(gamma, gamma)
+	gamma.Add(gamma, gamma)
+	gamma.Add(gamma, gamma)
+
+	q.y.Sub(q.y, gamma)
+
+	return q
+}
+
+func (curve p521Curve) ScalarMult(Bx, By *big.Int, k []byte) (*big.Int, *big.Int) {
+	B := curve.jacobianFromAffine(Bx, By)
+	p := &p512Point{
+		x: new(fiat.P521Element),
+		y: new(fiat.P521Element),
+		z: new(fiat.P521Element),
+	}
+
+	for _, byte := range k {
+		for bitNum := 0; bitNum < 8; bitNum++ {
+			p.doubleJacobian(p)
+			if byte&0x80 == 0x80 {
+				p.addJacobian(B, p)
+			}
+			byte <<= 1
+		}
+	}
+
+	return curve.affineFromJacobian(p)
+}
+
+func (curve p521Curve) ScalarBaseMult(k []byte) (*big.Int, *big.Int) {
+	return curve.ScalarMult(curve.Gx, curve.Gy, k)
+}
diff --git a/src/go/build/deps_test.go b/src/go/build/deps_test.go
index bb6d92f89a..3a0e769284 100644
--- a/src/go/build/deps_test.go
+++ b/src/go/build/deps_test.go
@@ -392,6 +392,7 @@ var depsRules = `
 	< crypto
 	< crypto/subtle
 	< crypto/internal/subtle
+	< crypto/elliptic/internal/fiat
 	< crypto/ed25519/internal/edwards25519/field
 	< crypto/ed25519/internal/edwards25519
 	< crypto/cipher
-- 
GitLab


From ea93e6885847b50bf4e6d3f263843f9c4e8d15f8 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Sat, 1 May 2021 01:28:16 -0400
Subject: [PATCH 2019/2400] crypto/elliptic: make P-521 scalar multiplication
 constant time
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Like for P-224, we do the constant time selects to hide the
point-at-infinity special cases of addition, but not the P = Q case,
which presumably doesn't happen in normal operations.

Runtime increases by about 50%, as expected, since on average we were
able to skip half the additions, and the additions reasonably amounted
to half the runtime. Still, the Fiat code is so much faster than big.Int
that we're still more than three time faster overall than pre-CL 315271.

name                   old time/op    new time/op    delta
pkg:crypto/elliptic goos:darwin goarch:arm64
ScalarBaseMult/P521-8    4.18ms ± 3%    1.35ms ± 1%  -67.64%  (p=0.000 n=10+10)
ScalarMult/P521-8        4.17ms ± 2%    1.36ms ± 1%  -67.45%  (p=0.000 n=10+10)
pkg:crypto/ecdsa goos:darwin goarch:arm64
Sign/P521-8              4.23ms ± 1%    1.44ms ± 1%  -66.02%  (p=0.000 n=9+10)
Verify/P521-8            8.31ms ± 2%    2.73ms ± 2%  -67.08%  (p=0.000 n=9+9)
GenerateKey/P521-8       4.15ms ± 2%    1.35ms ± 2%  -67.41%  (p=0.000 n=10+10)

Updates #40171

Change-Id: I782f2b7f33dd60af9b3b75e46d920d4cb47f719f
Reviewed-on: https://go-review.googlesource.com/c/go/+/315274
Run-TryBot: Filippo Valsorda <filippo@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Filippo Valsorda <filippo@golang.org>
Trust: Katie Hockman <katie@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
---
 src/crypto/elliptic/p521.go | 77 ++++++++++++++++++++-----------------
 1 file changed, 41 insertions(+), 36 deletions(-)

diff --git a/src/crypto/elliptic/p521.go b/src/crypto/elliptic/p521.go
index ac9de63702..ce74e0539c 100644
--- a/src/crypto/elliptic/p521.go
+++ b/src/crypto/elliptic/p521.go
@@ -125,18 +125,8 @@ func (curve p521Curve) Add(x1, y1, x2, y2 *big.Int) (*big.Int, *big.Int) {
 // addJacobian sets q = p1 + p2, and returns q. The points may overlap.
 func (q *p512Point) addJacobian(p1, p2 *p512Point) *p512Point {
 	// https://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#addition-add-2007-bl
-	if p1.z.IsZero() == 1 {
-		q.x.Set(p2.x)
-		q.y.Set(p2.y)
-		q.z.Set(p2.z)
-		return q
-	}
-	if p2.z.IsZero() == 1 {
-		q.x.Set(p1.x)
-		q.y.Set(p1.y)
-		q.z.Set(p1.z)
-		return q
-	}
+	z1IsZero := p1.z.IsZero()
+	z2IsZero := p2.z.IsZero()
 
 	z1z1 := new(fiat.P521Element).Square(p1.z)
 	z2z2 := new(fiat.P521Element).Square(p2.z)
@@ -155,31 +145,41 @@ func (q *p512Point) addJacobian(p1, p2 *p512Point) *p512Point {
 	s2.Mul(s2, z1z1)
 	r := new(fiat.P521Element).Sub(s2, s1)
 	yEqual := r.IsZero() == 1
-	if xEqual && yEqual {
+	if xEqual && yEqual && z1IsZero == 0 && z2IsZero == 0 {
 		return q.doubleJacobian(p1)
 	}
 	r.Add(r, r)
 	v := new(fiat.P521Element).Mul(u1, i)
 
-	q.x.Set(r)
-	q.x.Square(q.x)
-	q.x.Sub(q.x, j)
-	q.x.Sub(q.x, v)
-	q.x.Sub(q.x, v)
+	x := new(fiat.P521Element).Set(r)
+	x.Square(x)
+	x.Sub(x, j)
+	x.Sub(x, v)
+	x.Sub(x, v)
 
-	q.y.Set(r)
-	v.Sub(v, q.x)
-	q.y.Mul(q.y, v)
+	y := new(fiat.P521Element).Set(r)
+	v.Sub(v, x)
+	y.Mul(y, v)
 	s1.Mul(s1, j)
 	s1.Add(s1, s1)
-	q.y.Sub(q.y, s1)
-
-	q.z.Add(p1.z, p2.z)
-	q.z.Square(q.z)
-	q.z.Sub(q.z, z1z1)
-	q.z.Sub(q.z, z2z2)
-	q.z.Mul(q.z, h)
-
+	y.Sub(y, s1)
+
+	z := new(fiat.P521Element).Add(p1.z, p2.z)
+	z.Square(z)
+	z.Sub(z, z1z1)
+	z.Sub(z, z2z2)
+	z.Mul(z, h)
+
+	x.Select(p2.x, x, z1IsZero)
+	x.Select(p1.x, x, z2IsZero)
+	y.Select(p2.y, y, z1IsZero)
+	y.Select(p1.y, y, z2IsZero)
+	z.Select(p2.z, z, z1IsZero)
+	z.Select(p1.z, z, z2IsZero)
+
+	q.x.Set(x)
+	q.y.Set(y)
+	q.z.Set(z)
 	return q
 }
 
@@ -228,21 +228,26 @@ func (q *p512Point) doubleJacobian(p *p512Point) *p512Point {
 	return q
 }
 
-func (curve p521Curve) ScalarMult(Bx, By *big.Int, k []byte) (*big.Int, *big.Int) {
+func (curve p521Curve) ScalarMult(Bx, By *big.Int, scalar []byte) (*big.Int, *big.Int) {
 	B := curve.jacobianFromAffine(Bx, By)
-	p := &p512Point{
+	p, t := &p512Point{
+		x: new(fiat.P521Element),
+		y: new(fiat.P521Element),
+		z: new(fiat.P521Element),
+	}, &p512Point{
 		x: new(fiat.P521Element),
 		y: new(fiat.P521Element),
 		z: new(fiat.P521Element),
 	}
 
-	for _, byte := range k {
+	for _, byte := range scalar {
 		for bitNum := 0; bitNum < 8; bitNum++ {
 			p.doubleJacobian(p)
-			if byte&0x80 == 0x80 {
-				p.addJacobian(B, p)
-			}
-			byte <<= 1
+			bit := (byte >> (7 - bitNum)) & 1
+			t.addJacobian(p, B)
+			p.x.Select(t.x, p.x, int(bit))
+			p.y.Select(t.y, p.y, int(bit))
+			p.z.Select(t.z, p.z, int(bit))
 		}
 	}
 
-- 
GitLab


From 5203357ebacf9f41ca5e194d953c164049172e96 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 7 May 2021 22:51:29 -0700
Subject: [PATCH 2020/2400] cmd/compile: make non-concurrent compiles
 deterministic again

Spreading function compilation across multiple goroutines results in
non-deterministic output. This is how cmd/compile has historically
behaved for concurrent builds, but is troublesome for non-concurrent
builds, particularly because it interferes with "toolstash -cmp".

I spent some time trying to think of a simple, unified algorithm that
can concurrently schedule work but gracefully degrades to a
deterministic build for single-worker builds, but I couldn't come up
with any. The simplest idea I found was to simply abstract away the
operation of scheduling work so that we can have alternative
deterministic vs concurrent modes.

Change-Id: I08afa00527ce1844432412f4f8553781c4e323df
Reviewed-on: https://go-review.googlesource.com/c/go/+/318229
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/cmd/compile/internal/gc/compile.go | 59 ++++++++++++++++----------
 1 file changed, 36 insertions(+), 23 deletions(-)

diff --git a/src/cmd/compile/internal/gc/compile.go b/src/cmd/compile/internal/gc/compile.go
index a7380510d1..00504451a8 100644
--- a/src/cmd/compile/internal/gc/compile.go
+++ b/src/cmd/compile/internal/gc/compile.go
@@ -119,38 +119,51 @@ func compileFunctions() {
 		})
 	}
 
-	// We queue up a goroutine per function that needs to be
-	// compiled, but require them to grab an available worker ID
-	// before doing any substantial work to limit parallelism.
-	workerIDs := make(chan int, base.Flag.LowerC)
-	for i := 0; i < base.Flag.LowerC; i++ {
-		workerIDs <- i
+	// By default, we perform work right away on the current goroutine
+	// as the solo worker.
+	queue := func(work func(int)) {
+		work(0)
+	}
+
+	if nWorkers := base.Flag.LowerC; nWorkers > 1 {
+		// For concurrent builds, we create a goroutine per task, but
+		// require them to hold a unique worker ID while performing work
+		// to limit parallelism.
+		workerIDs := make(chan int, nWorkers)
+		for i := 0; i < nWorkers; i++ {
+			workerIDs <- i
+		}
+
+		queue = func(work func(int)) {
+			go func() {
+				worker := <-workerIDs
+				work(worker)
+				workerIDs <- worker
+			}()
+		}
 	}
 
 	var wg sync.WaitGroup
-	var asyncCompile func(*ir.Func)
-	asyncCompile = func(fn *ir.Func) {
-		wg.Add(1)
-		go func() {
-			worker := <-workerIDs
-			ssagen.Compile(fn, worker)
-			workerIDs <- worker
-
-			// Done compiling fn. Schedule it's closures for compilation.
-			for _, closure := range fn.Closures {
-				asyncCompile(closure)
-			}
-			wg.Done()
-		}()
+	var compile func([]*ir.Func)
+	compile = func(fns []*ir.Func) {
+		wg.Add(len(fns))
+		for _, fn := range fns {
+			fn := fn
+			queue(func(worker int) {
+				ssagen.Compile(fn, worker)
+				compile(fn.Closures)
+				wg.Done()
+			})
+		}
 	}
 
 	types.CalcSizeDisabled = true // not safe to calculate sizes concurrently
 	base.Ctxt.InParallel = true
-	for _, fn := range compilequeue {
-		asyncCompile(fn)
-	}
+
+	compile(compilequeue)
 	compilequeue = nil
 	wg.Wait()
+
 	base.Ctxt.InParallel = false
 	types.CalcSizeDisabled = false
 }
-- 
GitLab


From 8ec8f6aa87569a6bc567d4a7039fc22a473b37ec Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Sun, 31 Jan 2021 04:21:47 +1100
Subject: [PATCH 2021/2400] runtime: switch openbsd/arm to pthreads

This switches openbsd/arm to thread creation via pthreads, rather than doing
direct system calls.

Update #36435

Change-Id: Ia8749e3723a9967905c33b6d93dfd9be797a486c
Reviewed-on: https://go-review.googlesource.com/c/go/+/315790
Trust: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 src/runtime/asm_arm.s             |  13 ++
 src/runtime/defs_openbsd_arm.go   |   9 ++
 src/runtime/os_openbsd_libc.go    |   4 +-
 src/runtime/os_openbsd_syscall.go |   4 +-
 src/runtime/proc.go               |   2 +-
 src/runtime/sys_libc.go           |   4 +-
 src/runtime/sys_openbsd.go        |   4 +-
 src/runtime/sys_openbsd_arm.s     | 207 ++++++++++++++++++------------
 8 files changed, 153 insertions(+), 94 deletions(-)

diff --git a/src/runtime/asm_arm.s b/src/runtime/asm_arm.s
index e779fc8f84..6d3573d68f 100644
--- a/src/runtime/asm_arm.s
+++ b/src/runtime/asm_arm.s
@@ -142,6 +142,11 @@ TEXT runtime·rt0_go(SB),NOSPLIT|NOFRAME|TOPFRAME,$0
 
 	BL	runtime·emptyfunc(SB)	// fault if stack check is wrong
 
+#ifdef GOOS_openbsd
+	// Save g to TLS so that it is available from signal trampoline.
+	BL	runtime·save_g(SB)
+#endif
+
 	BL	runtime·_initcgo(SB)	// will clobber R0-R3
 
 	// update stackguard after _cgo_init
@@ -633,9 +638,13 @@ TEXT	·cgocallback(SB),NOSPLIT,$12-12
 	NO_LOCAL_POINTERS
 
 	// Load m and g from thread-local storage.
+#ifdef GOOS_openbsd
+	BL	runtime·load_g(SB)
+#else
 	MOVB	runtime·iscgo(SB), R0
 	CMP	$0, R0
 	BL.NE	runtime·load_g(SB)
+#endif
 
 	// If g is nil, Go did not create the current thread.
 	// Call needm to obtain one for temporary use.
@@ -744,6 +753,9 @@ TEXT setg<>(SB),NOSPLIT|NOFRAME,$0-0
 	// Save g to thread-local storage.
 #ifdef GOOS_windows
 	B	runtime·save_g(SB)
+#else
+#ifdef GOOS_openbsd
+	B	runtime·save_g(SB)
 #else
 	MOVB	runtime·iscgo(SB), R0
 	CMP	$0, R0
@@ -753,6 +765,7 @@ TEXT setg<>(SB),NOSPLIT|NOFRAME,$0-0
 	MOVW	g, R0
 	RET
 #endif
+#endif
 
 TEXT runtime·emptyfunc(SB),0,$0-0
 	RET
diff --git a/src/runtime/defs_openbsd_arm.go b/src/runtime/defs_openbsd_arm.go
index 170bb3876c..9b84b5a3a3 100644
--- a/src/runtime/defs_openbsd_arm.go
+++ b/src/runtime/defs_openbsd_arm.go
@@ -30,6 +30,8 @@ const (
 	_SA_RESTART = 0x2
 	_SA_ONSTACK = 0x1
 
+	_PTHREAD_CREATE_DETACHED = 0x1
+
 	_SIGHUP    = 0x1
 	_SIGINT    = 0x2
 	_SIGQUIT   = 0x3
@@ -174,3 +176,10 @@ type keventt struct {
 	udata     *byte
 	pad_cgo_1 [4]byte
 }
+
+type pthread uintptr
+type pthreadattr uintptr
+type pthreadcond uintptr
+type pthreadcondattr uintptr
+type pthreadmutex uintptr
+type pthreadmutexattr uintptr
diff --git a/src/runtime/os_openbsd_libc.go b/src/runtime/os_openbsd_libc.go
index cff5a092d7..8150753796 100644
--- a/src/runtime/os_openbsd_libc.go
+++ b/src/runtime/os_openbsd_libc.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm64)
-// +build openbsd,386 openbsd,amd64 openbsd,arm64
+//go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm) || (openbsd && arm64)
+// +build openbsd,386 openbsd,amd64 openbsd,arm openbsd,arm64
 
 package runtime
 
diff --git a/src/runtime/os_openbsd_syscall.go b/src/runtime/os_openbsd_syscall.go
index 5315487961..94e851cde8 100644
--- a/src/runtime/os_openbsd_syscall.go
+++ b/src/runtime/os_openbsd_syscall.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build openbsd && !386 && openbsd && !amd64 && openbsd && !arm64
-// +build openbsd,!386,openbsd,!amd64,openbsd,!arm64
+//go:build openbsd && !386 && openbsd && !amd64 && openbsd && !arm && openbsd && !arm64
+// +build openbsd,!386,openbsd,!amd64,openbsd,!arm,openbsd,!arm64
 
 package runtime
 
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index d9f8c65530..650ab6a1ee 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -1316,7 +1316,7 @@ func mStackIsSystemAllocated() bool {
 		return true
 	case "openbsd":
 		switch GOARCH {
-		case "386", "amd64", "arm64":
+		case "386", "amd64", "arm", "arm64":
 			return true
 		}
 	}
diff --git a/src/runtime/sys_libc.go b/src/runtime/sys_libc.go
index 91195eb3c0..346b1ab285 100644
--- a/src/runtime/sys_libc.go
+++ b/src/runtime/sys_libc.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build darwin || (openbsd && 386) || (openbsd && amd64) || (openbsd && arm64)
-// +build darwin openbsd,386 openbsd,amd64 openbsd,arm64
+//go:build darwin || (openbsd && 386) || (openbsd && amd64) || (openbsd && arm) || (openbsd && arm64)
+// +build darwin openbsd,386 openbsd,amd64 openbsd,arm openbsd,arm64
 
 package runtime
 
diff --git a/src/runtime/sys_openbsd.go b/src/runtime/sys_openbsd.go
index f6146c2e1d..89203bf85f 100644
--- a/src/runtime/sys_openbsd.go
+++ b/src/runtime/sys_openbsd.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm64)
-// +build openbsd,386 openbsd,amd64 openbsd,arm64
+//go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm) || (openbsd && arm64)
+// +build openbsd,386 openbsd,amd64 openbsd,arm openbsd,arm64
 
 package runtime
 
diff --git a/src/runtime/sys_openbsd_arm.s b/src/runtime/sys_openbsd_arm.s
index 45d69a312a..65d29415b0 100644
--- a/src/runtime/sys_openbsd_arm.s
+++ b/src/runtime/sys_openbsd_arm.s
@@ -10,7 +10,7 @@
 #include "go_tls.h"
 #include "textflag.h"
 
-#define CLOCK_REALTIME	$0
+#define	CLOCK_REALTIME	$0
 #define	CLOCK_MONOTONIC	$3
 
 // With OpenBSD 6.7 onwards, an armv7 syscall returns two instructions
@@ -25,6 +25,127 @@
 	NOOP;		\
 	NOOP
 
+// mstart_stub is the first function executed on a new thread started by pthread_create.
+// It just does some low-level setup and then calls mstart.
+// Note: called with the C calling convention.
+TEXT runtime·mstart_stub(SB),NOSPLIT,$0
+	// R0 points to the m.
+	// We are already on m's g0 stack.
+
+	// Save callee-save registers.
+	MOVM.DB.W [R4-R11], (R13)
+
+	MOVW	m_g0(R0), g
+	BL	runtime·save_g(SB)
+
+	BL	runtime·mstart(SB)
+
+	// Restore callee-save registers.
+	MOVM.IA.W (R13), [R4-R11]
+
+	// Go is all done with this OS thread.
+	// Tell pthread everything is ok (we never join with this thread, so
+	// the value here doesn't really matter).
+	MOVW	$0, R0
+	RET
+
+TEXT runtime·sigfwd(SB),NOSPLIT,$0-16
+	MOVW	sig+4(FP), R0
+	MOVW	info+8(FP), R1
+	MOVW	ctx+12(FP), R2
+	MOVW	fn+0(FP), R3
+	MOVW	R13, R9
+	SUB	$24, R13
+	BIC	$0x7, R13 // alignment for ELF ABI
+	BL	(R3)
+	MOVW	R9, R13
+	RET
+
+TEXT runtime·sigtramp(SB),NOSPLIT,$0
+	// Reserve space for callee-save registers and arguments.
+	MOVM.DB.W [R4-R11], (R13)
+	SUB	$16, R13
+
+	// If called from an external code context, g will not be set.
+	// Save R0, since runtime·load_g will clobber it.
+	MOVW	R0, 4(R13)		// signum
+	BL	runtime·load_g(SB)
+
+	MOVW	R1, 8(R13)
+	MOVW	R2, 12(R13)
+	BL	runtime·sigtrampgo(SB)
+
+	// Restore callee-save registers.
+	ADD	$16, R13
+	MOVM.IA.W (R13), [R4-R11]
+
+	RET
+
+TEXT ·publicationBarrier(SB),NOSPLIT|NOFRAME,$0-0
+	B	runtime·armPublicationBarrier(SB)
+
+// TODO(jsing): OpenBSD only supports GOARM=7 machines... this
+// should not be needed, however the linker still allows GOARM=5
+// on this platform.
+TEXT runtime·read_tls_fallback(SB),NOSPLIT|NOFRAME,$0
+	MOVM.WP	[R1, R2, R3, R12], (R13)
+	MOVW	$330, R12		// sys___get_tcb
+	INVOKE_SYSCALL
+	MOVM.IAW (R13), [R1, R2, R3, R12]
+	RET
+
+// These trampolines help convert from Go calling convention to C calling convention.
+// They should be called with asmcgocall - note that while asmcgocall does
+// stack alignment, creation of a frame undoes it again.
+// A pointer to the arguments is passed in R0.
+// A single int32 result is returned in R0.
+// (For more results, make an args/results structure.)
+TEXT runtime·pthread_attr_init_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	0(R0), R0		// arg 1 attr
+	BL	libc_pthread_attr_init(SB)
+	MOVW	R9, R13
+	RET
+
+TEXT runtime·pthread_attr_destroy_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	0(R0), R0		// arg 1 attr
+	BL	libc_pthread_attr_destroy(SB)
+	MOVW	R9, R13
+	RET
+
+TEXT runtime·pthread_attr_getstacksize_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	4(R0), R1		// arg 2 size
+	MOVW	0(R0), R0		// arg 1 attr
+	BL	libc_pthread_attr_getstacksize(SB)
+	MOVW	R9, R13
+	RET
+
+TEXT runtime·pthread_attr_setdetachstate_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	4(R0), R1		// arg 2 state
+	MOVW	0(R0), R0		// arg 1 attr
+	BL	libc_pthread_attr_setdetachstate(SB)
+	MOVW	R9, R13
+	RET
+
+TEXT runtime·pthread_create_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	SUB	$16, R13
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	0(R0), R1		// arg 2 attr
+	MOVW	4(R0), R2		// arg 3 start
+	MOVW	8(R0), R3		// arg 4 arg
+	MOVW	R13, R0			// arg 1 &threadid (discarded)
+	BL	libc_pthread_create(SB)
+	MOVW	R9, R13
+	RET
+
 // Exit the entire program (like C exit)
 TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0
 	MOVW	code+0(FP), R0	// arg 1 - status
@@ -247,80 +368,6 @@ TEXT runtime·obsdsigprocmask(SB),NOSPLIT,$0
 	MOVW	R0, ret+8(FP)
 	RET
 
-TEXT runtime·sigfwd(SB),NOSPLIT,$0-16
-	MOVW	sig+4(FP), R0
-	MOVW	info+8(FP), R1
-	MOVW	ctx+12(FP), R2
-	MOVW	fn+0(FP), R11
-	MOVW	R13, R4
-	SUB	$24, R13
-	BIC	$0x7, R13 // alignment for ELF ABI
-	BL	(R11)
-	MOVW	R4, R13
-	RET
-
-TEXT runtime·sigtramp(SB),NOSPLIT,$0
-	// Reserve space for callee-save registers and arguments.
-	MOVM.DB.W [R4-R11], (R13)
-	SUB	$16, R13
-
-	// If called from an external code context, g will not be set.
-	// Save R0, since runtime·load_g will clobber it.
-	MOVW	R0, 4(R13)		// signum
-	MOVB	runtime·iscgo(SB), R0
-	CMP	$0, R0
-	BL.NE	runtime·load_g(SB)
-
-	MOVW	R1, 8(R13)
-	MOVW	R2, 12(R13)
-	BL	runtime·sigtrampgo(SB)
-
-	// Restore callee-save registers.
-	ADD	$16, R13
-	MOVM.IA.W (R13), [R4-R11]
-
-	RET
-
-// int32 tfork(void *param, uintptr psize, M *mp, G *gp, void (*fn)(void));
-TEXT runtime·tfork(SB),NOSPLIT,$0
-
-	// Copy mp, gp and fn off parent stack for use by child.
-	MOVW	mm+8(FP), R4
-	MOVW	gg+12(FP), R5
-	MOVW	fn+16(FP), R6
-
-	MOVW	param+0(FP), R0		// arg 1 - param
-	MOVW	psize+4(FP), R1		// arg 2 - psize
-	MOVW	$8, R12			// sys___tfork
-	INVOKE_SYSCALL
-
-	// Return if syscall failed.
-	B.CC	4(PC)
-	RSB	$0, R0
-	MOVW	R0, ret+20(FP)
-	RET
-
-	// In parent, return.
-	CMP	$0, R0
-	BEQ	3(PC)
-	MOVW	R0, ret+20(FP)
-	RET
-
-	// Initialise m, g.
-	MOVW	R5, g
-	MOVW	R4, g_m(g)
-
-	// Paranoia; check that stack splitting code works.
-	BL	runtime·emptyfunc(SB)
-
-	// Call fn.
-	BL	(R6)
-
-	// fn should never return.
-	MOVW	$2, R8			// crash if reached
-	MOVW	R8, (R8)
-	RET
-
 TEXT runtime·sigaltstack(SB),NOSPLIT,$0
 	MOVW	new+0(FP), R0		// arg 1 - new sigaltstack
 	MOVW	old+4(FP), R1		// arg 2 - old sigaltstack
@@ -423,13 +470,3 @@ TEXT runtime·setNonblock(SB),NOSPLIT,$0-4
 	MOVW	$92, R12
 	INVOKE_SYSCALL
 	RET
-
-TEXT ·publicationBarrier(SB),NOSPLIT|NOFRAME,$0-0
-	B	runtime·armPublicationBarrier(SB)
-
-TEXT runtime·read_tls_fallback(SB),NOSPLIT|NOFRAME,$0
-	MOVM.WP	[R1, R2, R3, R12], (R13)
-	MOVW	$330, R12		// sys___get_tcb
-	INVOKE_SYSCALL
-	MOVM.IAW (R13), [R1, R2, R3, R12]
-	RET
-- 
GitLab


From 83df4a590bbd259b82db37e0c6e721ddc267614b Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Mon, 1 Feb 2021 03:51:02 +1100
Subject: [PATCH 2022/2400] runtime: switch openbsd/arm locking to libc

Switch openbsd/arm to locking via libc, rather than performing direct
system calls.

Update #36435

Change-Id: I190abb1aa544d2cb406fe412960ec106c9716f87
Reviewed-on: https://go-review.googlesource.com/c/go/+/315791
Trust: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 src/runtime/os_openbsd_syscall1.go |  4 +-
 src/runtime/sys_openbsd1.go        |  4 +-
 src/runtime/sys_openbsd_arm.s      | 67 ++++++++++++++++--------------
 3 files changed, 39 insertions(+), 36 deletions(-)

diff --git a/src/runtime/os_openbsd_syscall1.go b/src/runtime/os_openbsd_syscall1.go
index ecae67aa2f..f8f666890a 100644
--- a/src/runtime/os_openbsd_syscall1.go
+++ b/src/runtime/os_openbsd_syscall1.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build openbsd && !386 && !amd64 && !arm64
-// +build openbsd,!386,!amd64,!arm64
+//go:build openbsd && !386 && !amd64 && !arm && !arm64
+// +build openbsd,!386,!amd64,!arm,!arm64
 
 package runtime
 
diff --git a/src/runtime/sys_openbsd1.go b/src/runtime/sys_openbsd1.go
index b007b6d3f5..1af48539fa 100644
--- a/src/runtime/sys_openbsd1.go
+++ b/src/runtime/sys_openbsd1.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm64)
-// +build openbsd,386 openbsd,amd64 openbsd,arm64
+//go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm) || (openbsd && arm64)
+// +build openbsd,386 openbsd,amd64 openbsd,arm openbsd,arm64
 
 package runtime
 
diff --git a/src/runtime/sys_openbsd_arm.s b/src/runtime/sys_openbsd_arm.s
index 65d29415b0..1402402de3 100644
--- a/src/runtime/sys_openbsd_arm.s
+++ b/src/runtime/sys_openbsd_arm.s
@@ -104,7 +104,7 @@ TEXT runtime·pthread_attr_init_trampoline(SB),NOSPLIT,$0
 	MOVW	R13, R9
 	BIC     $0x7, R13		// align for ELF ABI
 	MOVW	0(R0), R0		// arg 1 attr
-	BL	libc_pthread_attr_init(SB)
+	CALL	libc_pthread_attr_init(SB)
 	MOVW	R9, R13
 	RET
 
@@ -112,7 +112,7 @@ TEXT runtime·pthread_attr_destroy_trampoline(SB),NOSPLIT,$0
 	MOVW	R13, R9
 	BIC     $0x7, R13		// align for ELF ABI
 	MOVW	0(R0), R0		// arg 1 attr
-	BL	libc_pthread_attr_destroy(SB)
+	CALL	libc_pthread_attr_destroy(SB)
 	MOVW	R9, R13
 	RET
 
@@ -121,7 +121,7 @@ TEXT runtime·pthread_attr_getstacksize_trampoline(SB),NOSPLIT,$0
 	BIC     $0x7, R13		// align for ELF ABI
 	MOVW	4(R0), R1		// arg 2 size
 	MOVW	0(R0), R0		// arg 1 attr
-	BL	libc_pthread_attr_getstacksize(SB)
+	CALL	libc_pthread_attr_getstacksize(SB)
 	MOVW	R9, R13
 	RET
 
@@ -130,7 +130,7 @@ TEXT runtime·pthread_attr_setdetachstate_trampoline(SB),NOSPLIT,$0
 	BIC     $0x7, R13		// align for ELF ABI
 	MOVW	4(R0), R1		// arg 2 state
 	MOVW	0(R0), R0		// arg 1 attr
-	BL	libc_pthread_attr_setdetachstate(SB)
+	CALL	libc_pthread_attr_setdetachstate(SB)
 	MOVW	R9, R13
 	RET
 
@@ -142,7 +142,37 @@ TEXT runtime·pthread_create_trampoline(SB),NOSPLIT,$0
 	MOVW	4(R0), R2		// arg 3 start
 	MOVW	8(R0), R3		// arg 4 arg
 	MOVW	R13, R0			// arg 1 &threadid (discarded)
-	BL	libc_pthread_create(SB)
+	CALL	libc_pthread_create(SB)
+	MOVW	R9, R13
+	RET
+
+TEXT runtime·thrsleep_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	SUB	$16, R13
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	4(R0), R1		// arg 2 - clock_id
+	MOVW	8(R0), R2		// arg 3 - abstime
+	MOVW	12(R0), R3		// arg 4 - lock
+	MOVW	16(R0), R4		// arg 5 - abort (on stack)
+	MOVW	R4, 0(R13)
+	MOVW	0(R0), R0		// arg 1 - id
+	CALL	libc_thrsleep(SB)
+	MOVW	R9, R13
+	RET
+
+TEXT runtime·thrwakeup_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	4(R0), R1		// arg 2 - count
+	MOVW	0(R0), R0		// arg 1 - id
+	CALL	libc_thrwakeup(SB)
+	MOVW	R9, R13
+	RET
+
+TEXT runtime·sched_yield_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	BIC     $0x7, R13		// align for ELF ABI
+	CALL	libc_sched_yield(SB)
 	MOVW	R9, R13
 	RET
 
@@ -377,33 +407,6 @@ TEXT runtime·sigaltstack(SB),NOSPLIT,$0
 	MOVW.CS	R8, (R8)
 	RET
 
-TEXT runtime·osyield(SB),NOSPLIT,$0
-	MOVW	$298, R12		// sys_sched_yield
-	INVOKE_SYSCALL
-	RET
-
-TEXT runtime·thrsleep(SB),NOSPLIT,$4
-	MOVW	ident+0(FP), R0		// arg 1 - ident
-	MOVW	clock_id+4(FP), R1	// arg 2 - clock_id
-	MOVW	tsp+8(FP), R2		// arg 3 - tsp
-	MOVW	lock+12(FP), R3		// arg 4 - lock
-	MOVW	abort+16(FP), R4	// arg 5 - abort (on stack)
-	MOVW	R4, 4(R13)
-	ADD	$4, R13
-	MOVW	$94, R12		// sys___thrsleep
-	INVOKE_SYSCALL
-	SUB	$4, R13
-	MOVW	R0, ret+20(FP)
-	RET
-
-TEXT runtime·thrwakeup(SB),NOSPLIT,$0
-	MOVW	ident+0(FP), R0		// arg 1 - ident
-	MOVW	n+4(FP), R1		// arg 2 - n
-	MOVW	$301, R12		// sys___thrwakeup
-	INVOKE_SYSCALL
-	MOVW	R0, ret+8(FP)
-	RET
-
 TEXT runtime·sysctl(SB),NOSPLIT,$8
 	MOVW	mib+0(FP), R0		// arg 1 - mib
 	MOVW	miblen+4(FP), R1	// arg 2 - miblen
-- 
GitLab


From 603f43cbae1f29c9c167b2b331dc31c8486c888b Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Wed, 3 Feb 2021 18:17:35 +1100
Subject: [PATCH 2023/2400] runtime: switch runtime to libc for openbsd/arm

Use libc rather than performing direct system calls for the runtime on
openbsd/arm.

Updates #36435

Change-Id: If64a96a61c80b9748792f8a85a8f16ed6ebca91f
Reviewed-on: https://go-review.googlesource.com/c/go/+/315792
Trust: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 src/runtime/defs_openbsd_arm.go    |   5 +
 src/runtime/os_openbsd_syscall2.go |   4 +-
 src/runtime/proc.go                |   2 +-
 src/runtime/sys_openbsd2.go        |   4 +-
 src/runtime/sys_openbsd_arm.s      | 508 ++++++++++++++---------------
 5 files changed, 260 insertions(+), 263 deletions(-)

diff --git a/src/runtime/defs_openbsd_arm.go b/src/runtime/defs_openbsd_arm.go
index 9b84b5a3a3..6f128c4284 100644
--- a/src/runtime/defs_openbsd_arm.go
+++ b/src/runtime/defs_openbsd_arm.go
@@ -32,6 +32,11 @@ const (
 
 	_PTHREAD_CREATE_DETACHED = 0x1
 
+	_F_SETFD    = 0x2
+	_F_GETFL    = 0x3
+	_F_SETFL    = 0x4
+	_FD_CLOEXEC = 0x1
+
 	_SIGHUP    = 0x1
 	_SIGINT    = 0x2
 	_SIGQUIT   = 0x3
diff --git a/src/runtime/os_openbsd_syscall2.go b/src/runtime/os_openbsd_syscall2.go
index 6aa57a99da..84543acec4 100644
--- a/src/runtime/os_openbsd_syscall2.go
+++ b/src/runtime/os_openbsd_syscall2.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build openbsd && !386 && !amd64 && !arm64
-// +build openbsd,!386,!amd64,!arm64
+//go:build openbsd && !386 && !amd64 && !arm && !arm64
+// +build openbsd,!386,!amd64,!arm,!arm64
 
 package runtime
 
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 650ab6a1ee..ba02b14995 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -1303,7 +1303,7 @@ func usesLibcall() bool {
 	case "aix", "darwin", "illumos", "ios", "solaris", "windows":
 		return true
 	case "openbsd":
-		return GOARCH == "386" || GOARCH == "amd64" || GOARCH == "arm64"
+		return GOARCH == "386" || GOARCH == "amd64" || GOARCH == "arm" || GOARCH == "arm64"
 	}
 	return false
 }
diff --git a/src/runtime/sys_openbsd2.go b/src/runtime/sys_openbsd2.go
index 91ed04fb48..2d53f67a61 100644
--- a/src/runtime/sys_openbsd2.go
+++ b/src/runtime/sys_openbsd2.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm64)
-// +build openbsd,386 openbsd,amd64 openbsd,arm64
+//go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm) || (openbsd && arm64)
+// +build openbsd,386 openbsd,amd64 openbsd,arm openbsd,arm64
 
 package runtime
 
diff --git a/src/runtime/sys_openbsd_arm.s b/src/runtime/sys_openbsd_arm.s
index 1402402de3..49cb19bbff 100644
--- a/src/runtime/sys_openbsd_arm.s
+++ b/src/runtime/sys_openbsd_arm.s
@@ -146,6 +146,16 @@ TEXT runtime·pthread_create_trampoline(SB),NOSPLIT,$0
 	MOVW	R9, R13
 	RET
 
+TEXT runtime·thrkill_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	4(R0), R1		// arg 2 - signal
+	MOVW	$0, R2			// arg 3 - tcb
+	MOVW	0(R0), R0		// arg 1 - tid
+	CALL	libc_thrkill(SB)
+	MOVW	R9, R13
+	RET
+
 TEXT runtime·thrsleep_trampoline(SB),NOSPLIT,$0
 	MOVW	R13, R9
 	SUB	$16, R13
@@ -169,307 +179,289 @@ TEXT runtime·thrwakeup_trampoline(SB),NOSPLIT,$0
 	MOVW	R9, R13
 	RET
 
-TEXT runtime·sched_yield_trampoline(SB),NOSPLIT,$0
+TEXT runtime·exit_trampoline(SB),NOSPLIT,$0
 	MOVW	R13, R9
 	BIC     $0x7, R13		// align for ELF ABI
-	CALL	libc_sched_yield(SB)
+	MOVW	0(R0), R0		// arg 1 exit status
+	BL	libc_exit(SB)
+	MOVW	$0, R8			// crash on failure
+	MOVW	R8, (R8)
 	MOVW	R9, R13
 	RET
 
-// Exit the entire program (like C exit)
-TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0
-	MOVW	code+0(FP), R0	// arg 1 - status
-	MOVW	$1, R12			// sys_exit
-	INVOKE_SYSCALL
-	MOVW.CS	$0, R8			// crash on syscall failure
-	MOVW.CS	R8, (R8)
-	RET
-
-// func exitThread(wait *uint32)
-TEXT runtime·exitThread(SB),NOSPLIT,$0-4
-	MOVW	wait+0(FP), R0		// arg 1 - notdead
-	MOVW	$302, R12		// sys___threxit
-	INVOKE_SYSCALL
-	MOVW.CS	$1, R8			// crash on syscall failure
-	MOVW.CS	R8, (R8)
-	JMP	0(PC)
-
-TEXT runtime·open(SB),NOSPLIT|NOFRAME,$0
-	MOVW	name+0(FP), R0		// arg 1 - path
-	MOVW	mode+4(FP), R1		// arg 2 - mode
-	MOVW	perm+8(FP), R2		// arg 3 - perm
-	MOVW	$5, R12			// sys_open
-	INVOKE_SYSCALL
-	MOVW.CS	$-1, R0
-	MOVW	R0, ret+12(FP)
-	RET
-
-TEXT runtime·closefd(SB),NOSPLIT|NOFRAME,$0
-	MOVW	fd+0(FP), R0		// arg 1 - fd
-	MOVW	$6, R12			// sys_close
-	INVOKE_SYSCALL
-	MOVW.CS	$-1, R0
-	MOVW	R0, ret+4(FP)
+TEXT runtime·getthrid_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	MOVW	R0, R8
+	BIC     $0x7, R13		// align for ELF ABI
+	BL	libc_getthrid(SB)
+	MOVW	R0, 0(R8)
+	MOVW	R9, R13
 	RET
 
-TEXT runtime·read(SB),NOSPLIT|NOFRAME,$0
-	MOVW	fd+0(FP), R0		// arg 1 - fd
-	MOVW	p+4(FP), R1		// arg 2 - buf
-	MOVW	n+8(FP), R2		// arg 3 - nbyte
-	MOVW	$3, R12			// sys_read
-	INVOKE_SYSCALL
-	RSB.CS	$0, R0		// caller expects negative errno
-	MOVW	R0, ret+12(FP)
+TEXT runtime·raiseproc_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	R0, R4
+	BL	libc_getpid(SB)		// arg 1 pid
+	MOVW	R4, R1			// arg 2 signal
+	BL	libc_kill(SB)
+	MOVW	R9, R13
 	RET
 
-// func pipe() (r, w int32, errno int32)
-TEXT runtime·pipe(SB),NOSPLIT,$0-12
-	MOVW	$r+0(FP), R0
-	MOVW	$263, R12
-	INVOKE_SYSCALL
-	MOVW	R0, errno+8(FP)
+TEXT runtime·sched_yield_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	BIC     $0x7, R13		// align for ELF ABI
+	BL	libc_sched_yield(SB)
+	MOVW	R9, R13
 	RET
 
-// func pipe2(flags int32) (r, w int32, errno int32)
-TEXT runtime·pipe2(SB),NOSPLIT,$0-16
-	MOVW	$r+4(FP), R0
-	MOVW	flags+0(FP), R1
-	MOVW	$101, R12
-	INVOKE_SYSCALL
-	MOVW	R0, errno+12(FP)
+TEXT runtime·mmap_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	SUB	$16, R13
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	R0, R8
+	MOVW	4(R0), R1		// arg 2 len
+	MOVW	8(R0), R2		// arg 3 prot
+	MOVW	12(R0), R3		// arg 4 flags
+	MOVW	16(R0), R4		// arg 5 fid (on stack)
+	MOVW	R4, 0(R13)
+	MOVW	$0, R5			// pad (on stack)
+	MOVW	R5, 4(R13)
+	MOVW	20(R0), R6		// arg 6 offset (on stack)
+	MOVW	R6, 8(R13)		// low 32 bits
+	MOVW    $0, R7
+	MOVW	R7, 12(R13)		// high 32 bits
+	MOVW	0(R0), R0		// arg 1 addr
+	BL	libc_mmap(SB)
+	MOVW	$0, R1
+	CMP	$-1, R0
+	BNE	ok
+	BL	libc_errno(SB)
+	MOVW	(R0), R1		// errno
+	MOVW	$0, R0
+ok:
+	MOVW	R0, 24(R8)
+	MOVW	R1, 28(R8)
+	MOVW	R9, R13
 	RET
 
-TEXT runtime·write1(SB),NOSPLIT|NOFRAME,$0
-	MOVW	fd+0(FP), R0		// arg 1 - fd
-	MOVW	p+4(FP), R1		// arg 2 - buf
-	MOVW	n+8(FP), R2		// arg 3 - nbyte
-	MOVW	$4, R12			// sys_write
-	INVOKE_SYSCALL
-	RSB.CS	$0, R0		// caller expects negative errno
-	MOVW	R0, ret+12(FP)
+TEXT runtime·munmap_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	4(R0), R1		// arg 2 len
+	MOVW	0(R0), R0		// arg 1 addr
+	BL	libc_munmap(SB)
+	CMP	$-1, R0
+	BNE	3(PC)
+	MOVW	$0, R8			// crash on failure
+	MOVW	R8, (R8)
+	MOVW	R9, R13
 	RET
 
-TEXT runtime·usleep(SB),NOSPLIT,$16
-	MOVW	usec+0(FP), R0
-	CALL	runtime·usplitR0(SB)
-	MOVW	R0, 4(R13)		// tv_sec - l32
-	MOVW	$0, R0
-	MOVW	R0, 8(R13)		// tv_sec - h32
-	MOVW	$1000, R2
-	MUL	R1, R2
-	MOVW	R2, 12(R13)		// tv_nsec
-
-	MOVW	$4(R13), R0		// arg 1 - rqtp
-	MOVW	$0, R1			// arg 2 - rmtp
-	MOVW	$91, R12		// sys_nanosleep
-	INVOKE_SYSCALL
+TEXT runtime·madvise_trampoline(SB), NOSPLIT, $0
+	MOVW	R13, R9
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	4(R0), R1		// arg 2 len
+	MOVW	8(R0), R2		// arg 3 advice
+	MOVW	0(R0), R0		// arg 1 addr
+	BL	libc_madvise(SB)
+	// ignore failure - maybe pages are locked
+	MOVW	R9, R13
 	RET
 
-TEXT runtime·getthrid(SB),NOSPLIT,$0-4
-	MOVW	$299, R12		// sys_getthrid
-	INVOKE_SYSCALL
-	MOVW	R0, ret+0(FP)
+TEXT runtime·open_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	SUB	$8, R13
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	4(R0), R1		// arg 2 - flags
+	MOVW	8(R0), R2		// arg 3 - mode (vararg, on stack)
+	MOVW	R2, 0(R13)
+	MOVW	0(R0), R0		// arg 1 - path
+	MOVW	R13, R4
+	BIC     $0x7, R13		// align for ELF ABI
+	BL	libc_open(SB)
+	MOVW	R9, R13
 	RET
 
-TEXT runtime·thrkill(SB),NOSPLIT,$0-8
-	MOVW	tid+0(FP), R0		// arg 1 - tid
-	MOVW	sig+4(FP), R1		// arg 2 - signum
-	MOVW	$0, R2			// arg 3 - tcb
-	MOVW	$119, R12		// sys_thrkill
-	INVOKE_SYSCALL
+TEXT runtime·close_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	0(R0), R0		// arg 1 - fd
+	BL	libc_close(SB)
+	MOVW	R9, R13
 	RET
 
-TEXT runtime·raiseproc(SB),NOSPLIT,$12
-	MOVW	$20, R12		// sys_getpid
-	INVOKE_SYSCALL
-					// arg 1 - pid, already in R0
-	MOVW	sig+0(FP), R1		// arg 2 - signum
-	MOVW	$122, R12		// sys_kill
-	INVOKE_SYSCALL
+TEXT runtime·read_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	4(R0), R1		// arg 2 - buf
+	MOVW	8(R0), R2		// arg 3 - count
+	MOVW	0(R0), R0		// arg 1 - fd
+	BL	libc_read(SB)
+	CMP	$-1, R0
+	BNE	noerr
+	BL	libc_errno(SB)
+	MOVW	(R0), R0		// errno
+	RSB.CS	$0, R0			// caller expects negative errno
+noerr:
+	MOVW	R9, R13
 	RET
 
-TEXT runtime·mmap(SB),NOSPLIT,$16
-	MOVW	addr+0(FP), R0		// arg 1 - addr
-	MOVW	n+4(FP), R1		// arg 2 - len
-	MOVW	prot+8(FP), R2		// arg 3 - prot
-	MOVW	flags+12(FP), R3	// arg 4 - flags
-	MOVW	fd+16(FP), R4		// arg 5 - fd (on stack)
-	MOVW	R4, 4(R13)
-	MOVW	$0, R5			// arg 6 - pad (on stack)
-	MOVW	R5, 8(R13)
-	MOVW	off+20(FP), R6		// arg 7 - offset (on stack)
-	MOVW	R6, 12(R13)		// lower 32 bits (from Go runtime)
-	MOVW	$0, R7
-	MOVW	R7, 16(R13)		// high 32 bits
-	ADD	$4, R13
-	MOVW	$197, R12		// sys_mmap
-	INVOKE_SYSCALL
-	SUB	$4, R13
-	MOVW	$0, R1
-	MOVW.CS	R0, R1			// if error, move to R1
-	MOVW.CS $0, R0
-	MOVW	R0, p+24(FP)
-	MOVW	R1, err+28(FP)
+TEXT runtime·write_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	4(R0), R1		// arg 2 buf
+	MOVW	8(R0), R2		// arg 3 count
+	MOVW	0(R0), R0		// arg 1 fd
+	BL	libc_write(SB)
+	CMP	$-1, R0
+	BNE	noerr
+	BL	libc_errno(SB)
+	MOVW	(R0), R0		// errno
+	RSB.CS	$0, R0			// caller expects negative errno
+noerr:
+	MOVW	R9, R13
 	RET
 
-TEXT runtime·munmap(SB),NOSPLIT,$0
-	MOVW	addr+0(FP), R0		// arg 1 - addr
-	MOVW	n+4(FP), R1		// arg 2 - len
-	MOVW	$73, R12		// sys_munmap
-	INVOKE_SYSCALL
-	MOVW.CS	$0, R8			// crash on syscall failure
-	MOVW.CS	R8, (R8)
+TEXT runtime·pipe2_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	4(R0), R1		// arg 2 flags
+	MOVW	0(R0), R0		// arg 1 filedes
+	BL	libc_pipe2(SB)
+	CMP	$-1, R0
+	BNE	3(PC)
+	BL	libc_errno(SB)
+	MOVW	(R0), R0		// errno
+	RSB.CS	$0, R0			// caller expects negative errno
+	MOVW	R9, R13
 	RET
 
-TEXT runtime·madvise(SB),NOSPLIT,$0
-	MOVW	addr+0(FP), R0		// arg 1 - addr
-	MOVW	n+4(FP), R1		// arg 2 - len
-	MOVW	flags+8(FP), R2		// arg 2 - flags
-	MOVW	$75, R12		// sys_madvise
-	INVOKE_SYSCALL
-	MOVW.CS	$-1, R0
-	MOVW	R0, ret+12(FP)
+TEXT runtime·setitimer_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	4(R0), R1		// arg 2 new
+	MOVW	8(R0), R2		// arg 3 old
+	MOVW	0(R0), R0		// arg 1 which
+	BL	libc_setitimer(SB)
+	MOVW	R9, R13
 	RET
 
-TEXT runtime·setitimer(SB),NOSPLIT,$0
-	MOVW	mode+0(FP), R0		// arg 1 - mode
-	MOVW	new+4(FP), R1		// arg 2 - new value
-	MOVW	old+8(FP), R2		// arg 3 - old value
-	MOVW	$69, R12		// sys_setitimer
-	INVOKE_SYSCALL
+TEXT runtime·usleep_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	0(R0), R0		// arg 1 usec
+	BL	libc_usleep(SB)
+	MOVW	R9, R13
 	RET
 
-// func walltime() (sec int64, nsec int32)
-TEXT runtime·walltime(SB), NOSPLIT, $32
-	MOVW	CLOCK_REALTIME, R0	// arg 1 - clock_id
-	MOVW	$8(R13), R1		// arg 2 - tp
-	MOVW	$87, R12		// sys_clock_gettime
-	INVOKE_SYSCALL
-
-	MOVW	8(R13), R0		// sec - l32
-	MOVW	12(R13), R1		// sec - h32
-	MOVW	16(R13), R2		// nsec
-
-	MOVW	R0, sec_lo+0(FP)
-	MOVW	R1, sec_hi+4(FP)
-	MOVW	R2, nsec+8(FP)
-
+TEXT runtime·sysctl_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	SUB	$8, R13
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	4(R0), R1		// arg 2 miblen
+	MOVW	8(R0), R2		// arg 3 out
+	MOVW	12(R0), R3		// arg 4 size
+	MOVW	16(R0), R4		// arg 5 dst (on stack)
+	MOVW	R4, 0(R13)
+	MOVW	20(R0), R5		// arg 6 ndst (on stack)
+	MOVW	R5, 4(R13)
+	MOVW	0(R0), R0		// arg 1 mib
+	BL	libc_sysctl(SB)
+	MOVW	R9, R13
 	RET
 
-// int64 nanotime1(void) so really
-// void nanotime1(int64 *nsec)
-TEXT runtime·nanotime1(SB),NOSPLIT,$32
-	MOVW	CLOCK_MONOTONIC, R0	// arg 1 - clock_id
-	MOVW	$8(R13), R1		// arg 2 - tp
-	MOVW	$87, R12		// sys_clock_gettime
-	INVOKE_SYSCALL
-
-	MOVW	8(R13), R0		// sec - l32
-	MOVW	12(R13), R4		// sec - h32
-	MOVW	16(R13), R2		// nsec
-
-	MOVW	$1000000000, R3
-	MULLU	R0, R3, (R1, R0)
-	MUL	R3, R4
-	ADD.S	R2, R0
-	ADC	R4, R1
-
-	MOVW	R0, ret_lo+0(FP)
-	MOVW	R1, ret_hi+4(FP)
+TEXT runtime·kqueue_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	BIC     $0x7, R13		// align for ELF ABI
+	BL	libc_kqueue(SB)
+	MOVW	R9, R13
 	RET
 
-TEXT runtime·sigaction(SB),NOSPLIT,$0
-	MOVW	sig+0(FP), R0		// arg 1 - signum
-	MOVW	new+4(FP), R1		// arg 2 - new sigaction
-	MOVW	old+8(FP), R2		// arg 3 - old sigaction
-	MOVW	$46, R12		// sys_sigaction
-	INVOKE_SYSCALL
-	MOVW.CS	$3, R8			// crash on syscall failure
-	MOVW.CS	R8, (R8)
+TEXT runtime·kevent_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	SUB	$8, R13
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	4(R0), R1		// arg 2 keventt
+	MOVW	8(R0), R2		// arg 3 nch
+	MOVW	12(R0), R3		// arg 4 ev
+	MOVW	16(R0), R4		// arg 5 nev (on stack)
+	MOVW	R4, 0(R13)
+	MOVW	20(R0), R5		// arg 6 ts (on stack)
+	MOVW	R5, 4(R13)
+	MOVW	0(R0), R0		// arg 1 kq
+	BL	libc_kevent(SB)
+	CMP	$-1, R0
+	BNE	ok
+	BL	libc_errno(SB)
+	MOVW	(R0), R0		// errno
+	RSB.CS	$0, R0			// caller expects negative errno
+ok:
+	MOVW	R9, R13
 	RET
 
-TEXT runtime·obsdsigprocmask(SB),NOSPLIT,$0
-	MOVW	how+0(FP), R0		// arg 1 - mode
-	MOVW	new+4(FP), R1		// arg 2 - new
-	MOVW	$48, R12		// sys_sigprocmask
-	INVOKE_SYSCALL
-	MOVW.CS	$3, R8			// crash on syscall failure
-	MOVW.CS	R8, (R8)
-	MOVW	R0, ret+8(FP)
+TEXT runtime·clock_gettime_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	4(R0), R1		// arg 2 tp
+	MOVW	0(R0), R0		// arg 1 clock_id
+	BL	libc_clock_gettime(SB)
+	CMP	$-1, R0
+	BNE	3(PC)
+	MOVW	$0, R8			// crash on failure
+	MOVW	R8, (R8)
+	MOVW	R9, R13
 	RET
 
-TEXT runtime·sigaltstack(SB),NOSPLIT,$0
-	MOVW	new+0(FP), R0		// arg 1 - new sigaltstack
-	MOVW	old+4(FP), R1		// arg 2 - old sigaltstack
-	MOVW	$288, R12		// sys_sigaltstack
-	INVOKE_SYSCALL
-	MOVW.CS	$0, R8			// crash on syscall failure
-	MOVW.CS	R8, (R8)
-	RET
-
-TEXT runtime·sysctl(SB),NOSPLIT,$8
-	MOVW	mib+0(FP), R0		// arg 1 - mib
-	MOVW	miblen+4(FP), R1	// arg 2 - miblen
-	MOVW	out+8(FP), R2		// arg 3 - out
-	MOVW	size+12(FP), R3		// arg 4 - size
-	MOVW	dst+16(FP), R4		// arg 5 - dest (on stack)
-	MOVW	R4, 4(R13)
-	MOVW	ndst+20(FP), R5		// arg 6 - newlen (on stack)
-	MOVW	R5, 8(R13)
-	ADD	$4, R13
-	MOVW	$202, R12		// sys___sysctl
-	INVOKE_SYSCALL
-	SUB	$4, R13
-	MOVW.CC	$0, R0
-	RSB.CS	$0, R0
-	MOVW	R0, ret+24(FP)
+TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	SUB	$8, R13
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	4(R0), R1		// arg 2 cmd
+	MOVW	8(R0), R2		// arg 3 arg (vararg, on stack)
+	MOVW	R2, 0(R13)
+	MOVW	0(R0), R0		// arg 1 fd
+	BL	libc_fcntl(SB)
+	MOVW	R9, R13
 	RET
 
-// int32 runtime·kqueue(void);
-TEXT runtime·kqueue(SB),NOSPLIT,$0
-	MOVW	$269, R12		// sys_kqueue
-	INVOKE_SYSCALL
-	RSB.CS	$0, R0
-	MOVW	R0, ret+0(FP)
-	RET
-
-// int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
-TEXT runtime·kevent(SB),NOSPLIT,$8
-	MOVW	kq+0(FP), R0		// arg 1 - kq
-	MOVW	ch+4(FP), R1		// arg 2 - changelist
-	MOVW	nch+8(FP), R2		// arg 3 - nchanges
-	MOVW	ev+12(FP), R3		// arg 4 - eventlist
-	MOVW	nev+16(FP), R4		// arg 5 - nevents (on stack)
-	MOVW	R4, 4(R13)
-	MOVW	ts+20(FP), R5		// arg 6 - timeout (on stack)
-	MOVW	R5, 8(R13)
-	ADD	$4, R13
-	MOVW	$72, R12		// sys_kevent
-	INVOKE_SYSCALL
-	RSB.CS	$0, R0
-	SUB	$4, R13
-	MOVW	R0, ret+24(FP)
+TEXT runtime·sigaction_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	4(R0), R1		// arg 2 new
+	MOVW	8(R0), R2		// arg 3 old
+	MOVW	0(R0), R0		// arg 1 sig
+	BL	libc_sigaction(SB)
+	CMP	$-1, R0
+	BNE	3(PC)
+	MOVW	$0, R8			// crash on failure
+	MOVW	R8, (R8)
+	MOVW	R9, R13
 	RET
 
-// func closeonexec(fd int32)
-TEXT runtime·closeonexec(SB),NOSPLIT,$0
-	MOVW	fd+0(FP), R0		// arg 1 - fd
-	MOVW	$2, R1			// arg 2 - cmd (F_SETFD)
-	MOVW	$1, R2			// arg 3 - arg (FD_CLOEXEC)
-	MOVW	$92, R12		// sys_fcntl
-	INVOKE_SYSCALL
+TEXT runtime·sigprocmask_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	4(R0), R1		// arg 2 new
+	MOVW	8(R0), R2		// arg 3 old
+	MOVW	0(R0), R0		// arg 1 how
+	BL	libc_pthread_sigmask(SB)
+	CMP	$-1, R0
+	BNE	3(PC)
+	MOVW	$0, R8			// crash on failure
+	MOVW	R8, (R8)
+	MOVW	R9, R13
 	RET
 
-// func runtime·setNonblock(fd int32)
-TEXT runtime·setNonblock(SB),NOSPLIT,$0-4
-	MOVW	fd+0(FP), R0	// fd
-	MOVW	$3, R1	// F_GETFL
-	MOVW	$0, R2
-	MOVW	$92, R12
-	INVOKE_SYSCALL
-	ORR	$0x4, R0, R2	// O_NONBLOCK
-	MOVW	fd+0(FP), R0	// fd
-	MOVW	$4, R1	// F_SETFL
-	MOVW	$92, R12
-	INVOKE_SYSCALL
+TEXT runtime·sigaltstack_trampoline(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	BIC     $0x7, R13		// align for ELF ABI
+	MOVW	4(R0), R1		// arg 2 old
+	MOVW	0(R0), R0		// arg 1 new
+	BL	libc_sigaltstack(SB)
+	CMP	$-1, R0
+	BNE	3(PC)
+	MOVW	$0, R8			// crash on failure
+	MOVW	R8, (R8)
+	MOVW	R9, R13
 	RET
-- 
GitLab


From bedf2c488630bd8253598b78088bc27fc36fbd29 Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Fri, 5 Feb 2021 04:22:18 +1100
Subject: [PATCH 2024/2400] runtime,syscall: convert syscall on openbsd/arm to
 libc

Convert the syscall package on openbsd/arm to use libc rather than performing
direct system calls.

Updates #36435

Change-Id: Iff3a91c959292cbf4e0a09c7fd34efc8e88ff83f
Reviewed-on: https://go-review.googlesource.com/c/go/+/315793
Trust: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 src/runtime/sys_openbsd3.go         |   4 +-
 src/runtime/sys_openbsd_arm.s       | 339 +++++++++++
 src/syscall/asm_openbsd_arm.s       | 135 +----
 src/syscall/exec_bsd.go             |   4 +-
 src/syscall/exec_libc2.go           |   4 +-
 src/syscall/exec_unix.go            |   2 +-
 src/syscall/mkall.sh                |   5 +-
 src/syscall/mksyscall.pl            |   4 +
 src/syscall/syscall_openbsd1.go     |   4 +-
 src/syscall/syscall_openbsd_libc.go |   4 +-
 src/syscall/zsyscall_openbsd_arm.go | 867 +++++++++++++++++++++++-----
 src/syscall/zsyscall_openbsd_arm.s  | 233 ++++++++
 12 files changed, 1336 insertions(+), 269 deletions(-)
 create mode 100644 src/syscall/zsyscall_openbsd_arm.s

diff --git a/src/runtime/sys_openbsd3.go b/src/runtime/sys_openbsd3.go
index 8fdee05733..4ef0bdcf77 100644
--- a/src/runtime/sys_openbsd3.go
+++ b/src/runtime/sys_openbsd3.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm64)
-// +build openbsd,386 openbsd,amd64 openbsd,arm64
+//go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm) || (openbsd && arm64)
+// +build openbsd,386 openbsd,amd64 openbsd,arm openbsd,arm64
 
 package runtime
 
diff --git a/src/runtime/sys_openbsd_arm.s b/src/runtime/sys_openbsd_arm.s
index 49cb19bbff..143fcf0518 100644
--- a/src/runtime/sys_openbsd_arm.s
+++ b/src/runtime/sys_openbsd_arm.s
@@ -465,3 +465,342 @@ TEXT runtime·sigaltstack_trampoline(SB),NOSPLIT,$0
 	MOVW	R8, (R8)
 	MOVW	R9, R13
 	RET
+
+// syscall calls a function in libc on behalf of the syscall package.
+// syscall takes a pointer to a struct like:
+// struct {
+//	fn    uintptr
+//	a1    uintptr
+//	a2    uintptr
+//	a3    uintptr
+//	r1    uintptr
+//	r2    uintptr
+//	err   uintptr
+// }
+// syscall must be called on the g0 stack with the
+// C calling convention (use libcCall).
+//
+// syscall expects a 32-bit result and tests for 32-bit -1
+// to decide there was an error.
+TEXT runtime·syscall(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	BIC     $0x7, R13		// align for ELF ABI
+
+	MOVW	R0, R8
+
+	MOVW	(0*4)(R8), R7 // fn
+	MOVW	(1*4)(R8), R0 // a1
+	MOVW	(2*4)(R8), R1 // a2
+	MOVW	(3*4)(R8), R2 // a3
+
+	BL	(R7)
+
+	MOVW	R0, (4*4)(R8) // r1
+	MOVW	R1, (5*4)(R8) // r2
+
+	// Standard libc functions return -1 on error and set errno.
+	CMP	$-1, R0
+	BNE	ok
+
+	// Get error code from libc.
+	BL	libc_errno(SB)
+	MOVW	(R0), R1
+	MOVW	R1, (6*4)(R8) // err
+
+ok:
+	MOVW	$0, R0		// no error (it's ignored anyway)
+	MOVW	R9, R13
+	RET
+
+// syscallX calls a function in libc on behalf of the syscall package.
+// syscallX takes a pointer to a struct like:
+// struct {
+//	fn    uintptr
+//	a1    uintptr
+//	a2    uintptr
+//	a3    uintptr
+//	r1    uintptr
+//	r2    uintptr
+//	err   uintptr
+// }
+// syscallX must be called on the g0 stack with the
+// C calling convention (use libcCall).
+//
+// syscallX is like syscall but expects a 64-bit result
+// and tests for 64-bit -1 to decide there was an error.
+TEXT runtime·syscallX(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	BIC     $0x7, R13		// align for ELF ABI
+
+	MOVW	R0, R8
+
+	MOVW	(0*4)(R8), R7 // fn
+	MOVW	(1*4)(R8), R0 // a1
+	MOVW	(2*4)(R8), R1 // a2
+	MOVW	(3*4)(R8), R2 // a3
+
+	BL	(R7)
+
+	MOVW	R0, (4*4)(R8) // r1
+	MOVW	R1, (5*4)(R8) // r2
+
+	// Standard libc functions return -1 on error and set errno.
+	CMP	$-1, R0
+	BNE	ok
+	CMP	$-1, R1
+	BNE	ok
+
+	// Get error code from libc.
+	BL	libc_errno(SB)
+	MOVW	(R0), R1
+	MOVW	R1, (6*4)(R8) // err
+
+ok:
+	MOVW	$0, R0		// no error (it's ignored anyway)
+	MOVW	R9, R13
+	RET
+
+// syscall6 calls a function in libc on behalf of the syscall package.
+// syscall6 takes a pointer to a struct like:
+// struct {
+//	fn    uintptr
+//	a1    uintptr
+//	a2    uintptr
+//	a3    uintptr
+//	a4    uintptr
+//	a5    uintptr
+//	a6    uintptr
+//	r1    uintptr
+//	r2    uintptr
+//	err   uintptr
+// }
+// syscall6 must be called on the g0 stack with the
+// C calling convention (use libcCall).
+//
+// syscall6 expects a 32-bit result and tests for 32-bit -1
+// to decide there was an error.
+TEXT runtime·syscall6(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	SUB	$8, R13
+	BIC     $0x7, R13		// align for ELF ABI
+
+	MOVW	R0, R8
+
+	MOVW	(0*4)(R8), R7 // fn
+	MOVW	(1*4)(R8), R0 // a1
+	MOVW	(2*4)(R8), R1 // a2
+	MOVW	(3*4)(R8), R2 // a3
+	MOVW	(4*4)(R8), R3 // a4
+	MOVW	(5*4)(R8), R4 // a5
+	MOVW	R4, 0(R13)
+	MOVW	(6*4)(R8), R5 // a6
+	MOVW	R5, 4(R13)
+
+	BL	(R7)
+
+	MOVW	R0, (7*4)(R8) // r1
+	MOVW	R1, (8*4)(R8) // r2
+
+	// Standard libc functions return -1 on error and set errno.
+	CMP	$-1, R0
+	BNE	ok
+
+	// Get error code from libc.
+	BL	libc_errno(SB)
+	MOVW	(R0), R1
+	MOVW	R1, (9*4)(R8) // err
+
+ok:
+	MOVW	$0, R0		// no error (it's ignored anyway)
+	MOVW	R9, R13
+	RET
+
+// syscall6X calls a function in libc on behalf of the syscall package.
+// syscall6X takes a pointer to a struct like:
+// struct {
+//	fn    uintptr
+//	a1    uintptr
+//	a2    uintptr
+//	a3    uintptr
+//	a4    uintptr
+//	a5    uintptr
+//	a6    uintptr
+//	r1    uintptr
+//	r2    uintptr
+//	err   uintptr
+// }
+// syscall6X must be called on the g0 stack with the
+// C calling convention (use libcCall).
+//
+// syscall6X is like syscall6 but expects a 64-bit result
+// and tests for 64-bit -1 to decide there was an error.
+TEXT runtime·syscall6X(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	SUB	$8, R13
+	BIC     $0x7, R13		// align for ELF ABI
+
+	MOVW	R0, R8
+
+	MOVW	(0*4)(R8), R7 // fn
+	MOVW	(1*4)(R8), R0 // a1
+	MOVW	(2*4)(R8), R1 // a2
+	MOVW	(3*4)(R8), R2 // a3
+	MOVW	(4*4)(R8), R3 // a4
+	MOVW	(5*4)(R8), R4 // a5
+	MOVW	R4, 0(R13)
+	MOVW	(6*4)(R8), R5 // a6
+	MOVW	R5, 4(R13)
+
+	BL	(R7)
+
+	MOVW	R0, (7*4)(R8) // r1
+	MOVW	R1, (8*4)(R8) // r2
+
+	// Standard libc functions return -1 on error and set errno.
+	CMP	$-1, R0
+	BNE	ok
+	CMP	$-1, R1
+	BNE	ok
+
+	// Get error code from libc.
+	BL	libc_errno(SB)
+	MOVW	(R0), R1
+	MOVW	R1, (9*4)(R8) // err
+
+ok:
+	MOVW	$0, R0		// no error (it's ignored anyway)
+	MOVW	R9, R13
+	RET
+
+// syscall10 calls a function in libc on behalf of the syscall package.
+// syscall10 takes a pointer to a struct like:
+// struct {
+//	fn    uintptr
+//	a1    uintptr
+//	a2    uintptr
+//	a3    uintptr
+//	a4    uintptr
+//	a5    uintptr
+//	a6    uintptr
+//	a7    uintptr
+//	a8    uintptr
+//	a9    uintptr
+//	a10   uintptr
+//	r1    uintptr
+//	r2    uintptr
+//	err   uintptr
+// }
+// syscall10 must be called on the g0 stack with the
+// C calling convention (use libcCall).
+TEXT runtime·syscall10(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	SUB	$24, R13
+	BIC     $0x7, R13		// align for ELF ABI
+
+	MOVW	R0, R8
+
+	MOVW	(0*4)(R8), R7 // fn
+	MOVW	(1*4)(R8), R0 // a1
+	MOVW	(2*4)(R8), R1 // a2
+	MOVW	(3*4)(R8), R2 // a3
+	MOVW	(4*4)(R8), R3 // a4
+	MOVW	(5*4)(R8), R4 // a5
+	MOVW	R4, 0(R13)
+	MOVW	(6*4)(R8), R5 // a6
+	MOVW	R5, 4(R13)
+	MOVW	(7*4)(R8), R6 // a7
+	MOVW	R6, 8(R13)
+	MOVW	(8*4)(R8), R4 // a8
+	MOVW	R4, 12(R13)
+	MOVW	(9*4)(R8), R5 // a9
+	MOVW	R5, 16(R13)
+	MOVW	(10*4)(R8), R6 // a10
+	MOVW	R6, 20(R13)
+
+	BL	(R7)
+
+	MOVW	R0, (11*4)(R8) // r1
+	MOVW	R1, (12*4)(R8) // r2
+
+	// Standard libc functions return -1 on error and set errno.
+	CMP	$-1, R0
+	BNE	ok
+
+	// Get error code from libc.
+	BL	libc_errno(SB)
+	MOVW	(R0), R1
+	MOVW	R1, (13*4)(R8) // err
+
+ok:
+	MOVW	$0, R0		// no error (it's ignored anyway)
+	MOVW	R9, R13
+	RET
+
+// syscall10X calls a function in libc on behalf of the syscall package.
+// syscall10X takes a pointer to a struct like:
+// struct {
+//	fn    uintptr
+//	a1    uintptr
+//	a2    uintptr
+//	a3    uintptr
+//	a4    uintptr
+//	a5    uintptr
+//	a6    uintptr
+//	a7    uintptr
+//	a8    uintptr
+//	a9    uintptr
+//	a10   uintptr
+//	r1    uintptr
+//	r2    uintptr
+//	err   uintptr
+// }
+// syscall10X must be called on the g0 stack with the
+// C calling convention (use libcCall).
+//
+// syscall10X is like syscall10 but expects a 64-bit result
+// and tests for 64-bit -1 to decide there was an error.
+TEXT runtime·syscall10X(SB),NOSPLIT,$0
+	MOVW	R13, R9
+	SUB	$24, R13
+	BIC     $0x7, R13		// align for ELF ABI
+
+	MOVW	R0, R8
+
+	MOVW	(0*4)(R8), R7 // fn
+	MOVW	(1*4)(R8), R0 // a1
+	MOVW	(2*4)(R8), R1 // a2
+	MOVW	(3*4)(R8), R2 // a3
+	MOVW	(4*4)(R8), R3 // a4
+	MOVW	(5*4)(R8), R4 // a5
+	MOVW	R4, 0(R13)
+	MOVW	(6*4)(R8), R5 // a6
+	MOVW	R5, 4(R13)
+	MOVW	(7*4)(R8), R6 // a7
+	MOVW	R6, 8(R13)
+	MOVW	(8*4)(R8), R4 // a8
+	MOVW	R4, 12(R13)
+	MOVW	(9*4)(R8), R5 // a9
+	MOVW	R5, 16(R13)
+	MOVW	(10*4)(R8), R6 // a10
+	MOVW	R6, 20(R13)
+
+	BL	(R7)
+
+	MOVW	R0, (11*4)(R8) // r1
+	MOVW	R1, (12*4)(R8) // r2
+
+	// Standard libc functions return -1 on error and set errno.
+	CMP	$-1, R0
+	BNE	ok
+	CMP	$-1, R1
+	BNE	ok
+
+	// Get error code from libc.
+	BL	libc_errno(SB)
+	MOVW	(R0), R1
+	MOVW	R1, (13*4)(R8) // err
+
+ok:
+	MOVW	$0, R0		// no error (it's ignored anyway)
+	MOVW	R9, R13
+	RET
diff --git a/src/syscall/asm_openbsd_arm.s b/src/syscall/asm_openbsd_arm.s
index 26fd791fda..520da91bf3 100644
--- a/src/syscall/asm_openbsd_arm.s
+++ b/src/syscall/asm_openbsd_arm.s
@@ -3,137 +3,30 @@
 // license that can be found in the LICENSE file.
 
 #include "textflag.h"
-#include "funcdata.h"
 
 //
 // System call support for ARM, OpenBSD
 //
 
-// func Syscall(trap int32, a1, a2, a3 int32) (r1, r2, err int32);
-// func Syscall6(trap int32, a1, a2, a3, a4, a5, a6 int32) (r1, r2, err int32);
-// func Syscall9(trap int32, a1, a2, a3, a4, a5, a6, a7, a8, a9 int64) (r1, r2, err int32)
-// func RawSyscall(trap int32, a1, a2, a3 int32) (r1, r2, err int32);
-// func RawSyscall6(trap int32, a1, a2, a3, a4, a5, a6 int32) (r1, r2, err int32);
-
-// See comment in runtime/sys_openbsd_arm.s re this construction.
-#define NOOP	MOVW    R0, R0
-#define	INVOKE_SYSCALL	\
-	SWI	$0;	\
-	NOOP;		\
-	NOOP
+// Provide these function names via assembly so they are provided as ABI0,
+// rather than ABIInternal.
 
+// func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
 TEXT	·Syscall(SB),NOSPLIT,$0-28
-	BL runtime·entersyscall(SB)
-	MOVW trap+0(FP), R12		// syscall number
-	MOVW a1+4(FP), R0		// arg 1
-	MOVW a2+8(FP), R1		// arg 2
-	MOVW a3+12(FP), R2		// arg 3
-	INVOKE_SYSCALL
-	MOVW $0, R2
-	BCS error
-	MOVW R0, r1+16(FP)		// ret 1
-	MOVW R1, r2+20(FP)		// ret 2
-	MOVW R2, err+24(FP)		// err
-	BL runtime·exitsyscall(SB)
-	RET
-error:
-	MOVW $-1, R3
-	MOVW R3, r1+16(FP)		// ret 1
-	MOVW R2, r2+20(FP)		// ret 2
-	MOVW R0, err+24(FP)		// err
-	BL runtime·exitsyscall(SB)
-	RET
+	JMP	·syscallInternal(SB)
 
+// func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
 TEXT	·Syscall6(SB),NOSPLIT,$0-40
-	BL runtime·entersyscall(SB)
-	MOVW trap+0(FP), R12		// syscall number
-	MOVW a1+4(FP), R0		// arg 1
-	MOVW a2+8(FP), R1		// arg 2
-	MOVW a3+12(FP), R2		// arg 3
-	MOVW a4+16(FP), R3		// arg 4
-	MOVW R13, R4
-	MOVW $a5+20(FP), R13		// arg 5 to arg 6 are passed on stack
-	INVOKE_SYSCALL
-	MOVW R4, R13
-	MOVW $0, R2
-	BCS error6
-	MOVW R0, r1+28(FP)		// ret 1
-	MOVW R1, r2+32(FP)		// ret 2
-	MOVW R2, err+36(FP)		// err
-	BL runtime·exitsyscall(SB)
-	RET
-error6:
-	MOVW $-1, R3
-	MOVW R3, r1+28(FP)		// ret 1
-	MOVW R2, r2+32(FP)		// ret 2
-	MOVW R0, err+36(FP)		// err
-	BL runtime·exitsyscall(SB)
-	RET
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-52
-	BL runtime·entersyscall(SB)
-	MOVW num+0(FP), R12		// syscall number
-	MOVW a1+4(FP), R0		// arg 1
-	MOVW a2+8(FP), R1		// arg 2
-	MOVW a3+12(FP), R2		// arg 3
-	MOVW a4+16(FP), R3		// arg 4
-	MOVW R13, R4
-	MOVW $a5+20(FP), R13		// arg 5 to arg 9 are passed on stack
-	INVOKE_SYSCALL
-	MOVW R4, R13
-	MOVW $0, R2
-	BCS error9
-	MOVW R0, r1+40(FP)		// ret 1
-	MOVW R1, r2+44(FP)		// ret 2
-	MOVW R2, err+48(FP)		// err
-	BL runtime·exitsyscall(SB)
-	RET
-error9:
-	MOVW $-1, R3
-	MOVW R3, r1+40(FP)		// ret 1
-	MOVW R2, r2+44(FP)		// ret 2
-	MOVW R0, err+48(FP)		// err
-	BL runtime·exitsyscall(SB)
-	RET
+	JMP	·syscall6Internal(SB)
 
+// func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
 TEXT	·RawSyscall(SB),NOSPLIT,$0-28
-	MOVW trap+0(FP), R12		// syscall number
-	MOVW a1+4(FP), R0		// arg 1
-	MOVW a2+8(FP), R1		// arg 2
-	MOVW a3+12(FP), R2		// arg 3
-	INVOKE_SYSCALL
-	MOVW $0, R2
-	BCS errorr
-	MOVW R0, r1+16(FP)		// ret 1
-	MOVW R1, r2+20(FP)		// ret 2
-	MOVW R2, err+24(FP)		// err
-	RET
-errorr:
-	MOVW $-1, R3
-	MOVW R3, r1+16(FP)		// ret 1
-	MOVW R2, r2+20(FP)		// ret 2
-	MOVW R0, err+24(FP)		// err
-	RET
+	JMP	·rawSyscallInternal(SB)
 
+// func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
 TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
-	MOVW trap+0(FP), R12		// syscall number
-	MOVW a1+4(FP), R0		// arg 1
-	MOVW a2+8(FP), R1		// arg 2
-	MOVW a3+12(FP), R2		// arg 3
-	MOVW a4+16(FP), R3		// arg 4
-	MOVW R13, R4
-	MOVW $a5+20(FP), R13		// arg 5 to arg 6 are passed on stack
-	INVOKE_SYSCALL
-	MOVW R4, R13
-	MOVW $0, R2
-	BCS errorr6
-	MOVW R0, r1+28(FP)		// ret 1
-	MOVW R1, r2+32(FP)		// ret 2
-	MOVW R2, err+36(FP)		// err
-	RET
-errorr6:
-	MOVW $-1, R3
-	MOVW R3, r1+28(FP)		// ret 1
-	MOVW R2, r2+32(FP)		// ret 2
-	MOVW R0, err+36(FP)		// err
-	RET
+	JMP	·rawSyscall6Internal(SB)
+
+// func Syscall9(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno)
+TEXT	·Syscall9(SB),NOSPLIT,$0-52
+	JMP	·syscall9Internal(SB)
diff --git a/src/syscall/exec_bsd.go b/src/syscall/exec_bsd.go
index 41d1f693b2..569dd675ed 100644
--- a/src/syscall/exec_bsd.go
+++ b/src/syscall/exec_bsd.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build dragonfly || freebsd || netbsd || (openbsd && !386 && !amd64 && !arm64)
-// +build dragonfly freebsd netbsd openbsd,!386,!amd64,!arm64
+//go:build dragonfly || freebsd || netbsd || (openbsd && !386 && !amd64 && !arm && !arm64)
+// +build dragonfly freebsd netbsd openbsd,!386,!amd64,!arm,!arm64
 
 package syscall
 
diff --git a/src/syscall/exec_libc2.go b/src/syscall/exec_libc2.go
index 8e957b3d4a..7442d59aff 100644
--- a/src/syscall/exec_libc2.go
+++ b/src/syscall/exec_libc2.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build darwin || (openbsd && 386) || (openbsd && amd64) || (openbsd && arm64)
-// +build darwin openbsd,386 openbsd,amd64 openbsd,arm64
+//go:build darwin || (openbsd && 386) || (openbsd && amd64) || (openbsd && arm) || (openbsd && arm64)
+// +build darwin openbsd,386 openbsd,amd64 openbsd,arm openbsd,arm64
 
 package syscall
 
diff --git a/src/syscall/exec_unix.go b/src/syscall/exec_unix.go
index 206a1e17d6..54b18dccd7 100644
--- a/src/syscall/exec_unix.go
+++ b/src/syscall/exec_unix.go
@@ -301,7 +301,7 @@ func Exec(argv0 string, argv []string, envv []string) (err error) {
 	} else if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
 		// Similarly on Darwin.
 		err1 = execveDarwin(argv0p, &argvp[0], &envvp[0])
-	} else if runtime.GOOS == "openbsd" && (runtime.GOARCH == "386" || runtime.GOARCH == "amd64" || runtime.GOARCH == "arm64") {
+	} else if runtime.GOOS == "openbsd" && (runtime.GOARCH == "386" || runtime.GOARCH == "amd64" || runtime.GOARCH == "arm" || runtime.GOARCH == "arm64") {
 		// Similarly on OpenBSD.
 		err1 = execveOpenBSD(argv0p, &argvp[0], &envvp[0])
 	} else {
diff --git a/src/syscall/mkall.sh b/src/syscall/mkall.sh
index 7739147310..dffb52864b 100755
--- a/src/syscall/mkall.sh
+++ b/src/syscall/mkall.sh
@@ -303,15 +303,16 @@ openbsd_amd64)
 	mkasm="go run mkasm.go"
 	;;
 openbsd_arm)
-	GOOSARCH_in="syscall_openbsd1.go syscall_openbsd_$GOARCH.go"
+	GOOSARCH_in="syscall_openbsd_libc.go syscall_openbsd_$GOARCH.go"
 	mkerrors="$mkerrors"
-	mksyscall="./mksyscall.pl -l32 -openbsd -arm"
+	mksyscall="./mksyscall.pl -l32 -openbsd -arm -libc"
 	mksysctl="./mksysctl_openbsd.pl"
 	zsysctl="zsysctl_openbsd.go"
 	mksysnum="curl -s 'http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master' | ./mksysnum_openbsd.pl"
 	# Let the type of C char be signed to make the bare syscall
 	# API consistent between platforms.
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char"
+	mkasm="go run mkasm.go"
 	;;
 openbsd_arm64)
 	GOOSARCH_in="syscall_openbsd_libc.go syscall_openbsd_$GOARCH.go"
diff --git a/src/syscall/mksyscall.pl b/src/syscall/mksyscall.pl
index 5ca3b465d8..758948bc53 100755
--- a/src/syscall/mksyscall.pl
+++ b/src/syscall/mksyscall.pl
@@ -191,6 +191,10 @@ while(<>) {
 			if (!$libc) {
 				push @args, "0";
 			}
+			if($libc && $arm && @args % 2) {
+				# arm abi specifies 64 bit argument must be 64 bit aligned.
+				push @args, "0"
+			}
 			if($_32bit eq "big-endian") {
 				push @args, "uintptr($name>>32)", "uintptr($name)";
 			} elsif($_32bit eq "little-endian") {
diff --git a/src/syscall/syscall_openbsd1.go b/src/syscall/syscall_openbsd1.go
index c446768aab..450f384831 100644
--- a/src/syscall/syscall_openbsd1.go
+++ b/src/syscall/syscall_openbsd1.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build openbsd && !386 && !amd64 && !arm64
-// +build openbsd,!386,!amd64,!arm64
+//go:build openbsd && !386 && !amd64 && !arm && !arm64
+// +build openbsd,!386,!amd64,!arm,!arm64
 
 package syscall
 
diff --git a/src/syscall/syscall_openbsd_libc.go b/src/syscall/syscall_openbsd_libc.go
index 750be6f707..2390912b0f 100644
--- a/src/syscall/syscall_openbsd_libc.go
+++ b/src/syscall/syscall_openbsd_libc.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm64)
-// +build openbsd,386 openbsd,amd64 openbsd,arm64
+//go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm) || (openbsd && arm64)
+// +build openbsd,386 openbsd,amd64 openbsd,arm openbsd,arm64
 
 package syscall
 
diff --git a/src/syscall/zsyscall_openbsd_arm.go b/src/syscall/zsyscall_openbsd_arm.go
index 31425b3558..04a2fadccd 100644
--- a/src/syscall/zsyscall_openbsd_arm.go
+++ b/src/syscall/zsyscall_openbsd_arm.go
@@ -1,4 +1,4 @@
-// mksyscall.pl -l32 -openbsd -arm -tags openbsd,arm syscall_bsd.go syscall_openbsd.go syscall_openbsd_arm.go
+// mksyscall.pl -l32 -openbsd -arm -libc -tags openbsd,arm syscall_bsd.go syscall_openbsd.go syscall_openbsd_libc.go syscall_openbsd_arm.go
 // Code generated by the command above; DO NOT EDIT.
 
 //go:build openbsd && arm
@@ -7,11 +7,12 @@
 package syscall
 
 import "unsafe"
+import "internal/abi"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
-	r0, _, e1 := RawSyscall(SYS_GETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -19,20 +20,28 @@ func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
 	return
 }
 
+func libc_getgroups_trampoline()
+
+//go:cgo_import_dynamic libc_getgroups getgroups "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func setgroups(ngid int, gid *_Gid_t) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_setgroups_trampoline()
+
+//go:cgo_import_dynamic libc_setgroups setgroups "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) {
-	r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
 	wpid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -40,10 +49,14 @@ func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err
 	return
 }
 
+func libc_wait4_trampoline()
+
+//go:cgo_import_dynamic libc_wait4 wait4 "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
-	r0, _, e1 := Syscall(SYS_ACCEPT, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -51,30 +64,42 @@ func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
 	return
 }
 
+func libc_accept_trampoline()
+
+//go:cgo_import_dynamic libc_accept accept "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
-	_, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_bind_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_bind_trampoline()
+
+//go:cgo_import_dynamic libc_bind bind "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
-	_, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_connect_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_connect_trampoline()
+
+//go:cgo_import_dynamic libc_connect connect "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func socket(domain int, typ int, proto int) (fd int, err error) {
-	r0, _, e1 := RawSyscall(SYS_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto))
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_socket_trampoline), uintptr(domain), uintptr(typ), uintptr(proto))
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -82,66 +107,94 @@ func socket(domain int, typ int, proto int) (fd int, err error) {
 	return
 }
 
+func libc_socket_trampoline()
+
+//go:cgo_import_dynamic libc_socket socket "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
-	_, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_getsockopt_trampoline()
+
+//go:cgo_import_dynamic libc_getsockopt getsockopt "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
-	_, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_setsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_setsockopt_trampoline()
+
+//go:cgo_import_dynamic libc_setsockopt setsockopt "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
-	_, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_getpeername_trampoline()
+
+//go:cgo_import_dynamic libc_getpeername getpeername "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
-	_, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_getsockname_trampoline()
+
+//go:cgo_import_dynamic libc_getsockname getsockname "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Shutdown(s int, how int) (err error) {
-	_, _, e1 := Syscall(SYS_SHUTDOWN, uintptr(s), uintptr(how), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_shutdown_trampoline), uintptr(s), uintptr(how), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_shutdown_trampoline()
+
+//go:cgo_import_dynamic libc_shutdown shutdown "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
-	_, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
+	_, _, e1 := rawSyscall6(abi.FuncPCABI0(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_socketpair_trampoline()
+
+//go:cgo_import_dynamic libc_socketpair socketpair "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) {
@@ -151,7 +204,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := Syscall6(SYS_RECVFROM, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_recvfrom_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -159,6 +212,10 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
 	return
 }
 
+func libc_recvfrom_trampoline()
+
+//go:cgo_import_dynamic libc_recvfrom recvfrom "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
@@ -168,17 +225,21 @@ func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := Syscall6(SYS_SENDTO, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_sendto_trampoline), uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_sendto_trampoline()
+
+//go:cgo_import_dynamic libc_sendto sendto "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
-	r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -186,10 +247,14 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 	return
 }
 
+func libc_recvmsg_trampoline()
+
+//go:cgo_import_dynamic libc_recvmsg recvmsg "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
-	r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -197,10 +262,14 @@ func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 	return
 }
 
+func libc_sendmsg_trampoline()
+
+//go:cgo_import_dynamic libc_sendmsg sendmsg "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
-	r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -208,21 +277,9 @@ func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, ne
 	return
 }
 
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+func libc_kevent_trampoline()
 
-func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) {
-	var _p0 unsafe.Pointer
-	if len(mib) > 0 {
-		_p0 = unsafe.Pointer(&mib[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	_, _, e1 := Syscall6(SYS___SYSCTL, uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
+//go:cgo_import_dynamic libc_kevent kevent "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
@@ -232,27 +289,35 @@ func utimes(path string, timeval *[2]Timeval) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_utimes_trampoline()
+
+//go:cgo_import_dynamic libc_utimes utimes "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func futimes(fd int, timeval *[2]Timeval) (err error) {
-	_, _, e1 := Syscall(SYS_FUTIMES, uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_futimes_trampoline()
+
+//go:cgo_import_dynamic libc_futimes futimes "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func fcntl(fd int, cmd int, arg int) (val int, err error) {
-	r0, _, e1 := Syscall(SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -260,20 +325,28 @@ func fcntl(fd int, cmd int, arg int) (val int, err error) {
 	return
 }
 
+func libc_fcntl_trampoline()
+
+//go:cgo_import_dynamic libc_fcntl fcntl "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func pipe2(p *[2]_C_int, flags int) (err error) {
-	_, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_pipe2_trampoline), uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_pipe2_trampoline()
+
+//go:cgo_import_dynamic libc_pipe2 pipe2 "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func accept4(fd int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (nfd int, err error) {
-	r0, _, e1 := Syscall6(SYS_ACCEPT4, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_accept4_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
 	nfd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -281,6 +354,10 @@ func accept4(fd int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (nfd int
 	return
 }
 
+func libc_accept4_trampoline()
+
+//go:cgo_import_dynamic libc_accept4 accept4 "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getdents(fd int, buf []byte) (n int, err error) {
@@ -290,7 +367,7 @@ func getdents(fd int, buf []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := Syscall(SYS_GETDENTS, uintptr(fd), uintptr(_p0), uintptr(len(buf)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_getdents_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(buf)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -298,6 +375,10 @@ func getdents(fd int, buf []byte) (n int, err error) {
 	return
 }
 
+func libc_getdents_trampoline()
+
+//go:cgo_import_dynamic libc_getdents getdents "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Access(path string, mode uint32) (err error) {
@@ -306,23 +387,31 @@ func Access(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_ACCESS, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_access_trampoline()
+
+//go:cgo_import_dynamic libc_access access "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Adjtime(delta *Timeval, olddelta *Timeval) (err error) {
-	_, _, e1 := Syscall(SYS_ADJTIME, uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_adjtime_trampoline()
+
+//go:cgo_import_dynamic libc_adjtime adjtime "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Chdir(path string) (err error) {
@@ -331,13 +420,17 @@ func Chdir(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_chdir_trampoline()
+
+//go:cgo_import_dynamic libc_chdir chdir "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Chflags(path string, flags int) (err error) {
@@ -346,13 +439,17 @@ func Chflags(path string, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_CHFLAGS, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_chflags_trampoline()
+
+//go:cgo_import_dynamic libc_chflags chflags "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Chmod(path string, mode uint32) (err error) {
@@ -361,13 +458,17 @@ func Chmod(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_CHMOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_chmod_trampoline()
+
+//go:cgo_import_dynamic libc_chmod chmod "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Chown(path string, uid int, gid int) (err error) {
@@ -376,13 +477,17 @@ func Chown(path string, uid int, gid int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_CHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_chown_trampoline()
+
+//go:cgo_import_dynamic libc_chown chown "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Chroot(path string) (err error) {
@@ -391,27 +496,35 @@ func Chroot(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_chroot_trampoline()
+
+//go:cgo_import_dynamic libc_chroot chroot "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Close(fd int) (err error) {
-	_, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_close_trampoline), uintptr(fd), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_close_trampoline()
+
+//go:cgo_import_dynamic libc_close close "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Dup(fd int) (nfd int, err error) {
-	r0, _, e1 := Syscall(SYS_DUP, uintptr(fd), 0, 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_dup_trampoline), uintptr(fd), 0, 0)
 	nfd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -419,70 +532,98 @@ func Dup(fd int) (nfd int, err error) {
 	return
 }
 
+func libc_dup_trampoline()
+
+//go:cgo_import_dynamic libc_dup dup "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Dup2(from int, to int) (err error) {
-	_, _, e1 := Syscall(SYS_DUP2, uintptr(from), uintptr(to), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_dup2_trampoline), uintptr(from), uintptr(to), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_dup2_trampoline()
+
+//go:cgo_import_dynamic libc_dup2 dup2 "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchdir(fd int) (err error) {
-	_, _, e1 := Syscall(SYS_FCHDIR, uintptr(fd), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fchdir_trampoline), uintptr(fd), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_fchdir_trampoline()
+
+//go:cgo_import_dynamic libc_fchdir fchdir "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchflags(fd int, flags int) (err error) {
-	_, _, e1 := Syscall(SYS_FCHFLAGS, uintptr(fd), uintptr(flags), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fchflags_trampoline), uintptr(fd), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_fchflags_trampoline()
+
+//go:cgo_import_dynamic libc_fchflags fchflags "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchmod(fd int, mode uint32) (err error) {
-	_, _, e1 := Syscall(SYS_FCHMOD, uintptr(fd), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fchmod_trampoline), uintptr(fd), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_fchmod_trampoline()
+
+//go:cgo_import_dynamic libc_fchmod fchmod "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchown(fd int, uid int, gid int) (err error) {
-	_, _, e1 := Syscall(SYS_FCHOWN, uintptr(fd), uintptr(uid), uintptr(gid))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fchown_trampoline), uintptr(fd), uintptr(uid), uintptr(gid))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_fchown_trampoline()
+
+//go:cgo_import_dynamic libc_fchown fchown "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Flock(fd int, how int) (err error) {
-	_, _, e1 := Syscall(SYS_FLOCK, uintptr(fd), uintptr(how), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_flock_trampoline), uintptr(fd), uintptr(how), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_flock_trampoline()
+
+//go:cgo_import_dynamic libc_flock flock "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fpathconf(fd int, name int) (val int, err error) {
-	r0, _, e1 := Syscall(SYS_FPATHCONF, uintptr(fd), uintptr(name), 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_fpathconf_trampoline), uintptr(fd), uintptr(name), 0)
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -490,74 +631,106 @@ func Fpathconf(fd int, name int) (val int, err error) {
 	return
 }
 
+func libc_fpathconf_trampoline()
+
+//go:cgo_import_dynamic libc_fpathconf fpathconf "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fstat(fd int, stat *Stat_t) (err error) {
-	_, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fstat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_fstat_trampoline()
+
+//go:cgo_import_dynamic libc_fstat fstat "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fstatfs(fd int, stat *Statfs_t) (err error) {
-	_, _, e1 := Syscall(SYS_FSTATFS, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fstatfs_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_fstatfs_trampoline()
+
+//go:cgo_import_dynamic libc_fstatfs fstatfs "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fsync(fd int) (err error) {
-	_, _, e1 := Syscall(SYS_FSYNC, uintptr(fd), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_fsync_trampoline), uintptr(fd), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_fsync_trampoline()
+
+//go:cgo_import_dynamic libc_fsync fsync "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Ftruncate(fd int, length int64) (err error) {
-	_, _, e1 := Syscall6(SYS_FTRUNCATE, uintptr(fd), 0, uintptr(length), uintptr(length>>32), 0, 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_ftruncate_trampoline), uintptr(fd), 0, uintptr(length), uintptr(length>>32), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_ftruncate_trampoline()
+
+//go:cgo_import_dynamic libc_ftruncate ftruncate "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getegid() (egid int) {
-	r0, _, _ := RawSyscall(SYS_GETEGID, 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getegid_trampoline), 0, 0, 0)
 	egid = int(r0)
 	return
 }
 
+func libc_getegid_trampoline()
+
+//go:cgo_import_dynamic libc_getegid getegid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Geteuid() (uid int) {
-	r0, _, _ := RawSyscall(SYS_GETEUID, 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_geteuid_trampoline), 0, 0, 0)
 	uid = int(r0)
 	return
 }
 
+func libc_geteuid_trampoline()
+
+//go:cgo_import_dynamic libc_geteuid geteuid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getgid() (gid int) {
-	r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getgid_trampoline), 0, 0, 0)
 	gid = int(r0)
 	return
 }
 
+func libc_getgid_trampoline()
+
+//go:cgo_import_dynamic libc_getgid getgid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpgid(pid int) (pgid int, err error) {
-	r0, _, e1 := RawSyscall(SYS_GETPGID, uintptr(pid), 0, 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getpgid_trampoline), uintptr(pid), 0, 0)
 	pgid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -565,34 +738,50 @@ func Getpgid(pid int) (pgid int, err error) {
 	return
 }
 
+func libc_getpgid_trampoline()
+
+//go:cgo_import_dynamic libc_getpgid getpgid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpgrp() (pgrp int) {
-	r0, _, _ := RawSyscall(SYS_GETPGRP, 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getpgrp_trampoline), 0, 0, 0)
 	pgrp = int(r0)
 	return
 }
 
+func libc_getpgrp_trampoline()
+
+//go:cgo_import_dynamic libc_getpgrp getpgrp "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpid() (pid int) {
-	r0, _, _ := RawSyscall(SYS_GETPID, 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getpid_trampoline), 0, 0, 0)
 	pid = int(r0)
 	return
 }
 
+func libc_getpid_trampoline()
+
+//go:cgo_import_dynamic libc_getpid getpid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getppid() (ppid int) {
-	r0, _, _ := RawSyscall(SYS_GETPPID, 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getppid_trampoline), 0, 0, 0)
 	ppid = int(r0)
 	return
 }
 
+func libc_getppid_trampoline()
+
+//go:cgo_import_dynamic libc_getppid getppid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpriority(which int, who int) (prio int, err error) {
-	r0, _, e1 := Syscall(SYS_GETPRIORITY, uintptr(which), uintptr(who), 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_getpriority_trampoline), uintptr(which), uintptr(who), 0)
 	prio = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -600,30 +789,42 @@ func Getpriority(which int, who int) (prio int, err error) {
 	return
 }
 
+func libc_getpriority_trampoline()
+
+//go:cgo_import_dynamic libc_getpriority getpriority "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getrlimit(which int, lim *Rlimit) (err error) {
-	_, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_getrlimit_trampoline()
+
+//go:cgo_import_dynamic libc_getrlimit getrlimit "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getrusage(who int, rusage *Rusage) (err error) {
-	_, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_getrusage_trampoline()
+
+//go:cgo_import_dynamic libc_getrusage getrusage "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getsid(pid int) (sid int, err error) {
-	r0, _, e1 := RawSyscall(SYS_GETSID, uintptr(pid), 0, 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getsid_trampoline), uintptr(pid), 0, 0)
 	sid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -631,46 +832,66 @@ func Getsid(pid int) (sid int, err error) {
 	return
 }
 
+func libc_getsid_trampoline()
+
+//go:cgo_import_dynamic libc_getsid getsid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Gettimeofday(tv *Timeval) (err error) {
-	_, _, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tv)), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tv)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_gettimeofday_trampoline()
+
+//go:cgo_import_dynamic libc_gettimeofday gettimeofday "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getuid() (uid int) {
-	r0, _, _ := RawSyscall(SYS_GETUID, 0, 0, 0)
+	r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getuid_trampoline), 0, 0, 0)
 	uid = int(r0)
 	return
 }
 
+func libc_getuid_trampoline()
+
+//go:cgo_import_dynamic libc_getuid getuid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Issetugid() (tainted bool) {
-	r0, _, _ := Syscall(SYS_ISSETUGID, 0, 0, 0)
+	r0, _, _ := syscall(abi.FuncPCABI0(libc_issetugid_trampoline), 0, 0, 0)
 	tainted = bool(r0 != 0)
 	return
 }
 
+func libc_issetugid_trampoline()
+
+//go:cgo_import_dynamic libc_issetugid issetugid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Kill(pid int, signum Signal) (err error) {
-	_, _, e1 := Syscall(SYS_KILL, uintptr(pid), uintptr(signum), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_kill_trampoline), uintptr(pid), uintptr(signum), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_kill_trampoline()
+
+//go:cgo_import_dynamic libc_kill kill "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Kqueue() (fd int, err error) {
-	r0, _, e1 := Syscall(SYS_KQUEUE, 0, 0, 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_kqueue_trampoline), 0, 0, 0)
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -678,6 +899,10 @@ func Kqueue() (fd int, err error) {
 	return
 }
 
+func libc_kqueue_trampoline()
+
+//go:cgo_import_dynamic libc_kqueue kqueue "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Lchown(path string, uid int, gid int) (err error) {
@@ -686,13 +911,17 @@ func Lchown(path string, uid int, gid int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_LCHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_lchown_trampoline()
+
+//go:cgo_import_dynamic libc_lchown lchown "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Link(path string, link string) (err error) {
@@ -706,23 +935,31 @@ func Link(path string, link string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_link_trampoline()
+
+//go:cgo_import_dynamic libc_link link "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Listen(s int, backlog int) (err error) {
-	_, _, e1 := Syscall(SYS_LISTEN, uintptr(s), uintptr(backlog), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_listen_trampoline), uintptr(s), uintptr(backlog), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_listen_trampoline()
+
+//go:cgo_import_dynamic libc_listen listen "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Lstat(path string, stat *Stat_t) (err error) {
@@ -731,13 +968,17 @@ func Lstat(path string, stat *Stat_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_LSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_lstat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_lstat_trampoline()
+
+//go:cgo_import_dynamic libc_lstat lstat "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Mkdir(path string, mode uint32) (err error) {
@@ -746,13 +987,17 @@ func Mkdir(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_MKDIR, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_mkdir_trampoline()
+
+//go:cgo_import_dynamic libc_mkdir mkdir "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Mkfifo(path string, mode uint32) (err error) {
@@ -761,13 +1006,17 @@ func Mkfifo(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_MKFIFO, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_mkfifo_trampoline()
+
+//go:cgo_import_dynamic libc_mkfifo mkfifo "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Mknod(path string, mode uint32, dev int) (err error) {
@@ -776,23 +1025,31 @@ func Mknod(path string, mode uint32, dev int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_MKNOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_mknod_trampoline()
+
+//go:cgo_import_dynamic libc_mknod mknod "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Nanosleep(time *Timespec, leftover *Timespec) (err error) {
-	_, _, e1 := Syscall(SYS_NANOSLEEP, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_nanosleep_trampoline), uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_nanosleep_trampoline()
+
+//go:cgo_import_dynamic libc_nanosleep nanosleep "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Open(path string, mode int, perm uint32) (fd int, err error) {
@@ -801,7 +1058,7 @@ func Open(path string, mode int, perm uint32) (fd int, err error) {
 	if err != nil {
 		return
 	}
-	r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -809,6 +1066,10 @@ func Open(path string, mode int, perm uint32) (fd int, err error) {
 	return
 }
 
+func libc_open_trampoline()
+
+//go:cgo_import_dynamic libc_open open "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Pathconf(path string, name int) (val int, err error) {
@@ -817,7 +1078,7 @@ func Pathconf(path string, name int) (val int, err error) {
 	if err != nil {
 		return
 	}
-	r0, _, e1 := Syscall(SYS_PATHCONF, uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -825,6 +1086,10 @@ func Pathconf(path string, name int) (val int, err error) {
 	return
 }
 
+func libc_pathconf_trampoline()
+
+//go:cgo_import_dynamic libc_pathconf pathconf "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Pread(fd int, p []byte, offset int64) (n int, err error) {
@@ -834,7 +1099,7 @@ func Pread(fd int, p []byte, offset int64) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), 0, uintptr(offset), uintptr(offset>>32))
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_pread_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), 0, uintptr(offset), uintptr(offset>>32))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -842,6 +1107,10 @@ func Pread(fd int, p []byte, offset int64) (n int, err error) {
 	return
 }
 
+func libc_pread_trampoline()
+
+//go:cgo_import_dynamic libc_pread pread "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
@@ -851,7 +1120,7 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), 0, uintptr(offset), uintptr(offset>>32))
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_pwrite_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), 0, uintptr(offset), uintptr(offset>>32))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -859,6 +1128,10 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
 	return
 }
 
+func libc_pwrite_trampoline()
+
+//go:cgo_import_dynamic libc_pwrite pwrite "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func read(fd int, p []byte) (n int, err error) {
@@ -868,7 +1141,7 @@ func read(fd int, p []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_read_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -876,6 +1149,10 @@ func read(fd int, p []byte) (n int, err error) {
 	return
 }
 
+func libc_read_trampoline()
+
+//go:cgo_import_dynamic libc_read read "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Readlink(path string, buf []byte) (n int, err error) {
@@ -890,7 +1167,7 @@ func Readlink(path string, buf []byte) (n int, err error) {
 	} else {
 		_p1 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := Syscall(SYS_READLINK, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -898,6 +1175,10 @@ func Readlink(path string, buf []byte) (n int, err error) {
 	return
 }
 
+func libc_readlink_trampoline()
+
+//go:cgo_import_dynamic libc_readlink readlink "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Rename(from string, to string) (err error) {
@@ -911,13 +1192,17 @@ func Rename(from string, to string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_RENAME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_rename_trampoline()
+
+//go:cgo_import_dynamic libc_rename rename "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Revoke(path string) (err error) {
@@ -926,13 +1211,17 @@ func Revoke(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_REVOKE, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_revoke_trampoline()
+
+//go:cgo_import_dynamic libc_revoke revoke "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Rmdir(path string) (err error) {
@@ -941,64 +1230,73 @@ func Rmdir(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_RMDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+func libc_rmdir_trampoline()
 
-func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
-	r0, r1, e1 := Syscall6(SYS_LSEEK, uintptr(fd), 0, uintptr(offset), uintptr(offset>>32), uintptr(whence), 0)
-	newoffset = int64(int64(r1)<<32 | int64(r0))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
+//go:cgo_import_dynamic libc_rmdir rmdir "libc.so"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (err error) {
-	_, _, e1 := Syscall6(SYS_SELECT, uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_select_trampoline), uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_select_trampoline()
+
+//go:cgo_import_dynamic libc_select select "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setegid(egid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETEGID, uintptr(egid), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setegid_trampoline), uintptr(egid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_setegid_trampoline()
+
+//go:cgo_import_dynamic libc_setegid setegid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Seteuid(euid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETEUID, uintptr(euid), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_seteuid_trampoline), uintptr(euid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_seteuid_trampoline()
+
+//go:cgo_import_dynamic libc_seteuid seteuid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setgid(gid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETGID, uintptr(gid), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setgid_trampoline), uintptr(gid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_setgid_trampoline()
+
+//go:cgo_import_dynamic libc_setgid setgid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setlogin(name string) (err error) {
@@ -1007,67 +1305,91 @@ func Setlogin(name string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_SETLOGIN, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_setlogin_trampoline()
+
+//go:cgo_import_dynamic libc_setlogin setlogin "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setpgid(pid int, pgid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETPGID, uintptr(pid), uintptr(pgid), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setpgid_trampoline), uintptr(pid), uintptr(pgid), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_setpgid_trampoline()
+
+//go:cgo_import_dynamic libc_setpgid setpgid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setpriority(which int, who int, prio int) (err error) {
-	_, _, e1 := Syscall(SYS_SETPRIORITY, uintptr(which), uintptr(who), uintptr(prio))
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_setpriority_trampoline), uintptr(which), uintptr(who), uintptr(prio))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_setpriority_trampoline()
+
+//go:cgo_import_dynamic libc_setpriority setpriority "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setregid(rgid int, egid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETREGID, uintptr(rgid), uintptr(egid), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setregid_trampoline), uintptr(rgid), uintptr(egid), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_setregid_trampoline()
+
+//go:cgo_import_dynamic libc_setregid setregid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setreuid(ruid int, euid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETREUID, uintptr(ruid), uintptr(euid), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setreuid_trampoline), uintptr(ruid), uintptr(euid), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_setreuid_trampoline()
+
+//go:cgo_import_dynamic libc_setreuid setreuid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setrlimit(which int, lim *Rlimit) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_setrlimit_trampoline()
+
+//go:cgo_import_dynamic libc_setrlimit setrlimit "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setsid() (pid int, err error) {
-	r0, _, e1 := RawSyscall(SYS_SETSID, 0, 0, 0)
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setsid_trampoline), 0, 0, 0)
 	pid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1075,26 +1397,38 @@ func Setsid() (pid int, err error) {
 	return
 }
 
+func libc_setsid_trampoline()
+
+//go:cgo_import_dynamic libc_setsid setsid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Settimeofday(tp *Timeval) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_settimeofday_trampoline()
+
+//go:cgo_import_dynamic libc_settimeofday settimeofday "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setuid(uid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETUID, uintptr(uid), 0, 0)
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setuid_trampoline), uintptr(uid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_setuid_trampoline()
+
+//go:cgo_import_dynamic libc_setuid setuid "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Stat(path string, stat *Stat_t) (err error) {
@@ -1103,13 +1437,17 @@ func Stat(path string, stat *Stat_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_stat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_stat_trampoline()
+
+//go:cgo_import_dynamic libc_stat stat "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Statfs(path string, stat *Statfs_t) (err error) {
@@ -1118,13 +1456,17 @@ func Statfs(path string, stat *Statfs_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_STATFS, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_statfs_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_statfs_trampoline()
+
+//go:cgo_import_dynamic libc_statfs statfs "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Symlink(path string, link string) (err error) {
@@ -1138,23 +1480,31 @@ func Symlink(path string, link string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_SYMLINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_symlink_trampoline()
+
+//go:cgo_import_dynamic libc_symlink symlink "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Sync() (err error) {
-	_, _, e1 := Syscall(SYS_SYNC, 0, 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_sync_trampoline), 0, 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_sync_trampoline()
+
+//go:cgo_import_dynamic libc_sync sync "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Truncate(path string, length int64) (err error) {
@@ -1163,21 +1513,29 @@ func Truncate(path string, length int64) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall6(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), 0, uintptr(length), uintptr(length>>32), 0, 0)
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), 0, uintptr(length), uintptr(length>>32), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_truncate_trampoline()
+
+//go:cgo_import_dynamic libc_truncate truncate "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Umask(newmask int) (oldmask int) {
-	r0, _, _ := Syscall(SYS_UMASK, uintptr(newmask), 0, 0)
+	r0, _, _ := syscall(abi.FuncPCABI0(libc_umask_trampoline), uintptr(newmask), 0, 0)
 	oldmask = int(r0)
 	return
 }
 
+func libc_umask_trampoline()
+
+//go:cgo_import_dynamic libc_umask umask "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Unlink(path string) (err error) {
@@ -1186,13 +1544,17 @@ func Unlink(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_UNLINK, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_unlink_trampoline()
+
+//go:cgo_import_dynamic libc_unlink unlink "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Unmount(path string, flags int) (err error) {
@@ -1201,13 +1563,17 @@ func Unmount(path string, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_UNMOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_unmount_trampoline()
+
+//go:cgo_import_dynamic libc_unmount unmount "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func write(fd int, p []byte) (n int, err error) {
@@ -1217,7 +1583,7 @@ func write(fd int, p []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_write_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1225,10 +1591,14 @@ func write(fd int, p []byte) (n int, err error) {
 	return
 }
 
+func libc_write_trampoline()
+
+//go:cgo_import_dynamic libc_write write "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
-	r0, _, e1 := Syscall9(SYS_MMAP, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), 0, uintptr(pos), uintptr(pos>>32), 0)
+	r0, _, e1 := syscall9(abi.FuncPCABI0(libc_mmap_trampoline), uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), 0, uintptr(pos), uintptr(pos>>32), 0)
 	ret = uintptr(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1236,20 +1606,62 @@ func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (
 	return
 }
 
+func libc_mmap_trampoline()
+
+//go:cgo_import_dynamic libc_mmap mmap "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func munmap(addr uintptr, length uintptr) (err error) {
-	_, _, e1 := Syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0)
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_munmap_trampoline), uintptr(addr), uintptr(length), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func libc_munmap_trampoline()
+
+//go:cgo_import_dynamic libc_munmap munmap "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func utimensat(dirfd int, path string, times *[2]Timespec, flag int) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_utimensat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), uintptr(flag), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_utimensat_trampoline()
+
+//go:cgo_import_dynamic libc_utimensat utimensat "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func directSyscall(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr) (ret uintptr, err error) {
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_syscall_trampoline), uintptr(trap), uintptr(a1), uintptr(a2), uintptr(a3), uintptr(a4), uintptr(a5))
+	ret = uintptr(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func libc_syscall_trampoline()
+
+//go:cgo_import_dynamic libc_syscall syscall "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
-	r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1260,7 +1672,7 @@ func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
-	r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1270,19 +1682,19 @@ func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func utimensat(dirfd int, path string, times *[2]Timespec, flag int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := Syscall6(SYS_UTIMENSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), uintptr(flag), 0, 0)
+func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
+	r0, r1, e1 := syscall6X(abi.FuncPCABI0(libc_lseek_trampoline), uintptr(fd), 0, uintptr(offset), uintptr(offset>>32), uintptr(whence), 0)
+	newoffset = int64(int64(r1)<<32 | int64(r0))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
+func libc_lseek_trampoline()
+
+//go:cgo_import_dynamic libc_lseek lseek "libc.so"
+
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getcwd(buf []byte) (n int, err error) {
@@ -1292,10 +1704,195 @@ func getcwd(buf []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := Syscall(SYS___GETCWD, uintptr(_p0), uintptr(len(buf)), 0)
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_getcwd_trampoline), uintptr(_p0), uintptr(len(buf)), 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
+
+func libc_getcwd_trampoline()
+
+//go:cgo_import_dynamic libc_getcwd getcwd "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) {
+	var _p0 unsafe.Pointer
+	if len(mib) > 0 {
+		_p0 = unsafe.Pointer(&mib[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_sysctl_trampoline), uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func libc_sysctl_trampoline()
+
+//go:cgo_import_dynamic libc_sysctl sysctl "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func fork() (pid int, err error) {
+	r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_fork_trampoline), 0, 0, 0)
+	pid = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func libc_fork_trampoline()
+
+//go:cgo_import_dynamic libc_fork fork "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func ioctl(fd int, req int, arg int) (err error) {
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func libc_ioctl_trampoline()
+
+//go:cgo_import_dynamic libc_ioctl ioctl "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func execve(path *byte, argv **byte, envp **byte) (err error) {
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_execve_trampoline), uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(argv)), uintptr(unsafe.Pointer(envp)))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func libc_execve_trampoline()
+
+//go:cgo_import_dynamic libc_execve execve "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func exit(res int) (err error) {
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_exit_trampoline), uintptr(res), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func libc_exit_trampoline()
+
+//go:cgo_import_dynamic libc_exit exit "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+//go:nosplit
+func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func libc_ptrace_trampoline()
+
+//go:cgo_import_dynamic libc_ptrace ptrace "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func getentropy(p []byte) (err error) {
+	var _p0 unsafe.Pointer
+	if len(p) > 0 {
+		_p0 = unsafe.Pointer(&p[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	_, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getentropy_trampoline), uintptr(_p0), uintptr(len(p)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func libc_getentropy_trampoline()
+
+//go:cgo_import_dynamic libc_getentropy getentropy "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall6(abi.FuncPCABI0(libc_fstatat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func libc_fstatat_trampoline()
+
+//go:cgo_import_dynamic libc_fstatat fstatat "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func fcntlPtr(fd int, cmd int, arg unsafe.Pointer) (val int, err error) {
+	r0, _, e1 := syscall(abi.FuncPCABI0(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
+	val = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func unlinkat(fd int, path string, flags int) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	_, _, e1 := syscall(abi.FuncPCABI0(libc_unlinkat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func libc_unlinkat_trampoline()
+
+//go:cgo_import_dynamic libc_unlinkat unlinkat "libc.so"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func openat(fd int, path string, flags int, perm uint32) (fdret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := syscall6(abi.FuncPCABI0(libc_openat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(perm), 0, 0)
+	fdret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func libc_openat_trampoline()
+
+//go:cgo_import_dynamic libc_openat openat "libc.so"
diff --git a/src/syscall/zsyscall_openbsd_arm.s b/src/syscall/zsyscall_openbsd_arm.s
new file mode 100644
index 0000000000..d33f3aa3e0
--- /dev/null
+++ b/src/syscall/zsyscall_openbsd_arm.s
@@ -0,0 +1,233 @@
+// go run mkasm.go openbsd arm
+// Code generated by the command above; DO NOT EDIT.
+#include "textflag.h"
+TEXT ·libc_getgroups_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getgroups(SB)
+TEXT ·libc_setgroups_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_setgroups(SB)
+TEXT ·libc_wait4_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_wait4(SB)
+TEXT ·libc_accept_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_accept(SB)
+TEXT ·libc_bind_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_bind(SB)
+TEXT ·libc_connect_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_connect(SB)
+TEXT ·libc_socket_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_socket(SB)
+TEXT ·libc_getsockopt_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getsockopt(SB)
+TEXT ·libc_setsockopt_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_setsockopt(SB)
+TEXT ·libc_getpeername_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getpeername(SB)
+TEXT ·libc_getsockname_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getsockname(SB)
+TEXT ·libc_shutdown_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_shutdown(SB)
+TEXT ·libc_socketpair_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_socketpair(SB)
+TEXT ·libc_recvfrom_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_recvfrom(SB)
+TEXT ·libc_sendto_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_sendto(SB)
+TEXT ·libc_recvmsg_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_recvmsg(SB)
+TEXT ·libc_sendmsg_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_sendmsg(SB)
+TEXT ·libc_kevent_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_kevent(SB)
+TEXT ·libc_utimes_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_utimes(SB)
+TEXT ·libc_futimes_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_futimes(SB)
+TEXT ·libc_fcntl_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_fcntl(SB)
+TEXT ·libc_pipe2_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_pipe2(SB)
+TEXT ·libc_accept4_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_accept4(SB)
+TEXT ·libc_getdents_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getdents(SB)
+TEXT ·libc_access_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_access(SB)
+TEXT ·libc_adjtime_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_adjtime(SB)
+TEXT ·libc_chdir_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_chdir(SB)
+TEXT ·libc_chflags_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_chflags(SB)
+TEXT ·libc_chmod_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_chmod(SB)
+TEXT ·libc_chown_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_chown(SB)
+TEXT ·libc_chroot_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_chroot(SB)
+TEXT ·libc_close_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_close(SB)
+TEXT ·libc_dup_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_dup(SB)
+TEXT ·libc_dup2_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_dup2(SB)
+TEXT ·libc_fchdir_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_fchdir(SB)
+TEXT ·libc_fchflags_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_fchflags(SB)
+TEXT ·libc_fchmod_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_fchmod(SB)
+TEXT ·libc_fchown_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_fchown(SB)
+TEXT ·libc_flock_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_flock(SB)
+TEXT ·libc_fpathconf_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_fpathconf(SB)
+TEXT ·libc_fstat_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_fstat(SB)
+TEXT ·libc_fstatfs_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_fstatfs(SB)
+TEXT ·libc_fsync_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_fsync(SB)
+TEXT ·libc_ftruncate_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_ftruncate(SB)
+TEXT ·libc_getegid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getegid(SB)
+TEXT ·libc_geteuid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_geteuid(SB)
+TEXT ·libc_getgid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getgid(SB)
+TEXT ·libc_getpgid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getpgid(SB)
+TEXT ·libc_getpgrp_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getpgrp(SB)
+TEXT ·libc_getpid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getpid(SB)
+TEXT ·libc_getppid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getppid(SB)
+TEXT ·libc_getpriority_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getpriority(SB)
+TEXT ·libc_getrlimit_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getrlimit(SB)
+TEXT ·libc_getrusage_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getrusage(SB)
+TEXT ·libc_getsid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getsid(SB)
+TEXT ·libc_gettimeofday_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_gettimeofday(SB)
+TEXT ·libc_getuid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getuid(SB)
+TEXT ·libc_issetugid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_issetugid(SB)
+TEXT ·libc_kill_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_kill(SB)
+TEXT ·libc_kqueue_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_kqueue(SB)
+TEXT ·libc_lchown_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_lchown(SB)
+TEXT ·libc_link_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_link(SB)
+TEXT ·libc_listen_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_listen(SB)
+TEXT ·libc_lstat_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_lstat(SB)
+TEXT ·libc_mkdir_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_mkdir(SB)
+TEXT ·libc_mkfifo_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_mkfifo(SB)
+TEXT ·libc_mknod_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_mknod(SB)
+TEXT ·libc_nanosleep_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_nanosleep(SB)
+TEXT ·libc_open_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_open(SB)
+TEXT ·libc_pathconf_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_pathconf(SB)
+TEXT ·libc_pread_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_pread(SB)
+TEXT ·libc_pwrite_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_pwrite(SB)
+TEXT ·libc_read_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_read(SB)
+TEXT ·libc_readlink_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_readlink(SB)
+TEXT ·libc_rename_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_rename(SB)
+TEXT ·libc_revoke_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_revoke(SB)
+TEXT ·libc_rmdir_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_rmdir(SB)
+TEXT ·libc_select_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_select(SB)
+TEXT ·libc_setegid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_setegid(SB)
+TEXT ·libc_seteuid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_seteuid(SB)
+TEXT ·libc_setgid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_setgid(SB)
+TEXT ·libc_setlogin_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_setlogin(SB)
+TEXT ·libc_setpgid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_setpgid(SB)
+TEXT ·libc_setpriority_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_setpriority(SB)
+TEXT ·libc_setregid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_setregid(SB)
+TEXT ·libc_setreuid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_setreuid(SB)
+TEXT ·libc_setrlimit_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_setrlimit(SB)
+TEXT ·libc_setsid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_setsid(SB)
+TEXT ·libc_settimeofday_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_settimeofday(SB)
+TEXT ·libc_setuid_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_setuid(SB)
+TEXT ·libc_stat_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_stat(SB)
+TEXT ·libc_statfs_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_statfs(SB)
+TEXT ·libc_symlink_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_symlink(SB)
+TEXT ·libc_sync_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_sync(SB)
+TEXT ·libc_truncate_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_truncate(SB)
+TEXT ·libc_umask_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_umask(SB)
+TEXT ·libc_unlink_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_unlink(SB)
+TEXT ·libc_unmount_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_unmount(SB)
+TEXT ·libc_write_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_write(SB)
+TEXT ·libc_mmap_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_mmap(SB)
+TEXT ·libc_munmap_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_munmap(SB)
+TEXT ·libc_utimensat_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_utimensat(SB)
+TEXT ·libc_syscall_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_syscall(SB)
+TEXT ·libc_lseek_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_lseek(SB)
+TEXT ·libc_getcwd_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getcwd(SB)
+TEXT ·libc_sysctl_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_sysctl(SB)
+TEXT ·libc_fork_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_fork(SB)
+TEXT ·libc_ioctl_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_ioctl(SB)
+TEXT ·libc_execve_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_execve(SB)
+TEXT ·libc_exit_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_exit(SB)
+TEXT ·libc_ptrace_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_ptrace(SB)
+TEXT ·libc_getentropy_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_getentropy(SB)
+TEXT ·libc_fstatat_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_fstatat(SB)
+TEXT ·libc_unlinkat_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_unlinkat(SB)
+TEXT ·libc_openat_trampoline(SB),NOSPLIT,$0-0
+	JMP	libc_openat(SB)
-- 
GitLab


From c14ecaca8182314efd2ef7280feffc2242644887 Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Wed, 17 Feb 2021 17:12:03 +1100
Subject: [PATCH 2025/2400] runtime: skip TestCrashDumpsAllThreads on
 openbsd/arm

This test is also now flakey on this platform.

Updates #36435
Updates #42464

Change-Id: Idedb81478178ffffe7a9c125a6e8bbd83458f9ab
Reviewed-on: https://go-review.googlesource.com/c/go/+/315794
Trust: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 src/runtime/crash_unix_test.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/runtime/crash_unix_test.go b/src/runtime/crash_unix_test.go
index 9469d5e6a6..694cc3d138 100644
--- a/src/runtime/crash_unix_test.go
+++ b/src/runtime/crash_unix_test.go
@@ -69,7 +69,8 @@ func TestCrashDumpsAllThreads(t *testing.T) {
 		t.Skipf("skipping; not supported on %v", runtime.GOOS)
 	}
 
-	if runtime.GOOS == "openbsd" && runtime.GOARCH == "mips64" {
+	if runtime.GOOS == "openbsd" && (runtime.GOARCH == "arm" || runtime.GOARCH == "mips64") {
+		// This may be ncpu < 2 related...
 		t.Skipf("skipping; test fails on %s/%s - see issue #42464", runtime.GOOS, runtime.GOARCH)
 	}
 
-- 
GitLab


From 287025925f66f90ad9b30aea2e533928026a8376 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Sun, 9 May 2021 11:06:17 -0700
Subject: [PATCH 2026/2400] cmd/compile,reflect: allow longer type names

Encode the length of type names and tags in a varint encoding
instead of a fixed 2-byte encoding. This allows lengths longer
than 65535 (which can happen for large unnamed structs).

Removed the alignment check for #14962, it isn't relevant any more
since we're no longer reading pointers directly out of this data
(it is encoded as an offset which is copied out bytewise).

Fixes #44155
Update #14962

Change-Id: I6084f6027e5955dc16777c87b0dd5ea2baa49629
Reviewed-on: https://go-review.googlesource.com/c/go/+/318249
Trust: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 .../compile/internal/reflectdata/reflect.go   |  29 +++--
 src/cmd/link/internal/ld/decodesym.go         |   5 +-
 src/internal/reflectlite/all_test.go          |  13 --
 src/internal/reflectlite/type.go              |  52 ++++----
 src/reflect/all_test.go                       |  13 --
 src/reflect/type.go                           | 111 +++++++++++-------
 src/runtime/type.go                           |  53 ++++-----
 7 files changed, 143 insertions(+), 133 deletions(-)

diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index 01eaf26a0a..8c0e33f6df 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -5,6 +5,7 @@
 package reflectdata
 
 import (
+	"encoding/binary"
 	"fmt"
 	"internal/buildcfg"
 	"os"
@@ -473,21 +474,25 @@ func dnameField(lsym *obj.LSym, ot int, spkg *types.Pkg, ft *types.Field) int {
 
 // dnameData writes the contents of a reflect.name into s at offset ot.
 func dnameData(s *obj.LSym, ot int, name, tag string, pkg *types.Pkg, exported bool) int {
-	if len(name) > 1<<16-1 {
-		base.Fatalf("name too long: %s", name)
+	if len(name) >= 1<<29 {
+		base.Fatalf("name too long: %d %s...", len(name), name[:1024])
 	}
-	if len(tag) > 1<<16-1 {
-		base.Fatalf("tag too long: %s", tag)
+	if len(tag) >= 1<<29 {
+		base.Fatalf("tag too long: %d %s...", len(tag), tag[:1024])
 	}
+	var nameLen [binary.MaxVarintLen64]byte
+	nameLenLen := binary.PutUvarint(nameLen[:], uint64(len(name)))
+	var tagLen [binary.MaxVarintLen64]byte
+	tagLenLen := binary.PutUvarint(tagLen[:], uint64(len(tag)))
 
 	// Encode name and tag. See reflect/type.go for details.
 	var bits byte
-	l := 1 + 2 + len(name)
+	l := 1 + nameLenLen + len(name)
 	if exported {
 		bits |= 1 << 0
 	}
 	if len(tag) > 0 {
-		l += 2 + len(tag)
+		l += tagLenLen + len(tag)
 		bits |= 1 << 1
 	}
 	if pkg != nil {
@@ -495,14 +500,12 @@ func dnameData(s *obj.LSym, ot int, name, tag string, pkg *types.Pkg, exported b
 	}
 	b := make([]byte, l)
 	b[0] = bits
-	b[1] = uint8(len(name) >> 8)
-	b[2] = uint8(len(name))
-	copy(b[3:], name)
+	copy(b[1:], nameLen[:nameLenLen])
+	copy(b[1+nameLenLen:], name)
 	if len(tag) > 0 {
-		tb := b[3+len(name):]
-		tb[0] = uint8(len(tag) >> 8)
-		tb[1] = uint8(len(tag))
-		copy(tb[2:], tag)
+		tb := b[1+nameLenLen+len(name):]
+		copy(tb, tagLen[:tagLenLen])
+		copy(tb[tagLenLen:], tag)
 	}
 
 	ot = int(s.WriteBytes(base.Ctxt, int64(ot), b))
diff --git a/src/cmd/link/internal/ld/decodesym.go b/src/cmd/link/internal/ld/decodesym.go
index fc179fc6e4..c41d97706e 100644
--- a/src/cmd/link/internal/ld/decodesym.go
+++ b/src/cmd/link/internal/ld/decodesym.go
@@ -10,6 +10,7 @@ import (
 	"cmd/link/internal/loader"
 	"cmd/link/internal/sym"
 	"debug/elf"
+	"encoding/binary"
 	"log"
 )
 
@@ -126,8 +127,8 @@ func decodetypeName(ldr *loader.Loader, symIdx loader.Sym, relocs *loader.Relocs
 	}
 
 	data := ldr.Data(r)
-	namelen := int(uint16(data[1])<<8 | uint16(data[2]))
-	return string(data[3 : 3+namelen])
+	nameLen, nameLenLen := binary.Uvarint(data[1:])
+	return string(data[1+nameLenLen : 1+nameLenLen+int(nameLen)])
 }
 
 func decodetypeFuncInType(ldr *loader.Loader, arch *sys.Arch, symIdx loader.Sym, relocs *loader.Relocs, i int) loader.Sym {
diff --git a/src/internal/reflectlite/all_test.go b/src/internal/reflectlite/all_test.go
index e2c4f30487..e15f364fcd 100644
--- a/src/internal/reflectlite/all_test.go
+++ b/src/internal/reflectlite/all_test.go
@@ -982,19 +982,6 @@ func TestNames(t *testing.T) {
 	}
 }
 
-type embed struct {
-	EmbedWithUnexpMeth
-}
-
-func TestNameBytesAreAligned(t *testing.T) {
-	typ := TypeOf(embed{})
-	b := FirstMethodNameBytes(typ)
-	v := uintptr(unsafe.Pointer(b))
-	if v%unsafe.Alignof((*byte)(nil)) != 0 {
-		t.Errorf("reflect.name.bytes pointer is not aligned: %x", v)
-	}
-}
-
 // TestUnaddressableField tests that the reflect package will not allow
 // a type from another package to be used as a named type with an
 // unexported field.
diff --git a/src/internal/reflectlite/type.go b/src/internal/reflectlite/type.go
index 15ba30da36..f529f7c5fc 100644
--- a/src/internal/reflectlite/type.go
+++ b/src/internal/reflectlite/type.go
@@ -321,49 +321,55 @@ func (n name) isExported() bool {
 	return (*n.bytes)&(1<<0) != 0
 }
 
-func (n name) nameLen() int {
-	return int(uint16(*n.data(1, "name len field"))<<8 | uint16(*n.data(2, "name len field")))
-}
-
-func (n name) tagLen() int {
-	if *n.data(0, "name flag field")&(1<<1) == 0 {
-		return 0
+func (n name) hasTag() bool {
+	return (*n.bytes)&(1<<1) != 0
+}
+
+// readVarint parses a varint as encoded by encoding/binary.
+// It returns the number of encoded bytes and the encoded value.
+func (n name) readVarint(off int) (int, int) {
+	v := 0
+	for i := 0; ; i++ {
+		x := *n.data(off+i, "read varint")
+		v += int(x&0x7f) << (7 * i)
+		if x&0x80 == 0 {
+			return i + 1, v
+		}
 	}
-	off := 3 + n.nameLen()
-	return int(uint16(*n.data(off, "name taglen field"))<<8 | uint16(*n.data(off+1, "name taglen field")))
 }
 
 func (n name) name() (s string) {
 	if n.bytes == nil {
 		return
 	}
-	b := (*[4]byte)(unsafe.Pointer(n.bytes))
-
+	i, l := n.readVarint(1)
 	hdr := (*unsafeheader.String)(unsafe.Pointer(&s))
-	hdr.Data = unsafe.Pointer(&b[3])
-	hdr.Len = int(b[1])<<8 | int(b[2])
-	return s
+	hdr.Data = unsafe.Pointer(n.data(1+i, "non-empty string"))
+	hdr.Len = l
+	return
 }
 
 func (n name) tag() (s string) {
-	tl := n.tagLen()
-	if tl == 0 {
+	if !n.hasTag() {
 		return ""
 	}
-	nl := n.nameLen()
+	i, l := n.readVarint(1)
+	i2, l2 := n.readVarint(1 + i + l)
 	hdr := (*unsafeheader.String)(unsafe.Pointer(&s))
-	hdr.Data = unsafe.Pointer(n.data(3+nl+2, "non-empty string"))
-	hdr.Len = tl
-	return s
+	hdr.Data = unsafe.Pointer(n.data(1+i+l+i2, "non-empty string"))
+	hdr.Len = l2
+	return
 }
 
 func (n name) pkgPath() string {
 	if n.bytes == nil || *n.data(0, "name flag field")&(1<<2) == 0 {
 		return ""
 	}
-	off := 3 + n.nameLen()
-	if tl := n.tagLen(); tl > 0 {
-		off += 2 + tl
+	i, l := n.readVarint(1)
+	off := 1 + i + l
+	if n.hasTag() {
+		i2, l2 := n.readVarint(off)
+		off += i2 + l2
 	}
 	var nameOff int32
 	// Note that this field may not be aligned in memory,
diff --git a/src/reflect/all_test.go b/src/reflect/all_test.go
index 065ff04611..17104ad4fa 100644
--- a/src/reflect/all_test.go
+++ b/src/reflect/all_test.go
@@ -6942,19 +6942,6 @@ func TestExported(t *testing.T) {
 	}
 }
 
-type embed struct {
-	EmbedWithUnexpMeth
-}
-
-func TestNameBytesAreAligned(t *testing.T) {
-	typ := TypeOf(embed{})
-	b := FirstMethodNameBytes(typ)
-	v := uintptr(unsafe.Pointer(b))
-	if v%unsafe.Alignof((*byte)(nil)) != 0 {
-		t.Errorf("reflect.name.bytes pointer is not aligned: %x", v)
-	}
-}
-
 func TestTypeStrings(t *testing.T) {
 	type stringTest struct {
 		typ  Type
diff --git a/src/reflect/type.go b/src/reflect/type.go
index 9727bfe467..39414fc2a6 100644
--- a/src/reflect/type.go
+++ b/src/reflect/type.go
@@ -450,14 +450,11 @@ type structType struct {
 //	1<<1 tag data follows the name
 //	1<<2 pkgPath nameOff follows the name and tag
 //
-// The next two bytes are the data length:
+// Following that, there is a varint-encoded length of the name,
+// followed by the name itself.
 //
-//	 l := uint16(data[1])<<8 | uint16(data[2])
-//
-// Bytes [3:3+l] are the string data.
-//
-// If tag data follows then bytes 3+l and 3+l+1 are the tag length,
-// with the data following.
+// If tag data is present, it also has a varint-encoded length
+// followed by the tag itself.
 //
 // If the import path follows, then 4 bytes at the end of
 // the data form a nameOff. The import path is only set for concrete
@@ -465,6 +462,13 @@ type structType struct {
 //
 // If a name starts with "*", then the exported bit represents
 // whether the pointed to type is exported.
+//
+// Note: this encoding must match here and in:
+//   cmd/compile/internal/reflectdata/reflect.go
+//   runtime/type.go
+//   internal/reflectlite/type.go
+//   cmd/link/internal/ld/decodesym.go
+
 type name struct {
 	bytes *byte
 }
@@ -477,49 +481,70 @@ func (n name) isExported() bool {
 	return (*n.bytes)&(1<<0) != 0
 }
 
-func (n name) nameLen() int {
-	return int(uint16(*n.data(1, "name len field"))<<8 | uint16(*n.data(2, "name len field")))
+func (n name) hasTag() bool {
+	return (*n.bytes)&(1<<1) != 0
+}
+
+// readVarint parses a varint as encoded by encoding/binary.
+// It returns the number of encoded bytes and the encoded value.
+func (n name) readVarint(off int) (int, int) {
+	v := 0
+	for i := 0; ; i++ {
+		x := *n.data(off+i, "read varint")
+		v += int(x&0x7f) << (7 * i)
+		if x&0x80 == 0 {
+			return i + 1, v
+		}
+	}
 }
 
-func (n name) tagLen() int {
-	if *n.data(0, "name flag field")&(1<<1) == 0 {
-		return 0
+// writeVarint writes n to buf in varint form. Returns the
+// number of bytes written. n must be nonnegative.
+// Writes at most 10 bytes.
+func writeVarint(buf []byte, n int) int {
+	for i := 0; ; i++ {
+		b := byte(n & 0x7f)
+		n >>= 7
+		if n == 0 {
+			buf[i] = b
+			return i + 1
+		}
+		buf[i] = b | 0x80
 	}
-	off := 3 + n.nameLen()
-	return int(uint16(*n.data(off, "name taglen field"))<<8 | uint16(*n.data(off+1, "name taglen field")))
 }
 
 func (n name) name() (s string) {
 	if n.bytes == nil {
 		return
 	}
-	b := (*[4]byte)(unsafe.Pointer(n.bytes))
-
+	i, l := n.readVarint(1)
 	hdr := (*unsafeheader.String)(unsafe.Pointer(&s))
-	hdr.Data = unsafe.Pointer(&b[3])
-	hdr.Len = int(b[1])<<8 | int(b[2])
-	return s
+	hdr.Data = unsafe.Pointer(n.data(1+i, "non-empty string"))
+	hdr.Len = l
+	return
 }
 
 func (n name) tag() (s string) {
-	tl := n.tagLen()
-	if tl == 0 {
+	if !n.hasTag() {
 		return ""
 	}
-	nl := n.nameLen()
+	i, l := n.readVarint(1)
+	i2, l2 := n.readVarint(1 + i + l)
 	hdr := (*unsafeheader.String)(unsafe.Pointer(&s))
-	hdr.Data = unsafe.Pointer(n.data(3+nl+2, "non-empty string"))
-	hdr.Len = tl
-	return s
+	hdr.Data = unsafe.Pointer(n.data(1+i+l+i2, "non-empty string"))
+	hdr.Len = l2
+	return
 }
 
 func (n name) pkgPath() string {
 	if n.bytes == nil || *n.data(0, "name flag field")&(1<<2) == 0 {
 		return ""
 	}
-	off := 3 + n.nameLen()
-	if tl := n.tagLen(); tl > 0 {
-		off += 2 + tl
+	i, l := n.readVarint(1)
+	off := 1 + i + l
+	if n.hasTag() {
+		i2, l2 := n.readVarint(off)
+		off += i2 + l2
 	}
 	var nameOff int32
 	// Note that this field may not be aligned in memory,
@@ -530,33 +555,35 @@ func (n name) pkgPath() string {
 }
 
 func newName(n, tag string, exported bool) name {
-	if len(n) > 1<<16-1 {
-		panic("reflect.nameFrom: name too long: " + n)
+	if len(n) >= 1<<29 {
+		panic("reflect.nameFrom: name too long: " + n[:1024] + "...")
 	}
-	if len(tag) > 1<<16-1 {
-		panic("reflect.nameFrom: tag too long: " + tag)
+	if len(tag) >= 1<<29 {
+		panic("reflect.nameFrom: tag too long: " + tag[:1024] + "...")
 	}
+	var nameLen [10]byte
+	var tagLen [10]byte
+	nameLenLen := writeVarint(nameLen[:], len(n))
+	tagLenLen := writeVarint(tagLen[:], len(tag))
 
 	var bits byte
-	l := 1 + 2 + len(n)
+	l := 1 + nameLenLen + len(n)
 	if exported {
 		bits |= 1 << 0
 	}
 	if len(tag) > 0 {
-		l += 2 + len(tag)
+		l += tagLenLen + len(tag)
 		bits |= 1 << 1
 	}
 
 	b := make([]byte, l)
 	b[0] = bits
-	b[1] = uint8(len(n) >> 8)
-	b[2] = uint8(len(n))
-	copy(b[3:], n)
+	copy(b[1:], nameLen[:nameLenLen])
+	copy(b[1+nameLenLen:], n)
 	if len(tag) > 0 {
-		tb := b[3+len(n):]
-		tb[0] = uint8(len(tag) >> 8)
-		tb[1] = uint8(len(tag))
-		copy(tb[2:], tag)
+		tb := b[1+nameLenLen+len(n):]
+		copy(tb, tagLen[:tagLenLen])
+		copy(tb[tagLenLen:], tag)
 	}
 
 	return name{bytes: &b[0]}
@@ -2570,7 +2597,7 @@ func StructOf(fields []StructField) Type {
 		hash = fnv1(hash, byte(ft.hash>>24), byte(ft.hash>>16), byte(ft.hash>>8), byte(ft.hash))
 
 		repr = append(repr, (" " + ft.String())...)
-		if f.name.tagLen() > 0 {
+		if f.name.hasTag() {
 			hash = fnv1(hash, []byte(f.name.tag())...)
 			repr = append(repr, (" " + strconv.Quote(f.name.tag()))...)
 		}
diff --git a/src/runtime/type.go b/src/runtime/type.go
index c0911b1dcb..335fc57f4b 100644
--- a/src/runtime/type.go
+++ b/src/runtime/type.go
@@ -459,51 +459,52 @@ func (n name) isExported() bool {
 	return (*n.bytes)&(1<<0) != 0
 }
 
-func (n name) nameLen() int {
-	return int(uint16(*n.data(1))<<8 | uint16(*n.data(2)))
-}
-
-func (n name) tagLen() int {
-	if *n.data(0)&(1<<1) == 0 {
-		return 0
+func (n name) readvarint(off int) (int, int) {
+	v := 0
+	for i := 0; ; i++ {
+		x := *n.data(off + i)
+		v += int(x&0x7f) << (7 * i)
+		if x&0x80 == 0 {
+			return i + 1, v
+		}
 	}
-	off := 3 + n.nameLen()
-	return int(uint16(*n.data(off))<<8 | uint16(*n.data(off + 1)))
 }
 
 func (n name) name() (s string) {
 	if n.bytes == nil {
 		return ""
 	}
-	nl := n.nameLen()
-	if nl == 0 {
+	i, l := n.readvarint(1)
+	if l == 0 {
 		return ""
 	}
 	hdr := (*stringStruct)(unsafe.Pointer(&s))
-	hdr.str = unsafe.Pointer(n.data(3))
-	hdr.len = nl
-	return s
+	hdr.str = unsafe.Pointer(n.data(1 + i))
+	hdr.len = l
+	return
 }
 
 func (n name) tag() (s string) {
-	tl := n.tagLen()
-	if tl == 0 {
+	if *n.data(0)&(1<<1) == 0 {
 		return ""
 	}
-	nl := n.nameLen()
+	i, l := n.readvarint(1)
+	i2, l2 := n.readvarint(1 + i + l)
 	hdr := (*stringStruct)(unsafe.Pointer(&s))
-	hdr.str = unsafe.Pointer(n.data(3 + nl + 2))
-	hdr.len = tl
-	return s
+	hdr.str = unsafe.Pointer(n.data(1 + i + l + i2))
+	hdr.len = l2
+	return
 }
 
 func (n name) pkgPath() string {
 	if n.bytes == nil || *n.data(0)&(1<<2) == 0 {
 		return ""
 	}
-	off := 3 + n.nameLen()
-	if tl := n.tagLen(); tl > 0 {
-		off += 2 + tl
+	i, l := n.readvarint(1)
+	off := 1 + i + l
+	if *n.data(0)&(1<<1) != 0 {
+		i2, l2 := n.readvarint(off)
+		off += i2 + l2
 	}
 	var nameOff nameOff
 	copy((*[4]byte)(unsafe.Pointer(&nameOff))[:], (*[4]byte)(unsafe.Pointer(n.data(off)))[:])
@@ -515,10 +516,8 @@ func (n name) isBlank() bool {
 	if n.bytes == nil {
 		return false
 	}
-	if n.nameLen() != 1 {
-		return false
-	}
-	return *n.data(3) == '_'
+	_, l := n.readvarint(1)
+	return l == 1 && *n.data(2) == '_'
 }
 
 // typelinksinit scans the types from extra modules and builds the
-- 
GitLab


From e18a8b4fb27df3ee04f7eb00c4f1ed77e5486ce8 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Wed, 5 May 2021 17:05:51 -0400
Subject: [PATCH 2027/2400] go/build: avoid duplicates in InvalidGoFiles

For #45827
For #39986
Updates #45999

Change-Id: I0c919b6a2e56e7003b90425487eafe0f0eadc609
Reviewed-on: https://go-review.googlesource.com/c/go/+/317299
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/go/build/build.go      | 36 +++++++++++++++++++++---------------
 src/go/build/build_test.go | 18 ++++++++++++++++--
 2 files changed, 37 insertions(+), 17 deletions(-)

diff --git a/src/go/build/build.go b/src/go/build/build.go
index 8d1a107c6e..b85fa96de1 100644
--- a/src/go/build/build.go
+++ b/src/go/build/build.go
@@ -810,6 +810,17 @@ Found:
 	}
 
 	var badGoError error
+	badFiles := make(map[string]bool)
+	badFile := func(name string, err error) {
+		if badGoError == nil {
+			badGoError = err
+		}
+		if !badFiles[name] {
+			p.InvalidGoFiles = append(p.InvalidGoFiles, name)
+			badFiles[name] = true
+		}
+	}
+
 	var Sfiles []string // files with ".S"(capital S)/.sx(capital s equivalent for case insensitive filesystems)
 	var firstFile, firstCommentFile string
 	embedPos := make(map[string][]token.Position)
@@ -834,16 +845,9 @@ Found:
 		name := d.Name()
 		ext := nameExt(name)
 
-		badFile := func(err error) {
-			if badGoError == nil {
-				badGoError = err
-			}
-			p.InvalidGoFiles = append(p.InvalidGoFiles, name)
-		}
-
 		info, err := ctxt.matchFile(p.Dir, name, allTags, &p.BinaryOnly, fset)
 		if err != nil {
-			badFile(err)
+			badFile(name, err)
 			continue
 		}
 		if info == nil {
@@ -874,7 +878,7 @@ Found:
 		}
 
 		if info.parseErr != nil {
-			badFile(info.parseErr)
+			badFile(name, info.parseErr)
 			continue
 		}
 		pf := info.parsed
@@ -896,12 +900,14 @@ Found:
 			p.Name = pkg
 			firstFile = name
 		} else if pkg != p.Name {
-			badFile(&MultiplePackageError{
+			// TODO(#45999): The choice of p.Name is arbitrary based on file iteration
+			// order. Instead of resolving p.Name arbitrarily, we should clear out the
+			// existing name and mark the existing files as also invalid.
+			badFile(name, &MultiplePackageError{
 				Dir:      p.Dir,
 				Packages: []string{p.Name, pkg},
 				Files:    []string{firstFile, name},
 			})
-			p.InvalidGoFiles = append(p.InvalidGoFiles, name)
 		}
 		// Grab the first package comment as docs, provided it is not from a test file.
 		if pf.Doc != nil && p.Doc == "" && !isTest && !isXTest {
@@ -913,12 +919,12 @@ Found:
 			if line != 0 {
 				com, err := strconv.Unquote(qcom)
 				if err != nil {
-					badFile(fmt.Errorf("%s:%d: cannot parse import comment", filename, line))
+					badFile(name, fmt.Errorf("%s:%d: cannot parse import comment", filename, line))
 				} else if p.ImportComment == "" {
 					p.ImportComment = com
 					firstCommentFile = name
 				} else if p.ImportComment != com {
-					badFile(fmt.Errorf("found import comments %q (%s) and %q (%s) in %s", p.ImportComment, firstCommentFile, com, name, p.Dir))
+					badFile(name, fmt.Errorf("found import comments %q (%s) and %q (%s) in %s", p.ImportComment, firstCommentFile, com, name, p.Dir))
 				}
 			}
 		}
@@ -928,13 +934,13 @@ Found:
 		for _, imp := range info.imports {
 			if imp.path == "C" {
 				if isTest {
-					badFile(fmt.Errorf("use of cgo in test %s not supported", filename))
+					badFile(name, fmt.Errorf("use of cgo in test %s not supported", filename))
 					continue
 				}
 				isCgo = true
 				if imp.doc != nil {
 					if err := ctxt.saveCgo(filename, p, imp.doc); err != nil {
-						badFile(err)
+						badFile(name, err)
 					}
 				}
 			}
diff --git a/src/go/build/build_test.go b/src/go/build/build_test.go
index 7e78568083..80f930f3c2 100644
--- a/src/go/build/build_test.go
+++ b/src/go/build/build_test.go
@@ -104,7 +104,8 @@ func TestEmptyFolderImport(t *testing.T) {
 }
 
 func TestMultiplePackageImport(t *testing.T) {
-	_, err := Import(".", "testdata/multi", 0)
+	pkg, err := Import(".", "testdata/multi", 0)
+
 	mpe, ok := err.(*MultiplePackageError)
 	if !ok {
 		t.Fatal(`Import("testdata/multi") did not return MultiplePackageError.`)
@@ -115,7 +116,20 @@ func TestMultiplePackageImport(t *testing.T) {
 		Files:    []string{"file.go", "file_appengine.go"},
 	}
 	if !reflect.DeepEqual(mpe, want) {
-		t.Errorf("got %#v; want %#v", mpe, want)
+		t.Errorf("err = %#v; want %#v", mpe, want)
+	}
+
+	// TODO(#45999): Since the name is ambiguous, pkg.Name should be left empty.
+	if wantName := "main"; pkg.Name != wantName {
+		t.Errorf("pkg.Name = %q; want %q", pkg.Name, wantName)
+	}
+
+	if wantGoFiles := []string{"file.go", "file_appengine.go"}; !reflect.DeepEqual(pkg.GoFiles, wantGoFiles) {
+		t.Errorf("pkg.GoFiles = %q; want %q", pkg.GoFiles, wantGoFiles)
+	}
+
+	if wantInvalidFiles := []string{"file_appengine.go"}; !reflect.DeepEqual(pkg.InvalidGoFiles, wantInvalidFiles) {
+		t.Errorf("pkg.InvalidGoFiles = %q; want %q", pkg.InvalidGoFiles, wantInvalidFiles)
 	}
 }
 
-- 
GitLab


From a9edda3788b7ff6a73686874c9b3dcb1e5e18b87 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Mon, 3 May 2021 17:03:01 -0400
Subject: [PATCH 2028/2400] cmd/go: add a test that reproduces #45827

For #45827

Change-Id: I4d3268d66fb0927161f44b353faef11aa4551e40
Reviewed-on: https://go-review.googlesource.com/c/go/+/317298
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 .../go/testdata/script/mod_run_pkgerror.txt    | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 src/cmd/go/testdata/script/mod_run_pkgerror.txt

diff --git a/src/cmd/go/testdata/script/mod_run_pkgerror.txt b/src/cmd/go/testdata/script/mod_run_pkgerror.txt
new file mode 100644
index 0000000000..fd7060aaa8
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_run_pkgerror.txt
@@ -0,0 +1,18 @@
+# https://golang.org/issue/45827: 'go run .' should report the same package
+# errors as 'go build'.
+
+! go build
+stderr '^found packages m \(m\.go\) and main \(main\.go\) in '$PWD'$'
+
+! go run .
+	# TODO(#45827): This error should match the above.
+stderr '^go run: no packages loaded from \.$'
+
+-- go.mod --
+module m
+
+go 1.17
+-- m.go --
+package m
+-- main.go --
+package main
-- 
GitLab


From 031854117f91fbc1265840a04caf2a7a168dd06b Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Wed, 5 May 2021 17:08:39 -0400
Subject: [PATCH 2029/2400] cmd/go: include packages with InvalidGoFiles when
 filtering main packages

If a package has files with conflicting package names, go/build
empirically populates the first name encountered and puts the
remaining files in InvalidGoFiles. That foiled our check for packages
whose name is either unpopulated or "main", since the "package main"
could be found in a source file after the first.

Instead, we now treat any package with a nonzero set of InvalidGoFiles
as potentially a main package. This biases toward over-reporting
errors, but we would rather over-report than under-report.

If we fix #45999, we will be able to make these error checks more
precise.

Updates #42088
Fixes #45827
Fixes #39986

Change-Id: I588314341b17961b38660192c2130678dc03023e
Reviewed-on: https://go-review.googlesource.com/c/go/+/317300
Trust: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/load/pkg.go               | 76 +++++++++++--------
 .../script/mod_install_pkg_version.txt        |  2 +-
 .../go/testdata/script/mod_run_nonmain.txt    | 18 +++++
 .../go/testdata/script/mod_run_pkgerror.txt   | 20 ++++-
 4 files changed, 82 insertions(+), 34 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/mod_run_nonmain.txt

diff --git a/src/cmd/go/internal/load/pkg.go b/src/cmd/go/internal/load/pkg.go
index 153399d83e..3c7cd44ee3 100644
--- a/src/cmd/go/internal/load/pkg.go
+++ b/src/cmd/go/internal/load/pkg.go
@@ -87,6 +87,7 @@ type PackagePublic struct {
 	CgoFiles          []string `json:",omitempty"` // .go source files that import "C"
 	CompiledGoFiles   []string `json:",omitempty"` // .go output from running cgo on CgoFiles
 	IgnoredGoFiles    []string `json:",omitempty"` // .go source files ignored due to build constraints
+	InvalidGoFiles    []string `json:",omitempty"` // .go source files with detected problems (parse error, wrong package name, and so on)
 	IgnoredOtherFiles []string `json:",omitempty"` // non-.go source files ignored due to build constraints
 	CFiles            []string `json:",omitempty"` // .c source files
 	CXXFiles          []string `json:",omitempty"` // .cc, .cpp and .cxx source files
@@ -144,6 +145,7 @@ func (p *Package) AllFiles() []string {
 		p.CgoFiles,
 		// no p.CompiledGoFiles, because they are from GoFiles or generated by us
 		p.IgnoredGoFiles,
+		// no p.InvalidGoFiles, because they are from GoFiles
 		p.IgnoredOtherFiles,
 		p.CFiles,
 		p.CXXFiles,
@@ -371,6 +373,7 @@ func (p *Package) copyBuild(opts PackageOpts, pp *build.Package) {
 	p.GoFiles = pp.GoFiles
 	p.CgoFiles = pp.CgoFiles
 	p.IgnoredGoFiles = pp.IgnoredGoFiles
+	p.InvalidGoFiles = pp.InvalidGoFiles
 	p.IgnoredOtherFiles = pp.IgnoredOtherFiles
 	p.CFiles = pp.CFiles
 	p.CXXFiles = pp.CXXFiles
@@ -2493,7 +2496,7 @@ func PackagesAndErrors(ctx context.Context, opts PackageOpts, patterns []string)
 	}
 
 	if opts.MainOnly {
-		pkgs = mainPackagesOnly(pkgs, patterns)
+		pkgs = mainPackagesOnly(pkgs, matches)
 	}
 
 	// Now that CmdlinePkg is set correctly,
@@ -2547,50 +2550,63 @@ func CheckPackageErrors(pkgs []*Package) {
 // mainPackagesOnly filters out non-main packages matched only by arguments
 // containing "..." and returns the remaining main packages.
 //
+// Packages with missing, invalid, or ambiguous names may be treated as
+// possibly-main packages.
+//
 // mainPackagesOnly sets a non-main package's Error field and returns it if it
 // is named by a literal argument.
 //
 // mainPackagesOnly prints warnings for non-literal arguments that only match
 // non-main packages.
-func mainPackagesOnly(pkgs []*Package, patterns []string) []*Package {
-	matchers := make([]func(string) bool, len(patterns))
-	for i, p := range patterns {
-		if strings.Contains(p, "...") {
-			matchers[i] = search.MatchPattern(p)
+func mainPackagesOnly(pkgs []*Package, matches []*search.Match) []*Package {
+	treatAsMain := map[string]bool{}
+	for _, m := range matches {
+		if m.IsLiteral() {
+			for _, path := range m.Pkgs {
+				treatAsMain[path] = true
+			}
 		}
 	}
 
-	matchedPkgs := make([]*Package, 0, len(pkgs))
-	mainCount := make([]int, len(patterns))
-	nonMainCount := make([]int, len(patterns))
+	var mains []*Package
 	for _, pkg := range pkgs {
-		if pkg.Name == "main" || (pkg.Incomplete && pkg.Name == "") {
-			matchedPkgs = append(matchedPkgs, pkg)
-			for i := range patterns {
-				if matchers[i] != nil && matchers[i](pkg.ImportPath) {
-					mainCount[i]++
-				}
-			}
-		} else {
-			for i := range patterns {
-				if matchers[i] == nil && patterns[i] == pkg.ImportPath {
-					if pkg.Error == nil {
-						pkg.Error = &PackageError{Err: &mainPackageError{importPath: pkg.ImportPath}}
-					}
-					matchedPkgs = append(matchedPkgs, pkg)
-				} else if matchers[i] != nil && matchers[i](pkg.ImportPath) {
-					nonMainCount[i]++
-				}
+		if pkg.Name == "main" {
+			treatAsMain[pkg.ImportPath] = true
+			mains = append(mains, pkg)
+			continue
+		}
+
+		if len(pkg.InvalidGoFiles) > 0 { // TODO(#45999): && pkg.Name == "", but currently go/build sets pkg.Name arbitrarily if it is ambiguous.
+			// The package has (or may have) conflicting names, and we can't easily
+			// tell whether one of them is "main". So assume that it could be, and
+			// report an error for the package.
+			treatAsMain[pkg.ImportPath] = true
+		}
+		if treatAsMain[pkg.ImportPath] {
+			if pkg.Error == nil {
+				pkg.Error = &PackageError{Err: &mainPackageError{importPath: pkg.ImportPath}}
 			}
+			mains = append(mains, pkg)
 		}
 	}
-	for i, p := range patterns {
-		if matchers[i] != nil && mainCount[i] == 0 && nonMainCount[i] > 0 {
-			fmt.Fprintf(os.Stderr, "go: warning: %q matched no main packages\n", p)
+
+	for _, m := range matches {
+		if m.IsLiteral() || len(m.Pkgs) == 0 {
+			continue
+		}
+		foundMain := false
+		for _, path := range m.Pkgs {
+			if treatAsMain[path] {
+				foundMain = true
+				break
+			}
+		}
+		if !foundMain {
+			fmt.Fprintf(os.Stderr, "go: warning: %q matched only non-main packages\n", m.Pattern())
 		}
 	}
 
-	return matchedPkgs
+	return mains
 }
 
 type mainPackageError struct {
diff --git a/src/cmd/go/testdata/script/mod_install_pkg_version.txt b/src/cmd/go/testdata/script/mod_install_pkg_version.txt
index 2c14ef737b..fd02392af1 100644
--- a/src/cmd/go/testdata/script/mod_install_pkg_version.txt
+++ b/src/cmd/go/testdata/script/mod_install_pkg_version.txt
@@ -143,7 +143,7 @@ stderr '^go: warning: "example.com/cmd/nomatch\.\.\." matched no packages$'
 
 # If a wildcard matches only non-main packges, we should see a different warning.
 go install example.com/cmd/err...@v1.0.0
-stderr '^go: warning: "example.com/cmd/err\.\.\." matched no main packages$'
+stderr '^go: warning: "example.com/cmd/err\.\.\." matched only non-main packages$'
 
 
 # 'go install pkg@version' should report errors if the module contains
diff --git a/src/cmd/go/testdata/script/mod_run_nonmain.txt b/src/cmd/go/testdata/script/mod_run_nonmain.txt
new file mode 100644
index 0000000000..036755d2d1
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_run_nonmain.txt
@@ -0,0 +1,18 @@
+! go run $PWD
+! stderr 'no packages loaded'
+stderr '^package example.net/nonmain is not a main package$'
+
+! go run .
+stderr '^package example.net/nonmain is not a main package$'
+
+! go run ./...
+stderr '^go: warning: "\./\.\.\." matched only non-main packages$'
+stderr '^go run: no packages loaded from \./\.\.\.$'
+
+-- go.mod --
+module example.net/nonmain
+
+go 1.17
+-- nonmain.go --
+// Package nonmain is not a main package.
+package nonmain
diff --git a/src/cmd/go/testdata/script/mod_run_pkgerror.txt b/src/cmd/go/testdata/script/mod_run_pkgerror.txt
index fd7060aaa8..48f900dd34 100644
--- a/src/cmd/go/testdata/script/mod_run_pkgerror.txt
+++ b/src/cmd/go/testdata/script/mod_run_pkgerror.txt
@@ -1,12 +1,26 @@
+# https://golang.org/issue/39986: files reported as invalid by go/build should
+# be listed in InvalidGoFiles.
+
+go list -e -f '{{.Incomplete}}{{"\n"}}{{.Error}}{{"\n"}}{{.InvalidGoFiles}}{{"\n"}}' .
+stdout '^true\nfound packages m \(m\.go\) and main \(main\.go\) in '$PWD'\n\[main.go\]\n'
+
+
 # https://golang.org/issue/45827: 'go run .' should report the same package
-# errors as 'go build'.
+# errors as 'go build' and 'go list'.
 
 ! go build
 stderr '^found packages m \(m\.go\) and main \(main\.go\) in '$PWD'$'
 
+! go list .
+stderr '^found packages m \(m\.go\) and main \(main\.go\) in '$PWD'$'
+
 ! go run .
-	# TODO(#45827): This error should match the above.
-stderr '^go run: no packages loaded from \.$'
+! stderr 'no packages loaded'
+stderr '^found packages m \(m\.go\) and main \(main\.go\) in '$PWD'$'
+
+! go run ./...
+! stderr 'no packages loaded'
+stderr '^found packages m \(m\.go\) and main \(main\.go\) in '$PWD'$'
 
 -- go.mod --
 module m
-- 
GitLab


From 82517acae866d60a9754d44d004bfa159e656c07 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Mon, 10 May 2021 14:52:22 +0200
Subject: [PATCH 2030/2400] net, runtime: drop macOS 10.12 skip conditions in
 tests

Go 1.17 requires macOS 10.13 or later. Thus, drop the special cases for
the darwin-amd64-10_12 builder added in CL 202618.

Updates #22019
Updates #23011
Updates #32919

Change-Id: Idef11c213dfb25fd002b7cda6d425cf2e26a2e06
Reviewed-on: https://go-review.googlesource.com/c/go/+/318329
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/net/dial_test.go      | 10 +---------
 src/net/server_test.go    |  7 -------
 src/runtime/crash_test.go |  8 --------
 3 files changed, 1 insertion(+), 24 deletions(-)

diff --git a/src/net/dial_test.go b/src/net/dial_test.go
index 394bdb047e..f899da10cf 100644
--- a/src/net/dial_test.go
+++ b/src/net/dial_test.go
@@ -656,15 +656,7 @@ func TestDialerLocalAddr(t *testing.T) {
 		}
 		c, err := d.Dial(tt.network, addr)
 		if err == nil && tt.error != nil || err != nil && tt.error == nil {
-			// A suspected kernel bug in macOS 10.12 occasionally results in
-			// timeout errors when dialing address ::1. The errors have not
-			// been observed on newer versions of the OS, so we don't plan to work
-			// around them. See https://golang.org/issue/22019.
-			if tt.raddr == "::1" && os.Getenv("GO_BUILDER_NAME") == "darwin-amd64-10_12" && os.IsTimeout(err) {
-				t.Logf("ignoring timeout error on Darwin; see https://golang.org/issue/22019")
-			} else {
-				t.Errorf("%s %v->%s: got %v; want %v", tt.network, tt.laddr, tt.raddr, err, tt.error)
-			}
+			t.Errorf("%s %v->%s: got %v; want %v", tt.network, tt.laddr, tt.raddr, err, tt.error)
 		}
 		if err != nil {
 			if perr := parseDialError(err); perr != nil {
diff --git a/src/net/server_test.go b/src/net/server_test.go
index 8d4db7233d..7cbf152298 100644
--- a/src/net/server_test.go
+++ b/src/net/server_test.go
@@ -105,13 +105,6 @@ func TestTCPServer(t *testing.T) {
 					if perr := parseDialError(err); perr != nil {
 						t.Error(perr)
 					}
-					if tt.taddr == "::1" && os.Getenv("GO_BUILDER_NAME") == "darwin-amd64-10_12" && os.IsTimeout(err) {
-						// A suspected kernel bug in macOS 10.12 occasionally results in
-						// "i/o timeout" errors when dialing address ::1. The errors have not
-						// been observed on newer versions of the OS, so we don't plan to work
-						// around them. See https://golang.org/issue/32919.
-						t.Skipf("skipping due to error on known-flaky macOS 10.12 builder: %v", err)
-					}
 					t.Fatal(err)
 				}
 				defer c.Close()
diff --git a/src/runtime/crash_test.go b/src/runtime/crash_test.go
index e5bd7973b7..e0c0bac892 100644
--- a/src/runtime/crash_test.go
+++ b/src/runtime/crash_test.go
@@ -470,14 +470,6 @@ func TestRecoverBeforePanicAfterGoexit2(t *testing.T) {
 }
 
 func TestNetpollDeadlock(t *testing.T) {
-	if os.Getenv("GO_BUILDER_NAME") == "darwin-amd64-10_12" {
-		// A suspected kernel bug in macOS 10.12 occasionally results in
-		// an apparent deadlock when dialing localhost. The errors have not
-		// been observed on newer versions of the OS, so we don't plan to work
-		// around them. See https://golang.org/issue/22019.
-		testenv.SkipFlaky(t, 22019)
-	}
-
 	t.Parallel()
 	output := runTestProg(t, "testprognet", "NetpollDeadlock")
 	want := "done\n"
-- 
GitLab


From deb3403ff52b8833df6c4e2f82cbdddeb13573dd Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Wed, 8 Jul 2020 16:20:51 -0400
Subject: [PATCH 2031/2400] go/build: include files with parse errors in
 GoFiles and other lists

go/build.ImportDir returns a *build.Package with various lists of
files. If a file is invalid for some reason, for example, because it
has a different package name than other files, it's added to
InvalidGoFiles in addition to GoFiles, TestGoFiles, or other lists.

Previously, files with parse errors or build constraint errors were
not included in these lists, which causes problems for tools that use
'go list' since InvalidGoFiles is not printed. With this change, files
with any kind of error are added to one of the GoFiles lists.

Fixes #39986

Change-Id: Iee007b5092293eb4420c8a39ce731805fe32135f
Reviewed-on: https://go-review.googlesource.com/c/go/+/241577
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go/testdata/script/list_load_err.txt | 26 ++++++++++++++++----
 src/go/build/build.go                        | 19 ++++++++------
 2 files changed, 32 insertions(+), 13 deletions(-)

diff --git a/src/cmd/go/testdata/script/list_load_err.txt b/src/cmd/go/testdata/script/list_load_err.txt
index b3b72713e5..0cfa7fbed2 100644
--- a/src/cmd/go/testdata/script/list_load_err.txt
+++ b/src/cmd/go/testdata/script/list_load_err.txt
@@ -2,26 +2,42 @@
 # other files in the same package cause go/build.Import to return an error.
 # Verfifies golang.org/issue/38568
 
-
 go list -e -deps ./scan
 stdout m/want
 
-
 go list -e -deps ./multi
 stdout m/want
 
-
 go list -e -deps ./constraint
 stdout m/want
 
-
 [cgo] go list -e -test -deps ./cgotest
 [cgo] stdout m/want
 
-
 [cgo] go list -e -deps ./cgoflag
 [cgo] stdout m/want
 
+
+# go list -e should include files with errors in GoFiles, TestGoFiles, and
+# other lists, assuming they match constraints.
+# Verifies golang.org/issue/39986
+go list -e -f '{{range .GoFiles}}{{.}},{{end}}' ./scan
+stdout '^good.go,scan.go,$'
+
+go list -e -f '{{range .GoFiles}}{{.}},{{end}}' ./multi
+stdout '^a.go,b.go,$'
+
+go list -e -f '{{range .GoFiles}}{{.}},{{end}}' ./constraint
+stdout '^good.go,$'
+go list -e -f '{{range .IgnoredGoFiles}}{{.}},{{end}}' ./constraint
+stdout '^constraint.go,$'
+
+[cgo] go list -e -f '{{range .XTestGoFiles}}{{.}},{{end}}' ./cgotest
+[cgo] stdout '^cgo_test.go,$'
+
+[cgo] go list -e -f '{{range .GoFiles}}{{.}},{{end}}' ./cgoflag
+[cgo] stdout '^cgoflag.go,$'
+
 -- go.mod --
 module m
 
diff --git a/src/go/build/build.go b/src/go/build/build.go
index b85fa96de1..8afa9d5240 100644
--- a/src/go/build/build.go
+++ b/src/go/build/build.go
@@ -879,14 +879,17 @@ Found:
 
 		if info.parseErr != nil {
 			badFile(name, info.parseErr)
-			continue
+			// Fall through: we might still have a partial AST in info.parsed,
+			// and we want to list files with parse errors anyway.
 		}
-		pf := info.parsed
 
-		pkg := pf.Name.Name
-		if pkg == "documentation" {
-			p.IgnoredGoFiles = append(p.IgnoredGoFiles, name)
-			continue
+		var pkg string
+		if info.parsed != nil {
+			pkg = info.parsed.Name.Name
+			if pkg == "documentation" {
+				p.IgnoredGoFiles = append(p.IgnoredGoFiles, name)
+				continue
+			}
 		}
 
 		isTest := strings.HasSuffix(name, "_test.go")
@@ -910,8 +913,8 @@ Found:
 			})
 		}
 		// Grab the first package comment as docs, provided it is not from a test file.
-		if pf.Doc != nil && p.Doc == "" && !isTest && !isXTest {
-			p.Doc = doc.Synopsis(pf.Doc.Text())
+		if info.parsed != nil && info.parsed.Doc != nil && p.Doc == "" && !isTest && !isXTest {
+			p.Doc = doc.Synopsis(info.parsed.Doc.Text())
 		}
 
 		if mode&ImportComment != 0 {
-- 
GitLab


From d9e068d2894ff2fce48a171212171bc3f394b023 Mon Sep 17 00:00:00 2001
From: Lynn Boger <laboger@linux.vnet.ibm.com>
Date: Wed, 31 Mar 2021 12:28:47 -0500
Subject: [PATCH 2032/2400] runtime/cgo,cmd/internal/obj/ppc64: fix signals
 with cgo

Recently some tsan tests were enabled on ppc64le which had not
been enabled before. This resulted in failures on systems with
tsan available, and while debugging it was determined that
there were other issues related to the use of signals with cgo.

Signals were not being forwarded within programs linked against
libtsan because the nocgo sigaction was being called for ppc64le
with or without cgo. Adding callCgoSigaction and calling that
allows signals to be registered so that signal forwarding works.

For linux-ppc64 and aix-ppc64, this won't change. On linux-ppc64
there is no cgo. I can't test aix-ppc64 so those owners can enable
it if they want.

In reviewing comments about sigtramp in sys_linux_arm64 it was
noted that a previous issue in arm64 due to missing callee save
registers could also be a problem on ppc64x, so code was added
to save and restore those.

Also, the use of R31 as a temp register in some cases caused an
issue since it is a nonvolatile register in C and was being clobbered
in cases where the C code expected it to be valid. The code sequences to
load these addresses were changed to avoid the use of R31 when loading
such an address.

To get around a vet error, the stubs_ppc64x.go file in runtime
was split into stubs_ppc64.go and stubs_ppc64le.go.

Updates #45040

Change-Id: Ia4ecff950613cbe1b89471790b1d3819d5b5cfb9
Reviewed-on: https://go-review.googlesource.com/c/go/+/306369
Trust: Lynn Boger <laboger@linux.vnet.ibm.com>
Run-TryBot: Lynn Boger <laboger@linux.vnet.ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Carlos Eduardo Seo <carlos.seo@linaro.org>
---
 src/cmd/asm/internal/asm/testdata/ppc64.s     |   4 +-
 src/cmd/internal/obj/ppc64/asm9.go            |  33 ++--
 src/runtime/cgo/gcc_mmap.c                    |   2 +-
 src/runtime/cgo/gcc_sigaction.c               |   2 +-
 src/runtime/cgo/sigaction.go                  |   8 +-
 src/runtime/cgo_sigaction.go                  |   6 +-
 src/runtime/sigaction.go                      |   4 +-
 src/runtime/stubs_ppc64.go                    |  16 ++
 .../{stubs_ppc64x.go => stubs_ppc64le.go}     |   3 -
 src/runtime/sys_linux_ppc64x.s                | 176 +++++++++++++++++-
 10 files changed, 223 insertions(+), 31 deletions(-)
 create mode 100644 src/runtime/stubs_ppc64.go
 rename src/runtime/{stubs_ppc64x.go => stubs_ppc64le.go} (83%)

diff --git a/src/cmd/asm/internal/asm/testdata/ppc64.s b/src/cmd/asm/internal/asm/testdata/ppc64.s
index 1bd4b1e1c8..b6c0aa5035 100644
--- a/src/cmd/asm/internal/asm/testdata/ppc64.s
+++ b/src/cmd/asm/internal/asm/testdata/ppc64.s
@@ -41,8 +41,8 @@ TEXT asmtest(SB),DUPOK|NOSPLIT,$0
 	MOVDBR (R3)(R4), R5             // 7ca41c28
 	MOVWBR (R3)(R4), R5             // 7ca41c2c
 	MOVHBR (R3)(R4), R5             // 7ca41e2c
-	MOVD $foo+4009806848(FP), R5    // 3fe1ef0138bfcc20
-	MOVD $foo(SB), R5               // 3fe0000038bf0000
+	MOVD $foo+4009806848(FP), R5    // 3ca1ef0138a5cc20
+	MOVD $foo(SB), R5               // 3ca0000038a50000
 
 	MOVDU 8(R3), R4                 // e8830009
 	MOVDU (R3)(R4), R5              // 7ca4186a
diff --git a/src/cmd/internal/obj/ppc64/asm9.go b/src/cmd/internal/obj/ppc64/asm9.go
index 69f967acfd..316959f62d 100644
--- a/src/cmd/internal/obj/ppc64/asm9.go
+++ b/src/cmd/internal/obj/ppc64/asm9.go
@@ -2220,7 +2220,7 @@ func (c *ctxt9) opform(insn uint32) int {
 
 // Encode instructions and create relocation for accessing s+d according to the
 // instruction op with source or destination (as appropriate) register reg.
-func (c *ctxt9) symbolAccess(s *obj.LSym, d int64, reg int16, op uint32) (o1, o2 uint32) {
+func (c *ctxt9) symbolAccess(s *obj.LSym, d int64, reg int16, op uint32, reuse bool) (o1, o2 uint32) {
 	if c.ctxt.Headtype == objabi.Haix {
 		// Every symbol access must be made via a TOC anchor.
 		c.ctxt.Diag("symbolAccess called for %s", s.Name)
@@ -2232,8 +2232,15 @@ func (c *ctxt9) symbolAccess(s *obj.LSym, d int64, reg int16, op uint32) (o1, o2
 	} else {
 		base = REG_R0
 	}
-	o1 = AOP_IRR(OP_ADDIS, REGTMP, base, 0)
-	o2 = AOP_IRR(op, uint32(reg), REGTMP, 0)
+	// If reg can be reused when computing the symbol address,
+	// use it instead of REGTMP.
+	if !reuse {
+		o1 = AOP_IRR(OP_ADDIS, REGTMP, base, 0)
+		o2 = AOP_IRR(op, uint32(reg), REGTMP, 0)
+	} else {
+		o1 = AOP_IRR(OP_ADDIS, uint32(reg), base, 0)
+		o2 = AOP_IRR(op, uint32(reg), uint32(reg), 0)
+	}
 	rel := obj.Addrel(c.cursym)
 	rel.Off = int32(c.pc)
 	rel.Siz = 8
@@ -2877,14 +2884,14 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		switch p.From.Name {
 		case obj.NAME_EXTERN, obj.NAME_STATIC:
 			// Load a 32 bit constant, or relocation depending on if a symbol is attached
-			o1, o2 = c.symbolAccess(p.From.Sym, v, p.To.Reg, OP_ADDI)
+			o1, o2 = c.symbolAccess(p.From.Sym, v, p.To.Reg, OP_ADDI, true)
 		default:
 			if r == 0 {
 				r = c.getimpliedreg(&p.From, p)
 			}
 			// Add a 32 bit offset to a register.
-			o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(int32(v))))
-			o2 = AOP_IRR(OP_ADDI, uint32(p.To.Reg), REGTMP, uint32(v))
+			o1 = AOP_IRR(OP_ADDIS, uint32(p.To.Reg), uint32(r), uint32(high16adjusted(int32(v))))
+			o2 = AOP_IRR(OP_ADDI, uint32(p.To.Reg), uint32(p.To.Reg), uint32(v))
 		}
 
 	case 27: /* subc ra,$simm,rd => subfic rd,ra,$simm */
@@ -3043,10 +3050,10 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		if r == 0 {
 			r = c.getimpliedreg(&p.From, p)
 		}
-		o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(v)))
-		o2 = AOP_IRR(c.opload(p.As), uint32(p.To.Reg), REGTMP, uint32(v))
+		o1 = AOP_IRR(OP_ADDIS, uint32(p.To.Reg), uint32(r), uint32(high16adjusted(v)))
+		o2 = AOP_IRR(c.opload(p.As), uint32(p.To.Reg), uint32(p.To.Reg), uint32(v))
 
-		// Sign extend MOVB operations. This is ignored for other cases (o.size == 8).
+		// Sign extend MOVB if needed
 		o3 = LOP_RRR(OP_EXTSB, uint32(p.To.Reg), uint32(p.To.Reg), 0)
 
 	case 40: /* word */
@@ -3404,7 +3411,8 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		if c.opform(inst) == DS_FORM && v&0x3 != 0 {
 			log.Fatalf("invalid offset for DS form load/store %v", p)
 		}
-		o1, o2 = c.symbolAccess(p.To.Sym, v, p.From.Reg, inst)
+		// Can't reuse base for store instructions.
+		o1, o2 = c.symbolAccess(p.To.Sym, v, p.From.Reg, inst, false)
 
 	case 75: // 32 bit offset symbol loads (got/toc/addr)
 		v := p.From.Offset
@@ -3432,10 +3440,11 @@ func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
 				rel.Type = objabi.R_ADDRPOWER_TOCREL_DS
 			}
 		default:
-			o1, o2 = c.symbolAccess(p.From.Sym, v, p.To.Reg, inst)
+			reuseBaseReg := p.As != AFMOVD && p.As != AFMOVS
+			// Reuse To.Reg as base register if not FP move.
+			o1, o2 = c.symbolAccess(p.From.Sym, v, p.To.Reg, inst, reuseBaseReg)
 		}
 
-		// Sign extend MOVB operations. This is ignored for other cases (o.size == 8).
 		o3 = LOP_RRR(OP_EXTSB, uint32(p.To.Reg), uint32(p.To.Reg), 0)
 
 	case 79:
diff --git a/src/runtime/cgo/gcc_mmap.c b/src/runtime/cgo/gcc_mmap.c
index e6a621d5a3..698a7e3cd2 100644
--- a/src/runtime/cgo/gcc_mmap.c
+++ b/src/runtime/cgo/gcc_mmap.c
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build linux,amd64 linux,arm64
+// +build linux,amd64 linux,arm64 linux,ppc64le
 
 #include <errno.h>
 #include <stdint.h>
diff --git a/src/runtime/cgo/gcc_sigaction.c b/src/runtime/cgo/gcc_sigaction.c
index 890008e327..dd283151f1 100644
--- a/src/runtime/cgo/gcc_sigaction.c
+++ b/src/runtime/cgo/gcc_sigaction.c
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build linux,amd64 linux,arm64
+// +build linux,amd64 linux,arm64 linux,ppc64le
 
 #include <errno.h>
 #include <stddef.h>
diff --git a/src/runtime/cgo/sigaction.go b/src/runtime/cgo/sigaction.go
index ee63ea4c09..692fd2675f 100644
--- a/src/runtime/cgo/sigaction.go
+++ b/src/runtime/cgo/sigaction.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (linux && amd64) || (freebsd && amd64) || (linux && arm64)
-// +build linux,amd64 freebsd,amd64 linux,arm64
+//go:build (linux && amd64) || (freebsd && amd64) || (linux && arm64) || (linux && ppc64le)
+// +build linux,amd64 freebsd,amd64 linux,arm64 linux,ppc64le
 
 package cgo
 
@@ -11,8 +11,8 @@ package cgo
 import _ "unsafe"
 
 // When using cgo, call the C library for sigaction, so that we call into
-// any sanitizer interceptors. This supports using the memory
-// sanitizer with Go programs. The memory sanitizer only applies to
+// any sanitizer interceptors. This supports using the sanitizers
+// with Go programs. The thread and memory sanitizers only apply to
 // C/C++ code; this permits that code to see the Go runtime's existing signal
 // handlers when registering new signal handlers for the process.
 
diff --git a/src/runtime/cgo_sigaction.go b/src/runtime/cgo_sigaction.go
index 15690ecb0b..6099d1b746 100644
--- a/src/runtime/cgo_sigaction.go
+++ b/src/runtime/cgo_sigaction.go
@@ -2,10 +2,10 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Support for memory sanitizer. See runtime/cgo/sigaction.go.
+// Support for sanitizers. See runtime/cgo/sigaction.go.
 
-//go:build (linux && amd64) || (freebsd && amd64) || (linux && arm64)
-// +build linux,amd64 freebsd,amd64 linux,arm64
+//go:build (linux && amd64) || (freebsd && amd64) || (linux && arm64) || (linux && ppc64le)
+// +build linux,amd64 freebsd,amd64 linux,arm64 linux,ppc64le
 
 package runtime
 
diff --git a/src/runtime/sigaction.go b/src/runtime/sigaction.go
index 76f37b1b53..30050efcc7 100644
--- a/src/runtime/sigaction.go
+++ b/src/runtime/sigaction.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (linux && !amd64 && !arm64) || (freebsd && !amd64)
-// +build linux,!amd64,!arm64 freebsd,!amd64
+//go:build (linux && !amd64 && !arm64 && !ppc64le) || (freebsd && !amd64)
+// +build linux,!amd64,!arm64,!ppc64le freebsd,!amd64
 
 package runtime
 
diff --git a/src/runtime/stubs_ppc64.go b/src/runtime/stubs_ppc64.go
new file mode 100644
index 0000000000..f692947109
--- /dev/null
+++ b/src/runtime/stubs_ppc64.go
@@ -0,0 +1,16 @@
+// Copyright 2021 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.
+
+//go:build linux
+// +build linux
+
+package runtime
+
+// Called from assembly only; declared for go vet.
+func load_g()
+func save_g()
+func reginit()
+
+//go:noescape
+func callCgoSigaction(sig uintptr, new, old *sigactiont) int32
diff --git a/src/runtime/stubs_ppc64x.go b/src/runtime/stubs_ppc64le.go
similarity index 83%
rename from src/runtime/stubs_ppc64x.go
rename to src/runtime/stubs_ppc64le.go
index 0841b413fd..5b733136e3 100644
--- a/src/runtime/stubs_ppc64x.go
+++ b/src/runtime/stubs_ppc64le.go
@@ -2,9 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build ppc64 || ppc64le
-// +build ppc64 ppc64le
-
 package runtime
 
 // Called from assembly only; declared for go vet.
diff --git a/src/runtime/sys_linux_ppc64x.s b/src/runtime/sys_linux_ppc64x.s
index 75da130357..46387288d5 100644
--- a/src/runtime/sys_linux_ppc64x.s
+++ b/src/runtime/sys_linux_ppc64x.s
@@ -336,6 +336,26 @@ TEXT runtime·rt_sigaction(SB),NOSPLIT|NOFRAME,$0-36
 	MOVW	R3, ret+32(FP)
 	RET
 
+#ifdef GOARCH_ppc64le
+// Call the function stored in _cgo_sigaction using the GCC calling convention.
+TEXT runtime·callCgoSigaction(SB),NOSPLIT,$0
+	MOVD    sig+0(FP), R3
+	MOVD    new+8(FP), R4
+	MOVD    old+16(FP), R5
+	MOVD     _cgo_sigaction(SB), R12
+	MOVD    R12, CTR                // R12 should contain the function address
+	MOVD    R1, R15                 // Save R1
+	MOVD    R2, 24(R1)              // Save R2
+	SUB     $48, R1                 // reserve 32 (frame) + 16 bytes for sp-8 where fp may be saved.
+	RLDICR  $0, R1, $59, R1         // Align to 16 bytes for C code
+	BL      (CTR)
+	XOR     R0, R0, R0              // Clear R0 as Go expects
+	MOVD    R15, R1                 // Restore R1
+	MOVD    24(R1), R2              // Restore R2
+	MOVW    R3, ret+24(FP)          // Return result
+	RET
+#endif
+
 TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
 	MOVW	sig+8(FP), R3
 	MOVD	info+16(FP), R4
@@ -351,15 +371,97 @@ TEXT runtime·sigreturn(SB),NOSPLIT,$0-0
 
 #ifdef GOARCH_ppc64le
 // ppc64le doesn't need function descriptors
-TEXT runtime·sigtramp(SB),NOSPLIT,$64
+// Save callee-save registers in the case of signal forwarding.
+// Same as on ARM64 https://golang.org/issue/31827 .
+TEXT runtime·sigtramp(SB),NOSPLIT|NOFRAME,$0
 #else
 // function descriptor for the real sigtramp
 TEXT runtime·sigtramp(SB),NOSPLIT|NOFRAME,$0
 	DWORD	$sigtramp<>(SB)
 	DWORD	$0
 	DWORD	$0
-TEXT sigtramp<>(SB),NOSPLIT,$64
+TEXT sigtramp<>(SB),NOSPLIT|NOFRAME,$0
 #endif
+	// Start with standard C stack frame layout and linkage.
+	MOVD    LR, R0
+	MOVD    R0, 16(R1) // Save LR in caller's frame.
+	MOVW    CR, R0     // Save CR in caller's frame
+	MOVD    R0, 8(R1)
+	// The stack must be acquired here and not
+	// in the automatic way based on stack size
+	// since that sequence clobbers R31 before it
+	// gets saved.
+	// We are being ultra safe here in saving the
+	// Vregs. The case where they might need to
+	// be saved is very unlikely.
+	MOVDU   R1, -544(R1)
+	MOVD    R14, 64(R1)
+	MOVD    R15, 72(R1)
+	MOVD    R16, 80(R1)
+	MOVD    R17, 88(R1)
+	MOVD    R18, 96(R1)
+	MOVD    R19, 104(R1)
+	MOVD    R20, 112(R1)
+	MOVD    R21, 120(R1)
+	MOVD    R22, 128(R1)
+	MOVD    R23, 136(R1)
+	MOVD    R24, 144(R1)
+	MOVD    R25, 152(R1)
+	MOVD    R26, 160(R1)
+	MOVD    R27, 168(R1)
+	MOVD    R28, 176(R1)
+	MOVD    R29, 184(R1)
+	MOVD    g, 192(R1) // R30
+	MOVD    R31, 200(R1)
+	FMOVD   F14, 208(R1)
+	FMOVD   F15, 216(R1)
+	FMOVD   F16, 224(R1)
+	FMOVD   F17, 232(R1)
+	FMOVD   F18, 240(R1)
+	FMOVD   F19, 248(R1)
+	FMOVD   F20, 256(R1)
+	FMOVD   F21, 264(R1)
+	FMOVD   F22, 272(R1)
+	FMOVD   F23, 280(R1)
+	FMOVD   F24, 288(R1)
+	FMOVD   F25, 296(R1)
+	FMOVD   F26, 304(R1)
+	FMOVD   F27, 312(R1)
+	FMOVD   F28, 320(R1)
+	FMOVD   F29, 328(R1)
+	FMOVD   F30, 336(R1)
+	FMOVD   F31, 344(R1)
+	// Save V regs
+	// STXVD2X and LXVD2X used since
+	// we aren't sure of alignment.
+	// Endianness doesn't matter
+	// if we are just loading and
+	// storing values.
+	MOVD	$352, R7 // V20
+	STXVD2X VS52, (R7)(R1)
+	ADD	$16, R7 // V21 368
+	STXVD2X VS53, (R7)(R1)
+	ADD	$16, R7 // V22 384
+	STXVD2X VS54, (R7)(R1)
+	ADD	$16, R7 // V23 400
+	STXVD2X VS55, (R7)(R1)
+	ADD	$16, R7 // V24 416
+	STXVD2X	VS56, (R7)(R1)
+	ADD	$16, R7 // V25 432
+	STXVD2X	VS57, (R7)(R1)
+	ADD	$16, R7 // V26 448
+	STXVD2X VS58, (R7)(R1)
+	ADD	$16, R7 // V27 464
+	STXVD2X VS59, (R7)(R1)
+	ADD	$16, R7 // V28 480
+	STXVD2X VS60, (R7)(R1)
+	ADD	$16, R7 // V29 496
+	STXVD2X VS61, (R7)(R1)
+	ADD	$16, R7 // V30 512
+	STXVD2X VS62, (R7)(R1)
+	ADD	$16, R7 // V31 528
+	STXVD2X VS63, (R7)(R1)
+
 	// initialize essential registers (just in case)
 	BL	runtime·reginit(SB)
 
@@ -376,7 +478,74 @@ TEXT sigtramp<>(SB),NOSPLIT,$64
 	MOVD	$runtime·sigtrampgo(SB), R12
 	MOVD	R12, CTR
 	BL	(CTR)
-	MOVD	24(R1), R2
+	MOVD	24(R1), R2 // Should this be here? Where is it saved?
+	// Starts at 64; FIXED_FRAME is 32
+	MOVD    64(R1), R14
+	MOVD    72(R1), R15
+	MOVD    80(R1), R16
+	MOVD    88(R1), R17
+	MOVD    96(R1), R18
+	MOVD    104(R1), R19
+	MOVD    112(R1), R20
+	MOVD    120(R1), R21
+	MOVD    128(R1), R22
+	MOVD    136(R1), R23
+	MOVD    144(R1), R24
+	MOVD    152(R1), R25
+	MOVD    160(R1), R26
+	MOVD    168(R1), R27
+	MOVD    176(R1), R28
+	MOVD    184(R1), R29
+	MOVD    192(R1), g // R30
+	MOVD    200(R1), R31
+	FMOVD   208(R1), F14
+	FMOVD   216(R1), F15
+	FMOVD   224(R1), F16
+	FMOVD   232(R1), F17
+	FMOVD   240(R1), F18
+	FMOVD   248(R1), F19
+	FMOVD   256(R1), F20
+	FMOVD   264(R1), F21
+	FMOVD   272(R1), F22
+	FMOVD   280(R1), F23
+	FMOVD   288(R1), F24
+	FMOVD   292(R1), F25
+	FMOVD   300(R1), F26
+	FMOVD   308(R1), F27
+	FMOVD   316(R1), F28
+	FMOVD   328(R1), F29
+	FMOVD   336(R1), F30
+	FMOVD   344(R1), F31
+	MOVD	$352, R7
+	LXVD2X	(R7)(R1), VS52
+	ADD	$16, R7 // 368 V21
+	LXVD2X	(R7)(R1), VS53
+	ADD	$16, R7 // 384 V22
+	LXVD2X	(R7)(R1), VS54
+	ADD	$16, R7 // 400 V23
+	LXVD2X	(R7)(R1), VS55
+	ADD	$16, R7 // 416 V24
+	LXVD2X	(R7)(R1), VS56
+	ADD	$16, R7 // 432 V25
+	LXVD2X	(R7)(R1), VS57
+	ADD	$16, R7 // 448 V26
+	LXVD2X	(R7)(R1), VS58
+	ADD	$16, R8 // 464 V27
+	LXVD2X	(R7)(R1), VS59
+	ADD	$16, R7 // 480 V28
+	LXVD2X	(R7)(R1), VS60
+	ADD	$16, R7 // 496 V29
+	LXVD2X	(R7)(R1), VS61
+	ADD	$16, R7 // 512 V30
+	LXVD2X	(R7)(R1), VS62
+	ADD	$16, R7 // 528 V31
+	LXVD2X	(R7)(R1), VS63
+	ADD	$544, R1
+	MOVD	8(R1), R0
+	MOVFL	R0, $0xff
+	MOVD	16(R1), R0
+	MOVD	R0, LR
+
 	RET
 
 #ifdef GOARCH_ppc64le
@@ -406,6 +575,7 @@ TEXT runtime·cgoSigtramp(SB),NOSPLIT|NOFRAME,$0
 
 	// Figure out if we are currently in a cgo call.
 	// If not, just do usual sigtramp.
+	// compared to ARM64 and others.
 	CMP	$0, g
 	BEQ	sigtrampnog // g == nil
 	MOVD	g_m(g), R6
-- 
GitLab


From 73d5aef4d19486d5eb03730791bd21f47c6c7d2b Mon Sep 17 00:00:00 2001
From: Tao Qingyun <qingyunha@gmail.com>
Date: Sat, 12 Dec 2020 09:45:45 +0000
Subject: [PATCH 2033/2400] cmd/internal/objfile: add objabi.SNOPTRDATA to "D"

Change-Id: I65913534a4a3e2cbc0d4b00454dd3092eb908cb5
GitHub-Last-Rev: 39dc0d21b81eb6aeec4c29d4ea72e6c1ef7fea0d
GitHub-Pull-Request: golang/go#43151
Reviewed-on: https://go-review.googlesource.com/c/go/+/277452
Run-TryBot: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
Trust: Heschi Kreinick <heschi@google.com>
---
 src/cmd/internal/objfile/goobj.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/internal/objfile/goobj.go b/src/cmd/internal/objfile/goobj.go
index f19bec5dcb..dd21d22351 100644
--- a/src/cmd/internal/objfile/goobj.go
+++ b/src/cmd/internal/objfile/goobj.go
@@ -168,7 +168,7 @@ func (f *goobjFile) symbols() ([]Sym, error) {
 			code = 'T'
 		case objabi.SRODATA:
 			code = 'R'
-		case objabi.SDATA:
+		case objabi.SNOPTRDATA, objabi.SDATA:
 			code = 'D'
 		case objabi.SBSS, objabi.SNOPTRBSS, objabi.STLSBSS:
 			code = 'B'
-- 
GitLab


From dc50683bf7ebdfde726d710131ba05fe97e10a07 Mon Sep 17 00:00:00 2001
From: Roland Shoemaker <roland@golang.org>
Date: Wed, 13 May 2020 18:24:16 -0700
Subject: [PATCH 2034/2400] crypto/elliptic: upgrade from generic curve impl to
 specific if available

This change alters the CurveParam methods to upgrade from the generic
curve implementation to the specific P224 or P256 implementations when
called on the embedded CurveParams. This removes the trap of using
elliptic.P224().Params() instead of elliptic.P224(), for example, which
results in using the generic implementation instead of the optimized
constant time one. For P224 this is done for all of the CurveParams
methods, except Params, as the optimized implementation covers all
these methods. For P256 this is only done for ScalarMult and
ScalarBaseMult, as despite having implementations of addition and
doubling they aren't exposed and instead the generic implementation is
used. For P256 an additional check that there actually is a specific
implementation is added, as unlike the P224 implementation the P256 one
is only available on certain platforms.

This change takes the simple, fast approach to checking this, it simply
compares pointers. This removes the most obvious class of mistakes
people make, but still allows edge cases where the embedded CurveParams
pointer has been dereferenced (as seen in the unit tests) or when someone
has manually constructed their own CurveParams that matches one of the
standard curves. A more complex approach could be taken to also address
these cases, but it would require directly comparing all of the
CurveParam fields which would, in the worst case, require comparing
against two standard CurveParam sets in the ScalarMult and
ScalarBaseMult paths, which are likely to be the hottest already.

Updates #34648

Change-Id: I82d752f979260394632905c15ffe4f65f4ffa376
Reviewed-on: https://go-review.googlesource.com/c/go/+/233939
Trust: Roland Shoemaker <roland@golang.org>
Trust: Katie Hockman <katie@golang.org>
Run-TryBot: Roland Shoemaker <roland@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
---
 src/crypto/elliptic/elliptic.go      | 39 ++++++++++++++++++++++++++++
 src/crypto/elliptic/elliptic_test.go | 18 ++++++++++---
 src/crypto/elliptic/p256_asm.go      |  4 +--
 src/crypto/elliptic/p256_generic.go  |  4 +--
 4 files changed, 55 insertions(+), 10 deletions(-)

diff --git a/src/crypto/elliptic/elliptic.go b/src/crypto/elliptic/elliptic.go
index 85d105419b..b8e5a3097d 100644
--- a/src/crypto/elliptic/elliptic.go
+++ b/src/crypto/elliptic/elliptic.go
@@ -40,6 +40,15 @@ type Curve interface {
 	ScalarBaseMult(k []byte) (x, y *big.Int)
 }
 
+func matchesSpecificCurve(params *CurveParams, available ...Curve) (Curve, bool) {
+	for _, c := range available {
+		if params == c.Params() {
+			return c, true
+		}
+	}
+	return nil, false
+}
+
 // CurveParams contains the parameters of an elliptic curve and also provides
 // a generic, non-constant time implementation of Curve.
 type CurveParams struct {
@@ -71,6 +80,12 @@ func (curve *CurveParams) polynomial(x *big.Int) *big.Int {
 }
 
 func (curve *CurveParams) IsOnCurve(x, y *big.Int) bool {
+	// If there is a dedicated constant-time implementation for this curve operation,
+	// use that instead of the generic one.
+	if specific, ok := matchesSpecificCurve(curve, p224, p521); ok {
+		return specific.IsOnCurve(x, y)
+	}
+
 	// y² = x³ - 3x + b
 	y2 := new(big.Int).Mul(y, y)
 	y2.Mod(y2, curve.P)
@@ -108,6 +123,12 @@ func (curve *CurveParams) affineFromJacobian(x, y, z *big.Int) (xOut, yOut *big.
 }
 
 func (curve *CurveParams) Add(x1, y1, x2, y2 *big.Int) (*big.Int, *big.Int) {
+	// If there is a dedicated constant-time implementation for this curve operation,
+	// use that instead of the generic one.
+	if specific, ok := matchesSpecificCurve(curve, p224, p521); ok {
+		return specific.Add(x1, y1, x2, y2)
+	}
+
 	z1 := zForAffine(x1, y1)
 	z2 := zForAffine(x2, y2)
 	return curve.affineFromJacobian(curve.addJacobian(x1, y1, z1, x2, y2, z2))
@@ -192,6 +213,12 @@ func (curve *CurveParams) addJacobian(x1, y1, z1, x2, y2, z2 *big.Int) (*big.Int
 }
 
 func (curve *CurveParams) Double(x1, y1 *big.Int) (*big.Int, *big.Int) {
+	// If there is a dedicated constant-time implementation for this curve operation,
+	// use that instead of the generic one.
+	if specific, ok := matchesSpecificCurve(curve, p224, p521); ok {
+		return specific.Double(x1, y1)
+	}
+
 	z1 := zForAffine(x1, y1)
 	return curve.affineFromJacobian(curve.doubleJacobian(x1, y1, z1))
 }
@@ -258,6 +285,12 @@ func (curve *CurveParams) doubleJacobian(x, y, z *big.Int) (*big.Int, *big.Int,
 }
 
 func (curve *CurveParams) ScalarMult(Bx, By *big.Int, k []byte) (*big.Int, *big.Int) {
+	// If there is a dedicated constant-time implementation for this curve operation,
+	// use that instead of the generic one.
+	if specific, ok := matchesSpecificCurve(curve, p224, p256, p521); ok {
+		return specific.ScalarMult(Bx, By, k)
+	}
+
 	Bz := new(big.Int).SetInt64(1)
 	x, y, z := new(big.Int), new(big.Int), new(big.Int)
 
@@ -275,6 +308,12 @@ func (curve *CurveParams) ScalarMult(Bx, By *big.Int, k []byte) (*big.Int, *big.
 }
 
 func (curve *CurveParams) ScalarBaseMult(k []byte) (*big.Int, *big.Int) {
+	// If there is a dedicated constant-time implementation for this curve operation,
+	// use that instead of the generic one.
+	if specific, ok := matchesSpecificCurve(curve, p224, p256, p521); ok {
+		return specific.ScalarBaseMult(k)
+	}
+
 	return curve.ScalarMult(curve.Gx, curve.Gy, k)
 }
 
diff --git a/src/crypto/elliptic/elliptic_test.go b/src/crypto/elliptic/elliptic_test.go
index 0d43b736f9..183861a54b 100644
--- a/src/crypto/elliptic/elliptic_test.go
+++ b/src/crypto/elliptic/elliptic_test.go
@@ -12,19 +12,29 @@ import (
 	"testing"
 )
 
+// genericParamsForCurve returns the dereferenced CurveParams for
+// the specified curve. This is used to avoid the logic for
+// upgrading a curve to it's specific implementation, forcing
+// usage of the generic implementation. This is only relevant
+// for the P224, P256, and P521 curves.
+func genericParamsForCurve(c Curve) *CurveParams {
+	d := *(c.Params())
+	return &d
+}
+
 func testAllCurves(t *testing.T, f func(*testing.T, Curve)) {
 	tests := []struct {
 		name  string
 		curve Curve
 	}{
 		{"P256", P256()},
-		{"P256/Params", P256().Params()},
+		{"P256/Params", genericParamsForCurve(P256())},
 		{"P224", P224()},
-		{"P224/Params", P224().Params()},
+		{"P224/Params", genericParamsForCurve(P224())},
 		{"P384", P384()},
-		{"P384/Params", P384().Params()},
+		{"P384/Params", genericParamsForCurve(P384())},
 		{"P521", P521()},
-		{"P521/Params", P521().Params()},
+		{"P521/Params", genericParamsForCurve(P521())},
 	}
 	if testing.Short() {
 		tests = tests[:1]
diff --git a/src/crypto/elliptic/p256_asm.go b/src/crypto/elliptic/p256_asm.go
index 08dbd2ea54..9a808f260a 100644
--- a/src/crypto/elliptic/p256_asm.go
+++ b/src/crypto/elliptic/p256_asm.go
@@ -29,9 +29,7 @@ type (
 	}
 )
 
-var (
-	p256 p256Curve
-)
+var p256 p256Curve
 
 func initP256() {
 	// See FIPS 186-3, section D.2.3
diff --git a/src/crypto/elliptic/p256_generic.go b/src/crypto/elliptic/p256_generic.go
index 8ad56638e9..25762a8f76 100644
--- a/src/crypto/elliptic/p256_generic.go
+++ b/src/crypto/elliptic/p256_generic.go
@@ -7,9 +7,7 @@
 
 package elliptic
 
-var (
-	p256 p256Curve
-)
+var p256 p256Curve
 
 func initP256Arch() {
 	// Use pure Go implementation.
-- 
GitLab


From 5c489514bc5e61ad9b5b07bd7d8ec65d66a0512a Mon Sep 17 00:00:00 2001
From: Roberto Clapis <roberto@golang.org>
Date: Wed, 7 Apr 2021 14:36:40 +0200
Subject: [PATCH 2035/2400] net/http: switch HTTP1 to ASCII equivalents of
 string functions

The current implementation uses UTF-aware functions
like strings.EqualFold and strings.ToLower.

This could, in some cases, cause http smuggling.

Change-Id: I0e76a993470a1e1b1b472f4b2859ea0a2b22ada0
Reviewed-on: https://go-review.googlesource.com/c/go/+/308009
Run-TryBot: Filippo Valsorda <filippo@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Roberto Clapis <roberto@golang.org>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
---
 src/go/build/deps_test.go                  |  5 +-
 src/net/http/client.go                     |  6 +-
 src/net/http/cookie.go                     | 13 ++-
 src/net/http/cookiejar/jar.go              | 17 +++-
 src/net/http/cookiejar/punycode.go         | 14 +---
 src/net/http/header.go                     |  3 +-
 src/net/http/http.go                       |  9 --
 src/net/http/httputil/reverseproxy.go      | 12 ++-
 src/net/http/httputil/reverseproxy_test.go |  5 +-
 src/net/http/internal/ascii/print.go       | 61 ++++++++++++++
 src/net/http/internal/ascii/print_test.go  | 95 ++++++++++++++++++++++
 src/net/http/request.go                    |  7 +-
 src/net/http/transfer.go                   |  3 +-
 src/net/http/transport.go                  |  3 +-
 14 files changed, 215 insertions(+), 38 deletions(-)
 create mode 100644 src/net/http/internal/ascii/print.go
 create mode 100644 src/net/http/internal/ascii/print_test.go

diff --git a/src/go/build/deps_test.go b/src/go/build/deps_test.go
index 3a0e769284..5d1cf7f4c9 100644
--- a/src/go/build/deps_test.go
+++ b/src/go/build/deps_test.go
@@ -440,7 +440,7 @@ var depsRules = `
 	# HTTP, King of Dependencies.
 
 	FMT
-	< golang.org/x/net/http2/hpack, net/http/internal;
+	< golang.org/x/net/http2/hpack, net/http/internal, net/http/internal/ascii;
 
 	FMT, NET, container/list, encoding/binary, log
 	< golang.org/x/text/transform
@@ -458,6 +458,7 @@ var depsRules = `
 	golang.org/x/net/http/httpproxy,
 	golang.org/x/net/http2/hpack,
 	net/http/internal,
+	net/http/internal/ascii,
 	net/http/httptrace,
 	mime/multipart,
 	log
@@ -468,7 +469,7 @@ var depsRules = `
 	encoding/json, net/http
 	< expvar;
 
-	net/http
+	net/http, net/http/internal/ascii
 	< net/http/cookiejar, net/http/httputil;
 
 	net/http, flag
diff --git a/src/net/http/client.go b/src/net/http/client.go
index 82e665829e..03c9155fbd 100644
--- a/src/net/http/client.go
+++ b/src/net/http/client.go
@@ -17,6 +17,7 @@ import (
 	"fmt"
 	"io"
 	"log"
+	"net/http/internal/ascii"
 	"net/url"
 	"reflect"
 	"sort"
@@ -547,7 +548,10 @@ func urlErrorOp(method string) string {
 	if method == "" {
 		return "Get"
 	}
-	return method[:1] + strings.ToLower(method[1:])
+	if lowerMethod, ok := ascii.ToLower(method); ok {
+		return method[:1] + lowerMethod[1:]
+	}
+	return method
 }
 
 // Do sends an HTTP request and returns an HTTP response, following
diff --git a/src/net/http/cookie.go b/src/net/http/cookie.go
index 141bc947f6..ca2c1c2506 100644
--- a/src/net/http/cookie.go
+++ b/src/net/http/cookie.go
@@ -7,6 +7,7 @@ package http
 import (
 	"log"
 	"net"
+	"net/http/internal/ascii"
 	"net/textproto"
 	"strconv"
 	"strings"
@@ -93,15 +94,23 @@ func readSetCookies(h Header) []*Cookie {
 			if j := strings.Index(attr, "="); j >= 0 {
 				attr, val = attr[:j], attr[j+1:]
 			}
-			lowerAttr := strings.ToLower(attr)
+			lowerAttr, isASCII := ascii.ToLower(attr)
+			if !isASCII {
+				continue
+			}
 			val, ok = parseCookieValue(val, false)
 			if !ok {
 				c.Unparsed = append(c.Unparsed, parts[i])
 				continue
 			}
+
 			switch lowerAttr {
 			case "samesite":
-				lowerVal := strings.ToLower(val)
+				lowerVal, ascii := ascii.ToLower(val)
+				if !ascii {
+					c.SameSite = SameSiteDefaultMode
+					continue
+				}
 				switch lowerVal {
 				case "lax":
 					c.SameSite = SameSiteLaxMode
diff --git a/src/net/http/cookiejar/jar.go b/src/net/http/cookiejar/jar.go
index 9f19917084..e6583da7fe 100644
--- a/src/net/http/cookiejar/jar.go
+++ b/src/net/http/cookiejar/jar.go
@@ -10,6 +10,7 @@ import (
 	"fmt"
 	"net"
 	"net/http"
+	"net/http/internal/ascii"
 	"net/url"
 	"sort"
 	"strings"
@@ -296,7 +297,6 @@ func (j *Jar) setCookies(u *url.URL, cookies []*http.Cookie, now time.Time) {
 // host name.
 func canonicalHost(host string) (string, error) {
 	var err error
-	host = strings.ToLower(host)
 	if hasPort(host) {
 		host, _, err = net.SplitHostPort(host)
 		if err != nil {
@@ -307,7 +307,13 @@ func canonicalHost(host string) (string, error) {
 		// Strip trailing dot from fully qualified domain names.
 		host = host[:len(host)-1]
 	}
-	return toASCII(host)
+	encoded, err := toASCII(host)
+	if err != nil {
+		return "", err
+	}
+	// We know this is ascii, no need to check.
+	lower, _ := ascii.ToLower(encoded)
+	return lower, nil
 }
 
 // hasPort reports whether host contains a port number. host may be a host
@@ -469,7 +475,12 @@ func (j *Jar) domainAndType(host, domain string) (string, bool, error) {
 		// both are illegal.
 		return "", false, errMalformedDomain
 	}
-	domain = strings.ToLower(domain)
+
+	domain, isASCII := ascii.ToLower(domain)
+	if !isASCII {
+		// Received non-ASCII domain, e.g. "perché.com" instead of "xn--perch-fsa.com"
+		return "", false, errMalformedDomain
+	}
 
 	if domain[len(domain)-1] == '.' {
 		// We received stuff like "Domain=www.example.com.".
diff --git a/src/net/http/cookiejar/punycode.go b/src/net/http/cookiejar/punycode.go
index a9cc666e8c..c7f438dd00 100644
--- a/src/net/http/cookiejar/punycode.go
+++ b/src/net/http/cookiejar/punycode.go
@@ -8,6 +8,7 @@ package cookiejar
 
 import (
 	"fmt"
+	"net/http/internal/ascii"
 	"strings"
 	"unicode/utf8"
 )
@@ -133,12 +134,12 @@ const acePrefix = "xn--"
 // toASCII("bücher.example.com") is "xn--bcher-kva.example.com", and
 // toASCII("golang") is "golang".
 func toASCII(s string) (string, error) {
-	if ascii(s) {
+	if ascii.Is(s) {
 		return s, nil
 	}
 	labels := strings.Split(s, ".")
 	for i, label := range labels {
-		if !ascii(label) {
+		if !ascii.Is(label) {
 			a, err := encode(acePrefix, label)
 			if err != nil {
 				return "", err
@@ -148,12 +149,3 @@ func toASCII(s string) (string, error) {
 	}
 	return strings.Join(labels, "."), nil
 }
-
-func ascii(s string) bool {
-	for i := 0; i < len(s); i++ {
-		if s[i] >= utf8.RuneSelf {
-			return false
-		}
-	}
-	return true
-}
diff --git a/src/net/http/header.go b/src/net/http/header.go
index b9b53911f3..4c72dcb2c8 100644
--- a/src/net/http/header.go
+++ b/src/net/http/header.go
@@ -7,6 +7,7 @@ package http
 import (
 	"io"
 	"net/http/httptrace"
+	"net/http/internal/ascii"
 	"net/textproto"
 	"sort"
 	"strings"
@@ -251,7 +252,7 @@ func hasToken(v, token string) bool {
 		if endPos := sp + len(token); endPos != len(v) && !isTokenBoundary(v[endPos]) {
 			continue
 		}
-		if strings.EqualFold(v[sp:sp+len(token)], token) {
+		if ascii.EqualFold(v[sp:sp+len(token)], token) {
 			return true
 		}
 	}
diff --git a/src/net/http/http.go b/src/net/http/http.go
index 4c5054b399..101799f574 100644
--- a/src/net/http/http.go
+++ b/src/net/http/http.go
@@ -62,15 +62,6 @@ func isNotToken(r rune) bool {
 	return !httpguts.IsTokenRune(r)
 }
 
-func isASCII(s string) bool {
-	for i := 0; i < len(s); i++ {
-		if s[i] >= utf8.RuneSelf {
-			return false
-		}
-	}
-	return true
-}
-
 // stringContainsCTLByte reports whether s contains any ASCII control character.
 func stringContainsCTLByte(s string) bool {
 	for i := 0; i < len(s); i++ {
diff --git a/src/net/http/httputil/reverseproxy.go b/src/net/http/httputil/reverseproxy.go
index db42ac6ba5..1432ee26d3 100644
--- a/src/net/http/httputil/reverseproxy.go
+++ b/src/net/http/httputil/reverseproxy.go
@@ -13,6 +13,7 @@ import (
 	"log"
 	"net"
 	"net/http"
+	"net/http/internal/ascii"
 	"net/textproto"
 	"net/url"
 	"strings"
@@ -242,6 +243,10 @@ func (p *ReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
 	outreq.Close = false
 
 	reqUpType := upgradeType(outreq.Header)
+	if !ascii.IsPrint(reqUpType) {
+		p.getErrorHandler()(rw, req, fmt.Errorf("client tried to switch to invalid protocol %q", reqUpType))
+		return
+	}
 	removeConnectionHeaders(outreq.Header)
 
 	// Remove hop-by-hop headers to the backend. Especially
@@ -538,13 +543,16 @@ func upgradeType(h http.Header) string {
 	if !httpguts.HeaderValuesContainsToken(h["Connection"], "Upgrade") {
 		return ""
 	}
-	return strings.ToLower(h.Get("Upgrade"))
+	return h.Get("Upgrade")
 }
 
 func (p *ReverseProxy) handleUpgradeResponse(rw http.ResponseWriter, req *http.Request, res *http.Response) {
 	reqUpType := upgradeType(req.Header)
 	resUpType := upgradeType(res.Header)
-	if reqUpType != resUpType {
+	if !ascii.IsPrint(resUpType) { // We know reqUpType is ASCII, it's checked by the caller.
+		p.getErrorHandler()(rw, req, fmt.Errorf("backend tried to switch to invalid protocol %q", resUpType))
+	}
+	if !ascii.EqualFold(reqUpType, resUpType) {
 		p.getErrorHandler()(rw, req, fmt.Errorf("backend tried to switch protocol %q when %q was requested", resUpType, reqUpType))
 		return
 	}
diff --git a/src/net/http/httputil/reverseproxy_test.go b/src/net/http/httputil/reverseproxy_test.go
index 3acbd940e4..b89eb90ad6 100644
--- a/src/net/http/httputil/reverseproxy_test.go
+++ b/src/net/http/httputil/reverseproxy_test.go
@@ -16,6 +16,7 @@ import (
 	"log"
 	"net/http"
 	"net/http/httptest"
+	"net/http/internal/ascii"
 	"net/url"
 	"os"
 	"reflect"
@@ -1183,7 +1184,7 @@ func TestReverseProxyWebSocket(t *testing.T) {
 		t.Errorf("Header(XHeader) = %q; want %q", got, want)
 	}
 
-	if upgradeType(res.Header) != "websocket" {
+	if !ascii.EqualFold(upgradeType(res.Header), "websocket") {
 		t.Fatalf("not websocket upgrade; got %#v", res.Header)
 	}
 	rwc, ok := res.Body.(io.ReadWriteCloser)
@@ -1300,7 +1301,7 @@ func TestReverseProxyWebSocketCancelation(t *testing.T) {
 		t.Errorf("X-Header mismatch\n\tgot:  %q\n\twant: %q", g, w)
 	}
 
-	if g, w := upgradeType(res.Header), "websocket"; g != w {
+	if g, w := upgradeType(res.Header), "websocket"; !ascii.EqualFold(g, w) {
 		t.Fatalf("Upgrade header mismatch\n\tgot:  %q\n\twant: %q", g, w)
 	}
 
diff --git a/src/net/http/internal/ascii/print.go b/src/net/http/internal/ascii/print.go
new file mode 100644
index 0000000000..585e5baba4
--- /dev/null
+++ b/src/net/http/internal/ascii/print.go
@@ -0,0 +1,61 @@
+// Copyright 2021 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 ascii
+
+import (
+	"strings"
+	"unicode"
+)
+
+// EqualFold is strings.EqualFold, ASCII only. It reports whether s and t
+// are equal, ASCII-case-insensitively.
+func EqualFold(s, t string) bool {
+	if len(s) != len(t) {
+		return false
+	}
+	for i := 0; i < len(s); i++ {
+		if lower(s[i]) != lower(t[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+// lower returns the ASCII lowercase version of b.
+func lower(b byte) byte {
+	if 'A' <= b && b <= 'Z' {
+		return b + ('a' - 'A')
+	}
+	return b
+}
+
+// IsPrint returns whether s is ASCII and printable according to
+// https://tools.ietf.org/html/rfc20#section-4.2.
+func IsPrint(s string) bool {
+	for i := 0; i < len(s); i++ {
+		if s[i] < ' ' || s[i] > '~' {
+			return false
+		}
+	}
+	return true
+}
+
+// Is returns whether s is ASCII.
+func Is(s string) bool {
+	for i := 0; i < len(s); i++ {
+		if s[i] > unicode.MaxASCII {
+			return false
+		}
+	}
+	return true
+}
+
+// ToLower returns the lowercase version of s if s is ASCII and printable.
+func ToLower(s string) (lower string, ok bool) {
+	if !IsPrint(s) {
+		return "", false
+	}
+	return strings.ToLower(s), true
+}
diff --git a/src/net/http/internal/ascii/print_test.go b/src/net/http/internal/ascii/print_test.go
new file mode 100644
index 0000000000..0b7767ca33
--- /dev/null
+++ b/src/net/http/internal/ascii/print_test.go
@@ -0,0 +1,95 @@
+// Copyright 2021 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 ascii
+
+import "testing"
+
+func TestEqualFold(t *testing.T) {
+	var tests = []struct {
+		name string
+		a, b string
+		want bool
+	}{
+		{
+			name: "empty",
+			want: true,
+		},
+		{
+			name: "simple match",
+			a:    "CHUNKED",
+			b:    "chunked",
+			want: true,
+		},
+		{
+			name: "same string",
+			a:    "chunked",
+			b:    "chunked",
+			want: true,
+		},
+		{
+			name: "Unicode Kelvin symbol",
+			a:    "chunKed", // This "K" is 'KELVIN SIGN' (\u212A)
+			b:    "chunked",
+			want: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := EqualFold(tt.a, tt.b); got != tt.want {
+				t.Errorf("AsciiEqualFold(%q,%q): got %v want %v", tt.a, tt.b, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestIsPrint(t *testing.T) {
+	var tests = []struct {
+		name string
+		in   string
+		want bool
+	}{
+		{
+			name: "empty",
+			want: true,
+		},
+		{
+			name: "ASCII low",
+			in:   "This is a space: ' '",
+			want: true,
+		},
+		{
+			name: "ASCII high",
+			in:   "This is a tilde: '~'",
+			want: true,
+		},
+		{
+			name: "ASCII low non-print",
+			in:   "This is a unit separator: \x1F",
+			want: false,
+		},
+		{
+			name: "Ascii high non-print",
+			in:   "This is a Delete: \x7F",
+			want: false,
+		},
+		{
+			name: "Unicode letter",
+			in:   "Today it's 280K outside: it's freezing!", // This "K" is 'KELVIN SIGN' (\u212A)
+			want: false,
+		},
+		{
+			name: "Unicode emoji",
+			in:   "Gophers like 🧀",
+			want: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := IsPrint(tt.in); got != tt.want {
+				t.Errorf("IsASCIIPrint(%q): got %v want %v", tt.in, got, tt.want)
+			}
+		})
+	}
+}
diff --git a/src/net/http/request.go b/src/net/http/request.go
index 4a07eb1c79..7895417af5 100644
--- a/src/net/http/request.go
+++ b/src/net/http/request.go
@@ -19,6 +19,7 @@ import (
 	"mime/multipart"
 	"net"
 	"net/http/httptrace"
+	"net/http/internal/ascii"
 	"net/textproto"
 	"net/url"
 	urlpkg "net/url"
@@ -723,7 +724,7 @@ func idnaASCII(v string) (string, error) {
 	// version does not.
 	// Note that for correct ASCII IDNs ToASCII will only do considerably more
 	// work, but it will not cause an allocation.
-	if isASCII(v) {
+	if ascii.Is(v) {
 		return v, nil
 	}
 	return idna.Lookup.ToASCII(v)
@@ -948,7 +949,7 @@ func (r *Request) BasicAuth() (username, password string, ok bool) {
 func parseBasicAuth(auth string) (username, password string, ok bool) {
 	const prefix = "Basic "
 	// Case insensitive prefix match. See Issue 22736.
-	if len(auth) < len(prefix) || !strings.EqualFold(auth[:len(prefix)], prefix) {
+	if len(auth) < len(prefix) || !ascii.EqualFold(auth[:len(prefix)], prefix) {
 		return
 	}
 	c, err := base64.StdEncoding.DecodeString(auth[len(prefix):])
@@ -1456,5 +1457,5 @@ func requestMethodUsuallyLacksBody(method string) bool {
 // an HTTP/1 connection.
 func (r *Request) requiresHTTP1() bool {
 	return hasToken(r.Header.Get("Connection"), "upgrade") &&
-		strings.EqualFold(r.Header.Get("Upgrade"), "websocket")
+		ascii.EqualFold(r.Header.Get("Upgrade"), "websocket")
 }
diff --git a/src/net/http/transfer.go b/src/net/http/transfer.go
index fbb0c39829..85c2e5a360 100644
--- a/src/net/http/transfer.go
+++ b/src/net/http/transfer.go
@@ -12,6 +12,7 @@ import (
 	"io"
 	"net/http/httptrace"
 	"net/http/internal"
+	"net/http/internal/ascii"
 	"net/textproto"
 	"reflect"
 	"sort"
@@ -638,7 +639,7 @@ func (t *transferReader) parseTransferEncoding() error {
 	if len(raw) != 1 {
 		return &unsupportedTEError{fmt.Sprintf("too many transfer encodings: %q", raw)}
 	}
-	if strings.ToLower(textproto.TrimString(raw[0])) != "chunked" {
+	if !ascii.EqualFold(textproto.TrimString(raw[0]), "chunked") {
 		return &unsupportedTEError{fmt.Sprintf("unsupported transfer encoding: %q", raw[0])}
 	}
 
diff --git a/src/net/http/transport.go b/src/net/http/transport.go
index 57018d2392..47cb992a50 100644
--- a/src/net/http/transport.go
+++ b/src/net/http/transport.go
@@ -21,6 +21,7 @@ import (
 	"log"
 	"net"
 	"net/http/httptrace"
+	"net/http/internal/ascii"
 	"net/textproto"
 	"net/url"
 	"os"
@@ -2185,7 +2186,7 @@ func (pc *persistConn) readLoop() {
 		}
 
 		resp.Body = body
-		if rc.addedGzip && strings.EqualFold(resp.Header.Get("Content-Encoding"), "gzip") {
+		if rc.addedGzip && ascii.EqualFold(resp.Header.Get("Content-Encoding"), "gzip") {
 			resp.Body = &gzipReader{body: body}
 			resp.Header.Del("Content-Encoding")
 			resp.Header.Del("Content-Length")
-- 
GitLab


From 326a7925179ea669aa9f947dda82e425673cb220 Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Mon, 10 May 2021 03:16:28 +1000
Subject: [PATCH 2036/2400] runtime,syscall: simplify openbsd related build
 tags

openbsd/mips64 is now the only openbsd port that uses non-libc syscall - revise
build tags to reflect this.

Update #36435

Change-Id: I357b2dd2926d058e25e618fcca42c388587598a8
Reviewed-on: https://go-review.googlesource.com/c/go/+/317919
Trust: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Mui <cherryyz@google.com>
Run-TryBot: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/os_openbsd_libc.go      | 4 ++--
 src/runtime/os_openbsd_syscall.go   | 4 ++--
 src/runtime/os_openbsd_syscall1.go  | 4 ++--
 src/runtime/os_openbsd_syscall2.go  | 4 ++--
 src/runtime/sys_libc.go             | 4 ++--
 src/runtime/sys_openbsd.go          | 4 ++--
 src/runtime/sys_openbsd1.go         | 4 ++--
 src/runtime/sys_openbsd2.go         | 4 ++--
 src/runtime/sys_openbsd3.go         | 4 ++--
 src/syscall/exec_bsd.go             | 4 ++--
 src/syscall/exec_libc2.go           | 4 ++--
 src/syscall/syscall_openbsd1.go     | 4 ++--
 src/syscall/syscall_openbsd_libc.go | 4 ++--
 13 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/src/runtime/os_openbsd_libc.go b/src/runtime/os_openbsd_libc.go
index 8150753796..0a342e5533 100644
--- a/src/runtime/os_openbsd_libc.go
+++ b/src/runtime/os_openbsd_libc.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm) || (openbsd && arm64)
-// +build openbsd,386 openbsd,amd64 openbsd,arm openbsd,arm64
+//go:build openbsd && !mips64
+// +build openbsd,!mips64
 
 package runtime
 
diff --git a/src/runtime/os_openbsd_syscall.go b/src/runtime/os_openbsd_syscall.go
index 94e851cde8..3cdcb6c707 100644
--- a/src/runtime/os_openbsd_syscall.go
+++ b/src/runtime/os_openbsd_syscall.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build openbsd && !386 && openbsd && !amd64 && openbsd && !arm && openbsd && !arm64
-// +build openbsd,!386,openbsd,!amd64,openbsd,!arm,openbsd,!arm64
+//go:build openbsd && mips64
+// +build openbsd,mips64
 
 package runtime
 
diff --git a/src/runtime/os_openbsd_syscall1.go b/src/runtime/os_openbsd_syscall1.go
index f8f666890a..c20ee8300e 100644
--- a/src/runtime/os_openbsd_syscall1.go
+++ b/src/runtime/os_openbsd_syscall1.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build openbsd && !386 && !amd64 && !arm && !arm64
-// +build openbsd,!386,!amd64,!arm,!arm64
+//go:build openbsd && mips64
+// +build openbsd,mips64
 
 package runtime
 
diff --git a/src/runtime/os_openbsd_syscall2.go b/src/runtime/os_openbsd_syscall2.go
index 84543acec4..af1997131f 100644
--- a/src/runtime/os_openbsd_syscall2.go
+++ b/src/runtime/os_openbsd_syscall2.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build openbsd && !386 && !amd64 && !arm && !arm64
-// +build openbsd,!386,!amd64,!arm,!arm64
+//go:build openbsd && mips64
+// +build openbsd,mips64
 
 package runtime
 
diff --git a/src/runtime/sys_libc.go b/src/runtime/sys_libc.go
index 346b1ab285..b1a9f8b536 100644
--- a/src/runtime/sys_libc.go
+++ b/src/runtime/sys_libc.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build darwin || (openbsd && 386) || (openbsd && amd64) || (openbsd && arm) || (openbsd && arm64)
-// +build darwin openbsd,386 openbsd,amd64 openbsd,arm openbsd,arm64
+//go:build darwin || (openbsd && !mips64)
+// +build darwin openbsd,!mips64
 
 package runtime
 
diff --git a/src/runtime/sys_openbsd.go b/src/runtime/sys_openbsd.go
index 89203bf85f..ab3149558b 100644
--- a/src/runtime/sys_openbsd.go
+++ b/src/runtime/sys_openbsd.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm) || (openbsd && arm64)
-// +build openbsd,386 openbsd,amd64 openbsd,arm openbsd,arm64
+//go:build openbsd && !mips64
+// +build openbsd,!mips64
 
 package runtime
 
diff --git a/src/runtime/sys_openbsd1.go b/src/runtime/sys_openbsd1.go
index 1af48539fa..6f9ad356d4 100644
--- a/src/runtime/sys_openbsd1.go
+++ b/src/runtime/sys_openbsd1.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm) || (openbsd && arm64)
-// +build openbsd,386 openbsd,amd64 openbsd,arm openbsd,arm64
+//go:build openbsd && !mips64
+// +build openbsd,!mips64
 
 package runtime
 
diff --git a/src/runtime/sys_openbsd2.go b/src/runtime/sys_openbsd2.go
index 2d53f67a61..cd1a4e879f 100644
--- a/src/runtime/sys_openbsd2.go
+++ b/src/runtime/sys_openbsd2.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm) || (openbsd && arm64)
-// +build openbsd,386 openbsd,amd64 openbsd,arm openbsd,arm64
+//go:build openbsd && !mips64
+// +build openbsd,!mips64
 
 package runtime
 
diff --git a/src/runtime/sys_openbsd3.go b/src/runtime/sys_openbsd3.go
index 4ef0bdcf77..8d77a4b216 100644
--- a/src/runtime/sys_openbsd3.go
+++ b/src/runtime/sys_openbsd3.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm) || (openbsd && arm64)
-// +build openbsd,386 openbsd,amd64 openbsd,arm openbsd,arm64
+//go:build openbsd && !mips64
+// +build openbsd,!mips64
 
 package runtime
 
diff --git a/src/syscall/exec_bsd.go b/src/syscall/exec_bsd.go
index 569dd675ed..709066e809 100644
--- a/src/syscall/exec_bsd.go
+++ b/src/syscall/exec_bsd.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build dragonfly || freebsd || netbsd || (openbsd && !386 && !amd64 && !arm && !arm64)
-// +build dragonfly freebsd netbsd openbsd,!386,!amd64,!arm,!arm64
+//go:build dragonfly || freebsd || netbsd || (openbsd && mips64)
+// +build dragonfly freebsd netbsd openbsd,mips64
 
 package syscall
 
diff --git a/src/syscall/exec_libc2.go b/src/syscall/exec_libc2.go
index 7442d59aff..b999754c2e 100644
--- a/src/syscall/exec_libc2.go
+++ b/src/syscall/exec_libc2.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build darwin || (openbsd && 386) || (openbsd && amd64) || (openbsd && arm) || (openbsd && arm64)
-// +build darwin openbsd,386 openbsd,amd64 openbsd,arm openbsd,arm64
+//go:build darwin || (openbsd && !mips64)
+// +build darwin openbsd,!mips64
 
 package syscall
 
diff --git a/src/syscall/syscall_openbsd1.go b/src/syscall/syscall_openbsd1.go
index 450f384831..15870ce1ee 100644
--- a/src/syscall/syscall_openbsd1.go
+++ b/src/syscall/syscall_openbsd1.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build openbsd && !386 && !amd64 && !arm && !arm64
-// +build openbsd,!386,!amd64,!arm,!arm64
+//go:build openbsd && mips64
+// +build openbsd,mips64
 
 package syscall
 
diff --git a/src/syscall/syscall_openbsd_libc.go b/src/syscall/syscall_openbsd_libc.go
index 2390912b0f..e67ee4e571 100644
--- a/src/syscall/syscall_openbsd_libc.go
+++ b/src/syscall/syscall_openbsd_libc.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm) || (openbsd && arm64)
-// +build openbsd,386 openbsd,amd64 openbsd,arm openbsd,arm64
+//go:build openbsd && !mips64
+// +build openbsd,!mips64
 
 package syscall
 
-- 
GitLab


From 2520e72d3bbfe6651cd6324077afdb4babb36b9a Mon Sep 17 00:00:00 2001
From: Michael Pratt <mpratt@google.com>
Date: Mon, 10 May 2021 16:50:32 -0400
Subject: [PATCH 2037/2400] runtime: hold sched.lock across atomic
 pidleget/pidleput

As a cleanup, golang.org/cl/307914 unintentionally caused the idle GC
work recheck to drop sched.lock between acquiring a P and committing to
keep it (once a worker G was found).

This is unsafe, as releasing a P requires extra checks once sched.lock
is taken (such as for runSafePointFn). Since checkIdleGCNoP does not
perform these extra checks, we can now race with other users.

In the case of #45975, we may hang with this sequence:

1. M1: checkIdleGCNoP takes sched.lock, gets P1, releases sched.lock.
2. M2: forEachP takes sched.lock, iterates over sched.pidle without
   finding P1, releases sched.lock.
3. M1: checkIdleGCNoP puts P1 back in sched.pidle.
4. M2: forEachP waits forever for P1 to run the safePointFn.

Change back to the old behavior of releasing sched.lock only after we
are certain we will keep the P. Thus if we put it back its removal from
sched.pidle was never visible.

Fixes #45975
For #45916
For #45885
For #45884

Change-Id: I191a1800923b206ccaf96bdcdd0bfdad17b532e9
Reviewed-on: https://go-review.googlesource.com/c/go/+/318569
Trust: Michael Pratt <mpratt@google.com>
Run-TryBot: Michael Pratt <mpratt@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
---
 src/runtime/proc.go | 32 +++++++++++++++++++++-----------
 1 file changed, 21 insertions(+), 11 deletions(-)

diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index ba02b14995..378d5e32f5 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -3132,24 +3132,33 @@ func checkIdleGCNoP() (*p, *g) {
 		return nil, nil
 	}
 
-	// Work is available; we can start an idle GC worker only if
-	// there is an available P and available worker G.
+	// Work is available; we can start an idle GC worker only if there is
+	// an available P and available worker G.
 	//
-	// We can attempt to acquire these in either order. Workers are
-	// almost always available (see comment in findRunnableGCWorker
-	// for the one case there may be none). Since we're slightly
-	// less likely to find a P, check for that first.
+	// We can attempt to acquire these in either order, though both have
+	// synchonization concerns (see below). Workers are almost always
+	// available (see comment in findRunnableGCWorker for the one case
+	// there may be none). Since we're slightly less likely to find a P,
+	// check for that first.
+	//
+	// Synchronization: note that we must hold sched.lock until we are
+	// committed to keeping it. Otherwise we cannot put the unnecessary P
+	// back in sched.pidle without performing the full set of idle
+	// transition checks.
+	//
+	// If we were to check gcBgMarkWorkerPool first, we must somehow handle
+	// the assumption in gcControllerState.findRunnableGCWorker that an
+	// empty gcBgMarkWorkerPool is only possible if gcMarkDone is running.
 	lock(&sched.lock)
 	pp := pidleget()
-	unlock(&sched.lock)
 	if pp == nil {
+		unlock(&sched.lock)
 		return nil, nil
 	}
 
-	// Now that we own a P, gcBlackenEnabled can't change
-	// (as it requires STW).
+	// Now that we own a P, gcBlackenEnabled can't change (as it requires
+	// STW).
 	if gcBlackenEnabled == 0 {
-		lock(&sched.lock)
 		pidleput(pp)
 		unlock(&sched.lock)
 		return nil, nil
@@ -3157,12 +3166,13 @@ func checkIdleGCNoP() (*p, *g) {
 
 	node := (*gcBgMarkWorkerNode)(gcBgMarkWorkerPool.pop())
 	if node == nil {
-		lock(&sched.lock)
 		pidleput(pp)
 		unlock(&sched.lock)
 		return nil, nil
 	}
 
+	unlock(&sched.lock)
+
 	return pp, node.gp.ptr()
 }
 
-- 
GitLab


From 9b84814f6e909bfe9054eab30e423bc5e880d137 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Mon, 10 May 2021 19:32:13 +0200
Subject: [PATCH 2038/2400] net/http: check that Unicode-aware functions are
 not used

Change-Id: I398aff06bec95077bfff02bfb067aa949b70c184
Reviewed-on: https://go-review.googlesource.com/c/go/+/318429
Run-TryBot: Filippo Valsorda <filippo@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Roberto Clapis <roberto@golang.org>
Trust: Filippo Valsorda <filippo@golang.org>
---
 src/net/http/http_test.go | 62 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)

diff --git a/src/net/http/http_test.go b/src/net/http/http_test.go
index 3f1d7cee71..0d92fe5f96 100644
--- a/src/net/http/http_test.go
+++ b/src/net/http/http_test.go
@@ -9,9 +9,13 @@ package http
 import (
 	"bytes"
 	"internal/testenv"
+	"io/fs"
 	"net/url"
+	"os"
 	"os/exec"
 	"reflect"
+	"regexp"
+	"strings"
 	"testing"
 )
 
@@ -156,3 +160,61 @@ func BenchmarkCopyValues(b *testing.B) {
 		b.Fatal("Benchmark wasn't run")
 	}
 }
+
+var forbiddenStringsFunctions = map[string]bool{
+	// Functions that use Unicode-aware case folding.
+	"EqualFold":      true,
+	"Title":          true,
+	"ToLower":        true,
+	"ToLowerSpecial": true,
+	"ToTitle":        true,
+	"ToTitleSpecial": true,
+	"ToUpper":        true,
+	"ToUpperSpecial": true,
+
+	// Functions that use Unicode-aware spaces.
+	"Fields":    true,
+	"TrimSpace": true,
+}
+
+// TestNoUnicodeStrings checks that nothing in net/http uses the Unicode-aware
+// strings and bytes package functions. HTTP is mostly ASCII based, and doing
+// Unicode-aware case folding or space stripping can introduce vulnerabilities.
+func TestNoUnicodeStrings(t *testing.T) {
+	if !testenv.HasSrc() {
+		t.Skip("source code not available")
+	}
+
+	re := regexp.MustCompile(`(strings|bytes).([A-Za-z]+)`)
+	if err := fs.WalkDir(os.DirFS("."), ".", func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if path == "internal/ascii" {
+			return fs.SkipDir
+		}
+		if !strings.HasSuffix(path, ".go") ||
+			strings.HasSuffix(path, "_test.go") ||
+			path == "h2_bundle.go" || d.IsDir() {
+			return nil
+		}
+
+		contents, err := os.ReadFile(path)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for lineNum, line := range strings.Split(string(contents), "\n") {
+			for _, match := range re.FindAllStringSubmatch(line, -1) {
+				if !forbiddenStringsFunctions[match[2]] {
+					continue
+				}
+				t.Errorf("disallowed call to %s at %s:%d", match[0], path, lineNum+1)
+			}
+		}
+
+		return nil
+	}); err != nil {
+		t.Fatal(err)
+	}
+}
-- 
GitLab


From 9995c6b50aa55c1cc1236d1d688929df512dad53 Mon Sep 17 00:00:00 2001
From: Manlio Perillo <manlio.perillo@gmail.com>
Date: Tue, 11 May 2021 17:02:20 +0200
Subject: [PATCH 2039/2400] cmd/go: ignore implicit imports when the -find flag
 is set

The documentation of the go list -find flag says that the Deps list will
be empty. However the current implementation adds implicit imports when
supporting Cgo or SWIG and when linking a main package.

Update the documentation of PackageOpts.IgnoreImport to clarify that
both explicit and implicit imports are ignored.

Add a regression test.

Fixes #46092

Change-Id: I37847528d84adb7a18eb6ff29e4af4b4318a66fe
Reviewed-on: https://go-review.googlesource.com/c/go/+/318770
Trust: Jay Conrod <jayconrod@google.com>
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/load/pkg.go               | 56 ++++++++++---------
 .../go/testdata/script/list_find_nodeps.txt   | 39 +++++++++++++
 2 files changed, 69 insertions(+), 26 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/list_find_nodeps.txt

diff --git a/src/cmd/go/internal/load/pkg.go b/src/cmd/go/internal/load/pkg.go
index 3c7cd44ee3..a3b96702ce 100644
--- a/src/cmd/go/internal/load/pkg.go
+++ b/src/cmd/go/internal/load/pkg.go
@@ -1797,35 +1797,37 @@ func (p *Package) load(ctx context.Context, opts PackageOpts, path string, stk *
 		}
 	}
 
-	// Cgo translation adds imports of "unsafe", "runtime/cgo" and "syscall",
-	// except for certain packages, to avoid circular dependencies.
-	if p.UsesCgo() {
-		addImport("unsafe", true)
-	}
-	if p.UsesCgo() && (!p.Standard || !cgoExclude[p.ImportPath]) && cfg.BuildContext.Compiler != "gccgo" {
-		addImport("runtime/cgo", true)
-	}
-	if p.UsesCgo() && (!p.Standard || !cgoSyscallExclude[p.ImportPath]) {
-		addImport("syscall", true)
-	}
-
-	// SWIG adds imports of some standard packages.
-	if p.UsesSwig() {
-		addImport("unsafe", true)
-		if cfg.BuildContext.Compiler != "gccgo" {
+	if !opts.IgnoreImports {
+		// Cgo translation adds imports of "unsafe", "runtime/cgo" and "syscall",
+		// except for certain packages, to avoid circular dependencies.
+		if p.UsesCgo() {
+			addImport("unsafe", true)
+		}
+		if p.UsesCgo() && (!p.Standard || !cgoExclude[p.ImportPath]) && cfg.BuildContext.Compiler != "gccgo" {
 			addImport("runtime/cgo", true)
 		}
-		addImport("syscall", true)
-		addImport("sync", true)
+		if p.UsesCgo() && (!p.Standard || !cgoSyscallExclude[p.ImportPath]) {
+			addImport("syscall", true)
+		}
 
-		// TODO: The .swig and .swigcxx files can use
-		// %go_import directives to import other packages.
-	}
+		// SWIG adds imports of some standard packages.
+		if p.UsesSwig() {
+			addImport("unsafe", true)
+			if cfg.BuildContext.Compiler != "gccgo" {
+				addImport("runtime/cgo", true)
+			}
+			addImport("syscall", true)
+			addImport("sync", true)
 
-	// The linker loads implicit dependencies.
-	if p.Name == "main" && !p.Internal.ForceLibrary {
-		for _, dep := range LinkerDeps(p) {
-			addImport(dep, false)
+			// TODO: The .swig and .swigcxx files can use
+			// %go_import directives to import other packages.
+		}
+
+		// The linker loads implicit dependencies.
+		if p.Name == "main" && !p.Internal.ForceLibrary {
+			for _, dep := range LinkerDeps(p) {
+				addImport(dep, false)
+			}
 		}
 	}
 
@@ -2387,7 +2389,9 @@ func LoadImportWithFlags(path, srcDir string, parent *Package, stk *ImportStack,
 // PackageOpts control the behavior of PackagesAndErrors and other package
 // loading functions.
 type PackageOpts struct {
-	// IgnoreImports controls whether we ignore imports when loading packages.
+	// IgnoreImports controls whether we ignore explicit and implicit imports
+	// when loading packages.  Implicit imports are added when supporting Cgo
+	// or SWIG and when linking main packages.
 	IgnoreImports bool
 
 	// ModResolveTests indicates whether calls to the module loader should also
diff --git a/src/cmd/go/testdata/script/list_find_nodeps.txt b/src/cmd/go/testdata/script/list_find_nodeps.txt
new file mode 100644
index 0000000000..55f98f6c6c
--- /dev/null
+++ b/src/cmd/go/testdata/script/list_find_nodeps.txt
@@ -0,0 +1,39 @@
+# Issue #46092
+# go list -find should always return a package with an empty Deps list
+
+# The linker loads implicit dependencies
+go list -find -f {{.Deps}} ./cmd
+stdout '\[\]'
+
+# Cgo translation may add imports of "unsafe", "runtime/cgo" and "syscall"
+go list -find -f {{.Deps}} ./cgo
+stdout '\[\]'
+
+# SWIG adds imports of some standard packages
+go list -find -f {{.Deps}} ./swig
+stdout '\[\]'
+
+-- go.mod --
+module listfind
+
+-- cmd/main.go --
+package main
+
+func main() {}
+
+-- cgo/pkg.go --
+package cgopkg
+
+/*
+#include <limits.h>
+*/
+import "C"
+
+func F() {
+    println(C.INT_MAX)
+}
+
+-- swig/pkg.go --
+package swigpkg
+
+-- swig/a.swigcxx --
-- 
GitLab


From 1a0ea1a08b26f25d3795ca46e4a831a8ca4859ad Mon Sep 17 00:00:00 2001
From: Guilherme Souza <32180229+gqgs@users.noreply.github.com>
Date: Tue, 11 May 2021 21:37:56 +0000
Subject: [PATCH 2040/2400] runtime: fix typo in proc.go

Change-Id: I12c0befc5772a5c902a55aeb06a30ec7a34a3bd6
GitHub-Last-Rev: 7d41e1bcb9f6304e1b868701740279e845c99a66
GitHub-Pull-Request: golang/go#46112
Reviewed-on: https://go-review.googlesource.com/c/go/+/319053
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/runtime/proc.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 378d5e32f5..66a06feb24 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -3136,7 +3136,7 @@ func checkIdleGCNoP() (*p, *g) {
 	// an available P and available worker G.
 	//
 	// We can attempt to acquire these in either order, though both have
-	// synchonization concerns (see below). Workers are almost always
+	// synchronization concerns (see below). Workers are almost always
 	// available (see comment in findRunnableGCWorker for the one case
 	// there may be none). Since we're slightly less likely to find a P,
 	// check for that first.
-- 
GitLab


From 485474d204297ce9ff2b7f6c2a2b0e048c61fb8e Mon Sep 17 00:00:00 2001
From: Manlio Perillo <manlio.perillo@gmail.com>
Date: Wed, 12 May 2021 15:16:20 +0200
Subject: [PATCH 2041/2400] cmd/go/testdata/script: fix test failing on nocgo
 builders

The regression test introduced in https://golang.org/cl/318770 broke the
the nocgo builders.

Update the cgo package used in the test to ensure that it can be build
both with cgo enabled and disabled.

Change-Id: Iab0486f0b85ac5e5a22fdf8a1998edd50cbb4d96
Reviewed-on: https://go-review.googlesource.com/c/go/+/319210
Trust: Bryan C. Mills <bcmills@google.com>
Trust: Jay Conrod <jayconrod@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/testdata/script/list_find_nodeps.txt | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/cmd/go/testdata/script/list_find_nodeps.txt b/src/cmd/go/testdata/script/list_find_nodeps.txt
index 55f98f6c6c..e08ce78950 100644
--- a/src/cmd/go/testdata/script/list_find_nodeps.txt
+++ b/src/cmd/go/testdata/script/list_find_nodeps.txt
@@ -33,6 +33,16 @@ func F() {
     println(C.INT_MAX)
 }
 
+-- cgo/pkg_notcgo.go --
+//go:build !cgo
+// +build !cgo
+
+package cgopkg
+
+func F() {
+    println(0)
+}
+
 -- swig/pkg.go --
 package swigpkg
 
-- 
GitLab


From af0f8c149e8a4b237910fc7b41739bedc546473c Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Tue, 11 May 2021 22:40:02 -0400
Subject: [PATCH 2042/2400] cmd/link: don't cast end address to int32

When linking a very large binary, the section address may not fit
in int32. Don't truncate it.

Change-Id: Ibcc8d74bf5662611949e547ce44ca8b973de383f
Reviewed-on: https://go-review.googlesource.com/c/go/+/319289
Trust: Cherry Mui <cherryyz@google.com>
Run-TryBot: Cherry Mui <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/link/internal/ld/elf.go   | 2 +-
 src/cmd/link/internal/ld/macho.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/link/internal/ld/elf.go b/src/cmd/link/internal/ld/elf.go
index 87d88dd957..6f81e74da2 100644
--- a/src/cmd/link/internal/ld/elf.go
+++ b/src/cmd/link/internal/ld/elf.go
@@ -1171,7 +1171,7 @@ func elfrelocsect(ctxt *Link, out *OutBuf, sect *sym.Section, syms []loader.Sym)
 		}
 	}
 
-	eaddr := int32(sect.Vaddr + sect.Length)
+	eaddr := sect.Vaddr + sect.Length
 	for _, s := range syms {
 		if !ldr.AttrReachable(s) {
 			continue
diff --git a/src/cmd/link/internal/ld/macho.go b/src/cmd/link/internal/ld/macho.go
index 642113cf07..45a3971c33 100644
--- a/src/cmd/link/internal/ld/macho.go
+++ b/src/cmd/link/internal/ld/macho.go
@@ -1194,7 +1194,7 @@ func machorelocsect(ctxt *Link, out *OutBuf, sect *sym.Section, syms []loader.Sy
 		}
 	}
 
-	eaddr := int32(sect.Vaddr + sect.Length)
+	eaddr := sect.Vaddr + sect.Length
 	for _, s := range syms {
 		if !ldr.AttrReachable(s) {
 			continue
-- 
GitLab


From e03383a2e233fc89958cff31642dff917d649378 Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Tue, 11 May 2021 22:40:41 -0400
Subject: [PATCH 2043/2400] cmd/link: check mmap error

We already check mmap errors on some code paths, but we missed
one. Add error check there.

Change-Id: Ic0e9cb0eb03c805de40802cfc5d5500e3e065d99
Reviewed-on: https://go-review.googlesource.com/c/go/+/319290
Trust: Cherry Mui <cherryyz@google.com>
Run-TryBot: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/ld/asmb.go   | 5 ++++-
 src/cmd/link/internal/ld/main.go   | 2 +-
 src/cmd/link/internal/ld/outbuf.go | 2 +-
 3 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/cmd/link/internal/ld/asmb.go b/src/cmd/link/internal/ld/asmb.go
index 3754669555..d6ecb2895b 100644
--- a/src/cmd/link/internal/ld/asmb.go
+++ b/src/cmd/link/internal/ld/asmb.go
@@ -167,7 +167,10 @@ func sizeExtRelocs(ctxt *Link, relsize uint32) {
 		}
 	}
 	filesz := ctxt.Out.Offset() + sz
-	ctxt.Out.Mmap(uint64(filesz))
+	err := ctxt.Out.Mmap(uint64(filesz))
+	if err != nil {
+		Exitf("mapping output file failed: %v", err)
+	}
 }
 
 // relocSectFn wraps the function writing relocations of a section
diff --git a/src/cmd/link/internal/ld/main.go b/src/cmd/link/internal/ld/main.go
index adb39d0607..cba0e3d81f 100644
--- a/src/cmd/link/internal/ld/main.go
+++ b/src/cmd/link/internal/ld/main.go
@@ -334,7 +334,7 @@ func Main(arch *sys.Arch, theArch Arch) {
 		// Don't mmap if we're building for Wasm. Wasm file
 		// layout is very different so filesize is meaningless.
 		if err := ctxt.Out.Mmap(filesize); err != nil {
-			panic(err)
+			Exitf("mapping output file failed: %v", err)
 		}
 	}
 	// asmb will redirect symbols to the output file mmap, and relocations
diff --git a/src/cmd/link/internal/ld/outbuf.go b/src/cmd/link/internal/ld/outbuf.go
index 530836ef7c..9d5e8854fe 100644
--- a/src/cmd/link/internal/ld/outbuf.go
+++ b/src/cmd/link/internal/ld/outbuf.go
@@ -160,7 +160,7 @@ func (out *OutBuf) copyHeap() bool {
 	total := uint64(bufLen + heapLen)
 	if heapLen != 0 {
 		if err := out.Mmap(total); err != nil { // Mmap will copy out.heap over to out.buf
-			panic(err)
+			Exitf("mapping output file failed: %v", err)
 		}
 	}
 	return true
-- 
GitLab


From 03886707f9e8db668bd1fd7b8f99799dba0408e3 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 6 May 2021 11:38:46 -0400
Subject: [PATCH 2044/2400] runtime: fix handling of SPWRITE functions in
 traceback

It is valid to see SPWRITE functions at the top of a GC stack traceback,
in the case where they self-preempted during the stack growth check
and haven't actually modified SP in a traceback-unfriendly manner yet.
The current check is therefore too aggressive.

isAsyncSafePoint is taking care of not async-preempting SPWRITE functions
because it doesn't async-preempt any assembly functions at all.
But perhaps it will in the future.

To keep a check that SPWRITE assembly functions are not async-preempted,
add one in preemptPark. Then relax the check in traceback to avoid
triggering on self-preempted SPWRITE functions.

The long and short of this is that the assembly we corrected in x/crypto
issue #44269 was incredibly dodgy but not technically incompatible with
the Go runtime. After this change, the original x/crypto assembly no longer
causes GC traceback crashes during "GOGC=1 go test -count=1000".
But we'll still leave the corrected assembly.

This also means that we don't need to worry about diagnosing SPWRITE
assembly functions that may exist in the wild. They will be skipped for
async preemption and no harm no foul.

Fixes #44269, which was open pending some kind of check for
bad SPWRITE functions in the wild. (No longer needed.)

Change-Id: I6000197b62812bbd2cd92da28eab422634cf75a8
Reviewed-on: https://go-review.googlesource.com/c/go/+/317669
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 src/runtime/preempt.go   |  2 ++
 src/runtime/proc.go      | 15 +++++++++++++++
 src/runtime/traceback.go | 17 ++++++++++++-----
 3 files changed, 29 insertions(+), 5 deletions(-)

diff --git a/src/runtime/preempt.go b/src/runtime/preempt.go
index 372185266f..1d5aae1363 100644
--- a/src/runtime/preempt.go
+++ b/src/runtime/preempt.go
@@ -413,6 +413,8 @@ func isAsyncSafePoint(gp *g, pc, sp, lr uintptr) (bool, uintptr) {
 		//
 		// TODO: Are there cases that are safe but don't have a
 		// locals pointer map, like empty frame functions?
+		// It might be possible to preempt any assembly functions
+		// except the ones that have funcFlag_SPWRITE set in f.flag.
 		return false, 0
 	}
 	name := funcname(f)
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 66a06feb24..ded406cc28 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -3570,6 +3570,21 @@ func preemptPark(gp *g) {
 		throw("bad g status")
 	}
 	gp.waitreason = waitReasonPreempted
+
+	if gp.asyncSafePoint {
+		// Double-check that async preemption does not
+		// happen in SPWRITE assembly functions.
+		// isAsyncSafePoint must exclude this case.
+		f := findfunc(gp.sched.pc)
+		if !f.valid() {
+			throw("preempt at unknown pc")
+		}
+		if f.flag&funcFlag_SPWRITE != 0 {
+			println("runtime: unexpected SPWRITE function", funcname(f), "in async preempt")
+			throw("preempt SPWRITE")
+		}
+	}
+
 	// Transition from _Grunning to _Gscan|_Gpreempted. We can't
 	// be in _Grunning when we dropg because then we'd be running
 	// without an M, but the moment we're in _Gpreempted,
diff --git a/src/runtime/traceback.go b/src/runtime/traceback.go
index 167d51c452..89780edc1f 100644
--- a/src/runtime/traceback.go
+++ b/src/runtime/traceback.go
@@ -219,18 +219,25 @@ func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max in
 			// This function marks the top of the stack. Stop the traceback.
 			frame.lr = 0
 			flr = funcInfo{}
-		} else if flag&funcFlag_SPWRITE != 0 {
+		} else if flag&funcFlag_SPWRITE != 0 && (callback == nil || n > 0) {
 			// The function we are in does a write to SP that we don't know
 			// how to encode in the spdelta table. Examples include context
 			// switch routines like runtime.gogo but also any code that switches
 			// to the g0 stack to run host C code. Since we can't reliably unwind
 			// the SP (we might not even be on the stack we think we are),
 			// we stop the traceback here.
+			// This only applies for profiling signals (callback == nil).
+			//
+			// For a GC stack traversal (callback != nil), we should only see
+			// a function when it has voluntarily preempted itself on entry
+			// during the stack growth check. In that case, the function has
+			// not yet had a chance to do any writes to SP and is safe to unwind.
+			// isAsyncSafePoint does not allow assembly functions to be async preempted,
+			// and preemptPark double-checks that SPWRITE functions are not async preempted.
+			// So for GC stack traversal we leave things alone (this if body does not execute for n == 0)
+			// at the bottom frame of the stack. But farther up the stack we'd better not
+			// find any.
 			if callback != nil {
-				// Finding an SPWRITE should only happen for a profiling signal, which can
-				// arrive at any time. For a GC stack traversal (callback != nil),
-				// we shouldn't see this case, and we must be sure to walk the
-				// entire stack or the GC is invalid. So crash.
 				println("traceback: unexpected SPWRITE function", funcname(f))
 				throw("traceback")
 			}
-- 
GitLab


From 07ff596404b03a8e01ed53f1553c59eb215dc697 Mon Sep 17 00:00:00 2001
From: Jonathan Swinney <jswinney@amazon.com>
Date: Sat, 17 Apr 2021 01:12:28 +0000
Subject: [PATCH 2045/2400] runtime/internal/atomic: add LSE atomics
 instructions to arm64

As a follow up to an earlier change[1] to add ARMv8+LSE instructions in
the compiler generated atomic intrinsics, make the same change in the
runtime library. Since not all ARMv8 systems support LSE instructions,
they are protected by a feature-flag branch.

[1]: golang.org/cl/234217 commit: ecc3f5112eba

Change-Id: I0e2fb22e78d5eddb6547863667a8865946679a00
Reviewed-on: https://go-review.googlesource.com/c/go/+/310591
Reviewed-by: Cherry Mui <cherryyz@google.com>
Run-TryBot: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Heschi Kreinick <heschi@google.com>
---
 src/runtime/internal/atomic/atomic_arm64.go |  9 +-
 src/runtime/internal/atomic/atomic_arm64.s  | 93 +++++++++++++++++----
 2 files changed, 85 insertions(+), 17 deletions(-)

diff --git a/src/runtime/internal/atomic/atomic_arm64.go b/src/runtime/internal/atomic/atomic_arm64.go
index 131c687e1b..3c8736997f 100644
--- a/src/runtime/internal/atomic/atomic_arm64.go
+++ b/src/runtime/internal/atomic/atomic_arm64.go
@@ -7,7 +7,14 @@
 
 package atomic
 
-import "unsafe"
+import (
+	"unsafe"
+	"internal/cpu"
+)
+
+const (
+	offsetARM64HasATOMICS = unsafe.Offsetof(cpu.ARM64.HasATOMICS)
+)
 
 //go:noescape
 func Xadd(ptr *uint32, delta int32) uint32
diff --git a/src/runtime/internal/atomic/atomic_arm64.s b/src/runtime/internal/atomic/atomic_arm64.s
index 587e7f05e2..e9467afecd 100644
--- a/src/runtime/internal/atomic/atomic_arm64.s
+++ b/src/runtime/internal/atomic/atomic_arm64.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+#include "go_asm.h"
 #include "textflag.h"
 
 TEXT ·Casint32(SB), NOSPLIT, $0-17
@@ -127,10 +128,15 @@ TEXT ·Store64(SB), NOSPLIT, $0-16
 TEXT ·Xchg(SB), NOSPLIT, $0-20
 	MOVD	ptr+0(FP), R0
 	MOVW	new+8(FP), R1
-again:
+	MOVBU	internal∕cpu·ARM64+const_offsetARM64HasATOMICS(SB), R4
+	CBZ 	R4, load_store_loop
+	SWPALW	R1, (R0), R2
+	MOVW	R2, ret+16(FP)
+	RET
+load_store_loop:
 	LDAXRW	(R0), R2
 	STLXRW	R1, (R0), R3
-	CBNZ	R3, again
+	CBNZ	R3, load_store_loop
 	MOVW	R2, ret+16(FP)
 	RET
 
@@ -142,10 +148,15 @@ again:
 TEXT ·Xchg64(SB), NOSPLIT, $0-24
 	MOVD	ptr+0(FP), R0
 	MOVD	new+8(FP), R1
-again:
+	MOVBU	internal∕cpu·ARM64+const_offsetARM64HasATOMICS(SB), R4
+	CBZ 	R4, load_store_loop
+	SWPALD	R1, (R0), R2
+	MOVD	R2, ret+16(FP)
+	RET
+load_store_loop:
 	LDAXR	(R0), R2
 	STLXR	R1, (R0), R3
-	CBNZ	R3, again
+	CBNZ	R3, load_store_loop
 	MOVD	R2, ret+16(FP)
 	RET
 
@@ -160,12 +171,20 @@ TEXT ·Cas(SB), NOSPLIT, $0-17
 	MOVD	ptr+0(FP), R0
 	MOVW	old+8(FP), R1
 	MOVW	new+12(FP), R2
-again:
+	MOVBU	internal∕cpu·ARM64+const_offsetARM64HasATOMICS(SB), R4
+	CBZ 	R4, load_store_loop
+	MOVD	R1, R3
+	CASALW	R3, (R0), R2
+	CMP 	R1, R3
+	CSET	EQ, R0
+	MOVB	R0, ret+16(FP)
+	RET
+load_store_loop:
 	LDAXRW	(R0), R3
 	CMPW	R1, R3
 	BNE	ok
 	STLXRW	R2, (R0), R3
-	CBNZ	R3, again
+	CBNZ	R3, load_store_loop
 ok:
 	CSET	EQ, R0
 	MOVB	R0, ret+16(FP)
@@ -183,12 +202,20 @@ TEXT ·Cas64(SB), NOSPLIT, $0-25
 	MOVD	ptr+0(FP), R0
 	MOVD	old+8(FP), R1
 	MOVD	new+16(FP), R2
-again:
+	MOVBU	internal∕cpu·ARM64+const_offsetARM64HasATOMICS(SB), R4
+	CBZ 	R4, load_store_loop
+	MOVD	R1, R3
+	CASALD	R3, (R0), R2
+	CMP 	R1, R3
+	CSET	EQ, R0
+	MOVB	R0, ret+24(FP)
+	RET
+load_store_loop:
 	LDAXR	(R0), R3
 	CMP	R1, R3
 	BNE	ok
 	STLXR	R2, (R0), R3
-	CBNZ	R3, again
+	CBNZ	R3, load_store_loop
 ok:
 	CSET	EQ, R0
 	MOVB	R0, ret+24(FP)
@@ -201,11 +228,17 @@ ok:
 TEXT ·Xadd(SB), NOSPLIT, $0-20
 	MOVD	ptr+0(FP), R0
 	MOVW	delta+8(FP), R1
-again:
+	MOVBU	internal∕cpu·ARM64+const_offsetARM64HasATOMICS(SB), R4
+	CBZ 	R4, load_store_loop
+	LDADDALW	R1, (R0), R2
+	ADD 	R1, R2
+	MOVW	R2, ret+16(FP)
+	RET
+load_store_loop:
 	LDAXRW	(R0), R2
 	ADDW	R2, R1, R2
 	STLXRW	R2, (R0), R3
-	CBNZ	R3, again
+	CBNZ	R3, load_store_loop
 	MOVW	R2, ret+16(FP)
 	RET
 
@@ -216,11 +249,17 @@ again:
 TEXT ·Xadd64(SB), NOSPLIT, $0-24
 	MOVD	ptr+0(FP), R0
 	MOVD	delta+8(FP), R1
-again:
+	MOVBU	internal∕cpu·ARM64+const_offsetARM64HasATOMICS(SB), R4
+	CBZ 	R4, load_store_loop
+	LDADDALD	R1, (R0), R2
+	ADD 	R1, R2
+	MOVD	R2, ret+16(FP)
+	RET
+load_store_loop:
 	LDAXR	(R0), R2
 	ADD	R2, R1, R2
 	STLXR	R2, (R0), R3
-	CBNZ	R3, again
+	CBNZ	R3, load_store_loop
 	MOVD	R2, ret+16(FP)
 	RET
 
@@ -236,37 +275,59 @@ TEXT ·Xchguintptr(SB), NOSPLIT, $0-24
 TEXT ·And8(SB), NOSPLIT, $0-9
 	MOVD	ptr+0(FP), R0
 	MOVB	val+8(FP), R1
+	MOVBU	internal∕cpu·ARM64+const_offsetARM64HasATOMICS(SB), R4
+	CBZ 	R4, load_store_loop
+	MVN 	R1, R2
+	LDCLRALB	R2, (R0), R3
+	RET
+load_store_loop:
 	LDAXRB	(R0), R2
 	AND	R1, R2
 	STLXRB	R2, (R0), R3
-	CBNZ	R3, -3(PC)
+	CBNZ	R3, load_store_loop
 	RET
 
 TEXT ·Or8(SB), NOSPLIT, $0-9
 	MOVD	ptr+0(FP), R0
 	MOVB	val+8(FP), R1
+	MOVBU	internal∕cpu·ARM64+const_offsetARM64HasATOMICS(SB), R4
+	CBZ 	R4, load_store_loop
+	LDORALB	R1, (R0), R2
+	RET
+load_store_loop:
 	LDAXRB	(R0), R2
 	ORR	R1, R2
 	STLXRB	R2, (R0), R3
-	CBNZ	R3, -3(PC)
+	CBNZ	R3, load_store_loop
 	RET
 
 // func And(addr *uint32, v uint32)
 TEXT ·And(SB), NOSPLIT, $0-12
 	MOVD	ptr+0(FP), R0
 	MOVW	val+8(FP), R1
+	MOVBU	internal∕cpu·ARM64+const_offsetARM64HasATOMICS(SB), R4
+	CBZ 	R4, load_store_loop
+	MVN 	R1, R2
+	LDCLRALW	R2, (R0), R3
+	RET
+load_store_loop:
 	LDAXRW	(R0), R2
 	AND	R1, R2
 	STLXRW	R2, (R0), R3
-	CBNZ	R3, -3(PC)
+	CBNZ	R3, load_store_loop
 	RET
 
 // func Or(addr *uint32, v uint32)
 TEXT ·Or(SB), NOSPLIT, $0-12
 	MOVD	ptr+0(FP), R0
 	MOVW	val+8(FP), R1
+	MOVBU	internal∕cpu·ARM64+const_offsetARM64HasATOMICS(SB), R4
+	CBZ 	R4, load_store_loop
+	LDORALW	R1, (R0), R2
+	RET
+load_store_loop:
 	LDAXRW	(R0), R2
 	ORR	R1, R2
 	STLXRW	R2, (R0), R3
-	CBNZ	R3, -3(PC)
+	CBNZ	R3, load_store_loop
 	RET
-- 
GitLab


From 3b321a9d122f0dbf8b333cc79bbf61218e3d05ba Mon Sep 17 00:00:00 2001
From: Ruslan Andreev <ruslan.andreev@huawei.com>
Date: Tue, 19 Jan 2021 22:30:10 +0800
Subject: [PATCH 2046/2400] cmd/compile: add arch-specific inlining for
 runtime.memmove

This CL add runtime.memmove inlining for AMD64 and ARM64.
According to ssa dump from testcases generic rules can't inline
memmomve properly due to one of the arguments is Phi operation. But this
Phi op will be optimized out by later optimization stages. As a result
memmove can be inlined during arch-specific rules.
The commit add new optimization rules to arch-specific rules that can
inline runtime.memmove if it possible during lowering stage.
Optimization fires 5 times in Go source-code using regabi.

Fixes #41662

Change-Id: Iaffaf4c482d068b5f0683d141863892202cc8824
Reviewed-on: https://go-review.googlesource.com/c/go/+/289151
Reviewed-by: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: David Chase <drchase@google.com>
---
 src/cmd/compile/internal/ssa/gen/AMD64.rules  | 19 +++++
 src/cmd/compile/internal/ssa/gen/ARM64.rules  |  9 +++
 .../compile/internal/ssa/gen/generic.rules    |  6 +-
 src/cmd/compile/internal/ssa/rewriteAMD64.go  | 74 +++++++++++++++++++
 src/cmd/compile/internal/ssa/rewriteARM64.go  | 50 +++++++++++++
 test/codegen/copy.go                          | 36 +++++++++
 6 files changed, 191 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules
index ec91ea1513..4cd00732fc 100644
--- a/src/cmd/compile/internal/ssa/gen/AMD64.rules
+++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules
@@ -2216,3 +2216,22 @@
 (MOVOstore [dstOff] {dstSym} ptr (MOVOload [srcOff] {srcSym} (SB) _) mem) && symIsRO(srcSym) =>
   (MOVQstore [dstOff+8] {dstSym} ptr (MOVQconst [int64(read64(srcSym, int64(srcOff)+8, config.ctxt.Arch.ByteOrder))])
     (MOVQstore [dstOff] {dstSym} ptr (MOVQconst [int64(read64(srcSym, int64(srcOff), config.ctxt.Arch.ByteOrder))]) mem))
+
+// Arch-specific inlining for small or disjoint runtime.memmove
+// Match post-lowering calls, memory version.
+(SelectN [0] call:(CALLstatic {sym} s1:(MOVQstoreconst _ [sc] s2:(MOVQstore _ src s3:(MOVQstore _ dst mem)))))
+	&& sc.Val64() >= 0
+	&& isSameCall(sym, "runtime.memmove")
+	&& s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1
+	&& isInlinableMemmove(dst, src, sc.Val64(), config)
+	&& clobber(s1, s2, s3, call)
+	=> (Move [sc.Val64()] dst src mem)
+
+// Match post-lowering calls, register version.
+(SelectN [0] call:(CALLstatic {sym} dst src (MOVQconst [sz]) mem))
+	&& sz >= 0
+	&& isSameCall(sym, "runtime.memmove")
+	&& call.Uses == 1
+	&& isInlinableMemmove(dst, src, sz, config)
+	&& clobber(call)
+	=> (Move [sz] dst src mem)
diff --git a/src/cmd/compile/internal/ssa/gen/ARM64.rules b/src/cmd/compile/internal/ssa/gen/ARM64.rules
index 3d2759493e..62699f290c 100644
--- a/src/cmd/compile/internal/ssa/gen/ARM64.rules
+++ b/src/cmd/compile/internal/ssa/gen/ARM64.rules
@@ -2859,3 +2859,12 @@
 (MOVHUload [off] {sym} (SB) _) && symIsRO(sym) => (MOVDconst [int64(read16(sym, int64(off), config.ctxt.Arch.ByteOrder))])
 (MOVWUload [off] {sym} (SB) _) && symIsRO(sym) => (MOVDconst [int64(read32(sym, int64(off), config.ctxt.Arch.ByteOrder))])
 (MOVDload  [off] {sym} (SB) _) && symIsRO(sym) => (MOVDconst [int64(read64(sym, int64(off), config.ctxt.Arch.ByteOrder))])
+
+// Arch-specific inlining for small or disjoint runtime.memmove
+(SelectN [0] call:(CALLstatic {sym} s1:(MOVDstore _ (MOVDconst [sz]) s2:(MOVDstore  _ src s3:(MOVDstore {t} _ dst mem)))))
+	&& sz >= 0
+	&& isSameCall(sym, "runtime.memmove")
+	&& s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1
+	&& isInlinableMemmove(dst, src, sz, config)
+	&& clobber(s1, s2, s3, call)
+	=> (Move [sz] dst src mem)
diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules
index aad7600d79..5cbc70cf41 100644
--- a/src/cmd/compile/internal/ssa/gen/generic.rules
+++ b/src/cmd/compile/internal/ssa/gen/generic.rules
@@ -2065,7 +2065,7 @@
 (SelectN [0] call:(StaticCall {sym} s1:(Store _ (Const(64|32) [sz]) s2:(Store  _ src s3:(Store {t} _ dst mem)))))
 	&& sz >= 0
 	&& isSameCall(sym, "runtime.memmove")
-	&& t.IsPtr() // avoids TUINTPTR, see issue 30061
+	&& t.IsPtr() // avoids TUNSAFEPTR, see issue 30061
 	&& s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1
 	&& isInlinableMemmove(dst, src, int64(sz), config)
 	&& clobber(s1, s2, s3, call)
@@ -2076,7 +2076,7 @@
 	&& sz >= 0
 	&& call.Uses == 1 // this will exclude all calls with results
 	&& isSameCall(sym, "runtime.memmove")
-	&& dst.Type.IsPtr() // avoids TUINTPTR, see issue 30061
+	&& dst.Type.IsPtr() // avoids TUNSAFEPTR, see issue 30061
 	&& isInlinableMemmove(dst, src, int64(sz), config)
 	&& clobber(call)
 	=> (Move {dst.Type.Elem()} [int64(sz)] dst src mem)
@@ -2086,7 +2086,7 @@
 	&& sz >= 0
 	&& call.Uses == 1 // this will exclude all calls with results
 	&& isSameCall(sym, "runtime.memmove")
-	&& dst.Type.IsPtr() // avoids TUINTPTR, see issue 30061
+	&& dst.Type.IsPtr() // avoids TUNSAFEPTR, see issue 30061
 	&& isInlinableMemmove(dst, src, int64(sz), config)
 	&& clobber(call)
 	=> (Move {dst.Type.Elem()} [int64(sz)] dst src mem)
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index efb5d27145..5045ba7351 100644
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -1038,6 +1038,8 @@ func rewriteValueAMD64(v *Value) bool {
 		return rewriteValueAMD64_OpSelect0(v)
 	case OpSelect1:
 		return rewriteValueAMD64_OpSelect1(v)
+	case OpSelectN:
+		return rewriteValueAMD64_OpSelectN(v)
 	case OpSignExt16to32:
 		v.Op = OpAMD64MOVWQSX
 		return true
@@ -32981,6 +32983,78 @@ func rewriteValueAMD64_OpSelect1(v *Value) bool {
 	}
 	return false
 }
+func rewriteValueAMD64_OpSelectN(v *Value) bool {
+	v_0 := v.Args[0]
+	b := v.Block
+	config := b.Func.Config
+	// match: (SelectN [0] call:(CALLstatic {sym} s1:(MOVQstoreconst _ [sc] s2:(MOVQstore _ src s3:(MOVQstore _ dst mem)))))
+	// cond: sc.Val64() >= 0 && isSameCall(sym, "runtime.memmove") && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst, src, sc.Val64(), config) && clobber(s1, s2, s3, call)
+	// result: (Move [sc.Val64()] dst src mem)
+	for {
+		if auxIntToInt64(v.AuxInt) != 0 {
+			break
+		}
+		call := v_0
+		if call.Op != OpAMD64CALLstatic || len(call.Args) != 1 {
+			break
+		}
+		sym := auxToCall(call.Aux)
+		s1 := call.Args[0]
+		if s1.Op != OpAMD64MOVQstoreconst {
+			break
+		}
+		sc := auxIntToValAndOff(s1.AuxInt)
+		_ = s1.Args[1]
+		s2 := s1.Args[1]
+		if s2.Op != OpAMD64MOVQstore {
+			break
+		}
+		_ = s2.Args[2]
+		src := s2.Args[1]
+		s3 := s2.Args[2]
+		if s3.Op != OpAMD64MOVQstore {
+			break
+		}
+		mem := s3.Args[2]
+		dst := s3.Args[1]
+		if !(sc.Val64() >= 0 && isSameCall(sym, "runtime.memmove") && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst, src, sc.Val64(), config) && clobber(s1, s2, s3, call)) {
+			break
+		}
+		v.reset(OpMove)
+		v.AuxInt = int64ToAuxInt(sc.Val64())
+		v.AddArg3(dst, src, mem)
+		return true
+	}
+	// match: (SelectN [0] call:(CALLstatic {sym} dst src (MOVQconst [sz]) mem))
+	// cond: sz >= 0 && isSameCall(sym, "runtime.memmove") && call.Uses == 1 && isInlinableMemmove(dst, src, sz, config) && clobber(call)
+	// result: (Move [sz] dst src mem)
+	for {
+		if auxIntToInt64(v.AuxInt) != 0 {
+			break
+		}
+		call := v_0
+		if call.Op != OpAMD64CALLstatic || len(call.Args) != 4 {
+			break
+		}
+		sym := auxToCall(call.Aux)
+		mem := call.Args[3]
+		dst := call.Args[0]
+		src := call.Args[1]
+		call_2 := call.Args[2]
+		if call_2.Op != OpAMD64MOVQconst {
+			break
+		}
+		sz := auxIntToInt64(call_2.AuxInt)
+		if !(sz >= 0 && isSameCall(sym, "runtime.memmove") && call.Uses == 1 && isInlinableMemmove(dst, src, sz, config) && clobber(call)) {
+			break
+		}
+		v.reset(OpMove)
+		v.AuxInt = int64ToAuxInt(sz)
+		v.AddArg3(dst, src, mem)
+		return true
+	}
+	return false
+}
 func rewriteValueAMD64_OpSlicemask(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
diff --git a/src/cmd/compile/internal/ssa/rewriteARM64.go b/src/cmd/compile/internal/ssa/rewriteARM64.go
index 0ba3951df5..3cdc4d36cb 100644
--- a/src/cmd/compile/internal/ssa/rewriteARM64.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM64.go
@@ -984,6 +984,8 @@ func rewriteValueARM64(v *Value) bool {
 		return rewriteValueARM64_OpSelect0(v)
 	case OpSelect1:
 		return rewriteValueARM64_OpSelect1(v)
+	case OpSelectN:
+		return rewriteValueARM64_OpSelectN(v)
 	case OpSignExt16to32:
 		v.Op = OpARM64MOVHreg
 		return true
@@ -25983,6 +25985,54 @@ func rewriteValueARM64_OpSelect1(v *Value) bool {
 	}
 	return false
 }
+func rewriteValueARM64_OpSelectN(v *Value) bool {
+	v_0 := v.Args[0]
+	b := v.Block
+	config := b.Func.Config
+	// match: (SelectN [0] call:(CALLstatic {sym} s1:(MOVDstore _ (MOVDconst [sz]) s2:(MOVDstore _ src s3:(MOVDstore {t} _ dst mem)))))
+	// cond: sz >= 0 && isSameCall(sym, "runtime.memmove") && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst, src, sz, config) && clobber(s1, s2, s3, call)
+	// result: (Move [sz] dst src mem)
+	for {
+		if auxIntToInt64(v.AuxInt) != 0 {
+			break
+		}
+		call := v_0
+		if call.Op != OpARM64CALLstatic {
+			break
+		}
+		sym := auxToCall(call.Aux)
+		s1 := call.Args[0]
+		if s1.Op != OpARM64MOVDstore {
+			break
+		}
+		_ = s1.Args[2]
+		s1_1 := s1.Args[1]
+		if s1_1.Op != OpARM64MOVDconst {
+			break
+		}
+		sz := auxIntToInt64(s1_1.AuxInt)
+		s2 := s1.Args[2]
+		if s2.Op != OpARM64MOVDstore {
+			break
+		}
+		_ = s2.Args[2]
+		src := s2.Args[1]
+		s3 := s2.Args[2]
+		if s3.Op != OpARM64MOVDstore {
+			break
+		}
+		mem := s3.Args[2]
+		dst := s3.Args[1]
+		if !(sz >= 0 && isSameCall(sym, "runtime.memmove") && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst, src, sz, config) && clobber(s1, s2, s3, call)) {
+			break
+		}
+		v.reset(OpMove)
+		v.AuxInt = int64ToAuxInt(sz)
+		v.AddArg3(dst, src, mem)
+		return true
+	}
+	return false
+}
 func rewriteValueARM64_OpSlicemask(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
diff --git a/test/codegen/copy.go b/test/codegen/copy.go
index 0cd86d1161..ea8a01f803 100644
--- a/test/codegen/copy.go
+++ b/test/codegen/copy.go
@@ -97,6 +97,42 @@ func moveDisjointNoOverlap(a *[256]byte) {
 	copy(a[:], a[128:])
 }
 
+// Check arch-specific memmove lowering. See issue 41662 fot details
+
+func moveArchLowering1(b []byte, x *[1]byte) {
+	_ = b[1]
+	// amd64:-".*memmove"
+	// arm64:-".*memmove"
+	copy(b, x[:])
+}
+
+func moveArchLowering2(b []byte, x *[2]byte) {
+	_ = b[2]
+	// amd64:-".*memmove"
+	// arm64:-".*memmove"
+	copy(b, x[:])
+}
+
+func moveArchLowering4(b []byte, x *[4]byte) {
+	_ = b[4]
+	// amd64:-".*memmove"
+	// arm64:-".*memmove"
+	copy(b, x[:])
+}
+
+func moveArchLowering8(b []byte, x *[8]byte) {
+	_ = b[8]
+	// amd64:-".*memmove"
+	// arm64:-".*memmove"
+	copy(b, x[:])
+}
+
+func moveArchLowering16(b []byte, x *[16]byte) {
+	_ = b[16]
+	// amd64:-".*memmove"
+	copy(b, x[:])
+}
+
 // Check that no branches are generated when the pointers are [not] equal.
 
 func ptrEqual() {
-- 
GitLab


From f93b951f33add708d9e745e95a29ebe98f3e1255 Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Wed, 12 May 2021 13:08:16 -0400
Subject: [PATCH 2047/2400] cmd/compile/abi-internal.md: fix table format

The table was not rendered correctly because one line missed a
column.

Change-Id: I1373e4e9fb8b8f2dcd9fd0db339083362cce9b71
Reviewed-on: https://go-review.googlesource.com/c/go/+/319291
Trust: Cherry Mui <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/abi-internal.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/abi-internal.md b/src/cmd/compile/abi-internal.md
index f901e707be..1ae3c2538f 100644
--- a/src/cmd/compile/abi-internal.md
+++ b/src/cmd/compile/abi-internal.md
@@ -402,7 +402,7 @@ without corrupting arguments or results.
 Special-purpose registers are as follows:
 
 | Register | Call meaning | Return meaning | Body meaning |
-| --- | --- | --- |
+| --- | --- | --- | --- |
 | RSP | Stack pointer | Same | Same |
 | RBP | Frame pointer | Same | Same |
 | RDX | Closure context pointer | Scratch | Scratch |
-- 
GitLab


From 6db7480f5973ced97dfb08f949889e2ff108a492 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Tue, 11 May 2021 10:15:57 -0400
Subject: [PATCH 2048/2400] cmd/go/internal/modload: in updateLazyRoots, do not
 require the main module explicitly

Fixes #46078

Change-Id: I8044dac717459f1eeae1d8381a6503f22f9f51ff
Reviewed-on: https://go-review.googlesource.com/c/go/+/319009
Trust: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modload/buildlist.go      |  3 +-
 .../go/testdata/script/mod_tidy_lazy_self.txt | 71 +++++++++++++++++++
 2 files changed, 73 insertions(+), 1 deletion(-)
 create mode 100644 src/cmd/go/testdata/script/mod_tidy_lazy_self.txt

diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index 7a0cea405e..e5db41c748 100644
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -815,7 +815,8 @@ func updateLazyRoots(ctx context.Context, direct map[string]bool, rs *Requiremen
 
 		roots = make([]module.Version, 0, len(rs.rootModules))
 		rootsUpgraded = false
-		inRootPaths := make(map[string]bool, len(rs.rootModules))
+		inRootPaths := make(map[string]bool, len(rs.rootModules)+1)
+		inRootPaths[Target.Path] = true
 		for _, m := range rs.rootModules {
 			if inRootPaths[m.Path] {
 				// This root specifies a redundant path. We already retained the
diff --git a/src/cmd/go/testdata/script/mod_tidy_lazy_self.txt b/src/cmd/go/testdata/script/mod_tidy_lazy_self.txt
new file mode 100644
index 0000000000..ffcea18603
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_tidy_lazy_self.txt
@@ -0,0 +1,71 @@
+# Regression test for https://golang.org/issue/46078:
+# 'go mod tidy' should not panic if the main module initially
+# requires an older version of itself.
+
+
+# A module that explicitly requires an older version of itself should be
+# rejected as inconsistent: we enforce that every explicit requirement is the
+# selected version of its module path, but the selected version of the main
+# module is always itself — not some explicit version.
+
+! go list -m all
+stderr '^go: updates to go\.mod needed; to update it:\n\tgo mod tidy$'
+
+
+# The suggested 'go mod tidy' command should succeed (not crash).
+
+go mod tidy
+
+
+# We prune out redundant roots very early on in module loading, and at that
+# point the indirect requirement on example.net/x v0.1.0 appears to be
+# irrelevant. It should be pruned out; when the import of "example.net/x" is
+# later resolved, it should resolve at the latest version (v0.2.0), not the
+# version implied by the (former) misleading requirement on the older version of
+# the main module.
+
+cmp go.mod go.mod.tidy
+
+
+-- go.mod --
+module golang.org/issue/46078
+
+go 1.17
+
+replace (
+	example.net/x v0.1.0 => ./x
+	example.net/x v0.2.0 => ./x
+	golang.org/issue/46078 v0.1.0 => ./old
+)
+
+require golang.org/issue/46078 v0.1.0
+-- go.mod.tidy --
+module golang.org/issue/46078
+
+go 1.17
+
+replace (
+	example.net/x v0.1.0 => ./x
+	example.net/x v0.2.0 => ./x
+	golang.org/issue/46078 v0.1.0 => ./old
+)
+
+require example.net/x v0.2.0
+-- issue46078/issue.go --
+package issue46078
+
+import _ "example.net/x"
+
+-- old/go.mod --
+module golang.org/issue/46078
+
+go 1.17
+
+require example.net/x v0.1.0
+
+-- x/go.mod --
+module example.net/x
+
+go 1.17
+-- x/x.go --
+package x
-- 
GitLab


From 2c76a6f7f85365cefb5200b2b3408fd6bd421b3d Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Wed, 12 May 2021 17:55:42 +0200
Subject: [PATCH 2049/2400] all: add //go:build lines to assembly files

Don't add them to files in vendor and cmd/vendor though. These will be
pulled in by updating the respective dependencies.

For #41184

Change-Id: Icc57458c9b3033c347124323f33084c85b224c70
Reviewed-on: https://go-review.googlesource.com/c/go/+/319389
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/compile/internal/ssa/flags_amd64_test.s | 2 --
 src/cmd/compile/internal/ssa/flags_arm64_test.s | 2 --
 src/cmd/dist/vfp_arm.s                          | 3 ++-
 src/cmd/dist/vfp_default.s                      | 3 ++-
 src/crypto/cipher/xor_ppc64x.s                  | 1 +
 src/crypto/md5/md5block_ppc64x.s                | 1 +
 src/crypto/x509/internal/macos/corefoundation.s | 1 +
 src/crypto/x509/internal/macos/security.s       | 1 +
 src/internal/bytealg/compare_mips64x.s          | 1 +
 src/internal/bytealg/compare_mipsx.s            | 1 +
 src/internal/bytealg/compare_ppc64x.s           | 1 +
 src/internal/bytealg/count_ppc64x.s             | 1 +
 src/internal/bytealg/equal_mips64x.s            | 1 +
 src/internal/bytealg/equal_mipsx.s              | 1 +
 src/internal/bytealg/equal_ppc64x.s             | 1 +
 src/internal/bytealg/index_ppc64x.s             | 1 +
 src/internal/bytealg/indexbyte_mips64x.s        | 1 +
 src/internal/bytealg/indexbyte_mipsx.s          | 1 +
 src/internal/bytealg/indexbyte_ppc64x.s         | 1 +
 src/internal/cpu/cpu_x86.s                      | 1 +
 src/math/big/arith_386.s                        | 1 +
 src/math/big/arith_amd64.s                      | 1 +
 src/math/big/arith_arm.s                        | 1 +
 src/math/big/arith_arm64.s                      | 1 +
 src/math/big/arith_mips64x.s                    | 4 +++-
 src/math/big/arith_mipsx.s                      | 4 +++-
 src/math/big/arith_ppc64x.s                     | 4 +++-
 src/math/big/arith_riscv64.s                    | 1 +
 src/math/big/arith_s390x.s                      | 3 ++-
 src/math/big/arith_wasm.s                       | 1 +
 src/math/floor_ppc64x.s                         | 1 +
 src/math/modf_ppc64x.s                          | 1 +
 src/math/sqrt_mipsx.s                           | 1 +
 src/math/sqrt_ppc64x.s                          | 1 +
 src/math/sqrt_riscv64.s                         | 2 --
 src/reflect/asm_mips64x.s                       | 1 +
 src/reflect/asm_mipsx.s                         | 1 +
 src/reflect/asm_ppc64x.s                        | 1 +
 src/runtime/asm_mips64x.s                       | 1 +
 src/runtime/asm_mipsx.s                         | 1 +
 src/runtime/asm_ppc64x.s                        | 1 +
 src/runtime/atomic_mips64x.s                    | 1 +
 src/runtime/atomic_mipsx.s                      | 1 +
 src/runtime/atomic_ppc64x.s                     | 1 +
 src/runtime/cgo/asm_mips64x.s                   | 1 +
 src/runtime/cgo/asm_mipsx.s                     | 1 +
 src/runtime/cgo/asm_ppc64x.s                    | 1 +
 src/runtime/cgo/asm_riscv64.s                   | 2 --
 src/runtime/duff_mips64x.s                      | 1 +
 src/runtime/duff_ppc64x.s                       | 1 +
 src/runtime/internal/atomic/atomic_mips64x.s    | 1 +
 src/runtime/internal/atomic/atomic_mipsx.s      | 1 +
 src/runtime/internal/atomic/atomic_ppc64x.s     | 2 +-
 src/runtime/internal/atomic/sys_nonlinux_arm.s  | 3 ++-
 src/runtime/libfuzzer_amd64.s                   | 1 +
 src/runtime/libfuzzer_arm64.s                   | 1 +
 src/runtime/memclr_386.s                        | 1 +
 src/runtime/memclr_amd64.s                      | 1 +
 src/runtime/memclr_mips64x.s                    | 1 +
 src/runtime/memclr_mipsx.s                      | 1 +
 src/runtime/memclr_ppc64x.s                     | 1 +
 src/runtime/memmove_386.s                       | 1 +
 src/runtime/memmove_amd64.s                     | 1 +
 src/runtime/memmove_mips64x.s                   | 1 +
 src/runtime/memmove_mipsx.s                     | 1 +
 src/runtime/memmove_ppc64x.s                    | 1 +
 src/runtime/mkduff.go                           | 2 ++
 src/runtime/mkpreempt.go                        | 1 +
 src/runtime/msan_amd64.s                        | 1 +
 src/runtime/msan_arm64.s                        | 1 +
 src/runtime/preempt_mips64x.s                   | 1 +
 src/runtime/preempt_mipsx.s                     | 1 +
 src/runtime/preempt_ppc64x.s                    | 1 +
 src/runtime/race_amd64.s                        | 1 +
 src/runtime/race_arm64.s                        | 1 +
 src/runtime/race_ppc64le.s                      | 1 +
 src/runtime/rt0_linux_mips64x.s                 | 1 +
 src/runtime/rt0_linux_mipsx.s                   | 1 +
 src/runtime/sys_aix_ppc64.s                     | 3 ---
 src/runtime/sys_linux_mips64x.s                 | 1 +
 src/runtime/sys_linux_mipsx.s                   | 1 +
 src/runtime/sys_linux_ppc64x.s                  | 1 +
 src/runtime/tls_arm.s                           | 1 +
 src/runtime/tls_mips64x.s                       | 1 +
 src/runtime/tls_mipsx.s                         | 1 +
 src/runtime/tls_ppc64x.s                        | 1 +
 src/runtime/wincallback.go                      | 2 ++
 src/runtime/zcallback_windows.s                 | 2 ++
 src/sync/atomic/asm.s                           | 1 +
 src/sync/atomic/race.s                          | 1 +
 90 files changed, 98 insertions(+), 19 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/flags_amd64_test.s b/src/cmd/compile/internal/ssa/flags_amd64_test.s
index 8bd87019af..7402f6badb 100644
--- a/src/cmd/compile/internal/ssa/flags_amd64_test.s
+++ b/src/cmd/compile/internal/ssa/flags_amd64_test.s
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build amd64
-
 #include "textflag.h"
 
 TEXT ·asmAddFlags(SB),NOSPLIT,$0-24
diff --git a/src/cmd/compile/internal/ssa/flags_arm64_test.s b/src/cmd/compile/internal/ssa/flags_arm64_test.s
index f201bcc994..639d7e3aed 100644
--- a/src/cmd/compile/internal/ssa/flags_arm64_test.s
+++ b/src/cmd/compile/internal/ssa/flags_arm64_test.s
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build arm64
-
 #include "textflag.h"
 
 TEXT ·asmAddFlags(SB),NOSPLIT,$0-24
diff --git a/src/cmd/dist/vfp_arm.s b/src/cmd/dist/vfp_arm.s
index d571f8b82a..525ee9b366 100644
--- a/src/cmd/dist/vfp_arm.s
+++ b/src/cmd/dist/vfp_arm.s
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build gc,arm
+//go:build gc
+// +build gc
 
 #include "textflag.h"
 
diff --git a/src/cmd/dist/vfp_default.s b/src/cmd/dist/vfp_default.s
index 84829beeff..0c1e16b0aa 100644
--- a/src/cmd/dist/vfp_default.s
+++ b/src/cmd/dist/vfp_default.s
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !arm,gc
+//go:build gc && !arm
+// +build gc,!arm
 
 #include "textflag.h"
 
diff --git a/src/crypto/cipher/xor_ppc64x.s b/src/crypto/cipher/xor_ppc64x.s
index 4cef31d0ee..2ba6d9639c 100644
--- a/src/crypto/cipher/xor_ppc64x.s
+++ b/src/crypto/cipher/xor_ppc64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 #include "textflag.h"
diff --git a/src/crypto/md5/md5block_ppc64x.s b/src/crypto/md5/md5block_ppc64x.s
index e1f859e337..8c28ec2473 100644
--- a/src/crypto/md5/md5block_ppc64x.s
+++ b/src/crypto/md5/md5block_ppc64x.s
@@ -10,6 +10,7 @@
 // Licence: I hereby disclaim the copyright on this code and place it
 // in the public domain.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 #include "textflag.h"
diff --git a/src/crypto/x509/internal/macos/corefoundation.s b/src/crypto/x509/internal/macos/corefoundation.s
index a9efaa299d..cda2336c9d 100644
--- a/src/crypto/x509/internal/macos/corefoundation.s
+++ b/src/crypto/x509/internal/macos/corefoundation.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin && !ios
 // +build darwin,!ios
 
 #include "textflag.h"
diff --git a/src/crypto/x509/internal/macos/security.s b/src/crypto/x509/internal/macos/security.s
index 09ce5c6c76..0038f25b27 100644
--- a/src/crypto/x509/internal/macos/security.s
+++ b/src/crypto/x509/internal/macos/security.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin && !ios
 // +build darwin,!ios
 
 #include "textflag.h"
diff --git a/src/internal/bytealg/compare_mips64x.s b/src/internal/bytealg/compare_mips64x.s
index 4f05fceaca..b472e510bc 100644
--- a/src/internal/bytealg/compare_mips64x.s
+++ b/src/internal/bytealg/compare_mips64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips64 || mips64le
 // +build mips64 mips64le
 
 #include "go_asm.h"
diff --git a/src/internal/bytealg/compare_mipsx.s b/src/internal/bytealg/compare_mipsx.s
index 9ac5ba5687..dcc4916e56 100644
--- a/src/internal/bytealg/compare_mipsx.s
+++ b/src/internal/bytealg/compare_mipsx.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips || mipsle
 // +build mips mipsle
 
 #include "go_asm.h"
diff --git a/src/internal/bytealg/compare_ppc64x.s b/src/internal/bytealg/compare_ppc64x.s
index 7819da31cd..83444fa826 100644
--- a/src/internal/bytealg/compare_ppc64x.s
+++ b/src/internal/bytealg/compare_ppc64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 #include "go_asm.h"
diff --git a/src/internal/bytealg/count_ppc64x.s b/src/internal/bytealg/count_ppc64x.s
index a64d7d792d..94163cbd8a 100644
--- a/src/internal/bytealg/count_ppc64x.s
+++ b/src/internal/bytealg/count_ppc64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64le || ppc64
 // +build ppc64le ppc64
 
 #include "go_asm.h"
diff --git a/src/internal/bytealg/equal_mips64x.s b/src/internal/bytealg/equal_mips64x.s
index 641e3ff06c..c2f7d3997e 100644
--- a/src/internal/bytealg/equal_mips64x.s
+++ b/src/internal/bytealg/equal_mips64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips64 || mips64le
 // +build mips64 mips64le
 
 #include "go_asm.h"
diff --git a/src/internal/bytealg/equal_mipsx.s b/src/internal/bytealg/equal_mipsx.s
index 1cabc70178..11e5549e45 100644
--- a/src/internal/bytealg/equal_mipsx.s
+++ b/src/internal/bytealg/equal_mipsx.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips || mipsle
 // +build mips mipsle
 
 #include "go_asm.h"
diff --git a/src/internal/bytealg/equal_ppc64x.s b/src/internal/bytealg/equal_ppc64x.s
index 18171eaedc..5f0fea521b 100644
--- a/src/internal/bytealg/equal_ppc64x.s
+++ b/src/internal/bytealg/equal_ppc64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 #include "go_asm.h"
diff --git a/src/internal/bytealg/index_ppc64x.s b/src/internal/bytealg/index_ppc64x.s
index b7a1e2d7a2..3ed9442125 100644
--- a/src/internal/bytealg/index_ppc64x.s
+++ b/src/internal/bytealg/index_ppc64x.s
@@ -21,6 +21,7 @@
 // work is still needed for a big endian
 // implementation on power9.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 #include "go_asm.h"
diff --git a/src/internal/bytealg/indexbyte_mips64x.s b/src/internal/bytealg/indexbyte_mips64x.s
index 6ebf0dee24..0f377f5a4c 100644
--- a/src/internal/bytealg/indexbyte_mips64x.s
+++ b/src/internal/bytealg/indexbyte_mips64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips64 || mips64le
 // +build mips64 mips64le
 
 #include "go_asm.h"
diff --git a/src/internal/bytealg/indexbyte_mipsx.s b/src/internal/bytealg/indexbyte_mipsx.s
index e44440b5f9..bed015bbd6 100644
--- a/src/internal/bytealg/indexbyte_mipsx.s
+++ b/src/internal/bytealg/indexbyte_mipsx.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips || mipsle
 // +build mips mipsle
 
 #include "go_asm.h"
diff --git a/src/internal/bytealg/indexbyte_ppc64x.s b/src/internal/bytealg/indexbyte_ppc64x.s
index 6e14e80af1..8e13c5a56e 100644
--- a/src/internal/bytealg/indexbyte_ppc64x.s
+++ b/src/internal/bytealg/indexbyte_ppc64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 #include "go_asm.h"
diff --git a/src/internal/cpu/cpu_x86.s b/src/internal/cpu/cpu_x86.s
index 93c712d784..0df5da1cc7 100644
--- a/src/internal/cpu/cpu_x86.s
+++ b/src/internal/cpu/cpu_x86.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build 386 || amd64
 // +build 386 amd64
 
 #include "textflag.h"
diff --git a/src/math/big/arith_386.s b/src/math/big/arith_386.s
index d0ea949fe6..acf2b06665 100644
--- a/src/math/big/arith_386.s
+++ b/src/math/big/arith_386.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !math_big_pure_go
 // +build !math_big_pure_go
 
 #include "textflag.h"
diff --git a/src/math/big/arith_amd64.s b/src/math/big/arith_amd64.s
index 61043ca2d9..59be952200 100644
--- a/src/math/big/arith_amd64.s
+++ b/src/math/big/arith_amd64.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !math_big_pure_go
 // +build !math_big_pure_go
 
 #include "textflag.h"
diff --git a/src/math/big/arith_arm.s b/src/math/big/arith_arm.s
index cbf7445e7a..f2872d80a1 100644
--- a/src/math/big/arith_arm.s
+++ b/src/math/big/arith_arm.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !math_big_pure_go
 // +build !math_big_pure_go
 
 #include "textflag.h"
diff --git a/src/math/big/arith_arm64.s b/src/math/big/arith_arm64.s
index 22357d088e..7bfe08e7b7 100644
--- a/src/math/big/arith_arm64.s
+++ b/src/math/big/arith_arm64.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !math_big_pure_go
 // +build !math_big_pure_go
 
 #include "textflag.h"
diff --git a/src/math/big/arith_mips64x.s b/src/math/big/arith_mips64x.s
index 804b9fe06e..4b5c502440 100644
--- a/src/math/big/arith_mips64x.s
+++ b/src/math/big/arith_mips64x.s
@@ -2,7 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !math_big_pure_go,mips64 !math_big_pure_go,mips64le
+//go:build !math_big_pure_go && (mips64 || mips64le)
+// +build !math_big_pure_go
+// +build mips64 mips64le
 
 #include "textflag.h"
 
diff --git a/src/math/big/arith_mipsx.s b/src/math/big/arith_mipsx.s
index efdecb80f3..e72e6d6377 100644
--- a/src/math/big/arith_mipsx.s
+++ b/src/math/big/arith_mipsx.s
@@ -2,7 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !math_big_pure_go,mips !math_big_pure_go,mipsle
+//go:build !math_big_pure_go && (mips || mipsle)
+// +build !math_big_pure_go
+// +build mips mipsle
 
 #include "textflag.h"
 
diff --git a/src/math/big/arith_ppc64x.s b/src/math/big/arith_ppc64x.s
index b299ccc2fb..68c6286494 100644
--- a/src/math/big/arith_ppc64x.s
+++ b/src/math/big/arith_ppc64x.s
@@ -2,7 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !math_big_pure_go,ppc64 !math_big_pure_go,ppc64le
+//go:build !math_big_pure_go && (ppc64 || ppc64le)
+// +build !math_big_pure_go
+// +build ppc64 ppc64le
 
 #include "textflag.h"
 
diff --git a/src/math/big/arith_riscv64.s b/src/math/big/arith_riscv64.s
index a2f7666c7b..2e950ddd0f 100644
--- a/src/math/big/arith_riscv64.s
+++ b/src/math/big/arith_riscv64.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !math_big_pure_go && riscv64
 // +build !math_big_pure_go,riscv64
 
 #include "textflag.h"
diff --git a/src/math/big/arith_s390x.s b/src/math/big/arith_s390x.s
index e96480699a..ad822f76b3 100644
--- a/src/math/big/arith_s390x.s
+++ b/src/math/big/arith_s390x.s
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !math_big_pure_go,s390x
+//go:build !math_big_pure_go
+// +build !math_big_pure_go
 
 #include "textflag.h"
 
diff --git a/src/math/big/arith_wasm.s b/src/math/big/arith_wasm.s
index add1064469..e8605f1e15 100644
--- a/src/math/big/arith_wasm.s
+++ b/src/math/big/arith_wasm.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !math_big_pure_go
 // +build !math_big_pure_go
 
 #include "textflag.h"
diff --git a/src/math/floor_ppc64x.s b/src/math/floor_ppc64x.s
index 29b92a62c3..584c27e28f 100644
--- a/src/math/floor_ppc64x.s
+++ b/src/math/floor_ppc64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 #include "textflag.h"
diff --git a/src/math/modf_ppc64x.s b/src/math/modf_ppc64x.s
index caa435eef9..1303067661 100644
--- a/src/math/modf_ppc64x.s
+++ b/src/math/modf_ppc64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 #include "textflag.h"
diff --git a/src/math/sqrt_mipsx.s b/src/math/sqrt_mipsx.s
index c619c19ec2..291d4af39c 100644
--- a/src/math/sqrt_mipsx.s
+++ b/src/math/sqrt_mipsx.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips || mipsle
 // +build mips mipsle
 
 #include "textflag.h"
diff --git a/src/math/sqrt_ppc64x.s b/src/math/sqrt_ppc64x.s
index 174b63e35a..c929da2159 100644
--- a/src/math/sqrt_ppc64x.s
+++ b/src/math/sqrt_ppc64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 #include "textflag.h"
diff --git a/src/math/sqrt_riscv64.s b/src/math/sqrt_riscv64.s
index f223510c42..0dbdbc99ed 100644
--- a/src/math/sqrt_riscv64.s
+++ b/src/math/sqrt_riscv64.s
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build riscv64
-
 #include "textflag.h"
 
 // func archSqrt(x float64) float64
diff --git a/src/reflect/asm_mips64x.s b/src/reflect/asm_mips64x.s
index ae661262cb..8d01c5fb7e 100644
--- a/src/reflect/asm_mips64x.s
+++ b/src/reflect/asm_mips64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips64 || mips64le
 // +build mips64 mips64le
 
 #include "textflag.h"
diff --git a/src/reflect/asm_mipsx.s b/src/reflect/asm_mipsx.s
index 47fef844a1..6ea8233108 100644
--- a/src/reflect/asm_mipsx.s
+++ b/src/reflect/asm_mipsx.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips || mipsle
 // +build mips mipsle
 
 #include "textflag.h"
diff --git a/src/reflect/asm_ppc64x.s b/src/reflect/asm_ppc64x.s
index 010811c31a..d955e4110f 100644
--- a/src/reflect/asm_ppc64x.s
+++ b/src/reflect/asm_ppc64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 #include "textflag.h"
diff --git a/src/runtime/asm_mips64x.s b/src/runtime/asm_mips64x.s
index c3b57e472a..d4d2280105 100644
--- a/src/runtime/asm_mips64x.s
+++ b/src/runtime/asm_mips64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips64 || mips64le
 // +build mips64 mips64le
 
 #include "go_asm.h"
diff --git a/src/runtime/asm_mipsx.s b/src/runtime/asm_mipsx.s
index 1d828b03cf..ea7edf20cf 100644
--- a/src/runtime/asm_mipsx.s
+++ b/src/runtime/asm_mipsx.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips || mipsle
 // +build mips mipsle
 
 #include "go_asm.h"
diff --git a/src/runtime/asm_ppc64x.s b/src/runtime/asm_ppc64x.s
index 2c39b38912..942cc14f17 100644
--- a/src/runtime/asm_ppc64x.s
+++ b/src/runtime/asm_ppc64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 #include "go_asm.h"
diff --git a/src/runtime/atomic_mips64x.s b/src/runtime/atomic_mips64x.s
index 6f42412502..e2118e6a20 100644
--- a/src/runtime/atomic_mips64x.s
+++ b/src/runtime/atomic_mips64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips64 || mips64le
 // +build mips64 mips64le
 
 #include "textflag.h"
diff --git a/src/runtime/atomic_mipsx.s b/src/runtime/atomic_mipsx.s
index ed078a2d8a..1eacd273b4 100644
--- a/src/runtime/atomic_mipsx.s
+++ b/src/runtime/atomic_mipsx.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips || mipsle
 // +build mips mipsle
 
 #include "textflag.h"
diff --git a/src/runtime/atomic_ppc64x.s b/src/runtime/atomic_ppc64x.s
index 57f672f330..b63de2dbd3 100644
--- a/src/runtime/atomic_ppc64x.s
+++ b/src/runtime/atomic_ppc64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 #include "textflag.h"
diff --git a/src/runtime/cgo/asm_mips64x.s b/src/runtime/cgo/asm_mips64x.s
index e51cdf3d12..ba948071fa 100644
--- a/src/runtime/cgo/asm_mips64x.s
+++ b/src/runtime/cgo/asm_mips64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips64 || mips64le
 // +build mips64 mips64le
 
 #include "textflag.h"
diff --git a/src/runtime/cgo/asm_mipsx.s b/src/runtime/cgo/asm_mipsx.s
index 1127c8beb4..fd5d78ef97 100644
--- a/src/runtime/cgo/asm_mipsx.s
+++ b/src/runtime/cgo/asm_mipsx.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips || mipsle
 // +build mips mipsle
 
 #include "textflag.h"
diff --git a/src/runtime/cgo/asm_ppc64x.s b/src/runtime/cgo/asm_ppc64x.s
index f4efc1e67d..9dec8d04ce 100644
--- a/src/runtime/cgo/asm_ppc64x.s
+++ b/src/runtime/cgo/asm_ppc64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 #include "textflag.h"
diff --git a/src/runtime/cgo/asm_riscv64.s b/src/runtime/cgo/asm_riscv64.s
index b4ddbb020f..fcd1d36ca8 100644
--- a/src/runtime/cgo/asm_riscv64.s
+++ b/src/runtime/cgo/asm_riscv64.s
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build riscv64
-
 #include "textflag.h"
 
 // Called by C code generated by cmd/cgo.
diff --git a/src/runtime/duff_mips64x.s b/src/runtime/duff_mips64x.s
index c4e04ccc9d..a897d7fd9b 100644
--- a/src/runtime/duff_mips64x.s
+++ b/src/runtime/duff_mips64x.s
@@ -2,6 +2,7 @@
 // Run go generate from src/runtime to update.
 // See mkduff.go for comments.
 
+//go:build mips64 || mips64le
 // +build mips64 mips64le
 
 #include "textflag.h"
diff --git a/src/runtime/duff_ppc64x.s b/src/runtime/duff_ppc64x.s
index d6b89ba940..d4e3b409d2 100644
--- a/src/runtime/duff_ppc64x.s
+++ b/src/runtime/duff_ppc64x.s
@@ -2,6 +2,7 @@
 // Run go generate from src/runtime to update.
 // See mkduff.go for comments.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 #include "textflag.h"
diff --git a/src/runtime/internal/atomic/atomic_mips64x.s b/src/runtime/internal/atomic/atomic_mips64x.s
index 2751c6f808..fba668f94a 100644
--- a/src/runtime/internal/atomic/atomic_mips64x.s
+++ b/src/runtime/internal/atomic/atomic_mips64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips64 || mips64le
 // +build mips64 mips64le
 
 #include "textflag.h"
diff --git a/src/runtime/internal/atomic/atomic_mipsx.s b/src/runtime/internal/atomic/atomic_mipsx.s
index 3f61321450..c0835d66ed 100644
--- a/src/runtime/internal/atomic/atomic_mipsx.s
+++ b/src/runtime/internal/atomic/atomic_mipsx.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips || mipsle
 // +build mips mipsle
 
 #include "textflag.h"
diff --git a/src/runtime/internal/atomic/atomic_ppc64x.s b/src/runtime/internal/atomic/atomic_ppc64x.s
index 37c8515d37..dca26cb334 100644
--- a/src/runtime/internal/atomic/atomic_ppc64x.s
+++ b/src/runtime/internal/atomic/atomic_ppc64x.s
@@ -2,11 +2,11 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 #include "textflag.h"
 
-
 // For more details about how various memory models are
 // enforced on POWER, the following paper provides more
 // details about how they enforce C/C++ like models. This
diff --git a/src/runtime/internal/atomic/sys_nonlinux_arm.s b/src/runtime/internal/atomic/sys_nonlinux_arm.s
index 57568b2238..04036ca970 100644
--- a/src/runtime/internal/atomic/sys_nonlinux_arm.s
+++ b/src/runtime/internal/atomic/sys_nonlinux_arm.s
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !linux,arm
+//go:build !linux
+// +build !linux
 
 #include "textflag.h"
 
diff --git a/src/runtime/libfuzzer_amd64.s b/src/runtime/libfuzzer_amd64.s
index 890fde341b..13645fc7af 100644
--- a/src/runtime/libfuzzer_amd64.s
+++ b/src/runtime/libfuzzer_amd64.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build libfuzzer
 // +build libfuzzer
 
 #include "go_asm.h"
diff --git a/src/runtime/libfuzzer_arm64.s b/src/runtime/libfuzzer_arm64.s
index 121673e092..4ad8242804 100644
--- a/src/runtime/libfuzzer_arm64.s
+++ b/src/runtime/libfuzzer_arm64.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build libfuzzer
 // +build libfuzzer
 
 #include "go_asm.h"
diff --git a/src/runtime/memclr_386.s b/src/runtime/memclr_386.s
index d2ef17f7ce..046c344119 100644
--- a/src/runtime/memclr_386.s
+++ b/src/runtime/memclr_386.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !plan9
 // +build !plan9
 
 #include "go_asm.h"
diff --git a/src/runtime/memclr_amd64.s b/src/runtime/memclr_amd64.s
index 5d2bebb901..a10f57bd8c 100644
--- a/src/runtime/memclr_amd64.s
+++ b/src/runtime/memclr_amd64.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !plan9
 // +build !plan9
 
 #include "go_asm.h"
diff --git a/src/runtime/memclr_mips64x.s b/src/runtime/memclr_mips64x.s
index d7a3251e20..bc037013fe 100644
--- a/src/runtime/memclr_mips64x.s
+++ b/src/runtime/memclr_mips64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips64 || mips64le
 // +build mips64 mips64le
 
 #include "go_asm.h"
diff --git a/src/runtime/memclr_mipsx.s b/src/runtime/memclr_mipsx.s
index eb2a8a7219..3d21c3c414 100644
--- a/src/runtime/memclr_mipsx.s
+++ b/src/runtime/memclr_mipsx.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips || mipsle
 // +build mips mipsle
 
 #include "textflag.h"
diff --git a/src/runtime/memclr_ppc64x.s b/src/runtime/memclr_ppc64x.s
index 7512620894..65639322b2 100644
--- a/src/runtime/memclr_ppc64x.s
+++ b/src/runtime/memclr_ppc64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 #include "textflag.h"
diff --git a/src/runtime/memmove_386.s b/src/runtime/memmove_386.s
index d99546c633..1a43a1f724 100644
--- a/src/runtime/memmove_386.s
+++ b/src/runtime/memmove_386.s
@@ -23,6 +23,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+//go:build !plan9
 // +build !plan9
 
 #include "go_asm.h"
diff --git a/src/runtime/memmove_amd64.s b/src/runtime/memmove_amd64.s
index f1e3403596..24c6529f58 100644
--- a/src/runtime/memmove_amd64.s
+++ b/src/runtime/memmove_amd64.s
@@ -23,6 +23,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+//go:build !plan9
 // +build !plan9
 
 #include "go_asm.h"
diff --git a/src/runtime/memmove_mips64x.s b/src/runtime/memmove_mips64x.s
index 8a1b88afba..fef3c6be82 100644
--- a/src/runtime/memmove_mips64x.s
+++ b/src/runtime/memmove_mips64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips64 || mips64le
 // +build mips64 mips64le
 
 #include "textflag.h"
diff --git a/src/runtime/memmove_mipsx.s b/src/runtime/memmove_mipsx.s
index 6c86558f8d..cd02fc25c4 100644
--- a/src/runtime/memmove_mipsx.s
+++ b/src/runtime/memmove_mipsx.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips || mipsle
 // +build mips mipsle
 
 #include "textflag.h"
diff --git a/src/runtime/memmove_ppc64x.s b/src/runtime/memmove_ppc64x.s
index dbd835506f..fd16ad8129 100644
--- a/src/runtime/memmove_ppc64x.s
+++ b/src/runtime/memmove_ppc64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 #include "textflag.h"
diff --git a/src/runtime/mkduff.go b/src/runtime/mkduff.go
index 8632fe08a3..da191cc594 100644
--- a/src/runtime/mkduff.go
+++ b/src/runtime/mkduff.go
@@ -179,6 +179,7 @@ func copyARM64(w io.Writer) {
 
 func tagsPPC64x(w io.Writer) {
 	fmt.Fprintln(w)
+	fmt.Fprintln(w, "//go:build ppc64 || ppc64le")
 	fmt.Fprintln(w, "// +build ppc64 ppc64le")
 	fmt.Fprintln(w)
 }
@@ -202,6 +203,7 @@ func copyPPC64x(w io.Writer) {
 
 func tagsMIPS64x(w io.Writer) {
 	fmt.Fprintln(w)
+	fmt.Fprintln(w, "//go:build mips64 || mips64le")
 	fmt.Fprintln(w, "// +build mips64 mips64le")
 	fmt.Fprintln(w)
 }
diff --git a/src/runtime/mkpreempt.go b/src/runtime/mkpreempt.go
index 3a9e6cc478..6c980540f5 100644
--- a/src/runtime/mkpreempt.go
+++ b/src/runtime/mkpreempt.go
@@ -123,6 +123,7 @@ func header(arch string) {
 	fmt.Fprintf(out, "// Code generated by mkpreempt.go; DO NOT EDIT.\n\n")
 	if beLe[arch] {
 		base := arch[:len(arch)-1]
+		fmt.Fprintf(out, "//go:build %s || %sle\n", base, base)
 		fmt.Fprintf(out, "// +build %s %sle\n\n", base, base)
 	}
 	fmt.Fprintf(out, "#include \"go_asm.h\"\n")
diff --git a/src/runtime/msan_amd64.s b/src/runtime/msan_amd64.s
index 669e9ca73f..1bb57a3b7e 100644
--- a/src/runtime/msan_amd64.s
+++ b/src/runtime/msan_amd64.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build msan
 // +build msan
 
 #include "go_asm.h"
diff --git a/src/runtime/msan_arm64.s b/src/runtime/msan_arm64.s
index f19906cfc8..93ade8dd89 100644
--- a/src/runtime/msan_arm64.s
+++ b/src/runtime/msan_arm64.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build msan
 // +build msan
 
 #include "go_asm.h"
diff --git a/src/runtime/preempt_mips64x.s b/src/runtime/preempt_mips64x.s
index 0d0c157c36..b755425bc5 100644
--- a/src/runtime/preempt_mips64x.s
+++ b/src/runtime/preempt_mips64x.s
@@ -1,5 +1,6 @@
 // Code generated by mkpreempt.go; DO NOT EDIT.
 
+//go:build mips64 || mips64le
 // +build mips64 mips64le
 
 #include "go_asm.h"
diff --git a/src/runtime/preempt_mipsx.s b/src/runtime/preempt_mipsx.s
index 86d3a918d3..c1bff60859 100644
--- a/src/runtime/preempt_mipsx.s
+++ b/src/runtime/preempt_mipsx.s
@@ -1,5 +1,6 @@
 // Code generated by mkpreempt.go; DO NOT EDIT.
 
+//go:build mips || mipsle
 // +build mips mipsle
 
 #include "go_asm.h"
diff --git a/src/runtime/preempt_ppc64x.s b/src/runtime/preempt_ppc64x.s
index 90634386db..70bd91982b 100644
--- a/src/runtime/preempt_ppc64x.s
+++ b/src/runtime/preempt_ppc64x.s
@@ -1,5 +1,6 @@
 // Code generated by mkpreempt.go; DO NOT EDIT.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 #include "go_asm.h"
diff --git a/src/runtime/race_amd64.s b/src/runtime/race_amd64.s
index 58a919efe8..8d4813eadd 100644
--- a/src/runtime/race_amd64.s
+++ b/src/runtime/race_amd64.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build race
 // +build race
 
 #include "go_asm.h"
diff --git a/src/runtime/race_arm64.s b/src/runtime/race_arm64.s
index 82e3caadc8..c6d5b91edc 100644
--- a/src/runtime/race_arm64.s
+++ b/src/runtime/race_arm64.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build race
 // +build race
 
 #include "go_asm.h"
diff --git a/src/runtime/race_ppc64le.s b/src/runtime/race_ppc64le.s
index 069e4d86dd..963e57099c 100644
--- a/src/runtime/race_ppc64le.s
+++ b/src/runtime/race_ppc64le.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build race
 // +build race
 
 #include "go_asm.h"
diff --git a/src/runtime/rt0_linux_mips64x.s b/src/runtime/rt0_linux_mips64x.s
index 55506755df..fabd8570b5 100644
--- a/src/runtime/rt0_linux_mips64x.s
+++ b/src/runtime/rt0_linux_mips64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (mips64 || mips64le)
 // +build linux
 // +build mips64 mips64le
 
diff --git a/src/runtime/rt0_linux_mipsx.s b/src/runtime/rt0_linux_mipsx.s
index 74b8f50b73..9f5842b51a 100644
--- a/src/runtime/rt0_linux_mipsx.s
+++ b/src/runtime/rt0_linux_mipsx.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (mips || mipsle)
 // +build linux
 // +build mips mipsle
 
diff --git a/src/runtime/sys_aix_ppc64.s b/src/runtime/sys_aix_ppc64.s
index a56d043f42..c171c191c0 100644
--- a/src/runtime/sys_aix_ppc64.s
+++ b/src/runtime/sys_aix_ppc64.s
@@ -2,9 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build aix
-// +build ppc64 ppc64le
-
 //
 // System calls and other sys.stuff for ppc64, Aix
 //
diff --git a/src/runtime/sys_linux_mips64x.s b/src/runtime/sys_linux_mips64x.s
index 0206cb88bd..e18d291445 100644
--- a/src/runtime/sys_linux_mips64x.s
+++ b/src/runtime/sys_linux_mips64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (mips64 || mips64le)
 // +build linux
 // +build mips64 mips64le
 
diff --git a/src/runtime/sys_linux_mipsx.s b/src/runtime/sys_linux_mipsx.s
index d5317d3957..b3970be9cf 100644
--- a/src/runtime/sys_linux_mipsx.s
+++ b/src/runtime/sys_linux_mipsx.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (mips || mipsle)
 // +build linux
 // +build mips mipsle
 
diff --git a/src/runtime/sys_linux_ppc64x.s b/src/runtime/sys_linux_ppc64x.s
index 46387288d5..05b5916db4 100644
--- a/src/runtime/sys_linux_ppc64x.s
+++ b/src/runtime/sys_linux_ppc64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build linux && (ppc64 || ppc64le)
 // +build linux
 // +build ppc64 ppc64le
 
diff --git a/src/runtime/tls_arm.s b/src/runtime/tls_arm.s
index e42de8deb4..879caac9e1 100644
--- a/src/runtime/tls_arm.s
+++ b/src/runtime/tls_arm.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !windows
 // +build !windows
 
 #include "go_asm.h"
diff --git a/src/runtime/tls_mips64x.s b/src/runtime/tls_mips64x.s
index 888c0efec6..779d64ba31 100644
--- a/src/runtime/tls_mips64x.s
+++ b/src/runtime/tls_mips64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips64 || mips64le
 // +build mips64 mips64le
 
 #include "go_asm.h"
diff --git a/src/runtime/tls_mipsx.s b/src/runtime/tls_mipsx.s
index d2ffcd954c..ada8d06a9e 100644
--- a/src/runtime/tls_mipsx.s
+++ b/src/runtime/tls_mipsx.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build mips || mipsle
 // +build mips mipsle
 
 #include "go_asm.h"
diff --git a/src/runtime/tls_ppc64x.s b/src/runtime/tls_ppc64x.s
index 25d796fcc6..7e935d0eb2 100644
--- a/src/runtime/tls_ppc64x.s
+++ b/src/runtime/tls_ppc64x.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build ppc64 || ppc64le
 // +build ppc64 ppc64le
 
 #include "go_asm.h"
diff --git a/src/runtime/wincallback.go b/src/runtime/wincallback.go
index 8411c98412..a7a787d8f6 100644
--- a/src/runtime/wincallback.go
+++ b/src/runtime/wincallback.go
@@ -22,7 +22,9 @@ func genasm386Amd64() {
 
 	buf.WriteString(`// Code generated by wincallback.go using 'go generate'. DO NOT EDIT.
 
+//go:build 386 || amd64
 // +build 386 amd64
+
 // runtime·callbackasm is called by external code to
 // execute Go implemented callback function. It is not
 // called from the start, instead runtime·compilecallback
diff --git a/src/runtime/zcallback_windows.s b/src/runtime/zcallback_windows.s
index 37ffb38aca..e451c2b9d0 100644
--- a/src/runtime/zcallback_windows.s
+++ b/src/runtime/zcallback_windows.s
@@ -1,6 +1,8 @@
 // Code generated by wincallback.go using 'go generate'. DO NOT EDIT.
 
+//go:build 386 || amd64
 // +build 386 amd64
+
 // runtime·callbackasm is called by external code to
 // execute Go implemented callback function. It is not
 // called from the start, instead runtime·compilecallback
diff --git a/src/sync/atomic/asm.s b/src/sync/atomic/asm.s
index f86726f3a1..7b8c9b9430 100644
--- a/src/sync/atomic/asm.s
+++ b/src/sync/atomic/asm.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !race
 // +build !race
 
 #include "textflag.h"
diff --git a/src/sync/atomic/race.s b/src/sync/atomic/race.s
index fd6ca22700..0866487cc7 100644
--- a/src/sync/atomic/race.s
+++ b/src/sync/atomic/race.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build race
 // +build race
 
 // This file is here only to allow external functions.
-- 
GitLab


From 0fa2302ee5db35b4caae6211656f81ebb92cdb0a Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Wed, 12 May 2021 18:07:43 +0200
Subject: [PATCH 2050/2400] cmd/vendor: update golang.org/x/sys to latest

To pull in CL 318212.

For #41184

Change-Id: Iec0d7bee2d3a5874c24a55ec20efd7746bf70902
Reviewed-on: https://go-review.googlesource.com/c/go/+/319410
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/cmd/go.mod                                |    2 +-
 src/cmd/go.sum                                |    4 +-
 src/cmd/vendor/golang.org/x/sys/unix/mkall.sh |   12 -
 .../x/sys/unix/syscall_darwin.1_13.go         |    4 +-
 .../x/sys/unix/syscall_darwin_386.go          |   51 -
 .../x/sys/unix/syscall_darwin_arm.go          |   51 -
 .../x/sys/unix/syscall_darwin_libSystem.go    |    9 +-
 .../x/sys/unix/zerrors_darwin_386.go          | 1789 ------------
 .../x/sys/unix/zerrors_darwin_arm.go          | 1789 ------------
 .../x/sys/unix/zsyscall_darwin_386.1_13.go    |   40 -
 .../x/sys/unix/zsyscall_darwin_386.1_13.s     |   13 -
 .../x/sys/unix/zsyscall_darwin_386.go         | 2431 -----------------
 .../x/sys/unix/zsyscall_darwin_386.s          |  291 --
 .../x/sys/unix/zsyscall_darwin_amd64.1_13.go  |    8 +-
 .../x/sys/unix/zsyscall_darwin_amd64.1_13.s   |   18 +-
 .../x/sys/unix/zsyscall_darwin_amd64.go       |  572 ++--
 .../x/sys/unix/zsyscall_darwin_amd64.s        |  852 +++++-
 .../x/sys/unix/zsyscall_darwin_arm.1_13.go    |   40 -
 .../x/sys/unix/zsyscall_darwin_arm.1_13.s     |   13 -
 .../x/sys/unix/zsyscall_darwin_arm.go         | 2417 ----------------
 .../x/sys/unix/zsyscall_darwin_arm.s          |  289 --
 .../x/sys/unix/zsyscall_darwin_arm64.1_13.go  |    8 +-
 .../x/sys/unix/zsyscall_darwin_arm64.1_13.s   |   18 +-
 .../x/sys/unix/zsyscall_darwin_arm64.go       |  572 ++--
 .../x/sys/unix/zsyscall_darwin_arm64.s        |  852 +++++-
 .../x/sys/unix/zsysnum_darwin_386.go          |  438 ---
 .../x/sys/unix/zsysnum_darwin_arm.go          |  438 ---
 .../x/sys/unix/ztypes_darwin_386.go           |  524 ----
 .../x/sys/unix/ztypes_darwin_arm.go           |  524 ----
 .../vendor/golang.org/x/sys/windows/empty.s   |    1 +
 src/cmd/vendor/modules.txt                    |    2 +-
 31 files changed, 2038 insertions(+), 12034 deletions(-)
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_386.go
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_arm.go
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_386.go
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_arm.go
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.1_13.go
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.1_13.s
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.go
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.s
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.1_13.go
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.1_13.s
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.go
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.s
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_386.go
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_arm.go
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_386.go
 delete mode 100644 src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm.go

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index 7a96bc6409..c3617eea0b 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -8,7 +8,7 @@ require (
 	golang.org/x/arch v0.0.0-20210502124803-cbf565b21d1e
 	golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e // indirect
 	golang.org/x/mod v0.4.3-0.20210504181020-67f1c1edc27a
-	golang.org/x/sys v0.0.0-20210503173754-0981d6026fa6 // indirect
+	golang.org/x/sys v0.0.0-20210511113859-b0526f3d8744 // indirect
 	golang.org/x/term v0.0.0-20210503060354-a79de5458b56
 	golang.org/x/tools v0.1.1-0.20210505014545-7cab0ef2e9a5
 	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 1c6e224820..f42aac70d6 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -12,8 +12,8 @@ golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e/go.mod h1:P+XmwS30IXTQdn5
 golang.org/x/mod v0.4.3-0.20210504181020-67f1c1edc27a h1:wbpC/7Wbo5WFVox32n+KjhRRLmTLq8YW/wRlL2iVAhk=
 golang.org/x/mod v0.4.3-0.20210504181020-67f1c1edc27a/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
 golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210503173754-0981d6026fa6 h1:cdsMqa2nXzqlgs183pHxtvoVwU7CyzaCTAUOg94af4c=
-golang.org/x/sys v0.0.0-20210503173754-0981d6026fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210511113859-b0526f3d8744 h1:yhBbb4IRs2HS9PPlAg6DMC6mUOKexJBNsLf4Z+6En1Q=
+golang.org/x/sys v0.0.0-20210511113859-b0526f3d8744/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20210503060354-a79de5458b56 h1:b8jxX3zqjpqb2LklXPzKSGJhzyxCOZSz8ncv8Nv+y7w=
 golang.org/x/term v0.0.0-20210503060354-a79de5458b56/go.mod h1:tfny5GFUkzUvx4ps4ajbZsCe5lw1metzhBm9T3x7oIY=
 golang.org/x/tools v0.1.1-0.20210505014545-7cab0ef2e9a5 h1:ImcI7RFHWLu2QWpFDXaReu0j+sQAHIy65vUFZImXiqY=
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/mkall.sh b/src/cmd/vendor/golang.org/x/sys/unix/mkall.sh
index d727cad19c..396aadf86d 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/mkall.sh
+++ b/src/cmd/vendor/golang.org/x/sys/unix/mkall.sh
@@ -70,23 +70,11 @@ aix_ppc64)
 	mksyscall="go run mksyscall_aix_ppc64.go -aix"
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
 	;;
-darwin_386)
-	mkerrors="$mkerrors -m32"
-	mksyscall="go run mksyscall.go -l32"
-	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
-	mkasm="go run mkasm_darwin.go"
-	;;
 darwin_amd64)
 	mkerrors="$mkerrors -m64"
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
 	mkasm="go run mkasm_darwin.go"
 	;;
-darwin_arm)
-	mkerrors="$mkerrors"
-	mksyscall="go run mksyscall.go -l32"
-	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
-	mkasm="go run mkasm_darwin.go"
-	;;
 darwin_arm64)
 	mkerrors="$mkerrors -m64"
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.1_13.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.1_13.go
index 5fc3cda6fc..1596426b1e 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.1_13.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.1_13.go
@@ -17,7 +17,7 @@ import (
 //sys	readdir_r(dir uintptr, entry *Dirent, result **Dirent) (res Errno)
 
 func fdopendir(fd int) (dir uintptr, err error) {
-	r0, _, e1 := syscall_syscallPtr(funcPC(libc_fdopendir_trampoline), uintptr(fd), 0, 0)
+	r0, _, e1 := syscall_syscallPtr(libc_fdopendir_trampoline_addr, uintptr(fd), 0, 0)
 	dir = uintptr(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -25,7 +25,7 @@ func fdopendir(fd int) (dir uintptr, err error) {
 	return
 }
 
-func libc_fdopendir_trampoline()
+var libc_fdopendir_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fdopendir fdopendir "/usr/lib/libSystem.B.dylib"
 
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_386.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_386.go
deleted file mode 100644
index 6474677122..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_386.go
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright 2009 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.
-
-//go:build 386 && darwin
-// +build 386,darwin
-
-package unix
-
-import "syscall"
-
-func setTimespec(sec, nsec int64) Timespec {
-	return Timespec{Sec: int32(sec), Nsec: int32(nsec)}
-}
-
-func setTimeval(sec, usec int64) Timeval {
-	return Timeval{Sec: int32(sec), Usec: int32(usec)}
-}
-
-func SetKevent(k *Kevent_t, fd, mode, flags int) {
-	k.Ident = uint32(fd)
-	k.Filter = int16(mode)
-	k.Flags = uint16(flags)
-}
-
-func (iov *Iovec) SetLen(length int) {
-	iov.Len = uint32(length)
-}
-
-func (msghdr *Msghdr) SetControllen(length int) {
-	msghdr.Controllen = uint32(length)
-}
-
-func (msghdr *Msghdr) SetIovlen(length int) {
-	msghdr.Iovlen = int32(length)
-}
-
-func (cmsg *Cmsghdr) SetLen(length int) {
-	cmsg.Len = uint32(length)
-}
-
-func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno)
-
-//sys	Fstat(fd int, stat *Stat_t) (err error) = SYS_FSTAT64
-//sys	Fstatat(fd int, path string, stat *Stat_t, flags int) (err error) = SYS_FSTATAT64
-//sys	Fstatfs(fd int, stat *Statfs_t) (err error) = SYS_FSTATFS64
-//sys	getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) = SYS_GETFSSTAT64
-//sys	Lstat(path string, stat *Stat_t) (err error) = SYS_LSTAT64
-//sys	ptrace1(request int, pid int, addr uintptr, data uintptr) (err error) = SYS_ptrace
-//sys	Stat(path string, stat *Stat_t) (err error) = SYS_STAT64
-//sys	Statfs(path string, stat *Statfs_t) (err error) = SYS_STATFS64
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_arm.go
deleted file mode 100644
index d30735c5d6..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_arm.go
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright 2015 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 unix
-
-import "syscall"
-
-func ptrace1(request int, pid int, addr uintptr, data uintptr) error {
-	return ENOTSUP
-}
-
-func setTimespec(sec, nsec int64) Timespec {
-	return Timespec{Sec: int32(sec), Nsec: int32(nsec)}
-}
-
-func setTimeval(sec, usec int64) Timeval {
-	return Timeval{Sec: int32(sec), Usec: int32(usec)}
-}
-
-func SetKevent(k *Kevent_t, fd, mode, flags int) {
-	k.Ident = uint32(fd)
-	k.Filter = int16(mode)
-	k.Flags = uint16(flags)
-}
-
-func (iov *Iovec) SetLen(length int) {
-	iov.Len = uint32(length)
-}
-
-func (msghdr *Msghdr) SetControllen(length int) {
-	msghdr.Controllen = uint32(length)
-}
-
-func (msghdr *Msghdr) SetIovlen(length int) {
-	msghdr.Iovlen = int32(length)
-}
-
-func (cmsg *Cmsghdr) SetLen(length int) {
-	cmsg.Len = uint32(length)
-}
-
-func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno) // sic
-
-//sys	Fstat(fd int, stat *Stat_t) (err error)
-//sys	Fstatat(fd int, path string, stat *Stat_t, flags int) (err error)
-//sys	Fstatfs(fd int, stat *Statfs_t) (err error)
-//sys	getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) = SYS_GETFSSTAT
-//sys	Lstat(path string, stat *Stat_t) (err error)
-//sys	Stat(path string, stat *Stat_t) (err error)
-//sys	Statfs(path string, stat *Statfs_t) (err error)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_libSystem.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_libSystem.go
index 38bec30026..53c96641f8 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_libSystem.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin_libSystem.go
@@ -7,7 +7,7 @@
 
 package unix
 
-import "unsafe"
+import _ "unsafe"
 
 // Implemented in the runtime package (runtime/sys_darwin.go)
 func syscall_syscall(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
@@ -25,10 +25,3 @@ func syscall_syscallPtr(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
 //go:linkname syscall_rawSyscall syscall.rawSyscall
 //go:linkname syscall_rawSyscall6 syscall.rawSyscall6
 //go:linkname syscall_syscallPtr syscall.syscallPtr
-
-// Find the entry point for f. See comments in runtime/proc.go for the
-// function of the same name.
-//go:nosplit
-func funcPC(f func()) uintptr {
-	return **(**uintptr)(unsafe.Pointer(&f))
-}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_386.go
deleted file mode 100644
index 7ee196f7fc..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_386.go
+++ /dev/null
@@ -1,1789 +0,0 @@
-// mkerrors.sh -m32
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-//go:build 386 && darwin
-// +build 386,darwin
-
-// Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- -m32 _const.go
-
-package unix
-
-import "syscall"
-
-const (
-	AF_APPLETALK                      = 0x10
-	AF_CCITT                          = 0xa
-	AF_CHAOS                          = 0x5
-	AF_CNT                            = 0x15
-	AF_COIP                           = 0x14
-	AF_DATAKIT                        = 0x9
-	AF_DECnet                         = 0xc
-	AF_DLI                            = 0xd
-	AF_E164                           = 0x1c
-	AF_ECMA                           = 0x8
-	AF_HYLINK                         = 0xf
-	AF_IEEE80211                      = 0x25
-	AF_IMPLINK                        = 0x3
-	AF_INET                           = 0x2
-	AF_INET6                          = 0x1e
-	AF_IPX                            = 0x17
-	AF_ISDN                           = 0x1c
-	AF_ISO                            = 0x7
-	AF_LAT                            = 0xe
-	AF_LINK                           = 0x12
-	AF_LOCAL                          = 0x1
-	AF_MAX                            = 0x28
-	AF_NATM                           = 0x1f
-	AF_NDRV                           = 0x1b
-	AF_NETBIOS                        = 0x21
-	AF_NS                             = 0x6
-	AF_OSI                            = 0x7
-	AF_PPP                            = 0x22
-	AF_PUP                            = 0x4
-	AF_RESERVED_36                    = 0x24
-	AF_ROUTE                          = 0x11
-	AF_SIP                            = 0x18
-	AF_SNA                            = 0xb
-	AF_SYSTEM                         = 0x20
-	AF_SYS_CONTROL                    = 0x2
-	AF_UNIX                           = 0x1
-	AF_UNSPEC                         = 0x0
-	AF_UTUN                           = 0x26
-	ALTWERASE                         = 0x200
-	ATTR_BIT_MAP_COUNT                = 0x5
-	ATTR_CMN_ACCESSMASK               = 0x20000
-	ATTR_CMN_ACCTIME                  = 0x1000
-	ATTR_CMN_ADDEDTIME                = 0x10000000
-	ATTR_CMN_BKUPTIME                 = 0x2000
-	ATTR_CMN_CHGTIME                  = 0x800
-	ATTR_CMN_CRTIME                   = 0x200
-	ATTR_CMN_DATA_PROTECT_FLAGS       = 0x40000000
-	ATTR_CMN_DEVID                    = 0x2
-	ATTR_CMN_DOCUMENT_ID              = 0x100000
-	ATTR_CMN_ERROR                    = 0x20000000
-	ATTR_CMN_EXTENDED_SECURITY        = 0x400000
-	ATTR_CMN_FILEID                   = 0x2000000
-	ATTR_CMN_FLAGS                    = 0x40000
-	ATTR_CMN_FNDRINFO                 = 0x4000
-	ATTR_CMN_FSID                     = 0x4
-	ATTR_CMN_FULLPATH                 = 0x8000000
-	ATTR_CMN_GEN_COUNT                = 0x80000
-	ATTR_CMN_GRPID                    = 0x10000
-	ATTR_CMN_GRPUUID                  = 0x1000000
-	ATTR_CMN_MODTIME                  = 0x400
-	ATTR_CMN_NAME                     = 0x1
-	ATTR_CMN_NAMEDATTRCOUNT           = 0x80000
-	ATTR_CMN_NAMEDATTRLIST            = 0x100000
-	ATTR_CMN_OBJID                    = 0x20
-	ATTR_CMN_OBJPERMANENTID           = 0x40
-	ATTR_CMN_OBJTAG                   = 0x10
-	ATTR_CMN_OBJTYPE                  = 0x8
-	ATTR_CMN_OWNERID                  = 0x8000
-	ATTR_CMN_PARENTID                 = 0x4000000
-	ATTR_CMN_PAROBJID                 = 0x80
-	ATTR_CMN_RETURNED_ATTRS           = 0x80000000
-	ATTR_CMN_SCRIPT                   = 0x100
-	ATTR_CMN_SETMASK                  = 0x41c7ff00
-	ATTR_CMN_USERACCESS               = 0x200000
-	ATTR_CMN_UUID                     = 0x800000
-	ATTR_CMN_VALIDMASK                = 0xffffffff
-	ATTR_CMN_VOLSETMASK               = 0x6700
-	ATTR_FILE_ALLOCSIZE               = 0x4
-	ATTR_FILE_CLUMPSIZE               = 0x10
-	ATTR_FILE_DATAALLOCSIZE           = 0x400
-	ATTR_FILE_DATAEXTENTS             = 0x800
-	ATTR_FILE_DATALENGTH              = 0x200
-	ATTR_FILE_DEVTYPE                 = 0x20
-	ATTR_FILE_FILETYPE                = 0x40
-	ATTR_FILE_FORKCOUNT               = 0x80
-	ATTR_FILE_FORKLIST                = 0x100
-	ATTR_FILE_IOBLOCKSIZE             = 0x8
-	ATTR_FILE_LINKCOUNT               = 0x1
-	ATTR_FILE_RSRCALLOCSIZE           = 0x2000
-	ATTR_FILE_RSRCEXTENTS             = 0x4000
-	ATTR_FILE_RSRCLENGTH              = 0x1000
-	ATTR_FILE_SETMASK                 = 0x20
-	ATTR_FILE_TOTALSIZE               = 0x2
-	ATTR_FILE_VALIDMASK               = 0x37ff
-	ATTR_VOL_ALLOCATIONCLUMP          = 0x40
-	ATTR_VOL_ATTRIBUTES               = 0x40000000
-	ATTR_VOL_CAPABILITIES             = 0x20000
-	ATTR_VOL_DIRCOUNT                 = 0x400
-	ATTR_VOL_ENCODINGSUSED            = 0x10000
-	ATTR_VOL_FILECOUNT                = 0x200
-	ATTR_VOL_FSTYPE                   = 0x1
-	ATTR_VOL_INFO                     = 0x80000000
-	ATTR_VOL_IOBLOCKSIZE              = 0x80
-	ATTR_VOL_MAXOBJCOUNT              = 0x800
-	ATTR_VOL_MINALLOCATION            = 0x20
-	ATTR_VOL_MOUNTEDDEVICE            = 0x8000
-	ATTR_VOL_MOUNTFLAGS               = 0x4000
-	ATTR_VOL_MOUNTPOINT               = 0x1000
-	ATTR_VOL_NAME                     = 0x2000
-	ATTR_VOL_OBJCOUNT                 = 0x100
-	ATTR_VOL_QUOTA_SIZE               = 0x10000000
-	ATTR_VOL_RESERVED_SIZE            = 0x20000000
-	ATTR_VOL_SETMASK                  = 0x80002000
-	ATTR_VOL_SIGNATURE                = 0x2
-	ATTR_VOL_SIZE                     = 0x4
-	ATTR_VOL_SPACEAVAIL               = 0x10
-	ATTR_VOL_SPACEFREE                = 0x8
-	ATTR_VOL_UUID                     = 0x40000
-	ATTR_VOL_VALIDMASK                = 0xf007ffff
-	B0                                = 0x0
-	B110                              = 0x6e
-	B115200                           = 0x1c200
-	B1200                             = 0x4b0
-	B134                              = 0x86
-	B14400                            = 0x3840
-	B150                              = 0x96
-	B1800                             = 0x708
-	B19200                            = 0x4b00
-	B200                              = 0xc8
-	B230400                           = 0x38400
-	B2400                             = 0x960
-	B28800                            = 0x7080
-	B300                              = 0x12c
-	B38400                            = 0x9600
-	B4800                             = 0x12c0
-	B50                               = 0x32
-	B57600                            = 0xe100
-	B600                              = 0x258
-	B7200                             = 0x1c20
-	B75                               = 0x4b
-	B76800                            = 0x12c00
-	B9600                             = 0x2580
-	BIOCFLUSH                         = 0x20004268
-	BIOCGBLEN                         = 0x40044266
-	BIOCGDLT                          = 0x4004426a
-	BIOCGDLTLIST                      = 0xc00c4279
-	BIOCGETIF                         = 0x4020426b
-	BIOCGHDRCMPLT                     = 0x40044274
-	BIOCGRSIG                         = 0x40044272
-	BIOCGRTIMEOUT                     = 0x4008426e
-	BIOCGSEESENT                      = 0x40044276
-	BIOCGSTATS                        = 0x4008426f
-	BIOCIMMEDIATE                     = 0x80044270
-	BIOCPROMISC                       = 0x20004269
-	BIOCSBLEN                         = 0xc0044266
-	BIOCSDLT                          = 0x80044278
-	BIOCSETF                          = 0x80084267
-	BIOCSETFNR                        = 0x8008427e
-	BIOCSETIF                         = 0x8020426c
-	BIOCSHDRCMPLT                     = 0x80044275
-	BIOCSRSIG                         = 0x80044273
-	BIOCSRTIMEOUT                     = 0x8008426d
-	BIOCSSEESENT                      = 0x80044277
-	BIOCVERSION                       = 0x40044271
-	BPF_A                             = 0x10
-	BPF_ABS                           = 0x20
-	BPF_ADD                           = 0x0
-	BPF_ALIGNMENT                     = 0x4
-	BPF_ALU                           = 0x4
-	BPF_AND                           = 0x50
-	BPF_B                             = 0x10
-	BPF_DIV                           = 0x30
-	BPF_H                             = 0x8
-	BPF_IMM                           = 0x0
-	BPF_IND                           = 0x40
-	BPF_JA                            = 0x0
-	BPF_JEQ                           = 0x10
-	BPF_JGE                           = 0x30
-	BPF_JGT                           = 0x20
-	BPF_JMP                           = 0x5
-	BPF_JSET                          = 0x40
-	BPF_K                             = 0x0
-	BPF_LD                            = 0x0
-	BPF_LDX                           = 0x1
-	BPF_LEN                           = 0x80
-	BPF_LSH                           = 0x60
-	BPF_MAJOR_VERSION                 = 0x1
-	BPF_MAXBUFSIZE                    = 0x80000
-	BPF_MAXINSNS                      = 0x200
-	BPF_MEM                           = 0x60
-	BPF_MEMWORDS                      = 0x10
-	BPF_MINBUFSIZE                    = 0x20
-	BPF_MINOR_VERSION                 = 0x1
-	BPF_MISC                          = 0x7
-	BPF_MSH                           = 0xa0
-	BPF_MUL                           = 0x20
-	BPF_NEG                           = 0x80
-	BPF_OR                            = 0x40
-	BPF_RELEASE                       = 0x30bb6
-	BPF_RET                           = 0x6
-	BPF_RSH                           = 0x70
-	BPF_ST                            = 0x2
-	BPF_STX                           = 0x3
-	BPF_SUB                           = 0x10
-	BPF_TAX                           = 0x0
-	BPF_TXA                           = 0x80
-	BPF_W                             = 0x0
-	BPF_X                             = 0x8
-	BRKINT                            = 0x2
-	BS0                               = 0x0
-	BS1                               = 0x8000
-	BSDLY                             = 0x8000
-	CFLUSH                            = 0xf
-	CLOCAL                            = 0x8000
-	CLOCK_MONOTONIC                   = 0x6
-	CLOCK_MONOTONIC_RAW               = 0x4
-	CLOCK_MONOTONIC_RAW_APPROX        = 0x5
-	CLOCK_PROCESS_CPUTIME_ID          = 0xc
-	CLOCK_REALTIME                    = 0x0
-	CLOCK_THREAD_CPUTIME_ID           = 0x10
-	CLOCK_UPTIME_RAW                  = 0x8
-	CLOCK_UPTIME_RAW_APPROX           = 0x9
-	CLONE_NOFOLLOW                    = 0x1
-	CLONE_NOOWNERCOPY                 = 0x2
-	CR0                               = 0x0
-	CR1                               = 0x1000
-	CR2                               = 0x2000
-	CR3                               = 0x3000
-	CRDLY                             = 0x3000
-	CREAD                             = 0x800
-	CRTSCTS                           = 0x30000
-	CS5                               = 0x0
-	CS6                               = 0x100
-	CS7                               = 0x200
-	CS8                               = 0x300
-	CSIZE                             = 0x300
-	CSTART                            = 0x11
-	CSTATUS                           = 0x14
-	CSTOP                             = 0x13
-	CSTOPB                            = 0x400
-	CSUSP                             = 0x1a
-	CTLIOCGINFO                       = 0xc0644e03
-	CTL_HW                            = 0x6
-	CTL_KERN                          = 0x1
-	CTL_MAXNAME                       = 0xc
-	CTL_NET                           = 0x4
-	DLT_A429                          = 0xb8
-	DLT_A653_ICM                      = 0xb9
-	DLT_AIRONET_HEADER                = 0x78
-	DLT_AOS                           = 0xde
-	DLT_APPLE_IP_OVER_IEEE1394        = 0x8a
-	DLT_ARCNET                        = 0x7
-	DLT_ARCNET_LINUX                  = 0x81
-	DLT_ATM_CLIP                      = 0x13
-	DLT_ATM_RFC1483                   = 0xb
-	DLT_AURORA                        = 0x7e
-	DLT_AX25                          = 0x3
-	DLT_AX25_KISS                     = 0xca
-	DLT_BACNET_MS_TP                  = 0xa5
-	DLT_BLUETOOTH_HCI_H4              = 0xbb
-	DLT_BLUETOOTH_HCI_H4_WITH_PHDR    = 0xc9
-	DLT_CAN20B                        = 0xbe
-	DLT_CAN_SOCKETCAN                 = 0xe3
-	DLT_CHAOS                         = 0x5
-	DLT_CHDLC                         = 0x68
-	DLT_CISCO_IOS                     = 0x76
-	DLT_C_HDLC                        = 0x68
-	DLT_C_HDLC_WITH_DIR               = 0xcd
-	DLT_DBUS                          = 0xe7
-	DLT_DECT                          = 0xdd
-	DLT_DOCSIS                        = 0x8f
-	DLT_DVB_CI                        = 0xeb
-	DLT_ECONET                        = 0x73
-	DLT_EN10MB                        = 0x1
-	DLT_EN3MB                         = 0x2
-	DLT_ENC                           = 0x6d
-	DLT_ERF                           = 0xc5
-	DLT_ERF_ETH                       = 0xaf
-	DLT_ERF_POS                       = 0xb0
-	DLT_FC_2                          = 0xe0
-	DLT_FC_2_WITH_FRAME_DELIMS        = 0xe1
-	DLT_FDDI                          = 0xa
-	DLT_FLEXRAY                       = 0xd2
-	DLT_FRELAY                        = 0x6b
-	DLT_FRELAY_WITH_DIR               = 0xce
-	DLT_GCOM_SERIAL                   = 0xad
-	DLT_GCOM_T1E1                     = 0xac
-	DLT_GPF_F                         = 0xab
-	DLT_GPF_T                         = 0xaa
-	DLT_GPRS_LLC                      = 0xa9
-	DLT_GSMTAP_ABIS                   = 0xda
-	DLT_GSMTAP_UM                     = 0xd9
-	DLT_HHDLC                         = 0x79
-	DLT_IBM_SN                        = 0x92
-	DLT_IBM_SP                        = 0x91
-	DLT_IEEE802                       = 0x6
-	DLT_IEEE802_11                    = 0x69
-	DLT_IEEE802_11_RADIO              = 0x7f
-	DLT_IEEE802_11_RADIO_AVS          = 0xa3
-	DLT_IEEE802_15_4                  = 0xc3
-	DLT_IEEE802_15_4_LINUX            = 0xbf
-	DLT_IEEE802_15_4_NOFCS            = 0xe6
-	DLT_IEEE802_15_4_NONASK_PHY       = 0xd7
-	DLT_IEEE802_16_MAC_CPS            = 0xbc
-	DLT_IEEE802_16_MAC_CPS_RADIO      = 0xc1
-	DLT_IPFILTER                      = 0x74
-	DLT_IPMB                          = 0xc7
-	DLT_IPMB_LINUX                    = 0xd1
-	DLT_IPNET                         = 0xe2
-	DLT_IPOIB                         = 0xf2
-	DLT_IPV4                          = 0xe4
-	DLT_IPV6                          = 0xe5
-	DLT_IP_OVER_FC                    = 0x7a
-	DLT_JUNIPER_ATM1                  = 0x89
-	DLT_JUNIPER_ATM2                  = 0x87
-	DLT_JUNIPER_ATM_CEMIC             = 0xee
-	DLT_JUNIPER_CHDLC                 = 0xb5
-	DLT_JUNIPER_ES                    = 0x84
-	DLT_JUNIPER_ETHER                 = 0xb2
-	DLT_JUNIPER_FIBRECHANNEL          = 0xea
-	DLT_JUNIPER_FRELAY                = 0xb4
-	DLT_JUNIPER_GGSN                  = 0x85
-	DLT_JUNIPER_ISM                   = 0xc2
-	DLT_JUNIPER_MFR                   = 0x86
-	DLT_JUNIPER_MLFR                  = 0x83
-	DLT_JUNIPER_MLPPP                 = 0x82
-	DLT_JUNIPER_MONITOR               = 0xa4
-	DLT_JUNIPER_PIC_PEER              = 0xae
-	DLT_JUNIPER_PPP                   = 0xb3
-	DLT_JUNIPER_PPPOE                 = 0xa7
-	DLT_JUNIPER_PPPOE_ATM             = 0xa8
-	DLT_JUNIPER_SERVICES              = 0x88
-	DLT_JUNIPER_SRX_E2E               = 0xe9
-	DLT_JUNIPER_ST                    = 0xc8
-	DLT_JUNIPER_VP                    = 0xb7
-	DLT_JUNIPER_VS                    = 0xe8
-	DLT_LAPB_WITH_DIR                 = 0xcf
-	DLT_LAPD                          = 0xcb
-	DLT_LIN                           = 0xd4
-	DLT_LINUX_EVDEV                   = 0xd8
-	DLT_LINUX_IRDA                    = 0x90
-	DLT_LINUX_LAPD                    = 0xb1
-	DLT_LINUX_PPP_WITHDIRECTION       = 0xa6
-	DLT_LINUX_SLL                     = 0x71
-	DLT_LOOP                          = 0x6c
-	DLT_LTALK                         = 0x72
-	DLT_MATCHING_MAX                  = 0xf5
-	DLT_MATCHING_MIN                  = 0x68
-	DLT_MFR                           = 0xb6
-	DLT_MOST                          = 0xd3
-	DLT_MPEG_2_TS                     = 0xf3
-	DLT_MPLS                          = 0xdb
-	DLT_MTP2                          = 0x8c
-	DLT_MTP2_WITH_PHDR                = 0x8b
-	DLT_MTP3                          = 0x8d
-	DLT_MUX27010                      = 0xec
-	DLT_NETANALYZER                   = 0xf0
-	DLT_NETANALYZER_TRANSPARENT       = 0xf1
-	DLT_NFC_LLCP                      = 0xf5
-	DLT_NFLOG                         = 0xef
-	DLT_NG40                          = 0xf4
-	DLT_NULL                          = 0x0
-	DLT_PCI_EXP                       = 0x7d
-	DLT_PFLOG                         = 0x75
-	DLT_PFSYNC                        = 0x12
-	DLT_PPI                           = 0xc0
-	DLT_PPP                           = 0x9
-	DLT_PPP_BSDOS                     = 0x10
-	DLT_PPP_ETHER                     = 0x33
-	DLT_PPP_PPPD                      = 0xa6
-	DLT_PPP_SERIAL                    = 0x32
-	DLT_PPP_WITH_DIR                  = 0xcc
-	DLT_PPP_WITH_DIRECTION            = 0xa6
-	DLT_PRISM_HEADER                  = 0x77
-	DLT_PRONET                        = 0x4
-	DLT_RAIF1                         = 0xc6
-	DLT_RAW                           = 0xc
-	DLT_RIO                           = 0x7c
-	DLT_SCCP                          = 0x8e
-	DLT_SITA                          = 0xc4
-	DLT_SLIP                          = 0x8
-	DLT_SLIP_BSDOS                    = 0xf
-	DLT_STANAG_5066_D_PDU             = 0xed
-	DLT_SUNATM                        = 0x7b
-	DLT_SYMANTEC_FIREWALL             = 0x63
-	DLT_TZSP                          = 0x80
-	DLT_USB                           = 0xba
-	DLT_USB_LINUX                     = 0xbd
-	DLT_USB_LINUX_MMAPPED             = 0xdc
-	DLT_USER0                         = 0x93
-	DLT_USER1                         = 0x94
-	DLT_USER10                        = 0x9d
-	DLT_USER11                        = 0x9e
-	DLT_USER12                        = 0x9f
-	DLT_USER13                        = 0xa0
-	DLT_USER14                        = 0xa1
-	DLT_USER15                        = 0xa2
-	DLT_USER2                         = 0x95
-	DLT_USER3                         = 0x96
-	DLT_USER4                         = 0x97
-	DLT_USER5                         = 0x98
-	DLT_USER6                         = 0x99
-	DLT_USER7                         = 0x9a
-	DLT_USER8                         = 0x9b
-	DLT_USER9                         = 0x9c
-	DLT_WIHART                        = 0xdf
-	DLT_X2E_SERIAL                    = 0xd5
-	DLT_X2E_XORAYA                    = 0xd6
-	DT_BLK                            = 0x6
-	DT_CHR                            = 0x2
-	DT_DIR                            = 0x4
-	DT_FIFO                           = 0x1
-	DT_LNK                            = 0xa
-	DT_REG                            = 0x8
-	DT_SOCK                           = 0xc
-	DT_UNKNOWN                        = 0x0
-	DT_WHT                            = 0xe
-	ECHO                              = 0x8
-	ECHOCTL                           = 0x40
-	ECHOE                             = 0x2
-	ECHOK                             = 0x4
-	ECHOKE                            = 0x1
-	ECHONL                            = 0x10
-	ECHOPRT                           = 0x20
-	EVFILT_AIO                        = -0x3
-	EVFILT_EXCEPT                     = -0xf
-	EVFILT_FS                         = -0x9
-	EVFILT_MACHPORT                   = -0x8
-	EVFILT_PROC                       = -0x5
-	EVFILT_READ                       = -0x1
-	EVFILT_SIGNAL                     = -0x6
-	EVFILT_SYSCOUNT                   = 0xf
-	EVFILT_THREADMARKER               = 0xf
-	EVFILT_TIMER                      = -0x7
-	EVFILT_USER                       = -0xa
-	EVFILT_VM                         = -0xc
-	EVFILT_VNODE                      = -0x4
-	EVFILT_WRITE                      = -0x2
-	EV_ADD                            = 0x1
-	EV_CLEAR                          = 0x20
-	EV_DELETE                         = 0x2
-	EV_DISABLE                        = 0x8
-	EV_DISPATCH                       = 0x80
-	EV_DISPATCH2                      = 0x180
-	EV_ENABLE                         = 0x4
-	EV_EOF                            = 0x8000
-	EV_ERROR                          = 0x4000
-	EV_FLAG0                          = 0x1000
-	EV_FLAG1                          = 0x2000
-	EV_ONESHOT                        = 0x10
-	EV_OOBAND                         = 0x2000
-	EV_POLL                           = 0x1000
-	EV_RECEIPT                        = 0x40
-	EV_SYSFLAGS                       = 0xf000
-	EV_UDATA_SPECIFIC                 = 0x100
-	EV_VANISHED                       = 0x200
-	EXTA                              = 0x4b00
-	EXTB                              = 0x9600
-	EXTPROC                           = 0x800
-	FD_CLOEXEC                        = 0x1
-	FD_SETSIZE                        = 0x400
-	FF0                               = 0x0
-	FF1                               = 0x4000
-	FFDLY                             = 0x4000
-	FLUSHO                            = 0x800000
-	FSOPT_ATTR_CMN_EXTENDED           = 0x20
-	FSOPT_NOFOLLOW                    = 0x1
-	FSOPT_NOINMEMUPDATE               = 0x2
-	FSOPT_PACK_INVAL_ATTRS            = 0x8
-	FSOPT_REPORT_FULLSIZE             = 0x4
-	F_ADDFILESIGS                     = 0x3d
-	F_ADDFILESIGS_FOR_DYLD_SIM        = 0x53
-	F_ADDFILESIGS_RETURN              = 0x61
-	F_ADDSIGS                         = 0x3b
-	F_ALLOCATEALL                     = 0x4
-	F_ALLOCATECONTIG                  = 0x2
-	F_BARRIERFSYNC                    = 0x55
-	F_CHECK_LV                        = 0x62
-	F_CHKCLEAN                        = 0x29
-	F_DUPFD                           = 0x0
-	F_DUPFD_CLOEXEC                   = 0x43
-	F_FINDSIGS                        = 0x4e
-	F_FLUSH_DATA                      = 0x28
-	F_FREEZE_FS                       = 0x35
-	F_FULLFSYNC                       = 0x33
-	F_GETCODEDIR                      = 0x48
-	F_GETFD                           = 0x1
-	F_GETFL                           = 0x3
-	F_GETLK                           = 0x7
-	F_GETLKPID                        = 0x42
-	F_GETNOSIGPIPE                    = 0x4a
-	F_GETOWN                          = 0x5
-	F_GETPATH                         = 0x32
-	F_GETPATH_MTMINFO                 = 0x47
-	F_GETPROTECTIONCLASS              = 0x3f
-	F_GETPROTECTIONLEVEL              = 0x4d
-	F_GLOBAL_NOCACHE                  = 0x37
-	F_LOG2PHYS                        = 0x31
-	F_LOG2PHYS_EXT                    = 0x41
-	F_NOCACHE                         = 0x30
-	F_NODIRECT                        = 0x3e
-	F_OK                              = 0x0
-	F_PATHPKG_CHECK                   = 0x34
-	F_PEOFPOSMODE                     = 0x3
-	F_PREALLOCATE                     = 0x2a
-	F_PUNCHHOLE                       = 0x63
-	F_RDADVISE                        = 0x2c
-	F_RDAHEAD                         = 0x2d
-	F_RDLCK                           = 0x1
-	F_SETBACKINGSTORE                 = 0x46
-	F_SETFD                           = 0x2
-	F_SETFL                           = 0x4
-	F_SETLK                           = 0x8
-	F_SETLKW                          = 0x9
-	F_SETLKWTIMEOUT                   = 0xa
-	F_SETNOSIGPIPE                    = 0x49
-	F_SETOWN                          = 0x6
-	F_SETPROTECTIONCLASS              = 0x40
-	F_SETSIZE                         = 0x2b
-	F_SINGLE_WRITER                   = 0x4c
-	F_THAW_FS                         = 0x36
-	F_TRANSCODEKEY                    = 0x4b
-	F_TRIM_ACTIVE_FILE                = 0x64
-	F_UNLCK                           = 0x2
-	F_VOLPOSMODE                      = 0x4
-	F_WRLCK                           = 0x3
-	HUPCL                             = 0x4000
-	HW_MACHINE                        = 0x1
-	ICANON                            = 0x100
-	ICMP6_FILTER                      = 0x12
-	ICRNL                             = 0x100
-	IEXTEN                            = 0x400
-	IFF_ALLMULTI                      = 0x200
-	IFF_ALTPHYS                       = 0x4000
-	IFF_BROADCAST                     = 0x2
-	IFF_DEBUG                         = 0x4
-	IFF_LINK0                         = 0x1000
-	IFF_LINK1                         = 0x2000
-	IFF_LINK2                         = 0x4000
-	IFF_LOOPBACK                      = 0x8
-	IFF_MULTICAST                     = 0x8000
-	IFF_NOARP                         = 0x80
-	IFF_NOTRAILERS                    = 0x20
-	IFF_OACTIVE                       = 0x400
-	IFF_POINTOPOINT                   = 0x10
-	IFF_PROMISC                       = 0x100
-	IFF_RUNNING                       = 0x40
-	IFF_SIMPLEX                       = 0x800
-	IFF_UP                            = 0x1
-	IFNAMSIZ                          = 0x10
-	IFT_1822                          = 0x2
-	IFT_AAL5                          = 0x31
-	IFT_ARCNET                        = 0x23
-	IFT_ARCNETPLUS                    = 0x24
-	IFT_ATM                           = 0x25
-	IFT_BRIDGE                        = 0xd1
-	IFT_CARP                          = 0xf8
-	IFT_CELLULAR                      = 0xff
-	IFT_CEPT                          = 0x13
-	IFT_DS3                           = 0x1e
-	IFT_ENC                           = 0xf4
-	IFT_EON                           = 0x19
-	IFT_ETHER                         = 0x6
-	IFT_FAITH                         = 0x38
-	IFT_FDDI                          = 0xf
-	IFT_FRELAY                        = 0x20
-	IFT_FRELAYDCE                     = 0x2c
-	IFT_GIF                           = 0x37
-	IFT_HDH1822                       = 0x3
-	IFT_HIPPI                         = 0x2f
-	IFT_HSSI                          = 0x2e
-	IFT_HY                            = 0xe
-	IFT_IEEE1394                      = 0x90
-	IFT_IEEE8023ADLAG                 = 0x88
-	IFT_ISDNBASIC                     = 0x14
-	IFT_ISDNPRIMARY                   = 0x15
-	IFT_ISO88022LLC                   = 0x29
-	IFT_ISO88023                      = 0x7
-	IFT_ISO88024                      = 0x8
-	IFT_ISO88025                      = 0x9
-	IFT_ISO88026                      = 0xa
-	IFT_L2VLAN                        = 0x87
-	IFT_LAPB                          = 0x10
-	IFT_LOCALTALK                     = 0x2a
-	IFT_LOOP                          = 0x18
-	IFT_MIOX25                        = 0x26
-	IFT_MODEM                         = 0x30
-	IFT_NSIP                          = 0x1b
-	IFT_OTHER                         = 0x1
-	IFT_P10                           = 0xc
-	IFT_P80                           = 0xd
-	IFT_PARA                          = 0x22
-	IFT_PDP                           = 0xff
-	IFT_PFLOG                         = 0xf5
-	IFT_PFSYNC                        = 0xf6
-	IFT_PKTAP                         = 0xfe
-	IFT_PPP                           = 0x17
-	IFT_PROPMUX                       = 0x36
-	IFT_PROPVIRTUAL                   = 0x35
-	IFT_PTPSERIAL                     = 0x16
-	IFT_RS232                         = 0x21
-	IFT_SDLC                          = 0x11
-	IFT_SIP                           = 0x1f
-	IFT_SLIP                          = 0x1c
-	IFT_SMDSDXI                       = 0x2b
-	IFT_SMDSICIP                      = 0x34
-	IFT_SONET                         = 0x27
-	IFT_SONETPATH                     = 0x32
-	IFT_SONETVT                       = 0x33
-	IFT_STARLAN                       = 0xb
-	IFT_STF                           = 0x39
-	IFT_T1                            = 0x12
-	IFT_ULTRA                         = 0x1d
-	IFT_V35                           = 0x2d
-	IFT_X25                           = 0x5
-	IFT_X25DDN                        = 0x4
-	IFT_X25PLE                        = 0x28
-	IFT_XETHER                        = 0x1a
-	IGNBRK                            = 0x1
-	IGNCR                             = 0x80
-	IGNPAR                            = 0x4
-	IMAXBEL                           = 0x2000
-	INLCR                             = 0x40
-	INPCK                             = 0x10
-	IN_CLASSA_HOST                    = 0xffffff
-	IN_CLASSA_MAX                     = 0x80
-	IN_CLASSA_NET                     = 0xff000000
-	IN_CLASSA_NSHIFT                  = 0x18
-	IN_CLASSB_HOST                    = 0xffff
-	IN_CLASSB_MAX                     = 0x10000
-	IN_CLASSB_NET                     = 0xffff0000
-	IN_CLASSB_NSHIFT                  = 0x10
-	IN_CLASSC_HOST                    = 0xff
-	IN_CLASSC_NET                     = 0xffffff00
-	IN_CLASSC_NSHIFT                  = 0x8
-	IN_CLASSD_HOST                    = 0xfffffff
-	IN_CLASSD_NET                     = 0xf0000000
-	IN_CLASSD_NSHIFT                  = 0x1c
-	IN_LINKLOCALNETNUM                = 0xa9fe0000
-	IN_LOOPBACKNET                    = 0x7f
-	IPPROTO_3PC                       = 0x22
-	IPPROTO_ADFS                      = 0x44
-	IPPROTO_AH                        = 0x33
-	IPPROTO_AHIP                      = 0x3d
-	IPPROTO_APES                      = 0x63
-	IPPROTO_ARGUS                     = 0xd
-	IPPROTO_AX25                      = 0x5d
-	IPPROTO_BHA                       = 0x31
-	IPPROTO_BLT                       = 0x1e
-	IPPROTO_BRSATMON                  = 0x4c
-	IPPROTO_CFTP                      = 0x3e
-	IPPROTO_CHAOS                     = 0x10
-	IPPROTO_CMTP                      = 0x26
-	IPPROTO_CPHB                      = 0x49
-	IPPROTO_CPNX                      = 0x48
-	IPPROTO_DDP                       = 0x25
-	IPPROTO_DGP                       = 0x56
-	IPPROTO_DIVERT                    = 0xfe
-	IPPROTO_DONE                      = 0x101
-	IPPROTO_DSTOPTS                   = 0x3c
-	IPPROTO_EGP                       = 0x8
-	IPPROTO_EMCON                     = 0xe
-	IPPROTO_ENCAP                     = 0x62
-	IPPROTO_EON                       = 0x50
-	IPPROTO_ESP                       = 0x32
-	IPPROTO_ETHERIP                   = 0x61
-	IPPROTO_FRAGMENT                  = 0x2c
-	IPPROTO_GGP                       = 0x3
-	IPPROTO_GMTP                      = 0x64
-	IPPROTO_GRE                       = 0x2f
-	IPPROTO_HELLO                     = 0x3f
-	IPPROTO_HMP                       = 0x14
-	IPPROTO_HOPOPTS                   = 0x0
-	IPPROTO_ICMP                      = 0x1
-	IPPROTO_ICMPV6                    = 0x3a
-	IPPROTO_IDP                       = 0x16
-	IPPROTO_IDPR                      = 0x23
-	IPPROTO_IDRP                      = 0x2d
-	IPPROTO_IGMP                      = 0x2
-	IPPROTO_IGP                       = 0x55
-	IPPROTO_IGRP                      = 0x58
-	IPPROTO_IL                        = 0x28
-	IPPROTO_INLSP                     = 0x34
-	IPPROTO_INP                       = 0x20
-	IPPROTO_IP                        = 0x0
-	IPPROTO_IPCOMP                    = 0x6c
-	IPPROTO_IPCV                      = 0x47
-	IPPROTO_IPEIP                     = 0x5e
-	IPPROTO_IPIP                      = 0x4
-	IPPROTO_IPPC                      = 0x43
-	IPPROTO_IPV4                      = 0x4
-	IPPROTO_IPV6                      = 0x29
-	IPPROTO_IRTP                      = 0x1c
-	IPPROTO_KRYPTOLAN                 = 0x41
-	IPPROTO_LARP                      = 0x5b
-	IPPROTO_LEAF1                     = 0x19
-	IPPROTO_LEAF2                     = 0x1a
-	IPPROTO_MAX                       = 0x100
-	IPPROTO_MAXID                     = 0x34
-	IPPROTO_MEAS                      = 0x13
-	IPPROTO_MHRP                      = 0x30
-	IPPROTO_MICP                      = 0x5f
-	IPPROTO_MTP                       = 0x5c
-	IPPROTO_MUX                       = 0x12
-	IPPROTO_ND                        = 0x4d
-	IPPROTO_NHRP                      = 0x36
-	IPPROTO_NONE                      = 0x3b
-	IPPROTO_NSP                       = 0x1f
-	IPPROTO_NVPII                     = 0xb
-	IPPROTO_OSPFIGP                   = 0x59
-	IPPROTO_PGM                       = 0x71
-	IPPROTO_PIGP                      = 0x9
-	IPPROTO_PIM                       = 0x67
-	IPPROTO_PRM                       = 0x15
-	IPPROTO_PUP                       = 0xc
-	IPPROTO_PVP                       = 0x4b
-	IPPROTO_RAW                       = 0xff
-	IPPROTO_RCCMON                    = 0xa
-	IPPROTO_RDP                       = 0x1b
-	IPPROTO_ROUTING                   = 0x2b
-	IPPROTO_RSVP                      = 0x2e
-	IPPROTO_RVD                       = 0x42
-	IPPROTO_SATEXPAK                  = 0x40
-	IPPROTO_SATMON                    = 0x45
-	IPPROTO_SCCSP                     = 0x60
-	IPPROTO_SCTP                      = 0x84
-	IPPROTO_SDRP                      = 0x2a
-	IPPROTO_SEP                       = 0x21
-	IPPROTO_SRPC                      = 0x5a
-	IPPROTO_ST                        = 0x7
-	IPPROTO_SVMTP                     = 0x52
-	IPPROTO_SWIPE                     = 0x35
-	IPPROTO_TCF                       = 0x57
-	IPPROTO_TCP                       = 0x6
-	IPPROTO_TP                        = 0x1d
-	IPPROTO_TPXX                      = 0x27
-	IPPROTO_TRUNK1                    = 0x17
-	IPPROTO_TRUNK2                    = 0x18
-	IPPROTO_TTP                       = 0x54
-	IPPROTO_UDP                       = 0x11
-	IPPROTO_VINES                     = 0x53
-	IPPROTO_VISA                      = 0x46
-	IPPROTO_VMTP                      = 0x51
-	IPPROTO_WBEXPAK                   = 0x4f
-	IPPROTO_WBMON                     = 0x4e
-	IPPROTO_WSN                       = 0x4a
-	IPPROTO_XNET                      = 0xf
-	IPPROTO_XTP                       = 0x24
-	IPV6_2292DSTOPTS                  = 0x17
-	IPV6_2292HOPLIMIT                 = 0x14
-	IPV6_2292HOPOPTS                  = 0x16
-	IPV6_2292NEXTHOP                  = 0x15
-	IPV6_2292PKTINFO                  = 0x13
-	IPV6_2292PKTOPTIONS               = 0x19
-	IPV6_2292RTHDR                    = 0x18
-	IPV6_BINDV6ONLY                   = 0x1b
-	IPV6_BOUND_IF                     = 0x7d
-	IPV6_CHECKSUM                     = 0x1a
-	IPV6_DEFAULT_MULTICAST_HOPS       = 0x1
-	IPV6_DEFAULT_MULTICAST_LOOP       = 0x1
-	IPV6_DEFHLIM                      = 0x40
-	IPV6_FAITH                        = 0x1d
-	IPV6_FLOWINFO_MASK                = 0xffffff0f
-	IPV6_FLOWLABEL_MASK               = 0xffff0f00
-	IPV6_FLOW_ECN_MASK                = 0x300
-	IPV6_FRAGTTL                      = 0x3c
-	IPV6_FW_ADD                       = 0x1e
-	IPV6_FW_DEL                       = 0x1f
-	IPV6_FW_FLUSH                     = 0x20
-	IPV6_FW_GET                       = 0x22
-	IPV6_FW_ZERO                      = 0x21
-	IPV6_HLIMDEC                      = 0x1
-	IPV6_IPSEC_POLICY                 = 0x1c
-	IPV6_JOIN_GROUP                   = 0xc
-	IPV6_LEAVE_GROUP                  = 0xd
-	IPV6_MAXHLIM                      = 0xff
-	IPV6_MAXOPTHDR                    = 0x800
-	IPV6_MAXPACKET                    = 0xffff
-	IPV6_MAX_GROUP_SRC_FILTER         = 0x200
-	IPV6_MAX_MEMBERSHIPS              = 0xfff
-	IPV6_MAX_SOCK_SRC_FILTER          = 0x80
-	IPV6_MIN_MEMBERSHIPS              = 0x1f
-	IPV6_MMTU                         = 0x500
-	IPV6_MULTICAST_HOPS               = 0xa
-	IPV6_MULTICAST_IF                 = 0x9
-	IPV6_MULTICAST_LOOP               = 0xb
-	IPV6_PORTRANGE                    = 0xe
-	IPV6_PORTRANGE_DEFAULT            = 0x0
-	IPV6_PORTRANGE_HIGH               = 0x1
-	IPV6_PORTRANGE_LOW                = 0x2
-	IPV6_RECVTCLASS                   = 0x23
-	IPV6_RTHDR_LOOSE                  = 0x0
-	IPV6_RTHDR_STRICT                 = 0x1
-	IPV6_RTHDR_TYPE_0                 = 0x0
-	IPV6_SOCKOPT_RESERVED1            = 0x3
-	IPV6_TCLASS                       = 0x24
-	IPV6_UNICAST_HOPS                 = 0x4
-	IPV6_V6ONLY                       = 0x1b
-	IPV6_VERSION                      = 0x60
-	IPV6_VERSION_MASK                 = 0xf0
-	IP_ADD_MEMBERSHIP                 = 0xc
-	IP_ADD_SOURCE_MEMBERSHIP          = 0x46
-	IP_BLOCK_SOURCE                   = 0x48
-	IP_BOUND_IF                       = 0x19
-	IP_DEFAULT_MULTICAST_LOOP         = 0x1
-	IP_DEFAULT_MULTICAST_TTL          = 0x1
-	IP_DF                             = 0x4000
-	IP_DROP_MEMBERSHIP                = 0xd
-	IP_DROP_SOURCE_MEMBERSHIP         = 0x47
-	IP_DUMMYNET_CONFIGURE             = 0x3c
-	IP_DUMMYNET_DEL                   = 0x3d
-	IP_DUMMYNET_FLUSH                 = 0x3e
-	IP_DUMMYNET_GET                   = 0x40
-	IP_FAITH                          = 0x16
-	IP_FW_ADD                         = 0x28
-	IP_FW_DEL                         = 0x29
-	IP_FW_FLUSH                       = 0x2a
-	IP_FW_GET                         = 0x2c
-	IP_FW_RESETLOG                    = 0x2d
-	IP_FW_ZERO                        = 0x2b
-	IP_HDRINCL                        = 0x2
-	IP_IPSEC_POLICY                   = 0x15
-	IP_MAXPACKET                      = 0xffff
-	IP_MAX_GROUP_SRC_FILTER           = 0x200
-	IP_MAX_MEMBERSHIPS                = 0xfff
-	IP_MAX_SOCK_MUTE_FILTER           = 0x80
-	IP_MAX_SOCK_SRC_FILTER            = 0x80
-	IP_MF                             = 0x2000
-	IP_MIN_MEMBERSHIPS                = 0x1f
-	IP_MSFILTER                       = 0x4a
-	IP_MSS                            = 0x240
-	IP_MULTICAST_IF                   = 0x9
-	IP_MULTICAST_IFINDEX              = 0x42
-	IP_MULTICAST_LOOP                 = 0xb
-	IP_MULTICAST_TTL                  = 0xa
-	IP_MULTICAST_VIF                  = 0xe
-	IP_NAT__XXX                       = 0x37
-	IP_OFFMASK                        = 0x1fff
-	IP_OLD_FW_ADD                     = 0x32
-	IP_OLD_FW_DEL                     = 0x33
-	IP_OLD_FW_FLUSH                   = 0x34
-	IP_OLD_FW_GET                     = 0x36
-	IP_OLD_FW_RESETLOG                = 0x38
-	IP_OLD_FW_ZERO                    = 0x35
-	IP_OPTIONS                        = 0x1
-	IP_PKTINFO                        = 0x1a
-	IP_PORTRANGE                      = 0x13
-	IP_PORTRANGE_DEFAULT              = 0x0
-	IP_PORTRANGE_HIGH                 = 0x1
-	IP_PORTRANGE_LOW                  = 0x2
-	IP_RECVDSTADDR                    = 0x7
-	IP_RECVIF                         = 0x14
-	IP_RECVOPTS                       = 0x5
-	IP_RECVPKTINFO                    = 0x1a
-	IP_RECVRETOPTS                    = 0x6
-	IP_RECVTOS                        = 0x1b
-	IP_RECVTTL                        = 0x18
-	IP_RETOPTS                        = 0x8
-	IP_RF                             = 0x8000
-	IP_RSVP_OFF                       = 0x10
-	IP_RSVP_ON                        = 0xf
-	IP_RSVP_VIF_OFF                   = 0x12
-	IP_RSVP_VIF_ON                    = 0x11
-	IP_STRIPHDR                       = 0x17
-	IP_TOS                            = 0x3
-	IP_TRAFFIC_MGT_BACKGROUND         = 0x41
-	IP_TTL                            = 0x4
-	IP_UNBLOCK_SOURCE                 = 0x49
-	ISIG                              = 0x80
-	ISTRIP                            = 0x20
-	IUTF8                             = 0x4000
-	IXANY                             = 0x800
-	IXOFF                             = 0x400
-	IXON                              = 0x200
-	KERN_HOSTNAME                     = 0xa
-	KERN_OSRELEASE                    = 0x2
-	KERN_OSTYPE                       = 0x1
-	KERN_VERSION                      = 0x4
-	LOCK_EX                           = 0x2
-	LOCK_NB                           = 0x4
-	LOCK_SH                           = 0x1
-	LOCK_UN                           = 0x8
-	MADV_CAN_REUSE                    = 0x9
-	MADV_DONTNEED                     = 0x4
-	MADV_FREE                         = 0x5
-	MADV_FREE_REUSABLE                = 0x7
-	MADV_FREE_REUSE                   = 0x8
-	MADV_NORMAL                       = 0x0
-	MADV_PAGEOUT                      = 0xa
-	MADV_RANDOM                       = 0x1
-	MADV_SEQUENTIAL                   = 0x2
-	MADV_WILLNEED                     = 0x3
-	MADV_ZERO_WIRED_PAGES             = 0x6
-	MAP_ANON                          = 0x1000
-	MAP_ANONYMOUS                     = 0x1000
-	MAP_COPY                          = 0x2
-	MAP_FILE                          = 0x0
-	MAP_FIXED                         = 0x10
-	MAP_HASSEMAPHORE                  = 0x200
-	MAP_JIT                           = 0x800
-	MAP_NOCACHE                       = 0x400
-	MAP_NOEXTEND                      = 0x100
-	MAP_NORESERVE                     = 0x40
-	MAP_PRIVATE                       = 0x2
-	MAP_RENAME                        = 0x20
-	MAP_RESERVED0080                  = 0x80
-	MAP_RESILIENT_CODESIGN            = 0x2000
-	MAP_RESILIENT_MEDIA               = 0x4000
-	MAP_SHARED                        = 0x1
-	MCL_CURRENT                       = 0x1
-	MCL_FUTURE                        = 0x2
-	MNT_ASYNC                         = 0x40
-	MNT_AUTOMOUNTED                   = 0x400000
-	MNT_CMDFLAGS                      = 0xf0000
-	MNT_CPROTECT                      = 0x80
-	MNT_DEFWRITE                      = 0x2000000
-	MNT_DONTBROWSE                    = 0x100000
-	MNT_DOVOLFS                       = 0x8000
-	MNT_DWAIT                         = 0x4
-	MNT_EXPORTED                      = 0x100
-	MNT_FORCE                         = 0x80000
-	MNT_IGNORE_OWNERSHIP              = 0x200000
-	MNT_JOURNALED                     = 0x800000
-	MNT_LOCAL                         = 0x1000
-	MNT_MULTILABEL                    = 0x4000000
-	MNT_NOATIME                       = 0x10000000
-	MNT_NOBLOCK                       = 0x20000
-	MNT_NODEV                         = 0x10
-	MNT_NOEXEC                        = 0x4
-	MNT_NOSUID                        = 0x8
-	MNT_NOUSERXATTR                   = 0x1000000
-	MNT_NOWAIT                        = 0x2
-	MNT_QUARANTINE                    = 0x400
-	MNT_QUOTA                         = 0x2000
-	MNT_RDONLY                        = 0x1
-	MNT_RELOAD                        = 0x40000
-	MNT_ROOTFS                        = 0x4000
-	MNT_SYNCHRONOUS                   = 0x2
-	MNT_UNION                         = 0x20
-	MNT_UNKNOWNPERMISSIONS            = 0x200000
-	MNT_UPDATE                        = 0x10000
-	MNT_VISFLAGMASK                   = 0x17f0f5ff
-	MNT_WAIT                          = 0x1
-	MSG_CTRUNC                        = 0x20
-	MSG_DONTROUTE                     = 0x4
-	MSG_DONTWAIT                      = 0x80
-	MSG_EOF                           = 0x100
-	MSG_EOR                           = 0x8
-	MSG_FLUSH                         = 0x400
-	MSG_HAVEMORE                      = 0x2000
-	MSG_HOLD                          = 0x800
-	MSG_NEEDSA                        = 0x10000
-	MSG_OOB                           = 0x1
-	MSG_PEEK                          = 0x2
-	MSG_RCVMORE                       = 0x4000
-	MSG_SEND                          = 0x1000
-	MSG_TRUNC                         = 0x10
-	MSG_WAITALL                       = 0x40
-	MSG_WAITSTREAM                    = 0x200
-	MS_ASYNC                          = 0x1
-	MS_DEACTIVATE                     = 0x8
-	MS_INVALIDATE                     = 0x2
-	MS_KILLPAGES                      = 0x4
-	MS_SYNC                           = 0x10
-	NAME_MAX                          = 0xff
-	NET_RT_DUMP                       = 0x1
-	NET_RT_DUMP2                      = 0x7
-	NET_RT_FLAGS                      = 0x2
-	NET_RT_IFLIST                     = 0x3
-	NET_RT_IFLIST2                    = 0x6
-	NET_RT_MAXID                      = 0xa
-	NET_RT_STAT                       = 0x4
-	NET_RT_TRASH                      = 0x5
-	NFDBITS                           = 0x20
-	NL0                               = 0x0
-	NL1                               = 0x100
-	NL2                               = 0x200
-	NL3                               = 0x300
-	NLDLY                             = 0x300
-	NOFLSH                            = 0x80000000
-	NOKERNINFO                        = 0x2000000
-	NOTE_ABSOLUTE                     = 0x8
-	NOTE_ATTRIB                       = 0x8
-	NOTE_BACKGROUND                   = 0x40
-	NOTE_CHILD                        = 0x4
-	NOTE_CRITICAL                     = 0x20
-	NOTE_DELETE                       = 0x1
-	NOTE_EXEC                         = 0x20000000
-	NOTE_EXIT                         = 0x80000000
-	NOTE_EXITSTATUS                   = 0x4000000
-	NOTE_EXIT_CSERROR                 = 0x40000
-	NOTE_EXIT_DECRYPTFAIL             = 0x10000
-	NOTE_EXIT_DETAIL                  = 0x2000000
-	NOTE_EXIT_DETAIL_MASK             = 0x70000
-	NOTE_EXIT_MEMORY                  = 0x20000
-	NOTE_EXIT_REPARENTED              = 0x80000
-	NOTE_EXTEND                       = 0x4
-	NOTE_FFAND                        = 0x40000000
-	NOTE_FFCOPY                       = 0xc0000000
-	NOTE_FFCTRLMASK                   = 0xc0000000
-	NOTE_FFLAGSMASK                   = 0xffffff
-	NOTE_FFNOP                        = 0x0
-	NOTE_FFOR                         = 0x80000000
-	NOTE_FORK                         = 0x40000000
-	NOTE_FUNLOCK                      = 0x100
-	NOTE_LEEWAY                       = 0x10
-	NOTE_LINK                         = 0x10
-	NOTE_LOWAT                        = 0x1
-	NOTE_MACH_CONTINUOUS_TIME         = 0x80
-	NOTE_NONE                         = 0x80
-	NOTE_NSECONDS                     = 0x4
-	NOTE_OOB                          = 0x2
-	NOTE_PCTRLMASK                    = -0x100000
-	NOTE_PDATAMASK                    = 0xfffff
-	NOTE_REAP                         = 0x10000000
-	NOTE_RENAME                       = 0x20
-	NOTE_REVOKE                       = 0x40
-	NOTE_SECONDS                      = 0x1
-	NOTE_SIGNAL                       = 0x8000000
-	NOTE_TRACK                        = 0x1
-	NOTE_TRACKERR                     = 0x2
-	NOTE_TRIGGER                      = 0x1000000
-	NOTE_USECONDS                     = 0x2
-	NOTE_VM_ERROR                     = 0x10000000
-	NOTE_VM_PRESSURE                  = 0x80000000
-	NOTE_VM_PRESSURE_SUDDEN_TERMINATE = 0x20000000
-	NOTE_VM_PRESSURE_TERMINATE        = 0x40000000
-	NOTE_WRITE                        = 0x2
-	OCRNL                             = 0x10
-	OFDEL                             = 0x20000
-	OFILL                             = 0x80
-	ONLCR                             = 0x2
-	ONLRET                            = 0x40
-	ONOCR                             = 0x20
-	ONOEOT                            = 0x8
-	OPOST                             = 0x1
-	OXTABS                            = 0x4
-	O_ACCMODE                         = 0x3
-	O_ALERT                           = 0x20000000
-	O_APPEND                          = 0x8
-	O_ASYNC                           = 0x40
-	O_CLOEXEC                         = 0x1000000
-	O_CREAT                           = 0x200
-	O_DIRECTORY                       = 0x100000
-	O_DP_GETRAWENCRYPTED              = 0x1
-	O_DP_GETRAWUNENCRYPTED            = 0x2
-	O_DSYNC                           = 0x400000
-	O_EVTONLY                         = 0x8000
-	O_EXCL                            = 0x800
-	O_EXLOCK                          = 0x20
-	O_FSYNC                           = 0x80
-	O_NDELAY                          = 0x4
-	O_NOCTTY                          = 0x20000
-	O_NOFOLLOW                        = 0x100
-	O_NONBLOCK                        = 0x4
-	O_POPUP                           = 0x80000000
-	O_RDONLY                          = 0x0
-	O_RDWR                            = 0x2
-	O_SHLOCK                          = 0x10
-	O_SYMLINK                         = 0x200000
-	O_SYNC                            = 0x80
-	O_TRUNC                           = 0x400
-	O_WRONLY                          = 0x1
-	PARENB                            = 0x1000
-	PARMRK                            = 0x8
-	PARODD                            = 0x2000
-	PENDIN                            = 0x20000000
-	PRIO_PGRP                         = 0x1
-	PRIO_PROCESS                      = 0x0
-	PRIO_USER                         = 0x2
-	PROT_EXEC                         = 0x4
-	PROT_NONE                         = 0x0
-	PROT_READ                         = 0x1
-	PROT_WRITE                        = 0x2
-	PT_ATTACH                         = 0xa
-	PT_ATTACHEXC                      = 0xe
-	PT_CONTINUE                       = 0x7
-	PT_DENY_ATTACH                    = 0x1f
-	PT_DETACH                         = 0xb
-	PT_FIRSTMACH                      = 0x20
-	PT_FORCEQUOTA                     = 0x1e
-	PT_KILL                           = 0x8
-	PT_READ_D                         = 0x2
-	PT_READ_I                         = 0x1
-	PT_READ_U                         = 0x3
-	PT_SIGEXC                         = 0xc
-	PT_STEP                           = 0x9
-	PT_THUPDATE                       = 0xd
-	PT_TRACE_ME                       = 0x0
-	PT_WRITE_D                        = 0x5
-	PT_WRITE_I                        = 0x4
-	PT_WRITE_U                        = 0x6
-	RLIMIT_AS                         = 0x5
-	RLIMIT_CORE                       = 0x4
-	RLIMIT_CPU                        = 0x0
-	RLIMIT_CPU_USAGE_MONITOR          = 0x2
-	RLIMIT_DATA                       = 0x2
-	RLIMIT_FSIZE                      = 0x1
-	RLIMIT_MEMLOCK                    = 0x6
-	RLIMIT_NOFILE                     = 0x8
-	RLIMIT_NPROC                      = 0x7
-	RLIMIT_RSS                        = 0x5
-	RLIMIT_STACK                      = 0x3
-	RLIM_INFINITY                     = 0x7fffffffffffffff
-	RTAX_AUTHOR                       = 0x6
-	RTAX_BRD                          = 0x7
-	RTAX_DST                          = 0x0
-	RTAX_GATEWAY                      = 0x1
-	RTAX_GENMASK                      = 0x3
-	RTAX_IFA                          = 0x5
-	RTAX_IFP                          = 0x4
-	RTAX_MAX                          = 0x8
-	RTAX_NETMASK                      = 0x2
-	RTA_AUTHOR                        = 0x40
-	RTA_BRD                           = 0x80
-	RTA_DST                           = 0x1
-	RTA_GATEWAY                       = 0x2
-	RTA_GENMASK                       = 0x8
-	RTA_IFA                           = 0x20
-	RTA_IFP                           = 0x10
-	RTA_NETMASK                       = 0x4
-	RTF_BLACKHOLE                     = 0x1000
-	RTF_BROADCAST                     = 0x400000
-	RTF_CLONING                       = 0x100
-	RTF_CONDEMNED                     = 0x2000000
-	RTF_DELCLONE                      = 0x80
-	RTF_DONE                          = 0x40
-	RTF_DYNAMIC                       = 0x10
-	RTF_GATEWAY                       = 0x2
-	RTF_HOST                          = 0x4
-	RTF_IFREF                         = 0x4000000
-	RTF_IFSCOPE                       = 0x1000000
-	RTF_LLINFO                        = 0x400
-	RTF_LOCAL                         = 0x200000
-	RTF_MODIFIED                      = 0x20
-	RTF_MULTICAST                     = 0x800000
-	RTF_NOIFREF                       = 0x2000
-	RTF_PINNED                        = 0x100000
-	RTF_PRCLONING                     = 0x10000
-	RTF_PROTO1                        = 0x8000
-	RTF_PROTO2                        = 0x4000
-	RTF_PROTO3                        = 0x40000
-	RTF_PROXY                         = 0x8000000
-	RTF_REJECT                        = 0x8
-	RTF_ROUTER                        = 0x10000000
-	RTF_STATIC                        = 0x800
-	RTF_UP                            = 0x1
-	RTF_WASCLONED                     = 0x20000
-	RTF_XRESOLVE                      = 0x200
-	RTM_ADD                           = 0x1
-	RTM_CHANGE                        = 0x3
-	RTM_DELADDR                       = 0xd
-	RTM_DELETE                        = 0x2
-	RTM_DELMADDR                      = 0x10
-	RTM_GET                           = 0x4
-	RTM_GET2                          = 0x14
-	RTM_IFINFO                        = 0xe
-	RTM_IFINFO2                       = 0x12
-	RTM_LOCK                          = 0x8
-	RTM_LOSING                        = 0x5
-	RTM_MISS                          = 0x7
-	RTM_NEWADDR                       = 0xc
-	RTM_NEWMADDR                      = 0xf
-	RTM_NEWMADDR2                     = 0x13
-	RTM_OLDADD                        = 0x9
-	RTM_OLDDEL                        = 0xa
-	RTM_REDIRECT                      = 0x6
-	RTM_RESOLVE                       = 0xb
-	RTM_RTTUNIT                       = 0xf4240
-	RTM_VERSION                       = 0x5
-	RTV_EXPIRE                        = 0x4
-	RTV_HOPCOUNT                      = 0x2
-	RTV_MTU                           = 0x1
-	RTV_RPIPE                         = 0x8
-	RTV_RTT                           = 0x40
-	RTV_RTTVAR                        = 0x80
-	RTV_SPIPE                         = 0x10
-	RTV_SSTHRESH                      = 0x20
-	RUSAGE_CHILDREN                   = -0x1
-	RUSAGE_SELF                       = 0x0
-	SCM_CREDS                         = 0x3
-	SCM_RIGHTS                        = 0x1
-	SCM_TIMESTAMP                     = 0x2
-	SCM_TIMESTAMP_MONOTONIC           = 0x4
-	SHUT_RD                           = 0x0
-	SHUT_RDWR                         = 0x2
-	SHUT_WR                           = 0x1
-	SIOCADDMULTI                      = 0x80206931
-	SIOCAIFADDR                       = 0x8040691a
-	SIOCARPIPLL                       = 0xc0206928
-	SIOCATMARK                        = 0x40047307
-	SIOCAUTOADDR                      = 0xc0206926
-	SIOCAUTONETMASK                   = 0x80206927
-	SIOCDELMULTI                      = 0x80206932
-	SIOCDIFADDR                       = 0x80206919
-	SIOCDIFPHYADDR                    = 0x80206941
-	SIOCGDRVSPEC                      = 0xc01c697b
-	SIOCGETVLAN                       = 0xc020697f
-	SIOCGHIWAT                        = 0x40047301
-	SIOCGIFADDR                       = 0xc0206921
-	SIOCGIFALTMTU                     = 0xc0206948
-	SIOCGIFASYNCMAP                   = 0xc020697c
-	SIOCGIFBOND                       = 0xc0206947
-	SIOCGIFBRDADDR                    = 0xc0206923
-	SIOCGIFCAP                        = 0xc020695b
-	SIOCGIFCONF                       = 0xc0086924
-	SIOCGIFDEVMTU                     = 0xc0206944
-	SIOCGIFDSTADDR                    = 0xc0206922
-	SIOCGIFFLAGS                      = 0xc0206911
-	SIOCGIFGENERIC                    = 0xc020693a
-	SIOCGIFKPI                        = 0xc0206987
-	SIOCGIFMAC                        = 0xc0206982
-	SIOCGIFMEDIA                      = 0xc0286938
-	SIOCGIFMETRIC                     = 0xc0206917
-	SIOCGIFMTU                        = 0xc0206933
-	SIOCGIFNETMASK                    = 0xc0206925
-	SIOCGIFPDSTADDR                   = 0xc0206940
-	SIOCGIFPHYS                       = 0xc0206935
-	SIOCGIFPSRCADDR                   = 0xc020693f
-	SIOCGIFSTATUS                     = 0xc331693d
-	SIOCGIFVLAN                       = 0xc020697f
-	SIOCGIFWAKEFLAGS                  = 0xc0206988
-	SIOCGLOWAT                        = 0x40047303
-	SIOCGPGRP                         = 0x40047309
-	SIOCIFCREATE                      = 0xc0206978
-	SIOCIFCREATE2                     = 0xc020697a
-	SIOCIFDESTROY                     = 0x80206979
-	SIOCIFGCLONERS                    = 0xc00c6981
-	SIOCRSLVMULTI                     = 0xc008693b
-	SIOCSDRVSPEC                      = 0x801c697b
-	SIOCSETVLAN                       = 0x8020697e
-	SIOCSHIWAT                        = 0x80047300
-	SIOCSIFADDR                       = 0x8020690c
-	SIOCSIFALTMTU                     = 0x80206945
-	SIOCSIFASYNCMAP                   = 0x8020697d
-	SIOCSIFBOND                       = 0x80206946
-	SIOCSIFBRDADDR                    = 0x80206913
-	SIOCSIFCAP                        = 0x8020695a
-	SIOCSIFDSTADDR                    = 0x8020690e
-	SIOCSIFFLAGS                      = 0x80206910
-	SIOCSIFGENERIC                    = 0x80206939
-	SIOCSIFKPI                        = 0x80206986
-	SIOCSIFLLADDR                     = 0x8020693c
-	SIOCSIFMAC                        = 0x80206983
-	SIOCSIFMEDIA                      = 0xc0206937
-	SIOCSIFMETRIC                     = 0x80206918
-	SIOCSIFMTU                        = 0x80206934
-	SIOCSIFNETMASK                    = 0x80206916
-	SIOCSIFPHYADDR                    = 0x8040693e
-	SIOCSIFPHYS                       = 0x80206936
-	SIOCSIFVLAN                       = 0x8020697e
-	SIOCSLOWAT                        = 0x80047302
-	SIOCSPGRP                         = 0x80047308
-	SOCK_DGRAM                        = 0x2
-	SOCK_MAXADDRLEN                   = 0xff
-	SOCK_RAW                          = 0x3
-	SOCK_RDM                          = 0x4
-	SOCK_SEQPACKET                    = 0x5
-	SOCK_STREAM                       = 0x1
-	SOL_SOCKET                        = 0xffff
-	SOMAXCONN                         = 0x80
-	SO_ACCEPTCONN                     = 0x2
-	SO_BROADCAST                      = 0x20
-	SO_DEBUG                          = 0x1
-	SO_DONTROUTE                      = 0x10
-	SO_DONTTRUNC                      = 0x2000
-	SO_ERROR                          = 0x1007
-	SO_KEEPALIVE                      = 0x8
-	SO_LABEL                          = 0x1010
-	SO_LINGER                         = 0x80
-	SO_LINGER_SEC                     = 0x1080
-	SO_NETSVC_MARKING_LEVEL           = 0x1119
-	SO_NET_SERVICE_TYPE               = 0x1116
-	SO_NKE                            = 0x1021
-	SO_NOADDRERR                      = 0x1023
-	SO_NOSIGPIPE                      = 0x1022
-	SO_NOTIFYCONFLICT                 = 0x1026
-	SO_NP_EXTENSIONS                  = 0x1083
-	SO_NREAD                          = 0x1020
-	SO_NUMRCVPKT                      = 0x1112
-	SO_NWRITE                         = 0x1024
-	SO_OOBINLINE                      = 0x100
-	SO_PEERLABEL                      = 0x1011
-	SO_RANDOMPORT                     = 0x1082
-	SO_RCVBUF                         = 0x1002
-	SO_RCVLOWAT                       = 0x1004
-	SO_RCVTIMEO                       = 0x1006
-	SO_REUSEADDR                      = 0x4
-	SO_REUSEPORT                      = 0x200
-	SO_REUSESHAREUID                  = 0x1025
-	SO_SNDBUF                         = 0x1001
-	SO_SNDLOWAT                       = 0x1003
-	SO_SNDTIMEO                       = 0x1005
-	SO_TIMESTAMP                      = 0x400
-	SO_TIMESTAMP_MONOTONIC            = 0x800
-	SO_TYPE                           = 0x1008
-	SO_UPCALLCLOSEWAIT                = 0x1027
-	SO_USELOOPBACK                    = 0x40
-	SO_WANTMORE                       = 0x4000
-	SO_WANTOOBFLAG                    = 0x8000
-	S_IEXEC                           = 0x40
-	S_IFBLK                           = 0x6000
-	S_IFCHR                           = 0x2000
-	S_IFDIR                           = 0x4000
-	S_IFIFO                           = 0x1000
-	S_IFLNK                           = 0xa000
-	S_IFMT                            = 0xf000
-	S_IFREG                           = 0x8000
-	S_IFSOCK                          = 0xc000
-	S_IFWHT                           = 0xe000
-	S_IREAD                           = 0x100
-	S_IRGRP                           = 0x20
-	S_IROTH                           = 0x4
-	S_IRUSR                           = 0x100
-	S_IRWXG                           = 0x38
-	S_IRWXO                           = 0x7
-	S_IRWXU                           = 0x1c0
-	S_ISGID                           = 0x400
-	S_ISTXT                           = 0x200
-	S_ISUID                           = 0x800
-	S_ISVTX                           = 0x200
-	S_IWGRP                           = 0x10
-	S_IWOTH                           = 0x2
-	S_IWRITE                          = 0x80
-	S_IWUSR                           = 0x80
-	S_IXGRP                           = 0x8
-	S_IXOTH                           = 0x1
-	S_IXUSR                           = 0x40
-	TAB0                              = 0x0
-	TAB1                              = 0x400
-	TAB2                              = 0x800
-	TAB3                              = 0x4
-	TABDLY                            = 0xc04
-	TCIFLUSH                          = 0x1
-	TCIOFF                            = 0x3
-	TCIOFLUSH                         = 0x3
-	TCION                             = 0x4
-	TCOFLUSH                          = 0x2
-	TCOOFF                            = 0x1
-	TCOON                             = 0x2
-	TCP_CONNECTIONTIMEOUT             = 0x20
-	TCP_CONNECTION_INFO               = 0x106
-	TCP_ENABLE_ECN                    = 0x104
-	TCP_FASTOPEN                      = 0x105
-	TCP_KEEPALIVE                     = 0x10
-	TCP_KEEPCNT                       = 0x102
-	TCP_KEEPINTVL                     = 0x101
-	TCP_MAXHLEN                       = 0x3c
-	TCP_MAXOLEN                       = 0x28
-	TCP_MAXSEG                        = 0x2
-	TCP_MAXWIN                        = 0xffff
-	TCP_MAX_SACK                      = 0x4
-	TCP_MAX_WINSHIFT                  = 0xe
-	TCP_MINMSS                        = 0xd8
-	TCP_MSS                           = 0x200
-	TCP_NODELAY                       = 0x1
-	TCP_NOOPT                         = 0x8
-	TCP_NOPUSH                        = 0x4
-	TCP_NOTSENT_LOWAT                 = 0x201
-	TCP_RXT_CONNDROPTIME              = 0x80
-	TCP_RXT_FINDROP                   = 0x100
-	TCP_SENDMOREACKS                  = 0x103
-	TCSAFLUSH                         = 0x2
-	TIOCCBRK                          = 0x2000747a
-	TIOCCDTR                          = 0x20007478
-	TIOCCONS                          = 0x80047462
-	TIOCDCDTIMESTAMP                  = 0x40087458
-	TIOCDRAIN                         = 0x2000745e
-	TIOCDSIMICROCODE                  = 0x20007455
-	TIOCEXCL                          = 0x2000740d
-	TIOCEXT                           = 0x80047460
-	TIOCFLUSH                         = 0x80047410
-	TIOCGDRAINWAIT                    = 0x40047456
-	TIOCGETA                          = 0x402c7413
-	TIOCGETD                          = 0x4004741a
-	TIOCGPGRP                         = 0x40047477
-	TIOCGWINSZ                        = 0x40087468
-	TIOCIXOFF                         = 0x20007480
-	TIOCIXON                          = 0x20007481
-	TIOCMBIC                          = 0x8004746b
-	TIOCMBIS                          = 0x8004746c
-	TIOCMGDTRWAIT                     = 0x4004745a
-	TIOCMGET                          = 0x4004746a
-	TIOCMODG                          = 0x40047403
-	TIOCMODS                          = 0x80047404
-	TIOCMSDTRWAIT                     = 0x8004745b
-	TIOCMSET                          = 0x8004746d
-	TIOCM_CAR                         = 0x40
-	TIOCM_CD                          = 0x40
-	TIOCM_CTS                         = 0x20
-	TIOCM_DSR                         = 0x100
-	TIOCM_DTR                         = 0x2
-	TIOCM_LE                          = 0x1
-	TIOCM_RI                          = 0x80
-	TIOCM_RNG                         = 0x80
-	TIOCM_RTS                         = 0x4
-	TIOCM_SR                          = 0x10
-	TIOCM_ST                          = 0x8
-	TIOCNOTTY                         = 0x20007471
-	TIOCNXCL                          = 0x2000740e
-	TIOCOUTQ                          = 0x40047473
-	TIOCPKT                           = 0x80047470
-	TIOCPKT_DATA                      = 0x0
-	TIOCPKT_DOSTOP                    = 0x20
-	TIOCPKT_FLUSHREAD                 = 0x1
-	TIOCPKT_FLUSHWRITE                = 0x2
-	TIOCPKT_IOCTL                     = 0x40
-	TIOCPKT_NOSTOP                    = 0x10
-	TIOCPKT_START                     = 0x8
-	TIOCPKT_STOP                      = 0x4
-	TIOCPTYGNAME                      = 0x40807453
-	TIOCPTYGRANT                      = 0x20007454
-	TIOCPTYUNLK                       = 0x20007452
-	TIOCREMOTE                        = 0x80047469
-	TIOCSBRK                          = 0x2000747b
-	TIOCSCONS                         = 0x20007463
-	TIOCSCTTY                         = 0x20007461
-	TIOCSDRAINWAIT                    = 0x80047457
-	TIOCSDTR                          = 0x20007479
-	TIOCSETA                          = 0x802c7414
-	TIOCSETAF                         = 0x802c7416
-	TIOCSETAW                         = 0x802c7415
-	TIOCSETD                          = 0x8004741b
-	TIOCSIG                           = 0x2000745f
-	TIOCSPGRP                         = 0x80047476
-	TIOCSTART                         = 0x2000746e
-	TIOCSTAT                          = 0x20007465
-	TIOCSTI                           = 0x80017472
-	TIOCSTOP                          = 0x2000746f
-	TIOCSWINSZ                        = 0x80087467
-	TIOCTIMESTAMP                     = 0x40087459
-	TIOCUCNTL                         = 0x80047466
-	TOSTOP                            = 0x400000
-	VDISCARD                          = 0xf
-	VDSUSP                            = 0xb
-	VEOF                              = 0x0
-	VEOL                              = 0x1
-	VEOL2                             = 0x2
-	VERASE                            = 0x3
-	VINTR                             = 0x8
-	VKILL                             = 0x5
-	VLNEXT                            = 0xe
-	VMIN                              = 0x10
-	VM_LOADAVG                        = 0x2
-	VM_MACHFACTOR                     = 0x4
-	VM_MAXID                          = 0x6
-	VM_METER                          = 0x1
-	VM_SWAPUSAGE                      = 0x5
-	VQUIT                             = 0x9
-	VREPRINT                          = 0x6
-	VSTART                            = 0xc
-	VSTATUS                           = 0x12
-	VSTOP                             = 0xd
-	VSUSP                             = 0xa
-	VT0                               = 0x0
-	VT1                               = 0x10000
-	VTDLY                             = 0x10000
-	VTIME                             = 0x11
-	VWERASE                           = 0x4
-	WCONTINUED                        = 0x10
-	WCOREFLAG                         = 0x80
-	WEXITED                           = 0x4
-	WNOHANG                           = 0x1
-	WNOWAIT                           = 0x20
-	WORDSIZE                          = 0x20
-	WSTOPPED                          = 0x8
-	WUNTRACED                         = 0x2
-	XATTR_CREATE                      = 0x2
-	XATTR_NODEFAULT                   = 0x10
-	XATTR_NOFOLLOW                    = 0x1
-	XATTR_NOSECURITY                  = 0x8
-	XATTR_REPLACE                     = 0x4
-	XATTR_SHOWCOMPRESSION             = 0x20
-)
-
-// Errors
-const (
-	E2BIG           = syscall.Errno(0x7)
-	EACCES          = syscall.Errno(0xd)
-	EADDRINUSE      = syscall.Errno(0x30)
-	EADDRNOTAVAIL   = syscall.Errno(0x31)
-	EAFNOSUPPORT    = syscall.Errno(0x2f)
-	EAGAIN          = syscall.Errno(0x23)
-	EALREADY        = syscall.Errno(0x25)
-	EAUTH           = syscall.Errno(0x50)
-	EBADARCH        = syscall.Errno(0x56)
-	EBADEXEC        = syscall.Errno(0x55)
-	EBADF           = syscall.Errno(0x9)
-	EBADMACHO       = syscall.Errno(0x58)
-	EBADMSG         = syscall.Errno(0x5e)
-	EBADRPC         = syscall.Errno(0x48)
-	EBUSY           = syscall.Errno(0x10)
-	ECANCELED       = syscall.Errno(0x59)
-	ECHILD          = syscall.Errno(0xa)
-	ECONNABORTED    = syscall.Errno(0x35)
-	ECONNREFUSED    = syscall.Errno(0x3d)
-	ECONNRESET      = syscall.Errno(0x36)
-	EDEADLK         = syscall.Errno(0xb)
-	EDESTADDRREQ    = syscall.Errno(0x27)
-	EDEVERR         = syscall.Errno(0x53)
-	EDOM            = syscall.Errno(0x21)
-	EDQUOT          = syscall.Errno(0x45)
-	EEXIST          = syscall.Errno(0x11)
-	EFAULT          = syscall.Errno(0xe)
-	EFBIG           = syscall.Errno(0x1b)
-	EFTYPE          = syscall.Errno(0x4f)
-	EHOSTDOWN       = syscall.Errno(0x40)
-	EHOSTUNREACH    = syscall.Errno(0x41)
-	EIDRM           = syscall.Errno(0x5a)
-	EILSEQ          = syscall.Errno(0x5c)
-	EINPROGRESS     = syscall.Errno(0x24)
-	EINTR           = syscall.Errno(0x4)
-	EINVAL          = syscall.Errno(0x16)
-	EIO             = syscall.Errno(0x5)
-	EISCONN         = syscall.Errno(0x38)
-	EISDIR          = syscall.Errno(0x15)
-	ELAST           = syscall.Errno(0x6a)
-	ELOOP           = syscall.Errno(0x3e)
-	EMFILE          = syscall.Errno(0x18)
-	EMLINK          = syscall.Errno(0x1f)
-	EMSGSIZE        = syscall.Errno(0x28)
-	EMULTIHOP       = syscall.Errno(0x5f)
-	ENAMETOOLONG    = syscall.Errno(0x3f)
-	ENEEDAUTH       = syscall.Errno(0x51)
-	ENETDOWN        = syscall.Errno(0x32)
-	ENETRESET       = syscall.Errno(0x34)
-	ENETUNREACH     = syscall.Errno(0x33)
-	ENFILE          = syscall.Errno(0x17)
-	ENOATTR         = syscall.Errno(0x5d)
-	ENOBUFS         = syscall.Errno(0x37)
-	ENODATA         = syscall.Errno(0x60)
-	ENODEV          = syscall.Errno(0x13)
-	ENOENT          = syscall.Errno(0x2)
-	ENOEXEC         = syscall.Errno(0x8)
-	ENOLCK          = syscall.Errno(0x4d)
-	ENOLINK         = syscall.Errno(0x61)
-	ENOMEM          = syscall.Errno(0xc)
-	ENOMSG          = syscall.Errno(0x5b)
-	ENOPOLICY       = syscall.Errno(0x67)
-	ENOPROTOOPT     = syscall.Errno(0x2a)
-	ENOSPC          = syscall.Errno(0x1c)
-	ENOSR           = syscall.Errno(0x62)
-	ENOSTR          = syscall.Errno(0x63)
-	ENOSYS          = syscall.Errno(0x4e)
-	ENOTBLK         = syscall.Errno(0xf)
-	ENOTCONN        = syscall.Errno(0x39)
-	ENOTDIR         = syscall.Errno(0x14)
-	ENOTEMPTY       = syscall.Errno(0x42)
-	ENOTRECOVERABLE = syscall.Errno(0x68)
-	ENOTSOCK        = syscall.Errno(0x26)
-	ENOTSUP         = syscall.Errno(0x2d)
-	ENOTTY          = syscall.Errno(0x19)
-	ENXIO           = syscall.Errno(0x6)
-	EOPNOTSUPP      = syscall.Errno(0x66)
-	EOVERFLOW       = syscall.Errno(0x54)
-	EOWNERDEAD      = syscall.Errno(0x69)
-	EPERM           = syscall.Errno(0x1)
-	EPFNOSUPPORT    = syscall.Errno(0x2e)
-	EPIPE           = syscall.Errno(0x20)
-	EPROCLIM        = syscall.Errno(0x43)
-	EPROCUNAVAIL    = syscall.Errno(0x4c)
-	EPROGMISMATCH   = syscall.Errno(0x4b)
-	EPROGUNAVAIL    = syscall.Errno(0x4a)
-	EPROTO          = syscall.Errno(0x64)
-	EPROTONOSUPPORT = syscall.Errno(0x2b)
-	EPROTOTYPE      = syscall.Errno(0x29)
-	EPWROFF         = syscall.Errno(0x52)
-	EQFULL          = syscall.Errno(0x6a)
-	ERANGE          = syscall.Errno(0x22)
-	EREMOTE         = syscall.Errno(0x47)
-	EROFS           = syscall.Errno(0x1e)
-	ERPCMISMATCH    = syscall.Errno(0x49)
-	ESHLIBVERS      = syscall.Errno(0x57)
-	ESHUTDOWN       = syscall.Errno(0x3a)
-	ESOCKTNOSUPPORT = syscall.Errno(0x2c)
-	ESPIPE          = syscall.Errno(0x1d)
-	ESRCH           = syscall.Errno(0x3)
-	ESTALE          = syscall.Errno(0x46)
-	ETIME           = syscall.Errno(0x65)
-	ETIMEDOUT       = syscall.Errno(0x3c)
-	ETOOMANYREFS    = syscall.Errno(0x3b)
-	ETXTBSY         = syscall.Errno(0x1a)
-	EUSERS          = syscall.Errno(0x44)
-	EWOULDBLOCK     = syscall.Errno(0x23)
-	EXDEV           = syscall.Errno(0x12)
-)
-
-// Signals
-const (
-	SIGABRT   = syscall.Signal(0x6)
-	SIGALRM   = syscall.Signal(0xe)
-	SIGBUS    = syscall.Signal(0xa)
-	SIGCHLD   = syscall.Signal(0x14)
-	SIGCONT   = syscall.Signal(0x13)
-	SIGEMT    = syscall.Signal(0x7)
-	SIGFPE    = syscall.Signal(0x8)
-	SIGHUP    = syscall.Signal(0x1)
-	SIGILL    = syscall.Signal(0x4)
-	SIGINFO   = syscall.Signal(0x1d)
-	SIGINT    = syscall.Signal(0x2)
-	SIGIO     = syscall.Signal(0x17)
-	SIGIOT    = syscall.Signal(0x6)
-	SIGKILL   = syscall.Signal(0x9)
-	SIGPIPE   = syscall.Signal(0xd)
-	SIGPROF   = syscall.Signal(0x1b)
-	SIGQUIT   = syscall.Signal(0x3)
-	SIGSEGV   = syscall.Signal(0xb)
-	SIGSTOP   = syscall.Signal(0x11)
-	SIGSYS    = syscall.Signal(0xc)
-	SIGTERM   = syscall.Signal(0xf)
-	SIGTRAP   = syscall.Signal(0x5)
-	SIGTSTP   = syscall.Signal(0x12)
-	SIGTTIN   = syscall.Signal(0x15)
-	SIGTTOU   = syscall.Signal(0x16)
-	SIGURG    = syscall.Signal(0x10)
-	SIGUSR1   = syscall.Signal(0x1e)
-	SIGUSR2   = syscall.Signal(0x1f)
-	SIGVTALRM = syscall.Signal(0x1a)
-	SIGWINCH  = syscall.Signal(0x1c)
-	SIGXCPU   = syscall.Signal(0x18)
-	SIGXFSZ   = syscall.Signal(0x19)
-)
-
-// Error table
-var errorList = [...]struct {
-	num  syscall.Errno
-	name string
-	desc string
-}{
-	{1, "EPERM", "operation not permitted"},
-	{2, "ENOENT", "no such file or directory"},
-	{3, "ESRCH", "no such process"},
-	{4, "EINTR", "interrupted system call"},
-	{5, "EIO", "input/output error"},
-	{6, "ENXIO", "device not configured"},
-	{7, "E2BIG", "argument list too long"},
-	{8, "ENOEXEC", "exec format error"},
-	{9, "EBADF", "bad file descriptor"},
-	{10, "ECHILD", "no child processes"},
-	{11, "EDEADLK", "resource deadlock avoided"},
-	{12, "ENOMEM", "cannot allocate memory"},
-	{13, "EACCES", "permission denied"},
-	{14, "EFAULT", "bad address"},
-	{15, "ENOTBLK", "block device required"},
-	{16, "EBUSY", "resource busy"},
-	{17, "EEXIST", "file exists"},
-	{18, "EXDEV", "cross-device link"},
-	{19, "ENODEV", "operation not supported by device"},
-	{20, "ENOTDIR", "not a directory"},
-	{21, "EISDIR", "is a directory"},
-	{22, "EINVAL", "invalid argument"},
-	{23, "ENFILE", "too many open files in system"},
-	{24, "EMFILE", "too many open files"},
-	{25, "ENOTTY", "inappropriate ioctl for device"},
-	{26, "ETXTBSY", "text file busy"},
-	{27, "EFBIG", "file too large"},
-	{28, "ENOSPC", "no space left on device"},
-	{29, "ESPIPE", "illegal seek"},
-	{30, "EROFS", "read-only file system"},
-	{31, "EMLINK", "too many links"},
-	{32, "EPIPE", "broken pipe"},
-	{33, "EDOM", "numerical argument out of domain"},
-	{34, "ERANGE", "result too large"},
-	{35, "EAGAIN", "resource temporarily unavailable"},
-	{36, "EINPROGRESS", "operation now in progress"},
-	{37, "EALREADY", "operation already in progress"},
-	{38, "ENOTSOCK", "socket operation on non-socket"},
-	{39, "EDESTADDRREQ", "destination address required"},
-	{40, "EMSGSIZE", "message too long"},
-	{41, "EPROTOTYPE", "protocol wrong type for socket"},
-	{42, "ENOPROTOOPT", "protocol not available"},
-	{43, "EPROTONOSUPPORT", "protocol not supported"},
-	{44, "ESOCKTNOSUPPORT", "socket type not supported"},
-	{45, "ENOTSUP", "operation not supported"},
-	{46, "EPFNOSUPPORT", "protocol family not supported"},
-	{47, "EAFNOSUPPORT", "address family not supported by protocol family"},
-	{48, "EADDRINUSE", "address already in use"},
-	{49, "EADDRNOTAVAIL", "can't assign requested address"},
-	{50, "ENETDOWN", "network is down"},
-	{51, "ENETUNREACH", "network is unreachable"},
-	{52, "ENETRESET", "network dropped connection on reset"},
-	{53, "ECONNABORTED", "software caused connection abort"},
-	{54, "ECONNRESET", "connection reset by peer"},
-	{55, "ENOBUFS", "no buffer space available"},
-	{56, "EISCONN", "socket is already connected"},
-	{57, "ENOTCONN", "socket is not connected"},
-	{58, "ESHUTDOWN", "can't send after socket shutdown"},
-	{59, "ETOOMANYREFS", "too many references: can't splice"},
-	{60, "ETIMEDOUT", "operation timed out"},
-	{61, "ECONNREFUSED", "connection refused"},
-	{62, "ELOOP", "too many levels of symbolic links"},
-	{63, "ENAMETOOLONG", "file name too long"},
-	{64, "EHOSTDOWN", "host is down"},
-	{65, "EHOSTUNREACH", "no route to host"},
-	{66, "ENOTEMPTY", "directory not empty"},
-	{67, "EPROCLIM", "too many processes"},
-	{68, "EUSERS", "too many users"},
-	{69, "EDQUOT", "disc quota exceeded"},
-	{70, "ESTALE", "stale NFS file handle"},
-	{71, "EREMOTE", "too many levels of remote in path"},
-	{72, "EBADRPC", "RPC struct is bad"},
-	{73, "ERPCMISMATCH", "RPC version wrong"},
-	{74, "EPROGUNAVAIL", "RPC prog. not avail"},
-	{75, "EPROGMISMATCH", "program version wrong"},
-	{76, "EPROCUNAVAIL", "bad procedure for program"},
-	{77, "ENOLCK", "no locks available"},
-	{78, "ENOSYS", "function not implemented"},
-	{79, "EFTYPE", "inappropriate file type or format"},
-	{80, "EAUTH", "authentication error"},
-	{81, "ENEEDAUTH", "need authenticator"},
-	{82, "EPWROFF", "device power is off"},
-	{83, "EDEVERR", "device error"},
-	{84, "EOVERFLOW", "value too large to be stored in data type"},
-	{85, "EBADEXEC", "bad executable (or shared library)"},
-	{86, "EBADARCH", "bad CPU type in executable"},
-	{87, "ESHLIBVERS", "shared library version mismatch"},
-	{88, "EBADMACHO", "malformed Mach-o file"},
-	{89, "ECANCELED", "operation canceled"},
-	{90, "EIDRM", "identifier removed"},
-	{91, "ENOMSG", "no message of desired type"},
-	{92, "EILSEQ", "illegal byte sequence"},
-	{93, "ENOATTR", "attribute not found"},
-	{94, "EBADMSG", "bad message"},
-	{95, "EMULTIHOP", "EMULTIHOP (Reserved)"},
-	{96, "ENODATA", "no message available on STREAM"},
-	{97, "ENOLINK", "ENOLINK (Reserved)"},
-	{98, "ENOSR", "no STREAM resources"},
-	{99, "ENOSTR", "not a STREAM"},
-	{100, "EPROTO", "protocol error"},
-	{101, "ETIME", "STREAM ioctl timeout"},
-	{102, "EOPNOTSUPP", "operation not supported on socket"},
-	{103, "ENOPOLICY", "policy not found"},
-	{104, "ENOTRECOVERABLE", "state not recoverable"},
-	{105, "EOWNERDEAD", "previous owner died"},
-	{106, "EQFULL", "interface output queue is full"},
-}
-
-// Signal table
-var signalList = [...]struct {
-	num  syscall.Signal
-	name string
-	desc string
-}{
-	{1, "SIGHUP", "hangup"},
-	{2, "SIGINT", "interrupt"},
-	{3, "SIGQUIT", "quit"},
-	{4, "SIGILL", "illegal instruction"},
-	{5, "SIGTRAP", "trace/BPT trap"},
-	{6, "SIGABRT", "abort trap"},
-	{7, "SIGEMT", "EMT trap"},
-	{8, "SIGFPE", "floating point exception"},
-	{9, "SIGKILL", "killed"},
-	{10, "SIGBUS", "bus error"},
-	{11, "SIGSEGV", "segmentation fault"},
-	{12, "SIGSYS", "bad system call"},
-	{13, "SIGPIPE", "broken pipe"},
-	{14, "SIGALRM", "alarm clock"},
-	{15, "SIGTERM", "terminated"},
-	{16, "SIGURG", "urgent I/O condition"},
-	{17, "SIGSTOP", "suspended (signal)"},
-	{18, "SIGTSTP", "suspended"},
-	{19, "SIGCONT", "continued"},
-	{20, "SIGCHLD", "child exited"},
-	{21, "SIGTTIN", "stopped (tty input)"},
-	{22, "SIGTTOU", "stopped (tty output)"},
-	{23, "SIGIO", "I/O possible"},
-	{24, "SIGXCPU", "cputime limit exceeded"},
-	{25, "SIGXFSZ", "filesize limit exceeded"},
-	{26, "SIGVTALRM", "virtual timer expired"},
-	{27, "SIGPROF", "profiling timer expired"},
-	{28, "SIGWINCH", "window size changes"},
-	{29, "SIGINFO", "information request"},
-	{30, "SIGUSR1", "user defined signal 1"},
-	{31, "SIGUSR2", "user defined signal 2"},
-}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_arm.go
deleted file mode 100644
index e748cb1105..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_darwin_arm.go
+++ /dev/null
@@ -1,1789 +0,0 @@
-// mkerrors.sh
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-//go:build arm && darwin
-// +build arm,darwin
-
-// Code generated by cmd/cgo -godefs; DO NOT EDIT.
-// cgo -godefs -- _const.go
-
-package unix
-
-import "syscall"
-
-const (
-	AF_APPLETALK                      = 0x10
-	AF_CCITT                          = 0xa
-	AF_CHAOS                          = 0x5
-	AF_CNT                            = 0x15
-	AF_COIP                           = 0x14
-	AF_DATAKIT                        = 0x9
-	AF_DECnet                         = 0xc
-	AF_DLI                            = 0xd
-	AF_E164                           = 0x1c
-	AF_ECMA                           = 0x8
-	AF_HYLINK                         = 0xf
-	AF_IEEE80211                      = 0x25
-	AF_IMPLINK                        = 0x3
-	AF_INET                           = 0x2
-	AF_INET6                          = 0x1e
-	AF_IPX                            = 0x17
-	AF_ISDN                           = 0x1c
-	AF_ISO                            = 0x7
-	AF_LAT                            = 0xe
-	AF_LINK                           = 0x12
-	AF_LOCAL                          = 0x1
-	AF_MAX                            = 0x28
-	AF_NATM                           = 0x1f
-	AF_NDRV                           = 0x1b
-	AF_NETBIOS                        = 0x21
-	AF_NS                             = 0x6
-	AF_OSI                            = 0x7
-	AF_PPP                            = 0x22
-	AF_PUP                            = 0x4
-	AF_RESERVED_36                    = 0x24
-	AF_ROUTE                          = 0x11
-	AF_SIP                            = 0x18
-	AF_SNA                            = 0xb
-	AF_SYSTEM                         = 0x20
-	AF_SYS_CONTROL                    = 0x2
-	AF_UNIX                           = 0x1
-	AF_UNSPEC                         = 0x0
-	AF_UTUN                           = 0x26
-	ALTWERASE                         = 0x200
-	ATTR_BIT_MAP_COUNT                = 0x5
-	ATTR_CMN_ACCESSMASK               = 0x20000
-	ATTR_CMN_ACCTIME                  = 0x1000
-	ATTR_CMN_ADDEDTIME                = 0x10000000
-	ATTR_CMN_BKUPTIME                 = 0x2000
-	ATTR_CMN_CHGTIME                  = 0x800
-	ATTR_CMN_CRTIME                   = 0x200
-	ATTR_CMN_DATA_PROTECT_FLAGS       = 0x40000000
-	ATTR_CMN_DEVID                    = 0x2
-	ATTR_CMN_DOCUMENT_ID              = 0x100000
-	ATTR_CMN_ERROR                    = 0x20000000
-	ATTR_CMN_EXTENDED_SECURITY        = 0x400000
-	ATTR_CMN_FILEID                   = 0x2000000
-	ATTR_CMN_FLAGS                    = 0x40000
-	ATTR_CMN_FNDRINFO                 = 0x4000
-	ATTR_CMN_FSID                     = 0x4
-	ATTR_CMN_FULLPATH                 = 0x8000000
-	ATTR_CMN_GEN_COUNT                = 0x80000
-	ATTR_CMN_GRPID                    = 0x10000
-	ATTR_CMN_GRPUUID                  = 0x1000000
-	ATTR_CMN_MODTIME                  = 0x400
-	ATTR_CMN_NAME                     = 0x1
-	ATTR_CMN_NAMEDATTRCOUNT           = 0x80000
-	ATTR_CMN_NAMEDATTRLIST            = 0x100000
-	ATTR_CMN_OBJID                    = 0x20
-	ATTR_CMN_OBJPERMANENTID           = 0x40
-	ATTR_CMN_OBJTAG                   = 0x10
-	ATTR_CMN_OBJTYPE                  = 0x8
-	ATTR_CMN_OWNERID                  = 0x8000
-	ATTR_CMN_PARENTID                 = 0x4000000
-	ATTR_CMN_PAROBJID                 = 0x80
-	ATTR_CMN_RETURNED_ATTRS           = 0x80000000
-	ATTR_CMN_SCRIPT                   = 0x100
-	ATTR_CMN_SETMASK                  = 0x41c7ff00
-	ATTR_CMN_USERACCESS               = 0x200000
-	ATTR_CMN_UUID                     = 0x800000
-	ATTR_CMN_VALIDMASK                = 0xffffffff
-	ATTR_CMN_VOLSETMASK               = 0x6700
-	ATTR_FILE_ALLOCSIZE               = 0x4
-	ATTR_FILE_CLUMPSIZE               = 0x10
-	ATTR_FILE_DATAALLOCSIZE           = 0x400
-	ATTR_FILE_DATAEXTENTS             = 0x800
-	ATTR_FILE_DATALENGTH              = 0x200
-	ATTR_FILE_DEVTYPE                 = 0x20
-	ATTR_FILE_FILETYPE                = 0x40
-	ATTR_FILE_FORKCOUNT               = 0x80
-	ATTR_FILE_FORKLIST                = 0x100
-	ATTR_FILE_IOBLOCKSIZE             = 0x8
-	ATTR_FILE_LINKCOUNT               = 0x1
-	ATTR_FILE_RSRCALLOCSIZE           = 0x2000
-	ATTR_FILE_RSRCEXTENTS             = 0x4000
-	ATTR_FILE_RSRCLENGTH              = 0x1000
-	ATTR_FILE_SETMASK                 = 0x20
-	ATTR_FILE_TOTALSIZE               = 0x2
-	ATTR_FILE_VALIDMASK               = 0x37ff
-	ATTR_VOL_ALLOCATIONCLUMP          = 0x40
-	ATTR_VOL_ATTRIBUTES               = 0x40000000
-	ATTR_VOL_CAPABILITIES             = 0x20000
-	ATTR_VOL_DIRCOUNT                 = 0x400
-	ATTR_VOL_ENCODINGSUSED            = 0x10000
-	ATTR_VOL_FILECOUNT                = 0x200
-	ATTR_VOL_FSTYPE                   = 0x1
-	ATTR_VOL_INFO                     = 0x80000000
-	ATTR_VOL_IOBLOCKSIZE              = 0x80
-	ATTR_VOL_MAXOBJCOUNT              = 0x800
-	ATTR_VOL_MINALLOCATION            = 0x20
-	ATTR_VOL_MOUNTEDDEVICE            = 0x8000
-	ATTR_VOL_MOUNTFLAGS               = 0x4000
-	ATTR_VOL_MOUNTPOINT               = 0x1000
-	ATTR_VOL_NAME                     = 0x2000
-	ATTR_VOL_OBJCOUNT                 = 0x100
-	ATTR_VOL_QUOTA_SIZE               = 0x10000000
-	ATTR_VOL_RESERVED_SIZE            = 0x20000000
-	ATTR_VOL_SETMASK                  = 0x80002000
-	ATTR_VOL_SIGNATURE                = 0x2
-	ATTR_VOL_SIZE                     = 0x4
-	ATTR_VOL_SPACEAVAIL               = 0x10
-	ATTR_VOL_SPACEFREE                = 0x8
-	ATTR_VOL_UUID                     = 0x40000
-	ATTR_VOL_VALIDMASK                = 0xf007ffff
-	B0                                = 0x0
-	B110                              = 0x6e
-	B115200                           = 0x1c200
-	B1200                             = 0x4b0
-	B134                              = 0x86
-	B14400                            = 0x3840
-	B150                              = 0x96
-	B1800                             = 0x708
-	B19200                            = 0x4b00
-	B200                              = 0xc8
-	B230400                           = 0x38400
-	B2400                             = 0x960
-	B28800                            = 0x7080
-	B300                              = 0x12c
-	B38400                            = 0x9600
-	B4800                             = 0x12c0
-	B50                               = 0x32
-	B57600                            = 0xe100
-	B600                              = 0x258
-	B7200                             = 0x1c20
-	B75                               = 0x4b
-	B76800                            = 0x12c00
-	B9600                             = 0x2580
-	BIOCFLUSH                         = 0x20004268
-	BIOCGBLEN                         = 0x40044266
-	BIOCGDLT                          = 0x4004426a
-	BIOCGDLTLIST                      = 0xc00c4279
-	BIOCGETIF                         = 0x4020426b
-	BIOCGHDRCMPLT                     = 0x40044274
-	BIOCGRSIG                         = 0x40044272
-	BIOCGRTIMEOUT                     = 0x4010426e
-	BIOCGSEESENT                      = 0x40044276
-	BIOCGSTATS                        = 0x4008426f
-	BIOCIMMEDIATE                     = 0x80044270
-	BIOCPROMISC                       = 0x20004269
-	BIOCSBLEN                         = 0xc0044266
-	BIOCSDLT                          = 0x80044278
-	BIOCSETF                          = 0x80104267
-	BIOCSETFNR                        = 0x8010427e
-	BIOCSETIF                         = 0x8020426c
-	BIOCSHDRCMPLT                     = 0x80044275
-	BIOCSRSIG                         = 0x80044273
-	BIOCSRTIMEOUT                     = 0x8010426d
-	BIOCSSEESENT                      = 0x80044277
-	BIOCVERSION                       = 0x40044271
-	BPF_A                             = 0x10
-	BPF_ABS                           = 0x20
-	BPF_ADD                           = 0x0
-	BPF_ALIGNMENT                     = 0x4
-	BPF_ALU                           = 0x4
-	BPF_AND                           = 0x50
-	BPF_B                             = 0x10
-	BPF_DIV                           = 0x30
-	BPF_H                             = 0x8
-	BPF_IMM                           = 0x0
-	BPF_IND                           = 0x40
-	BPF_JA                            = 0x0
-	BPF_JEQ                           = 0x10
-	BPF_JGE                           = 0x30
-	BPF_JGT                           = 0x20
-	BPF_JMP                           = 0x5
-	BPF_JSET                          = 0x40
-	BPF_K                             = 0x0
-	BPF_LD                            = 0x0
-	BPF_LDX                           = 0x1
-	BPF_LEN                           = 0x80
-	BPF_LSH                           = 0x60
-	BPF_MAJOR_VERSION                 = 0x1
-	BPF_MAXBUFSIZE                    = 0x80000
-	BPF_MAXINSNS                      = 0x200
-	BPF_MEM                           = 0x60
-	BPF_MEMWORDS                      = 0x10
-	BPF_MINBUFSIZE                    = 0x20
-	BPF_MINOR_VERSION                 = 0x1
-	BPF_MISC                          = 0x7
-	BPF_MSH                           = 0xa0
-	BPF_MUL                           = 0x20
-	BPF_NEG                           = 0x80
-	BPF_OR                            = 0x40
-	BPF_RELEASE                       = 0x30bb6
-	BPF_RET                           = 0x6
-	BPF_RSH                           = 0x70
-	BPF_ST                            = 0x2
-	BPF_STX                           = 0x3
-	BPF_SUB                           = 0x10
-	BPF_TAX                           = 0x0
-	BPF_TXA                           = 0x80
-	BPF_W                             = 0x0
-	BPF_X                             = 0x8
-	BRKINT                            = 0x2
-	BS0                               = 0x0
-	BS1                               = 0x8000
-	BSDLY                             = 0x8000
-	CFLUSH                            = 0xf
-	CLOCAL                            = 0x8000
-	CLOCK_MONOTONIC                   = 0x6
-	CLOCK_MONOTONIC_RAW               = 0x4
-	CLOCK_MONOTONIC_RAW_APPROX        = 0x5
-	CLOCK_PROCESS_CPUTIME_ID          = 0xc
-	CLOCK_REALTIME                    = 0x0
-	CLOCK_THREAD_CPUTIME_ID           = 0x10
-	CLOCK_UPTIME_RAW                  = 0x8
-	CLOCK_UPTIME_RAW_APPROX           = 0x9
-	CLONE_NOFOLLOW                    = 0x1
-	CLONE_NOOWNERCOPY                 = 0x2
-	CR0                               = 0x0
-	CR1                               = 0x1000
-	CR2                               = 0x2000
-	CR3                               = 0x3000
-	CRDLY                             = 0x3000
-	CREAD                             = 0x800
-	CRTSCTS                           = 0x30000
-	CS5                               = 0x0
-	CS6                               = 0x100
-	CS7                               = 0x200
-	CS8                               = 0x300
-	CSIZE                             = 0x300
-	CSTART                            = 0x11
-	CSTATUS                           = 0x14
-	CSTOP                             = 0x13
-	CSTOPB                            = 0x400
-	CSUSP                             = 0x1a
-	CTLIOCGINFO                       = 0xc0644e03
-	CTL_HW                            = 0x6
-	CTL_KERN                          = 0x1
-	CTL_MAXNAME                       = 0xc
-	CTL_NET                           = 0x4
-	DLT_A429                          = 0xb8
-	DLT_A653_ICM                      = 0xb9
-	DLT_AIRONET_HEADER                = 0x78
-	DLT_AOS                           = 0xde
-	DLT_APPLE_IP_OVER_IEEE1394        = 0x8a
-	DLT_ARCNET                        = 0x7
-	DLT_ARCNET_LINUX                  = 0x81
-	DLT_ATM_CLIP                      = 0x13
-	DLT_ATM_RFC1483                   = 0xb
-	DLT_AURORA                        = 0x7e
-	DLT_AX25                          = 0x3
-	DLT_AX25_KISS                     = 0xca
-	DLT_BACNET_MS_TP                  = 0xa5
-	DLT_BLUETOOTH_HCI_H4              = 0xbb
-	DLT_BLUETOOTH_HCI_H4_WITH_PHDR    = 0xc9
-	DLT_CAN20B                        = 0xbe
-	DLT_CAN_SOCKETCAN                 = 0xe3
-	DLT_CHAOS                         = 0x5
-	DLT_CHDLC                         = 0x68
-	DLT_CISCO_IOS                     = 0x76
-	DLT_C_HDLC                        = 0x68
-	DLT_C_HDLC_WITH_DIR               = 0xcd
-	DLT_DBUS                          = 0xe7
-	DLT_DECT                          = 0xdd
-	DLT_DOCSIS                        = 0x8f
-	DLT_DVB_CI                        = 0xeb
-	DLT_ECONET                        = 0x73
-	DLT_EN10MB                        = 0x1
-	DLT_EN3MB                         = 0x2
-	DLT_ENC                           = 0x6d
-	DLT_ERF                           = 0xc5
-	DLT_ERF_ETH                       = 0xaf
-	DLT_ERF_POS                       = 0xb0
-	DLT_FC_2                          = 0xe0
-	DLT_FC_2_WITH_FRAME_DELIMS        = 0xe1
-	DLT_FDDI                          = 0xa
-	DLT_FLEXRAY                       = 0xd2
-	DLT_FRELAY                        = 0x6b
-	DLT_FRELAY_WITH_DIR               = 0xce
-	DLT_GCOM_SERIAL                   = 0xad
-	DLT_GCOM_T1E1                     = 0xac
-	DLT_GPF_F                         = 0xab
-	DLT_GPF_T                         = 0xaa
-	DLT_GPRS_LLC                      = 0xa9
-	DLT_GSMTAP_ABIS                   = 0xda
-	DLT_GSMTAP_UM                     = 0xd9
-	DLT_HHDLC                         = 0x79
-	DLT_IBM_SN                        = 0x92
-	DLT_IBM_SP                        = 0x91
-	DLT_IEEE802                       = 0x6
-	DLT_IEEE802_11                    = 0x69
-	DLT_IEEE802_11_RADIO              = 0x7f
-	DLT_IEEE802_11_RADIO_AVS          = 0xa3
-	DLT_IEEE802_15_4                  = 0xc3
-	DLT_IEEE802_15_4_LINUX            = 0xbf
-	DLT_IEEE802_15_4_NOFCS            = 0xe6
-	DLT_IEEE802_15_4_NONASK_PHY       = 0xd7
-	DLT_IEEE802_16_MAC_CPS            = 0xbc
-	DLT_IEEE802_16_MAC_CPS_RADIO      = 0xc1
-	DLT_IPFILTER                      = 0x74
-	DLT_IPMB                          = 0xc7
-	DLT_IPMB_LINUX                    = 0xd1
-	DLT_IPNET                         = 0xe2
-	DLT_IPOIB                         = 0xf2
-	DLT_IPV4                          = 0xe4
-	DLT_IPV6                          = 0xe5
-	DLT_IP_OVER_FC                    = 0x7a
-	DLT_JUNIPER_ATM1                  = 0x89
-	DLT_JUNIPER_ATM2                  = 0x87
-	DLT_JUNIPER_ATM_CEMIC             = 0xee
-	DLT_JUNIPER_CHDLC                 = 0xb5
-	DLT_JUNIPER_ES                    = 0x84
-	DLT_JUNIPER_ETHER                 = 0xb2
-	DLT_JUNIPER_FIBRECHANNEL          = 0xea
-	DLT_JUNIPER_FRELAY                = 0xb4
-	DLT_JUNIPER_GGSN                  = 0x85
-	DLT_JUNIPER_ISM                   = 0xc2
-	DLT_JUNIPER_MFR                   = 0x86
-	DLT_JUNIPER_MLFR                  = 0x83
-	DLT_JUNIPER_MLPPP                 = 0x82
-	DLT_JUNIPER_MONITOR               = 0xa4
-	DLT_JUNIPER_PIC_PEER              = 0xae
-	DLT_JUNIPER_PPP                   = 0xb3
-	DLT_JUNIPER_PPPOE                 = 0xa7
-	DLT_JUNIPER_PPPOE_ATM             = 0xa8
-	DLT_JUNIPER_SERVICES              = 0x88
-	DLT_JUNIPER_SRX_E2E               = 0xe9
-	DLT_JUNIPER_ST                    = 0xc8
-	DLT_JUNIPER_VP                    = 0xb7
-	DLT_JUNIPER_VS                    = 0xe8
-	DLT_LAPB_WITH_DIR                 = 0xcf
-	DLT_LAPD                          = 0xcb
-	DLT_LIN                           = 0xd4
-	DLT_LINUX_EVDEV                   = 0xd8
-	DLT_LINUX_IRDA                    = 0x90
-	DLT_LINUX_LAPD                    = 0xb1
-	DLT_LINUX_PPP_WITHDIRECTION       = 0xa6
-	DLT_LINUX_SLL                     = 0x71
-	DLT_LOOP                          = 0x6c
-	DLT_LTALK                         = 0x72
-	DLT_MATCHING_MAX                  = 0xf5
-	DLT_MATCHING_MIN                  = 0x68
-	DLT_MFR                           = 0xb6
-	DLT_MOST                          = 0xd3
-	DLT_MPEG_2_TS                     = 0xf3
-	DLT_MPLS                          = 0xdb
-	DLT_MTP2                          = 0x8c
-	DLT_MTP2_WITH_PHDR                = 0x8b
-	DLT_MTP3                          = 0x8d
-	DLT_MUX27010                      = 0xec
-	DLT_NETANALYZER                   = 0xf0
-	DLT_NETANALYZER_TRANSPARENT       = 0xf1
-	DLT_NFC_LLCP                      = 0xf5
-	DLT_NFLOG                         = 0xef
-	DLT_NG40                          = 0xf4
-	DLT_NULL                          = 0x0
-	DLT_PCI_EXP                       = 0x7d
-	DLT_PFLOG                         = 0x75
-	DLT_PFSYNC                        = 0x12
-	DLT_PPI                           = 0xc0
-	DLT_PPP                           = 0x9
-	DLT_PPP_BSDOS                     = 0x10
-	DLT_PPP_ETHER                     = 0x33
-	DLT_PPP_PPPD                      = 0xa6
-	DLT_PPP_SERIAL                    = 0x32
-	DLT_PPP_WITH_DIR                  = 0xcc
-	DLT_PPP_WITH_DIRECTION            = 0xa6
-	DLT_PRISM_HEADER                  = 0x77
-	DLT_PRONET                        = 0x4
-	DLT_RAIF1                         = 0xc6
-	DLT_RAW                           = 0xc
-	DLT_RIO                           = 0x7c
-	DLT_SCCP                          = 0x8e
-	DLT_SITA                          = 0xc4
-	DLT_SLIP                          = 0x8
-	DLT_SLIP_BSDOS                    = 0xf
-	DLT_STANAG_5066_D_PDU             = 0xed
-	DLT_SUNATM                        = 0x7b
-	DLT_SYMANTEC_FIREWALL             = 0x63
-	DLT_TZSP                          = 0x80
-	DLT_USB                           = 0xba
-	DLT_USB_LINUX                     = 0xbd
-	DLT_USB_LINUX_MMAPPED             = 0xdc
-	DLT_USER0                         = 0x93
-	DLT_USER1                         = 0x94
-	DLT_USER10                        = 0x9d
-	DLT_USER11                        = 0x9e
-	DLT_USER12                        = 0x9f
-	DLT_USER13                        = 0xa0
-	DLT_USER14                        = 0xa1
-	DLT_USER15                        = 0xa2
-	DLT_USER2                         = 0x95
-	DLT_USER3                         = 0x96
-	DLT_USER4                         = 0x97
-	DLT_USER5                         = 0x98
-	DLT_USER6                         = 0x99
-	DLT_USER7                         = 0x9a
-	DLT_USER8                         = 0x9b
-	DLT_USER9                         = 0x9c
-	DLT_WIHART                        = 0xdf
-	DLT_X2E_SERIAL                    = 0xd5
-	DLT_X2E_XORAYA                    = 0xd6
-	DT_BLK                            = 0x6
-	DT_CHR                            = 0x2
-	DT_DIR                            = 0x4
-	DT_FIFO                           = 0x1
-	DT_LNK                            = 0xa
-	DT_REG                            = 0x8
-	DT_SOCK                           = 0xc
-	DT_UNKNOWN                        = 0x0
-	DT_WHT                            = 0xe
-	ECHO                              = 0x8
-	ECHOCTL                           = 0x40
-	ECHOE                             = 0x2
-	ECHOK                             = 0x4
-	ECHOKE                            = 0x1
-	ECHONL                            = 0x10
-	ECHOPRT                           = 0x20
-	EVFILT_AIO                        = -0x3
-	EVFILT_EXCEPT                     = -0xf
-	EVFILT_FS                         = -0x9
-	EVFILT_MACHPORT                   = -0x8
-	EVFILT_PROC                       = -0x5
-	EVFILT_READ                       = -0x1
-	EVFILT_SIGNAL                     = -0x6
-	EVFILT_SYSCOUNT                   = 0xf
-	EVFILT_THREADMARKER               = 0xf
-	EVFILT_TIMER                      = -0x7
-	EVFILT_USER                       = -0xa
-	EVFILT_VM                         = -0xc
-	EVFILT_VNODE                      = -0x4
-	EVFILT_WRITE                      = -0x2
-	EV_ADD                            = 0x1
-	EV_CLEAR                          = 0x20
-	EV_DELETE                         = 0x2
-	EV_DISABLE                        = 0x8
-	EV_DISPATCH                       = 0x80
-	EV_DISPATCH2                      = 0x180
-	EV_ENABLE                         = 0x4
-	EV_EOF                            = 0x8000
-	EV_ERROR                          = 0x4000
-	EV_FLAG0                          = 0x1000
-	EV_FLAG1                          = 0x2000
-	EV_ONESHOT                        = 0x10
-	EV_OOBAND                         = 0x2000
-	EV_POLL                           = 0x1000
-	EV_RECEIPT                        = 0x40
-	EV_SYSFLAGS                       = 0xf000
-	EV_UDATA_SPECIFIC                 = 0x100
-	EV_VANISHED                       = 0x200
-	EXTA                              = 0x4b00
-	EXTB                              = 0x9600
-	EXTPROC                           = 0x800
-	FD_CLOEXEC                        = 0x1
-	FD_SETSIZE                        = 0x400
-	FF0                               = 0x0
-	FF1                               = 0x4000
-	FFDLY                             = 0x4000
-	FLUSHO                            = 0x800000
-	FSOPT_ATTR_CMN_EXTENDED           = 0x20
-	FSOPT_NOFOLLOW                    = 0x1
-	FSOPT_NOINMEMUPDATE               = 0x2
-	FSOPT_PACK_INVAL_ATTRS            = 0x8
-	FSOPT_REPORT_FULLSIZE             = 0x4
-	F_ADDFILESIGS                     = 0x3d
-	F_ADDFILESIGS_FOR_DYLD_SIM        = 0x53
-	F_ADDFILESIGS_RETURN              = 0x61
-	F_ADDSIGS                         = 0x3b
-	F_ALLOCATEALL                     = 0x4
-	F_ALLOCATECONTIG                  = 0x2
-	F_BARRIERFSYNC                    = 0x55
-	F_CHECK_LV                        = 0x62
-	F_CHKCLEAN                        = 0x29
-	F_DUPFD                           = 0x0
-	F_DUPFD_CLOEXEC                   = 0x43
-	F_FINDSIGS                        = 0x4e
-	F_FLUSH_DATA                      = 0x28
-	F_FREEZE_FS                       = 0x35
-	F_FULLFSYNC                       = 0x33
-	F_GETCODEDIR                      = 0x48
-	F_GETFD                           = 0x1
-	F_GETFL                           = 0x3
-	F_GETLK                           = 0x7
-	F_GETLKPID                        = 0x42
-	F_GETNOSIGPIPE                    = 0x4a
-	F_GETOWN                          = 0x5
-	F_GETPATH                         = 0x32
-	F_GETPATH_MTMINFO                 = 0x47
-	F_GETPROTECTIONCLASS              = 0x3f
-	F_GETPROTECTIONLEVEL              = 0x4d
-	F_GLOBAL_NOCACHE                  = 0x37
-	F_LOG2PHYS                        = 0x31
-	F_LOG2PHYS_EXT                    = 0x41
-	F_NOCACHE                         = 0x30
-	F_NODIRECT                        = 0x3e
-	F_OK                              = 0x0
-	F_PATHPKG_CHECK                   = 0x34
-	F_PEOFPOSMODE                     = 0x3
-	F_PREALLOCATE                     = 0x2a
-	F_PUNCHHOLE                       = 0x63
-	F_RDADVISE                        = 0x2c
-	F_RDAHEAD                         = 0x2d
-	F_RDLCK                           = 0x1
-	F_SETBACKINGSTORE                 = 0x46
-	F_SETFD                           = 0x2
-	F_SETFL                           = 0x4
-	F_SETLK                           = 0x8
-	F_SETLKW                          = 0x9
-	F_SETLKWTIMEOUT                   = 0xa
-	F_SETNOSIGPIPE                    = 0x49
-	F_SETOWN                          = 0x6
-	F_SETPROTECTIONCLASS              = 0x40
-	F_SETSIZE                         = 0x2b
-	F_SINGLE_WRITER                   = 0x4c
-	F_THAW_FS                         = 0x36
-	F_TRANSCODEKEY                    = 0x4b
-	F_TRIM_ACTIVE_FILE                = 0x64
-	F_UNLCK                           = 0x2
-	F_VOLPOSMODE                      = 0x4
-	F_WRLCK                           = 0x3
-	HUPCL                             = 0x4000
-	HW_MACHINE                        = 0x1
-	ICANON                            = 0x100
-	ICMP6_FILTER                      = 0x12
-	ICRNL                             = 0x100
-	IEXTEN                            = 0x400
-	IFF_ALLMULTI                      = 0x200
-	IFF_ALTPHYS                       = 0x4000
-	IFF_BROADCAST                     = 0x2
-	IFF_DEBUG                         = 0x4
-	IFF_LINK0                         = 0x1000
-	IFF_LINK1                         = 0x2000
-	IFF_LINK2                         = 0x4000
-	IFF_LOOPBACK                      = 0x8
-	IFF_MULTICAST                     = 0x8000
-	IFF_NOARP                         = 0x80
-	IFF_NOTRAILERS                    = 0x20
-	IFF_OACTIVE                       = 0x400
-	IFF_POINTOPOINT                   = 0x10
-	IFF_PROMISC                       = 0x100
-	IFF_RUNNING                       = 0x40
-	IFF_SIMPLEX                       = 0x800
-	IFF_UP                            = 0x1
-	IFNAMSIZ                          = 0x10
-	IFT_1822                          = 0x2
-	IFT_AAL5                          = 0x31
-	IFT_ARCNET                        = 0x23
-	IFT_ARCNETPLUS                    = 0x24
-	IFT_ATM                           = 0x25
-	IFT_BRIDGE                        = 0xd1
-	IFT_CARP                          = 0xf8
-	IFT_CELLULAR                      = 0xff
-	IFT_CEPT                          = 0x13
-	IFT_DS3                           = 0x1e
-	IFT_ENC                           = 0xf4
-	IFT_EON                           = 0x19
-	IFT_ETHER                         = 0x6
-	IFT_FAITH                         = 0x38
-	IFT_FDDI                          = 0xf
-	IFT_FRELAY                        = 0x20
-	IFT_FRELAYDCE                     = 0x2c
-	IFT_GIF                           = 0x37
-	IFT_HDH1822                       = 0x3
-	IFT_HIPPI                         = 0x2f
-	IFT_HSSI                          = 0x2e
-	IFT_HY                            = 0xe
-	IFT_IEEE1394                      = 0x90
-	IFT_IEEE8023ADLAG                 = 0x88
-	IFT_ISDNBASIC                     = 0x14
-	IFT_ISDNPRIMARY                   = 0x15
-	IFT_ISO88022LLC                   = 0x29
-	IFT_ISO88023                      = 0x7
-	IFT_ISO88024                      = 0x8
-	IFT_ISO88025                      = 0x9
-	IFT_ISO88026                      = 0xa
-	IFT_L2VLAN                        = 0x87
-	IFT_LAPB                          = 0x10
-	IFT_LOCALTALK                     = 0x2a
-	IFT_LOOP                          = 0x18
-	IFT_MIOX25                        = 0x26
-	IFT_MODEM                         = 0x30
-	IFT_NSIP                          = 0x1b
-	IFT_OTHER                         = 0x1
-	IFT_P10                           = 0xc
-	IFT_P80                           = 0xd
-	IFT_PARA                          = 0x22
-	IFT_PDP                           = 0xff
-	IFT_PFLOG                         = 0xf5
-	IFT_PFSYNC                        = 0xf6
-	IFT_PKTAP                         = 0xfe
-	IFT_PPP                           = 0x17
-	IFT_PROPMUX                       = 0x36
-	IFT_PROPVIRTUAL                   = 0x35
-	IFT_PTPSERIAL                     = 0x16
-	IFT_RS232                         = 0x21
-	IFT_SDLC                          = 0x11
-	IFT_SIP                           = 0x1f
-	IFT_SLIP                          = 0x1c
-	IFT_SMDSDXI                       = 0x2b
-	IFT_SMDSICIP                      = 0x34
-	IFT_SONET                         = 0x27
-	IFT_SONETPATH                     = 0x32
-	IFT_SONETVT                       = 0x33
-	IFT_STARLAN                       = 0xb
-	IFT_STF                           = 0x39
-	IFT_T1                            = 0x12
-	IFT_ULTRA                         = 0x1d
-	IFT_V35                           = 0x2d
-	IFT_X25                           = 0x5
-	IFT_X25DDN                        = 0x4
-	IFT_X25PLE                        = 0x28
-	IFT_XETHER                        = 0x1a
-	IGNBRK                            = 0x1
-	IGNCR                             = 0x80
-	IGNPAR                            = 0x4
-	IMAXBEL                           = 0x2000
-	INLCR                             = 0x40
-	INPCK                             = 0x10
-	IN_CLASSA_HOST                    = 0xffffff
-	IN_CLASSA_MAX                     = 0x80
-	IN_CLASSA_NET                     = 0xff000000
-	IN_CLASSA_NSHIFT                  = 0x18
-	IN_CLASSB_HOST                    = 0xffff
-	IN_CLASSB_MAX                     = 0x10000
-	IN_CLASSB_NET                     = 0xffff0000
-	IN_CLASSB_NSHIFT                  = 0x10
-	IN_CLASSC_HOST                    = 0xff
-	IN_CLASSC_NET                     = 0xffffff00
-	IN_CLASSC_NSHIFT                  = 0x8
-	IN_CLASSD_HOST                    = 0xfffffff
-	IN_CLASSD_NET                     = 0xf0000000
-	IN_CLASSD_NSHIFT                  = 0x1c
-	IN_LINKLOCALNETNUM                = 0xa9fe0000
-	IN_LOOPBACKNET                    = 0x7f
-	IPPROTO_3PC                       = 0x22
-	IPPROTO_ADFS                      = 0x44
-	IPPROTO_AH                        = 0x33
-	IPPROTO_AHIP                      = 0x3d
-	IPPROTO_APES                      = 0x63
-	IPPROTO_ARGUS                     = 0xd
-	IPPROTO_AX25                      = 0x5d
-	IPPROTO_BHA                       = 0x31
-	IPPROTO_BLT                       = 0x1e
-	IPPROTO_BRSATMON                  = 0x4c
-	IPPROTO_CFTP                      = 0x3e
-	IPPROTO_CHAOS                     = 0x10
-	IPPROTO_CMTP                      = 0x26
-	IPPROTO_CPHB                      = 0x49
-	IPPROTO_CPNX                      = 0x48
-	IPPROTO_DDP                       = 0x25
-	IPPROTO_DGP                       = 0x56
-	IPPROTO_DIVERT                    = 0xfe
-	IPPROTO_DONE                      = 0x101
-	IPPROTO_DSTOPTS                   = 0x3c
-	IPPROTO_EGP                       = 0x8
-	IPPROTO_EMCON                     = 0xe
-	IPPROTO_ENCAP                     = 0x62
-	IPPROTO_EON                       = 0x50
-	IPPROTO_ESP                       = 0x32
-	IPPROTO_ETHERIP                   = 0x61
-	IPPROTO_FRAGMENT                  = 0x2c
-	IPPROTO_GGP                       = 0x3
-	IPPROTO_GMTP                      = 0x64
-	IPPROTO_GRE                       = 0x2f
-	IPPROTO_HELLO                     = 0x3f
-	IPPROTO_HMP                       = 0x14
-	IPPROTO_HOPOPTS                   = 0x0
-	IPPROTO_ICMP                      = 0x1
-	IPPROTO_ICMPV6                    = 0x3a
-	IPPROTO_IDP                       = 0x16
-	IPPROTO_IDPR                      = 0x23
-	IPPROTO_IDRP                      = 0x2d
-	IPPROTO_IGMP                      = 0x2
-	IPPROTO_IGP                       = 0x55
-	IPPROTO_IGRP                      = 0x58
-	IPPROTO_IL                        = 0x28
-	IPPROTO_INLSP                     = 0x34
-	IPPROTO_INP                       = 0x20
-	IPPROTO_IP                        = 0x0
-	IPPROTO_IPCOMP                    = 0x6c
-	IPPROTO_IPCV                      = 0x47
-	IPPROTO_IPEIP                     = 0x5e
-	IPPROTO_IPIP                      = 0x4
-	IPPROTO_IPPC                      = 0x43
-	IPPROTO_IPV4                      = 0x4
-	IPPROTO_IPV6                      = 0x29
-	IPPROTO_IRTP                      = 0x1c
-	IPPROTO_KRYPTOLAN                 = 0x41
-	IPPROTO_LARP                      = 0x5b
-	IPPROTO_LEAF1                     = 0x19
-	IPPROTO_LEAF2                     = 0x1a
-	IPPROTO_MAX                       = 0x100
-	IPPROTO_MAXID                     = 0x34
-	IPPROTO_MEAS                      = 0x13
-	IPPROTO_MHRP                      = 0x30
-	IPPROTO_MICP                      = 0x5f
-	IPPROTO_MTP                       = 0x5c
-	IPPROTO_MUX                       = 0x12
-	IPPROTO_ND                        = 0x4d
-	IPPROTO_NHRP                      = 0x36
-	IPPROTO_NONE                      = 0x3b
-	IPPROTO_NSP                       = 0x1f
-	IPPROTO_NVPII                     = 0xb
-	IPPROTO_OSPFIGP                   = 0x59
-	IPPROTO_PGM                       = 0x71
-	IPPROTO_PIGP                      = 0x9
-	IPPROTO_PIM                       = 0x67
-	IPPROTO_PRM                       = 0x15
-	IPPROTO_PUP                       = 0xc
-	IPPROTO_PVP                       = 0x4b
-	IPPROTO_RAW                       = 0xff
-	IPPROTO_RCCMON                    = 0xa
-	IPPROTO_RDP                       = 0x1b
-	IPPROTO_ROUTING                   = 0x2b
-	IPPROTO_RSVP                      = 0x2e
-	IPPROTO_RVD                       = 0x42
-	IPPROTO_SATEXPAK                  = 0x40
-	IPPROTO_SATMON                    = 0x45
-	IPPROTO_SCCSP                     = 0x60
-	IPPROTO_SCTP                      = 0x84
-	IPPROTO_SDRP                      = 0x2a
-	IPPROTO_SEP                       = 0x21
-	IPPROTO_SRPC                      = 0x5a
-	IPPROTO_ST                        = 0x7
-	IPPROTO_SVMTP                     = 0x52
-	IPPROTO_SWIPE                     = 0x35
-	IPPROTO_TCF                       = 0x57
-	IPPROTO_TCP                       = 0x6
-	IPPROTO_TP                        = 0x1d
-	IPPROTO_TPXX                      = 0x27
-	IPPROTO_TRUNK1                    = 0x17
-	IPPROTO_TRUNK2                    = 0x18
-	IPPROTO_TTP                       = 0x54
-	IPPROTO_UDP                       = 0x11
-	IPPROTO_VINES                     = 0x53
-	IPPROTO_VISA                      = 0x46
-	IPPROTO_VMTP                      = 0x51
-	IPPROTO_WBEXPAK                   = 0x4f
-	IPPROTO_WBMON                     = 0x4e
-	IPPROTO_WSN                       = 0x4a
-	IPPROTO_XNET                      = 0xf
-	IPPROTO_XTP                       = 0x24
-	IPV6_2292DSTOPTS                  = 0x17
-	IPV6_2292HOPLIMIT                 = 0x14
-	IPV6_2292HOPOPTS                  = 0x16
-	IPV6_2292NEXTHOP                  = 0x15
-	IPV6_2292PKTINFO                  = 0x13
-	IPV6_2292PKTOPTIONS               = 0x19
-	IPV6_2292RTHDR                    = 0x18
-	IPV6_BINDV6ONLY                   = 0x1b
-	IPV6_BOUND_IF                     = 0x7d
-	IPV6_CHECKSUM                     = 0x1a
-	IPV6_DEFAULT_MULTICAST_HOPS       = 0x1
-	IPV6_DEFAULT_MULTICAST_LOOP       = 0x1
-	IPV6_DEFHLIM                      = 0x40
-	IPV6_FAITH                        = 0x1d
-	IPV6_FLOWINFO_MASK                = 0xffffff0f
-	IPV6_FLOWLABEL_MASK               = 0xffff0f00
-	IPV6_FLOW_ECN_MASK                = 0x300
-	IPV6_FRAGTTL                      = 0x3c
-	IPV6_FW_ADD                       = 0x1e
-	IPV6_FW_DEL                       = 0x1f
-	IPV6_FW_FLUSH                     = 0x20
-	IPV6_FW_GET                       = 0x22
-	IPV6_FW_ZERO                      = 0x21
-	IPV6_HLIMDEC                      = 0x1
-	IPV6_IPSEC_POLICY                 = 0x1c
-	IPV6_JOIN_GROUP                   = 0xc
-	IPV6_LEAVE_GROUP                  = 0xd
-	IPV6_MAXHLIM                      = 0xff
-	IPV6_MAXOPTHDR                    = 0x800
-	IPV6_MAXPACKET                    = 0xffff
-	IPV6_MAX_GROUP_SRC_FILTER         = 0x200
-	IPV6_MAX_MEMBERSHIPS              = 0xfff
-	IPV6_MAX_SOCK_SRC_FILTER          = 0x80
-	IPV6_MIN_MEMBERSHIPS              = 0x1f
-	IPV6_MMTU                         = 0x500
-	IPV6_MULTICAST_HOPS               = 0xa
-	IPV6_MULTICAST_IF                 = 0x9
-	IPV6_MULTICAST_LOOP               = 0xb
-	IPV6_PORTRANGE                    = 0xe
-	IPV6_PORTRANGE_DEFAULT            = 0x0
-	IPV6_PORTRANGE_HIGH               = 0x1
-	IPV6_PORTRANGE_LOW                = 0x2
-	IPV6_RECVTCLASS                   = 0x23
-	IPV6_RTHDR_LOOSE                  = 0x0
-	IPV6_RTHDR_STRICT                 = 0x1
-	IPV6_RTHDR_TYPE_0                 = 0x0
-	IPV6_SOCKOPT_RESERVED1            = 0x3
-	IPV6_TCLASS                       = 0x24
-	IPV6_UNICAST_HOPS                 = 0x4
-	IPV6_V6ONLY                       = 0x1b
-	IPV6_VERSION                      = 0x60
-	IPV6_VERSION_MASK                 = 0xf0
-	IP_ADD_MEMBERSHIP                 = 0xc
-	IP_ADD_SOURCE_MEMBERSHIP          = 0x46
-	IP_BLOCK_SOURCE                   = 0x48
-	IP_BOUND_IF                       = 0x19
-	IP_DEFAULT_MULTICAST_LOOP         = 0x1
-	IP_DEFAULT_MULTICAST_TTL          = 0x1
-	IP_DF                             = 0x4000
-	IP_DROP_MEMBERSHIP                = 0xd
-	IP_DROP_SOURCE_MEMBERSHIP         = 0x47
-	IP_DUMMYNET_CONFIGURE             = 0x3c
-	IP_DUMMYNET_DEL                   = 0x3d
-	IP_DUMMYNET_FLUSH                 = 0x3e
-	IP_DUMMYNET_GET                   = 0x40
-	IP_FAITH                          = 0x16
-	IP_FW_ADD                         = 0x28
-	IP_FW_DEL                         = 0x29
-	IP_FW_FLUSH                       = 0x2a
-	IP_FW_GET                         = 0x2c
-	IP_FW_RESETLOG                    = 0x2d
-	IP_FW_ZERO                        = 0x2b
-	IP_HDRINCL                        = 0x2
-	IP_IPSEC_POLICY                   = 0x15
-	IP_MAXPACKET                      = 0xffff
-	IP_MAX_GROUP_SRC_FILTER           = 0x200
-	IP_MAX_MEMBERSHIPS                = 0xfff
-	IP_MAX_SOCK_MUTE_FILTER           = 0x80
-	IP_MAX_SOCK_SRC_FILTER            = 0x80
-	IP_MF                             = 0x2000
-	IP_MIN_MEMBERSHIPS                = 0x1f
-	IP_MSFILTER                       = 0x4a
-	IP_MSS                            = 0x240
-	IP_MULTICAST_IF                   = 0x9
-	IP_MULTICAST_IFINDEX              = 0x42
-	IP_MULTICAST_LOOP                 = 0xb
-	IP_MULTICAST_TTL                  = 0xa
-	IP_MULTICAST_VIF                  = 0xe
-	IP_NAT__XXX                       = 0x37
-	IP_OFFMASK                        = 0x1fff
-	IP_OLD_FW_ADD                     = 0x32
-	IP_OLD_FW_DEL                     = 0x33
-	IP_OLD_FW_FLUSH                   = 0x34
-	IP_OLD_FW_GET                     = 0x36
-	IP_OLD_FW_RESETLOG                = 0x38
-	IP_OLD_FW_ZERO                    = 0x35
-	IP_OPTIONS                        = 0x1
-	IP_PKTINFO                        = 0x1a
-	IP_PORTRANGE                      = 0x13
-	IP_PORTRANGE_DEFAULT              = 0x0
-	IP_PORTRANGE_HIGH                 = 0x1
-	IP_PORTRANGE_LOW                  = 0x2
-	IP_RECVDSTADDR                    = 0x7
-	IP_RECVIF                         = 0x14
-	IP_RECVOPTS                       = 0x5
-	IP_RECVPKTINFO                    = 0x1a
-	IP_RECVRETOPTS                    = 0x6
-	IP_RECVTOS                        = 0x1b
-	IP_RECVTTL                        = 0x18
-	IP_RETOPTS                        = 0x8
-	IP_RF                             = 0x8000
-	IP_RSVP_OFF                       = 0x10
-	IP_RSVP_ON                        = 0xf
-	IP_RSVP_VIF_OFF                   = 0x12
-	IP_RSVP_VIF_ON                    = 0x11
-	IP_STRIPHDR                       = 0x17
-	IP_TOS                            = 0x3
-	IP_TRAFFIC_MGT_BACKGROUND         = 0x41
-	IP_TTL                            = 0x4
-	IP_UNBLOCK_SOURCE                 = 0x49
-	ISIG                              = 0x80
-	ISTRIP                            = 0x20
-	IUTF8                             = 0x4000
-	IXANY                             = 0x800
-	IXOFF                             = 0x400
-	IXON                              = 0x200
-	KERN_HOSTNAME                     = 0xa
-	KERN_OSRELEASE                    = 0x2
-	KERN_OSTYPE                       = 0x1
-	KERN_VERSION                      = 0x4
-	LOCK_EX                           = 0x2
-	LOCK_NB                           = 0x4
-	LOCK_SH                           = 0x1
-	LOCK_UN                           = 0x8
-	MADV_CAN_REUSE                    = 0x9
-	MADV_DONTNEED                     = 0x4
-	MADV_FREE                         = 0x5
-	MADV_FREE_REUSABLE                = 0x7
-	MADV_FREE_REUSE                   = 0x8
-	MADV_NORMAL                       = 0x0
-	MADV_PAGEOUT                      = 0xa
-	MADV_RANDOM                       = 0x1
-	MADV_SEQUENTIAL                   = 0x2
-	MADV_WILLNEED                     = 0x3
-	MADV_ZERO_WIRED_PAGES             = 0x6
-	MAP_ANON                          = 0x1000
-	MAP_ANONYMOUS                     = 0x1000
-	MAP_COPY                          = 0x2
-	MAP_FILE                          = 0x0
-	MAP_FIXED                         = 0x10
-	MAP_HASSEMAPHORE                  = 0x200
-	MAP_JIT                           = 0x800
-	MAP_NOCACHE                       = 0x400
-	MAP_NOEXTEND                      = 0x100
-	MAP_NORESERVE                     = 0x40
-	MAP_PRIVATE                       = 0x2
-	MAP_RENAME                        = 0x20
-	MAP_RESERVED0080                  = 0x80
-	MAP_RESILIENT_CODESIGN            = 0x2000
-	MAP_RESILIENT_MEDIA               = 0x4000
-	MAP_SHARED                        = 0x1
-	MCL_CURRENT                       = 0x1
-	MCL_FUTURE                        = 0x2
-	MNT_ASYNC                         = 0x40
-	MNT_AUTOMOUNTED                   = 0x400000
-	MNT_CMDFLAGS                      = 0xf0000
-	MNT_CPROTECT                      = 0x80
-	MNT_DEFWRITE                      = 0x2000000
-	MNT_DONTBROWSE                    = 0x100000
-	MNT_DOVOLFS                       = 0x8000
-	MNT_DWAIT                         = 0x4
-	MNT_EXPORTED                      = 0x100
-	MNT_FORCE                         = 0x80000
-	MNT_IGNORE_OWNERSHIP              = 0x200000
-	MNT_JOURNALED                     = 0x800000
-	MNT_LOCAL                         = 0x1000
-	MNT_MULTILABEL                    = 0x4000000
-	MNT_NOATIME                       = 0x10000000
-	MNT_NOBLOCK                       = 0x20000
-	MNT_NODEV                         = 0x10
-	MNT_NOEXEC                        = 0x4
-	MNT_NOSUID                        = 0x8
-	MNT_NOUSERXATTR                   = 0x1000000
-	MNT_NOWAIT                        = 0x2
-	MNT_QUARANTINE                    = 0x400
-	MNT_QUOTA                         = 0x2000
-	MNT_RDONLY                        = 0x1
-	MNT_RELOAD                        = 0x40000
-	MNT_ROOTFS                        = 0x4000
-	MNT_SYNCHRONOUS                   = 0x2
-	MNT_UNION                         = 0x20
-	MNT_UNKNOWNPERMISSIONS            = 0x200000
-	MNT_UPDATE                        = 0x10000
-	MNT_VISFLAGMASK                   = 0x17f0f5ff
-	MNT_WAIT                          = 0x1
-	MSG_CTRUNC                        = 0x20
-	MSG_DONTROUTE                     = 0x4
-	MSG_DONTWAIT                      = 0x80
-	MSG_EOF                           = 0x100
-	MSG_EOR                           = 0x8
-	MSG_FLUSH                         = 0x400
-	MSG_HAVEMORE                      = 0x2000
-	MSG_HOLD                          = 0x800
-	MSG_NEEDSA                        = 0x10000
-	MSG_OOB                           = 0x1
-	MSG_PEEK                          = 0x2
-	MSG_RCVMORE                       = 0x4000
-	MSG_SEND                          = 0x1000
-	MSG_TRUNC                         = 0x10
-	MSG_WAITALL                       = 0x40
-	MSG_WAITSTREAM                    = 0x200
-	MS_ASYNC                          = 0x1
-	MS_DEACTIVATE                     = 0x8
-	MS_INVALIDATE                     = 0x2
-	MS_KILLPAGES                      = 0x4
-	MS_SYNC                           = 0x10
-	NAME_MAX                          = 0xff
-	NET_RT_DUMP                       = 0x1
-	NET_RT_DUMP2                      = 0x7
-	NET_RT_FLAGS                      = 0x2
-	NET_RT_IFLIST                     = 0x3
-	NET_RT_IFLIST2                    = 0x6
-	NET_RT_MAXID                      = 0xa
-	NET_RT_STAT                       = 0x4
-	NET_RT_TRASH                      = 0x5
-	NFDBITS                           = 0x20
-	NL0                               = 0x0
-	NL1                               = 0x100
-	NL2                               = 0x200
-	NL3                               = 0x300
-	NLDLY                             = 0x300
-	NOFLSH                            = 0x80000000
-	NOKERNINFO                        = 0x2000000
-	NOTE_ABSOLUTE                     = 0x8
-	NOTE_ATTRIB                       = 0x8
-	NOTE_BACKGROUND                   = 0x40
-	NOTE_CHILD                        = 0x4
-	NOTE_CRITICAL                     = 0x20
-	NOTE_DELETE                       = 0x1
-	NOTE_EXEC                         = 0x20000000
-	NOTE_EXIT                         = 0x80000000
-	NOTE_EXITSTATUS                   = 0x4000000
-	NOTE_EXIT_CSERROR                 = 0x40000
-	NOTE_EXIT_DECRYPTFAIL             = 0x10000
-	NOTE_EXIT_DETAIL                  = 0x2000000
-	NOTE_EXIT_DETAIL_MASK             = 0x70000
-	NOTE_EXIT_MEMORY                  = 0x20000
-	NOTE_EXIT_REPARENTED              = 0x80000
-	NOTE_EXTEND                       = 0x4
-	NOTE_FFAND                        = 0x40000000
-	NOTE_FFCOPY                       = 0xc0000000
-	NOTE_FFCTRLMASK                   = 0xc0000000
-	NOTE_FFLAGSMASK                   = 0xffffff
-	NOTE_FFNOP                        = 0x0
-	NOTE_FFOR                         = 0x80000000
-	NOTE_FORK                         = 0x40000000
-	NOTE_FUNLOCK                      = 0x100
-	NOTE_LEEWAY                       = 0x10
-	NOTE_LINK                         = 0x10
-	NOTE_LOWAT                        = 0x1
-	NOTE_MACH_CONTINUOUS_TIME         = 0x80
-	NOTE_NONE                         = 0x80
-	NOTE_NSECONDS                     = 0x4
-	NOTE_OOB                          = 0x2
-	NOTE_PCTRLMASK                    = -0x100000
-	NOTE_PDATAMASK                    = 0xfffff
-	NOTE_REAP                         = 0x10000000
-	NOTE_RENAME                       = 0x20
-	NOTE_REVOKE                       = 0x40
-	NOTE_SECONDS                      = 0x1
-	NOTE_SIGNAL                       = 0x8000000
-	NOTE_TRACK                        = 0x1
-	NOTE_TRACKERR                     = 0x2
-	NOTE_TRIGGER                      = 0x1000000
-	NOTE_USECONDS                     = 0x2
-	NOTE_VM_ERROR                     = 0x10000000
-	NOTE_VM_PRESSURE                  = 0x80000000
-	NOTE_VM_PRESSURE_SUDDEN_TERMINATE = 0x20000000
-	NOTE_VM_PRESSURE_TERMINATE        = 0x40000000
-	NOTE_WRITE                        = 0x2
-	OCRNL                             = 0x10
-	OFDEL                             = 0x20000
-	OFILL                             = 0x80
-	ONLCR                             = 0x2
-	ONLRET                            = 0x40
-	ONOCR                             = 0x20
-	ONOEOT                            = 0x8
-	OPOST                             = 0x1
-	OXTABS                            = 0x4
-	O_ACCMODE                         = 0x3
-	O_ALERT                           = 0x20000000
-	O_APPEND                          = 0x8
-	O_ASYNC                           = 0x40
-	O_CLOEXEC                         = 0x1000000
-	O_CREAT                           = 0x200
-	O_DIRECTORY                       = 0x100000
-	O_DP_GETRAWENCRYPTED              = 0x1
-	O_DP_GETRAWUNENCRYPTED            = 0x2
-	O_DSYNC                           = 0x400000
-	O_EVTONLY                         = 0x8000
-	O_EXCL                            = 0x800
-	O_EXLOCK                          = 0x20
-	O_FSYNC                           = 0x80
-	O_NDELAY                          = 0x4
-	O_NOCTTY                          = 0x20000
-	O_NOFOLLOW                        = 0x100
-	O_NONBLOCK                        = 0x4
-	O_POPUP                           = 0x80000000
-	O_RDONLY                          = 0x0
-	O_RDWR                            = 0x2
-	O_SHLOCK                          = 0x10
-	O_SYMLINK                         = 0x200000
-	O_SYNC                            = 0x80
-	O_TRUNC                           = 0x400
-	O_WRONLY                          = 0x1
-	PARENB                            = 0x1000
-	PARMRK                            = 0x8
-	PARODD                            = 0x2000
-	PENDIN                            = 0x20000000
-	PRIO_PGRP                         = 0x1
-	PRIO_PROCESS                      = 0x0
-	PRIO_USER                         = 0x2
-	PROT_EXEC                         = 0x4
-	PROT_NONE                         = 0x0
-	PROT_READ                         = 0x1
-	PROT_WRITE                        = 0x2
-	PT_ATTACH                         = 0xa
-	PT_ATTACHEXC                      = 0xe
-	PT_CONTINUE                       = 0x7
-	PT_DENY_ATTACH                    = 0x1f
-	PT_DETACH                         = 0xb
-	PT_FIRSTMACH                      = 0x20
-	PT_FORCEQUOTA                     = 0x1e
-	PT_KILL                           = 0x8
-	PT_READ_D                         = 0x2
-	PT_READ_I                         = 0x1
-	PT_READ_U                         = 0x3
-	PT_SIGEXC                         = 0xc
-	PT_STEP                           = 0x9
-	PT_THUPDATE                       = 0xd
-	PT_TRACE_ME                       = 0x0
-	PT_WRITE_D                        = 0x5
-	PT_WRITE_I                        = 0x4
-	PT_WRITE_U                        = 0x6
-	RLIMIT_AS                         = 0x5
-	RLIMIT_CORE                       = 0x4
-	RLIMIT_CPU                        = 0x0
-	RLIMIT_CPU_USAGE_MONITOR          = 0x2
-	RLIMIT_DATA                       = 0x2
-	RLIMIT_FSIZE                      = 0x1
-	RLIMIT_MEMLOCK                    = 0x6
-	RLIMIT_NOFILE                     = 0x8
-	RLIMIT_NPROC                      = 0x7
-	RLIMIT_RSS                        = 0x5
-	RLIMIT_STACK                      = 0x3
-	RLIM_INFINITY                     = 0x7fffffffffffffff
-	RTAX_AUTHOR                       = 0x6
-	RTAX_BRD                          = 0x7
-	RTAX_DST                          = 0x0
-	RTAX_GATEWAY                      = 0x1
-	RTAX_GENMASK                      = 0x3
-	RTAX_IFA                          = 0x5
-	RTAX_IFP                          = 0x4
-	RTAX_MAX                          = 0x8
-	RTAX_NETMASK                      = 0x2
-	RTA_AUTHOR                        = 0x40
-	RTA_BRD                           = 0x80
-	RTA_DST                           = 0x1
-	RTA_GATEWAY                       = 0x2
-	RTA_GENMASK                       = 0x8
-	RTA_IFA                           = 0x20
-	RTA_IFP                           = 0x10
-	RTA_NETMASK                       = 0x4
-	RTF_BLACKHOLE                     = 0x1000
-	RTF_BROADCAST                     = 0x400000
-	RTF_CLONING                       = 0x100
-	RTF_CONDEMNED                     = 0x2000000
-	RTF_DELCLONE                      = 0x80
-	RTF_DONE                          = 0x40
-	RTF_DYNAMIC                       = 0x10
-	RTF_GATEWAY                       = 0x2
-	RTF_HOST                          = 0x4
-	RTF_IFREF                         = 0x4000000
-	RTF_IFSCOPE                       = 0x1000000
-	RTF_LLINFO                        = 0x400
-	RTF_LOCAL                         = 0x200000
-	RTF_MODIFIED                      = 0x20
-	RTF_MULTICAST                     = 0x800000
-	RTF_NOIFREF                       = 0x2000
-	RTF_PINNED                        = 0x100000
-	RTF_PRCLONING                     = 0x10000
-	RTF_PROTO1                        = 0x8000
-	RTF_PROTO2                        = 0x4000
-	RTF_PROTO3                        = 0x40000
-	RTF_PROXY                         = 0x8000000
-	RTF_REJECT                        = 0x8
-	RTF_ROUTER                        = 0x10000000
-	RTF_STATIC                        = 0x800
-	RTF_UP                            = 0x1
-	RTF_WASCLONED                     = 0x20000
-	RTF_XRESOLVE                      = 0x200
-	RTM_ADD                           = 0x1
-	RTM_CHANGE                        = 0x3
-	RTM_DELADDR                       = 0xd
-	RTM_DELETE                        = 0x2
-	RTM_DELMADDR                      = 0x10
-	RTM_GET                           = 0x4
-	RTM_GET2                          = 0x14
-	RTM_IFINFO                        = 0xe
-	RTM_IFINFO2                       = 0x12
-	RTM_LOCK                          = 0x8
-	RTM_LOSING                        = 0x5
-	RTM_MISS                          = 0x7
-	RTM_NEWADDR                       = 0xc
-	RTM_NEWMADDR                      = 0xf
-	RTM_NEWMADDR2                     = 0x13
-	RTM_OLDADD                        = 0x9
-	RTM_OLDDEL                        = 0xa
-	RTM_REDIRECT                      = 0x6
-	RTM_RESOLVE                       = 0xb
-	RTM_RTTUNIT                       = 0xf4240
-	RTM_VERSION                       = 0x5
-	RTV_EXPIRE                        = 0x4
-	RTV_HOPCOUNT                      = 0x2
-	RTV_MTU                           = 0x1
-	RTV_RPIPE                         = 0x8
-	RTV_RTT                           = 0x40
-	RTV_RTTVAR                        = 0x80
-	RTV_SPIPE                         = 0x10
-	RTV_SSTHRESH                      = 0x20
-	RUSAGE_CHILDREN                   = -0x1
-	RUSAGE_SELF                       = 0x0
-	SCM_CREDS                         = 0x3
-	SCM_RIGHTS                        = 0x1
-	SCM_TIMESTAMP                     = 0x2
-	SCM_TIMESTAMP_MONOTONIC           = 0x4
-	SHUT_RD                           = 0x0
-	SHUT_RDWR                         = 0x2
-	SHUT_WR                           = 0x1
-	SIOCADDMULTI                      = 0x80206931
-	SIOCAIFADDR                       = 0x8040691a
-	SIOCARPIPLL                       = 0xc0206928
-	SIOCATMARK                        = 0x40047307
-	SIOCAUTOADDR                      = 0xc0206926
-	SIOCAUTONETMASK                   = 0x80206927
-	SIOCDELMULTI                      = 0x80206932
-	SIOCDIFADDR                       = 0x80206919
-	SIOCDIFPHYADDR                    = 0x80206941
-	SIOCGDRVSPEC                      = 0xc028697b
-	SIOCGETVLAN                       = 0xc020697f
-	SIOCGHIWAT                        = 0x40047301
-	SIOCGIFADDR                       = 0xc0206921
-	SIOCGIFALTMTU                     = 0xc0206948
-	SIOCGIFASYNCMAP                   = 0xc020697c
-	SIOCGIFBOND                       = 0xc0206947
-	SIOCGIFBRDADDR                    = 0xc0206923
-	SIOCGIFCAP                        = 0xc020695b
-	SIOCGIFCONF                       = 0xc00c6924
-	SIOCGIFDEVMTU                     = 0xc0206944
-	SIOCGIFDSTADDR                    = 0xc0206922
-	SIOCGIFFLAGS                      = 0xc0206911
-	SIOCGIFGENERIC                    = 0xc020693a
-	SIOCGIFKPI                        = 0xc0206987
-	SIOCGIFMAC                        = 0xc0206982
-	SIOCGIFMEDIA                      = 0xc02c6938
-	SIOCGIFMETRIC                     = 0xc0206917
-	SIOCGIFMTU                        = 0xc0206933
-	SIOCGIFNETMASK                    = 0xc0206925
-	SIOCGIFPDSTADDR                   = 0xc0206940
-	SIOCGIFPHYS                       = 0xc0206935
-	SIOCGIFPSRCADDR                   = 0xc020693f
-	SIOCGIFSTATUS                     = 0xc331693d
-	SIOCGIFVLAN                       = 0xc020697f
-	SIOCGIFWAKEFLAGS                  = 0xc0206988
-	SIOCGLOWAT                        = 0x40047303
-	SIOCGPGRP                         = 0x40047309
-	SIOCIFCREATE                      = 0xc0206978
-	SIOCIFCREATE2                     = 0xc020697a
-	SIOCIFDESTROY                     = 0x80206979
-	SIOCIFGCLONERS                    = 0xc0106981
-	SIOCRSLVMULTI                     = 0xc010693b
-	SIOCSDRVSPEC                      = 0x8028697b
-	SIOCSETVLAN                       = 0x8020697e
-	SIOCSHIWAT                        = 0x80047300
-	SIOCSIFADDR                       = 0x8020690c
-	SIOCSIFALTMTU                     = 0x80206945
-	SIOCSIFASYNCMAP                   = 0x8020697d
-	SIOCSIFBOND                       = 0x80206946
-	SIOCSIFBRDADDR                    = 0x80206913
-	SIOCSIFCAP                        = 0x8020695a
-	SIOCSIFDSTADDR                    = 0x8020690e
-	SIOCSIFFLAGS                      = 0x80206910
-	SIOCSIFGENERIC                    = 0x80206939
-	SIOCSIFKPI                        = 0x80206986
-	SIOCSIFLLADDR                     = 0x8020693c
-	SIOCSIFMAC                        = 0x80206983
-	SIOCSIFMEDIA                      = 0xc0206937
-	SIOCSIFMETRIC                     = 0x80206918
-	SIOCSIFMTU                        = 0x80206934
-	SIOCSIFNETMASK                    = 0x80206916
-	SIOCSIFPHYADDR                    = 0x8040693e
-	SIOCSIFPHYS                       = 0x80206936
-	SIOCSIFVLAN                       = 0x8020697e
-	SIOCSLOWAT                        = 0x80047302
-	SIOCSPGRP                         = 0x80047308
-	SOCK_DGRAM                        = 0x2
-	SOCK_MAXADDRLEN                   = 0xff
-	SOCK_RAW                          = 0x3
-	SOCK_RDM                          = 0x4
-	SOCK_SEQPACKET                    = 0x5
-	SOCK_STREAM                       = 0x1
-	SOL_SOCKET                        = 0xffff
-	SOMAXCONN                         = 0x80
-	SO_ACCEPTCONN                     = 0x2
-	SO_BROADCAST                      = 0x20
-	SO_DEBUG                          = 0x1
-	SO_DONTROUTE                      = 0x10
-	SO_DONTTRUNC                      = 0x2000
-	SO_ERROR                          = 0x1007
-	SO_KEEPALIVE                      = 0x8
-	SO_LABEL                          = 0x1010
-	SO_LINGER                         = 0x80
-	SO_LINGER_SEC                     = 0x1080
-	SO_NETSVC_MARKING_LEVEL           = 0x1119
-	SO_NET_SERVICE_TYPE               = 0x1116
-	SO_NKE                            = 0x1021
-	SO_NOADDRERR                      = 0x1023
-	SO_NOSIGPIPE                      = 0x1022
-	SO_NOTIFYCONFLICT                 = 0x1026
-	SO_NP_EXTENSIONS                  = 0x1083
-	SO_NREAD                          = 0x1020
-	SO_NUMRCVPKT                      = 0x1112
-	SO_NWRITE                         = 0x1024
-	SO_OOBINLINE                      = 0x100
-	SO_PEERLABEL                      = 0x1011
-	SO_RANDOMPORT                     = 0x1082
-	SO_RCVBUF                         = 0x1002
-	SO_RCVLOWAT                       = 0x1004
-	SO_RCVTIMEO                       = 0x1006
-	SO_REUSEADDR                      = 0x4
-	SO_REUSEPORT                      = 0x200
-	SO_REUSESHAREUID                  = 0x1025
-	SO_SNDBUF                         = 0x1001
-	SO_SNDLOWAT                       = 0x1003
-	SO_SNDTIMEO                       = 0x1005
-	SO_TIMESTAMP                      = 0x400
-	SO_TIMESTAMP_MONOTONIC            = 0x800
-	SO_TYPE                           = 0x1008
-	SO_UPCALLCLOSEWAIT                = 0x1027
-	SO_USELOOPBACK                    = 0x40
-	SO_WANTMORE                       = 0x4000
-	SO_WANTOOBFLAG                    = 0x8000
-	S_IEXEC                           = 0x40
-	S_IFBLK                           = 0x6000
-	S_IFCHR                           = 0x2000
-	S_IFDIR                           = 0x4000
-	S_IFIFO                           = 0x1000
-	S_IFLNK                           = 0xa000
-	S_IFMT                            = 0xf000
-	S_IFREG                           = 0x8000
-	S_IFSOCK                          = 0xc000
-	S_IFWHT                           = 0xe000
-	S_IREAD                           = 0x100
-	S_IRGRP                           = 0x20
-	S_IROTH                           = 0x4
-	S_IRUSR                           = 0x100
-	S_IRWXG                           = 0x38
-	S_IRWXO                           = 0x7
-	S_IRWXU                           = 0x1c0
-	S_ISGID                           = 0x400
-	S_ISTXT                           = 0x200
-	S_ISUID                           = 0x800
-	S_ISVTX                           = 0x200
-	S_IWGRP                           = 0x10
-	S_IWOTH                           = 0x2
-	S_IWRITE                          = 0x80
-	S_IWUSR                           = 0x80
-	S_IXGRP                           = 0x8
-	S_IXOTH                           = 0x1
-	S_IXUSR                           = 0x40
-	TAB0                              = 0x0
-	TAB1                              = 0x400
-	TAB2                              = 0x800
-	TAB3                              = 0x4
-	TABDLY                            = 0xc04
-	TCIFLUSH                          = 0x1
-	TCIOFF                            = 0x3
-	TCIOFLUSH                         = 0x3
-	TCION                             = 0x4
-	TCOFLUSH                          = 0x2
-	TCOOFF                            = 0x1
-	TCOON                             = 0x2
-	TCP_CONNECTIONTIMEOUT             = 0x20
-	TCP_CONNECTION_INFO               = 0x106
-	TCP_ENABLE_ECN                    = 0x104
-	TCP_FASTOPEN                      = 0x105
-	TCP_KEEPALIVE                     = 0x10
-	TCP_KEEPCNT                       = 0x102
-	TCP_KEEPINTVL                     = 0x101
-	TCP_MAXHLEN                       = 0x3c
-	TCP_MAXOLEN                       = 0x28
-	TCP_MAXSEG                        = 0x2
-	TCP_MAXWIN                        = 0xffff
-	TCP_MAX_SACK                      = 0x4
-	TCP_MAX_WINSHIFT                  = 0xe
-	TCP_MINMSS                        = 0xd8
-	TCP_MSS                           = 0x200
-	TCP_NODELAY                       = 0x1
-	TCP_NOOPT                         = 0x8
-	TCP_NOPUSH                        = 0x4
-	TCP_NOTSENT_LOWAT                 = 0x201
-	TCP_RXT_CONNDROPTIME              = 0x80
-	TCP_RXT_FINDROP                   = 0x100
-	TCP_SENDMOREACKS                  = 0x103
-	TCSAFLUSH                         = 0x2
-	TIOCCBRK                          = 0x2000747a
-	TIOCCDTR                          = 0x20007478
-	TIOCCONS                          = 0x80047462
-	TIOCDCDTIMESTAMP                  = 0x40107458
-	TIOCDRAIN                         = 0x2000745e
-	TIOCDSIMICROCODE                  = 0x20007455
-	TIOCEXCL                          = 0x2000740d
-	TIOCEXT                           = 0x80047460
-	TIOCFLUSH                         = 0x80047410
-	TIOCGDRAINWAIT                    = 0x40047456
-	TIOCGETA                          = 0x40487413
-	TIOCGETD                          = 0x4004741a
-	TIOCGPGRP                         = 0x40047477
-	TIOCGWINSZ                        = 0x40087468
-	TIOCIXOFF                         = 0x20007480
-	TIOCIXON                          = 0x20007481
-	TIOCMBIC                          = 0x8004746b
-	TIOCMBIS                          = 0x8004746c
-	TIOCMGDTRWAIT                     = 0x4004745a
-	TIOCMGET                          = 0x4004746a
-	TIOCMODG                          = 0x40047403
-	TIOCMODS                          = 0x80047404
-	TIOCMSDTRWAIT                     = 0x8004745b
-	TIOCMSET                          = 0x8004746d
-	TIOCM_CAR                         = 0x40
-	TIOCM_CD                          = 0x40
-	TIOCM_CTS                         = 0x20
-	TIOCM_DSR                         = 0x100
-	TIOCM_DTR                         = 0x2
-	TIOCM_LE                          = 0x1
-	TIOCM_RI                          = 0x80
-	TIOCM_RNG                         = 0x80
-	TIOCM_RTS                         = 0x4
-	TIOCM_SR                          = 0x10
-	TIOCM_ST                          = 0x8
-	TIOCNOTTY                         = 0x20007471
-	TIOCNXCL                          = 0x2000740e
-	TIOCOUTQ                          = 0x40047473
-	TIOCPKT                           = 0x80047470
-	TIOCPKT_DATA                      = 0x0
-	TIOCPKT_DOSTOP                    = 0x20
-	TIOCPKT_FLUSHREAD                 = 0x1
-	TIOCPKT_FLUSHWRITE                = 0x2
-	TIOCPKT_IOCTL                     = 0x40
-	TIOCPKT_NOSTOP                    = 0x10
-	TIOCPKT_START                     = 0x8
-	TIOCPKT_STOP                      = 0x4
-	TIOCPTYGNAME                      = 0x40807453
-	TIOCPTYGRANT                      = 0x20007454
-	TIOCPTYUNLK                       = 0x20007452
-	TIOCREMOTE                        = 0x80047469
-	TIOCSBRK                          = 0x2000747b
-	TIOCSCONS                         = 0x20007463
-	TIOCSCTTY                         = 0x20007461
-	TIOCSDRAINWAIT                    = 0x80047457
-	TIOCSDTR                          = 0x20007479
-	TIOCSETA                          = 0x80487414
-	TIOCSETAF                         = 0x80487416
-	TIOCSETAW                         = 0x80487415
-	TIOCSETD                          = 0x8004741b
-	TIOCSIG                           = 0x2000745f
-	TIOCSPGRP                         = 0x80047476
-	TIOCSTART                         = 0x2000746e
-	TIOCSTAT                          = 0x20007465
-	TIOCSTI                           = 0x80017472
-	TIOCSTOP                          = 0x2000746f
-	TIOCSWINSZ                        = 0x80087467
-	TIOCTIMESTAMP                     = 0x40107459
-	TIOCUCNTL                         = 0x80047466
-	TOSTOP                            = 0x400000
-	VDISCARD                          = 0xf
-	VDSUSP                            = 0xb
-	VEOF                              = 0x0
-	VEOL                              = 0x1
-	VEOL2                             = 0x2
-	VERASE                            = 0x3
-	VINTR                             = 0x8
-	VKILL                             = 0x5
-	VLNEXT                            = 0xe
-	VMIN                              = 0x10
-	VM_LOADAVG                        = 0x2
-	VM_MACHFACTOR                     = 0x4
-	VM_MAXID                          = 0x6
-	VM_METER                          = 0x1
-	VM_SWAPUSAGE                      = 0x5
-	VQUIT                             = 0x9
-	VREPRINT                          = 0x6
-	VSTART                            = 0xc
-	VSTATUS                           = 0x12
-	VSTOP                             = 0xd
-	VSUSP                             = 0xa
-	VT0                               = 0x0
-	VT1                               = 0x10000
-	VTDLY                             = 0x10000
-	VTIME                             = 0x11
-	VWERASE                           = 0x4
-	WCONTINUED                        = 0x10
-	WCOREFLAG                         = 0x80
-	WEXITED                           = 0x4
-	WNOHANG                           = 0x1
-	WNOWAIT                           = 0x20
-	WORDSIZE                          = 0x40
-	WSTOPPED                          = 0x8
-	WUNTRACED                         = 0x2
-	XATTR_CREATE                      = 0x2
-	XATTR_NODEFAULT                   = 0x10
-	XATTR_NOFOLLOW                    = 0x1
-	XATTR_NOSECURITY                  = 0x8
-	XATTR_REPLACE                     = 0x4
-	XATTR_SHOWCOMPRESSION             = 0x20
-)
-
-// Errors
-const (
-	E2BIG           = syscall.Errno(0x7)
-	EACCES          = syscall.Errno(0xd)
-	EADDRINUSE      = syscall.Errno(0x30)
-	EADDRNOTAVAIL   = syscall.Errno(0x31)
-	EAFNOSUPPORT    = syscall.Errno(0x2f)
-	EAGAIN          = syscall.Errno(0x23)
-	EALREADY        = syscall.Errno(0x25)
-	EAUTH           = syscall.Errno(0x50)
-	EBADARCH        = syscall.Errno(0x56)
-	EBADEXEC        = syscall.Errno(0x55)
-	EBADF           = syscall.Errno(0x9)
-	EBADMACHO       = syscall.Errno(0x58)
-	EBADMSG         = syscall.Errno(0x5e)
-	EBADRPC         = syscall.Errno(0x48)
-	EBUSY           = syscall.Errno(0x10)
-	ECANCELED       = syscall.Errno(0x59)
-	ECHILD          = syscall.Errno(0xa)
-	ECONNABORTED    = syscall.Errno(0x35)
-	ECONNREFUSED    = syscall.Errno(0x3d)
-	ECONNRESET      = syscall.Errno(0x36)
-	EDEADLK         = syscall.Errno(0xb)
-	EDESTADDRREQ    = syscall.Errno(0x27)
-	EDEVERR         = syscall.Errno(0x53)
-	EDOM            = syscall.Errno(0x21)
-	EDQUOT          = syscall.Errno(0x45)
-	EEXIST          = syscall.Errno(0x11)
-	EFAULT          = syscall.Errno(0xe)
-	EFBIG           = syscall.Errno(0x1b)
-	EFTYPE          = syscall.Errno(0x4f)
-	EHOSTDOWN       = syscall.Errno(0x40)
-	EHOSTUNREACH    = syscall.Errno(0x41)
-	EIDRM           = syscall.Errno(0x5a)
-	EILSEQ          = syscall.Errno(0x5c)
-	EINPROGRESS     = syscall.Errno(0x24)
-	EINTR           = syscall.Errno(0x4)
-	EINVAL          = syscall.Errno(0x16)
-	EIO             = syscall.Errno(0x5)
-	EISCONN         = syscall.Errno(0x38)
-	EISDIR          = syscall.Errno(0x15)
-	ELAST           = syscall.Errno(0x6a)
-	ELOOP           = syscall.Errno(0x3e)
-	EMFILE          = syscall.Errno(0x18)
-	EMLINK          = syscall.Errno(0x1f)
-	EMSGSIZE        = syscall.Errno(0x28)
-	EMULTIHOP       = syscall.Errno(0x5f)
-	ENAMETOOLONG    = syscall.Errno(0x3f)
-	ENEEDAUTH       = syscall.Errno(0x51)
-	ENETDOWN        = syscall.Errno(0x32)
-	ENETRESET       = syscall.Errno(0x34)
-	ENETUNREACH     = syscall.Errno(0x33)
-	ENFILE          = syscall.Errno(0x17)
-	ENOATTR         = syscall.Errno(0x5d)
-	ENOBUFS         = syscall.Errno(0x37)
-	ENODATA         = syscall.Errno(0x60)
-	ENODEV          = syscall.Errno(0x13)
-	ENOENT          = syscall.Errno(0x2)
-	ENOEXEC         = syscall.Errno(0x8)
-	ENOLCK          = syscall.Errno(0x4d)
-	ENOLINK         = syscall.Errno(0x61)
-	ENOMEM          = syscall.Errno(0xc)
-	ENOMSG          = syscall.Errno(0x5b)
-	ENOPOLICY       = syscall.Errno(0x67)
-	ENOPROTOOPT     = syscall.Errno(0x2a)
-	ENOSPC          = syscall.Errno(0x1c)
-	ENOSR           = syscall.Errno(0x62)
-	ENOSTR          = syscall.Errno(0x63)
-	ENOSYS          = syscall.Errno(0x4e)
-	ENOTBLK         = syscall.Errno(0xf)
-	ENOTCONN        = syscall.Errno(0x39)
-	ENOTDIR         = syscall.Errno(0x14)
-	ENOTEMPTY       = syscall.Errno(0x42)
-	ENOTRECOVERABLE = syscall.Errno(0x68)
-	ENOTSOCK        = syscall.Errno(0x26)
-	ENOTSUP         = syscall.Errno(0x2d)
-	ENOTTY          = syscall.Errno(0x19)
-	ENXIO           = syscall.Errno(0x6)
-	EOPNOTSUPP      = syscall.Errno(0x66)
-	EOVERFLOW       = syscall.Errno(0x54)
-	EOWNERDEAD      = syscall.Errno(0x69)
-	EPERM           = syscall.Errno(0x1)
-	EPFNOSUPPORT    = syscall.Errno(0x2e)
-	EPIPE           = syscall.Errno(0x20)
-	EPROCLIM        = syscall.Errno(0x43)
-	EPROCUNAVAIL    = syscall.Errno(0x4c)
-	EPROGMISMATCH   = syscall.Errno(0x4b)
-	EPROGUNAVAIL    = syscall.Errno(0x4a)
-	EPROTO          = syscall.Errno(0x64)
-	EPROTONOSUPPORT = syscall.Errno(0x2b)
-	EPROTOTYPE      = syscall.Errno(0x29)
-	EPWROFF         = syscall.Errno(0x52)
-	EQFULL          = syscall.Errno(0x6a)
-	ERANGE          = syscall.Errno(0x22)
-	EREMOTE         = syscall.Errno(0x47)
-	EROFS           = syscall.Errno(0x1e)
-	ERPCMISMATCH    = syscall.Errno(0x49)
-	ESHLIBVERS      = syscall.Errno(0x57)
-	ESHUTDOWN       = syscall.Errno(0x3a)
-	ESOCKTNOSUPPORT = syscall.Errno(0x2c)
-	ESPIPE          = syscall.Errno(0x1d)
-	ESRCH           = syscall.Errno(0x3)
-	ESTALE          = syscall.Errno(0x46)
-	ETIME           = syscall.Errno(0x65)
-	ETIMEDOUT       = syscall.Errno(0x3c)
-	ETOOMANYREFS    = syscall.Errno(0x3b)
-	ETXTBSY         = syscall.Errno(0x1a)
-	EUSERS          = syscall.Errno(0x44)
-	EWOULDBLOCK     = syscall.Errno(0x23)
-	EXDEV           = syscall.Errno(0x12)
-)
-
-// Signals
-const (
-	SIGABRT   = syscall.Signal(0x6)
-	SIGALRM   = syscall.Signal(0xe)
-	SIGBUS    = syscall.Signal(0xa)
-	SIGCHLD   = syscall.Signal(0x14)
-	SIGCONT   = syscall.Signal(0x13)
-	SIGEMT    = syscall.Signal(0x7)
-	SIGFPE    = syscall.Signal(0x8)
-	SIGHUP    = syscall.Signal(0x1)
-	SIGILL    = syscall.Signal(0x4)
-	SIGINFO   = syscall.Signal(0x1d)
-	SIGINT    = syscall.Signal(0x2)
-	SIGIO     = syscall.Signal(0x17)
-	SIGIOT    = syscall.Signal(0x6)
-	SIGKILL   = syscall.Signal(0x9)
-	SIGPIPE   = syscall.Signal(0xd)
-	SIGPROF   = syscall.Signal(0x1b)
-	SIGQUIT   = syscall.Signal(0x3)
-	SIGSEGV   = syscall.Signal(0xb)
-	SIGSTOP   = syscall.Signal(0x11)
-	SIGSYS    = syscall.Signal(0xc)
-	SIGTERM   = syscall.Signal(0xf)
-	SIGTRAP   = syscall.Signal(0x5)
-	SIGTSTP   = syscall.Signal(0x12)
-	SIGTTIN   = syscall.Signal(0x15)
-	SIGTTOU   = syscall.Signal(0x16)
-	SIGURG    = syscall.Signal(0x10)
-	SIGUSR1   = syscall.Signal(0x1e)
-	SIGUSR2   = syscall.Signal(0x1f)
-	SIGVTALRM = syscall.Signal(0x1a)
-	SIGWINCH  = syscall.Signal(0x1c)
-	SIGXCPU   = syscall.Signal(0x18)
-	SIGXFSZ   = syscall.Signal(0x19)
-)
-
-// Error table
-var errorList = [...]struct {
-	num  syscall.Errno
-	name string
-	desc string
-}{
-	{1, "EPERM", "operation not permitted"},
-	{2, "ENOENT", "no such file or directory"},
-	{3, "ESRCH", "no such process"},
-	{4, "EINTR", "interrupted system call"},
-	{5, "EIO", "input/output error"},
-	{6, "ENXIO", "device not configured"},
-	{7, "E2BIG", "argument list too long"},
-	{8, "ENOEXEC", "exec format error"},
-	{9, "EBADF", "bad file descriptor"},
-	{10, "ECHILD", "no child processes"},
-	{11, "EDEADLK", "resource deadlock avoided"},
-	{12, "ENOMEM", "cannot allocate memory"},
-	{13, "EACCES", "permission denied"},
-	{14, "EFAULT", "bad address"},
-	{15, "ENOTBLK", "block device required"},
-	{16, "EBUSY", "resource busy"},
-	{17, "EEXIST", "file exists"},
-	{18, "EXDEV", "cross-device link"},
-	{19, "ENODEV", "operation not supported by device"},
-	{20, "ENOTDIR", "not a directory"},
-	{21, "EISDIR", "is a directory"},
-	{22, "EINVAL", "invalid argument"},
-	{23, "ENFILE", "too many open files in system"},
-	{24, "EMFILE", "too many open files"},
-	{25, "ENOTTY", "inappropriate ioctl for device"},
-	{26, "ETXTBSY", "text file busy"},
-	{27, "EFBIG", "file too large"},
-	{28, "ENOSPC", "no space left on device"},
-	{29, "ESPIPE", "illegal seek"},
-	{30, "EROFS", "read-only file system"},
-	{31, "EMLINK", "too many links"},
-	{32, "EPIPE", "broken pipe"},
-	{33, "EDOM", "numerical argument out of domain"},
-	{34, "ERANGE", "result too large"},
-	{35, "EAGAIN", "resource temporarily unavailable"},
-	{36, "EINPROGRESS", "operation now in progress"},
-	{37, "EALREADY", "operation already in progress"},
-	{38, "ENOTSOCK", "socket operation on non-socket"},
-	{39, "EDESTADDRREQ", "destination address required"},
-	{40, "EMSGSIZE", "message too long"},
-	{41, "EPROTOTYPE", "protocol wrong type for socket"},
-	{42, "ENOPROTOOPT", "protocol not available"},
-	{43, "EPROTONOSUPPORT", "protocol not supported"},
-	{44, "ESOCKTNOSUPPORT", "socket type not supported"},
-	{45, "ENOTSUP", "operation not supported"},
-	{46, "EPFNOSUPPORT", "protocol family not supported"},
-	{47, "EAFNOSUPPORT", "address family not supported by protocol family"},
-	{48, "EADDRINUSE", "address already in use"},
-	{49, "EADDRNOTAVAIL", "can't assign requested address"},
-	{50, "ENETDOWN", "network is down"},
-	{51, "ENETUNREACH", "network is unreachable"},
-	{52, "ENETRESET", "network dropped connection on reset"},
-	{53, "ECONNABORTED", "software caused connection abort"},
-	{54, "ECONNRESET", "connection reset by peer"},
-	{55, "ENOBUFS", "no buffer space available"},
-	{56, "EISCONN", "socket is already connected"},
-	{57, "ENOTCONN", "socket is not connected"},
-	{58, "ESHUTDOWN", "can't send after socket shutdown"},
-	{59, "ETOOMANYREFS", "too many references: can't splice"},
-	{60, "ETIMEDOUT", "operation timed out"},
-	{61, "ECONNREFUSED", "connection refused"},
-	{62, "ELOOP", "too many levels of symbolic links"},
-	{63, "ENAMETOOLONG", "file name too long"},
-	{64, "EHOSTDOWN", "host is down"},
-	{65, "EHOSTUNREACH", "no route to host"},
-	{66, "ENOTEMPTY", "directory not empty"},
-	{67, "EPROCLIM", "too many processes"},
-	{68, "EUSERS", "too many users"},
-	{69, "EDQUOT", "disc quota exceeded"},
-	{70, "ESTALE", "stale NFS file handle"},
-	{71, "EREMOTE", "too many levels of remote in path"},
-	{72, "EBADRPC", "RPC struct is bad"},
-	{73, "ERPCMISMATCH", "RPC version wrong"},
-	{74, "EPROGUNAVAIL", "RPC prog. not avail"},
-	{75, "EPROGMISMATCH", "program version wrong"},
-	{76, "EPROCUNAVAIL", "bad procedure for program"},
-	{77, "ENOLCK", "no locks available"},
-	{78, "ENOSYS", "function not implemented"},
-	{79, "EFTYPE", "inappropriate file type or format"},
-	{80, "EAUTH", "authentication error"},
-	{81, "ENEEDAUTH", "need authenticator"},
-	{82, "EPWROFF", "device power is off"},
-	{83, "EDEVERR", "device error"},
-	{84, "EOVERFLOW", "value too large to be stored in data type"},
-	{85, "EBADEXEC", "bad executable (or shared library)"},
-	{86, "EBADARCH", "bad CPU type in executable"},
-	{87, "ESHLIBVERS", "shared library version mismatch"},
-	{88, "EBADMACHO", "malformed Mach-o file"},
-	{89, "ECANCELED", "operation canceled"},
-	{90, "EIDRM", "identifier removed"},
-	{91, "ENOMSG", "no message of desired type"},
-	{92, "EILSEQ", "illegal byte sequence"},
-	{93, "ENOATTR", "attribute not found"},
-	{94, "EBADMSG", "bad message"},
-	{95, "EMULTIHOP", "EMULTIHOP (Reserved)"},
-	{96, "ENODATA", "no message available on STREAM"},
-	{97, "ENOLINK", "ENOLINK (Reserved)"},
-	{98, "ENOSR", "no STREAM resources"},
-	{99, "ENOSTR", "not a STREAM"},
-	{100, "EPROTO", "protocol error"},
-	{101, "ETIME", "STREAM ioctl timeout"},
-	{102, "EOPNOTSUPP", "operation not supported on socket"},
-	{103, "ENOPOLICY", "policy not found"},
-	{104, "ENOTRECOVERABLE", "state not recoverable"},
-	{105, "EOWNERDEAD", "previous owner died"},
-	{106, "EQFULL", "interface output queue is full"},
-}
-
-// Signal table
-var signalList = [...]struct {
-	num  syscall.Signal
-	name string
-	desc string
-}{
-	{1, "SIGHUP", "hangup"},
-	{2, "SIGINT", "interrupt"},
-	{3, "SIGQUIT", "quit"},
-	{4, "SIGILL", "illegal instruction"},
-	{5, "SIGTRAP", "trace/BPT trap"},
-	{6, "SIGABRT", "abort trap"},
-	{7, "SIGEMT", "EMT trap"},
-	{8, "SIGFPE", "floating point exception"},
-	{9, "SIGKILL", "killed"},
-	{10, "SIGBUS", "bus error"},
-	{11, "SIGSEGV", "segmentation fault"},
-	{12, "SIGSYS", "bad system call"},
-	{13, "SIGPIPE", "broken pipe"},
-	{14, "SIGALRM", "alarm clock"},
-	{15, "SIGTERM", "terminated"},
-	{16, "SIGURG", "urgent I/O condition"},
-	{17, "SIGSTOP", "suspended (signal)"},
-	{18, "SIGTSTP", "suspended"},
-	{19, "SIGCONT", "continued"},
-	{20, "SIGCHLD", "child exited"},
-	{21, "SIGTTIN", "stopped (tty input)"},
-	{22, "SIGTTOU", "stopped (tty output)"},
-	{23, "SIGIO", "I/O possible"},
-	{24, "SIGXCPU", "cputime limit exceeded"},
-	{25, "SIGXFSZ", "filesize limit exceeded"},
-	{26, "SIGVTALRM", "virtual timer expired"},
-	{27, "SIGPROF", "profiling timer expired"},
-	{28, "SIGWINCH", "window size changes"},
-	{29, "SIGINFO", "information request"},
-	{30, "SIGUSR1", "user defined signal 1"},
-	{31, "SIGUSR2", "user defined signal 2"},
-}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.1_13.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.1_13.go
deleted file mode 100644
index 48a62e3906..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.1_13.go
+++ /dev/null
@@ -1,40 +0,0 @@
-// go run mksyscall.go -l32 -tags darwin,386,go1.13 syscall_darwin.1_13.go
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-//go:build darwin && 386 && go1.13
-// +build darwin,386,go1.13
-
-package unix
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-var _ syscall.Errno
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func closedir(dir uintptr) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_closedir_trampoline), uintptr(dir), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_closedir_trampoline()
-
-//go:cgo_import_dynamic libc_closedir closedir "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func readdir_r(dir uintptr, entry *Dirent, result **Dirent) (res Errno) {
-	r0, _, _ := syscall_syscall(funcPC(libc_readdir_r_trampoline), uintptr(dir), uintptr(unsafe.Pointer(entry)), uintptr(unsafe.Pointer(result)))
-	res = Errno(r0)
-	return
-}
-
-func libc_readdir_r_trampoline()
-
-//go:cgo_import_dynamic libc_readdir_r readdir_r "/usr/lib/libSystem.B.dylib"
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.1_13.s b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.1_13.s
deleted file mode 100644
index 1c73a1921d..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.1_13.s
+++ /dev/null
@@ -1,13 +0,0 @@
-// go run mkasm_darwin.go 386
-// Code generated by the command above; DO NOT EDIT.
-
-//go:build go1.13
-// +build go1.13
-
-#include "textflag.h"
-TEXT ·libc_fdopendir_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fdopendir(SB)
-TEXT ·libc_closedir_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_closedir(SB)
-TEXT ·libc_readdir_r_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_readdir_r(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.go
deleted file mode 100644
index a266636af6..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.go
+++ /dev/null
@@ -1,2431 +0,0 @@
-// go run mksyscall.go -l32 -tags darwin,386,go1.12 syscall_bsd.go syscall_darwin.go syscall_darwin_386.go
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-//go:build darwin && 386 && go1.12
-// +build darwin,386,go1.12
-
-package unix
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-var _ syscall.Errno
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
-	r0, _, e1 := syscall_rawSyscall(funcPC(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_getgroups_trampoline()
-
-//go:cgo_import_dynamic libc_getgroups getgroups "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func setgroups(ngid int, gid *_Gid_t) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setgroups_trampoline()
-
-//go:cgo_import_dynamic libc_setgroups setgroups "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) {
-	r0, _, e1 := syscall_syscall6(funcPC(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
-	wpid = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_wait4_trampoline()
-
-//go:cgo_import_dynamic libc_wait4 wait4 "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
-	fd = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_accept_trampoline()
-
-//go:cgo_import_dynamic libc_accept accept "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_bind_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_bind_trampoline()
-
-//go:cgo_import_dynamic libc_bind bind "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_connect_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_connect_trampoline()
-
-//go:cgo_import_dynamic libc_connect connect "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func socket(domain int, typ int, proto int) (fd int, err error) {
-	r0, _, e1 := syscall_rawSyscall(funcPC(libc_socket_trampoline), uintptr(domain), uintptr(typ), uintptr(proto))
-	fd = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_socket_trampoline()
-
-//go:cgo_import_dynamic libc_socket socket "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
-	_, _, e1 := syscall_syscall6(funcPC(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_getsockopt_trampoline()
-
-//go:cgo_import_dynamic libc_getsockopt getsockopt "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
-	_, _, e1 := syscall_syscall6(funcPC(libc_setsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setsockopt_trampoline()
-
-//go:cgo_import_dynamic libc_setsockopt setsockopt "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_getpeername_trampoline()
-
-//go:cgo_import_dynamic libc_getpeername getpeername "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_getsockname_trampoline()
-
-//go:cgo_import_dynamic libc_getsockname getsockname "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Shutdown(s int, how int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_shutdown_trampoline), uintptr(s), uintptr(how), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_shutdown_trampoline()
-
-//go:cgo_import_dynamic libc_shutdown shutdown "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
-	_, _, e1 := syscall_rawSyscall6(funcPC(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_socketpair_trampoline()
-
-//go:cgo_import_dynamic libc_socketpair socketpair "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(p) > 0 {
-		_p0 = unsafe.Pointer(&p[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_recvfrom_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_recvfrom_trampoline()
-
-//go:cgo_import_dynamic libc_recvfrom recvfrom "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
-	var _p0 unsafe.Pointer
-	if len(buf) > 0 {
-		_p0 = unsafe.Pointer(&buf[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_sendto_trampoline), uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_sendto_trampoline()
-
-//go:cgo_import_dynamic libc_sendto sendto "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_recvmsg_trampoline()
-
-//go:cgo_import_dynamic libc_recvmsg recvmsg "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_sendmsg_trampoline()
-
-//go:cgo_import_dynamic libc_sendmsg sendmsg "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
-	r0, _, e1 := syscall_syscall6(funcPC(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_kevent_trampoline()
-
-//go:cgo_import_dynamic libc_kevent kevent "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func utimes(path string, timeval *[2]Timeval) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_utimes_trampoline()
-
-//go:cgo_import_dynamic libc_utimes utimes "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func futimes(fd int, timeval *[2]Timeval) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_futimes_trampoline()
-
-//go:cgo_import_dynamic libc_futimes futimes "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func poll(fds *PollFd, nfds int, timeout int) (n int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_poll_trampoline), uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_poll_trampoline()
-
-//go:cgo_import_dynamic libc_poll poll "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Madvise(b []byte, behav int) (err error) {
-	var _p0 unsafe.Pointer
-	if len(b) > 0 {
-		_p0 = unsafe.Pointer(&b[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_madvise_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(behav))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_madvise_trampoline()
-
-//go:cgo_import_dynamic libc_madvise madvise "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Mlock(b []byte) (err error) {
-	var _p0 unsafe.Pointer
-	if len(b) > 0 {
-		_p0 = unsafe.Pointer(&b[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_mlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_mlock_trampoline()
-
-//go:cgo_import_dynamic libc_mlock mlock "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Mlockall(flags int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_mlockall_trampoline), uintptr(flags), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_mlockall_trampoline()
-
-//go:cgo_import_dynamic libc_mlockall mlockall "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Mprotect(b []byte, prot int) (err error) {
-	var _p0 unsafe.Pointer
-	if len(b) > 0 {
-		_p0 = unsafe.Pointer(&b[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_mprotect_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(prot))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_mprotect_trampoline()
-
-//go:cgo_import_dynamic libc_mprotect mprotect "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Msync(b []byte, flags int) (err error) {
-	var _p0 unsafe.Pointer
-	if len(b) > 0 {
-		_p0 = unsafe.Pointer(&b[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_msync_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(flags))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_msync_trampoline()
-
-//go:cgo_import_dynamic libc_msync msync "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Munlock(b []byte) (err error) {
-	var _p0 unsafe.Pointer
-	if len(b) > 0 {
-		_p0 = unsafe.Pointer(&b[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_munlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_munlock_trampoline()
-
-//go:cgo_import_dynamic libc_munlock munlock "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Munlockall() (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_munlockall_trampoline), 0, 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_munlockall_trampoline()
-
-//go:cgo_import_dynamic libc_munlockall munlockall "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func pipe(p *[2]int32) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), uintptr(unsafe.Pointer(p)), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_pipe_trampoline()
-
-//go:cgo_import_dynamic libc_pipe pipe "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func getxattr(path string, attr string, dest *byte, size int, position uint32, options int) (sz int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(attr)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_getxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
-	sz = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_getxattr_trampoline()
-
-//go:cgo_import_dynamic libc_getxattr getxattr "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func fgetxattr(fd int, attr string, dest *byte, size int, position uint32, options int) (sz int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(attr)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_fgetxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
-	sz = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fgetxattr_trampoline()
-
-//go:cgo_import_dynamic libc_fgetxattr fgetxattr "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func setxattr(path string, attr string, data *byte, size int, position uint32, options int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(attr)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_setxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setxattr_trampoline()
-
-//go:cgo_import_dynamic libc_setxattr setxattr "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func fsetxattr(fd int, attr string, data *byte, size int, position uint32, options int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(attr)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_fsetxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fsetxattr_trampoline()
-
-//go:cgo_import_dynamic libc_fsetxattr fsetxattr "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func removexattr(path string, attr string, options int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(attr)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_removexattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_removexattr_trampoline()
-
-//go:cgo_import_dynamic libc_removexattr removexattr "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func fremovexattr(fd int, attr string, options int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(attr)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_fremovexattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(options))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fremovexattr_trampoline()
-
-//go:cgo_import_dynamic libc_fremovexattr fremovexattr "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func listxattr(path string, dest *byte, size int, options int) (sz int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_listxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
-	sz = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_listxattr_trampoline()
-
-//go:cgo_import_dynamic libc_listxattr listxattr "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func flistxattr(fd int, dest *byte, size int, options int) (sz int, err error) {
-	r0, _, e1 := syscall_syscall6(funcPC(libc_flistxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
-	sz = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_flistxattr_trampoline()
-
-//go:cgo_import_dynamic libc_flistxattr flistxattr "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func setattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
-	_, _, e1 := syscall_syscall6(funcPC(libc_setattrlist_trampoline), uintptr(unsafe.Pointer(path)), uintptr(list), uintptr(buf), uintptr(size), uintptr(options), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setattrlist_trampoline()
-
-//go:cgo_import_dynamic libc_setattrlist setattrlist "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func fcntl(fd int, cmd int, arg int) (val int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
-	val = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fcntl_trampoline()
-
-//go:cgo_import_dynamic libc_fcntl fcntl "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func kill(pid int, signum int, posix int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_kill_trampoline), uintptr(pid), uintptr(signum), uintptr(posix))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_kill_trampoline()
-
-//go:cgo_import_dynamic libc_kill kill "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func ioctl(fd int, req uint, arg uintptr) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_ioctl_trampoline()
-
-//go:cgo_import_dynamic libc_ioctl ioctl "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) {
-	var _p0 unsafe.Pointer
-	if len(mib) > 0 {
-		_p0 = unsafe.Pointer(&mib[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_sysctl_trampoline), uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_sysctl_trampoline()
-
-//go:cgo_import_dynamic libc_sysctl sysctl "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) {
-	_, _, e1 := syscall_syscall9(funcPC(libc_sendfile_trampoline), uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(offset>>32), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_sendfile_trampoline()
-
-//go:cgo_import_dynamic libc_sendfile sendfile "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Access(path string, mode uint32) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_access_trampoline()
-
-//go:cgo_import_dynamic libc_access access "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Adjtime(delta *Timeval, olddelta *Timeval) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_adjtime_trampoline()
-
-//go:cgo_import_dynamic libc_adjtime adjtime "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Chdir(path string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_chdir_trampoline()
-
-//go:cgo_import_dynamic libc_chdir chdir "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Chflags(path string, flags int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_chflags_trampoline()
-
-//go:cgo_import_dynamic libc_chflags chflags "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Chmod(path string, mode uint32) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_chmod_trampoline()
-
-//go:cgo_import_dynamic libc_chmod chmod "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Chown(path string, uid int, gid int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_chown_trampoline()
-
-//go:cgo_import_dynamic libc_chown chown "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Chroot(path string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_chroot_trampoline()
-
-//go:cgo_import_dynamic libc_chroot chroot "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func ClockGettime(clockid int32, time *Timespec) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_clock_gettime_trampoline), uintptr(clockid), uintptr(unsafe.Pointer(time)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_clock_gettime_trampoline()
-
-//go:cgo_import_dynamic libc_clock_gettime clock_gettime "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Close(fd int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_close_trampoline), uintptr(fd), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_close_trampoline()
-
-//go:cgo_import_dynamic libc_close close "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Clonefile(src string, dst string, flags int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(src)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(dst)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_clonefile_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flags))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_clonefile_trampoline()
-
-//go:cgo_import_dynamic libc_clonefile clonefile "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Clonefileat(srcDirfd int, src string, dstDirfd int, dst string, flags int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(src)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(dst)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_clonefileat_trampoline), uintptr(srcDirfd), uintptr(unsafe.Pointer(_p0)), uintptr(dstDirfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_clonefileat_trampoline()
-
-//go:cgo_import_dynamic libc_clonefileat clonefileat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Dup(fd int) (nfd int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_dup_trampoline), uintptr(fd), 0, 0)
-	nfd = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_dup_trampoline()
-
-//go:cgo_import_dynamic libc_dup dup "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Dup2(from int, to int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_dup2_trampoline), uintptr(from), uintptr(to), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_dup2_trampoline()
-
-//go:cgo_import_dynamic libc_dup2 dup2 "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Exchangedata(path1 string, path2 string, options int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path1)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(path2)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_exchangedata_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_exchangedata_trampoline()
-
-//go:cgo_import_dynamic libc_exchangedata exchangedata "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Exit(code int) {
-	syscall_syscall(funcPC(libc_exit_trampoline), uintptr(code), 0, 0)
-	return
-}
-
-func libc_exit_trampoline()
-
-//go:cgo_import_dynamic libc_exit exit "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_faccessat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_faccessat_trampoline()
-
-//go:cgo_import_dynamic libc_faccessat faccessat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fchdir(fd int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fchdir_trampoline), uintptr(fd), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fchdir_trampoline()
-
-//go:cgo_import_dynamic libc_fchdir fchdir "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fchflags(fd int, flags int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fchflags_trampoline), uintptr(fd), uintptr(flags), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fchflags_trampoline()
-
-//go:cgo_import_dynamic libc_fchflags fchflags "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fchmod(fd int, mode uint32) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fchmod_trampoline), uintptr(fd), uintptr(mode), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fchmod_trampoline()
-
-//go:cgo_import_dynamic libc_fchmod fchmod "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_fchmodat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fchmodat_trampoline()
-
-//go:cgo_import_dynamic libc_fchmodat fchmodat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fchown(fd int, uid int, gid int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fchown_trampoline), uintptr(fd), uintptr(uid), uintptr(gid))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fchown_trampoline()
-
-//go:cgo_import_dynamic libc_fchown fchown "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_fchownat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fchownat_trampoline()
-
-//go:cgo_import_dynamic libc_fchownat fchownat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fclonefileat(srcDirfd int, dstDirfd int, dst string, flags int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(dst)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_fclonefileat_trampoline), uintptr(srcDirfd), uintptr(dstDirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fclonefileat_trampoline()
-
-//go:cgo_import_dynamic libc_fclonefileat fclonefileat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Flock(fd int, how int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_flock_trampoline), uintptr(fd), uintptr(how), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_flock_trampoline()
-
-//go:cgo_import_dynamic libc_flock flock "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fpathconf(fd int, name int) (val int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_fpathconf_trampoline), uintptr(fd), uintptr(name), 0)
-	val = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fpathconf_trampoline()
-
-//go:cgo_import_dynamic libc_fpathconf fpathconf "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fsync(fd int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fsync_trampoline), uintptr(fd), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fsync_trampoline()
-
-//go:cgo_import_dynamic libc_fsync fsync "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Ftruncate(fd int, length int64) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_ftruncate_trampoline), uintptr(fd), uintptr(length), uintptr(length>>32))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_ftruncate_trampoline()
-
-//go:cgo_import_dynamic libc_ftruncate ftruncate "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getcwd(buf []byte) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(buf) > 0 {
-		_p0 = unsafe.Pointer(&buf[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := syscall_syscall(funcPC(libc_getcwd_trampoline), uintptr(_p0), uintptr(len(buf)), 0)
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_getcwd_trampoline()
-
-//go:cgo_import_dynamic libc_getcwd getcwd "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getdtablesize() (size int) {
-	r0, _, _ := syscall_syscall(funcPC(libc_getdtablesize_trampoline), 0, 0, 0)
-	size = int(r0)
-	return
-}
-
-func libc_getdtablesize_trampoline()
-
-//go:cgo_import_dynamic libc_getdtablesize getdtablesize "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getegid() (egid int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_getegid_trampoline), 0, 0, 0)
-	egid = int(r0)
-	return
-}
-
-func libc_getegid_trampoline()
-
-//go:cgo_import_dynamic libc_getegid getegid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Geteuid() (uid int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_geteuid_trampoline), 0, 0, 0)
-	uid = int(r0)
-	return
-}
-
-func libc_geteuid_trampoline()
-
-//go:cgo_import_dynamic libc_geteuid geteuid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getgid() (gid int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_getgid_trampoline), 0, 0, 0)
-	gid = int(r0)
-	return
-}
-
-func libc_getgid_trampoline()
-
-//go:cgo_import_dynamic libc_getgid getgid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getpgid(pid int) (pgid int, err error) {
-	r0, _, e1 := syscall_rawSyscall(funcPC(libc_getpgid_trampoline), uintptr(pid), 0, 0)
-	pgid = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_getpgid_trampoline()
-
-//go:cgo_import_dynamic libc_getpgid getpgid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getpgrp() (pgrp int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_getpgrp_trampoline), 0, 0, 0)
-	pgrp = int(r0)
-	return
-}
-
-func libc_getpgrp_trampoline()
-
-//go:cgo_import_dynamic libc_getpgrp getpgrp "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getpid() (pid int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_getpid_trampoline), 0, 0, 0)
-	pid = int(r0)
-	return
-}
-
-func libc_getpid_trampoline()
-
-//go:cgo_import_dynamic libc_getpid getpid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getppid() (ppid int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_getppid_trampoline), 0, 0, 0)
-	ppid = int(r0)
-	return
-}
-
-func libc_getppid_trampoline()
-
-//go:cgo_import_dynamic libc_getppid getppid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getpriority(which int, who int) (prio int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_getpriority_trampoline), uintptr(which), uintptr(who), 0)
-	prio = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_getpriority_trampoline()
-
-//go:cgo_import_dynamic libc_getpriority getpriority "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getrlimit(which int, lim *Rlimit) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_getrlimit_trampoline()
-
-//go:cgo_import_dynamic libc_getrlimit getrlimit "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getrusage(who int, rusage *Rusage) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_getrusage_trampoline()
-
-//go:cgo_import_dynamic libc_getrusage getrusage "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getsid(pid int) (sid int, err error) {
-	r0, _, e1 := syscall_rawSyscall(funcPC(libc_getsid_trampoline), uintptr(pid), 0, 0)
-	sid = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_getsid_trampoline()
-
-//go:cgo_import_dynamic libc_getsid getsid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Gettimeofday(tp *Timeval) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_gettimeofday_trampoline()
-
-//go:cgo_import_dynamic libc_gettimeofday gettimeofday "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getuid() (uid int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_getuid_trampoline), 0, 0, 0)
-	uid = int(r0)
-	return
-}
-
-func libc_getuid_trampoline()
-
-//go:cgo_import_dynamic libc_getuid getuid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Issetugid() (tainted bool) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_issetugid_trampoline), 0, 0, 0)
-	tainted = bool(r0 != 0)
-	return
-}
-
-func libc_issetugid_trampoline()
-
-//go:cgo_import_dynamic libc_issetugid issetugid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Kqueue() (fd int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_kqueue_trampoline), 0, 0, 0)
-	fd = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_kqueue_trampoline()
-
-//go:cgo_import_dynamic libc_kqueue kqueue "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Lchown(path string, uid int, gid int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_lchown_trampoline()
-
-//go:cgo_import_dynamic libc_lchown lchown "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Link(path string, link string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(link)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_link_trampoline()
-
-//go:cgo_import_dynamic libc_link link "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Linkat(pathfd int, path string, linkfd int, link string, flags int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(link)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_linkat_trampoline), uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_linkat_trampoline()
-
-//go:cgo_import_dynamic libc_linkat linkat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Listen(s int, backlog int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_listen_trampoline), uintptr(s), uintptr(backlog), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_listen_trampoline()
-
-//go:cgo_import_dynamic libc_listen listen "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Mkdir(path string, mode uint32) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_mkdir_trampoline()
-
-//go:cgo_import_dynamic libc_mkdir mkdir "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Mkdirat(dirfd int, path string, mode uint32) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_mkdirat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_mkdirat_trampoline()
-
-//go:cgo_import_dynamic libc_mkdirat mkdirat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Mkfifo(path string, mode uint32) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_mkfifo_trampoline()
-
-//go:cgo_import_dynamic libc_mkfifo mkfifo "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Mknod(path string, mode uint32, dev int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_mknod_trampoline()
-
-//go:cgo_import_dynamic libc_mknod mknod "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Open(path string, mode int, perm uint32) (fd int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := syscall_syscall(funcPC(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
-	fd = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_open_trampoline()
-
-//go:cgo_import_dynamic libc_open open "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_openat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0)
-	fd = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_openat_trampoline()
-
-//go:cgo_import_dynamic libc_openat openat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Pathconf(path string, name int) (val int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := syscall_syscall(funcPC(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
-	val = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_pathconf_trampoline()
-
-//go:cgo_import_dynamic libc_pathconf pathconf "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Pread(fd int, p []byte, offset int64) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(p) > 0 {
-		_p0 = unsafe.Pointer(&p[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_pread_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_pread_trampoline()
-
-//go:cgo_import_dynamic libc_pread pread "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(p) > 0 {
-		_p0 = unsafe.Pointer(&p[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_pwrite_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_pwrite_trampoline()
-
-//go:cgo_import_dynamic libc_pwrite pwrite "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func read(fd int, p []byte) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(p) > 0 {
-		_p0 = unsafe.Pointer(&p[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := syscall_syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_read_trampoline()
-
-//go:cgo_import_dynamic libc_read read "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Readlink(path string, buf []byte) (n int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 unsafe.Pointer
-	if len(buf) > 0 {
-		_p1 = unsafe.Pointer(&buf[0])
-	} else {
-		_p1 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := syscall_syscall(funcPC(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_readlink_trampoline()
-
-//go:cgo_import_dynamic libc_readlink readlink "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Readlinkat(dirfd int, path string, buf []byte) (n int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 unsafe.Pointer
-	if len(buf) > 0 {
-		_p1 = unsafe.Pointer(&buf[0])
-	} else {
-		_p1 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_readlinkat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_readlinkat_trampoline()
-
-//go:cgo_import_dynamic libc_readlinkat readlinkat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Rename(from string, to string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(from)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(to)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_rename_trampoline()
-
-//go:cgo_import_dynamic libc_rename rename "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Renameat(fromfd int, from string, tofd int, to string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(from)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(to)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_renameat_trampoline), uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_renameat_trampoline()
-
-//go:cgo_import_dynamic libc_renameat renameat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Revoke(path string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_revoke_trampoline()
-
-//go:cgo_import_dynamic libc_revoke revoke "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Rmdir(path string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_rmdir_trampoline()
-
-//go:cgo_import_dynamic libc_rmdir rmdir "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
-	r0, r1, e1 := syscall_syscall6(funcPC(libc_lseek_trampoline), uintptr(fd), uintptr(offset), uintptr(offset>>32), uintptr(whence), 0, 0)
-	newoffset = int64(int64(r1)<<32 | int64(r0))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_lseek_trampoline()
-
-//go:cgo_import_dynamic libc_lseek lseek "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error) {
-	r0, _, e1 := syscall_syscall6(funcPC(libc_select_trampoline), uintptr(nfd), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_select_trampoline()
-
-//go:cgo_import_dynamic libc_select select "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setegid(egid int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_setegid_trampoline), uintptr(egid), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setegid_trampoline()
-
-//go:cgo_import_dynamic libc_setegid setegid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Seteuid(euid int) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_seteuid_trampoline), uintptr(euid), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_seteuid_trampoline()
-
-//go:cgo_import_dynamic libc_seteuid seteuid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setgid(gid int) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setgid_trampoline), uintptr(gid), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setgid_trampoline()
-
-//go:cgo_import_dynamic libc_setgid setgid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setlogin(name string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(name)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setlogin_trampoline()
-
-//go:cgo_import_dynamic libc_setlogin setlogin "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setpgid(pid int, pgid int) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setpgid_trampoline), uintptr(pid), uintptr(pgid), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setpgid_trampoline()
-
-//go:cgo_import_dynamic libc_setpgid setpgid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setpriority(which int, who int, prio int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_setpriority_trampoline), uintptr(which), uintptr(who), uintptr(prio))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setpriority_trampoline()
-
-//go:cgo_import_dynamic libc_setpriority setpriority "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setprivexec(flag int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_setprivexec_trampoline), uintptr(flag), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setprivexec_trampoline()
-
-//go:cgo_import_dynamic libc_setprivexec setprivexec "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setregid(rgid int, egid int) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setregid_trampoline), uintptr(rgid), uintptr(egid), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setregid_trampoline()
-
-//go:cgo_import_dynamic libc_setregid setregid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setreuid(ruid int, euid int) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setreuid_trampoline), uintptr(ruid), uintptr(euid), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setreuid_trampoline()
-
-//go:cgo_import_dynamic libc_setreuid setreuid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setrlimit(which int, lim *Rlimit) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setrlimit_trampoline()
-
-//go:cgo_import_dynamic libc_setrlimit setrlimit "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setsid() (pid int, err error) {
-	r0, _, e1 := syscall_rawSyscall(funcPC(libc_setsid_trampoline), 0, 0, 0)
-	pid = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setsid_trampoline()
-
-//go:cgo_import_dynamic libc_setsid setsid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Settimeofday(tp *Timeval) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_settimeofday_trampoline()
-
-//go:cgo_import_dynamic libc_settimeofday settimeofday "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setuid(uid int) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setuid_trampoline), uintptr(uid), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setuid_trampoline()
-
-//go:cgo_import_dynamic libc_setuid setuid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Symlink(path string, link string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(link)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_symlink_trampoline()
-
-//go:cgo_import_dynamic libc_symlink symlink "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Symlinkat(oldpath string, newdirfd int, newpath string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(oldpath)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(newpath)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_symlinkat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_symlinkat_trampoline()
-
-//go:cgo_import_dynamic libc_symlinkat symlinkat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Sync() (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_sync_trampoline), 0, 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_sync_trampoline()
-
-//go:cgo_import_dynamic libc_sync sync "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Truncate(path string, length int64) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), uintptr(length>>32))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_truncate_trampoline()
-
-//go:cgo_import_dynamic libc_truncate truncate "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Umask(newmask int) (oldmask int) {
-	r0, _, _ := syscall_syscall(funcPC(libc_umask_trampoline), uintptr(newmask), 0, 0)
-	oldmask = int(r0)
-	return
-}
-
-func libc_umask_trampoline()
-
-//go:cgo_import_dynamic libc_umask umask "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Undelete(path string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_undelete_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_undelete_trampoline()
-
-//go:cgo_import_dynamic libc_undelete undelete "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Unlink(path string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_unlink_trampoline()
-
-//go:cgo_import_dynamic libc_unlink unlink "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Unlinkat(dirfd int, path string, flags int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_unlinkat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_unlinkat_trampoline()
-
-//go:cgo_import_dynamic libc_unlinkat unlinkat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Unmount(path string, flags int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_unmount_trampoline()
-
-//go:cgo_import_dynamic libc_unmount unmount "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func write(fd int, p []byte) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(p) > 0 {
-		_p0 = unsafe.Pointer(&p[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := syscall_syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_write_trampoline()
-
-//go:cgo_import_dynamic libc_write write "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
-	r0, _, e1 := syscall_syscall9(funcPC(libc_mmap_trampoline), uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos), uintptr(pos>>32), 0, 0)
-	ret = uintptr(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_mmap_trampoline()
-
-//go:cgo_import_dynamic libc_mmap mmap "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func munmap(addr uintptr, length uintptr) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_munmap_trampoline), uintptr(addr), uintptr(length), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_munmap_trampoline()
-
-//go:cgo_import_dynamic libc_munmap munmap "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fstat(fd int, stat *Stat_t) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fstat64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fstat64_trampoline()
-
-//go:cgo_import_dynamic libc_fstat64 fstat64 "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_fstatat64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fstatat64_trampoline()
-
-//go:cgo_import_dynamic libc_fstatat64 fstatat64 "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fstatfs(fd int, stat *Statfs_t) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fstatfs64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fstatfs64_trampoline()
-
-//go:cgo_import_dynamic libc_fstatfs64 fstatfs64 "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_getfsstat64_trampoline), uintptr(buf), uintptr(size), uintptr(flags))
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_getfsstat64_trampoline()
-
-//go:cgo_import_dynamic libc_getfsstat64 getfsstat64 "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Lstat(path string, stat *Stat_t) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_lstat64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_lstat64_trampoline()
-
-//go:cgo_import_dynamic libc_lstat64 lstat64 "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func ptrace1(request int, pid int, addr uintptr, data uintptr) (err error) {
-	_, _, e1 := syscall_syscall6(funcPC(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_ptrace_trampoline()
-
-//go:cgo_import_dynamic libc_ptrace ptrace "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Stat(path string, stat *Stat_t) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_stat64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_stat64_trampoline()
-
-//go:cgo_import_dynamic libc_stat64 stat64 "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Statfs(path string, stat *Statfs_t) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_statfs64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_statfs64_trampoline()
-
-//go:cgo_import_dynamic libc_statfs64 statfs64 "/usr/lib/libSystem.B.dylib"
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.s b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.s
deleted file mode 100644
index 8cc7928d92..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.s
+++ /dev/null
@@ -1,291 +0,0 @@
-// go run mkasm_darwin.go 386
-// Code generated by the command above; DO NOT EDIT.
-
-//go:build go1.12
-// +build go1.12
-
-#include "textflag.h"
-TEXT ·libc_getgroups_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getgroups(SB)
-TEXT ·libc_setgroups_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setgroups(SB)
-TEXT ·libc_wait4_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_wait4(SB)
-TEXT ·libc_accept_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_accept(SB)
-TEXT ·libc_bind_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_bind(SB)
-TEXT ·libc_connect_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_connect(SB)
-TEXT ·libc_socket_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_socket(SB)
-TEXT ·libc_getsockopt_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getsockopt(SB)
-TEXT ·libc_setsockopt_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setsockopt(SB)
-TEXT ·libc_getpeername_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getpeername(SB)
-TEXT ·libc_getsockname_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getsockname(SB)
-TEXT ·libc_shutdown_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_shutdown(SB)
-TEXT ·libc_socketpair_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_socketpair(SB)
-TEXT ·libc_recvfrom_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_recvfrom(SB)
-TEXT ·libc_sendto_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_sendto(SB)
-TEXT ·libc_recvmsg_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_recvmsg(SB)
-TEXT ·libc_sendmsg_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_sendmsg(SB)
-TEXT ·libc_kevent_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_kevent(SB)
-TEXT ·libc_utimes_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_utimes(SB)
-TEXT ·libc_futimes_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_futimes(SB)
-TEXT ·libc_poll_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_poll(SB)
-TEXT ·libc_madvise_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_madvise(SB)
-TEXT ·libc_mlock_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_mlock(SB)
-TEXT ·libc_mlockall_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_mlockall(SB)
-TEXT ·libc_mprotect_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_mprotect(SB)
-TEXT ·libc_msync_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_msync(SB)
-TEXT ·libc_munlock_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_munlock(SB)
-TEXT ·libc_munlockall_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_munlockall(SB)
-TEXT ·libc_pipe_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_pipe(SB)
-TEXT ·libc_getxattr_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getxattr(SB)
-TEXT ·libc_fgetxattr_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fgetxattr(SB)
-TEXT ·libc_setxattr_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setxattr(SB)
-TEXT ·libc_fsetxattr_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fsetxattr(SB)
-TEXT ·libc_removexattr_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_removexattr(SB)
-TEXT ·libc_fremovexattr_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fremovexattr(SB)
-TEXT ·libc_listxattr_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_listxattr(SB)
-TEXT ·libc_flistxattr_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_flistxattr(SB)
-TEXT ·libc_setattrlist_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setattrlist(SB)
-TEXT ·libc_fcntl_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fcntl(SB)
-TEXT ·libc_kill_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_kill(SB)
-TEXT ·libc_ioctl_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_ioctl(SB)
-TEXT ·libc_sysctl_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_sysctl(SB)
-TEXT ·libc_sendfile_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_sendfile(SB)
-TEXT ·libc_access_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_access(SB)
-TEXT ·libc_adjtime_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_adjtime(SB)
-TEXT ·libc_chdir_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_chdir(SB)
-TEXT ·libc_chflags_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_chflags(SB)
-TEXT ·libc_chmod_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_chmod(SB)
-TEXT ·libc_chown_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_chown(SB)
-TEXT ·libc_chroot_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_chroot(SB)
-TEXT ·libc_clock_gettime_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_clock_gettime(SB)
-TEXT ·libc_close_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_close(SB)
-TEXT ·libc_clonefile_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_clonefile(SB)
-TEXT ·libc_clonefileat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_clonefileat(SB)
-TEXT ·libc_dup_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_dup(SB)
-TEXT ·libc_dup2_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_dup2(SB)
-TEXT ·libc_exchangedata_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_exchangedata(SB)
-TEXT ·libc_exit_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_exit(SB)
-TEXT ·libc_faccessat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_faccessat(SB)
-TEXT ·libc_fchdir_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fchdir(SB)
-TEXT ·libc_fchflags_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fchflags(SB)
-TEXT ·libc_fchmod_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fchmod(SB)
-TEXT ·libc_fchmodat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fchmodat(SB)
-TEXT ·libc_fchown_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fchown(SB)
-TEXT ·libc_fchownat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fchownat(SB)
-TEXT ·libc_fclonefileat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fclonefileat(SB)
-TEXT ·libc_flock_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_flock(SB)
-TEXT ·libc_fpathconf_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fpathconf(SB)
-TEXT ·libc_fsync_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fsync(SB)
-TEXT ·libc_ftruncate_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_ftruncate(SB)
-TEXT ·libc_getcwd_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getcwd(SB)
-TEXT ·libc_getdtablesize_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getdtablesize(SB)
-TEXT ·libc_getegid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getegid(SB)
-TEXT ·libc_geteuid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_geteuid(SB)
-TEXT ·libc_getgid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getgid(SB)
-TEXT ·libc_getpgid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getpgid(SB)
-TEXT ·libc_getpgrp_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getpgrp(SB)
-TEXT ·libc_getpid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getpid(SB)
-TEXT ·libc_getppid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getppid(SB)
-TEXT ·libc_getpriority_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getpriority(SB)
-TEXT ·libc_getrlimit_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getrlimit(SB)
-TEXT ·libc_getrusage_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getrusage(SB)
-TEXT ·libc_getsid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getsid(SB)
-TEXT ·libc_gettimeofday_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_gettimeofday(SB)
-TEXT ·libc_getuid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getuid(SB)
-TEXT ·libc_issetugid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_issetugid(SB)
-TEXT ·libc_kqueue_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_kqueue(SB)
-TEXT ·libc_lchown_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_lchown(SB)
-TEXT ·libc_link_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_link(SB)
-TEXT ·libc_linkat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_linkat(SB)
-TEXT ·libc_listen_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_listen(SB)
-TEXT ·libc_mkdir_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_mkdir(SB)
-TEXT ·libc_mkdirat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_mkdirat(SB)
-TEXT ·libc_mkfifo_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_mkfifo(SB)
-TEXT ·libc_mknod_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_mknod(SB)
-TEXT ·libc_open_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_open(SB)
-TEXT ·libc_openat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_openat(SB)
-TEXT ·libc_pathconf_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_pathconf(SB)
-TEXT ·libc_pread_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_pread(SB)
-TEXT ·libc_pwrite_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_pwrite(SB)
-TEXT ·libc_read_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_read(SB)
-TEXT ·libc_readlink_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_readlink(SB)
-TEXT ·libc_readlinkat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_readlinkat(SB)
-TEXT ·libc_rename_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_rename(SB)
-TEXT ·libc_renameat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_renameat(SB)
-TEXT ·libc_revoke_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_revoke(SB)
-TEXT ·libc_rmdir_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_rmdir(SB)
-TEXT ·libc_lseek_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_lseek(SB)
-TEXT ·libc_select_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_select(SB)
-TEXT ·libc_setegid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setegid(SB)
-TEXT ·libc_seteuid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_seteuid(SB)
-TEXT ·libc_setgid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setgid(SB)
-TEXT ·libc_setlogin_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setlogin(SB)
-TEXT ·libc_setpgid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setpgid(SB)
-TEXT ·libc_setpriority_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setpriority(SB)
-TEXT ·libc_setprivexec_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setprivexec(SB)
-TEXT ·libc_setregid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setregid(SB)
-TEXT ·libc_setreuid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setreuid(SB)
-TEXT ·libc_setrlimit_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setrlimit(SB)
-TEXT ·libc_setsid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setsid(SB)
-TEXT ·libc_settimeofday_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_settimeofday(SB)
-TEXT ·libc_setuid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setuid(SB)
-TEXT ·libc_symlink_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_symlink(SB)
-TEXT ·libc_symlinkat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_symlinkat(SB)
-TEXT ·libc_sync_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_sync(SB)
-TEXT ·libc_truncate_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_truncate(SB)
-TEXT ·libc_umask_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_umask(SB)
-TEXT ·libc_undelete_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_undelete(SB)
-TEXT ·libc_unlink_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_unlink(SB)
-TEXT ·libc_unlinkat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_unlinkat(SB)
-TEXT ·libc_unmount_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_unmount(SB)
-TEXT ·libc_write_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_write(SB)
-TEXT ·libc_mmap_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_mmap(SB)
-TEXT ·libc_munmap_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_munmap(SB)
-TEXT ·libc_fstat64_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fstat64(SB)
-TEXT ·libc_fstatat64_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fstatat64(SB)
-TEXT ·libc_fstatfs64_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fstatfs64(SB)
-TEXT ·libc_getfsstat64_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getfsstat64(SB)
-TEXT ·libc_lstat64_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_lstat64(SB)
-TEXT ·libc_ptrace_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_ptrace(SB)
-TEXT ·libc_stat64_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_stat64(SB)
-TEXT ·libc_statfs64_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_statfs64(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.1_13.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.1_13.go
index e36299ead0..a06eb09324 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.1_13.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.1_13.go
@@ -16,25 +16,25 @@ var _ syscall.Errno
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func closedir(dir uintptr) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_closedir_trampoline), uintptr(dir), 0, 0)
+	_, _, e1 := syscall_syscall(libc_closedir_trampoline_addr, uintptr(dir), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_closedir_trampoline()
+var libc_closedir_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_closedir closedir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func readdir_r(dir uintptr, entry *Dirent, result **Dirent) (res Errno) {
-	r0, _, _ := syscall_syscall(funcPC(libc_readdir_r_trampoline), uintptr(dir), uintptr(unsafe.Pointer(entry)), uintptr(unsafe.Pointer(result)))
+	r0, _, _ := syscall_syscall(libc_readdir_r_trampoline_addr, uintptr(dir), uintptr(unsafe.Pointer(entry)), uintptr(unsafe.Pointer(result)))
 	res = Errno(r0)
 	return
 }
 
-func libc_readdir_r_trampoline()
+var libc_readdir_r_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_readdir_r readdir_r "/usr/lib/libSystem.B.dylib"
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.1_13.s b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.1_13.s
index ab59833fcd..d6c3e25c01 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.1_13.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.1_13.s
@@ -5,9 +5,21 @@
 // +build go1.13
 
 #include "textflag.h"
-TEXT ·libc_fdopendir_trampoline(SB),NOSPLIT,$0-0
+
+TEXT libc_fdopendir_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fdopendir(SB)
-TEXT ·libc_closedir_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fdopendir_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fdopendir_trampoline_addr(SB)/8, $libc_fdopendir_trampoline<>(SB)
+
+TEXT libc_closedir_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_closedir(SB)
-TEXT ·libc_readdir_r_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_closedir_trampoline_addr(SB), RODATA, $8
+DATA	·libc_closedir_trampoline_addr(SB)/8, $libc_closedir_trampoline<>(SB)
+
+TEXT libc_readdir_r_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_readdir_r(SB)
+
+GLOBL	·libc_readdir_r_trampoline_addr(SB), RODATA, $8
+DATA	·libc_readdir_r_trampoline_addr(SB)/8, $libc_readdir_r_trampoline<>(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
index f411162882..d4efe8d457 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
@@ -16,7 +16,7 @@ var _ syscall.Errno
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
-	r0, _, e1 := syscall_rawSyscall(funcPC(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
+	r0, _, e1 := syscall_rawSyscall(libc_getgroups_trampoline_addr, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -24,28 +24,28 @@ func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
 	return
 }
 
-func libc_getgroups_trampoline()
+var libc_getgroups_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getgroups getgroups "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func setgroups(ngid int, gid *_Gid_t) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
+	_, _, e1 := syscall_rawSyscall(libc_setgroups_trampoline_addr, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setgroups_trampoline()
+var libc_setgroups_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setgroups setgroups "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) {
-	r0, _, e1 := syscall_syscall6(funcPC(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
+	r0, _, e1 := syscall_syscall6(libc_wait4_trampoline_addr, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
 	wpid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -53,14 +53,14 @@ func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err
 	return
 }
 
-func libc_wait4_trampoline()
+var libc_wait4_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_wait4 wait4 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	r0, _, e1 := syscall_syscall(libc_accept_trampoline_addr, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -68,42 +68,42 @@ func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
 	return
 }
 
-func libc_accept_trampoline()
+var libc_accept_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_accept accept "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_bind_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
+	_, _, e1 := syscall_syscall(libc_bind_trampoline_addr, uintptr(s), uintptr(addr), uintptr(addrlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_bind_trampoline()
+var libc_bind_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_bind bind "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_connect_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
+	_, _, e1 := syscall_syscall(libc_connect_trampoline_addr, uintptr(s), uintptr(addr), uintptr(addrlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_connect_trampoline()
+var libc_connect_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_connect connect "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func socket(domain int, typ int, proto int) (fd int, err error) {
-	r0, _, e1 := syscall_rawSyscall(funcPC(libc_socket_trampoline), uintptr(domain), uintptr(typ), uintptr(proto))
+	r0, _, e1 := syscall_rawSyscall(libc_socket_trampoline_addr, uintptr(domain), uintptr(typ), uintptr(proto))
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -111,91 +111,91 @@ func socket(domain int, typ int, proto int) (fd int, err error) {
 	return
 }
 
-func libc_socket_trampoline()
+var libc_socket_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_socket socket "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
-	_, _, e1 := syscall_syscall6(funcPC(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
+	_, _, e1 := syscall_syscall6(libc_getsockopt_trampoline_addr, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_getsockopt_trampoline()
+var libc_getsockopt_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getsockopt getsockopt "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
-	_, _, e1 := syscall_syscall6(funcPC(libc_setsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
+	_, _, e1 := syscall_syscall6(libc_setsockopt_trampoline_addr, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setsockopt_trampoline()
+var libc_setsockopt_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setsockopt setsockopt "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	_, _, e1 := syscall_rawSyscall(libc_getpeername_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_getpeername_trampoline()
+var libc_getpeername_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getpeername getpeername "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	_, _, e1 := syscall_rawSyscall(libc_getsockname_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_getsockname_trampoline()
+var libc_getsockname_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getsockname getsockname "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Shutdown(s int, how int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_shutdown_trampoline), uintptr(s), uintptr(how), 0)
+	_, _, e1 := syscall_syscall(libc_shutdown_trampoline_addr, uintptr(s), uintptr(how), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_shutdown_trampoline()
+var libc_shutdown_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_shutdown shutdown "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
-	_, _, e1 := syscall_rawSyscall6(funcPC(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
+	_, _, e1 := syscall_rawSyscall6(libc_socketpair_trampoline_addr, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_socketpair_trampoline()
+var libc_socketpair_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_socketpair socketpair "/usr/lib/libSystem.B.dylib"
 
@@ -208,7 +208,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_recvfrom_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
+	r0, _, e1 := syscall_syscall6(libc_recvfrom_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -216,7 +216,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
 	return
 }
 
-func libc_recvfrom_trampoline()
+var libc_recvfrom_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_recvfrom recvfrom "/usr/lib/libSystem.B.dylib"
 
@@ -229,21 +229,21 @@ func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_sendto_trampoline), uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
+	_, _, e1 := syscall_syscall6(libc_sendto_trampoline_addr, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_sendto_trampoline()
+var libc_sendto_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_sendto sendto "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
+	r0, _, e1 := syscall_syscall(libc_recvmsg_trampoline_addr, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -251,14 +251,14 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 	return
 }
 
-func libc_recvmsg_trampoline()
+var libc_recvmsg_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_recvmsg recvmsg "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
+	r0, _, e1 := syscall_syscall(libc_sendmsg_trampoline_addr, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -266,14 +266,14 @@ func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 	return
 }
 
-func libc_sendmsg_trampoline()
+var libc_sendmsg_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_sendmsg sendmsg "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
-	r0, _, e1 := syscall_syscall6(funcPC(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
+	r0, _, e1 := syscall_syscall6(libc_kevent_trampoline_addr, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -281,7 +281,7 @@ func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, ne
 	return
 }
 
-func libc_kevent_trampoline()
+var libc_kevent_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_kevent kevent "/usr/lib/libSystem.B.dylib"
 
@@ -293,35 +293,35 @@ func utimes(path string, timeval *[2]Timeval) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
+	_, _, e1 := syscall_syscall(libc_utimes_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_utimes_trampoline()
+var libc_utimes_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_utimes utimes "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func futimes(fd int, timeval *[2]Timeval) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
+	_, _, e1 := syscall_syscall(libc_futimes_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_futimes_trampoline()
+var libc_futimes_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_futimes futimes "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func poll(fds *PollFd, nfds int, timeout int) (n int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_poll_trampoline), uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
+	r0, _, e1 := syscall_syscall(libc_poll_trampoline_addr, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -329,7 +329,7 @@ func poll(fds *PollFd, nfds int, timeout int) (n int, err error) {
 	return
 }
 
-func libc_poll_trampoline()
+var libc_poll_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_poll poll "/usr/lib/libSystem.B.dylib"
 
@@ -342,14 +342,14 @@ func Madvise(b []byte, behav int) (err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_madvise_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(behav))
+	_, _, e1 := syscall_syscall(libc_madvise_trampoline_addr, uintptr(_p0), uintptr(len(b)), uintptr(behav))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_madvise_trampoline()
+var libc_madvise_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_madvise madvise "/usr/lib/libSystem.B.dylib"
 
@@ -362,28 +362,28 @@ func Mlock(b []byte) (err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_mlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
+	_, _, e1 := syscall_syscall(libc_mlock_trampoline_addr, uintptr(_p0), uintptr(len(b)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_mlock_trampoline()
+var libc_mlock_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_mlock mlock "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Mlockall(flags int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_mlockall_trampoline), uintptr(flags), 0, 0)
+	_, _, e1 := syscall_syscall(libc_mlockall_trampoline_addr, uintptr(flags), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_mlockall_trampoline()
+var libc_mlockall_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_mlockall mlockall "/usr/lib/libSystem.B.dylib"
 
@@ -396,14 +396,14 @@ func Mprotect(b []byte, prot int) (err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_mprotect_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(prot))
+	_, _, e1 := syscall_syscall(libc_mprotect_trampoline_addr, uintptr(_p0), uintptr(len(b)), uintptr(prot))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_mprotect_trampoline()
+var libc_mprotect_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_mprotect mprotect "/usr/lib/libSystem.B.dylib"
 
@@ -416,14 +416,14 @@ func Msync(b []byte, flags int) (err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_msync_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(flags))
+	_, _, e1 := syscall_syscall(libc_msync_trampoline_addr, uintptr(_p0), uintptr(len(b)), uintptr(flags))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_msync_trampoline()
+var libc_msync_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_msync msync "/usr/lib/libSystem.B.dylib"
 
@@ -436,42 +436,42 @@ func Munlock(b []byte) (err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_munlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
+	_, _, e1 := syscall_syscall(libc_munlock_trampoline_addr, uintptr(_p0), uintptr(len(b)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_munlock_trampoline()
+var libc_munlock_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_munlock munlock "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Munlockall() (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_munlockall_trampoline), 0, 0, 0)
+	_, _, e1 := syscall_syscall(libc_munlockall_trampoline_addr, 0, 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_munlockall_trampoline()
+var libc_munlockall_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_munlockall munlockall "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func pipe(p *[2]int32) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), uintptr(unsafe.Pointer(p)), 0, 0)
+	_, _, e1 := syscall_rawSyscall(libc_pipe_trampoline_addr, uintptr(unsafe.Pointer(p)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_pipe_trampoline()
+var libc_pipe_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_pipe pipe "/usr/lib/libSystem.B.dylib"
 
@@ -488,7 +488,7 @@ func getxattr(path string, attr string, dest *byte, size int, position uint32, o
 	if err != nil {
 		return
 	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_getxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
+	r0, _, e1 := syscall_syscall6(libc_getxattr_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
 	sz = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -496,7 +496,7 @@ func getxattr(path string, attr string, dest *byte, size int, position uint32, o
 	return
 }
 
-func libc_getxattr_trampoline()
+var libc_getxattr_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getxattr getxattr "/usr/lib/libSystem.B.dylib"
 
@@ -508,7 +508,7 @@ func fgetxattr(fd int, attr string, dest *byte, size int, position uint32, optio
 	if err != nil {
 		return
 	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_fgetxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
+	r0, _, e1 := syscall_syscall6(libc_fgetxattr_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
 	sz = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -516,7 +516,7 @@ func fgetxattr(fd int, attr string, dest *byte, size int, position uint32, optio
 	return
 }
 
-func libc_fgetxattr_trampoline()
+var libc_fgetxattr_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fgetxattr fgetxattr "/usr/lib/libSystem.B.dylib"
 
@@ -533,14 +533,14 @@ func setxattr(path string, attr string, data *byte, size int, position uint32, o
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_setxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
+	_, _, e1 := syscall_syscall6(libc_setxattr_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setxattr_trampoline()
+var libc_setxattr_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setxattr setxattr "/usr/lib/libSystem.B.dylib"
 
@@ -552,14 +552,14 @@ func fsetxattr(fd int, attr string, data *byte, size int, position uint32, optio
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_fsetxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
+	_, _, e1 := syscall_syscall6(libc_fsetxattr_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fsetxattr_trampoline()
+var libc_fsetxattr_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fsetxattr fsetxattr "/usr/lib/libSystem.B.dylib"
 
@@ -576,14 +576,14 @@ func removexattr(path string, attr string, options int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_removexattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
+	_, _, e1 := syscall_syscall(libc_removexattr_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_removexattr_trampoline()
+var libc_removexattr_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_removexattr removexattr "/usr/lib/libSystem.B.dylib"
 
@@ -595,14 +595,14 @@ func fremovexattr(fd int, attr string, options int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_fremovexattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(options))
+	_, _, e1 := syscall_syscall(libc_fremovexattr_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(options))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fremovexattr_trampoline()
+var libc_fremovexattr_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fremovexattr fremovexattr "/usr/lib/libSystem.B.dylib"
 
@@ -614,7 +614,7 @@ func listxattr(path string, dest *byte, size int, options int) (sz int, err erro
 	if err != nil {
 		return
 	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_listxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
+	r0, _, e1 := syscall_syscall6(libc_listxattr_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
 	sz = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -622,14 +622,14 @@ func listxattr(path string, dest *byte, size int, options int) (sz int, err erro
 	return
 }
 
-func libc_listxattr_trampoline()
+var libc_listxattr_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_listxattr listxattr "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func flistxattr(fd int, dest *byte, size int, options int) (sz int, err error) {
-	r0, _, e1 := syscall_syscall6(funcPC(libc_flistxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
+	r0, _, e1 := syscall_syscall6(libc_flistxattr_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
 	sz = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -637,28 +637,28 @@ func flistxattr(fd int, dest *byte, size int, options int) (sz int, err error) {
 	return
 }
 
-func libc_flistxattr_trampoline()
+var libc_flistxattr_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_flistxattr flistxattr "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func setattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
-	_, _, e1 := syscall_syscall6(funcPC(libc_setattrlist_trampoline), uintptr(unsafe.Pointer(path)), uintptr(list), uintptr(buf), uintptr(size), uintptr(options), 0)
+	_, _, e1 := syscall_syscall6(libc_setattrlist_trampoline_addr, uintptr(unsafe.Pointer(path)), uintptr(list), uintptr(buf), uintptr(size), uintptr(options), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setattrlist_trampoline()
+var libc_setattrlist_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setattrlist setattrlist "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func fcntl(fd int, cmd int, arg int) (val int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
+	r0, _, e1 := syscall_syscall(libc_fcntl_trampoline_addr, uintptr(fd), uintptr(cmd), uintptr(arg))
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -666,35 +666,35 @@ func fcntl(fd int, cmd int, arg int) (val int, err error) {
 	return
 }
 
-func libc_fcntl_trampoline()
+var libc_fcntl_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fcntl fcntl "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func kill(pid int, signum int, posix int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_kill_trampoline), uintptr(pid), uintptr(signum), uintptr(posix))
+	_, _, e1 := syscall_syscall(libc_kill_trampoline_addr, uintptr(pid), uintptr(signum), uintptr(posix))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_kill_trampoline()
+var libc_kill_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_kill kill "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func ioctl(fd int, req uint, arg uintptr) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
+	_, _, e1 := syscall_syscall(libc_ioctl_trampoline_addr, uintptr(fd), uintptr(req), uintptr(arg))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_ioctl_trampoline()
+var libc_ioctl_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_ioctl ioctl "/usr/lib/libSystem.B.dylib"
 
@@ -707,28 +707,28 @@ func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr)
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_sysctl_trampoline), uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
+	_, _, e1 := syscall_syscall6(libc_sysctl_trampoline_addr, uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_sysctl_trampoline()
+var libc_sysctl_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_sysctl sysctl "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) {
-	_, _, e1 := syscall_syscall6(funcPC(libc_sendfile_trampoline), uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags))
+	_, _, e1 := syscall_syscall6(libc_sendfile_trampoline_addr, uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_sendfile_trampoline()
+var libc_sendfile_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_sendfile sendfile "/usr/lib/libSystem.B.dylib"
 
@@ -740,28 +740,28 @@ func Access(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall_syscall(libc_access_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_access_trampoline()
+var libc_access_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_access access "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Adjtime(delta *Timeval, olddelta *Timeval) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
+	_, _, e1 := syscall_syscall(libc_adjtime_trampoline_addr, uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_adjtime_trampoline()
+var libc_adjtime_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_adjtime adjtime "/usr/lib/libSystem.B.dylib"
 
@@ -773,14 +773,14 @@ func Chdir(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall_syscall(libc_chdir_trampoline_addr, uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_chdir_trampoline()
+var libc_chdir_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_chdir chdir "/usr/lib/libSystem.B.dylib"
 
@@ -792,14 +792,14 @@ func Chflags(path string, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
+	_, _, e1 := syscall_syscall(libc_chflags_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_chflags_trampoline()
+var libc_chflags_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_chflags chflags "/usr/lib/libSystem.B.dylib"
 
@@ -811,14 +811,14 @@ func Chmod(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall_syscall(libc_chmod_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_chmod_trampoline()
+var libc_chmod_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_chmod chmod "/usr/lib/libSystem.B.dylib"
 
@@ -830,14 +830,14 @@ func Chown(path string, uid int, gid int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
+	_, _, e1 := syscall_syscall(libc_chown_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_chown_trampoline()
+var libc_chown_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_chown chown "/usr/lib/libSystem.B.dylib"
 
@@ -849,42 +849,42 @@ func Chroot(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall_syscall(libc_chroot_trampoline_addr, uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_chroot_trampoline()
+var libc_chroot_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_chroot chroot "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func ClockGettime(clockid int32, time *Timespec) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_clock_gettime_trampoline), uintptr(clockid), uintptr(unsafe.Pointer(time)), 0)
+	_, _, e1 := syscall_syscall(libc_clock_gettime_trampoline_addr, uintptr(clockid), uintptr(unsafe.Pointer(time)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_clock_gettime_trampoline()
+var libc_clock_gettime_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_clock_gettime clock_gettime "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Close(fd int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_close_trampoline), uintptr(fd), 0, 0)
+	_, _, e1 := syscall_syscall(libc_close_trampoline_addr, uintptr(fd), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_close_trampoline()
+var libc_close_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_close close "/usr/lib/libSystem.B.dylib"
 
@@ -901,14 +901,14 @@ func Clonefile(src string, dst string, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_clonefile_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flags))
+	_, _, e1 := syscall_syscall(libc_clonefile_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flags))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_clonefile_trampoline()
+var libc_clonefile_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_clonefile clonefile "/usr/lib/libSystem.B.dylib"
 
@@ -925,21 +925,21 @@ func Clonefileat(srcDirfd int, src string, dstDirfd int, dst string, flags int)
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_clonefileat_trampoline), uintptr(srcDirfd), uintptr(unsafe.Pointer(_p0)), uintptr(dstDirfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
+	_, _, e1 := syscall_syscall6(libc_clonefileat_trampoline_addr, uintptr(srcDirfd), uintptr(unsafe.Pointer(_p0)), uintptr(dstDirfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_clonefileat_trampoline()
+var libc_clonefileat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_clonefileat clonefileat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Dup(fd int) (nfd int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_dup_trampoline), uintptr(fd), 0, 0)
+	r0, _, e1 := syscall_syscall(libc_dup_trampoline_addr, uintptr(fd), 0, 0)
 	nfd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -947,21 +947,21 @@ func Dup(fd int) (nfd int, err error) {
 	return
 }
 
-func libc_dup_trampoline()
+var libc_dup_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_dup dup "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Dup2(from int, to int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_dup2_trampoline), uintptr(from), uintptr(to), 0)
+	_, _, e1 := syscall_syscall(libc_dup2_trampoline_addr, uintptr(from), uintptr(to), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_dup2_trampoline()
+var libc_dup2_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_dup2 dup2 "/usr/lib/libSystem.B.dylib"
 
@@ -978,25 +978,25 @@ func Exchangedata(path1 string, path2 string, options int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_exchangedata_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
+	_, _, e1 := syscall_syscall(libc_exchangedata_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_exchangedata_trampoline()
+var libc_exchangedata_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_exchangedata exchangedata "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Exit(code int) {
-	syscall_syscall(funcPC(libc_exit_trampoline), uintptr(code), 0, 0)
+	syscall_syscall(libc_exit_trampoline_addr, uintptr(code), 0, 0)
 	return
 }
 
-func libc_exit_trampoline()
+var libc_exit_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_exit exit "/usr/lib/libSystem.B.dylib"
 
@@ -1008,56 +1008,56 @@ func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_faccessat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
+	_, _, e1 := syscall_syscall6(libc_faccessat_trampoline_addr, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_faccessat_trampoline()
+var libc_faccessat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_faccessat faccessat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchdir(fd int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fchdir_trampoline), uintptr(fd), 0, 0)
+	_, _, e1 := syscall_syscall(libc_fchdir_trampoline_addr, uintptr(fd), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fchdir_trampoline()
+var libc_fchdir_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fchdir fchdir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchflags(fd int, flags int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fchflags_trampoline), uintptr(fd), uintptr(flags), 0)
+	_, _, e1 := syscall_syscall(libc_fchflags_trampoline_addr, uintptr(fd), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fchflags_trampoline()
+var libc_fchflags_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fchflags fchflags "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchmod(fd int, mode uint32) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fchmod_trampoline), uintptr(fd), uintptr(mode), 0)
+	_, _, e1 := syscall_syscall(libc_fchmod_trampoline_addr, uintptr(fd), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fchmod_trampoline()
+var libc_fchmod_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fchmod fchmod "/usr/lib/libSystem.B.dylib"
 
@@ -1069,28 +1069,28 @@ func Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_fchmodat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
+	_, _, e1 := syscall_syscall6(libc_fchmodat_trampoline_addr, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fchmodat_trampoline()
+var libc_fchmodat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fchmodat fchmodat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchown(fd int, uid int, gid int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fchown_trampoline), uintptr(fd), uintptr(uid), uintptr(gid))
+	_, _, e1 := syscall_syscall(libc_fchown_trampoline_addr, uintptr(fd), uintptr(uid), uintptr(gid))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fchown_trampoline()
+var libc_fchown_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fchown fchown "/usr/lib/libSystem.B.dylib"
 
@@ -1102,14 +1102,14 @@ func Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_fchownat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
+	_, _, e1 := syscall_syscall6(libc_fchownat_trampoline_addr, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fchownat_trampoline()
+var libc_fchownat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fchownat fchownat "/usr/lib/libSystem.B.dylib"
 
@@ -1121,35 +1121,35 @@ func Fclonefileat(srcDirfd int, dstDirfd int, dst string, flags int) (err error)
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_fclonefileat_trampoline), uintptr(srcDirfd), uintptr(dstDirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0, 0)
+	_, _, e1 := syscall_syscall6(libc_fclonefileat_trampoline_addr, uintptr(srcDirfd), uintptr(dstDirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fclonefileat_trampoline()
+var libc_fclonefileat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fclonefileat fclonefileat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Flock(fd int, how int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_flock_trampoline), uintptr(fd), uintptr(how), 0)
+	_, _, e1 := syscall_syscall(libc_flock_trampoline_addr, uintptr(fd), uintptr(how), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_flock_trampoline()
+var libc_flock_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_flock flock "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fpathconf(fd int, name int) (val int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_fpathconf_trampoline), uintptr(fd), uintptr(name), 0)
+	r0, _, e1 := syscall_syscall(libc_fpathconf_trampoline_addr, uintptr(fd), uintptr(name), 0)
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1157,35 +1157,35 @@ func Fpathconf(fd int, name int) (val int, err error) {
 	return
 }
 
-func libc_fpathconf_trampoline()
+var libc_fpathconf_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fpathconf fpathconf "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fsync(fd int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fsync_trampoline), uintptr(fd), 0, 0)
+	_, _, e1 := syscall_syscall(libc_fsync_trampoline_addr, uintptr(fd), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fsync_trampoline()
+var libc_fsync_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fsync fsync "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Ftruncate(fd int, length int64) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_ftruncate_trampoline), uintptr(fd), uintptr(length), 0)
+	_, _, e1 := syscall_syscall(libc_ftruncate_trampoline_addr, uintptr(fd), uintptr(length), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_ftruncate_trampoline()
+var libc_ftruncate_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_ftruncate ftruncate "/usr/lib/libSystem.B.dylib"
 
@@ -1198,7 +1198,7 @@ func Getcwd(buf []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall_syscall(funcPC(libc_getcwd_trampoline), uintptr(_p0), uintptr(len(buf)), 0)
+	r0, _, e1 := syscall_syscall(libc_getcwd_trampoline_addr, uintptr(_p0), uintptr(len(buf)), 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1206,62 +1206,62 @@ func Getcwd(buf []byte) (n int, err error) {
 	return
 }
 
-func libc_getcwd_trampoline()
+var libc_getcwd_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getcwd getcwd "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getdtablesize() (size int) {
-	r0, _, _ := syscall_syscall(funcPC(libc_getdtablesize_trampoline), 0, 0, 0)
+	r0, _, _ := syscall_syscall(libc_getdtablesize_trampoline_addr, 0, 0, 0)
 	size = int(r0)
 	return
 }
 
-func libc_getdtablesize_trampoline()
+var libc_getdtablesize_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getdtablesize getdtablesize "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getegid() (egid int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_getegid_trampoline), 0, 0, 0)
+	r0, _, _ := syscall_rawSyscall(libc_getegid_trampoline_addr, 0, 0, 0)
 	egid = int(r0)
 	return
 }
 
-func libc_getegid_trampoline()
+var libc_getegid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getegid getegid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Geteuid() (uid int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_geteuid_trampoline), 0, 0, 0)
+	r0, _, _ := syscall_rawSyscall(libc_geteuid_trampoline_addr, 0, 0, 0)
 	uid = int(r0)
 	return
 }
 
-func libc_geteuid_trampoline()
+var libc_geteuid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_geteuid geteuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getgid() (gid int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_getgid_trampoline), 0, 0, 0)
+	r0, _, _ := syscall_rawSyscall(libc_getgid_trampoline_addr, 0, 0, 0)
 	gid = int(r0)
 	return
 }
 
-func libc_getgid_trampoline()
+var libc_getgid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getgid getgid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpgid(pid int) (pgid int, err error) {
-	r0, _, e1 := syscall_rawSyscall(funcPC(libc_getpgid_trampoline), uintptr(pid), 0, 0)
+	r0, _, e1 := syscall_rawSyscall(libc_getpgid_trampoline_addr, uintptr(pid), 0, 0)
 	pgid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1269,50 +1269,50 @@ func Getpgid(pid int) (pgid int, err error) {
 	return
 }
 
-func libc_getpgid_trampoline()
+var libc_getpgid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getpgid getpgid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpgrp() (pgrp int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_getpgrp_trampoline), 0, 0, 0)
+	r0, _, _ := syscall_rawSyscall(libc_getpgrp_trampoline_addr, 0, 0, 0)
 	pgrp = int(r0)
 	return
 }
 
-func libc_getpgrp_trampoline()
+var libc_getpgrp_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getpgrp getpgrp "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpid() (pid int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_getpid_trampoline), 0, 0, 0)
+	r0, _, _ := syscall_rawSyscall(libc_getpid_trampoline_addr, 0, 0, 0)
 	pid = int(r0)
 	return
 }
 
-func libc_getpid_trampoline()
+var libc_getpid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getpid getpid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getppid() (ppid int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_getppid_trampoline), 0, 0, 0)
+	r0, _, _ := syscall_rawSyscall(libc_getppid_trampoline_addr, 0, 0, 0)
 	ppid = int(r0)
 	return
 }
 
-func libc_getppid_trampoline()
+var libc_getppid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getppid getppid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpriority(which int, who int) (prio int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_getpriority_trampoline), uintptr(which), uintptr(who), 0)
+	r0, _, e1 := syscall_syscall(libc_getpriority_trampoline_addr, uintptr(which), uintptr(who), 0)
 	prio = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1320,42 +1320,42 @@ func Getpriority(which int, who int) (prio int, err error) {
 	return
 }
 
-func libc_getpriority_trampoline()
+var libc_getpriority_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getpriority getpriority "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getrlimit(which int, lim *Rlimit) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
+	_, _, e1 := syscall_rawSyscall(libc_getrlimit_trampoline_addr, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_getrlimit_trampoline()
+var libc_getrlimit_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getrlimit getrlimit "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getrusage(who int, rusage *Rusage) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
+	_, _, e1 := syscall_rawSyscall(libc_getrusage_trampoline_addr, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_getrusage_trampoline()
+var libc_getrusage_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getrusage getrusage "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getsid(pid int) (sid int, err error) {
-	r0, _, e1 := syscall_rawSyscall(funcPC(libc_getsid_trampoline), uintptr(pid), 0, 0)
+	r0, _, e1 := syscall_rawSyscall(libc_getsid_trampoline_addr, uintptr(pid), 0, 0)
 	sid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1363,52 +1363,52 @@ func Getsid(pid int) (sid int, err error) {
 	return
 }
 
-func libc_getsid_trampoline()
+var libc_getsid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getsid getsid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Gettimeofday(tp *Timeval) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
+	_, _, e1 := syscall_rawSyscall(libc_gettimeofday_trampoline_addr, uintptr(unsafe.Pointer(tp)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_gettimeofday_trampoline()
+var libc_gettimeofday_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_gettimeofday gettimeofday "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getuid() (uid int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_getuid_trampoline), 0, 0, 0)
+	r0, _, _ := syscall_rawSyscall(libc_getuid_trampoline_addr, 0, 0, 0)
 	uid = int(r0)
 	return
 }
 
-func libc_getuid_trampoline()
+var libc_getuid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getuid getuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Issetugid() (tainted bool) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_issetugid_trampoline), 0, 0, 0)
+	r0, _, _ := syscall_rawSyscall(libc_issetugid_trampoline_addr, 0, 0, 0)
 	tainted = bool(r0 != 0)
 	return
 }
 
-func libc_issetugid_trampoline()
+var libc_issetugid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_issetugid issetugid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Kqueue() (fd int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_kqueue_trampoline), 0, 0, 0)
+	r0, _, e1 := syscall_syscall(libc_kqueue_trampoline_addr, 0, 0, 0)
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1416,7 +1416,7 @@ func Kqueue() (fd int, err error) {
 	return
 }
 
-func libc_kqueue_trampoline()
+var libc_kqueue_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_kqueue kqueue "/usr/lib/libSystem.B.dylib"
 
@@ -1428,14 +1428,14 @@ func Lchown(path string, uid int, gid int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
+	_, _, e1 := syscall_syscall(libc_lchown_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_lchown_trampoline()
+var libc_lchown_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_lchown lchown "/usr/lib/libSystem.B.dylib"
 
@@ -1452,14 +1452,14 @@ func Link(path string, link string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	_, _, e1 := syscall_syscall(libc_link_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_link_trampoline()
+var libc_link_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_link link "/usr/lib/libSystem.B.dylib"
 
@@ -1476,28 +1476,28 @@ func Linkat(pathfd int, path string, linkfd int, link string, flags int) (err er
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_linkat_trampoline), uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
+	_, _, e1 := syscall_syscall6(libc_linkat_trampoline_addr, uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_linkat_trampoline()
+var libc_linkat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_linkat linkat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Listen(s int, backlog int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_listen_trampoline), uintptr(s), uintptr(backlog), 0)
+	_, _, e1 := syscall_syscall(libc_listen_trampoline_addr, uintptr(s), uintptr(backlog), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_listen_trampoline()
+var libc_listen_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_listen listen "/usr/lib/libSystem.B.dylib"
 
@@ -1509,14 +1509,14 @@ func Mkdir(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall_syscall(libc_mkdir_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_mkdir_trampoline()
+var libc_mkdir_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_mkdir mkdir "/usr/lib/libSystem.B.dylib"
 
@@ -1528,14 +1528,14 @@ func Mkdirat(dirfd int, path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_mkdirat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
+	_, _, e1 := syscall_syscall(libc_mkdirat_trampoline_addr, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_mkdirat_trampoline()
+var libc_mkdirat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_mkdirat mkdirat "/usr/lib/libSystem.B.dylib"
 
@@ -1547,14 +1547,14 @@ func Mkfifo(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall_syscall(libc_mkfifo_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_mkfifo_trampoline()
+var libc_mkfifo_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_mkfifo mkfifo "/usr/lib/libSystem.B.dylib"
 
@@ -1566,14 +1566,14 @@ func Mknod(path string, mode uint32, dev int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
+	_, _, e1 := syscall_syscall(libc_mknod_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_mknod_trampoline()
+var libc_mknod_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_mknod mknod "/usr/lib/libSystem.B.dylib"
 
@@ -1585,7 +1585,7 @@ func Open(path string, mode int, perm uint32) (fd int, err error) {
 	if err != nil {
 		return
 	}
-	r0, _, e1 := syscall_syscall(funcPC(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
+	r0, _, e1 := syscall_syscall(libc_open_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1593,7 +1593,7 @@ func Open(path string, mode int, perm uint32) (fd int, err error) {
 	return
 }
 
-func libc_open_trampoline()
+var libc_open_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_open open "/usr/lib/libSystem.B.dylib"
 
@@ -1605,7 +1605,7 @@ func Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error) {
 	if err != nil {
 		return
 	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_openat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0)
+	r0, _, e1 := syscall_syscall6(libc_openat_trampoline_addr, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0)
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1613,7 +1613,7 @@ func Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error) {
 	return
 }
 
-func libc_openat_trampoline()
+var libc_openat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_openat openat "/usr/lib/libSystem.B.dylib"
 
@@ -1625,7 +1625,7 @@ func Pathconf(path string, name int) (val int, err error) {
 	if err != nil {
 		return
 	}
-	r0, _, e1 := syscall_syscall(funcPC(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
+	r0, _, e1 := syscall_syscall(libc_pathconf_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1633,7 +1633,7 @@ func Pathconf(path string, name int) (val int, err error) {
 	return
 }
 
-func libc_pathconf_trampoline()
+var libc_pathconf_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_pathconf pathconf "/usr/lib/libSystem.B.dylib"
 
@@ -1646,7 +1646,7 @@ func Pread(fd int, p []byte, offset int64) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_pread_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
+	r0, _, e1 := syscall_syscall6(libc_pread_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1654,7 +1654,7 @@ func Pread(fd int, p []byte, offset int64) (n int, err error) {
 	return
 }
 
-func libc_pread_trampoline()
+var libc_pread_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_pread pread "/usr/lib/libSystem.B.dylib"
 
@@ -1667,7 +1667,7 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_pwrite_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
+	r0, _, e1 := syscall_syscall6(libc_pwrite_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1675,7 +1675,7 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
 	return
 }
 
-func libc_pwrite_trampoline()
+var libc_pwrite_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_pwrite pwrite "/usr/lib/libSystem.B.dylib"
 
@@ -1688,7 +1688,7 @@ func read(fd int, p []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall_syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
+	r0, _, e1 := syscall_syscall(libc_read_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(p)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1696,7 +1696,7 @@ func read(fd int, p []byte) (n int, err error) {
 	return
 }
 
-func libc_read_trampoline()
+var libc_read_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_read read "/usr/lib/libSystem.B.dylib"
 
@@ -1714,7 +1714,7 @@ func Readlink(path string, buf []byte) (n int, err error) {
 	} else {
 		_p1 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall_syscall(funcPC(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
+	r0, _, e1 := syscall_syscall(libc_readlink_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1722,7 +1722,7 @@ func Readlink(path string, buf []byte) (n int, err error) {
 	return
 }
 
-func libc_readlink_trampoline()
+var libc_readlink_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_readlink readlink "/usr/lib/libSystem.B.dylib"
 
@@ -1740,7 +1740,7 @@ func Readlinkat(dirfd int, path string, buf []byte) (n int, err error) {
 	} else {
 		_p1 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_readlinkat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
+	r0, _, e1 := syscall_syscall6(libc_readlinkat_trampoline_addr, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1748,7 +1748,7 @@ func Readlinkat(dirfd int, path string, buf []byte) (n int, err error) {
 	return
 }
 
-func libc_readlinkat_trampoline()
+var libc_readlinkat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_readlinkat readlinkat "/usr/lib/libSystem.B.dylib"
 
@@ -1765,14 +1765,14 @@ func Rename(from string, to string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	_, _, e1 := syscall_syscall(libc_rename_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_rename_trampoline()
+var libc_rename_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_rename rename "/usr/lib/libSystem.B.dylib"
 
@@ -1789,14 +1789,14 @@ func Renameat(fromfd int, from string, tofd int, to string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_renameat_trampoline), uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), 0, 0)
+	_, _, e1 := syscall_syscall6(libc_renameat_trampoline_addr, uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_renameat_trampoline()
+var libc_renameat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_renameat renameat "/usr/lib/libSystem.B.dylib"
 
@@ -1808,14 +1808,14 @@ func Revoke(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall_syscall(libc_revoke_trampoline_addr, uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_revoke_trampoline()
+var libc_revoke_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_revoke revoke "/usr/lib/libSystem.B.dylib"
 
@@ -1827,21 +1827,21 @@ func Rmdir(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall_syscall(libc_rmdir_trampoline_addr, uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_rmdir_trampoline()
+var libc_rmdir_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_rmdir rmdir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_lseek_trampoline), uintptr(fd), uintptr(offset), uintptr(whence))
+	r0, _, e1 := syscall_syscall(libc_lseek_trampoline_addr, uintptr(fd), uintptr(offset), uintptr(whence))
 	newoffset = int64(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1849,14 +1849,14 @@ func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
 	return
 }
 
-func libc_lseek_trampoline()
+var libc_lseek_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_lseek lseek "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error) {
-	r0, _, e1 := syscall_syscall6(funcPC(libc_select_trampoline), uintptr(nfd), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
+	r0, _, e1 := syscall_syscall6(libc_select_trampoline_addr, uintptr(nfd), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1864,49 +1864,49 @@ func Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err
 	return
 }
 
-func libc_select_trampoline()
+var libc_select_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_select select "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setegid(egid int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_setegid_trampoline), uintptr(egid), 0, 0)
+	_, _, e1 := syscall_syscall(libc_setegid_trampoline_addr, uintptr(egid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setegid_trampoline()
+var libc_setegid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setegid setegid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Seteuid(euid int) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_seteuid_trampoline), uintptr(euid), 0, 0)
+	_, _, e1 := syscall_rawSyscall(libc_seteuid_trampoline_addr, uintptr(euid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_seteuid_trampoline()
+var libc_seteuid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_seteuid seteuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setgid(gid int) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setgid_trampoline), uintptr(gid), 0, 0)
+	_, _, e1 := syscall_rawSyscall(libc_setgid_trampoline_addr, uintptr(gid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setgid_trampoline()
+var libc_setgid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setgid setgid "/usr/lib/libSystem.B.dylib"
 
@@ -1918,105 +1918,105 @@ func Setlogin(name string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall_syscall(libc_setlogin_trampoline_addr, uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setlogin_trampoline()
+var libc_setlogin_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setlogin setlogin "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setpgid(pid int, pgid int) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setpgid_trampoline), uintptr(pid), uintptr(pgid), 0)
+	_, _, e1 := syscall_rawSyscall(libc_setpgid_trampoline_addr, uintptr(pid), uintptr(pgid), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setpgid_trampoline()
+var libc_setpgid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setpgid setpgid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setpriority(which int, who int, prio int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_setpriority_trampoline), uintptr(which), uintptr(who), uintptr(prio))
+	_, _, e1 := syscall_syscall(libc_setpriority_trampoline_addr, uintptr(which), uintptr(who), uintptr(prio))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setpriority_trampoline()
+var libc_setpriority_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setpriority setpriority "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setprivexec(flag int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_setprivexec_trampoline), uintptr(flag), 0, 0)
+	_, _, e1 := syscall_syscall(libc_setprivexec_trampoline_addr, uintptr(flag), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setprivexec_trampoline()
+var libc_setprivexec_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setprivexec setprivexec "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setregid(rgid int, egid int) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setregid_trampoline), uintptr(rgid), uintptr(egid), 0)
+	_, _, e1 := syscall_rawSyscall(libc_setregid_trampoline_addr, uintptr(rgid), uintptr(egid), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setregid_trampoline()
+var libc_setregid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setregid setregid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setreuid(ruid int, euid int) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setreuid_trampoline), uintptr(ruid), uintptr(euid), 0)
+	_, _, e1 := syscall_rawSyscall(libc_setreuid_trampoline_addr, uintptr(ruid), uintptr(euid), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setreuid_trampoline()
+var libc_setreuid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setreuid setreuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setrlimit(which int, lim *Rlimit) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
+	_, _, e1 := syscall_rawSyscall(libc_setrlimit_trampoline_addr, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setrlimit_trampoline()
+var libc_setrlimit_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setrlimit setrlimit "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setsid() (pid int, err error) {
-	r0, _, e1 := syscall_rawSyscall(funcPC(libc_setsid_trampoline), 0, 0, 0)
+	r0, _, e1 := syscall_rawSyscall(libc_setsid_trampoline_addr, 0, 0, 0)
 	pid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -2024,35 +2024,35 @@ func Setsid() (pid int, err error) {
 	return
 }
 
-func libc_setsid_trampoline()
+var libc_setsid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setsid setsid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Settimeofday(tp *Timeval) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
+	_, _, e1 := syscall_rawSyscall(libc_settimeofday_trampoline_addr, uintptr(unsafe.Pointer(tp)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_settimeofday_trampoline()
+var libc_settimeofday_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_settimeofday settimeofday "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setuid(uid int) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setuid_trampoline), uintptr(uid), 0, 0)
+	_, _, e1 := syscall_rawSyscall(libc_setuid_trampoline_addr, uintptr(uid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setuid_trampoline()
+var libc_setuid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setuid setuid "/usr/lib/libSystem.B.dylib"
 
@@ -2069,14 +2069,14 @@ func Symlink(path string, link string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	_, _, e1 := syscall_syscall(libc_symlink_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_symlink_trampoline()
+var libc_symlink_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_symlink symlink "/usr/lib/libSystem.B.dylib"
 
@@ -2093,28 +2093,28 @@ func Symlinkat(oldpath string, newdirfd int, newpath string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_symlinkat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
+	_, _, e1 := syscall_syscall(libc_symlinkat_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_symlinkat_trampoline()
+var libc_symlinkat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_symlinkat symlinkat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Sync() (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_sync_trampoline), 0, 0, 0)
+	_, _, e1 := syscall_syscall(libc_sync_trampoline_addr, 0, 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_sync_trampoline()
+var libc_sync_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_sync sync "/usr/lib/libSystem.B.dylib"
 
@@ -2126,26 +2126,26 @@ func Truncate(path string, length int64) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
+	_, _, e1 := syscall_syscall(libc_truncate_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_truncate_trampoline()
+var libc_truncate_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_truncate truncate "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Umask(newmask int) (oldmask int) {
-	r0, _, _ := syscall_syscall(funcPC(libc_umask_trampoline), uintptr(newmask), 0, 0)
+	r0, _, _ := syscall_syscall(libc_umask_trampoline_addr, uintptr(newmask), 0, 0)
 	oldmask = int(r0)
 	return
 }
 
-func libc_umask_trampoline()
+var libc_umask_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_umask umask "/usr/lib/libSystem.B.dylib"
 
@@ -2157,14 +2157,14 @@ func Undelete(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_undelete_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall_syscall(libc_undelete_trampoline_addr, uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_undelete_trampoline()
+var libc_undelete_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_undelete undelete "/usr/lib/libSystem.B.dylib"
 
@@ -2176,14 +2176,14 @@ func Unlink(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall_syscall(libc_unlink_trampoline_addr, uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_unlink_trampoline()
+var libc_unlink_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_unlink unlink "/usr/lib/libSystem.B.dylib"
 
@@ -2195,14 +2195,14 @@ func Unlinkat(dirfd int, path string, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_unlinkat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
+	_, _, e1 := syscall_syscall(libc_unlinkat_trampoline_addr, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_unlinkat_trampoline()
+var libc_unlinkat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_unlinkat unlinkat "/usr/lib/libSystem.B.dylib"
 
@@ -2214,14 +2214,14 @@ func Unmount(path string, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
+	_, _, e1 := syscall_syscall(libc_unmount_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_unmount_trampoline()
+var libc_unmount_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_unmount unmount "/usr/lib/libSystem.B.dylib"
 
@@ -2234,7 +2234,7 @@ func write(fd int, p []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall_syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
+	r0, _, e1 := syscall_syscall(libc_write_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(p)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -2242,14 +2242,14 @@ func write(fd int, p []byte) (n int, err error) {
 	return
 }
 
-func libc_write_trampoline()
+var libc_write_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_write write "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
-	r0, _, e1 := syscall_syscall6(funcPC(libc_mmap_trampoline), uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
+	r0, _, e1 := syscall_syscall6(libc_mmap_trampoline_addr, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
 	ret = uintptr(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -2257,28 +2257,28 @@ func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (
 	return
 }
 
-func libc_mmap_trampoline()
+var libc_mmap_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_mmap mmap "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func munmap(addr uintptr, length uintptr) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_munmap_trampoline), uintptr(addr), uintptr(length), 0)
+	_, _, e1 := syscall_syscall(libc_munmap_trampoline_addr, uintptr(addr), uintptr(length), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_munmap_trampoline()
+var libc_munmap_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_munmap munmap "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
+	r0, _, e1 := syscall_syscall(libc_read_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -2289,7 +2289,7 @@ func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
+	r0, _, e1 := syscall_syscall(libc_write_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -2300,14 +2300,14 @@ func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fstat(fd int, stat *Stat_t) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fstat64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall_syscall(libc_fstat64_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fstat64_trampoline()
+var libc_fstat64_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fstat64 fstat64 "/usr/lib/libSystem.B.dylib"
 
@@ -2319,35 +2319,35 @@ func Fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_fstatat64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
+	_, _, e1 := syscall_syscall6(libc_fstatat64_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fstatat64_trampoline()
+var libc_fstatat64_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fstatat64 fstatat64 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fstatfs(fd int, stat *Statfs_t) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fstatfs64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall_syscall(libc_fstatfs64_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fstatfs64_trampoline()
+var libc_fstatfs64_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fstatfs64 fstatfs64 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_getfsstat64_trampoline), uintptr(buf), uintptr(size), uintptr(flags))
+	r0, _, e1 := syscall_syscall(libc_getfsstat64_trampoline_addr, uintptr(buf), uintptr(size), uintptr(flags))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -2355,7 +2355,7 @@ func getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) {
 	return
 }
 
-func libc_getfsstat64_trampoline()
+var libc_getfsstat64_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getfsstat64 getfsstat64 "/usr/lib/libSystem.B.dylib"
 
@@ -2367,28 +2367,28 @@ func Lstat(path string, stat *Stat_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_lstat64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall_syscall(libc_lstat64_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_lstat64_trampoline()
+var libc_lstat64_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_lstat64 lstat64 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func ptrace1(request int, pid int, addr uintptr, data uintptr) (err error) {
-	_, _, e1 := syscall_syscall6(funcPC(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
+	_, _, e1 := syscall_syscall6(libc_ptrace_trampoline_addr, uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_ptrace_trampoline()
+var libc_ptrace_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_ptrace ptrace "/usr/lib/libSystem.B.dylib"
 
@@ -2400,14 +2400,14 @@ func Stat(path string, stat *Stat_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_stat64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall_syscall(libc_stat64_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_stat64_trampoline()
+var libc_stat64_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_stat64 stat64 "/usr/lib/libSystem.B.dylib"
 
@@ -2419,13 +2419,13 @@ func Statfs(path string, stat *Statfs_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_statfs64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall_syscall(libc_statfs64_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_statfs64_trampoline()
+var libc_statfs64_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_statfs64 statfs64 "/usr/lib/libSystem.B.dylib"
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s
index b8f316e676..bc169c2ab9 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s
@@ -5,287 +5,855 @@
 // +build go1.12
 
 #include "textflag.h"
-TEXT ·libc_getgroups_trampoline(SB),NOSPLIT,$0-0
+
+TEXT libc_getgroups_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getgroups(SB)
-TEXT ·libc_setgroups_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getgroups_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getgroups_trampoline_addr(SB)/8, $libc_getgroups_trampoline<>(SB)
+
+TEXT libc_setgroups_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setgroups(SB)
-TEXT ·libc_wait4_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setgroups_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setgroups_trampoline_addr(SB)/8, $libc_setgroups_trampoline<>(SB)
+
+TEXT libc_wait4_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_wait4(SB)
-TEXT ·libc_accept_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_wait4_trampoline_addr(SB), RODATA, $8
+DATA	·libc_wait4_trampoline_addr(SB)/8, $libc_wait4_trampoline<>(SB)
+
+TEXT libc_accept_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_accept(SB)
-TEXT ·libc_bind_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_accept_trampoline_addr(SB), RODATA, $8
+DATA	·libc_accept_trampoline_addr(SB)/8, $libc_accept_trampoline<>(SB)
+
+TEXT libc_bind_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_bind(SB)
-TEXT ·libc_connect_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_bind_trampoline_addr(SB), RODATA, $8
+DATA	·libc_bind_trampoline_addr(SB)/8, $libc_bind_trampoline<>(SB)
+
+TEXT libc_connect_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_connect(SB)
-TEXT ·libc_socket_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_connect_trampoline_addr(SB), RODATA, $8
+DATA	·libc_connect_trampoline_addr(SB)/8, $libc_connect_trampoline<>(SB)
+
+TEXT libc_socket_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_socket(SB)
-TEXT ·libc_getsockopt_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_socket_trampoline_addr(SB), RODATA, $8
+DATA	·libc_socket_trampoline_addr(SB)/8, $libc_socket_trampoline<>(SB)
+
+TEXT libc_getsockopt_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getsockopt(SB)
-TEXT ·libc_setsockopt_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getsockopt_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getsockopt_trampoline_addr(SB)/8, $libc_getsockopt_trampoline<>(SB)
+
+TEXT libc_setsockopt_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setsockopt(SB)
-TEXT ·libc_getpeername_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setsockopt_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setsockopt_trampoline_addr(SB)/8, $libc_setsockopt_trampoline<>(SB)
+
+TEXT libc_getpeername_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getpeername(SB)
-TEXT ·libc_getsockname_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getpeername_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getpeername_trampoline_addr(SB)/8, $libc_getpeername_trampoline<>(SB)
+
+TEXT libc_getsockname_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getsockname(SB)
-TEXT ·libc_shutdown_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getsockname_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getsockname_trampoline_addr(SB)/8, $libc_getsockname_trampoline<>(SB)
+
+TEXT libc_shutdown_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_shutdown(SB)
-TEXT ·libc_socketpair_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_shutdown_trampoline_addr(SB), RODATA, $8
+DATA	·libc_shutdown_trampoline_addr(SB)/8, $libc_shutdown_trampoline<>(SB)
+
+TEXT libc_socketpair_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_socketpair(SB)
-TEXT ·libc_recvfrom_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_socketpair_trampoline_addr(SB), RODATA, $8
+DATA	·libc_socketpair_trampoline_addr(SB)/8, $libc_socketpair_trampoline<>(SB)
+
+TEXT libc_recvfrom_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_recvfrom(SB)
-TEXT ·libc_sendto_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_recvfrom_trampoline_addr(SB), RODATA, $8
+DATA	·libc_recvfrom_trampoline_addr(SB)/8, $libc_recvfrom_trampoline<>(SB)
+
+TEXT libc_sendto_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_sendto(SB)
-TEXT ·libc_recvmsg_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_sendto_trampoline_addr(SB), RODATA, $8
+DATA	·libc_sendto_trampoline_addr(SB)/8, $libc_sendto_trampoline<>(SB)
+
+TEXT libc_recvmsg_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_recvmsg(SB)
-TEXT ·libc_sendmsg_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_recvmsg_trampoline_addr(SB), RODATA, $8
+DATA	·libc_recvmsg_trampoline_addr(SB)/8, $libc_recvmsg_trampoline<>(SB)
+
+TEXT libc_sendmsg_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_sendmsg(SB)
-TEXT ·libc_kevent_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_sendmsg_trampoline_addr(SB), RODATA, $8
+DATA	·libc_sendmsg_trampoline_addr(SB)/8, $libc_sendmsg_trampoline<>(SB)
+
+TEXT libc_kevent_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_kevent(SB)
-TEXT ·libc_utimes_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_kevent_trampoline_addr(SB), RODATA, $8
+DATA	·libc_kevent_trampoline_addr(SB)/8, $libc_kevent_trampoline<>(SB)
+
+TEXT libc_utimes_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_utimes(SB)
-TEXT ·libc_futimes_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_utimes_trampoline_addr(SB), RODATA, $8
+DATA	·libc_utimes_trampoline_addr(SB)/8, $libc_utimes_trampoline<>(SB)
+
+TEXT libc_futimes_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_futimes(SB)
-TEXT ·libc_poll_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_futimes_trampoline_addr(SB), RODATA, $8
+DATA	·libc_futimes_trampoline_addr(SB)/8, $libc_futimes_trampoline<>(SB)
+
+TEXT libc_poll_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_poll(SB)
-TEXT ·libc_madvise_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_poll_trampoline_addr(SB), RODATA, $8
+DATA	·libc_poll_trampoline_addr(SB)/8, $libc_poll_trampoline<>(SB)
+
+TEXT libc_madvise_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_madvise(SB)
-TEXT ·libc_mlock_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_madvise_trampoline_addr(SB), RODATA, $8
+DATA	·libc_madvise_trampoline_addr(SB)/8, $libc_madvise_trampoline<>(SB)
+
+TEXT libc_mlock_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_mlock(SB)
-TEXT ·libc_mlockall_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_mlock_trampoline_addr(SB), RODATA, $8
+DATA	·libc_mlock_trampoline_addr(SB)/8, $libc_mlock_trampoline<>(SB)
+
+TEXT libc_mlockall_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_mlockall(SB)
-TEXT ·libc_mprotect_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_mlockall_trampoline_addr(SB), RODATA, $8
+DATA	·libc_mlockall_trampoline_addr(SB)/8, $libc_mlockall_trampoline<>(SB)
+
+TEXT libc_mprotect_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_mprotect(SB)
-TEXT ·libc_msync_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_mprotect_trampoline_addr(SB), RODATA, $8
+DATA	·libc_mprotect_trampoline_addr(SB)/8, $libc_mprotect_trampoline<>(SB)
+
+TEXT libc_msync_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_msync(SB)
-TEXT ·libc_munlock_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_msync_trampoline_addr(SB), RODATA, $8
+DATA	·libc_msync_trampoline_addr(SB)/8, $libc_msync_trampoline<>(SB)
+
+TEXT libc_munlock_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_munlock(SB)
-TEXT ·libc_munlockall_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_munlock_trampoline_addr(SB), RODATA, $8
+DATA	·libc_munlock_trampoline_addr(SB)/8, $libc_munlock_trampoline<>(SB)
+
+TEXT libc_munlockall_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_munlockall(SB)
-TEXT ·libc_pipe_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_munlockall_trampoline_addr(SB), RODATA, $8
+DATA	·libc_munlockall_trampoline_addr(SB)/8, $libc_munlockall_trampoline<>(SB)
+
+TEXT libc_pipe_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_pipe(SB)
-TEXT ·libc_getxattr_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_pipe_trampoline_addr(SB), RODATA, $8
+DATA	·libc_pipe_trampoline_addr(SB)/8, $libc_pipe_trampoline<>(SB)
+
+TEXT libc_getxattr_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getxattr(SB)
-TEXT ·libc_fgetxattr_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getxattr_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getxattr_trampoline_addr(SB)/8, $libc_getxattr_trampoline<>(SB)
+
+TEXT libc_fgetxattr_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fgetxattr(SB)
-TEXT ·libc_setxattr_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fgetxattr_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fgetxattr_trampoline_addr(SB)/8, $libc_fgetxattr_trampoline<>(SB)
+
+TEXT libc_setxattr_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setxattr(SB)
-TEXT ·libc_fsetxattr_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setxattr_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setxattr_trampoline_addr(SB)/8, $libc_setxattr_trampoline<>(SB)
+
+TEXT libc_fsetxattr_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fsetxattr(SB)
-TEXT ·libc_removexattr_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fsetxattr_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fsetxattr_trampoline_addr(SB)/8, $libc_fsetxattr_trampoline<>(SB)
+
+TEXT libc_removexattr_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_removexattr(SB)
-TEXT ·libc_fremovexattr_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_removexattr_trampoline_addr(SB), RODATA, $8
+DATA	·libc_removexattr_trampoline_addr(SB)/8, $libc_removexattr_trampoline<>(SB)
+
+TEXT libc_fremovexattr_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fremovexattr(SB)
-TEXT ·libc_listxattr_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fremovexattr_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fremovexattr_trampoline_addr(SB)/8, $libc_fremovexattr_trampoline<>(SB)
+
+TEXT libc_listxattr_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_listxattr(SB)
-TEXT ·libc_flistxattr_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_listxattr_trampoline_addr(SB), RODATA, $8
+DATA	·libc_listxattr_trampoline_addr(SB)/8, $libc_listxattr_trampoline<>(SB)
+
+TEXT libc_flistxattr_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_flistxattr(SB)
-TEXT ·libc_setattrlist_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_flistxattr_trampoline_addr(SB), RODATA, $8
+DATA	·libc_flistxattr_trampoline_addr(SB)/8, $libc_flistxattr_trampoline<>(SB)
+
+TEXT libc_setattrlist_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setattrlist(SB)
-TEXT ·libc_fcntl_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setattrlist_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setattrlist_trampoline_addr(SB)/8, $libc_setattrlist_trampoline<>(SB)
+
+TEXT libc_fcntl_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fcntl(SB)
-TEXT ·libc_kill_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fcntl_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fcntl_trampoline_addr(SB)/8, $libc_fcntl_trampoline<>(SB)
+
+TEXT libc_kill_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_kill(SB)
-TEXT ·libc_ioctl_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_kill_trampoline_addr(SB), RODATA, $8
+DATA	·libc_kill_trampoline_addr(SB)/8, $libc_kill_trampoline<>(SB)
+
+TEXT libc_ioctl_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_ioctl(SB)
-TEXT ·libc_sysctl_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_ioctl_trampoline_addr(SB), RODATA, $8
+DATA	·libc_ioctl_trampoline_addr(SB)/8, $libc_ioctl_trampoline<>(SB)
+
+TEXT libc_sysctl_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_sysctl(SB)
-TEXT ·libc_sendfile_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_sysctl_trampoline_addr(SB), RODATA, $8
+DATA	·libc_sysctl_trampoline_addr(SB)/8, $libc_sysctl_trampoline<>(SB)
+
+TEXT libc_sendfile_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_sendfile(SB)
-TEXT ·libc_access_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_sendfile_trampoline_addr(SB), RODATA, $8
+DATA	·libc_sendfile_trampoline_addr(SB)/8, $libc_sendfile_trampoline<>(SB)
+
+TEXT libc_access_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_access(SB)
-TEXT ·libc_adjtime_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_access_trampoline_addr(SB), RODATA, $8
+DATA	·libc_access_trampoline_addr(SB)/8, $libc_access_trampoline<>(SB)
+
+TEXT libc_adjtime_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_adjtime(SB)
-TEXT ·libc_chdir_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_adjtime_trampoline_addr(SB), RODATA, $8
+DATA	·libc_adjtime_trampoline_addr(SB)/8, $libc_adjtime_trampoline<>(SB)
+
+TEXT libc_chdir_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_chdir(SB)
-TEXT ·libc_chflags_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_chdir_trampoline_addr(SB), RODATA, $8
+DATA	·libc_chdir_trampoline_addr(SB)/8, $libc_chdir_trampoline<>(SB)
+
+TEXT libc_chflags_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_chflags(SB)
-TEXT ·libc_chmod_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_chflags_trampoline_addr(SB), RODATA, $8
+DATA	·libc_chflags_trampoline_addr(SB)/8, $libc_chflags_trampoline<>(SB)
+
+TEXT libc_chmod_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_chmod(SB)
-TEXT ·libc_chown_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_chmod_trampoline_addr(SB), RODATA, $8
+DATA	·libc_chmod_trampoline_addr(SB)/8, $libc_chmod_trampoline<>(SB)
+
+TEXT libc_chown_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_chown(SB)
-TEXT ·libc_chroot_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_chown_trampoline_addr(SB), RODATA, $8
+DATA	·libc_chown_trampoline_addr(SB)/8, $libc_chown_trampoline<>(SB)
+
+TEXT libc_chroot_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_chroot(SB)
-TEXT ·libc_clock_gettime_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_chroot_trampoline_addr(SB), RODATA, $8
+DATA	·libc_chroot_trampoline_addr(SB)/8, $libc_chroot_trampoline<>(SB)
+
+TEXT libc_clock_gettime_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_clock_gettime(SB)
-TEXT ·libc_close_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_clock_gettime_trampoline_addr(SB), RODATA, $8
+DATA	·libc_clock_gettime_trampoline_addr(SB)/8, $libc_clock_gettime_trampoline<>(SB)
+
+TEXT libc_close_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_close(SB)
-TEXT ·libc_clonefile_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_close_trampoline_addr(SB), RODATA, $8
+DATA	·libc_close_trampoline_addr(SB)/8, $libc_close_trampoline<>(SB)
+
+TEXT libc_clonefile_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_clonefile(SB)
-TEXT ·libc_clonefileat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_clonefile_trampoline_addr(SB), RODATA, $8
+DATA	·libc_clonefile_trampoline_addr(SB)/8, $libc_clonefile_trampoline<>(SB)
+
+TEXT libc_clonefileat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_clonefileat(SB)
-TEXT ·libc_dup_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_clonefileat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_clonefileat_trampoline_addr(SB)/8, $libc_clonefileat_trampoline<>(SB)
+
+TEXT libc_dup_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_dup(SB)
-TEXT ·libc_dup2_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_dup_trampoline_addr(SB), RODATA, $8
+DATA	·libc_dup_trampoline_addr(SB)/8, $libc_dup_trampoline<>(SB)
+
+TEXT libc_dup2_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_dup2(SB)
-TEXT ·libc_exchangedata_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_dup2_trampoline_addr(SB), RODATA, $8
+DATA	·libc_dup2_trampoline_addr(SB)/8, $libc_dup2_trampoline<>(SB)
+
+TEXT libc_exchangedata_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_exchangedata(SB)
-TEXT ·libc_exit_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_exchangedata_trampoline_addr(SB), RODATA, $8
+DATA	·libc_exchangedata_trampoline_addr(SB)/8, $libc_exchangedata_trampoline<>(SB)
+
+TEXT libc_exit_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_exit(SB)
-TEXT ·libc_faccessat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_exit_trampoline_addr(SB), RODATA, $8
+DATA	·libc_exit_trampoline_addr(SB)/8, $libc_exit_trampoline<>(SB)
+
+TEXT libc_faccessat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_faccessat(SB)
-TEXT ·libc_fchdir_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_faccessat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_faccessat_trampoline_addr(SB)/8, $libc_faccessat_trampoline<>(SB)
+
+TEXT libc_fchdir_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fchdir(SB)
-TEXT ·libc_fchflags_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fchdir_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fchdir_trampoline_addr(SB)/8, $libc_fchdir_trampoline<>(SB)
+
+TEXT libc_fchflags_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fchflags(SB)
-TEXT ·libc_fchmod_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fchflags_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fchflags_trampoline_addr(SB)/8, $libc_fchflags_trampoline<>(SB)
+
+TEXT libc_fchmod_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fchmod(SB)
-TEXT ·libc_fchmodat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fchmod_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fchmod_trampoline_addr(SB)/8, $libc_fchmod_trampoline<>(SB)
+
+TEXT libc_fchmodat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fchmodat(SB)
-TEXT ·libc_fchown_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fchmodat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fchmodat_trampoline_addr(SB)/8, $libc_fchmodat_trampoline<>(SB)
+
+TEXT libc_fchown_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fchown(SB)
-TEXT ·libc_fchownat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fchown_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fchown_trampoline_addr(SB)/8, $libc_fchown_trampoline<>(SB)
+
+TEXT libc_fchownat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fchownat(SB)
-TEXT ·libc_fclonefileat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fchownat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fchownat_trampoline_addr(SB)/8, $libc_fchownat_trampoline<>(SB)
+
+TEXT libc_fclonefileat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fclonefileat(SB)
-TEXT ·libc_flock_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fclonefileat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fclonefileat_trampoline_addr(SB)/8, $libc_fclonefileat_trampoline<>(SB)
+
+TEXT libc_flock_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_flock(SB)
-TEXT ·libc_fpathconf_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_flock_trampoline_addr(SB), RODATA, $8
+DATA	·libc_flock_trampoline_addr(SB)/8, $libc_flock_trampoline<>(SB)
+
+TEXT libc_fpathconf_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fpathconf(SB)
-TEXT ·libc_fsync_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fpathconf_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fpathconf_trampoline_addr(SB)/8, $libc_fpathconf_trampoline<>(SB)
+
+TEXT libc_fsync_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fsync(SB)
-TEXT ·libc_ftruncate_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fsync_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fsync_trampoline_addr(SB)/8, $libc_fsync_trampoline<>(SB)
+
+TEXT libc_ftruncate_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_ftruncate(SB)
-TEXT ·libc_getcwd_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_ftruncate_trampoline_addr(SB), RODATA, $8
+DATA	·libc_ftruncate_trampoline_addr(SB)/8, $libc_ftruncate_trampoline<>(SB)
+
+TEXT libc_getcwd_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getcwd(SB)
-TEXT ·libc_getdtablesize_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getcwd_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getcwd_trampoline_addr(SB)/8, $libc_getcwd_trampoline<>(SB)
+
+TEXT libc_getdtablesize_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getdtablesize(SB)
-TEXT ·libc_getegid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getdtablesize_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getdtablesize_trampoline_addr(SB)/8, $libc_getdtablesize_trampoline<>(SB)
+
+TEXT libc_getegid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getegid(SB)
-TEXT ·libc_geteuid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getegid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getegid_trampoline_addr(SB)/8, $libc_getegid_trampoline<>(SB)
+
+TEXT libc_geteuid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_geteuid(SB)
-TEXT ·libc_getgid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_geteuid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_geteuid_trampoline_addr(SB)/8, $libc_geteuid_trampoline<>(SB)
+
+TEXT libc_getgid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getgid(SB)
-TEXT ·libc_getpgid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getgid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getgid_trampoline_addr(SB)/8, $libc_getgid_trampoline<>(SB)
+
+TEXT libc_getpgid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getpgid(SB)
-TEXT ·libc_getpgrp_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getpgid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getpgid_trampoline_addr(SB)/8, $libc_getpgid_trampoline<>(SB)
+
+TEXT libc_getpgrp_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getpgrp(SB)
-TEXT ·libc_getpid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getpgrp_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getpgrp_trampoline_addr(SB)/8, $libc_getpgrp_trampoline<>(SB)
+
+TEXT libc_getpid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getpid(SB)
-TEXT ·libc_getppid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getpid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getpid_trampoline_addr(SB)/8, $libc_getpid_trampoline<>(SB)
+
+TEXT libc_getppid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getppid(SB)
-TEXT ·libc_getpriority_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getppid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getppid_trampoline_addr(SB)/8, $libc_getppid_trampoline<>(SB)
+
+TEXT libc_getpriority_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getpriority(SB)
-TEXT ·libc_getrlimit_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getpriority_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getpriority_trampoline_addr(SB)/8, $libc_getpriority_trampoline<>(SB)
+
+TEXT libc_getrlimit_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getrlimit(SB)
-TEXT ·libc_getrusage_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getrlimit_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getrlimit_trampoline_addr(SB)/8, $libc_getrlimit_trampoline<>(SB)
+
+TEXT libc_getrusage_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getrusage(SB)
-TEXT ·libc_getsid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getrusage_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getrusage_trampoline_addr(SB)/8, $libc_getrusage_trampoline<>(SB)
+
+TEXT libc_getsid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getsid(SB)
-TEXT ·libc_gettimeofday_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getsid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getsid_trampoline_addr(SB)/8, $libc_getsid_trampoline<>(SB)
+
+TEXT libc_gettimeofday_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_gettimeofday(SB)
-TEXT ·libc_getuid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_gettimeofday_trampoline_addr(SB), RODATA, $8
+DATA	·libc_gettimeofday_trampoline_addr(SB)/8, $libc_gettimeofday_trampoline<>(SB)
+
+TEXT libc_getuid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getuid(SB)
-TEXT ·libc_issetugid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getuid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getuid_trampoline_addr(SB)/8, $libc_getuid_trampoline<>(SB)
+
+TEXT libc_issetugid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_issetugid(SB)
-TEXT ·libc_kqueue_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_issetugid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_issetugid_trampoline_addr(SB)/8, $libc_issetugid_trampoline<>(SB)
+
+TEXT libc_kqueue_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_kqueue(SB)
-TEXT ·libc_lchown_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_kqueue_trampoline_addr(SB), RODATA, $8
+DATA	·libc_kqueue_trampoline_addr(SB)/8, $libc_kqueue_trampoline<>(SB)
+
+TEXT libc_lchown_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_lchown(SB)
-TEXT ·libc_link_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_lchown_trampoline_addr(SB), RODATA, $8
+DATA	·libc_lchown_trampoline_addr(SB)/8, $libc_lchown_trampoline<>(SB)
+
+TEXT libc_link_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_link(SB)
-TEXT ·libc_linkat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_link_trampoline_addr(SB), RODATA, $8
+DATA	·libc_link_trampoline_addr(SB)/8, $libc_link_trampoline<>(SB)
+
+TEXT libc_linkat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_linkat(SB)
-TEXT ·libc_listen_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_linkat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_linkat_trampoline_addr(SB)/8, $libc_linkat_trampoline<>(SB)
+
+TEXT libc_listen_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_listen(SB)
-TEXT ·libc_mkdir_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_listen_trampoline_addr(SB), RODATA, $8
+DATA	·libc_listen_trampoline_addr(SB)/8, $libc_listen_trampoline<>(SB)
+
+TEXT libc_mkdir_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_mkdir(SB)
-TEXT ·libc_mkdirat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_mkdir_trampoline_addr(SB), RODATA, $8
+DATA	·libc_mkdir_trampoline_addr(SB)/8, $libc_mkdir_trampoline<>(SB)
+
+TEXT libc_mkdirat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_mkdirat(SB)
-TEXT ·libc_mkfifo_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_mkdirat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_mkdirat_trampoline_addr(SB)/8, $libc_mkdirat_trampoline<>(SB)
+
+TEXT libc_mkfifo_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_mkfifo(SB)
-TEXT ·libc_mknod_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_mkfifo_trampoline_addr(SB), RODATA, $8
+DATA	·libc_mkfifo_trampoline_addr(SB)/8, $libc_mkfifo_trampoline<>(SB)
+
+TEXT libc_mknod_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_mknod(SB)
-TEXT ·libc_open_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_mknod_trampoline_addr(SB), RODATA, $8
+DATA	·libc_mknod_trampoline_addr(SB)/8, $libc_mknod_trampoline<>(SB)
+
+TEXT libc_open_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_open(SB)
-TEXT ·libc_openat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_open_trampoline_addr(SB), RODATA, $8
+DATA	·libc_open_trampoline_addr(SB)/8, $libc_open_trampoline<>(SB)
+
+TEXT libc_openat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_openat(SB)
-TEXT ·libc_pathconf_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_openat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_openat_trampoline_addr(SB)/8, $libc_openat_trampoline<>(SB)
+
+TEXT libc_pathconf_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_pathconf(SB)
-TEXT ·libc_pread_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_pathconf_trampoline_addr(SB), RODATA, $8
+DATA	·libc_pathconf_trampoline_addr(SB)/8, $libc_pathconf_trampoline<>(SB)
+
+TEXT libc_pread_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_pread(SB)
-TEXT ·libc_pwrite_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_pread_trampoline_addr(SB), RODATA, $8
+DATA	·libc_pread_trampoline_addr(SB)/8, $libc_pread_trampoline<>(SB)
+
+TEXT libc_pwrite_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_pwrite(SB)
-TEXT ·libc_read_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_pwrite_trampoline_addr(SB), RODATA, $8
+DATA	·libc_pwrite_trampoline_addr(SB)/8, $libc_pwrite_trampoline<>(SB)
+
+TEXT libc_read_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_read(SB)
-TEXT ·libc_readlink_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_read_trampoline_addr(SB), RODATA, $8
+DATA	·libc_read_trampoline_addr(SB)/8, $libc_read_trampoline<>(SB)
+
+TEXT libc_readlink_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_readlink(SB)
-TEXT ·libc_readlinkat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_readlink_trampoline_addr(SB), RODATA, $8
+DATA	·libc_readlink_trampoline_addr(SB)/8, $libc_readlink_trampoline<>(SB)
+
+TEXT libc_readlinkat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_readlinkat(SB)
-TEXT ·libc_rename_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_readlinkat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_readlinkat_trampoline_addr(SB)/8, $libc_readlinkat_trampoline<>(SB)
+
+TEXT libc_rename_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_rename(SB)
-TEXT ·libc_renameat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_rename_trampoline_addr(SB), RODATA, $8
+DATA	·libc_rename_trampoline_addr(SB)/8, $libc_rename_trampoline<>(SB)
+
+TEXT libc_renameat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_renameat(SB)
-TEXT ·libc_revoke_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_renameat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_renameat_trampoline_addr(SB)/8, $libc_renameat_trampoline<>(SB)
+
+TEXT libc_revoke_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_revoke(SB)
-TEXT ·libc_rmdir_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_revoke_trampoline_addr(SB), RODATA, $8
+DATA	·libc_revoke_trampoline_addr(SB)/8, $libc_revoke_trampoline<>(SB)
+
+TEXT libc_rmdir_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_rmdir(SB)
-TEXT ·libc_lseek_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_rmdir_trampoline_addr(SB), RODATA, $8
+DATA	·libc_rmdir_trampoline_addr(SB)/8, $libc_rmdir_trampoline<>(SB)
+
+TEXT libc_lseek_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_lseek(SB)
-TEXT ·libc_select_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_lseek_trampoline_addr(SB), RODATA, $8
+DATA	·libc_lseek_trampoline_addr(SB)/8, $libc_lseek_trampoline<>(SB)
+
+TEXT libc_select_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_select(SB)
-TEXT ·libc_setegid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_select_trampoline_addr(SB), RODATA, $8
+DATA	·libc_select_trampoline_addr(SB)/8, $libc_select_trampoline<>(SB)
+
+TEXT libc_setegid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setegid(SB)
-TEXT ·libc_seteuid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setegid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setegid_trampoline_addr(SB)/8, $libc_setegid_trampoline<>(SB)
+
+TEXT libc_seteuid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_seteuid(SB)
-TEXT ·libc_setgid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_seteuid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_seteuid_trampoline_addr(SB)/8, $libc_seteuid_trampoline<>(SB)
+
+TEXT libc_setgid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setgid(SB)
-TEXT ·libc_setlogin_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setgid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setgid_trampoline_addr(SB)/8, $libc_setgid_trampoline<>(SB)
+
+TEXT libc_setlogin_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setlogin(SB)
-TEXT ·libc_setpgid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setlogin_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setlogin_trampoline_addr(SB)/8, $libc_setlogin_trampoline<>(SB)
+
+TEXT libc_setpgid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setpgid(SB)
-TEXT ·libc_setpriority_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setpgid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setpgid_trampoline_addr(SB)/8, $libc_setpgid_trampoline<>(SB)
+
+TEXT libc_setpriority_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setpriority(SB)
-TEXT ·libc_setprivexec_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setpriority_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setpriority_trampoline_addr(SB)/8, $libc_setpriority_trampoline<>(SB)
+
+TEXT libc_setprivexec_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setprivexec(SB)
-TEXT ·libc_setregid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setprivexec_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setprivexec_trampoline_addr(SB)/8, $libc_setprivexec_trampoline<>(SB)
+
+TEXT libc_setregid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setregid(SB)
-TEXT ·libc_setreuid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setregid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setregid_trampoline_addr(SB)/8, $libc_setregid_trampoline<>(SB)
+
+TEXT libc_setreuid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setreuid(SB)
-TEXT ·libc_setrlimit_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setreuid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setreuid_trampoline_addr(SB)/8, $libc_setreuid_trampoline<>(SB)
+
+TEXT libc_setrlimit_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setrlimit(SB)
-TEXT ·libc_setsid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setrlimit_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setrlimit_trampoline_addr(SB)/8, $libc_setrlimit_trampoline<>(SB)
+
+TEXT libc_setsid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setsid(SB)
-TEXT ·libc_settimeofday_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setsid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setsid_trampoline_addr(SB)/8, $libc_setsid_trampoline<>(SB)
+
+TEXT libc_settimeofday_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_settimeofday(SB)
-TEXT ·libc_setuid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_settimeofday_trampoline_addr(SB), RODATA, $8
+DATA	·libc_settimeofday_trampoline_addr(SB)/8, $libc_settimeofday_trampoline<>(SB)
+
+TEXT libc_setuid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setuid(SB)
-TEXT ·libc_symlink_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setuid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setuid_trampoline_addr(SB)/8, $libc_setuid_trampoline<>(SB)
+
+TEXT libc_symlink_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_symlink(SB)
-TEXT ·libc_symlinkat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_symlink_trampoline_addr(SB), RODATA, $8
+DATA	·libc_symlink_trampoline_addr(SB)/8, $libc_symlink_trampoline<>(SB)
+
+TEXT libc_symlinkat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_symlinkat(SB)
-TEXT ·libc_sync_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_symlinkat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_symlinkat_trampoline_addr(SB)/8, $libc_symlinkat_trampoline<>(SB)
+
+TEXT libc_sync_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_sync(SB)
-TEXT ·libc_truncate_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_sync_trampoline_addr(SB), RODATA, $8
+DATA	·libc_sync_trampoline_addr(SB)/8, $libc_sync_trampoline<>(SB)
+
+TEXT libc_truncate_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_truncate(SB)
-TEXT ·libc_umask_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_truncate_trampoline_addr(SB), RODATA, $8
+DATA	·libc_truncate_trampoline_addr(SB)/8, $libc_truncate_trampoline<>(SB)
+
+TEXT libc_umask_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_umask(SB)
-TEXT ·libc_undelete_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_umask_trampoline_addr(SB), RODATA, $8
+DATA	·libc_umask_trampoline_addr(SB)/8, $libc_umask_trampoline<>(SB)
+
+TEXT libc_undelete_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_undelete(SB)
-TEXT ·libc_unlink_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_undelete_trampoline_addr(SB), RODATA, $8
+DATA	·libc_undelete_trampoline_addr(SB)/8, $libc_undelete_trampoline<>(SB)
+
+TEXT libc_unlink_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_unlink(SB)
-TEXT ·libc_unlinkat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_unlink_trampoline_addr(SB), RODATA, $8
+DATA	·libc_unlink_trampoline_addr(SB)/8, $libc_unlink_trampoline<>(SB)
+
+TEXT libc_unlinkat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_unlinkat(SB)
-TEXT ·libc_unmount_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_unlinkat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_unlinkat_trampoline_addr(SB)/8, $libc_unlinkat_trampoline<>(SB)
+
+TEXT libc_unmount_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_unmount(SB)
-TEXT ·libc_write_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_unmount_trampoline_addr(SB), RODATA, $8
+DATA	·libc_unmount_trampoline_addr(SB)/8, $libc_unmount_trampoline<>(SB)
+
+TEXT libc_write_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_write(SB)
-TEXT ·libc_mmap_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_write_trampoline_addr(SB), RODATA, $8
+DATA	·libc_write_trampoline_addr(SB)/8, $libc_write_trampoline<>(SB)
+
+TEXT libc_mmap_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_mmap(SB)
-TEXT ·libc_munmap_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_mmap_trampoline_addr(SB), RODATA, $8
+DATA	·libc_mmap_trampoline_addr(SB)/8, $libc_mmap_trampoline<>(SB)
+
+TEXT libc_munmap_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_munmap(SB)
-TEXT ·libc_fstat64_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_munmap_trampoline_addr(SB), RODATA, $8
+DATA	·libc_munmap_trampoline_addr(SB)/8, $libc_munmap_trampoline<>(SB)
+
+TEXT libc_fstat64_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fstat64(SB)
-TEXT ·libc_fstatat64_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fstat64_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fstat64_trampoline_addr(SB)/8, $libc_fstat64_trampoline<>(SB)
+
+TEXT libc_fstatat64_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fstatat64(SB)
-TEXT ·libc_fstatfs64_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fstatat64_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fstatat64_trampoline_addr(SB)/8, $libc_fstatat64_trampoline<>(SB)
+
+TEXT libc_fstatfs64_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fstatfs64(SB)
-TEXT ·libc_getfsstat64_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fstatfs64_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fstatfs64_trampoline_addr(SB)/8, $libc_fstatfs64_trampoline<>(SB)
+
+TEXT libc_getfsstat64_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getfsstat64(SB)
-TEXT ·libc_lstat64_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getfsstat64_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getfsstat64_trampoline_addr(SB)/8, $libc_getfsstat64_trampoline<>(SB)
+
+TEXT libc_lstat64_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_lstat64(SB)
-TEXT ·libc_ptrace_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_lstat64_trampoline_addr(SB), RODATA, $8
+DATA	·libc_lstat64_trampoline_addr(SB)/8, $libc_lstat64_trampoline<>(SB)
+
+TEXT libc_ptrace_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_ptrace(SB)
-TEXT ·libc_stat64_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_ptrace_trampoline_addr(SB), RODATA, $8
+DATA	·libc_ptrace_trampoline_addr(SB)/8, $libc_ptrace_trampoline<>(SB)
+
+TEXT libc_stat64_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_stat64(SB)
-TEXT ·libc_statfs64_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_stat64_trampoline_addr(SB), RODATA, $8
+DATA	·libc_stat64_trampoline_addr(SB)/8, $libc_stat64_trampoline<>(SB)
+
+TEXT libc_statfs64_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_statfs64(SB)
+
+GLOBL	·libc_statfs64_trampoline_addr(SB), RODATA, $8
+DATA	·libc_statfs64_trampoline_addr(SB)/8, $libc_statfs64_trampoline<>(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.1_13.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.1_13.go
deleted file mode 100644
index ed437f89a9..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.1_13.go
+++ /dev/null
@@ -1,40 +0,0 @@
-// go run mksyscall.go -l32 -tags darwin,arm,go1.13 syscall_darwin.1_13.go
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-//go:build darwin && arm && go1.13
-// +build darwin,arm,go1.13
-
-package unix
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-var _ syscall.Errno
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func closedir(dir uintptr) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_closedir_trampoline), uintptr(dir), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_closedir_trampoline()
-
-//go:cgo_import_dynamic libc_closedir closedir "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func readdir_r(dir uintptr, entry *Dirent, result **Dirent) (res Errno) {
-	r0, _, _ := syscall_syscall(funcPC(libc_readdir_r_trampoline), uintptr(dir), uintptr(unsafe.Pointer(entry)), uintptr(unsafe.Pointer(result)))
-	res = Errno(r0)
-	return
-}
-
-func libc_readdir_r_trampoline()
-
-//go:cgo_import_dynamic libc_readdir_r readdir_r "/usr/lib/libSystem.B.dylib"
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.1_13.s b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.1_13.s
deleted file mode 100644
index 0cc80ad87e..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.1_13.s
+++ /dev/null
@@ -1,13 +0,0 @@
-// go run mkasm_darwin.go arm
-// Code generated by the command above; DO NOT EDIT.
-
-//go:build go1.13
-// +build go1.13
-
-#include "textflag.h"
-TEXT ·libc_fdopendir_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fdopendir(SB)
-TEXT ·libc_closedir_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_closedir(SB)
-TEXT ·libc_readdir_r_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_readdir_r(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.go
deleted file mode 100644
index 7f88cb5ea2..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.go
+++ /dev/null
@@ -1,2417 +0,0 @@
-// go run mksyscall.go -l32 -tags darwin,arm,go1.12 syscall_bsd.go syscall_darwin.go syscall_darwin_arm.go
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-//go:build darwin && arm && go1.12
-// +build darwin,arm,go1.12
-
-package unix
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-var _ syscall.Errno
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
-	r0, _, e1 := syscall_rawSyscall(funcPC(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_getgroups_trampoline()
-
-//go:cgo_import_dynamic libc_getgroups getgroups "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func setgroups(ngid int, gid *_Gid_t) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setgroups_trampoline()
-
-//go:cgo_import_dynamic libc_setgroups setgroups "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) {
-	r0, _, e1 := syscall_syscall6(funcPC(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
-	wpid = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_wait4_trampoline()
-
-//go:cgo_import_dynamic libc_wait4 wait4 "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
-	fd = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_accept_trampoline()
-
-//go:cgo_import_dynamic libc_accept accept "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_bind_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_bind_trampoline()
-
-//go:cgo_import_dynamic libc_bind bind "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_connect_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_connect_trampoline()
-
-//go:cgo_import_dynamic libc_connect connect "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func socket(domain int, typ int, proto int) (fd int, err error) {
-	r0, _, e1 := syscall_rawSyscall(funcPC(libc_socket_trampoline), uintptr(domain), uintptr(typ), uintptr(proto))
-	fd = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_socket_trampoline()
-
-//go:cgo_import_dynamic libc_socket socket "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
-	_, _, e1 := syscall_syscall6(funcPC(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_getsockopt_trampoline()
-
-//go:cgo_import_dynamic libc_getsockopt getsockopt "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
-	_, _, e1 := syscall_syscall6(funcPC(libc_setsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setsockopt_trampoline()
-
-//go:cgo_import_dynamic libc_setsockopt setsockopt "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_getpeername_trampoline()
-
-//go:cgo_import_dynamic libc_getpeername getpeername "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_getsockname_trampoline()
-
-//go:cgo_import_dynamic libc_getsockname getsockname "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Shutdown(s int, how int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_shutdown_trampoline), uintptr(s), uintptr(how), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_shutdown_trampoline()
-
-//go:cgo_import_dynamic libc_shutdown shutdown "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
-	_, _, e1 := syscall_rawSyscall6(funcPC(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_socketpair_trampoline()
-
-//go:cgo_import_dynamic libc_socketpair socketpair "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(p) > 0 {
-		_p0 = unsafe.Pointer(&p[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_recvfrom_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_recvfrom_trampoline()
-
-//go:cgo_import_dynamic libc_recvfrom recvfrom "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
-	var _p0 unsafe.Pointer
-	if len(buf) > 0 {
-		_p0 = unsafe.Pointer(&buf[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_sendto_trampoline), uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_sendto_trampoline()
-
-//go:cgo_import_dynamic libc_sendto sendto "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_recvmsg_trampoline()
-
-//go:cgo_import_dynamic libc_recvmsg recvmsg "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_sendmsg_trampoline()
-
-//go:cgo_import_dynamic libc_sendmsg sendmsg "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
-	r0, _, e1 := syscall_syscall6(funcPC(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_kevent_trampoline()
-
-//go:cgo_import_dynamic libc_kevent kevent "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func utimes(path string, timeval *[2]Timeval) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_utimes_trampoline()
-
-//go:cgo_import_dynamic libc_utimes utimes "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func futimes(fd int, timeval *[2]Timeval) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_futimes_trampoline()
-
-//go:cgo_import_dynamic libc_futimes futimes "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func poll(fds *PollFd, nfds int, timeout int) (n int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_poll_trampoline), uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_poll_trampoline()
-
-//go:cgo_import_dynamic libc_poll poll "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Madvise(b []byte, behav int) (err error) {
-	var _p0 unsafe.Pointer
-	if len(b) > 0 {
-		_p0 = unsafe.Pointer(&b[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_madvise_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(behav))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_madvise_trampoline()
-
-//go:cgo_import_dynamic libc_madvise madvise "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Mlock(b []byte) (err error) {
-	var _p0 unsafe.Pointer
-	if len(b) > 0 {
-		_p0 = unsafe.Pointer(&b[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_mlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_mlock_trampoline()
-
-//go:cgo_import_dynamic libc_mlock mlock "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Mlockall(flags int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_mlockall_trampoline), uintptr(flags), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_mlockall_trampoline()
-
-//go:cgo_import_dynamic libc_mlockall mlockall "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Mprotect(b []byte, prot int) (err error) {
-	var _p0 unsafe.Pointer
-	if len(b) > 0 {
-		_p0 = unsafe.Pointer(&b[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_mprotect_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(prot))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_mprotect_trampoline()
-
-//go:cgo_import_dynamic libc_mprotect mprotect "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Msync(b []byte, flags int) (err error) {
-	var _p0 unsafe.Pointer
-	if len(b) > 0 {
-		_p0 = unsafe.Pointer(&b[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_msync_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(flags))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_msync_trampoline()
-
-//go:cgo_import_dynamic libc_msync msync "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Munlock(b []byte) (err error) {
-	var _p0 unsafe.Pointer
-	if len(b) > 0 {
-		_p0 = unsafe.Pointer(&b[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_munlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_munlock_trampoline()
-
-//go:cgo_import_dynamic libc_munlock munlock "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Munlockall() (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_munlockall_trampoline), 0, 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_munlockall_trampoline()
-
-//go:cgo_import_dynamic libc_munlockall munlockall "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func pipe(p *[2]int32) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), uintptr(unsafe.Pointer(p)), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_pipe_trampoline()
-
-//go:cgo_import_dynamic libc_pipe pipe "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func getxattr(path string, attr string, dest *byte, size int, position uint32, options int) (sz int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(attr)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_getxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
-	sz = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_getxattr_trampoline()
-
-//go:cgo_import_dynamic libc_getxattr getxattr "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func fgetxattr(fd int, attr string, dest *byte, size int, position uint32, options int) (sz int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(attr)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_fgetxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
-	sz = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fgetxattr_trampoline()
-
-//go:cgo_import_dynamic libc_fgetxattr fgetxattr "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func setxattr(path string, attr string, data *byte, size int, position uint32, options int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(attr)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_setxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setxattr_trampoline()
-
-//go:cgo_import_dynamic libc_setxattr setxattr "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func fsetxattr(fd int, attr string, data *byte, size int, position uint32, options int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(attr)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_fsetxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fsetxattr_trampoline()
-
-//go:cgo_import_dynamic libc_fsetxattr fsetxattr "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func removexattr(path string, attr string, options int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(attr)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_removexattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_removexattr_trampoline()
-
-//go:cgo_import_dynamic libc_removexattr removexattr "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func fremovexattr(fd int, attr string, options int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(attr)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_fremovexattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(options))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fremovexattr_trampoline()
-
-//go:cgo_import_dynamic libc_fremovexattr fremovexattr "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func listxattr(path string, dest *byte, size int, options int) (sz int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_listxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
-	sz = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_listxattr_trampoline()
-
-//go:cgo_import_dynamic libc_listxattr listxattr "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func flistxattr(fd int, dest *byte, size int, options int) (sz int, err error) {
-	r0, _, e1 := syscall_syscall6(funcPC(libc_flistxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
-	sz = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_flistxattr_trampoline()
-
-//go:cgo_import_dynamic libc_flistxattr flistxattr "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func setattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
-	_, _, e1 := syscall_syscall6(funcPC(libc_setattrlist_trampoline), uintptr(unsafe.Pointer(path)), uintptr(list), uintptr(buf), uintptr(size), uintptr(options), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setattrlist_trampoline()
-
-//go:cgo_import_dynamic libc_setattrlist setattrlist "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func fcntl(fd int, cmd int, arg int) (val int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
-	val = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fcntl_trampoline()
-
-//go:cgo_import_dynamic libc_fcntl fcntl "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func kill(pid int, signum int, posix int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_kill_trampoline), uintptr(pid), uintptr(signum), uintptr(posix))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_kill_trampoline()
-
-//go:cgo_import_dynamic libc_kill kill "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func ioctl(fd int, req uint, arg uintptr) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_ioctl_trampoline()
-
-//go:cgo_import_dynamic libc_ioctl ioctl "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) {
-	var _p0 unsafe.Pointer
-	if len(mib) > 0 {
-		_p0 = unsafe.Pointer(&mib[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_sysctl_trampoline), uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_sysctl_trampoline()
-
-//go:cgo_import_dynamic libc_sysctl sysctl "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) {
-	_, _, e1 := syscall_syscall9(funcPC(libc_sendfile_trampoline), uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(offset>>32), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_sendfile_trampoline()
-
-//go:cgo_import_dynamic libc_sendfile sendfile "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Access(path string, mode uint32) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_access_trampoline()
-
-//go:cgo_import_dynamic libc_access access "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Adjtime(delta *Timeval, olddelta *Timeval) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_adjtime_trampoline()
-
-//go:cgo_import_dynamic libc_adjtime adjtime "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Chdir(path string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_chdir_trampoline()
-
-//go:cgo_import_dynamic libc_chdir chdir "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Chflags(path string, flags int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_chflags_trampoline()
-
-//go:cgo_import_dynamic libc_chflags chflags "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Chmod(path string, mode uint32) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_chmod_trampoline()
-
-//go:cgo_import_dynamic libc_chmod chmod "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Chown(path string, uid int, gid int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_chown_trampoline()
-
-//go:cgo_import_dynamic libc_chown chown "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Chroot(path string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_chroot_trampoline()
-
-//go:cgo_import_dynamic libc_chroot chroot "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func ClockGettime(clockid int32, time *Timespec) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_clock_gettime_trampoline), uintptr(clockid), uintptr(unsafe.Pointer(time)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_clock_gettime_trampoline()
-
-//go:cgo_import_dynamic libc_clock_gettime clock_gettime "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Close(fd int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_close_trampoline), uintptr(fd), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_close_trampoline()
-
-//go:cgo_import_dynamic libc_close close "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Clonefile(src string, dst string, flags int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(src)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(dst)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_clonefile_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flags))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_clonefile_trampoline()
-
-//go:cgo_import_dynamic libc_clonefile clonefile "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Clonefileat(srcDirfd int, src string, dstDirfd int, dst string, flags int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(src)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(dst)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_clonefileat_trampoline), uintptr(srcDirfd), uintptr(unsafe.Pointer(_p0)), uintptr(dstDirfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_clonefileat_trampoline()
-
-//go:cgo_import_dynamic libc_clonefileat clonefileat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Dup(fd int) (nfd int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_dup_trampoline), uintptr(fd), 0, 0)
-	nfd = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_dup_trampoline()
-
-//go:cgo_import_dynamic libc_dup dup "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Dup2(from int, to int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_dup2_trampoline), uintptr(from), uintptr(to), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_dup2_trampoline()
-
-//go:cgo_import_dynamic libc_dup2 dup2 "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Exchangedata(path1 string, path2 string, options int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path1)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(path2)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_exchangedata_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_exchangedata_trampoline()
-
-//go:cgo_import_dynamic libc_exchangedata exchangedata "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Exit(code int) {
-	syscall_syscall(funcPC(libc_exit_trampoline), uintptr(code), 0, 0)
-	return
-}
-
-func libc_exit_trampoline()
-
-//go:cgo_import_dynamic libc_exit exit "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_faccessat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_faccessat_trampoline()
-
-//go:cgo_import_dynamic libc_faccessat faccessat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fchdir(fd int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fchdir_trampoline), uintptr(fd), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fchdir_trampoline()
-
-//go:cgo_import_dynamic libc_fchdir fchdir "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fchflags(fd int, flags int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fchflags_trampoline), uintptr(fd), uintptr(flags), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fchflags_trampoline()
-
-//go:cgo_import_dynamic libc_fchflags fchflags "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fchmod(fd int, mode uint32) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fchmod_trampoline), uintptr(fd), uintptr(mode), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fchmod_trampoline()
-
-//go:cgo_import_dynamic libc_fchmod fchmod "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_fchmodat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fchmodat_trampoline()
-
-//go:cgo_import_dynamic libc_fchmodat fchmodat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fchown(fd int, uid int, gid int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fchown_trampoline), uintptr(fd), uintptr(uid), uintptr(gid))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fchown_trampoline()
-
-//go:cgo_import_dynamic libc_fchown fchown "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_fchownat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fchownat_trampoline()
-
-//go:cgo_import_dynamic libc_fchownat fchownat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fclonefileat(srcDirfd int, dstDirfd int, dst string, flags int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(dst)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_fclonefileat_trampoline), uintptr(srcDirfd), uintptr(dstDirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fclonefileat_trampoline()
-
-//go:cgo_import_dynamic libc_fclonefileat fclonefileat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Flock(fd int, how int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_flock_trampoline), uintptr(fd), uintptr(how), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_flock_trampoline()
-
-//go:cgo_import_dynamic libc_flock flock "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fpathconf(fd int, name int) (val int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_fpathconf_trampoline), uintptr(fd), uintptr(name), 0)
-	val = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fpathconf_trampoline()
-
-//go:cgo_import_dynamic libc_fpathconf fpathconf "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fsync(fd int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fsync_trampoline), uintptr(fd), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fsync_trampoline()
-
-//go:cgo_import_dynamic libc_fsync fsync "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Ftruncate(fd int, length int64) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_ftruncate_trampoline), uintptr(fd), uintptr(length), uintptr(length>>32))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_ftruncate_trampoline()
-
-//go:cgo_import_dynamic libc_ftruncate ftruncate "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getcwd(buf []byte) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(buf) > 0 {
-		_p0 = unsafe.Pointer(&buf[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := syscall_syscall(funcPC(libc_getcwd_trampoline), uintptr(_p0), uintptr(len(buf)), 0)
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_getcwd_trampoline()
-
-//go:cgo_import_dynamic libc_getcwd getcwd "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getdtablesize() (size int) {
-	r0, _, _ := syscall_syscall(funcPC(libc_getdtablesize_trampoline), 0, 0, 0)
-	size = int(r0)
-	return
-}
-
-func libc_getdtablesize_trampoline()
-
-//go:cgo_import_dynamic libc_getdtablesize getdtablesize "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getegid() (egid int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_getegid_trampoline), 0, 0, 0)
-	egid = int(r0)
-	return
-}
-
-func libc_getegid_trampoline()
-
-//go:cgo_import_dynamic libc_getegid getegid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Geteuid() (uid int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_geteuid_trampoline), 0, 0, 0)
-	uid = int(r0)
-	return
-}
-
-func libc_geteuid_trampoline()
-
-//go:cgo_import_dynamic libc_geteuid geteuid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getgid() (gid int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_getgid_trampoline), 0, 0, 0)
-	gid = int(r0)
-	return
-}
-
-func libc_getgid_trampoline()
-
-//go:cgo_import_dynamic libc_getgid getgid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getpgid(pid int) (pgid int, err error) {
-	r0, _, e1 := syscall_rawSyscall(funcPC(libc_getpgid_trampoline), uintptr(pid), 0, 0)
-	pgid = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_getpgid_trampoline()
-
-//go:cgo_import_dynamic libc_getpgid getpgid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getpgrp() (pgrp int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_getpgrp_trampoline), 0, 0, 0)
-	pgrp = int(r0)
-	return
-}
-
-func libc_getpgrp_trampoline()
-
-//go:cgo_import_dynamic libc_getpgrp getpgrp "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getpid() (pid int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_getpid_trampoline), 0, 0, 0)
-	pid = int(r0)
-	return
-}
-
-func libc_getpid_trampoline()
-
-//go:cgo_import_dynamic libc_getpid getpid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getppid() (ppid int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_getppid_trampoline), 0, 0, 0)
-	ppid = int(r0)
-	return
-}
-
-func libc_getppid_trampoline()
-
-//go:cgo_import_dynamic libc_getppid getppid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getpriority(which int, who int) (prio int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_getpriority_trampoline), uintptr(which), uintptr(who), 0)
-	prio = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_getpriority_trampoline()
-
-//go:cgo_import_dynamic libc_getpriority getpriority "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getrlimit(which int, lim *Rlimit) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_getrlimit_trampoline()
-
-//go:cgo_import_dynamic libc_getrlimit getrlimit "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getrusage(who int, rusage *Rusage) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_getrusage_trampoline()
-
-//go:cgo_import_dynamic libc_getrusage getrusage "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getsid(pid int) (sid int, err error) {
-	r0, _, e1 := syscall_rawSyscall(funcPC(libc_getsid_trampoline), uintptr(pid), 0, 0)
-	sid = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_getsid_trampoline()
-
-//go:cgo_import_dynamic libc_getsid getsid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Gettimeofday(tp *Timeval) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_gettimeofday_trampoline()
-
-//go:cgo_import_dynamic libc_gettimeofday gettimeofday "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Getuid() (uid int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_getuid_trampoline), 0, 0, 0)
-	uid = int(r0)
-	return
-}
-
-func libc_getuid_trampoline()
-
-//go:cgo_import_dynamic libc_getuid getuid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Issetugid() (tainted bool) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_issetugid_trampoline), 0, 0, 0)
-	tainted = bool(r0 != 0)
-	return
-}
-
-func libc_issetugid_trampoline()
-
-//go:cgo_import_dynamic libc_issetugid issetugid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Kqueue() (fd int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_kqueue_trampoline), 0, 0, 0)
-	fd = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_kqueue_trampoline()
-
-//go:cgo_import_dynamic libc_kqueue kqueue "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Lchown(path string, uid int, gid int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_lchown_trampoline()
-
-//go:cgo_import_dynamic libc_lchown lchown "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Link(path string, link string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(link)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_link_trampoline()
-
-//go:cgo_import_dynamic libc_link link "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Linkat(pathfd int, path string, linkfd int, link string, flags int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(link)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_linkat_trampoline), uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_linkat_trampoline()
-
-//go:cgo_import_dynamic libc_linkat linkat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Listen(s int, backlog int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_listen_trampoline), uintptr(s), uintptr(backlog), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_listen_trampoline()
-
-//go:cgo_import_dynamic libc_listen listen "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Mkdir(path string, mode uint32) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_mkdir_trampoline()
-
-//go:cgo_import_dynamic libc_mkdir mkdir "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Mkdirat(dirfd int, path string, mode uint32) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_mkdirat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_mkdirat_trampoline()
-
-//go:cgo_import_dynamic libc_mkdirat mkdirat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Mkfifo(path string, mode uint32) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_mkfifo_trampoline()
-
-//go:cgo_import_dynamic libc_mkfifo mkfifo "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Mknod(path string, mode uint32, dev int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_mknod_trampoline()
-
-//go:cgo_import_dynamic libc_mknod mknod "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Open(path string, mode int, perm uint32) (fd int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := syscall_syscall(funcPC(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
-	fd = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_open_trampoline()
-
-//go:cgo_import_dynamic libc_open open "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_openat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0)
-	fd = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_openat_trampoline()
-
-//go:cgo_import_dynamic libc_openat openat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Pathconf(path string, name int) (val int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := syscall_syscall(funcPC(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
-	val = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_pathconf_trampoline()
-
-//go:cgo_import_dynamic libc_pathconf pathconf "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Pread(fd int, p []byte, offset int64) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(p) > 0 {
-		_p0 = unsafe.Pointer(&p[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_pread_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_pread_trampoline()
-
-//go:cgo_import_dynamic libc_pread pread "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(p) > 0 {
-		_p0 = unsafe.Pointer(&p[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_pwrite_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_pwrite_trampoline()
-
-//go:cgo_import_dynamic libc_pwrite pwrite "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func read(fd int, p []byte) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(p) > 0 {
-		_p0 = unsafe.Pointer(&p[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := syscall_syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_read_trampoline()
-
-//go:cgo_import_dynamic libc_read read "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Readlink(path string, buf []byte) (n int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 unsafe.Pointer
-	if len(buf) > 0 {
-		_p1 = unsafe.Pointer(&buf[0])
-	} else {
-		_p1 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := syscall_syscall(funcPC(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_readlink_trampoline()
-
-//go:cgo_import_dynamic libc_readlink readlink "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Readlinkat(dirfd int, path string, buf []byte) (n int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 unsafe.Pointer
-	if len(buf) > 0 {
-		_p1 = unsafe.Pointer(&buf[0])
-	} else {
-		_p1 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_readlinkat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_readlinkat_trampoline()
-
-//go:cgo_import_dynamic libc_readlinkat readlinkat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Rename(from string, to string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(from)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(to)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_rename_trampoline()
-
-//go:cgo_import_dynamic libc_rename rename "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Renameat(fromfd int, from string, tofd int, to string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(from)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(to)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_renameat_trampoline), uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_renameat_trampoline()
-
-//go:cgo_import_dynamic libc_renameat renameat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Revoke(path string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_revoke_trampoline()
-
-//go:cgo_import_dynamic libc_revoke revoke "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Rmdir(path string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_rmdir_trampoline()
-
-//go:cgo_import_dynamic libc_rmdir rmdir "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
-	r0, r1, e1 := syscall_syscall6(funcPC(libc_lseek_trampoline), uintptr(fd), uintptr(offset), uintptr(offset>>32), uintptr(whence), 0, 0)
-	newoffset = int64(int64(r1)<<32 | int64(r0))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_lseek_trampoline()
-
-//go:cgo_import_dynamic libc_lseek lseek "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error) {
-	r0, _, e1 := syscall_syscall6(funcPC(libc_select_trampoline), uintptr(nfd), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_select_trampoline()
-
-//go:cgo_import_dynamic libc_select select "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setegid(egid int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_setegid_trampoline), uintptr(egid), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setegid_trampoline()
-
-//go:cgo_import_dynamic libc_setegid setegid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Seteuid(euid int) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_seteuid_trampoline), uintptr(euid), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_seteuid_trampoline()
-
-//go:cgo_import_dynamic libc_seteuid seteuid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setgid(gid int) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setgid_trampoline), uintptr(gid), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setgid_trampoline()
-
-//go:cgo_import_dynamic libc_setgid setgid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setlogin(name string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(name)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setlogin_trampoline()
-
-//go:cgo_import_dynamic libc_setlogin setlogin "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setpgid(pid int, pgid int) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setpgid_trampoline), uintptr(pid), uintptr(pgid), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setpgid_trampoline()
-
-//go:cgo_import_dynamic libc_setpgid setpgid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setpriority(which int, who int, prio int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_setpriority_trampoline), uintptr(which), uintptr(who), uintptr(prio))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setpriority_trampoline()
-
-//go:cgo_import_dynamic libc_setpriority setpriority "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setprivexec(flag int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_setprivexec_trampoline), uintptr(flag), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setprivexec_trampoline()
-
-//go:cgo_import_dynamic libc_setprivexec setprivexec "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setregid(rgid int, egid int) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setregid_trampoline), uintptr(rgid), uintptr(egid), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setregid_trampoline()
-
-//go:cgo_import_dynamic libc_setregid setregid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setreuid(ruid int, euid int) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setreuid_trampoline), uintptr(ruid), uintptr(euid), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setreuid_trampoline()
-
-//go:cgo_import_dynamic libc_setreuid setreuid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setrlimit(which int, lim *Rlimit) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setrlimit_trampoline()
-
-//go:cgo_import_dynamic libc_setrlimit setrlimit "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setsid() (pid int, err error) {
-	r0, _, e1 := syscall_rawSyscall(funcPC(libc_setsid_trampoline), 0, 0, 0)
-	pid = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setsid_trampoline()
-
-//go:cgo_import_dynamic libc_setsid setsid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Settimeofday(tp *Timeval) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_settimeofday_trampoline()
-
-//go:cgo_import_dynamic libc_settimeofday settimeofday "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setuid(uid int) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setuid_trampoline), uintptr(uid), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_setuid_trampoline()
-
-//go:cgo_import_dynamic libc_setuid setuid "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Symlink(path string, link string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(link)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_symlink_trampoline()
-
-//go:cgo_import_dynamic libc_symlink symlink "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Symlinkat(oldpath string, newdirfd int, newpath string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(oldpath)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(newpath)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_symlinkat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_symlinkat_trampoline()
-
-//go:cgo_import_dynamic libc_symlinkat symlinkat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Sync() (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_sync_trampoline), 0, 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_sync_trampoline()
-
-//go:cgo_import_dynamic libc_sync sync "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Truncate(path string, length int64) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), uintptr(length>>32))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_truncate_trampoline()
-
-//go:cgo_import_dynamic libc_truncate truncate "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Umask(newmask int) (oldmask int) {
-	r0, _, _ := syscall_syscall(funcPC(libc_umask_trampoline), uintptr(newmask), 0, 0)
-	oldmask = int(r0)
-	return
-}
-
-func libc_umask_trampoline()
-
-//go:cgo_import_dynamic libc_umask umask "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Undelete(path string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_undelete_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_undelete_trampoline()
-
-//go:cgo_import_dynamic libc_undelete undelete "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Unlink(path string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_unlink_trampoline()
-
-//go:cgo_import_dynamic libc_unlink unlink "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Unlinkat(dirfd int, path string, flags int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_unlinkat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_unlinkat_trampoline()
-
-//go:cgo_import_dynamic libc_unlinkat unlinkat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Unmount(path string, flags int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_unmount_trampoline()
-
-//go:cgo_import_dynamic libc_unmount unmount "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func write(fd int, p []byte) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(p) > 0 {
-		_p0 = unsafe.Pointer(&p[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := syscall_syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_write_trampoline()
-
-//go:cgo_import_dynamic libc_write write "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
-	r0, _, e1 := syscall_syscall9(funcPC(libc_mmap_trampoline), uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos), uintptr(pos>>32), 0, 0)
-	ret = uintptr(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_mmap_trampoline()
-
-//go:cgo_import_dynamic libc_mmap mmap "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func munmap(addr uintptr, length uintptr) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_munmap_trampoline), uintptr(addr), uintptr(length), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_munmap_trampoline()
-
-//go:cgo_import_dynamic libc_munmap munmap "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fstat(fd int, stat *Stat_t) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fstat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fstat_trampoline()
-
-//go:cgo_import_dynamic libc_fstat fstat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_fstatat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fstatat_trampoline()
-
-//go:cgo_import_dynamic libc_fstatat fstatat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Fstatfs(fd int, stat *Statfs_t) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fstatfs_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_fstatfs_trampoline()
-
-//go:cgo_import_dynamic libc_fstatfs fstatfs "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_getfsstat_trampoline), uintptr(buf), uintptr(size), uintptr(flags))
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_getfsstat_trampoline()
-
-//go:cgo_import_dynamic libc_getfsstat getfsstat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Lstat(path string, stat *Stat_t) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_lstat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_lstat_trampoline()
-
-//go:cgo_import_dynamic libc_lstat lstat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Stat(path string, stat *Stat_t) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_stat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_stat_trampoline()
-
-//go:cgo_import_dynamic libc_stat stat "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Statfs(path string, stat *Statfs_t) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	_, _, e1 := syscall_syscall(funcPC(libc_statfs_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-func libc_statfs_trampoline()
-
-//go:cgo_import_dynamic libc_statfs statfs "/usr/lib/libSystem.B.dylib"
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.s b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.s
deleted file mode 100644
index a99f9c1113..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.s
+++ /dev/null
@@ -1,289 +0,0 @@
-// go run mkasm_darwin.go arm
-// Code generated by the command above; DO NOT EDIT.
-
-//go:build go1.12
-// +build go1.12
-
-#include "textflag.h"
-TEXT ·libc_getgroups_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getgroups(SB)
-TEXT ·libc_setgroups_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setgroups(SB)
-TEXT ·libc_wait4_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_wait4(SB)
-TEXT ·libc_accept_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_accept(SB)
-TEXT ·libc_bind_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_bind(SB)
-TEXT ·libc_connect_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_connect(SB)
-TEXT ·libc_socket_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_socket(SB)
-TEXT ·libc_getsockopt_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getsockopt(SB)
-TEXT ·libc_setsockopt_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setsockopt(SB)
-TEXT ·libc_getpeername_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getpeername(SB)
-TEXT ·libc_getsockname_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getsockname(SB)
-TEXT ·libc_shutdown_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_shutdown(SB)
-TEXT ·libc_socketpair_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_socketpair(SB)
-TEXT ·libc_recvfrom_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_recvfrom(SB)
-TEXT ·libc_sendto_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_sendto(SB)
-TEXT ·libc_recvmsg_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_recvmsg(SB)
-TEXT ·libc_sendmsg_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_sendmsg(SB)
-TEXT ·libc_kevent_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_kevent(SB)
-TEXT ·libc_utimes_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_utimes(SB)
-TEXT ·libc_futimes_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_futimes(SB)
-TEXT ·libc_poll_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_poll(SB)
-TEXT ·libc_madvise_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_madvise(SB)
-TEXT ·libc_mlock_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_mlock(SB)
-TEXT ·libc_mlockall_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_mlockall(SB)
-TEXT ·libc_mprotect_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_mprotect(SB)
-TEXT ·libc_msync_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_msync(SB)
-TEXT ·libc_munlock_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_munlock(SB)
-TEXT ·libc_munlockall_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_munlockall(SB)
-TEXT ·libc_pipe_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_pipe(SB)
-TEXT ·libc_getxattr_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getxattr(SB)
-TEXT ·libc_fgetxattr_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fgetxattr(SB)
-TEXT ·libc_setxattr_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setxattr(SB)
-TEXT ·libc_fsetxattr_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fsetxattr(SB)
-TEXT ·libc_removexattr_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_removexattr(SB)
-TEXT ·libc_fremovexattr_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fremovexattr(SB)
-TEXT ·libc_listxattr_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_listxattr(SB)
-TEXT ·libc_flistxattr_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_flistxattr(SB)
-TEXT ·libc_setattrlist_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setattrlist(SB)
-TEXT ·libc_fcntl_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fcntl(SB)
-TEXT ·libc_kill_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_kill(SB)
-TEXT ·libc_ioctl_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_ioctl(SB)
-TEXT ·libc_sysctl_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_sysctl(SB)
-TEXT ·libc_sendfile_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_sendfile(SB)
-TEXT ·libc_access_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_access(SB)
-TEXT ·libc_adjtime_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_adjtime(SB)
-TEXT ·libc_chdir_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_chdir(SB)
-TEXT ·libc_chflags_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_chflags(SB)
-TEXT ·libc_chmod_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_chmod(SB)
-TEXT ·libc_chown_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_chown(SB)
-TEXT ·libc_chroot_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_chroot(SB)
-TEXT ·libc_clock_gettime_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_clock_gettime(SB)
-TEXT ·libc_close_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_close(SB)
-TEXT ·libc_clonefile_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_clonefile(SB)
-TEXT ·libc_clonefileat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_clonefileat(SB)
-TEXT ·libc_dup_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_dup(SB)
-TEXT ·libc_dup2_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_dup2(SB)
-TEXT ·libc_exchangedata_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_exchangedata(SB)
-TEXT ·libc_exit_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_exit(SB)
-TEXT ·libc_faccessat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_faccessat(SB)
-TEXT ·libc_fchdir_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fchdir(SB)
-TEXT ·libc_fchflags_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fchflags(SB)
-TEXT ·libc_fchmod_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fchmod(SB)
-TEXT ·libc_fchmodat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fchmodat(SB)
-TEXT ·libc_fchown_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fchown(SB)
-TEXT ·libc_fchownat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fchownat(SB)
-TEXT ·libc_fclonefileat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fclonefileat(SB)
-TEXT ·libc_flock_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_flock(SB)
-TEXT ·libc_fpathconf_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fpathconf(SB)
-TEXT ·libc_fsync_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fsync(SB)
-TEXT ·libc_ftruncate_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_ftruncate(SB)
-TEXT ·libc_getcwd_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getcwd(SB)
-TEXT ·libc_getdtablesize_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getdtablesize(SB)
-TEXT ·libc_getegid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getegid(SB)
-TEXT ·libc_geteuid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_geteuid(SB)
-TEXT ·libc_getgid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getgid(SB)
-TEXT ·libc_getpgid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getpgid(SB)
-TEXT ·libc_getpgrp_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getpgrp(SB)
-TEXT ·libc_getpid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getpid(SB)
-TEXT ·libc_getppid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getppid(SB)
-TEXT ·libc_getpriority_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getpriority(SB)
-TEXT ·libc_getrlimit_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getrlimit(SB)
-TEXT ·libc_getrusage_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getrusage(SB)
-TEXT ·libc_getsid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getsid(SB)
-TEXT ·libc_gettimeofday_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_gettimeofday(SB)
-TEXT ·libc_getuid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getuid(SB)
-TEXT ·libc_issetugid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_issetugid(SB)
-TEXT ·libc_kqueue_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_kqueue(SB)
-TEXT ·libc_lchown_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_lchown(SB)
-TEXT ·libc_link_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_link(SB)
-TEXT ·libc_linkat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_linkat(SB)
-TEXT ·libc_listen_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_listen(SB)
-TEXT ·libc_mkdir_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_mkdir(SB)
-TEXT ·libc_mkdirat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_mkdirat(SB)
-TEXT ·libc_mkfifo_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_mkfifo(SB)
-TEXT ·libc_mknod_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_mknod(SB)
-TEXT ·libc_open_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_open(SB)
-TEXT ·libc_openat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_openat(SB)
-TEXT ·libc_pathconf_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_pathconf(SB)
-TEXT ·libc_pread_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_pread(SB)
-TEXT ·libc_pwrite_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_pwrite(SB)
-TEXT ·libc_read_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_read(SB)
-TEXT ·libc_readlink_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_readlink(SB)
-TEXT ·libc_readlinkat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_readlinkat(SB)
-TEXT ·libc_rename_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_rename(SB)
-TEXT ·libc_renameat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_renameat(SB)
-TEXT ·libc_revoke_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_revoke(SB)
-TEXT ·libc_rmdir_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_rmdir(SB)
-TEXT ·libc_lseek_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_lseek(SB)
-TEXT ·libc_select_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_select(SB)
-TEXT ·libc_setegid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setegid(SB)
-TEXT ·libc_seteuid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_seteuid(SB)
-TEXT ·libc_setgid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setgid(SB)
-TEXT ·libc_setlogin_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setlogin(SB)
-TEXT ·libc_setpgid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setpgid(SB)
-TEXT ·libc_setpriority_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setpriority(SB)
-TEXT ·libc_setprivexec_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setprivexec(SB)
-TEXT ·libc_setregid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setregid(SB)
-TEXT ·libc_setreuid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setreuid(SB)
-TEXT ·libc_setrlimit_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setrlimit(SB)
-TEXT ·libc_setsid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setsid(SB)
-TEXT ·libc_settimeofday_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_settimeofday(SB)
-TEXT ·libc_setuid_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_setuid(SB)
-TEXT ·libc_symlink_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_symlink(SB)
-TEXT ·libc_symlinkat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_symlinkat(SB)
-TEXT ·libc_sync_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_sync(SB)
-TEXT ·libc_truncate_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_truncate(SB)
-TEXT ·libc_umask_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_umask(SB)
-TEXT ·libc_undelete_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_undelete(SB)
-TEXT ·libc_unlink_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_unlink(SB)
-TEXT ·libc_unlinkat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_unlinkat(SB)
-TEXT ·libc_unmount_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_unmount(SB)
-TEXT ·libc_write_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_write(SB)
-TEXT ·libc_mmap_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_mmap(SB)
-TEXT ·libc_munmap_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_munmap(SB)
-TEXT ·libc_fstat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fstat(SB)
-TEXT ·libc_fstatat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fstatat(SB)
-TEXT ·libc_fstatfs_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_fstatfs(SB)
-TEXT ·libc_getfsstat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_getfsstat(SB)
-TEXT ·libc_lstat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_lstat(SB)
-TEXT ·libc_stat_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_stat(SB)
-TEXT ·libc_statfs_trampoline(SB),NOSPLIT,$0-0
-	JMP	libc_statfs(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.1_13.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.1_13.go
index d30ec4e29a..cec595d553 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.1_13.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.1_13.go
@@ -16,25 +16,25 @@ var _ syscall.Errno
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func closedir(dir uintptr) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_closedir_trampoline), uintptr(dir), 0, 0)
+	_, _, e1 := syscall_syscall(libc_closedir_trampoline_addr, uintptr(dir), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_closedir_trampoline()
+var libc_closedir_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_closedir closedir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func readdir_r(dir uintptr, entry *Dirent, result **Dirent) (res Errno) {
-	r0, _, _ := syscall_syscall(funcPC(libc_readdir_r_trampoline), uintptr(dir), uintptr(unsafe.Pointer(entry)), uintptr(unsafe.Pointer(result)))
+	r0, _, _ := syscall_syscall(libc_readdir_r_trampoline_addr, uintptr(dir), uintptr(unsafe.Pointer(entry)), uintptr(unsafe.Pointer(result)))
 	res = Errno(r0)
 	return
 }
 
-func libc_readdir_r_trampoline()
+var libc_readdir_r_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_readdir_r readdir_r "/usr/lib/libSystem.B.dylib"
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.1_13.s b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.1_13.s
index a5f96ffb07..357989722c 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.1_13.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.1_13.s
@@ -5,9 +5,21 @@
 // +build go1.13
 
 #include "textflag.h"
-TEXT ·libc_fdopendir_trampoline(SB),NOSPLIT,$0-0
+
+TEXT libc_fdopendir_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fdopendir(SB)
-TEXT ·libc_closedir_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fdopendir_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fdopendir_trampoline_addr(SB)/8, $libc_fdopendir_trampoline<>(SB)
+
+TEXT libc_closedir_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_closedir(SB)
-TEXT ·libc_readdir_r_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_closedir_trampoline_addr(SB), RODATA, $8
+DATA	·libc_closedir_trampoline_addr(SB)/8, $libc_closedir_trampoline<>(SB)
+
+TEXT libc_readdir_r_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_readdir_r(SB)
+
+GLOBL	·libc_readdir_r_trampoline_addr(SB), RODATA, $8
+DATA	·libc_readdir_r_trampoline_addr(SB)/8, $libc_readdir_r_trampoline<>(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
index a10df58d00..f2ee2bd33b 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
@@ -16,7 +16,7 @@ var _ syscall.Errno
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
-	r0, _, e1 := syscall_rawSyscall(funcPC(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
+	r0, _, e1 := syscall_rawSyscall(libc_getgroups_trampoline_addr, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -24,28 +24,28 @@ func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
 	return
 }
 
-func libc_getgroups_trampoline()
+var libc_getgroups_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getgroups getgroups "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func setgroups(ngid int, gid *_Gid_t) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
+	_, _, e1 := syscall_rawSyscall(libc_setgroups_trampoline_addr, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setgroups_trampoline()
+var libc_setgroups_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setgroups setgroups "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) {
-	r0, _, e1 := syscall_syscall6(funcPC(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
+	r0, _, e1 := syscall_syscall6(libc_wait4_trampoline_addr, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
 	wpid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -53,14 +53,14 @@ func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err
 	return
 }
 
-func libc_wait4_trampoline()
+var libc_wait4_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_wait4 wait4 "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	r0, _, e1 := syscall_syscall(libc_accept_trampoline_addr, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -68,42 +68,42 @@ func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
 	return
 }
 
-func libc_accept_trampoline()
+var libc_accept_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_accept accept "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_bind_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
+	_, _, e1 := syscall_syscall(libc_bind_trampoline_addr, uintptr(s), uintptr(addr), uintptr(addrlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_bind_trampoline()
+var libc_bind_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_bind bind "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_connect_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
+	_, _, e1 := syscall_syscall(libc_connect_trampoline_addr, uintptr(s), uintptr(addr), uintptr(addrlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_connect_trampoline()
+var libc_connect_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_connect connect "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func socket(domain int, typ int, proto int) (fd int, err error) {
-	r0, _, e1 := syscall_rawSyscall(funcPC(libc_socket_trampoline), uintptr(domain), uintptr(typ), uintptr(proto))
+	r0, _, e1 := syscall_rawSyscall(libc_socket_trampoline_addr, uintptr(domain), uintptr(typ), uintptr(proto))
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -111,91 +111,91 @@ func socket(domain int, typ int, proto int) (fd int, err error) {
 	return
 }
 
-func libc_socket_trampoline()
+var libc_socket_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_socket socket "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
-	_, _, e1 := syscall_syscall6(funcPC(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
+	_, _, e1 := syscall_syscall6(libc_getsockopt_trampoline_addr, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_getsockopt_trampoline()
+var libc_getsockopt_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getsockopt getsockopt "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
-	_, _, e1 := syscall_syscall6(funcPC(libc_setsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
+	_, _, e1 := syscall_syscall6(libc_setsockopt_trampoline_addr, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setsockopt_trampoline()
+var libc_setsockopt_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setsockopt setsockopt "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	_, _, e1 := syscall_rawSyscall(libc_getpeername_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_getpeername_trampoline()
+var libc_getpeername_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getpeername getpeername "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
+	_, _, e1 := syscall_rawSyscall(libc_getsockname_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_getsockname_trampoline()
+var libc_getsockname_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getsockname getsockname "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Shutdown(s int, how int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_shutdown_trampoline), uintptr(s), uintptr(how), 0)
+	_, _, e1 := syscall_syscall(libc_shutdown_trampoline_addr, uintptr(s), uintptr(how), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_shutdown_trampoline()
+var libc_shutdown_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_shutdown shutdown "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
-	_, _, e1 := syscall_rawSyscall6(funcPC(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
+	_, _, e1 := syscall_rawSyscall6(libc_socketpair_trampoline_addr, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_socketpair_trampoline()
+var libc_socketpair_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_socketpair socketpair "/usr/lib/libSystem.B.dylib"
 
@@ -208,7 +208,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_recvfrom_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
+	r0, _, e1 := syscall_syscall6(libc_recvfrom_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -216,7 +216,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
 	return
 }
 
-func libc_recvfrom_trampoline()
+var libc_recvfrom_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_recvfrom recvfrom "/usr/lib/libSystem.B.dylib"
 
@@ -229,21 +229,21 @@ func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_sendto_trampoline), uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
+	_, _, e1 := syscall_syscall6(libc_sendto_trampoline_addr, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_sendto_trampoline()
+var libc_sendto_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_sendto sendto "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
+	r0, _, e1 := syscall_syscall(libc_recvmsg_trampoline_addr, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -251,14 +251,14 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 	return
 }
 
-func libc_recvmsg_trampoline()
+var libc_recvmsg_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_recvmsg recvmsg "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
+	r0, _, e1 := syscall_syscall(libc_sendmsg_trampoline_addr, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -266,14 +266,14 @@ func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 	return
 }
 
-func libc_sendmsg_trampoline()
+var libc_sendmsg_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_sendmsg sendmsg "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
-	r0, _, e1 := syscall_syscall6(funcPC(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
+	r0, _, e1 := syscall_syscall6(libc_kevent_trampoline_addr, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -281,7 +281,7 @@ func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, ne
 	return
 }
 
-func libc_kevent_trampoline()
+var libc_kevent_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_kevent kevent "/usr/lib/libSystem.B.dylib"
 
@@ -293,35 +293,35 @@ func utimes(path string, timeval *[2]Timeval) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
+	_, _, e1 := syscall_syscall(libc_utimes_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_utimes_trampoline()
+var libc_utimes_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_utimes utimes "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func futimes(fd int, timeval *[2]Timeval) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
+	_, _, e1 := syscall_syscall(libc_futimes_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_futimes_trampoline()
+var libc_futimes_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_futimes futimes "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func poll(fds *PollFd, nfds int, timeout int) (n int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_poll_trampoline), uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
+	r0, _, e1 := syscall_syscall(libc_poll_trampoline_addr, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -329,7 +329,7 @@ func poll(fds *PollFd, nfds int, timeout int) (n int, err error) {
 	return
 }
 
-func libc_poll_trampoline()
+var libc_poll_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_poll poll "/usr/lib/libSystem.B.dylib"
 
@@ -342,14 +342,14 @@ func Madvise(b []byte, behav int) (err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_madvise_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(behav))
+	_, _, e1 := syscall_syscall(libc_madvise_trampoline_addr, uintptr(_p0), uintptr(len(b)), uintptr(behav))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_madvise_trampoline()
+var libc_madvise_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_madvise madvise "/usr/lib/libSystem.B.dylib"
 
@@ -362,28 +362,28 @@ func Mlock(b []byte) (err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_mlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
+	_, _, e1 := syscall_syscall(libc_mlock_trampoline_addr, uintptr(_p0), uintptr(len(b)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_mlock_trampoline()
+var libc_mlock_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_mlock mlock "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Mlockall(flags int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_mlockall_trampoline), uintptr(flags), 0, 0)
+	_, _, e1 := syscall_syscall(libc_mlockall_trampoline_addr, uintptr(flags), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_mlockall_trampoline()
+var libc_mlockall_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_mlockall mlockall "/usr/lib/libSystem.B.dylib"
 
@@ -396,14 +396,14 @@ func Mprotect(b []byte, prot int) (err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_mprotect_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(prot))
+	_, _, e1 := syscall_syscall(libc_mprotect_trampoline_addr, uintptr(_p0), uintptr(len(b)), uintptr(prot))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_mprotect_trampoline()
+var libc_mprotect_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_mprotect mprotect "/usr/lib/libSystem.B.dylib"
 
@@ -416,14 +416,14 @@ func Msync(b []byte, flags int) (err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_msync_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(flags))
+	_, _, e1 := syscall_syscall(libc_msync_trampoline_addr, uintptr(_p0), uintptr(len(b)), uintptr(flags))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_msync_trampoline()
+var libc_msync_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_msync msync "/usr/lib/libSystem.B.dylib"
 
@@ -436,42 +436,42 @@ func Munlock(b []byte) (err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_munlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
+	_, _, e1 := syscall_syscall(libc_munlock_trampoline_addr, uintptr(_p0), uintptr(len(b)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_munlock_trampoline()
+var libc_munlock_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_munlock munlock "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Munlockall() (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_munlockall_trampoline), 0, 0, 0)
+	_, _, e1 := syscall_syscall(libc_munlockall_trampoline_addr, 0, 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_munlockall_trampoline()
+var libc_munlockall_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_munlockall munlockall "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func pipe(p *[2]int32) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), uintptr(unsafe.Pointer(p)), 0, 0)
+	_, _, e1 := syscall_rawSyscall(libc_pipe_trampoline_addr, uintptr(unsafe.Pointer(p)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_pipe_trampoline()
+var libc_pipe_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_pipe pipe "/usr/lib/libSystem.B.dylib"
 
@@ -488,7 +488,7 @@ func getxattr(path string, attr string, dest *byte, size int, position uint32, o
 	if err != nil {
 		return
 	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_getxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
+	r0, _, e1 := syscall_syscall6(libc_getxattr_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
 	sz = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -496,7 +496,7 @@ func getxattr(path string, attr string, dest *byte, size int, position uint32, o
 	return
 }
 
-func libc_getxattr_trampoline()
+var libc_getxattr_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getxattr getxattr "/usr/lib/libSystem.B.dylib"
 
@@ -508,7 +508,7 @@ func fgetxattr(fd int, attr string, dest *byte, size int, position uint32, optio
 	if err != nil {
 		return
 	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_fgetxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
+	r0, _, e1 := syscall_syscall6(libc_fgetxattr_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
 	sz = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -516,7 +516,7 @@ func fgetxattr(fd int, attr string, dest *byte, size int, position uint32, optio
 	return
 }
 
-func libc_fgetxattr_trampoline()
+var libc_fgetxattr_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fgetxattr fgetxattr "/usr/lib/libSystem.B.dylib"
 
@@ -533,14 +533,14 @@ func setxattr(path string, attr string, data *byte, size int, position uint32, o
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_setxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
+	_, _, e1 := syscall_syscall6(libc_setxattr_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setxattr_trampoline()
+var libc_setxattr_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setxattr setxattr "/usr/lib/libSystem.B.dylib"
 
@@ -552,14 +552,14 @@ func fsetxattr(fd int, attr string, data *byte, size int, position uint32, optio
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_fsetxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
+	_, _, e1 := syscall_syscall6(libc_fsetxattr_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fsetxattr_trampoline()
+var libc_fsetxattr_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fsetxattr fsetxattr "/usr/lib/libSystem.B.dylib"
 
@@ -576,14 +576,14 @@ func removexattr(path string, attr string, options int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_removexattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
+	_, _, e1 := syscall_syscall(libc_removexattr_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_removexattr_trampoline()
+var libc_removexattr_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_removexattr removexattr "/usr/lib/libSystem.B.dylib"
 
@@ -595,14 +595,14 @@ func fremovexattr(fd int, attr string, options int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_fremovexattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(options))
+	_, _, e1 := syscall_syscall(libc_fremovexattr_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(options))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fremovexattr_trampoline()
+var libc_fremovexattr_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fremovexattr fremovexattr "/usr/lib/libSystem.B.dylib"
 
@@ -614,7 +614,7 @@ func listxattr(path string, dest *byte, size int, options int) (sz int, err erro
 	if err != nil {
 		return
 	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_listxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
+	r0, _, e1 := syscall_syscall6(libc_listxattr_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
 	sz = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -622,14 +622,14 @@ func listxattr(path string, dest *byte, size int, options int) (sz int, err erro
 	return
 }
 
-func libc_listxattr_trampoline()
+var libc_listxattr_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_listxattr listxattr "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func flistxattr(fd int, dest *byte, size int, options int) (sz int, err error) {
-	r0, _, e1 := syscall_syscall6(funcPC(libc_flistxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
+	r0, _, e1 := syscall_syscall6(libc_flistxattr_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
 	sz = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -637,28 +637,28 @@ func flistxattr(fd int, dest *byte, size int, options int) (sz int, err error) {
 	return
 }
 
-func libc_flistxattr_trampoline()
+var libc_flistxattr_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_flistxattr flistxattr "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func setattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
-	_, _, e1 := syscall_syscall6(funcPC(libc_setattrlist_trampoline), uintptr(unsafe.Pointer(path)), uintptr(list), uintptr(buf), uintptr(size), uintptr(options), 0)
+	_, _, e1 := syscall_syscall6(libc_setattrlist_trampoline_addr, uintptr(unsafe.Pointer(path)), uintptr(list), uintptr(buf), uintptr(size), uintptr(options), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setattrlist_trampoline()
+var libc_setattrlist_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setattrlist setattrlist "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func fcntl(fd int, cmd int, arg int) (val int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
+	r0, _, e1 := syscall_syscall(libc_fcntl_trampoline_addr, uintptr(fd), uintptr(cmd), uintptr(arg))
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -666,35 +666,35 @@ func fcntl(fd int, cmd int, arg int) (val int, err error) {
 	return
 }
 
-func libc_fcntl_trampoline()
+var libc_fcntl_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fcntl fcntl "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func kill(pid int, signum int, posix int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_kill_trampoline), uintptr(pid), uintptr(signum), uintptr(posix))
+	_, _, e1 := syscall_syscall(libc_kill_trampoline_addr, uintptr(pid), uintptr(signum), uintptr(posix))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_kill_trampoline()
+var libc_kill_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_kill kill "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func ioctl(fd int, req uint, arg uintptr) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
+	_, _, e1 := syscall_syscall(libc_ioctl_trampoline_addr, uintptr(fd), uintptr(req), uintptr(arg))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_ioctl_trampoline()
+var libc_ioctl_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_ioctl ioctl "/usr/lib/libSystem.B.dylib"
 
@@ -707,28 +707,28 @@ func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr)
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_sysctl_trampoline), uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
+	_, _, e1 := syscall_syscall6(libc_sysctl_trampoline_addr, uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_sysctl_trampoline()
+var libc_sysctl_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_sysctl sysctl "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) {
-	_, _, e1 := syscall_syscall6(funcPC(libc_sendfile_trampoline), uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags))
+	_, _, e1 := syscall_syscall6(libc_sendfile_trampoline_addr, uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_sendfile_trampoline()
+var libc_sendfile_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_sendfile sendfile "/usr/lib/libSystem.B.dylib"
 
@@ -740,28 +740,28 @@ func Access(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall_syscall(libc_access_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_access_trampoline()
+var libc_access_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_access access "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Adjtime(delta *Timeval, olddelta *Timeval) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
+	_, _, e1 := syscall_syscall(libc_adjtime_trampoline_addr, uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_adjtime_trampoline()
+var libc_adjtime_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_adjtime adjtime "/usr/lib/libSystem.B.dylib"
 
@@ -773,14 +773,14 @@ func Chdir(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall_syscall(libc_chdir_trampoline_addr, uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_chdir_trampoline()
+var libc_chdir_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_chdir chdir "/usr/lib/libSystem.B.dylib"
 
@@ -792,14 +792,14 @@ func Chflags(path string, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
+	_, _, e1 := syscall_syscall(libc_chflags_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_chflags_trampoline()
+var libc_chflags_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_chflags chflags "/usr/lib/libSystem.B.dylib"
 
@@ -811,14 +811,14 @@ func Chmod(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall_syscall(libc_chmod_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_chmod_trampoline()
+var libc_chmod_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_chmod chmod "/usr/lib/libSystem.B.dylib"
 
@@ -830,14 +830,14 @@ func Chown(path string, uid int, gid int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
+	_, _, e1 := syscall_syscall(libc_chown_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_chown_trampoline()
+var libc_chown_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_chown chown "/usr/lib/libSystem.B.dylib"
 
@@ -849,42 +849,42 @@ func Chroot(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall_syscall(libc_chroot_trampoline_addr, uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_chroot_trampoline()
+var libc_chroot_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_chroot chroot "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func ClockGettime(clockid int32, time *Timespec) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_clock_gettime_trampoline), uintptr(clockid), uintptr(unsafe.Pointer(time)), 0)
+	_, _, e1 := syscall_syscall(libc_clock_gettime_trampoline_addr, uintptr(clockid), uintptr(unsafe.Pointer(time)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_clock_gettime_trampoline()
+var libc_clock_gettime_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_clock_gettime clock_gettime "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Close(fd int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_close_trampoline), uintptr(fd), 0, 0)
+	_, _, e1 := syscall_syscall(libc_close_trampoline_addr, uintptr(fd), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_close_trampoline()
+var libc_close_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_close close "/usr/lib/libSystem.B.dylib"
 
@@ -901,14 +901,14 @@ func Clonefile(src string, dst string, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_clonefile_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flags))
+	_, _, e1 := syscall_syscall(libc_clonefile_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flags))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_clonefile_trampoline()
+var libc_clonefile_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_clonefile clonefile "/usr/lib/libSystem.B.dylib"
 
@@ -925,21 +925,21 @@ func Clonefileat(srcDirfd int, src string, dstDirfd int, dst string, flags int)
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_clonefileat_trampoline), uintptr(srcDirfd), uintptr(unsafe.Pointer(_p0)), uintptr(dstDirfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
+	_, _, e1 := syscall_syscall6(libc_clonefileat_trampoline_addr, uintptr(srcDirfd), uintptr(unsafe.Pointer(_p0)), uintptr(dstDirfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_clonefileat_trampoline()
+var libc_clonefileat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_clonefileat clonefileat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Dup(fd int) (nfd int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_dup_trampoline), uintptr(fd), 0, 0)
+	r0, _, e1 := syscall_syscall(libc_dup_trampoline_addr, uintptr(fd), 0, 0)
 	nfd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -947,21 +947,21 @@ func Dup(fd int) (nfd int, err error) {
 	return
 }
 
-func libc_dup_trampoline()
+var libc_dup_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_dup dup "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Dup2(from int, to int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_dup2_trampoline), uintptr(from), uintptr(to), 0)
+	_, _, e1 := syscall_syscall(libc_dup2_trampoline_addr, uintptr(from), uintptr(to), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_dup2_trampoline()
+var libc_dup2_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_dup2 dup2 "/usr/lib/libSystem.B.dylib"
 
@@ -978,25 +978,25 @@ func Exchangedata(path1 string, path2 string, options int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_exchangedata_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
+	_, _, e1 := syscall_syscall(libc_exchangedata_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_exchangedata_trampoline()
+var libc_exchangedata_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_exchangedata exchangedata "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Exit(code int) {
-	syscall_syscall(funcPC(libc_exit_trampoline), uintptr(code), 0, 0)
+	syscall_syscall(libc_exit_trampoline_addr, uintptr(code), 0, 0)
 	return
 }
 
-func libc_exit_trampoline()
+var libc_exit_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_exit exit "/usr/lib/libSystem.B.dylib"
 
@@ -1008,56 +1008,56 @@ func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_faccessat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
+	_, _, e1 := syscall_syscall6(libc_faccessat_trampoline_addr, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_faccessat_trampoline()
+var libc_faccessat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_faccessat faccessat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchdir(fd int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fchdir_trampoline), uintptr(fd), 0, 0)
+	_, _, e1 := syscall_syscall(libc_fchdir_trampoline_addr, uintptr(fd), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fchdir_trampoline()
+var libc_fchdir_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fchdir fchdir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchflags(fd int, flags int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fchflags_trampoline), uintptr(fd), uintptr(flags), 0)
+	_, _, e1 := syscall_syscall(libc_fchflags_trampoline_addr, uintptr(fd), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fchflags_trampoline()
+var libc_fchflags_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fchflags fchflags "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchmod(fd int, mode uint32) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fchmod_trampoline), uintptr(fd), uintptr(mode), 0)
+	_, _, e1 := syscall_syscall(libc_fchmod_trampoline_addr, uintptr(fd), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fchmod_trampoline()
+var libc_fchmod_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fchmod fchmod "/usr/lib/libSystem.B.dylib"
 
@@ -1069,28 +1069,28 @@ func Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_fchmodat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
+	_, _, e1 := syscall_syscall6(libc_fchmodat_trampoline_addr, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fchmodat_trampoline()
+var libc_fchmodat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fchmodat fchmodat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fchown(fd int, uid int, gid int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fchown_trampoline), uintptr(fd), uintptr(uid), uintptr(gid))
+	_, _, e1 := syscall_syscall(libc_fchown_trampoline_addr, uintptr(fd), uintptr(uid), uintptr(gid))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fchown_trampoline()
+var libc_fchown_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fchown fchown "/usr/lib/libSystem.B.dylib"
 
@@ -1102,14 +1102,14 @@ func Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_fchownat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
+	_, _, e1 := syscall_syscall6(libc_fchownat_trampoline_addr, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fchownat_trampoline()
+var libc_fchownat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fchownat fchownat "/usr/lib/libSystem.B.dylib"
 
@@ -1121,35 +1121,35 @@ func Fclonefileat(srcDirfd int, dstDirfd int, dst string, flags int) (err error)
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_fclonefileat_trampoline), uintptr(srcDirfd), uintptr(dstDirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0, 0)
+	_, _, e1 := syscall_syscall6(libc_fclonefileat_trampoline_addr, uintptr(srcDirfd), uintptr(dstDirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fclonefileat_trampoline()
+var libc_fclonefileat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fclonefileat fclonefileat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Flock(fd int, how int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_flock_trampoline), uintptr(fd), uintptr(how), 0)
+	_, _, e1 := syscall_syscall(libc_flock_trampoline_addr, uintptr(fd), uintptr(how), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_flock_trampoline()
+var libc_flock_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_flock flock "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fpathconf(fd int, name int) (val int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_fpathconf_trampoline), uintptr(fd), uintptr(name), 0)
+	r0, _, e1 := syscall_syscall(libc_fpathconf_trampoline_addr, uintptr(fd), uintptr(name), 0)
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1157,35 +1157,35 @@ func Fpathconf(fd int, name int) (val int, err error) {
 	return
 }
 
-func libc_fpathconf_trampoline()
+var libc_fpathconf_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fpathconf fpathconf "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fsync(fd int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fsync_trampoline), uintptr(fd), 0, 0)
+	_, _, e1 := syscall_syscall(libc_fsync_trampoline_addr, uintptr(fd), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fsync_trampoline()
+var libc_fsync_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fsync fsync "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Ftruncate(fd int, length int64) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_ftruncate_trampoline), uintptr(fd), uintptr(length), 0)
+	_, _, e1 := syscall_syscall(libc_ftruncate_trampoline_addr, uintptr(fd), uintptr(length), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_ftruncate_trampoline()
+var libc_ftruncate_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_ftruncate ftruncate "/usr/lib/libSystem.B.dylib"
 
@@ -1198,7 +1198,7 @@ func Getcwd(buf []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall_syscall(funcPC(libc_getcwd_trampoline), uintptr(_p0), uintptr(len(buf)), 0)
+	r0, _, e1 := syscall_syscall(libc_getcwd_trampoline_addr, uintptr(_p0), uintptr(len(buf)), 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1206,62 +1206,62 @@ func Getcwd(buf []byte) (n int, err error) {
 	return
 }
 
-func libc_getcwd_trampoline()
+var libc_getcwd_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getcwd getcwd "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getdtablesize() (size int) {
-	r0, _, _ := syscall_syscall(funcPC(libc_getdtablesize_trampoline), 0, 0, 0)
+	r0, _, _ := syscall_syscall(libc_getdtablesize_trampoline_addr, 0, 0, 0)
 	size = int(r0)
 	return
 }
 
-func libc_getdtablesize_trampoline()
+var libc_getdtablesize_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getdtablesize getdtablesize "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getegid() (egid int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_getegid_trampoline), 0, 0, 0)
+	r0, _, _ := syscall_rawSyscall(libc_getegid_trampoline_addr, 0, 0, 0)
 	egid = int(r0)
 	return
 }
 
-func libc_getegid_trampoline()
+var libc_getegid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getegid getegid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Geteuid() (uid int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_geteuid_trampoline), 0, 0, 0)
+	r0, _, _ := syscall_rawSyscall(libc_geteuid_trampoline_addr, 0, 0, 0)
 	uid = int(r0)
 	return
 }
 
-func libc_geteuid_trampoline()
+var libc_geteuid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_geteuid geteuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getgid() (gid int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_getgid_trampoline), 0, 0, 0)
+	r0, _, _ := syscall_rawSyscall(libc_getgid_trampoline_addr, 0, 0, 0)
 	gid = int(r0)
 	return
 }
 
-func libc_getgid_trampoline()
+var libc_getgid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getgid getgid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpgid(pid int) (pgid int, err error) {
-	r0, _, e1 := syscall_rawSyscall(funcPC(libc_getpgid_trampoline), uintptr(pid), 0, 0)
+	r0, _, e1 := syscall_rawSyscall(libc_getpgid_trampoline_addr, uintptr(pid), 0, 0)
 	pgid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1269,50 +1269,50 @@ func Getpgid(pid int) (pgid int, err error) {
 	return
 }
 
-func libc_getpgid_trampoline()
+var libc_getpgid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getpgid getpgid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpgrp() (pgrp int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_getpgrp_trampoline), 0, 0, 0)
+	r0, _, _ := syscall_rawSyscall(libc_getpgrp_trampoline_addr, 0, 0, 0)
 	pgrp = int(r0)
 	return
 }
 
-func libc_getpgrp_trampoline()
+var libc_getpgrp_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getpgrp getpgrp "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpid() (pid int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_getpid_trampoline), 0, 0, 0)
+	r0, _, _ := syscall_rawSyscall(libc_getpid_trampoline_addr, 0, 0, 0)
 	pid = int(r0)
 	return
 }
 
-func libc_getpid_trampoline()
+var libc_getpid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getpid getpid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getppid() (ppid int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_getppid_trampoline), 0, 0, 0)
+	r0, _, _ := syscall_rawSyscall(libc_getppid_trampoline_addr, 0, 0, 0)
 	ppid = int(r0)
 	return
 }
 
-func libc_getppid_trampoline()
+var libc_getppid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getppid getppid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getpriority(which int, who int) (prio int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_getpriority_trampoline), uintptr(which), uintptr(who), 0)
+	r0, _, e1 := syscall_syscall(libc_getpriority_trampoline_addr, uintptr(which), uintptr(who), 0)
 	prio = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1320,42 +1320,42 @@ func Getpriority(which int, who int) (prio int, err error) {
 	return
 }
 
-func libc_getpriority_trampoline()
+var libc_getpriority_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getpriority getpriority "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getrlimit(which int, lim *Rlimit) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
+	_, _, e1 := syscall_rawSyscall(libc_getrlimit_trampoline_addr, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_getrlimit_trampoline()
+var libc_getrlimit_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getrlimit getrlimit "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getrusage(who int, rusage *Rusage) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
+	_, _, e1 := syscall_rawSyscall(libc_getrusage_trampoline_addr, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_getrusage_trampoline()
+var libc_getrusage_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getrusage getrusage "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getsid(pid int) (sid int, err error) {
-	r0, _, e1 := syscall_rawSyscall(funcPC(libc_getsid_trampoline), uintptr(pid), 0, 0)
+	r0, _, e1 := syscall_rawSyscall(libc_getsid_trampoline_addr, uintptr(pid), 0, 0)
 	sid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1363,52 +1363,52 @@ func Getsid(pid int) (sid int, err error) {
 	return
 }
 
-func libc_getsid_trampoline()
+var libc_getsid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getsid getsid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Gettimeofday(tp *Timeval) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
+	_, _, e1 := syscall_rawSyscall(libc_gettimeofday_trampoline_addr, uintptr(unsafe.Pointer(tp)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_gettimeofday_trampoline()
+var libc_gettimeofday_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_gettimeofday gettimeofday "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Getuid() (uid int) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_getuid_trampoline), 0, 0, 0)
+	r0, _, _ := syscall_rawSyscall(libc_getuid_trampoline_addr, 0, 0, 0)
 	uid = int(r0)
 	return
 }
 
-func libc_getuid_trampoline()
+var libc_getuid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getuid getuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Issetugid() (tainted bool) {
-	r0, _, _ := syscall_rawSyscall(funcPC(libc_issetugid_trampoline), 0, 0, 0)
+	r0, _, _ := syscall_rawSyscall(libc_issetugid_trampoline_addr, 0, 0, 0)
 	tainted = bool(r0 != 0)
 	return
 }
 
-func libc_issetugid_trampoline()
+var libc_issetugid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_issetugid issetugid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Kqueue() (fd int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_kqueue_trampoline), 0, 0, 0)
+	r0, _, e1 := syscall_syscall(libc_kqueue_trampoline_addr, 0, 0, 0)
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1416,7 +1416,7 @@ func Kqueue() (fd int, err error) {
 	return
 }
 
-func libc_kqueue_trampoline()
+var libc_kqueue_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_kqueue kqueue "/usr/lib/libSystem.B.dylib"
 
@@ -1428,14 +1428,14 @@ func Lchown(path string, uid int, gid int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
+	_, _, e1 := syscall_syscall(libc_lchown_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_lchown_trampoline()
+var libc_lchown_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_lchown lchown "/usr/lib/libSystem.B.dylib"
 
@@ -1452,14 +1452,14 @@ func Link(path string, link string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	_, _, e1 := syscall_syscall(libc_link_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_link_trampoline()
+var libc_link_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_link link "/usr/lib/libSystem.B.dylib"
 
@@ -1476,28 +1476,28 @@ func Linkat(pathfd int, path string, linkfd int, link string, flags int) (err er
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_linkat_trampoline), uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
+	_, _, e1 := syscall_syscall6(libc_linkat_trampoline_addr, uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_linkat_trampoline()
+var libc_linkat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_linkat linkat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Listen(s int, backlog int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_listen_trampoline), uintptr(s), uintptr(backlog), 0)
+	_, _, e1 := syscall_syscall(libc_listen_trampoline_addr, uintptr(s), uintptr(backlog), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_listen_trampoline()
+var libc_listen_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_listen listen "/usr/lib/libSystem.B.dylib"
 
@@ -1509,14 +1509,14 @@ func Mkdir(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall_syscall(libc_mkdir_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_mkdir_trampoline()
+var libc_mkdir_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_mkdir mkdir "/usr/lib/libSystem.B.dylib"
 
@@ -1528,14 +1528,14 @@ func Mkdirat(dirfd int, path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_mkdirat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
+	_, _, e1 := syscall_syscall(libc_mkdirat_trampoline_addr, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_mkdirat_trampoline()
+var libc_mkdirat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_mkdirat mkdirat "/usr/lib/libSystem.B.dylib"
 
@@ -1547,14 +1547,14 @@ func Mkfifo(path string, mode uint32) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	_, _, e1 := syscall_syscall(libc_mkfifo_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_mkfifo_trampoline()
+var libc_mkfifo_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_mkfifo mkfifo "/usr/lib/libSystem.B.dylib"
 
@@ -1566,14 +1566,14 @@ func Mknod(path string, mode uint32, dev int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
+	_, _, e1 := syscall_syscall(libc_mknod_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_mknod_trampoline()
+var libc_mknod_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_mknod mknod "/usr/lib/libSystem.B.dylib"
 
@@ -1585,7 +1585,7 @@ func Open(path string, mode int, perm uint32) (fd int, err error) {
 	if err != nil {
 		return
 	}
-	r0, _, e1 := syscall_syscall(funcPC(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
+	r0, _, e1 := syscall_syscall(libc_open_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1593,7 +1593,7 @@ func Open(path string, mode int, perm uint32) (fd int, err error) {
 	return
 }
 
-func libc_open_trampoline()
+var libc_open_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_open open "/usr/lib/libSystem.B.dylib"
 
@@ -1605,7 +1605,7 @@ func Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error) {
 	if err != nil {
 		return
 	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_openat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0)
+	r0, _, e1 := syscall_syscall6(libc_openat_trampoline_addr, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0)
 	fd = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1613,7 +1613,7 @@ func Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error) {
 	return
 }
 
-func libc_openat_trampoline()
+var libc_openat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_openat openat "/usr/lib/libSystem.B.dylib"
 
@@ -1625,7 +1625,7 @@ func Pathconf(path string, name int) (val int, err error) {
 	if err != nil {
 		return
 	}
-	r0, _, e1 := syscall_syscall(funcPC(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
+	r0, _, e1 := syscall_syscall(libc_pathconf_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
 	val = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1633,7 +1633,7 @@ func Pathconf(path string, name int) (val int, err error) {
 	return
 }
 
-func libc_pathconf_trampoline()
+var libc_pathconf_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_pathconf pathconf "/usr/lib/libSystem.B.dylib"
 
@@ -1646,7 +1646,7 @@ func Pread(fd int, p []byte, offset int64) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_pread_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
+	r0, _, e1 := syscall_syscall6(libc_pread_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1654,7 +1654,7 @@ func Pread(fd int, p []byte, offset int64) (n int, err error) {
 	return
 }
 
-func libc_pread_trampoline()
+var libc_pread_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_pread pread "/usr/lib/libSystem.B.dylib"
 
@@ -1667,7 +1667,7 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_pwrite_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
+	r0, _, e1 := syscall_syscall6(libc_pwrite_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1675,7 +1675,7 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
 	return
 }
 
-func libc_pwrite_trampoline()
+var libc_pwrite_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_pwrite pwrite "/usr/lib/libSystem.B.dylib"
 
@@ -1688,7 +1688,7 @@ func read(fd int, p []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall_syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
+	r0, _, e1 := syscall_syscall(libc_read_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(p)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1696,7 +1696,7 @@ func read(fd int, p []byte) (n int, err error) {
 	return
 }
 
-func libc_read_trampoline()
+var libc_read_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_read read "/usr/lib/libSystem.B.dylib"
 
@@ -1714,7 +1714,7 @@ func Readlink(path string, buf []byte) (n int, err error) {
 	} else {
 		_p1 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall_syscall(funcPC(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
+	r0, _, e1 := syscall_syscall(libc_readlink_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1722,7 +1722,7 @@ func Readlink(path string, buf []byte) (n int, err error) {
 	return
 }
 
-func libc_readlink_trampoline()
+var libc_readlink_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_readlink readlink "/usr/lib/libSystem.B.dylib"
 
@@ -1740,7 +1740,7 @@ func Readlinkat(dirfd int, path string, buf []byte) (n int, err error) {
 	} else {
 		_p1 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall_syscall6(funcPC(libc_readlinkat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
+	r0, _, e1 := syscall_syscall6(libc_readlinkat_trampoline_addr, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1748,7 +1748,7 @@ func Readlinkat(dirfd int, path string, buf []byte) (n int, err error) {
 	return
 }
 
-func libc_readlinkat_trampoline()
+var libc_readlinkat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_readlinkat readlinkat "/usr/lib/libSystem.B.dylib"
 
@@ -1765,14 +1765,14 @@ func Rename(from string, to string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	_, _, e1 := syscall_syscall(libc_rename_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_rename_trampoline()
+var libc_rename_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_rename rename "/usr/lib/libSystem.B.dylib"
 
@@ -1789,14 +1789,14 @@ func Renameat(fromfd int, from string, tofd int, to string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_renameat_trampoline), uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), 0, 0)
+	_, _, e1 := syscall_syscall6(libc_renameat_trampoline_addr, uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_renameat_trampoline()
+var libc_renameat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_renameat renameat "/usr/lib/libSystem.B.dylib"
 
@@ -1808,14 +1808,14 @@ func Revoke(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall_syscall(libc_revoke_trampoline_addr, uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_revoke_trampoline()
+var libc_revoke_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_revoke revoke "/usr/lib/libSystem.B.dylib"
 
@@ -1827,21 +1827,21 @@ func Rmdir(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall_syscall(libc_rmdir_trampoline_addr, uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_rmdir_trampoline()
+var libc_rmdir_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_rmdir rmdir "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_lseek_trampoline), uintptr(fd), uintptr(offset), uintptr(whence))
+	r0, _, e1 := syscall_syscall(libc_lseek_trampoline_addr, uintptr(fd), uintptr(offset), uintptr(whence))
 	newoffset = int64(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1849,14 +1849,14 @@ func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
 	return
 }
 
-func libc_lseek_trampoline()
+var libc_lseek_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_lseek lseek "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error) {
-	r0, _, e1 := syscall_syscall6(funcPC(libc_select_trampoline), uintptr(nfd), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
+	r0, _, e1 := syscall_syscall6(libc_select_trampoline_addr, uintptr(nfd), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -1864,49 +1864,49 @@ func Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err
 	return
 }
 
-func libc_select_trampoline()
+var libc_select_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_select select "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setegid(egid int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_setegid_trampoline), uintptr(egid), 0, 0)
+	_, _, e1 := syscall_syscall(libc_setegid_trampoline_addr, uintptr(egid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setegid_trampoline()
+var libc_setegid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setegid setegid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Seteuid(euid int) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_seteuid_trampoline), uintptr(euid), 0, 0)
+	_, _, e1 := syscall_rawSyscall(libc_seteuid_trampoline_addr, uintptr(euid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_seteuid_trampoline()
+var libc_seteuid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_seteuid seteuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setgid(gid int) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setgid_trampoline), uintptr(gid), 0, 0)
+	_, _, e1 := syscall_rawSyscall(libc_setgid_trampoline_addr, uintptr(gid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setgid_trampoline()
+var libc_setgid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setgid setgid "/usr/lib/libSystem.B.dylib"
 
@@ -1918,105 +1918,105 @@ func Setlogin(name string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall_syscall(libc_setlogin_trampoline_addr, uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setlogin_trampoline()
+var libc_setlogin_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setlogin setlogin "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setpgid(pid int, pgid int) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setpgid_trampoline), uintptr(pid), uintptr(pgid), 0)
+	_, _, e1 := syscall_rawSyscall(libc_setpgid_trampoline_addr, uintptr(pid), uintptr(pgid), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setpgid_trampoline()
+var libc_setpgid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setpgid setpgid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setpriority(which int, who int, prio int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_setpriority_trampoline), uintptr(which), uintptr(who), uintptr(prio))
+	_, _, e1 := syscall_syscall(libc_setpriority_trampoline_addr, uintptr(which), uintptr(who), uintptr(prio))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setpriority_trampoline()
+var libc_setpriority_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setpriority setpriority "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setprivexec(flag int) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_setprivexec_trampoline), uintptr(flag), 0, 0)
+	_, _, e1 := syscall_syscall(libc_setprivexec_trampoline_addr, uintptr(flag), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setprivexec_trampoline()
+var libc_setprivexec_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setprivexec setprivexec "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setregid(rgid int, egid int) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setregid_trampoline), uintptr(rgid), uintptr(egid), 0)
+	_, _, e1 := syscall_rawSyscall(libc_setregid_trampoline_addr, uintptr(rgid), uintptr(egid), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setregid_trampoline()
+var libc_setregid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setregid setregid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setreuid(ruid int, euid int) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setreuid_trampoline), uintptr(ruid), uintptr(euid), 0)
+	_, _, e1 := syscall_rawSyscall(libc_setreuid_trampoline_addr, uintptr(ruid), uintptr(euid), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setreuid_trampoline()
+var libc_setreuid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setreuid setreuid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setrlimit(which int, lim *Rlimit) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
+	_, _, e1 := syscall_rawSyscall(libc_setrlimit_trampoline_addr, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setrlimit_trampoline()
+var libc_setrlimit_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setrlimit setrlimit "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setsid() (pid int, err error) {
-	r0, _, e1 := syscall_rawSyscall(funcPC(libc_setsid_trampoline), 0, 0, 0)
+	r0, _, e1 := syscall_rawSyscall(libc_setsid_trampoline_addr, 0, 0, 0)
 	pid = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -2024,35 +2024,35 @@ func Setsid() (pid int, err error) {
 	return
 }
 
-func libc_setsid_trampoline()
+var libc_setsid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setsid setsid "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Settimeofday(tp *Timeval) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
+	_, _, e1 := syscall_rawSyscall(libc_settimeofday_trampoline_addr, uintptr(unsafe.Pointer(tp)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_settimeofday_trampoline()
+var libc_settimeofday_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_settimeofday settimeofday "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Setuid(uid int) (err error) {
-	_, _, e1 := syscall_rawSyscall(funcPC(libc_setuid_trampoline), uintptr(uid), 0, 0)
+	_, _, e1 := syscall_rawSyscall(libc_setuid_trampoline_addr, uintptr(uid), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_setuid_trampoline()
+var libc_setuid_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_setuid setuid "/usr/lib/libSystem.B.dylib"
 
@@ -2069,14 +2069,14 @@ func Symlink(path string, link string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
+	_, _, e1 := syscall_syscall(libc_symlink_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_symlink_trampoline()
+var libc_symlink_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_symlink symlink "/usr/lib/libSystem.B.dylib"
 
@@ -2093,28 +2093,28 @@ func Symlinkat(oldpath string, newdirfd int, newpath string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_symlinkat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
+	_, _, e1 := syscall_syscall(libc_symlinkat_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_symlinkat_trampoline()
+var libc_symlinkat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_symlinkat symlinkat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Sync() (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_sync_trampoline), 0, 0, 0)
+	_, _, e1 := syscall_syscall(libc_sync_trampoline_addr, 0, 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_sync_trampoline()
+var libc_sync_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_sync sync "/usr/lib/libSystem.B.dylib"
 
@@ -2126,26 +2126,26 @@ func Truncate(path string, length int64) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
+	_, _, e1 := syscall_syscall(libc_truncate_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_truncate_trampoline()
+var libc_truncate_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_truncate truncate "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Umask(newmask int) (oldmask int) {
-	r0, _, _ := syscall_syscall(funcPC(libc_umask_trampoline), uintptr(newmask), 0, 0)
+	r0, _, _ := syscall_syscall(libc_umask_trampoline_addr, uintptr(newmask), 0, 0)
 	oldmask = int(r0)
 	return
 }
 
-func libc_umask_trampoline()
+var libc_umask_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_umask umask "/usr/lib/libSystem.B.dylib"
 
@@ -2157,14 +2157,14 @@ func Undelete(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_undelete_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall_syscall(libc_undelete_trampoline_addr, uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_undelete_trampoline()
+var libc_undelete_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_undelete undelete "/usr/lib/libSystem.B.dylib"
 
@@ -2176,14 +2176,14 @@ func Unlink(path string) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
+	_, _, e1 := syscall_syscall(libc_unlink_trampoline_addr, uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_unlink_trampoline()
+var libc_unlink_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_unlink unlink "/usr/lib/libSystem.B.dylib"
 
@@ -2195,14 +2195,14 @@ func Unlinkat(dirfd int, path string, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_unlinkat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
+	_, _, e1 := syscall_syscall(libc_unlinkat_trampoline_addr, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_unlinkat_trampoline()
+var libc_unlinkat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_unlinkat unlinkat "/usr/lib/libSystem.B.dylib"
 
@@ -2214,14 +2214,14 @@ func Unmount(path string, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
+	_, _, e1 := syscall_syscall(libc_unmount_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_unmount_trampoline()
+var libc_unmount_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_unmount unmount "/usr/lib/libSystem.B.dylib"
 
@@ -2234,7 +2234,7 @@ func write(fd int, p []byte) (n int, err error) {
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
-	r0, _, e1 := syscall_syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
+	r0, _, e1 := syscall_syscall(libc_write_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(p)))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -2242,14 +2242,14 @@ func write(fd int, p []byte) (n int, err error) {
 	return
 }
 
-func libc_write_trampoline()
+var libc_write_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_write write "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
-	r0, _, e1 := syscall_syscall6(funcPC(libc_mmap_trampoline), uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
+	r0, _, e1 := syscall_syscall6(libc_mmap_trampoline_addr, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
 	ret = uintptr(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -2257,28 +2257,28 @@ func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (
 	return
 }
 
-func libc_mmap_trampoline()
+var libc_mmap_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_mmap mmap "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func munmap(addr uintptr, length uintptr) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_munmap_trampoline), uintptr(addr), uintptr(length), 0)
+	_, _, e1 := syscall_syscall(libc_munmap_trampoline_addr, uintptr(addr), uintptr(length), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_munmap_trampoline()
+var libc_munmap_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_munmap munmap "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
+	r0, _, e1 := syscall_syscall(libc_read_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -2289,7 +2289,7 @@ func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
+	r0, _, e1 := syscall_syscall(libc_write_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -2300,14 +2300,14 @@ func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fstat(fd int, stat *Stat_t) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fstat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall_syscall(libc_fstat_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fstat_trampoline()
+var libc_fstat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fstat fstat "/usr/lib/libSystem.B.dylib"
 
@@ -2319,35 +2319,35 @@ func Fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall6(funcPC(libc_fstatat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
+	_, _, e1 := syscall_syscall6(libc_fstatat_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fstatat_trampoline()
+var libc_fstatat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fstatat fstatat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fstatfs(fd int, stat *Statfs_t) (err error) {
-	_, _, e1 := syscall_syscall(funcPC(libc_fstatfs_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall_syscall(libc_fstatfs_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_fstatfs_trampoline()
+var libc_fstatfs_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_fstatfs fstatfs "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) {
-	r0, _, e1 := syscall_syscall(funcPC(libc_getfsstat_trampoline), uintptr(buf), uintptr(size), uintptr(flags))
+	r0, _, e1 := syscall_syscall(libc_getfsstat_trampoline_addr, uintptr(buf), uintptr(size), uintptr(flags))
 	n = int(r0)
 	if e1 != 0 {
 		err = errnoErr(e1)
@@ -2355,7 +2355,7 @@ func getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) {
 	return
 }
 
-func libc_getfsstat_trampoline()
+var libc_getfsstat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_getfsstat getfsstat "/usr/lib/libSystem.B.dylib"
 
@@ -2367,28 +2367,28 @@ func Lstat(path string, stat *Stat_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_lstat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall_syscall(libc_lstat_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_lstat_trampoline()
+var libc_lstat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_lstat lstat "/usr/lib/libSystem.B.dylib"
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func ptrace1(request int, pid int, addr uintptr, data uintptr) (err error) {
-	_, _, e1 := syscall_syscall6(funcPC(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
+	_, _, e1 := syscall_syscall6(libc_ptrace_trampoline_addr, uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_ptrace_trampoline()
+var libc_ptrace_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_ptrace ptrace "/usr/lib/libSystem.B.dylib"
 
@@ -2400,14 +2400,14 @@ func Stat(path string, stat *Stat_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_stat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall_syscall(libc_stat_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_stat_trampoline()
+var libc_stat_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_stat stat "/usr/lib/libSystem.B.dylib"
 
@@ -2419,13 +2419,13 @@ func Statfs(path string, stat *Statfs_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := syscall_syscall(funcPC(libc_statfs_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := syscall_syscall(libc_statfs_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
 	return
 }
 
-func libc_statfs_trampoline()
+var libc_statfs_trampoline_addr uintptr
 
 //go:cgo_import_dynamic libc_statfs statfs "/usr/lib/libSystem.B.dylib"
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s
index e30a697407..33e19776db 100644
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s
+++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s
@@ -5,287 +5,855 @@
 // +build go1.12
 
 #include "textflag.h"
-TEXT ·libc_getgroups_trampoline(SB),NOSPLIT,$0-0
+
+TEXT libc_getgroups_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getgroups(SB)
-TEXT ·libc_setgroups_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getgroups_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getgroups_trampoline_addr(SB)/8, $libc_getgroups_trampoline<>(SB)
+
+TEXT libc_setgroups_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setgroups(SB)
-TEXT ·libc_wait4_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setgroups_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setgroups_trampoline_addr(SB)/8, $libc_setgroups_trampoline<>(SB)
+
+TEXT libc_wait4_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_wait4(SB)
-TEXT ·libc_accept_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_wait4_trampoline_addr(SB), RODATA, $8
+DATA	·libc_wait4_trampoline_addr(SB)/8, $libc_wait4_trampoline<>(SB)
+
+TEXT libc_accept_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_accept(SB)
-TEXT ·libc_bind_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_accept_trampoline_addr(SB), RODATA, $8
+DATA	·libc_accept_trampoline_addr(SB)/8, $libc_accept_trampoline<>(SB)
+
+TEXT libc_bind_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_bind(SB)
-TEXT ·libc_connect_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_bind_trampoline_addr(SB), RODATA, $8
+DATA	·libc_bind_trampoline_addr(SB)/8, $libc_bind_trampoline<>(SB)
+
+TEXT libc_connect_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_connect(SB)
-TEXT ·libc_socket_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_connect_trampoline_addr(SB), RODATA, $8
+DATA	·libc_connect_trampoline_addr(SB)/8, $libc_connect_trampoline<>(SB)
+
+TEXT libc_socket_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_socket(SB)
-TEXT ·libc_getsockopt_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_socket_trampoline_addr(SB), RODATA, $8
+DATA	·libc_socket_trampoline_addr(SB)/8, $libc_socket_trampoline<>(SB)
+
+TEXT libc_getsockopt_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getsockopt(SB)
-TEXT ·libc_setsockopt_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getsockopt_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getsockopt_trampoline_addr(SB)/8, $libc_getsockopt_trampoline<>(SB)
+
+TEXT libc_setsockopt_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setsockopt(SB)
-TEXT ·libc_getpeername_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setsockopt_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setsockopt_trampoline_addr(SB)/8, $libc_setsockopt_trampoline<>(SB)
+
+TEXT libc_getpeername_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getpeername(SB)
-TEXT ·libc_getsockname_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getpeername_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getpeername_trampoline_addr(SB)/8, $libc_getpeername_trampoline<>(SB)
+
+TEXT libc_getsockname_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getsockname(SB)
-TEXT ·libc_shutdown_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getsockname_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getsockname_trampoline_addr(SB)/8, $libc_getsockname_trampoline<>(SB)
+
+TEXT libc_shutdown_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_shutdown(SB)
-TEXT ·libc_socketpair_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_shutdown_trampoline_addr(SB), RODATA, $8
+DATA	·libc_shutdown_trampoline_addr(SB)/8, $libc_shutdown_trampoline<>(SB)
+
+TEXT libc_socketpair_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_socketpair(SB)
-TEXT ·libc_recvfrom_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_socketpair_trampoline_addr(SB), RODATA, $8
+DATA	·libc_socketpair_trampoline_addr(SB)/8, $libc_socketpair_trampoline<>(SB)
+
+TEXT libc_recvfrom_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_recvfrom(SB)
-TEXT ·libc_sendto_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_recvfrom_trampoline_addr(SB), RODATA, $8
+DATA	·libc_recvfrom_trampoline_addr(SB)/8, $libc_recvfrom_trampoline<>(SB)
+
+TEXT libc_sendto_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_sendto(SB)
-TEXT ·libc_recvmsg_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_sendto_trampoline_addr(SB), RODATA, $8
+DATA	·libc_sendto_trampoline_addr(SB)/8, $libc_sendto_trampoline<>(SB)
+
+TEXT libc_recvmsg_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_recvmsg(SB)
-TEXT ·libc_sendmsg_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_recvmsg_trampoline_addr(SB), RODATA, $8
+DATA	·libc_recvmsg_trampoline_addr(SB)/8, $libc_recvmsg_trampoline<>(SB)
+
+TEXT libc_sendmsg_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_sendmsg(SB)
-TEXT ·libc_kevent_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_sendmsg_trampoline_addr(SB), RODATA, $8
+DATA	·libc_sendmsg_trampoline_addr(SB)/8, $libc_sendmsg_trampoline<>(SB)
+
+TEXT libc_kevent_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_kevent(SB)
-TEXT ·libc_utimes_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_kevent_trampoline_addr(SB), RODATA, $8
+DATA	·libc_kevent_trampoline_addr(SB)/8, $libc_kevent_trampoline<>(SB)
+
+TEXT libc_utimes_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_utimes(SB)
-TEXT ·libc_futimes_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_utimes_trampoline_addr(SB), RODATA, $8
+DATA	·libc_utimes_trampoline_addr(SB)/8, $libc_utimes_trampoline<>(SB)
+
+TEXT libc_futimes_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_futimes(SB)
-TEXT ·libc_poll_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_futimes_trampoline_addr(SB), RODATA, $8
+DATA	·libc_futimes_trampoline_addr(SB)/8, $libc_futimes_trampoline<>(SB)
+
+TEXT libc_poll_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_poll(SB)
-TEXT ·libc_madvise_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_poll_trampoline_addr(SB), RODATA, $8
+DATA	·libc_poll_trampoline_addr(SB)/8, $libc_poll_trampoline<>(SB)
+
+TEXT libc_madvise_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_madvise(SB)
-TEXT ·libc_mlock_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_madvise_trampoline_addr(SB), RODATA, $8
+DATA	·libc_madvise_trampoline_addr(SB)/8, $libc_madvise_trampoline<>(SB)
+
+TEXT libc_mlock_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_mlock(SB)
-TEXT ·libc_mlockall_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_mlock_trampoline_addr(SB), RODATA, $8
+DATA	·libc_mlock_trampoline_addr(SB)/8, $libc_mlock_trampoline<>(SB)
+
+TEXT libc_mlockall_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_mlockall(SB)
-TEXT ·libc_mprotect_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_mlockall_trampoline_addr(SB), RODATA, $8
+DATA	·libc_mlockall_trampoline_addr(SB)/8, $libc_mlockall_trampoline<>(SB)
+
+TEXT libc_mprotect_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_mprotect(SB)
-TEXT ·libc_msync_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_mprotect_trampoline_addr(SB), RODATA, $8
+DATA	·libc_mprotect_trampoline_addr(SB)/8, $libc_mprotect_trampoline<>(SB)
+
+TEXT libc_msync_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_msync(SB)
-TEXT ·libc_munlock_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_msync_trampoline_addr(SB), RODATA, $8
+DATA	·libc_msync_trampoline_addr(SB)/8, $libc_msync_trampoline<>(SB)
+
+TEXT libc_munlock_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_munlock(SB)
-TEXT ·libc_munlockall_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_munlock_trampoline_addr(SB), RODATA, $8
+DATA	·libc_munlock_trampoline_addr(SB)/8, $libc_munlock_trampoline<>(SB)
+
+TEXT libc_munlockall_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_munlockall(SB)
-TEXT ·libc_pipe_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_munlockall_trampoline_addr(SB), RODATA, $8
+DATA	·libc_munlockall_trampoline_addr(SB)/8, $libc_munlockall_trampoline<>(SB)
+
+TEXT libc_pipe_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_pipe(SB)
-TEXT ·libc_getxattr_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_pipe_trampoline_addr(SB), RODATA, $8
+DATA	·libc_pipe_trampoline_addr(SB)/8, $libc_pipe_trampoline<>(SB)
+
+TEXT libc_getxattr_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getxattr(SB)
-TEXT ·libc_fgetxattr_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getxattr_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getxattr_trampoline_addr(SB)/8, $libc_getxattr_trampoline<>(SB)
+
+TEXT libc_fgetxattr_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fgetxattr(SB)
-TEXT ·libc_setxattr_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fgetxattr_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fgetxattr_trampoline_addr(SB)/8, $libc_fgetxattr_trampoline<>(SB)
+
+TEXT libc_setxattr_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setxattr(SB)
-TEXT ·libc_fsetxattr_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setxattr_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setxattr_trampoline_addr(SB)/8, $libc_setxattr_trampoline<>(SB)
+
+TEXT libc_fsetxattr_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fsetxattr(SB)
-TEXT ·libc_removexattr_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fsetxattr_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fsetxattr_trampoline_addr(SB)/8, $libc_fsetxattr_trampoline<>(SB)
+
+TEXT libc_removexattr_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_removexattr(SB)
-TEXT ·libc_fremovexattr_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_removexattr_trampoline_addr(SB), RODATA, $8
+DATA	·libc_removexattr_trampoline_addr(SB)/8, $libc_removexattr_trampoline<>(SB)
+
+TEXT libc_fremovexattr_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fremovexattr(SB)
-TEXT ·libc_listxattr_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fremovexattr_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fremovexattr_trampoline_addr(SB)/8, $libc_fremovexattr_trampoline<>(SB)
+
+TEXT libc_listxattr_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_listxattr(SB)
-TEXT ·libc_flistxattr_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_listxattr_trampoline_addr(SB), RODATA, $8
+DATA	·libc_listxattr_trampoline_addr(SB)/8, $libc_listxattr_trampoline<>(SB)
+
+TEXT libc_flistxattr_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_flistxattr(SB)
-TEXT ·libc_setattrlist_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_flistxattr_trampoline_addr(SB), RODATA, $8
+DATA	·libc_flistxattr_trampoline_addr(SB)/8, $libc_flistxattr_trampoline<>(SB)
+
+TEXT libc_setattrlist_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setattrlist(SB)
-TEXT ·libc_fcntl_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setattrlist_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setattrlist_trampoline_addr(SB)/8, $libc_setattrlist_trampoline<>(SB)
+
+TEXT libc_fcntl_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fcntl(SB)
-TEXT ·libc_kill_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fcntl_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fcntl_trampoline_addr(SB)/8, $libc_fcntl_trampoline<>(SB)
+
+TEXT libc_kill_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_kill(SB)
-TEXT ·libc_ioctl_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_kill_trampoline_addr(SB), RODATA, $8
+DATA	·libc_kill_trampoline_addr(SB)/8, $libc_kill_trampoline<>(SB)
+
+TEXT libc_ioctl_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_ioctl(SB)
-TEXT ·libc_sysctl_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_ioctl_trampoline_addr(SB), RODATA, $8
+DATA	·libc_ioctl_trampoline_addr(SB)/8, $libc_ioctl_trampoline<>(SB)
+
+TEXT libc_sysctl_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_sysctl(SB)
-TEXT ·libc_sendfile_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_sysctl_trampoline_addr(SB), RODATA, $8
+DATA	·libc_sysctl_trampoline_addr(SB)/8, $libc_sysctl_trampoline<>(SB)
+
+TEXT libc_sendfile_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_sendfile(SB)
-TEXT ·libc_access_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_sendfile_trampoline_addr(SB), RODATA, $8
+DATA	·libc_sendfile_trampoline_addr(SB)/8, $libc_sendfile_trampoline<>(SB)
+
+TEXT libc_access_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_access(SB)
-TEXT ·libc_adjtime_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_access_trampoline_addr(SB), RODATA, $8
+DATA	·libc_access_trampoline_addr(SB)/8, $libc_access_trampoline<>(SB)
+
+TEXT libc_adjtime_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_adjtime(SB)
-TEXT ·libc_chdir_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_adjtime_trampoline_addr(SB), RODATA, $8
+DATA	·libc_adjtime_trampoline_addr(SB)/8, $libc_adjtime_trampoline<>(SB)
+
+TEXT libc_chdir_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_chdir(SB)
-TEXT ·libc_chflags_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_chdir_trampoline_addr(SB), RODATA, $8
+DATA	·libc_chdir_trampoline_addr(SB)/8, $libc_chdir_trampoline<>(SB)
+
+TEXT libc_chflags_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_chflags(SB)
-TEXT ·libc_chmod_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_chflags_trampoline_addr(SB), RODATA, $8
+DATA	·libc_chflags_trampoline_addr(SB)/8, $libc_chflags_trampoline<>(SB)
+
+TEXT libc_chmod_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_chmod(SB)
-TEXT ·libc_chown_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_chmod_trampoline_addr(SB), RODATA, $8
+DATA	·libc_chmod_trampoline_addr(SB)/8, $libc_chmod_trampoline<>(SB)
+
+TEXT libc_chown_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_chown(SB)
-TEXT ·libc_chroot_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_chown_trampoline_addr(SB), RODATA, $8
+DATA	·libc_chown_trampoline_addr(SB)/8, $libc_chown_trampoline<>(SB)
+
+TEXT libc_chroot_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_chroot(SB)
-TEXT ·libc_clock_gettime_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_chroot_trampoline_addr(SB), RODATA, $8
+DATA	·libc_chroot_trampoline_addr(SB)/8, $libc_chroot_trampoline<>(SB)
+
+TEXT libc_clock_gettime_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_clock_gettime(SB)
-TEXT ·libc_close_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_clock_gettime_trampoline_addr(SB), RODATA, $8
+DATA	·libc_clock_gettime_trampoline_addr(SB)/8, $libc_clock_gettime_trampoline<>(SB)
+
+TEXT libc_close_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_close(SB)
-TEXT ·libc_clonefile_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_close_trampoline_addr(SB), RODATA, $8
+DATA	·libc_close_trampoline_addr(SB)/8, $libc_close_trampoline<>(SB)
+
+TEXT libc_clonefile_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_clonefile(SB)
-TEXT ·libc_clonefileat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_clonefile_trampoline_addr(SB), RODATA, $8
+DATA	·libc_clonefile_trampoline_addr(SB)/8, $libc_clonefile_trampoline<>(SB)
+
+TEXT libc_clonefileat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_clonefileat(SB)
-TEXT ·libc_dup_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_clonefileat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_clonefileat_trampoline_addr(SB)/8, $libc_clonefileat_trampoline<>(SB)
+
+TEXT libc_dup_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_dup(SB)
-TEXT ·libc_dup2_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_dup_trampoline_addr(SB), RODATA, $8
+DATA	·libc_dup_trampoline_addr(SB)/8, $libc_dup_trampoline<>(SB)
+
+TEXT libc_dup2_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_dup2(SB)
-TEXT ·libc_exchangedata_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_dup2_trampoline_addr(SB), RODATA, $8
+DATA	·libc_dup2_trampoline_addr(SB)/8, $libc_dup2_trampoline<>(SB)
+
+TEXT libc_exchangedata_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_exchangedata(SB)
-TEXT ·libc_exit_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_exchangedata_trampoline_addr(SB), RODATA, $8
+DATA	·libc_exchangedata_trampoline_addr(SB)/8, $libc_exchangedata_trampoline<>(SB)
+
+TEXT libc_exit_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_exit(SB)
-TEXT ·libc_faccessat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_exit_trampoline_addr(SB), RODATA, $8
+DATA	·libc_exit_trampoline_addr(SB)/8, $libc_exit_trampoline<>(SB)
+
+TEXT libc_faccessat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_faccessat(SB)
-TEXT ·libc_fchdir_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_faccessat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_faccessat_trampoline_addr(SB)/8, $libc_faccessat_trampoline<>(SB)
+
+TEXT libc_fchdir_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fchdir(SB)
-TEXT ·libc_fchflags_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fchdir_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fchdir_trampoline_addr(SB)/8, $libc_fchdir_trampoline<>(SB)
+
+TEXT libc_fchflags_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fchflags(SB)
-TEXT ·libc_fchmod_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fchflags_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fchflags_trampoline_addr(SB)/8, $libc_fchflags_trampoline<>(SB)
+
+TEXT libc_fchmod_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fchmod(SB)
-TEXT ·libc_fchmodat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fchmod_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fchmod_trampoline_addr(SB)/8, $libc_fchmod_trampoline<>(SB)
+
+TEXT libc_fchmodat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fchmodat(SB)
-TEXT ·libc_fchown_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fchmodat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fchmodat_trampoline_addr(SB)/8, $libc_fchmodat_trampoline<>(SB)
+
+TEXT libc_fchown_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fchown(SB)
-TEXT ·libc_fchownat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fchown_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fchown_trampoline_addr(SB)/8, $libc_fchown_trampoline<>(SB)
+
+TEXT libc_fchownat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fchownat(SB)
-TEXT ·libc_fclonefileat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fchownat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fchownat_trampoline_addr(SB)/8, $libc_fchownat_trampoline<>(SB)
+
+TEXT libc_fclonefileat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fclonefileat(SB)
-TEXT ·libc_flock_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fclonefileat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fclonefileat_trampoline_addr(SB)/8, $libc_fclonefileat_trampoline<>(SB)
+
+TEXT libc_flock_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_flock(SB)
-TEXT ·libc_fpathconf_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_flock_trampoline_addr(SB), RODATA, $8
+DATA	·libc_flock_trampoline_addr(SB)/8, $libc_flock_trampoline<>(SB)
+
+TEXT libc_fpathconf_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fpathconf(SB)
-TEXT ·libc_fsync_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fpathconf_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fpathconf_trampoline_addr(SB)/8, $libc_fpathconf_trampoline<>(SB)
+
+TEXT libc_fsync_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fsync(SB)
-TEXT ·libc_ftruncate_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fsync_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fsync_trampoline_addr(SB)/8, $libc_fsync_trampoline<>(SB)
+
+TEXT libc_ftruncate_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_ftruncate(SB)
-TEXT ·libc_getcwd_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_ftruncate_trampoline_addr(SB), RODATA, $8
+DATA	·libc_ftruncate_trampoline_addr(SB)/8, $libc_ftruncate_trampoline<>(SB)
+
+TEXT libc_getcwd_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getcwd(SB)
-TEXT ·libc_getdtablesize_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getcwd_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getcwd_trampoline_addr(SB)/8, $libc_getcwd_trampoline<>(SB)
+
+TEXT libc_getdtablesize_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getdtablesize(SB)
-TEXT ·libc_getegid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getdtablesize_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getdtablesize_trampoline_addr(SB)/8, $libc_getdtablesize_trampoline<>(SB)
+
+TEXT libc_getegid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getegid(SB)
-TEXT ·libc_geteuid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getegid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getegid_trampoline_addr(SB)/8, $libc_getegid_trampoline<>(SB)
+
+TEXT libc_geteuid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_geteuid(SB)
-TEXT ·libc_getgid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_geteuid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_geteuid_trampoline_addr(SB)/8, $libc_geteuid_trampoline<>(SB)
+
+TEXT libc_getgid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getgid(SB)
-TEXT ·libc_getpgid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getgid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getgid_trampoline_addr(SB)/8, $libc_getgid_trampoline<>(SB)
+
+TEXT libc_getpgid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getpgid(SB)
-TEXT ·libc_getpgrp_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getpgid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getpgid_trampoline_addr(SB)/8, $libc_getpgid_trampoline<>(SB)
+
+TEXT libc_getpgrp_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getpgrp(SB)
-TEXT ·libc_getpid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getpgrp_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getpgrp_trampoline_addr(SB)/8, $libc_getpgrp_trampoline<>(SB)
+
+TEXT libc_getpid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getpid(SB)
-TEXT ·libc_getppid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getpid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getpid_trampoline_addr(SB)/8, $libc_getpid_trampoline<>(SB)
+
+TEXT libc_getppid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getppid(SB)
-TEXT ·libc_getpriority_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getppid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getppid_trampoline_addr(SB)/8, $libc_getppid_trampoline<>(SB)
+
+TEXT libc_getpriority_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getpriority(SB)
-TEXT ·libc_getrlimit_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getpriority_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getpriority_trampoline_addr(SB)/8, $libc_getpriority_trampoline<>(SB)
+
+TEXT libc_getrlimit_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getrlimit(SB)
-TEXT ·libc_getrusage_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getrlimit_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getrlimit_trampoline_addr(SB)/8, $libc_getrlimit_trampoline<>(SB)
+
+TEXT libc_getrusage_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getrusage(SB)
-TEXT ·libc_getsid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getrusage_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getrusage_trampoline_addr(SB)/8, $libc_getrusage_trampoline<>(SB)
+
+TEXT libc_getsid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getsid(SB)
-TEXT ·libc_gettimeofday_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getsid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getsid_trampoline_addr(SB)/8, $libc_getsid_trampoline<>(SB)
+
+TEXT libc_gettimeofday_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_gettimeofday(SB)
-TEXT ·libc_getuid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_gettimeofday_trampoline_addr(SB), RODATA, $8
+DATA	·libc_gettimeofday_trampoline_addr(SB)/8, $libc_gettimeofday_trampoline<>(SB)
+
+TEXT libc_getuid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getuid(SB)
-TEXT ·libc_issetugid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getuid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getuid_trampoline_addr(SB)/8, $libc_getuid_trampoline<>(SB)
+
+TEXT libc_issetugid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_issetugid(SB)
-TEXT ·libc_kqueue_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_issetugid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_issetugid_trampoline_addr(SB)/8, $libc_issetugid_trampoline<>(SB)
+
+TEXT libc_kqueue_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_kqueue(SB)
-TEXT ·libc_lchown_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_kqueue_trampoline_addr(SB), RODATA, $8
+DATA	·libc_kqueue_trampoline_addr(SB)/8, $libc_kqueue_trampoline<>(SB)
+
+TEXT libc_lchown_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_lchown(SB)
-TEXT ·libc_link_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_lchown_trampoline_addr(SB), RODATA, $8
+DATA	·libc_lchown_trampoline_addr(SB)/8, $libc_lchown_trampoline<>(SB)
+
+TEXT libc_link_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_link(SB)
-TEXT ·libc_linkat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_link_trampoline_addr(SB), RODATA, $8
+DATA	·libc_link_trampoline_addr(SB)/8, $libc_link_trampoline<>(SB)
+
+TEXT libc_linkat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_linkat(SB)
-TEXT ·libc_listen_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_linkat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_linkat_trampoline_addr(SB)/8, $libc_linkat_trampoline<>(SB)
+
+TEXT libc_listen_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_listen(SB)
-TEXT ·libc_mkdir_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_listen_trampoline_addr(SB), RODATA, $8
+DATA	·libc_listen_trampoline_addr(SB)/8, $libc_listen_trampoline<>(SB)
+
+TEXT libc_mkdir_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_mkdir(SB)
-TEXT ·libc_mkdirat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_mkdir_trampoline_addr(SB), RODATA, $8
+DATA	·libc_mkdir_trampoline_addr(SB)/8, $libc_mkdir_trampoline<>(SB)
+
+TEXT libc_mkdirat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_mkdirat(SB)
-TEXT ·libc_mkfifo_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_mkdirat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_mkdirat_trampoline_addr(SB)/8, $libc_mkdirat_trampoline<>(SB)
+
+TEXT libc_mkfifo_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_mkfifo(SB)
-TEXT ·libc_mknod_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_mkfifo_trampoline_addr(SB), RODATA, $8
+DATA	·libc_mkfifo_trampoline_addr(SB)/8, $libc_mkfifo_trampoline<>(SB)
+
+TEXT libc_mknod_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_mknod(SB)
-TEXT ·libc_open_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_mknod_trampoline_addr(SB), RODATA, $8
+DATA	·libc_mknod_trampoline_addr(SB)/8, $libc_mknod_trampoline<>(SB)
+
+TEXT libc_open_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_open(SB)
-TEXT ·libc_openat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_open_trampoline_addr(SB), RODATA, $8
+DATA	·libc_open_trampoline_addr(SB)/8, $libc_open_trampoline<>(SB)
+
+TEXT libc_openat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_openat(SB)
-TEXT ·libc_pathconf_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_openat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_openat_trampoline_addr(SB)/8, $libc_openat_trampoline<>(SB)
+
+TEXT libc_pathconf_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_pathconf(SB)
-TEXT ·libc_pread_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_pathconf_trampoline_addr(SB), RODATA, $8
+DATA	·libc_pathconf_trampoline_addr(SB)/8, $libc_pathconf_trampoline<>(SB)
+
+TEXT libc_pread_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_pread(SB)
-TEXT ·libc_pwrite_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_pread_trampoline_addr(SB), RODATA, $8
+DATA	·libc_pread_trampoline_addr(SB)/8, $libc_pread_trampoline<>(SB)
+
+TEXT libc_pwrite_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_pwrite(SB)
-TEXT ·libc_read_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_pwrite_trampoline_addr(SB), RODATA, $8
+DATA	·libc_pwrite_trampoline_addr(SB)/8, $libc_pwrite_trampoline<>(SB)
+
+TEXT libc_read_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_read(SB)
-TEXT ·libc_readlink_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_read_trampoline_addr(SB), RODATA, $8
+DATA	·libc_read_trampoline_addr(SB)/8, $libc_read_trampoline<>(SB)
+
+TEXT libc_readlink_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_readlink(SB)
-TEXT ·libc_readlinkat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_readlink_trampoline_addr(SB), RODATA, $8
+DATA	·libc_readlink_trampoline_addr(SB)/8, $libc_readlink_trampoline<>(SB)
+
+TEXT libc_readlinkat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_readlinkat(SB)
-TEXT ·libc_rename_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_readlinkat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_readlinkat_trampoline_addr(SB)/8, $libc_readlinkat_trampoline<>(SB)
+
+TEXT libc_rename_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_rename(SB)
-TEXT ·libc_renameat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_rename_trampoline_addr(SB), RODATA, $8
+DATA	·libc_rename_trampoline_addr(SB)/8, $libc_rename_trampoline<>(SB)
+
+TEXT libc_renameat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_renameat(SB)
-TEXT ·libc_revoke_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_renameat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_renameat_trampoline_addr(SB)/8, $libc_renameat_trampoline<>(SB)
+
+TEXT libc_revoke_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_revoke(SB)
-TEXT ·libc_rmdir_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_revoke_trampoline_addr(SB), RODATA, $8
+DATA	·libc_revoke_trampoline_addr(SB)/8, $libc_revoke_trampoline<>(SB)
+
+TEXT libc_rmdir_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_rmdir(SB)
-TEXT ·libc_lseek_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_rmdir_trampoline_addr(SB), RODATA, $8
+DATA	·libc_rmdir_trampoline_addr(SB)/8, $libc_rmdir_trampoline<>(SB)
+
+TEXT libc_lseek_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_lseek(SB)
-TEXT ·libc_select_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_lseek_trampoline_addr(SB), RODATA, $8
+DATA	·libc_lseek_trampoline_addr(SB)/8, $libc_lseek_trampoline<>(SB)
+
+TEXT libc_select_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_select(SB)
-TEXT ·libc_setegid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_select_trampoline_addr(SB), RODATA, $8
+DATA	·libc_select_trampoline_addr(SB)/8, $libc_select_trampoline<>(SB)
+
+TEXT libc_setegid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setegid(SB)
-TEXT ·libc_seteuid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setegid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setegid_trampoline_addr(SB)/8, $libc_setegid_trampoline<>(SB)
+
+TEXT libc_seteuid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_seteuid(SB)
-TEXT ·libc_setgid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_seteuid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_seteuid_trampoline_addr(SB)/8, $libc_seteuid_trampoline<>(SB)
+
+TEXT libc_setgid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setgid(SB)
-TEXT ·libc_setlogin_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setgid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setgid_trampoline_addr(SB)/8, $libc_setgid_trampoline<>(SB)
+
+TEXT libc_setlogin_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setlogin(SB)
-TEXT ·libc_setpgid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setlogin_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setlogin_trampoline_addr(SB)/8, $libc_setlogin_trampoline<>(SB)
+
+TEXT libc_setpgid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setpgid(SB)
-TEXT ·libc_setpriority_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setpgid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setpgid_trampoline_addr(SB)/8, $libc_setpgid_trampoline<>(SB)
+
+TEXT libc_setpriority_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setpriority(SB)
-TEXT ·libc_setprivexec_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setpriority_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setpriority_trampoline_addr(SB)/8, $libc_setpriority_trampoline<>(SB)
+
+TEXT libc_setprivexec_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setprivexec(SB)
-TEXT ·libc_setregid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setprivexec_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setprivexec_trampoline_addr(SB)/8, $libc_setprivexec_trampoline<>(SB)
+
+TEXT libc_setregid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setregid(SB)
-TEXT ·libc_setreuid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setregid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setregid_trampoline_addr(SB)/8, $libc_setregid_trampoline<>(SB)
+
+TEXT libc_setreuid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setreuid(SB)
-TEXT ·libc_setrlimit_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setreuid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setreuid_trampoline_addr(SB)/8, $libc_setreuid_trampoline<>(SB)
+
+TEXT libc_setrlimit_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setrlimit(SB)
-TEXT ·libc_setsid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setrlimit_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setrlimit_trampoline_addr(SB)/8, $libc_setrlimit_trampoline<>(SB)
+
+TEXT libc_setsid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setsid(SB)
-TEXT ·libc_settimeofday_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setsid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setsid_trampoline_addr(SB)/8, $libc_setsid_trampoline<>(SB)
+
+TEXT libc_settimeofday_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_settimeofday(SB)
-TEXT ·libc_setuid_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_settimeofday_trampoline_addr(SB), RODATA, $8
+DATA	·libc_settimeofday_trampoline_addr(SB)/8, $libc_settimeofday_trampoline<>(SB)
+
+TEXT libc_setuid_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_setuid(SB)
-TEXT ·libc_symlink_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_setuid_trampoline_addr(SB), RODATA, $8
+DATA	·libc_setuid_trampoline_addr(SB)/8, $libc_setuid_trampoline<>(SB)
+
+TEXT libc_symlink_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_symlink(SB)
-TEXT ·libc_symlinkat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_symlink_trampoline_addr(SB), RODATA, $8
+DATA	·libc_symlink_trampoline_addr(SB)/8, $libc_symlink_trampoline<>(SB)
+
+TEXT libc_symlinkat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_symlinkat(SB)
-TEXT ·libc_sync_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_symlinkat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_symlinkat_trampoline_addr(SB)/8, $libc_symlinkat_trampoline<>(SB)
+
+TEXT libc_sync_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_sync(SB)
-TEXT ·libc_truncate_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_sync_trampoline_addr(SB), RODATA, $8
+DATA	·libc_sync_trampoline_addr(SB)/8, $libc_sync_trampoline<>(SB)
+
+TEXT libc_truncate_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_truncate(SB)
-TEXT ·libc_umask_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_truncate_trampoline_addr(SB), RODATA, $8
+DATA	·libc_truncate_trampoline_addr(SB)/8, $libc_truncate_trampoline<>(SB)
+
+TEXT libc_umask_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_umask(SB)
-TEXT ·libc_undelete_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_umask_trampoline_addr(SB), RODATA, $8
+DATA	·libc_umask_trampoline_addr(SB)/8, $libc_umask_trampoline<>(SB)
+
+TEXT libc_undelete_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_undelete(SB)
-TEXT ·libc_unlink_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_undelete_trampoline_addr(SB), RODATA, $8
+DATA	·libc_undelete_trampoline_addr(SB)/8, $libc_undelete_trampoline<>(SB)
+
+TEXT libc_unlink_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_unlink(SB)
-TEXT ·libc_unlinkat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_unlink_trampoline_addr(SB), RODATA, $8
+DATA	·libc_unlink_trampoline_addr(SB)/8, $libc_unlink_trampoline<>(SB)
+
+TEXT libc_unlinkat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_unlinkat(SB)
-TEXT ·libc_unmount_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_unlinkat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_unlinkat_trampoline_addr(SB)/8, $libc_unlinkat_trampoline<>(SB)
+
+TEXT libc_unmount_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_unmount(SB)
-TEXT ·libc_write_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_unmount_trampoline_addr(SB), RODATA, $8
+DATA	·libc_unmount_trampoline_addr(SB)/8, $libc_unmount_trampoline<>(SB)
+
+TEXT libc_write_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_write(SB)
-TEXT ·libc_mmap_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_write_trampoline_addr(SB), RODATA, $8
+DATA	·libc_write_trampoline_addr(SB)/8, $libc_write_trampoline<>(SB)
+
+TEXT libc_mmap_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_mmap(SB)
-TEXT ·libc_munmap_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_mmap_trampoline_addr(SB), RODATA, $8
+DATA	·libc_mmap_trampoline_addr(SB)/8, $libc_mmap_trampoline<>(SB)
+
+TEXT libc_munmap_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_munmap(SB)
-TEXT ·libc_fstat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_munmap_trampoline_addr(SB), RODATA, $8
+DATA	·libc_munmap_trampoline_addr(SB)/8, $libc_munmap_trampoline<>(SB)
+
+TEXT libc_fstat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fstat(SB)
-TEXT ·libc_fstatat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fstat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fstat_trampoline_addr(SB)/8, $libc_fstat_trampoline<>(SB)
+
+TEXT libc_fstatat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fstatat(SB)
-TEXT ·libc_fstatfs_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fstatat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fstatat_trampoline_addr(SB)/8, $libc_fstatat_trampoline<>(SB)
+
+TEXT libc_fstatfs_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_fstatfs(SB)
-TEXT ·libc_getfsstat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_fstatfs_trampoline_addr(SB), RODATA, $8
+DATA	·libc_fstatfs_trampoline_addr(SB)/8, $libc_fstatfs_trampoline<>(SB)
+
+TEXT libc_getfsstat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_getfsstat(SB)
-TEXT ·libc_lstat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_getfsstat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_getfsstat_trampoline_addr(SB)/8, $libc_getfsstat_trampoline<>(SB)
+
+TEXT libc_lstat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_lstat(SB)
-TEXT ·libc_ptrace_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_lstat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_lstat_trampoline_addr(SB)/8, $libc_lstat_trampoline<>(SB)
+
+TEXT libc_ptrace_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_ptrace(SB)
-TEXT ·libc_stat_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_ptrace_trampoline_addr(SB), RODATA, $8
+DATA	·libc_ptrace_trampoline_addr(SB)/8, $libc_ptrace_trampoline<>(SB)
+
+TEXT libc_stat_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_stat(SB)
-TEXT ·libc_statfs_trampoline(SB),NOSPLIT,$0-0
+
+GLOBL	·libc_stat_trampoline_addr(SB), RODATA, $8
+DATA	·libc_stat_trampoline_addr(SB)/8, $libc_stat_trampoline<>(SB)
+
+TEXT libc_statfs_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_statfs(SB)
+
+GLOBL	·libc_statfs_trampoline_addr(SB), RODATA, $8
+DATA	·libc_statfs_trampoline_addr(SB)/8, $libc_statfs_trampoline<>(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_386.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_386.go
deleted file mode 100644
index 1794ffc924..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_386.go
+++ /dev/null
@@ -1,438 +0,0 @@
-// go run mksysnum.go /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/usr/include/sys/syscall.h
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-//go:build 386 && darwin
-// +build 386,darwin
-
-package unix
-
-// Deprecated: Use libSystem wrappers instead of direct syscalls.
-const (
-	SYS_SYSCALL                        = 0
-	SYS_EXIT                           = 1
-	SYS_FORK                           = 2
-	SYS_READ                           = 3
-	SYS_WRITE                          = 4
-	SYS_OPEN                           = 5
-	SYS_CLOSE                          = 6
-	SYS_WAIT4                          = 7
-	SYS_LINK                           = 9
-	SYS_UNLINK                         = 10
-	SYS_CHDIR                          = 12
-	SYS_FCHDIR                         = 13
-	SYS_MKNOD                          = 14
-	SYS_CHMOD                          = 15
-	SYS_CHOWN                          = 16
-	SYS_GETFSSTAT                      = 18
-	SYS_GETPID                         = 20
-	SYS_SETUID                         = 23
-	SYS_GETUID                         = 24
-	SYS_GETEUID                        = 25
-	SYS_PTRACE                         = 26
-	SYS_RECVMSG                        = 27
-	SYS_SENDMSG                        = 28
-	SYS_RECVFROM                       = 29
-	SYS_ACCEPT                         = 30
-	SYS_GETPEERNAME                    = 31
-	SYS_GETSOCKNAME                    = 32
-	SYS_ACCESS                         = 33
-	SYS_CHFLAGS                        = 34
-	SYS_FCHFLAGS                       = 35
-	SYS_SYNC                           = 36
-	SYS_KILL                           = 37
-	SYS_GETPPID                        = 39
-	SYS_DUP                            = 41
-	SYS_PIPE                           = 42
-	SYS_GETEGID                        = 43
-	SYS_SIGACTION                      = 46
-	SYS_GETGID                         = 47
-	SYS_SIGPROCMASK                    = 48
-	SYS_GETLOGIN                       = 49
-	SYS_SETLOGIN                       = 50
-	SYS_ACCT                           = 51
-	SYS_SIGPENDING                     = 52
-	SYS_SIGALTSTACK                    = 53
-	SYS_IOCTL                          = 54
-	SYS_REBOOT                         = 55
-	SYS_REVOKE                         = 56
-	SYS_SYMLINK                        = 57
-	SYS_READLINK                       = 58
-	SYS_EXECVE                         = 59
-	SYS_UMASK                          = 60
-	SYS_CHROOT                         = 61
-	SYS_MSYNC                          = 65
-	SYS_VFORK                          = 66
-	SYS_MUNMAP                         = 73
-	SYS_MPROTECT                       = 74
-	SYS_MADVISE                        = 75
-	SYS_MINCORE                        = 78
-	SYS_GETGROUPS                      = 79
-	SYS_SETGROUPS                      = 80
-	SYS_GETPGRP                        = 81
-	SYS_SETPGID                        = 82
-	SYS_SETITIMER                      = 83
-	SYS_SWAPON                         = 85
-	SYS_GETITIMER                      = 86
-	SYS_GETDTABLESIZE                  = 89
-	SYS_DUP2                           = 90
-	SYS_FCNTL                          = 92
-	SYS_SELECT                         = 93
-	SYS_FSYNC                          = 95
-	SYS_SETPRIORITY                    = 96
-	SYS_SOCKET                         = 97
-	SYS_CONNECT                        = 98
-	SYS_GETPRIORITY                    = 100
-	SYS_BIND                           = 104
-	SYS_SETSOCKOPT                     = 105
-	SYS_LISTEN                         = 106
-	SYS_SIGSUSPEND                     = 111
-	SYS_GETTIMEOFDAY                   = 116
-	SYS_GETRUSAGE                      = 117
-	SYS_GETSOCKOPT                     = 118
-	SYS_READV                          = 120
-	SYS_WRITEV                         = 121
-	SYS_SETTIMEOFDAY                   = 122
-	SYS_FCHOWN                         = 123
-	SYS_FCHMOD                         = 124
-	SYS_SETREUID                       = 126
-	SYS_SETREGID                       = 127
-	SYS_RENAME                         = 128
-	SYS_FLOCK                          = 131
-	SYS_MKFIFO                         = 132
-	SYS_SENDTO                         = 133
-	SYS_SHUTDOWN                       = 134
-	SYS_SOCKETPAIR                     = 135
-	SYS_MKDIR                          = 136
-	SYS_RMDIR                          = 137
-	SYS_UTIMES                         = 138
-	SYS_FUTIMES                        = 139
-	SYS_ADJTIME                        = 140
-	SYS_GETHOSTUUID                    = 142
-	SYS_SETSID                         = 147
-	SYS_GETPGID                        = 151
-	SYS_SETPRIVEXEC                    = 152
-	SYS_PREAD                          = 153
-	SYS_PWRITE                         = 154
-	SYS_NFSSVC                         = 155
-	SYS_STATFS                         = 157
-	SYS_FSTATFS                        = 158
-	SYS_UNMOUNT                        = 159
-	SYS_GETFH                          = 161
-	SYS_QUOTACTL                       = 165
-	SYS_MOUNT                          = 167
-	SYS_CSOPS                          = 169
-	SYS_CSOPS_AUDITTOKEN               = 170
-	SYS_WAITID                         = 173
-	SYS_KDEBUG_TYPEFILTER              = 177
-	SYS_KDEBUG_TRACE_STRING            = 178
-	SYS_KDEBUG_TRACE64                 = 179
-	SYS_KDEBUG_TRACE                   = 180
-	SYS_SETGID                         = 181
-	SYS_SETEGID                        = 182
-	SYS_SETEUID                        = 183
-	SYS_SIGRETURN                      = 184
-	SYS_THREAD_SELFCOUNTS              = 186
-	SYS_FDATASYNC                      = 187
-	SYS_STAT                           = 188
-	SYS_FSTAT                          = 189
-	SYS_LSTAT                          = 190
-	SYS_PATHCONF                       = 191
-	SYS_FPATHCONF                      = 192
-	SYS_GETRLIMIT                      = 194
-	SYS_SETRLIMIT                      = 195
-	SYS_GETDIRENTRIES                  = 196
-	SYS_MMAP                           = 197
-	SYS_LSEEK                          = 199
-	SYS_TRUNCATE                       = 200
-	SYS_FTRUNCATE                      = 201
-	SYS_SYSCTL                         = 202
-	SYS_MLOCK                          = 203
-	SYS_MUNLOCK                        = 204
-	SYS_UNDELETE                       = 205
-	SYS_OPEN_DPROTECTED_NP             = 216
-	SYS_GETATTRLIST                    = 220
-	SYS_SETATTRLIST                    = 221
-	SYS_GETDIRENTRIESATTR              = 222
-	SYS_EXCHANGEDATA                   = 223
-	SYS_SEARCHFS                       = 225
-	SYS_DELETE                         = 226
-	SYS_COPYFILE                       = 227
-	SYS_FGETATTRLIST                   = 228
-	SYS_FSETATTRLIST                   = 229
-	SYS_POLL                           = 230
-	SYS_WATCHEVENT                     = 231
-	SYS_WAITEVENT                      = 232
-	SYS_MODWATCH                       = 233
-	SYS_GETXATTR                       = 234
-	SYS_FGETXATTR                      = 235
-	SYS_SETXATTR                       = 236
-	SYS_FSETXATTR                      = 237
-	SYS_REMOVEXATTR                    = 238
-	SYS_FREMOVEXATTR                   = 239
-	SYS_LISTXATTR                      = 240
-	SYS_FLISTXATTR                     = 241
-	SYS_FSCTL                          = 242
-	SYS_INITGROUPS                     = 243
-	SYS_POSIX_SPAWN                    = 244
-	SYS_FFSCTL                         = 245
-	SYS_NFSCLNT                        = 247
-	SYS_FHOPEN                         = 248
-	SYS_MINHERIT                       = 250
-	SYS_SEMSYS                         = 251
-	SYS_MSGSYS                         = 252
-	SYS_SHMSYS                         = 253
-	SYS_SEMCTL                         = 254
-	SYS_SEMGET                         = 255
-	SYS_SEMOP                          = 256
-	SYS_MSGCTL                         = 258
-	SYS_MSGGET                         = 259
-	SYS_MSGSND                         = 260
-	SYS_MSGRCV                         = 261
-	SYS_SHMAT                          = 262
-	SYS_SHMCTL                         = 263
-	SYS_SHMDT                          = 264
-	SYS_SHMGET                         = 265
-	SYS_SHM_OPEN                       = 266
-	SYS_SHM_UNLINK                     = 267
-	SYS_SEM_OPEN                       = 268
-	SYS_SEM_CLOSE                      = 269
-	SYS_SEM_UNLINK                     = 270
-	SYS_SEM_WAIT                       = 271
-	SYS_SEM_TRYWAIT                    = 272
-	SYS_SEM_POST                       = 273
-	SYS_SYSCTLBYNAME                   = 274
-	SYS_OPEN_EXTENDED                  = 277
-	SYS_UMASK_EXTENDED                 = 278
-	SYS_STAT_EXTENDED                  = 279
-	SYS_LSTAT_EXTENDED                 = 280
-	SYS_FSTAT_EXTENDED                 = 281
-	SYS_CHMOD_EXTENDED                 = 282
-	SYS_FCHMOD_EXTENDED                = 283
-	SYS_ACCESS_EXTENDED                = 284
-	SYS_SETTID                         = 285
-	SYS_GETTID                         = 286
-	SYS_SETSGROUPS                     = 287
-	SYS_GETSGROUPS                     = 288
-	SYS_SETWGROUPS                     = 289
-	SYS_GETWGROUPS                     = 290
-	SYS_MKFIFO_EXTENDED                = 291
-	SYS_MKDIR_EXTENDED                 = 292
-	SYS_IDENTITYSVC                    = 293
-	SYS_SHARED_REGION_CHECK_NP         = 294
-	SYS_VM_PRESSURE_MONITOR            = 296
-	SYS_PSYNCH_RW_LONGRDLOCK           = 297
-	SYS_PSYNCH_RW_YIELDWRLOCK          = 298
-	SYS_PSYNCH_RW_DOWNGRADE            = 299
-	SYS_PSYNCH_RW_UPGRADE              = 300
-	SYS_PSYNCH_MUTEXWAIT               = 301
-	SYS_PSYNCH_MUTEXDROP               = 302
-	SYS_PSYNCH_CVBROAD                 = 303
-	SYS_PSYNCH_CVSIGNAL                = 304
-	SYS_PSYNCH_CVWAIT                  = 305
-	SYS_PSYNCH_RW_RDLOCK               = 306
-	SYS_PSYNCH_RW_WRLOCK               = 307
-	SYS_PSYNCH_RW_UNLOCK               = 308
-	SYS_PSYNCH_RW_UNLOCK2              = 309
-	SYS_GETSID                         = 310
-	SYS_SETTID_WITH_PID                = 311
-	SYS_PSYNCH_CVCLRPREPOST            = 312
-	SYS_AIO_FSYNC                      = 313
-	SYS_AIO_RETURN                     = 314
-	SYS_AIO_SUSPEND                    = 315
-	SYS_AIO_CANCEL                     = 316
-	SYS_AIO_ERROR                      = 317
-	SYS_AIO_READ                       = 318
-	SYS_AIO_WRITE                      = 319
-	SYS_LIO_LISTIO                     = 320
-	SYS_IOPOLICYSYS                    = 322
-	SYS_PROCESS_POLICY                 = 323
-	SYS_MLOCKALL                       = 324
-	SYS_MUNLOCKALL                     = 325
-	SYS_ISSETUGID                      = 327
-	SYS___PTHREAD_KILL                 = 328
-	SYS___PTHREAD_SIGMASK              = 329
-	SYS___SIGWAIT                      = 330
-	SYS___DISABLE_THREADSIGNAL         = 331
-	SYS___PTHREAD_MARKCANCEL           = 332
-	SYS___PTHREAD_CANCELED             = 333
-	SYS___SEMWAIT_SIGNAL               = 334
-	SYS_PROC_INFO                      = 336
-	SYS_SENDFILE                       = 337
-	SYS_STAT64                         = 338
-	SYS_FSTAT64                        = 339
-	SYS_LSTAT64                        = 340
-	SYS_STAT64_EXTENDED                = 341
-	SYS_LSTAT64_EXTENDED               = 342
-	SYS_FSTAT64_EXTENDED               = 343
-	SYS_GETDIRENTRIES64                = 344
-	SYS_STATFS64                       = 345
-	SYS_FSTATFS64                      = 346
-	SYS_GETFSSTAT64                    = 347
-	SYS___PTHREAD_CHDIR                = 348
-	SYS___PTHREAD_FCHDIR               = 349
-	SYS_AUDIT                          = 350
-	SYS_AUDITON                        = 351
-	SYS_GETAUID                        = 353
-	SYS_SETAUID                        = 354
-	SYS_GETAUDIT_ADDR                  = 357
-	SYS_SETAUDIT_ADDR                  = 358
-	SYS_AUDITCTL                       = 359
-	SYS_BSDTHREAD_CREATE               = 360
-	SYS_BSDTHREAD_TERMINATE            = 361
-	SYS_KQUEUE                         = 362
-	SYS_KEVENT                         = 363
-	SYS_LCHOWN                         = 364
-	SYS_BSDTHREAD_REGISTER             = 366
-	SYS_WORKQ_OPEN                     = 367
-	SYS_WORKQ_KERNRETURN               = 368
-	SYS_KEVENT64                       = 369
-	SYS___OLD_SEMWAIT_SIGNAL           = 370
-	SYS___OLD_SEMWAIT_SIGNAL_NOCANCEL  = 371
-	SYS_THREAD_SELFID                  = 372
-	SYS_LEDGER                         = 373
-	SYS_KEVENT_QOS                     = 374
-	SYS_KEVENT_ID                      = 375
-	SYS___MAC_EXECVE                   = 380
-	SYS___MAC_SYSCALL                  = 381
-	SYS___MAC_GET_FILE                 = 382
-	SYS___MAC_SET_FILE                 = 383
-	SYS___MAC_GET_LINK                 = 384
-	SYS___MAC_SET_LINK                 = 385
-	SYS___MAC_GET_PROC                 = 386
-	SYS___MAC_SET_PROC                 = 387
-	SYS___MAC_GET_FD                   = 388
-	SYS___MAC_SET_FD                   = 389
-	SYS___MAC_GET_PID                  = 390
-	SYS_PSELECT                        = 394
-	SYS_PSELECT_NOCANCEL               = 395
-	SYS_READ_NOCANCEL                  = 396
-	SYS_WRITE_NOCANCEL                 = 397
-	SYS_OPEN_NOCANCEL                  = 398
-	SYS_CLOSE_NOCANCEL                 = 399
-	SYS_WAIT4_NOCANCEL                 = 400
-	SYS_RECVMSG_NOCANCEL               = 401
-	SYS_SENDMSG_NOCANCEL               = 402
-	SYS_RECVFROM_NOCANCEL              = 403
-	SYS_ACCEPT_NOCANCEL                = 404
-	SYS_MSYNC_NOCANCEL                 = 405
-	SYS_FCNTL_NOCANCEL                 = 406
-	SYS_SELECT_NOCANCEL                = 407
-	SYS_FSYNC_NOCANCEL                 = 408
-	SYS_CONNECT_NOCANCEL               = 409
-	SYS_SIGSUSPEND_NOCANCEL            = 410
-	SYS_READV_NOCANCEL                 = 411
-	SYS_WRITEV_NOCANCEL                = 412
-	SYS_SENDTO_NOCANCEL                = 413
-	SYS_PREAD_NOCANCEL                 = 414
-	SYS_PWRITE_NOCANCEL                = 415
-	SYS_WAITID_NOCANCEL                = 416
-	SYS_POLL_NOCANCEL                  = 417
-	SYS_MSGSND_NOCANCEL                = 418
-	SYS_MSGRCV_NOCANCEL                = 419
-	SYS_SEM_WAIT_NOCANCEL              = 420
-	SYS_AIO_SUSPEND_NOCANCEL           = 421
-	SYS___SIGWAIT_NOCANCEL             = 422
-	SYS___SEMWAIT_SIGNAL_NOCANCEL      = 423
-	SYS___MAC_MOUNT                    = 424
-	SYS___MAC_GET_MOUNT                = 425
-	SYS___MAC_GETFSSTAT                = 426
-	SYS_FSGETPATH                      = 427
-	SYS_AUDIT_SESSION_SELF             = 428
-	SYS_AUDIT_SESSION_JOIN             = 429
-	SYS_FILEPORT_MAKEPORT              = 430
-	SYS_FILEPORT_MAKEFD                = 431
-	SYS_AUDIT_SESSION_PORT             = 432
-	SYS_PID_SUSPEND                    = 433
-	SYS_PID_RESUME                     = 434
-	SYS_PID_HIBERNATE                  = 435
-	SYS_PID_SHUTDOWN_SOCKETS           = 436
-	SYS_SHARED_REGION_MAP_AND_SLIDE_NP = 438
-	SYS_KAS_INFO                       = 439
-	SYS_MEMORYSTATUS_CONTROL           = 440
-	SYS_GUARDED_OPEN_NP                = 441
-	SYS_GUARDED_CLOSE_NP               = 442
-	SYS_GUARDED_KQUEUE_NP              = 443
-	SYS_CHANGE_FDGUARD_NP              = 444
-	SYS_USRCTL                         = 445
-	SYS_PROC_RLIMIT_CONTROL            = 446
-	SYS_CONNECTX                       = 447
-	SYS_DISCONNECTX                    = 448
-	SYS_PEELOFF                        = 449
-	SYS_SOCKET_DELEGATE                = 450
-	SYS_TELEMETRY                      = 451
-	SYS_PROC_UUID_POLICY               = 452
-	SYS_MEMORYSTATUS_GET_LEVEL         = 453
-	SYS_SYSTEM_OVERRIDE                = 454
-	SYS_VFS_PURGE                      = 455
-	SYS_SFI_CTL                        = 456
-	SYS_SFI_PIDCTL                     = 457
-	SYS_COALITION                      = 458
-	SYS_COALITION_INFO                 = 459
-	SYS_NECP_MATCH_POLICY              = 460
-	SYS_GETATTRLISTBULK                = 461
-	SYS_CLONEFILEAT                    = 462
-	SYS_OPENAT                         = 463
-	SYS_OPENAT_NOCANCEL                = 464
-	SYS_RENAMEAT                       = 465
-	SYS_FACCESSAT                      = 466
-	SYS_FCHMODAT                       = 467
-	SYS_FCHOWNAT                       = 468
-	SYS_FSTATAT                        = 469
-	SYS_FSTATAT64                      = 470
-	SYS_LINKAT                         = 471
-	SYS_UNLINKAT                       = 472
-	SYS_READLINKAT                     = 473
-	SYS_SYMLINKAT                      = 474
-	SYS_MKDIRAT                        = 475
-	SYS_GETATTRLISTAT                  = 476
-	SYS_PROC_TRACE_LOG                 = 477
-	SYS_BSDTHREAD_CTL                  = 478
-	SYS_OPENBYID_NP                    = 479
-	SYS_RECVMSG_X                      = 480
-	SYS_SENDMSG_X                      = 481
-	SYS_THREAD_SELFUSAGE               = 482
-	SYS_CSRCTL                         = 483
-	SYS_GUARDED_OPEN_DPROTECTED_NP     = 484
-	SYS_GUARDED_WRITE_NP               = 485
-	SYS_GUARDED_PWRITE_NP              = 486
-	SYS_GUARDED_WRITEV_NP              = 487
-	SYS_RENAMEATX_NP                   = 488
-	SYS_MREMAP_ENCRYPTED               = 489
-	SYS_NETAGENT_TRIGGER               = 490
-	SYS_STACK_SNAPSHOT_WITH_CONFIG     = 491
-	SYS_MICROSTACKSHOT                 = 492
-	SYS_GRAB_PGO_DATA                  = 493
-	SYS_PERSONA                        = 494
-	SYS_WORK_INTERVAL_CTL              = 499
-	SYS_GETENTROPY                     = 500
-	SYS_NECP_OPEN                      = 501
-	SYS_NECP_CLIENT_ACTION             = 502
-	SYS___NEXUS_OPEN                   = 503
-	SYS___NEXUS_REGISTER               = 504
-	SYS___NEXUS_DEREGISTER             = 505
-	SYS___NEXUS_CREATE                 = 506
-	SYS___NEXUS_DESTROY                = 507
-	SYS___NEXUS_GET_OPT                = 508
-	SYS___NEXUS_SET_OPT                = 509
-	SYS___CHANNEL_OPEN                 = 510
-	SYS___CHANNEL_GET_INFO             = 511
-	SYS___CHANNEL_SYNC                 = 512
-	SYS___CHANNEL_GET_OPT              = 513
-	SYS___CHANNEL_SET_OPT              = 514
-	SYS_ULOCK_WAIT                     = 515
-	SYS_ULOCK_WAKE                     = 516
-	SYS_FCLONEFILEAT                   = 517
-	SYS_FS_SNAPSHOT                    = 518
-	SYS_TERMINATE_WITH_PAYLOAD         = 520
-	SYS_ABORT_WITH_PAYLOAD             = 521
-	SYS_NECP_SESSION_OPEN              = 522
-	SYS_NECP_SESSION_ACTION            = 523
-	SYS_SETATTRLISTAT                  = 524
-	SYS_NET_QOS_GUIDELINE              = 525
-	SYS_FMOUNT                         = 526
-	SYS_NTP_ADJTIME                    = 527
-	SYS_NTP_GETTIME                    = 528
-	SYS_OS_FAULT_WITH_PAYLOAD          = 529
-	SYS_MAXSYSCALL                     = 530
-	SYS_INVALID                        = 63
-)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_arm.go
deleted file mode 100644
index 6dc736449a..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_arm.go
+++ /dev/null
@@ -1,438 +0,0 @@
-// go run mksysnum.go /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS11.1.sdk/usr/include/sys/syscall.h
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-//go:build arm && darwin
-// +build arm,darwin
-
-package unix
-
-// Deprecated: Use libSystem wrappers instead of direct syscalls.
-const (
-	SYS_SYSCALL                        = 0
-	SYS_EXIT                           = 1
-	SYS_FORK                           = 2
-	SYS_READ                           = 3
-	SYS_WRITE                          = 4
-	SYS_OPEN                           = 5
-	SYS_CLOSE                          = 6
-	SYS_WAIT4                          = 7
-	SYS_LINK                           = 9
-	SYS_UNLINK                         = 10
-	SYS_CHDIR                          = 12
-	SYS_FCHDIR                         = 13
-	SYS_MKNOD                          = 14
-	SYS_CHMOD                          = 15
-	SYS_CHOWN                          = 16
-	SYS_GETFSSTAT                      = 18
-	SYS_GETPID                         = 20
-	SYS_SETUID                         = 23
-	SYS_GETUID                         = 24
-	SYS_GETEUID                        = 25
-	SYS_PTRACE                         = 26
-	SYS_RECVMSG                        = 27
-	SYS_SENDMSG                        = 28
-	SYS_RECVFROM                       = 29
-	SYS_ACCEPT                         = 30
-	SYS_GETPEERNAME                    = 31
-	SYS_GETSOCKNAME                    = 32
-	SYS_ACCESS                         = 33
-	SYS_CHFLAGS                        = 34
-	SYS_FCHFLAGS                       = 35
-	SYS_SYNC                           = 36
-	SYS_KILL                           = 37
-	SYS_GETPPID                        = 39
-	SYS_DUP                            = 41
-	SYS_PIPE                           = 42
-	SYS_GETEGID                        = 43
-	SYS_SIGACTION                      = 46
-	SYS_GETGID                         = 47
-	SYS_SIGPROCMASK                    = 48
-	SYS_GETLOGIN                       = 49
-	SYS_SETLOGIN                       = 50
-	SYS_ACCT                           = 51
-	SYS_SIGPENDING                     = 52
-	SYS_SIGALTSTACK                    = 53
-	SYS_IOCTL                          = 54
-	SYS_REBOOT                         = 55
-	SYS_REVOKE                         = 56
-	SYS_SYMLINK                        = 57
-	SYS_READLINK                       = 58
-	SYS_EXECVE                         = 59
-	SYS_UMASK                          = 60
-	SYS_CHROOT                         = 61
-	SYS_MSYNC                          = 65
-	SYS_VFORK                          = 66
-	SYS_MUNMAP                         = 73
-	SYS_MPROTECT                       = 74
-	SYS_MADVISE                        = 75
-	SYS_MINCORE                        = 78
-	SYS_GETGROUPS                      = 79
-	SYS_SETGROUPS                      = 80
-	SYS_GETPGRP                        = 81
-	SYS_SETPGID                        = 82
-	SYS_SETITIMER                      = 83
-	SYS_SWAPON                         = 85
-	SYS_GETITIMER                      = 86
-	SYS_GETDTABLESIZE                  = 89
-	SYS_DUP2                           = 90
-	SYS_FCNTL                          = 92
-	SYS_SELECT                         = 93
-	SYS_FSYNC                          = 95
-	SYS_SETPRIORITY                    = 96
-	SYS_SOCKET                         = 97
-	SYS_CONNECT                        = 98
-	SYS_GETPRIORITY                    = 100
-	SYS_BIND                           = 104
-	SYS_SETSOCKOPT                     = 105
-	SYS_LISTEN                         = 106
-	SYS_SIGSUSPEND                     = 111
-	SYS_GETTIMEOFDAY                   = 116
-	SYS_GETRUSAGE                      = 117
-	SYS_GETSOCKOPT                     = 118
-	SYS_READV                          = 120
-	SYS_WRITEV                         = 121
-	SYS_SETTIMEOFDAY                   = 122
-	SYS_FCHOWN                         = 123
-	SYS_FCHMOD                         = 124
-	SYS_SETREUID                       = 126
-	SYS_SETREGID                       = 127
-	SYS_RENAME                         = 128
-	SYS_FLOCK                          = 131
-	SYS_MKFIFO                         = 132
-	SYS_SENDTO                         = 133
-	SYS_SHUTDOWN                       = 134
-	SYS_SOCKETPAIR                     = 135
-	SYS_MKDIR                          = 136
-	SYS_RMDIR                          = 137
-	SYS_UTIMES                         = 138
-	SYS_FUTIMES                        = 139
-	SYS_ADJTIME                        = 140
-	SYS_GETHOSTUUID                    = 142
-	SYS_SETSID                         = 147
-	SYS_GETPGID                        = 151
-	SYS_SETPRIVEXEC                    = 152
-	SYS_PREAD                          = 153
-	SYS_PWRITE                         = 154
-	SYS_NFSSVC                         = 155
-	SYS_STATFS                         = 157
-	SYS_FSTATFS                        = 158
-	SYS_UNMOUNT                        = 159
-	SYS_GETFH                          = 161
-	SYS_QUOTACTL                       = 165
-	SYS_MOUNT                          = 167
-	SYS_CSOPS                          = 169
-	SYS_CSOPS_AUDITTOKEN               = 170
-	SYS_WAITID                         = 173
-	SYS_KDEBUG_TYPEFILTER              = 177
-	SYS_KDEBUG_TRACE_STRING            = 178
-	SYS_KDEBUG_TRACE64                 = 179
-	SYS_KDEBUG_TRACE                   = 180
-	SYS_SETGID                         = 181
-	SYS_SETEGID                        = 182
-	SYS_SETEUID                        = 183
-	SYS_SIGRETURN                      = 184
-	SYS_THREAD_SELFCOUNTS              = 186
-	SYS_FDATASYNC                      = 187
-	SYS_STAT                           = 188
-	SYS_FSTAT                          = 189
-	SYS_LSTAT                          = 190
-	SYS_PATHCONF                       = 191
-	SYS_FPATHCONF                      = 192
-	SYS_GETRLIMIT                      = 194
-	SYS_SETRLIMIT                      = 195
-	SYS_GETDIRENTRIES                  = 196
-	SYS_MMAP                           = 197
-	SYS_LSEEK                          = 199
-	SYS_TRUNCATE                       = 200
-	SYS_FTRUNCATE                      = 201
-	SYS_SYSCTL                         = 202
-	SYS_MLOCK                          = 203
-	SYS_MUNLOCK                        = 204
-	SYS_UNDELETE                       = 205
-	SYS_OPEN_DPROTECTED_NP             = 216
-	SYS_GETATTRLIST                    = 220
-	SYS_SETATTRLIST                    = 221
-	SYS_GETDIRENTRIESATTR              = 222
-	SYS_EXCHANGEDATA                   = 223
-	SYS_SEARCHFS                       = 225
-	SYS_DELETE                         = 226
-	SYS_COPYFILE                       = 227
-	SYS_FGETATTRLIST                   = 228
-	SYS_FSETATTRLIST                   = 229
-	SYS_POLL                           = 230
-	SYS_WATCHEVENT                     = 231
-	SYS_WAITEVENT                      = 232
-	SYS_MODWATCH                       = 233
-	SYS_GETXATTR                       = 234
-	SYS_FGETXATTR                      = 235
-	SYS_SETXATTR                       = 236
-	SYS_FSETXATTR                      = 237
-	SYS_REMOVEXATTR                    = 238
-	SYS_FREMOVEXATTR                   = 239
-	SYS_LISTXATTR                      = 240
-	SYS_FLISTXATTR                     = 241
-	SYS_FSCTL                          = 242
-	SYS_INITGROUPS                     = 243
-	SYS_POSIX_SPAWN                    = 244
-	SYS_FFSCTL                         = 245
-	SYS_NFSCLNT                        = 247
-	SYS_FHOPEN                         = 248
-	SYS_MINHERIT                       = 250
-	SYS_SEMSYS                         = 251
-	SYS_MSGSYS                         = 252
-	SYS_SHMSYS                         = 253
-	SYS_SEMCTL                         = 254
-	SYS_SEMGET                         = 255
-	SYS_SEMOP                          = 256
-	SYS_MSGCTL                         = 258
-	SYS_MSGGET                         = 259
-	SYS_MSGSND                         = 260
-	SYS_MSGRCV                         = 261
-	SYS_SHMAT                          = 262
-	SYS_SHMCTL                         = 263
-	SYS_SHMDT                          = 264
-	SYS_SHMGET                         = 265
-	SYS_SHM_OPEN                       = 266
-	SYS_SHM_UNLINK                     = 267
-	SYS_SEM_OPEN                       = 268
-	SYS_SEM_CLOSE                      = 269
-	SYS_SEM_UNLINK                     = 270
-	SYS_SEM_WAIT                       = 271
-	SYS_SEM_TRYWAIT                    = 272
-	SYS_SEM_POST                       = 273
-	SYS_SYSCTLBYNAME                   = 274
-	SYS_OPEN_EXTENDED                  = 277
-	SYS_UMASK_EXTENDED                 = 278
-	SYS_STAT_EXTENDED                  = 279
-	SYS_LSTAT_EXTENDED                 = 280
-	SYS_FSTAT_EXTENDED                 = 281
-	SYS_CHMOD_EXTENDED                 = 282
-	SYS_FCHMOD_EXTENDED                = 283
-	SYS_ACCESS_EXTENDED                = 284
-	SYS_SETTID                         = 285
-	SYS_GETTID                         = 286
-	SYS_SETSGROUPS                     = 287
-	SYS_GETSGROUPS                     = 288
-	SYS_SETWGROUPS                     = 289
-	SYS_GETWGROUPS                     = 290
-	SYS_MKFIFO_EXTENDED                = 291
-	SYS_MKDIR_EXTENDED                 = 292
-	SYS_IDENTITYSVC                    = 293
-	SYS_SHARED_REGION_CHECK_NP         = 294
-	SYS_VM_PRESSURE_MONITOR            = 296
-	SYS_PSYNCH_RW_LONGRDLOCK           = 297
-	SYS_PSYNCH_RW_YIELDWRLOCK          = 298
-	SYS_PSYNCH_RW_DOWNGRADE            = 299
-	SYS_PSYNCH_RW_UPGRADE              = 300
-	SYS_PSYNCH_MUTEXWAIT               = 301
-	SYS_PSYNCH_MUTEXDROP               = 302
-	SYS_PSYNCH_CVBROAD                 = 303
-	SYS_PSYNCH_CVSIGNAL                = 304
-	SYS_PSYNCH_CVWAIT                  = 305
-	SYS_PSYNCH_RW_RDLOCK               = 306
-	SYS_PSYNCH_RW_WRLOCK               = 307
-	SYS_PSYNCH_RW_UNLOCK               = 308
-	SYS_PSYNCH_RW_UNLOCK2              = 309
-	SYS_GETSID                         = 310
-	SYS_SETTID_WITH_PID                = 311
-	SYS_PSYNCH_CVCLRPREPOST            = 312
-	SYS_AIO_FSYNC                      = 313
-	SYS_AIO_RETURN                     = 314
-	SYS_AIO_SUSPEND                    = 315
-	SYS_AIO_CANCEL                     = 316
-	SYS_AIO_ERROR                      = 317
-	SYS_AIO_READ                       = 318
-	SYS_AIO_WRITE                      = 319
-	SYS_LIO_LISTIO                     = 320
-	SYS_IOPOLICYSYS                    = 322
-	SYS_PROCESS_POLICY                 = 323
-	SYS_MLOCKALL                       = 324
-	SYS_MUNLOCKALL                     = 325
-	SYS_ISSETUGID                      = 327
-	SYS___PTHREAD_KILL                 = 328
-	SYS___PTHREAD_SIGMASK              = 329
-	SYS___SIGWAIT                      = 330
-	SYS___DISABLE_THREADSIGNAL         = 331
-	SYS___PTHREAD_MARKCANCEL           = 332
-	SYS___PTHREAD_CANCELED             = 333
-	SYS___SEMWAIT_SIGNAL               = 334
-	SYS_PROC_INFO                      = 336
-	SYS_SENDFILE                       = 337
-	SYS_STAT64                         = 338
-	SYS_FSTAT64                        = 339
-	SYS_LSTAT64                        = 340
-	SYS_STAT64_EXTENDED                = 341
-	SYS_LSTAT64_EXTENDED               = 342
-	SYS_FSTAT64_EXTENDED               = 343
-	SYS_GETDIRENTRIES64                = 344
-	SYS_STATFS64                       = 345
-	SYS_FSTATFS64                      = 346
-	SYS_GETFSSTAT64                    = 347
-	SYS___PTHREAD_CHDIR                = 348
-	SYS___PTHREAD_FCHDIR               = 349
-	SYS_AUDIT                          = 350
-	SYS_AUDITON                        = 351
-	SYS_GETAUID                        = 353
-	SYS_SETAUID                        = 354
-	SYS_GETAUDIT_ADDR                  = 357
-	SYS_SETAUDIT_ADDR                  = 358
-	SYS_AUDITCTL                       = 359
-	SYS_BSDTHREAD_CREATE               = 360
-	SYS_BSDTHREAD_TERMINATE            = 361
-	SYS_KQUEUE                         = 362
-	SYS_KEVENT                         = 363
-	SYS_LCHOWN                         = 364
-	SYS_BSDTHREAD_REGISTER             = 366
-	SYS_WORKQ_OPEN                     = 367
-	SYS_WORKQ_KERNRETURN               = 368
-	SYS_KEVENT64                       = 369
-	SYS___OLD_SEMWAIT_SIGNAL           = 370
-	SYS___OLD_SEMWAIT_SIGNAL_NOCANCEL  = 371
-	SYS_THREAD_SELFID                  = 372
-	SYS_LEDGER                         = 373
-	SYS_KEVENT_QOS                     = 374
-	SYS_KEVENT_ID                      = 375
-	SYS___MAC_EXECVE                   = 380
-	SYS___MAC_SYSCALL                  = 381
-	SYS___MAC_GET_FILE                 = 382
-	SYS___MAC_SET_FILE                 = 383
-	SYS___MAC_GET_LINK                 = 384
-	SYS___MAC_SET_LINK                 = 385
-	SYS___MAC_GET_PROC                 = 386
-	SYS___MAC_SET_PROC                 = 387
-	SYS___MAC_GET_FD                   = 388
-	SYS___MAC_SET_FD                   = 389
-	SYS___MAC_GET_PID                  = 390
-	SYS_PSELECT                        = 394
-	SYS_PSELECT_NOCANCEL               = 395
-	SYS_READ_NOCANCEL                  = 396
-	SYS_WRITE_NOCANCEL                 = 397
-	SYS_OPEN_NOCANCEL                  = 398
-	SYS_CLOSE_NOCANCEL                 = 399
-	SYS_WAIT4_NOCANCEL                 = 400
-	SYS_RECVMSG_NOCANCEL               = 401
-	SYS_SENDMSG_NOCANCEL               = 402
-	SYS_RECVFROM_NOCANCEL              = 403
-	SYS_ACCEPT_NOCANCEL                = 404
-	SYS_MSYNC_NOCANCEL                 = 405
-	SYS_FCNTL_NOCANCEL                 = 406
-	SYS_SELECT_NOCANCEL                = 407
-	SYS_FSYNC_NOCANCEL                 = 408
-	SYS_CONNECT_NOCANCEL               = 409
-	SYS_SIGSUSPEND_NOCANCEL            = 410
-	SYS_READV_NOCANCEL                 = 411
-	SYS_WRITEV_NOCANCEL                = 412
-	SYS_SENDTO_NOCANCEL                = 413
-	SYS_PREAD_NOCANCEL                 = 414
-	SYS_PWRITE_NOCANCEL                = 415
-	SYS_WAITID_NOCANCEL                = 416
-	SYS_POLL_NOCANCEL                  = 417
-	SYS_MSGSND_NOCANCEL                = 418
-	SYS_MSGRCV_NOCANCEL                = 419
-	SYS_SEM_WAIT_NOCANCEL              = 420
-	SYS_AIO_SUSPEND_NOCANCEL           = 421
-	SYS___SIGWAIT_NOCANCEL             = 422
-	SYS___SEMWAIT_SIGNAL_NOCANCEL      = 423
-	SYS___MAC_MOUNT                    = 424
-	SYS___MAC_GET_MOUNT                = 425
-	SYS___MAC_GETFSSTAT                = 426
-	SYS_FSGETPATH                      = 427
-	SYS_AUDIT_SESSION_SELF             = 428
-	SYS_AUDIT_SESSION_JOIN             = 429
-	SYS_FILEPORT_MAKEPORT              = 430
-	SYS_FILEPORT_MAKEFD                = 431
-	SYS_AUDIT_SESSION_PORT             = 432
-	SYS_PID_SUSPEND                    = 433
-	SYS_PID_RESUME                     = 434
-	SYS_PID_HIBERNATE                  = 435
-	SYS_PID_SHUTDOWN_SOCKETS           = 436
-	SYS_SHARED_REGION_MAP_AND_SLIDE_NP = 438
-	SYS_KAS_INFO                       = 439
-	SYS_MEMORYSTATUS_CONTROL           = 440
-	SYS_GUARDED_OPEN_NP                = 441
-	SYS_GUARDED_CLOSE_NP               = 442
-	SYS_GUARDED_KQUEUE_NP              = 443
-	SYS_CHANGE_FDGUARD_NP              = 444
-	SYS_USRCTL                         = 445
-	SYS_PROC_RLIMIT_CONTROL            = 446
-	SYS_CONNECTX                       = 447
-	SYS_DISCONNECTX                    = 448
-	SYS_PEELOFF                        = 449
-	SYS_SOCKET_DELEGATE                = 450
-	SYS_TELEMETRY                      = 451
-	SYS_PROC_UUID_POLICY               = 452
-	SYS_MEMORYSTATUS_GET_LEVEL         = 453
-	SYS_SYSTEM_OVERRIDE                = 454
-	SYS_VFS_PURGE                      = 455
-	SYS_SFI_CTL                        = 456
-	SYS_SFI_PIDCTL                     = 457
-	SYS_COALITION                      = 458
-	SYS_COALITION_INFO                 = 459
-	SYS_NECP_MATCH_POLICY              = 460
-	SYS_GETATTRLISTBULK                = 461
-	SYS_CLONEFILEAT                    = 462
-	SYS_OPENAT                         = 463
-	SYS_OPENAT_NOCANCEL                = 464
-	SYS_RENAMEAT                       = 465
-	SYS_FACCESSAT                      = 466
-	SYS_FCHMODAT                       = 467
-	SYS_FCHOWNAT                       = 468
-	SYS_FSTATAT                        = 469
-	SYS_FSTATAT64                      = 470
-	SYS_LINKAT                         = 471
-	SYS_UNLINKAT                       = 472
-	SYS_READLINKAT                     = 473
-	SYS_SYMLINKAT                      = 474
-	SYS_MKDIRAT                        = 475
-	SYS_GETATTRLISTAT                  = 476
-	SYS_PROC_TRACE_LOG                 = 477
-	SYS_BSDTHREAD_CTL                  = 478
-	SYS_OPENBYID_NP                    = 479
-	SYS_RECVMSG_X                      = 480
-	SYS_SENDMSG_X                      = 481
-	SYS_THREAD_SELFUSAGE               = 482
-	SYS_CSRCTL                         = 483
-	SYS_GUARDED_OPEN_DPROTECTED_NP     = 484
-	SYS_GUARDED_WRITE_NP               = 485
-	SYS_GUARDED_PWRITE_NP              = 486
-	SYS_GUARDED_WRITEV_NP              = 487
-	SYS_RENAMEATX_NP                   = 488
-	SYS_MREMAP_ENCRYPTED               = 489
-	SYS_NETAGENT_TRIGGER               = 490
-	SYS_STACK_SNAPSHOT_WITH_CONFIG     = 491
-	SYS_MICROSTACKSHOT                 = 492
-	SYS_GRAB_PGO_DATA                  = 493
-	SYS_PERSONA                        = 494
-	SYS_WORK_INTERVAL_CTL              = 499
-	SYS_GETENTROPY                     = 500
-	SYS_NECP_OPEN                      = 501
-	SYS_NECP_CLIENT_ACTION             = 502
-	SYS___NEXUS_OPEN                   = 503
-	SYS___NEXUS_REGISTER               = 504
-	SYS___NEXUS_DEREGISTER             = 505
-	SYS___NEXUS_CREATE                 = 506
-	SYS___NEXUS_DESTROY                = 507
-	SYS___NEXUS_GET_OPT                = 508
-	SYS___NEXUS_SET_OPT                = 509
-	SYS___CHANNEL_OPEN                 = 510
-	SYS___CHANNEL_GET_INFO             = 511
-	SYS___CHANNEL_SYNC                 = 512
-	SYS___CHANNEL_GET_OPT              = 513
-	SYS___CHANNEL_SET_OPT              = 514
-	SYS_ULOCK_WAIT                     = 515
-	SYS_ULOCK_WAKE                     = 516
-	SYS_FCLONEFILEAT                   = 517
-	SYS_FS_SNAPSHOT                    = 518
-	SYS_TERMINATE_WITH_PAYLOAD         = 520
-	SYS_ABORT_WITH_PAYLOAD             = 521
-	SYS_NECP_SESSION_OPEN              = 522
-	SYS_NECP_SESSION_ACTION            = 523
-	SYS_SETATTRLISTAT                  = 524
-	SYS_NET_QOS_GUIDELINE              = 525
-	SYS_FMOUNT                         = 526
-	SYS_NTP_ADJTIME                    = 527
-	SYS_NTP_GETTIME                    = 528
-	SYS_OS_FAULT_WITH_PAYLOAD          = 529
-	SYS_MAXSYSCALL                     = 530
-	SYS_INVALID                        = 63
-)
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_386.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_386.go
deleted file mode 100644
index 883b64a272..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_386.go
+++ /dev/null
@@ -1,524 +0,0 @@
-// cgo -godefs types_darwin.go | go run mkpost.go
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-//go:build 386 && darwin
-// +build 386,darwin
-
-package unix
-
-const (
-	SizeofPtr      = 0x4
-	SizeofShort    = 0x2
-	SizeofInt      = 0x4
-	SizeofLong     = 0x4
-	SizeofLongLong = 0x8
-)
-
-type (
-	_C_short     int16
-	_C_int       int32
-	_C_long      int32
-	_C_long_long int64
-)
-
-type Timespec struct {
-	Sec  int32
-	Nsec int32
-}
-
-type Timeval struct {
-	Sec  int32
-	Usec int32
-}
-
-type Timeval32 struct{}
-
-type Rusage struct {
-	Utime    Timeval
-	Stime    Timeval
-	Maxrss   int32
-	Ixrss    int32
-	Idrss    int32
-	Isrss    int32
-	Minflt   int32
-	Majflt   int32
-	Nswap    int32
-	Inblock  int32
-	Oublock  int32
-	Msgsnd   int32
-	Msgrcv   int32
-	Nsignals int32
-	Nvcsw    int32
-	Nivcsw   int32
-}
-
-type Rlimit struct {
-	Cur uint64
-	Max uint64
-}
-
-type _Gid_t uint32
-
-type Stat_t struct {
-	Dev     int32
-	Mode    uint16
-	Nlink   uint16
-	Ino     uint64
-	Uid     uint32
-	Gid     uint32
-	Rdev    int32
-	Atim    Timespec
-	Mtim    Timespec
-	Ctim    Timespec
-	Btim    Timespec
-	Size    int64
-	Blocks  int64
-	Blksize int32
-	Flags   uint32
-	Gen     uint32
-	Lspare  int32
-	Qspare  [2]int64
-}
-
-type Statfs_t struct {
-	Bsize       uint32
-	Iosize      int32
-	Blocks      uint64
-	Bfree       uint64
-	Bavail      uint64
-	Files       uint64
-	Ffree       uint64
-	Fsid        Fsid
-	Owner       uint32
-	Type        uint32
-	Flags       uint32
-	Fssubtype   uint32
-	Fstypename  [16]byte
-	Mntonname   [1024]byte
-	Mntfromname [1024]byte
-	Reserved    [8]uint32
-}
-
-type Flock_t struct {
-	Start  int64
-	Len    int64
-	Pid    int32
-	Type   int16
-	Whence int16
-}
-
-type Fstore_t struct {
-	Flags      uint32
-	Posmode    int32
-	Offset     int64
-	Length     int64
-	Bytesalloc int64
-}
-
-type Radvisory_t struct {
-	Offset int64
-	Count  int32
-}
-
-type Fbootstraptransfer_t struct {
-	Offset int64
-	Length uint32
-	Buffer *byte
-}
-
-type Log2phys_t struct {
-	Flags       uint32
-	Contigbytes int64
-	Devoffset   int64
-}
-
-type Fsid struct {
-	Val [2]int32
-}
-
-type Dirent struct {
-	Ino     uint64
-	Seekoff uint64
-	Reclen  uint16
-	Namlen  uint16
-	Type    uint8
-	Name    [1024]int8
-	_       [3]byte
-}
-
-const (
-	PathMax = 0x400
-)
-
-type RawSockaddrInet4 struct {
-	Len    uint8
-	Family uint8
-	Port   uint16
-	Addr   [4]byte /* in_addr */
-	Zero   [8]int8
-}
-
-type RawSockaddrInet6 struct {
-	Len      uint8
-	Family   uint8
-	Port     uint16
-	Flowinfo uint32
-	Addr     [16]byte /* in6_addr */
-	Scope_id uint32
-}
-
-type RawSockaddrUnix struct {
-	Len    uint8
-	Family uint8
-	Path   [104]int8
-}
-
-type RawSockaddrDatalink struct {
-	Len    uint8
-	Family uint8
-	Index  uint16
-	Type   uint8
-	Nlen   uint8
-	Alen   uint8
-	Slen   uint8
-	Data   [12]int8
-}
-
-type RawSockaddr struct {
-	Len    uint8
-	Family uint8
-	Data   [14]int8
-}
-
-type RawSockaddrAny struct {
-	Addr RawSockaddr
-	Pad  [92]int8
-}
-
-type RawSockaddrCtl struct {
-	Sc_len      uint8
-	Sc_family   uint8
-	Ss_sysaddr  uint16
-	Sc_id       uint32
-	Sc_unit     uint32
-	Sc_reserved [5]uint32
-}
-
-type _Socklen uint32
-
-type Linger struct {
-	Onoff  int32
-	Linger int32
-}
-
-type Iovec struct {
-	Base *byte
-	Len  uint32
-}
-
-type IPMreq struct {
-	Multiaddr [4]byte /* in_addr */
-	Interface [4]byte /* in_addr */
-}
-
-type IPMreqn struct {
-	Multiaddr [4]byte /* in_addr */
-	Address   [4]byte /* in_addr */
-	Ifindex   int32
-}
-
-type IPv6Mreq struct {
-	Multiaddr [16]byte /* in6_addr */
-	Interface uint32
-}
-
-type Msghdr struct {
-	Name       *byte
-	Namelen    uint32
-	Iov        *Iovec
-	Iovlen     int32
-	Control    *byte
-	Controllen uint32
-	Flags      int32
-}
-
-type Cmsghdr struct {
-	Len   uint32
-	Level int32
-	Type  int32
-}
-
-type Inet4Pktinfo struct {
-	Ifindex  uint32
-	Spec_dst [4]byte /* in_addr */
-	Addr     [4]byte /* in_addr */
-}
-
-type Inet6Pktinfo struct {
-	Addr    [16]byte /* in6_addr */
-	Ifindex uint32
-}
-
-type IPv6MTUInfo struct {
-	Addr RawSockaddrInet6
-	Mtu  uint32
-}
-
-type ICMPv6Filter struct {
-	Filt [8]uint32
-}
-
-const (
-	SizeofSockaddrInet4    = 0x10
-	SizeofSockaddrInet6    = 0x1c
-	SizeofSockaddrAny      = 0x6c
-	SizeofSockaddrUnix     = 0x6a
-	SizeofSockaddrDatalink = 0x14
-	SizeofSockaddrCtl      = 0x20
-	SizeofLinger           = 0x8
-	SizeofIovec            = 0x8
-	SizeofIPMreq           = 0x8
-	SizeofIPMreqn          = 0xc
-	SizeofIPv6Mreq         = 0x14
-	SizeofMsghdr           = 0x1c
-	SizeofCmsghdr          = 0xc
-	SizeofInet4Pktinfo     = 0xc
-	SizeofInet6Pktinfo     = 0x14
-	SizeofIPv6MTUInfo      = 0x20
-	SizeofICMPv6Filter     = 0x20
-)
-
-const (
-	PTRACE_TRACEME = 0x0
-	PTRACE_CONT    = 0x7
-	PTRACE_KILL    = 0x8
-)
-
-type Kevent_t struct {
-	Ident  uint32
-	Filter int16
-	Flags  uint16
-	Fflags uint32
-	Data   int32
-	Udata  *byte
-}
-
-type FdSet struct {
-	Bits [32]int32
-}
-
-const (
-	SizeofIfMsghdr    = 0x70
-	SizeofIfData      = 0x60
-	SizeofIfaMsghdr   = 0x14
-	SizeofIfmaMsghdr  = 0x10
-	SizeofIfmaMsghdr2 = 0x14
-	SizeofRtMsghdr    = 0x5c
-	SizeofRtMetrics   = 0x38
-)
-
-type IfMsghdr struct {
-	Msglen  uint16
-	Version uint8
-	Type    uint8
-	Addrs   int32
-	Flags   int32
-	Index   uint16
-	Data    IfData
-}
-
-type IfData struct {
-	Type       uint8
-	Typelen    uint8
-	Physical   uint8
-	Addrlen    uint8
-	Hdrlen     uint8
-	Recvquota  uint8
-	Xmitquota  uint8
-	Unused1    uint8
-	Mtu        uint32
-	Metric     uint32
-	Baudrate   uint32
-	Ipackets   uint32
-	Ierrors    uint32
-	Opackets   uint32
-	Oerrors    uint32
-	Collisions uint32
-	Ibytes     uint32
-	Obytes     uint32
-	Imcasts    uint32
-	Omcasts    uint32
-	Iqdrops    uint32
-	Noproto    uint32
-	Recvtiming uint32
-	Xmittiming uint32
-	Lastchange Timeval
-	Unused2    uint32
-	Hwassist   uint32
-	Reserved1  uint32
-	Reserved2  uint32
-}
-
-type IfaMsghdr struct {
-	Msglen  uint16
-	Version uint8
-	Type    uint8
-	Addrs   int32
-	Flags   int32
-	Index   uint16
-	Metric  int32
-}
-
-type IfmaMsghdr struct {
-	Msglen  uint16
-	Version uint8
-	Type    uint8
-	Addrs   int32
-	Flags   int32
-	Index   uint16
-	_       [2]byte
-}
-
-type IfmaMsghdr2 struct {
-	Msglen   uint16
-	Version  uint8
-	Type     uint8
-	Addrs    int32
-	Flags    int32
-	Index    uint16
-	Refcount int32
-}
-
-type RtMsghdr struct {
-	Msglen  uint16
-	Version uint8
-	Type    uint8
-	Index   uint16
-	Flags   int32
-	Addrs   int32
-	Pid     int32
-	Seq     int32
-	Errno   int32
-	Use     int32
-	Inits   uint32
-	Rmx     RtMetrics
-}
-
-type RtMetrics struct {
-	Locks    uint32
-	Mtu      uint32
-	Hopcount uint32
-	Expire   int32
-	Recvpipe uint32
-	Sendpipe uint32
-	Ssthresh uint32
-	Rtt      uint32
-	Rttvar   uint32
-	Pksent   uint32
-	State    uint32
-	Filler   [3]uint32
-}
-
-const (
-	SizeofBpfVersion = 0x4
-	SizeofBpfStat    = 0x8
-	SizeofBpfProgram = 0x8
-	SizeofBpfInsn    = 0x8
-	SizeofBpfHdr     = 0x14
-)
-
-type BpfVersion struct {
-	Major uint16
-	Minor uint16
-}
-
-type BpfStat struct {
-	Recv uint32
-	Drop uint32
-}
-
-type BpfProgram struct {
-	Len   uint32
-	Insns *BpfInsn
-}
-
-type BpfInsn struct {
-	Code uint16
-	Jt   uint8
-	Jf   uint8
-	K    uint32
-}
-
-type BpfHdr struct {
-	Tstamp  Timeval
-	Caplen  uint32
-	Datalen uint32
-	Hdrlen  uint16
-	_       [2]byte
-}
-
-type Termios struct {
-	Iflag  uint32
-	Oflag  uint32
-	Cflag  uint32
-	Lflag  uint32
-	Cc     [20]uint8
-	Ispeed uint32
-	Ospeed uint32
-}
-
-type Winsize struct {
-	Row    uint16
-	Col    uint16
-	Xpixel uint16
-	Ypixel uint16
-}
-
-const (
-	AT_FDCWD            = -0x2
-	AT_REMOVEDIR        = 0x80
-	AT_SYMLINK_FOLLOW   = 0x40
-	AT_SYMLINK_NOFOLLOW = 0x20
-)
-
-type PollFd struct {
-	Fd      int32
-	Events  int16
-	Revents int16
-}
-
-const (
-	POLLERR    = 0x8
-	POLLHUP    = 0x10
-	POLLIN     = 0x1
-	POLLNVAL   = 0x20
-	POLLOUT    = 0x4
-	POLLPRI    = 0x2
-	POLLRDBAND = 0x80
-	POLLRDNORM = 0x40
-	POLLWRBAND = 0x100
-	POLLWRNORM = 0x4
-)
-
-type Utsname struct {
-	Sysname  [256]byte
-	Nodename [256]byte
-	Release  [256]byte
-	Version  [256]byte
-	Machine  [256]byte
-}
-
-const SizeofClockinfo = 0x14
-
-type Clockinfo struct {
-	Hz      int32
-	Tick    int32
-	Tickadj int32
-	Stathz  int32
-	Profhz  int32
-}
-
-type CtlInfo struct {
-	Id   uint32
-	Name [96]byte
-}
diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm.go
deleted file mode 100644
index eef5133857..0000000000
--- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_darwin_arm.go
+++ /dev/null
@@ -1,524 +0,0 @@
-// cgo -godefs types_darwin.go | go run mkpost.go
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-//go:build arm && darwin
-// +build arm,darwin
-
-package unix
-
-const (
-	SizeofPtr      = 0x4
-	SizeofShort    = 0x2
-	SizeofInt      = 0x4
-	SizeofLong     = 0x4
-	SizeofLongLong = 0x8
-)
-
-type (
-	_C_short     int16
-	_C_int       int32
-	_C_long      int32
-	_C_long_long int64
-)
-
-type Timespec struct {
-	Sec  int32
-	Nsec int32
-}
-
-type Timeval struct {
-	Sec  int32
-	Usec int32
-}
-
-type Timeval32 struct{}
-
-type Rusage struct {
-	Utime    Timeval
-	Stime    Timeval
-	Maxrss   int32
-	Ixrss    int32
-	Idrss    int32
-	Isrss    int32
-	Minflt   int32
-	Majflt   int32
-	Nswap    int32
-	Inblock  int32
-	Oublock  int32
-	Msgsnd   int32
-	Msgrcv   int32
-	Nsignals int32
-	Nvcsw    int32
-	Nivcsw   int32
-}
-
-type Rlimit struct {
-	Cur uint64
-	Max uint64
-}
-
-type _Gid_t uint32
-
-type Stat_t struct {
-	Dev     int32
-	Mode    uint16
-	Nlink   uint16
-	Ino     uint64
-	Uid     uint32
-	Gid     uint32
-	Rdev    int32
-	Atim    Timespec
-	Mtim    Timespec
-	Ctim    Timespec
-	Btim    Timespec
-	Size    int64
-	Blocks  int64
-	Blksize int32
-	Flags   uint32
-	Gen     uint32
-	Lspare  int32
-	Qspare  [2]int64
-}
-
-type Statfs_t struct {
-	Bsize       uint32
-	Iosize      int32
-	Blocks      uint64
-	Bfree       uint64
-	Bavail      uint64
-	Files       uint64
-	Ffree       uint64
-	Fsid        Fsid
-	Owner       uint32
-	Type        uint32
-	Flags       uint32
-	Fssubtype   uint32
-	Fstypename  [16]byte
-	Mntonname   [1024]byte
-	Mntfromname [1024]byte
-	Reserved    [8]uint32
-}
-
-type Flock_t struct {
-	Start  int64
-	Len    int64
-	Pid    int32
-	Type   int16
-	Whence int16
-}
-
-type Fstore_t struct {
-	Flags      uint32
-	Posmode    int32
-	Offset     int64
-	Length     int64
-	Bytesalloc int64
-}
-
-type Radvisory_t struct {
-	Offset int64
-	Count  int32
-}
-
-type Fbootstraptransfer_t struct {
-	Offset int64
-	Length uint32
-	Buffer *byte
-}
-
-type Log2phys_t struct {
-	Flags       uint32
-	Contigbytes int64
-	Devoffset   int64
-}
-
-type Fsid struct {
-	Val [2]int32
-}
-
-type Dirent struct {
-	Ino     uint64
-	Seekoff uint64
-	Reclen  uint16
-	Namlen  uint16
-	Type    uint8
-	Name    [1024]int8
-	_       [3]byte
-}
-
-const (
-	PathMax = 0x400
-)
-
-type RawSockaddrInet4 struct {
-	Len    uint8
-	Family uint8
-	Port   uint16
-	Addr   [4]byte /* in_addr */
-	Zero   [8]int8
-}
-
-type RawSockaddrInet6 struct {
-	Len      uint8
-	Family   uint8
-	Port     uint16
-	Flowinfo uint32
-	Addr     [16]byte /* in6_addr */
-	Scope_id uint32
-}
-
-type RawSockaddrUnix struct {
-	Len    uint8
-	Family uint8
-	Path   [104]int8
-}
-
-type RawSockaddrDatalink struct {
-	Len    uint8
-	Family uint8
-	Index  uint16
-	Type   uint8
-	Nlen   uint8
-	Alen   uint8
-	Slen   uint8
-	Data   [12]int8
-}
-
-type RawSockaddr struct {
-	Len    uint8
-	Family uint8
-	Data   [14]int8
-}
-
-type RawSockaddrAny struct {
-	Addr RawSockaddr
-	Pad  [92]int8
-}
-
-type RawSockaddrCtl struct {
-	Sc_len      uint8
-	Sc_family   uint8
-	Ss_sysaddr  uint16
-	Sc_id       uint32
-	Sc_unit     uint32
-	Sc_reserved [5]uint32
-}
-
-type _Socklen uint32
-
-type Linger struct {
-	Onoff  int32
-	Linger int32
-}
-
-type Iovec struct {
-	Base *byte
-	Len  uint32
-}
-
-type IPMreq struct {
-	Multiaddr [4]byte /* in_addr */
-	Interface [4]byte /* in_addr */
-}
-
-type IPMreqn struct {
-	Multiaddr [4]byte /* in_addr */
-	Address   [4]byte /* in_addr */
-	Ifindex   int32
-}
-
-type IPv6Mreq struct {
-	Multiaddr [16]byte /* in6_addr */
-	Interface uint32
-}
-
-type Msghdr struct {
-	Name       *byte
-	Namelen    uint32
-	Iov        *Iovec
-	Iovlen     int32
-	Control    *byte
-	Controllen uint32
-	Flags      int32
-}
-
-type Cmsghdr struct {
-	Len   uint32
-	Level int32
-	Type  int32
-}
-
-type Inet4Pktinfo struct {
-	Ifindex  uint32
-	Spec_dst [4]byte /* in_addr */
-	Addr     [4]byte /* in_addr */
-}
-
-type Inet6Pktinfo struct {
-	Addr    [16]byte /* in6_addr */
-	Ifindex uint32
-}
-
-type IPv6MTUInfo struct {
-	Addr RawSockaddrInet6
-	Mtu  uint32
-}
-
-type ICMPv6Filter struct {
-	Filt [8]uint32
-}
-
-const (
-	SizeofSockaddrInet4    = 0x10
-	SizeofSockaddrInet6    = 0x1c
-	SizeofSockaddrAny      = 0x6c
-	SizeofSockaddrUnix     = 0x6a
-	SizeofSockaddrDatalink = 0x14
-	SizeofSockaddrCtl      = 0x20
-	SizeofLinger           = 0x8
-	SizeofIovec            = 0x8
-	SizeofIPMreq           = 0x8
-	SizeofIPMreqn          = 0xc
-	SizeofIPv6Mreq         = 0x14
-	SizeofMsghdr           = 0x1c
-	SizeofCmsghdr          = 0xc
-	SizeofInet4Pktinfo     = 0xc
-	SizeofInet6Pktinfo     = 0x14
-	SizeofIPv6MTUInfo      = 0x20
-	SizeofICMPv6Filter     = 0x20
-)
-
-const (
-	PTRACE_TRACEME = 0x0
-	PTRACE_CONT    = 0x7
-	PTRACE_KILL    = 0x8
-)
-
-type Kevent_t struct {
-	Ident  uint32
-	Filter int16
-	Flags  uint16
-	Fflags uint32
-	Data   int32
-	Udata  *byte
-}
-
-type FdSet struct {
-	Bits [32]int32
-}
-
-const (
-	SizeofIfMsghdr    = 0x70
-	SizeofIfData      = 0x60
-	SizeofIfaMsghdr   = 0x14
-	SizeofIfmaMsghdr  = 0x10
-	SizeofIfmaMsghdr2 = 0x14
-	SizeofRtMsghdr    = 0x5c
-	SizeofRtMetrics   = 0x38
-)
-
-type IfMsghdr struct {
-	Msglen  uint16
-	Version uint8
-	Type    uint8
-	Addrs   int32
-	Flags   int32
-	Index   uint16
-	Data    IfData
-}
-
-type IfData struct {
-	Type       uint8
-	Typelen    uint8
-	Physical   uint8
-	Addrlen    uint8
-	Hdrlen     uint8
-	Recvquota  uint8
-	Xmitquota  uint8
-	Unused1    uint8
-	Mtu        uint32
-	Metric     uint32
-	Baudrate   uint32
-	Ipackets   uint32
-	Ierrors    uint32
-	Opackets   uint32
-	Oerrors    uint32
-	Collisions uint32
-	Ibytes     uint32
-	Obytes     uint32
-	Imcasts    uint32
-	Omcasts    uint32
-	Iqdrops    uint32
-	Noproto    uint32
-	Recvtiming uint32
-	Xmittiming uint32
-	Lastchange Timeval
-	Unused2    uint32
-	Hwassist   uint32
-	Reserved1  uint32
-	Reserved2  uint32
-}
-
-type IfaMsghdr struct {
-	Msglen  uint16
-	Version uint8
-	Type    uint8
-	Addrs   int32
-	Flags   int32
-	Index   uint16
-	Metric  int32
-}
-
-type IfmaMsghdr struct {
-	Msglen  uint16
-	Version uint8
-	Type    uint8
-	Addrs   int32
-	Flags   int32
-	Index   uint16
-	_       [2]byte
-}
-
-type IfmaMsghdr2 struct {
-	Msglen   uint16
-	Version  uint8
-	Type     uint8
-	Addrs    int32
-	Flags    int32
-	Index    uint16
-	Refcount int32
-}
-
-type RtMsghdr struct {
-	Msglen  uint16
-	Version uint8
-	Type    uint8
-	Index   uint16
-	Flags   int32
-	Addrs   int32
-	Pid     int32
-	Seq     int32
-	Errno   int32
-	Use     int32
-	Inits   uint32
-	Rmx     RtMetrics
-}
-
-type RtMetrics struct {
-	Locks    uint32
-	Mtu      uint32
-	Hopcount uint32
-	Expire   int32
-	Recvpipe uint32
-	Sendpipe uint32
-	Ssthresh uint32
-	Rtt      uint32
-	Rttvar   uint32
-	Pksent   uint32
-	State    uint32
-	Filler   [3]uint32
-}
-
-const (
-	SizeofBpfVersion = 0x4
-	SizeofBpfStat    = 0x8
-	SizeofBpfProgram = 0x8
-	SizeofBpfInsn    = 0x8
-	SizeofBpfHdr     = 0x14
-)
-
-type BpfVersion struct {
-	Major uint16
-	Minor uint16
-}
-
-type BpfStat struct {
-	Recv uint32
-	Drop uint32
-}
-
-type BpfProgram struct {
-	Len   uint32
-	Insns *BpfInsn
-}
-
-type BpfInsn struct {
-	Code uint16
-	Jt   uint8
-	Jf   uint8
-	K    uint32
-}
-
-type BpfHdr struct {
-	Tstamp  Timeval
-	Caplen  uint32
-	Datalen uint32
-	Hdrlen  uint16
-	_       [2]byte
-}
-
-type Termios struct {
-	Iflag  uint32
-	Oflag  uint32
-	Cflag  uint32
-	Lflag  uint32
-	Cc     [20]uint8
-	Ispeed uint32
-	Ospeed uint32
-}
-
-type Winsize struct {
-	Row    uint16
-	Col    uint16
-	Xpixel uint16
-	Ypixel uint16
-}
-
-const (
-	AT_FDCWD            = -0x2
-	AT_REMOVEDIR        = 0x80
-	AT_SYMLINK_FOLLOW   = 0x40
-	AT_SYMLINK_NOFOLLOW = 0x20
-)
-
-type PollFd struct {
-	Fd      int32
-	Events  int16
-	Revents int16
-}
-
-const (
-	POLLERR    = 0x8
-	POLLHUP    = 0x10
-	POLLIN     = 0x1
-	POLLNVAL   = 0x20
-	POLLOUT    = 0x4
-	POLLPRI    = 0x2
-	POLLRDBAND = 0x80
-	POLLRDNORM = 0x40
-	POLLWRBAND = 0x100
-	POLLWRNORM = 0x4
-)
-
-type Utsname struct {
-	Sysname  [256]byte
-	Nodename [256]byte
-	Release  [256]byte
-	Version  [256]byte
-	Machine  [256]byte
-}
-
-const SizeofClockinfo = 0x14
-
-type Clockinfo struct {
-	Hz      int32
-	Tick    int32
-	Tickadj int32
-	Stathz  int32
-	Profhz  int32
-}
-
-type CtlInfo struct {
-	Id   uint32
-	Name [96]byte
-}
diff --git a/src/cmd/vendor/golang.org/x/sys/windows/empty.s b/src/cmd/vendor/golang.org/x/sys/windows/empty.s
index 69309e4da5..fdbbbcd317 100644
--- a/src/cmd/vendor/golang.org/x/sys/windows/empty.s
+++ b/src/cmd/vendor/golang.org/x/sys/windows/empty.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !go1.12
 // +build !go1.12
 
 // This file is here to allow bodyless functions with go:linkname for Go 1.11
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 5fb1c25ace..10591f8041 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -39,7 +39,7 @@ golang.org/x/mod/sumdb/dirhash
 golang.org/x/mod/sumdb/note
 golang.org/x/mod/sumdb/tlog
 golang.org/x/mod/zip
-# golang.org/x/sys v0.0.0-20210503173754-0981d6026fa6
+# golang.org/x/sys v0.0.0-20210511113859-b0526f3d8744
 ## explicit; go 1.17
 golang.org/x/sys/internal/unsafeheader
 golang.org/x/sys/plan9
-- 
GitLab


From a63cded5e413ffad1ec8088ef7abd10abb7b5252 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Wed, 12 May 2021 11:03:48 -0400
Subject: [PATCH 2051/2400] debug/dwarf: delay array type fixup to handle type
 cycles

A user encountered a debug/dwarf crash when running the dwarf2json
tool (https://github.com/volatilityfoundation/dwarf2json) on a
debug-built copy of the linux kernel. In this crash, the DWARF type
reader was trying to examine the contents of an array type while that
array type was still in the process of being constructed (due to
cycles in the type graph).

To avoid such situations, this patch extends the mechanism introduced
in https://go-review.googlesource.com/18459 (which handles typedef
types) to delay fixup of array types as well.

Change-Id: I303f6ce5db1ca4bd79da3581957dfc2bfc17cc01
Reviewed-on: https://go-review.googlesource.com/c/go/+/319329
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
Reviewed-by: Yi Chou <yich@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/debug/dwarf/type.go | 59 +++++++++++++++++++++++++++--------------
 1 file changed, 39 insertions(+), 20 deletions(-)

diff --git a/src/debug/dwarf/type.go b/src/debug/dwarf/type.go
index 316db258f6..eb5a666ed3 100644
--- a/src/debug/dwarf/type.go
+++ b/src/debug/dwarf/type.go
@@ -292,11 +292,35 @@ func (d *Data) Type(off Offset) (Type, error) {
 	return d.readType("info", d.Reader(), off, d.typeCache, nil)
 }
 
+type typeFixer struct {
+	typedefs   []*TypedefType
+	arraytypes []*Type
+}
+
+func (tf *typeFixer) recordArrayType(t *Type) {
+	if t == nil {
+		return
+	}
+	_, ok := (*t).(*ArrayType)
+	if ok {
+		tf.arraytypes = append(tf.arraytypes, t)
+	}
+}
+
+func (tf *typeFixer) apply() {
+	for _, t := range tf.typedefs {
+		t.Common().ByteSize = t.Type.Size()
+	}
+	for _, t := range tf.arraytypes {
+		zeroArray(t)
+	}
+}
+
 // readType reads a type from r at off of name. It adds types to the
 // type cache, appends new typedef types to typedefs, and computes the
 // sizes of types. Callers should pass nil for typedefs; this is used
 // for internal recursion.
-func (d *Data) readType(name string, r typeReader, off Offset, typeCache map[Offset]Type, typedefs *[]*TypedefType) (Type, error) {
+func (d *Data) readType(name string, r typeReader, off Offset, typeCache map[Offset]Type, fixups *typeFixer) (Type, error) {
 	if t, ok := typeCache[off]; ok {
 		return t, nil
 	}
@@ -311,18 +335,16 @@ func (d *Data) readType(name string, r typeReader, off Offset, typeCache map[Off
 	}
 
 	// If this is the root of the recursion, prepare to resolve
-	// typedef sizes once the recursion is done. This must be done
-	// after the type graph is constructed because it may need to
-	// resolve cycles in a different order than readType
-	// encounters them.
-	if typedefs == nil {
-		var typedefList []*TypedefType
+	// typedef sizes and perform other fixups once the recursion is
+	// done. This must be done after the type graph is constructed
+	// because it may need to resolve cycles in a different order than
+	// readType encounters them.
+	if fixups == nil {
+		var fixer typeFixer
 		defer func() {
-			for _, t := range typedefList {
-				t.Common().ByteSize = t.Type.Size()
-			}
+			fixer.apply()
 		}()
-		typedefs = &typedefList
+		fixups = &fixer
 	}
 
 	// Parse type from Entry.
@@ -376,7 +398,7 @@ func (d *Data) readType(name string, r typeReader, off Offset, typeCache map[Off
 		var t Type
 		switch toff := tval.(type) {
 		case Offset:
-			if t, err = d.readType(name, r.clone(), toff, typeCache, typedefs); err != nil {
+			if t, err = d.readType(name, r.clone(), toff, typeCache, fixups); err != nil {
 				return nil
 			}
 		case uint64:
@@ -567,7 +589,7 @@ func (d *Data) readType(name string, r typeReader, off Offset, typeCache map[Off
 			if bito == lastFieldBitOffset && t.Kind != "union" {
 				// Last field was zero width. Fix array length.
 				// (DWARF writes out 0-length arrays as if they were 1-length arrays.)
-				zeroArray(lastFieldType)
+				fixups.recordArrayType(lastFieldType)
 			}
 			lastFieldType = &f.Type
 			lastFieldBitOffset = bito
@@ -576,7 +598,7 @@ func (d *Data) readType(name string, r typeReader, off Offset, typeCache map[Off
 			b, ok := e.Val(AttrByteSize).(int64)
 			if ok && b*8 == lastFieldBitOffset {
 				// Final field must be zero width. Fix array length.
-				zeroArray(lastFieldType)
+				fixups.recordArrayType(lastFieldType)
 			}
 		}
 
@@ -719,7 +741,7 @@ func (d *Data) readType(name string, r typeReader, off Offset, typeCache map[Off
 				// Record that we need to resolve this
 				// type's size once the type graph is
 				// constructed.
-				*typedefs = append(*typedefs, t)
+				fixups.typedefs = append(fixups.typedefs, t)
 			case *PtrType:
 				b = int64(addressSize)
 			}
@@ -737,11 +759,8 @@ Error:
 }
 
 func zeroArray(t *Type) {
-	if t == nil {
-		return
-	}
-	at, ok := (*t).(*ArrayType)
-	if !ok || at.Type.Size() == 0 {
+	at := (*t).(*ArrayType)
+	if at.Type.Size() == 0 {
 		return
 	}
 	// Make a copy to avoid invalidating typeCache.
-- 
GitLab


From fd4631e24f53cf836a67b00e82e2159854ec31d0 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Tue, 11 May 2021 11:29:27 -0400
Subject: [PATCH 2052/2400] cmd/compile/internal/dwarfgen: fix DWARF param DIE
 ordering

The DWARF standard requires that the DIEs in a subprogram
corresponding to input and output parameters appear in declaration
order; this patch adds some new code in dwarfgen to enforce this
ordering (relying on the existing fn.Dcl ordering is not sufficient).

Prior to the register ABI, it was easy to keep vars/decls sorted
during DWARF generation since you could always rely on frame offset;
with the ABI sorting by frame offset no longer gives you the original
declaration order in all cases.

Fixes #46055.

Change-Id: I0e070cb781d6453caba896e5d3bee7cd5388050d
Reviewed-on: https://go-review.googlesource.com/c/go/+/318829
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Alessandro Arzilli <alessandro.arzilli@gmail.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 src/cmd/compile/internal/dwarfgen/dwarf.go | 55 ++++++++++++++++++++++
 src/cmd/link/internal/ld/dwarf_test.go     | 30 +++++++-----
 2 files changed, 72 insertions(+), 13 deletions(-)

diff --git a/src/cmd/compile/internal/dwarfgen/dwarf.go b/src/cmd/compile/internal/dwarfgen/dwarf.go
index 422c7e66c4..5d7dc320aa 100644
--- a/src/cmd/compile/internal/dwarfgen/dwarf.go
+++ b/src/cmd/compile/internal/dwarfgen/dwarf.go
@@ -222,9 +222,64 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 		fnsym.Func().RecordAutoType(reflectdata.TypeLinksym(n.Type()))
 	}
 
+	// Sort decls and vars.
+	sortDeclsAndVars(fn, decls, vars)
+
 	return decls, vars
 }
 
+// sortDeclsAndVars sorts the decl and dwarf var lists according to
+// parameter declaration order, so as to insure that when a subprogram
+// DIE is emitted, its parameter children appear in declaration order.
+// Prior to the advent of the register ABI, sorting by frame offset
+// would achieve this; with the register we now need to go back to the
+// original function signature.
+func sortDeclsAndVars(fn *ir.Func, decls []*ir.Name, vars []*dwarf.Var) {
+	paramOrder := make(map[*ir.Name]int)
+	idx := 1
+	for _, selfn := range types.RecvsParamsResults {
+		fsl := selfn(fn.Type()).FieldSlice()
+		for _, f := range fsl {
+			if n, ok := f.Nname.(*ir.Name); ok {
+				paramOrder[n] = idx
+				idx++
+			}
+		}
+	}
+	sort.Stable(varsAndDecls{decls, vars, paramOrder})
+}
+
+type varsAndDecls struct {
+	decls      []*ir.Name
+	vars       []*dwarf.Var
+	paramOrder map[*ir.Name]int
+}
+
+func (v varsAndDecls) Len() int {
+	return len(v.decls)
+}
+
+func (v varsAndDecls) Less(i, j int) bool {
+	nameLT := func(ni, nj *ir.Name) bool {
+		oi, foundi := v.paramOrder[ni]
+		oj, foundj := v.paramOrder[nj]
+		if foundi {
+			if foundj {
+				return oi < oj
+			} else {
+				return true
+			}
+		}
+		return false
+	}
+	return nameLT(v.decls[i], v.decls[j])
+}
+
+func (v varsAndDecls) Swap(i, j int) {
+	v.vars[i], v.vars[j] = v.vars[j], v.vars[i]
+	v.decls[i], v.decls[j] = v.decls[j], v.decls[i]
+}
+
 // Given a function that was inlined at some point during the
 // compilation, return a sorted list of nodes corresponding to the
 // autos/locals in that function prior to inlining. If this is a
diff --git a/src/cmd/link/internal/ld/dwarf_test.go b/src/cmd/link/internal/ld/dwarf_test.go
index 5cc4800e2a..2f59c2fe0a 100644
--- a/src/cmd/link/internal/ld/dwarf_test.go
+++ b/src/cmd/link/internal/ld/dwarf_test.go
@@ -1660,16 +1660,16 @@ func TestOutputParamAbbrevAndAttr(t *testing.T) {
 package main
 
 //go:noinline
-func ABC(p1, p2, p3 int, f1, f2, f3 float32, b1 [1024]int) (r1 int, r2 int, r3 [1024]int, r4 byte) {
-	b1[0] = 6
-	r1, r2, r3, r4 = p3, p2, b1, 'a'
+func ABC(c1, c2, c3 int, d1, d2, d3, d4 string, f1, f2, f3 float32, g1 [1024]int) (r1 int, r2 int, r3 [1024]int, r4 byte, r5 string, r6 float32) {
+	g1[0] = 6
+	r1, r2, r3, r4, r5, r6 = c3, c2+c1, g1, 'a', d1+d2+d3+d4, f1+f2+f3
 	return
 }
 
 func main() {
 	a := [1024]int{}
-	v1, v2, v3, v4 := ABC(1, 2, 3, 1.0, 2.0, 1.0, a)
-	println(v1, v2, v3[0], v4)
+	v1, v2, v3, v4, v5, v6 := ABC(1, 2, 3, "a", "b", "c", "d", 1.0, 2.0, 1.0, a)
+	println(v1, v2, v3[0], v4, v5, v6)
 }
 `
 	dir := t.TempDir()
@@ -1708,18 +1708,20 @@ func main() {
 	// OK to have it missing for input parameters, but for the moment
 	// we verify that the attr is present but set to false.
 
-	// Values in this map:
+	// Values in this map are of the form <order>:<varparam>
+	// where order is the order within the child DIE list of the param,
+	// and <varparam> is an integer:
 	//
-	//   0: <no param of this name>
 	//  -1: varparm attr not found
 	//   1: varparm found with value false
 	//   2: varparm found with value true
 	//
-	foundParams := make(map[string]int)
+	foundParams := make(map[string]string)
 
 	// Walk ABCs's children looking for params.
 	abcIdx := ex.idxFromOffset(abcdie.Offset)
 	childDies := ex.Children(abcIdx)
+	idx := 0
 	for _, child := range childDies {
 		if child.Tag == dwarf.TagFormalParameter {
 			st := -1
@@ -1731,7 +1733,8 @@ func main() {
 				}
 			}
 			if name, ok := child.Val(dwarf.AttrName).(string); ok {
-				foundParams[name] = st
+				foundParams[name] = fmt.Sprintf("%d:%d", idx, st)
+				idx++
 			}
 		}
 	}
@@ -1739,13 +1742,14 @@ func main() {
 	// Digest the result.
 	found := make([]string, 0, len(foundParams))
 	for k, v := range foundParams {
-		found = append(found, fmt.Sprintf("%s:%d", k, v))
+		found = append(found, fmt.Sprintf("%s:%s", k, v))
 	}
 	sort.Strings(found)
 
-	// Make sure we see all of the expected params, that they have
-	// the varparam attr, and the varparm is set for the returns.
-	expected := "[b1:1 f1:1 f2:1 f3:1 p1:1 p2:1 p3:1 r1:2 r2:2 r3:2 r4:2]"
+	// Make sure we see all of the expected params in the proper
+	// order, that they have the varparam attr, and the varparm is set
+	// for the returns.
+	expected := "[c1:0:1 c2:1:1 c3:2:1 d1:3:1 d2:4:1 d3:5:1 d4:6:1 f1:7:1 f2:8:1 f3:9:1 g1:10:1 r1:11:2 r2:12:2 r3:13:2 r4:14:2 r5:15:2 r6:16:2]"
 	if fmt.Sprintf("%+v", found) != expected {
 		t.Errorf("param check failed, wanted %s got %s\n",
 			expected, found)
-- 
GitLab


From 2a61b3c59088115245d084d5ae07dd4be5fbe1b0 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 11 May 2021 10:52:44 -0400
Subject: [PATCH 2053/2400] regexp: fix repeat of preferred empty match
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

In Perl mode, (|a)* should match an empty string at the start of the
input. Instead it matches as many a's as possible.
Because (|a)+ is handled correctly, matching only an empty string,
this leads to the paradox that e* can match more text than e+
(for e = (|a)) and that e+ is sometimes different from ee*.

This is a very old bug that ultimately derives from the picture I drew
for e* in https://swtch.com/~rsc/regexp/regexp1.html. The picture is
correct for longest-match (POSIX) regexps but subtly wrong for
preferred-match (Perl) regexps in the case where e has a preferred
empty match. Pointed out by Andrew Gallant in private mail.

The current code treats e* and e+ as the same structure, with
different entry points. In the case of e* the preference list ends up
not quite in the right order, in part because the “before e” and
“after e” states are the same state. Splitting them apart fixes the
preference list, and that can be done by compiling e* as if it were
(e+)?.

Like with any bug fix, there is a very low chance of breaking a
program that accidentally depends on the buggy behavior.

RE2, Go, and Rust all have this bug, and we've all agreed to fix it,
to keep the implementations in sync.

Fixes #46123.

Change-Id: I70e742e71e0a23b626593b16ddef3c1e73b413b0
Reviewed-on: https://go-review.googlesource.com/c/go/+/318750
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Rob Pike <r@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/regexp/find_test.go                    |   1 +
 src/regexp/onepass_test.go                 |   2 +-
 src/regexp/syntax/compile.go               |  29 ++++-
 src/regexp/syntax/prog_test.go             |  15 +++
 src/regexp/testdata/basic.dat              |  12 +-
 src/regexp/testdata/nullsubexpr.dat        |  18 +--
 src/regexp/testdata/re2-exhaustive.txt.bz2 | Bin 394016 -> 428262 bytes
 src/regexp/testdata/re2-search.txt         | 145 ++++++++++++++++++---
 8 files changed, 176 insertions(+), 46 deletions(-)

diff --git a/src/regexp/find_test.go b/src/regexp/find_test.go
index 87c49b074f..64c2239d90 100644
--- a/src/regexp/find_test.go
+++ b/src/regexp/find_test.go
@@ -97,6 +97,7 @@ var findTests = []FindTest{
 	{`\B`, "xx", build(1, 1, 1)},
 	{`\B`, "x y", nil},
 	{`\B`, "xx yy", build(2, 1, 1, 4, 4)},
+	{`(|a)*`, "aa", build(3, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2)},
 
 	// RE2 tests
 	{`[^\S\s]`, "abcd", nil},
diff --git a/src/regexp/onepass_test.go b/src/regexp/onepass_test.go
index 32264d5f1e..6a42eda391 100644
--- a/src/regexp/onepass_test.go
+++ b/src/regexp/onepass_test.go
@@ -142,7 +142,7 @@ var onePassTests = []struct {
 	{`^(?:(a)|(?:a*))$`, false},
 	{`^(?:(?:(?:.(?:$))?))$`, true},
 	{`^abcd$`, true},
-	{`^(?:(?:a{0,})*?)$`, true},
+	{`^(?:(?:a{0,})*?)$`, false},
 	{`^(?:(?:a+)*)$`, true},
 	{`^(?:(?:a|(?:aa)))$`, true},
 	{`^(?:[^\s\S])$`, true},
diff --git a/src/regexp/syntax/compile.go b/src/regexp/syntax/compile.go
index 7524d628fe..c9f9fa024b 100644
--- a/src/regexp/syntax/compile.go
+++ b/src/regexp/syntax/compile.go
@@ -57,8 +57,9 @@ func (l1 patchList) append(p *Prog, l2 patchList) patchList {
 
 // A frag represents a compiled program fragment.
 type frag struct {
-	i   uint32    // index of first instruction
-	out patchList // where to record end instruction
+	i        uint32    // index of first instruction
+	out      patchList // where to record end instruction
+	nullable bool      // whether fragment can match empty string
 }
 
 type compiler struct {
@@ -159,7 +160,7 @@ func (c *compiler) compile(re *Regexp) frag {
 
 func (c *compiler) inst(op InstOp) frag {
 	// TODO: impose length limit
-	f := frag{i: uint32(len(c.p.Inst))}
+	f := frag{i: uint32(len(c.p.Inst)), nullable: true}
 	c.p.Inst = append(c.p.Inst, Inst{Op: op})
 	return f
 }
@@ -194,7 +195,7 @@ func (c *compiler) cat(f1, f2 frag) frag {
 	// TODO: elide nop
 
 	f1.out.patch(c.p, f2.i)
-	return frag{f1.i, f2.out}
+	return frag{f1.i, f2.out, f1.nullable && f2.nullable}
 }
 
 func (c *compiler) alt(f1, f2 frag) frag {
@@ -211,6 +212,7 @@ func (c *compiler) alt(f1, f2 frag) frag {
 	i.Out = f1.i
 	i.Arg = f2.i
 	f.out = f1.out.append(c.p, f2.out)
+	f.nullable = f1.nullable || f2.nullable
 	return f
 }
 
@@ -228,7 +230,12 @@ func (c *compiler) quest(f1 frag, nongreedy bool) frag {
 	return f
 }
 
-func (c *compiler) star(f1 frag, nongreedy bool) frag {
+// loop returns the fragment for the main loop of a plus or star.
+// For plus, it can be used after changing the entry to f1.i.
+// For star, it can be used directly when f1 can't match an empty string.
+// (When f1 can match an empty string, f1* must be implemented as (f1+)?
+// to get the priority match order correct.)
+func (c *compiler) loop(f1 frag, nongreedy bool) frag {
 	f := c.inst(InstAlt)
 	i := &c.p.Inst[f.i]
 	if nongreedy {
@@ -242,8 +249,17 @@ func (c *compiler) star(f1 frag, nongreedy bool) frag {
 	return f
 }
 
+func (c *compiler) star(f1 frag, nongreedy bool) frag {
+	if f1.nullable {
+		// Use (f1+)? to get priority match order correct.
+		// See golang.org/issue/46123.
+		return c.quest(c.plus(f1, nongreedy), nongreedy)
+	}
+	return c.loop(f1, nongreedy)
+}
+
 func (c *compiler) plus(f1 frag, nongreedy bool) frag {
-	return frag{f1.i, c.star(f1, nongreedy).out}
+	return frag{f1.i, c.loop(f1, nongreedy).out, f1.nullable}
 }
 
 func (c *compiler) empty(op EmptyOp) frag {
@@ -255,6 +271,7 @@ func (c *compiler) empty(op EmptyOp) frag {
 
 func (c *compiler) rune(r []rune, flags Flags) frag {
 	f := c.inst(InstRune)
+	f.nullable = false
 	i := &c.p.Inst[f.i]
 	i.Rune = r
 	flags &= FoldCase // only relevant flag is FoldCase
diff --git a/src/regexp/syntax/prog_test.go b/src/regexp/syntax/prog_test.go
index 50bfa3d4be..5603aea228 100644
--- a/src/regexp/syntax/prog_test.go
+++ b/src/regexp/syntax/prog_test.go
@@ -88,6 +88,21 @@ var compileTests = []struct {
   1*	empty 4 -> 2
   2	anynotnl -> 3
   3	match
+`},
+	{"(?:|a)+", `  0	fail
+  1	nop -> 4
+  2	rune1 "a" -> 4
+  3*	alt -> 1, 2
+  4	alt -> 3, 5
+  5	match
+`},
+	{"(?:|a)*", `  0	fail
+  1	nop -> 4
+  2	rune1 "a" -> 4
+  3	alt -> 1, 2
+  4	alt -> 3, 6
+  5*	alt -> 3, 6
+  6	match
 `},
 }
 
diff --git a/src/regexp/testdata/basic.dat b/src/regexp/testdata/basic.dat
index 7859290ba1..1776b1ff96 100644
--- a/src/regexp/testdata/basic.dat
+++ b/src/regexp/testdata/basic.dat
@@ -124,24 +124,20 @@ E	((a))			abc		(0,1)(0,1)(0,1)
 E	(a)b(c)			abc		(0,3)(0,1)(2,3)
 E	a+b+c			aabbabc		(4,7)
 E	a*			aaa		(0,3)
-#E	(a*)*			-		(0,0)(0,0)
-E	(a*)*			-		(0,0)(?,?)	RE2/Go
+E	(a*)*			-		(0,0)(0,0)
 E	(a*)+			-		(0,0)(0,0)
-#E	(a*|b)*			-		(0,0)(0,0)
-E	(a*|b)*			-		(0,0)(?,?)	RE2/Go
+E	(a*|b)*			-		(0,0)(0,0)
 E	(a+|b)*			ab		(0,2)(1,2)
 E	(a+|b)+			ab		(0,2)(1,2)
 E	(a+|b)?			ab		(0,1)(0,1)
 BE	[^ab]*			cde		(0,3)
-#E	(^)*			-		(0,0)(0,0)
-E	(^)*			-		(0,0)(?,?)	RE2/Go
+E	(^)*			-		(0,0)(0,0)
 BE	a*			NULL		(0,0)
 E	([abc])*d		abbbcd		(0,6)(4,5)
 E	([abc])*bcd		abcd		(0,4)(0,1)
 E	a|b|c|d|e		e		(0,1)
 E	(a|b|c|d|e)f		ef		(0,2)(0,1)
-#E	((a*|b))*		-		(0,0)(0,0)(0,0)
-E	((a*|b))*		-		(0,0)(?,?)(?,?)	RE2/Go
+E	((a*|b))*		-		(0,0)(0,0)(0,0)
 BE	abcd*efg		abcdefg		(0,7)
 BE	ab*			xabyabbbz	(1,3)
 BE	ab*			xayabbbz	(1,2)
diff --git a/src/regexp/testdata/nullsubexpr.dat b/src/regexp/testdata/nullsubexpr.dat
index 2e18fbb917..68d9c99996 100644
--- a/src/regexp/testdata/nullsubexpr.dat
+++ b/src/regexp/testdata/nullsubexpr.dat
@@ -1,8 +1,7 @@
 NOTE	null subexpression matches : 2002-06-06
 
 E	(a*)*		a		(0,1)(0,1)
-#E	SAME		x		(0,0)(0,0)
-E	SAME		x		(0,0)(?,?)	RE2/Go
+E	SAME		x		(0,0)(0,0)
 E	SAME		aaaaaa		(0,6)(0,6)
 E	SAME		aaaaaax		(0,6)(0,6)
 E	(a*)+		a		(0,1)(0,1)
@@ -19,8 +18,7 @@ E	SAME		aaaaaa		(0,6)(0,6)
 E	SAME		aaaaaax		(0,6)(0,6)
 
 E	([a]*)*		a		(0,1)(0,1)
-#E	SAME		x		(0,0)(0,0)
-E	SAME		x		(0,0)(?,?)	RE2/Go
+E	SAME		x		(0,0)(0,0)
 E	SAME		aaaaaa		(0,6)(0,6)
 E	SAME		aaaaaax		(0,6)(0,6)
 E	([a]*)+		a		(0,1)(0,1)
@@ -28,8 +26,7 @@ E	SAME		x		(0,0)(0,0)
 E	SAME		aaaaaa		(0,6)(0,6)
 E	SAME		aaaaaax		(0,6)(0,6)
 E	([^b]*)*	a		(0,1)(0,1)
-#E	SAME		b		(0,0)(0,0)
-E	SAME		b		(0,0)(?,?)	RE2/Go
+E	SAME		b		(0,0)(0,0)
 E	SAME		aaaaaa		(0,6)(0,6)
 E	SAME		aaaaaab		(0,6)(0,6)
 E	([ab]*)*	a		(0,1)(0,1)
@@ -41,11 +38,9 @@ E	SAME		bbbbbb		(0,6)(0,6)
 E	SAME		aaaabcde	(0,5)(0,5)
 E	([^a]*)*	b		(0,1)(0,1)
 E	SAME		bbbbbb		(0,6)(0,6)
-#E	SAME		aaaaaa		(0,0)(0,0)
-E	SAME		aaaaaa		(0,0)(?,?)	RE2/Go
+E	SAME		aaaaaa		(0,0)(0,0)
 E	([^ab]*)*	ccccxx		(0,6)(0,6)
-#E	SAME		ababab		(0,0)(0,0)
-E	SAME		ababab		(0,0)(?,?)	RE2/Go
+E	SAME		ababab		(0,0)(0,0)
 
 E	((z)+|a)*	zabcde		(0,2)(1,2)
 
@@ -65,8 +60,7 @@ B	\(a*\)*\(x\)\(\1\)	axa	(0,3)(0,1)(1,2)(2,3)
 B	\(a*\)*\(x\)\(\1\)\(x\)	axax	(0,4)(0,1)(1,2)(2,3)(3,4)
 B	\(a*\)*\(x\)\(\1\)\(x\)	axxa	(0,3)(1,1)(1,2)(2,2)(2,3)
 
-#E	(a*)*(x)		x	(0,1)(0,0)(0,1)
-E	(a*)*(x)		x	(0,1)(?,?)(0,1)	RE2/Go
+E	(a*)*(x)		x	(0,1)(0,0)(0,1)
 E	(a*)*(x)		ax	(0,2)(0,1)(1,2)
 E	(a*)*(x)		axa	(0,2)(0,1)(1,2)
 
diff --git a/src/regexp/testdata/re2-exhaustive.txt.bz2 b/src/regexp/testdata/re2-exhaustive.txt.bz2
index a357f280169150b1d351c3fd5ed9a9eeff4ce66f..6638476dec0ae8eb102fff1d339d99b1a3e9f412 100644
GIT binary patch
delta 379101
zcmZ3`Ch=^dl$=vkhNYonq*`#~-f6GyGpyec-@qUcQ(Ym^$0pKhH&L#&zBM}QfLWS}
zX>#tiO=knRS08S86nAS;Q`3s6+!6E2lgqLXy+~rQtDNxe%tRNdmH*}~Um3Fa5(5JR
z<ANhX^IBC_c|MxOz}BoFCCR8&eKp8eZ2_C(0ybYMh6|prCIyBxNM%l3zOp0Z<b(?s
zG*uR@<Y`}Vpsj(Y*N8zY%hPMcU$^?smkU@jn-W+K|E{0-=l;uosTvysI!<V~By5|q
z=%ACb!a~6bV1DLbqo4~{z|6uWOBc4@SSrRPD9OsvBX(&@goaCsh>{VQ-)k~uiz%2R
zlc|~Ez<0Ze>(c_8^(Aj(d9)IPxn|_-`@OgN>I$&2k3GHXEB1(lPh~uu_cm5E`rXwF
zhn7i~XT1O^3^|<o{qE~~>-RE(T=3Y_8=~@Qb$Ql{_3GQct#=Yt-0bEovNmmrVvw{+
zilNuF(7Q4H?Q>smefaQP#?`Yj7gx`+DBfGP$Hwxk)Xv4TOpD!3vYz#2Ts><W`}yAP
zxC-{OQakGx&oXguXF0p%(bmwIHEHUiQEMs}hnp0;t;=|L?(3}&AD%<?fK0Po9B%Tp
z{Cw5h$_Mfw;etJa4-Xn=TC5EXZ?Lw}keYAz_15PDc2K($W^S1iwrbTLeTK4%00T>y
zjUb2kuijUEJ^MU^Nml){J|@QHKkcLLWsB~A^)@vBs;HF4iZ0P!*ObVJtd6h{r&g|G
zD>mt@U9m{0>DJjT9xJ*!R`dpL+}68d#cj7Mxo%e?Zo6r$&<QisSYftkaZ*=vmf7Mg
zot(gcq^_o;(aE_IixzBL(JQssZN<e^CQ)6cYzG+}n;4p!6Rw$ctXgASpVXF<lM~vO
zrL{58)$Q2Ph%J%ZR6<-`Lfp0;>*~_dbvqgouuQWnX;Z6+wn?tom7M6nEM2$WC^M5R
zh@n{;S3(3>G7jW~MCUr?-17dIk*m7JY^7P->4~e3sCC>{+que;C41Vfhf_9+sTg}~
zyVcvfCMROinw+SMu3K_)>T|NzisUeEGs*20bUPq%<96<ft;q@AW=qX(g)W`C;nYEA
zZK<xCQ)kUE&C&?D+Pm#mZ<vnSD&DQl0c#{3)^2p_I(8-N#!Xi)NuS##B54by)}HVc
z+~)N(@Wk!VQ;VLwgW7skFb830ZnUd3LvF8hvP<9wwt6$|ut}5FM%?JkxpH<&X4te~
z(T&b-YXY|}+PWsGt2xZ<>XO@`-JIKwtzGQcu|}Kgwur`>+{m^CD^|O1%{05ewzoMs
zIr+}slewx&-kxq#5_MnLe0SfuWii(&@3TvmJl-J`<>mG@<G>bh#>v-_5S`-k$irOj
zT}d_forPYvS?hDRCWUzCrff>oQf<vyW42gnk(<&Yr{2|R7p0S<F0SHTbR|nST19lm
z#GYw4Cg*Mq&N9|eId!O&?PTuiL^VmBBQv*sSy(*1G&m<<&eL<JcScTGlM}XVt+T4j
zw%aKyCL65DS+?xd4WXnf+PX__dz?&)&bf4R(xoFamza43+>DHzT0gThM@1{mYu9u0
zSdH7ovuDqCn!3#>#KX+1lVNS(wi7p1&bk_hhMnr!uyCf@%}EnCKHvMi>hrP4D=shQ
z+zOmJW!e{X&zYTYU&_^STWZ3R+a|N3mT)Hen1py73GoP8oVDn-<C^3UX~z{yXP8Z#
z>2)@6hI75)N=G%1Fq3UpH%y%EZK%7UDtpelZD6msYR>lROzaHQ?FrLdt!;MccA~DD
zq0^?Wn_HTNZnj&Vo;+Po#Z4z^O{;3u5>11np@B}@GII_&cFfu=mKC`ua<jJ4W~WJ4
z*CpLDT<xa2Sn9^nEy<x0+j>IWR*PocoMM{0l{cD8s(zzm@0O^G+q!dd7hRRkSaI#f
zv86syvrUqELX)M=a;Tk&mRP&umf37Gov4l5g0y<qx-OcnlW{dUl6T{_sfJlO7kjsw
zD9kooESfB~NXu-tnQ5lSjjg>aZY(=3o#k|FO;qomX#(Dyi7XozvfSk5P&?_-x#pCv
z*uFU~ic$g>8aZ0(lLYs;ofB+Pc4FeVt;peKqR^7YquHkQW?4#~ROn6B!$ODo^L=NE
zK3rP1Xo^Y0gc*}PIz<Z(z0sC9)ADdq*^Q;_oO9Ou9W8ot+xU=})N+G0iCeYK7%M$A
zcWO0m&--3>J5*%tmYZn{_L!<k7ONJVY`t3X$n^HIJAOOQ$z-k4&aL0BwVg}piWZ~p
z<|t{GTTW*}wh2qM-s6|fsaiC3TlVGm*0*DJUfv#Fmc23W)myde2G8b}`<C;?i`?o;
zO5>jvxN+~UmG@<q9E-SU8?rNSvQF8j|7W8=d_4BlXw`{c*98ojg5qUsxBk>}G*t5a
z;d?_PVCjmbi%Oo{2o>3MJMqY!&Gkys(@yR5DrS3jF4yn)qLn|x{-|lET$&uwxpB)T
z)ro=}9W#x#Y}s3^aVnKJC%I0{>~r?VEz&D<PbyEDX1r74xj{;Kxt@gCxx4FnJZF`z
zGhS2HZ(^}ot>Nv?&FPvJJMzMfWZ1R+ZdVF6{gM7O>vQhTEmzJ8Xs6E1%*@Q3cKE7#
z{fw~trCOF5eyO#uC*`hUG@aBnJJ;Zv@3u?1TT4rJteiOU!1SU;ixy{H+;&TBdoJrW
z?}&9-w{{BdITEo*<zQ{tABC?;8zXc3Qd=TtW=N>k-eC{D^>WFjEKik5ZXeTirg^K}
z4Y)1exjE|8siY~qVy6l}&UKzOdEv^~NoUM%pH6bCms%Gzcbmz^Nx7bDv%ZBL$rY4P
ze=hyWcixns*;#A1Jxp_L^wj9qoiWMObJJ|Kxt4-LmU&USy0>ng&NTDgmE-ES_141`
zA`{jwd2F3>+DK|jP-|D;m3?b|Wv$ANuG(0(ELX$3On2Fp&66TtUYK^STsCJ~-q*8F
zXHUG;zI<ZkJDIEQTh>K-t3CTTabD@>jAx-?CyhfkJ8#?;9W$lf?B*4V$B((qYPsEd
zgg^JLT^Dw1(rp)GJKt09a)L`H?hV|<YBtsIbzj1>Q1{E5gE^C!>TgSbc6@nq$<y7o
z9Y%a9+s^og^Tv8yT01L4X;XBR=+dSuZJm))8PhH+MMs95$X!s)zT?=}?WNZXFXycF
zopw^?cH}nUlM6L7y6Ylcda@JNF1UJP<6^h#x|xdC(ymT9nP#z&xjVS%Nup=&Mz?^x
z3y=GDXRlkf<W!RGwUfDKmSq<8YgcY+PTiR9c`j<g<vCAoiLG6E%U+|WL~*0`thv)A
z-g;VFb{;pG6ZPC!)#5_b+Tt+3;=&&Z@=i08r`3FX-lr&{In6SCp3TQ23VlhNRg6_<
zEImEr^YM8m{Wg`)o>{6Wax^IyC>JiArFbai&beUAL!Y%Q4%p1#Gbox_*eWw)wPt;5
zk|F10pUW;PlhP)qIOq9TOf<W!aHOqgwu_V}uae*_Uo}I?q%$jfj)^W>8WzgCWOCX>
zMU|PIS1uV&HC8s*YBVj^?53IH5+NneO>Q@GuC2Odl(Ma}S147<&EurutZ6}EYqmIM
zEIIb`_Uf+7>tthRHJ9#qYhAcw?NZ%BwQat0>;1A4czAsndqZEPrW`qLIWxqJJA*5l
zS0UHQX;ao|ZMmD9ZmzvDTX(4ks|UmNm0IBp+iqulVBi*?Q}r@F_VM+woiz_aP5c=c
zHdY?<`t{CeOK8^$Caz_ZQl`B4sH^&7xm(sd-|f4;A5dV*)xF%KH0QQx+O4Udj4F->
zzR6vk7OY*LrJcKB<#(&(_d8D~y(?ND{I2BacgvjEb73{%?V|pfz7y75nb~lta=YP?
z<9ll#{1lRQva5NncJIiv+@-TEX4YD?-11%Tns;2~^R0QF+ozrJHp?qod1uSZV}*Ie
z+kW49zw?oBw&5qAmRY_lXKC+#d}Z>vqGxK7b6z}s@=(fU=83%epp9=Y2l|GF$Ibot
zJ@)Wz6?uhesdJv)nY|*yc}JPwhr`o1y=l2}>89qnv&&6og}3L{JgcgX<(;KFQ{`Yz
zIKT1Kw>poW^$T}e-;rIr+dQt~oSK;3rX{z7TxDHzKg`|sR&;jJYN;jPqFrt+JG*Lj
zpdr&q(a<Gp1cas~g&G~pI_Oo;>vc>tr9(G$&C&&4DV^&X7%b1RTka0b_p5q)eRpHh
zbGDN^T#vka+C4YKbEmo2+P>y_dB=5k9eHXzyZ3q8C(Gj}jXY%>^vle>E`5#+)v(#~
zVbWgj+~}ek;=8W1oYpPbDtMq=@ad-TX(zKKJ|6OrZP=)LVoqAvuO~^4&y9Cl^3?CW
zZ8m4;yK5hUE<QVT_f)#`EpfhkpYMI&TVD7)#Ion;R-;Or?t9(s^2|#mB~FJtKXNu)
zCUfgtiL2ReJ#+8M>{=H)-RRBaZb4I#W6Mgn1)THjHhLDUbIMd&bLX0xple-gq7_O_
zpG$X5+pMP4xiP6TTW+<D@Zn6>{vd6^yxct<^>d=lZluOtFL}msdwJNiOY0t=`&u2g
z-m9crTj@>C?7*^_Q%sllTfKXhy}j}=zwf$TpEGXVJ{4Si-S6gP%ZxWqs?Khix^CmL
zvrBu|TKh+wl`6aImv!RX-pa@4+;d+~yBd|GcPu;W*wh!Zmvr6ct7K(8^D-ppTKFXA
zNtNg2^4>0)ULU~hs}kh8!I(M8f!V-Jh1DfXX^k;&CxbC>Cu5SCawwnD+pN3Wrp!9U
z@#I#7rOC-)C9!ldqil)Se79b@9l7YOy5-EejB{ewQhhF6cG^%_vMy(qWw-41%J-?O
z*Ou)~$ogJ(yEQ;_4ezQox0sxjjJ>uO&%8IivL$d!;I<93tz7DtE8bmQ@apl3UC(2m
zoejKcv+>{@pW+F3!q#n?b2-#%=Sg;D)ftxOUaiVlDs*nkw9R>v=Phij=dPKx^wz4)
z+Y47;Upwh`;xg~x(6kksc}|^4)0uT^a@Ot&35FYo0(%m)9ddm#dM-<8dSt0iI=aZ%
zCu6B%>Jp;}-xbFenI=muGS{m2PT965I^3*lrn9odte_W?OhKFyOLcbVhG)IadFR<X
z+u@yAK%Upy3$ljMY`2}4=bR49xvL#>bj7;ETdh;B=BjR4yJT5!?y<~mULLEpoWh-x
z4qJy!6PldvW_8LmAa|0<ij9+FV-7A3&r6xDopUfOBO_Nm)y>dssp*p00c=xF)Nc-n
z%qSCjE4Vgb%hlM3DbLuhZj^S(R-EM>thD8lTc+rYHK%4yN(-pvn$P`OXV&j&7sM_y
zgmNx8xR~jUcdTi1#A462Zl`i)Ei&315jbnrvFk}Z&0!1H?phst%p^BZ?XIASljkIt
ziHa6|5<P1oOD#)QUODwlEpzcU9~mX(5*6S2l`7Vq8prP5DbbpB?4Wts)ooV|c1=1u
zHS)$Z&8f3mlQ#OSo!T6jv8rQ5uiN5`6+IDG1&vY!6}18vO?e{~Dy6QMwd92Bw%Z@Q
zz0>7<Z=aG;dG>Z|0R!9OfRzE<0?ZL+OTAh<7{r>xm5$xHxMb~8(<QH`d;4ndj9!=7
zvfIooXJ!47*X^2ZDo+m;PFrg|^YEJP<jEqQGoIw`TJp5hbj_(Vi+kSQc>18F@|@y9
z9YHzMe94p6HrHm)`Sf1dDfX_+L)E_Bn_TifZ!W$)C+cv{<f3xdyQSW-vs11_Zn@@l
zY?tWbEKaSaS(jXL-j(&toTYPC)v6@%jM0J9^Ng?Zo9qtN2&=!nq&GTe?hd}$n$g*L
zGR2*KIj?uk<2U!Jh&?=K*-kTGnL^>6JLhhmu4Qdva7<fV=+VM63$DwC)^2>?`!eG6
z=`@pG<+Z2Nqf@UQE)VB>yqz=C?P+m(Y(c}NjGJ1)Dr-F&cxI-oRn42WOTj2Lv-j*-
ztJf{8YQ2+ArJTCb!80?e-i0CM)SB3HR+f`WV<+o!XI?G5oU|?LW>lNywWI0gmOhtq
z4PA5AgslnAoRh!4=gFMs7I9Bj>6G1jeP6!VJo$M^-`bd)(+;j&yDBX_ReIa2;GUq<
zL6=if3MaI;&li4{`zhy~j(1Aa&8bFFXD55IZPv~9xi(XfV@Bb9eI?;r4Rie#XTAx~
zGFyB1^!B`MuT9O)ecpDy#_sEPOBFla*w?ep$7~9*=G>InXt6Hl_2JL|ch~Oy8!!5y
zKK9SO+^4Vi#_c(gI&;FVcg5@8{quk7sWN$Ty@>SW2_jte#ykfY7?+)q%2Z&TYM45S
zQDs)9=4MY7PL)Z%%WiJV)pWR=c2;GQ!z51?5MwEmr;w*ghfj-Fl#-H?vYXp1L2nn=
zo&$Dy2Q<BcJXLzmoDEj(&30S1)wkO9w%XY#r@cLA&Wc=fOJ%FsZP8UfTOMspOv!dp
zIi0!XX6~Y?njHp5QhbF}IuqBnZMdkE;i3~7Dy?uLMRCD}3%#rxxib}$R;^n3{e$5Q
z`_yk~?EmL4nK(Jn(q-}mQI^RbqArqb3LQsWTqK&51qB6?IC@-M96OW@1%>|iO<pIa
zJUPKib@D|qTZtkbN5PJc4nr0<B_)L;f)X7a%>ph-N~)9pikeO46BA}WaYSOWV}>Z>
z^vV8K$^zv|%7TKqxw*M#*RFl~^j*tj#Tq%L>d%ueR>_9spI(3de5H3Lhr<HdZ8stG
z{>At1J-MB?RMYQ(?Avuhx10nt*mJi9f$99}+jnN?URkPngL&`!>gvh4yQVC)W+>nL
zKEEh;d+_!3(XZD2n7r|mjB(MY&oFr&#(UrQ?mfBfu2<092J3s@x9>E&z0xaq1AFzo
zZ{Ol;zu&&TK5qNf=#P^RT1jzNf<W~nx$k?HPByd=oor{rfsDCs$Ld#Kk1efQT{C&(
zCu!EFPoF-0KG{G*zWyeN`Sj`2_rmu+s;Ep+R9VQW%HgTu<mn{jB`_&qNsA)W@9ER0
zPpz!1&hg}MVu32qKKAtS_OqYs*?#WJpZ)A-?`P>}=4U`GFn3@6jQfWBl538x{!v%>
zN0vA4?~|X0qwnwO-}UU)_xCyb%FMpMm)B#Nl>5H^o?Q&5%If=jT;laSRaf8NyCMAU
zjY;u)Q>U~fi~hQ{;G)MLi#z@2Z9eZhk+Ep?yE66jd-sR3vQ6mfb-U$yTD-|@>*_mM
z=i<awF1-6bHQjxYzP|e&m1_QS_IvjOlT%k$zm2()z{y}D#2Wki&GtJjiX2Wd+xzD1
zyq>)#D{=FuB~JDGr~X+lwdC>k>k(HDr=Ob0^)LL>!WJGy7Au(#;&--9{T`Al@=s^l
ziK%a+{w{`sMS2~(lwNd0d5a<3uH%;Xx5m%BcJfVMV$QPJZ@ORVPWjTleBa%ZpV_Nl
z->+5uS*$zv^37u1xmPaN&P(~4E&!ITKUuz_=Etvl29nP&)v8^r2yp$G^u_hp)-}z~
z->-ka_t*V>Q{(&lPb{kO{PgNx;GaLw?(bQ!>b?KkWtAtp`R_YFcFu^ur2bY_d79m~
z%ckq<(~Fu#zfGLKY5gu+rB(i(Tkfj92M5He_yYIF$gN^#QA@K5`}Zvmx*Ggx)v8tV
zeCoGckGQ`4;it<Ve_S+r{CZ9HWib1g;OPrZ7B^RasN;Vmzxd&YA2oK2ANU(;n88eW
z{`SKU<QaajA26*Ke=fgnmEQ*an=+>+dRwvnQhJ#wnxi28^3KfGmUk{2_NSg*@|y4U
zx0qXg8{Re6^?0nB#bePBzr0v_TfCLt>-hR@_mUXo7xhg3@OZ|4o6pBpE>5bldZzb%
zp6n%qj^^5PM}B^;{kHr0{rw^wts=8noH|^Jjy4%Y2<m2sscv1hY~4}wvb(i*_V&!5
zi%YB?SsglBBc#W_ci*C8r$hEV=x5q{G_N&TI@No3lkD;1SAtv{{)L8y27iiPw{hj{
zpG%g8hSrD1<#o<3nx1hfp)zt&=9JADmlE7wzc!Y7_H)Vp{P}|G)Xpi#)P1_F7CqTU
zSZAAOx=jOvK#KwcBZpIf@#*abvUkn4Gas5cdj{XT+0l&;ePcA_ybs=O-M-w-Kwoo5
zgYdL8+lt-OzTFPqcH8Nmsp?K2t!ckce_FMoW8ROCAH9O6)GyWa643})s_7LpWua3m
z%Ti6tGiT47Ik5HanX|gLvkPqWv?_v)jWSiHt?x+=J@s>1>$dNEwjA#lSa|F4oWi-2
zmq)!=S9q)}<>e(KBi82%eD4%w*B)8-Oo8c<WakZU@2`>^wNt;fM%S&{c58K(`ns>6
z6tK<X!nBi4zfZ0Hv}#-Z?c8mVsnfjG^9$I%tH<6mwPIk%FDkwJICudA+jn)JcMSKQ
zyxx86?p;&emkbORfxMD?vsSRnbYz@;9dXQ{MbYBTnS@(Tnb~Szx7}LBIQJCWYs;-6
z%$5P>k!RN=OE?M4JeOwJqG+C*^6YkQD1-a@eCg7A4Gc22)fKnbePLjD81nkUJBEj^
zZy&pR*X;GSFAWUbE7TsFuMK5*cSX2x_O*>Yi5yPlIcL(6jX8G{Y00^e$v(2y_1k$J
zR3C?4t-3wy1IwPQUF)NZ;~1v*hTLIL^$m{>yEpCh<LZsfTf=r8@2+^`@HTYa#z*(8
z1&j@t*Iv7(Th7IkvnM)tW!%$pAFZ{I?%n#Xy(=*^U+mlUozbCTIX8TCw)RBpKDwQ2
zJ%Pv4A?n-ha|<Mj8n(XOKG%W6Ntn+;=#pUl=V!)mR_%Xp-Ty%LQ~88NT{88&<}Y%M
zBrQHjvVMLdW_I{^N0;m&*?A8uj8ESQo)TcY?8~iOi`_=a47uBG$IR9<6M6LX)QKH)
zcbz%AIrku!Cr3~Oh;_!PcbcN7B8czdG|5SH$wm+}PF!u-bA8@xuPe_LPg=c2%<OPI
zhistVs*lIEN9SyvGzFBtCM*>aSg5pwlgVL%3W!kSY;u_X<?X5~Q~uRoXB4U1bmhz$
zlM_eVrX>f=NV&|cb&*>+XycTyNY$C5X_qdX@s<b;GH}yWjmTMZ*5q{HWVhbPRVOay
zhFrUGRwvBIFvzIwQp(Mh%alD^R~vFHYO0?kl*_hRbED3wOQt#-rMBGI*3+sT89C8o
zwz9UE!PbNeVO!U3Iinn=9ISKJhc_b1&}XYL@4_wHrX3C17Lq2kwlnNX=A>zvv(wx%
zjdP~mn6jzu(k7#}i`+VDGkupD=Z2iQwQ_b+n{HaBmXAwV+LoU47u1A~t=hS8!_7-Y
ziHDLd)!z`CDR%1YN!N{Hm$l6nomH9T@g!3=QOD!$#uFB<b2r`AomNn!<T2TENt#vC
zmBXH^mDS!Y-nr#@@ix!0HqRB8jxIPSdp*4Dy66?pD`z&Eu8l~{$=#H7bYp18l;yG8
zmA83#=FKfhxHD_Y>NVGNlKURaoEkWzdExA}+tjtw6DD4o%sb~I=Mjzv-Hn0Lzs-6k
z>nSMK?|Q5dTRri0@9TADyIyU3wR6#pl{%t}0|OV`SZNYw>Jlxn*|gU+S<Kt*f_HS@
zv?Xh&Tujb130xVqwpGGR=cq{7+D$sQ)UIw^xoO&}lv_s*yBU`GEL+>#+r6~ojdsYa
zwW@2(W~m+V+?KXz&Dp@++oN-5vK(qVG3&{a)`YcDDywJfnRX}4I=j8>wWnt9joWM8
zlgzHTM{91k2)tanV@|nNnC7;ViMg5CT-$nAuJp^gG5L>zLH(6ww-ST$cHMaz-5NbR
zPiUItk%XtacPtf3osu0KZR(M8W{c6}^3rXq+hk@NtnMo;vd*)-bmQ~PSX-y39lMfK
zuB5xIuikcbc~@HGjI5~L8>6!fovpHrHm$jxE#94XYtmxltlmvIxzfA*RE^aQUI*=!
z^zB`BLvu%^x!J8%UN=hW)1Iu&cDtS6v3A|7?zM|<r`%ZfOy|xdonsgGEGY=wI4S7t
zb}h3T7vD`@*~wSU^GU_*Ube^9sa+{2IT!gVrS52#4lldHxYum;>~&UaeQs~B*er8t
z<#}<_)EUWYno~<kw_RB)bvr+J<;tV6n{GZlF*#?lk;6n|)ftg`%eUQpm3msWUUsST
zWV2fl9`hb(Heai}Zn->o-bc9;lYNeLT3qo@RkWOT>ZY`Ma^*?Ex4{{cE-aO6aeUzM
zK{V*s3a8+=PC_$8y_u#ag#>nr^aM;6S!LkHab$`ilZmKXtHwbwjx9>O9L-EgY{}m~
z{&Ihr`|I1K%=GeC`}WqYwmkRcB%=xEUEBKQYquXLZ+TKtQLDKxIzM;Gk(Nov>uT@M
z`?|X+*L2%Ej%0zOnqJ9G(mK|$rQ5^9v)1i$G7D&#)S@y)Q5xQcYnk+*<ythX;r3+J
z{HqOh1(Vhv6LkD>XxV~AK0HelSB6N4I<{<>BF3PjG_h48)Fok|{MlDa^)<{V3H86L
zt(nrIfA~+`f|lApcD0@&(|)k@p78YiIc3uP%YWu7dA?K?Wq-t)bH8(Pq_S=ORH-#H
z({AbZ_IhNCb%sT3_U1Sf>=l%glNPigXO+fT!41t4liDvV&DPqsEjKi$H^;Rz)684Y
zP<O$$m0{birSx3XW{DE<{J?(DsAWykG6NkWZHb9JTFE>~V$IHmJQF5d>@c|zapbU2
ziq~qU<p)YbjJ#F1M9$bUBkPix=9aaq>s@Egnq@XEEn>>aRXI9WbdF?3EE5hfi#l_5
z$|lc_mJ6N&Z3;Igt4?WMteu?@nK;8(NhND?NXS`F!^W(v$;Lb)X$qS~b(T)Ja%Ic1
zu(O#)m!)p{xa#;yC5I*U=B^F8X_z|Ebb`y4h?$%{r`D{R((5wa=*(oblP1wBm(Fks
z<<72mo3L?}YOmA658e+JKbm-Gwa;o3w<xntql0U5SKQjNX2aP~lY?$<t&_uMDeD-W
z4r#fhyX5Ak+fgc)dJUyGS6rR3F{dq}#naeVO(oQ0w$tHIBex7y(<y5bZY?rWn-!J0
zENXJH<iu>>tQ9(`jcXS6+~`?#RI6u+?b^;QTDLBw8rE-H*p(ADL7UCj?c~a(A<5E`
z+F_<ir?V2HW~|*9*~?;J)U;XDm?L$nT7;uMr<Zl8cdF1$&$b2IJQGqI6NPl8wN^HZ
zZ59pPI6J4}2G98$=dYW;Zh!NAfBN3{HRqLIe&U#RnDc1G(|7B+k7t)|I~}Q+yX|(?
zrAceUTo)=W(pscdzl5{FQNcrq<LuV8+tO~Q)wgP`w7=o_qkjFDy7-5GMgATCAj9})
zcmJdIkAC)(qy81odA{PU<)j;l4_+w*KJLxib~9TQ)EZi<=%u3Q<mwXY66)dvsj_Bx
zhpL9mKR>h4`hE5J((C&>*lQ0?_<Xnil3-lu1I7IFv;Gy&d0)TGW6w+LdGjvc?tSsA
zeDA6c#RpP!zuc~BPB<X7dcWQK^VRo$huq5Db_0=lPH&T4cO6gOapc?t?hS=kJ+~~F
zzx{@F)3>sNcf>bu<9o38@BTmcfBfHnyxi>m@|Sfn?=Oem`+T2qf0$kW>HNBTuQn}V
z68rOW{m0@t?;-B$clG<W_1?nwxy}6rk|J+x?^cGe#)*nDsBihY?H$M4vfH_Ld6FcS
zYWfs7-tzQG&Rx4*_Szv2kI8xJ67`!WwA>PyB;+K}_@VH)@VDRWjMbSN3WT@KW@ohi
zIf1$FW$iPANzo1b4?&?4fBMv(LhhQM>p#Hl4t<*PKKt$6Z8t2wGfwn7#27xcGBCIg
zY%}MU8wi`7GuLisyB(cpd2W{za}&59*uu`DQV;7L>Tx)kfy$Yjg`BG8tDd|*zCUZZ
z?N>2RBj39>Rql&be0+T5Pu+R{)t8^!=g0oAwOen${_2}=mB04<^LPFF^qXCO-uc7#
zzP*1qFRt!+W&ZrdPd<LBj{fk|Id|Lb+-;XQ8yFlFJcJn-7#LU@^?z8m%(<N%ox9dR
zrM|(FVe$;#4MIL_CmXB_Agve`PNoC~0S_UTMg<5V%)oL`!TU$ZyN3C1^S0e#-Q}CR
znepr#L5}aTrX~yw%r+t*lNlHoj2oZ~5cPZ7iw{nBb9XC!$g~!mlk8_y)GqndLNRaK
z?WiqVgh1`5(2Dy0IR6TWB_Qh<JeXE>PI=eQtaI)5<~s}L9Zi=u`#A6EJB}3vXHB==
zPR_QP(h5q*8^x{}P7QGlaSd?*YxZH#TC}2T#f(Ra!tIf3x66c-7)q3#U0xUv(6R9F
znrpXpqa&{@(ew(Mv^Fp|SyI#`5azLZu+RQK)6iBqm2D<%$fmGkL-Yp*CZ_&;W<dr9
zhUE+l3_V=-Z}h#|R)sL62>s?b5D}_unxi{AIcZYEZLK4|Qr;?ACnsGKnz?mX>WyP}
zGhQu^^m?r`%`9xSnAxJE+g3Pj;?6Z)6CZhF=@d5C%?_Y|VUQEFxhUbWB<$dqdW|9#
zW+4#<1{RAsKg5sSkjmy35(_a7&W+OaWxQKaz`S?MB1eS)&*d|fY^uWq`j~5Hs!YgQ
z{;O*F%TSLKCME|pUxZv)<)g;zs8xM6&_9IXvS7=+m8zm{3=EnoOIFzW3ssp)Xk~e7
zEf&6Hp!U!Br<%8YYs`-6AMaHk-?RD0(|S2KM<?Z;EeXo0x?G-`89|=jPLsT%#Jkiv
zKDs6xa61(x-er@a5t1UJWO3S!$t>u?l1bBARi<pwR9U*P$|RxslvV60tGKJDJLhck
zUQ_Zp+-t(2WzyAKOYXjlnO(eldE|{xuVr=}*V}mF>*@ZgmG0iRb`}~>J6YOibM<m2
zk5*#+_TAyW_nw|jx87Acw_k7L=`}^KWj5T+F4?3pNn@I~>efjIx>P5fjP$xRZJyP;
z*DEdf);-@_w&#P~u4(g4vOc?;WIgNeU-xd;<c3!hLCa>=az=X|&02L~>Xx~c4{T#0
zYPViltC_i)Q;|_()drPZb<tI;{S<ZWGOj-B%c#G4R$e~#ZmF8q8cu1b&N*SL5XOKw
zRuNu)jL&*wE}oUzxqR*2>r95B2_ConbU39wMc0Ief}@oA>b>gg1)m!jzV5zTs?P9P
z;^OLARd?@}sxw}_^L^d*UAyOfy<_u$L4bjQKfLmN?BR0^3>6YrrRp1wt+<laz|^a`
zfZ-Mcm&vjQ<`g4FHit>RYKv30N-SEiDN9$Z+wG*<<iJf)J%Is{refW$i<WHb2@L2=
znsLcgM5{At<FqLvx*8e*zEMZ6F73H;BWYI9nb~3<ixx-u_PQ+&Of|}hRO;%@G&7az
zbvv2V)w|NnG*ZWHrJ32*r+)RjN)NF5?J7MWtylCs_0IC*>DGErMJCPg>P(!p$hT$1
zv>T3|p{^SvHg-$#W<^Xk<hho~b1iFiX0F$%ut43G87I?(a#U{aJQt&`cdO{>=~Yjr
z99c2p$ckyXOI<d0Nr#4prg^8Sur#EuI4d}7>TIL7q*b@3Zc#|<IvXOK8g^=ealO}O
z*Td1uyg9idNj*W!biHOQ7D?&}cH-Qurn^|wq;s>H*)g-;WhXW!9fgonI#x@~6kMe%
zawFs7VplUMlZ++2TS8a^vjclGj;(gPrL`s6b*r03v|_ICiTDQvhuJtXoE6zx6xn(u
zToid+1e#0|x6hdD(a9-oHtWo-mG!C`Qf{e}HnRqLO*RqdS$It8j792=fF;o;Teh9L
zal5sV$F^!#-m-Jq-O*fojMhgRU(s6SyL9blLFPlrNy3Jlv#aj}dY#+W`EX_8lEu8v
zJj}O3EwX$}p1B_OI2`oNxAjOW=d)#3%(`EveO0=gA+jVYmu=bAwbiDfpKHu-_GT`r
z_tr{_oaW^-WvNasTl&_z9e?s}?=*Yr_c~AF;)-YM-pQKgU(MZCr|@dyhCf>kYVIz%
zHTTPl=~Es>sqf9Xsj^sNw%f&pTetpT&UzYM(WJU%=|V<LMMh0UMU|G8DGL=<T2hXr
z97&m3V;OjQCTr2tb?%#UPMtCfll-z&<J`8hN4MRs&%K#H>+0>imz&-_)L*^!g38TC
zR##WojT&dQ%C1{yY0tSE<}SM8>x0aoWw{PDZao)o-462H<QSl-WU8`tZGPLn$qJcE
zjnxuo&Q$YC(++MG%ucy>>&}AP8OyHe&CY8t51Ko5)7E*>W_N2tV=V5kx_v0utVQi|
zMn`x4#2wK&<|pghUmW<+J1Nc9Ofgscbk5@4o&2WGQcFJ@n;m<de>L}^v?GghCP&Nd
za~2UrMJ^M!xg_<v#7l<O=Jw9!Gg|#L>zk~p@7>KN&r7W(7oJ)Bdihe3g;Sf{zTD0E
zZ1X(j%AB`rceQTPJ2l(Q^6<luEAdhR$5w92jgQV){Mf%-<JO!jGwU1scAoimYvQvB
zXQEZzFD{y16C1qNZNtul+sV0;zG=P<IjlQf_S}`i6@?br-KVdu+!VPg>y~utwk4}Y
z&Z=g<j%##V(z;qGRBWSaAY0@fzuCHXEu@1}ZZ4d(JT!H;*0aNs?x}ZnE^AMm6g$Ua
z_R^edqT5b!@@n3czN6Q+bj`Ba>+0uROx|^E?LqOpJIZPqn^n(c=M-H%yLxv1_LFs*
zWltp84YICt?K<TvGFw77GF5G|%2b_BrM7GGOEN-TLLk_6b^f(8W$%oOdU~}@qFU2B
zw*_vRu{v;B?zE^|?~Y{5bUS9IovG!qQFKK|$BbCb!(PQPJ7u@z#XQwATs^J+=*Dek
zt3PmYDNCAcRSAmJVsvoG^qJ)8)6~$&9i%cTciTO`;L@JbPN|f(NhT+GRWc_<ZJq9@
zG{IwukY1R~#cOx&cJC_fYwnmkn`_Z@8Rx#VE80;vrOR@A&t_g;E4a$o<!+LjbmXin
zX{T=WW$h|nnzQc4EbCB-D>Jfks`D<csNc$UZ{?Yt>m@dOPTw8dbSpA0Bq%V8xj5@)
zZqBQz*Sa?>I}#Qx&d2rg-3|TJS+|zWxRy3e^RdzEP0Nxt>TUTRZj-GNDL89}a?vxt
z2i8Hh*>`uXzIN<(O0I5T$W%k=BI~u6o|kYY+%OI|43*kymUQp-;^lhV_ariY*c7gD
z>*bca^=2>DvaXut6rH<bq0U6L%W2J<?X3g7mia5KK4)ec(Z6=f&A?j=Z|yo^x!~EH
zi+-u56SBgBB7LXaHo6?fnY($_p#`s_rk(Sc9C6um#o85b!>;B?D_(QIwm8=_>V;wy
zPr}iyewl&2DlvwU@3u8Q>bh;H8lv0$nSYX}ir_*4m;9OaXXj+Now@V8)KhCxx8~F>
z&zYaFeO5EM`CMg^r^><3V@eh$Ely5zGceYiCU|C2ve2Q!W)C@f)NY>Ckqr&hIXT1S
zu~wQ-RvJ%sTtVltg&UGJ)0UZSiuUZziSo%^v=YXQc3Z!B&Q-qElZ(Q|b59=Ixi5Xj
zv@E$JH;uLG7n?+O&fKz<Q*+a7Zz(s=$gM2B8Qb)8w!LksnzeQn*N3ff%A$PQlWfW=
ziq5TDy7lt`-8{B_-s0AbpT*H<Ena-jTW`Vq?s}Q;zHh5?pRDc75egPc-~71k*w<~T
zX2~U=7QTLY;lBSA({O#K#ZS*}eR@Ib)`f{%RgH5N&Q1)9H1w=rlF~ABQOYI7Ng3PB
zuV2nrHuB_6nU<(?_*(F_7u%<&>%6{DnY(7$s>A0h4`gcv#n)c1z54C<oczk;IxcQ2
zSH|b>J$ml(=I7F2O8Rwm#I{AJx}O)dW%6Y4oS1XYO*XVNJl!}z^nTTQd2u6I=bn#u
zg<Dkk)N~CvviVZB9jy=Cq;n}*o3HTmslt>m>4CS(J7>;2e8E@r&drbf7SE(Tjz@f+
zJ3A|PlEowO^Tzr9f!F7m3#(L07xqut*y*{QfpP20GAZ8R=;S%yWs(HC&C;V9mu?6N
zo1Et5yEK=rIa)Kv<<c2bZHZ~7X<W0|qAvTc`~AG+JHzU|AaY}IWBqmu(ei!e{skhO
z#j1VT5_5$%hQ8|!eIO|H?C831UB`gj#rdYM-kB$FQ#&sA_~D%6p>eB9zlX10^?1j*
z>zkQZ-C7|hU68arJUVy%p5N^|vO;Fxk1vgTwUPUU;mXa+ax&iTzFU1@*W%k&3qHIm
z=hnKH?YVXK?YQXKtv9!xF4mhoyFO3(>^9GB6Bc;1*-W4M;_&eUk4~I2I{VEwrzF>R
zdz8GmVDPP5y}Q>$ZcN&eTNU*wGQcfh>#Wl0xjok&dX>6Fiye)go2hNF?L~XhtG7{m
zlouHtmFzU;*?KGRMt78d_1xW;UieN`ygI8lE3oV4<~0|MtDUMhdL7rfyL9*6y<K`%
z^$TAviCT9lFU-Ko=eE*ioqUg_TTcoxT=AH|x~Rd7Ra8o;7lc=*EnB)(T3~i=xJK}X
z4NG{J^9gS0>+4>Sxh8qG%*t81o3)Ph>E4`Nyp_A>QD1uQ_42&xZO2!M%55p?Iq*EK
z_1N{I7iHQ#&5_Z5N!MQPdOdN&l$==!p@&Y-sGqyy&DI5*qOOQ+_nUTCICtmWvJFRN
zlh&^CIaFRQ=6w6s%+Q$&Ho3V>RPfI6&fT3Kp)INy#Ork`Qfrg%9i6tY(%Htl{PgaM
zXIhKAS#kH;)lCviE2E2cZV#N+wQ<GOmCLRh`h;cWZVKVqC3Uq>J1xySQz&<KPT9t(
zt!%GW^-hYa*Hvtb>Rl?Ex<#66o90H}84DF#B`!yEc1A9YOma$;WZopZB-?A<wXK?G
zMYnD=o48igSR*YfV^)&R*(JB!CfFyN)tSG!{WWxg3EP^C4Gasmh)8)gUE}5yJ1DUt
zDB46>Ya7eOwcgQlS4O95Zr9W{mw4>fx6Z1oG-YRLX-ICgaeZ#I5G&ioWjCi>x|Y34
zI>+~@NT80#qAu2iYr4|{T}86IG(|KgyNU!xOmr1moME~lH+AA-w;s2}BFV`C*`kgs
zdcsTvLyjHxS)`<vwoF;If#ZV9rf5y043CLQE|)!)TIA>kEh~Dqv+RUtZq(|qwb5*U
zI?c<a)Lc&Vy)!Xam#WX@obfO;FlYg52ZI@dRMwg`N5g^_&YA7az45NFPPy;t&cZoc
zie<u#1(%iU@tt}TJZrJL<eB3>N;fo8wKa9pmZfYHx}DPYs^#3aElUl3k6Wy{d1g<(
z<RL$q-nISNx5_n-$F%mnd#4e2oxQMc+v7d&d^gDz&pjtQIo8c6=3-f7eRuAKYgeS2
zjeV{zS(mptcj;_bljVLlE<6!Tj4`{d*1PV~%<H1pEuL%Mz4GDn<U_B_V(z@ilFp6R
znaw9~+qz_0z`WPHd_@cIs&&ms_S_t?H7jS@QLZyva+N)o1WW7{;!9Y%&Qh~BvQtQP
z;_=)KYhRbR+_<;t*rI#kx~J~49b9_1zO=izWXbi?>$+mi0b!-r%d_6SUgQ{I*c;%w
zN^I(^cgeeZPsAR3VtS<o)REsLxb1e%a%t^$>B+G%)~jdUUfmZlP50{6+kMwv!%lQ4
z@XRzy-KwO}tme~oQ`>O!&ZF)Y?x{=9$%t#Mof@^3Cnd$~jn$nyPfb40ammX_-@JO^
zt@^FGD;;yc$Jf*zt9_TJyX(@GC}pGetj^teE9M-{omRMTyK-sdP9xu~QlXnREK`lR
zb<On7yJvaIx+{)FEL#)U#+!7}ZL{5rAJwdDbymA=T{!bOU-7x(ZH8Hnt)}<mzE{gl
zSz0YB?RlCr=t|kz-i+Hx+a|4@bo)pA|F*;#X_9S;^)u3hpimMj1Qv%9+*(PeRdiN%
z>r9yB6%=&JQ-O8qrkj~w3=C|#(@qPyghp(O*6|cnnX-}PmY|ADq}i#PIhPKwu3W1*
zbL9%AE7zu+nQF!mvQp)wnrG0V)7&~Ly*W#=Q$rMH`+B5iC8yoos8+98`!U?pXz8@5
zplLz3#B>*cJ9AvOLQ{-{ozi;TT-w^eLmJ{AZbxmqyLEN$zxpmE1TbXd=s4mc*kLFr
zDB$Aa;)b*YLJ7PwLRlb5NlBr{v7@7-$&gJ+Nr~f#L<a~M3W9-#AZ&Ss3rGz}rUSZ$
z0%8DoX@x?M<MhTv7O_NS7MCO?Bnilxi^ji&J;@Ts414k(Z-g>-y#Wg(ORw7vl1P>~
z_D=7ZVGk1j^*Rt=;+WyC*Dy^_l6a<n)MOT`hY4Vsg3$Fu0<<&)=6cBD5DZHZ%Hfva
zGZU(at0(VC5|0ZAOg|vUD8hsA#p`v`AKqXVo_xwm!t40->C>k#<p2Hqhuv$)s*z(*
zdIx0n$Tk=a7T?1N=flKzc;{Y^jazkp`bIxS8F#t3xH5zc#6)Di*Q?cYORs>|bFAHV
z4Ky8~vUc0GZMUOt=VquJn4rR0UV8U>Y-#!AiPqv=3prI~%S*4v#@9~XC@!I5{C?k$
zz3*d74?0-q7EHS&(1?Ye+$5n=zXK8}kXVF7p~NxE%3BY0mnbqdl;NPud%l18{^9$)
z^XZ#!8fi}S=}I#{`?=;mggBEAS~!wa_-|jw|7AAf7iErE{a(DhAl`Y><~=_@&-pGl
z$My4tn(tDD;<oJd{ie0I9!>h0{WbS{_BNBx+phjnsVO`w_<df*>V-YY`FAHVu6dqT
z^E3Z8lf%s)&*z;_d1rm>`&!T#<L#X62FbG9&zhx$SXW%hc3pDy?DKw`&+B%*zI-`%
z+wFt-Es7j2DlL=SRUWU~b!?fmT}Vgxsed6SQkY`DzbU_a_j#ZEwYvJhzrX$beDL=U
ziwA!inC2cYsM**50t_Bm^eK0MSs<btyg=mltNs~Lzm+4ReYfwn_r4RARI~Z|($Ae6
zpGtqqE`9K_`%~4<X@_Q2Kkw;jzv{onZr<l(@4WXdeE#@)s9@I7elFd$SuOf+U)tAA
zjj#QFe}mp+-|~8y?epsGc3!_zR_A!QKfmfWsMOtdY(In18#c2Kpt2!eTzKBIuXjI{
zt-T)h{B-(r`{_Q<&p)%b>|DFw)a2;p%<uc7^Y3e|`ZsyM)~Z!2C+nJCGky8t&z6rr
zZWikO{$_p0#x69}KJxeX_qU&)XZ^EZ`)R%Q)KgE3c2E5#pZHC_p1=JtWH|_EC5Rp4
z@1G}sz1Pz(-(O@oRcV^Tz85d^U01|APuj4dT`6A9rY88jT)f#_s{<eB89lqaJVL-G
zz2nHs6B!zE#z)>ImFG;~@%qcjkH-zW-`jj#*QuYkv&ZlIg!L{7jK3EzwtQ}#x2Las
zhxN0)avd{@epg?+oeN&NVETh`dfpqYRb2`i`i8fnqEmBqw{FuZkXZ#5;Xd?TNlESF
zzT3BJkA6P2@^$+Cs@ruxL&GmQ)Pp=c>27JS&;8j_p`oFnKVRqH>Xx}bTl#Hs>c;Kg
zet+Yc_eeSO`vv3gg6#MHe*OC^+@{X;W%~PSP?Z0wyzjukP|v_5&|+5IAaP$Mc=z1{
zzwg;bAN=Tf-|^k;?z|A@?&&*iK&7$3p5OQ4wKkW{J-2V|%%0HDhmVi<%YlZ4K~wTm
zmTCknbo%{L{gS6{bohgxpIo1MEH5vw-o3l&T2)oW_G{NZcrbp<HGSZB_x7@Q!P~OC
zx0jrn(4sD`$T-)kUVQ>6lELQh`lio$_wL=hXBvW>tMA2YEnnVg_jT&pePNDQ0>iXc
zt@@byQ)hB+gY7o67rW2tGqBy3E_!dVhe0|gZ#P4APOfG7oZQ}x6%6vJpAT7GKE=3q
z`gxAmo-d9Gw5WZ1_ssY_=j-<srQ2>*I`B^2)4g_I8H3T<C$W<|97O8vN^jmtJU)fF
zI(zeu!~Gg;->!=%@IH@SyyN)#y$`R=3*guK`S|c!n+4L^&-?kd%<D<yaLPIN%y7@X
z?e{*s&fW5<L0Y>~Ji6u$Lu&MiUAJGHHBsbnw!L%Ad=i81uG^{eAU5TG-oQ9DU+H!J
zVv`Fkiag(oCGL4JY<rzMt&;f$!>P%C?WOA@avRhhpMGCiy5%zp<MAB^_kR7owqkd6
zr$4*R5N!8p&aPX(6S&gv1y7HT&k<`7m~w)B&+_2rX?Jrs9ly;`IA4o<?YaVX$xjP*
z-Fhy-(4sEM@M&QN)9tm}A`V;DzArC*5S#l&cKW^V<#DXn?mOO0T6Nyv->-hI)dvUG
z?a?`#|Npe}e<J(5ql@DgyZD!XQL<Z%*naR&h@U?@&-}!Ko^~0B_wyb)tS@DCWl3TB
zYj?q{t?ZVk597AmxkY6cCW~)ccDhqcLQiFqYa0`2$p_o%1h>-yOD43cv}mfp)_piA
z^7knplvDovdCqf7qut(lhV`e)CB=8y9%?kZb~|@c(3GW`udlC<+gmPMwFfj+0iJj8
z5Ms#%PsqItTE%}yiTPWYk+G!8(U#RxGo@DPZ1Fgw8rhn=)y3t&7AIxhWtVzI&hq;D
z8i%c1=5$T%%35BnwJT?e8P3=i6&>1Xa?S13mQ!cV3~q*;cHJr!b+dko=4R7r+?k8K
z0u3_-XPwSDC3bbqr9($fN$RFfIgzH&yK2@^$4y;PA*Zu*GB->+xy|LWuIQ$)T(z6N
zQw+6umKsh8<IUW5>XNqMn*9f--8_-pZSBn|oF$YqIn~s%<#^Ui#lDLvhh|2rTse0z
z>86Tlr;16QyYJ4{HIrs7w+u7psXw<|=FHoJw^r{g=~Pjjwn@>%mnZCbX?AYPqr6^c
z?*vb8X>Wx?YrB0`dHH0mn0EH$Zs{4jTrQWFTdthh$=i0)YFW0(8C{u&p=XuUQa#Hw
z<}Qu)$(n5(vSLlp(xci-LcJc&-FDof{C)1W4<Eh;o?c~H>aMrqIb+a+b-T0ou&?@B
zAIJ6b(5`}YbF|m((DQq{IFswi>&fP-C6nHGg|nW#yE<jX%i^VLFImi8Da;dIcrmqH
zR&=VXuixXPI<Z$TP4<}5yWyybp&LiUOwFW}B_}57=K5|sBh}TrH8`Sc%Y_+7b7x$g
zv{YyAF%=Kbt9-soH|v`14qC=H@hb1M8Jp9tL``$6?^&xG)*UEgIP2Xjquv!)EPOZm
zuH33M?Z}O5y3L_C&&FIe=1bnZRQJ$@cefl@-8M~Kv~}a%xmudrI?Wb@UgrtgUV3hI
zv5LBMt74?*%2^w?um|3@c1~S;JK@Ug%(R6|jb{7%T`PIZ>b5Cm>-N=Vx0mR>v|P2#
zbVk(X=-sW-hc~XQ*W7kwZEjHbcClWY#L94kIUBC{ZZo@@)pL09-k0}WXZmEOSS{^6
z@^rh??8RA`;+88<g&lpi?d_7qYTa&=^WF*0ES5D@pKYqREOzPc-Ql`t*93+87MNYA
zUUyqPYg(-5)rOm!Gp$2zuR6sOoUl~eDA(*}mUnLNlB;KWE;kA5M0?innRuL6ciPqJ
z9X-cwR+ij~T=Usjy;x?++oEZ1cjI;(O)sCF_U+k2l{1s4JUUXcX|1oH$79j%m6wxm
z?w0KGPYrr+dR?#Rtk>-cYv-D!mCSo|OTTKj)w}Ac{8_7JU09#AcU#8|x2q9ZuDVja
zn*=UhT{0`8H)!^nNujqwZiNP2;k2sn46Rt@AF^W7kEvP<{&`IeNKiN+*fiCRi{+?S
zn3iTjgqX_Gu8^%7lLJ(aYKyFOS+!MY)zP4&mG<#pxZlg?%IAE4wJvjJ@xJ^w^G(-(
zE1rDkdxXIL9GQ^Alix4wTx0KLKFxO9WTC7{Gv9BSAA5J}g6OT998Ob?m!0;$o3rBG
zyVv#Q95=yJ)B!D^Nm=LuUhgL1$Q;OO5S8_oq34R{%cv}V>$PNl#*_n#g4sA-4lK%O
z>1Nravf_fORBMPq;Dl9eCziCis#r}74cF>wn;I~6YDjayD#6yEl-7W{RUvANR!!J1
z)w1#j6aS--=;*Mt)Je$<Cj!ny)~}j0bE(f&CAYMchGQ)92P94%V;0V6>{PkroiZs?
zbCTy|wHvxxo1@l<`E+`Avl{4ldOwwxikN10D_Y~wR?pSGxnWW(HMi&lZ4H?C!H%;j
z%wSE@8l%odY%a!1f(9p!1SSi%DQ$>2E!ZZRxKvG0St<BIDaVPZwM))iFq?8S+O2+)
zN7OZyW7lpiOG>(NS$DPP<XoPK9LmZfX_Bj4QrAv8<{@&aO-0gVvEi&Gr*&qi&RCk-
zHEj*gF{6%SE2k+MYnytV4r+^v+NPD6xN*ykWjQ^*EUmL{3QoH!<{fQxIoIuSq+pWB
zX0?TpT%1!Ck2P#u;gi_2sPTj92aO+7cCC~;SihCcIc3AGt23vj=}yhukQO!Tidi$;
zvP~-`)eIM>x&=-(*wCY!ZS3nTaM^6OOV*i9mre?73>H~)N#JZK+o?%sxH5eMXN5-c
zuG~5^%;2izstcRVwoY(5I<4uN*RdP3Rz<8>+8I8}Y}%#OslpjE7eyqioC#ZXMPqH}
zB2T4Eh0Y0`^=nflwz6fLa-B5RN^R|!YIJm35X)Clj;C95HeI{Qz;=y+Ya83`G;f}u
zEa9kYfvH+rdpsuDYkt4-`*~fxz3uzz$32R3=604Iy!d!}U)Klkt=n#A>!yMhc1&BV
zt*g5=R4^1YCEw&QK}Dd+VS?&^vun53*58gPFW=qMI8XU={d3E6#W#xA&N!}LE>XQm
zW`Xb4ZMRcE)8;|*_EvqpQ~K&-faePEvO^V4rufI%VYfer&)T#9h=kel`KzDLtJ_zz
z-#A<0>+fLgQwxvXukHKY@KeO9pH;LX^l6CSgZ-IyyLV?-ue~*;MbRsHcj{868zr-K
z3sqDi1R%+~9_wl+nRm}EkAF|7zh<}b%dgd;l2xD5wtk*7zxZy7-2UvTPvb0Zzu&k&
z@mJuUjjtB14)sXiUwil0ySHoKZO;l4Xw~d{J8gQ?-R;u*e!ni~;Dcl-0U3cw(DhX+
zI}|x?LUUbs{nT*F%2V%)HYJ9)#xbs+Y`T8Vli%}RD|}d0`a5S28<K~rr&ffzJkY=8
zzm7TE4`R{o-I=QTrMvUYZta*P<f-n-314x6vEbr~V&V1pZEJIPA7F4aVBi2Reqdk_
z@TeC$FhMm?6t)IJh~)r-0(^ah!vr-(mPQ5dZ_6AwU)$y}yJx2yD4pD-DED}&^#KNk
z^73*928Qwi2G(u2AyfXKW+j8&meA8nciryO(!6jxvf))%Vdw+ZUALukCwK%+St6a=
zJME;XU=U<o&IGl3MwSB#)35Ce*L`2TY{#Qz6JF)6V_u|r#Fb&&$+eqqCvrH6EM2X;
zW!u#d*N_BAYeblVp~+$TovTH6-<Q|E-{%)+RBC#?+<j;Djt+fU-O16Z)0QZ51Wj48
z>C)}cK+!-^XyO5{E&6{9yavKD_^$baD;u>xaMU9fL4;^`^l+I!W&6M&FXQ&y(DAIZ
zPRhHIzN~9eL1tm1UY%^sQQ9xqL$$08H;WydDwWW(>C_4%PEogQoB3nQTDNUG!)V5w
zlfi7tmYgNPb?@;it|tr(yo`>A4=_ovYpl;@kp0Z}nt91Do>{C63=F(B=KlTL@BOH+
zk>~m?rPa#C#c#0})a>W2IZ%7|p18HejuR;pU713@d^K4ak|@EzpfcNQ*;1*@#R3^e
zm;!$-Sv3zdilg$?Q)5!Vt%j;*U%3TAp249~lFV1W+Bz_VT$wZ}aM=|eUlYb3lKbEP
zDf_2?@BO3Cr=H5{J(bl9-veXSg9QZbza?p8c}Q~3@Q~zO_Drd5QtjvS+EYq)Pbt|M
z2V?C9^Y{GTeZJy1ctJ$G-Mi2C>^}8PKipiE6Cm>&$}8%det!3!@0<4q^X*!={c=*n
z^ZOwIC+~>&ZF$FiJUObH>w6)?bFO=C+qYId*j9fc%j0$=({06-%DLNhYb?)uA)P9M
z%DcFF7U+zTs(tTmwa+vBgdRll3&Q<TJfAF`^$?S?)}EExw|@8YrO?AmGOnJL55EiI
zvh{}U%eeZr_C6L%O|qW#9$?^=@BW?J>!JE};g)F^ZmlwFyCinuR(DpYnd`>DO}bsu
zN;gAuy0d1hhGcOW2lyY?D^AnUI2;h1^Rl?z>vnx|P?xc6;_9@ci7Uc2g<egJcDfas
z%bi&)xjR}_c9D0+4b?3|XIhQDdRwL)&RTS9mCk`%-q{~FZpZ<Fz3*dR?^qS`#BXV&
z-(1y~mM*VsgEmiDnW)02HC1QAI~9qqR!wscFTJyP>D!nckE_g`FZCJ)n>#OkQ@!)@
znZ?1<*ODgp`IgjgF>B7ub<PkwwQb6p6K6eVt%_VVbBT1$TDB}MR;d{QQk%1utT{MK
zEi>q><}Bt*t><E|`fk%WYk7K(Rlw4O7bVMbu6m^==e*|Y%DP*++3KlMY;xerjZ@C7
zjalNo>TCpG=(eV7S*E;>xxFh)S+_MuXPB;3j?PuPn#q~EWroK|qk1<Z$F$9ES&>V9
z4ySlWEza;xm}cshrFDjRU2*B9#aX`R@}A^an}w|r%*l?9x!Tp&>3QnLmE5r2H6>nt
zxxLwW7sak@<IGV_6WT10qjXcZOXs%6nk(AYeGQJH+9&2l3-_r$D(bxY`g!&3^?J78
z1h1d<^tklJU2;=0C(YbdFRNd@^ZJaaRi7iaJvZi9JHu7z%-YQ*+LuqfeDV5}%dXqk
z?g{4R?n>&93sSw7AG23``mC#a^UJ+r55P{t`MP^o&^xBj)0Y-!pNrdje7f%9usye~
zn;T@^x+U$nW!u6nOKyf;nU;~(IcwGCP-8F2t|=m1rUr}C!g3={n?}~JGWJ??X=az)
z>Efx^F3;I{<5s&@j%m<L)7;{0cb6qwcjj(0yvSJ^xgznJW>b&Jl#Vk~(l%>K^Df9$
z%n_V5C2f_=b93X_J4zOM885sv!!&4iu&Knx)3dYZ3Qf-4x$T;j$MlF`=2b_NHfI@J
zIXgu=ZL-9)W6C;#A-M_LZnLd&x>e7c+nB5Doi-s?(`<5Pf`{}{<DllCnJe8^T<cid
zajoO3OLky)#<8^$+j_zli(TvuNxEeiD0W*q;%aiX&`sZ^Im=Gu25#84<VIFbz|{>4
zSBuWhN?UN{Y?8K7?`oqB!O2;(Rc<Xiwr1K@Gv}-+Dmg*3goBy{SB5F)3a(wGmEovU
zzjkA<*Nm-Z8Al~n9W$LJ;5%cRVRptft&nSGT1U5adqwBuO8d@MTV|TOC?L!%aE;qC
zvx{pNExC4MOK@thlxf=3+|^QGBhA*hrnLy2bqN(%*&UqLle=;u%gtU%-l!Q%b5}T>
zb<4`-c3W}ma@w)An$lt$H~Ow|Tife4O+&NZb<5Rls=g6dj`AxBDhYB-%;~z8u{Ld`
zK~sb`hiWf}+KCKDGjC<dRcV*hHoF>avy)L|5xCIi#LMBt%VDFqog=43pjn|g!%5(_
z6Nj@S&xM9(+k`HqSw!5;@<{1gC$XBx=Jd&Pg&j6J$3rH0@(P$t$~Yx*WR}Y$x7#h|
z3MYIf*94l^Z=4$XaH_%4W1NS@<lcv@dU!~xtkmJ5%p5<3hf5}@m>t)h@oJK%vX-c$
z%WRcf(~KsYYNTxra!XZF>^v`Bop$W2r^>XOYv1m@yxBCH?JkIv^iG|zqjM*(<=LG=
zX`VY~JW5Y5FHiO>yS=(@*Hr(5CY{^bj6cj&PTTixdErL;dcNCcPG|B~OjLgwwYrX<
zk6p;fQ)N=d#JkZsx1UV*RO?x`Sj8hkJ1lI?S{F|fr|9HRl}V93E=fAKOEPps#1FIm
zTAHi6WtNItr;tnMqKv(KYgKd2Zr$3ITXWkr;m{qm+Y<%V6$O`Eo|7!|%<_zcN}{st
z-P3dLo^IojFx&LH^kRKa$kL8EmkZ5JEZN#--7)L9;<-qvsp&`7+7Gj<*6{gG&NcCs
zGFQtF?OHp>?WCPsa^W(wCmtR*R)prRR-J5`DHb_XCuwERf)gFRi?bJI9ErH7=;G;+
zu*V>ORp@$d)1-|NYgU_CoK*7odCv2=apy!qL9-7tkDQo!)o69v?GzjLSdPbBg%Yct
zY4#Ya#-^=my3uuHnv#YW=XVM7tJ>Lz4n`?;HHU_#-EMKYl)2@S$`Rj1C5t=UW$yS2
z&&qj}D^qsLJ5?hlduzcJu}060%RDD%BzF}{cB|;6%5%%J&YavIY+b+V%B{5zbKEYv
zN@;j;{yfIJcI)BXm1%1wCbiZ0?wCBsXlveT&8?o%hXZnVL<dA2GtKF@D3tCn+|Od(
z+2Y$M_%LUV<syq`Ph8w?9?3Z;DC~0CSIFq(nSe7rCk?0acXar2n$60&B$PWzMa@@5
z*~P`s@bRTr(K{OsBp3)SXt`lnzv5zGa^Rvx#}>P~?h>0Um~zq6ZBmPY>$clVqr8Kn
zV@pe87`NnvL@dp{(lgs#diJC&jYVCW#x71buPxQMGe_O>z>MA#(kqQtgxyXJ)9MWs
z%F<O`+R-7RyY+*!kr#`kN)wl7ZVpG9r$e)n*U~^0vpbJ-4{nKO`OFq^X7bTg_j&_9
zqi0@^wVs8_9XsW_b`{6BbF<@HS6$iu;LDSVM@uy$y<SGI*}K3;P2q%9q<8K#udF*-
zO2;`Ss~s{?$~E%o-4+_Rx_VK=v9Gyz^42{J7tUo%spxR&T%3Q@HI!{bbQagaJh6#h
zSy|fJn%kbFDe*;anzd19%`(r8M~-tY$x|1sU%ELp%Vc(vvW%19vCXDNT{nFWwVJJ+
z+Tp9vx;o&oeoxw>H?uWnt6g>ONu07wY*Bxc<})V8_6y4*p3b+aeB9y6mD(5iyx*pf
z!|=o{pF=*E%<}Tw=h=K*Qu+A2x#3Ag4i`aQfdYlcj$52tPVStuthn)+%VQCn8SN5t
zmc=Ca`P7F_Ie>fuibGN2k<M*1B|D|vd>8Smv`yqVtFjDq0!p`JkG8AVnpM)CYG;+4
zJPoF6PL)UvmUJ^RoCZ7p#K+7-#n-^I<K$+Ko0C&KPD<+JT-h{fYqA!1QpUtyqXk=n
zwsNViu9<VkQaR=Eq;$SWN%7qJ<$RGvkEiYqIUpf5gIQ|zwP~jf4bP>8EK3bY7D<zs
zoa}8JFk!($#YofCWox!A3%0q%am(!01g;5;>w`kpG3G{RA7IdlD}24Qw!A+!>gngk
zkOc=AxWz5LUfQ?&_`0=4KM$-5a5pauifawp^xbdkqa}N}mZrYjdg;~mSg)}64G#4z
zxAe_(lNLR@6*@c1y>s%(+^y?Px0!8;(%6y{xOSUX?YSAh-xb~1J!j>s+H(`%uPYAR
zJ?FMzjAf|pR5QaZy_3ugCMpV-uWp~XMY-SdiIH37#ATgkv!o}R^jJJz8RIMSaFOl1
z@*?F*PQy8$TXsCxdh%Sj=VWJ(ky6LHI~!da3hTdC_f~RtT$p_L;o*}TC!VoPZI>v1
zc~pDyoar;u+a4ctnKR?#&gVTJ4Z?opOj{uw!?yiuX{M9Kh5poyn{G|qnk$-Qn9`Lg
z8nnQ1(lisDn^U`(rYz0frX{H~$#m1U$PC>F3=9m+fr0rdD<(Z(cei?nm|lV0?$UP;
zB6c3!6f(Odp}xEG?rCugmUmCP=ZMVmj`dyV;*^`0bUQwL$+St{akoBh{rc^_ZFTt^
z=G7Z#y<WA|Ge<fheAjips0T}<C$7ydmV0M-_gwL;o#%=JWqy<|b*VV^I>gO-wa>42
z?>@e--o4|alAFiOGoSRt<m^I29{o72wlC|}$!%@9K1VyaGa5{t>vdWc7xA+3N{9!k
zsjgl!?O+H?wrj82Q7PZ8j%!xtEZZX5rE}XkOmI`=wiQRSw{W%`kz`%lv`BZ?)^b+~
z!wtC!VtG?8^s>0Pv^<tEl#JN)u;{5bPqO!{Ht966MN1}Ud2;VKxyZoNP3xuJ18auc
zX$v=nExp6mU^?N>ZPQaCYr^U^Cmq=;)*X=B>$d1(#FZ>vu@zms86B)@E)!f@R(fmn
zUX4~_xE1tz2b;9->iD3b)oWkItqh9Wp1T^{Epl~TB{i!-Oo3}E!$t<PgKMNiu3X_3
zU<_KA#K4-cM(kn6BC%7&YAMG=4yzoVF0MLRweV=Vo>9WvO}E{Gx&k-%<<*<>&dFov
ziIjNGu02!Pz^8D>$2rR93i)yuNhzPXe9Y5wp1H-R;v=_&i(4M|p0_xzb82nZ5}#1R
z5ML7)#m(m|7fCA`^zu0gDEG_V+Sy{z>vl0P`mo!@PHnN<Uaw1|TQ@`<Q=NKTrr<+`
zja;$L(^GxN&MXV<USYLpPKuhvOZUU|a<w+$l9fr*vW4z!S1S@adpE|swBX&k1-vR-
zHSVm-dA&}oD|M-n^X{2ymsdS<G3j7ZShCDJ(^NH6yJSQ5B92Qzw~~vC{dPUfFiXku
z+Pym{D#mKE*Om@tPwz~jRZF!xg>yWfvnRY<k(G7Z$U-RB&{ZTjOgl_F#p3*YNtMTQ
z>c6jArFi&mygb{)IkRQ29_(;CWN3KINuFO`UgA!+(5-0ANy|>mc5%~PI_YM#S5N1}
zlqBiL^KEWR&Sg!HymWL^)TFz2wp*Uv&NVsr;>l~bg^wTJ8)<VtakFji?2xk(3C$~v
z;?4fpuYX+jBJ0{#PN^$){mYBZp-@^{TDl%YV8>EN7fW0-@esMXveRtsl;BL0nX}DK
zMoTH(cI()-WKD0R@0MB4(Gi|AmW3TVcD0+uQ9$Cx4Q`i^oZO94$GQarMK^14Z589_
zI4Y*l!O_5Q>)6qa8`q|(UC7Nj7AkS$wi;{KQMKEirnB7Ni$=EQZa0ZeGP^CMyHV=O
z#%-6<%(m^EmNnnrE0E8t`J<-%w47Tv#cxN00BB;`ZSwt(5^^GLhCRt5AbwA>#A3)&
zgQF1Yn0CbEhnK}Bzx~L;w6$k)<0l0+7mz}bMlpzpEUz|Ht=a4u#~x3<Sf#|Ja1{n8
zCss>OcCcpUR1Fha%^BLV>hR=?RSMh-;0i=1CsfOTRMf*&fQ$>&+HlOU=kD1%ch}yZ
z{rvwD*oY5k^WL|#@)Gb?KIAhQ#Mf{#7%=#~v&x<4vM^VYN$Zm;cg6|f4>vDM9CD3Z
z!m(9QBihZOYfq=sEhCoOR>=|`t4$is&doR`q;*!ock?pC`j)QE9zq}%h#{QwvL{h#
z%_TIYXBbt!-YL0l12!e}iI>>L2})PM_UXESIqQ`Iw)HfMEdp6Cn1#d<a$Nz|6xA_B
zcd-HzXAvXso%||KCq2mM7RY1z>BZ}I1?*aFz01={$V)sl_O8mpvU01}OCf`8Ka1Ap
zzn#3WMtJgu8WtqXT7R0yB`V8tlBc%Wgp^5>E(c9%R#jEqa#e#_b=eY0C6A8IX{uo^
z69okob4@O-_UP!C=yf?#(?L?xE2!S;#br;G3ER3|7hTBQuTaprCOR}UG)yT)Nv$KB
zGizI}`4i)|RnxL^7}&ODO<8i-P}+5o(#g<mCTT8-&2PVb_;x#Y(Tw_F)=sTcr_)ZZ
z{!<#mV07#1{*L2sMQ-Q*c1@GEwY9Zh@~dWFy#DmlPe1(>Ke5mC6NCv8n^@ERBwo4R
z-+t-d-$$PwxcB$Lz8KT@=Qw^A=huBZSbMkk{XPBZOrGZZEB3{3s$Ab+q5Slu%I*7m
zH^i4GdDeYYV42{Oe<P{BTXlZB=$YJ~&*xcs3U=3?J7!n>^fynEk)vC;XZmrO+xIFT
z$5-Cix%2aUtv`SG?%Yv&_Giw0uj}uh-{03)z4y`gTRT@AU}=z0-MxGJ@k6~=_Ztbc
zC~`#35Po7{^Lm||l)Ig$QRRG<`6`WT3~cwjp4c|=+@zGxcAj>gyozrXTh`UT+aCQb
zUw*&*;ve?SkR<@{6CvzCheLqHAO}YLeD}OwZ~OkdcaN(|_x`TlJ)vetf1UO2wW^<<
z*#0WJdv}ZfqTBoQq<6j!ORtGBFTS?s?7AOKq59K}<o;Ucy}PA;?#cNJMFtFi8y!2A
zOsaE_JucIwRR8|Gjm_u7J5F@6@qT-E_uNtarC)#7h)6IBHi{{oRQYA~&f-q@-skP}
zD)hJSjy-qu(ym|e@zWp5PkYCA=Ptv;pRva;-nDvgW~R7=iA`GGl9@7*>@||6LRahV
z@9W<2svb1_$@{1B^xp5gpWFPr_xsMLpO1eO8{bf>nQbI--7F=o{!HnK!^x_BY1J%m
zU%E@oR7sg7uhThGO@ed69CiUk8(TTK7SMtq0Y?@H#XqBT+rC-po1N5nGCY^u+?>Dh
ziq6g%ztpO4?(3ZQSxP9=Cg<k%8?VG-&T~|!cE4#_e|j!kO7q>>#l|}6%LTp*x2rGN
zZj|~hPt0(h$hj@y^;X3OH#bT58P0ptAosm^e;ot&^Sy80{{Ft-R_1&4(P!27K(YM!
z?E3TPwim=N5b{)MJD>3AN&4oF#N&Masz*<pPgQJ}QE1^{n^g#MpbOlge1byr<a!Mb
zrYxJ4t#(r9C~JJQQexYTgiXP|rjt{qB{i*IJJDomy@7|4jaSH=$y+*48dz9pWGJgV
zn&NA)NJ;s~5-pcj&s#p$o(uWRJXNM#-sY(?$;HDt_N248A)92E=ftBEl5-|`9swQ1
zQczG(P`T%0XsDoIXsDo&_S|yAymz~Gj(%O2_DuKg_0$>rw%#u6`nqTDjguCSrbJ%b
zJvG$oveB1kdG(&RRo3TB(wXzt)5u~IPwwO;lRP<`#Mc$A`yRgRy>)m;;<6bT9i4lx
zhFZ+tvuakDAIFYW?@O!lK5u<oTy7dZJ8IXKxhg_a4s~?QIq7BQ;+wK?ugWB|r=ibR
zhezdm+@2b4y*9jTZi-hhmy%NAQB4<@yOY{QTBM6sJ&z8(yF8Mu{?4kcd#x*PZm+lx
zvFXh8CGFCetW`{QtFy#}Rzl?N+&vq*J?nbml9viomWjByoYV7)mFZkF#eB&mw>zu$
z-VWP6<=({YTI<TA*1fel0akLjE2yJ$w<@0|huPE6bK6$$_S*z!sA{$f3K~3`vPdbf
z{-kr46YtK@;<c;ZU0%}*V|02Yy14jQEY;|ky(!?)gyy`^nAcgmx4c%f4lPQz&b^)Q
zX`HXMYSlv?3tvsIOt0W3w%n&NGtb>FyM4*mdeiFLxtreV8x^Qa1PWSQnzBtO*ek+M
zNZ{d{Ro`ys?Djr0eY@rByw^S3Zl0M_U+81ur|FfsD4A2!J5imJqdeyM+TH7nZl@c?
zzFD>7>#E!OIWr1<G&(wa<^*k0iq<(fCzB&R1}Zaue)Ij$$9KtXKIGxynY--jvtxU1
zY<(@b>fgTiQ~yZs++ZfB-<;r?+NkDwXvzr>Mz6pn-)3dJw0&rDNg{FKg1l$%^6Te)
z*89HY%lBN}X=n4Cj!bA(X^!?z-5fn_n)HgOAP=WWP9l>)YbJ80O#rQ&*u7u7XlH1#
z)HB`n$LH1A)%^Uv<K5jI@AhmtE-Z0OP*9`usK)iZ@2l^9uRixa_9PQ@PD6!LP$?~U
zTiX4mDHG#MLRlq(CTagT737-gr5z-)YK>AzqQ+uTPs4!J-^QQpb@vxc_Exji+^f2M
z+l{mfr~T^v=hgeqx2yemzqBBat@>uU*4htM6TYaoEHzl9q^1xou}o0Vkm+sFy2i4d
zao@s=CM$@G)CVk?xC=VHq`%qNX!EBto6fBIvt&y9n^h|p1WjgESdrl+HED^#v`{Zy
zPo)!r28)9Ne1%q7EpU`yA{aVFA*k-rl<>PV)5KC|9P(9Ma*21_WRn@0CT$)n7dLWl
zT;#-};4yI~<F-pV(+=loYfKboxV6eDbmmNtjg8;A&hQ+o7m{)l3C{JpaWZY1v3Jsq
zTZSu5Rg*4;Ci8gCkW|#|of2&(*c0%j`N)hZVMf6c-4fnBQ<Fs{8ZL4)n>G97I5{R6
zL>d@eb#rQ*8fwF*=^GTW&2y%=#L<+QK5Hh<)SPKHIpeILaLN&%i-JkZ5;jhioV4cX
zG)ZZ-G&e;PAs5A-dXY4rL!wDZn{`e~CeAQc6*O2D>XsU8FwJP{WR}gUJcp)vgsJI7
zq$cYm=bEG_wD@vP*l?y}O48Jr(?&k0(jpF>*{mAbb2PAL)y9e1k}Un4wMXS0`2>uT
z)+D*<^qg38VN#Cg7M__>zDBv;oL$QTr}h|0B>K!)GcC>Fu<DeVo%No{8ip-LI+JzU
zjM@yP0=t@$1fNB=oN-Ny>^L(ua^jNPCO)29E_0g9@?9o$EVP-2XGK_|&k3KcnyIU%
zdY^RhPYS*nxKZntbJmm%2O=aBB0U4wdTzVzuxz7r?uG@+-|L^(Kd<#Rud%9}p+@|{
z>LtR>g?-$IE`!pbP{*9;J84a;*2Znseca$7#L~gyA;i)oa7Kuw|4-K1=-mIabGOFt
zy086o+q2%YQrBOfw~yYQcXsZ&m)F)B9yw;%;^L*0Gd;Y#yu5g~Uz_SKiD~cNop|@|
zZb^B0-Yyo<w4joUhmifzt-1B5CI{a4nfxzZYI5v-Nv5n5lk3wZIHJJSfXkN2jv3;U
zb2F5uPe@@DnLHtbb#hgk<m7-1mgxtkGqc91UELZ~cqj1dl>E3$4E_pn73QA%4EEl&
zh?=(k^yfwQJGTA0pxR*jK+Siy<fojQo6EKvU%vFL`tr@))14Dj&wO32`1mBKjPkXS
z$Xq6sEOE?$_14o^rnhCcbJ%W9exG5Tw(s^ePR7~W4k{Rz-B4jGV40MAdu7qG2~5=j
zUutvTU%Z+c;8Ux)Z_4ch%mJz)&mTXZfBgJ>yFc%DZ#Fl+H}B+Y-aC_z%$~}f_oCvk
zufat@VFAr!1~ZNs_9S_4J++JVel;kUe@jQsYzI3HI90hHZ91*K?K2DG?ARv8wCf2C
zkp~1Oulsp!_wIeS)<0dZ{p{Y~hs{w@`&{?AZeQTd6m@xi|Gav6yV+*Xo>f)lrSE0(
zv{g&1dUyBx_VN;&#GYV|jv0+UNiz=iBuh+s3(DfVrE`}=1x?Xix@D<G5TyNE4{87_
zf?D=mB9qL6yukCyT@{R6zbnCR;F8W^T+YJ#|Nhti@!!7xuAl$$U;X^&_n-f+uYbqD
z;?cn1(x~78>QZwuxqmN@ExmhDAv$l%Bt{h`k0=I{Nxaf4O!5|*-7YUr0iE@u!pY>q
zzyzH_1($I30*p#3obsPn-pzVioOH`U|M;BM4Y7HlyBLqXoeEkJnSE-t`_$0Tu<5&Z
z?_huf=67MAD;pp0;F$Bpx`Sh9cyd$H&F*UwR}6wBTwL6D&wIR6&eAgc-uHR7)%PIt
zyrA`G3?2+Zc4l|3p18Vm(Ute*_rCA_UVlODW&0Ylr+kK8iGqTHd&;%vyuJr2g!jIy
zKKBv2<z0xSgMr0E$nMtDqT5BfC)Sqbg<j%Zk@QvV&cb7cK1#~v{etf;&+UEpeee77
zJ=NzP!HaH)=l&Zyg07|5eYT91K~d^{gM)xbb%jI+0|Tqo!ulAO1h0L+TYkDSJMi8%
z&e-a9OX&c!2g3#4+@+bFJX18)7KI&~Ai9m=>V}SO#?hgxTBUinu?D(Eb2Ef(&RWH5
zY<GCln{5mXOx+t7AKba1xj-}2J0bkm@zR;4n>@2wZ!<73Sj*YY`60{p_&DRsYAFwm
zRVtUyyamNr$cHTnXX+2%VV>lvA~jEasn-eyg9Zbyv?)_HOfE1m2rb_mYU;B>iXnqR
zsA|cSpay2Q28Jb5f)@T-<{y0JtU~51TZfe^RYe_a9gG<4820_w_+=W++jeowt!bB|
zcUu}o{?U4RWPji1d$#i;{}eeS>Z)*a_9}S^^t!TaThtUC=%~A5!G{U;kAzz$1qHNZ
zY1pVd4su8|T;k~@xMIPyD*@hF8me1G<Tk3Zs(@yh^|PKHITx*Z$13jK3ZE%wUzBXG
zUha11-OFoxABJ0mo)ax@^?mNQzCvlIZQoq)ShLBy*7=un%+xktc<JuDxsvDJ%}w7M
zwqW%ft>;`5baJIVLhlx(2}T=q)vK}g<SGWK9MbktYE9|socHQ^xl(y(xa_?>{c()1
zy`p|^fo_>^zYdzCD=n{l8CSu+8a$gTx4wMd)aMOVd+$|+&trV;6*gt-JF9muy?5}f
z1J5ddU8-Aq%d~Rw!>@NQO)rp*1uJ{?-B7`BlBW`Hl0&k}q<R;rBdyOHs_wm;vb*84
z+qw+Up8411B}?zHhl30cFQ2!&-vW~ELAI`Ye2#(fb@i^Gcg$y!-PUD*=L(ru?>_H+
zZryv^a=8MKQvUGW=VOo0VPO7Mc4ckNHq+$XUdG<Q6+Bs{QVUF_-L6V)$z@z|OLuY9
z#oYRCquJV-s*?^yZt}@A_PKCYEKBFA&(X+*s;jzAn=OuF=rK}sy41?W?KIOzBh~1_
zvanRisk6h3Hsu<wxtg}*jF{=HHCK(D&T7uoHVsRVd${xRI)>Pi*9~T|C9k*Lkk#zH
z^YmO&yI1b4mA+E9IIiRtXUhsrZrhl#CCb$8xXY4<^=qPZ#ky{Qm|Mbbyqc)DTI9gX
z6<3V5nFifhI&;gkv@4N|jDu8{80sn~Mn-Gr1dE-_)y!GCMdvEdQORVX+eTAoM!G$>
zEL^VlOrvDs_HyamkY!iStnF(pny9z3>uAzOhup=1E3SZSot>N;ZMkSRcWUld-6_ki
zs`+r{Zdg;VxoNAB&y}ObxvDe6GDBw@wPj7oS-NS`E$x&AX1BU?yQXDL%UI&OVw=mh
zvs;rB&cAPyUMjL?Y0^|BmrmZMO|xc3`RZ<F6`k5OQO7Kl>nvxQ)>*9&shblHCh53#
zY&6wz^_r&a645Q_lI;@g#F;9%#w}CmW_QpsjiVBaMOOAMwe<<?GIY~i$Z~VC*u}0{
zE;rS5d$J=|1}7&cC#Nkt+S}VJb}`i?TI9s7oNh6l2=K0c(0=|Iu7Oc!y(gc}m#c40
z^paTX7Pdg-sBvJfbneDgrdg(ot~iQyD2FZ5jxt=k$Si1PSI(*10-MAPBWFe@e+t!N
z4q5RBdD<~aAVs0&z&)c@L$!%2lRcHwF0M%oo2WAFcCN14jhR9Rr+TVPHu1S#&~r{f
zkWcJ&SlF7i9&SpBYBvgICxr@puH2OJOr<DKDwEAdS<WXvU=`O%GjD}l9)31Y9fM_3
zlRlrb-mz$FNW0px3de<J7aB60GkiOorBCo4ViL}2Ij1;Bq2(aAan&i4+36C^X&>1<
z%->GlQ=nfzQFXyK%j`K<ug9)EEiD<HQ{(tEU{#v&hgm-U<te$r8_)FB$gG;jXHyZ`
zrl@jJBq6KU?bOZ4(6GcGlZ=-I<S*GebIG<TTU0qcIh}%>oIE*=Rh9~cO!A$S*?zd^
z+?_3}w%uO6?%F-Ev<{Ee8H!cMGOdGC{ft<iPM;mPH9R`+alKjW9hIBq1(Qw)MKbv|
zTwzt4+9je9uq;zx)n(m{Usm2;<@R{ao#M04ax*i`R^9l~E4jGiYGhcJitmJ`1y{Iy
z-DXZ!+cY!m+C9$fm&U#svy{A}u61;5+R8a0dzGh3?<U>mth3QsXQRUcALYo*S9#p~
zGwf<~g>uF%B_(;m9T}nZRo9ZZ4|W=BSauntCTkh97JYci&S$yA<J`vRT98u3Ek~4u
z^JSjQG@I;a@mS)Nv8K^6jU%ByB76R<RGDO)KRdeQ)XhU?ey^4)$rR7F<mh>_VA5QT
zrCfnt2i63eb!4rvRGG5az~5_GP(@lzagw^O+stTf(e0sI!*19qKDVwn3l`nnk<+>G
zoW=LBtXrWES46Jdc1iPtp~mx-M=cJ<oSd=hS*Ss>#}T)5nOv2}6&24co}6(pY583>
z(ep=Z>^jAkBa-Z1lcUyY1Z}%>!sWyyfzF_9r?W53I_qGpt;MR5ZOU+F%?go)YZxbO
z5b53i<cMJIs%Ot-JZ_nI&JvvCc&%P^V?@}|#7L8z;*}jUdWB6Q7AJK}+zc}W9a6c&
zoO4^DUQD=H(eps-oJnV*L#G|xxNZFbja-+Ei?gC8Y3fX6SU5o{SY=YM!omrnI!ihe
zj!&DsvFmi`v`K3=TvjnT>@(@=nq8bCO|A+POI)`{#&n)N<9TDP+avXy+gg)6m8F~~
zXB5lV3s^qi66LizWL3>2w`nC;H+7i{&b*d&?2(G+vRf%Gvwd!vUb{ahP)+-KVT0N2
zwcBp{3oG=_4+%333r<+=mv%X$-Dqb*vC3oh;Ox+XEv<r!yrtbXhBnMfX;e1ub61(N
zQAkQ*<F*pfZELrtS<II2xT$OzvN~yX*s7}=@)T!s+{nrk-10r^n2p*od&zw&P68eI
zGtbUZl;%BG9x`dA#-^Fkeg*dxZa(wL+<eYcW#WWF-ge>S&dEM5oMyg^CtZ$la|^~8
z9Anm<GwI;fP{}1HCDJ)2OG;Ec5}w9v6qdW>>ZDsf(Mgw*Zke6zRhyhwqRhpqZM50j
z%rkN;=j7QX+G*F~!)<Gy@2Ra?T6s?9k>bs^J5!Eq<J9alZtu%E_T}c3G;@C~xqWkU
z=ld_nS{KW;=Vx(l&A!Imtja}Zoj$ic(rzr7=5Z-gQo%)SqM6FY+|8?UPZ)Xfs@?Wx
zUMjW1(oBhG^}1cJ+9vCi%GI9_Uy|CjyvKQ_vt(#@XvyT<0EU}eGit2%*}nSN(KF|H
zOQo@$&zUnP4X4T!U+*eR`6zkpNyT}UPx(w4v+WemS%z$8ZxehhIO9px!|nYxANTl7
ze3E<2F6h`2?>q+P>`Sr7nnTWRExlfNOp#-ATGf@5V_UZ@4NF;aD|EqyoQq~k^{TzI
zrp}roF==hWfu(CTv-kbHYkNTJedS%-13EDea?i2GzPDb!14?$!;oW&~mB&_<>}khV
zFWs48wo23~L_5bLFQ_f_)z!DF8$PUK4BC3@cIe@RRm};JTBlasd%mN(ZK)T8@-({<
zt+~}>_qIphKFv$L^>*{xbl;$BuO=S5<34lAZ4VD2MY*)k`5YC$=gavjxfQpo<P~mL
znfz)=M#qeqC(jD5UDY}9$d#8IrhzO`L0&hEBxIgEoN#E)p&v_b{>VS`XLar(u@;{z
zQD-O5EHkNZFx}<EIca;?y0uakcZv;n=4gwp+PKs=C&wc?$-$S6H&i=QIa}*i%FIJ%
z=9aL1%1Ng+7Ipc0x{8EkGvqF~1>%{iiUf*wF6z=)<FTkqbc=L^*$q>{gliqE+zxw5
zDJi98B^kLSFqsJIOgpKosd7?C#bZ{c$l4qA*A^_9qR^SWZhLImj-y+%)`qU!Z2pkX
z?NLg~G0X1O<Ko)99xrY)u3W(&rofz_6~eGGfawT>Gy`vrNY=qcw+=`(FlbM7N!fPw
zlGmD)%@fbL9BuO}EIedsc;rrt<FdYjhda%ZoHN%Xt(>%I>XeBaLwh=o%r==VQ)Crg
zcyPx(Ib#LTw&uk)E+3Dp3p>xr6c#q_tCYE|GVktYtA(N4u12hy{H9#KzMq{>@}bYE
zsat(lPBSZLyIGo=vTdzrD(Aa$&qeF3ms||a*tlp-wCJYIy3!t(Qkq?-x2!1a(v~Th
z`Z3K|vgfi)X~3<|vFjdBiPPnE-Lrby)4b+{OYe3a-F2rky?CzC%#f_bG0#iZ6|IxZ
zP??;va^gzXrD^Y;S?{>S_s*p4-MZcNyWTPI?cVi{;Z=;)_HrrTyP%EAR_jzdlS)eU
zWS4~IbTn}s>zJsN<`tTiDdg;;vuc&6vBz^6V~fYqZFg493|$>&IB{Z2!Mx&*-m^R(
zUag7Rc4a~P-8j2s6~oiHGw<dFMQrZYc&2yTd#16YTX$-r)@`p1O47UM-Z?8c(NNgU
zH^V7oweGfUn{6+C_{N)Sc2+t?F?H?I>AT%NOJDOejhc1wykBLg*0#ni-G-Klo{_SR
zTV^Y6^tl?k_FQ4n^JDj|zy5sYtaGNN-Rj-@*Z(Geyd+$IbpNj9X1Z4`H|DK8+g<9H
z6V@%UT3Rq?+A)*lT%B!>Ta%`oSras4a?9Ckw`R@mc=E{7Vz%s-Bda4896NTzL7LU=
z=$d4SE4k9^-tKyL>$;cE?JZfS&Z&7SG?}<%?dD6~a;xZS$b(~RqS<=b7BFx$biCfd
z;Js|S^3swuQD=gliM-V{3*DT(W$tXvOxDn_HPWAdFvz~ny0vYZnPKl@)<wq*d$V)5
zf4hJ2&#SFk(a|x`IX5mMr{*MId)@_YTrH0QEjOPVbZsYO?`aZf#!gibG`%Nr%&_a0
zAw)QN@`O)f)9rULu}_cpXA~E7S#>BhQ7dZ#3~rbn=+7u83!S68TfBSjop(NG&YU@I
z_FPMH=FFKho?D)q9(aUVc=CfPHvS{44u!&WW=%+(F4({*Rli0xOla}$B`xpw_x}@d
z(OrB;X2l}KT)78NS9ChvvORb@P^fiFb@Nn+6liMBeTOAzwyeLP2sE80_uw6>%4whp
zwQuHo?^QmRz4IZzvHzGt?&_)8b9SEgS}pzf@gvYYnb`ffsHn8hM<%tX2u<NH-MNyb
zb(-w~(<!Zrsna4oCUe!8)N_elE@wQn#$_SMDG|s{0bB5$UF(RK*hPk?UO}x}DpB0?
z7_6Y7XsIT`{nGc|+kEbOS7H7oA^&w~(5eOp9KdnSEyqclGui6Byn<#VX?rbYNSWlR
zveneXWQk9N*P4z=j=9Tb1uj`KX<O(l2Gf<>POHwE%E0L25^^(8tkWoEvaibIl%tB<
zqIEWTon30=oEz11e%Z}q9TR$2W#y~_^{*HhHcm*%TsZBvN4C@|un3!if`WpklFB4+
z`|2*0rJ5>hXSOe_?>e~Qkl%yH``TYO^TGfRY)TF^1*h~=^v`|^{U<y3{ytc<bH7XU
z`+FPW=idJM>u=4^?eDX@zwWBr_IvBm&n5TQ?t5D}`RV@X+FNgXKCk`~6#4P!sos5`
z&r6pmDSuTEV)QFx`dRarfu(WYlu6Fc&b#-S-`A>NwQAKiV+OzP_j5n9WHJXX&e#-n
z{;t^p2HtJAt32jE6`AM>M$t|g0naTrwkg-DY@YdL@<)}+TfR@(Q+xXOB=6ev`?cTs
zO{KiwWn`Ov{t|wE@0IB1&!5XTf2iY!ZM#J<8fusy$TR%2*L(Lw|K|1m_4(zcYd<}y
zo8<fb_3YiV)F1Es_1Df|zVqIEF~1*E>`W}TcdI7_H2(UP_wL-1c%8a^v$wrFckA-q
z*t&z0yx(3gJg#(6c;6?z%E#d@35>sUi_3~Pdq0x+@y?blGQnBk_`P|*R;*3x+L$w~
zdUt2cs#U92-8jRjy*+;c<3x$vj*X&%^(vQrO|G1<-p%@H=g)1ot{phQP{&aBy;L8x
zxaQ}c7oj&*HhVogCS_D*cFWQ3?6!%a-w&C1&-+xo<H^p&r_BD$d*A*2(!Ro<HJ9tQ
z)o#CIb0t%My4kUNxqog4+Pz7dbJD`_6@%>K<NX{RP@vEx-y{6!K8x3R$<F~_9@YOy
z*&|Z-S;V#O^D3=#b)U1R`z8E+S+&F{WO2O3t);KGtY30&-~8H7Jjnttt^7VdK6r~s
zeSRfq&}(DMDlL$QHvO8FX41#UYI^Ec`qi6O;h|;c3>fO_7^J^2=$psAub!9pE4D5&
zG<f><>JxF7a<}uFN_nkwI=MP$?Ut~a!u1l6;ZzqFM-~D9emPCoiNXh8?)kLxy~mVg
zny!<N8O}7Bd})Q&_r1#Z1wG%m{8Y8`bbfriM@dQF^W)>Ansalv-LBy}q6%_R=n=h`
zog6VOiX7kkbYIPJI{B$IWzW7(Q{y~UW*UF}^|x;MJi+K(L7{0NXRlIH{@$s(rQZ3`
zf=wmU=H9LBi+->w%X7=xJ*?YKeej6W-3HzyUhwY01IElLZB@H1k4xun`!j#qZR^}^
z(J7O>t8>d5&82RvTBWgS^|oub!y+AK_f}_?T|1q!ecSa6;lj1kPUbzZn%;eL*Uq9Y
z#n7F5TJ)AaYGL}8yX}2R>)qy+6?<pzy(CuuhPjpJ_My`ni&m}LB+z0Jn!DhhugNvH
zOVI@&iDQ?d3g;c09&80MW3$<{NU7M$@1@4R_g-@EIG^mja_+kc3)l-Q_Rd~CU1O1G
zc-n&&OTQGRPiME?eK%n@<DEGDwD%>gyBQujn|;`HN@LZkH7$yKqR|=VlYLDmZkcwc
z9whT|%d|Tn8mkJB1VIJgZP#wiJRaO^_IoDi)PU_bT~EZU5?9Dqx%BkRwOd;ruRJ)r
zcH5-ug?Gf*a^JL02@DNh`$X@-#+y0yY@afhZ8`>%%G8}M!@6*GNo1->XsC82cf;1*
zxgZs*%qHC|JP;+h-SxJt-z3Y7w0lBNr#U?h*y$=#bQKb0PH+2`d&+Dv&abPBi{E@N
z{?JY-|A*JM+^*cXeQH%pmeA?D=U?n=d{K7ga&z_W3o2i}giBwT+)?kX!QL+?FWf9~
z_?Abq#8S;>#;v#7u3XMtyW+Jbx5}n-pd;fwjz#6p+}UO3bQF1OvC|~SyT>ihy+2cO
zZkyHB?UAcx>*``nF8i)jo2A`*S0P#Akdl&8&=kke(C929fk_@to{9{JabAyqRjY1i
z-KziZ9d_$#{AQM=n*ur4tP+**X)@Yq%&{`%O#6*;Nw1kxChAOjcrj#Z^4q>u&Jtl^
z93PIRNgSDxsAkxvS+qQDGmmy-xSmdg4BO*kHRY2#JI<`?IPQ6U(vr|6>qP?}?9uXC
z`ieEse+$>58B<mZEja2G*fnXf$fS*4-ccuYCS3}fRKMY{)?%&2+}y7n>ztpvpZfme
zcFCoP=$fv5QQEg7(pe_7v<tMPKQ&3V*If2Jj;&QbN5)v#`Q9?ci<{(ZDwZ0|cy~<D
zdZJ-RlECfgxpy~x*SqXFD-yIK2QqYzJaTX5so@m!c=y~p&n@0P|G>5S+p3nDBlQdI
zGBsNSeI&Fzn<ixiO-z^;G+|cPDnnLfR*9fRhAPS(i&l4paZQ@0;j_qNjo6Bg@N1!g
zQB6V3pH#JesZ86Nt1>Iig(-L2A-7ozgAIdCwFGC*5ZX9V>lb6sngqkCJ!UDBGF48h
zcq)1M%rrZgnY(Ojgl=Z;6rTvqHIsgMMx@rOeAye4=-T5g5oXkMOeC2pnI|={<A{ly
zqIB9u!Nmeiss<~0mMmX*)LA8B%_+m4Rhxy<w2c%61)S8BSY~dUX*St&*)2&W0XLVx
z8EIM*C+nO##-Z6I8M0=^YQve%IvY-{oDp=IGqNX%&CuwCTWVU+rXy`yQ;wuI8=N?D
zSX)=6-d9>l+E>`g<wVldsa%USHIId?NphA*W@x@JeWCjTnO4cv$kvWD)h1uFj*i|f
zC(SMkvZ^_&96DsM>9mAEThHZ;CO2OpH8IV|NlTJ7osE`kW}2}~G$TkSGDRn4O;W1Y
zQB9qo^*o)%o-;hon9S@nnW>h!$aC4Gv=(21qZ861>z8cuIW;peVZo-O(^hKC3u@|%
zT01RktpnrM2Ii<MX19$Zl2!-Iy0)o1)Rp;w;FtdM!JkjO&GozDQTpe<&FUS7%)Wd_
zi+6SQfUY*u>e{qw)tc2RiYgOYnj9uFbTT<iaN=ZgnE2=Gw%cL%--a#xb$(5);pM<<
zS?Tff_kR8Q_3JnOy`~pq@?J87X7&VyrYxE~uSty4VS-Bi+O1LlIVRVqdo!=q&73T7
zUxznS5CMdy^Uh&XnZD{Mlhou3_gR?27ENzVVbraUj*iyvuhzJk_Kx`-^NYGq!b>JR
zn4ikL>0+!`gwR&~b-O?Q`cwJ*@$>5CrCa8{PdV~Z<sI+dH|3MQe0+RVqqFZ#qVP^(
zi8hYhwXt_MeYg3%_wGia7Tv5{w^WtHw&vz$hh4j<DbVTB;^lH-$;63J=GV~E)jz)8
zE1quiJfgh%0{fQR47Ln>w=%t_+B0|_{L%hEVJ&yQ(t2Id7eXy9%pFd~z7pqs%~x{X
zx#d?oS4CxVpV{|~_cGP{<urZNtT(p!J@HABXfeC?ygX;`=`EMirYv2^sXAF9ODaVp
z?$yrn`|D#@eV+Sz@2cXx<y-x-R-OB9#CJ7j@0C02tNtl0xC*i96~hgot16#Aem-v>
zZ};b=+4qv|YbV%F^JC7hmVGv<;^U(!hZ1-a1z<KYZkn^(SM4KchHbJ!mV_@KpUQ);
zF*}RiAKxDfvgeXa_4|Djz8zKlUtfR!{qy@D|JlnQ|M>jz^VfgP4lt=WFeo`pPyy|S
zRC1VDU*%rpFtNx1x}~yQWpZzpL_KIe&HcxfcUOycZoSqZ{@q-UIdaqO-MfWzb9aKu
z$F(c8Lql`jPJ)g{oCGon(uA#D^>mwAcizua@7Nf9Hy7TR;gcw+DVmdYMQYWJ)q#ne
zDlICL1SWx|_rTM@4KDp#i`HewEV{Er_Ga$62PF&CZXVAx><Oyx=vECC4G6m$wQAZS
zAx{oZ6#>WuAIRwwziaIb=Z>B>;oZ*d)&h^6CtDuR6qZ;jD5xD0>a=#%R;U(`A3=#3
zl&mNIhny^J#FnzTLE@hF2M)xhO7O|jtM4%|u%BR<)TqU^nJ05`y_B11nwum8Q;Ugd
zHmB*5B`T(?v!w-FR;F${vMpsPuVX~S#i#>nn+_ayY2aKOB%tiJjlpyuBn)a8RCcg;
zh%m-7{7$mw+jT?Gi>-lyflW?!`F+QrE)4^}G))%P8(9+>bC?!vx2a$&POCb6?){#R
z@2k(tOqspeV(!@uS@rW@uBr<4GC6TzhN`ibR}fp{tIW1}SA%9bC>-Fl4f51-xFRXV
zG%0A-;;O}_Z1Wa~nyLydc6L*^d`0z}y;R$&nX^OFa(!3yZk=RyQ#s3H)me|kV6Isc
z4ksiA^G-6m<mwCNPlSmdS|)0+vhAdF&cxs#iI79fmegm>2%R<Q5+m;{qrj<KuC!=5
zr}eaHMx6~*>bSrZz>skz!z9auL6w26*R3bnZL#Cxz=aE@Fi4q7@k;gbvMgX=)L<~l
zGLbTsVi0Oz2FowFxZ*;_m5dCqo@Tej&W>OuCPEFoVZG8OLJiCk7gt=k;KjfzwOY!w
z9wY$P2R4^is#od&1L(A|tc$L$U8bVU8f!XN_6Blgbp$MQT&2^w;#AHmuPIWuau>O}
zgt)qdb()!7+$t)av06G1a)o-tjYSJ?b@g^>@vgYlyJF);SH~_bZt0ATxe?biR_J6Y
zgRfW5>J?km>$t%|AfdiNVZjZvMGMwSY+LPYW@5BBIoDZNYE4MSiW@g>XWTONxi)oT
zfMB55HXc_|p;p7_fJLpjQ;w!`X@sTbEIXR(+m$p^$~0reqQ!2<dINhhu1e{;N{b5i
zuwBvIEE2GGN-CSFcGeNqj@znX3SGCFHIsBa(k5=rGBew_F{x|g#%$Mmv5OlwZVb&>
zoWQ$raZW~;8N;z-S3S3_P1@SkHR;xoXwfWZwQi}kZd{TPSHjM$x!Slo&}p^Q43!&a
zqoua3G)}l?8X~dc;<l@zf!j0!BX0Hj<Sc6CF%6j-wxD-whqvHLt&3vY4oVBI;#um_
zmMON#w6|L%w6`}WFjrc1?GjDhu6i?uYrUWg-7jvtHL26g&^b$Fa?ax16}?*|O>$jV
ztaeT6U9)hT$59cjZKrOeY*Nmec6DZOVp#6#Ok>`O8*&4;=G<Dj)hjJbX=|i#*oxc9
z0d6;!T)M__RoXQ-Y0Dw)G{KE*7o|34Cuu2X=j3i&$>qD*bLlFFX`-8YXZ3V-N_5qC
za+xjcb#%LOJ85>7=&YVoN6m~JBRjJeo4RFr-CDacSIcZ_bl~b_jliC1x3&qL-KcY<
z=WNuhtrDw((=NDOagBD#&gzLclCom5*~viNX3y?`HQT0{O6qvdT)ItVjkm~69j@DE
zlf@QBt~Oe8<gDbR$d$&Ci;W_us%5QRH8~?^N&PLwS#4RGvs!aEXL+_{b==zGcI`^5
z+O@5-la0J?1?BX1nuSVERm+&V#dCH>uFH*WORla}%DQICk~_=S)KO~D)y*7h4SG9t
zT$8pPTPxbJ$ka{MW!p7xos)q&n!Sq_IlH>Fnk~+aICU%_>}VQS&O)czxvRC!CIno{
z5xTi_!{MCzsIIGSTXJ%;bGytkb60M1<4pF>xf!zN+Jf#R-EBv5x3sElmE2~mwd{&p
z+ST09Xr;3*X`8*49qFCAY1M^H$<D;CD_2)!ojD4lCA-9!a?GZ>@kUNKE1I?}Gp*}v
z;0%MTGi@2GO^v-x!m@fU?3cO)xoKV6P3zd?IeoH>+a~Yold0cka@%#SbjGs7VP;2H
znOzJvjX>p_-Illl-pd%+wIw-nA<NC~Wa+4$tdOHCH@j&ZjWS$wp(*F+#_n9Vi(77P
zOuE*)X<|t3;;3UNyrbYt*%wFhZp;;36Q#N7SZ|c+gxg{lQ+=}Q%`%SWnsjc`O%_`$
zHPvv<&BdZyE~%Z^+7s22^)F^~+Ocgj!j5L#(z&^D?K07=l0J)k-A<XU?Mf9)+SYaB
zR(JeU9ffH^hd8%n3a6MT%vM|A&7s<|p($6&<t8tO+Q}6z*L-rlBA2d~KId}LNLXOz
zf*DT9PH7if)N(m&)cAyXIqDUSQ-sYfw5YKtwCG5Rwk<67xt2LoxwZGI$g;G8-Ysf5
zPG?G8H8N(L6jIY%>6PTG)+wDQoOVRVJS3>O<u;4rPNVGHluId>ax*UWN}NjPmb@ym
zIJZxxAU))2bc{yVp&N?2li8(Oi+zshOFm4~cDnUpk!kKD`6rIGL0&-ulj@b-Zp*t!
zs?0XOE}fLSNyVkCc8a&k@32+(-P_F`stC+>@>FSYDGxKd{j&Wc-|b{KlVq1oYnS?F
z$0%uMr)IqlkJ_Un#VZ2R;Br>U<-&y-6O}S1s(7?G>HF>sOEH*QWwbIa=Y|*m;+fmc
zZl1|I{A6jWrjARXV6$VLg!!u}^<P7y)74x!d@iM=Tr|m?`D$Zmzp#XzO4Q%dt7}Y~
zTCVw~UQ<+<ae^sn(W1q<QC(&kw~J+@GgYQdTiYuw^;s}kFsWlw$7Gg-eG=xcrslIP
z7M-;*GVJDAo|ZGSJXIzsDL>pf$ETyCBcoT$Htf`5wqI_yGJ6*tJG9bEI(Juas9=4v
zi(5yJ6!(XN`<8}22^4h+6kVWg@W|N3#bYK%i_b-~&P#oY!k$ZnIFB1m(OAko<JqgQ
zOIOw|nQhrQaZ9IEsQAI;3s-~QZcaP2bhgsct*Q!wbM91}>7D%~Vv$aut4P9y{7c)+
zUbUT#nzEoq;AF~nmD@sLA694=tZ2=-<@s>BQT>int}hHYW=jcMe4L!ik>RP+6LciC
zXXV7Uw7{U7SwYkHG;uU3OqimgDw46-RZ8QcTbFK>VNZjaQmbj=#BCpU_61E{9lA}h
zu^`cnr!UlOTdTpG!c)o}rwk`VCi$%KYzsJXYRwWuL$jMwLMG3zDP<}N<qGEtyBzUV
zaq?Z1yNE5rSLL$j!pV`7H0l@nx-DB|_DpeSyToJXKv$7K&uvXNudV176kMAl)*QB>
z*E?vFhqA>Z$4gU|t^HzP<mDi#(qQDBodRL5TD4`ewA<9+^cigyLC3sy7|on;>SVIe
zh8a^ns%y@emTEXPQ>|C!*|QUZg2GBS*Qd?gnq(@tHaReB8qcaW-JIO|Afx3HmK)mg
zGF#f-ELF;I6%sT$>#PzbDJp2P<c1_ukd()<6^pK!_J(d;>?$Y`G}TMwlE#Fj2$O?H
z3MbrobK_;y)V778UIrPeTZ2Owy}Ct@sS9ga_N1nTbk1CI;IdIlTSq?of_<-|u57<H
z$-VQ4+sat&(&-!79F9n`M`n8ZPOhKKQ7@%r;%Fl5(<z*5GC8AjOGf9GNeOQEw(dQq
zVHme{ckk6Z>;WfdDJdz=m?y;1;&lAB$c@n4RU1y_YCXwVWRh`l>)KwisZ*z%lrES#
zVcX%-6)AVl3agw;Qd7Hl?73OqM%Sd7vu3rLvJ~7gmnod18?`md;=W%n?-s4Zu7gvi
z`5F4vho<=+XD&3$Wigj2dVH0?Lrqysm-}eNhK*Avwj7)kaq6(B%yN}8VX5AexlX3e
zoSB%Esx9G@DDfatB+WI=Ytt#7lWis$xq>|tceJ!zJlSpN=A%_KQ*qMHQ+KshR%Uv?
zV_<7wFxljpGC3M_12zNbD(n!qMOudqRx%iKO%Sa&$qCNgmJ^y}Xc(-ixJc}_)YgQh
zn$bDRK5B_4dw2A7=Z1&|O06~xxiLG@BvH_iNkFN0QP(P=D^oUHoKx`ZPBFW*NRSj;
z!Hl=twyipKS?#LVCM9-(6SI?xLwHlAd?n4UY`Yc|74367J<p<ZUcQmrEl)NdZ_TL@
zCv=jIsVTVBXY_7yGg408zRG~@m{3nL<0_U7xgNbL&WsHk9WqSVZZrpodUWy3=v-zJ
zG~tT3YPXB8;i4(6(<You)O9lyO&0Cg8ZD-iu`$?0Rhq|OsR|Fv5~gh{qjr_F25rk}
zc+R+^A=H;qYH8Z3u%$W5c|ONxY8$amIZ-&7%_z(%vt`lk`gCRUNVipsLnbDz$+%^d
z?dEJMWt3$QxGgwq;~Li~E(er^Ii)R`4Ne-1`fLa`^qeWQn(5RugV1ipGmCak@|h`^
za%tVIUa#enfiok!W=`_i$dfWHSTNF5%W#plB%4XMRLHSO$y)kByx&g?h&tpjhOo4D
za4j%nSjFVa#$}+^T+b>Y{>Dx1_L8X`R~e-)x=j`d^G?;cFiUsJLeGv>f-AS(>Ip4V
zI3dxju<GE3=)7&WcXS-%=t;PCK#Jj7$s&PHDJ5lhiN_`>mb1)`a;l_Enz1HiQrIMC
z3(uYa&z{gru?NZ+SFT9ecC(yu0dHp5tE=8y)h@2M=Igm7%WT1I!9eMHSGP-9zKa95
zvfW?~IXRI9v@cOpQ+w4d$L6SPhLotOS$_|Jx*<{Cp4%1%Ef7;+fZTnp)pTpBmNWya
zSK9%tZNXXTzRrabE=OFFgm`xadYN<u`gR+}^cZ!koI1?rq%4$k+;X-{a&zyQg3d)r
zMkc<(%7sj7Cwk3%uGRN0G8fcMHCu44DL6-L!6`vAHML_cW}Qlj(b+3kPf%pi(iWA@
z^UOFht?SmytUJ0wx3(?Kb)F?tC_HmXN1njr7Ue#3!4qc|P4H-QJWwEcBuClp_?@Sn
zLfW1yS4++gHZ>0L_Gmac?NYCpS&AUrWVe$+GgY%#9N2s&XZfbARgJ6{kTklL?AmL@
zv0%x?O_4rR)`FB@F!0){8M0PrRmLr&Q0JW4d5T9?Mie|0IHzWE<aVck3+E=2=yct!
zJl8Z6Cq`^AN>f%Ul$?`ovTf3oTNk$UF7{Sgv^gr<CB?17Nlhu|&W0Q3W^GM1JGOD-
zhBZ;9y<2xp&6_At(7CudCva1JF9+j+YE8#?lbY{uyLNCRevs6qbmL^QTgSGeJy9nE
zH@ZgZOf}1$v{p*#YOi4E<eXfw8^@+aEx8>iDzWY8#-!eE7MB?(143p@T5!ef*2Ogm
z8<Wmx@kW7m4H~jIMjdSq)3_0#owUU3V6=47mY&;TYmVlwY|$27#;ci~liM5Eb=&R6
zR<({T#$ne^q_N%hQhcXrZ~tbJC(k5Ll}Vl^U{Yn0r`jZEl?jJIf|op1+CWk&vpiKM
zJI<8hFME?X$pbX6HOX_yBu|yeIWr|<?r!%~nIsAB=VyXRPnAi&Ds7&MZ6LuV_>A{R
znIw@o$x~&PC(k5j9wSec$z^viEbzIzWs;;yn?%YaPqnuoTOsb8a8kwKFw{Oc8^%!0
z-OhD8PjuTI?c5z<cfsWCB9O_`6K^p}d4oi67p&d(Fgo`T%ncxafgOX%m=y+7yzO=?
z!sML>CsmB5UtG<oP(Kx76IhvwktdJANtH>?JX=*jIw8)5kZZTSzyA8?%-KA~#))ld
zIR<CWwn@(1aM;*PA}#GO&zT#EFsa;JUC=CK#XIW;^8%Ur|CQg9CHz9)-jUr_4rOcw
z?L~aY7xV6z!5pvEw|7|QfLN<<FmD4*Z2rxAck3Z|{uMl@`JG(`+XO6l{#8Nt?)RsY
zw?F*=o+_QZuUf1gw0-f8?6-4ok~vT9-QBzm!7wvuTDiM<H`LJFxi^jpPpvLzhck3t
zyb|}kyS@AV-Kwvz(Y>{I_j$Q|qkwH4>{`(E;L$D&qMBY}7a<OjS?LuE3J>o4vbW3L
zFIyYBYIW#j!8p14w7_LTt}4qqOcp9kn&Oh_sp7G0ieoCnOpz&<E=)V^G|MYvQ_D%U
zj*f1fWnI%IMJXw%xJ2oyxVX4@dd!%q%ehEN>1s-o(tp<r6DGMO&6qMN*jr-Bve_c3
zQ>D${Jye_#G}|mqa<*1Vnr2I)rrNXyQ!NIb#e!-ai%tj$dCu@usP|AgEp+Rar^(4&
zZYQZ*oL<2yOQy{_k~{09TF{hJK~q!LGH^2FW@bAuIS8dlvQ1@R0H;eQuguIXlLElm
z#bdIs*=$c^#%0rHdm0^?ZE`DD<+77!YR9CdlRR}cZaOksi-95QYQEVDxwfz~$6j83
z^MCS_pLYI}AN{P^7hkUg*-8mw>q4e<E&jUIEid?+lB&{fA7NLp`u<M&($jJO-cCPv
zwEB1dbWW8?d;cCk-7?8D?%yN3yh)zx>r0z{@0#RUUv^|c3Qzvi6-q|_$7PQGK5tX(
z5t#k1%=r1eTmL39DfT))?v43Auj1<WcGt6Kzufs1_4kLB*RvNf_m`Vr4y~{I{rlqi
z@;!0YuXe6DyU;6mhyJBn{uc}kOe{y@?J_1G{vjDv&i_RFxtYPmFLE0d<ntFroH6}p
zFI%vE&Fvp`@`pc6-XAYn51PZhKXJb6o&)l0dKPn^Wq-@LG%-c`ihP9Us%f550rKlh
zOcs0J<uIwcl(F<#gMFq+&}Rn?dyh!<b1`|gKhKsto39tV<NiF?Kn=r=gnxpP>W}-9
z{yv{)siv&*rSwefdmHN|i3#_MH_o@q-?zQy_pe_HE{2m7TnyWf%alZF)GtzWbz!Px
zIxuDWE1~l%?AE<s_ile3f6QIJ9eo!H{)U}wexE<dTWS+e4eK1C628k>dd2tN>)U?K
z-n#zv?~CQK{vVM18_~ePz)-ua=B`d!|Dw=8Z8gu1N!c}DQ>xORy|f1u2zK{<BF@Av
z(@C?pRSG)keKJv@UU-Ma`@LT^{lQbX3Qb_DWBSKm(Qo&@sVd#}dq#A`50h;#mwm6|
z`+V=~iqje5Jlh(MADPh*UwW_l^0o8x_x-Wn`(@kn_d66#H8~&WecSc<>}#v?%gz^<
z-$`V>Uu*k%YISzm9N~Lwwk+|y`#_Q5-u6d-?=f&P*lb_=KK*39YHuW)!Mm*~8&@kF
zyEmJG<pBc&hp^DrjQMfg4i?j|X3UQl*wmu7LtDacfxssJ<fEECN=iyf3QZhJO5oKc
zk=4;9-<#dD^S0euxc7Dbgbxy{zg^GyyE%9Jwc8;QXVq-yPfa^`>}lMz$V-dfXRo)p
zw|P0+=WTmFSKYk4<Wi<cy|rQ2Zmn<Ep4<%2&D*}R%8cd3hx`zcmOV^YSQU-mv`Q@$
zT$%B=_TBsN-TUj9e=tm#<f*A%9$gt4+LJ6A8k+ld@0+)4W8YVP?Ao7m`*mo^@y%wB
z%cHM~SI1U9`#RSu^TooOWub4^Ui+@|ytzV-(b?`q;3`4s4FwEN0xin7KHaY`uROl@
z{5mV{(0%Vd@5tBsz1ybx&aeBGwFR;YTch8-xA?yE>v6}d)#uJdKlU#$_SL!AlWh4q
zuaC{dhHdg42EOZBpKqS7$$ZD2J#Fs2Q~ONb@LcvbN!GEBt~E&(v0<CMfx$Xv%iA}r
zANw76TePlR_FYXS*to|#zCMjBmwi`XQ~BY?=Z2T8tJYiheYdlDykKkS?VCjvm+ycL
zk~sI?yJWj}2+XqY)q4I?)s45FE-&A-zSo-B<kDG*(|p(N`$`<;XI%1zf$zGmb+y)y
z%NyXfo;BI*W^{P#_RDUD&IdBB8JM@8_5(W<qO|_U<qcq8ZFrme<zi332PwY;3~!4r
zZwDFAT01pI-|lvP^+Nr;&<%Tj=loi=P2BEw=6iOB_UqfVZp77YyZ7Cx<lWB7dpFFt
z+-Y}T7Zx4*;=wl_>8s*C&J!43d_8^c+rhodo|spCzMb~d?8f&B%j@%QSKWELC3T*M
zROZG<)9d#z$h<zEJNwD)<hu{{y`DCGo9m7575dq&t0fbwwVpH_%c)rUo`Lmk(WUQu
zj(%VE+w%|O{SD<8-unqTIq)@};hWsps8CeW($3oWJN<LnO<s%l>>2(6UtXq4w+SD$
z5WcrNcP{UeV@Dd#P4@6inPJX)>rL*qcV$c8&b#L|RrPRMTD?ThnIm3PRWEMzG08b|
zn0Mxk#LdP$W@(9w)6%5O(h}RwoT++uI`!_|6Wh5q{(L@vzFp1Fikf|M?^dr!Vg>Ek
z5$c%Gs?ZX(e($}H=TY}es+gtSH{j5Iv1-LHZOt_<!peeMOnU`pC$fe4tYH&0lnhNe
zwd!bnV`68-v2KY&i47MPD+R4t(=+4HkyM|fK4Ds?nT|&ENG2N0SgqOPDQx5`pvYu$
z(pW8JW5lTwr#2=W+T_u@Y{rR+oV*KprPyW}F7i0m;c<3pXGG#muRl|b<{a4Jc204U
zk=nC#!FHCUj0T_CYCbM^T$H!XJYuA#By(HF;bGRvQ}wAn%lx!^wz@bebSMc*&*VLB
zRyf%xSE6lBvGE*FnZn~{F2$DHWMrNd?L2e3Yo}Au#)(so1upS4bIF;gB+!?~r+9WE
zi&LKR<cZCNQZ6%hE^DzUZac|yQ{Zq%a>vCZzH{6ye2+7p-Eii?*}Sc5v$N_yTxQ@k
zI3SzH_2mOU*O!m=%NV2*805CIR#mXKR#jAluiK%wcPHp-a24+LMYe@|OOKhY+gp4+
zR>)K4xu&kl<Gbe`pH%NJx9-<IS2W2p=DDWIBtP3LTZ9Cfc$Y4i;J9UrAnVcvEdsf^
zmI6^xoE(m9mo7~XGl>@ET(DMZ=Eg-gR(NSkElS(iZI&C+otl-YzAQK-KxW&rHJ5I6
z-Ap;HFj=Q5TXpKB(=Jh)JU4K4X&e;XxH@A|m+It%B_dWX2b;D>YiGx<&Nk9E(l+t!
znCzvN%C>UGZJ#w^+hz!L@+_P<&8tiI#FPms9m&zj62}62T(7PzT^SuZdEJtL`osXX
zZA+s<eV9YGMS58z6&iXyo)hDzRCqjh>WYd-W)B}6mom<C4ouQmtahYua=x6^sx@jA
zw^b&qOyb;j*?Q6JFs`g5UyWO4H?HJ*W<Bc`J2oxkc2ZJB@6K(mn_XS9bHaGtu54Pd
zB{|UYh#%u3<CfdzZJRaLZmr_moTYK)#ku;~?UT0Wu4Z!G+R1S{+%W38$F@ywYd3D&
zxHUrHcE$v=TkpD)^lk@c9XsY>((JC8JMloy9VZ`u-kHa`Zf%*Ubmi)jNj^P=l2Mzv
zPOVvQ(RtWN;o-A0m1dJ&r1PaRdQGQ-ZyQ(Z673ecl`%_@<K)f>#XOIj1Ed)4Ee+f0
z=pJ4lG@aAv)YJ3aMw|7FLM^_f>n@w{oX<C<-J;;aO@lJ)P^Zwav}?MdoS|_!&rWV`
zyFFX&JfF+9iOM<CRBleX<#VKC%Mr6FvrT(<Zax*L`0T`;Y~zKI&Xe<IEOefbyR4_f
z`M6nn=RC_fg~qcjD!wIOySOnV<(Q;b;Z!+8o^!sgM)keEzV1pDZ?3w}T6UB<&}EOy
z(m0kCA5|vpKkvaJx<DYTRZ1k)$!CS<ibYXfs!iT3(_EHD3QbLzDxvEBRz9abqV9&b
z>NL42_adq}byX+%`ql4#KL6d%&-ZtqURn3{N__UyeGhE>tc3gJY=RG|8nBs7nh~kl
zV0K;iK<>KehF#O@PnN-2_FZVL{lsZAyTFZp>z#Mc75BZXcZd(-z8lbA#4RGSk;&9!
zN@h^E%A~LmEsIv|j#Xl!LDLjD61}EI2rUi`;rbWqv|2#J^D~!SD5qV<q6n2uLc-5h
zxVN(EYq=~wGRf<QU?Bgj+E2ghA3Qp|%kMScgm?3I*O$iLF;H7J$6Mo8((KUC6qhwU
zEz>+uiZKV!l&Aws$Ap`+>sKud{m;sOVV~j0RXbZ1WYsVB{K{N5tH{?{Z0Zz4rWr>K
zIyzlEoF+KwhGv~iE{9CMf_GcGbWBjGe|B@Wy!-7Z@%gv4wro@Q^kwbVx2%p6O;_*!
z{Cr-$UCsCXaX%uh3jFq6`(5}_z52w<J4F>Ay%L3HJXmHr>7|%ga?{(q=pB03p6+hU
zk5==GzP4UTsc60KtDw2LufwNqTdws9A}~2|g@_TKOmOk;I%%G|<cr_rew0Rrh{-G6
z_YGfR%GRQ_zI^^XbvYZWkSTVio1AnfGS%)`zFBSZ$`vy8SGL`*x&`fX8OWe^#S+^j
zmT7KyIOQDQbIar9_J*7J&(!o!_<nA6Xtr<oiS3s|A1pW|w)NfT7C)PcQcvf{(JFQf
zKe*FA@BM!7luS(06mVMD8P0ZgE8p(uX%Eb<C#PDyiq74etGiSWoDL-T>R|~3(&gK5
zm?v1|Mj|Mc?ApES-|Fbt2MkJ(ZL2N}456W+;R}73jk&h25IJCMusUkhwN+bJhX$#*
zbbx2(wWC&DTW|&}vo$nCvsH2iNMzMk@NQQohlvbAN)8kMuDrXtymU3wxyS1-p50yF
zY~CDOboVZ=St#fd^Q}>9JJxQywRQ?<a0rGOziU_S+4}4ygQSA-5({bRwYweOMBfrR
zedCnG5}_GOH6tZC1-ERSbgkcJy?H;=47N1JnGKo^X$g{GW)p+p%qEe8TuZlmlpF8Z
zz{$t0V%?owbmxG|vwPQq>$i1DEHU&^3Yz9&r0EqRwRTI_R1OCw0frXnnkvvPU**>^
z*R}Hk*ST#pF1k~gD1GZx*+nObqXwOxP6|skldfhaEnUdL;KTshXA9am&M;AkrT_no
z1#2d2t~v0nJ(AJq;Q9j!99*`0cw875nC1qoQ!-HD-^0|vpjz)V`E^v=?Mw&Btgx*s
zqMXbOjCD7g1Ze~@x<+e;8AeBLNn6;sq^U7CX-mT<<J#l}x(C<=7#IcQ*^{04D?oG2
z`>rJkT{*Hgt9Jtf1J|1m-{#A4tyD7lD6uY!l{sgjt3vd7ImS6R8-rWlof9uB_|EWT
zk|*2p&X*yp40;$CgzBXxg)B&6U|?DKK2%hQv*S?aGG&%|D}4h)czJmlE?m%5_4Sf6
z4v@-V;F>jQ((+fm(g6$%znJUyAFK16bTVX-*R7LD*Ep8+PBQbjshl?HQYK4~+gY_~
z2Sp}sayuz)&~>vV=u)oYN?y+`ZK4J%R~nh!R9d#g6eQrJZO|3vTMy!xO*ph{$%)%4
zAy?X#n5wOoI++rv5-`hGIb~MREnl~elV;6AGngGU7@~qR7YBl7=y|*ncv%)OE||h#
zBGkav6u_`$X{PUjBg+^rcrl1gxs`DxgH6={B!0n*L5kCXIVl)A&o2!&D8m4nw4`|I
z85r1(EMv$xaAV2=DNbHC(9v^_4GfH{ZkNBiwfmv##%QT6BGIC5t8_Om=+L+{O*^Bb
zW1EQ}(=_cQB{OFQMU~E!R?ftzF41U@V9hC~guGQWyt)`Sg+%E}O^z~jb(|!+ap{y`
z&lLvK)+T3*W*V-^?OJi|s6x+{+zf_mnk*aZw>CJ7oLuHDt?25yWg6(p<x?peH|2U<
z?K;YtDxz`H)NtjRscTm#hdN4a<G3oAo2V<e)#Y?Zt2R@Jx7npd(JZT_leTf)Hkoo%
za!Hn9q-00h(zMMEXGNtI7H&<9&Rv}t&1v9qTW#C6Cf&77rY^bLCe4^ClyfV@<Lsuk
z+bKER^_j-5kt<ei)Ydw*?Y4H3Tdt;L(~ND3Io(Nu#;h}0XXu;^6}zxHW7$PBu`4&i
zQr27wT06;XN?J(UMd=`8FXu$*tSeKuh6t|WxGlKt(o$0)kI9@Wo}1aO<VZW+jGU6D
zvN_buJJ(fhiP@Rktd2P$nH)1Z)h?RdZ_LUH0qp`!s-J4OWhG)4Xk#j;Zp2zAv1N)`
zi@`TMn@u%z(>Q9PFxx2UmSM1~r{RjDTQd;*K~K4ab~TxGyIoF+*qC(G%(YuANNG)o
z;Fj#Lt{jt$i;LZQMH;ttyDkp&ZR?dX$+);^g4xB4Euqm8x0-VUyUcF6*5_*F3T}z^
zGWN&`x#4!`*2Gy;w{8vV$;~*{am#RxTgO!ml}jm|CbJ@2lQXVeOv@EJ+HG`Y>a-{~
z5wpPVtnSpv)f!D6zAEw!H-lD2dEA&Z$;;d2l(ET_jJ6*ZP8^DBHVe8OlgO0F43l!^
z5$HMdS>(!6L$%4Snwn;7GnqWPbL&%1+?HCgG;uq(S&H7Kt-foQT@5^}nz%6H(4mA^
zxgjgfrfr-hc!bB)HJP)`v8~hKVB*xorQST+Jd1giHXKNtYVf%0VKYy#$kkAb!}oJ@
zx4ukrx#W~F(PXCC;hGuuIrNuKx~V(qWX`4~xw#weZCkcxF`shP!qB#}ANdy)oXB6F
zRUb0xDyOQT3-98L+tO|gxw$`8ZWm{4yM8v)x2JPUu4ZpfLz~A5j+7Rmq?wZ@^h~>D
z_+gRLg^9<~i%updtyGzmoX%$<H&shBXkpjdUiTv&R%WN>WO7whJbGlYW{&oy=&QH0
zmS&sXnP_IHl+)1b*>PoZZfLw$3NMe5P@3e-sZ;AcyPvvha8B$!_Uu7=N5>D{4Yi?L
z!|n+CvIzTfxV5C+u8CBW_c$i+E$YeNXgEi4PKH%#?$@xZ(G|)mf{Qp*JY1BI6bfn_
z<~S;)8Yea3+ihtxnIzdMdX|STdbU(WvrT_4VdS|s>e<DNExCsiu3g<VHPSn0I?uLS
z0z39ZswGR-`^=oIa#1MfSNfzb(be8b$r(qb-EJ(+nmR2@IO&$zvXfi8g_dh=Op`b=
z^K@H8;i)%fp)SgNjuX_*nj{Geac;_;<?wT_>Pou_;dzb|4A~qnExCGhYrqo~rCdd|
zOpaMff=W3T=ks#9gk*RrEp`gb>gCjIP14X7bPoM#cEM!nmikF52e#(=D)$MC_HH%w
z2^KkO7`a+E3Um>3$3>&wE;GZ8z0H|g&MDn&M<UEF3Iz%U3WYtEVtcj8S>So{g0&mh
zWUW7y)p0CX#L!q$D`Vq^Nr}8hM>Hn{2#6|cs!W>6%E%aGG|6+-t$mT|q0$q3Ppd4{
z^6*s&X_+$1V<o3{c71q^!jefGnktPUo@qB$X}a@SOHMMbxZ}B{ZIVj6qM)#|#}{pn
zwb6mPZlRvhVPR{e6lXXkc&a!_TexQ(<z19yb}plErLL&T?X=$GlE*D_N<)LDW#k?y
zIGH6np(xW}GOuLHs-U}{3_FgjzP4_{B`eLXB6*4~(N?LsXP2~0GO2G;7V_jZQgcyG
zN#|dlb?NH9RqqVgw!OM`+idF(liaK|YYs+Ds&R~1bBTA|tZlcRWK8O~sMd8fI@dL3
zxsJ@4V-m-Fg@w~p@-{43cI8-Y#HlnU&d^D@8&yM0)HlX;b{sKGJQBx|E|Y1}Trk^H
zZH7hSnL{QL9g+&&T*jh48@Y|@BaV72E|lES<fK+;aK|-R^qe=(s)va)^_3^7Fs_)W
zpew?-L6n6-l!YN;fms8qsEDhp%hEIxrQ0csm5yEY61gqyWVG6#(d^PRx0^@OT=Gl~
ztq3){a78jQH#2L~lC3<)wp`2dSRCzPa-)NFRjyBh)`Lx;gL`ky6kKVV&8i_%ziHaF
zv`CMqoso@(Ern^vXP=bvG`OJVVkEf8%q3B9+uOalo0f!`oY0oqA{}O?EO2&BSMr?6
z%`=Y}s~UJSFojLcy|h|2C~D2p)yob#PP^99ves+TwTY??%G$ZH$vK`ay>mkYHwE1m
zT4Nd->bQv`vMcOnU&Lmu&76^KsXV6^D%5v2Opr1;sGPHL$}}B~#T<#=GlOS}Wof<H
zwq#DyveX$fC#FsbmS~nZmEtp_vq#M!nd=+Z^{x3#7o;`@2xc>8@J6iQXf*N+{dvUA
z({x9|8WAa9N5>_%ILvrCIn|o9I1VmZ>Y3`W>Dr~RCoEHDcXF=OIg$6&Xmz^M(x6M}
zLc4C&UzJkP-N1Iu#3MR^*K1ib+lt;vQKz<?$lP}J>`{?G-6espT*9s(hL^^Qwcrhz
z%5J?9y*+`wy*i7!G|jv;7A@Mqc8fPe+Huvy4VT(FI%dwA(KAt^fuomYvgek`iYh0C
zR6KPy1qEeqyS75*B8yk<Vm2O$wOjXVy=oBEs%K1M;B8=9>Ht0smF)o28tELdYYf*I
z7(7)j1*K{)Q)*E0obhCWo1&5AG3B14$!e>Ojl4Cd-CF0?snIJGb&GekpPr%YtW7%V
zddfV#N6a3XJ@TBnYGY{AYSAb)MV`(@2`v-NGNgoNCM|XfHp#VYEfzgvvF5nMblu*q
zywOVa$+>xxP6=J|6*Vzja#P4x)O2!Kz@-~&r*4iio4Dj8TX%9p?!L{}G*<+Nrbx3*
z)`{4ZIWc34XtUa8l`E4}M4MH61KbuZbK4X(X;Y|b%GG8e24f+^DUFfZYMXVHHBFl?
zopQ@cS#?v8g>kZ)&#H-xlXaJB&6EmS8L5<WR$5r#P`$HOvi8j6Aj^ejQ)Zo7*`sqN
z(%Ue1%cUb50=%|`r6y_}n3^2qbJ0*Mr*mTG7BeSKDKp-+5uIUO)53H&=59I6z#!F|
zAt7ycdfByAtGgzrc&&3!$W=R(6S_7u>dsERm>;*l?!W(fCeLOgzVf^~@7_=HT7CVb
zfV}*)wX3tV-HsirKL!FvyL1ARdXYg_x5Tz1VUw<;T+TGkI;zbowb4sts?<@@-iS33
zCsQ`%gyn3z6e{M`wB(?wV?b_5w6xo?wUaZB=42f+T(m`Ma+Jm`!>z_yQ@tW{lanQS
zA{rPbv&^^}W#ZYJaMNtXZB@0^soU0QYZz^-UzV+=8F9Ad#?2u9HOen^Ce_uvd*K8+
zi_ytNkpslwOiL3sXi+paHa1ogHa3_E0TVf#(m<-bK_U=Yoim5h(ga%0oH=u5voYt)
z8BW5+#>PfZ3tG;cQA-1Z6sNQ_kRV80(b$-C=FFM(AmapP&YpX>cn)Ys<(%i1QQ*;S
z!=A97WC_sqp5jr<EzcFtdG~tGbIW6CX=$k-Eieo+(4YlmK1g^5Xz%2iGiOeNTnoiU
zAnOx3Kr*Khj@1i+xTPMX$_V6U7~TvLfnu;HL58QLB^n!ZIDvhUCTt9`5lPT>)sEAl
z1-YRIw}wk*t>ay_!)(=qTdR8zUWe$!B<oRxzy`2|=Dh<S$qMnl#G=qdXh=vbmY5p7
zd(QLnSZL@PgFLk1%o#+;pM_f8Or$G>($dl(wqA{S&UWYLpY8u9ABYv7d@7a~gzHl{
zm7cg9+$PDS=i(!sI04RyDKEYdcc4FEL)R&ZIcv42=C0ok*%}HyM5;w)ihl9lvbQ&#
z-iBM>JE`I1>GWQU)hC(lMiR(00gjbDSpt&+_Iav8j#&k7YT4xpQYZ61@9x5qNdXXE
z{Y#a_G7L;0O&Csqy9Z=k!fl?Iju~c$6<kkrHs=_zG=a3BN$h#Ndmiui#{H_HS}Q}n
zS{MXiz>!73kr5d%Yjj+i<grXiv%XQ$hlA7CDch7QQ)QBeS(dJr&;$VpmARC`kvTPJ
z$q6oJPqvxNsX13o7}UHnH!jw>ma4fqEg>yrh0!Ti1I;N%8af%L9N<)&#?d>CfoBQ-
zbp|GdCI*%R5-iIE96SZs95oo%&JI&hGD^6TaXT{W{@jvD&IS`0cn+LlsyC5rlMK%0
z7P|oLv4PhCaH@bNFx8a7^P8E=E@!GGsIV~drma|O>d6_F1zuUgz#Mive@b+8&DFr%
zZMVPH7k&El`Mk{@D7cqzK7IN`aWIsw*FWd~<mtY@cb}X7o?ZQY&3@Va@$0Y83;liT
zasAg_bz7^q9-qBz-`_`{*6+J6X_xgk^xgHG^mDiN`^>X=D!#Ag$8`^d-u*cfn3h|m
z&x_x%=0^V13;UKWUvq8xHBY;36IP#EwQAMss+IS?uYDn;>MD|)a_fBNHU@^=ZMQGE
zOsb#aS><*+ciUU5?(<e#Uj5p&b=l@ehwR($_wg-!D)p)U+t17UYJMI*>o)1f&TVF&
z^B?EWetmsU1r+4-KHOtt!vKcdx!XU!_5OO+bn*P<rDtc9@pt<D7Mi!Cu+z(4US3Z4
zHUHXQD@_V&Zr_r+x5`&WLcVv~w!$!}SH7CH7ju8v-g-M{d(QMbrN2@>9@p6W`T4OI
zlYW<;Qm?Q5Bz{rCfd6jvT;ucAw_n<Pe|zY(aFG7Q(&>jce<;&GckFK*Xp3a@0rB!e
zi*2`am+ESWwQhQScS^XaYt-&I72R!1yt*`brBx<<fBXJ?_5J;=@cpRZow$?ZrE?hc
z_4j?h_j|s+-Jja?>l+yAw#^ML{JePMZRy_nJyU=3&zWvg={9$TQp|acOVu^{=O=;o
zrDpDrw#)szw{F>jIu1sQj~{=Cf;N1*8Foxma+%*ZKREm4y3-Hd`v<;P-}8OXugTYQ
zDl(<FN&Sk`n{-(wZ)->0m%Txf`craEm3!^`qGC&<>=hT@e){6l(QTc2FJ-a~if^sh
zRCnrL{Y{YXqCyizLqXd~Qs4107|+^y;>f$)uwCcC+ffDL7cj)@{oeO`zInxy+$|TD
z&E2V&xnEIN^>)GM!1Y=?K7P0a+9BJ-q2$sjWH01)yE#c_D+|+tO`g`5Jauzo3VV_l
z=SSymzx0$f@_p3bqMtv1t(Drnb#~O&45w9h>Z3DOWlsrK<9sT5^4aBDRmkSil}6v$
z86?lfES==3(iC?4_4<MWhApT3&)?tu{QSPZvX}3>$S|r+_OSc?zBM$&CE}Rj?`!X?
zuWP=yE}C?Cm*=U^IeyU(cAoZLx7tnYj_8-`y?PhFOat#q-S%_(4hx2JSr2!`yqR-*
z?Y8^%lRv%PGVR-~w@i7aMV__Qxg{yHzTJAW!1vhRExWUxOj><Adkg1|t0z^%3uL{I
zzPTH-(^X(<^p*)uui`Wu^wVzVefQAb%^viz+Pr#+D0sK%PmVy>Nvj@tKz57H&NV%#
z7WROhOLBYfk}Z#Id-ax;?{dCgIB(75*kjeo-eK$Q-Yv`AeOF-}RL(JgdB>i(vsX_~
z3FHjjutcDpc_zc2&AHpFmx$irdqj*qAp0f@?6a+ZR~;!f<&_@KtUcMP{&7~9qLoyw
zI*Zso<=V%YPTE@ml6kvjYIOI(gtU7Rm&{dGh8C*q5wq59xR<--+ObKi3oCSZZd**&
z)?;ktx&5HaQ_O2+VeTS{(A)+0a<^P(nHgEYqmg!BOZK|nB+HESeEz+6%F7Gpvr8P?
z=^9^ke{KDi<xsh_`_J}1{V((_({1*r%oo$noqajQmS0p`^-lV}zi)pf-q~O^kMmW0
zzFyU|L(?xaRG-?pyi4}RP04GQcil7FE+fNUG&g<kz29-)+t>Y^opy6}6X@(!LlA4m
z;uIaEvshKY_tz>vdJ^??>xtX-vyQC;oy7XXW{=I&GjlZx4<*ZRbj*%!5zpzrUwij{
zJajY@baEw2qeA5N3mRJUEmrZ*h&XD<EUc<6>Ek96u~8-2bK9{LZIPK;9d467XUyzm
z;@srSX)K_Yrjpj?(b1%6lBw)zHgi$tHV+RUkIZEXojgh&IUW<Ysno07^w~7!nB<gY
zk-tPIo-uf6Jj+K(a7*u!bBfb-&h#YmB~I2<N%484aM_}*N9D|6t-^yz$ui6NWFBqS
zI#)P(Y8y{v(jlS3bD*<`3VF9ZX%bZOob9QiWL#v<df;@MPRw(Q$C^Ef&IW0rg^@jC
z?lO#LMA;;?4!RT=7qgk&ZmEB@c<$!?Q$s5%s#ZL`Dzj_x^pN64&a3X$=~a7dY(t7(
z^~DCgUdKIocg8KJomNlIo{Ux5Ej0CDQF$cSlh;$WdpvpTu`OkaOYFIaF}roMx96@7
zTjQz$hFVXyZq2&dv9##T?y_53vyKF{1hoY2Ql8|OrKI=V_0C-B!n-FgJga}v2N&pj
z=hvRQ>z$R(inS&J8_UDJBBsnV=~T`!^c9u}@tLyGXQpUwYP5-<o8e-y8$P#AO`Enj
z*Q~=*<fev}ciUY(*O+alD{q+vEmPMhTC*`NEg@1&Sy`}gYPguu?p>{m=32Wg4xExD
zvsUPq*|LjU&3dOQ^F>A1w>YsqnK^4!P_x?Ashd@Jm3+_nS@M~br9Qp6E+&-g%yWx7
z&vO>7xa7I*o=L(pC9_MqGp?_C8!>U`?OrX#iQ5vDZhZBfC%C=ovC^Z{f@arxw{DD7
zQh4xOxN(u06X(X;-qPLE@<2Duij=(eT#_DIJoDn|;9RHjl5_7)-0~0IoL7Hr(T0gT
z&#`qFA640QLn&|Lu3NL$&gztDkDQyD=XJI>Z|Xte+y%eaz1u0KyW?ii(Gzplth%{5
zi+5W#d+2QARi|#KEW2?fF`8|ucG^|1+ZneQL&L7P-Ifm8oa-%amZ7Rskep;<GIR1_
zb6HKZnXAK&&v|f>Upj4Lq}%0A!8uQ?6YHn0xSTv8)A(G)ZSy&ICTGr^5!_XfC^Jp#
zRO%e*f;PvqbEkF*ABo_e^?JHxPS~AR<27lM=3aSfDbo{d#cB2;XJOH1nHP(bCMRl}
zq}^q{$`)|f?A+`W-Db0mT(?8DPR>@@$lJLrx{s4RQ|!{zFcqzbPSY1msd5VSJ`fOU
z@4>aAJ~w2dPf*fiR>7u@Bdrk=Rx?Ei9ctCl2s)^7P~(q={w_NyJIUAIw>`O(%|EI4
zWAg1xmWGL$pMTi={QQI8X1|f?_we|->d&7%A5Hka@%r9En~KL0AJiGjqvn+Gy;VDT
z=<UP@*7F`%&&!vNZiX~Ul~a*gn+xkrCz*j-oPN*CEzeo+{K^{onQK17gdeQF9;?=h
zc&=LMwPm8PqSn$Wi`+d$W4IP3Ee(y(a?KD4N$@gSG1dK{R%eu;Q2S2LcOvdP6~kCI
zObxAWX<y|UTD5Aa)|Zx5(;Gv)zWetrKQ5Fdbi+4y!u{Dl*HyF!?A<lF=ksN~+pXK{
zIkqh>>e`-Kw7TdLXji8I#{?BlFd_eb?TV?tS>!`)E<Rg%Hg@Tzvai|EU$?J$^cAg~
z>e`)>tC_oH>9$J^&~2fhjg<ec=06V2%Jl$MyB*V(fSLs^QCBy@Hu-`U<blNMCyHHL
zwszCkpYH;%$4z4Vq8?G}{=H2jI)|yzrnf5V*U2RpR9DsM&;5P;>Gm}r-7~C3Y+k5-
zomaYqzr4EhnC8I)a~O{q9+zUblD5sxQm+l~uRK@1_uD<_;n9kqO|P)v7SU8;7b@Tc
zHTL681M1~|H!+;sTYrb)+}=A3r#U>z<MzCt_kDiFn%eWbmWHLaFO@zWez1vU>+;jj
ztNRZ=pZ;WR^G3(wT-|N#dpm9RJu2)fC{Sl8>?u6fc=|5iyJuJ28{Y1o^L+RH@+#&g
za8IIzoke8|%mo20$|=wbiQ~Q2#r>-J^NVrr?H$bZesAwMTxwvwdp#z1yL0ZokJs#;
z-&(OM>F}lAr_(P)Xb5e!i?{yVfARVBXC7~YqI2Z+bKGwUpMIw<GvnZaxeV`aD;1`^
zt6q5b&aI9wd{18&-+RA%FXKV5C!JvK0BzIPa1z{P2D%gZpqU^4tf!}^@3Wh4*B)0{
zf3L#1-{$inxrmka=b!)l_qV?O`{jSX{x83O`L})l_Xb8G1qML{4<Q8x1_t@ZC!uqQ
z6I6seCa7@Acz|oCM-CJ3-c@3}GeM;geq3#%5~C1Hqw=3s<+*D&@;XOy?k_$YH+kD@
z<=u04G40NiTD5B3iK}I|b?ZaJQ?DW4wkr2?)z4gSC*Rx#OLP9h6zh!^&*!Nb9_(Xr
zaXqDVYo=(pcBVIEOK_uthss0+4<Xy^r!h@g(TXc`Cg+*+3uI>BlF_&EN#rR|GtS=B
zwe7L;rZ?Lz!X56wpyV*|UDmFXD|MN&#17S`-frJ@=u+uxKI8Mk95aqHDJd6qZO@$;
zy7LFbb3!aoulzp~5av1MT1dV77KVvmwm%SHVU@ebro_O&=*PgoC?S--N1i7%x5wac
zlF!7REKk=a6}2;7*EXlEIl!Q`YEq{lr+}!EM#~DOwlk}o0<{{0rYdx;_BE@QWL(9-
z!0fPqzx^nqGNgOO^IQ08<B}@gu*Pi+3=C}jT<51-6!=*ufMg}x@1Acimys!NzAmMs
zQlsk6veI*ciG)z7?Z1_wrVI>BA>UU8O=>v7AXK#?I8<{2`@$6>Q?)W*Rfklxd~)NO
zHD%Tmo(A@3t783rwOyGxJFtG{R<lKB*F0{g^o9s}N~>gDRmq)X%65xuwWoB>#1+~B
zp)R>Ax<ka8t~9P`^%PwRx!E*1<90^3isy#OX)c}{1=UWP3FXdG^4-=knPrlSlFBV5
zpR<B$x0KvCI?Zk=`L=XU)!d+U!?&yL)PysvX;YS64cfNi))X^Mo>ME+>RHWhZVcLX
z(|4=pY_6qAy^SiJt=`6lGgZyJ!qTpWm<ffMaY}A>@s{*m>2)*gqI1@Sw4j;Vxf#m2
z*$Lely<1m?ththQ+f&JRv&kf5PTxgSxB4z>yTojynYLotC9kuaW_$A74&XVd+H=-p
z+p1ekW@pu=ZE#z0OLx_=+dfL$5~b_2lp`~xL)_M6-ImT46<w1nb<{0UbTh{yvx~Xe
zs@pClc?#t&b2)KVrPE+?N>8rZtxP57%q5*HZI{wAleHxR0=MQQ`flY}b|pDw;-<B$
zgbj?j&aCP=8o44kYunOIid)vMGMjeAtW(<SmQz~jOmD-GG_Ny(X4|48qngaNu28yC
z@3u%gYf9o&uhhhrS#Fa(K=#d6nW$jo6V;l!W#fvINp4bR8^V_K`noRMBApYRaywy*
zXqIm@YgW^ZNt?B{ow+D6%TdjDQL;yhj|=Z2gPt@uL!DGHqrh3KQ<O8#OwO8;%aN>g
ziR~os%#dZbxt8Xf3QId0G&}6fkx43MK4*^ACuwd_PMRIEI5Q+o%jb&b#(=Y1)vg52
z&I(CWnQ`XCnk<gnCbObha@YDOXSU?7=uKS`?Gn05H(KgeXG^X@7jMRztFto=RXWWs
zE2ZSBbef&<Rq@=EspP24(vxYNm9}8Pip7~ZYNu{3yVAL3TeAu$lTVK4tZ2h&tFyL=
z<V1($*6U8Wsgx5P>XsTgHI2)d+i+WI&}PXHR&8mc)mdgYRXU9&ReEyPww!6snv^D(
z7BJ(I=0?#iD~uI<*G{{3bK}a0rN(BLGNpXgPWiT->Q1>CwC3PUkr}3GD}8)@w}nbJ
zZPwU!OYFAGfm6pqmN+P}b=<c5w&v<;NyA);ty)PvfztKa5?7Klx&x&{CARhC3a;%?
zm=!f^+9I=#8{L8~A+8y{8NIoJi#V6&PCA*bI_c`9Olg%%hAfwaGC76PJeRi2a`0S|
zGug9K$YZ9Ep`vcYZRsejW0zARF0M|_Sd;6v)iq*GbW*UGZkH+7txX#vr`+`2G)qC{
zw&!LQDc{K%6PKK<H#?c;amaB=ipp%E!@*f;VK<!<7j<pZm3CdRHgH?-;%IGMw~HH-
zy1Fh-&h+g$wdQD=%9)ije3#5rR8HBZa!~E2!Yo6bvr!wlgT=1(1om!QaINF!LYCWR
zN>{FIGu+m3qieC)O4Aj+z8tEvj$|kKswvEJQ@gBkNhs4eWlG9PCC_@{%t_n4RdZD*
z=Wg7RYnC%>w$w&}H4#m13q5YQT{#wZVdj)G%R+9sO`Pqd!pSx{x7*b$;^Nwfn`TkD
zy<4NhM7N1{rmfwklF}BYb8?2Z<jk;CpOcAeSFYB~+>mv1OU9`--HfB#W|?IvU2(f4
z?71md+T<jQ$4#|~ohGwIqJ3wz)SoarY8G<SY;o3Ro;5*dCS>wVOWL5FJ9V>m&`oJ?
zLt&$yOV-b#GZS?brY;J0-Ke=yb0Nz$wMo-%X=|Kx^Audtamgi9$y4B@k)z5?6;GvH
z!A{j#I!Ami8UElCXyV9lR%B~YWNR_xFcNT*Xfbx;UC7HJCC1Mws%UUWN0LKeV||Nw
z)Ffk-X`QnzoWyc69J$RwSDGG7HWE%d=b5o((nVt#owHX}CPkdx;dYZ-+9a|aB+t#`
zsp4|f)GTo2MrF?}lN7g$<<54UIXB2tMMmdFhTH9lN@{5*RTo|IcHMT#D9I?vDC((i
zc8rk9G{fzDd<KPEZX90Zsj^D!V3tY!)J<9Zd!tr+s(ny0%AIW!H09Q|_1tVHRVxxs
zYVKnZoX|EqxBb*4kEz*}(t;~B&A8c4di)Gqb;)xdONx`!!EIlZ4RymD?sZpdYh@fe
z>6xj~+i_*eY}V$KN&9&uRkpuc_o{GnlafGN>%~ajsnJ)XO;_~H=$X+oYi)MN5h<gb
zDfQF5yp)qnRn-nA+*I0Q80BexV6)9C-_0E^%8ndPQo?K2F1eGicH6c`hHO2vRaGZV
z>bR+LWu~U##-QlMY@WKe&St&v5V{?+aKeQPzO&axXFd<p+Nd()VOs9y2R&K6q1%>C
zxO7B2D{!^SEw{BD*L0?x%*k=vn6k|~&rpQzsL@H!=q;z1PILx&`W(rabTY3)Wzyc@
zsC6x~dfjeq3l>U>SmnF9S5T0{p+%9cb=%#*=17&*VOQLmlSNfkms|+x+%hRBWmC@5
z5+={B*&T~a*^Wy2Dk?d-v~_4LSv6UD^7?aHtRE6{a%v{uJ113tpzTsv*u}(4(OO$v
z7oGG9o&HXm?WF3~1G73d<b*`4s%}a<;e0SH$Cf3{oWoX1;Ct^OC6kN}g^pW-+gdVC
zT;%YM)-IXKpqgOh6{<2RMAd<F4Xeu1AWzkWS`5AkS{_ZFDyKx&T;0-W+SMGfDO5FS
z!8M(!p3$EL8Iz4pdIoDuE<YbpzdzaIs7dEuffj)eFCO=7YZTnkyTg6f)F@xAX{#oC
zO!5`-Jl50VboOd$n98)=V;zkGO$vhBL)L~)S+i!T%0xxA2@mI9ReN|hG{`eFRAr7r
z!-)?9O*vn4ybZ+;uG+Bb*rbT0*<mTYM-n!Qs;W-%)Lk8PN_1<+Of?Ue<R*iXWfSW+
z9%ybdyS3RnONf)_YS)?t6Q*&vYA&&`Et#ZpamFddrUMZ?0ehEb-Fuv%)v!UDaYb-e
z!-lR9qcdAIm#mqbsWL%jlG`NTC6hdvJXJE4T%6g?7-Y6Mg-nX{6v|ZT_vO8sY33;v
z)Uo8+k)YfF4{w#Eu9K#@(cUR7Glf&bCS15!zhJ{sQ`JpDIg(lnIaQ`6N_pL$(X>Qp
z$&yKDS7_)=%2r8PWD+PeWtz9D!!!nusi8rheXBhj1)Mmx1x)htnyulfHnGLSndxTR
zMAIaWj!r?9BqfzjLFGwNp-TdF1%*8ok0=U)0_O&^r|Pz>Hm_4V4+wcMs%%yD%$e<W
z(ln<&V9iAqw@XPr8LHb@wi=~43M#Vr3aJ#_6b+43ne8OxX<`%>8vc$kfPsOT+kt`M
zpvojK$SyP0NkO5_S-e@Ey4za48pITIbs3nBFscTvRGAnF8UUZ1wP2N$r`S@j*^HSP
z(hQ;wvq59zX?ZKAB_85&GGtLs;&9v1Rj<r;FjHlvrdFV`OP-nHf+i`$IWm0QTx+NL
zT=L}FBAsD&Wm06&4PA%Zo@yr)QUoq&1+ZL@^7K@hbTLpmaLrWDwL2y)xDaB}F=OJk
zf_E#EriAAD`Y!RDbi{JzPN9sB41od}wt_YRXSwIP)3!~UHaT?d5|yhyotrYZI4LCs
zD0|j>M+&%2nzjkFVN$GVvvQ`cYRa}q&rNHY6gW<*dQ7@8Q8_cMbEB{!NY!R3onVD6
ztFygQW-5F53f+=)GxG{%P?@&v)RtAb2X7mmn3kz>ro%-m;V2KcSZbPEqD#u5v${(+
z^=jQ*lq+`O#3j{D+ol@3C~jJFZQEKgjf+b*y47Ela`M%<x-qnqS9jYvnKQ=Ij%FDt
zJ24cntGE;^DX+KMwsv(k_B$0JqJf|-l!05Nj*5BpCUvV$PK%a0s<?7%u8&8Uh~}1A
zPPfi@8_jezJEgf%?Ml$uZN6Dr-K?&xZf2&vy}fQ57bm&)Zrr#rscErGw3M!6pyQgr
zZN1XcZib89mSxV)GF+S!EiEmkv8}gTV$m_Pi>`~aw7gPRfrNdo9Xo2aI!hwu;>u+U
zHm9xHxb0{bZ?fB3$2A#SZf?jib33~<cZ;W-T<F@#{h!1q&#K~@{5D!-^8L$;CSR=*
zQBDd?XbyqGP~=%P*p%8a!^yGL@{=8`S%i*)u1)M@TM30rz!xaWGA2!qu9oHiOSXW8
zgn5!e6SX$XTK(t${8vvVPq3DloN$$`KEC?utFN{1tM7gP_oudGZ`}7~SNm0PQA@+b
z*T=1|zAWciwfDX6YB^7h*s8s+cV3Uxhz))BZc^~Q8K1nbzOTxS08^p4yPuza_U^ac
z?RC2%%yXl6&)xNUX>-}t-8&Hi^=Kj|^~3kR+?ouhqVIjnjZTJX+%xHG^}X3)HW11Z
zY)okN^=H@b*MfTP+@E*vy&hZo?%jKEhc<rR@Atdk*VfkRNN-zv_uSpmO9yvn-M#bn
zdaRE0s%^V>Z}LpItBC9vxLfv?-F;uZch$aC+x}gcEEp$W&j6lhW7c4hbP#ZCoWjT=
zVIabAilK>trEv;_g99fUTL6QDfQp2H(FFzurT`{~85|0brKlh!3LXXwDx6G?oB<3B
zsvwrbl*Z2;JS-9%Ee9AG8JQ9onmB|e*cCD|vPf`vF$8R2U}NH8I@`dY#Nor>;>e;?
zZ<xWrz@Wq-#Kh9j(9p!usKCU;(Ztb^*r3q3tbv)^a0LSclR~3{f`?dg0t17Bf`SK!
z5ZkRR(-ojTAObTgFfgz*FnTq>7QI4-iI+97F1x_Mz{zaF;K<}~hB-KZfnkEN1B-wP
zR|EqGhY)MM4g&+X76U`*w(TL&xmQJ_vkMDr_D_9^2A;&ZK8bS$2|k}!2?Fuw-^rgY
ze<vRH{*K<-PxpSeK0T=R{tox)PSg841fM;*y}vkN@42AZnms#ICVB5K`t)Fur}-gI
zm3z?->z-?>O!~zVn9`)IB5}Xoq2t)(^vA77MeAO#n=UfZb$x;5jyrkg%cU<rapPpt
zSTxVFFz@TVkKs0!g*)!#`<XAh_ebWAVBvm0^QF=6@BLmb`@AZ)^!O@MF$N|Fvs>40
zXZ@|)7I*(6c&UJ-|FwBv@0Z`XyMFJ^_YbDrdtFuIf6!#(iWQ5$C9~~ik*)MMsds&)
z{o_w@LG-qG{=*M{K<Dug6njGjdjp7DwN%$@$ttfUtGu5{=N4M5-LjYUQNiuZD(-`)
zPgZ@nomth{XwkbxWxlvc<(GHwwoE^I#O4?1E=Mmjg}GAMSA3X?g0J{6vNI@sH}^gA
z^-k}XS5t$!g1zb`7?cbSei2|e669&`u2=BzNT9fV>BZ}@G7l#T9o)MkFM1ANp1J73
zSI_yw?=TpcGF-^qt9ZJ3?(22C?|EPMJ!@fExMLlExJA|eI^~@Qo;_i1{$e(j@9E7W
zmxC-i7G=wQn6puB@q}Hk`$Mu!*2c$|=@mS+2klK{Fh93r=l$||jD?d|+%&CM0B=Or
z^a}D65@=EU^n2c?l*yGrr#56iZR2NZ{u0a-;u;$JT!&|Ka#J(oRW_FBg9T6Loi?kI
z`?+SW>Bp&o6%$YJR=KZhaaVD99%+>tpeNoZrVOh0bQgcBI~$TxsdvkB;Yp<%uYS*G
z;;-IwF7FS=p7+&r?(e;S*K@@akNPgPMoXbAOChDs^%Z8GN<SDF_M2Ou``)*DzV@8F
znx{pk0<YMvZ#jL+_1(%!9-d&47O;C&HN8Bw1X>jN43#35>Ub^L_##;%S;bpqX=lhZ
zKZi;FIa4H#C|=n(dGaNXoGILg+8vF1k|wk$vN;O096HwYLT^#Kqrrm*2b~1#6;&oZ
z=5SH$ag<5oNi*a~4%ss)CXl11Wg&~wscWAn?hxD%^WM+;+?QRi`|mgW@(P-=v}XO(
zuV24@VPKf#$oTb}-L;!xUv8VLZ9BE8s5;}8-<vsY7v9R--8!jK=((=)%Zs0L3cEZe
z#ZH=>vD@w2WS>c|CO=h*iiP-i?W8C5Es7jYf_KmEo4EV#(!A@{dWsx|JuM2S@1{(W
zT=F(|)2B$)gDSZvW#4T!&)z#-$nDO=&sR^HM(mkp*k(ARMe?kkwwJ(6tw{$fRVLjw
z`_ex@T;*!gr|7hM6Sv=0nH<`8GFc*7vcs__U1Fk!Q_3oDb_pl5vwM~Ew@mU4vsT@f
z`_f&mdfK#5n6>9J^E{<gJ%e1IZ1QgMxIM`ZBB|25Q~6dX$mED)633DRk{-`m3pS4R
z$t3Tb+n4NKhD=_0TVFHx+a%9b$5S@;81@`dIA+}AF-6fRRJFNBQ5xi+Tb^pGWkIg&
z-8Wg|j#9nf^Ch{R+b_M{x<~QOFSk3nC#CD0CC(}OBugx{5U`%_aa%Zl>Fw+aw>!5l
zm0Z`kw&VJ$fOei_Lykh8n3l~>5z9=IYXUhY&#v;D^>o&Csjr?#&whEkC0BdfsjuEW
zN<HZUk0p*sJ9#bb$yt^8(M5UFT9~ZY+~_K|S#Rr2W@}&7;|c6ZQ)E+X*>U8gleE^X
znm~@nVfQ93+wH4%>Z|w12j4H}e!4&Fjq7UDb=%BdyXM^x`rhQfxWG<dY`=@#@x83k
zAE)H>PVtCHZ<=ygQe#ihgvMu%9E$~=eyFUy{W`_wQRpgbVSyti*IPj|e#yGJ#?>M@
ztzDiRK^{)^pvgfoO%?FGp!?Ixm8+J0yZ1RaeCB?0jZLdov}xR5)jM&+A`YjXR7KUL
zYfH9XDZG2;_Uy$`w{zhmtR0~34PV!8yBeClFjQ#9!l30AOI5TVtZMLEdRf-sgU@A?
zQ@gr$Ywg~)a8_GXefqr8>)~%!t<rreVQ~ITJ#Tit$H({8+=s-wf<fVG)ZXFLldQ>M
z)V}V0``z>FWAF3to*y?KF@Eg?I&d94fzit4DGd>qktsZUKzxSlS&_a(F(K8&pq>z=
zq@ZaF7OiCx?&=Ekzvb$<WF^!3ry~7MF6&jD)K_t7eTd!kc52~T=9R~8PM&^GF(S7U
zv>^pd2q`&C{I_ju?yCK(wq31V`?NB5$HjGq+jcyD9$2($#hw#0B4$c+DYR%D3lb=s
zw)N8Wz~kk{d3n9rxmy>&Mry%9^84S`ty`wwV`S7}TsfJ&O=q&kec?%MY%<<qp!o(D
z&~3<qf`X9w2T$;HgwWOLf=rCUljq*&Wi*;xm?1yeF+%}#`QPM*44%o5yZ`v=r>>2f
zn7i$F_VcIte=nq5o4Rg!rD)zQmd(6TrPt5xdi|ra@cixhvss@oshr(g8#pP>sr&d|
zp2VJ1g{}%oFT<WCg8s}~w<qmm&-lIl-tv>6SqMa!wtxfFX_6aE{BPXe(D-P(c;#2}
zwt1_yX7qe>iTl+4GW68}sYdPK^ER*7?W^RqeLkD@&4JWy6&<U#Kh*ldY*r!J1F=Zc
z!%1MNty|Ug-Fx2`KhOGJP@eaF>$_*3lOC$qJ5G9gyL|7vU$>*Ke!KqsX<g|1TMrJ-
zlzg-IDStpsYRIfrJ{6&%A%U)^7B1iOIbrW)M!6MP+n=mX-5$@He~&GwCs~sv_#Vhd
zOKrWJ*q5x`E&9DZJMVt9VqeOnCQg+F%_`G)gghNtCIvW7@@C_i6k(7u>0rVp&-T5~
zJar_D>OB({ESc<Bn{{pL^YftHw4WacDlvd23zQfb7#JUcCZWKC^<1l_Oj)v2Rqwgw
z-Me?sO*rI{sKVrtwsqUBYqzsKA{cH*-OkO<Z98EG5;>@1c5U13s2eH`o(z-37$kC9
z+fF2^*oUvFzH%>vahn|5b5G@xkEx+2rAz8RcuIaRFE1}(-rdgkj(PX)hWFLyisvBO
zR1D0w^R`Qe9_up++kNlzobPhCi$2fWXnbW8t0J4>lq3-+FIA2k_bbm8&wY4#@9u+$
z{K(?bDX4txcK7L6x3$;iJ{5iBaeHl)e)WaSDeh~6ST)%Ur$oKny4^eG%((~8p4~n3
z4(wP)6($ds37iT-P7Dk;c{>$&C;Z%7y|wK7I#0Qe0;-SnRpeB9cPnp*vt^qRG4pju
zqnBe(sv?`=5|u?kYO^N4dZb*RrlGBJD%(_rx#z$v{oT;BO2r)xFf6~ax}%3Hc^3mi
z4HN6P(4IwWLOl#lY6eRSOo}i|(qLAOPUeu#SaosBrP&7Bxg7^h4B9sJrfrK@8K|;a
zz06A5jp=TKd1y~B0|P?_1B2)Rg$Waw^cTPT&cML%`I2w<wUVc2tjqoC1v%GlX4TM|
z#MQp+vG~3vwOSdC?|#R#H-2>t+Vk`FyYh0YCkzaXfgFmj{eH*g*L-ZgXx`GfY*J8H
zMuvggOkRd7Up`IL3aS!jIg-$$CN$40<VpZ2GA3Wun5a_KlsSP-abeS>5YH(_jK&HM
zU(FVTT$wVJm+>V71H;eI@Na+X>sOinOfSivc~|OLx!cZXt&b}I%sH}Mn)}FSr;j!l
zvS&UkJ)XVoYFW}U2ux0UclXxk6W5J*nVxyqTWoV~$7|g($*!4QGkbThEz32SvC=Ro
zIaMlg*|qh@kFCGGUUkVOjwQXbe03ALJZ>td^iDF%)K#0{s*-alr+1>0c3Qolx965#
z7ssGWW-Dfbrc88M7i^K*H_L3_Y?+H&&-P{9dUo6-w>Wv0+0M<c?w)$7&R~Nqbh=!7
z$sERak2IyBrljPwh$^x6F3#ljnAs9`MyX@l*2?s*m+B0*7}^-jstY3PJ5#+>GmVs$
zQaqKMlzbs`6&#&r9g{OaMCL?EVI@x?L7`kDwTo)kCQMQ>o8>W~W3r3qwu?eJvpgnr
zn)nLk3b|j_?ft|mEpjT=Xr`~jij8U0x&@OxPP;YT4sYsC+Gd)eu}xd-#)T+t(G^?Q
zp52nWI9EDjQ*N@WYeW6DZnbq0x}sfI#ctfrjWyf2XwiXe*U1^Ti-SCadY70@mQ-o!
zU1HL;S!uJYb!e{OmRxC%D>=Cvk|Vv@bTWmG=EfSX$xT|TX4<=0JJ}@HcSWveS#YXZ
zNVKc!nrK(ojwRboGH%Td$konT@yt8bOytTUpT(tHeAP0|GTB@%rA@9+nYpDolXtG!
z)t-QbPOYhCm(o^lYl%|2DAuvXZQBml+y%X>1y|jkb#Z3o)R`{Z7W(>}l-$m-rPyst
z#<gCli;JU7ayR7&Fp4QOE#lCbExKsiU6m!Pb0)d8rJoiB-QE|zOLo`d+#KtLw^x~!
zC#}u*xv46-I&r(sl5L46H+tT>U7xk|j90ScD(_8f7jAfO)!Zs}A>4Fkz?(_MW+6ML
zEX$hon$gkc=2h*SQ%iGB<!Z)UklmKEcEa2hb5087&Q$4S&T9y}b=2>oZ&$8o%oV<?
zp4V>9nQ>FitV%>9V4>})oo8qJJ&k#`duv+ynv=7$d?$vR+?=uW?4~JibGJIrR5_Nm
zv|jJf+O`vX7sX9h-couKXt}^TWbNuquCr+@X}KP2r>vcJN^};-t*H@5avvwBm#JIH
z?C4zg0+#v>I)kH)V^653TMPU4<RmAnsm{1{JIz(q<aW-9rD9Hzo@U%$Dn3oV3X?rl
zu6e1r&D1i;jgB~WV;hgpid!?ciXH5nS}!fS?fT^C^h}p-wUpk?tIk;JYD_daGTY;d
z<ebRfGa=bhhHAIcF0RQq<m+RY>C&xpl3C@nmx@cKQCr&Dh_D{l%&Cjrlyh=JeO63N
zNeaqsT`Ht<TXn+L-00Ih62@t_vmz1>PBjd>n&`1L%5b*Xs?Nu*F`0Z<mP=;|o)L{X
zwYWaQOi6u`j@Blfpc7k#mOfmayJ}mqQcix;l_R>YNj-sGAx9-HJ8^Eyab20&opJ1<
zwBSZ*p_Loev;`NLE;2eb)pOC5*=iFz)Fw>!@LZyDNx)Z8ZL*rDkjHFaVUL??6MUD<
za*WnpY8tUI>DZ}|tSr}vH6bA(A#NL!ZkYwUc5ce87c%Kp_PAs++eyX4WVY(IMYq<h
zSu16dX%;1&am&oi%#7<;Z^orS&!C&Ci&AE)c}`04RJpC<bCq}PN@=r6n{}>=9hG*C
zoDv;mwlcD7b~MM$t*$fEgl;Kkd7HX!=v@>!Wlxu!JC8xa0h`dUAfKp^?IE|eO|_IX
zlr)qy?Rm)7Qg53(<00=}-&GsdOx!Z->$ckkjSr3arB+%bMkLI+mNn&J$6=-2j0Hyx
zu7oFw^LX=wNvKJbvzKnWo!;TMJ!4VlN#`R<B{}A6N>ZhdWSDL{T*dF`@N2c!CeMVo
z9&x5SN@k0F3S0Hocg5N%H+4=Xt<+j_oPB$K#4^uq&z1XEoM_CbpLSyw7kH+`z`32d
zTxE;T!D!RhB~cpNwQ|2|+;_W{A2RJ`pOTW2F2~C$nZ_Dv$4|EVoC=yXyJkv$+qLvn
z-Z{qwI$TN$m2;ECUW$dLF7s$P)yZ*XR=2UL>PoL{>FDU1$;Ki}Rm0}9OjJpBof&O>
zvFo5$aB%)gw_j$xd!p;jEP4eO9d{R!dv$AdrpoO`F&%?X4-cPrZdR38%)6~pbrH|`
zkX5DYZeE|ZJ9k~~#;tCvlysu2I{i!o4l}1lJ7?uY&Mu7(%~hFQA#jmJ?wN&O<Ds16
z$0we#^OF3KD>%W-Hpo*Yp?cM;tfPxoZ(X}=0b@@{vQ%bp>az7(TOTl7t!K#M)eM?i
zns39>!{orppsAQ0o7bf)mL4@D?9hg&pjj6?wjB!y&%0?{;5$uL*KBccW@5C)rQA<z
zS8baV*?Uwt*+o*UN;~(;3Xw^(Rji9GzDBOv?5UhL#US5tRzXtkmcF%CNxOq`b)~N4
zB=mO9I<{8g%C_WfTXSQhl~!BJ8P(sD*FJl~C{p0SG%rt+C6ivw+L6)gshZc!q%qAU
zEM%!tW@JEr&V|PlwoHn+ukD#EwY50wNk;FcNYlKeL)%2#rDg}}Mzu}WiWWO6aqDEJ
zZg)~o(3zPtc3c(C^N~HgLF?V^oY1`0xw|(?F<f*qI_a6Ixl~LiQp-D8%p_80+JR~H
z8%4T;Ts4&o&YCHn<r90|Y%=NA;;7i&QP(akQ%U=!qv>@qD`%-`s-nR}T{Vx3*+Ifm
z(;{`w1kAXy=~M*!q$qWXOQ%DWJf=l06mr>gm1C0G*3v^<o(fHqJVafl-R4>{$=mGK
z<_fPjQ)joB=iYdBd%;qz)4{$zVMonYUJktJcD24oRMIF~tn13!ycN;CUc5R2sk&>m
zu7~GbS*n@*@UCe}duHl6?Owr)ZfjR_a^}wMn05A=hU(@`7bD$nMrN!sUA8GxZFW*x
zi&9G2S&72AlRVQ}j#%ff`RaL5a!+=e;f>=b7hGGi?Vj14qdi%ZmWZrbn!DuEvDd*|
z>|ranU5%XCRli(nQBJh#<=pJqxw(Ri*}4Q)y3AD4S#w1wch%Ajb7c}wJkOh+dUt1V
zvxL;5-GbY$Z74i9?Zl0lt2Av|iY2GcI5RcP<C4djPnk!a%_*L!<hgUX<c>*6ZXFXm
zPA(F-#JS9gWzDv=XGIr#x^9)~Z7|&w9WAkFl6J%b-moP>+YX4`t7kAXKKCdmy<Fe}
z<HmXA!pYV<`n6t8o_V|M)Wj(_eb;4ue55uj?RLpRuiTeTQ|E4}XiHxkId!%1(Q7xi
z`cAp!yX4lY$6{+$_vmg<I;5SO(Ql=kdwli1Z#&JityI?BjOz7MSDCft@p(SoH=8!O
zCWoz^a&=pwS&7%uTVj1H?rqr`USGkm;xIRl&WawlOPM;iGPhin*t%HimSI#+R!_2|
zw|RoMBHKI9?1@EBT-Br31iF^xJWPw2HS<bIVOYkjt*5lp6W6_7D4@J;O~9SttT1oW
z&8j;uMz<9n;dnfAagTeb@|1%!w{9|>a_vy`w%4gLFOL`$oy_UJyKU?4d`XrYCzL(w
zJ+8i&-kM;NyGAoP>6)3zB+p67o|BX{qrwh4F6kCbI=N+1$fT^GTdt-W3Z0so3pzIB
zPV(}W3YxJsG^cD^;ex}OEAy@;M~fC~I&e-3y0TczC32x5_u8nFp*kWK7lKs1ma6!Q
z%&|<IVP*03xXPuIM;9r*af#*%Seklm_S)p=<ofJPvs=xqDwB6Fy18}cmbKoVcPut!
zS`?l%oGw$c%rZGSB`9dANZ`h#qdl{gwu-I@>*eI+<Y;kna&lBywQ7>jsg+iyOg(MZ
z8zXyN7Y9aZ>9SoEm^61wX;AVOC2qdbtx*9N1%-`+1t%#BFbXc{Oxfm{8KmYhQOV`9
z$3&fH*RIqD2DJ#PstPa9^;KEx738aPbNi7ypDaE(_XW+#z4JWkxz*LsDXYX@J)W>V
zT*hS63XNu!+aAp-Tc$lNi@mNZdAQ|_mNARj?6Ao~8J<d>NfDDxe7#PE-SXAR+nRWY
zfvf2V>(T`b8Cw`48cag9CV6@)OmdqDn(&(C70S9r?50Zn)-9Z=A+x)4w>{OE?JUsu
zq-^&znRcn!solF5XRY3HYkBZYORi_CX1QkDt_21yRPvc9pta<1>~7=0Xbu-6;gi-I
z?<%ZrmI~J|;rBatps8%n(g%!^HmSF*-s<j5=?t1-$*OItov7p@xHZ^l<+e*6Cwy{6
zq^w=<#pUibPHst+s$ZKcm6&iUHO=D4-0fm%PnWJ-5p{Is<cVj_ZOz@zTpqS|=^nqR
znYw!(@y?#bHW{?dPc%|#=~k1DnF@WkbM%r$rj+Ft9qZbZ>vnc!w&;w_Y6%-xylA`q
zY)_U>NW_}vgiEQtlYP2f7p##qopB|KXG_Y-O(7?4YNc(NF>#5INn2;V$}LYLwO+Mr
zGfg}$8f6M}GJAz;tN2`+>UC1s#7VK2+1X%Qg2&a!Ne3M>gw|X+C~(Phrf|wkCIJ((
zGuPHcwFPWDlW|)`XX}<tQPaGx>1@jCVprZ^HaXEq_K*TYzfA1$+WPRH|Lt%7&Uy1T
zId{M8>bke9LH#2bu4m27xfuXDWKb)Ffm3CY&!MFb43j)n!Zsz&2wA}(<f$^VY3pR3
zgTXnVYvNcYc`7h4m~Pv^xQf>yJAu<Ao9Bd~P1bV7Ze=l@Y&G3!Q=5`*X1eHHmYQ|8
z$6#Sw$WfyiOQv+Ko!N16TU(Q)XV0~5omI6bJ?5#zm#y6fYTjgm2n5y%opN>3+QnfS
z+cvHiiS~?64&(Jzo49t_O@(D)!J?bGa#!d2tX<99p}1sqPGGW>ZZ~LiT|h`qKuFY$
zqpWU*i%bKzd3lGr-Ik8pxa^`?ba0}X*-Gvop`m|fOzx?YXG-dr{O7VXWA^0kDmkX`
zSJThPGD=T(lVwzAc3llpp~|@hx?!zjdZ0g}Jio@&2(Pt4yimw9S@5dpWPxgK9ndUW
z%c?`6sfP?e<3es62SH;&63Q$fUP2FuBiIC%a<QJCE5|51{rehL0S=JiyC+H*PG)?d
zF#TK=ll=4>RZJrFJ3w0mL0(CgngF{SF#|3pA-sF{&fxd|w}*f2zuT|g;~3aref8>#
zZ#MG`S=|`khX+;P`;aUUlEC-1w9589J6QhGBCSQbS6_VlRB=R9f_ZPO=lkk|V2P_&
z=6&BIaYR&lhjq3DNN)GuSnas}>VuC#CVW}ZwW1qg%GIkczVDGUWOaMTck7rTs~gvS
zpXr7AOxilXcE7%;;Jy34cu{QFl@+sYY6>y$&Q?`&C=XhcowCG(@9ml?os4(q#l^)L
zf&)^$-eyyf3VYc#FPDaQw@!LYki8v=q(^HB__!Z9q55vywd)1@$~+$I-sH}DcanwP
zn~4V%JjCGwEPdR&RSG<WAaWB_3Sw_6H@!P4169G&sDKa<0_m=YYj^0__m1J`nq+~H
zya#U~)XRlpP!B>WhF313E}<^bJDBn&UX9+V;2~sn``y*8&(EL!{Lc$?LELVY$>0Bd
zc)IO&?w$vk4ZQ1Zem-L`yI1-38H3sOd9^>cFw{2K9T306T)VYtO_r(H^85AC`+jG?
zKAv3lb-}BTW?Nr#?`YonC|BlZdmiUEMfv<~->)~nZVU}?4SxHr{fDcot7}o;Tv;ot
zl9Cs%4fmZ|)qn|_7#J9J7#OB7T)VP@fr&$iZLJmqLlaA55ZkR&4GfA33I`iE-C$r~
zkX*pf=yaf-K|p5(1LI}}o<<K22F4933=0@|f9dXEh-!MeZAWwv1M32=TeD0uE@o-L
ziUtM-2D|ATO2P~*f`Wnq35pH}oO2V|n3RMXq%$J6f#-u57??an6@pk5JVY)qY`Mk2
z(5S$W?Z~z&3na_L5h9%lEo^w}qjQU+=WHvUR8%y-|M)}DhOF>Pb@TF4Fze&D>M6#P
zjpG8&Ia%!9v*d`=GrrqbEe!?U9C{`@_ufiApL_3(yiXL#^sjyLG~{Y%?CotiM&%zT
zUp%qXR;GLMbKUuQ2@|h#`p^1wv*_0STd#5|zDIAGIluVInacAUzrCDMVr*Cc&3j>h
z(d|<0_bDoNx!Z1=?lG1<IWy1abWvLL#NY4tft(TgUgg=lccAE9_2$X*r)d$9x22^;
zUwy6G8@E2Ns{2aZqObjK+s+>o-BvrpE9u4)UzU$z$CWZ9{0wu7)EbxC^yFOIkl^1F
zEz`LmQ~1QOv)OD)HA!yAm7E<H8P@B5+i~(^^!ZtDdp_QNo4#D!?ECSa{dK||N6n2i
zzlHvm4RN~bCEusJhxL@k_0p@ZBEjF-(p1$Kq$RAWm@Re2)#Om`_E(Q`-9GdwO?i9S
znD2S##x+L@kH;Dt#XYyQ{2~tua7mTWl$`Aodvdq%uH7NH{L8%yE2IohCxr0o@0(da
zqvKMtho8^;+T3loZs%^lIYa$})|#NBIw2walirzc-}3y<>z8Grp(ZB-Kgw=785kJY
zBUYWi#dJ!<ncUC0Om#E&ec!e(P3!kwdG-sx<@((hUwrYU%2ux73;P0F#uuk=ecShM
zUy~EdkHCGh;X>crct5<2@xCV^aG!5=r;9v4+mHIvyD_on)u!2L&3mzQTIk-1p64P0
zD?>x$+Y3Luv#Z>?aogsN+s@tNa}WTnS@sl-l-Auo>2&IjT+lt3L7sZQ_SJm9U$-x!
z^Q_rzE1&Iax807;-S*p<abE7$(9qD&Hz(b`cj)}=YCnI=y5{D4m-5*5IiJ0~aLtNi
zx8(EJeBWeSUvcr7*^=|+)!EOInGZ48{`~p#=kDFRSFKvL{@$4*3$|(Rj^19r?0uw6
zU}$Jq{@s~#XU_ZbIXi#$`dOTBcklB3UJz-0KRS2Y<$K?!f|ClEh(EGf?GR`Kxrcy)
z!~AMZ-(|j2@8lO78*er;d-CSYInTq~Yp3q6ojG;8VZAz!dGy+S_uj`>Z?WFId$;o<
z-#OLVx2E|v#-98<?a%{}O>w?^_gbF(`r9=$%=JCU0dt?1JFi-`>if<M=i1V0Upp(w
zolZ;ncJG~owfd|zQoEvemlrXv-CW%c-YLrh%C$_g5`DXKx7(fE_q{Cg>+1!d%L6}N
zS6_DQ#Mznk`+nWd-MZ~|?#6BBa<|=9jx@?V5hoeHa%pJzv+w8G=RJSXVi#$>JNsF(
zAg|^T@TPeV0hPJ44N92H?#wh2R&&_elN5Ek>^9r&^6QuWXe9B=yB~hIHZ(Nhma`FP
z&Q@iTo<ZA`WmA@FhV%0UR0Ov#Zs#eeW;=GfS)xsO_r3ZC27wm!a`y6KgEOpwy9+FL
z-<~<~-nST#v(*dAWAEO5dv3b<I@x8(xw=pG%zpRx)hec|5$v~KSAV~`zx>|nnLTO0
zZ`l5LI+MeF?+eBQ$Ez>CFL+<&-SB;{Lh|01^XjrzaD6ZLa1xvCTOVI|ykE}trv9=&
z_XI8{THU@mrQG*U{oRXix7}`D9`{uC;@h3y?|pRaP-RnCwSI%$@5|}S(<}Y`tDoI5
zSuXHsrr9A+-TXGg$@zYFWX-E{?^nMM4G>#(!0vkV+wa%+SHEBNEZOc(o#p#=PR5B=
zxA$&4c<)QrvTvsgN?z|>y!Yi^gxO0rv{W<&Byl=+Xsy(#SCnA78X&gnkifhfZ}Ruv
zJ9pk+&i2jp%XRr2nI3-6KIKl2J)LuTcG(?S>$_)=ow$1UzLR#pkJ=QTJdfl=#@+d;
z(;}=d?`~f9K6m;3T9|ik$X7$WBlrE<CFAr&i)FqWCV59c?5R(=eR-YlrhB<(_gX!<
zt&8T@^5y01zV~kX@B967hEcOITk^-RALf3aIb*?@L&o}hzig=e$Y8B=!!0N6?cPZz
ztS@hOkG*%=_WqvAz>rW;2aaQgEsPoKm@dY&C`)=r981tWTFkm*UFwqL^IPq{N0(J^
zs>-&le?Plmxt!urquiEBQTKV0mG@fju*&;(d*Anas}|^nDsmj3pKbR&>`&pjDt*kD
z*lBjUa{FYnZ~ZFUXID7$Y93oYNysz1#<1t)>}vN((P#HRQT`%ur26xxy8e%iC;CD2
zLL5@!FD}SxtG-LTZJQf?q5fmgrq~<rUcPReb~~Wo;CSwtbGp*ZyR{wHeB!cupO)Tj
z<M&zGStf$3pRLC%$KrOfvc!pVmUE6uORSOEsdF@~YC%U=SCf+FGNG{aSzHk-GL)1S
zL4>rlI679W0C9T^&Kx#o<}o<4QuOol=f&FVb{&y9B5^6=a<-IkeL{5A-n;kSEY;lJ
zvnRFUlvQw_&ZDA;8JW!{mjo1fB+G8xmISvsLR~_k^O3Bxb7yXUvt*L?<A8}ZVacgp
zfy+Xcy5+8&ac0IwjpU$fT~jwT9lLQOa-m96uh$gcUvIbFU?^M1tIohD6{uORWc6sW
zcU0zVRkz8hW-gcOO{SU53ig<p?Q!b1x96lJZ-b<3i>`HT30q{~(>dGC>}b#}ja8{(
z8D_c5Zn`E+UA9)`aFS?GcI2X~y0f}WGu)zXnQaVFxR{)wq_E~_dvsu5qJfvwn$0>Z
zj)h1^Yi{*ja?8(Xwr<~csY$s?&h8<%9v9`RoLikP<<on$AYE;eYyI4!t=DCXrM9h!
zNmV*_I(K!n*S1yHWpAF|y+L%#l(HK+X02M8fqpEdA*+Hu1bK@76Pe_i=#}V|)M4l%
zu~;NC&{s>dQ9|$sV{P{R{$um>=7-O3-~aIC^AiWA-Fv|2S$8a3+UZ(tK*A+q$!Yt%
zzGkd9bvES`+x`6h{m0Ly$lmj=?_RaO?AO%Qk0MW2@=R9Cubw&2<e}c@^Co&ld&ESR
zDlU>Zl5xz2p;Grr=)2oHf}Dg^&YXz$na!re)w3$MNr|gx-R5SAro~zvt2$OMPB`Ki
zIMsK93ycgDWR0C_<kl=Gx@nQtBCTaNloVE+0+TB`n%-42+C{C36F;?}zh;%^`&Hf^
zoKY)QrYd<099XCu!kMAfndP$Zs9?BKsKJs&3Cf~EqCYML@m+et5LCNp%I~8Bzn=!h
zaaA1fF?PvlQdV+NIW;q}O=(l8&nmBExidM7RwhYAnHo=3Vl=H^6X~{XVYb=KB`zlg
zrkUj|Na`?Jv9e-?R(51>tFh#&Z601LJGN@)Ms0|?9h_un#&C^y+wDx=MMCl#T0QrY
z+3tQzzy1FAzyI4Wmwv5{55JPXFXtI!uh}${wxhYPzL!_NdzTjMT~-ujnxB>~rDt5F
z8<B7#lf!0`kjL#kpO05QuWtfPzJfRZfe6Xjb%$26uU~)s`t|*c&adL$lt1-(QkQ?f
zw)_UKW={A9caEMM9wC+OYo4-~d3Uc`_jytSvsun$-EEP%DzJ{g3>D5MhY70RLcSd_
z)40)g)zhYW@4edE>5KVQOloc4?Y_awvhAzKL&4t0rU3K$>OG*C?q0R-oEP7!-IhkT
zQ()#yP-A3iRPeZMd_(R=jx=x6zZHxB{HwRmH(R^<^VXkr@zbAvz5DUw$B$d<uC1PS
zXR{&a7O{Kl%gc9bdgVUWmy9#@3hpy2d9u;qGF#>n1t$UJA`edvXf6er3)-soIhT3W
ze#6PK_vI$F2{Ua?natQG$&?*5Iq<$5hw4gje^6qwV}|7P1JjvBCpTnpGOKOdI$1G8
zSWWGAcJlM@)epnuH!3cEdG~rX<AQ1TR?0MVT>Ds=X^@+`U01ZUk!AWpCPs^THuK)C
z(C*N=yUI-t6F?oK@)S^Sh*O-S+~b`POCyvkzcjS2t7`+p4etN;Z46D-_t!svrE&P9
z;^HsUcfC(A5xRX<d4gc?LN`aA<lH77Z;7@82XeO=Fstqjcyc@7bJ@Fh@56uX`1;zW
zaj`L5&tbOPyszKgt-pI~LiM^AJePez876bttR<5JZkgA9e|`|;8fgFPc^+C{t-IYK
zR`w9gt&OVR8NWNVEm)9#Cx7DS(A;Tvw&Wgb)ZIM4{o#+QeWrIW`(*ApBed<Vu*qeQ
zj5b55%w;Q|&#PV>_xt_!mGv&3E-Iko(?DB9g%oG!&fIo$cJ(UeUq5T@u3vus^1t1@
z`SyQ5{QFzC_v0V?&cFYEzyJFE&-(k{+F$<7TFt7pM$<{hw46P+obh70$Lr}Ojmo?t
zt7Srh)`SGDTD3-UJ1CkKDJg1ZToeFpJna=&s^xO(RM0vVPAN0PZ8wh9Uzq-Dkx5$J
z|MPbPx8Ba^zM;I$JLQQ^>ytAlPoA;9w`xsjXw13q6HhJp6!(2^Xqo38z6J&X=7!vD
zKX_Jc2wHW}YqhAzYIZP#RcqC%H6cN33In}1270YpwLkJf?dRv`R~d%KmR_69P<DIw
z?p>M7W`WQG)u7zm-B}Sa>*{wM47(L}cYS%8K-(<ad|#6bLMzRd-QB9A7ap6*n!Df_
zQ!aDD+HHI9UJ_`Vl^=OB>fYQH%iepPQVaHSHFEOgocH<e`#L7jb-XSv4#$qoP~(vh
z)yb~jc4foP*wQ7Uy$g;p<**%$&aK|PM3GlLI9@foCOFXNUbo8$XOB4(COOv|Ii9cn
z01723B_*M0y@LFU1Fl@jzHhhp!{xo7E1vXJ+_^2CV|F-4No$cllf%Td`*(J6oiv(t
zg8Amj40*j%e;61V7T<0-dVqmJvw?v@nfc4_0}S#G3?>X3Y+FotMY1&m7#+7Mc?b%*
zEaYei)mW<P<*G7Kh;xI4l0s8QphNvNrjVdzx4b4UU|blmDuZzqm#c>ZN2tqHHjNOM
z7S}*em2C&KCNMCFtY88)ETPy=o|!)}=`@eP&A#Ks@-YPhac`bCY|Gskb$CMo=j(M>
zA22YOFgtp21u%&7HcoFp@Pjq(md1+E+{UnD3Rz!mWULrO9TsR`e7DD}euCip9ei;T
z-x&@u%P>fsIP{vM?F`%UWmhgubzH!ZR2k$Ia^k`Pq1ji1LzXRTU~5!g<r(;Ds)+<=
zi>8TZ5Cel&mS-s2g)1f}{>pcMsoOs9>Zx;EPd#66yL#%}?Dn{-Z&u(%1y)v{uW!7#
z4zVg>?!|TKo7Y*#ec^+xQ<!&d$J;8~=}*`g_3Pie?F1<($)5STV`_O!+05&*%Sw-D
zmX+<jwzn-g?{#cja?-7JuVdSimVtSYg$zl{lGDD&l<kF2=Gx9JycYGwSkze5Sh_sw
zO?2qHtvAxN(##-~RvHMJ<(D4MzSmo9y*TFFi|fWWugj*ct3PZQY#3~~y>uN&2(m0f
zD&tH@TEonxEt6S%W=Z(uv>ZJhJ7@J~X&*H$pO6_h-DV{FuJuOdcwKw8%Os^&QrXSq
zvUvNP^}Y`u6wfl-x$!Vo=2_{O8xPNgFZ=Mp@~m`y%#CNg>vD?SuA5md&IYfVn76%X
zm*)X~=(>rGXQg9qz6LFnVEFJ{`*KBv3{1U6@zj@lZ1|A1!WLYluf4NwQUNo_CYb6f
z$np!=s*K2Jt6LvW3Mtg@vQ)jw3|7t_y)#zj0pGe!1<Yr1x4L!5Z3Zvcfax&FEruA&
zaO2w5%0<`Le8TQZGhVS>k(P_Dd#js7y-eA%Wm5q(Au}*AUN0!U!@zKHb@bH0+!d>O
z7Yl3EcXV`%>4aVJ)fLl;(z$dh)s$(<rfjuMSrXGgBD!MTu3am-#WFKCt}rxOoN?*2
z+eJa4wL-dr8Qm^XN-H)lNnPxin_+0QI5{v{tn0>>C@mefEm7LZxl$lT?xK?`R&0;}
zBavxGb8;75;P#rb(rd~}XQ5tI#xUln>H9eut?M~lbUc=7I(jvGZRrxu?cLZpjlpnZ
zZ?4<oWU1bbD{kCQxYfJWX{xlum7Jw+i<5I3y-r1}xY(&>HY=AQH)PupkW(&-b=-FA
z@l089>)7IKiDfq<*3O!(E$KVOo69$8(V`>KZi}<UE_QVb=89eP+!&aoyJ*popr~V)
zl_t$LT~e>2x@B`tnAEngu#}5yrA!yQZOPcy)oq;6z|p19oY270bGGBwq{~W^rnIRF
zO<5qgFp8B+v~%I?w4MuR*Sals)6#8>^xZOJ*`bY*QLSbRLF{Qua~Bz%IMw5J<6_2&
zje!{}wsM`FqB(1`MrvB1?zT&*X{SWaMoux>tTj1zQ)c}{Pj9oEI@5fnU0Gx3xH|19
z+p;K;DbsH1W~?a=l<FvV-n`LxR<FB9(7Iyb;)PdUlv>H|xRRwDxZ+BdsZ@K3b*bB`
z7cSS~%aCTcT({O-tEQE<J9|R3wdKuoM^~+bE+M%cd$)7hF*C!BlZDQNZWYOyrE*zm
z(yV${>0FaVIoD>2Ou4k=qT0ztzLQ;M=SG@%uG*}$1ik`e$<igWRJQeqt~$n@?Z&mu
z)J;XJqdV8_*1^uH(qd;eZc{Q{)f*U{aO6~P@79$~OD21JN=Hug^i>H_N{W~<O-(f*
zDJe7(ygs8>SM8*B)|!cHGnI1_Hg5B&_e?O|Dt65z$y+*TwnNw|t=_f05|fVIx}uVm
z6R9yVb)%x9!dac$nMRj71=A*{N@V4nI&<k{mbd1#X;-2%j^y?lUCf*v>UQJS#*W)!
z*Oui<r37`Wd8bYGTyk3~+BhmuDLPl@)D6?LROY3uu4{HLyu49eORMz4solGUo;z<|
zc)dPq>jjjBDeKCDqkKZnmacQ0JLgT->fIYnZX7#iW|S1!b?c(r$wj_Knwm=jx1Cm+
zb}e<OkWR~{NoRGIY|aT=g|cA9$8(X_jf1%>4(4v$X2^D<Yc-o%NKUlTu^YYH7Jve2
z+m>9l)SPQmJT}#P+*DI-);9CZbm?5C+R~7<C3l;)XUB%zZJ=Pdvg|^1mPwMg*k;{`
zX_r-&9i7xE=BTSX>C(-Os?y-)EGILKJ>8B>$zAN(aWT{ET94a}%erEdZY>tvrkm|^
z%jCo)ote6`+$L_*oOP*X$?cR|$F?mFy<TD!%b6Qqo|d$AO?}{|jLAv8CW~^mT|0K|
z81L4_tXti<b6lf3Zbu!vl(SIhW>?y&W7@f^wjElz+0-av?b6ML5jUMhXM1j#EV<^?
zrfB0#<IJ!$uO3z3*|J$T4a25M7^IzDESj0v%$Bp-cgxz;HXg}f=`hG@n%R+JIoc`C
z%5H0C25Q_^*lg+|wlrBg?NIO5g_9#UY~)$EVd93xxikOvOlRj~+*)tmVa}cKa^u(D
zU1_FS7kk~b&fHEGOu8-Fb!&G1QnMdN1e%@r6$-Z9cJ4D+oRxm@=BlK$g)`J{U5vUd
zvCVYjBAw_YrK4-2)=!LnEO4Ri!sq6eGp)O|L$B&?S8>tpTAZlnsk!OuvEv-IFY{wh
z?JkwN9kp5Mu!z~Mt*mLsbXP3WsSi84?WfrNuz-FGK9l<j=dF7?Q&X4aUeoqm9n2~5
zD>!+Dh-<!Sx7aFk%e%LXvQ;-aZd`KB7nxkWd#l*VoG^`)%~?myypuNRF1Z@h)e|kY
z$jl@=ZOP?eB~7)cj*XEYI(pn?ZWMC(ZWr8kG@&XtI_%9QPo*RElU$8OXQpfpGK!8k
zx;o<Os-95kj2qWXE^g`y4ybTaoOmv`Pod?>&1u_=)Dpdv#Eu4TR#oZFoOSitjZJRb
zcHNlGnytAuCpmPRZrCxC<cy<R&gMo&i^vHsGIO`^xbaAqog=*?Q}WSm@7$(Vp|g83
zTnf`xxxBg?_vuC1j)YAM@7D9(akJiTz3_I|+09}H)wDf3u8D42BUC)+o8jWL($%@M
zL$w*!Iy!B1m~g9i(?&-(m7IX|NipwEosPP8+_mV;!fD%XycS(@b!AI0!y@hI*;%H^
z8H-DmltWG|>Xr_R)=Zt$VBjjunBh4kW$LuRDci!5&az4->rR{EyXAHy+q7-U^^uY}
z!aCDZBE&A8aCv;Twn!z)NHJ%Y>V}EBn>-Z-g*;Ve1znisF)<rM^xBy-XU;aW@kmFV
zUGHnOFJ{i2WI>(VYCR#Rg?XF2BDZ;Qo!Mw`LuKjIo+*l3Kw_tLrM!5<^`^~vlhHF-
zb+(e(WYu2b`jnYE85`cc2~OFjEpk)0>nP8(+=yi-bBZ(;DZ998d3lDM&NdFu-FkKD
z4ndU}%wWXisTwwOa$eUd4R5uVH!K(Pop^M2?#*rKnqgZyWOvT(d68-yxY{!!+vt|E
z?3V0okG$w|>$MlQ1Vo8NL~IPXrMfC((==nQMTSdtb~PIsXn89pam`&ErkkAAopGz{
z*o|8nH;%e(oE)(xW5veaZr9af*DfaKMoX-Y@STyA7MeEwsUYLJ`k6B$Ch%Q5r&Gpv
z(q+Y#J4+logml_1^A0c5md?G>_Uzn4)7d-TWL@jhwmKGUvf7j@^ymsMAD514jY)xu
zi96Jaa&z7k?i5j-+HIB*YHAX3aaG!-NNo{sjv%R|V-s~;8hd+|ge=O5*cf5BaY|R$
z$xbt!X&SfP%r3gEGF&UV=tli2Ev;VFp2I<IL1(W>HcWFmBE4<rnw+Ff+t#f0S+wn@
z!<FP|$6jX{PdLfDW#($>Wm>tquDW5nZn2s9v~JpVQfK4cOpUN7H*akAmD)6mORbr8
zs!&p*&`POkZX6v--N_=4Oro^6T`lU3xayg;R?Y3~fyY9}%<eMktlXWVVdm80P=6>P
zJ}G~q>&tZ^N!zmSCUqrm30Pw)d3L+j-VT+7-CCwu59NZ6_)4a&T5Xfu>!rCOOykzJ
z)2>{H!<eR|F--~cj8yP&REW8C^_@~r__lYu-Z4j)uFTC<;mEDnsB$W7a<tddO$!B*
z48mKcB<<Z?a67!5@pR5s?X=TLUAYUlw>_>e=w-=p+hCMao0Vx6v|3~7gpgUsPG%gL
z6m=x%)|8`$Y7_USY|ANKam;j6$gD+X9oLp@ndZBl%j{@&UUFb}q}H^ofTg@@ldaNH
zleR6)PHN@dx#o6v;%ZZaU`e0bv-1>nSBE`iEI4*BSw?KaAtPg*$f+);&G;szuDQA{
zXYRJbocbx-E}p&3r>?YVU$V_?Dc@dYDIb#=nPyeDwpg0WOrG6!G;Jcs<glv?Pwsd!
z=T4ZmNr%gfCpVYeT#`0f$|sZO<;vXC7Ek6BWh`5|UFY$n!jsGH%$O|1X*N02a!#*0
z+a<GGDYMmXs$@=FxRCA1?c|x#YA0@cDk*1jc$#In3Hgeu)~{3%a#XvtIgD4VH!Gy@
zxLKyOu$xhmk=iBCCP!gO;Us0HgpLVHW|sub&T{s&^>p?w63W@Qjh7)KWm?dxDN80C
zJe@EtXU%QZ4c=zHn+_Z^?N*864h+fiP7Yn1>9A$uf;FzvQr>Q>xJ<=Ny}cL=TbD9O
z99x^HlI+bCZPdFdqF(6M#cif3x6C%Xbfqm|O^i5|GHaXCw5?OM#d>q1oO5T*;4w9j
zxV2!#;s_I|Ym>E(C<S!6tU96;uw|v_;%t#wy(Y)B1G{rVW|=KC$=y0tF^EZ-b&)9>
z_kq$&b4u@C&y8VVxN*K*yj<wcBhIZo?;cr7J=C{)y!E}?4#%Dkk{X8fvjZ3yH_m&f
z_fB=^5#emfyGM#l4>|jmyX|o7eO(lIw>^8S(7X1$*~+_%cggO!oVs8#o9|L(E6vrx
zSywXDWm9u+=jVC)9GP-p5~o?j(J<#z+s;h86}l~D<Cf?!-PO`!Hx>uFCP!`Dw#{&>
zOW21!FTSft-F^2WIbr7o-MM#pX2;cw&lOa-R$gMbA?AhHxp!^;LJ23gtjv9NH|y(+
zurr|sp~fNyeQx;1i3+kVxZ=jAwqQkvF54o5Qm-3#4Og}mwCOHOkJ@be?tR(WJ(aiF
z-2%2nM^0GpDtXy$M&xA+_4J&zT0ObhI~Cr2_j_NxyztG;ytjADdP=x%Zs{ra`Fvh?
za($NR<eRrwPcu7xODAI!*Ur25s(0r;J(_(_raC(1#sb^RHqSd#Iwf^3xo%tN9F}$I
zeD?PA$T{D>oH}dxc+Tx}Ut?qDRLEJp5!|}%YNMgBTH37HnVGA?qVw~4B#tq&-C|~7
zb(3(D$V$`<lgL?cS>&Q)606FUkcdSYfo5!`YA4Rt_b&Byb?u4>G?O~EI4CL6)F4+{
zXy&49w%&v-IjIV3W=z^J+f`~&Z*oYKsoP2EjBULkxvpYeI#Fg?%E3mK-oag2nthuC
zcjdg?G+RVAahK$U#j<JH(OjjQb);7;I(9na?3Jvb-pdwVE~cVeHAA-f22Sbnk<?hM
zZC&cKXmd|qeQS<vc?_pPlG&zpE2B28yR~s!o=V52jZ+R8a?FY{(`EBC+b}8F!*i98
z%aXtzw`M6rmt=|FwTs<$7hJt^ZrkGAg@+6m9(e4VbJZ<qYp~~}lL8M}3q?Z?x-FW;
z<=L=ArDyF{*0o(qW*OVU%u`r|7CrD)&^g6y)ZHqQyzF+*woCO#eP`}mGE-%?RED>Q
z)akU%kv+4zle1N4v4tJ>RPt3+^SG2N;BnH-BU2?OzbB{QM~BnYDN{Amey)|4WaCV5
zG}}1AMd(1Yw8W`X#-0HZKHQsSRWzrZ^<A+rGIB{;XQpqKX<+J>Yi`UQTLM=HDuo5-
z<lJ_+)sPvoX3-|KwX4hO724J|M{m2Gw_9pM(#<1EnZlu=Lb?-tLsqpob{veIapP)k
z=!$bvx07ef2zH#f$#GHII!~tHv02N}EyvBaom_TA=k6B8H1n{KrDvN2wz(K?aAMu0
zIHO0RNAzablS2&~b4^y>J-aP6Ozd{<)m+De3kpsYC$yXs+~H#yrs=h;Ij~+r)NE<m
z)X244cb6@>rYjwoapOw1Sa)*Znke0zDG`e{u2`ijEpbgrDbt9PE2LN0Rr7Y*soBMI
zcNWYvxw!Fb(6mXu+e?(S1dfVax4gId+V;8PmUr(gk1dv19$U<ikg|}CNp}%%GqcvD
zC2Q`KmVK5!`|QE1m%)X{^PVe)hs!42t&b`4T+*4Gt)}Ixwk4W1RdZ#euUFEH$sTu8
zns#X!7cWu*Eq^mvAP|zqA*n6qYc|s;<z$w(mZ#<<k*4TOX_d(t8&^iF<fd%OE?RNx
zy4#Vv*Oe~Lv2gZcbxUaMxN_-q>e404R4z<%U9xnR+q6TvQx<w%TXJQZ*B#}oyAmBn
zV)b4fvqR5h9NRQ?-Pt>L4u)#SJhNOGZK|ET<>l5?ZG)F>WjC))Gl^D>70tW5?d@Xe
zvUkiuJt^CbN_&^wELnFeDoV~=NbRChuH0?anL38tLcB_srYx713FhGAEY;cjOz&N@
zc)5$4Nv!d_iZ2nfDo<O=mRDb|=-FoT(UvvL=G~flpP4G#i?=(^)ZO;PTj;D>wpglB
z+r*{YUYlw<EM>iVxIEm<QmBbl+h|Je5^urDrrKNqw_LW(=*jHP-Ja7sP4?*n+nls>
zs*5K)UAA<^m7Jv^$1*#E`&Mt<_FCi7nVn@hv(A)+>l|8Z936ACCv#zM^y;ODJx?3A
z>ODO#d2ZUgX^*vvvo$A2Td#B8#CdJq%~f}GX56^7EZaCT?8WiiZMSvLN_2~voy^oY
z{&U-{>2swSH`c4FxJ>d?xpn{Q?CwZGl}TPfo+^`#4H%eK<pxcib<)dIDb!*6pKZ6h
zeKuwas(3OR8#%B{lFU`}n60cb$t*gj<65Rl&i1cn=Wa(#@^G3IrFP<^a7xM~-^nQ*
znVUS7-Fl^x45g#9#hh}}W<^a~;}e~^bY+%6gio}RN~f2ABTIdbGq=G+)5SikR-MUg
zjxZ72lGeMBBf{yX)C~s4`lYLG-7Z_5o%_H1-$g-zBqb#!g@Y2xppjHTHqeczJc3Pz
zARdyGfE!0g4`?}=i$q692WT-_l9Cd~K|#Tej*e!QgdP_cM+qe*LqS27gpQ6QF7=Lr
zO-djW**Fe@G#I#X9C2}RY%*|DQc|Mac!H*zL*3y5aR$`&P$vo`^dOw=BB9Iz@(Rdz
z-hZbz$}tL0zh1>8$~bp2?`Ns$3w#+lrYp-c#!rv0W|EnF;XW&TrJUAe>CZe&%6ii;
z1Te`?*QjPPoo-jn#L2vSqQrE@o2&{<f_l?$$T4b8e<R1pCAGs1d>!sV2~YqlgF*>3
zs1L%^f6Ft<O}6>W#dv*kVTRP?y3Y#rHz6nX@2~s+_wM!BQqZxFW&tgeT9i{c+)fEh
zDp8cyZ~_Z}H(P>El+eDve}2`A)gDelo4jk^SAM-1Hlal|Wm?k(F7|Sv-_!5y(z+zj
zvS!kSC`N~Oj{>+rWPH)@>#k8w0#heNaXV<p-tl4tlb^OQO?T*H6lHhN<cQn;`RDY7
zM$8)dlYLDtKjyE#_r>kq>%;AQd<}cw*ZhLoSF^9SBy>S}p|;BQ<9o0O-upg3Ry0HQ
zj@L=ukMHfEF1fD{7kpoR_qFuy^_FMOJb1x<6Ex2-dHP2MMmaYr@RS2cVD{X1Uwf}E
zQRIwN-S-`C2a-pB-~0S}(ON|guZF$vtM?|Cmp(k)&h8L**5tAeXz`>*+Wp(>-+zC<
z?=r;4(eJCzuj|^<qNuI1{q*zeu2JmeLYus6un9seX}o)6&7}KsP)knge){?KVi-iQ
z`X1Q(<!ir2*Mr=xZl4Hu^4;t0d@{0()%W2s0(a<1-S2xrHiIGn>YTk*U-zxfe?0kO
zm2`}8+1>5Ax6AHsue<#D^C!?LoG-2SX|OWy?sQ&W?l;%UMSd?V(2>G7sJ!Im<s~1g
z@9omMV7+7NB(TBVyFSl3bB?cJFElu_Cts`*sh7^)dh2c3?$~u#zVCI=<Zz1Dejh8E
z$>9{{nZFkiOJL8TguCnG)AwSg@0s+k{xs;iIM7blP#E~S>Ez%4J973suedbldBvqY
z&v#s6zhp1_u5gix-QB~zg32Fv&&lXyetXB_V!e?5?Hz?)O3shVEiMWQ$>%*h=Bc**
z_50m7Ci#ZH-}m~)B;VZM?{|H>s51Qp3j%#&RQqRkh5zoEKm*1Gk*WLFMsu)fJ}W79
z{k`|jmv;$bzFTV#-kv?(Zuh>~pR*Gg8XF~+pLua-@4a_bOAiH@Yi&Gv;<V3MMcKDu
z^_G@1BTLR)V&A)6kEurItY?*uf9mP(c^elir|V9*cjHV-S<wx??|GV4$5!?9ySXp0
zy}N@ieI18=y7{izyLYh%EYZ|jwW4dq6i%*yGi!f;y!>z1yVtwdJpnIQQn+g$73t!4
ztmk;`w#myT3D@0@D4UyVQ~R#6*7p9vSgkMry6V5IzWhi2!NbF~&$E7i-}l|-SM`4G
zsm~u)#_SLMwK(C1LF)lk*WgQ>9{NkgCNO;Iy2PdY{`TIxckkYX55R*Nrqw5P(Zv`T
z?A|<Ea`~K3$AP<_CoA1K^1bZ+oSC9$qGzlt@m#ukH@~Iv-Fh|Ub3R|(ite8MJlR(4
znfl&5-OrP4!D`CObiYrY%v}+eb?3dM@u`y?pC{WaGFp4*zNPUg-824GccPzLb{@Xj
zUd*3<zqUPO=b8J}Z<*rs#ly>fe~?&|z|0{2`S-uNcYl9*=PqE_xwq=;%U-kF`Dd5>
ztE-rO{K>7~YRR3??CZ^L=bxWnF8+R(-<fw^=HK_e&s_d$@sg6=v2Vj==Jf2BoZoY!
z_VM?R;3%AVamO;B<HDI~@5&iie?6<cRPHMM^wj#<iy!^ky)~w&$mma6opILosq;fi
zPo6n-+UKnK)aX<1Zclfgvvc|>x$dh|Z=Xp`n>i~#&mcA3=dAVJEtYfYr>4(3{(Nd$
zXh~AAa^6PGiJwm{pOE)L)@j0m-S@r+mzTTn&97}s4gANzz`*|W<Lmde?<#ly=9^eF
zzc29A!+ZHgPo8_c6xaNCxY^JA{q&Q|dWtvs6s~#ly0B>Cj(zb8IT0I8KJHhw+YVX`
z363Zz!L|3vw0G|s80w*X1_lPERjXF*n|9KEuJy-exmF+XOn#s8=@u7cKK6ZjF2(*r
z!_HdbJ6~Gi<hS#z=bW)P$$spZb-S^}NycyIz<lO!=QMYoIo##>apUoVXX%ps+bZ4_
z8$4EosypFOySeYVF`touea@rVbIw>SX+QLD+h3X7U$<Z9@9#(!Il#uC049~P{t0lL
zKl5T|@AL|FM%DViCs=rxB|lr~<(KcC*ImNU*pO^%yn5!n_XS-qX2%zlJ$rh7-TQU-
z`58a~zBQ((*l5$snalQQJa`(JIdge+UX;z#Gdt{+<hnY(MW)WWzwLY4bF+K>{B`-e
zOU_-~{-omE_guboJ=WI}Mut77KF*A@y}QNon994~LNZDIckFWNLsRB$%1ycDvvRui
zJ+<4r4_Ik({Yk&*mYNX1fPsPWPu%x=zwdnd`Tk>dnc|-dHtNalau@b?K7Vsqa^3CR
z1_s8;_w{kVcRoK~AHLnT`d8zdy&LCLJAG51znLe^{_Oo7)>7rR$8|5OF&XVNmZ^+;
zJniLVK9iGe4kz1BM|TSy`<PT8sFS(%$+g@)h?s(~^mp_*Wbj_IE!ECT?ej8Wy=Ggz
zE$^asTH0~7UdGb?xVN*nc&^-^m%1rBmw|!9fV+Chn{zJ~*XAw~Xi>=B_v}UL0>-_?
z)=S=XnV+5-8sc{QUA}hii5teU{pIY6Y+K*Gk*<1uLe7DS-|O1XEthjmF8gk~?d$jM
z!SsoKOp5ikSI(TcJ>ks3ZEc5(jiZzEqf1qD&zw0ubK-VYkl>+bY1@w7+x9)@?xL`#
z+d89-jg5<q%%0piBb||>mzJHA`#Qhu>@C&2=#0tHw`cC0cH4nLF!v0Yb`of1W8H4N
z%kRvabLY0bXggr`-Sg($nKw4C-Qwir<m7O>_UuvV`XF;>T?X@Ysb}6z-fV4Iv~y+&
zgV~*PFRcwfpNm-)sx?tMf9H<HS#F=U-RV6l9c0FHe8y+l-mR;{c+Evz<ZQB|v%}Ul
zAMf2;@$vcun+BH22W%SnRkv=t`D4N)Cnrw^rp~hOp6U#2-%E^{mp!_<d+xi~ib)O(
z=DQcpkTn-Od*^+9(d#3V7#R27<vH+j$9B1rNd*k~<<16HdAhTAo;*2G&wIU)2LpTV
zOpPR_Uu&M-etpeTgYkIG6hp?^u;ScLtEUFKiiC1F3G8@tX2+dnX%e@j1y+6awgj!6
zpIyN)$@PxAf(aW)<H_v}oGP(LikKbpSDnk<1Cr!gwTiL6zOH)5ZRWe@ZdvQyoBq;x
zcJ4Na9ZR2IcpP_hSN40b``E?jJNH(Ly<ETdG{`+NakYG=Z=(CHJS`X=eST56KIyLM
zr<pR|d*<C^P?;Eo(@sW)(9i(x-=FUuyCL_k?BdO`FJJ44a%?D?#^S55rWNOIyIos#
zQkB7a+fI!O;#bqn?#FHNbl`it&dY@LYvkGOr`CnKiUfuzayY%aIy1Q_bcWl78|LAw
zBF}ESo%`hW0hUR6k1QGM7nom7H@oM%hrv_no$>@JW>C03xxZg)0XTTzp~GCYHwd)2
zH(w3p#d5(Dyo~!+TW<T5`+&()yilg$g7mA+v-A6Ff1*0|LXI@lsg-6Q7*)EB{FtlW
zZoBw7cSrOAmPtA%E$Vr<=WgqtoqGsmY?|kR+}*ibpG{$y<T_K8Irnz%qU=4FKYQ=q
z<!Qn2T6=-hyEoC{*|{(Gs!T!WGE8z{cp9>Hmyn0s>D?-`rK9e8gH|N(TwhfnoA>U8
zvFwtCUF&+c-}!ZpdF|c1Y{^@u7=~Wl_IrMP<bl%NyEi0iNawwKVREzYPM?!`Kx=2n
zF0<RY+qZ8zsmgcvwtL|Pi0a)slLFq}-BK>g=`0#6oxd9*t$TKoFZb?kz2=3Nl_&IG
zQA`Te>)m!c_bMoE6n<Si*~$}IlDjW_&7=S({<ShQ0*;2e-F{kiQk5}c1=FhfzQ5lk
z><S8-=kDuC_k8esYG~+xNB)P-FY6s@*;+*w@7}}zxP10+hWFLyz6;u{PgtKO*R*p+
zv7v2fct4vfL(9UO)k-NlHE(G03U#@c*PhG!&G&uJ`$FEgJ3hYOn)T^}<jhUJckf<~
zir&3@_wHr;tK4tj-JN&$_V%S;+UGo$IA&g-ckGq}7o$dwQ$ql!b5a3#6H%GjB?b^r
zgsH(xT3`nkqlWCAxCaY_+Ky<jGE6a3bkJZ~xRHy|LG{=X{Q{^$?_)>w868x4JD>1*
zo~YzLJzYOKcl)}#yUX6>x)<|ZDK>bPp0(;Fm$V4mQO#|ayx1E)t+IT3b4|S>$0329
z<f^Z)U*FF6-JJV+Z+z_sGY6FhPlg=Oi7AZWLrB=pF?lC=Ca7!>ia&bUz_?!7aI^fu
zEn+iz*G497+jMc6nsT<9Zsr7U(KWYIPDk|`C8Zpdb~8KK9VvA?+gRtawsDf_Y+<!y
zw=VNs)Co!I-Lg4xTefk|s<lzq>gzA2F{a7hiELn<!N5=oS>o!abAag#1B2Cdw#g0b
zyry#)O7nOXGMPOxH-gu`PC3%)y;JbI$TH=KYr1YalYCcgj!L_6<?K{3jj%-<gT0NS
zGn1mda-Gg9cuh{p^;~l+IOo(fQ{GwIe5G`^w5;89R&j~fC8G`A+K$>R?i+Z#PTkH8
zN;5mAl_8y^r4(Xn<~1W&tm)#Kqi!Z`i%q;bCN0ZK^GVd0)HZEPn{JrL)-7iuj;)>T
zn5A-5bG1g;m9%Z9+frPo&(vpBsb4rT=gQGFo~wmU&CXdhIoIvtHf^yrf!k7ogD(55
z?aJ|)&ARHMr>Vxx9L?;sYd2DSRdqLdtx;&YovpKBwp&-2#ze1Mr;Q@E&GIc4yAqhC
zH{Dd))TCv*%Zv%jGIM=Ydp#FMduOc4&Y8AYo9ou*EDhJqN;;dIM0ixRHfqge)d*7M
z^K<JB$c{~2n{jJ_!mTA!ZUnZng$AuQyK;8PvRr3PHA$VDbBw1a88BMb>qKw3B=N>)
z?aD1G7p5$|9?E98wmD4cdT>jZ#X_c}8CSW4ghQH>l8QYp<*Ip3%2aW=%{MD&w$<Yu
zH`C2!vtDN}-8u7S&crh>P9^7Ud)K$%>JihTTX(j0nQc~!=-PHGsAI{N6{aF79#?Lw
zuJu{Xc4ft>+?6Y4sclc$s9qG^Heo{jyK^Ud9ixqtF1v0vJJ%YvlF60Tkj15)FD>om
z6p^f(jXXCup1E=J?B>Lck0l#t|4244_K~=i5Evm4Am+jnI8ju^HQ?-QfwQxP&CGmm
z-25T%SN)~`hvpDd7jN!A`=?j``CeW=hrd>BedIOU^k~r!?5EaWyJ>gZdzDgT_@<yT
zuX>S3ya87^%WlPP+m&lN_50pWs~BJAu`r)nzjXKXQ!AKOt!k+9E+{W%e)#og^*y=0
zb>ZcETEMq7xSbN{ouUXEFaV7poNiH+h6>~?<hU9CeAVv#Z|}yI*fY+S_#<&+<F+$N
z5;J>eL`b&INH#H3lg`P%cDp|3MxHTG_Td~eVY9P6+l+YxXG<%DxX6F#XliomTENxT
z!Ib;cW1`yRT(t>CE}bT`GfieEc$}1S^SG2V*)VF8=j@D*2{V^WT*P#?Ej2YY>tYUX
z*UB72;oRQ+I&9|6<{L5+J33n2I+TnQ7n!vjQcLmOq-LZjoRDdpyKu|d7Uz1!ElM29
zX*yCF9UUIG(oUpgGzs)BWZ^i|+q><;vEyyl%mQ7kN>dhH=u~71Saaab))`SZA{1IO
z#Uf5BDV$W$QSw+U(5-0cyD_)htcgp**<s6Vvlg{&x{_>aM@|@}^$JYf?2s|rQ|DM(
zw3A@xqG+~T!fcrvmvovm`MBIPl1eq{nPxVP#VJfQ$%%<IP|<NhYKy>ZMGm8$<jie~
zMz_q4D7cE<Ou4OdadL3rMv1huiQ95dPMU6D%qUXNopU>*Nq07fZ`&=;oSYjKXJ^jx
zIlF4+W;GGlnXE2LLl-cp1!|gI+c<S|Qdh3h%+wWTM+3J6_Aa@&QdL_yaK+lF-l)xq
zVm!WE1hNxuxFm*#<ZgDIxoXumgPVJ|o!vP5ll=AQza^9Zn@r$;!~QL_R;A}!^{%RH
zzL&+;tf8_BeD&U&)VwFmR%Jf$K`zwYcDd;s**guO8|1!kpXHPJdawUJwiC=LjGGv4
zGUPOv6)@c3oxpa2Lz?Ag4%-Qyn+ekTkJs(mz0hX;@=ayIzt?yQhH!I#zx#fBD8sj3
ze(OsvWqtQta&7ek{;Bb+A9-{w6k`1nzGTUlDVnQ=Tv|K@0|U70@0ahpd-q=PoEJL;
z__g*;dlwIBE4<V_c=rtR?*5$h<$Cuf-LF2%u%Nt9gOy>4B4>3|LxA;;>EQ7w?>iz)
zjdzbM0Fyho7(JYXzOzD=E+{WdIRF{V0%@4SgicQXy@07+{vD&kpY_WxRR!1V3^*dF
z@UZFc?|Z+?%PY?nZ$H@gOu+9Mi_p9GReM(?`F-D2elNcI?)%Uh?pO9}rT%S+j?WSE
zU9c%=)~C4JyB#=HuD-WqU@pJCd-v*-53*J<tXj1|ZqgmuJ4XZ9s;c6v?|oYRQs?^~
zkc$u=sfYN4m0|Be2lyzPcf$ga7DfGn0MPJU1Bev!VP#k#!uJj|#MAAd!OFle0m(bl
zzf6kOo&PRE%YK5jdg5Q@)6@0WZoB>U_V&EHbCq}Ydpt`#b9k%kr4W;rOYXiZ3o7`v
z7SFpo>ySW?B1io(<Lm3=<8D{w&d!g0x9|4@a6QRzlVK91uH;nUox?Kiz@!772`c;R
zR=U<RET~z3`K7Jq{sR)8A)w&;_xFA6?%jKyTi$+fyqH71n2EEze9v>s_l%FcmVDp4
zeD6c&hJ9T&i|$_)yM9%zX;X%#w`VQ9fVx-zeee6K(>rTcHE69`!M<cWd$|GMJKODh
z-!oKIRYlgm7h!4u1(+s>Q``ek0H}gv6gg;w9%!&Cav&#!qmvmOKmpYS8pj0be)s4C
z7o!7%3OEQ=|Ef$oo&MQVb^6cjmtX4VO}Wn}<T6nMTf83@a<SgMyu5tgC)xMa_g4K7
zzv#YT;TI9j#X>GiJcS&&Y`<5(y?gh$<+;^NjPK*C?|ol78&=w$E?_VK6~Ev2zSr6}
z={zX?g1o}vBrtgg$Zeek0!$1JoOkNMDHoc4IT$&dgvyCXzgw6Z0zd(`KRfDnd506j
z1O^q(_OAz2IKf@edh6Z0cf8)cd-oEQcF(i}EG*NQ{0>aIAr!&D0E$t@hDr5|stuD4
zcrr}7!I0p|Fe$;zhwa<}22R~Zbq3x>6(&DWO9>=-L#Tjv+JQ+7H$m<FtqX*rbGIE(
zY4FV5wuQ-q1#B|o<_*%ijjF$Pw_dM)zxNl&<G-ThK2(M>e3^9Mb;{fH%+wA$&`@9q
z0|O(74h;=;5UmdlVcwk!x@Qoy0~qXl1_lQHr>k#C1$&1&*sS^$DW5m*!n^j8&%4}r
zr7vGLDdMc+vP;K(mux@PP#GHY?a75?2{(ZjWr<^k-P^vM-F&-t+rHaZKVzh0-3AU$
z9hSL`svA`HOYhouCtHR2fLv&8{acmU@qTw}mzg{7zI9br^$nxL+?CcQ3dM8YTb?T~
z4=t-M%a%B1(4q+5^S<Tw*__)|@5A>#VBk~`a$tZSY3HCa10H&(Kj*#5`(5f_!}v7(
z-X+hiU*2B7m0V)IcinA&-~26;a#iQuj(l4-&4azcX4Sg$dG%+LC5}Oy-%~c*cG=nO
z>%LasV*q781_n^O6_gMC7^Io}7&qMza*)<P_G<R}?V;cA*VUdY-o1PGy+fC8Y&yQN
z=+LvWtiDOVqsunAdv4ixDK}*TKSO0`?7YjfjtTZCa=3w}4Bnbm`!3Fpef9kw11~HJ
z>#@Zl^addJrE7jQ#Qc~Jz5(bCn;ruLqtA+PK?!O7z3(^3-n`1{v5oQKK@JaP9}ezF
zQAVMl4p$AX)2`Vrool$9y0lhtg|axTS``q$HHk^n#XH)uK~RG!RMF~EklzdzmDvmo
zrfW4WAO^bZc-t6cAJ36<woYKY``o|!{pNes&5!P^3S2jP<&39acYI%_(d6|FyoHpp
z<G{&dKR-11HfC#Gzt6ZwgMop4O62jg%g?aycvn$<uJ8i`1LNWMjNhJ~Z(m^N`n@kL
zIo&Mh+{2Ym4lNCmVpf~UAT;BuM#wS;HU~$><y%9ReD!5uT)3=1!1L9lu6dyhyiyqq
zP90vemfQ|9xwrtl7T$fUlrjT@71#2={~7;uwRAPCSj7C}u(t4z8`FiY8JiSR9-eO3
zHC>}=lyhjZ+Mx}%eKS{YdU5q;N!FWPre(2GyQUkmGm6){g4Uy-5520A;>j{miF@&+
z7>3Vo*TJj7ZNq~C*GER%=2krE6o{3XctAGqY02aUEAUe8(%n-p`7uCNhHqPa>XvD4
zbv0;}eKzzkz<K9(ye{XJxOUwl<LK5sy_LNZx2u*a8L2dROk}-yQg4CPx+T+=YcHvv
z!+5<sdXkFIu2bo1(<6PJTzaiJXI7??i@3Xr9^dX=?_l|lfq{W<dqL^l>jeyq*Hxuv
zPFk}zNSjf}rE|O6ja7+VtCk%W{qXJ6p5B`2?TzPP$Mv;auJ=BC;5pJ-cKC94+q}0W
z(+k*DK?~(!3)QRc-g>F`0J8Mm6nt#p#<i=S^{$VeE|ASAUeAz|C_8D&$xN>(=0!1G
zQ9&CGt_lhYN(+LHVv`o!nCz_+aZ5?bOgTyE253civW5t!&~5LuwV5s*o@N1_lTv1?
zc_*7PZS<WrbCb)qOGh@jscc!~a#`rM$1>AIpDbgMv`oWEX4|~OCP&@S2~|^zVBlt4
zlW}Akx5S#w84MfhBY2bDR5oT^+;;4?%B+*wQfHMswr%$C@bK{Fxw`F&wsDx5r_QBY
zQ9htWv97bc4hMuuZ8MCPTq3EKc8O<l*vTbF&Wg=8IV;h-DRb$f%f4ze7YlAPjr84`
zb}?sKRG?Dkq%)H}mt4wZ%gSAyWgK>MV$L)#$4r;b+$}3ib61!e)^{B?nVsZpHaW*T
zE%&u(SC}^2;=mPGKufDlMWwo<z$~+it7ojuo-G<(%(hxo;<o7On6;CZayo1QEqeEw
z((O@l$@9Rq-kfZ=Tc){--F;Q&@Mc^y+bXrdxOCgGFs^0Gl0AL0mMu$Mx`fBuJK1P<
zvUX0`nJnqR4VMmf*0ZIi9ScsH*&Cg<EOF_!8{P(1B3i9nA{qg6PwhOkZSJX^H?A$c
z%eOmPYG?0Gsb?lhx69Tgm#s^>wXtcdNJw&S##YI@ThC-1%{{vYvK&5F>|(Cy#uYD@
zOr97mx>(j^Qjykex5djQ`MD;U<d$rT@>bj7z~Xwnpy;L7)!8|(>$z^uSU5#wOH&ZX
zg=Q~hk4u-DUP@;gOGS2?O-nVC3dzvT4$N&jcH>g+v}xR;t5rf5Y|M^Wld?JO(xro$
zPGZvzE?v4|vXXbMn^e@)sXa#})~*iPl-inRYIbpT#DtEEYu8TBoEW6G&Ev2)x0j0N
z#GI&AuXoA3@q61lw?ysk-Oh9M?WLi+1WoUP&)S@Oab23A$(8i7b!nGw9Nm^{xGgGs
zCworTGu==L)4;%Pshy{s)MoW$8Ll{^6xr1yb)~rI&dVi}r`{BqvSr<N-??dlXN8;&
zFW$1q<=Wk%ld2c;R62#NH*G7*ygPOCWWP6S=d9V}<rP)DY?ANJ%k8muEw^<?*UvE9
zSsZrbnqk|O+ooYl7dl33XsG%6cAXL3tZ~$9%9e{8Gp;VqG+mr+q^UW{?PTso)ulpe
zGo}fdre)n`HPm(5oVHeCa!!=lu`Rc9lePw&S=*Yj($h4lEm(D<Z?~$D&SurwLa9rI
zlx}-YNn3L;GHRQy)YTrhn^6%ax1w|%7p<yaVj7TfbwbB&#YJ1qmM$?lv1Hk_N!MI%
z-JIy@nLANei&rZ--NYz&*{z6cI@7#$7prdD?2|b&Rm5lGYHg2`(@tG60<Fis){`5V
z*v!TqmYSKBoa^i>V#=7h+H5J)wp5q3n`Rp<al56oIwyBg(3WMnE3>6CM9y@aj+~`s
zl(j9b{#wr#$?Tj<l4^&PH4-Xv1f0xW`Gn0C4`&=#llL-v?BTg8C|lEMil!&i6p`Cm
zY16oF=Pa1Ub!H~-luJt%=}L8MoHE-<cjBkl!RwBBUMmth$(ho!%T-utk?T~>lc6`g
zMAU=~gjs@<woVM1vM|bP=C4qVAGeegdFQQ@FZob*=tX_mT{fL*t68Nzw6oSOos@p5
zE7*>ApT#BqMH_dX-gaxV@~$Q3jxKHDF>~+Cit_aGixv_~>-NkvTi<cj%lw#<k|H;|
z*Rcm-q75p6H<s{uh)hj-a5_bkVeOREv}M7f6SfE@=P0gmiP-vKp;zw54i_bk=;Uju
z+PQnR(>`wd+}u379(+yH-LOSHHLF6-g>7wG)hl%&a#l}R@5Zg&ZWq@?3rV{QX5IX<
zCaCvg$3-cdf;)<H&2DWw6~^y%?BlkX?8n(Tobos2?r>yVyJ>Z1b{mtoW5dLEhqpa1
zlieQKvT{q5*VPc!5F;;<thUx=6En7i9lN;VwsazIlG4ffULwnG*H0Eo)8I;2b1Lk1
z$=cb=vUPHGxK7>N{9G@{dbQ`aFAJ8Y-Sj$^@8~kATFTo~C_8n_w2liC6_tEvZ`dNG
zbXjMcjjhHMdE=;u+jAy)s+t<yI=O6ChA-!mNkLOUcthKlpKDEz^#%oGF>RCDWH#fL
z%B0zzS=^!<ZmyA3xfXOq%+u_Ko7#qy$&uax5w{a1W*wX)t?qa6&ZCQ3(Hh=DD<(%=
zne7?%knN~TNYX9dZkL>_gNrV?Esj{ZC9Ngk)TC)krY!PyG)cL5>{#e@H)lqL`ef^Z
zx8~9Xn^VmVWj8(Bwr%Iuu4_A$6hm&B7<;an<}oQ}(~V`P%$D8ixSe}8&_jrI+l<>Y
zR~oHOE4iY(WP|8(o>@C{jXYf!$0lm|d_3-&GRyC>xtDg?Sw%%bVVB6TXkDgLD=y4j
zHrscRl5SMg7L(k=wND>Ue5yNP)vA*-zpM$XKXoeLijbMN+M1~a#}4N9WSOnH+H>61
zWP8NgnY)5Tf>UPslse5=8_kuoI$~qSZDZGNw=JiZY!{p}Q{bl0*(qkrG`FrY+@^Fe
zv^T4F&1~(Y4T6RjbFZDwHhbi$WY%~{@^E3!-Q2BaXD<h*^!h9oI-<2?lE<=Bw=*TI
zf`euhXGPYB6rG)uaW{9XDR<&(fm65cn)N(R6J0mW(`|C@&TTs*Zch|!@={QW_WHUx
z=Hk|}CEGl#1kc{IJg1axw#~=sbmS2W-^|5EXETn5Ey*~!iA6cHQQC6zyUOjw9Wy$F
zPenMbTCKR)W!apwDW2Opat|5v-p;AbIx3ZuoGo_CYtpSFIrU+RUAapxNnh;UnX7Ya
z)09~noAN|A25t>E+^Vy1iRz{)M@4R`O}lzHX-m>JGqc`|8@CK6<*MbW-JBa3xi!l)
zI(NnGh^?ZzfxSsOyqkKLZrXO^ndO>uW{;b#B~Q+tR&=%J_JZTl!6CV#TNZdmOKr@Z
z9Bo%=ta3Y(XR_JkB;Rdc>$}b>dxUA5^eQv8O1X4&iDU{XrJeKL(z_&AdG^HPDvv!L
zPbvnTO1R+JO_gcaPPHm}E;^>;uEyMQMRQTs&1lb=YG;jdw>)^b!10*xl8LiSa+Q3P
zeK)(fByyy58Y}zU_VCD-ShZSFj5RdCGIvv?PgZWU*|Zzpn!UcOjWxnV>NRINYfhbX
z>S)TQnVXz0U0Bw;fo-d2$gEpFSzFVV<?0-Y+HiH&Y}S-xH?|oi=VWOb26}egI;yL|
z!?x9P>rxF<skTcuR2E#xk_h$|5xI0!I4mmba^S{nw_|IkDu^mDC){9;+M(LJ^^Dl<
zY32<K(vo+NFlW1!7c$;a?cMr}JNI<G^Z^Fmo_CKJH_pA|kgby9by8CB-Ql%XvODJ9
zC|&NnT{>;$0;R0%T+YoCAD@}YIgNeN=0w%RS+f(PbF$91=G=@}v@u#F;AlqH^@-aq
zid{V;we`d;(XQ;Y-iOI@n_1Hid6|VB^K?7Kwsxjl#;uEMR~(FLY0eI8Nm{Z>`q*ak
z=%o7DN!yN^9W~Q7)7%(wWW|w<oq?S>H@C-{ncF-oi;nbmaecS$y79gD>GL)pV7nHo
zJN51R!ku?w^}XlDp1t?Dc*m}c>b<dfx6JN(>$1&ycjo2h<;7)(i&!>$=jv_uJABUA
zsv>gghNpM)ZfD1s`8v$Gv%~C^%Tif3CWom>Y^t)%Y4vM!n|Q9>Ubs5%MPPJsSb){-
zqLj&I7ksx#9t`r5icHXqY|(UTQ@pw@;M%q<Aw!4mv@1!<Yx11)LRYTs+g6r);l$jG
z)e&x%#zJX2ic5}7yD{0wzvoQxBcEA{g1Q^OXopT@*|^%-TP5PyF-P8>CZ?XYw3!~O
z46|fg3{7`r=$x(3IJR*ME1S2dvFpq<m1!H-Hg<(NMW@`(b(GG#(9$%c$&Kr}<kswo
zTimu@TfLiw%|LVm+je0kr7X!!Q?(fwvZB3CC5sgqvgt_OV2)nRv~<(j9LsirlM|P<
z^%=?B$xG&xwzSN-@zCttl(pMDvcfbYrWH#Zag;b(5M}1|&eAui{;GL_tk(mn>%P3X
z2M=#f7F=*~O>*AtEg2UVyGpA~cI%bWmg=2!F+y9aH|OSJw_YieStc15Gj41FbF`&=
zrA#um<V0x;hAG|XT65F2TTI7QBx6yRsf4zu=prq{j*hNH*OXkHQ=E>txSWbg>Y1^K
zf#cTdpp!zJY8RC}F4e1eOjKId(xsVc)O$O3?E(!EqfM7yZ+Ype<F+<(YVXRKjw`b>
zZr3bxHTLOB5j4)5d-l1l?xblay%V2H&gtumJbUcnru3*Cd7GE*%zCzSec`jJovtFm
z>qPn9mM!Tm4&I$T^Ki>8v)<%PRW8Gx<nV&mv3E;3u9@{r-Pj;-DlDV5{#?oF9p~Ki
zo)x9O4*R+{@8Jm#4-d~}sn^4Tc|t=&gL$5Yh8y0EDKEA(%zJjuH*d=>Pp?Tcr39|c
zIVNKrxjghp%c~tTms~lrSv$w&(A2I}jZ<dcYPX)Q&FfGynQ}Wwi9uOFWXhCDuBNG+
zCQCOt1)0q9+L5*BXkIt>uBVGF3L5LT<eIg(CYuOosm^Mdb$fBAq}tr9JCl^WLQeAP
z2qv|zSai!<bvti!hOW_yV?9}hVZPZdQm+>rWYSomP~;lcDmK-1k?zK>-i=vYrcsNf
zlXN6j=dH_@oL#bXdpL7hYF?|sdC5mEw@;XEwpz7d%DnA<QvQ-B=2Znvt9*P^%qC=N
zy;{jLuJ7S;;&QeZrLSGdyPbD&lX528UCr590k<=SZYObWcJrOGELGd=l4^(I!dWs3
zkB>9lzCLgDRsHHyU;RbS%<7!cw&+^h*-2M}Qty`89Q!PN?)9E$&uyMtT*+N&Fe5qV
zVx-r!OS?)EPVMf_aZJ$ix|k{?5_Y3&rE-OHd#7|g&mF;S$pxDYJMP@RQ*34`am;X$
z*sM!wY8wRw1=pC(cAMq9ZmXrqEgw*y$fQe1rKdA#+a=An^TNOX`~Up!=G@!mCU@`t
z^XmW5tg^rhe1sGO!@s+ct95l@TaMQ{u&oYuFy=XIutuAKf#J@UWS?6-DVuVQ!|sYU
z)HAR!gx*}8XWGEP!jLz$Ozh3o?XC$7j11CCW81xUbC+e^?nQ9<rk07lUAA_e=>i5u
z(7ALgx9VzTWkqFsO`YVeGFxS;q3?z>**aUKxRpH9LQgX`UCMfH_S`&;*W29e=!xs*
zKD)PjJ-fXmYSG1vI~yb#7?h5%)X(BH5z1bB-O26NYj(Ah2~S(Kts|D^MXuho;MU1)
z%ZzU5<n~6Tc(x0qsxk#d1i36y;^N|p4twizb^WKPZ67x~J}GiJxyWtWp|x(;93Z`P
z2Zl4#Qd5=+sYIvTPHoDa5}Y2TyHQkdS9IPKskcj3q?+BH8XFd_Cmp$U1_O9KQ3Fr<
z`&$YeJD3*izY`MwR3y+<6ts>Pib1P(K}&eSD|EptW7(7xdISX}ngv{3K+98mz^i51
zz+xRuN(L@2NlFSG;6=Vo$}BE!N=h6c<sBUmDW$dXFJR|F2KG$vW?|BrUSPz`!X)B0
zec?(*(dkV3OuC*)+du<TAax?i62~--8TKGVL{D^dfL0nqSL8zM0Id)PITO4v7ixV+
zhmz7{j?Z>X*JGy_rZO2#=T~6lVkuG<WCPuC!l*jkH-JfV^4!l{(+%~Rw5E5<F>|u2
zMstQ8nr`FHtUEbCoZYfB>`>^2sW~9g!{CuVI1#9I!#A4;G?Co{CpyDUw<Lg8=k`cU
z_mN}Nl-u=sBUDy;r(j1jc%8KB4Uo4$!;;`-pOX(*vvCyq*ZqHdcmJg6&Hjv`g53AM
zSGc{ecz2C$Vhm%o31ls*CR5Gt>3RW-^3%-%808p$P7e)WY^$I6`MK<!AGzPFcdDzF
z-aTol>6UG}k~iCQC5Q%LbT)|3Gu`8Pxo1gVdC7E--(k0-pN6)6zHhx`m%H^Y?<Ixz
z%af!%oo;2WRpfH=e$74SlVi%lTmkFZ;$@0krsyu4bxB}}%G%a*l?s~zwt4r<6eqnq
zVm7IDivwR?*$Zchg}KHF>#8QWfV9loU82|%ux(cEb|<OK#+hxmcdv1qm5`SBJqmOt
z2xzq{XlZHw-gAL_pIeJeUmD10Qh#G9kCO}E+q9*M9-b*%mRPypp8*Z7o@9yhbDw^`
zH|eF^>iqKEOLm2{ZJl)mim&eOzk9rZ`_KP6@Cfq1*aOw~zVFMrf9$FbBv&AjqL=o0
zKiPNc{_#)$V&C@uZs<sDU{Ypdo4A32fuVka+5PSJ_pa}s@vPN>fq}{4cHQ6K*M9u$
zJ8-49fq{XgaogX0f8W;B98U;hTL`+QV}jZJ{dHgW*(Gn#WSU^gwE$!fqeAZb`}?cz
z%bWG3C@Iy)_87f;m%8-eQPac121m}EJ60BRZR^_d<7v-xo)ykXdueg!kIzG47x#3&
z^t^hDcNXu;o?A)G{%Dw;nj0<lYID|`?NSX4T;-Ct^9qk_jTX!3%-U#j+jn9{$EMJ<
zjZ#P6S;;W|lJR|C1NQm%z3;2<@K@jazVfD9Ym=j<S5Tvk_?`|2=J(YHYd`&dzc1-(
z?zTyuDu1RQ)O)Y>?%n1ec@KBwNw+<`^&@h7etG@uX?JwbullwAYW&n6Tn|<=IUHuH
zu6$otTC?yY*T4Oi^Fd(l*DopaC+1%aRY?4$W;EmM{3#3WAK_%~d&gVf{sZia(Aop+
zd*4?=*dQ|OHfSt=yX^x;mO6PyRw>uo$9LxL-Y*|B*<9Y?%X8zXRSI_xUfW($fAPCz
z+tv`jcY0fQFKahuKVCiSY9QM?J`k^%=^g*xH>Rr=l^2$-y=!7SL-q`R8vp&;ww0kS
z?;gFHx_i&}eUEDAySCQuo|zdLy?<iiqky_{`MJm67k}UPo+-7X>-U+(63m7Tocj(d
zuILr)IFfB2d3k&8?|bj6HZ$K$P79o_qp*{Gcd~EU>4|rb*m`Oo`6;jbipy@nuaC~B
zTHo$Gb~|_5^tup6m3nENLUEl;X{|zTl|oe}>!%-8o22)rbh0jgf6e*cp0`b3^j9P_
zz0TkEvpaO#El-t6ew+$*PsCX!c(QaZ-4t|FGiS;+$F|9QrL)8ze)v^q&%Q;Y{QS;q
z87kMmOgeY@%VfXHUnYN4F>s#|`*m0K?R$0~B_?^QG}%4<e!uq1PrF0sa`^9Be}8{}
zzZUqU&;5MwzVCexVehlvCD3A!;Cz4KyZ76pcQ3y<_x7x8zq@uDc+Xz@yq5jA>hT$Q
z39lV$Pw-UEp0Vpf`8CGsw%66$3+*<{n0V`Er)H<#>%C9r-8sO(e`@>F=uc~Z+&(pZ
zLMWqredWbCPnJeUM^8_0*&pBcUf+A|n#~6VAxGtMO+9Fmn%r~7<8Nqa;EB7>J{R4d
z_T%I3&=6m{xmS(6vR5o-ys!3eo<NUHe}A#rdX9`wcI^4nufLx!5h(YgsrJsk?X{Xm
zA`kxf`}_O*Q(#Z6TK(>U?fYsNr~cgo`|Q-l+Wy<g8*D8lKJ%Wr7JO%J<?I>Rn(TdU
zHiwH%r!;(5mrHvlb;{xI$)lFDXJk#9&rzee_-n|e(2!&X)1ORh7<)2~^<@4uUcGa!
z=-r>^UEY`53fa7~oMs|;$fDxywbN1@FJ-Lf9IkpFHM?tW%(l?iNqci&pFTIu^0Ca}
zdikBj?_QO9m(P7v%BASP@3Qss7Yq!H`{Rn<*Hk|*J{I%ZL~_Yb)9ow!Pv^c${-nB;
zTjk)-Yqzp3=9HI<e?LDTlm}37G$=oSrnhd_C*^LtB3|05_I%#<ZC_uuC+@9$+@82+
z^|f!`5^u11^2}EH<bAMSMNxH9qS~!JlU`~wM6KQWBl;uj?<<%4>KH#cZp~UYpQ}#$
z+Ro5$gP=b@KisY{yI=Tqx?fw`wR87NUW(nU+q|T7(>DKolY~4~zHfb5eND(;NWLxx
z63%P4-QRONr)t@gO}BG5-SjmP-SF;}+5NiiwVNg`+_+W;bm5?o@yhyj*D|la<f_&5
zUw)a5gT-Qh?fWi>ekl3(ho>1Rk7s$RT#E60m#OB-GwqR=P^6kr%3jrksI^-g%{&%$
z=mfe+AKwY~Hpu^bs^?s~oxACFu4UfS>d9v1P!P{{yQ*Z?>D+0jbGGO<g{W>XdQ@+{
zNp*?!#Jp>nDpn;{1?kVvL+yoAYZU#rsmw?!G~v$j)SC3jztq#nBV~I~z@(D~lT}}8
zGhNMH!y@pYdB#-t!w)~WxE$4(0ctL|xIaG;zP?cV`i`k@XRGhN+2-YvaMHkVrs%Rc
zw|=}84ZXa?y;8Jfv2p$G2fC-q&rhlaE!0<Vl74@Ge`shZG!j*_rRTbC)jqy!lXRI_
z;-oKA8>Xv0+ji@|%1@9_k8V+Qism_)@+|qxce@LdQq+tRt`;X>d*rDi;BQ?#TVc}k
zyhJ;mf(J)#vdqt&y)`|r&i3rt>A9Q1GR3L4b1oz|%hX#Kn$_ODV{q80z;oYov)XMH
zX1A|Qy%cV!c|+sj!Cs^6wMB80HX5odJj9`q>@&%I?$%ptx1RA-+2|rt@X*cWp{wX*
zmm}NrOHW6~&McYw#%tSkL#^8px%;Ap&-qRIGPSc)H9DJj+c%Y|x$Caxu1oS%jm}q_
zZx>zU*`Y4%a%A14`cJp#%uNfs^<>BA+3AIT2i^I2G7Deq*t_)Pj-y9QroJq!-BuM-
zd3JM~r|c1-qXL14TP1}HRTA4;9!#!1uibYmp?da~sk!TtLbq+WU9(Mn&Ro@(+QLF!
z+pbCHzVXz$9lPpw%#lf6+wS?=)ogn*S-?-Nvolup>2^!2GrPRLsYYkl&zPFK#_Yas
z=W}(>Dz76)CavAtcDq{0Yuoj#ZPyJ|Cav8**?+$7PL(6Vor{vfJu7q1`EAzDtq$3F
zJLbspgvIS_W-INsFWIY_l;r8$A`o!wit4%BiK}kMNKEov*roB%@vt&DguZTHcQ^O7
z(M#<cXpXHX$+cuSR&Uata?jiyljiPhyZu(DAn?$}eAP~s<#`qNCf<AYa&Nt=*p+E4
z%}?ImIh{X2kx#~0EvP`Tboa#Ao2R>Ohp&36y<MnyRgXoQs_EBl^Ijd@G0ES$diRFp
zpm5KK-0hhblN==iTqO$D%=KK<&DqRlIlJ06cT?8dt*>@@y*)B-R*ywNa@^c&r}E8o
zk4&nZ>?&cnQhUi7v)fzdcq()lEasCjsJHPG2~0FeWG*fbzI9u#D?4uWl67}HU#>XZ
z&Sv_odhNzAkeybO7PFbEmP~ECT{gK>MUYJ-@o*cffS*X9tAyd!y;l~m-EMixcY*EM
z+nw4|t|T6AVZEKReAmW2l}S5QW-RJa?=Mc=c6Z4mPZq~kiGqiXDGy!6gxv(p*O%%?
z*QZ|o^1b1Yz@MHjiQNs>Da-2iN7XH~u9WvxS2<rj&-%r}Zi5p66TYyroyZ6YI66bS
z>r+%P(-h0%+3(#P+V2VZeKELSwS`gRauo0OT36+JdnUS{y7#?2;4i0AmCF<X4)zI6
z92OS*djy&|EF9UVOx&?YWb)#U#mD<SbtVf;-nO^C>|j^0kaPC+9EqidYP%wr&GJl{
z(K2`I>uo$iGbTyL?M^tV*{N9ix{P<pGL_cr>uwl&C3)mly=@j*rqV_X*T4HDpW`&g
zi7&pCS<9}tX}tHjU!%v|uA;E1W*N-oy!Bgl#p($k-=?zp@>$W^d+$Zs`{e|mZd)Ya
z;-exc%qe;%TxZ%P@wIK6JF+b>h(@^BzUb|_o0{go&|0A&e?v$$Vyc3pqO{q`+-;Xm
z>Zs+UwB-opwg%+(ZvQyjxa@XhcGT5XY?J>wyt;e5K5U0c;}TwlOlIFOwrLkkj(8bm
zOC8%JWy~>alBd~`#TuP6w6oF{EHj#&btYj(=C)01w$2tZR=F`v%D2<tw#w;fwM%W2
zyriTgmqewCX-Qr3)LiMNyNPYf?L@Uhu1uNP$r@oA5z~@4iQLWI)Us{&j?JOHDjLTl
zcjZpqvN<3*+D&cJ)x~1Rt}fWPI^uSiZkV>j)`+cJ#LPmL1}tl96q*t=L1?AsHdF2C
z-f@iX^$i-FQA;|qT76iLga(%$x*l<HEsJq<$Yd`~kr^yau8a;-T>}mVr{~<3Hu!Ny
zTH3zZASY)=+L6P_3dXr>x80UZ4V>y0D(Vy}>Le;MJMH}a-))D#_MelVzrW5lENJtb
z@}K|y*B7ryzwwKG*3222XHR{7S^K6sP}+2Vo6T+8)ot|~BAN`mK6wc<X04iBe($@@
z_Ue1@DnFk-$WX(Z7x&!Z!$c>Rjv)W(o)Nk0n-}t}?z>&_-FI%(^LW_{%Y-F9KHe4j
zZQr};*420KZP}f7%}b(XcF^11A`3e_OLcE=o7ASLdIcgpJ?QT4OpPR=T<@~COF+_k
zw>Nr8v`nu@6Tcp}JJ~5{#^jvX?MYJ%In9>dF4J@tn4A^6^)e5y()NP0cS{a4d#rB|
z3I3LIJ9qv(#?5tUX=*t<CroY}+;nr>ZKGonCT6BRiQ6J>&fMIVbDPiXX3u7cvm2$;
zPUNH=u|LTgD$*Jt5WxSy!Il4oHK$2^o5`%m*(seuLS{izBb8ioTyh0&<<4fAab(-s
zwoBd;$^UQXoSkQupLR<kSJ>>Lu@aMTqM)#$K<73k6Q7oY25o{2F3Dm^DZXa6avYcS
zO645Nxt->0EXRB1W_RwklSxj|j=F1?O-fW2G?<;S*+(&Vn`-04wX@W2>x#`b+jKjk
zzHLFn3>V);CdrNynbgkQ7M!@yC?)5ZTbo(NvCE#5OfCs7$u&9Trs8tQ?IhbQla?7C
zE+-QgvFL77IkJsqw#mh99w!Y>N@uQ}rR2@%yK&>P8?$mIF4HkObT;gYT2kgj17Fv*
z3zywa0v$x&CT(ff;ko2Q%WR>{#BCP^mz~|D&|RNqoZ`E2c6v{4)~3r@mzHK{Gcd5N
zW?%@rc2hUQY<1dZ!_a8yM4zz3Ia{KZ9Me_1tT`pHCuFwIvSg{rLD6De)54-6w<H+*
zTwqpn*ycOww%NsP7X{faHZ!wuiH3TuTEW+_U{&3Le+Bc;73<%B|NY$ROTMj_t?zwa
z@T8U5^G^AKdJo2J`@V(7msd$NrZ0Sc@m{UYB;D<YR8}ooHO1wSqu?c#aKo5Q(H?Qz
zz}Rz+bL0`zInI%nTCKn=x8NnFbDX1PP8)L^H#&33@ZSrq6-)1b{Jwty7yASLYx5rn
z%wg5M{r&y^_=4K}n#R)!={GVJLxuSF{eHiTeS%R~eGf;I#srQyag~K8QLC2t<ySwi
zeXKHPrPA+743ikveqZW1-?CypKX>j1kvoao?l2z_d~%<^yriZ1&QB9iCRl3FG0#R;
z>vw#)chSC&mvXl|NgU<QTy`5WnBct~GCWasmm^t3ciE)3H`*=*Y@6ka5U$4*zkRFp
zwm@S~(B0l`ip&ywb1&!a5;&$2?Q3>>Ax~247BJW1-Sa1s^E=KgoavUz#$J1`_7}rn
z_ZOW`GQZ#NJ-6`X7ru9nGm>0|*4w_XUQo%bnsG=;V<Knlq?UtSDzW#z-}!X+ef7>~
zATQQ4EI%P29ke~Yy=9UISDwMGeS9re>-Rq1`@Z_f&8zE5Ki=gE=IDHU@Y4FN-%GY@
zzn4|r(xS;JaBXwcl(fxJ6QDFYd()xSrp!@ivz+0$DEtBc5fLsfwtqcl@<;3y?3#6&
zl|R`lOMbGpRZlqgeXbQNSIL~IOME9yy?Yj1e@vg4%&4f&MyQgo-MxEz{*CF4w#+iq
z8*G_nK?M8s7)d78>AaFm+yXA3TZ45|!0l%j-&MD#H>NNuPlj9*EIBzKLt^@Y>CD{q
z3X8flrV6Qux*6NPFJY)-_-*hfN#HPheSGbAtM)s`FW5YDoS(T`#ADy@_xoPR37m*B
z?Cery5^pKu5_afPmCLVwSDE*H@13vQ?>v}1n5H>Ah!i>w3)59UtOQ=|``-6`?|b3&
zu$|Wr2!M*t2QR~K{opL#zNch%j#ItFQQcj+8#$6iw!PFlrnqIwwwGl`6nlbhFWD{8
zb}8uglG|Wv>1}~lMb$}flB7Mo^CstjsLX|Bmpqci?ryu$V%Qa3ayv=jm}c(f+zw}n
zrQ3bCDOEnV-u+49k6S9w8l&DBOm{CZKColp??2MS@qwi>dh<M{`9XZ|977BR(<D}(
zuf7NN+9|D$MF9%DO)UqyR6(g_-^WRQ;n(j>V43*9aS7X%wI?4wRGB>eQ!1lsecskt
zSK6a)uJtmGT<guZ>e*I}vuR+gV|DFpR^TiMKFzh}3TP}3j5ANhmKXVX{b@7)$SQH=
zc6fQ&yZ?3d_RHt{*H7Pn_5Jhx*MHQNKMHvyY6Z{ba}~k4Jn~Yj#X>)g;4YCzt(J9u
zX$zj!XSo{(S<aex=8DW&k7rr##sS5qCP^zSXEo1UVX=xYZPDvhuUDM`4X2+m<~cDV
zO|mU<Mw;Z@ySrXIHYhe_HxAnM0z?J7X*G8(0kHy#O)H;(%9pF9M@;92#~7De?}}|p
zoGHw6*w8rG{z`E{jQOwcd*z<q`#$Hzx6t~tM>ls{@3_2U!aLL4Z=Y7J+Gl;O`rh@s
z$9GqLTD5A?s+YP&t5)sWdTx{Hsnx5OTsv8HQ+HF`Ht(D{0n0@+k8%|{Au-kzYa46J
zoH}#r_@Xyv`PJvXx!fqZSG?!d+939%sg@?zyJf605ARhxzI@@sdFwvE<fu5_&tGq?
zv1*xO%ONG@g-X%lTDw%Yuk>V|3GqKT5TL{iq%c|E_U@DP+~<{7c%~e-KKFUmmZ0@%
z4aT#N_axfhUDzM@Mf~#Z^Gg(F`18AKthy*@*s?UmcZqj++SPkMA)yBj!iff;P&Kc=
zofr9je%<FqlALY%)#p}ScG^3s^;}ND%a)qLZvCq2v)|`?I7|5Rd#zY?QL*Ka>V%1c
zVtUa^%jQ}k%<`BubLFg=E9Z4jxbwXF+=7&4lIP0jhAvqWca$OByxrI2;nf?-*Y~o1
zDWC7*)G<$Pw#KT91~U!?ZBo0Wy1IUI)|*KsFK&Cz4Uch-yjlv0wOC20^Zw6Rux7I6
znuSa6G&C9a>mN|y;IiGp6T`s3G=qVG$-we`1%Ivs1M>?m=7>-xK{hu}#vrGaW+z+)
zmSzjw4hfnR(lTLcsK(kEnJYQGG!`*w1a+-toaEu?z!l)NErm6d*SLOK6H}wYR2GMp
z&QJ}dz|syT(EZDxVO542eg}4E2N?ziei#2D>&Erle!qKT8lT6$=Iea94_W;A@$L=U
zw;2V&=ODAGv2H(n?$_@JHbq|;7}##jcz!Igt!9T{!4I%e3=HM>e%081c_713Vko=!
zap~i%V>xWgU!`1fU8SbRz%yGbIAjIG7e>v!AyYM<GB7jwhfJFCRV7JMDv?X5%h%M_
z;R36#r`PPOZjKY14=C7A{<&ZM)#a!|lhw{>8s%v7Pgh`PRH<Klecs-_UeMakbA5Zh
zzJVN$YAN-s8hlC@_{`(Y>#V(AL^&-KTKBr|`d;v=vU%%T_g-9Yd|goM-Hx}0W~IB;
z&TUV*dF{<?tCG7LJOa#EHCavX7;QB7@|kS_K5ZFv?(sV*!?o*5J$<=mGfi3act>hd
z-jtd3dXI14Exh(l$}o55VYfu#Son#|i9#!<&fEf86}k<yXf1O$+ijnNc@Gy`@5ng!
zPRe+9ThF_Pi^X>4rKw76U1E}`aqUW{o32O3nPXQcYMfk?Ep;N}T#QSLuc^e9<iHs&
zo7LOrTwnSSa^5j$8Rx@u*_S?iu&f8MVP_9pLQgjCkKP@tdWR8NSZ;gSF7F-8hp`$0
zGb0bQoOJEob(7w~m&QW%tqStGG$~YN$<lDJF)$5POY2qEzPq^f+0{oL6WPm({9dhE
zm-ptS-UB{}br7>&muD~8-C(vWQjdW_>ehOb+^T!vC8?MzQkj#Zv(HK+NuSA&20O>3
zRAtH1b#J9(b;?t7o?PCoovt>^V<PwN*m~92gV)Pr!Ap}NsgCj5JHFkZ<+MDxTZ>ki
zZPQ((oSbpwaEOabPIT7MkSyIbxocfFuDBhTBQY~@qu9})OUJgEO7(`cas*vy_Rw@P
z>AJKc+ey&q;>NYBRabjPoHWi%a@lt2cD9#_lXnheacffKW|d=}vom?7)f;(xsrVY|
zZs|%6%bmLI%C%!#Si6=SIn5wuoE&yLV9i<I8EdX+ZpfB0RBev9HrqQeP(&k4<Z9c(
zO&eF-4$fJut?K2u;>IPO$vhKoMSJR8Iu@xhk=vxDrKM%Vv@<8!JaU)Zn08~buEs>M
zOl{t1v*6r_TfN4fowIaJF6Cw&-DXy=9dT`|Xm4+pNs`&g$Sqs4dV70&yB52KnO*DJ
zxOL;&MVADnlg?zC9ci4DbLqr3Z(WUvoY3X3xr=T~s@<5JcF9oZbfBl_wiBUAtNUJ*
zm8lg6u6W56dM+ui#A+_za_8+*y)Id%V&L<KZ<i=#Lk{n@UL12qDRV{rxwkQAmu_r~
z^jw;#a@0s`;?X5WIY&S!LzL%?)^UL)MwwBIBUYTu3Aglcxg6N*W-8g@ZMbN$ly;P1
zPIlnVop~jfJP%rXsW^qbE-{ZzmAR;LIvKQFQ+L<XN#2cpvpg*%UM`v3m=kvFmagc=
zZM_k<tTH`ILub0>9+{|=USAe=&es~Yp3_&wRoC*er`jC_CT3ZS(z}-%n-~;K8CTr^
znXt`tYcbpHqG#X(jk~Uyu927-n6}`G8Mmmnx6}<C$0TmC+ksoeOxHRl=Yr!uAuCyH
z){JXYS|**GbaY!vP;knuEi=u0W_x>XoOCHIW!e;vSxNP7(<Y}(oz0n<yUojNg--5d
zp$Oj9qM*ghyvb3yrb&wyM<;DqJ6q(&nyH#<ivw;(OL?YEIISwAyS9^)Gq-2L8A#lk
zh27@N-4@1~l;kTmGwW!sMDM1soSDvHSGP(hHO<`UcETmMcX4jU)l{>|K7mTNQnqE9
z%!=%poTgi^F;REhwA8dizT14)?t0hmcVy1W>&`shbNO~%yS)%x92H*Z^5n`nVw9?w
zxinQR$md+{HLEK(G_J0ebWNJzayhWeNp<2@(VpDEu!}KIcV6~XS9;Urx@GaYjk}6n
zrl~F!(p>{uID2V>dDIFekBP>hyf^pOb|II}=`mX(>vt8&CeF=TcFW9=)iu;jEvt9Y
zil~TfN3#QSHwhXCuIk-(<Cb^EW~E8fyl!XmWZhh=G0}9RTAJA{ZPl);p34?p*buQX
zid$@}V{)|TR?Wq^ti91`zMh*dC5H;9Y?)y)B`I^#S;b9WX5QM`+7cdDr<`@{N?a|S
zvCTVIcT+UmV#E6AwA8E{YkhrZ877Bal~}cyZQF`NhMP8PZaa0b>xPD5Wbc&Jw3`k`
z4Z>~<ZjE-kkg+zyBzN12ZMQ-<bA}yw+M9GTWup$K&?X_5NryHan8cZKEzsq(RJLO7
z+HE}&tGz+DgJ0~rbeJt?%cixun=bpV)-gypHRE<_o3zr^Sy!~B>Q9``<@MR5opUW)
zO1D?w#KqM{s=1pTbGL+UTyewYM6<@REvbtWGiPr2#il!7HK~i8(KB}H0^csCE^)_H
zuW9#^b6mGXOJ|?BG9_PHkwZD@@Kx5#T#;;%+{HOzd%8NdecY7r($OoYI%&(QEG3Q9
zl$C)ql>|MF7To9++_*SI%CO!gOKF8kM7MPI#8p%BC0Z0N%(gWPFcF(@%`izP*D=d5
zOyf4funt9D4uQ?KqBAwF-8#6EcVm~*(G^{b-ENtgb-QlN$z8A76}Tr!N}$C=aYEad
zWv5OZdz{>JCxLZ|X-`DA)I#2k9UF5(vb3d>L2jEgyW%F3Kz+Vx+mfY97g=X}NJ)FD
z_H5dy8a64Xv)_v=?8Z;gjeGChSYz(4b8E)hS!Ro_<fh!}4%|99x1c#^VqkaDvKwbx
z0#0n1mXp%4WL6fhv`Ut)C|kE+a&D#6q}~rl6nR>1?oqg-cC6&4Z~wG_oR>4BlM`;3
zHQh>;03Q#1tHsn!$@pks;FhqpTXR>OpVX?k{p=<V$A#=2GQKSZZ;l0oY22FmDa%4o
zO>Lsdk;%R)E{3bqf^(-#mn&ivt5=eC?&DLOXl^<?ZK)u4a8O2=%1uc#C(liq$7B?5
zuP<76*IV|&+oNk%&0<(_B{xIunAX&7S676cZ4K~t)9MY#>d9Tyv{5tSynu2abFcX%
z$9a~AWkpZt1PA9{yR~`Js-3J2YiDLGS+VHGG<j9Cr3Mc}RVGEwo3U)shSc=f^5UfW
z8I$??B3@W!Ez_K26rFT1OIJ11?5Jaw&g7JB);qgyTUq7=CvB9NnBg=fDPSR2U}vxr
zcS=`JwkX??h~8dN-(<m-E3;BM7G3oU_~EA9&Q`dfU^efHQ@Q=oqFYn*%sN_Jlm$5&
zO>X;2xiy(=yAkNSX<Lxe7N#i+)&^}+HCf9X5go84>(;iY#7B}cg}ul6e9pAaHuUrg
zoiSUL*JZZJG%wGrg!8^DS8nCXGCP;nv8h2jS}Qj@VX<gnZ*pL6RPS2p=m;~e&0JTf
zuFlz_5xB?g#B-L}Tv^gR)4PfpWw{k5d6tIntSl`!=rw&)F{5hz!ZoQPSHf~5)^2tw
zJT52AonySHIqX!<RhHb1UA<eknHsIs-8OM!bl8<EoMtDbQ<`lyuUUKY+_R&iD?7H`
zWz9WuH!P{^={BtyrQ1xe+|E6r!?vb%(S*PV6{l66Dm_+-5y4!nhS9|t6BX5jot)ez
zn_Xm?owe`86yL9T*Ci(e3mB_rE$47il+JLxwsy+0b2+^ny&WySo0OC|oCK9T)l{ZM
zL9VCs^i&NywZ1LrvhL@W>76Bv=8UJOA1q;1N|&9oSjx*+z-`i`4rLXOrCGrq(=O;3
z$#P}g+O}+MXW_|H8P9nhrJd+)3(e8&x)H{8W9^1JjXJkh<h;uCU0pU)h)tO3H^)}p
z4=#}}SLeE#74&jk<Z+#OO(cEOQcqVymLBm{VN;fB-J0%M$|zs&F=Kty-2>UHcQEiR
z&F#s3?wt`DnqvG!(@isJqw8wbC2OX6=SkdhTpg^THJf>9TA<fP9)~BZ0+_wFaH)B$
z+&1BLPME>UC{Bx>J2RJVSfh~~ux#zhDW@ZKjum+duJknP6u8LIk~u@BEnvBuc2ZAp
z>f(ScSvi(lypvWOlrpwjQ{Qpy?NX6VL8?kiE+u+owkl}^sR<lPh)=m_H)X17<;I|y
zk<s2c4_SI9ZdA4k773hkMI<=gL^WjE)k$m525#NH#hBTU#h_}cXLj_AEpFSpbevMo
zY?!oa)tbtU$J{dVlJ9tjEe%y&rhN_KN8Yu&u6kcIoyw4ztIee>*ko8QVJM+}M$m<2
zN^(`$1F5y8cNjv8(k|ydc(~)j#hwf4N7g#498Kk9o1D_pyCSG(*`k?~gfbIfE^YK(
zwb}66vQwuHDynHla~gG>os_9FHAZ8#SWmXp#kHH4onqM>mTGp1@ygl-lU2^{xRzGh
znkIB}+ro&oQ<ZaGdh$H(dGO?>+Ku`nZrxl<W?T~OsxiCgcBHq{SV&^Rk=YeRd6w$t
zqFuK<JQYvw03WBEsi;zvyX3aVEuTwilg)EaTOLoFR@|5IK!&qrQgX`4O*u18>ToJd
z&Wv1iaqU!ROUc<Y4SXkp)`l243Ar6n<8WHU)8aS@q#`PJ<!a59E2qxrc-&W?JBjV2
z5Ramyu%Sw`5~ILvw~G^{Q#yImOv6GsB1BWCW-1$=FpBiax^1MjWtMKlwFrr$i%yC)
zhh!!si*>6+@n}w6a_Z7;L!B(`Os%K@#vWY_hGPaw9%m-!c!x>NHgZ}h?7^$-G*Q!O
zil*@5s7Q@X!C^-?F1oRGi`$ZIXMLFKgBdr3iq2ZKT4LfxRkp=OZbzm_^}2aZo$02!
zXsfhzuG_KOIj%`&lY)=O-YvU&fZ@vb!g9{!&b-3%LfzGK+)L+5!464|z2hjiE4Xj>
zuD7cj7+1b~^iJrw(49x`9z};+^u4w+JroDNDW+iejwVBm@9MH$eotd}rmn0Py)&nb
zv)p;RFUQJ|8)g^P*6J+TnrX<wzTH!7qpHD0uTZwQ)~J)SLX16(Hk+-<UAfxSFifNC
z+Ob==Ku07iMeV+O;n)hj67JyL3!4_~y!g&#Yx(Yly#X;V#Fm#kvnaC}xUo%QXP9_H
zP%~81Q6q%=aFP~Z((P8q720e^LS&BCZ|7<bNKM`L;!uxv!ZNOeh1;yYmzEdj^cAN)
z$?0X9o}FD@w(9#{uJHBcy*qoC&YXBV@7SGVm(HAcJMY@*t!aJE>C)%YKC$$8>L({1
z71MoNbgWz9>bZBZch0l#4ULoNJ(sVz<Rq`!5tryJ)11lLrkUwma~Ar1dpUJha$mu&
zRh#N9@+=;wADk`lpjVJZ>9(!WnrRW6PA<8eJLSryQ<__QJq)~=A|%vSv4ALrjzv9d
z45u3Q+zOoKt#QP4OOCX}$t_a6lBR*KD;C{a)U}d1Wktt^j9VHPH|9(;$ySYA6&7@(
zMbhh7n6{~j>6WfbhCK{fuF^@zHo9)zDAbj+a$CJt@3L#HY_~iZvZ9tohPj-WwT*XW
z-isqM7F=sE-H~-^(?M4?je~An4|`^;;@x&?)tWmQqS3}}7AKCRq_|}~Q+V8a>~?H$
zxE4>(HZ8#!w;ZP~NlZ>?G3}km6UO1NRY`(XN?D>~v7p<-0}azAO$uRQU9#%5s&3z_
zC%KC_TP|m0)*pEAcEi<(rA8|*rL=527%0`8Bg(em)Ty<+QYN=^-f6B_vuJkM;^dSo
zQ&l%+thl9g#dU?*u|<n+YzfJg>grCq7`SysM@Q#mH3yfLmX+R`se<C!QD<^@dGFHI
z?Mc&?jOX^!)%0?B_HONt$0;4fv-!HR=e#R*TKDFSXXLf&)z|jams?&eo_jq;^LorN
z&Fe8|bR`eBo{f37PFHcutu)CVUXBpOK#yq21#O!`rcUQudU)Nt-3<({cP~A_x3ye0
z_HL$b^~OCnzIwL@h3qKRll9c_TiwZdwNP2*^4jQ0?x9Dzy;(MR=Wg+xqUjbK=yQ_O
zq<M`8m(gmzfVFu$y#zDP$<!<4O8YJlNRBwmqNFrACuFMO#Uq_UDk-x{R~LD7YD`+Y
zrOi`!lCh`SMdP5&8f%0y&7Q4^I(AF1w{!Qp+;SO^?uBBfI9!6F6?K=DJo3tUcXg+V
z%VyBw*VAstm`dDk(h53ztvgckROC6?&7wjqF0Wo~&${+>OLnvxt5oB~dY9%t!!x;$
z3zc$()V|$3ZPGS5<<`|VS)NtjXY9SpruVLE%F<(nu5<3K?q`vy_?-K+XF{b}Q18;V
zrDpHeC0noV-O_1f#HyV;Wx+|Iv%I-eowXV!MZ26`IH91CGdDMS-Mc+D>U&>&*z2je
zZfeQttVE4&&V&@RQ#WH?#wAzw%I&ScWj^D2i;G%$IA@FVn#J8YF}ni-=dv2N@U3)}
z&g$J5);a0Gq^%W}mo7~^QK25SbGF%&Op#Nka-%caIy)54Z7n!+p?5~#rcEn7)pVjJ
zU5fHlma5BI{9sM9wzk3{uE`3*Ooub4Zi+OU8Lc|$<d$2>*%7DRR5xAhG}#tqs5aR<
zwSLoqt!-O!CaX4W&E1+MrgP9SD(S|p8=FF=bsDM(XPT;A>vcPJ?AXQ?i^V|8W)m(%
zUCGI~*yA!&%iCp!?~*ICu4IcDCV^I^^0IB6acZ%|Ez>Z=#cqbZQihWzi}|{p43#+8
zyIR@onBkVFo1NPXdl#+MxpplzaLU;XZEY#tR+BZS9cSj`WQFE1WU5TMwN}bBaB=RW
z=8%lrDGP3Sac2v<L@kTp>HHcf7$M?XzkosbyUAsr>4t913ey`{n8c>BFu6>3u47c4
ze&H;WAWz3)*n--uW77qfFeyzxxRa@sNlJP8M+HXp$pY0}(_hvzdQRWEi%CI1>xS1h
zp|vfm6SZ#mf~d&{tz;OFOwVOyGM?Te$IOAYcvla;c$a(0q_}tUAOHF<|7=2wD#HSi
z7DWx#8yeC{0o(_I1X>n|UlCmOcDmkFMoCv~mCf27PC^X<TuuU0m>NK`B1{NPye5}D
zx3x@a{V(^u`kvhGd*62pc?mW(ZUY(0yHSJn?Xp>!W*4R_-eyz})n790q<y*HzVGjC
zC5{O-gx$<qeX%D|gEe<rlWFWm5dBo@n86gLZKoZj*4+Tnp-{SLy_;dn0?}<z99PSZ
zfanzv+FR$;^mpt`vh}&sR_V(WF5bQC1NVbK(J3L{_rB}10vi<?*OScYpq;a&ka@S~
zw$@E|lp{cPduB||d#iR!#1JZ~4R%S&v`({kmvR?sB(axG&gD+ow&&~XORcYV?|tv7
z5%<3G_4TD@7q&%7w5Uza<xXAL;go51VUoAb_Y&V%`#ysW$ep%oFT`&d%AvPGe#{G8
z1F>Il)!R-7?VPQF5PG}Tmt+Yq#^}@qz2P|^dKH9D*>q-lfDx0-^cW*1E>6$<Yu>8+
zf96h_Za9fabb3M)Bk%NMcNp#KnLTbWFn9>DwK^~`IZQ|hI><0VMUdx!3MY%R6X<{l
zmPQ4JGzP{Q3~UJuA`6%W8F&`(ZkzT`I`^tBw*v#)<y51YKFdOG`gAOF^$MCYQL%Hs
zuyo6*tqcsJM$1lgfu^#iOuLmEG|O>oX4t|N3=E4@x^5bDtA?GK;W}xxR8oD8Z)bO|
z*rc@}VvVw|Nw(k`$4$r1f4CjJGBSd}?AFcPwNq15bFNKoVBm_*&aLSZVP3FMz<Ghl
z5*D}rvwwVttj>fjR$Kj2ck=SDf0Mp@KfSQ`lE3TGcT;}eZQH_s?~SRK{PMDF7w7N0
zc{4irK}@IGcZZ|umDt~xNi7xRzr5RYk&@!?yKP%sT<jxMrqy2Z<lo<a+_uY8e`|KU
zTl$MLe?<=MXG{Cjw*0k~USM+g`|6!9?oJdGIk7nU8>^9$;g+9s#dWfN@4fS-Xr|lM
z@9cSbg2lC#`=-B9nkgvg)6tVvGgq|w-n%N(eIH8C9^#p&Gf%<#YDE2$)QN8X-Rd2+
zKYq`<{YA1tvcV(xc>=?V6_YR9FmQ2k=3M;Az}}VcOoE}-c=w&TckjsFy(1?!ZNfr^
zrJPJtn5JB<`?u|M{TI;cxfVsU*_qaNO{TcqDM^=p_il3DEH9<hjYoIB>QTJ(J2W8A
zjd|a_JKOfndw;NG`|=O^-c|Jq_4X5F-rc?PwYv0f>Fc~r{QKvl2I#7P(@r8*i^76=
z-?Wof^;X&6+K#@r^?ICPB4=gz#@slH`MIC%>>1e(e_tLuF70&lzWc&h-tKEPU$uJ|
zR-J3VyjbpVvFRk{_h3aT{P*VM6mBurotu8~MYwa)*U8UU#^iEe>EBg7^@RJii{C%y
z9e;Z7U9}khqFUh>^TRK@*hS@w`d`xFIW|46mC?PvHrwJ_v|MGjzx1`c*YCdFd9gj_
zF2lpG<?`XTKj~-hur5hU4NZ;XIrZTCy3_4tced1Z$y(e@R;f{bxO{ES#z_`^w)b|J
z%XnV<_qMuhw{O|3zwhG3Y*s3tdQlN}_kB@$c|m!3K}A%QQ$Tk7?(d8A9=x`n03K>)
z{<!Dqz3+F!KRiG8{ocVY9^1nP5f7dvoJj6x(=fQ~G0$)fW24X<wS<kAeAt|2DhwUl
zX1RRqP2k~}Jf-uoRDyw0{QBcf*O%`R+pGQc+wIz8w=K)>T;5e4ZFMtcy4~MT(*w<!
z<m*@6e|{@>!u6bDao^1szwcdl`_A{>-{0SQ+h6@z-T(fU+wp9>v&t8}+_v8R`*z!z
z^Daq67vG%mJtt0d$7bWx(dX0BC%<=|yYz3$pIsm=`VkQkx0p5SIc&5)Y}|GGT|rw}
z;`4big~#QB+*w5eT`sjxQB;dQ%ieO|?e`qT=?0(c&k4Od*DVt0s=&a&^mz8idHW8@
zg)C8g%8{RzZs3&T`%JF(@-71g2kyT7W0e;e7(}G&j4$!?oHqKwx!J#8^0MEovai!T
zU#!xqdk`%eDH^G?YSoQZSHn)v`+mP({s3cL0|P_++KbJF*K4hJy-2uIdgi6ce9ztM
z`gp7Eew3;6v*7+!tMd7zTJOD|-(dl=YJc7B+_@VM+&OcCsZs4&S|h^+^X$7DwTo^i
zh3z?W=FXV}^PMvp0#tU+T;O2Bd+U3S*PU%Qrmi<OHaC{wZCe_YxA(T_&fJZzT^ftB
zrZ?_ZNX;>x&2vs7Ei^PVt4m{1m#R>w%OYPFjYVC#Jntq*zht)Da4xegU2E0q5HD4s
z`c9Wc4GqjworHZuLjzq!0`nQz)7X*@SQb4!Jtgr0Unob!3I<*iMK>Q~p2PahVQZS0
z1m*7Ts$O1R@~-Xp)3Bpqt2VtU@>KaW$@8U3C+D(7T^AS_o@jI^bTn}&bab@IzMpUR
zy}SsPzd-a!l}Vo0jg_S*1o>W)s?WQ=J1K0>+2m?gm0ixhAn#qDxh6l<_xkRnnJOiF
zi}lireRQ{-RO!-K)OpBL_g(&G>sg7{Zi@uEiZsX`xVz0$?L%2Y-@A7w*b7n_H}uR1
z%X=c-$L$c3=czI;$kSG3qT)_nh6gMP0xb&6$9M1E<*71r@2$&K&yxOB``6m7sRy0*
z(~~T@eBbW_to#gucW>4)sBbU%UVf=oOKa7-@AoSjAKt99UA}LANN8y6$KMvmpI!>B
z-NP8RYSk)@MO_+;j-Ihh;qhm@(3PMes<n3y1A}<(CQp@fwUgzn)iguDePFZPW^>}n
zyE7+_JrRES>-W2NZ|wfeR$8@klm7kOZRc*(Gwz%@ft5LE_3Z-;jD5NNMwZr_jSP3P
zn#Sid#BMvOGTHQ=++*drCfBx4uTlfq*QK$jTijp|Q<cPlz?KKIn67a<PkQ>|$s|ve
zbLH(jPCWNDUHkN;#FNU2C-c(W%oXPQU%y{op7{OAP0>)_iFLnox0M~>J#(f(LuzW=
zJq8Az`r@3*i6`&QoY;FpbJgz(W|`Y^DMjUJDal2gU;fs9FE5j?^PLzPa#Q^Mw%h4B
z4B$k%GW6{O28QEi$7jmSy*X3jPSdRQ+Z*(5r%dvkd)dfvH>=jZdkm{XLqkDv6zFpK
z9nZCS{LCpl4afo1zq{D9_l?M^dSp8bU;L`u_j~tl{{3nvR;|kE{(d`m^JWQT=i+iL
z89Jr&JT3C_>vOl=E<1UEE%sgSc9lt<%DE@i87>Fr@`kmBMu}#va(Mc%TJO8t?MZ&p
zv&(Mh?oN5YT)yk1%4F$RUw6EjxU%*Z<0{>lRiJF9vC&LsRTZzPM5st$Q)BqfEP)o?
z+1ET(X50^7dpxDr``rchWnbs+-krDS&}p{EtA1}`p6aw})uQ^hyiwa)qh_5E2o-H&
zo7JNgT0LzchtsR*^t^Ys*Bfj)xZ~Bnw+ypy=1lUmyy@|c_ju^{40f$mN5Og3Rb1UE
zki|Dgz~o9|(CRx|Ih@3!r=3)pJa<Ze!kyCivW8s!^4Pm~C-dlT$X5-&yFg|K*Uq9>
zQd_gGuF}{jp|EN-3va#Y1gMqoP}RyG*)#q4N&U{J$M=4)eW$Ug#VPP*=F7~gD2E3c
ziyEtU*9+9yzAs<!Meh4nD}f*V3)VYE&Zy$LbGVp)YE7M_NPzy)&`_`5sI6JE`gNnW
zTJ%?HED~6BM91mM*6Q%RyVrx(?TfwJQCY9al-PDY{NDRQE8&G!GKH5Iyqp9Uh%f~S
zv@)~H__e(7YnLf$5Sq{eI^eZM(LwK^hICRx97vvF0YX@VWr-peql4;&7Coj0?+Yz@
z2OU%uIRfmX{gy|RZaTc8avp!>JbsnQ5~qTFO)mSI7x}nejGR#t_N-odM%8*FIh%@)
zkNYfM95ZZDv?@`XYx3d*Xd6lUw$J9*?|#3pf;jLMbXFIbE8)p4<ecPDclGMk>*3}9
zc5h3|Z87XQc7J70npw~7oQpGZ7v!8>U~v0ij{gJZH-9I;X|FHzS&`MWGF3jxUdr^x
z#jIc38q69}%|b(Z`k#NUzHeP@UA^bNu-uU&Zwi?_w|T0}Tv@5b^nuAiN}p%i@flq<
zt8%(u>b`I?z6k1xWxmwSdwkD#Vy*6jnpNw*Y>hVobx=TO8an75bhs_l5C`sp>}F-o
z@nUqCt}vBRtX`i{lf$WTn<j@-02k<ZL!=(dz3+SX&CZ?w<F<jlfx+=-#!1EoH`)}A
z8A==$OE$}umdeR(yPU&zv5P^8sorSSf{uSz9UUS>0z+I5xQ5i<6gZ+Sa3t*}_)N|;
z6;3w8$!=YSjjEwjrnqFZ-8#7K$hO=iXSD0J)!L+mPNp4OH91F+htKRd&n?NBf&v{E
zniLnAbqESF3Zyuvb)22;rnsTwh*|H3j*cX0w+@Bg86CYG0vv7^dO8GWGN;|*x$&@%
zCnYCmvYE&2Ov4FoDr#*V!p=q+XO}r=&h}Agn<cC;+qdP!ZG~Qiq+GKJinGiVrQ8Gs
zCoZdRX=u)9QoH1F%VoC2O+zWpEj~Gdi_JI^g)%uOtE4!4&T<l*Wae>Jv2)^V&l#7@
zILvNmnE3V@3CuPW+~RiR7RRxM!<icno}83BDP^Xb=R`>XmlU<!EiM^{1z8+9Zd_;#
z5w%|+AQ<5p$hK<L3Z~o9X<4@&a-$=*T~$b1+jX0@UaBW;qT0!AzFxUqi!(J1d)+j;
zQ*#!3Ok3+XS*^n)cj1C-x6^KP8*8naD!`%Wuxb@UsOaC-zb1dxe<fnZCEL_;Lxa7%
ze*1gSfyp)Ng$mWuWIT7a?tC@h&f?=kP?|7oQMBIOxqDaMGq;e?&=9`IC1<j%GMC-X
zT{bIs+bxxPCJ&YgoQfM5L1{QgK*%9ehtE5~lmGVaUAtGsH^|y@zkl~o#ZgFS@uhH2
zhdl)kU0MQl1iF>K=l%Y?-AI3Z-RAJjOQn0O&fl#4eQMSF_{(cvUMhL5Gw)@^^Y2e?
zid2T&6u%UGp(P#MKfin_>hAG9vz2~DANUy>`!Z|EW#4+WTe+aV?&VEp0UK2oCYc4a
z<Sb0`bUFe$8`f!~r*g`q7L_TADhoMPx&M5Rjg6nRetYe%KPSrPsH~Ehk}B^RH)-;v
zfOeih#n6x?fl5a9cK5!YyK~~neeu(_#sU*x&X~}z<hea)#iGy$`W#DlK3SW8?^Dyq
z=DYnymNF`ni>>vl_i#&P9`6Td_QQ{l&Eh-<%|W&AtM7eZzenh3%_V`B1(44B?&*e*
zJOk?5$0GXcEPFsj4cm<+ikuEA3=>)u6Ij5xPJ>mE!+ZCxzYKx?e>9l>G1&Q^wDVFs
zoTsXG*lTz0_S+w;zP`S`K5lP$a+z5~$?e3Q?W;a3K0e+rX8|sF1X^BRm{oFlu`;Na
z!d`Ip>-XC4Cl!Pg9l(VR>;O$62bDG<ry~<?Op@Ol8e6w^?b@}|4Fj2_r%woE7M-pz
znUQ_Efg}^h^traoYK*I=8%i>1b1nhxF7D{)44r;(5~J*N+oMeFlLa2|Pu6`PJiXxs
zvniOE{QJIs{k3b`5=HGAs%p9auy_iEY8==t@+EM4%hFD7QLUV-(|`VX{`04q>(}?!
zvff(xZC@XG;P<CBS5|3EQ|e6MlJnFR?@`_O%w2g7-f}AF<+ACy?kYRVEN&LODe`Vl
z?w!sjle44DQvYcE>%H%*=M`>xc(`{u_r@YWvm)<yKF@-Mo>l@+rt|&j=u*GHH*fMK
z*~eNElN2Jh{Ryno*#4+H{0ifi&P5tiCFSSmS3l27&o7_-DEVfK@Xbac$D30OOC)0D
zetv$wdr$k`T`TYE=h?zi>TO6$HNNz#N?_8lceYP%iiuyl$9`%(8R-BN_g;*kyKMqE
z8B`QGA{gx^d8cmX&)xQRV`I0Fa{`l)gG%cRiH#~u9y#E?76XHCcJ9`-+x~efWJl+C
zGE8FIy6wmWPQ?VKBNGmJB&slZq)!6HwKJz;%LGovmXHaDJXj{&U`X;{nUJ`N$IJ<&
zc-z(up1fPvZo9UPQ*qk_6$d33k4`4AX-Mg%!IQUv!;?o^F>#Z$kn`tqxv$r&OW(#_
z58wM}I`=e2t$NTFyxeWKq0U00_>UJmZdf@XAVq|!?0xm_-P?=ztk1iop2@rB-sRr-
zSiN~YU%n(u95cD5`HY!|p<#o}hl)N=mEI>l-{oW9Z@=du#L}n$AsSpdCJM3iAG&(B
z&g`Ds?aJk)?U8qN7gV2G_4thT%apXY=?j<KJ-2etgC8FsAMXQYh{wDpw>0nGE*CT3
zwQAL>2i9{pMy;EbG5zi|M)7)SV{M)@UpZ1{Yj5=0t*Um?bqjxGC{OiWoq4mj&TG%)
zo%e3<>vm8!FFY<&xNJt|UeTMPQ?p9nty;B8LasbdJM^-z+3j4D3!q{Up1T~FlRO+Z
zNeekhEB<hjR68IYz_=mcjfnQ{ec#K=%hP^$IQML{-Nw4}s(Jk!d6|lj-~$Ov6!~7>
zJzsM7Xz#lftNwn!U-NzMwqMoz-tYYcDrpsj5ScfJ!O0`xCO0oA=N|0hI%zcP<e_(F
z1$^#$f0!5=7T<0-dVqmJb1K&(W#+Q)4GjDfw7Qrbk{Gl?qj<HLM4dD^1UXeaSd>;R
z@f50;Hc(&{S;QICA?U!gs-ZK0X(f{g%R+`pD>)`bWwdCfu(?IJE@1q?z`(@thKoUj
z?*{`zYy;y11_lPU#=E(n-ihj%md89io1NR-;eLDZLKZJ@obxZ+WBuN)K%kW~sB59t
zLWj4t&rj{ES|IOxF1eQBd+Y(}-SZe2*lpi4)EDnOU|wU_Abni%h?Am#)Vvv5Aqy8|
z@Jcai_67xp*gBY;FkxKzJ5*`qf(*t944$v11TGEcY+zvIQkvy8kIQD^E6EjKnU*bC
z>T7CL<#4Ovf)x|<uOISDnu0WZu4+v-b=^9%Y1`6el3g>qrp-vxf<m)2-fc6RPWu>(
zx*Cfbi|QI?2OC1*#@=l+o6a2dIqGxN+virIVNlYNW2a0GOXX%owjA~Bnk=nxnOAq!
zy9Xu{7^KX4o82yMU|iC`Fg<Z5qewmD;*1+6xzcRCixW3{8Zd2ya}zFZ$$_fQxMe17
zGMT}2t6T4~vnmIe-7ap(xMjvG?RGeAQUc?~ZC6!iFhB$jF3z}-bIFI{#`e2&ik5k`
zdO5#6x9<G*sdKY;Mqb-fwCuaKZT7jPigzAwIk)4j@j7dt`qzDztsZaL(YfwHFKEf<
z8KqF8&1SQn^GaMhyUgsguX)0?WeM90F3!DUl3va$dH1kedBMdQQ&Ns?T+`NbU_$4z
zjlFJLy?nC;L5F}&n6m2Kb<c8!ii=y%_GRY0&ic@)T)k;q)vZ0AoL=j|D-<E?D6fH)
zmG0hpsXq3AEaW)NATO_|cgKvN=Lq_$cr@=WnOe>sd$$~%I6y?{?q=}B5Pz=O?R>E{
zxm&w)UAx_mcDpXRm~mrk(xRiYqRh;0fw)Omdl#M6l@?6)IPKP)yJF*#)WwdeT&zpI
zgc>u0rfLRF?VWVZBqV}2qyDDZu`RiabEPwGyLELlu9a5ZnyH)Y>e_IvchbeEE7LYE
zT67@W?c|CrZpSWmwyo&sSaIZ3Z^t&X)80}yu4I`?_4a1zPUxK0+p83vnY(qVkfQ1~
zm6Jw3lU28Yj>YUuo9L`LBTQ;`+L{|{va}3WT*)#Om0FXN9O>J2Ra&aoZE<~aXt!ph
zZ?l+5XL5AVZL^Lou8VX9*Gflh>vg-PyXcngqFW}jHs*?oDSNKTcHI)~x+Q7Rk!V-f
zj!R){)z*L+S-Okewq#uEmAbe%w`GF^i>rX+1_u^5VVA(Bqd`fj4P3{T%vx<KnKNUd
zQ!CTaEL{(mX)2Q=O;aaz3T*bM2b}?$yH;bO*h%f2fJ3dlxk=j=P8Bl@Obg-4;`I%i
zv6w4MMAfZpP3Y{5i5cB4kzT2qJ<9@?tvMxf&2+J=Yj4K2Ue&J7r9!HjP7^hSCTfIs
z@=9G?9A%R2)|+uLS5(ZKg~7E$VMP<~q@!yCLwjA$s;Omcx$L>k>$JDqiW@iTZ``=J
z)orQSSu@ZwJYm(DYM_HeZ|kh;&NAJ$n00G1+qEqTSKZ83^@s*`-P#oCnY&?Hkek%j
zFtdxzxmzW+nO$AXc00;7&1A}%liG<soSLmU$Gp9BTekF=OffsDkrQevxydUz)yy>K
z%remp+N^2EJPeh2BW`PMJDQfW;AUifug{q^A_o?Pok^LUsM{QHTifiY<fgS7!>%N3
z^Nw;-o7fz2aBGx7SWo1##Zo<4#vHTFHft?rO&08pnw68BEG=nha^*~Bs%p!&+fji^
zCuXT!^A*ZnyO?#&mPNh_lRZ?fd8xRqnH_O3J0#37cddkOw%ax*wb>b~bXU7>$!bwb
ztzR5+c3XE+cUZHqmYMF>l+`|6UYiWnR5$0Wxd}c5b8=?xR^G0|skuFqHh4|hbW%HI
zYO{*zq7|0})wY~n<#8=)!>LnOCI=jwHX++fCDJG=T6O8nO<rc6)24WITsk&sc4Ekt
zoRiu)sb*6(Q$(^7r=*&!^h&y%vp8sD*Oj$flk24-q5_pp=Pt=K%UPD~rQ*5GJ7R5?
z>DEP80yj2$xLne>>g9AgMJY3|>DCgZ%oWELOZ6O5n>c0LWKrXYgR3RBZfx3SXmaD&
zF*Bp2$gUfUQ!c8_6mgx@bvt#Ucec@`PBEuQ&$OGFE}auRmk4FD%sT1PIVr+3usP~t
zb9R<#w%fIOUFoDPExz12(NO}O(|X-*PSZMe&2*b?2Iv^v+}<VEde@v#iB!p%c6JMR
zb!ddg6|(@dFwL#W2A#`pT-%b#F=^43r5RhhZcA;+I5JIlQ_42YjVX&<r=@J%23`ny
z%V+Io?X)v%eHE7|WiDFDyVk=ccV=3Y)`Y8F+nhrs>U%e4Lr(<tnQXFjo9R*^mD^sv
zS~pGxOH9i-X?Aa`R7AqT*;>bVBsXWB=8-U3rnT9bjpt_XwqshC4zuyx+;*{<E$7yz
z!)!b&yTdXP4$d}=Iy-e~?zEe!QPHVUxto)7xm?$1id_@wxV2%4+p6BRTyCqmT(`C=
znXb`PHM>3CZa$+<{aIc?!L+t%mogH<PA;5wWtQ~n@B*pN8z*g0WeQM@b#ZC?d3Dy5
z{I-jNQs$ErjU63VDXnMQD7t6uR1UWmoqH>cB9?{)9aB2WwxVl~)RC}H+j<2TI|(?Q
zeYNVbd34mvMQg%3Ou`JsT*E{bzS<nr`*4DbfIJ_ssxJGXGk0^nvL&X!oX;p*AKI!p
zU+czF>4zO1C)!#!UfLYg^KeUA)3$rO8C|zFc4r*jl(FsT8plN&J2obmnVs~?`sx!j
zyW)tFl!DXO)k)hljxUv(a`WMqTo#Ushlg(Gt=blx(X?gi){R{^j%KEHZOoNAcH^3f
z<Hj{X!NFH^f_fhdE;8##(S02(ax+?VWmi)Dw&P3FmP$UjxVT2foWGsV^00-Q%k7f0
zJCc-6ZV>Qc6gauiD<fiBt8d0O(_WAZj=1)_uIODGuI;)dIV9T+v}m;}@oLUe!xNbj
zb~<Y_JiVjY#aAVI-6&n1R<gD$urEJ%<`zy97Z;bwzADO2xf~}tE~hvdotdp{XEVv$
zqux_x%VeERr*$@gMu$}<MTJ)Mh)hW~TRA(|kWrQCs@N?7p(%z@U27CnHJh$VN4cq7
z+^Dv((<I5uRB*+mT-Cr8y>62;wR&B97kh4*wh_YHBW0MSv{>xmqAhO6R_J7lxGj!c
zv6Mq7b5_Wd4U?vLW|;GyIXT<7S$At@RQ*G?OA=i@QA$TM%yb1ehWSiwcDpFmyF%p_
zPnObw;#q1lPdt0L!{=76<+Qa$N7t?kmT28DJL$|!m1v)BuS>VyPM9oq>e%GunOT~G
zSzS?D(HYw=X1iTG8f9h}xF%&wrm57$En&yDM454M87_9yl@`jFbaiR(w%*OfMjn%#
zRCcYZ-zK;y&-hs9q}(S;CXT{7okBStE*VW~n=&r+a$HvS6%-Uw<H$>1owL&{L{f9T
z+R>Rt9cGKR>8{kyleo56Y}&!OqFXginrz%07@-{Ht+w58ZBN$Gkg%|T#kxteW=2kH
z?%Z%Uaph*C*{L~aLZyNujwb13ExM(<*frp$qngJ_<NDkKkKHER5fqg6-BR$x?e4a#
zUAdc=EnIRlIzZ+2%&S+o$Hs05G&$($wk11dZER+kvNz+>1(zMBiTG+Jx?J|wT`amK
zIjrlp)NP3?6T8)p@lHA-x@hCt?u<1dIXNQ9f{wke+TK|wQ&XdOE=bSLRGH=Dx#VSN
z!c5`7HH%g(JEL&Cp7-pwr(rRzExr@EIc7)SGmL($GO1GKk;kOiNQ;R^mS-NFkJ_45
z&@08^Qt@_<TE}y9&Pkq19+NyK8mYMm^crz^CJDLuPMn-_(<mu-7VlyGsIIGfZtvPI
zd$rxHqeJ*q<igM;z7y`fb<MKLy&FCE>IvnHNgn)sG6D@Zd4BY|uB~62G&OQ{z||?7
zoQ7(vZY;}^)H%N9Y;=yLQM8#!NYX8@$x#|Nx~|Of-KMQMb#=~!iBqIHu1z|bdnP(r
zIxtzZY1`VVvt^WXw}%7^_9jPN>)qBJbw%1EcXhC)Z{$|V2+v757BVi)Qv(;yDOAoq
zU>+SN)oOO?x?k>zTNV#@N?tRq&$(py@rlQzjGJt|8y}u*+0+(xWQMm!YR*hU1@EvM
z%TzeCZi}3p?77Wj+oF}an_Ra_M@yL9>XEuNNq4JCXvXa<-K}D`db8blx4Q90EK8cr
zsckT6Hdl`3wyQIO(^9r^8cT<*VUXIiGH2_aX{+9D+it2B*|yem!tov-7O$z=UeoH=
zKKmfSpk;7~!QjwgZfD*eHU=|84u&M*WP#Qm=NwnFBvIYTzO!7NI+sm3?Q)G*s!MHF
zkXXo!NgJjHc1KIxx)OFVTVhLcw!~VATc%Q7y}dp+e5EDZ3};0uoMG9-BB3PAxOSuD
z>=`q6g+^{s=}nn(N|<-CNMP2D6}P2U@f5tNKRnSaXxpWmE>Rt~4UHuy&XiiMW-4(p
z+jXO~YqZyzg2H20mR(}i?20gwINYYvY0@$ybHW6VW3w_16pcA2%j7OD%1b$%r_$1P
za<NM87PZ^PE-p$YZZ5Z7ZZ69GU{Jocr%96K#tFq_g~Q1TZH{I}91$msZmnGE<#tvp
z$n0Q%s)%ENexb2&)N37IC8tc4SsC7@Q908mE@kwo=g#W7%(=~6qNkTv%G{7c=jKY^
zm621HT{2zkY_LqSwV=yTYf9MS86BQ;uO7KDSvYO()zCv$tJa*8Vlm4zlF^Zxa#Y(?
zvnx2E$xLx^n&r*jm8QKbH+75YL@ZM3(gB}|>8sW&*0D`#i)&QQ#l>#DYLnf%eL-ht
zF1eI(F{8daNw;HFm$s<qnydvEdt9WGw0$}{gC<Q3xGAtvP|({aaI%O4OKwOf%jArS
zDw#qm9up?IC-baYwdzpMnyrF@T46WVCPxS5uKG4p<m8&pEuCB3E@TQW+$3B!ZAw%R
zvx14^BCZpsv|U=(3VB`Bc{$hcY;j!SW1Dq>t|DOt56yb(7f0O6HS9^2(&UH?SvmJk
zN>6#Q%K5Ujud_Z(00Gb<Fc+1m$R(%NcII5VInivwsx!;7B$Z`Tlh$4oaGb2-IAzw!
zY#(2b4xO|npN5Syj8$%>oD`jOVv@_GDYI2KMdylnP7(>z^h}$ka_JaLlu71Fv7QUg
zUXG%YO>ACAC)fKf^A^hRRJs&2EoHNZprLEh)R}6Nt*(U4mbjfPWw_#Kq}TOGCx;Uz
zmzpOud#$*%(kV(e;&#?S>71m+S-snO*RGNF2s4c6oVNC6pU=ddp#sIlX~kJ<C7XO5
zq%*ZOqeGwO?zy%u$;l~NH)K5<!?i$>Sw@LLk=k0<jZ$WN%vPv(nYeUj-_)5?*7kTz
z&bV+fCunofwoD;`i(P?J*7hnzG~HIn+;&bk>vpV{kI~Vt6Ni?lm~D0IU7hK<*f_}3
zZDZzSv)j{*GLCMQ>X~MkHQ{K=)iSBuEBkaFJZ9XHEg^Y4YE!bP>LjmY_X^M4xRNY!
z#ME?&Shk>`(Ai+cCAW8nJ*mH(X{a{gh#`-oAcv#St3B(_KmYjmGvpA<UknX@Ce$TN
zS|GutsJz9v?V7c-Me%GX)o!^XH+dSL?Ctilhj(}6Y&^3$_t?cHE-t=eC$^oqq@>ol
zO(~--<Fd;UA0wa1ie|UnnqACNm^@WHm#C;V_iQ^Wz{$zvFkxc7n#z&cYqyp&n+Inv
zdv!8wTV7=EG4MWala#|5XKyBk#@xMn($F~l^4kqLx0`E@ZCsOKFq2_Mn2MTcN0L)w
zM4Mt~ifT}bTLPP^8pEZ`oGntmYST`qZaB4pfx+jp&ayL`GCI1pbsZH9Ogghdce566
z&a9&i3`~YS$wr-1d=@)IT~gyZvb1T|g;hCGqLH13S=Vl@Y|UNS(YxqO#2Vij)1<a$
z1$u4`+-B-#W*D{PqUctJpoT^N92tK&2DHW>x$HT8VI8Bybb%#I9MkpnnK-B4U}oZ-
zzQ2}HoN?9kkA}?3pra%?wZ%ivE}7)1G6CHDnCz)INg}09Qe~2-+JwU@28Vf!JXI$7
zs!Z}!Y4cQ>e)~G3<n-G&7<s0zyw1oy{nRQ(F5cX;Jq9Ov3=Z>5@>H2T{oyJ`ZFaL~
zHxBbmS~7j#Dn`ZWC$BSdGws|q{mm*y1wNBWl8S8}iJ*hBuAX{0Iq{1MCv2J8w&~pN
z%=&^_H#}}FF<Z&I$~o`d?wxnf?V7I7&8)8DkvK^ru?>XMrfz%An!EGJwcB$<%wA8p
zz0NuB-NNlLZFh@q7k9QvDo&D|zVRlb#`Fs}8QBHBZWlLgyYpb}b_?y?b6mHJJEvQ5
zGs{eO<YpFSw4Uy?hS973K}Vf^<)^dC9H(^y%Z-aY4jG*ed3WjkqfXu>3zuD~?t2!N
zB+@!9!FuaiLzqbDBIitv%&l^dcW&L$s+c-^$Gc0<;L72WeQYro6?+0MXW1Sv*22lk
zMv_*LDg1uT@8|F5oGe~ax$ZmOW$o}#0vk|z9dyiO-s7D+3nsXLo%MPh=pf0v$IA%G
zJb2u_&ag}Da=Gm7>3M4zW$F!N&qgIl9OX4zHal40m`3JSlU*~~E(Ki9$}BbHNot!N
z?7gxhR}~_C%S$TPS8o~E8=0k$0Jxl$B<<<!yK?E3BZgg4xxQvl>8%jmzAHPDMNDqZ
z&U?5da~a$19VIO6mzoxGG#bwM#Uoz&<)`_VU&SY%&#C&p^K};38OuSQiqy#5D!d~v
z6Rfx2Tu+EwmDg<XopRF{6)`WVTo=A)({<J{N;xpMJ)6;H=<K`VbLb&Qp|;t9@2qF7
z6XKX+a;v}a&Q)08JX_t;q{?fyh`l%rta{}#s9W`>?^(;JHl61HBOe#szrNFNuVs|Y
zw6|dH{Z+aJG~xrrrpg%%3=CPK4GauCydJk07#Iu^vT_+17zKHqv%qR@rcClNicFcz
zGbu9VaO$)iv#U$jZn`u%o7WAb8l;3dENp6K)}&jx;L|P{rbcFMm>$@~C{eGufq{W5
zhk=2O)r^6G8A|eSg6sz`;A8M$TnIii6MEX_1U4RCF3_=>4F(AZF02BX%^<|U&=7RW
zQ)LpP0LRiPlRUkXy1YfEB&U7f!N3qSW$Cn_DN9<qLKb8SO$ZJMxxwt~7@WYfa?_2D
zj$WyHQ}ewC7??a&CV2%c<q8bCmCJTEb4#n%Y?et*QlVy?DlJA!Gq=qSRZ_YrXd<|1
z+ND(t%%NHf7>uTcY-$jK?6FZYNCuS*pxo>s#A~wUmZyeL(^<3Gp2iGkSam!%J9&C*
zYKn#iD0Sp81t`7g2wL^=-u}aXKodQy>VLd@QLq2B;;!QH>FiPL%Pl+CD!-m{@M_I-
zgA%Wr1pb}_c031u@Ep2bTl5oj7-0Cp<9pv%-@Q}C(x}cbzxtka*=@u8=-effJT1x#
z>~FW1^SzV3W4(i4e&6r+3%)Wi?u!K-0J&W7Nc988`}_Cr-@gh3cBkin?&Z7ae!qV9
z+EBLlrK=X+eYZ7)?fu#Vp&wUp*X-N3`wUC#zUudJ2`XAYtKU~POxXJQe${72#pvhz
zzCODkB>HJ)gVfKo1o2}Fwj|sA+Bv_r$kW)D@y^D@a}K`G$#`z?-oU1T+kw$l+J9L|
z)UVIyo=?>;J2vY{x`Fj=sqBq&4)1QN`Wo8j=U4B)=;Rm2*Lg3bU)**4Y(Dpa?3JvX
zNmKUKypH_Az*ss>?9u_Ne}|r1on^~kruR4KRr#y9%>sWj)AOc(f4^T86e2Y;)%U(n
zg|M8z$yR@wb<f=2cz1E>^1KN)2CvVW?#Y|LKciH7XY+!}lLdZh&-gkk^qYR@H+`P=
z+_KB<>Z-0q`}k}(KMf5HeQtTKc){HF)%QB)f=-$B%2eJ^cHVRC`hyP~RC=a+7K?q|
zcFR-o)4MnO85sD_ulrqBSGF$`e5lQI`%R1z^}m0C0(bScGSJ$AeHPaDzVAU65U73F
zKRa(zzHjBW*DBJN<#KnOWZc&S;_$b$Dyp|9$35IR>r~~*>oa$@ZJJO~WcW;a=9(q!
zbLN20tYm(!F7hldag|qv=HsoOFJ0{U{pwlm*AtU7j#XYgQ}M(nO{t#u>$#)v_vP1K
z-}kfMLoeaOzMxxmo_wIRIYDL7<O~LlMe}`L>|U1ez1-+h&)w5r8t-mgwCrr>o_c@z
zHPv&Me$AU7`}Xej`!~v-J-xkPL8SV@ocZjxD!G>(+-Jty+x+QWc|$3e6SMC7621;E
zxyof};=34_-W9!jy^eul_Z;1&=KGz~K@oMcd%wtTdG}i5oQtzxcJB*%f2Hb7Ox|Ys
zb=xjS9(nM<>fhh*k3iu9#_Q|;P4C*ws9e7dIuBK{<mt5Axzldvm)}$kiq@;~ezNoS
zjO}Z;UGh|!<OcFf?zVX!7T?~Ty9Jc0b2sO1yB!)Dp7R!*1VG6Eio-v@imtk{?b~eC
z?K89=-M-iJ<@d5vC3e52UEaI(b>^*#sA#{0zwhI=&3$p+f8VdK_1it;8|*&BeTWn3
zs<|I^J1_fg^)~O+Hjyf3=0~Pag4VR`6q%*=`|vKU+qv8BTqzH{>w5f%`3dE_$4?iY
z`7z`7^24X6KKFdIPwr}HX!ZM;IbSQ4FWrh?disFY9<Al_wTeGMPM_ew__2KM^En@P
zzj!~-y7BY!koKploIl^!tXdTa4vkgopI^J3oqNf5cD9P7n7?fP&F|-Hzy5x|uPPK2
zJn7w_g>>sL`6wJ+a4^#(Fw?{_)5MF{V%|yNtC{)_e{71%KV_7=@rcFx`*m8=4K*3X
z>R12#y6x8OlF4bePO`av-G0f<^QHRb)Q6$``>uU2dH2NAtGrmH&AWW}Le)u$YF<m$
za97=qkUc#+cf0Aky|-029p=7!$?SH~y|<I@9#3p#YB-Sb`k-o{r@~~HdoNb!Zo6F^
zc-OsD%mu{EySK8`d-pa~J=xoxvWJb;S*E$_x!0$A{(PzOed7|d7Mo*{`Q4dy)AhMl
zc&+DJFJG(v1XN^#%23c6-+SNhcdc5r>R)Yc$<2iIyLT<uW`rb(?OuM7x!Z2$ZkxM%
zec9>lY#tv!JkQI8$ZZ3M+UlQQw_Z+d+V>@W`9-w@TgzR7dfM)`&PZA1bznQ+HpUR<
z`g6gin=d@|%6pbBU8SAQ;NQMqzNSTiyGD1Lm!tCCdmqGZ{gKXX<lmzqSGGX&qbJ*g
z@CK$XjfKC2LDPs855Dhx8u~CgtNKX0^u6uN%ga@K1Q=DEJe7+Ncq)I+Jz=xt%lq1U
zOT8wYOxx_KI_s>$R4s4SS!Y$IWt&WjTyx1Y%?vDz;BWTSn=@zE>vePH?0Ua&FMG6X
zveV9h_SIKkJ-zpR@AI&EcXyXPJw080y7(?e`TG2QzwbVucLX+<3Z7LJSv6^u*S{M%
z$<ps~c(=dGHFI&voY1>q<{~3uMTuSxC!b3uXSZZ>_)KU?GP|9k$l*3~laPQx%k7*L
z-yXHeCbM!Evfa34CUx65LI2vUt0CM53=FShr2H6UOy)4K=iXtk$aGnHr{i^3u*B*5
zor2dzX1#d5?#Lwf*fN!gDwAh*TS5p>Q+HOk<=KnrDwB!>bH$20)lG$cZf@<44%A(u
zqAhgGZE}k5#BFP?oR#vLbZ~Q+(8;uJm6N=>x!WSwW}WC+xOC|xlNnPc^R^^LZfXlQ
zTc$ZhTeOoa$SEq)?Mjr{#wcT>nN1w^0WE1KX7!pzn_auOSXyJ*?TpNxo1BvcF7+hm
zW*qBw30xhxHQB`}JL+0nqnhuwiCb=^n9aB*5*D_0Tj0iRr&3s^>Uu>-&APTliI-`W
z+Qmg?*VJz4btTP=4m%|hc59~F;$X9vE4xlLY>w*c&A4Tlu~ImPJ8;76gqb<X+PPD=
zovP1Wv|8$x?v}8Ns~K5aRaeax-KL!roHWC0hSzL!w#!PMLLO<eTxPk<=IdIt$+>Z-
z+2lMmw_cyc9w$9LlLOaGopjQ3!NIUiR}Zso?aB3ebvrM$>!{g;PLqJe9-7{Hj9VQt
zcyp4Yd$(=&R&r@kap}|y-NClj)IiIjG;~gr+vH3gvx!Si8mV<InW*Hsa7Xj5<-F$B
z>vp}o8+h!_g*RuXgk9a5wy4)PT5^t)Ztu$Jv3nSG>l1r^pPj+G{fxB4vEL6j_GB0|
zbC{jEkUMj6;^M?LjNJ@L#<`nVLj89z?Kh~idz2E)`DyY~wUunSRo6<hC%8>pAGkis
zDPv)1$fV-u_m_*$6|cTqS*AI`>ST28xqY$^tq<>!nY8WpKDn<dznA>ZoxqXIU%P45
zs#WWoJGXAN(av?L|4=A?LOA8ysnw4=H$VM+-uBLwS!YuwWt&d&TyxD+ZF8i`>s@!>
zn&*AJy|+9%Q*+sMUrjEj(>l8zNqhR5?aEwp4U~Bl@9kcD_s-qj*VC>G+*md(a_bSp
zuFS2MPB~539^ctJ^Jla4C!T{p**G`OoUO)lW@c~i1eOC$8k0CQI-BZOb*XVIuoh#^
zNs`=lGjYb*{zoDKfh__df&4R=*sq9&l)s$0?RI+agA*48IeIy63vM<^OW_en`<%O3
z*vBR9$V`r##)%y_d==GvrF?vO)iMQn)r1U9&P?by(ra=%lkKvDXQOo5vEGSh9+%ZF
z_%1tfbJ@)fvojZ)jpMSTbJs4dU%GV_0|R%0l*??7$(aIzGbi)R=H1MfU}pYu^XCme
zog|qZ*gQS{*6oigU*%Rj_jTUq^85<x>Kk7k<+kqo`1pAHvQw*~x82UoJrufa+wHQ6
zqCq*+-fqKM41~Ibx`aOw2?*Tz&-(S7MU8LdUmfA8U#{}WufS(T1e?U7kVZ?9Ig?s0
zc&%D0X=nTWoc`{G%&UI#%f#<}KQ%snB~$s@N6asEzPC);l>6{Kv#O^W1B*iQ7td|C
zR;}8{r*`f7rRsa%ZdZJK+@wE2?d033;m3v3?}5&XZ}MFU?;W9ao_Lv-ES&ynKcjB_
zg&Dh~b8-u<J-ae;OKzcdLBQRmukVXLN}OMl6JXTa#dhO<?DKgCzrW{*^gH=vmZ64M
zk=t|4oQv~S(@$&8yQ!I`BRBQ;xrzeidqHk2a<VCFw>^(zVSbq}+$11heZPA5z3+P;
zH|cM?$<Su-eH*9^@L~F-LyYD15(}4If%VmvU4eADzOwx~9FQf|%>RX9RSol###as}
zr5Fra?DV@oL{9Q}zQ=!In?z*lv_v<FTBaw_@4kRmhaOT=Qc_BmI20(T>60iL8XBHE
zYwd287L`dH;1U@@{Mi~>2Ob}BahWJ6IQ`TCMxn{y@AFTWKgz^6-C+_V2h;78>E{nH
zicbF^!NkX$9i27(V<5AAJr`&>xuZaffXA8lwWTi12Woy8Oq}v&-jnwNhZq{)@E+Gp
zcB>Pb{h=#;#*}ThK2)W@x3E3%qta7CprUlrw%c<n1o-#n3%sj+Qv22V{l4#e3S7V4
zRuDKQ_YK?{ecZY2wt7GKg#C|qq1p4@qnzL1?!={BALq2}+_%{J!n|v@Z@D!q)(70z
zH@Stkk6i8aDoHx%_QGwqg9X5SW^gQD&dNX}g6W2b7!~T7KbcxZZaIF^_mk#4p=mdm
zAG}$AuYiyJ-ls_h>J6_|bGKW4P>}a~&%~hc!%}tLmq{KrjCm@P8JG;)_d<)B%}>LR
zgBt$vvKMO_&HQs#?X#F|_r3bw_q})3t{gGjcJFdlCbTOK>&Q<J7Pxi08q{O2KVmki
zZFVp$4NpfK0N4ud;a}gPw@h)X?k?$E2p=gGLAAfDwE5g0_uX#6{fI1H=KzlS`;UM8
z&42y<=ii^d@83Uu`?X-GVEAo=!#rnBU0acsAUQ)jYT?X=w1gg;03H}T!)(kOb*1Nw
zX?7@ta#Uha;bdTPcS~agsg<0;hG1|UWjJ$idhcOIiRqR{8F{BqJ<KRj-vBaMS%le`
z1;k)WJ9B<lj^c!!ie8qCUY37%et%T(T)gr7-lySrc;0>ezGu~s_uAmb6DV1Ln@_9W
zZo3WcjBaR|<Rs+D;i;kk8u?R!67E;mWzSk4B30mdaDfoxEf1OBl@@KM<W@fozt`Y-
ze0lxyiqvEqX9@SUw{ss!fOCnJP%=mK#=Nvst5z>NudC^uyKTzSZMVIGE<hXz^OpwL
zXGsldiSM4h-FABJw#N=Ck9P~aRe2z9=cn+Lw|vj4-#hM2zwqJSh3H3eHWk&e+pe_Q
zC@Cpfxs*(~<sy1)*Qr(O=hlBdxBI?@u>sE+W@Cmk2ap(U8f<AC5E0uucX#eCp7VCQ
zd0vqpul170y($dr_snrxCHB5D^!xIX#+NVeNmllJ<mc%3-F8c0c?&25m#7>QC_8e?
zYt`!K^UB`WJfDYTHrzJ1dJQ%WWr)q+i_4x{-k!VjT;824vbTiTS{md&KY1jr;k)-~
z_}yc+wfs`wn(hmHe0=!Y+ikCc4=E|BrnsH-UE&xM-5nab>h|vE-~d4lq%?4xLsCKe
zzoe#3KFc<zc3*DeoVR^HLxY0GxB3T$1q=*a2@DJz2OiXdR(UbVJ7`Q`n5v=W5Xu;;
z=r~y{EhuZoQWcFwE4|H@wA~1B=oDDc)#1S9rRcGsL1fVaMh2Fa6|4*a3mQD8T|02L
z8*Byx15*RTf_Nzg1_pBm2Ce{BR*fXa+Oz}OjL{LRS=er888GK)u!?$d)dvJHKQX9|
ze$4zpr2S%Iu1Lr#uggkatV*|yw(sj-d|*cH_j`<Y?=Zi8_v8Eh3idKNo(5rw-xB*a
zbhtMMADHTuXehzvJ5_U4$Yq79nauuKOH~;dGK8v@Oj-VFsZ<7=!>p+$lU3zcu1GY{
z%JS5jeC6bV1M?KcSL)~7PMx{!v~g~IcWTD9D`%v0joB_n^=8g6S)!{L&>76ODo89^
zQD_;jG26^$pM%R1wizZ%^?;U+8B6Et8f-aqSvm`{yeukl#!4u>Im7H$8n>>&nGg`%
za%|d+G_yo+A7g2SEoWfsFI0oIjWbh0%hP&i`xr~>Mwx)@W}P-8DlxNlnb^$LuF7t{
zlFDvImpQv8i>jFgE|a*N9dy_`t9PN$iHnm=QhFs@yp2%TmVwrnfiMH%HEImZo($ks
zYZ(o^Dh$wtYm7mY!lq1Gsj6z~3tylns;Rcw?c#<dQ>I)snalt(9U1dVd#2^8&Rm?S
zGYve11}1oO0~cp*_B3EXEPlJWq<#iNPL|;;Lr+c3Ef=>;OY2>-*(6tWny064u%{_w
z4_G6FU^|e^z`!iwHDwc*h{i#mtlJ?uuCAFJv&1e21_lO(NTn`1HZ4kbOS05fVQ<j7
zu~|{N(qd~ue046JH8azRSaj4ipv7lPj;m|0&c>vTSx4Ord!lqs)pvw00<Fr*=yu5s
zNJ@1(wk23g#p%Y{B`1v{S5Dz(Tr1Xf<2GdVSjJ5)Egd!pnjEpVJ7aC{WFggUlTF2@
zc(hDQO;iJ&cBhl6Ia$}!Ga9r)YORzhX!X{%u5O+i3QWu_3=Rnm96ZJex?3hIO_~-p
zIcG}L#`=h^OM)i7y}hdzhjwRmvmIM=NNu(>2qb&B%(#`AyGUuR+oHu%y&G4oxSE`_
zB_im;QnwqI1XY`pMW=<CM%?J=xRP<Cb=8DbCQ06^8EZ}~S$1ZsipQ1P+M=6-Q<F6}
zZHf>w<r2BF=9GwL$EBP}*=lQ|O}e~t(?FAJ({8HOM+JEWdEL&qnsl*CId{@!rAbq+
zd0b77Yzd3jT)DE*akask$zc;Zm-Q|>+AU_%;=0uA8gp*oij7^}NsEq#>Eya~ySh#2
zxUD)X%B*Wm1cRYi?^-wIoFzd)XEUXIb;5EM`dppqtZi^9cbl(kuGCGFWtTFS3aQQ1
zIcYM>S8ZBUV7-!?ciK(I6=GANXX=UMBwP|S=`szPu<0hptdN8o2RAldyJeWGDD3NI
zDsd%E(4=SSmKiH&M;zSRBVo8|V{`6eVc(vd<YYC~8Mm`EZkl*5b5%9fSi3D!WZPz4
zjfpA3F0<7-&3uJIqa{G=_EJDgl^nfIy1b%17kOvYAKaRgur-*~aoHqo50?vDC+SQ~
z>5k6OUE!n_rPFqEnr@KWHp8yfD%s%k4|7*GEt%}?DIGb{(^utoP|8iCoSCL!2e)SG
zYD_da(yOa>Qgd}m*Hv&V&N_BFEA3`v*U6wsSw@PkIWAdi!fssb)QL`-WNM}}#beWr
z2@@um)h{!dnd#E8*>g*7wAd<dDJQjArmo#m+b(XM&~aNVb#ZR*8rIORYlhOv(ZOcD
zMw*&Sm)ts;vMG047VA<W)oqu~EHhi9rE%ln5;s?=AhGCZ3A1ZGqF!!3Gp=SF%ub71
zE0Qxy<+7TmNaj-EwA&#Gx1$U~b&joe<IPUG7;!t5cS(J8(9K-W9L|l|ysNHhMtf`%
zxfM8DW0S|msGG`Bmt2EHa<{5P-8z%yJ7wag>_pYHlqo_ylQ!In+O*kh*_j1v9jBa~
zbuG+uo5;<n&4JspuKI43(9V_6&dxZPyW;GY?zG#U(pu3>H<WG$-Q-SkyXu{xyHJ!Z
za9eP4X5dDxw3ETc^(iZEOy!-l?B;(TpQJ4t4mO)5n`NeE=1#jA1-_6u<d}D^o10E*
z?yRJnQEk2w25Dy{H(fflW!veTwPtHJ9BkG~)Qw#0lH%spm2=AIwwuV=i9EfgIUKsZ
zKBptq4lT<J&DGTUu_SbT)izDH$0_&P*3Mhm6`U8CwKd{daN>q-^?kWrw-#62<ZzT0
zyEnx&E7v(##5CutPtfd&n@M+c1I2D%?V4pQpmNz{%~UO86{Sf57kiV;OhUwTJFY|t
zMrQ>F=dDfx9VI6k8620p;@Vb;gB!OQF4D<Tx@H&>b#%q*u=62DHMjRTa%4D7)qNVJ
z9d%6M##M<U5i5>HT-;`wT%VJ>=r(xCl)!}+#f3aA_qLj8Yvh^foZTJ)F)7D!V@Q%t
z#A>lcYjP{1I<|dH4OtqxN8^+kM>OXe*PbOeImIs9=mv!)ex2#8x?#<go4T{I#V+M0
zM{JvP`>-3=QNh5DTe)Hx6I3pnKn{<aq7%(^)M&-pt(q&&x753&EW4duoa>r(&Ct!v
z&@<#zPsXvuV!oSA1#+T#T)Vm>*6v#B)#k!`h|yVd+rcQ&uEl~|LK1GQG6}h2&T&y%
z=|=9gkTr@qYBz3pE}58X9(Ffq*0!s~f)U#c-7bnP+|i_P;a;Kc?961*%xSAnOPVC<
zE?JXh6miUSQ;oLZ+Cv@nGrrvPIVrL1ib?Ovts&R?zLYM`nswx+nb;QHl{wy#+9@}p
zuH?*?^4;DzNs&n@%EYxZWoy)wd&)`@ZJ}GIT-&<snU0iB=B(b8Yt0II1&&|M37YZX
z;w;7O9S_rP=XFMgP1Bj|(YtN!Vv(eon>CL0WX?(z72P#;Q`>RpfU32drrfN5aB<@2
zPDv&ABNfg9Gx%mL-5j#*k<!^~J9yqOm#$oO%{c7Vrj093@vbc2CU)(h-&?gKn>D;P
zX8YV)ucOv;+Ot>JG&^Ei*s|Q)X)<R#J9=8q%$#iG*|}xn#6>y1%VsMXt7RN<xy5qX
zbeXVP#<wqNYQMJUIV!Up5i;}>=x`F48(go|JX=Z7?4p{l$|jeL%PEQiEsAEBQ=HUp
zshnIg&106Qz$7J)P9>F&vy1IE=Qd3_v*D03!@{XEZmc-AVN$Zh(Vm9ercF`Cjt#1s
zs|{CN^7NYRoO6wHO<L0gkU+#FuUxavZP_f>j2#;k#Y|TOdn(<`S+MNNS%s?`9hYuc
zcBTHTa#pU-rDO6zTcmp|`rLZ5yu22f_2e#Da;;;VVVIY1M0c`irjUtn&MouMS&`A&
zVPTgJMY^p~F_mg^GkdvhZI8;$l@pbgb(?HiG-J{wF=MVH$zG8PXLzPL9TAmSrPV9A
zCE`l1sKk||H8~MSl8%IiPDp!pQ%S|A!&lkU%iFYmCkq2la<0~CRn`T!3tJ8x=4`C(
zoH6^QXIx;G#<pFjPK9}0ik@}s_KhYt&JLA?y{W0XJEDYh&vb5`<>oOt*CeA?StV_j
ziF4*ev&|kEy~@7Z8lTx-nHUw|=>|S9ZQTQgbxtO^W-To(IiHtq3OYDx+SV@{GZrT&
zyY&QaJG!F&=4?;Tpy=$Jz%8z8rg>+FJu>Q3JChzYYg@3!;^43_kz2F1wR2Y-dz>zu
zYn127G0CG-rQ?!H<|3_-BfeV_eR#uGhD^>)TEr2gEN0S~q@txDk)oxOl;Dz_tSPc6
zCt~B4<YY~WH8UnBophBtDxGvxw71*UHQDFn;>b;EZ5spYBW`T$7F?SfwC&pKoJroQ
zo2E>QJiunaxK=l1bF`*}l0q-b3_~eX5w}&77DjGdaGdv;dDOO`*}iurf;57Zl(}5F
zToNInmcMSwrSp-|qEm7Y<tj{0+4gd4PM}YqTfvOd8Q1O|5lG^wn)NW@yh!vp>vX+U
zYuQz1xha}W@T}kDb4yrKIAxp1Eorwq(zmyYZI#Qtleg{xbJXip&B)N{i?UU{*}S5?
zS`v;VT$C`B&_2W?klUPH^^U<R?8-E6tvxa_3eARw^L5rvot(5d&{aw|aI5Idl{(WV
z=Pp<r=yq($qBX&}5nfKdI>y=>S6AF}itNmFP4qhBIVn@(_{!*dw>;srGtYEHdlz*b
z$;r4XojTLG;GCjbM)8uZ9+NzJcRX^tJ)39kYN?GYZf+Mlbv@aSFH@#)PVePl;fGt&
zdYn^|%$%K*%z7s{IINBPESfCABb~t`oh)i_<xpa7fQHFYlYj`uB@>Qa$uLN`)x&1m
z6Qb(mlpQk3F(pGqDN>4~o{6I;Bw|s9Lvm0~&y6)1D>iyFTr-uLEX>inXi~Q;TbH4m
zX;<%}i)(V)CLMK64l@<IqPb#W)VABX3wsX=UER*u!@#y>t9Otamr;^Q#)jOeF4MHt
zJOyQDcP^$~-D<R2W!i>G$)OV_XLt%nOG`CPSS=)RZ9@>-0)YcvhKnVpuBgAUirKMG
z#yTxD>tN{QOzjM_3(*l~tG1Y_-E1q)-IU2`l#<al)1Y&sz)XY5X%lXx98^>G5#pU>
zHaX2hP^NR)iQa9+zG}Axw&nIM)eY+H;B!-JkJ5@*H8nIft#cXALnCJwk7GVfN<O!J
zjdRVM&6)&eq?|B0Yj$?AaE_9apj5qpi;3GsCMAUw-)(}7i*jmmZoJ+2a@CS6s*O!i
z7ZbdhSp;qeCV);(Q(Y^@vcbSnBw1&%NtfZYz*#OypmWpAnjIIbZPVDMu}WhVQ?nFP
zvosrTuXNzzY?Hu6v%My;t=Oi+IMGexlHr!Xj71kT7R@ph;W=>XkVck^r=V%ph5Fpo
zt?SnvRnstCaB%BkhU}2l3I`Jo#u|EdJFX2#xb=`}b=FjGN#<VZjEi%Q2yDBZvv$=~
zEzwPiy=w#-R|*`AGUISsoZ>7Up~xJh*x;traU^ed6H}CzSAY>)R3O))HFK|?+;Vck
zY@^%-?E(dE$3j_yb9oosPFTgABked<>n3kKv+T{tNF8t0u8b91q}_U@d_9+3iPF+#
zyC}Md<F+GfmQF;MPM}DZmYJDyvRkj(l1o{-qGHV%T^Ct$7c{L>TBHR&I!(Y)N<~Fg
zQ&TflXX%tFQ>NaI+H&R)=e8M>Qf_M-ZR51F($EP^<7ztVDP?kHnX6HX#4$sko}{CT
zP3k2xRXMJiO$xZI%-FzXxLS%k*+k&VR8`MNEw2+26ByD|l6_Zb>Z)CqI5t&TQ_C&L
zXp*<u0+XndsY@pHELkb(yH(B9GdWVpZSA%-CuVdTx~4Mqx*c)J(psD|&0BSH))u9U
zi+w#hbR`$GO=(bCY~XM*VpHaplam#*ytRT{mn^BjF<Et{a!RA`8b|?{>!f9p<JRLU
zX)5O1apl%E7Z;anZ%!L)$EHSw2?|Cv@n)Fjt}PbhI(E@D$*gSK$xNS%=O$fME-p?h
zxEh_gC1a-AEx`?|7OiSpox5amE_1QZ$z_>l9yb?xTuPpHW5Qz1uCPO`#+uPd*KUh7
z`J5Eus24Mua?>mAlIoU}W6C+bvrXNWxlCl4nYMJT*G88OQ@b|YijJ6&EX~Zrz_dhD
zB3f~??xr;%xr(cEr)^7n(y4VNPv-6H4z*RYJLlXya(0`gRJ7=<hN(QQIV(fgu3ncc
zWs;HN;${+Y=4htQG;f!aMxKit|KuFp_RlQg_@vbr4r_MSPdU_Wv^q6sw$Iv0C%2rs
zsWZ*#=#;devtHM9uB^>mow`^k(_~w;g3!&*ZO5*h%`%Gixwcq!(w0*<)^tYBN}HJ}
zbmL-AQV&aXw8W7RSC^2a-d-ugp3@#vXD*9!xn<bIw07fSmk?JsQ^TolhO>ia9a(d7
z(@kxooNZlKTaBHQGt=tZjvZa?sCFqiIy+*TZrh@+qrEIME=4G*T-$bXa-``JmuuI|
zj$O&^U1?^x*6rA_qife>TwG-qnHbd;EE+o7IQNh2?y~#O-|`qa^B5dfG4fQoB#{DI
z!R4tq$#V&8$r#V%ZEq6WJQCX^QYLw-%s9+5;V_Q@XepXuTfL-Wn*?~NSnlpj&?GWw
zDVnFsC6AOgNyRqM>?zz7mB}EkB6wC6dEJ^K+~irFJfQV#Ad^i%+93vKLLE2BQ{{Hq
zF{txYCV4KIaFWMpdfO^Sbz`h+<5WOKcum6YsvXnYt}`yv^n{oVS{XMPv~CULMUXZK
zJ2^V<$+g=%O}D)hn(R1BhD$YfcPkjROy|7Cs5xEs79*FEvDeM*<pD@5+{_EsZZFEt
zy))}}xtc`EB#D&iiMJS)CI`&oRn^YDgNzg>NrJd#?+$IdduZF;lWiU;Yqu9nH|J)S
z2d{op&Wz4`7@hY7zIaZ$yp(s>+uYrgqw}7C*7EU8I0;`z$6Bw-yL(sL-Me7b<zZ=g
zxA$NF`fvX)#9430W|wE0UETmX0#5u2^f<K(NBG{V-4gOH*aAACA>$FdZ`-%qyYGF|
z+;H#q?rqgKXKq~REYNZ(cVW&JLk?fHTVkgnT$L@H%Vzm*x&5CDcC1|e0`Uz2W=9r?
zLo5KZMVLS*$?a_dxnXY;h`m6BccTXD8}Na3@SW+<-N}$+AHqCyCcoca`uF$8UmJT=
z8P;yP>Sj30cZ=?{MbJa$9z)!-741Ma&h5~1-BwIDH)1laZwT|uf2}hqy6UFwdpXD%
zZd)N|xv6aD2Ax3>c3MpkEDq%daIxK(!nB>^8tACHNzttfayuO~z$a8hryMc`9dws6
zZPg`#7U&lI1qeTAt8DXpe|y)zzk3lul$pCQXS+n>-6gl3ZstLQuCPP)7RV=U3gww*
z7q&(BI0=J~w1b>hm%0!lJ?XSzhZ9I1^`JWFxplUi^Q-rKK4-o2;r5ShXaDku227vm
z$D~l7Db2tDT6@OBtDL~V%mzAGj*Uk`N)&X7I(V&`hm<G-11Dsm+JuAy7gjJZc)(Yw
z39&RVDlm932r;ngFfcH1>o9OI2VG!ba9|GFz`($gz>pQjz`)QW!625!z#!>6+f^hu
z?XpHk%dA=Vcc<rcbad2ji&pehndEaorO8mSlgE=;W2TEsaCWLlwA-|>Yk$wVcq(}X
zXKq=l>Fv8DjfG``n~I?d*R&%p6IFw5g3679GZ<$`WiC4+*&x}tY_^$#uNf1^$_*+i
znHvOLeH#^(y_PL7W-#VtVM}03RA`#b>f5Lya5-V+29;2)6FMQQo$50pGPf;h2<kKx
znk}-_%`_@I>wjzs)0D|Zo+cNJxpg>sPFzY0x(Qwp$O0~dK(<a4^V#MJ!oopQX3m;5
zDV4>j2~vWAl}wA)ofMh6>88qMPZgiDzMh&+PE%CU6b(fV7&CH2MYDwJwoLL(10C1L
zR)6i<^;6rlqkgVV+Op~Tl4<8&>P$O*|H;35p)l|c!uYz)^YX8M8>^RodJ*?hebJ-u
z-u8N}?<W1(Rh_Z@_50m7Cf(ondwr7E{`lH^N2cws{T_E@Du}$Lvflv$*T28N`-VNY
z&VJtb`}ekYf4KVn-u8|0^=<3-ecjt#Cl<N>>>B-NB{9d$zgO>kv714tSK`=yvkg5A
z=Vx9lmVWoW_~NdRWa;obvO9Ol{Cf8*>;AU;>V04D9?bl_J$CNAX?Aa`-oBkT`Cg~)
zd~fw~@ALZdf*nUHFYT#uQ4-Ku+ArYd!7}0N=69RoPJ`B@MT>@p`A65jf1g$VD=Sw(
z<XBM0#n9g$7_Y9j2aVJ3zhEwtu}LwxBhTVuiqp$wERjux(QJ>Gecs#C|K#RN_0P8p
zn+q@dO`87m?%i8wt#?J8ta^TbA0(VYLqlO9Hp%mSHD)+Y^1S@>a{LxE{mNJ2(oXf?
zJzspedf~?2OaA9$V{*Cgs{VYvw$H3}^S*wkUDD!feu5NzovVKF<?4kStIkcT`Fi!(
zg}v#Xbye>xTrTn7V?W#=!|;HeL0!huWQIb4P_6o|>&J!WUVbUJJ>*f)ckeI#(d+M3
z-8;Je+RU^+@n>G_?8yg(Wf_Ai$6obt!=C!x_c-4k;B@Wi=(zsKfY~nH^-TWmyXW0r
zrbsZ(n|bw2diA`Hm%S`5Zu=g*J$vE#_44cay|3BrcJJGtyU)-1dTIEQcU7hPs`bvD
z%dE<Iv+vQ@+qZSOmz_JmSAO-qy|4amTR(U9>`n1c{`1${&U&7p#LT&A2D8rw4v7Vm
zI29(zEZJ1=8X6jQG&FSbwfogaC(ccIonD|a$-z$j2os~igxt0hOM)C#+C1OZ{C>ap
z^ZR{Y>$8?FVw!O(P$V$_+TU2gat7J-UknTk`d{|G-}`;%)6ds`fEYVADVAJj(m80y
zb#hB2*U{j>vr+*ypiAY=_rCwUPv+;_Ki~K1sYJG3_TjMI%yKm8mg>}`l`Ee0r~iCh
z*bIhC^gr+3J=^5n+w$`AY?F7dPT#d&Ub217q}#^t?}KOcKy!TG!K=YU>$m^>Hao@i
zw#?DXIbUkCK6%Z^ysfV?cNc@(36;Ikah{d4R2)@bxLjMWve(Dt?es~0ciB65*jSiy
zCOI?6u_-Vga(%Bdb4JwOCsVuTzUO>X<M>TeiGL6O;oMI#(^XIBu9@Wdf`^SmeUHVD
zCPPmFhvm7|s(0?Io-BI1wTY3jiQ{Cw%6vI?rjx3h%J)8TbXnxDAH>*Z5*^YInJe~q
z-@Dykv(L(3|9an~>g)G?#j}5~zhe!B1o_0E(+;7ameJ%xo(ilxRj%FLw0wQZL?;gh
z@dgG4?oaQ_dymK3z3h?h+xdLA!0+uF@~l$t_I>|u`(Q%dbIUtcZ-4MyUmH>TbNa$|
zM&<gqeec*+IhBM}J%fByF8S`fy+B%bTSLwz&ydL~pxd7njZ&tn9P(AUJ$D!5rrQ~8
zM=mm#svK-NIVr@&SLNZ$>e)5ZRZkY(&Q_UJc=u#c%*03AZhNXUI4B5kFt>Sb^WM47
zd(zX}*(_?FdhhZlJ=w{6JC}utk)grE)Aq=Qlf0AaE#@tAJDfG`LhcDA$6}Q(jew?z
zB#S_|NuKK6MW6<p3X(4uU)^>)zsgg+Ws*O~l1Zg|x0QS^&fR`uhNsGe4<3vP44Ecd
z-|w#jFAWZbfJjiOJ9kpxv?ofQnQgO+w>y|+hDC4aR9hyMd+sj7tz-4CjeL`qSH(R8
z#Z1h$TPIbTI20NWtL%oy6^BBTljj?ccgtM83;K^&-+bV{_wM}yP-5DqwL$F3<mj?f
z^WNo8QJHj7MZi;KQVqxV@^ViV-raZ4n9uQYZTlMgF3(e?aeMX7w$Gg&8@A?6@{lgy
zJtN;@N;mJr@XGpaf6ty&nPB$5+~8iJrkM2A@|`<XCb8X*S(Uj<f6=`;o;Dhbc@&yB
z6nG4d$9ZZ^@)f#i!u?R}bMCJ~l}Vnqd6zty^Ve(5%IkiyeYueDwr#&SRo;2JMK}G@
zeR*VZ?%Mq`RxvRhjo$}4Q}OP>J11Yu{yw|?<q=TZHama8B)=#1Q&M+;?ExE=clYR%
zGlhrYj=o-4X)IIlFzc?$1hZf7^wk38{@O>r{mQVPY1Ib)y}#etCr^|+T($0V?zUf^
zY9}>L7sR{nwV0H<wf)oz4zAUp1M9X~@35X}o4mhr+h2=Go+`6*bH7aTdjhl6>{k8l
zmnw6SbZ*Dc8IXUuQ)QCpwrlr2k-T>8t;z(m-<v|Gz1Y`XRjBe|QIA0rheCtFVc8oh
zzMN*>DHrrxqM=^>y4zEQci)?-sgMvgyM<(DJ;=G+FS#-@hJud+JYLRTtiGoF6=S-P
zr^@8qwfiP{-kH?1o%Kuf<xaKR(X}j-%2gKY9;_An@(AQ4M->N$2o#S7aKrp5gs!tN
zFK&14R<GOl<^_e_cT|}ZJw0|?{jH_BUS?l}JiCitZ@V3`cJW@DnwlkR_ceK1Y}bRT
zew{bT<F@eTwa4y?>AqVs8RT`@si92!>lkbpIPb{bn|$uCL)|M+l}Y~5TPC^Pm^(Mm
z?8V0XQk9v<-df!*nQXk)Gd^_hl}YK+TVCg0md?3$yGOur=1rr!o+_;$>Q`58`+H@Q
zCq!}Kq_nb?+OM|n0vqLb?ef}<JN0|-z45fVyJS+?j<-uD<z_5+9i4aVcAisy<L<ND
z-+_|S>#|9nw{DegGgtk%`);Rt;qBegxx8EXuBz6GeGl?{XI-A1yC^w#*X@kNHW6#J
z=#?rH_6g>j-QNXTF<F17?A^87&biK8J>y;XUYWc9%let|mX(*!t=^rTovH2hUhm6$
zuV*pG4c?_~+qRAG_xtPX8FRNaaDEVSvoZJ}@gvCAf3|9yMy`E;hl=bI8{2KyZs%;f
zt-I}%gTfC^p#THcmID(t9E4Q4Y-?;m%VhVdAM!Y`VTOWdytglChjsm?)A~yortofb
z&|q1R+r`EQK5wVb;w6JBb4~ykqlR=+Lu^xk*-?f)AbCaygm3_-^Nv=A9h?rgMVP*U
z$u~lc+w}Loe<HVi@wMBw8ei7#)ofqy^SIaKvagyVkJ2O;m6j<AlLa-4>n_)UK+Vt3
z_0Nx6etsI>FVwSY)oQc2N5VTn3s7>m&B|alW?<ks17F6$z+i09mL_Fvu-KS?dqUco
z`%jD${yokRoF&-NVv;M-bD_sYp<$v~j?0B64&{uDBT2??5<QN*3z7tyqzrjd1a3Gx
z_AWBJsp1)SYwFsyW@~e!)BiB=N!2@CVw>D;z_6Ktfp6=<B@Y-6dmf#^5ZRu`tDVEE
z&Ukfq-`avqW)CTcOKdaO<cclvgf4{@mQs~8?M;s4m2C0#RGD_SWKztPNK-Li*E#Eo
zx2jA4Es*t8*>%+PlBeEA-;&bnNuJ8<b_=~`o!BZ?<au_^b6(fUfhkuaP3y&cUAF`(
zr4`R!bk0-d*`nKXN|vd3Ox$X8Y1(bIElYj0GdF9UF^e=a^WDm2qPf+yW!oi1$LQ2q
z4ihC6r|2$9-Ly^DWSj1y6m3c2+{IxVBCf6#>bbEk*Vs6)YZlu@QI!Rm%8o0!PK2eL
zoGOvplc}Y0<8+###EnI_LuaSX2-@sbFR8jMb=I<^TcI<IwbFR5hRtxhxy576rfXf%
zQp=9yiikDc4$4|_aobicK}pj|sxu{*q;6JKQ^}R|%DSbRx@>8#+O$ij+I%M+nQ>G~
zV_UCacUHIPrdcbEGEUACHq)7?J7tlZPHLcVYRHM+EoUa1y;v4$nY<=wTe@y~Y>>N2
zXKsC7;0ATwT_TH@ao)XFbW`>2)GbrhF69XMuGuQuu_ZLaM66frwnFIA1wBn-W}2H9
zZPU(;je53iSMJ#bx2LWP+@{sH?RB18Ua#(Ug`>t<H%_jVx~8kPc7ej`Wa(_7gsaJ-
zt2}OPOq%T(k+pWi!mY_!hr<%1(-v-JTVu2;LObQy*7{EFEQ6?RreS6)b&dvyrA<rn
zIy-Ay&Moe=(<xzRw@u2KbfecTHQ{Qc<D_MhtAe&>U70PQcDr#h)1}2hQ)ZdzES(&k
zWo8m_X<dd%?h1qKOl=FZ3%*merX>3colKZBw=-8rZPrY8b(1F#)jEY;lQvIoS(2>e
z5|ka*+cPO+<D^OTVGo<L-FR{XS93hhRr8!V=a%tg3lBd}<89L}&v~n<H7T^<Le_<>
z#nREMOST24<)svvxXn2&wyI^-8q;p4Fk`<=l}jp@GKD-<9F8aXOnVNh?;lPmxF%~J
zdF^hV%)?oEc}k|q%U+buyc;N!T<qpz&AWSB@$%e~wRf$<HB5KZw=VbHsA|2sXwHl$
zCeQhLT_ta69Cusx(q*R8<lL=Zr<5kU`Di&aHAXYtx|zCZ$x27(tccAy#<}aZ-Syht
zDI?`+)*<ukS<k6lvx&J}w<emdT-LHY-06B&cS4HM*3Qc%SGrVg&AKqz$8&RY<IHPW
zw?#~)&5q8<;d5D8qSfl>7*sF(xvL>KG^Ep1DQcq5lpA7+8<f)|r47#i71_Tv-tzO}
z`Cnplm)(xe)#>|Wm$7zlE^8BSgpR;#m6!S7?eG6?{22;5f$p`*_7!%2R$YA0<0+>y
z!Bc@TYe~iS=qgX;JTtBJOQ$#IoOdldlfGv4n%(9p{95}qeXt9yO$|SA!R$yqbaVl7
zG-d@C+l}e>zVCc4a>t_3_we$)_wL=hclUvw>FwR#+jfA*E8>_M0=U?Yf&_MFZ!hp-
zbdKG<Wp_4s_(lAs&Lr=DDchpezfC$R_%~2=iC0_Gs)$gonL<-zT~^6@ajXv1n3~lY
zbd{BB|CJ84sR66%r(acy_iFNfHC1_~(83F=L@ia7^jEE~tiF8D-RRkzqs4m3vlQeX
z{}YYezGU*<^j+a=_#O$))z6Qw05$OPX6YB2y}Ph^_O?~}=jYqi96vwx?Yn*D=jTDz
z;4m<-GDv_4%@zg|h5*KIZ*T7|FVFqc{JPfc@Bi7;JQeDr&98-D^IAW3e%>rklUbg+
z+p_C^ug>>W*=K#QN`-@kKlP>FCQtnhcCuC_uXE;o@2s$4e;UHV8v13^hurz)+S}sZ
zM<%^C%R3<#TATWyX4S7#>-(!915cm<t~b!(C&(Zah-3f_^XMml4ouWfSdd!}8}rdm
zSh((phICSUA*X`|E8io~4GOYHR2deCSa*0a)<3(Mx~W!W-s@kvzu(_Jt+mPR+Sy;H
z{-(0O+Whvi<C2pLE@j<Z`>*!*?|W6AsvqxhUsP~VsMhx^-FM)Jkbfgv-QVAzf3KOO
z<$a(L$??_qKCss>U%qx?&;d1w`@u&)E?M>C`wA9@36RShV1sM{9E=LA5bvOQ0pWuM
zpz$}*tq`0H8o3=2j0_+)7o+ozmIdOkRX6G1b+py`alSWhL(G<^Q%?)<Y&w6i{)fqB
zUz16a=~v_foIIR74elaUj?lVM*2-wrsx>#OJN%xl1})aSm2<$@fB|`VBLlNBM_S@y
zV=iNZPm|h@hF9L}ms_`H>+Bq<zANz>tA0j)z3kaE*|W*v`<@!x%gE7NpZZeo)9RPM
zO6OXAFZWLQzQ_CE1ADCn3Xp8`duQyX?^UNob(nG*pN3zHV?VWi4dtN&2@w${P*m4L
z;@W1V^QrZckKL_z-S$mg>(+ise@fWBrjtt!rd-NReVPCGeZ!wszrMdVEt{+ES#|E+
z%c|13R?P43?fbs>y?54<JsfhO4i2I5(fSO`wxXfo*G{ZV5C&!RX`qa*8h+U9a<19s
zT*=wI63Y&|NhB^7xslkFW0ID3*sWf3!(ovdxe|$8NwawjecL3K9d2W8zrXEv*_&TK
z7#MiAu4drb#L^8qWp(#D4<Q9m#uEPX&g$K}cdyqSFg9RCUTSK>ka6aa<P2wHhBJq_
z5~8jyHs%bC0<9BOT??j67y==yc$sE6`hZ(DBK62?R4*_t2E`+&)x)%E)wNYySFK<H
z@AT<l@n~>qRQ|g8ebw6Pd%7E5^I4r%{=WBV2)}okcS`ty%FwU-K--c+Lmh7CP7np<
z&(P2SvlCq4^a2_%1GyUs^SyibciZC2`IqbYz4E<sJ|%xYzh~9L*ZI4w-4|{#TVL+|
zUQ;si<;$0#gAEfo=e@JuUM?hUz{Is`mE_|>-Wjv=-hvKIyqw#X#;^>wf;WwEW?KU<
z$om|iRjakSw`Fy$E-%@8?MCUlX@_^OnIK;o>a_XcBlnf8qAxsKCcave#BW&dA`-~b
zlPuws@!ju{(_sUql+aM#PkZ;?t2y5^1H1xO6TGAu%uGvcV1+DxZP0ALo;&T{w)fGy
zlb4q)k9)0RRqm;@@6)RGHIwhkF23B$Y<pLK<0GS&FV6eB8TKS|_<Wb%o%iUR1f!*B
zsI%IQJ;u*l!7(@e(nm(A`n~13ueYb}UR|ELwLH?S_Gt)z^_snx_F9*%FSos`&%RiH
zu_QPs6gdv>Di;#VIl$4hYJqwo_hw;G!dUM2?%iDL1{UO~`u|KrTjf-?PQZ7M1>3@+
zKX5QH_2)5*GcYhL3(@ZA;mv+8vLN1V!)@NJ21k18SF13wtd3Av$iy0)>*98p$#J!z
zs*=YFCABk)-KHol(NJr1a^(~Wn>aIMMWCz7Dow>8C$AG%u5G%t!DMaj2X+Pq20<4F
z28JID%yI{q8zAv)R=dkV_eq6p9Q$(XyX@Q-Oz-Y!&;}js$*RG??9KS@p1kdsHr~$<
zEacADx7U6?P=2oX;q&Ty=8)Tlh0ik_J7D*N{e+C${g|@adCxxYzRn!{WmcxwlnllR
z8O&;@rUcE(U~6Dd^{-kfG{MJB*w;`(<*S#ks%Oh(21bLRz@XVe70Z1511`HY28XEn
zYVijycHot&xnch0AOG8slL0F|qE@T4I;r|drPcE)3j4HpEelJ#blPXl*<~}EmL+Vu
z%<XeKpmVC%lx-J52O3Tk0j*pW)l?1g^2(a!*}yx?vw>5^W2UytM5RO9LJS)i%$Ow@
z<a2e;MwxCkX1nckaO=j^Zrhe6+|Hb#8+GR3w#x=NQij_uWE@?cmBzbmW^=;D-fhip
zNrBx_&h>6W-Ju>+veLXZZS`1l<L&Iuo=JhzB4<wZ*>vX2(lj^E*}}dmvvX!;su-)y
z@-(|?a>;Wx=dww@+k8zX-Q0EZq|>%VT4pnow3HTStT@`8DRkRg=(gviL#ItMH#Mh3
z3(Z!#<(bo+wQXgts<hIrwX34TPHYP?bKT%MquXH08P}OX^=V3HIL^4vy3Ka9x3_D-
z4KrP7E|W=Tb(hX^a=UWsjI`6Ou3YXU?~G{eRNYRu3){j@Me8oi)yU<}T9oE=X3@+E
zn?+_$*sRr-qH{DY*|l3bWmCkJ2wlxhk-C#IbFOw71Y{-6X5A`uLwD(xX;%UlT%EPq
zG?i^}qT^~4p97l(eGb%bR+-tDrX|^!HYr!-rp6iRYzfebf4SQXqHY`wNp{m(aqJqH
zy;fA>w%E1aRfdbDE(Z2)+`8>jq{_By!JcZlohFmaZhJ17oa4FVq{$3UlSwzXEjHS?
zQPnI{JIh$eckMQhTN@&_x*c2FbnNJ=o61=Sld~O@t}V^=o$4E%P=8U#EThwG!WkFO
z*|~yhM!riJ1(nlI-4<G^Gh25_Z`bOKwF_>gtyT-%bgMO2bc^mHX`d@+eGYqWQ}UQ-
zq!KyFEos#mVWVVY?cAk3HzO`B)tR-a=g6(wNo#wzw75;1wk2b0v}jIfa_%-KWw$jv
zCNnOoc+8aYnQ+E)cCK=+kV|L1k=yN*Rkz)^RxD0to6xx=aMhI7X(wDREoR%;v~`<7
z*v9TC!z?GYSv^^XE6yloW*l8?Hal7D=9XhOGgtLU-8j19Xii{YZ`3he*Nv`jW||zc
zvJ6)oTWrvo=CyXEuS&y&$(bgTQapv!Tv}!*3c2+z@|bAEX)-BovZr#|rA!q`wfe~!
zlT>_WO!n+FnK9W{#bc&Wri$5QPqj0Lv%1}GtW^|tx-IH<>$cc6?ToEXf<_ltx~<Vr
z^Np6;cB^Mu#;t3*TXGXQW@g;DwoT=R$4RqGl0q(>#)e@DX|9o-##$+zN-h^C8ToFT
zICDvN&ap*jRkF?~Wp0_cWn$KCm9PsDw=S-#?^P7a%(x}Z+MBs$t*6w5h%I7T3pQp)
ztaVJfX42xBv~8oHa<0jYiOXC(drc-PrQ8%$JJHE=OUWmt7vwLc6qlZhLO0GVyX70H
z6?9sg%QPo<Wv|cSTt&fczG;^(u64Vn=-YKHD=oll%G#}FXFP7ZWE!b-3afdxv`se7
zWb>%cn55z%lym8}%xuFGYgaoXA9mQB8wn53rHjRSZsqnwr(Kp#UAD0~tS36-;OdNn
zQHvIfnRUVAC$g(Y=hjwJX%&@QzA7_?TskKzs&TkXTnq~1CSR4=$u1L>QjUNQ9Xm2B
zQ_1DTWY2nq$({-)O(vP0G?|pUmA5nFw&)V2jOgUt9L1o^+FYiIjz(Fxvu-X9?Yix{
zZE;kKQtHyJMvc*F6DQ>^0eM8FcgyUwOD+?Yb$pJTS(d7nqH}0XmTqrki?7+yts9qk
zd1$AyrbR1j&U89<?c&-MYuzSv>SUSSnr$*;;+7egJ%#Gke7E$@_ME8V(b*}fY~*k$
z+2rV?HB&m5buH1(RutS8?c40TbkR!Q5Gn0U-mOctL!@+5l*~?K<g7ZCJF#=3%85xT
zJ~I_uCfr=)F;VT7O0SUH5l`NU#sO7p4YRh*TH~`R>DW|niM2Wg31?@!nL-&kvp^>$
z-WEEUa;bjVmXt$Tm$FXtNEqjMt4?;i7U(*4nrW&~3Yd}Pt2lAVEKie3nOknEO%}@J
z=~cPpxn#2MVv|g@NxmwxIG5a1>s(?65p^`#oU?Y*D!0pN$8L#qU5R#@n08il>B_CH
zTQtRTE<|RfZ8Y0-#mIM)hs$iW%b8{;6@}6+)jO$pZc38&<d~=wanpBV?pjF`E-6)=
z8Q0t#gD!SNC%GD&+H@%C(1tUoB!wbpDyudMPWEl_k~oyiwc(UxQ+sG`csR@E0PiFv
zP0cMrmu{=AP~Elmj><A`t|j-6YX?p8+?6XR(4uA@Ch94aX{5Y0Rb!IR%T3ZtgVs!n
zu1OAxW~=vR^Jeq9D=6sc+b!7bnJOe?;`7yMYNtxRL`R3SlkuiW(yFt?dN<{EbzIEU
zRc)N=sIu`^tA?lAT|<sujtf1l+sdw7%DQokccsp(BT^l@lP39YWOeb#nl#B<t>cR8
zrl6<~A#RgA?ixxdD+)9TZqYe+Yju#XMNZ+yIa_X+U5czXyV#v9btzKYjkm`mchX7K
zNe5E{Jax(zdI@=McXQ;pC0$W)W75`)_G#v;xB@(NZr;uky6qE`lQcP5WJ>3hO<Oh!
zt`?2fRyop|B%K@-HEH$1#iA@yOD0{4)OK9d%XU;+W!j`A+p<hH3#i>VE9??*Iw&eE
zQd4Ehk{f{%Cax+|>jl-y7J40-WZvWA>}1G!YO|*AoZA^jrknFl9h!1eDdNV})h1d?
zHsvNAU7WNrFyczCXQZ}g&a@i`R~%`(GR;$G8gr21HkC=45C{7>DL9!q<(;{5Yl?Sn
zLBukhU_QQ}ZL@CN&dBZD$kujIb?KxflO{!b>*nSp^@Jox2CS+#4dXOvndPW9aZ}gr
z!042g%^FvHyHi&A3WRWEt19`bXNj!wR4zG^(dK0AbbH%bN3YD}pibU{i<K)1W=&Dc
z<Ll#ka8c&!mRr87Q@04^s(H4vDT!<ONhi;^aV~0eD3h<wt)?m3xoRpJSEp{3@^Njr
z(vdsKQ)fP_OUtCgGQBJ6bG<SRy;P3n>nz%&=CV}NX=z@>$;D!exEVtQms~XR)wy}A
zX^N0{;;Bi;p89UpY?nUVlF^c(B*@~^DaCQ2!zCp@?b^m^D-sU&O!7?GbYois1E<O)
z-^Do$44x{Ja-|a(n1Vc&x-vOavr?i{qFL80yE1LTwo{=}hc;_YN}D)!R{hkOK9fy)
z)^1z2=BA_CZI7ebf@{SlUGuu$?4~1->#4eAQ&_XB<HoL*NtePVaf|Va<eb!24Z7$h
zptf;VSYTL_laR|K7uTtw*KS8fr)|6T&LoLLNoP_>$|9Xmwq{SYH4;Xi8Qlg4CwX-&
zxg8y`%#dr@k&J9rZ`DbYqJ3wj=B}teX&lrklX-CB#U08@GRlrD8Oj;UbV9qeg?Ww{
zYaNu7GLht!PM4YD5$d^i^EQnz(QVUIR9hl$u2|!pbJjI2(6^J5=d7!wE0dFH%&`km
zOE%?h%u-sM<sFohvErJUuGGv`msL)(%+6f!phxnwHdo+GuS{ukUN5!GB@=oV^0D*Q
zpSfXaD(UO1rgF<|a+2DuPL)Z=Zrt{a7EIZ7>Q38<jw833B0W8&J%w~`M$PcgI<eGO
zDPK}h&}x#Bg_5Em_f$3KwqA}S>(;H^wKVsc!o+EADPEmRJe5=~c|5qd<)&rW)zv1G
z_*S|ccglG1a641R&Y(OCDKm$jTave?Mu%;g>{-7<_m1kWbq^K1W5Z5;Qc{{UX$7Oo
zmZg!EhH7h;bzG8_E}p9P;JKF9N()6sNwy^Es-s3dYqxCn+_Ft6=S;>eFPBZmfm5ce
z>B(8M?9?eqHE*e|GmB;m37s+8v{_rTWv1ea#TpAdJo_VV@vib#TN805tE+eF*2Ph0
zl|4I|GPhai)K8dm>PB#9OM!)7aB|VDwzVrJPU1A1aAL+PPnFqONwZbXe2@|Mn(NaU
zE@X7ZSS@1Bp|lW#qY_uoM(b=0my|g0L8;H9JS;_6T9U=gh;zk>ON)~gX7%*ynB3-R
zneDmAQ`mFMER~67lU*jM%vQOmGAU=~mP^T!9;YrGoHZ-O*UYJ2k&|W9GTx;cCd+zS
zmrOb_S>=+a+|_AI)g~GjF3yy4a_gMr(Q#xoQ|<~i&a6p>OU(kKJ;JVbrcIcfv37-!
zr>bsd(2*?VEH7^dhDn}llZ<>>)-G{zRn_gu)D2JKluU7Q5!oc<(P=U%FX&3pWj@}H
zYo4YFO~-`1RU36UnW7%lPn#$xGG)rr04C4OAXTNMnu~NMsrU-z39@x87F3xs&0BSa
z&}{~l2~3{ZF+$h8ZskV1h+Pz08M;E~)IlXrW0jyuR}E4pb{M)G=nOikI#p*<=pi4m
zm8K#~CMgMJ^0BCO&UqT@sm_scp*Qw`%JlF8PSw?ATO)cSKnHwFtKIgj_e`7MF^N|q
zFZaxvX>Mm{nauK?bScX_IVd_{?bI!9E=SrXPMI1g6ty{3OrvAjSt(z&Bhg7JtCbdR
zQcTj!>@rH~I4HDIh*RyNlE)<#PtP=;4kZ;;uSieNbyvd{Fii4PRhqI?NUdk>OlP5E
zw{M=Dax^uyW6?%Yw~Je{r9Cw=C)W359Z<~F_KcczDc7(kGbm(su%yaT&lS94DUlO>
zdJfH$Y-?H=w06ryWnUp-msOEot4=8?FmW8!R`HmqGD&xm=$1_zIwzf(;GMfD?Sx>)
z#brxeSQncJnDs8Z#LOz~mZ5Y~#p9%r&x}qXm5GxwCwX)VZrPTZlhMf(?di%h?UZJ{
zfFMiDj9W{MHf4g2TXeW(Hrqo<Y2z#o!AX<0Oq+7D1ENbv#p}#ulg%l<Qv#=m28B$!
zb5!ES(FH5kPW3ry(lX0;$)$t`hYYq%nRDuf#f)`)B9B&`)|q;&<Jl^+r9nA2C8aeT
zS30M3atL+>=PXS-(wWG@VUm-(beqx2CH0p)yL=LL)NXp63R&VaVc9a5%-l&DsT{Ya
zY`Zjd>uE`o<Q&HY?VvDk%}kxC5jSVV1ce;B6x1hfnrxgL*pYK>vY~0WV5*Z;bavQe
z-z7(8xvFlObmL-=n_+UMZd&BD?5P#G@85s<^?CQ+yYH>uSKklP3~yf(s`X|0s>HBv
z*U4)2tIe)vTr*sj>t+;bHtSfFr0%pf&!w9#oYXmOYHGrps+%<H$fjeH1GX5dt<{~@
zrm}6b&Xp^tdQ1b(%ywLplM|BLyW+-;EzzKxXftkH^ayhfnXQ`Bw$fyFPEN+fEm^%%
zCRsYCGmb`TPFrzo%c(^-jv4kO^>&No<YbxlPPnGYTR+8XTiD55-PWW?9icPZdO~L|
zx$0(;+qI-Sb5?4UnU>kHl`3YFJdM?&jgD>#(=qd4>2+Oev}EJjjLuoTsXRAV@vhpo
zaHH5!*EP8tx4OFBFzs2U>F6|DH__{MSmIW(+b*G%tkqr9nqMBbJkSC<UZ+J-NdU^w
zIV5ag4`FvWr3ths8iN2x+L*&hpha~CT#)nBB7vDLiX1*?&YU@OqD3u{!$}yVR%+|?
z3(QOg)AMDSeU-wF8G<h#>Pdo7$r49%l0gBJEOAWZn8q>Ptm%bD%u>_;EoL&EesCv~
zMug<f?PkyJ+@4*WmwR?0$V!j{x6N!hqX>3@B8T70usdLM_fF_`tI+MKtDZ}O9C0WO
z7r0v7oV5*d0q_B9mg(~KjL{M<s}r?uz+3`#qt`a!Fcf88_3!5DPCI}4(?9or;H8Q=
z&?SsH+c~c37izHPPJ0Nxa(9z=!Is85pmmhYJCN5fF5!C=z;)GaV|Ay4cJ8z@(7SW9
z)+%y<)WWaY3R?wP-#F>C?Om&X^>%VF%M>7t?HZ8#dZQqVBez9Q$=aP1z;#<UWcqnF
zCb{}ary0S{*mgP;FTKe-<$Fn3=CaATX4ie~oC3Ie&E8$gT@D$2U-1ZZX)mYh0^i+R
zW@p|6Uj%mV$J={v7M86m-uotJVcDw3dnX0#KKJ$Z_Ehez#dF`MOws$ix9siBB&YY<
zAfEox&~r7bo}HEE+-z23CaU}W&d=*HmRoeEwJCCf*J1wZh1}J<^N6C!?2KsLQ_v-)
ztDy9A$kI}{cUM5X?XANyUABo)U7jBiaNIXEK|%eE3$*_A8<)d7RfYxAr8t;mr@Qnq
z3W|fS+X+5zbANH@>bhMQKqFvG+fHpeFujn2Nw%J60Y_T|gOWi4XwfEk)h2_7fk|%z
z1A~V_LPiJ!1CwJj8(S;rWI+aoOJ)oVj0zrNt_}<g6HK(g9FYwyDiVrIau`6D2WvWT
zvT+;$t><KER0wJi;t_0Sc3J_llBH20A{xY)z+lY4z;K4yfPsP0-nzcAK_QhvKtMo1
zXbQsw0RaJ~Aoi;#Iy#z|I5Zd*u(mE>VBlhih+<%1XlUY?vVaA&kVCPxfuVzeA+pzj
zfkBXgfpY<)CiAN&E-sFYECK=oMhzTX3<?W4G?>&5U0`6~WYIBYU|?i1*Z@+?%M-%D
zz$oA_K|qCP1A~rXMm+-q0|y6(5EDzIR|A6>Xk}?wwAbZ~ZIGcpkb~J4a4;&cYA|r|
zh^B6tz{xaa;)Jv*4A<Hghk#@m7#Nm1FbFwJfSm&2$pm6+E?~^u0t%8D91K1z3@Otx
z7@~3+7#Jp~F)>IkVB!#B)nQ;^;bg84+BA)U!*ptg*;3HikqnHf4y>VWH}ci^UD@(o
zrE_!U&-b>Q_kC)-cgj4-C^l$r3xaENw}1I-d`;r7%idM)^B7oPD@Q(HQB)1-w-K3a
zANO7Ms;BhldyjW(t=up7-MY!sEUxnUj7j(B+m$}!R8hKg{PDf#r9t(cf~uQ8-+R1k
zrAo)7vp?S#-ks{Hy7|0yWuW?lGYn_WFw_+!%@h=roXOF#UolW((dE}x=DM}-t>?Kt
z6`VQAQ0n{Ko|@vv`L(je#d148RzJ`FBr4d^mEzhflJj-0=%w}5=blg8xxVto@#A)8
z-!I<SxpVKF`)c2h=hps`-MPc{?6>;j+NtmRYqmbWKId~zUGcu(XWv)fvpbrzYSoez
zT@$#=%RJTA>*k*{R8c<R@qJI<^SgJSet!HMG@p0-C11hK;`%M1B5@&y)3fh>MepZ+
zUVFFl?4@ge&WQG(Iofc^!v9`mQL;hsG1KVJ246duoKF&Zd91RV-=(tpE&H>x+qYk@
zKQ-@D?3d#A`+jF0O5gXr^<nMz`?V^QQ$c|pe(8Mmy-%Q3fpENU(rx7RpP+aMzZ6~1
z_N&aw`Ps@_b5*}oWxdFW+x+;-I<wZ-RsIvfOFZvQs;PSQI3sTRlKpYJZamJ2wmQG@
zMYwa)*D0^-*H^r^c(?iUwRhjG&sneC(kWbLYdM#<``XP*=huT4k6ycZ>HhlIobt-!
zWo~Z@%I7{ecb(sCZyvHLnSnvdZ~?=9J?;daWQp^et#;46SS)$J`kc^v>v^sRnl+9p
z9GJd)ce%C5KJTZWzUh}dyl$>ptv`M5=kl^YjX8`Bj6KW}J@pyKrf;^|JzIBawr$?+
z$jfE7PF5doE6$2n{q*h2yqAYJ7VW5xJ$~x@@tNoDm*3cR_u%c>3uNrB7k-;(eP+gk
z2|tfL3V2+of5$GgR_EKh$M;k#gZw?ynV*G*`A1r>oqNe+&1p~V>2<&NRp0xa{Bn`c
z?~l>txA*3D6*0ul_@3{Yy{-PX^W^+<@49!qieCWDP7JzYJpPKxJPMzZ4FV2amafYd
zow)tk<{NU4c>FadZsxF=aYn>Ivv<E~*HPijB?pe|DipIZG%(<p@;mqK_o@w<8|v!L
zw5|<Vzk6SO{Jt3(M?bzf{&nxS%Pr??6dWe0O!KUl??3+d12jsfN0>87)UR5#{_#uJ
z+HLXj%62uEbL-f4XY&0N_ubO5^ln}5(j_L__M3e!JNhu{a<0nl56}0$ZhE@)Zgu4&
z(evguKi{w8dcM=yJNt9Kc}`r|mf2;uZB(Cj*Hu(zdO50cINM53@_Z?~-B_>ip~uIx
z;uAMtp10t0@}9U*^1-VcZx{qvjvbe%?|$}OXC^C$lU%^P9g<ViQX`MIDj(U9JMUb@
z&w0GP{R=o4)XX3LGGxzSU|_mjY-8`{*!yyO?(On(hgR)9wPw}YRclwRnHS`#GHK@I
zT=BxY;c~I(&8xIyx7`wdURQZQAGC`8+PmG?-Ywr{e(qSUxg3PKcd>2JJY)WJU!mLk
zF4)Mec~g1!?v{s!+TY*b-w#><DqkNO8v63G|9+d>UAhNWMn~sfyT>>)x`36*>-Gf&
zDYmy~Zwqa`o#S-}w0P=u?uIk`Y1w%UQ#iHr9lkI-+}*i5DQtIcXVlwmQE#{9v*|{y
z0^I|wwy1Lj_;%hXzGuwuCKy{e<oB@s)bm;zbY;;2%g`w{jNKv;O3P+l?OL&@9(-Nw
zqS*)j7Bl{O#{9jcapt=&=A@?#SH&F!*mRsk4zlaAFi36X2ogxHGBY!aJGAN?+tskx
z)~%tFpT$={KR3VbdztLanR9j*m#-~(XFc`R7GuK(#tu)FNiHtYVcXvCk6(Yj`X1!)
zQD}l#waHVZ;n$nlQ=_AI)Tc#gs$P=HyK{G=cHy>r+h=SxlbaMPVgmKr?3=rDCb=t5
z@>Jcr>wa0f`T6NutF9WnPLQ0KnqLIkIkY#p)I7NMwDHUfH!tuUm{Hb{*V0mD76?Ag
zvHFsy&^q7Su6N4IPTx3ifPukDpkGn<-kWoiJonz7d-Qa**>j=#>vyzP9X&0kv3yaN
z=G%97&YX$aDX#nG%$cZl?2Nj#=iC*h?z}lkQziQD&O6_$&5I^ozoT8eStZD0x9+Bs
z#=f^*elV@tT6DB)#gsr-p*MV?p&G6t2QHZBo;f2_!@wZ+J}qL&#IjPTQpSgSFUu6G
zm!(Wjsmi;het@6hUj55H%SoPU7SH_N<UZ>1%{?lSA-(Nc8mAot1AE(dpTaY9Z%*=^
z_;Po~e1_<~GgBtz#aVY(XKpJz-Mc3=BxYmMsw#~|^WJbD(2MD=Fl*QvA;bDsD0z><
zwzAYNPw~{pyQ?yHYgW5fROFW&mpPf2sB*U-<YvYP(svDy8+oc6ua`M_w|9>Vr|I@p
z25@Kd^S+z$c&7DcPPI1>ccSwd?jbu{!E^22z_!NSd1(ogA22XL?7BO{(>(cd*+n~s
z?bSv{Rl0XYt3tdH8n!NCW2jJ<#v=b6vZ2ngQ74wMHKv9ec&=k$;4a^+6Xdab>841z
z+1ollFdwd71`3%&p1UFZ1Lix8Cx-ewsrzeo<oV9pZC}dEckjM8eWD<fczsOkOT*(v
z<!PQ~?#tdTs$oywz4!a8bfr}@PyGFr+i~>U&A!JDcefiGcz$4Durc42+?Vq1%%mJh
zaJ(-);mK2ZDL;C%=+44@4(iLk`?O5*RCDss@lARmn9KcYt4~;4z_Hu4PZT^~?!Bz2
zV))#1+v;t%d%ySlT5r~w`0cG~{S@6hx8K}-z&u?s>uI;R=8HwO3%9U}HafC~W}W43
zpSVk=MUf-+*tc|7^}I_ro$j99p?i-(Kkm$nB@=C|ZZDaf`YrDRV`$XQq@$-)MFL&s
zaae|iUStV$-JmDu_M%9jMKOBs%!{5%6{Xuf)lN6veZaK3>g2V{<zXp3+soq9-ZRw8
zOpV$ZAy~@&syAw@P9&2dYiQODaen0zOAaT2ow2Xgqt?A!Imzhm&4TDX45eVRiq~%P
zG}*Te+1fdLp`i(`B8>~8D#h9rIh;gy-<&HlN!{wU%4BcXd<OYNao!&$#mjlW&O3E~
zPEo+o%~iKHzRo)PT8Xiqea5U03f}k5?-y4J`E>VgXXewlHZz}wPrBkXFH|DUR65`y
z`>M>2Jn72kFMpN3pH}np^YeX?`=%b9S5{S(xvb@dzxT_G>f?JsYhWf-XU+R|<MEZx
z$AuSK$=)eE?g6?ixFLYk!%2ikrqD`w;oajX7cuK6OsQ|Y6Tp2#Rgoir3!#|l0Z4$m
zVM>dl1MF62MUDVFPsMApI####B<D+9`?xXd`TF(oa(m_WR%LJtE}M5HamJNgk4sk+
zxi7kkt(n);)03>$lWcO?sf6!YfM9av^U3FJWbeM8^BHstCMWD-#p$`dj2!i#%Q9Ie
z{LP-T^YomZr+zDR{OZ=&*s;>=rnAYa1E+#QbGOap-FBsMsZftc#u>N8xm`N5Q^kB;
zCySUGotUa~Vz%z8+Znnm({3Hi&P<Km+U=(6X4YuBIZQieSs0hd&4|UKO*6u{&Tcl@
za&2{JXcWs~<@yE6Y0t$CR)%FJr^^)9xAbfYmYA8aX*27gM@zzuGZq_6%UHBpsrA54
zp{~^%1G?6)3l&_c>9vN3r%TM0o3-iZrS;e3sw!W6K0nj!rrGVZt4nJ#t{>}N-`n+b
z>jJI?3<@lAal(IQ#T9?r-Df#z^_x2X)A5r(g)UoiduGa{_)1lW?<;07G_yXo-ud&R
z@x;)2pC`4dy9|01Z6%Hw&YKor^0vCa(s<&R?MiZ?wYuM85ZmeYHchbZbkK)%1rxyi
zRz?q5#CF0U_CgI-29P+n^~N>o0<#)1u8N-fK5y6S)qCIP3r*U0B=DoA=trgc9+uDq
zjajOqVGB7e0z?m~M7erRV_hlY_-WND(G^Ns^A3D->b|igoS|!-%c4~;nc_};x%hJF
z%cW%+ce`%93A6lD-+uQu=uFAt2S1h1`}<9JA!Qw3^6JN$3-ek)*Nf_x^(aa%yL-G`
zdCiSCU8{D!uaUi1e)M_E1ZXm-XP6|WoCvxX^+--{C+N0R1tI6JprgF!te#W-tNQb|
zrTnUOvp$@Dxboqrbw;;yjwbD$w<Y(r>();<g)<nvwzvLxHhs?a!sA9(>lfDv*{=P4
zBJRxHGrQl4&0Dd2GSk-Lld934Je)blWkf^HxnGK2%yCHgG6Y=mem8f0ec^kxBD-l%
zoI!r5I{o&2^%c-EIPlI(eMX1dLJhIt&6#_^`y3rW>%+J=fH#OXEXai|B-1;n$>G$%
z;Nc{&fr$Ym3AuxKfk=yN?EC79mU$7A6V;B)W-+h(eSdzA`FnofU)#z*7n&^LHmm<S
zb^DrS=e8`}6x6|38x>dlddK6LTKkUuQK^ppKJiIQ;**QLCd=O4{XXs8yZ3vau3gf`
zmUpJ`OxMae{Y$pH3AU&&UosC2rupZZ%{{(n=80d?6ZxzBtM7eZI`7n3RSr*$h~6nW
zU{X<9BVtm(MrjQvvw$^09ydW(HP>@^YB+huJeM<dpQdrcx67<c{sh<O_QU>d{W9)F
zH{Q(--nDJX%#S}z+GepW_BG*8y1poC<1<s~xbOUve4o#&dHuX!uJUoe&F4N}&I{Hv
z9b9|DQp=7rhi5KpfM3qa0*UN4A!kse7ao^+Zl9cUe?u;hSI`v3h0_(Bm?Xg`Yfis=
zfRTN=fF`rpbdO1ls#4Q7fe!6dQc{6lft(HDDtUBH-#3Xdles%LaQa6lCZ);$?(0v!
zaGwKqC$il1RY#emCJQ_etPi`9?DzTo{`j05b!K1pn!mdF{!L!!mL<8;HS=Bh7tOZG
zTEVZ+A)unN_hIc>eapPZeJQ2!Zs4$=uy@AaW%DkW#ARGtr>~uR_xqY}m;CPDsXjTU
zYgM}POWljJ1bfn#FZ}`ro2oOnyt93B&i&Gzhw)XQ{Gjvg``#B$^#T)^7@P!J8iX4f
zayuE+4stjNG5CS^{6hBm-caOla^O4w+7>Lt;9z#7K`2K^phZDC3A7=20cZm)OM{R=
ziw;ABK#QUR%Wsu!Cx5&+vmjM+ibVFk-=Du7U-Py9&flezCUb845?rNmZ&tt1G*wOS
zggL+4p6`!eU%&f&QOc^{(oXJM_p3&`?@>PC(E8HsS?sjxd*An}?7QW8dpD@G356Fz
zwklx%d_nS1NA)F;YMpN(FPvE3!53MAi<`H7Eed`w8T1oC#SRx{aa0d2kCN9YGVj7H
zj~apmS{B~B=dfqPHtxh6!GC}M{qOr{Z})$`{Q3Iz>)-wU&yvGrCZ^J+oDwmKQANk?
z(2)t8iXAtll~ZzhCvGxxJ8@I`FX&F~BNJLC+?d3uqNrk~(%{L#z%qgDguzWVm6rNz
z+itH^$d1nOWRAL>o1NQPdiU;0CKm>ePVjh$TzTpB*gGoaATw@VJE+3s;lS8-A|j_v
z$U&vKRD}uk8el_d<s=VCb@iw6<kfTKp*bbXqsuOxDw)<e`NyjDRe9Sg&HE)!{5t)1
z&A#fnk58>yRljQQ-Mgoj6=|)U(|sZ(G<^5YkaPYvpI6)fc}!Y41w=7QGxRpN9fo_!
z;`NT#J6`X;mm9aeH@xH4dI_s@FH_pyt54ImeR<9E-MqGav$s|i-?6**;OD2(&+F$^
zd_FH%`7V6r9Y5>IYo5O8I-0ceorPb=%ViCo4E2+cuabs^%e!5#ckjI__Az%|#_d_U
z;pOvwR3>e{=HXwq@AZps%Uv#2?eaKQWzg~^Sy|%byt!xm=H8OtX?2d}%p^^vg30WC
z37c6I7&#c67(5`S<|;6`cnGodS8lDkXHpi-ceLzO;=TCl{nh8I&)4sZnD_GW)-TrK
zi!yCvRlcM<RS940=}A_WJYT%4T;T4>Yei+QNgFGFp0{~FPk$bGwCd;G(hHmlx31mr
z<jIbX&fRt+r?u@wqKb6X?OT@VYE?O90dJPwoz=Ye_q*?BLg!6#s*ZhYE31(4*7oxH
zEfaf=t`^e`)L7J|@<2e1IkCRMqf&AvYu9F*Wykd$Ze=dJox5ySZWD66O7u?LsA2#P
zr}{MT5<r!o9aj~O9=Q!&0w|x*z_9(w?v6D)$KNwBC@_d$IM5~F8X_PN;y7hn&`nW~
z#->HCE|biz-N<syl~@_Hz{_jfu^XAa-N|VV^$S>*s<?Ux2#J_3ODjDZ!wWi)6Fj1@
zhy4(P-8E+DfL?9SFZSK}yA|H<J-91vVsgN>SxHQDH-Htgms!YeZ$Es#f{*EXd+mE0
z%kO)b-@U6T08273em-ww_x*ki^L;r7KE*dr*9lse9>}T?S{kf2i%sB2J+m+4<Ww(D
z2L>qy29}lYLsc~wFi0gbFbGwxn7AtBuYZWGLy8mwgQlj&<Rh6=q@=25F&tZ<l{Gm?
zrBZ`eqHzJUzgzD7_iv0Z=dV2KGnH#fYjdb3x9)__VCb=&mkn~Iwq$KK$W2SQG+_&P
zao|di$eb3h8760>(s(UE$9H<TTn_AYGnE9d7rdNsu{-Bha?X~^2Dw|#NVD}gE*8i*
zB4x<dle^aEAb6Eu*M^KU(>KdAshK4OPL8-{I^klAk`rt#SLBQ-Nmtr>&SZyly7?wY
zTyu64=!7pfN{b5ey3{$nP=QIV-psRSGOx)c&&|FjlTwsCPE6udauN1agRU!bG?|og
z*;5T92c<lP)O<XbfL0kTo224sG6A}5aNDiSC6hr52?bR=W*UMP(-^AF@|ehS$thFi
zcFJW>-Pz42&ZSjq1WsD2vvN}_mxxB%vRm7ha@8A!ES+i=u+XXHT8mQZ;v}=9L6?p#
zJF#tb%1txh$tjCddN+oOf|iDDlulZinVc)OCb!#l(Z!4#w==eZG$bcoGrQHhtvka>
zEy~O&$jKSBa?azX!UPW$A)ZTSmvWUH6(_2A%v8w%iEtXLfESH%n)GB!sH9EERI2xw
zXp++8t1LBbjkMHej#)V%kh@yy#)cfwYO;+W5M|QhnXt`t*@>%d%dU1EP1+c7V{ODX
zvm3XioK!YMOI^;4xS9mMsJUD0mg!;-muWg#N4G7y?FPCy_Q<4Y)zvynJZ73r&IF^J
zOyf)`PqWEVnMy7vx6H2h+%ns9OB;BJ)Rs<zO9`I6YB$wfCMv02QaK!)yJX`MrOd?{
z8<UQ9XC2MS)XC(Sm2pcaVq?-JLFtrhxw_ICrfCbETDhb}4A(>_d${CIj@+^(mvOZz
zmxxAKSkBr>6Qz?~Bd%S^&bZ~Ix^0sQXw}$cm7B^QmrQz<lRa|P>R~I^Hn~k)k}2ip
zGEvE4lEWoNg-dCjN-kZKyjH7j+vs+TS5eqwaaNEh2k0bB-|WEVP*7^^a#EYt6J?ya
z&2U?;apszYt8OM!b0y5S^+bzitT^cgPH-MB8?IgKP7ck~a=VlXUeMLaX{IRTsNyk`
zWtOK|{UkNeQo&r%(!nHOMbM%)C56eJ$}F=y4Z@^yLk<RHF6mYjcFELSlBTkD!&J>|
z(FI$yxVgPWC+Q|^WV?0AHQO;cH(}!{C$%hH2C)Sjqa#fwajKl0C}iR(q~^&hsO(~#
z(aGa7Q7N-yl8MU<L7^MkW?I|UPMx(aC+v*N)q3BRt4*1<<=oWVvO3eSD_7IlSlejk
zq%%t+n-aUuIO^Q+Tsb8x?I@eK>9V6+!%q4xnk|~cc4e}}W?_TPLTgUyoDfPg+8S^+
zI_>JJ*_;ta*GlJh9n-pXQ)kktWvQVv)6%%ioVKalTAHgBmZEL6BrVr8W!pB7tt)h*
zGflU#Zd6UKmuxlcT9a(DBqwAW=N9c$)wH0fs9THKwysH7yW(hX=IY?U*(S3*c`{8V
zsY-K2Yne^iwrc6jz_g&=Ro<CyM|GzLow#v{w=?WmW?*Yr*x}Grvz&`6iHp2>er-v)
z?He`IG-_eW#hGEDZE69R(pKwk-4?1dMeUa0<m8CUkz8SH3+uZ%yEdjpcJ``Vax^kA
zGP^7#(J1A)WVWZ_;-uV(lYK*tPId>GoLFOMl)|&d%X^jAsY?r|tezaSZq}JC2X-XA
z*m<Vl=)SF7VJZ`M<ZSzNGr~K4Dp$ZH-#und0-sXTymO;9RBoSY)fV!&C#}e#oFwOE
z8Z4x8Yo?oL7esA6SaC#NNT8^v+U>H9!EVV8vo21ET<prTS~ciWWXhIFUO_n~$!tf0
zJTrBsvUc%Gt4y7AA#lOPlu1jrJrG&rsa%mH(Cl<xcg1Seup38Mn-iQlO*&O3dy6c)
z>N`nABumOC?9`!Xn-xJVlX4$UaFSB+%v<Z4Gwart1m30tZS_~Cd8$l08Q7b|Gub=W
zXU)mn)u}9vhn<}SC54Trt?df9l*xOT<3?W8)R3#uOj1iW1$nAYPU4+3HBrgaWY$bK
zk6TZ*mW8fv>RFsDu*EU$qQr$;DN|Las&0zZRNb<9(T(nuNf+METwxSBYuhP99no!p
zoe66<^?01uI(5}VAY`^ty|-t|q?-|&T^dc@a!dkFUGg<@@l<iywqljagjJy`6JGKh
z*U{W$8l7e6W@hNKAw=47&E{Y&Z&lBfZQiQhx=UyAa^$K^3cE9F(u35H8)n`{t8^zt
z`b<{sTIO*_*~~J-ts~S_aN(9|lLC!gCX3y%P|EGOGb_yJ%)?VUp_hBkWYv3{tk@Xp
z6`j3W(j>`uQOMPh6HUsVi&AE}_-^qHndF&fX_l3&a&tvij%O>cZ>Pb+l^c~4ci6}%
zow>U*+HAG4!H&?z#6_GJ91k74vtjL~==7;(OSO%SVnvf?B*pSrm^eKtb2{B5y5_V=
zvW~_*fugj4u(P_eHY_`7T(<1W+AWjnr4Q#y^6i+UY^C_1x5IH;!NZf5+tRt_tlF?}
zlGlTtQ%0L+&GyJNWi_32TWWEx+N}@Kf;p3}EWL4RcGwZasou+uo%YI5xw=btk?xYo
zVVk7_xm9(aX3y?WNu4-TAn2s0s;17Qa3&5%76HG|tyyPP8V{!^yGWU}m<TSElFppH
zEV@27#4R$-H_9Mzw&BXKX}6V}a!qEdT%4A*B-LbgfWVEM)!vaROE-C^OkK9Y>ta%_
zgX`94XSGZf-zBp>C9_%9im6>;F_YH1bXKKv%j8T}v*0A(-nqiYvqhs#wR0zV8%Rg=
zZkyzr#k<DswwJeI=;okpH&teAk=$;PaqJ+An3+KRGS5t%X(v@DB`(^K6R}xk%e2kh
zV$E)wJR@}%EY2_q^VIUq&UIT8ow7P2aVguBPD#~CK_^w#8!ls=;_l&6DY|X#%1usg
z=cJ?rF7kBl%vp2N?CudEqZ2J1nkkDsI!z|o2u?Jfn(K8|W#b%W7bBCD+@;%DX6UGP
zDS2voO*$E_RsWp9Q@3d60U_1UkVyqiW))8sr7-GjyL~dLJ0~#PGh@mr&6$f#T6!i-
zY&Gl7@;MUR?0RrjZ@9z?9cgKfz?^9glYCV+`c9p4<w)CvWt!V2ZZ7bcxX4pUWs<U2
zprVk9p~0b4*JADzW0%cbt|FQu-i9s<x6JZzX_?R|bSltGGpgQYmivs3Ua_K6xlS{e
zoaEghxW%D6xhOT+vsL8QwzZoQXY`2$o|)}At6k&qq|PJm?98o4mo*n0GJAFD)>fBG
zGBQs+cUYd7pt>$}cJ4K9X@R6(mXK+lx~h}Bb~&U>3T@O~!^sr&#xSBWWqPvjva8X)
zQ&qc8-Hi0f6;?TE<~b>+{z|Z^h^fex;2aN+OG0NiXQi#VsiWJP8<eJL&E|S=#nPDM
zgc~|JimpMCx=SW|D*8^jaz!X@a_$k&MJkh&6;Ae~D`#cpx=l6;oYR-|BwR7IuVryp
z%<Z)3+?mWQTXRfq2pu@6C6y(`s~x#?O2E~eB@?AQl}sl2s&u4HTrx@7vtH$r$3#t&
zlx~%jqmxdBEW6e0xY*>_k({Knrjxuu3nVXHJ198GJ3`6GGq*`uW!eT2$w_QS&Q9{w
z^3>V1!6j2=#l;BG*`AYfrv)rcHS$?I)r)1Dmf5CkCXXA(Or}lFP~p@HT6S~h%+$yg
zsw-8dtPpBxoaLFiZO=@dq@a@ls*Uvu-Z7j!5|hrZ&@fzZ%u{Dl=)p-Vgl^pdiJcCP
z>g{m2DRAs|;3mZtEs2{Hdp&xNZB^EClg{<bX_=@3x{CKw&Iu^PQ!<o8WRhpl)Quvp
zo+^r=sUce?dAPYa&GHgbbK<zrb86YD=77*GQM`^@f|FXd-By__<T<-u<;bM8+_O8U
zPMtb+lF;E`w_Yh-(5d4>VJ6d#x^-zRy0~%E&6Js-GtC`^1&w?rtDKZnn4GHV<uP&F
zQcX`Gv!F?4i&WM^uL(9v)ireU36x+^=(u61s58}5cgiA<ODY}{l`>|DEZG#4Jv(fz
zvC(NBsY#iWJOz4|-43qjN?SWqaaL5hCTQ_mt4N@$m}b+0%|ULxrkWFdW{UM(@Lim7
z&1|+;O0vW;&51ox#*PuU#3tOz)topZ&ETR(wB&-e7A;NCX^FSIE=f#QIoaU>0+)n6
z6(+gO=l}_T*0x<#R=KP)k&|<gQ^rKlN;Q|3i@BQ|Cg;{Gd#9af>$vG^9OxYA>uPqS
zrB_jF>xOQ(UQ;FIOh@L7Te%7fM>jRGDY<!0N;%>&QSF4Ml8VQaLlMhTwp}q47D`;2
z6}HINaH-bRNop3R%}vKTx2=tOEXvxPoXDlS<PxXKCC?+Ci)3VYckpcHOqeFJILU3P
z!Njc^M>TG^92DlP7s|P$BA~l5ch&4%&Y80!HtJ}dG|uYv=~TL%tJ^7-=-G0tH=~<b
zaa(l8Bq=v1C1E2)gVxy|sip?5oAX#h&R9&EY;;!T*0#{Cxf;o0MqyH#nungP$u%>T
zIA*xmMHh6-ub7gOvY2VxWwBMh3)N<Oc7je^pR96H$jxQ8cX~bZ{^?)p?RS6v{a@2}
z+wRcq+ioZ4ZtBk6{;k1=f%#iSYiN$dv{lE_6yF~1><xMQSyi-@`JArU>d-|OHP^Cj
zj9j@UEOpkbqiK=Tva&MPX3RR0)|oqXb<SF+BfQy6mxE1aotil<({!q_&S{;~soO+S
zwoTl!;?iQpRlaIhrQLcmF4p%XOI*n^$+)=Ktyj#f*KOm*jhm#F+%(&4DmB@2+p&vV
za&mHweO9|2b-S^4%juk)kZ5UXmsz*YY&&+;ZH4c$R9&%!tJQi|MlRi&c67<Du1Onv
zCtXQa?U|;@yJ*5KP2MFpd6!&Ua%<)i@9c=%$vI)S!;+?mXlPtH6|p5ucjeNK+XA3-
zcXOq<wq3jZXLZ=sziXyXlx5Zits>){#=_(>-MNlYb^3*~Ogv0o%F|u-nB-ZKC5|ai
zUth;)4!Y4-8l;kQ`n6g{-RUchm=z{pu;Sqnf!(ru!wY=RuEFF3)~wUBS2J=?7jb8n
z1+!R%*0!upoP5wqhVRJgM6+uxtJ7Z!3c9!yPG4xmtTA0lj@eCc3gm8H$C*L*rysxn
z{Q0hFMoc;N?bYYCp4+@nnWCt&Fv%=nBbaQ-S(xPMbR=gX$4#drlUh_jlANl!%Wi>|
zXmO`*;{q=W%bf;U9tK)$w(iChrfsJSdXpu*7$a48M1hXX+Zwp)ZKs1aXiXZ@(RtdT
zQeed=b3upa)oZXqPtOxw1=YN23uq`hb&?j?l9Xw`JasqSpY=WN_1)@qv!9=z4_*Mq
z=;0*P5NC3Gx97Gwtco07jP?9wB^sb}40FLt#}q;G;k!3EIlQ~1(yX%WFyp2GPQ{A(
z!jEeF=QOeiK>Spd>#%G0tv3@m6;A519Y|zh@^E0^!|=%Q%d7V@jtMn{-OO4X0jBey
zhYCVZ0o)ed0$=FXW56V5b~1H_8|+j<JoNkOyHBI*Ohfadv-XFrY5<+kC(p#VW%}_u
zj2iVO3@U;=2UG-kxf2)|7=#!U7#P?tnKm#mFl3muf<{Fo7`OC-qzn?+E^K39U|?qB
zVYnp*UPQ*g=^?i>5ws+sfr~+d5yWB(U}SM*adC0hVB!EBOw?$=!n1&hiHWH}Oss){
zVS!@e3I+y_#wiRA4h|cRE?{tDU{Fv{@Zb<)U`qg5&ydEz=-a@+(9od3(9jT^z#zT4
z0klwT0)xeMhBO9|8=%EnObl!h3_=akQ4t%Hj`q6Umbx%~qco#feQi+yBO@czGzKP?
z1stt941yBMEFz4o42}*GTnq<pC$6{+@(5%whhY*6ct<LnU^QXTH3Kbr6S=^!<rZjR
zThIXp2Zsr23<|;w0-OyT46MPR^;--K3=WP0YiH*`&0$&{9haQ4;I-D;`c)x&t*fny
z=j?hOy)MgB>F<2dIZ&$*;MeJtm)~n|?7j4}M89P6#lq^P^TnOMd)7^Nx_MXsN=)3#
z%WL1yD|)ALeW&O8BCox_zfUg}s@hxi^+Qcq-0!oyd#l!bJ{Ni?zvA-VXZNzsS6r_?
z_-yUo$Fc9(XS=>Jt2kHh_NYs@^4#aXV>>6hE=!g;_C@4GN4LM^iEE$tK9}u1YNTXZ
zdEnXO0@q`o3ir(GIl#$qhO6`p>!XiX#KS|MPd|6{g)zef9m!UkVg^HrO`Ph-raqkX
zz2Q5nI{2imNm{Gcbgh}UDen8;_tEb*mHW-DUS49d%qV2p#l^1OS=H}t>%Z^fopw71
zq}oO(j^V$HkfVx_BX}vT=$^}Sc0aFq-Pilr^S)JfLg$Vb_e|#9d-Se7OmG!Pn^T68
zq^y98QKtgKKfAj%nkorQ3iGS)y`Shm->zoIM~=q#^L~DQetwdt3TV9*9M`5y0^Mr`
z<AWBfgocLJrc5gNU2^@kbJF*DOAEK?m(1(;jpgmWtMcRP)nga-UW#A7Zkxp|v2(v5
zXYu{2ntJ!S-m|Iie5S0=)xN*>Y<%UtqIZoS9#|ASWN0X4$S>m6ul(_S;RpVUrb}Ai
zO@8IRWY#X}sJNHvSF290?p^q7arL_!&(3{5S5RNM>3h-ID?5sNp2Q?e95Z@8m$Q7&
z<Bi1<QoL!#Y&;USO*{z<66e*5b{;FzEuL3+W6pbvH+}`l49sT_7u|VKT)30r!Ka;v
zPkp<!>+U(rs&hRr4wskA<-E{sbD^<r=_cD!jrH<O2Fh%mb|ULV!Z$gpSocglZW*&P
zVzp>o$i%0f^|mRS8=<S!POLilTJ?SPy|4RTt9ddoO`4!GEhy+pvYSbAvb0`x<@fhz
zKR@4J_wv0T3zLV6kmc6A7iQ798&xKGs=hr}ocaTjwr%ou?7a8$JiDCbee2`leY0OL
z6_}%^64?qmKk?+U8B(b&o+&ff)~Yn}s9o|9IBw}S$)Qa^-t<_}hb8mAcTIZz&{Mhk
z#3WBU_T@*npPxAEasDCY@;!fQf4_hH{QByy`@LJY?fw0w@3(y7^o8w=^7X#kuD|`d
z?DoM`o-<S&RXL_zeKOVH^0qin>k@|E&%RqfWN%wuwQlm${o=73-`AwP;8x$}z%o_k
zq0$FVwe%$pEK`&cvp#TYB`)Wk-T>0m*xzwqnD^Pe+)tItFHim`FJ9)U-lC=~*l|Gc
zLz_h2`TmZHX20jGl#lc8Z<jMu@~l^xu($So@$9$RJ$ZL`#_TNL-g(aMwundECp+~k
z0eduAF8S%c1f3u=No&<=rPWERA?Yq<lE0^l+(~C%JBdqXw<>bWZl~=0GV!JIyKURf
zc)q=mv+Z^gC`V}DtG>s*fPq20_uS{bk5?%6Pxf7Of=i+%+U|k~7b{=F0w=Mj>-LFE
ze!!=~m-)RsrlO_xeR+AwB#-GE`Iuzu*Iz%o?dEOSJA60az4&glWTl!=rrMpi7kH=L
zb}-9SS>-t?TCK4m-?~IvcUyDXB(EhiRd-ElnaDX=1z9D>@j~5~oROQt&AehFH51z;
z0$Btc!3XX+NHlaPG{tzmn=tK{Q#fCf&~zSyLmi3=lRO_bve-U~s83`Oa1u!SXcDlO
zLv2!)FX*6+8}d4#S*!I9LCUvno(ht}EFw9)(!y=h!mZN6tq0!Asg}=H%{TLUr{dxD
z%*Vs6lhdrXVv>ue%H+)LbH9E2{vI^f^$MaNLY_ORak@xQWy@jkQG+I{buTto-d=EX
zX?<kgA(dG(GPhfoFx-1~&l`HEAcsN|JI|yy(~E1*etNrg!lY{9g}Ev%S8lbKJh}%y
zGZhqFlP`HPoboQcoxAmRZogh`+Vzs|8HHOsQzmh!O!D7T`|jPliK;4l?;Ngq^zd@(
z<-CSAi6#yOM;3)9?z?BV{kd;;TTu8wT)}L;*(KsT?cTlMF7lW(Dehh3zQTf+n_g~r
zh@Rv!W%9a6)3)u_CE}f`T^ffWy7`uTh?pX!&e*#1_JW(aTf{-f)Rnze^76bs%{OuF
zxx1{7Jfm}^0#DwV)N^q9U27(z`q<qblO{#)*ynTn@ODid>28t0HUWnw4o4PQ&pV#{
zoj#M4)f*n}^h{WGJK>I_-rXgho>uSlCmVivd&-;b(Y9MAizlZ{NsBJt?pQG??6%vK
zB2SfGjVJFsRTg<pN?3FUloW4qADQH-vUVF-+$|O2;@mBn?&?Ke#?wDrF&Wjrz2!1x
z@^00chok52;yyCzs7PXqfI^diBg;G0G$~!-hQngd7ChZ{ArNHH?y`xhD(_CF6<m9s
z*Ypvaxhj)9F7^36ndGH1Q;kda++DWQxeNAyZjis70TM@XZn?^0qubM$STl*%GhlOW
z!Zw&K+d-$}t-IvD?e?CUWp}0XK-XR0p5&*p;fT1f+mRDKJc(^LRSzGj^xb84XHsEa
zY}q8+ZFe8Pd-qn!%OgE!a&_7h=|Ytm28Y`rF~!XJu#H3ErbW)3d6PWM)Eimq1ssL*
zUJ3;{Tc^yvZLV;;Q{`28$*V8bk$kt4=QZc4Om1aKJlrDdSusQ6FqewL9D~C=#g{L6
zvK{%L(8Qq}ynA{0;#()mZp(a;E>xMhy`)o9Y3?T9H(?WUk4#E9%qOGJ$Rg0hA)?+U
zq0pT2u<KHlr^1bSpq%Ktdx@u~$lFQv`AJ(q)=1vo9d&7&McLuxI1rav<zYMDk&Dh8
zimn0{juwdxho!!JndG?92Gr8(d3$$lX0(iT;>Puk+l4&;Fno|-eSoLNPIgzfQuV2=
z#n}}%?wOhHiTb!I*emAQ*?WKO&dpmNx3{7!_ulvGWx;PBu(2Oznj|r~XOfqrk@68C
zK1Rm(iER>IydnV)>=+zbMErv|zlsRBGPOx0cG<e`&E0l8<%5v7=GP?`AMl6YoBlzV
zNxPoy#scvTUQPlFM3{mES{W7yO=!_zWdJR2(gO?Z04<SXY5=LI**4d2+uW3O8+RSs
z9<?}n-M)SM?Cffu_siJ?do1|XG)ZK#&m@0F2jwe)t|E@i98Q8g$yOyPi5yNwt5!8s
zKA)HS^m+BYpXY6m7e3U(Ry#>}@~AX;^4Ff8Zh0<d=eg=6k)<DJO}gx~ZIaZ=ZHuP#
zdYyDyQ7~zx*6&kGRz`cd<~AJ23R_wk)ZS2@y<2<t=Cgj=j@{1aogMwy9kkde_|&Zj
zybY!TZkwa$&$lnXZ+))vzRl11rRQCr*uL4Lvg^e9Jq$-?)N~s2D400RNqv0p$84ol
zE2m4kFv--%z5?yY0L{G<e;_%_-liadR^}X(#Vv}U^+qo*FTEaHTHCbh%b}%JobFpf
z!nb%CF*$2$`YhF2mMXGprpT%}A+9k&8yXs)DTZtiWv%zGkejkzF))TB)~CtW>xj?>
zi6u*|RtZS1<P1EjeQLd|O+m%W;3e;-ytH02;ibyEDfa45J}uyWoxi*yphhTUvIkSE
zYST{+g+(0-jcqc@635ERjSL?|tvbgV!Wh1N`n<gF=XEb3W_Y<7#8etQK_q1TiF5t^
zaINQ-r{~@K^>^R;^4%LtzO}dU^S2%|mRy<@o4GYEBF<c7TZdP~?LB9opTB)S@8>yp
zMe)-W`pl2t^X!q`bz<o^7A6iB!IXKQKR;hGclyaqTB~L&{fev-==qXt@@3P6dGqG&
z;mYZLt<U`Q-qUm6FJHcV_9bYg4Y%N?)=pJ!!TL=t%BkE!USi6r9B!vXyF8_#y-Jzl
zIfcjhiu-p+*ZltT*Y5uO`GwnR+K=v=mfzodbgE15+S%K}bJmm{e7aLOfbGQWY}1{;
zK7amx?(@9zlQrc{UpxeAA5L$X9>vBkAgC^{khtyY&(HTJmBp)_ShXsr`(^42C*#YP
zFJEZkpM>PZ_tgidKXzeqncg&!QK<fvr_Sd0UnYI`)S1~89l-mCG5-AHH^0gl;~xCk
z{xtVvXlZ)o;_S77x!2>Dzx?RCN+PjsR;}Y#j)k5kCsjU(Fxk2<U%q^?#36x}WQlWg
zB_*5$dRDDkz_s^`gVb(cliRslF8em3FRCz@B;m<0NnW;S+xolH1&=bxU|9(iIQ_s4
zCJtdO)a5`O9UY6NUzA|dMbZJfl9$PA>vTg&CY9;yB$<>aPsm`MT-7Eyy<jq<J=4@B
zlNlc<O;<Y4EHb^}1+#d)+1jm}{_gp^Uw-@joB8Ya*ZuwW_5HT;ulf^yG(TPkx?)GV
zQbf+NqR?B=Wa;L-(=+G4{*~6N@kHroKI?-T59P!9?0K8C4D49s1spyc_`#TctAT6M
zF>o!H67Q|=Bsi}pZQisX;men=H~LPjO?^<a`&z*FJ>S>O$}GE{TXMPH%d$^ek1x4X
zk1xqApe1J^oV7zQ>5(5SVQ>_x9y}i!^Yp{(Iop<;5&QLTuF|e63-8|E-cX)>*n9uY
zmrs3l)oz)675OTX9}sK7oGI)vJGxfp+WY6v&+jXr^Ld|>{<IHqolG2ZCn}VD>^LM`
zFW5NTXY&4Bzr1vkCUPRtec@z$vFGw7FQ=-ist=l*^q218pI+r9_kDU5d_fZQOtm+l
z#Ys>$&hynk#q4dcLhyn*4e$Vk0!xb`H-q|>NzwJX^Yf3tudm;K|4qETzxn#}zyI6q
z-R~bSA0PMrcg@~?Z$Eu{|MvZ-cYprL%N5T7EedR4?Nm%)0xbiAl8|13<+-9qpbbvo
zRXt2DOe&nxpu4<tKnr_>oH;?u3Kd%>fL5PwVB82!f@~)eRha5M%(iY5a=v;8yg2BR
zN7=jXXtnO>=-h4Fwr;z1?c^d5y1fLle67Kg0lZ3tWx@u=B#(rf;NrYAKVe$%8Y}0e
z6PO}3f8Vb(bN#aY<ep03iM1*FKs%$%ZY!-?wJN7;)iO{n1X1fj_YFW?%`n|&5))Vb
zm*<w-EziB4YMOg$_H;7_uBU5P+?jsw%hIX|LLtAeMCynzCfeHCa`;L(8Ft?}_wJd7
zZfNpUo~G4zR_MHYd3pD4$Z1wBjS8UkI7*D*ML9noUA=bklJoM?ZFAF0HoVj?nZ*2F
z?`C|J-~$cUs#&$KM5l2vG<Ik#;t+7G=ae{RdwFM1rP!(sht}N;eHUJN-)0wb9R{kx
zS{Oh}s~9FR+~m7A=ehOHbLBBBSLYS^UOV?vMdSCuS=_I)-(A0}cEtADuhh@BDvFXX
zUpQqP66}e4R$gxSW^HKNp*F|RcX6lAna#@F05+U=ZSJ<M+k_nJx31lG$>{*gC6-3T
zb45>2&v~9dPd84x;)?YyPsK~+(SDoCJ(b0)PjBXfI)4(c-B&JeRt7~Dkw6v>#l;Zk
zSBS0J+!&s->U-t$*?T{qE`i1sXvHDeIxz+vPabJ-N_hSG=Ibxts;!Iv8#+d+)dxqu
zmI-WNIhcOGfk8l|x<FzF0|To8=u!uh`l<yX>nAy`VhG7P)YGx3fkEhsW3tHB*^<t#
z4UA2YSgc`^7x1{*@-wrnfMrVKX$H0i28LUmkNvk@Xx`N$qoG$?U85-c`f}Tq!wd%%
zRRnEVy%w-FsBo&RWMDA)wrW*Xeg9Qv2ZqU4HD*oKY&pP`<rTu#zJfv2R8>nlfN|lM
zKkt{nw0-k5-QDY4U+H=OYD?2oPqL?;xUM~MUAS`0yu0V-&Vxu!ohz#yv(9bjTA18i
zZ7Zv=(i!D5Zz{EP-QGEOl7`1ZrIs!s?d<Bg*0!h4^?`JhysVGBSP7FeyQH1u$|<^i
zY5JPLOPd!jO^<vMFwx7)EXP+QBrvc`GdJsWj>a;Lg{~ak`Rsk+ljCd{GHyLv2f{K>
zD@`9CVC!9%^=#U?jn~59xcjtatmy%MDYKocXPNC>z3IkoZ73E7)Aa}e?OA3!x2}5D
z9T)j%S9XJ(Np5jC7)Q@~*1PW1P3KKFc8hM>t=kR4Tc)T!Q_Q)sO?S57mRxDKi(3~<
zd+X#%=k_kTxFtK{mRYxBw=cJtZj`RU#w}S_vXj>2O5Ip3nzSagcXG6tmJVZ-*3pQo
zB3Dd#>zxCx_I9RSx#HSjb~Izf>X1+dN$0S`!Dgo-jb_c75xI2H#iVPUOVg%h=5AcE
zB}zMDv$xyqEbyJSy@F9@Q%u#ix-D9CMCxM3+TJaJfl0g>x7{X#=@lDULL!=@w0gJX
zF3uGJF%1_-nPh{muHBNct*hJMh60nqk$Qm~31t=r7eThIUN;u{daXHiO51RAT3(c{
z#Fi*sv2NF-a?K-}Q%;GTN;R74vv!-v?kSJ5L{9Hc&YLUaG&7p_8jrVj;-+nvyrW#S
zZh7389c0$KHSLDCH`_^#o0D#YopQUB6S$$bF>KT7j9b?xhutZ6y}eu5a>bRB&Z)(L
zb1#<F`@Pt;d(oQ}pp`y+FLrBL37X!OdRk<9>PgH_si(VlZ8~yo<>9RxOLs3X4=?As
zbMD1%Ewj1Tj;YO-c6D3S9k^}9HeackB2#XPZOe2u*}5s?+GMwrskyVgHN>WP%w%bs
zEM(*}EwC%#tXkLVs2f`)Cfs)GiOyIp*y$@OWwvaZX>z@rX|~u!uz+qvz|ph`SGQf8
z;<0VgfeDv#)pD2QE{O_M5?pd*qt4NsGgH?}XBes`bzHl+ty`s4#5B^-RU>W9DXCeL
zL>4UL_Hyz}IhmE_nd#D<&9W(Lvf9bXSvQTMZfYBP%$OAAFzv?4Ot#x4sb;6LbT(~_
zSQ9wq#<Ej6YwM?^<{Z`87#$XNO5>o<n!qUrH&>iGJ9X9+mn#~lZil6&g{3C-EH;|b
z>9f|2>z3ML4dX0bL$^~|x*{%7NwWi|q)K|}8oDj&U9s#+gc_@<*o;N9lk;88G?s}3
zZWX!JmFsHgYIa*=*(r_l2X1b5QD5w>v2@n$V6(?YxB0yij|mFaOJy9}*zdd2ZQ;Br
z#>@DoZrtbgE#X<(ZRgb71y444CR+t8=A4u{Ws;{#&@7L+w}tb>Zftv%9h{R8z@pVF
z>gqDtqhpfpGQZH+#Nri6hn^j|owdf`uCec;T<)Z6Q;k}$Y(4GTbFMXawPZxD?$(`$
zo?ckHbc@cW)w{Q)xvcmevc_flE*~cO$R7!}ty0Y<PRjLJcFD+hV@HkeaphS;PM&-a
z+9UDANl7)8+;%1bl}T-@J+rQ89qHQbb}~0xZA<79=G<-5*bD<xx|3F{oi>FbncIuO
zuz@#hPkGYYS<{Vtnbhjd-ixg}6&~Fzv0{_!#%+r;S&cnTNwpfaMBJPcnX%<OuW?T0
z%vX!DGNOW9g@c_g^Gt{q%27MB#msl@+SZvX7OzV-IVzH+X&9ZgV9l;=NxeB{y&FUO
ztd1t{%88sg^NezC#FWFcgL984E=}9MYt_};(Un>mSqa}J_JoAEL~*Q%u3vUzZSHOn
zBL@lIwT_{?Zl_FK6}nv_a-+e<2{U4yHu`Q`)O$zgP{!fx#W`8M8$)t?1Cw)dRW(<3
zdj$#lCH8mTi=LO<7q*V)ZB)yxlYH%F+_@n~gN;1X&TWj&%AJxE7A8BpB2H^>ziMp7
z=g`Z$`N}TFTzYl2Np)MEZ<A@?#dXG?KIHqH$t=3Y9<glM8uQj2UI(9-SmanZZp*W}
zZKj)b`-#>*)lJc&lTuUN76<2=b%%=POlM4CGOMqDUNXr$V8ty^UBfadR5>|-fq{X^
z)0jIWBo{Oz!oaA~o3=S}&89<>5;n7L@R<?0>0s{KO_FKeULgx21e9DZbfyNINTpqD
zIV9|KB+5H7G(LAj;%zqh@+(WVwuY^`ved;zLYXB=Nr~g2pkT8=k`j-Ep`aj3LPy8J
z4g<GTj*cFQW`Tqr!H$j&Wfm7V9>*pF7ng)1f`Uy-%7TJ|Y#awAIyyQG+&GT7xHvW$
zxG5<q@d!4-jZjijGGv1oozNpFC;{UnAuF10D90$lr3|vPqoZg4|LM2<nPiztuTKx0
zz$84)kC6+B%_jn~0=g3bMk!3!Qef1Yek+wpWO8AK6u&I&EQ`CxlO>M%OgF4%5|?}^
zp`>Jx#L>|Kcc}u{MJ&_htC{5L|DXR0ZaN_o`;V92y&gN;O;Wf`Qg|`XnOg=Y<{+WD
z5@~4{+gx58Ha3H>o`!7=T`Q3^TWjlLp3cKO!Kq<e61#E?PJk31<~egCapr6uW8=iO
zwA|O%!$H6Ye!#`_Q}v9}9=6}_d!M)2^?LQGO}BGy<|=ZCux!1~vu%<&Q^T}f52sxc
zXms$lO;k!&;EY`-nX8h=%BWj*79yM(duMv+_I{h!yZlz?Prg_sW7!Km#shqKM&<i?
zry(X!x*cP5%Sk|kGk2XN*oJLWCmBv)Sqmmt`!2hjF?r)BSzGDvwts)aygXMT!-?(n
zM(<3SJ}sumw_VX5PYOd6woP)fl!?v-^8$p<SHFGwd|u4EvQKOGPCr=Bs9<)l`t9B8
zv8C1T=l!k#=?D;-Hpxk#aqW%NEiDQGLg(HD-Evp%YM4GjMf>0F`e*g$XUTUge>8n#
z2$NF%ryvKXx!Z(HI>dh8y(u#}Id_3g?f3iD@mn0X?%((O{od<u7xCu5nqqQ0M<`zA
zm#0cbpH<76t%6OtiuPO1ENnYqx2^P*jM;?h`6ZERH-4U<o%?tH-hcnTU4QG!I%&%O
zJ$bkOg@%Tj^BBB){rLI3clWm4egF0Q-kYD@CvX0o|2bz(y|J>0uZqHF4-d9W9xQde
zU%tPMf4BGh-uZsF_L^Pu%uN7oUk=^2ktdg1WZTB9ZP#?eZXFO?ots>~_mO}3?qg=Z
z?>)<$_)=|aM{;hk=+@T!%f4%Rx82U&ZhG5yP4C&V%h}3RAX9Y1ZXLg17<Svf^m~Jl
zD|^{XmD=lf7$)h}KR@(3ukP*p0wK+^x=-)kz7sIKH>XKulKYM(`RaSF`i0^TRDM7G
z`fHPi*zDYtCXRYRcRly@#~&Pz@T!+@*L!&&rdw^*?)3~Bzq<X`?_p<?wsAhRg#X^D
zzb!S58*1;~WS6gXRs0DWGymXmJ9k^%?^k`|j+>mX-}|0^Rxb5VoxNJ(M+Ld}8wBpp
zl4ri)aXWXx={z>Yi3=DQ7#Uxv)J#_0A=ReNEO6pM?fKo|=j`U*eyI8>$+yXK-P&K(
zxAyNkJ^gYJlTv;4J(Ulw);TJftowF#t3J1ScjC$H#K*T+S;`f>-p#JKjmPfWE1ij8
z@wOW^EY6GzJAORB<f-gZ_(U~zMXwpplu1tREKfo_q}jjDoMLcO_0lql_-NBtGG^=Z
z-ki(bxb1xUE}h8<CzoZb7$3H&*<1Tf@Y|xP@8|FNv-Nl6+Q0RGpWeOvhk-r3fPwMq
z9r641mFutl{XW0;`}>%S5AVLHZ0FwlzU*`VjEeHlOV(YAKRd}^$@aj@eZM@{CP~~5
zIhvao{pE7Da_+X<x!?#Zj@@$W#Jx$;5e(d++csP=yXqdP^f~Xi_IEXb8Ejv}UY%4Z
zU3NQCp-G~B*(C#M6(7BN8`oJo<IAIOFj(-(FmUH?nRM%j;kK1sw~n%2&gp4%Ty#Ab
zlp0WzMeepQFlC3f`<iVsyPdo3&h=cgP3GXF^HOzd1H;znZ2swfW>?*3XZCG!eKP4Y
z<8GPtcQdzLf9Iq4z~_Mas_kK(OqX-(*GzEa@thysI9qE;N~!AQ;2kUrUubTbyvK9S
z6dQJdszAd>rZ!JvSf*LVmn*;D_v-hfe+-=y6}-Qn-#!0c=C&EWO9Uodo}Jlp%aN1U
z?2wAdvs;N)9uH=3_fS+^zNqO|>7q$myEIIfM`<cBc#2PtyXY{{x%BmMhU}>-6K<NR
z&bVH$<*B$S$J=mS$Rx*Uw?J&O%fjn@SQkyw+N7Z;9i<5}=Hb>wlcaK6JThM_*x~V@
zAn#7#E$=nGOD3shubUky?Wy8(J=ScK*(8sd>vrX)<f=^6HM``=8=Mr`TeM`7wAzu)
zQcpcqBy&OR!?}i5Uk*fRDy`mH5^cI@l9t%+aM#UI3`-h7uDi91LudE(K8EK;(@%sk
z$<{MYx)cjC&p5W^)`?r5N@=@ZZk@PglFQlB%h}4ADxHecZmCS#tyyq$Zj{QTP1AX2
zUR~s=DHfbD$?F8C!yW6yRgPMxrEX6<l+qMB&2+nN%Si?%PuA1xjSjNp?XCLekfY|I
z8s(E+cqM0o*OnRA9<R8mz~HH{v-H_yP7(9Cy&d&ZU4EWIo375;CNgW1YU*ms98FUd
zFBhdCkEs)+8h(6p$WirBjZBU%y5TdyYtyl9PdChj8W5q-dwqS}3I6XV>|5B+G-uei
z$A7pG$$#Etze%Njm8N~=rkdZcr(L;qZ_)L@nvb9EmB&?IEI03a$5;6|^m-Jx;+bua
zcbc!Szu$a&_xkIv_cO9I8ZdCEa55zbfCdm0yx(q&em}3==I85oZzmi-KSMP-DfZln
zU*E3WPP;d8r}9z5%_W8%Oz~eBIXpc0f3!$8{5!K@lIw=GT?UsEw&_ad92T7D=5pBV
z$gz~<gzI-ay+k@XcI_}JadB}8S#H(c^42fo&1s=S8|#+{9ojJMY;>aTMxALBB0_zq
z%nn?;DLK(qs_WvK8JBLEuE~sC)^jvz=2D|=EN5qF2Ti+>+N5<mcWukmCNFkrx4SZC
zmI=pRry8oMoH)1IBF$&oMWqZ+lSvX~r?pmX&3a&Xa<)oJ)0Qc(9iwt}yl!s2#<-=$
z(ox;Z@zO-mCn6oI>%WL}tPYs6)<rd|Yh|jI=u*|Cs#AngS!M<CYO-(YH~zyRoomv6
z|NPJL&->2Xe7PrHBxAk1`r7uxX4iWc?Yhd4eSUx4@ALQerY~D@JNr)Kx4Y4AKA+#c
zdwu%6s^qg(m+#lUd#``}bvSrM2Lp&?;%ov9QPuAayZ=2pcTxS`Rh~iLR!v<QAhvSV
zs#RMROoV(jGgbt9c;!uGHStnrby(}=IAK-$1FzPpqOP^2EM6;Dc!jT>EwMH_=cJH9
z??ma;jhl1oejCo5$M|q@0!NBd&at+$2FH%D*_h`XYm>|g%W<5{<(sLg?X{LGN6U06
zPfupcY-x^JTRW9>O)|~uFC5N^+_-tNr?MeO%gq_yhK<jT-8N~vx#TD-Yi`%Hr4rL_
zE9aUW?AUhdcJ2~S8%2-3{5gBe*WKIm^}Y21sa-FMpEZW@E-88O>)W~G+je=%O$wGa
zdsBG4$3f`-N=1fAHtW9yCNNcg&)sv;wShC|{qkGk@iw1thv>aLZz#w9La?*`-UF40
zMF&_upSyOy_I~v}fyOrJ?7NB+4&GJl`4ngtk=V(Tw(IBfdAAn4oAcTDR`Ih=MHQ7v
zei8{5i470im?wFvv`O$ur1(iBSb}C$CwU+V|9ij`uM(znhFM~=$Nt*yTfbF4U-n`5
z<QAvo*t_?hu(zIJ+;hoRnv3Dsu?gGv-rGB`^5v?t(z$okZ<pq8K5zH#9Y~~Wvv0@k
zyxX}47O#$4b!{)B&#G$+7(rx1umV%p^c~SmMgku{9?su)u>Hn?KilepYvxC9{}s(-
z$5{VF?ZEeSzjJqTm6yKGec+OC%j4F&+qv7W-Ok;18&u=o&d$A^o4bZ(2gjuzue5Jl
z-+X?}^!a&M&4skajgs3Yz4{&X_T{?roZGvuz1@0gM%&KgvWD3?$+;VQw;kbZa8&RR
zW?*P?n870SHzfP}d)sYs53F}J-uC(QtYxvZ)4RPn^?SEX4&S!xcJ3sv<Xn}>;W_Jh
zSat|+WG}mV??LR&of<o8j%;g`3S1(4JG|=pGPBvyxw)6c_9_=89G?g3Wxy~ms9HK;
zHYF)|_S@{6a}~-<R@)^RGj5bzc461PYrD_gEjzn=ZNAOt<I^{NK3~22^zHMYR4&ZW
zR1aF91S(ZHRR13X@2ImfUvIp?Xqof}2E?KIpxaW}#NRt;G1&F8W^G)xa>9lsiy{}U
z37a`FaB~U+7v$g__Cq{Po0KkA{B}Rb#;U}~;KIPbeB+1DM?0w-G8G9g*bO{Z-s}vP
zT*;`SvQXr&zf`DJgGoKZlrOV9wVE9muKZoKs;Ys3Ve(Z~UzM*8CoVe#d3ns5xop7+
zR$tFR|6pGRsoMEVztuk9J7>*{mys9G?R@z@U2SJfZ_!T32uSwi+dD6Bz5|v7kB7N?
zoolyxz8qP7c)7Nf?QZah+RVPs)+zz@6Qj$GH@R|(s02)Oa?Q;zUY@=)@*+%o_n9{n
zL3abF1Pf{0&AA8C08-x>6u7y1UF`b8ds}aT#@hm&x<mpNwXRk>GuyXwp>u9U<*6^%
z=OK-@Rb`)N01uAA2Fbv5(fY_!^)J^kR4&e*wG$1mlX;4)iLYp{>GKAOJI{L8g}w$4
z(V65HM_oNDwl{t1<rs#~Zr4qVk+9U3+^uKD*L(sE%q16xhPuyE-Kci$%B|Va!P#yX
zx8zFaO5BP}&bZcfsXp7ytanlGVz<ZzN0+tsF3!!&j8NHjEY~^g)Y%nTQf&)YXJscH
zb#2ggjaV(!oE$BhoUzvJ<d%>K=G?7n+jK%An6`v=^{!!XV7u+P#U<(1#juTAGd5;y
zOuBF?)o9l2R8y&wQ&Oe6#k!@%G*)cfvT#|}$_-}PS+muS<_2e7+}2yaB~v>&S5!>l
zT5fQ{jkT+CW(V9#>sqq5cME6;&P+GT$8g)Rms3t%0S~Ax4tf{d5v)1IYo^ayw?*%Q
zJ7<gRp7Ka!wsyJerky5X@5)QeSZ`Y~Obbq2I>m75l*E~Vn?jni+^z<0<&tXC&^Wd@
zcgvO@oolJwrZb&QolQe-rPgP;oLP2T<j`!z)SR`eZgNYk+U#^KC(R@)bk@Q&$2P%R
zW<9-bivw3&$(6h-p6cqhI8fT{c9!ujy;Hqw@3?LhIcqj)S>_hqg`&|y(W+ayGeyp5
z&77F4lIyaqJ4JWZlCx>8KGzbqb-8EVxR@&{ExPEIE(l$TWX)L<IOS$^VEvSvPTQ6R
z1P7*0;aPM-J2k0i*)nZj*Qsm=0^Pz=xin6lS(|aKH{)tg&@^qgn?_wmn>7M`u5J}H
z+_Y8DR5CJh?Se~TW+BO0+HS|p7HtXZx)`N(v@3PRt)5)hj9Xii1Gk;Z(lvB7obfGK
zW1GgdRHN=BC=7Jn5}0i?v)*;1>t@Y~B2jBa%ofeoSfH`+Q`$i(Cc{g;^E_21XtqX8
zU6b3(D5azv9bFL>aI~3iYU`A_t#VtBY`nCj(3^SDt=T>k=L&h=yu~hH!k3d7os)Cf
zt8D6oho#|CO0%XsdKx-Q<jtLj=Dda0EXoI#tqLu>HFMAMtX#8Y=e)`mt&h4{FJ%z8
zu{P`Ofuh@9*FrKjZVfg|(=iQ55SKPi`!UmZ$*EM6PLr-wv&ouME~#8%ljq!aDe;=N
z$*heL6V~MFoX)sqEXvv1wMJ2Jk;DZK-3^DA9qSF;w&<ekA_m3;ZAqWCU1wLV+Bo~z
zs%ck3t*mu7m)tY&ojE6}WBRP_Oi_!CVcqp&NpEI{2DdlQ2n$)J`fA&^n<`s!dUO{|
z4otYY?AogCD2=!4a;4seC#_u_G}9!E^XRG~jdh}3kr}~aLdsmH_OkjrKA4d;ebu(x
zri&eYwP$QxEEt`aweogKp+v#1MTdjd=}udkb#>0MZa1Z47ejKprQL39)5#T;*b;H<
zXt!I+iGU_0rx3MHAq$=#JP({*&2&z0(VM2d#q;9B2Ni{nk589eZsgsgwZ@xmb$GZ*
zvS3fdEpN}HOnc+xT5VC#xM-NRz@^P$I<u0(G_H2sPR@>)K5-e7Q~lrHrA&)vJ1{Uz
zYGpX15x{fEON7~Ap@Znks9vqhx%=C8D|xL{%Q$Ox*`=3f?dIGqt4<3oVBosaCfFj-
zBG9_kg@O5VZgi-2bZEW#Hy6idHYFv<@C$Tw2yNgAJnjS<5CV-tfjCCZ5S|if6bi0a
z;h+R!6bdpjB>_^v<0#nCF}**9NlNS>blgf%LP^O`P!KYf)ik{^g;9yw=<mnr@7J(O
zOjoI9Ql7p#fQfs0gB&9l_l`HPahZ41Po^*_GU`oVP{kxNJx7j_bGk+~lbDhV2w1}g
zSav-DalJS8<bfF=PU`fJ@{DrR&-yZQ3il*SY%c^IA`3FL_fE$_LBZ+z3XGCQufPB1
z2~KPSUul%sl`|=l#o(x!1o&d3N!|*eyN%$|dGB`jtzW-pdZ9j(_Vkl!Oda(y>%z6C
zo_Zd6JwH!k8GNv5b=0b@i+RGs_kKRTQ*U+NBmZi!Bc<;Nu{7$J@7X=+)w+iY9zu1c
zcdr*-J*d27qZo9&DmZ1*kqGzzRgS@#vu%<yx5pOkj5r1!Kr-w}w%dJqm!EXi_nmj9
z^X{#$zVptz?cVpwa@DK3cRYm3u0G#;y<~3K-6M_adtu{m#|(R*3WB~@gEW_iO!cfy
zX1CXW{-b_>{~s3~CY8np7ak^s1VLto4ha@dW`<6c#s=5glxJNp1eqB+m6QaOJazBa
z-o5R+?e5+0o-^C;R~P(nwtHRw{d%L%59jAB&VikBn<8wJ($9W2kA3s9*7CkEgPp<W
zCua|ae4g`g_Vc-h#m4+ScCW7-x}Be(*|nhd(_x-t_2=*HT08A-XlQ88wpZJtOT(Ky
zJlPNSr9RegmS?NFzSeT`v>>~ip}s5iYZhlZz2AQP_WAt!{`%<qcN<(L7;rQ;xJ>u>
z#l$~dD}zZu<o)j5ncHsf-nZ}j{o337lk5Ahe}6PR;yIISeSD-w?z*F!V)r=j*KKGo
zdN$j>d}sNdjY3BR%`7^X$$UylJ*51R^CRbZqr&6GpT8LV{Au)H)~nk1#rth83)h_f
z*t+cw*wvkP@A_=J{r&U@kHx>guUnnEJv1~lS{Lkt2NOf<nKEWM+Ot2{y0Jw_lI8dN
zGxO%}FE?-B_1g7}<-0w%FO@!HZ|bss^)xU(T59#((2Yx0ecHFpJJ<A?-`u-rAHLi5
z;e1u~-Bo`ojYU|E848L;4mg*;-~R6R)$iNyeP6Zj^YlBJO!D;#E|a47{ocK8cJA)o
zuiw{xzq{dgQOs7mOYO_OuQ&R)xcm%p@eO5hxf&>Fa(JFk&mARuf%yV6TVJqDF1GOa
zw5%ra{A6<$qa5afTJfp(?MjYZSDgK^{qD7AVz;XqeVp~aeV!3rws&U#@mrco2h!iy
zmPYIDTD5A`&D^Uw+g`0_>8}3~c-f`)-Yc!!nV@T>Z)dE|T^iox&t;V{zt?k(soMUo
z9!0_G`Kl+&i=O`SUH2zi_1LX9=!A0AE*4J}9wzPAs=QloZ1djU!E3&==HK^wUHa99
z7X(`5w7#lLD!=5xS?2xpq+X22p6}bXRVr3EGTe?;>Q32lI~IeO<Z<=bt~b%Dx9`6B
zHeKKklblD_uanNXWxA8zK9VuHK6CkjnaiA2v(=Ax<@PMqe0=!%i4zqcZ6nX9y<d9U
zXWNZ;mvy)OKDDZ5$D<uxD=d8P{oebv{QbUPf7xbVn*Ju6NiwrEDtZxv?a9w4!@DvX
z_={>jg+7|4!1kt5fbrhDnBVg}RaPH0iQ_5(i|eym*;Q(N^c8RVePv4bLBE&hcRrcq
z8TQdv_;%*rQ^ossEbDx`<=#`v`!T^T-)`lXuibSSL>Ilh^M0M?bio`Z(fWRO(`C97
zW6~d0TV(7JdGYfJit*o9YKk|_y*$78q{`HaWgQIP)z7QOX+qqWyZY8`b2AS?2HAH{
zLH2s>33h$3+z;lk;^&jri(IVG-|OkIN95gHkP6SRk3P{#uY3MfS*|tA>0W32@x}Bh
zIZOie!Z!~`r)aFL)GqYRov`8i>XXr3**UH4dy`d{ZgV<(Z@tQ-ut&2Lwmbp5&N1^O
zIB=SNUuYDFK3??v&L>aRIL##=1fGK&heS`9HmQQ61{!AHn+}2;zvc2hZkG8rQ>!lf
zSLozTn|zO(WoNxQ*oZ9`S(od9ov*Ov>G^qHdxBlW@3n9=KR^9$>Z|WB_+Ll;xms6O
zTBV%(?N{CT=jVz8&L_w{o#}qZrN)^@jq$xhU!uTSL$^~uKR>rzIk)7UMO=1V<(kUt
z^NMFZlP#GfQxNyeu*<udw=1#js0(;ya6#fmAA=jq>LqeQJXNN%NsAl?OBx(bnvuBC
z?y$<t8J_8TOSf;7^OdnY@Px@jBJX?Iwx_L|qVu*zuiX*Ex@r}y?*^i!bN@AT@!why
zQs1;$Co;q|<fPQnhz(OETLtR2I_#LTiB;@xOUFtjCB1dLvVwx5Dz2X5;cR`o9?hv&
z&$_he$?LR;X+pPp)=oO)tE}QJbT%VQb(W$ucaGWGsZ+bS&aSxWwswk}&IYltQ`44Q
zbz3u~J8P-M&D92?n`TVAx@o4$r06hR(McCGHhJgn?A^9FJ1<ap#!8Em1?@!-R{AY+
zdaB{45@^fd%Km~SAjxZGr%HsVaHyx7s*YDwXFYeIVycGEQqCXKj~~~6xhdzS$)3;e
zU!VQFuYB9r+t-gTS?OsK%qnuAW=7?ilWK{JW@zl}(o0x0bI$ei^Ud<(%H7h+W3SJv
zoGU&r`|RxNQ!hIz&b$k+R@)?&om83R469aeLdOoea-b^SmFLzU|Hk!a!o=F6LEi5~
zO%%BqJ60H}NKAA&>NQ<OXk7?v)>4ldOF5T1@ITSiYzR{Nsj_N*bhN{<ZHB81w`O_j
zOo{}ZaxOG0g!8Mwln;RqdAx!W)`Ut#EK_U~<53n>i4e76UbV7g8fVL)U|tSqj}1MS
zyoE!u7?ToAL#8CD9%ieTNL;Z@*wbl`N}!F`g7|<xb(VECzkYrD`h1J+-rSpuPabY4
z_c`%Q@Qiu&uD3U$r<dK$+4lB^Cs)8$$m;)4Q0zl+eQ0#lt$+2k(V@TN4>WKb<Jk8*
z`}#ToMu~&syT3et{PD-n&--eAzWaG>=hkn+?{~1wI4H%zRlj1#j#Zj!5@B|gpYK}l
zPIpxje7F0q<@0&zf|bwqeD`~I^J0<Kdhp~U0~2&L6aUq)ZR>A_?a$3$w)3lq#=;3R
z(taKP{Q2kRsvlpbYP?vWvHI+~`?*_kOG4Z_u6QMc$5nn#`}(|Orog-1>uo+;>DyeN
zZN8p!S&I>e?1lPCLQWo@j9ocfv!mT45~r<=+9(vf>)q=eubz0ixVV58f(Zo*3JL{i
zbkwjh)ITt0uuq)6EKR7^zHZm;8~th><<2~l*rfN~UAr@Jo7wHP(_ZI^G-g2-^MkU;
z1W4F0f7-e={NDEIx8s`{7Cr2f+;`*p^JiyYKR!}F^_1tL6<wF(b2EM%Tkq<UWFQi3
z@NDbzv$L<yy*P93_0s3_(p{g=`keOlX~_kTw9-kQVnUuOXAX!Q5IMo%5X^AqFi&vG
zBu^Cvg|q~&lu3@s>)!2pz53JI&|f<oSdyCb*R8z(qV?Wyx3jCOUS6K_Vuy?IsYR<+
zzi=01=w)H3chgXMcRSv%^7;9acW>v4bhz(&U-Eoj<s6Wu;0QUfLI&cU2Jrqguz%{d
z-MY2=0hkFRc%vB@GMEF{w$^r<2(irKWO87bz@WmZb^Gh8vczxqcbzk^x_LMH=8V!A
zf(JU=-j_$*-nw*mW^Vm9-rZ5rTepXXg65iGhA~tasU^I=d+XlHGr}&$6Igjvwr|}X
zBz7`)>9*G;iv%<z=cL&(+<o`j;>>IHyo(k-d>al~xEq^S?>e0~UH7(k?uKnAO*CRd
zLt*EWgUziutRyqDyn4+W<IWO`8wC$!9_X=#)StO~`&xL;&hlK{ZHIQNY|Mz+_F)2Z
zgbHWP+Ou0e=Vw<fHw<>?d2TFn2Hgqs{~TpandzIhsPxJLCY!}|3=9r|Zx19rU|<kA
zz`!8baPpnJ0#hragLae#i>iwQhofkG;)Ea$Mg~rZPuVZ*F*u|wpJDgl^_`@3w-%Tj
zU}|7sGPHi(byh*N@SIG8)E&7WiPIg6nM918U6KP-%~!3enz-NsgUVM=Pg^Zt69a`=
zQ+*ZqJuWbMs%kR(vdxm$&(7OdHS6}WW!qk^p59i>q+D-$>f5`WWqU7zmT#?ddwSx!
zMsMYcb#6OjdW$`BX7;uvXT8+(v!2}d<bmzU%Z3}y<i?)7Y&ca_R8>?}+I-j3Ti-!S
zi*^XE3%<77)78`Mq^qj5cJ!<l7gsDY36z2?)d~>FIjS4_tarT`bP#B2)wyur0`};g
zvGt}0Wb>YuTxYPcBsii38cjkOOv=liWwvw0W%Zeoi?`gg1mT6Kca@sv?ztEa86*NN
z3IpL}DYKm`Zm0%SM@M^^xo)jb=ACSq$-6k?nAvT~)ZWF?ZkJ9=yKa?CotEhpxh7|+
z>tf$rrHf)6TUeq+7hTgjb}~|1HE;`PPzbbu3%qj6%y-eE1A>7G94nf%bl6UuSz~0Z
zIWtY`R<6dywNj>wB`)TQiX6D1z{JqRpuo|gz{JpS%}_I<W9^EoNypUcLn1DncJ1iS
z?K;{m*0t!^R<Ro!JEsap2l{k*g<R`ZU9x3%a_*vw(b5@P7kh5I<#ncW#%X24Szb9I
zQ~j55t<HUR<BEStZ0wCGPZwRgbnV*O;4t0gu3KJg-lVte+Fg!W@4#b+1vj_6*}da(
z(3y4NX;+HNW$(J)y|&`W<>ZWO8uiz1=}vZA=BjGux^`Beuh~kIT(#aM7nfYzwmH#s
zwq(x?V{W50CuZp;OXp@sX}hUOCrjvNDGN>Ol@9inPL?p;;-;!AadpdyQ<H+dJ$tvM
z1O=zex-!#L&DV3Xn%B1OP*o#M&7d_?W@?=jyDhkJm2StewXTyEb#2UX)6UowlAT*G
zvNc-e%wnT7o>RUH(sVW%hvq78+UA{bi{Wj~)LcQ&jjqOKL7Q1+C)~_Q?b*0&<<^X~
zu3edn12=AT6<e|B%C^g)E|&v0<^)H3EV#wH;KnhxD`q#AO}Uh+nH%UDvFO^d6{i+%
zFblfL+bVu0XWFrYIXPj+4)u2}NwPKzJ+vnH#?tyXH@)62xf!@*l9$pYpRIzqfuW`$
zw?hSeE;c$i=VW#DOghn-cI28DzsS{~x6<B8IYAGM4l8YxRC*g!ZPxTwT6fx|n?VOx
z{SdV9+@037;g+;!TEI!349(6PvxSp#rll9JkX_{)a;Il@&SP(HP36>$L6@ehm)%ZF
zah@gZ)OKZaw9NAutD`fDjol++ELVj++Pr(+t!uo^NuBzQYFc6U(x$pZnFOw!YU^g~
zv8ZQOZ<20o)V6&=hP@qKy@Fdm$L@4iVdLH$b)D;O$nDH!H(MfScC&^}sP>fRk`~=K
zy`r2+yFNQN>}{i~V9MeM?bODeOpP_t!I2A?rE*Oek{zY9e6xDp5`7MCn7Qg^KxJ-{
zYv97WtEc9^J(FpYY;3ZseRJAH@59GMRVpT~?cM6+w#_s;iaYIO*lp*m;G|_oW}CI#
zy6G~T>Bh>LTQz5H4Ek{O*5ZxJWOwVN&PeO-oo28t;pUe5)lv(KJ~#JHd3iJ1ZDneT
z&$d(FR_9AgbxUO~GBfK{n{*}OO2mbwVux~Or}eIK+?uPLbY{m9nV{QJ*<#vC8<t(%
zdUtKRdsddJ_k@kpR%~4Ay}RJ8(xx?mJTqs7)QDKv@vN$ut-B)4Y|+6jx!t1CQqvN2
zc(SF8C3mcL343-qcTWAx@Z_X-l7Xp<!?s>G$+#$WB&)aMnyzTCl$mMARcXOBVI~<j
zt|^D)xNVH;7E?OfW$G%D)hpJqaZ8qxlA42*V$ZQ;ot#IZH3rWuj>$YUJl!fAo$I@e
z=gbw~&<HcPgK3LRt#gIfUR!L`anpCzvWsRR+jwWQ2iYXHK6$e`Yny+V?4E~@@2(5o
z?q|$yc&W5ois!;Qsa2b<X?DC;dvCttTL53|w97N1LrquhTw0MQxqWxpoMUC%9=bei
zP@cPX?Xnv#E~$o_B6X%s3hBSKb>D62)SO#dz1tRmwx}!CXSIRu4Png8U|>|u2m`l)
zJV86NrIvxj*%H;3EnwizowX`$t;Q8esmL|g(tIS1)zp?{o8`{-n&tBAQQ5Xj%cf<8
z<uWitXLBXZNNsad(>Y_nz<+mb?zXqtx!Zs4UjSZ|#0DPBItUxg0*_q@xYQ?rRxde1
z*Io&-@gUY-fyCGpj<`q|z}IpmKul5qkC6$ufkx4qlnh*4l9ZGnVuJA1TQCujstzbP
zC;?ht1znZZQJ<46af}^267<e$`oaJvQO2E<54K58KO@JeFr87JQIxTHx{N$y<n)zt
zjB+4R`RO-~v&u}XXB1W4_5S^T(Cm<zQFfxTB!kz@NM%Wp-i_0u-aXm1cF*@+@4Q#t
zJ_A}aBrh#}Pw0E~AvYt2DIoci5+|6#PMwr^8hbw9W4eAVlM0jO-RZtHOggTwmLw~1
zMr*4euZ2oY=}BSK`gT-zN$-ILs@ry?Zkf14gk>vuWz*Ir6DIDE&h3i!lx}qJHo28+
zHrw|x=rSR>dd@Aka?R#m=h-%)g^MXVyDi$oiIq`z>tWp`icAetw@eaf;bJm_N{3zY
za1v1DRL$MCMNwt#wrksNd+!D{@K%7<jd|y81q($9ObSy3owFOJsItZhytRYlrjsCO
z=TDN5*AeB^Bq1-b677d~ug0s_+sEzifB*Z)n+@0QZUA)!*R@2Q-X>b2bhrB6x7=;F
z<qu4mAT&u~dUGvPaQ)YKk*S(%qHBM#hx~Uaz00Yn;#6PvtIf$8w07r=jkUemf3thX
z&&)}9x@xKIs<lg|pI^Se?)rz-3)k*WRGH+d8q2YDdXCl$*EJxn_vyXw_vQY+Uvt0Y
z-5aeJ3{tnZiI$jd&(V63op-}+LG^u=bMN;2>1Y1Fv_ALy4I9Ppe)YfKZ(8w_=lT5m
zxgRRk%1fUg{(fS?A$Ge-o<^S0nRb_r)|mCLom;g|^5?#Lzy7|z$95?{;WqQRZ!cd=
ze>JuA@Av&YKWm>J{_*Mi-ru>~Zs%;f&EBHCZ9#rr{@34M|Ngoq$ivabw(afO1q||a
z@-ybmi?1vF{CeHr*PjoFH!%JE{rgq@CoA3)Rlo1O`MIdhUifoGBdfwq<@(z4_o=@>
zFobBmRq|AsBq12`H*|OI)|$sJ@2<|>X5Xma#%cV1_uKC`PwSX&&jI!MRxcFW^tLsY
zW9!`a)n>PI`yY6DaC+YN4xIGm<!*MBKOMY0@wN9>9I~5hp74<W$s!38`@Ekr)9-vQ
zs4wzuKa_B={owf}le{K{UH>|DYT}mKoYz+iZUz>rwDc{RYW31>Q^4$U!;QUjZpSm3
zPBoYoa;zd<Uhn%p&;+pVwu28j-mZ`|Y?gX`Ja?Pf%{N=G8$4w5^wQXV>vwE9<K-_5
z#`pIJJSktl_ucs!mEcL^{M}b&`rcRHd${NN-1<Ln%A#dge_k}voK@0sef6oczrH^V
zcVM`7cLO+z!=0nc4w)*fU4Qm%o?TPNty6o;_tvX!kKCS+tM-j|gU$QAd7TXVwqI2%
z+r4(7z=4j0?7UmI7#P3wzBJ!aSLdnv^vRw*&yx#QFJQ>dyAgT;W^At6jnE4WrrUGs
z!AS!w(d(hl$eLT1`{&-Z$8YD|mUnc0Hp^_&dPde))4uPm)ZKM<H*==>hTO)vM`rG;
zy*)>JZ`4%FIVX-i*>y5HX6EDL)A#M$A2RdSyKODbOp1+bcV}lXuwOEN6T9WoR*eU9
z{L*>e@K+bb?tRZTskZLd?JD!xsnW^Px%Jx&H?CKG`aaKld)&Lb1<T#0w!V9NovS1>
zBJSPYWUunLcX!KMtvr>z4zDZ~IUcB69`se@c%aIpd;9Laieu1kHJKzcb=z6%hKsgU
zx6|ex$e6b`ce9(3@D2v%D)l9kK81M4W|r#)UR=8H%I;|^UR=8HD)vOD>|O7j`5`5f
zJf&0j*6(^H<954zd)}^g!EJZn-d?xxNbdIPvezpLr4_9i7gc?Q8{U(mUckWi#otr)
z$%<*acgH4GeHFT1p1sCDZjq<z-rBu)*X6c;b(`coY40}9JIv?fZs&rjZ8sOEFqJbf
z*nF83=XLA0b?)_m{@Hoo-a@H*D1AMkS1*@`Z+cwqiQMq!rPt>dNrygoS+?4&-PwEn
z&ZT#z-DuAa+;vfJ2bfZs^gcdc;0;53NT$lGsX{S7U*9_|n=$G9yuEKWUhCBP`8vy^
z^!B}P5tIB@2I>~_9W{?qy)N)3xO7o$ikI&r*#@Rro>og;c0H2qs?Xcvy-xAQvezz?
zy!Y1bao)fX9G!pX{uhOR0{h!K%v$PxN&frG_hPgAq}x|~Ki~ST&)dY-`mAw7KxS{_
zduRKqa@V<g*Umj4?Yw){yLWfay^y`HAHMhJ-TV3#uRs0#!6L+RfI(q`3V59ZXvX5%
z#ps`ZtnZ)u+@t+&cWyPq&idXC>)CtH=jP73b~|6<u-PTAs5^!Y-oG4L8a%}xDs=o_
zt=OG*%1t!u+N6`33tLpv)~-<LX*d<6xu18odG4~?X$=>zs<?Uzf(E-fx_9SF9lJ8o
zV0p-H-fc%_W_f3BGP@R;Y&64UGv~rhw@#~_(%Bpu6}2@uQ6w-V?BrV0)lv0ojZ>49
zy|UFdOgp<`qfW1u(W+Z!(QcQ0g>Fuq7?l~gW#t+Uv)kDjIjfd!-H<corf_Bs)2&6f
zQ#VOn7F$^ur5o*b+UU%oH!s=LE_2N}qCMH*Seo;;t5<mEoIL60yK&p?Xm(M(l$l+d
zS3T#|E}pPc)9Rvb=CaJRyF4csx*cR*E>o|u^28)Rp_PY%luu3Yto<aUv|)<YtR=!B
zB3VsdR~3~NjF^=?jZ`LUvaWJ0e;+dM%jeU}3oqx!YE1vU|M=%WZ!3i#bR=$j(>m*{
z?#2D4LZJ(CTs+NgFy}74UcPM)>-3n-Zg17zu9@|AJws&5jGbw{xlA8G^F=HTj0zq?
z3=NL;3LeI0w~arq^8CTD`jyJ6eT&*u1$}h5ypDKAcytRSiHNaqPi1v(ndqY`BB7zH
z<rTbVq3RS(RlO`nJEfajh0_jd2W)IP7-F_<v&)i*gW5m6y5f{R`fx24mN?XA7_u=;
z=*Y$})<)HYg%3+b5(7?{1spQaNonGlYUs1oaGI1>y|KWNghSD;fkvCoq;0x3)#zGe
zn$N<P6}^lWSC$-Isb<o0OlzsXs8eLC*ICzD5vRHqT@)2@xox<rJ2NFB(PU-NvC!OY
zw?)1Bw73>;ta`Qcd0%zu>*I|TrFScM4tw8Jp5>e%yT0sNcJ{2Z+ivI1UUJRT>)EzD
zOz{^QRTSm^`{dNKUCy|*Ks!0XY_{wE%<tECl{H2CeD>P)^I6|V3I0XBYR3-bnssM1
ze4h99-P}cHGoQ!Sd^Wxv_wrV_rfx}n^?@Ub94>_+`YnoF{bv_gK-&g<pdmwn-YMWV
zL$EOf7_{Up<lqB|dfegv!qBphHOh?1Eaj3^eEz;~*C*Nt$}+m$dRF|d>1<lQ^GU4>
zW|a*u1h-ANoyoqv`gR=CChM({v$xFNwkdnt9>z%7(rJ%VXYNYd{PW`hCWi?O3@V&;
z<>ke585|U5un4j2ySg^(|J11MZ}WTC-@m+mx@H@bLj6TWmFW}2f4E3YX1@D=@75<3
z5+!_hH(6xrWzW3Vt`L`C(P3z~M86zl+38JZ)ABCm-8#AM)(6&Uo;^C(((3YUf7Vs0
zEP_BKC6z@g3p|(weL6KdHH299FAZD2r>iG?zisFvEyK9)_b1<vdwGj9*Z556_46hb
zbq#Lw>mA+9m@_wQYmh6xxA*cEx63xK*UzgH5W4OzvSjPUzwem^S`-D32JAlj>~rPb
z8Yku!@P=xEhG%JMX^F7r79=Q*jXB&-2{b$ei|#WGFJ8U-a&C6+)&<}dj~+rS2S8;G
zldq#%lfz_31s^6(CWi_2Dx6FaLKjrGfm*Jh)*W13e0Fi(@AuEk@7D$Ge0w|2Lz(5q
zwCkSNZkK^-Yv0^$x67{imR)U_&XKEgbaSz-x~b&lRn~cLPqJlh6x=pF?OW}#Np~0L
zZtpUd%2b*5cH7l$$INaEK*~Ju+O7#IoOQWprXOo(@=!H{tjrY7U=d>3`ZIgl)BSd`
zA3yK@xU=My?Dn!J%_e3Vmoui%YiAOxPnOPwIDG~K3&_3R|IY-3c}}_JBAC|8n9xxE
zK!Al+?hczB0|R5;ig3XQ9`n1^hTD!`&C+d4diPFJWFdFdthHLczB3L=MFd1nj@)<P
z-KhnjaXK3>76s<@wV!#NT<o?8O%h>XV7i@rt7d`P!vpLW-_CpXu6X9dXCLYr7_!xO
z&-s$F>%_yA4~>?3F)%PNF7x-)^h&wxY$9-3K`2$z)5O-{vIE;JTSxU(fug3)pE{&W
zj_@=rnX+=JjcstS;^L}_9VeTXEp=Nmf0g<Q23`gmGx^u=>a-%JY+LD3`}6YV_uQR)
zEP+g&I+2|^E{oQ@TX$3J#LV<!i;2ED^}%J@x~1h&ud)uQHvZW5;p5{Y?~drHsKj`<
zGAD@(34xg&J0`q!nPv^z`e<bpR#LL&#TO-)BObFog%oyKriX^ctyxoI%Q2Dl;%N)!
zwRhIddce9hPCMgj^LCeMRxmR>BQM6SI>n^YDXh2E>fEc{&Fda8F!1e|exQ>{y8f26
z?@BnfiM{nQhT$V@A=X-mjK^EEe(|}MeGC;Bx1NoGVyja(uW6^xlP<e)pfXFuP$OAd
zv8!`wPjYs&q2rQEha$Et@)nBrxOB$UEK6e6l~glHwS;MASJtl13fiWeoTMDOICsgC
z+iI)pP0q|*p}S<8$F1HaM$RnTj3qbUIhC4~YBbYlF?gkuc7i5&KjGPk7rDL>0SmXi
zHe0xI>g<3krlH*-5igfqXILwmwC$Eo$))Uuu&#}PS(n077H$pBopvR%b=&C-VbfV&
zn<H0=U3AXWU1+vo=9JZ@UT=5Lwk}UfH<jvjTU>9w=*`@V3Jbjzx3#*;1nihFvC!QM
zwAD0i@tP8!%>lCEX;({fWtZNvmR-ChaIL6F#CA&$m&<``vZaoSY0v7L<y*veV#!jE
zJ8QwaCdH2Xs_kS=UN$+V$tpAQ(&|nnmve8{&S{T~w&dHitw=UC=V{+g<CPm6SRC1o
z`^lCI*0TsO3b?RtyPX}gRbq0KNpg0e#FV8*y>1KEsQJ#?tZ_Ly>8g;RX2zQ2<VdrN
z+s<@(<y^a|buwpWr`QyamLs!OJIxknUCfo3w9zH%O2m;<Z40iL@k(8~bepwz!A92J
z)vUcCksLEK+FVwuT)O0vx>QJajnJh-QPJMsiONxdN}2VYs!KREdrBguIv1Us>D0F7
z+ND-5k)y4fb+U89x}$W0eWiNc7Ol9stao+Rt!Qb*&>Y?^+0r__T^F}36cy|;+6dlw
zs4cDH6&P`B+pXZhTxpYO-pbM3nh`<UZe12Jn$_(pC^pm8VA0f#Q!+!oUAu7WR_De|
zA^~ULOQ(Ikty-_?bW}5(HRD<L*_^erMIT5U-Bz-;&#WWIw?AyvLa~lDS$mRh^sd^u
z#^u(=U0053r)fHT*S>b_O5SbhO;JI7E8T)xZe7kvJL8fNnW?j4$s||JNzt37Th6vz
z7rH1ab|Fw&INLi}KrzcWam`d!l?jt_Calri6mezem8lYUxI>L+)kkbQc9+X^!Hrzq
zDQTghGamCrwkB(C^IEAiJM64Z(((h#riP@789D2$*4daOu~F#6x|5rtwR)p-*>o3+
zb={VZG7HXKZK@fOQ+=2}n`PV0nR_D^dw2wEToMji*>3W1%Ci`wO?s&_(~LE(rpp*4
zcU?%F8gWrr!}G@GXb-bX$yxQsjs|Yb302z?bu=j3ZOazssEfH9w{6*A*sBuFx-ubI
z%3~YXrppY;x*E(9%+a}zcgJqC-g-NA)s0WnLPI`>ZVmVt-mbLdv)4AE$d!?uzMDg~
zofX)&GFNrmk!?4ckN3rNd?{pc>&RHlvBA&CSEudpVc}D&+SqbLpOn3d$qFk!Sg&cd
zai^h<?VLbY(G^$1bd3yqJG$LE*2H>Exn;U)cVedkS5lh?kJ#<lsLrXHUeVjG<*xRc
zc5AMy8*gvd-DR?2t8UM3ZMb!N)24_`IT;(Jx?O!|namc+%DK4cQcmECEmCKvL|klI
zEYZ<*NlRKuOljJT#cCQ&8Y)w!dg@M@GT~CaN|?u@X|8#>z5S`}ayAwEGHjNI!u+n?
zb(yPnF*oSKnbW3aX0L9iZOA&f)>AcmR&UZ(sotbj*LW9;nM5r+c<IA2?W4C-bGLU^
zte$6+db&6CNRCor*P4h&GGE@@&dK+_w0PIHtbkRs)vj*x=Xv^6C7f3^>e{P2x6fI6
zOZ7ON&8$}yj_BB8mK^4tZdf7+y4qW%SLi6G$?WJEljL9R_kaI?-~N@c+um-v{qEhn
z=ebMwfo?TBe|GKfZ<|BG!)g3?SIrK4z?vPsEqB{%2L=wa-DzugHHcoixn<RL=>!HA
z2F6v9Yt?Q?Tzea`Hi5~vJeE^B_sZJKxk@odtv2Ltso!asacZ+6&zs228yBA3rJWe2
z9RfC&gK<{Z$)K=P(Yd#>#Z0verga&w-En!@IU`U7$0A+x_uH-9?S`}SU(ek9Y06Sf
zub>vtDlQOq18rXv6chxFun7tZxN$UqN5%{waveP`F3_cAVe20po8H92B+a;Z`b9k^
zjp;T^nDn@Jg0u<>N*FkAgse4NdW2cPzz}lZ_B;3zvfUFUIt;-|^<e9*@^-<Op@9dg
z)F&UXX5n;Mov3xgYn#y3={c-S4)r^GK#R&C#6S7J&;C|EneOpv?cVR_&F3CcQTiZV
z`SfJv5h&w%K_|x^w!5|h6S{Q;CUoC8_W9gfgjl=mb?+tB@4#bxV8Zy`$Li;kVwF#A
z`@E~g!}ar?C!cq?w8Syz?P~Fxc<$Y#mrM@z@GFKvn;V!Mz``=`Ug}LyDc-$gmjj#v
zwWw4$<xRJ(tq!}&c=w9aZRt>fZO1M<>2BO|p<7yNqS%dF8LkbtCW>8l(vi+`iB34C
z))JkZxezSA&1{xnZtt=-tF^mP56P4PT|KiqJNlpf!r$fZe!uUpzHcEvcm3KGw`S!A
zOy4NYC{oX~a2qI&*{<(D{^RfOcfY@j@`4T#Wib7*?is6d7D$ePZS}_=f9mYz-tRAa
zp6P8`v#!|mj_9fN(|o5htDdzEV352UwL8qy;M%2|?a>EVJ%dyx_3AvC<(qtD(tJDr
zx!*5Dt=)F1?uXf*lXl-5<v#uEs8IR)p5I>DZC1wJ`p?hL&$qcB@muHo;ph86XGYGe
zjnBON)GlO(<k#G7YiCP;_#J-k=kvWOW@fin>Kyhi-R5BWSMUDZ!<!lyuibkmoxAOJ
z-H}O?lEUw1PB+}PcFXB$?;gd-9*a44PwigP_wvH&hGti{%`BGQp1=3;34f_$w|&zj
zV<&l<3ovdwK9S`|Jwr)A`wK4a!^%$t8KUA{(#(55zpwgzfITfpb&8@h1Izjbb(zeD
z_8$?yz8eVGDVXiM{z5nGcBX|&<IiP`DGMfQs5H5(uXr6Hz|Xht_Jxm3kNl6!v+MkO
zzxLieJ7ppNv$fyv*Is!f`29fdkw5!>8H-Gu<hhSi`1Hy(ZO3kxi~Xs;To5-+<kX%?
z-`8h_8(%s!vsivooTvA02kx03i;tVVP4K+O+~3F_wZ3|O*#;d>m9*>G3${k*E_pEN
zqr8x(^80<i-+lY~vLZ---Tm5c@4IXQ<>k%x?a$ve$I0$@p}qdTo<9MP?=mnjZM>Pe
zcH8azjVgP#N58z2{q^=;NC4KuL-1GLlC+Wy%VLgq@7Oi<%*#Zdo&CbzcVa!x#Oi2H
zH?)b1oaY+kv83pcr|J5v)f?E$3zzH3FW$4;`oOw9e)qVheCpjcr&6qFueMwA^(Ah}
znWm?w@A+-xaF5~Vmly06%n#qr@MQj|GRaeS+wJlvpHFv}2pL)*XSb+-eXcn7mDQ#9
zEt68B_OVRT?U&OzGUaDo&9$2h*FU}eUhrlCL+SS2ZJ@!yvVhn5<$R|Y*rTg=qz4!>
zE_T#=yG+3(Gw$6xA&$7m;wA6inHvY3RGFxHUs&#ZY?8;Mpl#7PUV4sYXG%1mb|jSQ
zG;B3mAeqY@6l?TaeaVCf2GzUuWz{R(4ULm}x81JWccpE%^7Qf&8;8Rj5(@IH%Px7E
zs?5&ab~`ssQ+08{w5i*cCt7iM=QcTh`d+>__ua#r4h&!y$->z@uQD!3S?AumAY~f8
zea&lzt<gD5TA}Yszq@d2O?kC0##80<&DU!@g}lN}=XN@@v)-tm`u390{aqYhE(N>x
zE6tJ!m|rRvc!G6F52uQdBa49Z?cBT9Zd8^`^3*SnK5RA1I``Jq?K}3U*4&rd{qDPv
z+ikC#xf?Zh^4)HCO0?}yF})VeuqDA$WwuD?*?<dWx3_Iu%c-(bxXV>-$-)-dZEx@1
zz1t?Z)9m)PBX?%qI=JG_?`8FC)_C)H%+6imx8z`}^nA1XeA2?zYw!Hto$@8u?Ob%m
zomrbUYED+p-L_EQcgduT+qnl1CxuRXap&!9SDVu2z@1-jJxS4>%;jm}Xf>Hl#8oKj
zQNiKxB|*2NquizxxlJi9yQ?xgHrdNk*~@Zw-X!03x1of`yWBL8@%1>(zi4XO9Juql
zZ)C)VKMA=DIj_txSftsU-_B#@_xk+ql`BnWT+WrA92TZ(tc2;hzB~ffAB`3@&3w^T
zQ{Q`J>Vb*Eo(^soV<o#h+EP9o=3R76=XYMh=k`2lj%DvuV?3KGCQBL!uCy^Yq%rAm
zJCDKjtzCI<XR}$9KHSiI_QL8;1An1pH6~N_HVL=KxepKXnCB)JmtAd^v6{1DJ)38_
zP{KTwV?Hc7MJ`KSQyv_YNZh#U`OKReDi3exZ3#{-7h0!s(8jZ82FI0o5{V+7iKo`<
z>z95P_`2`=k2AlLGxw;ag>AAuI$t7A>DA<P;f|14x1$>$Z`j4je82yY$VaC6MuPjq
zuGwUngw;r@Hj4!6yvtK8nraiaO>5PTwH;+gGhe=_DxI!9gGsf1-SqrzPxt19_uIVE
zm6pzz7Tdklr!<PwS~ggzbJ^PbP$#yp+_&%7e7|4&`F>uSWLx4)VV=VVXFA&wXQWBC
z<v(|Fn!Zy*>rdyDw9cTkNt}tPOu@NZZhtD>&em|5S0p7@HEQiFty{j+lD2X6u8^EE
zZD!}fm>nBtDOxV-m59ojUN0V^@YX?bX`sdGjwyjpSz7hqv$X0exh`20>7hDBBqAaz
zRM=}#(ps%QEVbdMKUkY>-cs}By|vlXBfX|)=Y}ivn(fI6k9HD$p84}X|NQw=@0T7w
zUsv<{drrJl=aSEBA26+P$#Gh>#;<iphuDLy922@tIUp4|h}JgRRKFTjtAjWoTH9#T
zD$jsU?og;gQ*O)IW$&J)8|S}d*!ybL(l0_Q<6V}Va%2<JRNCYcrsb&<64A9JqQmvd
zRM#R;wT4xzxwfnbb-&jdm?^SUJ!@6h#8)oeZv(e(kd7ABIhGZs*%NZ2Vc*4&c|r5I
z16mIDB=gp*tXX6l>X{T&q338YB`xFFf-4fMnvH_AwIa@j2pKv1a<fV&oZL1kEOpvd
zW5ZS3BsEi6#U`p7ojL22*kkIUmN7BBOH{RIQSOGUt&_7Z<gN`f+}Jx|T4vhhtX!vz
zixU-QhRj+blI(OlcbjOa_bEaDEx%r0FSSiQZ#8$D+t%Jk_3`C*y=6Uf%Zsk7_)C}M
zX|?!Q@4kKezRmah)%R=nfFitOMp_0uzMr)QR{ya-zkmDl_aEW||FOyYT1Wf$YhSTt
z5v+Q9?bOw|hpWEM%{pEF)~@~b%G6Caqe35LF1s8SU3N3~&Z)OkZ<pPS(@xzUv@Kfu
z#I4M2w=(L5pu?n~4WA4i|0BZJ=f~amkK4;XCw;BF%%06@tIzC=HZiriy75@fRhyT4
zYyR%7mi@TnqsgafUyt@Kn`d^Fiy^e5w<9#P^TKvPraQhTg?(Kv7lO!3r(IN(&N`_m
zojS8-6^z~G$+2m(w$_rVS`)SgbaJ?F4(Q~7;e88ozbZO=Xr%t^F+cWe_S?M8ySqfU
z=59Yf_ifFd%IEvjr#_zZWL~9hD7VX34#x#j64TPB=^UN;(QLNw^aqm|MHwBZKb*wq
z#@xAW%Vft4rOCM&%99N;*y~ldU0wR?``7PZzkk_&{r>*CzkgTVsEe%qnS1U}POb0z
zJ60=m-{svD*_K;%W8F4}Tc5Z5`Coqi{Hgc5Cm&huyzYB;<-}#P{H^XW=p{)_(m0~E
zRo&^1b71RLX<xJ3zGk=mpdqN_;vuBu;_-KF*7|jd8{HCly8`z)A8emiTEE)n*}a7?
z6uPdjyLoNRMAg|l79abV_s6E@%BGt+YqdU_T+UpryE|vwyVSB%Z+GXc7u|GwWwh?p
z9pH8<!vqyh1_maF30kWb>F;6AuV26W`rX&B-<kjZ^t0yo^S6JhYvt~~{qoQKR!?VJ
zijOhRi5Y2<6OGhdPRta}PMnc;*sQHScWeCHq9e15Zcp5-e8zX_<kx@uSFB4rU3PW4
z=r(XqgMq2nCUeWjWtWf5_Ls`F$(Sjul;YC~Hf8p++q0*h4m~Tnull~+KHsZ%!;W3{
z>g`%6Fp0zMg#fQ-T183Nx$Qbv7F%V>Re!$UZ+Pug*saVcPc4DW-MbVn@UqI;)TbrR
zNOL)CaK=~(<iNuQXFsjWp0zW(_)M<K8r^Wg*gGIIZ>y|u@MKY7V7M|Z^~{M+CX2m=
z`lY>fr}izMw0qT!TbY3yLzILZIqovaRUXLwP-oBY-+#RK|BMA|CTp(w>YcEYG0rdl
zfC2}X?GBz81_q`X3=B*L67mgSCO@n1W?6G9+goJmY>9wI##K5K*DkvW_I3>egJlE5
z@{05G`ed8mF<UcESiry_tyGiKQ_DQZ{qWr*6F@EPoPx&^25drtiozFXg?c3#O0dmq
zniR^w!0Uf&si#{51IxTsDp^zh22NmKAu?&oycNlsov$*uW=&c$&x3*ec5?0yroUIG
zADG9KSYPPw*1K)XVYh83UAL`|jJ8c)vvw{zHa=e#c0S_4<KD9HScZ&SkHe+Rc3eGp
zT<XobT?`ku9$ROU^IA3)f#vevJShzgeXX4y0m83x{Vv|h^}DLQ<<{JlWwV2~fbfd9
zX3M+J%{k7W!@O2HChM`=b*UX7qo%K&&!kchI<ITd#f+niF17`0PC1n-HN9w#)68h&
z;Kd!m8fRc5Z?BERZl@+X&1QEFxMIrd9B_5h<}9ggVYy(g54X%L-vZW*)nZrOc4|G~
zx)`Rr>S&*@+77Lrg)0J*%}Nfeow?$6hECYV+%;lmt5)h<&^fj0Y}&+Vhnz_UW|MAp
zCxu;NHVrk--FD0Ec*L48t#`p&v^!=VTO0@)p9@@ZGwNON7R{NfV^5W}vQDpGz$8__
zY1=97Y2H?$X<^Sgxn>teOJ{5eJ9f+L;<nyR8-lZ*PC7R=a_S6?tEW}xYHilmE=s$3
zIqS)#><-h#$$8qj+irCo6;2F0lIwP5>85E{eVeu|*sM6KYqQeKg<%P^gHwE0g`LdZ
zbaTbltzEacrLKtSu4cLwY8=@(V`<vvAfIa~Q)ktmnY3FwHOKAJtwpyk1}?gBP0J)&
z?9jHbOQzYGIcB}B*&$m_%}y3I3r;l)&dPDxxG_q1(c+{n(XLy}f>TY!9HX^GQYEyL
zde&~70^S5UTXzYU*|bZy+OFI(o4PouH)-QWw~cGErH<X|T{>~aHM1FRi*7B>bTSp&
z+6&qUd8J;`ZBfsfQzC&=XGVfhZ&b&up0$n9E>}{GbJn`}x`hSjWSL6M2#ZYGG&^af
zYjTE`wrJPUq+7jfHo7g$YBdwl4Onw*vBoK*DN#w=!q#>fZCe{Hk}ByIIK|XdY{oM1
zp<q3?bb@tVrL(q2+&Fg3bYriZ?pB>+W`?OVjvbpWx`@ev(RX^-A|}WB>g<%YQ@3Vi
zrKU@ihlUy6<ZP5#AU@M9EHy1?rtgwl5obH~+hvnBdrbD6RAhBDZKB#_X2HcKt{uJ1
z3W_bO-mGoiv~5xDw%baJZd^<b%*oieqJiOR_LjovrlzLjqC3=XOXn<nveU&f(o=ob
z;?&TXit<fM3LYgZRdfes>dew=s&94-mo!|lanZ4!h>OW#R~Q(x3|I7q>&9F=>sFv<
zCS1C5O4iw^O{=9gMqKSWcGII_T3d2U+))cd14AA~8H<VvX_>>9bA9Kj+i0!0ymjlw
zEt_@DFLb`Bvs$xtijkYxRMl?JOl`rOETtP)T(>5toDf|hb?UU4cdG8BWUq)V%Tgr*
zdyY-Ib<-_%mbC7we_A4@+FARbZo9UB+H}DsOp;8!Tc<CqWt8F(6iJpirU4rD(9N1&
zXv8cv{oi6H)9D9yGU-iUX~e9-e9W+Cy8bRE@#*X98MzsAr%#k)mY=4`$dBg|nfm|t
zw}1}O<OI!hf(e#J<*8A3&A)zrrn%u{ijZfDkh92*{Mp58n!LB&`)+kYWzq?i-Fc-G
zJj?EV-+9eZ_1?YPxp!|YJ6v|>wZf#g+xLRl<-6zZUb*4!_Py^w>TciD%~~C`<EWX`
z+AME{NfOHrhpu%NxskGoQ?aW)!O$16<?p`j+wFU|y?cYSJ<$9t$PAv~#NBt#-Mw-n
z?{@XwyIna(kt`Enn+BoUcjvy(-50j^^W$glmK}z=?RNFO=aDSat8d?XSB4>)`@VW^
zO0ZBY)Rj=*e7koKY7yA8yYJomUc9~3OnUFz_vO~*!HK)`tM9y4FOMyKxcvs(U&Dws
zVW-YUtepzFNi<s9)L@xOcGlF3Z2n#h{QZ3!*cc8NJ1{bvFbEhsFmf~HTv}}~bBo$F
ztyK)HL6^LvX6H_t!nk(L)-_jWE%lwnAQkwm<+G}IIj8sTk3T;@|N6h`+r7P&FQ&^Z
zXELeZ_w)U}-*2OzTYlV=zqZ^k_Dp!O)b+Ca^0Hg1_GaC?e*M~YnR2)8Cwh^yUN-6n
ze&X}q=c(`gYMOT=)9+_Hi|ijTFv`D=U@g1Bz`!`E_UxBkRrfu=Y(HctSRPhbTl3eR
z`}M0wXTI!MRvi=CyT;(mw+%ez^KOePXY-i$uG2mHy1V}S{Jnc3=S>$m4-#6#%yT~b
z{qzFWyT>_<?|B;wov$_)tGXS#mYu;whT%d1vnM-)$t1@EyzC4n6AG9i3>1l&^Xc1n
zZ@zc#?)hqC-Ll)o#+TER;*@@M?=<3ja>9DDLZ@nRV3GCC3EdMvvwpJkuB`v`?7r&>
z&k65*Ql7~4%o6A<GmzNs!@g2T;*$7Dm3$x7Ne@+)?OHnN@xEVbx9k}hgzL64L}x8v
zU|{n!V_--xZ3qXQ94D!ED}KW9ko&nNm&>-U)qcA!d24>;yz|xf`5&GBZ~^Af2?fla
zDsb0=8IJWZzkp;e-Mu2iaGm|grb}+10gNfzPJ2p&iA@eto(d1xcIa%n<n~k-llU2V
zfo+n91>^E}U%vgm{XT#1zVEY^8+P`5`t&K{cu}%Yvan>(!qm<T27Q%j#c^J@v))&T
zA7Egv&$p_#c|Nc50t18Xbp8Ci*SjjKHLG$r*?L4NBt)k!0iUs@nLBNgIhZ)LmX}j*
ziLQVF78f8~MVia4;7*@;bFy)`>Dl6-eYp#gl5O_vEq->NSy(b?r457J<End}H?!hC
z=r=GhFrOAnIuo&X@3rX*S29^im-*b!-+t?I<jQ&9H?|xL4L<l}&+}DrpMEe1C~i+&
z#dMLeUN<>hCwISpocVhB<;Rb0zqPJL=Fo{dmFq=5URmCgG@(6d#xd)u35=oM+6()Z
z8upZjiLEtac<8F)sxl#2P_WAb1eKIUCPLxlw;QK3y>pme_~z#PwQY-5L_~{j+MAO*
z^>(6&*Q(db+YY%VdGG$WWV*@<^;4}{5`pz9;jcqPwd%5(nz9yku4+{ibvU#%{LA`f
z^IJEkrrx@xTXZC=<Erk?pZAYHK0fEq`*@zD{V8Scdv<nM@2o!j@zK;@&Jss8y~39m
z_JjwmOr7K{vP}Du<j0TCZT9S|S$zmJQVeQ@t1vKtM}_OV*6zQz?RIYVC)J?&p&kcA
z>K8LJsWx~shHMbBQfiIo;*eS?C|Z40#J@0Vv*>E+l+Ij5wVq{*Chc-Osw=2*U?aC!
z=YqqYS%IEi6AwIC9qM%<Q)0@oCa<e*y(|)mCLyb?2JJX3<&(8o*wfR_VO2ci*HgEa
zUHS3-^ZoO$^E{OrUS8$STypK$n{5XelsZFWC*7`Rm>7BY49f%tcD?t%c2DvSjX#?m
zeg7SkfdfnW%a5z)KJYkbeU4$W082sx$GKg%OPCBC7?}7J+3M^xy>tE~OB_3&D_*)S
z>ZMn5u35z~L$9DI+s=SRt*2^w1>H96NtU+V5)0Y%2U?5>TJj0HkVSO@h*X(W51}CB
z>vg-pXkW3xeciq3o2G6HJ({ugtYD7YmTk}H{`&RtF(|a_PQ2-_o-ClU`<{Hi$ofkX
z$27fy_A2%y?V9SXvr{K%#(IxriFK>CJz1g1z~R6o0Nx11<iG%?<zDBmzZ<$_zuqg=
zhia;KIOmu(@1Fcu+OB?W+wwTW>sptWZ8JOdc0-qHXz9e;iPn|(K=-syWawma0232b
zIOTWeuB}@%ePST9DC5@Y2SL3@iRn8gF_uhU;LIdCIX8o6a%r2~<bVwE=?A7Wi%y@A
z!YEcBwsxgmbj{!0c5l6I$8CJs_bz?g(!2)_(-q4-{Er{i{;SvnOI1R#@A;2+g}>xU
z7FntpH{qCJtk=?MG1D}Cz$q*=x+ogC<^=8U6S<KH-qI%t4qgxNj`}uFl}X|jMLW;M
z-OgS0y&+hcg~6@j<LbqG9{C6`@7ZyZ!Ht8V=k?m{4$2Jz3=9g71k#Tm)y$nQam;Y@
zZP&ZG({=^Txa~X7uqSBBQr*p9QNO3~sD1tV_4a+9(*@QssZ9T{nvqrh_qW^m`DwTB
zy<$KHYzuf97%~``45lAUU{<K#wm2l(b?5i@^L{>`SF@#CZr1f(yGys7RNZ#t?z9_s
zr`=T9c3XPW?UUuHccb6=Jehg-?3UfLbtjy=%^R>vOzhYt$=fNDL~kbwb%v&FSa+La
z5w!n_u#oxLjkQ7^LeIBeyS;nI)@_egL`27~-R7yg?F8shIj{QFsoQQV=N^sn-mNk%
ze^SzuqbJR-t8cw_dy>~Cvpb;@QMq8n$H0nLz1?<O-tt`8=X2oh9?TNPPq*hh%`+{`
zJy*2txm+gC+YMK_7AEH8D$d>JsTjLWP-AMCH`m(@UD_Ei9WdJdXMGpfNuyckAGkJg
zu&P}8!^F_A_;$n50}KqB4Gav*jI(~;JHpESFj|u<K%gTtmurH{HD(`OHcgYHmH=t+
zE=TE>(>g~kFsSd7Wp-as-LptbsewV%b2;yx^J~xZ^L;q!zQaYmJso7BwDd9um6pa(
z|NlOjp(+XOD-xG4Ia#mjm6X6R)%Mj?Paa>!4xy^0LRlRdl18kmnhXpXOv{!m3D#VE
zk#YI8#QoC0?W^bCtG)?7He2TPym{Y>K<8t-Z!ZR&?sH*g+3vl%dreKZFI#eY>)n@W
z_|6cD_+mL(u6Ih#x9<j4W!0;vuR3+?yxXZ`=k7iCJ72UJezf=EgNv@Mi=NWfHCc3t
zNp{YZ?5GbF(|b2FN!H(bwqEz{x~T`iXKJ@wu2-%2zzAJpvZHv`r|^CTDez(2rG1;W
z!ErxA3+NbbDBfDBTfo3@ZM~G~(>-rX)-hBZd${dtvD@`&pSNDx!T8wix*^g@-Www}
zYIR-?sNbf#MLX$M$hM$cD{h%7X9k>E8o6lA1!JX|U2B(YbGj)Ov2?4MR<viX#<f*9
z!X%~{Oq`vWmdiDDhUTm(3&V|aW=AV#EH8<5DtEnlx6?05($CAqDpkB_?%Y#l<(fC|
zEEkrJz42OBXsHflFBRw{>g-uZOZz$}XC>y$D9)>&l6zxKNoil-#*5diq_&z}?M+(L
zn;bo7iBjf@Yo@(PU1mGic5U2}owO!Y)@0TL>Dja0ebsibrvwEDnVW75GrcCH6D`Z@
z7_%wzYN)!e+71@bQWuaC)@_Sk7OzxQ)h*A=d17_y=84j&n<u>1PWO#@x#T)8XfxT%
z!|NU~)Pq={U1iGAQMdCV)=JFCI%e3NyCLGXV5e8N%N4bS0TEYqb)qgr986~I5i?C$
zyI^BzC&!d6VQV9jq9V2|5^|lax|(&VkfO@%%*>>yh-uSQm(HBT((R?<l;k@}b;(&(
zvztn0rjDJnj<|%a((RU*87P<&?Q}V+*KKj&))n=)Gd2ktUDWOI7E;|d?aZW0odTPM
zQf8`oCud4s>J;|zRyiBFc}<vR#F~JsGkv$orX4k!oqI7l<R<8lq!6=JxuHe8Q&-%`
zxsnsOIhE~HveXQ%S=-W1-JGc!^!{SFkJ)VP%p9}X+F7%euJ*dF$u@I!b#-W+7PaEE
z?#z_i+F2&`(XMVsGq!b$Tz0#r?FyzB2d>zbv+bg<(6&XHD{kDlrm<*i=$4$oHDP8N
z*UT=vom{kWwaKMSlUYZu&5p|G4U`Ua&A8U+Dj7L-tDvEaPgu^{6`ORrm6UVU0(Apj
zH~Mayox33<%&ckA#@vlzTDJ_hiY`u;4vf-`Si3lM)wlXH$;o1oJvqr?$IKRst~HwJ
zy3uvB=9FlWuv3~FUD*PCH@=;5Q}WsxP2cT2Cud){y6t?_jHS|9S7&<ho`?vWoZ^xp
z=DB6ImdPYf71t#*v$%Sbbh*}c-Q)>L_1u!X?Nr)D(b=YKtc=VNTRS#}o$^%F%{1~<
zx#T<1SUR8OaC*d=`l~%_!m@6*3og#w;$~!YJK4%GvT2IewxdSd7P{qrO1rx4S;lcC
z<A}Ar(JZq?dm}s3ihJ&;8Jhb>hh4d)b~b2TR@jL`-sqgduE{fV&aTe&ncS(;@yJ}J
zcc#%QkAMX{A8u{BwKaTAMCPI{j>UmV-EPX7630wjLULU5ww9ZTsMIqA9Oaq7#=R=)
zcFdwnQ_PKBI$5{foW{O(Wlq5DtW~$nR_HaV>`FD={OER{JExT9lxydr3r{>$_Br+>
zS2@$zqqOUGn08K%o3P5nnG<;@nq4$jGP|v~NkGbz?d)8!t6E(ei&do#Zd){)V^NpJ
zNw*ETk-f_rn5CqB8Q4rjvnEce=ejv1rD?WtMVODK)MDpdddn7z^-2Vpy0w?Y`nqYy
zg&SPTx^l@maW8AG*V%0!Y|40NzVf<l>gmS*YKrBymAPBJv!-1z3%Yf4TUgp+Q^^(V
zM|?SE7n&*YJp1vuEbP|IvloID_qF9bJf`fsx!Q1XvhOTiu}-H&TLP2XW?buLSyq3s
zd&b7z?OLWu$F^NF+n5z9Eu1v%!m3ph)g>Zl=RND{aXZ>v8nm_G;MVIQYqzd>laq98
z#m0>t8%5oYT@+okXvK}IqN1+7tCUhsG<pUJns_Ydx%r{p^0-CDa|ugVlQ!p^o>j*@
zw0bTXc^a>D&6T*OyFD`I=<2{+=`5~<2Nl)n^^Vb^t?9EnpYxl~;T5>8?90oiTzoDk
zcRRmt<mt4qt2176-8^#Rr9a2Bu=UJ*g0rOyuZ3y{Ma|mgImu&Ue2)3sDMxZ9Cd@F~
zwn2B<SsmROZdbF-)Gp3iY9blBY_nF&E$_7G2!jk$v9-ZjHx@44lC?T_+pI|4u*1F^
zx9P5N+cJgk>Q;X)6-gD@4E256wuMf=z|3SYJztiYm2um2#$8PIprH_z>5{&Tx}4xu
z9EM%0iPI;rGRX+HtWE?CnLtE4j(`@DK+Y5D^<#9c*W_L0oHfDJ|MS27%Po(WTTBXQ
z$yvy$$~nt$S)#Otlc&><@5SrhPSIOmyd~M^Zuq))lLA^`SK=1;y{k^Mdgt{x_pWN;
zws(_ur`;`AEx5hQ>+vqH$GLYVUd_ETL8Wxtx^j<K+unJ+J@-;J?Cwb>_t33&LHF%y
zzCNE*UR;0M?EBu==Plkn-<EHfoxZpF?zvqronC$4lO1jQ`d-qt^Htw>@7^A(5&J&w
zv)DG@?IlxhOU^A<n!7n~_oUs~dF38&*Y3Qlylva_lD^gXx!IwWj~picuU_|f_3nkr
zJ3)J~0=8Y-CJ5Ss#SPkg1$VpI)@`8n>;x$=2_}^GedhfWVY*s$(?;j8)Z8f0-an0c
zv5DZl>)bw|?lS{3(<N=l;Rl=zY&i@pOaW}Su58Ud8hX|25NIzT?<6m;o7pOBeRDch
zOry1~z7D;zX#vA+mK=py+$LJ9R;}dWcNWRre3?~(|L@<r@U!VB;AbJJO!Cye=4<u#
z-HY&)OP1=<)w>uN7~j;NiTl3SSSa?qq3g99Q_t`mee>?!%wlG-%JOoTbxHgjP9K{L
zj9nCy&YoE+ES<Y8Pi5NPt25s!H{F@RX_!`NTb@7rneM(T#>~MrKkv)EVg0dRQs<NR
zz4tClCaDG;IMT?$($eF7k8NYZ|NXl%1W%eUFfF^4yX@9aiOJ!4Pk16$y{&)unk${j
zbp3>V&Ww%A98HpZ6R$sixZi&5k`>!B-L=bts^^zpU{Icvc{pU7r^+QuRmIrN4h;Nh
z6%iA9JeAcB-@9L4V!eHbl7|F~!vWAPt-UE3>l#I0t4%y<b^GoG1_u7Lr0;uQ&Y1MB
zd)_<EnNjN^rk=5#tGBe+@@dhToek6Lr+e>Mmh^1(G}U6kCo}q!gajLBP1w5b`#w7_
zh2DFsUf<pA!(6^(+TPF3*H@hENZX-%vSDUpQ?;#wLrdzq+&eqCjc?AJ6nk<;a-Xol
z5k04;Z_d5XZ&@;%WoMeQan43fmCl$5iHS3t&g+|SZph@Te$k*Z(Sd>En=g~48o0q*
zU(=lS=;=h$b$Jd)LtftvaJJ-p^KQek0_pgky?5`-tCQD0S6V!;WMOVw`=P@>4hk4>
zOk!gMk)A5+Bc-$#xK^FG@=`IE3DhHL(4EWa{5X4K&h$LBx68IQioRBv<hSj6iPCG8
zNR=Bg+irGwZU~=VUUF1<`YzR#SpjWloKDm`8g9FtEc;>cVII#r)5{eKI4zz`ezxb|
zydCFOsK;-=wdvKTPll?uet4I@oEH~6^KO-@%EXl1lOXG6c9(u<V6uG=^$Yui#k0FO
zc-GxcbnUOMtgPPiXYbSZ)!TNi?kxqKiIltT+6AS(DU&>+9lE|wYP$tG-KcYSX8qa)
zu2m;hCTwdI(J8F*c(m>AqDeWT+|^58OfP=-t}|;APuj}&9_LbD#rduCoO6^TWs=w4
zd4|dfx2?C8m-J8GckSMnhFc#ONq4$zRkZuIB>VE|DbxBF-xQhT;~zcAQ>DvODQc_f
z9R@iT4gpRMCntY4@NrAK3(a#)w{WbFRH>gNc0sANPdm4?>Xy*tdqpnK*Lj#Gc3Mw*
z_k@p8U1pu}=eY38mrvjPX8YRmyQj)TPZjUd@9d2X4Q{r#%_?4RoAvhH-OlX{4t4iz
zujd+VyP3az``+6dAu?~)u*K;I*xuARxpmvEzk6$szMB24;^X@=PnFGT=b<w7H)l8P
z^pBaA^5#rL!QrMIOZwvFzMfQ>mh$H8!I<UiJkw5YJ}$m;+P&vDW*4xqzkPfsZsoo-
z&+6*xJHLg~`}Bi#_nzM<Us4>EbW_hzzN9#MW6pGm{#}-9Z*24Kalb2b?M<}WhKKE}
zMe}y*oV+;$#4Plb*=PHDlBdo|kkuX_yKlZeU|?GmIa};{_P4L!T^YZ-^Ftf~k??o=
zR$dUU`Fc{7_~xBrGFAoQA`?$PzPD2aB(NLg{K;<>r~f;^Bwim5w%jmh*5MuNXR^I~
z`!u%pwq2E&?9rMNCi7QJ-#+Qn*V6AfKVO*p=WD&b`TC**f7z#=`&GAduRaZKk@#8k
z^rSr-SAPE9ed{zB-`xxB&Dp&^;obLqt=G|duVce{ugS$8xa|3pN%Z#eJ?8PdXZxSn
z9d|zTVhQu<N;8}2-1YUhub;jv?w7gwcz<QezV5UA{4hz|D$Toh=1(-=esA0D(#nvB
zY<4j_i~J8Z&A$CUe|5{dcm5~-3myI8S;yM_LD!*CEpFQtTdCP+y>7qz+CP6@)gPxt
z=R6DB%bsyO-f75dkt{i5cjMZaSqsvlM77pwFFGA{Y0BxWt=??)H#27+n&c!h$#8b+
zGSKdud@fIpz)b>6Cia{;bM~R9B9|vekcZPGCz0a0_j512md#msVcEH#?|%P${bt+E
z4p)sv<=ne>vsNtOm=Y{J@%Q_EzpLNA?*!dH1|HL5P~l|MTC!@={&&o2iT~LSwq0gU
zOZ;<#cV=tDO~tMtpU`?$Lnm+1jlF-~oIhvx?DzKd4;@3NpXS;dW%kLm<5q*IY2~kf
z`}X{N|Ly7Q8}nqZeR=0NvxC{CH$C#m(oJ`cI=u)D300YA7O5MVcU#Nz=E@}tIaNVh
zTqXs~oH=tQxZdV)J0)yvY;5dw%OwR?P3y@#mwnWJQ&saxJs0Z}RU@sb5n-B|Mj?}h
zl#+BpL)|o1SvUphCv}A`5fJ*K>6`uCFyrX9o+!h$t0vu;oRpKR(sQ!sVAPhLo3mXK
z9vdFxNV}nI;$)WWEO1s*!tIFU<`l`zZFhJlhXxyK8Z1*WIH|I1$)=NCYfhO8P4h{c
zoaW)+c3a{C+arUH3-#O1F3#vUb}@I=v4F-aB9o1#ZaZnF+Ts%|I(6kHVc#u^li8${
zO+&*Za_2Anefay#iz`Yr?myo9>;3if3%_!y#d>u;;dWfLsGwOUSnR};f_cBIUqOcz
z89<wx7&w{SKSzgMyZz_t>bL(|q(!ptT`h3jylZEG<3?xUY$4xz1_ho29)|W++~@qa
zi$%T6K9iOhti9>=n$Vl&LQ8ea?k-)crf_Iuc<P<7T~U{f9XS}B7!^DiK-+2<7(jIY
zwrkh!m)7aNuK1?QcIj(K+*;{Mv5qZ_YfURZzh7@x{r%Iuy3FTh3K2U(Ha5kcH|*q{
zn=Ul%beLApqHCA6R@JZdw8_~N-8CgDy3~LAaZgbDN^nz)$`m!w?j>+@OK?-mnKNh3
zT-Y{IQe~lu?h-do4eOof3h$o3ot)eM!k|w2)$yy_ITLh}A~=)ku7A1w=yuY<a2HPL
zymzldT{jA9EK^sW<gp~!MS+n6wk`#-ld1o8)>@Xji9)wQ_atgF&AK%Gv;>p!bcacd
z9MkU}U}T?;a*g5*NhW#5F3@?IDzMuWCkJHk)=%5o{Ea{Q)t}X>t=p=O+KN6^;Sl2x
z>{QW-yK9?%XLGgix%BAEJJ}RDlP)SpUMtkh*=`uHOEgq8vR_(f+M4aT(+yt>G_WWz
za)4KSeBQm|_3qufcQ<U?x)r>K{*Z^+*6lAtqu)JbJ1X^gYb=Yj$h)hDc)LvRX6<H?
z7UHS*yP<DsyJORJ@3>@Ru9>mZW0TgM-Z51(d)r&xOhY!&uHAZ%wq8F!x46Os9BCdx
zEDa2d3Je}Xc2{%nD{^>%jzSU=0<8yOU|<m2<|NR?u%#u7>DnKUj0q|x9zqI&pbPa{
zqie5y-gSHGnMt{8yu;pC?AYYHx;*#Dy6F0xNzQ5$->6M|)8)x((x3JMG|GgGf3C?+
z*dP>HmZKT%omsBXHOsYk*Q$=-<oqIqlbf7!u8J+$taUW{$Yi0kq}(N&%X3>J)^e{_
z=$hrUZQHAkAh&x@94C2ls;yXpY$k|pm)pCI=YVH`?#-OrGiUp5R1fwDPtIGh)wj63
zq{GN|a@r2pl{%-pnT-vESf*K*iL70^W%mSEU!`MrLtQjCZr>@8a#PVPt2-!i{zvfe
z+c~v=t8WO1{M&x#IMY61j?@cn0WutciQ5<5X4)^pvFUxJr3=%JDcdtYFijKTNbkPQ
zJ%`gRb~`&ObDR*z<d4ds8>Ba1ot`VsEKz?ucQzYG)P^G~T!gyB)F!p$#vSXQ0dlfH
z_yk7KG|1jBFWCAW5(BwBf*KtbhP(K4oRMs)C@;!60NN@hBVR5f!6wA1u&REt$*NUs
zZOX!o22xc%lcuP!_1gLeJ1}bQ4Oy~m!B+-`3k;sGrY!cFRk@1S)>oo&@f9vFF9C_K
z{#U-LHA}h8V&j^%qzh#6=fL>;``%8Ml3+GtTrxdSf?1@#Wp>!LvppAQF=uFQbxsW3
z;<Z^LENf|y+qI*fTQ{|x^v=jJ(^_qGCRFFN(S&Cc1q)}Zs!hz@5OH;F)6uQlP6csI
zGo0a?>*d>#8;~2A8yf8zY!tFNNZ0IY*D*6EwTZc2E|+fgWc6eju39X0Nzmj<w$!nW
zIng3pZu96)X3aVlP=DoCbJo?|Mb}IhE$S8(Y4J6cI<|35;95~>*KH?EX8A7im}sPu
z<D}x#+i5bxbIFleKAa{qC#rbNG*rtp_MGK5+2fF}POh=ek!_1YW(OzS^0_JObgg&A
zEwfeHfeK4}7Kde>^$8PJTgE#nH#jp#bZc;`?g}B$ey5~uW?NOaEU5RKDdf^Q$t`8J
zP|oCp2}e36sW=N8Y!*wDTpDbo*0kWVr`U!TU)?3$Dcvg3ITN?KPUxK0x?qbIx7dX(
zTT{AL=w!3@h?#AjWV%8p>_P-sx@*R&tb|#fER#}BbV@GiRB}0SQ&2ghQ%cG0wu|S6
ziHkfYnxsq=%H86!&CJEKzW4bwFO5wa$2P7O@ipAI5xg#A<Hj|)5m%y)Z8W)(lanp7
zve#{KU~bZlZMusC*JNxnl{%}Pxi}|EVzSAMOG0YCMw_*bHmlCmIhp2dwB)SfCYO_)
zW|K3GeT;+FoH#QrWohWfoHZdXOU1xzG>#^R_PVXfU8Jh9CgbL2QL%(;roG8ghOS9n
z#}?hV70}gnO`A>ISjD8-L&c*-C6iZiiAmeUB__SITsoYbJ(u=wnW^QqDR;%pjN5K%
zE=x|kUEGq(a@w`ysw&GhjjWR`v(zU0t_jnYPEw1~GT9us;^>s=2c?+R>s6;NSu#1g
zW^tBsh})4Iw<B3fTYGZdbhjC9?Cpu@b_q!ioNTmJYOA!6%8iL?LMpdhW_wJ|6iRa0
zZ00d>l1h3`vbj5_mukqwG;a@cw$o;>)@TO{dA9R*ba+kGx)ycMj5pzebWpU))Jc1!
z7E1?tu3g8OT(suYm76NF&2z-oiq-Q>eQ+^EaJ9;`Nw=nT>nJHXE?aSGnv#-%PS>Td
zFi$TPk4}{nlhqkHR+n>T2(!#u>}0~o9UQ2UW7g#Dsi~_n$<tGJ>10!uS!)+3XI$-d
z+n9ASr+1R%b`}fWtz2mfT{g2Nt=*QUDn2nxW15IzlEguSLv9P61!v5h;(5ty$GWC^
z-(*=uQO}M^3%y(fCMCJN@w&P?OW4(Qu}iL$NyLhaT}RgXuH=~Px#X6kl1tBI6^~4I
z7A5YD&MJ&km4#dwM0BRAY??C3Q+3Kjg;l0mHzq|`ELB+{bZzUM9BH?UOD3(<b(qG|
zs9U=2cHZrh+>UL!ZcCPIJDEE>#WTu9XU3vT&3e_%UO^K&(|HVU9DAUq<l^QmCAHdY
z)s0IYcUq-puAFjf#wE_y8A}UR9p>1OvOpndXHu`!Mp4!%r!&TCS*trk5|@Nn=7sg9
ztd%%sHtFQ<tiAn*{_UUt@2|bkwA<Tu=kMOVyE}JkbngD0Nk>+cewehPV$nW<OkK^X
znI<dDrmdN+5s`IrV_3qKlN;4CB+hCp`-W{v7HPYfGi$Qwmguy#nZ7GmyQTWBosx0t
znnv2hp3Y_4R&CqHowzaD>6R$p(OOrYzdr<KwkUG=fa?DfAjTnq7QJ`7cU_zQ(U4hr
zdVvwM7-Qh{k1H9)rt?o=(qjyRtby4h%Ph^B^jtLe-1G&0jJkN%y2yeLg$5H+kl`T2
zz)(-%bo<qeO7%&h8>Z%{M%UWCWOA5zd+sIh-kZKV?;wLYoJ`TV;2T_TUAy0@vM?#x
z!YSDzVp70H!#RpbNXJtnV#YZ!@D<ld$riqAbGK~)Px^B5z1}%R(QuC1wQaYfZs%qv
zJnoZuF7w>-xaghSJ7$8(x%Jx%H>}M2`}6MQ<$T3`+j6hRyu7@ePki^f=kxZyouXeJ
zd)~I{%fhPNJKy`HbKkvQzUS-voQ2i9-c`Q7zLfj!_2Tn!-%g3I-n|zref7FONOkqD
zci-pjtqRzCx4im%++K~icf0pKUmpiD?cV3>>%GL+z1zJnx8~<3Pp2a>#|m1G6>L;l
zShIYu;T-+YyYH*OevDgReOdC**YfhcFMA$V?OykMugb!zd0&nd><urzHz{B*#Guu?
zAwuO3%fri`U0J}o>g?huGw`YZqN}tvfJT&5>lHwC6bv)I*|9|zGNQzE$rQq1V_ldF
zmFJz+z`&Nkz_?YZOUrD<6{skTs$S<J!pOT2JV3=_)&@S5@6bZ<d9WM}3~Vb!H$YV~
zIV@$+l4fAwbP&2(58nF(Y7<J$2Hj^Sodz1XV(<`VWZ<2x#<bLNSp!=D@1(x14mW~c
zE9EfNRvkXFG2y`P{kPNRS8soRm+Q?eca_)q<&G+oJQW^rG&d;mF?3iksWeybUiijS
z?bewi-^;~xb9MH;PSc*j!C)+|_wL2iGb{`eoA2JeEPBSFzCpSs=Q6|Xc<H<E@7}$$
zuJ~-|^Snn%4wKv$H(go8GPB#}>)l;b9lNcj?U~uwVUf-)^sTD;V$zNYDjZHuZYtI1
z?|olCeYU6a2L=X)Yi5^o%|0sMz1@{`w7PoNp&2`sqdr%hHPoNj|Mcgl?-F}I1Q$No
zSHQqf{PR=hhpcHQRc5)@t1QvpmchX2wlZhQt#_xKcBd*W-RxzwJ3Yy>nkPbHW8!q@
z`6ZXH=a)O}h7M9Os!Vb`Ajr<(BEu+9z~afyUSiv+a{K6vdG8(_UAy}2tW9YJ?@k-W
z91tsdSuT3!;p$CC)+KPW?7j5r<cuBVsWa9kF{W>pGG<Yo7qslQZ-2c``RQF-?lA|O
z?^=DndfD#0+k$WV3%ru@W5kvUBs<BScMM=*UYC1i6%Xs_>}5V4my=J<;ATA$v$yYe
zjZU05&uyKEbt)1nQ@*^fUbpl5dO6=Mpv5M<Y6ln?q<k9~SU$(7hDmQObe+CD^03Bq
z#kYGCePVj~rEVYFnty)s^V9zIW_Ra?hrVwS7Pgb<Ipb}-he76F&8(W;wRgGR%vlT?
zZt+x^<YB=Ci`!0x2ON`px5iG`)+k!$snWWIV~73H>q$3-ydLM4=}rO>lcOEFPqH((
zJj|VM=V_%sZ{M~Xn>;r}R`1@WGx79Yq3D^j7E0%CzL&Xd)=o{c`Zq~tmpnH#2yVF?
z81zf``~21&yXQ4s+`T<4-lV$kdAIMineTFH=WbsVsWREvdVYE7199+39AoM3E)K!i
zZHGG559QQd&JLeAeP{KhT+lcg#91v54qX+P(ZslIx7dkEJ8lPyoh;n8TkNFD<Y<Sk
z-71ruZn4Bjz22Bp->KcZ)i7teboR!aS+~j^*~`9{JFdL;*2r^1*zGMR)edW{<@Ee~
z;DGx1^1T*5d{#I9>@>8Kyl}ES{H4&#?a6}MCi%87^e&s#5o-OQ^0nHwFQQ!>xm@eM
zXR#b#YkYe0v~McUPR_i;eSm>OK*8zLr%#{0=Was;o#}Ojq?<zF(pgD2^~|m(-89|8
zv1dX7i=WunxNY}VKi#6Letx>63bRCg=Dc?=tJ2E#85EotzFKa+{rY{?k6n8>a#dz$
ze6Ol{yDsdu*1mgdbssoqyezw}z4}1g#mjLk1hzNwF5%rgZC%`M-|Ne#D;C*E-YHJc
zuX=0Hy62={?%G|h3EO9Cp4}=ld3JW*L{BU2myb`Yew;Mtc63SC!F(oZcd@T-(Rnx1
zE_v2(>o4yYU-ho0XVSNidv@Q}xn-drlG=N=syy2#THWk6%iir$Z$OM4$99XIJiG1i
z?ZS0OHx=jZyyTa=24t8~@a&W#-`siMPI#J$x}Nxu{IWVaeeWi1);%1#GC7U{XPG>5
z)o$6|vz0lUd9m<GWxmP;#Vv&!S)5J44z0)Q((c>4qmph~Zo8rScE@!P<L)uj8{7PH
zx5?e^Ez_MmI~U}`+;6X{D|6-4&2EDnvVHX}@n)L|dtdy$9G&}q+q`?xTDR`Fi!nag
z7P)0o?&7<TFCMuZefxO7eZIba&gP8zM;6=IC*4fDc;sDoV#<cLOP<@d?>@e~B=-EY
zZy%q&efso`;?^B=FXre>6S$qbcX!79=6jagZs$nnZu?p7e2-&R_6eu&joWUgy<J?X
zJK>f^pKc?_q6xPxv!2RGoY&Wjne|Cv@8h#`_sZCQe0{w}e%;m|S^K0rwl3RxHtCL{
z!jbxYZS$Rlu3bOz*^X21%)5%)XLb~<P@WYN+;iF2SZqV~6u*W|7Z^H2Lql4{va?RF
zj1r7`B``sSQ^i$fQeY2sF_?jyrV<pYuiY3e)ut1BY+Js->vEApGkvyj-7q_~HB=!h
z&{a`d?WC#4rO5fWjm311&e-VRzp8%0lwY}9j@(?Pc1km4YC>Su6R+j0p;J~ep9~6`
zR2ed5$&Ap5(Aeh7@e;Y)j!m95TTjV>fkCqA=;yaz_vgMfxqe#Zh|Q#PZ@euSJiqQ;
zSaRuf-d&SxA2U1da%>F^^4Ju+D|79myEnHjnE_gvG(iPCe8woG1RBkeKc`yGS#Ql6
zdPC))Rv6ccQz4BLwfvY?7HF*%aE(*tka85@4-Bn7wCaP<(n7BZR$Qx(#%}tvY0kwh
z#nCpUk7pmdJu}<W*W}7dhfUjVh-R&FFzrbR^zE6gVmisdi2*eFz~ti5DX664(y0O-
zyQ|xEYi(#<-Tmp$Uw`>)yY|cNH;WF`3*UcvYrR(G)zdcbIK?zJuzWsuH7+M$0|TS<
z`nNyr*Y4&uxm>z*nsuzu>DcWd*LQunbUgP)=CaxAjVA31x}Lr0bnN!TWwY|OtSQ^2
za@%*?J+sRS7Ea793KpQ&-67@{HDf3n)Yv<OkZAq=VBNpkzt;8T@9)@beYfUz=#pp4
zPItL@=WPA@>z~~Jc-xAP&#Sg?-&Xc^iGF5&%#m)@3%fE?x982uu3X0CU82;rYMPk$
zc3;yy7j<vyMjYf|aAIi$jeoE-a7+XZiFo`vc$>G`z|3|31m`<)l`m8_&g?L3m=y27
zP}=;3)9ux2VJjrFM03=oQ=?Yh==IWAqMUM5ZKVWghHN4@eq1^xfH@z-uGYQUHeGN%
zQwG!QT+pDBD3jXl=?@*5L>arM7rtOtp1$fRlhkB^2a?Q!f`ZfMA7xTa-?}!W`}zIn
z*Uzt?y4SYq>+9>su3fFwt^2z7_W9X)tlrhS-8VC~Pu;-4B;*mX{q4`%s(dGbzM|6w
z6`zf|I)fPF^OCIYUD(i~yX|d@qD=IJ14mhTl9B>l!`A3b&r#%f_C$Zy&(+V*ub-Zy
z#jI7IvsqGQVeP8jt3SVbw|3P#6*G-9smVDXwXM3c7R<Z%ch#pw^GbKvyz@-zW?*o8
zePq&|10G@w49cb7kAJ$`qR8QCs<ZXh%WmDWyFtDaPdv=t_C}?kWpc4*_EO!lT{>HD
zmkC+!%b#yowQt}2c>lHF$ORLy7`Db0#oyMwd-wWN?SKCLx8HyNn*aOX|NC#Bzy1EV
z?!SD!-T(Hp(e+N#{k55`>a#_gjRkbPfA0Nj{&~`)<GHuj-tjJvF3$n29Lz3GnRPoa
zXOgGdHkHkK$;J|!B_{D4OJhq@U$}NQN1(b_UQlNgYYr$H`*>0UJ={)ivhaKkPVWw&
zZ05kA<S>zeg~PGfz%Y%;LoBuG_3dJvOwFx_QiXO)=WV;UYFT}w+U)fni?7R_Tr$g1
zb!M^P+BCyt!{ppF?UZZZ?i^Lk-M(5&W9sel^3rYhR)N;w=BbJlWml{8?pTH~E@u19
z?Ah&}14m|d7#muN<xLV;<TvHcQlYZOXttZHLjw=?bZK(jG;`-P4+6DJ8(bO{JR0g5
zTpE=ah3v&|fBgFGcV+&+q^3<i%Qp2EeP6>9^I<<jgM!Al2ZjX<3|t8e3>*iNYM(Ga
zxp7M9zyU`lfkqZDuL~D>Hi25yO!HZnF@V|-<!#?j>6w>tH%@7CWnf^CozL38rr_Zm
zLA&Hb1)!F)V4D%cL{1f@`70lLt<qdjpTKM~(^IQ~fo0j(kgi?{Wd@b6UZR|AjmsLA
zEY)20)#u8ETO6XMnx1dHX85@AYpPy)zbIGZ+P0=!YFCyeUClX@wZbHH?aZzV8Mh`}
zT)QbSY?GAetXpa+J}2EG(;U-W&Mcf3*%FyLBQ$kds;BDKpd8m6<wWhQXzo<c4HIXE
z%&hOyIT|`s<z`T>)3z14fzhg4eV3|T6`ZlsSS51OYNLs&($RsrxlXrkEX~bXxW%_+
z4QrNEYogPPTRm&SmMu$Gxs;P>GMm@vOvq-PQ_Hf{4xHH>8q{r^5jop2Eoags-EG{W
z8QTsfN9Rls^^Hyq4og@TDv~%+C~=X>!9^-&8J*1a-f0<~5~mWi%`#^z=6Xg8+*)mN
z>0+)*u6ELDlVd6~dz3)KR*6f_&hqL>Iqb>1c42UKinP`(ryIGxQ+-!WIkQ<~wb5B-
z(?Hg(qGk(jg&h?;6z#MuWoqgM&lxJqZf^2AcGcJCs*lvl6;iX>ayrg%ZR|N3b>?8~
zms`=<VkX&A^~W}@$rkZ7m6nz|nslr;Ib!4Dh-(_NlCuK?7v0zf+Aef-V@|fPuiLR>
z8@*<1GnML%xR}+|D|U1vXgiVG#Hog2zMB@^ICWZg)dtT=X_HNQ)jVhUTuPg4GINQF
z&y2~LW|Kj~J}1E=Y$|8fGC76SCMUyWT4vX)-0+wwlquObb;XsetSea&Yr?d}j(7z|
z+?cXhwCiY3n6`*l=!zSQBd(cgfCiW%Zo7B|Mr_=2v)66Qwd~}i-sA|7q@-EYHdn8s
zxih&lwjG(}?2#$u3mR{la7oJTl8Td%l<yKJA<z(1rb*j`OG1ifITMuxCS1xin_chV
z$*DAT(>7nhExFQe7q?_f%*<Hhc5zEa@8XQDpxsDKi#A5A2{Uz5i_(?WxstUZButw%
zB<sw=tX77JYA4M+C#l>7QJZ`xrA_vjW#sHJIc2uWNuiv{DGir0h217iS{;8|&Fx6e
z$%z}K1vg3yuIOE)JJZNaInAfH<7(#SdWjoHXB+nR<Rm9cOMv7gZW(S}23m)ebIi;z
zBst<}bn28%om)E1W~p_WO;o!C8PO6_xvAuK+2taLpD|12mdlJ3knBkzGZl|}n{!(P
zj<$zx+L)=bc0K5%VNFd<&A@GDOSauIiCA$})pHv&r<$kAlEwVIi|ZvhIuzR6uBE*;
zHTF1D%XGCX$vf#v*vYL0O9cfz-I)YTdrCt+Rnpd+@%FgpY&>OA!N#dw6I8aY-9B~I
z*|lr;CLQZ>Gu*ghvBZswfx;e_Qf9fd%=VmPT+YBS$y4>p+NoZfJWhHY4SC~Qw07I&
zfK^<R&898(I2<*}Gc#9p$)u&r>bLhqT<kb@)Xgwy(#c3&)k!CF!-IA(d1fy-8RBd<
zH!*UFxwvS^?5W$fJTu9a=$6=+6Ot_L+U+*!WTx(tO+jJanYunR1zbElIv2V0G21m;
z2%OSYi%LyWyOgY~bLL``Ns0o?<lunL76V1LV|PlYt`1tecG{IQGpD7_ycp`dXjMS_
ztc91_JPw`AT<t2Y%agO}&?3Xgpxa&tBi4v^9o)KXw(88STSU7iZR`p4HQOp3mZ@}e
z)6q@aW+iw<nE2dS8#&b{OytyUiL1>~S6Ba7oppcr^a-_$`qS-Mm{_MburNu3Mv-(y
zyB327gd~m`Zi9^pN!^&<$iig8)SELMyqn5ipGju&0dX!-7trD%uWdqWTaXyj7aB2Z
z*!Lt$fR`3QWg!DgNu6Pb-5{oF-9VgJ17dXqNr$vuRov>48zjvcc6j<iIcDMd-T(jA
zJx&EpY4(CnMfADMmIhwC1De$|IS88J1fS&xIrC3^YI*4E?DDmbuAO@K$a!_{UB%nc
z#k<_YZtrqlc6+DR<J>z_3%9-V+Ht#FqwMNhs0?_e&@Iro*0#HsWW%<%KHqouIB3Ze
z$l&@-EoTkVK+B%Y0``{A*t%)mqiZ+IOFo}~p5n}X?z7mo&^ys**2JxQ_wLo6Kb0yA
zIn^1ZHGJ3RZgw*{qnygQb?ruJ4WEm>#+<4go}lSHAuoYR0ein*y_W=X=Czx#ccNss
zZns`i8eQ&DTJBMryL*Y%+TBYy`EG|jS1ajTo%fOtI@sn>XSO=~Td&*26<4xMrQJ4y
zh(&9~);3JN$mUwlFRQ_rxP^g%k#hk<gHQtpqXvkQ&dj)_Edi>_K$w5721BC;lalDt
zMJqsj1_p+P#!cD`3=Av{W;a({l}1^e&8o$~kh^6|Shp)|*a)IWg<Fe(!HXd?fkA<T
zbt(gc&I*RyZS|KHZwu1xjNLFhsP)|a^>5z4{X3DFp%ZqYo5KMmHbx=PiXVjp!T3li
zk9CcpMKO@2G2Z3(%gZk3ZZEH`eZTwtwp+FLo_;UeoLTo|-<{o?I?X#KS9F?fpB-<P
zd+u}0sjBVKSI)k+i`U(AYW?Jo$>-<m{R}x+@uB{b_mk`Qt6xptc6*k?4W{@SL9?0m
z&)>%}oz4eM>_t~_>+TKxVZHP2*>5ikAKiZY<oV>2muvS33dPLW_xq#z^7o*<UB{G;
zT^D<4di3|@d-wD+cRiYwTX7`f)(45U+0nUs*i<g(c2C^;Sm>qc(eKOm?pb~P<W{a6
zoz`UcdDZXdG5@puIo<9TlVtt+HN7g~4jtf2>_DXIZs^5u^Cm9)_xt_o4kz*3_lwq6
zWtN_0`pM(_lgqP0WYPys)o0iDm(9KVSgrKw_Sk2o)7N=kwOz|UIr`$#vz#jm?wi;<
z94Mdm-D+mVl$Gt%r=MJ3{qBe7?W*}I6K1_F^}L;XRw1Wee<#xfB~O?Abt{-|hcYlQ
zaOZ*;%&O+G72LXe7#J8Lb06qz`@rVqz<)yUl!ji#q}n}mt;(lX%=ulZFY~hSQ_S>o
z{e8dpz2EkS|3e+ebo*aS5)$a%QQ=`y;LHCIJzX)INiEgvnpx|UeZQ}VSCxHsuDO$^
zw$kk(JBNqoq<I<NTdw!>YB*L_`X?oxQ%~J9i(&44PnCC*Jnws|Jn&T6nVanC?^(gX
zz_97|fymqk3=I4e6p!o+aB<id;M}QS{itky?bgOe72ntInZ7ZLNqGAHEGE`^PnFD=
z%ymaM#pJHZX=QqYezP0+wm0<a-Fmn7F09_2{$lp$xz$ha+Z9^uI^^Wg(lS$D{q*S*
z_j(kcKDAl*^upX-(NErP+gWwx?Y8#}Og~tr-`PD~@9CX=@6ET~*yh~}A*OR=Gx5~B
zZ7t!L<RQTle$5LsXf$0qTiRy&?sVNVHIJt(X_;C1eNV;5_x?%w(Ybyn6;yBPPggxX
z{a$|d7XRF3-}UCaU#GdKI@ii08pMBJt_Qw%ZBccu`OcD8TeiC}R8I$A-zLCZ=Fq|L
zzFZG_mDwT&+tc%HrdBNLu0O!N9IQmVL0V-=97F8oo!@OHd4_jo>|xkd{CraA9`MC(
zMK90&dNfOY+vO##yIsEB%KKjQZZ1@$db(fvb&;c+^mZJn`vO{vBp#Dw550fQP=2q>
zwHe!7uS@h_zIoX70qbRmtp|7~1?e;By}a|gejen$IfhtE@SST7{6){tt8QDLopa}=
zf(t|W?&-zvDpf!iy)no^u1v#b3bG+u_cXgxVhcO|zIe6;m#da<ZrgUEo4?9tYW<F7
zAXep%qG>k;6W{w)s!ZB0at*|EpR`@%BFs`3hPxA#7_9G}hJ_BqouEtM4CTS$r{37P
z>w)KkBx`68FZlqKuzkS&1bQ7D<0glBA6Vb3p0s;D$y4j=vUwj^>p%I=^V*vUkB|<=
z-B`Ts{p<a{_vi24{rTtjyP7FsmyccV&fdMcGRf?I`})gY{+OTAGTU=0?t}Zpi4&Ah
zDSYgyII7rZ*xnVQwvB75x9LW&#79%g_t&it-+g_5<;<D0Tcs7b%-ldLd5r6gjm^2t
zoJ4Y3G;T_qIdkTY#!b+grNt?VZYP|2C;lxxv~$<273Cq*s;_sKiMTjFQQhvl_R;Bz
zZ3~sl_I^HJQ~iGB^?ji352QE;O}hVi8@4v;);~=b*C|S>_E(ftt)k!W&cA2YajRnM
z<Iuae?ztxMGO=Ay@KiLv`_<&}5BUQ}=dQC^qAD8{!n?rXR@}FDHWf!MO*k%cbnZF^
z$J3L<Ri+qvC7rv@P_8_+`WvY3o*ogvEME^|X~aC2d3MM0oPEQ3){rl%&KFkAm=tu>
z$;dM()hV2-mHRuB<D#Ic>_s6qLSFHls-AE8<Ku#OSC~ziX#Usw*Z<gRlW7a(mHBP+
z_C)5sJ}9(mYxUaK7o*m~Jp*Ad{&}@JYW4TETjOW{;b7<qaIC$$L%qJ7VX}xoh60nJ
zBkSF5yEqscn;bY8Js-*UAAg*=?d4LH-h#`Iqi_2pOU#<fk=&IG7VB@})id;hu)Et}
zRU!Bo3kC+p>J5^w^KGAf`W3L$Z2Q&z71q1WyN+rs<qErL_W69>p1u1F)3f_EmMmWJ
zgj2zxe%3?v_j!+x8Ja9HJZhMp-KbdfWRaJmDo@ai&07!jJr!z-c2#g$(&e#)71HK`
zEdv7I9RZGfV`F2En@*smYT$+t_wRMDcl|%9GRyn3f5xpzYI7!TnKIx1{(7-z%KQ_i
z-pS1ui$1zGRBG?_?%1vi3__r=0qyq#(airtx8`4&e*OTX=yU;1W|ip%DU9q)URyyU
zH!4EWptiV@l2SI5&P{=<6lE69R+^mOrZPDog9pBoPnt=kW4cZdvrIks_(DNJ-EFtl
zpWVLt)AhHaf;rcFw^STkuN)}gFo}g%P3`x)R(ttw>v(-ljaQQ=s5CPBR^Q(7@v*SO
zG0kr47<N66Kyz@I94}I?Iw}&VsnjwF)W-AF0FR}ZfmUrRr*eW8xh>39GV*j1@)9=A
z*>Xl@ihgTY{nek~8`ik*tv$$Ky)I=zvm=9G7l+>4t)L6n8XUO%1&;UkF1x*~;fhqj
zt#6klj;RH*8T#a!-8Ern;nheM`T70s_xqLiOJc5r7NjsRaDqaMfq{YlY<6}mXqE}e
zXJB9e-K_@ZWic=?Tws5w;Np={KLNCEhylEwNyzulEqAv$!U3Kum9pRM&%Qg`JJ)RK
zn=5xqADzxGn!am#x7GA+t9$RhpSP`kj+Q6CZ8uwVB{%r`{@RCmhdLVcoT5u^-P76L
zoh2mH8~6I?7N@Qyv(IjJxztpUds5hYcW(9O{G`KkolewyTzh?V+P$Z#ihN#MtJl8U
zG-uToup5yG#;@D8pKjM&P>>;1zB}6}U$atYmrhG>-m2R<Aum-MqxN1qRXQ~eG&Bku
zEQBtay7tJI*^@a_xo>y(icJdK6Q<oY+up7F=+jD0xAmouZYjD3`PTpcEFwB7)pWW|
z(g}g&M^k^WFfzJtXY6iZU<hVlU~pq*eLg>Rfk%^oqnmF4b5xE*?yOX=g(}-lbAl#9
znd9vmc$yd(800PT?l>>Gr2%e|+MZKCamF~VM!vB9CMX8jH*-HfctA#_!!h{dqEN4t
z%M6YRo|?f|ZZ(*2)(78P8KmUc*}^h!m6E29nleLBNXXy7U(2Ls$}MYHxiZjwg$aXf
zV0hBrwYgE(u7Ze5x74nNZQU|$ORnzHE!&!!T_JGmmNU^2CRsPGnf4~#N?UB2w&sdz
zq~nr+oLP}mr$N!AGo3R-Q>Ud&i<F#nX3ESZXIttodzc+u>J=5847%KXZSS@tEuKcb
z5k5V^iP74rIm^yYot<SIX6P9-(Wp0SqwfaLQkmPHorY>Ex6LN!Zt0k$;$-CPx#UtB
zr-Z6kBrBJQ=H{&2jVVg0i=(2l-L|?ex|nfoTi0#rFs&<*98swnVK+M_srWQ1Oz=?2
zx#f1-qyD0b$1Ee4P9CANGp>e&8Ez6Z>COsLo0=@ulVupTv3D)_pyk}|q#H|@-Pr28
z>{?IQ#hhp{tz+93OC5FXPF585b=$a&>xu+u%mL)Mi5od48u6-47RoeKo7m*5cB50t
z<z%O^=eCJUE+u<T+PZbyGNFYgm)y3r_;PJ>J6SKS5*_BTb&H3~(xfP%3s=NUy}hNg
zJk~lUH63N`x)5>e7Psh%36qq=*4*$_aa8e{DX5m>DWvAf)-gGw)2w3xN2jz2C=jGv
zTxO@ZGz7I8hnaGTZZlk+u_;Q)?C6%zMb}nNIhD3XYMaQV)Wl99PRS+5CU~eEm~8BE
zQBrZs%=&HGVO}|!n{ridx<*b*)tsg2xM{(yg_29XPWt4mF<QCe%$l@YO3}P~*KX?a
zRh#Us9G0{t(B#;$qb^w;E2K6@+;VbqG7Hl-xTZF%w>xR7;fgCEH!gY|n%b=_D7oae
zii%suMJY9B&sokYDn7G(L2FlhR6ILpE;|HTfi!VTOYkh8!$z~UlO`H%(^xv`q%hZQ
zjjX_xj=3VKIX&K)xw?x5yEWaGrd=}g+^8ftDaXTOrm&K5j>iPhXvuA1v&pH^$_d+o
zv%;?AvQ0K}yXB^G%y#MY^UloD^;HI`S6Q=ed#bJDj4bZlusJm5?TTABr97i{Zppbg
zQHa-Uv2t2R54Y};ZBgEunwp-fOVti1+*DaDopI}A*ljU`s7aIEI>neoyG@17#5#Q@
z3Ykpum}HcZmfp;9b1v6S-?c_FBUc+;OKI|*WHu|eUz9Z~SEcd6Aw`MPyrJ52qB#R+
zt?k_EbF_Hd^g<VAvHD7$i`xVw*Syf2+U0X<vv22Cp9|b3D^_u(Ce2j4Rq%)<aYs`t
zuVQn);>=|3d`*dCOQ*QHb*#y_*kvlQI5KF`$&_sql^oSPCZ|i@UbJR{WRQkOgJ#N#
z$u6EMvpi)o=Z2lqP?>PYN!jO&a@y@J+g3+x5!2FPyQ!@*ap?wgiQ_!=XK(t31g^>L
zX1lmC>DZ!6!C^;w6&2Nv^s3BOIW%jtw#aRdOHA9YZuacBrMTF`#qG9v-<4%6jl5Qx
zOD^l#b}J_1;$oLvmnbtc<(!<H9G7gdE?sF>k)ugIlT}U{xy<mGI4M`{l1i?!hKr|X
z)Dh2UK|v!1r6WsKRaJGC%t`E5tLHnjDs9!-NgmpwKHXWXv$_p=A|6X@+O~CLhE7NX
z?<Pr=UUg|B!EGmcdD?Q6bLT7-?zx?I=XIFj!c9s_hQ2dy>TEi*SuHKh*j(^#sN>yG
z#~++GjC#UWimer0quZ?(aCK?aMx85HJCjXymZbGuGG@#2jWRQd&YZR(H)wLUcaG}H
zZMRd_<V;&M;g)aOt(l#(f-VPb)7%=Fxs`X?sau`=hMte3qob!6vM?z!-C6+}z)@zp
zos2r<BgAw&XL_J4v-0$~B~0p!BGcFJVlrUtoIYQlNp-S=HT!gHcV<q;L(^^CnU$gh
zVdFwQ$tq?mLEFTpr5*J@|0_U+lgT~%`}@3tr^R!2Z{2(6_3l*eRo{EF(|6A;&skVn
zeed0in@+F3z7JfR^LcLRC6!hWubUai9ytY_3Yq}oe4hT%oq4*}yzhJ8hnBBoN)obp
zt{1a2=DDJR$8*b~r>CA<g4PPDZo75uc6M~`+8mYXKi!!%xUW{NkDp)Fbz_w&cx#qQ
zM3yLMbf4L)fkAOaE{Ms%?F+urbIVmw-6tUx#=yW3t+A*Vydnl91Zw+cM1#miFvZ~D
z$Q8h#!oYBvfq_jlNGD=r;HsnG1BAuu+55a0T6Gu%0@#=u40J(*CR!m3prhoN99FJj
zU|`S%ubvTNVu%Fs1e{YH7`UTu$7J1>+WUU*`?~W#@9+QluWJ_r+qSnYpb4AM3*C`r
zhroAy33;kaufF$vcHQ^;mMrD>-W@z?*00!E`~7}xbBmes?%hv{d^_sjz56LMIkTpX
z>4)W)NuEJow}aGgrG>U#ijTJX8e_IvTKvFmiQBnbF0<Vh;%~lP4LZ(s+s)iPpR2cB
z-}n3d)T+s;8XLF${=!&w|K9DK7DcY@&p-co_49rB_4~Dd|9-1EeDdaxV@H`k9#D3i
zRQvw${O8YZCorrCy#+d-V#0y0<@K-DGH|TQ+U+sPQ}=!Kz4!Xn@2BrxFMDWR10&>0
zF_oz$O4njHtX?R#34EE>{svA3RrOk3H}A{K-pEY;q?D2I``uSJLD1D&9JS?#p6oqe
zt~?3O$gy+wT)6a;xsZp)E6;#+Csn4ZtX=af(rtrhTI@a7oyGP0YQGA_{XTE~zI<Z|
z+wVzInag-<)>pjUHrsdOw)3g$cCPc}Tzz}nZIHjG-A+BJQeK{5X{qVyWw^0--|Kff
ziyLI-gE~ESfBuxmy*zL8w(|SRb=OaFznNpUX!X5Qsy{mQ?W;d5zppQNWN~haS!0t>
zY`wkp`!m1FZs+d3dpofnw1o=cMMxZaOwKNYh5-1+t#xhN-nL}1?_=Wn{jfT7<M&?k
zy>Iru&sW{H^X>LYw`0zIGQDDC+`H{|-ajGrOz2%)ri;5T-`n%}h}^8&w`YDY`hM?A
zeFCWADbFC!Ag<aPpS(Le!^J?UUP9{jwrvdzwQq#qXWaMB-2_^1rTTzD{QmsvIK}t2
z-|yE{ZMW<Cwdkk5`TM<htGDh>40k}i56oqD^fu8F2HxD;T)SXbyeS89A8-t;)L(t;
zPVMH~$uGA}t>Dnjom#=6AF_D%y-EI6#+IvhZPhBate@C>Qf2Dg%TQO_yjNA5=dLk1
zz29HI);~}9>gke8TM-v_h1{;btr7}zJIv`V{mG|lcB*H^vCQq{)R*(rSJ|^?`pHWD
zNuR#o-JS=!Z;k=xF7W+gZc9YPK@Ky!v^KYXYSnS`y_H&}b7A+19X|X_u+~3h_tbLP
z+tE&njRFU*-QBu{f%%QF>$wYM+{Y(*>QDOgd#B#%_2qG!lG`SE%FT<jt={!@+wEF4
z3kE3{*LSb4`4n7IvO2wF+1{2(-c>)VtJiGuyf<kE!=7nESMxS~nR0#GZI*Y8drjYN
zJ6JERAiRTtajyYmrS7(a)(!c-)tp&dH@$OQ&#N-Y)@Bb#>rT}N*Bcm@xRg#W;;mrv
z)Vq7Pl;ggq%HG|(UJ34-<XK%_dPTWbWzx5IuUEMJVzg$sH|yK&gx(39cNiG%fh@h9
zF!zA@vb`-^qjyX0HhrTqDf;^9+lQ?uG43{CtgqBjU3K@y*_-QgK^KKpW#7(iGILNb
zU|_CFVEPoD+f)uV&QtXr*mO_Tw|B1x^nRJ-eS7!1h0-rorf)BgbuyXn(dL&{y}W3f
z>r5%1i9B;I8TsG7`|{n>oNl9H<Ga?Ab|%hkx_g^bW!l$I-##3>UtOVlfW5k!Gi$@S
z`h$6ITc*`~t(|>+n^5GIN%^y)mi)bU_7y|<_6?KH&s)E_>f52HHO3pFcPE0bS&O?T
zar=Ef>kfwZ`H8w=k~ehkZkV>3=Z)CA8=flL*H7QxX7>B`!8``*+c&&J+se4h^FP1e
z`~K(qeNVsd^zG)`7IvpIqQ<uP%)RCFZMHx0K2YvhU+{KsbNdU9@3Y(6+j?g=_6wNh
z3z_p2p0HkcOWJjpbmh6?^Odh$JcN`SSUiMSIzU9Dg2&H@tG!*<&$nBBJ$~+$MA_Ym
zXWr#*`*GOf=C0`IrG}fU_HNyFdjV&?hJZ@TB>o>NlUPGebWL?X%d#jYlV#EmhCip*
zTKo+?b}OT}esM~Z=eFCq%*<cwm%skH^@%@=Gw=2kookuJ`7@uD?uFcz6>--vkI7WZ
z@Yv+C>kXS;Ps_OTSmJh0feI%BcvBc;t%Unc)_RWqpecJfdK_H4JWN(8&ET3kN0l?=
zgJWn`kgL}>P4AP8;<HvM&Evl8x;00B|J}d;bL+P~2(}H&xb^Pho@8nBp2(Cb+hVuf
z_T6?nGI!G}ruY*IER*irr<qEuw|RH<+&fe2vqyWfgcEaFM7P{xyPTN)JAU8Z%UgtQ
zal}_25?HnR-qzcx>v|+}wqE@Ey+x6cMW4fI6$tFj-gY`xexIFP{_JNz_vNqsx_*5J
zWU`|kGz|mVN@f5a#BnkM?=b^)!9f>P@k7Qd^lz;X-}~e1yL<a;`c|8^cZ>I>KCoJ~
zCZl}4eeJeAoew%*w4QlByXLyd&UI<u1Hawfw(ah=>k~vLIawv8ZSHkT?u*UOUC$UP
zduz?vyRwQLpc~*dB6_Fjcxpt)85<iLfSD1!;O$ZQNt4`8s`B%zd;m|W>=$2OwKx8u
z>YZIz&3q@`uP!`aQ@-=g*Xzb_Zbw5R{c(rW!%LI;rW`x_cFC>VxffXWe`0B=<Lw23
zmgyf4FiJ29hl19t$TEf9oGy5jNd|2*6r=BS#-mJf(-qD$i%q`J#yR=lef{YM&P>|%
zNzhReB_*ZYZ5O^ApWj!+IeS^mIR)o^a{u?6U7z?M<3-=yO%_Rf*)#8bmCwDMoqIdC
z!ZEqz7_;e2sh;C9yYAO~KKFa|p7-;@dmnwipSJ|m;$Z--t6}i~uhFQ}4Xu4F)e~O(
z?&_WQriF8#?l`ts^tK~wu36)j8}(8Du0t=*Ix8p88XEU?-EG~Hgwv_(`rq$S<ls=O
za1sp#f!DFyqF(&{V91RYxkSb7(a`s{;h+W>uMkTs==dU#^T2C=>L;jx*N}i54HI->
z0<k70nW$t5nQj0p0~650qH5P3TX9=7=J)+M&+q+?dcHlkf_K}tn^w1Tw}CR!+HEJ-
zZhO0$QO_e+=Mu+-TgnbMq|J@b*=>xg4LWxBcHi1<_a)K=u6ye4PR`xd`>OuS_2{yz
z8+*4MGgILd;FzGoDZl_CncR05E^%W?FjJM_ZI4~Mcc<?8Rc^O;7v5bmW7|oKZ6{T>
z=We@oJ8#>$@_i*B$AR7K!T@pk+ZEf6x>i4*SAO5-^WF7%E0goy9uNC*^sUM<lTF@v
zH*V)H+n&2++ucnpJC*BA7CR~XHcHH9-dt?+__gTst2()Ncf7it`?0N%w`9`oZDzMK
z?ydJN-JTmQaXZfe8d{(gH=t9qUV=AZopxtBBcXKF@2?l={G<OzZzvdOPStv(z{J4N
z(7?=8H&?HLf%ypo|0><ZH%_tVny@YKU|?L8BEr(>z);VS!jQ5=Lu`WsgM-`FlrI4c
zObrYSazg$aCpozUS2NyKxh;0;-s9cQAzCXL7#-vbyTn&Ns}Ou6>%pM0v@~a>#zLpQ
zrw+%p78ITIWz%A1U=3h+FZcAigO!D}DdPbRjSRLKN}<7Ovocb6IFeE>GiuHXS~S^#
zt=WOWB!gwy*P!}Uvl1C6D=RSj8k(30RV|qk7<`4{E8_wN29_&JCSMK;T)?cXz`(%e
zrR3=4tXvhite4q=;h#Nw`OP18FPUHc*{WYB<$1qPOsKTYIOwZ12z^rtteRBX+A=rM
zTO{`4&LVR?x2Lb)m#@2Dk{8prVQH6skl%(4lh<e_bzhmhrd~(oH8-c#LF1rrOXemf
zsz<2rjoyA&db)DaSG`xeRU(x=pY3`ZzGz9vs(q|}*S78UxLz7NNoQh8ul~OGvHM=!
z*(p8wYMI9-x2x5w-b_sCEf2k^bW+UY((iX)Z@=q3J#nXPcuKcQX70|_OO*vBIu|AB
zxXw5ma?wys=}hXXAhjjF^(|gAZhA~L+@#y);hJh@Z@pjYvA9NeTUV~>kBi$M$6Va5
zeIwEPdG$JJ>lJfjpYJW(VYT~w)!PC)nfI~lZFr@NV=ittJv{gI*5{3j^Rj1|J=?iB
zFMQ?ad%I)!A)M@X>+9L)ncePOH_1I)@Vx46<%5jdv!3<tT$gcs>Z_Xi@9VBJLwT?D
zkJnjT-eCukk6U`TRA=YCyoYz*f%`kMccgCDnM7atiO@02H1w?4SG(HRTMzt%*xqX!
z9u($gEEzfDOu}iS4abt%BB%D8I%8~9FCQ6mJOA9Ztt`uqG3R#r_ITyw<hm@?tY6hD
zEpc(<#;roLB{)rZS4>ROab4ItIXWm?bfat2joVU3T^A>Hvu@l7;;k~t2~6nHkuqDf
z;>NA6MJq0X1aI6}bTB7lt6Oif+r~vV7AIVAaAaW-$jvg-*bprebxZlzwpHEX+8Jjq
zX7%K*73+31b~}=>cAM!|X;*2fquHUNUE7XsmCo%lVcWRs#tpX<tN#3$cI;Y~*|u$4
zvb0%dap`V5n(MMUIqSwPX|Y3QUbmKtMCf*PXD3J9{`L3!df$fCu3Nj7?|psQ&2;Oj
zb-8P$L(i_=-!}bkICChY^z`5e<`71$=_?|bFEjlzn_e5q+{O5OJ4Y0A5fkI{?bR{N
z6-<n8w||La-pMHPAvf#4n5kC8m2HQP9qkqi=?)14-x)4n&-~9fYTZ&b$l`~dq$3C0
zjK##l3}<ZEwCS*9#G19qx!bg^@_p#z^}29o)~t)&rmKPl>z8+}6Xuy2k#THevJq%K
zKX0zqm9>sj6C(qTg#~NtBwaIQU|>jp{&nlxsNGqi?^&}Bift9!7`Y@kWp;@6PsQ4q
zn|>Ad&Nj=9xl?~<XHU}3Q_nSE*9t}N-g@`eySL?KhCX-sGIz;t&%N*>?C$p5+lAnz
z8eN7x$s(Yo8lopUIt&F_5;~4ZyKB$6UY=2QcdK!U<+2xLcegt)JS)-6ro?eX!cb69
zAmNCMi;E-Z+VEyUK|wYi(9K8^ATCIIea8_&kXj`rCAfq^k`l*3!43mAjvmL34rE@F
zflCrck0Zz&K{h3Y9zls_nRUgnch|jJSF|H|m-a+KK>>(n!;|4=7dLK|mM+w~xqH{U
z8#iv;mX?;5PEO8KjphtHy$<5tch>db!3*hiMKgEFa-}WX_NMI0wQJWdLgy+3CGVE!
z<mBXnngSa)ZjUVkN0T{>j_K$?b_(=rrq@uz3DMx&o$7m%rFTkzO@Y}d1i9A<cE1yx
zegX<O1WvsH_QT!dpj9$G$>p-(`02eK3!(2o-CBsIOc@>@$}DaQr|UO@mG62Dp?CLz
z4LxQC0*2k7hz17`m?*ve<=_0v|EIrPzwh_k*Vnh-&%H3Iy&!jc-t9cE3AcAmnACXp
zef90T7Ps@fH~QY?@Mw_Tc6WE~PQkakS8{5|-p;+f?e?T4X784$EGVzO_wBoL?oL7B
z`VBHw*7x4zZr81S_if+mcu+|9_9SOOoB<AQley}i7w_GBdF*ykNZZ{jEmIg?dU(FC
zuD;8=?TL%ufkKd-yxX39eSPiM+PbURb>G0c5QM=)3qRow#ofD?2&&9D%wsr#vFUbh
zi`ngog4T@3>-WCTFM+aAnAI2BZWk%3Cs=&n`}Q4_`K5gCjo<J0-TPjB?|t^Gtv`?)
z3AWB}@{*TU*0<3dhU7*N^CdXIVMIOHjQe}){{8z`_jKExj?No=wzBWb%x+Ix9cLg@
zRekS!a_-Kot&bUx&qZ;^?YyY96$c7mzOTO9yY1<!>pkpp^S<xB0Tq4*b`J_+`~CU-
znYG^_HoUK{UI@0V9@(~<@8t~b*FS#!^X_r(#@o5Q+wN|=aXTk>8}GK`4HG!F-JcHv
zQ^gH?@@E_~+xzy$pP25CYrk*3@iX3Z-=DjSpKHH+yZ!FEi#7L6SAW{i>Yi=A-85yE
z`Ajy?<DN5K-*TK&UcT#f?zZW>u9wGcwSAv`R_cOV{RHKlKYtj$-L}7Cdw<@;ci(p~
zzbO<6bQN)HGLbnb>tJ9ITXrmw>0!<LoR~<z-#?~@iW{nK_#+A$oMSk{Y{1)gfq}v4
zY9@o(>Zcc&ZarJOZUqD5R$e#o9ybOCwQcuTXPIrg%d|Re0Rv-JE_n1$J2(9HkKf<F
zzg@rYcm4ZyARoTncI<X??uOiLHY^PuX{p<8F<9nq;8bb!Ja=RArrk+?=k302-}AQf
zBPS=PX-i8>_j%7(=c1pbw=cQc^xAyqBj4H;RTZDNOEao%opxdBDNhDrgG6uP8<M+I
zR3<OD(y>)dux(AsyWJBvy*lCRlwlg3yL8K=TNMwwKAfvp`&R3nfB5a}-0f?ZAGXy=
zU)q+Lef~(CcG)CP{>{@5@BV(r_TG1f+Hwc`{M)A%Xs}I~a6KnYK$G9`z%hYyDxTIK
z{Un_q)l_}wi7L|4*z<PdYQb*D?i%(5LM3xN%1gNKeSUi<cbj$Y#%;H^-ImVn-F9%>
zjSoVM9A{4FZej3CtF7mlwQshh$}E<{lR22a*UKNj{;ci;gA4=ny}SMQs|0c<$&1W<
z_|j-jGcV`f^FpaC&t|E#p63@zwX|$gsF_q#eq_?(Tj$=Ml%5olx61R!_k4v3U6JP_
zRbEu~?Oh^aosp?BRe0v!%PW?%G2hv}d%@l4-MjY)MIO2`!RbZZuI+o@?XBN+=iU*Q
zv)Oa@Ml&{?=xB+b_2)^)-uDdE`Q@MN-rq0yUVVr0XY2(I+wXhX_r5-0H;4K0l_duG
z);DLdcf6<)m|^y<RwpeWib3}K?kjl-vd{LuufFat(DCWK5SQeRxq0&Q>$biWuU=bS
zZ)b1)^Y8BiSuR&|QYPg{vc<<%E+|?RQLn+?R&Zo#QOlbxF>_6GPrZHHy<y_n)weI?
zt-X8q9;c4-k>A@dRD8U-J>%}%Z@<@fnJj+XyFPz6$c}Gmj<#luDibtKZ|m0X`F-p9
z?elxrzPC<d5;~l9uy~rsl1POO!MYPBd9*o)c=JwWnOb*q+wH1bv3k9eFL`r$I0=>T
z^OV&ys!ULx<gT&~lFm-O?My9lP?^N4T6Sda)Z0R3;W^&gllX;_zVuA;nQ55!?##ph
zMh1z3i7cFRR1A(3GE6$j8KfW-sc7B4;&Rzpl?l2!rWfz6On$Vr<9EsS^)-KfKVz#7
zJA1=C?A^PU%F_)VuTWXN$z)Ra+9gpQ*^8?yZ`ZHgYrB52xTmgK!X!tPNrEa(jw}-#
zYj0mSpY-nC>&?%^N>m>CHPrO(=USp1?6JyerBlen&5o077j(#Oni=fS9$VI=P<ATS
zmr1ttmJ*A?>vb1g_-^``l^nZ%?Ca|cyRS)Cx?{3_3;0HE&G_Z=?cNdLu-quSiMHD}
z<ZhD^Fio9SpE#rRb;d7Gl}Yn*w;6?QJa+p=legKq#g91O{1)&`yLqL?(RO~q?HubE
z0kxJH$G~bi)q}6yPF9VUiQW8O;Mkgb^GX$-pWovwwYjSDO7ncXk1M(CYJMLvTy4Ir
zq~zY3-PhMHe5v+DWz8DZXsK<cIawFCnMCLIOwB3W_Dx}Sy;UaEVd=iQ@*dx}&v#Bw
zT*#d6WV)GeZ?3$j%A~jtH%N4sWbNzhx6kig+jp<_ZPwbY-ym`8yKPcgc#h}I*o|tp
zy+Bf6HTC=M<z(Hsx^Z>MSKWPOXE(chKB~O3?dNT?v$E=)CHwX*-EN(B=~i^{w%l1l
zRvuL+ITd|%w<<<Px@}}TF~M!4)DdYVN2&92vu|gr&31Zar!cD;nI#c9cgti?-X(Kx
zy}ow&mZ!?(6;&rDxNYXE?NHgA^U6+P-ue2CEYou5x*rj~`HgqmVJDUilO?WQkK5M2
z#O!vA?X$b-vCqqYxBi%KRGYkZ_Umc=c2RoK=e5sPeqF!R?zMXP_3am}-e#AspDML}
z;`WKPrdLkPy|%k(mteX3e4W^LAH)`Ue7+QME?GiWQDd*VkU?i<%bXWUP8%j1GxWR5
z$*Gd9v#I{1&csQc>bkmng1VeMw7TDCzP=te@!jV+4-X$;(B$ysx^(-{CM8d<6{`;?
z1u80Li*3vn+c?QnJ#5-N5f@LD7L`c?leiYG=T<(+sjy1xL&qm4AGU^!g19I%j}yPI
z%)PgFalUD9KG&YxZe3qKUDBQNreN>;u=QTwtG>Q0U%L09Uj4d<dg~sR``%H#+PihB
zbjJ3y+c|4)Ox|U7ZD-80Ti3O}wXE{`YrwESRwC=#nx<91>rVaNtado{Ty)pQ{J5``
zvyR=kUb<^>Na)?b6)Ud3UJ#wVG-vu^gJUMQ%pzx|`#ui%A9J;|ufA65v2RkZ-po&Z
zv-(8ux=B8j={}vic+*jd_4T5uY2k`zw<VcHd+rmu>2vDUl=2|=V<LOIek^`8@s;C8
zt-Y?yyL0QRe=Gei$e&|wkymw6Fr{Pf4)b{(n_ME5^z(S1FZz1y)3e2a)9*d|;&(@!
z$w*)l7sm;QcU%k-cMrDui-tPC=yhNgT;-C~(>ASrX=>1vqR@hMA}d8toNd;wPY!NL
z3i40AF~=fYFU>0OxYm;$FJrx~Bqj6CX5^l*ZbB*Rm4?`;u&vh)hr}uyYx_)FH>0mC
zVr!9hPvp{WZjQcHFSRGUTACg-t$J}RXTq6Ny-$}FES|N&iszj79__7V(R;NwybDZx
zc%4h>QTI`PQO*aek9g|2MH!391?LoOEU4eCz2eR89d3qFb6;gn)m3lP|7P`M<`d7^
z-Sd<x!k15ryZ2#nPhekr!?~-+W2SRmdQh<T0qc`hUp+6eZ&JP(zEs6J?W(P@jnCmV
zvvvEd-<lph^J%BvuijU2?<TG~Qf+bUc0oUvyZ*8n-}*#~;x!(g3+#H*e$+j`^ol>%
z^TUyquj+qZ>eC7Q^lZDv`o4$vo?FSr&G8F7c;tt!o>f?8ocGC7Tjz-62+3>N1=%>+
z2JBPRZ<&73Yx<Pap*<FEXO}JKnd7=KFM86QtpzdMv({Z)Rh9hq#FfH|?&Yy%epAZS
znI5U_RbE;svvsPp^n^Q_=knAR^PW9@HEye7wfZLSh5lNeBCi5pEQ+sMoU}Og(y9Hb
z+Mh3<j$JzaMjrE;`c}op&_<V|Oi7|it0F}wMl4MTbDfyj7C0p{bg7i+!YIu}Gua$l
zvwGDg3k!2a1RY2)j99C+Wz{K3XHBEYL8i)qD^5mf8*9xBIU17cl<C+ZHD#?<SfG*T
zf-D|iwZJKfVWOFWOWXoBwKmPrT&gx@Mrdm!XNu|+o&||+L8ekY^`1%IPGLe3s}gjb
zuIQ?Uc^Cyw>eX1Qv8E%%SvAaSO~_FnHs;^^ue#JH{5u<ebM<eVe-H26ikvM|z+ZN+
zXXd0#_1H__^?g^dwah&>yY_qdCCz==qR*~h+U{E`xT1GOcgkedWzXiuG)(R>ck@!d
zRvOjwE_~53$2I=@()X=fcjs9Bv)ZcHx1SXK+_;$2!(lGR)~9jVy6a06mDX#03TeK}
z;j#MEo@q-pFSK;+S$#Hj>$?`vMBF5SiQ!W#wH)8IsDwU^^A4Kw!pTzy(m|3`nN-^C
zraK|sqtnB~!^u;TQ?xRCwopIF#PYpwuUnnFmUeH_^dDIZ?GLbjYe=mRjGUS#<SnTt
z(x$X#vq=AgR?$DAyiA%WOtpEVytcUJs;mt(@ze|OW;9r=wZPzjNK#0TP}5aiucok8
z&WI`8JUTj}+ML=NtV=RF!x}?Z1zeTn^jS4oWYMWL4Lz+qoQ4rAc{ma@P8h9H)>@IM
z7O9fr_F`%97O#z3%eYn@R-97rrN`0c;?1h7DRjUzkn3)A?$jJ<%?PKaEeEAmG_eWr
ztht??sm6FzuqdRR;b@B2Mgjl*jhuRtLCz}{`Gibb>&nLIa=>+xrq8O-j7~A9rK_6!
ze-v~SHF<Vwc4)tz%4(z);NP`s$v2fV(^8J9_INX$IdjQl{fia1ZW^nc&54$(Pq}c}
z?4+i#Q`VuG3j5E8mu||<QO-`eb<0^WNqMnWXiRFF{!8uMsXly`(b0Wj*N(GG&a_x$
zxo}grsh6?9zmD~9`HjrdlzBA%b?l$DdujC^$2;05mUq~QK8jy7eOKqZ*0=0CR^Rcy
zsl91;_cg6|@3>d7mT6t{ovk*j<ww_JR=fI+VokGXwnN`UPb>ZOKCy0<?27&_@dL|G
zdR`0<m@dNaVv|~X@uBJs&nKQUHmhF@zS6wXJ!`4O)VQfO%wO2O5+)=@Ol?-`QA}B)
zqqX`=UEjqb#g=2C8O=gbZLJ|0siG@ZWLkClrEEJZYPCgK_h`$trDnIY9vxNsrd4zy
zI(N&8`j4TEk0w^6Xw5hpns8*Ltnk6Q)?fS=_B(&kpR({rq{N19Z<dQ$lf?{IY?vI9
zG%@95mSNUPkAxed5uJ8lH>HKn?74N*aM4OOu?16QyymB@NjlBUljw8E&CAeKo8>Y`
zXqREf8Xk>=raI--3+6-$J~*Oh<aywr#~=U0&+IZkYrm|wYrLr)ns#f3x6xv4o}-PE
zj17BqO_#0Wc1^gt>B33J4s9*FPrZ{Q62BcN>^ZsRR%qK~Q*9l`=H`y3SHHa_l6?}*
z&K$dSRN}OXnrPDU#>NPn7$(`kZ!3Evc|#5>3mJL#Fm2G*Ds4=iB*!MS!D5Hg^zfT*
zfgNX(Io5QG&zd^3eydwVYKKjv;51kDn_APImo_&|<I`ge`S3g9M32F%qt4$KbgX}B
zKgWKK{k+n(TP-}8A|0|_9-VvS@QkIQIyCoo?7R)qh6mnSs(kx)?ew)bpIalhZCRX~
z>2_pJ?pp25iJLd)oV>a1w&rn*x61`y6-*ERy*BK2*w1>`Zn4PJX*!Yhne}J7>g^x@
zpZ}}&m#ba-yZ*a;apirVbMNlHcjoc+E#XsLw=a#0cI&NrU$SG%q^~dYqg|bt0xAVH
zPx3{0uioLkdPnT#a?aAchpNcc`jm%y>)%|v_20**qhqF#lA6yX$Q+HTn$Ju@qm+{q
zh1ER4BQf=YLeRmMTbsbbVEJ3OBaKo{PEIwu<#M8PQ_9K7YA0srs;<s0{bxDnaqpZL
zs~`MaeK+3b-{PHHb6mH_hCloL{&@c$JL!FMx9=5u68gFJ`#t6CXTRTFzx8uV?!Kw}
zX8r28spHyUl(jT9zwO0I7jJIMIa|`TFD5J0Uo%Q@X46s8QF-il<TX#yhr>(6ytF>8
z*Ut3|eH!QD@-!~=i3^Asc5BY+Q+ql(PwiQKqGPTqWMm=TGs-aI+{BbMQHB|ZTtNDi
zUa!97dHwvlbdTb_=kn4$>R(H(t*!lD@-F7tx3$|p$FFv4Vz%$U|NPqZr$1x1WGJW`
zfByXW-uJ!lwIz<mS!VM|9An&-RapAyBtz}(W!-K~%yz%u*QSQKPnRoWPLXH7{jGNX
z^S9rB{i?rz{LlRGJHN`$|F2g+{H?}b|Kz8Z=?lx4?dv~>rtd9%Um?m6b~|_5-ow^S
zS_Tr#7M8PP^D7t_I2fw0y?xKX@b%sM3Iz=gE+(dihIJrf0mBOpt_KPl9DHBPqr-NW
z$9>-Q?RE7fPxl>>Dtiy<3b5`?FKsV4$-TS!c1~||<F?y5i}R(e?|p84eeZ*rgR}zg
z1hx~*DU6#N6d4$D*iJB~zM8%J_U_y3zT50Qe7N*^?(4nRx9$v#K5^}{>GY;@W?eb=
zxBIxWqi$y>Nu|BncH@pdWIyrdyv=7SnD#JDKU>Z$QUCYx6fdm?DgH&9Wp;3{U2ViH
z<<!8ykih7m$jY3|z}CRP#=z*rz)-u>%7bqSlSf0Tvyg%f2MYrWL-?Y-`#!#4oUQ$~
zvHBd7f-9$HfMd`c2l3|jeGLpu%?^zHj18|G0xvG$VqjpfK3u&6bodVQat31w#sdtw
z?c4a;mQOxaziJT=0}~H}(7aaFpdN-ECIht@UiqO~3wcd03o9;sF~i>lG~cqQm*J}v
z;{pcZpr9#VW@Rp508O^22x>K_tz72T!0<;uD)3LdsP~g;n||5leR{69S#zzJ$F-AU
z9+z&Ghh7er=oU=bI_2WV#cs!XrKL=AvUAvad!@|c9{bfRH1x}Vf9ZLlR@17GeZPzN
zDwnuU-&A#{lb#ng1(k_iy4MJro7wq3?i*+tWx8^~vQ3k>h%a)9>*Tl<eIc$>uu4Ta
zGvBdF#r4HR@kPOrp0~I!D(Sl{->Yd27M#9AXoXY9yNCJZnw9qo!<9<I1r~{2`o1%}
zx^?GKE5rJL2cH=93y+vhnY&=Gkm61`v2CALnQgs(A2Jivd*Z{|2^&{jy&G$}%j0S%
z@0y8QJ#tgJuFO$rP?%FyxkxayQ7xk-<h57y=PkLQS(WUo-z#6ngf^yTw1g%^Mk$KM
ztVwo-Po~H`UkYbu+@AHd_FjEeICNrV*28mE;q%zQQ!Xg%XT3Yuhu?j^v;aEgvOfHI
zovn7`XUJqt)$ToCmR9fidIvoH!oareey?=ZzW4K{!Y5loi{0+6-woHlV_UR-?7M|i
z_8O<;<oMP{Z8hLsxk$%tOQ;BV)}&YJSZ_c8Xm*5wt#@_6#E>kHty_aUqkPw{I;Q0-
zEp{bLw>jc)s{FfCyh{Z)hMEcNuZvn_#%Utxc63Xw)KM|+Wa;SW?BCK^8*Py%K3qdW
zdZ+X*nR7L#<5}<Sxw#c#U0uDalcVadWNm!<THoyArW=zJrM0FnYtC4lyJ%{*pxCKs
zu|v69|7EmpsN^cmR$Bf}I5TJICY7`ho<r(urCGOzZp!7(jDOs_ec#vX^}Jn~m4c7d
zHEw%fyY#7O&Z?q0%QbF$+2|J(@-9`+(0A$FdM4)N8NXxVvF|l6ZpsNeUwwU9uiM(9
zwe?b6+H)qECI{w3M?JeOEf+WI!=9hDrVrOo`|6ds_SB+{PhYO*`1Iv^TknchW@d|4
ztkMQ4*=Dx(bP!S?Kizrya=uAr)pr3$Mi#NPvgfwEyBRGl9djl0vqyBOa#T~?8PQy?
zw_7@{?G9=?(0V2~i+9Dg1^--a-`B_Gh^^SV<@?^MjMZ+gIqZp>yx#ckxjt=Pidc7c
za%l4D%W-1Ij%MdJtbBJebW3&7Hc@Hqq@7cEm#SZD%Q~~>(q_dOk!_i2tIl{OZn)O8
zU~6;2sufxXvkr#&Mrh|wnXMKwt%v8Zp|&B<(KNB7Gp;jajynI1SdtTPYeKGv{Ej8L
z^&UABa$3xSq&=lWLpKK0o^nodJGJUopv+0Oqiz>?7wV-<JL#R$oE5l%?b75Vv(Q}6
zts1wOQ<iRW&YJY)Xtd&%X_ppf@UHaEa?W)58g(;TIXOAicU4H%u`NcX(o(lfx2ZCN
zL^^V$BWJsvU7ch$)oiM5!LkdpeWzUxiP#ug-@7$1%ygldPT0k5H*U;ar4zC0=-Q3j
zj!f-Ix^`^U(QGkYl`PZVt-ZaT-N|7m!lH7dr5$eRE{)bPG8OIG+Uc8RW*RNECfDUm
zw8WLHHM!egrCnUK(2RF+Zs)8;$Bs<x*tlwoui3@q=$ve~Ri-UBZs}%A3!7a`TAj37
zI#4xPRJ1<KboEn_(2grvi;nefnYdzg=7Q5wvrIB0R$RGoajR=jl&P3u#+IyEVy3!F
z+$L;GyCmuqx+pcU)6;WScVOp?i>_kFZd`QTxXtXCTGEXhix%ZB+hSxYm>p;=cFb_=
z?`C0_u-sPZjLu1cuFF=2CWkCrG$m-O+Ob7TZd}RI*4!AmP0=N%wRhXmjjDkzCk>^J
zZd_#AopfW7*U^YYi$Zm?RMxoUPiLxQ)~?T)EiL}R%a)HnP2$Lp8d+PRiWg_5rA9W3
z`+Ge6^5NlOxicakOCEM>9n(3y#;b5z(vDh>Z?7zNOy~aaZ8?9M(3g*g^n}$Hi+dSX
z**CY!s0DpXnZq+D{7S*E)AE87{wU4m&zLc@Ey5rveB-2zP1QR72PNFnkEN-Lxr?0k
znWoKN|FA#lWR=`GiGwdT>=ko&R{9m+dUWfyW5@LGg&j`Z(xAIaSK2Xa(ZwwyYr8XZ
zw}d}_+#;jq&ZBc!Bq=P}X!*g$I=go6m+c!R1>bfZI<4#aUg4O_D<9dO$jP4``e~my
zI%gm2kr}1_6OPWP<FTx*5j`^3dHb}m7;%}@4`H4s{aNcPmMeB!iFU<r3EIznc5Uyr
zZN`z4nz~H4T-><Ltaow7rfX3%R&cv*OBD&5wle9MQBGj8tF%bg+2)iRn>CGcr)*0!
z%Zc_~x+U<<rkRE_eP%3^^qi*j+p}%y4+D!GGb9bdBI>kx`i~U0sV_MGuuh%Fu%d6>
zGW8eSm$fzvO@CUryk62LBxlk|&F#LWQ;tT5rA5vN`IEF+h0XBD=5@PXi(Y^D_{heo
zHilD<R-7q$WVL!Z&yj+|noSRzdkiCv2`>|FIi{0z{NbTvI!Q?zJ9~5@&YYPs;nkW|
z8JXEmQF6DYUJ7@<q_;gjcH8Z|4ZUt2UPq@1t~kjVas6u6+t>ykQv=5S`nBsGzYNX#
zwKhKF#pD&MPN@YSW6PbGrfqiM;FRDlwLpu6Ws)nqBRqS!QoBx^KUQb;;lwf9oo6?0
z_9;9#$8dhTdqnBw#;=hxQfHhw6S3T9d8D3E;pC1@ZYkGh`!2hDDAnS@j#^`xSgT{F
z4Yx>VB~O;Vo}9II+vKK-)W<$qF$G`h7a!&4`tadZd)JJKhrX2TD&;6`(>jyleIZr&
z!DOp5kNYH!O%2ZKIh?iZs$}n^0?%t(OO@7jZ`)h3dVA8`t#`uBP5O_O9&dfIzkTs#
z!v|-=QW73ZcE37v{MqV^>96P9YL_w#yLx8r(qG|m^FuD%RNbz!_jj*-c2BZ!mF(VS
zHz()S|I}Uja-QttL|dgzJ!;mcI=6aW`BCG?-DbzXm~W1(tifM{iWSwuoL$KaA3iA9
zyZq(hFIApj)+#?so&064Ui7;<+42uH5<L3uopz!t>e8(ITW?p+zV$bpXP&;q%1PgP
zW*R*ef0vT*(BRh&pZ(l(cb=D#t&tClEBvLO{PJzQ#N>M6TLvkQZ%#D7CsR0Cj`K^L
zzD)e057oBX$3i3KO?)fEr!L$YyXR9};=UzctV&*e*=wXTIi%Du?bvnBhv6G`*n~%f
zCHe3Rb51$<#@&0z&COZ4ImX&tAL0+KNRK)@J9pc?3E>^vrmoG^*|a*hP|8rM<6_5^
zB}s;hjwvS_^dw91OxI{)7G>Nv-L8pQobl%LuqI~D`hQxxPMu8Lk}EALWwy%9>}1Bq
zOznuCt6Ot&*=~D1IGMC#$I_KKfxRxtQ3tnmb!Th|d$nubiY1pq+`7ez7rXYo>y<8e
z)$O)oOSY6r*2!$PMO#dAcoWimPR<lFv~TX)RXCsfT#r|(v&Kw)u8#$~`o+BTG)p^e
zEFSGqnSZ!nPPSe>rk?xu51Uo%y&^V+UT2-Qa7K*WIb&nhu5Wv6Bp()3ODx$@J>{6@
zyqj-t1r>BJkBM7hXSBH2vv_tv@WMa*S09x~)FvKEDM(4HvnnV&w6frfXE&$6NAL%`
z_7??p>(dpJCEe;IgI|_DwwIIZUiUaXOX>Kbio~D?KfK~DEPph=zWZ=XWV~>v$SaXA
zatGfQ7FOHl?$Gh$nfd1Bkw*m|#FuDJ4Js7sPYV9=>-@j<AL^TXk|ldK&Nyalzo$N1
z;glTj*_>N35=Lv4d0pm2FPpk6GjA4{ieC06CpKrR>Tce3TQ$wKSKcbkD9*9mRyOVO
z$`wzy`7N895t%!+bZ&WlG_UHaTW?cNXT6Sk$6$48s_wFtY2mu8tC!u`b!z9L)y+C<
zG#;5QyUcj9xPi&D<l0VI(?!>{XZwm}$J{x_EO8)v>5f}$Gs4mmEsk0koSbyp<>AUr
z+uWIT*Cw6XdM#^r?7>y9PHmLv;%H`xo_4#o?$)iX*;}iYZadm#YIIFw&9ZCt*=DPJ
zRaac>U2L?~=f<krS^sUfuKvovz`($`1x&6Dsju33CfqXSnPJQ`!(~}%2=ugg3S=xR
z=4tVE=Y>9Zxzb*gSjid(n;Hk3``kI}bLFhhl{=7gIz+%Kldghi?j;an^@cr3>jXeH
zF~or9o{yrdFziW!tntXRUR++1_pbNu#og2H=<djMy4|{+J1-}?;8xoe-5t5kS<(U9
z9xpC0T-^emRuzX#H}81YCw517M|8oqhq;Hdz|7(#uud?Wx8N4Y6tU}}+jDQ1P2YQ%
zS(53P;q)7anUyDR7Z)~ly}Rw`#tk=0Z*RQ=+JBP+TD4KAb-BFs?#7K9H-Lp;a%sno
z9Xoc%Yl~{s<cn3pksyZ9TApNyyLY8`cbS*FJwn)8u<hYi?mVyqkX;XQVcOITh)&M1
zxp#$D`@J(-?JRK&tR3Wog}H~O&uU{<((Uou^6tgdsPYmokR9NlLl8%W)^dimtab`r
zsC5Bk-ef~-;d&55HFTl*hky1T{-1t+{hH>r+c&ItKY3q$&$uUPZtmXQ&AnUif>{lZ
zPu}~!ez(L?tJ~EKg=i{boJC%!PWw_&F821~rs&j1oT+<d@34!#hA1zW$zAvAk;HOG
zo$ZTv_nBTVE#wJaa5LYXk?r`)wQJ)SOs{QcHm$#VKx+cu<CzMJ?^nOy6fSVo3T#N>
zx|`Y^Npo2?-Rpa2aXt3x5ktSG$b9#5nQUYuZ>tva1TUBteerm?)azX*yPz5#cbC0Q
zn;fk#;H~@Oai4`Q#AbA5)*vTMt``B@D8tTP>ArVwEzBbJ!o0iEs@vierbS;ocqe<i
z+sWMN9jep5louY|^=_SFSBcQ+DhuoGvKKdXH+=-TlJ9ZsE;H|(Js{6E@3@}VJLxvq
z{&x>7wqtdE^N#HxMN(i@4=nyzytA;EpBU12V@t%1jY*5HN{39J_>Wbw{%l#W=9E*Z
zMl*fZYE6q|TeDW@`jfkCYqqLtFh`qhe|fZkIc(Xjd(mrGMi;%-HfvyD(wVyL?6&LE
zcC8HBw1D5mLg_!tKhC}1Z$J5I_xn}h^Yi7WK%H#{W=D@xJ)u)J^@ji1SM&3}#+T&a
zFLkS*Pk(*)xn0TU+#le4$js|hzYMffn1NMOWzp3QSGT1Z9Gy5Rspih)w4e@E$+S&N
zuANBRc5~X+$Ta4g3w0O7C2R}Xm*m?r-6&U6cJsY2)9?N8Z?%2F;Ljky@PUzmgYDq9
z8y~os=H7i@eeVOepsUD<MO~$PE&UC}Pe^^V^f@Sa^7dVe;4{AJY;*iXF3fpWc)Y&(
z(BiFgZ%<WQ{`l^mN`<IDYcFq_`hdUWlBbGFyO7fy-tAo<_8wZ*q}9>CxAyI}+ts`K
zqix@AyREhAmxt{62Ww{?&Do~4>RrS!!=9uH|MuPS4$Im1?fbUQ`OeKx$KS8BD7*6Z
z;QKW{dp#Ro=G?C>e$sjT?lInPzu6lc`%_+fo?lr1tf|70eOLLk!b^Ug4;9*5Y|nF4
zA78ugOzG|1Z8rRenfM*&*M8k3_WP}v;Y-!zpz2+_FYj2p;Z?M^ch&El%&4#%qT6cN
zCx}nKbn|`H$>q~0-)ms`z{tSQAi&VT(!i23?WFF!?^DA(%eLLl;BR24zIyfUZu#j2
z^C!P5;k1~u!=s*0_CdSn<<^f@5)&@GD4F9YF3{G^FX!SA*T7$};%$1_n@QzQ&%V9$
zJzsp0O;_}rnW1YhZ|d!SY&v1WgqiDRt`9Gp$H={~>eapPyFPm`igX-QnO+xPeecij
z9rIj6g0G#0231kbx@%qAF0ESKDY`jg?X;tzF)D(Bf;u)G^$${8gxc<1Ka+h=vV3ci
zoYej*dE1bhV!gc~J|&^weqVoP+ApuveeL|-ujePJ%a<8{zq~<i-q&yZ3@7$Z-7@Fb
zxxK+Bf0nA&*2%8Dqw+TC&vd<6U(VcHlO1_J=j_}acd~nx_Aa$!Mhz5Dz%;NN{7^Kz
z$fkbToqoN^d&>^7GWm&|dUWoo#+2RN>gh(&cbB|*=6f?hB=S{w^=++XWr@%28lSao
z-6d;d=Bd&$;gRPhr(btD)z@#^<f-n-IdisH`4THLh<8^kpE~IV$djR>p~t&T9xGMl
zuAaQS_4^9RC${Q)U(Z*m?yjxfz3n!Ckl&g59W9T2O}Bks9_n<<U3N?ExAL9SPU~)8
zROG?nTf@%qX?Bs#vOE2n+vhPkFeOy_?vxA8bNhYE@9S+25jLA;hT5lsX1x&dyP0-D
zW$vaaC)4u2EZwqx@7t-thu^H^Pdu)^tZClN&D+=ARe8Jh!lbI-*(#GtCbY@(_b9su
zhJ*&K*t4jfV~@T<#jf9Mw-dPx#U-W-IsKaXeeb3toy+n*-n_ee@!IpgNzu7W{5%;r
z8=smz0lOgIhGkR9^a$xS?=0@|NFNk33D|a<OZ3>i6)(5t!-7Nn)RCr+?h_S{Cq-Tl
zxZ_tP8nE@w^La0(9Z!qni%hh1n_zNVdFiE3FYC9xth7uy_35;ty2b^I<;}{=^`2gO
zox1%_zs`m^i#;S|^`<Ic-n+MD+0?7CCHhmt9)1hf)dwx25Lmc0StdM|ciDw~p`mf@
zYxjky&gH%Gs&Kj4?ISBno_MBvuaL<QI~J{Rs&vWA6O$O2L?pU<vX^`EPWkjnDf!O&
z6i%>;dckQIr|;OS=NFmCdnHrwLeBQi$fMJ~>;$>#h(Tt=@yg)pD$#AyC$?*>_nrq*
zl+o8*F@2Y<rBLJri*4(6iJw|s@Z;{Zuiw{C&fd_<mhm!j>6MaOBA-^Rx?HsPeRZPd
z*0Z}_#B1HLyEXmx4KKsnvAk10EZ$?aPP2AzbMA)LdN!rUQZFw#r`qi4nDJfv_U%NC
z<GIHgC37VmZu@-K+^&2o_r#~!T4IgHcfjcY!iOY^t=n$r!}-^4^*+6v^Fem2zWCOS
z(@u+BUaQ*la$5!8t=wfd9$05{OgR*>PkbtWrKr4zr)}9acayz~bysH|tmo2*_7Y2W
z*k*LIe0u0H<GpXEPtV=7Ojx2S^OAGwr>>6KCsuUt-4<@Ga^XhmmRt*UC2y-(hsPlG
zZb2|lVDm$XnT_@y`@?lhbT?hst*jIj>HPI|-Aaz=$bDJ8@n*fB)~`{TXuaxH{p^^}
zPZvGi^J&kj9gjJzWO`=o6cKb2FrIfX_sy}rQP+34@rJLs_^SJghEni~kW5Z7(O$ox
z$bfA@-BnZ9OuM!<G-|ET>ZmIL+org@3Yxxldv`9=l%=mTv!hn64eJbDo28+$Wl?d?
zq_5jPoOW2MS#{gBw`%L!?5Jx?ouUGTS9-<OZ@Z_vg$toGPvp^p@YQ$r6n*+09&z>A
zvCk1}_wK%1-QHgfT2pa%?cKMJtdDaCP1?HjWOkI;#GJ<oOD43cv}md*Lhr^3vtaCk
z+>zz{@b2B%@bc2{vEkvRcE2u%sVsl2`z`NH=$3WXYC4l19Fy38{!jfJBcqB_?|<pb
z`t(#76wK>9uxg&Zzh{-!7uT1e9QU8y+?+0Y#{BN;z24hnI%W!QUAubK-Ivx1`!6$b
ze#!K3^PCcrw5iI_RZpYf$yCv!X-OG}JB>PnUzM#%54<|L-EY;Vl$F|Da|2$+wu+RT
zvfgxS6ZhgZlefFYcpm0it)pO7R=<u<_(g@kq?}cZPhp{X*~_aJCfS5O@>?=b@KLAc
z(PW-DG2RmEl$j|rN+w=cInVj8@x?qN3!`H`DGwgbYnk%ZeNl<~BK1YKf&nF$;-=Xw
zy&Empy*y?wd$-D|ljgabqw`cgag}~Kaq?xK_N8?@{Mr{)oH*0RvvIOajNh6$R>^X5
z-8xS0Ti^Ak$~Em>vOb|&VP!=`PIhOETEy}_d+mj%w@qZ$sP8z|aZ{nwD7!Xl-TqU?
zt0fH%_7&%@-FE9s+`Rt%@xsRikNi}#<2>uT`tX7eK5{2Ts(&nBD%Z7-<441fkRMG;
zt3Uoaaq4Aa*W|tGu2%x;MFm#XAJ<yym=UyKtHZPvjT2prw4Aw=nRu9%X^I?mI5IVb
zr?EpKG-b`yHi^V3Mr|SWr)GwQuDFsq?S>j>Yimy`&%#M5GiJ={b-S6`bu?wN$_zKb
zE<-nM(J7~LXLcM(Qd3G;BieE(Rnkpaa8j6O#A?x$P0<Mk65WD{5^id0T1O+oL?=ix
zcFkDXu~AG-O-%gv(fFI&f65fCzq$R*?Qh}trxuw`P`b2K)%V9Wtv?a#kJc~Rx5e#7
z*TNYd+d@``-@f<r@q7OEWzWi^&zSAt>AsV`J43?7p?K1?!^<<HmQG#G)cWGnm&&Dz
z`UQKhELC(8Xyn!o6WJ>_?Ns=#+nOpW+gEx8uid_uFg48-lu@>>*QwvIURRUrcFJC_
zpt-qwbKhQ%EiK>s_SKTrzZ?F&3|3fewC0d!vNo5tC|l$t%^!|lf3(^bXcZV8NbpLS
z86eKe+UeM`%+(`til?cQkJrjX0}n%mEKkukF|kmsS&PIbG<#fBGSQTBnHD&y)hJX=
zM03F<rnM}gD>SoA6}1CZvl#26LNhufwE|m%btd|>T4{#7Qtb3hVlp_9;j-LinWt!@
z(W1_#gPQJ~Vxb%-c4%2FYG>_r<O%534dHmyv1Q4mgw_R<Bqkaug-%(xs$q2?x0j%)
z(}k66ELmOhkAhmVygHqKXf653f>;i4Fl7CUsWT^SnYLxtN$`Sz%fex4#u6KrX^H=K
zy_+*TS}8YYcC<>8PN0=hE1%J3;a{uDL$_ru=6c;bd!1QsY<SeQ>00U;Ii9nY*e~IK
z>prV@X3Jqt`z7n&+4irJn`)=^)BWh@7yhZ$0pBLyw7vMZI<D)>q$<G|iyy{a`SatO
z`zG}b>yxSjFIi365&BYp@ASD-m<8&8F)uXmFj(VtaH5-1q$W4l!e938Au&OQu2Vf*
zW~|l-IIwcbr<Izwx>IvEOnG%8SWi#XH&Z!xTc3`m_65b$LA~2<iQ2e&RCulDQI?tz
zVd~`9`Cz}(U-lRA3xA0}*vB|A)mgPOVq;G;t6{{Xh(H5@lfticj+|L-EZH+nOkg@w
zeSAur(S}2bJ(@FAPE8gTO_;G!L}JPYL&jEDd%>%>TppcLZ)Pc+6x_ICYJBI9{h~kO
zJO0LRusyYm&Dc~YG}&urM4ArI#F;&bsWT%qHk=8XEVAl?{u;Hcki-0I*d@-iNd=p#
zMNCR~@MxvyrC;6>iBpV?4JV5vv>fUYe2}y<;bVP)C*P9aPRAtOybddN%;HKGTA3KS
zA~s7bQqzVfFhVAVGw5ZlN0QOWR>w&jDvqo<tYdU!^3e&)A_Mf7gsf}#X6N)~7iZPj
zW7m@q%wx4NWR9vxef(|jUx$AkFS<25C-&4W>y_23?`YmRW#s9n(dcoG%bWZ1sq@TR
zCV6h%ETd~(pQFQeCNd4JpyxWyV0evNF>=#6%X2b?$1TtQoU%~<3sc<OldnU6?76Wf
zIWAPRa>eI}YuA^yc3s`}VdBzv?z^@*`E4qhaAnEb%%Z4ktxKXUZXiqrU9C7tw2vWa
zl9R|Jfh80EmzS-r`#I4lMc?H_r{`ofpP5D}Cnvdpz><?tE~@ZE&?LUrlIgb7ndN05
zGx=a4RnX${Kv$6|fvzA{(5mTwrZG!TH=52Y#RFELwFG3U=k!D-MoE^*N+~BMJ7$RJ
zE$Ud*rGbJbDJf|z0%26)E{#PRi>Bw?U{<W}=$IWEs<AizP|)6zhcjL*eY^c<%p7^s
zs;i&nsw`)2P>c#c^?mE5vvp=&`y$pKU9|6_SjP<pp{weFiig<V7Keux?KL>}+D+i8
z2+y}$tJW9JyT!P9iyE`ar7u%gMMiDV2vV9T^6Jx9O{)cay@CYxUVS!Ysmj`jpoz*?
zUnj<GJLy!v?R4&oOCsQbfz-WHPE$aG2szsqdjx?x{Jqn@WO9Lf^_%YXDtdu>+Gf!g
zmuP|p0Nf1MWJ_J!+I7ve-z`#T&xR!mQ>VFYI%Fy)(#W>yP#9Rf@SgX1`K}=kKYl!B
zrS*8-#$$zjmxPzc79O^EER!zrV)fVa^=EcV7hPP?aQ^a_zqQe|i$0ewonN}{dv*)|
z?vfQ-G8By8@B6m8=6m+^(%6j|7r0iR+jTp4+qJFR?pfUo?z*=3n8?oCyKV;E&fRu1
zXKn7b+u2dK^I5Z_Q>(VFjJm#d+wF>NVO!U3yPcaIo%`r!(AM?Q`O#X@`EI9kw}VCy
za<(t7Pu+I=h|uXOv*?SPZs&qVO{8^S+|1nu8c67!_9bW9&5EYTd^eDST=0NG#5L32
z?5LxlOW9!l@13+HXX>`_Mcce4Zo1by?RGwBu;T~w?!LeIr~a(J^z~P~^uwC`hc)@}
z(m&(<zx;AwU`+CeU|`@jx^#K^?wQOH^}nvW?+vXE-x_y4eDC}4@VyUgL*G|0zTQ#r
z9dz<0!|mK{3=C$_-3s8*00ssI=IaIT_O9J?CHL9(^6bhLxAti7K6rh**s61nrX6a`
z-RrHHGch!bC3oAwLuPL0%x+4vF!)YxQ9F4^IOQSdrh=B67EU>H%+h#`jSVvEXB`1?
z=ia?1KI2Vgd&cL`ExW^x&$#tYNke>XYuD8((YaTqi8q-YtiHYR(3LgU&J=8!mUB&4
z=S;*gqf3{Kv0$?^2bZO#@ft_WR%c6Hx-9?RtKHvst^2M2HeOX#(^FOTdU$Nfy6N7k
z*-@9Go=mO(e<mQzbIP>{(-wio=-TpE0W7R?_x~v|FfjV82p41!U|?ZkkPyCpkAXpi
z`L#)wk8aMHMP`>HJ4F~B7#b#+F*7iL&YNXo$efjS@B<f15K{w(z``011_6d@P)Oam
zvZ_(l=2nBIf(QeHhRLbDZ7dI;*#ydcyTc9|fMKe45Ya1YJixbtL9e1Lk%2+VhE++1
zftA@Y$0S*8CbL?b<HThw2~*B$YE4O!U^J9qF!{DBWJ>15S5j;aCYLjr{6i*%O!?v~
zW$P;?X~?)>)|9S=vl@Rb^LMK9abO4v;+Pm99UPF$*(g=tzhM3Me<yz@&Puy%oVhGp
zP}x(;<4SgYa?ZpR*N$CP$vP>uIVdaDXQio;>m-wj*;=VSD^~`qL@J${sq85k9IBPl
ztr7|1pOo_0Iu)d5+tHLINy>tzytCAljzsos_4W$Y+#=MFp~|pj*;&wXjLZd7m>o6P
zngSR&9i+@mGHzU83SjH)H4$oH@L~Y3+Gr38YcR>l0JCR76<v1JU<R+}$WS$bo&e0Y
zaj}U+c23641ydLoC%g6bN@<yH-0CT|bxH3U>8umEDP3!Irp|PhI4hVe*<raaI{(e|
zdvlmW>$%O=F1z9xEpl^Kj_1a-g)`O$=5E{)xN%LW+mW1AH*RNVEW6ZYe^}{8&ZL`W
zx>L-i=CoZf)4IiVV?wd2Z)dbaj&dgNq-9suE>b+^Vy2kpacjw>e^LR)t{$)5PF*&g
zGFwsVlH20kjBRVhx|YpM3_B&QY@E4a*-5jen@i4aGnKkgf6e3C%9UGPqup-xx{9gv
zM$9x@bf)KM%CX4MnUa$>2OTq3P4hPJIkipcb*OTt(=FFrrmc(Awu)qXiEZ(^o#b`3
zfjg@^lkIS(+ona=mN>5sJK#HY)5IJzkDS?BJO^hi+CL#D?PPYQ)=J%k+fm*c$Fj~Q
z&J0acoV6@bH{t5W%~JJOvqP?#c1*jJHLKU_;0mpi(X5Wqp4)i0NNtL0YLlEgGc}pb
zAmY@qpkq^xIZOH^^(5JR^~?>(3CZ#5x6#Z|+_K`Ps<dOY)~Xw-8(iycwagf9dgi+H
zC3R;xrwXU?wru0=(w%UPGdrX&W68~+XqRnnN5xKLD@Cr-+BPLuI8(SjVdhG=)S&gx
zyUbSHa=D?FvDirXZqKsQsas~Nq}`H~>N4%lGR@N6)*Z&%+uONO?cmm#TXJ)9R%f{#
zG2^-wc52z7)e)j=nO~pIIlAd)u6L?-#<pu_W?>g*GnuJnb&KgHUE8?r$dsF#vnD64
zPM9s6qPwasGjP_F++LMi!Kub(F7>w*H%n>V61$RZnz5?YY-7?j-8Q#H({iGYZPU`a
zm}R=?MoN~M){?2ZYo<=x+N*7>ljfFekmhkV;O`^fu3Vv;iW^oZbY1OQapBZrw>8<E
z8#AUw^{&YYU9@7Y*rA+=TT8Y~I<-<)b=6sKW68*#Q)iS-!>fH=G!~mAPV9AC)RSde
zFV&HfrP15%n;~s<YvIHd-EP~CoLVe2X|kz^PnT}*#zo!9Ik`PPM>lSCb-C>px?*N`
zvc!#BiWA)y2f7^%3|x_tr8+U`maep0PsB>z&ALn0PP*mgnX2loY-G%HH4W@uP3=rw
zwY7iGwp<7a2?z-Zamoohw$>@f?bgK{&yB7~6aN`oS4`R{&AFmY?Wn^nLur#MsT&vj
zZpkv3k(sPDQOZd>Wy)4nl}$l6wI+G`F4+_mGHF%Vk|~=!RpYNrFI~WF%Ir01^Ypa~
zm?P>p-TwJis@F4%Wvko8ZM?ZsCb`m{xeTgXXGJ^bu4=w?*kIGtDbv?PwizvL<M-wd
z?Z339Vzrpjhr_Sd%`trRuutpZ%}B#T`{p;i3=7YGwJglw%}k5ca=Q#?9)7euYsXyG
zTal6n3m#6|r<GCEUa<RFZkDdpu7z3JQ}?fq&bs~cmqPtwkttIqg-li59Jp0Fa7%9Q
z#whPhZC&4hTU-ZK1y`E7c&>33bd{PkX~{}$)m4HiM<NYH)sCH6vSd|os&_`1(ngkP
zx~$2et1l&OOqEDwa}%{&mD=@(XF8w3(UxODn+*QAN&Yx;<YBU${u)2|=4CoDZr18v
z4-=EWuxIU^XtX@F-f+r^zw@UGZ+aPixYf{SMzT!2&y1>q<5%7+XLon!7W$<vv_|!%
z-qmuYl=&{l+(U&Qm4pdzG)kPQ&hLF$<@k&ClnrzD7`d(TpX3(WEP6zKQN)QE>w<jd
zb)H&r;NXwtUb`)VMNSzUv)HF2@9&eWc*)Or(_EInqIO)ryxR}_N?KbVXgkSZhQ*{W
z{)-9<3e${EtEHvv4)S00R(r{Eri7z)jb+-G;@H!?vO1qkd^7Q&g$$q9s#kNaT|1n4
zDaK%i&tldelggG})axv~wC<k7vd)O<sVRz$M%%h2Hg1jGnp-zPZo&@j4KGg3I2xgz
zI91psLi>{P(rd@oEYoP!GGaB`8eRWt)AP5U5_?4T4oYww%z7qq%-7(UQ8341UuD6K
zu2MQlTB?(RLZ(gfR#n{;b+bo}S;B|SV1{st%K;`aZ<VE!JUvxrhjBG6Skap@IX5*-
z;+U6V@1!o}KxvI+NsVJ>UK+hFIZ{oFGd6i<c`ci<sH5X(uSk-vpchP`L7>zDhN%sv
zA>CX7i<DB%tn8Siq`;x1q2v^)t+F!6Ytp1i(}GT`s;a6QDXDt-?!Pg8?P6xfdbeJw
zO<CP;+fqZOO}cbq<Dw0JJ0pX(O#H|bG$-USm%(8!NzJ+`kp^z8Q|hL_HEy$*&KkVv
z#WbGa#auEX1(8#Ew@r<Vo7$``a{9}GaQ<7X4lDL>ybwHmz_3|s)AGl5J02{x((5+-
zm9X@1qr`!}gEF=r38yr^2p;*Uqh^yPQo#{)z@5eG-Ky~0PxoK%m$|le>#SSXwtW+F
zdH%`6^Uu;ao@Jp+5?2ZHNEmIou<YuVT()D!j+ym#8@sMDbxo7n5~juLYm#+SXHx36
zDc2^O%(}5<vr6vt{Y#j|LKFix-P#=OoRZ^nAy?;G&QZxFX-lO8*WC0@TDx}9tc-2k
z3EOfvhD5E7`llWCpFzk2bQ~&61EWd<gAmgefk_Tw)7CgSv`m<wDAvH_pm0bqw7x!O
zy5>@5U*4GKmIchx85Vg3cOLGV-n^9Avp&4&<<3LTxt{Z$lb!?Fj}M)j-Qg4{b*bRa
z!<dJ=LMN@Av}S6~)S}RnVUU%+fnch8TLS~L1j8jyl{Sx*NuEm#PVyL>R5A8QoFtJr
z$s=u&r;3rY$|PUKHjl(MPsM3VBekBaPFbxQGqosmQ|QSsubo+;Qj^wsZS&d`dNN!!
zS~X^Biu76rmPR*$?p^QROix+H>>$~jyIXDB-PYXQT(`@7VWgU*O50?|S;B(axi`XY
zZ&<rMQ|rm<N$b3JvQ2-ujM=Hac<S11Z^O3TU3KmDro=W05CX|U6+x&SiIdhzq=0p4
zJy|{RXw-ABt>>m@@9x@qZfZv8wcBN)rQ7aK=9%QIV&tic(7g%d^l;Tk#YyWtQdUn|
zJ87NQrqJV}ndgL7$KElz8oj&spMBc7|LgZ3NM;id3AlS)TJm6zghQZnxlB$vn?WL@
zEAO4cjdLUpwy=tr7aluS08^G;X4vvH?%<u67lxabu&yyLkkN#zx_P%J(K38{;V}^7
zUFaKj`GTzb2c`!$F-p`+L1yq*`(}X-YJ;@qr7l2d5e5dSTMHN%7hJo*z>vYfU?O#k
z*A&!5W#DCNU|`N*jsmN@kio!Uz|y>GE0^rY?<YSb91{=>I9_<n%tykog(bxBPGRq4
zHl9RAQJ!*{<dlQW5)Q7;vd1NE8h{km2i!e)%&Y*!47ht-Trcj@&B&ZRX4}5Kd-qP`
z2}E%@yTnZ>OC~uTViZGp?bk^q@Av)uy|G7K>l@#r=Z?Ko6?7Aucig=8S$FER(}%P3
z^B#9SM+=qm!c9-#>O!U8S)6)m1?N3((0C3pyBy|VUZ{&=&*k~;Jh$`omi|c#e@C;O
z&brwxDz$OC!6YWJ=?A14+3OiUZw)%O=-9C>Q4Qb_K@iMy8kPxo`ZO$ak(_dJ*#ZUz
zV-6Kgg`8VVn=^bGmd(lpg}zuuqtT=WlUv!0IoC87Fh*{RlDHTGJ}a1kf#J`pSBnCe
z&d%m`U|?`N>yyTkAZ==D*1*7^sg)&hHsp3>Mpi>Ts8<noI=f!>K*L3~WFrSgR)Z-k
zSM$Q}zz}Lsjm$R70Xs`NGMj<bYc|M;Ty0axL607$T47<no3ngaGou`*ZO#TOWMDYO
z5W4zl?uuI%S7+SL&Yu*m68kXhq|%EouP?uPH~0Jf+PiPJ=Wa8*EnT16oV)RXiuLY$
z-}gRHdE5j#D&cW1X!~~X0T0I9M}BThpA6jYeR~sMo-p}y)7gr>YI8l8vwe?Kd9SU^
z<#6rp-HhK`Z`tMjydC}RkKwIzZ?EmVaWdr3_k8hn)$79-imks_9e0Umm(@$lxp(i)
zJ)*bV#=|jp@7=q1!@-;KE9)0@n0d@{Dp6<muljvEciSXSm9Ja4^BMdfu*<BAne)B&
zo!tBC2D>?`*6X*jSZ|+SZS3&zqV0=d(3Whu-gocUPJcfyMX_PYgZH)Ten0njI^5qk
z*Su_gt@Fe{*XOsB!<5CE#eVSnP447-*XZ|se!|;r$8P6=w&0uHX1kqyz@xsreDC|}
z0}i&f>v@w5^9}QuFZU_>eV?Cac3b-WzTdUq_tvdg_3o{8gCjo!17G#()w|2=c2CIs
zRr@w>lH_uQLv2g$rEJl>_Vtl}QOAXgDw>&!#fOhfIBRLS)O6DQt#xHFlciTp=PBE~
zyKG(d<%JynZe2^~eBHR`gwiyVmPZ~QmGynQyyx<&OzhjcL^*cLCHL^tb`ESe^7C$e
z-}`#&>1*%HBcHu5Tbuggn9yz2y}L`Vp5p21Qu5TV+xLC%?|0YhJXKU|wpZtFyX2`d
zZ`<5l-6eLt_rRwbyxt+e)0SjAWs<9#r^<|Jp6YwK(t4h#W+?9YeRG!F%=1fo-V5!%
zIg7o%<D^>quH3!zy(M4FuYNw0qvCb$ww23`gk@7++P>fOS0{B&EhndC{=J`<FKl@H
zZc?EI^KRLF_ff+!4|Kz1_xAI9*VgWVZ%j`xyIr{L#_inO`X1cd^zPNZ&E0k@+Vh~F
z>Ku=%k~Zl(r@2`Q)p_gpc1U^Vbl*91;d1${eE~_<-`Csy{r$dC^k-f5I&Wt`zk9dx
z<C5;Zcl_X+yX|&{*u8D7TeveUOLh0vZqC(R9{c+3iaq<j*ZzLL@AvzC3<^wt-hJOu
zz4sjh1E<jM)0=n41;=hSd0BSm@~#t}?<=1<39-%fs$9S4<%`Gz%Fl0X-gd73Hma+W
zU^}U^L5%NnH{@<(yPj|NZQJeK_ts#^+qp}(Gz51<UMlYiD``@D9<c4>mPwvv3v=Ht
zxfK;*?q0QMvF-a@l}UadZ8FsZzo;=CYS{;M?vgDpGhCOn?K0m!E&KBKyFZ`r{ZRjI
zeiaA9j$>+*gvvcHJU%=hYzKV5HrN5M!1ECAh^P+Z-g$l7q_@?%OFtP`-}Y4b@~zcB
zPf>racmDjG+ur%nPVeJ0ZZDbSVXJ5*#PaxF%h#Hp-#gpy-J5aKb>F?c@^-cFCNEJ>
zSU=zHqrvZ+;g{=kUN)zS{jTcY8(-B@^Yi;IC+YdsTEFsc{jU1*^>#^%+|_AGXI`IQ
zGRggRb=mE_$x9T}vz2u=oe@h9&fdy?$x~&Lr}EpqyPWv5l?`C(N?PQmNgR{)?HBSi
zo}YI+_fkm<%Zmt)goAS{w$1jaa+s^4IOlgsi(KoBW2N<P`%6@yuI!E6YaIF3eC1xr
zc)RZ&9)1Vo?P?z-M@pv7zT|0b+P{5;Vdh>=keny)trKToD(>A|U1eJKQsLXV?%Z>G
zetD|+=iAM;E@_z{yv^svwXnNop6jj%!=311yE*q_@p`*Sp7ObGF9}pdBukW<+0=Wg
zoU7fPyUkGhT1@w=U;Dn_UH5L^kNqMiInwR!DzYz3Gn`wUe3z4JJt%G8xcYtT`t9?p
zqgDF1&##X9UAb}f`|S99yKh^+eNGOC?7+{NWOuLjEriT|`|KE4<L_HHRdhFbMCUKN
zxh=`c<9^BHy?gVQ-85KrsD3s3(T^WLKDsX(zWed2d*PiHlVsn%t~EQmbepG|Qj+<R
zmiJYjihH+BO3GDvy>k1KNuG0ldw2+l->?0C=-2eyZ_I0Ny?gz>|5$?e``Y*S1^Aa=
zzw~~0?e|A+#Rxy*^I|>1kM{iq^6jPX`e)_5HZxB9dEBV2?~7UPhg%xgPwm^#<?=jm
z^}L$xW;;*ExzEe`9G~@brS{XAmiJthYGcbwDnETbZ?3f6Z|?>7$=CCh<JL#&hrZNF
zk0_nGi6@y+ZX(wvHzW7u9w#Lxq;qL-G$|}<>S9vp(6~A&#Bh?Wm7B+rW{asEytx}3
z*En5ta1mq`+&InXm|@Q*w}{ggTLJ`G99_ANGFG`by0VI}I0^*c&waLi;_9>OwMEzS
zHr>mX+P?04-136B{?ezK<z@F4PS@GUY*3%{{FH{H%`1&~Dc|6*wP7v#{^h1M#bU=!
zuk$mT8y;J9^;xd8)c5EWw|5=umil@@Yun3g)kyu2sU}%ElVbI5nk6kxndE)7Hm3bw
zF!y4adPk#&ZJEmKZnnY;TORneSqpcS=WgA0@It1t&|9B1C%ksudN4IGIjfU5M`-Vy
zgE`CUv$m}`le2h%@-j!c86qD;U-*XxpJaTiQPCAzy6yVh(rvq*6#sto_TZj}I}aCM
z^XOK6dvMR!NlGULs|)gN#n+inH<g;G`hDkK;q9{54c4)wC=}#+UQqVDz$_-zoN09<
zdu`k9TQhEL%}UPP-nmz{JW%j@si4)~yXK1uay?HfYIxWCZJS`d(J_-{!Pa%NO;1>;
z-n=pQqTfO92U1fOoZ6`EDPfRU;VmjWMVzysOS>&h+gQ76%c=@ljikuJ8Ko)(4|d23
zJ&0JNCS|tGSZL)%?N!_h{8l>k^}IN$?!9zs;iV|k6Ga(UwyaeTdBqoaG;sPs!&|3A
zdfq0^nPhS5xYNc1FY7PrwO%Ngrrmekohk5S$Q$piLAy0}J9QNtv-UIA7QJZYy{s@S
zH8R#p&0wS7@h=v^o2L2Qz3QG+VI64`XQ@)Sq{k|@>$ua4gBNvV#5v1E`VQKxm^&p-
zU_F;UOK6;7-`p8DH@Eu>Yqv|hDb$-MY@_<vDzsVaQ?c$kt+%d6KOC-?6FsTi_+pMs
zfsc2`UWFGQr-ugKm{VnR^7f&xS0*00<i6Z+r%J__>1!VMwca{-Q;)mx!G@AaZ!Z-@
zCO5SuYV37=>AX?&rQ=&iTcLTYg7mKT7*2X9IdzUsp^V&=6CV=4JV@G65xnr?p*fQ*
zoLh@l89kWsF?E$&YC30HI&;g09gpkV{SJB`nx_$~sa~@1VQ58A>;16X(S>Jj>hmNY
zcY7`Em%8b=yT9ngn=#5qUVCTGwLZGB-1XMs<ZR#Q$iD8yVulrluiJl2`VjH)z?T=(
z_rATc%OENCxY_L7#lG8aFFz2We$lQ!!Z6-vH|Lek13y$dYy57eu5$OExw(01r=O|r
zw)$<thLPK}J8$@WNL}SVXWPzD`O57n8#@a^!xEOx2%69JOMPj0ll!Js`#ScW2!7G^
z%Te{k-1WyKm-INRc^e&fu}aiUk?L+04^<BhwCQx>{H4mFwlr#L($W<=UPsny%?dS8
zV>z)&Cs^cY(gw{&AJvwPI^F?MO@|`9Lwo}boki*mX85c+wI-P<!Dm%isJ2MNqC?so
zYZj(*i$<(EYUm@(a#T!XBi9ja5s3w-Jf}?Nl<+tzrfRS%B2=g01TWL6l`V%7HCvV~
z<@J(qZHem2(p<teL1NX$&`hpOu0+w6u%*0SQe9b^O{wZL`PqB@r86t8*S&bQtyg8z
zr9W$O<CjjVzx~Oyc9CwNsKZhfm8jXZ)%V?e1arDo3{^HSd#U;$`Pyu?$4-8H7apCw
zaOtI=!CgtIV}9G_-YKoR_sk$KeSK`)p4-w@ACC64Zu7Fad8sr?nNQ4U!JgXzA_0Mp
z0xql~A^|RfjILZqS)bi%Sk%<T(WIcUU{RAo2bYFtvQBDGa=m0q&&Fx2Q!>t}IBFae
zo66!S0MlyIGX47s`HMj*lh&wg<oM$d{%DdZtDndwiHMWljFJsKT#14fE<Rilf|G<Y
zISpOK6nR}%WQ6(zi5v;q$Qq_8EEurSMPezpAe+{rh)Hd%IvfwY<|=55ERAyX>zH(8
zl@F^aXUM^NT|vzvjWtfwLgp;dJjLA<F>Td?BOP-@T~4@|sswvFhBbM1hB|YsI259$
z5pvPXnI&v0tHe^?K;@r@TqTu47SD8530`2I{?V~MQ~SqM{|CaqFV?f#H|=AZ&(%Lg
z{Gk3+;fKx_Z9}W7IA5)dn-bTtzDxYj>K~e4)R&4c(Z1AtwO-|m$BRX;7R;F%`e;?H
z@IuX}8f8j9U2P`FiiQWZ6iu;NG`F*mF@BOz(v;N;f*v{f1iJooSy3m_YR{pypJPRQ
ztE+!3)8y-+!Y2c?;x4|;{VSzg@0xG6IK1uXqU$qmmAA*<eH#}N7xX-0d-vY!Ti<g>
zot-&z*4C6VnUDil`evN1pK(}nvqZ94GEdr>v`O5m5oc$dRT1-6*u=fC<cQ4UcA3ZX
zpL2@TFX*g{%dA|x?a$Sx8@E<v@jly_UG={7%{%Uk@9t&Byxr@xKK9-2-MnSb^0v-S
zDLrR3TjDH|!HGRLdkkkA&hpTi3b6?!@bC8a-2Kz)Z*P0G3Nq^(=n0<u4Rl4H4TedB
zCXXSL#;afx#h_VX7sw3p)Ya(vRz`V2rhzpz7WIk*x{5}DW{Z_HI^dvFqkd7B26z@(
z2`<>t(WP_?qETbT3efcOMb`)r)upj$5r{r2I#ugz-~8t@ugm1T>iD+z*wN3~KjP~z
zT~|8Ln5+HiLQZa7#I`@Z@q()bQy3h)ZsmS`U-R*+eszCEJl7ki4~Dw>9v+O#MP}Vp
zx%R!jtnJD}-DKs6lh<zQZVGTxX;Dm6;CX4`ve<e_q{PMv+fKT4DyH*1U2GYxB|dQ@
zQ&*D~hmwNQg03cx4vrN%0egBoL_!1u90eIgSwaL{99*5;jE+U7_G~&WnXIL}_nwRU
z`q(GccOSklpUBbaCZy}?$l}5hV#8i|V1E0<g!Y2^(AH`Evd7DnZh0rBwr{(g{WJIH
z76HjW^?JYG?sT-DemAu0{N1gG*msw#xW&QqefPE6tH*b}40N=8cRTlO?~)0VJgw61
ztVtFvFKJY1iJrRYbbh&Rdbwc_Uue|Up3r28RjX6C9gWu6Hpj3h>RhtqVTpsGJxQz9
zPK)-7I@psQ9bDhu_;|y|dp6~b56V71-c#|O`M}%9$N6P!miHY#_VIC*`jp$pdmkUK
zkYmr6v%d6YugYGPz51STC{g8E@$hB7ob`bZ))gP`>)zhI?e@Qa^6ih`AAkAJZvOI@
z@0Y*&`R88|w+bX}pK3axG9gmS*nsDZ7PrDipWu3t6SGc+W%5i-n{+rWP0eewN6KoG
zY0}09httxOmU>N1S#8qhwb_&B46`wtw6THY47M~Lv$VvvGiO}ArfQuG%hWMTOZ|U9
z=keMA#*hu~CZtCcGdzrBv%S6deRa;)S3K3b^Q#Z7Y&gKfB_bhmfQL&6?2-wQtP>(x
zCUL7yFoIAZKI?=?)^{&%hnH8~-Sl<S+ugg4t$n6-zJhOWxY>8cYwyFp&%3+6A~ZB~
zy6|phZS~bA^WH^=-M)5x)_OCI#nGp9_gq}Nw|s|_nAk}+50S(QNv<o8rY_w+J!Lnu
zUj5vEyVm~Owf4XK%eqd5zSp~_Th0}UG5>Gq7^xN<c~F!uhbgi&zM()sq`v+~2ZIEw
z(egWf38r%xet5sooaEc=Fl~d0aI!8d1494<FAviMmfl$m3=HgtR2UfIb0@hvIxw)8
zGie-PkaP59cF5zswBlhv00RT#vD*v`EFE2{we`&&KOER*Eyzmbm0-$9l(JRt;x$~V
z6(Ysv%gf{J<|ZIC&#Oz*gyG}@1~vyy+n_F`U|}`pz?aLGxiL!kdQHw+VU!`o?AFsP
zkhvfzP|(GzYF2)*^A(3fDM`s6{xJO3y7lTUr~US4tMgCm+*F-yAGcz0NY<`2hs{Q8
zGxodf3aOvvHp%2tY9?g%H#ukGCbu<LW=#=goi#P3ca12k<95_hEnWt;8zv0WVY}Qe
z<h1s>F7Z?jGiO-Wx}?h}nawEKC|Po{n$e+T$;lFDW*kdN^E$Iy;;c@xkxsH<Pg<y9
z&!K;EFGCMin;mPmv$!pGJK<Ju{nl{ahFiQ1SEG1yFL~!o4UIW8HEpw|+im6CMZ&X|
z+|bN1Yt3dgo#=nC$?VotpHz*xXImpz1*haN8wvJI^?RjtOVpT2<k>B)dT*hf3%7`y
zT?skH`1_@I*4jqt(8xv8GP%DW)m@q!s-2L{X*$ujYqnNSM^5J~r!!7}KZ#wHR;rg)
zN?Wj5Y0=(W(=H|*-P#475X^SlrlqB|R@Cj-7Q-#Mx?N`ui=2t<HuN@)oSAH7EIBP@
zS<3dq&St$*rfYK4jxLH^lbf8JwCZ9`#I=^&Nw-!TrKL_eGjp<$x5;M1sWZ-`iJX~~
z%W^|&>l8U3ms=~tHf;OtbH%C4$Z*A#z}|WnqmG-YQqwjjosBx$6QwI=xFS_&+9l;o
zUg=ELX-k$&RrO3&opfc|l9f8smdu=4XR+g0;>@W=J!duqXYIRoFfh<DFwAW2<mAAW
zX1ZD4DU()eO<FQ(rFPgyX+x!sWhxn~lx|0+xOFU@D8;drZJU>O>ZB=CRaL!JHFa~Q
zOi4?utKYO%<iw_nZf}mwxF+iQ+E}ag-K_=t4A#bb1+uX%PFuO+R$%U?+bJ6Re0isO
zR-Cw{oBM(37Q?mmbF_V2zuvZWec!Q7^}Enb&d-|Jn&PK(ZY^zFpTBncgIcdo-DkJh
zz23RCw4+=xzGR*$yRN4m5A)mJRd#)ap>0#jYt9+&sJxw4|M1|+Gx09J{S9WjMYfrS
zzMCy3HF=iVe7WgWH^Zy8Exnz?p6eQZaMkauoBX}($Aouzwm*5&`Kwnxvd*sd)#vtl
zxnHGOPiI};w)OUzJ@1<*PCeRNWIefWwQKPwjh}LfW<6V*b%RQ3b_Pd9WKBQaJmKkt
z4;RzIPaWOxEON=trL)BAb<V6d2^Y({Y^bj`?b@U*oVlW1C&O5_?JL!6larYGi`TPC
zlKZr{zW(&vw{Oq9^V#;|+c!I<uRN-jiaR#_nbAkvtuo;o&%}tUCKiR+IB(-y@n&w;
zx)txHE)NWE6JF)d6q~~Hm-~xSeB--oE6!}oxN@6kagb-Ipla%hXsOelbtd(TUpy%&
z*tEmo!KFWm7YxIsV){f6{?rY36Q8N<&iO+<@nYwh(1YvTxtl-5PkOXRVxyH+MEp{w
z{Z;`}7bkAYjZ!;y%v4m`?QC#zvguOCmJLe{dm=U_ok{7@@=5IG77Oh%a!nS~anqSB
zk{Wc3C(^am$m58;YG=~JgMQ+C3=a$HA3D$W-8Q>T>-d9RZaQK*V)_RYlMWsIvN7pL
zyjI*YO`pI?DSu*AECRpm^zu{B6ZI1*+3BS&yq#l5;H8HiJEha}WRg=ho6YQ9nU?di
zi0kd4>rB^!yTbK~a}1{I6>jF4dRp9cvDV4X+8q&x6W8QK{7URG{Bq20p7-hO#BQxE
z6Y3AU?Th!`E3s*{tB>^|@9DC7Uy@F()k?hQrLKG2d-bl|&DlxKEP+u>>#f5!ecJSP
z_O{hCPkTqq_>tCf$Tw|Ll5eV-$Z0#N+hSR5BFFn<-nCuYrkqp0_Vd|IX4**>Z{kB`
z)-DcyvGuFP($jNp^D0m4OY7<5S$gEE<o7+#?)*M`zJB+U>bIwg`uL7l&6Ry>VR^cI
z+TBgp>~vi(KR&MYrKD_zN#A@aIo{&4ew8<679U*C@&3emtyJw(v)z^-x_;zA(dpT4
zst2c7%+!5f_H*y8YyNV2nnxbIDKB3<=k6V=P5oh^6}AR@x3-JEat|uWj$KlIYsFii
z&dQ)$rnXzx3o8_4){6^!-`gXtn_Bd7?K+XuGjF`M=K7fF9(pb4%7?CZ9lOMWmN!ak
zizli{aX!hN^Cq%eH!$NB>n+EkWvaoOE?o(|s9KQGu+{&Pm#qFtuRl#2M4Q%`ZOhHs
ztaEn5wTx{imwA|Oxt-N!=*Fv~vB*@)#7*g##*tj1CDXiBJyRxKnyOmw>6zu7;2q`K
zsu3t?td*qF(ZQtDq&jJn*Ho32nwpxalO|2}I`S(xGdMRe*;UFbP3N#t?zXITDj9z+
zmF(!!3Ch&+@|v_MD#|2dt=ft$p)<2p*PNW;lVufi_QGn0N2~eI^mVNh{UNePFRkOl
zg&Bt|R$ck#?$Uo^;-$aNroo18^(KoiJ<D=mIH6#5@F6SLg1R;d(O*q_^`7;+Wa*d&
z9$6C?@RI9~$h!UuU0*~GzBEkGexTiavE$2L)&%W^o)5G?|N39|&;0ZIXaDMNpR4$$
z<}%Sd_M}pZr*Qe?J(FO($l3Ku&A)h(9cOL2qBiI0F*dgeYgVpGI2sWgXs18_gh%Ye
z4+*EPny#33?AWoRX|t8Haw4<EuFMXd7_!!A>&7mwo@AHo<Vd6JFt4p^GB@=u$<3K4
zf3NBPzHOVQZ)jzfGH^+jIEuV0Rcr-#rzMJ*=)V)NW^~u|#uP>+Cas;*4UaHOPCwVm
z%+3zc-ZA~)IVNHLPUNkbklmtUkUgJzyCDie=9gYi7Mz}t#G*Ex?<O;My)<}U6-1~;
z!FP9pxS(yWN4Bly+;@KW{$HOyy?Xb!TqZYJqG>TcioGz$*E}TefyLIIB(B~&g-BGt
z*7e=lp*7X796)zXI80C}-<{PRSifz>?U3A6W>+g8IZRL~yLMmdm?5hh-=iC|@>U$Y
zlPQ?@xOYvmKuE$n-OgpNdf25WvGm;nU01)hT!m9Me|B{Ie-&f><JaqWW555rJ$-iO
zzW=rPx_fs;rp^^Fx|@)lU;8=s-o2>LyNkX@?bq#g?d=6`K!i?KF)%RHGcd3%VPRq6
zPF=vjz~R9m2D&7TErTI4fgxUF+b#yy6@hMxu7n^ou;19p#-t?FARTaVD@2s#s&XKB
z>Wwjsf#K=|-DoXP+edM&8DvV7cWda`wY^bS->#p2dH3@Ex$}+}AL!C&yAWo0Y~AE@
z_1@E8#O~d1u!F&Yok7;f%k=KX>XZIc;ufEp_Ve3r@zW(gbKjpW>wft981v<Q7T=$}
z+O=Ty;e(;p{Z&6#s&p?|J!#v$^|Rk)elM!~F`I$mcJ52{a`g{ybaHRz<iyM7)rJ>J
zJf33m<DKP)AIcnas;l0a&O0vkdX@N80d4Dc%j0}`^($@P$<Obfdn4mr?E7y1s(w@X
z@`-ostMpdgS{wHDfX*bT+^u)6#BM$GfRRClq2z$)-S_+QzJ|uETEDwPLoeQ?@k`D3
zj#u2RUphWTe6i?{T-0Tidt5MURo|L|-0dkM0V0=uO^tMSboyM*-MY4ofpOdIZwvg}
z&zp&s9rNcZeKxiJ+NB>VzNVADiPi?+nX~lOEbC>q>*tgnn?5Ul?Yw)7&${1zdU_{!
zznnM&2g3vA#oVD=MEGMn^)B5|ouu^a!YonoNQ>kNF{@H0d5U|gOpkI^xz0Mt<Mg_<
zt1c!sFywB#?Hhb;+th0pR%t)1uH4O0(fKxa#pl3Jp|J&vl}&F<daG5x>!HK-B=0TT
zI8$c)+@dJb>1iRorgLk;o5ul66Fp52rc5$XpL|+vuFuLXx3jjNU2-dX)6zqY>yAv%
z%n|d+;PPW_hFE#ltjuxSdb9a8dU0*nE9OkSC4KR3sf4)J0<X-n=^5{Ky=Dsb*Lyc_
zx6g!N@ArBWzUgj1rJbtaFumUFb~)R$Q{J;b#q{UCn8{daH0^fLoD)kLZk_$?s@FL|
z%>VQ>kbx8RmwjFr>vCXcXw0SEiL>%{mKs<l&Y$!oU{}kMeR*rdZWrx&7|9emJ9l@}
zE1^lx-th`6=*;xa-RYMS<dB>8bJ28{6WnS`w<me`CU3gisb|`Ex=dxqHEZ4a8<QSK
zzI%Flx4(bP@%-5pmjkak_4r2J%Qd@ZawU1Y*;kMoe3ovzv)o8i!EAHQMeju^tdliM
zd>S^T>TY{#Ink4G>+EM;vBC;E^AA1$9y<N3UfQwzIibgka;;Y{yQOKp%_icP*2n7n
zl<#|7)pv;>nfcEB;G31r5=KwNEe$tj)=!-}^Hr0QmKI0HvYC;Q^D;D(7B1-M(wsSS
z<}--!iWN#qdn`ElCcLz)nD@|mk@xZ3zB_Fy!GeM;OGCVrRw;om2y#$zn4nS_^>^yF
z{UtmKi4KMmtA4MJFU|fI_dfRS-Q#7k%hI}ba=e_CHEma#=gSa=CWjdep!=Zf8Ce<?
zJcL*p6}<m_4Z9tkmAi_eXqjT0u)<M=Ue=XCJ-HdDlBP%s-qM+@r^l<Tr<J%WD@^L)
z;xvQo)`(TBo_bm|J>inc4&y0|o_O?Z#;Jmq9gDtA=9}_p>C)7d7Q2-jkG4&m9wd=9
zBTVwJ+ufoEZ~eN~DvPS#n(`{(CF@Ox*!r`HeSJ|+S3SI9DbrhK)tBvN73QWG>-wr+
zF=?5co?wL037Nnr{T4m$PLB=?PVZ2YTBh3e;Nq!yoDw}=`da#0-G`=paI91jeU|y;
z&bjc8>v?zA-CnHB-YK*6#+ypnb;moc&a92SbZM){Te%tQoP~A<J1spnL$zeZN6~Xh
zv)rxfCkK4c?&fvY5A<wX*>p8-VpJQK+)7)IsxI50#TS~sg-rQ(rBC(Z<725WC#|U|
zPQ3K??w!LY<;?un>+6fYnz(fB28*?wCu71z?-aRS4JljSQth^+#!aQhXOjBC4Yy|V
z^5kqYTcOUYnA>qOYSpJho~y;QPxQN8+86NnkiXOVj;{KOQ0H6x9(Eq<Cn<gkReqqb
z&ugLgE3T#PUmZhMoN$PATCrh@n^I%f(uhUVM3xEl2qm~_CM}z4v~pF@A#cV+F{P_w
zBBy+u15(5svlJ(_Es9#P(OJc$Ss;m9AWGHHD=BcITVRxHB5RA-q{W(nQ=C28ICKP}
zLY2LiBseBG)?KMz{l&g5{;>65cH`8U`eE8vT`L!vDJLpj+PLkHpW~e)T$=Z6AMZ)t
zb2Uz|==0(!$BefY%``iwq_AQ|N7JH3N?ctX9a>rt?!vURw3Nt+iL;U*!nO?W-fv~F
z-u>Um{WG^q&@!eip*~u6tnO1nRpy0sZJ4s+P}hOU^-LQ@cqCnPJ#?KEo3&P%IBl4!
z9h#w$7;vOD;Z&ehM{kfax6{Ig9ueKpg#lYbHCq)9X*Nwr=t}TxjPqC&-lS>h-mp>B
zbH#d5uNdELx1-+vabjcPW@u()04H%!4aEXV-Jm3{Uv@kCq>JvQims_QLiw89)^6MO
zss3BXLX9qw4Y|FurJW}+70lCOd8jISsL(0&l#se-t7eRsrin^$%LSnrChnk+iGNm1
z>U9eA`lsO#uVJ=r+O;dUQ=}!f8Ez2~3)&VI8gVk|)SASk1IgTC%%W@yM1KpnEPJMw
zwK~<<YnxbtS+w9*-o+WW%zA=3CV%srRI*NM;_rICiI*NMJoNClsEPO@^+mVLdM79L
zdhJ!`b@}9H!hgeZ#U}1kiVvdQPHwo-e8}RIzDTjwjHWkUCBZ2-R4-UA@ln{R>Mqo~
zlAA?rs)pT4`J^>oON^EUiJWR}@zj~re&JWV_sd%Sr7!GG2Mb-ACSWivRBNs4f<&!f
zN|RrxycFT<s<%oyIx(o^SFPQAfBt0>o7#**JAIZM(3#=o>)FjJv1l68ujqGbS*uf)
z#yhPSbL<K2H0(MuW2KZ^($qwa6Tyc*JoJe7vPnx>lNv186A{cM1sXk{-um!RhuxKa
zZiz!PR(4G}>g!PvC$nf}?NXtaC66@K|FtUozY)a$j%9vmNd2U`_xJ1LKkmAnXLaV;
z^So`h`#PG+Z*Keec3XJr?NGtokfg_N9KJGE%wx6eznu5R_Ttu^(>DrS2~qX+>R1Ja
z4K5uFEFMC)|7c9==ltiQ|LSv#-uZ%eDi58iTdfy)KfIm1U9nT-Na^)(@$&K*P(o1f
z5K<6S@DQ^59m<ryZTg;b%+u>1KCe`B6IS{Bqx$2%Y5Tgr3y4nL85rZ@5Xd~?m)U*i
z2?a+qRxPNQS1G${jf=*fbWl#<zG<f7q5{74jKQU2f=W&3dhM#|=Sy5%YHL@Yy7zly
zn=w!9-MfOO%AQ8P%AQ6B{Yq1nPjo+T$m#D<>I^cOtP;wra?)dpQ^ysPdJyOIoISU;
z=B+*b`r~~emx(IgyC=C!RH+Hwem#G&qkP=8*VbDPnM!fI+qyg1QR4G`qdnYn8n@ku
z-4@<@u6WL#&*yCfA0K_F;334&(JU~5fkA~+UUYT%`QwK?CaHdXz4+FyCo+c?2VC-*
z7-BM6#iQej(#0U3i6$YFm1Op1cGP!td|P^=zk2cR-P0{yu6i0No+((bq0ltr0rP9K
zq<<MZW-0x-Byv4sWrf{Ri)(Yen4E-K7BVu-xR@-tEn?$F$*85>Vj5FdMZ0#hdR^rf
z^Ie)XHR^Bu5(bWm3=Ex2E({EeVJ(fyP7V{-I+zrydx$c)-Qcy_z@Hm?_ilOFyLa#E
zL2X7*Ze?Jo%&Kmzo??0HIOo<r-)XP9y1I5)9OpjHeW)RHCd<~orH9Xo>h#K<(psc1
zQy=_W{_)%RcV2G$-c7ry-FA19<re7)ZjT#+SBb9e(v-TZyD6M^w@Pt_xkB%8hUFnG
ztJZF7Su}CQmC2>sPR5wUoDG|%-l9^R_4Y))a^V5ZiyD*D=P~{G8SrzP?S(T2hm;M@
z7#vdC%yVeNsja$B8&10f3JP?h5z%60I@W?NVTEfRM;_bUwsd8frdyfr8twMX*j%ey
z!eUp&5@&=-hAmwwq!|X11QYc?ySPpo%{nR8obf>B!>c<C4D}6*KmRzwz{$YC5X@-y
zfWgjdz85PiLx2YZF9R#10$YOy+XM#2?FTQ-4-9N7U|+CGK*4Hb14BR-x7!pE1_rk0
z7902(G#HL#F6(7k`SRDQRT&AhOb&QeYI-Rg$zW7p<rO4lV#MI<rR2rdzJg)NBE?YY
zE3@P#U-@<Ieq`F&kZJWflg>_x+~jTMnRfnpNYu-jOuN@^_c<X38uDbFIYH-4qpu$%
zdKfYo%nm@AQVhHsG8oJbE?~IL*1((t;wD}HusS~@*lF8>8@y4x4Y#%_Z4L98xzLw4
zlr@aEIl-(sK{rG+J6bSuVc5|yvs=6kTNg*I-NspO6mntP#cdaJ#1^b=PB3*1&E57p
z(^u<K$dvV;&YU$|7MylqW&O2VCKqlw#m$_V*_|-)3+D#4S>0|oZUwRhJDpO<l~&bg
zRMok;anZFLm*BriCb>zv+t$XVCFrmmTCr-%_uSRF*||Iy?4mQx_*a|d<k&yZnHqO3
zajDmju0vN3ch&c7;XidbtmE1$@oP6X-Sj%MB~zg`b8BuuVn6S@Wid&AB9qpB4SB=Q
zQkuJLjsME7ms6JsFI`oaHly=#P~gwr-qbDPYi1gTJV}~3TgS=&tlO29Tby~hN;7^O
zJvixf<MF4>M(NB`VuE|bAJnebHBFp$=}^wHqccuz*sA)PJ0k8{N8n|)ed|O%Wo=zD
z&nQ{vioWQ~DSy+_lJ=fd+mLcmr7lbO!A19jE$>!DnXIzWiI=l2pS5-B);l@t#Ty^}
z`F5|}v*oT&)`OFCH{Fyn%q)qEsI>YtUFr&RZv7rV(YjvsrbBy{ORe+Tqa9-7J;yz3
z)`|y3hn|XFG_>Gm*|D;)VL$6v8?&X;P8kb(N39mz_ma(5+il;&V71Q0!S5z*$(WJ!
zyU8TO;L4vC)lX)=-5Iy0HH%%kX%=?m)S4q+`=q6Gax#T}WUWbcKddduDH$1)ENO6L
zZtAqKG^11Xhs1l1MI>wM%ruska#Ld#_!z19uyL};^q$Sil9GuLCnsx6eJpX}uvnP0
zn(LIL6o~~dC#!i_9ZDA2EOBz0&y1kCsXaP|Mw_NiNiuZPut?RJp)F~YGU>6J(HbMk
z2xW~UM<rD@YbAF1sHtfs23+vdxEL0ATu4vjajSEe#nTYWdfgSb3Xet}+Lf%hMB>52
zBPJ^!2hFkCQOM(ZZSB@e-q&8|i8`#V$Xy?Oc%^CJq*S-g&k~0<E*f5!IIdE+b9>Co
zB?Ujk4;`2mYACTOBsI9XE97C4x7HjPPCv1bO)C!`RoT&&oM{$pxMg-T*M^4$lZ|tw
zgbg>l1s&};+Vtbm8DpOMAIFmIjO}cKJ{p~zVwC2yX2q!`C#R(Rig7*iYi?@kl~bpB
zCT%J`VkfaIDxf^d>d`v&_Q=>$qfLu7Bds2~K5U&9)OT!l>B*DJ=E<g(hqrAJTyj(E
zpp@_AG`}5-KAfF(=A@sEv9^q?k;UmFM_x`TUA%JD%PEBhelik=`P*#H9)48+!G<SH
zYs0FOZ9Fqp9S!qYk*dt?y*fE{<CK$A(;`={xRG+gOxi8TaArl}p`stVVs4i%*|N84
zWp~Ebo;KZN#f}wMHvKA4QufF;)|R||Y~xJB%SU^pyc2T0TW`dN>Y4e<bH9|FopB-Q
z(37itV#=#5_AM7ZvSXfjc<7bajYl4LTh%}Oa=K@a&&w%~622MnMh4%vIbZ#K&cTZh
z9<4i`yd_g=;gvmBr&}$vDkZI6ozC3!)Oyc6#-6NG4`QWkRPU^fSBVQb>E3nIq$-|U
zETkyIPfXnJtgeps`jSg$)&-t;vRm(F_PXUU>5(5^_QVNm?d@q@BR;SC7(27eql}9u
z<5tP8sJBkII9WX_Jk2}Pbm|+$3s=~uO1sI4Z|R=Q^f2j_Y{X2X@QqJyZAzWow52$2
zx;LNGJhvdzCB=(29Es}ZYHwLpWWsrCa>n69UYA4U#DijW)V!Ud=5U3FP6`uIXX}X7
ziJ0<M%Ux|@K*k@D{hAe*lQ#P%oZakkX=%%h85@JeAIwS6JabUe&?w`mlzoUr_p~f-
zwM|!2PEK~yxKiix&@XL~QD(|vg$sY0TP@ROW-ONSnUP>BpHR>Kqj%fw+zpuvIK4BY
zLbaxa1syqb=#r7!#Fnc(i>~s2;It5`_y0KCEa!&H^uLFh<tG2TFFgIhcV=nfkFb%e
zV}`K1-lpd@u}H8(!~>`2G_jaYPiSJ{s88IScD6OzGe_%Ib7I(4-c`~eW-ChSlO@g^
zm!JQcvB7u2ah2yXiWvq)e(R<e#BjFvzq-5BZMW-GL8;(yvAav$8@wB>*d(jhO<msI
z>cIP6&f@B|UF)VFkSUbCeetNf&WDSq!@WMZ&z_g^R?m8~(6W;TV(+WIt}oBK9(rlv
z-3+e!J}s+tubS3rF|B*GYvr>g8INO&OgW~;?%F(e;<@JCbKaadF}u9-_72nQVddG@
zTLZN|t+GAyT=K!>nY%VON8Vj2u<dy6#$y6;+y|>T^vkR-%f8ay8hC5-v1<;eZmn+B
zW%GG8i{n+ss|*koWi_pD<#MCK*o;?ER?Fs`JX&}@qW<~HGsQCJ{mwm(ypwJ5sM{td
z^1<n~qAqvt`kuXNc696YxpEy}%~E0{Hy6$}XA4hSWbHc7Oy@)DwXOwcvU?uKNXE`w
zXT0@T*$$)Kq1DZQE5!RkSuB<<4qPL0JLuTr2(z%2QTwa5{<yh7akGQd%@qnw91JW%
zETD>0mt{(Z3THi&!}R;PYrn5u`{Q1qsO{lU5q~eGrH4aBJTI+K`n0gXG|<)5=dzOg
z-yjutriJ`p7lo)k^=Z}?o1q(+>c!TQ5@akE%+<9)UrVA#rq5S&ao5v?t4oR!E=ERd
zc~G$FSnj5bYdv#T8ZzwAD46inV>!=EanU(GF~O}`b2RN(4!qb|?~<5w!f2;#*Q+9v
zi&0j7R>@rtC&lQ7ygGHtXa>lL>+Zr6Zw0S(cokTpcti14%iM^RU5h)<@ktgL>UFNX
z@?NahZ}QTBlHjMFkJPvlvOGR)%viJ5)MRPWI>$%-;+!jO+C`@=y7-7MY)#gu9fpff
zT@NaGd9>h^xG%q0*piDY>z6YgdaAro^J!pZP<W&Glod9itWQ%nPOa#9EG}B1tY&%R
z<h^x1v#y@F)X!=fF1*jpuQbZkX6aL|O0M4%tDQOHE+$R*>K2^rWh$9<)az8ZsCY{C
ztD{DJdd(u=v>t6bYP6SYN2IQlS;^C?s-o1k)RN05-FapEEVU|19<6wrwY+}Pk*^t7
zA|tj2zL<P7w2I?fz`U;Dt6Ka{&c8GZV%ZyC>}^f8lbp`8vv^^l)#)``XCHCzoEF->
zrQ+6}KC9lezUZbeQ%=k~mbLEUoBU)O?GC+FKbnu~cvY!s$xU0;wNEhPmaf!B(@iaF
zQ#WTug?6mb4i#L|$2{93w0Cvbx2>GL^-@aHRQ9-h3A=2X^Fuo5$)3hHUO%;_YiDk4
z+h(}rXjHHJ$-}NIpVZjNF1?+0xOa#9s)a8%^RD)s`e>e6UJy^tyw#1~K{BfT8dF~e
z$#aQ(S?c&<Rr^zqiSnylIt~Q!EOeFNR0~;<z_pQKQ<u*aUV$}2Ggc<5wPd)77%Xhk
znG#jsnYHKyuhyD?D{U%<icJ!V6SYI8PUzvds+AOS!P${VFriySZHk)8T9>t6%|Qze
zO*u5>s7KNgqp55`3yyLnwHkUgi>$C;u)_Iwr<K#9IVYw}y|8ow(^l_Lt}9D3gnGod
zbeIlwC2W{#7?j~*utqD4X_I2Y2Csz4LON_h%T(qpt=AM@k{PgaN#CTdBB#!yf6s2)
zcIHB2<cfn5R@<&!TeoP}Dxrsh?s{*xrQF<{V<2=<u(gp%ZAFiZo05_jDr7mJ;^{C$
z2qySeWaX))R}?HJY8EU#p`^zUTB0^lGiCwT!4N-@t)UDLmO4)8lK<vWA2wmtlzogI
z_LJ7Goy@!K*tILSw78VTW;ME*^@QA(PMvTfNireDs4dc`jdNPCVpG<tRiUBLwOgYe
zIyyQ|+H~rePs*9pW}%gn9xH8D*&MJf<d(ALR8RR6b8k!MrWxy`oN`|EWbTPG&8gAC
z2GRkyR;Nm<U6nA<c>hU4!)V&nwej`3_ocdeQhU7mR+V1<q4GqzsePgN*094Fx57@u
zDHThbF7baTb5*>hok>n9eA2YTS)NatXKvl(^+w=<>!p^Lnp;CGy_%b*JPeZbYUWxr
z-&KE;(Ik%(r#w>=G*Xk6hG}!GT;Q`xYcbRGi*~DOJ-_I$v|I8kUX5F6ORLes6)ah8
z^_~h>wO{irb_u@@0vEm*7#!>{NIDqFrW&lWVQJD4m4q2n#Dr>%lGOqy{W_`m<=4LX
z;TJ2tHYBCYm=+{CwINY!tFt28DtVuo?$<?YFV0w;H0e`(Xwngh2#GZkCk@<ECyTbZ
z1sQ4?sd4%=eL2}x^?l>k9+ml`Uqfq7nk-AJH*7MPtZ>L@)jpLUKT0{OmE=@DeJYDr
zR$BFw)5Grh{g;38is#Iz3g!O!MM*tBZAIeC5dA7afwz@eU0GSn<_EpcU3F^j=jWd9
z`(kWsRu{A=GB9vBFbOcUZp*db<g{1$Z_E5QLIvuRA{M9Ij5hOe4wY6rb#ucJ!%aDB
zj&>w$iLMu18MRcZH%Tju`9t0N=kGV=X#e;gU3GEe)UfE4|15M@ty(oLKk3PWpX+t*
zec!(0`;yr?v$=lX&3)~5EHpB2`E%B-p`mX#o#j_+ezs?G^}TzK@6DULP3*Sn!q)J6
zugxyJeY@`3v7R%lHgg1hHMv^z;C5(ebaQTKsO!lWcG;)R_r9%vI{Vh0{5ac_FKnuB
zF8sXNIiS+!PR6r7w#Bn77dNhW)|aU_ZSgG2CA*^fkVP{dWLYkrWg*p<JmW!r?z!X{
z&vehqT#D6oH#{@lyW*MUq?Z{;T6a{~<mA3iUS^eGwLeWmTjf-?hKYVx!b!{Of_erf
zrvCGf1sK#oXEd-p`F$f|zNtv_nkB)TZZI&WNd+)k-8AA_80t`Pfq`+|!Y>I{meLmj
zmNJH{7j_B>6%pr+iWYU{4badKyYu_KTzlh#FD$cEmb&%Klw!CV{NFZIBXhB{n?mMZ
zua&$8vy3tqOunk+$mY0!<;o(Vl?F2yMCzw#crCfN#K7&Bz%Nco3HCeom0x$=x&Qcm
zvu|x)w&F|)w%gG&Bqw~i9zFZsr5cGN;mPk6zdOHMc$Y6__ljG4-)>+4^)?w8LPJBN
zSWm4_`n<7fy1o1y)~Dec>#W6Bma6Cnd51zlTy^)kqpuwHdUAgZeG^xvAN2hEvHF@i
zyB~37`nsEVL^-4xb5~ql<(*-=c1^As*R(^oLPbyZb_u=a>i$0?u<okI59wfOvs+8I
z>fchk$Z%`o-P~>07HkRKx+Xem^%;$*riP|f2coVole)~vyJ6d3^(95hQ32oQbl5(g
z;<Y~J^*QZR;sQqsjAH5+JXt+sNm|FhQz}3E>Timkb-L9u{mkmUnT4v?ZiSrb?%(;x
z;^ut!ExL>KkJVgR!{76?__@%W3;PU@RmY{?m1hg7x#;n?T{qtB&~L%YuGxXEb(!IN
zGYg!z-RL&dJifX6%lRE=pZlEqvNh)H+{cq&eQVv4`s4DO(8S!Z{Ix~Jp}ya_({FUo
zQol8G`LyXf>z^)p7k5oOC;Ze_(Qg_zh33y#t}OcOR`@pcx7^>lYHkOaE(pJuw(0Zx
zy>n+-Z9Dbq_VsC3st&d9KB&{gvP5vh#feVUHw<&*;+C$=W|x|FzV`dE4^R6izgw9W
zZL**L9LH5Nsq@#0ik&upJ$cr$157S|cB}QY`E$*%-gi<P_SIiI{j}j-&U|65-ODcJ
z+*-ft#O}<QW>f1FSH!QmDLQM4@n^T0;mRL2#!t<P_qrOtYU`J(HJ56hl<F@`jQ85~
z+gUU{v?eNTvPu7TyPGzXUj}RKn{Zsj?liYiSc+Zov+3J+3vF_pI@NvCwF_xWjlHki
zRv)d|_C?hpW2?)ol%}owTkF3TMqPEAY;Y_-bh=*D4Q>5b1&?DkXHA{{s;IE<#MU+2
z*RH$n^`^I`mveT~le75`I@BL-+Geor;)YvWeHXP#{Q0ya@<{rXLpEBgKK9J8`Lt`f
zXH2QY<ds$}ZibV!N`J=2M)pK_JzjBSuI5#dh+{s17alz_Oj`0_x~K(+JLyz?V$wlv
zO$lc;S8t&c%T|R8WqKY~7b>&}GMwCLF~@6~QK7o<q|m~sW5+ICGcy;RsI!_ijb{zF
zfzgJ@rc(zJ9_@0QP<r*~C8LnntGkyZb+22udUx8@+|6mC*TceDQxhX2)xtZzxGAe-
z%7$~DI+|Mek;nZw^DOCfxp2{`KWv*T>z~#J{n{wztNH6m(ZolO3Rb*5@knpF@D#1r
zU61B2S3SY)x2bIIwyVAsYI}s|_3n_aYR=2Px^~Bu17_PNYBqe{zI1KW-p`Mx-|qOp
z^M1#iK6jRyy}2`;;{HC@-!Axo=T)Ue=ci9MX9mUne6APc?htw9RiW_p#ZekYhrU}q
z*{SDhQ*X(u>usu&nbtOaa$}Fg(f-a$DMwCTZk9-XRcci7u>a)YqgH1VQnSJ`*5BDz
zyj{xM>&1hulVl%n-+S6~;*E#dOq=iSUGlQhtI)RlM!3Wc|DK#5KRPXr>V6M?x_Da4
z_iceO8B1SxemUxIvt&-y$)1oeA5*8D*0)GAe)Q_}I^$Q5>w9h)nq4`$)zoI+(>If6
ztvnn1Mf>iJ9ir#Nj?7sYQxw@)CNCMWDf;Zv?yjeCw_R@NuI|#a)Vbu}FR^FQpXsmG
zI0yamNuBj4GJc(MMAVV<`!b74`R`fGnI4n7*7eq<%)*nia!$6^Y}Gv3xpLXGh+|pG
zCND3}ST=9^mLFA$7Ka|~tM|3~_&n?5Jj3eM>vsBmtKCxhYWLE|C!goH2T$2LCH(mw
zqxY?w@-}=hU}-)sE0Gt_F)2exWL~OVqN75T(~k;6*SJ-dcM50wCS2TeSG>@#f3awm
zq;8<i%AU>fp^Kku&YJoDte)S}TPK$umz*7G$RD<(C}s1y&D-<t?R+<1?Rdnl`mE&=
zr=M)SeSP=F*VomL=SEsp6xxJb3yrtl7d=~DVpodM?lUhBZ}{Qy=FJ?V<bX@(&0a0N
z6Z}LxI8w}+H)vCoW2IKs<;XV|Ur)B}DOPi+%IZA2>h0~hPhZ_MlgX$`(aSn7yk5@g
z=+Z}lvlbOz3%jy2(plTG!sBC5p_rJDXq#ufQN*NO6O(nWuUYThvEt1|cCo$~*_>O;
zC1y_b-t_dM)8oKIk4M*Br~2xwGC0cStrhg>b?$VrmFg^=M;A=mr0cU~!O4l<JX+nV
zUDdw=>ba)AOzm3jw&_gDh5koAlVx@!`gto{3EQ#tRQyR<W!W9sy@g9Gb%LcNR`y9A
ztYKb~yuF^ca85>F=%ln67moT`WH<d|UXi?=w{T91%xcA%TdwhPF6S*;{#ARy@jR)=
z7N@8BKe%DJ^ISBeXUh`@LC|4F3=9qq3=A#|Vb{Czw(Xm~Ws;}Lq$$fz`38qv)ql41
zROW)MtP8fP@#=<FN3FV^wK{(HT|q$=7X+9t@62Sw=KWaWn4#Nr#+%F%(-VF$^G@$q
zW8s<p;03ch)4A!>3z}HO>T^I{bBo7QL6qCAMXSuNN@wkff8i1AwepwBl>ZWSxl>K9
zZhAJM$KLkLrF`v$n^WhC7l-F%?_77`*1EU48@Bf<uAOQnu{gDB1>2o-KF|GhSCuYN
zpTOFpAToJI)y<&QLDgxQ$_iaN5t?S3ZgUqdG2OIOFflL9=ees9L(aqcOPma^R#$J1
zyL&fvTHLg_ww;$_US!W)Vmd9_A$yKTPe{^1&vgaabJ;B~@#Sn=(9K<Jw&`^7qE!>m
z70=c^*D>+5(WcWzXVz@eRGKttsnR4(O|76ao3(W|>zq1m<~!-8@8pzi!6`R&r{&C6
zJDIUqBvQ*KuuEsEn#NHvuSptRnp*Wffg(X66I}v5gOw)n982uy`2S^X;Fet9ZAM$;
zvu@pA%Ph#tEXeI}#Id7eD`*nIQNcs#Xnt={^~p;$<?a4l3|8Fdx)`juEv+;dCOQaK
zu?8>*cnC8vfey1*fG)-1tS{ZVH8-+p!E~VunO!qOj`a9)tjg*-pgC(=eZt8kk!-dN
z*=(D#wN4#jIn?g4$>7k|)04S_Teh4`SvJe!+L>ch6OXDZ7;ITIxh3$x;#OD7WyjjJ
z3X2|XS|?U`=+G7ArVD|G9vN*_{Iukl&*VvZo;ndJvo6H!(wXBOmD1}sRVrnJuhHY^
z@;Qa#!p$p-mEJUShXg%Yv5WE6igkzTMQ`mYI>#4tEJt?L7K=@9OmCW4`xZUSn#J+f
zAa<?GOg)irUI+JtXD$vZXkF&(+*!0#XT#BK7E6y0drw9wtA|QmcFC$(YH~7bv2Vfk
ziG>zcfmc?C99jAz_(b=mMHO5&UW>23Jm<UZNmZ}ao3~{J$MashKIrjY@#>3JU)x^I
z=9BgBVt38-(JY%aed>yh1)nnhGe+dGr#w{l+^4r@t)7?I<UY~B#U=}5ysSg^es`T@
zdBfLn@~PmcEMEUs)@9x<nV*86e5$BgS}C~bqMT#gf-0Bwp&UP$`a354U$uVko4fb!
zKCa1TpYzH{lCi;R=hemuwy)XkO63cy_PkV7TWC;YGhN{gvsnGx%TsUEEb3)EvhK>K
zA3GkUeDYU6vRqjGK#k9QUE3`MyWS>0S>1a5)TtNRT`vnfe)Fy4<UEx#n>X0ZRk-U`
z+O2Itd>6MRYM+Q#x%FFjaqFQO%cm^wstJhE{IW<-<iy@3RgG^JRjry@rKR<4)r$39
z>@Njf?GGuf*rcVB!m8P|lC8ca)JT=5OSP*rNi)Oc$kK*QQ(GkhTiTR*RehaiDP36B
zX|&?XYM~8*tGbRlGo*@KnsS6!YmLLDRR<O`^{n((^kxcE3Y##iD}u{FB%>wM$)v@E
zBS9oVB&(G-U}1yC1upwnQ$oW3F7@6rNoCiBgqGDDC%G<oD{vh$42jg5F;%#p<EY39
zwWV5#5?wO`O@n-t71gHndip4<s5MzF64(`VX@%CQ?ky{W8$1f@?`}(Rb~xg6!B9|8
zP=J9$g%gx17#Kj=0=(4Y?bZlC=2aonwN?cl-nu#2ur0?`;?SuhfgRh-wwdKRJ?Ruz
zc&QLB;xT7wQLD?7C437PDq7U9a7l4l&T(pzas!vqijewuTEScsU28Rh!av{Ka&u$O
z3du0GY_C(BHm!=Ba&*GU&ThfULMIohBza9{Q~1x9nd>=Ia^g%0)tH^hy4l>unj4i;
zX3m^BbK2DzUGAcXr+WXHt1>s#`tFiNoEirO9JGUzf>*t~o*4f`Zk1f%Q)^Gz@Or;p
zi~jQqKKb<erkTxpxl-<?K2H8A(cV!vXU?1*9JcE7)|f4~%LRG2oe8Z}FUop(V)~Ev
zlI(Tm94`WIiB<$>W=CDyI&CSx!ZY8PXSdDLmdtZ`=UetfxMA^x&KpxVrKRO~S~<^(
z+?l(!rH|2FN$^y_&1hrJ;LwmTQI<b}zqmE(1(G7URwVLF3JWzf6&Bj$;}kUiWyc)P
z&_BvQwSS6#(togjs=eqJqqSbC6OK;ISaHlpGAS(N)Y<^84MuC66_l=q{PFR+GDB<q
z#b5UBFaF9ee6==M;B0V|TZ&1WQ^M4QLo<_@vLch#teA4if7gmz@y&f2J0?%pNnPU^
z-~RANoqYW~#Vyk^Jv-HWRwbNLI&v#GkWI9<Gur!0(cd!RC8gGPx22hd=!gDDTeWRv
z+HAL@S&6(MMyZmihFKmbC4(du-%vaGF{Y+ecuA?%E|>lGc5@a<^vpCmt*tC@R9oO@
zORjwA@#`+7;;A=pzZQrO6yJR}=HAOQH+gd9q(h5~!_C|3x0{)5+!&m_tGnS*X-!Q{
zqutRUCiVyR(?5RY70sNIW_DZeMA(CiVKd#5b2q(djGh{v8oPCSpw5=9+b){UFgp~S
zIXSkKfnkBu1%Yh=?_l5o10w^22V`{yNNjiix3yc>KHdIw#cjc<tNuC6|E_7KvhM!(
z#ToTCb0t<K2d>z-GHThe#erQ@S7n(>bxTGqTye$i=GqxovXmns?5L$%!>?E8S3j`(
zy<KMR{oab((X;P;sIW4$<ojs)?&;chcdrGVd%V2#^0HHVbyf#%zi>OdxcVMHyPLY=
zJ+-}ew(h;X>r~{Ol6O1i_)eAR_tv`NwRGCm)wT89W!ug7KKM|QR3!T-`|j!JySvwX
zvHE89%I@XCi-9MqFQ#pux2@kgXj)#oQ0AT;kAgdGj-2vY0!6-AlQm6Ov8~BEa%}~R
zB8QVe3z%?GQWWIqaB)%+6zFKo3%av(r+3M1DTxcm+Dy!D<Zh78ZQbczH0|xC#%;Xy
z8*;ZD5Y{xB9JL^~Im~ox!`0r1YuA{=Op~J{_&<w?PD(YM<*z(bz*#1B2LmIc`}2<-
z41x>{49l1T=lf?e*a?W8X<%U7#_r1ypcxRv^dN<S!R+CMS|uKts+F2tPJTB<0s|OA
zZz=mSFgq|L?vQ!*)rHZ4P1)BZ!_?-h*D90x18y@o{Z%zJcpRAgLzY}s$gox5T<H`P
zz;=Zp$kXMjmfQrhW%K*^uQCL%KAyhg@9ytg(|-RmNIYNo(fVEc?(3_KpXm9k%=mfm
z`GPwI_FMH1{=FlA_iFy`?wl*zzcVdhTHLqdo&M7B*Wz=#FQ&iz^+9}^zI$P<<AsKw
zq2Kha#TV6Iy|kP?yyn$=tKD%840hJJ8$R5>^ZxDMeJ@=Dw?vt3U3Beg=!p%&yc@UO
zT3aDGBda@i^&M@uwfnBQ96S7nTV?gzG^xPwFTo*~Rl}|3dhx}U2J}Dg&zTqMl$o;h
zsIF4lwB?6lHRU6hHQGu9`mgEZ)zr(`)TQpNvD$9Ke(sesSJ%(gTmEmpu4%@ltG?Zt
zIg!g2+4@xFw#4;(<_;EpnJC|JRjF>Xv4Pf~BgsE@$d{eg-Po(5dFe{XCR6!l=k=F%
zty#0~+eIUbtIMX|JX)x~UX45H)@-dq%cr(fPTzK0=eA<pEVX6oQx~n*4waiaCH#e(
zSM%4|X}OWJG6U_GuJT`<Q-4PDo2j5&{Isbj{zQd-^JTwP8-C1S-@5kThw`oyzvl>h
zytIj!aV%rsj$a>dtNCoTyBhCwvEfzPNyDjW>esK|pLMOq+SJf6YyOje({2Tur0LAs
z()!iN^=sIKADe!8@^a2vyS{YVx3gP&m(EoDCaGHM?Bu^>YpDN+X;augMX7(;$`$-8
zQuN2H?vM7K(>H!*j;LSx;KS30^Ch((OgyHwDbZO{>tq-A8OtO+LklC7^*!C^wF+zu
z)%AH+J<|A-G<C8_`wZhgtvQKCPae728H&#fc{ESL^Yme@9bPes$t*@mYi0)e8%;cz
z6k`}#=*F}zQH)#YFw2a^B7qZUMou}i+GtHT%gm-zGX!Udg&dS@GFrw|f3Rpxap$?h
znCGIqv!`pG4L0X2R@r!JPS7)@<5~skGAqv+>1!5F*(s)3cw(P=U-8^+A1797_qiUw
ztXV7gAu%G+$6#g9+D+GQ#80?-dD+!VGlX;7btAXk%H8cLp1<BbBd+rC;>DBpX!YCe
zS<f}E^0~XaXobq>pHC|$d_HewWwE;cQ1|)sddq{S*vwJ$QS(`?=HGI%bF%uClanXx
zo2LD$R;KxUU-;n%57zhhw;%kVE%W2?eCbb@jW+$Uc>M7B=5|Yq7mn5Qb+Tu3pUI8B
z*;`yAQuF&@Z0XlZm+#l#REoY!x%lMb%S<`exZlQ?x5j>b8_V*lq|&6uC-fs{&9h_6
zdS=zz%vgP@j>jPJYoE-Fl;_8<TmIa0=FXY7k9K=!^<BCZA0!t${mAo4a#lT8)dTtZ
z)Oy_~Yt&Au{8)A8^qQIJ6X$%_D_8D2_WHSD-@9bJrJJ_-oZ1$4a@G%(bIT?Ndp<d0
zGyP$z^Cf$aEAl~q<(KN87SrWF?b`jdDCxwEV}5b9`fBx_pJo<(=GplD@lGqtYT?Md
zk~wo__7%6QyL-v!?n}>J-?e8}l+mp#8CNR0`%Ppeiw?d%dHL9Mx762Gv;0H-m#^J+
zJFC=m)=ZNvMeVQnkG8fh4q1I@*Zk(!V*1CWW-K{9pX=e$h^)OnJ7@OPgwJ_tWm$PH
z#;-5XcJmfXT{Ug53-wR5zHdv*S@9%OZl|T*j(Mx5uhL&|TBmif)auaW5dW#+!Pl?p
z2yML*woEItom+K{WQ<b`=cE%!yIf-zg)g|Ot;?EmVry8Kq0%S!;46ZwXD-#e@=_>e
zV%1`e(}JlBrWssaZPImY#nniW!cxu^3kufU6uB%Cm8iH{uxD}<SJtJ8ysKGtCA9yr
z>^~B(6{a#>;5)NXx|W?t)@m`GYq~l!yni}oYpdN@xN&pX-CKEoUM(+6FmVV@3NL%Z
zs-|*s$`cj_2B}3%3=9m5lsX!e7#bQF%sU!x7pdP{e>;GI*MxD+X>V`0UMV9ZBNLM?
zTefVN#+j)9Ct&i#sDJNwP5&6kY$B`B1MNu)LUu<qDS?`Mf`S4rZt)S*3m>pZOpj$|
z5uN^8j*)A6+#6OlMzQIEO)OH=Yj&~lP3OPK%v+zk>PF~BX{Q{m8=)Ikr}Fdvk~lW4
z{`222RmS&TK1sK<TyUpYFK@~nai+w_zqV%vuDh7(;x^^#(e0UW?}Y8DkMqm1NzZJ0
zH8tSf_dOMl!@bw_%g7YU-o9QKUUa@VM%&!mwDjZ6IlI04-mI&*7Zs^^`gXER*2~fh
zb4u4eTK8z(tNMo3yVkwhy^3pB<<v|uuN|h>l><6MOHXv4m^$yc)cNGz(yOKEWz!y{
zJ&A0Mnz>Un&eg5Br_rxq@438rIeRW;>ScUc*6$YaCAHrzd~tf=ns=sikNPECdBz+X
zC9>n<c4=wGsT-E?n>812k-Qlc9Wpsg<!YyCl5fQ13XcyHR!v$}zhs|~jf&QiRVy_Y
zd1XwTrjk1AwUE()Y&G7L14cPwz702hx|`h!GR`r3PxRsQZ92I@T61DSRx#Uh1F2OP
zmhkyDmE<1W>gIajm5JD5hun}S5wdPgS2B24&FOyJ|J5R_S1N4fiYr+<sadndx)Z>2
z4I6S+=dZf@W3wZ-iNKor3(|~cSHFgC{~EgeafOfmtn%`*cMA=6`@MU2_nP7igLRj8
z?_T%Ly1YC+Z^HktA*&`{)l```afQLOAZsnvSdFYDy*jJdrZFuJ49^M+?26)*Y3_Cx
z*f7y=!JL2suA(cK#YB&sJZUj2$YK^}te%!#SC+fbgI=wS(=svB0;dZ-oK!#Kq{U+Q
zkkZnEhkcz{UNRngIKC)+TC#lNQ^Vxo=2>etuBck<ed**)t65FEW=#({88~^;{46Q$
zCwqjCsx2wmA-G~@6m!7kSjQJ@cJnOOyHs#&x=(@E!$~nZi&q)V3%q*u&|`OxEmP%`
z%7SdU<|(cEG|4|=Yq#garG?8fFV##r+FReJV>tE7tF1OMv0Dqai&S)TeJV97v{j!R
zs(td&Q=d6|bVGknHIdcV*OJiR^wCDsWEqpCv+GtPZP8V19hYN*Dz%@4Ydwsr2{^Rn
zN5HGp<gl>t)l(mbuJ(F3H>lv4RgqV+My$d5kc?l8@5RMh$7a3y8Iq!Tgnz^02dnHR
zEWfIuDW4i>|J*qvXDRdR7|YKKf2F8AJ|X#V&I@<lyJuHF-c@`3+HbF3?aM|trceCM
zELnf*(u>_%`?O|sH|?6|GskcF<dd(~Ypdy>2=njS>9HwE>!-=0-rm5)$x2&R2dvTd
z&2U_*t;g#3bj9@h9=9%<_#KVyd@=RJe8z}lXVtW>WEn5JxbpF18EtKkYkRitQ<R8|
zn=B$3XBpymZTZyI89$c!oD8>B+P5H{#Y!{utIPCDi|SYXanb(D#IpW|qQ|K&W<jBz
zB`z117<lz)EbVaZ2<;T@6c$>uDAU<X$|Z}lOKg#D$Xc%m#SRH!Rfz>h*<1{iMZ#Rx
zYV~p%vUaUp$krm^bgFe#NMcB;*4Ci4UTjO56_zRb3h}5&da(sHwyGSOl%gTY#r|hi
zAp2jDJ)Iu?O!W~<MN%RIB?GdwR3{`kUDRBnYS6Q4<x0<$0R}!xRtJQ!%<{UZm9gk#
z;EG6<s73QMruYl42-Fc?8S0ni6451k^8W;<vn<*sYzJbuu5f3q^i;j*%C~ph%_VLU
zJXhSL6nP}Kxa7DbfcgUr4A}{jR5*EOUTWB(eUzbSNzj9JQ|h@&x|$D0h`5V#MR|B0
zjNn@JDkL;&l4|@zt{x7Kzf*%&xj%Jf{I|_)GtXgzGe!y<LzXt3U0wUS?claala?%5
z>21ujV!DXM6nCX3FSTbzv^-kJ{a4lXslIyqBKem!7q{AWXZOr(WBf2L_^M~6_sNG3
z`eh#0FW<T)H#g$YiGAt^>py<<`m*q);1`}Nr!Fjhw02eTT$x=~AvGFrbHgrto-6Zs
zCI3}v@2&opSKUQqI%-7ImPN7r2;C^HZh7&XWvE>!-?byTx&D@imOJqY?Bz^bmNl_z
zWtz)P%X3OrQ}`VHRt6gcrD{lO1=YDf)S2k4%%avCur$h4m2Gjrs+o>mqAm5CM7<1z
z{&as>e=5Ffzh+&~pZQm{Ij2YlhGg-$hGtFuDK=66<WGC`Cx7O5el={1nv!xdF(Pm(
z%SJaL&86X=gEj|$IC8M)RcL(slRx(AU6Vg~^#&a2II(`${BxylS1r%=AM;5$H7~9*
zWPQtDv1wg1Cr(>+%$r-#B*;k3BW$VMwfZYRo_plx2G4o%E9IEahE#ujTTc1;%|F(8
z`h*3X2o71FerA5m6WgV?md|<d&nQ_f<kRO<TK@vp&$@MKMbh@u&t=}%e!jly`Ko8S
zGV5!ix2?-s-*vS(8GIP#v14lwKbD?7UvB%_*Wu=CV{TmQJsY>DfbGV!YEAK{UW?>6
z|M)k*{@8QN(?wTy=j^TLpDOqE%~c+i-8p+JKP@WHJ{=PDYx}m_xxSN1uKHF@xwmps
zx%sM9D?_7Jb%ln8uFA>`4P2GAY*p6MRUoizRa@k$t|$cAc6)nyxq0sYpoQ@s|1&24
zy)e1cf2-7rn`U9xP755n)txLgbyZ+S{WimuQA@?Zynp(4zyA68=<|tsdF^dq*WEa^
z=(GrQ#yIca?vu=Gua_6^6<#MMbo;KFwcd>rD>faqhfXNhd{^Py9((uPm+BSX1)EKF
zMOQCO)LmEh?Lv0m#i^lbGex<ymah7FFlyDR?!BM$K{L<O@~dxOWj|NXyEQaayyi#s
zy^Pw|_jY?9&Q&k;Sq8hzaK+5rwqPx_=)@_fKzAE13)Tb=`Y`G-u<YPyT>wT4eL$*M
zT~6m5V$s$8x-3{js-7nRbZCFZIYA-EmF3$WFtD)7&p)QX;KsnfG=nvL-w%!p3@i~0
z3_RJ7>l+xg&IL7SX!U3aE|_4h=6pY-pMll?R%R%}1qQ9U6RR3B7zAx!hK5LGTo!Eb
zd^KsQtpk6s0_RGX1)Z-d6<;zeS)>$Vt6;Y9OFe&IP4V12KYxAc+Lvp%HnTU|C)w!g
z+t1Fsq@6Qz`L?cQI&(rS&EbO22@%7sHvIErKYU;J<8}R>pEdhHL$=VB#}Ep(=oqvl
zS&D&o`{{<TpP`{^SN+J{cBy?=qw43}t(yGPZU*HBEkD&}bm~m%)ETF>B~EKg>{s&j
z@0_G|>8nmxwB}bI!7briO+s^BzpdrYZ)-e0@6Vs#&ptjrZgckXGV8UUx0FkNs-JsU
z`I-KVeOc9?J3mZv*|+@a#}D&VosXQdiPJpfc;%>Ue8{6orAFFI6WxWm3?sTu`pk4z
z3)z&atQKU{<8)ed$|0W(YnG{;7D_b;)9$p`v}TjfCZ8~oQ;9yy9H*Qr^*NQ4G}B*P
za>|h-Uk}y%{$Tl>d0xTJ_w06sZHY6}O3tL!SDg9nS?QT&Tl=H-`1w6kXD-+KeIxI3
z$=+xFTWV%ay6W=wet%t&cg)8l#$A=i#3y`>x~#fVM{9X{&9~NFNfK|CyH>36HCnc0
zgU4>!Pps!6HmrK8TCy>XXOp*30#{*a7?+=SwBoE)ky#GQR4#pAA@?zk`<@v8QK|ST
zCi@kR{#dQ`@yycox1;t)yDqvAr2q+i1_lP^KkvA6H*LGEyY2qAt=X|z*Y@xJKAG`>
zj<TafM@N&AlCprCl9ED4N5>IRLsdyh$xx6bNlA&Lqoe)ybVp_u<LUB0n7O9!c4d*C
zp6SNIQ(t)FoGfImVzR_B!)<0)%gtG%xweTynyHClS8jw})sKJu{-5PJndf}PozD%`
z?a%$3tM_^5rT5klN@iWr!*ek)PY*tM+<SW3?Tp8}&pv&k@3V9Z`@D+cIUs$S+m~C<
z)y$9k?p^hLSM>G0m(M*u_xRk$=jD0zcen2@j(R71$9hNgj_Skr<UV|FFW;VtP<rX!
z-t}d#-rbG8z4q>|CB1r;Z*4wbomctlyv^72dDWTEgXj8{&Uux^Hs|w=6)RS(SgGYT
zX~~KeYXV(G0)qlwLBKO8WU4BN;p*z@wm5Lbm07)Ri$g-fG(gJgK}29+#G*xuHoCgH
zCUtdn9ktWCwg1-rs$2JK8FV%<on64%#O#1&T=#d_`mI^t??~t0V6c6hyX|%YL-n!S
z+wN|=oxAM-!}lKM=IWj27??Pj5*Yk$=R!mo(r$0hQF#a2dCbWa|CZA$tX`{&ozpOi
zZB<y1so)moEW@&8zD%iwQAJu0c4&7@JtbV+m$G=q&QsrH3?k-i*_e97>FA}`-5X_B
z-i&R$q*}J%y7jJif_KWNZ~44k;2G<xIqjM2w60v<7&K##-j3aZH}))_vYyjMQ2Qv`
zy4cUf$7lN6+&@`;PxF0+!&BEIR&l`{^^dYwNt%4}T6FSN_0yYArarWpzUYhlmhKCk
zahKLtp4>n8*?Z~d9WjT64}97e_vg<0d6l2$z1Vwc-jh`Z+AVVzKCGT)RH`0)RJrq&
z*P=%$U-mA2qaP@@QhcRS_^Iv}D+T4>tQ3?C@>t_2aADP~z^>3pkCO&#rn&J%t<}|u
z6xyVkQooj&v*To9(pDXpH7;vZSL#e`Nr@5@)aIBvN!Mdj?^2zPgF+izW~rKZWvVKB
zYRVU?c>O=59>f%SF*J$eVwAIIW?+<*>!L%`!~|QXhKUKbcBC5dEbHu?8s*m-!tS)y
zDNJOS$eeB0R<Hff5ShR_+ksnvtpPkA1<q1U^$w63Db-UdmfTCG6bO~?&fRvy#q9v2
zpx_232NoB%gB{%x9UUD_3P&7WTwEL>-M@|wB_0=v4nu(?g(Hp~O|RDG#s*$!De`nZ
zWa%;CsV2L}g@%Gf%$g1bJ({60DxFaR+)q{AmaK63I#ty9QJc2G)TB)_I}B5eg#?eO
zrJAbNEvnma;cvl}zlGgjrW>%cDAqf^6{>c)AnLiuS76n}DAom;B8saT-z<I^AM$JY
zrCRqZKZ7}^q=qb8%#t-fBonft?CL8c!-%Dk5mD=B*J`)go%o;}%q>2<V!1}?w>77d
zqGtNU<vyCT@cI>FHMQllEBu(>_?7dC-MPcS9QEUN?$+qsuj^la{q_6a_r32!9qO6$
za?7`^TD58gL+;u2)iBn|yC86febv+JyB(xhZZK`z|28{x`?2*eGqz-@CjNGrzsa}B
z-Tl4W#m$KwiCc1|%_Q1-C#Us<tPQ%Du_fcuRxeX2EnV%9#eo}>E^YPFl@<eY0vBBl
z>UDMN_PVNd_3O8PvR}W{hjD=+`yO3x-dPVe+}h5}ySl*O)^@E`CswWc_&WD$kH{Jb
zGzF_j+?vNG9rhq`YhGyR#L(P5dvkY9+T1iJj?1RPaOxa^4J#uw!7wXIOxpBd;-))1
zW@`@|&bqT|wbH89$JcI;FgEe??cUDv<i?H@MLDtcXVlelSFKv&T2Wg1>N1mu!Xys0
z6SI|aIyb4Em}BO0Q@HKa3J~{jYG{b>M36uVh|;t~ux|>d_)bh#I_BEbEh%QClM-=a
z^G2}lP?wv+DSpygi&%UoTI8&P7zr25>D;8wJGDL#WM<o`)nAgDHu)^ue0JY61#Zoq
z+Zh-XH2(cFWMC3tU=TSV^X~)a#|8$5^9|Pzh8E9!c#%CwqJr)EK1Lg^RrCLS)LNC$
zYoOrxHdKq@LREvLebABx%nr=CK~otrBpH0YRxW(Wd_{^O$Sc&=hvDL4|5?jVPFr(k
zYm%|lW~2J6J(uRsI=W4Fd&&$c&&KVg+jO_9obqg3GDEtmY<mSb??4D{23E%eh7}MF
z0|V0mQPu{g1sfPbSex!?hi==N6Y6@^2iy!0?8!_6Hwo6H*=mUgO>p;W*2v^f3%KHX
za*An?f8i8USN8*{JetZY%tTE&PRVe|^X`kT%G!QCVr_5I2CxMQV3MJ(YHRG)Rneg@
zS6$m4x;FpbkB#6OY~$pO;-bO{N0KFu@gz$eQ)W|^IA#E<)h1u85;Ns-Gi;VPX4rAC
z<CtNO#4*DjHy$^`o&?a%%J~tXT-|$nJ9Lc4C3bfSggM=in?<DF#TAPbM1fmJ$L>Cm
zZV-mEwr$&aF67q2t<G6(S9w=SE93^;TKGgiKELYSt9M?yVx1p9oy?84kE?pUcIK|v
zX(6p1dAn}TUbijPX^GaMpE;9$&CQv1Kl<vTiy2#@RQAoTU$-so_1c+1qKdm-r{(Rs
zIhAX|YOWb2d&<3Zg&Z@sMCpokyG}Qc%{hBL+GvTEbLq7+cS|>Gi7JMPsy;qGy?1-@
z@rnMjo9Cw6R7$7!OMQ>NJ$cULIg{7)-7P(PJ?3ud@$BHOD{ozSn^m@LZPc^1#aUPP
z-g>sSIBe(Etb1?Ym2I`IkD9yI@7i*(vNO*u=bpTE#_w8E*=FIbGv=;2@-|I9+t50)
z6Kuj(YmnMq&t9*~+r?@0?o#UA6_YjArRf$MX3q{wy0!Ie)U%}P8k044Z<$%1Y4q-j
z=akr6t|0lWGtpr?XKX!lbX{&xs(9ICy|+ahU1nCVpXUEQvfkS5HjlI0#Vt9vHu9SF
zF1xtlh{-LpXx=v6?b~kMuV!e9U=faBk!EClz3uAj(Dk+rws-HaGRfY(d-ni@0u@>y
zwgtO8yPxtmCa2vi7C0|zJ0;b)lsDK)NOy{9lJfygvw*9KiVsxXPD!n1X;1W&*2r2N
z(6zT|TW@`6R;$;6q?OKHOiue&tq6@R;&8pI)MO|kxQaI*scnjB)|G`TokJIMtmatF
z#v>TUv6`8gN$Wt@1_>UP(1xzPwSm<Rf#Ex~FRHq%zO-nKLgF4y)$l1kU2BB9LQihH
zU3UM0!Zb#fYmB)Yx807;Etp!$eb8%%*PaiIJ;}+^3=+rc%?ueN7>*fk>}@;SJ6lF*
z9oGlVa8|F<pa((gSXLic!?L<zX#{6@s18%;0i`uep+6UOoeUAOI<cTHi+3qsmh-G7
zma8T_1ED1r8ik6jDsC<jT^tt{t}}6#T5vT|HI(o2^{QV?s~WUctq-5M?gQ5<hE=Qf
z>^XD2f;E&OG&HW>eQN35yVsi!@7{Ii94PN|Fta-Fh&nJZFt<W7Bm*Nu!V1Qw1#Dam
z5?T<Z&FACuD(~L=5*Rn}S?^+#B>AmEZyaL<>QZyoZd)yM)cvp5rP*qSvu+ylng#EQ
zyqjJ+dC4aK{PUOR-8=i-=Hv35d&TE@kCyxXV?K7dKB3}P4!^YT)KJIAnHy|!ZLfuX
zu*oqO0YlNdX6!vZ{9?12k6lg;4FIe3FP&Ojv0h61sOY1nJsYn+V{eo0g1~nmWthf&
zSD$EmTkKHvHr<x*X-i|Ta=yE<P2_!adB54M$`_y`Tfp9IZ@Znl?FM)SY-ni60<IYh
zTB#0N2@ES6n3gesc=eDw*>big<uxpv_-z5Gdw2hs0)qq743>xOcJe%#nTs?Sn0CHM
zRNl*3zPo{eUqo>M7vrXHcWvZqnRzZubuyThz!_3~RUvcY1g7AVUb7Zlkdor8w+))q
zVH3E;KbUi+N64+Vwgy&Jkt<(4Ql!{-#r0pSI_dfE`^xZiPY<&dH*QQVi_~PhDjoA>
zQ&8TdFH_pLw`A&=%wj*_&zSLe&Z;-@en($y{_^L8_|*8MA8+Ei-3zO%SB8cr=xgme
z`aJ1Nly&#TJMp6NYvRiEUFR=<JonL$H*xjduJ`4W7M*jju)6*3s_VAf*|jsc9kLj<
zU0d}*Bj->fPutb`x|_0d(-yyq{3faO>BKr=mw9F>J0gTRyK2sETV<iFX&K~MAsWvZ
z#<ZHN;e(*OgS={)-=!L@=@XwUs%l)Xe9B)WPBFYw=)>;57jswYP4s$F)bhl&tW#U`
z#HG#?^{ttiP8nad^rzN~rbe6nb8B`?IheuKu!7ek;o@Sq-fb+)*sdC!VM+}(OWU|u
zH`~~_RryWCj7Z<DtFp^{&E{E|&3So{Z;j{VjE%`|SH&i6TXAFC&76fZeNxVpEcFj{
zTkE#g%?fm+Qnc8m*`ZqlXX+e0q#2*ET4J?S#~P~*uj}W?6bo;aU|7|gbgS2u+c2_u
zQD<Chm|<v-*No7Fmh~G#BMd{6MZ-)v7M@`U=gqsfJ8IFbn+JC7{kx>or?XL*ZQ3+f
z6Glz7$ca)jwm2|2^0KvwNo+V1F=KPkr4zT725vh7UE#(e$l!eI+U>M$x9jh{=s4mc
z(afgA(Q!l%#NYr`Fg=2Tf)X7a6FPca96JmWKtde{L1(H8c61oB@qnu&$LaBJSR|)g
zHL>upNgOlmdcAJ?epeQi`aIBCOrS2_va7s}pbBZLbHeWb3@R#Tn5ImAx!dw||DM-N
z?iAmzuY4mHer1M>gM(k9m!ICms(E^%e7tY37RG61we)eD+|Kb`WpGfrIqKrIbCx1;
zft7x@UhP<u+_Uvkx$M?}(9qa$sq=Xc&lTt^Dd}t3bab9Rr6jxN!L|BwzT!Sp<5Ew{
zyKBIQ0<B)RZq>GXTcc~Pt^K?tNy<$zvnNSO0jX&YX_-$9@qb~xf1dUJ{Wk4wt5!%p
zQCzi(rR51n)G8INRqIqk7+D$(7$z_<fO=XG9n-I7t<9ZvZQG<LMyaWqIcG%LoK=H*
z>v{B+?9`Q6;j%-WwP4kfBF>|{?j12c>n1f`7FnZJqVBY-Yn9AYK2529K|Qtb(2%JY
z7B85~TIw|6U7%_AlAv83Yr>B#DvGjhm>RpK>1s$BmmQ-WV?2kK__?C|bDtOfIL|-l
zMRiZZoab%D3*Q+`de<xR=t!ZVx4^ec2h}dc%+9TU<g&|U>K&&&Q`B2lDn8(6Sl$r$
zfb#*@r%A2ii#WqSIci;1nYN-MVW|Yy8VzNxh65c3Iu1xMD^56+Xt1)?hc!W);ef#!
zZI*)uflWQE1|kO|w3!loxC}H7tl>J~!*U?7VKHL_*8w#~1Fi$w-@R6UnyOlVRQXA#
z;zzCo#RwhIdNr0A6FeIeg=S1uV_3#?KqDa_Vaj5L4XS}nA_+_etPKhYTx(o35?EI_
zwOvu*bz*q4$m`8CC)bu(h3SGUMfGdf&dya9*m4wejZ@p1+c{^qoq6aY&h;WxJZx+3
zs<)4F0^8J%N(73mNp?wUS}mw5s9G<m+R+KyG6bTfjb%hU5AEWb&Kj_K(hgSd1}3X8
z7L^Aa39hOqqgsRtn6|14P5<aJSwzeGhNt?zv(wJ54&)7SzVmEb*tL^gQ>Qf49u)k}
z@T1-357%6#{R~#x3vIZpSS>^k_%|$O+913juwf0u-lZ=x1E!l;vaRK+H(KH>uzX>a
z@CCVsDuyo%U*>yuh4zT7R#?WgT78)}H_MC}i`F||sA6AW%d~gV9<hZ|TQnr5v4v<Z
zaJXt~#1s0mXbB%XAJ?KUa*Z$e9jrL|7pz~juj{4Cx^}<0njT;MLnk?0+7fh0!#7ZH
z(H^cnS|3(#4O)2N<>f_8HMU8sPOYk6a6qC$G)^>5G*&?CMajzxt5$t;4ZB)Z6>h70
zCRb*=;g*W6dg(?x=cYU}6FUbcwyX<fp2D|6*42YwGwXKP&-?nvx9vGn`p9$Vz3emY
zl7hm^&fV7PSk<}dRm$OQx7Y33d9L2ev()`v<NP<dVYjowR`zx^2W|E3?b5j<v9?|;
zH=5_l5yP!%N5#TcN{gyp+UlK?6CyV2R@UwNk8gi`_PO%IUcuYj1>(-0P73Ua@ZMCG
z+a#R5r93*eoSTW`aU(0Lcxh@z$g6U0E&&G>!4(IOt2nZrJ)QkfcZ;W+;R3-!4%2lG
z-ZWg&ade|<*$qXr-R_s_r{=ubCOb_t=gqdVXui`TTO)7gyxAI2wrcIR)w$DF8b)*k
z3c9#BvWS3=dpOwG(k3LtqL8TA($dHwIc-{$Sj5t<sL0IJrPEqhrL9y{QWETP(|opK
z)l6(WNs!<)%}5Z{bTy-H#)37I>owP0+?LzW)V6Z10|N(_{r(;Yh6Yvx&iJ`i48N|l
znl>=7{k~=0pj`PR(1C$(g%N`Y?{>?(_d1#yc-&@XT*#caD%5QT$7RN4Up2jY91I!N
zSA}@+@|u_k2L*cZTrp_l@={XuHOf_M{wn`m?P{+7y?>VXig(XH|9a!Q_}6k9-=@w>
zH$J}c*^aW6pOt6%SDxBFyFEJfrPUwL3x4l}ciBbf{xzw3D`$E4bInJYpNAgvzPlsy
zJ$Fa(Ihpt3*%ufXpB`9!biUs1i%(Z4NNc-Y^PQsfY}Re<tQGQRw<BBSZfE3jKRMgm
z{$Tn^aTd+`23gi{msKwmOBgHoRVwtahQ6{5X@8^@8F%s}zst9YuR?9(v`=*(n7d+~
zm2k&;kFc0j;jYELqPp=@IzN7q(9!-BY<A-ebJnS>$ZfG%mp|+(j9hj0s92WRuB~_T
zTyLwb@-6qu+qU4w8KzZJ);#UtE}PzUZEeLO`A)Xfywjz}E$SbqrJXq!xi;-;G}nz_
z6TeokKVIo(_ayn2Iva*ZiLBG-;k(u6U3tv#TwzbaHRfpPlv_tvac51ssvX`GU^g|=
zEtJ{FDI(ygtM^AuWp*j4yUbDSQ310|xzrPwqJqzDo?y1@wpLVe*xS8jzppTG1&D=3
zPGOxoO(`g+w}Bz&21C8pvfHU4t7e5<N}V#vH*&QL3j>1~Xx{(#+vwbD+iw4U1*$l~
z^`?Xp1Q>v;&Lkxs$7Vs;fGKRo-^E1`G?oe)15#3a5AJD#iQRpW8ugtus5c4fXZ9qQ
zUQd=dHa&rvg#$FY%FU=V{of5{x%%7;(3yj`xD&$;t>^!9=JNahm2t-2I!(G)Q#xn4
zJiK{#_ZsiZAGfD&3*Kb9Ei!lR>`mWG`zD>3T)I2m?6&6fefLhEdtQ0&o8zU=*FCHz
zP2!7t^0oBU#*5nP<0gICbo%0!%gZe1Y${1<@)P3Z4)7CVo$~bE?YXH!N6n*(H(6eK
zQeT$R7<ryw=*z5gyWZW5O<HfgB=7E~o!b)?JlSq4cnCRe^K5BUak|puA>?v8D8@s`
zMb|@!Wg>S>^8`QF+_?*$2v3YoPqvzAIX$-Y>X~(^#ad+-9tlqryKb~|swHPmv2%x?
zOLWYsXCY5iH=gBFv=qz*3Aw8l%Lq>tzP#VOe%HN8_ogrR)Gyq);&Rw5Gqa|ttHSPG
z-M&|YRfE;HLE-PUwQoc7t53*f-o1OhjPc65cP~mdoz~rSTX-$kDi*7f$$uMM%2sK_
zvd!`lIHq#iEToxnC97#<9P_lkki`<A-YZL0uPpIn7ft=BRdjrcidE9nMDHdmb*Ei|
z0Z)~u^xD>U7G=Fq40i(6@>2u+MHQzmZwYS+i!T+PW~-?fH*M0Q1MUs;m@2qFdTOkH
zADnQb`kwFIXYZw-$tB(?_q}_zKYM5O_1$+`K8os1h!a@v5q_xU$4UWzhwugZ4)Ypq
znf7X}YOQ7H_}Ac)Dqysdn=7y}v}MI1$40LMs}i^la5L679655xpob+vnPCmnMm3c~
zi3UEx3>&yv6V?c`9GD@@ny`km(Lk8dK$~fUFr$HJ!}@1k>)(kg{}-xMYWg(MpjDf(
z$(ti$qBc`vh{Vz`R$)d1K?xRvpotASTuTi?CNs1qa5iX4Ftsh2;KQ(1$kD7*MM`Bt
z*+PwyHC)p~F9xaWv2q^$=%DGKmBYv$cI!$(_o9x68t$^Uvu<v1xX}^hVb-M7og3UR
z-9d&$uHG}K`JG^(`YV<hteSNijlbXIrfQv1{2aSlAxUw~zP!_E6V^3PT3A|oYG1x_
zYR-+Lp)IQ_*jxUwlyLlEj8%CtpQ(iPz&e%>!mJ5?jRx8b@u6QNJ-tOIY}zC?*~`%D
zs*}zV{{^)owOn?M{tE)Xu*wHNITbo1Xf4wQtu4PU9XL|2vs%^p#V>isFZ>JamT#P@
zE$OsY*I8-dstFmtQjN4<J<*!u+{dx_fi2?~uKpnY&;u)D0*^Ck{D@oZu;q%>mB!Ad
zRYx4Qdaa!J=*N@goWfUQLvJkbTk*O{Xg)*u(%LYsHHlg?gI4u0Y}#woGsS(?I?fOo
z=RUzuel8F7(oGq+qw9n79?!aI_Ve@3vc62-)tL?qY-VN`_iQarj*@#{J{vTUe?04w
z%KC(A)<;@#A&Tq=R`9>7kKg{fxMgM7ZTaVm;%46hvE;sZTcxk%2z2y*YQE}N+l};D
z8`2~j7}ydRXE3BmYCjH*y1q2`@79g0g3sjYZkshV%V2YI${9o6`kZY&rv?7m=l=Tp
z`|iE<A79))v$8b&^W8FrsP!4o&+g6Jeed%n+kz$gz8v2itMz*Sx>pI@p>Jh=ZeJU|
z_w7rQueY<KvrbLF7Z$VjS=y!DVxd#{=Uz`RFT26gd2hbzzV9pb*Ik*qWp;My`O4R&
z_fqD41K*ME;=<tK0_x<N-L41ERou?qz!bm~;Nl=Cz~aIv$l&6|be)0!&r#NtnZ9YW
zK87!l>bv`n@&Et-|3Ciy|A>L5tF=(G(fZu4OM7qB&X%lBU|?ztJjk*{)MZQ7zQdqt
zMDEQmKi@p$+sb^QK=x28V+gB8fQXQ|;i`pBF58Z*O;~V&;nd8=1yci9>lrdvI7B9B
zEI1@3!py{@z{Ri%bZ9+8SR12*$Py0_J3u3>r(w;F7`~#e4^j*a9Lpw7Tr9Xum?>da
z<}#KeCyp2;@tU=UdVtP;0QpHOKWNpIsu_%iJPZs>39}LyRK9u!ELaS36$A4X21Zk@
zo-3zT%>pT9kjkiMVDxk~@znzLDL@l$SN`mt{`s5A^mD(bU%c<hWc>QKxnA^&*^)V4
zCBn&ek9SX+%W~s{-qT&38>jolEcfdxKcBt5q<G)%c+17sVZXBWW<6`)tGbmhOXkA&
zh0ogiEu&YhfBSCR?gPKR-si7+-?#hx^6OVu&n~KC&fP0;Ly4om-ZscJcYBgFi{I|^
z8{e+D4RV&$e1;!ikC)ziz2`@Dmf7VO@^)<p1zakBh!#1&d-6JWH(2A#xBkrccD&nt
zw|su`t@#dbBwV*`si+YWKfLIYk?Du~@9Vc8e-!s_auH|M1?OkdLEfLelxMBUcDo>U
zYyHk_(Z!5W+kS*y%sEuQIO=x<Zw9X`Q>)wB^*c18W(4qP@aFI4&1`GA^=s{H$M6cF
z_d?dUbM$UUz57&fjK^S2!og;VWjrB=C6;mXB$@2Y@YuHX>ZYZ+rZ+jI);!&E_-nlX
z)a3TZZ!79V9v*JzJ6Ce;*0l@SVNvVOx2LD4Czh4gTxMQu+U<Mon0lwCfBm7586O`X
z-yX8GDt$Q=aPc4MUbjbUdFR7Y<&{M&yC;_GJv~trGc7VTG_YLt&d!jl;El%tEm}KY
z+Nv-4GKZ7jpJBc0i$%3dZ{EBbD;u+A)tfiZ`D9{yV(etBt?l+dnC2ee%%1Qwbk#fi
zR{8EDdsh9a=XqDTevdnM{gr)J%POtsy?!rv=&SzL*m-`>cl|z6u-E%-c>3g>@AiF^
z(GU6^dh^M<YLIFyiXU0TEj_jFyn6B7LK*#_r(j(>`ovcjt=@d{&i9yk=S}bJ_wm+0
z8nOA4&UA;bVe%7S)_Lz*C+GM4ZJ~_5Q2o>J^vyd#mg|L<R9epi+4nTueKIzoTh{tQ
z?^a(vdFQR{^v?3omrvf6^_@Pld)1du<<{=0k7BP@Ra(#WTYk1U_Sn+Ym)c?#t&{$S
z-h5=EAM`i$@J^_%hi_iWig%WVzI^ghR{Y7X`c+?k^)EfLul;FRc;=J2{8MknE}v9l
z>3-;?PEUN$iK9>c+GW4n@2sqUBuxK={#5(WvZAR^o_volJz-=YV5iHbE3UO`)tgV{
zw%6}D{Ez?zoBQOI@Af?@i(C3CHWVDP@7%dt5$q3vuIsz@cSmh0_FX#JORPSn&cpwK
z?__be>4)}3T~^XbdaUzXFrMXWjGtDw!Jm%xk2+s%?rc3Apl9&6WBnu5S3BmoM7F<b
zt&<Pt*3I0y&wJ~wM;Wo}wmWCcR6Drf$^o-wk-l@YcSJEQ&|(e}54-Ykv0JZn7|Sx&
z)dpvn(ym=rIh7STQzdQJU+1ZPYOA^ptY3(}^uAhX84%h2Li87Z=#eKYHuGQ5{xW^l
zqaw#N`K3XBJzwpZvq~)S*Hr!EckYKJJ@N@UdCceJ(I~ku)BBZKMC(^^t!(b_Nt7(s
zopw2E+R3g;&0V*SCTvP$%-R&~6_pp!usvkH`2B3pxOM6p-4{dlG8^p;7oOt!Fl4{u
z%(&H^r<DF`O@CpmeYMciC4OnpU$(@mb?QpuuR`_-ehB)NWYHFIa#HHsmATG|2SskL
zoo%ak^HKxzHkHo2DVb-t-45DTKPji<tmgM?Kchtjql10dW_?#;*ZA`5<8iJdNlUAZ
zWSli6UhAnER&RN(-FV$1rnuwbnY?e7-HC@bJr2&&UG+L^tKT*|)pJuAWITm!ql3d4
zRww67&51I*!IomU^7yr+HEkkNp^LP=J)$xUxAd+$8nIY2#8lO;*+4W#^GtMCNPS^s
zVP|mX)Ud*s(3p&V&ntJ=9lCZ^H|tHup{Om<xneA{Of5xqey#4=vF6=|>$A*bv)7(o
znJH|zaq9}s4Pq&^p%xh-|McUJuRLS8d;8o2Uj)6ova~k6DN0>-r+oHZ`Pb|jNqwHN
zvl`~GFflT4sGOYAIa4LgXx6k-6Q^(`E#0(4LpgQRlB~cD3=C=eo3}^hB>8MsGBwO-
zU}!eg){L6kl-R8-nYQHG(cbCasw}cx*FI<GhJ0HaYJYipkt$0i8>mrVE<1hx5oU3|
z!W$qSxOp$VdfoJosw~RW<3Jlm?_Xl!nO^V8B02qh5)04tl}DIW>u)D#<OV$M3o(NX
zt|f*YTH6X)NpU+jaNFv~|3OQH(&|@Fe|RU2Eq%`3JCgH?z898kGV-<2c(ZgKb6jcY
zT%+f@`?j6>V`nFQJN(ET^}?F+3cp9+%UdSz*n4-~_wDOu#afrKhD`mMW$`>jZKvtU
zbxFA#Y*#t1E4R(Ae^ArsyY2Rq>E59+ODy;}7M14}J-dBL`^>G5o$hO&`Q@cO*Lk<0
zc*f)1McU8r<!Afsd9(9YOnItu?7e(_n{U}l(WY_RqOYBl_O;4+cx+b5wK?0qyfiD3
zRgq=)u;P2DBIKAOn=^rvK}LMpt#2<coi<EuI?Z_U(z;zG)1nJx@5t8Qd7kDe5#(^I
z`1HKH_p0@6?tRa@d#~!GYLC~KNw3$<`X07>bFAw1SgWMftxvCSc{%Id+48i#%Y9@X
zY@QQ5-9jej(XBZ<PZd39?w%8^u34UYD)x4)R(P4&Q`NIYlb)@cs=ZsZq<eNr_te<b
zBGa;%t2c{QuUY4Ir+aphUTCTI#O?K7&+cls9_CBCdfd{_^1#D$y3?*a-krVf?Yebu
zw`=TN7g!wbHEBooly|qMyu0->=-ttnqo<3-&31)M=PjChyJ+t1SgqI_x2MEh*Vwsw
zsb`G2PRyN+#j)C|1v@vz?A#P{S9i)fdFlLVH?B(E)VgB-(rxuKY3`(bi5nfG!dCx&
zwd#MpuCq%L+rmYLOjk@Y40~Jz92gWPsDWy421f8cK$b=Y?>}0reyhAx`CWZ5b^6-9
zHX<(+7(6RMOfV~5b<)YIo4T79P15=j+RC7Gf<Y*XBZ^6Eg^~hC$AZ=cs$NWD4Xq0l
za~H5I=x6{5GAS{1G$<*aE1pwWfBf&HDLPG)EDkP>a*ev3b&}UOLF=E=iC6W4|E1PH
z^j_6zHCHyYWP0k2j!h9eLf^dkr?qa$i&HCmgJw<B>09m|8oTt4L#6*I`PHZX@N<Sf
zwORP+)1J_qT6&>{dg85d=VVrvB?JfFEDOE!=4m*WW^!oR^wfvpn-{cumc)vdT3gqz
zP<<MnSr#W+ZN2Et5wW!qHj__PIv;%^G%x(YZtqPWR^L3ZYDdxP&Vn7GCyz{tJ12Lw
zP)~ftcmFH%d4guGlUemBMo+YEeoN4sZ>zWL)(?C(XDJ_8@ZwpEDc)bc)!DB4Go5=&
z^{=HrE(EJT{u=&dzxb27%U?a@CtPTW$Xb1}{?oF+0~1#}hQ({YsF{4%#(h_3xH=!m
z@fpvicz&$YFa2WmU46=v_2)E;HZ=43$*g)5J3Zt1sjlgpPaeLtZqmatx!O*7b#=bb
z+FjnQA7y^Ks=oPD@NM;{`0fp#zlL61u*~lK<&VEsFWE1i`1{LB@0)M_)Pfv+_}n7*
zlP3?qtq&J^SSIsoQTP7z$uHl6oR@f2-EFCwo!|4zFDliid|G{ficoEQ_k&;ZDt}_z
zRh9RCDyp>%J+dRVT{S57x6S<ito^D#cDqOYRsC^LOeS7@;Rid<PxC@+M7;N>gIuV3
z=&fw_PLJm&KS8uDURxe2^y&BV%^$(G)n~l^q9@fg<L{N9R`#KF-XF{Qw*JzZ^q?yE
z0c*_UDF*vR4_u91%DiUFRq?|bdS6~uREIu_6VG@Z<Zklh7bsqKyGMCUpMKV6jxESr
z7q6d)=XLd2mwEEysdXT$YgVkRths#i@U3;19+vg(JLP_QR#8dO>Mc8B7q8zMsIOl?
ztJ<PE^r!yOTULL$7Y7E*=ijQEJHPp)UGT}ceOjE)AMdP<UGMmAI`@{^DZRyhezM@G
zdA%ekF5cu@EyT_%dcCeb`O{6F{3-<n%;Ht6yw~f`s<xX4N-G&pmXv?`xm^A7)EMv9
zTb7|huTRgaja|R+lmC=Y;RoaEwH2cFem%2K@A`qC>ZdBTA1#=-Z|~Eqmv4bxf6BdH
zFY_BT;C6;gkBhl{^9wj~x71Cv$XapS?*5kFcJo((qu|A==|WY(r~FrP%1n8x%>6N(
zIkcox{rSFt-?EqA6+6$p{3dL@iOsutQTytuouA&diw-xjyjyP<bK!Z(ucse#x1G+O
zU0m}sFH3oC`EvEkt3Ux3%Jo+3kLyqVRSGt|p;K#}ez|7NbNtjB`eM?muMuhq%c2}M
zSb4md^pbm#hxn{@zfbPooA+_=Lw~I`mZ3#!WGC!WjMRHjqtkamYxOgIt$wCTmAygg
zlNKM;nDpXlxMxY+;w|&*H%o<Uo#=iV&#tv&I(NsTmbvn)c6l%QDmzI%y)<^|&9c6$
zOkd^B$$^4h;l1HRvGA!6D%Gca*S_oIe@QU-mypu3NlF)1igk2d;dYzWtIIZVamb=e
zoKdcez1^m@we{*sP3i`TOU;Zl+LRjPBP6M4#C5QnC1PQQkFQ}*R{hq9E2~2`ZR|<T
zNtV(M09Tw>3=9myxUObx$vAOotEtH>9|_Z}(>j}O8|P|!UAb~8(;(q$ugPWKt!p<K
z877@fnd-Id?6k<#mbPu#X=i=aCbRKIZ91*9?aXauWig#;-l17*l6_4s=Vs^h^h9im
z)D2y=5uy83J;=1xI-5@CoP`?>;^t-}bo(I5ruxp-*>svyXVYokY&F#tTg4_^l2GGZ
zbr_)<Y!?a_)nbUFw}!1cW^&ortp3CasF%RDy1D5@>P%a8HR9N;%w?o-Cany)x#_gd
zrqenbCM>x!qgybgXX2`@VTKbYc8htdf>_IDWg>BAN=j@@*%Y<9J~UYhNgSa93k%{N
zI2o0>Y<6~Zijl;mBhx&MJVAC$oY<4OY*y~t+zFe+RCT;&`Ks|q7-U_Y7MZ#&?N&%;
z;L4RtE+rgImV)R^Njf^QehD}}L7vY!3ksT}-KvwWMy-~(>}zs6>bA1-&nw<P)`xCQ
zPWpXo=jM=$#o^l0u1U{!)~Qy$d--nL>a$x{>bi!Vy7A84Xp2!!vGR;)%?;ZuC(n2%
zd+u}Fd-1~K;i*PDW5PeaR#|FQdYx<Kk!9)JU1d{mye;w5GrBREYdVhs3xE9&hW%U<
z)gQVVF@_#V5;^gcf2vDn$VP*megV^#3q2CdXzhA3YgO3frUIocOEzrU>a<BmD9U4F
z3~#75yHH`kT2Z}lEz#Ajg|51xV#;DHYgHEoHu(m-iAqg&nk=$x@skT~^Hp{*Z4HT*
zRts1YrsAtIi)E|UmQEd2iAHzvoiTy+e0pB5WCPtgW-a!9Skq`&(|I%`!s%#{&yuz3
ztc9XFEt^(FEECk}*cijJWQ~k-lju~{&dG|W4ozL%X)#eJVAC4I*b`HCEIl-3gX*NE
zlTw5ZifOM_3X9P^sudx0a+*)d%9NQb8(b%e9Mb6)Im)$FBuc|Qc8>c^kKeWP1FtL(
z<g8z{G&SO>#Z+BCtwNTKAd5Sr{FEL|)!|G^R`upOwCIGGcH=~CcELigX-aXsW4)$Z
z#wsrrI?=6lO#7P4+9NSROB;23QdTBLghVnOElu${-5R6mtt#d<O<BZSRdvED(*UU{
zji0^K%XV%Fxmun*+il~P(6dE9{Ic#o%X?n5w7&4_&A65?Oq-T$@JP`(a>U0+b5+M`
z&cIfVtsF*%oShw!K5U*|hC$sfu3<}p5?s|hSrdhWwoI9^)G%mT+qB6pZCplzOHCDx
zR@ys?#;jOoXtXMP!_3L*TTX=DjEzm*T79rIGd4DLquPRJQ*XWFz9=FYzBD%UWq20z
z#m<yX8XM}@%vdv1B>CctFGZ8q`v!}4sdk-8jr0lA>3Eg2S4Zj9t1nwt#%3gKR5g`~
zl8WlpRk7pDNzS;qSlX>8SITfp#>LRUjoZ48CMV~L+_(`PoSc~JyK)of)ytPJiBwfp
zRh7OJ6kl>Oo*^kjW@^Qr)UAFxZ<b9h5f3*lc33ybS~1F_-kNDIL(SAmZO)d|Ov%VF
zo=uyM`fNTKVX;HG>ypui+~{zNwMUPpc3M38s=ey<>P1#-mDN`L?(N^7Tr*$Ur?G4$
zkJ70{JxWJJ6U7!Xb8HO^ZHZEla9tW;)H>C}sC8;U#>xe3T{A_sUQJ)|HAc9*XPe5Q
z9UJC6Ee?%Ucp0lbH7IbdlTOyESxenaJ!P#59;zlYM93QY$yy|d_6TfPy>8b_;XX^1
z)hGV%yUeAKCB>x>)z&NG*wF+(DwTl&dP0lN?VNKQpZ2WRo}OaNqFW!x_iEKsYqyzF
z89tM}-s)LwZjoHwr?Dd@^~pMmomx9rXFXoDPHcfqlh49TB}vwWUYocbLsP_-dTru%
zX>7=7xEgX&;cCc1#fGh-p$%KS{5_kNe3`LVZONO}tJiE>dGwZEXe{g1voWXUgkBU6
zO}%nVH7se-v94(m8zWvGnrpH|rao9|(weKRJsO*2qq_8TUB$y94VQYI<w;aJ=Cdiq
zZ`bQpdb?gPn)vj+Sx!jAQHeGsRo9-tjz~=<gKH)^Qih8RMI40!(O^W!B$Y)7DB0)v
zWbx6*x~sRW)p#lsx>Po{Y<2gn-BU$Ray{Xye<kYAP_3_;x-@mF&WTUqGBHz+t=P8q
znChX&`l^LTPlle24wrSX5!4O!X)skfsJK#0gEuHrlQ$?rAZyYg$0cDJyo!@1T#{6g
zTAAt;EAQWF8=e{)le*RKVrIBTY2l^Vsio!NhJK=lc7@6=TJiGok~yIoFZ<@M;8qEo
z>QH(;roQla#_rg4*Rx))+Z9l1HFIw1WR~{qt+!rS$6V@LXLNVULv`*cI-XOlc0COj
zH<`52wZyfI!=J+j!^OwBP2S4uPkzKd<HoP{+d}F^D^k`>)qH6+Z}LLLo9^L}xv>*2
z^#z^^_Ojab2JHR9aM2PktNO^PTxUIXX1u(-RGmfJU}c(*)s9`ef=<r#nwH=l%4zj_
z-72SDuh&hAJCOBGI%mqJHLSTI_f}t<Qdl@W@tjc7la-w&%&XUh7EId7w40^2%Qg1o
zC6g1Eow7Y&!GiKQx6xPaK6!?p(~jR1DJ|s<b$36!^w#RFXEk0u*6pk}Eb}@tYf@?H
z$>8o8Yr?%=idZe0mgSkIbF`=A<yDu5Dw{RMQqIhHd3brKn8viEMQ3JC*4y=ZE2C`b
z^^hscTO`BRsBY#DeYMN#^}1bCubg?kX2ve-*mYMdZ@rsRSh#vsU%_N?W}#H2($bSL
zOSPM{7iq6r#e8Ia(56e9PEAXxntHrmT(xkO?&`urXZCtM?w+)IWyq`W;FT|SuIdGw
zFx{!RWrjE--@2Vz7Ve^@;a&}Ima6;BRhSbbyjpMF3LP)?*utyM>vp}==y>&R-Ai|I
znMco5PM7VNau8%=NVr0HLU`7SSMDB{m3=waYA>nT7mi}z^7^24eb=)uJkQ=0c=Xu1
ztLKE09whnjt=p;HQLt|6mEBy6m;238S-i}u<fKUHb=lJEu`5H$cE_%>c)V_Tu<^Q0
zNv*fumhD=%?iI+p(~it6R<*n}JzQqWL)8LMN?EbqC2lDsX@Ax3)AM>95*_xqb!OGn
z<Kn7*Ew4(g=GAwJhnJRnS?qW&Zm1T$^~f^r)$6<-t<!q7uJh80xmLx?gIpe+UcI{W
zsG`;5zFn`^E!8S5op$w(c-Yjd*P?~8_%dVHy>fW7XeZNdro9ZW!XkstL{3jlU0T?f
zv-UW*(VKM^J6*4=yPm!EWo+!#yBd!k>vkGF^D5q|x6V?#wP4-UOZB@J_|3H{nAA7p
z<z=lY5HB{Ve|{LM%QY$dgOk$xv}<Rh)2>|$^z8C%h_j#cxOM)@)1OvtU%GDBpV_fx
zf!$K65^I+Ug{cY~Z45RRtMao6z213U@=@V2oyd9WGF5&SU*>#?juyM7kg_0o9rwKG
z=;(;nDc(k#*Rz*~+TEI8pQjZ!$9{VFr*nt5mX%c=Zuhh{ym|5B2iexz)o&{L#GmY4
z^{3i;UN&gdmYgADr152>kz#l5D?7mh&FkuwTVL6>PyMkczWCO!{U+1rYwYu=W&Khp
zHytwk`*)pk>!X-eZ@!h=LPnqa)r;>bx4w#5_2LsYA;jSD;!Pj*UhTD+d+y@Ris_|s
z^ZcG?yxHTuYrVgE@yaVd*Jb&g*z55$yx#pu9cU<<?|Jc-viM2wR$sn($x2`7)#}S9
zFInlIEDe46Ro=U^cGaJCr{3C3UifLZ_Lfh6?WzU4yp_eTY%;90_n-B9!XM8%Ps`AY
zcePL6`5s>+&Z&OWwtc~;{o>v4%DwtaeyfL;R9ek@{mwo0Rov36;8F8^PYQN`+4Ylm
zzT5YtUW$Lp8n1~<)24Q+v4v@iu5_HD>9bVxqyE+S*6Pp?>#xRp{SEyU{*e8usoddP
zw(VQ0`7^%BUHrAwwtY(tjQ7S?`({XO=tnL)QN<4{_&aMtKdiq{*CrylETc2!sLG|4
zhIQPcYD=}bbhN+zco26vF!=Druk|-WcFbS-s%6)-1+li4p}|wMe(1){>RIe5?o(A$
z6cl%Q=_=8Ov3eG>7VNRAs`x6f(`kLu)wh$6trJ~(Y*QBNn}^4@Et$3=e9_jBxPJHL
z3DaNJO~3S~)M(jMZH~hqyC3t3zS-##-@f?c%U3J)5B<>%Sl?Qu?|Q50M~$6L)e8NN
z(E1;`@jdfy?Fg%@zTM`h&Jf?;{`mL;@2^h#MBhAGv3K6RyP@KbR{1mE+9WZJbwVcB
zG28je4?q0!*WUl~rzQQ%?B@F~zx?vcuUb2iU$qvXn}<N$Z=PR%xcqRcVYGex@bJT5
z;uo@3MP1v}xavw*q(fGm*rE+xhobaM`Y&sW^VhFmx6=F4yeWV6w3c4lIOTxeJev~M
zD@&`z)=Tw-`z+_sm$T5=yK3o+^?bp-leJb}KHj%PPgVQI){2vl!@0f{dhANy7BbEM
z%C~3QUQ4GY-;6siyhwa=pO*NRzy4PqP1?`8`s3us;aq?0)E`xa1|RO*wIseX=v(;a
zOC?U<s!K0&f2{Y6Z@T(%^6hZ0ABDEdLW3`UyzZ!f<=afHi1q2gH(xk?`}UyqqoRNJ
z!?$(w#See2o4@+Y5B_AYDE19M9ez4LsqyO5lZp3V{qk$A-TLLHH1@4uE`IsduUe4M
zo9S0Sx_)T==vZT?-+oHfzsu{dSpQnhUj>h<eO4`h{q=zNk&kxu>OxB|ZM@uhko$Na
zN8FUDAENeT8OB-^8niw>&gAF)W=qSfzSk>$>TeJaFBc7YG-+>l`0_sI)@rL#qXhA7
zESp01ioW<#Dp-}|`fL8muNF(zAI$nwQzWDP;pInLj`%(c&N}r+shq$1um0Mp=e>jb
z>$jhbb(6v$Y^}4i<P-f-^0MCj$xq9$t3?Wy0%H4auiLgYf8SN_hw=RFf#Tb@3yQaf
zK5Fl@_hff?wQH`2_!T>5FX^16iIW-^P1s@`B>VDScgDVqeVNzhZwz{^9w~NWUrM}D
z>EyMFaV%{WAK$)x`}Nn~x_wx{9`=hr9!+j_{OVEvDtMvCtJSMsm5Ih?O;~@xUX=g%
z<Bz}O*gA4ItVvmPGBs<Wvr_o+$6vobe*OCO>yN*%fDc9|jaJBqEPly-!fHv-t`)DW
zriX_L>K~97{dlB_|I&W#*>#rtt+&g5`@7$|Cim0U9Sjn8EYD9fH@Az|ub;qBv+DJ;
zSJy+MbNA+Q{Z`oBc!%$0sC%TwdZC98A74$|tdo=FGWo4noa)1ek1uuX6Tgxaa>^iU
z(MG3lbHXYf^@+ZD`S!<$$Tc@^T<WZys(m9hsAy-*&Z5{=lfMK_*}rJ=g?;6d4TP3X
zJ9ayIVt%yl-8GwT>wBz)i_}AebY6<CJ>azMI>XX!r*)^DI+BswcI&pz?&yrw=CRwZ
z-QLy|Bf`Mc$nD^C(~;Z3>FT!Ax<VWbOpsNn6Yt)=9$UX{b?(}l(4Vii1)D~+f0@Mo
zCE(`PzoKr=Gu^IDJm~cQ{lEQR|DXH+`A2>HkD7n7|K#f@#CPUIHP`2?4Gzr7cHA=I
z)Xiw;tW2J0?bKZ9FvV%7ZuML^VsJBBIXUTw$<1hGQ;D_}+sqb=PF)qT&1}KSj?_)t
z7Uwn#oX*;&ayxrcW|8-~xa#~1Ur#Jys`7I*w2o;~4%~7(xrXs@a@;JJ3Cen>r|n>1
z5WKB@eX6|7)y%+?(ULi_88=SXr!IGmE)w)$S%<1AQprPbdg|#I1_q9|Q(vFz@5|b<
z;>p^cZF*aBQa4>*u65s3IjPg-adKX`!jj3&bJdR@-g|xT`|!%j;tA{CHFxDW^yT+4
znwd^gX_PFB*?NG1CDvP1Vcy<r7Z@14Td(F#TB_1%XZb02d3}`c(t!EV5$aK|UN2CO
zX=2<s>FBlIo^4TOyYBGL&fQ>^yKUR;#*NHrw{wuWsoS;}PtKIyd2(8y%Ux!51!+%b
zPqRsFlTxPynme34!E)<Pi|*E)9MRdi+n%(vY`gYEF?a0=r`yrF+f`Ilw{2JC&dqZY
zyLCHvXT72#L}8J@wrjU@PjYhRu03#b+im8w+u6B0qy@|r4oa3zXGyyjBRD&<z%6H{
zMyA@OfJ;7`y0lt!7Io<^$$PGL$-H>7&Z5p;Y<><PH{`1Fs+`tXw8H6>#-dwp?}~Dj
z%PoygY0O@b@`O1PU3>k)C9^%9J&jIjtP<GNrLk>N+azTD|9imO$|Damzj3sCe+{y&
z{GS4YA81>-!129b7?@TuFmN$6fo7l>7+CU`yj{9DOn@OHjDg`4a{*|MA^=2yG4lk5
zMg|Th1_lORh6xK87&;gxu%tWi&T9Qo#bAA;VejVof(lIy41yv5Q*A>-m>n26mcI#E
zwb*g-C8G>xxs^c<CXCBK`_a1=NHM!FTc9NBRUK;oH)yef34^9q%EYCCW{aIOB~SGq
z|F~pY{QBGM%de_z`t`Mue<hoa%JjRAEDqxGwS{-fcfGgU_h<FK=J)HY*L{zDe*OA^
z=^n8x3eyvs7&+@fCy}FFg9YV+y}-c0z;XG-!vzetS<{+AH->8UW!wyPFO<&RcJ+${
zcXn=kp>x!wGa-9Bdp2#BOik3$+2$3QGiB3F&D2dnAdxhqQ<n^<g{A&*Ol)SGa^Qn2
z%R|+Yt}pIK`MCN7V+4=J@-48M8(aGC1%L3>e{wq-9@WIu6fz$9TKIpufQ)~*{4X%)
z-#Z11dF$+UG(4)>@#_(D=c~uBJNVRB_pbvB?{%n{r+@wRBj!gnar<^OJgU>PmvJbx
zjj6MkZsW|NR1a3Vrs3q*y8ZD2^1@$hKsNk|sRbJiG4AUTcHyhXuY;|O0qL!1_-M6>
zSzXK_<wwJh`Qq#2CRjDRs);TAdWAjs5!m*lAHkfJVCt6^=Nsl5>`$0M@E7A>hJOw9
z4)zn|m+F5xTff=hR&%6gV_1S@gU7L+t!p-R?w=s1U_U|r1pgEEPs~3V|1|t_s8_J(
z*uOc|SeiL^<+iIj3D+ir#6QC1V2U42{yA~OZ0)SDEVIc!8Go%RT)HVbbfa5RuKF9t
z-wb~n>JHc^$UhYRJ2~a1neXHjU9oP5>4uY-MD-aM>dv3vo;V|OfpppihHIDDCP*?i
zr5si|t+UC~Q(JeN62k@;*7*CmtFud^Zr$HLeZC9JNj?MnXNKSfnjpewx<C?({&at4
z7Rl+L{qEBnTv=?VgQsuvcd_t-wn<1#4{&2qWh|WjSCvH^F}+)FUU*D9s|&P&Pp)!1
z_%vX%6_BajERZ1R`W`5^VPb&pq*W|kjY^WPHlN@B{eRlq6})**SFBTg+HFsjp5&Zu
zdN((7Fu45NTh$jFE3<4Zca+$Rr=}NAWiOs`-96g!*4NE**GF3hi7G;oZ2fwW==7=j
zouNkScyr&^<WHOR`F#4Rk~h!u4lsV*obol^OY{BRK<|tdov-g-%v~$i4Y5>Za&B|N
z?^~9>B}KEg=w?KNEYMsBwsjX&Fq3P-N-%m`b@SZyC3|nLIdQ#w_O)4`&!<e-zI(fz
z=Z;H{>oZ*@c(Ondc#k32ODa=Lj$H^Wn+|gAtxsqcfc<dm>*lEtUns$>XI||%Epslz
z*5?~HpIdJ2SNSI7^ZBIZ^QtzVw~c&0Z_VfPxi+tgSDssLH3vjp220dOu2q@Al<jZx
zCFk?zxx4p#`(F9XD&wJPc6M~hxm{_Qizl|WO|z7U$V{Gi-CbFSQ&y+Q=(x8`&&Er~
zmDlyTMF<&%Zg=M?S)JD>@iOezwv&t7uJy=jonGB$6*@hfr(|_*bjroU*>1eEEG5LF
zWqP>R_PNK(^muccY&>!7tWJ?({bp|&oy$Hv(jbuoyKX#5h|MXodhsMF!gFb#8|$^>
z%1p1pRtp{S)hXDp;nHzsZtitpLpG>z%IXwsI_@o_v+>e#Zk>{ihi-?(#u#2&vuj84
z(&(()YJJjC24JVX*z&e2wpv$gcG+IdpqJIU=hjKQ1S?&ewKaFLJMUTvE26x?H#PO@
zVX*hCkqnEQ9(TGJ$+P@R`3u;*HiVtJYPLB3>(=6!TRX+pWfe>ps9+JT&w3iM%GBL-
zdjVueJm{Xy87z>)LRlL1uAa+XSG0Pn>xr$qTc8&hdkC={fDRX`aMo#E+b`PKz_g%Y
zDuhf(U|6AWz#)Wz%>c{c34gP$?T^~JzK((6cJ}ffE(QkAdWH#H(4~i4FE%<bSg(5b
z?%mzHcW>`t;b369oxAPUS*3&k1||=dgo_PKY+D!bN*FBQP-x;%XmI46#G$z9Ad7$_
z3(o~d5G4R6nK*JLK;#@*%sdp@PO`9W3fMO7(oK!}1x;PejG=<!0#XY9r<~yb^k2XJ
zN6Z45!lPH-ip)&;%6R=}(S$<A<Fc_`lUM#~c>Q=Q^U5piv1MKUaqEMBGQPgS9v-}c
zZ*R4$T6%c!PsUTs-JM6+V<%01yn5wV##_wm)-4Z^T{L-p-@4^j*f;RU?TuT$f<I%)
zYq0bi=IiUjSH5DtrD^r!)vH>EYKE_`ufD3PZ}`^bx6f+V`~bNHwpCxN<}I)dS@o;o
zs@63B75obF^6R@Fl{CCww{E$s*W-^zkNj~+VUH~>v}!mNRQMXit!Q|?UOadOzsQou
z*TaKfF<)U{AGbdE3j3;{(m65yEBF+w&aGP>AS0^2PEY*`yN7IPsa3<PDRZkpPN-`5
z`nvw=tEz^tUT97Tf_h>F)Dt04PrQP9;>x0Z%dfCc4O%bW`IYfR^T)40_6sjzk1Z{=
z(h8Sfr>FjkS;6Y{>dq@{L6iIAK-?qju@$@KI#euGm)o^#{tEs8xxH0;{R8Ay)_Yzn
zEVNr-(eT=8*Ib8!ka;_H%ny)ND7|{+74xc~($}Dnh1q%)8gw9c6Y1<<Aa`m6eXN+j
zh(S^`_`~-g&nH{vzP{$EzB1F+(d*fydb8Jk>y|t4AN?`EgD*5_e@u-374|G)a8$PF
z?JX^}50E<mjTl@}`}Y&$$B!Rt{5$wFmi%+5`dhWvKS8$i>XomIZ$;*B6j`zVk*k)D
zQd6pfXBRhDkJ3ibCWD@UQ<97mB#lz1r}?tfO;7M;DXyO&$v9apGKI|{<>a(TkR+5j
zb0*^iNf0(lotBoC=8(eXGc$GOOo(!j5Lg5(>5#(yr2ZUlbJDGCSz3o?J7=w3xW%mP
z!YyfqThgjIyp0>Sg&k9kI5{iOWB#jv`c)JDhblf*c*xwrr(plGo~4dKXnt2y)>PGx
zj0+?gABA@;T_xW6gju~aPHEbTIDG}lim8t@vsxEOYJ>PT4e1aG7$b^t(k8exlruq6
zTWFeKVqjBB%Z0G1j<1*%jF^w|b9#&V3m;+g7qL;*3AKq+F#70xD5(Buu!2z=NT8zO
zJVXY@Fk;q73W7<aa12E|lGa3qNGV+k`N}v!lJTK?%hD;!J0CHtx5^1k3!0}dAXyRk
zP%~9?g2ZAF-^L*wA^~H}Wb878NY@KZ3qtUOrUe*rT@2<7f7W*4R&>~zNn0m2WHBG=
z=k(U}QP$dMn3USG+F?uA#xOM<pG`9-gmukQIB2Aq5$s^#(-kFhfk#+rTB`{&%Za56
z{f|0$eq{XUQ4=ID($0BhVwl&f@St5&Pp}7V5;^H{^wP_cJr1SXf<E;VtTytChle>7
zY76=(**GNJjt<UQG}UYssBwGj*e#P#u?7aSwd?zKy;{9)*XzEC@-3@{y0182KEmc=
z8zeKq#-T{z5%WUzN6eQd9A#gs*t}G6>RS&(kAzVCI74g35~GG)0rjOGr5+W|jTTdn
ztXB;@5_EK-FH_QmaPHQJ6%9u_ma!h~K6><F3Y(6r!RqVl<JP{uzCP^syY2sY7(`iE
zuCXz2H8DjUIKUX-*u=1cfhPgBqf?1V$pCuxw6yVo&{v8tAEkhuY^hMl_=tG|zsp=r
z{tkXGXAw5JDQ%%I7ECt_V3DsE3^}UUu_|f8$sntal8=lN`Bw62?eTiZr<(LgGj*ZQ
zWO4384>JWHYNk%~ncVFXrz=>Pbb@E2$f=mZ<Ki-fN8{}n7$jW+1qG!#j<_M1E&@y}
z3=Ae4MO<9m7Aa|T9C2G@$l}(e1Ufs(P#{oHP#_7iF{oaNqgjv*cG!#Jyh(DqHY&b8
za-_|nsNoTF2cL^vr&W+F#NjIau56k-uE8R0N-MjZVGchMYUq)qH3Nh@lC)-ka6pRJ
zu8xwAMv9;qvsm>gyfY@WXr()M>!FXXGLeNvD~!5~v<i>Q*;G8JU)<%~<$Uz0Vi%u-
zMZ+WJiR_E~rnGxGFI9Z$QKezX*vY)4Jx<4?^ih(tf<@?&b*hEV9ZP44oa}Br^w36C
z=fpBUeQ|NoPH!X4rOtg8k64e(6xwkbDz9?3T4J@t#>J8W<Ov5`kRSM_w6nCkfa8AG
z5<^FjS=wFoGOjuomPzc0(bIgWndWNn=wo4lp=O$^QQ>i!B{GG_g;u_pyvq4_NL#5#
zit_|M1&f9!%oi_Bc<E8%QP5F(RdH^RY>=FijMt-Zp&e6CEtSy|=RPV@n0oZ+6pdt&
zV}?B)8i_7E8jU_d5)+<)N*_yx7cV_ZmRPx1xL7Q)dNrZ`+)AE~Lha5NuSelpQwny(
z=!*m%oh~jG=q^+7xX<EAm&Fn&Y~31C$asWZK~^0UI+qj=Iv!O#s(3x5O~s(QB}VC?
zxK@{h3?Ew;mqfzD!>p`4Ni&WaPGyY=k^#X<G7cckE)P8lmRM+5I23w-V5vu8GQ?`Z
zz(WrU_5>=n@yQqj1RT@sNtP4{_}k)=>JilcP(=9djN3WKE{Znw=j&!@YfZmzwj!1P
z+viLk=M{X*A3gqK>rgdseSeHYp`D(c1*kjtpAXarv_A~)<b9a#=*%K3d4;|6(cij#
z3U=y8UxPY|j~;&n_wOE0b7qm5?&HkDQ-6YIe)#LJ9~nQ|haW#KAme`&+W7<bDDA;r
zKuG@((lhMf7hbJkRG7l%-@)JcvFhtf<`sO)k6w?Dbttvd1NBR5;>AH6tN9?R-h)4b
z*U_ujgJ%V&(IoYi@tyHP`&8@Uu&$;4*VIWnTpx<J#0geFs2UbN!3x(!`W$<dK6D>~
zP;WvXiXRL=5Pnenp!7%WkJ>-xpKJ-!5y=Yps~M*M^y}9f!5es{E)8D2ZYNg}<CV2s
z6_KUaCoKQMd}S?HRZQI8GLcV=ufkew^~3w4L@w|x%?Mt4^|}UFzMiWpZhhQtu6hSM
z)r{bWHSzMYt@aD#g|=vZ*r(s$cWC|z{?2&rBf*b;{CK4KN6Xf~bz(;*x0rtGpZL}v
z@kjrF(1!3!N5AZlV{d#=A;;eML5{s~!3P_D<^v$&jU4-d8ZfHo{;_Y(s>sx!OU++a
z*>@|=(_g<%X>Pqk%9>SkV@r<&cknH(h~t`D`bhIn!&mJ~A4ML0eciFVgFk4mzMy|t
z)rn;erP@m$X<ohFviuYCmG$07g0H^5F6jS+{mA;(N17jNY6?aEIn;Rlh*O#`e*8F8
z;$xx6j~^dJ{wdb>Z~SJ@e(*yb|G^*j><1q<91L$<)fKq7-n|_HjtEp#WPE^t-*WQo
z2S3!vvmgB_P$%ks>DL}tyM23Htr|{7?AoMxJx*zkL#g(m4<WDD3;GAhEv<@)akZ`b
zDDsi<Rru0Z4>eya&1Af?ZhE+&-$u=^V6jJ<udjD3zXEb9)J4A<eoXzaPfw|SzPy~$
z`~Z2Oed0%t1V4U!B=~Ch(pSH_<{y8okrr^N`KI9O{F>WmpW9oOi;8Bm*%|KK`SIiS
zW4Cmp;}e`je#xCr-~8~yj~a`|eaOhJT|hzmz=x-zh63E6k?8&L$JaO;@+zeA^I80;
zv7OJ~e)!>WnZn~Th4o;n77VJ+q^w{1wQg6?{Povge?7teD*R>L`s=T+X#QpZIaa^F
zKVbPA=11X&e(bZeb(+6{zcWhYN4)s)<B9$cIFvfSyT7;Z-*!7YcRQrZks1oBTNy+{
z>x1W>S$Dg5{&nlx`xa9J7{L2Vppx~WHN`up-p(t2^Y(uEIn@vbQLwB7NGoe-JU3(S
zwj*m+Fn|wxYhF8f+r5a>dn(Rum$qkG!0>i=W$}~cMnS7itvUq)t4^&vGi&GK@L~r6
zRv3fP-z4i<uh+I)+ivAX`>xJBbvyNT=Cj_Iiz~x!hu!u!sfWqNob*ds8ag#JbSfB3
zp89CVI_(_`bT?nmG%a>p_pCvIdnR5Xgd~`?-sbb}Jo^_e?x$?e7tKqb=`WSNH1-f=
z+#1vwOc3x8Vrf*U_Yh*)Z=H4N|Cg>@kHwjRx2#(?Y+F0!h^aJpVs5l%$JFJ|SKYn4
zy1X>z>Z!Z1%~znn0pqf@cW-Sk&$@ee+p~4$U=bvO@z&0;TheT&Hu6eyXPJeaOi*x9
zU0`;VTj+@HqOA;z8N%+aSS?z=IAYtWs~I<<JvZj87Pz=!TW}VH7Q47<jo<sX|MpA#
zsbf3J+a)bxrjZkHW8p^Uq_(5ceYuO9>*g1%uvk~cE_&W;)q+PmU&w^pGIu>+P#E)t
zPkUbD(c(+1zyPd9<jQWlx}e|5B7bYkgYK6dgBw*3Gdgs~vs)JC`yK`qR^>DISLJK1
zYDPBf0?a0`nF}86e9zopeQ(d3&)@g#yK&S$KK9D?J5L{VJ!-oXc=f1wOyJd{ygL@G
zi@17bWgCjidAp=V^B(Wq_I6u?1;f4Ht@VyaU+&?veYt1VDu}D07CAsXqy@GP;*`+K
z+xHco=X~oPFz@o+Q`_D>v|aH^_*UQ6$+!B}bG~(VY2PYaC48%TCpZCz-|FPM_py49
zdVY9$?0wsNzxPI1do_N3AT3cnkNNolg+gC1KFyVmN9#>BES4>07rC<F(X1&l!9mSk
zc{<^?Iegmlwy}%Y_PwjR8J<uW^L2y8x~dy80pF~5zD|vu>Ub1GS5`owk1*%k!aE9&
zQH{$AfLR67vsc4n83;pd{Ia0_(X1~EAb7Iq`Do^@=W82}@+a?}w=MLB3?YX!9xc9h
z;L*<435Cu#-aTJCwTzt<Bee2!R&THWZ|E4Q79830`TtASNYCg71_6=!`X3F991ILx
z3BEHAUSRm;^<yOi!$KY>g^q>=;PlNn`&<Kq69eN6W({RN1_lNp2Bx!1MLEHRMotNM
zlwCcQ!GL?610RFg3Wo^+CA<s_8VU>|;4?p^SfARmy<@t;)VPDeq@IC+flqU>gA@Zp
z=bNro&T5T~jKV=(3r=oj_{z&NZ>6Tlyk)bPSy-;DT0VcJzt<|YnGy_|8k5wwhBz*p
z(fmR_{7diJnz}tQUvjg5Oy#RG+j?R7`iWcD+dcrX-*nVS6g`%R)?MXo=9zZV<fiIu
zmCY&BaweVK_dE2<wT)Y2wk6%UwtZO&x3NOdTF;qGXHH0^Ie|}(-E71<bAtBW&~lbI
z6+Yp%%ny6-M5;`E<nYiU{g8FwHc&8_+A%+e4CEi*wm8@B;MdoEulHWB{PO!}xY^|g
zc2$pey)V62yN6-AsS}GrJud^>4HE|GgbS<z84P9z7ckt0o;$n!_Ur4i*Q?ikZfh{z
zb9HOj)#7ZaiyZw%(ZX4x`e%Z(maN~#9K{^ykhSe<Z7X*$7h~J)u!gIvYoA@p&JoJp
zG+Sx@q&48P=rodb)*OqB?3s4bTX)j5XjPqUUJ+}PCHA*!wn;?PuaU^o4UJm-Ykj+%
z{C~N?n8M>Sm0#CxUAxpYYsY_?!sEgH+kgAIUzRU3yueT&VEp*;<BwNGAKO%Xe0;oL
z&f;;ui2kPE`kQ|1HR?_GUV7;zNW5>wl8^HsDr5?ecRs3^r`~x)>7R&Itj0d=KD+t;
z3&3;q55e`^M|suC+SM=XuZn!wKk5IU{p)}2Jh5E-$&USTAbMqC-QMDfe)>U={#HF#
zniIG5=&!HmTrKu`cYl37r>n4Py7=qsmLiY7>giu!SEPCLRZRT)m?y#AS3ug&XHD*&
z^kvUZk$?I^kN(y{jQREl)tGw1=A2kAj^d2#x0d{hpY-V8{)ztFpW?))Tb@`h{wXGY
z{rMHkFMZWt`s?dgkzesAYxS=m34T~H{m{1`T{U{aTmF^>md#grYpJo*U*%G;_>oPT
z-PgYc)z^!IjA-<a4FP%X=&!F=J&(SM_x}3&ZBVU#5ZGU<{Pe*7f3@U)4{Ow?@IP+F
zrba8$?1S7FJ}tELlI(xv@sEA#k*6AI_KQ6JHA2LK+`sT^cb*D3Q>9Y7>T}xcwApDX
z3R_qmLfDoVWL#YAwv{QEIn>|`Q+;agOts*kGbdHAe^uA+JT>7=sY;c<cIQ#W8Q<_Q
z7TNdjT+4oPmZ_|j*<7nU2HA*{E@u}V?UmXR<yC5)9T=f=KsRLCrD?MpqF3haRZHG_
z<k5srDiuD*ryhAU;hRbooKX*FK^cqev-Vuwnj7uA?RKW`f?UnC=8JdCBBi5Eu5I0W
zqVd|-zuKPBPnX7)hhEoMo@K^h$`Exi((Foh!m3SCr*i*z^*=P0^;3J`+mgd<S}(Hr
zhtKJabIu;~i@7Kr8ZBZR{z2n^i~o1u$=PmKqIAW27cflUB+V$|$;jcPYUFW>Q3bS}
zE@!a=gXH?3x0gZBu=3sNnYCoY($+Q|W1%f;W<^D+Ok6eX*lj@u7e+<~21XVKf&XGx
z*QQ-voB#OFblXIh`HYOywOv_Mn5Mr4@2mq&!>EELWF(m0Sx<NT!K?$?NGCD<w<-%S
zXtKr@baYiuvfFeSHx`rnU9Y!Yl~|3~P#26~YTbgKvbaP##4Ln&Ds!sC6On)W&+odj
zRo6QRLfCEtHOX?Gu%%m8?^qf1r}Vz`<~dtG&o#3Yk@@rUSq1aD^P1Pwr@U;Mp}qN3
z>CLBBZ$8Z}tMr?p*)(GrSHd!``jllh+m5a6Td>UHn1KY3m6<lDnOU~V?A&bv*5|Ua
z54XHsx$yzhzQ?H{&i8AgrY&8W1tF%IZ7?g_w(R8lGCWqy1Y41^%(y$}#N*`j<n#o+
zS+gFuyj{8ZZbWI0DPw@BZoNYYt3wFFKU;O3T0Mi-hO&l+T$zi{Y>4wymKk=f*}A(Z
z_`L0&)jP3F!EE`w^4xN3%PZisluey?uio`inRAl2#H7``&*zuVTV6k}>iX`v%hp71
zw=H|V?mXvJpDWkXTddxEXpf!8zV1B3*PBoHcH1;wPoMI7^P#ECm(>GojY@SLWQ~2;
zK`iFW>Oof+FPoeQPoH4*<`aADyx?``wMt={8t?8dkmg1+@FCxB8^!DCjjuN!uq~^v
zWL|fk0~|3Q7_Y+&ad^G?KuEvOT#qj&uWaQgIcp#bV)gsX^$uwFxy*Qlaw$26`WxJd
zIXU%Vip^QGLvGyEadx|EwmKsxOmT76#gI_ZO<UvlhTZ<Yim}10$7ux{!!1KD5XsCa
z)&n}qjDbN?WvR*}$iV`jT9AQ(agtY%r=}-JcnXYJw>3L{ZPfMs2@K49H*Btk`i6!E
ziG~J*ff8-*wsYrh)a!<VHn?-f-o1M__CO;81B1k|GTseht5#*LTGg;MG-7LLXo_yA
zYtyP#TpC@<N!zrvbXO-`+q!n66qs1F=oUz5OA=U8sbi6uHkjGm_s)99y9aY#o-=xR
zd9LNLSgYdY7N?i{l{}X$d3kQmW4*bSm*=EjUS4li+->py7MIg0uP#fCO^eNLoa9Xv
zJL>&6*h^pk%m0x7LX}MO;%t^rs#$)>Ys;+pjr!Y<|6JbqG|^dYS*zW?``(kDdRgpU
z<^RL#%TARYyH;9W7Y`MDSTVizZBSihW$3XLs{@Z-^*pynUqd)zr=EV+<j*fPYrS9A
zuJT{ED^PB_YW>l-L3O3!Qj6APi>rcEF7Vr{=iPm4$)8WFrcZBu6em8_^YN)g_BQ*)
zJ1gQ>O+K~$*oxJ1apIj7aiQv;f3Up%SQHb#YI4`o>tO9yT`K;3`m)FS(39X(aZ;1k
z>g#hK*`u#D`GnTI5Z?gT?oXQkL?WNQteD<<)oWep(UXPsMXYi5R$q4N>A9NfBu&jM
zUZ>~XJ<-=;-hQhu`<5O(vHS<uxzeLw_4HirPfUFMdA;|MJ$kM-OFtadI{x$V=|jJ!
zx1Lzu#rgX4>4!xzF<muGo9EVm4Dj!m`1<qTs+j5GO7k;o4ZSx0D}MR`WQpAh_4ViV
zA*L{GK0du3<VB@<O782=>mPj-C$2Ov=nKf~KmYc3|I~l<B>1PJz47{^Cku--4}_)1
zfDD||DYxHdufEWSog$x>w{fkhpZOFN;3t+pb#?wUKUG}BtH>|-&7v3UdOc<L$7lXl
ze`^=Y{1g;Em$>%SL;dQLu<FwDn3(DH;z~0eZR<*3)_QkO^#33_=XLk1n3%5miOScX
z$4&37i0P^fe%Q2H{&~MX_bZU|G(hfe1-a(~*SS)NpFpnv`VtfXwJX0I4DJ6sUmvXE
ztD|jQWmTN&!y?TGqVsI_fZhC2$hNMs4$S<td|5r$n)><YU;o%Y>7Smf{S@KPR)4^L
zWK9FbPLU=k&`)3bsLwsoUtm42YQ%rz(}y6u$w%t+kBWP8J(;uoQ((!&dV5Q=I=`1c
zKwJ1eg+aIQ?c44A@~+*qI~Sgp{K^j7Cog+xVhuPp7dlV+r~f2)(W-j;DR1U3{}foE
zuPvyn{VLx3mFBk<{oBQ_?3=z~d8jHV)J`l9b^P|xX7Z`pDe;WI3>DiSf0{pKkG`P4
zR%?9zqhHf6{pl(d4F^Zf+yMEB{^01<*D8%#v?jK&C|>iY#(vhIFHIBnAL8=LU@+Ab
z4O<wR!LtUu)h^Ll<fO-@)Ra>vr%u)u(wsV3TP@57B-OD=FsV%=;b>FDq7zaPpbd9S
znP5sPY-uuR(|VGTk+H$y;9xIZjp^dqELPJMvRMp41n>6KSuA#pBDen?68&-g!;SrB
z>vFD|#9TdfwCl`t*&G)6`hq2oll3ANp8l|DK6h(qXq?3((I8=ohlN&}WxHcVb}$~a
zO!VgRYqDA@>37oozlQpyg&}sURwR1ZtBR?HO^I>mPz!a}Jg6Mpcrf5loA#sxwaFb1
zy^J&tx$$U81RO1z!MXBC!BR<)!h^~dGNL>hNlQ)~)i|-3Q^H_HqO<5}#(Gn*bfPkw
zD33;J$czZD8Iuw@ivCQAVJdpE=+#_Jw~)Tzse&sH6?#c1Zd_XA8|pT>t58)c$kZh%
zRU=EW>#1p|)STc>jY|`cYbjg!X*vh;digB#beqx}C^6GZsv~J<)+*DZ7L$54r4|_)
zO)(WX$(5KAacas2*GWrHKUq}&G*o7%#;)+7z*Wjqp1Nce#00gi;t5x|8j@)dE)=**
zImAs2ETXw;#g&IKo^C7pECVGE7J5moFx51SRFzs}>XMkMk+tAx(bbUb)<U>I$HBlZ
zx2_d`&%HeB+tzMrxmN0E*UoibR~OvY4clE7Sh8-(;t)3{9kno}WlA$t5)(ZR^oSZp
zEHqegWHC2OPl&;)8EZm(SPr_02}%UqUpf6@E{k~mN3BUGKFTQ{Db=(|*^ngIG~>gE
z4^NdUE*xxi=CX;1iPIPJn46JsD%5N1y0u}wQifYHj$I6ix}`1J+q)&q%<Q7pEu}5N
zzou*nmFakJT~%CF`vH5_ibqSzCR(kOV_JXE`^lmshonqH7xPLkHVmB8wPRh3XiOMe
z*lO*_s6*K&UF(k)Jy`W<gVEN=s8iRL><eXWkPOv2z$>cSAf@WfU=lKoA!Diz!^NNo
z#zi3;m|Z;+*gAs_@M^8v<F9?{!O{bKoTs@W#a%DFD9|biF>I2UYS^jnH^(wi;y@d_
zPr=KB+tzwT=Z36W_v?230|T~;9k~q&yo&|49WY?KAfd1&P*4!mEoL~Ws;M&N0;G~<
zU}0et<V2}sRVGcD<Q2YZ{nV#5>-sizy<WFm*lJNrAN#b(O7V%VPdR<M^bK!s>Yg<9
zDCbR$CsRtjVx1~2Mb31kO-u>ap6GLE>c15;W4h7;W!R!teiSlb<_tQ(qvg$D(lw1C
zvtCn&;gVJa<B}yCm_1e|uuYnDfLCd0gQP3JFstXIq>rY4r@}M9;krQ9x#PvIp1G5J
zt}6DZq!?aq_gShZ<a5edYLSs_gwmsf;$c1$jh!XEBu#7oHZVx39dQ*Dj94tdz;Mw_
zNu#6ds00Ti69a>^VB1AO7nfW?5tpQmy@K^!MnOTIDNB}2_Vjc%^YW4mf^fN2RaK^W
zd3owgnKCJ&qobo`$->#HsysI}HPTK(6mAL%I6G<5wzF0XUhP}Dif{Fws0BZsEIP7y
z)x@hFFI|2peJawNDRL&{NwC3^CyOqA3d|01*HV6>vNbexQp+VakI5dA8onMz^)9m}
zq%1U5I4P91;G|Qg;3Snx%Bq~JI#;?>#)Yd^#!gvx@m8kSTiM+jJ2hk2of|K_blFw%
z@+4=;alejPPElHY*R!|YdcAJft5RdD*J@6B*R!`?Db?D=c=e`HXja*!Zddn|#hU`J
za(-H}3+5ivz?iNyk@ZuWyOw6M)-P27^`@^Vy;$|)$&ApFq8XuOPZnLZ>RY_x#iCs$
zFHg9Zre3|eP_)JQgJ-9lYIygQlc5jT8E<>(bXl#`pD^`<YstPvGbj2S^;Z?!5cp)#
zwH1A>;jR4Ir#|iKTN>_QwOh?=t>3M{EGt>Qb}!Y-%l$mOmsyou5<0Z9MyN6_d}{pz
zxa0NW;^LTFLLc@ht>;-L7|y(HN|cths_dk`3G*4BEV?!&>WV(pj)k&b;lV4fe2n#4
zw=P&U+`)qHR$wNElRH9hhL$jIk75@3abg)~yrT9K)tag94W9zDy>zq0Cv`_?d<x92
z_u^Zsz4g}H3ahEHF)6EFJv9nVD7(}hc;Q8fRiNHnt0JdZ!^_JiOq&|?wrqDy;qh3%
zW$CdgN5!+Z-g;}TwXUIrdDGl2D^oSzOeyoS5~-Mo>d+~&T(N%3gAa9YTJ?fGZ_BE!
z>bV-5P#jth3fx5=Z^gDOdcp2stu%L)d#LiNiBGv#x~_G4v*;R^wZ_&J;X&P7Z@sPb
zJGFX&EW?}Sxf&ZvtYrD7crW*xGhw<<$;&0Gjo$yBgz{=?b^kxJXsYJ|hPShQXX}b2
zO-j)3IXXYM&wf+k@jvR~rkie=ZHx9<6*0x<)X|yUHhvZ#>n$GJ_*oq7Ha_yWU%1c4
zpOt&vj`=qhUXSN~ARe*nkJG;EPwTV(UH!Dq;&Gpy^2`3^mtX#y`u5ZM)>oPj>s5d3
zUw^Jh^XN}(qb2C09M}h2>fxg;#kZC`da_qv&(*&B$d3K-bHJl6d-sC|Lr_Lbu$u!n
z27S=x>$jD5)1U0vzy3+^p+D1GpMu=`XS(?7&#yGU?Dc+GU$?i`)o%Kyc<-+tMSjGo
ze%QNDX+HO)AMv2UmXf*4RmC-*%nHmZ^VQf`^>3B`qkrCqK7G)9y=rpzl^r|w$L(5a
zvDf=$-QL<&{!3qh2a~RP9tDpY#fHrP5a`b`L({QUb<$F1Esj6@EB^9dsghg#qN?Bd
zhyIF#U*(-&+10mSspVhsOMcO>{)I=ttiUgJi(k~SU#VOC#Xj(t{EEN)A>U>M_5}HA
z`Rs3<s-|e@+VypkyPu4zjF3T+a~nsJ@S>~N7PE1b996!kys$~uszC82=ZC0$Mio~N
z9OQ5J<CN=^W8<i(015xljhD2^dXUh5csWbIOFuJ<O}&kUz?YUkV(WY6nHCs0KfK)J
zzR11t;eqxxj+#)<TNRlRGnORF$;|_U`G-8e9KQ_S3p3w;`O7cA3VuQN!~CeV_rDC@
zGIM2qYHHA7q0Uv@>>pYVT`62umC(+kQnbh*OYyLiR8vXRt}6*IkF2N;l;xYVif>l^
z3fl$qSyw++?~UPa*J@t2qCZRdz=x*+6<G_uHPvy4AM=;mA<q}e?i(m~#l7+2sRbXd
zI=*Fry4Ox-72m8ywk!IX4<BB&;KzjJ-G`69eD&pPRn=bm)LN+(2fsWNJbJhrvUBC?
zm%kjydslwc#;^YJw?2OPtH1Uh{<k<^Y^lw#wJ7wGS<xf$aH``9b=TEv-T3BswNDki
z@bdDi1>c%##MbxAv@<`vyei<^A{%~wzE#b)IDhEI%USZVA6_1^@U2UQoSbYZ`xfC3
zQTuF)Wcb_tRyyD6_+VpWwTiFZZ(f)Cqj@VQh<W;~?-G6{U$E@ZG>1*~T9ML9vz4YT
zJnJg!q%U|p#`VC5mzOvnzUD~PILc$ke)!?VfG?A3wE6pG)R`Y%UNZ5e2FN@udGW0&
zE0-o5bko>sXHyi;{P6Oki7x^lBsw2H+@K-8plQ{@Px|Nn{j=V^d-twYyFpVG;OgD(
zIOm-zzX`9cN?zXk$Ql~TP|q3~8X5qa{aAfs7w3&zHpdJbbG25jU;qh$SG<cPc`*n~
z@(9gZz%t2GWm47Zxp!1J%lpeMt14{Y$KE{)o&^aFbq$RRVGRwR3Z3)|)8c~6sK80B
zRi74Ut=hAKYt?!!rd6v?HLL;&)UVom_iA~0d3oX8tF;$d18f=ItlV^V+tiNwSt|Qa
zEs^DW{NL!h_SAJz+67ndsBl8}gG^9EoC>sRXUy87ol#F0ZRf=@?dBoGvO8BWS2^X9
z)UvB)D>rVH5HJ$U=}bFxgE^(AIXbZ(W}*sbgQEg?rp`m?ZOnDEb=lMIY|}lZjor*$
z8^g?2n&v%(>0mjS0M%=DOhso}z^2G(<xMwl2yKwMz`(%40-68>$?IJ`dp3Lav~^*o
zht}R<U{K*?@B&4P1AHN9*}Bl~j9a=J+Im|zZ0ntxB!B%+eeC)7e}CRr%(xL{Cf3`!
zI1$FUSZfjQ_+|4<D^E_FiV1W7PUo#;k*`k)4GoQp6ySS&`SO-`NA|w<<cPXe<%FUU
zVnV;`mxs0Nm(HcUR8jf($f@kZ3WMF%TTd8(Zwo3~wF1H@fKWxN7HF+nwP%xp?D6Hx
zGw*g*Uz;Sbb<1b*ZtsdMIgc){eRS!buGKwVX^Z+Tx=)vEpT#4E>Q<1IRn@n`E57aC
zd2jQhPtO%&?=q_I_%hFi-NWymD4TeG*-rQsL{J8l3XK#E4Go{>!hU6apjGy}a|LtF
z^bVDr-5Tzl0cPFU1)}e$``iu<5Dl#l4Rv7N-S6*TGI{CTOXYc1rSCmcnU{8z7YGSt
zXTI4p;YNl>#wX{*g^G($^0uc>lIG>)<K&g|$caobsZ`vUI^p7zwqwVWq{SlnI2jZ(
z&t9B3q3yW2o12p~Z|m||Y#l-h9?nUpr@1*vi^Xg*61b70YjeTGVIpIkM^4<_YJHV@
zGkw3k(<ezw%XZ|%y}Vn!>63HPm)AEd6*pFuf^0u}&ClSw-}Bx2Dtgk#Wv5S)=6&3E
z8tRgF)_ou)`7&j39y#WH*7_=DvhzH0%y+!A-t_r0#K~<fZT+@jVG|V#6$=9cby>5u
z2M)|BxwV~{sqk`E${ilg<GyW&E-nPQk(USJM$6a7Wv6gno;RWGuqwz$P%<&|yr;uO
zCKpbQ9227xC!7-@np&6JRy^L+XjObk;6}<WBO@4@qigw6LrTG;ak^hMi+=r=7BeZy
zloZ7c7fvfH^0pni@%WJPy;mFi>_3Z$PD(YM|4!^LgK)R(5B5ez_wWBZ8W<UbwPc?x
zV=2D-DOp3_fq_B!n&BqZpxLvdu1x{W*KvKgz`)p&-tcM74H1bg8f>;3`jWO8STHKO
zFo=eLvPl4g5(85MBS<X+14F$P<HB=V4i|a^9j2-skPK<KU3RD}CG_Ekc$NhnBD>F3
zEn?ydRk?SiYN-ZjqR>QX{=B6j3m6O<7#M`+c?B)Gz)<DDtia&;YRW{7ue@>-E-rkz
zNGfxIaH!ghSxW<#Ih;5);Q|Afm(ncLkjacDnGGB#`<Gu}U`^Y=YohXJUuZ`CU)f)Y
zX}@Y`*xqZMeeaHV-HpiosmFIdyLP00WlPP4oBn6{jqI=UE_|K#;JMi&%LTW17u;I-
zW7Xe^Y2B{#SN__=`Z4rpXU3MuAAdd`Obvg1WJ{FJ-@FHPTHD#mV`LtH{0qXYS~cvu
zFJD+c{pi|l_x|PgiLGTjnAP&<sOZo7wyPq4FDahgc1r!*?X0Dhi!;}5^6mWF#=2JQ
z+CGH?xodwJI)_b@Zx(cJo22r$ceQfvwke^O+s;k?*0<Do+v4n}5+X&{KdyKd`rA#^
z%BbUbp2rP8Uh!Wq4)yV9yluI|&a!{S0}KD#W@m0q`gG{UR++cQZq8PW+1S~1n)zA0
zUCo{Pqm}bZ@0T3eTJ`ny_G!U~4<DX-TdSlbYiDZkq^awhzis@({%MYS;jI3*o5H`{
z)c&38{_RfDrXzoE3xDdGRMWfKId@BLl;pNn%_z4eZ8>hPJZIdNie+|OXv;cgU@+Mv
zSwd3iz>lPjoynqxT|G&wj;TEEemLcrvP77HPZIy()}DHagYAdK43ZU+AGR5^fBdm(
zF82ewl*!DZ`|~&o<SarhZ+Gc2uhSB@E@)@G&LkbM+`5pDd0j}zv)zT^#(Pw)i(^>V
zeOg)cT+1)!srGb><+|afIesmFLa+X26S$dS)SVL6EO4XiLW)@^Pn*JD=PsQ#ffI>5
z!7EbToVikr7FE<gs&N)Mkt*`n`Gt7rGxe87Go`9e|JwLRZ2!)nr{{u-o-3XfH`u19
zW_|njIm@+cA3d`9d_UUEz54Unr-c%g&%aNt>bLnQfBk>+t7@x~+kTJEy}Gks%~#&!
z&(XP8cb27G{0tV_ZItnId0~2KUhGVhn#(&j@7k_+W|m#%oyfcO(bLwidRkd@Z-$|1
zYSEsZ`92b}azMK7Mo&*WD{t~nch_&Ro$8!jTO*~mevSAmw!hMQx<$;EVwYPMvtF;?
zS3J97hkL)h?Tx<OpSM1gvw2$KCcpSqz5c6Pr>A{6*!k$x)0&-mJid`}uTM{VaOCRL
zcY9E|^?P;}6xzhBU9T4-<FD2?-{fl4^vmx4v$EEDzg)ch?c1kM&;0r7-Ex%2$Ta(9
z#ILA-Pm4~^Se$y~+}yvPD|U&#t==25=30%B=&jxQCl^2VH4R&ObMf-WxAsoIe0ll#
ztZy;%<{F2k?wtJCG%aeTMcSIv!CMa=`ItC)HP8I*r)S>pT3z3ARGC-(V#MFA>+ibc
z7Hpig?_By;uWxI9spdR*ef^ov-w+u!O*bk3#)!Wxwe6G6hS|(qHTC1>_UO8#^NPwX
zN3{%2{59;F{zCA`=~LhKuh-vs-zzXiTm9<Sij3F(XCjYAPkVav<>F^^kIo7G%iw-U
z^~0+92{(B+CH-ehUD38ydv<+2Q#_;o1@AYD4lh~pgR{0#e}n4N(7mfoopo0!D%@($
zRyELFafaD|ch!{3y4gCZreA~}Ecz`HpVa*%u%=6YlItgreV*bsmHyhhoDH4Tzo|gF
zsbj6D+w`(+J91frG9?bKb&I(ZpVGa_^`z2Im3WozClhNXLA0F|fB8ALK2`mu1@EEU
z^w{!P2gWNC4Yd|)-HZ<PxsuC%Q|aa3=<J|*!n_CaytZtYDejZbZ75ao@m-U<CAVws
zgxQXVf3@B+ILBPHs!#sFv*x7SrE@1QxZ^fE=L+uv)6~O1R^GJWJ+k8UPtBR#npbmI
zr#S!Iwt8jO)#|$S?|yARS@+^+ZCz#k>+iq5eY<y2#rJxV$4nuYyKk*eDy4V|m)@DA
z<}%T|@?QDs>#MK$bSmZTp5$_3lG^*=Jz$AgkSh68zg0CgeL90SojG>uv@!2&Mz-wT
zv02#+Y)ZGiqkVI=Ze^#g)lQujnKEfoZrbf6CI$xHKmpb!1uZ-I)NQwOpWV*2TYvZw
z{3-%LK|$DU1j;Pn>j+$2AUFIR0p0(j#L)qv6=3%gNKAIjkP_%pQmFX|+UW+~^JWg+
z#irxN!ZW>Q7YpBX{+rC)(=#Ml_~D!0Wa@j8rL%gsx`Ag-uPnRDyGo|;>{hp1i*9}X
z&%iMGebLYFqJn2;O$~2f+kfy;++`2B+e;5PC?5V(`+U3X%fO|!k%3E1B|==DFWmJs
zeD^Nn=X(l1&Usg>AosnWy+R`|?e)~qch>hlA9-(CocHN@*ZShjkW$-wFVCJWj#(Y<
z^`WNz=G)^oGk2;ninq-9W>ImjT<^xgQ%cKodkR-Cz3yKS#nrGv>%j^wtCdng>sGIN
zaIL!V#H@*0m6GT90z^x-u6*d|xK>?wu6TD#XsDb;@thQ{;?{S?#pYq<+13-zRm)`C
z_L*J}kBz*$=H1m3x1}fEmf%faR$aK}+vCVLg=@Z?&#PZ48@p20Ju~6De#|TJ*er4P
zoDJF27r5#+bLBQ1QY$vz;q$y;<~c?|<C$|$bZ&d2l-qas<eW3_T+QybnjJ_umsYNn
z+k0YmvP`zE@nzc`*Fa`7N50{8da;#z!Oa9`?Xo4MWlKtBmo~@jEnX2@x*}F~(;=nQ
z<RGhFk5{}pQuR+?lyWb+qSu_-$g{?(^<tK|<E8^`VX`3ot3DrI8OI;CuiI^L=Gx$l
zTiRl?uA1aZ9n;nhS)6fOFfwZW`t0~yZ49kEj9hI73~b!L7|QD&@V$Rf;lAg3XlQJB
zxRR~u)zI+JtA{w$eT8iURn7+a28YImI;`qg)v<c!wwtqa>t_c4)9_llG{EJhq0VHD
zO(vl;Zi(#oOj;j*<S+k2+f`m)U%q^EWvkHC&d!`&7k|kenKz>=Vw!5#-m0psEUwi-
zKlV%6nTpJs*6k~0$~AR!anX-mH+QWxHPscHWtQi$nvK`j`_b!*o^QUzO<yaeu=;Uu
z(2rdgmRwx9GGohCm$22R>K{F-^xdGEnwoUvRBBVlZS8C^wcb~6guYIl+RdGMoKrO8
z<;s<1>o?pC%1uo=^5EPWq4u)7*RE#^H}6?BxlhK@QZMw3rAF6|kdscEZY6T21b>z4
z<8F=N4tTK4Eow_p_O4rRlM3=frlwAv+AZ8{6)^Sq*}2AfS#hD?r!4;c(PLBnj)#XQ
z2VIT%6cqa7b^60Mced(pS~Sn>=4SKFMW5C_Raw1$wpCG4)bu-n{xSs*PoB(*d7v6w
zdRXn*)0MTax+-p``JO!;bbr;7wWXic{rtRxzPswJi(5VQ=#fY13~u*g`{vA<wsgys
zYc{!))1EzDnKNZ|Y|X>VlP6t`d-TYw__*BF`oohaUD+`yblskumpgZ6tuM?}HGh1}
zclPXQtG<g(>DsrsJqBd|>U%27jUHcaS65wCIbX|DzCr#ZU(i&;EyaFJeeAESCU#sc
zOevLd_mb7@dZnz)8?kEDHOZQiU$wfS?^u?7xUKeDOr3q-iWL=KuRfi+wOhFPey8Ts
zJ!W5S?yTRLwZ6tv>(^(#Z6#OkYz^P(>96~6`?9mXr$ei!Dy?5{@H*Yk&pWjG$dpgd
zWU30DJlPt)M^)?kwSw2`%dV-jUzu2PZq25>*L3{&>#i(~k4wDf2Xgv1Rl|JVO*wb&
zYz<!_TK)BzYzoM8YnLqBv*&QmY;$wn(5*`A>$bN?TGba7MXm1CT(6gS%ui;{v{er^
z!}o4)i?qtii(2iexnB3-G;mm4)C}JreR$1WOH19*BU7$VH+Zbh=jR<-$mzSX)U!r$
zmQ%#M$~jBt$TG#suXq~AC-^ABZMj&`iB~r6f)71D_=I=#^oDwW|2#SOb8+wA=W}Q0
zn_JwQW@5+pvi|-1vWCm|x4zlBx_oZcVV_y%=DI?iAI&{K2K}0{UPLqH>Aj!lRc$UG
zQTg!KUF*w3+4X)LUlV#`B12R41z*{^3tp)T>i0NWr8)8Sq}95jZh^0+Es9dfTGFe<
z+8HNV{cg{>30qrNX@_6ho;3Br-KSnBcb{66`{an$M&=vyPTiT&U+?kDeM_QO54&q(
z@RE{=20g2i7Bd>T>}T=%qu~EkMrLtndDMFL<&U2~e-v`c@}pdm?IFwfIUH|m9%!b1
zDCX(i8YI^!cgVKmp+w)s8%y1f9PU`p=3=8RvRCELigg_8oPwunxobFGdRiTK*`3i{
zd+O064<33-nVtHyF)2~#>8Ypng@p!5EVUh8OTRgV>P=atbz(`gz=BgNn@$8picI62
zn&5IW;MA&3ib)zrLsGO(8A)(6W(KPrnaMcY!NgZM=*p&^#eyA2j$GStSj}fs&dtqf
zX^DzKOP4O4MkKo)j|Nq*Y15`fZcaNpb7sp_t*EHTw6n9#($a)NR%T|V&Nj=rIdg{R
z%o$-<m9s-SO*}i3BGo)s&00BS(=>^clhdNMW?fy2qE8fI1cIrQhG2u3YLQu2SBGs~
zo7m<vGY#yA)akQ3SrqE0ZQYi3YiZQdsFo{gL8)pXsctGqW^Dy2OI;ndHtO2eHc6w@
zX=|glW=AAWhMEEsf~kVbKpY4b2CI=sIk`4FIxV+Vn=5R|TF(e!ri{g|Qd_gGwn=Tx
zj=FYpc4ED1qH3nlCDm1ds{%pxL4}1jbVdg0Y}=X&3-7Si+8kadC+loF9kw=V>t=%q
zD}ydwx^(HZSq{jJ+tO|%{%ctJKgZ?Y^gFAxx)yER7_o0@-S)Yc&#ROP&eUz(V8(Xn
zW;A#5jB@L9(t9UfoKyD5H%c^Q4Qu_%19SAe3Xf#}$<0};dRlqTx~z$19lJC(`JEKw
zto*;K^{>{V=3fh?G=ui>C>cCz7xhY6apXv$MX1jl#Y2k{1CJi?)?;}zX{MLKrU;><
zJ`;VMigs{jJyPe?oGLu^fOoiv1=kGDj+05uN=Zu%RvbE+;H@>o)rj+S!?Yc%3S5mi
z>l<|zHU_Jzxe6Vc>9p2sSx`vP4-3_p9afzeLJs(7Yj+-Wo!k`THJMc=rb}ms>Y<e;
z8W&xs`YiPI>I+xu4i~iO^c9tu8Oay6Xxcha3#C~rCBwoiRieA}G(A^MT+%ISAaXJA
z_9WMJq86;CDk-Pcq&zkTGx~~3G8*`Vb~8;=s-LMSTlT|RCARFvNA3ffE0whlcb-%_
zc|?!V*HtEFlFp7+kf1QHO2pDBOD-x;J*jjREGJjCTP5acN$^UMOMz1ppR05iayJAA
zxq;00*7RKDp64mHBk0kTSt^-Ihh{3x3Y82EV{KX5p%W7P+2N|x;)ol!FUQ<`J^5Ju
z?XZ|#HX<LDW`#<08L0`23F{~rhHTK-=oZ+`IZbnhS47i6XOWE>8$}LkGac||^$F5h
zI9cPUR)Si{G|$wanOb%lp`ky#(tNn;SWa>`Pk$U8{%qxKzPs6}5`Brc-mQExX<EQX
z=T&kVr9p8<5pA53ijy@`j)o?E*rU(g<b9N<UaM!}lv9#E3%j)@ubg5Np&lOI?I|8&
zG|8yVXW?XxloPk}wrx!oo9Zm>=&F@)ajn?4-rfw*l_}EF85cvM7^HJoXD8j*CMqW<
zC#O_VQBhIyVP(aPg&(Fa>aftykGdJNd8NUw;O(ZxDtfNsDZ!guAF7{HUo0$eW~)%P
zt>o#h`k1R*3#Ti&%j}UUdNkcMHzxIl@~wpiIzie@R~0tsESSbRVbOt&UOL<?OQ-rW
zO$#*=i3~Xrm>R6qQZdiS^l`Mt$)Xd_wPy)0nj7${U2AE{iWwV}gQj)|t-SQIV8=?G
zh?a!dh#k9jM6J?^^pps_yxebktX0YCtN(4+Zp(2x%py>~#;}ROY}?Hhk0ypM`u270
z)T^PbhsqvrvC_MH^=zP?tGG({rjQS-KUSHxZ4A@M_)>V<QtNC?QJ2Mz>x=thf}X8i
z-FIrbn9ICV&04cUgHHMiig_h<Yzo#?I_cvvP2@snq7O?%u!?J|(MmCqt1R=lPaoSB
zuD8Tux>wn=b(!uWR`tTGBukA>d8JP9*_dQlvLjY!VN9@2s9ID@%G`*q!X(YB(|oo}
zOr0`un$M<`xmG2wUOugii_Xu!=cUonqcSB>P$Fo`#$Gms?zGEk=UgV=TAv?vYq!JI
znCYV0p=Ga^7Cl?{z<Z+WNu@WMRiZ!kN*#_^ZBk|N^x&~cx3)_yjfu&wzj$0vvpDSP
z@yvi~#fV@|*NH|hk-}ONlX_Sp7OS{+8ENUPI<+K1hXsUsma0D3U2*Ny8&6OeZPj|Q
zyFA=vahFWMtHrAvUY6{NS+#1{rdO}LwyK5+#9Ea+JlvkLv~1_9-Gyr}%?UhuN?YT^
z)Z6PsPtOp#=z3G>RmfhhuT}M+a0LZxbFb>wJd4e7eU^pZv$n143XfPNzDcxMi|f<s
z?Y+6Ns;hSD1<YE#Jyv90%+)&!kMe1hhP+G`3YM6Xl=QM>SGb^NucP5)_Hgm=z{wI^
z$w6+Sd~>ZzLiOfam4-hEi@mz-6kF&7-X;0kXG2f-maROeak^E~t&#6;eZjhb=_=iu
zT(7dev;hZC1vGeMBG<Fa?9iT-8yh6_@zI(EHtS8p^GtV5?y}gi<dmsu+3O~+r)L&U
zv08XFc)`k^K*Mf{4WRA4GA_$ZLXy>t60aV;dS#QV;i?tKd{T~HUhcPI^>V+tEOD)s
zMXL-V+Kzml`fSzHW7hSm=QK`FnCUiYMcM1tqL!U1v6J*xim#{u2g`@T)39LSvn=#p
zv`XFSBfp_ESm*AL=OU>`-2#^=Z;uhwo+uOWs@<ie#VS^Bx~3K=5-u`cUe4F<H`hua
zcK7OCtEbDn>AQQ%bcgUnlc|EY*YPpMOwv0k?j>H|fyJr<zgD5$4{e@SuG(4Hx3aj)
z=%HHR)KJ-74_el_6gsbx6}$wF?MbU%onE~<D756|;pKjFtyV30dpGuK%#LfPOwS6>
z4ZYn5wZu_h6kEuudwk$NeYQR>Yh6t7bfez9>q=R3cRhI2E@HLt!dw-;>28@1n2m*v
zjZap17{`TAy}aCSZiw^ts9U>Nl^xz5b<<6GM%nI_K`&HKD!rLlsd(X<)|t(*Qipq1
zZrUyrxvtN$U|sw4>9h8rxJLuz_<)xlpioi)C)KO<q2YdWtV&*9UZwEg#lfg+ivLH=
zkkEHWnF6-<WJ_!dx~iGj(`F=b;Hb(~jtK5Q>p!!8db?K3Cp56BG)(Kqs?~oix0&5K
z<P#`4^<Hl8woMaT!cvp3*ei$^Er0rf`SSgVHcKD%FEW@v?c%M9-RoZG#g+Uz*tz=E
zPVmrJ^z<~}dU=y~I`7t=-mKO?t6Z!+?CH(P?q{vLtydSlISCrofe*5Qhs)$*wlCxH
zjf`2Z7k!ycZOyvyX>*Tmk5B5_dQ|n4pJ$1F(r&4_Yu2pSi-nAg<(@7`$~yHuE@nHM
z+M4yHPfr&l<=lMv*$-r2`tq};VN1W%U%dQm*6N^N881KkhOVqNDfzi<)s=m-tZFV_
zUvHStB&8MGS<CfQb@8ix)6@B+GFNTYU)JBZclFI$TdSIH>r+p@ylk2lJ=4xOEOq7N
zwyZN-jVi+@ecN#IYMcM<r)S=Yte-OVgX&Sy!*0jV?(Vi&sod##P;~QUkPj_ZdfZX9
zHma|x`FbbvsMo}mWo1?1F+|b4=;`UpK%r3>{zzOfVTv}-VxFdsLs?VB42-h0wL^Ti
zY9?rlOl4D9{E&Z@{3?lsx7v^L2K-p~(fOcnz)R;4Qv}*DYvC%nDM$jMQVVaXr^<G`
zanF)nQ9Jona=pZ?)rygBnrb?egn1Q=OeIYYs>LszswNV#=x9yC9KTNf)Q_3Rx2*W(
z-+5?NNt>o@+`L^JFH|4+ES1sOV`H&YZn`&9+=`MNj}nzHz54Lwqe_9$S7+~Io060-
zJ$m@E(~V_MzyW{mqYp0$zpT~2^sihiOXy(oSLaJ#ylnKv+c)2+U-4m&UZdU>+v%Hr
z30do1Pv=i^Pndp`=jXFKMuiqFHTvBTU%v79!CAJj^#x})k6pw36N}=m+Vk*4^eA%}
zCjHT0`eC2=$6EcRU-m2w_Fe>P6N2!YEnD`AO@jcjzThcOE&YP0{8^sZDRf|s%4{WP
z)nNHGfm2<ZQtRC>9a_Bl$3H8UkNzURVnkvCj!rq@9=?2eK;KdEE*YKWO789L8txli
zAGI$%Rk$fbdG+PXn<k!E^wIg!laQ*7FBdIVzw+amHkZz7`7Zg^S7npz#rXo=AJzJ=
zJgM|!;fKBcM?P`<*irIE@Xo}fHt{XLmh?o_%7;t@^Ok&@>sT+b;g_|ieDFt;iK+aD
zUe)PqD)ZO|xh+u7-rD`>ZP`Bk)vtc-Q~fi8XW^e14~rdpbwTa_)!`|@Ve7p?E#a)I
z-Ql1`E@iu8yB~&oq=rVS?9cT26(27A(M0geucAq|{=pwDRbm5<UOn<urK+lElFcN2
z5sR1@Ur#wXnI--8!7G<^ALaKx@TiRA!<Q$5CzW2cFMahY<&yH{Ah${SA~yQsDT@!g
zx?lM<-}}gvC!wc`^5Q0iYoGeCq-^f;AlF;%ske?Cc_R4X<q72{6Keu~#EU1@%=`5=
z>-I#(6AjxB?b;oh{A6O;!kcCLmMrG6^>jZP8t?hx$R_tgKX$R&grDlES2>i_abarn
zMbX#!mD|m2e%?OQ_w>%vyIN+qZlBF9j=7g_TDhd$dspnGz?UK=RThbDQZ;t+ye5}@
zk&s_tS%lJ2uea95Oq(MX%#UY(`KxYz=vz0H)R{a}b#&HhEprV&{PRz(-Td~;FF*Xq
zTs8}i>Orhivg#qrJxsRN?eXxx{`!l(U-!!iCsLJ8B-KkyQ~VQu`p3WO!p#ylu4>tL
ztp0FhBmbd4F@^_S-sWBkd8M+8>8(Yi^TV2W{`MtjXG=?k^oC5+D48k|vEi_AXF2;l
z3%+;n-aUR}{o=2^;;LDTJj-r|obF%DF?aT{Rau>?x9d}b^=u9)-rTcm(d?X8%cg$b
z`{wQT+4HNGg-mD7-F9o$rlr-a3m6zyv1{E5unfDmMNm<JQBie)OUtxIAt7&vEes4|
z3@;|0ba)ya!0yuL#jbU$!Ahm*f|ZKYw%duP`?ohYF#Npxd`Iw3SBvb>KX$iPZNI&0
zU!{`EN%`_3pB^>O`uqNId(~VzC)w&vR_2_%`}+O2f6G^`zB5VRdXe(o%YuT!dw;F^
zd^!4h*)fSThO;G-4UT+@y(`qEv1==r#+6=`lP0|?Cqv=P6HiV|G;*I;J}D*9$lrFu
zD)kj1m4daxiv(R(N_kF_a+{R0Bu&sIOUiSSR@<bML^;=bE%%AyL24a=Qf-q`x)v^(
zsVRhD+r3}CJ8aLYJ#p{z+Yg^UF-fJfyvSpcN@vyQJ(E;Am16HqQt4FQeO_;(is!_Y
zf+GGCl~44gxK9kc$hG*Cs=$gXCX-b{c~wpdDI37q+gw})MSKNTEK>F8b@nuJslOQH
zGf_!7pxf2c$mL>?PY1)kuMb^C0+Y&%l$4a`baZsSUJ~fGBx<Fa$E=lV9ur+xK$$KK
zWshSHOSWldBu!cL=fC{<kALjd<%{3_URV1+|LphgpWnVeZ}-3Q>#s?(uUfs>RkE%l
zE7y1B=8Pkzo?FePWn>x5f2HQRDW^WNSwLxyMv($Xf&A&8>%aWh{`NcL-uFe*xkdio
z5xcdy`uXAK`$ENQer}(ZUtPI7QfIey<?d}J(_%MQo>f#k`u2U5X2C}PbKJR+dp|$?
zd|#`3U(IdL)SJ)Vrfhoi_Sw4|mm<r~KDW74cB=DzZtjNs>T9=IHP&&@TD0otfw!y8
z_tn(fRX>fszVWs5=R0!WSM@EOecxbTZNSfi%^RxwtIzW9Et~e`(Cz2bZtAR^<*j#f
z?Y_#Fdl_`s@$oTyy4C7#^?A7{S6}IKzvku!8$LdU4^_F_ZfED+-NvwOhuQ7it=ls-
zLEDn9-Q8tid9HBV?cCjEZ*PM{?t&N$&n*w|)fdkJ(*?(&8&6m4-C4wRK@`04w61;z
zcpjN6L4FVWk>6eo3msj#7?>RbF8eHE&<NVX!SFT2_ky61s1|F{r3GDFMhiD*r-gEH
zu^JS9U}fu-;%T_xIaO$}g2`nE)lmEIt5!)e3#1%WU*$DLibvS3DJxJ=t3Hue(uB)P
zNo3`w#s&Aau71kg<Zb5ZYqx80=w%gdV};B~L32P8ydcaB+OElv+w73by6u(7g%i0e
zHb^^ekal#t5S{Be$#+}R6{&;Sp&eQqlQVO*x^pgUYdgA;!~a9FPqt*I*Zj-I#-c&>
z)wxqV|9uN}zASBa>)0Z;8TE}@ay2%tjgGqSx+Uvs_zVti(beHEL^tQ0T@x>zR=fT?
z_ZIyUoh$BdxedK)ZU-iZ1pT;n+vU{N+Sb;%2U{n^J(+c-^IbIOYF7TJoSdbLL*?Gj
zG5TwCb(8&#{T^TRbF&@au1&1Vtekb_v(JSOXO7C5bk<$mV7sM1H{fLl`)jo;_5C_A
zSHpT$iv3ML%Wk?G`}g6o%`s`E1-qUtkCiwrqsKk9*zw1H_gTxX=4{D0vd`emsvlR<
zT0gEhe@FXn+QN5{6RXagoH2b_vcx6*G=}|>UO%p^e(bT&*WVz_S1WEq&FA~`WUd!J
zoA+z)-}mRckDT0TnYsJ9cH4~0ZOJxqufCtJt=GHSd3e^2E$1E`R<n}Js(5|UVm0Tf
zIZp~L+)LJ3t1g;uuT^Vv=$6^ch%N0mmt5AYHTB8TU$$7v`{9aX_EC$Utu<6X7G|{c
z(`DaaNyQJxX3ff&aZ<loGI83<$)WzU0w-%te%e3HF5+kM)Apiwv6pY0oOhgk>7;wp
zmA*yFPv-YJQvYRVmZkWrOu6MIJKC3=`Vc03#4>B0S4FT&Wyo`l7hxWcmL3!C)VmT<
zw8}*5k;c=8^%vu(KFijfa$~b}))wEND@+ZI^3MvcTyk>yThYlO7ni?TIyrE0IGEIb
z8W^(g*uhOXIjghQPEJk^WjduB$SrZ^<jT&@$!ck$tET!S*3US(<jA3vLnouA@Fbnt
zl(oiZRg%<1iGwpzE*ctX3!IwTvs$fdrshPqP`lM4sRfUkyB;1@JzDT+Nnwn|M9WRL
zQ+Fh-mZ{az?s=H1E_vuwxa6TztNSdc9Sc2v>7~Smhz$|@ritn3#CwbBKdcS-wPvbL
zU~6iUW|!S^5$&#1%_4>M7EbH5xn?ZxJhIeJTQR9mokR6Rn%UIZ$%b3jZhKVZX=<@f
zX~P*))2&IV)26L;OPe)o$&FK&qSh$CJ#b97J0eFnIcejUqdgJ_`<F=^miI}1`6lk{
zvQ0^;Iv!h1rRwH)-d@=`WowYBb)l=JMakS<GiG`R>CD~X>E|b_p0`Xb=xV)~-<^fp
zlM7zP-HSAEo7Ai7$&#6zIU{rOc9m{fH4Ev@6L!v-vE20J)XYh>J2vwiw%a)4{F?LY
zm5;8~I2F1qs<UHOre{-%Zv@+lO`BDhPnNoMYg?Gl<cu3vf^}=`mKCq<U99H0B`0H9
zs<&RO&(nu)8=DLx4ocj(B5iqK>y_(uX7z1Z(?SZb$EKR8o!WRkUdZsr>TOw>wf!f9
zbI$6rZk?5xVU}`eXPD=~RmPw9?3`_G_vz-&-?Qg$zghFsl27GPY3!SI%kz|;?0D$s
z-KRSD;r1}^S&xpUuKcpW=KbW?eX2LhV%w&+MPx=yPrn`$d@}XiZMS1?JMZ2*cI<5V
zdi8)OvGqN*)vKP*oqDKJvLgI~RmQr*rbad4S7v8N8uiYKT6l1Y#hS@>-{;((U%B&p
zO|HqM?{^n>6om_KdiSE#vZzm8&u#aPo#(7(7-i{CIpxp&=wlIono+5hkDKD9ADi@r
zGy80^Gj82@yt^!XvdAmFV}?()_Y3*WR6goE*?rZIwOh6X)*oyvj9B}=?C0KTCzrL)
z%Qfp0ELuJ3RoUILn8LZ+)!i0VMNO?(uNyZl;K?yR*B9+s;l*OU)<M>`3t~;WkBXgK
zyy_dvgR6l@Q>(8}+AOTrJ^9#dpOXi9p3S=Jx9P3o!_<&B(<7XP545)`J?xkp6s^{;
z<k_~Wz3X|F)S<+tFh7-gb=RPxts(1HYb#B66)i|wv0DDb+I>;mk6dBvU7>PWHCL&3
z*2<Kg^-q>_&)giaQD^=Ui<q-BRXelxcNFZLZ4|6>>7UobVzVqY;m|+Yt!HkonBg1#
zX#b&q*CKPS9PPTYvCYU(XUV1bOD<13|M$N(%elEZQ4kqS|L4Rc%%<Yv;<E3@^uh-$
z5=_aG(+?hJ6|dI-Z8pjc+_qxXqP5$%KR4zz`5$$6=Reuo^Oov6oi;giDe02laxqb!
zy5DERRNt=e&AJ};X&>L)v!zQUdZHiSU3Fy7mbN=_QER*%12{S+xvejsckjLJ`ttI;
zyVny9J4_276g@uh)Hq97I^mre|2E$Ktvp^5Q+bjl7+8c%7#A?qGcZ6-B=KO<T2#$u
z+bqBK?zL62nX6hZE?cFxQsF?oVFQnJHe<sfKZ(^m%1&2ALzhN$8M{q(blR%4YckiB
zrxr$1b0m_T4$DMEyRGpxyV$33R7pmYPc^2?yVt~$w`gXJcZ<-IMb(-UFRWAA<m;<>
zs+5miv&}hp(P0T4)B2-JH{IRxsOaR$tFl7sS}RK(OQx1^mK&B?>^!z+y3>`H<z1If
zUMzL7R*gHgS)Ws9%2k`iQ`{DdEn3HX#AZ&j*Nd2CQen%RHXK`W*di)&-5o#mgpZ7s
zij^L50n?j8AFw`4`fz7+*PgbRx2fl5ZL|@&v`)NcnqH}{&OGi@tPhs|t-tV9bCIpb
zC2wV>^`R>l_=)UxzMrP8c=D#3_JMW5JYmZhtudUGxT9B(`Ks2pkZMiaR=Ful-v-HD
znELR&)KlBVR@bB6*oJ29sK`F7_ro+XuG2)jYu)La>6?z;7tBog5_d)4wVvaLw@Qub
zQvQ}iu9{ADO}?&*{<^@E#ky`&ODpOZCGF+f>0=l*pEXS4q``b4yO8-R`dte@hAcnn
zD$l6(V~PAT?beb#aqB~k?EKeWs|<WnxcPYB`jqv)9gl3~=FN>;^`k4Qt0t{?sch%R
zO?K)>UVU{vC7xQl_?DsE(M0X1JOV$~YG{7Rkrq3hy6x6=Dd$i@)@`@*BYZM>1v7NF
z)^9(ycKge~MBY_)qF>fot-jLvL2F-^JmU+wRoZVu>=c%M;&MNr8Xwa9$)RiiD~GNP
zQ-d~za%6O93w6am=1@JfNIOu))JsfAjWLojVd^5O)+KA&oRwBx@!F(uz?Um!<y3FQ
zNY|FFp$SP+&Kyx%GnN`^WlZ++(MnmlYSn=(=b(Ct6<aw|yiRo;=vgHxk`dUlnlp@J
zR>urcqm{m_5u&LcSxZbs!dyic1TGCUP>m2;v(n?#lpdDVj9UK<MMD375>Me`Pgv76
zNm7#G&}xw>Jv~}$T_ZT6dV_SDu4qQBW|<{&X<=rRV1`?$np>z^pux(CQ$45n9SvG|
z;h;#brWH%Qo}h@u|F^S^b8b%PQf6Ria+txu)WFrK%jA%DJ1uuxy4F<9L!~Us&9-gZ
zw!7-6uuh=PmcVUh3J*E`gck+HEaEDd<LXirH07nq#Nd{t-U5pr8mRP%vKR(wCJ3z&
zT2a4<vuVY|+LcUpOST=m*t^)#aj~?USuZPF<kqFBxjI{y)~Du*35$iC);ijnIyLE(
z3Dc%fjlVBrR`ERRHVV5c*>p=S)pt=^)Un<yvlZ7&dy{T#3z^B$e=j^!JfqO>mUqh9
zl&~#Rx6Ec;bYaoIix1UXE7r9JFDcozf2-EZlGndIo~)kK_@Q^{mYmt4IT0Hs{dCv5
zVmT>Z;N{BjC65E@GoDS6``%&D`qt~FneWt`wGkR$!g;1tt$G|H*LgN5DfD6B^xmZ`
z^7R2vMZ#6oj)r8d<P~!I%k?K~RX}2w!<I>>nA#lUC;p7@{#d7f^v8bfx2ZgfPOLZ-
zvBYu7rU14n`z4LGgxbsZAAkJu$De(ntsSW=t~xG>@><Q)>8zC`B*pz{>u;^IqFYt!
z_Q%hkKfn8GSi~ByWYJ8uRW2t|J!S^}*e|30Om)-J`pP=VjI~m$g_1?rtkG;*IpGAi
zP*vQ#yMp$iaua(Zr@3adxpgG1zEvG}H!%EBzqiDhlak7!lMLjhFJCuBzBRn{;p3(3
ztFxoCu710J?04YTJ*{tF*;aB@$bHy-_qyjjxw!w^w%xk7>QC6(I^C@6bs>SS+9ADC
z8cVZgt+=?zEIX&ZOQS1nWysakuzl4p_pg30Z+EBoh1j#AQhpnA?Y%p9?<k1775PE;
z%#&Ag6?x&+1$WKOSwpQe(<WVgAhvn(ipqyOW8bn)m0Ni4>7D9}LMk2;m0TK?9A@Vj
z^Det}QOTvlNx(@^$)!_Bphc0xi8*nDw3BdhhEq<ikP7Fv!-;Ed)Zb3raD#W7G;hQ0
zgI!!Fjb@$v%XfVS_eQfj3=9p6KmR$xz{$YC5X{K>pjI`&ZUv(QLr4ST*9i<(85%A@
zoJ$z)@L0W7<<t~VXc7?dbXpmeHETiEQU%8A#;+J17rQkpm`JVsSG6+0h=F0sr;sVk
z4h){JmQ1<KFgsX4ZK<HzREBzHhb4=Yw0vLn8hhM}y5|Er$!1dICU3KP-JLTh=$vUx
z1D#|O?8m^sV1Ra<e0FwswAj`y7nZfIWjm0|b|5;3VX^NPx7%U2a~3CQ39I_@ZsQIJ
zJGepW=(by{lT@xPx)RE|?aKj<f1jmN&29y;f6Cg{6<Ys4=ggMFi7Nl4b55;3?CQ4Y
z)TNn%rYWngEj%o3c00?#{zz`hEzjr;YGOy%=I)Vf4b09yc6PQj{~P}PWe+l9BTluS
zIy=cYK)$E#%B-WD-);vR_-xg?HY16(?v?mkU7wS($0F3Wh`!c3rs=*Whj&3*>e4{l
zQ|)cv<xL7xkFK3tT5t9H<f(Q3qI1r~9zAJtB7dvgg0Jk`Zk%;}9Bdlj&Gq5R8S$x!
z*&ZLm(t`eO_L&gBCf9Uj_!@%~ahql&tzNCQbhfU-^vEzt_IIu^Q5BaTYrQ&^dg<}%
zy0yYmFSC4Jt&`OWZaU?s@mS%nc>c}Ryl&mb+{&SHvsNABFIi@~M!q+o{$r;1Yo09U
zi=7+SEUAh(I;HOB%o+1dx+6ASX|>b!w9{#=(c!<NYO7<nr|QS&*=GvdXS|!5ee<pD
z{O!|^JwH|H%ii6#PG|G!@ELO=QdbpO7WbS!Qg!sz>)Ta&i$h~4&n(z<JV#AOvW#CU
zy!GlMKf$Ttip6@$;zDziEczxTsLO{hEQ`-fNy*>oIyvgZ>A>1ZpY3-77fVjo@qTnF
zbxPcZn<g3ER~x6P#;uuUvg~4;s@$~5?1(7Skkdl*+IrSRY|-giX`gf3ILp}NRNa#$
zwWs#IuzRY%)BD}@Un^Nu>i@hAo2I+sEc0iF-_7q<+^~D)omhLyY}MZdOMZ8)h{`cA
zx{<Xyf%(IYOB**X^!j6JI7$DoPKwBuOueX$lX;w8>lkgEaazq|de72HC;fRO4TX>K
zq(&r&_w*ziNzOQ}t-;<i<;o`QqghKIPB}Sg<zt=`$0QRBC#wZ@9}CEenpkqOezI2I
z2E&QQ5+|qm%;?&6#MfJ^Poigrn^DSDug5C0rY%{PloiQw@|fh*nLejBYn`%6m3Z|?
z&M?-hP&`uIZ%%0GRI4-RW-Kqe8e<hJF(YZi(S%<q$JDGI_7oib+H<%qkwbX9_Kky$
zOe_jc96#pTo!{xWGC9jT=)~Hlq$J)+NtyMbrb{lROu3S{;YO7DlgqwJ7m^n1A9~a-
zeB@}ssy_yjN#WvsN{=d%c8YH0eAtybNl#xU^vH*!1#2gUw~0k^J-M7OGiO%j!$Uhn
zAI>(NIjQ2qId-4mo{CM&%eIDI>szb5Ea<g(n7Ys8ZlU6CgEIzylF#H>{5jia+%EB_
z;;Y;=Wlhf%w}_2NnYyggRv4XJvLP}-XW_(Yo=d*w+{`(YaxzLxBz5z08Ht&ewbM_p
zW|521*&cLjw~C9H%Slz;ofX%NAMK6XbY_;A$IFVjC7ac_H7~uYe6}s+$gZ-jQ{$bU
zKfj!ux+$hz{pPvIbknUn9{e$~IK7(PXZ2dysJTY#bo7n3ro_HZ+w=YNy3e1dd#qv6
ztUv7M7xc1Evm_?#&(a!gp^Bg1Zru#KE*=({P-eF_^|;LYoUQlX9*>oG)7$m1BJ$yk
zBL!RfOL-G)KA)|=ey_0g(uW=E*6fH?)-0NQJTlj8hqzkBmCJs?TOM9p9%^&uXw0g0
z=LKGV;@)ypym#-<O}*<hZ?0UXd8^vw=;1l<z4Zzn*FSvNbIiTts@%h<i*l8(d%_}P
z#GJeJlrK#eTAtIhG4;muQn4)C71P5yZOlI3TAauAGBN2=fBNLC(>fcI9^8FoST^Oe
z*V?3*mueAHS3Y(5!1CzQ;>Gz|i_bZ&J9X7p+iC5Az9(L%CRuE1dUx>BB<=36tiNn-
z9W~Jox-oxC)=sT0UR#aAUz!vw_BJ`J7UdSd%EHp)<g|&?-|F%4Y?&;vrDuO;VbN-x
zTT@r&OKsm8x2u6cXw#XLgrnU$krJCTjCk2nvm)c~h&%}XRkdjPMO79tZAZ|m*p7~l
zCPQ$4M8L%@_Tyv;P^Uv;<IW<a>m8n+p1$Z9i*o(V%?UYLH$pe8P7Kfb#}Gcx#o^C?
z!y8YwBu}<H9?fR?Q1S8Cyi1E?7oF<p)m+`3cj4ph^L#ptcihW9F)o;yA>Q(F=QHn?
zX*;)BOnA4Y)FDK)Fd#G_gyZA7ol-4cs~1S_6iW<Smgk+^9oD%eFet1`%XdrIqOM6@
zT3#9}rv$pX){Cl&giHwx3Uu{!g)-l+KenxR)3lZKod0}HF1z(^__=oL=jiNxFV5Y1
zu90qfE{B&-d(NFlq5r37w4Pezv92vFY-_M+$Oa#!9Ho_u-eg@ZvOMu{WlwkK;wjIj
z-Odee+B9LhV4>ilj)&6%&lS({SUmmbMfF1)<@iL`q^8yvpG+;^vg2i+o}|{pRKI1x
zMYDOghb!ys_B^5RV9A^1sm?1_ygIGCv@o$}$ELp9d!NTHnRugr%BCwHrZya`c(CT!
zv~I5}7W339X4!lSEjYHOqG)Yooa9ZtxfVN8wO%$Kxwu2OyJANy`xLERinpfPC_WXj
znbdvibei+g#HDdwnXBtJZ=S5Hb39G?)ODNBb3Z;%edPVutBTF*Yp_6)LHLeK2Tmqr
zN_st5w|wQRl2;kuFRX5zba8RIU-<InY7uGSzBW?|F5Y-NX?eS!!rQEVVbM36wsYKJ
z-{8K|`@-^t;!DF<X;iE7YgX-eoGx}Y^i|KxiAQX?PDgAkEUnnFn^$(@(YSh@iEpEJ
zmY=V@Z(GgurT@$7N5NY2MH1FG91Q&wC8-md<?GCGQoAKq^ihp}=aCN;v+QaXh4Z9j
z>bfmX_cO_=sIil=TCKe{#`WR6jzXR3abe!;E-mLzmT_8lZPi|*`NCo+esq4){4~W*
zX#IqRA4O|47JgE(U$tCTy!EAB|3tH*`lVlI<n7pX^zxdD6{mKleR%Ly>0|1&jZ%8t
zm%di*aXxKiotxaWFErst?E2~ZMRitxnCs?z&}7jUQ<tABoImD<wO#X-@(EpO!W)#e
zm?g#Q(UMm=u20oB)%YLzCa)COJMC;(&Wux+GIa%86XV6Tc~fTTx7LK8`WYwqIPJpg
zWEqwE9~11P4K8~wHH>vWcJ^iWR?p<b8tq2sQ|&^sQ^gmFpKz^hTHn+qA2RiqsL0BH
zt*%;00SlK*^t!}xh2=umOjXY*OEMHLhM01#^_azRFjAQ1pvkf+SA@BILk!v&m-x6&
zi4<*(3fi(XB~omXj$)SUs_uYZFR2M9d9|cM40)VY>U9KDwT`UTnyly(7^bm0AWNH-
zmrF`9ky~Tolz<bfmDX~s<yaHwED~@bbiryajYL=ew_Hp4|7*RP;Iymhl9TBolO6}2
znW2&zSGY{Fret|t4b;{;#1nARE9H>ds$Pdp5nfrHjYg>&r`&@Y-8~nrTFrXHqllqs
zf9teaCb>H~gX)j^t>kz#H8(G>X(`jP1I-a)+tOy|oC$6TjaYe!)iS{2VQ{0y4p+@f
zx*nn@Jwg|T#4JqcTBoWqGt_B@#==Fe@~<XJEp*YJwIUQ0Fn<<j=FZf)vN`Cix2aCo
zC6E0RWo|P%I!@WLbjhaEsk+H($vToM8$#Vbxtj%~EZGzk>0R%&b!tqe+0qTU-U&B#
zTc@08{WG;ZCwFVljFX+wJ91|8u3fukb;zWLGVv#re^||p@fU6QA-rk6hWaGaiM^bk
zoM+v*xtgO|U84PCxYWxjRUL1ZujoFhZR)!)?oiR?w6hVySLPhpGnG%^qhiIvwaiDl
zXWiVKwc@2~%&K**e6408JL(s;3x<noTnP*daIJ0nwd#n&S{+f(#iAY;C$${S)YufP
zA<{Ep-~H5Y>o<N|zqNLL`lB_SDOn-D5=^P_IU!H&&IY#Wh9=!uI5lO`(F85SD2-q(
ztCV9tC#FAt`s0tiyz8ql-H0$Zp%a_B)_Qw6E~qt1*8J|JxBTMd(8(O9wix-;OD0a$
znW;82Y(>_jNVkQdO?!+|K2O}bLGxq0d_s+~(Uo47tSF9)@$AP{_~uPb_UuWWIpffw
zOA)-@N}2A>hdVz;EsbZ@7w@ZFoHF&L*2MTH|L_0$FFohEbnBhmSqs}`a;L3Wwro}2
zf0m^s^WSLxJLo4^AKH~`9OQLX<KjxytSR*wS0-)sGRg9cT3>zf{_S<sW1T-f-9GK2
z&fgu|R;^kUx##QYZ6`OZpBG)3D|CLH?y6O*rsdl*7fgFtCG|RY`<&AqcZ^MEz1I0$
z^=NBo=#JZ=p`kkWs?06Rrq2N%;;E#>5aKIzn1Mla%7G1#gKeiXFvYOAI6zT7h~>ku
zRaS#R{+Wih%BgHi@qPUahnH0sFfcLopZ_etpu)hw=)-)u@#7aM5e8ljttJN(W`zI-
zO<@M+rw-3U0~RnWSSY}-)YQ@EmIHGL*QEA)-U$I27Z;r1Wm~=}WPua|i|wjV#bv^7
zz9vFdOGTXp7j98&%JP~tf7TQRhI&nnj*#|MQbzK&TR($(I<v0-?hW@jA(rN_?rmW9
z4$uq@1GJX|aesz(>_T7e2s7pkGp1Esx0alYYPw>wYPQ+LO=dx2w>54_2QBJ<Z@A2u
ztE;{(EmY-S?y5!ghqV^I*~Z(Pbam^ttJ`j_Q2DzdwCad|*=^5H^*6VEtG^)2_>MW1
z`<vs&pnXYFhZg+IT_sV=+%oThnP=P+X;JnaZ5tNZZoA53sJ_1av4s7GzX9L&9!R^@
z9~#n{FPMEK>a)`JliOBI4DZpGsJke2RmAG>*KHbySuKvYpTAo;J0|yX^Wt?9#|jE8
zR)6@bylZW@&ZeI$jC~h=7C5uEe)`#{CEKbmW><Bsz7i-JzAam_`CCY~M)x(%*Q!;C
zzivAvE@^L{SM&Gf)6|EvP9KiCd^o$p=JR>>%<jcfCofLhC0ls4&_|CgvOwx#l<E(A
zjdx*3r}^4F>B-u<{BFRpwk^L~lC>ji4;fBf`_8oCyVOy+#}PT%qPE8juJQIJ^{3Sv
zw#_g)ShqQ0MwZf#h#H-EZtsU#`@~j%%zUx2O4ohSRa>#{iy0qu^qEdnh=qL6iDm67
z5nHv3+nr&fIz#`#y1q@4-G-?d={>i+u3TJoUh0N+aA;fnnj4G7+9c~XXS(UEF@;cu
ze?2s6d>1FD=7wF`*4sOEORk|;7}wQ$*4z*=iNv<Zw6v_r9;$6T2C3Z!7kvYjd2|dm
z9nA_3(rjaskW4YvToKHpCgH6$i{+^3r^y^yetk;QISUFjExenjthAb38Yxh)ZQG5g
zYqwWj^bWri%b64rk`y6yWP@sFt!h_~H_JvHp(Fby9g3I+qK<6Te=+_1(s*wrsrq2n
zZm(%m9z4-_m@v)tYAMsM8H<%(?R2r4#nZj&#iVs=TXUmBXWY0W5t?}Dq2}7$Hm+>l
z8A+?7%r+b{?RHZZ)A}vLEv6jND-m_bB<Y&U(JvcO=Vz9_sOH%s<(hG{f3>?<v&bx?
z);?XCC|=i$tE?afPyO0iQ@3pkk6c^OozS~<%A<#ewq0AgIa1<i%^bIgZMsG`C2Jx!
z9i4u3TD*AoVIv*RHL1Fu*-jgEmab7b8JQMlW4P*!+N6#1Wu{B`Or60~xUx8O)27GQ
zBVV&iEmkc(8guH#=Dx1WZ}^Y4U;5*@Hn)v)&9=nOY;A4f-oPtYeb&p(t+$*yGxB`j
z%w@&LjprFZjc?7WR#)D5q{viPYT7j2tt)%%ZiPOdUu$fZZvFLI`Tm$EA74)?DJk{U
z_07sminT30RAG9vENZ>Q%KHU-r5^2mvpnQO@}c>eu`}AeB{uws_qew0Fmq(a6`3`Q
zUS);Nmz(n}-Oh5(kE`!Chdwy;Ri^KFz4FAx&OD~xPp4Qv`}uac?9bxaeDh@3a}zIK
zO-x$u-X?r1yW>;v8F8l%*>OR0e|lOQEN@8`lbe3%+Lp|~Qx{@%bgRp*?Th-7W7_V`
z`lQHO%1^|0%i{B9U+&}>>+w3Cjwq7rnmg5cOX|8y%WE}aXRX?!a!ki6?x?ypmqo<h
zU3==)5>E38GhICKq2<#>f4v)PF7m8rT0W_>DAn~+u*8N>T(dSbA9{Kz>cGW@Ek&W?
zPC-vjbYC?!RjdkRmuOmb`B%{T7wz3aXH91=+mw)@w&{{?;NoAchhjEej?`=p{m#A8
za#_@o8HTloUioEC+cH^M{FdI5XEU=yX3Uyj66<+3DosY{XwskH-}4VkCU$cx`^-vO
zE4pOE`VR|Zw?_SmpI+$9q|BzI(J}p)&h!T_n6;<5v2fP+B#SKu&0yRP$z7$pUjNF3
zGxz6}t^57+cE9PZe5<l+@#SmZE}ML-<jwQE1G>Af&+f0T-WnD9;`8o;>#VPjeY)(a
zqO+&$@wr>`%6c_6X&dKk*4eIeZr8oD=dyh>ujfUEhCSVSJ$CBulA9*4w_G>uiL)%8
zZdp9BM=W9*S7dazQ+>oV)y|~Ia~X>z77O+Sc4;i?(l{cev0%kwwqphnN5l+SdmPti
z?SH%3tyggBDpwJyuoW2_#llv<-df`@L6w>H+p6E8HF5WL@0>f`dgq+2W$((%qqpAP
zz5i;6QpO@x%M`;E88ckOrbcyziFr*(WOq&2dd@`WWwNfa)ZEDE=*;H&i0mm*PVOx2
z9G0wBbN!YFuPW7$4V61|^g_(ah~A8tT`P|kONmvr8C^1*dUfj7y-^Py^TjTD8!}zc
zJwx0@c8a*WJD&{S#O|e+9+t#<v4_a5O8cPgv7tiGGfZrw@>G9OyPc8ZEA^6<&aYT4
znJTsE!Nu9@^!OHia@r$Qsbtd>SI;8HCEk3v&mvA()~ev8jmnXNJ^I|Omp;Ua@C(_0
zTKQ6Ksx7ydPLycev@Jme3vVso_h@GD+{q#zxu>lOj$0|U<<Qpb*2NR{PMWu%O6iMM
zHOIUr{uJ)Rwgpv@*JDcdYIe7`xAV;teW}@L;qHCu%Z^xm?u*r-;fw0;EI+Vm<p<q*
zQ9EuI%}-o&6s<ifHQyhaQ=Bw2c%N6&yhSm`7M(8??b+(K;=AyT<%fbFY5d@_3)1+(
zBCoOJf6zMa#fL9nFs!lL^--U_y<e`Yir@L-%a<Rf+A-F!e$a3F5zi$t->YP;R|T)v
zyk=Ja)<q%l+*!G1(@x!R*tIxwcIxa@O>5<xll8(UHQ&0O*cY0sztrN@SIv(i`&I^i
z3VgBnrpIq3d8L3KK@&f)$cHTX)5<ab)G9$ktqE_IXir+zbZEuY7ROYjRVRbO0^C?;
z1evsEIb8~7I2F~baHZ>zv%pM|glR%q$_gpdR?V2~Wyq#*%5#O7kV(gZHA<&ecKUF(
zN;tMiEX+`?Z(7DRgL9&rs#K7HV-t^}iBdvfqgzPZL>>+Ug+m%wx(vOfRC!n=I1Ihq
zG(8R|98mZlGF9RKtLa`-T3$H^Es$zk$t#q~GL2ayY{8bPA*UolwuD>>iFD>z%XBIz
zYw7|Yr&Ge75mUBIIUuR5>8<H|D@d_q)|90ZeS)FuZru*MR{#17%L!G66X$}Kx-&0O
zd9YNwZ>CV7&@^SiUDvLLy_(Cl=*a|i=2k%&5#fc48VfvCmxRRdhIm<MYGk#DHYl7>
z>Hj%p=?WE>A6_fu4@#Su-ImVD&FNCP%GA^om9a7_WGk<v#I%KNJl-CMwS}%qq$Wiz
z_GDZcqWxv%m7qBfmxb1+g)ZYcnmKXCTEnnww?n3cs)`y1n;Hk3n)PUzifaFe)zF(X
z_wBUF(V`M-W=E_znsV#d#iWZNAtA{Ur$bXi<qv&WYNPT|J<)rqyT>d0_8HSoCq<_*
zABq$2KK}XIr0-YcE@?m5x;V-dgdA6OKiHvHbR)-18q^Um6hE>nwq9mpje5AB^`cuV
z|EN#zw|*x2kiE<EMbyQ$QWw`sYz+CLCvKUWV<ydW+UQ!yUhdVaJLEcVZ&#0+^rCqw
z_d(x`YrPrQTI0A1i>F<?b~te@(}&>gex7<PG6HjjvfWZuzOoiuot<^%R=}=Bd>o6r
zl+$iA>M*SiWVKOzbgE<O(xs~PVk_3TFdfzU6Z&KNqxjA`RS?zv;%F4N#$=~0D$ZP2
zLqkoxKO7divf>YHszhE#Qdxp0P^{~uXLnFXMwF+r%bq145Bsb-)A;05rOiBl<*PhN
z5(_pa1qW@JWTF$|EA(mdsmhm|v$i%T^shb}5xT5vt6<WRnJKfho$9BBToRo$Z_<~&
zu|oFt_Lc&_Lb9^LW`!whM2dNAQoj`M{p#iSoDjQx8`>{LY)qY&wlXndS<sRBp0)a`
zU%%h&$-iXsL;co|H8oWlwM`-Jf8%fdD|`O)ec8?PpZDZut`*&OBYWwzqGxZXhA>FI
z<@+GCrY!LR0|N(-2AilO1B2z=`nz|_%UKyT7z0Bc!N>oIFa=#&wOWvI)v8kqOc@#-
zjDpy_98ShZ&)&Iv_P4iYv!#9Ae=F5*<-EoH+kW?-n%l1&_T6b0yEJ=QUZz>>iL+vN
z9QGE;M0@4U+_~gtxw6`X+-bK9#2QL1Ir;LYulCBF!}9R(Y~QV%MGO4uXDnDVxn6V4
zmc{Sb8P9sHJ;1=BWp97Rfnfpz1FHeQT+P0$y_4=5H83zRl!)kD4G~%ydLU22Zr*x^
zmW4qaO(842mWVnvsAw>7O%&i~KCplxL(+()ZOKaifD4(E6}*<e4-L7HlEKU1`D$tK
zQ6rvt4vwZ;8CRCN&EoNCSTd#2YuV+mp1t+LS3cj){<>ys-q$I)+jcN8FkL-k7}d+T
ztvNeWYj&<eZpaOf9I*o-`w#XU^{~I&#QvSZ{&Cjr=yi+JRx0r<l~|oK`QMkDuHi<v
z6l=HLIwM||n-%}VSNM+bH<8*^xtwutw?uY7)p6g$d~br?l^n*;VJEJws@?r`{jIaB
z|MnmFwy^%U-sNZgy&>yw^+(xWc($tjWAD<q2cIrYpMCcm+f?~^EDIx)d_;KFHpwe~
zzA`z|VEP-`?sw|f#4o#iZ}Pw9yJ}xz&4C|RY>l*!GC$t?@rZ5v^T&@LJZjt4ocnmM
z^Z7kI3zDWy)Qr5sC%ojy0tuaE>kUdDZ3?fGs|}7cj4!#>f3rT<{mqTJXQzK$oUwbh
z=GE@dThgv;%Q~el=I&04TpiW*c2QX3<NkQ7*XvEsR<GZBSGKHTdz|c+w|%$v&wd`Y
zPF{Ao`{Ce+D?hFee0S)<x83fcZ&Gb%RjRLMJ+)VR(|VC_Yd(rgt*TURteg<_NB_K=
z+N~>D@iWf2KbyJW&t;?aXVdDZevjO?s0nn4h;*)WSew~}rP?Z|LekPwB}FBBjs;H9
zHafGZXNob;VU0sQM-HWi9Ql!OOj}}^VVGf<orGa)4^Kk!!)^(~W_cdNHam&qkADVo
zztK@O?AdhY%*jcUrHqcwNV@8EY+A&cwT!(yn<OKHr9wNqwygT)t90b?L_hU<nGlOP
z1+GUPuUL9)Q(8=^#^vc(6XtAsni_gqFU-|4_0&mmJ<Dy8+ftV6ullGKCOWk>;a9|Z
z$)i(?m#1!vd4A>Sxw*@BeziOJ?Lb7Ycl<gpi@qY)>oH!BEKjOlk6H1^@<`|P7<IvO
ztERk;EsdSH_1sd4gs9g``F3v>+Vw7NmDRiY&5qYruMOL@R({*fnY==2YoEMJa}EtF
z*OEP6Y$WA5_oVZVcWKT+>7}05g?F1Xa&F%BIL-EM^5zX?yVXuze|A+ObhFDrvqgyp
zvxC-5jt;9$=3Fv!uQ}(UnRgH6owoepGkNBrbi2;Z@4_AzmtWZW?Iqvt&0Mc{&eGdh
zy7)-ztN`VD9cA_}2Ro7%o#>lz>|*h*?Q^3m7jNF0Q!=w^Q}Oe4wtFfzu3eKpC2@Yu
z)0ewXOK&}=zHVLI?CZBXUmrd1;~)HLPUuDxonE`{_`K$IZ!WxckE{reP1>_nuIy&T
zuZLILOj&M8+zNY?+p-|2$w`DiY<2&7zqoG|9}XXtSyPkrHQ&FUPk8!TnR&BQ<(57_
zV55=a>v1IW!`4qPUh8drux!_rd6D7mX(u0FJI7~nWL0j^BSQ{nC%-8zM_xbJFfX@a
z&!T;cg?n>d3oO5?7Ij7k9mtwG{mePbkT|PT{kp0To*64&Uv}HLanGH?Sxa^VUz_sD
zvg_(9^@VX=i@O3hn!08!oNZbk5@)Nl<D{SH<Iovu8$6#Z`n1ANGjOA6pwVT4egQet
zxU5ZUb8am030iT$`=`o|rGHvGHX79ni&{qQpW0ZowO(7)V$(kz&6CSNCHnc=Pj30=
zoS4-bwBPfm|B=7$uk0><>u>oH`eAm+%V^gd>yDObzlskGzhb6-%53s0?N{2j;_5GI
z-%`$!TOzIaBJiP&rhB7y(j2bnQ&An^4c<vp-PA9wereRdB~?B%WBpMOS~qo37vI90
ze3xWb@?BNDwUYmU*S-#UPuK8^PVxak`(0N2W%0i<Dg0Ge=s)>uX=l?mU7V&SEUYuF
z>txnU{~rz?`2X%-w+%Y00HP-QWbjQtFrAr&DelJf#m87w>wA)J-Fj}daI15o?n?3b
zuXDF<nm^b4-h<ZP|Ei7&_r&HllouY6Dwvj;yN&z$E>D#uUtd+9?NQZOF(I>?ch-qg
z-JI<^H%<!M%9-)(NOR)WEXQ3DIoEC{JX?@-QqZ#}Qb`j8wIz;DE=igcwz4NlbXA^V
z%C*OmCTr6ki}@s-tnZ05?AF_w`#AbQi(;dI_0{rKAAh`T%s8-}bH<^}t*g6s7aooG
z%315-Z~;7;!@$76yE%8;joG=5Tv<^Ix<aF)qm5EdPFC~HG&-BMIU;LXSht$DPnfTp
zRBx7;o92p>rbfMPfh(uzxQQG|@>SEgw9)C1L9oLiUp5gP!A76@Ne7h<NI7+j-IC5-
z92(`O95K^y!HKlRVTO{tS*FR%ifi2>j;5HdxGXizIcl}PmZH<wwxwYcJT@f>>s(or
z<#kEqh{w0po)u>jKCVpS=d6r2U3F=pQFBh1=$e~raxQgj3`tbx(t5J-Xhg@MqO}p;
zOj{buBGguG5tp%<XDqQ^x1Kj-^?{08mC<u{N49Hf9*K3h>u#N8D7kj_c5CY?D^Bt)
zi4iyzQnF>LjcUJ8QnTo_E13&Tc(s;iok&cY!5gqgE__|j9`~rz>}yOss#bkZ-}<bw
zKR9Odbk)jPSBtdfEbb`u?0OjWsb4(Tty${qo#!3uQ}tEk9QJ5QvV7X=ePmO8(-+l#
zPlJVBZ>L;#G@9mEKXKx!Q(JVy7+b}s+VaPJxq8oY`I5P5QPa<?nbLmfclz1XuhDZJ
zo>@QT^6A^R+x1iSoXy(XSnYi??(ijTjSuU+zO0i`Us`r0H8T4m`+~h1RV-gcY*`H1
z7dCxav+%{VuJ#SnY$tZ{=mq;sF*FJOvt~`bq{*5n*ENi-u2036+OD6kZk^g!)vdoI
z&RA#lR!zR6pSP7<ou0M%eC_9p@BCI}d@6kV_IzknwO83@{-k-2Z|z;a<%ep@s*mnm
zKh}4BSns~2I`nqn%4*>|awn=o_BK?nTJ_E0Q1x2&4M*Yw7uu~fVBQ*(^~RL3^Iz(N
zxuz<cvi$02rkpz18#v2LC)D%o>eNk>ug+M0sw~%D|Mcm}FV&B%{KB$2xPQHWSL%mP
zvEds&t=FFZeqVdSt=oKW%66CUcitpEC8pXg+;7*arBib_UgQQ;1ip0NWf%C?@8GF<
zmufn1h#w9760*L7e{$=`i0KD1y&tS$y|v_2h<#{K)?c2+mG$)sqN0BfgoOWIsVY1{
z>By<2PKOd!N_cCm3v><Vn4z_*s7rH-(vGKIi@TH_cW6&p@p!7}33ZvN7R`M@4=sw^
zRkAd*G!wNsqj=d?CPw(EO<kJgrjixdDIwYzHR;N<C0iydoG_T!(#vpx$1}-W#mL!9
zD&U|pORq?j#)c_}f;GeHgVu0L2$?b_aEmPM3c4CHwPE5EtyHcVEImx_|1>#%t_WfN
z>$KO^#rdMJRzQ@P&^Ke3l#|S&u31aGy#+f%wR=1h^*p)`y@&~w((Bd;NEX<rEt-@P
z5^-c%V9Lyhg%L-CRW|vo>54eAOzB9{NioBq3sF)Llfx!OaXWioa$3Hnep;hamZfLh
z1jlBLLo1F7CL9Uun0(Yh&i>lj+*!HXa&8Mfn(B4%!NgZh5)zUg8(14xdL7j&V%46v
zEjQaNH*M{<wX>sh4^5GgW9fJ3W?Y%Vt+nbvX3(Zd>sdqmnH!Z)G#xN9(nwi!z{DeI
zrJTx&FH&Ap3WRJpc^IdKhGvCEFxLl&1qv_fs*q}8Zt(cDWNMd4%8CulAsR0xI5((d
zEt&eC#dB%M#Q3JBQyi-WMgLB`b;E4iVo5ino>Ylbh7*p2g}Ur?iNEw=)dANN)4x`P
zHZ5-2zxvR|kRm_*m+b2D7wt|jjrUT&HSvr5D(j&CQ)<;ytUO+5FPYD2r|`x5rq*|c
z`fnb;y!N@qth8Op9};|PVzt1hm6jpx40<9<S9mvSJ!LXbn*JifV`@BPWmcVCYpDN;
z_|_lur~ZuZ{#57R`b)4`WXZ{8Yk8Kgkn(mAR$bC%5VcA5&&oynCp-z76?Hajal{o#
zH<ztbf|8OvHc1@v=bTzM`G|LzQRHgTM5CqkQaxI|+L9U{qx>&bh_22#navaC*|j)u
zf^TRK=c6t2CqD937W3>dm1qt+wp32c{nZ|yHiH?yZo;lT9v@BPSI9}Vu(VD}a$w+8
zzy0>>FH@gwt3ys_T`h}R9UAVS{zpKOkMnzj|3Q_BoJ@5J!V8(4U;e3&&tJLy%j(VL
z)yH?;ua92$ePY+0J-JU~XYamed+pcV@;yCaGh80ry07)-?!7O2pL{E<y?gEJu6Lix
zwPQC{z1;b3?%mgKH<_7TYw*n7wsqUBYqzr_IBu}y9O&J^utBB4lVK903X=!R1WtX(
zX@-+`S=B2DmOkCVz{u+U{AUM)5Ca3lGRF1yYiCHY3e__RF)rJ>P^mRQ$eV$+R`%2?
zt*(V$9$GD4t5~Pb40G+_5?QJH`Cu0VTjOMfTxGAu3Cs$adqZu53>q#w2vsdv>L4Y>
z4C-lU2Ha{~?8`K1f~uyZ++>G8Ti0&C?&O=r+ps0$>eg9ex0TjT%vCU3bZbHIx2UZv
z6n||E<$u3Q`A>azcG&NgE|Ojfxl&W2wr1^byPX}Epu07Hhep7>+i6?>23*wp;C{p7
z<09p=fz!8Gaz0b4>{9P#w7Dvo>Tg?f#(v|k#fNNedsS}p+w|IR+ok!N8t>_S^gpx8
zJ>u`A)W%}#{IdJoULIa-l~(ZJX?*{Y(zV&D)w7kpi=B*nbbGJt)B4zFSIW1g1^u}a
z^jY)S)W`B0BC{smwl=+;R(0n5+1Z<A*X%YnyxH@jXqQebZ*t?&LhlcMo!4gTYJOJB
z>YuS$<LAm*i=QpaKIVK(_*i7q$DWfj-FwcYNp1B%8*<sv*0d_?%kgElYwUR{*6azB
z(-!YK`XKdY#BS}-n-Q_i;ZB?8)^nZO#jMAgGKaBF`^$8l%cA>D#Z0!`pCx9p<^0*8
zW6Ng#Y)uxMwclWE)XYr5;2Ss0!cN^V3%e||u+?CqVb7VFMw>PqHfC*5GdPoS<kZo`
z&WVX38@r88PEAeanL07FN3zXFEllNP#G+%NlZA}j0u0rcb|gJK7|z|!up`Do;9)`i
zLyu>dbC*5rT2uHcVaGW&kH;1>U5^zSEj=!CIa}-Tm6u^YYCdZI!NO{4{=sVgC%^Kq
zR$As9*sHRZ{nCrhlFYybuVO{S-6lryExn*ov`H<r&@!m=$eG+=!x^`h<*AD-R@a`W
zyXjE0(Usmco0c7mh}z1(j?FM9>TqJVv}k`%ME$`Yi64h0k{?U__)sx3GMLHev|U(C
zSjeGi5nAW8^|ZATdNxc=7o9FT)u3m?l<Co052d_J1>7d}<ZMzsT6i=qEalAln8>!o
zc^hY(kDRxAch1yK-|T>^yh#$h&JnJw*5*duHcITu44r-P#G|QOw%u4A^lI9jgQ7h-
zHw<>zEcf-SZ!J9VtnFm>>Ju|R&eE2us#&>hme`ps(vc~puBRSG{oZG}cJ29!n>)Xo
z+ufHlt?JX8&fTr7(_?gIv#eL@ysxLqcEz&w81qVASqtK9Uh&FgSL@03sja1kc1unj
zOG!@l_n&mz*E`$S&($hsvfcYRx91lZzkO|ZbLzvwk{vrX)t~H1Ub0N$<K>RGGfQ^)
z$ZG9LwU#_|YPndN=3CK}jWZ>6du?pZE{D5{Yj@rIzJ2$>884G|$HeNy3eD9iU3X@2
z&*|1vo~Mo_@iWW{4%-qXc6IvHgRZMjecqmN%wk4ZOstFUqNu1Pg(1_Nj&0cDopqX3
zJoKE(X~xV+s<&25b4)g^_YE@)2@l+m6D_E6X;q!p3@@2~Q%%gKE^>%J@=xfW$3MqE
zp?|s`R#(fNxH@TXGcWg*^-0Gjz7_lQ$zNk_r0}6-66z`I8IpJJ^gAN8#d*Or3FVF2
zt5*guSh(6X+=+KW#LEe>3M+dW(=YK)+R{I9NlmZjry2UKO<y8I1>+Wd>Aq+wzEFHY
z_XVY2O5#UD_O0|<{79w0mE|Xse#^v~fK~f6z3kV8)bIXdY&b1UH+7A~GEwd9tJ!&L
zbN|IpK6qb-Y5$t(iIOa0phND&>wk0FU){g&Yqimf%w=<B&+aZR*ItpefB(F@ch~*A
z{WLqZ{CLilW{K<P%ig^$-<^H;#=BQKlY&CueZGD7`PO%LCu?@?-t)D3&sUo_v$pMj
zX4o0EuqP>O<(k~w+>ISc2b(^G|5W*}#3azso3(H2zODP`Pd{E>w5aJw7c19fm3c-f
z^XoUA+1a{PErrVyG=>9itxGZRZfwxaTD#UbBVbE|n4wRkn9sD;j;l^497#<TQ}aqp
zSrg_sHK`{|)6_diM{G%wsnS)6z*IM(8QmN+v_*nFbtcSOwOWvEW8|`JlNoMKNLsTs
zI6GT$#g;?cwrwyKTP?UbZE2Fh6|<a+k-U=iyt7ThoZZA7gC@M_=IT-l4B9PNwCI(o
z%Vd|RH7SXv%QmJ(tO#~>bCU9EUez)0s^&>QKUrB>_dt<C$0K1fQ;!y8UD`A)^_<1d
z=`v1XL30+Z6IdG}dX>xHQQTv<wZ+q`u}k}8tSn_#sh-lFs=aFAf>+`0tczZ%v#k{i
zxw<?yygqm;bEBnWLBI>ulm)w){J*fodVKhJuCQX}<>j*K6SmA*_j=dU(%98o1@HJ>
zwRYaM;HaP0`_0^54==3IyRgGF;b7+Sg6SpG3#?a$-Uuz@%$gAAu<E~q(yR8~_xxe6
z*OlxI*0U~qygcih>Z-Y_hYufK+@3!1sc5D6q>AZXA2brC*Rxu6?`J)DCNVQswrj&4
zmmQ{wDRC|z-KX?x=xa@U;PGkFtU#?V3iCe&O*MG&_VFpns^9CL-n_l<kLH648=HzR
zp;gQmY}psS_!_wK)UNh|57i!Sx6*D+J9A{|(QVn8vlG1+>K!|sbHzq{(c^`cDtle^
zMXi<IEwvSj6H;$kQY{owKh^7>poaTjrGWmoN}_rTHoGh|xhk}DqK{Bvs9=n!pNP^9
zNAAW$PBC604+{lloWg~h0uP23TC9o*nd7HX=-u*2PwAxADbYpCIyUqOheS;}k}9Fg
z9W-momBk{aT3Os)s~s*%OkL?S<&cijf!;ug1&4T6%~+Mu&1xDnYo)J?LA|q=8)rmN
z)}#d2MzJ6_PN|L=6HP-kS14WSjGCzJ;&f5e|94=B`e%=wTub}{A_H$Mnc6i~^}r!9
ztr;;~OEz`29yqW}C}k;+gvU`HMuUXKEJ+IvHc7AvBpl)i&2(n-Fbus|<`9$+D_Aa~
zEHZVHNP_cJ->qxkZ)D_f<7Nm@W2k3XyYA|$ty{0|4O?C+XfUy9#er2jCa%t}ImVNy
zaU|*1y4zV@1-m$QFZ5g`IH~Dsz}!$)z3ztY1u93JIYUlOnlmxv-3*WJRjY!#Ru~DH
zEaVLedg`IqEi_SvYsv#h6EC+Vf|oor9w~{b2JK%GlH#>?)xOzLhFg*|43eeY%$iv?
z)nC=sU75Nn>XgxelP#yY)wp$ZX6OX;EDWkIdZbz0a%Sbm$SFCi4W+fthV?`zZPSU^
zm~?9Ew1wJVEroVEuUZ$?wxu^!+I6EzRHy!xcUtfI9#3kX@YK>iV7lt5r@vjEEEj6u
zbTemLwC=QJOKhjJIem>WYM=60tG?-(^Cf+c^+7l5bGAk6q_nRrI1;z?m{)~fiX6ut
zmI|@cshe&(eb6&>-V}4B?~vZ9(3`=jo0eK|uMH?#6+B_$CD$z>bC`5Jrmpf7t&tZ$
z`Ke~U`pK`gQEiP)Jen;n8+}$PCQ6*_*64?Tc|C@{Nm~}BtPar0^au-_(3KUYzr*L$
z>_GkbHg+{XKR)uglBz7RT5BW6i7QKzX2pjG{W{`TleXfTTEH=FqfM(7j7%L)n(SWp
zPRK6sj%il5Z{R|mWi1<`rt95ck*Z%c<;fzUy6<1=-tND8cH54}c`>)MDr_IVFOQx3
zc-Qw^SGTPXt>3zKrHaCmMyAX0QtGR}1t$9$8;S>cPt82uDrWN7Sg=%Ot7ug2F{>ki
z&i;8tPmSB&ZJc&D?OpVoyblbFECNv+(V-#HVmCb$nm807<s=J}SVQXq#SD(9dN50&
z{uy{JjTK|q=>ui$(gh4mT>bF1G%VH4Pv$!YX*z^B2r)1)F7R?N5xXU%8REjx!?bVd
zgzgOt3qyoLor1bJMMJnY9Jn2j)zrXV!Vth<!ZVYVf!X2Y1e0&8Las6}FigIx>cxEJ
zf~^DR%3vo~1_oBudO@Kj`JVP3GnYS&&W%6Tww3Kb*p{eUCufOV*xH<MgLlCV-Vo8S
z8*3J3ncdQ1O^&*DW3t*U-KHy|YggwAs;<&?-4OaKGq*)l|FX%k8QX4!hWs;0)?K9e
zPv=ZS-M5>qb`mF~U8gSd=v*AN?RKn}g4VWc_gEVyY|NT`J2yKwvTJ|+hKetDcs;N7
zG``Dmj^z4r!E|v(*WTQ<vyQCE*pb@npuc9D=9aJ|`%<HviFYRUbXFa?=5;ePe9g8T
z-$|RLHih&@noZ7X%jD;M7jJO$dV2iKN*T+Z-P4uw4^^{oS?{~$8uw|n#9CeNJy}QI
zot&xnY^_oItgiLPq<u5DtiHCj<x~A-qg4;5Xh-{q*salRDNjuky%uzhvt-lmtu?7v
zyZxri&i<4=>t>AMu9%hg3}dWjrbQks3~ni$P{;l0)3LRYi5t@{PF(R_+I_8Z*wRhY
zx6WL2-_Nz$=$7&|sbfdxUAwi+(EC<$u(85-k8ClC3AItG)uzrjSBY;q_)IH1P~V&V
zczu7oTyf><X}aqTx4bixeDyVM{qg>3&kubt^?h(`osRKo-#r;mlf&GFr(0ZG`()mh
zy>YhN7rofzcimK4PfX(N<ix3M>pCB6eb}|f^T0-RjbhhLj|_@buT4BsGFdaY|ERp|
zG&5iAkozW~D`&R0P5rjTG=G<~nlam&r7u?;^IxqMSAT2m%5IOiSyOw0s<M(U&Gy!I
z)xL4e*vK$d%~a&eni)o0HiiWY*k!tHa{6)nn4RIr{+{-d^59+b*0fdabiT~G*D~bW
zNqe33-b&vJ7q{${623jNXw}!OJz`3qVloO=K1flYQruLcGu2YNmtDlKnY&?AS7B&j
z!+zEu6}jGKk#6;Fe=e=bGF^X`vsXLH-jp{Z&Hv1bYu=IZ5zDenJ40*@HZECMm6Nq`
z<0`MOS(mi}u3YL<Gu$}MSG8C%JTh75;ta!uei9o_ghwXx9Guy+X+u!yWXZ_R88Z&b
zrlgz{k4Q6Y)>*AB8hXvmz?j=8SxZ)@^O~EHTbj>IBahdbJ)JYfbT+B;Eb~#8G)j<3
zNajpai<p`$tQI;w<_?Qqy_An(L{`-L?$B$-7F%o5QXXAb?&d%B@oV_ii7AIpb52%D
zotkpgEn=oo*J(8$(Nv>g<J`@f#?q!;n|0S_7#%vTb!z=$9iw2iWXY6e1`#DY79M#}
zcvvz?;&H3p44y6CyRKdrEVP(Ya4a%drqJbOS87M>+1SEx;m+ecsjYn$jFOkRbwtay
z++OGBYw|cYR#;`~_0Y9d6OFthrz_rNaj)MhadFF4p+IS~+i71*Z?3zt+H`Zwt*lOs
z-dU@}cc;$m)j6B2;~cZ&wPo3>vw3efToq)=xx8-cdKDKbmy=ql*{kDA^MfkXgl9(^
zC0Yf)O-;+me)Mayac)-6v9pP(6K_3wu%li4;=w}&A4^MPtsc#>cobvtX!AP$W$uy{
zMph|S^%pNLy{ve!>us3l^Lb|3=l;Il^ZVI*!-~Bz>UnpAor8IOd184s7QS7saN2#E
z%-ow>GYaQyJ$U!rHlur`+pc9#uTtB1<kH-T`N7&@)7FX^rb$cv*tgg?H*3?;tA&L!
z>(&@tv93AIoAsbD#%g!!y1u!E7KKOWrn6t{UbiETts>2!ehyD~XGHkC%Jo*i&l&8B
z3tnm&X51&*^kD9;HLu#k@_W`C_1*j0qg%S{-f3r5<FGaUQ>QNMT-Y|lFeU41<fNPH
z)i?WEx{Gsn?b?tyWmnB%o~<$L?0oB{#g;toc{!hN#+j4~ea;xq=W`3YPHQ(^jFH-U
zDn>JAi^+|HZHp?SW@`&;9gQ%NI2{(H?d%<r%yTRy+Vtu4ANN?4>Uo3HyiSEFdnBE9
zn|3B}#TJ8UTOtj%E?ujYo5uAqQC+a%&<Uv|=WWx%g04ob+^l6Xam8AOBUu|GW=AdB
z;4^iVTdLutvu;sdv1UoR+qP^vbtO}cjkVQRQ)+6IhvBB1({!_Vc(gf}Ol?RzvDQo8
z#lYk5!vj~jT)*k>tetW3+v+#`TeD8<@2v4TuY5ICKl$p+>8tLu=+`e=wq;3{Qo&K@
zsVWk`7Jl<-zi`rSvhb@EyEgTeQziyqnRj8Y#@;Udj78rTbw607Kgsh`tL7)JiJw*k
zeqga<P`?=J{X${>!C$j;x7}Q=b4)Vn=ro;WJP{i<L@hH-x%&5&^OW}g`y;owpaKcd
z3`9pqN3#eASVD06wdo6zSXAo;dy*l$9BxU6n61cFnQOl|H`_QWverDZzTY<JeQDL{
zc~w*2oqPM&_-b~PcEy|TyH9Ni`*?SE&g~l056{XYp6#m9yYzUs(X;JUZ==_n$(Zv!
z-0(KebPZp5(5aTWrL6()?%uB7b~zzzWmK1$)Kx>b6Gu!pZq41cG~wISKkfCO4VM`u
zcGSJ<zfo@<o%`@~Z{ND@0j*a{v-Yq43tCn>DRRT*U?W!W{<)M1nhqC0Cw?$)1Krnd
zz`NB&%h)V8NX6JVZKXiA*_m5DXAM+ldUPe7oN>%p;#jhzs-~xJX4<ApzG^`c*Rrl{
z*_!QiSxSwEM>23~(x!y1!eaGd8Yd&QnMEVLgHqbWw1o_{MK(wVCVDm<+UVG_CNR<C
zz=p8Eu%#jgBDr{O8)uoU6*+QREh=om$!4`p*StlIuBIGT+jQk*)-<1EJ-(4CJ_#ph
zoLrR^7PZXhn9sTujru~7As$z{!kd<BsY|9D;Y?Z_wrNvp>a>X4x!uNwxof!U#avAk
zyOegU4EnKXZdb`+kr(GA3oSzUG}V<%4~Od(ZOvSH<kV@MwA<ay({}7EC}`TUG{$RZ
zkWQnF#^PHVJ6dmD7QM52RdI7$%$ne%CNJ;lW?sA+Vj1vc;)%$jotHNI85Sn?%C0Rc
zD%vfvW@C1D<LOlsOI6-X+U0sH#Lz`fDX{)utH_JJ*}_-TO$zx#Ba-K?vA%k8a@5YK
z=BvJXvY(Dyt<8M!fjz@|VY$Y;#p<EwZtZ#$xja|hZQZ$Z%OcXkd5vC0725Pn)@O|i
z(r4J?vYw$rBh$-2WX1jq0Wr;o&gOibS}nSB&2gih><4+HE*w4eY3tL(=M$ckUA<zF
zF?~a%Y<+Ow&Bx)^tFF!K&r)AnE%YUPsjbI}S92=POYOX+bNN_ktmNY0_V#vn(bU4#
zOJZlXhf9>~s95)Cy{gR;o0f_d;ZxLG+@=P6o7DAhVaPH)(T7#@-A_qdir+TfUH0&p
zO-Ryb-*rC^9?Of7TVb=>CoSYuDZldJ!;^Q0ZC2iP%|iQ8eaH#B$fafRy6f|&hcAs;
z@MfOt1Gy>RsvS;-hh5t$<M(#;@pb+Ra%&^9RW25+4}Dt=-vIH&&-L!S7?}xQ+(m^?
zihN_Jaf}yPxniaMj+PbcpR}x$|Ea}fsdeZIr;cfmYd4p-Xj9vwLwcMVF+uAz7CrLv
zlkxH_2n=qmKjQF^wV=>rotEp72kxvfF$+sYOI9zLt8!wQtHH#Hyc%03U79R3YqDob
zuVUAXm6O&?O%z=+wIhOCG)y&0nd3@uppR?EM%Pr2tIkd)OSWicEIOsxkRYLDqGi-{
z(sjk6D}h<U0W%mbFmq|Pikwhe;{RUVsbj+;y%j53|FT~6Vy(Xwx@eD=Y6t6K!Gs+R
zF+mzTB32nJ4pm4w%GPj&Ytx313(Hh}3|6)pcuqR9*h|uJae!24i4Dt&L$Q;}yp%nb
zX=+^RC}r4H?`GI0)8uNQdaCt~qN(E25R;YCx5KvPzWpF=U>3=cjkqt0DFJ$pf)LBD
zt<ll-vD=P^1fSAaqjXdtX@M0ZyK}3^D^&?*ub`w!>!vt94P4|gM<jSvNJPjc)<_0R
zP0tIb7Oi>^=r>8@h-jBkK||;jjqbpp_#IAH9hCF8ZDnQiR#lxe>7<*n&au>vH52@=
zOrD)0A|mPS73Hn7E$B?jnbc;^Fc;5Xo@dOWC8woatk-onxar$=D#t81aVyU<mibF#
zId`|6+;HpGty3Gc3T5IKhJTk`9xi<7$Zpk}t`8>O(p@{-Ol_^w2fxk9X=@Z;?Ko1;
zQMm4gJY$jbsVQZPZr$7%cHm>kW8JlDvYapN?5cLPaDC`n$#HY5=2Mqvxw*NaavIAS
zO0=w<wmH0XwFuc+&tRdk%rR<J)AY+PYvqGq{hFWsQa&ro+ig;7FIP9)niZ#h%~X?&
zVhf8{*x0g~Eo9SCtzI?Gkc&Pk$9%H5U%&kN<<}4Wl#NMOeR_osrF1476kU+!vnk#r
z$K%P5S*e+;Od}!_CmE&8OpRF0v`j6e+ta9g;?`M=FKaX(8SAKtrqmx=vshooqu|vv
zlc>`?XO0DHwj9}z%Ik6Ra_7TL?uQ|t_7t=pSv1xD?7#Z@-^U&o&)s?M<BmJkC3}u8
zQux1n_xAGq-22b&-cB#u8oO<E{_H3F>t{Z%+b{d>`+9cS@~hSN7;5fo+phOtzkJ@e
zuR$|E=T{%#pZn=*@yXB^^W)<_SH7>W+^ZTC6Xpq$sm`xH!1%>eVUwq7q{^(brCF~d
zRVKtnZ4L8O5d$OfAWxM`o@=gos%-`-NSTyvItjv!n&hGTAGF9xbIsz*TGJX-=e|W<
z<HTF{YlWQ_11D3Xr^W&X29cn!1?G3<*|*eJzTgUFSfC-o73d(fICL#j(1N#*kAnMZ
zs=?oamNGCfO!*WVkiy1tLgj1FvId{o3J$ZTbj_bM;Y$NUP@tenukgv0%U3?%nzidi
z)Pftlxnf&AHMd=9ow4lVrhsjk+oF0G+~7JInjQM*(v2-k=I>@y|8+Z*^WQbI7QMf&
zft#4>Z~3mx+V<m0n%RWdOAFsk`MIsP^B4akcOly-x0C#57ALIyIK9NNCbHH!jeB)a
z&MMneW*mDH7JW_C4~rL9o%+LQqtQuwu0H`^-FIii=Wg1UHTO)ed$HTWve_xJuT*1a
zx!zndU)Q61aiE>glxHi~O7HsoJo8LW;dVdK8?QUl!V2mO!Wn<W>rH06I_YvqW!tIG
zuGzu)Gu^UsrqA54-Z)ErcIM`kew}M+O@C5^zOGun#`Wc*`Q0JYdnz(2&K&&MmhmU&
zo<zkKIf*l?53`jN#_BXL)+w+E7unA)-?h!?v`TH#S<$bpGu5vx%kp3Ab7^m?``VDb
zsWY^%8LK75Z8n^dT<=n+tJU8vFBUI0`O&GGDF37V-um9+OIO+Is4t!PU}J^O@}^V$
ztdkd}T8U|1*z`bWazp>YI<MD~DVhF9C+moQ%F3MZ)6~~Qf3nyN5EiPO5*QYCadVol
z@6@fE-BK3WX5}hXM_gU#ICWBChhEQ&X(1&?Cv#by^e9c8>EkU}UmD@Pre*#%t~i~j
zlLjZd64j%+{B(M=BvOtVEsab{TeVfq;W9Jlq^XN)B_t9f5`7F-^JpDj%*-Pu!DAq`
zKG^GI%gIGqb~D?$<#s$cn%oy7^}BCZNz%hUo`S#bSL4H`NUdz0CbBhnbqAlWQ`T~E
zm8k_6W{In7c%EF6F(-y;UA^npZC7%0cWeqd-QDT4DOjgjXR?k?M%LbGS-L8j%XVcR
zTXay@ly#lS<G?Jp8LMWV)-&{(I?Yw*vFn*-7pE2;7o8b7*=W<RH0L1QtP5FfTX>xV
z&P+9sObZJ?nqri@Wp#*Tl%!4Zq_xb6wFmNC&xCF({Cf4wHlJ0e{FR<-ZrLJLujhI-
zH0A4LZk>JlD~(PXo!WHbjZBO<|C(KW`r`2E25p_1(jy;BON<g{q#XA;vwrKXCwn5#
z9rKMjJo~*z#pbzD7E`ZItzC6h>dMK~)Q`1pk&;QT`1F+fHhww!u&}hSFm<xTao5E5
z%gdRMrCz;q;-&i4j6IU)wps?1)~6-R*Ypiblse|^IDPe_(|QvM3wBr?Kic}}(W|2u
z)~&HR{oq95%z~XkF}F6(6nqtNF<4k4>#B3a$*gH{>o|<Q7RnmFO4#)1VQ5;w$;Mc3
zHq~X5mUX6u&E(eR%oW=>=|W^e^J<kx2R0oD@60-~RY!HPSIDWQ(<ZwqCT*CyCF+=W
zeORQXyW7!?8yA~-Cq?<FE=rij6S8tu*NwEv-lEMR-qJ!xw7*QsTFU=u@}gTkO)K_0
z{#x}n=&$In$&vAuhW(z8Dzp!!Ev=Y#X&=`Q@1&ZJt8Z<)syWw)uj*a!LHnk5(k^|T
zRW?(76Xi607gcCHQC@Xv)k{_55G$rE(Sj3vUXAr@0)yq9=4YnrFHMrqNRdxCX{+Y>
z(8yEc)8bQ$PpEeapH!;!6uvb{eS!N`uE4JWonIDAzv>!%!Le!;=Nl&dqqPd$shg%O
z)z;S5I-43Lsn&jlo#Eg6wYj;ux!`@w$b<^G<?rGmC^-Eb`05_Rp5%IoV^2@d0B>^!
z5z^E3k|j=d8SX5422&w%HaFnb!Y#c^)cxOF{crz1-K)j#c4-sK;p1C(dnkPISy+0%
zyy*3um^XakwI6eyTRdAA`_7zW+cAr)M;f;tjnVoT?&^8F^c2sXPrB(FkL`MtKJ%RM
zUEf1yKW^vbE_1GLxE)%m^EOm;OTq_^B_V>6s}?PdXFjncL_B@fDy=XOj#{M^8ntTG
zil`|rVXHdUu3WW9J1f-16^#5o=!OPHJIOJ=K77FDZRjn589_az*LGdodVAreBF%`5
zg@Sq+ZRxjn*s(m{`6gv^>PlmU;9z5gAn@p427}oFEyjim47oiQf<k*$mCjsNTA0%s
zbY;q-QzyFxr*&Prl5r&?WsP>ohNBXjc&1Nz%c54lz~^$*m8@XTtYuMdQ<G+<%oJAB
z3FZyC>gF?JnUq>{U}{#Fb6{#xp-_jF=%l5hlNQ>r7EL{LDU>H9H)W&bw3KVJR<emC
z1P6J=1av<P*)4kY>d~Wz9x7Q19??B%X*tXHv}n=g>3Vubj~hZe=7h|dG;KxDn}z<J
znx&%8vOYZStLGP-9v&|4y`=S`Eb~U4=|R_nURkc0_Ihp1!pnL)3QI+0gLY}WbiEm5
z;;FBs@~=~~Onh}%@Z~u>;+B<Om-P=yDXiEN6B{Sq<@HIt)h6^Q>r|P^JFO=#UTHn)
zS*E$(>av3885Ns8w0sP$aC{)%sNUcfr248$|AnXbCR_ERXJhJvALeZ@z4T*QOvT6J
zaoUf9RUTRGja#R;UVQ1BiLd%YtMt8ZDxC`M>H}Tudt}e*BYVAyBXy77FM75<boIP|
z5BwZ^0&N(-ty=nRLHJFjB#sY?{x4LPcDJ{$`sU{Oq4xBSJ>EypZl70pt}6J#hpMWt
zAGK;AdmO}1`1+|{s;HM+KSeWZ=C+QQm0LnyOmEri{U~nLkEwR-C%#uVepuH!rH{iV
z#J|hqr-=4JVb)N)uO6NDv%G@hH%;X<SDB-$Fg3BO;nY#BnUkh$Y8F*jnWWt^d4j4;
z$AkxuTKTlJc37-(ZU{Z{sB4a^yXc{ihn$C=DmN6#h#rhulIXTn*DFf7-X%q9)kZO;
z3mYP|SyMfys);1JDIAe>%~-l9tTT#p!K|*NZpH*1)`ktu941q?OxfVs<im2nXT{7w
zBd<tRU5B*}YlXr(wS!!aOxe`cvuH7=W}>S8-=!+rzqyxch+diOQPCNa6)^GOq_&QN
zsUA-R`FJ`q*%nPW*(f#Pl45F7YyGN~4PiQ=K3WNGJ{(utf=o>WSMs$tafMC2uwH1P
z(V~qiKAL=!R?5~Vc!(Ti*SfatcG33I(Df=xM?F`GYzVUQTpfFtn{lDajiYCCL)RAh
zP4zzMG$Sx$QiP(F*Q!{RM_#cVlbL*$c#Cr0m=x#P)v(i3c*UYw3&IqpX)1TQ?DDK%
zHP!K;pcRLApwouX;Hg}S2PREh#q_^Z<)C(M?)vO3!!6QoW=&UC3mx`MT(aR(MA8h6
zQx3JkQ`x3Ee)V%m3ff=gm)pB-<77!AZ%!WZcTO3P|1=(qyAr;{Uu1o1_>%Znb1vDj
zR;{!Zsc?MN`D)^;l@);%tPjMS_*Ir(n7qJmRlRyp(8ExfAa^d8i%wfr18i5{+B<#Y
zTiexFt8FuqW_4_m6b(4FWvOD<hEv{l52tKh93rXa6*f~<O|6rSJG5igde5w@iIY7g
zR<ml0c7(3TOj<1WIN3E)S66k_CU3@;wuKV|CmK#xbF#CuJ7vSIX~?<Yh+1QJsPe*M
z9%BOuUhjIwro+cY!n?$i*J-TdXo)}j=imKf&u-6k-*#s0MC*u*^yr|djRoarCPl6O
z(|Cf<$v%Jm=`YXY`_}z>clRf+$82lM_pt?e&tAOlz1JLM4dRtg`WCrM=De(Q-pw!E
zj!?0VtEuLp&lztYPV!|4yZ+}WYsyUDlxuo&8TH&{hw~U190Py;OJZPYU|`T}$p3yn
zcR~Q;0+U6Hw0(t>9W)j!h+xQm@s35vrImrvYoUX5Zl<)^vfM2m8VhP4z0hEgV)JQS
z`DUsH0|VRat6sAV)EHRit<(&-z~;bmWlHBtwgv`Gjh00V82FDz-L5UsU2ubI#nmlS
zeYY(zYfi0KxXHVS<IlCVD;&RX4U%8Bs{QqZwcoR}dY73vPR`8^`zI}^y)(z->$clj
zwK>;+FFCS4V$#n>{i^Ovm%ZCgZ2hWwW!@+5dyLgrqP<$*-S$dTeSiMU;XnLOgKvFT
zxoLaSZ1?n{*WsT%)o1KE{+V@Cr*;3+ZLKqwp85Fw^PcNg4==B)H?~MTwZHvSdr@{|
z?NYPlw}LZ%d*xP6ebzqfmRxjHe6HsP<$K-t+;@lH+~zt{<>T}D^|qDS$8LPwwr7vc
z=Y6s>OU_RBxhq?E>rv8!YXzo9v-BVQ6TCC)*!)d8motB}&dRk<*c|PDL+9G}-o|%1
zi|^dHxoP>%88>onx^GJ}ZA+}L*SRq*RSR@}>1q9G^1AUy_v-A`_4f|Gbm`012OBGN
z-J4ET=vs*dFU+tK+rh2!K>3IMQ>z1KW*lArbnV2{p6j2^F4=V1@XzKfompPLQgS2H
zprmNXFSD>yx1_aGb0wzogd7P1@2pMBmYg|*m&pgTxAshSSYk(3{ggEZn~tVMT}qS`
zF*tBqaYi;b$5A#3wM;2tA>V-cTvwU79z4-_)wg<u>s8tC5O&vsA{Cj%h8wp^_AYyH
zXf<EK=_e7QSEmams$TY+a%m!naGtL5?B<r)IX6!F=}#>6II*Ey>5z{1gN@>m2R3#0
zX`T(v*0cB-%z9nv?cCah^)>A$JHvuQF0*FrdK7qc$t*ofrov1~zg;V=GBT}RiN;E+
zonF@*Yvnp~+ZJz=Th}Jej5b|3Yv#&j?MEI&Y?L~Zap;=hVzG^C`bRsCHXUs``Y|!-
z(9s_olm5i@XGfR>n_NFu9GViADYkRY!OrYJpQr02jG_*#E!BFsAu~E}-L4z;rX8z|
z_QAK<ZcOdgpB7oOXHTx1*3Bh{a=e4CY-8&-GktX}>abVZ&%?c8!6}=2Wlm>Km)mtd
zs&HxNb>UgL>9TJ7eUoOUpZ?^VopZ``+L@DSVX2jxmsh3MRFymnOHH?%YwYv<xbb|+
zPkV3GYR|JO%Su}|jaRig+S}IY`=2Fk#rv(!eSdCQ`CfV5u8nKgq-W%O-{UX6+}C39
zoj7w|&121<bfvNbPD`er{$#p#vs>n@O0SZaQ8iV?Gw1wxwsZQ=uPlW;o9B3Jb~_rj
zHZZ(p()6-#EXq=@6ZE&NN@dz#uxDznq}PP~i+^?hQvc@urT@+JE#Fu)^21%jW=;AK
z@b+f#mL;jHRzB3&^vto4Yi81_?5_@g)C7OE3I1wR{KdomAi<7pX^`+M{VDMx@m%^%
z-46omn7ThLS$|a__=~9KuTa*XT<T9I`XBX>@6=fTseZ9xk74SXt*udFYOX&|%1r!w
zzcx2FH)Zm{`x4Bq`p>6de8VbLpDc0g^*T@sQR0|#ZeZ4p)meN0Gu(e}UH;|GsqcPw
zJH!6%{kShGt;Tq60dLLobKkaZ+Q+XwasAw9UzepxeSCN2d%DF+<?!8SU&p<@z59F+
z+wyr;W|g;hpAQcGx3MW~<(gzxj-)HIv$NB#Eji`BAb)HA21W^n+N^!M^S7Vxd-qPz
zsp*ksrnh^~N!!y#&tlF@IyRmE2a9BV=A<Pnmrc2JV#Co$L&-><h-Esi6DQ4xbatI&
z60x$iC8EbG(<k7<MsC(7orNvSR1U3dOmLkfp|nA40$bFy%(YSxY@4n~^`<P_aygP$
z>ZHzP-PF*<hTbNpBcx_FZT8tZ;nG>IvqsmPy-h<O3QXDSYQ*BUYLRWAU(l`@nraIp
zQ|r4nn690jW|rwG<!PX}pz&y^_Cwc;v9U2RF?ueGUi3{$JsPVQnY7k9a_jEWTkj@K
z(~4<4F?H2S*-4ro0!zZ%+hqzWdUoyFu`5<Jc!?Ezpp<(?>8UNUp(mHMwp^Wc_j;Ve
zo<(~EE2gYx<>}JC!m@wWisc=9ZHwo?8guo~)?BORlYXI!)hCoicDT<oFy*s$W<JX2
zYhWrC^`X5>j<v$!6UUb>Qz88#g@3D7ET3eXzoTY*^||#^PWQ`Mygphp<)lU5`ta4=
ztB<~{Qu#8k`(jnxrHQTKLb1)~9S_fJTv7T|nfa>nWFH>!g>R-Wj9ai*FzzbXmnoZA
z>g^`2ivPmYEzU2u*K_*$yPx9ZY(8I_*S`4j_4SjMAK1tJuqIxA(oBnW?TxQ~Im}vi
zadzg`084MvZ5gXxH6Plx&H1XCf8%lQtIAI`z6Bo*KGFTutJ-P$D%KjWs8vDxS7<2z
zOIXnVVU>{oyRHUn*0nCJsZ&CHMNK-(rh51Z#E5X#A7!;#wM%QsD-{dvE}=rDLUBfQ
z(cq399tG`857n7l{X`zkT5wWzl1|80)h<)dDF#yBLYHQ0E}FH{h;71#?vQ0%C&Rc-
z>8wiX7Ku<?;--+q#+f3<nbFOqqp@LWhSni%j<rF{LY8s)h6D!&HZ67)7UgE@X6n`u
zox*h>FhOH~{aY0m`yYJ`A+nB%nol%Emw2f&9QB;aquiw#rs`7A#*`YmU}=&h$5n4n
zW`UE+fl&d5JX1_nn<Uya48??!Bo-Wr)fZJ#4tmvnKr<>(YSq=??9lCNS7+zG|H0t6
zcH0wI(W`NR{sDp$wL^nUJ!G5MYqq7`Iw35`;(9x5>)O)r`c)SzRf0X8y)>=_T1{bn
z@M_UK2X76xg_=uN?ABO(;1JgwR`H;zQB$-PoLxd*sl@RL1npYYRWU(r(JBKaiz$Jz
zp@BXe{nr+()zZ@17c|vju~cqCV6X0`i^0muZXqWQu4e6=y3BRTsmn^IG6Q%SwQFB4
z4Y9oJ8#-&P>1JJ>HD~LW&N|ZRI;nLg2&@vFwBq-9#oYB_+x9-1w2^hvMb=3do6K|^
zxI?w0^RM0K3O?j7RHAuRc}c1Kv(L(DC$4!P_2)kN`1nuuEpe;(SEYeKYS^Ue<)OPf
zIvPUO=I@Tax;H#pKX~<W>(wdt7j5=bKA&P2SP@hka^}pLGgmIy)?ay5p1V2i%$c)E
z{jOK99#voR_IBTfelNWiTg|oEQP;MzKJ?Qo&fS)CZIztJ+p8zSS9O)TR4v(TETqr0
zbJy)`v%v7Fu2x-r95-jET5#zs2xD5&f1pnEr}&fjravox27mf%w3a!bZK=U3*QEvv
zbr!ZIMojtx+nZ`PBc(oaY9vF#5nUsfwLw=pBSTy3c5FJhR;Vt1`qQ6v@%>I`rcTvL
zI<m}LRBU0Fn&`wj{kyl*Qgd7@KV9QCl<L@Os=93Al!Ly`TFbmn?9mtZ@;`t6oW{N&
z!z7~<rxK-joHY~n=}(V0TJiI<V$I5KvB<QPl!SyMo0cE_^z-v2_oLoV>;1c*ety2B
z-)pL8{o!B#=hg48-rV=GW9^21)udI-VS!7V85tNDGz7M==x)(qV0K_&&=6r@x^Qjj
zwYC+CSxsV7LL)kOL&HKDSwp8fRPXtG-saQ2%G>`|Xm|WqvhsMbQ@y;tefxx(kNxJ}
zSC^VqZn^EH$G7A7?4_?R&9=EcJ2SDKExL4haEqnMEB&x3x2-3%tIf(?;XU=qe?!Me
zwcyC_oU>gRtgCM~FbITzFAp$aVBktnvitm|fnh0E08^8LNPyWv2T`umj19`Qhk6f$
ziiC7AENWEh(qNdtblZV}lR<=GeqQ1O5e5cHBevx)v=(Gs;AOb-chywI7RDBqdG#x`
zCSPG|T<p`76{s-9ak86(rbb7o;8w<0RWpD8YYTtfvsydp-}(3FKF_`L-+uefC+jO#
zKU}4Kb=vY>w?QY=Ft3fhn_J%a@%29cs`t}lpC5jF+^+Ea>`YDNHm3GjtJv2#?0vh9
z^X0aylfF%VxAa8&z9N;qpC>H(eq1BecIVyjkb2wB!!7L+n$_o6z0VX~Sr~UK=A8`3
zM|D1i$G`g&{fvU<C7xCZ`F65+M^S6?)8DUq&hgH+Jg)w?deyd`y+-~~!FQ@B>`i?v
zXIPPH&!b`Y=x0{-Hn}ZA_EC$^7d(l}T`{@M?$*A1dz-Y9icJ;IqbiT9*YL<(-F)8q
z?zZ)ITDOeqe`Lf<=+6v(Hs56BXSNMro3C|WR{4^${@^ODx{dlP7yaC(er)N76QR%F
z#@I*A*RhNI^rLED!P5snHq95)@7_LboBw?4vRhx{xix;o=-tfepKn)Lv01;hMl8iL
zt9Si;yPE2%sEc2}3rFQ<)vOUeCj3~dCSjl9*KM8OE*Ry{>dmOPlUn*AY5Ac;@|;ur
zk8BLtw{OFa^-H^7ZK(~@Uv>J`KKHXJwL9i%znZDP;%Kd#`;|)hV6jc>x7$5@8Sj-c
z-{Zu-iI?n-^)^R(zdgUB%KO1G&JS)yt)Gm{f=z;N&-)rzb<{`b%7y;GMcWo^U3`1q
z!@uiuHyQh;<!+cK>3!r>{9@Jmx}M-yTb3V9{hGVxgy%<Jk7S92Wd?^uBaXHS_DCco
z3-hQoe#z9aC=7Y<@Sr<8pQs+63|D>4#LI?r4MY16FF4HF#>~Se-zFv@k&yT!;V_$g
zn?#-bjU|ifN)5jrn(MH7P26%mrH_~9C~B|K?>yWRXBFJ#RNC=tj>VFSmwueV^=rg~
z+gV~-7imvhxY)x)S7WBni8HH>mZgTJhUsulW=c7<W`>$ix0)Zz$)=Q}kp?r3N_=Mc
z%nb9HC#<ICGjEyCJf*t5JHiipl)XK&J8Efc>4~=qe!Cvtx+r=*cHNP%UDsoN-^-s-
zbai&_w$*F0bGLmFjs3g#>jPOiz9}zM%in#kKi*(vBddAQ<Ne$B{S3QoWHm3e*W6y$
zP*PH|JV?Dh<Kk7n9g@w4X_E7J4jY~Mawe@NtyKMdxn9PZcFX56r;S$cd0)Baq~GUV
zuY#@T9(pXT`m=W)i|h{ji0MvzcjR@vmvV1sKP~j4c{|&N+4obPg%-=Js@D~1J@?+>
zH^u5G@2UFSphv35HD@jTWOa3BdepQNxiNyr1b0MpJ#d%NIka!xW{!(tU0Xsw{F>&?
zzRI@Oe>&?Lw+&GTv%lZ54)}Y|oh`KPz2LzGkAn{1lQQVZNt=^4chAo_Nr`WkN6+jz
zZdhzN^<2${m;QNtBA*_7JG^S0*p|fC!B2KC-RX1X$#l)x*LK!tTs-zzEa_>~tH}?~
zob}G$wmrkxRO_qyj$e|Kj>M__^wsb4x+b<^>-#&_q2KrP@hq2=s66e~bmsE(+V-5)
zQP(G)Gqaptb}r-byfs$g;q2XfD=l<WvXZqW<2s)D<VzNvxO9w9vryv9>4-IPld1yW
z_0F0)>B97eeQy5Kxg)l|KT~h*XOei&Br|YbrE;6-taHa@a-P}jT+DY&c0ysW&f;L5
z&B2GJGo2QT=+#$><FwV*y2kA}W%4Q4S0~>dT_0TRwv_j#+ZJ!5JAJ;Z4mX8!%`$Qe
z57axTubCCCxJKD?isw_o%9KwrO){LvSYyJu7CX6nF3MG%wKUVHWiCtU+DUBnUJDCm
zb#7HT8={%AW&WaxSM4>sqJlqItPXZMb!o%=DTQInRJ$douC(Vo8Z}eQ*L3F8mG)du
z3{z%C&d!c9)PL*UxN^#-+-+%LOa7>9ZP7oqyevV}poocqfeC~a*e`GPZQ*|V<=4LT
zn;-p*(+|@RzVg*}+1of%IpHNA<|wZTYIk`tV{uP&*Oc=cYG**9!H=wlc<o2~L_dTd
zSl_UILHMoaw_Nfe>Q}U11^t?2*R}dZ(EhuBjE#*Ady>7qz3ta5S4h<H{^PZHYS6Fy
zyQUYcXHsVGnEtaTSz_JvhcB45rn#}O*5~Htgv%6xua7^l>%Y#KWV<Jif89TCS#0%M
z{=CiI$>*(~?OJcSZ063hQ$C-UQ?EQd^O5b*4KmYbU$=O+v+C~M_ttZJviH8dS@P)F
zv-dGFhZFPe?!33VeBGUQ&vo|R%a8h=clWMe<=YhYc~zIs-Mup<C?wD`W6{Z^ZdDNw
zvp)QGSlG3l@vUL|rp9|X2`m(pznlB}+3lZuEFUsYD`cK__6VP1aRGyXhcE+^0|Ntt
z!UPpg@T7PBuKNknxvSPL<qSE*x*#=a%c0A{zQH;Yr%qg&X#gq_d?F-zHI5vbF~dzw
z<B-Y1mP0;jp%KbnJi<%{%3f^Ufd<EB@EF!FTbkHw8ro)ZF(O%NX`A7y7>1y^-fT;*
zg!M42cF9n=Iyo{@;i%?{3rp4rRcaj#V_V#sJz>X+qe<*i36~c22DuAL6im5dDr!+Y
z?b>q9Eg4VpVtNHmELRR??kZ~f*6VtTyTwG@=*rep%0X}SKD~%_Ikb^oZDv{4W#vf%
zPc@1b)bDahys&K1QSPbBvp4%$&Wh!U4SQ%(X0GSfabn#uy=wtR1^p?9_H=Iz-efXe
zWL?N=p%{11o!Y`y4p;Upy%)>9WQMlD)7Uxl{8n!cR~K$6Th*Q@Gk0Z}*YYN1epX*+
zQE_d3?PKe5*XfJSDR|uTdS~~kwxu^dS?rYFG|Q&<^u$H=DgDZF5fc|r?^gb~wCiD+
z-^wK0#Y;-2PIxqjBct<#-=$B}#WnMmT-o|m(NsUPe7e&sHP$2xcju!w-#mP@o@ck!
zTy>X9flAM!iYX}{CLC3K;ga}Lb4Auti^{6<+>>v!XKuW^dFz{5mX+!5v85*;pSiS`
zGeTCq>x)TgZ10nmi*MB5*(s&7^i6fu#dFa=mo7c={>XWejh232mM;1syRI{8xgL|$
zs-;K7L-jdd%$VCZxl-lI*0(CY-cP|{c_2)k%gVj+&Ci$1)%`=`W>)O+=X@}arD|oB
za`#m>|Bz|wi@Y^MYgpXmnPy06+|Yl{%PY-4uPE=mdBuI3kGIsU<L1|w9oPC{TD)h@
zou?<S{Nz?WTKd@HlblV(r_wm?E3H{m3uM(NzR7q}vHHYUts)cK{`@G@*RNvw^gJ_u
z#B`>dn0_+VYZ=p)nL;rhw)tA(3)Y={=c}&rNzU`tREz0HRs2*Zb^VHQDo@UGZ>sX|
z{PLsl!>X5uKFsU<puV8Lsb<o{PxY!R--%q=+oc=yog+$9`;|hE-BmTVkp7b@n)Poc
ziR|COwN7c#V%Mgp4th!_9Rp9bES~a|OZ9}p&Tv(ZLMJ~yRpy4t%`MHH&dps*k1S^w
zF?is|a%kZykArS3sew~^ybeaFg`}(%Z8T6@w9H|P;{plKj+uf@MpKupVL9L{G()RC
zX<|!H&?c`d+KLe@2h=9<Xc(y`Ol{H)(P1=Txzx33(b`bgseuVB2RIjbTvW;Q(DrhS
zKh?D&{@21=A%dm80wM|1yeh6tTgoixn03|3BGPS|mZn9F9;>Bm#~h_BAswSABP}-_
zr=-O}t7fEZNm-C|G_X}FWSXR|#Dt`y!c1B9s)>^>PW2X3Gz^@|CJ~X!16m~$=wq<a
zC?sp*BUP3U!742V(;aOLQbQvd7mJEcZ5BF}yS8fU*3iBCo*1;YxFpFeSa9%ydK(+l
z38~(o)TypZ6FXBht-88iAI{D>cJ0RL?6hm=L^UmB8Ep(Cc(pdH5xSbm*>QEHY0%0m
zQv+|*7ci9^Ffduon&2I9sq2vGN)xWwfWQYSU3v`aK8(#?2iCA`bernhWG3vjVyDQe
zGO13LM-6_nLc^pYxK3$o44kqsQFww-ILA~sj}`V$RJMi&a()eJGSrAaZgP|7ShC@a
zGf7J}dJ3yKo^q(?+7)CKdc?_MP9eK%xR<Q<50%xO^~Xi5wEl^=#)*q)cOGXc3I9;x
z&nILtr_g!PtI~fWR+fURU#zIrPEG8v6FnPd$Umt#be8Cwn5#MBKeT6Qdxh`#CTiz&
z%QUO?qr1VipnXcuq&4kCo^>2?Us^3RZ&I$*mF^pTiCY5StURl5Ncmu#Cwr&c#Vt!J
zHHsAsTuQVzb=B``$qA7VlwmFKa-9_VW17RFlo^WJS{t>JB3hL{*2%X&{81<0er3Um
zKb&>?Cx6<jKlw9%^2ge!wHlXZhPE(WjaaNJ*sahrYu2=dE*rhy8acoH`V$0dHe6bh
zlyqoQsIcf%i4ChRwuQNRoSI*%yZBS8=r6^Gp}gKoNr%=-q}Hb_NcA_>ZSP#Q^!l3<
z##%-TvLYsni7w_@<6)$48g}@|RnhBjyS8z5`GPcDYzqt35uX)y_{bIQkHSZMA`;tl
z7EZOfvQ18H)$~`3KCPL1wma?U_E{^><mmRcZk`#kn?)=9W8MArAMftIy*u$B$0U|6
z1`9<cPnAXmPnF!y<$LST-uv9Q^q-UWrummvJc<6bHEM6v{-+|6QA<Svg|>PJy0T4O
zB@z&+r_!e~=}T<*_7kPPX8PeOd3<lrIy1{%i*pTW4EF7|R4ypb%aV}zw&{~<&;%B(
zSvgL*X79Egd+_bf6$8V!sn6COjmfwgy+t`!%45T>#5Re<w!pSPPt_?Q^<a(!n3POx
zlT?}Hxn$DPh{P#Do?4-8lCCO~mU^nJ1aY8UKUJ@XRm^UTh<oD%KwUq@g5RfKn3yUA
zFfck~usbj>$lzsK>80JpU>%xl-PGZrDHL>Zm5PYSf^e411z8OYOK<n+F901$T7QC<
zWtPUGX5lP`^jGtLtzuwc@O(98<+6qh2DPOEtLCq8xR9W!DroA}zQQ<g`H9-+Tfc2L
zfBdo8w>mG&Tld<t4JYmFoHuXZ_H57RM~v4PHcY%GWEpy6pKSN3m>)GCxQ~X<0I_48
zVphG0vlgGSYr>v|I-gdp4~^UTdi(6Vx6jt!`giZ`*SiZ^?azq#w=H7Ynwwh#x@-Ju
z!+{9iu&aBSx+L3Dx9%-$yIN<Q{<YrYaEE-2)kHH+|8?cjdR;pbyw=@)SHb;V#@=yT
zT+-TY3*%ny*~zudW%Xn6$tMp5RJ=Dn74k}IYMO7xFCSHFC-F6UK3zLEU6^Xzx2mn`
z@Z0Y<>-+u9*2h|X*g7R}&wHCUCnwi_`?BR~x6;+UTlD?&rrMs5iaPk_NY#w#AD0CF
zIg<S9#m{NiHth2W5?}APv~t_l1>uIZmwryZ|Gw<g@-=e1&)oVLeDK!I8rfrAdoRX4
znfJa#?rg}_{u%u<)sHRuks*IDQ)$1{?WmhG7VY11;J0gSXKj6|YMlScrA2>c)R@%l
zE7(#iFLC16j-6Gty4r7b`d2=UTeBwFR6eG*qUf~FzVM5g-*dTzUdriAGfC6@`t|$W
zY+G}^WjgVpUvwwz%F0=|CP&-k*RNmS@80}=Jf`6Do_W3tCr<nq{Nt=-j;_$Jtk5qT
z)=%sF8vS;57XNDf)taeO?CPhju<Pd7H?hTkY1AtH4^aX3-CF-7<{u0FYbt*&_}8C(
zYxZb<G1Ono^=roZ)t6tL`t|st|AMRT7f!!hu~km_WzUgck1weoFj9VC?p0%wru=wc
z`td_6POTPP6t63-aAu$Nv-+tuw|!TfT@}8X^-rq%VUd5ER=?f9CiutFz&~I6*ZJ3T
z1^#^b=);HNBk3#uJldzp`dV&NyM$%cPM7dw`u^hlYyr<Z&IfCKShT#yCaGOQCPH9u
zVnxM{JrWDg3r;HXT9<UDGnsYz(-Tvxj#O0au#psc-f_~x;W4MAfn<XAG49F2Z6cPT
zQ&v3FI@#G4sur5EFk|b|Z09JkEm9Y<GTe+(>$@b5oK`iQn%Z(qSf^W^>$uG1IYoSh
zC;bXf`n<WWJ<WMWUxdtwqEkC3p4K?c&pJ&kQnKn;(aAGAQ&QWHPQO<4L-R|bL}Hjk
z$YHKE2CGhd6|FvQ$6FlNyPY?m-)q~}*oq%dDwNN^m;K&7&tkn38;C3T{JiX)InT8|
z2&MPO)c3RM+wUp8&iNp4o^6p0OXc&vT@P(seLmL3gg$OINYgoNd~rrv<b0lE>DSV`
zx?lY`J>8&x<%y?(kLSzD9IPs`(D-^j&a(C8i6^43=WV{Md_{C|UtmJ;l=69DTch?W
z2ruZgn5^+Wr=afB@q_I9E%@HYiTBIN3Ci<0-}~;ptmJ%snD!;{{T0pY_Qom2&2)TU
zpH*^h=BrbCz2yE}+Z!joEMRYJ)z(*ss)A;G&DO2hFi-hIGMi!YW65JO$0Z|9zwCcj
z_(uLl{MOolO`CW=hu;-G#IwfndDxXX3(MWE>aSXE_3^yTo@bYyo;(^?`FQut$%od)
zd|o}bxA#$n-)U26ojWV)-%IPusa6(T^E}bFBU|Ljugylifvaqn#ij1@U2*$E9glkJ
z>+g5|Og<JT(U<hk$Z}%;=_z*8#k~1qcI@oFCUfYSW!H1NdE$9*jVC_yO|=ewpE<|o
z$Tis|Pp`Y3e)M`ueB|tV&)zOS-+Z;#?$wW(lh3VP-1PYA;!TxB5lIH#nkCojHFCS%
z0!%hFrc95z?Q6R9L%dwH`n=c;&;2$Z+3)giR_0`dukv#9PdtnFi8<Q;^wjjDmIgD8
zQcq8p>`9)nH!XRlOfjGAeA&rXdoog2Z<UEH%-O5AOXcU@ytDV(yLlqJP2*fjDiWS`
zpPp`Gw6*l+nYX29uB-L6R^L3iHsi8xjClP4yNN58b)8)8tN3bt-28B(<5!R9XU0ga
zI;>_{SU9uincTXhyG2$nZhVw2)u?_NF4oqYbjw2f=Ho2Ajr!u^fx9j~)%Ygz!_Dh5
z<I<I>Q*1kLKKZ6tw(yien2yiWQ(LEIFAP1A85!E1)YsK7aw_RURHE2c!`{TqR{xMV
zeaB$;dSlbBsi&8EWd@W@JFRkbl~}~8Syz(XwuH?PdHJZdq3e}#N>ob7m6O80F2-D&
z!>&wA=sK<Zhqb=-4bQ@VF30pVPHUZR7On4$<6O+MabbOHnsjbS*lYLTl-JXx9y|Tj
z*cIAsoU`ey=r8Vw+^v`99?N=ox9sp-t8=ESe!N=!IP{%{Pt1eB6AelX91RQ%jGup<
zP?_v&azPsebT%E@5GMM+VRFm-xBs?GW_%#a1G`J2!|2cB>4i-!TJ^oxV`2L&jv4lD
zb-T4VH*nj<ZL3fJRk`f6>7TvtMq$ef2~XXw+J_yp6zp-_^sR5VS$XE=ob|S!-o3ni
zP)*M!A#BM;i`I$VB7vTz({6;sK36YSFPFWu+2)<G&Y44ZUal)KT@t#j>1em8Q1l$R
z^4W*ay$q>h|08Pu;M&>xjcc2hDRne3I4bynH-|HEf;*>7jxJvWz6ku86Z#}~+tSdD
z+itanhU(;QJ9Rs&rTqhwr-Fl>$&?98ADoI>9LTX@wPwg^u5KMo#jgHPQ(iG;b-~N(
zfeEYJh1MxNTCp>AT4XrSjx&W_GHXP`^_=V)JB#?VlGe<cwQEjfz0Z!-ZNWx`KCkBL
zt+U$G+~s&w>x1iq=2NTWY<M<KS2s%SxjECHv%M`&a(bIeMbbwfr>HsHuS{&_PW8Kx
zwd$!~h>o|Rx3E}&-pcL`r&6zm3$G~*P1brf<D=j7a6YT4rxw}>UJ9*ZeBt;;sp?vG
z@SW#zmrhH|=@?GEJXv4eU!wlyj%{XB-z=NH`Ed7I+da?YZmd4qAI8}4`BeSSk&8tY
z{;Vl>`a<)#)@V;>^;Hg=abnYjWnEXUvwRHSSj4Bce3itkYK<3_iErDCtgcV!&8qaa
zUHa<7p4hTopZc!IGJX_%HN}o=`T@sJs&Us(XZIa*KV7-4;=>PZWwCp5x)w8|eCm&f
z746#c)+Xlc({tHIcbc#0^b4=Pw(jD!xZS7wqb6T(p1x~N%-p}PlAhKoU--7-$iwH2
zQTnS7RES3MaLt*vVNI`@R#uAZB*Szey;X6l@1|*oyy<!wv9~i~&E76cer505PuETB
zaobXv`e@OXt8r78AFciLWpA9{*EiOIaVI_n)z))WP4Zu{=ogE8Nb~cO`=9sTE3Un}
z?0e;&#oFwaR}v?f&#-*FV$OS26=u29Z+9I#9+P_2es%1#chBR(4@hMPXGQ7pt8bp}
zYoqM>v`_TSrw^HL9(|NM@T=*-BWr!RofhXcD$d94jW?bA{L4CvU1D|<FZgU)@hej!
zZ0R!9WzjCFlJ$X!8E3a>%?jG`#Pw0gm-eG}lcyFM+Iq~J{Afy{-4(S(mD#%8nveF@
zoU<04^g3KqU+$vlv6`?P{mk$a@r?1V{2Qj)o$9O&nNT0p{f9Ng`488MwtxVm5ROA#
zIvP`sda0>+oai{UG-Ab?5FO2=V2w>`E3(=YuC#SZbtD+{EXk^0aWqm}BT1rJAW=*(
zRWwU$)5M9Ankn8|vqBE>C>)SrX60GRBXp`ez&F&5!@#lCJ49{CWR=NWx*}065&}t`
zNu3#9vxJs0@vumRczZ0lFln`*@V}QHVO@*(e`)Mt<&tCCFp*nK(?{fJh%g)18qp*r
z!=#B#2CWeWt_>R&9PO&-VHWg}a5?HW#W2-zflZJ|Kj%u9Wvi?OrXHHAdHlnz+s4^B
zTQ_HJyCmbORmjg6x^8XOw(I%4Jq9-pJD5r=1~1|i3KR+iGeCrhizkQ=#nNVJ7L(eA
zk1FXcm{Mrz(5@LWPdLcaQmZq|X}K_0h^11!atPC`mZ^~ptNveTO_-{szlw|f*Nt0e
zjCl?loG}cFShCvNJ8Iw7Gs%HH*_oOyX@(PL9CI^DRu*&@EevSaE96T}^3!guU$kgX
zoQ;j+ze#V*)YnLQU;3!t(fR1(!$;wLMfHmhefd(M^|9i^hwxwDE0^aTw>*0KdV6PV
zz@yNwp7rrwH+!{e{4#EuCA-?Xr(LnXwC?1_cn%BKk1o|-H)l+~)t7Y3Z0*v`2H~gt
zPV5yZU|;BbMLOEW*0osUmRYDAi;PyBkoU>ZEnW{Cj|#o;n!#bJ6!K?&Yl>FSj1^r;
zNdZP`N<G?4P6nbs_G^FoW3PYs)1UbljC49%1T$tV^~$K1?+$hT3<e+N11Iy$P}7NE
z(@I(yIMpCjSu?&z(%w?jUVi%HPk*YIKXN2(^e|d}SMB1@x{42zzRaH-wIxI9RMuf;
z#;KtO1|gfmXPI?p=GG*getf)%KYo>D(^aoSSJ@W56T4b%ySvP*N`6I;l#a%UJy$nu
z^PMkg^yA|b)%u?S->duXy*ztXc;=mT=|#nsjd7<YwJ=}&_Vsh>bY-(^kwpe&Tf?4~
z&%HbIUhe)sigE3~h3Yp<UjOS##zpOrW4%(US<|*;+%Q=iobA@zG<8d_G~3iwq3gH4
zt+ltaKA*RT&+2_f?%Hh;$2-bft}Qh?duLhbYVR9xk@|(sITyD*o^fjH*44T}Tlcoz
zx}Dln(O%)3pLp+e?li5k_DZqz!fr90h>eMECKAV*K#PA*B{Xq>cFH$#Xy_F^*DHEb
z^juGzd(O_&t%siL6+JB2d3w%{7?2D^@bGlY;<ks-?q93u>S?U)QlObXk-GXB^$m>R
z{-12@_xv3~UJeXQ4FU}T0W6&=i3?cIH}Y8@5Mf!Nv4CNf)+z@RDXyR;Or;w>A8K~%
zWpl_-^-t9bl4SN}NWQ8WaDiE^Ve(Zi6=uf?ELRq(+Ikro$}Ma3ba9$0eU)*+pI5)M
zdiU+m`|x4w_tS@-zOFN^%v&$oUs_!6UwLZ#?AC2rv+ps_d9?H0PyWCnIr(L`75+F*
zsHru(oxANe`*f!DB44U(w%yK-4i20)t5dsoORi|}Gv>2fa#nsgcKE}dr=I^=wv`lU
z)y6*Ys4Xf|>dDaK^;CIuCCo})*yztyx72{ADIOn-JGBg3T26cFg=`THlbgCq`?blD
z@cQgfg=1QZ(<b?>?>zPM!^@t+(5)ud)%o}z+W1I&2gXUc&nxnLIO)TQPn(u^otW=+
zmGRq|GY9<JI$zypzI908)u}nNQ<Zi~*{P||tk}=qW_Zh{J7mw!%R!$C9=v_(CVE!l
zu#ru{$IG*Irv;y?ZM$?~-Yot?xwUU|7wlc@zHH&k3H5t>J>xD;h;I&9_2<l$)~|_n
zx|`fj9f=oh(mpu#%SBtmxS6*0ax;#5eMxm+tn#Jg!(oXs@y1pB%#D}D3`)5dT<t12
z*c1LSJaSsr<cEzlrlB7W)R-STEAnHborL&dul3Cw`@}Ttgk9D@*wRv~W4C7c)unc8
z_*ZMc`m;}GS3Eas{fAAHAEv}}AN`ngdeN6C;fq-lU+mHkbBon{5E)V-woc(=V(KBk
zrlVbbYgX$&_1ki7i~H48{i_9QqnckGvD5vQyK4PXt$xu7d#fHE?(Uj&OyXd`VezNG
zUiw`XzU*a`8B~?!=Ias8E7<F`YQv$gnfiHC9tC_j>E^R)O^Tb3!p2GU5~o-bJ3eKq
z_gyS-`5mcp=|pI6z{W)@61yt4hE$d;=X7pkIHn|#uxq30sbv%Vc*LR<uKI>*HY7GA
zHYPS4=4>;TJP`5Vfu4+v;Nj-Rf(OUB7Zx^K#IW=5iE+1cA9^`0wddubhsN#9ty2mf
z7QRfDFibj~y4Ug1smPRNk&4s2>Sv~`Z2hq{EywQGX7eE79{2Q{xAaZ~o4BW+yrnl~
z)tME$?ffp5b)0o6t5eU|r5QUv-Ra0{)tR9)#gb-CkGy9t^yggRjt>GK9{ovu*j2$%
zQCMg6;i!#BoJ@Sr9z%a7Ihlyl%QWYtUpKd$xpU^D*b~M4N801(&DAP-dG);TPVIyB
z!Al<%ggg&UStlg3PHoLxAMp!&bT%a>woW-(e#~&Q#9Q4JIaWcZPCa<Dll9!RBSnh}
z9wv*YHoc6WkZLqD<d8v6dyiZCRQr%qyW*!`*smjgwBy%)J=dDBc%EJAhr63<EcP0`
zTHSFhvO3bvd9`z)Y06XQNm-{a_DNiMnz_22d+PKGIo4`P-C(Upt18%+oH)~Ub;^~~
z66_PLZRQ<Xy=B>S9(h(pkB0|%Lp^Vrs-22#h}s$$ai}L*r?K$H%BHSDouC_&u5n6S
z=<JEQu<B}4+f4RPDu1p%n5q6uYHLjEvR=yw{S!r7t=gtdUF~bBGrd%vRn>Cs=WDlq
zUbQJp&|EUp*piWfff2M6LO@V}fqm`1+YBs|a&B%;J3HGfXv$iX%f7-wDf72@7EJoT
zebsdBAZA$}0XHQu;OIDgdwL)<i}ZBGBo^6viQAzYR;SG7+9q07UmSJ(>#rAk-x$9z
zxcGF>J$Z@V#~<#^-8lV{N>aeVy<9WCckg(7WS`vkZXHjXk9j(0r>^lgdOb@yVz%{i
zZ;OpfChttx5}_k-Ga$Qq)yo#GT)yi|=d6}GtT)>zt#@7CUF)dSSy@j-0$oJ{3td)p
zX-pL?bQP%&bQSS?_ww#t>)p%CT?0cxMV&5&go<j5x(0@DyDXUEaxp|O8bT~u(9zY^
zq@<<A(XnEMQhERPirdEyZsTX{I@Z+`wleB(*xt{~8j;QJTchKy=2qWJK35)l$=Z6|
ztDxAq*OlkI+Wu|Z*67?=hfck2XO%00VT-neMrLW&r>^iwTD&2{WOdMS&7$Lishlz^
z)(KfU%E&|(?AYY-=n&`8quv)1Et)$_#mtRPW>4~yR2RDPD)#NEGBM8JmExi534Ke%
zLof63@h#R{vnw`YYH7(M$J9e|C$7Zlb-j>OXFbFd92~MSFYu<hYNqkhqK&tXN?ejL
z@>@FbQS93zW%Xi0{G!2!#9PIutf&+U@A?!Ob2{<V9-V??h8Hh=RC5pS*3;)c+EB5_
zLN)c_RrzP#oJTM1n%G*ktFPfmVS(e6jEy?WRz;YL%6cE!v18gRU$qLpFz?XCTc2h<
znk;dg&o#_wYS~sf&+ePn*ZH->I}L)Kvc3%ZqV+W>?ugbmkvMg>jc3i~$gP}ir^KqR
zo@!WFBPZSw87|H#8}efZ<CP7L2U3zEgE^BTghQhziYLZ-zM18BdU}r%t7^S_)zf%+
ze%G>zMZ%l-r*wX3`Vs1WXe$3yr~0|Pi|5?E8~1Y0of|)6PfstHetF7nce7JZ)^CZj
z?0ay`a`EIo&s)nctqJE|-eytq^77)P5B4qfnexbQ@zGbOyH_85^|h)xGWpi8c5!xA
zqaQJfsV)889<7tECPheiyBc_NC1^9Q3#k_mS>Dwj^kbTLX9Z|a#vJcQ9><nRM3}g-
ziC)^H@84!o@`14@j9c`CjbVXi(w@nU&WFXfnaQ)RHsznR`o_{vOg|icii)3DWXBa^
z*VKP#!Ycb$lU8U8DTZlG2@6rU7}DnHaw?R^Q%q^H)`F9&iLPCfIg@$<yG&iPx=yN1
znpMxbAc9-emvgGl!U;)kDyg1R#g_Vd&1$)#HX)NO(5Q1kFH2IlNYsj~g)2o@iZ0M)
z$_g>nl2AFQrm$6OMq`JRVpvD$3egp!ixyoB%u)=~3^=7_)YYRIaA+$3XC{vSkJdGL
zxra<+4Kg_DtYXyQ6TvyDM^KE1Gf_-5;K)&C(Xe{fFdmhSt{pmI3L7<>K+W>qBBAb{
zt2%rZFZHl=^|G$tV9azzM0V?{tGm`#D7b5R#FTE$ow@0@#2K^MmWqJ~{Z_SF1acnq
z6XJRrGUdgx2}>S?EcSFP2xfFVr0VS$5TO}xNi?)RR3uZYWBN`<#!r)`^1qbO+7!?x
zHTCc6reLOk3DY;IuxivxW&L!m5viFp&tV^9HP^q(Z7Zuhz6Mn}eOOsFHEzW`M>&x=
z);OVl5pj>uTT6C(E%%V=;1dlz%9S*gXVs+nlRr&!T5+;#h0a>0ww{$rSF@aqq*}u!
z9cfuCGX3F?{p^qGLciG^zxhMhS#ilKZRY^j2>-1q>hf7(%h;B1uG-Yn!=k**;L!9K
zRaXD{pkg!K*=lFEy<<1ru+2>E*x5N(J)d|g{LB9NcYp7>JnilGcO1N%dTMuhVZ-xn
zuCI45z4P4Ma_95v=ax^O%)jd@7xY&se#MeUfe$vBnMLO&Np9TucH1|8#;<?(%byM0
z_i^{mlj|QJTN-FqR(#*;eYt7iF7t9r)6d722Hw1RzUKAb`mz<XR@^SJoW9O;soAyj
z=ee~yH*cQz^Lq93uBq<p-uQla_xd?#msUrEk^%z*<2Fzmjllsjtv-W+9l9mrp|7_F
zNBGirjQ>I4@Bc>(ET>uvH5=}gU#*dHV02*OZFc1}VYuM2GT2w-_67#VRbLqFeqRt`
z2&iXZU}^{uQFy2@VZ!XJ0}G}Iadl1MxW;lj#H-2CF=SEKHPHR$LW~Lv0s>Mis`7ng
z*i1M(C%Xwq^7!}&n<)Em7)d3re6wU#55r6Y2F_(}3_d;#3|B+`e_u6K;Gm>b!i*Wt
zj>{SsD=za<V^m+&rRwj&kaGDF1B1zh6rL*#O!ZkI%b$v5EuRD)kICQ<$XtAdD~MAn
zR4d~P17}MD0|NtR=cnBI_1AObH`m>Bm-$hr|8Vu86}LWDK0ZJ1dhgltsC(Ia-}F7P
zTDhhz<7&r$w-As?StW9FcVzqK`{vu6w{hFOAUi5JE-h{5v&wk|#V2gOJzu<c=i}*C
zU#hC=W73x|EpC7Q)iip?lGWF^?*-PH-RAmo+v|2M*T=9^jj^Y0DZE>q81yc8+o^SH
z*S!94=+mUNExHZ58KNdvY@M#G+BVU5L2y*7+N_1IRxXVEaFyknr?A9SVKJ4c=hye;
zKF&^msP(QVc$T>3qp4?}?Od*_A3DW7*K+l&71EKqiH^(at*0B$D>hD-C|vv4=*Ep}
zk=<9!yAH;lh&{Euc*ly@d=K7vuTl3|`XR}wVpHsqciL-K%r$g+*)M66_*l-)>X=!{
zk(b@e?j+8fnYY78MoK#AOq%ZM#2L$G81o$Y(z`KY>f@J7^?QPT9N1_4SXExk{mdDD
zN$ta;HWAH7PAz^CF?DKvr|`qXk4Zl^?bC@DlNZ1G=;+pmNqcm{TRR^XR&3aqvrA{?
z#gtgFqgOkQZnY2-c@VioCPF95b3??26}OH??Ay0$U1XY1c*l`iHRqS6+OH1AhbjHo
z{N~JoeG^tz#fKk1epJt}=(tR#wW!m}MECGm(c_w#MaLzgUASAD`t($Dx7O?G-jG_f
z;AW!e*00*RhcfdHTvV0T;WA^JrJ1F(KuSkznZl`Nr4wEWZDOp6i6Ms$DRXm*iD`<7
zB#0&*Fw|xU(_!q4U`aZl<8^>10>nIEvUF*uVG>Wol%t(K%uHb#S3NG7a%M^`$&_+G
zqPkW&B+G59a!7`^$CEu<uFZ0*UvX{4Mbp4l);3#LnfMC3Jei&=x>hvX;aXF6NN=_C
z)f3u%rUzrBcV}nq-W$DZx7hcs%VznmYA(+`b}_%&<g)9Ikh@QJ+*Pi=?Q61j!uFc&
z(n|NfUG~*33@*Q&9kw=b(*+$J*48G24LUk{tgVfSi4qa9Vq)CF!B<U9?N|$^M%GVB
zbGoKtI4wb^vVVu^)HT~e&DZbDnUODj=*Hx#chSPq$38~0?ya15YWuPeW~zJBB6|*8
z`r&KpYqHklsmYbgerHW??>FgNa7=UmY`0U%T)9g!*|w%RAI<ITnU<F5CY_KGk!W%u
zW0~o+)ToMMVn%6cN=b$iJ?^*PHd)1|Z;5xSPn-1RvZ3v!%`ZO9T($b8QKiq7%lw_o
zWWwW~-hP&5({8#tDl_)lv@P#)vwhtnmOgA#7mu~<mP@_3H*#9j)fs0ti$0%oXVJDj
z-+Lmrn`TdmtW^HH<ZE^9?@hVY`FAI0Z~OOVcI@`=DYxG4{{~{cJGu3C9WtYS`+Lu<
zO(zbeEPqlHGx_bbi2j_&x~-B4tB+2)baZN-WrbgyvBaywwNjbKax<5;MQWB=7UXm5
zB=(psxpYjjb+V+{lGnM0X<||#RsP}I@9$Q-zU}W#v)%b1i|WgK*WLcRDYpzHockMv
zu_aP-vbJjEr1~pcy`RZFKecbo`RS7lRj)R#xO-K4cUr{NIi{H_r?KqFTWh4V=~(Il
zKeMO}$*hw@g<smOzYa2wIBWJznyER_a7yIFtf-}*L3*cUc|1A!cv5)Jw#Z7MdCrmb
z+<Xr6e))&LzF+3M{@VYX*|FO}PDcr&?Ta#t4kg`fIrXS(mm2G|pp8vyPDD-X`q@=l
zDHL{1ZP_7{tzP2uJU^dOS|1p7tu?hNSs~3aD{AV^S6Zn;HnVpA_FB|CvCTjyX=Tbm
z&z_dVO#S@4norZ!)tB2<*1Lc3h*f$ien_8VkJ3Mu_ygS^#UJS(iO=$Xu;OIoWVPzh
zwWk}T6RrxItxT3U{ZXuAo9hp#l8*fW`vdlA+J|g9a@1_w?HAo%pF?hXN7hWW^VsV2
zl=~|ZJmi03(_zDe8ezAt`77dA#IJ~6Sl0Th^;h$g`jwwTerlDfehLoD%{8b{>lL*R
z*sgLTA}w{sCV7#>U`~^j(<HmOA4*1NMrS__EuFy?Z5rd+ot<^-*3GEar<(7k{OPy5
zSUJCu=a-<TsmZJBoAaKA-9Oy*#`xs2JI`L9KgjPfv&YEWJnr)M1!_VJ3@Q^<Zl+FC
zlw4mwd!nR^bd>R|Ys;=J^;xPMa;<}dfq|o5|M0`8tKPfTZrVHFQBY7&ut`Zt8AO9H
zi%XIck7M)XgKeVqEG}@s-w!!D3bZe%=;;~gK~l#Idrx;3<C2*U8d?HrfGD`wlZ>i!
zy4h9fte)IeW>=-w_HK>+_`jtw|K;IlyTtoqK76)(`m|p6+vk}d=A_ND+1@Xm+j+h(
z_tE9j>%|A>6g}XrczoRY;Y`b8q34R8>@z)49?fbq=XSZi`OJG?cZZy~UU}{9ve)aL
zNxi&R?y)9qaoUz;E4@=LFnIJ{R+;9_wfo%m-16D8=e*wgJoeb!(pzVQF0b1yZT0NA
z)%(ipMU8VyZ^u5DDcxP4z2{l5=9FNsRHLpygBde>I$MsMNrQ=G&YanE+1OZeSz4NL
zT3YIi2{UF&3JIyXbaDzSxg1JLGg1>4Hk=64miqkMs()*HJ8nj;D~>MQxFIZT^}JKt
zH!;rOoW-aR@KZa#Z`-$$J(lN+=RD^t)Vi@itTQRHJ|!S3Am-ZEwWht<Uh<!tLi|kx
zoh&XHYAekzxw7y5?sqjIc6N3$bCisZUMl_<?U^(CzFvsC_>$*yR_xf}SKQ)WU0Tmn
zz9eSH4!`mxZs~gZ4}4E-&&`?hq~r5+@g+~X=j_<wCny7AzZ9>&y?V(@!Sj}dRelr8
z_wL%|H&Nzu{dDmqSY%c?{5rHHV6A~>*bJ^&t+gH(KK6@tRdk1SWVAlNuP@FT^IT7l
ztM|{{tsiE%o-4Zb(4gafX>N^L$Ii1cF=`#X-;qo`b9d`YGuJauj~>c%DKEPYchh@4
zea}mJ_20LLdtOqWSM=!1+=XCAUFfSk-F>O7_1?EvFRfXM&&9+|-l7Lmbu(o8lHiNH
zEUVq7>55Gg4Z3t-;nGF=fr%!qPux~M_DWqGvhh)r_z~Z;VXxLMiMRb(6SETJOi#Ce
z?{59_Sy()0+YX;5^SjaUo~y(yS9iBu5#0CbQT;E!3%l>#ja5(ROMAQCbC<aBbaBot
z%DcDiRp;1wy1V6x;JHt5ryT?b<Xi5&Z?9e|<9I%2$6ob}*!OwsCU0=Jd3yAvwbT3R
z(vrDL7T@xGGvUjs?LkYo-N?AOCF$1DO}CDQY}?>=V~Sx`_lp_PkDllWrpyxS3R4cN
z7cmrPIk{wpTG&&=;HJE+?V&lY-|ug~dTQ#qqDN1r<lns=H(4X*x$Zh)h2HOB*Oy%7
zo^$o+p)8L3m4#K*aCtq7)0aBm@b`$jD*RHkNHC^YD(lg)8^_FY3)PgfyTzt+cXPx<
z=oxw(UGZ4+tD3sm4n3Ab&%*@|iYa?LO>JE*;N!Jpa#Lp5l$2Xys>vNu-5X<f?Bi2B
z#QXZ>%=yMq={vUt7T4_9>9W36K4|@xh2K{4FIie5Qor-stlep!4Y!?JEp{i_H`~~q
zk8i1=+Qp++yS=lQUTw14^-eb`^^1?m_KMU)J~FqS76>cP(~IHQ6d|%!HzLSKOGayl
zdPJhc;w))pbwM3v?M*8?ZIqAqoeR$>TWRgQ#MWhA7r&?1JRz@7Uiw9n&1YXcws~%D
zyz|bznRj1?T)kgEbH<gQk=d1NGgp^BS`#+yPO|Uzy<69s?TAzL@ydj{qkHx0b&rnM
z2`*jiXjrjD<=M1`IUh4vW^cO0YRW3BB@?u3@*$HbWsXM^4_S3ZDcgGJs;;uVG_N}3
zo98>uj~@Fpy<U3Aa|-Qah=rtiP-4EMe5w3--nxnP#dCJ-@|!4skY&aE)2w0}I5n=U
zbVv;pnlUwKO{cPx;EKQu!A#98SCg(Sp(dg$qE<U?(dJqm)UB{lb&Ao_30p;5quN%S
znl)|dvYE4US9@JLZOpV~t<GixZNkiJv(j?6)vpX&8MabVH6rB7%B9*KDXWecI%h{l
zg-wf`A-Xg(b!H<eOouDHiV>PgT1P@xx^)@_E|{GaHEmYTfwkJ+I%l{pZP|1NlUa{0
zymV#evb5V-0aq3-nwl^*saZrq<f7&_BD{0yv@zI@Q<t`En+Xb#*;y`GE}22ARkb#?
zWOUpPy0R@TQDu$F)K-N=56Ky#Yol&PU0qv0Epp}zk*&HWmwnD|yRub(^R4~flEE&g
z16L>ATot7`QI#{ac2n)bZ|yhax%{~1Oe|_WCI0V_t;dqdS6ZhCx*tju6ZUq9Se2R4
zEjF!TW60G-I$O4|b}bW3I-nD3x=82J1u?Bz7sWC&xJ7-Gjy6QBN)*#!IvUKeF>6(Z
zu2<%&mGuiYsjTKSSZFA4l#8FUCBm1NF)`TNC1Q&SYpZXR(rIUhh>$}%60EJh8Qmrz
zF$m?Obg&^J<kZSl7j&JjEL-icQA{gq3%6jFNYtdO4oAHXvR3#kOf)fBwZ`?yhn35x
zRx%xlv(ZWi(Ge?GUC?oT-s<}_&S9hYyn0b{glN~SwM<7K3P8*&%T#<+4l%Rp2(`DI
z5)*dzS~+Fev=tG1R-X`4`uH%|21FnA4Qou&x6#Vi`o!9?=fg^{Bv?=<<Z6bP5)$*0
z)|DO=39dt4wFf60opEN#6_DC`r3+z8wlcO%6VXvQq;*hClm|=+CLGYwN)+Q^I<%~I
zl}h(RyTCWL?VFx0U3x<^s;sQ6w4i%6tB*(Wx?QhRVj~u2@rjyT6zg~x>?@ej7c|>U
zcWSgWch=Gl{RNx4Ix4k~t&~(>@I|JpX!4Y0t`;E=gE!h9+Uq#U`-)`9>iP{?LA%+y
z<hoWnE?SHeEeH)yc~Q1{YxHtXiyb?*saml1Xe9~uxL7>y-R9aOY9PHZS!5Y=iB8g#
zqgh|>Z7^y`JD{ME?bguvWWCgalX0dVC*zza`UTB#J+y48pQyEa!uO!{0a**Hngi<l
z4lY!_7@A=cf{u(rGEB8hq(Y^5L%r55-ab|9#EX&`>6m~=j~=ZkJX&~cg6~uwt*}RJ
zx<`4$=Ns#sm^9&tqtB#CO5EA0n=8FKU&-y!G_kEv?AmixS+vOYkY2zJbxmJYYxjgV
zaxdf-Toin?nnUyvTfNps)}+;3iyfB+F1WPfLS{&Y$ttj=TD@#j-I`T`SG;}XwaMyY
zXv(^)1%<f<e0o~#GKDcYD>6m$G!laDghs3kJ#f|az$vW<iLR&CEGg)2iCI|GdO&W)
z8`<U!RZIB;vO3jQhN7D41+s2MW=N(~XuXu%RJSEZCcUwKs+CcGVClm9T3SbA*6Hc4
zV>}x0xX)tkRG#QA2`_UIL#KUgE0$h3VkH&uBE@;(66Gn&HT^^_LY@S^0@+m7t|_?I
z#kDLnYUz@xB_{38g5l0As~4^mJbCiu$rCZ5d=`(pZU!9Pv2e%2CmwqPS53TdVlI!;
zi;VguFOsH;Yx)Jv(JEMZD)7~A_JlXG3s0<S-V*LC@FHXK!Y;nH09TM9r(~Me#q4;r
zEyOTSBTpksWx2*BJvNUW5+OUJI=I1}J|(UsYqjc)Z1W~dMUPj@orOwFgcmLfUbskP
z&YU?hF<OsS6dsoeyVRz8RQyoao>i(J4;(yD|KmYM(Ugb5t$w1GUS+Y(8_M`jJXL3I
zyw~<3rKqT|u&^-1;&Gq32neq4TC_ukkDYtgw3eruhn92A(JIq(JYmVMX&LmOz(V##
zMiCewG?<0hn|UqmYH5Dsq_z6mnT?VQ)=ZtWDa`9+XrQhr>#EhNRdMyEscAE(MQl2v
zkl~dj)T^4YWm=c(LbXmCRcWuAxw-x_$0Cjyx>_i=<V?*8JDr_XS1g&#86(c!&SA0i
z(4)s4kEU~X_t|$?ta$41(de|Q0lUwst7}cwrY@3=I(2ugsZ^BL+Zorw-e#`$eHZ*=
zvuW?sqH9xX)Q_HiK3nbjw0}9X>tnZn2KA~RfjYZCw)w8R4en%vdb|k6A}OIQKATP&
z1im;kEp2V)iYuAim#%pmmu<PaI%xS~iEP!GyQ5lu_;)`&4>c8PD5@zSYv3XUD=vwC
z?K*R+{-XPpY~g&limQtQ)i-8N*=(L2sJ@@`V|C@TlUu*tzl+lKhwDaRd~=Ok(Y{hL
zbsAILs?(gwQd^e@-{0?vJb3UI<T;R0aK;y3y$GM^4KriwRkc?*-c;6U(kt?>@YHTq
zsLa1RNj0~!viP2GclYUeALdWBn%LDP=@#L$Ss<{R#bMK;BU4h910yyXd9$i4n;5+H
zW5piG{^aSG{KNFaS6_YgwQ6tN`YyTkVbft8hObq7qvO_tB}@3jyVi5<(fU}iU-g%8
zy@=7GLqXBLs}^dTMMniK&6HZT<;vA57vdf*+sf^+F)8Ga>(W+VgOxwJv$<v`27eU0
zCTezQ`6JymTDh(MN1`J_Zgb7=*tTKiHc@-Q+{EA<tvaP!x1E;1^wbWRt#K;iki<rA
zi9b;AtE1}p`nbJSUteE8TJ?1~m|6e&Xw}!(`C!piUmxuW@A~-oYur_dsZ$~}#b$La
zTa_u5mF>AA?#X<!6;V?zdoAnOvgHEEHMt;rx1lh9wQk+ED)=jRcCM!X72UO4mfDMo
z{1x4;IxU9TJ5VYrQwg$>J4VZH%A~8h%D%ptTO#VkFM59M3f73&5c1pU(q*sU5|Bo_
z3){9`n)2J})@`rgw_x+OfQ0P>K*E2)!k=8eiobcfR_D~!wN_KNZo9H=+l3X6{&F@m
zC2<@RNbw0=wrp#3(19IGo-Wei7UP<`Ff((h<}I;nw}R#@%*|b@33BU{<*&r*uiXlo
zzalz1)2j|i{K>*^-rtI@wWVfVo9lJ!c42gM2IuSR>$?lqMs;1`%?cA;l)19Un`@qC
zTq4g&v8!$uD?i6>UAZS)yKKvgwQIMlZr#?@-`^u@r<ru<m};vJPssiAvp-#1mu|Rc
zUDV}A)2`hPxpmvc{m{Y<XX?*xopUd3bL{8ZbI;nid$&DcU|`_M<Foj5>~Z1Kr+c<f
zd%(a~bb9KND%Y*sTKzr1F>O;Fx^?T?(6{e%zt+{nzOTOYdb{=Iz2+LHlUC<svu@3u
zrExna)FF4RSZwIh)-}0Xvt3gwvsP%WTD5A`BCRzptfFB`EUaN5?y6PwpiyqfHuhs`
zhRq@Zx*Cj3m%5<WC@ZYmw1Pux%_?@ctSnDc^EJD!?v_{?wZ1%b+jreS(dwPs)@jXF
z<36GMzh3;&pL+TJ_kZj6-@pIy``>yN|Lwl3G}i`;>4a#9tnC(6U3Bc^%BZDb_v5d>
zuif|k`s0JATVAYc_Nl-3)!aC;d$(7b)tQ+yjdgW3XPnY{mb!#<Ye44gd&{0>8<uDK
z9FLrJ=H$%GOrK*Bj#GPLwp`@o@Px{HPF8w%Y37V)%bpyTZ1Uc7a#qj1?K7QX!UI~4
zt`K@!ur=buk&`<WxgDHtu(&V^Y6uE|C<Yf-7TpC*0WJ=L^-uu^kj#6?K6{3u1<j0#
zrl8FhA$9dX8W<HA7`PIWf8Nh`FHxvrU|?n7Qb=M^RCsfsfSC<6sUq}%(cgigxS8XC
ztpmrZu2mXMi&m{#1-g{l>1o3X2IfUm0v#4GEMRoKRi?tg!05ohaDlC%pv{3HFs1$?
z11oF8jRp=O2d;%KjZT_O)+qu(9D!Q0D_%D+XfOmSxQYgbs4^_!2y$7$Dllh5b9-ZR
z(o|Olu8a$84GdEAPGzm?Q7}*tN>$ZVGn!@Wz%p-TsLi}pCUOgm7?uX*J1u`1>S*$%
zhhfPg5#OMNEw;Y=N6eqF@t?0vO#8ooIeY!~g=yb+*zV;v-+S=(!nD6RWiKLk-Db~g
zoxQf~U0?b8Ti<6HpUqnx-W#~e;Ln8{(=PnE@ZI@r_@Wc%7-AT9FqR$G+HWzfd(rc!
zcU4Tc-8poj$#K`aNm94-5;MhJ&mVu@uxHip&Wv4p_3Rt$LTis~i50i2PKaUHo%m_>
zJJm%mc7CqEAs1Q=RblTc+ibm#FE;o<MXlcR{`_1=b(00vZC4ikc5*k7cDo?9I!;Sh
zf@^iYuiN6>86jEsxw?ATm>m`dZrl36Ktd#7M&zvZhOS&w)_%<SHDkk}WHBBw9$~J7
zi3U$+r{#JTsOy=Xx#{(D)76qca^Y_4SAW`7cl~I+|LRx2_N~v}es;6js?Ab~Z;SS>
z&%X6-<=g7G>s#LzzKaZfo39<Ya@yyts~+=~YSpdse7J2^?kkSt;PuD-M}sB)9J6or
zKYw;%&eUk%WmBbmS#%XLO=i1pxs|zW#_?5M5g)-SfA-WR%h@EsL7mo;W3A5I9QAzO
zoV)I3WNlQp=?z;wd+oJXck{MKtqosr>eHr8oAxs&zW5q5{rBp|Kl&f}AO3soz0dZ^
zj&<yZPUMtk);_-H-SwbGr|o#y^n2tA*W)zh?)vG~`sXUbKjg$aGY37|$H!gpqcpR=
z;`^jWJ7mS2lb<gA-e0Mw-S}aXv}{y7SXiE0apP5@gu$M8VrI3ae&5HFg)#iC5D!gy
zv_qbI!jJmttAE?ZtxJFZW~cgt8vPShrut9o*$+LjFxvuF&euKR#?Q=Jh{lXk0<4^E
zYujCS)L3oV79DnY(H%S4sA%2Qi5K(a`PS-AtG~M8#diMou<7Be>ujIw*M9IL-r3o8
zYmNM&f9)S0UAmbY&ELACq%>#CT6WhJHCEfA!kT|XwI6ovI`CkVtdvd|+tCUCAk?9+
zac!+H>%y52mh4!^{k2a2&HGJ{_B(%xX%kzu&1&1ekMEZLjNxycaN*U_@BNkfr*72f
zx30*k2gT!kkhaDTTY3A|>hG!kt*8A@Ft}ZQ#hhzvWiDr?9Mw7#{)*#&m)VNj>Qg6A
zDV&+fb#=<)&~5)U7Jpdzw9ry(wUK>D;D1$rZHpN(Mxuoi|19eNq58DYl55S0e@gvV
z+-Gh!aSh02yO2AXAtz$v##NJMh&oI;8<NI2gLPYdsu6d#=E|sR5vOLIxn`2Ow(t-4
z)IPOItBtHyxqs9?^{6Oh&53`Z%0ELs?U=J@wUPZ)kAJR}F@8Z)XUd=S_$Tyf$DF{h
zlzLa?Z}nTQtvKVBP?gpbQ{3C#_i_hA*_A0iN5y)3dwbWaN(W{Z1($7W&d?3a@HwEH
z6|{2JHSf%I5%mq*BWv~7MxD&w_NXvuy{5;<kTd?;okzX)uk`pAYAk#TB>F1IeyY!r
zPdny>to}8n|7oz%dhO0bTK~G-pa0Gd)lXgZdfn=E3mD!m>FnIXnA@ABn-eV>aqE`v
zvI{e(mi}3l=67AVY1Jo$#&2L|WsD!!>R<I>HpIN8%0FS2FPixA$MxUYsuovjGgmXX
zvUM3aDjX9rdTep>XzBF;hO$X&Y72PRL<eT-25!@h*xIz(P3?-$sbv0_au3adGq;9Z
zRt?^Bc6RR0(0`upzuZoltu{5gbY8e~r_|Zm(P=Bq7UXOTiZb}Gscc_=)X!+gnaI0|
zb1!H2sf(LR8mDdDnj@U4o$7Tq{FFM+!uTbV>b$*w#e2W3)nEE$-}KazWwFy=mc>p_
zy$K?Af`~V}^-eFn^s;2D-gNJ!mkzxw*%hld&3oy}tf*;AFFBRPd4u$%{?&h3@BJ%w
zy6Vlc_@!XYH_Kw{r#%HRH@(>n)_Y}Ftlo5QZjfQSBK4+$jS!Vp+4b@9x?Qi=?Rwp}
z>ko)px9#=1y`|S<ORvo>y&eG)0k?YNw|>_2oUAD@$ym~B>NJ<2Bdk-Wxp*m^I;~_j
zTbhx9fn!rppmf?628j*^?$kB6Bcm=|sXr36Mrw_T!4|{Sl9^tfqFZi9DJU>7Toq)9
zP-0r7z|o-4!Tfb?)atcStKZiw0<9ra=;-L^I0%|X5fl`Z0Es9mDJjFIQ4&D19Y<Uw
zn%R^%2+|!L8a*IWnhXU6SzKJ8i`1ZIDk&U+PtAD$p6=<!qBFh0mBkixLm~g<z2Y3x
zZzr+vO#iLQ!aLocnMJDp?P}?)-mPXUKnMJ8b<S$L%Da+xm2?PLVCnt;8yFZE)qgzw
z_Kquv->6ipqvNxB(2A7nj`wfxp3#z3cJJM#wb>i@&*PO=J3mz_cr_RcN(HYLFMGR|
zGwGsN8^`l=AKPU<-!yMXbZwf%E9I)V*v%!>Ir-kl$FfmzTkE6N>PLNSW^j=CdC+*v
zIkx7fdU0#DuI+O(PnoT9!!z4b@I<H0JA=pbs;!l}R?KugmAt#p@aodnp{p)^U7ovp
z!3w4YD@+{&yS8cZbM9U#6|`z=)Y{Ofy$7cpYgs9@#A|hg!n+6W9=v;QZRDxK5c8Z#
z$(nnrjO4tECtQ^e%PKdU)vv2AJ)gJp?RDE-GdFi_Kl8=y=e*9x2Ol4}egX_j!?s3v
zFW#VDQn)?l9pBD7>@n|{*Ojxqo_p}Rb;An3<WkNv$tza8cFj0_cJhRIIddBCipplJ
zl{_^);?2st2@l<6i|-cSa4$WdD0|(uQ8eK7yw~%Lr&=#A3wgKABJg<3_xhNRb5`D!
z-n6`Q<DovQ=ewTw%)NL+c$dZPb>-|a?~d=iSH7Y8?(=H)>35%3fUIvY5<Z#oN%&;S
zljEgfuCkX7UY$JSZlq;TsVIAtwp*OHx}wcAKcDi@l)$?>vXPd(S0~Rn9vD!%XiMso
zO+^T82lh<!bE?#tGo$|9suPQMMTk#2dBR_H@?_boks{@l+qYJ)x-~m+iP5&OlbcN1
zq_wlQt?d@LoSGXFv1V=f)2P+Iu9z@(%xY^e6uQFe;Naru=)j;bL5%?f7+D$>JcL*p
z6*zyhG5l?2sQo_0G2nB=s#RM<L#zT>ow7wk!&a?oxzM4oBZPC7L;b8JvsSGt4b57$
zYT;DDP{B|^7l?iX4i)JBr1;$EzYGivx1+RO7JIvDu4;`8k>hd=_d4QpJDDpob4%x>
zBi#QLr@s2X@PEMnH*uPQuNCChyKnds*S<<<!-g9Fr!W4ms95o7t7_I&X4M%pjP}Iw
zE56t(Fn!@K{~vqn<u`m4l~aA)k?_zqu0Qcr!1{$B_VHgT&B<B0>Vw0PE#Foj_~ReG
z_(e_AG%3063xCyrCTZELzW%Bs{@}}uEhY-<Ut~n_KPt@-TYZT6%Eq@<Hf^mh5>2)^
zg|&Y%(PjT=wXLiFWYwP)H}06}@Cs+AxR&OWNsAp`^}f3)e)XYM`&H{-U);DOCqhbH
zTtqXYOiHYI)xVFqAP0TO$&(gio4Q}@WXO(PJFNM*6PK2E>4kT#+UqTMx_QEb4YuLW
z;=3ly?=)iSk>6CPxLVU&^|-*C_~yU-2W#Y3|LsthaDMvXmpu1{OWPlE#>Aga-tcu}
zhQ0RpmUUr5Yo=xGi|1eXVJ~mJcKsyJ(t6##!>k)F)R(Htc&}3zKmG8F)rYut(fy%b
zu^^2Pc1ZER)0!Elwd$)*b^LU3cEzR(8J35FVq;_E4kz8nu-^#NccVt%`NHp`Az{1r
zPhY&@!44@N*VI(eLcJZ`Td%%)@y1qs;evZhrtI23T^S_FyJB&@>T%(_S3kY@CC~lf
zi<zf)Z2akFkW^U3gX!8QLhHQc`cHQUo+yasWoH%Nrz9L3Kkazp!2;XxnQvVs^>)lJ
zEv&F>KXfBA@^Mh8{_}l$>-Y{gJ;;na688F3*IsYA>$dUJ+7%Dxn5_AD(rMb^rFE(r
z4|d3}dZT%5W>V26&y-#DkJcAG`YZpUuKSB^_$;Qv?l=45_(4e^^x3La@#|85?UR2|
zqu+eB@<_OLNa&=q@~NLb)bh7}s9JBSsru*dqgOZHnCP}mop&Yhr{0b^wbM^u{9-G9
z@YS9-Q@wxwK6-WIje;0nZHul`pBAkTI==Pid2zAhiVJg0);#6Zt+)MHT2*f(Eq2)J
z+oGQ7GJbZapMLlx&;8(QTtzEb_lq}Xx@}WC)~pQ-S9-nm-oDdMFFvsoKlo~sr?>t5
zJ+X0phm&q(Mz2`R-KV~{Sbw_vg&*<ktL{wowx9j6w91-~yK!m3sy}PB!db6pzuP(e
z(ThLr5BBkDPf^*t_Qzg`=D7MRfvv}d@9jIidNIhKUROPlb$h?Mu<F6Cx3$-w#m34{
z_#<}M>#4@HgBSiyzSOFJ=t14;Rh*L^x7Ix``dCuG@R$CDZvitWpZN`TNHlMdYxSS&
z-9M|WdAk#rCan&es?BX$IY0H&i(eoge`=Y&|7^vsz4fwftskn^g@9af4&=cvwql39
z{ssko|G8c~9F&CQR)6r`x-j%$>8<bU&+Hd>2L<0cFVFPPb$aXFoRfaohG%IUdffRu
zKK0X!PavbeFzufO@;`6)gRgO-abZ)no1lR=;l?(puprI!&)>UOU%UZ|*4p|&H*p#N
zs%P<fz2LxHsR=gNJ@JSBfv@o$>rY)3Er>1K_j+bwl_e+-76o}*-S58o;=l958oAZC
zx(s$as=j`+w8|Xh%Pg;@^Uwa+wO6*C^}wYao#t^N{D;22&A)CFx85C;2-kTrz1ZK}
z_0>iEi>>&=KWl_eeW*|KicIx-6k8yAey7>}*%SWReNT)xvHQN8>*vDH7GW9nkI#ud
zYoBlsM9w_4+4;*aOS9XV-_6y2J-_=%<-Emr{ps!-Zfuk46g*JR{lj8Spw@wZZQRU1
zqm=rE{``sJb#^*%X$#jh-ovboSF=KkPoMfIEvK+P=ok<0;iLnXwz1ap$h2`Yueum2
zr~30p!-Xp*I=tErTCa9(vtPI|$E@pn)K;zalU}d-QOn=@ATv5B=*J?b|Gzr9|Ga9A
zQ4P6tGE{1DOUt2%rQ8jz6E=oMOpS~*+LYq6;?zl}Q?8QC+G=4w-AboUPMyMa>g3eP
zAnuwOE|Er?Qd2;JA_qfG)(0Hy=8$N(s;lGU8?`m-FmIF??_#&LQCo9Yhpkz*;_B+K
zwNYEMu1amqf-n;j5)QUWMn+9r+RP><*48GGIxRAH=C-9P6ArevE?n3qnK~^xEq7&B
zgh66rMn+;=Wa_k=pczFTiHImEiNtA<soT<Sfiz2oWzAaZHLX4}wWaM^(7|SIZf9p6
zqtiOu&fE^VvLWHnp$iud^K3e;yV>l@Rvih^)W}s?Q?(*frwK_#O~WuuOssQN$ja1d
z5gw7L(<Ej^&h~;B$j0l9Y4l;Ov%w)NgHG#gm~iV<Jt2oOtyyjA8?@A0XVW2PEQTT6
zX{zhZ#-pRl%VTg_XVYzCR8PPpA+GcUx%5PeLBgR!^%pK2Msp;{zXlt&m>3+^*>pM=
z#ZF?SR3}0F4+_vtkvbA^<1i%ZK^C2gOq~V_TItBGQym~anug?=lPU1{z{-THMaaU0
zz_bp6goF*;Q>v3d{>Kx|5ooCfDdrWo&W=7CUkciQ(c9a1s?JYkju6AbDRVr(InP`8
zo|ErE4sYXzZDFTwZfaLkQ8}o<)Hp@uNV`H&Df7ja-h-QRbERvy{d!w3absnhVZUeS
zEB1c5y%qD+S5-_t@oCR`(bCdshj%SJdMw)M)v29c<%@SY+6Y)p>Iu)%IQ3~!ulJ=Z
zD`rhwx-w(Kgqb?iyt!Q$EtWWD^8b+V&p?fTs$E(VnkEkNZ^N$UtW<M4$eq<#aM1Z^
z(vp;oTAOxs9#Khg?CdJAU`Z(qJXG&+V%5=th*dp$q85#k42Mo6X`Iq&k_-*go^UiI
zqcG$F#|h`=mcVwVf*^^h5j{LEks*f!J9u>3lzLPf+O$@S9_?Cjx>HYR;gn`UH_leY
zPBxBMr-$Mki(9*d8+cYN+O<FQ$dr^#?Bb#qVl~_}B*N60TRl!Z)b3btD75RrMy+~-
z9ZL&cc^Z<Iq)gLlR$483A}J)JK%8qu60@+dW<g5J;ii~S#|f*oP8=;~b$h7Yu&_Z&
zQ^H%*v1zsF)rEo6g<>?FLsp&aRs)H0H9M^q4cWAEs?M5LHARWmxV`bGzAfq(`e<9V
zH%v1ksBLBF)Wic%f{ZM>9;`5RjabL+RKJ+JE1WCfs@6t>iylYALYlp%c0DoCGO<`%
zu#`76^tpS|#B+R|r7R|1o7Nb{WrXBuf-O99*i~6HGKg0zOnbG{Vm*dOA|_L#G$p(h
z+NLUt1{`7wbt%32Yu%N=*2(MEtv)opE5w9xBE;s<La?r;3o8yi;8S$2_Y7S$abiS>
z)S@-viVFi59-1z)B7<3&-^yB~ub@=)VnEi)$S{fZCR*kUg<MizYejmx4lTGUnzU<+
zmeHfBho+c%t(kGM7bd#OXUd_}M8l*>Gp0&S5r5Zq;g+;_)~!v&o$5k~1zaqT{4M6r
zoA{2YB&M`5PBl(s;mXkZlocsHi?ul?vz$@o2@MnS2~C<}uxg`9(lo7R&M+=-rIb@M
zTqQbERvCp(2{;v6-=g?~Yh&jm<qx4Vjq20__6rN_3GY4@&2JJO79Jj%V{hu*-LtLn
z&N?p}xx$#P3l0^XOMF}|sZBKKv^CUOanx&rnvbxWN6-4uS9`-(y>Y6lziQy4wVLHr
ziqA66ZcXvdrmD!0mnD1ky<0;nE*vzPv_@FX<z!RJ$$*!kk_($srbei#xg0rYl&bV9
zVcxuXbG@pnrn*aPStW6cOLN1;#cpOjxgt^*w`Q4{E&$C*<m4`P4a{KR3DXws?cI`-
zYqsog(v4N?{r&y@18t2~d^HlT|0CMydQ^Y<nQihJrRlAy`r<v?R+;pR1-)l44e1M5
zd{m=EBthe3H7JwaOxYBvqocC1C)tJnkyLogM;#w!ZI@FQ5>9LDO#Zv@=zQ%kZ+CH)
z!YH+{w!?|%v<nL(vvxOL4?p!bWozlxi?U&zQy1PblYO;aTyz?{OuY8i*469k*LA$w
z;<J|T;fD92J9ezu==>=(aLT>|H<?=|Y?^Lh=J1HCXXzQ<36`wFn#Ig1d|oW4Vh-G7
zp2{)Pdxo?^(F)HgI~zB#Gfhg>OUP+F=>QQ8<phgr2Kje>sf`a0#VAUaCW<e#<!rPK
z4Q#1ze6&$DVa2Hf{GyNcgoj=UNlluxA-r?yk&iZhtEXt3I<+!l;Ylx}J)YVJ))*YV
zn)qmAo5bGe(5LYq7x1{O$Y2)KYFxpg(4k?<f5<#~?X}lzHjWa<3~l`-RxJJ5Q!!61
zeCyi;qmAB2AM3W4*zhd9dM(=Z(bq{;OQ$T;`B43osjlAB{Z*IIQl1ry51dTd@2%Q8
z>06}EH1Rdb5;xhoy-ssZQ#iEAHe6Cq&tk$Ei-+;MWc4=v@Uz&_c*aboY`wv**wjyb
z5MD`)PV>i5Z_Vn)P3&5$CWAvOFjNv8Of70b&)81LOoeh+EdmGEp^ll}GwP)o9xMO_
z8^cr4z$rT$H}JVSfn=E{hU!n|3i@eSGh?66^sYF4$sC&tuRg5f`dD!~Yq7`2RJ{-7
z0sEDbR=!eGs?+foKH+kfYt766!=wYL73;K*R;&~CylRxua#kzMXJweihm9N$lLQ}D
z#OSH{gt}#<obuX~a&)pt!A!&YP|1alDw@`F864*K=I7=y+8e$)yK+B6(4r$Qft?LY
zT{}7!3!PNRIGb=wNlB^WNJNjz6f`(ZNu^T*32Hyi4L`b1GRN*m%nDG{FI**~rjxXH
zMb+L9=~JfEEp&en_(J0p%gK~Yai_WKRY3u+Q+3R66Q9`CM<0APvZYk5Gm43fNm`w_
z<Eo#yWR<#1jKec&K5O-N?cQtl1s)d{uxvZrclDXmpU{v~F$Zq2Ybb$2EVRgL1&F)q
zNr+m|Gq$7Qnp&Ww+qF&*oE$?>1^9T+kXDUZ>68?6;HK6Suf;;o*iP1mD>Xs*O#9Za
zZuquuy~v)})D7?28y`(yeZBj<($Uu{U%fSbA|HG|p?}bx<&Y0&i_+1gjS=fzT00*l
zB_&mO^<P!k!y&(*wN0W51X9Jq!otErdy+4$?D6rJGwiAJ7ycNk78Vv3-teJ3#3m+n
z!{-o-9j7bwLS^*W>Q~vsS*_Dc38|RWvtqH9#!*nXL`3RL^HzPcVPk*9aSpS1Z5_3U
zW+S_BNj;r)hM^no6l~UadEDJ0b2#y$)x)&76%h8-x{Qje#fo*JAxCyLZVElMQdsC2
z+o|bFp%T*#%tCgGfVd}O7OgVWOUP+GAqb%y>p^tqi3KyJ8<=rV33XFF!`t-KOPKMD
z@2RQYnOiPZg?er|)uvOi=R^6yqJ>wlMf0_-D43@&u|7*~eU0QJ^(X!(<}FI<K6H#x
z;sB4&dQc|r+7;?78DKb>z4g$CJ^HLij%hkeEe+Gq(+oJageT?T!-wrlRvbPUlGrAZ
zwEj^&Z(QQGLpt4DZ3p+ty=oViER%Wg9TYrSi^W}6^~mYVgewM~S}DiW!zvljGtHZu
zTXoXOlnt9Aj@c%+X2$8Wd`#jw@iiu8$EF=8<~^Bnxb)DO-Owb`6FI%h;?X1artDog
z7VFROPP7YI*_k4=$F<e@)zjK|NNm)jMh7T1)}Q{~Xv5iPpeC5G#IQl)Xir3H1;}I0
zixhi;)}$QsvGG&yd{nWzL$TL2%qUq+yF;;82rO=Jm?va0kHKLkb`FzSYr|GMOB^%o
z>Vc$zlRq}3rlux*XR8eOv)^W2yM@hFK0Tv1^_Hg=2h9-{v)BHx%3fo!md2?rgD#^;
z9UV{#Xl<SJ@$vC~d9A%+5vUmh5$(rxPG6NNEMz{ae}=c|Yv8M@dCQO9kv{lrMPcFe
z#B==M`f!zDNz{sik3JqP2=17tl%&RTG-R5#XxGsyE}eRPZf<VwFD&~579HmI_u(-(
z%oFI^Z6o>Y2FFFW2{vyVdc_+a7jHYT&e_vop1w@Drp5z}4<ZQ~hcr&6Y}l|VQfHc&
zn770+!=+(UAARr_Q#jKfdd$09yC*cqTn6g0895e5XI3rl(_{MR{f4*c3uuz?!~5p5
z0goPsJJ-*V%L2#x)4-K}oR2;pE%ZDvLzpRPv4CsW(WH%WR~?foX3Ur|f0bihlbA$R
z73lQ82G^-mr%ru+eSO4{BOf129Dnj>eh1H*HEY&{>3m3^%76Ov(dW%JD+&wm>18d}
z`(deaF-~vC>W&qE1KmObr-~$cAqDTTdc&T~ps$gMMn@zkzS?oJFtxC2ZQJ8kuzMAX
zdD|s6>xUE`JrJi^+ql<1_{vv11)I1;P~e`^15@YO!%G9FD=wMG*)2cyr|>5=r6e^`
z!vJvbRtGIQ^kKt>4SW4F0;_`-9lm_|GQTj7!Iwi$8<Rm!?E0EoT3<TtFeoH+7nEyH
z>XG~zztD5alqxO*P^F);DIy~7^v$ZcX`m2Z+kBogI_P7C<KshT_6h5(Gt^E1l>}1?
zj~?Mm-0)ZoToZ|DrlzK*=0<EjI4{Ir|GXI3>^(78-C{o!c`n*m^=JJ-dlqm22kC@q
zi*|jh=ZKi6rlzL;$|HV3Yn$A>8K7+GrT@`M^O4pf`?H!MYqPd~Jn1Z`kr<loC9+}F
zzWU=bIzKJ`@8sK5c>V0U>!}h)eHKex+PXDj#kABUo->h;3Sa5%_1keixX&=@%vX!Y
zM;`YJpL>;)>$}D)mDBJ#>v4`0Bb6lOV@fv3&y||G>nC%i2Bd|RKCIAMx3Tn-pZB4%
zo$+t%Z*7z64O_i??KS4mr&*gIU_Z0ti?6ZaUv|hJ`Xzt(>DK#lZ)2u2KTI(L&l6rf
zSzssToV+^wJxRj#L@B?1dY|acisztN-3yPl>o+&uv6GFCzh`@EryjfOgd0C|YaicT
zJqa?cd>tYTnr$XRxc>S*vvuB$A9nKgtzEw-7v!NLY1!!b3Xsts_A7q)uRr};)!vx%
zch%qQXMR{DC4cJ5{^o~8GSW~rt|xM8w(SF{KJ>)I3Onn$=)(d#am9sKw=T`uCM)*v
z!>e1Dwng)G7yKx#&&`b11<&+u+p=~Vc&0ZxHg4^Y??;Q`*$@4ak`C*B@K5}UeY@DT
zshe)p=pJ6YT6EEclBo8>AiADA;78RO9X@Wwi?23pFw<%O@HHYrTFm*=UVUe$Qx6Ml
z#KO6o{>FFzwx0TAfAf!+wyCX8z|r-->&gy!ZpDRH>$~5}{aAZC@xwl`h2UxMnsC(v
z4{CIsAO4G5|K?rz6aOPKR;r0k?K+wga42Y*tLBdtKZSp&U9=E>;@9$1_`&=mu`VCf
z1FeKt%;mh|*YZl;sW9Y~x>KFY3%^ArQ1MM*rY%&yRCuAulvnB}=Ck|^{G?ug(0*!t
zXro#f!&WEbgs2k{Nq@vt)@bzzB*veA{z!LuleX89m&=s+gMZpGS*<t`dgaU4OI|NH
zf9S?-mDHRRdNt+Cmq&~rOE!vB2`@b^EUNAG)!<^+(mF;neeIliTMN{tOPy@hep+Zz
zQ^D||%Rs$l)zPHH7pwMn|JZ-@*Q*pst@@sj!#^JuKKLV?`onAg)XqPNE$kob#ajXo
z%!r7as@?Ud;9{%S1I|DC+CLxVu5L8`{&q*oqe9R4RbTD>eN@Ab1Rj_j{wOrpEa%JA
z_=ViJ_JyrF<<l7%r=9gPCS3Gt&HAaI_BY6ecfH!RZuKfK@o3k&)t}(JTlFC3*VypT
ztEI8wp-W4n!>(@4jSl}1{~#&g)KQmBEJyw<Q_a*eaO>_B`4`@*^=GbCRe+&S@S{H=
zeJ!U>rK*<N+FC7H*R}Xz*4GsWt=24O3}3!nRO`n|IhL<6%ca#+)-7MY+%cRr@Wa-s
zldr>>YSxLYUfJK{kn+!e&cUo8qk5eh;ipw|L$#kgJSti<|Ky)Js_rkg)@`aYEl_{8
zU-+wy%KG4TzbUJKX-ac$O{!WIb~$}{sMp^~i@!wem$b`z;D5Bx&R1o<@Q0VTrpBNA
zl(D2jIP0s~%uwyL^H+m*ga$n<G>cc~?)+FYU;N~O(m16G;Z=V+<GVlA=`HtOdFfS2
z{jNERvU<xOy(-x?7bLXhWvNvhL~7S8y=j+Ix7^IN@akW(;-6UmXUBT&&LclfChhNk
zJXLG2fAB|3k-nBwuL><gwJ%?u8nkE9;tx@Kvkd%JcOJPKwAa=$Xm#eRN|7GUrHS_H
zo4h`Jc`|9Is{5g<kFP5pn6JI^%E?7jKi01b%~+D)6Q;gV>+ngheg2bI{_^U7SQ&rL
z-uZ+7)2cZ>tET=cc<QzO%3oiR{sZ&7{`gOR^35~8-Op3|lUM)6tiN@Zd@O&%gP;8M
zPnr6w<jK-_SLH^Fb?O_nZf^eKwZ(I3rX7c@bHj%zC#R^KT4}UCWyPV3{R&&wpZuj7
zQSg@`vEE?5y3)i8Gh_XPCwYDO@?_GUNzkZVr_Q-#>dTiWz4mpvH`;~=ue@@}>&us?
zA?rK?KWwe|dZIx6)T^?f^}P%!|JAzO7utred{r5$E!7&g{8PQU%8I{Y>#ska@WB6S
zslD)5+eu*-MM3LtEXh&3y5&-8$lCe+SA+I1S@Bn_e*N)t&W-k>SKexVITdnqbM7|z
zcD|5R|NJMrDzp5ISMU7zHe`KosCH|}9E*Y<4-Y?n{P^*5zqwW=FE1k~6TbfEPt~9J
zt-kU#G<^B;<vt+kWu1YSbKB0&mp}L-VOgX=%BBq~5`K8v&#o`d%d6k}_Sv-4XSU_K
z)qnVQckkM@Z*#NRY&Y)Q`S#`ZW!Fsin)c?p-MjJaLGD}qlF)cnXPKIM`S#-<|J3(m
zS`M-c?34qqKB~9Mh6n%b(B|h_^{?K(`Nx;3@}duJ|NJq3s%-em%YVM@xR%=6>lprH
zl3hs6`pK7{FVw34qyNd!Yg3QJQi+B?e%f}0?o4&sD}U6<b(_wXmRcJ6&uj66nO^Is
zeyXXdnYS|Z$5J+)x*vA?>-UBjtW$mWF4U6q@w*=`#m)C#tw@aVzI$g?k?`^P9DP3g
zdqZ7yLxa86&q_VDqQ7cc$kfnzhwt9KdpDGK+wG)Ddsa1pmoh5VuR7uo7@DNu5SpEJ
zYt^c4YZt8Ax;2+IbnWU~)=*Z^YP^tDt4`fI23_2UU>p$*3%jPUYSXsO|GqDoH~HS|
zd!Mya(%KaNFLAsW|4TFUN#&|ry=$j-WZYW2;?~WGHm=;TD`~+3M<d!4w?+qU+_aGg
zEKo0S>}sxCsv(cw%`z6>76bYDSL3(8FE5Q>zI#F5he<j)+kTyj=43iF!G1yJ?dp4X
z8yJ}6ZdP5Idwy5-^7U(8ro0G!?NwfUse*m&DlPV+Nr4YlA}+@CED@P3`f2Ch&(Cf@
z-xnGhV!P?<QtSC8-~HnwFP*%w`r4Ft&zF4Q-*rD?+r;{wwM)0}bd7hgbzir8cf&i&
znWwr}g$hm+S;fS{py?qYRd#)|!K8QdzLztG#^m0;8XA(DP?Q*ai(PSfXYJi9s_(2<
zc%N#teZa6~@tv<rt#>|9-^2FyZb$C!jl5>>LXR-Xo<3qdy`x-fy#PnK?w)d)eS0eU
zx%N%Jw`bqp*QZ|}@2LN<`qjP1JKBpr@;wcG;o<l65lF|>@P&$IcW<=a-YsxB?`bS2
z=eBo8K>XR|S}#0&x0fkydw0a-_Reqtj?|vL+g>ic?R(jKyYbR@Q*v+Kxc27dLX%Br
zP125SPfw2CysYKY?UJ**rS8t{%{w<s*jwkaTTXUandxq;3}4;tKJ~XZuEnP3w8_QU
z$a?CZX=tmQ%2o+j%yz)EaCQL$6IcKF{{jr4rI|jQO3d%|J3<(kR1CR<WDA%$`WP6P
zW8H5nNV+HN(VD6;LCaMrU;-Dz0`=J}4g#QAdIk`w!N90gKZ#-CAqIww1ZRg;6Sx9G
z86B7!7H}~tZ82qFm<U$MV8!v`s|cg76vG7uCSReT1(^#N7hL(fDr5-*1H<I2nt`v>
zS5zrqNny$gb^f&YtJbmxH3g9+S)N-~20Pd+xZhD1{IYJ^v%mE|QrWMI>#Lk+N+@1l
zx7~atUy7Z7Y+il-zRYLN%VYEMPk&@SA?L7$(IGKIv_V6XX%iQl!%EhcqSYHymtNWV
z`E$dbRo`^B?3!*btDxjD!J#trO=M=NUgaewmFAD3U>Uo*LXAoMT6?>7^_HGLZZDs7
zD>mkx$dqEOGn0)vcdR*-#<kvS#kRc$QVmxEMAv@i5=(S2sCQp`Y#C3=UI~MQ4QqIG
zG#j?Mt&Cm$<>BSO=T6306g)gU<>BFWKKXEyBM%S1d3gB4^PBy9dxWOH)hc^?dV2oO
zpsl^2E5_EDt}|Vee4zDFXvIAB&PUl%*LJN~x&|b(ws39X+GMF&Ffb=HG%Ksn)YPtH
z-^#B+tH0F8PWPK*QFpqXFMR6LvaoAm*C61!;Gf^C-|P?G^w<0E>2Lqr|LmGG{m71Z
zeVbQBao(+;KA&5z`h;Ze<MUVE?3&*F?T`P<Qa$n0kIyYvt$(s3ZXZR4{;9K?GyTY}
z`0J0#;)Pz8feigKo%`v>=fRUc#pq9;S8A!Rdgx~*IyV_2TVDp1hVo(D`T19V>UY-Y
z-JkffZt1W1?eVgG-Vbe-ug@1<`OSCv^V>(W>OHr7UG=JF@|Is$OKm1^`Ioh8p69L7
z7~jcVN8Zc{6TkiI&HnDMdeiTe?29Y?F?af;hc$ct6k6)5KG_woZ}F-ucKW23HG3=T
zYo`AQ^%0s=uX(U9S+mPoqF$r_$gM|39m)KwlwX?dn6pUY@Si~WhY;4Mj{lrnk31DP
zCcipt{n}4HSAEr%U7EOM$!%>eu4&z3CRrCVH8)3f9ZXxgYSOKsOV=bGe>7~@?mVUV
z(<Rfe?Yi(3=T9Afd=f!M{8?l#ERkDSZ|P#M(SPKabc|mh{}K1EVNcV-Ql%KKT?}>G
zwkbMq?`n^-9dj1RPjP>g%)3rqqrFS{qv7Q2&LhrWAO<~B{N+-oW^n6Kp}=1!`}s$X
ziFY>l6%?LvwGQ0CxPs|g?~>brYnxV`3=6s!cXi2nv)2|Kbra<~d(3vsak2C0Z>a~_
ztR%k#V!j~%CFPGGhjz5T5`3uf$FkWl%~)ttl2X;8uC;1*EP{NB9%i154n0Rhd*TJ%
z4<(By%N#50`c<2_sdvh<EpLVPIe33Hs`2mqXs3SU$2@=aSCuyNJ)eB4w3+9xK6&Mn
zPnC9;Pd@olWh>XGzWCycFLmzqAgan<_~MaAg%<N#)=SRdGT4;zsnTZt$v^W?{+Z{0
z<x{2I<daY%f=@pARJ(lg$roR$Y-Rl27hinwryoRqsZ(FvdE`-{y{5v~K+jiNnw?q(
zBJ-B4_<~N%KNV=}8TdleV$$LZK~<9$U#JI@5TeF~eMxK8D%F>Y@d=Z@1gsB0BA%?8
ze9>vIllMg}TP@F3AmUY5zt^OyMT;*9Wh|N{FiT{02<J-8_^<zWOU|5eNY%*W6r+lA
z>ZT<*iyat*CZ*04T-oiyz#^TQyX;ozRBbJ<Q<pYnW~NMvaa$EFo#VnNz{0}7z#_=t
zd~e&WrQ5F7)t$gt2iVa8UiR0~p`<J*ki;X=0b25B0AB3}KAAxfbvdBwU+}rpV$*fi
zSa_yqH?asz&vavvsDEb-Id$P~=?%mY47WpaSDAGuh8<el8qK;fRDb{f90r~P#`eec
zj~50lnP+rttK#Z4D;G*`)-esq4gS5&=#yvA(z)VA*Yn)oWp4=$V%+VWv%SYzchhnq
z4`zn*irQjpH*MHDjmOXFkW#lu#Ddt=ZP6g<CCv5N+&PmE<S=~rHhtc;?Q&mtRY%#p
zTQbRDrpm@nt=)Sv*A-ZvQ(T*!x>b9w>A6|YlB8~@PP@e5|C7-}>wptO)08M)ud7;G
zI#JmntEMi~(p9^()mK!iOJ{AcsMzGpsAXN<ZaQn1Y3Z^q&6*nedF{5pS=aupIi{Fq
z$aPlYh>HV*Lj44^b!y&^R{gl0`zL?;s@u;O@UGb#cHTic+Vs_}wVSh;bsOYPEnwng
zN?=qkFE5W-AhAGV6@v-S8D?XKGY5<fAdLIh_wN1oJM7!qSF2Xt%r%Slopy?2Q_9p?
zN4mpOLv^!rH)NQI`G_^F;A*(i#w%5Cl5uT;S3=e@$p)Xbn^jI_Mb1>&w$$w8qy{EW
zVNv7Y+%4N~CkDS-q4K+RRhRysqk$cZg-`$8f7kxXJdw6rw{qsGH))*+mDKX@Eb>#=
zzuy1dSM3^$p`qEe%O}marZ?!XED{%<{<Gq@o|gBd$9*w+K@(4{u;{c~`q%H|mA7v{
zeyE=p#$vF}yU(&@x2L*b;Hg#fFV&v97MybB_U$a;lq<LM<pi}ILpLq?=e>T*O;fXP
zpQiJMtd=@@WT&3RQ<eFtTraqP>P`LlZJy_&%IX@$*j=&Sn_jQGH1T^V`z@irlh5A<
zskHV!wkovm?(&m%>ZgDGQ<)CZ^(sCQELU&ATJ*3`&$};Z;@432OG2+~-u{X4p7hpF
zs%x!YjGpSr(p#Q(Q@IX>h96OtTYAXDVg`%EjKE-rNYUGm-^O}RdLVjSPh9B9PA|7r
z&5C-9&&3}-vQz8fidB~$Pv`C|m@sG6%D?JYC7<g*`r|$6is*5f9r2w-QB!(D*#)M5
zvU&O^rrvwfTmQv@p?$mFUi#y`>8;94rhN?imR{QQ?Z;c2$wwZB#uT1@vtzpISC9oA
z-f!0D)-In^F;_gBi)X#Q-fn-Dk5-;KQ?w6=U)dE_dHct%>8ZE4Uaz~WxAbNi$d-WV
zpKRVfdK5D~t6r*WP2K+Z?Jw(={?@<cX|yn&A#UlVP4%abZ~5de?4{lF^w6W2=}$GK
zR`Dt7KdHR^W5;yWTXRfBBVJpVfK2r?(z4VP`7q_Hp68K^F%k+VWBfR^_dCRNz5VlT
z{-ug}p@C0Nw;tK47c_Czf)n0f<=3Hxgcm3+6s+01r*_%NM~PgI`(pHu?9}ygt6$aJ
z;r&yt=pQJk{TB<ZmMy)#^vCqnTb@Q*R!sjUzm<HRzv)rT^ov}N`{GlN?9>aGIyGoL
z*W{OHx^Ks4ZUTjbCR_OQ>9L?tX;quFxIzDw-HY?q_2NNqb~){Oz1@3dS!}4XBHxAS
zA1c8ye&wH`*2Z6d>+Uc8HT}*0`cRciAtkJ@>|UIC3JRx(T#qdac1&0OvC7R!W}*Ir
z&)Yv1>UnRqND56}^Y+rK*y$kk6&jUXdMAH6@}0c$K&Z%1omKJMs%gq^e^=}eda{#g
z2RI}}Jx(|WOmF^r8k`_HLzjZm$)kWdjP-$E-6~K2*e~>CBiG};dQdp%z$}{%w#=@_
zYfb6(yy=f1ww18{b-#-i4Ejrhj0B!?*0awCYk9Z)W`|^4Tx{7q&qrlK5fj#HasTSy
zWqj`b(JQ<4Cal{9ak<9{=Pjy#<jTO7*!OsW(nCEYL0t7TnJUXz)xXQwvI69Lryb`&
ziN8*3;)He$?;ns%@ly0~$ZFa2yy-!2cCA#KwD`?b_KA*<qC)M0Q?9(&9ig;QcJj(g
zT>n~qnuM<%v@`3!ca1aJ{ey>OQ`*Hd%=b3<oApna+7x#2^PO8p4EyeYazadKy|PGq
zNY@^XIMoHe{w<$WF)Pq?%S}_0NozFtIhL=i_%>T@dBZ;mfrF1vRjPMBSQQZzexUPJ
ztdI>T7tC@3t6dt#B+k`+37TXr!&ZfMPv`C|idm$l<$gld{XbJkeS_1!C5JAtCTX@j
z3<+lqd8iu05hE@ddSun3dYN$Hj=~r}#iNB5?V?8>$#AWD80y{hXvZAqu1AG@+MP!%
z)~O3T+A+r!rT|I30J~^tj5|mdk|2nyYT;GL$IjhRu;9U}eM{q=eu+(+20mm6N*PX^
z2;R}ulUxt3{iMRCuFcvSu`%W3(xsD5CLLXymPQ9A$dY=fg><kE$qJCo5R2>AA_<ep
z%(w_KYi(K@K_<fHwP3aNkkAIR!AvYHxDW<ovD>t1-l_<4>&%&x)j&esV!aX@vm<BD
zG|J3O*%X0bM(Rw{iMp1S<})iQDk@TET0Mj}xBrdqs_0PfjOb9^Wz&DyAN=ro-L99R
zrPpKp)P+~xdRw+@uIok1q*8HC^+5MP_eA&qs*g6cs!#e9=Y2FIL|S*+>Ci`eR90OG
z%Fr}fsWxHqktyr{cl9rtBJZ`bVd={dAC2awgFy+NExO(u-d%~I5=&)PEa&L)6K<?`
zW|Enr-I_8ZR8n2!p-7U)A!W`+XC{eo&DOvvkLD=#c*+!X9Opc+u#rb(#xg-Sl^!L7
z86pOXtwo1cobD><GE_+vY&o#7k#Ewf9UjfCNnH^E8$<1uw&u15PWO5!k|=nqtDxh^
zgB>CU3!W^D(N;OM;-p15$6}5iC4&eNg9V4`clv1cEaw8LJkHTm5W^)Akg(*?hAxAS
zL&~g;&Rjg&(?s23v|9pO+yo_bK(fNDO@U4BS9XNwX!Yy@8P#_sxW!GK^}xbbc2%y2
zk!qrDo`-h0O1LBnHXT^l%I5XdXsV>2=mE7<j#GliHQX%pw6u<_I^-R=)HP{oQoS;3
z*Mw7!twpCoQV;EDm2@&{N!S=9>0z*HVryd146a)3*0NI}sh2=fR*U8=l$awfsyL;&
z6J$})VwHz6PCW}HoeUyY@+^@E*POEARKYq$w}3uNC&Pn<L6ROuOJ;;Ax&`zsl+X!j
z3*yn97PMGT^oYhO!6{IC>s<~ecpO^zWt~tt>x{`pDyNqgav8NGdL>3U8cazDY&s~|
z)F!gDHBl)sB+=twf?!MgkyStD3m<u;ch~hwykKeQiYr;BQklzUWod#Ire5TFF{O5C
z;J2ynU)5KzJ1<S+J5{oN8*jk+Q>)@z+Ag^*>78~ub<@={-f5>(S6x^XHK~4aP)L?n
zZ(!g9?^nw^6O9z2OhXs*N-nn5a;**eF+ERP&qecSf?;HswoX{A%c4i&M|KxR7Ag8^
zhejD(oMpTv{Yv_!Q1L5StKFoG-7>;oF-GdEdbXT&+Mq6|YN*GsVFuS4&Qnc3-jkLb
zN?8~oJV7ZbhB47VG(vbP%Z%x&o-Oqtr3x-bb}$`E(AuD`#c8PLHJNi#Yl5FcXJ-Lx
z%Yo1YzYw9Mn5k;Qs$2)=Gztqn;O1Pl;HvjaF2B>u{pJ__o?7A;G1v8oNraS?l$3(W
zWnYs^$~+<xJO-D2tx7r$v$Ao5`RW;N5=*$Y{fhnvX?}~ifSTVE>d~9u+iq7~KlL+K
zUOUFgbZutVqG?;#sS9^*y>&A>Iy!VqR%+PA+ge-21^gEEs!DYkn2F?Ui=B2lbkmz{
z(YoQDfxfJ2O_LoxmwMW<{EJiV7Vzv$`lu7p<iAzqrNurF|JI^)OCJ3Q(@|6x`scMW
zDY{<EN6kyL(UM6`^?;Z#V`!sgfM;h>$PAw;+Dt_(KHd#FYD}w{iWW>3da}}BrbZac
z6OI|v86tdG!&sg=s;Qm~N;C>s!wFiyfiJ9`_Nl3I-pnkEnmcXj5Bb(K{*$_kw}qyL
zbqCh3xRSYSR_2u(o;`~s5(PU&yIHxz*2el>Q8SWA2sp4iV8)5WMrXlNuS;1|wq08p
z8t?UM*`gkeSzQJjC31T*dIHc^|4eb2hQ9vi>e{N+Pt{a@Sj?FG;I>dg;FgKEJT3|c
zxt&hkbTg}dTeRNk)Kyoe$_90=)G}3dTe0E?|I?2;5vvwGnU&QNA5{D*)8tZ1%^~?z
zSCcvMN0SZ(&7HL1C9l^?v^3GM>cE^8Do1w0!c*O1T4>0j)R5IoMUHB!hn5^la@w@A
zHXvlnd<R``MP8RDEHlEnCUe$zavg|w(TeI{AhvWu+p3s`$y^VE5)Bn2geQsWx?kW9
zI^i6uzf#Mp<d?hO{Kg;QPd3zve!Cjg-S8qKBLft23%q?zE-wu%QQ8$Mp0wzRbaZrd
zbkwz7*QRY<TWU2oG_=%g+qT_Ny_zewmicI|?rb#)$<nwHcq4Fy8Ym;?)NhN{ot_FV
zxUD+0vzE*Xnfyau{K&?HuGq=GL6e@$$`IN2<Z^4$(GdR^3tk$j@+kfdTA3K5<)fye
z%~a&Hbj2^mtVoVb?U#;fqF_&MRGzZJM|*0h!Az~t7E4B`=!SO9fEnRhs}hYuR&x|F
z`DnL#wj60qkXc&qlw{WsHO)!N`(>zSmPN=6ACEAVr&_{XPZnlHEU{a%0<<sk9c#RB
zP{x}Xlih`dGHwf{`nm@~lFh2ttgEZTU9`8dmaO7Cq5Z-l)JF5sQ-kFldtxVZCFN+`
z^0+c_rE<pN)J<2jwnc+#sZCd=N=;fE5>m<(wMhG0%;b7sCOyw(jpC|FM^^f3i?M31
zO#BnD!$*UM`H8BIwid_Fc<rY(Yu%<?iQ26ua`nieS<Bkmot=G6F8eY?WiFem)x9yW
zOiORd(m(v#r#|gj&$e}Kws+LEU32}GduL~7XS+?gdQ9Z%sYGAbQ)@+~y39m!G%l!}
zPF;01XIr#x*y_{;^-C@UWd`|bc`oXzVed>jC{!^`M^L>r>5x!Gn2uNHlD|vEmadq%
zWT&3@q$j)9YObDgXjXT4%ApyvblnyQuDI-LaygXi>gup{9pNdWH(5(U)~?FZ-F0f&
zon@g$t3#DDm4n=t^omOBPFo$i>1NK>sI}9Uthh2&YSH45kPN2^exalFT`R%<*SPHA
zddlR=qFK`qbhaFDIWjMN>eI@2HYDc<J3C`~{Ls>^Teoh#9$UIrH#_Q8snuM8To5o@
zxnir>ty9ZXZZiwIE$VHR<}z85vn^_E7%0tUZHwaaWmTK1a%ssdrFxl3JJn__RXu5P
zRnwpAXp72+H4!ep-cPv_jat?VANgqG-^7dLr4&$Y(`$0s*E9gM5#mK_nPcpPaHr4}
zo32E42bPH3@_<A+C~I$xot}ENG+Ng)aHW>1tJ{hdSDAJ!Sa<1E)0U|>O)e<CnUx_}
z)?07V61&((Qw{8oPqRa=M0Mw;1`Fka3Ug4kmLYW6*W_hLY*+Utk>5)u{|j0*Q;GHL
zY@O2v2Xq+rKhSzC{J2M_GJD;=Z@XSr-wHQO4(yhSbmr<z7VW8+Q?RjLxX;GV;v;C?
zNo!BVoWe(i$2*s-+V#5gxSYC-PV&m*^>XSm74tuMm0p`RH9R7=X!)n=c>b^UH{R?h
zczC$|mOT&nB3DqD7RtxUF8{Jm{mZ<|Ki~d(RTMAuux8Kal_x9p#802MngbruC5_u}
zAH1plRh<6qkM>Ki?1<Oz2b)s$gEUjnT=4M+$Z0R@<2!HGcrU#TG7~iJeSEH;_sN2N
zag|q|?3vE}^f`=M599Yiq;Ei_QMvPK_Xj`Or}|-co%_;X(_hxzttqqA?=09`dE(FX
zPw}mv{_P1{{$;j*)Vk#-t^L=A2cNX|f3|w%lex=7kKD9a<9F&;umAJcZ|zfmP4|9h
z6|Zmg$L}=AF?AMm>Zeco6stddPN}ut>60b<;tH=U3_Ue>>Z-l&AL^Aq)VVMGDc}4f
zZt;ajw)}xFs`{O;RLL`6sghf~@D)_x2v|@GBqO)@!iBGL$_GBmu|KNwVLHs9<K@E<
zF(WC$M{DuJ_QxN8{He2-??3+W<x9}otIL-!Uw-(q{^d&$<MQRpU@_2AY=2){8yg!N
zdwp)9Fh&E%&K~}VIsC`D_-2R{bi7D#UM3>J@?g`(DG3D+HR_bCWGw<p4mE!ecAeVe
zw`qq|!Gf19?vIq6{Y0b^9e;2xI(1AvGKLqVM){-Q!sT4N1`GbMTue<CUbBvEj)qlY
zz2J|I3zz-6_?A3b<0WCRVp@QXhW4k+t3Up%v)4cV^vA!cKT-o5UmluN7h|y>d>vF>
ze1H4u%U3U7efjFk*Q$!War4&u#?4#rAHHnfdhzz|!w&OXr}oFRGk?6i(7DCknQw-M
z0q4QgWQ_w44+Z>jDX}Vf0dc`P=f>rJt@Zpz+}dW91k^EQY}$BT@xbNfPVJABoqeq|
z>={iWBVJE<ka>Bb^GCsj%jSy6HJX@QUZ@Q6Yu`>jwz*a!7A_?QFPoYf=7@zE_3+84
z@+w)$T7eDQkPJ3|mGf7Q3zz*?vcFmdGi}v`zfLA5msdIdTGcBSR&VvhLaOA|68nH&
zUXxc7O8r+QtqjvxCc>sHTPV)#H&<)%*H9^)HKivCOkQ5~C~7G&c-iGRHKZUi;*^0!
zp@@AzU%TJjAbzbC7gLF}5!J%_l79)of^I@H3`{OBbp9Y*T<|PU=CskwIfr{9Sx>4K
zv9zWogr%{jL@LfKR-PF-)mZPzy3{+X+%HUCns7Wuo!M`$M*l)k2x^qpt`=FXnvm#m
zkS$oYD4f}EE~mVgTiYBJlS9r+LiE4XFaPmt)`g9(%UoQv3)gasM5VYmtUX=7dRytL
zj#ZsSucKxZt-G=9??MKq1m?dg6S#yt*u!pZ`@Zk`_Tw|}rN7yu@VM;p^n0tfZfouF
zbH4hhJap~5yVsI?x8(J!1%|EJwAP=oY}<v6ohPdH_`TY?_x7$cGSYgjTX*!Ud94jQ
z9IAcu)#t-O_kB0-C_8rRw!_9AQ8`EFqrx5ad%kX|i#@wx$@{sVA72XeGS%#=wJf!s
z9=vOMut@T{*M7U#JKlOHR9^0R_ih#6^@8Ua$9DK+?GQM)PFU)p;i?DD+m@v*OIww5
zbE~nbv1xGH*%bjI8o?q*m4Z~2f-<<6uBD}=tx8(i9o5X#us}C0EiG%A){Lzy3^X88
z3+gqvBWKQ>1(C~#T%nLQJ^L?<sG(~f1A}AWPtXMl4GavLjS_diMb$bmFa>SP6cAZp
z?7$#;{1Ah*Livh-kS>M=0U91$OtVZJK(`bygh@c=iWe|2u5n;sj$~jEVqoBCU}?}`
zRN$1l(7?c;z`&xQ!Jz3?&&3*%YxBWrd8<hVvjYRCztf6|lM+ty@Y=4Ls*=LEtbuo{
z*Ob4iwrUL*7-p>s{t$d>Ww5gv2dk>uvMFCyH5p_YReh*hz{Rle^quPROOe`k`?CtI
zKiiy){aw0e_OU0?MYqLnT*=)hou_@rvc2G0vw<<Q!A9$Lt$kDGD(a}#*wq^pYOQ|h
zc}eI{_{BZ^tzpIIjReCS)E7TJ&nmjf^N!i7^|O?o-A;*nur~KgBu{SThGT0#aQ*1H
zwZA7K(Xg9GO(Kkqjcr9@s`|0h!Hu=y{0q%%YVBBky=H7=ezfvI>!Z;6j#`$2&`Yx>
z%3uE?_^a`#q3*}}sK*ok$`o9>{WtA-{crmpf4}xg$0lW!Uf;LzaP}Erzg^$2S>#rB
zuDl-i>p1UvLsP5Q_ah!|eWtcNw)(Y<*`6a;UazlBZo58X*4)zfYYJ|C77kvw_iLYY
z9K?w2b6>?@x7XckC}p$l%9lT{L57ufu6&N&uzKvK9nL;`)^FGM>%8mDLDt8Z?YRT8
zHFNp*>+dff-L97Ar*Cd<^7?*^*{(ZRKCdsh^|{!1-QL65XV0A5^__RUxv|yjJ7#<C
zoO!)=R%}*P>9w<ZTWzggr%jKVH@9@N_ga6yU9WlnCbv(YS3h&6&3;Quvp+YNK3kq1
zWwhVe*4`wwaOTa)+&TW2)x>7ZnQ5@)$iY9G{@F#;%Zopk`*qC!^ykTJY0smpUrSkl
z0z<zxIqmwqw7k;g`!*i#?mlz&+?MaxEb2SFA1VLUTK>z^{)z6QTSiGAXJ)Xi<;(pM
zYAfphVbOn$==Cc?Up3YL*W&)OLht0qDQ9$NGaGI>HsyBWwyVpwDfUDiovi;bv}#5C
zRj023dqea?xvxz5r|JI)L_B^W70tFyE2}po%<SsSz^%0<uCJ873MO^zb%}$+sP*9&
zb#;3uZjG9DFgNU!&e7Vha!|=gC>`fgALkOO>3?a;&)^x+&bd1OX6Ia4oi%l}eyZoZ
z6KP4OD%NhzVSE#Mn4#Xu`z2`cxvWja%Okr={y~;G&F-6Pl>lCPWm59;@-py3tjWuI
zrA$iLvtO;7@9w{3YDDnk$83D_`;R~Vc)7FW<sZmOEpu6`l7pZnTlH2MFE20mnF}&c
z-B-#a<D{$hColJx3MPwuG=sk?=^g0a(DX)W?h@BqF0qSRZ#i15@ZPd${-mygPX8lX
zbwa@#R_qRRy`>VnV$mCy=#ap&McrFGc5`)eY3%lDy|qa1RA5<9_ePK1f!toL5Y85j
z-HKu<N^h2mX9Sk5sPEpQvD>LzOJ&m(Z>@$?8j+z{>#x_%+?<wk({Og$Wlxb?nTlS_
zT(cb*x8+Q8U36+z;<8z%Be$h#dq){aFfizD>|taxV1J&w?RMGi-0k0gfk$~2;4_&5
z$r4a@2Uy0i#}P8{>t@(w;3#p-Kr#s`o-CmZQ`(a(ao}Il^xs@8GWCxarGTbXU2ks(
zQBWMay9CNY5_gSGTDa9YF*?+Dl{81c{qF{bGyi4oUoS|jDz19Rbl%%r#bMi*=)2al
zR-9P=TQwvl=tQ7SS2?H5Hw$NGHX-5VTC4Ar-8e4h*PZUez{qDjPi6O_cCGq%rTf$)
zjc)BN-=4j7)%NOp_wMc~+Vk}8=Cf@#a;y_Kx~@z-y?EEPkJ-#~uR5*pPTLxKcj@cf
z*KVwKeV1)zbLw8z)>nn8RdXUQFFv#OwYt&a@4Iq&`z}3M<9(cQcg)*c&y%<A3N!Cx
zF5P<Wt?`_)YsQWqGHlO-^KMJa7TwXbc)Y#d$vkh_ZP`sPmrSwXy>9ho?Q*AWo}Sk(
zechrNb<CvdR@}B$?TBN&8y4qiL<Siu3r!1II#n~(i^tnD=)%^j)!tl}4sFqi>Iz($
zsTC!*J~T5iDk7}4JJ5$cDdoykUGDHzTP~{|+iAv=vv=yk1Bo-uOiyk|PJOeMkNG$|
z<Gq7-Kh*PUb<JdxPHj-QU%PhwzH8S%?wh&x;{}V?QRf<uXJ==pT@mx(v(Edsz5I7*
z=&kKpcUNy+o2$9)wr5+?RyE1qsF|Bh*P7kBx`A!MYU32%Xd#9J+QF%tea_C-$~rsE
za8q(lM$VQqXB!x2_VjK}U6z)^z;h-gH~M9C)Y^56PHM`3uXpiTWb(8A(Erx|%O*^n
zmX;P3)v@YF$n+B{U+pX^`nOO2N33Gm1~*@$GiNR<23%Qc@BaB`z5TJ}FBfrp`<j}X
zx~#eqvN~wWUzr(+iPxUJ;`Y@wxpL>O*QzTkLsxp$^_)4gY13<imA5x<&+mSuP_jhU
zB|cdA%V}-Bt&CZjOP9@>TJN>dDYR4Y#8Iz1e@!l3UVFj!?AdMGZWoG1ELobc)Ka#n
zEOY7IodNN;XV1>fJ+8EBjn>o%P5+B+&(mhbZ@Z~gwKwkG`P#h!{0hxeT)&3L%$=24
zK9zObvuC%XA5U<65+XIF`_)SMCv!AqW(7*6xRgyWQ9k|h=C<i&9=SVrZoBqfs6O=1
z6744;kJg_(cP1*c?$?Tl=)An#rTZtaT?}5e-`v{d(&fJoLY}^T^|j*do9~UGMFA47
zeyjf6d2`u2{9P#b&*SRqGEqBEGB#?hQCc2adUEBmY3pyU691fg#&_G+d?T$j9IFlp
zZ|s=;uP&)9ck60{;AitM2m9(qU+G%S<r*<*d400Hy#+|7#C84t*-3f1TUQr4{`Fe5
zf62-l_s^g6JG*V;>M5@0pG#U=Ji2;nLA?`1=FE0$vs=g328#Wke?~ui`{wigEzCz0
z9y$GIuPZ%ybK5mbmzc*r=lm=-uAb^}L~C`D(yN7ai+}#vv?Tug)4u^yla^nN{@MQW
z=FhG5y-vD+ZVMOZuE`P&{p+&om)D$C$IqWVcXr#xuYy_k&u%t1yLJ2mb5O|N(Eho3
zWw~4XA5Ho3J??JY`stg`3GgYhpVX>bb^aX4Imb1+%k2tho;)sQDI$Mm)#{X$zs$d`
zp9}KSpN_5h&u-70otrG`@UJyAW2(KI-R940{LXHx-^j5w|JjY%vvU)=RzKxhE42K@
z^=oydoj12#yC_y(UjuU5yerHe&9|KXYd@=Af4%$D?d*<j>z$u_{QN9-ERpA0wasg8
zZ*Bgw8FOdnrV6Hq{Y&iJx$Rm=^TW`v&fqWEuj{Rjyg}B|wK}Nr2g84lRbOLS<>Ko7
zLMA;ud1T7`S5BvX&o}n*J7>0~WAj%?R4kYpuQavBYi`fq?B~za({4}E$+~}bqq*5F
z2apfywt{`I&n4n2NO|VgPZMgiR$bJp11XP~J3F^fFumNau=C_`aW3{#Q^QU|U32Gl
z_D{j&uz$IoGq;_qcVb)R_-VraQ=jd!zdri2?bZ<`uxYtlTfJ64m>Q+(e{ubqKd*&1
z=dN9(^X}izZEDYMM+fn@hDL*A)`Df$De1g>e$LR+;?YBgpFyi`YL%IO-9HPI-ln+D
zjsDrD_Uv|~XlTt8klT7|^PeNR?Q4DQzVll`qXg`ZsGG9tGD`IXb=^6w%^IdZ$!@-q
z_KU;ZB0@X7=DX^aNABId`9omZ&+_#B)oTu&uif6Obo^RfX6MXp*SbKydn%Oam}T#-
z78&gn*>h&oX0P_E0hx|vrq)KME(I@UNG&aU^TKPR*ZL__c1x@bU3qfZv>?%$GpE&u
zWh{*km~>UuS~jn4R%R~K<=|jnU9YL}8lhFIT<TwV^#8o7YOz)<WU|Vs!=e*;+=U#E
zthAW4jw2@I(W)I&V}kkw9`dp5;CP_iSP*(JoI}R-NDNbqD4(i!gFDy41EGhyTSE`6
zdN5t-Nu*KkvYtb}zP`Smn%+8-eN8TT@*J8{zv-mOWnYyEXOP4w7E+n8b=qbFkTJnQ
zQ$Q4M3+iDG!J}-c&L&@z%bqI6a5tU`I<0cq*JP5jktfgLU<e086&FN&k`v4cFcmOk
zKy*DQ96$_gG$L4_MofazP?MngAc9DoOH($T)b!SwG-cCSlS$47VAV^p1hdLz-+HJ5
zsDBKWR^QI9-S|7_&Z8AMmb0bjNFHT2Te;=5{x-LLYh%k?<CgA@I;Li~NdMKs`am&3
z@xM}bT9e&+rHr(^)qG}}WGq^2(v+s8bH(W_m##+h|0~lU1?ivgekB_GH6Ut<yQpD6
z*3=Z&tC?CcQ!|AUm4&%G>q8!@T%NK{(alR{sn&y4*<CVPYDxy1HmpkV5j5&}^k7x$
zK^ZSKE{h#nGYeLCshpbFaq0-0;DpH<JvwW&W=z%+7L?hcHS3|eC}&5H){NB}lSSR9
zEQ#q_dSb1r8^e+CpAqais!<==MLee}a~(e7dSK;pRtu&?=SJqn;24nyoUQddqDG5V
z)SN7Kh#EcO(-hX|@iCe%7Ah8_@z5!0;nc+ET)~B&M^+h4II7uY$a0`xPh{DSz(bs^
zJU)hANj;7R$}Y<mTy;tn{1+a(D`-y9OZOIGF3B+2RpMO1ej)`;3GRx_t(xmZ3Yrp~
zg?WNzdQMt#%DH>el+&#;3Nr-ni%+Vb@?5;bhGSMsYDD>@DR(p;HDxU9Y@4zyC~1|c
zM`cmatVfeuL$W4ZnsUOx<;uiWL9^I|bzP=~s(Jj^UU$zcxGy%~gHo2@#N>tIs+!A%
z=4dSr<Wpf+)m*1)5$d)`DrkmUfUlNJ%#>v@0S{cRC=1Jetkm=?tPnoRa?x4qc%`Oq
z{gLHdE3P<u1+$#uT<Uy!(v<5=g^nfxCwqgIaZVBTYV!#8+SIeb=h8}piCzD-J?0+0
zJA0;9y56LU1+z3VgR<0CELM>UnYD1mic`*BD>K7<rY)MR<+egs<&w%F_m!b<wSHVX
z{VaU?^xmAkr=A|$rd}~UyojH(V7h0?^yI~h7cbsgFB%&g8yhFW-lFyLaJ%0u*Dz2Y
z<1J^b|Ht^Lp#{}d*G}Krv#GM;+L05V4xiIE5qYEdAmqbRtBy^nIx~$DC5=)}&Qz40
z;(2A!T#?`vT{WWrTt7z4U`&gj>hY**y`I#gDa(y+7EYh4=`X(O^|tILtzzBjl2z+0
z({`-XJhLq(wf<`Oja6#ln?g>uYMs~_#5(ne>tqdQr3aoq>y&h6av15UiW=?c*pxIO
zC5ACryQ5o8%US7B$jYflmZlu(II*M4b?PallM9-ao_MW<vK~#<1hEz^II&|z$f>6a
zDHpYj^c+^cs=6Gvb<=n4=~B1W>sm~or*Bdktn^`eeakNIElw|9ym;|>W2c(L3IoZE
zSFc`us93P!KwHa4uNeso8(uzq_@v~pLquvohHS~p%bVi;|J}|xcEaGc4kO#!)zQ_r
ztM_i*^j+_a&7SO}w~w2T?AderEMt8rx5m^irBg~LCmT*y|2X-{rj(N{Q$uHUL{4;_
zr4l)1(Oq@5#ZSAY)*Jfl(~iluSQu>d_%GKy_3o>sr%jJcnsYk!xC7sM@l~&<Wj8Ig
zoOZfrkMNrXJ?kg6PWEC}dbC0;T$NjG3Y+T@p_wsLbY?B#>28Ivma@4X)e6?08nP*4
zijkg3)2T;JCp*|&Pc01A?&MYrVdHLDG&9B{(nug-N2li0Bdzt5wU}9tc>1hU(V4MC
zLNCze3wo3rg*$zi-m=Sk@y3f6FFtye+SNIY%joD*&uI*$rKJ^nf^|fV4zvY*G&-s|
zjY~4+v|8xp!-tPv*74c0)acZLlb~+rlG^&2)6TBlY^*ywIyvX&8i}Jl`Bi)GeKLK2
z_g4MhIMYp^QVVvM9xZwnml*OO=-(opm12QnJ~NF{ew>{A%P8fnl8%<pSxvDdk(Yt~
z9{bjZP74e<0}ixBD>vOq+ObdjxXyJIP$2bx=~}lO9D+wx{ZcnQUMjR}^{Yi;;X-0Q
zD|p1YCP93jG{<EMBv>>L3f0eyS)wyDKw`PbA`okq7Ekb$Da*n&xz#4Jc^=^ci!G2;
zXYxudny@LWA!UxM$f>7_DOVPx%n6tRVqNM;nG?!<@$JX8(|497K7AZ5o-ZS(`t(^`
z$~vK!`kW=x-QANHFJ7Yc3Y4rg<2=1StXMZs##&SR@ZrOU7c8z{eP-RA?9@B!VzSE~
zTI@8mE?wIi%<6Y4_@q}^W6H_NYCbcK5>Cz#Oq<Hh)uppy(V3Q*rM7Xab(V;wzS??h
zbEja=cA0q5<2u(FL!L$Ji$3mtwBzZlN0XKt-K<@;wAAX6rk>VsuBlT`Ih|a^IH@31
z6T<3vqyhG03s1c}7sTT$*+LI#`m75Q^9^a%dc+E51@Nry^aQgwBxSU^KtYfxka}bZ
zRPT-{;1Iabc*<+}s&7B8oxXP`e0p!ro|!RvcMD^7PM<NIvtYU_C<NS-7mIsKYRov{
zrWP9;r?*B<Q&>Xdm``|TPyNE2RnrU>E?Ro|@Zm!%tr9LxITp~9a?B^zs^sMr`y)~1
zy4y5UB16_r-KRe@X2<pJIq^n23)gl|pQbi<*A?zpN~b_j6B<w{CucaOEm=7$L`O?x
zv!b|amfd`pC6J^dvg~x>(T_1jXA2gA3#8EFI@d*2t=85*o2|bw<fDPsCfi9}r>;1>
z(g|80zB4W+JM~?-p6Tv_IWaTl?z(nlqu!(s(>+T{N=nM6hj{i(1)oxI_3G6tdxF%A
zI*$3I9IX&ET&gT-IGJyroUGL{ju}@#9M53TPPL%^CGjjZr=NxE8D1^!eip80`sg|5
zqz7-WEe#f_U!Kyf(X9chy^X-WIHWlvByyF~nWbVuld4uf+H}-w=Jcc4z3D<r&7%AC
zyB<%=?gEt#$H0-!>Qx$_v~se@s?!ho=dCWRo_e~sV&_qi%QqT*I&yh?)Y8t9>7J$H
z?(XjH$tzav+O=!f9xd&YA?xN?l)T7Vv2LzaeMMQ<^t`8c*2NT0H+mPYXL<GMGqoLC
zeXL7cgGIn@({u$V!jzMfw_XYY7xE=5mZt>Ogno=nTIzH9(bi*|ySirU9v44ac-r)+
zCn(>6o!JobYVRa9pODG=^NoH^J>65a4(h%`DLbr7S4Dv8pum!PP>@<Rty{Nl-FgwP
zPph<-^T}FeOxjiQ^5HEd>vFxPMUSIF#JQLw*XPEpoO=71s87(`Da%t;r?SG_rIsm}
z)+v^%u{p$bszX-$(bUdRWBsn{Qs-2?V7Wse<XN<y(GO6)6BNAa%fyt60ac-K_nyA1
z57)CiJ+pf1>Aup+%FcDV!F+d<z)piicHe^4AaG=5T&Qcw!^6vcUA33{&6DMsHEH$s
zsGH^5r%xZ-77MFcOBE}$=4kqzf|gzfo7s3~E^3|CrE^s2ESJur))g*aO`Uw)SDhB+
zI<q%iCh~~aY_a;s-B$}wn;r@UhZ`tWig=aA-Pf1;xO&}*>%FmMU$2{O`ugR1XxH1v
zLPvIaFWKb{s<u-jC-R&*bLNbzGOOU^cD}hLp0QRXAKq$)|Gg5F!Wn+HcMUhg{uiQ!
zlmGeu_o#1_<J#l;^|SAqDJQgzc08LMsX0a4sQy{wpXI9c|JUii{ywMw#sAxF)9%im
zTlxF7jM*;iW5)0iXyOO4^R2J!Uso4hm1I(xyYl7F>!9K6*TTW);KSMVL=1_yU7rma
z31252mj@a{-;rCn6Et*w+5i3e`-{8te9p{?%gf8WzHdiv>CTnU;~s8(_AEWNy6yVx
znR83uNyp`-m0kzwnRz|hWY?81uTe&<>mftd*Q9?P=hwG2Hma;ED$4!2+54>Dxh<)6
zX;pO@ryd(`Ruj81f0>W2p`}q`W@q!y)IT*F{@LlDv;EpLfBJJZp0nq+eZOW>SlPMq
zTHLQ=XV=@Dx%1k;Ho09~eCF)AneW#W1-b5sS@J9R%KVk4o~QhS$|hf#x8!N?mbpv*
z)h~Igo@woQ%kNUz<SnxyoGvhDE{J0q2$7iy;((Q<P2RG;W1rFw?}z$N{>>0e5DVo|
z%$yamOe=h2`-gw>hkw-bKm23ge&dflAOGPGf9yeoZU5m9e{AI2AN~MMwtoVPS%FFW
zdj9Vx{@C^>-}q)f{m@Bmr)2^uXXG{&ir;wrD24sgpQ;ZYAMGb!^86|mB&Y8mr^U}2
zykv*1zmWUkhli9eeb}(7%KPG_kFQb{kAC>_A>aXsd$J~5&Bf^WVMU2hEAPc!6R%$G
zSo~vu_s81G30a|rJW28Hhdy%r+BZ*5qkrj_4fU&PRln5ew_a8JT5DCY#I9@krFeJw
zy4=I+!j1f^UtT_{_(yBLXRX|NQRT~*yC!}t`{f$%5`HykueqVErKPp4t*xbhsMY#c
zjxYb(FNc6-&(qV>)YCyAZFzcndK!q8o|c}rY}vBqtHY11S?Z&8Sm>Yp>7#-_{?r!+
zSuGFwr^o8=nfU0{9FD500>uj}KTKyAKWgCo@WTV=3oBphyLX?ex@olF%a=z14?@07
zUwrkE$B$IO$v^EZo347LL>$@2-~Fg0;23Mv^rbKB1I0Bh!_}Ui%n~@xr^UZi^QFG~
z>PIC3UmhNGe(6=^eeu;tJGBtGITjlA>YtLP)c^8+@oS&DEC2G#P3>R2YE{44t>;qy
z6Es)#;?+m>lePFi{<F}i@$dX<5i}p<!h(P=Umh&HH06hPbN8b}kP8>Ss+h6VR`tb;
zs<|QZ{C-+|Ucr~*`olXXE6MX{WO|iMcMqSUylh4PlYjmvPkPm=eyNRHp45K1U8()b
zuUSF$^F3?j!&knlS;fD+U1QZFrKjpzPp<6LWewLBp6d8l(|^gn{?(VaC|?ffZ+)~W
zSdukM>7?eXyLo$~)`e$Zef70$ckH_B*;_Be=Ki6J07U<!N=$$8XOF=A<L&JqFaP*w
zKYjJp*;`kw4O<;L#r2hc=*ye81b<vnUQ++ke)6O#U#7|F`?q{rVQU&t7Bru;ps>bH
zc&g)vtB!9#KKoczYU>*!H%p^Z)8DhoHZH{da6r%elS@@s`G&4samE!K>`M9|m%jXJ
zRI`dtYK7e?a3CyS`AH+$m4DL|P^7)Q6n9o+Th8s=X(j>x{GVK!0t)*2ee;%Iz7p{B
zWyKoJo~b%IYaI<jYi(-n`#-+?Q!jt~<BzvcAKrp9-auA4Kz-V``o}4|Ri&}>*IZcj
zwe0P!b=MNb1J~S6l#aKzDc)CCTk&zb`oTwEUp~$*x}7f?JtgV@0|SGg>(=ubJBx20
zeN_K3_mu6<^D^9*KIWc2x;1xSZrD7fPj>5<ub(b$*xTzNzr?#}cG$DkWh<s;)zu38
za!gwFU!A*U-|?$oe$}Yu+_-Tu;BP?Oq;D1~ReSjrpFCzf&OU+foyGe;yZLgT+}w1x
zt>jwqF?W)YVeVFsK;gEV3IR&H<_VoId|!R<d;8i7hWb@2*tAxyYL8lV-7#rF#3}{`
zCg#Wqh7P7PnMIf*Cz#G;j@<wD?)I`bw|D=!%^=*spio|T_w(2I{L=rX8+K=SY!kAN
zdzmxIW8>^&uf%RoGtMm+*Im68B4cO0bd#sjv3%(j(RmSPx88|6eQlN6wbQxW+os*#
z7`6If<EM9f>mR;*Uwv?M`LUm6Hz$<MHsafMlF4J^^z3QIxdpfHGcYiKH(oI?FoL$m
zhZ^umHqL;e{hvidC#9OsFHTjP;1m-2gN>2Z{rmrp1uhMr*VTS|#xi>jEB`_!uK*PW
z1_s8j3m60%7=AK&<~%Q1kimY8k^SDM7Yy>%4D|ui)BWC_dUK(HxyLV``4vkE8$%<5
zqX*LkjVl64t_;<dAU9|#unI9ua$r<on8+oh62$mv*3uTmv!Gjbsx0nDcsBbcvvjGc
zFZnXrYZiOw5)&g{UdF9#>Psg1Uk%|8Rxt4C;V?Pb!m@nI6irE~s^%+f3KxGZV31;&
zw=$?cOY@iJzf~CwQXqSl2IXH_R5fW?TTeqq<^rBs3`~;(Mf|UZv>afYHA9Vo(co8Y
z-PTR*-)-6wAI{UT6Pzj;n5e2fxr_baeBM*nKEB+s!d492D#}W{5$sj4?p-6-yB7ky
z=cG@q3w<28^(ZLqG3SXq-PJN@d%zTHuEHJl@B6zSC^T^>G;vgiJ91_}Uc2?p0|$Yu
zdCs@qF|WJBP<p$8Z+GFfUBNSsMl6kR&|9@WR%g+Tt#7_mtiE1wj6HUT)jI|@1HRn_
z$4nAr%O3V*95b+bmt0u@os<L3#cfG;_*l+!vR2<DxbK)*N_NPZv?Sw{TW3Pd7AGgw
zdvs@XnRQ(3=rT!C>Rn`-!yvIpOW|7Awp%Q>({gjAlR5%!Zn^2d({skQF0)+j44+Fk
z1vjTebEVB@%DJ^TYq4pL#?39hD<v1Fw4H6bvDhTXadS$vN?PyKu(O>x$|gBlH#bc?
zCAl~yqHCMk?cDXI58TRQckJGE_4ahWch9rTw%40o+!DAY%6Fz&=Y|_OYp1N8w92Mj
zd3TX`mhM8qXN#T*=ggYqy3x$#)+N<xEWEAqB}>kPR&To*@a;BtlIHHoTZOj>oVj(|
zC3L~9Z94)2W~^P?E6M9KoBNH_RO@qn7t2H?SBl;}y=C1M&snSd-pyU~rq$R*_D<R2
zEnR7i<)ydQ9j*7A)p+;ZmA3&i7h3P$S{5j|(t3OBqSdCFx6Gu&u5J`F$yn5rq!2Xe
zmZxb@)D4|!TUA%P1e=DYg_>;(OVByB?AVF38pcYwX2C{XX<j#Tre(RN1!vt1%UD_E
zwrI}bLqV@L`$i>QcJ^5|YuXH{%ov%6>v)nZAD+Br)~S}36zz7jKBRVQ@J#KD8&lsc
z;Wvx+4f)trJzIP0tJGUNTjt&_7220Sd&|phQCZ8^%=`1I&(~_2zp1p!+GlrK_T|so
z?Kg9)$yNV|{r8o<=B~JDrec0}r`LS*vwD}8ZR0f!zUI2V9V8xTes<T2`Q~TcGcQYf
zE?ZS~WM6jH<VPu=1GmOp)U3a|-OK&#XV+ULms7S}^^dUqdD7D4Rn(%-0mtHN-W?L3
z_x2LIt!=%*wX4fBFXU(bxqmkFR>|qCwZ<7+br!#xCj55Wjm<g94nJ;-<@RL7A2}M?
zG=1;(pzzf7e!-^3mz#e)yKQw{Cj4`~N#EsVYdbDmt8U?c{<*6t<yF+GIkUvC+^;`!
z_{#B>lV^QgAJw$ydtOka)$;INH=cVh-*mS9)7qR${otUIy=Qy<GK#)LZoDd|wy1n&
zZs??)Q$r{JSg-Xj@5<ce2Dj8g?Ay(5@~U0jIC0fK!(zrIWjFet<t;a!u07c};Hr7<
zl-g^rlIJ`v+G#keZRPI#r>D$=RnM#|OgWY%wY+}4ON?hYqr}Qd^F_Uu@5(h@n{1lB
z$@JW;9;05Vv{bdTr-Msx<$6tJ`nqDXg63InBZ0KAgkZxoPszy!tIil}L{3X`OEwZq
zOW1H~=FF~{Jtuii8?2m>78p6%P;tg)g_%=lXr=L49$FJA8RpF&=@t{RCne2gk4|Km
zR^rz=M~WWRPd=<ACngp;NupTe^i(|^x6mm*5l7M@I$H{kY<Tp@PbSvs*;(VX!X%$K
zer6ttDucrheunH#TgH(pG1)lSZdpjo;#ccJ-IKO%HTr1ip1W$z;-j(RS<!)Jw>&pR
z2b$d!$vSp*!M06iL9@m7M1`9%u9(T}!0U2C%9L&O(QTo{5%t$DL?>-ryWrNbi)$CG
z7R`~WbPIiC;O7@QxpPzH%9y!2AD_BgUYYYe)bd>L<a1|EPI}%KQatC$sXb>R^eP^G
zigGrLv#G7EE&Y-#E%D))jg7zL%*bHXNTc)Z{Oy*HmW8G~_n(=@e0KYcujjST+;U5K
zuD(0BdvE4><IUGT>m{9@UVn7bj@2rK$)eRCcSOHgFR_^|DNQV8v*?PXGs-4<i^A{S
zo}v@!d)Loz<z&vuZ+7wd_}$o8GGkTFs*+91em{F&`{AA3edfoHS3NDN(U-IFmpN}&
zvHJE-@ndm&jkoMmKlJjAx~VvCJIgg~?Oc^bfy-uZwz#(Umg%vg-fa6`scZFG^`>k7
zm1IYL2wa<<ac%RK?D+Y6Kh^B{``$}`R@=$Yt-77Mom+x#M!V`RPFcF;re@A9%`~pC
zW`SKx_q-}91&xvY)eT;9Bvv>0`#f{GxIJlACAM$ZJdN6I_F+%*sko&6(w7g;9r{wZ
zaNDie^HLvwK9%}7FK})8l<de`rfc3xT`Q~a&9-*iI(Ko@xr=Mlb27J-NKLZRy1#4A
z++ei{mokDsXB{)%d3|EVv5HcYX(}JL-EyzqXZq&PQ>icKL$V`Z^=8|`91b(EH`}^i
z#IIS9FMdXHblPUC9d4>T0kNxYmqzFAj&y(fwkG@LPpI}=rfa^{FOE8&1$K(W)k-Nj
zmuK51=Po}sDR7<bo!?)VpWeUs&iCr=_f0O}-S_jyO6OJTnwFj)mT#JOs*Vc+>lZBl
z5`X>O?c|JOQN2?lqn#xdaa`iv+QYI&^x)L6DfS|d<^+HAKWZ=X2SWY&xBTn1pA~cV
z#Kxvf@>H2r?`gUz*<fwx!t?y%tw$>Oo~=F^=h}AQRpg^{D<2*T?s(L<l>ex$=0kt3
zI?W%;AI<LqQOCa|+xM;h-h0`m=#k;>mBrFqW}dc;6YTzzzGd&q<3Y!!S}mO(YR!2!
zP(IbrPvodALg)GyN9V_e{yz3Hy)Rtj*t@02>obg}mG_<&7wrDE`A_<(^-YIllGY>z
z2mRRU&s6EE{L%mT!AYC7KJKfyt8G*0U0kYrC#&zOUW}hU$I%b_yMKK69r|tAq|jr{
z5)(}ISBHG~FqJ28rO||*CCZu{dw;0k-^8M8ryg}}>l&9JB_$<&LD7zmjx8>37X<~k
zL|xmW!l_WNxTE8K?e`vR^4m^0v{XzCpUQY;$;+UMl{O*swERWYyCxs?e6-|aP|bop
zAOSBZ7cReR1%&B$6|NK{FsB8sAK8@pEYFo{OJ+^Vnb1<*AAkMf<Ht{5zW@H?cU_#+
zwXJJGC#tMDb14l3)Y3K^8yg$%Idkr^v9Ynm%$c)&&YU^>EG;eH*w{F8=FFK#&YXD*
zR`K%;Xi;QZa<Iuv5IA$*ZtI&D%QqxTOC={u+_=gW*pr;>lanmHzwYnv`tR@W@2~s&
z<DCy^IOWVa<?~{ex26=HyRx{iQqx`LwU@>7EVcZ)M`=IHg{Eo+`JA{F{a3bh#{4%$
zg<Y3SeSOYONx3Dgu~kgWb*j|WsZM9EF)%PNOXqH0S9iceKy>fM{bze#ue<xZ^pKOl
zLhiWT$HDiRzP`Rb?!L`Yk*RNs92AbYNOW{`7zzpsBq?<C2!c5Rpw&mvLmmWDe;M}V
z?G)6z3pv1{^g3wCQ}6XyP}|D9aJsz%t7v-Z35Xe>8>a-4KnF#DFprD(#$<?kkYeyc
zD6_>9$6l{nzv1iub$cp4mflqo$~&@VYZ7D9nIJ{AH(sa16hs1+wWSL@n=V{(W2rCC
zIm?C}$r87Ek|l2Kxii@@L%6=P%&_;mlIrbsyFu%z@^-xexo6kwjUX#tuLCvwKvv!@
zQaHU4<Zhui$zqFh1EcQM-1)>P@%ni0117`k*$oUz9Va#$YinH$6xjiyuim}xC*F1I
z>a))v<70ck?gn|;JQgNUdgGXRY+1b_)bEB{C61ZLmR5e-eJXD@Z}-BPM=ZB%+>Tg!
zmgk(}*`02;jwZcGE9A>PWp+)o*x9&u#W6!LURk4A=HYDh>MQ6*Fx%qmach^H7Yy3E
z*Xz2dcFdKvv203<4=1^r^6Q&dRd1KGkS%a@5D!~9t(Z6Pc5J+Idr-Z!PH2IlaB8W^
z)GZ7S91M&KEPF4jP6nksV`F2r(z8p<m(DyMb7pE>WJ21i&*gLO?pT?;O~PTHO?iLb
z&Up9raTlvxKe@gX-=#lEzs#(`Sd}Gk35UB7V|Bl1sn&6?U9&81<-OF)U_6(#YSsG4
z*U{^Dp5B(Wbfu5}EbkqjGiTNt<=nlw(Yr-y^PWJDE0LD$%qEPW)wT^n*WO$1-n|ZV
z&e+$}OY{9iy;o~}mNPYt<;<GoCGD&;@%6L`S>6TrcE+VoU|?W;d-z72Rdvzol^3j-
z54T9|*tOMXv(B0&IeoWYb>_WVdE<qW)-q0;=1zfTrUnHT28IbtajBC$R;{XEwQAM6
zJvY|smb;hTxqJ7VWnuU_x2d|R%{wm_MT33IclOM5m)U~6mMMkz3T|zUDBJOQjya2?
zV|nfquSXx{O19@-40*=D!m%NOMNCzxsgH@#;gCS2OqaR=gOo#BvH**KO+erSof8&|
z`!pVTs=j)A;a*k8bBm}QSC_R`pRAwo+#;$amG>UI<>_;-vv);{r7m6HskX}d^poc^
zpX&vDF1xcbE-fzY(^KARvpcK1WRA|9nzhq;($noF42D^r3ss}*bnZSVp63!d=SfU<
z*c9!1E|JscbO+sGde2u}S$Sf^%yT}jGa`OW%FYSWSlnqcy{ppZ^MS)N;<;VcE1r{j
zSzp=qGBaGn^5BEKpihg9nYowlP?`0yAUH=*<Pb;T83sk=Ba;^SuJKfA;dmyXJcGeu
zrjen_w4_EBSA!;zVh&{v8&B<b?`PM1ulgIm`0Ll(+b--E4D6V)aqmYNKe1V{HqDs@
zR$;B0u1>82D_$H}#Aori&*Cwc!lSL3hF5tT+Suxg=RCJO*pn=A^k`dZ<8-$bN2gtw
z?XbyJ#8FT(F*PzRB*axCBy^%+V4%oCW20ctz%UnASC^nx*GO-<d;<-&qY^ian%QL6
zZ!>>e^UCt=`P>a_Yu9!kt59uEYfYMx+jFjX&U1^qPcJr0IcGF+D16`hzWQ<8r@a@W
zIXN{Ka5g2>&rsoPN|=8Bxr>lWfV;60i%r2-t@TT66?eZ{U7q*;*Yy8yy%XK8Oi;VD
zXi1XJgj)eoGc~Rp3R@<SV0L3$?_#acszxojXT~~*jncwW(t=IdCNr+eW}I?WN-W_@
zu-1v0leGQ{#ahi@{^ft{O6&K#eS%(kz4U&(Zr=a%7k2O2<N2rlV(_EsKVC0C|9q<7
z^V)AK%d}3#x1W3W+#-1Q&U>e(C#}=0lg{=Jnzuf9-&K95HA}y}f41da@V<A?v!;W1
z&(CHanw{;lvPA3A^uC&Fb2PVYIW^sBon{3ViLXJ2)~xib@9Jz?W%^H9wQ$X3kJ(D~
zw}KPR7H(R*=*H~Oje#@HTnY+S^Yok=78Z0lP3O{?nX3Yu#5@Zfj|c4(&9qvsHFd_$
zDPgIiGeb73>YVa6RGlewM(EIP<%}HZ&`sN>9o=d+@kFm$=SnG`$6{$IFD#a}sk#TI
zyov}m^mw^q*Icdsu2|c@)mx65U7H#7BJ|R9>1Xv@^nSm4H)+%KW8c?WY2L3}_uLEQ
zvB%X&etC9nURU|`^5RQNFRa$Acz+Km03Of#x|}O_t<lm8tGnVXKSvcTyLDMBmTSk-
z$Ma3GN$hgz=j42}GURBXX~)D>t2JHf(^8XVVlF)o?mRPV#*WN1pQ{FehjNxJU0Ode
zHBNY`o<-kP<5P1(D}xV5x!mNN?6@jtvgeMY7b>)t2PQn)u&lDudePUac@4FiB|o2^
z_6g3-oT}Fvt681DHY4`?-Mgx(`n~U?N`m+OjXgJ2uQk&9<=)qRBDbSby%&ay>?zLn
zcdfU6y?f`&pckQ2_LRSmD%ZSUUcA+NVOY?|^HrByA;EN1U*_jp3y9G%K_Ac0!X^<b
z66fl#srip%&GLq88f_~!G?ccKY&P4ImCVn5-fHeS?NgOLdzQDxoLt#`C^OCHN|>lk
z4zIUUeZ5xYxvzTnW|r!DABxfqSyQba8}fRo-}F_pmaSaT_bTK1j;F4bYRw^=rZ)+_
zTBf}+spr6+J##}|FK74_^z!TTtIMD%ZpyydXJKAmh7y%u?jc9f*5!-le!Y9=%gPe1
zQ*qYc*VbE4dB1z-EpW^}-%EUA2Bq?@d7A#J;!{OyG{S-}Mjd6iDmGEH?8mE96N9D%
z&D2dgHtTxAwG(OVT~GO5&3m@}_&Upe_IYuacb^w|SG4-t)or(~Smfr``)j_n(f5)G
z4w|v*bJnbB9s9V?&r8{BHQlLd<@=MBd#$DieN%1i&NQ8<ecN~1>C73&4A(^J24;s`
z%kya1GO2gtwh14DZ_U@LT4bkG(_eO6RP@OgPw$}Oss6Ql=LJ<hee%)k-^zraca4AU
zp8e;l_1)Jyr|PxFtGMr9s`^EvR4KmxlG8@J&TOHjQL9Q6roQri`ToAHrRTOSNA;$x
z^91GMQ@&f5X_hQ4@;+{t?H820*3f&Y_9ReJFPfa2*%hl9U#Juse^te6^>>j8U#5nN
z$10}yDe){ySm@owQ55vl%X^B}gXv1{tT7V{U61H_>{xlyFJx<=)rwiGRvc+Lp;I4f
z7;-8&R9Rz%ROSq}S!s;RW;SFlOF-xFnq1p<JJf60s;R!AYC<z69n|%T^vvCME8`5a
zuQ9`Ap93bB4R}p3IMNwi7eyDW77PpJ4ZDg}Sv|5Q)2-2_TcfqEu2~(n8Jlq+6E6E4
z_BG};F<l#WHam2)uQ3C}T4RRGz5<thx7}~IH?I$$e(~#%AAjTI?1HAh{<vW83GY`P
z86G8B(O#!ggu4F*|MmR0<iA&i_@c#^>SwIJG}HUi%%JD7rGdqBo-JCq?aq@<$)Hrv
zscIo}mdsE6Q?z7h{Xv%_UZEYUwZi{swl3?`nY5<W>#~+_Xr`v68{<-=kgqGPe3><`
ztkYcXdBJGT)I#5)InA0~sYX1@3w=)&LCIyBQ%)GoSQe~sDru$<M0#1slKMS?Cre%C
zx@=i!6)@NH=t@IVHRUkHZm*8guvIhUuZui2;#nTFW7(YL3a3i79?g1c$rdbfDn-)o
z(d;QtprlW*=7dy3pJk3yjvCE`Nc(h3NGM8#@_KnLy3{lM>rqReX0Y=#PZ-Vh+Oce>
zA5`s*W%VEvcPs;uAal{pikPO=*ul1Hib+)9q<=e>YfebDntId(q<Uqz$aPJqhss6n
zELS)MArYQK_;;CBQpjo%t&2gcL$31ZzwRoU$>x|8G_^xD%eP*wamtlhzRa2{O=htL
z2W6V@EdL>*S?j;@tKIUic7kE<M`}QbCG>PVpNy&JksX>BEi@ZH1atk+Y}tQUE7bks
z*9#kd%@4lnpSAeX3}um*T_t(j?!MjTvD(XLrO}d8lbc_tJmg;L@?UIawx(yJB<Gq%
zCYPkT)h~&8t$4ZQ)Z%)Nc#kNr`5sXL@kg|6gHEmr^INJ`G|flr<fSF&f=;$ZT87L#
z6=|?qU2C$Xx0-0m)1Y+CltXLgtnzuPGb42JRL?m}Cv$BoT4_9GQ(~B3C`9X#Me8@e
zs`X#_<dl`0o10t6(lyCaUzTn3W%Bn*7P%5P<(TG5Fya1pe*N8Tx0kBQyI&V#ZNKi=
ze&uVh$d!djbDcK&b>~OteY<;wEo3GrF{<-8{bO2HqnO08e_KH2R8ukkC3-tGO)fTM
zP5R|@Liop`%|~&&=M-+Q)MN2W=$q=QP_4QAnQsjZBPAteC(A}0Gg!7z_@a-f^F@DG
z`}OZ~Zs%vMv^##!G2{1@(2U;~GQI_i95q#mSneX7_wDZ6sp=(SU}wL1$bCutqtZTs
z4PF0kb!7&tZD{rl4mGM(EIsOVIf8Af^N;#Pn~_5fk4v#Q6eZ9P@GpMdvP?ckX~VC1
zldn`QU-4Cj-`{Vqt*yw1d0km6`dtkgsx(&yR?QN8m9g+u(xSb-Y?@t3^)r@vb=}V0
z_CD2fs(NX_smWUY?HutOaTE5f68+HHCHg0mcVgJ884D6NB?ov1t(kvR6kCMjbv85w
z=|K|5X-JaUsaV^;N9f}B`i|A^_cX%#Grr0#zG~|x`ts$=r!QYD7ksgN(cBQn7t2Jn
z{>|!I{3t8r$4rqQGX-jVw3c=y%~+<nVyf=8+qs*ToSLlV_mF3$orTjw?uXo0#8)|O
z783n4>Ex6(b}QDLTJ&qCXRWW7d@#rKD@R(Z`U59U>{^p7aZTh!o5-OV!Mi4k)c+{7
zEwp-6Xv-5Ua@5e*bKC9QZQ!Vzs<vd_Ie{HcKb(FveFYo1@2~Gy+vTfol^TJ7VNY^I
zFju0F<|?0=wkfaGokfls`UD5%Zo8d3RSj&yN_9SgeIUqK^;>naW@L^3{@_~wm4~lX
z^#{JPbzi>BaE)eby}>e(t7<+otxsM7d8;eS7v?RWm8L3>3R*vaAoul~Iy1d~%ol!t
z<$f?fNcW1bax;#Zwi+xGIW%j@$;oQIs^DPRc6;A%P*j3kkmY$&KXb~O`5y5g7_@wS
zu$q63-(qDDkbvo}U-I|W(!i-fON0L^ty**>-l25XnbfGWX+}JeVUlh-t9cfSg|-DY
z>8uEOGPPFwVB|BOQ)WH~b9yJv*rwaf=CFsQLZADk>*4;T{vpe?)P9DB)GXYXvv#t<
z+NE)mmvP+`|HXOORd-STlY6FdZ>1hvx^0~=D|M}=Bs=mGWT>%z3vBSRJUDmR?I`o0
zO2<vxd?(!M{N*m;YboWc_q`_j_;ZcxJ)e5BZ6E`i;GtEd5lSIn?W(5r8^iq;mR{06
zZ@%+u_4nQLjJIHnXs+MC_s-M%_udt~e;2U!n^JuFy!^@ar=OoPeK~IhXtXx+t=ral
zSHSKuT=mJsrt_oPEYCfUW2*9twm!CY+wtT3eelqw$5wF<r*#Wnm`H|9Iu?}7lB_9l
z)Xm7XN8zxho6)LSp$Vz33l@EKS5|&yr~JrX`4brZ2=DkPH}R2;d&fsP<s%jSSrz?)
zkF4G6p<KbE5E+n^;3FG1^^QjteaaobxkUDHto{_=`9r?7PUzS4Q){G{g_6>y7>0Hn
z;^F2}I$^Z3(@0`5+YHexHD80t46c{MxmyoCoNyw=NFqQ$gaZP&S8#A}wXlEyU!0tr
zoWutZxZbW8v$H<S|HR)ypWunB=64lYJeuEC(a)#(V|m91yv$Qmrh6=ZbZS$ox6xu#
zP5+}m=6C#Ye)(eNVxyaDoTbEce6$0zbY}+}^+ZKZNy+LB6ZK(}=$e_-)0?tz)taqS
zeinsanx}lYD``$oy?CpoOrif$8~1jRU%^Kzpv*sD=24I+67z}2f7S3A)1O78r<|F%
zY1`C-$F0srfoB%Fztp~%+AW$G7O^^1>1dZ>md^6+LSI0hn6X@$^`)P?OfcBKI?YEm
z7Rw)jtcEe`l@E8p*vf~y3SIwtKJ)r>n&+{?O>yDwMx9fEXFB;murJohmTDGFI;QB&
zEs}Q9*LAk=?TJ+&H~IumZ2A*C@wmtj5YN9A&BaKL2Q&S&>bWXc*c%<TI59h9$8ynw
z^;&0Ex*G+p{v{InI?*@e?8LXH=1uv0OeVVQb^}9nobKY>MQb0f%{>#5F6p{yx~RqK
zRa2x@ZfPy4&$M-)F7oeEMZccr-z6XAVuF8rKC;=dT%o~X;^XJfpFe+i|McnWZ$5qe
z7Pa!YK*8NCjdLHnA9F?79g~!mPS*9Zo}Qnz;9T*X`gn=xXB`V}^R_2$ys<VjDrl>S
zi<^EAXe=-$A|YSI?b#wHFE^X-<>j%Z&ku;b4HVq9;@R8XyE2!}Ue&p4)e7&Ux#gS;
zHUCP2A8xyLJNRbkvLnYhxJ1}^gjk=S_-l2{;;~HeJnPcit0PTrnDHbW<B?+UfD8qf
zt_`gYVyic4>{Uqikji9TzjdSJgK2$l6}R004Sybcr|Dw2O_fE!kwu^;`(E~)s58bA
z(_q(=dq1!Fwtmr$1;-|sTw*h6YGAze?bzSVYmVFQe7kkBZ*#&io`j3w@n)%OTbFPu
zmhl%$JkkuZ=-9XS1CQ~%BImcR4!xI6MVS=pRYU?^n9|ZTf)*{(EIw>(b}daK*x|t4
zON%s%8zj;m-d@Y4xv)ig$2v`uUX_y`Q=B@km`qj)^?Q0Q{`J55{MM*F*Qb8^@yTP7
z%5)KzvX(3<&q-=slTsWLUB$&#c}`?w5&6A$-o-b6_-fdyBBLKYe*Ee6U*7Z6<t~Z!
zJ73aq`Cq?Zttx-M_v5u<-+$T4{)UWS|6BK0r_j;yQ(MA;4#nzMCxloUq)erbig7YI
zOkiLUW@vI-9F*&zFoWfGvgNZmpU+!=o>%#N?z;KMAJk|6`nUgS(RaP|)vLw0xsG;o
zORyd6kvQ1?FR5vh&$7)=OPW7$zRupyus}iM+YiGKj(P^J+(Y|T9I*SYvG@Up0>c8k
z1_lNxh6xN7XBik6*uJLa9H=SPo_8zx$pXFxhA^is3=G*Tuivk(p7s5ZqsmvU`KziN
z{suebI#jhUQJlAGseRT0(9#E!PXSXdffzznOGQ+9LF*xyvVvAH`!Y81GB9YWEDDvI
z_=+JT^Hn_q`|kViPO3jX`Iy<3iA|f|;KW3B-33Vr$BZl9e3Cs}-1eMZ`ndDC$2(p<
zEi?GM!}+M0naRQ_OIjUIEcDcMbUtqq#UOPiCppQobaB!QDf9MKFBCuCez)3xnt@&3
zGXtx~yLax3ZYXXuXP;hij6J5o&_QAWPXJqT#055s83tDG>XVt*Ju_at=k@kxiF@V@
zj8E?{$d)sdmd`D3VEA}g{H)FEJ;@ShtL<8@#+PhXyLPlT>(=sA?af)+oHwTR9C+<|
zGqfxxmveSP@9dxzcIAq<0^Yc$xd`u`TIN#Lcl)mFUB44$(T=xgisxmPP2ME>jETQo
z(M;>J)@Iikl2f{8aq-vNo_hE6X1Gz`olA3f_Fc7h)JO|D>unObl4-kd#A+$cscyG)
zqPlc9h4yX<IJ<GJm{ynWrrgC*MpL^sL`_=XyLMC8wXJ6aO}0()@?GtivQ{-~k*;c(
z)8y1Nk?^lQ6JjloW?c184RycR-sZ7>GOy8RZa2P+FIj<gVvGLB$!dP#uiv=kw69N+
z`t$wP%YC<8zGJ#l_j8_xUH;6nxyC7%RqSeRuUhqU>6RbaSsT0JW-LE<H)#D#X~oKk
z-;AbOWZCgdk~O)kI*Tjg&{<gtt@V5|?hg{|eAPDw{F&t)xTIL|nY-Jhl1p#=cNNPW
z<a;bRbGm8o{JQFM{cg)=CNn>`j1xLjzv#-I&u5=)-+oeJ)-{RQiLL%Czs{93c;;4H
z)OYb~^O>a^?R@oT`Dbs=`sONmdg){LgNrPmsjEIZ)y;TjSNvozqq9A3&W~#K7OTme
ztX1QAu65IYQ9|l-t=k_~I=^-`4)jP{Y0P$W>RO#6*U!lu&0Q-wIci#QyTOuKhm2W6
zv&A;nr!9`%VcH$BIdI)wP1gv-w7bLM2M<rrG1gjYk=Q2ht``<*@$kImfo`73I*WOV
zEt@0~+k~}sHuW5wZ1Y@YnxwMM)HcgGClaShCg~VUv`I|X2|6q}vom3xgqTD)kDiQ$
z=wUu7#j~@{&XkeTwA>uI*&;#5;4sUE#CjQnIR<?aF$QxCDhdn|6Wb&V9v*sdxQ(5S
zzwt14J0E-Vt+uPiX1AJ6%$!rxdbh1iTXkdKnRUBL-s)~!{p!?nJ%{4(Wed;j+0eZ?
z@yXSjxw-yg9ou)7@A;TE&*-eu-q}@&w{D+ivAu1+dvjIhbe&bQmU&Azl;@tERGwco
zukvbf{oL4Y%g0CKDtB^c+N4@O*Q_}F@?e`zvP5#9p2TBz9=krn!sG0R9~;il4V)U4
zmejwWJ2&*yolPM+Gq`uHyU)9F-iz-=x8~l-=8j@s`Lx%}n}20n+sQbWnys@KbEUa*
z&Af7MO*zx;m7)47P2NzN=d$X|nRoQ|$vvO*I%?wDfQR*!5?j)ymNcK)+M4O>sl4Z~
z(w&EQ9u~7ENo+6V^D14TwrP^Frqs!xX;V)8@sMw+xi#(5`rfonj|_F!iWqu(uidmN
zDrM>Fb;`n#TQ^R2c&LB0;MBvTr!5|&Ro*T<bLQl^zD<W!d-aTsE$1a4Hkc=ASU9iZ
zv-@IQNi)aEs>VsjS?d>yKbp@L+<f@(kz{3?g6Rj(^-1z%>}<DrTG{$=F>mYPhv)m7
z9}CTMTXxW>Ag0y*u~}NCJe%i%54G~_M?yEJCHNeQ=ZTzOl4~3|Bky)!RzzYNv(1w|
zSNeG++}SUF`TY7tZHi~y#Vy-zoas5c*zLxINCPbk{r&T|znlE_p<q`}y`aRJq>iJd
zMHeMj927p9n=Im{EfXlQ;-FyHF^!(pPv_MbUpdaB!q6u9DL}Dtb1>u5nLbjHQx2yr
z$=xWWbW6#^tw)D*sd1QaV4F9u@6rtn4C2RMuFl>1?D~uB=-}F~QK9AkW-2l;Okhxb
z8hS^ClgVNF)$cqK1_=k7*?5wal<Jj~z`TxTHXauVgCvC`jvY;Mk0tJc>fjDAXio<5
zK;&^StIPm8OW1p-%n*)2Gnl0(I-1!)26i;wIA$Kx0h(I`skyGCgggZp)6vl}@0W@Y
zQ-Z&Ky`Z3=@Of~x{=RH6sM!IUe*{fFf~Gdj7H1ju<X61izVGXu>0#?0`P<yu^TCJn
z`Ru^0(t#jF;7L%!o@5YDI&iDRF~hCWfm_Sl9A>0&R##U;<{j_-Vq#%nU=S(|eR9lj
z@2)q=(&v2|4NeFNGB9}5GYGv}eQeeCd9vjkpj%ZuuiaYnu!TXfA(4T@@65N~HDb|s
zQ`dycGl?EszmQoXRw0b**dqq{7jJq`7Db1KMymy-%oSOrq@*%8RIyTMra;cb))Q=>
z+$1L|rHD-M%8Fa`Tj{sbe&y__-H#kY6DD1iSjA}?ex31$<@?HWSJwKyst;SlJo9cw
zecz`QdY@nh?o;<(J0~DEyZYXZRU6B%>r3bE7v8D&P^Go^-1p;_>Q;w5ZBi#ai@ket
z&*OEE*Q!2X;NQ+~K6ziQ`0SgXU+k{bXGqx3J~wC2%dXX8XSS_cwJl}JOto$Y#+RE;
z#cm3nb%DWwL1ISK)U7%*moBK^8?CcpcY)E%OUBDi>*(F#*;Ue`#>jKRa|!d7fVcPW
zZ@um=A|7?``!=mLv7e_`3kV7e7`7;K_!ZA_xO4NE)|$BdtleN&o-3a7STs!E^3b!-
z3E4I0vTGaz8WN|gMVjTFoR*iK_q-U?E(mlL;TB=-Vqjok6$x~mq;*oH{#n8wIU94A
z4eYzO-7dMC?{G%JP2j-Wndgcd7#Mf%oLhR`*dRLc+=}f*sdsNUNvXO8&A#?_+VNCS
zKi%(`*$uYFoA+}snD6@r*1Y7*$)02Bmgg84*keo2oN1Yo@B8k-&fVvNW)!gJGTq*F
z?{(R>8}Ak3Guc)utYWwtp|G|-p=lM9RzsKB?X-ix-CxQte}4YykA26&!otq{JXdT}
zs{AqSsP<Mxw_``m%X!Y6@vz)BOZoNu*e`eQhA(k(sowP><tTd>Z(~DK-aF2;w6wjo
zCak4bFJ8RZFg>=^VcQ{rMIou0uUa?*`9COyc>nQClR9(hOxvu@-X_Z=GpA*37Oh_@
zaV^<R;7nRT=M*W2*zJ~i;p(CZ*Dh|_)|7B&ZP><a-L|bum#LWf&X#N}dvIep&t_fK
ztZb9hb3%)Ki(|NhLxhW^eVcY_tT~u<D(0MI@wzFmcqf_8Tx!g{F>uC`ooyN29qo+X
zOGB0gTRhrw=~*;iakJ$)wHd-P+l%wAf1i<9zmDzl)T}kiVw>mKeAs+G$VRT>RZnI`
zh}5N7oAhO#t=W0qt6<{Hu&7Ym1xuds9M~y7Rr$b_k3rk6znhe{GwHhL)N;RFNxHKQ
zZywV*RG6|x^HGh>aT{)H3yag!lKbUc`wix72yec7arep^i4FJpg=Np2KDuyaWno7i
z>!oE%n=aj|?>Ra%`8Z!(toQERd3JJ3lFv7WZ<U;E*kzqN@xzbfHi9!hdIg>NVVSj3
zw(Tmjwxie2rA{+lKZe$b=r^peV-4b8q}5UPQ`E&oV97zvkW-yJt5z9sGaQuA(b}-;
zh_fJ1x6&z{MF)Zo1f7~VRatAzstu|Jss;-aoer!p(Bl1le`o#Qb;V0f6gXQZc(1>y
zI_b=2WBrHc(&7)QaMfvXwLY1&>ZD@mN?jJCkgR~H&J`Y4S+0l}G7EKWSQs%S<fzKg
zpe2U{twJ?J4+U+R5}N46BP7_g#K2`@!wN$Up|>hsM;)F`YMJzxk<0&jc3O6JT1xM%
zW0O@iW}3{@)>#!6Y;c;V{;-ZQ&xSKv-WnbUTiXndiR=%WCZ;2i7{4;Y$DeDxAfM~6
z6+5_MR?2`}zG}tqp!u#63z#({7I{l@OS<+<I;QEY%qFok(px!b!xphnu9cn4FV!zi
zzr=oNQtgtTiVIgIUAi3X7M2vTnoZ*{&zg-Bj%--9>d0xYWju)qn<n@ytgq!UN}X(Q
zT5Z+Il*LkB>sRr!wh5)Ar5bjcI3^~GadRg~x;~s4HgQ7AO2b87zZxGJBpmH*lVn+=
zW@r$hGv&jXl@m^idAjx}g<t9t*GX;7-Ecd1+pW$O25UMcIfO5)^!V%i>htq+oRTwV
zKHdKG%i|vQ>#>P5XEuqu$J##n+WWZv_*+knf2-8rF5D!M<WTi|mWqO1yh!7ghR6>;
zsyL(b7k{Zq+IB^);Gv^l@f6)HnqGl{Q<jH*yIPyI@9gT+?<WO2d8nBg_HHxca5~_=
z@_s=}pM~ePX(mZWyA)TdoJ@|5c9G6*xaMWrWpp!DJYZMrnM9qPx$CRf=Y!Fd-uh6t
z-?Nw!O*h;)+AZQLID5-ti8ZfEIh<w*upIJG{Tf<RV<%f)k~BGBSL>~b8ZldDhngLF
z&DgE8=w-0i?C;yRee>3fPG)h_mRMxy86C06?7D8|)L@V4y31HDEt_g4bb5-;*43$*
zx1Fl@f4}`^zkOcy-y~1&KmYso*?fHe{`2#V_1}K(`M2I>>P^pZ$Z2jVsndG*Fgt9l
zV_<LyeET730Rw|b0}Df7L-q$NyIQju3>nN0b`5L|Od1Rf%nr`)m*+iO<&b!4@27<h
z3=FI#CK`<Au9$pjn6%;o11GOnZ%Cp9gUk1o!JaD@FfjRtOqnW|)hm^8`3mPst;KF_
zzLNDO20@;xTKvHdQu15Z{)l2^kqXWc<7N@ie&1T$9{t<WUp##3sqYL747_Iwuh08v
zZjrqAefAu~_tm$aH+>duy}RSey3ix0Ed~r6#|#%s8LoJ4d5(FJlH!atkxELQNf8~L
zD^1lvwe)ezb9}p-*FCqqRlV->oTmq`7fbNG-gB>>p?F^L91x44cyD>>-Qz}Q*4{2&
z<vZ=-)(wj@)0Uc<_0Cq6c1zIopI&++@9E7gp*P)*mNmJa4La+ndUt2^t~a-oH|j3D
zsmXe#+th1C%+`(Fxzb6;79HKXXwA({x|1_EZn>qpsW(eGVsTQ}H<!#UA|kq`I$J$v
z3M(zm>6~p=pL5b)v_AQ$f69-~JxPoH9kV#4-ji%|%;1?#)}nthMN2+TO_RyAIDX8t
zuqWY6GS6{Im5;}jAFilLspnQbV`s8lB7XDDH}4F${QY`N`|jye(`?^W{QjA{>Drq4
z?T?L)6&{nR(>5xWIT!rR<e1W9$#$ciSLG#Q*Kd8(^SCR$dD8m&&f@k@r;g>OrKZNq
zPcu9$8T#SyIlf{=dto;2b7|8r397fQ%I00VF+1d%wA!T=I!DgxE>1e*bLp0uR;Z3m
zq0nQAWQjk8N0lWuc1wsE_Cy>rG&tgum@L{8aWt8=M<*d!=opV?k71`_*M@@<2R8O3
z>LkUSia0fMVzSncljkhn)~ol#6dnzp@o~{(IfM4x#aFc#NbL=}y0+ln(gNvYocTHT
z?%uOF-Xrw5_xqIHJLJCI{&vsy*Hh=+vu3i}*;`-y9IAKenb~2%nU=?o)!4~52Yhzz
zX7ACL*~23dkvN%6PDYQ%^035t?xQwg!d(wrj~!ch)Q~^kYZiCtMEPygU)-{;pDw@c
z?5d51jQ7?TD)Fg0dos;gV9hq$aOP#6BahWGt&+}6J)=`odAhIiL9*7zDbKv8&v-nq
zLhCbkmu<u`iIbVZTCJar`j?#Xds6u6bHC+z%gKd3ZmDIrjV04oSsXd0byoFus$pTb
z<w1!<TRh(HJS}mwXUU~yT!F9OZk^ntdSq+;wxx4Bi^|T5CVTX5&KA}QjkxHNzVFj#
zo}@KN-I5`#nZbg8MEM{5IR2sFZo)PluSnIhEvvF}XWia)JI(A^T9$XC#rcQFbS$T(
zi%S+CpHr!4IK$$YpU%f~6+4deSR8rWX~FW?zFopFCfO*hFvh0P=Eu*^$C4k-GdLrY
zto3M*W&OwJ{dVd-9uM0k+GRWsH2&$iY?Q0M<?eR9w>#$E@iR;oE6Z{1*6t|yQF!!Y
zq5u5;`8KC@>SE697qv5(_Uv&_!kp#@KPrFx{8&@-$Nkufkg{Co%&l&Q$C%t@3KSBv
zKdyeC;<AB(fr00c&oZB7siu=vS8f%QICjOwZHwEg%nhsSJ+dN=GPfMdIF{xs6_gbe
zskv1HwCa(8@#pHSOWW4gcjs=qpSwD|{)OM}Ndi0y3=9mytFEmFHO>vdE%jVC!=79>
z!`?r4KR;37yl=L?N{HqAw#8W>6`*{7%y28HRSv?^fm>^Ky-Ai{=i-uZu$jeL;@Io9
zdJfQfKpufN$<jNZ7_<`c^+Z8Ifg~kWcsByG3jyiENEjq3DS<jI;I4|2!a+d^WfnIc
z2~bBw;fRZiiz8?eB?!wFgL@a{vWR{|@AcT}xsohg(<PHwxa(_va_)N9^6L83s4cgq
z9PqfoR#>|9fX4;isB+b-x!|tT1O|o$A`F}iOtG047>yWIQqmYY92giKG#G>!Saw~z
zS`HeZQ@OUk{`%`5|CnF><bI;RB6R)w#ama^A7H57y?giGz3;2KmfV&*Z94bU1%BTh
zU!yJ`nkT}q^X}eihx*s%Yp-r-ZPk0zUj6-!5R2{4=c&c9!JZ7Dy;2OKW;bqK1hXvW
zRX(5hcH8aTl%sAb8j%eQ4^95>KllHA-Yk{=1_p*n4ZF78xw`FHx0-C}jh9)WD=)oq
z*R`6%z-X+$tS(+TV{yQh=|-L&S#C}OPfvy3^xpCF?<qa&_j0=RuA!mrYhTxFzxt_`
zQ|r&x?R&ppFOR(|<YB<{T6ep#?sgO7P01DyHm-d2%Cq{~w%fVuLPJAC@|Nye-JKlj
zJ3GbH<fe(KiRm`yVBg8k!On~l25O%*V^|c$^Mcl#I>79{-dVl)z`gg?D%&k)6rVd6
zwlr!^@fn_^GltJ17#LW+bn15|_{Le}E;>6qZ%cm7=djzk+inL}KQ)ptC}3dI-qTrZ
z)U^j3gJP+VG^QS1z`)?C>@a~1)Uh*Qa=55|@%w$B@_oBcU)^Y4EWZ1F^|JK6_u97_
z#(lk#e6r`v?ufP3_dt_#+wN$D&U~`{-mS>l+a~#~y7YQw<lXGkd)vM1^QRRD_OI5}
zUU_uY^b7@lGfs`>yT!&vOTDIQs=l~imGr&ZxM-4hQr<KD@``KUw=aC^6JGZ8*xng;
z&z_0eSjND>qAF-!Gr3sXdfp+g@1<JvLd!Pq{Iu`dy%kAPQ%lyqyA)pjGgo)hgh}6v
zRw*engoX+VGQ?aBy{*i_v})(Nl@0Y=J8nzoZdkQ?)~gu|F{`fbRs%_c$W>Q&n}^nI
z{cAcyCzo|)=+B}*)t^7tyxaXedbWecX43{KEyY~DcYb~O0almZy?bTtooo5}Mn!(3
zf;W?++6q>MfX3YucuR8{LeqB2Zu8u_^LcCit5qEJ*8&!;fA7(;`o2c4#<ocAdbf_t
zVN#pJf)z6*GF6v_g=tKju*_@8g(Jt>uH1_H_jT*7*=}1pC$G^udOW1i;$%rrPG&Nn
zrT5~V)l(IFwNf(0C5w)Q86E5MDOtIrU1G-3V@`gNVNz49R>V43af&Uv6xGB3r}B`0
zxPH1%%<-Ox$A^y|7Hk&xym9GhSK-B&#Xa@Hl74}`K8DA&K0Zi3-ej}t>0>_CHt$1A
z443-!Dt&l7E#hcT#5tdml}E!24U-lh({P@qIJK*tr9!nbDC83d|GV6+$vgaxZFrYw
z>1*w~a;HqsnGMHMXPjj>yOujOOIsi*qWz50_v6hoK6X6r=NG6jm|^(onZIyPj7?!h
z!H17F^*W)QrQV{qZlx)_auz7tHZ$R{Xt<cf)eSRF<@lUkmX-MM)Q&wd!j?1p`P(}-
zeEcHxahtG|v~a|kOG}TRF`RSeNWqW8{fx=-nu-y}4<4OvY^a&Ek*j~E+p&{e5`rH>
zKZM4MsMs-T&2Qo0f9KF}fHgu(Yhy^TNWg(*tcI>#I<56aA_s$6eFU2fl$i`e!?ac%
z)Mi-|aMjt#>B5Aq0j8p18Xie4?LX#!OO}|*<S;>nv)(lPZggVkkAQ|hS`uDM4mN2s
zMleQjZCL8qu;hShFvF^y9xLWJ^h^;tv{FZtGmDE?WTDieMG^~E*gp*M?BZhm$G{qY
zaoe%mN@voHC6jsTBMwU>^8`w)WdFid?<%h7$2CXruc-D4_E6<jZ7r=URxJL={%A61
z$TZCakE2ZyOMAtnRwQzUHZA;NsiWg#I8D+xBmq?58*FOvS<M|fBk0gU!%*jtIf*@n
zOEz|_{Hc5}DXCjYjGN_1H^b^r6AvXC>U0G*ZSV<95SicLwVb7X$?9LN|91Y}{kL}e
zmfrUjH@#M_u-tNpW&S2lCV_t}lRW=VXlUX4{+2m5%1JbG)79IGlh?;>yZwEsX3zo#
z53}33o9(sscdh>4rLL-e{Mb^h5Kv*Pdewhwct`(#L&r$9;K<W2%4`{wvf>*U1VpN9
zBvvpmuqrSzh$JY@VPJe;-=<K@z_x1vFM|lz0)~YSj9ND*FfcH`eO0T@A8XuD*!cVc
zQ-hS$0xs6vrE0U78bmH+)pZ(Wtzclte7VXrU{+G*D<ih$d%dQ7S~e?#*}?PGq^`vm
z91<E$RYU%2_%IqUP4d(XG@N9dDf}n5j%}*epR0vjS|aO0k7%q2k9qX!UA<!8U)#6E
zE4uh%lJ9-rdTx=1<pBl;>2u5l+qhY{-bv4qDHrDmVPcL_W{`Pqc|7)9al7R?ndi(_
z@68)zp3k`R?72ztoab|FFhoAjc@Bz~W0vO%O79#q+`6uK&U5zIGYLmm&+6TFGIx@z
z+X02GZfomBGkVv!I4~qjT<lt8$QZHW)>YArTenu~PL|qsBx;eV=(dxQQ$Z}HTU%G%
z3p0$kRZz~r#j`FvY}H${T&-InQ)_njy^Ebt)^^ov&1JKko82bH0nNMH%U*`w@?Ft!
zX3DapxGOiensKrJd9*b2*{TWaH{|B5*w&We^jl|JuWNUG#?>{GO;>DOD=lWa*efzq
zWLs{S##(8Su&(vH(=w;FTuC!ZnK|RCvEgDf`4_>*xoS=u%Fn-hq*$~jS-#-R$AzD{
zzAd}0XT+~<v1#5(V?Lw6Pn)ZEeb?R?ce}9tnB5xwIZs1=95b4ia?eWi%<lJAXZ^VD
zc`mse8Zymgn!CzPh35JuufpS=6{q(e`F#1j+8VL&^oKTa)2|jJPWmCS=JVV;yLZGC
zUa1T7u6b<T^)~YH%%vMYuGqZo_S7Hs)>&q^`XB#1d1GC=gguXKl;C5L&*yEzEsmxB
zsp+2@@v-aYIeDcYJfg?X&#9>WxjA>^hYjsBlSS;cMgB^DNnaeEaqHVQ?@RR+(-ohl
zmWLkRHD_O%np=ck_>x1*Rc#h?D{pnXSjeX7?%6#3V^3Pz#JY7eJGbOS)ujpVT)ASl
z@0v%_uHTnty^fq~ksXq`JMGrA^LLKS;pU6gITcwQs8n@v!_kbKwX3eAH2pbhEV6Q~
z>Y5ePQ*O*wyWki(CC$sQOX8TtQ=c=3HrGpb?O0Q6aol*ah+$8X#fcfGd{X8l9Xjw>
zc<Q8MN{@veb90L%^BJD(I5gw1#AJ!pJc2#k632v&b(P(gRPE-<-J<+B@ODn&)nbLC
zE7?x^T#U{OSNO1z>swI9>Z@jVJH#{`qFvffY*vX}dFo_EglFO7Rgbl%yjk0w5qRpu
zmRg%t_4_V0pSRNZtbFnE#-?qnbPhbXzP;_Hv9hXUzuS~&Jy)eQeU2NIX>Pe3mS(IR
zlyj5Kkat_Q%PpN`Vb<5pzS+{g$v%dOZSw6B>%x<+HERcLnl(G@P_FBm+<3z~PwEVg
z&EIFOwk-Jh-nx^UZfBibE3rn>Z2OU)MW<_*tl#_1bp5>g7jv#3+xzU5x=r<L8_Dix
z`*T-r>z9?g&7)>4-sX5H@nF*_ixmFFAH|eThw`5}^=HzVb;}j5=dCT-Z)`X-EM}eO
zEzRfiXTF~)R#G%8Z`RRVhxOCfM}5xL+dVnW>tUkV<jqO5qY`7bYPXzSlkNBONcr6L
zuBX?1UmIV#tfqL!!{*!dd0`8$Za+WIe`?R_n(LQe9xvB^eD7nN#f#rLxtpHx`HP2C
zHlKXV{C>}Qb%RqiGe3U(u*bxkSLL+oMSq>uOcxe?>`_0(W>9J|3FM}Idf|FkZ7N>v
zDV#QERuAW<IhS%S2l`0`Ju^0o4!m>s;LBp)KGV6|j^|nIJkAp)tZDOka{a-o+kMk5
z9_*^BV!Ke$6L>>vq0P^}r3N|-^M0EJoqE_6!@2Bm+C{eOp2rJvPrY3ocxBhElgxor
zRvZ@C*tN>=`FVjo8Lrw)SLBb1*0Ue8?{2wsbJ=Y^m7*(_#o4*NQ8R9*oLZ#qcG*eU
z?MO(|L;LnUcWiU-<(tiX?!7G2P$Dw8{+Qv4kB=8!4o^8_$r~Ab_{htXeP1I|=EV2~
z*>}F5z4GD5_p=}6^87qexH2ttrssUatGd-)kFKUBotmR&(^E6+`-Rlw!4ey;NL=l9
zG%U1qjXzTT?3Il?|MB~?KeZj&{CTCjTCkx+s`rPJ=X)MR{_I<^_4lf6ON%y~I;K%4
zR%iU6exC6BiT#t~(_ivM-I^3*YH%g!aF|4s*WJ?WXx;d!`+b)-FfdG6s;R2!<*71d
zvbOW@Pdm2u>dZ__oXv9U#8sDUmuT;3-%zcMGY(5!%v?D;)X>b>H0^fo_9H4gJZm$(
z_WZloSspX>dVv7z0Y(J|?`x~JzdB~vlboFJ?OS<T!Foj~jY?%_95d|6jX$n%#Kn91
zygpV7KQ_o@3V5mo+{1B^Fl1Bc0d;knL477A&;(4gfE#Gbn39r`!a;D)sH3A9)Ctl%
zX1ME#i(|8(0I2shQBZGsULUJiJ-DL<+L`r!v7*9EP9}i~>i2|L8Wp^spIrfRqXcBP
z)xNu*A52iaZ??X|LkQHz16M1CJ;_;yJ+lM1*52!!Xu=$utEa><12px|z%Vzo=Ix8S
zw-=Y*dSLcof(j>7+^XFzjS5TxJjIINzvq5@yi@GN%xfoR*5B|u6u&0#@9$TZ>r#CG
zS-g8*eb4re*`*}0wV{!BHqT9GX)18G`E&lU<>L3x#Y`;!oIfA;J#1_7oNGllRh~@T
z<;WuMdGgGRE`{r9yG?JdJF7C&P{i@&^X9kd(m$>&npq?`ZP%)BtCp@AayxURx0Pg;
zJ@V}1Jg6ct|9o_9+WVa>_2pY;Ox!kEV0-BM{qk?NJv)7UL8W=`oqPrchN~Z(#1Bu;
zwpir3$#iKzQR}k@oN+(5$BI|q+x9#5Ny8PvD-sjl%$>Y>&%5M9ap7}L&S?{v#-ipC
zul0;Ok~O94nuoSZ*e32ohMSg}3MtHUl9+C4Ox?t!JCQL@+ktsfndc^(lbem|UkKg)
zG~Z5h^*(bB<J}+c)LE}z9(#E0wEJ%N*dM)i$h!A#_U_UJrWx<fy|mip7Ui<(-0CGe
zH-&P09eD4+-1BtT+O2nYfi{Y*TD5xjwhP-n&)v<sMr=dWA(^|Icl|qF_2d1Vv-|GX
zottZ=?lQMr)>?15-|pppbA=cA&9$=QT%y)fzk0ja>j&>Ub+mW(>8H;*ZyLL@?sNCH
zckAwIZ$G%tyz<EnX3q^mG0(Htl+S&?@{`KM>67LZy`8yhwU79;Wo<&$rAI<T*6F-^
zCG%hogP(F|@yu*#-wi%$UdzR|ekeaOP4v!jvG?1&o~+M|-1TTr@%Eyrw;$Y>ewWwM
zAjH7ZptAFH{o9Qv_hnr7R7riZT;@#m%I|k?ZLG}7NSs`_%;RG3_E+DQE6mE$=*{vx
zSNY^a(~T`n+)1~+lR8Z1JiW;x;Jr;a?S#3?^b`R{O_n7>(~gRl`@P=1y!7t<tNX=f
zWjY8nuqX!QpZ@%6Z{+NIufDDjWJ~MG$=ovUdnNb1uW`!P*M~RM^H;C0z8lBj;b_32
z!pW4<z^K5$;K86PckkT0RpsU7e8qE~2h`7U@~CfBbojTd$ymkb*iyqN&#k=)Nt?rh
znJ$DyifuGC5?MJV*sCMeV2d=jub8l~O4`a<5~u&1jht@Ob7Inww8@ES+B2R`5!WhS
z>f3qb(2V1{5|4K-?orp%uAg#v<_wO<OwR*P>B)M%GC5|MRiN`Ic&3k$>xNlIA{J9*
zR`6*}Es{3ba4e$mc-rA58OK(O?JN|%5wrDlXrYw;$5^EuduQx9J<C7qu&Qa2&9XJ8
zHZF^r*KK?5P4Vs(J(tp4pGo#bOlP$`viGjSjd_AC$%R?ZW}KFZd0JVr;&f$Yec&;f
z9q!^1w|!Wo9dlZbIbBK87Z1<6#p@<<nCYSB#7V2tI43LY>6+&n_@rS^XK1~5?zZJw
zxtoq%$Ss-~vC%asXIf9>niuPZr$z;5C)KVl_w8wuvDq2>JlrT(PPDS}<Yaw~s|Fip
z=We?=Ys<^ieqXLGZ)x+Jdn6)@eR|g$Hk105t1i5XT9#O`@8fahTWcg%{n+u!hRx*C
zjFhX<;Z5uIelEMZXScJ-v8=3Zx|Z*`R^PCb*^o0^l-)CSR?Y82+7H6qmTom$cI9ST
zl+Ut@TbCt$OqZ03XPzFE_3U=;v}18Gryo6;n)K<X*51h}H_e<AH|vD6GwtA>$+LIa
ztHm=U%FOB?I7S!mc(x{d;&rEB<J4fMi;8g};uE<(b#k9@SbkC?_|t?*@>dmA44lLm
z0~1*y1cRB{7z~y+&2%;D%49gQ;1svgvPC*tGXo?8q!uk!T5&;GGjI~qNv>I)+<}T2
z4y&EC<gb5G{eS#-x&6v>)wYIb-dwy5E?#e4+x|H>cWeF1cT>GQ-*riGdS$J3;#nf0
zDz++X)nbk?4>gaIuDSu*DghToCuvHpT4kl;Y2nE0v1*xS(2S)TTLoFWoPq-y!!#Ic
zC#;I+3sunkz~S`owpq^2kh5-ChDJR`J%LiJo_|-Z?KO4l)znNfS-K|ETO!Ogm`6>*
zP5c{cGs`K>ON{lWmL1Dnvv%3ll?~ehUroJ~qMS7?ggqprXlYKabk>QsLy-zPQ$qbu
z@gI^{HD$(P1s$W%o<JjSi4`Zbx<x{NSS=R1Vz@Ht*u+$yRGn0xm6L*&2?rV-n_xI2
zQbJ|vM7?E8wkCO1abI#@s_|#fjLi|c(I$&U+YBS64w>bIDRYU1)$90dayo1<Q$ocs
z{AS3FGf`PLj&&z(S|gGcH2G!dqr{$-twuhEp*)gJDGAHOw|Xu)G&?A18B^rcp!p(R
zyID3$1l?M4sX53q*SFJEPOEFh{|@{8-(H#*m>1nWR@_}4dpGcp)5`ip_e<)VLZ5w|
zdq=!H$MRg7;D0s4HhIoEf&cYyJuSSSzxivtd6`vs6r`rQc0a5A_>CJWh7l5B#||?~
zOSbVyOG~!#|DUm7&1B6rODFydZ``W={s039m+d~D5C#UO2@DNf2EuU+j4x{!DKIeb
z255k$ygf1}3p+4~E)8K|V95LR?a->A`3cES<!f9R0s^)%FfL_Uq3Ts15WpCntKpTz
z>FU<NkhT2Zs`<ZGm@qI1t^DVu>Kx2D!9=KP$*NRIDF#MURi%KF3m496STe~gM2exR
z*KU7@!14Q^ARWfS{_1<ztvVJwXZzf@=X(R&yDef;Ph(utq^6$Q(Q(GCJ-NB}x#rzi
zwgc+}?<7Zrn&=iw9D8ngp#I$Mvk%xUS6tja=ehap^Ogrt_%jZCz4P4Kzw}<R1b7lB
zx>$-m_FVDYtM^{_o(;EQk3G9;m$QhDp>t5Eh6dXex1-4-fh&5uj%h3o6kBnO;h3S|
znyjO%y1G-YOmh>v7}lLDxHW+%SL~{^P}a<7w_Cl7%<8YW_O3eGyEtR*Qt#9)(yBRH
zLZ991YG1iGbbUS_-4GsE_GxGJ)oa&2T~l&1OFG({yE@gk)2!*1=Z2NDg7~wX%G^%s
z+|JQv6;%q{G-;)9sA_WBp>1Y?e3v|J-?f_^yLMIY(l(8*vokfCZ){t-IV(7o?ULi$
zXsxC#lR{=}owC8KJ}68nC|B#`Hq%YhyfsB`uKhA8TToS1F!yt4{p!wK|1&FpGoJ~4
zcW1}tnSUx?wVSGbxu5sGdh4dWkC$I_`mONs@$Na=Q;PZ&zD=FA+`4eX(rp)h?R{VD
zpPt%#W9jX-=_`|V&iQy^<;zvi$_u{D@A^Ht;^o&x%Z|>Cs9SkEvwi;AP4#{8+B+{V
z`f+AP`kb@du9usw^qn5Xo3Vd(?l!}${*YSDOY&NVZr^j}-reZ`G_~gNrgazJw4Fa3
zpPl79W&O;<+AEWqmx&*%I4@BaclGk63w3thPxoA&d3(EQx$(R28+(@39+pY1zT<Cl
z-1B8dcxQFm?%ce$8%;OOIac-k&U^iJr|OS+C98^i>&dOT__6E8-CVWXp^JM;()w4M
z#+@_fDHfMGZ~6F|bhdAqz;A=oj&F8`$sCQToNxKzXU*xv%sV?ZYa`-JZr7CDu6QhI
z9lj;J`P3ZCu6bs+Z-wW2{haA-x}tCO!AZTdC#^o5yP5gc)Ju~tg%%{u{I&Xa?zUsA
z<ae}hs<+fTEY)*illrR3AvtQ(yY<5TigpK`xX_>I>$E9+%7s@&*Q2b1PW)2}teckc
z<Il?%hl9OMDn2h?%q!3{V^hjhpOZ5q+foV}PdzubO!YeOc<L!TnUI~4!N>F>Jq-+c
z7PkvMO`0z8bjli@sTomA4)xty%W*L(>WCR<>Qdhgf6c?{a}G+nPd#P1q&e}`mFYVC
z%v#-TX8wM!eowqQJGaMh?Y1LdrB=P&v><1%gzRSB&HBuu%G>^4&%HDI<$<4(inVJO
zs=oSQv1)#g@^QbZ>axF&+DkIqrOSOTD15!O%ikz?Mz@Ka^|r&3+VV!Lc0OmfJwCTj
z`&P?mPnko;s*e>fPMlP~ai-&znaO=cOHKz}TX8hf@lM?7C^v2`V=p7#psP)0cIWP;
z@B5v<X5a7VKI_~c=L+vd+g+LKb6Da1*%#CE!=&S?yY}9@dHC_WZ?(6p+KXc{&!5{P
zW6GC5BQebVZuPF1%{4ZkKfd^DcAC?MnW^C6lr@rChj|PNH=7xU&Xn#fXs-YAGeiHf
zWboIJ$L7pijKzIVygIaTb)VhsQ^l@7pZ9yNeO5N_Qh#Rq@#9_JOD|5#otE)r)3Pn?
zMte?PTwyDbqj{P;VtxC*;K%2<_dQPCHRnWX&(%jap3kp!?}_BGOJDrrllgu9y(i`!
zc@w#BdhS(m&2?E*A8t<j+&y!v<?Xz6J9gB+d9uz_zM^)|vV^Pgxvib^`P=P6d7GBs
zT4l3ppOMe0=~ogPYF%T}UhQVM)|OauXWHhZ-EL`yYKCk0WGsIBmLAt#SFmA2u%YbQ
zwTV+3EmvL5>g}@3x|z*wed;l{WN6jdW}_mpz!^Kw8`<jJR<*qN;-&bErNu51ot0D8
zB(hhV)i1cJo*UWLGB<SF(o~<E*^_6cJzidTrMEjm>9F9UjBA%xZ&{Wq*ef{WcBIIR
zh^5kLtHU}?Be-Vgvg$^tesqaD^ySCxY~9Gqv8zooyOS*@wl4Jz6FirlyVW%1_4G(%
zPE~2eB{wG>o1{BQL!@O@)Yhw0x8>aK6fiis%w$P(q}QwZ+wsSD9!q(gxn=8}u$Mkp
zw)=J#^h+c=y^Hwxbmy$=s!=D>+Otk<G_nrevQC!U*rcS=U1sZpw3Vy!O!?BYVlK!A
zZ+&>qt@DZV58HD*CyLVxk8L~`c<#<y@43gVbsk#pc%Jrn?&6diGfq8nmpCR`e)_I_
z=7t~an<htTud-gX!^gZnk>}CTa5=BTPi0EJ_IEs+aMieHwUo=o6_rcN=Q5P)x1V#r
zXcx5f&(e2A(-PL4+P&??&9uIYGfrzfw>rGz@lJPZX>pcw*9snQy2aa)bZW<v!iQ}V
ziHBC-pMFQ4=d{k>V<&$&e$&Vf@x3Y=>2<g)l;_D2{?@pfsqIf?N`9ShvlprV>}cvU
zWqEGf?Xb0?&ezn-mDeg)o^rIB{_yj}FEy;Gq2F%(x;d+Xfq^-5*=BI3bB)2jT|18T
z`b3$W-5fe~M%G5nRF%%An^B?C%3+6-qn2$p)!CA%HrY4I*DUB%P-XyQ?b<BA3G?5(
z{GNaBcHZ+e%j0G@xEq)p7^ZLA-7?$x&%Vcyb&KFmvOof8;t;h%4edmO&t+jrI0EWI
z3ktIFNOUxQ0e7jvopbYg$n>TJc;zE>%JO8HVejuhpuuR+>dOhLAHXfYM?dy~&Vg}k
zl7*~Myj!Hi13rNzS>hOI>eOs;cHq_(x31*ECQ`Eudy;OMt)Kn0CbQ^md0=dI6KD>g
zYSlZCah|U?l;>%$yI$`qSis=HAoMl#_0wwa>6t~^YYRMtSQ_<1<9SycNtQTv^<#PO
z!)UXdo12sN9>4$o>fNKCA9r->tL#%*<h4rcOd_j;$Eh_++Zi5(TNbZxT6ve@e?iFR
z2iNB*F)RCC4eDW3xI0xt>yyKo(;FXoJg#1R<J-U7`AJ_ct-raE`TM@K#Cp|~6)Qcn
z(h^lumYH3W@;#6{_3uB=*kjLqw%oD!aC*-|xj*q-pH?RM`04+89p4l4-R<4I_q(S#
z8DHc5`)l&_o~ars(>dQP$Y|rS`#Y8Ee(lfqbFNuh*wuin`+48awD#!zv`?Y&&Cfr_
zt(s@IkIUnXs9bU6EfxO8FA}K_eRtI#m?UBn?8eb|TQI_6&UWSKcD_R$<$CNlG+bS@
z5-cWk3amUD#L1Sk(lyRQa^^YKt6|y+6BoMAJr=^JefQqyb9;96&8<#aWT-Sx{rI8Z
zXQTFMJo~p|LU(7(U2nze^6h;plcGL-jyhZWEqv~0N&liZyR)wB+k97O*WQ(Lz0c_c
zeXiHvw`zUi`HGl_r?1~GF5UK7^iANKNqm}Ylbejgw(p*$827ct@*aQDjk3ss#hbKq
zqpj06>KPo~w43jA;?2}UeID#zSy@>bk~v(tQ#o~(N?d*WKC|2KTH5a${)UQL%gZ^Y
zOqf=E@5>~QDV-iuIx{=Id)OP?JNfi|wSM6BmnTdd>yHUEe7u}reJ_hwlg(}V?#aG}
zysF11xOj)(y%n`OrswR_8!D=yE2hnH?mG7_cjJ~Bx1yrVQ{)ZqohUE8S-tZ{Sclc6
zmW8)-XYVnabkO_L_iJfFVQFbXp{c2$Gn*1sp|n~WL|iB>O-TOT`a?(eom=!!!9$3p
zes)QG-1cPGxbj)gu3SmFIn!qPc@aThfu)RcCP9J^t->1|6?~XDnH**+uuNib@DO6z
zo3u1IE_=?kU81*cT+8-b@pIA=_eVh<@mD7;-QaP{=+Y*m$kwbGhc%~7S)ID3IdWB6
zGS5^GL+{WapS6=sGS@~L^<3SWm>arsWs<2jQ(b+;jg{Vwi7CFVrc1WAt6CK49F>VV
z^-6nIjx>9!-^!CkrBjbQvq(KR^~9?gPd2Mw6AwAfQ|zwiDRXIa&|~hIp|j=&JG|wJ
z-P({nOShdV^s3f6Eg4Sd-ju^UYO#`jevyS|)?DoEDV}@w%Capxccw|jhG!?9Ssjsh
z+%h)ooL*~LJ)fRl@T7<hM>6Z5&UUf6b#%k($Q<U}scW55-o&odyRc)H+KF#{m9H<Q
z@r7I}oH*^6&XJu`ix;dpIO&+p<C&I|H=GHa>27)9yw_?zwhZl+XPJ$5gg$nkVQcEQ
z^2AqvjtzUnC+Ul=wMzPUZpGQ~c8QfU9!{G&^{L;=W8S8Gn@W9*>US;b%M{C47OQyR
z!=<IUnwqyG9M_vf^D)iyntVaz(~{*KLen3X>85V>%=20I@@kRJx?-hCJ!eiE&P*$r
ze5y#<F6Yeawad=xoGH5_Ja3-O;l9^5m)V@pUVPMQUiy^lMu+(|pH57cG#1-=?(pt>
zqs^!9RbNlJe7+(i`HWlA(<yN|^#xmEcORY;ywq@VuFo|+y^FU#mL`2tI`rt_K^-^I
zXRPw&2{n?*X_NL&DX5wr81~ubi)x$m!+lz*eo@JymKom-Z#tgwxAksGdnRX7S+&gA
zpi*(wvuSK=B8`<S#U0&y{B?s)B<rk^`PnZ%>lV+k;<k!M^Qt=@9xG5b_;^lU>v27A
zw?WhEHD1dFZ_diP)V;{Y=$W(8$<>m^QK|k@En^kGv@1PlGrO6aEp<(N!d|BjTwC-x
zKLva?4GVK;3p%@T)z8`r?&oI~%biXa={at6)ZZgfENh8mS4_&%Q!mt2T|b-<%~`3L
zw8T!N{iuk%s7tL%*YrnDLHn1qEV-h^8_>A0UTC#QL!wti&@`4ALJ6}v7qSVMv}|d~
z6fq2vSdp}FWk_VG>q?JAk3^+Iu3Z|2u54NzM+4=*Y5sHnk}R2X^-9qHiyZQ;T>M8h
z7qs#u3Y=106|!{FNsg_7Vj_z+7=);;)QVc*acbqNPQezhaE`8UFOH2`%psw{E}Riw
zt4vxL>ste*1X}9%I`OP@TJ%>VL_T)yv}*^Zt%^uWOLJS{bXIBVELF{!Y^i@+HR}^R
z4_XP7wCr0Ndh2SUVpn_6iX9?1)*SUpR64}6Uu*rTBVEgQmZ}*9ZE`v4!K3Ma+~tD7
zX5Gamsm9zA%BluOmN{KoDRnfI*HmeBSi`lBuqBy>%d+Zk@;a@N?Amn3&CA1RspSe~
z6NbO)uU3Ek9keV?a@Nh6tCJ(tHc4#MG3bdnrnuOb>)6aLV~>OxEvCL}r_KmVS+p^*
zu_1I-=eMOk5>sY&Y}Q&>8yF|WaXYguRqLR{%2i4;Rv8$mTv=5esyb=I)UbrbMhjNI
zX!Ks|<g+kIG<4H!rh4J5*&LyAK^@b-`F}aIa^Kr^(Nkj<XU|xqvup8_kX8Q|too<r
zpS~t*&EChmr#y4d|Mzaqx#H=IHvSjh@wW78={is?t@<&n|AF`K6@EguR{gp8@tnnB
zzE%4;>)VeVOYHo^CSKI#J2gnzRWkIhYnp`BgBv%_7$p4vECM>bc;d187>^GsCTo8%
zFfzJtKiJj4z!1bB!05*G{{RE?i=Uf1vStN3y4}oK${fPL5Wp}&+xvzU*Q*<<IZ0d$
zB8;pI3=Aqy^EW@@k~>hi_f7iMtqiFS3|B=R7?_>bHcni)fFVHj?ke8kzX~Ft#hv~x
zUdxvG@=7RNwg0keL57K>36p<)$dsU&OD?cE%$gLmaNz>Bh9FOsRlQ~lj(l-{{fm*O
z?*I0^>q-S3&j}pg`#yWFOF(gh`5gAR>Z94MO^^|Sww>XEl5H0pk3DB7-1D@$_xRKc
zJ7X^7h-j@h?8z&JuG5^=D_wc6xN>LjbM%pd`eO#R<(B7)#e?sb&$za6abEEpSrA|H
z>b=+fhU*QtW}odkc5Ka*DWOSQMP0MBj%00dU7Wj8XECpr!75*~W+xVn72U3G8jCYl
zX&JgoyRLC#mS8y6lW<fdcah=htQA{4x2l<DT)Vi%bz8?avs*`I>3a5N>2_@G&K3-b
z+NR@KpL1$U*2Oh$*E()oyB(eNG}$#dy&(2(S;%h9T&GEAyiM0`+q%=eKJHua9gcgY
z@2m?LwAWi7mU{Yp?eoxe(Mc-FX}VI{9$99KZrupZ6uaoVf;-a7c6&*A$!?9e!l@ox
zyV|x2yvcj??%}P8w|G}A>JH4hlGVHFjOhx|iDt9BmblcPjB?qkx@u``ch+oafg87Y
zdnX5OiFRDO`c&^WgRC1jt{pS-beVBgGa=GvrqHC7Yd?7|Qdu(n!~CB``kS}@>?{^7
z&x^?_b~g38cmM9&mDi%T2cOyJY?$J6;!WsUnUu*UbElZLOSqR_&RV*4L+vvC@~zKq
z?Y;NGGHSNglMKgaUF++6KDJc0U6u;S*7}+D?e*48Z;JI^?=GA8;ncUqX{Tmi*ZOht
z)}0iCUtX`(uI2XB{P?A9bU9?(?c0w#dAm;JZkipn*QjjKorA}F!+Z>`Y6q2beA<}U
zvFCibwc72JgjK;&`=q_2pIld29B*)Q`&QGBm(=In&Yo6yHTbhp{QSL+7gyEaTJCj}
zzeh7$DgJiW<lkQXnas1Jqi4Hh*VYLZty_@gx^`R2jNr%h5}v<idY)N-*1PQS+s#qC
zoj1Sc`mI~>q9Qq>Cu*hf?A+2hg>}01*@^M%-gf=_yt^#4-q>XCl3O=pQf2q1^gmo7
zx8>UUX~Iu;3txLFbbD!UTy|Ee%`)Lc$@=x}C+E9YE|<L?9a4Iv_MDvd&cd2wuPkln
zMVrl>S}wC~%b9I%+9zzqIBVXmj5f24`WbfQj`7aq=-nk@=VrZZw@%(>b3L;sC4Bw9
z#|OWLF1_i=vrK>A=cAibYvN4~hH_oZ2@Z?)+^VL#G;^bwwq178e5t+bD)t_q^y#_t
zhFeot)Sup*{pO7J+iPFrKE@dvi$0yRNqT3rW7ny@UAx84%sU!8^^JI@w3gvpceb9!
zx4Ar*cNWZ!*yMgT+i1%TU0<!;f-|{pYNrNszTx9F(fGD1XPdMc&!$b*mTD8Xo#isl
z)i^6`q^%azb}Dn)%?&GW?6dvTSN5cAaq8x*Y_nyl>Tb&Q$}?xKiVjYhKZ`Hpd3u@e
zl82?2?rN&tGLa5Wz1fqp-{_d@tvPRt!!F)DyEyfF#>MR9EMvVh>9^iSYx5XQ-eU3A
z&v4n|jmJ*hoNie3)@*97+qL}-i~csJruiJ)khA9GtVvUj_So6md@?%PV^jHj;uO7<
zGeK#R6IPzt%q}4_<FiQpXJf82o4Gzp8XNW07`arOaPLv`ITM#|Ftg{RoT0O1;E|Lb
zwSptfJ#IcrXRJ#-v)I_c$IWXq&te@zVV$W-XHLzWmb987S>ni<vtGN^PN!WBIJRhG
z+Nr56XO7Ma{jI$zXIt*k)ob28S=ldmbk?e}TdSm9BsQnMS@6)<sN!78(zN=ply8RV
zx$}!}zTI|f$&a2n&sCOh-*(bpimPm@m{hiJ@6*yvCs>_srZ6qswqEwO%jDxTAJ2UK
z?bqzj@*St=Jk-CPzwt5aTg~^<i*HG8>pWc>^|w{7?)IIp(O=KZ3c9iC=1k^kuWtL_
z-kA2i#^CK!;SJZHzpD(tb#!I4%eEWd)7BlS&*e=juSmRo(j<3Mw#w`0J0Dnwold*r
zo4T~+=-0%JJqE`Ne>`RndF#6(>%hz{C(cT?9NCnkoOE(^=4a#RH>K;X<lE*|y-Dib
z^qf8I&@JVxwfnXnu9`j}>u22av&EuYCQaMj_2U-T#VyjYUoY*Gk4yV3x#XK!j(g>D
z{p9zhzjbHSfB9VXv$bs94~qvUe(!s?tN8PWzoNe-d(667k4vplc9vu_eqGovZFX|=
z%w>mFmreOIzfGiWS^TUAJ8!Rgx;^m9ww&Ntf!@V=v(uu~VoPIg?=D<>weHsGsJ8W`
zH`Ds{-JedMyP~>0zsi5wp;I?`x2@Xq{Pc?--@N_iyqPvT^VyrK`jf>v(pf$mB^MiB
z%k>V8m^sm!H#zIu?r4TX+)aneZbgJ^_iQ>D!{cnM)svoFwA|~r>bKghv!Ay`d@NdD
zb}gf5_pF=SGAplr%b)S-@as9ho^PCKQ=O;1;_AlF!mn@JR=6d6*=+I3)>Jz0aj#c#
z@b2aMVp-FkgvVIzwA#IEckZ<M+nwv|PKQTbmx{MMY-qCYHs7n~cb?b0JNe=0io>z1
zcJ=7C@Xy}8pyb98^O9ddc3C<n)=!#Qb8&W|jOko=RjHHdd8?=0b&uAablcbC)QgC1
z%F?-Kj7_tyT%O~1GRJzm)EztV?YY}mK0KeRH|=YFwEL{k%RX5by93)cWvfL;t!=MQ
zOOZ5nQ*%rU-R_-qbX(A#byHU_F<&opbn4VqGDl|>t~6OKD&>85XLTH3yUvy!meX$g
z8TeXmm-u{nOQqYQGgECR&nQk?Ea}d6z2MQQ=FKxN2%lw*?9MJ<%)2t{w(l(AOv9q0
zjAGX7We+z=uibR=wok;FC*f>9MSX$1kr9{EqUukq;EZ|{En+4ua^tPh)`U}+b5G~)
zWY11XTV)vZ+GX1!(^XT><SuPZIOMuA>#@>=XCaHuEdCWTfAz=s(kr_H%w|nHbyl}I
zTjk;slbog{7q_%V@-nsghUeYM70kWu&Xp`?^>nS{wW!y!F=o=aZlNb$JbNY?fA`tb
zox9}<9!sR<)KA`+qb_=u-K<<st;}?~d7Hk$SL;*8w$*pn-a6c8*!OwQ*Q*QfZd@@n
zWnxUk+L;koyN~l#mK&QDSMFJS>|xog$A`}y`MBfZ($iB<^`%NZUh!|<&z%+T&6oCD
z$lSbBv`pvixf8`ZOD9KM-tj!kEN5p~@yxqRp7rH!ossae_EXO}+4`>^A7AhL`TfR>
z-}~Mv_dQM%yR}>ASaP}7<FI2h@=g{O6wdl^e%4R*GY?yi8BW!f=*bK^weR!s!_RZF
z?0&tm<({rRLFUxrm{R$R@6VnDEjW1*@$<^Gv~-Otk5}(_yD{bJY0srvXHLzwp6=E*
zJ?-(rTQ}CEUc6Pb^K@e5jGEH-v+I{1`SHls|NfM;g7??$>@8<z?OT8Eex2RlNAvFQ
zZh012&fBANBgb8e@10@KwaL<3wI?61%kMZA$M@%E`k9aOm+ViSp|RU+b=qmEV<E?;
zg!Xbvb?R=@UAt`R@AHSx_qyMYZSPW^ws!5hZGYbW+H`?|A#GO5Bu~wtr7BCkrnG<9
z<yAlJ)Ur({J+-}qrcPVxvpH3uCD2sIscYGqm1dhgwNq!Oc)KnOHn|pYnrF-9gg>{V
zqu#DvTVI>4|CedXg$28#;!m+O>OcE;7~5Ew3uwp-au_j>L<bTu1g$F(6cn_5sNf+i
z#IpA>WaY?SK{g&27Z-=0)7j^<s&awO{q0GXxLbN-`bSk35drY2zmSuKm6Ui~T&DZY
zXBDeow_D=a&kx`ctL=K1p5A)5XxDY{-r%pHALH{NGU~S>V_ndpuHT_mf5lf8y?VE3
z*Shc5z=MN^u>HV2NjL0kua~8BedDiQ_vW1FTepL6-@H5XFz(>{(z`Pc?Og>rLKwOo
z0JMX+9z;k7ZqZ99Y`^{1;QZ97TFXx-3i=lRy(ts4r{jT4dk&A*)h@{(uj!^of9$^d
zb&-ExRpftbcgu6dA@4Sb*fJ%~th#V_%dB+{Ip?)p^!hj6{+;t%?s8=4&y~*K_ubtc
zxzIFfv8$)fg;{HZCZ;T?v+K&cA9u~GCOqZVpX`*a^^a2zyzg2ok^TGDm4Dl>KJDM@
z$q~8o_37|{<C|67Czx)UUL~j?{JiVP6}9PW)h2zny>&Kcv7(Ptv?1pSx!iY~ibc+^
zO3}=aT)<GZ?$87kZSme-)d>%`iM5{(z3SWiHe^wRjkF%SWy*n-qB==On>l6%c}?9m
zCAO(^ad^Y74I2yUYZ<#1X)R{ucbLKY+PUn)tW}d$wkTB{3cBdNP{dhlZ`reLS-N89
zrc5l>lWu$1_{jE)n2#Al^Tvh_+nKG~v%XK?y)!j5ZtlA;{l?etb$!>=Sig2vbV`Ve
zuj{0eNw;(+#^>I>yL;8UlWMCv?}f%aJALn?%B1qheb>%M=g(eusd{bwJ>h$wPB`Ct
ze`LP(z8~iI_d7T-%w%9-VPbF+d@x~S`MzV-7gptc&dXc0>U(C&yVEl|Iy!f^1{b_q
z7;<&(1qOzlyLx+8RoCUlo_q85?vppwXOph35_ia2>iPD^?Y9qq806%yJ7&1hK)-rX
zt7z)I@430hxr~h~-d*1)C@7<`S}&tM)FgD>JMb=nd)MydoelLj-CAyY_xjA4v**Tv
z%!*m|GHAWh!RH0`(hSbgWs}Zws%&;>QJLhaa{)|V^3=I7$=gI_(pmm{7WbkHU+h>1
z9-dvj{(OF2MNMwC?!J4qcc!g=d-K-rh|TYIGkfn|CS}@ea_L#d-KDyh>ZgXFkB{xk
z$yt@(R}<53v$iU0@4fHU_vU;)AM^RVKG*-1UaIoXl%}lzY|?a@S!$Z8sjqRC>8cZH
zVQQ|c1CF_6NnPFM?PhS8E6`-pMa3wci;1hkG$)#-<!+hfljU_%%4nl@q;n)&#0@k1
z=Uz|UwuEGh)@R+CBDgK*Lgp&osou$*U9sJHqKCD1xNQ|noRu~!d(-AA>t<ZChzvdQ
zEX`PZWwOTA*tyqZTW6%ooG85`>#b+7v0XN>OgU+{SbE+ipUWFJ1slpX-jYq-&AsGI
zIiHhwP|H)*QdiH*k=j`i7gw7dlQ`~qa>2TSOS`5<E;`Jb_wGjh+v1%^US&jGUXvTW
z>BY0~vckKU&gSf#b9i;ykuw*k)@N61R9%_2QFZZ>s?>W=B^&M@Hsz1L_h{XwtCl+s
zA3okuaKhxo_jMJz2Dh%d2j6&>o3^a1WV6}2)VR&3*$Vm=ys<sE;!MoF2_G)8Nrs;4
zO~{sZ3${G=c+&3mMtQG#m!3Ue&k?iPvqwzI`Ot@5p$3~)pNvV|*0VS}(r;<6x2b9P
zx?_2}Rc9p19A5WIHuO?^b>|J))~e%skLPE4>$2GPPIOCJydmyF>9n`vUfHsTr>HlH
zFIlmt$)7><UwT$@a;Dak)8&5MQ?=(dMVvWv+Suq$>yvp7C$1mydVA~G(X5@;TY2i&
zt+1XMJv*?S-`nD5q3k)&Nlz~=_#9<+J7?z1o)zB?CudZxbMJEAefy01>de>EgO;94
zSw8jJtLQYfjcI$IPrcXNZ?*ZjR)wne@m=@Un7+QZHMQ#1<K#r6L*F#5MeXMOzGED+
zZxipm_hN}(*YA7Ew=vRx^TYPbPem&-c{d%uUwg0K_(e>qO{MjD#x?rATHoS6pLd+L
ze(Ut|n|4NDzMgh@Y;nGs-D};_rM_Y8o4%j7Nu94`kSWvWnPIo@)z0;jIcGJuZaSWK
z@qBuP?w+h)aS~mR?9$gP&UUvu_rdL+-758-=-^=1W-js7&KWt9lTCSQBOdHl-!v~~
z*V@7o&2x)$H`kvte%w_ZRry}Y@cF4pHfe2H8&^oJ5nQ!pN@>LH<h0zjYiXi2;)g!8
z{B-#_F)is^iKO4v%}r)+X5ZS)dwQbZwF~QPexKBBs%?uh`|<PpB>B*#B6BWoPSCpQ
zVG}C+k}+P>qo!-3e9077`5e(e`Olgzi#c6p2rW4ov~<#xX(D1G^(&ivw2V9_`345A
zbjlJ;Xl-&1RXFAB(i<vrk}K6y*GbJ$%~5TF=n|HTK~h@IFMr(6j=WpC=Jo28-jHdQ
z-=TG;i&ok<a{9jv%GBsOtkStqSW)5BCa-CM-a@O4+(J}Slr}QVbULBx7V0V!s_M=m
zbgD~rDyxo`*UW$^8TC_{u7tEL5cR+3vg%?Gm)%sQNx$Canr(Aj8+B>2VVcXC$QjEF
zc@lXNjXK>jLslEPtT}Sl{Rii!H0GpS$Bea1qE1e0b+_GG*mO+wA0LlrVq?nWRa#b|
z#;Tig%%)wO9OBy%&7JD}C%`f+C|YabjKC>V4=j2TxHfD<PQ(_kn?l>_x2>Gfl_Heo
zGWAzz9goM-4XZ-CRf3LjMx<~ZmYQmGVa=3QqmcRSLWj1hZH*2#HCkq}ut%9ISxYDA
zl1uKkQ!A$#bGc-Pc!x^NI%PO9A?jGRRJOsXl%{E2dMRl$J0hp5{8|0U{VDgy%E+EG
zGmSkXE*UOOxssSQSz7ASnqw(G7weP7nneXW&UEv*Y@Cs;ExFOiP+_a!H`Sb(leW3t
zob7gM+NvwOvxTm$WIy3=s%`4oEpcSlnv7+_A{$+OjD;h^jFV<cgk-sI^z2s1RXMa#
zW!tue#-af=PQsf)l2W~Higx)5xo%Do+-l~jRG~59*Xq~PR-M1TKVExt*0*o|shg_n
z_dc(_SC${Q=Y8?+>ml`<RKx#zwf{S^zx`&y^>1(guDkZV+Vc@(>XK~_xq@0Wy;7Nt
zzu)k3`ET|5-umoytHD!k&Bll1zjeh=nmomSzkQnZoT=BtJ!XRwM|zj?m!KbZTDPSo
zSF?0nbPLs*wNzxPsh6f!)|8--RsWx9XxFQp%2q47IMtz!_4Ee@CZ_)UW>E$Ph9wLN
zOg*gW4KM5j<sGMLFmMKXr!_kmO%P%TU|^lW%fM2`d*L<%1H%Qo)i-z<YJ#56zVSQC
z*XY_Tlfb1W3mBMOZo7txcsh0Qt$V>6?EjV5G=zb{<ja+=%vFsG7_R(XwJL*wfyqB)
z(xm!^3k;kqRb6@|85lsj!g(4pC;qXoV36O=J!6Hkbh+T4`{(xU`TcnPjAMp9MY|gq
zc#r)&EBAP7i)l;Z&RDruFDiX|dv!#Dy)<rTw>9`O>Cbs?*;72{ncm#%<>B6{L7tu|
z+lr;<+&4cUA6~ugXZNZXcchyO@^}yKFq-69wDDYh@r+~IE5FB7cCXy|>;Z#qIRks_
z0omBQ<qQm3&$N?;L{+6Tb*8wPZgIPq?UI|MsB=0~(^OP2*LCA2h3efK^InxrycwM8
zZOU+_WzM_sa=)v7M{+~M61mPS%5@c;p&52%!J3Of;i((Uc(*PxTe0Zc#l^Wzw^rSo
z6f`Mg&C)4rbn884x$35_-F`{O#bt{6hvny#4QHzV);iOpZKU$tBFtcwagcSiW{$;4
zo|89jg>HCkrgTI5N%>lR+ii1O-sJj)c?Fh#-pxDhw!^a=-QHF6Sy#myv74+qv*yIc
zsUp{yBa;=<bQf)HGg<jHLRQz>tUXKba?*=S%QuC(pDPG|m~=J1e&MREMM}#SxcY|N
z+PdF6{qEXRyxCv%kC|=}>7Th(=VJU}mp7|w3cEu0W~JSnxb=FtSHJ|Gw4lG=ZtE;N
zaVu-;=hv(3Hu|<5h^w3|u5Z$~E@zeytJdAs(a%iRR<ypkmdn2CLhY(u5kFgJs2}Dr
zTKX+*?VObUO*eR_rsbHqEz|f>f9bc9>>|6X(m^-cPE9C27qVw-=r{FE>)uUIk-7c2
zYqR$A-0dN0cS_m~qx&5HsAP42{yf{|tm~HZ=hB2XO*h?IC*giJ{EYu*qn*uXgU@cN
zIhMKI==p+Qysn+LuHUw*DZk3fPBKb*F>kTvf~#7;EUkIWZl_z$+LgO$>if;Ulh)3z
z=S@ir6I|iW<{S|c#Ut;2@s(|HyXID7xo`KZx4ro4b294Jes2a--Konw7kgw}X%0HA
zl&vz&<<{+-v=F<=D*J9pZR?iIel^*5L+(bY-i@oKY?aNv6?NiIrvI#(+p&#yNn01o
zo0e|QI3`-#Yh)L-<HAluqb(t&D}7hp)D6~k$*ecYGMN?iS@f#ln={g)8?&Nj8*3W{
zN^A_yIBV9}oHgO9+nK96SF(<!ZO}V*)FNIoSL=56%l6Eib*E-rF<YIGSajgTtM1RD
zGs8@_PT6mAOj~8qG^H)eHk<92mX7i?I%8yTStqgEIN{jzk6QaO(?WHwoONmbZ0vL9
z%A8c6Ge^#()r$w!c^(RtU3Thhu31>hjoI9vUEPl<MqCP8E4S#tE^n8~TNO<wCX1Yz
zY$$Ikv}4(-Wu6N)X9i0N&QwdNoT7Sk;zY|SHfK)sCHQA5Z@ZMXNOIcISzc!qZfE{l
z8+q}{S?;5z#!ND&lg=!iwJ37QX2(~X-er7MpLQ%o^UaQ{DwQiX*N5hs<*ts7UhMj+
zAt3Mm+)94Eok_nIh)8e0Tgk8f{OPS*d#<I|6m{)Ou}SrQv+D8b=u4~i{rq|R)31H^
z!p)g?J(lGCwC4`r>z<VAs{6g6E4LX1JbOF6=6#!;-TU(jw)f{eZz?MK<ZnA~M(yHb
zT6zX6&%|sjKVM_`@q4V-?2vaq>yI9uRQcx1)zBQV#0`gq4)(-L)SY_ccUyVeRl{Y5
zWwDdDyp7$)mz$I;Eid`m>e!seU%e|otaLTq);INjX>EMj56#ehKR?f(A0Jt(m$m)w
z%l8GP-Ui?E_e2~&^;<dNo7=g3nddS;uNN06f47Wp<`)a9{AsLOwCdaMz#BS;-6Ra_
zeM=24U6YTqvGx;OQrU4PX=Ce8do{&QdrkSp#-Br<uQ+#&uP5x((dAo>y;pX;xwvxW
z#KpOaGo>}N;v|c9Hh<NzZM&*H&&p<Fw#h7=tZiafb$jQeT&=mbIV~vDXV1=<l<P-q
z_!4JbOkCMjQS#d8%C4xr(|)%f{G4YUpPhE~y>@;3wme;%lxMH|R$N<VC38&iS!(a}
zz1Iz@qs?rx+;?|Rt9Vyh+O2qcRc3nZx34u<e!gpa*k8QHKUBxm<?fZjuE(0?g_WUp
z%wEU5jv1?^C9LmS{Mu7evcKnh^Xl0dxm#u3B3GG8WNbe7*e7+_#WOucvg}5eBI44F
zymbn*E=Bm(Pce4hwn6lb*v8!4%9)nibVR2bc^*7@n&Y_Zc8_lr=W}j1n?0U#^4!8*
zA*FYAW=-ey*g50LQk#7-1;@HwmnKa1^4b)#Y-{#?#udkSbGFSkJGmy;S~PQtXko(i
zqSd*n(!!~wQ93*uCpONUb#&F5EoU+=Zcg)@64ml7P~wW%mEO#Ht-cvc+{LG#KKhs^
zQCDn%uC`+2s@$B;8B3B~?YpM@<L`eoTeoq`t=^TJj5Um2Z(BQCTV=;{8Ozfa*QV<3
zF6eAy$PAL4EP2#w=ggf3m+WV!l}$5jOW3TeF4iY*VR^UIPu6$VxqP0=V7YRm(>~>M
zt?!tby)9f(WRi4qabJ30W&LBr#YQEChoyAfG>Wyh9#{Nx+i35Sgv~Ra`R+6+mb_bf
z&e|-}FIKvE=G}I4r8A~h-?zRkd_TXoTkiMCGqKysc3ddtIiB)Ndh_DBGLN2pc<+41
zA|<ga;!?6x%J+GFuUo3mJ3d-kIW=^h75`(?SsLFquRFZ#Y25BbN<m5)SKpTB)$<tk
zNOgJ0$d)rOT(Ek_!1(xj#p@j}mT7L&>`I!kEPHlzwobBHxvas>#C3Pp72S-Sk$ud<
zByR7=RabxCet-P_9{u}8#fGgn%|g?o^DHhKPBWVM@L|&D8tYf_h5~P;g|o~gE=vg-
zuGU<ewM0{^S*n@8>hsR48r9dQuTr{F=lZpN+3f@dR-H|g(u{pn&ZN!oI-6-~wq(+@
zOP4d(s+vrivUG}*s;18*HLk^>YS+SoL)OeRj1D<-a+;*!v~8=UbGKc;rWE6{-)rT+
z@_$RuUcD15(FZy#Ar8Fh$3y7<^fw(H21!Z^2b<ZHU^|zfgGb<vOB&YDVI|NiEEYG=
z@R5H7crYk#A9#_KW3wP=RLKEyhQw}(qdm!`CqReHU61XVo+!y8GCd)HiM1X)wj^-`
zbV{8xXhiAtI<RgR#}4o=D99ct?~OeW1uibTL3d~!Gu-uhV^97*P=6g{rvjMp{ycZi
z+q>e?;H6@#*3ZT`bWUu=F~hF))!V^?O!?^`s(x|e+c)pLx82_1eeYK9id#M4b26X=
zh<6J#?9{vBR`2TjwR3it%LIb=gIx{Z9;}(R9(0t%-q3Q;Otea|`r{AcYFQy?{+Fzr
z`6n|d&Evu*&jTNi?bSc2_PO#0)4lJ}{$EQPy@IApSXgXSc4kvb-<sL0>vb;atzP!>
zm;Ayy?WbqgExUGYzwH%?rD0n`*E$>(y?U<p$CsD<ooA(=isVlTTp;FY!O+Un^H)m#
zQ@jJSH-pXO-E5VrZqtn-iyNNbPhKFv+j3Z~_U`3vt$WSy&z<{N?bT_MM!TBtr)(Y+
za#Y*SuWL_T=;34Mlsbib=BtpE$#+HSLBz_W#<X+=!KFMss;nu8E*Tv-lddw&z<H9l
zQtRP`1q%eY=Wf>9`hM@L-|wq-KM+^l^<F^nVGEC1T8H#@p(~9-<x!>?-=lSxII%fZ
zzdy@%fj^f&=m&#T1f#>vMNM<w_`baDbWeKEy|<PJj@defNINhvFMZmW+wQyWE$8m~
z@*M6QwRi6tbrd<z9hlqjUT53w)IHYsE@!R2_D$qj@tn8ZnVjc7Z)p3#By4)=UZC5S
zz_lXTuA!l<3;|LXL!n%$i;j+t4k8R9cGd6Ke7>!2S)7u&P3`t%p-CK!vEQbCEP4}O
zyR>Yrrvd}$jyT_qxuM>%*=J7sEjd$vbT`ZW%&e;`f_BG#_nN%*y2X;oa|Bo!*NVU2
zue&WuUVY!MGv#}p&-?rR&F_!h3%5O)q`~xJw_urG_wKMI6F|l>Y24VhYNem*dShLy
z$;P5#Z=Rf2pM2u{?!>a3n{!%zetv%;fR&-O^zOr35(^|&B{i+ux;Cppg0YLShgs~u
zNd14ydcU&m?Ci4lFaIj~H9zal@B39{!P@Ui%hqM<u9m%Dd;IwQ+D&OKym#+%NblZh
zqL8UNJ?)sA=k{B@Q+?&_!YAK-8hv7`?R(qz6_wBDRh!SNs0jbzCFuTr1%v%Y!;TD{
z89K_0v!;YbEIF!Zsw}!>%a+q(n`WhMN%0I#Te>;8K6Ry=$xWY)tJ8V}w+3$MT{T;z
zJJ@7fPO{6tmkWbuiCuV^wet27lQbifTd!AdYY$s<;;vrVT*aBvlH6LwdfhUo(=%h9
zUAx)4ZJRIK)Z>Pydsle6dS+Zbsdx9vt+QJ%8P1+%l`SD`7@o22(%NO0vL(B6+zw4O
z6$uY@p2Auxxy-QMY+GngWK@y2YpaycY1V?$E3s!|W~FCjp2?dt_4L+dv3EB_tb4XD
z=XKf5wA4hgSjmaKY^hs)vNhh#xpr%2@9pVfp=XWG94puCd${VX$+27WZ)WP5UX%NJ
zd}6ZNtP_Qvk-2IoIalhqeOVvvICVz3&GEI&XXKK44n4Ot?|9^QI;B3x=AM^M)X`O&
zm+ySbJ=tCFx#O+A@VzH<ZIxzDoRtx=Y4L(nlU-NLaqgLs5ZTu~XK(eQ_i@(IX=bY(
zmsWh1<GbjedpCCRrnu9Q)i>XV1-rc3q<lHzKwHwPZ>`meTh<&)3Vaw+)HS_j$tSMG
z^1oj96|H&teD?Xu&1n}^CV2`=9IH3#bZo0G-PoEVHZ!L$;<RM4PFvfrN4c}ZBokxq
zT#>rHIb>by)TtI*tJzj-P1Yz#NjP|@wRy9Sw8gHXQmxcmGp~Ek&3m`^;_malX?=V5
zR<77=cr*9vblVquXZwkrdUd=z^h{c3R?N(<z3<D{rfq#+VDv7mx}wT^wP*NZ$8X^>
z_4&2ek6($J$1k+i@LgB=zEZhq(OL0{7rzuG3r{IGJ@amISa16rqfIiA7yG`Sled%f
zxO6pIJ?l)=<>IXt>t{XI&5SmSEH2nqlOFLk`O&)Cr=Q+e?CTBuHg&emV>^q*hmS#4
zdns+SOJ6h1a);Y}d65;bW#&~@JgcodvAdeBe$TF@ma8}1nz<%1YVo#twNLuHLXzbz
z#RI4GhE7`CeoW#>q*!;W=c0>Mnzb)WdCIyQCFkCeTb*)r)84gF2j*uMRqL*v*>>8<
z-G6?C?t)(@dwuuW)jnB1@$;gEpQV*kx$JHm=WaGmoar)cp*t)4rAezFiiV#M)IYK?
zF#b;0lrYVDr-(qMBTGXQf}|Gc26Bt?cw~BZ`MN9)3`yc_4O|tHC6W-@7#0+CN-KgR
zQ8a3acSvW7hmnfZQs$5ab@JUm*F6s}JG~0L3n~89s{gZAt<Cu-FlqV6pjl1}l1{AH
z7!t)`66LaNDmTZ%Nt>p+PW9NZ(ph7s(u5N&=Ai=h(^Tt)`cwl=nnWkE8oDgH<TdF^
zkjO#NFb_}vpDb-56E!}13H|0W%em&dX5+MwG{v5PGn`!^*Em*3u;gs>bi3^;IIC0V
z(2{?PBG!Z~mYDcA&tzeb<2y}Tm&I4v4rlo;I2<aR@tbS6Z|kP4wO-P0P3wY!9(v9&
z7BzOAsV1djFlClk{nYrWbrVyj`05IB_NZ))>f~iz%DN(oJ9O2BO)T93-OuK9wi-l;
z%?MWQN}3jwa<s9BD@}4Cx2foARgugEUDuXOj?kK!In7w&jI$WW!C8h=O?%A}XPnq7
zG&O^}XKAvw6w`jqpW2@~f7tZQa-9)5by@DrG|@GygAT1R(@ouS%(OmYsau%T=EzoW
z*ELgnHyTPfY|!7BBb>NNvP<Hagv!+g!H?KyDTir?MoKJQwXIXwDO<I7V?>WfDu2q&
z&`meP5|;5KBrTOV84~Zr@hm%(ciZjUE;lVB2mYXr(7)cl9`odX|6eb@vBzbyunNx^
z(TQQMk)kP{Y?W8z9|+0+;jFJeu>6z%_RsZ3-=fu0Lc2D(8TNP>_Dn8TOY_}-)4W{m
zou$e;22O_DZCf9;)(Q&$Td1e><7dtFvRCg+uYyO4^h4uk-MV!@p3BfQ%*AC@qo7us
zq2#I=2bZnv5xHvE?6n?pnENK#r4u5Ugs$voU;rQH9>BoB<-o+CQGdX82SfG44u+-7
zpvq~f34=xx=yLm-xWjJk$Cg@fA7GGVVEmH7((J&v>f3eB;IAgjOtnlHn1k&@eMSC<
znp|LOI5uIb=dT4ODF-HBRaxnLQA&!JDa&ihg$zT6gPtl=R+wDinN?T6;Qr0S<;7pi
z+ViUq7fT$=x3=YbxbtvveRJ<~=ex%XuWK*nFXsRa36)Eq*L-IkdwlBq!n@ad9!hL8
zGu$W_n{i_qTWfbB=b41kJIB~#iYs?8_8xq_=NNnJ!RrO3cVx@iqxW8~uzCxTk3Ewf
zUcK&~#Ier>405|0nAbhvTlYQo0Yl~CTh;3xubUJUsXOoW+Kp>w8P<2_M7v$PX&M-5
zIO*7-TMO3;X;$3c8GBdn2+~pPQv+v)&eAz>R!Dg6sdq1L@ukY{Txwk`yQ-{1aHhAZ
z&c!q>#bVthrz2KE4q#U`P1)KTaoFtGmWWjvw@$8>&X}?$wCT#UuaR15A<1>}S8YU-
zwe4meT(vRKul~~hRVg2ic=u|Y(Z1|!Ji|0>@~rm7T7iFLEJJ@>^|+n8<wF0mRogme
zsxRjLc=~hh;wL}-+mzDJ@qWA9<-crJma%HqTD26ro(?-1tL6un{Fin85u5Z@*vNlz
zV64&ln{U3AOPo14`TO1Q<2>d|vnr<<*gbd{S0fRT>Tc96_4|ER{oZZYe*FtbP8PZ5
z)p1+u+Sx7ZPyU?i>~_;WBKyqF*=e~;V;6rmlS+K<yTi?!H#g?izDu`@YwkszdG#XA
zy*KnjN_f_$&%zTcwg#C+^KNQ4dQq=7<?qh469=zpcl?>B=Q&yAZ!m9L<=wR_c8k<$
zHcp=vlk0l_U?Bf(qpeG4%=*2$enales7q&j-dP89<tU{s%gPp=y8}Y)@=*2{O*(jF
zs@0~${D-@jPK%MTd~OvICbe=}Xq)Anqt0P#jCy<`GbJLQTZXJLbc+IsUf6J9W~w*O
zv84uA)grwPOU~>v^lsBiT(WD!j)GT{9=7u`g3eXHVYJn$IBj!U!NGc;4WN_NWpEy>
z-rOe6C&SP2nd1ywD$k|)%cffuz19AhT0C7t=Je%&XK_&z%W`bZW)+)l>sRIsPdo2p
z9bK6)`R?ZA+ncj5FMk&o8DeXhZyQox<X;_a^?uHZ@?uHvdC?QL`AhLtmIfcI4?oT(
zv9TwyPexB7FI)fc(TWX)h26cqernn;<yDScl;5U*W9G8mX0d%QUVpna^Id;&+p(i}
zo~{j!3cYZ(-{5Mp&ehZvxA>1OIkxE8opYyCUTxm4Ephj1$*yyYwoUTa+9!3)XREL0
z!r&`s?2hEPW%k|Xp4lAM*7syrP3qgt=XPDIXI(2=@Ud}8)E3h)=1Av-a%!_S92U&-
z^;-CR>cqT)cLh6JX6)8ov{P)Y>9!l!qD=E%O}(^RFwG%bY3Z~j$5aeXxNKDm{;@><
zl>CuYgTK5wj|{c5r|!&>Si1CTsaBChS>C#Jm(p`?-Mkxf>&D5+v$o54H|_6wIQ4M%
zw88_QHqTmJ-!0nfJx#Cj=(F%yt4$JHyZH>yTYTo{Y<+mIddr$Q-YwHV`nMrYTt9ky
z&ea&B$lH^p*1Wk{7_-sxnWbF9yN4DTciTg|j-LGZ{LGJ<qs%RbKD?h-CUWwlp2y@L
zXJ^iGe>kbYM!x;<6X+T25}WNyZ;QrU%5_~?uT^;U;_;|=j|wLp=9Zl;+OvbtUdG?9
z^33T|cB!E|cUfc{nlruq@%i&If8=M1dKU-m6Zlj5Heqqjv?U#K#d9prRX*5qMQhcy
zsL<6>zqao8{@lP|7Oh~Wv)S8dhR|uF8G?|r*SEN2^xX7aaaK1}qIY%T%(mG<OV_O2
zv^j^No`J0{H)_k()$v=Sz5hEKwJ9)ofKD0T;Q`u-^Rqs%nGJH}dPhfxK?0~V%p+ka
zkZ`c0S&&VMqqZlx9C~zzl9G}vm<J+3SV{55UGTNhvtef?f@p9TcOs}`>>^<($h<MI
zCvT^q5bQ8Tl<sZbGbM#16JXn$c4xtsOGtnY`2g|2yN%vihu<%~Gd(-+k$-j8_m%_m
zrZ323m9KXLsa`B`?AL4X<<Ov27VldcLH*<=2Omxz(245bSFNu2SbAMp0JQUY^48FF
zNv7D~p50-eL*JL)nI5`5mgkfR18CP(Xl$XPh6w2FzS5A#3O+_Gv;N5+{+@sT-PYeb
ztM64;f8>nlc(+ieqjz<Rw5R5`DJooV>lZMvdfvDdU(c^7bXM3+NG(vQb3LQb4wbzN
zh0aL3aW>qR3iP;ib@}Hc*3ka)^4LSGo|l)$1T+LJ>at>J{`9^&wmfESsLPN4#m9S9
zzxfzUn-uozrnTg!1P{^M4h&qAH*VQi^X2RuA+~4lUNkVW{qBC>zPE!h$kqJ1neOV^
zFJJ2CTQ}eLagaA^J>wwg?#Uv=xngl=P0UVNmE$Y--czr7f4ueW%j=IHR@YipuuRgQ
zq4s3@AqEyv?F<ISV6S7BPK4+?SubW-6xkFx$y32yS5;Tl^W;RKlZ~4EQL9$P$n-sI
z5!VuEwppvU^y+1&%s^g+&v(z)PE6v|+RRyNqQZB!{_aHvCf;{?Z}ct~y-}1@shpIw
zdY9L#F72HwW^F5IU}P&hX<p*M&|JNHcMAiD^^SFu<IbIVds%Jo*+&j4!5brYyuK=W
zHEV0p(rZidYZ@3Bn2vUfv0ge5tHZ#+z%8Z|v1?V-tCi_N?sJ~oeyw3nuz2RFCONaa
zp*-z-Vn*!U&+7F?>5&Z#j8(I)+m>GQv^Zyx=g)J>^v<rGcitzqD7I~_GYOrRUaacr
zvr=V}r)ui1z)*%45~<Jh8_MS%I5~4>=p^5>Z&k#1nyaNHFii4Pnf=_d!Q5!i^oMg}
zPMbcjoPBpjMa~1>6NRSb<ui76E3LR98nfI>W0gc>h=Frx{_*ni`q;}`gV#OYy?a#)
zTc}4**Ak(p;Vvnm_0n~-mR;~%p|WP1(x2}!`|aLe-d_1WbVu*Dth0jO?cUGcz3N9t
zNB{O%?|pae?n<q1nbqVlQ*i|cCl}|IsOY?gPKgE~50*(?8f{xy+UNfj3=IFKB2fRX
zlZ*dN<f6-=v&5!FN=B|s^zo@zoN<;*v&$#MTjyfhtTmB6vrai@+{_8MaLfC5Z<w$*
z@3fewdOKI`WL)dHSm{~G+l{9uw+9u591BTnXFDvaJ!3PMtk*gYtCe1bJtt44%Y-d<
zc^2h!JaT8+&WUrLb6c(xOrDapd-m?o%)h<dV$Q2mcIIr}lv}ihM{#LeaqIKedG!^_
zM~Xh{O*rlP5NyTAb6Ib9raZhdCuqj0o-Gq9%p`)A8%8!+X;!FK1jKP^?cXh|TLeC!
zeRo!pq0r7!tv8dSo<=>*N)i^kvHbX9!-MbrCFfW?d$qXp_>AX`>7i2#`4yk#m_F}|
zc{*)P;p0;gpGBT_pYb@-A9`21@v3V5hYK4MYbt{>-HR=6M%hFKi#$EX^WC-5EKR>4
zeGm7gWloVvw|b7wO77E(i*W{>=5Fh8e7=|Wt)7#!F13rF-km$?@iUnU$DW!gsy#KJ
z1Kp?GNSmUwreXT6O<Q#(g;uVb@XIUSOYp;j{;q|Ze>hgG{@t-+wIHLZAXlc>!c|M_
z)tEMjE!fH(sOz$kP2r@st8Pf!DrXi6g@f8GYgKhsbu@G|bT!<jD06Wf&RQG4?0@CV
zv_lLtJeln`*k7B<F@Mpjkoi-Zy@J{nWjI_7+OQ;IX@}QQ&4j5w4o5Y7yaHQ8R*Os)
zn6f62>(v6$qLs={iy~EmMY$xEJST*RadBJ{srUN7)Wt_>(fUsZMMaaeR$YJXGF2$-
z#!Qo$Ix|gX>S~*v4qCD@)lD*SMrvEiDqSvNwlK-WX(Ia<DsywQsfqsON;HVmwDnro
z6@O_ZABTl%$&?KXwsdO#@cbE)q!_wVYSP5cq^?aptA$Qxigm3B7HR$}{L%X(^G8qn
zkXp}4S2ODuoa{QItznwjIgO`Hbye5e3Cu>pSyQKOi#Ax=EEzFvX~?XV_MsDJBu?`=
ztTR*1TV=)-#~+;!HXQOX%Gugx7}~M2wMWNWFe3Efw8X9>DUty*4ov-_`p_WZU}rNo
z!(z@JG1aaaD?XeyIBKwFVrn2yqE`O_(U@zQTUVGJV9kz<t`FLFQOGFNE6zd7enI_?
zOC9^u-#pj4zP{pXeyVNUx~u!U7ODSmnEuCW#Xq}K2WRe|J!=-Pr_ff@RYEKs9kaYT
zrfXl#x&PQGBg2#BkVjhG#Q0MI|C!XeYHPD2vpJX&RfJxxe!F(n*A?rFML?TrrnH3e
zG9=zAh3}=QXMk*`Vcb~2{C;u}0|UDQgOmn?y8{DL1K$^|)^BYl&QpHBbZUrZ;F)x-
zm4SQft+ttLT_GnsjwEW;&05lF>p6izY5v|o(|`*MjOwerf_NF&K&LZiT*xq~nh83d
zF(7jRkN@_|=MUAs*%P%+^3=zy9ciKJ-DmGGFfi!WpR@XW&+5SL?NU=u?P%N3>7B44
zLZLDCaB+L|x!|K$pBCMgYH(zgD{fx*@YyqF+w$25_=?XJH_iny%GbTyy=zyb?wseA
zXCMQ?bDlGRcE()3TR!Kx#p?!UiDNw(#}?0dZejJVc+R_Z-(w%1EBM^DILuUH)n;!4
z-c`BM^=3}Dj2T7V+{k+>d$(-WHrKMiO-q6!e6uDj&(64es65X(%RMnVFd%ZuX04^{
z8PaN}Gj8UH9XY1EadlvF(y`mFt0h+5QcljgaWgne=iaiY2n~&>NWrD6m6Vi1CmN}_
z`mSG^yWi_;);`N)2Hd}9Jl5)$I9Az{c&6f{_=m@n{3Ywd5|61%{5TYoEMY8h*zlN8
z#p8(|PSm8-=}b5Han$0_-+AZL3wxKpUuPKiE-qx_`{LvG&u)|4hJFtEX9?&z=%?%q
zcE@MmlsqnSo?SIw=(#)YW6<@Vsx19ouXfegEz8VzRa(zgEwPK6W-d03b~}~UbJQcO
zUp8Rfti+z=kH@tZOKj|x==L>S+LJ8I6O^pl6K1k;)y9R%uD#Au-V&zVK88zulBA4;
zCA4*tIg^E+1sw}H(=8c(%&+ixrcKi0KCL;&d&MO_PLer%Smt)_mWm|LLk?}BVJyt;
z^~#)yO)Lrr^(^jJdhc$0pSwTz@%?on);m{DD1Q8Tue@o{TfO8QL&?c=YSIrs{9(#(
z60xD;(8tpU4z{*Q8YF^lb(&+?^I=c$(L{@NQhH`aGQk30KL#@$gr0;x9dr=-^*R0J
zZ@-`V_%8Z*Ncz1G-wUsuNh>*QXmN6uU;V7el`$8SAD@dUKF=%}-m}~&X3ue%&j-V2
z#D-KPOBt?AS{5XJ=9JxJL+gphPoJ}SZu89dn4#p<GiQ!PuIe*1Tw$zP%q=dld5&O@
zwo>2kIU9STQiDZ}Cc5vtturT4PqioLX?E#4*638-)d8AOx+;d99_MSHK9e{aaU^Vp
zLYP*4l6}*{Km9%R%57!Gczb7@HkLJ6m6bc~_Bu_0C6m_XdEq|@eW3+d0Z+KZnVECK
z`DOg=>}o#F__4glm|f!3j`e&sm5<MNJ{Gb_Jf?WusYo^albPhIZ_ie}d+_e|^s+lU
zj`q|?-rOjrvrh5w!{g#dkJ{DQ)qK|3__NsPPsooW(X;yun~M0GA3lHl{OHHeALXS)
zmA6K#+{!iVGgRfXc(v`?&9y7HhF_2V*s%t5tzDv8uv)O$+0>MisYzxV1*JAh&gRxR
zVyboI=+bGYL8qXbWO}ajOuMo;5Oj7rgZ{C#tGyy_ZT)pM^1p{MholMv0|QfO=w0wZ
zc|U({1hv~c4oWB)Bpd-X!P!9VcMj-WRtM;;05))gA2h86p6F6iQi=yPrjPc3PCcJq
z(8MA(eR&lVZ#`%x3e=L9P`q)>JjTFzV^7|W1lY|>pxc*9LE;@99fqI=z7^~w!0F(H
z)yHH@&(1dMx-oU5c2d|;aFZT%>N*6Q$Ch2mb-MyOtsPtdg+hc4LDwbK{N!Xg;i1CG
zRPQiBrNM*6gk=MR3WIs>s&y|IW-<tU-?}yKTYBtn4nfXatJdvM;kn=oZNnb|9YJ7r
zfBPHR{QGaeeZ8<td|}kS`OaGd-oN5nJk?!i)v8sub2c8nFyp9zrceX(|5B60CJ95H
zqf%Q{7~KT-z2xH;ynCVi`ntIR&zalT$NjDk71{8CA=@`O*K{32l<&6KDXUi94vk^h
zwBE1!`}^~vc`@&89zO3{-Q2$Z@V)=@`?uHr==;eUcxv&q&`_1hnkqg=5>j8ybPGA9
z&m9^qyj-v<_Ukjz(3N%aY~Qb6dUJl(yme=qSiL4_7q!~j>Fd`#KHd_e<f-9$cOpx%
z%+3cNMC<)o%1=BE5Ovo&cH=hJ>TPDXb<fHC`hMzOrR3z;&J#P=p4zl(b=Im?7thPI
z+dMCQ_Uv2P(Hm#VV~^F&y|G)e@AZz8FI{G?IVH|=K;iC6rp+2*N}hE>UUMB){f;Nk
z*=ZSV-o0h(t+cag#!5<g`?jz96&f18`SH`K@ix2m<vtA!jjdn$+|+3~pG?t};+~VU
zuf4r{Wy+pstz45lRb4<}&)t<R+tN}S7??a|nH)g9Cyy0Q3Z+^<_uegg`{YpY90uJT
z+n!mk)Y>b(TXd(vW~0UWYC=K=d6PU<CSPRIHf+DEIB~|^2BuXT%!<p7J?DLEtEux=
zVwX!;Y=CfMxAc*&`c;1!&(-|=d^N<yh2i?S+M1umuXev{VA%HP_Ke!6ODhlWUbJ1!
zDtdas$1^G_hIc$wCiyieX&W|7+4r<(0>ic!yz@l!cjlLsEm`BFuu$o9>4}-au}7MG
z)R^b|e1Ct}ijM9E@Tuovv$k!!(7+rL>K%5YqPRCXCwJSitDzzr8tO$?t=e{>A#B>l
zt*Z_(My*<%%OQR{zHKwBC<9Z}?EI7G*YDS#{k-(P)y_zVz^)Sv9bARs<r^<uzQVV9
z_r0&%M5{}G9zI;d$rK^PaE+zWtYy>I^7Hd<7thNLzW43zz3Sb&FK-1MeqOa|f&48^
zt*MVe2cJi^E_TT}wp!|#x2REl7>~<oZEY8i3&9~l8A-{`S-HCPyKcSpT^!|d@|tMU
z<5gCErg{^X9h+wGc+oD40}mB@LQWisNj)tYaazjK<k7N6GD*qel8Tn8QAR5Yot`qD
zSf%UQnPp)A^Esz&%-*?%#d3zp{ruuQZalH-$=+g`$6bs1Og(#pr(~{dvv?X;Z^KjZ
zCGcsuzC=-&#Cj%YiIo#O_E<cfW|%ByJlRjHFto=fV#UX)0hURUQ5psAi>AI5ntmw6
zagXn`qdQ90t~QOmyn3bEsdv|QEZKI-Gi5_s>au6I&Td-kn#AKR@UtcE$A@A$Lz%*d
zkNDYy+3aFYJ}T^P@6+d#lT&Z)+A=+4i){VcB)%m^&RbWrNqH1znQ2SSxVq6;**N3y
z;i-icyM*W5-1zXrM=?1&#kix%Jh`1SOt*&Y_}ON8cDCT*$9y)L$?_ar$L#oY+D+4z
z=!8uO{2XxO){+GW`kU6TWc=bZwZ_3EE`T*OjzMeH(I96Ph6{q3t~^``!6FfhE(AOJ
zy861-gHAtRnzb_0A(e58TcFg6tc8;%Yzh)nbq->7S|lYZ@L%~q&y<w`DxhoZzK7N)
ztqP4_u&VJ#h)IW7XxEBU!YrMWCN2r#4Ox^Ks_DZNx@(0(j*>8ka!{z4!qN_r86vAr
zEb=-L;vB@p|7)qrCZ<sTxmq5z+iq@yoPpk3Z@5^@;F!c=6*Vo#zl{Db0!u_*X%)DC
zVJQg>chzoMs}yoHB=D!>k0qzPf=*3av2YXHw62Jy%er|2E;aCo@?UtgC1OUhj#1i*
z6DG$Ddn6*7d{%R_rFe6D8HPG@l^m8x)=U-({^Z_t<fxd}%BD*_9-Ca&pK|AHIkHit
zM_FmBNc{y@eFZ^rcjh@3#dCgt;HwM%xZmhJA9LVVUN`^pZN-Q7@70+6M>Vwmpv%Vt
z@7D)Np7}h7ZC$Q!?t&AKlxOGPn{sLC0tOETvAUM^4;B8i3OCl&Bugy?71B(xp*3qA
zA1VJo6A<P(<yv8s*Jp<8ecvBQu&~PAZ_{dEU_QSy{A#@f7e8NvU1M!dTLx$z8id(y
z7%@2ofG!a1o78jrsfKfV)hY(g4Qw}<LoygAFlg|7^kDcB!sx$8YQn`=ybO#B7^E_s
zFMD}`W*ivUW?xyUXcFwez;J;<<*S!hrtcQdWesu@*cw=_tXvszpvQ;V$>iiRXI7Od
zu0d7v>L>gScAR{rs)6D1>#v;u?Cvk*sr_F*542Og=&@Yo^I6XWMPxpo(=Clz-4PhD
zv}m28tJCh{?$x_=_qa*C>&|nN`1Ae#y_lnKGViFhbzi%8Z0^0~W!t{&E1h&;(#k1~
zYPZkb+GTLu+;VG4V)xD4H$N1&TOK&K`@ua1%kvU<o;^3IFP`(fPYxt@>;vPuiet~s
zEf>#uZc|qA+#(rt==#Cy#d98>mAZYbw};JgadffUF=pHFYMboY5^}LSA22X5>?nL%
z-Y@m+82j|R3I+xS6SIF=>s)^>PU+vc>f+ReYm38rx82#=&B7Ac9kIc|RYXA0H87!}
zORG8R&Wfw6C$`nIB(`qXx)_}oapOSXDxI7JjkVckW?|bnI4(wUa9rHFQGaVn)BNh$
z(b;$JNrTAJ!>gm%4RWUNWrdn#t<+Dtbz>W+`mC^|Nn3Yral5!WYkN;(+l{ufn{yT%
z>z#2ycedHtEjc&0<u)3&8K_6y?BO^pwbD2{Dr(l%u&rXciv#PEZs~^UWV;>h&A7ED
zFv?70t#tJ5fLSeDjeXWm3eHuTwfaMxO~{`_yEDPO>OIL?S%+`MEh`rJ_pESYxR|#a
z=c=ROSr?MUc=cz+>6)fSZJk!EZ~SnDyyS<2AFdpm_;SgqQ|p&p@{@Eu>|=7+XPNfZ
z)ofF~O_OSKn{??^MP}mCw)$yee5ucBOaqT8A5D-C{TR1!MW$u^s;_*VRVDKl*g9Xn
zyyTC3%BepkbHXNTyRMduxY`zVbj`+YyP4suC9XDW)K;E1yJGR>%A>VWo38Y)K0Wp6
z)cHJV@$xe3rz~IYu6^;icAsIq%)<|-ek`i<>sLN?@#TjH>)Wr-si<Apb)@~)>iWeG
zf5zKKo84aA;~TI)YO?Xe6$M#qQu(h{{*bM(vwo1>?DXo?<ZtV@9=Te(E^PJFg4&f=
z&9a{Dcsyfr+qC5!4-dQiGTL`}o#y-AV2<B$wl*@W3@%;y?eg+rn*{%=qv7jkWzFdP
zw#T+&T8*t~!iNisC-p7Un<wwxX6U}sE=f4#etq`(x~IP+)2#VSXB@cN9L!iJYnsu1
zdEyL<<q|$dmcP%X_U!z5F17z&Tv}@Xt)=P@7bS-V=B!<GGuneWGe>vn7C|>dXNhBC
z#a%H;X~}jw9wbW~^*NLBr|@7;utemH6K9gyj3Q1Xi-{bQI5OjCL_$wO#4&?uCSK20
zCUectW;d)q*te#A#^XMLk1fa4XRVqWVR`WMYUeYB$6c29hPrRf6%R8==iPR@GKHU~
za>CMkuQ#3DmSX#Ex6bYK=I&#Hg-v26{!+m`E0iUcMt(f1SKLy3PMu9KUEaE`M*CoY
z&#GrZ+n-<Wtgy4#ImvSJemk2Fsr)^Q4gB7lbo|(m=Je&%!TQ#zJxQ6%*kmG-g>{UB
z+CA5-^^HudooADDv^z+Bvvk__wC&r@R;|0acC*Kag7&D#(^(@EHu(sCd3qwrAY5j-
zQcR6Jo1De*2ag~9X}YAdRdq(4vG%J6ujXXUTvvE;)i%r1Pb+;c&YC%Eqi)3M<ATra
zB|m<6a41dNP=4k`qcw7+^<SU6+B~;hzb_`jWaYDHag)<t#VY$W4PGAhHR@X@wNb{@
z;2mGcj~`#Y{MaGS-Yz4fbII<UcC)<l%GAZ0AN`h=nZ}rwtj-dTe*OBD?c%5V>;h}U
zQ_ZGDn22?WAC~Z6-P}?Da><pG*)mUR*N65-t#^4bb5WXC!pFX;6_4dB>nnVuoX_Me
zp0&nA+`zx<(?;j^<vd#s6wUQ2IJmrECx3sxf49rij1QN^3~PL9cJXXTjgysKv@_q%
zFkaQ#OzHfZ0x9mGP<gv&m$ln86HclNoh<GPyBSq1^gCAgqT`HiVVAc-J6Fv}(pk21
z<JR;}r>NbzcV@WVI=gjZkpW-h!P0uB8!~&YyH8v2VtK?&(Q4m@h#$W`avx*zx)A00
zG5lI?&b676w|N&YT6wC=N=<Q=*io~(OX4s77*4ItPMw|eHahfl!L);0cb!@@op;mr
zuq~UWT+Q3|?3xRAU|4r#)U-=iOQUBS%X)vk*}GXe=i1H28zo15wV8JwwVY>s>2uju
zHHrGGNw0QI>~<=y+i`67%=2v(pIuKIUM*RXbZO-;xpE7bm|tYCR`bfF;BRNDd2bgz
z{BX|ZisxykrP<kA_t~HPbl-pJeNUwnPvO!#lhj-${#^S#hr#5sufbs+!?npg28Sh%
z85<jIjPhBl6J>Pe;$r_F<~coSq36_f(mWG-uDTb@xptH1hFUJ@Ja@shDqAx{y;e*M
z+2rk;IxE=O*!=kih7!^G4f2nkot<sk;9%eT4!oujv{uo@u~{IA<A{q3ybq{wu)~lA
zd_NUv^Q@qL#Ps#YSf!`$J;urlA_O=M1+5`_U?&%5$cKUTx`3A{f;*3(Gu=V$egyvd
zN{Dm91n<4zE?mYf*>`z2cZ6@TzVi-5*&_3{ZrzeBakO{!)$5ZtS_@A<f0I>z`nj8|
z67{pM_;fB1EzR~`#L)(--x(Oxb60IH@#$P375%Nw?(f}adtX1lT6VAWesSBr?858C
zueDFVi(Wmw==Za8yXP7ke*a^C`0>Z7U&^BAOMaZ+8~A<8pLcWb`kyb~@csDn=Yi&5
zo>$+SEM#^mNo@B%)!3&V>KxW{uOF*Te=Xnh>&NT+^)fYSC;6}C<nkQOx+!*Ln^)}b
z?{n`6)W1}jX(-~zw%hdP(wj>rt0{HZ?z3Y*GT-~o$IEfs*H5&57OnevwpqM=z1=?D
zX`jz;Kly!EdFkbA*(&$;Mt_;3(!@8R{Qd8>pU*GZZ+G$8r6jjoK2F#D^Yf4WPTg)6
zpI=}4W9s|&x!Z1M*T=gZzf_w#Z~0{BeL45#ns@Ks`}*19yqqexJ;@Tss@82^+AXFN
z`FfF((!G7>^KJ5No_^Ogx|uI$_h)|f^77#KyKhvl-0pax+_!X+ZPoUBCF|QJy<IXp
zd1lkj8EcAJ`<`*joO$z1EA$BK%n2T64!F+j;5H2pHZb<t*|YgdXNt?d`cGb8tD^1d
z@^5}SotN|Z`CTEMxusVkn8n2BI&5LkzWTar6&P%v>oX}ZW#Z|R*SKZOGRrd4=iNJ~
zE4$>~*OblotG?XZ<(ay150lN44DZzE3=GW0=Ft_Wch1nM_+*)HDdm}6dB%j{?Ad!U
zPiCs{G@jVFduGcv^9J`hy{g&ul@1`~={o6ZX~{Vi$*27y&j|7{Utd{uGIdgU)mK}A
zXt4>7InkLpfozjJ%N$vxR~zhl96Ngn;(T=hFGo%G50h{2e)BSQ%C_5y3>?mxtEb0m
ztnO&MyUy#a&hAbH7az2<)Nki*yHo0ul{m59epQfATz*1_@~*3zYn8HnR;8}gbxmeV
zGuk4?bTuRDfWV=pD_o<l7-mH#8=N?G)mUPU&b39GwrpG-b!^7f$ve&&OS?FBONE<+
z8e9pRES0I9W<2HA<W$pR5;M;p3)XNm5sPx2u(8>&FWhKz)(f4d;n}miibI)7Caqhr
zdcw-0rS)fhF1B1XideSQ@{(-AmGY2l1sBhMpZBnt$H!npRlCh|vraiv?HTH8`ot_x
zr7bWpRNG)0*lQYc<G9va&2^?d{6-HYUl(>6ER?tqnJMORjOVb-x@z|YJIz*}c9e~f
z<y2>77nu?>Ve+kAN4H(MvF*mLD>-bJqP!+&nup%HmmBn~e#Vszt33`*%~m+AJzw9^
zHYuvV)HmaNrG=gK8Jz<k=g4jSsAu@>fU(oZu07jqwEL_!E@|e>TGpf58rF4Z@s^U^
z!CAS!jazbglXW7z*Y{7K_(62O?$J#-v(*mV$XT;!YrxXXt=e{F+8b7WT(ZitJL$=~
zORP6t)e|&BZ>sFxw(VB^)!45Yz2e;Y(T0a^Z$0&-G-B48Lpw4;Uh{0}TyZ1Eq;`IP
z?|lLP+4tGcPd+bKFhA$#Gi9B}-KSst2ss;6alHGgw8g0|D`(Z)xpMR6qxY%&+^4_8
ztM+tKuxss#UybojqF=->veqYRa?0PB($eD;k`&b0sUp!eH7V3hH6+PUqJCpy(4nQ1
zoK@O{d^~mBlwC8{I)*J+CL$4#$#jXeHOa(dS*OTFmo0%hjgd@SLj|%{DIDZF$aP?Y
z{#WMT`=74OIbbZrsk14Fqcrr_tMG68&!m6vd2Er~E|c_c|BF=`{!c}M{GWP6u__##
zu;QY|rIo6y1Xrz^Hr3gqC5h<}*P)5^7ef{msPc+TS+gW4W1?n@$}A<7)IgStK^_Mp
zH3k1(Wtkb^we-&kul~nrSE9{0lhTZm)eMdbP7Rv+M`)FOlYQgCphq4Bo|aypRy+)`
z(6Cg95xq32d#T7ehqa+D5?bMpf<GxvYLrxFk~n18lrhc7aLGol&MB=wWE7Xo(8(~_
zP@i!u&Erx^(u@<QC3_;eR;Ku@n%b;%(P){(DQ&4~N=u^x3yzs;91HaB+HbTeY*E&!
zBS%x!e3B(2Hf`B(<Zx(DLQ+KJD#z3=XNk3mkzH3pd%cBL87-8bv_r}vIp|2rD)~us
z3|)Paj<&G=P*|rWqJ5;|wdU3tH;yfh7Yv#HSz~|w_W$*lKm6lK<}vI+VEgs**N+t*
zlPKV`I0mXA4G!P6eL2@E<>Ud|m-meOOcD>+KHifqli03&Z!SdKK1kQ`@t>)N-8`Bf
zju{-j!fEqvQpx1^fBx6M^zO^wUAg)I$GyDUxuH{-W}Mh{>eX6F*N!(Cw|sl+r5yrh
z8RcZ_Z1Pl@DfMdIs#A=UPEK66>dBUfzGJ;hZrt88{Rm&a$?V)`+x9RpxUF0D3XD!M
zFi7ega#oHFJ?3(>vvtvtGLu}jW4(*sTsNP7R=+##^Vz4X9FMLOD9mn=iF(K`wgWq7
zUTpoWH`ng2^(}K;bL%>X#a7U5A-Q1IAwFIIt16S;G<OF$vIsbG2XQE7FKBKMaJtgO
z5j6qCS7_qbJ6pDO&Gr-l$3uL~u^^Kg9JymzWZ17SnY??S%A{(~OXZd7OJ<6%dva3#
z^1YvzeqPx%J!Fwbr_Q_YFIDD8*QhXLMzL!JPwQk5;0sw4<?xPy!9qlQsz$d!X=qL9
z$3Jr~3hmx-^xTtoF;7qHC`FsRo4m+SGii;(l+APY-9P?kZ}`&pZ%-<DOtL%mGib`n
z@KdXP#)qX$NH$cMbXrxRIqQeYnG-A%XEFrqY-(_revpS*q@KxP1_J|&Fr=n$a+tv)
zw0F{J{ewD-f{sRXIVP>y6xGpFUS9NE)oM!I>aacgc+NEToMiIWSt7x}z+kO#j7?rK
z;^+OSHJz&&7&JFIdH$d6+^sT4{%3vv`_BvHFD<RF>`CS^SlKLb%-}FPbacV_V7q-|
za_#j85-jzg;RQX&@WMq2?&S;&RSc{yn%}&pOwkMt;z}|};%Q*)-7>{7C>!iVtzWOF
z9o(6BX_5o)43;hffvkpA3->m#&u0vM!N42vj9p}E2IIEs12(G4z9Ll)Y_l>hWH9>&
zWX@X^8n{^4r%fR#NkW;|d}R>mig^YGp{n{NOQn{4HD8spz{qR?1H-II6P7aYnp8C~
zFmQP~g{*vK>rl6%s;z;6{q?Vw|MOq$_rLr-=5Y1yYxkEgx;?SY8bsK|TVFT0_wMWV
z^RC;KdCEaV&A#$=iF@z9&bzs{dT+7$?!D2^kyL)WeLH+HkEDlCsL_OamD}aHu@VWV
z93TS_yR%*#X1E#Ba}YEd0pbYrZ`%F%am<YaUvJN2U|^6>>&-nYEx}Xlw(VJO4_nQ;
zAD<C&Ql{HYauN*BO5L7iW+3@#_v5q0$;{WmBMrHYuio2SH&b7C=K})+e=l4`Jwl0;
zN#>vZjL+H@#^kIq+LD}_aAjLg+B8$$***e-ZYxkmCD6F8Ys5IX%#N;!P*CdP;8+|Y
z;E<i`lGrGb;3gs1CfSnM8Ui1$*mf~FnbB><#*Gb&Rx_^ZmadoJ(v3RX+uPf5GpmWo
zB&><aBx{3%Th|2#x87XVtt>1VTf=VG+{|5eOU!VYn2DD9y4PtppO;Uy0)@C=kNNJs
z!Hap{z31C`_S)Ia=iUpi*mH0zZ*xMlBiBc5twrlLnJ&pzj^vKwSiCvy=C;*=JqBPb
zaU$ztkHOX1rdjnlS66Nhi_G?&on_c2cFf>#w8UZVWQoLWXSPb5ot<ddW@6Z8WZHG+
zcKEhK1_yc!LzH<q4vTt*DDz}Z%(<|C>XAwxXJOAc@6#(jn7mvVpK^KWl74QLlTj{L
zHmO$m%$Qb{@KGl@Y;DwrUS0{Kr_Cp)ubkArT0dAb)>n1Xmad<!^)2g`Hk9f_%$hN4
zrnkedsHn+W6$ckx($Ush?Hp1m#tVYNA-l5Hi>(i4+T(FC@Jqi+#grqF>Z&zfpIk4j
z`mj^ICFqmu!-|;6m;5{9)m4k!CS5XFt<4iA8DWrd;9@h6&ORUEBPTmkc`oU#zL~LW
z(WXrs5`!OnuySu)k}0KHU+LGqq*9!3;w6JgfBm|z#Ccq-^mp&{7c$|h44Et5{Ly`@
zXr0kyU7Kk_kD`|B6*}LPeapAnvo&VTr1%LxV^t^oj8#^AwNJD)+ecr-ubZv=r1qj$
zYgK;Caz9$|>04ri=9gV|t^P^}7kyXRv8UU0)uzsma{ReE+AQ(jiw|F2Em42WFnq;^
zP^*ctJbcT$YF1A<%(6$bI%TS<TeV;K<*PZjYB|euH|$cKEOaW1^V6=a$r4w)CO>&(
za-m?kn$VF$CI9s18l)V&{PprOp7}=)KDq28Y2P&Qr(TTbX`PuhJ1v@ZHYM%X^9xFy
z=F`pQt)_D7!c~o@4VSJ4R{MDOExGj6y}nyrU0p+b(v^9BOD?_Y7xVM;Tj+T^IXO9S
z?W=9C^B5RxL$+?+cI?xM(3m?Ha?hStkh(qlv|?y+vEz1gvD|I<f-2^52)y#ul)at1
zKX?0-c|p}yEU&+Q`sn#oeRIREzg4>?pWsjH%3L+|T%}RVUf!V7PByyADpz%tc?^Ah
zeFdBAr=}X5nzhE)M5tt1ud?RCW}#p6_}R9d&RIJ(YVDIli3Ss9o}B0N<eZ}U+Hhgc
zmP1Lxx!KpQUb~(3=Cpa#<>tmP9%hfNA@jxASuXho$;60@h8}%stES$1wELsQ-uctG
zKdknjymXc6n;p}psV;r0?oeCGz0y>Da!33;p{LwOr)Ack7Ci0hpD=5>xNEnV$ctA|
zCX1(>O0{|_EA*|}X8DvaR!hG6i#$AK>Fpa->!*0&@KsATo@JeHvrg<<Q94=i$f=jg
zkwH7MUw-+aucPm_cV0*K%Qfr^!{)1dt1f<76crb+V_}xhirP|jEjeDlSrad7%ANS+
zCN#%i^Hjo>Q<IyXhSWbbk(yf=u2gM1FZja2SY_8ovu1`#hObI|^+dv`$N5mv+(bU!
zioG+HFJ7B<XkOD=Tfb@3`ct2BpK3H!TUgq9nY9=cS6g#FB^u1|@XdN1dS`}@ny>(f
z;Oy`YyLWAAZqS426D_@FF4gN7D>j<Pw$e}4GATkXD(dRi($Hu1YSDomYm(BYM7(V~
zoVY1h_o8do3ceF7Q*>2LE=Zk<oc3$g_50B^Nhd<xOr#|?F~8inapQ_r*BDe1idrYT
zY!|u}oaDBx>zdg%(>2ja3SQo&(XS_SwjAVK>y&6P!^bH*>&>>^Ik&Eza&x?{C-QW8
z=knG{qt{U@Q&LWC*b$>VZGV01$;o^>Q!ih+eB@IWAJ3+O9iFG-4?Q{A9<%A?tIS80
zrmP32`H6G-Ke{wg`;63_(%9p%$FobbA7!3=a*6fUS>4sSGiI4>y_y>O_4oa0f9mx9
zcnT|d%wG3oqLE7f-L1cJ&1QRDTBfEZWs*4MRI1U8#5O56k1G*tRx`V<Ty!*PW1Y_X
zn2$52t%{TTsrod^<U|DbU%8*G57#!Vj0{<;t*Is-e}3(@YrAu|X8-=Lk~IBeAhXXj
zW)`u@hwqC`zo*H}H@)r!vow?bo5_yi!qcOVvrb}kn|?8aRe1XOH>^taZ`ZH=scg0N
z+MiiEZ{w#g*mWzvCpp)gZ+G;PqVKxXPABe+*_j?%^Tj3Ub-C+p|G9a0diQVryFR7b
zK6TU0oNdy}H~XjU-o1SN(!G~2U(ah^Fe!PN72nIv+tynzpL_Vc|NU*R|Ca5#ylk%V
z%(Fq^`<H8PywyGZ+`41Oj-8#Js{P~h<ob<z7iN7o+ZOk7vt5bXo@0iKCALq~iCD2Q
zeV3A<;Cf}d?f0whr{-*n=6&+1_O0#j^Xlb(@8rt;t*4iZ&nrGtd1ueN)#vNJ{W8|s
zy57Izn6lV!lZcIr&hK{=l=>`jtS4FGVo$Qzr=#7XVmc8U1Cx$++g=px=;(2A$v$y@
z-|xI{^~%-NrTb2c>4Zc?>rOjdF;D&8<@<X+m6yDG_`KBcLb>nU^<`E`o~x~w-7b+8
z^PF8G%U*IV`%dn~l-ZZ}>b{TLwsqO8%%1w9ntz7Bf4mR2J-+Yz)}<dsKl;zf*S`1m
zY4zPbU7xnk-Tu0vWBrz;F6&pFT5`4HGSk#B9!<fOMy75{>!TJcMMU|`NI9%F&DYx?
zL|fGLYg@?Lg4k5C4H21(mg{*vowVu9CGA-y7c8?x#DkPxt!~jORC?tTa#-_n%N*}@
zqKl`znzQT3DMO=WY9Uu*w3p86(woM$D@pv?8h0kWl^J5CTF;hjwVCB78CYrM?ys9r
znP3w!<z;J(fE;Vc2mX2uj|WR$`8e}9Hfz0n@WJWB^yyp|SEW9EG)HY$(pp1zwV27j
zdF7Tqxz;f=Ra`B^hF4!JWRB)k-h$<kK03DZ`c?KwwS22CZM??xH7Vp}Yk_`fU|d(n
z7xt|#(z#Qw?%&puu}63B=Cgu}K5YAT_L$!6Gu!suc5nCEcxmI(WRp|J*3@T4T-vzS
zXk*WkLQ}199v?}iOy9P{iCfJi;!eMOb3Lv_Kew{VKR@%yN1K>QKT_X5IqB20(=xpA
zLv_%aO-nu+Rq$(>b#5^$%5e1)HEGY?b~{I3_06yB^-g=YzO_4ZDzG+n)0wIM7J(n8
z9}SVy=%`_Qx2o||L&y4!OiEirq*n3P2Td^ba=5ZG<cO#bH`9Rw2b+ba99e4MkkD{o
zgO0|b9v&VM-4Jev#SV)@W-U!HkO*-T73^AJ7|O=jkSfR<C~!c6`S+9QpZ~qh4qKCT
zqhYdf+L_G)Vv#x9BDWmj>|g-hmk6G^LnhQ1IGGY=faX6LCe*VCu^cq;ULAG6J2yA}
z@;~w9^B>E9{{J)c{KoHhKc(;7_|AOq_9Z{;ceB<P1k?vCv0ve%C}J?lFeqqafPqkg
z7$Xm>foK?$AE%Q=pw|%%wM9x<8iA`ERy%q1YD_U$<aK~oODR4p)a$~Oj{S0~Li!(@
zR{s>#TK}YJ<)5a1jt?s8y@C%kd=P)=-ta+ddDn{dEIar_1&@YEumy7b@jtC7rn5BR
z=v0G-12aA97MeP)xH8M+s&GiA&x+G(k%lH-lQLFL2)cA6V&$Y+DjO3Mg;pI@Nm%|O
zv}tCT*F{qv&V`eC3?ro6n%S0|%*fhmDmu}WXM<Kxq^6n=TLjxoWlx@n2=}Iytqy-y
zJo1@hn3xd3^k>DRlqE@r4jj<@!L@p8?y9TdkN#Z!`LA}*`s(cy<AU$hiwH0{?4Rx+
zaQRc{Bee%}<Tq_(=a)Qi=G*i`A6YF7e;<ES_xFCC&+{9<-~BYcbK|@8z1x>+nCEAH
zzx&nruI=}|%c^Jlm)!eyZ{_d#$?tc6e=>d9M^^Rv&)??nFTX$8`mNpXeZKE*RWJL#
z?aO@5`v_g%&E~z_`*v@z?dAK`x6*f2zpwUz2|e}RclrJ9C-+{y-}@@R?DAbubp2~8
zeyhHG@z%-dnd#Z8Cu4tAzrXZ8=#u&DZMSkapVmIWbb-ly_O{#GEKHwSSeUP^-*z*1
z+sn6Gcl*A*eVm=0ZO^eir@pUCHCk4+x9qFYZrix8(_YTo_wC-wdFvx>-`>vm`gZND
z@i`9ZYq$4qyPdmrckZ^^KA)SLo8yw3o2zc;PP?7=?bh98l?M+VTyLnbzUo=9R{HAe
z`N7(ouU9^uwz#t9!>1SbVxNA9VqKDN&cesXQ7?ThI(K_DXk@j3L9Btn?Q_}fvfE|H
z_8eyix#l=KJAZ!lz4r|cEDYu6-dWzgv+E4lx+JrR)V7G!ZIUUe)z^(?2HVE%u9_J;
zZ++G2lJoJ^`61`S_pV>5zg6Va`O4Qd!P>Sp({H_;XKNEyeLlK2^~0vtZDF$&Q@J&w
z>r*o~i3K3|gt=j%Q>W%m-JLTPq#dDLxo1!6guC0kkA+U1rnB~T%4%(`Q>V6_0*S;K
zoyfbb8tHUO=xgq#&?!0#bEhsl`FF|7%X?qz*YAmRx~=Uy@vzm*E9aJZ9h-7f&vAqI
zY}K=qo=CH9YMr9HsYBq{)Lw1hjT`lRCq22TS1_Ap=cbsOdY5x@w+BNsT})hbxa^kh
z9_}mp0ehWpYjkUL=PYt~Fu{tQUE<QlrJ38zZryY`C3e$AUOZIz0sHYcXVcDGZ;qT@
zfBO83`p<Iz{r>I0Y79z~PtF%7-^s7e_k5}HEoH7%>7?@N;xiL;RT`KWWEmJ5Rv(@k
z7Tf^g3o&qT?Xe6^wQjngYrTWPfkA+Qc?W}|1B+;QyVjaj-Nn=O-u1=w2udg!xFmEO
z6l_vvapSyOUiR+YyPXnB27a%1@8D2)pwL|3(8S00dg5fkCS^uJL4hQNMFxUw<*|3m
z*>$!>=SS;KJDsY~P_$~*sx<<I+?wnRn{MWAQs&>cZ-07;>-Tl*t9fGH`8^43ohGO|
z%Rln2RpuU5ozRYVFYoL;{qf)Z55HFDZ>^pF_Sch%DsH*Yzf|_yudn;Ja?Wr0+WTtN
zv*jLFAFn@k{nq;1QP=*~OHMUQJL6((wCv1gLDp%Zy3=wE1tc24$0)#v*({t19zrY!
z7!`bkL8po`E)ei-N|?Ut_WG4UOPCm1PEA!1V9{I}w9-L=qoF~$?#Sey*6XKUuijOz
zw_4CcCv=*3(9N9fo=FcjZ%;FqxcOoEqW$%?*}Rdti&@fAeP<gsiA9EN%QkG{N$3rY
zPhGpZ{{82~^Y`9wzZ4XsD7CiF{%lC5c7jvM)M-j)TSHt!LtI1S9(&H7=3I1QQ`ob+
zYucVpxU)%T>dx)idUwU77ag6t%k1Tv>3Na7r<G1d&o0}`d-}qiz2Zyra&Mi03)bJ>
zVcopLy7#h4TwC|Ws<7T=w>*R#Cb3MowB>2roQ<iOr`P-XTKZasZFzQi>!i1*6?djY
zY8U5Si`}JT?%J(gA}jy1i|eG(taDajDJu-3mi=L1Xjpvv!x0AthRO#F49bkzj~y6a
zFxbtGn$i=b;IgViSz2+z5v@k!v{Sb;ST-=!GcYhP)+Rb^Dp;{#^33i?g#^V_Od$;H
z_m#pg2QV-&ykn>pWnf?wzOibl6fc{@1?}UjraCJann-1+ny*^wzG9Z4gs+59)siJz
zye146I9I9)O<*u#&{UZc6ns*CRoe2!o-cp@FNv;aN$h*E?MY()wZEu?G4-$^8Qr&6
zt1qse$UpsDab#}qoQY@WT#HUlS1C?6op$5h*X`AsOkT@^SZ3$FT@4$WQCXF$;JNMH
z)oYQ?x}Y(d<k{hF63?z)Y?BnO$+&he<HmvHS>OQ|<E!`OKubJ!7aw3?V15i4nSn0<
zsF%68cIV<`#@>A91_rr|TRRuKp^Vws#y+3*>=^qx(69_6c!<Wpw(NNW0|Q%cgYN3M
zt8HODIctnIoVvJj>Z}u6kynNwkHJWQWf)jDhD0cIad0fUA|U9xLP4o(K|}r4wSsLd
zu(22w$8Ko}E>qXu9#*kipyeZ1#mo#uvOt1nD>g3bS{t04oSd}Tkx@$9kx|MtLP6Oz
z1A?7;x8-i#62u=i;WXQnYu9c^-@VxOy?j+k;@-Qj=1Sz3S1oswzI$&aSg>^K-n%ag
zzVWWek!GvE5-rgA&_Kj;X`0tr-jr<CwOk!<Zf?u%Oba_^aOlP{iD-$#xm^(_eT@v;
z434dw0Umr=+mqP3vBzMWVViWu5vf(Vpg|aeV=JeH#$7wuD3P=RG_1su*zKg4yCm(_
z{k6NcR?S+PvXP(PGW5aaWmEP~xx8`}e=z5&NRN{V_1X^(E1mCI^(AV{VKI%X85d4Z
zbDtJ3woqPYpDyFkRS~{k_6wq1UK%xCN&>-Cre41cPHb8AS!+u~u;K!vwO*fQ@hofB
zTyScpx=z2&K3%T8AzNB&S5_^35FsYKDt@Xy(-W<)7XDg`KIjKud1%M^Gw9D8^-vu(
zVXrNlPNpthRe#~)go_Iov&FYgnzuT1sR`TGkf%SQ`m{{8Y%vM>)4uRfm4uJlr1j#e
zhbr~@gj=qL?DwAZV|vTUihcc|{w#+=K6Eenv|m%dtNBx+ugO=#;E7qTAI0jF&Ub8n
zq^o$c$^T^dm8VjnU#--fU)G5xtxauxDtaozRL=2KVMh3q8U9D>W7gaGIxFn!3%?aq
zrL*cvT}Yq4=9Hrg{ZI9~pE2d>wCf8$_0!<w%6P5RkeCUj5`FrbKf+a)1=<GuxUl4k
z@r$Q*^R=^X{1q(E-85I}u+ou(YU@w7`3Tl74~@#Q3OqVhN2gu?(bLn)V($94r|a~@
zA3gEuv`$a_fhm7OPj_0TcGv44J$g_wwOi|NOboZq##Ei2)nZ;rN0PjruIP!>*w@p&
zT<P$VxLI@kmJ0?SR{HWJqDbG@Z+Y+vp*J}>IXSud0k76EFfd<Rnzil5y-2RLXHP5d
zE;=zOy0|jMG<x<l_p+xGRo~`TZQpjq;ia#m^|sq}Z?`YC)%<v6((}h}zI311SMR54
z`QxXhcx(8{1zS#O&-wD*OZiE{rmJ2*Hq4qFm}qo5DCuZRN@1kWhM5wPsex8Y7jv$-
znvoIT`r=E{#>g;*xXYligi7NJGf%eM+ZyAeCd}D#FgN>F-;}<M(_>OEJWy*BI21K$
zzPR&3Q_lr`daFtt9{q^t=019~`%6r`{?+;w`xA`*=&kljKX}F9ioqv6(fC-_6Pxt?
zmiix`SnBlUvdPQF%Uts_dZq_2x^m^xbnhjXPFVW71+Q~n60bkK`{);om7nGXFP`uy
zGFAOy37@k2rP9!aOHR~AMS4$^O*&B&X|-r`kj$FjcIP+R9Ici5Su2wLG25f2;q-@H
zCPw@E+Un(+UNxQA==|xW-x6Diof&=+6F<xo77bqVv1pdWhLu<SG%bBYyVr>xw2Rjl
zzi=v?bJC|78>0;4x!sS8T)1S&?|G@TOQyH7W~2JWYf%UGDXsRO@~|!Z;0t|M*OVyk
z8FNj&z!8-bbzV);U<P~uhO+?_Qa#sh*Sp3EJ58Rld{s<iT5G|V=V9Vg6Z9s$x?-w*
z#+b9<TW(t5hMCF2Cbu@-2?+@aIh^t|Xq|@Usbw0QuDESv+w_mAZuQ%o&AA*$CmN=B
z)|r8Tp*QIK<&}mqt7dEz7re=xp}S(X>(;GnWBo5r2F2A@&Xz;TrrWY}n@Xp=+EBmh
z!i>I>SK7<wEt|LU<(#W6sYyo;9z9ZY{lkup8Ly|s?9<s37d7$3X>oBORIw>LC6gXK
z)%+v5*>>$V^W4L`^U8BiJ*<f=tW5B{b!OYzZHJC57ysA&TTCa)S8cNAVz*vNpJl<C
z(;`z_4w_8!);h5%YOR>Js`AQTn`cf;nXVUjX{*VFNT=6DVw-cP>GbI8+&2HV!gGah
z{pv5%6`h&<Cks3f7Yl@)b_JqA3qzEYloXCkW_+N|?EUNU^u0G(8>Vk~!^+8+G+plv
zYhZnT*zfzBC2w7i{uZ%$Ykj>-Y_9n+!yc=<>t1cW_G4qx(XO)XVehWid~tCpwJc4G
z+-G*}-}mqPgkRM?1r4y6>racfE|0yw>Fcg9C0bufA6|I5YnIi#?|W?TSik=Mef`Jm
zH9J#Jm%WL)`gK;9#_i0d($dn>qT5bp9SvL?TxZx_TfZjq=S9$12rp<DL`-ANcNZ6z
z>@(@le&5@E>1fWjXzA0ZKfnBW*Lp`?xqrFeyE&_;m*-aB`x^Id_5AqwnbRV^{Z5uR
zru$`M($Q|aUrI`*&kTDcju|$)byp@G?G}ju`9NEA-iwY7B_$=p^@j7SUzcy}ef##>
zFOZa&PW|cBO*ii8i$A~oc~^PCpLg@#%_+I-%lG=c&8PKT{WdR3u2y_L*Y3Pd;N6~&
z0W05rd;5BO-rZ@DsWbm;{+MZ$l(haQ1IzzTrzQ2RE4p=bwu(3|%?etY66NdcxFS`w
zb79-mwyAB)q?Tngg@tl|ojR50!Olf9n@(L;D0wyAM=k1_R=w46oxsxqnk5Tjy&g@7
z)$((lXp&`FsCi=7qqQ>2gPvX!bLI|8Op4H(^5~k&axs^pODq2=Gd&3`(q%fgH0F}8
zzmHyz(5Hu%Ro9fS2|jHsI<!uReFFC(+mO&hQ(pQwySb($?X0qK+0%VpG~>#quMZ2N
zp0=h=ve@)s|DKFrax)jzd;4;|N?3hq!$(&=t)$R7i=KH4Yd`%`vHIc)|LNBw`Zg^6
zbRcF!Owg}|+7FfNLRUY{TATg@Jh`9q*(IY_Y`10iq1(4DqRY;i6kaJ=XJ~R+byc#k
zPs*kX;UO2Ar%t-GWkr^5+u_6wH*!t&SN)0CE&b40n|=MzuOEB%#Kma+sqfjhXRGJL
z>EeP<>b!n3E?ZJHYu?f--3hlYmZs*0ZoQownY+4yVV=DD%{f1rAKUrwy5=f=cg<#@
zS(EBK<EIAkAK<8CvS(%b%fM7$AR4lJh1af@)eaL9RHPQTu40MmTrs1^ZLzY_s+3S4
z6&@9yprg8;rYc90j2Kgxu5v~#)b=!q@;YSDqv9r{9O_{j(#(?3%h1Nq#**Ov@1^(e
z|JTmk44SRX<T-QGvPcP`)4Ef=wUwFNSf(G~VHT}tN?@3v#tFJ2lYx`LQNc%;*=kDt
zUM2gR_Lovlc6R=ERjGGWmA|02qRUxJu&Ya3Ftou<RDvtQBhg_)!<|V}wOxZG1(mWw
zgjp6whJ=``63I|l&C-;$Dol{IKFXtqfouQDAo)|Pyw*Pn^{Q9Zf6^cLB-Edi`KbQ0
zNfrGH;`OV9_No^22`R5yBBAWGYJX{vF!$FauA?1BhDkFPN(c+dFY$HBG+EZOMRTdq
zG_T}fU*BM^mRYQeCT3-=T(DJGY1y)6Oj9FPxUKTP(9@Zc6yc+`$kf-@<WgpsaKMS9
zMzeG_CP{R2oEBBtaEdGGKr+K=mMhv~I$BE&y4K&C+?ZLf+AXG;u;TAZizug!Nk<YU
z{1xGzq{{r8^PeZj|Bd$NSN^M?l^(ou%BceWs=2SAtV-*XbLPyLF^Boy@~W9vUZon%
zVZP`0DP3JnO`YNU%6rR7t!DbFGkl-CXXeS1ot;<t{Cs8_8d?M+)Ienp*gmO$uU1r)
zlvKdq@?rk_fBPTL{kMPJ@AtcR@80onzShr>Z8yNH!!6PeGO=*np5btJ+wI(KcR}QK
z<8>??0t#;ByUSKQZ#&y`%F^A&IAZ&xv&n5|cjeq-ut=YJ?Fs|qVY|>zD|0u3r;H2E
zPp#<?P|izaF1ww(?RI(D?cAO9a~&F)SaRNHPCfIs>}{&d;(3Av?^S0V=bc@0bMjh{
zZMXCCzA~|J2$+L3RWmR&Ffgaxo_Pgi_nkv593b<USa?AOp3dF&cH7;J42%s7<~%>c
zPwfl+q@26y!|B8NJbR2j+$rC3>ch<qk?tDL+p@(zMXo8hx!reG{jtCkmvi+3Pg%<O
z%-x*%R@&rt*6dt$o?CpHTNn!cr{-NK^j+|1wgbD!&#<@bA~=L6vhz%2kTHH5bfdY=
zqq)taflu<&${feTX3br>3^Kt_qqoQexyTr~Fch4h>Yc<V9U^14g5lx3@aTa0f|CLT
zCj~&^q}ySU2C|L0t7dgsbJtaN-c^uLlrdXjksH8x*k;|f1rN769?ojulYCmbm7RAL
zpL7UA!FlbqE5JGzvpt&Ucs&EmUH~$s{NvsC)q85x<>h(det0$OcvrTZ=9-FS8;{zA
zRn(_<o#*)(-gV0I;XG{{<D=<qHLH)N$~3~9p0{#)$j3;q+|xL1jpuD%=Xs{ilYAPq
zsjmX0^=syn`C1<%kJ%VUeDqB|YT7Sy&0@)#4<{oZ&I{Gncz!tZdfVmoyvyUH{TiT7
zmk##@xf>h;TTAM1?Mh!Q6MVH#^V9k;!v>3G7Ycp%y?gh(_WQo``+ncA4^sK7F#k|}
z$hoc8)@?1>z3$!KxU2)B3=BDZvl$rfb_pBE+zw+{!N8mlz`*t<U}nQR1_tXL49p1(
z(hPhL7`Pc2)&$IKn7MQ20x5w9ihN9HM0Q^4?QF1EHgxo)JofJHjSE2vC1=i@*`i?K
z#MENJ$ibJLox5A0;aOT*+H)ly7dK@VH}(<*4d=$|v1PkHy^hUZ8x^*9>(=T&o6SO&
zoj5QlEobF4H<nGOQ-e;OI54phyuw2hw8BG$vngSM3MT`TgMf!H%R%+W#%ZS<8H9Y!
z&NfhBicH;fGr@t4WBSqytZMa~rP<M+9~-BgHgw=LHp{uB!I(Pjbn21-HVwvAoJ_tf
zjS8L%Kts>I0UkmbDx6FvLJSNHA**iPug={X|K})c%1qzX!vE%P1T@+I|ND;}{3~W=
zVE)Yffw7@FkHIc96f_dR5D>s1!o^w7{P02by$}ZGnx`il7<d_287?p|C+v1Tv!j_^
zX3t}hzd>~?|G!$r`2W{Rur3Dqf2%-;iGZ^@g5Wi|xXRUi<*x;{%2yZ|co~=-pmHft
z8boDoSsHS(gO}M&*>PFhjNTQA3>g>eTT*zOg&mGCJFB%hoG|Ed^EKgRFiJU+VRAuI
z%8-{q<!eyDRAUc@|Dil>ZEg)0*cuolnjM%G7f3QLxRAkcftRu60>gzPDGV8m%N#E7
zH83zRc3j})nPnfsEVqKEfmtBM#Dw9(#R(w$L1QBe7#LC*Jv}-DH!5qs^)kC!&*s3m
z*nzD9w7-Uzfq~80!9<GTLfwiK21(E+83yM5B`Yg*6QulShl>mH%`RoqTG6;jF!YFT
z?vcd4)0^kUB<^}{b-Vh1+SQv9iP6)w3vXY0bzL@9!E@W2XID=gmc3SCxpv*VvkOm8
zJ?ZkS@Mg>h>sgPJnOD#5YhYmDTRqpRzTnlf#|zjS7e^N^PG+1t_1tma!i|kr&mMPR
zU|`<f7dmBkWnOkn-tO(iOSf&Cnmt=v+SfbnG-&0=#lUPa4vs}lOd6{e+|F^6hyt(j
z*mmV+)Pjc2jS7`g%hrl4y>D^rc5Lz7aFLsV*CwqhjR;vT)t#I5SRye;F{>xBMLVp1
zb(YjdwrkgJ-4>G8-F7$I$>7+^(B5rRwPuHg3g)U^Oq+7sgk{^L;ILI5>#p57aU@&f
ztY2zj%fgMhJg1@qx8zRF&0Q_HA<B1h5L<HE*5qJ=6*=1$g=DPMR@)RPt=e>R>Z~)t
z({5MnSad8_QsBWsp4$>Lf(*MQbdusCg5J*DeY;-5&?nKKjjP~@U)YM6oHJQVF7FFo
zb;{33`|X>@TK;M(Z?0xt*^%iiseD>{)s;O@V`o?x`ecc7^CbEC8r&<j_DP($IO+<Y
z;kC-tr(JV1<$S_<)NZFGvrntcm}45XMR?iSp7z8QyVeHAtjRjICd<UesNCdm=)Gk|
zvzAS{a`h~Cy;RqmE60|Z8b-z%UaLsuo4Qip^lH(r;I6D)>%Ct3DZF?Z>u43cc=6Qo
zK%48+wH|Ga+A<@xS;r(hGCS(Xc^<xHGcuz!k3Kl{(8u6fXvMCbv5`?*wHJ3!z4Y|d
z(=6|kM{kx!mXwz)_qwp$(_+`2bEmRCB|MNZbvhfkd71lSo{JaiugbA~kv?#@H}K#}
zey=@zYO4=C&Dt&Vv3FL?v>Qd;ZOg)4EebZpX@_?_UiW2-zwq>~l^0h|edv04vBV~S
zk(c+jY+3oJ=w(^r%9~SzTlBQ~WaWh0qPkb?KD2DwN6X50RXplxR+nCw9QO7qDR>aZ
zCbfFj%``qSiGqRxn{^VY>VEZ_Tjq!!^OlJD^4xI7^LfRRFAuNXIIs1X<fP47X|6Ne
zr=<lJ&YaS6J5%fNa<0e5HWm*hXSPq52{ty`I4v<PD&X0|SxYNs6gT^6UbcALAnRlG
z;PRB0a|%zY7V|AVdU#c6bjDqs#^}Obk?f%*uT)hJwieGm@4WE7hUN3a3tp6;@~f|W
zd+@^UQ@P%AUQP|Y+jhmTH)^JCWa^4zCTn)gIIX!RXKBpps7+h4T_3!9b#k)WioVU!
zxtr33nU~zn-Qk^kZM$yP&RI`SH;Qf8BC+(r)02^5Di2T1>9i;-OJ3Y&GsmVPCzp5S
zmTe)olPWi9JzL!?qg_#ywY|9Ivanw}>*J<^#QN)+aaA&+*KVGPxw2j;YDd8_qd78b
z4E-b{o-=n^zhAs~_mr}dq6dY(Q!6ZkTh|?DU1REZ^}x<q>%wGQw@mJRe7xzk-tB!C
z?wMtC@g2?Q^O^P0VpfSdqrt(72M=OR&&ZtEy>2yE(JqT@Nq4QHpobIt3g&3<`(?c)
zX3Z|c$&uDl_3w(7t_=&lT2LHVaM$|8+p`<4iN?0(-I<lW^TJ%-P_58)x<|vM*1R;}
zOrBaibM0pCRVVyZUix{gZ9REyPHa^06n8aUzpYzVZCw{yx^~uOcgwa%K?gk^%nHt0
zJ2mHv=96__H=W(~<>;XqJwAp$hFyt0mIvEKB`4)+XU$o)VA8fJ^{eM>GrO1*wlLRS
zXzgst#$<tGf}l=eFi&W*P%<-*#74m$tz@BPYB~|Y63jfJX19&S1UIgA$hoySKzGrS
z+o4g)ky=;Jxo~>sh32yhGfZ1(c3t$W*=lEv=Q5(lUhZm-ELan{=*WW|96UOL$G#NK
zJZC(2yWbXzw1OC>X=0qV^{kiYzyyOH&TLqEV8fIzk<+81XBQQ`-SL`hx`|n`t2%4r
z%a2=Kmozd7g-p3B8anlwnBO|R_4*qOHX3f?6w#eJBiY*7J2*NyW81UujEC=dSXwp|
zFJ1{c2zc}E!>2C_xg7fT<JX`63;}C+L}XNSOl(|yLShn=o+&5SFMh%^(<IBy%jeFL
zH5*S>cFtV6^W@E!pO<TBWc14|USiiYZPvU+%T}%1v~AbEL&r{?yL9c=y+_Ypz5Dd-
z*MDYqZhm2LX?bOJZGB^NYkOyRZ~x%%==kLH?EK>L>iXvP?*7TsXY$*-`-ew334q(V
zpwSd01{;`vV>)9BlYTwRrqeo`PV1RZ6c<X;a1wM9=n^=3=8$H`voynCgRV4z4%RD8
z4Gj)@8^l7yY{Xo|qqv@NuVdwl_gEJ+<>uzJGiOc(P1zQix>`H5IatRiE9+{1+_S@>
z*M+CubnEzME>dhCcrLbhdbwq7xn=Epy}ZLy&oK7d{r#HtI<Y4$JNK*7|1aHNqPkZ9
zJa>|J>QCvZ51L?i$$`d41O)|IlBQ2|W>RJ9=>u(Ik?B1LI#@wTNvRlexWQtHJ3Ew=
zSzKIP++sj0RG6iw>rLKhEmHsC_Kn!rdw2f^f$F>e4#wOQH+#D4*`p+((!@aL)PPlo
zJVKP#3VH}9g()S~#7ixb?J#!h5MUM;&|M<r#d4-WEGcs4Bm-tSqmrI8SHCSgGgHY?
z$b=`5<>@4c(=2Y$x4!LNpMCh&`Rr@0uP&!NGh6b*Bqx09@%F863qIKXZ?1pv+^_U#
zdG*Zd`SO$3=6JNY2rLoeWK4Z=!gXn>fYv2WRi-qDU2oso&QZO&d&c&xbMM@CC9`pt
zY)skodZK`9>D}Asw#OFTT`eN8t3x!CWm2QD0;{GA%cPb`jVcW5bY`SX@>CEoj-4Sf
zPbY*mG?YOjV3peIeZOC?+x7DDx^3@&)HA9I-4{`Hessau<EHL{8#;%aX07yHGjYqc
zsXRwkwO!)$WlVJ7G005F%nJ6|a&6XSlVc~QMg`WmIqnRe<#yFLPlb1_<Ib3?+nyeZ
z_A~W#Jj3O#)ZNrPA!O-+7^!Zfou~SQ=S<sCRCp%g*kVbanAN?D!X@;K+>cy(GT~9i
z+M_Y`7fr9t$(s~*ZE0S()!i6rb{`MEM46SIS5;#fN|sEliQKqluA-G>Sdve|^SqUQ
zo!3>@8n0_-d!}}>aE{-tw^p}2XDvLovLt(@Mxl?`lfJ~$-F?4H^=9w%I<mdyz%!BE
zNfRs^50;C%mul=@BzvGWM|bDu=9uLRGj@sH%{_H#T~__ojH@%&NoYL|Gg4i;;q>m~
z)pJ++eUF{{t@QG8p%3SNUD<TbVwa8H3u7m%bmyhg76&~ZEo(Q6js0=w&ARU;ADhB^
zqE&-6K1}ag5vSqwfxThLyoO1gH5WWxHmr~c;Z^C%R0(DkZ0b04=&)PE7S=`Gu3{@a
zR|O>|rb@brNCaeg)o)de(&`m;^HyyzU|Z?BDlltB)GDz>QXN?WTR9?FLo1@TZ>~M8
zlyG9kq*K0Yu0099+fnuQeEHp<`_Ij)`1tsE^Y*;ow>Lhp?{C^`KgE^p>!cO7sfIy8
zk*+R>7AbRd9MIShBH^OV>2c80z_nCCc~;jHt4Axu6}`NkbGhtvTH#k;uw?2<l~u*9
z8tc3Q^a|Jo1Lo{+ov+EoaHTD5p5^CDa^1^be2|DZ@Sxx@55s{72_^%U1Oo{kul|NC
zHiI?pJ706HSY;QmLY`-m=7(0n58V%C9b#R@Lp80$4=rBkcvUslHSkgl!&5K4P^T--
z0gFD(OAAX{nx+wKw6JG&n9&T5dV^(3pH`Y2o!YsycQvo?l&mdldd{55>Jrv66*$YI
zwm6hk;$Wsqut<n6^Vwj9(_yPaGj)u0Hl(h0i|R>A?cvorx<N7Jl<G`fL*1!MSqz&F
zx+HY;t2{LHkT{r_5F+PQaKt5<n@4Ek6HRrEkfkqb_E$gsvv1eyb#tv==PzHf^iln9
z#|=5gFHJvv`q@)vYx!mNH_KbcS6_YpdV6f?)yvEMrXSF~{dNcF$U})^hP`+1-o3la
z(}_c&MP*ZfXlMv4m#E7H#%*^GLByu0Oi^g!aPo8laTf{sHLO~-0F>bx#2H*-?}9~J
zR8SPP)I<4hIvkA*?Yw)0JXwU;-WezO9NWTjChc9Z#68jC8OO}E=NvQNaZfaR>9+FU
zt3vCao?3d~gN#7Gd{=8XgNV1+B&V~RE(EP)n54Dhlv<!usAzbb!~`Z)=88F;hedQE
z7#2l^OcKkT)}*>9$Xz$h?ZhM1Ih!{ybY=#5)JJYQz`((!y3|wEQ`J*3?RMs-i_I=u
z0+hW3PX|u%S=6#ht2fX?YI3lt$I4Kz&PKs0to;dF;#LV>y`-)mcdzEp{P^X2Dhr>V
zpKs@PclZ0e<BcCDM*RBNSvAl4Ap;Xb@&W-)Fr~qu)xf}@Az|3p*pZRqX)?9qB=fWL
z8|KuDzWJ8>=3BLGTy6VwxtgD!pS-=j@7tTQtB*``EBaGCCU{I#)im<F8eM!~0+WNv
zQU%9TyH;!GKKx@|lyYFE!Dh+q=-iyC58nI^e0;@*_5OvoGw<)I>7V#%@7v9GN3Wmx
zRn`0YM_o_xjl6#r_ao$<U#ktiVq?pD@%`N2&vzsre|^5be8$5!yAA)y*L*+klfQP}
z#}{Qa$#?Admp=SBZ}S7Wm!D&P*rr)OK0onA<(K!HpX_r#Q+Tf6@${3)$LuUWo?Dk`
zw)%ueXROQm@_o`BlRQ->xihfvHZU}9c{0gkNrMuDLJov~Km{hbfq_8)BD`E>lB-HR
zBMV4n)PDKXg+Jfzu3I(f?tA<C=SOzNtp5Gq9&}Cs1LyI6Ih%@)hjX_*+;+R*cJ7Yc
zZFkIW=Sk;omo!Q_IdKQ$w%Y~Fx!WGF-OfG0yX|&^bnbQrv)g$LIUp-NPc^93-`aVA
zfq~&^%=2}xmfbA@cQ@r#&()v*TlKE~BGbEfZya{--YuZ_?%fgY-McqJ1SWZ^bXhC`
z8KLp$n&$uaKmT4>amiC<v8T$UUX@8+CX+lhkhrGSi~cX<a1v+%9T0g|Wn~a_dq+(j
z8y7=%)BOMMvG@M}r#v?>V6Zo^XOLhDw`1Vi*}%Z>c;WX`JDJ)q-ZNP;7b~m(Th(jC
zV3a5^i%nT==Koi#+?>BMB^juxop9#06?RY-c1SXkaF8;&%#?A^<RHUkCWZ?xll;F1
z|GyfNbJhNTs3`BNhUpun8O6D!T7&QJ4O;nY!QX)CflZ7O^~|Q4o(q?Oh8GzZTmXj(
zFPMZAT@x3uHDoSakYU7d0o0+tV8oEYz#t{XHj_b$;R2Wq?uZA41ZAl72VXJy8@RkT
z*gxR%6%&Rdm)&ME3p>85YPi)Oz{|`qV<wwoOUjW$Y@i8!X9tr*%=O9=m(E=mIV^F^
za3NPho|30pz%fG(CxHu!j2aAP47?3YUWXinm8VMAytBSA^+;%7c(7xxr_wD^%?;a>
znzL@{PFk27k}Gm+;#T2Q<*b!4n{uU{GtH*m>A0}+oYrHdGtWcjr26ILxE)LjcpSPR
zmv^1iI-Q$*y)qdxxhv+V&dI7T-nLxl(p}cT=-dmcnigW)#133{Tr9cj){Skxt5Y|e
z4NEl(-IOD_{A{aDXy8@Oot##x7gU2wb_B$-EXa0c516tx)9W>3n2u=nnpo=-->zEx
z&RVoDt$(WX!Q55ncibyK{ld8N=T@HS)8=wo$1L*t+;QP#?|ijqFT5IsgEX^dXV!1I
zG;8jc6BY65MWu6|ot>R?bL-}`+h&PPESwxp0tOBo5}-j>69E$eD-MOGkZr}@Q&pa_
zdGS1%=&3t%$t2H{%5ygx8d**}E>n2a>{(iu=FT?-r>E;lPB_kOxu8w*%OQ;iQ?=Bx
zH(Q>0mX>Zjd6%HqTM4hAtT4u)tkqi=M5xqX(B(7;<_vkO8Z5ShtH5jJkyUe8jw~o!
z$}F~n^MF8sKp|(R*Sn|MVmn$MaP1I{UAuLIXu@id&=sp!tx{>;eW_J&Nt0*8)P|`I
zAv0J#SFH`r5Nk|W#+5Kbt>wZjp$yN?P(!U{Q-i%$HZ(J`aTqu@tY!@3+7Q~MbyPG<
z>q_YL`XBS2eX7}~u_)YADBLrFYjTrj%&S!)a}<?BgO)s2;u8|ur1030xn))0g2rPk
zlN-Ed2>F>X6=+RdAlw`3@z6DD)x^X5&##<VZjw6t^mCsJI&b1xB`5Zz^(>aqIMd_M
z$tvMwm^oSG>dnF{hsrJ}ty*_NXpe5FmfsofO(Jhv-W;kg=Co|}dZOazH1X!DC8d5V
zjs`{?@H%wFW8!t271PS2U;lG>*le@UPT5_#_TJ~pQ^`BHcfY#<K7|-^M47-0Q{{#3
zHn-!IVhYQb%fu-b9=&{A?0UuPwB+KmTeogKcwFq-b?vq6!CD{rC%w-+UVXIS>7mE-
z#C2jm&v|Y<xBhsD-n>oi;;}Jzn%7R-V(sR6uJW_H$GHy&EEpvi7+5&i4(YBv`(%!c
zr{(05(z5c3%Bt#`T8%&d8N%4O_=H4jc1C1Ww7*#Alaj;3Q_kxu66mV@=!tx#kj+Ys
zl@>dGx>^<)trk1&eWuuQ&&!!Bce1WlSGn%DYR#(EVyE>J_14sXxwQH8vK!|&#vDs(
ztmS4i5eW$~DVeh8U#qFDyW8@mmtU1u-K|=+yL<NP-KTFq{{BP4BBEl(jvGHEEj^4r
z8y9c>Vp6i@t7+-hZ)RoNzMGeCzwn{pW8tTw&((YX^LM}t5g3C>2>}#9g43t^F{#$G
z1cDqcW@RDUb<^14S>vpKXHCwWH8p)|cIJa$^}GMC%x>rXp3l6l<eT};AIyhjWgD+l
zC~v$mxAEeoJpU~gbCcy`@;S}fa~>Rj@a_3cS&84meRqzlhrFK8-q&~V4&R;Ue=Ofw
zvq>>|bh)Id>O8At<#2TT(4z3;P{@}BUzT{)yDXZrV3wh#kg6{4uf28W%Maa-%&hr0
zKmQn8Sm?k1^Iw2Z7idugmF>_vjNt);3<GlmLjeOH1LLLBI-8m&F)*HFV0hBNP~^a1
zslXsJfq~CM?)%>N)%U*dQN0x?e`N}E$dyH9k$sR#+Y{K3Cj&z^gWRtk#UFqE&9pQ&
zHda?lOG|lj=FFKnGiT16JlXi(_suikSKs?qZ2P|Y-nksF1$F=D-~LqOsWN$zr^=j3
xo+?i!d8(^S^0ZW$<attMl3&0@`-{;2prD|jXQtY$|J^&4=4g1-Z+&u?0RZvzNJ#(y

delta 344814
zcmaDhQEEY(gq%}UhNYonq*`#~iKdCx4C{BqH!ujqR995=vB<DmO_Xb`Z_Mq<FiLg~
zQ{A@dYyf-q;f6<Xw-!yAuu9eG8ozaNnVf(Ui+tsTcV{NKNUi)gZ~4lQWmirxWbiUD
zFlxRC@>*n)(ZJ@wz#z1IZ>W+&0|NsuvvMZOyp^h=9+#bc)MiNsoZ#hY&{SEn($@cq
z@|7=+6Bm4yWEOVN%JTGDz#zrApq_!j{{5f+SM~G1iYz+lq^z(|u<2G%H!DX^Q;VA;
zn7{n<q-kx7z`R~nT^_xo8XE#SPH4C!Y?}hrF#*iaT(WfGiiLs`0y-XhdOI<c-4O_%
z%J{T;dDe@>V6GV<hf}}beSL4OE68MbDX-|G4;JlN!B;O`p7mnY{jzm!q6W8jhdXo4
z2syM&T7TdBxUaP@P?Yj(-`*YWT4}p|Yn8xC-dRQxOS4TCxhC9Ptk@N{Y2B+QH8$^K
z*YoogyRFN3)*Ey2@Z8s1A3i*narLas#nrPc7l)e^yRFN7^?u&hTb~cufrS^@Sg6(K
zs*A2#^)%VgV%62;vr;=3&oV7`=PO@#y}cc(2W;9|sh!JL@2kF^eV*Yb$f(u_{d}CW
zJ&$Is+QWGBp~ID*-`8EA$M_jy_hpu|OCD_v4SiU_y!lXL<2i(lt7p~5e!jOmu7YuK
zxJiKkul>pTU)MfIto^(0YS`bvz(rjh3nQ+CxlV0c(VFU_5wIq!Tj|uTE=3L9HMd>5
zI#zUbT$Ps2xYgCWCD-jru50g>q^_o;$w^(!Sz2ZqE6f&WnJqeYRFq9)g-+-;vx{9?
z+)^DESD9q>N-cI>u{a<{fJH)qL&J<WIiqXUVKa@iW5<q0)Tb?4Eh-X{lM~wQIy=eL
zCB)SwJ11ksqD5D7LS4C%W-Qaz2z1))b}`rO=vJ{sS2C_HPIg-XHdJg;ud5@2TMye&
z*KJqS&Mw)n)^;h{Icsu8&Q7T{P8q$MvS%%x;I=b&ous#5lCw#7?ur|?jvejNI(Bre
zNVMCrW5-rqbUPqjpX_$yqDT&7Z|}BS-C<@do3ny*mqtZK^Q;ju+PGrv%*d6^VT)RQ
zBW~xexSDh*Yr*XZQ?7$kxNeJRtjTp-+dCy-;gqx69o@17SKVp3D4nt{RHk=p%ql&<
zcMw~91I3W+yt*ZD1KW*@+e}=g8IqH>W@>6(t?%uacGl;n+tkcd!)OtctfSIV+EK?e
zR+uK|M)_`y*f2XM>z0W`*P#t-H#&74yE-F_t7}Vi*yP+_H*T1jnc1GcGwo84%9bga
zZbJ8(&zDrs_A*$rWX~-xKkG)-B}?+ddbq*q-R;xC#z+@GmFB{C&)qldJteYsL)h&w
zRhMno>b=#37Da@eI-F&srIMtjqH$|muHZJ)wNeXi>AEety2&xJQ{rT9r`hdLv&BYD
zK5H}ra;DwdCX_hojOXlpFLBHAP_v_)=VIRMo;uU(*wL)4D@GySx!b%tjk%7U%F0>W
zsHW?*>6Y)7o@uJv&g#z8)$yF=oYKlWb?VH>8Pg6qEla6iy{@?QQtx)lojbQ^MklMf
zG^ebXz;#tRr+1Rim0;7*oE4|JBq!z0)RdO1zE{59CUvfhU+3ASl98VIZs?xNX{icW
z(YtXam+xlJrK=pKi5zxy>2Y;w)iPV9yG81lspA%@uE^$0$ti2DO12nFO%Y0IO|JLO
zjpmfxvRUXh`?8&<UT1>5G9_r{mKD<^rV8CSnlx+E=3L!vLYI<7v^Cbw_Au0)Q9Ng-
zWzi#-q+?nqf<jk0P38#=712(cc1A^_bG2dG(pjprjW%nWXzE5i(_JjJCFz#o+MZ}P
z)4=YGqb^w+!`9Ap4!a$2b;H8dA`-V<*GkuCY&&*KH*i~5Z*EUk$kCOX-87Dd8Lqj|
zlyh`r*R9^gnVXZ2u9i+!T5;=2l;);my<w&kZcAqdi!D1VaXZ+FbF-9Tm|>RE;>^v-
zVN-g$BX0F}<!s!xL?`R$irXg>SvE`)@Rkzrop7NkXG+JcGm9=}zdYh3xR94apu<g3
z`bf@0iFzj!1%=*C0xii-9Bv7RW+bgUmFDqqY3!sJLmh)}Uv5r}lM2t$boSun>@?|^
z7|x@2Xk*U_KS}l6u7HA>r@p)i*Yn+MqnNm=nCqBy(3-<Wdcq|d!4_rj%X7B|dfoP&
zmc@NIC~>+`IM0mO@IK|(UAaeI&v|%k)uL^;i&hsb(sim|AavVw;TGQ|I!C<|4OhfI
z__*!(D$VG$y>_4XZaqEMy0koPx7fRNmvW2wGOw3hFL?UVcf~TbgrBL>(zjR5{dmeJ
zwO9D6_f$!v<N5kmSJ%l|+*uYHDY#+_1Fw?OyQ|ywt9q!Zc<$%i&B`URRb-3boY`E9
zrbXvi%$}CwTy!&B)2}|^&dswcZ+r>0*Sg<wG-p;&wxF5WG?z_Eih{ywVbi9sOO^Cl
zxV9(%(6M{Db!N?_x;s^hCLJqRmU+h0_wMOowwt%NUhFjX+j^|D@8Yv|v6Kt4+s$&G
zs*CfUdgk2lH1l@8l0kfPU2t6PcC%SC7qRAS*45S3HM&u?<TKap*FlS?)wetgzaBF=
zH-K}^l#tt*ZJTnpP0n4tdg)Q0o<5e{Q$<Ck!+N(}*t$DIZ&TFK;;^eHdY>sB6;$JX
zwf!OcYSFIKImJ3kXHGjD)PDECYTb2TwaG!ADwE8+EmJl{s=aEv@yB=8wXk531sU6d
z`+Hu=T$#)3^=4Y)wtLY+23L!wyxq98zGrflZ+7^mZOR!P2kkBHPs;hSXv*!--0j>(
zI$WMEkvT^uuJWC7)8yrej)|v>E@tLkI~VP_Dfe=cR_VIyybeoRbJZnpt3^(@vS^A<
zNZHaan_pZFxwh?V(p#Tf0n^?@`>sq^*?4)O?wog4H+Am5o_*R}c`3iY(&sytt21LZ
zP4hkL_*mKIb=t)<tJY3RTbb6LoU?7GCSUI66@|x-iRJtf>y=P{E*%}ScB|^Pj<lND
zQ}5hZ_ENcOaS2zhR`PY3gJ)LtFWwx<nZ#7Tw)f|PFHbHN-JN$tlHDjeO>K4Cx+R%m
zXH5hnb=PuTI+*3`vZmL>J9DD$npG)g7i^pFBv;+u^?Jw4ZDGq!r%cLSbDQ(Yg(+KH
z_v<WjGu;q&A?r!R#l_jvwoG_!oOLQ?vrIta(Um)k43=!Wu~@@Aqwsj_*6YDRsfJ>&
zQ?|{P*)3BacIBqyrW>1=JlFNeJXe&<9d_ld{1i7Ufg4lL`kn46TQYafk;k+Abc<(B
znv<a$wsW<*<&HlF{0n_Hp0=y_d|aSQ<h0D@^KuoB1l$cHCrM5^6ZG^<<>T{G?(=Lu
z7t2f%XmJ$WA-LnhS%HT}dFh&S9#&43Ns#klm$3BNaj4HHbV~i9jS?*<mt`&z@-+6`
zq_|y8#$$Hogd}G--$lGCZ4)`ps!f*Y*_ak`ESc+K&}yx=OP-rOCQR}<@+wo})Xa%9
zqGo!V&CZ#vaEVh;<)(6uS$1fyq*1iXu}-6j$|@-{&U$NVheauD2}-Vcd-Z7Mb-s0H
z9e3R+o4eyq*rjPZCP%BCt6y$vz{a+W;n=FLMw^n7=bTw3&ANqEw{3#iLd8ha)T#YB
zH*>DN@||{R3DXjW>?>2X8=`Z!Rxq%3pR+AlzwYDf)iL`Dv}UO{FhuNmtXf+x8KreJ
zgpoDa)5xo&V%nrH!HZ4H)o$OdejvbTHtppxLBHIt&ADDbC2f*cd^5YcS#xUrR?%%Y
zLVnLR{C?-@#&XN>mEWzBe$Uya_gvdf`*7FtEz3@XW%(RPw7EUwQS!ZgA8I;z7s}fe
zPtH&BHoJ6oj?cb1PPuB=7i~|TRQc9l<@V_`)!F8jA@8C}9$Rd;yj}aQ{LV+ttuubA
zIr*wxIV*bi<15eSmc_z6=Sqq`74$0kJTb4=jQI9)#j;ha*ZckWz3$=LN&FMMjm{P4
z`Cidcyko6ik$C!MnNwC~&XnhAmuK~L-rlya*w%Jk+gY(QlM=RRx6eHFZCYWmd*_k4
z@A$6WoxR>BU6@-wGAMVYQs1I&Km2Z&b)DTA+8b1@yC^p}?W*sJ8I37jt1g9caC#eR
z%}h2;SX$4vG?{CYi`b@XK^IhwT&_1T$UJABb9cq|<+f$7?;hA#+?;Yp=}~#n(Q~U*
z?#x~qcHHs2dGfToNkucy9{aqxQs(iKnJRq>;=84nW>&6QHAOD2!ZU8^wzWHRxbJ2+
zrB2%w)$zc(<I_#;(<xhfDjurv9f+9r#Lrl}w#ZQ7^UOPQ+Un!p&i0G>o?W4t@i{f`
zsqw<M-0k_5@2l_a-tl>r%(0|fGi~O%zIQ#`-*~B~Cv{cvqqNn1Cb!P@WNlsS=J&2I
zHeB!Y%reiT9kaTUgRO3Bq^lgAS*$rNRjPN&oojZQ*{)%_6Rc)^?mg-qIa$!<#zvQ|
z{h{+XA8u(nzEZSfyV*ULdOzLSIY#TVcNMebUS3_C8D99jYVYdsrB<#}CzhG{uGsB!
zO6v0Qx#h*CxA%N(Uv@pVa!YRRQ_Y>Pm*<?Ev!$%aHtm+z^@z)9myTVVyL?SruXWyX
z)0FDCJs+PdZ~J;WYptPpvgy`juP?rrTyxuPnwp-KtkTTZKB;)p=6Sz)*(LA#6^zR!
zX)4{2Y}}~8I73>9X_2X5m}J|L1`ysTEx4*(uxxAIZ7<(cmZDr8nOP|-CvqEiOPcnS
zw&#{CPRdw1=~h~}Nji77(X!0Ug%K9J!p(eTj`rQ&^L^9RYrEq%m{#x3J+wmP8r#*d
zTt>x-l1rm^o_X)R=a9xNjoT5vbCv3YC%n75qqOi!Z1K9!X)E5$i+FHO&GJN^c6g*;
z=Bl|dPnsuAIwSMEG}I)hGd;>Xay!rSIdXf?UGoik8yb0g$JN)@PUdd7th#d5=8(v?
z)HGu;-(1hFv3qzJauPL;8Hg@0TV~>x*(<WdROn>VMag9*K@&DzlGIVVk{l?tu{Th9
zYQ5^F=rG;Yvt4}_PVDj3Ea7R?Wa$Z-7Q1cr*0OEoD#y+)D3{hSR}Fi?H)Cyc?!wF4
zQdgVhO<k9CB|P!g+)Y{ACfy3V6zsO`vB_;!mC&h*+6y-(&Ry-z>A88aY^u}>vy)OG
z5hvHJOSrgtyOHnIZ3(MQOw1;4S}ZX;Xx1g)70g~K^^vP|wpeqPbzEB!m9=h-S21(e
zjowA36V9rxoEVj<Y|?cmEY;_vv4&mK@<YE;C&x$TGUf`f2F&7-GSEA+^>T!1m&vRv
zIm=G2Qr0$Ym0YzZw@l%LX%^S*Ra@^QyImE^y(sLWGE>D<NVwx+$El;!gQt7V^;wsc
zHp@EY;2|Y*CztwLlbm-<>dC!(+-c>S9O3fZ=-goLl{%53b32n}My?3c7CCh@!c?ql
zMOVj_EVHhTqrHK`YK}reOQkgZ4lWH`RP=0>PfK*}evvKP3ZLBFv+$5#-tBM(hAdOA
zsSFz#Oq;VpRzx%~W|$V~<eruCx)mJdx3gr+rQK6^J)7aZIXUfA{T#m?MKhB8V$>zG
zF7KRUbz+;Pq07uZx7(}yA|^+jS#!$b+}*x74)-~aWP}b1J`VdhXY%H=nLE$xeKJwK
zd-0r5#OvKEZttzlZFe4BV|LP9y(IQ}$kv<Nd|hYzrmV?c7-hC#(hAMBDsJbVXPlh5
z=**?y<!&;Eb$E6@whj2~y)~${K6jVL)omwlH@w_5b=$Uw$1SEjJGXn~gU=<)Tklw&
z%ATBZ@wlM%?3uSMixzKo=1JOEsHY`!ins7;_|^WJe6M41(S}PhW%Ht~ZtJa+-nFA#
zc89l@x%O<U*DY+5-A)G0RLyc>NI9*Vsa>-5BI9IjpS--x>oE$NCOOlB)xwrIq@1e1
zq`<5en)I&l;+e^--ptI1_FLUITXb{SsVj!(wrN}LJe4*%vr9WQX=~DKpU1T|=_=1H
z4}Dh+Oy2fA?#J($yXCEylx96UvyIm`H`r*m#@+2fbCRY-O`EN(+|y!X^JBho{^Yd6
zq-YhfGb<-u%bDe2Ix{;eZOe%cm&1KOD+T6VVexw_?Vq$eaBJSX*xjYuBUf%KpS!L4
z;rI1BPbz-QdLMJG>gl9~H+(1aa2_ps9{b;a^80`H**91JJMTXGbd_!R`&Vb$B4={1
zdv5ja{mXw#CV5V-7g3lzL4>28fk7(g;Ic^!k-=h-3PPUCCe1dP<S@xo<yP+Ov`bTX
z&2lbzs&J}I@-@r3<Q1SYQDu@x%L$jIi<Fd<Oj0rzifnO-IK%wx4bzmRDw90UoVjWg
zacxUhcF6TDv72&k`fS-UbLP@nXBT+~=WdKzKf_O3Ow4VIlh3x<zSC}L2F>VkbJ4x1
z<S|X^MmDdIT8q=s(7;VRZBA0Wyc`#z1-4BR(^|D^eqEa}`^$Z24*XYt?Kydps2ii;
zWFJx2$r+-894-<~%7TLW4<|1aGn;H6#yNSn7$@_c9>>Xv8KO*`Ws^UODoe&R3%DdH
zDe*W8c64+YvbZTJDI5`$=m5*M>YwO1;u0Ml9bKHAUHRwV3r`IvPbVQSfk^=^lUh`!
zD5@;vRONsRhVP&Lk%dVv_|L9Cf4)!IHlc-!@pdkh{_*?vo!PlpmTKN$-n;csw1*Qb
z!`p4AAoTm{>dCpgrYyB)DBt@&zbJQm(3Ir~eBbxJedoLFRn^zmwW0ebU#yZb?u(17
zg~~5%u)g<w`%bglE4_j@uvg#v_Fe6Esis#M!~5!c_fEgx_q*!r>ubMO*G+bek>c*x
z2Z0*rd*7!_o+u$Yd7cCZGUmRWz4U$6>viix^Jh#hjFDoq*|TTQp0|_lTg%sjnS1u^
zeN=r<1=GtS6IvAFi#~n&v|e97w^NbB0Tw0|clMP1+?W60zWLeDHTMnoCD$DL+55Q$
z!ZknpS^Amznfw`B>-o>wH!oa$f6si2?CS3mzsKB;`}=nKxnuYKK7M*&lJDN%^~X;)
zs!Xl^-qHQ^q{`On@7uV3?-ug@zGl;eo}~RzSEMxM+odP|d_J!{l2;_O_S})5-?zV7
zu;7wl;ELNGJCi=RUE5mS8+rQBlUcI&KCOB2#r5fn?=Ag_?;iZV{YociYkuwOSv`yj
zY)uZU4<An5ucFA|B=B@k$<uSYW0Qk<=TB7<t^c$BX~k7_*?qf?Et9qj=?MR{e=3hc
zB8TFI=MDQd-3q_9;+E#0o4OOVZ*BeU4h1f;f+emO#i2ZR2v@YPcz@P@<F%7-${f1s
zYkpJwQncnve*fCtlb`W@zrOF6_orvk*2_0Ni?&|5?6=LySLYPLvh|bR2mJi_bx(rv
z`6a)67kyaJ{psk7?yuRA?C0;t->?3<zgBC%y!=F$ACsS6-Lv@T&$Ih09YgQUkM{XI
zSxkOk`?0nQ`<M9N@^aUyeY-3>=HI!eY}#*??Nj4Rs$4_nP0rlqeSh!1MaNEu?0eA9
zv^h&BXRFth$MUs)OIIy_8X6jEGqXN(-NyC)ho3Hg{Bcq0@#_)SmxI|o%F`FJ6mAZG
z@JIfLz5C&ZAAZy@Kagkm!478H$@8}#uw(qd-;niB|D1hn$lQeZO_o!Yrj>AialLd&
z>xP5=<(<adoOe1C>rT)1ye517&CV@z6Ynzpm6#Z6B2mb&-|v}u&c2e^Yy0bS_Z(rc
zca>Csc-*kA@_C=<VwEqYXJX&mST9KwWcxk0^YgRcZ_Cf`uhS6Z(lp^{73g@{&62P|
zDeBr9@9a?D*si>{yMEQw)v-T&_M-GiX=~RHl^FTzTG!rbD{BwRu~v88<vM0|YI-?~
zb$|bgCEbjFR;^mK{K@v%<Y4p9o?fd~)vwxfSJ>>S-o+&cK5cfnteJLk$${SM*V0VS
ze)g=pZ>JpNJI8Iu->1ubwyRaBMdnO8SINMj$l<`iB+#-TeR^Jk^{(7J_Euwa1KGP~
z+nEo|+7Vzgy?HlxzF$v5TyP<Sy3U!ZkL9{=w=K`z*19LlyJ$wJ?)T|WLjwhEKR$jm
zWvOPpSI`uVfQ4Q`Q<iEvwQ_NK1r^VnJ#%Jb_U@UpqPJapP!SXIVOd(rB~RUWiDRp$
ze%9sAeP5Z`FQ@3d^|-}jYjwY^7h@jxyg7M!NlFU$IS1K04%X3~v1c4uj~EMYm^S^D
zk-%^5w_Mx)hURV!yW$@U$`sx?6Bp`EYW+Sn{Ap;e|F+vXn@;OY^Sk$e_nqJFJy|6T
z4ELVA-hFJj0|W0nznOO!_ny37-n)BOR`ewXhJr;>##L7X_$&o3&c3#>Cy~Rc@aBwz
zTUst%^L?GWHH6uE%H%>>S$Bs1xO--=_cAb8RDJunJ@y3y<KgQI?=T*|zP)$%uH5Un
zFBurb1ALF=N3CMKyF%@;`PyWOLjo=DZq7J!EKRr!*(~e&ts%^o0p^isS1ph{)wt_i
zE?DWgV#6Lq&fVGSX1DXC8oZCKUiEdm=>yJ+tEF+<p6y}Oms+`l!E4sKZEN@HPCxcN
zi9Ks=X}{RV8;!SC$0i@$Q>KuXz#hGJP1HLPiJKMMZU^l>^=?LJ^wGUr--VYPT6ItN
z?fRl^tJd7yFe5U%USeDH(QUWN6(oupw!Ymy*TLW^WA^QQs|JA<HJJw0CCbmwq~8p!
zzf~@O!1~F1MOP7ve^U7uZlxF%J}}~benKa=y<bqoy2aY|(1-NtJC<uKsP=ui<yK)?
z$}xu9x!ZP{#pGxnJw0_|p>^rZ*=e_%L?#I=*$86IXqDD+n&c!>KS^N8gjSUnZO<f-
z-0nNGX3yFEZhQ2(;yF`e7i`=n;qa=fG`!Dr*X`6bQ<iFa1x;zyn9#~8s^B5S(g-FD
ze1ur`U);7jDEOO$tNgvFnKRpFN^H1vCQF!SRzhl&VoFw+QP*je%}Q%-MM-uhbFFgY
zII6Omck0Y#Gqa2`>MyP~jg-<|HS4zI(yo(j+R7TaYQD2(C7H~K+APqep{b~LA=_xS
z(3!Q$L8k>*`*vrX2--Szrby=|qm4;oYoxfYZQVArCF@95>dcjmtGV4Yr!7m|Vm9s4
zja6Z%dJctd)VkGc6m-@&=fqjHY}IY5It#a~=~=kN=``oE;7p&}p~hzQtI{?)i)}WU
zs-~oE9F=VRrL$$@s&yGTW+iiG6wKJNjdhvprp-lxIj&nyon5inQ*Dx^lzW7?kabQG
zpI~~<w$rI|WI86PT*?%(R*qIoi}vx^z0G>6<(;>aVi!)zGTE46++KS1?$)EFLZ!w!
zzS&{N#E#uoTN5oB(dkusyU04FMQ7T}>u$U!SNg`LZA_LaXF0Q~=ZI{}?oi3ID=(y3
zo26U2s0%1J>9M-xf4G%1*+fCHzIe6Q%JU`bt+vm3b@QBbVX^DRpa^ZZMT=cG24$?t
z>eyzOmMztFOlMl}f@$0C>Uu_NE;@E8V{y>dXfA`Cs4IbPW|wB&^iIw?y5)4JQEpP=
zVu{^q!C}Xa9ldm<OmvlR*raP|mtAgjnw_~4I&+nI+3VcR3Nr$33dc;D5TPB`sr5|n
zY|;(2&AE4XUGhpUGkYC)qj#&|wNtt0L`v@Fsmq?4+LfEKVcV9it<i2*t}Hjrn9QVT
zP=7Tz*I=c2Y+ljYLu=1&XPPE?B;o1q9ZQ8$r<$%@J8OwqT9l;c?p?RD9=5BU(Rw^5
zrtfxN$u^s3;r;<Tlk{fXG?l!#`rg~EnU7{pOOu+m?u~TPR?+Nf+HP&zZmxWpdpjs3
zEjMtRZ|~xA&m+rHp2=o~FV@_+HJa6&U+vlLP|s+-`kp&eXI<QOLr6P&*P_=M+iprM
zd!}<|lFqS<dzKVj$w`^AIrmiWHk0ZluQn>4Pn_q{cKd9m*rts>GZjrdm-uWKc%1d_
zR)hJntHq_qLs!l&doPweE7bDQvo)J}QjQv}>)Uo~>f-3!SEZ&FtG7klSPJD%O7jp>
z^Gp--Uio%g)y$%k_3oJ&MQOLaIfd`A8dROPdT#Qn_@44jq0AW<)ulS$EKxVQ8Lgc1
zCf`!Yc2%xWl*r->9X6bDOsnGCFD>Ns4QN@$8gyW3#8i<aS7i~Eqgp+JO@^vG4!x{_
z3%v|nn{+vvofHmCY*c<LUuO3<{&HCAtn#|p&((FYbDmeFG|XaoS3mFawc8J@4;9(i
z*iE^wyM5cGBqz`0{dVuqSKU2mHtTjdi(yC7l%<9Td8f&)+jV>O>aF3iiqg=AYA;e7
zwZJJ`cLJp4I`w0y|Jwuh37+9Ml$zg&nz9Ndq$=`yEjX}>N3~_a2F65@9*sk*lvz3c
z{99!h)cng%MOA+OpM73V;=lela(usjWTIyUr+o2*Nt2)7`^)9&fBfwwmHA#?TKpTd
z&i;BiIab-Weu`<N(b+B0(oz$y>57I$Z1(0j6YLd~lam&-A!n7wS-}m>f~x!{MAoK;
zT|2vK?Zj<IBBo7F*(fY@i#ykA>$c4*X`K;D7Z&+9*l|u#O%^q5Oq>{Tq$e?0B3WRC
ziLt;*PF{&-Uv7yRNj{yS2_ZlDR<(JiZ0j}_o6H-P)H`){Sp7AVNjH-=d+K<lTs0HR
z5=$~!6U@0vS~o52RHVw0L=zzw#SSx-lWAv6JGW-B%@X1??37w^Rn$1hCn0Lqk~4={
zB|CJEdTXYbn(As!-5lk!<=D1hL2qHV8CPc{M`wp@nX&1_tP@I6IzBDOQo};M+!lGy
zO!J(aGD~+-W*SSU+1dKV9uZfCjx7xMq52{4qsPP0Wudc_b){WqCR{VSk{cBkk+y19
z!eV8oldF9Nr%9%+a>^9Dlyft8tx%@h8Mme^(=?rE#c7H{K9@Z^MT68XY*;l@*+gj8
zsW5}wKuKX=U6aeYo*R2kY+bfBM9k>GwSZ$eZlOt2-Gbz<9l0f%n<ME{pSvPyw&)VB
zgDY3uG&Nb(lbo!Ybu41jtr=m<v~$9e9eH>btU2m)NHW!Pnt=DApuVd?H(j;`C9cq&
z6d{=q;nJHlJ9iVuwTatq2Ws_;u*`3&{aO2?PVW1|_tp1>&(xgnQHthK7kxZ^*B*V@
zwbyRzrYzldJ9o90*Vag}madLf9joe32s1P}Oi&TXU7Nev?6&d8rJ?G-JM33~ul>LH
z<G-r<qkq^L>h&J~3ivnW@lVtB&n?eY^<AE++a|}ih*i$w+UwkDn?Q{ouON{{P9iEH
zt{@1lvkq(x3ibReIYW5g_dVZZtG_VbFG#WZ9{-sod};+p^yg>$=RCK5SwBhN%J2E|
zE#Dqj+0A{QwMXWIq{tiFyN=;I!>5K;Fjf0U=RKJ1yX`h3Pm;t^O`ihi)R|=$-j?kS
zExjbT3DS+>xQXcMO=nTt#Nj&$-0|C^J?H7Ey88+5xNqKOFNiyL!@BAFKl|_d-#*^m
z_wMh{GwQE13mAgRzkpr!_+p%>gJS;qS^u5qJg+r!eeQYZOO;mn)^%U`t8-+k8%``w
zeE0g)0<8}#RxsKwU%S1)J$u{jycfv=M>V~YoA@qyB}?b#?s&IN$jNgukEdk)38$Qe
zDk?3C%nu&-slWZk$Mo%T!UOeOGd`yBPYUd^mwul~RN2lTf4Euk`L6xbr&c@?`}sNk
z!E?*|J`*c1mD{X7b@JZz+q-i&6ux6tn%ly(UhC7M<ud-6uXFDRXKvhfdzZu!L$9D2
z585tA=kadacBj1bl7I}@*DVSbiYg21q5a(gC&5jEn_84pIXtxwt)9GIp6{w(mG$@6
z`>U3gy}i9PJTH6BbN%ht-+r$8zWQ{H-G2S&Z$5pmzyE&u?Uz6QzW(?0|9qd%n{U4R
zrN7x`&tKc8`|9o=fBfp_U;e{yeQ)P(yPdn0<p6`i1QpH(1_lNuhv~m#?|7cwwsqUB
z`pZlnEE6~_8*VeI9LSl$^Y)O#1Qkvu5YfQk2yW3p2p<MvmPY+IEAKkm@7#5}K<uUI
zwlnNz1un{WN=`0dV32&UfB_5`XMiaP!G333Ka1|Q+ne;+CU2BHX7X5Fqi|kuli2Ir
zt*gBqLCvT7rQt`aK2;-ZWngmPS~1h_#RsFaxw~yoNxlgy+?+4@F782BJJ03l+-+u?
zS9%29+gtVZ^_~98bLF5c0d+3Zid9Oh)GRt&9$w4NJuWKC<0iW~^G=9}l19O6(`~22
zu9a$X1x;D9IwU&cm}{UY#FzD)ObHA#R5<JZ9A!<J>6@CZy3d1ivt%6ugG1ok2T2MH
z3?dI07z7*L|F*sixa!rw(-fa5!OgWKZEfr3oSdKl>C}kM#hxj>kw#I6g3Y%3?3TE_
zRyO3dW^C%DW2der9lH{-?J7r@WA3u8-LI`hHZ`2smH`eL=0obUlsQGZ>TlS!^0_o5
zIW;gav<uH?`f;1tH!;cSR9jZ=YFEt#*6aBg%C}ANP~qY<`K;pJpLIy^K>lWxNxUKd
z{X_n0t(0VIo1tpUHEXJ8%Yh74|Eg7*uNtJ13?^SyS+wE+1FOoEsq8Bs`MWJ<_4QN@
zNvd*Vxqqx)<z)JY)zgLkS)Z@?KCQl9X7Py=8ZL#?dRTInF7#B@<?__b2=erH`sngd
zPGgM($4zgikM6y!Ts=)K?vfb?+)hP_ObWWNWYV-&l_^{F-Fo;d-Mx3Zd*9kwXguv?
zY2Uo8mq8LChx5zU&E9)@a$b4KYiqgK<mnMluUX3NEPNlT@v=HxPp#;t-p1pzcI7J8
zxB8fU&w9E0&dxQ@%l$TQe0t5Yv@bS!n)KSdX|6)9LMKzUZHf?d*%Ya*85MN-c<kL$
zb;hfAzOTDJkNJAg<!8Nd;I%X#zuvtbR3IB<Ho5C+=tAvGi?yLqLfa;<w_#ts2dwtm
zuBl6PO%qiVltsf>dO=HRGLNV(KP$DT{vv3F&g0j+*DX03+NccEiDFFG)zIbMoSp}4
zpsRkq?%wslO=}IOwCB-A<xHimU8^8zziRjSs&{e)407A6*DZM<mn>yk>>s^*-I51Z
zyXSqq^*y}!-tP7}3``6RjIZ9?zTQ!JfPtU6UTSfG#8s)@0EWP&CJfRJjBZmdFyyp3
zD4Y=TTyiC6+G3FqF<;k37c*|ET*@-@4(!t6R$Fv2V@t@ii(OiRI>AzIi&_J9!i+98
zwJv4l;#?guYs<!2vw4EOA}1%E6bZ@p+_>UOmd-NYZk52mwQ9!}2d=oO6BxKv?bvG7
zj;m_NuGQ~ZdEIXZ1BhTw1+SENSM)sf&Z0@doPjz<A)Xti3f<<=)LOAkTg))oajmyd
zn&PapinGp!=IXAD^g5-wVX~yoA>WqS=9Z^hp5FG0*;yJhX~t9`iK#+ox2%|E=$y4`
z)tZwzM;a#ZY?WMO9JDzt;7n+A(6$zyi;=6Ea#r1}4`Ry<%h-{flDM{aQBPo3$kCO-
zB1t`gT^WvMDMz;?Et_bTa_q*ji(77r=|pS<lba@rCI>5-x-Oc{D`k?g?66y}NaMDy
zhE=**hHE9RX54lS>(1D=;wX2D?xITWKYS7i2YESC6fU$VTwKi2qS(<S;MQaIStwIb
zQ912$Wc}<=m8HxcXEuc;tkMihYkD}v;z(pW&u%V}?zCysZbnNNY*1`pAMAVO=GnsR
z#PGJz*J)L)p`Kf|Zc9?A@X2vXQ#8)6?$V6BcG1RE$7D+4io}L$ujRa+ZF5fS$dt&6
zJGo&;&qA9kx7se&=G<EnmCH1x+jqg0TU*zst=gC0_S>+2tx0F9&uOERo|C35?Okx@
z+xqMBy|>HN?yS6<dsxa;=IY(U%hvu{yY2iD*)TKtY0LO$Z<!suZ?4d%Io>Yc*Una%
zk}RBY%fxKkeumtb)%gN0+oo($P*qV-RZ&ryFk#XZ6_p7+GkRw9OxADLvMg3u7qj)m
zx7?YLZl@00O<5{=?dFd9ZMSoG>wb>foqN|T_Kxb;(p@aG4HQ<aSg}o2a;e{~=ee%M
zvsayXv{h~ouU5#}75p6+XIV#Qd761>v8uQ&nYMN9hwGP8cukh2oG~_5Iq7pWt6-6C
z&aB(fQ>1f6ZXLaxd*R)y;7!}YHlI$ry?)i|cImIt6~4<ZwA{)S6wLi(&YfG|_S4|6
zguLJ;pX1Ap=q|0yol;(?_-sXT$iB3+8+UVmt=*%Xq0o}6C@{P7I5(f4$0V~8J%KB_
zA8V~&yK!^kvCx{eafg?!+`TPr&b#HwCYDq8mV8+>#b|@az1eH$rO$aYYx3N!+XJ?_
z-VDw-Zc(E(tNXE+#8orj)vt3!YBJwFl@6|-HQB)My5+pvK{l5pyHi&DG6{O$y{dG@
zHE|v3oZL-uM{QTlNZs^!=dC_dK6T#0%Brho-lo3M&N<tzOih}(WUX!X1&u2cwkCNk
zx~8&9;k0?@<<#BFnX__cn;3<>TC+Vh=0>u{o88k*F1#`F-rO!+vUb*?Z8seims%@V
zw_doibxQr^(#x}S%A>CCP<ng2CFQJG%FeU7eNj8N7UzEZsee@OPP4)@-l&J+k)Det
zC$p~BS#l|5($a}40k;l+>E&9{1;tx)f8Ff6dn_+-;?lJ4fHfD*PMHOZW|^GbbUHfr
zMz65Ojblf1RXxR&wh9Ugb1${X^vj;Eysh{2oTYB{rbRclnH{@Y$LQ#itTt^)m$#~e
z1_!U^Bu~u=0RoCyE|Yw>-9C9LZ)4v^WuFO`+-52+={52W+w?*uh*PA=_0-{6R<~zw
zEce@Zp-^~pVo1>Aj>0pyTC<~-^UiMExz?(5k*Qn8>@^;TvyG#AZbk>54fiWqJN34(
zd)8v9$-KV(x%Ib9#TG_iwVZDHSS-`%d-jHCZ|zfEUb+r>xzW07=LYS%SSE6#>vYn?
zgR!=^S>J4q4!JCK=F(A{wAiwcGhwRN=Dm8}o6@ah9L$mzbMg**miyZ3?V(jSZs+ta
zU8OZ?nR1?c>8_Y}jXKh7S<kc<hb=o3eY>RO>9y}Y3U*>%Po-n)&1NsVE4pB7u!nc<
zRuR=nDz|bjl%+q<(hNEIB((C_vDJcKx6RhF4zUi8WH*tyJWKP;vQ4~Rr@S>c%}$HT
zI;gv?G$KScJLu*~p=_y4Q_-!mt8T4rPO&=i>q_oQ?N}CV#~z7oE6-{fF6nO5w!L=2
zCNMfpWmW5jy2MYODorLz9QD1QEjRaa+?+k<-AdJ<z*M7ca~{+*+)Ft&+vdq6Pn8*l
z7DwDA)g_Hi9Ais0I%GM?Cn+K#?T(^g%WX^5=2fdyXBu<NN%c9|>vOO-`<$S~6*Hbx
zoh!$#d1o5tc6;`22~~qKyECqSE1tFRYEhooqqjRPuA86vEOgfS#_W2v)R44pLu0dP
z3sud6Gm|||YMU*XxK`}w+i7<<^aqD-b&L~ReI#k&(IWT0^L&w4uWZ{_!MgUq#fR$(
z*2?Q;S1y;8dwcacL+!11C%50b>bqy^M%^Z_B%g0J1vl<(JG1Oe-n<aoS}W<7pW0SE
zeGyW#bK9O>tkF?IW=odkPBG5W@~&6YH0hZz*~Dj-i;=I`v0uM(pQL#zu9<X3bw<^x
zs=H#J-aMUK#jm?{%GHR<^A^0RUf%C_z2CL(esS-6i>DnOS539we&4b4PFc<4auAhV
zo1ZOqB{Hz)UBFqzUdNfjGfx~|wQkj$XIV_U-^V_F^vroh;XLa_1ucz7jxJ;5O*~US
z?ZzrI*I7QPiRbJp{dDH_yt4NDXl#6=igVHK*>;N0We#Ubyp}88oa?*EUB>C>v)q@j
ztUe!ml+v%9XZUHFp{Cgb2D80-haFdC=M>L-+~XvecII_}$u_R8OF1V!x2#=oAv;yK
zV^(C_(qy4yYYqlGoQ}%edcWq~ya%G?d*01^AXcweVD_A8-S=}Z-!V1nrEEN#EW9X8
zYwyKXdzh4CZfrgEbcGi0mfUB1V~@QlJ96Xkof_jAuU236+xO~gX-v7~t#1jX(V@(T
z^LWBuz0TeGeSX1rUa!g3uive{8>U#xW@=V)wpVt0_4*3&km~dhIa$AlsnKUM%{EtO
zpDr%gZMHKnwf<6Z?vcuEC(SO2a0(os^l7g|#SfWCNw>&-$Jh4tuH5$8`Ozb->gd4j
zrQK#aVZH0U<Gi&vPKj;y+w^whtUH>1E4q_ztS(-wnl5%%;9YF&>hP8lw}{1tYKhZ!
zdsz!+d%iE;UKPu^X^GY5z_nh6(PpKy)bca@%QPdN&fc=Udi%zD*W)3!Cf%X8d`}%?
z_ne&)mD>AKWZO<92dPdWhAjbX2No@M2?XJ-IajW1Tbv}EyXq-dnV3l9mWPMTCSJT)
z!fV=7oIKUobz5r0#iP58^2!z#&Ivs8cGtVN=gV$<by|F_FK~v;n+rQ`y^G~LS~wwF
zJM&D`UGvx?GojweK3qHMBa4N%%1+xN<{i~E?d7H0i*mPHue&C(cunY5&l!I29-XMJ
z4%XUiBIa>ok_u;TXYTgg*Q`lPv>aDPdaH(c?rxoM>fGkEa?hi;7rj+anmbi`*R5^N
z458Y2;byOlE{2&(Z8f>|Otb5(?>4W->CRE>RCCUp%vJK;oZENJXv2cLp@H?Ayj_<V
zoDSTwc+Ixv#IU1gnwv#b3>HgeCmL#-XzO_RC@YjXZ|Thpy>)G=<)Urd)GnDWT9(Rl
z)>qiab>^1Y9+%kPq@6$ZcXr*XO>7NUd&L+;#G0Bt1ELNlD&0^P<?>EzNew$N%XDRS
z@mB4erDji6(;mxYT)cWb&~MFjy>+X4>sP1cu1<1TaLeSj(X6PmrOvsXI~H}Rc8UZ#
ztdTmp>6FHzUQbu0R-=qXUD`q#i$ZeQw(+jnWRh{Q<4RIbP8M&{3RA(ZV~ezA+{m2b
z;&SH7k(3RLQXJE~Q`LMqg;YFdWr{54ZCw>|F6O%4O-|j_p;=c~C)}T?_U^IEiJ5|T
zkG0i5dF;E;SVn7=RtUpJ2DSstzM)fRtU6U<JUKJ5%z9C3-^-naddAcGlDm#2nVfri
z@MdgRaY)8v%NZ|QqFH&CrmFT_IWz50bk2mk0W+^%o3c!E$8*uymeYG5TX-IxxOL;(
zYQLuzuP1E0d-o`p)q{72*Y1?hJ-N;KT=CAso3d9N^PW|&ciJ#_m(;E1fV9k6Tc)19
zmb+zh#<D3dZ%fHE>1emzPPw@CR<PBhUC(8nTJM@CS5y(}c6#<)UgzA^sgn~ANvG#c
zIwgF!+;h=7>m?V1c{0ti#n$>xy0I{FTJMrfldfd(MUH1gwjNj2Uu~%5vdQA@HqpI#
z9kZpcMO=wK^>k<Sf*bWFyVq^Z%bPOm-L9vLE@W|?+x6~k?A;O%Z8pPI99x|(ZH_%t
zUbvHc$DOua6MDDZ&fVr@b~|^<<J5x3McJ#{ON*^b3r`Cj-L-3X;jI^|ZVIw6PFC~T
zw!}ps<>bU@)ikqmixtl~-fY=<xan!=rqy8!dwSaLwnxvNvus{*NAFplZ>9Am)?sV6
zYUu8J{l0(4`Mqb4ZjXxUc1a6(8)%+;Rd~kQP3KI^p5(1ISM%Jq*lSyu$dT33QO9=A
zy>s?R>Q;%<B3HW%4z7vPxR!obo<Cvh(y1BOwiw$yJXd+H?3k{H!Lr@2@4ZjHG-Z9#
z;!Mj#t*E}M8`nzbgk1{V6kX5#|HBz$p2Iu_XN-9c`9R?0MiG(vgQ-4|DXmitQzr>|
zdU-{9sxWNX7Oku4z`$^H)6FE0uGM0vQ#+MZCQVbA?WEGtt#&h7cUA<$R@0@%rlt&0
zvo6h?wCn)aRF#=3C$%CX6H{9zuAS1Gv#Lcnb0yDOpPbufDo6GAX}wen*>u_~=v1`R
z(Jc%hz!>edrp+nC=VDaHi3t}jfP|R-NoR-M-nKP&|M`zD2;io0P*9?y$&gJ+Nr|JQ
zqvMDKXibDb5=W1Vi(`k9p&&~VkBf_oV27cgpn#jg5f>LniDp3%nCv6!qAcK&&;e5^
z$fnS7#09*lLco5VVNbHeF~i<Fpk)+NOh<1_{wu1$jJmi&1iH8aWqHNq1!Cr~#TcS@
zdK^1Iph*b{OkN<SJiWn%jd%J31x9|aPoF-0`l9&1zMlPVt|EsB^R^pM`Z_0s52L~2
z;tggnJ`%m__3Eq9&!&H5VUo!>efk`d4A?|uK4)xb@w#20#ST-q-MRp!uieg$&Rxqg
zLx`nO@7?ZQuh*@6g0cJqwkBlpx_7%?uYSLAa$>baeC_x9;(K4O+o8dpyH4nqlK|;-
z`g9PGI0g#ui{LPa5y$ndC+kVb*MFS%Pwt=G=bLZ7RjaugX-@Px_H$qU>}L?77rfZQ
z&;I&F`7g(teksprk1r{C$Ni!xtbD#*@w~^EJN8xa&wK2r^nAg`XX|&z1jXytt=;#w
z?AW}rTl-!5`z#mPeLgQ*V%U@Wdy|9doHys^>;6vgkhYikeDlrR;}!S5ZmS26*!31L
z>)o!okeuYORjM~*%dDMyK0cpUdOfzPDtFuM3f&JaiX1HyCKWuHQ+hq(%Hi}=6S;oI
zpPI?j;Jxo}-|yXfJ|6yc{{H^D`*s!f<?J%@6BvSbyyKsK@vkfh$hZq0DFiXV7`(i~
zCB8QBGk1JSHg{(Iw(sdLtGj*tr&WE~S7>IlxXw3kkE~&xf4I?&VE>wr6DRyy`L+G>
zy^6ah%dgn{sd}|YH)7*M*R5*<TL11<e}8H9`+dK^v0lnt_juap^Utqa{q8$|!lLl)
z`)JTW<hC2vAF#zX9J>d~V%(1&72mnHd!OIcU9ax^%=z>D)5|$O|I{CUZfLsw*|HhC
za_zpq&i(x~H2zXKX#Ipy>atzO_S(r$n`bYrr+UBccy)XGsa4Bg+t>a5UGww7{^?I^
z);}%U8M7|DXy4&CcJRd$hrw$p4%pXQ+Q&XU`tJKXccUdiC&cf{>b}?tia0TWC*F^b
z_jgr3KK<<S@`!pl<6|+mN?tRu_k5I?Yst&Xe5_*b8NauazRT9lw6l0-So?gQ=|$DI
z*9|-GeG+}q!(d-hl5X=n_xi+h-`Q)fFTN<u7oT4Rj>K)p_A?m0z1tcZ=)%hS%-Y*K
zXYJB$+m7}zPX&uStcZK!;&RXYc6I)aeU+iMIltdW=ijf_TJ_6=AMD}ibsJaC{+#T!
zYSpU!wz<CplV^WUu3eL}&FtU(x`UJNxa8XXVyk<k@caJ0{rkP1_n+9S^Y=YC&i$=l
zfCAV_pzVACv-Fd$^6DM()yG#?*lAk7u)STFd#a(Z=)3v^&}gvu{OZ$B!}2cgync1F
zVb`iXHuV)BA0O2OuaN)|Tp}9rwJN_nRaa;Ik+<{Mvr^>UyZ7bg1ySey{l$LWy2r_2
zr@L$q=k47kryp4-Z!dc{Gf1H2(GvyZ<u0E<ZUCDf9(VMi_3qufcTV8)$ge*AG~~-i
z^?RGPZa;Oxs!Qu=XlR_ye$`328`!rUyDM&2dGrCp?c}`J=i&{_xxLpD_;Y)g>wWIs
zxJ{pd`OUrx_ozw-^G!b=%4XVv7Bbwsd*@i?L)+T-eA{mOYcOt_ywE{9E%JE+`?=lL
zJr<uD@^j0|B?_N1+`IMY4db5ITgoNAe&1tt`4r>Rc$<pS<x`kbYd$`_Hu++YB8TtH
zJIBnYU;BMeHh0^+0Or(urPuj$8+cY%ibvN<E^ATbNZ&o<*e3_p?a?`#&mCY3oy_PU
zS1%d%NpIWF8w{tmPb}SjaaM+tKwI_Bo_rOC=+bScc{i}!sjPjkw{2blGNY!tf#c)T
z@5>k6Ub^Ye?F6p$d%@GA<8v5&exE9Oo&C1y0+Y~8hVN5e6%^fGyDj2(0-y0y$I`9m
z7#`b&h)2gfVi0I~tRNSn3$mjAv_!i8-goczaIf9hyy^G7cdrlZy8XghCp7Zq%a@mz
z$8j)hd!0M2{=fRkKh1kS3OdR=Jo-2PwDYz$hx?45xIcf+J@!*XaKhsb+0S=0MBgn~
zv7o0Re)%o73+HZoYBreN&RyqsODO4E$jw5f!>mUpd2Be~smSHca5IPFCU}X&g!)#M
z7EKjJPem?I4i?3aM=F$$)YTQwd9D_onS0FA@3GQ%_Z<Ohw{GWd0wpHfs;{rFuY0^c
z95Hau<j}kA%<Y`>f3-p#f44Z)ojT^0tTJQ6)Z}30P}galk}azZ)^1zTF+;4wC3VZK
zz(q3`u3Wh+>#E6#s3W(gE?in4y46_en6cPt@2rh#vrgO$n;E(6n6%c+jBSg(qm5e4
z(l#B;HSzRP(^WE#%$@0UYwN6th?&l+Yc|c~IU=|<IAVoaptsk|+}vI>p_^tWW~DCL
z=5=<-ZOu(>s*Y2Z8Fd|8Yj!irHO+MT52M?bJca3*iAuRnzLRp6EjO6)Hdw{*R=v)Q
zVC|GyGjHfbtF&!YY3n`la=XFSNx>n{wT>muyz+SF+#S}T<$4oUS~gvCQR`gTb?4pM
z+%<E2FRsYU;nYmdOpyrPm^szcvo}=e=1%kEVsVdIdGDT^8XGEZxTzj;Hfd(-;yGG7
zm$;l+sdrR(%j(SD;Iyo%qFo_7mX>s_j4|F;f8#md-?!WD$;qv<EOpmg@${<91Faa*
z>$&9(U*lFEjI{{&6TRG8dY$#;-7UF_F>{O3o~)Y`+v)XSr}fsHsj_+{TX(q&Z&ga{
zdS|7x?(w2cD^{+&Q?j&s*RG&Up^4ihmbGad<Q7)d@tHDH$aU??Z8w_(1GlZp77Uvu
zEU|X8)TWU7rIU9Y>EyIpcyi0O)MeMRLJnTCTDa-5SkA5Ppc5CTE?spoOS#QB_O4st
zR;hN*ZJJxnmImFJEp>E5)^5wyvz8^EDJxmJBTDwRhiP=$nk`}5tT!)pHM^*Gg=^Qt
zuCRAIujZw+JT6$Gt!Zi;X4de^Iz1z2>+T$>$+<dLOqK;_zPwd`Ztj8=*L<dJ`<iyU
zr1h@4Y1pyN++o?}1&b@nOjXTpOkKOm>)WG?%X{>-o(WHr>fCnh*4n@sCFOgqPi)rg
z)oBmexMR+?7r`aDzDmzcExm5+xpsHUl$47ZmvZkOGS*98w&Zi#5|h(gwwGr;-MO{P
z>*YGOTl}TBQ{D!hUTL*K+AOzTJ!^Jpq+?f($kH_5Ww&)bb2o08wR7UE0;kmOO!G+=
z50`GbwZ2?%#`CFqv%O8{rKP+}o-%h`(23ituS=|X_c`a@ojWQsCl$?!=$jV0a^*>x
zq>ZIkIo0OLhMsR$#Xj5h^jzf1=pxb0%g&sed?(uVeRz88`J#nyLxZD4--K_wD9urS
zYc;RO(#3(>oTQ?*O!gLB6<j*WYq!^IuT@cv>VaD8MLl0l6^a*H8X|u(XcZ5O1d~C~
zih~X_R(c(E)!}A3GG(LJw538>EHjoSO<gfHY*A>$DxXmG*Z&%8AHQAvcHZC6v&MSm
zXa7!qw)Nk+qUw3CnZ(~Vcg-lO{bFd^{?hH!@on{&l6-@LZNE)^y?fgh?y{wd96>YQ
z-OQ|BJ5~1X-Moi{7EV0Z+Ig<{am$q2l_8Vg3e6DlN;s%7L&R5LV!||+sZuP916H+h
z8Honm6q#^hNqdmis;7YgmsSaFS~Vd{)X89#&xBR={8znNu7n1OKMt5`&*1pSt2;aE
z%$ZF-36flr-KIgoCM#zx@i=p4g2aL5AIy>w2a<9H3{_@%=1lTcHS#n{xy`yXEIYL6
z<U~!wgk`Lqnl+1)y@ih5_D+=uTWOlPcGclfRkPNvuvJ2K><10Jj*0e!wgs9voM=mN
zQj?VE(n&I?KN7|*nPhNS$7IPNl@zZUzJ-$9p<8CoV!Je3JL8fkchr#?w{C}=@rjm7
z-I{5XyKs^sOG;ADVN;Kut(ziFGR+D&(yTTm%{XLc>SUJ9B5O7VU2U9kEKuUA(Gj)O
zw3U%r0jIsgj{54DnavhCJF#=Ygw4@PMz<E7%ub8SU2!X0NvGavTFMn|MMtA078k@!
zIeQGJ1lY0cW0e=09;zH+w%|n0H0h|#Mr)34T5HC0IykEBLc*16p~@=9OmbG7GFm1k
z*t#|?b48L=+U1Pi$Z1iLN@7|`Q)f9zu3B(2D6-L4bCt2zYQ?Q)o3)NfEjEo3OS`s-
zBVyBqsFM-5g+skXMK)^He|EccD>P?OuCR$WPs+@$t5L0@8%;b_d{qRE1Wng07F%#O
zZDFKZs?UavLdzmHopPABXrauuwbP<*Env8HfHCaA?VOW|UA|7)QKxj4x`uZOxj(i0
zHNWQl`RC8~zON~4F`m3pZ-<pl(Z`E%oMqc?=ccaNb~`sJ=<3qcrQ235(pmzV!4>cj
zVrc>q`=8yq9lHK^cHg`2g%gaA)YUw<JXg(Ex>@4syT|+`&QmzIZM&T_3AA!A`1<;|
z-F<uGv^Y(nEB6$<|Kw)fuFLuyKK(~C+m+8>Yd)X9et!D1+!VR}S*evF7PsGTyk8)%
z)E@X?(R!{ut2*z9zg53pUZ0y^x;tn>i>6O`&Xxtye3MhxskC%6LFV|CQxU7#V+3ZM
zP62gt7SFx&+~VIG{$Izh+075lTC5-Eb8TPo<agC;ny<et+Ozt&bnQ3uH}+oU(`-XR
zvsUtaf4_Tw?A@(<uf6qh5?E?@chjX0(c2!E->=Pk$as)*@{*$h_0w4trD1E7KCODL
zZyEb8%t!0P>I0^q(zbq{Gr#z5ikzt5{@m#e$et)#&$VI>>u=Am2XZqZhMSk?sw{oC
zJ@?q{a3Lp8m6wW2;N|%Z4?x{E$kL~S9BwDvP6_nRY0<NK{q5@7?G+3h^=b@^ER702
zpynheQ-l!9Dy0pO`E^bvhZzhk(1j-86_N))%Mj|WoM5y~Uwa_qZO#n7P2g1o%PSZd
z_};yH03sO}w%vxzlY<(N4D8psc9v|9E<EaLC7o>`8|bIChh=+oa_%NhuAnK+xf?gt
z-&9(p1zUo7Kw$=p(68%SPxrnrxh@lON!EAkff84Xjs;>jO}9noC~`PW*_yg-+O1U`
zt9l?y2bdBV1U!U(&srC~_uc!w-%p-C=C^FuyBFW}%LQ2<FWr=#v*}8UB3ICqX;INx
ztCUtLEdhI^(SSpRlPUhkQP!0DnZ9X7mG%Y#OuOqC5i18?wH69Cy8XHC_JKkAiP&>P
z#}b~FIa~U&E-Y0}P0sb|WDsF@F!6G6@nTvb;N<Aaz`*FGxb}h+6GI25h=zlZKnSbt
z9V@PF3=C`y3m!gT<Y7D+^o61Ljrlcp&kMP^yr2-uJpA^3O?7?seg1tN@{S7vL^$J$
zYwv(UEzH0;zx7<6xg?*bkcX;2%gUfclLHJsDyCXl6U>%5NTnQ@YWr%@s`*Pm3pPLt
z1_GV44CXDk?7l*6sc%rOuN1>&#|7YZ18feL9T<NY*Wdr1`$zuR`v;#-J(bmaDytX1
z2ga%g3y9iobLI1P4tf(MHNEeqh{g8z^D1K&FTJyP>8bA^*4FN<Y_TiXbXTsueLU~m
z-dlasi~6RY-@WI1|DMH5KRmcMTZG;2H-vX*@zT%l-rK%;A98rzirg<Z7Fd42DPpP1
z>%B1}E6zG4BJGxg<)Q5p*S?M0p}R?HQoY$VhixaaJZ|Tnj^``Bw8zF0G^;-gbnXTU
z&m`+vU&ht5a_e`W_ktbSv3iyrlq>U`T%Gk9SI<hVE_PeL`rXf$aTV+^+pm7Fd<i<4
zBQ$@OX>EKt7E5`hb}lYpV0M4>Z+FtoX7g*JGgoun&IuElY8JZDw?lWS*}`bAT-Ru?
zT;@#Q)-4TLT*d+Z=VG3n2?%Uku<Yig=X_JQ9a}0ApJsJ9>}=QJfOSEtR}Hr&t~R^1
z;p*&(dRvW?*Q8|~Wy?A^%g4;8H8;q2)eX%JnrlOIRk!{CA2(rU7WaMK*DI$|R!o;n
z)7g}*8mK2d*=XftCl8TRDVLlsIrbhsuypa{Hs1;L5n)_sqqz=TxgC~sYs=cCr~|VO
zW~+wXc560eW$N|O;Emjxb9RZ)F>kZ8IyZILmvYb9y=rz&;H={579|V44qkZab92>{
zQ^#&zlNGtT>vdY`DVJTx76&J5&WzgWF+FtF2AS2ltZS}hNj2S;4#?upW!rWkJIHO@
zE#Fm_gidD~Oq^7o(v#Bc?Jab3>FktN!&%pEtT7Hq>(22`&Q*}zd3t-=jkPn2rx%M@
z1?NU6-MF@G=W0<|p~+J>uDG>UI^xBYIk%;*-A$I-mc?_$IFsj=8<)hDvu?+xnwd>I
zoSB&*;OcY5d#=!wS(8>wH&=^X6~h%JH9hIVl{MSN**IU^<@Yi<=~I7~Z~ERlug~a)
zR<4OIp4k$1MyWF`?B*`fmrqK*ls;98&3&EEv2EL3L-+NXLa)u&#Z5hZHtXK@-AnZz
zz!r{F-My<>&RBW+($1~V_2V9&o_29{TyFO4874P3t(_XJb~IWk+BwNLHR@E<fo#?_
zU0YXraj{Cx2;8h~wkA2EKAY>B<C^ZMuAR$Xy^PJZJUzE}Mai<mp_-G!uA6Ns@$!zI
zb~{;CV0!4RHrb>Z8izf7l6-DVo1CT*#+oM8EOc|D?lzg{dVaBomvRNp<(qPF)s$N^
zR~+q&xgGOj%Iw^;+csWu*>z}!Y?!v_?7+5VISZprW*pgOD4Eo?IGc6b4bz}{u?yKb
z+?i6*Ce4|iTV{JRIo#EpHAQO5Suaz!Ev`9kTijMDM}f}8$T+$sX{*Gxo~*@U7rQ#P
z-MDpZwRD8<qMOpLTUIAVhuoNUI5??oZ7XlYn%lvqY|F9*Bd6p>PHmbk&7G;+x;5Ez
z!?vk8T0&-;zMLx^Ij*c0+}3gJqNs^N{j{(f$Cmm;%{EEu2~Czd%b|8AT4L*#Y*DSu
zjaz*e=ITcAb|)P(xpHjn7B8-2r%XGp9J^(@C1loZv96qri`~{-TDvvbDJ#IqRPAcV
znhQ;lE4mhm8fN8O?A>ajFxzmk;_6_LwOctNSDf`-m~mC&R?dy9OO=zZnQ3nAxVmx0
zrK7C%8rx=VJF;@M)Qp8soK&0?g>)xIofTbkRZYN~Gm&NELYAAn9BL<1l1+VXxm?Rw
z7Iyq_i$ar>zzN5N9F7awTg)EvPG}NH5y<6mlFo4C$WWXmAam_dl+ST)>9w9b6Sv(_
z&gG~ypLwoO!bazK$Rtl*0h37?r$mm-a+&0IyTx4L#N@s}i~5Vki_Pu{=d|Ptq;p)@
zwKTk)BlG4}=9Z#Di{`dT9@ET@>&|#J$x~TN)X`<O%4HMZnaVk;OU@jbZ6t8ydGDUw
z-dB@6Ra&(Dd`=dY+zteh7Yu!J&ne|O`xWQ8%$$^`W-;^T-Mcp~&)xRw{>3Y+>V!RJ
zXG@$va#Gs#d#QDAXZ??7XD4iyUZvvsYi;O$em-^~BTtn{858e1Zu_Zn$#b#hijzWO
zTvw;A)(#Z%6_|G8s;A1t9+xDY+XWXQH1ykezk1#BPRW=krQ#{1*171*IwQB!xwB=q
z)#gsgS{u5<ce|33pOdoZ@>s*ZVwq<=LIxB2-aS1BI+KG(I<j=vi(~amHIvj$?)aYN
zb6hxWJMSV>p^T0N3-(EvU)9}X8hYtgbn2817k3(0tqIL}Wajzl%(2HlxhEz}+!(Ox
zc9^$Ow42E#pNrBtotqXZDQDbz5oIW5;t?nmAfeAA{c39V!8KW?QoX#nu~D90?&pg9
zEa&)ibaZZSIj81wZspWyv)hV~;w_RpavlqAyVE<7({$Tw(-5&EVJaI1odW!K9Nf1u
zI!=u1qKIo4!?oM1f~I-vPE+!6xux!9(NcK!$VJO#=hQA9&snl9sP*c)tA_)kSk;cr
zRP&uElk>#m+8J}T<B#1RN={x7Y+c``+xFFWWwgekO&wE&KleySXSdxBIvZuG>1?NV
z$Mc+I)b`LRHzsXwTX4Hz+k&k<S-0d09+`_t+;1`OZ1HUrd}vhgtmE<QiGtGUf}1T|
ze1&~Ye0+^3ZkQ~T=5m|=jEh>!Y+tiXPP3Cj!fKNQ7b!{1_*xa~U2Y)3!^RXMFq^I3
zR7y)H%OoV?O2&%qPM4B&W@&0%3TWflcDrP?XO?&Nx^=4?%zC@JMb_@}oSgBvxX9O4
zB+ykYqa)ht%2MgcEzd241$Q!+s)cgh&RKOdaMdDT*Cksv3bMG}j%P7eS>QOyLt)9Z
zYX{m=rf`@{3f1aV-1b~Lk9SeRd4*XjXFhJZT`$v6Xs(uf<aSZ+#uv-Ztc_0S&w07^
z$JVH6e{3yP3N1P=%JiPKof>piSK)+Jq<8K#udF*-TFEV*lM|%`&1R~(-FEnJ@2P0$
z>WbUDw#!}(J#yP|rks+XQfBUt6{{9p<IZ)A&^<UMXx6N*Q>SuwN_I3)%UQO@TU&Ed
zPNCtUOzF=0Bbhljqk7eDbQ~9GDO_{bXVJD`gN44UQ<H=}6tk{aZ2QxhlQ+}1XIa>7
zJ|*F_6PdmJhox;ACM15*oMxGRUasPipwrCcX_b%9%Q*2AnN2pBY|=Y>_QdD?Hkoo2
zpU<8t@^BJladwg6u(*&b@X#pFFK5n!O2avBhtKp_^gKJcqrP#@iQB#t1d$H^P_Q(3
z<Z|1m=Sc5jwTo<%oIP67CY!k=Wn4;j>BvpaS#@gRmPt96R8%JO+_`CXMD4axj>{3>
zZN3vSSvn@=Oy-@$DeNPZWR!EsEaj$<k(;-)sm_u$nNwLens^+W84$&pCE^|S({e|V
z+sWf9b1dtZshNk)v0V1-@odYL4F;wLY^LFBb(guhTdLjM<hzZdx0A<n<I<TcJOTnH
zteLgxa#(b*=Db{%oVB|U2Z4m$`oO>~KBwwseC*@vVLNLcglZTtFdaoc8Dz?~*79JL
zYmz=^b9S4YG;IsE?vB-4TY6<_eclfi2H(k*r5U%Sr>5Ns-7IIM7uFPWBF8&3H`+Tn
zYt8MX<#%58?|ZJ>z4O#O5VQ7Nw0QAU<vf|&IbUvT9J^%ZapRCni|@U4a&8y;Y@Saz
zDf!H8mddS+JfBMjkNcJuniRKneBXKZMDG)oW5wqrcRV+{bFOfX=fnxCl{C8E)}I!M
zV3!ZywfTgPTgyCoJ~`i>KId5(g?u%S)9#!rHlOUzd%UO9((rNddC5nK(yz8n=31E^
z8kXNKDcGlD_;SUvwKLYPmd@yjRGQ@)vO*wbX)m`~YEr{e&FI_}Z5~T{bJk9a;;sO-
z(659<pVU&>`FeZYJJ#+w?Cb7U?-0`~sLz?I_D}+HvInE}&ZOt8YLl)9XHOKE9X(^)
z^{X#cmrT08ZBK4(?e6n&cb_x7dXu*6)!LwFwi}}FwjQ3gLo@72cGR8YyL-xu=R8|i
zJU5}Q#`@ACo8;0}%Cc9N)s~l6eBXQbPQ^rJ6`yC7y@#ETzuk7*;{Ifx?XNSZ+;%ow
zmQ;U)b&G@4!f8$uF0wVV^>D8g7P@-LJ7E=*>7rwklX}%|Ew~o4EjWtns95g8)f_i<
zZiggoy~T1UiKpq>!9cOQQM(uQNZc^nuxfM3vX%@bB^7mvhZ3{hX16_ic5|V?wPy?4
zZnmyisd8(Q(>tS#9-+XlUEVwR4w&6sku!B=IpYFtqk8GtX*->!b{#c}@O52uMLIcf
z#g;HrsczR*O3hJ9jGhx!1QoS{PAQj$ooFzdvg;jV+vTk5R~GT*D<2Z7+?`Vz8XCaB
zAl20!Vrt5u;~=WVn8c9V9AUO{<q9zcrln3t7`P5b=pMT0>FYaZrkabHQ=0Sa-ZPig
za*s><<*7MdHLVYvvS>=q<JrB3)1?~^nH(u@o?VotA}Nz+lg{yZj`Qq{wvNvxA1C>x
z_nxzv^U<v3&O?jG#peu98?8=SDJ<#}D(oxBk@LAPqwR!`vh#!%j>lKuuAbq{aV1w&
zbdO1{#H5Y6Th?t4-4V^YW^3B)!s9YFa{TObW)&Cblmz9>&bYgwzU;=$BZrmy&h{Uv
z{Cw<=@3Y2T=DMAE(UUDX)84I<-c=fVJb-Od)Req%v(oF_j+qlPwcfq<%-K<@s&z?$
zqiNDi-6dD1E?Il&;JOZFPw&j$vuCYdw=TFjai!L~H=dJMJ&NR+vMS7Dwnu{!msfO_
z*Xvcg*?paZ!){JIFgdeJW6`YojZqt;6_3^YIH@l4d~awVpWLe-KTLX_+<3Q+$H`2v
zv(HH2N5zjH#~w#ayL8iMs+r3zCBs~uX{T<5r1*3z3*49a`RvA-7re!>I?<{tb?=@o
zo^!jPGk2Gz)$OE;ALXmnXTLE^U%P4B$s~b<w@qn(^Dq7R?{gw`=7fne`RBj5^Xv}a
zvtvl$;AFuW!u1>1L>cxbyM(&-L`}MJOJke2>YAI|ylz|+yJh0KQ8{q6=C;Wm+1Z@N
zff+Y$+}fDXp~NgL&6v^E+q+FU;$o7P(zaB`utf(2B^DhKWE5bKj<~VS%yi9>TfA#$
zoLa2AI@gC=w99wfWRw2K3fH=B=Vfd=lDo|$I%&<3t~Dn`R~Kc9=FZ>WcXnlXkZ4@S
z)YsRpon2}-b92sQhbtnJ-(TjEJ1W?dEO8Vvp?pjOJg<Dr&<!-be9W-x+GM*cVw2xr
z=3rWzJbChE6A)8pEoi16k0z)Yy~~~%?wEd2fl*dS#A}U)sRtCgh6%0anSN1`QI@ka
zv}M(y&_t~bP-PBR6`)XSjVfGOJzN>cWD&15hG%zfH+y#H_Uy3x=KuevKt^^TLsj1`
z&wby7ej)>NP9c*69|LEu&bw!e5^nP}ie{<tZa5+Q;ayeXaZb^655XcOB;noj<`f=s
zjl9J2?)h?=f{9^)C5_fQUmllH37xCp31|7iGz+7vFJPH`b?MwYSA3)sCn&9TIk-)d
zNzVn$c>?BWU77rFhZwUYlgDKJ9THYfJFBzreL+4zBJO$B+uNI3Z>=le3)-O9dTaIG
zH<McLm9M+I8?uq_-RqyLuKn9E`QU7s$rom`*XL|F;<{{!q{^htnQWe#x~7^QMnOT*
zzCjH}QCW_YJT<+7E(h^yDhdiJ=9*ku?a|ROQCa7b(yG-S9WDP#FP&DI<TYD!%Bj?_
z=#QbLUXd#|Fi1^GQBv#3=FHlbYyM*E)zqM~z6}i5&IYw?jqJFkD=6l*cH?3rC4qYV
zrw?DP+E~9yT4~ePsi~=(Q?CB~wT?kjXzp6Cx2rQ`x8_V0H$7Wef462|y#DmlPe1*v
z>3$Ng^iv$n1c{y4=lV&1;{L_wUu@rBv1f<${XOER+xGrED6g0M{@xA!-5dA*KKki_
zr`q@T;-?!`W_^FpQnOQKcJ=pd-0$9a>fcjgn8eZhyPhX7W%GweJA3!rd_JzJWSGD6
z#_@AC`xATIJTxw5>il>-yZXFM_Iqn_bGzcF@$(yR&u)piKY8}csK0-Hf4_LXd{5l(
za8n6}3A{VEUE6j$UY^S=`k9kJiy}wZ&&-(jyWedueO>zLwz>7b==@HFjXbth5m#JA
zY9?i0tnsYz6bbuPAFI84?X|zNkH0_u;vfHmA2pye4?y$x?BIhB+CfZ^SOfT6gn!jL
z@1I`#{`T%2_vYr;-Icl>w`ptnf5)9`^CPo%f3!U8=`<%N@I%?Pb9yQ@vRgNIcj}fu
z;?3Q<H}!Pr{myfI#bJBJw*C%1ae(<7E1S|J&!4j8^)f{o-TQ4md_K?jSV={~{Pym0
zYmt4^ufP2ekig=`649+P`NiuUkBjua&y%Zsu<zd6a%*v~*Dq`9;#=yXcUTvfFt@Q?
zT6kx-k=m?@M||X@w{e=vbXLEOx#AuAyY83X<CT9v6~6h$=X&4oy`S^>dG-6^6RT7|
zy4|12Q4?xnxwwAiid99&7HM^+O4p@WeL7O;xMY!6`<W@yo->4lE@(0dAHMkTg^P=e
ziz9~s=v0js1&2oF$JV*ar^?S|Wpg!9bqx)#Jk6|gdtN}@=Y0WnUxJxJ;<Q%1w@gT#
z{gL@<s`@OI$<Jy!X1Tm8H@g>DS<qjwqqkCbwtwZdRFOCp`J8%BdA-i5AzhC@pZ$G;
zzk28W{S2(1?|m!#`}_Vp-K(cFZia%$YbUC{c5dA^e*uH|+3UOSJ)gZl_4?c2)w8cZ
zp15Mqhql5a92^27%OzSAIh2$*6u?W6I22li1kxoIODaVy)$v-gsfcA#b;^Qcfjtv-
zf~KhkMOrd>+HMM1R&Q`ZNnnmnhF;SvjS^u#J{}Q8p_pWW#fBVC!mTYC8p@8pzr6nb
z@~i&s2lCUezdyjf-ZL`lz>_={=OR!@3;Is-)Dr~FFLQ}#RNkvtwW_0I)g~u_rb%{J
zcbaYsojm!r+v}q2oYm^;+oq?BOy2g=dX8t|F+-)dORGE;Z}YyZj}^@<^~}7gvc!Ao
z1<w^vJi2nGt4#9ba57K7<XOGtX}<T8hdfIqJ)8vg-ttsDw0+4Wk&Ak)%99{+%SCU!
znN)HsQ)foZB*h+MffmJ!I!P%DxrGi^s!W<~t1{QxS9QjoDK}rL)ZX^gJ)W`<q(<SK
zVULr*Rvno{j@h>LD*f9oc^BSP%K0)Wb7$$x(CgjLf_j!Ha+G)%c|7_Qw4^I*I@83H
zDlfruU2n@g&35@}!>m*IaW*-~6k*+U&!rW3t%KU8x%raE?_8DbvXkoD49++SG+P`q
z<Z!yOp|Azy4m+@0m!0=ie!FGToiZ<p!-gDAJdY)gC~^lKJSNZy*Ie{cCG*Sf>}^jb
z?_M&=Q)OaDy1+8Su4IV^4)0(xQ?2JsD!rY$&fH~(;$cG$=dNUFMV(+t?hZv6zben`
zx%Ja_+!eYT?{_;|COT)A>T!v5fyWX@HQ5EG8Ez7K#Nl36Yn_`@n7ir4v^`%YS>E<E
zi(cjPnCFNhhsAV>iyF?Ull{9C`8Qwkc%G|rGjC<xJpNia+Y{g7Yz0-f%?_U}^*QPK
z8n@Li)-Cwa9qSnQxI&9%(+Qz0w`5*UhGdBuaZ5GpHTFIdStM~vWPRm(+vj_p-mjLM
z_ipLZWqD4IJe(#u&YCuD=FX&to5WxX9fCZZwoFs>RFo;6^X^YxU*okkuY=QHUtfPU
zG&EUg)k3u;se-S9rnD%sIcoMOtXe(o&Fr9Qx4oisHJv~^E14W7=4NMu7Qp2`>zLH9
z=@?QUHc=?>ql>58B8@8!SyNiGCc0*EoVd+a?``k?I{%SSX3Ft}`AWBM=NM<CF1KI&
zeE!AH&ri=yIJBYe^VOFs_xKa#oIdg-&Tw&g#AfkWMoFoVxjZlQ1%Ktc?|Z*%?}Z<z
z1Y1$JkW-aQWRe+FT>SdE`r@hQS1Q;DxvW0GIyF$J(IB_AEk}3ewnSbNj%6xSF0Bf>
zD!M9HQ)^lfYl+s<puMM-vWaRfio2!MuN{>o<*UqT(l*({?3T}^#3h#`6(+kKQ9IVj
zA<(Ggmcn-1b5k_$hBb>^e3-LV^4#`RJCo7)=Wr&In~;>7NN}##tu3=o_S9dxvCXU}
z%hx3<RXU?3%|qDWtgD%+Mv`*kWA>gCXL}c=o#@GE%ka7FlH1X6k)zqH*(b-zaj`(=
z1jXE~nSr4htfyA5Qaa>oYOHc|k#gotGv8%NJ~!2J)h^CbQajl(bCI&!O@)hQM`muD
zxU8jjvazzjEKVhXBho@CZPFPhZu!=$C1rT1ob5^Bc37LCn>9JC<I+{P$!0>*CTGlg
zdZmOjW+~^Iq$srba!%NAvM23G&h0#3wUpT^7kSktn_W`L-6)*9#V75eL7I(mz2U|W
ziHDg|au*p3E>k&n*~xRG+6AK&(`D0|vZgKA64o2F=8(WmBeR)HI-JsG8@c726;9}=
zPf0U&xy&(}qbG8sbi#?la=wa_47bd3Q#reBvXt*;mm{-%4JLaox#eu)yG5YU?5fmN
zu`MezJ7y&`6^TrG?X+!)nb$T!6Ne08hs$ZX-O)y?Q$r$GM(1vI4Xl3oczIvvnr&>G
zF7T&*3w_D5@XDjMMUVR|9tsK?bo#D!3=P-4X&wujt((Zu$>cD>NwUdd;{V>z6?PxA
z-uu0cy(OEvdCfNO{e`ZlR;}9jGdz59kx|E2O)n>bW<glu&g_Zac3EPf^6uTG7w_KP
z^#VNK*D0vr@$cK!t^YG7?@!mBJRzNJGEbY-<T>e5lmEB!PF84Ro4g@iks}kdG*(dP
z(qzL7@#!_wnMJ1uq%bN@-!+>_Io<=bly!F46_G7l4!@pKdVLAQJcp|bulfBr%p<mR
z^`}2Cwm;I{w}mrdlJ`AE)6l@0(9qCbX@B-?uKV<P>nl;ow7*+A<!pHpXS67CRY-an
zf#!V~-j;dlH{N=??H23S$#*lX>+ik$dQic5eK||RxxIIUm^D}?mB;P4v+@!{{?ql^
z&+h$QC&jgN^^@o)(Nzn09i|4)@1IvMZ&&mC^S<X#pGJS5KI@z7T7Ay&1-Wbad6r5Z
zQc@Q%^t14@c-&|4$oKBf@H@-C?|xr>@B7YkUsX`fHiKkEji7pun<@(r9+|`B>GWe=
zK->57IRb3uc@G*g@9u75T*}aP?)P)6ckg~@?Vq-1{p{-RZM>OTKgE8E-D}k0%=W9Z
ztNa)m8g6xe`qcb;4wK?Mx4+HX_jTKa52pgB!2GP~6*O=5?xOV$cW>`__wJ>*#4+BD
z+YFaN8v8<ClQ*>s1smkfVSIRguJZx=sJ9G>xeLTkZO#ApfB*0Q$M-+}Q(yn_&wsi9
z^4EXYCom|vFfgfbGP!`7Gaf?rn|Hll_pUQ{+t$rO4k`_v+zdRPY|;vcQ`ELh?(LAM
zXYlA`a{qbd-PR)03AY7!Kd#sMz<s-D-3wN$?^>%?ty=YL)jFwFt5)r}0x}MY<%_nj
z$zhw;D6~y%f?#F%j)fMt3fHyEHaE)@baeD?-Lh3Gr25|Xz3*+RzVCr;RcCTwn82V?
zle=^E#MQ;FEAPGE``-2_=e7ERyL_(}`dJ+3=;-KMy1Mi__tenR=-HrhICl$lg4%&W
z$zkHR>)O+9Pt5ZY*z+#*CCeL`?9RI(n#Uy`3JRNTo3{3Pj9zHbt?k)fQJ`D`veO0Z
zvHxcR!aS#3t1+rL#;`$S`U3$LR=Im@N(>B)ek;NSC4|=3?|Wz$=x~9#>}-~9;I`fl
zR*@TAth`!TGo~5^ESc3A&CGQ>ciRTBBMQpVZXJ^r+>p-I2x&XGICbs%#eCCly^}24
zz+lC|s9+;|z@WfZh&v%X%{nPQ!YGvWHUk5LwVc^}#xG*e`x$KCTohQeVzR&SW(EcZ
z#{BJvz9gJEbU<a2XFc2U&X=JcCJaXygk~;PS=C^|kh%DZ(DJ>Zra}!2Cm4jPmP`q1
zd^LlCvth}UuC`t&UIqrOEKk<}{s5i^{)G7Z2jz=HH{8gT_Fb84x_k3v)%l0k#d!aC
zZ~OS>)A`3$*n}=QY?yILWg*9v0Pidf)vY2zx4QT_`4lZYRaH6M7B$x&@-tOo6P9wB
zqA1nHnd{23ZBbKnpyO+yfFQ?9?*cD<TNmT=bW`l%rSD#~ob<WZ?p?mCB=_9Ax!Lzb
zi(6wJhFgT(D|z+3Nqh2*mshr4&a__j<a<Hqq|H^by7yjQob&GGwd$)`Tsse~D_F^N
z?BbTz*z0PEqMJDuB}5#%B&y`2w59%#MwrKmneWz>7pa$q7T$e*;_CysElbz$c3Tg+
zx*_97ZF$MkJM7`*^QJy;sM>q4DtsQ}EAW&p`|7*TmsWxlXL`pyUiWUw?uJ+IK404N
zfj=tf`rXChv+U$!L34RmA<EVl3o%QoOj5X}!e->D;<&~mu7Z8-yO;IeJNRK!&fCkq
zVh@y-SH6rZEw6mN<8uQfxr1zdXY+tT4l+@A%p~hse>7;$&}#RdFMD3S`+U9dIauY_
z>OEiYR32ckU!LoA{d97e*^LVlSEU+`Ee>489JnPnaJAb7soq7mOxKFt*sQr}+oVVx
z)!Fqb$0nPc<++%)=xoTD&{;xJE7okzGF`xNSV=@zBVfT6%_)c4f_1r4(*kEkZcWx!
zyDW7!EX(I$a^$MBK@pj0Cyg_6w=~pp&$W8MdfjgabLw@!-MNjIX52j&^Gu^;+09i`
zF0NhB>vr92<3&x2Y_V?F#UVK*UVc(X7hTL)+f(A@S1;|F+qY8a)kYt_S-sBM$)UPk
zk+VJ1a$RRBn<_;)3tci3ow{k;QNx^Rm!_SHb~+nyCUBae?q<!%sZ;Wbr%M&ROKSI$
zE-&16)hpNM)QuP6nnJH;tO?T=VY_82)$6wLqNe3Gv#XnDX>QmSc01^%S8h<sfoZq7
z4$amMRypevY<8(Wa%$St$jusQE8R{-Yw9lA=Ea=5V%v?CX)DvZTyAxzc<1K!hOXV>
zD!9m0V5*W!+rda*pS5b!ZZ>tDI_fb^TC45SVUyl1n{y9k1vq5|3nuCKdJ6_E?YJnW
zbR<yfqR54&NSAEESuWd>uB_}bbkjJhm7E!jym`HT*+etX?qsQJS|K-X+_-Ub<;LXX
zWY;Z`zG6p>%w{Vc?H1GAq!W>qF=gRuv6YT)*}|Yb?#Zs*BH6C0QpdP*OfoJmcI%bW
zWX=^8+@_n`aaEKjY_WC#SJKR`oY}b>SD9v+F1q3<)}b7>NIS}K?IN>|t-Vubha@hO
zQqEMnD(_Xl)FErCJfA=lM~1T^TZ<xFiy?=RfKx)gq|=Pa9+NzmOx&Dt&0w|1B=6j9
z(<bNmbS9iyGRbq6TJ8?FbODZb?$XuTVPQ*@1t*+YQE;lq;A6!ypJysXc~Y5dHp+57
z`2nlAPMUcu<Z{Rf8=EL@5<7G6yX>97s8!CBlWi0(%+7F7Hc{N7c0{rF3EM+P&TUTV
z0_Oyr5)OM-E;~9ixZ|MrVKxu*r<1o9=+`e*xezV0^<38Lb=RKu_Dbi*3)F>Z&FuN3
zHd*rPWzlUVMalEq&2HORe7<sRwZNo|E(24y#TmDZR;@YwQ6=4H!Tq4LtxL8|*`mtn
z$>|j2<mAa|tg@7oGcDCvr+wj(xy6x9tEb1V-J^3>U}D&XtnHUJd)}I@RX9OiXV1m0
z+-tWN*3Z^^CzP{$hi3|>PNUj^ET+kUE0%JJXwGuc+HyLlR;%pQ#2wGgWj<HVj*8-4
zwarf1E#r}CSm>G{&rJd$QjMM~E*qs>3)Z@I`=D;ETINh|j!D<HE>hB2>y#pS$WvwQ
zmStC?rH<XWwsy6~M>9VENrlJ$tj=1yM{rB7pdf$89Uas9xLIc$D-6|A*$v%z)}*>6
ztc#Ob@bI{%knx(Z`=MLI?s4QAa<tq&ZmH(G<Z_=yPpagUnaLtaTHi8-KP{Q$aduyB
z?q%(Cj+@r2rgRjZ%Xy+?JgLd6WYH8&S8b+^KDQKCZFn*%sHfRZYo_PJneS%{T4tH~
zu3Qs#H|%P3!jJYjZ|ZOQgq>5|q}Fcn_-^E?&AE>QHV5Y}3BGY;@w~}hg-tsr8-|`)
zm2h-MN6$HnTb{>0d^}Tlaz;lc=eMs)lRt92dF3W7kRq$)o3&F^=ytK9u#$(9ircN+
zs^G{KY^kXZOL@~4NKT!~G{v;RD2!?1wm&nPbhpOl?b@{@S4!n9$2o=9^;|dBXeVu0
zGt12K%1Q5li^i^9W*QrNo5PkY)%22XE|{GzTwJ(atmt{5b<U(S(V?5Rh2^gPz$G0h
zWs(NnvYx^=<)q4#6B;S3-kK`2R);V1-kN1{*k{6JUL$88lasnprx#50PzmA`cZn{Y
zdSc!7sLmT}-5#mu+}4`psXRHhSg}56)$8k<W-27Iew`Gi^Kx~nNS?CsnybA>e9|Jr
ze3Feeg{f=b&*?Ob+ug&s?QZV2n^n^qrR`R%$y&4QVCbBwvt2Bwo@Sn@E@^S4>tQCB
zvdc8H-Yi~6laowt=`wwun#q!_JyKd_ysK`lT~eyM`cv4Yuw5Lvjy+;m#3el2G-3?v
zBcDen%LymT_uLm!<Zv-R^X!~JZ`*V0Rh}VJB7N2_x5%H6^I6U0=5v)v9w#i?4tH)m
za&nmx%WSoVCpS(sJG+@Z<Y<_kuCk#t)GgD<P4bYjlAD}G%hQH4Q)kUw1lbPWopD=j
z&9swQxhp4Kx#|3D&YanqGLs68CwW>fu}hy^SHi=^<+deTZQCT%jX{&AlxWwVwX^#A
zecs2fuckh?DDG%alP(Gtx}ma6<(!=5X6egmfiv#ftf=}`x~<kOG{UNA;p>;zZhrY0
zYL-@YOj~kO=nSvknX^(dO?oCM346>I%Gh@Es@W4smA1*bOB*lsh{o!!^jgbTJcn)5
zQq}jRcdx#^^Vss(b>*ngx9=W3FTDA==X<@lb>Df*>(_p5P3>CV<2=(@GIS=p$?U8K
zwzI39A71@heSEc`q~&>zPiZwXCwWem3_NaY6Wp!daZWG!u+8L?dpH;6{Ajm$cH5-+
zh~bkYcf-$Z_iR2N`)K4oal6D%Z;2_h3mBy1CcQI}TDI-D)jNwLiefqEqk7gx&Q{{h
z6uQZ?s{Yj4S!zdIHf|2u9Mmkxb0s0@+7y({+t9t+b1&avTK6499zDl)=fPE>8Iv|I
zyV|bya!PK9R?CX88x!s<<>i;G&U#>@-4L?2Y}?g>8(Ir)h<R;VwSDJ1xrZHY-{W5G
zy_zHxonvYyogMbhYWwZmanZBGT5oPWU0mw%I8XV^rQ9VdoC5vEmD^ivYR~tpO;ol#
zJjvYR_9V}*K_)IfK2M%?T)XOW;>pIMkW~l0mKv$_E;ML7=O@Xdc}Blv%D1@JA96QM
zHCn2hG;{6b$z>+>U8~NX3|g5f-BY;OU0h~jalkFpZMSr8F3ojm-KN5FA>pdvCgp6c
zTPZUSnVDNIO@;3FjZ75@^jxX2sH-=DcZ+lsbW?C^QmROx+mc0HT4v4JY`57K=}27^
z^|+Dg?Be2c*2m4Ghrz8$b<$1MrJlNiN-mwtCVJhi?>QRe>BKQ@*Xz>j*}c9!VXLm(
zoc*C)xzI?>rO2H3xb$qNn|((^L%RbQbR5_Ygsfl;TEN=DV8$SIL*r_*>(&NS28M8@
zj+42omrUI>ZCjD$i5VMCp3}2Po+;yd!bK|MIiK|8G!?U1$Fyc@X-0ZVi$<L2@!agW
z@woER?K0B64;3HVs60Gz%lL@DOi`hU<*|u|#um?)mTsFAcX#VLQMTJ`3no7;m#>$T
zu}E(<)(X37wk%>f&)O}I-6kgsWvr~8dnsde-%FE_TRIu5)vn~+@=e+-mU2eSWRI$I
z$BkPS4`<h93aNM-9uMVRZ+h#UrR$^188<6dPkWlzoN(#guA@751*I3yHJTZcwK(Q^
ziPejO(~c^$RegFrgOy{%HNs6-wH8OMlU9_jPhgL|Th36bCmX$cwd(G^)jM8$w+ChU
zdbbBXyyY5pqC=r4Q&XdJre^5MC7!$jn^vt<IjcOU;LPKmJn5oUsbOm)j=8xB9;!U2
zWNu=7c-6+N+d<9zvD@31_#CoaHF<YlP{ie4GfU}JXHQN#=+>Q@sCC<GgOW68cdx{Z
z6UQQ^)k~x{riN~v`L4fxLw4r2jN6LbJ~vIir{+g(pXHgDv$e0v@@dGbTWptfjy!EO
z&g^T9oN}ml5>xb?n4Pcl=YIP6%vtA5OV5eg_~>K|kaYj7UrzL@;-tI5v&CM`xv^Hv
zFw9KprfyHhv0ITjQ**MG8f({!EK_-CT)J)9vPYH{eST`ka}AYE1&$p%;vmiHc63eB
zty^Zxu3N93du7hC%-EzgYaXRc;!t++&b{!=+IP8bs2@+(p>4O)m;)GC99&B8FsNRR
zo_J|jm~PUx?Oxk<F1jtab8V6CnoBE~rB>I~n}&v#&z6=JGc)X6%)029VQ+TscCH`!
zFaAfZ^_q6=I&>C~$jLrdp<dAR+O3$a9Ztf=#>VC$Th~pVA1yX{L6yMd`cM3v+hAKx
zCl`DYo1U?RNlqwGYs1tCuQi}aJ5I=?-sFW}<YcurYz;TNw(8lft1&5xoHJ+6oSAm#
zsk1Q{7*4)eCCMqY8m4~16?rFBu-@F3`}NB|Xmmuo@30JXak^!D@N}S1>z3-~X^T|3
zGrqHHL8P*j0=D%R6kTyym@D_->55K}!n>2@XN#G2AD6xJLEoW2<G^agDbIDa*5t=Q
zh7oVSKJD#uuL3-)_PV{MGW)d8z2d1ApLKPOjddsU)R;u8a_@Oy5!x|DckvyW)q)xz
zC!pFB(dl$cL1v{_z_xx}7ca4k@A#r1s=*Es;0sxbqA5Q%_HNbcdZ|_SuTB<>ldfmm
zoXO^Oc8R2>rdMLeTCFLJQzm(;9Bo;3Vp7tPX0IU6klQ+&cvV%VZd!AJajoyRNS!My
z7`T*_mYoWksd93XugN6e$wHyqX8W2<TstvS>$arieBZ5Crz}|+%`FDr_szf%wPn?%
zO{ccpPFZc50PcJlGBPqUdJ3vciu`@2-pga9r)tg_Tb?l9c~dtYujPN+%!>>l({$pX
zc{%Mr`z`c8#oYV*U|-DrMY`YLN9dn>`|EGrzM9+Lw;ug<*FL)T)}x=h@~_=5+i~*K
zeegEn%B#OLb$&d0>UO{KdG9Vk!Cw<N8J1f!*6gcmU~)Kr+_Aovm+#$=`!%5PlN)Ck
zwYQheWyxd?T%55f>iqqCfB*jd0|H-PU%Q>VePjM4ffhxsyB93a<s^38_tbe-tMXUn
z@|Jhndw<KmWBC2KzV7eus#<P_zYAZ~@?T!VYwWQ7{P}bC><|9P^TQ|IU<`&IpxL<k
zKXtKpPsDFtUw7}_v;5T)e|ehUUzhhTV}9TB*I$4AeE#Nr^wG)tRQY@Pavz<%F-4&!
zqjdW^Rl8aH^QXPtz4f-yciFmwlf2(vFFdYvQFz}cy~@YoE(wgkbBoK0H+#RVt-Br9
ztg}I}Bl*35ZAjQg*NAQ2ws()L3k?ko%}HaJdV6=hkf#by$Kf2;jul;#JXcOAFXMh%
z{5f~)+QtS3>D+DK%Y*(gFfj1XJ{SAG_WP2}UeAt68C99xa<n_UZG!*(J=L$IYLD!$
zW^3QE$xr?E_xbl%n{4jCFnQX)-|uf<ei6a`*wa?!m*+2!pz>sqXPyW90~p@R*;Ih0
z-ay!qMWFs~Q%&@P&dA5U-0yZ@Kdky-@%I^vw7<^{3@iRVJ7!lg`+M)Jij$T~{jj*T
z^!1kYOU~`L-RiZ?kZ<ym_i{F}3zRCqPYn$Xjh66Q1d74c`YV^sYkd1YAvk93vf9|m
zOH0FZ9y2hQ-OfFE-&19hr^30#VaH03Xg+=@6rT5e!rmpf>+|HYOs2-PP7b@NGch`G
zqG1cjVIVBv$nxXkqbZSsHgdDiYt8%8>6J7k(k5AQvZt+9)B5U5wjV|29r2$O{A7xq
zO~oN4r7!d4Y=UNj(#e4}PM`n|O|?mu<cMie<oM>N`)ZEU$xo#zmsfrbS@p?N<>dVJ
z*I$3N`Fy^<`tIFBN<mja8eClJzON1a`2472%1d4AU7uyP9}KxNIWxL~J9p}X345Z!
z8@_KnynFBf(`8MbuVux3X18;H+UssByPdP`q{_5!x85@4nQjaX2@DO-UAt|~rbctA
zZ<pS#opv%mcijcG$I-fz?j9)B7vEf3^i;%Yb#Wy}tatrU4%RofbML+6-pwBLvD&<P
ziS7+{F3Ih!(*j*XLsJwv3Rc~A+%qe4P4ALz4?q&VOSU|=?bTZbH6tx|%_fswpWnSo
zo4xmvc;UQb(}S(=Dmw5z`dDoqt{3Q{weIXej-ojySf9?$-F;WFjCseNxU=_Oa+fh4
zYRi3?I;B1^G&GXKNk(hig?zPH*~*!^J3umzq4dMlDP$^mR~?;oxo<gJ?ssEQz~yi1
zp0G1S&*7fu($h27Zp}O%+-&wcS9M+e;~hFYw{LQ5ELycZ`b6x(<V`ntpIr7$?Nwa|
zmbq~$TF-*p+3dxpQyQyQg?$od%r3hHQW27?y6JJl7UR6`ZB}ztiY}bpqk3AW_0+<m
zE{&(qAZxuX>o>_VBkkVLpOv+7pMIDu_WkAm@Y<H!l^eHDt!l}%yq#ZPANqygdE2r%
z(s%DQsxM!(<6g@gr$`5ziVr{LNF0;9<ScPi(?^1L-4(NCvvYIZBRwKjr<HEebW!wF
zmdxCi_Dtg@H|S*b2}rw!gJR3;vYxKXjX8GbnrZRp&--eAetzp|axo_FC9}jaK|w*G
zDU0L2?*$E`@7{gA9yCb-8;EtBx$Wlcx(!-gbr~x|>vDvqope##v?3(Yh~w0eGfGP*
z8_65qN!3aVa@pkF?iv)@KhJ6<Phw<*@?p^#$wG-OGmc3tJvDdM8H07KF*`OU6o`u(
zCE3iL(Q|4=Pg#0?s>f>2IIYD8D?+AvUt$gPpEFfyf2>D+XSmSRq!5XfUWP#-Nt41f
zJ+mWKCq;Q(3X@0;NexL%tP>GGQd=#5-S(gF&Xifp?t97mEWT}$wovJkzy0*{Hvi)7
z{@h)CH`eZkMVeasULWVhDK-@!y%G)Y_9&GrB?}x;+_v3%cj~*?Ws||REadE5=rOTQ
zLSFSEnkqSy0{V*Qlo#)w^IZ1MFQ!$0wHC^AOi@2HX@;Z7!KNiMG}V@BigBiDa;{jl
zSRlwCuvJT0$jPEhYe#FsO3kE}Qz~5tvpQPqgjRK35t<?|6tsSlXKrrf%xRuI%vvkb
zbgpvE?3%eUpy$kisXd+HCwNkm8GBZ=otfmTGE=3qUM0wLvf2$@-7VKvv#u4@n6V)^
zQuWiM4W~R`?A0<@bWF8JTheinv>>yRpxKQc7o8-7quy?YNd^ZyeYBi4HD6e)Na+@x
z>1H@JEXn6+T9Tk3i&Bz;=j_bMnI^Mx!Mh{fj<ob{OG>$vE8yr8aB6AF(a4@tlBsQ>
zK8L17c%7+F7BK9b=47mGG<BMaVaPIN9mzH~HOb5^6HRhDa!q_Wg%Z2MLbQ68ESC)0
z*vXUF!^H2X@94gO&#7nAnnOp7g_?ZLIy!o{oHV;E*fd#jQevV+WNHtGvs>mCM`g86
zNp6ufCxZ;9ESwn>+2|9@wMA1*XOoywn4!_qq$$%h!&~Z)%v^FtB~8lb$Sj}9CKpvM
zdm1~b^%$l|PRrDpY_u#QLPKX`>MAewDGL^_xw`3W=n4k24GdWxx!Y1U91UA&x;9m8
zRTq1M^1J@N<;Rt`Zq<3GV)eiMM{4ZB4ylYX?YUQc5(NbXB|}1|hK8m_Dsrkcu{0_%
zf+o~jgjgDtf0w##yB&7_tq=dT+T@pgv-&m%TmAX_e*OAov*TvHSZ7|+*ptlB(b4G@
z$Ql}&yW)hCry{3Hi^?RB0niO{_Lpw0tuLAWk&#hi`W;3_;mLk&?32yzOEQN|+cLQ@
zU59r|2Lg0X-|NJrGX1SBvmBFl;B>{wjJox@Yu8>lzIRH_=5ogGj9=_ew7gWYP`~M1
zYt*NdwNhff<^Abze^!05tF!t0QmKw__2kdFzfYF4>x=puav#;`?0b_ayi-`BjU#t$
z?A_hZ=RBWRzI&TeK<nD*XqP2U*Ve9Gn|14!s*<3lK&Qtnkx52S=Db%s^ZVm|pDTJ^
zKj+PD2HRyf7+)}yUG|Du`GeEKzV#1_=)&A5p-&g>WpbJ1#CSwea#>IMve{Q!-sP&>
zotq@&d0e{s#(R^=$NNQ=3CrF%q+X<E$m1lPUA%i++|yf`#@<NR4h6J8my$V6aytnX
z|FP=n{r<Y&q0g<a*H?!;uX>*~=W6KOcPX-~cGiU4S^uzJARw!C`^4~RU0)e;II|{I
z{`mQP{`&cKC9|t{wVR!gJFU*ReQ)1qPjFT@U^D1|+23%}FLrs^`%b7mD0d;j>@O%(
zXW#Yo^z_=A>bJqO>tmZ67H&IuAg}RG;r-u#{?GqXzx?BW`Qz^&{<B~IvtEJ0rGtUR
zLx`n=fdNG8zx8<MA*2V5e3rf^kj;w<9zqHXf{?SFA#x2ajS3$Be$BnLF5J31gRy>c
z(F4=jy1RF8G`n_tYG~-TRkxb9hK60qsh{MjGRXnlE(Q_ox7I}`XY5{Aw7an(IOk58
zny`e6mus}tR<>2!w5~)z5+EbkA|*y41wrMvF{@`?*VwM7V!i41+ygHid^h)9N|snE
zDCV_FYr)!8TSIkQR3-^bfH(@`$lp_AR=2KAyd-<w?0HhXOh!?<#apFhkwr?XSzRka
zw}x#Ey5Z!h$N<v<@|HblU*=5T^l#pGmq@E?BX7%m06Ne)wE6%8!%qgG09D7Z#I2DM
zms7OP^cXR)ayw*Q6Uz4V@DTOwIdLdtQ<&;(RgEmJL&v(VF`7<elTu-*_m!H^C}p~V
zaqS0?{~4GcFsdG~aah3hf~n(%l*7-h2GI-*3_Ld0{tdsT1Uem@b1aC1d&8|04ciz4
zqUYH#-+i7|+CKMA!I{HeK9e~o@%oz@ty;{Iz^FMZC}^@;<1&ZKw^jx$FkyD^d^O3_
zt4CSkg2<#vflnn@n0%R`mF1;b@22d_BX?o?&hJ;uLeAV;ZJd?slDlT&wv*C9u3=fu
zTr)zhv`I5_&B&R!ZITv*-wP8LHCWl|W9D%?rEAuNL(4=>l|v4#xiW16N6y7bJ!_XO
zQ4EqcNip=gmencZ)*#ft?6%l(ao_?*4F;1elVmAVDPE~wUY7a=3>Q~i$heY`p~}F(
z>A<)+aKXhD7Z|26Koqd`x;48kc6J17k}{Q&0xMa#U<yOlmW-PVrZ7kx>vd~u3Sh{%
z8gX&u0+=>lmIVwTL$86t)NplJmzGZ8iWQQsDZV~g9l;?^tz5i;DZXyOsX_H23$9(x
z71B~#q@}dQbK|z&6)SGLM%?O_&NwQ{+I8%xDBG2goWOuwH_(0NU0OVW0TH)dyR(jM
zbahM)lrnYe4O|?Ou~j6Cw~3*dg^`u*;8s!AjAL7)BsVUcDlMHQnQ=8~v8&s$W4GNd
zu1edormLZ=W9x<_jTKWgyKc3LXy?>JE-=?lHPg<@2^KkVakZ<fsFayWR!_3qii=qq
zH&*l{m@V|3v8Xj?v373T(%guajnXNrjtE8vr0TeK@?0`o>vrs#nNDDsnQq3STV`fv
zT5Cme7`K_^_6oWkkhpPcrS9s8wMmPXY}+VyG-|@hMaNbLHnoMBif-06O~|?uP`~Qf
zGR`#Puw!di`P?w=4Q10Z$=&K2lG`N`X0|w3T4SLzZ>ZYstR}N-iaKsfR=Y&qX323|
zVKh}pa!FJN#9q^lu3K`#woO>FP2&c0l!>b}L$cfLEHBj=M|oES`EKgnw#e*4%Ehf>
zi`I&EnQdyjsVow(>b7>`Bqg(zxsml#%|z2~ZJTUxQ=09nblBNdvqP4pCTWLG)VeC2
zlf`k{WLDHcsl^#<*M!Y*%{gSIa7#H%H^<c_H@A12siNn$Op~o1LWi~mZVsFns4N&b
zBPZ-CcfyUeQ{7Ij2+K0o7P)bfHBEI@&sE7uVOMj#GXuA*y44#k>C}_5?dpbUxhqXq
z)|;(O7Bh@$(p|ftcSYB>j%!yXHg=p0RLh;T$VbX2sx@`X#uX=%e9r1_R85Llb}}LC
z=9U>-xz0vTO;gJ_GwH17th17n&T1Nm=7!96PF1_ebHzB&=S0|Tvn4a!R`jlR$<6f$
z%FT}4X6&+dsoIGflT!m{2BisY>om^gT`^ni$i|uVnmkv#mgcUR7PX)^FzaSZ*bKKL
zVoDpMlf$}>1WGLyS`?kFIxS_zG?8N$0~Hr7a+)2uZA~iAg0)>|L~c5@n%xcy%T-vo
z<c8{I&o=3#D`Bfl7bho2=LBx{&h?#S;4S4lTWjj9D}p($+ivu3o3P~CVzXnJA-6it
z+*-S8bxP!lo@)+CD>o{q=B(Nx<(A~wb>-@ctTRUwp>$4CYr|~buElI?PNa2h4mR2B
znzrJMglU?yN$9MZOJ`}Dx+U!UHMy@(qyE~)FtaV8y(woMqq(GJW+w++-K>#y*5``o
zhJ`Dq&A6N^wk3DbY~G05Vk>UD`dm#$<!?jm#9R#BiFxZva?mne-&uxkS{HlMT7=Vd
zd$P04dY7H;7Tc0LrE77n)HP&Yz33Y7<>yhR6K;!Lj5@k#wob;?#gV)lbEQI#ZBFY6
zyX-Mr>6&4d;mTmCv$G7NeU);$BaW^(b}{X2Z?3`Gu8UhDHz!B?XeXr_b(%_R+}fr&
z#k1>{c5;?({jLZ{9n}`$j7w@KG91l(9j1XdXx=jE+$1I7J2{|p&5T=~Y4y|A<bQbL
zn{pyrU|WPKkExi{)HaE%5FHyeKC#129MNWuIk%kzwy`L*n1~&_(32Obt25c~(6Lut
zVQ0<>Zfo6~B$m8N)7f?7Bo&|FpeaXY`3jlc(cPRRCcR42@zCvr7IU@k+%>a&X8Ep_
zGF&VrdFWWFtG3yVhsW6pqSmexaZRkx5tw#z){ZOMv(hH)NpGF8mTR7f>)Jiee~*Y?
zRaxrMGEvIx#xI4FDmVA7Gdpf}Q%K3$?v(1J+SQ@?ix1B(n8e|`P-T*nlJ#oo+%Jb;
zwC8SIEM>STGVIdQt?L9uw{F^6x_WJ#7%yAnx3!`BI%m0bE?j7+<Z@BTV<JaO+|*N>
z6<g|8-?$od=H`ZJ{EKI9H@kTz@9>kQshU16fr8DBbrR;UrdF+5yLqw_i(00UQN}Ej
zGhZWC9q;Us7xJy!_3E0`L8olB&7~b4YDNq*R;*ZYJB-UL<94x(bf(I*X=|7D_EvUm
z?AYky>EhXB5YHq1)oXim;L@};VWHcKofVDMCV8rK)OY;IOBYsBQj$`3?GN3w;^4lC
z+h!$a%-palsO@&%lq-VCE^Zw?QrsU7?pqrABv8~PP;>#$;f}L{f=Ve$g2s@2mA+~d
zJk(`Q1uUAPmpprAw0F?9NjcBd+%BnPZaelP<CjA2RZZudOA~``O`5=QF3%>-?d(S}
zjc$=ZR|%7P=}&8WcP-o;wp2r&#VBgpli5jL_e5FqL<Mub&YTx6$~|(k_lts{nTc9q
z#kt&tyqu~NyCQlvPBk((b1G}v>7Xflp9r`Jva~Ez)L85)rE$@%%Oo)CVowUAp_j<j
zHn-cyo>_W@t&LjPA>AY`;8UDCbuCw-#p5aNf>V+eHXWH6p+1>s;l!zt9!W{Ln@m(P
z&#!U0<f3v*?Uq_+$1IPQ*)F$TF3j>=HraJ@&?Jp|r&+zeF1cr%i}?(XwJqw>STs48
zb@N&$9T&H)8=`ol4w*zvo#ZHaT!?SVQq%l}jgx{HPO30YijG!<FjuYiG~ALIYF62i
z+^UnZx;f-bTbQ@R)RrU5J1u>VY}V{qH7VngUtUh5prDcOns1w~9b1|-b>?c3g9)cr
zBwagpwO(1Puz5B|+OruRd8dNZS~VtgPRo*1x^QAe=Tfx;Cxj+kax--m+qfocZLgF@
z$5F3PjbM*Oj-3gY*#(a|7jI5pniVEBY1Nd33*K4FRxnNL7CojetYz7gnig`*GtFU>
z&&<{yedY`CrMg+suRWEIJW}?I)h?aBk<H<VBzt70r*Hj^9I?A8Q>S_A3Q8%=;#}s^
zxowu`7MEKlF1I`ll=GwRJr<EzA9eTGt9Q&RjnX<gI?~izniK^#emiO=8lAPqXm)5!
zuZUZ(l-bsei!P<68oAw3OVQnMH%rpo*yW`0jLyz2g*(sAUK1FxEN$6BUq=~p-s3Xq
z++k~@`php+X}cv_Z*Vl>l()LXa;?p3j~jQ)HfxgZvn<@ZqN*v$FzLe1I31nTlthD+
zX+|54x@(>^7M&UN<j|(bw6utbnO?_)CEP5;TqP$)PFl06*(kABO4=n^B~MY&q$uf3
z;AE~j%RExn6>axAsTCFUyMb{51Fz1cNR?{`&hU0J@Eo`?K~!)>SN(=FS`IvimazIt
zi`>qgEgI3|6LQKUqjlS{wGo<LVYfLhbIvGA&Qn&p9m*Qww(4xCnc59s2^SxS7LLUk
zi&nL4Rn;*`m$BR~bMV+vk+#M;YSy`HS8dvIa%<3<j>aQKYB%m&WsY>4?B=^wck7gC
z(=MCcyxpgiKKsnXZIc`)3!O@>4>RJH*x1=2D5ab$*wb<2?W-QfjV+5M4rDdzNCzo<
z3LHq#36SDt+@^4aHAtyhO$mOjw6IUcQpMCIMiJhDJ+2W)lXSz5c1!7moaJ;o%%kba
z%&5t*c2(HAxr!lcXDe79$Wssvc5qu6xoPUkXpY;H4VQVHX-qYeNvS{BGj+nOM2&4X
zPn^9LxN5~!m59|+W<9emPB`n<Gpk1=cgn3b*@CHp1{^Ji+|D_iG4eSYtRr$JD9vTn
zflW($M3YVwYphF|tmYDFvU=O%pq0l$(!!FKrA*dwmQ<Z`B+S>VC!_0_W3SS&sfJ5t
zoa(;ixbJ5Y(+b`Ot%eC38AI3()QdWJE;#7Mav@<c)8CFGw@W5%lv<!1rEw{#>txPS
zDPh-5Q#1`lolMPc2X?JHBFQX}A{t@FoqO$exuC>B!5*m_%nnlLrZ@>IySQXLmPzYr
zH+H+RP^D*5uxQsLuS*{3oQ7SThLC-brlvg8ZtFcTVO*<qH)>_sl3S)yCs)>+^}1b=
zPSR4&SaHkOb4!-lg4+yPGmR8FCQQ{#RaGsG_AtoyP2lMcS{uIu)OzOj%rv{A6~c6c
zK@_z6F`G3YI%uhL0>jFH8?0fca(!N|$W!K+(b41NxZO+BZK9Xv#x(7TZGkB>BN9%y
zB>B#GZk*9mP`I;C(8R~ht#eUIeV&5LO~GX+XI<Rl_DFTjvMW*-ymFhaNIIz<IdbDd
z+eH;0?c7q+A{GT#*QCX{Cv_zzU5t*^jc#2O9d>2yiel$JrDBtbyoY28S_+RnvXq<>
z#3^vXf{)pvw<Y7o?>QTlTr*8glZ~^|mSu5f3P>8=3S4yTOq0T;jGJ1)Dr+4&80t?>
z%Jp0`b;)WaX0>RajE&12MMP$qd23FZx)P+EjWcYi*3?CzzS3@9D{?329<i9J%_pNI
zdF0rP*@a3Rjb?7$IZwAOoOM*kNL!4}=SYg5vT<+Pv`ay=qr@g|$xN9NmhGF-({Yi*
z<%sX>Y0{FH!`3Xjam~z3wA*dtw(UV{FV!pY37Qn-c9{h(WU%0Gnj$YUMecoXZVmwu
zv8ZF4QN+bXx*L<lHihH_hIy;{&Q4kF*0D9&B{b!>wCgs*rPEfLU2%2O-Ix=xIO(9E
zno)?Tn#u}O!EIZzC3GS-b2W!GDH*!f_c#iKZA`e@WyW=5rO<}3V>i|+n_XRP7@d{K
zbu_ctE9$m%a!As)i`#TP7wPg`-MUG#aoeSi8dvql-zRx0f_m$opgI@KP`TuhGD#wF
zlBdcnPn8KLRVI0=Oa{#}fEZvwo=MI;Mj%1ONgj!9o+^{_?y~e4dGbuoohe~>38r-R
zwwEfCoWYuW!6Zmx$%K<C28UH9d78kjoqTSF48JGbsM|1;LXk|G<g7B`FwZ1UmAhLY
zP6UyXDs2)eAcm*PBsd$!Si9|Ebnc;Tw_9_!bKTwzCi8rZJb9)+yum2rx}EEGp6Iqa
z+POPCp`Mw9n=#o7ra0_&0g}1XCoE$YpRTZmk*^+V56DcFHc!PiNtH<+iPM&VbP9pI
z4fX%jZFj%_{(p1khQr2Y5@~6NdCuHOoH?7v*f_B*Eyv)@*)~a-)U`{uf~M#$?|Zz1
zxt#I%zwh(Q3|pSY-930a9mWWOOvs*llgxRle(&z)ZD7{k2I~~i)aY*LBrbIF)G`ap
zEG~Gu*TH)C{YdND8eH=5>EPPUyCn`4t<QV#7QyK4QCOAt;N8<q$h0uRaWGe&4isv*
z_wM%Y*Dq`S{CS4vVe{kF=kxPLbQdw6nzEETGgs3~>>>lJS5WJgN|19q*tLSDfPyIh
zaM|76pRcak8k)6ovS6HSJzJ_&qDqigMzfa?r>2YBlu0gKnJ!`hoD)5LbvbjkXf9dS
zt>H5%QBW{-%Eh2d-YzaK9o?==IyyQ!HHC#$7n-=ZM6H?N68|lhlT#&4v(r=6WMh|C
z=0>;3z|D2<gd|%vH>V}e+_cOsX@;B7q|6NFpal%4422T9bQ%>^X0}YKXKC`;sJnK_
zWS?mlwkWP`)bvW3GU;+e@8(FAQ$aJmg4S$Zz^K5xRyTvegUP2^;nD&I7Emhn@buL+
zo8$#b#gjaRGM8P>R7)_qbU9NkVshGS-zBp$Jask-g>3Rvon{s>In{xIH)`#(OY94$
zZZ_Oi^4tE;Pdop~Pkw?nc-DhAcb))k>^%MSiwPJ!{?YSKz2I+3s!F?kg#R3^@9*62
z7G2-JJN5I%xPOnI9`aOKUtjp?p~|H2{X6<+FPW5m|8By*cS|P4-`%Jo$t?Xdi=$`q
z$K!@|pU=x&5{ddfx98{gZTpuvbR-A-cpPr~e4c6T!;8hmwdQuy_Se<(?c619{_^aX
ztMT{u{rggU_r3VMU+c1rGlHi6{ZqEq{uhH_UEKG3zwdnd`TpbUS>^msw4a+9T>K)p
zQ9(X`QN$VF`uTl3qOaxtvFCq?*u@FnwTX0_HE26${wL!X+h;I;oj4`2a>3t)CTnz>
ztD0ZebD9R7RQ6*2`mSwCX7xh0{#(8xdoHlQRqKk&U}b;Fty1&!*yH<s*~?9S7R^2O
zr&81_AX(txA0;FI<1$BopSLOUar1ofddBX173Cg>4(@xNY*%x?Ht*;6uU{NGl2sf!
zlKJ~AUc7p~=ksyf_cr49WX1LF#OBF|mtQZB-_O1-uf0CTJ;S1I-KK=!x1UTpwx(I0
zF`Z>D^OjpZ&u!m*`g}iZchtZAd&LW{{AXa&KYj1_{pxw~w*PF)*E2BWpZU2f;;g*O
z>YqG6&-R$qvafOZ5^wG;x%h=`QtiGO8)xkHi8xbN<+60r^ht*t)C&slSHB9H2ip81
z;K%}^1O@dUf2rSoyZXkL*SX&fwr%{7nS0sy-51&CdtV1myPzkT%h=y($guDAp6|=o
z#@W9AuzSyvDc?6|u9nGMSN3kxnWT(O_d@Ml>dtN4u<z5mDa_HTtIc-rzFs_i`uFdL
zoWI|_dHeSR4ZH8Vm%dLwsoERKX7Fxn%Er|S$L`tJG5urU*su4!`p)P2@{f1qFYH>|
z^Ln9XisI{+S}Jy%JiOR9KAN%&<VLVl1wcD{T}>y2-nr|#$y;TD^xjK;($DS|*ye1T
zw`G#&B~QkUTubAF4{%-kyn|U|(J3DN$TUNf$h7xjH+y`QPOAp3WUlIP5NpUzS-gem
zw(4YeBc<GwwD*o1QuHs?yRMm-$ZvgSnrVu}wP?BZyZ6Su`}>3c0h5!b%96FGd>9x&
z*MTz#Wmm7vouFSX^Sbf1r<DWO>Q~yuyFC{i`Z_IH*mYWH5!+X82h&ZFW~@DTpPjkQ
z_VP-e5pzb$);+g#m(9vt)|<w8yD+}YDts~r%iA40Co_~?Ilo(0y`W_6o_es*`rWeH
zCtDZ{Go6Z8Z%$gZVwFIPPNu4Bj!XXRQoXa=ZsshIxU$gl>dj3zooshC6t50D8X6d)
z=<;<^(F!NFpWB13Zo92JMfv&)cB`#9+XA>^z9-KYeR7CFV&|J*2|OU4%(<Gdd!8)}
zhQ)XLYQiUTFhpO`_<8l_#?bnZP!1=tJ4;r1Edd$y=63G1Q;gdK7C#S9JDtk$?G@v>
zwb7!Xt^uvW*E~-x<dA-L*E{TX&bEO5xCJt=u7ccCMbJGEwHrf2LOB9$Q|7D^Xxx{3
zWoz!X)2SR^>%lg(2XM?e9-Uw2>s!F$m%Mhl1CzSuwOhMqpWO1-^njpc-?n>iW}VJ-
z7GIn9HJtZJrbCc}k#=qL+I!7htNnSm-E*5_Sat1vXu;jPhHIBRyq*2_?4vW;`JUdn
zPTg&@SFMh>c=qgezF2a!=izPFZ_l2)l;hc!#O$|c&!#3a)^n+wGA#D(2-{b9_UyJh
z*8=*opXu*4zvcge?=SPd_NszOLJTE*2_<uQIGHCeQL)hBzidBy+lkEM71mBw?aRG2
z?ikF|JTUL;?VK06YGx{YC9|BoRSxdZyPll8y?D#?V>MMFEA^y}4GyQJDTS=m>+MQh
zoR%h$bLKGb%o&NBjd|;(jSVhtHs&!)OMbpvcY1lD*uyY;o6n!0pP#SKKmGFV_2p~|
z!4k^^1vNT3f;e1P?R#JGd>vv+g{5Pn5YO5D1{~TiR;~D@t+^(d&Bslf+qK7NVY9Yc
z7&FI=o>d!DLz50{II<?$wI|WwKt|w1&9E>xpTs1iWl77l>qS!=lh(NLY?$E_I^~$k
zku#HBI2?M7d``~P2{YPcv?jt}%_QZ_WkxDa&Kb^bjmvs6CK)agGR{m2lSm8N&+4<>
zKu>UUM@moU&Y4FN4@%5Z5LP=mS<qaN<L$CSp3aVTv*Q95QJacp25V04daN7K;UdW5
zq+G1H<Jmc*G~dMnm+Sk|iaVA2ES{a{OE){*Jm*}v<;=ox4ZkoWqZy~ATqdWuofJ~!
zc=q6t%uN9owMUkg66S(SJZI0!aBjEAnQ(R@k42kBuZ&x8PjOpJfy@fegW9EQv!jFm
zx6NS4Y-4y`5Wc*jB7AwT0mEemhOaxcFCVbczI^!5-qM4mZ_mf%#}?Kr#8yvy-TQi-
z;nvdE^LD+M<ni3nGgDpeUAdg6P4&(@m2t&WCV4%#^i-Kt`0mjK4<`<@X-$r7moB)7
zO=}Wx+_L3~V`hemB8#-QlW)YuoDj99Em>*Dx|0@atjX$}bxh~x#+AN{#Ue8{ELycI
zXVzx#EbY|EI!!*CIM+-I^VSv2iaDuvAXFr<NjW*}qN_-#%3>u+VUbg2SG&$E-8Qr1
zL`#Zrx@*G0=(SU~uDiN*rsz!3S!zc-mkJv-hn&e>7N#BT!|Bo%aN@M8tJo7S4<i@D
zwHteqHI6C0y0+`e+EtU6E(xgLu!1={Xsy;V##IrUrW71`lr;6Y#f~{HkNa+G2Yft|
zd-!0VN!p#ZMMnbNd^;Yi-LokTjqv%n%~Q=&ML2g^xvSY4kt;`Lt+-`&<4Ue)*0XN0
zW1ZVVB_$trJ@v_oxXm1$v?0rE=~UOnQeDplE!aBF3Fq9CI<sio)fZN0S1b-*Y*n8p
zC%QW~LP&Rwhuf{4UDtNGZk=SB+q<=Q)q%F#E{)r+mqZJe-RcfAGjd!aW$B&M$DH;^
zD5)anoJrW#C7oi+)~ZZON$xmxbw*fdYUL3>$%*XzX2~bF%u={raoHtv&6;2}4_`r(
zfHe`*F1uXlaPvLWJR@C3YC#5b)zqk`tg^B7UNI`CwWr(YoI11PWXR()=c0WT&&kX>
z$ye}j;iiN)Wvg0NtvS0UYL(EcJvYxzPUqcj<~vWOGgry&rjF-k)h#nS1v5KxHO;c6
zi_@npay~n8$F+2)P3>xT4V~H*Zu?3KwD;wl7q%(3c$98d@bS&@wHr5vq#Tp<Dx4~3
z$aBuu)u_JL*VkRC;?1qaXM>X(S1gKC3R=$;QZdOhZUTq)KL^Jsk&M8poJI@P7IkK6
zOykrMiWHif;uYEyk}y^JM}JNIjJg}%s?+4A+>5B@l=4=YHRpf$dHbuMpYJc99`yJ2
zs(sf_*B+>tQ=%?sQ?b0oD}g6h)nHRFL+-lhhTAdQ8B2BRC(VF$3p7!?3cPJmX`0|3
zgZ0k4=ZgE@)i=Zkao=0vex&IrtByl&kg8P3qLV69r*icvdOgx=Z4Fu4;Up2XG>m1%
z)ljDWTLV^IVdb<-bU(FF{j7*L%QPpa%FiLn7ahH?dQ7SER9Ww&rTE!@TYY>^y6@_|
zS+nEU@BaFI@B7)d;^%5Mz3N@2xivJ*#p}cg&y)_=Rlo1Pm-%`Jywwr1-P5C!cjoqI
zog#lXx$^(fsC)XheR+AQf=ENj{E0n(W@Rp$GuiLx(o`OYWrjXVN`XQGO9Z-W-&ey;
zf$n-2QVOjP3jdRHwtw;4Pv&o@Mnwz8&2zi;t!crDSy%7={CwVSR>nSAZgoG->$mRb
z*{Zy+l(p{jm(%o73YHN$wkcNWq)$QY+SBE%x9)5&(0!e9@^sbJCoX=WPxpESuicyV
zY1@^jaiLG#tIPMkFW>Vl?cw2>v)lR7@}%4OWY`&RBpx;Ay<2~K*UsI$>v-GjCBD?Q
z?~@H<4G#UJ`{im?b3ldzL$<BN`DL^0w7J#&qgce6RjhBOeUkgsE^-XwgrjG-8aAih
zY6rXFy56x<rDxb-J-h=2C>=lEHi@Je%MP~%TkxE@k-zTt?y}pjxBb}mqkh}o?>thM
z!FE<?7__df-t({W`RC{7>)z`be=qfsR9(LL?cGi7;u1>@I(-;>*M%P3oa?;q+S47p
zTW{R-+coWW46HNB2<kw=5>r}^nM7h&(rg|>Ur<l;estd5o3B=_T6J|I187_KL?+N`
z!&R%+*H83eHs;#8Lgaw4!Rn}0*H(EnxO7Yu((@2qwKfYRu;2_>W@~7OW~<~3?Wh*S
zdI2UE4<Y-l-W6823KJsll>V~ZUXb=7dtLPIh09K@-F7=SY<1{j(QUUww}VEZpqTNy
z^2{?9=_L(36C^Lm@b=bUySt!F_bq4Yn^c}4PM@GDYkFEbAImL1_&$95Jgx-E8Ek0`
z%NS=iq=A_n3~p&0!7Q5XNAupt-ppNHc4~W>a?zawD$nj+3*OcxvBc0vDQKF9k<O-5
zC$8ph2n%x(@`Rr0>;U$-`?a0x!tQihY?$1qmKWWpqg-Dd>32)RSz?)>rcSfcX`Mw^
za~5s7$pOCc8bmm-bWBiz-3Be2*5x2(B#69t;1%dhXNB4aA`FaLBJ-oJnBDebI32Wg
zt<xpJjg2#NXD*uPG=WR&rq{-<TW1%W^6;vNaA%7yVVyYpwJc*EgGEC<14qLTYbgQH
z@&g9bZ<__CEmO@7$!%a@2v2X{^5a9Or{MICqs0Ll(y3gUO!q22@H{)iHAla!VE5+s
z9qcNTJWOr;y_N>HBrq^cxH4%evjPKys(;mr6%%~ignbPqRK9v;buGxq$Y5)0^wi1<
zxHzlfvI9fNl_^v0Lo#kPFtFEOkpBD6_><2xucbm^*Sy6xxT@q#+~jsr+GN^f52Z<F
znI_vfmh?_C^SB8*;da{OOkR&H-z5esTYWtzZaXPzs<@KZBg;!LvL)zJuHs5w&n<1D
zrfP0Cm6k0rRa|Kram`z)Q>o=rrnJhXX_vB0+&s5POgSLM>A-Ypwy#t#Td!MvLsBq9
zhAIOu%L2v)Qy5Hy8d#TVd*!mJ8n875Fl<?N*=@0dp=N`LPy>j6!HYp!Xa;nN!3~f}
z&W_NXvkVs!7#Pe{4Vc~7jx1xi;E`d#z`!8I!@$5Bc6)!>)%#q!T{o^SSaf5RX<%+I
zi=*3=jnOVHt{dwYbck$>78Kkh$;heVt)k)0btPccEvK12%K|1vDmsM(@J?EEG2_at
zi(Ohg6V~?XESlx(*s?WSI%2hFZ*oqk+cr&>)Wz8jY#TjPd)F{YEb}#rxXGoZyJX{v
zD_Lg2s=br5+}4C?cxx<l^IX~Mo3b|7QEC;()eUYdy0bYmdRM8{M=jBe5Ly(uZK}`>
z)ri}o8^UfbS*CGTIk4-*8D~>%(^+g8D{iv#uI9R(8_jjYv&rqI>DDcRxjBNXlykRC
zIkIAM+NDKqxl_z;D<?#I&eA&T>f0F^Cc5orw2*P8#~G2M8@W@W1v+QwoX|O#=Cxv5
zYqYCb=Z0;|4sBLVn>00N;+FcwMoY{(ZcUsOB+YR<Y{}YH3wi_GZuD-Os<~p4%M4E?
z-x+3$6K;u}I<weNb=JyF(OH_Nirdm|XmKYk_Ha4kY1X;z4|j0TGL54Wi$zxUF7*lQ
zGW6w8J2PWj54VPA*3m41t%ls85{pHWrW$Sm?TXc0$Z~VC*u}0{TAsabx~tvlFQ-Io
zOgd`j+AS8Ov?fGwOB7-!?52sLNeg-xM{NmC1nqk@$yma>B}!MS3%U_jq;Xrf>!MXR
zj$M(?>IvL-Njoz*qj%A*z*){o%MO`|UFo^9cI~Py$=PluZWnu#Ox#vFs!dk$Typ7*
zwzS)}ZsUw?I+4?s)UVle$zb88p6HNht+SCXLQa_qf7nh<^}6JCWXhzVD7C<uOBTDB
zA3P-B$eTK&OU>Z0$6>Dxmn0He($Z%vTdLV<GE39bb8EJTkV|y7n%j-5uG+jiA~!3R
zPF<CoYqqLSQk$3Sn3ynoaMn`KEn9mo^eH5+(w6Ws;xX}T<K|h-t5qM77?CQGDcZ)&
zv$9<#oCj1(tXg?Y?ss<XdT$}MNy09jOHOW+esb)GW3A4#lR4A8Q>Q9t=eB*_YMLrh
zD1DV{jahz2EpwZ5ZFSI+X)8Q6x)gGy-EQ16Vb0D!sdjs|>$ZK_UO6egi!*(4Qdo@K
z9Gq1YCX1Yz(vq_6Vt=cUSba;MvGp`>X;Dv=$<h{u2fnNf^qR^Onv-Rx<alvg$YYP-
z!^g!1kET3~n{;p8?NIH=ZBIHkb_%DkWcj!)nVq%jSFl1x;)KZtXU?oy<rA-^>EP3o
zXKv1H<KliWxB1oDRofoS%21e<;bfw0cKgvugI{h2zamz7)NuAZ<az9PSv$Xe)wWf)
z4@xWa3OFh`Dat8#bh=5nX<XF$aHW0Qjhh=D3%pracuua%NBPnXll>M4C;4VwH|us?
zoF~n;ZS9p+r=nAKq;9*=di2prV~JBKXJ)E(OisUSGbLbcRJ5?Po5n4(quL>BHV4cW
zySUZNcTL1p%g}CvV=Cujj1KpOCvIA$C{bU;(`c5tSYXBk-^n?b*w4Py_59MbyNIW;
z!-#LH+B)4;?TU)RnViNRE*Awlh0}U|WOykpb_x`g66y}g@bu9Zbd2bdT7Pm|<5Jxv
z6V+H(XJyJ1%vh7VvMXuEGR>~Dky+QvlwHoabxz3%+}PWbBkdU^trB6TbZ}e8BoN$Q
zFLA*<bdp57wJd9HZ*pi|aEP1HjD?*uP6oU7woK;8oTlj0)X=a}(i60sm4j>Ilu5o}
zS3jM!T5+c*FH)5=$SG54iOP~ot{$GzQM(?ps!VY7RN-3WZFV%!%cAhcnTfNHJ@Q>*
zGEv2nqhpqo`@$&KtXrK~MytGTZQ7b}k>`+bJ(H)Bz|BL}VH&x@g4>Fndp$E&s@*op
zvp8pYIC<5oDVv@1l-s-m)-+G{Y?+a9S~Y0e`-wens&QLO+9qD~U9q^3OX=oi?YvwS
zm5ECPB_?@fPBc=KR<@|M4x6_2Yj|OU>GrT~H@B`oxHvmBHI3`a<VRdb(<bDWT-|nE
z*=34br%8R7*6l2<r<MuN(hQCnWz3jus9f60YPQVy)v;g$0k1Wab33&bF0}3X;^U^+
z&8PIi+2XP166uy(o+bwm^Q8$cIO1@UB_eRfs??6iNyoGzc{$D=5fU`+Y<r|NV_i{1
zYB)E~$x4}t3cN0zj2R1f8&)VVtWaP&%D9C=W5psZEmiG$!-ZnERVBsDRs}4(aZ7M&
zWDDoEDVxmBDH|ylE)#WHxvg!%snglsp;J{?q?s<;9ONo>%W>He2i@STWX5pT>5}0_
z>#m&W^;{jH>9BOlw#`PT+;zOpaP}y7o7vp+xa8T^XrwryS8$UuNALFB*SS-bHZF6F
zxVqrh#*GqfxhcUiPwMB$oKu{s*%ZMbv}JYP)JUyKS5tLk&A52BZBbFp3YoU0Q-@J9
zI_tG`l8;Kxt5v;|rrnsDxN6lZ-U&`;g0`J0Iyy6ShSwQmjkHis79W;|i_18rQ+t+d
zOmvlS=88Er=fvi~@YJm;k424jj-2V%Sv2E_#Iazdlp{WghRqV;8^ZS1udWblxZ2gw
z9l`C8b=1LybCTEkb4o^@YY(#~EVz`##jAF~aYKfOr-@*I8?UOCw-)QPZIiYus4ThT
z;p>^^T&_7a+EP?&+GLBV*RHL&sF>SewsDcuZHBB+6A4q7oJrS0mpS`x%gfVP)S0W)
zr4cX-%m{RK&0x-DyA~;BQlD`oC#feV6SR|bQ=qG;XoJ~>tOd7tLweh$n7Dv%knK3a
z;F6&-%Xi64PBo8-N}j2cCQXjrw$)LsLn$~{!XV*j?%JQ>Aq*=6xCIz;7(}%gLRPSL
zFqkojCfrWgwt;N}1CyuPq{*7Gh9ZngKF3v>3^^y9Gn7fwmNbo=IjKI<XWP{x6Hk|n
zN!KpqMimxzytz6t(Xvn?B~Nj?;C3OOv!PvUL?c#RG~`I}6=qTC-0W~+%4tz4p_z*_
z&uGtBmv}VI;>gaN+!a|jg{8AgrUgu!l(BMQuiA-887tS!+SE4fXwKSM7q|4Pd6-1Y
zFz0@qx6#*W)@p?tCNq<cPWI_`tzWQ4(sZWUl8FjyBz3ZyOht`MCtaC3X{EN>8i@&v
zGbZ*d;W`;<Ix|z!bB)-vAmd<F&^Aw=nMSE09XvC0HA7BZn(B2@I4$GGj5Z<3V9A)%
zQWMW|Zdr0I)F&}5=~QHQ?y_mBO--SjHfwW+v8<Mwl-Ai9oZ{2tyKs|$$Hfh~S@lP}
zwuEfjnA@GZOoD;oO18s+o7-Z|wuZ)p%vK65vS!XS6HZ#2wd&f_lSR*u-Cz6ff6R&0
znG=e4mpw19nG_ng&!geTpRKvkfl+2qpc9zXErK!?8WM4Io6?qPi`8a(&JNRz(74(a
zuw=zGjWt<Ela6`Ut4>bZoVsn&icKM+YMfeJ%~^|X+%hxGneC>X9A?-ny5P#Ji*6Tt
zSI!Pu6?8gVTH;935eAkSD#un`T;!9@c5<uRO-<8i-K~j{j#IZ9M;dw^%TYUaYC>(I
zykpAb&(F(2L(?2iLW&$<hPSc7%oauPu1SHJGh5D_Idi7|%$YMCPQnH)iX2XnAR&l!
zTAHx2L5o^iT3YJN89rwY34nH5PS<WxOG`9{03~5#1CZd%nKLJHg4BRaJ9DDt%$;|y
z=RCJOS3Kvr<tgZWqDfnz2fXgO3YI93d2V?QWQ-2jez49nXHJ6*Y*B=WpE+|V4FV#e
zwt%Q<AnQ4tKoUrfEn0+d%QTQ26sLl;K=BN)A3<gt8*|Q_0p5mcY-}*IekR05gs72j
z=&`8P%~|VsSM4|*T96xhaBDc*)tD57*CD15Ai?^LR+krswn2`*?Maq6Dzush8WKk(
zj;y+S=ec$Lt~b!o1x3i&wlqY@r@^e2Cf*fbTg_HIw=jEt{^|Y?oy|E$EHNE3%nmEK
zp1{hfN0;&xR{|Yn3q8OV&Uw6hUeh<0YSxypfFn;cV^-(Z?w3bdoL@cn_4d3|;#oWI
zeFNQ*BwiVyl`LU)7;Hd;t50%3%cRy%&=d9qz}sanfz;ItJg+W$%e`b$E0`<psVeb+
z0j%i+x)Ty^^E85GK*q7%NO}T3`xbH#t_l_j*XOc#KIHG={i(Gw)N56U0z(57G;t_2
zaX>*mgq8$Nt-2Zt`fze3ICy0VN3IC=RGH+sIWRL|N<$-<YWCG&;*i#ws^$<R<zaF{
zT03p!0!E`?-(JbI&6>WmjhT&>I!+7FZ1h>C!s5ZRjKR}ngG<f^hE#>R9Snjj0t{*l
z2UHE3m^>PcI30L%Zf#@~oXob^t^U^Ous^StOp<JAU`S(25L|G^;MDAhh;7hb9TR9q
zUBOe;WXmm2LrKuo`ea|T*`CIX3JM(ArmmT*JiIoCL53Ejw%x8-bnEuBRo%JU?yvqm
zefsoyl~1AI+2_hVd-ild;O(DvMfK{s-`~BrTz{wj_Wix7Ki>ZOTes)a`g_;q*Ixd*
z`tCZLyQbgYi%+fnw&UdI@K@{0b|>4FUHz5v@wmp`&(DwTa%9Q<ozfs`dD-UE-`2Fl
zHS1cxn%bsq*|*8_>z39y&`!wctA5}2<~vN((pW65cCFfX0|RsJwtJIQCjVLFeaY;0
z?)J<pag|q>hhMF~y4G~QnBX6~KLw@y8rP?9KR5UD^K)`pCex3e-MD>ry>!j}xV?`L
zLqSD8@56@=7{M?)cYl9Y{JPAwGJmbt<s9Bn<5hlR%Gbj^UV%S;{P-|GqBj4k=i=sP
z_by!f8kF(iz@OZ$o4Yn#56bj@*PVay-SwQOyHoZ(USEG%z0cD1{d_xfm+80H1zNwK
zu&?7_L*1)8FXvU?yYKmYf1X&xtcf+<Yxc>`Z{Ao}X8!6EXyoV~!|vUkN4MS1)y#C*
zqB}kA&7z&Fw65OzsF=G|DJ0M%<EF~={rPp(_x}FTpL+i6wrkti7#MQ5-M-{9>&NW`
z#>(37`@Y}#S^53(yZYK12Ij9@Ud`^GE8BPDPVSTSCu*MTTztypt)tMhO1H_kAJ)}O
z{oH^0vG1>&pY!Lw{%Xqn!GZI5fB%71N=iyfhCMEwLMnese$9^eEsJNbs_L(_eZKek
zm3h094}09*aQ)K9l4&y@m#%UCzVy|ElQoMoSIT7mDZ2D})y1E@eE0R;rq%0i@htav
z9N9eYs_W!$Vc$-He0OOz2Z*{ItY1*TIOpm)H}&GIt=9@0m_L7DX!^^*^t1f#_d7p#
zA6L#@)@t(hWU=p0&P=`A?X!9-Lyz~jO@VB_6;kn-_+ygU9ch85D-=XoCwbnR<e8oH
zxF=awy6SfBzUdlT=c}&2uAhGX{MC%Bch}syy4p!J?9px4;Fv`-4g59M`J2stsSCQ|
z{dTVB^c@xq=dzyaO!8C_+IBy-y19XMSx{Zw-}`p8-(S3&_e<dcr^zhG@Aqr8RxMIG
zX4rpkd-c7Y{*||<Oq+YjFMM`V(S6o)QL&{_2HPI2U$!T+tbYl_;O%E(_8vUIRvgZI
z>3PbtySdx`%%7gSWc#-38N!9DCwafVoxND)`nKz-OnIhnm);InnHqOHc7gA)b)H(g
z8(zifr@eZ5N~2}f-6c)pK_8tMtIckg?{bX2VKu$`=I*-+Yi~@J-zVd}Cs%d3<eSV=
z<Gq*UcK3Wunf1>2rc`X@_fliudoNkbp;BB8vPU0%%Uc(-sKaY*t3r!~40Ok>!ny<H
z;t2C>>pyr--2vKR`$=F?w`%B-2~Oaxw`RApn|#(D;1e;<FTQnR%ksd2l&g;;wW>Z|
zn{-o9^NRNb^U0aNKCYSi`gmYL%JtkOtM0^cGn;)nHgTt_*XmBy2ODqZuzk*5w#{T}
zboar8w3|m}Mi%gBq}^u;^4JvW-JL6NXmu_~!H#;BQ>Pmeoy~p*yxUna@wBsbMeV!C
zyLY$zusCLVO6&Kvzqv~-p;Bi5P2cPPn7-M|<o;xTmu+SFJ_}z|tc=uqZ2SFv{$;+W
zjaNSS2mP)rzOqeZ-wft^p=WIZ-W@w}Zrj{zAGhv!@W6V?Yuk6<Z++imTYl!Y*_k^c
zlLVGb?5PJak4h^hO>zPWAZ?tL7gxHjyUq=?Y4+pi=jRVTefV52<)w3<u*3rwms@uf
zcBj<+e)sOz5700^WB?w-I=ipYG34jbfSN<cG&>|_YDSz&GFWu9Q(4M)o3UcVl9M4$
zCbN8wobeFwoh0EoqtUqDP}#)D#YK>Fv8R;hmb1dXo1C1IoP7;hJQ9VRlU#Z?Dyp4I
zowCf}%u=KC7uNJ8wsX$8lqk@<Bv-AFXJ=YUGDk7bOiyK{bV0V6M@$mc(j<fXxP>L2
zS`<7Nof%f#GiQxK(rGb)$$dq>W|x&aa<{7pbPD<0@>CR@J#mK~Ta00S(sRq>l0L~?
zlFde|yUrwRvUtFku)^SA7?*P6>=}mJ?x=^#yq)`J)#}5CuR^ZB-L-fQhu<p8+tybf
zK76%!dPvc$>9GYdb8ov{5<PicEzj$v>WwMuxF_#A5w0GybeFq&mg{DfMN03=xt`w4
zj@_LbwKYl82@Jzk*RBq$U*oDhJ@xjstE<D5rYKEO>b)p4sW?!u+)D4si`#wg{MyZ3
zieUUZ<wYgdxz`IXrn+V>Xa(J&dt}MUC7#lWT^TbDElOG1m2zTrw${xBU5339+YY5&
z3)!+&I&+KTiDf4pgJR5H7HK`*xYqCDrm2RO&Qnvnjg6U3Y?Q2*=;2wlW8>7jS9C>Q
z-ZGWySsd^*W7@^7X1y!7<gAn^x^zcLz+C0b)u1VoW^2~YRLB&{D=IuuxOlU^-r1r@
zE5gz(k3F|e6?L2ByY1s*c0<8!6LXI34bM8#d+ttVAW!dRPO;;waz6C#5tkGfi|E|8
zC3kJtNkMjYi#fc4n*@COZq-NJiP>CoS31~Z@$x8NWvkV5&h<sj&Jy0eth~(aQq|ho
zWu~Gnz2^!{9Or4OZaXMk+I#KF-JB~PPpr<o)-DRm$u3#PF*}$2Zh7g6jk(88P1AFE
zni_U?c0lgt2&*+W=Z1wHR5d%cnCphAX0+L=u-k4IxK?djWOn1$)Y(}PJ2yLO)+aYh
z3ocx8W}f7Zm!4bBMs2fs&el<J+qCPH*&L6a=Zd#^*1FA>Y4)5~eC+0)XHRDPoH;Zn
zxS8Y0#;{<W2e(^{_;TK?37DsJAm)0^&eKWTo@mZZHktBnx#o!{Ni#2aZg)=Qo;u^X
ztF*{$&d9}PFXUDjwY}U{a$7M+a%)G}t(9Ru^*2>Ja(s>M6nI#BY@4!bqhdIh$X=Gk
zmxNZuF*U9H<q+zewWKR)vd9dL9uYScts|`wLI<XaXeK&M<8<S6f9P0y@x#Rr=i~Qo
zSDPGBGbO)U?zV>tOSk|0gU`>;KT!Gf=fw59cK!Z*fBqzYk@mfPdtY}xJ}z;*(Smu`
zmB$OpGtK<!#dG=@?|f&x^SR>I9SO+RRM@4u;ASP~nu(i0Ez5H2o#zVgo?oH0en!X-
zmi7Z$S+1cOi+n@9LYH*R<P6nWDrDuc>Om;CsMe~3LD~+B7BdA-by;Q48RB)JV~Xu5
z|AIxfC%HDLwyauxN5wWsYxUJo&G03vA@zH>7KQJsDYdhh95C%rc23)$`)7-fShc>r
zGADiB%(6SWJ6yL)PYK<vJvDmTB+yl=;C-ZE;(u+f%laD%zg9l$H}%VUt2=r7>Zto`
z_oj=lM=Pg7Z!2ed=PuRVHU(sW5QOOewz^(wb#Q$asCspA*$S%um6Wcng>6pmga|09
zbZpydnmc{{`J%pEUncM`v^xCCevhHk?F13dC)t<7ulcGq>IQ$Td4JDdcW-)^wd0M2
z&mHyGd|s<iz59-zp&uX113tq(iwl+)ZoZBVw0^ax`dsnd_uJstNz^0n%w6cIU@^G?
z+^YY%s`<zFI|6K_?;e10gp>2Gug`0~@A-W+`CaW*t<5^N8uz01@d&7{wTrjDQ^#+!
zUo}Uzi+grv?gra8o=?9E_XIaLS}^w{_nGj;y(lj?TV%tYd*`|Bz2Cbp$bfqcEeaNj
zD)sPVgIg4(VfV@Y3N8A6`T6q;Jn!xvkSfo6#5RRN@7=D)xx1uuzxQqYZg<r+SWIq8
zzRtd;gAP+ye)@TTPF=svek1p!Nw*VzRwvnAm=|AY@#GjE%M13ho5J1d#drDMJ-gz*
zpj<zC-uK$OFZdwG0}IFqOsYq0hZg9axT!@sm5*~%LCtl&n7tpr{QP3|`P}D2GL_Hg
z34A*0`LEvo{P)+t|L>ds{rX?KfAeqtso%rE0iK8hO~)}X{Fj67(Pe2=m;~By{0Lkz
zxeKxMy?ZIZ_oPu7>2wDHjtMH9^7T)HcjxAIWJ#Uy{XH-1%iQgevUlEI5WQV+H8ix$
zZS}UBS*v#IZMy~O6M)I@XTwitMG0l+FrM5|-K}`H^SI4N!#<t@B_+MUuq!84?Tq$<
zpXBSP(#hm7@pZh`6XBqnyxu9Z3wKmBd&gaPSotWKBe~IVc5MBW(Cw14(^I!~K+|QT
z5(A?UOMh|bHDAvR;ec(zdUtHEiA`P~Q8=$+hRZPvK|xS<$mv>p{t(!6AOhl*e@RW7
ze3ot6wC>*|&ihaHGc+h@eEVQ1z`(#&z`($9V6yFlA4#io65FJOQhJhuymSN=&62|E
zx6U?AV_*yonc~sm(Xeu}h*Joob6TjP##D!uUK3nHm(AvBxYoeHupof_@T>U=Cmw*p
zz?OlpT6i_H#}}!!%sC7U47_r-+wH!6zt7)P`TgzzkczM8<lfnd`AAf7yq(RvL1=kX
z$cl>#4rQpUTK@ZQ(5m^Xcug1=c+LCj6;gkdaRP(N*MLcjW-=V$@|u!S)z)x<)z@pL
z7PE`3!^=>8<#h|Us-;~?%k^E+yLFP;P32IQAh(lJTRo*ydL6elt-9oPTP2I@ifEv8
zmeN($1zQ!e6@y%}AosOK+%mhRbW$is<>o}892d_`zAdxUIwt2XQaPy7$<b-nG1=Iq
z-g8^W#3m)*Z5@*nl~TQOxV8x=E!?!km@#sx=GKt4tIU@2b~ziZifr`VmJ_meTX3#d
z+M$&ZixWJR5`)g1N%QobG<D|IP~MiQy-jX87ln=mX9aBw-4bwXiR6@JUbmw-Zb#iv
zx}}_(6{>A2x$Tn2<ealAJ%@rbmgWX$EZov?rmH@3mFAX7n{$?3ayGldY~-129HhHy
zTSM<=&!uYwSDAHZZQOR5W9<yLTOHS;+^!0)mfCjg)=}4NX}67mp#85Jy<4KAPUdcz
zG0A0i=0qc7PbD9fo66Fj+h%!8xRt5osJLb3tcX*`L_~6<C4zIEHMdIKRLNPL)pCaC
z&}Oa0hGALtBDdDA%<0J0&gxydm3NWbrEL>tPE89s6Dm1rvxx87Y1hIQ^sdd~*ebZ9
z>()|<)S#IWiE0y<T#}gNGCS?0iU-eRv4xSjI$1^$6We;%h^|x)4$R19yDfIp?1nCD
z)a0;(Q46-ItU0xIvx%G91kcGCGcHLA3o>W)C`(T4@s@P$nNpv&>L$l6W0hM=rJW>B
zZE4)(oEECN?a<0-qp34DhAg|f*-)jEce1hJjIJDx8_TY0+zOTKnrzCI6Jng}xm6_X
z)>O$(HDe=fsV1|tYSRu%X9siKN|er0j?5IhD4NwBc5K_CL}?$T<|u8`v|B!&O1@i8
z%#`+2^4%=#DU>tIV}eKhL1ihQTQgT^XldMv=G?Sx<yNI!-32F^941Q(rA<4Ny6V>2
zR%x-T(%z|N9<#-+2F?sijcn>UbS8IZ$eLrJj9$mith&{^%~Q$en5VL|cA~MuttB&C
zBB!XCbmh3_YVn*9&Q9IBEhj5X)937#S#Fa(H%(65wCJW;$ZCT$S2f<qRrSHb!MRi2
z64sp3-PXG8qJh!IshR>Djf>3AA6;#lb<8K)P1kG2ViC7n$4n(|DP3{9>ZZF`+9f-Q
zLv7l!r7L<DnJFC!6cvn8j#7?x$!N-qPT3T7GG%MZEVq*;J&q<Vvz%OJPRdMFn;-<5
zGf#4vq~_A&;T>jn>{{2xEjPtXvg&W#(v}Wf8yKc7c4NxX?xbF)ZEMzqrJ4ojEbHJj
zyOeX1ZF0&jl}sbwO_7rfCS*!-svX&I<<`up+X8N6ELz*`b}>skBzJMfwNs}9x8y`D
zTC^qQR&cV>YQxA*W34pdOf?UWo4TC_p4&Xsdc2Lp);L``x^=Nga_$P#MP?a}W@kI<
zx0>qq<SsH(T5)uhZ<cbf6KC2+sT-3$JJcq2ZaHbvGRx<ts-%&}B$rz$YbTwI_Ds2*
zlPm2zTW#5~H7?p>3JX^RnF($+oVrCV)mU??*~BGj7dn|7m)uUe=sV3MJIu^?+U(@q
zu&b@Ptx1uqb2}v!r*<2qaUDwwof&Ktk)4%wsy-@5YFn<9(ZcR1!`x-PvpTj4ZfUuc
zGu!Q~k)x2A=aM8}wWDH}(-s=>ZuFgM=DXt7n#0;6n^mNoRcEZ>x}BPH>dH2^OJ`ip
zEH>%eIqg=2H-~D*l#4lDIbIo#rkzWcZtFT_6gbHxQ^{nal*c3&BcBPLYMw$Kvt5!r
z)4C0XO?v9<nvpJY<#FO^5olB7xzL>9?8MgE{7`9$nsjTkB9oXw)9WC&lt~wj(>a{Z
z_Hrnuy_)2yxI-t+Dd*-%U9m|~YRRoLcP*LZExDcJwqkNxw*g3gVPdCB$BbpmPMMmi
zWSUKKF?)1&bH--lRh}x%t+RPKZWpPz)StPjvL(thW7{n^A2%O2@0gWqvzuHd9W#4)
z@ED)jY>5(2m8niQbloOx^L6~OIy6(|K9jQA&CQRdEW5h3BErm5`!JiQ?*m6kj?8U0
zDuX<Q*5)fGnX0NCOt`5j7rJW8q<khLMc#zlRf037tyai)-8*%vNpi}PEmPc%WO?~E
z9o$s!8P6lBvi)l8mB;BUE{eR|i#A1TZC|x5J5bV4(ooVg>bhWuNy<%4ohfiFt`$ij
zbI<$?nVl}s;npP3Vxk@y?YZM%bZ+jEBwk4~FK<;<!A+hkje?SsmTY(9nH0Ts*3}CW
zRJZMPR$RDXwt3XH%g@8KHmb~cn3h|=`JlvAsnxl@ic34ft}G7o+|nB@xF%9}(v2Iv
zNhfor-AU5m?Mj_AIdcl@M4=^<W_Dauope{gQ?+W@)>uwcsot$Q%T$hR44IuSrKBX#
z$l=7xox5u>+a}MjwJUnrj%j&$doEZhoT;+pWXesi7c7&rt_!+k@phTaa&l?u<P`|@
zWDZp`pFI7XR{alyZDux8r$&b@RPveV<Rz4unW?kvY6xfU8rMlm9k(AiXKHI_Y<Q_V
zHA?AX%2KV<@1)sIs%||nt7Ah>NVKZzrc{H&J2Ev&*i>S8<a#-(k3AHWGI0@b$>q51
zWRjB6qPlkKF0Tfm4U(!_lRUMA7O-4nniRBBWzvPI3~C!hRUE}sCZ%$PW!-X^b<}Z9
zq}HU30oh_+OV&;fJD*s;@7TnyOyMd;4#f{I9`|f(6x`9f!~Lw+TD7U(p`J@T)jCxk
zyE!SQz1p-|$lL6(i$jN_0LSfBVXIDsg#}IWm@wI+;M}Xp1@Bg^R9UrZlAnM>N)3y`
zY};s|Gp-x5)@W^9GEHLH)tSnL5<0G)o+*>Ov#xAv&5cs?oFpjmphs47NqtU%!h_yz
zYcAbtX>vAATCJg?+9c?e$;Th7(rJ=r)RC}3j9EnQXVmr`H@Ft)upP(}xwSw?X)4cV
zU9U`Sm0O-FoGKHSOwLr9<S@xo%44Fy!Oc8Ui2_qqrUkjo@>IU;TpHy&$!*FaP1B7c
zvqOZ0PD(7=<QpA!>87HZ%gxXwCMNY6I-0(oIa6k{d985rRE=<(wC$O~N|u$HDx0&o
zxK(DIl+@@IaapQ5>12RvgOF-y$fV>|mjqk{nsleAOq#Upl#u6=L?M9#+Y*=fMl>lY
zxp+!+bSk-cJef8%Q^ecF<&sAshf8^A$fPocOP;y27Eao<u7G6{gQu=%P_){`O}^3f
zBHAX7f?H-xmg3B9)b*Ju;NsyZ?9wS?<{BF2sdk}dk}uEHsiEH)RxmIywk}{`NSNfQ
z8Uz~XR+)5CQ|sVXwyi4DZaXb?;1&>@*1(v=FllATB#$+qeMO#I144OKx`USbHf-6#
z+rYKJ7j(nYX7dnlgNJO25>0{|S(Ia3>jj$=woD3{GF4;ZB6Deh3y!=J=lIxJTf<H*
z%T#HN;@u*h<*BnWM{GgvlF2CoMjRQU8cZ3yDoZALW~}I4am{PVwL6{x8Cp^<J|4F%
z%0o7KX>D7!?2^jKB$+dJI!#<mI6%8KojDZyi>IBA_V)H%b?uT+)-soyCbtv?4K)Op
z)Gu8Fx@$7hty|iN+c9$DmT8kVMe8iN8P+Jkk}_$DXO73jEt_3#bj|>)>J`(R5EZ(0
zsgcjbC2F0yJd34OwHk!Hqf?_o%^tj+@x<F?QksjBs6kR2Yq!y6WrIaViD}a=-E^Cp
zbJ46jBPCPlX0+GLMFKa&vZKSgMKUf$EUwS!RaBdjbz{|$wrRK1`O+j$CvBA!T*zR-
zJW0uNqTthWYgcF8Lb_BEgLwrse;JbNw$XLc;)q2jQ*KT>w$URiH#%5Iw3RDYZNj$A
zLT8o*`flpV@!Tr1Id^hY*P?@gj)A?s$;ruqYclFDCg<ejL@ZcwQS4ZEKuAEgNbX{{
zV;6feF0P!FcB?1jw%D;_N4s<vCmqw+*t;b#<5t(CnOPv=%cdJQ`mVawCTWtDxkBgW
zsx`SAqnaZwt`5kS($#cynz1zPYQ&l2Pq*dPKZaZ{iT#$z$?GrgVoKtfY-la4p|!zr
z6%0;|fKI+0GwgxhN7<7s0Xb!MdZH4etWZ*CXv?Z2%^^@26q-1B;TJg$*ip2TFIEY2
zfYlrdO`L96&nQ~IVQPeL=s)}8zjh+`iy^}j$T!@G*S-&5eHC<Q-~ao|uX|s8UzHp2
z2}WJf`@Z__xm_=v-dF9t^LpJBy;X<4zP|dtD*2>-_}-UWlTVf`EPeHT-SgOzg{9%U
zcX>L!FSmNVlzZ>1@Abv&b_MKOeebJB+;-nrK@+}As``EKb<Vz}n*5Htv+mw`dp%Z1
zdfVE&=kAtXI*2UrWcuoRUv6!LQ)}N>o2}glQ+Cg@YVUjB)p8I@25iczy|2G+{eB<Z
z+5cN!zU%e6y?5`{KLmM_`|JCCzxRE=ejU{guxYziXYbyvGL854?zy{OFKsTnx_jsC
zb-N<WbE9|9-SzeLw)fR{--iBLb^D(J0l>fn0&D>cMhyzh%o<D_1_>IB^-~yG7&w_V
z7#bRccz6~tG$?o&B&052U|?Cm(r6&yzyKQJb!1`SWOA6006Gw>NoWBBgBOU^sLA}f
zgNH?eqvZf2BO_A+LlcM41bd5yh9({sRR)a+24+S!#<T+rf-GtbN(xP45?dG;7z9~3
z8JQd$92{93CNMIxIM%Z`7#t9Axa`2#I^zlh1EYY$1OXLp!wn1!0s;amES$`_rczfx
z{YxY~fq{X^fnliw*io>P8yzk?FkQ}IU|?yS#h}orkjA)j1p|YJ<N_uRAyyp*78XvX
zX$%akQyCbvZkwN2cDtsFcXP?hZ*}$QlTSYRScwe8CsvA21PeT$7Z(>77yj*c`?tJ*
z4@*Hf|8(_t?$b@a_wR6@?lirBhvRcm?)^JA^oyrVkDorBWs+z4cYQrhmC1ENo@$@&
zw|=+uRGI!l&~*|=&xGW<M!{aS^L^qXq2FUmb}Z@At!_M9f9!GLUW<G4CrYSrEb6Lw
zdUW^o>Z36qo<f9YS3h|6pu6|W<Eqg8weRm*ytlsedYx_HiVX}x%(+|FZoB&P=caG}
zJHTrbPSs_;kNsYI_SWy)^Zs%AzT3Y1$RA;Esje>jG=uC5j@PGrc8S}xzrQb!yX^Fb
zA9eElU{DVxAq2w*eufWVrpVHjAyYj=rh3*K&RwT2x^4P`J$}-;`i>QrmHKhgx%z<y
z>Vn%^mUqvxt1T~&@;-XRuD0y%-7T)t0)D-wuhbYVHD9SQG&cy=eJ;7<AA90{Y|yGe
zugt&(CS@M^1r4A(GQSi(=aX?2EUtgI%j)&wIYvqm=G%Es7dM_g_GpJ~%)?iI4=^(a
z@UqRmB(uZv-mcespX@EUbGdoCbk~Eg#qF!#cf2dG+{y6ZhqPCF(VIt^D`i{)P5UeS
zA|?l(n;u*Es@HAm>aV{y7Po8u0i_$p{Z@~j*WRl<D(V+;#WhgBqdA#vQX_w-`s~ih
z^KL5FgQkVScd~k_v?y}a?0ddvrpmpLO>3lnCN>{f@K@x(R6)pfm^U6QI8f@?DE1-7
zGJVt8dF}hM)qQJHL*i75nBykCUMP4{(DIt!%n<I@$E_Wp9qHZ~f97uvm6Y?|HYuaX
zWBa=Gcm8nLzWZ#s`-foVz3-O$zSnh{%5>HXx?E6K@^x2o2{e7rc2cp9fkA)v+~?KD
zL(iXjE<L|*r&LENbM~#&r%K;L_O!8Sb~%C_>=iU+l8YjTlT4D!Mz4sep2-)E865MN
zrs*xTQfE%1%DkHzh8@l;lhxIiOt`5b-pbdME^$<m!-=O!k+Zdz^+K#GUsK}2gH0_;
z^-i9u#{@c@C7LXbNSsL$IJUA<Wyd0cpPWt{u2a`OS1wRacwSX_uYBqCnA#8WpgT0e
zFYTN9`T6+<22K?Ld3)yQ)ac7OcV^wzI(hQ#;!NvJMbge&YJO*{OgyT#^ZDh)&kB!e
zDtVT9`7U}ZeaqL#dzJr`&dd_<t(a=tyeA3xw<vPBmz(`^dtWwnckG)TEegks1e*0r
zCwZhz-n#Ad$&~3V6Su3B?>cjL-M1J|=_2>@;VM^?K1CdpIF=-kZn9&ohEvKaZ`LQ1
zymM|}va5}m%yLIRpz>W*WGKum%cVP2GN!6}icdPJ$Elp>@e?9B$?QpgX2|5w?vu$9
z$&ww8-F;bG7IIEnsUtqgQ+IQ|$M2;<zG3>R+j3t@*G`VPqf{TAc5mYLTb^pGWhWgo
zIA$!+EOE|IDWK(K$TU8KmfYD@Zuc`)X00g$xx?(Yr^?mjO%O*WOCD445}2tq>EJPe
z-p%<Qx8JHv4(&T>J#XSRwfo-Nu6<}PekonJT_yJ?PqIa;VNcSO2M+IQm2-UeP0wBX
zP`WtZ^K#7QsK@njE1hHvdyXg`F)R`~%b7IeYVSuECBNL4R@u|CW3sQRi<@8Gc5%zP
z+uB$447v>GIQJwA<Z^0FGu*Ut`B8zsQ`=#(TBW%!rLwnN%2^+>!_dueMvKHOp~u3i
z9675pKe{OQMpwDbdTTOU`>Ou$gYTc`{>-2C#&xynx^4AluU+$QwCsH_`CA_Q(MQ)`
zG~f8XV0E2Q@5D`=+&mwGW+bbMcLfR9oKO@=(uil7y1O=~eU8^w_oO6=wpkyROlVc<
zNnN@uKdE=ZMo&d9PmUlDr%6snRa(0|*~?{~Tkkb@cX%CkH{fpRTan1n5NDD6t8OQ5
z1hOc)8BKVZnH{TJUn)~xZ1(KMwQaZI!@f!?E{)26UgvHN4c@S-(?@H8@Pkzi=`Zq=
zZ`8Yat4>Zo>HJ8%?22)~Y5%9s=aydo^!ePrbDt#ApRsM-zNF&&-qwfQM>X3FXLw%^
zoAmnn`dHQ1tKF;bJ-(a0`{DQE*O#A6YEeO4W*rEc77>^fu+URE1u9YZHMI7SUdEDQ
zjtvvFxuzs76c(DYl~puDU`|L-SLu=viG@MS>x5P^eOWZ|hR4)zAxdQn7OhYEdiuK7
z<LKbtt&?l-DMlnrP~ij*=n60@sc_0a&knmK|0B2k&OP_Zx!1x<SLeK5za_9})rvhQ
zW<<=C=2B?UI2I%n6?NS^)?N0_*`2#g*KWH6nc`?v@BrPC_&;=O_P<#xCkNb@nCyRF
zm`OKi@~>8%$s5wy;5Q}CNtd2H{XVa#iVFyMhkz$RpfeyT(?3pPlw))SozAK-J>Ukj
z@bm&nCYkBIl1#$B+JTarR()9B_Okm~?$%j8es9VrhP_?jZE$sYY+dQ~_`?U6@A;gt
zr@>|B_VufbyiWvHd|%jO*t0~?pIOt*a7vTrgR*UJ?pMvPv3vV{<)_JYnc^|v$tHnG
z0sHk0<jX26<rAN;y_y;<IPdg3*Lbh>VGLI|qvlmU4+$(<k@?={hJG5e?&c$|q5C<*
z7f5bCa3--QRiUdw(#uJpRr8hMJlVCoML$@lOu8TT$2xr>=j4|U)a!#hUpNVTnN;0h
zeY~H&`dB2JL+ryIsY_cw)t*@WGW4~>G?uN)=T%;ht*b0NzuoS+=Dwn(ui94Ed2Nd>
z{Sfx|L8`_vqY19I52q}aI2C+li9(gv?TzsjW!rvlFHD}PvY^RRL*b-qGs~m^N0li8
zDU%L1t4!mORM`-rGb!<X<s@%551vU88k#B>;!U%oKA_BAd<36j3L-jKJURuHil^(v
zFnJ`Z7))YRF^;;Oo1MFLi4H^V+T3khw;fKAp8VjEbp7--)mQFiEsR^d-+Fid`uOtO
z&&&DOhnMs3-o1NwgX|rP@&ehr_dd^gZh7zfoaYvx+7F7^x82P%Tiq*@v9^5gbIW(O
z?<=R;N6dT`$uyx^;*=qmqN>pAjt9kgw|70eb?r9jF4-JN)5<}~#iLWs>`q+NE7QC!
zNj*aRLT-1nE>_=b_E}_`G(potW#6=2xw+Skjdxh?++J+msQ|vZkzo>}3X=!Rga!sP
z=Ohp26ubPmx3Re;(XoN+Hb%V%&xzUITzheum|E3Ug`f$^k{*sdnVcHi%hD#_c%%&5
zFr~HO)C1}Ca@dBc7ZMC2zor%nHu{u1Fz`1x>^rq_N@&+gHc3^j<Rl?)wll80oEf(z
z9B#XY^)8!ovpIL$k%U<i&XI1Lqjf@7ObVU6Tb6e*W8MMjRma>K7#K_#7`Pq?cz7_1
zU;JL(z`#)XQtjw#tD<MJyX%*8v|PK{G)2^t)%kK^_x&KdsU{BJYu7g)_{B8ef8P7@
zJMZ3=-z#8XV7=HPaP7Bn@BNB{?z0cMT=vv-H8GJ;_GxR#s;cyus%gvFlw{y0%;~SH
zmF2;}khy@t^VJlOiKey+nakQ5zRE2K@@frif7QOk$E26x1lO!dQ`A;=HZasP$ZM_o
zyTARp)L+TFQqRiWcFw)Hu5w|;yn1s(-D8J7+FaP<ZzA=qa&F<Rw_9Uptc1dwySJC^
z`DA+LU2n1V;+XTs>#R=4wk0h~T9%ymI(D{?nwC$<jGJyVGPkb&_;K~u>ys{JvIM!E
zRhx#fX{+AM?ZiUS%^XXY+;Ur_urgCR#HV+g#}%=r3sJoBzS8l&eHpi&9XH7>PM&49
zbK_a*n44eoo|a5*kV6)Fx_jy+KZfsxBE3*kjLe+4CW5Y3Y+K@UNIOl?B|2))=A$5O
zTaZiwX{+~Rkha~Sb7a#}p)E57CmN|tR1{RZtdx>A$)&|*wu|Q$Fma-%b0T<NXQpt*
z<ZKU5A!%O~4;RlxDz`H_%|OgqYMo}C$}dhQ*EG5vHJa(OEI2?*CvxecBN3O3E-u)1
z^}(VWYkQ-(bi0mjGZE`Lnx&gvoGYDi+wE4p&g_VbfeEIIPOhHD?V7aJb(`7kaNji<
zD>g`7Ou1!t=gOpz#hJWIj(I97XYwkoIkD!V-_>ZBTxqvUrqa?m64!zbc1yWzj1KpK
zZuH7Hb>pmbaF%pX?3A0nQ^hWNW{X`6Ow!anD`mFqinQ0QRhE-(`nH;COxC!YE9^PT
zw|<u6M3b3IZmQ)f+;UF$-I^?-5wI}QcgxIGxeLWQwzw|R6<oVcFgimy>qyqNXIs+3
zQqux;R|E$ex#b?xmASZ9%5<^YmW*q?(mAtP7+gCPRy1*|9nDy~-BVNRw#r1snV*g(
zZH!nG`mQ~1#qDUm7iF({=iXQyec8;@E$c?^X-(bw8AUlkW!rA8EEbw^ENjx6#w}(-
zZ@qF|w}_ri3$a$2b9Sm;s^+XEyAA{do0WRqHd+~NG}|lOggtk*c8YqIx{=H5G*2am
z+Y3auZ4BNLoHRQq+?081Q0caGH8aoNd97R`8vaG=iqkId47XhOHge``qqJL-Q$o+0
zrD+!DEVYi#tq*wSX*hGG_lDJpo0zw_p4BSr*e&9h!FN?V>z32z$VSQ8LE5R>she8U
zn#`7l8A?~&xOunpT)Uo9_AXfJKcf_K?acKe&YS0sTuzpjxN)*G&1~DviJrb@w~aJi
zCrk_SZMxJctT5R_<r1gqq)x$QUOm!b*9^DmHVbQ+)i29+-H?>(b~JbElWR9`1uC7K
zshsm_GoQDYim##CB~!L^vE*V=sbf8!+h%UbmNJ+e%o7!;blS+_q|v2LK`EbwGgpU+
zE*6XeU37I@Iy6{IB~oI_?8Ho$PP3CKy3t{u4zuyx+;(f4gh8rL=+=lJ-LRgtv#S<W
zTnv|T-l}=*R((q`Yq-&hYrGwuPrA9*bc<}#by-=FbvtYAj1#k^A8a+`4vYZriE}f#
z(3Cq{Fe@tQmf;q+BROtIR^@nh9m(j;=-IS1C}XMG$t6jgOH?iiWpbLd2zz)gIXTH?
zlG<gLOJ<%+gfrD9gq_ax4bzF(xM`}?tchXTqN1Xrf@>nS)%Q-hn3OZyrB~VGl1Z=H
zg-#(}wUfCkwyoCIcI%b$oz`~Cthcwfw`t?zD3d8cA=^ANW~zBkN|`C-X?9ZB)HyrL
z?d*~@r%hcqx?K!Q6}!^ADlBQ)wL@mPfoYK~+d6JdIvbdyoG~p`U#WfKVIBzse$mh=
zlf|a$UNu|0)DJW*QSauPY~i?&KRV6AIX^gSjkZdz+TPr4cN8jo4j)_PClMy0ZaQnJ
zMUugZbq8V$eN07fxE>ZdEZWA|CVLQcncgGewYM}D6$O0cm@CcuT2|8SqZDuMhI`Ey
z0_>)yhI#79uH-(poo{l|J+G^=E4PYnnyorhCsZ|L#)EHfUyGbHyHo$9@JmmJSZ8kM
zf+f?sJ#~dyEDFqvyj{+SZjRgTx+J(ncc0SsQ#aQ>n4FvSs-vT0i}JF-C1)1SmRFNC
z*7VBC{S>%QI&$7h-OVyiih>u9^lt5lUJ@BPZKjg2mWpyvmd=?e)0S$k$<59E<Z~uy
z%G9VDA(x50VyQXj-LzRXy;G~|&vsvoSkJapCh3??#EVDHccVjdRc03`yS3O^6#TqV
z;B%w5BX{#jU4gW!rNL{<&h6QHJGVHuca>?NVAAa?UWKdLB&4-&Ne3sLxxMPv>P(f}
z2iiImz8fAY;S)}?v*}Cx6mY&dqo;A>t4W^9%y+|s!*oSs*XEis@FXpkxa>7sx8Afe
zbUg#x3g&=JuPLinS3Xcl5MuCP^yH3uT@skF+3L!nZK6$=rd;cB-DcFZyX@rbrko8g
zGq+03_U5|jHaUN4Zs?XtXYw>=ODUY#d@(w2sl$>fHx+NsJih8|=qyj^l7-DxJeQk=
zbC;B6UKYJIIWyzh;$)T_pKGQW$ChrE-MTuf{?$#<$QvK0efSxd=Q!y^8_T93&!sBU
zL#`fn$@0`Lkq~s*q_k<Nrm)wkmg=;2nbswfj{S`CmbkilcDS-j?xd5ei^W7Ytg*Oq
zt2670$;_Y|+cb_{^Y+Y%7D<|xa^~o<6|;*H-pMwGm)%ZUT^gNxx8nj^m*6xnZ%<#1
zjY%hiq9y7#E;^aAjb&@clAuYNp3-fZ8~HK{w#P^=nRZp`(%W0twzV26n_t+lRNHms
zrYTpav>bBTGE>=gt%pxmWXfhkr{tj1nhA2A8FP}obptw;BC}dNg-(YkdEB~sokLTl
ziOW+VR46(}Ym%qV?X0s8wKs+33EbVDJUg#x%4%I-Q^RPH`diC=-BYE*3_?;)=0s@+
zZQZpn&s4)?gX5HKTUN)$ZVsBVw7<RN>Ll5v(=FDSxVuViTce`7txPG~JYvDLbEjQX
zrBhQEt++Pp<dRvrowEcwC*C$mJXYqZI!johv}&H&nKwys+(F8VY|gT6Ro(V++cTZy
zkf{nwQ?+x|rkO|02(YT(>bq^#nKPjlSA~;q>dnrMxt*QSD`67Q>ZNj0Fg0z#<lIo*
zmKTrt+^tJ?>%BcSN8-R$(Hp(nwl?>bY;!wuHqi5l@{BWUj-{+Na+~CqKG{#*<nf$N
zA>XqWXOB!4GI42g^A%{D;A<qHnz}VFW37~z?usipjB6*|x^YxwV$@NFtop4=Q@1f}
z`@pzyUb%3x^^W!i-k#4pW=q~ZQW@?u=iKdWAwA1Z<ratc3z}RuyS<bvINwWT&D+IC
zjBT^dtc{$fx9#kzoMo4C)vkt1Y|Yetn7dm{Fgn|%@}hK}ZQS>*CwE6)R82c|C9BX<
z<?3>|io*QVsgty&w&pBbySa1oqENjH^;=5azAjz0`v9w(L_}h$OOn}S&$P?F%T^p+
zD{<{&*OlauWQkLeyO|<6%!|BZx~D5?THQ_R(%ziTZFJ<yxy6gSHoIJ17Z`2LTOP~N
zD7!VO?a}O@O_6J7>YnSmW8A0UE^}5U$!ev{GM=+*C$3qxP3Z3SXpQH7ip|r!Q{vuk
zU3<H};)L2UM=3A2^%ZwlGcL|e^p+OexN*rOpUF}_6D7SaZR6rqiRc#dT{3CO<e+Jn
zG*>#ZczXJ>xHjiZ3W~Ti<>;!_$y+z~vPt@Smu;51v3jN#gU_UCOC>fbo#pI^&AR5b
zGGXDdriogino1c<9-ihoc=5QNrP?$<T|x0Ar5i!5+Vy%{?q*BfmX7w^c11!{W$s<E
zvun;S&5H7Sc(mE`aGz(-j>k(4PfJTHO`58)sJB~8C*`K-inUH#GCVvyT$F@_gg9A4
zLnft#dR|;1l45wb>r9reRM*A846}}wDQ_3Ank>6eAfkBfs!MGh9W!Um=$R<dz|qU%
zt-8tEYod`$r;u9xESJu7vu%sIrYLl3YRt9H%2dq?nv|J#cAwhwiN`0&6is=Y_uT5b
z<+W97mIiDOmucO#<Kfb&jxLgFw_GGumu%PG^loRyIT^LYz!{2LZf%({*~wGLTj<El
zMOk4%+b(4$m#*d$U<eUY(A8yNc3r@9gmKZzkV#&iER#$+L1Sx|>VsD3F4%Tbb?pLg
zttEG&bGK`{+>&T1SKfMO!xM`uw{>FgN{7ZSyJ|J(<cV-Y&CQuxw{7a0$|;o6(HN>G
z_4ekht{YB@6Xto|?R&`@BXMbG^@6IhG8W;jPxTo%PCnMVc|9}tw2If1gC{g2S4MLR
zDfF(IIn{UDBsZtzj0G2O>3#ZKpZjvQjIzen?2OCYY{A-w$5h_#*lez=>+5t)*Jn;&
zTIuTC9n!nD=ITBwx^go2xj@dH3nsHcy9ZaD6xCh1#N{MQ+3mz)i6x6SXHPQ;ot$Ns
z>m9M?=uBhQUUwI>`=*ZrlNKFKk!G8$lQSzNN|!a^<eFoPE~GA2^PRNJ?PRd&lKLaP
z3KN%@c&c6UoM@71w&mm^x6a8PEgn)qD<hTCrmPC{n7K%hCqqiIbu*LOsx#BLxE-dZ
zE#qjL<a1)S$_atSh1=4$CS5UV-InZjQ!#bz(n(h~g>6io91>tD+qh*m=Y)5H3@jCo
z-dVr?Q1^fT_qyNK))BY!PiNgfo&{b^#!wIGv@%9Vn}slNs!Z~l%E08QGTC5d0E5aT
zPti3q(nPgDCnc&StW7y=5OQ0qfq{WhWs(O218?pchOFiQsT)kbQiqLr{H0c&NIG$}
zTk2$Y>e7T6+oA%wO^z+woXn$<IMvW+nWn1J>a--I+=UC;f|5<wE{fatWQo6!{_gy+
z+tL_7OzTwE$*_y7MWQ3FcIhrzyKyz!vdJFTF6T@L*4FI0>1uX$+p@5$ZASzyg>KW>
z*eiAvbSa~TmYIf@Zcb9uVu_1VD{iZ*u3DViyEfu-#%$e{8)i#~wEmqMTCX;_F<N4>
z{}omikz|QQlOINlv4iv)MjeAnuzCLMI4CIC(b1vI;^L;Hq|hTMDACc;WZ>eGq@=_F
zmTH1XDe(w4843ytB=mrkH?t)4xVX4TD6=FfDP292EOBhIL6y|x1yvlJQP6F5F4He6
zGRg~yc&$+lTge84LaTW|;<B8e8NEZHiCUYcKagWooL=V3C_nvFDw8P7i5`hXlMOTE
zrwc1EDop3`V-&8xlMI<wJZ9MIVG4yNaIqfFyLa!b{9ga|>JRr1$0r|CSaCr1)vGVn
za{dxciy6vSue5z%Vc4N%z+Sa$uiW=$u>8wF(Lk|RU#cr@lDK*p@2y+%eeVOX#H&~S
z)%SRkxO(r%ZtVfd-MzO?d%gSK2Oq&Egt&&dB1{3<a*to4X>mDwZn8wvV%Gd+(-W64
zY3tO+etj`P_3r!boqDUYLVR<kbTZ!EI%%SU^~ylgO+hN`W!Jo18s44P*VmUgGW}y6
zqk8?kNKGN;-Px*24&}KiOFa1Au0hfx8U!DQgDmd+9-W=NBi>r2Aoiwm)4P*0;$<EW
zCa7@lh6ymav)-L#p~A@okrT4edo%H1c}gElg~J4d04GRyJzTqjOME#)%{9XgE%Smh
z2vu^S8|pzQ#ZaoGwMc7`?j1&Rk5_9!=P$|Te$Tq~`T5hI|5ZWT%wi{b{{CN4bUSz3
zy#kX1Y}e=2d}ff&xB2y%K|1=p-Je?wb_e7WxZg4EyLB+kRH{4pz5UwzwOhYF-nh5w
zLTSb9sIRSe9PfNI>#I4uo#nSc|MuI}uMd7buxj<8mEV3l|5>zX(W0I1etmOgt*lB)
zXWX9|8Zi0bY~gwb1_spz2B8M2TT>Yr9GM)hE_GlKaG0Rwa62-9fklNy!oUo4<qfk5
zgMdZ^0~2W0&Mbj(f+iyagBeeQ2m|AO)$I)20WsUIb7wg)Y+;NJcI%bWbw%7E#K3;(
zA&XN2Lz9w{5)X@p1V`=~g##{50nE9eJ2|0+izm|(E{7$YOtTooW;-wls4(zmC|vao
z0F^wBT+O-At2!B1=dQ~xo_4Ot&oB7nk3U+VeO>QWp1peqVyyaScfP2tC@uSx<Oz52
z@+mVqVh-M}TCS!fJ0s@s=G|8nPtLyk%(IfudE(bSb5_k-wR(5i**3rWe@0c7;_8bh
z7S%l6{Pv8H)kDqCanX9w(Z6GT`{iDj1slJsn%Qsp&F-!-Ut9XUlO<Yg(RoX2-?X%!
z-F7=|dt35OW8IT8^L$Ph+1Gvt?>F1~WX|2YSHTfFXU?BBr@5_@lauzwtq)&)^_6~L
zRri&+jW4d<{Bda8`OTa@(e*N&3+5@^c;d^<c}%y@<$}rbiM_L~@o;|ZPM&DOt5hj*
zb8W&A{~nJUPdqYA+*J2nm$cKa{2aS+o^|b-FOQzx`|)x5yN3on!Np4RQ{y*Yb<w@D
z@W-Ru2VxfWmdAz!y4okCB?VQnrEwka+_>gQu#d*=x^-$-@;M%9`rS1)cvmsIUh0gy
zOzCA~)px~{=R5vjU|?XJ<QnF7x>DlUZHHU88>Q-f-*PoBmf6PYaOwBUnH{}qCM{3S
zeZO`)ckQ;@wKJRQg;pKa2|DWP@Kf(`b+upZxqZ`9LxX*$$_w81nJOwOaWH+`Z|6wY
zo@4jTE~vkp{k}T;S<?F57eCbUZ+!8k%2uwv-+l4L7yJ%Y%opT(_O8!<|N4cBf`6;@
z!>fh*6$$tGt{&O@u#xw}s~uAuKYYk<kG*>I&Zo@eM=RfTMW#mI6q)n1ReWk_=#O%F
zzQ@mJM@wg0OXs|O@PrYRa8f3QPTX|6QfFIq+l_9)Kv9)R?^i!RU;F*_(~dcpb2l$J
zU3EKmYyGy{`I`+SpWO}(4UM;*sk`@$&d=>zo_wDE!ov2g+Jo#THg|VPo$AS5`0dyE
zYUS&_a>-df-^;h{OEa)hV7@<p{`}dyckf!YYSrI2XS}$Rc5mHXUX}NC;!)Ai(6qld
zXWpFo-rsE7&s{$k%)7mN$^CNH$$P(UyPa$Mz7mu^K)60MH1v<RQ4V-hdm|GI=l4xh
zZl&CeJ@(z$*xFb*&+p8cCvyyT-HhITb7pk0P{HBSUAN!9`}%#i^KR?iTdY)W9^bTg
zWy%fFJM%4b^ccNWpWMEEdCvU!Euo<)abO4BD=)EHwQ7C!T%H$c>G!r6DZbg3=AZlS
z3G=4PRR>out>3-9TtVu#`HmV;kTHO>t>VRw*V}FvznT5MJavBDE`IY;dD)_>oSdGU
zv)`}Xb{lkorF71-+qs)eC#%hAeK_^ktkBT9{F)Dy@9H|7pHAMrZC{$9z@<6hnQ(_j
zCeNFj*&WPtPfk`eO5u(;rn+`}?uOj$wYB<(+7v$4f2pyPx*8hByTlmO*qh|3^q3>l
zE7L1zYQcx6?5!4676r%IH{|5*FziUO-ur@qk;AFHpuF6e=Rm0RcIMf8cg~c3p9*TH
zFqN~H-o1P8&dcJehquzqF5UA!x$phGRSR@O8*0~W-(NfXd+n>8Gmho&ZNA?ZIiaQc
zUV{uz`ChsD?|k2v?BK7y#AbbO=JRK(8rGMWv?yk7x&HOLOvT5?cPIVIKl_l^OnB|y
zneHWb&)${0ox8)T^j+Xxx!dz=--}2z1tf8;`px`)uUS=D`IIl;_vIe;D&*6goTD=7
z+K*&OvoCKCUM}Bu_xrxDp^RB;nBSJ}yI))Vec!KjX~u7lKc4ri{)w`g@Y>zCb7bGU
zt;)~Y&hEGSmi4{aNQQfJxOb?sDNK=QS~cmAV1q8m97WEzeaC*^ee>qa$H(_h)|x;2
z&^D#zUB24Q(mUJET5iuhczN%ggUC+Yz5C7N_j`hm%gjM?qJs3cZ}pL>&3mnPSmk}Y
zRr~!u)IWb4zeD`<@qKNsvRRpMSITWpm96_Ej`{AjdU9L$*`3>$*ZFR`hw4}Js`7%8
zyKlGre!p*Kvxc!jn!S8H=l#l=T|8%$jeg(vX1_1Myy<L9+OfRbH+7o#T9=gGeY3g#
z?(gGMMO_0!7<!T=9K^aF=!%|jGMuutCynV&xIuK+vnV&4-@)%ox2Nw`U$*()&+S}=
zk7R<?Zg{G${cz04`tt7PW$$x$zps6@is@>QKu_hj&F@R|kIOt?gc%dBC+BRRU1^-3
z@yWY#dyB!PIa!s8D)rO0AC@>XbNiM`)jhZWIoUh%xbL@DfAL>JrsL=5=jSIhF0AWi
zytFCqne66kSNHOZYOCJudpB=~WbRgu&pc&!&OExf!Ftmcsq+ep-+fD~*nH%@;TFTA
z4J$rm98NpjyUob3r|0p^Gl3hs4xXNLCM<mwN5_g4N=ma5RnsaLEbVG*QmWU|f`~0z
z(9zY^q@<<AahT_fv4O#1o>LR!?dr;ncD-KXc*e0;wbyLpLNnIwtMA@@cPeOh#pz?=
zJ&TuGJUXYY+SxY4*jJHB;NbM!-i=dSLCviY*AVE@ev#X5&aPYKskGm#rTa@{?^I2<
znL$$}w{1%{N;<Nz*SkJSE9?}vbaG-^%fv2Itw8hV+ioW?-r8X@hruG#W$B%c*ImB4
znagsfO8HK?DeQA8;!>usQtDb|?Oa_o&rY3#-BI09S{I`_4jQTDO57Ip&RDc^YUF~O
z+h(VVHigaFGMTp{%y4a5cgVIZjjIbKvomfT4QO`lUC`0ASxh$9&9bHbpeEO*Gn*Dm
z2IS@}yJ|K$)8bUlHmf^Xo?AM3WrMSOPi~oPwRTRXk$LFBIkP;)N>5#nDLs>QYh&S*
zZfV_ZYjd@3t&S;A*L!y$>{8(E#0|GZRxWk55WE_+()*yNO8BECleD>lxq?L;yA+N}
zEcWWk4D{hR&_6-^%HGHCmv=9}{Jj3n_it67pCowa7qF}BPd4pcm~FShAd|D_bi8WS
zmhf2%XSH<4et!S{<7Y3v_o_#)hVQQRy82P)$(}aP$>w{{oR=z?Uio~MxMdtSSI~ru
zJV_?Watt=pK52c=y`!nfIVmkgcbRXqAgf!b*+D^8xA4e=J&u7>T|!+#FK$RuSaE7u
z{S74$1tM2;G_5-|Q`xbj>t>*6plEQ8pg>3}m<(}oEVpY=KOgG!^NQfRP?hf?(<TUQ
z4GcQvGEK43DQbn#g;1d@oz6=_V^?V`b6J(>>2knLOGW#=sD}}Qrrkxa8ZO0;T9ZC*
zzQNg+(JSDR;*+Qra+=3bbkeF+-k?aqN3LdOHy3kci=CXx$!J=?;<DSeh1q5^m$;l1
zI4f-yVCW(l60#>mR5w$^%wyW^V1u)*D}CH<99xxkW82a!4dw{5+qp~3Iy`C~tWw>h
z#P!3!fBNaCA77Sz-J2hMP5;)Bo&<@@naLhGVfWUTm(P3mEY)Oty6WPvZ)t^#9-A+^
z+Q!p1q4}iZwo|v$Zfhy6QmS92v`VQ#$zg(ugOY>SO6?!K+Y)})?k~Un_Wqn4ySHEa
z{+qNV*_*%LxBCs-lx^BKlv~`)*f<^TzB?CCp0Z=ts`r)}4900Ejc$Qf%YpW1F*(do
z;cRl47*yN4`9qJ!jm2EI)6)0t-S;E3eUg;jyzjAZ*qWlNmK1axdot7VgmnGhd(fy(
zS7i^4o%I0892Oy#R@IRC4fY%X0SoS5PEP()@BjNt<)Z!)@D;}YV()EV`?~5%?Jn8Q
zWZ^STxhUDSH)zV^-no`KJ|+ieWpW6#aNL=E`n=5^$jmNiO&^Fg@fS;U*7{46AGT^w
zR%m0JJSSb6X>Hc@3yh2kY~VeS%Al11l8}`E3*;Din66!$uIS7pqJC0ErRLxJ8m+_M
zR7`5EcfC(A5xRX<{W`zb*_Y3}Lvt?Y&2*l*?Z%PmOPLrg>e)g4mj}ByxwBiB^l>sd
z?A`?K{OG-zpc12aS9ynr5U4K%;?{+R{?sxMPT+0W|M^D(hx*=M|LPX?*b7P7dseUe
z#_XuOH^`Dv;+9B?z%jEMDn~YU<nXZFPG&HQzRKsjmESz?-Mg>#tNY_NpO7*($T(w=
zyW!rxw|DFBu4Lc!uHmf7B`L)ow^^C1JWbv9e!pK=BlGqWtlPy`_EJWOr4il%Q}EbP
z+<Ng2ynnV*`yKl|5mQ!XyJtV;4RWX5*^+y#QFrtF_J=>J_L-z5T$ai=W?8%41!~DW
zo9b=1@94{Y-%}|NSnuNK>JsFo<fW+KA*AHuA;i+ZHad6z<mkWum%sm$fB)Oh|MmON
z-~L}8|L^yo`<Fle<A3@4pIx1O_~W0~f7B~j?QVFnOE7WK)VxPi!$cN}sVo!?6qC{n
zvske-V#U&^RqKrNl$4Z|U0j@kE-q3O6ciMcQc@C{)+@-jWTCQ?!^E}q`%lN2-u+iU
z{qxWDb#^sdT;B+uk!EodTx`suGxzT9-MjKut$J3zr!SO!()YcuR&VlsP{P35yY20^
z+xZQrR<mlY5m~h{&}%~}h_NAP)v8rTUA2yjimVnDS+#2QS1I<rcQcO0mR^s_VZ5F9
z?%hk!x%jg(mo-fF+`8@U%EY2w^{-i@Go#D)-o4=@mGO12$z=zxCAVgmUD>cRwseW;
zwq^;=Exb+JZhbHJaFWX0o35H&RkmpMUTuw;zM3N2%x+vew(SS#*cpW;nI;|y1Bn}#
zSq?TcE$z)OyERQ*d)=0%jawuR_%__o&IPxomb}V-vNpdfOLO+cjF}vn!jpvS?|t5V
zFYf!kB`z*5ZXF#hOBcI1zsQoB)m#1i+J~a(+s9Rsk3G9_J8_$Iq9CV~5KC|F|7RN7
zDyOoot!@Q4STlEjU|?eE&tn#6U|?9rz`)SMfB8KF0|SEwLjY6z1(U!vYqu~2<aW$X
zaPbssyV|?L)Jr>ebI?TJO)eg41_>P->k}4<1cyejZ3$X-%WK+Fuh86S3s+?@F3{W@
zWX6!Q#qBmv($t7<Q<qSo&}@;5QEM9*7_KZ_*Z{Hug8ADI9DZZqqR`@=EMSu$=bu~q
z;mU3iu0;QJjEAFmnG~3lxq`a50s>fXUk`}8&u`byaCKXkvafV5Z?un2^WFMyKWyYV
zJ-IYg;v?Vfv5rqLyVsC+PkP=5zSj(o4=~PqcAe)&&fzrX;4g|^3obAi*(^2nnjN@s
zF;mF*Rb3%pO-z^_CSO%q=rxOn<)Ek5yjc@DJ5DwR2YIdd8+?Vq*8Sz5_m_XgRflU^
zUDuws=i9ol(si<xuW!7#ZoJF%%!}9O<EDRLV^rdO@%8!o<i#=PUR*a`yngzGOh%RZ
zy|DES>Fbn2?-t%lk13mZU3TfsTi>I;N%rnuTPE4todu%0W`cQLGa;~d_T9o;-yvr0
zGClLH^mt_UhBF~&LeAvg&EA+BzUzA8jFmHPLnz1!iJN<`%dW42%@ChYk13tDyPoH$
z&rzRacdzZXhMSeS*f7{I*l^S3*zB02({@{CZ=SZ>GCa*}hEK?hm4=&o4UWx@nug4o
zy7p{I#z`q7x1P*p`uvu0vkxD54q6J)j+F^oGjVv%df$f+if5VCgV#^oc-Ffvr`YYf
zndRc_*|w0i6d8ym7MriV3-`2Oe0VN=*@q97XQgAn>I<H0U#_T-LDnjBaqC&o+Kltj
zJ7ZNIu!C%Zss6efv>c;yarSJmqD|XMw?3Yv;#gl&<h_a=tekIq(Js#evau--*k|0%
z>J{6Yj-n&u)-#B)j2qXk`s}(s61?IA!<7s<Qo1FZie1-D^UK(J>11YR3U~`KI1w|i
zd+>S(1LNYb?OKa&2Zl<!sfE@H3X17OtX(lHN+)7V<kBgpvRE}!uKA{1G1LKxMCpok
ziw276T)LPXkd*3nap|<)MM|nsDp5)oK?@-QlRZwmHQl<9l<IbD(KcPtjTu`)B6u^l
zgdMwO0%F{Dog5gLU<gK<x?MMJyDr*hc5z$pmfS@rxAuyPF-J}B<z%$3S2o)0mFwHP
zN_W+^DQUN*lZAB{l9Q!w^|~E1l}--axb5Ip>8w^QGs6`(y?Wh_-Da9PWn<uCp^#jY
zTMV~W=5~UdvPf5OTd%~VlYv`%-L4t>ZrT`aY8GZRTVtBYtfQ{39ou@{uIVlo6;ryU
zyJ&LKq9f6+t{qFZ_AYZ(HOuy>_wde4yRpVJXU&?Ei=#}k-Fh=F=8B4?9b^y`ab!El
zASgLoaI5MvS5-}&E3<<Wb*JV8Zd!BgSne!iXS1zRy%H<7v8I|`N}A1eG&M`)Rx5}d
zHFaCZX=N=#>15YMi;lW3T69I*EMQsInT1nlx~y7ra?7&ADcdF|noZ8~-F9+Wy{oFu
z?UYTCM$thVj<T(tEh05DBPb|3W$U7iXI-)s@A92HaxTkMR?%zc8Q*j5!3(dvD0>{Z
zqStM4;EF3*vKQW7m0G<}IQHVY^pfnEccq>s3dg)zwq?f3S#Q@l=Dc~HZY{QI2WYLy
z&AZ*X<z;HKC2kx$=HqP`b|r9A#$=x^ugrRp+%1<nH%Fxe1$#|)nXT4o<|~xDHRYn(
zsxw^^jW|u3d=(}~YE7CpDPz(tgRs>Sx@#r0Zd{d^uu4gHt8_M-T1ZZ`(XksH*H)Rj
z=7QF5m|a`OHOW_3B{$7g)nw9Q(^;D%SDVgSu{m<pD)15xWpB?-Ubj}OWJh`2j?l@S
zTrU*Co9nu@S7Oq!E6Xm3uIgHxo$RKvaobi-so7#)Dv>!J9v;TtX19E{EOLola??#}
zw$WyjO;M9hr7qnncFRyY*=I{s+SR~qW^0nnj&5B!+ij-E#$`TNHtU==T6ESkTVtZ`
zwrQz3Qk#t$FEuT?7JK34jmc9*tzM+Y-t8=2c=N*R`n6FnT&_a`uiS0t443QHnrqdx
z(so@}ICrkhH1zI`Svkqc(vpTcM{_e4r(9H<DKh1f#_iOJ-q}W%I>nqKJ=3NIMQ+m$
zWnC(y=BPHobBR#4s*sw>Mb(^yZC4Vu-MB5$oZ}h_3L4#+$vJMfL3!!e?I^R!M%%Kz
zR3htDawZEMoH|=&%OaP{LWdkoqs(rLE;$lmcH6DTGdU|bLwBo`p=x*Jv^CzDlY)~@
zx^yc{n|3lY=f<SoNvTVPlv1|LT(UUH%k1KkBN<y}XS*rqWKQe$%nj_gEw*)8u2hPr
zn9sDc${x2x&Sp9V<!;JNjt*S)dY7zT%eK|KHycJ>tJk<`;<?dnR-jpQc5-$y+pUXD
zw-&Q*Q(EhiyEZw~<VM<*-bu4vaznRW<yv;;%E_c{)6N`CPUW~2mdbNt+T>j0pfI0X
zp))5f<_u0d9<|LUbZHxp<mQZ{Q4t9TXKP)~)s9STW(zrXbsBiR&9ZB*8o54+hDo<3
z=cFC=&^a5ZDH?I==7z<&89rMUF6P{@aK^%oxikOpOuxp<xV2t?G3()gvcP9uZzksE
zx|vF>HqPyF?am3)&dS|4<@RF%CtePl#>1fzg-6V^Q$EY;ZWcD>IcRpR>)MT@8`t&<
zCfybk(@nZs({*2>t;MW;j*ME0?#-xmD|2@$DdvPqa~gU2PFrVY;r!ma>RssV71wTE
zohc@<aNE@t+Gd8iu7XMR+jO^|*!F8vOXY#WWk1;}@8o!E>l){6jPi||;c@)ZY*~jz
z+Ldb}wg&Dz_wM54NZl^pUbRiR$Yku@72CX%Hae@$4%6HeEjlq*ZPk;Iq#IiWH!hAg
zRhu<a(9`IOYu7xUWWhd5=N^MoJ9@WiGhfcSwLNW;r<h9pB+VIXPOHwEIO*0g-Kb-0
zLy}h9c00ClS?`pfS<Qz8dHRZT3R%?E&TQQ{(U>bxV4GI&Oih(&pKI&Qj!rV&dhN&!
z?MUD3WT~|qv$h#7mUh!!mYsF##)1#Mf}1Q4xg8gHVc~4!>~UV~R&<Vt#<bkWPRiY;
zLF!?zzE5}FdYE-8-;4UPM}~KI-sQU!mOEn`r(u+j+lIAU6DH4jzOh%@cx`mft(6h1
zSzMxBENxeEr*?4}DknADOnP1x7Ikf#mG-n$o~_%CN32y_>!XsvDj0R=cHnAhSLv04
zQp;RLB5rNE>8&$GX3CtflWV<w!`6BS2WLt}n5lKHTyx{prnLr<Yu$7W>rL5wjniBk
zb9Gw$Y_4Bda$T$>c5+cPr_gPcNrHkZlRTH|axUo<+l(QabLPyM8wLpnx30PM<+AqE
zlV^_^3Z31Qanxs{!3~wAvr`tVIW5fF<P{ll(n%U5rnBkdk_A_bUS^&<)^XA(a+7kV
zQN%?v&-zKny7}H6HS<o|=sW4gnt+pOSG#hi9arj7GI0r7vSg~yw#}wxw_~HC8-+X@
zjKD}`QfTH(vlnX?wQS0p+dND0vP|~!l9iU5bF&Q_udBPfQ9GFv9XZ?SQr0o$)naSY
z#7)bsx8BIo(B;<AiCC2@bk!u%Te3A!;?lHO#~GsfsuMP{`dwTtwsEWLmR#55oLrHd
zq{R^@*MymbL>xQ1IP2)vEfL$+_GDcXPLr59)ouDVLB@6UlYAE&@NKoYc%kHM&x$Q~
zmN;|>>9kv}Yfs4)jor*W<(*_^xomILMc4F*Q)yGv7G|wmyWv*J%vsyCP1VB8S<d;c
zo!e)w)Us(~+F7n;%etjZeQtTHCUquqIr~IhQtg;vxN%C?6yI(!Z8kHbiGh)ZYDXs>
zmCiVJOXI4W>7p&sqV=w>flD^d$nrQ9xvSYg=tM+w*>%(2Ubo&}i7kPlz1uEE?K-kM
z>`F1`jL@07i{5n2_73z8UAL{Vcd}y6+D+a%<xyUuJI%^;F1xK++SIw=V5-ZE87`|_
zy_H#91YI|F6-w!f-p<<TwkB)I*09OSX%7lJlcn<-riI+yBqFWoq>xx|puf@l#G)_P
zwG5+8^ESE~-qHw@>Unm1YTOYagV?E3TMPO%lhk@Phlb8GJhoKiind5@bn2qk#MNw9
zwzgea?He{@rm*PksJ%x5yT0AM9(y1=Z>#RwC5^o6#Z+c`UCPc3*%qS2<Hq%2Qcw7{
zJn5`=4=i)1EzP-^6X?6e?8BWr!TJTg9M{-<``7xaoeE7A*~B$D;-;>|B=3l>=%5+P
zR4$pXnRd2stHiNwUXw%IE=paQHtFQHhi*64=AOwi%vKFL>m{;q$)$9kGiyR~Ojq2<
z(VjN-*uq?0gJ4OY+q3f&bytTy<$4}Hb#BqNzV!66SJzhgU25KJl<l2eH1n#(m9x5A
z>Wj+`cb-_Y`kC>`jcI{tN@rSUavRNEoy+HYT;<uLjgd>7RIYB#D9W=`Hy7<Xt0Zxz
zFIDGMWM`V|OetrptmvY1mg+LIG*{-Hws<n9D091-%8_QH&DzG3XKc36HVmDqc5<7i
zR7ysM<4&zUpJ2_d&BhW((*!2vT<B4mrR5#u;91Wy+v{wENtEeI!{ahbXDrrnIdSAz
zuF4D*LBok=N=9lNolMHPio!V;PRxjyabiv4OkdGv2PsL_DXW%hs&-heF!svTN?UMN
zBX=5`;hIRL3sGH*gQBI@N_(*`>19pQxN#}UG$3%r#;m9S#vWY_hGVALE)#ooICD;!
zolJ1M*1NHOwc5q4vs8jjIYe8NH78}==!&`)7_lWg=@RR<tOSEA2a>az7WF1v$c{1v
z`NrpJSjueetj>&EN7WYl8g^Ytx-F{KyTVsGH`ODgq2pjiuVd2(*^=e5<)yd785qor
z?;gE-WV=OEZnE``KDQm-=XSiUzPL^x*@n%FC+!LYLr#7A?(W^4d4(*uj+Gb6^cGCG
z91D`Kx-+Fb@zz_H-3xCoJMr$$yY@Vjn;9wxCua%H6}h@{YnF*{-==MEw{KTjmgJS-
z$ue7KE8Em6>1@w!&bgVUxnftlvyL6zrg0@O;@X<rwLQ6kqI>kMY)`UnuihnbL$8E8
zz1&&tdh2r+57YX&cX@KetynkjUO4&445M7F=&J1zUuT4!2{i~c7CGpfqqd%_qv=AH
zGP`g<h>KWrpoG<uMQ^%O)OnP{Ja66duikxkbG}^J!HZLLr(H|YzUWqRahX`jInJB6
z)wFtYvv(@I`|kI?dU@fSS$S{omi3fwPU$K4`Fvh?<yNVaZ{A)#T`!&bR?H-lHRj!W
z+q>I7J=*%7&o(;cR)E~gdBsOIx%5oSRJt9oaJ6Y>`qtZ<*PN@aN==*b@m%ins&(u9
zZ1`mg45L<ONJ^ZX6e*pnYwC46_wB=Gi316@9TFH;9OgL8>!Yf5n0Ja)(ku-fhb6PR
zx<!1s)D9e5a#M2SmX#}3Z1m=;S34YWCCkT0Z5i+4q+k=@go|s$dV7|LP8JFi&R850
zxF)OHZN*LHT(OI*dRHvE=-Tae)FmseT{ElD*VXV^*4b<6zOyxMSUbHH-f*iuQ#VW6
zIw(W$#*K@<5z}+Bf_g7oc)6I0Zsl5;Gi$M?$PA-Ew`pasX1b<J+~vAq^=@a#wE9(7
z*3ObqmXh7LI_Hk3plPyZOVTYhUum&smDv%VhD%hgaw-LB98-4el~`oh<96-h;@BNo
zueRRWrnTW=$A$-msVj5cg0=>GPC6;@kav4_?zUaG4jH=53|zT%(c0#y-kzjsre@vC
zB(7@r=5k$Im>slpbCR{zqpZztH$98aoSZqc-gTPfngd&|Y}wK|RqWU`Zxf!iZIfJP
zIr&Una!X<2q?`$tJZ{{Vxbg6#Kugb(mEPuOGj5zP@MhxN+S8;kjYZ<dv9Q2dUJZv5
zVrT7`uq@crY*A}!+Qc=gOHEf?b)9xOQi50MqT5=R&Pd;ln{!z=hK4yxX<V9SW}d}j
znj>|0+wIc&8&{jfu6wv#Qd_l3C0b#IXh4Udg!X1>skKcv=IDkL_3^l=X}0Mk&5f~m
zcw~){X-d&npG`d`yEYv5*fCYJIH5&%B2SJ$V@^k!GMh4MS<+5}1v=5bTII#LGlPRe
z!*f?BJlJ62W9i5_N4a1|)|#NHKC6yuhdSNpO_4ggx$KQv{l<)2-EPMgM{J3f3d>40
z&J?*4xLQQy;>O-2CAG;46DBIVT=XitxoO#*=Xo(|z9u=fAxoD`&b`ZVs>RUN^j!I>
zuWO&Xo+~d8dA%-K<n_7)9-b)*2VA!}Zb(QC3Yj{)Z{5A*$~|{vW3}?Ec9&an?b`8L
z?A7B*zABTYBMpNxO&8VQ(AEqSopNQFW~WK-H4i>f$(<Jk#d;ndk_zC^GG^hK+O0O*
zXQolgR@JF0Q%(vx>Tc<s<hdo{%GxPwXZh;fWz9Jkc4d3<QiF3cic6Um8#tVd*p#{D
z<Ro3sR8LitDVsem-2h!u9@%nbn%5oWth*8&M!bq%(R^D|v(5_6U3=$lebxfE(rfEB
zN=Njr-t=beva?I96|I(Mn?z2TS`xau?Dn>v+}k^Ny-YLBqhhXZiuQBQnQ2gQ$78lj
z=a%Z6X(^jMw`^Q(wsz{~TW@b$@*5sHeJ|<V3&Zjfmt@zg>na~#Ov-$&^Q83d``AZD
zH$ETvA{y~|*G8k1Nq5if=JUB4b1dU*z0S#uOTikMQqg&vgQjo=#KxGH7AH^CPzc(r
z>2}Lyqoi@rhNZmAjKkcNPFxKS7P;_#*$268#_2*APZV7aI+|q`v?|%;$jalPH*Obe
zJUX+pEN9l4l5m|<y2jBlM|(0C_C~K>dNtEBtzhY$osTUqUA}ZDFKo72)ZE)MN)FCl
zyK92Xu1Ld;TYavjZCZP=?{@CC=vjthI=PcB1@?c=-8#KSnsH;j$`qGLo+`KO3wLat
zsH!q4Xp*PO%$W_Mp$^*wrOqm;O!8VG_CM@)VdgYlC6!4NjEz+oJQb&1+NzY(Gs)v-
z?k45PB@;K@-?^>q))CM_t{2VRJZ3AaOv;(9;_N%gQ_3XcvS7!x)owFVGgD{XT)S8~
z)MTr!6E|mfipxYzCk}<)jE=-KA+;@;Q$r(r4YJvq%z7?vQRL=`R*u$UVEs33b$0Hp
zwQINkz5m<A#SyeQ5W0}e#YF<dGjQWL0@^r;B;_cfq+|#hcNR!ef-Ok{tyY`9P?k}A
zvg;>BH5U}42&$jHQI=6ui6x<<<A{rkW0Qd!XfY4++BUF#`roD-Rx=4tUoFqbJ-xSz
ziHoshx}Y4R^z?UfjBJcX(;ej)<)+uCGI33o{49!Kuvat5O;@O9Qh{q!m@Y5Jn8T#d
z1KRy4KYfiHqX%U6Lvi}SR3<s@<FIvX<}uS3&SsLDmc}GfA6o`pM3-E8J>?jf{qNuZ
zzjv?4mKJiVa=4uWox7N`kmIJ4ke`zv=&(b`L5M<LAc;wPzkT0Vvr{ya!zs)&zr6Um
z(pp6huamm03q*MDs=keTJuz%Ti)zZWrVCtb?<O?_fXHv_OHZu!a1z?&?U=zT$XxE}
zpux&q?im}_5G2sDKxFzx1x68O-=9CHKh$H=%(ju^XWweNd-o#IZND@YbzfC|pOzK_
zvryl*Nb7=m$<#^F$Kh5#eZI~$itXK`P2SbJ=j{~Dkly8WQupyrm`gr=zOJ;Ex!f~S
zb?@Du-=D?Te!qS1dwJFU(Cv?>FI>W;?J)1ppWmPL_x*n3BrtVS^xZpOp^gQchVIXI
z@2Z}JE>Yx+RNXt>=vmC^nZ<gbWqBIOe|P-_fs;`Ge=oN!(z+zjvS!k~xT+_i3-VrS
zt8DKBxfE>6>GLsNTX^rPrc47XB<v;cuhDg2i){5$&+G(QZ9NYbD2P}<a@}2!4K0e=
zD%*F1gJRy^{8hI<P7eGc6L|LQ&h2K;?%bX~<>%)oDpM3y*52=8bhvvd;O6elX=f+0
zzk>xL*f_A$w|au4CO7X!3F`d4@7{ggw>p3NMFmEg`W#STfE_pYu7f6rQ(X8iSWuxm
z29!d;9={~evUb{e&z#Bs{{P<xK4l%eMh!x&zIIyu;~%!vg-6e9V;48NB`<Dt(so+B
z-&?(ulhf?&e$TryE&ura@~x`v&+ixCs-JXrzuoV7H$9U-e!u(HQ?>v6zUNz2ASzU*
z$<MDnpXI4@`}g}@-!7_5|H9<`i&6D2!=!%=o^=i?_j|Y2mos*$F&HpS+WtE15Mx*6
zT$zjY<-6z2J;QWz+xi{W#YNArmtU?o+a|yvA=p)OuJ`oach48+%?|y}o|hN%>)o%Y
z`ulb4d3o<Ff0oy3*VWlQUmbt#%whj4Z|goE`981zz>Jm8f=|ZC_j7jh8+GcO@~@P#
zXJAUYXqYkS&JyplFU2Q)FW>j)cYN*l`=LKqT*+XVpy@DSDbK0<_mBJkdcAwyyWP7U
z34ku_;63?uxt_O9il|E!lP{-6AM+_gdwrj2=F{sh-~FMzG;aQ)y;@)Xv;VM=klRq_
z^=0FP75xo9UNTHg0l#y9+_pJB<5@Uw(8_n6Tf%SVY&SZoGCy_NoztqDPJe%d5&V~K
zs+X68R}Vts15ECpcRz(Mk8R@ZVjGV~$1cvCJx`@DJ6k&HSG|gA_s;Fi`OV1%W)tuG
zy?x!dW$td{z29$JO|o}gyCygL-LuX2T>9R9jT3wQUdUc|;_654PerRX%T-ML>Ds&4
zx^&G)<uB^DH*ZhB{k}Rq+Q9Vpdn2DMTefc9`j1(}harLK&)@&{yZ7(k`~L3T+qqi{
z65Avr8W=vP)Kp|hKH+{YU9Ti<!@%BWz3ct`k~#NF0<6o+R_$YmXze&~hGAa%jG3SE
zpS)ndXTKjDft7Qmr|&Xz;j}q^H+S3nTlep(mjqZAUH!oHq#zZpnzi8vv(0(4gHz2z
z8^qXxHj6J&w!Y`>l3{STMvZUTs~!HF1{Jec8%@=Cuw|dHO}(w}t2;}*EZC-MJUl$J
zX6?2mn@_S&V(B?^`f2XgO4aV2%MOTxR$$fZ_s3ViFFt#J)1MZH?;2bzkvb_hAGrlO
z<gSW1DO5lGB(PfDQj+DTlwi>WrJprx*>Y}9Ha9v^SNnY`XeAsHj$gXT@7+6?0BDIE
zm|YdE^5^D01A`YK2X;=9HQO-xz@%C8*Qk6@eJ8}SGhzP56?Z<S&skb>xAnA<zq{J?
z#9c9)Rpu4F1q*mT*Sjrio|tpmR;IN~dfCRGU-#~NUv9g`{qf7&@2Yp-I$|%gJJvk0
z=;Wk$%d#6UcXOvj+UkDU{p<Fx+mf&I_X`};Y~W#V0Fy3Pe>f=H&%9VHJv~O9QMLZx
z6DBsso}Y8Y&3E5D@4Ab@;eg@1nOD!eFW=!>;tR`R*YkT{s)gJQXHcK{?1r&$X}k-U
zzJX+LX`1NNDkmfT^68T<GPJHqmgv=QtNhs*T)Mqrp3RIuYKMhOx6kyNQqU=7&uM7S
zx#7x<EKpPk<^64Go8kFZE+;gles0Q{O=+IfuAH1{vog0+C+?H@-go{joEtLbLDM{S
z`ql4i-&NLp|FL)Hs~SzCh!a{qBA=B`FAZq@3X*4FU<jD(8LjBKXkJRNtD4w`RyD55
ziK&-XIIaHh^TY}DV@7#T3vaEy<aWZ=aB{hJ-`7)**F`<vufs9RM=H~0Mq_0?=d<_G
zx!b@iUcu268XCIocKF>y)kWK$i5w2Pd+nQ0uIToHWs<Xv&6e(#KH)hf?Czl%X*p+Z
zO;}dj`|jlK-JtsmPDSUvhbQk<t5!Q$H|JJwyPa3I9h!t!hc?I__`>9{WzCH=E6-Fh
z$(b4w8Bh0x3EmEhUU;B|NuYD)%$buF-&dcSZph0dTfb`6s@1i(qYF5-^BPt}_wHe8
zY{>F1kIsFa$EddL1y}2?+Xplx*wW6NU75G{?yYHWa<}*HV3~1yftJ|oe1-)HVAt;Y
zUY_N2?%2n@ckgbyof}>reeHXB+3j3Vc@cDb_uB8CXFu2cE-zXoc6;_+b@Q{I{kNBA
ztqfTes_kH1-=x9ia69hpwmWb0qu))Q{rvQ_ZQpgb-MO2;%P;5Qr>85kqNX;;9u#3!
zuw|H_)Ubrx>)5fg4LT8X1zbg^B#SX@OgiaiV32H5bYDAnrQ+?HwcCE`Twt)6Fv-cu
zlYwdK-+Ld}r-tu+&-d!b+d1X=>zD8Q#IS08^*!0EA8%W{yC3ggU;BhHH17Kz>(!69
zl|B2xd}{T*@9m{EW#_E7UuJgMsdsOaXYRIpXZv#3Mwj23&rtU5q}uJ=*SDVCy1Kn~
z<p*}%n60iNfmxtHTyOTZ<<{*rqFk%4zV-aTz+gH1+U=By<q@74Yj?i&Z;(0rG=!=8
zWW!F;*I(|ZrDfi)3}uMU-By27<$G!F0hP78m=<OveOvN_fx)^uWpeJer}wPlcBDj3
z=liaA&p|Z&{Jr!1^UkRk-+cY@{hkJ`_3J)f`g&ODnB645ZMUyiysUaSF)hZ@onv~X
z<lfwEo?>rXrghz(cjX7;-0xEZINz%=JqcfbxpwBv<+V>kR6yy-)AlYn&g&aiL`m#j
zX~)38Zd`RcXOiA)PF>OMwktm{&jcAHUJ5hl%)M<_7(+uH^!L1bIkVy2>zNbJ#GIRV
zWj+G~dw$NO+->*XT=HGC?fq6ehPQ7g`EI*?cb4atu)E)uACTEvbX6qK6_gm(z43j+
zX=<LJCDyh+%fEqv@yxyYZMRjrcOCL}%{`x0!|*IWI(L#QI8Qv^YR6D)zG?;2s#Oi~
zm3J>2Gv2*!tUO}}B#dOvzRum`v3rfmmaseDmLK3t`?~F>O6)bEDDAxJ;0Nr+@3j_i
zty;xc`@G!e410OZnZDG8-M1z`U|=XVU%Tz3Ql8(o=XrVW-dZr!PcMfGJbMQgK;ggm
z^mf}#72lKF?%X|l_wI_=hjK#i-hqPrw#n_B-7_bqtvkT8^OEPb+tq2abEg*@>HVtS
zY;5_Sp=Q;p2CenWFZ?#P3-U~eJu}ItVS}mO0S1N{>3-Y3y-Q17n)Y^fcGND0@_O0L
zYxnM+IWseIciOFM>l$Q_=e*9(dzR)EZFYP1&Y9CXw9R8wHkgJ6dk4K>V36GN&C~4O
znX|XD&2Dbnx_SY7x$Pw1?VF9uW}V%ZyEf|u<K6QqlXKskxw-3;r_tRrXKyK7%Pp96
z;A*I^uJ-~4hOB!xRc_~Qn!DRm_IA|O3(V8Lovc^8ojc|2Esu8~%VoB2^EA7i+tr}8
z;`zSI%+Hy9c#G|N(oTMvKX28l^*8&k9e=w0Q~Q&epl$j4HtL_cS(mAEW@i8C)3xst
zCS+&3G?^_g`JTJ&-d<}n!4*GOKbyR@Y|jP{o2hXQ&8M&3opd+bSS|TeI8WO1xVbv3
z-o0nMd-u+_de6IeL3Ffon_;uGWcQ6Jr-B4p6plFvO%h=WIHTyG!Lo3MFOR`t9)q)I
z4;!m6ED&l-<YIJC<vAqIut2DB_tLvuj2dYI3lOTE8Ui>A&M1~UHF!z3Xs|L&_c<i)
z0Mcf+QKQnaiu+!R;!;gtkclCzz4iB-zL&mxe?WfHt$nWX%GnP+9UfSQ%9NW+9TMnK
z<Tz$HZ*SSR+m~~0S3O_7_l22*N`oguPJ<@{^r#TFbBwARR5l1jaOxjD^^__8j>nSv
zM;o%0Mb|FtUG1B6;>6L+iEC4uBG#teR*SllIaydGCroLX+m@rNwoLX`yA;@6?`4!K
znysjl*1J(!G;NAjl-G=~wb}MBHZyGId#7`N=?nvd)pfSX4eY$?VhN0C3=Fc_&7KFC
z+h(0(u-eWx!K87C$&D$yC(0IjB|(;<1`Dpq7F#UlsdhDTt#M9P+No|4?ZAkYD`)C%
z*{HkJY+>32mEe?I&o#G#b52b&<&9k%t=21c%PH(;+Js9{+or9S+8QmjChO4Iuw%Eg
zCL3-u40gCJ7~~mn<)&7mPZYP?)}?MHZHrC3Iwmd4O7lt7nAA2q%2{f)N^Y*Pm|@u2
z1zQD^rd*w(on;&?b=yc~dZs?3O1-nv&6V8|lfzV}n%!dAb~I=0R;d|R!fss&4!Z2K
zwkyYHHtVX3n~iR6^mR_#svR=zV8$%3=%lF;j;!0RMJAf{imVA#Tf1hnYIo+6>xQ|m
zVvAlD2W}4b@GkM}<Vu@%<;bj!IxB9P1+F%`l(cEX+SO)@TB41VPOG^covgLys^76I
zYPsUsTNj5&U60I;GF!o6w#X|-<508K%Fx+ascAV=H_SFxH1_fno^EKsXjvbodn1#l
zOfBrnEul<R&C;umJ=qCYJGNeWHf2|j-}303#ctbfX$uR_a+{oK<TKe*Su)_wrkQ?s
z%0(_umtDI%?9FwRmn&yHdE+}V=JqbD=5T?lr?ZQ$Y1}$9GfC@qrkB#BOAD?9PE-!g
znYPtvjdVa*cTU98DVxhC2gP1oCzd#)yxwo7*ukx;VzYE-ZY$B+>LH||*`cIjQEY7P
zvtZG!2?kRZPwFZP75ev8G+>XC!}PB%jXF)*ie4K<v<0SYnQAiCV9H`nFQY)8DZyXe
zpZlL%{<k}K+HK>o=wE-!>!*e=@0+Z>Ew}IHwxboyPviHOUHzpalyf`(SZ|$4bllYk
ztPfc0pFUuHz|SH0^!3cyx!XLAq8l2DR$sbv^=SyG?6=x^_FjMNd-we5dmp~Oe(JgH
z6XjIU;DA{`3wXdla1-e0DQOKSvlxMv9JrWrYJJS2{h>nqmxMb0ax8WYQsy`*($=WB
zL@6S0L6DAz>!F3tla>kxDzd58iyRDc{c}>pXK6r4-3jIVcN3L-)o%GJq;v{pnqA7w
z-Jp`vtE`e~<~d_+q{`VXE*?IYJT5Yt9X8su?AkR`rrvF5T9UoG{$3EQb&3y&a5C&k
z6kNp7(~;4;(BPP7&&r<89>XczMxlw38p)iki9G^tXCh243JOfza(2Rri!6%L^-dfT
zlSM)!T;-jtSW*^lS$1XZq>Ljs!!`y-IY+fMvq@~0%FJBS?aOu2Wa&(8w@tH?Zj0rz
zhy=7Xu2~t8IBjvnEWs%$2aO^&wk1ttIu@3eD&!lH*l}8Nh3-OwwAoS~lRZ?9q#7lr
zTr_q~YwR(N44q|gGALE7JItA9nMA^D!FtiD5-C@^dJGIVuF9NhveD>fPGE;ul&JPh
zqufa;vwS8eIVvh=v~)yg3LTu4F_AZDwS?hHXP$*&X<3@iFQ!a7GilpRP17k;*NUoL
z4c)+-<-0gHTQb^AW7#FmX;IBNq0+7rw|u201#L2w>bkn(>S{B=gd?ljxB~)?DQ>%+
z6RK06sk`lVmZJB|phfXJ>NefK=4pS;li}}yzgOcXxuwqCZI#;grh2~!>rbscx1Vi2
zyEFS)*F8Swse#9fvLhGnUct3$)vCSUK701s7GHVqxQXE=Lr#O4gR}zg90qB|O$;{~
znG<H~Hr!;Kt;3x9<LT+C=RDuWy?!>|)V}MivDu9^>-X31pKts5sDriL<m}x>KI`7h
zREt{AP_yc9epFiSCZF(~+jr&KUQV@HDCcA|p<j`Mg~|Kg*)z9uH+gp7JK$g$`Z6!;
z(<+8ls}{(r?vUPfz`W$m(elz_EAQ$Z;NdBT1tKkqdN06(QV&F!8h0<*z0g5JdY2a?
zi1cm<;Hq~Lm|g-NodS<hd8;vkX)o~b2p2jT|A?hNBH&NxyS<n1`rEF%t#d^AWaYBG
z?|y^Y6lyY)zvgnvtzF_dZS~#!w3MAj=ia5)e%)XDy*xVqQuH_X*KYfxbk}d=R=W_X
z8L2aU-@Bio4D~Pbm{xs{d-v{T8nRE02C$X9tlqsd^rg<bM-2g7AXh1Jc<%!HVFxS2
z0uiQntqcqDUTUy{NIgc-_)F{sn5TK~>dXKs;=K#<nzw@nD+9v>riK9Xk||(v`X$et
zZS_G%-&fXGzgOAt>0tHa(-&GSmTG=%lSpiRY*!vH`Ss4PcQv=ueq5C^s<`xVk{3JU
zsTGfR?zkq<lE~p^IB##&+qc`7-Q4!|e9`+V-U*xvLJraj@I$p2H#d0ZaO$v3WAc7`
zYGwF?fZwa%$Gv>FeE!6<W;f10*>gGW`~5sn3+{0Jq`I{Wm9K7T>94vy$#d7FE0qkD
zd2ge4?R~N+?puf0itVquvtLbij5HBhx@7P7@>46=y$b~R-o1PGS`RtAKrw&r-2=Y4
zR*|5nX95M8hm#N_jPyXE$ABL5kch8`jZR{T`3qc(4h$*`;6VK{DOz{_OqFTzr}InS
z&3je(>e<X?Susy*|Ji<jf8OTvNtMHJk5t47K2fZ?9ai~#e%x<)yPBV$pN223o^5;V
z^qrjL-IH}rPCGL*&1bX9$(+64%j-|AV2>^k;Cp@d?p>X;aiI>Pp&`s`wlgp`$gKLZ
z_wJolU#688g5qz12$MjI%3W}hjA3GM;9xX&YCuFNLxVtzq8cQng9l-!`G5j}?cEem
zs$T$3H(+w<0uiS6z3;29{#~1$drz^RgUNwmf|~p~Mg<R0x0m_z?%lilcJJQ3%Y$VC
z+X)tM%&Iha<}f&TCa64PnRZ~(0R~XKGVriW0LQQg%d`W`Odc$g88;=E6*DlXY-5?j
zAkE~#GKa}K!INRq4Tc*+1#G7iJQ;Ex=We^5o53>ecJ2mF1)=ENwG5N$8C5qhGO9M@
zJY!DXpt5gWLCnr~-|xqL-}^LfT6;m!D#lCR%(;_`&Yn!|umSZbRxmIyty;BeEvQR#
zTV>kq+-)b76F?3}!gW!5C!F+|whB~}o%ojXrtOV+y5-8Si%~~Z_N)?WVtwkuS$#8i
zlFzEueb4HbIrbz<I0=BZvg@UNJG=RId2V@rcr3*0kc16t0#3TY&@kzM=NV4jM%9ly
zPrZ9$Gig%Fq||M94yrWYnDMts;YvO~gO2;&CQqig2=-}mtWTy)R++53YG>cG#}UU2
zTR<(#o@AMmv(JKCmiIm|fP$8Rv0epq03D}-kPm}_N`t3?v>J2j=e(lXbMGuwIjM3w
zcW09)`$ogxERHMg$uYzl-8-prX41Jcr>*r;HaS=@PYpd&ZZ37qut$-@4K%R-%;$I!
zs`)VE3m9@ZEkHrsU=}Yu)m-mg=)LdHQ)cGYZ#RhhP|X6eVUdju!$!I9soRZC%1kzj
zJ87&liSdBUs&&abP1ht!91>^&O)m7MoGDjJ$$dR<efa^#ZCjYUbGO}KnZT*L?HZ_!
z3=Sl-V#ZB3gyMg8ah)`pb#hOrrHA5wu0Ko+4U2C#96i9mpgEQ6kur1Y?|V1cW-X{+
zDRzLFf5WjeW~@sNM9x^jF=>jk*|dZ!E7s1K$my!+Ds|P-J3@(fYv{Hc*{-H4tZTP*
zOj|8=fID&l&nl<VB}-alW<(n@FnW0|g0Dhn{NTvI&tJ~cJNE`d^jz!vwcma}+m%z@
zxAktbcQ8+E#=BW7n!LbUs2R%F)R(p0eEhh76WcYm3;y#N-?MaTdWyyc%GAVtzr(!s
z+w;Tci~AcG82D?e9dgT_w=b~ielO#a^XyFD;ot*PmO3ynFa=93<yvxrms#1t<lCx+
zt7bL(wE4SS_FXXfs;a<BXNRf=29YVfA&WC-Ez59o^I`S%^l(+a!f+%*-tD&i`yaga
zla_h4dO81i9-jX3#q|4Dj7{}xYxdd2%kAw0ACPyhZ_n2^vv%wC#!h!zcY1Mn>c!RT
z(l@WOj{5>$#aiyRa~@=6MS4lN@h;OdUt@#ZTqbx5DeSUTJ-`oI-#yE0=jN-Ws#0I4
zZoYQC&toF%#gj6O;I-P!YwxU^RDis$nmcRH+WN&|*SGI_y!Ac!KtIrG**CBIwijIN
z%`I;0iH<&Tea6M!?W=;6l{{2B1!83;y<%SV$}<bRD!aUNr;^L*HOq=JOQ)Rk)!Q`l
z<g!UBjwMA-4_@zHhgf0F!0@`9J@#%n1A}Z);L4d=r>-h(5LEG)U6R|iOk!32svN_3
z+h6Mg*H1!OM{fEO$2#)kYwxa`^p4>(bY(hd<#>Pe?pW13jF465>%fcFO}EBe-1@qD
z>!sKOav6wK>l<H}XD`{^z}uS*T6He%b~L^|*G@S(<H+F<7Z;ZtmuS$!UALpXIvbNS
zIy!Fjc628kIn~?SvmijlJ6Cts)}=y<DmNX$2aD<UT;V!umX&r==(e}eNr_39I)#0_
zbCo9M@=nb0xH0KW=Zsr7b)$T<6E=p-n3=$!!?tm;P=rp>rn3u}4knoPN=!Ps+U>S<
zPW_~8)iv2Bol3XPDk>@}>KKRJ4p?(G;-<=G@61et$+{X7#WJ;d9V2pA^sbneFmqB^
z!pvFQeAU!4w%lBnaU^%LuddjvOp~(`y&G4Z%3W>Now5n!kZCEieAOm<7zgJ@2hQ4d
zraNU*5Vx0#ckWWh)wzx<d%`4_+!p4HoGQ6eyZ)@S+u6k#rc%9b3-9vX4P3F}O4Kzl
zYg=#3(d?KTt8ULQjaYH)#@eW-Ik}52MuSfyG`qOASJq@wf$8FCsf*isqcbjE_Ecw%
zGVNXKwt}-bR5-)zX3oU4oUWBCXJlqF3thT#X4#_Lz^zI*!j5vA2+mNs6=)W?$#tuD
zN?ZN3+le{{UIeTHohRs2uJxSjR=L*m<f!Q-R&R5%o|!$#o^i1|_twtdTRXe6j&WTH
z4D8*y=t_Fob;HG?+s!uSO7*UZcHI)~x+Uz`;$@TkTyw&DN-lYxSe+}?H_OvfwBsUZ
z!N1O|hYW(^u?J5t)eg(uyhb}MsVyLCTjv(<l<4}PXz#3BU7JPIJT`lrS#v38VX9lx
zwXI?|baH#uZe}KIjN0TH#VxkA>zKD$uC9*Q6vfOOsi<g9Bb9Ae5|^%wj5rh6b!)4(
zT0~fKaIVzWPL5uwTQ|*SiYjHN^q6eevdCqo*wIz%b}u}4<lT*%*PU|j-k9^EJTw}<
zHoYFaINjH+JnLDmZclXDW$DyqyC;+#TbFb-usKvzV&m#LOO!HK99t~ab4Yc@ii2z2
z&2`Vs^0bVd=;`hCy5#1yRGEt^I#$+RD!#ebbtc8KJ@S}nyjwe6ZSKuzOOtn}Zk{@=
zvSjIUt4x*Kb1h2mUY?z?b!T(-bkp44WQkng&7t*KQ6i$7nwnCs+*ork+NdXFrMIuN
zSZ|cs<S4VvN|R=)<V?FQ6cwnH*_o&umbP|7u+SB4v#g7qW=9w2Wcx0=rX9+2>PDE?
zl*wTlsYcNvH#UI|9gN(l78R(ZyJe<Z))~>MtCKFSjX07!b!oHj(nVLKv{pHXvh_xC
z^lp;U4$i8Nat1B8&(uxvT{}}`%Cwt8H@9({omeg=taWO$>tdhFCRaOWt<~vPxt!EF
z%``Pr(&%PXn~y=l*;yBRSL+xg9LzeiR@WzYMdqTm1v*>Pt}F;UvtsJD;53nr+b*HG
zy<5D(rcBMb)~&-kDOotmTRJIq+mf|O*(}#qrb((DQr1YAe%*nQzg|_kaEZ!QP17k0
zy+oEYdU54$HTGuB-4@`@n&#7XDl;fhtk)&tl<z{Z6F*B=UQbqeZONI^vdJk{&?tAU
zI&aj@Ez!Zc`cv0k-BKxc>bBd(++LphTubG77bywceD(0Yt)=XSU9#I9yVX`5bh{wB
zHSE$!<0p%zoNwHIxL4t)Xz#iD*lky5%3jsUYwFBxdOdmfWN%MR;b})&XD+%F<-7Wk
zsjBqDj*bqegO@h$Sgmz%slIVa^};Q;i*{_e72><?#w~5PjTu`dxgEvK4oMwx?T!}`
zS$3btNm0P*w%lgT=-ijl=DpkJ$jIEec}QS$+N-UiGk&ZJITxAD8Y*SFV6&;jTIu@a
zY_Z<O5!+PEx|EKcpS01-{IK96lZuBsoUL-V=1y57H?{Y1t`UDbJBL&LOtU)*t*diZ
z-O4RE;F)0{WP79R&b!0gUK>m`>-LPho$H;udY0}QG2Nc*q%C2`F0QyOoyeP{bacKd
zS8(phPGb>PgRoTX++AU3FPly?o5pf+>();%>o02WIGMYrYmsrzQe*Q4i#%<6RhM*{
zZo1{|lHoC7qT1OTQM`hg)1u|%rUo@X%Z@R7JIPaJ*|M-}z9yHQGJI7gO<4-UE#}LQ
zZMl;d>FKzF>qgdzTge%dymD1n=!6|k+mJFj(mNpHcA~_rgOhwybsdv)TavQbJfqe9
zF5Y=$cu^}_!&``D*0CkGysmSYX(=rhyO0y5oE*k0Hpx`#sPAGErM8eM8zxQh%uwr@
zWpU%gbbe<>h5FQWF*2JT#z+OH9!Z{ZCu(-gt)tm769rb~%#u2C&0EFOEHWoJRoXk(
zB{baBRl!5-R_b=+pwzH4FIPl+CTPnTWj)<;QdO+Cv}LLBaaqwxnbtmcHP+rXX=!os
z6-<rH*}|>0*ePvRu31ON*37I67q|0%K7CyIRJ3Af=rrReYr^VJoeH=jWVUp2nAeWv
zgl)%6r2|(>_H||EZHzW9S*Ee<q{)m|t%gzCL~i;f9bKGrR!mpwveu-#h88D#G&gzW
zXs6_?4oS{&ZCWjLRXWma+R+51<VCmFPP>+SWRgoRbBl4?qno>KXXVabw(O+TOgGhz
zP*0VKzEihdIwPyO(#LYEPW>v&v~wnT+iuNj-Eg%dH8*dzTj6G|>)tAhJ-6Mt9kV9)
zM8`o@0YTlRRX5jV+}a%&ts=|u?9H6#f~K>h)f7|LJd#n{a&czbmZa4|CMh?W1h*XM
zopbZ^yxcpF)Rb60O%qtP>O{sx&E>|CLZLm{%|ha$a<4OPY}?qoCOT8gJ6mvLeMGm&
zZO<j<i=~ThMQ%-Hx#&8%U~O0Ls-3+nPDwdMYx)HGPRh(FxUp7ZZEx@5C^NI(NVQ98
zk8)>T6`dWnI5>B!bhg-{wW|!*xHet6vF6IH6^|^o%+YRVDl?vJuJd%Y<aWotZOa0;
zgk5S>&B;2t%{#a1<D|6EG-0E#RLQAv8zbwNWO5x%o46z)V6n$UL8o3N7oVFaw@uvA
zyQH|t;>ny$nIgZuA{9>)ncFUtZru!6qG=Lwv}>n<jM_q9;jmM;e9oMTG+J#TBgV!j
ztmP@W*zJ<aA(PuCE^Y#C9+Qns&TeUG+t{^glVCz<D06SfSu@v7+m@!SNSkfAa%);D
z*P&M9dW}@0O_336rUjdML`A7w+{SQirPkzV&)%@em9xDKrmZneTXrzYaGP$=jN4LO
zJ|RI#+ctW8F*B|W%FWc`bz8V)8>fb;RGY}9qpT(yU9L`>wdqPu)WwafQ$1Kc7;cy`
zTwBMPoLkJg?P>1=2DW46g$%bY&b{MM&Y7HB*>t<;*oS%s=49&~4LRxM0#YX>g*Lgl
zRBw3g*Pf?dCYyQT?XjDyGPss4+je2LrJT*l2{RKa&MxISyHIy3@2c+1#AvfHjWuCM
zMGT{st*w;K70it}xH_hHQO3=zh&@uuXBBP*oLQWjlQJb|LDtPFX})WvZuN++@G#pd
zp{C`va8I^z={C)6_1ZbXIl)PrlV*$dc=dQoOqG~+c6RCI<l=MbnOmo9afy5Nw%GRF
zx60Qx47sU6H{<Som!5m{(wCiA@7#T7Zr#1CefQOCZx`oY*>vD??9I7mCGYZX<T*^s
z%w2lz<&DZ?>HgeC+hncR-p<W#JGnx5_H?$JQL}?SY`AbWvfEUjeb&wB`h;fFZ7;HJ
z?-B{SbJ>jDG$!TD$uOQ(!mV2_Ca0b1-K^_&B~o|VP3NeaD?E-e>CO)9=-arHcW2nL
zZB{pLZg*BHU9>h);>j7$85a(n={9vsnK^HgyF8~+MvKd~<0ryat8gZVwN3Nb*xS=2
zEy=<v$#d3dVo1^zYmTJsf(wzeF80<ZXK?XM(@N_$I^(IE9L+4Us%6{BZMT}t?k?nH
zHDu`#U1ywiT{)vSdu@0b2Ty`_0&kw0i^~<`RIM-uhAZ2qPC2IYB#9@&bOYP=u)v_3
zVcTR5cch%S>~x&7U7Wk4Eon}=)RcnR>0V*CRZO)-)&yJjBq{VH?a-B0EtgrgGHZ7I
z4!)%YyxFT0vmO)_1xjp)*y37tcd=Wql*UbyStc15Bd+93>pB>5B|Gh`lu5?LB^MXF
zb-Nv12IfRu%DA}Lb#c<gh^~!dM?%w1=|pTy(pc;&61d`E#EP|ofjurRp<)|_w4{~9
zl$6whE{mib6<}~XniZ+!sB%liQ_7`Ns9q)H!bDeHwTZiPw{Br&Y72{sEn7Dw=t$Pp
znGv^UPLT@R*1P>wO0da^WsbtpCGYYrU*=5N<`vCvapp-$(YZWx-pN*1Z*DbSwk~_t
zce(V{QvzMB9tOO-p5<}f)Oy>_ITpT)Gp?CU3Ro<0%(R?u>)q=Cy~!CTqa_%5h0Y4>
zJU6qvUh>4zJLi1%X5HJq_KqbdCnu-4#jaPU61!HdT9r6w)v9OKtNY%itLfgkd2;Qw
z<w`+ImbtZ<E;nosy*aBi#=~!Q=PX|zZ=-ETd^97L1@$b>G&Q@fn_c24xMbO_i2{rg
z4NI0RndCYxV6s=VimI~bA{o=br0uS)cZ)90v2eI$HruIQY2z#oL9eq;zPT5V^i1~K
zn&&B~s+H0<jbo!%!lGN=s@r*+Gjxqs9P7z44D-!yk$S!Abx6m`=vlXOqNAmAa|CmH
zLUOwU0#{v?xGj{m);Z7WY}B<oo!e!2Z%*AMa@Z!lQ#fDY+L>3Ynu4nCT4dU!D^<Sq
zihSNL67ex8Wai}=_1br1Dq<?WyW~d)?#|tH)UfM}=$V^ZH#e+0leWqrRmW%9*-1IK
zqCKW5w6$dvH22Fe=f_p8583-(`>IW_VUo`gQ?V^(In!26)_cA2nfZ)+<+0DrEuUK+
zTb%3Ja#%X8>r}|Lsh1bCh2Duy;${pA>vr`Bj84*8()*B4P9<PEvuM52gG(++&(>Q!
z%gHkANp{gSU2?`ZNl8gLBG;@pQg_`}OOsnZo=Yxensf=N^mHa|yQKMcd(G>g|Lwp2
z&-?m5?tA6?>ieg2?jJLqcIZYZWRReKb6D1C?-=L+lXd{(sw)?G4jY`&<~qQ@pciGB
zmg{B|X*P3pUe^JJdL{;~H&?ey9bjN$F!$QcU6yrw(FO*F2Hs2S4lj*u-EEqC48d&&
zDYzVVUFre@LjwZ?&y`!#rka}SnlAM^sXEDblGlu7H_}X}Me(vuRN1WcwBcZ;Y4Pmh
z*_+vx&Yqq0GV<Ef<z-Jww>?=Vaw_G{28jj+r6Vk}>N!n>ve#aBa=Z0f>s8J)zKEdB
zTf4%Z&UhOl9cgyuSTt+z#?{7Ask_5+%~o!?nQOYpNn@2(=f>S48|Oba+}=BjUwM+6
zuaL<$(WGsgARcC7U`yGot*WY%X6myl!)V#DQ^mg1j)b_q%-t1`y=~IMDYx@NOCw`;
z<fdIqU;v$o$;4o|{r&G!mUUcR|GTDsK0Dhi=jLYc5glN{z>Nd6IJX0FIAp>R7r`ba
zWq~A)4$%3Lg5U!q6^?+!1O;5&I68V<Tm-=jcLiL)3vC_2Qi3cHsnFH`d_W^pJ;@SB
zC8od7Ws;okP{$}XeXlN)i?23R=9r<IVNVihkPjge)6vlkS_{m^aS(A#rIM1u5zrc7
z@KRn5h$B0iz%Eys9^lU;!J?$31YT{cKK*1Wli2hp@{A&&vnIKjl?(-@Zwz5mm<~T{
zlJO4cJVx#5zPp%Q%{apjg>IOd0~)3~1}BaRt!=rs0l^2ersnK`1k%A~z3JeE!(#G`
zqSFt^F>;CQo+!~_kOXp1EXX$?gEoSe(Q0u^95aut{rCUz-ThtDz5N+O1!eEo{r!Hj
z`hH!0#j7v<Q**z9)v-yOpI`eadip(oMr+2(=~4lVZS@mea?JN`FW<g6>TH&C)Y+`S
zSqK^%8>GfL>d3m?JJnT7@1C^Oev!MmM(fbe_j51BD$l*EddcGbzI$z#0=CV{_Hddo
z>DQs>HWMN>qFwl&9lhI;tID0ZY)gwKr*>lTJP(~Ix{JM!%iP$#k$1_$Tmk0Ub9V_G
z(}?!Dp*?SjAXv+~yBx_Py31zgUT8DCdiVOg?|UbGeZ6}3`ujV;fdwYc-#<T}`+i-`
zy<O9@0vS!}?-lo})<{>cFP=PU*X}uUCcg(ADhdj#V}?EH=RW;>?^)6xx_$TEOR>sx
zvLn}eKylpe?U#4FW2~S49(-cq{^L9NtM7e3$M<uqHzYG4k*p=_C;imlwEg+d|F&<t
ze=`a!ZD3MnW1F~vfq}tfg4zA+_xG;vpYf~}G(_ldyT11KwI4tG4qWMN0A2sK?cct?
zZ)<9fCj_xA1Qjw9%<kWx9vH+ZQvZH`)qQ!hzFa4PxxX(gop<YI$K2}PD|@2iboJTF
zVy<mnTYfq1dCs%KIqA9<cmDc36n1e>=S$DCcxUmh?75Z1?5~E|skzaiyVl&=t$S<%
z1Jm5A>uwkKsjj-Q*~L4wbJ?w&ZWq@{t4%wush#Cx_{*pEeIIze=kI&p_rBx%zPtY3
zxALHy5f{ytUAZw|Io!a3`F-`l+E2gV?`uxoc3a3(<<Ink>d$=d-cA3L_i#s^blbyQ
zKhy5Me!jl$`F!==U+VfF{^S1`oww~~R9FOiTXFvB_xTlkEY<gZf6_mH{`~pV{Q~{%
z4;g-c4^>F~J>yieS)CW}?@s2vcf9q@e?&t=L+e9B;|mzySKouJm<tUJ4Fla8s`|Zw
zMeyfWk;H3j--}(jy`%8LZ|ms$3gxZ4mrQbEyYlu@Zcq8~=Wz#o-<RDxzW4Rj&%5qV
zzrXhl3-8L?OKwZpX7~s1tNH1B$y3of`|d8^jm=LNzIJ}Py!Q9E**hkAa^8-6dyi$?
zv%5BlmW8ZLm0P-57DfM2IPWi{@b{g4b^p8P-)rx&oE8-QKGV&BEtx^Mw#_+EN?EYu
zTD|e|yxYI`-ud$G_K_EB_MX1GeZG2l_{r++=lyP<*NU6G=C$=ho%b#8X9cf6^!@(M
zPpei<w+vxash6+2XXEztxZs_QkHl3fCN=Uu{iw#I5|iSgYhSlX?(6d$@rAX{EaK6%
z-`~HlJ}+1Kd|qW}XndK}ud4Jl21kufdZ#Si6m*kK%E$6rMtu9>mp}f**X-K<{QbV_
zdGYGIe-u~#vAI{z|3E?cg8H|+weP<7?{OFMRGHv@w)Xq|+QJw0kq3V-ulxJ^`%`c@
zhd;b~@B3aT`*^vNKpPK7^%vW_-(HuO{4(BM?3;Oe`8CF!yY9Wc#C~z^^;y||cNOF#
zSf9PF-tHm$wIS}|u6u9q_^(k@DchFhmE?WpeWm(#0|w@AYk!CRU0t{LJ!s-))vEP7
ztU;;F#!ta-dPFEAe|@}key`>#jm2)g)9>H@{Q2{{-`~G~{_ObjK!YbsUvBg+-f6dU
zJXI$7v+VZ%!LU!i`uV=<c{SCa{_K6g{NdO3DJm=GNfhuuRlj~{;^7lNw)34nG{>gD
z@!ikbeZP#ol<y1p&yLT%A5+m%Bj102f88I5BUbHu$9(Vm9uNn#5^~===5N~~#INsr
zS?%ziN8jYyySc}Yl|6gydwECWhs4Td+e_Xl$V*<Iz1H0C5qoWV-1T$cOW!WL{&w}Z
ztFP;tr5KVKOn)=2VeH8`)|2_$c=gV?qIZ9vcX?lKD_B>yH)pScqr!ZC|B_8#8u<nM
zL$>aDZ)z@TwKHe+*{;v|w)Jtl{A%>0;(i@}zg_N~+WC352Nn4qzrPdh{(*skasRxc
z_chhei_iC++w3^Ye{yuyj6d7%EwfjO3fSZ$KR0*T=Fa2gh4nQ*zk;I>nTUj(7^yPJ
zf5+TyH(Bnj)YLwF@AEO)w$Im>^Bt~QefIrrzQfg>^#XIVK6xKh(Nq)4RL|Knsq6*A
z&D<>?Za?DrzVUd!KckeB>!#!KJSF{6PeWr4dVhX?IQPTt+T+(^tt4kIsrflySjn}-
zPR*pNW8RVpo+`6rUshie@)we?ivb1hs#U8_+P+k2zUi5_J9pden8E|=9^5{-{rihu
zw>71tr7oRRnN;tosBAUsZQ9(r3Ck}{`BiI>(BRzt{oW6#b_lip{v>C}T;HTXm6N(h
zrl@rIOjY$XnCxlxJg*^V+bzcGNg9iIBoYtri3VRD4D$Qr?xL@^bGP2k?bpjqyJ7{_
zpZlIuWp3==b+=>J-FhQl;LWm|bGA?0Phlb61=FU#3}=+B-)|e##C7sO?j+BY$tv3?
z1x!*jN|~y1$XDg|++B>DZf7uY7_{v1I?PieC}`-V25LD73jX}$eREUz=9Km29^Q2?
z6g34831u`dWZ7^e<-?LDPqi)%r9+%1LPF~qgtE%dPpVbqa1u~(l74@GKPbMy?p4&@
zI%$vD$+YPD3!Q4qq;k*QW$;|7pSx}1QW=mu?*?y{-R(|^w!Cw>3%{z&_S`VbT3zAW
z9Z!`e&f>i3J6R^rF5xm{=5ef^;AQu2a_Z&0dAcX7C%=0Kk=lFmd%2535}QQRcemTg
z?R+gCyxg9?>)*YcQ)O<a-(7v7WsBJ)n%8U0yL6}i?S(j%DH4l%6keZHiMj1N?Y8%k
zNj?&R%{+-G=1C+jw1`vloqcC_uIZDvmv>CvcIl&b?t)2fyE}`n=as$C7xKEDp)#pl
z$m@3IrrVhnlRTqyt^^+2J<E$rTb=vJ^1SSwr{nf)yA{1-XZ5Z;tt^AY4y$*1%hF5l
zEZLB!d3$;6F}wPAbIZl`%e`{9<tfZCSj;AIc%pTuay#FW4_<E1b&u~}&va+D(6(D~
zs<~T)Jgyh&MZG<Dm-UfnbS}#zKM-XWovSb8shvBk%i?;mr=x4i!-^?y&z4(eU!T0)
z?@`!o?;~rsHF-+CQ#~EK^Y(&0o*?IY-tpAVU3NNm=_60o`rOTd?o#hEH8j@D(HEM#
zbKP^@s!z8w?@lVtg$C1ZRk?F_;Gy*Hpt{+uIooap9+~7Pkk~9CC(|d9;V0f%oxXeC
z&DSSyFE7;2UHT~OwxddKxzN*fV2x9^UGP+Sr!sZh<<xDLKB`RGc5}tz-g1*EB4K{w
z^__lqt`|?+TWMYLPBnMS9#DWzT=ytu>+QL_xQ|TQc8gPGE{Mw6b}LS0QrK-%k-~M)
zCN*`PJoHiX_N;eB*Vn7(&8fV-?T%+~UX!PMY^sFef}2Z^ObWTZT;}b}ordS`n4Q#P
zX?|+<oM++!CmzEKvpXL+RTsOOUwWs#d&`@-^}BM9%$u2bu&?Ry;@e60n)6g9Jv+Po
z5Z{sIc}<>bM?R`FStPj0NL-kA<YC*Ai-+0y&M(j1x_8=bzmvC@-SI5n@ZhjOS?S(&
zmM6>}dFlzb$tb+>Dtn<aDaT*PL#a=qAhC~i@?joRbv_Z#%02P9>t3zTwN}rYU8s8R
za5InN%|rL<Z>?3h-Kny3Qba-XM$Ov`CV6hO@l@!tNIckPA>wFbaG1x!@$Tk|#kX@W
zZOt!b-D&p7E9;w#L{hWatw&(j&hm6@lhN-k;#8R}d}I>G;x-wH<i?f{hj~2@w+fZz
zOWw}j^*_FX|2*SAaix>rSKTYl-oJluy>4w?cAeq+Y323z@1Ng({m!!K#mkQN?+AP?
z=cF_D+U;%krKMxtu73Rde80WjA4dN@y6dl8-uqU7WpQ7Jr`k7({%VshyJ&l}5A&8x
ztj+T3Vr4!N=*r{8zeiwEm&Bre?VPC<+S!{Hb?a>Mos=Y0c75FqL$4%{+^V<DBFp;A
z=X^fTCpU5LySwkJ_STnPUkDLbX}!MohS{VUlf>h8Cmhx6RNVS{8&A-TNz%k{?aI{;
zI5BB7bR0?26zTHh`JtUE!r-^{tMu&T+{&)?)$48T&ToG5yE@6+*5+dP-FF{7Dn34x
zi_TK4XK^{?C}=P-=4jE$T*a!J*^x&~=QyJi2e!h*?#JHVc6+zxFRvBNU(~YJTs0Kt
z30ju5>a4MeQJ^uW<II5Dshpv!rg^HaVw?P@@#^lrwFQ~X9#RgM*k-Na)m@O;F(u`i
zX>W>2noz_f&)k)w^^2yYaotYY#yin0bW4YkSm?4_*<Qv%X@RrEQiT$?c~0BryOdXD
ziiwG_$Cgt%A*M?v1qby+r|@QOJLKEa#d7J|v4AxJ8+DGSXzse5%9&eUn6_HVBd~9C
z$!+b-v;|jZYinj*>`u<Q5OH-)?rJfyqgywLo%G!n9qPNPSxh_1Y#V!TShMT4HQv+z
z#4@_qH?@Y{_Bow9)goLqRL^popW)&tj<jtn)uu|_O7Tf`YFia56S7=0(4)dbWBHQ_
zfj%vZ6<rQ^tqlzfTNSl3YiZ!Bscs?5LYCkDC}P+Ay#4(7EtT75o6RY#{QkFY|Koed
z?W^mwYrgH?b?fIld->k|_SUs5IoJLqpWS?GM>cDRa&Ud_#|0G%wvRkj=CggfTz%|z
z)V+Jz2N`PkCOvz`eCVo&*uqXbzq>4xyx2RGPZr+JmwUN+b<FF>yF?Bp%h{BB?Yn;W
z()0Z4-Pfk)-a6?lFgYuBd(sp`PQ9hO%Ps{RQP~9%p7bhud#);vlkdvByIa80x63r0
z1wg{}$l_M7ujgcV1q<bNZ+jEerl@vhcivHrB%xey5LapMyYjtnpIdwie~@$Y-`m-_
zn}0WG);^gysZotvqiNREkXeeXtzsUnz9N(62u<Y^^_Zoyw6;`hYUrV*CV`srJ)uD}
zLzJ2ya=QP@ZJFgP<*RdclS?OOy|kv+nu$tgN@hLUS^;S;X)B#J8@niPTC%)VUp2yM
z<D@kyGY%w9G3-g{Xz|@BxF|)9v&Eo;Nm*jEuu|r#QwEVqN2jy}tu&Zq!`<m|HPqNG
zan^!q*DiY+OzfE9yCpNl;A-G3mZK|^wPqdLG<Df(H?e~aCtQ3NnIt<-WKugB*jeAr
zGt<yx#)htluG2<oI-7YSyG|u43n?Wkr!@OYIr*q4rEIv!BpNtVa)soSO-Fr>oM|}|
zI&EoBS_bb_k;uSl!G<XrzP!5IuBattPBid!UAu5;NY<*Z4XqZZj!91Q>G0gBHcdKL
zP%39-kHnQupH!EX52d5lY`L{%Wz?+$42-M94lsyr-R2#|yXtn7$L-t|D{^{Qgj_S3
z{xX44p?=G$w3T668+#JgIC4uY&fRu{QM{>Z`GH?4zq04tmzS6Owr<O3?c>(>eqVal
z+qdMM^#v7%+ws*}>v!+vaoBv}^NaU((>%p)KNJcL4E0h<ROomqq&;I@r0x>^XfR$n
z2b$|IwOWB$Zoy07CBgl;+x5G5?=H`N{`mR)w%a@S56G{zKcQ&B6}<iZ{knY*e%<@Y
zJnis)%cor{lWYIg)z#JV@3Fca+_A(rWZO?Wlc=v7*tUMYU-xqF<J`4LZl67vJeWQH
z776@{Ir-t^=jZ3=+j#AB4L^9HJ@k0)-j|%vM7>N<_;~Zu`0RHt^TO|0)%$LH;ViK*
z*W`9yi(!}8WzVuV&Y2p~zIwM8@+7rxxfHuw;Fg!zWzTK+gsc5_CkYsKMQ_}8L?Kyx
z?XKMIP7+7CGnd^iQS1rWHVec(XT9@><op$97S41_Wn+B4=6wV6BRdxPih3rS-MhUX
z7=BZz+~W5<W$Cv2cK`nU``3O?Hh1MoRg>QESvhkeH+y|P_x<VnQ`@WW{X9Q?`z!|`
z2Z^6dEL|^6KYZAB+c79YX?^oTzSZw5-dErIXjYm%x2D`_$|0qS4<)PL*51`U_4~MI
zt|FHcXk^067&1ZuqCvPGCJ5q0CWg*xT${F45r&sMS${!(g@%X-?_Y_W`+Mph{*)~#
z`FsA(-}9?$bzi(+zka@7@08auS98^8<%Z8IKKr<I*S*Qdx4q0?K1=KO-g}z-ayH7R
zb6pfVW_T#6!4n2=y1=zUC?SPlGQkCFt;@^v_D^qI$0RyE-<FwwdcY(`_UZ2@GTKO8
z18u^0adDX_C<waAck4t*)7flw&UD8VMy2VyW;1C`H%MWWsGl@tsqSXg-ffw8zkmP!
zh4%;JN&fQ!?hTIo_Pck*GhVC~uvJpfOMI)DcE5i9{Q2{p-}cQ8-m+!s2Irj$2PQmb
z<m9|ly!U<oxtH&&Z~bY>H)&95Fl=GtQF;vvbFF=REmrIIKHmGj`pC_z>q<YcXto@)
zsjv$DwvQ?1?fZIJwc7%1hTeIzbDSiO>hAL1*paKMyDN4hN3zJamwLw(w@lgg(hNeC
z9Z~e~OxZ2bb}0xnz|eLn=vGGTmPryvx94tC<Vl)#*X%}%VOMm??IeL?nz@&AJ8eGC
zz5B!PSI;TQh*W7C#>u4&75oj%k3T9j*)YmQmxI!idGGs@P@#8aw`+d?{{8!xd``)&
zU5-k*L90*cmMZ0L-~0XjlY1YxUE2;yP412C0xIF2`R%RSeotSU%BWf&buBwcHal&r
z#@V#3I##P^U0G}j!5dyjo33=r2IJK_TAKq**IZiy!X|U3UN2X9vi@MtUq?67+^yy1
zdGG)KuDic~{r$IJf7jm6kI#Sk&;INWQHxf;3D-&%`b_{uw@1iJP(mnK=%*3fCGx1%
zVxeDr_skXbma`_Fxzd-mq}Y_*I0(#<IqNI2iZ5-!vn)QX=9w#Yz1sCEO|mU<Mw(<>
zijOg92;G?H+`GFag|lSNI-a?*ZWoxk*tOu%N-#_2Y}{T@0W>!}#yRq8X<Od&a_<di
zjFl2+q~&JkX203_T=e+-yzi^`+<jmBy?*ts)$@v8TWsFlYu(BBIP8AD)~eNy_onZC
zTYIN^`+TictF+clx~{cq_3D_{$}y{U?efi;zIM`W)z>N8E<?Qm_Ya)$bNAlp<?H9$
z{`pz<_SM~<eYJP*s?1?us9w(VlJB;oO``21nW`!|$ye{~Ce*k0RDAfnscTh|gpZPv
zm5}PjqScF{tENl<g+~A?5zG_HZVVC=bv$$Rb9vS2>igC26VLit-miY2wJkUFZjMZO
zzr>;H-Oh4*U+6F2KHtO9V4hrGVCW*HWKORWvpuG*JG=UQP0wM2Gtgi>F{2(7w6ouC
z*ZF>a@AnnY{4Ae?%-R-u*DT!jvu(*CJBy>!_u4-DeSV2zk9zykkkE_?hZ2QOcyx4&
z>rM>zn*%lIu)&#5a1`ykU37lF-QS<zL(e^$TJwANE<csWyDv;&+G&%_`R*-G)%OMa
z`aZwp2oyeiIaM@DO}JjdE6nAV%hs~o*hzkKr8Cn*uM1o&jV+BW<V_E~&T|43>xr|W
z#}%7>@n5%qwea=_4%Fj{`Rd;@zHMM&bO?}-h&s@6LnCE^sEXF)oR&c2)NE<qkf2E+
zEfc1OYOI}+xjNy{wi64QRDwE9*jyD^8R|71xl~v~d5xzvGBqkpWoc;X4AoEyES<o1
z;{tTpmi@pN1_p)$3=Ch~w>`STxW49&N#%jB&u6v?HRirEVBE&l!NBOn!0;l$`|#s)
z48OY<Fff>%+Fn~zzWegw_mvN%)BB(X$=7~<e(=5pJA;%&>vOXmF1iV(_VrGpn!G$}
zj+0ZpvZk^%zEGHQZ<SZbR|dvqLRCwq%$jm>0Z&s_P|H_exmgYjD_3f&uj&tAkZ<Pw
zU9bJ^U-`VNr_OD?v*vZoI{10S?;y)RUtBl7iFP1x*<QIlU*A9u;w&kJo>g3b-S7mm
zQro$Ox5Aw+iE>OWk15*=IpX+hiSE1J%6U6F!%L56c5YsK)2wv2+PUp1H!m-H+cTTr
z?bNaJ`NgX@-wP{U_i!Eh!q4nex6HP^eFr|pE4}dTyB)8~c_p^pdAQi1bKQ&U#`Ta(
zZ4Ej@PMx`xJ;x;Jw%Lr^x+Zs<bC)G-FSt1Oj!AksujJjsZsi3RyJNN+3-v@@k}{Z*
zo#nDvY>7!)a@GlGe;{2?$w_TiPnO||GfI(@51-4vMARzK`e(;+E(3jt*AR2iBH3&2
zu6vd<fR=zFEg!wAsha7jH7O`)HPUL*>t?n=lfu4d-1?mLQN^Qqx21Y%Xt;S<eaZ9!
zcF3wzh*_n(K}$`gV|Av3E_@50WwtlJY?t>AX4p~3po5fc^WK(BFJRobcI&fVWNGuY
zVCP6#O$rLSUe>#An)Rk_MVWV}Zl3I`;?a6{-K2FG3u^13D{9%yZtV<}juyKpxN%ET
z;wmL2Gu^F8t4zhNnO$3S<4W#|Z9G0JZgeND%uJ4!>UCQ?b<5h`rDlP-YA138*K)X=
zc00Ch&9t?u$tq`;b_(70&Rwf9kyCdgWO-|6+L_6cYPm~{B2MaROf)&N?UH71<hHQe
z!O>C|#Ok#s3+pgMT=Z?u+UB{%>!#W2jKvWbJ9VUvZMhZI)v?fN!?HD|yi<GKZp}`W
zjMNJ9bvrg8WkyQdrCXk9(~M5KbVM#uQBhHC*_P&E<eaN^WZRLMnJyihJtMMiZknBS
z>`LY=AD@ev%O+=s>2BN@b!_X3H96UViv_oNon5*(Bqt{)Iww?0YvZ;pp}lK+bHyff
z+!jmr+@``aIc=KjrpQc}4j<?O*sMd-wrEEwM@?NbEn~@&+bLQbLywnOTMJvRxKh%p
z_1w_hO4hGEc;W3{w?(E>-OjsYcP-AH9$?QXR)54W?Xb6=xaqc&hf|BqEmzOHyL!gj
zt>q=wWsAcNx2-bm>X~-5cuI?}sl=7!z!@%^rL+teZCxyOY^(I_Y0rIC<_K?D<f59l
z-MMsI;8`J`ZJ-63PPf-Zs_c+>xny!<-z-lHv7^xSv{!o<FPkzwG;&JX9Zw;(^3<Fs
zmv`60R&ZW&3A#MjWK!-S1_i^*?Xh<)BovsK1Eki1Ops2F4mZf%u9qB=<g}t=ZF1DX
z&Z%Nqyv_+5L$+*O+jK-sVPo!AX~*QKD`I9>6oqxA#n_e^tz6lg>EWp}QztsjRn^RM
zwddrNlUugTmef^C^UQSVT&9wlY33POzhT<6+bN5)nvUHxRBgDmG3r>4XTmkpWtYRW
zv`n{YbKTtN+jTN%QkE(2)QwA~W%6taRJwIz!h~rzPV#^+oKBmZn!91z?bL*6YAP2q
zr>zOQ*l}Am?c@~G+~~k<8k)03a$4MO+%mh?8y1{ta#TonnRnV`&!sa?nk8N86uO<6
zRv(t5ay#YL?R76o-gusxTVilz=Y`j6b9V`v-j#Y*F3Yj$)Xkkoiw!ewZa6w)({s!1
z5wC+27Kg1#7432q_I1<bnC5mR%y6q~v}-XqHo7-)ie2j4b?oI?p@?ZyJhp8vJ*_g`
z>%iTt1)WMR=iaQHGpjrc6!@`47t>yzC~YgPUo|`9#t~7`P>GqV%(@n4CfycY>$>fP
z%UQQoX19|wbr+rK@`}{XU1GR8ZObB;Ye#0zxSg?Pns%t#tZt`+Nk=nuqOP*`=Biy;
z*1JW_G<T+{+G)?;kd>RFe5AY#O-`mwxTz|wI(6#Q9+j-qo?C;qO*IR++8vS29kD9c
zGn!L(wrKt4%q>xd$zfL|RxM`Rw&JM7&B!UYQxlHnh)AqCcFJgT&Vr;F+PPD5!!B--
z(vISl&RwOuZEDV;&<&Q!5t|}ad%Yu4Q`c-<*z2tsX*wm)=-8|i(b>6+l|?fXo7r-1
z8Ae4UoSil;bm_LJ%&n<yJd(lEIU5eAL~V|0)tt7pZRM6t^;b8{G@7x^#97&G&55bo
z&a!U17<O!NqOcOrVyTPMdRv#J9eyFPt!8Rh;EtQQdvjNu_Yzrl&upqzbY<^Gv5Psm
z>y<+_?wL6WxE*a@#dUN`;F`c~y&I!GX(`=4cCvXXtLDbHU6)o)6m-^B_3Ak((B(Om
z?MOy%uhfEzUCM!?j*E`eN8FC-)pYyV;l#_i`En}jf-P+uy9JZ8xC6U3y4_fuE1k6U
zNr>zA9!HK0ht`=d)*R~1T_ZK&w!|WxsE$=8xr>uCwnU2^yY*>JQ14@b3oVKZd0Nbu
znuUd#OUtA^W)Yik%`izPtHtb?($S59E7s(K-L};1<0ck`d)d66UflIAVz~+#xhm6)
zj&^EonVjNN6%e%T_=&Z>@17k^++~?|<!H{8Tit<MCuixpUGv>~h<B5#n{L<aWHUi$
zrAv_;Cn-(JTw#(kamAJpDIM3|txvL+N<ZvylH}Z6;kd)M=jEo^@;VD{UN+ix?BIr6
z)-9(D7fbbo&fLn8)#KW=XmQ5c==!YNfuJR``Lk05nw|IsEM{{&yxFs0P2g7JCszuT
ze0-HMJJn`+bR>tJS#~=_I%#8f(iM-~Ucuy?gl$UNt{b<;ty#@t)-EICtdy5+cGks3
z*Vl7l#N?Een=X@6f_p5Sx5qt=-8Id6;qC6oP!q<$6}PUa9n+e+?dpoKv#kMQJ@uhd
z3$9Asc4bXinr!3HXTfK3&y%g<IZsKr?nYnV?a^81mWCE_Ge#R-^bB-Pil~`#Ys%r)
zkV&3tRY|kD4o;n0diQKsl8=>T@`9JEW-RkKaa)W#FjL!en-+Iq%52q*ch7{~ym&fk
zw&;>;ZkM*HZH)H1G3(HSrkhHOrH(po6jM&FcMXm>l4z<nQ%NvusYZ>m;NfPA3l_d@
zS5nQ6ukE_EX}h$GlagRZi^HtkWxdLdQqegY%Wg*NOt`h^#=>ofGjnd_dfjSW9Cmfn
zWqyGZk9+b=iqcYaZgzPEtvPa2BTMDxl1)M0!Opg3%a&cyTyfiSmeN&*ux%l?t{rsK
zTFkj=TbE1Nk!?!38@F9G(hdt-yXnG0w~x}wbA*_ey<CxZV|GUGlSyhPRr2{|%++o@
zN;6)&Qg_z2VDGd?f_!44o+@+XUcNjYx~gM(b}^%B{nWIzA`y$DrFyrv6dsq8=FTx*
z)Estd+g3;EoTSCMxxGHCqIgrnjvc$4aIJN%(}eVCrBioW-np@8t0C`pt=?VJ9<Ftj
zHM=6VdUkTG@3uQl2eM8?skDkVxo9n!<Z*bJXsf}3VA1VnokBv1CMqhK#<>DPw?n_V
zEXrS9w&P6Gj8(>ywg$H-3G{AJcpY{sINi*x#qEfb+D$=07DbMUDw9<v`+#PiJXI#C
zOvq(FwZ*4%Uu@8HrxHeU#>>;IN*I;uWsXQ(3d(3QnKH#u%F9bxFlEWjQ03f?63x|F
zw`Ofq7b@s0IH#7=Z6+Dbm9$N?X`6PAxq`RZDrt*M-_>O^h1i6dezQhR`=O-s<?6OY
zvn||OGTM~Ryyh~#8MG9%NKt%M*p#JOH%-#LZhGCeT;Ss<IdRz$r6f;DB`24Tw6@Rn
za&JQxO<CpD6TUX@f$7yd4D3PMPKVvwX%@n`Y;Dbot|PO0T@9C<l=4-(8@6_d)K;UW
zl^d+WQo|0eHC=f|?5b~bmg?D=zFXR(lQy<`UGO}T_T;RxXlt@mt7)#!vM7~gOO=i*
zOJ=)tWVAS$oZ)lU2zS#?>IqI=9Iz!T$8w8z()8J-i~?d;5<N0ol{A9X1P&#{r(Cp~
zGF7#5W61P_rHrEWDndD#yw^lG=ch(p4NKxk_^LJO+IGW?-h7dWmXk9RRYOA~J}39|
zT)1<5$F#LxtGp%FN0&3MTlav$Y}@NleV1z?j7zty(dcpGIFfKAVZDK?fKXuX%jkxz
zt=9`!LyOWb=RSD2<HE(BYmy(e15O%7Iyo-6si>SKvRHG)vXqut5%pD>3Bg%w&Xlg)
zv}uEfXII!EpGBKfqP$hZxwMWhmO8d2?dIiFrpVPsvojf9g<bHRly)a`v(=%^oYJ{Y
z8>6*+ZeE%sd0g_~$xXf+J9@=LJq?#=i+;FWDJ^8Ca>gUcSt$46$sJGT+zHdpR8(nK
zdpxPQFk<bJmWd~~P0m%$H1?cT?{jy%&U4vWk>@NIHx#G|dG=0LJGm)YWrIqS@6xnx
zw{1a^C(hhC*_6|}Ws;}jB!Nk0iUv+X3MX776((_-P4?Ytnrdolv{_K5@a!gsn@Wx?
z%1UV}6H*+Mq%&?ADd$X7Tyt#IsfFB3Yc{P_NwZ}0*6fW=3tH{D=xT3jV^5UM#QF?V
zw`pvK8Jk=eTovn?)-yXhDC?-SYS5(yp2SQCHp50Cx0KmQQ5&w@oS3`PaMiJmxoQ`4
z#V+MaT{`JHY1TH~Ua_NV7n!PV%Sw=%!P^uVxoXwMPHCZlEMt`%PsbHkQf5X@$<!5H
zapQKDnc3|mZNV**=2^Xay=@%>+w$GrJG^D;y^Fhdcjm@CvR?DzI%g%g`*!HvBaW|^
z=9J#Oo*To!>t8NjFwJ7xbMbPaTRV@GM_ybf^clRTul4Q`!A|#`7H@*ewceiA^;q}h
z@g~)~e0NQhmIf!>cA2$h)1<3QjtI!zRf+7>Z0ibIVf01on$M+$vmB?++?t&08@cLe
z#G-obXzA?iL!TGl>CAdx?ku%n=LKEAcWqov&)s(lUA_0N&D61YLDby4JOVuu2PM)@
z2Tx6TyHd9?C+L=FoU~v-vDh6gUdISCr3KG)cZ5haYwK=z6G@C_H3(+q-FSWX>fN(b
zif5ZEr(}rSUAy+~t=0FwXvXcmXZFl&TAF+AZs}s_dT(RpZPn3wS51nfE$$VYPf$tn
ztd<tj*qEO^%_Nd-U3qDFv5nl<(268;%ROzARZM0J3g)i3y2)qF)ur>UZfZ5Yy(}!V
z&+^c#RVN<qc-%XmEyuaZ#6_Sx=gX;0kx8e;ymhyAi}{K~n<j-E)Zt7>n6*L>L^UaO
z8ErTga?H3s(=AhHv7p$+4LQkb7cxvzuDXgX>dxxYTEaVNk<!7%8H?SHZi=|LW@=i{
zrfEkMPK6n5j9j^J?UJyGJqgS~8n?wvyL8ufObJf)-58Q<wnfA2k^^(lRjpH-)LgD^
z$n`FFQ#s1Eg>miSu&L9yG!5Oj48nO*js|SIt+i@%;eybdbM+FBl?5kGlw3TcxzAiW
zx70Ugg^|&X6>iCyY+(~ydz%EVnYkE7C^B8?ND#^BNmA-@m2PKZit_Rd5D=TRT4&0(
zxmQozb`j=WcHwg4!P|+eHhQH7E;-4W+qB4(?S>Yw<J74pCK;D=H}6=sXj4~iRB!L(
zppa=t7cI`{4isB(TdJ$RJLzKJmMksZZdbQ!i<Feqd}cBV2?;ILSvtifc5SxdwwHP@
zwrn$;u_m=fS7XakP3GCVwmt5hq<D^b*`is`t><XT-g@gP^=$9)nXlgMdTRB0*XvfR
z*E5b<y`I^+*rH(P>N!`BE-{<!bJ(zPAy<o*CU>%lz%{Q)n;u@-QF`}!0fTIPdC3mO
zYwI4b-n~|JeVO@exs?U4yr%OlJ-lL)@Tx~nr7<2SO<spRnRvBO>C!<Rq1(B_sa%0m
zt^^x7`6|2?V(M9Sc#3xPI**Pm>3jlay~{3e7_Lcc5)|~@rsbHtxKl_4s$D2hH9C`L
zQnX6iB;Q48OVa`)R4(S8jo8{-za>^$xIE_8JIJDF-6;YcOU)MQE-QKDmGkcEPL+_E
zTcX`odFQT^>d8G6G-Y$?qHAtN(~8@3u5dCbm6k@Y%`Up7yLM@#+p^n>I@x8CXWTya
z$mN!b@7vAOGI_;LZe4xj%A~LF4XbzY#NJt|>D}|F+j4KX9EZinXSYvFDtyYRUn=d*
z>y>*q=2&^Sbf!>B3Rl=|O~*;9v!rfowS_XOZ0nrutniRAWZSm2*URJNgztT+h+8t{
zy4SAMtp-zETQ(R;r{=6HS#P-KSbyAG>9dg!1v%$lJ(MW$TI11ealI=d>5e`RnOj|@
zvwAm%bxt}kDf!^JX;Zd2AGEr9=H_-~k7e~?!CALmOne;qN>{g~wd5QrojTP?<!E<M
zl((l!a{R1S-`awCjAjLF*4iAbc3C@RQ?AiAZ`H|}n~q)EIIYJ!b+J%p&Xy!!wP~kQ
z8?$*cZcLjTDsekm)Kqs>@5Y{J>1Z*pNf*^r4&|yXxpi^HjT<+vnTjMG1>LGH#U0h#
zD`i;UF<I3!V>0KKS(BrBlaA>G_9ROjTySl(WJt2K+p1$G8OID4yBP%~om_EKYq5mk
z)|9jx$ILn<x3-;~Ep}DcNG)q^s&N$8sbk%V*+v(#b$ffg);92}Oo|R&?6%4zcT+%C
zuXN57X-~)8B#rKn)67CIJb7K(->q8u+AQZb$QjeOEN0T1Ua^u<dio|kCS9hZtEW4<
zG3!hZ*vZ5>{f91-9@DkO(;E$$Yo=e&W3rqsz{(Uo{k|e2-}LvaOq?vL(VSbS$M0fN
z;GCMH8Vz2yJAGpvV@ZATa!-}LckR!A{a1fgk;4mo=0*Vbh5)l83&b0iC~`XJuTT!X
zEd)A#;l>oE4<ap!8mu=oq?16$cia|g2=hz>9hD0{lSG4+0i;2L6>bifROYhD0+Ryv
z-@f<0`tbGYd*72h-P*X=Zh%hg0NJojd{*X?+s>@aIpEVvk^;DIXmU6Oa4}9dY+w|v
z-!~~*<?mgq-}m=?NtW<pj80v(-p#OOf#|j<j;m!y7Km<(o{}wbD1hs>E=$(#BoG|}
zrBCgZI40B(b~6L)_^_K<i$R_UyQ#BT;~K<-6?o}M(JytU)kjy|%$@fg!*YwpyGw36
z-OLkQlg#O$t+K^)d)ee%E(xfp=!;_pQ<ye+yUZ@nG`ldxka@S~w$@G2g&j_rW)~(!
zv0V05yCq`C;j4B_?6k8$%cb0fIa|P7A<xu#@8*Wzt1|3SWmvoEYPi#4RL`9<?Mc*N
z&7Ia{8oLohuY%G~<9a|2$=M>f>TRckcFxv72t6%w%Jg~cOtM0^bwj}6bW-=%$&~H?
z-fmhj-O-Opv0lpU00Xnr0tRMgj~fgO2OAd#FfcZ=v9*Gh?=oC6V_*<sYjt2?a%^0Z
z!@!^-VPK-gz#zl}qCp1}ut0=4K_)ONco=9VG<XPcv?U0!G$}63VPIfja+tti%)oGl
zf!TmTXbOXi1G5Hm?$Z6e+g?p;UBJMcS-)wf&$3{xoMkS-T0v8ms(2*jUpe;BAd7)P
zE7f<R$cc`QPEFk{x0aeTXI)zB9KgWn;whYRNM~xaQKFdFn#|6PW@@@yqP(_&hz-3a
z7uUFLWIHWcYcOZ6uP<nQ9LI&;u&}VRnGp;OOSf&ieq!0dPnt81pU7EbZ2I5!&!<(O
z#gdQ}c_4EAl5KwTuYc{nt3Tc8yQi(V_^!yGCHf`PpI+Ej?)@bu?&amBKTAwi?Do~X
z&+?pKSMz+UO8$Pk;@d9M{_gv|w^L>N`}?JDJXQA>Op5&OsbcqUf6O;cm3>#&{FR))
z*!W8@*B{B*pQPrmd9l;AH-7KC=Zni+>Rp1Bdh>6Hoai`q`B_QK#?|k>7hgP;Djj}D
zcIOV)vtOS5ir>(c;^JzgWVrHEN$C6PoiDEaK6u@nW9Pm(_r3Q0;k&c*#LoTd=9liz
z@89`$zvB$X87!@KWlaC{AMO3|hV|3W`1y6V3yi;Kmd)~1zpOu7G*UFuR`=cZT_-$P
zH9SNX)Qc=z{q@)F)cv2phw=(s&NaJa;HwWlm$!z=w{z*s)Sjjl{S3a`7iAcj0y~$!
zoOJBduj>7*m+s9!SQUNw7vo>X+q<`y+s553kFC1BruqGI@EUVaXhQJ*rJMY#@1dQ^
zyME~=zxn58{askUvHE<_j<fzu5i91e4&3>`GuP&COs+pu+^g7}!Y#UUzf_4{xUo0=
ze9(?t;%i>o_4~&1c3&%*{CwRyv)0#E-k+~W%j9yWM?#dP{CpKI?Htj+t9t4Q_iGow
zf6Y7oyn5%Gh+pT|{5rq*(^d0lSJxj6`!!wfSxL+>!=BXp`#7h|wKCe(-;X+HI_>zp
zsLRK`ZZG{_omYBCwz!13{py|C`1})l*FC69%57j~7Ru3zY)y@u(9?Zq?~|3!ANC)g
zu$4O`!k?$krZr&I>DCFyg-ZADj=Q_=a_qAG)zgpmYk7QHGH=>F_Oo4Uy4K8__C5M;
z%Inl=`^(?E#2&m>559Yyf&Fpi>4?4WcRxHoS0_bOp}ND+(lc7o9mGy-4LqdA!nCv^
zAgS0p!l^IfgqFi$uEi}r9IRfkT77~J3ZnWmrE|H|m2(%mT>9ytKbxU0``Wv?mv`N~
zc3NfU_xDq$GnzBW*N6SLyPVUuJ9);g+<E<b-<I8bz9;YX=e)FBkLa~#e<#_S{pAVU
za{H_3o#W5$Z&)V1>(A|(v%_0=UCuwPQkQ$9eBrrE|2EadmL1>wbNU(`om|Fg)h=>k
ze{QRtv|g(5bMwWYg~w$oqf<pgLqojgg)CiPzKEa8Z&SHf;Oq3o5A~j3tv3w~jbdP6
z*zwZFK7XdauE|oHl|IkzJ2*`UGOH?&d(FVepl9XJf7yY7A!JfT-Iku5oGW`4KKQ2N
zH;>;{bV{<#1_$9?bq}IJNmpsrsvE1WhDY1J-}kScf%^*s1JmEi6;D!Zelk8=JaNM3
z6`o5^8hj4@eYfiFN0~Z{$1lH3KF_8y%bfo{G%P|xe}B83^X7q2*j>he?a~#j%nWC4
z&fKbdefRF5yS>{!ZfBS*UBc>gH}`=E53_Mv+Li5b@7{WsncY5ihsoi{R!y_C-01b?
zWvgbbTD9nMh01NmHx0iW@;i86U0odp-f<ABHPvgWsMD%d>oV+KJNa#q_uyaDa9=lS
zYZB<7*m|w0Ap#6VR}@{v)<%Ky$2kVR9BCiEn4LvW6DpXeE#zFwz@*Wl&2{Y9@qIk7
z!(llXnR?G|yZtnG`?cHQv!~t8{j}}&>)e%G8mm^9FfdrEbWBoG@>H9B-#&i*emk%$
zKt{uk6S{ZpF6ivj8NobfXV%XSy4(9i<&<{bLmy+av|R5p^9hs1R+^>dhTcw_ee2%#
zyCS@I?{2#t8X6k1blbb{o@c+iGH)*joeR5#d56l~+qpXrp6z(|?zzJ|_5~hdqO*C9
zeNeu9_pW_`*6O6yp^+Bi-`~BnVB}y?<Y4&t?%lg>x3kZ^>GJ72{qe2smtPxt>cRV#
z(&qhs&mdyM;9j2kgJIs?%Xja4ep#_<)$aSXkJ#H&e|($wt2Qt+wEXy+$MUnTUfp+&
z;c9o-TF}bk(BN3+$qTL|nrN*N<@FBV+`zzGT%Nn_*017qmfN<L=5KD0*}2U;b?@2T
zoVub%_nl)XdUoUPwA;BGck8~(-S#?<v0gRzf+!DIC*$ea$z{=ZZf}@$F(&%W1KzWD
zx82S@xyPqq)7QgF=VD(if`;L;U2Gq?5-gZD=(8RWbBK_ct{<7Z?RNG{n97(5PdDz?
zy_<W(Gh?0Zw*uzrX2;%ayPey6Gru@@JNRhYh80Osd*?7P@WtG&m)>;m87Mj)-A`w*
zEY8V0T|K)@C`!A#b`HbSvm1BoZo3V3RPMDqOkTGaXh}?4pU%JlHgo&V?TM<3c5J_S
zKzjD>+-=wIMsJv$v2N|R0=6|#TR{=DYSpT)a^@3@m3g+vG6r1PT5Z9=U~XP^J9k@o
zawVrx*Q@*K4D~QO8TQKiU%y{op7{OAP0>)_iFLnoH?Q5nGIhH{h@o!WIR*xHJ+K$@
z4tcv4B84kMT>tXd?|1Ls@cUCv*Q#YF_SbH^iO;QkF}GEw-99qi+Pu8H-0WUGgWU7d
zN#42JZl_GTUBR(vwTWR~+uG=btHoA3Pj7v`^Danu(z9pp-o1Nv`v6;d+3nn|CvO{h
zo81<@U&fHMT3i>B41(BogPAne@P>vaXi4ooEzqKvdhT}aww=~#o@uv}cE3Bo*;aP%
z%$d6<Zf?(1owfaLgUnX$u(hFO^=vwk3s;Nyc9@24aTEz-Te|wrMh++O%-!2J8=DuI
z<=*m4Tl+nM^<4F~+qo~ddmBxPTwQyE@pRZSXbA80<zB?K=#)a2HgnL`cM&a$+}q>c
zZo6HTd+E%QX<7Hn7}93ny*+d0w2iZOd&*wj_lDu=fvl&ew-_cJ?G_C+F=VS>8|@<K
z@**n=?B;T5RK<T)pX{6GS<A0y`@VNyM|afh=x4`%ZrpyhH~gf6L!*AxZ9C4IGpCy(
zRA){;)qOI5`UVdJ59w@{CbPxa4)?Q?SU9V1ZOyt`DzP!?XrWxh#-yoopF%?vLoUn`
zQ|-R7_syA^GwWy0>`hBqK52`#c~#ZE@70|b=5k(m+&6(KNT8KrfzX5&4GD`!CF)Kk
z7LS)OOlbj~TDwG%i?NK;;kF3V2ar4~lCXoSB1Zrhqh5<*fe2Gvi((lUqb7$_<F8w#
zR)^P4b3XW@!uCal&7^=9lgm5?hk1-;*VeNNm|YccyONtA`S@hg(QYxVRml>^3|iFv
zS}re}D=8To8d~>#@AjGd_PyWt6L!WI_^ev!Ikks8A|^=-Ie*)|YuBz<|97c)tYw+7
zI%KJ;d{xk-UJv1*5YrHkt061Cc;8#S=C$6Y-G7dr-NMB?JNo0|kBj4b#p>6u&S1`9
zPT)=3{_WrS^XH%6d-wZ(?a%pZu3pQQEuB2|`_s_!C7bHry{z87<lVdP-pB3ttDRVU
zYT1c>lkT-B+k!e_Y4avsduRLPrue0M?59?}_YVE+;RNa%ISEW*dLzQSQG@jXsQ&`#
zKZ!6kZc}C01MUu$ak1T~pTg7t>Q@PY!%{kFLW?S9zo~B0?VNv0ww+d){Pzuy;cv-}
zk~4Cg1yYt~1ue~3;<jj}OW-E06(?3Lp0sLW=nIV%S6qbRGMVbuW=_skn{0N{WOk-W
zv%%D$&}2!IjKvZ{%r2dRi=?yJZVTPqHo4wl&6-&fIo_(XrB?ZFa51pI-@EbQY-eL7
zB|#|x7ZbOOOiBt$JRLa~B{ydrF%y(%ySPnIkjFXWB8%W=LBWMgj2yQFCo&l;<lJ_g
zEhq8dnA@?F#woqqCQGs;Ib~!tni#9~+)6Q<x#bW?=0YRREjN66H*s8IQ@fnWB)K?A
za7kjlprllW2ZvdQQm#tx63>mjlLZ&db~$!X$~d7-P;J6YBR3b5nM)KUl~Z~yNz9bo
zGP74Xp*eS3v&)UkikzDTrCoA-7xZNCn9b&qnW=UYJbf=Xk;Tm^?Y4_skD-8zXjE6$
zR#xs!Qx%uCu4Z6h-L~z_)ol$oZm!%W+H9H=aHzi5$Jk?XX719CZC6A$c^dY*Et+!6
ztm~v_uj6F34wKx43$EQxyEWz77RGH`gQi_&a1!`p^Ypn~NqBCw->q%abNybbGXJi>
zv})z+Y^!6Xvop?ZxK;3hKYe3pH)xk%XlQ7ls{o4+=kA%3fuW%R*1eYvSG-&{J4dAf
zdeCxx4ug{i%LHi_mI+ec%#&^i#XPrP=<2>TyypGl<EN)ZU0pMC>%NSii*Ef)zxHC*
zM6+;j-PiiZ?dyCe)>eO=wcBs<+Sk|W&YnG;yKT?6#V4GcZ1zm!KBD)w_h!bYm7DaJ
zY+uN69&})y<nkq3clTGCxqjK+_-WPdOIJOY&GMZvDPUv0v_{0FfQ_J&Z38x{EKC9)
zcpI@~;wDcgA;`5jt^cgoB)_QHe%kKF&!0O}gT2$X<sa(@ova(RZ<E>r-X+SXPamJY
zy$4iTotJ*{H`>X4btcCr-JLt8Eq2*v5GT0o^{41f)%QZ;<mEo)blI%R>3*sE!pZnD
z82Dbk^s7o>(lJ;Dy7ztW`>Njub;8fW2Miz?2Qu)WchCX%xP$kB=`S3ZWa?k4Y>T$P
zvdvTXpQrlA{k`?lQJ>D2^;Rb5?)iNF`j<a-5{YdRiP<0H+f4lhvdlK{e0;L8s;a6A
zylqyX<>iH0C6^Z~gIZ1Og}aNT*3HV?b~|&~Z0PZYh_WY9MaPr3Q}O?+RoA~lR(cA7
z7l2Opbz;(;etr@o$MjAKCe`UL9hr2vTtO>BU0hte)=cM<WRjV_e-fkGG$$sx>AaFm
zD$}>lX40EpGo4v<`U58>2N0n%{jDvtR{gD8w@ysBBpw=Pe5}9fT4ZY2S?Max7mM>b
zy@dpyG&ty2R($$?zV+ue^VFS>Yv!-c@c7;@=Q7>wcAn~ri)y_>30jpZo0q;l|Ni7A
z4Seb0dinj@cb)|gPwL6`nZ;PkOnP|Zaq8iA>3TicKJQOo?|t8U-r{D#!(*pgZ|qc;
zwp2abuCgOw$y|;i@AkTNyWZ{k8(O>j?e%A`et!zNbW+;w{zU&1%l>pFKVaO_xl%Yc
zZTsi1KY#xDefNI#`~Aj0*WEAo%HO@xWc}`L^;0iD{rUU*`}Ax66}lT=Ru{g97OvAE
zg{!gQyy=%Ov`jMxN$lJ9!7jA6_Q5pmXNXb~JnY1M0Ce4wc*26*P6v(Y0uvd<>Qx_r
zsv@(a@KnUb2r8957!^634sd>%R33ZzenLV*(vb-_7+NN9DyFgNcrr|qhOT=Pj=G(j
zox8uuL+aXXAqSPlwYeKrm^>mFHmVp*lJI1hB>7|lr((;5Lmr7LOdg3U29p?7%orpl
zF{()9H1kf_sKVsxk-IiW$T>GVcT3;9*Xwrg@DNfERLYKy1{>UoI6xMhsuVXcaw;~b
z=$JVtdDN|Yd~a9q8Y}0e6PTv&naZd&eWEm@NImoC-P_h@?_Rcc<?5_mj-OUZe%*R^
ziQgsZ$i2&@_U(#+mN$VeSHCbZGc1_l{orHjw%aMCP6jJazh+Tj<X~{&WOA6G!pY>q
zq~g*sL8VS?UF5rMbFJ5Id2PMM>fFm*=6j*xashj$`qV`%_HuXlI4}Fg#-yWNt5$97
zNo!FQy=y)9?)Jju>Q$>&t>e%A@V)ka?I(}v6Q(hW*GuHIKf4}W`u6U<Yu9d-&b=m^
zUb3z6z1G71>ZOw}mu<fAR&n#)>w8P~&6_uGUQe>bAz>$ezvm_I?%s*G_iELug^kb4
z9&P>o1a|%^?ELu#wj&doQ_NHv%$z^2TlV_a>f2eXZ*5z7soXn5?$fFrpRFP#cSk<n
zGAE^;U-H@Bt~C)G!3{xQR}mIg&fVS8cLPI13uNz{30u5uR&J9A=nzu)sl8?liYf*<
zt!*cAJo)b&Wlfpso364e?t|ce^EyTbhrqW7k{&QHh@5II6l~mGeSm@egs3ay0z(E-
zt+i}Zc@0*r2w1|=5+q`hC>YYI<XoS_!my~3Wu+6x0>;p#yg>_CLs&F8ofrdy1XYbL
zaZTC6tgNGSf#C-O10#b%34@002L^@(3^t&Y_J!|t{`7*?8Cmak9-ejWHoHLoc6TT4
zDDXG{<Cp90d6fs8L|nbJTvoL*zb*Xg&(~0uS1kR4eb;k_v-21jnD2c)V0owhf%HCk
z2j0iCWn7d58CSk+TIwam)^Krw(2T1pQv<#-TvoWiw)|~K*RsY1Yz~a-s{+-Q`Y1CQ
zN|^{O(p;)G`9zldD#;ap1GKWdLX2irIecljV8z7z^B4cO30|(8vz7*>t=P8NAneMP
z!-m0zL6>=s`as~ZGY7X_Hi*n@t4~^%v@B`qGTp2+Eig1Q1WC+T34)okeblskLT21_
zo006h*4tplO2eS!RH?+JTVwCAO=4hnySO3amKlS|1O_Ry-ew4oSK961;*1+PmwXsZ
za;4dN7bjfYl4F*s#t??!BB`#Ib~~IlDS>U<ii=xrE}6lQamx(J1T(W+OExn=1x#|K
zd1rYxNQ?d1+!t~(V5LXx&Z{@SecHUXT-)k;U&y_u>1!*mEU}(bHuJjdveM(3a|>^!
z$COPMG`%ATUM1S%wJa>{a?HcUQa868yP3J{jntJhV)gH&jCZ&7ynDFVdPl~&cT&be
zJu|MEPPjNjNYLb(;fiZ3J=Z3w^mHmr5}F!&>!scUekrq^8_(*_&5aXO$uA2#A06JQ
zs2K`A*b{O>r`27MGQRELMU;@Gp07MTy<=}23p?ivULU!nQ=mK#wluOHl#&=282Gjq
zfG4FG-!9#D`{-)v+@#xqNf$RJUCh`LWu_akVq@C0-rjACE@o_r*qWTN+1u?%#3iGP
z3vOrWWJ+dSh;(Yq3~E^r6|&STWNC8B)?QID<|s4YjccK2UM^a6AlvO^Zj^V##lQs9
z#VK3DwyLhlSg}FsV*REpUDy&#EkmQlNxHq8E*;xuD%I<@I6102MJaW0vd6Sr(Ycu}
z9iF+JMn02OPUcRV;xQ{Ja!J6cW1?-#Zmu@dmg?%sGL`Cebz3bhaV<D$tJ|@~fh%rY
zO*$18oN%;PDdO6dZD$wh3TAY>WV>C{T^zWzJ7ZgS#<pIyHTBW1t{s=Mr7q@*UCfnO
zu~F<|V3Nty)t;-tj9J|o7uQOeE_U0JaXV2*fKkvzAV+{vu;ro%<Zx1^jVskwopp;=
z(+F7TuraDTNKmy?<(h9~$|4t?OF}|ILbtQMR9rWC-4@-(C1$#{>sDJx#8KCo0h%jJ
zO{0=}G*<-FPnFWz7?!)pb&;-Ms^*ksMl+peZPo~mxYjEwX1X}aWSW-R6ptxOxm=cb
zxhxD*G0Ar8g*eG|OGu=S0Hc^f(;^NtZ?UbeVWz?+GiENj?5lQDTUS?VadL8UvfEXu
zDYs2-`5M9(c6#S*TBW;U?N$lh)e>e~7qiu`GTa)Hu&O8Q>ZDWNxh<O}8C+epaa)gc
z?uw%ux2=`X-MS<!+0*CDq-`PxCd~*tld@&o4R4Rbp3XUw+KvVX&Q@7t7MvV*=2T)d
z(}u8|lm;gShfG#4QKyL_O9R7_gN?OW4KzeIORC-QPPk%r>g-0hoYmPG2Xm%vY4KHN
z+t{47r9NS;#AaVNQ;92Sf@ZmCp>ABql%=+s+&Fg3%qS_dJL1wQZ_eCpTNb%aid4Dg
zE0nu-G3%NwtGqo_E^(Sp>J(fy?V3T<Rnea4Y&Y(xi?h9^Y`U$XxpB(Ph#*0ui>uOZ
zyKZz{?YJ@{?8<E^XI+hnDM>!wX*VM`d3&k&8me8ooh4l_+IH%;q-w%c&D2R@C$-r;
zBU=NPDEVg24w<+n*)1$=$*eY$EzMDZN+%~>x~Z#kc2eLbpDl}A+@_gKxy`j~ahhjz
zvgVeR-U^F@Ll<p{<me98-4dqk6Sg#WwZx@Empa9wbCo?ery55ED*0}i*>!Dkbd;{E
zw1i2EuTpQw5}j>M^=eZkbXUPwa%W0<XBq~Z_DF5)j+W3)7WVDQNlsQ%ow2sd%vUIL
zqNmT4u-iIa(UH@pcx)0n<!yG_OU0+jS7EY;$~7+)pGl{@7PD<#%y#Wc*0tU>QD#Ro
zIcAC7*tSJcSXZidvrcI5n(UmY3rVSN$8Jk|u9c3Q=&4gb$;><L7C1a~RI;Qsq_stE
zZCo2PEjsJWsgpsIL{i+kBi3$Q?bhR&bX#odM&E8#A)U>ty<0%5j<;P(&7B!-mU487
zNsF&ZsN&X@9KD-$PP+z4Z45h+wODYQZrYVCZ8JrtT)Gr>Vs_S<E-&w#&Xl!1Qw>2&
zq;p>fPIlvol-#r?;oxkuH5(2#YbC8VF-SN&<91HcS{;Lgv$Jz04ARc7)-gypHDha9
zn{dc!6OPkN4r{b|n4CAQHM_ZSTdUGFk?w3Rm)wXT<xsb4t;(UTO1BP8l)5I;v2FVM
zd5pUC*MePKA{Q>*GD|{qQ%34mwYFDR@38H8ld^`>VG3t>prGR3$EF(hc^4^}<f|RZ
z*6LcL>3lV9sr0c69d0c;_f{B1EDZ}>?Xl5umC|~)jiP(jPF-Y@;lvTSH#8>g+1Zkd
zVcITI+7jI&IuLD#6*?5`WTd>J_*>FmZCkQgV*2d)jI#ASnm#|nj%wWJadC4o(e0Z$
zYf3urViV!q2iH2TUG0f>)1B<PO*e^Gw8yoZapN{c-?)`s!TAy`&Mq8rTXVvWN_<%y
zG~33kcR?e+j74<r)v%Mf0%4P*qb1h%giXs>Ep~BDZf~-SwA4|7D_^5U7FQg}=v^eq
zU3KNCS=iC6q#0}LH@=Kq=~iKqai5*{@WaD>1?L1O@=iEjc=XzikP|Elf;_WCmbG?f
zgk`&KT$2lOfs#&ju*ljOC8=g%YqX6vYlj`p3Fcd!s@do4aqwemwv$&>!lSP~nr>EC
zH(P}r)iyl)cC%TdT1Q96q|7BP8NLf81*LL2+#)BZq#vK;naNqNGHp`ow8+$HkP|n&
zz19mhP3lRzYMi@FL1jVIqT5bPL2cTBp)D*+4WbrjdmNc%rgF_tt;Z9zw%m8gDpSD~
zmvU7DS8UvpX*TH^gcsiIrt1=tbi*X9<Hl9i-lUEz*`^{3nS71CCQZ}SbeYy%aOcd-
z%@(G)tG%w*bC^vy5|VULOxtl|MsL@qlr>Uj9anN4)h;9liYcDUn3b+PyX~QI=9Xts
zTTe@E+v$@eb||;oC}m=<aqhL(+1n1P=`IfQ-CDX#W6ClSpQXB6qBFKG&Q4k@EwSR7
zQIyH7-i%w?$x*t}tgI3j7mM|FnuKi4OwL`LbLY$?l?k1CtLoRbWX$gQxF}_IB}cD-
z%V{N-*+PO+3Y}|anJ7D%oVe`b;?mh9J>%)NnAuu9Q?5@=Iy2KnIxt%7%GB*V*@4||
z2j_}z)i`OgadTkA#I>rEqi0+@W}380J9LW1>4;^^!crGJ$}x|~$~m*_X0)-W+th4{
zHLkrO(XLxER_RU=O6i$gZ+3^zB$M}`px~C<?tCt}w{s)b+_uV+@}0VsDLOA*Cik3m
z)}m=qD<(!xovpUDbZJDd4%@V5U#5salclY~zB=1_!Y=kkY3F3;BnP?a%$6|o76|J)
zwoP}@#=wmm0()H9Ohv<{U7d95)E3DF=4O{XO=e8?ytL||k=o)&*FfJHj`e-gvvW_a
z*~!f@TS-jNZ2O+X{GLgkPbPONd6uR;ayjwbxZ5`C>dHeV8H$3Bw-wA%o^wadQ>9bM
zQ_1DTOaUj86N;)Go|0y6zLQf<c5cfs=h>U39riiz)t&M%nOjN<{+em6VH3@qtG9}-
z__)0^uRL6#caf)pjYWYIbBggJQ?dGOTf0Kj);fm;sHhy7wK{3$ij>WAn@w{!JUN+j
z<6>ZUrj~EU;v{XCOSu~(ebz>&wDc^>QjYRg-ENrMlk3{6&6*pnZD!$iJ8#7@kxM2W
zonA{hIzlx?wWDTwWu0Ad>X6Um!~>61WLEX^JnodvyBTT}<&eP@s=3J^Mj^uD;ZDi=
zYo<Au&eT*2smwBST%1!;l&G_C>P9u8Q<BkYJ|03>w`q1VMQuB3lyWI|lJ1IC-Z>L<
z-L4(u-KHIyc4W$Jp@7ufO}bmfZuMrn@oshFjS4pOZJ9d5)3?=3<aX8>&CN#9EHiso
zhcWO*hHQ(v=N(#hJ9?&CWZPQL3CDYUSVXnL>Zj^PpM7A!5R%x!kl5NL)+Q~%!;q6C
zz;HzEm?F1C+l{WABU;gFvrW2Mg?%-rb*_;z74bD$qO;OaHBoD^*fzthE7mT$W|(p8
znqidTmMl|IX{nhTW|<lDB%5q<oWYsGVc??19GzrrZfIPxYIBCC)QMmXAG4l7*VRdj
zb4^1e>L1>0SISwMyL6*qmU7OKGih!qS!<#;Ms1oo<<`_qZ6^#59+wW9?IE&EGvP!s
zpTs1UOG1guoE(*<GM5}^Iiu!NxUKi(&dIzxCJ9Na^-SD$VRp`0L4l5olES&dX`R~-
z9K5&9h$BTfS)sM3nYX7&lI6w;#bkxkS<9wsN}H_oxXmi&FqPF|?~yaU*=sh<a%s8b
zX>ws&)|Ok-9hWlt)U#a`T_&89XDBHpWs;X95V<*McF<-`-&Lk-oeh>rwia|5hI(lS
zo^eq*_v%rGXXj?WSF0Y%hK8l{GD(|D@`>?!B~6_*<*4QcM`?kJn`Pcy&hkyp%2{-@
zTTG*4QMXyf#l>!uJr}z!((PC)7&hA^<Kkk^B^MW6PV1F2$uyZ|5>>BsqdQ4!QP<I+
zY^fC{$%1S*x-Kgzg)CVTV&<ab;sQCnlTkVpc6MjWk|irO)?Hn7fgw|Lu}{#HCCa&O
zS!X+Q+Yepp_BH{XcBPzQ(sAJ?=WcH=T^?oy6URkdCr*VfatiBI&6rklZpQ1F>vJm3
zYflMu6$PEsS)XyuY&Pg%z%Hk5t*OSldnWe1OPTrZ>fYQqQ2SL#s&sXcM@zT2$;{A=
zy0fB<)GmoePC4tWlDsBjb%~2W%1MD#wM|i%)Rwr289S;uM4XYFlxvjIbuv|DqRLXW
zlR49FyG}}J73~U&T-s@}v7_6q*Hr1^ERIYMCCF9u^_g2vCi!xzM0o|BnU=}2bj9L8
zsY{W%#Ujbc(mBa)rV^_)qux$c;c52Ou;egV)vGl{VT!_~6{fCQmmPu{y*6&$+MLOC
zOk2?C>h6dqC#9zbvYVTwo2|NXMktHnwr8Z*t@YZu&$bo|2?^cIT3TViZ4%U(nwixy
z%dM?g&2vlVrg|1nsmK{GBWHTuIMQj>%PTCh=E~YxE-fZWQ&P2)K?iU)F1u~9IqcS}
zpu}l9VQ!*|UfU8QqotK1qb^MHxTb5AcDv}9uf(>+fs>Bu21#7=4NqLVYgS=8y9Dpy
zhy&-WuCD9}ndYf2U3uI%Ij|>L;L5cLk!xIB+_Gl!s@=V{U9En$XQxS<Vn-53hZD#2
z(5E#ub@uymcURwizW04?oAl>nf1gDsJWkUoYb&^QJR_a27)Cue=Ur2D@bK<}cXzC}
z^G>szmb>GYNk>QLqMKqjrCeMtnjP^KI4hMgqqEI(Qi|H`j0+iUXBs?JI!#(yHWW^~
zxs+kT1QkwBq532r&t12}3ye$6cIB;^ns)ZI;f@oalPBAHX5>ol*3nu$d)H1iwVXe7
zx7p6_Fh7$mb*!0l0%vQIQ({D$ikfIglEgHpP&Jn{hNPebHecOo&7Mmx-OSl0>BGPv
zY;sz2v(79frL~JTx`ae**5b}N)f}z1F@b@hCt2dmqEumxYxY|@n>K1DEZd?rTdXxK
z$tP;-wpEGISxL$no5i$+(^T8mMokIYw#w|-ietyLLuM&$a}Zgev7e#guRw@m_(zk=
z)BAOq6enM(;+)=T$jrlZRB(C#3zI05Xvp-7{Y=W!_b+DR%z3r#lBdcfj}-87{UsAl
z@)$YuO!8Ej?2$N0BC$<UWs;{FNXi*>Ce|ch#Ws(`HVKg8S<XBY4)YkCRGH*yGD#97
z4pNp0(r$1Vr1+9VN}EJto2SYo&u!0+fjQGB-e6Rf@KtF884faJc5zN(n`aP2*L1E`
zjMCGqRxxrj-MKw|;SEO7>F%o-#hA067J-hyRGEHY0uu-0+UeaBnDnQgUBbj2_3n9j
z?A_uypfTq*iNr}@J3w}VodaUv5S$fudyeR~=fcr>1z~2dC){4=ocC_w_L#Q2MY-qH
zBvRTuQl>YqX4G@>)XqJ}b-TD}+non%w_9j~B*AtOG9Sq$yQhCz&FEGC%*9^b^6Ob;
zj?=n<<;KMxhm1~#RD16~DkSac?7QN-?3p!3G`V#SlxNRMf{CnlX}c6~Im`BVadsh>
z(`oa<yGzf)mBS@vcy=ywmRPv#N_F3}P@JrKBxwhW$M4t7{rvr$5XTggTm6N1t`<yi
z0UPjoo!O+;Eq9L>7d=$y1Uu_`4CtiI-F<Hf$s9Z`9s@dI^PTm!9mh1Heeaa#7WM>e
zo4w=Rt;Z4zbEVA-?`}P2=yWT=de)XBhFwy*zGll5djc+JWtL7~x1UjVdc-<Lh3V7R
zF^c({-97Aa*@t&~!3z%lrL0bZ4DIYP@{9+BZhroL1x0K1?CG4WliFqnTDLu$(PrrE
zyW(@vLxoL{Fbh58n6hx$6^D1z@2q8%N@1|b%j`%NF}c-m8lxhpk-1gw@y=B+U!D!;
zWbu;9b>HzWYlnwYz~wB3a#M)vS-C#oz`gVe94#xCLS3M@OmWK;lUpF^OpVN~Cc8lP
zPp>(|C{=$8#PnUc45||5&8>z!No})(zcUox-yRJfg@lYPF$bA7Ffgz!i~#K_ztX#a
zfq|KgZP^6|20?)<W(z=Sc&B-)99Es?X>d|?nvYpz+Tq-&sN1@lW*e^Lg5?<)7)(<$
z!=|m&U3QCsft`VYfira4>gj@-j1u)svl$o|mK|VVNC-|~U@(A^2WEpDU;;iyv_VP~
zq=O+L6Er~2$&hg1!U_fk1`lR79$qf6`HTt-9IQG^CV46dGIT|Hs!Z9Yv1FsCn^}H!
z0|Tq3S7fTDmxsqvFSd!Atfs8K4JKDa%@|J2*6rx%xLCh9xcUwQ1E@4u$`!CwRCn2h
zoNKc^f>v(uR8d?SoG{75Su1RI=GGu3T|r?-DWO}T4h&gKLm1eCPE8A70+k#plU&?*
zKqUpJaPeevTsCdCrz%rG<g&||Y6+4JOFPXnJT+5QwN|ZS3FK|?Vu_u|6&mtB{=@%P
z(2#X~yzE{6Pye-#z2vjmQo5k3c*d+tc013=hMy~DcUgX{p*D^2OB(xyG_l*ytA2ts
zgdaS<_kH!<J5?-=>Wp^Z_msWemUM61ZBLa+1@9izZ|8d_d&hc5d4ZgL?f3hRuNatX
zcE8{E`=y_9$M*w__dx)>9&dMg4(M*@hwk<FXRi%qdtbV0;oWyzL)hN0by)p6K<szT
z&wB|fy5H|teP&b)zkR>@3`^_!eZQ~I;N-er`+dDx!-Vx)&M;iRZOpK5E9+v(pI6WP
zc|BpW$pzWdQkG}rz8&i;=KIWif+LE7OXF5ey6gIRm3KaQ-`%)ur{o#FZ^vf6NjG@+
zVBX%)xXo+oUt2$lyf0vP`3CRD?d)|sKe6xX^_>(n{r=u;dj|&bk`3FYF<$>AZh0-k
zxYn@z)AZo|lfKSq|LkpDvj2W9B0wr3L36}@;r0E&(Z^msE6>Z@^7ayYn{4H>?Y);6
zKl3dvOL!qy6eB!yXY-;s?g#t0AMAO$>$#zO)Yia|@Po&<)vQ{zYQ5#T;stZxSKsTH
zJ1cY9EU!#ugR=9UYu6uq;Goho-LqKi>$Y2-Dz&?J>tA4C{PpvG|Mk~fzx$uB{rU65
z^!FPXCF;L}*EO!Yc^fo;_~XHQ=t4)BfaCWzyWCwT_nJPty=FqbPvy4PDr~<DK^!|F
zk(PO~z13~cvNfNp$E7`!I_3EA#PJz<X`3d<6%{_qOI)*rf6koXnLFE7YCc%ry?)=c
zp7iJ8#-G=@%yu(Aw=Vg(QnH~yeg2#`alfB^zgzwOn61Lj=0iWdGk<v$f)aP5qR4Cq
zMpuy^=el>L^OqOvYMi~ZWl`VTUf~%t3U<c6ex`cv(ob8v^6lmE^BZr^o}Sm$m@=Pr
zQ;mG)6TR7NKW><r@n5%nAnP=t;dJ#~=0!s7^D<|)zFWW$doK2F=>Z1u;;CD<zc9^t
z9=YJ`U&HdJddDx`_qlD7_ABZAl-)n&Hj7KIIsSR=mTQF;7JRUX14UVA`2PLVZ8kG1
z*RKUF&%K?y?WN~w-EFsZx7~Zc$!p2Bm><(m7H>DqkIr2($y22V)C{<tYx~fBd)e(w
zKjn^Zx6^Ke?w$|Nc{>$s9D)e{er4O&mAP-tyz>phk8a;9`SQE(loz#Mb(dFXU%R~J
z!<KDx4*tHkH`n^&y!o|XU)Se-S${yjLcc<v%hfJ_ZSHo{cYANEZaU0m%h>o)>XT-e
zQ%skyaP7mpqPg2{=Ve*1c(>^BBk3oC?;bzh@vO$D_UMOCPb)7~tZ&~M8XEWey1H$g
z$M<OOFFPw(!&^fhzh7bxE-G3W<ijiPRi2mLC;R<)f!&wa9d%0<+E?G#S``3UUbg!8
z>)fr|UaFnlI*F%Sy>I)Q-_Q5``uqL9t=8LZw{tfi-5DAh8vatvAn8KFmRTBGW+`l$
zrOGzPKc(~4l<6OTrfj*t;^emD0+06B{+#akh*7*g{(f}s+U=fZxoak*#7Ebvq|BRC
zYZfOO@cV7<ySaBdHT~YDOgNeMy+mb`kIKoAsg3#3*~~kObGJR)dwqAxwur>)U2eDY
zqVH~s-top@L4X9WY=z1yO%<Vx*+}7VVruTT+qt)|>a8p<JF@if?n31qX(<mTomhHe
zP5n#zDo@)tnY;`64W~svx)s0l^x^mWe*1mDU;2LE?|1v{`4=!Sh$wP6SKqG#`Rx0(
z>%P;tey<OCnqYPtWGXy4-2DA@fAsHf`&XPO0r?IQ&!K<6ZoQn^wC_v$^2=%mwwAjD
z^|ak>osqK2>%hC1?MJpU1~J!vo^m$li)GO4oimT!>$-VB_~HBG_Z2yq?sMl(n&9!h
zd=Klk{cN`roZoY?&t1V)6Xdu<^Z~=7E{(dTijR+v_shtA-?M6ucCLTLgvZs_Zr;6n
zQkaFoQ(%(Eoex4De{L7?YbxIRz1M51>ZG%2le|r5IckMW^ERF3sdFt;Wpm_`NoUQ#
z!U%raq*zPK((54Ne&=5HXxTKC>U)noK8RfQHu9AD-ucDgFt^U8^V3i7WR$PZe!ur#
z<r@znmPQ3QAsQ6w8Gpmfu=m$&=G^aQvz3%gPPkq0xhTmwp~tO7Q7uy{?UqT4nun92
zbnYgB7G<BCoE#EPx!a7?jtP6t@-@5AoRcffn>%xZ_`O+ILs@4qFqE$2RcGLn@?&7$
z_KrcuWKqyNm(rt}J*ju<J6?DBmXuyk@>E{8TgcN><=LWhP+}68E-r~YsWRtEwCkKn
zo@ZSyo8=~5yW*Y6$#rDg#D$yGPTUU5O6yhiOt`t4Gi9^uq?ER4+ivSz+nVAQaOu)X
zDIYJ-wnGMMZaQnu4rX1nIB=zwlGkLl<}6+5h_#Y4eGal{)H@lc_`1znJ3Bk$V(*mT
z+$|=@a#~JyWV#t{+mh_MNaN~?o5?Ot*-_Wp8r6KaP26%T#cakkk+86}+mw@Yr<~x_
zikh-*t8vtY4il~wv)wvwN6b#xrP-C58?6x-os}xp>vMbAGHorUGgm^g-7a>!ddyCU
zlH}aRIqjIywwuv8%Wl<cZCtzPwrj4`27#zWK4MpLSKJQFbzS9hDCFi2vzbC3lblU1
zsa#UIQ4%UTNrw02mf3|yCRwRcZc9~Fd)+pLd8?{5vqqf`=aIT*xK(>~?yl3KUAc-v
z84KMetn|)f-0G0Qo0A;9>~`eRiAqjFN-mwDJJ{Bm8fZC`hOTo|_S`aC+v8HoOktNx
z9urkA+;O}c+%|je_1KbkD<0=%l%<{0&bqZZ&~4e;o^y&~$4*Wc+QX<@e|E-!4`znF
z-w!8CT$6BYkxt7nJ9BZv#SPaOjy4!dZo4VD?Pk3KYu$q1e~+A4Cj4dcm&qYoGyS5@
ztu5lXboG_#YuEL<D^@L;JU{N=p16|O_oYv7EOWLk-?#Hz@x1+o6<;5H_<iqZ=<mMw
zOXk+T-*%Is&EPwvwzHTW9eilpm3n`6!J0-h|D09(EN0t<))cBvk6bg!H*J%r>8z6~
z7d;|Vr^h&FYA(C(yH0V-l*`%c&Zcehyk5HdR^Hv$+tW5jDyFt7dZupA?noB7oW1P2
zz>Q_oBDWqf?8@AF>6FuiP3I3Dyp#TlCx1m6{~ZanV`(`vjE&OF%p8Oz&dyAhHn!YW
zf7>kGIB}Z}+l?c}xtr2%B>K+a-TsD4L*oR8mPY$4hQ@EKp}D`(a<|=lbC0K2P@v;N
z??!23w={=?Z24xl4NZ=?<#<l$oopu2+j2=L<>Hbf7cQku6u6YAEbMcVqsQa2@3slK
zCM+`qx8-Eq6i(?i%4NBg(>p77Msv<t3FD~GQT4ZTb9Hss1~4$pX1Jts%VoAlL(iER
zDK~OwlpV;)znuO&p*E4HaRIZ+lDhl(+pVuETb}#6y>i>V4`tsszC3c9yY}(%etzGn
zA=`7e-MZbfIyZOQTP3X}H+664zOTkC3YwHwDXmi4$LPu`J^%5(eXlg+>JR>%(KzMF
zJkN8SQ@I%qi+D{?SDHL2U>0X+$YS-&_iLV)?_S8f>L<TU{NDFd<KtH{m9KroJSp-$
zr)tXW!}r*{CiyUMII_Q(oEsV%`k~Nl+rG*7zHhsIyk7<>R=@9kUwua?*T)&$vw(Id
zmR>nxHmPlPeX#e+j$Bn<vt`qR1#Wpkx>4YsNGxhcWf??$+=X2;+FFiYxSgEcdCMo*
zIU8HIWZvF)b<UDsdb`*HH#(fkU-$WZ!td`bI?Gc&`ASStwN%@AD%vFdWaOt)>D%hP
zBAXw4S%0tiaHHI(Nd^iZUaRJAxB8$U@Asbh0f&O6>bx(LJZu>AR3<Yp2^_w66IAUS
zJaY5XYS3|cr`Gqq*yk`?eOqX}jPLyFz3;2<y_=ksBpscfxzz;KpI~q1?p<~T*71V+
zXL|lRM)CUWTjIe2x2E0Y-F9mRxR0C(?Opjo17~*l<ntC^-xt5&{nEDJiYc4@j@-?!
z@=qQ9xZ$-a^JMwx5B01wRr;!r{E|p)oferUlGuJh&vpA=emR?p51`?l8OIE!xOfFi
zxQ2#?-cDPccT$m41ztZWa6_1XqgL$?oSry|QD%CaBoq7eUJ&tKf=O(8%?&11W~pnp
zreAboa;onR+o~J2W%s_CKR>rLRPfJt=9Kh1`Ofbnj{=9>!F872QpO*q+;0iCIkI%y
z#}8HM?=5T({HXMl5U41fwC(oX3IYD*<&AQmC${VJN2fF&5PRflz@W%t3vQCt9v9Bt
z<}b%zeecui$Gh|=sGWQ}HT>?8o8SAZ?|t9B<kpO~YqzI&?PrYSzHsYN*<_Imw_a{F
znf~w~qk=i_CsV7)Eyqv#e$t#LH0^tX9p9<H&lw)nzSmS{s^HrccDr~z6XTb69~7AQ
zn<quS_f&ycJw0weV`C;PWrD^hvhO`d32X+%|Ml~qf8IZTe*b*C^5-wV|8@y=3H^S?
z;IOgL)>V=-*wVPJtw>9doS`hj41>lDXAXyLRW|00x(cBhl^9ew8JIk$Cmv>$pPqV{
zQGk;zjd5m^p@X3#NK9n9|6xY1`ZIzv8`2UaH=H^D&`jV&%!H*f4NGPI{`^yDq4mM;
z`<_+58|U8J_kC)->{HOn{M+Du47hO<yX|%=h!G|*$-~K0kyE7!xdov7bY1qW^$yaC
z9yzQGZyi4GzQ-xO=Rvvnsr7pqCinaMeK>WjqRpT`x_;a3BZe)Yg^499#{{+~-8nlo
zG~9PyRM52BxtiX&+omkwIm2wsaOQxq0hn<V!VKU!V|(ZBwwuKp3Ks|!-t8!xRKP!9
zU7)CK_r1{CJNe!(D)KXQKl01j*si;s<up%FP*7IM$}3li>v3#qXwBzyKcC0Gp92a=
zP{2sn%e~9Hb9d*tvfHz_m&}nW_dG7;!5Cj@(Hf$A@6+n{elM9XU*2Q%S@Mybpxo@-
zEsFl&t8-p>_9(pV+%h$^=JR=*xA%UYw*f^7D2zb?Is?k+3E&BEOJkhbke2xF+1qo)
z+pUY|+}*i^?=2^@lLLR{r$XK-YW4R%t$z1dZeM$EwPSuq#m9%Q%WjuyJ`@xb+N7Ma
z?2^Jd-J`2kUCrM6xfv-WU_ru?)R30Y0}iCa{|y}@)q*2M8{3i@{wc&aI0%ST7f9@2
zU|=<1U|>lou=@ZS4dGuP;=$lGMN~nnVbz2MC%cX7HBEhjCW!=wES(+XoTH)O(h=b5
zqQI&uuq42ND=>hefypU^sX-&aLB%^eA?+yG5C#TD2ZjLsUIqpR=>`T?4W_0kh79{Q
zCx|wzT@%{GoV!(mahnKJ*HTsu4aQFrwrf8&e&BL`v0+=6R;X&`L{+AVxih2hyI*|Z
zWB2=gJ;S?qjNiW3RKMTDyqllRfwQN!CqBYO`QXY2UP}#T^f0TPnsQYubAqi;<MORR
zlNuOIIBkQxg1-j!nlLN)dd>2j)PLoQ!3<GTm8qVuQZ6L;3v^$ZzAbmtncJx|w;kQI
zB|9sPciYV7jJ0lC&PWA`O<3WwvN=?fTX#ZdFx$*#pM&+w5-uA=OKj|QlkA$=HM4iy
zv>8!}nY~-ReT+qoMRg6%gg{}=8R=YO)@d`q3(2&ilD&P5r45!YlkA-kl_qF%B{{Iy
zEm3IY)R|j0fmWg&JG)G>ciJqF-A$)`bPcu~y3Fl!b<xDdYCRJdOJ=ql_3WA~t#O$r
zvwrK!#HCx^E_9}3oRl(h>p7%46Lm=#XjvEtGe~*B7K<@lazI*323dNRxY^Ty;o_DY
z=<>6hOJ*=IE@=RZm^eV!vw;LxdTM)lhD@3?YuTg(#>E*o>P>Q`xu#5xT%2(u$jd8h
zmS+RVGGxrwyJWN3q%#+{OhdYXhYiP?HdBeS5=*8`xs`Ft+t}?=<SesEr&X3LTe)Ob
z!!c0ugJR|c!v+S%9#yYM)_N|Hgk`3=tIU)ZZE5l4&RDTx#fnwDMi-O4b;WKO_C|Fs
zU7U1u(OF%w-tI6hwP~4Yv!%s!0+SZ4a8iphQ(AOvTExbPtx1a|j_Hb}x@cWgx+vDM
z#dVR{3PYpC$x)h9g%oqbE~U)WxpIoN;aazAPVQn?*M@7oTXLp~iZO#wy%@9Sny{l=
z!j7Hn6uRv>tJ_P($=hhdWR;UfKGRI5oSe2~$y(47t!uqf7Z*pFM7z4S<p?k`HZdp|
zIIyruZV<cWInmQw*K?bfZp0ebOpaM@$BtbMTy=D-Yjbi~qOfl-2y9%U<dbW%?V@1V
z;=sUOw;NYNvNmpv($UNaT3nx#$ua5R#;()aQfqQtT(V4(oUVF=N*St7+7gx$6rAQY
zNhK?HYS+z`n>J3l8L7i5)ykC>mdYh^B-6~(baI&PELT;t%^n^e9^N^Vbv0ErRdcsw
zZOk|-xb0--L{G15m8^|x4r%L7xpL*ef~zyaJXd?TTz0#dbhKN_N$Jw;Y{qT%E3QNw
zb=?@4v|7w;vFoD69xl0)&gx3LhUqX!bh}+!EVwO5Q!{N#ui7+ivw&q;XBJMKk!f~Y
zZPB*goLRw{CWvdTy>&GvDyweJS#X8h3wo$umzhB($1GQ=l^&5fExuX?ISDroX6H(5
zo6xyzu~bi%F~=;op!!=rA!pYl+&ac1aW&%Lwu_z1j+q&5oGf%EcdJOwES1YjlV%|;
zOX6JQJK1HnTBp|9o@iZ-iAJ0zO}+|CXSu5Cs$5jvl5lIALDb5o1(!WVmndaKofPxf
z<hpi?*cC-#T`}jJ(_$-?qa}`pPBI0bzqswn!6472OX_>qoLI7KQtnEloS9}mvsNeE
z+5%ny=r(O~%9N{{T(cn2n4G%RIA_h#l$D;Qk^+miDVc_8=VTn2rn}KoYPOh{N@R|Q
zhlg~ql+Tt$E|E)anXT;(Rqa(2_LW+6v^P5A)(Mx~ZljCaj$LC~bu?R|cjMZXv)#Z;
zmvU3;H$|G=Hf6d5K3^|bI!sg~C*hK^Qm-br?%E#dY&Wi@%4$AYTN1Wz)(r!%)0(W(
zWpb%=bM7jG+_e%~(~?6Mvu)j&u_kv@+a=wVIop<OW4W=l?P|8j+9lCkxf*AuM5;ur
z&6&71Q)wla*{w;sxoM_qr#x<&ZkV*$$cvNBvpynMH!^Z|a9Tjvf>UW{v$a)jbLE^m
zxZ<{H*0NhYqT6~zw{A(;b|vkW>*m}gy;F4?a|Cl%=Cp29&RV)f>_S(w#%;}wTUOkd
zYMioi=BAJwueOuHIsccbfzGl!INNZx$)+vaPUozJEWt`v-L_a+%xK$L!<@CwYCRIh
zX+1aVGgG6YQ@4f94vR=QIMra<nrn-Ul$Bl0QYCX2bETbVbDOn|MeNwJ)HRb6gH2X#
zn=-W~NbCCEXpzN*oARB*&W9Y;+^(@TYE7}`h8xlDW=C@a_vExF^mgZaNo_S-xUx%X
zTh%g6-#s}S^Tbwk=e|1XE7>8GIV;R-s^la=PmPRY8|$T|w7A8NWa)CO-Kx2Ad+0_l
z^ByOzH7nPfUCEB>Nw{%a;-Z+TV7A06-J~m_tJ7B{O}Twcp~XbeYucx^qHB`{a<Y1o
zbV8EWWZah8xXtWh?yGH}^YJpA1TM5W<wwmHonkI6mUep$#2_<;8><Y(bV9oW!_4;R
zx<prPT2&vk>YhldG>dM_HKk)gIW66p^Tbwa8~i%6aMF#itek0QO}jJAHm-^G%ze0+
zHK}98kzBKG6Az)xSyA3*MlL~KV!EwKGeg2|O}UbONXaNTck9k=i?(J<ES8p7vMSZh
zBss8K?dGfwGhH{OqpoYh?glM&R$_a|uyD%lgtc5p13PZjYZ>H(N@-<Dw`BBA%rSed
z6(+DvI44KtlE=2$tMgX+MrZBpSQ9O=IHNn@j-x<EzQwe&TQ+uWIUV}6XO^MZr7%-T
zon)z-cA_2E9=iBc<t$6-3C@yoyK-w)wtJP;#jU<cIkUN=#I9^pT{Cr4j&7EjZ?D?z
z11AL<1$CvAj%<orTkn-GIFZL$>(;64sN2P2ykaJ2-L71lZPC_|{A!z~PeI06f!jw4
zHs@}4S+m+(%yWs`?XZhohCVl^B)gfMHR|fR>vhvPdEpA%u$x{vA2Lq-Jkm2!`H_uc
zhY!1N(9KoRg@S3XW7x_VcU`%fEx9^3GU7@q+m+q7xw8|NmrYKJoT6GEv2|H)_%va+
z)FsEJ&Dy%gTRYh7?Pk6-l_PFWX+9@ssvNoHapIzx+hyO0l9Nr6lyaFeXI<u;Y*Jli
zEL<DCU14HV5~sv+4i`lZzm-!R&ral+oiSN$Qlyee<|cs-CxO|Sn-qm}g;FkgtN5yP
zcnYexOcZiSyEs2`+d;3ih(y7L`hZhsazc_LJPmu2jydGcI;bnT;DFGSt23@-sx0+g
zxGkIInz5q?NMMbps@ZIp+ony~k_!$9bW2^)Trx3dTR?DD+Jvkd3ohLV&PtoO)ofX2
zGXKgb-eWTE%5J8rs)5pOW|xApU7{sctE#PW-PpCIQ;Kt2uJo$2I%}t{*3L|<*I67U
zB-QJvEM0Ot?3hr_l@k+#U1voF`gmq?OSUE%F4dWk#^$Y<#MKij>eg{fC(Eo0bZ@Dd
zPLg4g)~XZ6#W@p&)LhgiE?KHN>rN8`o8h*psgs&6<nB0>kl1oy-;p!EUzV)b*eVho
zo0_VvnyGs>IrojDGRqMmgSbtbrrpu4=iK(p<<?nc70+$6Oxz|;GWL~H+;U=e<PsCN
ziOX&~e3pCVu~tK6vFPi(2d38x7{V2$%w{_|Ihj>nx~Z9P(mU!`#FoH~8yCB2+)lcZ
zb9Tv+mAYHEY1~q}=B>JQb)lrYaGLR2-)PM#fh$*QbLIL@ox1Hxa^dFAZ8ObPT0B);
zCb`sS3YlCK)k;#kWw4BGb;v5uZ5snwGzGh*Ts8`c3h)?-iWwRx8E%}?6=<dtam#Sy
zl%6mj&y6XIdXsuLCUqS<x@ghHWhoce+!S_>Sg|H2;%LXUZ7ZX*OSgHdPP*ykt@D6c
zg5lb<O_6J-^au*LHTg*NN_8oRdIqeyaUr?wvGm&LdQIPD?|L*vGzA4)m0FbyAi=i%
zx>siUnzdc0%pRIe@Z1z#a%-E$GL6L+K2~S4^OHCXS!{g^Hl%myK9}7*Jv6L&lCQGB
zY!8*2YPp;}otvUna(Nf$@xHy)9o294&OE$;ac$|QDQi}pzGymWX|t;CQYV8XgNz=D
z9?^$v9Q9@gx9%-xkk!ueR-GEh$0y)8W5)SuVW&=R3|z6OS8T<tt}|Drd3$cV5V&G-
za!_EH=C(DeifYp&r%uVblB=k5WZR+*OVd<Nn)D=JS-aSrb8}j;7}v3ju1RJlS-qRi
zEZmVUFxkZNQq&Sp6}LNu%DHFT!mjp4T*<lJotnLIIlD<;y~R1Vmn%Cz+%k4k++--N
zxNxJi+X)4Qu=SN)8++Jzx3KYU?3$64Xs~UCh*Z)n4IPF{9?4lI5(c?$%u>g+gcd5A
zuJTmaWFjP})62rh;-;k&Xrf@a(#$O<%p@dYX+ySDuV-hA+eJ^;Ma`}fi=~dbUCg*<
z=IoiYXya<B?ktfj^#N<6bGKbM_MkKCcEd3S=BTKpE0tL#4W&#X%+|U}Z4Pa-u$Iot
z*qn81X6PjE2v5URCp@>Pbgu2~b@T}B<jIcEWDej+aFw{&<8>t`lySjvKH1G$TN75D
z+%k2GbcXI4>Ch-?;he*k+ise)%rr7__L<>wqr+#0=Vp&wqlC$V%j!AVPD*=jR^jM#
zxt!v5+j80D+>U6o<3ZC_x*cIx7It1MsuSw9YSU(y%WMTR6&I-_t2qj)<u04KZMNcU
zM-CsO6sfe?X%{=U2?}!bawthDXEX{57^&UnXt-!*XO>fT<IB~cETIDjbu%`oHa2nO
zuGpa3sKX<4t(z%ALZQoWT44PwSBcXaXO#@2c-eYpJ1)35Ia(xIBvd4n(Xp4&vA3D+
zSnrC9TW4up^j+$~91<<YaAL7Yro=6cErA&#fxc2*Yze7}BBn|z9kaG(m~Fas{d&@5
z5vdCaw;nc_t_q!yupwdHj3q}GTw7s~ThJJ~)oW=_<FVc?8RwEXqI0)}UG<t;&vjGa
z*fkD^D;)`IrCAgMH!1e65olZ~a6nnmCCNPYAfv9Ts)i)9u10HMnBS`>w^A<n&NRE=
z++m@dtktw~Tib=)4WX>tco&?Sn$y<U_h!wSX{wWsnuJ90E_UlxTXHE&S5&Myqw69|
z?t-SRVmhv38eOKM($az(7rRXk$}|=0s_%B(;+oN9cEK@JFi_OR<>X`q4uxJJA)zT#
zrfixPbjr)i>+Ra8v_zKMKAuLoQ)foA%$F4r)7Z@Fn6{)>Dl1rNrV&rF#4<O-q>Hn7
zwoGctmiE-hoY-)HRpM$d>&96eSzeQtteL8s!sEeUEM&OsipaFdnLWu~6Q@j7)|B*A
zom?LvrJJ(plBZixNYAoclcknyTr*KQ>~>g+kL!#@n;P8~Cn=eV25$3Kopf?*lwiii
zWlLPddM-G7IS2;MP)J!5X>u#&<b<uNQ#F+?1?6~7Ix}&T!?J6T0&v?xQ7JQJH>I9g
z-D*d&a<i3`l(NfGXHH$WX{|O#$680WEmGUA)$i<PP0m=fQQA5>Wy`XR=bl*;ckbM5
zk+pWqEfb%~xg0k_14A7{w_Wnw*0^(7%4L(;DmfQbG7V4Xcmz&4s-5UGbIRI{*}2`0
zYAKy8+>%~7ON}#yZW$#DZgV?3YjLoWN0ZOypleGb7Dad+jmXtq<6+p_*v7yZB+{ch
z;pViPVOsTO6RvJM9c^6XGBwMbuk7p*;ZWZr=W-sU-InRq?K<n=)#kJ<WYx8+*A086
zOpKJ2rF7DgwoLO@U6e9Y<)XqrvxM9A(gw*VLti9LIdUq|b!O<MZNAIGPNv*S&6(z{
zm~_fmGi_<MSXS7UtD7!%n#_vUoxquM<aTma+Ez*3W!Zs~>Q6?c=7hPdIcw~*r86hv
zn4ue!?%JLtEu}?ThHl4tC61*o@j7!^S1DKGAY<5#i;J|B7E8@IwOHcpO5dcgl$$wI
zXPQO3W*wTjaO0NE&dEtv7fjAHT)TCRx7gu8*Q8@jKAAd#LfO$NC)donq?Da4ot$NM
z?8<D3Ym1YUldfGe$+&7St+QdRvu4+-vop8-<GZ^%|MRytNyRpa#7UAWlOPMb4y#N!
zsRCaP*5-M;%;2z!!C@XFPnAhN(-p2WicXih!8j+w7wby2NuY&hs-7mG6(FGHXeyI3
zRg6GlpqckOiSPw!v-56&rh!3=*KjUL15I(KOq!m(icv~$lCz4zNw6ERuWB>9yAkRU
zPnAiT)AxU4lApfd1|zqo3Pc#RzRa`7;4lx!Cm{EL7zT$8*KRM$&b>41b~)#C!8MGs
zaog@5f*_)ory(sLTbgrw_ln%>irdQrK&#YtO794}z0-8tJKx;hlX;9hd5oqf-elC6
zuCRuYU3KcVccMs0;3N-7WOsRDbl$`0yeEfMjKXg3n9hHbQBw~beh~MXtleI)c6$-r
z2HxGf+U}NZyL)o&_9D>gJ=kKn`nJ1w!OP^z18(nLZET)<|Mjo`@qa-(e*?Hc=P^9?
z-MwXYCipx#?pM$w+cJ{a%O>Y?s_uvasn}A;yzFpw?%ns*A~*7L@7}h3bLPf{g&j_r
zW*4?aNwla<&gD*paG}Sx<^FGlZ!(tWhU`a%SO8{oF*@89YKS`sazotoq6S9wdTo_$
zp5Jfp`uF$8-w5!5bXkif&Vo*U3zS-SV+zx@(~x7~wncS74z!C}0imONoP<Hg#$9n+
zy-gK#7#x(2OoJRcm$Nl+O)@9=tT(K*%J#3*JazZh=gj-wABKG3-K6MN(AH_~)X5y+
z1Mr}H4e$|s(Jjzp;tpLfJF)<Be#P2NiBgaQ?LsrbNArPv2MOT@&{k~GNzp3b-`=gS
zyN4WL+oF3M-d)N~SeUaN8jw4V@Vy0j+*!bS%j}G3-D8TJOF)O{LC?p#0FgeKI^&3<
z2}qs?5&##Fx$|yr-+Qm}x$K<}w|^W?``5;`V!ERrlfrb3CPw>uCI^NI3@Qwq3{2A)
z7#LWmF|aVM%wS+pU|bo&z`$g{V5-f)z~IKiz-`LFz_aY^qAtzNnNwVxe0}rpZr<kN
z;u5VpVaX&<wFDtYi3vyAR2rxFEK<_kx~WTdvA1@1-E$?CiK?1gZUs$Qy6loM6O)Is
zki;Zb?<6IUNh@<eML~VS8HO{wCYO_V4)7ef>^oaPZ8jrI$PFPOlN%gL%MMJKxHLFG
zvO%(?iP?bJV1lD>)3O7TI5Ibc+z`^5nj)qZy3j<&<aUsQrpt^@->#s=Qfp1O*00;e
z=;b+6Wmbk{>ok_OluTpIoUNb{Kj>04Q0dXF7Oeupo%Jide9roM8Z}8eLP{l2;iGa|
zciKsvO*eBUWiFYdmbPrkl!c03LdF6!x)LNCT6A@rw5A>MRNI`xz`($qot^zOT6AsA
z)s0b+*_XW2OQw0JzW-F84_e&>Ua#^U!uoYv<>lY{h`pCUr{hh&SXjMuKIp)_`np)#
zEzw`U-+kkmf4}znM%DQB``#yc$M5^SKFRC;zTfL}h2j@LVEFg<ci+gjPK$3_|NedS
z(H~jA-$&nAe>nVp)xD$pxpl5TyC(kGN-tUZ_ue~SVjDQ!dXnR3N4PPhpLwyf_j~ou
z7k9M`dsn~XyK|SXw!GFf|91Z5<5lnKA8h$~d)>M7-tuL8%f6lWeD5;t{L;z0mp-4~
z-*F_#=4G6nk|2jz(D4ps6(*0Wo8Ke#Q$g#u)^@F0t-f~O_wQS4P0c#Ek~Lj2R{j0K
z@apP((8zrJ3+X<SNP&$<%w;k*DVAJj(m80cwz=?f<-KF>pK`uT{`q#t!5uG`dwTzQ
zSO4y9+T6RkDSM0G--iU$s#U9CL3UE*``-6hL|^`Sx&D^4_@1xYy$h?Ce5uNMkrVe)
z9elvuyGeh(UOO)Bbo0LZLeRN)H6S%r=O(}Sauswao~K>atH&8}o0sgjE#IS*$^O2c
z`QZURh63gW;XavJJ^~h;c9ZXBKkoE<`K3R4RiS3}(qHatufMm=PrClvXLFrC=oCD2
zP+;z65Ne5=yn4p5*!L{o9<VGr;^LD1QG#*4@uFwuci%l<T(XIW;k?hQXU2QayObPj
zQc{jDD0}vz`1S7B+mC&1o*#QZe%pO@+1I=3S6?c(wYqORJw4rIuUT1qVb$BW(^@a5
zr{C+p`abS!-R<ymXV2c$|5V?;f8N>R4T6j<H+>kFMX>M$c(P3J<O_;aTD59*(yCP_
zU+3?AbmH8m(#<=BJQd`HA2Bja@Gv`^5~Qgx$yw#wzS{5iety4SwSQ~SMMj@gjV_Jt
zuj|%z>~5&%+x(Y-fkFIN-1mFG?|l0C`VW{9DX=TEQ7mCTYsxL1)})myp7m<jF)%RL
z&%XEl=Y77KZ~v<Aiwo%-dbx}xvMFg}uF$ECAy<msH~;y#;~*Gb690Mk?%7%8WxIFp
z-a4ziH1*xw%e$hldFIai{vN&xt$J!`=yc~tjKcNNe}4OJl6u>h^m1F3-PTG~ACtG!
zC;8oFP)-qwTf1Im&siabNnez*!zaZplPWuXQa!Kv2pcmKqnW2-13$9><3pwIlYGwT
z#(nZS>i50no1MaMk%{d0*dK2DspmcE>9%X0Dqq-`S%mM&)Hq5k=}-vXws+FI{7FxC
zmfbqY&~T6?rGAosKXYTsq?^|FJ}E2;RG+?*;jonMDhHiy-G%qdV}EUZ*8lp~`&qVC
zzwcX~{lom73A8RWY1OI|D^nL}Z32}T4^<{G-I<h~cQg3<E{}yO4BQ787+8On?>_c;
z-TabcyvJic-|eWqeZySV=-u(^-}63r*cZ=vCtLQ1E&JLUyFb$nd6{JESFQT{J9k^z
z@p9%#EfYB>Em^51l&N;-?FHUxw;jwfRaSXUie9PVDKOK>Yf_@xB+%{9H*>czCuKD5
znv`%T<)oI9+N6Rnd(ZCkp7dmA?$$}37Vn<y)bscVS{CS_Ai%-Gcv$7O>Ye+lCyU;0
zZ4y?QUT%J}D5mM{wkAe~1_u?D`gxBcQrb?+_y;Q|ZuQPEdm^Z?bCRowhNF(5jK*S5
zmB~kUf|_cRJQ04q`094<_Pr{T4|%G$1bJHByKPmybKC7FJ}Q$uDpVLIFqq7W`hI^u
zXw@jVBwV#>)f!Nl?{`w;bdjLSmcza~Z!eHGS*?4+WpXfYJ?Iwi+~m@kY8!+1>KB9J
zM=v@zWs)O{fWyN{vG5pU5pYyg`KD4Hth988`{TWDJ}BRN_kIWHETL%82<{@!wYyXO
z%gs*-d8SO_P?_Xu$5Op}_mW9$ci%meKBua5xN6;ZbCpRBxA)#TTzO<kMAUXq72e%<
z&zR5g^KxzbuzJt!x@S)&c}SP<o{?`crJMKF?mKrTc{1m(3pKebelg!qWu8c2n}8#W
z0GmYedX=f3YMnW=SU+@EZu@I7$x~(C_Dq$=?boOJn!8SKe99<Ze<qZXF=_q%+->J>
zynFC2<!j&HXScsR@>H3WyLI~oPxT@%qdO2&!5Z@(eM+-<2zTP^9eZZ>Srlx|o8%!~
zTP{9XqrYzcns2`v;u}LF*zf)QF2C_af8yTo%5Ar6RVJrQN!_8p=-wPpvs;IshOn@P
z{(igdX8mp1JF;iyZM?tdcHJCLl}Wzaw*5k~b#`v<mq~t45IS$eb;2~RFn@VulBde;
z?EEE@%2gKY9;_An^2qab8OTXDwN97ByY97^R1xSV0g5Jx#J)E|YAv%>H)V()(tURO
zOFhV|Rd<(6V!L1FwFwe{n3ld&YG_!szjoVg>*U?dJ11YW{>req6SUvt+I>%zcb;z1
zO}}(s9+{lGc3+dH^`yXQ5B7Ce6@r|!V3LA@4%nk`=d!}Q$qCX~kF3>VyMFApTT64_
z`)g|FFPP+~dwSjN+@NhsrK>nqj_xeIox3XR;=Orxc0pnH9aZK;PlqZl-R`N9+j;Za
z<GgOM??GU%^PO7N7{8xEj)CPJ-+RyJbqnlERVI0=uf64|oa1+HyL3s!_Fa>F9+%Cn
z&)wxY^V*X2tM0w>H154sy6t7}w(Q(v913UN%*<Od$>~Svp4)Y=K>er3Wpi_PoHVu$
znff*QF4!pb?96L7?o2=SzD#9q-X%}#n6gWrW?KSE*KSYF-L7bU;O?{A-;+F5CYA2?
zRC$|gbz6GUkGt=VOy2SK?%Hi_x7xEN?dz_tU#aq4cK6n87Y(=F&D~;fm`irD?v+U%
z@f_P{=iddDTkovPvvU`2TX<{9`bGC%`Q85&erElgJujb!-rc%&%haXi)2qst7V9O?
zC^wFdj%Kg@{`z{uw%ZOYKRA`;Br14nH073`ope~lZ2k%rA-+#?a<{W{w?*epyPc{a
zP{Y!xAyLnCD8XZj0;f=`+&($b;^q6o4^<K(d<0b1FI@)SEuA|35`!1pjRhi10cJ;;
z*<}ikgHTC>P~$cYR)#6O8y)lxYDgzF#DU})79fN*SQg%KYKUQ3klV#r4JJV+?up;~
z{)s>O;_KXbQ>w!5O{qV8eOckLS)k*z+XOw8gq*wtJUgcB+@HDM-rnBcuIA_G$8&yu
zT7A6JEi^QAwtgY!ovYv_CcY+&GaDG7%O^l<G#D5pXE+=4O3nzJ*?xP2aa#T-$qn^|
zTR6^g9C4B|>v79)Qxb6Sm~Ez%;m9Jm#U#m4axssaLR<X>Lk>q?i8dpS9K{94E=uQ2
zQdynrb?w^hux)EM|6^e1Rmf!aJUW9RvVnm;>cOP~hKEZYong>9yq#_8HnzzPukIcX
z+hNkU1f<O8npt;{3UtwFXRlDttYaJ3wDlZPTQbQzZ<nWDmd>nhwMFN`EpJWo04+sT
znG~BetNx|R^oV7<tX^+anRq?6v$W~Np>9i+XXlFB7M)zN38Lke#zbSwvlr7<CKU(f
zp0f%TQt`MoGt)bFa#YYV(JeQprb+9}mR7sfDkXAj)}iQ3fdy+fomKGYnQ%(%qS4K0
zv02e#7mY-FI=5Y19ifwTt<x<h+HB^`6-RxUGrA_#2bfG;aHTax+bHE!kI^xcsX{ra
zn<aX30&`cL-E>AXaw*TG+eT-D4Rf{5NKQ3o%UbQDoO4ShEHc|ww>LP+tc%+*ccp1a
z#_g!796hs63Z3b>WOQ@VWFfPjrKY(;n=S`!o9vyL>a2D$$tS5-B-*Xx=vLRRo4z44
zO;XNs&KC2SR(~o`S<Glf=cZLDZnx4rXO{%)%-MKNGun9C=5;HTXSr<Ku5m+n+Fh=|
z%Pj9+Tjor9cj}hc<V-V8wQEsbN20X0NO8M$=T6YNbivJ$TUzAi#c0uO>(&-W$C^F6
zkbCO7#%)pe=+f=V=5Et&Pe_`%H7Dg-Z?@RvunPjA8+*5Q8f0y(@4Bjz8?n)M$r{tJ
z8v(aAZcSWmuy%96t>!SvP#w`t$x%mIw@T<nORbg;nU=J2wXwIMYTDUovs~8AshhOZ
zZhM+}=D003+K{zo!O38rtC~?;vwS;*a}S(s%nV%V<tr@~baL%hX(^q|a1$xBD-xz#
zrp}ShP&+l%%Wzp|$_78bBlX)lg?)V%Po7m&FxjPZ(Z<M=hk^_zDruUoc01;25^>T~
zyWrr~#cXCPuC^3zo2+u?T(0EFIV$QZGjDrmo-3O&)l+LnhG~XrVDH+iyP`EWn;Th5
zDf^{%hdPCZNgZ9NExFueQl?O*NvFyrh2)KD-o>EWz2JmJHs9<uuk*I^71W<KHy4!J
zc)7&t%)1qRhC3H4$+q3SZFzayuCRA=S5J|;<8*o1jY)H_?)391k}7U@Th#MbBzbXg
z$s(VHp4)CMO%?Q9tR|}1=&-giH)qq$ppXR%x9UW0liYSaI&W$0kv?9P*)Dv=#cru)
zvpu%8=6cM!a@i?(^}_6}t{aRbqmI1XRiEW5l<S+}xlHBe!2@Sro91>&_0CQ@W5%u&
zvP;xyxxz}$pGO@uSFLiHHBr}NnpY0D!41L9JiRm0|8>RRT0iIK#q+=Pwq4F$yKS0#
zrMyYly=_eg+17}0lujzy{(JuWzX$%T`t|*_Y3Z!!EAn-r8Q<Gf`h`4HCNOLbvWZ^1
zS7qY%dTG({OQ#QROJB4*&G=gAwb<F4*r&!vR>*7Z+qC*YhICQ@7x>V%*e1xCm&`fd
z@2l^8?#h#~SoZMpz4!U~`FS72rQY6MdOHR@)S%Dkpux(V1QLkddV7Z|!@_lUZ^do}
zkE3vZndYhb-zZvl@^8<Sj(;n<E~(Z#JBI3Lwfb~=ty>hzx0EGx#T2itE-SN|TH{~2
z2z#vv^?o%`f2pJDSFedzIs;yWa?P1EQT%H7p1m*ME6*(UOWHZz@T>s;$NyYwZeQ|z
zxB0I2HTFV|bJMr4-vjEEZTA)5F}pk?^6c$U@#p8~+a*6g_3eAS_4D(f&Nc`$)i>}k
zFfcXnh#X>&V$fjtUH10w?%mt|Iey(YyYBzl(<&2mXTR2dtr~vn{B~cJS-vXMZkz6}
zy}EtLq<Gl}dxcn-*f)Kd9;q_@hCJU~tI}=$)kpToF@IXc#I)*HWQE!J-BWMtm#^7a
zI@>&jUu)kc(AjsX;m7xaMw1{TE#Ek~K$j+b<6^rp{kQ{@Vtv5%BoW??&O2Hbh%mJm
zayn?R@;w3_L@Ikkm0|zqoJ}|FCi$2CHT(Ph?bE4|%GqguQ|mT0e~tY1a>1pP3z?=l
z*Z$l6{rlclWzvuLtS=@g2-r?vvg>|A4X65nX8XFoKmT6y6jgoTfaJox?<<%uU%qx?
zWrA=Dzm^ink>B^euf7yoQ+<Vr!2^141SI-yXs|F$n0~^6NufS~i_zgW=wMWq1`)F(
zIt&dUHY>xzJ5B-IUnkuZf45-X)SC2T>m&4{icUT4V2ezD@JA|h*(^_<&9C@ZD5@x`
z%*ey6<@)AIhK7da>^-7h917k!VwNB|gMk5Q$shyc%obyVi}f>GC1+H6IzL*y=e>J>
zcv#fgZM^PT`cpz{*8F<8<e=x0g9_F6?Brge#Z+bJm%mo$=2q`sx~ck}>VpsRQv(Db
z>A&{Qx|`K|Q@f@ynmK%0{aT;-Y4|mqLBRBF`Y8t{IYb~pJkG_4h&Q>Ag-^qKJ}#bn
zH+R{lYm1$qil5TXcTBmIuqo4Q)0gcZzaOXzt*r*1{<&mtdU?rSt8;T1zrT;KzW06U
z)}S~Reys%xTI<(NZ(y9)wQBY2l#mUapp5Aa%9xW@Kb)PpZFXk;ww|+XJ;8~Kc?>Rg
z<ro|_lQK3=Tr6@Uu`9={$Ka@;Z=1xj!#u%>hZzsQzn#0gthR=Mfi3E416w4M>s=7I
zuEHq*$_1SN%4N&T%S*2(NX}q_t;qy6Dx?@p(h_;jD1sJdvKr`SU7XpnYAr}Y=-OJz
z8TD*wQVbf9C6<gn3d=z2HxsxLK=NRw<cti4i=gOgOJkhb7#f-#8g(^<33h^^gObC<
zUpK$+4cq%(>_%z3Z0f|{_dcy+U%Fd$llB9fRln{-w%skr-FAWtl%ZCwS|Odn3QiWF
zVJ!v*hUwy-%)IX9<#o3MUv7WdzSMlFS*79c=l4PbzHYxOyZFK_>G0i4zfb8|^X1Ez
zFW?i2&zH;I-rdPNgON2fl;`7)wllul%Vy_po0Ylk@O1l6jMDYf-u6wKn|Uejb&l0{
z@5H;;JoxvlS{V7^qw<xet}iNwJidk*vd>t=rP1VO*rRAty}VE{aR#H2)~dFjarfTa
zr62SGFT)jqEyM+d%>gFJy3+$9hhJ|yogZDk_U^{ZyMou3PLj1=GBLg~)cKm{yS|Gr
zk2TJFS3mv6N6C^e>B|>O95ZZDtM0wKy)d1JVNTbog_CpQBtIX5M2;rX+S$Yf%x-A{
zXAXfvT|RF2wy(E0-MzYd)2-cWX4`#Q#lH7i+{?JRyTf<SdpEuL;`EC>;E)h#NxW;_
z$!(Uv;usnryrcDICnz~wUS3~b?l<=UN)-M7EFwB7)pWAplD-QXdZ|BH7#ZESGj=yH
zFa&Ff9&uya`n@Yae{n=^+pQT%ZlRMHnL^hH1T-?O+_p$Lu~Fgbj7bw!LIj1=0vCG;
z28jqeD=M{gX?vVm6{4|dQmDv;m5Qn<S=o`f5mI5>elR!GGca&0VqjpXVPNb}U_1ay
zn+y!nc6SxTKH2cCXTCi5U32RTsdslAMBg?rFfdJFU|ibpJ)eKxFK4!&A7uE`5AXZ=
z!1}r6htGT8OFsbX=6v3eoFHGr{De<Af1S16`QpmEuNznX@-<oNWx{a6gmH4Jm!_`?
zvjc<B^1UIQ^&V=<oXckP2vsdro3!LmW&^_vO^ubloi@R0>MJrAJFHwKv}`K-ii-=_
zdhK$gf7P>pTa~gRWQlI*B&UT!%Xp31CUh=yQVrHN&P)ZJGU#(K*dQ{qby@BTms3l<
zqBABLsWf?XftHSPO_{V(Rn^p2<pA4Rl>;o3RD7l`@|c)dAFU;EfI*tEhk<|Fv}bFj
zZp{SUNPX+Z)y2`l2Dw|#h^<XaxSct}j921zhDp-Zt;TG(eGYEOICk4{v7yG%wTg>5
zT~{sfGBs9>j9L<wQ+D>qF;9)tI%iHTi%d%k+N`W{wsYAe-)+7olO!kms?5%rm8o*J
z<+7*RZM9jRId@Z@EUb?X6qWYbC@L7ZB_!$Smd@Ozow-X+CZ^8Xa?^2>Zl~|WT$OFE
zTcbm^P3oPP8+KK9bxO3Bw9*ZgGp;kd(v;4uG!{%_NmDwT+njXl*wKI-X|di`DbKWN
zm(D6GXQig`F3fc`Yu%{2MR)3^X-5`kL~Ez&PP?#eidpN{Kx4(UK%W!!kzGC~BBweV
zi6w0|Ty(T|Q>0Foj@Xo&I@3;?Y|A<-p<!z1+jOflN9@uq?<|cAS!W|>ZE6nOu;A(}
zwS>ryWeJg!d=6|D<vFm~(`-`Clr-M0JyN#=o3`DS(9KC&Ww=;0Bsn`8#J<+mliQu`
zc2(kHZ^nvaH*Vd|)R`2Wt+}Lrve}VYp3=EXE_rTKxs)=?hh>&$&h5aN5jQ5yHkrCr
zvQzEaZI#>zov6jhVF#0wuI5bKny_)}f{och+m@YLwsu2Cr?iR7Y>zZ0m9yJACQGVa
zV(6H-IW@O4XqxY|OKwL)w}f5DH4dGuaWmIxTh}eIi@eLS(v~GIxh<&TF;htAq;kDs
zXd35C!<kdJT{@PtCNpT7Z=_pNZtljgW4D}?y}hGMqSkh8)7rT0wxZzTFg7Wlj7cg!
zy=oq5DrdJ%+}5e&GE+HsQ)upD){wxB%^oh7G_HC%ola583~Y`#7<F4hJL2eCiLHvl
zzL10dOtvIlob9`@JLgt%&X%igyg5l%>XWu<tT?tdS!~gbMT@0HT6|&GL#u{eSvJYR
z!*k0lPa~C1VI?OYflg(&iz*&7S!Q_}doG!{In!hk&t%Uno<eFqo=c9*^6^|YNyVqr
zWRkS!lF4a_TU{6DgiYvNnA^2DH@7=mbW7Aij+q%(7Ke!ltF7&g&UFhm$;}qKRd2ST
z#b--ScC=8AO3Lg^9*~!2tTr%KT61LPR3n#(N*O05)oy#7x#YSnIWTRKX_}zPEst9s
zTXQFAXXxZ+Ty>k!X|g4kx9QlHTVYFjGjyW3MFS$Xt_fSPF<Z(>Wn*+i$HZ;3d^|2I
zsT`Z-G0`ZeV{(d1Tdts*k=scll}<sUdL_4v&YZO1T(vb*HB+ayN^LW{a%@@Rwh0}#
z)i!5lTw9ziu<U5Esj-HtSJ<uDX)3vkOlAtXbWT<|<m@?fOS6iJr;rM#S!QmZ?~Es5
zR~If($`r|3s+hV-&}7BIZEN7cdFf)eTdvtL-OZW3n=VHjT<xa2CE@CpgtdY7f!)%s
z@Ced5>L!*OHLG`$P_Eh}pH3y06B8!0D0y521+t^sB;SpTJSG|?`Kqa0O7b<CsFdQl
zWP<0C2`RHYrBh~kn%!zUvL(0clAww1#%<dKR%T9ZmD;dirfKfhoQtcD<}SJ&xYkL~
z=+dp34r@1ioHV;6Ddf^Qsow3D@8(P;kBQUNlG1{WCL4(*hM9^TTXRTlcG9gImsC|m
zH#Ke6ojB#p!sP6XYgfV+d$>$9mCp5@<>PV7Cv!=su-YxRvrA4)QgJ!bGjXOurs1rl
zlVM&imtBKIw@&D|t-I{tvP&03+E($3ZfU!9Npuyj*d{^g6ce-1RI?LDPE1Ov2PK~g
zN**~ERXir=3b}PEC#kfZn7P6>Y{u4T-!QdE!(^|eJz>*8ClW4}f-<)GMkY41<#wiQ
z$_$P&N;J(h1zicfO?A@A#n~E*PMwz8)M*4}7^+P;amiO@mZ!<BoXMaAf7~Wzs$BA1
zc5#-;WKXq8zATsOb0)i7l7<K`m=(D#>}IHP=H}#FF4rvGg&v#Jx-MP0wdj^ew^@eH
zR^y1-ky(;zH&v8;CueS%oid@*I8#wb<)$I;k`|ANIyuWuY`fMoi<MVsnoqW}!pe*z
zx*L^dq(&whCPt*C@^tE)nK<b{$H`@fRCy8&TO(3=4mz*eR=;|6Q{)QOje;UmZgFPj
zP7V>e8}?2pShY1M|MAq7o+@|EIy#($rB`z;=`@)scx%%XPqmVpyq8vndFt*nT&dfv
z3W9kZ9ZQxS?Krw*QzxgCTGc|YBa_T~TwD|vO5XJ3opiR_?WWmLmy9jbCLK7nU{b_e
zrzt9v^JcWTwPd(C)!(+x$~4VMX1g-YH;LCp?4+mKjiyB^rk<XvlU=fuZffdQXeoQD
z<jv?6oY3LOaZ4;cH*}@i95ag>=c00?Gj(QX9NpNPsWWvk+c6chlPQx<CTv=vGR-<*
zDW}Tq#R@ICyn8HiJfpTapO(JLs-ZG1=j~R`++~_(hMpU{yj)I2M%71jT<uyrbyAYk
zM&6Apbv;8LT<mJ%4f4#?nY!SjTXRzHByZ24Xj7@k4&j`%&P5ujD|NMXrcCk*%F*bN
zQkvw|G1)p`X_BY(F(t)?5-m?7rz|^{yG2s!=JwP?ubhcGIaya{i3UZQZA`kjF=EA<
zEVCtRrY_m$os)1S$vMkgWtw+A<4S?sLY^kO!7g5=D4-~<Xr7jp>!rGFhfc7VW;?rP
zv~N!C7PBKanw>KyT{;=$>8ZPP+O}<mZd!(GR)k8eW|`##ItcWpYwn7*o17x2WT_q9
z6sp#t#bP>XqT1xGTwy8`cO{uPD@rcRy`8pTsmaEbE^QAkPTXVR>m_W?UhmFYkkOZQ
zD_8C6rdyn5lT{8k3vy3Y=iPWFCtWvkRioOpTt_d_ZIgvWvQFLVRZ}{U<zjYHWtxA}
zA}7zpKDR4oOHF1h6-qXr78oh46f|XF&~}}ai`{{&4XZjXWz1BYmh;xpi&J&OQ_tk0
zWw)jr?tOU3#K}aEqe;!BmnFkR$*A6Zb9Th(5QBtco+_InbD|v>SSER@UEBsfTE(n)
z0|TR`%0yR_mQ7oYbT{cXT?@|g4v0?G>P?KCa?;r2)LE}H%RFbfh20Jg%ULivcS+LL
zj%(eX*{azG7mIP2EtzyFQrmISf*VJjJTtXDS-aV~%u=RKTA8twLpb8Bw#I5l#d=O9
zPbH;Ot6t}>S-UwpyIjhUMNrIB%P3GxtJ!hM<S-sdl`XC_5>BeR1m&(>6D-jhoMd7;
zY3Zbsp1RA<8g09hGIOO%pUHz0FYX9V<P%)bWFojFSWN5a)XuhK$*BoFy;3}Fy_@^I
zRJ4{{yLnqgo9ni>kkBEWoGW3f+tL<o)>u}5q@^uwQO}}AMX7bk8M;A{W;eD925wbd
zX=W0VEiKmTb2W2PN|W!F3k7aGPp7tOoLOqpJG*VEu*oG4w+rpeZO?LKX7wyvHd!cF
z*>j_CuFE9P<ec0kYdbc@rsg@PxFqE^>MU8(yQEVrXRVL=)|8-S6U}=%I_7!`$_NT{
zw4Rz=uXxz4B`G{S>~7Gu&jKE&m5o$gE~!iu%2X-HxRo<!b=K8cp6nruk{6m36x?n!
ziCJkb!z-=emdo?jYwhYN&n0)n-U;0eFPNaZZgpy<prEH`2*aePpf!7DOb!cn$>i(Z
zd1`V&@l@52IRXtm&4#>tlV-Yw-HKdtD_YPj%_LV<sXkJ2#VM~aH?y$d)Ks3ys=cmh
zfxexbX_AqVQ>PsAnQ$d=N`Q*W@in<@S5+s6>13I@x}Capac$bfB}W=fZp(;y_@(A(
z9yw$oqprDeXRdSD6_1lFvprILLRBXDZZ-6slvcsVz0_}+%j!<aG|9<2VTs0C5=lK-
z&(=<hSl!c;P*E@Fu428~h_kn+Nm`QSN=jzn#tFV|ZquZ4+njutTvX{?a?4l9W47la
zPa)q)8IwHCd~RhL_AE)wNI2_jq&8boprt7?nC;ROsbDv!OP(p7lQLEMvrY$1_L#Zj
z;+9@TWtWpGE=i${W><t+wt7ljnys;RiFVeJ%^sdx!me<tOqy1|Wo447;8s=D1q_}l
z*EUM3HHBSLQkpdFn8~!&8(DfbDJpSAa;mt@@-)}X(#&jUJCdz3YlCAlr|P5w(^wjH
z3%or#y1cxCRxqk;St&FzXv#$~Pa(BVbB<=0z>Y~?-l~(XaOO4$c`&MMUB{WNnrpUp
z5qCy+$f_%xsR<KRW=_(q_sp7MbmEA_q6C+fDU(i3^VE8%#vL-NE67uj)1;kA*yUW&
zswI<KOfuZoJrMF<y@O@a)!k8R+}1=XT@>q`oV#SnW)BrlwjOh{XJOvTX=kN;)lO!b
zs%~7VyCUq=EoG%7XOB}}D>`)}H+74+1gG_?O-|C?C=@y|;HJPvku66h4eMPJIzu{H
zCTC1k$rMsqvRTbV5Ofpok|o!(RtGS6s!W>b71Sy07ItP~XL9bFC#RA&Z8{Pd(X}|^
zmTB*jDJCb5nI;HqnYv`HXQtVVV<s!Ld{_2N3R-f7t=mZF#4@);pPs{x0V~69WlUVw
z$+;+0XK84vpa3IF($q;R9+N!9PIA@Xii~hMndYIo?V@oC$CixCK}t*)XK_foUCv}|
z>RoIim@-KvWu}^sOQ(>>Nt2T*E*-a`O}3f1H0mx{)aIQk(!tT><dYjTGt%Trw_Aon
zuC(tGLBWW#EF332qrAORjzBbZ3aO@f&WhZmc1q(E*Get#yriC-qzfTor<T>H%yRNo
zyOe2AkSG!5<(HZx;}g!#RT!E&&FisCaj10AO0%4v-YE;NEZpSM!f{k{ThQhtmkmuU
zQf6kCZcBz-%2YY3W-v`SXKAWdkeWwuu#(BPlOjefxn9wkUbjH|K(;At5M8OQI%Uf=
zuQfSm^fa{+Gd110XKkFham5j{Y|r``vyOIbTF9%rb+zZROG&;;lWuzEWE@kL*tlid
zW}VZfr}mhA|Ng7C^6tHN-{+R^eZNv<_2Fw;Q>%in8mx9*baHa&?5r)>5|_;uOX|$_
zP1fa^cG_9x(#?#NX{obj&0^a$ZKH2eWU}XqD2d5o(@r}JMMqA{%1U*UT9M|v;F_74
zmRbF=D>*q)x;@Df$4qiEmS`)k@}0EJIb@daHZzlqTc&QkQl?_5TawmHIUSN5l^U3n
zEOE@x?P!;onW@yV6WJndr&Oc0Q?^Yzv{7doXIiwI)|pFLi>1tt2DxrIYqVBcR603i
zlC-DF%*nbllWuB@NvklqExI-{DB{`{m$Po0+H$Vevt5l2xY3=o=$hG$TZ<OwNF56n
zS+LM|+J>dMs|{{-=PuIP)3o=fx8s+`a~?Pev?y{o2~6aGGNvVR&VVpo6pcBY1ZIK&
zNOmSjozNM$V9V1$4xd8;Eoy0LX=y1=!UiphoFKKmQ9aY|>oO@#cc^0&o4!|<$%RQf
zdHO#eMj1wt=?@n(=|isM-M^SgYI^ogCe4UDw`UjU<(}QS-R#)~kR2cgMf)5|69C&N
z(4t<lIuC;0Y2BWyb$ip*;vSH#iN?4<*3N@lqj^Aw5Nh!p6<XV}I#KI}*ES*WQG^Z}
zZHAzTffI{DH%!fe^NxX8s?nUQap<?JFZY{vI{oR-dgcEpD+jklw`7a&0IgXp=mp)z
z8>zY@%HbX83aiFDUW|yPgO}I~HCVG2N9+Y%(0dxXUQuOh7~&!q@HN5Op^#;T;7f1o
z?dS8uEQ72|+!j4$`gArXIlpO5&|7bxLRU<NLg<sJ4Pa+Pr>??FN2+eB-lc7F*>l_M
z>}B((2i#&5t#6rhLGA7>-z{&ZfUYynuPJ+97O*?q^4>SIfZd^m_fBfWKCgOvdsFMJ
zo#(!9@)EDSx4Z1k!t$wL&ZSk)?Lv#wdRuPJwv*<X_WNDU>vb}>#9&wXZm)G)4PLQ%
z=aIlH-z~b+(42j`xWh>tw7@ia3iPUC=#|B))0n2eYhY9m0ed%PTKhFbfW4W1hn-25
zZ*S8C>rMv^R)uoVDpSxE$&$jF&*$Y|Ty=GSYzAl?i!nMiIstUlo@_l^0E@E@gP?=~
z_*^}<RtL}xzMu<#VHf!_DjaNPc3J__#sEHSZ-NT9(gFqs5AX?m6I8e&n1px)K(_!h
zDtL%2U}<Ja$Or*n>Z|F%$;NT8abXBZFO$Or9bM3Mz#a^e4Gauvj58P*80OEdKX5?6
zsDXongM-tH!GnW?gHe<D)e{#NM@AMAh5)8R7Z?~=8FX|R7#JKJS-b+6K&vhU4jo`{
zVPMcXwt#_wqk)0t0>hNXuSH5q3Jpyh92}AkEUXLy0W2bn!igCS3@lAzQVk3YO%f3x
zwQOx#3=9k%3LYFnY!M7%5?er5Ww5ZYa56GEEOlVu2Ce<n)?J#pB{~7*XfS3DU}2cR
zG=+hcjcd~_50*wRj}yjT4B5_stH9C>3_%MRI1%SCsesR9nsR|*%Pj^5Mg<=h1~n!I
zBX1K1UC@b%9>R<aJQo;QIGLs~Ffp+-)~}58W?+#zbwoO73)r|#3z$|d&M}|NzNp!J
zQSY{G{^ys@_pd&+9?K26`?lTwRX6iBPu-%ptIFpYn7&S2^MOfV(kl0PT%PmSSNFYI
z();s$;oYer_xr2o9#omFZ}a+$Xa4#5R-aiW31%jLd|$k4WxYzrq?;gBA(LD@)Bb$l
z@$S@;NjIO*-Lqoyhct$?GzNPML!XY0o--{j@e@|`1ZIAnD?M%B_qpeli#pDnl<2KK
zcg)W6<Mw@hJ9qZS{Mh?>>rbwZBd$hD$GXg_&UL*E-}}7y#GUJV-XuSsFJ1lOP0XEp
z=kh04Ki;<QFW;RzO3!}RTkbpc{rJA9&#%u_ZnL+%U;FI)-uLoJ+d@NwLR>vqckfo2
z96oLPlNpl)pQu#db1#1P?$ghYpFxvvxnJ5Xa(3>&1u7;3S`>?`ms^&f`+4o%o@Xz!
z>(aQ6KTA50DWm>gXQ$x|&Bsz}f6k~naw&ZyXUSumqwR}q_I_*roOb*6>-wkum3qG{
zzu&Lj^3eEx^`Q^@e!t&0$#c_r(Agv})Aznd9KHcMcq8637kPyyXqDIMm%96#YprD!
zKZm^aoAk@pw8Tt5^5d&;X{WDy)lYy|Vdi_<*_IY=(T~0qzaDaBar%uf+6y;Uohq%r
zzNdUndF0R6<<)ba%U-+X(z#!5&bhXuuXA3eUthP*to3!y%lzx>wps6ayj!`<!us6j
z*^AB}oIiV2s9^&Gufzq0`01=0*bIBpZ_bT9^I~Vu`@PRO%jcd~df+%EX+nbc-MhQz
zcEziH`dKZ$tKjwQDSM}%zV~zY?mCBU3<nsFG4{CCn<RVRoEv*~+NG`Yw&$*SxjQ#y
z@595ETlFXXtgiAed3a-IjP1I|PpcoFd7i)fO>EwSw`VW#$!G8Q?JxVxr@*7;aiK=x
zj_L2@wf0S`E-!p9v}dLIlFf~uwN|UInS1TrOO>$HB~wrDuf1>kzINl6i)yt$*6x0L
zZ`)Bz2E8-Y+ZS!UU7x$~<o4&~u6IiHFM!iO0|SFtH=Fu|iERRvhBGu0GJE%%cAdEW
zIr0sEA)ES?6E|DreA2iiM2_8`bu_7S%cX>*Sc`5si5U_sUbWl4{oWg4a>L#}&FR{z
z@Vocz*WdRsN&4|E`PaSQnTOK%2`G39d8_R2KmPdR4^V7|hK5e(FlUme4-F0f_@!yz
zZT<d<^X)RX?PreN(q7ZO?3PQ=yZvUDE=fhl&#v5^^kHr0wn@1^itl|rSaj>%-aQ|=
zp3k0F^Zhz&@tuWBxBlEddz-#?l<)4`c|xC#?zgeovQ%MGi{iZAlPX{OZqJ-<@nK2D
zX3HlzU!KolS5!T5q31(sP8kCSQ*v@oz3b=dX+BLYiu@Y+F+8U>8?AYKXyT&?v-9aT
zHRsum9lyZBAT0giuSD|}1_s8=o%7@uD;)cBd)wRH&l5xAo`!{nT@AY$=C7$T$<ycL
zw(cG8R`=^YpS@Rf-R)fN&--m2h&M1Wu)Z#jeO(@WSNeIf-Ryn{^WMdIJN+fwH!l-<
zdp|>tKdj8=-Md=_Gp7Fj{{B9Ah352vc1G6vFE5whpO<@7>_N!dwcB3jGn`qwgQ-z9
z_k{p2bJ?@Eol$SMspf$W=KH$sMjHEO)9nmiEK|2HsA61@cjxX#?bvNc)|TDYExT>r
zEVec@R3y+<IMC%vpsPrrt1f#n<983qxeDgTm}{o12Cd8rOpsZ1N{-=ZmyTetZ`RQe
zkg|GLkwD)EbvqmW7Bl|d<#6V^E91tZhOF)d9L!>hTnWw7nizPaS~NKf_ex7k>nDb$
zGiR;VJ9KN+$<O+GKR@^1U%i{}%$aksJ9l5(RW5t#Yn0@S0}Mx0CV46;>8_40zrX(a
zbI^%S(BuH7B2^|i)Ry_4TD$g+v5rXnq?f$rd3iUc?zo*FeI{}?zo%Z86x3^H-`w5i
zsXXzd%A{L&^LHE1etvptXx5C<4Lm0{ZQltx{`KC<U9(s2dph&Xi<}p12|m^i=1xww
z(i)#YOVMm!s&s~{y<POqdUxuZgaif#MGp4~)83b*d#c=fd+yQGy|aruv)_r<hbBGk
z774!SD)Q}nURs)7O!u^JX=%FQ%nj4_Jy)LKb?41Vkx9Dm?!2qsJA0>R_B+v?Hz#ST
z#7?`JGIQD6MKz3}Q9F~4hInZ#>MUc|S~W$fD<MOA+p{!II|c^s^36Iy9=oleN*O-f
zd)a3>dAE`0CR_7d;Royu`6b6?>QAanmMK;*GyCYOw(U`m3GeM<W0v_049thCmsvdX
zdvj9l#Fx8U{2O%do!R7Rt}lCZ@0QyZPmkTxTBR4UG1OKh(7%lJfw-RQ9%+ZDHGE9p
zIt}j$L|YpjRq5XJ@$O!eyHoZq+GAtBE4eRayTPQq;~+OPeBgaI<MB+DNy&XF@9K};
zQ(~EQ`>F)o+3aoKeG1Raz1cFk4B}37KG@xGXA7uYySL)7!`<!12A&@n7$A1NJEJmt
z<ICL{^BJP|&P<x*dRKQ6#2Z?x!*wE7b-IcKs^8&TwQg-neK51brqwf4t}`&O?!Gxq
zQziD&O`U$<+b%yCAMU*j3YkQeyAb{Z={qw|tXfuNUpG6c_|CrDRo1)j-hCfEbB4+f
z1_n9lyN1V&%F~2=Z-B!~&*{sI$1|-rtISruTz1ipdE?!CzrPw!4E1?Z_t)%5((jz(
zg$wd-&zw<@tl87d9UMU4cRf*Qvw3O0_GZ_e9rqQ4FIO*f@>H3us3NAev4mq=>({7d
z+Rhrux%)l|sC>Eia>68u&r5EH-p)Pt`}nfCH>Y|0E}L{p>|O4+ybp}0Cu}V`+CAk<
zpxuRAOkD>SG_Bg2)_VBFT|Os)7QM&S#`TLPZ_mtGnD^|C*n0-?^=TzR9`j^#FL`eI
zZC=5!YHiHMq^Ck%8jJi{WLB+u(WJ5HhB&`+i6w`Vz}kCfUM!htV|9DU<kW+C9~eXT
zro7JFz1qkvdbj@O@&-PywJ~crcC~(WTN^b^r%|G5)z%#D_KCY>S`;~A)_tA4HoQFK
zq-5Tk`W?FW7_7i%Szf!TGAlkB*;+q#tyLS8x*RU(+H^ZlXi?<4`{rDir|{g|NuEm=
zZExVesIU6NQ@>yJ>-N<AbCw!OH}~d7eBGM%bs|Ia8Q%&4)%WT5yC-T@=Dj<z<<qx$
zKA%>f%u@8%>M@q;U6Ijz)#Qjdug;#&U;bKsKMh(ud0*$g*Q4{+wzejhol4Y~e%WIC
z_};$nd*6H7ZuPIuDSTBqJ;;_xyWZiQ2J0L2i;xSz0tdXD1Qv)e!LL%5SDEmdZ<=gw
zoZ<GK?1~#(i?3f_-yhc>x7UQV<FbF2!I><xC7D?QtuGdJhxxm?xfxD&Gn|#V(2BiS
zgJa{K&nKVH<9ql0T;)ULdywlP7bYfxFQH`esM~rj=IObZr?nGYYF(#990{47vv5{u
zLaL_Lw%a~!x3e5Bb-JmTq$vk(J1XY8satK)$u6mxDPGf3e5YN_-6D2nb8f=cEt}Td
zI=WbFv9!aio2x~)1#7c%<*W(pI_RU#ns#$mRCeg9Rco0NC+@!>xVgByen!Y@lZ~7E
zEDpIvY4-SRh>UD{SQw-|b4%b1Z<D~#iB1n<I$c9=tZ)s#uGMj6%F-}4Hdk(?)~16s
zFT-E++uD4oe12wj&g|UHS(o;iWIuMhe(Y$?tqZIH3<6C2`keoK^(}wK9+x>8`psVb
z>H3pDwJrzcp4sH7zh}~d>MK4Bj!niN=id4A1Dq4>Cf${A6PVYNEOFjje^=Sw<9lYF
z_!T{oUu)mA-+G9BYH<gr_lh!!*F!hyX)^Da!qgB1>Y&cOaZR|x*WtDZs0Rq{kZOQ0
zYWDlSJ+}1fz3<yQJ>!!!eoX25G0}}lYlDcdP}k~!mN^<+4~2A<mU=T?=~DO^8p?G=
zP}D!6TG91QkamM>xKdzfNuz#hRmPV~UoPzy$vc`;rY-Z&{&4-fzwfK>ec$<^X5#bZ
z%RNeXW!LX2tqIHUcLLo+E56%JpyzVl<J}Xl<&?RG#(dw$_ul%^=R=5#EV%_YY*b<L
zNHTLfG65{C`0MkW=a%O}&)NR9{rNknebRp4iqsERKKu-q%-xo>G46bn+1Ew4e&%#;
zVOSb{=udsI_qpgDk7vq;U);|rckS;J{j|JivERD=LxN8>M(unuY3-6WmTk#>T&vQR
zU+P|LN#uM91*+fuuJ8Ch*;3xSND<_Py{X^6?|lW@JPF?XC*A<sOsEIh@yG;P`nLeQ
zzzY)I2Lj9>y9n!58Kx&pX;E}wP*LQFU}ON@kqucd7{KMkx9<DiJx=~Qo*O17`8G-K
zuYG@hoAmegWq+fsf9{wS#5%j`)a`4*=}|#9HC-6?t<|^udZ+Nr)cE8&A=|aTPkeGR
z_>^&MR&aUV@6+Yw<@Y{ayX4Glo@VjPHRPQ8rRc>RhlDR*s`m#2Z}n}n{T|=*c~Yx;
zqJ6JAX!+Xt)U-)0DpPdaPKkj@f!--Po*EIoQxv5&!ZcNKCIz&B<P}xc757UmJ}r`?
zc2wGx{|Rg5;fKo)yZ0&Y%qjO>c{e)9=f@u@XJ6*PWwY2fW?$5e_$<}CzPkOS+UN6j
zrJs-6_1k<rKCkk)TFVRBGYgcCX&dcMZd|?PvIG2@Qt;id3PR4Ht7bVBEFSk2&)>K$
z|Atwcs-{=KbU{fbh3O9_GRjTAe}qX@);kjU4q_LVtrH=9&{-&JrzhGn%T5oN#K=DV
z{X|AF2<uidqbjrOwiVMIQy7(|@0!h|HQgYE(GGO+uy(z6j^Xmk@Aubl%dwZPx;Oi4
z&i8NTTDOACdiVJ+YQN|^&oqR6dJBh;P~3-o&!*4WUU=NdYW-qJ=*OL@yX>DKrEiiQ
zE<SbJyWiKUGu89n**-bv8frZ8%d{6~IgS~FZhfw*s;Y{#-Eym3?o+z*%e;d1du!iU
z-<wuleea86J%<M)gCd8M1Lpw;vm*_{2`!484C>&mv;p8%k8cE86ctz=Xh<goa55-J
zCpmDMadJ2b@NPuxM0Mcga1vv1;BXR{z*IXaI^|DET7Xf{DIU}JwLgC+U#mL)uI|!F
z&z9R&ntMg^ecd~~g{Cas;8%ON`2PCq^>?4|GzzWlU8sEP{-m{w?+HFpaQZU4Snss$
z`|5j>;&WBr-UXE|tCkf(3!QnBK;A*|kc;h0km_mGS|y51<?z*z;PU3%aVG)wk_Pb&
z;Btpy3E!gtZb<&P0hX_a7DyYf2{hitERY;PndN=HLR>^N>xOL{|LgwOAFr36Uw^*;
z`TpzIzt{e6GGmnH7IGHcq~pmjNlZC0$%AFWk(}O%o6Ou!+>};M$?5&qsUYN><l*Fz
z<H;~dV3M?ugGvhnlLvE(L{77iQ+;-H?v)9qYqx>!KHj!<+mT)G-aP>wc<BNj@aVVR
z^?KbqA#0Esx!DPm7*!M)4ukG5=2Q@J+%<_2xq@PtB+)w&ba66Bw9e+qtLN6Mwpj(Q
z-JO|g<?V3tPiXjF^Jtsd$9taCrhdB?Z+q_J)6mfR(71Q+o(5ZrhMaSKVx+bD?wwWX
z>hmhE<S>~rO7l+K1fm#v8{7^kC&Ilnr}R$gozlDS&DKXBTYV%qyhk>@WRr9G<kO<_
zzPwiX?(ZD$duy-dJNf*Anx9rbub;Q6eBN*KUHi&Ab=i~GioUrfZH)OYqwZ32*+HeD
z-V;)-Laq&lg-dyC>D_y;x+}I_H_1IKwtDyZ8k>!guT|7{$CrMo4qlXL8>^CRE8$dS
zII$<?yx%i*zqh=1=B6{Hd5TQ5@N7PA5ZNTa(88d|paQvzS%6VVg_FsB&#k@rQr4R7
zNxM@G-s|tZzxVmx=k@n>{7XLG`X#&iqRG5<ld6mt+H$@)=4Lpt=lRaN)*X3IURzo#
zZH(CS=lQ(y^Wx`)SQ-^PYToU7!7?E?J4dC>bnV)0w{y&#4yPDQ;$55jR%Y{LTQh5o
zvf#Y4j`#k4uYRU=-c!+b-M4vt6HLnHy}W+Q<5<$wZm|_p0$qg)ID{ED)E`i>={eJM
zG;&^W^7I9{CYN)!UG_CQh#apxZYOSlFT-Y3vEK|?=l5)@U4i~#*gC)d4Gs*^uVRmc
zu_b?RU=U#7ev#nHp|pyFLrdXQv}R7%5{H9<N{c+DvvW+9w)KRp3{X{#PR=noc68%r
zh57)dph-$gI5@eaE*o1tTE_-D1`|AF5XbzGK|Y%ivO<r+?pQ7J-R*ZLl-+x9*Vtp@
zifms)M!y?ih0MEU_--G5_<RpLWA@>F-{;BvzQ_2z+|B|l$-waQ`8@gR_xl*%_badq
zd@H)nF?ZJkQyb2pm6Ls$Ig;ubmo=Q+v{YpQ11|#uQ^@yKlcro?;5BGq;Is|#xT;mR
ze3je+BVGmukttI=ADNuu<+b%?NDdG+^;{`rGli|k;R56G#b)Qff0KN<{mP?dUaekE
z2UksLop!=yWwX!0WeJxJGH00eMwv#=Fxza9=@A890T=?hO;puKDvj5ejTLli=91~t
z<eAj!&8{s=058=$8exKZ2<8owq}ygQZtI$WPR(RHxL6?Lh?F5)4`@N($u-$hCo&ER
zD#BK5>74O0%yM>1GhOAfSZ(8)Y{kVKF7QP~n{_o+GhLcICbC@eY!Xz-xTVr5;Hxsz
z<dWxP-+CymGF#=CXWOhym7B|Ec^V0-q<FGSRN`C$TUDem%hM=x$z(MIrP3)3US6c8
za@kWzVU`DU)!^-1lS`hUb%Y#~RD5QD*3!(F?5pC@l&NSkDR)!ml4)lTK1nyWnWAwr
zXj;fkr`CEd5#!+8=%7|ft)Nr0H3AkoWjhHPUEC<0v@$a}I3+rCQ_gI)lbZrJx!qXR
z1zH()qjzJ-mW|uG!_1B@x|p#gCwEIUSi{C_>0GzluAsYAr6n~L6(_2A%v8yl;GrVK
z$(AXdX*N+|!ih;LK9kHqA}li}ftQT2%&K=Y=@ByaFqx?0G0VtNZDOx?7;kT6i?10N
zT<y(?Faxb6y8!}grJPhYL`z*x$vPaIbu?*X#G0J2HPO;JxxI=)5xTvZTh?T4%mLqX
z+?^|Rafy<*m}%1Oz}&@ACM}*xp1PB+P76};neDj+jJBD~+|sKuyWX=Gv_R{Y?-CGl
zRyi?A#pRaEj7$TSW0P|xD|t*5&J;>qx$RQKB|(#mTOu|l9o?F=&14$rLf2d|orsN@
z9KD;e&8GEEk=h)v(5aQTOX8aD#wAK-C)eDHGHbXxtCdScTiYz`q(|?@MQgINOt<7J
z3f+#B^66A^IXNk3;*$DIDYuCmmzYgfg05G)sqAsdq*qzVW1@nmLMFq6Ok<acO0J%&
zp_6V$EKX*d(77aVt0outC`z@hD-Nz&qLjJfsG_j9o37-R+Y-0UW^TD=khNIKYg><W
zw3}|%mXMUi;FP#TDIz=L=*CrBrYdKeOiJ+-QgdmUEznu7FbQ-+uF7mrVdG4bNoJsh
zgNAAoKug*t3V1G=*yO7+Lz~xZRl*9BORf_-7nw}CWGobR!)wact_xA3tgTDCPKs@a
zXwJ=4+PYxlwha+i6@^X38n^=@)~=c5$ucSBM5mNWr?5&}$HYaFTU^?dJSLhP@sv{X
z;pof}oh=$2R)6Yjw3&9AQr5C7S7$Xwo8?To6}n}{QL`yCXHK2zb22Sx%|U~sX$sSF
zRIZ#dHBM?)opm|s*6NgH7k#_7F=u)9M0U=I><mkpmcnT)8MPv9?dGhjzAbB#uJvv^
znk<@|GtDzK*l5+6&Bm<KiqS&3LEENk8;Q;gGB%sFDLPsu>WWys?v`1%nQlzl*mG#c
z(J;eVL1tRfEVo2AP1>xftD76x9Cghg>`KzHEmv2rI6KQ%rOjlPr%-RJ?o?^7=+K}u
zD>iGoT~*z(IBD9cl_@!yY)4ino2)prT03#orrBm0lMF7Zw$(-%<t|(6Giz<Yri?SI
zwGInwWEzJ~yLDS@nwM}c$I1GQYckigYBL8MZ8;jTS?9>HNtp^Wr6i>@dwCpsRWA81
znQ?KW*@=_OR?SQ~x>717Ok$=HTbQcqRn^qYfK#C-SBCqhMJ2=-mc%@>NV*@@sx9Pk
z$1J)sXN~ISQ>_}FYWJiSIVz1dt8QC6MJV^F)6`CteBKEyf*bi&rB-$d<@zkHS2>EL
zSjSvTqif0J+}#l?7aK0{%{ZZRaZy|7q?MUEo1#2bHO-_9o0BwEwoLPCI?C2N$?If>
z#)XVco<Y$Cpw&}*3^^PZrcb*PI%#!I64SvAiY>ETCV4LH3eH+~Qi#ixS4}%LQFmU5
zrjw`HhZBmt0xH|X7HzBd&5bf(JD31k<u%DOWyP_LY@SQEEelK8c6C#e!^4FOIeI#0
zo(?;zk!jNQuqDS_*K1YQ+D6`>NKKVVCpWU4^x7~{WtOkcVwK#Ysli%T54r_z?1)m>
zoY9k!YveWQ)TEm_QzqStyqM#<$upzu%oRzUv(c#%)3|PH9N7?d(@iD4erjsgEDkN-
znW{@RdFHH%T;woov6+-cYNpyuC6!4^(IKHi9-&&3JWAS<r-|H@TDw(Zv9!dp2rb?P
z*CJO=Rh_hCQ?%-&rPD5*Wot2;<f)zK>ses5Do0v%W~kUnon@Yrjs~mb3C@<;qU@qI
ztK-5gZ%>VxN}k<$GJ<Bu@_e<`(&`JIifO$(mS(CtD<opoQr)drduAD`UDV22mEtJ4
z<f4(UlG-h`Rh}xFWoDZiPRhArYNm3iZP}3-0atEJ+;B&ZPcSX-%G%kXGiStT9oTS@
z<%Pn-<h+Qmo4T7%%?_G6bEaO`Mju1HHW?|!B5TFegIw2AXBkct$>*>%*3eFyb~Ylo
zK4s?a;H<D)p1cpY^|Z%$3eFYy;C4jewnf2{Ik$~l{X!!GPO28TrAkKn`Yth<)imp5
zZg1eW$+;D}9osy!g5IS1u1=CTwe)gw>QWP-th-_t#V&cSj_lQFoiy#!*0V>1j82^C
z&`en}Y05ND?M4=bCJuG2TU*m6IXv7XxQJKUNvfXXLND)@vzK+Zty0$6thQD{<Lrzp
ztG#n4Dw@smos@CfG{|U{?+T6_v(Tk$CI#J8-Q;ySLN#Nf*#f0oYZp#7nWT2fcS+CI
zrm$||EGB8*shMe$TyA-8X_~FMQSI2d&Y5Ss*3O!`?WF1q-ZgHwJ=M0dT~p3osybuU
z&6UwPlYF9hZr9H-Nls|umgWdn*)q*LWztE5ixFlzk&~jlBU`&27e}hBnRX#?i<Gv?
zRJE<!7KiC>3SDDxsoBe=XVOW{lu6+;E;F4{UZP~vbvx|JO-1E&US5ujHkUiw!cu1E
zJ>ry1adHva6bM?DB*$@L=BaH<(<Vin6I>)IWn^~gc9V~o(9wE9l_^U-Q&vwcZcv%F
zGv)!O(5h9Q7LL+3MS(^P)1q^qY;@hGv31E7uT+sU7p0usJUkA~cHOF$q<L`BgR5?<
zdqTu`ds{TNc`JCTO^R4{>Qq*evq!MVZI7EfR6H)KOce4IT&gjlQ%GV)qS2zAt(znl
zMYbw+iFB#XSQK!}S4GLG-ovFcRb#2hS|wlQGcIo3mZ@e7eJ-W6-Ql>U;JR_A(Z(f*
zx^kn#ZW^3%=hk@UyX36%l){rPkCdAm4?Vi<xFb=zG&479Q6?W>(ULndPdtRKYn|Qp
znzgsX(5*?!TV>j$ld7=_MxI&+rd?xc)Gd=(<FLtl<Fd<HYnPpxbTl<*&9Zv4&Pge=
zRZf~^Y0m1B>dMmGrlOL`nRaulaahhYu|wNd8jH+rR(fzHXr1AP95FM2MJsitUGiKq
zVcDsyEKXz3ZI4tg3V8}nNI7OaajU7>V$Ycx=iCj8v?pvj?i6@bFL$%<wlj@QQQM?)
zI1>`4@|yCpO<i;8lt$LJAdg;^iBg_w^^;tTJuZ0)E}4|6;xT2Gk?SO*q?4&y!MTnL
zF3w6$GBZq@by5|yJ~A^qq2r|L8bL{wZ3hJ>c}H;ZoMcW)JE<~NWm;r}lF6iyj5S<m
zmz*>^tr4_ordrskrA*PH(vhZ(Dmlqg-kw{8Sf*+Q=bSmSY0VX(E0erJIGr5Ms%*L)
zSMM{;P%~wP(18i6>sZ=&Jkzd-NL)x(ndYhW;A9AAZXQT1b>&*OBMLbk$+;_T3S4nA
zxG8XKiCc2i#Hq@>+m>u|@|fhg#bZ*YSqhY)(zB|C%Tr~g*NrZvC6feJZCVxOsiLf;
z=&Q;ptjLn#mKq%DxI*ieF57}znj7n#qH`yCcB-76l;mk__Uz87Q>RXy<V;+-*sWI#
zbnJJhwv>0$VpoyCj2ky|Hu-?g6j$i%n5pJDDWzwE=cXx3RXlD7O<B?@t?4NpC=_;L
zMNUUVN5@Q~X)_k9Y4k7%xa3GonC7))+NnU$x;2l9Cca!jk(#DwSBK4<ncBwdS#NSu
zrNb>acV(+_*qI4ub*-nIO4_vPP?yG{Zjpllkt>zmW=%P<%%|HeL+#?0Y-!)6Mut7f
zA}5aNN-kKF%k7bCHs!<_V~LC<x;+=1okT@iH_qb7Rn6q_oRo4z1q3oVmrU?f_Hh9T
zsC9BK%9uDQbCO3(%SA;K@RGB7C8vySHx)d$O<cM;#n~li(aaSKS1emJJITpy!qli6
zu8ZAfO%&X+pm9sC*#v>4n~uza$|@&~l2kk<r>IO6Qt?XE2{ww(lIZL-xU^L}P;JJg
zsa_|AWuy)sOm?{)wzjaV>EOl<tzwrlStezwJW{#H$H#VuEwW{UH&@_B<)9fJx9X=P
zP03M8=xpgU%M{`eyRq%6@3xjRXLTZ`iKfil>bA^fV(zwSN4gD`97=ZE;@UXjw(b^B
zUS&l=&Y1!;oX##Wnl(e|=60r4X)>OkGt(yJMr+;LHpQ@8Qkz#~%ERI?v)NKT$r2YA
ziOssiZQ3m;DA+A^II}xc?ZRZ=B}ZoYs!jH+pOn(6tmM0NbL0KfzwGDV{rUI*lx4SL
zSKYpyyK&o1*KN0dJIFCG{<d*iwT;I+G}&0-+ruNrR+asn)U~Vexmb7Ts*4#@t~E!j
zxpGb0=&WxNXepejN!S+OBx9Ftr><@bTbRVQwJ~$$EZ<b0(<ZY{&777xEp^jvE~99V
zTOpZ&6Ry^)P0s3F>}Ha2%&;fRR0?zfv|G2d+v12DH*WF<<;;$p)$6(Bc5=ooGc&W9
z%R(0?EzSwMmAcJLOSiXok#BBVbaK+-5Vgxj)4Bt$PIe1fbLrORq)WN3o)O1RW*JU8
z<}K28(IZ!+?NUzLrR<<wpG&G+*W_;8rk%Um(2Gk%Br8=yCrVrF%B3T@YjPrvZtG=@
z&d&W8x;pFMwdn?K%odD`rXSQ}5@WiyczUBDvo@31n(44>b9q#c3ic#R9F>49?=tKT
z126LerB2Y=JLq~a!RagXn9Qd;xG}3tf9S)gJ3V6wlgi`=RUFd=Sec@y-&bVhoBp1a
ziF5jMeI{kTq|gnsvz<aWf9dF0q+~IDV;y6@d~T3*NZVC~Gb{5?KYsuD^IhbV<+eq)
zOuuf(Bv*gB0J<P+2XraaRVYo|;dRb?pHD5GSH8(hU{b(FX^jXl>0}nLQDtG0SwKt9
z!X!^8A&_Ltq-~dTK?}QDH{E6hFDBb|I#lXdy#Zv6T6m5ZV|3~cw~alj3~MIc(Phr@
zVvJe=JzfvxpgYl3y<o*D+a7|A+2jp5>h3C3?^W<=ftyZ>LS<`JrrpdxTfM&Y-QMfI
zpP!!xuOb7_A?Qox-i=st+mC5Niz>tZ_T5$@)>}Y(aLY5zE>BpZ$myVc_okvkd8Ux#
zr0B$kn;I+=_V{;xv{OIl(8K}p)Lyf@v2V*fSSF-QYfdm|VpLIJzQ<6g@T;`^%yeA?
zrX2q7d*6LpyI*S6_O)B%SBE-)55TLx<#vF9*=Yd-GqcAH28M%;3j-J!o7vb}13)7n
zpe0;Fpaoz|j*YVzggDv~ggDw-H-N8M6<}as&XfY}pfr(o0u83{Fx+wjNl6$mXGAkF
zfQ(_t<pwV<V_;drAF~0pRKbCjL4*OsV%A`2QfN}jS5ln9$O1Y{$YBN(TL2>?BclU1
zw*v!1fWU?;3=Av|rx+9z6e5y9D?tPV1XNf!8JG<i7&sXij3L*-IyeY0I5=o-VBo!a
z0JMP2gFz;{!I*(7hk=2Gg^__-hk?_9cdbsu#-wA5b9*zUPn2d9tGC;!!O+mq=*_^$
z6u{y%je(;_u!)PIsX<`@4=Y1L?uIM5Adi4TfPsO*6S7+sysH>Y%wiA&T|2A7mBA2|
z%fP@eK{J6tLBT_qL4dP?gXI7V1JlZFpk-|g3<?SzVQ05N&0!2(yWVh9K<U)5`m0)T
zbN9}*JQrKM_PVLc#JcnF^T5EX4MJ;EH<kR}_a^RT%`Wj>o-cOny>z~NVfB*z-V1Zy
zO@F1QU-I(W_w$zJLfLngT;Hi0_xJbdU7faZd#irfY3tWMyL)VJSmkrAcjkLC?|sfU
zP2ZEf_rd3|dmq<*Z$7)|o3u@Oy>g+e*q-N=$CG1DEV^vilU&7>;^Mlz=Sg<uz0ZBe
z9?cY#+Vh~eaEH?4N{f5`ZV4<6X{=Vym_Am#;$FS#^XcbVUnCnm#CQ(Pvuu#)iDa4l
z*z3c|>I2nHlR=knPVy8D4Ra0ikJPWe_kHd6NbBW(doS;j3YOFg&bYYf=vLeB^Xh-!
zWjmd_4Rn;&JWhRv`bC@ylQ<PRKx=Ec?q!~f{k*UAxZB4i@8_CsaJf^GFXf+KSnj-<
z<0^}@qKP0+Ux$*U%LImc`MiB1lMEOI{P(^uKe7D$e7l&67KiWWYkq!yeo|!;=x_$m
zS}ZW$x5?A?ef23Yd)2B{^$^CsO`cY@yRyG7+*o}+XvZz_UH<ON*0mjdH>n1EK;BFJ
z%h#i2a=FuMA;;*|+IqeFJiXZKyP8+{wyE#0JzKx$y=A$>j{+Hsf(8eR2J@Y4)A#(T
zzVL(n#jHzC-#x!7U-FIRU8`R*`PJT(tH&;U4&3`ar#QXxxkbIr&FY<DuVO5Z73mrF
zBuf^bYuSCT@W##_UbfAW&1^h!2iXi5c+w|Z#yqwZ+j-vNjbHhkGIa~X2F7O(cjgsX
z?zq!XP#N>^X?1RF-gB9~>24*7yLb7uyl|bD;jlmGrrfS6;r)#gg3T`Txx%}&Zz@cZ
zJ?8az&bpX2p<U~>JU%U{pSLOU0Qgee(9o37l&_P%?|ol&zjU%n1EZ&hkhi90mf>P4
z!;QVuZTI~C{_N-H`}<42FK1#@5#p4&wY@}IciRonAt&FSTW<OTN!xPfF){CJo;UZ)
zyr27c^>N>?mpc4FXXDMu*rb?p*@xHYkjf?>=CDZ)ZNix<9Lbi8Jr$fe_-8$~tO)Y2
zKI&QeVade3PdruTGhcpm`}v8ph1(wr?!H%N_xJn9&#$i@%|CYQcHG}z?zR0JrbADO
zTXsA9+po*H53Z`55mK1c;+^%$Yewd6eU-Vp7~Fm?yY<8LcJSVC&rkQe*WLKO&!~iT
z@@)ksuSo?HD_ABQUs7Q55;WLa!7|n0a@*+xAUzJpkK}i@ea<)gX*2Q5lRwrwFRM&G
zBrMo*B!T0HGmm-t@gp9yYtM!BuU9{QxL>+nP-T)w+`jKS&wkr_%slVTx|rR!k35&p
z?NZUNlox)b5hv1=sV?>f6h@w+p`jB)H-<tI+$K-;C6oA57Pigj$&}8uG25NHDdv~Q
zmx<q_qtjHry)cW;-3ZDPQ{UUZXT89{z<um_<-Lzr1dg9vb}@yO$4+;C1{W(+yMaW2
zV$t<@F3%6_LhL5LcdxT?virV!_byMB>4|(yvi0GwpWV)R+xLz==X*)@%%G6ToF<d=
z%3iRY&RrmFGAUH$r0!&g1Lkvg@lLz#xY<)R$Y;`BPbZI-lar8DvLx@A_N8UbP3_sL
zdOA}!9Oltz;!pselBdAq;3D9tr&{jeU8|_w?#SugCXwhOFu_yh!+|Ebk2>`RO&p3G
z#uc+P;#!0~P1QiBY~=7y)7lz3JrPp6MXOBU>1^UMW9#ia%-eaWxAV}0@_wP+XD4l+
zty(UmqFSt`qU_Q#+ij1hlFB5{Ew|78uCD$LT9Ne?q8~!0r%XxR$uTJ^aT(}*z*(Ww
zUL4%>_Cn63`Ze1Vg?xQXZqMDtkYAjy3OxysMZl4{&9lsV=e}n@%Wj?UwC%jGZIV+~
zu9H+@K4|F`DBve~zEo*QRo(S=+pV|Tj!!q+oW0BSjKwXLO`a@5p6d7PzL%GKOqvw;
zE^%LB!OKlAw>voVII;*RGzmDezI%4NE`N4zN9Tij3*YI!ySVSnFE3%;sp9FWUv6;U
zVn@l%lG_V(PbztNUe}p*IC}0b?jw_qiX^sxb+ZRm=y>r8Hypb2_Cn6KTil@2=607&
zR8@I>T5ZF%=Xp&ZRn~6n)p+vG(=A~ef;-7mD)8i;NuDl~RSsxuw+3a*rjIHilRUL^
z7kgP+PYRr&yYu#fJ)U}Zmw0;W-icRBet3JzG~T0K8izR)99a~a_?Em=X+N^eQ*iQu
zf;&q#1m|wZQ<$E2NoC30a`BThev~~`Z7z(?l?pt$Y5Hv|CX@PYw@emK-l-}%?atc^
zaVk@{U0f<N$x|6*m8Zs}lo<#&Ae=BW_uO69N1kPGmApLfPCD~&Ets3sWpIc?z>!0t
zsa$9?uUO}S#O~sNqT3l7k33Z-#qRc)G^spgvqg6CcE^fIVYl6;6qTziHo85%&zeb8
zg;nf%UUTZU3vnuwJXLeIWV)*tc^N}I3iJ2O={i<SM)hI0-EM=9xVxUId^`7^U2tCS
zc9lt<%DE@ig(8x;I~OOVsIeIw&YAS^k<GHZ(s`a1+x2#P%H7WU_`Mty_{Q5j_iirY
z-7(2WBJnUJq8M8~9A**7nPZmc@2Mg!e4vR#p>umlr>5fEO}=kuPslwosnmK`X_f7o
z_S}u<>m9cXc^+yqczB3!$sQk`#8x2zKZ(RP%a<=znv*I799aZc-o3o~;@cGK+`cN1
zHMe)UOqu9+Q|+6!huI@fgT!_|0f#0IM;0#O!#o0xn+lF*+Nw;*@n_;tXi~d-No7e_
z*-7(_Q6O7--rilC87*U-xN$v*+c>G<aC=gH#=;hXMIAB<a|{k7_EuGSD%_X{YH7KZ
zy}Pz$ZJ+Fh8`l@y?o|25P{Duo0h^sX-(A;<wojvWZrziUFD-RXx8kbiQoZ7|_jU8r
z{lnMC?Xfm{U;TQw=C=>b%nutqc|4DKswzx;#L3Rk@O{H!9#yt3jRJWFg(fcbl`Oxy
zIFuUeop}t7$}PUP?RM^_3QpB2zb<8bU|;>d@W>0l_HvoROAPRJPt5Exel0J`3y;ex
zuq;vJVsubd<Otxtp~{>CA{99TxEM7#oEic+J)A_C8bI2_!2&S|)ppT-%cK1^g-6^?
zj$RwM_IiALe7(H9UGedLIn5;jwT_-#p36Md8x{z@(pc1`(Ac8Lam;Y8m61V<qGV{O
zgU#pjW}iOqeP8o@9{Rcp2bBg-9+fsB2bK1HPfyQzt{3y%b|Y8NkF%bc3!^=GLv9Cp
zxh+ju7-HcWGPU+;P{`V)O4|-3m}&>@sbA@Qz<TT5sdsNaTOOU9yT$G7+K-DtOP5wY
z%`IR%Al0E9x%T||`MclGeQxu9Ud{Pk&li1?`xYk@n-YGHA<4(iW#$Aa1wW&Y?`wP~
zhKAe}zjXRSOZsBT<x8iueEIVAL2ycZWQDxm*D1E|^}Z@{c%h!7q{-n_9{@RL9CVHn
zXx9g5%|qNlhufgTo<K)J#U0e-aBAEJS|k8pQ6n&gsUfK3<)zo_cI`VDT9p{Imu2xS
zE$v&Xl8lN|rYsAZ8f?@R>eChKr=_$`Gs3~)v%snduBPRC_`Sj>tXRjQx6Dy(X%c4y
zPf*a@(0UG@D=jM?O??{PH_yVRWaXuDuadc!JW3{&d&y7!R2jhfb^GN#8g`soo=X^=
zCLOG45eRe<a5&5-*pqC%d#1z(-OzNVRSc_dpFVG1{e0R>#H?~_1GkWa3W$U(dQp78
zdTQ~Ur|0u)>+Xl|zI$U=wew;2_CxiLC3`My)!TAwy^g+gSG0?&PVT+5&(Gh!-(K@v
zc|!NoJ>rcYzqiHl-AxJl&BVyU#Iec0^5^GEey5+@6b<#ASgW&_!>!72R#l{jzrTMR
ztC{Q9>5ZS>7d@|j`SRtnFQDZ;tsOU=j!XiPf}2`9Rk;N>wJ4`@9aZU_1nOkgw@m7@
zJZJH^-SYSy-hH+I>gMO4KfmL)o%5sn-sZ=TJvz0>?b_Mf+S|gc6F%MPT)~{;yLHx`
zzm-3KKd(G*{bZl@!73FFyAP)id9P(=?%<f*Kf&O3)}Np6J+1X8r-X)@xqjL7MN#tQ
z%a<>lJds@ZeeZ)w?R%fzTcTJGI@=4BFsi}Frd5L%sX^EdpcOH&r6eFWB#n6A0A)P0
zqaaNREG>%M3<_XP;DsdIUsa|>e*fiJy=0otQQZ}6{}|Rk|M;!enqhrGUG%4IKUVG9
zyyxQ9Yb&<BUVr(^k7ZYR{0$EK+Aa9i60l@e%A^V|M!Ch8FJHdclgQy@*pu$p)1%1Y
z78)AB8uv_rH+I>q+-<iqmmR=Z6ynLF(%{M8w=+8Y-E=-lCS}B0CMK^na1s9LFCCc#
zcwJlqg+O<hy12Nk4w}9&nbC6k`-zO~)Avte)SfOsnNe=~K1n9+=?4OtjhMVHO*YI>
znqD)VS#)|p3Zq#4?66xm>+aRv@4x;2&Gzf}_t*Wd`hMH`*Yp!Ljvud!d3$c_-P6Ud
zu*YI)$E={6+f&b+|N7V1ZAy_~&Gx1bb}E7or#Ekp6qS%?;_pzXNT^}h`qqKfGug{h
zWs=(_{iV|va-4TF_V?E0eEIVAfn_H^hoHs2)~LQ$ecjh&clNejne|I$j`L1uH#{<(
z-B4NsG-v^1#fTdgs`G-ARLi6mi%AcjuUc31qx4*KP#Sk_z2C&xtbliKZy&JU`f%y}
zH(x$2n>IODx~i+H%Y2329L6o3OMKVv>&q_x{Q3EP>vNU&6~#|i=({ws@Tb@as>!qP
zD7}zV$Zu5rsdjnSNfG4KHSLR{<cnjOFI5$7ZEY(=Zi-*J$9{V6^mPtQF7@CQd?MhX
ziU~|k0<8_guRL|9o!|cW`~Lm+-+$AezkK%f=YRjtkGsEoegFFP<$w3Z-7ouDS^n+&
z&+@u@{(j4I#dDrp9$-2$VFM#*(Giq{bS7k;TNWbrPAM@8vGi_TyY1RGPUs@HLmu@k
z6ApPKsxWy(Fx&vA80Hj%NsKDeQMWl2U%k`K-L`exOBL&K*R_*fK}%esqi*MBr(6V~
z+)ExT6F3!+3i$|zjVcB?;PQRf_6^>e*JKqhonX|N^7s9o*-F2npWL$n#a2A%sIb|&
z6GK56FO)kNoB>0FQ^FU31{6f<tBU8`p7Xr))U0h!eNWG3U@f|KCC~ePRnT4!POaKk
zI@7oqHq4thuSKm#QR3*k^zvd6u~i#SwK;~q3lS?Xd3pEl<>jDru?~TU7aS%sbb^K)
zYCdMY&UmSKdDm^f&ATE>rtk7({60Nr{a%g_B1(IG?Y?rIW@T_VA`-~Lp-|t_lPvf0
z&M}+r(1^tFoK@eo_q?AMi{wkNr=1u;>$e&_8FJe5{fg(_d2YQf<mz@ywb$t-lSFDC
zoMrvG^?UZa$w_jrYmI)+n<UWl<%^<8BF8cPV(Z;AzJ;yYoan5u>brhwy0ov!4Y1*C
z*S6h`y3MIjf9u-qOvMDIOeTj3&n=6do-5vdUTnSSo-EnBDidB>uU#H#y<}qd-lsR)
z^&!spWSd{rs@l{b(8Q(D#3FDJ>U{3d$OEglg;wwReD>bYr@K&=SE)33ax;jjwDE%1
zv3~ve=IgI&+qpac&seZ#a=qr7v$|8H8Jc|c4=`|W+3w(pVPIgI0lK_F%6@NvR`^MU
zs|;GEiEb`|4h)&o7I8}~U324<lnw(A_;fl3<_7{ln%vH)pZ4C|pt6K7g29A=f$fUF
zWbL*l*?Tt+K43k!KEFk&wyNOPj0EY66DD!YV_F)(>>$K4DWrixsyehj)K>jf0|U#v
zl`dCS`lvAo2L(+@cD};EHEYsR$rTy=0YB@epZ+@UThZplOVi!0o-f}!XV%jq(^F5f
zr=Ga3J#n3X-gCe65J|6deN)$kE5}@e$@xv4E30jF#`?^giB7J$cg~#@Q3;sn<jN_!
zb?>>k^PZ-=d!6g6pSr7L&5J!SIq6K%jY=(Dw=ZqJrtvcJ;-$@NK52L?Rh2eV>(bI#
zaa3g6*3@kx!6E^RT3oj`AJ;y)UXH;ew>TVx`HJ?;`uKp^?Ye2PcY4HYZ8&y)I%nOi
z2kgDlF;~w@$6URc6FU`(J8$OH!#QBVv(hoQt`@tl*ZCN0dVpWbZ0G7(Agp_~*zJ01
z&cd5Hv0XP~ryT|1TV6t+1-9ixi=FMbW!Aem<JQIArPIuMw;j8fam#c~uC(idqsv;m
z#ny_=h`42%Wx6rUtT!jLYh#$!v6E}NMa3A_iYBee>Z;F@YFoG>>)4UaSy@U4q?5LU
zgs#$R;90mjapmk(oteJAK022!W^BxMxwP5aWZR7^QM#gQB9|`q-Kum^tYeE?$69GG
zsmW1`0|S$IGq!{syQQ&WBiokT#hxobbVx*#mX70EQMX%W7q@kRm=YJ)N|`Qp+mdn1
zB-+(=Mvg!|qd*de8INESgAzw`)Y6=QWlO_SQ$=Uo+-$BZ))S>G*6q4zqxF<WBBxTh
zQjKQ%EDO8M6?>}Clq>b_#_fK6iau-GUbCrA-EcEHQ+2J9Xs$|*?@DR6TbpxKmo}$N
z$vK&$ovNH^rg6jV!0O1*ExFmAtMjZEy}jEx=Sr59%c-3!>d(E{tzHrvd$BA8v~Z}s
zBzCGS$E<g~MLVUQ7U{+G7TvuYnUo#!@Yao8cQ5Z=y}LCpy(D(3wBPGwVc*_GivwL(
z+zyFW>-FjK%IS_aSu`u^rb)Kv;*?F>&Muw8?WN+=<m}lgsphS5R3mM&Yv|gXs2-2p
z#csM=LOYHu>*|#buJ@MOxL9gycg9taz_c|QNt->gZfAR`M0+N9WSUJjyJU7rS7Rc_
zrKE^yN!!xAuJvw_n6%L)JL9(NB&RN^H8U1XF%C=R_4VWm2xeWXsIn<#tFg+KMXp<$
zB27Ifr<~lHGgCKb>Wn2mp1KO&IVoG3b9WidPBj&aj93$<aVjUcKGiJjl+m`NX%TBz
zYp04NEDO^(C6RL_HSN?{FQqJz)ZEoZo3)KLx&_Yka#<F(m^D{8aEjzsu^Ed~O~tyD
zbPau1oHFWJDmG(rpxc$;EFEE{S=~N?z8kkMnk^E{rE#k(*VSy%j776^rv#^pq(8~I
zxk&ip(kVe_b63tToSECc)S&(`M@O$oa>VgvR~84H_maHK?scO&t72-biqxVTS?jh=
zTe5MkMqtZHlT)55lQex*{N8qM=gx^PHC?&QK!Zutt!vRD&m}INVwcsm)@|5%#W1lr
zDR*m_MBdD07tLBXW_!(adKL9_(Xn)=ZC88Nm`%HN=V8%{uuHeZB17-qHdYF$o}S{v
zq!hW2M>^GLw#P}cWx<(}YB!G92^XGt)-qv|^JEAuQDo%i*(sfPpoLTA!qrUOsMaXK
z@Qj-}TPH_pU0~dH+nZTp#U|H{Az`Pz7z|sNGDsX?TODV;vFyzB`#wx+_0i?s;i=kd
z5B7vaD&4ppxMkawv&tG-BBun+(h5@-U9&McyYX52QsH2yOOrHa%@Uh&Q(>FR4d0m=
zIkTgqlg?ZTylyxvsmoMk#@ej`VX@JMZrh~YZmc>ko3!z+na-Ir&je>})ND6fcDuvb
z>ui43>hRp$Co31OY`*1Y7#Jv+p|r6+Z+6nwZEpfjG9;L7Wet0sJ1ID1b)LcIq{L)J
zgI%pjvvXagcSN>aY&+MxG0W^|;5Myp>Ex^_%a-YCdbnD)*$MC2ZgX5_ZH(ltt(;pY
z$@1lh-CEhTEM?N!xk=lu+}60UW{tJkhdrScm0GWl&ssP4M)9_;XVb&hws_~<naz?d
zyVxZ5>4SSSXIy%^hHs;<Z$v(K!PMq+FA8oHH0RtYxw$br?7m>=2i-|G)=bt|aV0Bv
z*~P3yYa6C-OlC5z=l}C=l4q8vv;(MtGs$a7P8Nvasg{__)eD(uP?@;qTDIx5h?Q#G
z2GJ}hTW9Nt-MXzfEoIA6FV;pT6<>~Np~jBOawU8eO>|tBY@HhV{WhEIhQu#Frz{Oy
zbv0_rL_s!=gAyGbO$IJ52}dM4n%Q_<TpT5olnj!11k;+7l-U%HNGP);DJgLr6clV0
zNazt1lrUs*N$BV};^N}iWZ<Txq{JiGWGE;IlI!T`Xl6<1ff>Qk(b3}wHCma)#f=BX
zK~}^wT~LluLinJBl9G~=vi|?a5|9~1^VsPZ<QYY#-%n-YoPIKuNghOqv7G2}5uBWu
zAv~Q^fl+HZj~}B5<B7?M8It_%uxUs0!W+j7Cr_74WfGU#;l|O?BhjR!gm56lA$-#f
ztC@uB-&sR#Gu;3AKV<becnLa$(EoV1y!5hJkC8f$k-D4Y%q@u%Es&6v!I`s*c{(q)
zrR6|ar`BezjxsoE7MkrQDcmNp?9|$f!y-2lCxR5VNzUAG*w{=WE$uMRncLUbfx+~|
zB}}Rw-|yGz+kASxZoQUw?&j1jEeZib*JF%sdEDV*ihA7^?cv1AsPna@v!_9|Y)9&r
zi91ACw%#@a3+pb8Jy{xE@%h~DC9k%9oE-Q?#^NG$<`v|x^m#wu?D>3p-L5?gb+;bY
zU82a;FzwdEX_o{V9lSFml_eRxZi2}zw{p!VFZ?2ByTADUy&Gw17u#GOwz<4G(4vsH
zTV&hB6OR_C&bzU6OP{-_6L+SH^2DRtAUsB$zu#}4K5w)0&fBNaRnspjFe;et`F?x%
zx?Qin-?#k+*1@QmsiMdsbr<T7cSm)X6j`j`tYmW9|91Po^gn0$j|6|59v{M_RIjq6
zq18G^B~w86`|eGaYR7InRQ-Ox@7w;2=Ir{~@As?M-*%C@e^nuK+YOa{mR}}$T$Cy0
zjLcGIx#d)!In$Z9p*H9B6^mSj?{+UXxg9@O`}cOv{d@oGtFyl?cAYe3|DL>C|3X7U
z&3O#oy?*$7-n)C-?!JBfzIyYse)aTc_n+O2s84g#nC0R4Y{CTIB@;OQO22%6YyaKq
z_tkcDw^rq@nRE*@Whu5gH%a1_m}YL$)!a2vYqvJ&hTS^$zWT_#_vJmg-}j!mtbEBg
zTj1EOW!l+X_m|C%l+N9DJ1=|N>`3WZZ<k$j`vNj0YVFqk1xahS)xCbtpwh+n_L9f%
z^*b0<V(ZVhUc2-6_PqxxL2v#(y?gtPLh@cq7EhJ_LKeI4d%EHt=^ya?e){#-lnJ_K
zw@$JM{8Q?S>5uO}*tcQIKYPB|%MClld_&9Q7y`eF&5y6(<1wpfZ}pJhJM}lmPv(T*
zyEpOK{pxc5oV)FI?t_WjZs+{{epN=VIi-F5-goC`*_{6I$KL1gBM00235xqo?ARAf
z+;-b>+8rKeWd{ZZCguwsKh?YoOnLm+6ek||J-=-IoLcMchrFL0nawgeHu}r=t@WkT
zrZ)yLDb;`9<N1)Q?1slB?%Gl@?{lShC!RDre0+OIk<G*FWqi&#618uyL@I;Dc{lvv
zXk&I3{CIxJB)5*oC%jGvO65pus<iZRo>(!#jQ_Q<M&c&#r9KAxwq;+j$c?*ubI$GL
z+<E6qBGnE~_POSf-d6Fm>h~Mvx31dv?JIv~f7=}WyZ-m--OGP4@U45mz`S~g{=R>o
z<JbOvZ}<ECy`75>@4oPvPrUlx+voBIAKpLrj9s#Sw#q!0>c-2pUnWN#G2FJY>(-&|
zFPB|&1I;~vBkbAk%&imms%+c9AhtR;aYgQ`zD=&r?)HVh^HDV5eYN)LB!}0&+cr6}
z81nlrNig%65mR5$ZCbSN-S!O(1u_;4Vz)C@w{|4w28(X(;$C)BlBwBs-EB~6Kus36
zb6>)gwdT#rO##Kx&ULqPQy@v_l6N)(W7f87@_KV}SM{4+mQCqCsrrn$%rbu0<=pjm
zW;h?1+29|Vw`LOSvfK5M3QZD|?Y1+Ug?gNL<-Kfq0jKkY;7s+3$(9-wd<tI{B_GME
zJh6jQr)b|h_xrV1zaRa>D6Hf#{r&uM`#qO)4Q6{NDlRv>%(<mWNGi9*BlGN*LnRXr
zn&(Y$a`ty+-SXO1CA1_U+iy#d1H&YJy}gSXmD*lk?_;>G<*B$S$J=mSeaIx|lpE8M
zV^*p(>uv$DbC;>d&ER%b2~7!zG20RZGUjl$tBT2OjtQ49Iu=Yk@Zj!_#apIFN_(pK
zT#q%|WH!lT=DJ<EDY+^Wjblr0ow((x6qUPVlGL&zo28z5s+jq9rkS3a<Y9Ch#BRHl
zRQj@EOOR`L){AY~t}3DRW$U`rwlI2vUAMJFAhLYD4CA>JkVC+ZYCE}6=h)65Pqyex
zm9~=`Zu|J{HDFd<vI}HQ+OC&dCvKVKa<=qxwsNLQ=d9PuuDM<E6q=Z7)~T{)>EX1}
zj7eUnV$9ORI#rfL`Y!U+R#0Uwc-yv;WwlOrUNq+<&ajC3Yj?H@t1xh?i0kb+%_6w#
z>+7408)hm@%`{wlJaChv)}`d=zQrjGj4Dk}ug~&P3AkJJO(9FuQpM|ZSkaB3ERU(v
z);!&?<jO=%flg1QFo!JW$2S=_OjVeg+M9bi(a2HjwAAfshoJgrCN!DH?X6a@zpwC5
zK;DRV!9Ush`ooSX_BNOPTzs<k#gf0zPJVvBE;=~7syo*8^YPP_cPrn!-nnPJ!}9sr
z@YoEUcB9*UPwwrn<Ij7yKYraG79o}c3<?ueI2#<n<0$&uj^^*Hyz}|_`rX@{<?Rxt
z=604_E5E)SoIAV9?Mc7Lv9lMBDR9<bVRGPP|CQv)c3b-8#`+ojA5L?sM04F(%xlJ-
zbaC1lLrIYoALAUKG&eKeT1_P_kB;uu&F-M#HrMMSucjxx*4{czwKds8wKY+9*0!tJ
zT-Q{Wh=~TLs$JbAb+*w}s_WvK8JBKG&f2u*vRl$dpGz~7R$bB+UFn@+bWk)jXxo`E
zP7Rq{>5_sQPn)IJPN_dKW3sZ<nujxuqFp){s$B9&ysfip)z#Gv$JKHsPU5=Qdve>6
zE2q=6L$5JzX|Z%v_j0^6QS^yO$Lg;k6GgLxrmkpN8yKn^v@j|tDk#!XEx>cBLK2J0
z^v@18=RYarZn<RN|MJi8U-9Yls`8`1zqR`N`}_Xd>>A_Tid))i0~o5O)=ye-n8)b)
z&TUuby%XHg&|`39?%ise&zD6d7rtFG<#CJPwqs_u944qRfHrBd2!nQ33H|R{{Mw=G
zdyv=ky&-G88n*g|hK8<WTrerq+tq27Q}7Z;zfPBg6{0IWj6?%|cLr=ySgC%gWogyT
zO`<EzJSMi}blg@m%k96PW^8<ezn)i`!C6T-&BQFT%}l}Y;qEjOgVRZ~lX%*4yUuQ0
zawbiUvnOREPfupcY-x^JTRW9>O)||c9L|Z{xOuX-cd|f-@649X5^_1Yn>})8`2+-n
z-B_6w*qOV@>~fAoch1^vw_GNl<Z^vc{q*(TvaiqA|9IDs^?Kp?S*#Ie6E81*ecQTT
z?$%3{Do>xB+Z&I|88UePThhYh@oE1}*9Ok#cej0Z6=P7{yl;MHY|ZEMxdFSE+Z?Ho
zU*M)*-7qn!n?d-zb#(3b+V>SsY!bQaOWK^-OWKT2y4*}`Q!$+N`uV)-tma+CXU=Dy
zpQX|=VUnjsV#C8W<~9jFPnAg$3E+lV!;^aO?71RB-1>I|XU)Wj%?3P4zDj?;-@AVE
z`MlYO-uVe~_Li4dPmmKgVEgQmqrogK<#g|R)wjy$%T}A@ZZDXhdv)J=o8P;4fkd><
znknb*&fU(`2WsGbVKrJE)xZKG8GRafwN}DT);FKcpg+AZnn_jQ!;ga7uM-ZxOQ_ve
zyX?n&>+Q>;nd}(rAF5sYzV3JKPOkFO*SQZ|5^j0qTHMav2D<at6LiDV?M#*1dAB1t
z3j~)+OgZ~D`{wg&tk2J_`MKaMbCPkc>eX*sZ(ojicXNB`+S}Pn4S9?Etdg$XICeW(
zI=7GIfC4DvGB_&uFmcwcGX4F1-p|x`%)3{}ZaJ@);bpi*@Ab9%)3-BCtFzZ`yQ#9w
z?2@Nx*{Kf)yc?|r%5!7ivEH6Nsk{A*cZT3nDaX58%hy&VXKvkg?XF?=C37{Ncu>Cs
zhM9A>-Og{w)i|=;{MPl&Ru1o8hSeNNV@@*mU07PXwtVicx3kNm?$4`yeEMeP^SyVU
zzJ1;V8lP-%tOu=iVrX)h!6NkkF?dhk+%y691uoa0{$OB)pWP3-GL@P8`vOr0dAFvm
z5m!S_L<9xuT)3v~b7IBKO$@By1!fG)57`_e1vB>4PJV7u&2VyWa~DSg14B-Y`h4Lt
z(d;E39(-Y*p%S;}`Oc{pXFWI-RXJAvTVCI*HI*TQaru&ysvZoCTGdxWZmmdRU{qh_
zHA{0v=EMbDo}RqH&R2LDR<6`CS@~<>0_LxO-e3Ph^za*KyiMlyJY@BAWACha@$Fs7
zoA26IY4v!=;=sdo`o^1FIY9$;J|2rpH&>s5j@_wxx}ANuvuyA2s_U5=H#eHPa%luQ
zb&0K+ZIo-K*2=r};dAZFaTSb<vuEvGoIPtt@zj^=Z5S?YJsX39>$jfTo36cV2jjEe
zby?^bO_SxRFW2WWBp1&z+Zn#*X~}g4n~Ph|W`~<ZeVrHXTflr4I-CckuVh`^cHJay
z^Qo8X7%F?uhK9;zOgl0=Iyfsg*LSV7+r=%pTaq(V>w6bRX?w1fxMkL5)+?FTEH+Eb
ztat0ur3sU6OK#<j);3$XB1@`m?MlP|9dB<=Xz!w}(rOn26L_~>nRR1hU;@|0FfFqU
zj11DbY8M5&vt6T(U0rl^(a~;a%_*m{a;IF$Rtubxr4yx-6R~K~u}f_;S1mhmW9_P(
z*`izPeOH6V;+CxK-4YVf9J$rEIceL<O}WmQv$Q5{GrI^H#JjOI)8N=`>1Dy%!J1P}
zr5g2m@AOmjSr(|3YP40Vd#9gTPSCsHj-Z^icg0RUxfs3k?u8rTIWL$ZecPr59Ge!{
zmg;sgh<BxQsM{5dEQtk+rFyqrx@539a*EEiRGzE#JXeD=r>+z>nw=BOmD4(P)3((q
zI!UX}az}2QadBl>R_jbQ3HOX!My67|Zi@rAq?g1_6_x6B$(7Dsaqh)#Ewk-~Vn>2a
zZh6gIc41pfXpU#jv@5zxf(=%sxo(-bRp^%Pgl(%Po6Zt7j%>Q6DZ4t^bxTN2Sa-%Y
z5DH8Y-L$dZEjTsTEjX3y)=WoV*J%Mp-3n``b{Wl@vBp#^M4Hi6GIEN>Vr`?Xi=#{z
zhZ%ZBtd&kVrE%)aLRaIkD=x=QU2(aRnwqw)*)!s1VDE~x(h|42E=Fm)W~>&|oVGa2
zaI5IztgF3lw>4L6IVy52`KHgJ8;fpEIi=eLg|1@t7hTt!N)<aQc4nDNVAhs^TU|Me
z8Wy$RoXwKKaoo$SQe~3EGSRHCjoVCEGCF#5b020pi}6T>i3OF3R9zQ3?ltkK4qtax
zu8~`br+RvZjKc-XjZ1SkZuZr@73SP}H727gE4X`VSVr*X;+8w6N8SkZGtF8VdOIua
z)7+I?Zq2sTtiRQ@H#;Tcpxe=}tIHWr=W0g=E;@GA=jMzJR~;K-a?Z|vm1;IwbIK)^
zOPW(|`78_enCu}@t9IM7Jz~wJtfNUz8@FuMU7T?yL`_U<LyKESvV+35!+f))Ox<pE
zyNY!%ur{noHQJ_awrbU}e5qB@fgvy6Y&(0o;+|PrVU|){mhO`JkVi+ObRxSq<%asn
z@g+tE&6vLG_U)8O7dIJfYw~q%PMaOIN;hNiww+tDx5jpDTkDl_F+yEz<%vZ*!ZcGC
z`b2p2Xls2DwPkNgTot$KcFwh4R+Du}$9i0IcdlBVJMl>3p;z6!UOTo$O<f&UETt>a
zE$te(O($16>Bhz_AxRgLr9;JZB_}I!baDpFQt^0T{KB}ASLDWKy$ib{)?HM0Z*P2f
zyk9ORZO%zOgH;=Kq}Im9T<mc(OwQC*?Od{d;>P`=T{k1vglUU*WJazQ^EK2K$vSFw
z<JPt5hRc|oeC_-0I;>cBfq_9~p@T7(2(!VYR)#Yg0jybJi@mno&VRb@#H3Z8vy6SW
zTvT?}&bghdwdu$T2Bs~}9EUiZIGk=RWnlQ5yE<!WcGmh=|4vMwmBJ*Y03K>$LmqcR
z;jm2iN@Y^CWJ&1gIM@Li-(llH3}itDc{(}_5{|gINEkvDfka{BRRYsLPGVGIc8fnY
z{h~ahEF*ZdNn`q{R3=fy6CkVMgJO`uDi`Eou;~X<nM9`d`!jJv^ob~+=;-L^Xon9$
z#ele-Wrn?XKnxJ>**#hCv+VTxR3<Lro@6n^z|-!D5=u&j)9d6JCA5G1ufG632*e4r
z?0i{TW;2J|DFKj(=FC|MhrsIuAR>Cx9nzR~)|;C>1E2L;Y4bi2H2WKzyEaL1)9mc%
z+^uVzj91_L`Si~8(Cvlld%>eZz3(}h9H#HS7kjcaykLR~r+sXB>7CL7kF<<qEy}58
zx2`ElYtEcyxR6to!&AcvvgSQ}UU6O;Y-zv5`E_63O>Vol_g%T_;rzJoPS%qiZr=+s
zFS=ZaW$xC>_oa8$L$?<yc)o`Pg<(&!Ekprl_1>3v)p>WX@>;Uruz9}y{KLP0{O_3l
z&y-nedV2;FU;XoQ?{4L8d-rDTv!w643oAL(*L+{<Ay&y*aYRv9RLC}EL)DS<yWi#Q
zzIo|S@qXFnkMs2>S8L7J{hs#y^t;btw{137ofgwnnJ&cIz^Pv$b##XP=XbMMihLOu
z7?dYv2%a=yT5{WW^Uc20$NFiuGhfGTdFB`C@$1y8T+f=P(q7`VoYlWRKYo7y{Mt{`
z_x@rMR}=j@d6xD97oK-7*qxXAy<n(JQ`!6Sef2%h)O=&{J$Al-?e6dQPMQAU50iAg
zYi-KHZM(%zmVM;=wT(&k^sJoU_nzMStorqo_nnhf*N-3Fc|YpOpIz@yF84AI4V!0k
zO<zvT$LX@`i^|!LCMIlex7p~aawf=APlcN`cVo&V{|cMQ3H|$CE^t@5z`(#{sn#en
z*+I*<f&C<Rz*ZCeNk26?j?EH|xUlzq+t0sWm#lE!mg%-KXUWvvn%476ALW*(D#mX1
zGWAYtbPLa!<gsOO>FrD{-B}@a&+nG->xm_(G^VNaxFzU#c$eS1A75g<efKWL!_&Jm
zndIwV-eus|IWm2(?fdGJI^c*1pP+nw?<&=EJ5xQxC$#7@C~`zGOz5monZCBBCVKAM
zqPp1fr`L09YaZUccl)i?@0I%{zt_yZDZTgb&6-4qdlpxlE=!&Lbo6x!#Ct58a&M(+
zsvUZk`1GyAY_<vi-up6Hsx>e$2%a?IcrweBF(}8*p*O0f^tAxXBn<`z1|d%ngVl4N
zLvK{;r;D~y7j5kVoPCX_@B9=qy<9Io<<|S9)1_W8$%gLR6mUDXJ7sr8!{zGf$3Ne<
z<uHGGs$8b<&ab{NlUyfx-r+vjB=q!1_xbAV^hx3^0=!#qZ1e8LBs^7mW3tyB-4wg`
z-udk5eCEt*_4gDH`x?Ib<a9RTnuX(jy}+F0E{&Z<77uyX#mslSxP14yoNkqgvp1$p
z@_WD#$78@Fz%a4%-Tk;P=J&oYpQUvBbyvo`+rICD=YBnE;-9<hd)4i=U|MhP)y%vO
zhVSa<RpT@lG1#8`d@{T%qd|HTivxT0&f<5KDwEcWT&&Pky9k!pBl6<slhsE};<(=j
z1?jU|FSmO>$x}5NVy5P~U(@xonIw6N_w87wJ258x@x`;5(>G=_iKchHdAR69@Z#qX
z!=Pq~-&?XIj;q|S_PolZ&_}ZrnD5NDnOd<7;+k#ivvcm;RB&M^-#r~<iPlG7@us<!
zP*=P>KhJAVu<L_;UsaVp1n(*bsZfnRI^8aZNxWXJFWV<t>2=Q^|8(Bm35&KqS$ouU
zo73TY>s9kK*KQJ%``R;Y+D&f$sy&lDqq{PiE>8wKi*-3947lGru{h?-o}OQPQe|qz
zvdIUW!LCBkPEJvt4-`Lsx0&P_-j(^DwaI^;*WS$Kd&D^HDz&~Yn^*rK;;ydx9x=`$
z|D8`JdF{<y#O)UY4mHQj(_phY^!IWI%G>?B&++m7sa5}X&fih@@8eVL+)uyu*;$-&
z)Oq7s%05vxSn%YUh<PfzXZf7*@it9RvM4+*>7lbZbk%|-ie8RWE=@V*Y#6z6+p3k`
zZidg&9<)j;a+w`VOG~RyOG|@tokVhb&YU@Wkju<TB&S8=CP&~Vfd$rLW}gks<x4Jk
zH)(8@SlJn<GCMQr?zWd|ZcFk!P5OLQjtYB$r+Z+%Ee5mO^$V1mKdlgzf3W7XSSW9(
zk=x2J9aXoi6)TP`ouIM(Nm|ZLPeH-bf{Yg(9V_dVv^;k0FewEMtt5MOPhLASDZ)F;
zXqz{uNzX(bZ_|Yl({d8Kq!va8XKu-n_PVj`=vFgBsSIB2RPUgy#bI8qTZ85V-Es&!
zl@uLzDrJ(&jiZY;Md^xp=59BT4$M8JR4l44sVDF*MpW~PN6b>rBVFnZf{uS1x_CT8
z4OP0C7S(61)Ht%V(>qWxOGRfX=ahx^Lgy>j{Jo&#(3oVH_Wn`k&-pVwzMYG?Bk%WK
zbILOP$#&6s?`}RdnmU8SSU@3iO1n&<+)dvrHmB2GdIeq+S)wU-)8Xn$&NZi_a+e*v
z(2}!|<EE3~CeWeiEy}5os_+aHD1s`$deC+)j+^l(v_Cny{t)%lKM-=EMTbpk!HEe;
zuEL^PF%!IY28gyQlm)5C1hrgR!2UsG$^lKmx+7DA-)H9r_U0sqBxhZj6sZz9bLPw$
zUYP;vcbtL`y0;i=dNyqgNlcp2CJ|xK6EZO&<OAQTWl9lh!kj)Pio8mPj6HRH16Q!t
zcQ#xN3hbE9Bazs)XojyU*N2HNAGI254}bkzS@*B@@1LsAkK_g9vNTp1s%D=_OG-<+
zyY1|(D>KbgE?KIb&D^%A(*qv!PzLkAtGU_Pzy6u#hQF;>Vo;V)`u%o&+ztnpWR|%1
z$L;+ufBE@&U(L^VKacI)`mJ90{SKBH2c<X|7!(d1VBy>ovEZEM(RH`iZSe7&c6RHf
zDT`OOYH~%r-SwLH(0a&bBPM8i<3F`FH-6LFx?A^si(j!!Q1F(j*j#1&`1q0PbiF(-
z<p8dLuba1@&RIKWq1UM}1&56qnO@+y`q&w5?iJLx?cKZ2<rVc`?^|bIeKlQd^<F1|
z7Ufjat!pD%6iv5oaq;wfy?fo`)e}_(1qII)&w1kM;^N|wb92Tof%-$uclOql`n_NG
z{r$B`F@mluysm9b&ee(Dc30)ZwPT)Y6HhLgu_zM}FmM-N&CXiCH(!6V_(LWSfuzG?
z`Pub~k3sJBJ*-swVnx^G_}q*i$JV>LBs2@La2o~*EEjw`<*xIYZFy6c$|ia_O?*3r
zH)_JHGaI+vW}BU;!nldyrUAo&oCZ%0w^N{uoWR(q!ni3dEg|-9dFl1o_*GlOpB`dR
z77?s1&1(YD<+VM_<#fyLmbR&>&S7X^;H%G^;l**mfhDO)@9kE$LO+mPQ<BfN+;vly
z%KB(}1YOU)9+Awb3Jr4x1{G*5|GAx=^&S!-P!R^x90tY(ybe-Vzo}gC5Xw;DWMFb&
zn4q#c|BR>9$LjPorAcA#IjU!lCLfvEX_$0(+cD1#UG=^bJykL$CyLDGG=Z4|p_!KU
zM0Q-dy<|g3MpVnDP8H6iJntnp)RyFVicHEhby2z0sdH*G*QMxfH(s6DxO=z2DlygM
zh?$);XYS7J^IVlOTWONVm5JL|x-3I=BtuNZkrkWrZp$8>YPm9WZGA|R*Nh2C0jx83
zZ#vG~mvVQar%IO8?H<+I?0ilJ(<X=Mr|#TV_MPsTu;M^ePo&Qo))})Wy)@%oDLu(m
zWtMLsr^zC3<Nt<^k!rz_+&kk6m^0tpZ(tA*sV<P%!N9<3z`($gU{pQz6N5&82-DUD
zj6xFym;_wIZ={GcnV2$g27nG>XJBA=;;2zFYktSK@3CmvRmNouQVa|{Nwx2EH+yi+
zDQ;Kb_T#TH_{gGOP#~kC(&~S#GiZeg11FQGR<JO$!<2igf&v#@U{Lw$>7mKMptjU0
z@RjtH{=g2ANkI$FIxzmMUAybgSJUmjzPXpfUmm%<JSBGBxt(QuWh<+1y_jxS%p_cI
zmGxcNZ_l=uE7$JI%FfGN9J9#u*&@)I8q>3io6^iAdsi>nY4Og_dUC^eb)RF04Y!u7
z`y30I0)jdBUQf@yD+OBR^}ubXf7Dx5QB`SGktsQA^RgGaE$X=Fl5umRNnoI>L*QnS
zt>LrG_S}LF<%GVrj5R$VoA<P&{yIbH?x~k!7(Ngl7s414+PN;{*0aSv^HS3KE~h*L
z;daCU_MoJ6b=zlG=ui)Iz-ea>NK1lN^Q~LA0ypWdu9wJ}+3k@l?Pj>`#%Y~giCbpV
zB5vufIIXkUE9h);s+O))cBWXz7S{zzH`a=63^VgO8L8E~Xwd=D#TnO*Mu5k7Hsy+n
zF?4k^xVi`iCYZUUCQh8`bJ{TMa;95v#>KS~$GS6CEMq&!AiyHP$l&70Ai%<!EHt&F
z>sD`=PEu;UYp>3hh>mSH)<kT~Sf!I4nA<HeGf;G^$cZIOeKRgad3$a%yQM3-aa(tk
z$?V)EYfjAU*<>uaWZ8vDfwvY1S}%I_?#OaovF;^aS51>{l|=h>Tk9^(d%Y93GO9p1
zW_!6*R^-%EZ*KMFJ>K0r_s%LqlN+~8yG*xrr(9e)vEI{nVs_e;VBb}~(w>VmO)^b#
z*NSFN^z`;xvRZYUx96g3hTE=fU9=@BahqY&wMB-S85g&jY}{tp9PN@6bg?(ur)Q<A
z$(9+n(_B@}JlA?o4obN)(<o(i#@3)<rAbq@PI^vSGck9gwA7*-Jy};GwKP_X9ZA~O
zt?IVzqUSc<%v8zx$p&dbxy**C6KAc?l%2XMn(YF6cFO9EF5fQAnVY80(0IB^C+Jk9
zui3>Y?ZBj28CP<00$o>WY)$oLPMc-6cIw8hTe>u^x~<am4&3T?)MVLYP4BEOt)pT`
z&91C!J8;uG#Y`mb*vXt6v13Pbay0&EI?iaDcyrS_(M<oO>6^3Kqw0O9N_na*(p5Pf
zD0Wq9<*H@3R&=HHa4|_IhlHd|bMa)kro}IEVBN(n+tiNgG3yv<3$7H;ntXGMc*f0~
zZPTuLv#oyM@=)#VEUm*CIZJ0cs~9d=rk<4J+qo%n?zshJB3FG+oZNQKWXq;WX3?U$
znnmTg+tOSt7jDtW^)@_LdU#D_Si7-FY3t!xOY^j?cfDPkaKkLbvxd`TrS_RiE4tmf
zOpTVWIF>0AI5}{Q>+02E*H5__ZWIh$WVSDRyGBaG!LsbAhtaEM=bGF$+OpYLjBBmJ
zw@GFqX4;w4Rm+*Q>%Fe#-4F>B^D=GP79nwLQrE$)rn49fmtA&XGZEaj<l2hcVTnEm
zH_TjhGoUgzca~N!-`kkg`FY8ni>2JA27Jr8rCCw&Xi0yL+cvYSoKiQg=4R+_TpFFr
zyVAF7wouM3?(9^d9PXrLX;+q|9rZpOp4E43M%kN<(-LRtnMEAB*_>8?X-!t^>2rK$
z!OK%~rIt>esIx76YjnkpD-oA{1vhTVG?}*O*rH>t8ryV@a%Y*XWV^bhx7+BkK%sX|
z=9-8#U5947T`$`vV;vl*71P?Y)wNeE_I7)w=+vZ+lrxtWKUjG1Lu&Aon>jgWa$TD<
zZi{JcGu745;mMXVmfW%0CG6Sd-08j*Oq}(Lv}23idIi_Gt+>&fbTQ)M;^c_lz>QKz
zlihlIlT6)?WQ(rYn4}Z2I3&<*#l?(nX}3j6N-2zsg3^p7lhcJ(KWw)=X7HS|FGl0l
z?X27lX=#hHRvp}A#%(IO@^;1?bDpp*LEE|$qBV0lH{{%~n)sMUUp+NCbW_FK=lpVS
zi`MS)E1Y53H+fCOg|ya!tD)02`nX4$SMGJ+)KK(h+nhsYx6*ExT)VgOs`8y@yMmr>
z=ThfklzE$*Yj!MGP|_!7nz!nbsmkATqd(oat(|r;BzG%lN4sJ@(-l)tt<3H1z`&{P
z1inIp$rm)Fbrmdb%xP-Mz!05tHQ4OT;((OQw9Sz-4N}g`m^E|F&270_nZmDymu^|P
zbk@|_4h&+qLVbdHHk>$ebY`1$4&(2wYq#B9o4f6Q`3KMt6p!Nq&;XNx8)R(D1++%V
z#id>lG!7&v09{+<;@Hfl1Y27L8NV_V#4^NX;Kp&p#YGUjRI3AIY)3~2M9dMkItwl$
z*aTW*1;z$$9H3Dt$f_$P`RfwL<RF7QyZd(cK^9;c_T)X@2p%`;NtRwWeWDzr)burS
zjPlbT$T5mCCQSb=#~3xeQ;ty%Bq}%ke+C=d^tw<svFQ$ejG`)eyZ`)u2%1KoZ~G+M
zYxmygTeAJkuI>50C9^cT@_i|2SZc=fiwcbLZsvPb-+iB6bZOn=-0bt!Zd+FGz6T<A
ze*2;_wF5N#HMPT28$1XG+TH-}0z|Y-+Q@M;0(4OB)VZKBteT(GAL=owy4$|bduGHi
zb<-v{BZjG<rA}@S0)(!Gc^q>PTAvdHUQ!jE-4^XB-RR&Q30nK)9p%X>-3VIG1X@?M
z*>~CH%q_QaryH^|$p@ZYb~*EI!Rbs6hXtzJc0d+p-HtK3<s_iN8SSaa;jlnC7b=~r
z(xS-Z;p7>eyOzUKI~TO?VD9zu*wQPYX<iknYqzsOGSjbAGpQJ83-nI?5qmX$|M}Oi
zfBdh1KlAHr-rU=qDw905UbwE=ofz(<n|kkC?zY?V2c}FAn#3_(zm_SuenCx8$g+*O
zKYy@?{BJ0|d%Z-Z!~gyLfD`Ujzwf>I+1?Ib!xUM%^k~*PHI|qMIg=_LpPw&Zue7dh
z+uN2&o+?vIl&-~YSiMke6Nsy?_kG{b?eA+p*IwSeVf6xr?7SPH7p~piuzKOz-HFE0
z{?+?_%HFN~DaZca>)-A78!DXZ-_8AgKQ-`^<azsjw;z1+dH4E!`}>KGEqt{qlTs#a
zyHvX@H6m9&+UjeJ@#osTUw_}<yQR~7LvG{q>XI+sU%hty`+dKyX5Xjxdf%t-eGgh*
zle+DOjiT&U=IYP&>+kRW{yM|OKuJRC_O@*e47ES%lIkm6e|}y+zi;>V_3Ihp7`W@d
zfBt^;`}!5;ir_U{oj?BgpMAt4(wx$}^xoe$`|B9ET4R@Zs!Vcb(we_&3v<@b<Ck}b
z-Oj0JisunZzh8d){pPt<vu<w_@>H1=dZ9bA?9jTFsMFidZo8fQLue9HQ2C`RDSNH*
z4xY4EVs;k4U%twqf4T1s3+JC2ZM^)q_qnUqf499OGdc0Y41>fE#V=JREt$IYZz{~o
zW+5@2ipnch{dNVenWA?0OipsT+4TdxsXnSx4d+Q7KfU)oXm<B>?uH5{>nt{(gk!rt
z-p=jaR;^ol#=>F7Q;kLUr~ZsBXT1D{L4W`KE0(fgFUpmIG~Isp)m?e_z3=rq@=c%D
zTgy&6p7rO&65oSv0XeK`f2%*B$DP!Ku<OshZI^d+$xV&heQ*Dy+iPxbFq>S>c0;aw
zyT40AeDtfy*0I+vbR@VKm~PL_WnlQ__GR`RdwZ2hpFYLK6>r=TdV#@odydu%Sd!Q_
zJ4fpUL%r1PZK5SG3AZKU4NcqjoBhkrF8p>rw|~K+&%V-;;SEh+y{qr-nRYkrZsV5O
zH_Q&4d*pN9?(I3zduzSsoJ&bAicML&&gbLf)A!@!SNXgxk9JaQ6gY70?$#{~%rB+C
z>D|hVno{7WZroPJzIUfq?)P}>-JkEzpZ9(5*W>jEtArSpluzHgGd*wb-CYm;dbPRl
z-d-p2;?jn_cXu6|@^0_lUGKR{Cb>;*4|=89w<zk}QV`{-y0>=kl|2mcT$w7C+PSmJ
z85dQ3-FDWx;i7HT?X;d0^#TUAFaDmYPgYFZb?IHy;>F(1E6a5QFD_kpW%ooO>s`}}
z?yY#KGRf?8eRb&-i{5ST^X``NDd+CKy*<{s<96P+x7Pz6nK_j)yL^2OH(cU`-vb8T
z7xN~0pA6J3FWYtG>nqiD@2*G8+v_sPyXtrK?wH%$uX<J5RjYG^cd*afo4eWdj^p$7
z(K#14F<Lh;$W?jjtLEm;-S&Eg``PW)We}<!N|(J};Wpi@joo{_-4nCb2QR%ozms>>
zhmzf)vz-?%y?*D?JMSFltt;+kOpgImlRV4UZ|^8$&|hUTsnn}eujcFf)V?jA>F49V
zMZ9*IR`YeMiq+fq)jFQ)AuFcsXiu8GR_Jv{ndYvGdYe?$KJp!4^i`P~v?#Waul}fc
zl<IYXH^HTgJXP=QyQg@AL37FEclkdB>N(;MyGT3P*Yf<YYcGjhd@}cy+RwMO)7uU*
zJAHPzp<#0D!1smo_gXJHckkM{2fPdKUM(-rOE2LxeD!_b?%hw{%htx*H8eTQU|<nq
zX*A#fpI)r`eM{Ky-`4kQzdZ=QTXyRkV{yH-K)HGKyj!<T*KWIK*p|Cw%GMpp4AVa`
z2{EeZ|4<Q>zqCnWTh5ZiFk{b@DHje2Z4SF4GG%M1?%K7{{yzmRGI$vmukz@cq@=fw
zS5{EG?3QWoN~J`<mBl%{YtyE#6*Jv1D>Ld;!lg56ZKtz!W^1Qx4vmW18k{H+7!tT_
z%eA!`^|RPQJ9;(O%sLcpw&=(vlNG0W7pHE?HMyueQ&M!<f?Ta^Cf;qgZb@scT$>}U
zYUXk)nqk|DZMU{LM<rd=({^2*aWgG)M(kXLBexQRXS5cjNt`)Rc57GT=9!k7C%2j1
z&Q5r=^vq<#u+o@^OY@4vRn?<Z*P5KwxxH|viN+0ulE<y}qLxCQhe9p9T&h-za{dj{
z64qq7DiS8@DdE*|f~RTAl1WDba|PK}vaWKh`WiCt%IE2F?b2C~9=u<l_xp96%MT@q
z+}(<4o4rf&&$>*_kQNm3-NtY`v-IxU^^B?4buRAq+?}nqJNtlGq?%sj;%J9G7Plop
zyUHNTl$bb~>K!IX{tQ+5&!F{7C^X)wO;ylGhs*1TXM{($K$3_U3-?r3=az{+sv;7q
z!CI51eAVzw<?{62HNpQ*wArGZ8>(4iYl9Akm~GqavLxc5_IH;_)tn(m;xrpWl9D9?
zj%iKPIutQY>%az;H6k{8i+Z#q*-lBgvGz=GoU}}H+A^cVuJvw75<L>$8LQO7B73ey
zU0N1(TIb{xgQ<cG)TO4(*s5}D!i*yVI~S}pT_w0CIMP(BYtcnf5trMBt2%r&S6$U<
zQCrJ)J9lfSmgNeq{-QsxcE6wZ_t)$BtdEzkNRx^?DRW7h;cfM{&CxN}a<|>ixvRFx
zE8KM31EGH|oQfRZzb7Y{)z5aj$`~!pxaF4aZ~uLJFK-dLl|C!<`gxP`jsvwKnPz6p
znOmY=*yns-U-DLP%XzEU&u7lN_1*8Brf2rz-}l%QIh>Tc7S<?ogcLM91P@`hC|H6<
z7{L>L3psB3KnF2Fb9@RGPG$j<gv^<LHz?{ihV?e|ZfQ%Ne*692txx<}+#Le9?VR&_
z!RE->7e0Ay;hmRY#ge<k?3Ux(d*7}%tm%6jmiAWd?V4F{*E58<$ENPMnU**6egAwJ
z1{F@wO?uO>7w_JAfrSaQ#?SlH+U)RutFG?PuF0+Yw_ShwwN@sDdL<`MeFgmw9foSt
zci*qhKJ>xhh3xK>f=e;ijra07>^V><kd*8Z_wM_)J*?AHXPvpb<nGqVv0EQ->r9r2
zTywtPeBQ5pdxZiaP*6}PP$)o!v16Ib6qhNSOz}s<)}M2A)4m_K>Z7Q{`s%l~U*FAL
zFzvF<(b$^L?(HvFGQZS|Bqx~7=FVVzZu|PKwM(w?xm`cI4>3i(cr<0&F8jR?k_1|m
zELQ#8{p{zy{MoM`3CMtleFIw9jg5_sAp^poSxnFf@ywYsK*7rn7M=RzYV5gn?{nAY
zZkqruV^lbq5(GSiSQ^z9Om<Z8Trfe65wsdFT!^JnhciRyHfSp)xb+58r+@0s?ftgj
z@BVzhAl!C$_DPn6*+REoTHVgObvt+4$+g>V=iNHF?$!pOhrCN?Y|Beu@@%nHseA6-
zoeF2ol*}$of6&e(CgdT6Sg7S8#IkQw&-CJUCXae12e9>K4UP)l@nJjjqF+C}FK@kX
z_RPyG%I@Bt#B<@sV&BD^tL-j(=3U%&`>15E$t3Tx+gYHcUp+Y<!VFCg6Vw>M?ic$1
zOha4cRJQ5aO;QZ5XJ&ukU}EaeW0q%NVAvj_-LZyE`rY0cx06;a`k8X{PLivNqiUen
z#QLI*2{UyxoT4_@HckPL@97&m9AdDod449WSLj5_B$pLSLsYr09eO^6JumS9L&@E{
z-}gS=y>RUT2F9;<=at7S-E=M2*=JU&R>)Z&1_p*JpQ>C#8Q2;ZFsPiG9Oxe^zbYdm
zL(1ghD^A;>F3nf%uM`*<7(F$$*k)x&@dq%l*86&T22}M2Fe@<BO7nmHZg(nT%C?mr
zwLdR!e$U;>$E4BdGEL{mG^N0>^6;GQ6rasI=XfmJrny^m+OFMeOHC7n4*c5o;p4+c
z#WPxuv~+iJEXZ+s<m3usa*7MdT=7hvv*rbOLnCM#WsAp*PT@=?7jbu;SF2WE3$v0F
zR8rzzJgtB|dS|TZ0q(3lVHa1kn=5(CfDPjm7ZM6937?+O$)s0*&Fa)mIJUWa>tzhX
zN7x|PDu_&))v4pN@6PFCs6bkL1=6OSe*NP1oHOiKR|Fhc*pt(yr8dp5cWus5w#nX{
zNtZfxJad)34X)f=k(3=c<wnZPCZF3u+t#l1y3yO)(HqvgZPMhNS@ml!8>KDSHtD8v
zmf3`vEs|3eHD8Bp^PQZrB}!MU>&UzAm4O*IKsyAvQjNo`q=UmmG;(*HU6GZVcEx11
zXwp?Nt4z}a+O836w{^>!%z7ZYXiexQP3=tqw^nXDouzZ=cIp<+S!Y!v*Ieb!Sh!`{
zh1mf<r$T2fEh~4uy<6CF#g(jjQ^~vHDH%arBAcW$LIRI+cXEZ5lz_taT9(yum(!+<
zxAUfMdlP1L_L`N|@d$0BR*@@rOT4CRTyf2`H>q3nth=w;PWF_bpe1=>$3WX6yOWnq
zj%nI>*>jzv%%;dot2>ok&b?VXr#&*-l5f+tBH7fOr+quN9!_ZBXyWagV^#l7i9>-&
zp@Tbj+qIophH6_fj$K=1&=IV0C5!7&%FWd#VW!)30~Lj)bsaM^ot!J3b7IM|v$>Pj
zEW32ZW6L5JHI<t>o*SbjeW$Ke4)jWM?eSTW#p|4KajmZIhKO6-0ui@1L|k>9&^fIm
z#cPtUuBWrE#>Cu&Y14!*-HM9ll)BVeFAUmA=;@QZ=)@IYF`rW+rfJ)zXap?N(Vdw(
zJIiS1lq->`NgJ}vZgnnOoSYo7=xXjZEwhVjayFT1yIpE&<q4eHv*yYowS^Hky<7rU
zhvjb42~N$qG|N}pY~><Tm)y+~3#VL((&*T7O0#3pjip;nw_QIhwOBf=X-1&4`I+3=
z$LqZWmP!}o@<rU+YPM9mf}=a<WwcDLz>UpvTSGavxF&}_7CVv~dNxVzYVWmWn$d<{
z>?h-H=kCtQJDKTWwN%nebhGcq*@l9RsY^C3@|dLQGwJS(J8C&<rD7c`wl#I!m>m@@
z(a0S*n>S^prplDgO->t@olFjT9u$&Xpc`^7GbyJ&_rl^ZF40-Dg>tvuau;|uLuyNO
zCX<(L@0!_J+s?ZhhPnkNs~DZybXrWYTTrL#&1}^T#$mS|yEBe1+IH+(@1j+=qRn!-
zY@Ot0@m%#e`&uNElPguqDcbBNU*w^jCwJ5?OHcM(;<?#6?Qx6Xv1=TuVJ0r8gvxZT
zT{2tclN)hkRlS*R*OF`95vzPNu1#ymj?&#`c5ND);garztvWo(o?-{Xq7rygmog+X
zWasWF&)#;tY<JGq$hgeZP=C|tP=3*hA}xQD)rqRJrp}mh+tfSfB5!osnzJEks|+fi
zn=9EAvbc3*EaupdE~z%nIq_lV(@<w-Gp<k8rFy2?wyJ94YwM%sg@q3HX)NlxlBF#+
zQ{vbW*TpW;rCPxm*H*o4Q)$rbl2kB=&MnPS3t6g}cRO<1TCM1;Qc(#rGu~T?SF_gc
z+!4XMcDJ@>x7x98!4+FVZZ7uR=(g;vl&;!Qscy$LH(h%rv<y2s)+#OBq?n|c*=3Z}
zu~gJk$x-E&il>xI*U5U3pc8A)Zru3c!sGKc=5ttz+j5Q9#%`Q>b82sN+J;G)xff${
zH%FKzTw5|}>shyrS-ox>L$lc~c1!6-Io{mklKbq{?9j^DXSdsY){Dtnr<^F<6Pk2f
z;Q8FyxxG)Hx|il$Ss0yma%;}y!<LnvqK7>_*IwPZeNNFdQ;F7Dm%P+A3f5=j99uK(
zT++*sOhdJap2{v8om_66uT-(``fK<9_s1VoZ|6np?%ln6*V`?t?)Ufi_wSDW@-}TX
zXx4y1e%h+s=mycXc{jJ+UdzCsaO>@?ZLb)@z0)qOj>&Cc5MW?inYLwiZgTY2psfv@
zrguwJa<>O<_uVpWyK;IiYgk@Nws3B}inFy?&YO&)ysjIeT}Qw*6^GW^q+UhkjM=$2
z)0UZP7fkCiUc2M+vU5fuAZwfR`!DCN&fRr&?e;I%w(WNU4}QT2=pYz$*sRIG1-!rv
zGD>FP;*zAK&~Z>uu%n}EYuz{S=-Bk5i<!h2d#4-hWYU~|!H`*(s~5cRtE1y!)AU>N
zjPlcGWw7yzh$KrK1MfoY0j+}Sz0+~Tv19u0R3^#k3zslygN{DsV4AjOdgLx9%X-eR
zL!ld{=AHqm1S{`JfB*kp{_*oFyWFSdzTa25_wz|h?Zf%=tuODZJb5xsy5{G-dBsgC
zN*{Q4+H`ohPV4Y+eP+1l^PGD~f_<--Ub6iT+5!kMR`Pwt-p?oXCO(a>yjQOBWc|FK
zFF)V&JQ*ilUBCCv<SE6wm+W$Yw~Amakf^)$F7G9rGVfmMO;CYRkcN@_v29n^XWd$8
zZt0@CacdxVPOgd4ZE0VQjT=`A=JqaYiQru+m}{bRaN82sZ9GXCuG`FJfyJYfGZ%{8
zxRv4hYTG*xAr^JWPD{{0A&6yHc5VCTf5#u*pMHLy?faSswQp;-EzZi^>M(txG^0p8
zR~zWSPzLF^|N2iqe}4D#=TYYzP%QJ-h8Hs}+zMhcFo%8xfp<TD-k!Tu=jzv;XRa57
zYwfF<t;gm)tAv4Z?$y;>QzrA~>Tch>%k1_8b`u6h0V4(nWj+R`@6(s>Inw2+qJB?$
z_bksd2i%hWTsSc8S;E-^#)^~Goa5_37x(SH#-H3%yRQ;-UgWu7wM*uU{8%xA;rR00
zO>c6f-@dJjw|*|KIC0xu&+21hk8>K5f9AzcE-4FOFuT2baqhO;`Fkb>`Kwmv+SWe1
zwe7OC_4WdeJN?!MlN%<_(3xcO=76W{-SgH4^WMJBUfA4{sM2ICSNLR-cL9TWxtmfw
z=K;pGM&=S4I-)X;0xa!G?0fFdzP|VR4u<<x6ZHdH`58FlReVhj9hCmC^5oqG3I&b3
z_NLF6=&92BEyO-AhP_*4W1x4=@2{^LA0%&1nR8x1RprOz<5Ks__uedcC^D&b^}X+V
zFI*Bl&!jK>^u4XF*_TN^2PWF=o;PjYB2U}q+V%B?T|4b64>jn%Tu_!8(^d8R{G^yk
z(~TO$?=1=Zd1hyXz&_?aCbJXE)ALJvv^Z5_uU-pN3G!4lQQ6Qh<f(k```(*H#d8#e
zRrh^gU$OY8;N#h=FJHgQt0?pJQO(}x%a8Kep54a4n!M?<bndo$KUH?7nQtyReqHZf
z-zf&R+vO#>+v;!UexKy!ec4d?rnvffYl8<9zct>RSXA?QGanOc{}%R*uiiedxqGAV
z&F!1dy%x>h!D#Vm)y@XXa|M^D^Y5!Hwmz^fPTjnz)k$SS;1MIf?vBcKzb$f!3W6-+
z=Ibu89^lKjODJO~NZlpm@B_S!L}lW=kmm_^bJ&{~&w1$H=TyIaSFw%5yiC=OjL(@W
zrZN`B4BU6$XR0o{H$P_YE^7@2>D;>)L8Eqer+{L6Qv>6+yLTnG@GBT(sGiyKiG5Au
zB~J<7<(F)PG*zl+E}S;WQ)Ty&z1wp(F6mU&l$m5Q>xp>u;+fIurk$}Bm*%dyG0o=0
z_LM0vOKceQ894Lq%&p&|JkRIE;@oZb<Bqh=&RX~GSw*8OPlkdF*Y4=t8=gj>^9YwN
zyVLZcNHn+Y!p}CpcP~_A!u($6!Gf?X;5M9{cA2f=;O)GyhJ&l_?q1r%DKg1Gs@3o9
z>^m2%LbQ`+Jyn@hoqJm+Q_0iIU8Pq|;K8m*o9aKOynAkN(xXr4?2)jAF5J}%j(pvq
zq7raBbK9)UWt(^JUb`C>3bTD=w>{0ey(?B|&%L?D+qX<IyE7Z?L#ul-CsV%K25dU6
z%;e~(yX{M(!Q1ZE>RsRS-aOoPhqHx4OsJKobo=`9@=_7oYj3x&U2<w`w8VzEd(YFR
z)_Y!DxOMmLm6H>70$Ja_y?akaSFPN$x_Z~ut?!oa%G$Q~+M7$Oi=}zaoH=1Wr<_41
zEiH{}-Lq%2_k53!-qm$0C+T2yRkW7w+)I(3x+%h7L!L}oa?#~&?{bydtG2JSWmYkG
zeb>Qy`<9bDQ0BJV`DS-F-Oe|=eX~5Y{;p|s-0QN;(4D<)X=y3a=d2s}jE#+1!;6c3
z?^Ul~dv|SCnPI}-z30wq&6RHLz3Vvn){UK6il>dWR!`+Fd%8XD<m8QocaJ5MJ)U#t
zn6R<2!o9*f423gi&d}ODdsg1Z8F9~VHcpaY^GLkDtD!tU6TvJm58!+I?p^&W<|?Hv
z%hT4b<=)e?Wa@zl*Otssy0)|`DtBSYJdwccFw^q2Z`rrbu886&U3>P~jefH;Ilg7v
z!}VNL=B!%OrSn><eAnFzahub*o$r><44M>C;aTO)65-FKQN6yrtWPAc>c;oj*J({(
zXY&U5F7~w6RBdmWzGQ>zvL#*tzG}TJ^?|O-G|OIYFOj>J`!J*6b@c4B8|89m+?e$?
zZ(U4>r)6lUNaQt>_oe%nr5_XGJhs`m<48GM#kQH^A+s&!I4yc*rrR&udSSu&{uaeY
zES5`@4LnT}I}VyWxa8N=6sVuKU0|!%{HbfZR;{19k?+P@-PosEH)pkMHRViO8Fpo>
z?#va_A5CWxt6$+=WitD?N8xjYVD3$Ccf46<TeT{A)dkNRujX~B&Dy#rltcQ6qTJ8-
z`+h&)cjt^T&tW4q$+pCq!aRo!&KUFDzn<k0^i7pDex^~+MJ=C8jygIEymGhAuFG59
z?2y^kWn?yKZP;beT(#4N(X4J)cusly9J#PACc;->&PBH#T{G|c?o|S13j{8$m=k)$
zOXH)ahup1&LH>PBPScv4rcG436sWUA=oFWZj;>bc(m=y7t=}!R($60W>3JUfEfX_2
zQ&q6wQCVqBlgX`*8)I`h!sjl3{3U+bQu9;h-sQFL&9-h^lxd&4iy`!h+Yzl*pGtH;
zDMUZHGtuOVuer>GPL53%IqNw#2Xu05+N`a$=^`hDeUTH)Uow?r!q$LJuoy_q=73Jg
z?PnSGUJVWU&Ka`4C@58-nOkIHq>{F%$}}w<*B~7irB_~ycB)Kv2n}tG3ej5p#%aZt
zu0_K4m0UlpxOIbfZP&D9Q*DuBS}6|k9IN~_{aIHyCDb1?Y?~AoD79+IMok-W6*Ey&
zSIJq1D@@t67Mz*Vb!wV%C|gpRSVV@I7U$Ho)U?RlU}LG(iIb)U1ZD~q>zuiwCUH2V
zDXmkqVqs9kDYe_VTU2LtZo8_QEG=<U({ysAZg<j}jY-J{KC66#xC|HOZoAF3YUv|E
z|CV2+@82zcX;M^wW9kiynGS#K`F`GfA@llP-q$7mXLp&4Iw`6M^c+y&mY+Ynu1>N|
zDRJgvP{c=PgJAqBQP;PxKYsgZ@1O7eQeKdM>)fpKC(rKXXA!L49<8mX!Fw*L=<%Fi
zpP$c<;k|eF?G>wsf?KXmyR$92_};pkvD<a0{*2b$F?I9f$NTD~!KZA2M@AVyqiRg<
z?^fM@|M>mm&wu~^z4~*j{<if~_b%1lzU<kR4cn@2^{MJ^Jk5Xo+}{%YC>iD5&#PbW
zIHf$*`uP-w)hBv8LPMXth<@U*{p3!i%oVP)S|ANN5IuEfWGJX{2V#p%5=>1C3-#0r
zRm^f*C?uE$!%OB&{pEH)Bj6I3WPM_Djro#$cP&<ku-+`Y{rvR7A79?reAK!d=ql_R
zbx*6csiH;U01v<F_J`To`75S3&Sny2Qc{@CAIK~Pzp_(}>2}ogM9_J8y^>6t^+LC^
zF8!(flYXkE<3!4&0Ja3?X9wy$WR8gcvtUt{R)`VK4|}_0>E`TfM@u)bCr^`KKlj&*
zxGfe|^K7eMUl-35WY68j5MRmbDUu`_F?nJBge!@KPN3!`1E>wj;L<Tc#U*Icer<!g
zjzhhjJQ_DQ)+IjVUu|`De$4F)9~>O(i%%yNJ!-h~OkL0N{PuZ&eixWm>rP!7KiSu8
z)~4IjPUlr$y{*0N>E?CTxA(qh-n;wux+$(9AP8C}2OjR6z@Snan)~(p=kK4tfB&5S
z`&Zrk_4e`mfBydc`}6zHzvP=NMT&NwSUmMySc;D^&xx7BN+~{_TQ{6BPMqy*cB_8<
z!=h8lTV{Lg&b$$D{ppXNKP$@fV&7X|zJBU9XsG}L1EbsgS-JKmmqFSl8mYNJP1t94
z=gzvQb#=Z=UwIu5{<7}THnUkFIiVaalMf$0SA5=P&*yWD+npTC)SY`4wJFEts(OXi
zOxYH+?XuS;&wys0GoNqYulatzw*K?|yfk>()j1JVejPS<nB&K3xIC5N?enT~xzhKB
z_fE|UyQ%8L<e|vGz^1bI_4_J&w@x16DdyFsA78v)Us1lPqx|TH7fM2o9A}sqJN2vI
z)${NAV<)i}d<2^2ni<cMW;Sj1%s-%jdIFk+e0{^Gsh_%8*4)ey^orcr${`>fvB_=Q
z>@-k2oACn!!!rh^xsUCtEXoUhA4uOIdn15>f$zk8!5Ov8bKDQxJp(P@XRtfoE^)BI
zU_vLyyq-&|f;l@5n0%F+GGz+G$;OqxLsqIVFmT!ib((5OF??m36cq9|;Hz1St%Ink
zs;kWs&Lao-=k{*@_a}6E;yk9r`l5ce-fdeByKOt^x^2Cb*&d`#jB}IMtOaA^^JQV@
zBOad1J{f1jka6o7Xf@k9nP+>ZK0d$(-u4Jq1yh}T_U^i=h@-|PXO;C`&MI3OyX?wa
z?=83HF5Yr$?o#*6tu}Eb&#V)8<xHTboq_1-0rQzu>LF)zUF>#U%(D!%WzbabsYR>N
zwzTE$0?Ptt1icIH2-cjn@mkv2ZKn>kn(?)Pw>U0botk#VG-u5%Fn0!QRBqcU(@X0Z
zqqL50jR1{^iMj<`(J-8Cl@NC3O70dh?TBsHxTQlwre%nwhNf-ySi8W?Q@Y+W*L9<I
zCgZGCGq>H&RZa%&&nnlvC3?i?+2TO(Ho_IRjCbjs>W(^A?s_vYBzdv!G_$;|ca~=a
za~*feF<W+O+2O2Q&9aqSx8yGBo8?=?n{hW)RV(+@joYq^wwYbr*1IKlaj4jFU$vcV
zTe3q%AxbXpin<-M%_`IMM7`<a<h-!kxm!iM)DErfxYfJTJ5_hpY}Q=IG-p%MG*@G%
zH3!X>otPc6cGB(C&4Jn3qFcmFSLj5Cv2IzFwwc+`>ulPRnQKmJo6b}%3p;hAcj;Ew
zt&0}BZd?<Ru}!x%XYG=#YnN{1N^@OXnK{+$m{!iRQ#s47+-OZs+7j*Rb~IyKeRoFA
zvQt?)P20jWP8oz9m5ff-*u-@+VzF7Yhe)pO(yhEJx8!QO9hEwooYb2fam}=MtF*Ur
z;F?^6Ue~Q|ms+xPv!yPsmAbgXs28^VakIA3W^Jjhf~JzuOxrqFoJzYH)iJAQ&9WO;
zvP=!uY&x21b~LE#*oBZVZPBiy=3AvBlX{)5a^+}5EsX4S3!IXwvE^va+Gvr~+^B6D
zr;K_QYh-2V8v1Z$=^DC9Zi!eH)n#@yUt;>og-n5rz0-d$WOA&px^~K}w<lst_Uh0(
zY-?jz_;5UB*mH8zW^JP>r*hRU9n0~ov3M;y%Vn0&<cZg`O*&0xNc2iB(s9X<WaLo|
zPtDPtx>Y!L+f7liW8G5S$*#RF3~a080#Du1(9kK`&bjT_ZH-F3K)$db&u1%chK9?@
zz6`P`G@NMTy3%Btuc)JA{esmq4OeVjbgU=hVsh9O2F5JI6}{n6yQ57d56rmXdu>_Z
zYSXM!YqE|ehiOZvDltV#_6b&L9_(!FNaT2U`0#-n&*Wxj<$Sb!80t26?b_a@Gt>4v
zwQq_H3+C2H>Cx5l7MpY_OzFlI*NrQ>vyPpdpdDa3bz07}Q_(8NrfkggIki|^vR8HM
zrk>L#X3?R)u4rV1U9CTzySAQZ`h8s{Nhay+=@*%qq}Y@+jv4j@PQUBJXf(Z6k4bs@
zv3@4K>GRx}r6)hAVx8Wzgo%T>Cs|_p|HVwQY+5(Gwh7&ye!z`cYjQy~%XHseOs@6N
zk(U4aL8ncs2!W~~Fu}>>9-3W||N8lv;KWHMR3@EJY17<r-|TrL%k<p6?@A|ls!s4M
zyYpIM(%Zf7i`O)H@7=rY_U?_oZEts8b5y;ZUkzfvFSjlaPTZYe4OX{(Pt?`0t%Y4V
zrcqa>IjR`?wyln8tJmCcGDXN)<UrDF9z)+YiDid*f)n>u-_Ebjy?X=9Y17<rSmZ|j
zY>*ie%MO?Cp1XVHhP&Io@7^tPBV`k(VpopAQ8Nj+_OjdeZr7}>et!JyUEemS+qQk*
zdu|h_-uLZ$@4Q75jpEe1eeb)~2^E+tp}u*$cQ3@E?O@NA@7??EdEToW^Xl98-j%&u
zcDU@`_np`L-tBsQIDdllm!nA=qqR+wwt-WB&YCNSW?WpmV!GinCXeX~nv5Ktc6K%i
zJd6!#4NPnq3<_xtOkylImxd)8XZWrO4PoF~x@6i`v)if~%+ZnAk*iI;W}7gWEI!Nm
z%uDZ`(Dd@>KR>_z^?&cLdw+kvnSN*)lS%#keSd#{e}8NHx%a)V>r9^|?Ku-Zvp4(f
z_T$H=^{;*%_B+1+*mcWiz2YZk>P_A2<gfOGXR_TS|KexfYAl@JZyTl9|6pLe{quQ4
zX&eIs!>0V=+I91`->O~vp}!^e>YVuc`20h^e`kEXeOBo0T1oFX&84^Fm}YO!-IAkQ
zvFudT#k~5r8Gqk?U*Ep&UdHrXkkAK_OK;cjo7t$ACgE_tQs<1f?VB@^uXD?`$S_<e
zV0Jvft0Kd2$&;PIM26v#;{jeU14Y8L*mmB%cjv3E%WdDB*?K$o%z59romJf*#b+Av
z8>PsloUoCXxB0BQJ#NqG*DJr&@9Up`cyoE#XD45aGqW;pGApJX5_op0(RHuGr;@hW
ziguHney>!W%&GF~nzx$d_q*n0@(m2^@kblDHZm|U=u9qQVAypX>iN7k^Cu*)%HQv6
za(8XE*YB@q%GSO%zWKiT;h)GlDL#e_3&sTx*e3BYWU4ebNbxabDm-9ot_QJDWukXA
zH%LABF)hjiw2G@}+RaR5Fj3~g?5QHdaGiBpl*gT=+c1dx+E$Q|`Fn5P{p#Ac-?!iU
z>^Upb<nraqmx5+a_Eov;xvZzd=F9X3&X+2?ubvc*ocF;$w1I*5{`!6V)%R;ZFfj0M
zdj0m>=eW$LZ<fB?cH*mIMq^{{v`J>SbGIQZysx#zM5SuN7Ka1dPJ2pE!AeYDy^_hQ
zK0VFn?7e*R+52ovb*A60-G2M|<-=Dt#jB*;VvsxZv&gqH<$F^N0|SFx#AdOiqi^4B
zBiqNHH>Lfq-FI!)*{JG!OVwr>&UU_3UCn-G-j^Q?3QpTrF<oS=k2<z)<F>zcd-K=F
zFF$^4`_u3mS<l3RZ|6B53)%#A9+z}ksyS1Zfz2r5o@U3CrN*+X)7LN@bX9RxnUE|f
z*yRC&O3ES=p>Xo28<&~V93~rly{q@LVx@$aw|hz1`n(sf_LRJoc)dJpPr3V&ne&fK
zN}1GDs}Zzt)q?s3^JgtsFl)u4tc9Mf0R}5We`{Zx-?}+9^``ISX=hR<D5Ol7Is4c9
zi@yZ#UoZ3uydRO;zSr18a;EL$nhN*YJ3&)iT*|(SER{`3*>qA>P~+`8O)sls(JEgi
zfM(hmCP0=ROwhTVb9O&t{GC-R?O0X?KMXPm)i`jVGePJ;XuS?gU&q4mQ%!6lo}xEB
zriRw8>Qeut9hS5;IcK8o5|xXZE0(OAQ0VRAWuW79bWw)ErKl-ENlOYWw5|qik#bWt
zTrg>C;9^HM313mIts(0Sj!l+YapY2v{{pS)ckGO|t=ww&->&BSuV|Gfwq*v>zP?+1
zd%gAn22fz!S<iS^?o8rYCJzS2$;LlsPVx?oKbjr={yU?D0+aEVA6M@ccpS8O$Ec>j
zagaf9o=xr^h8_V1hQ@Z8%pWyM+V@*Ey`s0>o7wg0l~T~{Yi~8Zl$4bAdIe3{p1XIZ
zprByfQn37tlhaE#Fsall&v_0$!uoD@=)T((*Jml`te(2)dPaAW>C)}h&mVt$`Sx9)
ztMH|yFGu9gModeq5bN-@weAY)=;*umXv*R>J<}p51qwmfsXLVf8dww<IT$<`gjgCC
z7{GM@uG`t)L$mgW-CO-JW^MN@v+H$x-qpUpzVFA+*D{(~y?tlB_U>N1>f_}l$?N8>
z`uKeMz9LY6On_s83MZIga+vsg+pX)brY}rp6lKbeoL+c<QFQv>iHv&F-ydO;o!%+I
zq&oeS6O+{Rx3<jO)5X>^DT0nc7n#0mHj`Gpl4{m1^~?F|=bb;gGCKR3t>N7>->$4V
z!y%NSmR@+j{gCy~J3&**uSq7p_qoI}8B6LpGpS<=I3*?Pp47iAawD+|R_9If1l6OE
zS`#uj3#l$sCV48ad%Sx0`fazf()WD;$I{-c50!T&voL&Km(rlj!r)f%aoYzb2}TA6
zCN`PE<;M>x?fvK#H0|y7Wl4K>bxhgzb+=bgM@Pr{peajrZ|A4ExVVI`^a`4`Z{NP%
z)lVRHA(NXprwguO6qVQCoxAPZx7@w&z|&9+FmQzte6711Xi>RB{qHPO*DcZe?QMU*
z-}n2|CH~x3y9=+b+I#oZ`n)|LR9*y1i<8nKXS{pnYvgNeT%K~~uK12!>qT1<HFb60
z>8-wd_wcHZmr8o7=gEfm%@u`N1Ecw8CvEXm@SL3;nwQ4Cd-uhbC0n<K@7@{u?k)(_
zzm(XsYVYmcdu1o3MXK!HsWw?{vdZ0?lXJ7yPIC9Vd-uhmNngRr--1-%eJSy3)!w^z
z@5TLo05cy<%j@pmwcWJn_U_erkE^>^eT;Aunsn*jqgQ+H-mzLQtL|}p=fkTNFE2ul
z<^k(~5dZ5Ti&3;aPIetAEjbNcj3Um!z_5&gfuV;j`|(9arytUqTmb?dN2h2x3P&#S
z(N*p8)md;r+Yr>nW<PkNndbsS-}mz&lJaGmN0uF1#K6GnRcoU@U(BL_!M6Bpit^#j
zpcvp!`;x+*<KnQYewoRt6&DvA%1|{*sh_lH#taUj<$FU`NwW2DHu;Av48E#4!GxD-
z(v)5`wJUPLmsov0z0@2S>}Iz8&OiDy=FjuJki{bBcD{U{u5D!%R#IJVRaQN9t_<qY
zK6CJ$#636p!ZV*Lv%vbzx9_~X`EFg@YHev-X>Doi>bcgor_O~d$E<VP8Pi+T&(<Ba
zGcQO=%O`BY#kHFP*JdAlJnK_<KLhOW>vqfasudq#C;RN#UbZWo!3NZ=MefqB%R=t&
zLYAR`R-9O!s=s;72B8O}4~nlo*?NG1IciVF^=Y5CUfRL<Si0?Y=vnEw=yTV-z^8Q|
zkBqj0;iE}MR;l|s-I#V^ZFgqSP4BG588>>DIvY(*>)PyarYlWr+oYS^DUnIjuH0Ce
ztGZ=z)V76Nlueuswa(V7Ca#QZnz_<Tv{>!r)=gqv<*rvi2TtFZ@^s;pCrg}{1(s{x
zyt6#LXztuog@#-2_HDeV6?E<e=xlRH7_AA9crnv#nb^s8vzKmnyN<g@ym&1uo4jy!
zaBjpkEsblYJ5M>O%>s4pG!|#iy0Kc?ZJXB7z{{TN7<ca6QgW$2yP?cg)l|7SS~NK}
zQR(Q$3s*!>tIiD#D!G*1;O?uog9XHh&eEH1H7O|QdfBvd&THVyPfD(yo8?<@LxG8*
zZ;sVF1r7x!h9(9D4kpvBYqve^y4cyaCRt+JZPwn65>r-e@pZ})W$g{RbaX9ikC;Kk
z!Q?QnTil}c5feJSU9+yXsV?pIQdEgFirNqrs3hdOZQ3-|rJb2cQIRthJRmDml%jkt
z1?NsuP7aZnxyHpcYtfC3ol^zHj&9L4U2!GLR6446TeqUHuF#Dm8<nCnb581NOyo8M
z-9x+0Y~osti6%!j`COfCbu?*e@8ZN<wNnevYTPsntuGec>N`1U+sduZS<9}58w6)3
zwd!`6Y5F!zIc91QYMOI)>SiOaTlZ&eyQgImEp^nbJ2~g3*qSWe<j750T3ReRo36S=
z=A2f$86CLjmX?{e>z0URv&=R|>4Ioesb1I3soT0TrfwDXbvt%!qpRquwTqK_lQwR2
z+qi9(nXhPXedMyqo=dK&ZMk*XC9C6Bm$us$E{#)X)~@L6QcBvKn(I0-B~nm2)2K76
zOSda`%kA8zMH{z>igxFAZ4A2zJ7g&9Xs*=S@NLP`5}VE>CrfQJ+$ym)6MVAJOwb`i
z+X8*NG>p1(`*V(+IJY&?D|bhl&%L&_+p4Y{)u_K6w&qkop3|W%vz3$`Hu)~O8MtJU
zr;@J9>41=I!Hm$HuoFp(wR{)nZVNW+SaWlQfd+@v(KW7J+k!kfvppwys!hu2oN>EC
zP1@>c>K5O{nYkVXN4riPQ&!g9X1rK*hNjc%oM7!Nk+l12xzTxPJw=AP(t){-Gu<xc
zDx1tHn9f%3l6q#_+SRGaI#;!xEzM~cxVr7Q#7fI)XKrn~a?)awN1t-xiJOzPmb7v)
zoabGwyE?S$Xxl7}1zo0M8e5W#CiWz|xVjw)dmUb!=;Xl413JTc*V46HPw8qp7n^uY
zh|ZmvP<3nCQQmE<)-KL!dLiV!EI8UucgK^0iHm0X<~-dlQ{N|KawgC1lG&ulc9Yz&
zi(6eK+I-F&nJf`38D`{@w8}X}!DJHeY%ASWp(259UZ%~tu4aO+B7u{76K-vm_GMr*
zF`LD}lc9B0Sw(cS#z|JQv=3`$1ev<Em&E$I=}H+a$?D~Mv1?XO*q(KXORlb5(ssCt
z>(<oSxeqGdNE=_7x~)EI(uQMeS4HOr-CDYZcgnVv!8vE$vWx@xl`>pzcWx9&H=mPt
z>UOZ@E-oK^N6mwW3{$<AY?~dHx!HBmMU9ZKE}ekOQWq1Z+%hZ{Gu-yZtUGnf%3SZ1
zgi}T<W@|Bcd9Mz+w(ag&QHkDewpUBD9yVvMTN#}ldE>^>-oWH!!6dET`rbv_uC9R_
zS7~W=ONY3eoXFy#DD2WzaCSaN@toqezQX1y!5%4QCr+(NX<BhsS!J@-qTZ>iP0j9H
zytd5Hcj~qU%lO#ax0Q%)j0mgTF|Xir<$;U5n@lcTcw}z#?AYysFIVSmOU;e!+pu<y
zZ{L&;eW_U=3`@PPUELmTBG_q|oGBTi(kc2Sao<iKx07N#O<OahHciXON|X*=b7Qt!
z)|3mWVVT)l!kM}=a}y3OxE+>r+wEv>aKx3{Ic$?oW^I$o?cJE0WV&Q=a&C2?!bydX
zj@H@P3Awq`8=0B(rYq<%u`(s+PQSRA$$omkPA1Oj`xi4wP0!xRq&N9O6&tgN*Wu|7
ztV}Y~GyE8N*#tYo4ux(2U8!3XvF+OGIk%%$J-hYg>rc>iM4*!tJT-hS_8N2CbQ1Cs
zzdiT$_UcWox1Psd>@_Z17yCYCilWLw*r7n*&XnGndhGTtugAG}Rm;xqysNzG_D<#1
zJC#>Yf4z%Irao?R_51U2mB-6%H|JO1+w-~aU3J>sa@Df4d*6LNZ}IMV@Ai_Zx6NMf
z)ZUi+zWVyS!n@~lZm)Z?&g|}`@SL>LJ6&aGcfIp^JG=A_Ox5+GaNd2!2IadzyQr!J
zH??ltx&d?~l16lPG<Yd>YbVlqMQQ=FLD#nAP693F1vQL4z{J1o;JR(RSx0l$1YDgN
zEg1l6ovGKeE(rxSRG2PHgSR*z*wS?Y#AjeiV4Tgs$S{R*+g9DEkD;Z$8&)xZuB}z^
zxRo}^FzwPLuMM{(ekLBduxiz++blT>v$##PR;^me!#Bh2Xz((}jf~IV-!K3A^7{U`
zeH{`kp3Dp&Qe{&3nqJY%yR_cST0E(A`|d@a^(vFRZ_cQ`_vH-p&SwIzbGT<rOMLV0
z-OOU4!#3sR4m%fr^8T!5-l>~!_Vd&8^73+<1H9GC(zm(`?le@$IP>A_-QClLjO{~=
znS*P;*L+XVfAr5Z|7zXedyOg+G?F4XIXszI8{ey(F$5iiG^x*XrOKp`+}@4bYIN9Q
zcTdzYSYDrB9<l12N7VV28nsE8x{(4$8_vYm)%pJXn;X=1bJcR~vQXReyIy&!ES{A0
z<kZ?po~G_9tF+$En&hdn{rt@8=X>_-tG@T?r%bdBi^BmW4+#+IsWNGAO2)cI(bvks
zOXlXjdjV=Xe@m15zSo%HUAyfawbaz213SBKUV0I8uD&v6vtE+p<E3}h63?uQ5I2Zp
zYkec2m=w97MY&itkR|Wa>h0FMmoe@>wQl!=xz8)jcNL%eTDkY=nbdpLzaI)^$K2jo
zsBC<5=A_t@Gd3O<ITNAWQuyZF`}_%>W(toDB4?*Is!Y(6n8tMGNP54a;+7fewqJz2
zJUJ$Ls>+?Ok^8={9@NaO4}88a`)7XMp7-TS5kaNz76qnrR9mkJO;_2fzai>&lF5(G
zjAN4}7dtuVoMBe4*?aqYlR|=^3J(*Aoa7m|$t2vN>+8gomz-{~fEHjdL|X~9zXcsD
zv|YIDa<oI&*GZm=xl9_RlO$Dctc%V$<hfD2@7>FmzPK0lQc{Ahn^{r<dChL;n!KMh
z``x|wLglJ=PslL&S*rY8Z$EFxxfOe_Z@!g!`FLwX**?czU(@?#XWp%1ndGdT2eM4%
zjCp*Kr;2{{<)FZmrYa2f-uJ$rt!n$d@Avz?HQVd<dzR0izGv_Ivg@XW>voHsEPK1{
z)-9IsHIqEKGX&!{)k6+UDm2eE-NLaxQe~3Z1*O(LeNUONTd%%MPSOhd?tQ^}et8M6
zO6RgIjcT9o?e#u+^`!BPg*=ly!#5vOdFQ=*;%)0)?uYkXyZ5EjtTIcuKp{i%`xddi
zaTb%V{IZ=e$+P*|lS!V6DicgD&ONCzeUgxnkVA`t<Gy!azgK5(tk0RAr}lQ)wnov{
zDwCXUu>@>9n!9d&v{O*^IgdGCPqM8sR4<CX(|ADT@zi5=*{6P0RaV=b&gSD(nN;Pe
zzUMwuq`u0YNuPe6y}9{#?3U~KWp8|UFfo7o_-=RR)NQA0_wIdnw-X|hnqc&?s`1^)
zG~cz`uD^Z#PCw+n@$vrZ`c0myGtH_XQhsOdh@Pr?vROSX>2RBj=uwrTAK%w`s%%zI
z%j0@#TjXu#JI`XT&$jP&M{YML*yqbV`s(}H$oux~d(UsowkfQdnftD`<M-lOm&HyN
zg6O;5DLanTUObz3bW=={-HT`2lWv-}^H^w4`Fb+V@61sUvn$r)>BsjmlRVR4cB`F_
zV{Cjq>CBC7yW_X7-=)F7%c2782&hDr_~zYBJN;uOU)VeM#D<5Ln|3Vei<kR)QUxRc
zcK-ZK4zMFmtTUWG@c@%}{WaO6H7Csd^R-^TyZQOThIiV}9GCoc*}G@@^wsNkr=NG+
zRb3e#cRsF*p?dq2<Xg9MFCUc&H2LwkkNwF;;p*DAUkm--J^X#jaP9QcH?sHMK8?*z
zy_>!2>fK7+cTZ*<{Ndqxd-Xlv>+hZ&e;B*_eg3LK%e#j@Y_G1pb~|sLM!Rr-Sp9pM
z0-fncpB-;s^<o#}(>=50<o1d%e9zb1yYK6^+snHw7G-`sF2jE^N$uP3+piwYy?gk>
z{tJgcus@Wj6I|rvkgzo^mEUdI=b&xB?rr@1{(O8!t=g}?h~3)_xu+LgnDOY?tTWb=
z(&iW~*{ti;swW;eZF6X7>Xt3j)Fvg#<#Bm(1l4;S%bf<^46;L0MbYhq(<C=zV`Fnx
zl@?7EMNdVL5|2L-7kCp)XQ(hcsHE{_zg#_a+ZlmXD?G$*@7{IF$z_34!jmFTPW~Ej
zMZ(}A#L~d1;3331J9p;xDO?^EA_8k2f}FoKdh!HKN?NJeB@`L5%KBxH|5NpESAXW$
zpMCr<X@$wxRr+DQdwL8Nbq;u{Oga!D{qxV!ZT07jtJ%AE-J5$Ta)!#Z1yR={Ple`e
zH&_|#HKmoI;?}09)ZIA?tWA<7%#Pi7vJhN13mY378}x#zV~(3npc85`qCI-Rb+`&h
zup;!F`%YEO4_vGtRE@NzMuchBYZ`@27E(&m2@Q4ASY_c9q<2(gwTFW0Pfbtjw>h(;
zwQ_T2M|<&{GS)byZEUFK(wv=bsHrW{+|nnIsKw(gku)(;!dqD2sD!F!Q*hG`uGCPU
zGfNK5m~dES(yU3R)wDKiT=9xDoR+GV*l;vZjA2KT#L>2u5o?kKBd&(_EMz`Vuc?-*
zojWOTmc)!@+S<V>YO^z()i@%KY`dMikZW%HIeAN7Hc-Gz{@VL@{#y-EMz(dWt|z9h
zG@4N8a=GPjN|D8qmJTORO(us43@V`O+nGRf`}e#w!xQDsU%R>O>c%Z!o>;a>Td$tV
zA}x}=>uQOL%CsbhY5ey(K2LsoShv13>a*0DkgVN$yDr8~FVI?bJ@?kygbUNOE`G0l
ze=qy}?&tSQ&w}@<gJYF}0UW!3b8~ZlhkwkEKE5%-Z2GE2Uo&o>*y55f$y2qBn>l~c
zZQEn{37=;>xyf{`$z(4+lOdeF=Bd`Us6^MPQa7$@`Z7MwI+-ULlC|xHb-hWlgprUJ
zX#2X#Lhu$PP!mg_cZwP)_FA`eoK)ppn5$&u=_KT3@omwH-yHVb*WK5xOS)Ms=Ggpg
z|FZQ{w;dLYb#mBt_wKbIX;vm-cI8PP9==XOo*bSkiYgNz&W1F0`af?C+rOeSccLH|
zsJOVeOrPV(q`>5xIX!<8<5Wi1>57vXRlv6y)_X@?jbF7Ve|~AohHd8~mM_|~Xv(E-
z2Eq32;cI^P+&lQ(^xBtqLI*hvu5d@aw)9#%?U|_d%Ag6$l8;@Tbi4NZ{Mz@o%jbZ{
zccnpls<v)-PGMlWb?u^p2k4}vyGQz8t=j(f5O0_1^Q>JQW}0_bw}7LkjKfUhdhPes
z-|MSwcciXc9hV&0)f=9AJxY7iJJ!&sx4T2vNC_PU@x*qmO^#g20rDC00O!@{@(V30
zpfS%*P9YZ1zz+j=v?7NqLzI&#V|KlelnN)W5K9M(hY(Y!XTa?bXWu=$E1P)tOy&FX
zsfSf=<-Oe@uDi`s>16#X+pets6x;9j!}r;~xBYwo-0*`DcGpZdCawKG@8_#k+oVJ9
zbc7_V$-Oke<;LwhO_63E%g!n;NDJn=$8f=PhS`C$ceiOJW`+B7gd}ul=S^^#xP2$f
z_I<zKudn@n`u2U$AQsG228Q1`xf?fzKA-nD&HK)oTiXtlBy?}w?vZJF_U=`dO}3NM
zb}U?w7GtP$=18N0;q8r~(Y&kPxo8=LnZ5K-%E^7_s54t7IBmiOWBZ?7TqliYo&FFn
zbwWMAZhP}_rhUR3X?lnEPZ4%qx!v<N(|!?-&Bxw^-eS1Lwq4)@(=-u|wC-YI3sDKn
z?dw>W<AmyG-YK_jaOto8!2&*dyT5^fA$pbQkuYZU_q9``+$M-9G?{4&Y6-G%nRPB%
zC>@^ceg@<X4($^R2N)O_@7FS@RN2aCDuB+fdih;W{n&|vGu#hvJUjCR0|NtNKVP|w
z1e*}2!pfh<UaJ;lFqkl~Wg1PI<m<qEk%3WjZ;07asTJoz<At8DrYsKXUHNOV&qcY;
zWwUG@mMmHM%6+S?e-JZEW=F!xm0nr%CNMBCSZl1`zU}?=!{W?l^(zERTSZr^Zi;4_
zk+ZO?Ywe`a8LnxZW^32ZmRxMYb|E;c?a=Cssc8Xgj(SZp+ot8ac8Zx-v~%Ld(8y^?
zE7KxZ224vk={a-L3Z1NL2a|5yPSw=99cehjHP_3xBR3#7FgG;XHP|R*bCAwev8z2f
zExt;(rgSddDsfffN^+>1>5_V-Oz?iD8{0H9x9J9F9E{pH#nf!Ut*vIK(o7dE>J}Ag
z@imn?wsB41T2X1&Z70LLg)=6p_;gAObP6jc`Kk$J8mdiZ@>NUm6jJl?oaJ*VZQ_zk
z29v#|Q)ank-8j2hJC!xfYs#i&sX1Y%ZfG1;^>R67nzrW3(L|%Hgk_1_dh3%`C+9A@
zb?mB;kjp94EVH#UCZ{xlP4kqTl;gR{x5-&Z$zvkNNnT}-q{wY24X3RVHM!)vMp4*1
zQ|YGCNwM21xq&H4sS7i7xtfk{(bbJqTE#7OFqyS?ZAxzzx9AozU6Ax5U56_NO(t=w
zoSZ0R>?!2ZIdPMc+eIN0m-^mq9g`E4T_!4JoK#Y|oza<-(=l24`7|$$O&V8cZR}E;
zapT5~Yo@))5jU=xfyR;|W@VX~nRbO7TO7Dz+s2$|v5V5)nVYutE?uU%EF_!9bCypg
zr?A@OOtZ<E#^CUnoN4TlGtnr?cgZcEOF}opQqsJQf>zzwCU!VgNpnU0l`K=KS-la-
zfvcr6I=!@|%yN#pZUv12_5?;O+PGqy*%YNkTe}XfxVBYsiIk&~i=wheCa>ZWlU~Io
zIhRzNgrt0Ra+h2Z3iI76tSg;y<iwPj8Mn-O7tGAqD78py+D7LvAC-$HvvRIvt;y|}
znX%&1S+}Vxm#oorjE-99ETq;my+n#xwqDpRXp(R4hu#&vfzpB-r3F`XT{GM&vF*mO
zV`hd)x`KhdZn_yKuCBN-QSC^l!9=x7Dz{u_drTHmow>=SXQHz0Y@TZ;_UKGm6zVCQ
zvSr2{GvDn~6QgEK^0Bzl(W2_Lb$0ZzgKMOiv%FI#Z3=G=NzU>#-FnD3x@}9+El;y+
z->&-9r))@B&(^h|H&SKGv@2U869t8MP2EB^3JNx+giYGC$;(s8#Z%2?riDP$-9u3<
z2h~<w=w)!aa>YxUcfq7fUf!N6lY+c6Q_eanX>QH+U3ANA+KJ8DMkjf0w^&4HiJW!n
z+02%-c3WCd_m$A4LWkOPoF&vGJg&%`$`v;1wDJrWtv}b~7ue^dHCa&AX-bEp%8|}D
zURPIV3A=K;b=)$^*ciB2v}>*JN{-2%OKv$Tx%5m{@yKN7aN#@3Gl4Cn$5VhIU{lDX
zQ$e08(_A`P16PL~nRM_}z*MHFYrA`!Gj5qo3RPVpbYOz&x^1^}Z|C)H6g#@&%9Lq0
zbvNg9YJ0R!7V)iDRoRy56(p$hn5SCe4rj+i!3oFOR-Ik7&190fQ?JjJQ@K8wEUhz^
z7OXnVu_0wahRC{z#cpd{9m6I?wxyg6E!65U>1vmrx;RqX&9HaLro3D0(;vTo`FsEO
zkAG6bZeQD-$H1Dq>DTStzj43sSKoJDUozGCl=fY=Ntb4ZP1b78%!)p_scp?{(KKG4
z*+OZJJ(o6_T)EbhG~t%+<e;Q&-N|8FmR-5J*l5|cQzog|BE}xaTrNk4Mn|)5xUqI&
zE?0ZezNEH#n}U`ziX7l(T$&4rA<&{&UV8W1*6EIJ%sP-Uoi)r%9@Fb&nWdSML#N-<
zWs+hSw^*H5vO014Lp>&~={NM5T-2uKs78Yqw;Tg+QUVdkw}64S03~%!kJ-hfH2uH?
zCbs(9&%b#HvGm<}H}Pujoe3&s&rAAN=RE=Kzqy^8ox2ruY3{!zlUh4_9&+|PO!9O(
za;%^Q32jtan3QZ00cv)F)R=AEcI$!)Culv5^}2^n!jgwzhKO4pFSp*k^VAo!FVY+v
zx81&QBV_yf*q8N>kIUZqoOZABo=wH$oz=VERldG=)9HKZozK_Tdx@{!J@3o0g1vXk
ztIx-MJ0-q*-Sc^Ss{;1kEw}mlK4)Ro?%nsm(y=9A)w|cduY7%dDfiv$<$J!qzSR2e
z_3nFBUtc<XFTMNTw(85ms&}t<Kf8W@zRDCGpL7nNbZ#Lp@t{-Hmn9E<jlK7MnQ@Dn
zaqFw^dkyF4hnH91n{iHj^{#i-m%PMRzV}JzzFKbkQk5HO(C(cOq1t!5-u;=vur+c^
zwi~D*>Rq(eH4HSIq*~7csv+Unc6PVZ6$npP8N3;dfgvGE3^KyRz;JT~149}EgLII_
zqQzOgsLcch_FYdL9RzNPf`y$kazX7J9xbT_Amch17_uftgIFM}!WF=@a03Iw6h__p
zX<&H|A(qCK+d#GOwk(i7mPP{shMSubv_hmZ7*ZKb1Fx-+cGcUYc0m37+MT>cjDP%J
zU+;fh_RscJ=GsT6^S9mmzJftz5+6f{1(U)9j^+j>4-2OGCX*(q-I{yna;%bn?c3Fn
z8ypyJefqxl)wCP|29tl^_rAK8%fwL6_Ae(Rfx+zhc_~j7p%%*})BT<;n4mK8>y((O
z4pXG+{bp}honZ2}ck$Y0$47F)-p{}Oel_c?f`>p$OWVZnm*4OEU9)eZO8*N621emY
zno5&Q`uD!e+H&oC^}Q>H<2+vMn|Qcw`qP#__vg>PC-wV7_?-0T4GheeKY#l8!?kzq
zwtG7D+aArztzcj{5^?L%x7q77mt7Z4&OWBN?D|=ieaSvjnSGy}IZwweaE+Zjr3gA$
z!_MF$!zfU|;&?z%MTSxAr^=FEv*qO`*FC=9t+cw|x$D)n9F{+O%S~s06nniYa)YqY
z@9RaSTOZ}^+B(}o{c|C2hv%PlK^{w#UHa}`T~_}=YUbXnan*NCZ<pQ8Utcrl$m*by
zMNd|-3v^z8rNhuLEAGxThl7=6GfI~fUbDKPrmt98^X&IN;dqtfw?F}r<Qczy-|yQ?
zzkU1oY4@)96AV_n8<<z`U=V+?M|HCGdeh*0`>r1`m_E@uKPz#)a`WRQeR{D!f7aWZ
z*-i4ToxbUJ{f9+O?GG;8_S|2?AUA*h^!~HA-&f7buGn-V+M!crk|!iK!4a#{+@R!X
zcD2mu7E9<&@VL)|KhtBoQ#`fd2V(o?GU=<xFbcPBtNk*0(eLZmZrgs{zGB|@z3)Tb
zPOrYIdUjvPCQpSa3YWuG)$aDV-SRZc6JRo%m8G?A-rIR`@AvRe`mXjq?)!Cn9fkVp
z>BXNTCd{jQ`)cyGTerV2-}^qFVIL^<GO)hgxk|xpcCL@g@>WH=Uw^-yK5_ca-gmci
zbD6Z>fQP9#54NsSG-P4UEz_N-TDWbQ?xe@LWxA6*)uta*W>%<=t83jGe#x)<+U={g
zDlhh}j1rpso|$2O_1>3<5(=*!e|oa>!?`x^UHd(z`|g(L-7+ahfhE`E%BQbi?z7Zq
zS9u=T8sgFsS^d6<mGh$W)2Dj(GQF>Df6w%Tfsu)Y!^6pD@9o^R3tVHtLwI_;r8l;@
zOg(mM2ISmuPzdpZgJ^H~+U=`;-4dGoe)?NwW{LW`Y(`DHAGVXcPgYi{Y<12q+nqi2
z>I3IYmD}#SFJI3s+IBPa+t<u|CTVx?Z98M*Sj_rneRXKv!;z~pJL7xBx4q%TPxn+-
zd^%afkt>sZHIch=(wy7TC0z&eje=)qS*n{|yQ?&*B>eL6Y2MGgigR->X|wL($d!q{
zDw(@Gb+)Hk{Vm&jHgT(WelqgDeeBcwoXr^z_6ANfH+^|`tzpib+c`qt?qqMwnR7eu
zvDBMrb+g<2xyN>kojkkkxu@l}jUdBL`sJ>80=ClgV!Xdxr2b6Jvs<@&tP%U5xTSC-
zi?a!*;uergzZ9D;cRfDw>7GdrZ5NLn5#+h7YPoIO%X-nKdnwD!t`zy@uHEIT@?!n+
zex2!OraZfKdr25~&EDNxm+4NPo!b<5ySEI)xRV^)o$~B<;@ch9lWtmWyB&Daa@+m9
z<=dxSd{msfZSkby+<o7kteAfLUfeAkzufJ&SH69^Y3<r0g$Z)rAm84yy=N=qYr1z&
z#piFIK7BiF)>p6GolvPeEmy|x#Wpc-P^e~C@2M(xz4J3aUoP%mT-+h)=+3)hhfXH)
zZo7SZTkn%?@ddmMcHggW`}OPglj&F2*4F0lkT%biKAF>Y@kn6~zv`y5OD5;ay_f4#
zn|1G=P37;(%IehF?t(`**sQ;9{P^&_yIyILbJLc+ni#2n@%W4S%#!X;$NsZSpZ$ID
zB=eaM6WkZY89w}YoOfNL_|#yAc?TGSPU~#+QNN^HuDT&~%L&k)2t}44PgRM75=%Ok
zbS!CRNt&btg;lpjH?Fw0x8fz=NB`WjVTljluuV{Di`lfrQft+gP2y|!tnF0$e|6ie
zT(eo(KbJk2^5gB6`Xe`&sh!eHnVJ&NqqSzKhfK(nCG+=sdU>{nE?V`4?{@941)6J%
zGqy)9V7O`e{q3*&+pGJmDy^fGx5rm5`NN=UyM2ebO!l_7$7PjcOv+hfHl0+-F3+p@
zygRP)`SyALz7~SE>p}(|lw3g7jq>}|(Y0Ay*YE0Dy~DF9q<)QP;FOijN+EMtgC2xN
zxVqfn45^%=kjdg;=d|iuYv>bIuSZiAO1V~_js5g3)pBvhvu%~H&zsNNU6!9QX;0zF
zWX5%q9E_e$T~MOPwQ6r-)vXfUh86}z1`Y=%K_Mj<k4`})PbJX0CHZyRR)@yN=bwN5
z`paM2wV!XlSad-6{`2}<>$NJcp0;_%DW<W3<@33#aXEnr3>@#~pZ-37+g(44$GcR%
z&h}CHHajnTdCBA6wA(9>%apr)EIDR2+edxN?NW=!eJ`eM&TLuI<*8ESs^U=4!p`AP
z02)PXVdwBkhq9r3m<0E?tJ=r&<@Wuvsi@}<+pBGMHPdqCrbnAO1ZF2?fB*YG`uqFB
z<NoT|%DoF2*51Ckr8n=vox*jux673Dw{hw{ShZ%8&$V}V3NP6Sz1yDh0OVQdNFxI@
zjDLk%KirVUc4GTCjw<$?uMaKE8V?A0fBmJ?Ue}eo)9OnE`zA4P%6O&T=e26BPV4J@
z?F2>8SS8qij)~xjFwVHgi65k$g{Cak^qOvH%d9^A{3J%P=>@Zy)EO^<SA9w3ZUG$)
z+0oGn-6!t>;cf&C9w|)^xWOzu{lE<-h3Q(MY<$zhB$=eryrZsq?6du6TT}HT`ttSl
zaeHgFZCm|3`(5<iJwLWR2-&{r#@=b&mC+20oGNO&f7boqzP@V8(&;DPoOqni&6(7=
zeCL+x{DQ2Y*}1!erfgbQl5ka2Mnq`Unw`ecAc4<|mVORDKR<uEycV-oeYoE4b;Wba
zi|?4(Mci1pQE{VNvbJ>k!N@1Up&|3`{ay8G(Y(?fHt#%>x*3?P7kldEfNnJuyleZ@
z-t1M-l%?AzRr@Xzs`lNkogb|`<yP*lX{Um2pVY}U>|J)5^R3xk?^L~?pP#RO`>l50
z`E3gs4++R9f(X!XT_WQlVM(h)0x}>DX!tG>N#@tOckf>R-!ET({QBdM-?#t$`@jD2
z`Nwa6{oNOzZ+HLvqqX~mrZa0ZTh+f7ZM(&C>A&Xv=l37xWuD!hH`!$OF3;W3puORq
zRktsB>PP2p`_kmO=Z<t!9;ZScZ*#66--K7eoIc6(45l5(Wb#Not*yxs8oG4C-kha-
zPlDRr4xrrNz@X$XkwHL_Ew|aX$wRoR<np%sh)H{wY9ESTGbvN$>C^|hk9QT;htAb`
zU9r7OW%k*{i}E-RE?4ngyY{7Z+SOg2>gp3)w&&ixd&$!>H5YVbq}H14OJ3(r3ath;
zBN>oE^_$$Y+l|?#NU`0TVfs#2vt^m#c?s_XlSUQer&Fi2Xsx<*B5qsIy@vuSoJ=lE
zAcBDjw8C)Wk9xcL?dz9cK3)G=M08TB=@i#;lLva?ve03u?gj>iVDJra!tWL2)s6*B
zV`JhFXyH%_3Tx{~odj}%$PZluP(zz}kNLj9!rdEUc$Nr(b{f6;p;MdO&hw!2vz##4
zy*-8#SUNlvMgICrg$DXEGe|Bu<r%_I&!B3)YDq}OK?z3nRRJqJOn6OLRW*IhSEVg$
zyWp^LrI&wJ$e|>IN>9D%wZfThTepZ^G+SycwmL02)N#?;oHJp~ZdclRb0>9eop52z
zwTs3|X<kOBjkt}}Qh7F=Q97-2XtmB}El=H5lasU)r8%R6ZbWPOw)C7@awafMYt2cu
zQ}vUxM7KI;b=}lmm8)sCqUWgROr<kZBd2s~+`84Boh5edsCITL@1h*l1nqz;+FT;X
zuB0YyH8qx0o1E;q<VNPSq@^>{LX88>*ivV$ni4tN>C7!|<CG~Ab2mh+cHPD;bvvbD
zRn~2-S({mnRxIY}n9M7v#w)0}*~LRD+StY8STJXO<Yu3n+*w{X+O9?}o7SDFoEa?|
zxy(@IOd@E6N10bG=Tb<rnv_RwF4yd6g_~iQ#13cWtjY~pmO9fla$1Just(;1E4Q*;
z+NQBh=$5Fl%4*#vpM$DqXD5Z3t;$MUm2lP9;mQ@`6t{%Xo;0m%X<YA@UAi5yaWQD?
zO>)Gd%oX)FZd}tAGs%`Z+ADQzqswLKsIFeIqZ<Pk-PoqvoeUc(I=XSim8@gkA)swQ
zUA<z*Hk$OT?AVk$RqR+;WNv7a&t#LCOEQgoE~SAOXBCxFj?DJlGINPZuNr9l$YiEk
zrm=^|Oq1D?Fd3DbYKL4-O!hca&$HHTad6n;prc6}Bep38bsamhRANn-PSVDRML}!b
zj!GQ^tzKG_Ep_acQc%~?-eqU9OqXqrmKMpDI(Ag**oKpvu5Qu_)6O{&?Yd3nl9aQ@
zCGgNv+k{JI6O{xeT*_4vnCy|stL(YNq;0}P&dn*E0xfNmJ-6Iq^6(T{J9SfiM(<+K
zXw%||Bd1-H%z78Q<Vw4)b_|SIBP!Z;G-=~1L!*lsH`5k}HZ9s1p|v<Hl{-X(rPIuF
zlg~u8lV+Zqd?)2hHksveagvnFY?Yg89+OjMtFTS>m}N3$YSh1*MrO)sKD`|`K*%Lm
zFz4jNjnYObIc}?cXB<1GbF(KWxjtE1;>J;zT)~WE7kk&5B}+?ePBYxtwOHzy)@_}o
zQ+$_rZn<dUxuw$#GGsMlqS{Fzvsr2&{$-boYL`?FtAJ!ZCT>)6`#L*Ep-snX?bL2h
z)!a(ZoP(#Qr&sUBt*YBDE;{PAQp<OPgr||Gs;WdquEYr!M;0Tq&GqJyD`&YSzYtp!
zEEFxaXq)fqR*jA>FAIUjHOZ@1c`BQxB}KVylAN<txV2|ZNTcf7+&yc<a&vQEi<u-D
z_V&6;96Q$4G0SbT$|V(*TRsnG?_gk=<f*qbXI1DVH?J_Q<w@F8bGOZE4G5XJWvi5%
z)Rjrz-kG{8Q*}-EBpvH<Gt;U!>=v2kbuv?Dns?T&sRx9-W7)hGNp5+~byji5j#W$U
ztlhfYaB;?wh@;&}izRO9M43$U_RLkCG-*?`XI9FICM72qUm=wO$uE)z+5$6;E^7;#
zO_r2QOY0F_tjM4;YgUVoVk3u{+2b{9qo(HOY+IIcX0y(@u2r(4AvRa}rWm=2d3yUs
zY23_6P7M<k>^e2=Rv6dOgf(HjYfWzIoL#$MO~}-qq*a+)SKQj{DRy?6?$j-pnSu^3
zN;{f$W>wOLWnnjtt&zI6HvVXI*xwt|8|xUArW>#@>3|pgh=jt<d+CLp+AMKxI%6H9
z^7MJSOhVk*;Bg=j;Rd>PUVHL`Dh|+5G{N;EUfZNVgGR>;JHrmc41t_Q<22#c60?=O
ztDLhY-0<3lDwixVHAgk}{{PqCK^Lz;?p<+8n*pAm1dGgE#&ZUCNekqZzCEjVt&fi0
zn=iI4yj(~&I`1Xlt=n_!FIjE7dr8*p?#XcJyeF%Bw-<#TyS>wS+uH285Sgvpt(TNt
z1C3T~dpF_L);;>R-`-h)7A?7f?nYC~YzD1c65Q1Kde70dQ_ID+o!-5C9#~3IS|hG}
z#@0>i9^Fe#`dVII9{T+8NmUL{3yzykx!Jk143{NJYxpLu&F#49l-83u!&3u#=~+O_
zq}KQA)_n%KQ*7I*caJW-T?=05w99$*F6Y&`cNMSZ-c|4@yS3eVNojPs2Xq9j$@$~f
z==d#JW}y2USKKn~4qS1|R5W924rqgvTYbe#2X5X43=AB;3@i*&7#uhqK-6t-w~G<*
z*{7P94lJAwf&y!GA!9!b3@j|X6C)TH7*rUyopoCQ-FFPC2pJd{Gy@ozbC)jK5~T~S
z@t~p%j0%wf3`_yc-VBTk4mv9s7*idXbGOw`mEANk$Lnp&ttonCf9uoh^WT7$C4m<w
zIUG=8V-zspn8d~?<jKs?_3OkX*AkA#2A2s2AaYXlzTdmI&CcDu`}O<U`?cFHzx%Gg
zd+TiP@2cOP-ksvP$7S{r&#ilI{rsF)KI>WV)m`_N<wt({nfolXW`4I^&Cl{v%earX
z)lZ67+xPo^$lPsrF0maD`u(7D%gO)tRUgEnD?ppGZXbxueYO7J-E;5qw|n=C-OpFI
znddkA?Sqa<PmX@S-)U=KcVnk?oS~T6j_sc7^zY64_OaUcy2$11V@k)aHykm!bvyTg
zq1x=6nBMgg(>>Se@3npVG;W{oir~Z)Z7G}2_iMhhe0+a?$@IPHOj7lkO1nU7m7pt@
zbnn;Rz3sd0?wv2a=HKtv#yAP=yZ3u)_GRyN8R93B@=pYLA6PQI(No`S@9!<|-b)&<
z*WLBrc+K7-zm;z@YG&Q*)ywd8Zu`0L7aQ}Q?K`iWKC;xuX3sv~>igw~{BB?QsnT*i
zdzIhqyiDfgpS34M8iiDUyM1*KyS0LWfgw5<#E{h7_4+_$?gIt}rqlV1soNWjf*9%?
z`T`w`k4%31<mKf(tB*XteX`=YcmJd(yLZ-pzx%y*`-A%C57YOgGf7LJ`b8l@kfFG~
z>25dL#dL++Hg3^Z{eExP?#tU}Nk4mBXzFFoVd3QDGv%}U9<@CcnNHlNPgM)^6<X^)
zxxn)7m#2EkB)?yt>P()hr?aKJs=N;{FtAR$$8<WMfq|i>kx%tglM?HvCK=D_`@&m(
zzg@#Ge0*>1W6;113Ly#`tx@)R>{|xnB&TSIPoMalNo@MQ3?_cZnA|nF+;?x=yWF4i
z`o7-J&z(oF2??>NsGO{{i;HvnlE|;G`LtZG<?W^W>bYA_Ut6BLy@EmffXcq7cXpQR
zJ^fy}ce=z2Ci(h(o4`w%cHEA*`DE{H%e>_0GD}rdPM_cV_;`O+wQ$w#tTInVy^}RN
z^<wsYu8v()ool|c<auqOukh{6OHOw|{OX<Meo&FUr<aE=-KD^MXD9f^GuVY}<#x{}
zd1`(16<~Y^xl$~SAr^8cTKyh|o2p75nBL7j54v>>bU7O9<@q*~);^l0zU^}LbieZJ
zA{TA9%~jF8rM~TQ`R?f@?;s+x@9cuy*H(H=`8#Ow(1~4-1%F>Wo7tTbTiEgU#j`C(
zH|gy-QaA6Mls<#r9PmYEaSS<=CRQ+(`#rz&$rE&O+y|!mm*6YeTo|gS+g0jrt&UE6
zc9KbfdGDRw^C1_hbufI_tN9fAXcj(GUY?)l8TJu;dz<@vchhCM6S2F>c8=*bmx$_%
zPe50@xkOZ-KU_a$+lg-eDv(_}mVuczQ+I&wl7m>P!1kt5fbrhDSZL@#+^O}^SG}?0
zCn$(BZFqdIGx;+M-iHP;T;e@LyvolftFO(fKEOMP<$HsErJg7F^0&1n-y8HN)qDzl
z?JK}o4~-B9-kVsw9e=&{dtKeT_vfGAFMhIU+dQ*9(Xn@<PYZ7QV_P?W`NMsIfm@$V
z`rc&I)6*yy$ljBDOp~Xu$0lf@>4uP1k!!nx`9&7*{r$CS@4dah&zw1P2Yi#8A*lC1
zbLPw)ftv&tr_?LDodDhb_R#HwQ||=uWpGX+IsLEKiJrZ3)p^&F&G+_1Z&;)xuc*5#
zH(xCJ=vGeYt?%bmKfYh<xAzOI)CSZ1&$G5>UAz9#OG#&;pyt1Yf|{4^*WRxCxW(=A
z(e+a6-d+2oEs!B#*2v_^x$pgY`2+vhblw&|tyk1|HEBUE6WgWl+Y28bQ=8Ieu}tS}
z0TW-$gq<o2yMo2ab};XhS$%&C^!~IK<y214>BF#E5`OwH=-N@xN~7l%&&?j5EBwP+
zp|yOWmRxJdkxA3E1Sfe-))Lwgq7lDCh*xOJ3hPM=A504R;i=_cpHcPe(}Y~dElWE0
zzr26_*Xx^0wsQQGsC-@e=yZM@$JEf(ck|=Au4aI}h#>f%helnE-<!MY&;19WE3>%Y
ztvzVHgJs5oW=96WE)Ko7TQ4}U@CY$DaQO@Tsk4{%-R`TYlHE36>fWtni6d8DILib>
z#OiAlG7Gz)oETGRWe8av!oa|Nx8Zzr<$Lq#ms&Nq?pssqc=zU>FilsDplv6&&#V6W
z^zFxP>zGPcRatihPbQY@oc7h_a)zBt75g;1tz$U3r>hDDa%v<^IXZV8OS#4rp<9|v
zswzRQ3eejqK#O{&ms&Fmd%zZFNo&O4Eswqa&r{`6{H$uXD-%tg^e$QQtL|^bc0-Ap
zmUWM_D>mKJ&02Bw-JYm7VGzd(K|@9U*V@(78`d$2P0zPw=7*fi@_r(tjo?jC^IA|)
zI1)-{Pk%U(Q3b4kX?EoF07)jp>AjLn2K6eA5EV!yWc&t+?9APEwJvvW{IvZUE4tJ6
z<SssDS}E1h#4<r4)6o2WiRO<#k+*(Udb)?qX;k5m%D#8^c)!FfHbbAtTMsOYoH}=a
z1H*cv^fiq|ot`2pQxv5^Eho^Bh+zGu7BC-_q|S0@3QqD8m=rK`cIvW3m4!80+t!~w
z#Gou95cf5YgYj;$DvJ~cLr;KXdG0#Ub!touK^1K_HMwSYP1qJ(Zo9s1#xX;q4#TeG
z%xy0hSSVyVODsRX@BO~t=YB7G2AMu!@PLL}U3PTTdr(k9E&v0IW`Pe2WME(pU|?Wt
zu;*k_a&~D{Tm)H3#^f+5|JfxglLxb!d_9HZOMl0`xfPwcRX=Un>-A#M)l>Ff*%NtX
zPvo`l<@+jM-?v4}rCWDy6<eG&Z}0E-++`vzj737XmtFgqx+gkdLj9Di?{T_|L_$^W
z<<3%@BHWzkF)Q|V_TAalVluD9oZPm@>1_M1t;taY$`hqio`!<w?7;4Y68vj-#_R6%
zWo~wuy!UqG<Vx?8sTWgJvP;8mCoT8X;kx>6Tkx7yA3)=w;2Ys4fR0dMU~-uFZM#s0
zlt;a^r%dUcSl5XRF)iC(Zru}^FFw`7%d~pE*hMa_N%_z-U#?zq6Jo45qK|Rri@wc|
z02Q|lO<YVX7=jZH=LjtgnB)}}EdX*`4Flg9(80~$?@N81n_{z_Z7y%H0|Nv5ok!nw
zo?D)j=X+Oh^8qOQ`I9aC`55jR=QwfAUwk=e)nWz)lVek+tjKjZIl*h*SFe?FlNES;
zRK5mrg0|wZXl1Udn(D8)Wu~ozsHvuweNdI)WR9z>bq)KU&WZ#>w+UXMX_<mEx!fi$
z$z)h?F#!y7bB)EW@k(t2tu)y-bH&-n)ux<b^#Pe8(rUAOmqC%wrDT=cxh9v=GMA~G
zRm(K?oXxpxLT<Cylr7sp%TaDeOXqfSOiGp7FjHdLp>1KOZu-vFHoKCxCTY@ArBtb{
zNwdM@BHJblCHZ)6%T>FbDX8MnlF~NWbIBPY1FtEYxI{F9)2`f3I^lBKZOfKxz4ck$
zu8S_N%@y5dwkCANCV?%d0@iL8RPmU}<ft&g<K~v$Z4(!HOf*U96p~P#ZMbU1n&cFv
zOtC9Ve6^05N?b`=n=BnQp>x^dh}&XEH+uVS%<A$|HQ@@_qRY#0Nh2s*R7|%AytwFw
zc0iJ|=aO40ox)0PN0eMnn9TC=TykWVTRo@A>?D;=VKtSrYPZ}bd-ke%UAuN`hF8mF
zPpM0SCR!(@RdOcgMk-yqs3<hGGsD|CAmXa7PVP#jt*l+#B4XN($=Mk?VT+tRdZRWc
znoMMwXq4hIbE1mJOcg05-$g37lpK^)axQ_E7i9_x<xUi0^b$E6aYZBS#<8`FPG)r6
zt{1x))*ZDhSaa5ftQ*0eQ`=NLRMI9(IVwzM@;R&QlG1i5?Z(>3*%~>^!qS41bJZrN
zolH(U=({28MpERqTvfwO8%`}-Y_xH9MrV%Mujo{fS-xu1+}0e;Sd`h@+tqPZFu*iz
z<Cd0|mYg+ViEDgKrNxeFB?qopxpC3dR&6miCF6R}Z5|%If{RRi+9sQ{fd_#+w=}uT
z@R%%Y?Ay{gStwUIlhb5oTdG;uQKi(JKyTGaYNFc$t}G5}x}|aIro^;Mx1!yY#e#ah
z&MwKBoaCaca$^GMWGA&76BU<uZt2{n7M5yu<tW>-Q#ZHfgz>7S^ls_#?5R~v^vo8_
zaSb!9UuBq^EOvF}HWkm7PRS)6w_IlDR2!sTWzD+nsTRkiW62c2<Fzhip)W^}*VVI&
z(|S54WNwv|HgQRa%vIfVDbmx^%Trg=Oq%VaYQ$}~YhK%KY;3wRWtNG@27xt^D`sxk
z;+4`damgf?iIbg;Z47#6URXQj)@9A9vo`Cdd8ph}&a7W{<I{q*zDp+97<9N99rjxE
zgjd65EmP1Ehn)d}-6@l{?bztn?HSRrDpy%0lheq}wXKTh;x+-vH7_)$cBRbDOqGmI
z*}$uFTRI?ETjZqK<#qvO-lMHtQqc*yFN}2(bMGokT-nsI;-YA;l%d;Vk!-D?NS$ey
zR6JBp3gtYuE(xul#H{7YDZr{TRVbrVWwNJoukoszt}K(JJ6tknw&dI{_0HPb?U=Oa
zK<=bXo>I}wg*^pl?oPStDs}9}hFobeoh)5d(;SaWLP9wnmpnK5Xs$Ne=)0v?K|43v
zWJd2IDU%kL+|8A@rd(C?3{`t<a&g*i?_MdBjNTR9ZpV(~_V)JHcl0J*bX}aVXvP}P
zNhvecJSKAr8Tl@`<<h$(m7`NrJEBuNNlDFtC1T2wB}<l0ncQRe+Mp~o*fcC>lH-=#
zP03-mvu;bd2`=8)t(_e$)^yah;kM!=k4t4aC){o;nHZVnDCf>uD!lDRmgMH>=@Q3G
z%v@aDG&k!mxs+)#Q{|S*&)D2;H{?S@89p%8GAKH+P8CR<5ZRC+;Sr!ZF*3nTaqZe(
zp_|Ljcnh8J5Kg(eIN5dE%xt!+nj#)yOrc>4nMnc*x~6m{EmdOa6iJy9#i|*RvXrT<
zbt#L(-vx{6mQ9}iK$l68$!yj124*H@#%<FDjhIcRzt?3FVlul8IwwbY@{uZa#-r2y
z^qJJA7o20_p04Q5tTg#S75DTz`b^rfN8BI-Jw3@1M^-0l-SFBb9CfSpZ(R^*neD6n
z^LFh#JoQ}B`>OA|=a%OzERFlPHs^csy0=sG)>q%XE3FY5xA&Fl+Ihw6b_MLdxA)!i
z(zWxxzPG#{s}cJ??tAg{x$ex<b*ArqU(G(xGgQ}W(%y2*bJjb98kOffJw07}&J)NY
zAx<WD%hS{K!Yxmpo1Wmotj7H^ZuRwRSHg}4uDSqPN246c901yG#UK^Jz{u;I1*&=&
zqQFa8SeJo%%?t-NZD3$vj&v2t1+5?j%QG-Aa65tOdmaeI#KaNQz^K5$7Qw(^uxet`
z(XQSwtp?C3!eaH-MFA|D2@FjQ1|p1&nGp;Oj6n++Kmj1c>YKp8z?gFzWaI<^rn8`3
zVNKFn3=C1%ZaogWxzAJ2vwr9A-~a0EFMK(`P@Vg}B6r*E+?_>j$KHla*T~7c>Zvlx
z^WOKpZ_cnjw@~~2?7ef?<VQ}w?|t7TrOLT`_mis&&C6@*XKi7h6!IZ=&vVOjN$b**
z=6tWbaeS%vn{#=2R>2dUADUhE-FEx=S+(1-Cu^oRgBIJ~+xx!ydZ_Q+dyN}~4zluU
zzYn{evp0X=?VJ`xuI=Zaf4utX`|7&%^YhKO9sIa?eo}kmw+Av4Ufurua{K)Q3=GC{
zvqeFN(mH6L)A`20^|`*^x9fK9ew9f-O?J=v{r2Pc!<QKtZilLXHfqHz+_*bb^_0}#
zb>H`x-Ok-V$<tHl-Q-%`C*@Tc38wj-$2@J{{_MPHd-i$x!bQ<@KfL;Ld-uxKdF6*!
zf6jZiY%TkwNY(Gknkqrockc$RJE<~#_pV#lFP)mt>6vi#q1i4?|INP3X4T&kk2|?F
zI(Pg1@}iobpFO|dEuY5F$l$<Zu~a_qUCgh?pwKU1yuEv8?#A$$s+yW^W`^6()?C*s
zV4e(GT+Bc3Z|QoI2O)hC-@b3kseP{bKJnS~x%r>AUGe^Ow0XMtR9i16mhj^Dcfa4e
zefE9zz2@8ykk>q6u~ZL<CY1?yqeE3sF)-(bOxG~G>RHsB8`A9X{XnMvKK1D#zYjJo
zKh=MqaS21+4_@{4^Y>)#`}khC*x1<E=>JRJ=iw91Og3~3IB_#-W&YB6nzpr-)i27g
zuJbzg0W_Ay{DAoZ(<YUjC+}>#a3evQhjH8LTn2{UC-U!=8*jT^pZ9K(1NR07{ds?0
z?RGv_`Fvj4$Gnos_g-#(X*=`%-n-Sa(Vd0OrM~J7mx8MN*XgeO^l0U`)!Qm~m2+>~
zuu7f1Su=Ip(!`gw%f9tJ*I)YCrh3UF@4dIrE6!9)YFgMAH@UR_zVou}3a!Dht?%1y
zm)^d9-MvubY0<C1(+l6*s)~M}=5%__+|#+dZHyZZNM~)kz`#Gr`Q*#}ev@@4A5^Qn
zcw={ykfFr1pYQkE{(L^~_xtQA3~aYn>ILMkn)H<I)=IWnUj8xB!EeKJa(Ab%d$#ZE
zOU>(*PmER01cVs8Gc?{{R_k9MX}$Cmstpsar>8EQ?)mtVr~0L;+Pmt;>&xSIuRP|d
z(!Txj@%80#+ivG?4{l&qF%#dtKK9CE6*Jkg-COciCVBk&Rrx)3_wK!KZz-_86mmPh
z?%v(Sm7%=vm<_LeS|vRrL;4N_<BV4faTB3p9ye}pt$)G$SY?v)?U#@5mc4toSLK5_
z$Yj~Fy^MPpckd40z1q3hy1YE!_HLB)%-g$nSH637;m*0ccW<9B4{Li?*0`r}#_P&Z
z-ZLh=?-&@)lrrdhtZMttIOBDtN>25}GrR72s!aU)<?~~{mkeiiHHa_ql$Lu^thaq?
zz`X~?viVvIced3x?mfUD*|&i8r6^SJ-Mf45-mT?5^Y-rDJ>N?+^3wC(y?u`Cj!Efx
zhk4(~R97$Ez4367k9lI-HxHxq`Q_X1Ub=hZ;oj!{{F14i?TXo_JXQMFFP|@wmR|WG
zszLVoN#&%(6H%Wgxm!!md1gLklI0}NnK$c|Q_h#qIR=teDc-pATymwSv@oC3^(m7)
z<>USB49=YU{9r4C_4!F|M-ETe`cx&y$C5iP$Wx`Z*5=1yW9#!xR~X*gLA1>O{C@BI
zf4A?>S$4ENT075Wja}T&SLJ6}9)BvYRNWFgdD}ys`HN!qK6~^jsitwqgguKKZY;^G
zS4`chyXc6cd0o-_eLv5YKezGdWODIf=wx!32qGq^aLQdXO-|bSe!2EJ``jSmZS6YO
z&ThNsl&z4rIybT1@7wO_)pyREIro9}{|bc_tK_%mZn&M(+sq?B+aN9Nznj_FZFUdj
zCHK#^e!K0}ro$(>gqya8dN|Y-fBgC9`_7f;>l=?WFYJr4lP}ACw&&XR3Y}J_CzCer
zYR#C`zxatxCy%(wnxz&sJ&*lBRRVbH36qLTqk>0J_@0B?pB%H}oo#-w$BkLaER8#N
zo8czroZDR*9INUT8niZaDRFiGVd}Eq;K0cKWz~YF`3vfWc(pTCfBlWW{*&QkiDX4h
z(~SDw4kxxF+B%a~r!p`xFs5!h6*9g2({vTC_2-{ua%EWG33z5RVROIYvI)zYjTw1B
zl+pL%duQ+ESL|-$shM!h=CgO^w%tAsZPzn9@3a{<x|taE+k8H6^Eujg>#Za`4#S@0
z^QIk3@>ErVT$KxvhAF_irCX*~TQl?3H+%r!r0Mi;)z|9#a(k~;eX&||O)g^3vpDw9
z&|b##<@erK&zkc?#`lr6blKXu)6<jpUA2+m&SlVhGBwL%@rr;Ni(e)>+p`PARaOUH
z*kh6_8|W%D$;s2{NY26}Pp6wRXU=Q^vyS9|_dQjMOfvJ-sHjwL0IwUi`B?RdqyB-Q
z{E9a#odVkLZ$0z-{I<wlp9I9_Y>qa&U70#1Fwkn%RI612W-N`l+a{{s{aX}!ditYW
zv)R6jrcao}D8;mD$#h01CK)E}oaua$Ov=+AOk@;eR@-(0e6sCyhoelKpyP>T!6y?<
zzYxM^Fx|k8nY-TXcEY#g>t9>4oV~1<E}$~y&-eQcv8PYkMHL<6i!?o%esk^nkPivE
zTNrj0g_#GmO!$#y*UPPY>kjLksZ)gHd8M^3`)<4JyX^@l18C(1_z+u8CiknW`inBT
zGK>qIr7hak&he|EMBekw<+JZ`-}{jKq|M0i`7Cfev6$`l@q1#}!)3Uzr}Fu{%IC9g
z<*vIdSm4-`ELXY4Rk=`8X_BUNr>DrI={eTSvhWD|v1;%0Rd2HsK?4~Jco`T#NfW%X
z2eRu4lxU&cMg@-su&j<-ORtmLHiWQ{f*@!KSO3%<SEZ9y&$s$M=hu^6Jq9t87`ELs
z-F7>d=|q6BvGJUDX=&wqPq1Fqtkx*1_ww^Fo5c3uxZLJ-Ro^+xjIM6GeZn_Y&{K5_
z3xnXMO(NSGqkYY8IZRN2FGiW5!Wp(+)spc9m-qw`>ACOH@=L3?-Fw1zELzAhI%Q^b
z%A_a;#@xN-*JF$4mfi=u6znbq28io)UAJjzpZooOz4e>Br|W~hgDl<CTBst>nKJEy
z0E5#7rsxcr>1FSn-}O(|__<|D_H56@9frr(yq>rB5O2@c+-;wPBVB?#a~T;}a@Mr!
zE(p5}TH=mk#h;_BDKmZ3?wYVgNQybvEoE>BeEa{=8vzNCQ&S5C7#SEG92gtz{iZuG
z)H8l!V81GM@l7i8wpq*pDhv!)jkuT`7BDavF&G7ja7QRGC@4p5s?uO!bYNiM=TyIO
zQc-DDeuDLq*-1B}@04d`wT3D%XfVGsboyFzp2@a(B?GI-;%y;Qf~EvsPtYk^$riOL
z)hC2&0aF9xJ=@c}8A=MwvX~nJ0xs|xxU5>{TW@mVgoMD6lgpTbO_sVUFt9Z+RP{1U
zxwk6RVWx?R2``(&Wwo{@|By*tvzD)5o40VXF9QR^tSOVKvb>}iQZg7AGDN1hG)-x9
z`?A<qimie1PaWU;<@bNL@Spvu757JE@_rE=mDfCJOJA9R&>N3MUsYanb6Opmrm=f*
z(UZKG`rgym@4b)R_u|e@*+g%VxFvHF6V)Svj*72TkBIQRCMHzcl(zJ(r`4fDejEI&
zw&(9M*K>RND)wrb$0oPQXG?FbclB5qTB9|0ZEo4bb+2}-L@J$>im$!5yY}MFB6Ias
zZziVnuKFH&Q|YACyVaXqC+SRF`u*<f?RTZ8D;HI*J1OQ-f9ZB{xR;xfp|H!5h;GAK
zD;Fi{xXw5ovc%V8Hpf)MO%t_}Q=)k$be+nnE3Y#>rWYvAD{?FQ<Kp~dI~V7LZ#Xpl
z-1iu>@<6NI=d0cpl$Ou?dh0=r<-Of;6;fu;b}r7#ZnwUkeV*Cv&UKUAv&C+A)(1b|
zTed?U!nw{@zOMfIJhtAQ>oRW7dU)>Zt<MK8ZZ|zET^w_9yY`iz?_<}oLpj&t`~DOz
zFQ@@a7wz@l^(wM>&)vg2?|>S$4AwhLxBbc3zVb6dhe_7zS-P)keqYaS{0y;Os%qVm
zH9cuYn+<0ioR*r{bBt%Rw&c|M8EGm1>^AM(c7N{LEKc7Zw%bCpC8pfCajVlSI8@5a
zaB*^Sma3V7P=<7%(vgU6XKuA^ORi}rb+c~VX4=*5c2tZzIT^$Y$+)rTph$#Cu4~}N
zt)i}hi$Q`LH@Y_6xR})|b*wkpb)(zC1r1Fc916Ft<OC*c)7ZMj{Y!3Wz1X_2i!&Ep
zmAD<HE7p|O+i@{ECp*im%gnUvnzm?ecb3_0kqqAC(2W~<Cx-s~sN1{dN^Wj$#+5Km
z6OriLu3Md9$F6SNVy4@YGj*$%#)fE7v1`Y+ZvXQ8ecWuuu<mS8|LW_@da|>p#@voF
zTRl6vUd>cgBv)d!apu{eXN#V-<V?RB&g{k*JzXY(IfRjGdSL|fWu~9orn^NlcQHQR
zele1{h>7v>c9$6D3MR()+xNyX?_?DDl$-T$O;*UpmAS3G-C{Z`#a66!0QE5C>)HRz
z+8XQS16mEylPqzxvzaGNM`um4VPa}(o6*L|sAIQtLRZN?l#!acaHgs0VzKOyWlI13
zMPt+?jW%5DO*)p^z`$T4bt`mbRI}EhO$&S0EDMV`x(3u$J%9dXcGT9gE35BuU2W3M
z(oNdzvFxPTitx`)zl~GBJeM}hxwUg={mx>Eqs3Ft1wvL?Bui{B&)&WD?yYxkl4kCb
zxm;qMcYEQ5wY&3fZ+i@0b0Lx}aZCfGR(qnLK#~&2LBS5QzHrNR?=HOEot5^Y*!RNQ
z-FfZKvkcjITm(A|l9ZGb4uXdJn*{|01;N*dOMtkBf`Sn3^@1HrAhj+oE-(p!gd;A3
zP09iZJ%SR=f+#$egpMPE65#8|m3UknC6o-=EMuPS-W_{4=4rw5l5iy@B?XA)<Vovt
z7bj<#nLP^KTwZ#2<Hn8K%*@Qpjvc$>wM}U4^jMG=414dC<$y;a%wwJ!msp9M_07HU
zcIDc&YZpP+n<^RadUxZ-joZ@F($dMvdAr_#qX|y$gm?+&6sV!sanjS@CozlF7a4-W
z0cL}e>J9K_sk^0UH1s+rP-ubhX~<HV-F;xy$KF|kqeFV#ZV0^t>NMy*>2PIku;3SP
z<LGgmo-A>!-moXR^g7rh$>p-(aOlYafn+fV2O=eL?DhKRfBw(^uYWnd_WSMY>+|>B
zUZ~3V;C9~KZFi<BZZB0-W!`=7`}SRh+wM$Hn!QV4B7=4A?y}oO%D2mdgaWL$-QJ$N
zUDYG^u7{_?yYGA7zH7T(q@<o;@uj|e?~U7eQNQoLtqt1`3Rr20W5}DtGOhe3FW$TN
za__b$D|vUX<kVoiG-2|+Z{K%G=bq@8+wd4<r*!Vg*Vos6jrzOl+FyvrVU9NJNjy|A
zM_s_Vyxc>{)38k<S%H~#+ii~A?Mg~z%>C8(?$y6Quo2Af3wgIaaq&A)_`dq~T`2R#
z`|6F~@7L~q_kHiZ>sPZsq6Uv)&s=rSOC{yoQ5}ZlMlka-IDU|b`eTOsEB^ld`{(cJ
z+?|5L8)T}i@4d<0t{b)|!Q#vJz3-0QF1nh1jJe+$#U0!3Y>oQZ@c8n*@4KaQPlv9T
z;Ip-TU%e43jC5xgEFh}ipWkov`z_dp>U-b5JHsrihuik^-8)A9^^afwynF0+^0wR3
zxw~^WZo6?iM>@BkQ9&?wzdZ<O=_O0tH|)u+zP<59ghy53%|~BmvCS#_9;b5Yz_suB
zyJHvq+?O5xw2rIqT6td9Nt1jdp2>Za4X<x$ws`lx^xExQ{nB;s_GVSzyFSZwL9c?_
z&HA4|7~gKIUsJu`_VC^J1?)E-X)Nl}=w->UY_e)dNZ9qZ=Md|mpZ9L;*fjV1N4-^g
zN#2QHLqT_IF&pq4Fq3v*VB`*6!f<Q-bO-M2S=)9kU|_pq3OO{1fnnC|y0t5A-7eu;
zJF9_#b>&uYRkwC)eE!q#@892!ul;^Mc3b_8+qt)Md$%3Cop3v+f|FswnbWyj7>aHu
z2zfG1p1V;!wd}~;d9`ozD{l)w5)u;1=H%oQpEvpHob6}M^Lwsly_R2mWY+J1FCU-h
znKAih>n_xuGKoPg;m|bo4aQ|BJk=dn3TF8z^G2M!TdtgXb;7Kc3t8K4duJZq^6{YP
z!#Tche$`LA-+tTdc7C*fTUEq)Z=Orn=XdN0d#f@@K3%`P{QZvVz3&))y=$nuzkRAh
z0I#Crx*KN{g5;VTdlct*Oe%jg$Ef|tkFW0}wmb<5th}8ZrYzPh_JiL+<)y`hcQ3^E
zKEJ)=c23#t<lODK+stlD=QihVe4xT4ICI+V42C&pehHe^)|(l5nsBzO39!EV7k~Qo
zXZs2UJ_g43dB@-H<uE(R-{te+%S=DVww8O(JB^x(eTAH!w|5%NnR8gc&eP8Nk!RrB
z^s*<tC$-E&RsK|OpWxxD^L)*u5}V_3mw05im`w8OJag~mmEdN^cd>Ub<gLAX_a3Lt
z!z>TQ68+fdd*9>k=H=HXDWz>a7q_<IK#Gf#{@J=Bm$>f@w%d3AkcWEy&$<^Za=-62
z-~0MN-jDI)s~`#Uxo^%gA1Sfr@R6>zn`W$`%fR>h?kjTxzRz*r_r6}<;Zm92$;xxb
zZ#)0_{ZU`K_g>q(zh8dtpSr&fOqH^>8F`xVH0!V1bHOrHM}+xsy+u;cPN%XcJ-=Do
zo|b((dc)({)weIq!`{7n&oWK$QSI#)HWhDfZ^`@iyY~7~slboNu5Z5!vZLBqVcu+p
zNgg7z-cH+hul8;B+voSLeV@CLkuz~?!p_qwK{^v6G^d^LRB={ZrP_9?$!mYk?cBY&
zdehxbzEo{hQRK8@Z?k5Y<WVnpQh8E%j_1u-a9Z26Q$fg+Y0~Z_zf*5Jt+ltQPCd!q
zX;|gvspd0ddwH723Wf$A3y&t2b3zhH77d;$Eh_~$btcR`d?j;t+9VILX;LrVhiv>9
zb)<Gz^!0spwV#=7SEs#^UR_>ZGV%0`!Ye|dH>EtauU*nrF}=8V&)aMF=G9-n*u7-h
zWCKryNuC^&92J^86!yJ+J^N&NdFjp1+*U$`>JD~p_gjMmS1t)v3|Xk<adW{*xeG3Q
zH+@zva9+3DQNTLYXjvoQuD60r0;Sh8l-P5YNn0gnKd$<^MZRidmg_px+77ifx3<(O
zRp%#ht~OgM?=kQ84YS+498#N38=SGK|GK4CWs;}A*=<R!8;^6}II7N05B$jTt+qpD
zbIvO}g?Z;U<ZhE)$06+GlWYZ2+cJ6O>)ef#*7oV${N9lqmhW#hq4@bd#ooxhHm@Ad
z&#$=BDsNZ&NaE`3%T`wTVX?2TUHCG&N+>K$Xl-w_)Hc(M+fusQj(KgfxLqyaJJ)1O
zJ;Y&~mrd(mQhodU!p$2lG;Urfb+bKgTmO<tp86FzB)Y3--`B0*KEKb7&$s)wHSE@J
zNZhL3_O#aCrt)Upjmf!7!BP-4X7#2ySvRiks+xA+I_>7-B_C~GMc2HYoz^$`$gcSK
zpxbjdXXfheylr-tQ&z<`rDejhX}2b<S+h8zImJUcqBn_mqC#(azwg^ElYJMK$_x0~
zBC~pQ&fW4{(ss!&xAb-9Ta`(kS8P)}lq1{ijtE6=E0q`UPruRRU2k@7@gvSRzu9gl
zE@X=E?8(kvAMJigI(MDi=e*79KJWf}=#T$QyN%b*em(6zUsqiB`P657eqFybzjX5M
z*SBBHE!(>5`l;UV6Sq(7oAoNi?{)0XSdQI`&rj3)UcnuxQu$IR-LQvm!j!nlof0m4
z4*8WBDn@uDODxZ8X_;g?Eiz@ANBv2a$<wCY({xo-5q15(<?HM99^Wg^6+C>vAkw1J
znwk4BQc$HeB=q4%jR_OBc1LXOjyS0@d9`;wmy*gP@L4mgf#IzapR`N}6|HcoR8(Vj
zFtO0rl~zfqedYH)?&9`Y$F{e|<t}!us>~ESS7s6SeRcTK>b+H8c3-;pVS0GM^!o6E
z-OJtyy*hU5Qty`N&AHpcay;)!XUD87&dr|syD3z)ZU#gAx*pT)Fvrl^{i$_lPHwna
zJnhk%=<9pq(l%~0y_>h<s%UvgmX>MN3$a@-qg7v=G3+(#ot74Px#Eibb<^17`S;y+
zT#i`my{u;Ovc;|Cfo+xUN}q0LyxHiceKaz%e(H(h+!?*oF6Fmu3pU!dRQAfmkFEMi
z`!s$mshUvZwLZ|{-R<~!|8DHNBmJEBob<d+E|E(5dA!dT=}Z*!=)T=t`C@P3o}DYM
zq<-JIS9m+?fu0tXrY0i+>!t=a^Mb_SqoD!6lmi%!WKEP<thjXH%gB(WGE-x;TeVz^
zj1x}Xxbm=GV#?&3W$JvQr)Ty}DLl1P&ni4<tHg}MX$PF1XfKg<EL9K>o4U4i!&PyQ
zGp8=Au3n}*cbaZY*JH8Fq(g_4SMBn8Vzn~z%F=l+t~*5-8!fKPoTKq<4PUeIr1xBJ
zW2e3MdSg8$qN4Or$BsoGosT+IXnhp&o;a=NX#14gGCDCjr(V@t>%9}~aa&$BE7jZc
zVfWv@oobarX^)<F%oBb2bo%x^8jnSi7d|lFT6kUc(3TxC+7*nIT6=>^8sBt$34Q6w
zcXO-1&v{{k*J`Je`+oZt7Tc`z-nY1F`tBuJ8|BU!Zo8v=XyWOY%WN07%1l3HQ9LDS
zr{c%J+jmQa5AFPLEv{-`$>REMk(!-rPia5iQNHtBd-!tUDFuag+}?dtXN6DtRJ1mo
zRhp&!RR5HIf&LKv4)2GmAA*)XHM*M2C%8Ft<zaQfoakv!w(G`-Gd)|qC2QV{-$kY}
zaY`?*$4*`<+j(F|=X#HqG48slZpWUOa~03-TyeO#=xg{|kGPX>CcOwgHK}S!m7vD-
zxzb^Wv(6bEzGnD7dZ(r7^o4oMYwBB^XIOBp;ZoBO7FaDBbYe}{QEjG8I^8@*J&V0&
zvbAP}b!9AboRHNUxa3k&Qld9k1P`0G=+dyMk<J<!(>jyFRFgJFxdqOg>a!|omC-_z
z1xI*XQj}eFRW_|Ukg_RC+cm3gMat4l!6`Zm6P9shdM;HHO$>92<V<DOkO-X8>sG&5
zC}Pr8&qUR(WlUFeoh~)2NNSvPn-Vr9%*9A?(rVQ(t)ykljDPRHT4cYWK5hM*tAFR!
z7re{WIm<MKzwBPm%t@K*v6sH<`>tYZx$-%DUctxNQlGt(cg-^_T;60VxK%J`Qp%P)
zmsc-TX_=F_%P3H8^QtT9MSI1Jc$3vGFK%jmU2o;Ld6`guhG*jPk~tDyPAo56*K2)_
z%&lI?DOwpmX^GqmC)c>pCtEfBT2w-x#%1fSFHr<d6i#UA+Ozs(5PylH(t52=QB#&X
z33)=>z$aBEuZc3uX|{6vdP&J);`{2`_r7o6`FefM<nq05?|t7M^V&Lcc9mEB!&NQ+
z8S3S4F-~<&3!UMqlQJVnqHEKcAp0hf@OukPIF>71S!0^1by0N7q^&L&Rdzb+gz9LV
zTESz$Dlt);Wx-bOpaoMGy7YLlwuy;xO>J51!MY@)GpsRmRlvolkZy-*i!>KpVM)<Q
z@a#J3k>Jee<~TJ_GSr#V=%liexvSRPMWLOc2BGy~l01t73tWtpA~Z8SrZKKs9U8ql
zchlPDRBeucuo=ps0uF~5r_K)QG~m<dp0vb*jaOy0hpU^>l6Iw*t(=NoT3drO6SOil
zx*geqCd~@b4rQ7D;i14&mdPUB9@?*`vKnax_^(>vePgmw<Yb9yhC1BF#-2+17cI_C
zIWyU4Ti~*KUtZ&!Ns~>~ZiZdDw(9=XZJ)(@LRTDJEOl5gNqMnWXiRFF{!875xl2Q@
z=cLDO?0U7!GhM{p#4IpvrCXBxMbW<tpShhmlGrMLQT&sg(D#bw9pMxG1uC?U?03~K
z6~4=Ti@z{@$Mj9%spaBpLhs%Y58-+fx@NZ7w5XOJU5{DqI_irx&1Q$@=qJW((x0-Y
z>(#<rLAzJPGtF03ca3$539uFTIQ6@G%k)I`iE2q_=DYd_@hz2IHRVxgRmcba3$mI`
zj;%>yJY5E@lO}9fwf^ESYu6KP!jhqjcvKEtSk=q3Xsal%cu-fd>b8uPR~Jg=>8Ne#
z&fR8dDm0%<Tr%W#ZdZT3Xn>ric$?G8p3pEJuZb6J#9zcO_{;sp-sz{8eCxz+jx8H}
z#a0?7OLcRax@n5}Oj|6brI^#C#@iU$G5LM8T59Bsvuh_yX-!DX;tV{p@|)K&oec)Z
zM9!$BEEW#h;A_wtu~?$(z@at{^+#5_IFC-0<8gYdGKWW`|Ip9*hM)as*2jB(;X4_%
z+U&|fV=bc%XCfq(jU^79HaZw`$~4SuX4u4Ffv}L;r_w40hu=0lmYkfqWi_u_R#-$c
zJG&t3)o;@bj?FlfJF|Cdm*F%IAFZSQ%uE|9cCc72ej6;cNor-An@Y-L3D$(Lkk?G7
zRcv@v6ABAj_116dSu8l?m|&!szG=O-aaPZU(*hNnly$oNH-+l8d$Y6Z$i#51eE4nS
zM2W<!UG4831>;ZEThv?Bo2qVG&dK1d!J9EB@{Whhfm!Rb*6z;Ue2qEHLUy^zynDB9
zR^6Rfu-fd}l-#u%HzxOPU0Rl7R+c-{+U&-w!gJP{N37<kUj6qvblcHK|GLF=Hl5aq
zsNZzy|4fm8^~e9)fBF5TtCs(+{4SY2?`5Ce-d(<T>G`;eaiL=OrdH-knZDk8L^D(M
z^`(2;x>{Hkd{PRYB>O&ht;X%Bz-`@y+qSGT^Ip9p_Ob=va@p&#Tkoh|y`y^d@2=bN
zuR13R3ah!eoSftW0ZUF!R#NksX{3~LQb|dv9yB210UBxP=$IV_5eCW6j?M-t%2{^X
zW2T^)&rG9~o5HzEwyb*nr`YniwB^O{gP+59?W_FjUYy&cyX)0{^ZRu+wGThs{qlD2
zi|tD5XTRU~Q99oIe%Ze3XBX#wS^MSs6}OW~I*gM;wV5~EmDK1=OgEm^^R!B*K1J%7
z4@bh$me!UznK$Mp_QXk)G@W#f3w@fq^3<NyCpzY=KDDQ#^VFWzr)~#Ntqh+iXc<1W
zQc!paWL&7{rM8={<RzV{-EO)P9-Xdnp}StMTkokJZ?|)<;<@jZJLf9?Uz)Y`>-W2t
zcNWjSwe9}Vy0uaqJpbbNA78uv^rxK}>K7c+pFe-T_i1Rd#OmX^iH9W)nEU$a?FnRl
zch@A!L_qTU{p#0RR_xQCmolfwyWjlstA76G`>)^r-{1dp-~5xG-e3P;$KU_wPrdu;
zFD%ou%9!oze`RgHx9j_!ZMPb<bGO}&dpP%?s00t=oY=QpuYGS|U}#|9n|JR61ApAR
z?@de%4GR=BIJh2w2nN1}hILF#4Gr(ZOSfikFMV&lK2PbSs@%hrN#8lPIEa0ndrkK6
zwsmjc=Wa6NW4oQZsdrD#`|5Mz>#GmkWXNeSbC6cxoxpZZnSp_EgR}zg^i_H9^WNv}
zzP<PQj*7fJZ}*n(`nFw5yHe`j-L2C-%b9iS{om}9&W^gBog|g^X4{QB`u~!eHu)^u
zY@}c;!;u!ZKd3=L<J<p_0t^gXsZKjO7#bK96c`RH`}gsb0|T?8YrK0|!>(JK6^w2t
zZew6&XkcY%5n%xxm&3xqpuoU>d-9TL$AcJE9E^B88a^m+FbFWdYD`nVt&uzR?H$RP
zA)Qh6M_Dzr9G#N5^!WE#F)(m3FsL^q6b3L}b`W9EV36Kpy}J!GkYQESysof8hJo!y
zZnJanmw8h|7Bes<Nz9Vq^tm)?r5l5fV55YOs`;v^A(wq-B}(}6uvE=Z`Rb{v>ekEb
zz#qWCxl(Hi|CPpxjgoARjh-$|ngP|Wwm$PFJJd7&lRL5gkG;$PqO|$fe-*EbnUn20
zBT_k9B~sZt^=`PYPm+%7q-()$$9kouOmZ?VZd|)T%FHC=mfzzzO@@}o->R0r@(<Zt
zvE=<lPs`Spxd}5@R`r5VwUEYM=b|ThvBmfHzP-4!$Xw6u!OWG_L4F%HOkSgz)O}_0
z8Xc9_T=fyKDV{@q8+@+p{qFYk#GSo$f1y({`njGViZ0~^+jmdd^WI|hM61;uf!vwZ
zced_5bmw7S!P@w#fm_$@`@Og9H)wjuy>;!LRlRFV;d3@N+9^6&rsd&&d6P_&oU>JO
zgQO#sw(4qzEM0&1=gSzrb?@uvO+E11EBbrJZP0wn_0{h_U)muX_uf{!@hXTZ&sThD
z&j;B23liHT_iWWZkTU3WNx^elZP>&OGP~IA4#ZG-s3EJr*HwixKZ8u-d@Zl9eChSQ
z^7Rf-Br`DZ=I%Gief4`ELWODQS?Q{M@8?ZD@N;oq_AIj}w{mUYKUmHAY}?eWx!w|2
z4wx<L*eG=|B+#`<V?&lnwv?%(BO{A|0E3j-S|``Ql}gvHda7pX=7t#tW!%`dXk(7l
zF=>teZ2`F&y<ID}I@Z^3)(w<qnZ>a<>6Te9XcDG7Iy(Dr?$(HTzppPl5W48r(cpVu
zUoKju<#x*Ll3&&~mtwcO=eF(9c6D{Tx^ZomX~d_`es8C4xi#t5(j3lbp*b42GnPhO
zQo8A#bi;RP{C%!%oYEf4F0B0Baw}Rhr&Dq&v#C?n#SPJ+(P|gAP5t|ETmAQYyWT(C
zFl#S|pN^H2md%PUR?bT%JUZI>zUs@xt=a4MK_>fhi^YwKg*UcduRc|hGh1}?y{|79
z2d<7;?Y5}vxk_)um1wbRJGUJ>K7H99eY<$yitML*gJxwHtyoi8m3_!&uj#|ZSz5il
zD^_WBft2X>t}eQ=e)sdG1$G(rw`V=;-I-VP<@Q;*xV=XN92{9!yBDvu-WGQ3*mWbV
zpG$OCO<dy?pU1UrY1u88?AVpgsR1!Z%@*A1&f@>1`M&CN!dBO{%lE#%>>6dHonXy7
zDLg6n>3VH{ou-SqIay%)Z`@d$yNPRlo!8pM$HERRPR$87YTW4gb>Xbd+9qr2Po#+@
z&Wc>MS!hO%>4Fuy2{*J>aczj&5IQ-G>vpQz$*HP~nGMc(opCmdY@M-LFiorfThhdh
z&RLFI73v;M+^V?Aag)GJk6e}9(6FP9-!*wVrL|UPx)iHOi%L6~wd|Y}t*SeTcct3_
zX)oW7o1t6Pjz~M?Oxfm<8x$X>b(43=w)&~k4!K^@LDHVycg`-(j1IfHMYqMQC)-&$
zaO2v=(MiF%JvVL!CrPtiOS`x^>&EI7-3fbNb*Fl#Zn^BRF=@4Q)}l4pPB{^47w2x=
zXdDu;F|<26Ik!_=;^^Am(5`DbQ65*arL(1_CW{?g9IdTu#@o9fSM1W-$vI~iC*AN)
zGwH2goe_4Scg4)^WU1cJ-fjPSZkdFr9o&)&GVI2rjbf%@oy%_NWasu~Ty@(pTiSJP
za#GqYozR@n<SdmnNsCq;+gh`zYok<eNW{f$lT1Z(O(c_p-Fme}rDjQ)t=QP@w&<9y
zSZ}b?v87u&E{UDF<+Q?Ui_a=UO-<v#EJI@{jYaV{ZcAxwGdp(U$eCzqkr3Z4*V^0`
z>1L@V-8g2pe}|!oYub&#Z5=aJg;OpZ*w$u}lbkHr+w1DNamAIe;H1qt9XGk9bGwtg
z7IjWaGVM-w$rd}h(Pe7aMpu_rQCB=8I_^(DSj((!F4mm%k7e;Wxwihao=iLGgO@L=
z$4X8*v)Ul(<z8iZe?A$*HwXR2{Uo-A8K%i51@~+gJzVSY?a_3_I%cu@#*^-xQ})hO
zXI2;eDr2|l_>mNQj^)m`)YKBE@kmU4ld>jZ-f7Pt${c5YoH_F7#G{#+la40*F?<uL
z?|k#HgsqtPq7yGt;=MoY*tYG)jibL$-N-SUz`E6SafWV4lv&f%jk&tpy8hG@G`F01
z*g7Mr$Lma5$PWYk;};&*np6u;l)F*CMrYHNxKBJOeoGGCI6Bi_Pvp^_p2*V=Vm#YJ
ze)2@NKR7)7`oS2_E7p~%sRs*>#j~c&nerjLt4Lz=!ic56U9~^#xpm`qcCzVA4UNUo
zzS7dk8Mn;3byHV%HEhXF3v|uQnx>Pic2vwHaHHFr8)m-UMw8WUdZ!7e9o=#(+Ewnf
zX8mNzDJQ!Ur_4;!-!daBzL~kZvvD$OYWt%NC;qrgBvtX$i9aehEZ*_zRZ{sE)|XQw
zJH0>cxI8UbR9a<|SMKH5R72m@#yV%T>I@?%F-ts(ydGQH_4>odM-ivyNt{aBlV(*Y
z8+y4d$s%#e!GeRwB-SKzUgkWMEM}Pe;bF3vp<zV*kz-;yX=y$lrD36wVLqoOYkgDh
zlnH$_H*eqW+--LgrFtez?bcBaoFuey{i>_Cb~8w1B{0iJ#~#15>gw01eZh<T7OmEp
z=`SI<&2`3_+stf%ei}1f9yZNLTc(?+W}rDuTiIUn$Lqt&65pPi9Xo4yoUPzkovdu)
zbwBp2X^GR4jq44Q<{HgS*>UoipVCRm$x*pxv;8@zJZ^gU<xFA8YiXTh7jjqj`Q*p;
zuG)6XkMrU5Uc;4zhcESu*k~U<yh=_h$({S+rI%L}uSu*noT%?O#lOktwQ-+CvQ((=
zDr4SNvqRF%JP)c%_6fC%JUd^r@a$RFvvZz?o163>D?Q%&Vt@0+`j<04q-h%&6!skb
znwI=Ibc^@bbGgpF(%M<i!Y=*QUhlsubDnMPUisyV_kGUi*>RQc-sPN=+iRv>`f{G{
z<A!+?Bi)2$pSs*y@~Xy8o%OIh`^9!YzP=fCGi*X^J6nz#Uik3ABJT2+hreu9euYi^
zY;^LM-*nyY_I$g4*zvH5FFrEAp6iOev8?)`w|maMty|sZFWwV!vf9mOW>NQdBZGn&
zwJ~b(t>^AM@8jFYzgpkoulU9<-`4kdcD|J`DtvQd_Io~yll?5e^u_!1FIL#joBCL5
zjlajYK6c^GL+kEU>Koh-s*<%Tt%{o|=DEsh#^&VgmJh3M#K>u{(Kb|L?`%1h@J&s5
z>7AULTg|pfPHnBwf3QmO+UB&|x!aeBJ`y=H<+P5d<>t(-n=?*KzuL&GB6%$<sY_WT
z=~$Pclu5=?o@CaZ<dj7nS0YwU7iwbmtp6_>o0_uWmRWCCuXL!ibjp^9EmPNI`Sy01
z24v^0%+}7^9<o)p%Wy?cc7)l*z+ADeyWyc%MP_+*TueGwlCkmb#l?BDff-lDdXwFH
zBXtw5gw4*lA$8!)%*jSNN%hQqy9(!XH=op;%CjhCkM_|+uWTYUb}YT7^5JpUhe`G9
zayIo=emnkg-~J&N8opE~QtNfo>3}nO{OOW2CmpShljHfY!?q_V#`aXQ$oZUaZ#6Ak
zFR#-Nk(UfSwq)no9hw*ZF@LR?%O)RDFjGcSa(>?&nSxa@wn9mVf-i~u;a~VmMt=3p
z6A{M(=eLFYimf<*ynWH@9XD@vZ2T}!B4mf1(DW^uKkAo1`tVRJ{Kz9$t5#d~4b?F*
zap$A+xP_b5s;vqw=Gd^l<Vp>h<Ffe1lz;M(|F8a)zj(~B=UBv<WXbv0>}M;SlH)y_
zb1O!|Xst4@%bc~Bz3!T9_tgbaYcJ>I#O7>O-OamhtERd3>aw{}GPn71=PupyD$6o=
z^2+5=V$rFw>GiSK4tr*8+Z}0iYuB~i4SbuHdS|YRoO;?Z>*aR6P3tmO?J&A@H0)@h
z)aA^Ew|Ng3Rd!{^^v$}MJ@xFeZqs#n$&5V-re}7}cDT%S=8U?;ayCh$$c#CrW??5D
zq;B1`F>Ke_@a!F?v5{fQf{p?S-9@+a*MH5<y1MSTTWHQUv)+_#^=3L*k%pmbwl2-t
zmMhsi;mpyn+u?t{U0V-YP|m;xK9iGeYv8}H#WU6w?L3pT^UU4tK3C4d(4BQfJ5Pbv
zEEujUTb9@EG;^28*$Xd9tkRZcr7g>wxpUUcm9u8U)^l`0RAxbDuEA?O>J6cS;T+)h
zrd~2=ZaN7`1x$gPVVAPRF>~3AyLXwFyS;mzCw517N3PTD*6rMRInf2T+OFvC$aT(=
z4(Ppmarcg^hZI2OanAs+Pq=e*J2zN;biuZVTfxko8*>lcZrv^p=0MHKUUhpj)cWat
zhnb}$Kucgi0?86v-N0@K-L;%7adbMP0h6TRtaoO*y={lr-Cg%M83wj(^|s#i&diLr
z7Yuei*Lw?QfQTK_=eIG-1Vu?4GX(iTB=0Gbt8x$B2KfNwz}&-G(gE8ZZslD8_8#x*
zIa4#dwx~u4t>p}xdsk?+-#eq#&JxGWi*C1W&pmXz-D!GA8?#b<@7;@?Q2EZ#g^&;g
zhbEL*6uMCB0>Y#=u!m3xkOeKPwy6EP|M-9Ve_g{Kb**oF?|#X?uRb>8nDEr<a(3zT
zGQ*aqaR&-tl<$3hw<pmud;_~&d-c7K%M6`bp2pohc<kn#Gr^o!n#0!|yrXwFIcw{q
z30Yrf@8A=+-Uu@7oyBeInO%uiV8O?hV70w*n_q4HbM4yt2h*+FnN90&hlq!6oqJcf
z-oD;`zP{bAUmron-90XO+i}J+;gxLbBX{>1&pmV0V6KO0)!93RbKa$Cw!Cs&eJ$^C
z&)Wr1+mDw^o_lsj4WfL<!?HJb^P)a_m{y%BJkIpI*w9Bkh&OJt?45M$*#$HFmPqYQ
zv+gsVdv=G9dQd%Y+-Amu_a@AJ`yA{%RIkji?s<F7Y;~L_*csw5&&;rHy}c$kY!Ap(
z_QJWlj$O?@s&MtSLAfMcxSa72+~RVXbZj~qk3T$KC~)w{Uk<(8Zr9#!F)iJ|t>A@O
z3iUGAQ;lZ&EDP40a_Z8`)CpOqE}gBLz2NG!B}*By)2{t1jA6LCa@+Q4ud~AL>^gOJ
z0Ruy~YVPLTtxwmj3R%r#ddA)CzvMsT^KpNFzPEk8zwXz(?Q8QPS6TAhPU%^3G}2q+
zYW?}==jVRvzp~c<@vnHB{p;RaeqKI1A94aqy}=c&H1Lkxph;el8-o*7wZfvNZCP9I
zcXG3)i%`$z$e`>LNw!R_%-OlyzihkKoi+Dh&dQo2vpMxrZUwO~ynE1kKktv~a_QW@
z+c~-0-flZ~J2`hl?lv2i29NUcz3;0JcqS^U#49P?`}QV&PXDQW-*$_in^d#?{`QRh
zmbG_R*T1`-vG4Wf=h^YAKdgA0UiQ>;<<EEbY$i;2e5UlR!a0WTvANqW-73r#Zqhz%
zF?q)%PbMJ`C*gawZ@1m9-hH_|c4{aC!?l~XkAE{>eZ?O4is84+bIWr@fAyc-eqZ<M
z>+0{H@9&+tpn7rLr1Sd<kK9(z<FC2Dv`3G5)!pys=C!uVm)A>}-+m*<#Ikvd^}XHp
zr9WTAFV)<he>}Uq?CGyq<|F(ikJ$HA#%HFL-OlZ2`7uS)YSQ2Dr!)5bj?~$_cFo4t
z@5Scp3yv;VTGV}h+p#rnx@@}eMG_+KE5E%nyDhs7v=Ah<YfWfMXxb!}3F>>_ZoB0X
z#lZZ4LGEj5d41mT*E@udoV=p@=*x^&&dxm|ud6<)cV9WWY<ck7M<3NReN&eAI|*=F
zT{Q<UeL1OKw{!3Ad2b(ia#{&-zvWe#*td6ya>~cWx>{=4%d)TDUEbjIB5v3Ay>Ba*
zFm$;jO!D3zUtX5K^az83@7<VHD;U_eofm$ocFI#}vC1T$XqEcBoQbPbCV3iiISI5V
zT)xn9P}|Fqckg^}$$P5hn@#uyC%+GVd8Xy#rJc{5Bwnk`yI=V$;<UvtA)%uCdp|E<
zn0WkduidY2%-8SLHXra#d8-oi<#YAz)1T^gP1?6#cI_RNw@H8XVoiT}{??pX{>fwS
zu9CZ^E8o|sZ>!_qD;oJUOsjrhXwquYNEi%%c-!n-dCu*7_rObI1X#E$CS39{-{q*#
z_i+1`OIP1r`!*|jw<p7dNk1j`PGRU+I>R^RxW{*yo39sMyPd1MT<qSq{^>!tpMzJv
zcrU%Uuy*ad<)uZd7BDa}CFs6eP#UcQx}9l~PetCI4Cm`PXY2X)seGSc@<ML=z0b=R
zrWfq1-M#I$@TB{y+LC9d1@K)f+!i3Y`q~+}UB9<*IPlGUb7Ix0%DC{dvwP=49QyXu
ziB+d|Z_9o2?k0G4zWUsa1_f^`XNfg0S$tlJ-Mi(zl{-IIVHWSjdn;C)&so57;e^nc
zgY(qZHk$hFE7y;%ug-ZDUGqEbcJAv;AAjLvibAz76!Zl<JuXhI+xvZgZFFu2r;f@o
z?e2`9Cg1mNnI<N++^Y2Y`jRVpFFhwPq*WVfZCdwscC|Iw1>0{=ZJDd+vAy%o=bEkg
z)6x=eI&gGl-F|E}?Y`a3ZMUm##p?A=zU0m2;UrWs*{|AQPGEk$@phNn8riqrZOdu7
z_QkR~!>#O`#J1?-H9FSWx_kM~=c?W=yD)L`wu1G_Pj_A`yS{D1LWb|@Wfywh&N0j@
zZEZ_?dGn0A+lLSQW@QX~i4!^sepj>IPGSPD!FZKhw)mwA17Cl`x0{Jp=I!mXtr?1W
z_F7xEya<fT37Ewq%idT&*V?k}b`q1&A@DMcTh5nC6nUx-RGvCiqOsmg=K{O)PAhTS
zEy~h|+tMQ*u^U{T#P0Nb+oZR<Gdxb*({yK)d2R7-;}Je5#@FZGE|j<@V|mTune63~
zH_wC@eJW=@JGX&(M#fLR@3}X+Pct~hrmfkvQ*C#kt;!@%rMyYy+amnxyHDQvoSwj!
zIDL7#!CWqDtJxkE6J{SdGs7LUm_$HenozRj^|i|`$xU9!k$hL>?c0qk5O+C7=j`5{
zcJCY{@Na8q>%F_VeKSJj4TO7vfe)(W&AXdhm@VF}+4e4ct?=X(zD&Xi6%y|C*}A)@
zzE0g19T&c~O<_iJ%13oi=6fv@=55*b^R`*%$!i&G2R<Ds3lQ{-7Ex<tXFhODc~g61
zD3d`?;;Z}7No^b~iZTw0jHep9yl!lEkm1*P^GtZ5Yvo3#4555sqeS`qgxfg|P7$6x
z>2cd;dsO+gDE603-oEV!Xr+dkjr05Z%fItqv~G)fx?W#NX`=nQtydMfv(3*2u6}lL
zU+CACAobGN;Ou!dTVl4)b7n}hIKsK|!nB7MCMYUuI{R8P?OodQ%y8}zRb`bYot7<g
zngp7Pc$9)}YMhoRY0YNLQt4Ng%-Yy9$x~9vagt$=3ad+trJ!8s!w?pi%D}h^_V%R@
z>z~ha)%(8Q+xFe7PwRzNaCCfHsoL`l+<M{RTI3|t(XaJk6_b+9>O&y89TOfl7|*<`
zE~_qGxhCs#a^;$^dw1XMJ$!uct82E^yQ6pCK2qK%wp2CSd(yQnx=J^X9rT3Uc;z(7
zNo111k_l@Hn89?bO8dj|($d(w_1ABfdTG8}YntR$_vzl=yItF+UOg+Z$-7x1>A(G_
zf)ghnYwv%tr_{*s!NEgS>P)LD_S&kxSbb4^X^3+D?6k9Ua}Vx&8~ZAD*Atf$bJylt
z=zW<xQPYlBljEdOS5KHfPoQ^~jHRk;VdRWi29JCeh5VSiTJlP1%EQa6*38uMdbB*G
z-YPuNRo1BQ&9*g7FJ7y>y*OQ{;IP(d4!*gon_GU!2_JLsn=UL9<9l~kX^Bd|XvO4}
z>Ma$Eyb2=@i?=q%^4(O6RFhRHJ!yQXzTu0%q>N;;no&W)c_*)`#TTuVFA86j>sVox
zsqZZp^lojx>*aNE%||Dtrp(@UbM1DaN>-~MDds6(j*Gqwk5PBNXp@rW&K7a9PftC}
zPu8&Cb(*5`t?%xe`W@pgg>SH(5VA+d%=E}QVV&T6ar1+xn@wcasGqsb#O)-D=j7;D
zS4;m(>g%K&X0trIZQJeai&a&2e{1|@+=ZXa_@QoUww|x~ph2}t;QL4Orc`PDP=3Vx
zF!&MI)c409D{C)p)AIW=S3J=1SBTTf|5}SgeYBPwn(EV~I59{fP(mO<)X-y@7Msdy
zg%lo#L#tI&))*Y-SvbXLS;(pSO>5m2>uft{;G?5!IK`;Vb5c@LmZ@~=G;PsIK9dq9
z+%%3#tO*O&+?J*+*fFECX+xMW=af{59yiZO)uc6{lTPL~97xh}ZAp}vF=Mr8Vnmoj
z3Y%8aGNmICGiF4@-wFLIU4P_p^Ute)Ui~Y4zVO5~hi<PaQ_Y`k41e17XG{3Cj{4hz
zA;z3yFIboucb24_ne1uxZu-uu;B>}?>V?b8t{8GSsLkTo^7_`s3E7ew3SZ}{M_v?~
z`cCDYi<hETz~YFLE>-7N2hKfpW!tp%N=ilRwLU4SYkk7X{4x!kB@E}PW}KTS)Dw0c
zJTF&YDJVR(`tF^n^$Yl4O*P`$taV0Zn$d<u8v{~jD$Q>ZS$}9n7SnQO9X6I_oKqPK
z0wShJc%_82NxDo9Q8}_|nlMYV5ZjW8QEP)kE;uGQT@uKYQgLfl4w{s)R%y{C&aAF(
z$0e+hAq%?}C2iDl(^L-Ny0qHGX-iAkie-^XGr3BF>Q`QI7MgT~C2_)qPQOl{N!m=Q
zuEMMny)y$Q9&(-PWTeN{r?K#0a)7gl(&<npi$%JcDl-%_RN7R0I;N&-B&=H46>?&w
zH`mOd2?=g17XCdI&@*XKz(3ZIc?vTpotbfDV`oC-%o$o!|8_=BOG>&nIa0Sf*=JUg
znP+5AM6f9L-$zOBw)w7|XtvFF?Ic4njk%Ie-D{<;><`$p;dX>}Xl&u;!c(_yJa}xZ
zuIN2eS}1KL|C`1?7oROoOEfs-|7Pl6_l;kjFD*YBukmAFE$5r~89x?&R6kU+_;*cQ
z*Oy6Ef-e@ojJxu8y4w_HrTQPt3k^IB)_5J9=%y5@$<4L!m%V$4m1>sef@v#togJ2D
zt%%fX>7KFd;<iJ<s}+5A><Beo(!1@J#fBy89oluh%x-6dd=yoDsI|wSC(AM6DyNlt
z(_ii{@(b(QU&J^4U~`?yGfg$=m=TZ2(In4Amjli!{%bZ18?8B$W)u<O6vJ6xJ4xcy
zVa_&#WeJnDe0)Nil8yu<1syoTCMxpBJv>vmTVo!N;4x1>Hcj@<ih0UMZM;7F8?E{+
z5Fv5q%Er)Mt<=OB8;so23|ptACM-H^=;af%+F{>@nJa^N>^8_G8%bpPT$!2V+1%W<
zRNecfPGVcYnKQ?H0-J=n4BQ*LmNp-)Kd53g`7O6Zs-!kgn^J~mkJr-Hu!W^7B2$)p
zFmz2QEKv1c`c<*xw3;ZJ*TKg^n|U^z7V;N!nwjdbZ(`6cSsfWw9hn%BMIU|{Hu@O6
zIvP~urSb3n%k285^&i5gnKf;nc5J<w+2<V--c5x}`0F!;^@p|WW6xBXoSkM7RaSo^
zf_KKIGeI6G#kgo6L-HCir_HGyeio1CJpVOiq5K!7xVa}^yRUhjw6V7`B=p(hv&qrb
z<-2kwPK;Abvb`|(Os?*;d)p>x5LH3^-o0zrZ#9>b6NQ77R6&#TDJLhZc?t>&3JOhz
za?ymr6aK5fm(hW)qH}>LUIi9L7oC1?8nd)bpsNT7c|s^xttB9}5N#lq3%V|_Ak>EG
zje*P(EJ8k=lP4Qyi0XDJb!jX@K^`3)i#k9URaj$D$D--?Y?)Q+b3;QGeXY;*`g--s
z#*5y!^FQshu*>?o`kBp_Vzadyxi0Ms-@9&F_UDY%;PUR4(nV<orl_TRxe6KX&XqJ)
zx#YKF`c6-;l9q<d+i9LE?@ZpVkoH|!ASE8YHcr2Mp4HyCo#IOOlB>SnKIP})75FaQ
z#l<_~q>DGV<(w_)+F3mHQLC@13WCNAdgC@~bb>|$vc7h@fV%C;;cL8<N)@iYmfD*X
z2<q%dTzxIn0U8)Mt&`fbu_t+Ue%iOZ^xo>S)0d*YRopwTE#c|1(Bsslja5e$fyMxK
zUktUVsVVI1+VOf#;hf|xEibRf6r8g-E_uvK>t}x0Zt0?n3+fxrKmYveYwox1v)888
zUfX?loq*ljON%ZpXgI&`_pP;`@2-ozT6T1?BU8z_(9nouS|3kG6dW_&ain?K-O~|T
ztJX#x(^|E$C-gzG#MU{-43Z^Jt=glTEO9h6%&=>ZZo)C+sg>ERaT`~y28|d<?M)61
z?{Zvy&9v&+s`Vnx;cK$K#`T7R#v3B8zLpM!3PD9qOD5|iOPp3o?b$fZ=vc%t!)YF;
zC6lwcr6ab^P3c{ull2v%F!BN4JL})`Z~Qy{w(9Tt)*tcQkN1hMZ~YW+|Ly02=?ycP
zlj~os>#th%ZGG0>b?d9|ty^DxplbEK56ssK9=-=1+`zc)b`AqW?gr498UnMgdw91x
z_TF8$d)eh>+h_HzKD2v}Y<2cMmA!{_1w<>Qx<QAfFU*<bBcq&>^Eh|n1_zd#7EU>H
z6wUkuW~+1fPHs^<c{nZMvavCn<;*n@?%nINi}TIyZ2Pq6y2kCZ-PuzbY_{Y~oKz}V
zJ!wmYPE=rea_h>-wKE=O>fBrt6**&L&-4Q`nWgK`oRLb~Xy(Ur+S}*;-mB&BOJo1O
z{}_L2>q;+AO}$;aUN0@#6<MmfR&||c{6X*)foC68NK6oT{_d|AL&M_R|BpB@FlbKY
zdZfU_z|hdZ%vAOJ00UD)ty{3#lB878+|U${1zZd)OpR+ez=z8+C@}a+u^-S7^x$IU
z5Lj4K&%q$TP{zQ(z`k>3D3e#^Rt8oE&}hlTHwNnbhL1YFZvzjuFuq`PdAve~fq4P<
z9@z~y7#NmMu}YMXcaY+9a!|O^z{|iOm2p96UaM+Qk28asG6UPZt6nP?8Tj(_C>+V$
z$}(@Is>WgkBVM)!24AmMkBkd-EB~#kaz2$PRiANS$r3@O1(!WvuJ|O(#Q*Yz_CNbw
zbvM#xZaH%+bJh`$OKy`)rEc6-$uixz)l+Jd+nOu0W(I5d`b<peRf#$^GgvDt<fNF#
zrez+N+(NE;%~U!m2Ijj>(oF@a(cKuSDbaDn*Ey}TW20EIZqTKvUb!p_q&OXPH8;B*
z>#diT%1~vv;KjIL3IkIBTW_zFnF+%b#>L6LEDIQf8o;YG7O*Vfm4+<XSk?qpbHR(@
z;>N{p$7XT*vO&@n<C=`KY*M$S%raCNGHzU4ob1-so0A*lx;9feo9)&n=}4v3-l}N<
z$BbPfjwSKsPrLc&aZYaT^c{1U1M4|%ZJVv+bz|9?%SpZ+SBynh>23q>!(6p(X)fE<
zZD*%Md$b+pzwMP9cFA|?R<o{c&Y58cazeL=Zd7=z>bp|fAxAlrcha&eYZoaVb1_p)
z^SHI7^X|mZYz?pH+8L)K7tL0<<#Tp%*5p*-lp7}3HmpwNoj7yLjo`E`S-P`)ZYS3V
zuI)|f&6+hkBy>yeiYtLho{Mg7%5|M7*>$pK(`qAQ)wHEOX<lchB}84g(LFb$cPV$K
z=$2K+n%;)4X|6t}+-?hntzn1`iS{s)_A;F+wpB^y)i$P_wTpriH#w)=3`pZSD*DHF
zb#_?FvIJw*ZCBM&7E7)+ZA%TE(PnljI?8ujec;B~s-9uKle1N~%v!cMXhRm)rm%wn
zVV827bJ^BR$=zUZX3c4B3B#siVMfzTmKjN$N*2kwvR*eRIz(DjT4?cUu4s;2Ei+HI
z3t^|4vnJh8+COcoG(*l(GmSn&*R6`1Iybc)ie@`1b|RZ)>ne9CO|y_`7j-9YbloI%
zX|kzn*rod3MY&2j+!0;Zn&hIoZiJomPMEo<=Y)Tm(QMsmm&CS8XQX6lT+>}~b>)I>
zTN7^FxG`HOM>^UtC#gFpH%mJtG$-4v=|*Ta)7AyGGjnHbcI&#hIxv@W<Hi-+E+<4w
zM^4Q(o9($}aw2FdKkC?3x7!i7j;+d3oE4I`R65zyY|71gpR*IqI&zM6ZEKw!tQ)1Z
z(05J5*6zfKE0)d{+qkx?YfDsb#x_Z*-maCZ-r1@-M>cz%IW0MH#u>>;#v%3<lapq<
zZ1c#`?OGGICe*DhRLV3t!nfOH)0N!hq_v{18QX-Dj$Kt<GA-28=fviqGsnV`jW%-}
zyIqsENF;EU!HHvw1MA&PrFvbAOhw#|F5AL8GdJMG71zblNvVOIo}RP1)Lg}m-MHww
zahusOwWJ$27A?wMtaZib=*FI$T!9md16M3gTCw7ak*Uy$jk#jIi`{fW+HOv}6m~LK
zRb^9}<iwehZCRT|XHFBkGG*$PX_LeLT|1ParKO>zrKM=5ogB8%OgT5hW1Gs2-lQ8B
zrH*dQ2~<tm0-EmcZMotsoV37KqIXu7(T$7CZkbB>m~5Qt(W@xB$t!Boq)5%2sh%p!
zE=6i;d4_5Sc}1#BT7P4@#{y<k=7==o=?x2*BkCg~{#@LW=5{;HIos`q>6VO(TXI#m
zFr?}(-C}lYg{_V;w`Qbg)zKNrS`i6fHhhivt986<W3oPv-Kv*|<@6*Tt&^QPSw{Qi
z55B3XW&2j8Ci9(~+_mxbV#zsnT4k#{FU2mMI7ggMl7E|6yNFfmb;+$Owq!l)Y_$(s
zwBI`Cc5-%dz2S@_Q&l~4uH?F1$(2sd37d4w>vV94S<?njmn`2vp=?2yK({4JR%&^j
z%xZ}=6!UTQ+_+g&Q)|l2pj)CHYaCU(9V4zxUvf0*l))*U9<ADt)1p5l^<)yeIeV6-
zB>w0z{@B@h=$K7>#2kBepNJhjWqwl+9XkGk?`pMDs^6((&H9PI?X}cXFRgFqN}6eK
z%wpe6gD(&JSKjpF>+2I!{Su}c;e9D~)jOAycAY(atJIIYSfiela@fdEZu&CM{)>Dk
z6Rj&!dPC-`^sHvn?yz^+IMFa>$xK_}sez5nAN{756)e-7lGsyN6Ja-R#xdt5bJA0-
zIDcu?h<=&Q-}vQd)S~Kol|+L=)fe+!9z1w-CUu(6nUiHp=DXes_w-{q*!7p`P56>M
zd}pRy6+WqaQ@N?YLS|~{Rm-(&+b%EJk!Uc}jr*g@Tkl1&LXVfm?lJTg+NgJ0!<i{H
zSIjUuYj@V=lZ-F9n|AZ{tn3MGDw7N}ac$bGWEGq1bt<VNXt6?YcIdv&y80^<FIH&9
zHW>(ZZ7t?WR-2J5so4^^Y+}caMZIE%qCzJ%wY)u5Cr!Gkn{!N<u}6(r!iRH{QUW8l
z>ZG8PDoZB$u4Z)%2yxrwxoy*Go@7;tV<%k&SM*LX?3t1*tt#TS$c)!9a7(1hR@Gpi
zKo=L#M73DQQiQ?;T?VfMQmb5BH39{V(n5}S3JS0YiU=y|Oq~?6Qq|Mb(_1rj(xgd~
zW(o=|Rl9#;dh=pt$9k7rxndbPv%RjdrJR{LG1)cox6r1gnaYnOmRhVlCX(1DVifdO
zV^cy8x5i)nTj@N7dR)t0FX~7vcN4MDc(7SZI#+AcUTwB8&FL>2*2!-TZF80oyrA6P
zkjxgE>VK@Z@Ss;otXT4wgWl~-hK;gK7F81tP6>RW-1#WNr{avp2f_M=J`VSU{`;@%
zzx|UxJagve$j!$2k3C(UfAsMDlN!gfEObfYDq$W8qb(PfUEPu!xN+mg-o;60E@t%x
zMz*aL?P?D8mD=X5s}`N<n`!L1w%gmtQPg!~lJ1r;gJ`xDmvYy*hHN#swAI&CHFw3v
zP01lqU6-;J>s-q@Dmf+1%WQF^?WQZafnryuMZ4X0yY0risyj40ereYIXH1?93@Qu^
z6Btw`FfciUH3@leUAo%gAuvgZMd<>A2aAN0*7}DxrvG2U?92Py@>~qVv0Hr7bIdJ@
zrbjMi_N@0kz3e&n9PK&g7I_7W!SkY^{r84FNe?+)vONzMw-&dnMrz&EIvI8{Ts3A2
zijubr7#NN*tW}xhk<#X=GRv7~!eO3C&L(Y=ifxiAZJ8>QoK=iGRW3=Sv`M5)lFSO7
zw9adr*QU^u;i}Q9F;i1kPg@!(sr6)a%4*e^sYRiiLQjTS<ZWRPVwG^xd)+hLdKt5W
zWVzSYb5pZ-cWu3UH0rt67VX@drrX}kNSP!#U2qMfu;AM5iP3q7w%uK_deS<tom!9E
zrtetB>{MSEw(a)TsM}?$qw`L-NhE@h*G{b`5JgbxVVl>EM6fQ9z(bJnP^->OEfX!>
zcDFS)cYDfVl?f+#CV8g7wXT_(Gqou6WSB?F>PZmCPg*lIuP|)RL#?fM59@~R-f{nU
z?$7+Y^#_vKG{mO0y|cJ+oy{PrF*76Yac^${UcuY3H;!puyM4pDbDh_XQ;In&cQ-t`
z93yeCi*@P3-F;@)%M80pw|#qO0aB-5y6qct|E{h17p4npGD_6*MuFQ}SC?%Co#O{)
zGw^0WXkP{fwrwjI7&1(^Ffd3lFz~W%YxV`pF*`0`V7SF_tpTLaM2dldhf(3xS_i)$
zzhBiz7<RGhF6?{Ulj}p6Sr1mcySXQ~AmNyX$hNk37PIc=r@4i>6{c(|d-v|0VyOXC
zg3oa4!DfjCLARuLJeH1u7~R14eqYz;`?X(xZ|n(PyM05saLm+=Q=D!Fvlni?RGN~S
zk}l@0p7*%3^lnem+}yp*J7zsu+p|dQ)a>0mZh@`wfY|f6H}~2%xbg<YQix3w?;cAB
zv+*P~dS~Q89ag&Y?8)nv*DcE?ehRVAPPmyH9kDTRwR8w5G-c}LtwVLPbaJv?!ACHH
z0tbdIPjDr&OgX`o;yBZ1Ru%&Tvq6)?B(}2)w9Q&haAhu=?ZCjmnARbzsln{KY=hX@
zq*)B2vr`xLin@V=n1O-+Xn3elgILauC<X>5v#ewTWrmw8S8icoVDt<QIF_~S)@f(Z
zy-f@ZQrn`Vzr15%>ok^}#K581veY*s1AZaK6vnBkYi@2}04=b{O<ltvs+Dt#fq`+$
znrq<OQ#}=~tc;8_JG;_AbZI7A)Y&x<*E4G{hOM8vZE?2S+QqqR_j%?_ENzWe>7IOk
zzI}Me>vg+cy@u}3uLo_=XINfdeee4orjG}{SKs^gICtZ=+uOE$;9^vHSSi7M;-GZ(
z?Txi}oBWTnlsqbWzTkOt^>Xfe+tzw0F4?{7;`i(=HFrO6+y3m2#M|_;*D-HWR@K?w
zKKgpz>#HwZSARaAdDH96U8AqnyZ3zOG_m@yC|c#+yLYd4@A|s(ef3!u$NEh!r)>J!
z?Y?~9b~|U)>X!;aehl>uGDSO!itm1hY+o-(ylcB4;N87_-_|)FH~BtEy6Sz_lh5hp
zwaRwCz6KfyR9N57-1qDGN#Xv!%DXpzzmWCL%*>C^?bY_W&9v=2<MZjQ);l@M_trL}
zo=O1mbp0MC_W7Adr!LK%8=b~{UPi_G-o87z+syCRe*68t>d%T*@7`KBIPx<v@Kvu~
zy}QhA_k_%!cHfq3W%DfzVr$+T=FskWx%GQg(1EieElrc-^tomoUU^O6V(QP;A8!`<
z<gJP^ymjvFt)0tlI{IgG=PF-clJjb*u5v;@S69_`pUp8d>qFOG-qbri=V{;iwi*WB
z4fpPDeP4Y&d-~dY?>3*k_crSE#U9md-qmHVS5J`?6>*sq_h;Yty+6Na?-vXSzIOKQ
zw%b~(etDEkn8bhTCN#L-u`oFsibrYP_FA=0V%6`HyoqrOPBXQA{l2xR@_M}C`ij(h
zS5H)At@AJ5_HAEseZ0x<`*Ew(`zCp+E~{Gcc+scd_pAOK+xYlNVAaj<`*wbEdHgQC
zy}^3p?YH0fQ0D&MZacW`#_ZbKx2oU1e%~_v_Vs(0%GcfC-F63bRzTUcPp!L?a$mpC
zRGH-DVI%OcpR4kzVR~tj%hE$1Q{E^}otXP>-3H@j59&{7ed@OLdS9Iy67Z>VL$^Zu
z%G<ZCFR#vd_bHxv$s|t|CeKR_lNeRF*It-Z^*dWdrQP@C+XG8|)4tu#of;Yv8XA0N
z+K2DecNiFiRKHJ8FWVz)cJ;h*Zp?RA@q1riEz(F|$RAnzdcH~pSA2Yu?Y7<d@ztKS
zd!de=`+8fw+P!_>CjGAZearjp>-U+~*K?$En@*N}{k~<Ar+U@f&h6{>E}7)XsnEzL
zWV83N(4M85yIu(SnT1Af;Z)DrZ6v63_TH3jQ@`)sv}*6ek5ga7D>rm9&f6vAAD^4j
zG9krsf^@>NnVYw-EqVU@?vKy+ew6#~WnqX(7WV4Cvu94luHVA-=nmrDb_5iZo+>R9
zoC+q|F7+;twN9PwcRQ_W>b-BL*3VCw^6jDI>xC*`zg_e2wDJ(Hsy6dkwX)KEqT}Ox
z?w5Z3`hB?jeZIx5OE=%XJp1+Q_nnpQ8@yk?e$S`BckT9bx1O_In|40m>G!4I7o=am
zeqYpCzw7s{+cocQRaX_i-1b!H+tfbgb#rT0ZNFVzb~`UFkgKda;+Tc<y0*(1;-^-v
zT3x$+yT<e_QIB@LynYJ8nK9#-Ufc23@Yvejx!d(MS}m0{o7r|1s+a|z;@48!^}DFE
zQn@F4c~14j@`+#e?c4X^vDbU6Q@^b*+{-xq`h8J-*Ei1E+S-T5x+9KPhQ3YB-@YL1
zM!wRu`1tCn<{4Y>h1|P0chAkdJ1eWRXQ#{p+3KGkZymeS)oJcl)847me9aawyP)|r
zG&FSI?b}oJb5mw+kG1+4n!oMaQ=!ko5=SrG_^|5r`t7;fo<0>=uHtHtaNSR(?Np`X
zQ<v-Ud4c*W^@Y79Z~Kchb-}6N*lB3W=-Lj7g!uf3oB4Z}?1Ll`G)b-dkf=*e1#A6%
z%QeVjm8bgLtrHIyZL6O8KHu|sZi-6Rl8GUceBQ3<+!=j)s!lxjq2<+8{?^%wDxn3J
zdFP2#*WU~EeY<H#S@^QHd!ga6wNo4!Yro&G(O+4+?{N9ub?^55_+!izU;VzW#=&lW
zy!XDh-|x5dfkU;kC+S5_MQG{u+uLpzed-9Fq%^}Id%2Kvs?CB=i?Y{m*O)%Z;@GaT
z<2%KFd}sVoTD|z$Y^$?9H}@5uS-5yF@7jIRu2Mh4uhk2B%z0&6e16)q>z3IkKA(-t
zej9J9TC-W*`ot3d)$88%+r?ErdlL5Y`Yw)7Rd1hUUwy6mYSpp5!i#l+wyp^JbYa@+
zsI||ht&UQy*s_HyU@5n^)1?cVPE&Mswnkmex7iwXQTwpA!={r$ty32&W{52G5}UGd
zO}5mvtzFkl`-Q|By^KT_W@dQZV%@W4VP-~D6sty1>-K%O&*m$K&yEYzj+18HbImkA
z_T65;2YcmSp9*^ScCYJn!HvuY_37er51lxl20DFNa@92JYKGJ2Zy#4*Hq6P{`KaJl
zam?o<>y0yRT;Fxq?d~;`i0kVbL$`ZJYMrcFvT|`?%A}WNCpU{qt4xYp{pykYS%Y1M
z$G-~eNu*6OC`rC(CE>^NB6*|5^0M2}IkIe%4E3&@Ix{Ks+I5yy-O?c**@;W5Et_uE
z`&`WpoN?3L!QH3H)<E;o>I?H$EuX}EE8wHZs@J*etzPGro_POIJdgJ|blW{>*ZmsQ
zP4}Jpd(Xa@yW`!?MuVUg?Q9n+*$zHo7L*WkdY!m#o7DTP<gBYJdzalSx!1RQMaS!1
z9dqN}&AzCR%f4bU<AnN`3hiYI(JV{2E3W&_dLkqA=8fNr<q1na@OlNLMoeAOBVn*d
zwX5?Kcgqe}(ZkxJGp8Pn3bo;zVyLs@jMXHIf*8Ke0-Z2nUg>Db&X5;Vud-fH4_WB$
zR+2P%>7`RUUh1rQv`%M@PtSDMORHOpRvG<JvyRM~ICqWlBzMV(7hx8%^;W7EcJT=v
zExhsKftRJ$+|II9;i=*ofqoLlGmoVv?NawFIj41Iwf1tCV`7>&{w?P!3p#mw*NQj(
z?Ahww$5r}FCboNTjCc_%VWryK^ic26#2e~Ug*SB{5`F0UplkIp!^@kc%?e&VN-cOS
z+oyW@P<qRrbgvDmaek>=kH)Upu}`8t`Or?40$btcKF-cU@g=fyMz2;`3-`N4T35vF
znq)D{<I6L1m43NNU*{BF*d1Z5da%GojBirxE<bLaf`Bus;w$!Qlqv1iuw9|PDEO+E
z>#dD#Mls4pn_K&on=j3j<FT8=6VA_7Vr3CL$(^HMU8q}(u$<0Tk27l?>YRB{Fil*h
zzTo8z&5Gco+)Gv7O|j8h&lRxy)$Qy&%h{?Adn#VsP0l>CE#k$?N4u=GTPo&e<{B@r
z*rxYlcSKHZ=IU(2izP|N^x13+{<Z88vnjB(Qhi@trq?4ez3}X^+ZmU0x4rxz#`(p6
z@im_C%X)`Ol?v=Qlj4Q9MP^OB{4D3e%cS65@7(&eEoZ`VyB?JZ+el_je6G7L)cs!W
zO`W6|(a;&1X(G!H?dyCQ`e5RlRqGe&ZxZ>Xv~PlEm3sEawoGM#latPDyvR3e$yu$9
zet~{1yIA!vELySGfJ<x7r+}tZQLSl;9a-D~5mP&(LQPgB_;5~4iCCuDbu=NEX@)mv
zQpB_cTUlE+)K6P6Yf)00Mxw#Y(5Vr}SPsk#S+gokW20+Jm|&#SDKV{$p<PKc)Hu6z
z0+U2L!ZZvWr%cvV6Ec|Cr4yLdlohJeaDtcVf^N{28D5E+E1iSd1QW#;&FaczT*9Wc
zCN#=vmeUN^MA4O6M?ygwCWp+sB*!l`&+O92b^9wGN4ssUUz_b6w>IL|e$`30KT7Sp
zD7K<&LC_>2UEh6s-_NsKzW4YZ{e@?K^Id(uz4ZINeb-N1-52%v<jfg`-Ns?3uD(<{
zDaLAbyhnQG>+9j`&5qsMTlwB5_D*Tl@##x9EcMgP)`-65>9A#st}a)=Ql?86wrtUK
zn!@ev6n0_znn{hIa!RCrp%?4Yg_#*atr}v}nvQK;lO1(UJK~z6L_~P&LXVK88>T?C
zT)ME7D?nG5zd)w&{v77^XF*$*oK%hQOcMOju>Pn@7S|lj6oZYErZE{aN{Ad%D(ILY
zvO!rz<&scRmyVNEXTXJ3GnQy}EKTBC6QriJFsZ}POH7F;)McY;Jr7re;DM=D4q=*J
zTbkwys&<CV;K~wO*%ayJ@~F#HORZ&x*W@YUEE{!09Xkar9KF4!tQHDP=~~#Ra%9!Q
zmXJg(VG*s2rHW13UQIngZ7U}JS*X;@<?8Z6{9)`=|8o;>aqn7LG38zNuJsMe4=sMm
z`oa6D%a4FB{-JU6nyOZXFRd3}r2VM%!>a#6^PQ>!tDN>~*arE#^mXa2;yf7|r?vc|
zmC(GP_9Xo&!6z9nhL&o$YdW9OyfIxs^rxblrq?c3Jr$LsBJoqa+8=rZe`s3$p{w;r
zQ0tFSm;H?D_d~d*C+{hrcImykRoJNyH?~B5miGJbdiUPdr@GIsnZ3GvwavZP_4mZK
z&NenS%{uYMVrAn>S;N_eZN_N^$8wHIoSku2Ma*mCY{OX|I@26e#GPJtB%3AMpU>T0
zcK3Guiq6Wo%*wT^&&sCey8B9}eU8`)+QVDU`r>=O$-1(8Tch*SXOzayp1JE<?!@aB
zuX2*jl6lh3B=+3wLD-S0P`@b@CX#1)+<ukwPmT?S8#iv;xJhGCmltG;Rue*LEP>9<
zPJ+(cf;Waw0&Njj4S`94cq*U`<DDUEBhmCt^|}O_K6Vue^mG-;Sk$Gl>Pld}t4N?A
zc%B$SfaaE6K=aFjA`k&E87OuUBqkE*>I$O8y0nghXQEw2MMVN##WXhEj!p?*|7iNI
zXXjS*XWz-OzVhArU*?&cx!ag-g+IEGlUt_~U8fv=B<n~dgMiSs*|pX8Z4$hbZmpbJ
z&)G6ZbV<uo5oR05OIk0jcdK1^G%0ND)YX?<-#uP^<%?&L)@P}&uh*N|K3%&u$YaA|
zSLLHsH^SF$oT46dtdTn-=$4447pv|<?~H(@8Y0_T*Dkc0X2KEeH0{DduK>+lu4t!L
zO^2mh#J2V?nZ9KD(wA9RK3`iKwRi74*KMJ>Q$<4SmnsJ4PTAJV71ZdRQNj1PX@2`d
zq4omrAVYoW==`|vCGTRMzTI}~Z`q$*7Ph+i>ubN=SulV7-O#G@=Wab@zPl?VmxZnR
z?rXbOkMEYOSTOH<?zV5oE;yv$d-wa^=kvC&%Zr*;+&0~2IH|mJ)84yLSFCR5PCIq&
zc6QY5+-=7^rE`1gQ`$w>=1zTeZBN)%-ECXfZo8e6VqSed`uh49n}QEEWpdWX`##w4
z-Lon0mwiwnyQkve<HV;`-xD8KeB3L1D);fRkB|58GjH#geOVPZDQ;5SbdWb8xW`sy
zPr;Y%Abm1kj1JOIQqodfVmI~%$8KI&G*{}{77hju$9g7C1#l8vq0{8aI%%;n!<j=1
zHgSs_HT3CRGc|3($*@cvv$Uj?)h2CTn>`aZ8}pc@C257M4D;ITk+Rxk!kGic28o-E
z8D}=6B^*vmlgK%9BxGgKnyG1%4yUErPrF(6_}=Z@_tiJ^o@!sTT2Po9siLx{bX%i#
zn6uow+xI@K@=7pZW@=?)HDG3HX*#LWbTUQEF-6P~!hnzvk?LJ$z1yd)tBkpN_nK+G
zVOaHn(pNjT@8H|^vHI?7|LWZhqSGJjV%ApcUT%H6sB6!y&!Nwbiey*1Zl7hkeckuC
zrKfkqiC&*xc5lt++na3;PdD1ltXJRPpS%0<?Yw{Uuh*DnN39NQo%C{5ciaDG8rmwS
zvJF+7PBpA$=KjFP#MJ-(zaRrM!?KXyooCoKH^_6=avFJVU^pEi#km1A61IRrN`h5E
z+Hf;yhy4$i1_ti8TRc{1Ffg3qSlqz)(m{%?;g0muz(WfbFgq}<v%Jl~z$!4wtNu5e
z=LZK~UkC918cDVpm!^728fBOqIl(h4<789t$-v;C6ox~*3~X&PJYP)-6k;+-n`Lt4
z%Zz3>rmRr8rT)PwGo?~0ofS+DF=%RZEOKFAxqyLz@y9=f+NrsvWi9is|JAzv<+Pb+
z+WDKSG_Fdmn>j(}Oye^BZ`Zvhdt7pxRqwM_B~#f`sy8Qhl9|WVS(AgB7Hke$GjVIv
zf)!>T7?1(u0*2dc4a`~BJ#O(%*tlX#r%Kkb2cj3YOmy=}IOdb)lWdf7EW#(*C|Po{
z#F?IxkyDc;m-eK&_M{p1oLXi$BYyi`tsVYpH!h?fmrlB!BOSPH)x!<a^^O~)Ry(fU
z<(WHa)#@2RYp$hg+)l~e;#3?mn^m{%!rFvon=~ICl+N{9W;Dg`*`YO8H8+_t&g3}e
zwY*d`muqGtS8=YW{nXBw3%9suXK5uf{Oi@s4c!{DwsFm(Y*l|<mz&a|UN@u;`KAOX
zEju+^Nm?mw!e)W}ixqPNHz{sX%i^v#($c=WGFMC|I$}jimS)<qE!jzn7OlD%l9TN$
z?RM$LnlpwzM`vsn*&I4^nz6Fs%rvhw?-~>1jEjq-jvdO0Qk`||nwgo_TCt<O8NS<e
zS8Y~Hi}X1;(^zG*x3Oeo&#^?GlWG@yn^s3U-tU+ls&!55e&MW+KsPs2sV>76ZGqA{
z^^1e9=|rxM*x2p5=$I+b(n+^maupZns%*M4Wzv$BI!iW1O}a8wb<&k7lTNFudg^Z3
zwq#n!va7Xcn-(o<TC^rNTJ6~4pq!{H(@v@eg{pe028FHtrkth{C~~A%)FnDwr{ki?
zCS^yl1=mh`=4=X@v}DQ3l%=X`Crz4`CjMq>#xmDw^<Cy^CdW3c(vO@OqF;8E^<&f3
zFG~dyvdpq(^)3~=t-H;s`{jk3A=6`e7e&`FY-=!G{haHvU~Sp;6?;F59ohFNTG1|5
zH&y9p?(C2aSKof!^oM_CTwvw4_Pga~>o)Q|(SA4i*n+1kRS!1QZrtjA@toF%OMUNW
z9y8~+&beb@Y1#dvetzaN;f&J;$5!pVoOC$g?c&V4OV8%4p0#c1u^W6QTKjmzZ-<?z
z$*?n+d&$RMUB&-~Np0$npWj!Xll@cu^6Kho*?zaK=No<A$LAI<W_seCpVeB?^CuQR
zscgArbd6`L=fzJ?eKQkR#q04oPjg=FIx{X!w>@XGXW6B*+*@Z(P3wA7zd3AXXZg$A
zOl^m07bDh8P4Lcs>Xq2urdrn=6xZhT>FDXxPrrTp_N?6Id`We+p4(T8dB>)2T>7(T
zkAJSa=$m43<||qA7KevcW~~!_s+aK4((Ce)(5o#kJ+F8#b2#_uFURx;)mv8?>&`MY
zJDg>zGBr>rEUI<mno04!8ow-MWOVA+@mQGbmnh*0ZJVy#T2SX5da?DH$HhZ+oHt66
zibV^uCmwq6XZn*J>)CYt`lgA$^bq{n+jeqmM%Jxu+j`rs+}dKA8y)59*s@`%VNb-y
zq%$c!OJ)ZwGdSAX9h%hZu_ozg$I+FBZlO8}M_1`+PI6QHspBoq$5pVSfStRYOXgN?
z{gyk1VfL(-3==jcY^>wv78BE7+AV(QXV6zeucV&I>W>~O9_n9uDyY!9XsSivuBa(~
z>UjY>0xvyT64SeRyPn~u$k{%}u530d*{-neu5N*Dsm0Qw=VpgFi=ImxoQ&C69A&g-
z#`N2*J!VqJj`lB;I4tjz{PM}3ZQCR^t@h+G$$nb@W%tEytt}yk_o(bFy!75pXVs-;
zvQHKj-6`3%yLVe|j>AEbuqLg~TeJ1G^=|IY+Bs*-*3SO63?G$inQAK6f)af;KU}*p
zZAGF_#n*EWZiQVkJ6?6)=C*Uvwu#4seyw<#D>dJB{mP?yG0$#f%4{h%NhwIxQ(JL<
z?{l-~_ws7*E8nlr3!YL?W_{(wd(DIAqW5fjJ8k2~EWP=1mf?#RZ#lT6<i~{%+4HiB
z&z*QG$6MiE=UN%885eTP)J|-lI`g!cTZVc(3y+-4uik$4-L*{>9}E4|*^_tgm3j8=
z;ngWsn^qru+4^>k#rhzt$%~`jD(}1Mo|WQ#YTCt>Z`W4LWN!A@F)ObA>w}xw+S7Y;
z3zo&4J05u>yxYra-KJ^FTf#NE7i^kp)p0Xohfv~zd2Tn)9i6f1s#xEG*d^jxNuk!d
zx~{Q8;cOk;A%9gCUivd-{RwTx2(8E2Y1d90ow?1M)}1per8(Mn+lpk7giD9Ilmi#L
zB<UpexLwrpOxYAN%~Mx1C}hgCCH31_wl0YXY84bVTBhXD(V(QE6sfJUGRSMvq)F2v
zH8oAv_%Ah^YIar3Byh>Hq%+29x6@WVa_c{<?%lEIs2Zq1(N<l$*sbeQR<~>9v`tZG
zX0{w#y!6ant_^%z8~&VlvFc%bqxYd_8U4JRJ<45c{ZmRj{&dRf-;i82v&(R)-1K_m
zAX}d1)~I=cm$aL|7#vuCgX_!gS+;^JHe7WV+F0qlMEgU~E_)~K3*qcbjy9}sSjX?C
zeCchd)T+L%E;~cz^7(I9$*ukRYu~++r*C{ZmGX8^ayc<c?Y(-X3XHee?C(+bPZGzP
zO;cC+TAuFV=~avj4msGhVcDX1`+~3uyOkdtoVqGIP`9_Yx9hB#+m#!euIa8cTdlM*
zDm6P<L{#Ef$F*adQm(C;njLXDRodg$O(pxItbeO+odNBpMA-}qo(Pp#EOAtDdTlGS
zGEevuaLXA)1Ws3+%&5d1dL|jXpHvUDpL7LyN9qxX5s=l|(7l=>uuYyVtDQi5H77r~
zA|e9XvzZA!j2omAbj0@bhpH@6(-oLmxu$o1W#y?)mbe3Q71$WW7Ed0SnCjLH-*2^l
z|GwAPTldbq@YprO4lR6?LAltG%cXAbn7bp6DXh4ATpEe`w6=QN*6`!|mT-bD`QT)7
zuimzzeyem=?^d^4i*v*0sc<s6=jMJ~lPnOD@J_dL*{dGeV-v;RS=>5i$m+)T=*FzP
z6$c7;DtJJyjlW*xF!9>Yty}-8w59&s_5SGU{ruKNpL5M0zF+%v`*v@g&5Pbeui?6V
zzvg=R_Gx?G-PyZs{pF;K$;naB2{K4SrJjL-fpH}xBO}wz3<d@!Atu(T4Gav7vlzr8
z7{pKMu4`b-5(!+fRTQEcL^6KUb8P5nS-^J1Bp1|hV_;x3^|%6=6%B1*FiqhOI|W+4
z$C2&31*D#VIXAR8J2`A?b@tOQ?_NHBoWAkS2c<5y3t@)G*3GN`Jn89g@%;QNdJF=L
z2iSck^_J(veF}amzT(r;eYNY3e!6QHUHv(B(T}Q+4PV|*m-`bN9wJ&%p|!m5eY~j3
z#FD8+VYjb-u03n_&i_8=1_s`3`>x(S{NeRk?X^ok{CK;!TK1lQ&kd6w?<_z36m0Rc
z-CHhoKDoE_D)*@l(Yc4`JZ`Ty51IF!|M=<0Wm4ADs~;x54}7-x-6!kz_pVo?Ls#9~
z!8*y=ciZk+-P?A=FeorL@Xg?~-uwORy;ZBHhJG((Wj+03f?fZ-kFt&h`zFeH%e4!>
zHVJh1-SJ2_H1KL4@3uEhT}-nwmo0PME~q&xciYwt2N=w5*InWKRP#A8JSXMD^0@lU
z*j)W4m&=j*iQ!jmPo9cfxp-Idt)ItZGAoz;y7~5%&6V1FF}o-1`1r7Zp@EOV%3y1>
zqr=x5liun!MJnm#axM%ko!n;0dTN=c%EXdMo~28Id<!B~dUn0KwN^}mf$etgmaDee
znX$QCi}s0cpS_{IW8Sq}{igD&q1U;LjAJ|X>MyNcC&F8%vfDdhnrHuPCqa)XlN)!P
zm>tG<&Xhq@WO9s{r?OL}&8EyNr)K+ZTU~R@ciC>O7!9d6o@LVxrW|Wn@*u(lV&&!Z
z6zQzbncoi<eKFg8<jJ}V_xfJ1IIuI6DcF0<Zuipb5kj*n%S*oAN@<!EUs=+=F?U~J
zv?fzM%g$}LcbIGoin%}ONp-%<3GS0qw%wlc%vFW$TK+7}5}$@mbun8&26on(&n<eT
z#(HYiv#GavE|;EO*?5}g&vd2ME2^rWOB1%;p8A~YgwUGXxp%|^rc5_4$e78Paw<Ca
zRI$<|=4|t`BD>TaB29I73&mv1PJ827xTY+6qw2AZ^*8g5OqV)et`~c&s_L0_&Fy2e
z`ZkFqWnKH6xozXJ#j-oMuLQXvRd?G{%ZZ+hTW3G(iWOGSnd!YKg>|xK?sm;HT^_t^
z?wbU?n8}#(k9+;&ZP8EHo>=npb?)_Uw>`N}IhMS;@iF<u>Z5P>PQLe1WZsK-q4b^d
z?3<SHB%GcQ^W<3l(Pd#_>8m(8R;*A`nw6TGR=HqlS6h>k#<H}u^jQ$$MGHE*K0Hvd
za$fTEQFSX{r@rhq>mrGXJ}xdoQv)@+R&=RwLT|a6_%!?N+O2;S5}COeJC26mkNW*O
zKKI?%yLa!Dr{2n1v~Gdl%w;RHm!-^`>cFAG*}$m4P|v_1;332Uy2FNLf8VOx*}1-3
z9r!|y7#vEGSR%M!t5#s|T1lUvW+iLaNvTH<E=fJ=W9sX5IL0LB7;nL9(a@Nc>H;y1
z&b?U&`?QNJcCMB56PPX%cPa7GoRBSRwyKM#6j*GyWc13JH<;_NMaJ!QF|sQ!hAv53
zvO8$5m#o5Wje72#YYZ=*j@cSx)vi2o-SNP)8OOa&9MN8}H}Hv0$l;@hwAmt=yKE*t
z7wmWu6Om-}k>zm6kqvjGEQ1evU0Lg~oYg|)sbJ9(eU+v?XKiNBJoQoP?d`3%OHvX(
zDo@!h+poO!#z%FZQ&&$#g{_ov-=@9AP<_#<mT#v+l_#uQ@%^r|NB#4lEIHP~#1*Np
zG!3pAM6JH09dOY3s`^U)K=)N4RRVFRCe6Px@yITliZgqSLi_u2tYUZXo>8fM?Bvy_
zPao|KGD*9&>YLfpSGN7hN2{hhaL@YTz9q~3NRs=JlS(zxyel_cICeTYtEu3U*o~g4
ztJdqN%-Wc=r{hbm_ESC^l`mR9>N}RVhS)Cn()^_Br;@yCkR22ElT{-74y+2PH_)0Y
z$-%7=Dkju%B)~9awMfvRDTe}^d^nEkYGnp%&04CXvO!ERNjEUjXUP#$HpdjPMUom>
zs;jz1jGR3T*%UUiE(#V|rYb3tD!L?0Ai^<I%V?^ki%Ca9(?QmyK_;u*Sj1Sw>tB2A
zcmDSDck%uc#b%L{z9#Jr37@5$WG1AmEuDYriR>ANMROnDvp!~hHuRymzLlj<vURxT
z<eW!JTwNU<T3Sj9D^_$gEm{QOilwEcxy}@mTm}(de1Y%X{|v^v_iwAzb8K<dO3-!<
zIkfnnmJMr==Yxr1LQ^FIBkF|`!ju}DHCk7)u5d9(4Rz}X6Iz<JmX$|KV!|3pFXceN
zRW6AcAqIj?t*f?ZiLF{{utdVuAc#lMhtoj2QmHeJW64oDrX!(hi*~IFdbI6!Zua(1
z91;RLOgt<MOq@)RH9GJVzV~)+-YLbr$wxxg9a>Q$G;7<f`rD^(DYY!p2s)UPbK{oG
z1mTvC0qUF@>x8?6)&)$o^3n8q6zI87X^vXMqz3{~la}<~b(xasv}*PDj|x*Z35Xw&
zj$D(Rp<!m2lboR;W*D(C%qU`OXpc?=Ph!%6qy<-)_6HSAxpU-fXwI_CutR6qE+?5O
zXWTODT`Y1)<!|tkx!UzzOX?OcDcPY>u%m9NFYAlW7u$Llr`$*mTJL!{&}MQk^H;ts
zou*G66=D}R<(Mga=rig*DsyU?!fv6tA~(%AOZYN{IrKaOk1Wn|I>@?IY4uLka*c$R
z)lOHGW(I8NRGk#?OWylst^U$4d)aShB}D}tViP*GG<3xl9@Ti4pjwu>^-7Hw-F+f9
zY5C3fUw--J!!L)$0*-lY)SNPdbuy>tO2dT3B0&e@y=y^Un6mms=%W*cT^rR5BPNR~
zdz=YcqbkW&5htU`{nEYX%+#J$Nrv5AiO!DROh!Q;_E-e6-<tR^S;9MDE5}xDp>@Gi
zFD!`9blDYa(dGH~(1iL5&(L32>pjaECdGwM`}oD`cJ8IuiE4LSBMvFd{rYxKb?(%g
zWmjFILnU_nx?t-Nr{3t7{APQZ+>2XxPT%Or(h^#>)Fm{9lgWii#eqS|Vd9@{YqPVy
zZT%m*>VE#-fZeu-cRcg$%gR}2Ip^o@dtdXMg)}=lnu1oT3Wf?IZUwVv;SSB;HNE#7
z^Yr@1&nwm3gjGKOtNn4`JKpsV2iK`PE7mC~2(4MaeqQC*ish5nb*yT9RQaTA)kc9u
zALj*2oV)J!vGVCjNNdi4#iNtS{b<yu?JH}(ySTVtzqM!W``r@B2A`$|Eb8^R<TKgh
zl24EFiKQN&lzu*tR({N}D5O{Aq^Pr}QIM*@BGY<a2q*8sgBMo*vu|G%n55EKUgR-J
zrN3+2ueV<^lwaSvn_jlVZLy>5aoKWxu0_Y^{hazB<_Yh%LvJ_j(JP+w<aW-AohPTb
zhPbFO3bH9GFfe!s*=dKZpWojyQN{aNM?6EP;2AAbs68$ny-vEKDkp_qz2{8ruX$4M
z;^Mwl&!yVws;805RZk<uGX?841XvgaLL?a2;|ssnyu8i9Q`N-olwsYos(8tAla!2&
zJ!^xdbdt?Zi<v2FhiptbDzw!*V`IX~sD()<x2z3X9l!bS0ftTi2960T4h#&U86H9=
zETJxO77ZDX{3d8I^lp$UO^~~_YSFq?3qwQeLqovLMFs};X*;({i_WXO7Zq1|FEVF)
zNJvQN!DAM27I7j>Yfh-HDb<t9SecUXE-+MZU(CL%-}U!@$p5=yN%s4fxs!I}-c+9L
zxRWK%g4Jqa)Qv?G*Iv4<T5x-lyIHe};Eo3(UQ1L%bGN99^tvsXy>^?|!%fe!wrsRf
zRGuAPpXVsu$LQDTGMiEDn5VGr>WDdo7IT!0c@Fa^X&ao;=2;zdMVn`ftDqpq6jWmB
z#`L7a8%12xrOuho$+pOfnwm5vJ?ZSsg16dhmq$A#-CA_UnCr0Cm90vyT35De9R(Bm
z55OmrZn77SUceM`WIIDWgM!ANe})W94h#$;2Yi1puwR;fsezSYf(HWwg9(!Z1G7UW
z0|W0qS@tVh34M$&lvXSf2@POaz_(ya%31~y2G-+6333bpj2)MKr8t8xe+><}aL^>P
zValhVsSKGfd71n}mI|=-GN>)(@@Oz&2nrNf)%(iXUvv4nZ9h+&Wi8oUpE50H(%DIo
zo4n2HOkLN_oS?nycFCE>v=nY*g~*vqXHJM*0q?_MU|?%t&Vfc1bc8cUih*}S27}o_
z(153Iwbt#kTp3|kq#0K`ZjcT;61M8(WE0JWs}`&}xFLt_LJsSyrnT8g+9p~zRvo+T
zxIt`7cIdW)YV}^T#BQ10(rvmTx*>;c#j3U2?&oSQjq<v-ZQJjYYEv%VQd)I8`i9#q
zX%Fwq#=3?%LbgshoXZwn+-5e#ams~F9nx+my%apX&2lof&K4B;zsIe2jqA3ntB<8I
z9q`fWT6OCyZ(HIj-_RO^YhCMm)6Vv`|6!f9`qmkfmGOcRQ9B9)>!&q--*R=4>8jSR
z+j6!AZPu0YkdMlZ4v|PcT)lF-#D1}e)wQeUHa?V%&Ri}0)-cv+%b}93{%0-=+GKgz
z8*W^)t?BDzHLW>4LB^>ao<CRInrhaOxX^E{yu=Qp$O4N$8`69p6m@qMHvQq>`gGYE
zqgxTaQ*LaQ3=><jH`O@g%c-z{sMU5mT^}7bntaSBbyn-6%|`RroH-M|Q{@`ZES3JV
zPBl^*KMdwx<#wCu-rD{6_`1(wo3`!lo%-m5P5ivu7hW37UfCNXX}m33*-clk`<mR`
zs_AboGw0Ut)eHE&TJ_be#Ya!`DZYwY_+;mivX!g)*md**V}*qqHh6bUm*D;oAAC3~
zGH0=&$<|dHrQc0RxwIwwov2a9EK|Fe+HRd~`a6`}ntA<CIK?Zc+}PH;GQ%)ecXDcu
z&#E&nt6$u>n4Ih}{o<;PQ{~;ljD(Cf?KozX*lBfIXU&<^sr4=Tl06%ag+&^rnVIzX
zuqi&;<b0S}O;cYo&CST@(8kGXf!fCmC${OVY4hpUIC8?!@v@rFgwmE{nrViUb!HkY
zwK^>kk(8RMt#Kr&C!pX|q(PWb%1PB@KB*BYMjPA$JG+cL(?Sl5%<%CEIka$5pWuo$
z?lMddWeNid`YbsLw$-~`?$bIadRanh)y9K|8!q}wEqQqLaKnLJhvuZEhpV358lBsE
zcdOsJzRr~rJ`-2jB}*ikx>-Gzc*=j>?DbqzK6$1e5uOPVJrSIZ1qG|-=x8Ry$Y=$(
zHf_-36ZD>9EbY0~=h&q@9<9TzhkVX%$?!RLR?=HcS&aMPp<_G=#}D(=C-%1)e)#Bp
z<g{AA$(cr*7Hdsb3!MD2P+a&`>D24N+FC|lC$9_qNSc}HcsJv9*N%Czsijv=o$6Vd
z^14;LO)S#OS}OOty4te6+9z|Lt!LXJxa6kRfm>;7uBE*0(&xFk=FF7GhmAHKysX@_
z$H#A`dz96zbu-<CSsotjG5C>u=8j#xKJ$U2NvpZm%t$y1Iv?j$Tadw)UE9o}C4FXw
zrOukw+vd}pxFuCta(cUrx_<Z4Q#)o(wtA7BYUXhw>6(#5SFg8z9E(e)u*$Ze&s9E4
zwyan0mN1!i;MR2R4f|Hb<jk@YzhrE7alz5nldEKO+(Qa${j@s^ZS>ZyUU{9l^SD@P
z{o$9>B`aoL);x0XO^Vc}<@+k<eSdG+y!hbJ*uLW#mrR{kR+LWXD!TH?sPyWz%c-Zz
zD{Yu1u1-C$%cR14XVgBAJu4^mi*CyJvQJEB#ghwjbo8!=`OI3peP_zGKGCCvR<WC|
z$NKF!xB1~^i9Kqe)soy1`ZnKt_}Ds+TwFY9Z-{k3ec8dqYJOMNotbtiTl<Fd!WH~l
zW<56gnc`}!hmKyc+Gv!rKKbO<l+)_08PD$OO_OQ0=~<HP@!U1BW2>AfKWE634B@S6
z7u#E=E?Z%vw`5m@kIzcOq7{9|CPf6y2@6`DxpJkrhx6os6()6D@tqZylQ#P%oZakk
zHRzC!PsGaZ4}NJP&k}lO%rr^rm0u;}dfJqAa%7fK%E`qdS@uc=%Z&piO*SP?$f$EX
zG-tEVmcU*$9|NiW4ff4{vKSbbHK^(?%?xeUiPZ7Y(N$K-lyqB>s2lK~VREDTm;W3c
zNMO-q!wiw>HPe}e^^`%Irv(KCS&~4L+DZx?JuYA%C^&r|V#MtAI?#BS#L?*=8d)T!
zF9>C0V|1JTK$S%rF)}uNfgGzqeMr>BZ7UYs2;HzcG3?OV*4WkmB#x!|fBpNVB)$6Z
zYRlcbW^9qLR1f#wp~rIg`1ia^i(?m^>gd&6-JN$yiD3fg1%sop*S#(uJ+y%Bd%sN9
z>)3Gb2YeQNZ(lrGJgp+*>FT9fuP@%5v)jAx&5@g%cvxO1gVlJomoCt<Sn+E2s(P*+
zE4X&AdbNDk#Kpa(C$1=k#<Ck1=^R??bLW%3Qh#as_JZtnYu;Te&sr4vG^BdwIpc%s
z#--_On|BA99{Ld1#C@<r-;wp@t;g0elCi7$uFf;t#1?k-?(6KizOuoNvc9rl%G*8Y
z;#HGpe%fngz1>4D&$L))`C8_yWnc14&6j7sJgX|!kG*cb=-GqQYegMr8>F3K3s3ZT
z%f86gw>M|mv-iGd?=8Erd%DyuX1V$gAEXX?T{V^JO;~nonyJ*mO<TRLeqSB;+l0j|
zgCp9MMZl4Pp~+ze0|Nu=f=RvLZuhTu@2p=~_x=7p#nqqL)m8XX$4X{bSD}(s9D7#8
z@P-8X2AiBHknekEVe#NWbHlrbzEfI-w;J)RiAvb&+8B`G7V2>((nm|{!0vz}3H48k
zGS<q3YqPCYp3K&D>gaOj)@jDMlijwYJoW5gJ?PxhuH|Zxa$?7tM@f(7XofuWeBr~_
zJ;hB-r&)XAjdjbFbrx%H+3~VZyUnv;YcOaNVbbNsL#Jb9{M<ABmNKt&z0jV}o+VV8
zIO$cNx`jpRi6gtzmIv>NGPUxX>UhyV%fDXGAecGGy|vrr;xwJEjo}KP`t^i^s${~V
zCTm|>-DaA6T<hx8$JVNsmx~_Oh&8d<k`x)S<$*=ak`h&$RvVS7mHq;&zKHru=A_0c
zTO2(a$8oZ+%&>fOx3}TZl<-wLGSh3;>XjL7teU<e_`>=l-A{Q`YZe_<{OA^(>}47@
z<BD><OOeQ{@O@`pS6S@h34RiKG_@<WhHFQpu9R8H(;7ROnTa!FO};E{>pLzp)u!ap
zinj@Se7$cj4opqD>b}T7HS~q@O{XeN|Bw~7ocu4A9xRb#U-V6M%8#@dqo?OukG$5~
zbS+;{ZrUuVx!Tu`Pd&Y9b7V{&_oZN^YROf*-8b&-`B1-3Vb|(M{307QU(8rh6}3w1
zhnernO}S!cwRN|yG)a`?^)hwilJa<9xh%JJt6-Vi&Dpxsu3cT@St<Nr?Xs*}KSMWK
z%+p#Q(%+%ZJME0=#$Gk8D_M5SdBv7b{j@LK^V->V>4N@H=gVo*VUx9w+T`3>B5~6;
zoN3w;3$J;B+LxBt)r)Ap^lE+>%D+{~rG9OYirY#dWkwG}6^#R)23kCfVG3e_o|76E
zi8cj`>Zn}k<v7$PV&FQdJ5V<yl5uHhm(+wKZ7K%NEJmtXlQs!9N-g#An#GZ!*rX$v
zv?@|m*HdCil4wMS!BT^zhCvc5d6qg(Sz+ijW1&ybf}>jeFSG>y*B7dLG`TxXQ))_;
z6qR&I6ba*I6=O_rHHh$<vC>3EB1}}9F;ZYdgsOpOrx-J5u#n%WiNZ@V16D5So77d*
zv~}I~-;S-bc(hF=lykRpP3dDT4N*O$)R)hwD=3kmx=5LuiN!Zi0#u|;aY2Ec4IYyk
z4OHquqCRJGZq9frvhvi@D+-pXN=2O~l=K)vOT1N;EF83111*BChA=lxWpmP~f2bJg
zv?}NatHM98ZQFcIxD2->Em&ljDaI;s%P=5d(^ajd8%{GbbDY*}oM?0^A;s5&$4m52
z%d=BlTs+evbCxdERXNQT6s&q!Y2&1b1KZ3*H`Z^Ox?+n^_^ZXclXKS`OYNEAcxk74
zk+H(fup?*Ku9&U5>2`9f8xNQDpVn>1ZbzJ)%FjJ7<3?_7N>WJ4a=-Zp)fHt#Y&rI>
z+9vIGX`9nW;TbpAD%Ep5Td_yQLg1s&o+;a;gZx!w&aRylp3u&uH$~mkch$mEAu=M%
zxh9+nkq8y}Rj*k)ampk&w;*qAMrU3pUbmG_r&eaEavWIt)&0_ZmtQNt_%Eu}pUgTj
z%4uf66(&<>QI4#sU)z+uv|oPtRcklj`NDz2YzhavSrd#V%~;wPrZZ(?Q&K>L=a-W`
zGkT_9R%yTd>Q`;N>r<_Ros&``9DBkTTUK4=X^~n{Ym{U+C-i&0TT*YA_sQDOZh^#v
zqz%cOlO&E#7HxA2GSo6s<Me6za&l5t^^IG{g#5dHt=gAps%F@e(4%s~V6xWwrW!k0
zC%F^tU2*IEPQNnJTED`}@yGoB^FOXS^Ls6<tr8U8zB$C;%PR4`935qQwz`^{2K%op
z-*z?C_q~(#nMpf7$ZBb6)oUp*uqZHcFqoa)ocZr0*O&e`D*q0uGgYc~nfXrLoN~l8
zNLTDg$l9Q8*G*wzD_s}e==Hj)aV1;ONrwH#-~0PNZ_3gB_C31l;>M|A(JTM$&|S4^
zmFC{wT_*CTPiNoz_FeAF<lM=L@zrbhX52WnTKCGI2isPy+PiUC*NY1^*Qe!I*WbQV
zefjdXL$_157_9nzH|>_}-mSN8T%0*IERid2*{t<*q_bA7F34TAYQ;`l_Oq2~-}mm>
zTpiu}`uI*;_Wo)UyRwWd{_G!jkM(6d$g*5K%R;Iz<JqK_Ag1@y70-}G``8xGvRvG_
z;+bV1+qXN<Ec=q~Ts*5<f9XoG%*m4NeaSQRrXlHF-QIlc*u8C5$;+5me*^bBH=891
zWU;$0+|B^&b|!$joqqm%TRT4odaRnFbUU{}!{s&u%Sx+T#t|J;844~iFs@_pYj;2K
zoRup;Nc+fzP*DeQu0+>uvjP|bm~+4HtNBtN!`{9?<)W&ViOE-9hOGJXR;@6(xNxz6
zsqL#!g%k!x^;JR36fX2iE|@jNY069!DI=yy9kZ6YT`@9}Pm)hmR%ZCcf35C%^z7e%
z6E4R`&pMIj#<=a;Gqx04(`(PZZ<)_#D0<`XiMk7aSCl)?)O%&N-sUy~;{pcI!l2O5
z&;>E8>c8n*i?1yH`13$qXtns`jaAcwoW81T4TXZ|JNCSZTf%*1!hX@XqtBDR>ec*7
zKmPcA>+_^fw-pWsG;R>P)f=^BTXWQ{W0w<F=IAaBjG1v`q27iS`(JbEZw<2LUD-Q3
zH|W;%TWS{>ZcV(KyY1S7EumZ2L`SW@pb^#7(6p-lK-BehQkNNdH*EVe`I4pJT8-*+
zE^;4FsfMpBeJ=WxyCca$QqTTIQRtZ<W0!iPPTS)-UC$QgI(a_}y|-n@q}RDxX|BiL
z{NpoAfB39*OX|mYufo{ZJT1PbYPqoLxa6}vsdwdiR(y9=eq)*SJx70|_>7fXMZzC@
z?S1XtB)jcMWM{pf%{l#Lb;t5$jjb<TEjBCf^FMu-JLB|Y|Ba!oTO;>vJ$W|N{EqJY
zB)yFJS!wg4;+{{Nyt6tYc4NHOmGB#jQ@rX7{oEFx-DH~;pX$G<`|CE<G{^YLS*OqM
z`&O3m>bCak{J7}gdwz01Ulz@X@wqd1Yfjwn%d4|Kebx1ju(-0Vy8it>^LCw@`CGk>
zZZ7@s^PtqS!;xR-%(<}U*OO;+jzoSvdDe3I*{$5u@{enV^}dtZu<zRGrw#9N<}C{?
z_g!*xYy8xSWtWX|wSKfMtW7(y=1A!JHEXt5tY4L7*QWj?;fL|3y}c>>W5QGZtXvuI
zwduFBXnJT(RN7>d@N+enK6$?qYp#D4x_V;x(bk#TM)H=Qy>H*`j8t6g7`H5E)itGS
z{(05aCu_caRdvYN>M|>(Y3qKk`F?H*Yo=|D+Vacfac_?3^iOjvuIt=dn)=n!;&@8b
zwdh;dvzL~+?MrJpyRj&3`-=|s2REZ7qBCyfMlHMO)Kl{@M(2_7r$jlfReKC4v-gW$
zt+(=eyyD1Q&nrrXJu`#XPrZ6|#?h8_Rz04V<_5a<q#Tvy(^D4H^5ZNFZglNQIjOTu
zOh;(b#1^BJkc~QBS(6@0O({5e$YM^21c>C=IJu=TMpb56+SQF|xzQ7ss;xR0*{scU
zhG&gf!ln%p7VB1B36G754V^Hzw6HWx)#}yD`qJ6n#%ZG0!@^lp6C)$l!W$n+N%6?`
z1uhO;Jbg<>b)n_r+@epGQue}UW}iOsOZ{>{)|&2*M+>=670HCm-6<1VvO}iPy2vv0
z(t`re)Z2lVUM;x1Tk6A{uek?q-;gejJDYoCS?;zYpR>bqx7|CxWa0CDcWR!@V>tKo
z$de)q<=dz0b503;elN2>#=SxE%14XNw~ubl42r9MJY7$DfzGQ^i_WJ{vR&CC;)>UK
zPkPjS;-SQbt*wj2HcITVkT}>A@nx4zM8vLwWS%;`X?k-EKNfsg9(6V}GhyqL+T*Y1
z7M(P*)?<zoyk}kcTvyFK^}sdF$mjVcbNNM<3!jNgj7d(kO|DO0AE+*|bbnTL#?ys1
zpHoGTb;ZT_AJeM%=xOokWKYPaipbPWr;qa-tJ;-$d)mG^JF`=+<hJ#;$@y>j>{-lu
zru?Y;+*@;2S)R)AJSBQub%uE2Yi%~SPd81&m7C9Qns(K<&(-3|W>4FSgpaPD;zN_9
zrawy7xqfu&*CW~75mCRN)lXLs`1A3|lU<K<v-GY__U`k!oaUqbbfuq<uhpAP$BY9d
zm;3b`HTkl4`QeM4hgEj0pX|4%^46a8p14=9*9GrgKg*_4@6{d~zl!sI%ek&iEdIVv
zvi#6Z^N0!wCdbEpJ?0uNUT=cC?-uU4+~#gE=j$G;$J(bB&pj@=<r=T_u@}3$>Z>38
zF$`Nc>8kKmpVV1zw$wZ|4z~Td^yHP@ktRDH8)vI2zPi%qGp+Pm+1u-rzVSOcbNKK~
z5^+>tD7oD4bev6Lb!o5O^{GX10h=AZ@4j7}@>txbExdBBMVZ_rYio6$8COg;AG;f}
zyQ`Y@$~D&sheOs(n_x55G;__jjISr>9kZNVuNdCV6*Hssy7lq4OSjfVhEG;34y%}3
z@$s6jzEICq<-SeZmYzB#8F~7k@}VV<baZBD^Gr(Fs9LIYEONchdc`9lWf{$rwfjPE
zXD1e2*}7n^pOr>TmX4-O)QL?imo9aaSa34cD<(E~)1xDkn_M1U@Qf5&7R5MOX_`c+
zn77D3&(Qimj!#Xl@T|EUwPmC556_O{dODgXQ>41C3&$+|<MC=u*`w=Hk3EVamYEm^
z%SaxqX8;RH9_x4-sg~Kx6LPsZM*IWc)V@1Wk1bAEhB+H&u8|V<<1JeLY3h}Yx4UD~
zC5u-6;ccEh=jqy}$($z|lo&WbJA)e<7#KPj)~?r5&)c?d`<_XjDwC!xJLMZ3a#jD<
zbj@W=SHzkwY{*(0T77HP^{mzLf4@)vc#c_Yy1`^d6Aq!j$r8sj?v_r^cV+QolDsti
zzzt@xdb0z!7H)O!vkbVkaI3@ZkWlafk?BWNG#9P>sWRoiM4j$bldGGaP3W<gJ#)!V
zV@*$|lx8;5sYBPqxK6N_O}i0&Y{Ioub9n+c9SsxuY^?2TowIP&CE*iHhXlAh&)DXy
z3|(ov*<|7bS1}!t*^#-eJ1$Ax4C>fWtgY>v8OmU`ss1+8EwS4<*<rrLCKClEloi*N
zT(^>XmdTqs?Sj;EA!SjC4MEv+q@FvTD`}psyF%&EowI8;-FdNUN%5R#r;8V<B%N8a
z>C9$roi2|hOICU;>GJZLvRUWU$z_?dW+g{l>y5Z(y3luW%C^W&IkQz4^#rD@G<4J0
z6f$G6NTim>B8??0>kVB3J%d~YT~&R$JZAPBmgD$;Giq_ht=TzVSL?L1>u<3sNwF!3
zHFh)$3TA_bqMIBhsCM078}f7Vq}t-;>Rt>gLLW~oU~<%XRHVT$(Lu11X*~lYOQQkk
z1P9Q(pu+^vocZ+6(a~X7n>sX48m-oKx)3#KqbaB6Ds5KJ`dQPGQZ{)>oyyi+vus1Q
z)~Qp11`99g^cbuydUEK>LtUdt&1HS2n+=yn6ndWE(G>`82|Td4Val`FQZg%#9v7Wj
zu(?l6Y>^+gQ+Ml;)TH*UYDOt@CKh=n9ag#4^z>rNqo~U&StTnjt2Sj$m%6>@amS81
zvKnuixdXJfxL)A9>RMJG5T5n&w8grZV>z;`wpeU>V|vrX+PCOo)+~j$2J5aZ^zjq<
z=5=sSc;@1ug4Wf+0gqx<dg~ZQ9pnqL5uY=4kx^;jS`)YBt(wccL#49Y_P8E-@X|eK
zZ7^e;(>x`8RhJK3Hll$~D=klMyVI|6dEL3|={#lcw#2a{#kz-2cx5H^sXmy!^SRz#
zpJgh$eS=S3nX#kNq@FP%PwQ38k~P!5m1Uef5^}Qe6l-d>(&9<l3vIt^PO`k=>p1zS
z=2}y><x5$YdAnr3S-$zmhsuCY%C1Xnn)W(;>5N;Xd_kmYN&C-LfA5{W`|Q2+x5w;r
zUKvR;HdyVv+Bm`XHM?D@d|}m|mx^i&r@w#AELop<dFqX7S1IPs*p-jI79KhI$Y1!%
za$)tARWtT(`nt4W*W2VLt6Q(1I`u+(;-v=@f62xO2~W9cCbcZ5OI>u!*{wNCWEbZg
z3h#(Jx%F4HJ9n$0zsT}d+khC&AB*%vj@qhLYpoCTz9H~!q4U*H*BXU7k1owWN*dE#
zU3!87eL_79>xF`q0#1dBX{mN~UFd9B!#Zh=#-Sb+Ly=6aERl<1ttOsR-Ihjq9dy%J
z6Jo#?=&R}DH7hitacO9y8>^J6POA=QL}!#!X2=GS1dWRvms&D8G6W829MHJRCAH9*
zA+SN?zp04E|3|_LG==|uS=Bx%G(&4@iiFZumkk|ZiVf33>w{T5I})ax5)KJ9<WcqM
zG!>cA7O2)LHEBj$h}uLskqP=-GZ{jsiU%$AQ)oO}1IrQ}9UTn}jtV}YY=M;2S-qxf
ztvjOfKww>XM3-S(j;q9>Q%3?jx(r=%!`^0HTYGEuAxD|6rFw#g7J7Gth9_K@P(LR`
z$tY0skkOKk2TVOJA@yfMrmgVO_$ex6ck5<P*v$=^8v_%9lQu;}Y>F_Nu`$BXFg3zx
z8Lz5h)1n!M>|ct#vwTjR={a#KI(mERw3*YQ(jvF`c$uy?Ha0d6h+64dWEm5(f8~{l
zm!?;5Hn_R%%wYppiH5LcS990v?pd#Iu>Ms&ziN1^P4HHYSG!8DihrqCeduH9v#{e`
zA3k2uW7-)M`qFnY$Sl#R>??}ZR?oS)Iqi0u)*jD0vvw7!{#Cpy^?L3hE0J9xHY>LI
zoH=vWP_$C<%&eVfx8<Dmv~hXoTlPe_Vey2{8;diuqpn?<^j7PcZ=TuNMeYoXCvrU1
z$XPpcN_}fX;3`q?SK3d5Jp_^>xmG0dObQD%G+8XPAyQD)$ZP$C8t+H*MSiLustJE^
zYOCfnXEE1BizN+GJ0pX&wmPgjaB3ruXkgZ=8XvDyv!=+iAN)`w&wgre8;`T8Z>Hpg
zOA;$ig>0Iktus|KDRV`pmY8R4)3)gckBh`8PuJO$%@tmM_~C~iH6Pk8MXplwl-TGk
ztT0XN#D<2e{I@1<s##}OD!gh}?7Q2>yc5Nz))<FIhivv;oV3-5ZED0upG`ANy^P$v
z+B811+_Vjs+tqnBR&U*u>F4M7dGV|k)7f<5RFZ_&5!*v%{ihy(USt*Sy?XswhyBvg
zas95v7xR)Mj$M45wXQxd>sh(F;YKqvv2%~+OrG-U>+2hxzqBUwzpL;4`+wu@+#T;W
zeQ4OSDSMK|w!31d4>4V8jGh{v8oPDd?nLp_YqydX=eFI7?YO|ez|_d?;B?c0fgw6~
z0S5yEsOX)b!dYHkULJe=*xIdYKi&S5ack}Di1uGh^(#F$s#fmLbz5|-ereW>D_J^O
zVJkPTxRSIqYgVt@qGMqzvP=cHWv7`+wOu-5c5zG2tu@XX_FMn@@BFLv*IVmK?mxwC
z*PeafBgfa{=e)<adS`a^_R=YvcRb!TtK??*(y3Wyzoc{X@~aO%cyZ*3^^xnlr)}R|
z9_ek}XT7rX$j!ixFPql7tcuKy+J0eseRgs6J$`mKb;WyXd+%)BdwbV;=k>|!7QdS#
zD=O2zS1h~ob;jqdnrV;oxFYXZ7gXmOP1b~=s3oU-vl>@RZ8TlQ$l)Z=q6j7gIXYaN
zlmrDjT3nPAqONC0z0HnY>ntU4;aFSB4YPyWZZkwr*{+#)TSGeGHrws`97dzbnx?DR
zZkQ%VNAN~m?afUvO%5~N+VJ1dF;Xo!^86u_qm0$Ew;LD)MC$4#8W;r_7`PHtCBJ-|
z!2FOg=L7@uf)`Kk?qttlX?1nbZggN^&SR)qpwD?PWT~QubGb~Ar=!E_jGiqFY*QFY
zkA0DQ_G|BEhOGIUf)-9-V4L}>eq{jLES?#jQ>IK|765hKvnH6xO<=jQP-6uHgQm)&
ztf|HURn7kU_^&bqupW!;zg_n|-2C?YgNM%@KXO0Cc5l_r`HCr@JddA|E0OKtf9t)W
zzMTDgY4p2Cw@r2b9$3M!;@FBC`=-XP)3-hPV&|{AJ*-c=FK(=LT*&xo^*fMQ{jOah
z4_>{W8~Z#w`vL>|@!V~4(!b~a-M{^=#wxRJw`*IXZmrrW#+10t>~`pSW@FyK+^yBE
z8CSR8Ix*u$ePhbh+BJv0wElHv%}QDIJb0z!>2<3F|9pHq`P2$uohdt(F7df^<%joD
z<<}+`)E9GUew}!5sp{Ejfi5poMboc|KP)vituJ1B<^SoY%hpOot=yQa+ih~iePzGz
zhVF~=60?%_>L`DdTH=2#EsZsPMo+ys^Shg=+YFbqT19nDb6fl&qx9Fh)!N#7xA^p#
zW-cu&jPZVbvgyXQWv4c*e3~ei`gYrCvlHRVI#+f+%~*Zvs{7JZ(O=4{j=#=sHd}Mn
zWX1eTSJkg>t4|a8E!EMlf7<IwovzkzwdS{Ws~=0mhdZzQ(7))!?`@n*O6KYKB%8#?
z)K<KmtQIvtYyHBE1Et0(Gfr(5e*OCW*=#%6Su<vA_5W1wovS&^Sj;!d>DNr9U#mT8
zB5PIJTF!=D-*vh=?bfkNXD0mSnY3@=LiI~gtCs)p_G132EBq^pYvo^^u0Ou6KjyET
z-u#(4qJHwhhbJG-m(+eJc#Ltfki@CgY65YIr#TBd4^C9AN%gmx-1xB7(#B|Y*Tf%3
zR;ww=C7iQpJtnN@rxN^F)aH|)=EJ5r^CUx$dKR|!gcv2QnHlJB<lL1MW6<1`p!H1D
z(8rsHD`Cc>o}N=@mZe5cP4)3I7CC9qY_QC;!&o3?hGu<N(Ha+tj^>OGv($?Vj#wNr
z5H}LDR2M83H9ToC@wm!!$>0+^PV5X8EIc(|__*b{+ZCtg1wEc>@hc_XrA8u5BA7?(
zFxSTV-2U4c&z>!waY08qZ_0rUpSEthK7IS?@UD54j~6eVv`1rJZKa&3&F6D{eOe!;
zeE#{QV#4S1R#q0P57m30Kd&CV@??1OR4G%pUe(3!D=x0MxcJ4z#gmp_xl*gY>WN%U
z(LQ;0)|#3cJO0LqegXHsKfBVx;@b>AeBSx+`DCdnIX|Y{70p+bw(-iFueJF3J+9a5
zSD#Yfw?FyB`eL>4)Tu8s<yhl>8(-cU`}J)s%ge&pY2iy(RE5lYy5-8n$@T7&MJxRe
zw(;0)JUp3a&W~Tu?agP-o;i0<cxG<kt!VF8&Zjs1nDfc`c;KuhuM{sHxwzs}D*vW_
zJN@XHrIU3&8PAo{ILOkR@5B+JFzd#tv`g38E^gU6Z>4U*rid-`e4J0#iG|oIf9ZAn
zs(<OP@XwVir`8+Inm=c&$<m&br_V2aN~xc(Ii26&w0xcQ<i*oBnofJ}dGg}v=N3gJ
zB@4gZepa^Y$Lf<y7wfKd>viwg@!9d>bRD@pb8Rw9(&9F+T=GJH_1bN>lOCpR%uG4;
zB=lEkosN#K)Y3T7D}UspX3almYUnxLPV}(XhO1RGi;X3Ithc;WQuKMwj=8cT`*JH*
zPgY%V;#B?4fS+$?&epP&a$o1?J!k2K>8tb?oYrYwEY%~mVd*#ar60epTs3jtqOFF(
zJ{FO>38x+jJ@A?4EP6@nt<YY!m5~|RZmz2~ZR`~9jGKN$aP`cknpa*5WvW^&);KMg
zx?q~YG1E!C5n;R<>*h_>2@H7{xk+=G#+F0QVak$fTSTrdRpt%jiZTfQ!CBumUn@*x
z`lD~mMwzTtovYSFY>wEnDN+AH$k||1Y3Zz6Tf$4O*Eh|**>I83w=?$k29X())q*Do
zFfe3wa4;}1b#y5)bTBb7Fx*pO&OI@|YJaW+gUJQ9&5>)aWo2b$MNL~OB^4DF72(aY
zVfvp-Ti0#Pj=%eT`o=(J)9J}Kn57wCPZtPd6Pv#82DA8dc|S(3>3m^qY^+Jg%wx-@
zH-2Rm0ZrWUO;2!R<*k?20?phenYG*q-LUK`?<zU@FNVE3|Lgz0_>#WsxP(xpvEz+1
zdu|19h!Ad<zj}MA+jdvb?CsU=-6iV`-dk_5c#yd9-O~qKy;kJj`}kNkDsD@~!5+7}
zuankJE6e6OyHrN-*}0Srldct>+o0yYGG^C1i{oL_*K+ojZVWpb9l}~49lA9-L^Siv
zYL88!&1+M#1hv+txSp7L?y+p~j^j~Rvz~AFPDneknQN<YN@$Um@p+j>e;d75ySKic
zdRA@Hv%V=8FHW;EI_?$@fxcT~m9us^uUgltQ&OJ1;~n$V9YO5oK~}R|Q$2Hod?O}@
zsa)+eP4YeD&dIe>YnAt*dI-ZSW6~^@)K1B?T}OI0D(iTh7V=)Ba+*^yCo;>eYvQ6M
zy;-M|yf#eMQEA<nx>7pylG*Adz1z;}&hpwYIjr3ychTvfu!~F1$}-*!`J}@icp=u^
zp*+;)`04mp7c(xxnk6eYW^Ch{x+-wRZMIX}eyxq~HWAqDSkHBqaf5Jfd}wriXmp)<
z%b}mVqFJo&S`HV(7Hh04S{I^Y8n!}hrP?v(zqfO8xAZObQu)&B*s`H()rr+yT_+bc
ztF7QV7@idt*cHVq)7-7SBEn;NfS-m1%T801qpgKTMSf}%=IE@Ndg;;P7t59u>Tz7s
zS!-JI<YH9G+$h(c$zAm(rS9S3d=f9FtrWbf^|PzLp?^a2qb18HJ~d1ZZl1Mf<BEzf
zzh!<WuUzSRm1VVT!dgAeZwnXg^FC-3l;!T-DAhT2fhn))q1CI5-Wc`l_B<>VYj_Ye
zH@vBD#i>g7@Nn*4S*1%M6`eOdzGzi+tv=;xn{-WAz0Ex`TW|7{WjZ<ag^4|L^mt<R
z^lt5l?y_-ht+bkHF>mt8Ra2jQEL!Gg7jp35RbO`R)2G_F-|X?{^3`nU3%Ho;({(hf
zagoV&k$GM}MNjPrn=fLp)=tD~X2fN;zB#Lptqz-d*lNkco{}e1js@&Wj9YQ>tNWfk
zyUKPQ=V#3fESegAs_Uy`e9)p_N~`LBvg&_t&|~zS!oP0A=jRK5rKlXAV7c6;@{-BN
zqt)BHtDk+V+8V7>6LmQ&q2BA#>)=S4_Cq?+uH92#WtEsDX2&ht@$KZ~t2WJVSy%e4
z+BMH-j^FahCtt1CR?|Nb=HIo`V^fmWPm@Kxy@89fF7>o&nYu+TWSeC2YGJicQ0=d&
zTk98P%<bAOd{KL%9n;3%Sw5jFuB7`e4nBTt-C{T8s882^v?Qih`2?iatmBF^tm(;F
zzr`rcYv)VRuS`D_FM6$CrLu3TX!s+=_yrE`zgJBSGFsGdz^P}6%ZUZ1L87ZPX0$}C
zlA6@(=^Z5La;a^KNyimo5nY$4l~GeRI13o4c^Nv^cky&2xM{5Ej0%+!N#Yg_cH-qQ
zXr0O(vf_y7A|8Pwp%GoH9hNEj3h}5&da(sHwyGSOl%gTY#r|JZqxoM~T*xZH2i{y=
zJu4?FD@iSwbiz<EW6C9=8E&B=SC(8^A)yw;6Drj*%j=?6#-bzIqDCHDU2TMvDz!yL
zBGf|^3%r8rpYDIlqI1D%vqKK+Z3TDMN>9~`u6%p9-O5ttVarnH6=>tRrDUdL0O}Gj
zFqm%e6k^HUmhQ#$V7&<AsfpfAy8<*XY4Nir1j>YHW-6+)CTPhlbq!sq6#93<iUST)
ze>XCPztLE={^i!3GsZlJ4NkfmYJ}<PX4k%MJGgDqq$Nx0R~n^Bdc-(A3Y1xS>ZSI~
zh$V&Utp6r0`lPRY_#*$8eHpjr9o>4&=P=hk(WkZ{(<fHO$#Hx<C;qEC+U?ra9-WmR
z<JpfN)xOle#QlPCu(nfw*S3}CN{U{*4E(To>(*%Jb0x)nOYB2(^{(1H50wchQv47)
zYi5S<!>}VcbDq0fJPoP;8DbqRxOJ<|bFR4@7EWJOXU$yY`fBM+;gshV9j^i`S*@1(
z9Q2&BAZ4ZJPx+Qjt~@<l)51grP95o56Xqb+wbs>br3q8l0q;-CAH`3s6a6XvB!2R*
zrHMw(T3Wr1Eumq8zqytCZ~W~Cqs6b1dA4etoOEczVlB?39+hCP_4Ut|rY(Qi*;Q1k
zwf^v@I{C>*J%6gYtw?f73BT+A+-h;woagS3)r?Z+`P-}tKUCN4?do&lbZD|_YsV~2
zNnsW3p#JQvn&Ks9AaB<iC96dk`K!-s=|6w)Pq@l5ZH*MoRpFbT`L8RIyYx2rTuHs8
z;bfIhl}|<MHKZ#~C0{$erGBTg`_kFZ&;9u0RF}MUQ|^u5Z+7)vs5xRCb~)w&LvaIR
zZ*O$_F>`Y}+x+Nj>++*^Zd@xpYj4E^#_i_E*5=l(x*8pwzjpun>mRQ2sO-Iadi~+2
z?s?x$ojEn4Z=Zg;E%MI2=xvv?Yi>T^U8nNps&Cbl_aP^3XI~8sS+zFQRcqC%tM#TP
zt5#e!4GuL8x(b>C3=VbHx$3HmAf0utI_v-K-5_1VBmc0O`=6-lDc28cM7M0~o$Z=6
zB}=y_3p`1DY-!e%C=h4$kNxG>KR<8Y5&rhU?!BeE`$EMcmcMU$x2l1O)!gK|=cd<Q
zxpS|iE!w6Nevf<i_4?=?PeLM-=FiZ3wQ7MvaItU6Y`rbZZr*iY8=AUkTiSH*{CS>}
z&g3m`o7k7J?RK`wi4}pNy5VO;uZD(1-xrSx&Ux*XJBMY?D^~{wCfVZ2xlXaYE4-&N
z`A%DLRcdj#=9E*ZMl%DAZu2Y)@!575!u44e3>o-|Vc;yN7vy#TBPXyjuFh#UTR5Vk
zug&yXkof^J4ZNf*D2d}u7h)RN05lD(Q~UjZ0|SFeS_1>y!LJ7xPHhias>%?M=+MBR
zKkttF`H<xe5?ysCRxMz@!fVL()ioqhLT!dp-4)Pu?=oeE$yZgqsv0h&)TaoCXsqP9
z&~}B<)1}v|{Z)gBz530M`=$5J{_*FxXr0cC)M-9Or`06RY^~Y%qTD$nmv`Z{tqZ`b
zjioqeGPRj4Z~XjvpWN5`vgPyjr=I}(44JsVklXCQxQ&;A?FO?0<F=m#T=%tBZQUBr
zyX{uM&lN)T@nyGzCj8Ews&-YYc15zznq!fXJ)1W6Y}(lUN#)9~nM%3(TP}5OiNCWo
zXj|aRRJJQ|R~P1fxnS}6`Tg@X_iQSj&)ijVyma5UzQ=XJJ5p+oeiy&%KfhwWr;7KL
zueG)6odF+><n#p(OH3#=<XazjuxH6!pG7Y=CUaTLaOP$+6rEH*)2Pj7Wy&cxpCu^<
zlXY}@1gCK;bDZWlabUxa$=zC~RZgoMI%H(f)3bEq#4BlTJZ|pYJtqz}KW_Yf-`}hJ
zIo}MwKM!8E-ru7)Bli397|FKOnGa{2`Elmug=0KP$E*z73@=N3n)GSXm73}=-{otc
ztT}60{ycHF@1>t-=3V@j<sDityuEH;?UQLcA9tjSeD2X#{1|mvb)}Bh^7NXYPInD?
z%7Pc|2~(RH92B7v+xL^{xsIvhA@|IcYeScHCaN(6hie^Jax-;C=o-#tsv%L6PX5qZ
zf5c{G|4BbKdx0k#e}<k+{uItF-&$wgX4yM`ll`Kciy68C@aSRupU3ws&EXWA!w)a-
zRMpS5pQax?z^F4_Ae4<|`h6D`QLYYUK|ui*7Z<x7(+wqABtcD9Y0&fs_jI{DR-Wlc
zTv?>+3*NwX;u`jD+_rkhThLxv(5#4aR@+tH?yPprTKo0$f84!X?t9nYoYVa4z2xrg
z8;{<;@#yWF!m@4Kqodc(Uc36}wwr6y(h}DjuiJAs=)1^f1>5h3%YE;fm(85_9-Dfd
z&0^MOZ{E(mQ*XVadPnu)dvYJXx0kQm3^(|j#qQ|nwQH~4-d*Y`74!L4<@41xpRdlV
ze0ARD+vRi1t>(P8ymE!t^7+QVz`($ukg2Mkfq@aA(}tET>H>jDpd;5ojIOS(Ubn@8
zD@~<(-Bzqv6Brm6u^6Ou(V~s6uC7TkU0q#AMMXusYC^ZxzOG%JUAu*0(*bU?1~Cp^
zhUtMCEW-7#qxNlGeLsP}?;QxdW?Hp^LH0pxcxY%S1M@uv8S$N}p`lKoolqVOtPBi{
zTCZ2F+a-G4QNcrqW#89rTeGg*3~*dBBh2BH)<%y5t5dmdOb%Xjae>cliLK6=x+`va
zT=X{2Jt1?Xc<Lt^gNQksva+r?9eVU^UB@fGsi#)2^r(Ln+WY49rd7K&Z++SG?BE&h
zP)okcF`+A$rzo~QEDm=mS$(R~>%-(zQ~Fg_^On!t7nc%OIe%64ZSlQZ*tPT&FMXQh
zE*u+ha`lm>nfj^k`{Gn8gO7Y$zE%5D@U5lF7i{lFex8?}JKtYnXPbKC)7pKtcizvd
z{5Ibt-emciscx(Vlk2zG=+9iN9$2!cGg?2TX|~SvEnnufeiZ!Zu}`HlK2zV-qvOA;
zN5`p2t_hu5ry5hejyiU2m@GO~V#CHoVVzNGqLWS>><(SJv|B06WzEzDiH4FoI$=vY
zrglti*{V9ppr_mEkZPjPCfAi>fm@bNlu!!em^!6fDOhDn&!ix`q)8K<{<rw8=+b(z
zYD3qWw$R96t<FiOmN^Tp@d@lY$>S5)b;!u5&D-VRgp6HY3uL*jaz+Hb2r62sz4iw*
z9u;8mxNWWTgk7HQjKO<v=WaVY+sKT8qocP$h(SrojK?M7h>MGhAe$1Gl9CdS3j{a{
zBq<zm>}VEbQ{r(E56#Ycb@kPRKF^RC<td$fK>;Pb9PC^QMyr@x61`SERPnmxAb-mv
zOhqf`*Q8Zbe|aUQHciw15-xb0Ph>~@qDL0u4-d_;cW3UCahG4#8Lw1x*!elHzs1pC
z)330xDAs%J4T@W}X4QgeL6Kg~8mCrH4GWqS+O+B`zw0Yo_l2+a`foLu=@#mhW$3u7
zs%^s8*Vos_t?xK-G-+yTl5hCkz2cnJ$_ILVyv1i%^aYi^jhu31tC7T>+eeBfuMapg
zBWhmmqjjs}=dCTDb7W2N3?8X%ckkZ48yb7}cWm|Z?K2ouCe?eY%$#a0TG_y$G6~ES
zFP*`=?RIVhYtc3a*3i6lvDI4`7x*@4XMbFqv0nMllbdF}Gul6N+Bf+&xx0T{oN;r*
z5rbQ1y|a0o-A-=G%`xOz1n#>{$ubFv3R~&6IO!;;iZ{~%aTYChUA9!JYsu#&@2$!!
z?_S=$=Ux5R-+!F1FWj&tM^~EL?Z8)7HtDbjiCgo))ZMiYcn+}Y?_N85a+$f>n>?}J
z*2Rev9ow$%kjRa0Y`eNwS-os~gE521zIS_$J@vhL?PF%u$JE|A0SOnO1|C*w=3QN2
zaBDj=h=Q57e#x^k)%22kuY{M?A3f&0?C9N=m$S20trU#2+4VECQANO$MaYq5f}@JC
zX3sL?R>LXB3YOhY2D8m>=Wd*GELhSf)o{wOV2PY_5C)Vl>60<zqT!-smt&p1!cuA`
zFP0h2I45#D2c#He1hb@1I#=#CqZy}?ErP)Y)k_|lo!f(?tk77&o+lv8bILW>D2a;=
z-OI%uFtD)7-#@0n;KabdG=q8iJw`hN1_sFwQa`lT728-j?V51(f!IEV-v_#u|2wg2
z!HKg92idoVtjJ)T?2z);YuO6628P=qOC6-x9E5{bRn1$z)ZnXt39G88FT;f|m+DP^
zud1Dyb>?)Kvf*lD-H5ZAKi5Pj-7fQNTrxwtJUZ!ik<XGDQl5?5muHtZz-u4|h7AlM
zVhmhx5go>W2nH=~23Cg%-A7xav%`*t#H<203nF@wy$z>@CF`tBHhdYd)5}pNMAF%#
z#;9$P-kF7~COOsgEL^2!*Q}A~DaW{Bg<HUjfFHS^ZeI@Fx9ez5wkX&FW{ADapRcZZ
zyEf?7df%|EyVhpceLo65TB3JyVzrnso3g|)15kw~VJLCTuvy}mVaMdc7*PX*B*Pxi
zQ5bGKZiYPx#|(RtKqAR(hCRu`RiLczl6QBP5){0>y=b~&H>*rNiV##1Oqsa2-YJ0;
z5(t*-)~&~7LO{z3KsDzoX@%T?TMKW*+5Xd>^R&3rb<ssTyEW6UZvOiE+^(Cm*KJGn
z2x)u0cIK|vX(3upYxGyAOh0+;WbWt6j4e^RVx9WE*Q4u=ORt?-$u;3_>1OlToKvkH
zp{+hvan?)4Iu$@_x?LBYp1p2c+UvD5gG3c~y-v&9b#p4$gw<S=K0ZEu?Do#bCzki!
zJhyqCP4DL8z13^qo;>Gy&hwgk-mYh_*X8YcymjTRD{r&PwpvGrtt}4Qxi#zF+v2dD
zt7C3$%`f|I9W{5YU;VY^*}-6CX~lESJ$aj^o^5Cy*?H@X-?gN&&B9w}%w2N?YywE}
zwdJwJrPs}4S!R}J8oj&XIVId!Z0C%vXIC5MMm<|wY?wX8b4u(jpWRz#mS?G)(tE3P
z-B@hr)->JKF=wKlC0#dLY1F;jb9&j%h($houV0<~`<may`fY~=E^f({He2KDyEt=8
zjv=pE@3g~--MMeKZNGOwVHzXLHAc1rj#Y2BR$a|LpTJ*U&gjryUS3`Rp+M7LAa)<)
z#e<hSem6{5uM(hmsO^+g<5J#W3zcY%tRwA;o}1cMbMm>Yxal04FyU{P$4%$ZsFu)o
zqFb_7htz9@F^hW1IxO(p#NqnOVZs_$mLv`35UEvbx;AMYGZanII?SWAMrn<Nfop`)
z8Xg{w)l6Ck5)1^xn6y4V6yL)t_-{#(N03aH)Y8yZ4^*bcE=mban5!8sxb60~|BNgf
zIMg<9ZZo@`ox6@RTq9OwbyMi`2A*VTi5m>Z3^#T#9AK+A?Cr_Poh@x<A+(OQL^GUe
zsb$CxuFwNsyF?qN7I1|&Of6cOAheF5YXfKar!H;RfRGBMChJMESK3QG%0m_Jf{;f^
zz$<4ikDiXLTpSk`uG=&<>(FX871p@$ZQuTs?|q-Of@#&NuY1mxH-rYThK4?UmbUwV
z7D()q&FXda@80c^lf8TGS@8h|1_lQSErx_u3=9l18jy_0z`@Mwz$40F5W;XU0Ll!v
z(^#}ud6!ww#g0mmc`2fY_}_({x}CLAhwHP}rP*qSvu+yln)y!7Uh?VP+<UQiAOHN-
z-p`zv@g)#cP*2)^15%)a%Jr$Cj`iRYK2k6ALE?rRQD)#`KWFL=iIfb3U7(V@Xw?cx
zk*<1bZ^iar?}{zkyPfVuc~>qtxHvHbqGJ=H8rhl`8VasYwx;Y1UsR;-+r43~nckt2
zvs=TxGr+9Vny+)0uLt{%Yt^b%^{ZB`Sr76oh_h<d6vki%R-YBDJ`AD;3?T<VJpZ4N
z>)KM-Wh5B3<y~Q5XjuIF#}Nh&hG2#{3!Wc-*fY^3fPuB(ckLT11G{)L1_p~jUWNd^
zbGJ(#e16-^Y2xYC=F`4{$vM<>*({SI38wa0Qz5%bCtua{s?Y3kb7aa2G7Y&b*ud!N
zYHI5x#UR`KspPI%-s_ue){oO(E8NtXBJn(RO<Rhs)$8KwYwx3H{i};$H&EEb7{Pj_
zrD*lWnm2Jv&(EL3`ZRoFowfMNQWgCm@6gb&#>&t)ab@~JuRP+GwEkH2TYPT!m7SkI
zo_q8MBpCVeO|<u%`UZz-_uW?MZo3`*Cqb8S1=H=Q)dv=C=3+6D4y)OAa_!bx{VUUN
zoD84lS};rH<7U-E2WI#LKg-=3cu>;wWWe-Y+Ap;ButspL(PDlfDAyXkYOnfAyHiVV
zyjfH~!Su#k^^jPnbxXXLzNvQk>RHhht~^CuN&AXt#5%VrelFVHUc&D6zqM}t3jZAz
zx;cNvg$$h;x{Lv$j4OGhOfoKRJ22(It!0u8K8<V6Cc8ylOH1c+znPS<ah0?8w9J*e
zcifsidvcR(#ALOLNymCu>8eU+X|r}`O}Z6yNmfhzMwns5(X4lCS7+U7JGy1r)!dLY
zZ-aua@Ef5$p}j6)vJs_s!()!Tb*pF4S{$)$ks0fZH3u)ctan;1vFezrkJbjK@Ef5K
zhM~!#VWu1l&oD-pW|w_=o7J72&h+Zr*GZ~IYAildQIR4SSeDF8bID4&$iQrN!$e9V
zBI&SUQr5|(ODAsiTAbSfUE9W?#L&KW?Y6VI+x}H6DGLfD@kn$)X&rD~W8mWAlBA^M
zq+}?_rf{$cB&N&)s(aj&6plz3f_I~_r2d+|UzJ6P6;u^!PiI$SQLEn#s_&8|Zikqy
z$l-?6NTK=m4_I1eHUv$ok6s)#;n%uN%UaT}7aJ7q%}NwxWK?$5^@t2iU85t)A-!eW
zp?iir+fL2pROwWlv1i+<!`sp(wz!IEZ1mhZ?M8Huv+lm=d-vY)Hpt1{d42bN_PX6!
zCsh)SJd=gOKJTfFD{l)EUF%^TTXH)%Y~$I4XGfa1TNXXH;M(W3f0F*Qv}<R#oZZOn
zlPoC60Nt&{z`!B|-mS&bsNZ$_^V)s2l5vxF@7}#@&S?|It+VcJJL{0Tf%!Va^g<yP
z;ree|!?vAN^(>M!+B9Wb8ke);62Zu@l~?BYtmB$8N4RN6Xpkk#qqfCI^wh#V9bR^Y
ziCPISjCBp=^J*9Ab?=xiti5WL*Nealehr_LCVUGt?LHE;r(;d{tw2j%xdUG7qa3ri
zesI|_+A+p+c!{4*_-pgZUh3d;tDZIok7vBaD^Ap>@K+r?KiB>2bE}?ruUB(2z2RHp
zeZ({Fi1wzIw+a(Jur~xB(D=aefwj`psrw?!>K_VIvnF|mxEKWWu!e~UwmKxZB)BB-
zFitp;XfPw>&@!eCq74ZWVWLe5Gc*pmG0osgSR>kKpvEd8k`Tt4pvIJ-aUif^4Qqlh
z!wl90(ch}|p?_UH<3D=*aGCI<)j(j47}sPb9}krS8#;ZwCNl&xCWshl7<dIXL<p@o
z$YsDN!E`{tfHh1>#DM9Dt8<oMXqEtbs!({!CLtZAmn=Ivlqdhq6}V)`?GuPKKJ?bE
z4$WJ;XVoehl@QBv)12Jg`n9vR@o02~87?w(4DFZ%f=65?stUrO#Ldly2VLf9FIZU+
z%C%FwA!G-G^3nt+KZZ7zpqQy0O@0hvOBMzFeK9Gi!}WuZ=l`6WIk&b7T=fip@N8Sy
zwUb>_r!>?t3jSdD(eCos)vqyr1z*<-f2O`hKh^@_2O0;~)U&)0Nzi7{&#aORQeAL$
zp<75tlE@c*rz++P{0?#ra+6;gdTnf)nj&%_H08_5#DvMhBB3v;_#M8mF9<)Rz37T^
zSSz#8fm5v}98$}dId<*U3u!#?@L)(>^95VR7wnFLUqruzUyN0mdg0~erJ8apUv2V`
z3hRn;<y@s?65bfz8don`wkpI*)~dw8zkN+;WN3&4Ge6VnL#q$1Uc?&9H`huuH10&h
z1inhHPhLkSL`~Y5BCf)E=2^J$nK{P}-2@ZQw5K{eWj@6|F^GA~*4))K@24MMx93Rd
zBhQ`pvd_3n3JQfi&z<TL>T<Jmt&er?p3kS}Jb$xf`jom1$v?-g=GJdpnl<Cb3RCTn
z8#fl6RqVQ$c6Gy9A7|;XoWRtqi5r7*wL`WYJL;IZcG=p!d;iwi+{?GUzEE~|Ven_w
zTdh5Q&Uc{8c4lw8?0fQ*?zGUAFZHhIBo)a$%D#I#`tI&E$EEeu)Sf(9>*|=J6Pdat
zYTl%`%O|{h#oCjw;wLM=Y&~>o4s&_AZhqOj&DX8wmIrUW>l3{0Rq0*7>!pT{*GsM5
zEqGhbc=wL=?iE7oZo0S%3bF_U3c9#Bv$1u$b-FBQ1yj4D%_emPuJj2O3F->;GG%Ex
zo0gXC6P5HuLWq-f)|oTcW^6h7!azlc+jQp4B|_XL%d{L7Hhb5HMAyz(ux7I6nrX-W
zaWtEL&UIkm;IiM}<G|3sYQPyk=NrS%Ev=>v3~awEBACqQxr#6_Jd$K!Wz$P9uT<h<
zFqFz%?6|CIWe5`+i^Nw?PiM6TM)g&JUKvNEgMC@9Oj%@N!oW1CW7$+`Wewx6^2dBv
z-J0M1`P}EZcmC~<?JxRQU-(+?=Cfj(YPsz8toe~Lm#WW&?zy9PD_ixxP=x9h@8oB<
z^Vjv~z4&BZo4?*$`K79_%6&6Wd9$0!CuOE*KVV>d-55Tt?r!<vYik>F)=Ed31$58K
z&RM%^L2d4~&0MzIF5D8oa<;eq#tf~hh^B`Uv1zjutFri}u9DqsY${UVGiiFSIE!HY
z0=}lzi$Y5Tb}{T>pJXHcYSmY{RnBikb=IeRX<t<B@l|WydeNt@5B#o#%W@tGU&wX3
zXHg;7X$_xhq3MTy9CkWoyVN+h=YZLoWlLwLyt+0&_3)%KYwoc23SAG|z4l_+$xyZ3
zOU<JLa?%(>y~2u)u<rJJnjN-hhJ0#hPuQpEb(ZzVrH#$fiq2-6g>G2eYOL}iWc`+9
z#kmg~FD*FcRl3mY(T4+XS3KE1Ct2pX#Bt4ruwysPHfA;5TCydXpJhRf)<y}@h(nr*
z&Z46Fo0js1ORbJxA+?2X%R-Y(FNY_~=cX&<`fdx^@@zWy+5CO?vl<w^m`<HGYS^^t
zh?nog4Gg@q88TTzZs)9;c5|t(=CmM>tFyK^I503~bTBD!zulU<J?eJ;`MaRH5nN#!
zxVR*Mc5@#Di3oOd7_#xWxCnN1bSNn)L26Jz&`7BpsB%?O;^=5UhuF#e&U*R<RTjDF
z+(|4vj2owaWMYx7PtFb8x;Qs*+v*J6)@ZIh_Q%rZ&woGlv1#fA*IjES8hgyKw%%Ua
zSyg9Td8j<!>OD*Ap7-W+w#5eR>YNaIJ2z$Tdw*|>b>T~=-I`WD&9Tr>VQp5m-p)lw
zPOqDkZE`zX_VUs>;o6?blQ=adc;qw%Dr9zD`yP6kb2;y|IdA$(cFNYzRLHe_D8A%c
z>GiTxuSF~GDwn;TdUnYnhe^Df944qV=S=2g@@QQtF+rts+L9d;R63$2sBkKY?POP&
z({<b0@r1h4wsXfyjf(Yly<R;t=G3#0w+oM`E9tIFE!HX$y78=CU{1%jom0=OJmH-@
zOU9{4=@wXMnq?p7iO!ezSKqDA_ssXcykxetRIh2~;^Yj?sHM68!tR?a5LqB<#?bsR
zYWt&A_sthn&%ItAdxJf_L}0V8$!*^)-W$>q6jR&(GYZ}k;$Cpsvq|EL&*rQp61)N2
zJnI=xyK4pZXf3_6YtpMAb>^;3U#D6op9*UCiCLpr;O_Dw+(}DjNzugR8})o+>shp3
z__e$U4_d|fXo*SYL(zw#(_gwg?f3K)e3+`G!&1TdK)qqT$fU0Svu3j$zV|8by?Mp`
zh|2cDyXNI)w(Fk0k9%Jve8lA?>qD+DigBxiuLNq@GR8IRWvXKN!u2gQl<Nnh;BQ93
zDGsNW=xDmJh6yd^WMkE4TG^n@pu@&2EL_iV$Uv~6hiL=Xkr|UYTMiodFdfhlZQ9@?
z%#`3G+O$E9<$w>%fi+wpGK^{eDy{u*wA{aWKI!5<<#Lo`O=zcTmzYLqf{#|S$f^U2
z64aQK8QQpl3|JdOmT^r=5Lm-#z^cp;a8gB>L0id7S!ELMEf?pd2_YNSaZM~(65Rex
zEqB|kDNM@_2$bfo-CCM;FLZ0xt7})YULUy8;c%lP$iu8jsUvsYis|pAS>)=y76t7O
zP&uIK{itiz_gmXC+E%phEnCyr(YERPZrxc<yZF3Xuby-M@NQf0+SQ_ALMtE034c;v
z;QoZQWb&d~mKWTOF`N(7xDL!^N(f`vr~SZa(ll+w)D&H{DM?dTwM2T%=i0|o!&1XC
zpTYeA$B+5Jnqi4vTeuFay8PH%>y(%_W4%1{13ShK><9Qe-=umS3s~(PaAHN)5-B@L
zpP(Nxt-%cs4~o<>Uyx^5@nzLs?Z%)T?tCnPU*Z;PEsI!nW`dzXXhdtsA=ZVDeia3G
zg;a%JjqPH2DQlsq`Gsk(_M?rV$($jlriLW2PJKBgX^E}Y4%L7H84K4Cn-xv-Uk51J
zTsv7mFZJx=jHkt7{mU;O-E(W_+Q5x#+1D{h+_>%bY+X*a+t=5}8F+Vk-Hr}@o4f7X
z?d&5VdjvV`SRL~3{QWP#_MlPPZTHVFW}W+<Fw;19@x9KabG{wqF)-Y7yxOG1dPl{#
zHIi)!42&}v(ikM$y#8jbj{327zuAVXn$OIp-S+j`DiK+~aZ{Q^+qP)8)Q)=l_jUVa
z-@Q-!Q)Rv9neWZ{TX*kZl6*J!`o8MDdAsj@zGPdlWZ#$Ln`5<J?~}c9J9pdc*e8}B
zK3{vi_r0xBRqKv)qx{M_cg}sD^KNFvWs?&%+shfReJ|h?`c<><`$qHaWojm~vrErc
zzAn9&(jU74)Q#=vV5slt0I_nn-G-n9mIEvYIvSJ|I69b=7&>OKono;6EFwB7)pXvj
zBQF-1Gu7{4|NsC0|Ks2PcQ6QPi5^+T^4|Kje|X}zoYc1s44ka)EJ71JJhb*52AxgH
zz4=AS5fz3K3BE@SObwbL6PTvxnT0yKIBw2eoueV@%CxQibcl)4Dh7tNrW|ZJ3;~I}
z3~VeC4jPOO3``9SObrbT8jB_{h-fe{Fl|X;oH=!e+Ha%0DYqFI*j6q|IdR$9*W^&<
z!i5b!oXZ+6oKQ6YA7KSL-GOtNzvHs6URqgfoC|n_85tN(q@0}0X&V%xxs-u{mw|zS
zmzRO%$|||Q`c<nkKmovzxqyLHRY=%t$;AZ_0p_po?7!b*{Hpi(_4|#-9@UrM-|@IK
z$=5o;ug7!wkA3erFLs(dw(h;!Y4UDPp;bxozUtWBi|2m5_4BOct?idXUx%C6zSLb&
z9Pq4tFMpKWyq(dj*1vnVZTEp+U+?o*z3<z7e);vQt7q32>`|E%#jAE);?d~<Sx?o3
zOF6~sKEJEZG6M~&uq{7eXIpr;eAjzBxm&$kezBilx+Kf&b5)Gb#A2g3-EAK?W=i$$
z_s^=3`+B_e-s?TT=Uw^5o^VKa>&A;mT3_7Q((87w`_i7j_uig4X)fS>mc=e{tIB?p
zMV70MZOLWKUG@9g#`-7&(bf5_xngIuOxJH_T+6s(LBNWuTfet*2XisDGOqppaIL|G
z+3}&9Gqj$u?Cg}eoug;A_4JpAJrao#2b<XpeI!=48TyDx9LX%YFfliKb*k5`>`g+Z
zk+(D3Z|$A8>bU>%U4LptUS3}AC;Q{tt!o#u!=l#7^~qQi=*jCxCDa(#M{K!oW@xLj
z)Sfda`SRt<w^s%2N$;1lsrdN#I2Zqs?sa=bgD+L-PqOpgpn6hV^<<gs^wgfDDeVR2
zGJzsXHNAp*k~Pl@ANgqG$I{;K5Z?OG<-2z~|I`}0*e$Cb9^PwJT9EYe#mmF(+y4li
z`1!@4KyKC6nEr?Em;OwDwSM`BbN=<WzF#TX<9#=r|MKLs)vv7LRNt*`e|hrR-mkLy
zLf=CVe|hpb?pNRR&gxYUe-%}(uXXo6viEAiUrU?o`xY;K6!&UJ-JE&ZD_&Mi&%(*t
zeDZh9^_!ikUsj9Nx=#ARFPivOPW;Nw(92(*{9aeTc<E2Qs|BBmDnZWJ8qa@u^0~!J
zAH}ZvQ8#B^sjR-x+i;K@z&7lYU#>2A=+AVmJ@$Tn%B?^3LM!U#%yH-b6tn8XUrUQV
z@h3Y&AO0$;nXkUKJf_#{^r0}FKdqB~haUc9FWy<Z>gCCkM+)|<o?3r=@*_L(C;LJx
z>gEg9f7rM5)9S;wY^Mi(lb?DscKJ#xdF@TR{ewy@wWoaY)ehd288yHA(X(<pWo7*(
zVfridL+!2>yw(2l=5yTF8%A~)Y<1am#k2N>Lc-+07YR^c9{%#v=K7vK@y?3rr`E|Y
zSD*EL;-!}e_8*bJ>__V#Tw5!1IXN@sQtM3lNy0ybQ;vSP^d)?CREld)OzQk3?FaM1
zg}WA=u~*Xmp;Q@p<j}(v;u3X7!aoRo+A+r^vi((SoqVvec5rsh^z5xiF6@rYYfW<U
zZFbypz-(Ehuix4`knteyRa>UtS7H&Z*Ew@Nenrv7BUb~{WSRB^ecCZ+h0ftGTz}c8
z9(l52GyetcFVm+UdD3*o-fQWv$)_F_t%z)Y6|!HxxHhu8C1shPQJS9Ms(oALPA$89
zd2#0DWe*tNzPfYL<=mRp69c!h21i;<N)|~yvn|?pRkX>JPr;>IyAGzDVY-^KZOWEA
z8yWLf*4ybH+q$&xy6_a&har2|QY&Np0>u}ttZO#fvrb*3`^&2M1!vZ4cb-!Et2O<F
zG54uQMT&Jxy&tV_S$<jTp~Pf0&*|HyZsncaur2r6*?H4*UOF(|7IHZsnz@c~>&CSi
zTeEyKf5mOuCT*s1Imo?ow%P4M_x|;M7Ga?+`f1uNNx`!9sYjOSm(6)vVD+54uTaLa
z_ug^C9E-4+%v{&4>$cs_nwwMOJy(OlVv<_bYTp>9wY{4{H)h;UkeqOAxqM{T#z>cl
z9<P~3A*Z#r=CoZ+S|hBqB+IMT+t4K@@Jw{essf|OLd%7<);!v=YR9F1;g!2%yVhn!
zXT9k-6tyKfS4_!Qs(wz_wA#>PF=6Eq>9fpZv)7(onJH|zaqEhf8{9^AtLB(!)w9n(
z96ZZgFX!cpV6R=%V%ti$Zrr<j`_9At>Tz`(Nqv5K-VSpF1O%8EW*SX2R_Qqw9CS0t
zsL>~6TS!aJwvb*gGX@5p>mR<o_U-YUmg2TdSAao4YU-4=UMD4zPMp@&Iq91dp)qOG
zmNm1YB2^}aPP?%Rv>ceDL5ZQEfq|h(frJ0X=j_~&Z)-#CuTPg&WvOI)EOE?mcOPiz
zOqucObi*VTmFWhqERxgrG_vqaKYfFl2h{2}tj}G$N;<^i@l@W~A!aLbMRUN5e!<5z
zfwzqw{|~BQ&iqf;KYS;REq%`3JCgH?KIWWE$?~1caW?22?~YTejj~=BeBBoQ@W+q*
z+<2jaxko?VeQ4c%_nwg7qwi(A@7>##S@QOV)ZGvF@=9MXUAlCxcz%EN(dxcW*Yn)o
z)n{*E4&D3lV@=fe-Q{J^tzMPq6+OFsBz(=Sj-BqaulW_-c{=wRU$IPio@>qTvu`t}
z&z)}V-S=im=CfzdeN%HT>8_r3y6C2IS<cB_2iwlhG`lQzXQtX~g_8;=j2tJVaVkvW
zPB@*?;K6WUr}@47Y|rYQdhfh<@7^9&d_HQz_k!|*`tstrGgT5jnKRGpRhL)3+4H&j
z?(Xu+*DBKt)mA>Ax98@)>gqjTZ9ZSyd*^w=j@`v+zPWd<-94LocBYA8W17L49+im(
zGxJgsXG(Y~B^qo!6??mAdf9casdsyKdKSkl*|~bD*Sn*!O3&^pJq?eH>5ZLkS{AeF
zwf4mAO3&_ePmT4ef0BD?=XS5Bc}rt@cfGsyde`dJyN>p*+r4eqyIZf`-7e~$^;F!n
zWTkf7PQSN1{obyds`n=JOw4w};_RiK1=lt2Zr8lK_0rP2y*pjc7In|s6*Bd3(b2P~
z#Z5153g@1!dV03%*-JOQ9)8^RGq*SF<fOIE|E6T^P28|e`<mod*378&AL>`F{_~Yr
zutTb?;|O=a#RbO<5vNQck6V6RsWSh_OqKcP3R9=+?zC9a%)sQ`t+O-t1ej&0GtGP2
z$=sPD6T_9(XfTR7Fig7ObU|RNqacHeD~m3pR)D}37F|Z}Tn1GZ7e+w_7Y9KB78gc7
z%X9U`a~}8EznZcz)iuQ8;KYon*}1DVOwKl}{?V=c<e&0C)A&QvPj%Y)x1U<yS+GM%
zXPVyBN{f2Y@RN3utgAUTnwqQ^pZcI`@}&jq#2>AH>?gl!r-wz1){}>))(I_o8y@ts
zPU}<2TkkejQyD$cqJp>KUYg0Fg?i$T)~g?AKeA8!Q2qMJ?OL35s~*MZAC2=1EI1M@
zaW%%f_0T#$t%(JHLyzo;@7gn$YxVN1UDLgn#?JM0ee&{Yc+ks=ev{vxFOF)idU<Qz
z(n~MHZ+>yrlLHyt@ppMpyWiDPz3GB?t)_Ut`BZDO>eqDdj?ZtsUoKeYzx>wvm9_dS
zelNc@!EWJHh7DKi!(Tl}mEn}yBAWVXU;9a`824G7;ptEVG`ipXwW<t#_bNu;<L@i=
z#UU%(!BXOa_d`YX)n8sdwZ5}thy30n{lS};XYIW&^s>sm_M&H{z2CghTJM(y_O+|_
zNpU6L`E55pYoF?u9rAUjrtF#LzkJuarI#Mm{S>nGJ6AvN)voE@jrXUD#C)oocV27X
z(l0yYHSMIP%=l^<yRLnuZSd9b{UJiN@!b!8$p`(4;XCDSzVhZ9P|y}wYfXAS`OB}$
z(69PSkJMbh=|8ne$6}v8`+=Y8r>a){aP^+&AG~~OtT#wfRe4WL?E1ua{v}_v&wSzX
zKVI|;95VHn9@*8lUJeYFuk#On_-*y8c<+v%>o<l>cRn;{Rcp-TDF*vR4_u91$-LI+
zs9#vu@-=(nr+%?l`4i)Q)>HQK=9{44e`J@b6u&;IZm!L$SFw7^&sW6ty85hpdGiCv
zm4))QAtC$YwtOo2w7RooNB_L1%2)4N+sUqa1X8-Ie#P|H*XBXOt5DwV(2p#w<h$Sf
zH@Dwfr}||_|NO*|oxi>>pM3Mv>Xjus`imy6dwKIRC;=48+bK=@TXp&58;Hz=eNtUB
z?yY-y^UcrDE4yN}52$?pcxK<a>lePO@2Z;mR;BprYrpg9pj6cHHpKh+>s^($;5e!;
zl+Uu873#D1>zRFe*TEq-^<#j)-QLG{zEy%ua#vNJx9;V;YHJ85DBeC6Y$+(9ek+w+
z4ea~9@8!E{yQ{U{FAL?9R>gWg^uIFil9!)X(Ztpts~cDCa+&(=*IWLbckRBLSl+dJ
zn)TWF+{>q{pFiJX7kl|>{nldVxtE`w<tz7Jzj_N>_lsZU{!4RnKkN(pwY`68jQ7$*
zE5e1=FNqKMrosGaHCubC-=!Y?qv6b<6+){%ZB$EG7B$tI`H}k}??>W?yjImEzTPu?
z_t|^qdo*9IIy^O8>u9xOjbfyp!<R@IhXv2{L){n5TQYr0=c|yaAVK~1tbMBWANIHl
z)t<?WU9F@aS|tmLz{RVCYV5Aoct5P@6H?~`Wh%j=4tv}uFMqXe>7_R^XEMDq9-dmK
zdgzsvmitRhr+-yJt&@Ug2DC0x+RAis>0)okB^g&WwlsxJ%(!%M>B5DJz1@~90*Py@
zh54+R88Vrr&BLc@L()MpjVNK^`mnW88xDslwp?5tX1L9;S9Aqvg+))6goK1PYu45%
zla!RCqmxc%tqtwTTsA9rZSKU0-D2LVtG0$2E}NCPZR<8SH=W4LwOUhsXX|V_&B>c{
z>dKW%nFa}0SL<v#opW}}TJ7Lq&m{+&!)9eJo1GmEHEn5d+G(9lhn%BL>o;fms!e9&
zjoNftXWN+zCysWjPP!VkTH>;=(QRX|OIuA%X8A~%Ci|LP&dpX<7SoyL9jZ0kEHZVP
zP-N;fscAXhfmynWOALItd5nw<lTM~=4O?~0<g%~XwM{786G#S|+*VdrTQ=FVnQd)k
zYW=k6Ox!9_wBhF{L(H2NnK~^xZQGSulLeD>CQdR9<BfucflubLS<nCg2PY`#>UE~A
zx*Bl|CcZ{$Yi3l~GO+7rAS{HlAVB~pbxkh&Ze6=clE*X2TV<vSDBw<<fcSsgiAZjt
zX-hzX%Ohc$bz0ZtcGPXfNG@;ydo4RVEi$#GZCkcL+GSt0$>11Tv+1<%*0s~^^jRdG
zH*U<0wl66TYnyGkc*eFBYhteJpA4V(Zr<yxJ-4GKT~5qd+xMhc+ga_nk!82o#W3w@
zJL5v1zI#=@_G$6zO*3QGY5&NcK1-iPt^WT3{X<JUe|YIE4JegpHL`WS8Wc9wTbO&w
zQ_ieHJw>sOh;^Q;mS$S0GiiHyb8ClaD;-o_(k*)6YS4y4by2Ph>WeR|IKIl(RhVhk
z)Rm3eo*7dTCWl;Xbz5>_$x+P}Uk#M?Gz*!wEZNkWv{58e<$~%eDUE4b+Nz=M;yYsk
z`Sj|&Udf8|3Yxl2U-XqJ>8tP+jSa0`PiA^X`EfncisVcU+32GbDVVfF(lf%Mokd&A
zTUgC`YO8j*P@z)9!qkYQ-4nG7y<0UCyj8tbPN+8NgonAT*%90ovO#sS&Ww{mCyh80
zx>YorW{RnHb!}zY641A6@2OX+rB`ppDSh;s#<Hn?P0<{$Y0E_|nj#h^?NoDFt1ejR
zHH~GX;iRRliGeBHq6bb)ZSL5y)LT&BI@W8tWvud2p%dL&$F$FMMuUWzB4(TnI<#TM
zCf2T3C#Fv4+7aTbG|MR~Y|&(oU<Kh&g)2+=XGL2tH(j)B_3oHkroD^SWlujGbM3ux
zx%E`-zICVSKln3*g-qk*X-G;EQwz*m5ZW@am18THi6LueN2Cv%r)R`UZWq_EC7}jg
z>K_t4)t5~4=9o2g$&#a*T~oH0Y?-BE5ICV%b0z0g&tDviA51x>7V7mw*eK=4Os?J9
ztJiE>KSOUVh*r5Gb7^<%!3tNl&`0Z5eGJcHJ}h)HB`~o*(lFAf<9K^}yQbF1RY@CN
zHb(la*6cbuQPwBCo7HO9o~V#@TMQ#SHbxq)nXzW3R_wN|8+#YK_2fz!Zpk=yaj|Qt
z+p$~PqP>l|zP+tm&CJBE+?uU4y<g78!KUKl<Mo0{6*ILzu&Fwp3}5<k+Et6qn`VVx
zh>f{=mT8yAo7PN)H}zZ}n4he^vPMmC>XOvd2%}S{MUBn}Z73{o7hRH?aBJJT!sza<
z(?W$upR8NGZe7Q#Ej?>wuWl`0btfh)D%3w<YNA-ENTQg+YL2ZO60WPd)+k+MIHar9
zI7Mfb;}l;mUQq+aMax`0KFo8UdeCCW=_DWRZq9SzrlA+Zy<Wzwn(|7}KRGny3TLlV
z-&~7=NgEq<_-0J!n`6jzj3dH%-L9A1eHI@5p>@iRF1*f;F5CeZ7j<B1ev0L8OS_#`
z;J)f>-0JDv#w@z^BCDr{md$aSDV5<fS^3I3i_I;PtNS!|#H79omx-Agb9HOs#c=Kb
zxdoFoqCDChGlJGMT?mb2T^Y2d>7qh{&eG5XU6oY_qE>1hi0WE(AWBuevuVjk!-`px
zH?3Q@>DF@bjGdt+;^C&nT7}_Gb3>;GOH7UI>Xy=qOgfspoU`Q8gseiJEU(QWVg`#&
zlxA@jW^tCLPL>K;bK#hfPReODm)GldEqc9fm!{nMjLyJhktB(ZsbYq1iYZGv4o6(v
zka4WzNFa-+3mQyP@&L~@gXWt%rkUlODe@2M_r5$`!GuM!-obYI%E-*fRBt0&ugBe!
zc3c&^y5k74cdsyC^$J_H%t2~m!h|c`B5W&lrnIfp;V|_~RJf!q!ZzWgM<&lC-jGcT
z_1kwnnLhPqc(`P4@Rq31Q?fB7(^F$(ubv5REm${2cF~HLmzTtZYP{^5yMkLKaH@yZ
z>va~7>$k+NyPmzZ^m?p@)m)!*yG}MaZ@u-lM0Q=Kd$?rYse;L^r^HlF&5bQu-95`Q
zV$m+8-7M;h_+4LxMM`D(X2!U$zVf9%OytI$g3bCtJ03k*^=$3xP3yL*>U##9jMNG~
z@~UDkC*LWnU8l3&v`s1M3z`*p^?GVd%+))qyLPNz#O`fWzc6y8>SS4~l0^?%(?oSn
zwug&{dqo;+2A$!|TBsgddeu{V-L99aZ`js7+;-Ai>p<95-=~#JWnxlq6t~RSsg>l*
z@apx{7?pJnwyPH33DSBpUvQb*EN&y4smH}t3s>o`E<AK*&(!1MTB~Q}#(HTV@7f^x
zv}n(|tFd7J<#=}2ZwgbnGI{knuQ@SClXiuBOuZ_yImp{EO(%J|-zsrV)tMff)l!c8
z$y%-0=(1T<EalA1((AD+I9{*YwPe-24x{x3)6Uqe*IvAC*XxzBpy2CXy!F;w=eg@%
zx{FKgTJfCIu)t6)NIg7e>Zza|O1qSHty*BKTB)t8t+O)CebSCcPwLm1x^B(0h@1}M
zta=q{HTBA?ikPczZ_B+bcAQ>ldB}&mp*=iis*G~iuGLFjc58ZGUhW|-((>x`>Q&rA
zo!4VZ175G&<)tYbd-blyqsMb%j?B!vE;K`L-A?VUt|we?m~X83sr<;~#AT;!uOF-X
z^t>L2M29_Yomr{fr{^`-YgfH>?0R<V*h_tSre*62CW|u*C6tz)jB#!)S-12?sH|1V
zLsePB%ga0#uiNo@-LAJ@Anz3(mo2rLIk$AOh~D+=tyfFS!%G%-_iR%+JyY}Cm0dfY
zEa%j2(q5#!)wRO)$(k)|HZ7eg2T$4$)8atv<xXXD{g$_Kudd&<d#OxJarcbLy0;z$
zvtGTfS{N=`8t(FDmAc<ti%IHXv9U3Jnw-~VO0UP3Y6h=fvu)jjU0c?z+jL`cK(W``
z@*wt9(G#LKL?7@iO`WQ9bY@vtRJerLsXGOm^-ewRo)YWzwrqEt_G+*#sT<W|PWqKC
zy?R`=V4ditUEv{|m+P1N2?bu3wMq@@+x2+euGbq}{?$0@a!m^V_)xGo?b_Ms?6hlv
zo?V^|aq~|V9y)*J@sFn0>N53Qg{P&Xb(d}2y6IM;YEq!Fwy3dTdgt+_u~mLM&U+r0
z*qB!3XYtYE@sa1PTQ}w=v3apsJ=po`)~#DdbQVQUom-{vptrH~o$%Z0`t^_GkH)Rq
z8+y3?-CR4Bhkf$=?F$OD@5Vj;WECIuY4yt|PyXT<+`S)o>7#yWjJ=<~>3h&H>@LWF
zCTO@8W7K$8-}KHh@c1zrs~#-4+h+bIzgo?&TAx-{%euE-0T0*KUJtzVXL{C-N=qBi
z@bj(p?JrM054`kI?`n;`pT8B@M9|nX$U^Y=aL2<s@2PQk$AazrCtusW(!%wTd)7Yr
zz%P5e>$k>Qf<}lzRzCUB-}+M@WWtde{gpMVK78v>y|N2+@YkZ>^`lNt+@%vof7Q<0
z`d;zNq+gTDRzExy4jLMNqBjZT&8Ltt^Aq9The~YLAAR(D?xnrKZ|0|bunm8B^4Z=e
zCA;EOKY{(d_ep)d6#tSer!coorYc)Q7YD955}L81+r{<U^jGT-?OpXF{MGuUb*uhr
ze+YeID(8I4rhQ5!zs4uIz;7$|v`?vm@t%fX+B-!)w8p_sRP@7&=|}cy{Rn?y@65$>
z*~Dd2(xl9g8T(ngCI?Mz6%+mSr$9e*#mW~Se!W>0<A0_8Q_HSt3u0}GRxQ^E{SdV$
z%cxf+*6{J;Nt3?C>ISTLE!puXtLaP0$Cpo>o^tK&4&UbQ8>8*rn{tKw=HdQaPu+m^
zTvr1tDk|Ox{nfwpE52`8$fc!;5_N_(iHG)1*XaK6;ZMb<mHLPN=mxBBt%wuP;(qwy
z$CpnF_9=!x+U6VIGq3*Ej<CAw+iia84Ds!YKfZjR`fFi4*SEruxN~>+9`wJUdTQOV
zsTomPN24Z29N+xqM~&V5<u8BL1uTBqzx?t`@Y%rrE&JyC$@@dNwi9dZ1ojEUbBG^)
z_~9@23)4{D>`0HStxD4Zq^3W*5+<@nb<tywzeW=ae*JniWlwPZQG4&Ml_hIZ4Y-#t
zU+xg=6}~a+%ax>EsTPh^RRw|7q27n~$}E>w3k_bre0h+#(9}0kdyT5H9>$&16!-ad
zYSPJH^X?qY4B51%TKncpE5&MyM+>X{ul)7X)cz2)U((LBVEy4ob?RNKsw`fwa{Vz?
zKegJ%uOse!-Y&&Dkdl4%M%7sl<N4ILoLW^;Q+mPstL-wcY1%ihe5+8bt}bx;F=6@9
z58w9tcR&2K-~Z~b8uqIxK0&|SS!9A96e;c4QCMrYe)-iezxK`7Q2knKv2T7j_#9;a
zlzr>F^jq}1xF3G3u?y6y2?~F)r8d+5a=Y-Y)KL5Qbxd)SFV*;|dM{0`UoPAvzI-{0
zzR1)MQF~1#*3Ge);q>Lp1J$=yGqvJGUwn-5Teb4><*rqQo^eN4A78F`XzyIBnFidq
znIg5~L?1r9;`&%f|H@zgl}A<UxWgYmp71cf-M{le>yO6`(;wAod-!juUBC5aSxm#e
zd+!7IyS)C0tv`NT@z8$0xf*}wYj4|Dzj`9$iH5D;cD>FH`|CCR&^~#-Mf&-9O8Oqt
z7x{bIJGBSxlJ#5V^sD_qrgQF;HAVp@Axjq?RXl6C=$3wzepJoncUtjAH7B;YzE=7=
z`I-N$P<=<mdGqGoyLUf+{q@(_zy-Vh<05k$<30VBS_LhxU$jfs?_}t;m8x}&KUUP)
z%lBXSBBi+P(8fvKs#90F@^r?__g}xh{QC9l*B^hy0$v!MG!)r4Y5A3vKURIvbnn>1
zFMPb!Q~!Xx=*J^X{FnCC>AgK}e*3uf+i%~`somF(c)-|uc+St{;^L>D?kgPpw7P!%
z?A5Wk(ZP2W_MXslc*3X388dn6siz;VW&1{lscP&I*sJ>DOI5`p{noD%Q;mA0R;&rw
zyIgeMoWMhS=f>`jS-Ixg)vYN(6)j~woYl7T?%lh5Md-&OrFxlqxxf6U_TIgF*UI(Y
z_dV6?4CU^5_)Ls8;S4&RTwZq9b!X1@;+##lb?Q%wZhIlH_U<mGX}5K@MQeN9$a``3
zcFv}Ew=-6o>%Dt-JMY~=69xt@&<JZPhzPr_v+cG7Xk$G1b}8ArcT2B7x|+Lneb;{1
zZ6asG6#t4e{$(-Ct#=HZAZ6XC7gJzh-SGbNuYdb@{{3M)pS}ITJbv+0%qQKGu1Ke5
z&8qKCj^bUKHSOreRc5oUYKtA+xZ<|J>C{}ej3kMiwG%gPOp?l3J8@QzGw<5o6-QIE
zrs?*s(3-j`Vw>55RbeZWbHW-PI3B2SUpDEh{o|J2ov$?|W~>b|JmQ_YZS8@htL<h=
z@5(JaZ>(-p#JJ7w#?nU{i=TvuuGI3iPQ12dR@v!zr}`yJ3MOvXn%LQORawTxW82jo
z5?j-a%u8-Po|ooV@q|G>C+K6u&QDrgSEj1X-S9ff*E)6ma#1~(P9qi(&m~KPj65y3
z&6zLH_dV|W-q@#4&pGYh#i#MYExJeO>YNjIFK72v&a`|yfyHV!*JH80*RI{p-FA59
zmAk5(Dy-+Hb1H^#*0W0Nx;0zWJv218Yo)|(&*eH+*CzYj%zj(CbIZKjIk)_Cw{E+0
z%O_WT+ikPSw{vHEzTLL%_H57IC2zNCPnqp8^^{MNfY-JUOLE_;=6jk=+P-AQ5rwI_
z4?S+rj&3u~&67C0b=&O%gT!sydD3p(F`S*9yX`^3VX*j)WV36xbL$TrYy(Ra9Lrt1
z?RH}`?^aZc)y!vi-c3Dw<lClakE$b!3vFAT!YopBGZttun~2LDL`m0A+P-AAXY?hX
zB!R_}9Zu4o(U*LetbM6w$Pw6cM3Mi?QPz~1zG-5cRZJNFTIVq^I0XLu|A>L*0Rw|(
zBk%9~4h&ih3``9QpnF{z7#KJG^7QIzU|^78VAfz~U|?WicL0%K%;&(IaDa&cyd?@O
zz`(#D`KEs12U`YdAzSI(9aRim8jXy+q4u{!{)RgL_3{yHG+6mtWYr3j3m3l3WSCU9
zDpcVJV+W)9s*tP+3?@}sOhQ2_&I*#eOp}&*N`(q%nV3zSZ|eT3-X?7O<<|!vKhusr
zZz1qY;Izo*)TonbCv|SB&Q{s9+34!bX=~1G%~-xm+Uu_I^m&dfsuFTlJKpWS9{cj~
z`O@-+&sUF^-rM!wU(U8+`oS0$h3N{KjGXmIJIYNMq!W<1FwaO;Sb%Q2$~oz@<XP|3
zkaFHttNIxmwr#umOd~sLQ`oJ0F5q3}8>ShZI+Hqe#%XQvzB0(x^DRB8Q)ku*L?j$s
zYG9-2XyF;Fv{&$>bJOCMaF#;n6@1H;!(;1rF<<#w-@Z=4V!pV%j6<PqO#Ra%?7~-%
z|C<Bm?4JJ0iA6?geSn;L_t#%P8h*?dUk_5;-G5v_#y?!XZ~6x(7P0B?omhnG6^v@*
z*Iz%ve&laF$S8Yp`52HHbvqg!Rqgm&$av&y;a9NP*Fjq46m0y~G@Lv-LDEjaPW|ZX
z>r40+Sj`uYtu1A|@?*!ZN6eicYrvdWVCvtbrfP<7j6WGb@Lxl{gZ%>e3;d6k|H>48
z)qUo6+SzUOTiG@RGhIuNYzSMEaXRX>r0<`GkBomB{yEeu*iVo@!T*H)6Z22TAKbsq
zf(<uG=lX72nasA;A0&DNEQ6%9WB!@mNjYm*My|NE{1fw6&12J!=7t@W?A+>qqxl=-
zZ-&1ObqDMZssC0xxhZG1+R07bt_u{VPn2d9)3rN4KYGI%lMB3?BNz-EE-@<@^vp;(
zvFWtRlu0*pHwv&eDR7y;&t08ec5B=A+tZz0SWfaO)Xz8uTVg3`IQ^q4i_$b^7Q5+v
zf-Jn#7r3&hOz-~6$^|)SX?G)wBxtX??Q|VA775Y2M{lfMCCW6FX)1HpsYb6xug0vl
ztJCe>SVZf&LU>nev1+k0p3?mI@$dint;Y^0Zn%+SCe7O#UtV4sYHS_tefM0S0K??>
z&nKTMd->Gb!mJ?oGMH8JY3{Dtt<QH?XP+<oc73K>;FMHJx4<dY+qdoco*(vE_rqqr
zv{e(zC!cU$6C<WGuRPpx)rz=xrIm9l7R~$nROGf&$GrNzzhXd^wSjC6EiccV%fIjC
zQ|ppXbLU7~m_b;(D*f)-EYF)4yxm{(=D}?!wm9EBZ0K3?MDd!E-mQhVt==0i@7peW
zO_ZzEX<@*M5Ho3Bu)#TIq6x42UL@`YJNDeX;LXkHY+y6%L5AL5`*ywU?b~r6ho3U)
zS*&rxtRUyX?d4P6UOw=xz--s^1!lXRO?%C{X4<Z24ZB{?VtT!f4TgeVv#t@_5Opw{
zb&c4jsMn3VUN=ruQp#G@DfD`sX5Qv(>(cXiJLm1H@H<ylyglaI>)Gq(xm~^n#_rqw
zmFqJ!U;8U(Lh<e86Ss(5i``X`zGipHhx3tTr?-}Tc=ND*&9*lm&PV3nd^m5@+v!;^
zAKpC7x2saZJlCd2dfPmZF=}0}{gtgCn7i~kGarc0_ICNi=CaEtzP)^saxpgZNy6PN
zpA7PDRm$D9>6xWn_VP)tZDu`)cv4;R$*ieq-j)yBknrx*?dfe*r}NJ9e4U=NJKUe|
zoJ7^>?fyJpr{~R+e64r0Y~4KBIR;;+-JK`-T6edN@wM1ZZ)0t&EfQbr-39T$zDT{b
ztD>yn@U`f&igbuCQ2kVo>?wYT7jJJqY@2#p@9O2lo7?0?Y!8?)hj25oEcE>ECFQG;
zu{hk+LIrwRxx)lCM(7S01@EmzYeJ<K&$_(>c6D&0f)5i+;q<KMX4fr4Pc3>9b@z}1
z_@HGFkubfdoQ1P~pVqZ~+RO~Bj*Jje>%alV0LO-g6%0HH3<4g)3}Da%)u;M(b=0q`
zYpZ@RFz?=7`eBCz1H%fAcLCPBp<ufo8w2CrtKgGF!^_K=SQz*~ry#t0cRjeVfq|=G
zj;sZP!rQqFFApAO0G+|vP~TFn;bc7vbRwta1?aJy98OGvcNTKI3joVaQItI;(D#(X
zy=edK(5>6n-p<Wh5#x~2{4ZF+{`8;y4~rTKkBbLy)igT!ih2E~rwWgl`>b|rO<wt{
z;q~LK%qy?3$CfQsUmw2mPs7(Y%&S*kVUOFp(sSn3EB_pd8Xi5WFJ!!)wB*ODSG5jh
z4X;7cSwW>AuU`4p@Qv~H_0?CtGQRcl+h?_Fet_Ho+p4cs^A^~y^t^sNJopv!4fgeM
z>w~YbZ`HH{>#u6~`uggts)nzk;aAv}il+Q(_{8|}*N=Vb9(=oAy((E1F5jo8{)kz@
z>h<c*D{Nkq`{VS~AJsD-VUMlYHP@kHs=C}RkTnaS)_6@`^XO5nLm}g}(o(C2havNJ
z?3f=Qt5ACN$}8rTL8Y%(ul&mRiuwBb@RhHaudGCKf)>=x2*cL*ty_MDeFcBq-niu}
z_(NT5{a5g7gjUq=@n6B`BHzFM=#RM|m#w_CGNx|Fj`=Hi8eXqkryd}w<!4*5WBv+$
z0ol?=uSyvoh0LjX^{Q@xtwYt<S6^)%s-~((9zF7_;SuwiSFcJL53RH<EVNr-<p2)K
zpe3)bgF@;GG^AESgZ3*lXkUfQt*<F9wL>;7UN+W$1%H6t-m1O+0dh+{zt;M%;0p=*
zSTSFbfzLJMXZ6YOqZ@1fe4eykxBJATolAOmJzl-?6625k!XFt=aqW+Z@xQ{JCA@Ck
z@&MUM;&Hon&0oQv05$B&lGl$xq4owEYPY7$t+51K-vIGUb<pHj%-0`ZeO1lydfmF^
zEBLd5>J^r{{uc;ZbVWp1g=NNq4J!_53q~k&9OYR!{i6@dlIb6OSc2;rCrBElPIE|M
z^O>1CL6UK@8iYA><^)Mb5T2|SnU<E8!sd{2a$4lfnGofXP!X_X3Y$Zn`=19l%yd_$
zEn1_w#cb6rX=l*!JDYeHZVEeaLz+7^Crj&?&mm3Wzh3-bgXCW=u~{OcP{??M{jWoP
z|Dn)8|C5fUUfhqE9gLWd#A$kmig!L?R`1voG;Ni>_ynFku8*c{4a{J3ow9UQ_wfll
zAH}<ZuDU)x!B)|IR5NSQ1)gqA?@+OZlt{0r6<e5<P6b_coggVDsv~r0F~`ZEjHwGf
zzA{dbWPHTW>dja&Pr<07`C!n2IDG+05TpJ;B;$m{paXF>4(S~>qB^XPkFbHnp~4VJ
zWHO@bXvAtZC#k?pt*V9-JPjY*o0d*m-uZ}Gy~##YXR1w{f)Q9~nM0yP$fl5wkC<%)
zAFNDS2{KptV9?261%n=~NUan$!B%fopN9HF1}jrmPLOaD)mf0rb!lbG>d(#@xw@;<
zJflt=FlBtu&+4t}qpX>faOAYeYL6(_h-qp(KAUDv(e_%_Vdxe#ZPF~pE~6=1rd;3&
zoU(MuvWBFdrMjy2LQMW0{9VqECj3}p;djL~QarF!Jg|uIN~Efh!@&zLN^BfT#Wa1I
zc5Ms~>t4ND!J=DanP_+i&)Th94Ho;PW;HN0FdRE}%Oq5^;Xv-%_2s+Qtt`DBTX<>J
zAJvE{af{^UDHtifn((CY5%WZL0a;Fa0l6t{8n&7|vYI^WvmCpe1w*D!4PcS4_gIxQ
z;Uv>b$E%806(5GP6p9O0G8KA7m`u5-+3d28o%z5=#%7Uaj7OV~9(|C)#uGGyVNT(3
zhQi}A4D%-b2{jE32@w#EkYLc_;LHY<@@yPT3m6O=pa+sOF(@fRDv@U6+|4$uAa|*`
z*xERxI8S01kW;W^sQ==5X~K_&FG~y^UwWj*b@2pAcrDZ9Q4JPp6I$8j%o%c2v1L`#
zghQc*9*J5rmKaR+fhbrt@rv{E4xWxuk3#PwF<OswVuGecd8N#-kYi`|=x6oTS!(2`
ztFb34urTQa&ql9QJ&VWPeR1o<ZomA(z+lv|NJ+_5u%m~8p&rKWP+;L;V8~3;=;-Km
zaS0Uc=ygfr=oN8sad8w#Qdp#<q;LeZ%hkmNbSw*xi$sT^K$60?oZIP3+Sje|sQPHA
zI6-ECMFS|f7x_(T_i}#3d}+c-<%^CuJs~9FwM?lVL`Zlo6Or@`59FJt=3-URaH3sg
zNB5DKpr=}W?97dimdZpH7OgN^DycQ6@OZzRg~p=^k0yL9^hj!+z^7o*@Wk=O<fV$2
zCcN~h3X<#MaY%G{sd&9xNVa0egcE#1kMxutt?mjst7??+puj?()!S&w$)k@RJ=(A`
zEofGV#pC)u6+Mf`ogX|qWrHL^Y2cCK33dS)ha$$8AR|kbSg2SjuX0}HeDtbf7oQT`
zID>-+9u$I&JKTNr=z&8^XL_YP?z8l;c-*HD*J-uHrqm-nq|L>W;SqBOpM$NeCf}5H
zmv)Z!SePwGVqA~JxSpyHmEmJ&KI&z$>CvN8QwopwSv>CZ3OuTKRPk|_vye;!s031w
z1#9<c=V%v!7%&my61|`m4+<>gv;vP#7Z(dz+-FmGT&5_fPm>P<9YE1Bfe#Wo0uL5|
z!tM1cXCWDo%|~LE1|E1&P;V2mxLZ$8XQjJL#p6DUr$N(2+CfmIT|ma6kny5Lkc=iD
z7oUJk5D3Z!LG^}$^rC8gvQ+-PqF^Ui_wP{Fz$`A#cV}|9C1-RUbl*O0i|ADE_p?Kc
z+J9GWX;Zwy9{jQJpWFgl|M27M>XEvA?E;|w+(U2&?FV{i4bqdVg$Tc5KJu|{f4qRa
z@T0Gw4&BGXACH(jUp@W^)(h_3p{U0YPGR$34em_V&tLucaR;CJqsOm1_|#YTL-ejw
zu$Z^b4%}-5bpu~LKEmF4b%LbDCT8^`>_>j=t@_e<g+2Ju>-FnE9Y&B<cKY2Q&Rl;G
zW#7RcAhlAJw~1MW&4bg>#Xqo4=|}e?{U`A!_D`%=`seyf`IS!hEBzJw7S;cP(7(Dr
ztbV1xVvp-r@hkCxwGgT%=vVhg?+?=-=^u&j*e_Tw{L`T8Xj8A3{G!n2pS87RUS*6E
zGr3o<+o@{F@Jd(JhG*C7lbU}SzKTtn*Dk(3cG5ftTh}Ga7ry%V+S3=Lz)Ci@XsP`I
zxkZ<PFMO@~dQ<Z+L;a6#Pyfb`H8o{k^$vDQmx3SE#LLT0nty`7V;_50@S`6;9!>ct
zD!2U5iK9`02?syeH-E5a{$bzz!@l{OYAuhv^NU*kg<tI2FZ_~k{9@M*!WVvlMH|1^
zGk<`h?pLRlP7Br5u=jNTkgECU*RMxYUNI}35)Y59FZ3#8yb{OW8oX{#(EJnpfmL#v
ze)@4cmfAQ}bzk`CRkitA&`icFvHT*-!{fN13jD*@$AA<gInklU^@B~&eDUMQMV5bJ
zex%>{vCylgredjm$NKI^KlV?5^e6uG&wBl*KlZJO^nOw4HBVo>`_->~>+4s8$dj&L
zYvc66Oc0^J`eU8`(I5N8AN}dD=XAgDYfsSp_&80!1x7lukzS?OyMjCT7JabMnp^s4
z%2&o$`p(^5!PnP|Ebjn0e;wDnO;b+rEqYN}=vCV4zXB|#=^wWzXnugaU=4qFSMcM<
zM>W4PeiT3OV@Lf`J3AXxnOD;nzWO!Q|MABu#u}N9ubA(KD2u)h+g?-rge#!Y>ymQF
z^~rv7D=YOUE#=aD!J;hJU%ajC-16X+S8i@jJ3HGf2TsMu?c3N{%fEVR$YT%Cu=Uqp
z|7?>aJ2IIy>g@LIpMQSx$}6wxOOZ4{wa0Ci6u<Cmf2^wi_19m2Jz@ST{-SRE_19OX
z{B5Xl{a~lx-yanG4eb1VcDA1WH`tFvdDZZDKYqL^_=ocQ+VA_mzy7}OZ~5cjS_>Ff
zfdROWqqXWEzxA1Qw=2&-wyu3Y$7=<H7Whz)Rp7BRu2p*~@1>UAK38pB{l4Z=r~_jt
z2!w#OhK4>&Fx+-y>Qqp72h=sXcJ)QYyRzzU4~y-Y7BIZsyE85<EG#rEGz<hn!$SRy
zvOc@5uUx>v^jU4aN!IsS3=Ld07gwK^nwq;ccgwA9v%@Y=-FAB0<!AN1aT!-u=dR9O
zepYJF#g$>V!)|+>I(6#Qs#B|0f#_4GPCl&(@A??`(IGnh`j%OHF0Q_p!NjoVeAmY~
z?Ry&BIlsP54xeROeU`yNeCEeE?W5I48FS~yU4FDDyz6@x(`~!G%a2y97kw|ny6y45
zB}#UI@2aPKwmDUCsp8Z-A(lpkdPt8_m;v4c{G1yd{XEcjrASUlS>MAP-PNgvyl#hX
zM2DS9lIWkey1X=c_o`>>!rp-c22L=oTD5Am!rKXDC#+LT+P1;Pp$z7&MQgIQ@lH*W
zG84O!vvz6{lhY0MoP|p+)k`PFFl1`6=HBYs7-ia>vo<(T>{3p&))A8&-6^+ba~)_@
zbTDD|2w1}*AHV%={^c*yB4!#n0XG(IbWUnJ%G)I^nlG2T_~71ub{|$)?8;-8y<D_v
zg~hwsjmJyw@L4Z=P<Ypzx$or;nR4G#t5&UAz`!6jGrV2eXVo5`L$Y0hJ2UIQzFl86
z?fY#BxPdV9!#+N{Wh1?h7-K;uKL%NT_qw%R-Mje0uG;GCdrS9zo_<vHQQJL@uN8~F
zKI#welCD^=UMK6bRwCHtV2kRZK8e0(`|S4ZT!spU_j{+Zi~AmUyels>lwJ060fuLG
zg3@JZXoyU??}5j=cRkOq73O?<C-zWvanSm#r#eUXL`8O2JZ_z_y<0O)_i@m?yGQRm
zwB5N9tSfx0kQ|u5Yw!EG@8|d4udiOszGa1c4cjrP1iK%6?6T*}H7wp$?{qk|Xkq45
zSEtKbU9HPPMHve3d@pM5d%k$%UGp41>t$~nj~ConxjQws@p#GI4HoZaZ)2A|oV4ui
z)Ur^h5u)5atF**shJ@%EtymG28W^zU)Z#3Y&2n)?(`HtH%>*l`M^OQ`vjd_U%!b-8
zrkFX^6(pVnGI3{E-VK>@-`mW64>tyvo!ZUZ_i}eaA=qJUM}2Q=y@5Co>@aCj^PJUC
z2VO2a@OVc~$lXorK%omUqMk@I7|#5KTmo|W$PYs{#-q`oOF-)De>5<1fGz>?oq6zD
zgWU8ZQyLg1v?&U>ICwx3{@HU~3<3=d$qc7B4mU6`urx4iFV|8P0+%>%KuYQtF!gG%
zF}<F^+`u`-VFCjK-z)|e1|}Df90TKnFT4#C7`PdjFEB7LaAjOzYhX~SR$4W2;lj?z
z3NBX`t+<e4l+dWY%4_mfsWxGsSt-IntIS^oUs|Q+zH*CO!;(dw%R&}k%E(o=FZd__
z%xvqYe>*H++`4`)1VlQ`+vj$ze$V#?5NDI(CxfTQ47NpwOv{;cc2edhZ!=HG*nZ91
z@SAIsvv%h0T$}H6LM+W;Y1CvR)|nGb&a}>)pmU}%Err`yA$-@WcN}{>WYl>sKdj!d
z$y57C<Dr7{EoF;yKpx4emCm==w&=y~%AL-szQ1y}eecfFd%fqkU2Q1u*)6}=udlOS
z_dWLc@rLQQ99b0VL062jH8AH$F_;}(z;GMF<lT_LV0K?VKc+nP-R^Tz4A(w~U5ySs
zyC&ObrPt3Tx27F+s$8*+GyE8H6my_M)V8ZNTw=>an7P(w@J4MvyUp9|)TG-P+or@R
zuJ!><4LD1trWu_&lZiZE5OvJ3Zpt!=#QLNSDOaLaZFT<|zg$lK!KbdreHM?;_vWt6
z)m$BV{NZt#!m9N$r$wJ;ea^c2l7W5GVq05Vd)dG^<KvKhjC~d#xS#CvezMPdf%no&
zFH3gKv#I#_c$KCNY@ee{;iHOq>Ya}YIre+W>P?ATdR(5r{eXY_;fEhS?0DQ)Z}Hdt
z&3gT*HTpkXZS<e){}zA!kL8Kw;#YR;ySMYia`BagwR?*v`soKf`d#&0X-?eIqu;)s
zbG6v(-Tn6UoUX#E>EgGqTZ%mTs;9qwU6JO|S26MVF;9ZK!P?JfP41rbWzSBLfBHg?
ze%C^b`SuINn0g}2L3hUSQ%iot2R-_?f1*G4t2puLAoqTXiO*l(vHZ|i{nl?^KZ^YH
zFRJwKJEeE|li%g9H(hU4P2TeD&7!xqp0|nui{^Q*Sf+nvlV<nzuR-<o;-BKgr#Je?
zhJZYG^xM~~o=0EBbH9E4G^j>D2<)#_etKa4zgqG?Ks5WLedC<7KC2}AGnHRd#`p!b
zC4W_^YoB`LsYaT8%fvtIQ;$3fI8)mxf1onPPnGBRt&X3e&(4~iH9I<?>4GR@fYgM8
zi`{yqu5kMBh8#BFte?6qWu~vUvC4G2$y1L!nsBB}rB)rxsO^;Zd|GI+#8^Jb{ZeI&
zpC-@o8xy~Pwk<jvep_T8Zyd!RY?AFaSK4o`IRoFCltpQv^QNM7Rjp=kU9m<iL2Q+G
zrnm0_-K(?LFF8}TV@{BqOF!p~PdnxWfecKuS*I@2eq&<&mzn+AoktbFsnn_^pL$g2
zQM;nQG%oAbwzbP{=Wbbc!EDNA$1ml)GkVv~%8t7C#Nl<-pKQ<QSC`i9UiErP@K$LC
zsRrGQHM6r!H-tv&rfPrHviF?vs?eM%M>#=q^;a)@&zWV$Gk2UkJxe)jby8c_UoQJi
z>YrvSX58v_U375^1H<&m(u^V=iX1M>JS81ez+3I6WH2zB{<khUZKND5*1^Dbn=5Li
zj%H$FH_y?|Zj+PK($aF-!mheF2r@W0Ffcd@u-N-<&5n$^w*B+3>Dv=n=1-4HWRd0S
zfSx~``e*tEQ#P^bvU#k$(=j*LaZbN}gIR2P$5&R~={H?jrNQ$&(+lpi@K3LCW#O9s
zKaoX(4Ln`6aryyQ7SsA&Z?{HsZ4-s<!#ipQXC45ZxwzFitL+r;Dz;ONn-=7(kZGF#
z{{FwHX-ijTL5Oz9R`|^fXP)bqi)zK!?S8r2@^oDEvg1n4^S94SZ?JmvX>M7i-we&B
z-8Rc(=LN4juX#Ov%FCu1nq3LYxDuAtdnKRF$<i+mFMEB-YpTwR-P3j#nWjw6-FAq*
z@~m$~!Q8E8HVol+au_tK-**RH*{bUeA(mZZJ9q8MP1|?p8A@+H1=(T{%vx6I2e;)i
zt3j~IK_8KWK2wer=FXJK$$69WhV^oA49Ljp)qHE)7HBaoT~W`~u!0NWpJ_{11gz8w
zUA17<s#%lQ5o5Mt=(O$mS@SC2K8-zZ+dHq+@>cQrq~-IfMZrfbzg<4puhjA;=#b@C
z#Vc3I-i^KPDd96I;>gt4d*F?J^`Ecpy|(3QciHoGcfQ_yXti?ItT!LpW9JFH-hANe
z%?EP3Z5pqqPXPI^tRiSZRmv;&WqwOnFfYq&0I@&<Q4LmUGr8V;Vvn8Y@Oty9(wk5H
zV46NyZ_i^+tU@zT@p^iT)te8tWfkn}&etoH-h9Zn+lD`O9)lIkkQ1_H6<iZvPF^WD
z(`wp6zM0FIK`f9!mcYwd305E$g;EFj&xswnabr!rGuu_Ol^ZujwDqpa4ZCn-jkDWT
zGv4N;jr=dP{x#=ryTP1sM5`fzcd@{#h6LUP27(#Kl$0147#Jsc1$k;hruad%Bm;w_
z%2Jg{Q^3NWP-gi1u&uwZuC4yTz#uz!L*=SfvsSHIqP1$lT1cv$J9k4={i>C#R;`i-
z&CsmgA)vs(z&ly;hS`BAu&~qB(4?!Op%b=-igB%4p|MD#x9i4=72DQ!M_t=?BpXCz
zb#-Tfgf4b~CA*Y5Zmb0{*FAW=yYHR#4t1;Io?Ru+{R*f1&3Spw=;h_Pmd9ePikDlQ
zUhY@&T(ab4{kb{Mt`+`&CDOVgRHP^{)h&19B&k!nUDJOqn-UlQ^k3#bl~1fTdn)}^
zzWTdN%`~-Vir4plHIIF2E6=Q%B0qlC=y^}oc=T<h{l)7`PpTfh>UnO*t`+^<NA~Dv
zO@4j))H+kws6M?_ex(m99cCRpSy&x1Kc3V3Q9Sq4pqkQ49bb0V>wy%m+HokfH|fca
zT`Mh*2(R~^^yu44yFE;M_UH?J*t5!CPRafH^h+Q0x!(p=hJHB|+OH2XUu*KuzYcS2
z^}M^^29>OeEi8(O4Vlv^XSZjszR-uABA=$WX@*Uo-ufs`e5&U|QGYG90N3tUnm;r)
zp9UG#wCZ_G%ye;&daaLNuP;4WSfsf!S!A{M+`^)mn66ZouV1e({ivtsYR|Cdc}%>}
zqbI>1g=}j}Usg<SJ+XYsexIN<bvBh1@gR#nI@;D&)=gJEdSdwt(K)Zb>;!2GRK9-w
z=}VAVHA_Dn)jIxo{&om2z&}1NZhB`$OjiYKdcQt*{gFL-t~M_H@p19qVCK@7U7`KQ
zKmYot|73snME|EOzs~Ig8_pOBaa@r~)vr%q_IMw95`1c&gx1C%=Rv`t=U5jKVz2or
zu+U|>%2PWpy{;EmCf>gN)b`}Nd8?Wre%1Q;=k=v0J9dg(HEe=;HI9H^r`r37M*OMx
z^kJXs!y?T`O;x`>{nhjCp6Gu;+wwZtOLdFf*RMYfHuq=n!=}~peRcQ20SXG3=>-`q
zBK5VEwU9VjzKm;4o&EglAL~{B#B|kbs9!4uhnEG{nb+Nu9z6-3sC@nU^resD#FgeL
z#z}d>Jm+fT<S+Q8W=gDz_N1cuo4S{DfB!tip1tJv&V}b*{?HDeC0FjREB9ON_FcE{
z+$p!Cdf&MSpWSmM%k|gm?ng28u}<x(f8tN*b*=cjJmsx@s(90<jY20r`D;E|^g%Pu
zHu$8?@>iNyJxh;*(!te$nmUlkN!J&0$5agd)P+8Z6Yp3))oK0ok2T&8YhA6nR<8pE
zf!_-L70V&6oocl<Fida9j(ID8YV2nX`W3K5|HDF$NCq~c0K)(yA8xm4y}D9Sre3;A
z-QZ1mkwzPpW=0xqN=-R+a_VG_ZbdPTq&A)i)h?ZoOz?g@&ZS@~Gioa66iCw~BO_yj
z!@<E`x?Iy4vsm1xugYRknLam*g?GD07K<ID$ox-gSHEBXbYuVNaI>sgdRb4C4(3ds
zmCYhwUldfhak{R?)_T)Z^`;XTO0UO+`l+RJcV6_~dh5l~1ALsPxgvr}1aE4bD)X|x
z>S)I)>ijg+nalB~#zw6ziym1x8m+SQ<CL1i$JHic7&DpCWR5#m;6yhegT#PCZQ4@~
z`1&cgYMfZy7vff6v6M&PMpjTt%9M=2RmyBZZ7X@g>vcojcJ!$%cIpk3Fq&fOk+sT4
zN7cvEpvAJzOD{C=^rY@prK(avmVO~_%Q=r~WGQw%nYF4{UF4CM$&##&Bc}qcIE$Xj
zT4idnTqtm<GRT%WL2Zkqrp)x2)T=4A$k1qtsld^qt0CE4g{o3PrY=dT8d-{yL=K(U
zI8`&DTh+UM`byVRt1OEGOV%w}9OABds^iLo9ZPvbB-VMZT5+jhoyy`6w-r4)V3FX^
zz?Fw~OzI7kDOzOQ^k|A{Kvq!FCNEQ$td2vc0<JoCJzcfpI@cq(fMC;NkzUcj_twiz
z&7@@B7H3@32|ZgBwwCQ?)^a^By{T8GWOdY^aP2x0awM3gM@LgauxXjLh?=Oxl*ELI
zU2USlqFtR0Gc*nzQs$Do>caj|bEZM)kD2zu+MBw!L|y7$Am1Q6<x{9<N=3imBdaO%
zj3Nv<4*FD7R1_*zTsSyoVXK^up1yduir*H4RE<P+4&P;$v$Jx|w%yX|j&@DjxN%$8
zv16C(Q_O;T7JYL$#r0J)ZpC#~aaHXL>{%-wEh(F5wNj30ebV%muAQrRrB+>R>$x~%
z#W{@~>taM>!q~!AYez;M%0B6OwCKUAM;nZ`Mx^x|nIq~O8k!++fvs!O0bZe{4N_X(
z3<gtm7_MsSFkI4#U|h0f1GC4<1U9c#d;GOeJpiSy`qNyId=C!2D6tT=(vmpH<2B>R
z<mG-cD|%7`5=xHq%`tUJ)@o*awf^h2n+;|?&N<8sxe~407#qwQ4ze!l=m4E}#OA5#
zsj>{*>t<kJP+;Kb@Kn`QnX+V3&?HYU2y?SxUufLwt5xgzHg&yTw_LDKM8xAkW$N^a
zmGvTV0aKT1Zz+4T=*iMTr!p^lA?<HV^%mO9=}L1o_SmF3^~AD7uRkkh#%gR`rQC2j
z)Yi$3AyZU`;Zjfp<C2gK%$}YJY!ibH@T#gdNV$45m`s@lmOiCXF+<B=SiEypS<r5`
zof<neV;Nq_xVv6Sc{3?(B~PNVV&5FARLz3=Nohe6R|O}$Iw&s2v1?OG=PZfS(IHz`
zKR>|0>~f=Hk&?DZ5(9&j+7VYl!HC6-3<?em%t;2flr%be7b$i0fR5#K^YZf4nKETk
zrlv;PNl#}j2)8k1$&yJYJv~(?O`7B_C@3f}Wr}gil7+KXRe5eg6q<Q?Nv^3smYkdV
zBD6}*vo(C-sl?FRle&faR=I~NFIjq3^~sZ9Bh48r!6D#kv{U4aW_(lo3XcQ4N=qlL
zx)f;AIH~1Ivx?_RHZS2Io{4I!c&4aLlvMInG76ZrBBDz!eCo-#@Ko(BWwU~IyXT$K
z^9pCY@SwyhP;ahPkyEVU<wa@}rqy?WcE^<MdcAHJcq`R}?ya}pmdbjqYbY)AnHn{B
z%c6^cH#Oc&*`KuZs_Ny5J|~tXEmxYks_RLx!P2@*d>TDdqJrEzA63kC((78+=h+(W
zuGt!%=cOCG;+0ijm-ceMIW6H~v9VEt5ia&DGbTO?t=Q=^HIAV`cFUp*i&ss&TJQ1J
z%T|3-cT`|@z@8~l2i+%iM=i1vjT5n1uYKy3)znyqS8rx&ZMDvHUGbvCN_L6&a=$qf
zru&q<T%y_<^hM><p7q)Xug8{Nd6iar%?GqCZ1Kv_tH-?7tqWESW6#ytu;R^>GA}Eq
zDt1&WT1quz{gwwGEv?tuwbN&6EW-oqOxGo^tojyjaxHmzc|zB#)2mlIX$!30wCV+W
z-j-Ec)pIpAEh!DMS}Cj5&-i4~wJA|o^i{<+1cI2dUg6nWZ+$4$+O^|k=+#pxs}8(f
zDz<pxg%@Q?u~sEdT6QHb_f^!@T6*hk(GhnUb<Uo`W5P_$r%#_g^JZ23F2)Odr^+rZ
zU9xyn;7yGefsa5TAaW+;M_1Y^?MIq3MM^YFt>*f3>781=Kz7%qRafS2S#$!!p)M0|
z>1MiK;A<#zwOT0~(znWeir!MOt=yZsBQ)MDy0$RZOYeI2)~D85>l#X!H_hF$2s8<A
zEvPrQ9+DK6O_;{2|5s>5iib-5AqM{FXx+8TM3N>Y==&U<FWhIptMK?YKfUbKEx9?{
zW`=Ckm^roESgc}B;iJN16>|!^#nL;E%c;v$%;OS|Ewtb1{O#|qxuO2IgTH+WskN~`
z_>WJ|;&GpS;D_UfAAa~V_3iKQmsMRA@h5BbU%#%O(^XhY%-{<8pa}Zd%(s;mJN3O!
zPxOEEQBQw6bc`k+V~hsfn0j<`(8hRbYF7ETe$~@|{Zr(_zNHT<i|2F|)~g=<_UlJi
zjegLN`22W5|JFa#5B;uNG=J$&^~_(8QJ3nnz_NKu-dbwx^jEpm9lR;ib=B9uA@h&^
zncn*JLGblZb@7#jg|&N2gX#;brXTuU^)qBX_m#b%a9B0D8$6n{L-ni1epVfp_?ZHt
zr#d4;H6#>e_&dJIUHoFV_(84vg}>rQ5`OeIew1f^WXFD_hCk^?f8&uF{*E8=f*<UZ
zAJnlQsdnG+tv~Ut+~HUAGg~E&s$5!f`pc#zN7OVn#z(4@JUkS5P?=4o-Xft*(MmTq
z%OIiMC&;c-mPg>_<wpJ`>I<{JoO~S4%wj8Rp;Eh|pE;Dhy`4!uL;b<ls+5nb8&@@7
zygXI#+aep@5IH%SRs36oKSb>{s<?XKs^g27r#gNI%CWa=H6IRTUm7xhU+~4HNl6oX
zs_f?byMs31)J^hlvy<lsjmg#jsIi^T-wtN~sIil8KYa7ew`$vY=U3W!om$$aDjXul
ze~Ytq#p94)SqmPnQl2W<9LOiN!j$F3*3uORFLws~4wU7avx;xl3cCybPFG(}KDLg1
z@l?mlA?~+2KG;}>$Vq`D4njP0@zjEstCZimRDfK}8v^o8J;XaNo(7a$1$l>`pKn$3
zC8v4%{Nj*pF{@v`3qQE3N1jhmCdOi)y!hcqKWgIn6UC2y05iHDeyp+Q@4oe|I_`Y-
z%{MLI9qqc^k2SwM+!gTDCE+;FDqcr$=$1SRv02gA?l(7-{TAnosJ%8tGW_m-E1l~>
zu91@kiT==yn`g<#zIb`a!f%Ugzz%uK@<(jFzf3#x#mlP#z+u`R>UiPh<rhopG{5>Z
zZ1PI23YfR)>y(>*8O2_6E<KxaD|lABsYofu9(UP7apuFzJ=EK;37iV-lBnW$U%Y7H
zmq}IH{QffP%oi^&nfPT&g`8ZytSG<t+eod<2!p^bU4MU>sRzE4yjW7pWy7OUQBe@^
z#WmFZ%lg;#{m=KlufF#kGUo^GP}lYe@AxuT@mk5t%X=Sjty;wZI=LU*;byh)dwi*+
zJ@WE$zxNeQt5!9D=C4+OG%>oVEMVkRX$@P&;K?Aj>UlY5JyY!CyXWHOsf0H?1J5R|
zTD54^dM&0^t4}p(fdy8JvVvz<5QJ!GWq@dCTnKAu_*BNw(5DWeNCM3N-n}p1`@X#F
z-MdoXRk>T%IR8?a{xzg|X=VJ+sHa6+PrK$x?QUrV-53QT>RApbfEILumS~oSYfoJl
zt{t-_?BQyxi$VKBZbWO`G-+G8)pu1+uAAcGS<fcVdKPYwYjHL2A<RUUMgtBN=<?Cn
z)w7;mJzI2p+R>e^*;tLNpB|=l?5f(@J1{K{GrYl@WSAT#sNUMSE;r`7*_~@<&$MF?
zm@Z&o5I{0|_N?pXx-o0ATcdX{Fn9=o!k3`|d=(bRV{c<ti(T{u&j}v7Wfs~|_dkD%
z-TuH0kXwHa!EWoRKXmcMzB&2}enp;{tI{&h#>4O5A1xledvA+)%+?+_oONf_DkuX=
zt=gouYSnt34)(&AFK?A6#eH4UqMK{0$n6F<62@>}^s8WB^UHLjl1V}p9~G@DLL_4M
z-g*MLc4B8}2$(V5wt|JLK0q`yG%iwr@A2i!TizYn``VKu>Q-g<(WQH$%nCEFeay@k
zo0~7zJ10u))1~OMY`oGKw#jwBn|oOK9TR_5<e5jpOBw^WT{~%Q9JsYVdiUzB&-X3g
zSJe!<jp){PtyNG4GmOu)YE}K}(@M;*!dJ{S{hn^&H(NZ>D(%+lrCY$PoLCdT+2VP^
z%W_w(0H<)qyT_L=-{pDf+)L~2vR2=hY-+r8)OrUehv}AYaUMA)DkhbR8!k+^_@wRd
z=99c_E$u9A{VHZUo1|<e+}Ly?<CAl8@<!fnopzQ6fi2HooH*f}JbQ7yvLbKWq048P
zT{s0)6gQ@xR#xQg){B(n$T1U}mm#I#(Xd{{Oy6(s^hwg<%i~U;<n8S{Vy0j6Ztu-X
z#f?>^Z}v>MvDXS@d(vxliR$IWcc)Jh=Y8CF`Xq1L$K$C`mwcB!UKZz(W8P=2uVN;B
zTz2{-X}<F+X3}@cW$SNNzJ$8j$=MwuE+r%*BqJdq+&4SyL4u!EZggX##mlXEY%GtL
z9Zt-+0CHkm8^noozCP|d#q#pJhjZd2kdL6`hAq#REXZh7Vremxl1xca+yK#Z=<>Wh
zg*P4MTE67SF^ZLx<j65n15;*VbG}UB6;N@Q(015arw69%MpW_jK5Gr(<+jt8SFz~V
zfBy%$?D3VHUKi(t%KZ!<6g2+*|0uwqz?AB|XUc)T>U}<`tlt<I7+IWLSS3Y*+Cj&&
z@>WJMFc@@KFnBO1F|ec^(c)-0z{$|S1X-WJ)-1rF!oUeq2+BrMJPbmD91JR-7*~cg
zEO*)|QnKd<-wz8GMfE%R^;!x{D^{hinEz`@;{*oAg_E5$f4&OU0%>Cqn&%ZX<pM*M
z0|Nugyp^s#E50%?NTo0^nug4LDz!2sbAplK63}Vqoob?9%`9K#I+9W@T(-Nvg@H9~
z1Fwn7fBRW$<!A4=(YYVLoqhL(&DFP?-e2c7f3@Sg&8-{#pAzN1m<9i?cRthqx$VN2
zn>#Ge?&!-fYtArRQKz*(O?A=5^cR0^SU-mT?9A8_`Qy*WgQ?+fj%<n2`P=uPPHQ_`
zd5p{huqzoD7+AGx`rFsL*5$8`&fQ&Gur<SsJ5>0Z#`=idK>t}TmfLQ+{N8qJWn9Ls
z?3~F-HHRg(F1mI7iUjZ0eLEJ`ulBHSQ)=f`@%&`Argz(|z>sIRt^B8yYRPVuj(c%n
z@w9!j`cmUH4lQ>Jlz4kmn)BeI|5gTzo4KqL%^45sZz+&bKglT_b?<5Psm)pM&7EA=
ztk2suS3Ix%+<m*6n^)`JpLssxRb=wz%iE^~A3l6|>TRu(lB}Jn!IP%0Pkx&GLO!Ja
zp>@xd+S{sN6!<;QGBT;=w(w6u+lN|iy{nybx8z1iZfn(ya$C}Nqi2%jj2?~65<LQE
zHumtSoH6X-=}f3Lj5xBfYsOJG!_Z`*!lQ3aB@6awOQ;#Le>`-IC*knTZVAH)hHnl_
zIKTX}YA*NP@I8|fvZ9|J<YPWAwA{MTwf;cqk=Ao}6c3ahSn)jXD_`@R6)Vq{JzAGu
z;Z^o*2Y2k#pr_|T=IlHbu2<+6wJz(%T+TnMS3i+(PF-+HcVZNebCR~>gqtBo63vff
z0#gjyoH>%_I%^q81S?JzJ}!JqVwtnX@+0<)74wp6)Pj}$WA<IMYhAx*Wzlm@%i;-7
zyJtk#iwn!X{eI4J?b=6=Y(8IKc6Q>u-=8aE+~g|1pW3T@-p2j*-^HIQEeft#UcGm9
z(?7p6cF8|MtS4^{KLZO9WNgjZX#!G<POr0jbw0JAe#Yw1iL2wM_BUNW7xeU;xUS4a
zvp%(5ufNZEc27_6@%i`Bg4b)m?NL5HXFbQ^2Y=>=-+H*Fcy-pzT9d;+j+?EWt~O8J
z@a*c;lgr!B6ldKm%6#})=GL~DSrs+MLMQ!7Jp9aP&GgHB@`h7W_RT2x*|S>p%i;Fx
zt52Vv`S+!F%TXR9)B5a>5r3k7pL#mo(Cu{RT<gzgAH7(8>T}W3^4NdYTu)=Be@gt=
zlNzb#V^J>``effc8N15xN#808-mQDOdGq64yQle`_j~m&(s~`AdN<G9h?JkzJLi5|
zwZkXK;8LAv|Fo^21EphpFMi$|$5LVa)Z^d!(%L=y)9bYOghdwfs&80RQ_oU!U3lS+
zT^v8-ufE%N|N5KvTRjS9EOnEV=Sf=nf#Xr?)2j8`r@wi>Xi7NO$)9y`J{HG6uim%n
zX3kC<gP(n+<yYfh2+Ez9zG+q6)J<zQCH?0)9n!Xz-Ru`<HOoGx_=h3?Oj-W2>^~y(
zU%>mRZmqVdv(^<yfn3L}lV*r!oMATLtzR|evTn9cV)hrICxLZc`WIb)Y3z3uf2s6W
zC4Ncwmx(oYg0rS&&0q4soK-MtQt$M#Z98&VgEA!!u2qY<6ThT;lj}*C(z;3dmt22&
z?DrHueDBr?kQUCZb4%}*GO!1^99h*Hx@p_0nJaF!zf^kpZQHe#Hfquhccy06=UF_L
zF}uz1%45dth^xstp*bzL+WEHzZ%LfP_LSw}mvx!Z+_^e$=CVC9xt%s4*Wv1P{zY>q
zH{1zzj}MtSW7FKQTib%<gW3hNmhxo%*q3!Zul3&EnVZvJp6>}0&yISRw|kPyiAiej
zm%LZ$oT%b^y~tyxkjvfYmG|!bt`=7En7yw4$wVWS&fPcfd4jnhUjNOyonBtSN+D}D
z8*bWk=5X2p$64>LN6k9G*s<->wad|7YfU#@o4V=JX`M+yzB#vZK$jP+QexQP!supK
zAG_^#?z7vu>z{uGt$+sKT+q?c(F4A`Ku}Py335$=66j_i(A_{hqK?giEG|h(JdVwR
z0?<nglz663lw*`)brlq_J2TxriA8Dp1y>fH>GEnUlGC;FSOuo<zrn0lUy>|w?AGGk
zu&cbQq(jV>nyttUc)ad*NbV}#_4XeaIPIS6Z<^{-thO}t;p^o071Os|V&C?%K!Bs*
z-~Y<D$E!jz{lh}?^sUz`s?J`Xci`6Dz4@lPXRI7--^=lR2)I+7dbeoRp7MN~in-7A
za_`05J{rE}R;a9h^tCzZJJ*G-URqIam-FrMJfAz08M+VOeBEf3Saysr@XE?-$1JX1
zdcCx|=|TvrV>qj0;8l-HQ%hsR**4$qbGgzPeBxX|QN!w$Var=w+&16tE1r8tY1N94
zhvz(22%e)~JbUJ@&ATJ-v=!fY9Qmej-L74)&b>`9Taa7Ep1ncpywA7Ck#CP}zVSHn
z<-EJ~K~}qitokk;To<?Vir%g(dVMz&uIoE=MYD<AW^D0!mR>OP+(Y9zOiJm-))R$u
zZ@Ao+ZJ%s8^G;XpZm!&hgLBTjlU;YmI=0Vr-prTt?qu8UxK_=$<{R6>lBm`TIU5wG
z?#47fQP61PN?ErhrEJr9i|W5vwO-5;cieQKElk$w#a8YGHxrz-`M~-sA6{9{zHQ&t
z#erL{t=y6;+U=V)%d9t9bn2?WEx8?Q)`ma7b^YVQ21REEr-eNXj7@*P$ll+;y!*SH
z;CqvxtE{m>PPPzQKw++l&sUeprk<w0p{1crtCUtLbuu|jyY+i*eb}~Jr&i}WmCTst
zIboBj)|p&Y{g-;HKK@hxVt=SIWa{I?hfhvADY9;P(51)xFDgUk$p-2zy|Qcd@%A>K
zsal)j#Xq(mb5--^mPnj5WvyAxK0T9LD~(b%Y;2p&v3l`hHSb4{4|+cN6er$ez#1=U
z6fZ6r<O7nPqO{@1$w@zUT&?%G>^oamH$yWf^Kjbfsm04zE&01_wpmo%-YHs#+kB>L
z{a$uyvaearrnN5@idH?o+`c(=YVp;esxM!@RqJPcU%p~u_(G#qq0=sNcq`2pT=8H>
z=z*<#LMf@My{2A<C|;$w*5u}<Q`;A)R{dPg_jacK)!Lt~_PUwN&P)s4Kc(Jl$Is>b
zYNu7dXKDUiYx3?>&i>H7E2b8H_LDoGI_dXSkw0HwzI^j7QomM9>v6x|+1WbN?`bT5
zw&l&uO(*j^JtL2wI|owuVNuEP$2>E2raje~di;FW!#Cd|bv=Dve~z7%b2DX&W?13p
z%k7(QrpA?4O`7+w>eG7v^i3zL7KP5Ks|R^o>+@=%;Cg#&kURIhI^r51`vv6Fo2hYC
zljeQ<`Vi!R@VRkIRq7dPJ&IO^9J_edg3Cf)@Jf%{>Tcx~kE{Y-`h<t_^q3}TotwMQ
zqSkI&=yRvws_f0avvpRVYtj1k_wutjW;vVI+p8>pU6p+pBz*pqYJB{z!usVrAT^hQ
zzwR}CxXgE2=<|%OefvuugS<br@|9QJ-j}ZrU%vTf(|TL3(D|`n9&bLJc3SJLs@3*o
zTRz;}bZXBhm({Po`&nD$+)RygSswP~dfIHW$ndUJ;q&8n72X6XzB1+f^>?%0TuwW!
zb;UKVHs8<MqS|&^=qs=E*Z1bt@3ys_cUtR<X84@#%k$1jn?;7HEUVkTJnyVo&Zae7
zq0g^<dAu1MbW4_j+_D+$mQYty^&69)dhODhtXI5u@~#rjk{Wld4+Z@~hfFOtO>+-?
zWYN#%-juW_#5*`^?Y{5FGir7(zyJNdiEX)mn2BBN<;RcSGA=)!{bFnV>hif&_kEuw
zZcc4<`7zt`W6-ZfHXchSPp^J%Gv%|tz~sY^EW;PKl<k!fe3{T26B(MSFZfb!;*nCh
zuD};PK1+5@o&LaTu0VKTr0PT+l~hlO33^NGtSg_@y%*TLbV^vf*X>o|54XRXdUN}$
zMcH3oiN-p7QlGRf?9?Nxe!)LMi+|Khtbgd!%N6Z)VVmgIpesvmO$z_eR2z8klxcYB
zst;B6^ZxIjv@Gy^#%ICT98c>Dl()WbSUP><86&f+9tDCA+?#9#|MX{k(+qrT@M!6S
zQ_hD9y)UYN34GD@O=#Ygm2y`d6Wb@BELyXw>oCtuoz+^MF{^v+%yPC(nQ@qBrta#b
zjz9HIq56LXrh0pYgii8g6ID31vgwqkPM0^!sSQdgD^f!v1vZK#tuhi#mE>V<*s^kR
zl260g1yX9AE3+cq0y~Z*C1pn>PF9P|x^i=~vB89uL6<I_1}*O<nq7}o!=$C&-rhPl
zH>aIBbI5C|uC5Mfow>0wr&h?8Et^0q&d;1tIdeukYvR^bS=TZq3mw_yGda{WSTj|}
z;N)bTtyx!BM_t>f>NRcJw8+hAXJ^iA#mVG=shDoj$)Zpnv~=mxX`uD&X{iV;GiS~=
z&J9`{wALw0Skq{-meFFNB;TkFht+&GU0ofvHaqGt&rGA!VQZtdu7O(*6N0IN%kUVb
zoYsYC2CLyQO1ZXm?Pjw>Q(Luz>cf_-;cPSsT+|!2HR~{M)Yi4xIcGOa+AwKLXQt3q
zjjI|U`=Fwo5iV<1iiPyR!b9t7cB-Pbn$M=wx=~xRu5Df85wbEfGcz+4v_L;Q>b7x?
z!T*S$|L+Cuj{moC4Gal0(-wam{;=|{&8MxEEot5fIlPVa8@7cVy75f*+~>CUDJAK$
zJ0^#9hH5jWJn$1&wRmLue{!_O$)Xd_wP!7fU8HwZ%=4zwL4EtT0sE#bYJTfvvQYF*
zqF}pdjMK7EH#OnTL#t9AhBK-$6&47cZnBuN%&SLdHB-c7EzK@<?S^UVR0@J-dRoRb
zMeSJiP}GpK<J6Xhll78ZvqB{z!<r&Jr;1$ZJUziXCa5sb*JBoEYFJ=!z_LK0gGN)s
z7DOtk>nBgtdV27xdq~J7VXjk;iZnJAbT<Thx{E7y>j@TcWole>oitNv)~dd6rS5Q1
znV?{=#lqT(r>+EDJ?JMA9OxE0^`58LBXOZ6R|1!Gb0vvfTJiRz()D^)3#VBtC5=wD
zP14cq2=-d6peES0AxSe)bCTfo{Nzop*Yo;C{W*d|m9-9co>V${G`K}`Rp8N+N~gP)
zgG7aSRU*7qJ(ns^J*jjRBKbUflk2%~PpcKnx_VagTdG8(sobv89V7H8WLA*L#3Y~k
z70VipR;>v+s+q_wD)R5bEotY>-01LG#bKXk?q1bxSyJKoXwfW|BY~3)W*E#&YB&(a
zDyBFk;ZSN<nx;2Lghrx{mX4}{*HIs*h^dAin^voNHm&UNS*f$=M98TX-&Rcx{o|G9
z!&T36lDm2O=jiZnD{u4N%}$l*OT4_V^^wP1$NDF-2cO6u(wEc;ZB<r{G+M2u7-7TD
zeBg;^#i|p+TAOBuPC2zE(#vXQ=%YiRb2&YBtva<NHOyz#$*GY>Av=~tM{DL7ZV}1s
zIk-4VH&<Hh0)qhfqMfcq8zgvp!n8%V%E`&esZ>-{RFr&ZeU!BNrnZ+rLEL)ZoOO{`
zX2fdN-=4K|lDJa$Ce52lA12=wzHsD-v98Ok^Ujuq-m|u?GkW6jczSbROwhBnt9y2{
zRIL(bI_R1ZHARedlF)%oT{_%Oiw<m=G%eJ`RcBSol*o{i8k<%wRg_cj>8-eS$|z=&
z<*8>KFZ@>RTJ@A`7pFmzasZE1V~LdvU#M!cmNLVugGcMH9=IBqaB4|{-(0Ibt3G|&
zvtDcKm+fB+9JzS}oHiWeU@-7qy~;JN_0^Yar(Uf(^w7HSmaKT*t7j{wD|JtDy{T0Z
z`e!e1;+oJdDO*0vbk)e!eSz-cQeP~d9@Wdbwd2jo!W7S!A(A0SxK8>A=}bAObkb)^
zx2nOSh+t2lLo-?;g6p-E4$b7!(Ok)CBR;)1XI-pEq283YXJanOgqFC6MwS|#^h%wg
z7O_#nN`|j3V4dbPrkPnCC#^P2d2}dvwa&~;rPEpyr}=D3nQK+@>gDC-p;a}Wu7ZLs
zle(0Yxq_w{E;u46xJdt$XF{^x+>)};SoSA>Ij+X;dKt5G^$wvYfkhtmySd_;_D^59
z#<Xj*`@-XTd?wSb?zpP;=y6=T%#NjJqr+vFI=*t+uuRi+qR}Fq&IyZ-O0+~Q)>1ku
z>D8^ZNhCtYNk>dkOj*^lLhqjGrrkn`1#@@2_1dL(_v%^2qv4{l0j~r~tYrB@m{;qq
zTe3PZG@<qKaz7c1GOzILS*y28-L2O=DigD4Q%`5?u7@!@8+AouC+RKqz7W3jMK*8J
znu{+APdE3fZq2jU40DgG_L@-cE3FA9S}Q|uAKSKW($$#h8or^o*L8*KWxWe63_Thi
zGFK<jE19duN0zVM@u;fdDq%^3(!$bGNyCm{sg)8TRwXYlh+baqx9T6)>H1yUZaSRW
z#JHvRY2~V&h3l?b9+fOutZ_l{_Bzo+swb7+Oe}S*Qg4pP7ESACm)T))DLU+Nx9Nk&
z(^-psSFdu4vk9HTKK0qEx5u^z6}pRy%ye6_?rwo+%+9Hip;yC0=6c0HR^gLSIi{0z
zn7#2qNuQ=>uU1dWF(0cPyLL?r36^TAPgXNZdU<(yNa*F|ex2eU!l!F3X6?xFw~WhL
z7n8gx=26d1&MBE%?Rh)GIi{<0Z*sk=^w0SqIJTPmVq`LPR~H_g^`Y=|SFC8Dm3T*G
z$DQ@2;d-XGmRl^=(=zH+l->29Gp6xqcxWv177tKN1csKTUcI`IdAXk~-(0H_`GDBn
zt9PxQF7u}E?kUq9!V^uV3f^AF=cwl?p3=RP`^fb56Iev+ojPMb%q!Y+HD<^0kex>*
z3npuvTGe;Az$sjzF!XA;!&?q3S-y7F(Adb*(k!iYb1h0hJ`#C*H}-1Gj%%k(&kD~C
zz1;^jbiwqld7vCK%SNW?!DG+d=sun6&3!S#ODb5OJ_9-4^7Kr%?b#De{q7ckVly;W
zu>KYz5v^0#ShcI*;pOFibAz0>N8Q@Js_gLgsGDxeGs<?a40<E<WMY}eo(V6qMbjeJ
z^(Gz*xd}4gU1mqP^Xb!PL4lf`D)p@M+^V<7*+pYQOGB@QX9j@6#cS2BO|M>EWq5hH
z-EXc{X%PR{Bg`5rUA}7uhOeog!s&F)a81%p-;hNTCz2I=c!GRFSsV6W`0o+-?$)Ix
zM?)plLzC8Lt=fOw?AYxH&n{)7-Dfv$yB1{7b!JVK^IwLzr~Y65Fg!j#(Jtu6;+4_f
zfAd1$?3*`lPV&2T-_}l7Pm?!1hmTQ@p=j;u)RW8P4bNfFh2KL$=dIMww4L-I&gI)W
z@0-i!8@>;_y6IPDyTr4ro1R=g{LB(GqW0luUv9LXuZ>;u?6A|5{rP8{+7$0&fpzq&
zU#{N1G~Y=gWT((C(YLDYS8MhB{e6<PPSzUyczkNl^vj3a&ue{(JI^P3^{)N&?58EA
zwtClhy?9j>i#)h>XzII3d#CD$gfEk_%bpwiHOPIX=Zmh(hxunb53dbblA~&AZDUsf
zVy~3c^YiDiOP(A1HSBci$%pM{>Wf$JTlG(|s(YnIn53H|t6<AXjg5_yl{RhaoaPn5
zb;PS#B=F7ZPpcoT{>7j0&+&x)gnETvD~tFRJdtUhP{ikW!jfI#+tMOF$6pXONH{0-
zgzcogOXIHCHogsg8~S7ZWQikJBe_l)dKzY}P?K^<$ui1p^4TXAG9xglzFYKdOO=mC
zh5Yo(myd>&+N&>GRkB*BZ@v3+kG`fjj+220P9Hwp8TevXgwU5&FAI+xRlZPKQDqa-
z#}qd;D$aB=r(AP)`(mzMmOY_K!UsN9l(_tf?|xWYu9c+Pbo^-eq9-9W{M`>9K3Qca
ze&~Ytt<{G<?ADY!eCu14&6NHE?_2e&ZGUd(nd8S5zBTTAw)PRPe_E4on63U4vMo2a
zY^t8Crh)Fd#%{regFF)U%^#}y6TjHAKlmfBA%5W?6AOocf<xmH1&2pq1`}JuFS)}v
zs`(S&*tS3VwOUne#Ywdj6HbO4Kc;atFkz<ihs==DTD!Ru=4n2f-#yXwY8cP574?1V
z-4|~ays_wG=z&v3K{hs)fpUwwkA^RJYH`z~<JFfcYc5NXIIX?xs(~+)FD?z7{HeNF
zv{gLd)i&N$C(DGk)vZ6Io&2fJ&r^JB_=Yd@Pd@4Rwlns6rq@?hGu~C7Vq4bEj=i3!
zePzlGv(;brO!svDSublH(tq;LERRjAe^^D^)N@8h$2WzmhU%wpPXAaPcm3(ly7=i^
z_AO)9+Se`^`m1jKa&-vUs`TW^UrPuuD*{d6r*FRbV!vpL(W*6*;x(rJu-8-nlqvY*
zPti)b$(QQYRk~NLk&W>SRlfM*X^_n%ebE>`J+)Qt?d@6<Us}!b*b`dC&)j*lUhv_I
zCml~FmWIBt)m!E(WGl5&%41Jxg`D0|_qHkFpFnF!PHMi9yIO4)$6`CjGNeEAt;xjd
z&}#ndpZ1flbbKp$((zp-?rPlOXZLcmpT|qR-I{x%;fX`^lZPh-e|hX(wYPoijTQgw
z`&`|hhQ@ckIkJgA@okB#P57=Jl|xA#7wV@rU+Jv6x+!w|y4<tpZNGh1-nl0_`q-_D
z+f3I;eC<7ZK5q3{<z2Ct-gWi61op}GKXzQu=H}+2$l(M!lLt&Bt#H*_8M48y{puCr
zWla0**g<Px)`v<=oR(q~vSHJfRWn87&aYqo_~ReYL6XNWzx)C}$VZ^P{_<6xSyN8N
zJHPtzQP9rLj{WeWKPg6%9-AcQ`*@4i@~?jR_0{7v!;Pz2i>8?ETJoyxYR;+KT1#!$
zZ}Xa^vO#>y!_@E%-}cTs?{apww3MrSsOq2g0PU=8xw$!;SgW<z%jGlghrj;O8*)|1
zd)ujHF|`pcZ|<1}hj{AU)|y%POpves>?Pg3Ig50+MXOxg#5Vop)@_mMk+Rnsw%rc$
zo58@qAnNcm+KXN5_O&Jz6$TZREgTajT~KoJ1Whw-V0Y>BV%NIWV5L$NU>SCW@uKpy
zMle>7|LekhwQ}XAZ8@`?|IUBLy1#7IZzGq^N%qr=e0tP8@8|FPHB(5<<7>&xdI_Jo
z_x|4Zf4FzmK2D|2yOiu?4Fv_QAFo<(n_Yc(W1BHg+A)bUhBnj7U0mGf-V0dN>v73v
zvd1N#sR(9Izf#BI6Wv=|D#fSDxs-1cb@|HGucW`I#7SeSvZs-=$0eUBJ%==Uojr|Q
z11|aWD4$sB@k!~G%SA5bfci^56GKcUt11O@DF;B<>R*4A7Zf(|%y+;1{Q2n<lT<p(
zi##T&bXGsFRPhvY*}YT6Q^>u1UaXSGWaV>DCh9MbnW^6AIbmMu1t0HSF9TO(s(GxE
z@|>jNmIz}{&gtk<(wL<f=;Ad|s%=tA=b|Mum0a8wigit@Pw8B=vv|@f+wXfjIy&aw
z>FDTquB4<?eWzpYooTB)C#kLSoTL(%B?e(mWRTtQs4_0Da`);@S9b5(t+VOv?!34A
z{!efF_V;U_)V6}l)7IP7{NFzR?tex9U9+`~HuCze+-jC9(YDfT*`>3*Zo+>$C*{l*
zOE_Yja$_TdbHl%S`J?sIf5yLjySVyZSBy^Z-wMU7*w@#q?ycRve%@Z$HM_0LHbs_|
zy)-X7HtF=XypKy%ZtS@ox6R#C<j;d`S7+b1lehh}V)yg2{l4#$k1s=3`E2qb&&%6%
zxADHOx}C68^k8vFXuO5&*0k^E+t1gmuKH%1QCHo3ul{S`mCe=9#Lusiw=gK<FMMCQ
z@ca78h2L&%Kd-wfGTLNX?B?j2&)2>%<`xtbuur?9WqEzB#fp&P^;RV^GK>!j3fP-L
z$7gPPdpm(UyE%8;?dY;evq5)r=H6b+Jm<M|?zY?8^X~2jiGUaz_=@K+Jhwamq3-|e
zs^>asH0x{)&yN$j$Clk;U}#wU`OgssP6h^sV1~aB?9^|CuyS!}Okj{=YMYfR)DW;L
z<1$0`t6j!BSXr91Sc@)rb*);ab>-&T8LJo=Oyw(B0x~WxIKj&%ut17|DY$Btrki6^
z#s$w;la{o#u`tY<;^O7})qz1%qa$eXDJc{4b6e|cZh<z82K(<@akb<m)0q=eDN~k%
zau*mMV7mc6)=}CqcUP;4k#v?0+l3sq3xQk2ZU?1I&RwvTZ9~-6B(60Px1zlk-8Ru(
zxG~2``0ts_-eg0~;9qHJNvr(d=Wgn>e{^a^RdU+xh${}41<ZPvikYs?j()SPH)_@A
zdPc^ityw==b8Z`Fiyyl=Kl}Hgx7>HRO$C2Doe7$6b|vDf$Uf6;7mc>YCnkpP&`lBF
zskT+AdfK6^gU;7xOKWCab>ID*XTQ(Zoc?e6mu$IjM_s7Sj)<QXm$udBvWbncp?j}V
z{FWU4T;<y#R!NM%PHt5`Ep8gR*i+{6*_z`y+r#VYD+<?Kmz*1;w{zunH>2a+O;2Mk
z)ahS*wsLE<u9TsEkFnN1Q^|!jS;pVFzDKU8o|Y1~*(go*<&0w{-8UQbj|J^B)%tNs
ze{%2{(aB!Z*T~y^f8K6-r*iqe_4U=CAAK~+^NY&+dFtUZlZP|Ti|^X|`M&qoq=IMb
zbd7gxIN8@eYhJz8CqJ!2MawN^`~>f6_npjGdj8aWe}iqk%ffUOzh#=7iuVnc>VCQ6
z*rXp>hW*!8{9Nth`EhE`%9<^gLymdW7%p2jOU=mp!Lf+cRVi14pG`?Qwd7~=)Bb68
z5kC{}?4Dlo%_x22!Ivr9m!8-=&Hc&YOB-$VqWWB4&2nFPR!{Mz(VlwImXCZ<t0&D9
zIVl%vdCE$3lEuoxmPg)O#bj3Xa_#7{Owj%k{<Lz|=~OeFW4G1{*IkjCG1L65;L0T@
zr@s}Q9CC5_o28Qj7t7C5o2ISp|3E|iYHsMJoSfBJYbPfshccb=4dj+Mb8=;8=VY}s
z(N$A@5@(#8a^z6Tp_7pzJV|FZCDbRS1`8Y&?2&BqnJlcdk!NMZsZA*>C(RT|4Su!J
zEu2roVx3G-OgNvGyXfIg;n}*|qT94K9=~*G$2qZ}!Z|ui3+L#p+VOa1PHIf8-o$R!
zZr1LXiAjf!e%YAxPy8zXs*^!SCBnj#W-NYH=(J<a3PX3{7Oh7cR(4s;@d|mgNlfEW
zeSuO;TXJUPHe+e8+j+s0JXanq6y`Y`937?>nVEGZE$ifz*-{bH!UBF57<MOJlje@N
zv8L8Anav>iWt+kA%M!n;#W!cJnK9ElP|VkD{_;m<uaZ)ALwe@!STtvjmET<-pQS6s
z{O+hMSLd6&Jy=*Xt6M!UVCu;oCG+k@8n{jBRjv1A$>d#@xXka)B%P8O5Ax1AJu6C@
zb6qWTndjG|Gtwl#_8hBCtF4sN&2$S|YjnlO<+7KLuu^72R=2iMRHfnCwX0K8PMY=h
zx*A<S{3_k*#x0|i*>1<W(n2;py>iY*<C=k+wuG{@ROjY7+_Appk2BI%rn<|PUJFjj
zSuI=oQCYseYj>_seDbG|+s59GxoNYacxM`{3!PMC>Q+}i-8k*}y=Zg$;^J?=_2;WA
z9+~5JdhgULZ%^rY_lZ2&@hI}1bZN@Ybvj{D^SzljzdkPXEp~e1(!^;}VX8O3UKjZk
zS-kDkjT6_cci*^ibKTb`uVlJ6_OCCE`Mha|zp_5pFLqzitI_ph(@*?X-Ig}3>(<GJ
z2bW~RJm*)R%RRs6&hLF@vofpST|8o`-FdUT#A?n?cj4*Ev3Fvg%lb%~il0hVZ~a)Y
zlYO(K)m$}YftNLr;+<QL%b9M;%_+RQTl-{Jsd%!)r>XZl)qN&DT6S{r)tazdQ5p{p
z>{t`_eRs{h(<zso&zsG5=cq4;nI63D^`^%?Z+BXm3ST<1Ui9heOQ&RJoIJ5t;H}rY
zq?60D+|##kFPm7g=%z_&+<`e#t1Q;6ulf|0lyb4C;&SFp3&nNG(JQaTF0s*BHFwf$
z)`)p5Hk#r*F0UrtG}#m69oiT^@m$yDkPW9ME<LFgyF&Falhv9vU9lpe2fG%nsY(3j
z7;hW>)Rb{?7N^O{Xx}KatfiAo_D`DKx;f41$fk;R?wOliHtL3d<P$ee^GcZ&e=<fd
z?X1he#6N+jilZZzu8OD&{PX<HY28^fHbzY|IOe80WtR6Zk2w?VPyYgqt>4@*-7$qx
zo~=_!NlEo5=x$8$`gOY{PJ%WS8TKTXUQd<)@5O}@ZU#3uryW|`8XX#Tm2dxNgUsbW
zuD$x#U-rCe*L0`TCa;rYE!Xb2Yjrz3{`tOwm)qA>Ut3$6ul?ZNo$FDK9Y^=s-rjjR
zU*_uFXZI{hZY&Jjx;Dyfefhk5?`_wYm*?HRo@m&yy?A&1^2)oH_dI*{^qj?1IWPMa
z%YU$`@_4lw_AoGUN-<nuU|@hPLCoE@_1n6ASFhjS`@TT;Ttd{-Gn~y{ulC=2wd&Qo
zr`Ka+WA(z6Ll>=Cxhg=CM`LYj#-_l)PWO}zYyE<o6;~c?Gl)p;_RhH4x$KtV;S__3
zd@Aii>p~_yuJ`40j#(D2^oV6gpzV|sFTw>Q)s{_pYSqp><*?$)i-|pAQjad(%)3=+
zneyaSU#D<u(3_^0npcG0CA}#u?v2!IU3uxfvfA{llAv`*Y@MSjJx#i~5A6ur7&T+z
zseXY^MZDSzi)Lg-&Eq;OHJRsOX4>vTi@D85Sf8{$RjhQ1;|#CwTC(R%ob<H9@Cm2q
zuGx7xOucDV=%M$Mj-Fe(bn?MUk2tRSyZk}3l&|!vY%<XL8a0dMq4yTsZ%LbE=1xi4
z!}ZkQXjYZhVM#UVj!O@0gVv|Iub957>s!aXmerS*RN6kBqwjS+=k46kHxfmA)_mIZ
zzBx?v#bl=)tKRILR;?5JQEXbhzw2A4FX2Dj53QN_VcHZs!4}O=Dsz@tX+E<3>8^Ta
zt5oRKhr*&SLQf@jUHPH4;h1O3kBOg_{8X$7<?mW*=cVz3GyJH+{}by(FMX`q8*<{O
z-S)_*?h}ulm$TYCX|I`b$Cs+A(yG;uG_y26&N7=)rhe?ikNLu@FX;vB)_yB@vEy64
zHfOw+f%Bs+3zlEpkQ1#tJ9q0kleSe#+_~HCZJ2RMO6fv$c7AVk{#4i2-c@#@U)EWz
zzS8+YYhQ;Q^99?G@LMZt9KD}-xgSuC4{83?(6#?4qi9BG&?XjVEky~}(1f5K6=zMS
zLoNrj6?B4(rY0@(xU^R5O5-GFrCvuP%}L8b>vdXF#e}YgHZCz~>xgK&;<}PsQ>Qbl
zb<(m`s~K1FdSr<lnC7x(#Tt%N3n#j@N_cIUn$WqTvoTm}%7xIzFwQU`sV;4$t_zwe
zA{$gAgx0L|I5nk5%UNrQ{govF|4#;Q)O2_w+O<+~;shRMRi&`0tJpNMxTd)U=`@`P
z+GMn3i)Q^&r%PLuE=+5R>RIKpC^1-BYqG}NhE=k>DnTYoUQJnDwl?e5y8V|_lmfbx
z85o)zW-u@{a5d^OIZRNwomQyoRWO$+c#2o>_BDY<M}<ziN-Wyy$EbOz#LIh1qn~gq
zS2(9&*)&h5r%I|Ffdw;!+_{=0ggRHPat>8k{ae6iX`oX553LEir*zr}MfNV1c57;O
zGwaEf+;;4CWR_3FvPd<ZU>!A`mD57IxlU^xU1h?wWva&Cr9~@@XN9G#U1iL=#pl#)
zm$OmFdb7+{Tr=%Wj<^;wtHu4zx=VT&9?jhlwn;n6>y~fR#f*TzlMnfGeT?N=?(wp;
zJ}dOn%j@4Jo($JyerPW3otdlKoO0!=%8ziiPCLb;9o62`wDzYKD_xR1qVJNcyL5|L
zPu7Aj;k-(Fo2QA!UD?^PRq?6dbk3zL^7URj0^Nm{Ze`k_8X4sD&uPEZswong8e)?o
z12j@Zf67k<AG;Ob{b}E|fKxhMJ*u59Qr@Brncg2KYr6)2{P73W2R{8YBBCu~jcBB1
z3(uM$txGeaIR!4nPhEdAEMx6T<<B7Sv1-+6(N3SFHJ($IQjC`PtoRe(C;VAau0Fmk
zO51JKkr_wR!bA>+oJe8qwAJ^I6|@hPo7fXMEhJUz(x$0d{N9(ZC$&H7_m((wQc_uT
zl7Zax<?E)%w}!Vqe7ux>gICvn=^yvI?7mOfyVrfaqCfLJaqDvyXV1OeJ@@~sP`&n_
zO7&B^-v4wJ3EJv$aZy*;%2mBm%4yq9Eb3TVpEcDtEHwM|zS}?d8-9Iz-0te_o6`?)
zElAusoy~`X(_2?<1zW<RmIYdk&G+MC-`*>qc00G~*_q7aNBzp)R<C~i=ska}=I!k2
z)%UCOK3Bi!6jJe+sN^tF!FR*Ww#&I06O~*PITSf2D!FumM;I74+~8fvxp9l4nOUb0
z%k9Js_1AK8H{8f!yUp8nAhQm#PFCLFofP{e=Ism&3L1a@8!|9CFffQ5aNHpu5Wv5H
zfq~Uy0sA!v1_q6eDOx2B;!NCIR=6y2Rb&!n&=BI@?47_iiDA($#}8b*QYMm&3#JBt
z`5ziEL$JY7^T|>zBZkXv&AA~fq<9$^O*I0Q+Ugq^f&zsyL(Ye!E%UX>tyq@nb5?Wa
zQe%_l`__3Hm`r8{6RC3;7#JKP7__(<SRE4>R_HK@img4iRqEQB4L1|lCM?iqWn9%D
zlDVzpcGm6ODLJmrYPr)y9oIHzaWP#xwL&}X%q26ogWFE+-^Sqnea2<YZI>q4PY&G@
zwElNmed;o4PW2zR(?a9b4rkm<N{-x|)@|U`&XaRHcO}Dr!L5@s)vjk4N%dxj-kWec
zIcmG_Y%??YFZ}(73rzIZq&h!MJ1Mz>e@)w!Sw}g4=B}Kf7BxNF$B=1%DfhQ&%ToFt
z>j+12eVv*tviO=A+XZ8zODpC*bv|6(Kg(j%qig4O&8@9}^q{a(>e*K7l}9#RTKmO6
zpsM+HPTHc6D`%}=&Gm8R4E@m7waTY98%=+A*2uAL<Cben<2D>ttU8t0wQkL-X*pY(
zVpAhh<ade|W<K`sS-o0wx_95&Ut4^#m##EkwWDOCAGfB(;-2O&vHR23m`drK(diAT
z%33X9duhhC4YgVA-Cp(aJ%%g!-PDe4n)otVEbw<)T2jp=-K5h&B0sjO{MaP=VS|0a
zlrJ0pRDAvT+<ex~tUXunv{miZ4}X39bn(NANPcnNn8@^L>kTb7oDO+X^jva!$Jg$w
z*SCF%bz8Mt-RNOz-wmG#qc?IU>$z7SnWL<=&gof<o1UuGkwRIO1Ag{SZ^HI#rljPb
zS#)x3O6rRJV!^sUyG)XeQafuReKvJplUC~$tlD67WcAg_Zc}a<99ewnv~D)H+p3vK
z!51!0?G|gDI92`a?6h3Bw3+^Qru3g#{n_#7l>J82pG_}c$)ZyK`_@{W=)l?Um=k{;
zG~>Uv;)Z?Hq#N;Trf!U1;p%^K!-3O@jT;z$<YY$NxUjTNYQ{<NhtrI>qD-diMr}##
zh)rz^GnPy_DfDs5rbx|)&1y;&2YXiYFnyfZljdwJnQ<{Re67-vOZ{$~uTG_$4EflW
zlFYL~;^gFj$!A^CR+#Dpmeik|tkt){aK+4?l+$XyO6#_Cu1pO)EI8RES<N?OovF%|
zjb3SLODFWqNt_uu<;-fMHH()8_N`NVEP8plVCkfimq)`RgV&sS*;Sq!dU)x@&NgkH
zF#f}8hKAR9lH2r;8S^nEatLqNzHzXTiABMQ<8Mrz|Ct3>Hf~j2nG$v=Vn%aTy^l|*
z?~)@YHCG%?+?bQIR`^rqGOtvruA6G{-d!^O!lFmjPT9@i*{I!pT(Ho_FsAEP%ZH;z
zC&k74v>sI??Fc)u`Y^XnYf<L*K0jZR4-aFwKAfF(=A=zUI`cBkV>Xe&yQ5aUb`P6)
zS+lfzweT{}qn#Fy&KUF9ZG2`fQ+u}0xZObF*T+}3I&PCr^lVHzaw&>iHz0MgXTqif
zk<Q9GlRaPE+;p?$<fJV+8mH6!EDVi`{!DjV%_0{s7Mm)UmUDC4X|rr&!>Ol_ZJaOq
z>g%+W3!B`%kGx(w(;(7sdhmJE&1$MwFPq3aJ%4`d*0$Ns$z414tt)yyH?}-Fx{rUE
zyJTs?%c-S{R|hW(J=*#%Y)$ulo1E)=e_yZsK7HqE7R~yj)5SS&T|KJT-5Wn;{n8};
z-0vSZXXF-^rcPr|{+O+2@w_^9-S<4J7k?yny>5M&-j*zQ=#uRf(}vIIP2b1QdCa}^
zVPUMvQ){n_7T(u$&1T1NPqw*o*)Mp@!)wb!ZD)4v42_-Vy!?jVWs$ht&+kr|73r;s
z%+i~_S|`Tx+?P$y`ReWDB+jH%^aj2YT`Tx}-j1WGQxB$CY<gs?S<rfI>at~XgUXf8
zx}WMS&6s@b-p`QS17)+8Ez|f`X|`t5X)!(Cd&=Tj`YDntEpK`Is%BL!s$h9^Y4PIx
zQ1_i&yR}12)^crUvYx1|<?-kg_ilDCk9GRDxW9+KUF$kkVs_A9ZN7k%`lBo3H)T9k
z_BJ`}?K5@xTX%L%Nux_ff0rISIBin0*u?2?_4Gm`vkawU&9298U%G*TS#w#=wF5`H
zbs{A;XBhFarDjFO-w}Bb{MUXTXhjZcucIdc+8vQNX5a?9NP<ln+B4xv7Ots3a-yT7
zqoY^c+#I@GR!J`}544^Zgk$c2#w|e#I(F{d30qhz8W?bE;a2CYcK1Kh*^x8s?!U8^
znbuR3Zt*(dxQ&WU{j|4QrnhufbX=OXW7}JsvhRKR70f%1mv3QqG`gVA`Rw^jJ)x*)
zHy%0fx_FhbJ|Og{W2j?*^08e{vIMo(HKaX>Y>k?^Q@2kyN_|H_fS}s3!=}C+H*Tbv
znMwBcwr$+FaRZ!_oSZlV&Z)Hj?YlT<>8kic^=`8=7rWi4pS1j^R()7p?NO#ZcfyNS
zAKK1pdYtjUM<930N~K+4y;4cD8rIYcbIe?^VAI^*sCDj^GNy(T3r+HZGjq3Hwa``)
zdJr>ZokO2ws?2kXhpsXq^QLy~4%avvWm3Fy@!qA!eF}@Vv}-Obi_$%GBX`$M$<$kZ
zj_jJASN%@4dj?*e=I-_Auw-GX?Dpz&yMo+<Y?n@3-m->G__~(qYPDcx(L$S<PcFXq
zs$VB@wO?j+Sa{Ey>3(x!jHZ?xd~$JTa8|ybxZ_i<bsc3({W&UK`LzNoBXdqvtcm0o
zOb$;^SBr}5JLBH-eDAqmUtRWi*1uW4AZ2~1A)7L5b*~Q3G`6J~eW9`bogb}AO=^CK
z7Ho<#$$5F|M~$V?VWVA{FWq@%`z*C8ULKKM8(Lo#)!#XFhuZ_&CR?w#R$Gp}T6+VX
zZ)#L}Up+2uu`O$TNV-p-;)}4TquuT4%hf|uOIJ_$aw+^^pY{97`?l3gU;1B$A6XV^
zr*SZzv1#>_Ek+S-s$Cm;Chc&&80Ww8tHnGyU-`O=+HFQA(-sGAUM^*7Q)@TJYPI&-
z7}v*k9ECdd)8p1mk6r2~uPozGa^TyRc-56#)_2TTny=~nQ0pg`ykPjDE_o&Azo8Z{
z_UL>5uyeV2YWib?yM?9Q%OgGpPAxk7@Zc-gN2hg@Ok%{BzWQ3xJ}sr})^XOFRR=$m
z{P_MvE%b-qV#S9hi+)Hgs=cE4W7}%yY_(oBtt+$GR+<Jj8L8G629=sAeN{hcxBO8}
z`wiEuTRB(LPWG%-n{-hkO!QO1)wD^cY8St$wVSuJ>eemUoaC1ILhOgrq%uvGX|Jfb
zx!164rB051Yk@{(z$52Pi@rGh<XC?~>xag|A4}FRS+UgrrIuzelZeqomkh2=Ok1?X
zrmQsea%<uhbq-i{rE@`#X#GS3AK_5bU=Lp}AHfy_ZB<>bjAc`@+FVlHLQbt!iEz5o
z9V(_3rjX^VVzMGL;D{m5gbl7!Rtv3V*|K7*h^dHSXxADM6OD}47M(?HfzC>6y0$27
zQQGLr6X@(1*0e@rVXH{|TaK>%U-=esO}!#EMR3!#j!P!1R?UjyIO(=R<79oS+e#@e
zH#gC+MQfFGX1H7pTp{Mo=^JRE=Cf4N<4r^0rA!CY;6+PgCb0AWG`Z~7yIsjCOFT;}
zTwzh+9ka8I+X4)t*cKa|-E8Q`8Je`*L*!||#6!!O0t;O=FD+B$da^|8!YaLhjb41J
zDl<c!W@s#&G9~<rS6IjtjT#n>dZC-SX4fW1^(JKtN6ZSiwKlhO+qMTc%y^q}uBG{$
z)>)Hs%;#8yk!P0H;-AX1lXKS`OPz6M<7Cc+XG=HadMDhPc5qWPx8_9dpIYy3+|HIX
zoGi4x;HH^$baZ6cO4UOa`zN@6D7D%#Pn+?Bde(du^+|@)?KiQA*1uZ5QuC49hHW8L
zD+{MxyJjMMWzK;;tuagECM{oNx}Z|&S#E9)*IN;b&=QRj%?(SBidb~*<X98vb&6yC
z74es$3ml^&v?jZCO<b%PbS0zdLayk-kcpF4e*J3Kzv`D=|LRwN+NR736ZF>R&~|<u
zup>T9nI~%1(T&bpCsn(yh)S%j*Ah9^H`8#kk?Pkkzkb!$abH;zwP8(<>WZzdVM~`P
zT(IYvajGsWT4}ET!O5YMIZkac@{vrOsxwn9GHgYn%EgEkrh%_6UHUG%b%w}~_5CO0
zInHcVc9fddWD<Vx<4NY_OCv5NOQxk6Y}hi5Iq1?f*Q)j5s^1LSZ*{(WJul;?Y87L>
zYrXr=fA=33&v{(9J?-WyiNa$yv%0dfmc2hvcqiQR-=X<$L>`L&S`(bPB`rzfR<7iX
zHnZ7oX?%>V4=V%(9@sa3t-HVP<c9U%U*|`=Z2t2xH#9V4bM<q*+iHjQecirxQRL5~
zTSG&G&c1Khb|X6H+hwiwd(&=Q-?nwh%xRVT3Zquluey`FYSpS~`8DQyuFft4?`-2#
zVeHI`lwx2=Tqecl)&QC#VN7daOlz3rz^TFjA)*-4)Xp$4|2Yb}BP_M+D60ooS~KL1
zuzyJmEDa0{nhjMS?ChEy7}%zWs4$pZ2+&|<T4=z^z<&3jQ=`KIrWFi9>kdq--!y^2
zP-qqVJ@2$GUU1jw$~Uhm%nl4$)mKG8(>wklQ&yNT3$R>SGO7B?iVS9jpg@6DGrqd1
z`P$9SeyMX)b++mH*HY`ir+miVT6Dbt<Xi^ud=5h{*zF7#!gf2&65Ei&b|Hr~M0Bg?
zq^+zgGDFRBl~Zz-)az~w++w!WRsLGCPnxL6zcXi6dH%T_>hgbEsPoMnX||)QvvXJH
zZVvGLld$TupzZBk_0wtBZ~i^-g1<moBYqQa*VNAf*F@P*=LQ^pA*1r0ag*0~g&Qku
zkC?U!zTLJWvD3E3UgF?i_E+s&-!YqAsamx}yHadVcif4!Ket^K()!q1|Cs-la@3;s
zh`Mb@B@&iPeE9i$opE;Wu7Z-%!xHEC*hTB)mz0NYOq~{Q%9gpsE=h9grk@>YVV`>^
zeKupCxp8wsW!lCW_Ni{0I`$^b+Z4V`e(e@DDUXWE=jZRu3yYInv&VF;joJ3*^EMyK
zX6!OtGgmTu;dR+?kwXtsr!%e-T@+v6{HgD0PGrjEcOJ)9N7Y{C$;kHK;bydT`W<D-
zsC$ni_zTwrzB6q*wlVllGH=3-YZ~8@B{G|J#9y0nwk^_cZ9jDM!<Kzws~=|V7n|2D
zzUWGoZt%s7y<+`Lhd$`EH>UbC9la2-+%aqQf-MEyLIoUu#9zEtoUvIftgUpmXVfgy
z$ogyBxUO7Hoc`KO<LJV+_%*izyR~^C6i@w?ruHqj%*?{B=4xl$xEbwsS!8L#nkC-6
z5sA|xXU<x3iZgN5VYZ0PydsA@4u>4()(Kl`;+5+(BWsO;(G^q86~VlLZ7rvkH5z&C
zJ#@jByJ&4dOvr;rOJzbHJQCTl^57xYBHwNGw|s8r@rrD%4SBJ0s-fakgOF1*v{L<7
z%~YIfuySHn>%!{R6;WafGvXd*M2Vk>dr`Y`Ro77yohYxZ;ulYJ9y%EuSWqZ3M>jO8
zyLr-tf{nbc2M;VM3QNx1Vl3@@ur*9ZPiWS)8wtxc-E7m^x;UFhIbutaVbc0d4<rnt
z4rV4~Gu2-@xJI=3MZ$&zg9L+G9v%q^yEYzq=L_E?v!sHyBptuHxI5s)vYx=?Zg;VT
ztHOF+A|72lx*}<<q-w;YOT{_2a|9!^v)5j|y5Z~^pRLKFp9&?DZfrT7lKL^}v{<}Y
zWKEnt&yh`?YqENTjodm{89PO_MNaMK$=a-PG0gb!q{k}tM<XXB_j=DTTdikXI&VYa
zqNH^@R?k|ybWW+Z{swz7dGC*ETenH5ZMxZ}x>m|mFHH2%!K_^$PaX?PO_#efb6Mea
z$>UMKYz=Fco_JFz)9dZFbZK{PRx<y#sg=*~`<$J5?r-Vb_t!0Ls-DWq$_9G}N6m_u
z?jKt)kGCv#+Uj#!<#+1!-FB?|t$Ec(;=}S=;c1GOj_KHmUou_0;lQ=1h*b|4tqTs?
z^6les$vM@9>*8~2Oxv5euM}C!^ttu&7+lq#7Vv)d^KEm=pPtLHswj}%+U_3O+BH{B
z!e4Wp@=1S#Snh*sE4|8}s=PTgPp~JVDxN#);!<~Q$AS%8-`<Y;nSF7?wR%|{@rfti
zWLgA#yVP%U`*PuiGdoP#brVliX;!p8J9XJcvGS{{zZmnC$r2l0R*TG8qwz55+p7;V
zn{_OFxZRZx37>Yg*`2i6#b^)LJTKLgQ^h@fk`ABH$~wf)J>4^#*^TMq$&gr1@5x%h
zOS^@ZCr!0T;##dgk$*zfj9I6RO|JPw@UmR<Rk~<We`&d5;nHQBg0;5BD;9}MMP>`7
zhUrh($=$27b;%6F8rKssnW<}oQnG3mJ<&7SbZw=HskP@{|A##rj<!x*=4&*q>&hDK
z-x_`a^I!f2?L6QBO^7J4b}6ZTJ39TLDvQ)~1!h*R>78F$c|bSRvD9De-MR_1a}Lyb
zNVWPu$=SGm&fD1U-}7wOU9MgpI{WNfU%BOe*YDr6-OX^jeBPa!S3kE#g?^~sU2vW4
z*;`+sns;I`Z;$WV@;&d}-Qz{&qLU_jeLnj-?(OZ}W$!-UaxghQuga|Q=DEA~s(p(k
zjy~5bdahSw*mU$<?42Uhvv=>*KRp)%Mj4AG77KPP>e5)$rEx?`W5J5WY{v{Dj))nu
z_BgJe8vpL*Vz-V{SCzVWwL?rIy0t@pzm3ljVp))|Z)<$i`k8ySr!4J@nl#O&t3Wkk
z@z+p}Sskl_yA^w#L$*xtR=6-VF=Zv2KuH*P%+AQ*7~iOrwGlfqZf-Nk=B+R44$yco
z;UT-$iXAa};@nLSMZ+264jsJ^vodPx%;0{-B8y|K^PDA9)<#)m+}w4YU83l%cxuRw
zE^CKf3U32qWo0Z1tladbd$(RJ)sPLSS~>f`TBU;zcB)4DT$y@cuhZ9~DRG{KJuBCX
zm}V~8ntE`tc}$F~>r<gULX}E3O>r#sa;n@1A0C&{=j@wnQ8G^`$s$g?_0Y=-eJ=J+
z`QIU5CVS0mT`H!_wca~Q(<0z)@clxcmFG^b*y}YXIWYZ-*RiO@l7}vyh`Y3Wg<Qv8
zu6c*l7c}2$tVmzS?``$EZ~9Whf)5`aUOu!})li+|WmVjC?xhc_^s`od@&By(L1$GB
zw`;wB(?zbDrsW)dm*l*vKP;EIv5fn?$5!zxOCC#g+g%jxHCUtlVExqKhngQnYFOnp
zMQWJ%Ck5573}?Og@Z}4Mee$st)0+<;?{~FjU-;t7mmgm98TK*#5I<O>-^$~^)GBPL
z4ck(G$EM|nPC3ob+?cb?cX8I#;D%diH`8u<`JK3JRPXZ1t2%I#{?usimwr}zy=q+b
zSB2C}snYlsWOt(d#1uP`B{huf7lY~?R(k(Au+m$FYc<1?os(39o4VX4ab`^6by)1+
z<}f43(BsI;P9J916iK!vVL}ouCl<48m>ej{tg<!a$gIE)L$)AahYb^#xUnXRh5C3U
z_-GvBQ8>!&s8cU$5OTn$%TVLe#3mkrM9zi6Og&siOH4Wv92?mL-IfG)1zglfP&nY&
z6=dk;#>mFV{%grf_CG627O=dUni%SED8o5mhNiINs=y_>F5ChqgRZPxpxTkrbwzBI
z>J)>(2@x$<wOxFat~$0P1|3@VMr74oH6^93+EW(ladbTWd7HC-f*0e2-PyUht5@x1
zRA=Sd@p5xoa@v{H&Dm+!g&GU2L|sp6s57?;$_NQBT+~?Lsk&54k8PEzjK~yIC9VSk
zNkZ=byn?O>Db-9`#s0y~IXNL9uy>h?nHejq#1_M#E88xIO%<GK;$x8N>)93-ni3gh
zqSMVN?9ny<V4<L2%xbmzg==|c37ailcH1~BDm##6nwQz6lWxnh(m*JgDQZ#ZAH7AB
z7lv2oT*}=T*mZJkS5KI4POg}))Z)Ovo@CvSN$MZ=INET1RL@#js(4{n|HEfNH*=P5
zOOey6kkgkxAGP!mzozJisEcc*Kxn~L*B3kVif(|enq0efjiGq`%934{N?+#2TD<Gd
zTK-{PoXz_g;Vp8S>I<{owq(0)Nje&QVMol<ts8FS80(yl4EmzCZk<AvdfuJ6S>B8I
zrs%VpE{-x?93@(zdGuU#bTn_<7Vd+7cP&+R2oyM#c&?SYsCqT<bWC=(VNTZ^78yZz
z5x2A3m?AjC7IBrdhlRMTt=CoQN_1N?No<j9=Z)A_2)b3hI^fi_K(*Ekk2cYz9@9GO
zBvO3?<~M(+<3ISrp8fIDW|d^s6juXN$E-w=H7mOUBVBLA7Gx%^IbdyVZEdxmKg4iq
zq{s||(4__|G9p9WI?Kefc0bNeoW;8^y#K~ko(+;(QL96xGIiXT>N6r#Q<krq*S>nG
z^5@T=r|_@jk<i&>vN|-_D=XxZ|El@UuU>x7;rR9IgnXz$!fBneqLViIXbaVb{E`p9
ze!r|s-c$W3_)40p5W9m~%D?Yl{Ac$3$Lrh;KXyf*HC?prHgCzMb1`=}t!_v?d*iHV
zZqI}Z3=9E^8643W0St_yVfCw888jF(z$XK(TGhp<nHd_|(Qq|1wIKCC>jKrN1yi${
z!tQ?xn!fjP=Ef~o>NlzX4p@B7Q{86yoG(AOUumq}$!Dm!t7N<9rkBSuwmo8fJ>jv?
z?B(7iv-RerT$0S$c6-r<S4AqtRcBsZ&3l(Ir{LM;T&I{7!t<YLXsevcw*6MGVR688
z!RZ19Ca(VTpFyXFFfjTszn-r@t0C$n0|VDKhAJ-23lp@ahBL-EekpGd<O*Q=+QhPG
zrK(ng3c~^hA=Usk_C^PW3q~oNyq=*_k|vig^r(i~e_yrAgvVEsnbS68*|G(foz+)v
zWy%UNnHt!Vzz`Iu))jJWfl21K+u8N+*KEzNI%Re{hJk@G>zTw_w}#t}TenR0-8R8&
zRgQ`ocY;>@onuK$<R3P%e{GO|zcqL5%M~|Qc{FRfY28-&H!Ek+>NDFqVsGcBalf4%
zHT|nv=R3~dT-K{{IpcM=M0Veb=%2xUR-rs_1AEjqx2?gu-$nghb8G*`AMzshsb_63
zzOE0|{<iq6zR|h|p}($flFM3Wq;5X@nf2^-|318y-n?#|MA6QbKmI-ojx?D5M&{^u
z;n&<R7u6h8f30>k?qPM~>wu3F<0Yz}pRe(sQ~rJ5uaAAXeQ)<vewMfX{O~rPaq6|a
zdx?+NYj?Brrfcu8EREEj-(I(J&5ZTCa^2r-Tl_7@e{+56|6Xa=Z#m0Pi>=;c)*ba;
z$aK-|@*|tWwu*jT6qb0rKep!Q=UJa^&d+=ozJ2xN>Y}}=ufx~W-Pg~Fk=wak`Eu~>
z;A?yOr-?H^JhP5(mfp2E)z_hx{K2zUcU6ZKc^_jvDaU%Ias8n`ACBCP>h=CC+41MH
ziTtdz(4T8A?R#ygp<cgnYesVJ;;akDZiy^Snd#MY=FDQH#fCFZ8MUTGP79pWmN+9-
zB5=kGpH(yF%`ogbrr8tP6WZ@1ap)MEf#J(;3BzW&8Oc0V$@2YAUGz6>)Jpc*bmq*-
z1<OoQyA6)6n%b+gF*1r-N;1W0(=wCQ!lGH)uS`}>Jlx`^+%CeW+%6bg-|_II($lq)
z)A@pWE%r?lJUX3QX~(9ADe7V|I#Vrn7H*rlEoHg*rI!*LA~r<E2Xn7^l(OUDS+mo9
zc0F?no|zuM_>F%X(~+#Gzl9nPWeSy^o^DwucwESPx}KJWyIxSx<GzrcUQZ9W9xFU}
zrgxpCm%)Lprzf@R6&v(fo{rG&D_m2*>M@_e*&we;H+7e6JDEE>K48+tMLt(|TOLa>
z4NbRLQQU5ErfpKX#T3iKbJCoH(k+Ah@?@UzF5H}M>2aFvxyrL*cGEMnwGGZhHXCIA
z-0CKpbJ4(e#S9;{E2~wmU7eXG*=Dz~<&w`mbC!!f&n?uRMIPrlX3sgPbdIpa<DOrW
zm(>66T#|A5Mbz&i=joO+!u1Mg=|$|!cs1*3OKMBPzaNG?C6R)cByI^yd&WkWyBp8i
zW~mkzY4Q6xf8VZ+YuBV_9Jc%3ee8KoUUr}Gxp48`=eJuvukM$a=fA38by7y8RIS*)
zJI&KAXUS|SI=$5NwCL@?d%4r&V`SD@mzTWGNY0F|@7yNT=*7tqz&Fja`So$}vvW%h
zud-NEb>-7Ns{%iLlR}%^DV2J^*uA8MgAAprqP{&TIz4Td=DH{+o+T4`y*<>U5_lw%
zLe2K(>D^U%vR-Gp`0R(>vn?$GKdklMmJ@hu-5-^bCAr>=tHNT_Dn6~)@z`lkre2@n
zOu35NX@z0W-qzoa@Vuq3)7|xMu|(j5^<0ZvHEzsm&B=21;VSwxrR<X4#nZf5izAdi
zihR(DStPnuC(!7!K%aue)#A{p+1Xi&hF*&q^`A_7=>3yhFeT;uqk@%(uFgO8Ku>JV
zzi_TOKAV5+&^)-TUR}$N*Z8Nw{1Z940jt7a+H3xpzv8d^ExU^^>ut5Z%nte1JLRkU
zD%-#h^SR`?wyB5Ys%Nab7<cJgXWS*}fKQH_<hZQ-rYzp#bz^y>chR&(q6d_drn;$L
zTK&?fe@m)-#wojtQ)(A$eCt`%wSK}c=U2|JCj45-ziLUm!_-;<yGdQ^7q!?OSX$Q^
z_={tH*OK*DRaXDrzbx%++NO)sgw%wE!@ONnwnWW3`DcO!`_H`-rz=iolw?(LadFu{
zJ$o&Sa=l?s;LOcwXXorJ2;HzcYjRTX_8)9<l{+7vx_o@z>}}h_)!A0B+qI+FPw1@f
zwzgM$QzrTN#|Q7ZaVV&(lWoR^wPzKtY+sr2Iay_Gme9qsoot7*t~8fyxVd)gx;t;)
zy6H?5nQ?TI5*Tjmi8S{K^15o+<FwWHn9i&_$!b&A+^J7G*%N8lt!9||GVH$8eI|i6
z7KiVveyw`__-SLtf$dFc2D5UtLmy}DS-EMeBC`W{+=qdIfsNtT!RXxF)!JT7+MzCP
z*`~A3rfrV$xdvi{3A+V*drn&%9N4xvs&!&lmXWW|Vr7jhr^J-Gk_^?<G%js)I%E(W
z8sWL%P-}gcgvd!9Asxmg8XI#LZo6d~x+KZ8bFvgqTb60E;Dl?7!wih1uB7&aIY;#x
zu1qmqarwWMMw9)yB@5==GS%AZ;5u1hX4=x^ps)$L4p%O^Y*h=W4PCP1Ov2-!BQmOo
zvkgv!YzfU>aaD5d+T^q;u3d{YmWhNO*?44)OVXUs)tm`B^-3qFicUEaKRHxKtm)&!
zlgE++A8Q@t*IKu2?%LzxrZWmX{RE2|ce=~m>T%0Xd-izdInBU{;hcU>VIASZD*Bp+
z7Y!X7j~z{&s<SdtO)}KrXq{B(s!SiY6|u7GEhS53woVhDwpvr`6TjIW%XL|wBCqXw
zWx3|?D(<Cap*N;2-jZFvrL;K9MB-Xr;qd^!E4vlmaIaKWn7cOURitBuYCp@NHg>aM
zUzSrdLsOg1_`A8S*1E7Yf=wiL<%7@9X6?Lb^v%2HbkJ*URmF?t=}{X#h(<~?Ur<%E
zcsS9b#dONjYNl_~H|=d-5*B!9ul6nL*u_VSvy9ekeaPNevG9TVMCYT59rZR6`l3^8
zR2MD$pxWP&)GT_`<U$*du$29&QwJw|9bFQ2Kq4e|;hWg`H9Lz_`)ysPr^KX1hF{g>
z{SsT7er(OYRp+YT+sZw8r88&V@3QB%a^GCf+<5DHwai-Y@<MIZaFL2|ua_~}7hlG<
zn`sMg)mybIv{ZP5>;!Aku$3hzYIq&%KdjZP5jwPLFU!W45zO3wPA@9T@=Us_n=Urf
zXhU*H+N8Dx-n*rJ7sdHz=})ZM7N36ec=(a!D}!HfhArn`FSl~~^3;Qm*73>K{`?re
zYVFz$zms46`u*<kOYSLgwsXUeZ{Hy7oZzmw)$vk4YsvbqH+IdZ=3Ocke!)LQ^rO@I
z1i5qd+*gz0n!Vz>POW_5?V|OIDeJGB!&Uol9U<XAIzqxf26>6IEH%|-(b_OW%T4H%
zc9+Jg2c4Z<a{^tBTEcnQ6<M=1{lc23tTLG@W3*07TVamTj;V(1JUf=QJe={!UC2-~
zOEXcMGm4jO#l;98wW&*!+*Go>j`VOHSnHYPEwVAVUg3nn#Fk!$3p}1l-YzE2UQz)E
zm05a4qBJ&jrHY&iowAzAjirZiQ)r~tvPEi()R^3u+yYik(Mk|9;FP}^pkjYTdsU~v
zOJOCgSz=xl#x5x*nN@;LIz@^uIk_@wg7VarYAa3nJiRQ%MJ*j8=BRabBnxcNS#{#n
znq{u8Jzj}E^{d4+n?<xGRwXS9(+OsC)kzBGN}a56>ZF*VXQwd_Pt>Gio~D|O-A5Sq
zsGM4<nY7E}Ba4Jlk5*5h7>}z&r_~C_>%VTU-R!&V?Chi%&5$*+LN*K9*w}(}7!$Gt
zS538PnEHI}?5MM|BbVKlHrsZ)X^ISAOFyF+bI=K~(9niUOY4)oc4>HCc%V|Iuz{zi
zOHyM4uaHDY-_no@DX%Hz3p}oJB=BsR8n!aD!D!X8K;a2qB_<y13?6SiwM8^e1}3nr
z2t1_F&Y+U8Wc_y~pH`Ldn;emjqV+Ml3(hP{HP)QzbHVAV@~j(X+ZIc@8TF(}oHCqn
zBrMcrhpPWe<)vXvdP4Q{FUo2i3_PO$Vy?ERJIBB2-U0>n?LO)^i$cFl+0Plj;BVkp
z@Bb5T+D-T|@q_j&??=-wt-j@VNw%RzWuJ?km#okSuRUG*BEd(s9(XU*dKKz-QJ5))
zWpx)zrpD4=VnV9nkD&|2mbChxh@bMO|LBkX>JNWZ#V?eI>X<eyqW;ttpT;Fy7>%Ml
z7PGE)G+K4^r_bb%u|msIOt#Ki>$Y))!CFn@kf5X_k4+M%7He%PmE^xtGUd$bFr&!T
zqKQUJrFyh_wWT^vZ7tanzv7ixYSwL|sKcU@l2%+v5e`jum5kaIrGM~}v97Y1XNRdo
zbI`F#MyFR!`K#A+rp;i6ubXhaYj23LU$6Tsc3+ngF^3B+lRP=??CkEFt(<l>Yi4fL
zy3?Uqt6s4DKg6PV(C!20PnAiE3jSx9N)$Y5{>_i?-?;s1c-p(~{iXZ1$G%q<-C1$_
z)Nb?gJ=JT!?s{J-vDTpT;MRSiH+S!SS$*=&qu;yNzAnA{<XzbAq_3BY?^^G^emkc=
zw{Y7QChy#>Yqwq7c01~T+X3Y?mfQx`MinLxmI<5+LJleop5>4W*WOJ(S;y)Y1-fu8
zq^^EO1ET`y!ZoSC-)}ZB7%>PkF59|LsZ~QMn1Pk&z@k;FR)z$qgm`I)-A<c2(U+-}
zQ}_7+4F)MTpT;e{T5JwHjVs@W`UllBDEl&iHnlWlWLy^T^-@u3Yh1uIX@aK4Ww&1D
zuWNJn%@WEE$YEXVwsy^hZ8t@8x-%KKid|)zzv${(NB+I5R@CiUWS^UxbzduxEvQ4<
zZK>GWsP%8R-MT)5J2(1?h=zae=BR%f8PhA2->6hv6nwVg^evf|&w@5bg^xAN%j(%w
zzkJ@lH2DjER($9;yEHF%@|s<j*KS$<EWrBcJ<T7dmX!9NnXJP-^LF*NKew0j^}L*U
zxOr-wd`s!tY>n^HUeznN^p~2w*WSzbbwl~Kw4gs(nw3*NdwuLbBNnx!?A+P1oAWjs
zf81P_ymfk7nzi9vzHry>g=-2d)@j!9pOVdv%=DjGZyZu{bf)`RpR4kw#&Je+2J?*0
zi1(!VoU%zvHaI5!j9X__+%?-Z)lqxb#$A(dmebZ3ZSOkzG-40WZf)_@tld*vZ<v;7
zYhDTqy&zdIby5NAkMJkcb1sYS+bU+V<$jcy$(HkLgN`km`L#7!Y}URFYfOzUDJ|c)
zA!qH>4LNI<sXEtlB`PIL&NNC*O>9f!W&myK=$zVhSXk-M%4D(B$y%pQNop&tmN4d-
z;j_kb(ni;w)oLm!Jqwcjy#<aQZdxbK$5^nVK=IJSLle&~yX|{eG~)4<gN1W^CLSv^
z>h5`z>fL9#>{{sYm6z7c@R{K=Z<(5p&%9+m^E<!tuU1;dwphxuK8k<RL!pOD-I^yo
zbS$`}?Rc_4WSvydg`yZi?@8Czw$3<{8*DDz6*zh7iD@?zb!TR|U5gA(*3pe>zs@YN
zO*e7F*50n;$8-{o@zf;t7=G-jsj%@`v$9b#b-uQqwpOCIj%d2*bkV5>ZV_IayH0nV
zn&B4Vwe;Gl9d46)T?CgbGOLdidbH!wW^JRi@O3(e4bDfLNndk5_U<;XBdepXm^w$a
zDF<8=Oby$%=Iu;_qb94)zIal!G*@?<)|FjLw;Q-7o1JauZa!6VWk$FRUq;TfomHLl
zc`im=zWFgY*C5*HLT>8BtK!<N+3$Wl+qT{IaoY1ccYfDYTzzG+D@ISJXOqEcqxv(Y
zn$xPUYu<WUB4u#KBt2*wh;wf7%FH71w7sXfo*en<Iko4+v19Yjcjhizx^>y|q&e$6
z=a-+$J->73x34qaocge1S4>P~$}z)B!8{c&kCdI+6|2TKHO|!USiz>1M`yNtca79Z
zbMsF2ci)_A^kUJ|!svV7zE>E_>V#)^FYT^h6uh)=>&;abXLiIanX@KM;REMV(`?s;
zxsjDIB2jzRTbK1DcTU>$@I>ntZ|{)4Rg+FcTocpGF*@jawYbyhfYFI1@3?%mW^HY4
zGisGxowau57LjQV`?;2NI{yfHCGB-lLH|-+XWf#z1%I{vx_;QZw?8H8WZc2F)>q*h
zlRdt5SJqdmPYGMo`7oGAcvE<T;oUpSlX#;PFL;Zs3ZJUHZeiJq)sl`^RklX=DeP1X
zmSj3ViN7<-{Ya*~;8HuyRr9%7Uu;^XwAb~e_#%BLeMj*HuAeyK6{eq>vdT_SrA9>f
z5!3vTN%I99zf9`-JAb#aWNOm2sDoXJ63gFc=dI2CA8+C^eUcob6x04Y(+}QYR;oAb
zNtVv)-RgEbH|`Io-Rauut8Y#(TsEtu-0bbyJL?v%`t_%}ylnU5?MJgy%MWkMa_q@|
ze0TTm*mt+Sms#)XR+%!jde67-m2a!Jr<^%vdiVM2yU$lXPr17Fd$PpTRT9Tkvu0gM
zX6#5h*z_U%r^<ipwA(pHl$4{^FU?<?|M}66^78uPb>-znub!8e7w_JAb=9wH>-TI<
z%=MhfG${ez@NdZ7CT(^*cgZT%8LiwNjL9NLC#IY@thF^#N1|uVq9Z4Lbfzv%kqpx~
zn$*qN=_96^6{c#iMq`7Is-c*mp*E|Sr;%0!GgoNZs<WnBX0V-U7EN6>+blE8b(!ea
zt@Vv7wnl_qyC&LkIN;`H*A$Z!vz(KWyb`gjUe1ejv@~YAdcAQy)h^m9l+hj9)1$WK
z+OjQI1D195w3tj4J?Le7Rr99bxj7a^mO|PSgFDt(YIi-jx-?bi^qj(CznH1YE-@NK
zQzf)kuM(Npq&KmwtnfH{QRe04e8;mo%evlry$G$JQmVbU>0-&`=CE$3V=+&Q$`+KU
zXXtf>XHA^c^oG-Zg3>GZ_P*loL)Y`}?AG_1sV65VV^t~V>RxCa@|N#av#7=DeP?vF
z+nqM-c6xBNb=Az|6W*u1PsoL=`k?qUWY!Y#PSN-i9J>}iu0DKq_r0>}Zojy=nBA3f
z7fqH6y?k03Q!mSRd}>9&M}MJ@`l1g44(f50iq~;B&p32xm$hhOMQ1_Qp;PlTs{&st
zU*f*9q)MYdWXj1Pxz3RNlQ^Q*$?mCi){if}v)j7-eya^XdwaiJ*LsI4_61*T<yM(m
zh6lWp3tuF-ZRWP6n@vS_Y&)B4oTFKydgEs9toEiaF(vvM(^u3leY8B&@2G#0_k~4O
zD?PrcS{`w-yC@j6pT*Vd&qAlgUCTC23_8u_l%?6^r?p7CY2~4oa1O-+3lHy3r#X5`
z%9EB9#jF%P)p)Xq^F(mxQ9jLrIj%<{H8Q#`2D?PKajw$!Ofu>bYhCH<l@-_}HPw`L
zY3PDPNoB5-WrB%fELk1(N7)3jR%M1<6cbDc4%J-I#*yW5X=1C|N;Q@U!7R<Ft}vl#
zLerRZSR!23D1|w4E42PQvP$^hlGxTD^$cCEPnxPpOFat=TDz8sGp*EFw6MTHvt_2H
zGn<g1GlP$W#zBb{1_^D9EfNOJqEP_{C-G|S(mTQB!@WrFN~pw=H4_%sGs&*vwEiz3
z(2}r$l_>$V)3&QfVamf2r8hx7DhaEMR)$__mHjxwuw}7ech>IQ)nV5|FSy?2@(t*j
zBG#lH>gc`bfzk_3Q%xV$V3jFvx|UBl<YK`Rs}h<jvSzAcQ_xcny>2ayK8Eh43bR&v
zoM<Tsm9O<$(AS}u>NWL`(qgartzlQ=&t2=umAJ(taqMF6f`d9+y}h#{v!<LfI&iY(
zG`AYJj?N67fS!dxbx)53J?ESmoU~cvW>}J0Xm6BZZr6>CNk_Z2t_23!mtLB9F`Rjs
z)|siZv{TKNPC2Ub_j;D>)EjRWys`E>zen|E+3wm$W!|06H*>Z{>rOiz93*$TS+Txq
zouu=r!m0MIXWEy<O^jQ*>1NKhh?D$54?FfQJ?2%Rmm<fphowU7bn2#?PM^dj7T(lL
za!(Xb)p{FpGiRk<)3X)Up_-RE9=UGOv;f7CkZU~q(N8t=)lYt^jSpM6AfcHnQBfyY
z%Ok?gDCv~)V=#EWn8!O}t;S5PE8M<PL841ilx9usekW|S?27mE^YiU$DkhssdK}X_
zwMHv!YRA+Sn`#Q}vVvYeHg(%*)Mgktb!uclN><~f%*wb}m72gOrdip(feUq(wQPu-
zu790Hs(w-MRuz>$@#zn@e=N^kx9j%yvQrhd58s!^%09kZ{W0ry_^N$ZCj@yodNQ#t
z+h^h*{$|m!IcZ6HOQvgG?&s3UJeH>P$}>xA%k7@hjz!&ivH5$hojH@aI?r_G>e6j#
z2N(n#Sr@c!4Rzg^JEe(3p@{=hPC6)Na6~bQHMB0Mhp_(7Sg>ZY=9+2Zep?z^O>z$~
zaA?`vpK)NAz`($2Aoz}dQZ1uGfXD=<2Bu!7#=yX3&00d5AucSr4A-yBWr}U|y6q~o
zGC;{8(7{79nc0_ZiUz}O=LG=_COk7)8JHbTPB694n(7<Cz`$u6G|4F?<>XTn&Xq2%
zA||%={s9>xQ(UwrU-{B=Nvd9S+tr^Jt}VF1b*(!((ips8N1AbqG~=qKRkuZ_=(^o@
zZCH~Xbz3Oqw(Ewdrmb6Z7pZJ@U9pX8|6JV-O-ui5_Q~wdT^j2Dez9b(p#QJUMvVW=
zZnoM<oRD^%y3C_<an!ckv0e&V+pgVXI^Yqp)${GP`mNj69F4zWQ<cZI<kc~U?`Dc?
zT5B?-E^cv+m(EVxs4b;8GdY0!wQg6g=#2i4!D=UEPfDDazQ#9Y?bOh!(`iR;Y8$Rr
z_4qnD(`-fBgb(+ge&(H9R{C3Cx!rJj(G%Yv^A5h%zMN~?^y%o@;4eo$hneb2MO~`c
z*t782qSc>ymu<OKANo4#P<7_a(2`T4YnO4!cXKDoMMkz3Yi6_T*tBPBP3qNdzv;5G
zzg#!nv?IA>XYih+9i>KRHa9(5&hc2`kN)*(rdg+XyUluf!p}x)Kb^F(bBll5)+zVr
zbbU+R;=abTx6^j*R-dHlTaGPDb9^`9nvS8upD5LuSqnd9wSJmmbJVv!OZ8>KkB_e(
zpUXEbI=c0l+1z7?ZR1v7{rULm&JTNdgDVVIck_I@oG)b=adqO6r{_#pSE{eo5AV-?
zu}f$2*0XM>TidKtZlorzUQ}^vkKTHr0v*p&G8c1p^vHCUE-92%ITiBwQ~!EyX|<`V
z@^@)nIdkZ+*Y7B)?ROO?OE!mv{EVny8x=oG_%UyHu&RIC(qxhOygpIEnW-5|YkHE6
zmBoUR1N~c54o+R#wP{A<XD`!9;>YX^Klb<3q*yQBHTTNb6yvL><Ywr;JhgnA=dV*=
zHtDBJS$JPuXuET|*7~s32b1(wkF|5nV{@u>w@`OF89Zsng+iAX20OSlmWzf<aDUh@
zS1%oOc3R-X{h48=QrF*d_G(AjXGvW+Gk??KNS}+p1G7bE287Sl;GfJb<t2VNIkdMo
zC_K#Q!iua+cVUSer`49YM<(lBoME_B-6tY7=(SGb3}eG-VM2bJlC=$ug(U-CE2{~X
zwk1m#o!Ycv)vgoA*b>uxGM$$$v^sIj<IKs)YC<wrr;?S@ymdJbYfk1k<}+*6jswSp
z&iHH<O%_(0Iz9Y0i(b9XwAI2nNr|5lZ-;F?IsI6gpKg)GhQD!ktA1_LnGu<2l;X2#
z&5RYNh1CKhQ%*LmS>~0-6dmQI7Isr7Eo<q-)TycA7pF;TPB!e>6fB`*6%+8Nz~W)g
zMxMe$^L^N&RPScJ?$|NM&mvi8WuL{OlA}gP^q#HTvAXlf<2Iv1$7L8^O0-Vn+8vd9
zU0toWbltknNnWp4UE8z7XPW19**h%m^|QlFa!p;PxSid0bI-b6mnXI^%{=SNJF|Co
zSXXy7x5~0jK1-*r%DY>scX!w3=-oM{E{@VBuh(WD>1g(tsp_+~H2YSp@Iiw)w{A}6
zyfi;sQ)%|o{JCpYjB`C*PHoy`9TOui@aUI?g`b?>y4A~Lg4<=h+hxK^4}LlESf9<^
zr#-6P%4AoHg+YnQ^m&!J>2rVI-t+s}dsCZv=YrneUX_uRxN>3l!fAT8Tb@W}d^$XN
zx7k`g<7qo=$|r92&*Pjved*T8`KHs>UR(OrXlrKH#bmL>jqAH#8Jk^OtrHtAE_mwI
zVP5C$XEt10$1Zw!^|q)NFRu%?%S2u)s0D3(c#z(f%vpcnXvNgl%IC8_uix{Sd&{Re
z!CRB9UPkD3KAt*f;mLWX##tNhosN$7?UT*Q-4tw^b>wGcl*BBFO$WP`!&aS{cDCBi
z*W_hPjGor3gKa@CKl2z}Es&A1+7(%PxzBi6ja9PY#0Ps+3)Sb99@ExY$L(5>bzQSy
zY0-tt$!x0wZP)rv6`q>3Mv5nOwXW#GrK=3vl8toNe4YN~E{jrq=&GEPkzPkKc_K4T
zZWhVX<xyQL=A)aL?KL~HX-|abkpx2%wpjunmrk9sHEdOGrrRV_(FGE{VcM!&S821H
zj9QWwEUBAt+SPm68Q*Q!rbR~esvJ15RV&luYG|gyvD0Z0TUQtutkG5qW1OwDRiln0
zVdAfLXH8A<C-F1ud@}y568tl5ZDi`t=~vEtv(whB>2KRQeaSr*{rW8{*J?_2%rOjj
zs>x=zqIR<47bE{AM}E!ZU%0YnT9-z=%05xMK>w!hry}uM8v70@{Z^Tu5i~zxrF>Sa
zyo2)#QT?rqc9R@`Us@IZWBvODEH_h@dTVRztl739>1b=yRm0V4>z^%&-MZ?>z8Bz4
z5(uJM5CnJx1qG78f=x!>!F$A~SGltA)hB`XVwi#Uk!#%u-LN`k(%X6yW0f<TzUOWF
zA7`_&d~RH1>Gj;)(#7|0TdmD@&9j|*?`iOkJ@0N^HM=+K%d_%`XS=FmS8IHIt)E}L
zKI`7j4Il2weYjB_E_IE4-dCL!p0BTol$Tw*`a5ugcF0;+Y2K_Ei&LhqO6qOgx@q;T
z@cJ+ESB}j%*{1j}tN)Yyvrqh?w->y6UCI#~9=7_?U&syjH!@ewWIA&~EX`q)hsc5q
z2Kbfp5)8M)R_A&OZrhq2GD+>$)m1Y&r7rm#n3UC|*{zl=aVA-^C)uzk&17a~iszD3
zo|{rtwk+9p>BdEaq_v?7qojIugRa#3L`E!DO<BVenyTwLNg`s6$B{Kb2U1;I)wsEi
zvI%W;ZB=GE80i`r63mz?BDpQ?N@kR1=QN)!YaJ)E`KGQ_TbS84ZMC<_(Itmc&SV_9
zI?d%6&&-}#%a*3DN;#8q>8%6jlgW;r5mVf!ayRuEo$L@g>b4ei9cbzlR-ZGsgmbsn
z=Pui}ti{mNU6J#X#;!##+cYoEF?v+6LMF&hGxF4N$-|OKPqt((TbsMnGF<ZHajmCX
zJsm~PO~GC(N*47`2`uG4I&JY03(JFt^};kC%_@1XmU?S9m+Xo%k2gBIV;^ny+gNfn
z>(t9RF)>za-Db@^d1{?Cr{77vC4DD$d$nmaAMvWUzp!Yo_}ZkZHP8AKU#;dT-rBu)
zPE=%{#Hw#%e&ID)&r{dh$T3!G?a`{}`Vcl<d!K3X%CvbVb4)8Lic;G$-li@W_EVoY
zDfPkXQ?3uhJElJ1XXVxOeC0I%-HJtT<fdh(9}E4YU2eL1msR^g-lz*lPkq|@aMkCd
zG2y*2?Y=@kS?edBDt&C5^?t&cy{j*J-?9y=4ty)V$)_)PedO!#8rNA>r&hORTzUEO
z<>6JEc3nLZC)uvI;nB-id%E^c`8MI3;H!mk7v@cr3Uz)I=>AJ9XvU84)>pOi8aYqm
zbFRI;-7fJlu=}jp?&s{1I}56o#`SE?cDh&?zWDOx%_qaMy<VrS3#qS}uw~VcYwp31
z)7ST%&nQ^+DvtYrt>&wrp<xpqrzP#ymzKM)w?2qJY>nxpj2+>tzU^Jl@o{rT>Bc^x
zDs`oI=k@qJs+7ArpLA6@*m;DXXkF21U!SVw)c<O#qB|#}%+$mLPaP8{orp;hYgUDJ
zB?fnCtUS@K)LE#i&ZnxfLt|zAp+^b@O*<@>go`RYDo}1(rx&ne;fW&eNl}3*!JLu;
zm%2T5HBFU{Y|@#y#4uRYD0I>qr7e>-ax*5aI<nd&QK~CTvty%}#+uFuty5Dcs)hJ0
zn(1o5!_4Z|>K5p$G-J_>MKe|=EnUJaz@xEj#iEmelNLKEUFg{VNGa5Q*76Y5kouQA
zOCJU5IOs`qvmRl3G|~0Y(ZE)zmCR}yCTt5rr#3BXHPlLM_0eqdnWicgaEe!|;nM1b
z4;0o0m3cnY=vA7rWYvkKu?~9k-yAbIJi%i*tCd#8%Ag~w6?nCrm#WHEZabE{&Ey*6
z8crtA)mUHxak<p1i(W<bD_(U~x{9_$EaC}acTjjyuxPH!VunmFpP<l79X6{>JcXOO
zO1-+dra7#3VV*Q)F3&2hb*v(9H5RLA2MQHwhFCf&9o5vo;B;Ws((up9xxL#q>wtD<
zY?kafZ8$SYTSfG5cGN>hN5?5!mM+;A8F8{_X3vI1trMO0lPsqlPC2u=Uad3Bvh7rk
zS#aW}*}N-K4OISxmZ-gxRy&-Xovn3X<&naArS(5$mxl`<I<jl>isg&kJGO1hxiM=?
z@U7{l8#jjue2q!6-zAg1js4K_p!F`{6Mbh#du?N15wqpy<}lT`i)TIGiaZo=6@8+d
zc4hfg;h9^vZVjneG>7rRinm-hnU{*xKMZ=(P!Q;=7`2Ei-hb(rTL0Cr_RY_XcMgg&
znWB>sVj5<`vwr2I#HkBXQ@bQ2yf&nI>jbU1lrYs-<d{#&u?73~&5!qA-}KE}OgH4j
zMIAMdX*_~aY$>NzKf4|2^Y2_1HfwQc>oiGaHP30GT^qELQa!dzR<D$fTp&07&^%?M
zL-mPaK3b=YJ|1c3Tbb;-X2Y2?sYWw=yx9V-^vt!GCpKxmhCaVu&~hOq@wdPK*2hIp
zvp#Ne@%E)>x`OO~-&fzh_wCXDOYK_DQ@Q@hA3Oj1pY-ne_s^BjeZ6YR`R94>7;5fo
zTgTe%oAd5&$g-N-yBp+fKV7Xn8G6xf-|pFS@7z@limTUF`MJHE@pgFuL#>d9&Lqz;
zkLTXYlvU3a&w2MQNnyt%#}qKCn&hcA$v172r|GPdD%Y}ACP%J;a<5Es%!h8oFp>%0
z!n3<HkAcB4@F#pDM)vosjvpBq6_}Q~ifAwdXb5cJZ+@_$_`;&q+cIv~v#k(ynxesY
zS?k&quMq1i6$=<LB#l^B)tw4iz`!8L6~fDKf>C`{s42sVss@%TOHEFCR5=(iP3j2L
zl3Tdg$A8+@Ri77TH7A&EiMpz?>~@e?(rmYrPB)j`%ra|E&=w6{8@_JZ(WNT?W^md+
z&ka%ktCPzS_trIV6Vol<wOQMKzp6Ku_RxD7@ZGC+TW{wd{<q4Va%+`S+TR6k2>Cg^
z#Ia`6ALlgg)j>I{Y)_eS>`hqoHB~<>Ue8<mOKMW;q`IlU7QX5)yRi4|)XyQWlC!L4
znQ<?<t?)Wf>%}F#UX`C&E^)msKaGNCE!&c}djDK?!;Q!8T7)OBQ=J)k@L&x4i@#-2
z^{bOTr-^=Bo$*`atna>4#=$9j&bC(04z#)LJ6okPZL^8^YlZ1+Lv54veMSC8E!mTN
z*!fr*|BST$YiA#}cRN1pIkm?i-Cgw32`i)H%&mpqUkZP%PS)Av{#Yzy{V}nW`Mo|@
z=J)zs+MDXWHe_$=4DD;iYDsaM4QC{~)UDO(pJrDdS+ixn&hpcqzc#*1eVO!StNYTH
zFPm({^jW8ThzxwNsYGYF(@`t27}iMzg1_`{#wP3ZYW~`k+O*Ht*GOJ%<+9dKNtana
zC0%wB*&TLqbGEnGsarP}8wJX3HJfO=ChNk2QztEsh`afCYgr|oY?V#YC{3N|<L$9)
zt<Y;t#jD+sYW0$aJ}Qp`J&#UY>&!D_S;%S~-Grp5(8#RSAzL~Q)fgBY+Hhz_Vwgl|
zyBnK?j)6piX`I^B$()m2uGFMS=~O*#7VWbv$bM6Ld9gT8L2~<>J?)bNLz}Le9P$xg
zd4gTcDQmenOS@RehL|}E)zv00EGk;nE^>3*(VW{wncRMU9$V@!Nv24q<cdY<Yz>p|
zoYn0qmAT&6;!2dzWvyjJr+b2hHXT_xC-s=-q)pESz57gJPUT95%M?aVooTGCf7mEY
z)mWEpMYh8gQ{GJOP|38g@KYyJZfAzAFxp~N@mw{E?a-eCd9G(dw-x?)^(<N~G*!K;
zxOG#8Nlf?E(3Fppg?+8-=ee9#IjwbCc|&1AjJ;&3Oq`y$m|LVo>dZ8&u!x`6g^ymn
zaI!6NvaGhze(kL%D>l#VnYFXs{JCeWZ}F8=Px^zM4;<PoHg)Rs(;p>MQoC1J?C7&P
z{;>PdqgRg}omMmK>pIMTcscX2)T>ucyi|X*C64EL)SMMon+^O|`i3P+9rLbtoWA<$
zv{;2l4+~2Br-^rWuNHUOwc)jXn{&_U)>D(7UF|v1A9Sp1#*D*ZtE7&3hiv*<;5dDC
z$IJd;*6HG0tBu-xxL!pV>Y7Y7@iy9WA~M1|V{6Z}rqe94k?LZsy`k<w$w5h3leLw^
zLUp#xGUOI*S-a?(QPifBURGwhy}go~>Z64&CF%;ZY)D$_8xnTdWLCr)sYMYtrYXj+
zR9hAB@1&LPibGo6KjcrXf2#j5{>Wzcj}pgQ-dc;^G!EK5Ii)<b#yhE2aP_Tfk#E8g
z`k~T}55hNv9W9BI45`$bb;u@Yw#x_6qh2p3SgS-GT6Z<*iq^vkGE<o&7A>=9nm=XJ
z^oJ3F?N51{Kk;~fnl|yKNvFoU#k&^oP|p<JsZ{PMd}@+<YtWuXr9G`)ae*Q8TtaPF
z#Jd*Eb5Qzy{nG8+ZM|WJJxNEqxxIN-d+KgqyX|(_?cCpcCr+Ob$SlR`C@5K1IKA))
zvsC?L5!54~asxN9bhLCd%&>3L&p$I`+l1zAd0YZV{8!ISaOl-tB68>9LDQ8LtF~C4
znq+qEz;e|jC-03d*OoTq2Hl$EG40y48`h>1RHyc+Y<K5e9dueUZN|misfv34uDbda
zRIqyO(>u3n#oEQ}4X#QHI?jfQYSsUcb5&Zf+cq>XXlrO-(59<_L94EYhB{qYq_j1}
zHP<&(Fgj?Jk`@>h@|xYw$yL)(C|6>>!n~4GWinS_zt#0w*Y?Zt3-5X-YrXEJ>dm_)
z&+VhbzeR3NR-LWuIg@GD%$ZD6K*M{?4vgCvc-R`4bCN@IvvYe@mCjsNS}2v%8gyZ$
z>(t3&%DQYmVZLr{UWc}N^N6lo>NCCn4U1a+)SzpTGuF6HO4xETDzqzgQi{)vjXtKq
zp^`>PGcsm{c4ZvN4AWd3^hjeui8f1@Nvrp&6%S>Wc`WSeT{BJD=uG4^4vD}<Ur)_K
zt>9fkZ^FaF#l^W>Iv!0u85AgGX5bd2A=2y>xI`*|OKQqa&O)WcKwG6HKUMV>?KvAK
zQ+V)Ez0s>zk6xBc*rmLnOm)($s6!S`$2iU;=>`}$9_6xdbq`tBWffQ!(ktYBqSJn-
zs@|cmS*NOsr*mI9x9joBS3Z6EpiFb<qf5!ktKtDKR%L{%yz*P}^pK69PD0Nz&ZDb~
z8V@!f5<VLGki8*}WgerX$MjVi`*%#5o>JvM-L%lZyS{Yyy6LA<kN3-zKHBG%GRHl9
z_0^+SAAQ+7$u{uSde@iLDv@4=fmil=Un%ly52~J6Y%+WD^}Uw;g?*LI2W*r+x_sci
zpuR-(tx^)l8%6z3E0s1DeE1r7;-sDY%yRM0ik;g&pR+vgRVByoAGgnIKGP5V){iy&
zTCO~bRd0Ott5r9+-s~dxRI{$RLLa8DteL)QpVxf$i|@WOKiVZ0WTEge&@RaRl$PBp
zHLg{)t0oH7mny0J6<XnWQcc%u(Heu6-w8oGrB;Y->6oRpF{o5iX@{q!R+pus;=!X_
zG9jS_g(2+>t2>X1T6Fbkx2!xQ+<MBL;faNI(^l7v#X-}S>IyD0;;m;EOw#3MZQ2kP
zGBYUAO(coOaf;8XDAkOq3ubYyShgsFn=wI$wMD{l$<ifDn|y>4)R<CTPIXQSI;oko
z$}m*YQ_@pn(ljNtF40A;S(DUOD%OALa@v0(HfTY3kgwvCMJuj2xwCmmDV_*bp5S6(
zq_{+?%UO*j%h{uKYM0omWsLO^8$%6NHcA>O2T6Kdx!|_MN-k)X*QH&ek3!T!!c;n2
z6>o$pum5s8=j^s)+iq^VBNQ5=*R*Fsx2W2Rpo1PSRs8)~8!k-BNqU<by0&cVi%@-4
zu0+>Go(U~4wN{o)?$j((^5Kk9Ra+SJWy$0vTN(6%T)v6~hj1McT&Ys%G2PR&K4^u7
z%Hj)7QC*@<tLCima%b|2TEYE4$aBf0Ww(B02lg(wWw=Fbsn^xENrycXmuxs{&~?$F
zHh3!ARL8G=j!{dse=T_i+48KiVZy<B7qve72Yg)L7VQ<;)$y(QuI6{Wly$HA3zjeH
z=dca54YCc@=hA1`!}P)N$&_6}C7f65U0!*`Xf5vYc&O?tqU{*Muk~rY>XS-;t&eg3
zQWDElB6*g&MuvHMB&{);bpDLNtc$C7CaY@uOqwk0(#*Q*h;Mky)~roiGL=OWmL_fF
z+A8J~l6)p7W3}qiC0l(p6AUI?G14+pGfFw(et!O>ex_4CP8o)r3zDvSyofo>bB2vM
zsQy60hL1-@A2k$7ENZ$S;NbY`>&wqNlU}%om7VRWG@Np7R*cc%2bKS9Yy=h9AFR3<
znz3TP++JI~Z^z9!&mCMToSts`dL8ebyRwD5FJ!rcd7t7=n>){Zyg2u^U1Nq8MC_x~
znq{x{Jg~0F-PqQkoejBubW_19?)oT(S%IK)l~y3mRkEmlzwLxZh6uxjWz9Kktqcqv
zY7A1m4NJN-0s;cPI0K|}H-+8Gnw`6C#R7&OwHLti4a`25rZ6zDg#53X>cGpuF!`#g
zs}#e@1)M8AT-D~eNJ@xIaq<eXb-r>ze%jV;zg|Q;ZV(MzovAguKGz|a?UdstX&1o{
zTXUWGXNM|&yBhHOiFVB^t=?rOj+1k<!~R7JYVXYP_`2<OR&CDp-=3YZkG$`(?70%{
zrTRFhJ8sEN&u5O64RKkzOPxO5_DWNIfBwwjfBdhOZ++*vsd`dwx!%)j>))!(OZqH-
zLwAbjo%-mE$gY_4^7ZAjp2yT%l^#pyu?+wC*LkPunthjM2fx+aQoGb_&#BMOXLI>=
z*Xl1@azpT0_nCg(c(<EkDU*-StNr`>be!4o-mOm`KA-#H&FN)1yV72~?z=85&bGO6
zopxY7|0C<k5tqNY&dRk<*zCLfjaYW(Z`N7&K5h;D)SdOyRWNt`lqn%j{W)i{c@EY8
z+nf|RW%bkkY4SSzB5JnQ>%L5VnN<}vZ`$;w>sh-GX4!}ZAI!Y4X)d?pg{=o7)fwdv
z{aYR(Iay-s-|UpgWYfQCmm)J~{M($RGt28&N^WEtg!B!W{FY<l;?$hA3pZ^GyVx0U
zW!WUpHp$eP+tLhY&TKdtXmD_v&S}Fn#`QeTfnJBXb*81RRTFG#laNeElR9+B(6KEf
zZQ?>hl|$|)HZ4twk#UM~J$PurGp{Xrd?8&=^!P$WizL_fE}V5Mk4J06qaVuxc5Hbn
z*0Rp8C@IR-(&V8}S4>R1<W|Yqk(x(8`YlMBvE<5(C0FLBbxxU^u9WC!>27G2dfZOf
z<+)b9<#zj)KdV2TR9kh`<Wy+$>Q-^JmGLn$;xQ|OyEU@bSvXm2l#nU(>SH^&>2cSZ
zM~_0zsBT>rG3nZwD=FK~c1LVFwSVaWgM_V3mkwNGUD_O>&He$hpSKRQpVz*bjsL-y
z>ZlW^rfoWZZD&fB+6JAc>mnt54n#e+j0#(9qFf)dHk{QlHFwvp*9q5@mTdcD+;Lj$
z=(1>K{b@QIQ$L;7pFX{J$qBQp8OyHvEDO%$(anu~Y;u;D+x(nNMq*A_;o@1_A`4%y
z`MO+c&GHz()QxjWX8kqoN}aEN(sb=+jcd`ynro#lUWthj>%Tr-TvzJiI$KL)pU1a*
z9^baTK5gFA<NkhrCfRN?bGMu+3)a2A$Ji|0`tzFib;Z-?eX@GJTI$xZvbOWpM?UT<
zx!h%Y^l`zZIT`j!7ng12**L9czjD-VqqLdJLzb(nX1=}MXKeB9vE}sVUswuxww|6c
z<yzPki9_v~D$`TGvM5VyE)DrF5T&*FZ|fDauuv8K5A_}U589uUe<=TC`oga)8u@;!
zcs8n+ik7_OUZk43YUM?ZO^+3JI4z45HT|`qPMG7bGsj<Nfxm3b9}MJ~S-SdH><g?3
ztkKxVrQhiKgG>L2=ubzjx(=<nmewCjg+F>Me-L1Mq{~i!>)NQTQM1x!F3E@tomg{H
z#^cX@t6R5j-8wNjF++lB>EG!aOxeWilO>MnBum^ay>SdQ9DF2qm2R|XZutHO(tn=k
z{oZY~_wx3Hu-#|h`ph%^{=Gkj>E83>ao4tmANaIWs<>>K_v0Pe{iVxyTORe4+IufQ
z>U-YZdsP!mZ9ZSzeD3bOs#)v5_6TkDO_tzs7F%*VI@)ZjT9B=1{?_~rj1mmBS^IY9
zZx=aYr+DE-Z1IkF<+69b-`amO?d(>y>3_emNY<;lEcG>6HqEt7>*$iy6vLz$8^zqb
z5>t7_JT4|J6BA4_)Ld%l>~us&jAK)q(2U7k%UB!5JQBJNM6Fu2>B?r`j7tYhCkJGj
zcA8GsxwJ-dRd32=6W-97qO&5incY&gO}3oXI=V(V(gZ~DUG-@B=(<vaO(^iL$fK#J
z5=CaU)~8O>I&dvFcWrdUgf)|*I5IRWx~6_u^kUt*b$WW@LL!f*9+@_0;gKho1CB<n
zojtoR-9pur^9UcOgkUVI>#G&Zo%YyRJZ?UcdiCnjORtvtO?V;ek}13Jy4Ho#aJ5;y
zLB}>1_gMv&EZ)++WNFC~Bf;1!LVrRvc5A+TJ?GI^<8?b;)mKec?mqhH(W?)80{vAg
zCLfJ+lvsMm=40cE!dnt@8bz6nD>hy4l+&mXeHa?Msy)$diR+UNdr?>MpsM=?Kl8rN
zjn|wmXH$5+>!;?VLfN?W;o{-lm%ezuv=v|UW$#jDu5~KA+2=L48#4#IKIO)~%3W=S
zgnr<g=?mi)>=m@(>Q|~)>slH&iRDkItC*ggZPjG``MaO&v8jB%)Ry0U`TBTO|Hc~e
zLqGP#s~Q!?@-tuk(rD_t*z9uFf}&~JITu5(vbW~uw6DsU&)heCmHVl{H+m0t2hCe3
z-s<v6Yw=aDD6Xmh6c+UVY-+N96cQ>fuyw)0$OMg9TA4x*JXSnpJ*A;8RPRybuE<s7
z5w5Xgs&G?qtHl&Qkr>URjz{`b9;yo-n6vQEtOX}kC+UQ2RSuO}a!P_%wKLOa(J39F
zORG)>hb$8~7^!tI(sim&U{W`WNyiZ$hl4sz2XzG#U0cOO*0N+x$(oYL?W7wL94c}p
zBw@uxm!mEh0uusLnKm^>aQcS2+SeN>h1RW%b!d@wObw}I={gk}RH&`!<8ff8(u$Nt
z?gA;o3|B(dGz&_JE_FCz=y54*3Qw~ruV#v~!l`DB4U<9St~f7I<)ByH2UXT;^m1n{
zyS6$%JM4Do`yUJr+irJ=glp|uH20L?MDI{9QxDmu=6%t|xj8IH90kj+UE8{@e%06L
z;0-G_xkhrV3G`mc5WBk3^<u~@tuR&1B`bDo1wKe(^<!8bq;Mo8V^!#sMMV?EojpX>
zg$DXf;!J9c;+lHGOXC64%n;@G0b#0ITKh7clM@1al@=!_1a{6=oy^&~a586Wvy`{z
zVqMo27pE<{k`xpsvgE((fh9W&Q%+oyG^o#3^I4mfay93QmrkeaOc0nFvL$5wmtBfh
zqUF0Kr*7s}P2yHfW(mo0+;)@A!~W8TRiJ&bp~0(GFD#XR`AqF>=bG@Q-K*Y}m)CfG
zSYFD$DlIK7+1NDb+V-<~tIGui8G5{Lmh7@v`l__#d1+4j-|p?@wckQtY2FR0S~+uO
z{mdC_w%x9|x@&uZi>Jz|TYJUB!$syz-kxW5$W~*QYFuDiT3VXc+>1rUvvW76Z4LOa
zJa5iaIW9dezn3~^j&v_rXRf<#bE@ElMGu{Ja@?GuYQd$mAS^UM`BV6l_^vw5pXv|o
zIe*s83~O8wnxq?~YNWHEt!qn~Yhyfg+iN}h^UFNl25Us7O<XiBO2|jeHE?O9`0H*p
zx2-CF_UoVi^k=_Z>x^jvGYmqzP6k~u@=A<Y{^0N3ZE3ty`u?S@%JxiJaj<FANrO$R
zvLqIrj9A|I=tc17&z~Fig+>@erX;4iHLIlROn&gQ^s}N}%~AiBgUvdd4Gj&940Y5G
ze){?OV!iuO?}v8$)6dWAvegPz{XhN3|9SQMzNgFXdT)L2WzVinG23qGY*#vR^iTr>
z6Jtw*!6b(U1}+8$CI<!v74D)a9X25agNb6dU7S1&7=$?$6&TcnoE#XU*X`UN%39F>
zOL>yJQuyT`zy8O|%qwt<Wx7&ySvTxXfzGUhk|o@Mr+w<T>+ZM`;JfS2r4!4vwlw=5
z*Ijy4<Y;Kvb)^!X_%i`vo>Q)sU;MGS!J7Tr0|pjR`T5Tj7<?EQm}YPs-}BpnLDOl9
ziiX+&h6@^u3T(>`u3-A^C+}XNGF8jdW1&!^P>V`a(4y9D4M7bHxB?i~#~ePO!N6dY
z!fO^7%Hz{3F_Ud&{lBZB3~UNKDqp=kmaj084r~z)>R1*k$<yr1=;<;`GoY&3*W~gq
z`Ca>cQlr*(f343epY!hdkH7oXC+#;3-yIS@b=vZ|xpx>C7#Odud$(=(f$E>-%jd<u
zUib0c_b<=)6yM!4W#VB*=d+>A&lKWk=QdT{&N^AA`g>)OX!SWw^*xX37tQ<hFd**E
zJK2Dr!tI=V20=g1v3j2=y0S1{SFfCprDAeBL*c*Xj^Lgt%V!jw6t#=gE9VPXQ(gD#
zv2k<Sxx$nG<4waZPCu;j<I;S?&x$pvkL3(2Qtf#(>>ho)@^hQK6sP>!z~^Ty#b;-!
zJnY}LzI^^XV=J3To8q-Lk0<YA<EziQ`F!rX+u`$8-7@-eVQ<3TQ}bTFn`(P-jh#VF
z#y&~)gOm2NtyuZ%$i8LWcQ@K*#m(f}^LKUo>)_k`Ip4ng*!%GG!B?lMHdgJf%ue}!
z@9wsJ+Lun*>WSxUbKm#->7z4ywJ)YQPg`;8`~BLQePUZ`Yma98uJxbV^y5%Xs(+98
zvH0lvjQP3DYTpCbvM*a%Wf*+vklbXA`JG8CYxix~v3_ayt1Y!*`m0XA+UI>YrFO?W
z?N>APR~)T%bH7q4A1t<M{dT*DAJ#85@?Vk?@9|PT+3nz(rQe?4u@m|d%<{#psP#=s
zj?YE^<MyU;)m<}GS1y$672V3ZR$i~>@XwlUC(fGA+;*tGB2`~lv#w|AFGKmzrFPo-
zt8>$w{3j)?>@~Qm*(;H?>ew_XWhse-WX(2Vu3wv$#aMJ6J>12oCo^GZj3sN)nRK4e
z<X5jE6HTs4T$T7~s%t87CHcw4Ua9qy<vyOd^V8n$qSEx+9}TZ_l`^f{ST)C@`?yy@
z%eoEwmh%Z#y!6xLtiPuGso>GX$4f0#{Wiq<$p{t(Yr0FU)>f4go8l|BWo<^b)3vTM
ztBy7rCHTw;oy>A_V#<R@iIRqHK2s-$q+GmYlqzYmW|obcubZ#DvRc3JG0CYjeNJuG
zI@9^<>7l(wq1R))x2_7k9@BS?<@Gw*wSuvwx8AsBuPr^l_u0>ORRiAo?UQEkXRXfN
z^P{>tZq;)4=A~AgvA_3Kd|(GLHD&+qtN6gZ_~50v9OY+sy<m5D_bOE?|JExT^15+`
zu~_2F2WO0R&bK8SUrU#j>^4Z_IcfWIXR%v~<@veAI;Yls-urB`s`a_oD}COTbNA#-
ze`Z!8Q1;+&QY?pcLG4DpDSCJ6<!(%Ok=<e1S^70ivaS66k(~>ktryh$`>5U8@6~iK
z*`&6oW-AMY9#1(N^y|x+w0^10Iv-c&v|T+YlPKM~VI521p)=Z#kEK2~=vg?$w$S<I
zSDk6?r|f$5*M*$*I_tVdZ13;(Ecx9h9-LZ#_mPE(OjbnA!^I(n8)p^HD*Jrv!-?bd
zC!UKNeU>?T=2^Jq+jg&-9Tvf-o1eC)#^`1oejI$W+`DMz%0n^B@_UOeF77?1bM&Bv
zarMr%85fKEbho92t-fim{Ki;y(mc;vo%wmn5mAS(pWjio`hBI0q@R(&=V`s6#wJhi
zPk1{uJL;3=vExSXZl0AXesp+gX+gz?m+Gu*dVT6sleHhUYb95lp5`{qpkTUS&zY?g
zSALj&Fz(W=D<-poDg&z}ZFfW+T|e*Pt-{589~ZkyJ)dNe7`f(6;jwecr)L?wNxZ?Q
zl{zIWby`-1>Vb_bmn}{CwB*y2y=ra=n<7>AsM^ko+i83=FEyd<&EhE4nR)JNR}&9}
zbImex3wMeQ(ytdfnaj4-*>j2KQ^CrVPcbbroM$+m6s?-35*~D9Tj$!KEwh~bnyjv!
zWM*1bs1tN!(lxHmB`51y)*bz$>vCd$*G`_uU^lmw^_oQzTh*4W%{a2Zvq)mgvT2b}
z<|dyt7tUN+n}6-vtEFjcO&e!QO#i6IHsv4NbKTr+$Fh^_CkQYw2naAR2r}52eL5|g
z8@f+_`PHwr^TkhntWNqCclu^k^y1Tj53T$;4_Tck@$2leIAO8U=QsP!b_l%8?+dz0
zD)ePs*B9*z;TN>ugnkKizZzH@BJZ?*(c+h(@qu3d)4!ZmnKWgo>8!J<-@|sD+#2B>
zSidu*Fr@x9+b__{luMHhGlWGnz{^))#Pr`i$r9_P@4vw;TQ3MXTQqOin`G#LqJ~|!
z*X_=g4lxV3As+v9W>5N^IrZJ|BqEN*thIgTGt0Vg=B$|Ms#A1ZpU;c)-t&0Yr|?~~
z9iHsD_qi{7MqI|7wA3>jBhGXr7NrC;oM35)xb~<waL1X`I&P1R)FfD@&$GGaRPpiY
z^1i!wrUZoq)_Z0wI+@h1DiRbD=(+uISlG3laaW^$uKL-c$R#NFb=9v|`|_hN@7}%X
z?FEZ%c>)&BdZMABp{tf~HV7#&Ffa&s2(dIOcnGoVf17`RA=GtsZq_nS?xfWYr%s#>
zIURC2<TRVnCX;18Vm@j<lf~GSy$lVOsR?#=8T4u-8cgP#8dlG7shQ<K567j(MOS<_
zu4bIJCduS#53gym#^taXzNVQiPZc%&mM)x_)U&1|=#YWR)ya{OT$eOkjz&y#S(-5U
zXqeUpLkpj$!4uZHEezM$xZu=*1xGp$^z3vsb!+vLd7P#vcIwol?J{8=m&CP>7D!B5
zE6%liY0@06IgX9RI@5N#)Tiv4UhyJ!%2u~k;bKvx$rBzPDO$+0y3^T1ugT<vH`l4w
zQ<t~iTrP7~uT5`tq0YM1g+~)I{8o!+FFeZiWVhE>-M~k4SuaMaD_J<U%+X$%=XELF
zBW&_X>*G#uRaf<@7L*oN?3RsqQ(6|g<PFEE7jAPWty${N5H^ov!&-%%k(F`vrp391
z6>A>1%cRGiu@Oxwjnkeyaku8;6L)q>E#~-S`1Il-cjfKf%D<O(JuLH^bfjkSk`isj
zqZSG$#1&&FpR}}8doyjajjEgXqu8gnmIoSWt2~tD7f(NV_-LGD#h!WUEg#&cH0ujR
zRcM@i;4H}BpsYV7I3&}n;M0%t+@mk&T&ur&ckAUVn|6GhD_eS9z2DgDi`RjdHsPyI
zy(x`8qO(49$D>VA>Z`uKeOeg%cK@!Zn7&^#AL{r8?-jaO!*|^=YPlYZ1k0nTWui~!
zom}#!%=byR=e$l~)mI?LBpQfz9_pL;pl045lP51fhJHBx_|cE~oFDuf<(W1=b=Gf@
zv{Q<xpU<eXX!Qk-)3=r!$qcHmF)_)p{XDt6a`&<C=VccqZ~gFlo27i#aqFXJ&&AC3
zpRg$=JkGdZ@$vC~_0R`<C#(%x$GqfY+-mKvPjcEfxw{Tut@`%%XyMyWetddD7he{5
zt8vy$V-04E@)gtz5f543HGNZ^=aMJ$oKM<L*s1=+#ZR?<QrE8-r}E@1_of>4m0!L*
zzO;Hd_n{i$3-cM}mVEPWUlg%-O2oVq%Y<)CHCeIx1(V@Np(|@S<2_Yf{%5MX{M*P<
zuv9V9H{=mZ%#@R%PCFenE?DY1brvW@@%d_aJz3<lx?7dG!*lA<PIggeJ)KoCUFl*0
zrzfmqO%%<Tw887Z>UzaU)ubL_)|9Y`i#Dw|wb*GHV^-s;Rj1UP5_(o-Y71=)Nm_A9
zvn!ZWqT^6lU?kUtFi|&Aw<$aVDP4!Om6o~shKR0e+Qe}|*&|pZIMgv}73Wf+EsMgK
zRvZYG|Fz0V|8KyXPQg;2m5dRZQ{o~fJM;$hbRAXkjpCT&qqbToD5kz~sZ`8zrWj$S
zqLvG*bT&rK6jc^;G}SojnA&yaq{Goki$i*XrbVpvQ4L!*X&P&m;IhSHp*oQ)R~BpW
zY>G5$)0rx@Bqdm9+GJO^m2$2g>P<6+CR`N{b#LQwP1>l-l5x~TN@&d*NwJXZxX|3J
z?Xy2Qb40i}IXAf&l&rEbFm$e0$TA5QP4M<QtaQoKD#+{g;q07a*KVB7PP=waK=Z(h
zRW=5a&R%P@MWVtQ4W+g$o2pgf;CHw&q~w56uhzkcz>HZ=8+tQ+HB~Qh+3<uaJ<#f#
z!OS+bF+yY0VlUSwGtU((b~1^FW=vH*u|j+6gw?z{teHVNA(<YLN(BN_4~V+e2WrG`
z(lk-%s<||k<H7{DNv?m3eJ7krGnVW*rsXX%(I|^gx7jGo=j2RdL2sq~ORd|KEJBYs
zS<ES957b%plHKcHr`Dswqx>R~;a~QMJ}h+FF{i-2F}2>k<HJMc&f_9BVzGVu?|Oa8
zo~qq`P_$-oYT^=kjb~DuLci)IuGRRqyx!nu@UO))-8jC+9a_F&TW^%pS9gPJs#V=H
zay(!9B}xc>SU*Yg!{m%>E8>+b+b+4E44%=<D980Fz{bn0cZvI?b^|s>S*|y$!V`L1
z*%<nmc4|yanOdhhL1U&Ghu5h!ib*p%y?*O&e)HSz{N^`57HHXPb$_h$Kl#&M{mEbX
z?pIgqGu@_~TB9Hq+O*|T*s@NZ45`el87r1t@jtp^HRz&=&!0biJM6Wwb7^Zzh_APn
zQHr<GYM)idA|*wYwQ8?y>p$7C{vtnTz{wP!nXWU#W`-G^IO%X|URE@}u-EkX%?f8$
zoMcw*G)ma4?XxCzVkevHvsE`LX1SLBPFmZPGFf$^QGH@sRBF#Aqm>DJE^U)jYuX<$
z&ne}!v1HGNRGyX3mTvfHva&8{o@97&(k-*kp_aX^8#ip*xnORfLjRlp^S}PPdwXwr
z?#?@BuWl{e#yibx)!Nlrs~AJK`dLl?ImLUa{h<|4qW>t$YW-fZ;M7%(MIBRDMRjSI
z+*%Rnn3^?fRpoil-}V1)zvK|BYjs@qJw11Crr+Cg$&I-;95y2hn7M8{Z6=_zK|%WV
zu4cb?=WbVBntSVA*{ridaW{A0xx!f)c}<a_A+b#&RU%bnQlzV!L}Hsng27=PgTp)<
z4)aX%RJr6Cw8r3+rpi>U!#s;7c?K<+6tYrfs@AKdrut1j%Ql}<KG?xN+X6I`q5+;s
zQD9&YIpFl+@dLY71_lOBE(R;cZCtr&4yQad&1D%R6fLhRhAe3b;+Yk|%D{Mw=i-8_
z1_p79Rz}CgZp{iN8YUSRQrMb&mWl*qoONsPe6=Lx%Pgaeugsh)RZWBXJuW1gaCs^E
z1}&~ykWnw+@b~+z-{Iz;zdv|;ee0Q7SFfI#J-Lqg?9->k_Vx37*w--@ZoXz#8TwAY
zeaD{e`R&gS=!?c%?2~)+Nv}C()pzm!!b)*BeT8d3L&L9zU!NaWRrYwf^u?Qxo{MeW
znqBUtpdGe$z1!{FwG{~lV$5Mz^A2@MwxzDFIJ7wWQt$jn|LP~UbI6xGRm=_Per`S6
z?}}yA67?CA;%q)!v;J;pe_?idSLn7&+Gox4G*+i9joVmORuIY_^R8r7QJdCgwJkM1
zljdA<`q+BpO6alETp{OVSkim!_I*k|ygR(lFIG2kYtHxTJ7?22|L0#i<yLm4|5@(C
zr@NNVeC!=zGoxQv=%1-;z5E$ByO{o>Ti3)lvvMDA*NnX#bwax*KC^oA`S)gT{UvOQ
zcW%Av*O#68Rqj~VzKiiG^Yb^@&04u^-Xq(SwpseV%s+IN$gjC=oE<TxUN^LMO6^L!
zlnEc}B4z5L)~`DCtF~xHjcu~>(?gFw{MfR7WlGK5)kmlHq%D5VKi6W@Y5nZ_hne4Q
ziK(8Hjnv6F6a4)Ao@<*A7Z%OfShK$ACimpvRNmyo$mQqf+k7szdp(_x@AKx(87V3C
zQ~nvdMTea7pQiXJtAAP0kNj=hj@U)kY?>D7{OBtCp+ou|ht!Wot<wJx8DQV7^-p5{
zvCzM!^4EfY{n-~;vix9YjlufKqMtteOs%PZ_+a^gtL_J<-&%B~R9@nY{~Q~oDmIrY
z-jn{mk{w^q7hhi*I5kY!W$%`pW}~m?i~p>?yX98Tt)&$k;*W(?CC$GUTATmct6pT4
z{XE0ZotLK6Rg{*zc)a4g@XteggSd~`r1D8v?1>2!eJ$P|&h8cflF@qU>bK#wh($ud
z2E~f{Locr$dU2G`s%LVi){dhyg^qFSpYE7iairwcgOU{QzQrmJ8V_?y8b~H+uMrm(
zZsw8+P1UlxVzN~?tSO3DX<2tv*cQ`;*^X=3mUS9V)(JSK7OB~@T1U-bW=f=mwv5H(
zJ{ia3e5w`?k1Q)TJzAJzailQA;z(iEI#Zdb#Xjo;>z7UT37fw*>alpl(-o)Pw@yFv
zv`X{CA%jC}3|6*@MkIz#{JTv)cjx}hv$j`@bM@Z7SYq+|y5L3Gf3N2k?0DT;Az-{d
z#@)&Keav&=K8w{0CR=?xQWEt3d(6%PzgEfXeaZ{^zORefp&l4)wO>!P^uQU(Zi6!)
z(j=#)FH1IlmL4izfBITXOrpHH;L*VAa=QwfK0LAzsd#)mCb6PW#xc&~<2*?@g|#x3
z2MgRMd_O<gXw$C*^97xId{4I9Y&`Jywp@qJ_lDwmR<Wg*m$)xed~S2;$vK~oNqZD4
zzjIg?eJmCFaEjmZ@5+;NW<EN#$4jnyZN;uQNvDrRAG43Pd{}Du=vq|$t3##o%@T&)
zavSFuJeD!qIQ^LY%)=+_H|)>)>2&IZ@veOrtsJLzSf9Ezd1CO+XwE;5rRQU-&zEj0
zc`cB;d&dfw<7_u?S=~|*kyH0PvpI0n*`w}OH%qUqyCZedqT}hoHNl;q&YX-06MdQa
zZ1$FI+WA-OR;#?M`1`HS^IEK-Owzx4Ba0KqpPp(zdgx^0(W8eRi??t%Txe0;;(nkY
zb2+DkrEjX`%I_xU_#S2RWm@bkGK*UmvtnObzU8rJm+!lGOVvyKin{b&T6?P1zSOem
zb1e$zs4jYYE#Tdwc89VpENpkqZaQsLv;6vO?|WreOHa>w6+fxo*W~018~646PYS0W
z(=)73{#l@X)nbOvOkuZPCWR(}wht~&!Yl%fjOt5fc<0G5rDxtyxYoMq!_J~f)qC>N
zo;O}?(>Xe8-6cy|gTh5`j~@4#@%HN3lDB8m#ljP9Up+c=a#_?)?i=zRS1zljTwNCM
zF}$CDx@7XxgW^-xv8~#0vQJN(=S;dp#g3ypFYP>aYj3^w9IpKpRx`uGvU1ifsf*jD
zdDipgl_z;oRw0$Dwi8!IW#~jri*kN3Z~pQN;;Uq}L#1X-+f`!hZ0YdA$V6&gXROP5
zp_5rDx+bn`eUc-hGFConU;b*rrd`)I2lUO=;&rf@cAB$WBQh)0IIvghVpN9a$*bH!
z6JykJx_!E4%~Z;)@8mhO=IU0}8A_W@{0mtBVNc@}`y(@s9_rb&W{1S;KTAt|B~p92
z|Fmt5&Uq?5GbY-5uGQvct$!AM4AVKg>9k4s=isQ;*yN-}*#+8OED@U=W~`50wKr?G
zPfUSGp#X~mqW}W~gYDl1lhS5oE(i+?3yVxT&2=zJ`yZ1Zr~SA8#c9(g$}vjRPZSgs
z6cllR0LSTb;9cR~)6)$h9pq$*W9E7>$KbqmF*_j=F*}Q49cRc+ch{)yT<NS`|4-^%
zShIiq?YuQRpKo~h)NRVY*OpJ*E!nO-*wPi;%{9Ax?y4gnBo0X*Kh9Era?L!&oTsNW
zmhHNlRCe@YS5Jtjr0@zsBPE4!+g;B$UP+B=EP8sXbM-vFov&Wc(av4HYt`rI?6Zbk
zNuq`#E(}bZOpwj&@b2(@$Nsg=zidK3n+ADp%UYru8gw>v*~+y&^=-$@m>F-}Q1m|R
znJU%cx+*L{*FdEHa)@Wx!Z_}Li<y#^%9GVO6IO+u<m+0;G}q*^FW+iC$v%mRM-x`<
z*wIq0wN>3~UDJuoq~qe=p3}7+YtFRt`7%#mukeaR5T94*mF}hN0q(Ip8>b8R%uF^*
z3tn<~S*)?%jKIs{AxDFfo(A8H4DVi{w`vW$$Sdx^G|!}@bE~R+>gR?|y1bz%c54ya
zTE3<Imn!z`c)n=Y3jeG8D&Z~stn4kFk0aOm8~4QpotBo3NY<X*IXzuH;_0s0VJH4{
zt3Q49s#yPg>3N-1ua0*!9B+B6{%6U>LMy+eDYmg*C95{9)6>uu?b({;Yvej5>6~VT
zz2~LXlaBt<I+^+_@I=|+(>y8lMb{IhE`9Q?R^NQ8(z@jBlXYF|nyNfLYRNUmwX!eO
z`m}f3j$%o<+q=_aZAB+`=Uwmi^I5BweA;Tymaq1DXMerBmb#07!X|t5>1X2>pV?Qv
zuI9>od%k^Fo?gEHYnk5qM~e@95*BXWtD3PdmfgW*btvnRv&vqlvnB_t=uGUkYWiBQ
z`b&RHQpT<+C9~$Ol$cdDrI7E~^y%An>Pqxxyq!K_v5wqi{m$=~Z&lmGzI_{>)SnqA
z6t5I_YSNFD`i+jC0;<pX{<l7R&;0hReDm^(TLqubJNG%fpJVgmi~78uixVttj{P`0
zAz%yV+Krz#uglWCUBzH>ZP}GAF?{FM#nt92d)}^>5q<LZ;_}I@S1Orbax+hSSy%J&
z%wOlvb~Qh1XWIUodbssS#E(8jqeJ1Rxk8dsyHb~3)%LjRxhgd~S0GYwI%l}o@=0=6
ze#{9ylvFX%MtxP_q1u31owp-%qV$z-zmD0p*z>lG%BL?&Www5my0v_XU8o&XjjCNx
z$WNE)2LkH7y6ZoBI?4ZBso|`lA+@5(U{N=hswr1zr;t&gWXNi!FfB2!h$&aaTn-uZ
zszxfd^mJsc+Uo47!?`qS>J&qs1*do>rgU?LO<K)ms4S}EnYD7NPe4+$fFZL`n^&94
zCe;ofmP5^4Jgf=YqN+<hGo~C0W@Y2z37Mwlt*Mo&>chpuRnN1?TVv9JfCLTuXNx-Q
z{{)tVa>+Jr@@VbW3U->&B+TX-)*2P0EEdwsaj7-JNa=#E7f)nB2G61yMlP2YYe_||
zFk#P{=<(8I#iR@CmWEwDyLHvoo%?UJC5a`OZaW#y<n(CuMXl)`t8<G>auVB)NinWC
zDghpgo76E0MAw6ej*dl29v}fY-r?%p@?xd9!cv*Voq>EDnwK(N)j5J@3W<wO3DsV)
zs*RH~K}4!W@qZ!L38BE61q<qTOGmaP&PbDN)AAOXGSkTW-i~9Y634bpnzB_@qvx2B
z;bcjvrroR5y>^8t9zD)cIJIkzcGLb#i+0uTdU-|uRm|a}ii4B(=q-7rR9bp@Wo+S*
z|9-0vAG{bI9&4rj_j9>lUUHvB%z9a?sRv~ytzYH!Q`)d={y}TElba=ipX`nn{I}|v
zZ`W7HBi$FZzJ#4QF+ZeCcX8IOXk)MSnU*W|XjnLWm}29&b<4s>+C7UiZmqJ?uwX4&
zsdsAaO6~ea$3shYELqv;I3;NLlRw&uAt^^)f`x?|CmM=mtW{N%WUbRb^=Ci-=?{P7
zC;wt|ooLXcGg)M%FZ0I?&>6U&KY#uxudF6%;1jWdC*+E#+p2_BZbADcjOq$j+RIOW
z{OL~x^G6qxH9<TpzfI2gv)}5~q!05aM{UWFI+b;pnQ?+xeKV`KYPs9RT;25%o4#HT
z;+J0~In_v+n`=$*u4RX>zFv1_dE>8+gOe`0x!#TDPPzG7EpFFap}!$E_mXFy*|}Tq
z)NI?SH{Z;i+ZgZBaG+Lx`}IfHcFNwpw)MorcT1zEzFR5uH2(_^+r0#Pg=F~&JW2OI
zFLvvUT4s`QQ9ESoVz+~!TMHNGN||xxW=fgyYKPnofAnMTo-fbiWp?pN?ECTV)!KAB
z#rJKm65q|<(-%5TzwqwWsB<;W_j#|pu-@6W&gSvdw3(%v#?^iAR$VK8B=;k4ec}7P
zp=(yYk^4El_?~6a)6>%>7EAFYJA&$|ou1jDtFC5kjanPFI&{@lE}zLNC+n3?8hK4x
zf{WPXY2-KcKV-(zYcVH}Ly2tJ0|pjW@QkGkXvUH~yjH=^(}RI&3Zo{&f(4vH%)AWx
z4K+K;8#Fir0v#BG0w%CEJGx9_v@MfMgme<6=A8^`U~Ay1TB;>g&yaFKsA{RNtE8=3
zzvpDml`dXYD^ikd{T-GpQuOM5)o`JH*1lDX^It#SYpeTV{d;|J{qXzYy;ooKmlpe1
zp4vXUbz9c#d(3kl?R@k7Yx&&rxl!*6UcI;4eLXz;4g=%k#_(0uw)3i9M~B@G&oY`V
z5_mgj?Nq0qE97#gZdE@l&401J{?IfTPyf|>n&e~VbWQBxZWd8_bYe}3pIYkAsghmo
z+FHs-&nX7>XsAU@dg{%Tb@<Yzt{-Pjx!z`Z7<LMr7V=p?>EY*xmn9yp&dOZpCnJBT
zVusnYMSD#8Z5~ZNtom?i#ir$5C+2&dVtzYw=BgDxGUlz_V7tbVZ%uc1ZjkoG#gFQf
zDyMgUs7RJwd}6Ej>A9x*>U@0nLbCcYj!8~@+}=0mX3nO0-al4nX88NE@8}Qvw(UgR
zwZ)eMzMP0Vwq$+AiRHIua;-meX2QNT>PNSE{EX;+v^8KoTli&{FGs6VzWk|5mesyE
zRjz09#mk3z5^uz@t+3%^_lY=oMXxzb^DvuX{K@**w8&NdZLA-zh9749a9`SB`O(e~
z2lh#Y)=0R1*y#9SmTEog3gwrHUsLVYYJN?qjf@X}`Z4v=j|lzNDf79Ne#Gf_i^YmB
zx-hRhq~G;o)h45t{!FJ9AJ|&R-p#EiR3fGmQkoiBFY?+qo8#Bkz^_UAs{?8y+K=u#
zyJ_`Huf<1G>h<Gx6g+ygWMi8_h{4hCpUzEr8)$2?SZ%8MvLz{38c&@HTjO9F>7Tab
z>n%T3ex4~Qr&b+vNjbzVso1k1Orl>bsN$_Si~rV1zB;X@soYXpZ4%47L*1u)6-=>6
z;7L+!<6bQkvnrG2!NJr;ydhVEX0S=HNr*}C7|cjEoWt73$5j9D;6WJ+3voW4f?eVg
z#;pem4m?cQQLsmEW?IC#IeNkt1s0L+eByG`44cJtwnbl()6v#tT{dN{A@8cNSx$%k
zL~S;c&yAeD(dDtno8MN!TLQB^W8=lWN))bz#LidG*yVA?<INwxi)EUz^V6M9m3E!!
zIT^WXQ*3(09q-SU#~vT3cRt+xaeABP1I33&f1Exn@*%LIu+HeiQ5%km!eqS}%L?bm
z+<BJvEWNW_@r=EYY+Y5!%FD~cZTz0BXZ4%jc`$gc@1z|bMLT9~Dm93A`mpI_YnxcG
z=zWP}XOg#UTe#t+x3+fc%_8o(x*bnl9v(WTcbfImeuY!1Mk`wqCHW<K&TARht(;o2
zUw>g;gnqZ+*SeUlA8YnWmiV`ev-~KmO1&B`*t6-|rkeJ!wntefPqnLDoxWJcX!>gz
z)+R}*WuZqyKJa@^oGH3mbLBJxex<TX+t%<*-|20#tco6w9<Z%i@@CfLRGkC5Q7hIY
zx*1M$*zqRhpsU3+%^c5cmYxikW4alkSqGhcnt!V7Z$7H4`X{u<Qgd2ZjA`)C(8J=X
zkw%8oVtl5*mt|G8oc(g`)-S87-W&+_G)gOCVqjomVqjoUP*Px!&#nn!5c1rd2Ac7@
z=@qo)vagYk=cKxes)xM)$EScA`C`+1C7IZH1l%AO<Z*PIem-3wj7^LSH1j11YStf}
zKJf;#WPR?c8=;$gTcf#l+XqJ-|N8S)=`PDEU)f7@W0THWW!uiJ+%{uR=Vd>YOW7A^
zd#6`E`4oAyUw2x>q{>HkB4=wy%uBs);<nMO+;3W8a-@3E!Hf+NiklW(`yP6kBjm>0
zs>o9t*BHIrtd?=>+1txomqjjH7w9Sy=qfJa)v>5EP+TOi-c=;f<=wlvcQ5bWRbK8I
zv05}~4QtoNFfC@$q&1-v#1s`d93oaLi(OMX_wJ=tdG6&76&FXAjt<4E*JH~|@7{X7
z-t<?-MW?M^8y78@x+-k{t?Q4KB%Mx~)Lh;Ad3E;3O1bpXyULq)y<4h!^KOylxvTr5
zqi$`xweR0nCzU;7ZJvwjmDai@g{H1pI!&QX%cj|JY1A}J?`am@8XZqv3nm^=Ztm6-
z7xR>faJ1O5vW88#!=gDb88nln@^Dh2uHVvoca|q6OtqR=8dS#d%CR)o;K74eMz2mU
zz1kTb?x!Laqxi{f(Z`Z-hm#h10!g!GEp2-$JGm%qvQ@aY?3%zH=Qhv!E1PV*_wMLB
zbjb11stTtMi#|=|SMvH8=dC?6$1=RNPvV%BRh-I+S07W4KCIZlFW%0wW{=h4KNk}%
zc7+EStPc;oAknACVbm+8I_0W2+oQ!RE2fJJ-SzC8$2@h?)r_~5Q9G6#Gdw&ov}bAT
zTK7pw-~7HFK6UkxkH}8Ps*t^0do_9WlSHez^o4Ico9)N%IemiytGc?YVPTD&ct>Qo
zIHzpLj~$FxHaH$gNs0{SOj^UaYVC>c4eM3D`Kl*R|EIvJTJOELXnlYCqTL=lId8I`
za;;I=CmQ%+sq@o-`Olp*o|~74@5(nfvkNbJdPnukQ@x94H|^AZE7q61!>}*o$>T|7
zE5EE3J@oQnpR85Mi<cGpD}z-nCa?Hdwdv8Tk5zl)=3R^Uwr}Clg9m-~iE~6IDnGiU
zn6fou8k^8XAE84txDI4bt!KTe`DpQ#eX5fl#c6%i4_YqtW0K*@HZfko#@3Sc+?OBr
z$=Wa^i#8oC;^&Fside7mAmGE%x4rELv(7p{41E*yld(pjrmOo&fE`zeT~q&~ppO5R
zS}Ug3&s1vKs3e-y>6+vcrs1_^%F;y+M<ym|8m;1)6ebd}(qNj#QHjMNVIuXJnoE{7
zW{5GJ&{>)4t&t)zu~RZA)w3g_wQHJIq}Ha;RAG%-92eX)Ho7*g5lss0bYslm7FaE?
zI#hMlq${hkLJgS(Oq^zVwP`ID4V<DmMYAi!(5o#la7sv`SDVO+0uJT>UAwhZl{a|@
zYPm^jWVB6KWtbY0v6#iRnJL1xHKg9q(BWukV`wv{PGAzZXorqh!ZaSi1ih7_ftL~m
zX1RM!*mZ5&wsrUau_Z({HLp$Oo@nLJC)D(K?dqJf({3Egx|Q>!)t%L9mB>REb)`8f
zqNi4BUi4M;Jh0MjQqz-QM#n>{-i`qgnxZKyL*uWyN^mLJi7a*gt;`y>NZ@eL{#6f{
zryLQOuBgnaQ7@VG)3rvVX3{)|eT>zdznAj{eVO=b$(PoLL0`4@2HG^)XzbzIqbjGh
z@>YnIP)XBUt#z6KPnmX#iY*e&5YpfDYqD3<maR-H7i%p@&G7Uw)C!xLwBS<2gefVL
z{@9B@_~U=@o89rtABCM2yH;sCySPTF-`dJ~`o-#C=Acli)fyeFSNUcf4w-&Nnbp5u
z<XKL%neXh}JABEBIXS+)vn^LmJ~7Gh&-Ks$_V=F4E1t7`+ohA6of@LIP4n!{WVTMx
zC@!8ouY6zeyg1EYD;A%MpQ-w@Q}625%GJ8AVmxbuG;ZcTojl23KYo5|WVO-TF0bF8
zLK#}NY+3f&dN$XZozruI!q<5%5C9AGT#cyjTC?q$h_gk<Lfy5?V;UNqE?t_v=3VKD
z6)Z+uW<R`p{XA%mnIMCU0|Ntd?zY>x+io*4LZ<Z(Fz@ca*~N9zXx5oWRxJ_6hM)d0
zGc+vz{pUykgM;RDso%wn($6oSobSb;p}By8d1nKI?<NL~1tJd^N|;}7;9pgJ^x+q-
z1@#Q989Y-M9iCmf<`}YoVHHDq1>fW4_gGdOTgA)3z`&6Cl5Mue(g22x3lhx^yez$5
zDJx7)NJ&XD@G^M5nzC#uL*0ram$S^4wXvA6T$$2ovVd`c6axd(q>heNv+_d>SWd9@
zINQZ5%x~ZKOXU0O@=~^E2Fqnn7f*X`CEIGUetCGkR`2>*KY#w&Tk`4iyw7v*e82Kt
z{p`F|H5Y!b`@QYn?uOUf8Dz^Iv>8~v<J;Z5?qLrbd+Y)BDXb2xp6p@w3Zl>6XRz9K
zdyVX!gAZkP@7{gE`je2yWY-M~qE$C+S#>0EZP@CwhqtcFmUg=uowDRomhZN$YY#OX
zxpm`=zt@RdQv&Zw*K4w$F$-0{w(WL??QGMxf4$~<h8+?+Ahv~TR#x~?ABUS7+d^Gu
zte6%N`awr@-<$<=F1egl^!8QEzJ7k+?b*@xmf?G)z9j5DHShO{{?cca(|hLg3ayW<
z>^EAq`qPPzndKr@zb!o~&hPrUulm_to8;rxvtwmtuATnM_cSq{{hVt}{i%5KGb?|u
zs7-z*Z?ezOPHOs#ODcc2>aX^G=07uDYNc)6IZ^$#I+I_=uhrI6oq73k@@0L$J;}N2
zt~Wa$Ja{eIEH>OZ)#7k+%5UX0Yo>mwEe!p-pf+pzwO<EoH%eyw+{WLl{cx(CPV=Lz
z#UG+Hzw8TVDOUZG`RVdye_x(wGpF;__w13{&lcY;-~H;xwYJ!JX6*;5H9GUT4}MI!
zHg&r9g{*nqt}k|bzB(0kT5siph~<rW3Lg_wkIZGAre(Eh&3^qWHkmUGPhGhh(Z6Qj
zW_8Ew*9wo#I8gX&$77$Qb@t&hnLXVf^KWiz{q42n&*hwJ8)lmyyxJ?27L;@6b=cKl
z@khVvKYk59=CAYdao0Dk)|W|g>*HD<pOW#{`PjUou_D6x=p(&d3y-|*Jf+3AvP*CM
zk=WSILhGc`iqi*`l8#Q+;%6;9X0-5x#h%m~9Y?#>w0x${xD*^xI-TWYm$y_?YRXLJ
zZc&R!iyd<U4O1RHDp*>aW_D(}$f?fBVme+kHfkkFxYTbtv`I%`)4@nF(Xa^5i3wp5
zq7xIHxgM=s;~p+9vSY`N=5AG^lRnxkkzyR1bb^d@luqo4jVu)x={d0>qT5i6TT@b8
ze6?)q%#;Y7gQ-5;tVfR}Y+4p_YM$^h&1tLc?r1-jaFGyFb7AI^a1ruk*(o;dZR(Q~
zaaOyoHAnHruH9C@uXNkh+ne5QdAsSuqBy%a^^W&dJ05pEz2#~8>CLXG_r5&tW6!%U
z6RJJ^_Q{gqy|4Q$`qtgEaCrK&QtxE!`<TKbMQ<uDYMaLFEVV3p>etSYaKIoT!a%~H
zf{llbM~p|VnT?G{o|%oW-AygCvY^n|@pR`&nJv>chQ%9y=F50Cw_arT`LiVv@5<R7
zcAua1BJ$2VcdyvzcT3zW-l@CBKD&0d^XQkz#MFt?;>030oxVCP(qg97_xB<n183^}
zeKl8g#`KuruD+sM{^3WC_iWbLlT@%KvG7pAwBqQ%<B@G?V!@hI{;)rFQ=NP@{c!ik
zqTo;0stWzvX3qJ!WA)Ri^Q<bf>rIV=d#0AQuADV1@yTW34yidUS1vA2wS08BgYBBe
zq@pFkliyqHJT7D>aq`jEm(L`>K7OCy8Ta$_&LhRySzF(I=lg7#d*_jz&6``9r(&ah
zYl8O9cUHM{;MC$nn_nJ%^km+x>(f<!rml<GcUJ0xWyH#3Zjo8L<>FbNUSHq$tj52u
zp#E{6e_vtYaS?gt(+BTJ{rG70^5k*8keJBcZlB{_{(U=6CtVknXRVoX<!Y;eNx+A&
z8jC$K{khqvpI%+#@-$1imsfUg$lJ%aXPr-<Zc+5OWA){&g^R9j&Tg1z6|>=tPNB<(
zMPGcjTv{8U%&f^i`MU15C)!8fK3&7{B}?>tP`J^}`s_u)Q?s3pH~1}De9&N4mgj2E
z(1a}ZF1_^{OEVAj#Vq9(S$I`)hPIBdB(u?qmrp{jtZHsaHi(?+?W3_ZGiYna---Gc
z{jcx2adXM+>@?qAuZKF*T>cgm9&O&LoAl&xXL?v!X{MjMW&!)_qdkwiPE~YAS{lzt
z0tqLrbJr}W_xfA0F<mBf%BOBgOLODI&bg5{uXgN|S$dT9SE8-o#I<~r*;n<g-JG>$
z=GD1#BSI`?9yOgzlnJ?J7GWQ<{=&Ph+ipunho0Cd=;G+M`)h6g?Y)2BeV?S}GSNKt
zq*98f{PE|ED$^oUXQrLjG+nE8ZR%QW@6@H6PBk!JKO43+E<4&Tf74%$W<h}@B_)L;
zE@0BJqglVtu=l!>>g{#ALE|!@ZivJ&!(Fd;z24Z9w^JbX#xe7lj?OZ}-s_VMGvqW>
zZyYn+Dsjv_#^C%b-K9=G8w$lPEmVuJ=+1e)Lw#PZn_&+a$4&px$RaU)K`0wb{l=c;
z((CZ4jGpAEd-o2M-ce8i9q1@jx^2xP4>ci2eVf}MQQOR}R{n39_OtM>Tz<DsUhTKE
zRLjt=9jler%!~P~bDZ<`2D9tc=Ch`rn<w@4dHZz6)qCz0&))p_UUA&RJ5^Vg1+8z$
zTeWIqn5X(Av1>ouryn{zHDa}BeM;!$GiUFH)*RN^u9_#QI$_CXr`r>@azDAxJo7-*
zl-8N~p5{JFb>|wst~$*ZnzSZ#Vwk_p!3ooz%qcyV;$tASIA-^*2@<BM8^f)hC+lvD
zob>h8>0)gkwiVZPK1E)5d8X&K=Vnh%oy|J@M!}&`+r)&9tBQuJgzzYOdK)$foI797
z(8lgL&qLs)k;7Sm4;+G;ijy4QS#R!Sd}nQKbz1K6Zr;*6k2o0)@J)7Ml8{xaRB&E$
zlG(-i$XsO=l?l~tg}d@@#9m`~bM^uQ!%6kDl#@D>v{o>!^HgA9Si`)#NK8aC#jIn2
zO6!D0)84JyX?ivMeW2siRatv-#V#66jxOrruGbFza_vWhU<3Qr(66C2wF}?!wYv(g
z&bqoa?ty}klOqQM3ulRxZ=^P}p)TWUhkz4OOO<s@r-gN}MQVzPS~Jg?uI=&Y>H*V)
ztkq$bnyVWgMvAS{$!dyqv{<#yp-*PHl!e94)TvWkkG2HML}{Mve6dEa<AJ+{WrTWo
zx<;yRY(3M}##K?97nK$5;#+kn)#K{apjX@*HE%NBYW3T7oKJRXyR7Ww#mh}Dt_VK4
zYWcKDCJ$q>)`uFFKDuOSD$8}TWG-jyIn%%r{b27aI(tM;&Dz7XH6bZ#kMQQL7fQW3
zJKEN)TCW%v>V3+!Qb0~)!oR0xQpb*Mo!Q)VQEu-!%c{+5>d(Bq`czx>%E!lg`a%_Z
z^mIaPBIJw~>$&$>8_a8+y!ud4rd7z%SD)t0jAc!=+Ub`nQn2M_Ze&lg)WP7Hv(0WS
zys9t0n)7OG;PMuo#o=2-Q{`5Cee$-lf?4B;;*(Whgf9u-Qmp3S57i2vx8v#C-P=kp
zUroK<^LWnf_V(s0%RH~tSL}@}EUk)LqkQ%Cot=g2-wDga?vwg3nNRP!qe)HdF2T%%
zrG+AMv}CpR2wyXlbPus|o2L}f8+U4%@<Vxfx%2!<d#}o!_^$X-s3w&CfWr@#^^+X`
z?vm!8`|xqi=W~Z%y?PXz<f(ABI9H-rwJ+2yWwzF-N3V|+Ua!7xc|5%JqgH*&a-mW=
z{jiwWIQ{U|*LSAx_jvU1z|5K$q11-?VhcPcXr9n`8Sv5TtNI~}7-hjn6CcVgn$B@w
zXl2Kd{0aM1_IXV|s`S%U`>KE)!_+ULb*us1Z&n6$3rq^r6!Ga=v{uAxi%>6<&&rS^
z-kiaL5la$gtn8d%#I|a(z^qA`A*Zyp>P@sxL^=m;Sj!zC)o?U$QLtjvs)&#SGn!Q+
zMJGi$WHL@!x>B^m$0<o$Q^z$k=py4HW)-nTVq9xPqgLrGi4u?!kXRwLiY;jBilqsv
z396|AMja9?Yna0S*+1hFsb4AQ5F);0$w|?`B~e|zBBmZoPWpuSvLvZWx=zs65>r_^
zwLZ)xSVhgrTg#_ovC_gWH^G)3(N-U2P6_RWOyS-NDp|3riU$S#>aQoTa9C&OhOJxm
z>2}twU02tJy*E_s5Ef+dEoj)a`b3D|60NzRM^xqrIbOK1YH=4sQpn;}TeMc~>QZc4
zp&J^~qviNbWon{JN9|Hi<sYY0J7;;Od4^1#w5dMYTW8bFX^|<%B2%@56+KfW#UJck
zv*xnNS>u3-3$F%T<k}UyYL_gR9&0_zOSPcofhAVErhj~PEiGxq2l1AYRV8}u;X(gw
zZk=&`V585^S+Vj##h!}gUGvzxkM}>Ar%)NHe&|}S=BoB(7f;VA@+pkszVl|i>~-zs
znzq|^%UQ20tiLzqpV_nW@aYzdr?7J^zHlaGqw1@*Q*+O~p1Lk<LRHMA+uJRko^JJb
zOP&>7_MEB6q0lQ%E8ADf;frbKcI$PeMU%cPkC<KYuG3OL#zSvOcGRUsuhu3-&e?fH
zctXR&085o@t=5LAQ#}1o27mHg(2=xtYIe#h$rMlSkcdSyCJUUX&yo~dA~elo`lH~F
z${*ApOn)@-$I2fof4bjDxe|5S(8uHGWYuKHZqbeq$%q+hqO*ckJ5}oST-Zg{Uy^F`
zNo+~;HWjIBe*s16hn6WjCM{WGwC0q@hQ&%}RxY{VnP}JRmVVaVyY<QmgF`b{2L9MD
z{^(D9_bKjYLMB@T>pNC^WrrF?bf(0cKRp+?rRceQ$F8}hvQnX)ojQlS4}V&f*lHj;
zS=85)M=W7eMAwl$_wGEI?XFk&N^g0ryW7;H8H+Xxsz3ht<7sWCai~v<kKkmkivma0
z;vVI!`u^PR&Xae=?s<ie^p?l+t@S$Uvy%DsYp(fDo0ix8d4GG(o_p!_rIp3~tLFOc
zYWbyAe(KiF?K1bu^Q^BQKJV|naca!%<Oarb3~c6n#h0aL&zm><a#eQY+HKbwJWnbr
zGALB}n^@^ueKyuLdZKe$FF7YPw>Pm?Y?83q%~cD`t{a{**|4?e>@;t+_lu{7f`LnD
zL<g7F8W#?(wP1b-14BIn0|V0qQ2&x)3u9`46obQ-1uWcNT5DX`R;|`*Xj*k@fx@ay
zD`ahF8l{{xI=d-a+RTvuPv?LA-~ZRUeA|ELN?Nk~^{CsWbuBZ+%hf#o{k#2i=ClX~
zVGgGF*wEK;`(!T)?cQ+o+>>`PPwz}Gy{KLkx;RQ{Wms?KH^=2RCQEheH9D2AT@Bf(
z^6lN^-OG!f>+QT-Ui4g5R#4*IyQk+oX0seB){K|mr=BA6Gg5ww(p#ObNQ>j4Z%i{M
z2u<1VfBp8K-_GBTS?<}~mA7-ZdAY_e*`DIcbdkHo<>uu&3a9gKl?j~Oyy)vv^U^zW
zdx}clyuBs#YN!2Y5z$Ghrc<heEDzLcvh4lA%E;)x{b9!f7lzO8V!u3N+B}DW`Tdr>
zw-?wz%lDZb7#NZbWO<op$%ZuWefawLvH}AGUwmTEYRyS3k2@=b7#QRgL_!<`SsEP}
zcAi{TaXMc0PRp{XK8AaRvZh>|eC5Pf_E!!3SJ{@&^62Ww54m8(){vA`HN&e?%TuY|
zsA}HgO9@#S%nlNsucl0xH2d<&zy%jFzNj_u2nS6Hxz#JzQB^goaajWc!;&d3s~Al9
z11>u-Fu(m{7f|?*zwl1=@5k@EJ2m5e?Ai0qi22fks7Ur{)28w|t<n-@XvizPdw_xc
z_5Ntk;01q{%ysW-u8Qpelc&8BYESet=f2QX&!PBc9ryt4nyU2*En7cEXM8-sz;Jc*
z9oyL0YrBGH9Qd)jdEJB8r_Vl+i#@;|dsu>fdY;6w9_Dp-40|PxvB#c)wB5w_+F88^
zH4(wwTsIT`@PcEvFRi|}ec83`MZUR{CU%^id@F0+QKvh%o=m&ZE77soO-bXHQvH+c
z&;!gOt}ZgGi`M2%>$<i`Hz(@qL9^?=>(1_6o0r?A)V(=1cD8Tptwm>b7np5ZaWmwa
zv`cPI+a+I<u&aVw7p*$EF=|Ciw8z%&4BxdKw_4XkbLHl=9f>-+Y30@pW`WsaN1~&(
z*0yZz&Qv?Q!c6$yqq$T4PKCDbc<`t~=CkXi`l*F?OD1jg&y~7*cF|>*Em0c-1I4b2
z9aXA$H}&og_oTHgR<B!&JuN5bCbEZJy1CjcBXYCO6_?8Afwuy0Em?DEs@+De%ID5o
zmA48RbLq|&xt;2ICTz{(VDCh`8!GQDtV4E-Ivcg@-W9tvb|vSGPU{`JUCTm(jRML`
zt)1Q~L^jszz4JS2EfVJzwYBTeErn;Ha^=?InNDYw-n~1#Rn(a4U1@Q2*reM<8#ivr
zbzQVLaK(xnH&$$1>?)Eh$n2e|vgFnlF+*d4oSVk1vs7-~jBGVl*k<OI)RwjAR?f1d
zZUgVsO_8lUm&C4aT5~YiXvvM7wj{5!9=XyQXPk^h&3q@N)icdpaBH?!n!voNUF(;&
z+9Z9M8q>QhDl4<uS8b-QY1oWj6JMicv$}nPpU?a5H#>9r9Q|0|f{k6z4==qH?fdMG
zW4!s9-F`DSWv;MI%UX8nmT>iUM*Z>~yZvU}T5HO_R&~oZk^Hh3tna=nZ+Y3<xopAL
zj-Rugw|?4Gwk}Kc?)DJP`p-3o-dbgDiOS-SwEcNC#^kBVo+Gz3^39&O{M?rsyWD46
z=&}W0yMKCJnA^E2H(>U&JFW8OXWTO{hg~tbBDcx6#!7gj*@Wn4cZ1r`epY#FmAGM6
z7JtO@vpLF7Gb=l{#vJk9o!267envd=vfCw)l<m(G1(&BBnwOL#ar*t-TlEX$s<&%R
zJ?|esBRlKzmKWwL{@kDGz2)WPl&Gwnu%%tUPMn${pS$hk>|}}Q$8H+uBy0YRnD;1W
zxv6OE?E=x8*_WrB_4)GPPjT+t?7oFR_Zx<1UJlNhHf!$E+@N1a{=8Fe^9y#g+NyWq
zchsA@FxiN2n~LL1U#sxj-d-?mU0=qP@Ac6#uS&kn-0)}GHk;*J8!vq~Gbs)|eJSm@
z<I^me*S^hOMW<HwGq2cVZo+qY#x|`>;SaCe&XkIFJLWe1vAW4L?^(-ki~gLwc;@Nu
zwzSX{cejOpk6tYET)Vr?SnEpO?N3jm7ptCGSCrUuYOCx|MfPhdXI*`lTzEa#)W>ww
zEZO2^E9=`P1;1vUAv`nKD3s@@v52#g&nd=PZYi#53umm<xsc{5mbK>4s<f#yR-_p#
zrloQ7teiPx<%}~E&TQtI*_J9g(^yEd+lX^!WYe;QGplq?oC%EVoT;_uRGN@v>oLnN
zos%h>blO)>STD(QNMCZ&p*3gtS5K6aWIkpT$vNTai8-fL>nANsW;Qw*7M5~m&8ahG
zog2f_dTwWhrkMIpxzTf0^4li9+o563M|Q+6xv9GCNbkz*jMJx1%5GblV&gsO&9tm7
zVr!)~uDX!BRWvzt!L`k)nt{=0r=E2VG-7L9F_YPCL)M<jqG!ywbEihT9n9Tg=G$~T
zDc3o7=e5^!rS#T$PB~#!zf(76?dmf&pDUm2sd!O5SKadB)u$Ggk5|ok9#}j#=(&Z}
zo;PO<=6t*`=egCEd1*eO=Vj%BRnvrz_s7e})=C^ZW@FgTFMKR5Oju>ZX*(G^ndeQZ
zI+mB8MYdLM`z*Kf$!D_$B^Gx%t%cW{kEBdKc=AH)bp39nN0IDehWd5p-0$mq(m?w*
z)e_UR4U7e+cBXdD^fp;Ozhs4Z?xohn%H{5Si|1Op*|HwB$ar??%9EtFQ{lmakN5rF
zdB4WGec|it-remhA0KZ%ZhXF``}VHIkM-kb-kQ&T<mD^AtUhVA55;$1E$!jHKdJfI
zlw40~hZ_@adS?aPSavnwR@)J`E8B$3>ea4H+_cSQ?bI!*Ion#+uARtpN+%+;*P~jv
z=EcJ+SyxwwZ@KU^lW&>(d7BIyMPb$hnU%_Y6%z}O2^_V#vcB}?gL6l|ntTkcTJ&L~
zXwNE}rRIBOta_umwL{itOPqT?u~_nWXv|!#J+8{lTJzl7ww+CSJ!6WYW9ind*KS9>
zPP-~xFW<8CN1ePyvd*+4%~`DiZWBTiv`%d;G}<g|Xk?_L{7J6Tva)1)Olip^&y-1?
zDw8~QCq-*&ZMv4b>%+(5Bj*`g-ep$kYh1at@>F`aRli<n=-H;@%Ar2pn))a8ZS!V6
zo-W#ZXSw0-z&V?{52SpZxAKj}Q^To}{$Yzx+64J@3)Y8U@VQrYSLfq_rxABg72aBH
znO<>cQ-M*{=ErubA0<^DD;*2fS$=fIrw@vTJgZjze7^S5=Hp6vdBNpUtG7(oQ&(>|
z`LZ@XPCn>2&#K^_Frx)q;ySxtUQx{SZ(h&+@b};E+fU!TzkmDr{re9;|DOiAka|a6
zbndp>celT|ox836TkgKzZMSQ0=YGxIc0cWQ{^s26SHb)*x!Z2v{JZu~^Y?E-OJ+`0
znyTeFQ)On*l9}^vo-3a7-17dMXCPx9?k$%2wA9mB%PsxkwvJ^<i(aK^CC=>XR0~;Y
zt5%&Ib#3d~?5JaHp!tg0vk%==-kjo`{r-;6{n#UCf0hfI*FU}EbN}KUpZj@_(*Er3
zoc*<2*!=#EDJz2}r8zBsetT1N&9}P-Tf-K+nXbCIDQ7X~v@J`sqC?htMKESWPGewT
z*tf6#bm*$}wtx58-P`+PZF=N$LH1A<7RNn4wHzI4jtWjJ3XbKrdGFp=@7_0~m6OS#
zMeNU#7L`d16Btyl70wrr*raff#U-KRU^5$!i-dt~vc$2TyvG}Rk|pjQPnNiQqN4*e
zxD?xyTv~9D@0j7PCoV27kY#Bd9fqI<u^`N*r2e%^h^0|KY<t(|b9Yac=DzweIWa@B
zetNE(VNY__yXq<-PDTUud8-|JlBL5}PZZPx8?_rU^3;1hwg<FwHnt2j!+sZhNDgSE
zOM0D)B*=CprP!Y2>gxQA<E2NE*R50PIC+3kfx-K9?)vOoZ<3`!Lu0SkfkwqP_CU1l
zmN*6$s0WRb?ZTo&;@a)o*JBSbFfa&}UAx|sEOASG`t<30l=$OfJtmZ=nC+UV@a{yq
zs*>Z~3AbLkH1D=Ou(2mO3*?o!FYAv#e*66K#~&Xb@0Snnm-)Qz&wY>PCjJeMH=55W
zym5RcP|I|)O=<DNMXpBm^8T~$KPxI<$Z9=3)aX2$Y`T8d!@V2tWL^!;d;B8(SQ-MP
zU%q)>R(sv<9j9OC+uZsX^t^1h+2Qln=VRmJ;}-pL{pR|m`=$6L{Uz}p`(Erfi7yGe
zKmY9Q;;>aee_vf+U*CEzR!{oW_4RQKyxVT)zOy~Se=)gi$;0~d64nzYxyz*`M@~py
zxA`LPB_mIjrc3Wu`>eWkjDdmq@%=p(pSNc}`uhI$@%4eu8eX>}muF;|T`oJU6tT(d
zcJ4ONl-qNDr_al8UoWkEU~zQ%^iZR-+L{tu=d9fp`ueul`rRjFpM-`cyw?{E0rg=N
zpI3dJ=Vv-+^{dmd1&?a#Z=W~Y6EfF)!tRMY>E~@sBO@<zas2rCyp1)WwbMPSd;-V)
zAnnR&x01?wI!!Jto1q}U$Z<K_FwkZZch<IB>2cfQPFPECYSQ@mvd~*()pn7M-lbe?
zjE?FAt-2HRXyVS5E0;ZbZ!tag-0s6#Pgj=Tu6|v4ZkKt0N}dX1G0(<Z(QE6!UYa#=
z+m+boHE&+LedWpX^zPyOSl!!cdde-6)~r;QndG`pec9w#og>??NS>SZEGbs^!<w@n
z*BsegsK7W~GFJQAk9o6vb+ebwEuOO|R;EB`xB2er%a>bDJl)+@tkrNS`i@d^c6Iv%
zzjr_T^KDyZcz92J`+9eCzL2Ei%y|coCaTp735isnpZ_KI^76du+voIc&HIZuUHJI)
za|`<nUVTUvT$(UNQhbq6iw5&WuZ|f!&n-bEi-la;Mb0XLDUM8@8oNPY52Rgx$6!OZ
z+t1=@KW|*zc<y*<>Gkl?;}IPiJre~oI+ToD99>fO%XevNYR1R?`}^(rcG10`>nmU0
zGh27(?Y`R|kI9NHp5l0A0?54GyRxpV@Zwn1r2$3;A{t93O7TpJjION>^z`)ltDAMI
z^KX~Ol)5vgjncwW(t?d5r=~d@^;}5JG}gFqO>@<SRAV-SO$%40wCYUQ8r1xCd2!Ls
zf}W|fJ#yHttevv0b))YpGv~}`j`~~O*-@S<lO|1?G}Fk-D`eU&Z?#*wn%jCMm(ECA
z>>74kL+@14;t9)RJ<lAPtiABWGnbhieo4<fW=>K|5jI+7tm>Akai+^y%Wb#ohHWc1
z&Gy`Awm2o1w>fLuDvL>{jwVG$9`iYKxOvHq?qH{O1L4k<8ZSL!y%b(eYMwc@r=&Qz
zey+^Atc#1=mL<;WSsBxI<WypPuB5)`QQ4B%h4Y*zRr2#D1#Yp7Ffr5CE}YzaP~lP%
z`_#ZEj!%QutGLE*+;nrzResf(TVDrDRLfOfyz{V9&MnTp({i<2Kj+FBX^S=G%(OKp
zRP)?hdHb+lu;znVK8vz%z0AmIi{(#zW9#%u?qL1;!Xr~F)}%_xsdQ#VY3+7dcTn$y
z_Xe%lMH;K`Z8h~>cADKxEh|oY(N_QB=*P!pjyIpzPu_iA@Xn*SYqzt#o^IVzDR;c}
zmAJ@F)n}JdjXFQdTXP?t@<dMY)7(9le!(Yve0)<mKTG-?%~^Em?xwV4vtzfqkJz@K
zsB-$DKk?m-2leZnG(L6hW3|<cSDN^#Wj>dK-K8LreM=msuMe2W=dp?{ltn^i8k4uC
zvnm_Yk!2!BW-6w%wz4i&%oKKvYR#CsLSkXZQeQ8H15yfCf<x7oM6KB1%wp1+qS|CC
z*cfzRWvbAo&WM#dA=B&qS6_Yo?a#f~-#;t9Kc9c%apuMuf9J2SKi+1))nkQyU_eLR
zqM%cXVG^8%fregcp_8~$wR|+Dd7N6cSXJYY$EMbau0Bge4r&_mgm`9Yc~A0K^n@c!
zRa0ky#-UZNO$$ze_759)v~^87q_DngWoQ(Khs{#Q&{_erwo74Kd9$Q0t?^b3n!jjm
zTZ)<Fq#S9sl$&Ngl3Ypke>r{XT4pL%Xy_~4G}CR%hz_-J_tnY`{H5HcYBuG{B7O#&
zRoi@5-IQit8m`Tm8`vZ>QO_wmWLsxK$W~GJOOs!@sdOf5ToVXgaysO6qH35?n1RF*
z!<J;uWFf;zJqbPuIti<J1deG+3bQuNbefQ;St}p-)%%t3qxC5V7wM|jXI#^`Fl(|$
zl(R@z%9@E2Ht9HPcqWJ+3ynB5bHd6G`-C6LdsK#BW}UHF>}=ASlo?xA2OCMHU7X1i
zHFLs=3z><Yt%)70P755}6p*R>Y-P^OsnTMX;+^|KU1uyjt2O0U>&v7FZyj%eHXUci
z6x%CnQr51rRXutj*l5Bt7XJ-$vyRm-O^VpKYSm<Jr6V&wYbV(rF`Q(kd0<Ys(1J4x
z({DJ<ZQ3~1cco!i*OZ&m0-m=#7R8;nx3{;~`t`T&{Pe?*KfQj*Es!7kcl+ZygV(GJ
zzB#6}EEOyVfeKw#l?7U$#?)#yP?demoJU8w_P^b6Q;EqAptBYjd<599Ulpx?JvC~T
zNRxm<;JYS94F!QFCFT2ZC#$~S?<uQ%`1$p@U0=a15)Ow(7Y9eskqvQn^X28`)^Ayx
zw6*J+cEsAGt&5nm-rmpqoqtTy!#0q~QxR0ZeQbH=sH6yLG8pzekZA1SaAHw4gDeGU
zRPcWG^VYtt>vm`Pt~9G(a%<u{j>r8EYW6PDoUuMyDotb2%*3_ZQny{#U2r?^*tVm_
zx$DkdPtP#iY#6$2w{`5?bsrw_mEEp0`MmGX>$xSbxrA66IRqLVL8EnhL&Lo|loX<z
z6qumxs&msH92E&RIg>l*NJzfp@%&2rMN+TNn|EZdyUx*>-Q*frFB&KsXuw|hc7B@n
z?c``1gIN;3jvEhftcr5XzM}9|!k2@=rSO1S6Tc(-`u@M~A9;JG701XFh8#8)74$i(
zwyi7ecI?)9x6bE0)4FjxecR^Sk<ZhT4tVf8vM*x_thAdx{a~He`v3R0?)d#-(xp!+
z4sP}HznB~Tke*U$^Yih>z4i4IpZD8Z-IcSc`BU-n@$uuw`yc<Rm(M!`F6E=Me`U>D
zbhOK4RoJYh-KweK=g-f#x3{;B7cZ~1c4}z^Hy!^&u5Viqs!-fiXSDtR0|%GwKAsQ;
z2BrxN4O|9%b&MB&C^9S%bzlf!;AGHHWnf@s_^#zUL-K(|!Uu+WE(V763r;XFuDfpG
zwS1G?@~xp#42+taR(USFV#2^S&(k#I@>MAYM)g%*!Cn>1dKnu{wU)o?Wnf@fGRZ4Q
zZUI~K$NlLK+N{66&z@uWzWUbFBOvnmyhnTIeYkTh-`e)rbB4k_FRJ_2g&uLeyW^JB
z(-`NJ%0qHDuHMPFS+@6h{nYn`$;pAKu0A?3vgL+5&lMQ2`&_|zE}3!O?z0crEs`r?
zB46+9^7dzseP&>#!7Rc!<C+O$pBe*CFf*I+>b=+V4V$grn>X;s9$=7-eYg7n^SRK<
zES)f=B}bwI*Dl%=9cJn(+MMDWrJb=-OJn)gZSTs~-tjwG7A;tRE4rBL?ODAGZx(gV
z)ST6GG;LL<wOM*ed7-uEnZ;YAi<!3@z2&>=scfQ_ls4H=se99zz^!6t-J;#Xx>Adi
zBaY^%uDB{@Dkhn9?BX_^FvDm`-L6HwuF@h#$5tFoeY@@Ux7COA`3f$s2>I{W&a+fb
zB5_{gVs?`%Q>H%_C5tMu>ZhfYBv~YWI4aI#a5PQIAg!;bsiNSK9k1etQ~Nhcb<dP{
zTWOK7-}uaD%fmcpv-aDS_4VqdwrPD{r#@xPDKW|C^X9eRe!+3fP}kwa+HYIGO_@2(
zc=2R*d&90XbB-H#yp>;bGnwC_TjGr6)N`s^;(5dkKg%V}c=EF1;)g5YHc1xs>%{_Q
zOg$FU|KQ4|WRo*z4yMdke{{^MXQuK;gY+JmXWA+1k7h_#Hl0h;uIHF!pK{wIXV$IB
zA@{BB+!kxO5|y@OaqQ_WfuUP+rPHFW&XAs)lV!@8mNPr;d31DiX!mKIof<L`8&iK4
zJ)LG*^n6aC){ISSHl+3?_lPDP?Pl%P*;F5~`JAQ8#ze_f$>bT2HI6o>PL)iHSS%Kp
z+G%twSz?+;(V;aP`gB%L7iY3edURFuw#jWni>M{*ZZ5kyCql4WOh?PeXu8hoX+cjX
zp4NKWeY&+<S!dJH>3Z&BF&lPltclrVS@f_{^O<0euu+?l{$b@g7R91J6CO`j=}UY#
z;jz9>eaP<U;DhbPrnBbhv{<{Z3cakpX4SU6JLXwWzN)MjvDBjIT+kW5vOHsv&8MeY
zKDHD#s!WY}eEi|3KN9|vwT}fK*XI^<i%jj-2if?rry@?dwc}yYmC~&fp3GSNU|-N-
zmAW+bw?3H*XB1Dp{MlHu-%_r)+i1>np45m_bLAo~*QadwGb1Bs>Qi}%Gd)XN!k6~g
z9We_txisTg@|?-b51+FsJZ7Mi8r=FM>Ef)=Q;W}RY)RG8SYEj~STxU~Tt+X^n`@J~
zMd*=rMoPy*J!d){6LmNhDSuMnALk#nVEKs?*B$8bj^gDBy0UAnwzt>R*c}Q-ZV7fp
z8~Snl6W58^X_;PcVPkpmuxf9+(V0hu(`}NcJ_~O1>GSzG&*n){uA1M3ryli!pH4jb
z^y#C-iSriI56_h`lDM(XaHg@va{fMkJDbObPvZ@CWE@VJqpw#}c)tCNSCOe1=j4t8
z#jTp|pUrMAt&5P+7k~Qc7wfh&Cv}eO%iM75jD6CvlaY6`-j&WN+f|?G9qFS}mgCy3
z-La#_;?bWN_w&c+oYtv}IkPX|&ne%t7Z1B>?bLqsv+~Esiq9YFGFJ4R&N3D@OxxBg
zov<L~P{@w<AL>8D5+->~n-<x$bm_FjHQgbuNoE_RluV^GjvBUkPB}R><y7uOaOcNf
zG-}K0u>D8Z&OeuI&?qo>wS~6|CsX{de~;OCBn*<2ctATx1qGW7ToMj;bQpjLP!C$b
z#l^){!XV*bGn*2Ri$sSZNC2eN#SYv7ZwHfQ)BoOJm7KoMmyxaB9MVxfW(e)2A2XER
z@g^CBB`*rHfvj-=^?6-fK>c7yUmMmDetuA4f-n;k=(3<{$XT=?Q@}l2!=Bug(m`g6
zv)oRaElx@U84i+@xCQDSgK+PPTf2`r%t)!{WMEKY0PQ86ylS~5Q{n`bDVt`nI54O%
zaF%9WFJNG52oJj&+|y`qLMZ#k-@Ea<7p{N&xJ<vhet++cHRayN8RuVKxZ>5~RXbKj
z?^-)kJ!x66ap{pWbEo=TN_lhDXr}tsBNJkLCJ9OIy*=4k<)l&Zkx-*Im3;56hKgzz
zFt7G8t6!NiackGnq-~zoCZAVUn_RtByKGX_wd(%)zmNCM`E7k6%WB1|by{KXRz2Q7
zuQopNvfnIQ+uHCdAFZ`7pKpIzbuKI<_;vHM>eJVX_8VutowdTN%T?q=+OH?eZ`IWO
z{E|?uBWab{T;)IceT{3$yy>l~Zr5Y~?u;;X2xSaC>UHpHeN6e`JuXonS~M$e%5Jqy
zm$sS|wzyxgM10fD)I&cHoHo6Z?zXf~{2W{4y2Z@5ZZbKXNWQ((#FF9H?}jM;^Ye1O
zZcW`*^Ih}VHLbN@cPS{TIJ`V}NT5Z%aKpze=gYga*5{XkSGVSFJNK?@_4~Xxp|Q88
zoA6iP<%rHv`#m9yvA)fqBe`Vf*KfOGuV25wAmpLQz~HGS`F-#A-@ktSiSPbgwff=A
zp1rr$np|G?ZgYXtbIWud9^M;MLqmhS7@yC5Uogqo*s#IuUDn-eIj2r43G^6;Pjriu
z*?pLEW6)Ahl}VusDxa*qC6&8mc2*1HqTQ*7yp}Phr5Sy5nWD1lkjKfUddt&K=NK5M
zbgF>H1HbUwysvJVIQ`!9hRHj(2A-6hz4@BaIhlpAzu)hb&Us%wDb!JG)uIV@@80J=
zKc}`dtDqrrqp5aq3v-Z`*2==Ww^l9p^<pp$4Gk?2Ra$p?BSY4r6)Uf{Fo%k|`mJfm
zTC`&CyXw=c_ILe_)@AZ_(A5?G^tyh(-CzCb)Awe**g9*o@Waph^xmz0GRc2tS?uSM
zpS!f5EtnkOA;dDP$zg(m%I*CA{@(5LDx<6Keck)M^t#Qw^mzsA|0+!i|Hl=w=-<;c
zwMd_nMjK9Romr-ISkYK5Q$<HBHE5d7!I@@;X;L$L)*L%AE$Ph6rNLe|g8vH(b1O>}
zchx_hVbO9d=&)$9Wkhjb(4*BxYcAeul{s{lWv51g;89PXX@!TjTqzbi6KrsK&VzJ|
zM`=9A4u#2VFV4IEcShp6uA7!_nyp5La~?i#oL8~(!RO;b$M{*)jHXGfK5p5~S9mH$
zBQ12=RR2t+bxCUut)5uPTEP_;Fg5<}+OlP{rTtc~sGphl^4622aJ{pW4QF+)owjw;
z(Wpfq?QD+Qu+E*cK5aqrvABriayG90hJF!(55AY=y^80F$ZzlLdzSj>!qF;=Lu*fl
zb8T2SZQ6w!o7EEgWh^TTW8QA7`0-K9=10dj-fn|48~kpk)YKfeVV(I=i!J@|G_UEI
zTRBrRI^{E6R%`654~^Ff_`%`dHC5z~(xmY3N|VAw6b(7Ol2&!LYRwQ$aMN1jl^D!5
zQzK>J#FR+aDG?k8+#DlWQ$weQF->Ed7P4@vMuMV&!2DbFS1$X^G`pSKXfTPh{?_XM
zuX9&tUB8{}<!bNIHf2%Ik|UEguyLuiW-aMiwOGjMWU!W?scPVq&ib&xuz)FRM7r)U
zYHd`NWYK1Do3g4+%hi;X>42iqQjPUL*uPy`;-|@Q>(#c^q3bV5OyKbhUD7hm$#<sO
znMo^CA~qe<fg!C02Sa9TG&*rwb;A5htrI6D9ZZ>jX|dKReXe<4GTpxd3j|MSgPa{Q
zVSmW-m&&0U%|UDG8-uluu!(jyoLse9Nh?^z`P1Z2i$8_@S+xFO&C-s8ZOe3nC7p!~
zla5Y{bkjPpRKhS->*$PG&Me$o{wGdOohET~n#3BNC7T8MPpv+ZIyFqkEzBups*$nE
zC5e?r;?oQ^N(L)UHfoLUhzso&3!R!|5V6QDbf#-ZQm~@U#*TwV3+tOEoLR~F%Tw{{
z;xNw*w{y2G3Y$1dr)5)P(0f*;{#P;8Z})!RSKP;>o!#{I7KeiM{yhaj|C(&Gma|?i
zxoh;?^3-(8bF6`af)_hl`0VcFnM*t_$Zcs#R1x|e8v1qH>Uz_x>!G>X&-P_5n>MY1
z(Ks#bwsGTErw<eVKhw}wIhCzaUr=qkK=<|S4-8C9{rSzJpyoP*0#gsO`&^-THU-e>
zxC|_{%nKM87)vhLHOhyE$%r>F@G>xd$yR0HUOh)O)c)4ISu;Zo4H!)Q^FxKILKsp`
zsQRDu=+wAyal#@0kVQdhD=w?e%4Nz5nfQv?fk9-Fr<b#XMEmPi``#|Nz){a|Y1)NM
z56yV59j#(w9Et%;D~<NdjClU7NRlmxr)9kb14r_n&u5EQTqtf}Fz=I|Q~LNkdvpN<
zn*n1_vYTN~Uhz4dGiO$dfbm(@MKNp6tV=gGwu#d@b6$MTa|_Aq755k{&r95ScHHt@
z#dA<U)AC$F>7D0lp<QWteBJfN#_pCf505^OnayykD@SY5-n(VXuH2fvQ#nz0h0tb=
z%_5@ZdA^fV?q2Ghux%o18tY7#Ro2p8H*<U^+|b;(Rd?EzT(&DAvm+K=33Z?4l9|QD
z%Qkh^W!0&h)LfQ$rmdZpDJUqM`)O_bnvdewEsiP8f0NuBWSbrN%&^_?anSM)kL#zp
zuUT#Im|fz>k=X30$ezR*k45Dyp46CzUt9fg(ldFf$!q#=zWG*eoc;Z}(cU|i+P3d1
z{@EvPP5qfH8Mvl@>+iUuJ5T2GDgM-Z`sdQwZALY9F@}>LHvTYL|5S_n+2o|OuuL<x
zq!r6Da@|tX+ODK^tl0G9X;87zF~c8^r>r(it`{@#IdfX#n3|;HOo^k(Y6-_ej;SRj
zD;?trHk_%J8ga;&b>@s|Npns`T$Nmy9Q5n(+|pbA5<4Du`DI`0?x{Gndh3=?XD{%^
zg<RdXE`9duhRO);s`Js;*Az}!9+N+><y}GCx7*+D#r-Mqyz@*a@O=NdPy3QqZ<RTg
zCaIS6{P;ZXdV>uIKRrk|beLy`!NWrj4!5zh@gF?Q-Ok58{SwcF3#V58&ib=W@AdSz
zTW8GpdS&nZnV+B9R4=wE()oQ)-}1QRj5DuJ&eStZ^IolO!j~EG<MVWx&j*f$KGr-l
zUElDy&4<uu;z9Fz4HrwSRk#rFbH;qJ#Bz82_H}W^>t&M8nH)6^t-rb1u*X=`GAVPC
zG1r@0VS0w?7RnM~EpvXJi#Voh)a_x)>V1C8)nh?Vwr*Q>chak}Yc82xYPW72Iqc;&
zYszG~nopm3GQ$i*Gn<+d9eNx){<$jus5$@W>A7puZcAFNku)(d-ncEv&*`y!yM)E*
zc{ZPB9837vQ*d79W3rq?VdwFB&w|!t^?U|94xaC~;YplflPu1Dc)nbXPm+6^Op;8=
zbOrSfn{|$S&po_5PrD~{zFb9^(c)u<G5pORK7aiDQQ~B%es-4G+7-tvPB|7H58E0Q
zwf%nh)fpYL8bCw%oQkQLnkv3)uDEs_72PP7opS5e)MZ=LCMImm+%jd!mP?T)^<YY8
z%?btv_Q%mtmvgh@KW)ujziid^?+>lsd4LRIm>ah3p4no^xHY&Hc?`reTbyOslmDc<
zp?t$B1DR(Ptc#{3@TJe%^GS&1^Vt=*dRIV{LYkf+UhfKU>$7*ot-auB92XY}L&181
zgo918J;|kq*<yQ=%fT#W$kY$qLeM-Am;-7R!!dZKXriDXo01Z!HICXm-YF;qYBhrd
zL6b>OTpXJP1=)Bc48h8k6b^PMftu@VJoOR=2}fL996LHXnnAN)f}jSw6ZmA*xZj*C
zCp^@g99mR3oE(jWR~1apx_b!J+E(Onb}(V!WMGO7wPH|nU^&F(zyJy=mRBna6*WY_
zGON}-1f5bkHUIwSpYPs3{=q+QZ%uaY=ZDv}Y1>b*dT;Y-k00a8Y`OY9^U8l8JbdKw
zG)~DHv*M3G7yrtBKlgXF`>prqephQpm*0J{<lo#|t5!W=msl}#<_?B4XRfLq&|0~w
zfv5QVe67z{Lql)x`@1%O)A<dud4A0Q|8IU@^W&$sJ=2=#gcGM$y^6Y3s$2c)&;EbY
z-`{tC`SJISsMhee<vXjV#_o?_^7H!o`hz_`a-J`iZ12wIeE+yFulnb=-*bKx?|mEl
zF<j#1gOZx?_D2QJE*@BaV#SKp%-fhVbXL96TCt|)sq9;yLcfYh413Dcqy1F9RgabS
zoH^~lkiR-@YhKmsFjN1^8+VhRTT5^GKDYN;NPN=WJ9lE&WQIR3)6&wCKlSHt?)#lJ
zr{BJ--}B+?%Iy2$x9{rLew{h5^7_uu(9rU(^}F{Sb#-;V_5JSNy%$4WtKaW?3u;H-
zdcSXRXlS^W*uv2G+V8jdu8D20`3gE_|M@(T({pd%U|?W~Ib&?-m8QYn1xmU*(zrBd
zEP9qE*&md@-{x1Icl7%OIwD08K6iV!TW@B}zL`+JLS@nu)s5!XpU*QeFsi&>`|In;
zGqX=V6)$pNxv!%tJz3(;tu^<q6{@x@*t;q3#?{HubI+drd0ym90Auk=^|&ani5?D8
z+`HEZJx=u8Ccbmyw&#^6jXp<BdNS*B)TA4;<~+AxV0dm>`%aFtSTc-V@6Cs|drqyq
zb7-@i%M>QZp6ZMBg1<k%znin`wv(A~yZQ5}21gHQEt6;vi%RWdJe8IfCBT@qD0Sfj
z-cauXrmR`f4L(~=doW!!*}Lk`>o2!WL`)cjf^%-|o6~=Me%$rF*Q>9dUBZ~8Hamf>
zCxE^B{p?$x_f&0t!T0@st^3?7E!EH0S5%n3@DR#S5i)IZn6&AGMQr^$K4Hs;2g;7C
zY+SYRkazKU*8fYDR@A3@GW>h%ktUS3R^e)fTEvmdQdv=sof(Nbn^H5nB)YaLm`3_`
zr(FM0Y&>JLT1v3EMCa7wN)HRWUiunKMy5Po8mng_vr251<BC)5l10bdW@JvD>^C8u
z>#?xJj#G=CPMo^HFVwqhrIlh>y|VZ>n+I`zap^iS$9p0kA3l0muvuK(=+uQHJ6`m8
z9t$;WJvA%oWS@ncjhaoB%SXOAgBKE+aiUI_JxnD7K0KZlap^MKj3<|u$Y}QXM6CEY
zN#$wd)QK{J4?`<D__><?{pjS$jSjOey3u!qclA=E?Io|?X0BG5bav)qV`H6Dk45Vj
z&9F<9tEsT;m*}(j@R7Zlvss?cuwqWq!^ho++uJ)ICaqOHnozbaa;bZW&x*2bkqL*r
z+{IQ)<O*lph`1WLwmWmC!G{Nh6}vp=q#bWRd}%emykL0G4d1py$F!qnO9k!t*=F2x
zqfcI<@WE<{9~^3i9|}{?8oNlW@ml&>b<+*bdcOzm2g6S=Uvdrk>9uJ6p@|{(J3UrO
zXlf>EtxV7|Xfa@8IIuz2OKOS<=K|l5wIK$|OopLqT1yVCI<)Fw7}rJti4L9yBZf<^
zA*Wo!_WS<dY;+ntAW&~m-_fM~mD4kR(Zm%2Yr~qRsp@!4og&(?C}P1Zg@sF1gC~Z1
zJW`oauP7$yxWr3MqbWnHHB*)8L{Q+j6^pK{5}E#m%Paoct(?ip$;oNS5}SDr8=O*R
zV*kqUZ^4ePouPUh{}%LVEqNGP5ZcjjRcX;5tv`V&uH1r&UYn98Yf3ITEVO}PO_%$_
zQz;2o*KEx?E2cWLCs|uqKv{8WMzWGYMnoWQXfe-W(|T<~hd(PHY)n)O;nC%0G1BTk
zVc{cT5E9|j&DhHFwnL*JMAiFb=!^EZ^*uWu9w<8)&Ag41Inv|*9gRi*rpRp#o>W$R
z-sN%Ou8g&plc#QY8^+|=lfeA9@bQty=d>DB7&vQIt$w>Yx4!J!)?3@|y)T9YPwvbE
zzqG1C<^LtsH*NA+wrR%M^%Xqq()$@06g0m5FbrT|;BsJM&^X|4!N9+y)`)?DL30AL
z1H%GV28J*n2WE#uD;O9U<Zf*UneY5+)sC;VTnr4{i4L4nOlz~0lN}Z?EM}N$a@pt9
ziVF<9{+B~8`L0^#tjs9#Uuzy{<>}<BDvMTB3h)Oj%$hW{p239KL1dDr*1}#lAD{X6
z);|pYEwE@|Oq=!3?_19;(y%<hz`!7VPI^x1^F4WD7a|mvmmcB}y<={XS5Ua;Y4whG
z=5paqixbQoW?iW~R{(17R_<YVZgcFpx#i+H&uyO1fYrjqa~{0jd9Jv5-7~%AyWSga
z4cu-C;?+O5Jjb_t#<_LhV=9v4qED@vx+!;wPp_-v0s+Qt+JT~iVI4={jqRu-5ltM|
zR++9^a@*5wtxMRA-lSVMO_warTDW2DZ0C&Crcx)R&6aj7TD$Gqb#3YR+jpxQ-Z3zU
zUY{E$J~v<Y)~%hJb*CM>vN=~fRVB@7@!c!$Uc9NFctdx|qBEd#9E^=-uH0no;=Q|h
zccJ!{utR}sS=J`SCEZ$O9il1O6{^0$Y_=At<-H=8ElZ?Y>6UKNwl1xcDkn{HU3)Wv
zPDMrvdo0Q|nRe{Rjd<V0ZE0#NXZ9MWot^r}`;VpgnYZrGR_t6_9Bkx!dvedt`N!uh
zc^o8fY*${tJv$|>;PRVk8Ot|D=d3fBzT#Y)_AO_F!WGX}#0TCxFZb@vn~l4^b8qU;
z-Ieg;^ox@==W5QeRL)%VvHMn?`knbTR%I$_vcKn59(x?xzB1<QWPbZ?r}kBsy*=7z
zc;fdRt9Rw4cdv%a6ovO#-%+18uhKM8GImaV+F|M3Hnznle$1)YG4Y?2D*4=c*X|uM
zg%|!UcKyuvT=Gu$*7Ux#X~&N(NzdJ`{c-*6-_d2t+m5{c-MpzU-ADhh`eLu;GlOrw
z`6j$`cKrR&n&`6@xo6(?Bu+Uj7wK0y^?Tu`#m{y}PuX?j`TE@B>rNe0ZEY=nzw`0?
zvzwosSsXIoWa-B?$yq^li?u51H|KsV&VBSI<E^xRcGf)QBXgd)eA=}4!sFy!bNpwv
zPEMRA&fak)aC4#8ryd>uOy5OMBv!5NxUzZuo3q=L>SWb2%tAM2{+t>0E-PDd%T-Z7
z#;xLanI0KEy|`v_#^tixxvOT|7mMtetUNt9V%f#zAA^E#w{N@7rrRF%;Hu!Y$x%-A
z*&)|d{SMva3N|(|HWo^2dF)zj+?STN=*(uX%{-UZc^>CE-BWBSwJ<F$<l%}nSyOvO
z&uo|xE+Mn5*{Hc~!ZRH;uZ_(;MJCfUXPlXAv?fuq>C72#L-E{MiE3&Kb8bxfIpytU
zze3AJ5i^5kI~hCN+|}1v;p1wPIBT2S((Ly!P4$c!7n&G-yIMD?B`KTib@Ti%Bgk^S
zp?&rlr~XtkwW|)V?1U$+{Bg)8RyI_BtI*zee;a<BS~=gizjBwJez?&Q-IisUdhdRh
z<xWdBj11a*_Tb**bGxVPxthkgX~9|X%(6u{Q`@fg9L-WYJIS!;u|?>%vl)?#j`6Hk
zsd{iZ>e%Io`pY~KiS37b!aZ-T%~%^8Xd)@Cb|BZ|+V0r?nQxxe&aZfS{La}eb%tji
z^O*eo@}^gpy)J$ETi?mK3umnf43YBP_H%yBrtMEv>&kCt$J?G-dw1>gbE)g+8?Tu2
z@m<b`a*JKXpV!CFu-zth%Vh7zi{EY}t?4;>?_Oz*T;-2HqDLd*>)8}1?MUU*(-W=h
zUuoi-p?^F4)rwm?Hd`rg>Uo_fbyt4d*;Ut9yjXW6Hp}+@_TBHMK4Z7Jr?0x&a@~oy
zN;fwyzxQSDg1dLuMrP}rUXilqXjxA8*|M1#{t@jtGgnPo^L|I)=dCa9+%4am7x;ax
z<j13T3J$*AE^^qwaArI2d^?+X?Rqh`c+*cm3m<)-7k+&2qrKCU`>dayTfObrZFR$#
z=%dd)(zM$?m0Zu8ThyEM`~A#E&&0eRonL<Wp^Z^+l0?e%Thnz`eb8UCY~oV3M15o7
zSAl8X-NsXIwPb6YjV*h)_G-3SyiR|{nQP2qTeHf9&s*9qopUa?Z(W$S$eJrV7u`4=
zS|55$tC;8PVk7I`+tVkjO`nxhxUB59?2f0F$JMk|BUVm0WApLRhq!Hzm!7lqwyZ3Y
z%aC1a(HnEYw=+wtvUT6N6`2wO)o(gi_bk1->Z<0}%{eZ)lZ)n*vu-<Xz3%c-+1AZQ
zP8%+5NKLyMyiqqpEoIj2%m!Vzm4U0hW*z9<oDuoHeoyPO6|74#y?;5@%NzfC#e1$e
zdgE2m%VBr7-e5YNnz`FtD>BT}Y{jiCA<rdOCWUNUy;?gm^+<=v$(2&K4Ck<a`98aS
z&E038P0q{sZC!1gm8-3IRz_^nhhq}!b&mHuvMQdsA+6o#M8>5!Iq{j5l@iaV9NoEi
z?x~qEe46oBzMnl>|M27c*-th*+gY@mmCM{*^j4-kr1VaCfy9}kF+cmXzPU%<@?N;)
zN>b9AN9%0D<}1h5i1|ED_U2h86>_X6Ds+}z##@e4A1qca|0?(Ajz9b1kKdpDX`SV5
zFRL}{$h+IUnb)><uFfoH4+}YNQJBP6C$r&X`+UiVJb#XJ?N8Zt?n-pMW2sbBPpXe0
z`@{6dcA^!l=XYIxlKres>B+Stoj1<p8g4k1xMan#V?HLXwXJtA-ZB$(+xE3II@;^@
z`>*$prerZNFc|w9d3ps+3YxNnB`S1w_V3kemo8a3<yy$3lhaZT3TLj;?VPezXJ*c^
zH0Q9zD%Y-DI~i$oX3;c;{T(U~CjZw-TK)d_XY0AeyVGu4fMz|aR&6hspnA1FHGE#|
z$<pY`(C5>OV#Dr%mNb5yzJY^HqF#wd0@7C$NH`+V1nNeDx|ZPHEVu_LC<xv5E7&Xu
zT^kAMeYzlKa^6`>9D6-c2t26+>Y&1=bk;#vWEw*HuaH?Ekb);J-jH6gv^A*X`y1T3
z1mA-JCicF?-rbgdz3%tByC<3AzFmFK$rLx;UyDt?KJL%HyVvt}7p~)Ea+sj{YV{5e
zA(lqvOYe4<-f=8o@L&-78hUT9EQSjG?D*@i-+$-1w(Qod+bO=uDV}Xovu1KCX8!(m
zH+a^wzti`gs6T9d@8i4YWp^yk70)ld`n~k|<F9A8-(Ma!EjO<|?fQFto9DOY)Mxl_
z$?@9zhQonL#rF5_-yeVHJ^uBtzV6Q--KTEzG%g!w<YjXzZhyd#C;s}B{2m8~nc1w@
zk0<*^uFiR1Jh|9nli6wKIX~-6W*^|6^MHLXf7))F>j$pQTpMN9x_R%;#x)Arx1H}C
z@bIm9U;aQS<;<BIDc5dwCvTCMa71Fl$;rlv^*?jp?|Oc``u%FDeKWNe)hT`NR@aDR
zP3gMk)WTrSbzs?TCEIs<5Ad%)^>^>b?a$WUUtnH({qo}{!MWE@+}V4v#8toW-U{|y
zzIhBR5?-w4o2U1Nt(7@&xH%)*^7Ia=*aZx$SQI%AZfpqS;<<Ka1J^;ORZYDCjDGC;
zqM@OY*{o~od7tZSyPdk(xVzk_c<NK`%ta2oe#LX7F1l@DmD-Z+8XC&V5Fm9i)NM=P
zT1L0EQWqT^9UVkCI%amP+PGb9anVMVi4{vc^;pX;Evk&1X>2%4ch=T<zu$va@T}VB
z^Sr0`R7keo?h;j-HDRh7bz5gBIhhNpDV$W__xptgQ^U2cdQam9r?~4UKVMf{TwKMt
zTz6YiQI>h`?#H=P=I6aT{rOnNwybN#dtZSJT&;3#&&=~e<~G@jn;Qg7D^|Ro7cRXi
zSKV!cvm_VK&wJB8`Ev;0FJ7>Ki;?TlsoUSbcnGU7aDr}BWBwEM-*;yC=UdOVo865+
z9{%}z?zfZq)oZ?fu8)iMxDXwD=XvV2%UQ>Fe!p8&eZM9?=UkEX>({Sq-1lC6eec)T
z+<n(}etvlOe5UXF%DeA*KA)F)K9B!blW6D<g)Up4rP5lfwry3@7P;ANqNW|W=&Gcv
zY17uJsc8nC$_`tDR98zKJD91v%IM0>V9lkvjawqSf28J=X>RC@QroIspD8)%&8sZt
zEY*#Ld=@+xqrIM-nwIi(YR|K@XL>2?{P>p1oVgfm(wEg|v2Imi!K@2~5oaw^&t^)u
z>Rg<$GqX74(UmeGYte**fu)-2p6p6XEp%r}B<oln-k4*U@F=n8;MBIB$kR*sPFbew
z1UDVc{4Y8?FwSVT5l_Or*iCy^@2$U>8<7~+)4M!5(`I#WuhEUmmZyv|C#OxGn!fYy
z?#R1GLud3{lsk6hX==a4Gq=MgVM)G^*erQ2?Y-l4E4<^%vdp8CH)oxh@!&c4$xGU5
zpDO&49zC+KIGigPq&p=$q}b(X#ys`ljk(%uV!{l2m6v$WQp;-BI$Du6<;IeAiD7LT
z_3IX_KC)6yG2|1A_?Ns~w(F5wRZi_*9<%6R-(AVc#=L2XJJhFEhFqE*cG_Uy)!oaE
zX}0qhozeTec&2pV>RD+KiAQZhA3dL^6SdRLJ9KswL)VgP(Q9w(-rJm7#Tl`)q|jSg
zw6ddr_a?JdKP6TjY+me?SHdT;BQs7|@Y9XwPEViL&-vcEHNvR*;k+uVWyLFgExB%V
z;7r81n28H6o!VBaczs{qt?kp3HU~>wIdLPZ_#Uf%ro7bBqlwMW&s6L=DtV`!&$w0R
z<X6ATS!q+b=NwhLHm~-9=Z7$7vD+?_T&JzvqAR*SY`S;OwO`wI-CY}W$H~F0=j4-T
z{+(C4k}B<%#+}?+?~^izkLzX3iJ42MZ@HsAYew1H)uxA9P3M;Tt(nz*qPT1F8rG<j
z7H5;(rlbnh7%VYU3~h2hq4kT&{Yr@Y2`By&UJd_ecr_di73_5C@mP|irOYVC8q8?0
za6uI73YRNOW~d~sND4`qxTM)r>yXCDAk!eJP@WE5Ep7*o3qppPUiC-0!q=}2wX?T-
zA0GSc<GSrRJ5)HC9HwvGw)Ow5RTJYrD1`6TnzcwUYK_V?PMsAVr`EJ;dj+oIiVE2x
zBE=XX6s)y$f|gIK%fk?r2a|j~LL@>|r-<l;3T#=VlIS#bm6yvO7OkV4TJxotroP;C
z%X34HR1|L%ugF@BMeALIQ>JaKUvXv0QkO{YEZv?k(S|k&H;JXK|2QQK*&0hZ=5TH~
zvsvuwmZK}$PU(Mez3sJCD2H2R)kBdIr!(7pXBl{InsjNw7Oe^Y&n=KY8vZGaHE63_
zsAf;shD&OxT&HHXtPN6?RM_7xa#5lu?NVCLW-UoJNoOOT=1_)Bhg`0%=uMc|a;iRZ
zZAwntW>Ig6gGn1bCU%AEOgJ-1{nP57oIgYLFTUDry5a0>pR-21(I$yYA|#HsnfOKv
zN4goE@lLxc)h+1EmUVPRYNs<#qQn|cu~qZ4nloq2IBjY+<4|tMNh8l>E#_CNDrO`r
z957lf?CP0tOyOvvv&*+tYp0#@W!%aZkm@Q?e=<m3C}{2yw=`u}w*y8>R~e0kb60A*
zw@lR9H!(hb`}HH+%V+rB`?&j_nYqo!-F@$EwEwM|%Kw|m{)gtP{_Su7_PwhP%&$K8
zz9M~I#dDi4eD`1H-Ay;14qmkQXLauH(5?SNqpoM&`tzqQ-CA#YbQ5UIxN6m(Rkwcq
z6xkYCFX$c8v2>-N?<$umSCzc7CaP-f|8tZzWu|Yc+Y!MpT<=Wl7#JJ^-+oA1z`!8V
zz`_vNaNxTG<NJ+iS57Nru+GSc*2r{VU|7Gb;kucry92X#LRQ<Y1_mx!S<65M1|jAt
zU%$FLuRZX%`ex#HHwKXf3=AHOPK{m{S4m~CfG)GFUtwzFxKb<SNRq*nFRmK%SGBbX
zD~kNTG-cLe1_n;spg=7XlZ?y-YD*@qs+!5zx!4CZW!EdW$l$Bm{L^0yfBlcIj(Mfj
zJYC}Z-nYdo4jZU2FfbllbT)797A0d|uct9CY0{2a+$;jxJMs#z&-*TW?D44=t`3=u
z(Q?I&bIWHRsOKvVT%2!tF5i3}L;%i*%oX&5M<jO5d%fpaZ+7vV=N4A)l3rD>`*3W}
z)$Kh28;<gZ`KWcRSd-LcD!4J?s7RJ_u1kn(ZpW33wMmOpt}R*G+rT1rG)ilc?usr3
z9?%w;(2j$F8@G5TMtkZmyEN@$z1fu6zDs6%+)_Hrb8zhz*IdCZ+1aW=$+;QbQOXgk
zZko=_-Qv1dusb?CYUkqp+p8u%P&j(`c=878oi}7B-P~-p%`|l5hPA75CT>`ErME-%
zt*3Zqv`TjFmQ}2xN`aduZJTs#tFG^Cg&Q}f$}V-xd%ipG>H+5U))jH3m1Wy@ZVWqE
zKRau-7PnDQ^{#dA=1wYGbxR>lY32&OcYJS;>~>BFT)TG7wa_)Di(IWW%~WpicHP>x
z%FONBsooW5wZ6F>x-Bw0hj*&uTEUbpr!Gy)a@E%T<e90d(fCLC?;P*+XG@-`-rZR^
zd4{pmepCBt(cAS6ei}_rOj~E9mhd)oM&ZJE_uV(^pYPsy_r2z|wav>^ZCi~!KR#Z)
z^F*w&mD|K;y~_+%XR2El<tpUl$VYD3W;wm|?r!H-SM)c(I8_to-YdKIn3%j%>Evv)
zV|F#QK4%S1R=>THlQZeqsy!KRg^PpxC5}m?28WhwzU=1p`a18Zw3+V0UgZ~8Yc6jt
zmtDUl=k_h*#}n)0%5KNpDHZ-~6hD8jdt|P<&!U=4^%VIv`eA8|i<y6JTeYWFru6iL
zpQce?uWh@{_pUc=#g*)sNn2Ok)HZ(oQC#a4tJeXpP_J!2CvJaeIonA4Yv5ApyIW)L
zZfbw#cJ+*P=uPok=`wTsr<r!XvDhj&ciZ(mtJwK%`)Az<f4w_t|GfJ0yd!mK39;L%
z*2=B1bzAsjwb1g5t7^8L{q%PB;mzVkxAt5+yz)ubYCCzgTG`Kj+Psptw;TQ5am$~3
zXHm_u*UKeNec$zU)tR&zXL7=J$W2|<op#rK(dNyCdaw1mc6S#TeYtaKR^`FebmRAX
zK21CLW!m&qO(UbVvn^_B9&a$sx$>mG<k*heT3)YmFRoZKRpa9Hw5zqzyvrqzCH5sf
zp84FSD(2zssO$~Ci!)|jjh!7I#*-bm@mP$GW!H|+cEt}r{hX$5&h7W~qIY@d7M+vv
ziDmj5tJyQFL&}0vX1-NtThsVBcX#Mzwr(}8AID~{ip*vUQ@t6MVAh>9YxS+*<|v16
zKJ^(9w{uREP1k0f>~(gM&uwPY$i~S+VJA*a-m?7q2h*nCx!Z0WwK5ELH#XL?H}&?>
z2{zj0ck1fY9!Z19YumO>{_JKX)|%DZa@%|9bmi$5e3PxNUHelK*^^~(P)96N;v~;1
zv#h>pp%<R6OOaLoC?ftct-o*e%q?e4HoMD)8)wd{7Y+VwwPwz_)gCbyXL8Qktm%2y
z*t>@>;xqG^Gr>k@f{&b>*(PFf)ScT{{LHg3c0SR^4965f*MtTpCPj8Vi#geNc+!rU
zUS|wW^7t%GoH^xC!kVt#($N_wRx3_6ne5Y<a%I`EYq#v(9_JkCY41Gn%!}9XE!UHi
z6*HFXG)-H+cvt<Eja#=#+`6fKWvgFqgYBX{NlPkwu3f${cXRHHRb9{YQh5Z<9A?rF
z&fC3YcXM4*jZd-C`q^*%dj)oPo;&faUH8kOxX-n>zuQgwRjPbVc;i~pY}c1NbGObi
zKHOUTSvCCLqj%@e@B9>>W*GQvmCPYy;nRvYvob0Q)}<*OYfiCwTvPw9YEs!YgOh2V
zn~ko9X(avHaO0Rnvc#Xl<`r*q3>W1tHCUF?yWy5M+sQ4<mbGNN9&~mz%`EEV;82iZ
zN?qo1_o|F!+gYvGt@2yGea?K^9DeHi{rJM*wD9#-`?fZ%$!5F#{Pgqby|sH)-wT)K
z@|q=0;qaU@V?~U{h37mbEW&5@)+atVF0|3^_vsCf&F$^oUv7(P`P*%DID^OK;bEr@
zTfGj4wzUVVO0C%C+jYrns@B8>^3xBy><`vI^Hk>TareB{-WyD^mu;Kw>-RP<M*mjc
z!|l`EU&n=f`~5zD-^x#^Z#CY=y!crw&wV}Sjmg%vad}6drWiZk%({@qs}ptQwcDYq
z^^s;=Zzb2R&y!k~V!0-Je(m=?-)+}tm+!uN?_$zCZ8y`qTjwmVJ$5xub?4ESxyGem
zXP+#Zed|uq7T;pSe)r8aGd_OTHGVJL_j~tM^+<iAG`o45Z`*{N@tZpHc-*XWuV*cK
zw!GZ0B0cTVqh~pD%icZS-S=jjjB;;q|J)t5d$ng2)^{$c-KOo@-+uA#<cHmCQX1JJ
z)6d?$Xq9tn+PnEm^G$kA>95%Ivn}`Jwax27qmG=rQ=GS3Y|B+;y%`t8u4~;0_A8q9
zZn~cMjW@oFk6tZ4J>74fxmowAtIDQ&$EIpV2D^5vF1xho+M`2ZrbbD+OZ_(G=6Xwg
z=Sy=pH9ntvCgNCFy^px*#$!uP&62nxw>jagbJx0;JBuodP1f;cC-(;4PW4{yF7c^K
z^Xbyin`e)0oE~_m=t}eEnMbtGdPcUa`<A;Qa%+UCYI!+p$x)BkAoGZgGY>qSEVGj}
zYh&-U&8Cr}jHV?kwrOYSuHNdFa_LISVdK1KZ&SD3&OI6IwA<-y2+x{&k6ee%LD5-9
z+q`^r*d?^|lDN)##y181>wYF#XLhq!CvtJ_YF{O--hk}wF}b2;Th}=Y^GseBb?9lb
z*Xz)0cUP)PD=s;4a?RAp)wvs&Wtn(yDcy4F(T-=Yj=6u{b7#AG@;TX!Ya?fCWmztJ
zlBap@)!K_2V`Q_!&D(4a?Wst<cddSInZ=G%vCk`?NAH@tEG;*9TXf(u%~cz$#V+ls
zC_Xjk%yYGV=DszbdM;(no^Iuy9rH4BiEQx3hvz1HK6N+hExb~%zArD%`s~Z(bL?j2
zGBd6HEH7E!o_RO)#<|lL%l#hDUE7^<W5%hMk!Rjr)t)^gcWug%b@L?O%4cr4F8lm`
z(&~Eo^1DY$J4<eRmHAwpQXcTo;O?rn!o=|K){GxAMW5wWo~_z4^Dt*mvR0U(#HFRv
zt=to``&wke4?p+(GGD=Rs@slN_7mTqJqa2)d$wBp>D8^1yr=0rUcKXOYne`_%=4Jz
z#)hfo7Vjor?Rj%!r?7h3<Gzbqbz727?b6nsvyI_Q{mGBl_vOuJet0mvzpZxR2SGza
zE2bGfXJ*chdvI?7gXqgc#kvO5eQx9m+*!P|XRFq+H$ldekMB1>8u}<aesR{a{>J0_
zvwkFhlH25+kg}!KI_lc#u#Hm<muMa1mYS%$ZP~R`Tb_rM9v5^xS|>j@>gV=Tw{At(
zd)G}l&A=eJY^JJay{1=C(4;AA(hPg0qUPVTnw4gl66|Gk)=1Fh)~wB0$;QUcAy-Wo
zn_QX|t=n^S)-r=rYa*_s8J#(sx$SoSQja--_CHj=+kd<9Zm0ITbxlnVK)a8jgGl<1
z{<`si7gKa}7$hlyfx<!P=3?+-X3+Q+2t$U=1R-N(N=i!chTRg=_p7pqP2bJI#yx!}
z2OD4g=LZv1IGN)0r=LldUgrW@Eg~ogS{s74xC1nHwi9ZQD&h=1&^G7m$r4*@e%zd+
zeZ%(M?#&kA8>*|V!PMRIw1V}=C5}l{gU7%wv1%@K)GM2=cj-xZ6xi0dRr~5et6U&W
z(jL%$;r#72KU6r&&#t~F#IpA->I#=zJ;@TcdRN@q_qy)>_R#;eTA}{EjVnX#ZZik1
zJ~g9=OZKusU*Msg>$2mD4Ye=qkeZZtxFYNQ{l4Nk&(6K}x%T?w^{HpywXr&%*DPkP
zy72DprDDd-^#&hf^wcC|9_(yOOOH#IPzh6+FiDeZQp5?bO^cO_&GYQ`@Kx@=eLGU~
zW9f~{&r5Gy?%h4}^3#m-ua_M&T%Oo=%rIwe&L;E!NoSl5R72X*dYP6l-?ZvoHJ7-N
z+u8Es=rDO}4XO5h2A?W#@36Wd`}Qhp`rh|}YcGb*@KpJs?|8WWsgjV-wy+yf^1iXA
zQgW|euDI~v_Rcv^r#%Q4S<o6D=&O0q+e&Q0rm0sZy)nJLD`SrU=L=4z@UZs>@80`*
zz1Zx%UiFHJe4nP9ujPApm-EcA10v-s1Fo+xdv0yH=swd__WR*yCu#jw{IFPJP1vt}
z729`woE)|L(W-rZ@7}%Zdec=|pBtUh)zNw86UVh1N?R5lF<-lC+qzxMbKhQ_dNOZk
zw4m6JpEhsTo!xdXZ@0&${=B<_zwcf@Hz~zK*ht8yQ^1kEg~_b)@uSM;GoH*gyt^=b
zlKb>2xAQyKsYcE?oO{AkWs=X$Ud!l&qdRv7UfDUT^q7g`!WM}se%uTXjhGJ~;tLh2
z4|Hhp+&l53_3Fc$a;_gOFE*1bx}E#c^vI_5+?g{uRVI1PHeJ5EY?1Wrsj{9kX9w+E
z#LJ^_<g{yq#iVG)hiB4bcdKliFv(kzNnnzv%Ek#TDw8~QQYLvza;j{cX5^`pVsCN%
z*<!DMP7V`PI!#Oe{QPJ4@Z;9EwR^w&d5c}n%1W=_U6wYzyudVDa@nl3wKt+m7Oh$%
z#BxAkf(qv(22TYRmPQ579o$U}PfJ%yU5Pm(cvy8?^y7Jz&uu;*6aD{Ul|X&Ls#Wvv
zt_WNsaazK}uq|z}VOW?{RGZP%Y{gB!tHT;+u1YqXrqz@v<szn?of(yt(rcu&<#wu9
z$dcJ&K5Mgc>)9q9k&c%3|8pTcGejpln|0BFTT8B~Zrp0&HzzcD(lzf%GaGjvJGk|%
zv3Dfj<VmHy?!M~6GiRJxH_d34?A%jDuVyZI);x9Y;-!5XE_?S)*e#Ibo)x*|?Ty8=
ztb7)44LdO{$=YjMRA%U$ONDc%D=a+ZctKqu;N_OplG%xE!eIu->aF}@3{UsWOwBRV
zDW1H0<(<r<x)XcTf@c<+^+wM0^EO&zaPqj-I-YHLmls>bEKm1ddU<u)g_(w#x}m?f
zz7e`*CYrNN)!)iL!uoFDEah^+w{qVd9&K1_y|nneTyMtKcBczz>U&RCMP_Z=%I<vg
z%$c*geVO65Q(ivnwmcm-Vbha(-`QHxfzMZbR@v<N)Y~AvuivoR%~##?*mL3Cmr~g#
zFZrZ=EaRAusocD|UYScig-hfv*0^;ocxlgOw)S-=O=hp2?Kw+(R?NC5C04EFJH6g8
zZ&2SjGx*+<xqFxD#fBDfd|P!>V6&*~Qr&4$jPp`0&Yhm3`6Og7SMZfZdpy1D_noYt
zmFsijvFzD%8#k_dc_z)^nrx`e<V8N(&r7zgZMYrva9Xm=ZZYffDB)EF4__9Zv3S?#
z^R`r<&#hXj@Ttu*wkV#&v{g6fJb5#{>|Sbm<9pkevD<PZmrXu)yf02`y3B(oGgHMr
z-gvTQ-MP)?i>+23Ov%={_xaTO(34wi^)lX6#YWY~tw`AwQ+6fSDKV=1mQcLid+kW~
zFqhx=-mCn6zen^+3eVo`)2CMasPVis+s(-D_q$L2EBl^4-t$T~u_h(%(B9|s7W{hG
zzsb(z%f}dPzLNF*GICMNBIBl*g!Nd5#{GQ0YJFp~<FQmf&z17=rNzgM#mWoM9?X3#
z^6~TZ)9WmKb?YaaRs8tqX7lu`p23+w8JC~0rzFpAh_0y#`6hL;XURNfIa%dqgR_Y%
zC)RYw>Ro<o!^h6^^1$=3)zZ0Uw~aktS}ysiuBbElQjOD|4JWonhON5fm%A<6BwqdU
zp~X*ypSjNLzIh?lI_w<B?Je6k-kNlWPh+?4g4L_f@0l8Q#QjE^ME#{@_vP(As$Gx^
zKhh_v@-5nI66YkBU!k5~1*Tu<w42l^{v?#ce#a_-gaE0D8sE5ro@jb&wd$})FeEIx
z%9$wPwuCn*G?O(YWUG?TB(+8p&aSSEpqYZcS}T(@js$jv%vkC<Q7FS@{>y*z_mX$s
z>?=HTEB7F1&EWppwNd}fHq{5zs|G6mS>mI#Xk&+J!?ZwAqcxqHle!W*C6zToA_FxW
zM5DAam{w<XG;?)WhK90h2I>ZMnFt1Rt>|?M$l~(aB&gP~ivQom(5Ok1TK_RR)JL1m
zHdFOcZBt82NtzJZA#B98=9FartI*s@tGYB+tnFH~V$rn|H`0_7TMnumQ>srEnSbHI
zfn^dZSJi{qxn`ZZ={s9@Rc6N2t)e+*0rf%ZS|?WBnzZJSFH>QlpI2D6k=f+n5VtGN
zX;)`@nQE+YSyd-m$1}w%D>X>ss4&l@Wh$pxHUu?m3V*ybQ_R^g*H}9w&FdJ)kr^k0
z1rtQKWh(1>M=C`fSz_!ECYo_3TG*sMY)Y81Z{#eu#a@a=U8NI)qdfIb?N_M_*e^bH
zX5zNqlr^b5sk0XIgh>f=dm1J)&T>mJ4l>rrSf=SY;nuC0lQtaimYldo;%wKN9xrFE
z+9__=vSxE9&T>1rrJGG@?UbBQV^P+xj1O1nL>yB%yXEApu8o0>DXSLqoX8eAmcux)
zwcc~p-l?wLD!nUuv^j-SrA37e7ObDNqCKfADaGYRW0%j8#;v+5R+ue2;>oWR;{9v+
z?`*dE{l9;oynXZ8%B>skeP8!|Z`t<sal7x9SGj)(kpH)A?LV#cr{hId<*z?J-R84&
zrnc&~XeW`Sie3Q@XExZMQQ>T{TDKLP1omAGe_F5jf2r^)-PZWJ@^{JeKHu!ywJQiZ
zWjEoE;``p7!;H;rJc}kRTNUUT9I|NAvX!o?UhDrQfmSqa-n3AtgO`6g#)_uE9}Mir
zZ%$py*4AKh;kFP1qZtDOThlD<=tQl|1&mr-7#J8duAgVF;nmWrf6jd0t$~59bpyj<
zN2jPnmIlTUUe4g7MyXyi4JCR^{l8q9wdAkYOalhf;QyCaEL_0AF!`#g$g(RbM!ZZ}
zUYgFr4u=>$RVJ-sf7RADZ`u6$7Z~_&{X3I<k4fTv^{wZDA~HLU?|q*=*Cn8M`<&Rg
z2h0UcGRuxl36J8)KDDFcjA_00)Iz}-S#QtrafeSWkd$i8w>$^Bc(K&>+Pl}~rT3C0
z?!eYNnM#>`p7ZQ;B^tk=>Rs_1o9C8ilBF6LO7Ae3t~YE1ErOc!IXiE5;Kmg<wmF9>
zZPO0SSnGC6Su|QTWlCbIM5Ja@XNcQHv99`_K(~t-D~^ifif!Cx*kCBQ>gvXg+g98T
zT-7`6inPX!6}NI0Zt0yW|GYGK_qt1So3>3c=JYlaC@+XzYV8#|Q)Bt8*=EZQ>Rl4`
zO$u9G)c3tweTU%As|CDWPj6=DMIG@tc3L`0ciV-vO*x`lS>;YmigucKQ#!<V;TExN
zM<cYAa_cqCPR!ae>)O`fjk>c{%_iMgVYbAqHCplM${Dk^oK-tE>sD6QY>gbXw2ZSk
z(~Ox;c?)WqO<O<7t8=zlnlbx_^>faI|2-2@%$I5$yUlk_%KY}?E!$#_tgOEM`^b*d
z4~^7P{4TLwHFit&y`ICDaV=T3Y@0k!)b@?HP0eC1&B==MtY09$JyvNx<4XQB{`X7M
ztnIg*+;(YsX0CE|)6ZjD_D?mIoXsyU)qW~c`@VHr?&91@>#YuJuY5XX%ba6rx05|D
z#7&x%o%Pc8y4jPYtu-rywnQ6;Z>(K1KRL^?KWp)i{98E^hqh+TS6#8RIyZN-L_|ve
zd5h4WS>Xorcdy@;d~1G0{l40RH~mfJ-X2OXc-D96&8^@MYaD-vZtDHLsy!_5<DTqe
za_JlX&O4rb`GqNOx7(76ACI5zdOPu4=y%(fT|d(vynOTN7T<H}$Sj*x-<B@8$RDno
zp40j?ZgSb%ZR?)rEYB(op85Tr-A|*{3hS;4W|&`o`Q+X0ex6J5{%<=s2YMxX)~jvY
zT01*Y?b4|ef0rIfH1xl=yY$g_fA+qj*^USIr>+Tpd;RD;?PF;fA9tphH8+RM&nn-%
z?$YF=-G=VlPHuU(PA+WKv*yXhqTMdrUIi}AS!o)&bBjQ((QL8sbY`C1EfZ#)xScso
za%odm?ZQ86-J~R=W+$%QaHjL(6|)svQ!e&q)USSf-79yoYT)YZsdje_W3OwPo}M-3
z)EjB8-QMXhXD;h|yy0r{)?0>4%Xs&92K`*J*+bh@EMaBcsatKQZYa#y%ztdUn$F=~
zJ<edGG-rb|{*uPV?CejEv>sEaIAz$~%oaLbN5;Kf$hl|L8D&GxX136-O^1$D6nPX*
zjhq^m;<LJ*Dao)c$XFp+;f!j7VNX(8+RE73A!!q$473Gj&Rpqpzil#aY3ke^!3U=p
ztvSo}cFTktj*A(Nq@`s|+N?U0pSNw_r*EJ5n<c~2f|lpD`b39qPL<pi$(*|Bgfv6e
z)#&A03-az)@4a4g^}zGJ_tNLhJA69Q^X;r_w;i{NY?IE>m#<&9Khghw_RUv+XJquQ
z^0{<uQcdacH?h@z)_XpzzOP@kezDUn<=mBqQ){xfs%^b%@op#2mRSehPv5gNS@ieH
z-+{MN%WkdOxU}cZ+}=CUIWc0<0=Kqg{#>>#_uTqpao=;ir6k_<-DbOBwrcjAdDd%R
z-kNM2QSOy?-11qqwC9_gTkZ9gyCbXBk3al;Kd-Lz&Ye}?!gSW}xO)8I)ao4;1{RNl
z8JG5Y9s6}B`LMXK;HN)EYkai+np~LiM<&?+tSsBN_OPY1Z^eDQ_2%rws?5b=QJxdm
zoW9;uxApbD9eODx2Dc{XF153>`qsAVrPXQUa`9xfrPCJPS}Ud;$@*Bj+S)KiZDReh
zt7UeVYS;a~Eb;Ng&+RfbFH5$(xpq7Fxy@$V!h4m^PH#Wo7uqZx^yBlAxf1?{v1__d
zhgR)Xi=Nn}owv2P_)X@ut;ck(_2>3Iw>@rmZtJJt>THWMoq1X|E8p~fu>5MO>4LKX
z$8?g^k471-wc}f{Hettur#kZ`FC@O<OVdpbi>|-C(pTI&?(23fbCnl+c&e_3XXmay
ze0Y7fUS!EJ+0J8TCWnK=HeEA0Ri>4iDW$8DrZw-{J-?n5+f^mg7Htha6L)>`%F}u~
z-)?*OX1UqN6VIFrDwkbvT#`0PGGp~=j;#WFs@`QAL~Qa(GiEas{eC-Ia<eqcO_P<m
zS+fl{78Pagte?H*$;N~2S~D$VMR_8ot=jE)Y}Ki>lZ%5gS9E4;uiU!MH7Iwc<29ul
z-l?I+(itZswzx+6stD`H$L;MosU5|!)rc)?v#Xk6`~iLW<6o`WZs$DPc3W-J<y_-j
zwKbF7CS2T{a&eQiM}UUvrqEmKG*c&S%h<T)!PB$pX_qqCrc80I_X@qX_Eu((`j=g|
z&X|-H&F#*b8*=8tJDcQb`g|WH=j}Ol`qaa+*rlzjliM~%g{2iAZ=ZF%Z)4-kg5A-3
zY@YF(7aW|D>iDO9Ww_pI&*D`}&cs|5%(D*G4PJa-aOUZK`)o3z{VsF68(lAoIh%Vc
zCf3h%_TlxM&nze0m~_mu$1ACR?|pu&gYS3q3%$2>J`(gV=!~~n%5Sl^JMV4}dM4Yw
z)o`ZU)^5M6xjA7*FK-1Ovv|C;qV`A6x!7Ot`_HAtIH!E`4Q4&IS@mw&+SOZR;^efC
z#l+m_du-?WIW*L=>sDxJkF%7j?!>K<`uq89ZrFZLd=yYVZx71```254&RoO5z)&x2
ztdgpzGAU@vl`WUNqwKF0&Rp##WpZ=ric{A-CS|%z@)TxUl`SbIaWz|W&6#OYvwXFE
zwLO=4MS2QuTAaJ>*3YX#4^{tMnfLX-+3j6#F~^F2*PZBS2JPMf4HI$nfOgfRj1?t<
z_st`1*@4`d+R-d1{PP27WGHTLE%@X)$7VqR(0VG+Iw{a#5OjBui$q6fnIZT*I?%uk
zlf(22AYJkKi`kSEKssMfkN?VQUcXZyNeMJ=6kBH4`x!j=6W{$|xA*kyU0ttZKnLJ>
zKMno56}$mS;+WyqI=$UlW}v-K;KO;7v&`1d&);FaUG#ePqK+Mq6=Yw3#9exN>)oPV
z*BMwE81+NrBaRvNq~(Mi&GEW1b)$At*cs5OZ0W$QHQWCFuP@%ZfBD|G^>Xj^FVxDr
zt=HdQoqaj_-mClhvfHPZ&--DwguC|Vt@Gc?`idv-GIqDU_HK3csvG}ax4z%|`2F7J
zHG0c;*RkCf{rE%tYJO&Dd`Rwg-|gu#OEx=YZFTFK6uHneYO$+K-t6~Bp3mCx`nYV~
zJ<%(R`o8UukL2};Q(jkCTCef{-?R@)R<%7^^>L2v(_A~VqyY0r!7I7vTHIQG!`E*I
zFVDjE<Hw5jezu*LHD?~ro90&@r_W^X`*`n<(cey$Nk8(Ida4vgc|3N?R4e$YT(bMB
zvKlKZYgr%f1`U-4lfnxpE(y#OlyNR-cj^<+UTF~Dyz<E1)qAYoedK(yy>jo1`pNmz
zPd@HeOFCJ=u<7cg$*B<nPp5DyvCGsP+~K&m(#)Ot42N8Wf8F70(b2WHO%(l;B-)bm
zP4s5Q<rOVp+&=T{a+A9Y(rwl-2LwcCXJl3;vP5$@Y<r_|dj^A~<XHwj%Wct<p2aM9
zxxKjTcI9DH=~V}hDqJdXjoS9^)e)5yi>KDd%DUW<nzre5Y7pzHt69AnJP8M#4Nn&8
zrUqS$%vt5I)zQ&0$V<RU#ryc##J4y6-lg5#_U^vk-`&n1({n#Xr&JzOSW{HK_tmPV
zre>kdxw9wnN2FE#UR|EOV{K~A5vhd3-inO3ALkdBx=VQp1O%zh`;@s%amn7Z*JRx@
z%gxJ=)!%-4`%3lA)f(4+Sf_mPc^DLO^4|AVtGKwh<d&D6@0r{mZ){t8b@$d=p>L+I
zZ+mb!Q^UD$_V(KHg%QjWP8#L=<ykcoHAI$bodu6GZFT~UHf{D)+3e)0v!i&<bMN-g
z*`GJ&uj>M@7@W21-`>k<OIDxTvoqJsO!v8Eo=JVq-n%M(xyLO}Pv&uXxt^iPVFrs3
zOQVqkrwT*E1QpKeB!kqq)@9<Rva@-PC7!asF=fg6BQB2LGey(HBzaaR<>sso%}F)U
zG4fRl%~^HqR7T<yrHGKDLPlxLVo{4-g}tN9wzMtTblYchV$?>RNd2#c$1WT*TXtnh
zPH3*kmNUlnxyrqICzTDNEwb8EFIZ%?tK8`IEnYX*bl2`p4|$g^cxt3BIOVzCX2mJb
z_)cw@tri?RantGGww;1!vN_NAT+4VSbHVL&->DLdhdbF0dYsfK3XKW!JaaT>wT{JE
zi>uyqqSgg$c3iqjdRN(Ow{r97g{hm~HCsKk-aPkuuB>0ouJ!fbx4uz6D>!Sy>t#u|
zq^?cA9y_Bg$?BfT-mDv&cSg$Y=I4tu$Y#qnHZhag>TT+mu5>JFT~^P`wxfIJZjIY$
zQa!Ko<eBL+oh?u930JMYt2=#FpQK3Q63gJ!sCn}~-zrHDIpfS<y>!!;kesNnS;0P{
z=ao(s23<^;r+Lh<v1rcYCH1M6-J8|~XKb2TnN{#&<yx1AT~nV4g(n|RwdmWC=Owpj
z@sz1HP2GnCqV@}yZo9U1XWFHVTV7A6CrhVCihKK|85>(YUT>4xYqaLnEyIeH3+_uE
z&6)FV;hK||=Na9rxLLIB`FifQAiac(+kCD$-sWBPF;91oMzr|u+b3tGEqydMy1sH&
z<$G(MPv5o61FEwPZ&y#B7FX4mbXh!U`bPcrHAj9OO52;U@8ZHY9}Yi$6fPNP7pC&_
zT#?R?3W-lop0Y*y#p&6YS<m82-XkLy#~kb{mD)J3aO#xEB+KHSC7D^rcI6!RnjJMY
zFsx(KyxQyi;V0AY#p``P{q*Ci8=KSn`voKFKTkh2GkDv4yASa}!H;>{mbo^E2JM+!
zX|wC_hFfA=#AbD7`y4t_cKP`|?x$Y<Gf%m>1(`-_T7EO08)kOn=B&*|p-1h4_4a5)
zT|d&lS8uVkIFs4CM_(78SewzDv3laUkf7RW7gl6Us$vb_s^z{(lz*WR|4}8C`mY|H
z5-XM(s%q6I26{87c6l6CNepcb6E#>lDd40=mX@igu8^;guR<oX%an_%2BHyMYgxq_
zmI+L4QB7IFGgWK-<InX+*1evz>(xuI9V%?O+tO~Q)$g#s7_h3IH9-G?7}u(45<xyH
z5rJyUCJJ+@g|cRaHL|&~d1`DGR#>GQ#97L)vc$uiNz|lXRCA)L*b+yhkQEVA8CzC(
z|7}<}A!JqjXDv<t4>vbOn`v$A@=4_pGvrC+Ni+@hIP1ceHDy|A+Vmem?mx74v|e(J
z30QwmWv)VrrytX5N7to+{2l&XK1)S5q^#&MYMQB|Xc%!);#jb%&!VY5jCHahS#6%(
zVP`g`>PSsGwseX?{i$g@t962vvO;`LEe)O4!n5kswXg$6PAi#hx}0VZAuug8c*Zf;
z$gU}W;yeBX{jrJKIOE1<Ez?z77cRS%aHZ$w8o@Txh!tzxqNXJ>i%vMGabfbqNp4Bq
zrjGHVHdi)lM$Nd?tEO~OWW$;^(I}w`iO{gE8f#M=zN}dEMmt5cGflO=L#uw4!rWE4
zK|%8_DfDx{ULBhK<M7rp_vDl}+j4GfZms{pCI3Oh{)6g|+SP3Fo8CPvR^FUA<E)JK
zKRc1n>Az(j_ZU1{^-t8lRh`xT>yJO>GR4!=*70*Ke;5K9BVqm_A$#M-*$CsbD}hsE
zuLOmxauxFmZ2S+owqW+m%=&c~xZ-SoFfcN@Z$H@8z`zj1Ai(IxRC~bEu66^fMh53B
zhuZ;cv)(p4m?x}a_F}vkdR;b&m4SiTi%GtAg#-_emG{9fFLJjo>o}&8!NBCTRD?l;
zA$DCRuMy9xS#CWHuJ)HbR&iWl;PhA3G<93-z@YNg)79gvq^&Qr!mLSNE9w(XBm_hz
zd3w1uNSf5yueiVITzm44XURL>G4F^u>L_vZc<kTbU%zkr&T(wL`HW-Q$B&l2V=mlh
z8TWW=i)oAY)I#1wxmVvzHUxW_Zf_N1{n*2|yMb?aLFpaF>jlRw&z*a{d-c*uD^-?k
zismccwYz%Vk9!RKu_{Y8Ma}EmQtBR3TJQSYX3x%<0<}WVr!+1)7kX4{)xkioRST{?
zGXqV4ZJTs*<2K*59UHThl#OmpnkF4=G}~;-)He&&4(?vH>{3e_XK1d&)EQi|D>tp3
z&6Tq>S~+#w)x9cPX56|ojnykS?M&KgR=b`}myJ!XY)(ry-1JZIb7%bqV{O(MON!@o
zONR2)A6j>MW~kYuYd6ib&g|#=>^|>!s@|2CQI6vE)*Ei6X+7KKo}Q8G{M6U=vqCY$
zS;?kj6P8_!+H@x1mbTH-4~HIIPkQ6M)hbNr+Y-+oYaQy%PKT`vX_^w!9GRV6o1MR7
zx7n@uS(83Thg8qe{*kHue3ozUscStK&sp~5s4yGluKis9z&m4=$(DG#9pTqJH)%dT
zu5Yl~+U$1Xg?JP9O-tW;K3wtJ>(Tic#;P?2heQ3hnpqwA?Yn5(sxz~~JbrDmJJEO1
z?ozJURqdpX+NIyLcXw~p`}NA_=;!T0?{<ino~&bRtg9=|>U-{VD{a5AQMc*VI?2$_
z{IlZIGK)i>O}<$>v#&n&yz`61DCH~jbA>&>TsfVkGs|l6iAx!&?3bq}w%yKo?s-A(
zx9O(t+%<<T^+-6kg{F1P43pQN-hFP@y6&WF>#OsnzOK#v^jD4Ta@u8;i%U#$nte7&
zoyZU|k=l0SMs!Zsk6GNWb#h$V4vG3~TR)Z6?BJSE1yAoB!P$w4ku&+W*1w6m@F&CW
z^jp=MtEP+P4PK{RNnH{*qvq<d1y3%V_J~c97ESApls22W>`K~V_8IF0Dkm;FoO5-S
zt54L#Eorj@He5-&#k)F6GBsy$>ZTjFbJUZQ=7gV#YWgdk7iGFLbZ4yZiq)wS>v|+*
zxIYJ-nXzi-w(U2AW^GxbA$BWj{??qy^+q#u3?y=A7^loX8l?JjW!j4QJ<b#Us7s`X
zSV!}m&Q6?Zwm56Qf%0P!e#K4;AA=*S=A1N~lqPIgbHaPVAs;mzBQImY9>*CzN1wR{
zcPmb`oMLn4L|>|E+S<jYnlnTG7@WP#`en6u6w_;I?Wpc3u8OR8sZVTXcCEfyILZ4g
zTSk4(wp@|E+4@o}JlAz!WhmtR{8XA-e(LjyigT&XZ-mc2b3W7Yeg5<s8@V?vUshc#
zSh2p6=SzF(Ey1^M_dVO1)tw!BdC|F_@7vGsJ*vIGu6Ulti>D85zEzz37H71?IP}``
zn(v42+pbhQ^6uxAhleWPd|VQCYG&KT9ygw(A6LUpZc3}aCLMg<^4iw(eP7wn+od{M
z@A~|#uKJFR#MB+{6yJT%-y44FH`~EC(s6s9Yla(D7%iT^udiI^!X7(G)wkRR7kjs*
zc0Hcje!ZXXa_gJ6lao8nIvZ{}nVfdk|KJa!)k1Yk_WN8s=T^4uaN=d>#BTLx>vWdq
znr5z?ra5aiGyAk%mMiOj>Fiy;dzHSeb$;4OZQm_tH)d&V>|VisYiZBP)U<7TH%HcP
zS|9Xm=30ZxoDZ**&N7)3QM>xG-In<krEll#>X$tCu(WaBnNK%ut}Q9f?ah5(cxK%e
zzIV;jDqe3ZDP1f(?ZD|3&-2{Hqu(B1er@&o+$(v;q9=IoTHQMJn(N&QTcMizrLAqE
zlijui{Rr7NZEHE7)otJIwA+DKuBDnvW=YO6nPnXK@kpu6>ClvFx3mjccQ!j6$_+Xj
zo|~og%{k(B`pn6*)0P@$sIzOloS3{S_mtfEYH^JtS5?<NJRR_~Y0jAvr>bACSGI|X
ziG_wt*_O37zeZa^>ByR`w|KTHMlZN+vaLSkR<3u(!?wi{7aM18U2Gb;(uXI@<7U{j
zt<zTCT5Pm9BRI=#i-=X0hs@sED%*s^oQa8?tqay%T6AkAuP*Zs&U)d8f836mEju`C
z<yK+6-B~#|Bf0x_JYE;|qUUDfxyYH}TCbj^J(G|>a69MR)!vC|Zo6iMhdkFSxAc=0
zJ6pV`vcAAUJ+Xa?YsJQ0*OfeC+GVz^$(mE#b!o>d8{6j_o3)PerH1WzC4VS7cV^s`
zRG(*-v)*2Jn|kJ4_ag3Ptk3(D*FESIdA&@rJoD@+gR7g(4zDlUab5QFJxAWRM^x5(
z#LQt)4=y|yT{QD@_nZf(9ao12ovOax^=tjUz57a~q*|&j)Jr{H@Q*3&%$Y^sW?oM`
zyEAj+_T?@vmol!tEzjdw#mw5PwxFQ&4g<5p>m3XXuk+q*d#@9jG))tXUQ|4>RMLCB
za&}DDP49B6+v_&7g+A_&{W#~$*4X&H`~KAaKKlFJoHNN=b41sf-7YC8s(8MNb;B*T
zi(AfQt8UvSevyA~W&Kpqjg8MO56^i%&wyq3oBXJ2Yo_MrYUjUQ{V{`qVd;#eDx4El
z7&dLn%AIsMD|5?Ll`AVXm(JE`@d}!(>k_5w8Rn}i8KKM;>2oS=R-{%`$Q2g$N87fp
zTOB`j+t#}5ko#wqeRX(Q7&sYC|L5OGIM^&GkkEc6S$e0S0OW*_pt}VJ`HmUxdI&xt
zgwWy@(3k||$b9f|__?v?AHSHO!pRi(a~tSH`JV*`J33^iH*>J5PCwwx#tS0&>Omt5
z*HI5CLG0&x4w>+2X>#!4{QNZb##gyV%4&}qoh+t?hPpT~#jVYL3?6%cp6i#i`rg|+
z(;e?l;CZsdgYQj4x~h^xIc%32_=J9mV^@-)I5+NR&60QZ>#mpNbtyp?>fD|*W6H(O
z00ssI&#U3!tzY_CfB)BQ`}w@`)IYZWMXP>)-&)Hrldtz)KRzw($Guvvy;~0+{x>%?
z?7<cJw{v<6xa1R>ch}soecOHN3*YWdWp%6XhuSGVVTtp5+-DbGo1U%RtHY3SC1lA~
zW1~%*=dO8MuUD#a=1lbS{u8>j!I|RMntna$pE--6No`HbnwEO|qZR60EYH078!s|!
zt;yi_sVxnSZVssXeeZ8w^}X*$^ErRWuh3e4Pr6rD?^tZ3(Hk9=D=!6)9ZSBKvTFb0
z_xs)7Pv<_xf8|x)`)fJJlH+HF)-yjpd-p@gW&M;jGj3T2C5hDQZq)qn$l&P@)~WH=
z*FCT8TD7Kdg>B-Y_8SUsKPP<O#(ip~6(`SZ?Z_JorO$L}Dforo+ig0rVAt==YnS)6
zYAlnesH$#Xn!@nyyZVNpgy?XAh(_t#xqH~oRqvAWt6m`PFXKFwHHCp^$>emmn>j3-
z#BO`19+o?5z9R44?c7~#AL@_qUNSlDgYnd|+vy(SRrl@~m%N<3yP8L5R{K0(-U|U>
zz{<*!@Z-?~rXB$>x9})~yG+Mpj|ios6Jq(<mu#H*c-e*KY3ZJeH^p+B?@l%ha7~Li
zbKwrBkk^t)vB%Utu!`EoY~8z%`Q{vFHr?I3o3*AZ2>Eu1Dl~Y^tiKcJDio-`!Z}6z
zu=FbdQ;z6$l2<G?iDm8*D`>4KF=uj_v{Geq>h22GBXa9*=R5TscWp69ySua?y?npY
z`u!V!dpQc(*V{|ZjEtN)Gcq<ZcGc#sb7XIwIdkgNsZ(dpT`Sw%o0`s$4T^0j-v7P%
zz3lHz+d+$~RBqM3-u+>HZpzbMhoXfy=e>M4(R$LRgli6mx3*_*=i9YWR%?}3$D#xQ
z4<VM53@Q_tK${ZZicMgjThhxeq<P0Q@S?~@cCP<TDuRDsO%0U4A#rN0R>CPGp2>y*
zVy;F)lA05zoa}X*IpwtP!etwJO)^)D%{IA}t0TCnJ0&PJH#h25{gHoZj!{uTZ!gS>
zIwrPl!)@0aH}#_4><qdlb~t3l($?nPlb*XOGxg36S*^G2?bSsSXKpx?Q(kP{=B-q;
zrsGWL&Cpv@x7;xE+^AwC8l$yNlk;M>)V6I$dnGQrSqXct@>!O&MV+tEdQHix^3c*!
zRn=RnMXw{Lm*<G_y_KD9xge{4!{ivLE7^g|HtM}Rn>#IacR|XQ!t049!Sc7>S3P_b
zb<OMLmTQxYvQj(lO?`7~RyJ>&>8iNHrjn~3nX;#DGLy>}S>~HM>FmU6=~&^dGV7}+
z-Ky%?%pI88W!1)U=#XW&WXK$y^|6QE$5~5m-PY^OJukeYEYx;;;f>w=wr^j@y{g~p
z!y4DtV!A@MrP?)T+J(@UT)PDILj@~Yx_@koj^fSsy|V2r+uqwrmJ*XZW}H$rPCa+l
zGwfujXL8oF-nKxsmARkI+7{=o*%CG*wm9XmMRweC$vLanZOfGrNs$e6TOE3+JM`u>
z-Z`=E8ZU0gMY5i{eMv8Rw~)Wz?B!)Qr}=EFe|<jgY}TZ3ozm3vRr+a{TQ^kBno)7o
zS6nSo?)#3<#`m5q4!piy<<p|t`7-(YUO)Vz!!N#4Cu;8{>-#a`lYKYI7uCKJ57>1q
zrKl&a_x&6@{w}{0M{BP4Y)e~pbJOu;bMEwG@uC}Z(s-gwg3s>^=QD0e^H<um=X|72
zaY64sJCXYKNcortyK5>7)J@8wb*>q#4ZQ7d_sRXxgkxdc2|W@XKWh^XGaXDU5NvII
zF?rP`(OfI(u->KLwkUp^dh*S-qD_}m(<Z$9{9ZWW*FL-2530o>Ic5T@r*7SL(=2hu
z6{g>-mh5#6{WL|qGr+ECY4}4Sj(<-)l(`%umZ&DJYHjkGQNNNWluaOkrz<5`VYOoD
z6xAhKM>!kSR!A+#P}!msv1-*(=1@_CpqXCWnvO{!ys8fWmH+c3^Vok04UAV6=wG$u
zDo3!_g$1XUWVA%`h>ERfQxsjW)obA-k5f}7D@iDIu3Dk4(X?Du(bUN+B`8>tE2@iY
ztJZ`_567uqPX8-d>g)Y9Lp19hJ+yyKm5z>_aAxDQkTk`ffHRy^1I~H{N3!Z>P0HQC
zwRKVJjHU8d#k5tlCD_02xU^b=&DD}MmUY8T@5IDL-xYN#Z?<)AOt>^D*O_beR8Px*
zG@c8QtJ0PvPGsW>R+$(-X}?0sRMjb)f)@68u?3~5oLUx?*e0yxvWBI8zw#%0%{r&L
zfS<w48k;WltO@2y@tLu~u+itR3CFcb#{yQSc}8|QM}*AGoSix|>sqs~%HhbUt!f*W
zosBrtrs_3omH)9R8;<q}8!FZDAFAW}>+d#eW!lP_*|}S;Ejk-!!W+5T%&dnqYIEeW
zgwU>QqP<&<Bt(oBzx7?^+jh#>p}vmKvS*cE(z6BAUpl`IlsL?z<8^RLh_1@D(B2Ix
z25gRRrJZuNsm=<i@ot`Bu+lH-S*zC{PnB<~)uv0!CY0UIUCPc>FkNIy_^B0~KgFM~
z4$ZEg=P9DTV{+>|DXy-r9rF^I_8(!g|KV8Q=>6$8kJSAgs_8pao!eGfDNR#Qu-;f7
zb#A|A>~+<0*OQa(FbFZQ?2XP2zjbSMz1g*`hvNH}nH*L<@MFOq{;k0wfo__iN+y9*
zy{@bZ6$uo}ni6Pq5PDRjfx)b<1&Q{vF-~fn-N5{yg{ff`0|Nu20+)PR0|QG#e(l>8
z-wtFyuqfE~^Flr2HpZ4&7sHxE7^dF6-m-G9M^@dcWsQp&y!@+HEwy!DkpVisT`2f#
z;KIdfEb~@sy4><O!sBSF$<@Hirl6@ZX)6252@JpPKmFn?`|J0u=RDQ-zU?dolh4=P
zJ74kcm~rKe4|g8$na|}fyn1R!$L{UY&M~VyBKJJxzAd%8xBmH*>pMQ}eP?E7Dwd^{
znDpTF&fasdtzQy6U+?8JSRR&!iIlH<S~`z!_nBA=t9N|6o7diZy+^j(u<?4a#Ie%y
zU2mTmq{lw{z)<y$f#KEr(t8YYMXOH-CT$c|Q_gkU)^##$<0_3c(n?Vmqg_2cRc+U9
zFW#D0|EO%~%^dg4+_R#$XT?suHDR(*u%WTnnT4J=H(M{>-Fee5Rd&JcS$ua+Z?X<r
z<(A=dDJ|H5DRx>e{QP#Y#Ys1g=BQoC>Xz!}*_fQMN+(-lZO`na6^jGij`D2GGF-Da
zYxQq_jy;x#-4+J_=CMfC_;8r#Gp~f@;)^T9>mMFoDttI(v+`oW!~AU;I}+Qp4K6mD
zl%xnBZWsKJ$=??GkKszpiC?CkhgpBlOP_g8A}u@g=jSaYnZ-JW;d2XZmZk-4IB)ai
zYxvpkOolz)0Y+NCqkg+Zyg1oBe`e>I=Ym`65_@c(L{2w)E_6%3jeEw=enX$4l06we
zvb5(J%7oW<YxsCQ)^q=m6=^stDMB86Z2JuTBM0Xh6wg@OHNPt%^%=M2jJ1DUgX~j|
zT!~6ua@G9YcC(`kO^veEGO~A;tyr~oamH=2RL_t*uag5;cpEL@Eqk<zS$tY#QGmt9
zq|=|Cp4KUPdfwtus9|bk!fBb~5?V*Q#kj>HQ#Pj0DeA0GI%IUp=(yprz;33~T1IC!
zy6G%BEtJ}G%ur{-)7HpDnaFTGJ(i-QM^^=J%iNY!u+=kmv+rh$4a#CV5g{q5dXeEe
zOHV6L3q3799dd-aUQD0P&cwo`A3IZuo*w!Xd`4M9EtMxFzRlgD;F<QPgU9teWey)!
zJQf$RvTWP(=6b%gY*U*^j<RhZ4$nIKw9!9yb9LUEdlIRqMV9kLo{DTdclKD)w92C8
zHt9-f{yMAYeEjjVPSXA4<YVD|abh|>n@)?xfowcxeDrCIj-I$qU!;sq=!baC#7XwX
z!rzveTsUKS>gCUwQ;yH+w>&!2uei-<O{!nNPUfbFIv*1=uli5@J!x)1hqNyplTVV?
zmdf-=HazEf`QdXpi^mdTMk^0}GR!!u^)&EV#37?;BEfrZuI$<_W8Eiiu(UN&dXCnk
za7n>rMxRq+CPF+*C;sW=e=z@0s^L$`-~z$UY{!LN(R!=BE?rt0p2uNm){@k9Rb9ls
z^|ZL2U*tJ{zLJ8I$;tIIKnJ#`YoA%pGgD^fW1GqoPj30lbv(7;pYqd*N1r}@WH@nN
zp?<rSMT+63oinG4JpJ5!zTe{0`WZ1MiJSbyr`uUPKm1J9QffBK$tyA|mj1boepvhI
z=qJ~VLcitYOx-*;U3T4MNgadDn^PiFkHpjzp8oWx-mcF0So(8gyMRBJe9@0-PvyAb
zs&{p(WOJ11Y;Ema1*xcs>Z;+7u0Pw%GF4Y+Gpo0^&f!Su5Z5H_Boo(7Jt0Xm4y&9>
zIknkqst2gVWB7G7>w4(w_^ny<?<E^F3e1A-MEG0Z*bF`J(OF4JiKFA7gc9heNAP)%
z;2xZkl9EBf!6t)*BaR)-f^140(D~(#nq!8$Ckpa`NC8M6@tEQC_bE&g_3)D@C5{>H
z?mK4K^YF$o^THdjS!h8)@H{l+ly*c94|HG$Y#)IH^z2NDV;QyItv6eQZ?Sz>Zd|ZF
z%dCCxxi{xT-&j{$Z_Ar}t9RSQ9>@eUXwDgm>$ge=Zmm89+D_c&Fe8PtG-}-g20;b`
zP+#uW)>VZQ)Fhcay)_$L7?>OwriaEJVBlh02om(I{*@QL?CJFVmB+4E)%`waw(H_`
zOVR53=+oRy4_@R>WiPGycKfc++3Uha<yteBoV)`%y5021gqZR-GTGntZn*rtzj^oW
zy!yBEzp*zs=e%0`_{`?RS!=R$MZ0dQd^UN!@>$T@<&!<bF7>7S`hQ<u?%TIt_kOR@
z<8EHKEkw5b`t9SVrf${F`MkWVaBJ7<%6Iuk-_8vS34ZQ;=ehW{()eP;x$T>UPrm*#
zPeSH2Tg|M5)D|;2|BiK&FMU|DV(s-h>)rKx{j0CCI$pSK^<ekD>WAv{rKVlIki@z!
zP(gLgs@rM4-3#`fPMywuoLT33;M`ts8GRX^&9QE*GK~r;hG~i`*v~IuUGV$8bkMe?
zxwAjKnv<Kf>R$9BCM6fXbGtd51m?cn@G#4Hj@8l7ci%yWP2SGkcH4Y!(yGsWuSLVl
zo}Oi%Q~x}XJGbRtDQkj6GDn-lA@xeD*z5P-F|bVHaA06)>k&Na(LcH7)46Kfd8buo
z+k8H4uBFZ4ykydO1NS-4&PhlJpIEhO)mp~2#dBV&Y&JGJp!dGW$XoH&n~8!}#m57u
z<@4oNB&zqCTw1kOAv<W#r|!JB(YrGoY-Hb^J><2T;pWWxX?Y=GLZKy-BA;=d%b#tL
zkl=STG&D4WH+#-=Pu178?=r-`tA^)!R-H6(*_`&;@B7TTdhfp8`>wLeb=4}(3*`^r
zuU~Im*>=@mZboj~*HwG6b91*{+O?kHUgFl!28L4S=-l_Y@4eQu2;8&HTF=1yI5eRl
zUuyNQ^=CI{2xT#5M%2&u+x`0f)K8zjZ(G+Lxpj(v`?(*xcjvbVAfMMBp~7j((x}!Q
z`tjq(?KYpU-Vx``_Fno@H@y6J>;;c+U0zGRE{>WuOE+U?MC#PEV8O($o|CgCadXY!
zirCDSDzYg!Q!{5u)YeIxf=xV^=4k%!>};LbV|ldjjEqx#vSwn}&N*u=k82i&&J4?V
ztI?O3wkmj1JEKg)GH;8AQCXJVX~BleEf1V4JaR^|w@b$|@7dk;zYGq?if$_E3Fb;k
zwmf{E+2&*L!RLLdJ#rjAsXB(?eZ^ujkEiSiII~(;Yu;6rbxCWkctZ|qZwmOj*|Iz0
z#&&hFYnkVwr`H=wOg+6}%aqx<Wjbe0i)M8n`SDrigIHNXC7Vs^)1Jb|M<PCpJe{=q
z;JX)huk4f9aGzgT_RQ&{3%kA)wnk4{Cz|N2tGjRuwsYE-&Pa<;&)sBampqT@%&!o~
znIE1`T6!}_(<C8e-Io<^UFFO>Tw^EIYsH>)@jlg|QgxA~H#8{dil@`nfTb%Gvp82s
zEy{2M&0V&6Ns75niF9q~VM!64=+?L(Yn9rnMH#M9f?)zHuPtHc6xHwB|7=!fW(I>W
zr^57atG)$!c^~wcSg~X^CzsJ=MqbshPS=G|lNO5#3$!lLb>TXtu{LCp!NMh)Zj+qq
zi$oR_P15!V)nSy>T4ETaIaP_9Q&cx-Y2XVl&yEn0{{lklU$@<kHegd(b;-$FQSHpM
zwP^{bxy2%mPJ^KkNv_FaZjq5GDe7OmQj!dljQn4$);cmz)MkpM_?JZwlqZC1tzp$w
z(yCOf42+t@wU#+RD>b6w&_)AElX_l-fGtZ_pO`*jy^8-Stv}+YB6=jUlCBy~NOIGO
z*mPRsXrxeJvzTkdX61lHt!19}%4%T|$zl;n8#bxV2(cI1;}#j3bR_AZq^3{Lku07d
zgXPl<Hc196s-+6;SD6>uE#|FtYSS8yp4EnG3l2&+pO)xZIF-kd=Y-RqrjBRJ)@s&+
z4rrfb(lcetN`pn77Zz&#TWY`W_V4%acb7Szug-U0n=cz4D)(fi{#S+hQyoi#AMTU;
z`Q7nuiHMMA(U)njcYj-|8MHtJ6z;cH)HCe=;qsu?ZdS6IbPmG|PnKP)euhTh+PeD9
zQSea^0&Chtq!{L-90gGiItwD}<HgYD#~c_~K?mI4xWK?*#o)ibDcNvVVB*1=nxF<N
z24=Te0Zema*GbJ^Bph;8O3FwgbCy@i3I+zRO0Ah*Yz_>buO@{od?{seAwxJQ)R(8>
zK!c{rq^WGP7$^Imf1UZ0fl1>1>-X7nH-U~^pJQ(E`h3OPj-^|qg6g@#wH}ECCp3w2
zg)a+V7G`b9)2zwn6t+0Sgo#1pd)V$d&n<h3=R7mFJjYfFYSo`N>y!CB4^)qxE7m${
zY^-(E*qpE1*k}c_1j8}I#S+KNjqhwWHd+%5#wM}vc6@klQF-XvqP4E8ZZ287V5;n@
z8{3Oy@4WH6F?CbO;`&IhYaM|%ZkiW{mpz)E<#vi|T1L+Wp}x}zH+iR+nJL`N4ZD!z
zoSeya?Ap<g=#Y8WlFn`sk>b@hn<$kXbjroWwd3rpvop@loVNHw|Er4b*K?8u{a>LS
z$d2bc_7C+Zi}`y!uerbZR&70V>+jby<KEd!o%h|Q_D^q{|LM=h#(f6QpQc&%EPo~`
zE?Laue$9RBx4qrPlkUklKiNI~v$xr0iTU!=d6MiTU4Iy@f3!e<tK`y|zAMh^oNAh_
zY_eH7C2d-gkj_5KkU3{I_S9KC)jAV#v`5(3=$K(=TR@tdVSU8O8HQ60J7>%|v9Vd?
zOq%D+FoT|hX=$o6mK#kob<2pjvTwul*s{sT^ei4tp7nLnV>tuurF+v}u&ocdbvxWY
zwIFv-g1+URXJ22-8BKZJ`}xA$bKLiC*WEsSzpvAJ&e1N*k3a8)p9w8nJmbt^l`}EV
zkJZ%J^Qh0%F^r4hk%&l~T+b$B5hGFDlUA{3@xiVK4;MX7W>;-|`ZY9(mq)Aa)_&dY
zT~B}Krm5MM>X$#O`ROnB;=D|^-S_Tug~!s2tv023_e4&5b?PkhtS~#9r^jtR7*4G?
zRjhjYOyPMO(aP2<%NP4(9McXBYh^!k<i}?2U6wVrMW5$ZJQgclra8lM%`t=eGa*kq
zmwB8OJ+oR|V)Goq9&IPTn&&#nVl!P=tqyV7`z>n6shDX7<|(`8+|K2=EaG!Jv$JhV
zugM~x%Fn0I7%q)C8oEr=Rch51_YW%d{4@W=Z1-7n%y4>WvsxQ_$<3LXr>0B(u{hdp
zaV+NJbDQN7XJnFPjE~zy9B-3JD!j5zRIlFnM`5$}jC7to4?aJBZkK-GV_U*wi5)hU
zAD<sNrc#l3O!0WoPLJiEaw8YtJR7`w>fP;nZ+FHd9od<9@c3i>>5ZR1etvwc&f<^u
zW1+&HaOMX;Du4X^(Ua5~cXET-Y@gJttAt8ROFhMe-`LEKc1-}~Z%!fC6>C*hIyXmj
z3$78XztJt&rL}a@woR8ZeSNl^NjA!ynKpB!XXcVkH-mB*7#ZwMv!lYcu74kP{oe~k
zkbVZ?RqI}O2(&cXKmP`rx^PJXoqgT`Y8gY%uyb)qQc_X?-53mN6dOYK(JCp$gK}+8
z66gY7^BC}MUWJ48%`BjGmTf${C60kluxn#amH?@MwQkiwH}yg<GP-*ldhKv2cuy{P
z6EJk8Wej{_X6cEJ=@278_aOCtzc9h4<<%V3+o8`ua~LpVVY3<aZic;Ij~>XMaLPdT
zruABp#q4a=%~e7y-?uH!0<Bd*s0Z;Ni!?!NHNP)Zn90ckJ}7U>Qq6=2&=}0_?BE4V
zDGc8Cu7<sLdA+WI6BJx?S7)caIkO-Dw2ZSf^bY7)rb$<S*UKM&|GWLs{r>vnkMCGc
zc)aIh0z>`M(C(bFsi9Z4=2>4kpZ;V+(7_{f|JzCZnD2jy{qm_-H*CE2^oKTks_TeP
zRyq^0(fVYlD1*$#aGl-*!Y&=3I1RTQY<}dK`fUxfxZb-rOq!t%jM=@-F)>Nc>g&EH
zs;xRL_<}*I$o0elhTi5p)iaSlswFE*>o?@BPMdM|a)0iE+yzXtS2cR>w-I?O%XT8F
zNQ8Gna-Z(W6T2UZJ+p1G+F7%E_kwu7&*ud^j(0Ua*#1ydR5YRNxKwDVXh@jF+r`bV
zUwn?M?36m@&=a^#P~(ExodyO5M%Lan*A{!KU3=PgW==?}NLob1;zyfA0%s;B^&eYU
zvuauW<+6i$Gjw~mznixwYyD;4Ew_EQL|0BqbJ+GVb$8Di!wq>Wuks}89b3V`z_EtO
zVaCsAw{t^lKHpfeVnxmR+S|A9iiU*m`@QGm_w%+J-tN5peBRa2@DN?6Rf~;{jg9Rp
zoDJXId%Nv6IN>YjNT+b{PGI0T0g4w8cH?cVXJ|O_q=(7jRrvFHL9vt8P4c=_^lsAL
z>-(bf=e!Rp-nR6i(CqD{ngXldS6%>VVViX3Uh(R+X}5P5rfd(3E3RC1?Lm1}PVTFx
zoUx|LUO`*4&3DT*$}li+b_;!dGs*2yrs}KUdB1}uY*p7?S$wbh>9(KezN%Yi1uo6Z
z3Q`QcSO0wh$XMxfr77*9F`m*}Q$KxQbMDpE-O;_fJq;CCEIQJ<_imp<pC`wSxCi#K
zF9W@q7)?VqG?;7*Enp876%A2fT77B}!`0Bx1EQg!F|47np-v1}14Eq{|9$*YZlkrr
zgpp;+ZQc0A6Muex`L*_L`Q6hAY#qloH8AxySij%9uYP^`eBB!6eZSvNeD})9?)&*2
z71<9as9f+-Y4UYc@LZwNY0CQf**nfT-x=QaO**#fxKOdw&!GKVRxDay;mQ2y$m%Gi
zYX%ZY+P+cKqBb2lkma-5C3ERwj)fDoy%bkYmIR&X{vC9pyI7K#o}sXIpX;H=qL*f+
z8Eraw^+Zu=YIwbeSOiblDw)*Nl2VDw{CureZEh{>?1@S8dOC6Hs@4nYuAT)!t38)o
z?Edd>vFcONXUn8#Hc7|j<n$zZBzEka7S^VE+@;9RXl0LH$Yn8~!UG>48a}?H-cj_i
z-Qlp;hpEB7p;0}G50C3?T)K?c@Z|E)aIR!wF)f>fRdY5NZPhBMcW(`S!nIzcYyPd+
zmD>)U$rdjzym7X7>bZ^EW?ed&GAS}UEiHArOxUVTJk$7R27P{f@Jz*#!sG27HWEG(
zKMK2#JQnAdiIcIh@#hxJ)YH~@o9)%NV#dT<SDSe?WukmnXU#ZqOj>lynXv4X!-pG>
zK6<Ghb93Xv4_{UtK7J_l&9;^Gy<x^l+l+&*U733PjNx^&9C!X6iw~hawE<p+%MTvC
zqjTAmvFoC1ys2()%fbZkx$duAy=q-n@gEWi_;*BOVZ%xtt))64D~@<1DGN$83sf&v
zUaIUci{+}<Rc9sxWev|MDu-5q4|d<g8s@O-1hWFq#GqLdgZiKEzm^u6P!Bq&Q~$g3
z?-te?l@;p`Dm$&}F>*B#xftT>HCZs!XGPnRrqzO;RtthGSY|AA?V4b)$g@RMN<(PF
z6s4;!f*({}S1b+G|ID;x|FX*|v!$h_C3}+281o#~=m};1B`ANPd7}2zpa=agIG%D^
zgvN-baIMu?5kF=9B{3z(6dlblpZcJLo=b_7)(EUj@c3it(<8NY+S<saNs%*-8ErID
zl;m0MEE$rLHI1ol!86IWtgxhjKiUUVGr1jBJ9DmDnbEQ@VTaE$X8~>1tZ51-g4SPX
z;ya<O8r=7e|9pepi`w=3Vm=;t+q8{6N67Zx&GY|Oa@992sXwatXX*FPKi^rUs~1?;
zC$CPtwT7ix;_h+zt(sm_!NVL6y_SFU(*NLT5&Zgf#AyLgnLRx;J~}$=gXn)l$4Ir{
z$g_@L#aSAY;~NqLM5^l~RxvQ}+dYjBNzj{9!eGn5KRYyxfq|`of!TpoiqU~JC38~4
z1km~J45FoX$~SzM54V27#lXPSz|vbkV=6-c1M@wN1rA)SRa~qN41wSGN%?zKW%&nR
zVPIduz?LO&K4jHmhMpOYEs`c|Qu#qEP5lGGg@(#kFOQ(yl~N2B7qB(3T$vj9O4yen
zgY61~38SaVqEKe%D__|f7clVef6w{Pu3qA>{Oq@%&la!f;;USJG{&i`ZS^tfbM@VM
zZW8a1h}3Ccx3B%Fe(Yk^?HiYOJG;KlPxjrjd(Y0c&%00OXP^4YbaP6hYOp4g*Rmj%
zsXj|M&F+<5z1U{CwIs1GH&!B1zdYZ+-0}cu*JQPM17GnmbIYA)Wu99;o@cprPfmhO
z#<e>aH#QtM$<E8TaUgk?Y5jJSoCL$OQnzQB8A!g`efM$9jRT+Fo@ZcS;Md+$aox<o
zW_R%c1_tI+@8wL-_VDZ7`M|)ykjwn+cHZr{*HP<pr_P#fwBgiYZMR_cB<tMVjZ(Tv
z2N^|@uIUH}x*?dZEG&Up92|?T2nf0cFlHBLhn_L$F;M2=I9$(UaA@_ct7m&yHzp@D
zx~<r_v0-sY#Ek=it8{V_G_GCsmX?;5HjPkF&f?&>7=?tRvsQh(HtX8eHHmw-l_c(Y
z_i4GC^ttzJ&#vA2Ufu>KyO+$n8XcM&y3xa5afR16-4&XZYkE_%m7^RcZ%o~qb<eO(
z?3h9Qp&Q4Hb5)Xg5_?wV+&0WHICSHfM6|?V?quH0xvo)JAPK|8aOX;Ar`_D5vsp7@
zS|@Y1*u}7Jsf(*!MHhX)m2-8iSensaeVdiPQstYuP96AcEShqBroU^S3ID6)Hl`03
zjikC#Gqs;hjWo>au}ifL=8bAri;Sp$EZ$RNDEhI#jr~mI$~Y-CXQBO!D`eIN?2JfF
zoZ1#RvC=53H?(rfl`OZ(OqWvTE!JFdD$8hAn|4o};fGW0Ceu4Irv7L@Q8jU;l)B;{
z=PP|pd#uz~P57#O`0%2-`4f%gm%BWYQgimoIu>S{a_Y3`w6KVcKMcbs8>_82HU0UH
zZ}n+Q3Lmb#vN~+dT7f^|Q%_Vz@_shk_j|&xRr6&0oR2&`Q9LugT;53DYx0*u8}$iC
zKKv|LKY!ly{!?y>Q<Og}Jo2+{`Tb*e)+MBB)$^=4W+%xWlBsiQ`seCzi`R$Lo?o=N
zHAT-bWUpq0)yheK);W8AE%?)VVY8%l%yWs5S4Okut*C!xk?4Ok#h&x@l+TZyF1kOe
zeD&eM<iIIc{&W?5mFh8Qe-s(|^s`#)QqLdrZ1zn1@!{%%uTp}R8m|%yzRFLv>PZ#8
z=s#0rmROy-{_|s}e+I6dyKTAYmQy{m7AuRozdRf!WY4ZFB@^7Ha<KLI$Kw(kjvjyA
zXPEe>u;Q3u;-66NFZC&jD^_kXn-F$zON-<bV`DLkC(8|zC6YfpJd~CeYS?3F?<ce7
zK$=c6kDD=%&%w6P#MZ7fW0f<jCEOA=8w;ITwOo>$XO(>CDvNU~&iRBs=995nvgeBA
zqH2{s-@xM`r6;FW9B$`pluKoN>vrsD_FA=DbGI-spSmUVao$l++x4mSv&&<r<!)Ab
zTdi|@*PG3`^Hw~4IK|z-C2hjz5X%Wcn?+ssJ=J@sy!Yf)sZi<pWw*cQFSQMvFR}EN
z()sHTANq&Xl+10hcAme!ziKhVkCPIo+ASX|$cwR=Xg-{9Axn}cS+q@Jn%>G4$5tI}
zmJC|gIn6m(EsXuar%zW+eSE#zH%Hf}Z9AKHtYU`m)2)|;Ia>~e^?SV%Jsq<%Ml>~H
zP2g1a2Tu#utU5HEPrEg^{osd$4-ea46#V+abt<yyYQNj@cCM#>n{=nkSj}onFa1;z
z9h`JqO?9&AbLG3g_x-#o)t%|Pux`6Ys&C-q_2)}9z8Bv5Q}uL}$%>EDG9F7^T4$>A
zV^w`>!7GEqT%|=@v-%bX2cBDcR9;?APF{PG-Qp`nuVMpxnm-ikiN!mw*tEqkp1ITN
zYRWFdgQioa`&P_ve<+tyv-$B;@u$VwrlxHx4ym6x@@LoLMSW6Yr~70gbvEy^7d~}n
zX556Ayi3eNOx<Umnm*_J@i?^=C)P{O(lat#<!2cBsb0=mq%XWZaB7=MVQgTjRFCDU
zIjesB`0z6_<cXoJo7A$X<p-x<cbwXF(q>(|$;zYi><regESBuZKl31~XMucOcDST>
zNQUdBM5|rvdL`bfcNPU-;kqf-xx{jj#gVPLVP5NUa&mH`DrWeoMsHp2;iD$Z>B$|P
zw(V^0EY&9_D=g|4zLIs>?C|8{I`yd&WxYyUPROO4^@{xde8Qd+iiuIK&qF@Wj$C$j
z&E=rv)rlK!<ivW3bFJFtEMmAKvej7r)T;ZU?^VOTC7qbDiEHP^jT^VUdAZ6odeg0q
zG0dT@SK2o71YRgpHoIb`xRp24cU5xl*_nN-empspXqwV;DA6Em^{o0nAE#4mo#zz#
z89wZHJ~k)hWZP<S8J`F};~xcw^$Pp!BtCqcSeVRbu~>}jpPc1!9;4?Hk018)O9mAt
z^Kd*kvi#H88Q*T1=bn4J)51>T;p3oH&z5m5&CXseFMsmu`^|55znP@wGSNKtq*98f
z{Pfx_tX>-qYinz3>ufq5xZ+BdVPsEo?k0)0&Z$d|W~8n<b?WfnH_sA{Gy3L+JUT4p
zY_`I>qvUW-Z${Tq-OOxlZk}x>CL7nzoc;Zm#)?P2@vBz<FY!?PlfMYm-39kXLC3Z`
zb|?!93ffNJ;LN5l{gM-t=X8NY78VxJ!Bo>XhOlYyl-)AhDjl`!^~RoLiRlHdEMn8o
zgtF;PzF@^Z{eA|U_Vl_?Hl6xUUsVo!sIc(e&h}n1Bkk|}_RFXC&3-yJ_u9ww=-VfD
zXGLEYyY_h9`!ns`pLM65E-iW&ZZ9ZU_HNgbW#7{8)?Qy<y6W52!klf<{XI4LcO8H1
z_P_V??&ZGbU6r>z4OJ@U)hzeaztOv8#<c&{mh)<Nl^56EpZ#<B%l^afs^9(2nNn4s
zlN-%-+IQKpW5+J)+`5<>`ucz(^W)vSckdGT_T$Ho`@v#Q=k3z^*pqBqn(r;96R}rG
z$@JxX@x5<fZA?0C_0nYCJgex-7hYKLHSem*T{5FVEZb9~Wg?%%2Avras~VPcxLNv!
z9J<CQWx#**OLh3x%Dd(J*S-6dKh3ba=xDcXiA#OxV~L|Z$r9(o!@g`xI+}E}TTCZz
zqM(b5OZH{E{OUc&K7D$1?=*MnnrPi=rz<L|>N0=cwcZ7_ZIYnsx#k5gtoUAT@=)o1
z`7(d^rM=NhZ+n`ZReUXI`f+>ox|62cQ!XF5s539gTPWt_gEP~OkIu8S*?wx#G*8t-
z4Q!ic)yK|?FFrqk)m+lq^U~UxhT6pjjNCJ4uMRdgSU7FH*6kgjQ_1BD@4S1*z@Wll
z-*(^kb6LRF($m|*bIuiSD@sd@+L?7$%3sx`Y2U4-A^L|MrGvz-tvD@msoT`eEX&l*
z$uwzWM@NKmpjWigY0+%msV%22Y@FfCtvg|pp;6+-$@OABCj0N)F_WAc>aAlWyI{3s
zP|}&1foW%trgfYN+u1YYact5hw+(BJripBAO*WqJSh45wDs!Qo>rBKY8u>asPc3>9
zC@ZvEbEBcrG|h>rD~|`tY&f;^!lt`!?(**{53WqOkZ@H(ZsPIXJr@-puGBMG_35O=
zhIe8Irtx}hIyf=Sx1Qz9InT3#>r!XfBt0^GI_H$Zq|G6zi;`BGx*5)CmrH%sCzh}$
zNn9ehi}jVtJW=IK4*!$h`fk%ZZBlr$YEf)k(wfj#Q#a3Pj@{1v(^q*uopfr?i^!DZ
z^X$y;Do)Kf87J|eGWAo;dC8@0rrL)UD>mDN^A)8vtnubJab$y<W;$2>vv%#RW~;Mx
zj!siO{rKr4JFerWt)kVg=B`-l!L4>M;^&!gL(h+0Q;+Gk9<o~%RO`|F!ZF@sMdrV|
zX1QRvJ6A5b?3TsdZGDz{swY!@)n+;#Y!cU56XkNzOq#dtu=0~XcE<CyJU`p~u&c4D
zsCY2HTizzCO{d^t#eVK5V)dq;58GQGMys8ZShea&+oZSKZl_e*+4DR<GT->spOgiE
zZtEObzEkwaia$ZEFBa(^&_B>+AFyPV{Wg)QZlYcWL24Qu8x^^QRv2nEa~v|*u)&Sv
zqNa(LPk>H<jxxukUX2UEjy^%&B9jgZ9Td8-mg_2KL`bhkbCANRfK5|$IkcVXxh}dy
zX>>Ct=)YqBQ@`5iw9(~UPn}Jf3pKq?or=o17M&>`8h$mXKmADl+UVX>*WG24K7A6^
zirX?}($`jlrbUOjx(;<65Sihaq>{AcC`(ePfvbeZE>17Y(4ZMCsw+Hwxl~OSx+ZaX
zZ<wmRQl(o%X${lWpr!R8suD{>ly3&O*4Nw?*|tz;#u=X@XCz$`l~(@c43WR!{zbgW
zR%r53rVsrux<0Mg>oWPOm%o-pNZ%62Qvq8P){0E}tNPpP)D#{b)yPRRQl^ER4U-CH
zS(F-B*SAtv;VRF?2vfJno=jz}BT131(<BZnD{&e*d#En<*c7^8<64h321!n0UVa8=
zyf)XXYCPe;>Fw1M$tx__wT#EGXHA&1YPaf&tI0e|yEa6e2$f7#NSu@{lq_&!nuMWN
zGmH4EaK?!|28j|O^H;6ondD=bn5Z>>p-6#(@*nqaVQOpA3=`u&I0gP!;(zo1`tSPP
zKkRq^>UnsWjZfrzdqp~*gh2tHjKN_x{(|pq1rM9+*%?rTc?=HoNZ1~}CwaJyM~3;H
z?87-02?r0@K136+Z;`N#zpu6?HAUXou-|&g+(+epbASE0Z&SCnK)L$&wwsTxH$>-d
zyPX$q0s{J;Dw8}f=5Bi$yM30Fl$5Oa!hjVaT4uYfm)4(p@p8_Kcavh$dG%QGrNJ5*
zSk`5LK-?rxl}TT>-2wAb-?cg|3|MjN#k=X+i<cEIUJf$8Xy?LZcekAvyPXZX>x&7Z
z5~MXFBLl1(WUqd7&bHe|I~OioxUf5zYevYSWuivqAhSYpOUmoLr(V2ldGW5!rb7z@
zR;-(I@|t_`lDT(Y8h0((>Z!VV+BMZx-XYs&vdx;g)i^tILgvcZ!Db-tVzU)z*RD7x
zmDO`=vDvo87MZJzvwCjb>Up?q#o1NH*;&SIvxrhskIR^4xjwgUrATF^T{*jUnd9=y
z>YmnzZOoSC<{Gg%O}Ywl)pV^%PlIBX^RC${xz#N<aE{rg+kvw~(ym=e+nlyJ?W*Kf
zw}M-zK_XWr4`=JT<p$0UNrx$(9c;D^tfU^UW~*CnE=W;y;H<N=LlX5uRi<k#6Xo&_
znYJ$4Q+LbRm9wLLuBUzTyu94=waUDdS=+wGO-hN|Jz1sRfBCudbNz1K@)q8y6nXcp
zr^@7;4<1-IFz_)jsB1N_Gu~lfC}7|`wV;H7Zw_b>P?mvV0Yl`e1tpPp@7CYF!@$76
zyc+}>K#~Y723kds3t3J89tQwRaf6oMGcd4%#p9)Z{Mx-pwLGzV?#VklPw!Mx-RybE
z&rMY)v_oi`*7@T<>Zh;zvTxp>Nh+PnuWrA-xjA*y?boZ;uYd2EIy0?hlDEz*rwp&4
zO`E385_W<Na)U>@kq83@4`CM2HUkEh289V~oK5~I(;_D@c&cnV!5}nc&6))a3DeUG
z+0^RAB5iJ_PQNlOP%~+btHQ>xz>9)?@7~2cSsv7VHEa9qTal@=7(G*GWw2^SMrJNB
zVOh2Mdgv<e=jHnQZNIJF^_GEq=5zO{Z!NCAOxP4!+2X(yz+%5`b69FJ(~PXMkyCr!
zp@&mVwGrZCYpLANa6m!h+aJRc1_rs>Q~Np&)W=v(U|?Xrow6#PRYi%ZflVRjaEOp*
z(k(BArPAPl<1x!SxM{bD5NE6eLuebD7X$YV2D={t3pf;lcJHu$5MJA0#rTbp$Jgb`
zSAPeVs!R#a&R)mmT~oD~m3@t*7>=Cm5cIz{HE6{F1_ogUVU~F-HQiR(hg@8~@>S+C
z^%eCDmmSoW3Wf9tzTkYpz#yQh${DoSUqgPSloSJl{PGvVKmL_J{aLqrMt*tK?N49w
z?BcDj8{B*Mb$hf#`jO}&gX5>4S3P6*&U+tWUX<{_!gkM13%+T0uSKgfUb?;e8t<JM
z7JU5qW`4Zy-skS!T4iulX!o{tJqAlSwxud~ZhLoYSG~c(DUE8kcW1pgEOToYf+J8n
zXZi7CJ2y7I-fqLdz+iV)y4WtfrgB|QLKS%Qg*zuF!TeZn?pbLGo}aNFpCMF2hHlbN
zz3&GN$i(h^z`($K^&Ubee=lS(=hN=TXN!~TnXl(nFfcH%^+^7em(G2<Ep*jepBpRJ
zT-lbB6|LLrow|&JV{u4eQWKNL)ddY*N}z!o&}hvn@Ze2=gR9trhAvarH4zF*U7!IR
z!KSqV$vhp0nG6o}7_91*x{{NioC6xK$z62p7*p?B*WMmhsoNPjIXOAE7F}gwsSjMm
z!EtfbK}IRvtt_mYZi)2s8ZOz`x|rMI?zY?8-kY5BV{XscVZk@;wiPJY{d&xI@7;Q9
z_1UN{X^m|Qyj~ehSv_sxTIC4us7X_b&2nd_^dz=jbu&1e?FJsH$;~(>k#%<3<y5U>
zi;hWLi8!=v+tL|n8+#0{9Wywzt;g(a{f60I$9yu9m5zzN-4LqG({WhT$>7*+j>BS0
zly2>}F5UJy*Vi>=gRE>}=v9*^C*@C_Zd<XQ+v(CK)g@OI-$t!v+q*?hSR!$CSlH4`
zlcdwr!rS6{1iq%eII5@1?RC-p!A9pLS3)l(f#4}axi-nrMWs`tRy&-EXm*^kr>&W-
zzL~Ar;iP41Me2)_;*(6czVt2Lu$Jr69QPf4hjyxz&6)B-v`q9?MNIdN_@()$ot~`a
z_BypzO=q&$WY2Clv7RVH$r@AVQ(L2Wg|3AZ)<p4XWSY#_6!g{aa>rXEBNNSAg?h>>
z3uD{`7m4rmQ++Z$aMD|w@Wj}OE4p5KJ&Kj@w5@kqf0{E{pN;cELVv>b7p8BdzVWJ-
z%u?B}^2@JtQmwkzN!!T}Hbfm0pBTJw!G(%RFA6pWzcg9j_3G1?gIN>5#>#uDPq>g_
zH))-|;=<O6@&TXrZZ(+UStS#med=n~#$G8owm@|)?FB~*EBTj}7-j??TD~n%jXOT{
z;-9LV-1sB1^|y1y6|QEO>UhTY85|B<vsP1{FX$L|hegUVp6>ofk9*b_?f6@GEKL6B
zsSn4DHrziD`qN)rsOU7$z8H(pX%Q*=^<)C4MWp(yStc3SCN^oh)Y8O8|5X<XFJ$dh
zKHAPF8yfOyEqlA;s+V#)76ng5=C)nkn(NQ>uz*2sTj;ji$(8jfrqQ#fIp^g?GWmv^
zPje34xiiJ=+0zNCZ$n@04c#VqA*<`%?cCqFdzw$!S~6aL{qzyP!k1SoUVnY{!e(Jr
zrkiQd>-AzH%a=Cxa_!O8_Bdg(CSubxov6-<m$n#Y>O>eW4Jy%<3TyW47L8kZwKP&v
zs#nqPwb^CPmP3iglWk_6tZzBzqxN-ek%y0((5>rJN`*?NMZMP9u|w4`A;Mc!{piuF
zYFZi2-K*BEVi#ZdBH_c1jdgtb{--_u1|~nen(6bQs7<O(Hnd>n%aiJi3qCy6{Pl@X
z)5dVk&V-#2t}nP%PZfqOTjui8%2&;^#6(KA#ILogsv=H&=~e#3CstPKK^yB^?erEr
zGO1P%jo30veCyPemV(zL)jgLyblbFQ*Vd08Kl$rwAGTS~lD_Ip@QL8?RXa?K_VPLN
zowN+{S#@Of>jkfzPn|qAwQ!=`sZU{|vg)lDj&^Iwh88(qxHMzelXWg%zI@m#)p{gl
z*Xm$pZRJxl<BkVxOqG~?(#mh6^3?U>%b4qLy_Py;tEE$AVQ}h0ndi+womH3o%(h-x
zofndm6S}R^U<PPNWbL}G>s~4v%<%DSIh3fITOF;NyXv9W3rm;PhT6?r=VUH?n6!8$
zyPIa$rz_W%#zuV>HqA*&+t@iP+qdlEh8wxQN1cuc7I|y+WG!8zx@LdF{Dtq1PPm#Z
z=A0~6?=bz+;^d@Tw-~OSy1hE;)ReHN(w-ZAr{t;~H48Fb9CqwhcgD3NE-X`~OnY_p
z>q*e4$PC|HA*V!xsabDUy<M|n(`v1`MUVI*J|v%#lPsOKYDPq+kGtSey{LcUJf@|m
z^=u_RRAhx~>sa(@twRy>Jaw8+d3Akm=-0_9UY{K^k4Klwmgio1@FlsuZPL=4X}n9f
zoskN#=;43-H~P2!>%XyoBU?^PQhU8q#ivvG>$N}KV!CRRJ(pZu?AFU8VPcqcwA<@s
zq?qS|LzhyrqI}i#zuP{KoEpWq=hgJg-l!!<*8aAOyB+p*76aGRX{VN5I&+Hs`nRlY
z*VuQ5U0wh2kMeZI$&6Z)6Eno7C&@F)a|*bDPH0k6;+eiNklBK1f8J!r7|H4DGT68#
zd&KZe&&^=tWHgxmH<ZnI`so|YJk$L$*b?hk*XAFVymdYL!^ZTiKUGSv*3a!pw%VST
zY#m+mwOdT*ZT8yJVx{@>I=Z)(yTnG;ye@m2oBwYAu5aPnpMgdR3Saj7xc+{2<@fj5
z6*iZ*eBL#$^7-W5E1%D+uz5GHoZmKnfA049*ITby9G7|>o7M62Pf3}Xwcz!4b602G
zcqaI7cYR^Z#h8=1p6N3;XV*k*e(n+nI)mwZ#75BIMD-#iCDUiduWR4$1=&?mQTx{R
z_t`yinYSwMmaTfTzHHTP?_053KYn2R`QveNviaHX$r8tOzkxK*uj}aOJ}q$uG#qry
z_-@kCZq;rv9gs}7?M2A-f9nnB*M6(N`zE=%x^^!}!OWa((FY&=zEzFzOYGElSEDnl
zy|>MJcUA0`weiikx1l%V-um6l-jut(?*{|lpSx?bC5{=L{(brR$MyG*+xmQu`+Yw5
z#yx}bKAQ)(tmZCWdCQ=r@LqJhSJz7IXA@M`=Vo$F<Ca*-aO#Ms6whSV`h^BjtD<_A
ztrlA?wwgDLH<QU%#Xl!yvIU>1uz}%frX4S1G9#{SR9-8y)vIu7pt!2bqg??@PkCO*
z;Em$5P+qj_!Il!MzSx9|1}PDy+MJi>n076BI8kP!@U2uo1wGNMMdyNIQhN2SO+D<e
zJH}mm&6U#DiVe*@S}!KpI0he#3#ngesbt0DxmqJK!p~+slfTlQ9lBCId-jMk$E2)D
z>XR&#zZ+#6`fyE4>LeLcjSopL1$J~DS#7c8vFfDbQy<=lH4=SV@i_3<O1U*E76%H|
zS9Qis^^6OZ^H>#~ySVND?d;tdFSgIp=g!ah?D{bG?Ht|R=|#8R-Lfk5mf1KpS=%kF
z-dM6Xv}dhk#A%VD)vlh0RTr}u>Q3Dn&D%ElR!vp*dPntbd-n3@dmldd=+W}4)3>*&
zoH*UieYB=OX<C%Shs1|*LAOG;m=zomED;thyPdmbUhw6|u~n^a*N1*H*7EwD7A=<Q
zk;#5#`AHGGRV(=$<2k+Tl^T_Qda?8@nx-^Ol%YN`fXz!VWuchLkr`{k!os{dCoRgD
zVB#S$StyfjLej=aR-dM2A%P1$jzn~aWc4~ai@KzANh-B*9Y_#bGc_b<!K_uLq1zvA
zUHkL;%h_hZP6{SxXB#^y=xn-~vpJwcpo3w83MZ3qE=!|=4|BA`49O$YzpDDb{kQJ=
z{KwC~{r_oPKR^5Z&QIw(x4zrH=jKa0{`Uvt?|FrP5!L$FXwVg6&}AgFYEvi=!-lQ{
zE{7%^3hL47p0LDSNNGbW*QusyQ<+SemZo}zY!L|UVlfSs3~2h<B$^VUHT}nlrGL5_
z?58Xg|K#~+>Z3hgoliXEgzAm7x0Ho)Z&*^&JymAG#FHWhVXNv_^4}0`{&XN%Oz70n
zrX!+_CM)WivZgM%ka28^$ueby(>xmvPIL)V*|bC=m1okap3aDk5+RID8do)c2AmXg
zo4PR7jp@)~F`dcWUZ*x0O>3KSv|A}vnYD*AbmB^(#FbJ;6MLqv6c$rf<=Cjz{*q5{
z)smwfM`kGP_bA9(>J!luR?p@AQAvA>U}!w=oAc?Lr`~yA8GG$mSAmdx$|Oz&zUm(h
z92ft3aV-vKPEh33zF+wY7F70I{A$<ldwz1>Yh=O8=eK^p^Y^DQYN#@TM1LCJt$uIo
z^WALkwePcS)!%`1zdu<&=XZSV`N_6t*O%^ncHZ-o_<Q-SzrWl4nF-Ny=hpY=dpTd`
zGyHx0ZGYYK`;#rd?fX4nt$KFc>*}-fCO?qhQ+NISo!_6*?XKT1esaDz`)+>a=1Voq
z-}`U<{XM_V=lQMQ?`meg%dKAf-mJ>Mq4;g>cRO$q5e&7l-t#xet(YeKQL6a6{{D{7
zah1n=ZLZzRF8x{ksV+fgZ(L|)$k%P>9T-DH&%R!@Yc&|H{J_A#Bo`X?efQPU@X*rW
z=X)#mK0N#A!#>UK*+<{=96kH!d%Jn}p&y$o_Ap#p!#_2&xa!q<t$EvSzNlwlu&mm%
z>J!2o=BJ@C_rT_6b>EY@r_cRp#?C!)AI`+w)2}G5*rVTV-hF&(Xedn4s$C$<?ZDk>
zkn2G9hle7QcHkZ%1N*5}U8|Pm$A(^w4PDynla(AS?GyK*{@KThcoC2T+mfDrtUf&Z
z=);=GJ#n^=Ha^j>`cT!ClrOjO$%@&>*Hm)f+atFqzv=_0NJ|i-goZ$ulO{ut2#2ep
zNP`;}i_(NH2W3_!lM|N}Oja|QoLO>PLwBa<l-a4Qn>CFl=PcNksuq+xMeNLyQ@)#;
zZcdr$xh){tXtJhR{VDFWpj5S+jyb1%z<PXojhMYQD1t0uoFS4rA$0;<(Hi-%+hvnJ
zop4nU<T&suCkqU(<%Hz~?cB6u&5boTmKLWL89E$gF!TwI+!(ph>)EMCo0B#tO+7pH
zXxh=#TkU!>k!4_5v=btHnzv1w$4nxJr#`^YfhSmm2Sf#3ojhH5x^TOm%&lp+W-u(%
z+#jENcYA*C?cL?kZidGg9tpUz2t9cv#T43@XXGTH)-dOR&xDrE$#?QAH(#}re;^bQ
z{;kaR-GlN11_tYG3~Y&y&5ikFcb79*?_gk%J-~3rChb|`;qwd({5GHoe+Gun2N>%c
z*wW;Ti<EY{Yt1xL3l%g-c)%mrq|D+5F1SEDSeQVBl7UM?$3a0MPNswzDx6FS0zM2v
zEG>>MiQlhZ|6J}8U-jzyhNDLfmbsit)+@-)&%M1p>eEB-IlJDyn|pfB{^kGdUw#d{
zpY>b+>erKsGdCOO+i!ek^KZ`Izryvf3}th5&(p0>^+Rh!CO@d{NjAFe!j^V+=0X9n
z$eeAFD_l5S_(QkX8k^-TabQt7b8|BXL+i9?-Dv`hf(!!S-Rl@c0t1794>;*DfgH?c
z_Lt4D|I+T;meaXXe4fOtdaf!fD7Uo!e0jNEQSeIFZ`-!*3*CNxw{hB8W&tOkv$IVM
zSwN-u6+;#_h28+raurZf4hjsW2qC2d6I2*LRx+qCFfefDZ(4Qz-~aG`_0vE8-GBOT
z{jVu?OH;Ssj4$4HMzf}6pTW}W!nVGXZl`R!se7;!)GAoqc`J7E%3D@*>lcHW+_y|^
z7rUu%**m!vMH(UtQV3>EeYXk>m(PT$f{O^lO$dgw63cp5-ZJY2*#);?G2{xv^wn#3
zw=lb}tcNUI|B<A?zyL}Wf(_d~Ft9IRSblQhCI*c~4UC2j6E1MEoY<7PB_j(o?#Upv
zZ^i}votF=-6jjUN(o|zkRB2#zkh1ycGKGOP;0zzL1H*$-k&Fxm2F7JoD?@o2j$FuG
zaJg#AQU?Zx3!nw<LbC(p7AtVBR8@5_3w%|d>%M|%QoxicRf~B!c>hiR{Krk=U+(_-
zuG^J)%0WbJ?Y*6C-^<tT`vMxcDTzf9+*@AtO#1G<ZND$(o;WNYU%oDJ@7=fC*T(f2
zq$+rZoN}0)dv|L|VzVZb?`9qt5455t0mkX9Z}bPPm3hFx!1&p1+q2#tHp|7)#cs!#
z?biK#h8UlLt*{B_gRsu8-d719){$HH`D}4AbWEn^;@X{ylNslS*L;q-ap3Fid7yEc
zUbgCvH92dHwj`%!+?=|0+OegZHi3p{qK?)#F=-ry4#X@Di8>16LYCX057R6T5lFao
z3o=M!*pk>Nk+|(BXj}#~MAMxsW@aFg)zvL6!DY4;#173i1A(js4ZWfZ8hWMH2na6P
z#=&thcZGto>q34hF_UFII;kx4>feC|XMz{=zIz|?;&Aout2WOO?A_UMxzVCIz7w|u
zCrp(KI1un`>P&5uHJ432XKmZMI?qiabj2}=uq(+tx;=?)*Lo6Lqb0qLxhC^u>13>(
zo!AN;vAF>rwMlH<I@|2*w40l*++4ft?AEFqZW4lRS}pa7O@eJ^H{49O7^mfi{C7Q4
z5#csD#Kz`n_`>BrD{Gg{^%eMP;uG4{GfiWCGp}&mEq<kA23J>y1zfn;tQRS#vsc$k
zZp~hu(85$*XIJ?P5yDGOt$JygX_#r4u}1mT)(Bs%PZu&xf<qD{!@NGs;#F(*TySKQ
zA4sFlqCEjuHR^x0PqFFBST^aE{EAAESB?)$rgwBc2|n~;m-kKmEB1OpPkENE$P5dU
zSYx!sAmhNrX1A5gubOlp<_$Vztg)je(r=Q{rVUwBe%SCWe2^st8fIGbO3wA-6|1(1
z`bRHTb)S-2zVc&SV3pPtp%30uKK$`~C0ZA;bXuI)!h%^YUwrH8h2uKcyBt~<7N~#4
zE<7+xUVBBB-0}-Ed@hH4^1QNXwd+F}Kb}dye4U@h%Ehe>IyL##F1r=_oC{9X1Qk~J
z_(*tub)Wcl)m5Dd`&KVLd|4vv>gs?mvmACzDVouz&-pRN$3*q1=-U>tmD#U$+0UCT
z9sa@Z?Y8cwtPQiKG3}R0=8dY~nyK<*N6!`+&7+edBGvVuo}T8W(-*%kW|LvPo_n{>
zCc}D`<xgXFOr938>1SbqTV&Fy{d#(=(;_xaa|`WOHB2(-db*+~s?}~a=joQKMZrfW
zue|b5t0HUq@{kQr;%3eDTkhb!apT4{x&BgjLk}=8R9#seo!k3#!tK1gNZy@0Q|ejP
z?%cCUI``~p#qH)g4SU1(=xeQXJe26XJ9qorZ6Ewuz7}b`{`%>IdQ;U-t<qm#3+8d{
zjR@A6@Or(Ns``q9sZHy-15TQH2OQ=J7Sjzl@o1yLQ6qy*msFnWO0@+$v#EZplylP-
zZCG_RUk$VpCS9%4c(SFz?AxJ74ka3>Zp*A!pJe4!x@POOO%EP~HZvTFSZSxn*K%Z5
zM`4Lx*Xr(zRXY0I-Qo`mtM==x{IxXot3^uWhf*F>9^0T-Q@@^wQ4>CTYUQsFey%o=
z*?N)M(;92NqWtvKbfR2Oy)@dY+&SgQ>y8)GS6_Wt5!dc%tKRbBk)^lJk{`R+1s7kn
zWaC-pS^qZc!mbsi-2pF+c6nS|w63>iU%X~zR@||@aYv<oW;4E8xcsU`Mrtizo7_~Z
zrD4J<c02q$DkXL%^+k1jYoB5$^3q06jVDs&MJ&^!6vNU(JJeTSeOM(K^h!#fvs-kr
z=!-2?JK1>D0zUZ#uMM%3`dGD5edD#LBk>w;^ED6itZ%Nrw0sHIRb8!O;bkjhdwYA$
zOrveUqc^#+TVqeQ97+I<<h0JZb$08Dd0K~77I<Hk5j75su{EB#=xf-DSdU#<Qd6Hv
zw(OESyCyoYbJj7n%-m%=R;+Bh&D&in7_n-~6P>`+6}?HksedNbY2VG+Vs_)`gd0aE
zh`-#paZ^s%)rNZJY_F@guBN7XUbGgvrFLrBK{K}_oNBwa{(5pK(O`ymmM~|_i5b4R
zv9qpc9SRG{;@erUTxXBYp7v#P&IB&a%E+4Qy<%tfj~yE`UQdhJtFuR6Y)O&P(Ib!A
zb?e2&bY+W9PhUE{_0g53Cr*nCPrJ7M%9PHygqz1h@08vtjnVhk(+?MO(YuzF8=Z6L
zsB-5&*T2(rqI}gRdoFhCm6+wLrY4ctws4AxPFQH;l*1t>Q?}Zhzn+)2GAVrZ*H`+2
zE2lXfh=2cnLR{4C+||KeSB=uH<?cHWbYSVP{~@47DFK2Cu&v54dU~QfqvCXf$&3mt
z`mZHUPR|QvOJ`4(IA)SudVR8?wea*)H<)=r12f+BukO$NV>owh>HgMk>+p{+y0<R-
z*^_Lw?(W(vmetcvr*68lE_T|3?+1lkuf6MDt-tH;&YpkUzwWy=Z~ms6IoqOjPhXwB
zI@JGuZt(M~+Z``>8eY~dk-eO|WX8)mHsAjIz5X}qwO(Y=yPIbN<?ZLn_V%5$_<KC-
z*0!~)H--NBp7nI=&ic@0KYOB|cH6z^t?Zd`%rGB3crx!rr;>79vVHXDz4?cZb_=hY
zyS(Om$@jCn_?kTXW@ayVH~Ze#xOdlguloMzPu*snjkWuAk|mDr=N8k6*!=mTpx}DY
z){m1t$r4BRfJb=1hIZRt6moI#6cm*DEcx?(@4aK@+qXy8e}F33dZ}#kzUp1o&+f82
zsvP&(dZFA$rFWOvB*VMR%Wf~*<Ytwd@Aq!`yn=V1Pu{5f`1$MFY@JP~4gW9s`RDTY
z&wG8o``5nrocHYVUH={TvhTfpw)fpVw>_8d)K`aH-PHdvfXn`6hUzr7s8wC7l>?Ow
zW~>dmBH^=SqlrQNr45%hTsa(aW>ITuNc_wwjdLN-M9!?7x@?M7VYpA|vb0sxO<pdQ
zH3?$(@+y>7b$ZqG&}8Y<MK4c!cNMpsdKKdro0w#<Wtmve!II^{h8nwOXuX^o{ArE5
zpt#aiZY!;4i?XURb{V-odL^@GYsaTUHW7iR8D2P4dWL*(pXy}gGN)cG;9`f7LCL2*
ztCn|F9!gEhe7@+x*3(?4RSHuN)*s2NX<wGIGPBic#?q=VITi1&Szenvb}l+{`0AUA
z&?hPCt8cGyj|lpj7<iiN(ey1V)+f5`TXps8*3bac-RXa}xOE@8ecR?D<Dw7SzMT`h
zyZPwWw_7S+t(Mi6SSuNEY)x;(%&2<P)K%@=LQ^j;IdM`rFvm=q=Wyc6>hRN7*X?zP
zyY=Zy+`Z}DhdvgpesTKt(Iqn_3k&6xpHz!Rrg}b1`p~bEGdUyY(b16Qp<-NbL6fKI
z?I*t)&sV5PKk?hx!~3<g&ZUVf)h~q~4UtzA_#yaVVfYh`rSc!SG~KkEMO8CZnS}!C
zO_s7QRSg!|=q=cB;>4v%vx0)1n4OqKHU<ktOuDkx>qyg)rXw0hG)_t?hpY{_u*gKC
zC)BZPg@GH#2^S+l9!{;b@lT_!{o8-oIPFx<5tf;=%~EGHY&xB~>FhEE9|ywouk{KO
zvdwOt-M010<ZlbY-~W!CzVGhu{}1Q<_TTq@B`7_a@7=ztR<!<|NdLQ~8vmZmTF52o
z($h6%%@iJ%8KDLOi7JO$BOI+lgQi|sDAlQG!s4??BvT=D#S-nHt~O7XH7u!Glj=`3
zN_YwVmzt#N`mfcaP?h<kremGP{I2k&l|uFUTA|@9<~Mm?SuezWGBD0FMtPx2VJI8N
z2_<{(Pe(+%1yYhOY;-d6oYMY8ts~Q5meC1c%_*CLbt01v9Tnm2behpRX_aBBn$wA>
zmW@eS9;-IG^m5frF%3+~lJpi$S=!poV;CXT=B%uhlp2wA$RJE`8kcCdlV`WXX@%4&
zrU7<IM^1DtQ)T|@d0@+eqn%w5TJu-=iA{ADQ&VP{{9$3ZqR^^;*YE4^zd!Hv&09Ci
zqT^Sr=>OOG&!)D2fBEnKEz`rJ+0>{1jAGNRKfm$&-B0N|zTf+5eCNh@>3g>?)vW&B
zf8+1(eSc;`<aTa+XTEp)k{|5v<v0HRUi;H{e)9X>PtF%7-^s7e_x!+D+rRJqWZUES
z%dbs8v3|<${?*=3YrofK)~w(AKG^nbf8pM@d)4286oJNP?0)a_`EF)=?EAJa^BJDs
z_+9_*r}3TY_f<3B<y7~+&wXj%RQ%R|`t(Jg;-0?D+3&4?_si`E9QW>SySwdtboK!T
zM(NwzZg0E2;lYCk_dqH4?(4GKxy!!IKF-e0&bH^&_jRd8%c}O4eKp!`8~63HZQSmv
zWmS7?bEluE%6%ZXcX#gY+<DusH}Gz|ox7~^APCeS+zVP)u={rIw#zmT9z1w3A$)JK
z=2YXWueYz9dh^xybu(XmwJphyef@xeB|q;r45qK$c00F%fq@yMdE0HD&&|l7>NZ3;
zciZ)b0B(qro14rcQrjX@+ae|7zMfeYaz1?By=CF)^{emgN?(0FKjeJ)`n{gDE0%>-
zpO1btGxGJ5eb@FrU;8ogy>0H-=~dHWmTrr2OiVo$Sv2itA#3Y&&D2xTsYk@bVwO(V
z%$+U}5$SYF>}FI>>lB@Zxl@;&Aevi`M>WV2@9VsC!vZ$7ZVQ{O{#D&??)%8vN2jN3
zJ9Syia=O*ib32RI#Z2wh+!WKCFx||1w(1Ep?o@7#=u`p4UTvwc*~v*UH}!I+E8I{$
zJL%cUA~UnwE9d&WN)J{|_Bu9o*^S$I%j!#wSI+g>2C^ZL5k+h6T9EzGsi%7OFAedZ
z(p)cprr!Si{{3&!(%(N$9qm8!9#<alWME*tn8Coc$1=q6bj}ne4+aKK1_rGUPXpNt
z7#Qz@yT|MW3?d9%s}E0g(b5U+W?FT$e%jY<rxQU#DjYq663~GZByP%)gpLECt5!QS
zdRQF6C!8oL@wm7tv$!!SEHd~Sx9XDiuaAF|fBoD2{?*L$TYkU$1xm`xzW1+Pe>8sA
zwe9bJZ#K(WcE-VT=H|4>4sM-o(K@%1SdK7&HX$i^2-TyOb;1lRjRrnKER6~b9-x7d
z8LF?gz5R7|wgCr6TF%V|2dC4z(@rxqbZ~II+MBy(b^iX!*=8BZENN+HrzL|2L~bRs
zNE`%@4n=1OCp4HwFo$j3U%zX=ef8Dqdtc+e?^Q9GxiiIFr&~2I_tuHL$a>z>N++Xd
zmu-4`F>#kpWc1>^StrY$PPns4XX?)F*^0<Yp(=0hux{RA-K&-ti7KF75|P&}7QD<#
z=jP?e&C51N7B92XnerB9*Xb=!+vaRc%{)~6AF`jQv&V8db83BZ{r~;{v4c4W4lw*V
z@P{EmXzq8=svpLEazE^9ew+af8=bI`<1egwaIhzWfi0jxih<1yG{%|#KQx5#*My7{
zQjE(Qq$F4HG%zrKbpWYnsQ<TW1p@<<sC}r)|39l%{#x+&|Ej4D4D}|UO-uE^Ry8hQ
zU|@5|0ILNPj0>cA8BEQV{PplSmARFd^HrjR4}-HB181Y8*{lqKlT9fH+!z=*J5Dw*
zN-!{RPHZw@V4J^c((=8bY_p`Q=FMBdz`)A@-ayIhz`$^VffsBlh{#~o1TA!OU@&2S
zRqtRQa)E(?ae@)!gcA_uASDb83`>?QstPpmHI!mF!R*T*1r=p$c3@y&d<EixjLoXt
zz`!!euT3pY#kb$&Y&56VMYEXY(WP6jtzKt+y>qGc@0XhkUs%n~o73dM6Za^N)1XIU
z-VugpjB}KezUf44@u`n__h$9(n2HJB9ZT6Gl$J^}XG*r@&RDxyac0j{owMzcF`JW<
z6OI`R&sdkcpmD43(zKNxH+@&8xh%T1ZQ8XXXL;Y;o*L4YnUl7SCuzGm%aohaUU%-S
z++rs7>?!ZEQ|9JcH={%D-04obwd~m=-lZGz@|5~|)iO72-leWJ<yfqwK>dRYZHArA
zYnA#WHcm_qWtW^=xO?Zu14j*8BrbKHvA8+okoNAtUX5GJj234_T#-F%b@kf2Q#%q~
zB+a;LaU|)mgy@~q%hql2N!pQUcH3Ce<Lqn+-X(oAEe<3rEi;g~G$(P!ORGm`=AJ2?
zm1t#{EO>C$&b8AL9wxT4v-94GY)e^ls($9gG_A;)6F9eS37TzI%IWps>}sQE=Tu`Y
zvuo-)T|1}VJ#|}mcG%S|x7_lwzA*ZW2HsG6w|mj#{j3r1wZcvLD&}~UW@x?FTAa1Y
z=u+dORhLEGwk)k+G;CU1!F~9^QA3Ft2^-stDl%kl8;cy1Nm)H};|$Op1QG{(l0^-U
zh8fnY85kVw7L+)&%up*S>1eBAgTcYz+|7oG(o$F0&aO6Px^*LMg>c%XGs+Uv8x#z?
z;uwOCDOND77VX;YHREdR@6E@)>s9)0yPXS4{yeiL-OLqtyZGsso7?1bk1tKRDjGWV
z8poQoy6g1T>u)gFXt>E}V!FzOOINPlxTTabd-f5<dJZSG2aldSdtn~bckVr_T-?0-
z^6~Q@C?qU+sF=9$ky6s4$I8izPfgW{a&q(XNj)UcvXg;<fx|)4iA^<i=`*#oWoKs1
zF|@YHd3f>{mz0*3S5#J2^H$T)(y3doeiJhbE1S0M+IMmD@bc-~um6y+h^Uyc<Hk=(
z%gD-^J8%AyvWn8LnzifJZ)xl3>e;(*|B<nYshP9q&R<z&iDRJim_W%Kj6rJxL3qRT
zjmb><^`NDx28a3O(riw2J~d1_YHZr2wMuK1*5=B{H7oQw=Y5j%Q0d`ReA47$pL~!1
z*7xS7>Vt=EA3W4t)L}DGQAx@9V}FHOYr~z)&&8XCEF4>0I)qeJ%0KtrDSCH%&aJa{
zhiBWRUV8TNZ}`RTXP;L3uA1_5y~o`Z(K)}TUXRY*-cz5Jb8BL2WY{Kw7DWyxffhwa
zS0$H#fDjihFyLfTO3YbvI<enya=*G^ztfuCjy^drp0;e#j7mARHEL4pe9jYHwr>?y
zUuE&Cd6`wJWo7yK#WF6fIVaOQw}^-cXQZ8<_1x>yW&?g6S&1nQUMd`35<Wt{v#l~&
zA62GTw=b!;*?q?5xOCsV^tYRB)-SDHcrJI}OH~J%PXU^7evLDv#gekcwscKhs=BpP
zMPgMXr)#3Wnv&TLLAEEsUdoML;!JZ^t@@OuaapfX>xJe;#w$x@HCFnoo0;i7m>Z;d
zW!17-FSyn<l?crZ5D(;9c5b1im%m!j#&t`>1LiW#WsPOnQ$H^^hvi_HqN!+wPzd95
zp%BIfuLG)C9Uo3C)pOO1SQW7<N^{W+&88V@oC{6VrnpUUQ!r#)s&Q#b!jyxWE4Ty1
zSPe9r)`%tv3(V@;Dq8W+_PO$h8?V>?SkxKwkz>*xr%RqesTzw}H6oOFxTYMKn#i?G
zWYqy3=7l2b-UNnN@9wJCELzGbo2jvQ-Gm8GJvmDk1eRV36`sJf>&mL7*S$n6JvC!9
zlwL2?DB`fXs!@8WYiCe<Z0`4U#rb+usur&gu4Vh>`=#FZMYVPL?!4RE^X~SY`@GrO
zc=P7X2Wta99IE)|w913~EW^~7MJ{q_n$Hf+%Tb@*@+wf)Y2j6&<&Mf{uhcKRX|3kz
zmejB@L1;sywX2Va8B4clpp>T9QH{kLf?98gYTj^Kd4u&{Xuv%C-fg!lZ+~L6dY!lP
zhiv7~>lVdxgsvH1y2dtBH-TB{8k?rpEjG!Qt-DrcODtI(!PBX-Y`&{VAP8**gX`rn
zPxNAA`z-d>6drwk&SKBc<MrZs7Mt}WKW;no^3s{jI;Y!ZBB!NZeC+a??~k}`{`tyB
z&)4Pc(ks1g_9C`$57XO6orM*L*KNDS&lZ_cd0FMPt>EG##^)qoU2v3V5pZNFDdAeR
z-82*g)>*jb8-03Rv&Y~tkHKM`Gv=97(<EoET$wJjYSrrAIkStjcDm(jTR82^Wu9~1
z|J?Jisxq_K3!5))$(!!6YBku^E~`)gIQK#b#&QHGgXCkzHi^VGiNt503Ku`>Jp1jU
zWY&xoeNxKWx`Ip^8+gu0xPEU8SlPxkcV;tJ!pCl*00w0fg};Zz7-}9{|0#U*?8nEa
z^7c>k6)N^bA9!xvKhf&_@xJ8!kNhh0wiGWubxz`ozd>d5_IkdW$m>gHytCn#`Rwm}
z`0&v^jnCSrS?`rzUO%gn&HB#nGL0uph6)~xE?U7SR2m$G3>GmqG@lS=n86a{X&7}W
zbaPQ+&XSptZ48WG|IW|9|Kr`vS(Co+eP3b0FF*P0ixn-hpfW)A^|$Iy70@zu&_Z)a
zaE6A4MtppHykE}JQ)SAMNnSyos+ua3rcCnm@>E%>GAXEjlBXt`jGxa;qZF?sAx~99
zPL)YBS|)k=IC-ipQ&gE0EHKGav%^zm$`O@Gs0v))SKs@-Qos7%_r0Fg4Gav7i@YXX
zv%jgb6;vlMFfed?s;)_YCgd?S0(>Y0G&a`Wx>mn+|NPhXT_Hy%d041Say+OqiH}od
zLV>4BbCaivjF6|ogGrw3EVv{e_6VN;`rCHP$6XeW`z&rxyPdl;cN+=R^hHW9?|%g)
zI}jEE1sgd0e08-!Cs}~8!F0oAOdit}G#NST>z`?8tDMR<jlFBDz;>eg0|OINkN;z#
z21dc>cYojDVkoZQVq9D%W3nJW1ms1=WnI1|m(@5fGf6x6@O%w*R#sDMn<;51X~JW;
z*sUSuM8=WK1(^*&K?|4MQk#5**C>O*)<2j%Cp6S^lGZA|g&AUvX}SSU+qkn@eH(?7
zy6U&BUCQwxW4nvBwP>;9mSrakr`%XOA!p|{mxC)8Z_(;{Vy$!S#Eorcv(*l6G@BjB
zH%Hbrw4!18gjF^SKDO866{r0E79(Y0IZs5!`O&+x+j4H*+`{2Bp^+nDlE2C%myeT9
z>T3KD;f$+inzl${X@}r5Mt=j&_Z)srq8gtRgL)XX>lwU`>I5BWQ!!YzMr$?0GDaV!
z1Yr&zMLTijX$)RZ9JRS3SXOg!wgx3|C5H4c8ZaE>Y+z(?@eE|}tCo7YPim!e(WVER
zJQEjqJ=o+m_45AZvVWe}*O%vKf9784(iztvw3i{SY1Lka;0r82Is7+S9}t>vrGKe!
zVa>j2*REZ==v5yyWvQlD-0qY(A^)59Pxh}=nbgqmgQ2ecio?1P*Hn%*A<6=R5u5$a
z-n^nOVte>e)!fA|YWn1j<zK#+`F7j*kL|tLx!YH~vu3|#HE;3C!&g38pQ+}lkW-)W
yW1f5AjS}nQA8h*C-&M&T@9&>4^IYc6bIT1c%H|&5c)(t~$kifX0!y|Pe-Z$TVU(-@

diff --git a/src/regexp/testdata/re2-search.txt b/src/regexp/testdata/re2-search.txt
index 4d02e9cebd..8c4098a4f1 100644
--- a/src/regexp/testdata/re2-search.txt
+++ b/src/regexp/testdata/re2-search.txt
@@ -1,5 +1,5 @@
 # RE2 basic search tests built by make log
-# Thu Sep 8 13:43:43 EDT 2011
+# Wed May 12 12:13:22 EDT 2021
 Regexp.SearchTests
 strings
 ""
@@ -227,22 +227,6 @@ regexps
 0-0;0-0;0-0;0-0
 strings
 ""
-""
-regexps
-"a*"
-0-0;0-0;0-0;0-0
-0-0;0-0;0-0;0-0
-"^(?:a*)$"
-0-0;0-0;0-0;0-0
-0-0;0-0;0-0;0-0
-"^(?:a*)"
-0-0;0-0;0-0;0-0
-0-0;0-0;0-0;0-0
-"(?:a*)$"
-0-0;0-0;0-0;0-0
-0-0;0-0;0-0;0-0
-strings
-""
 "xabcdx"
 regexps
 "ab|cd"
@@ -3651,6 +3635,86 @@ regexps
 0-1;0-1;0-1;0-1
 strings
 ""
+"a"
+regexps
+"a\\C+"
+-;-;-;-
+-;-;-;-
+"^(?:a\\C+)$"
+-;-;-;-
+-;-;-;-
+"^(?:a\\C+)"
+-;-;-;-
+-;-;-;-
+"(?:a\\C+)$"
+-;-;-;-
+-;-;-;-
+strings
+""
+"a"
+regexps
+"a\\C?"
+-;-;-;-
+0-1;0-1;0-1;0-1
+"^(?:a\\C?)$"
+-;-;-;-
+0-1;0-1;0-1;0-1
+"^(?:a\\C?)"
+-;-;-;-
+0-1;0-1;0-1;0-1
+"(?:a\\C?)$"
+-;-;-;-
+0-1;0-1;0-1;0-1
+strings
+""
+"a"
+regexps
+"a\\C*?"
+-;-;-;-
+0-1;0-1;0-1;0-1
+"^(?:a\\C*?)$"
+-;-;-;-
+0-1;0-1;0-1;0-1
+"^(?:a\\C*?)"
+-;-;-;-
+0-1;0-1;0-1;0-1
+"(?:a\\C*?)$"
+-;-;-;-
+0-1;0-1;0-1;0-1
+strings
+""
+"a"
+regexps
+"a\\C+?"
+-;-;-;-
+-;-;-;-
+"^(?:a\\C+?)$"
+-;-;-;-
+-;-;-;-
+"^(?:a\\C+?)"
+-;-;-;-
+-;-;-;-
+"(?:a\\C+?)$"
+-;-;-;-
+-;-;-;-
+strings
+""
+"a"
+regexps
+"a\\C??"
+-;-;-;-
+0-1;0-1;0-1;0-1
+"^(?:a\\C??)$"
+-;-;-;-
+0-1;0-1;0-1;0-1
+"^(?:a\\C??)"
+-;-;-;-
+0-1;0-1;0-1;0-1
+"(?:a\\C??)$"
+-;-;-;-
+0-1;0-1;0-1;0-1
+strings
+""
 "baba"
 regexps
 "a\\C*|ba\\C"
@@ -3666,7 +3730,50 @@ regexps
 -;-;-;-
 -;1-4;-;1-4
 strings
-"abc"
+""
+"Inc."
 regexps
-"a.*?c|a.*?b"
+"\\w*I\\w*"
+-;-;-;-
+-;0-3;-;0-3
+"^(?:\\w*I\\w*)$"
+-;-;-;-
+-;-;-;-
+"^(?:\\w*I\\w*)"
+-;-;-;-
+-;0-3;-;0-3
+"(?:\\w*I\\w*)$"
+-;-;-;-
+-;-;-;-
+strings
+""
+"aaa"
+regexps
+"(?:|a)*"
+0-0;0-0;0-0;0-0
+0-3;0-0;0-3;0-3
+"^(?:(?:|a)*)$"
+0-0;0-0;0-0;0-0
+0-3;0-3;0-3;0-3
+"^(?:(?:|a)*)"
+0-0;0-0;0-0;0-0
+0-3;0-0;0-3;0-3
+"(?:(?:|a)*)$"
+0-0;0-0;0-0;0-0
+0-3;0-3;0-3;0-3
+strings
+""
+"aaa"
+regexps
+"(?:|a)+"
+0-0;0-0;0-0;0-0
+0-3;0-0;0-3;0-3
+"^(?:(?:|a)+)$"
+0-0;0-0;0-0;0-0
+0-3;0-3;0-3;0-3
+"^(?:(?:|a)+)"
+0-0;0-0;0-0;0-0
+0-3;0-0;0-3;0-3
+"(?:(?:|a)+)$"
+0-0;0-0;0-0;0-0
 0-3;0-3;0-3;0-3
-- 
GitLab


From cde2d857fe1f13ade269e3f7d58c6c2379a53c50 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 6 May 2021 14:01:20 -0400
Subject: [PATCH 2054/2400] cmd/go: be less strict about go version syntax in
 dependency go.mod files

It is unclear what the future holds for the go line in go.mod files.
Perhaps at some point we will switch to semver numbering.
Perhaps at some point we will allow specifying minor versions
or even betas and release candidates.
Those kinds of changes are difficult today because the go line
is parsed in dependency modules, meaning that older
versions of the Go toolchain need to understand newer go lines.

This CL makes that case - parsing a go line in a dependency's
go.mod file - a bit more lax about how to find the version.
It allows a leading v and any trailing non-digit-prefixed string
after the MAJOR.MINOR section.

There are no concrete plans to make use of any of these changes,
but if in the future we want to make them, having a few Go releases
under out belt that will accept the syntax in dependencies will
make any changes significantly easier.

Change-Id: I79bb84bba4b769048ac4b14d5c275eb9a3f270c4
Reviewed-on: https://go-review.googlesource.com/c/go/+/317690
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go.mod                                |  2 +-
 src/cmd/go.sum                                |  4 +-
 src/cmd/go/testdata/script/badgo.txt          | 50 +++++++++++++++++++
 .../vendor/golang.org/x/mod/modfile/rule.go   | 14 +++++-
 src/cmd/vendor/modules.txt                    |  2 +-
 5 files changed, 66 insertions(+), 6 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/badgo.txt

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index c3617eea0b..88f5f2883a 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -7,7 +7,7 @@ require (
 	github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639 // indirect
 	golang.org/x/arch v0.0.0-20210502124803-cbf565b21d1e
 	golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e // indirect
-	golang.org/x/mod v0.4.3-0.20210504181020-67f1c1edc27a
+	golang.org/x/mod v0.4.3-0.20210512182355-6088ed88cecd
 	golang.org/x/sys v0.0.0-20210511113859-b0526f3d8744 // indirect
 	golang.org/x/term v0.0.0-20210503060354-a79de5458b56
 	golang.org/x/tools v0.1.1-0.20210505014545-7cab0ef2e9a5
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index f42aac70d6..73750802bc 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -9,8 +9,8 @@ golang.org/x/arch v0.0.0-20210502124803-cbf565b21d1e h1:pv3V0NlNSh5Q6AX/StwGLBjc
 golang.org/x/arch v0.0.0-20210502124803-cbf565b21d1e/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
 golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e h1:8foAy0aoO5GkqCvAEJ4VC4P3zksTg4X4aJCDpZzmgQI=
 golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
-golang.org/x/mod v0.4.3-0.20210504181020-67f1c1edc27a h1:wbpC/7Wbo5WFVox32n+KjhRRLmTLq8YW/wRlL2iVAhk=
-golang.org/x/mod v0.4.3-0.20210504181020-67f1c1edc27a/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
+golang.org/x/mod v0.4.3-0.20210512182355-6088ed88cecd h1:CuRnpyMrCCBulv0d/y0CswR4K0vGydgE3DZ2wYPIOo8=
+golang.org/x/mod v0.4.3-0.20210512182355-6088ed88cecd/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
 golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210511113859-b0526f3d8744 h1:yhBbb4IRs2HS9PPlAg6DMC6mUOKexJBNsLf4Z+6En1Q=
 golang.org/x/sys v0.0.0-20210511113859-b0526f3d8744/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
diff --git a/src/cmd/go/testdata/script/badgo.txt b/src/cmd/go/testdata/script/badgo.txt
new file mode 100644
index 0000000000..cf4e2584d6
--- /dev/null
+++ b/src/cmd/go/testdata/script/badgo.txt
@@ -0,0 +1,50 @@
+go get example.net/badgo@v1.0.0
+go get example.net/badgo@v1.1.0
+go get example.net/badgo@v1.2.0
+go get example.net/badgo@v1.3.0
+go get example.net/badgo@v1.4.0
+go get example.net/badgo@v1.5.0
+! go get example.net/badgo@v1.6.0
+stderr 'invalid go version .X.Y.: must match format 1.23'
+
+-- go.mod --
+module m
+
+replace (
+	example.net/badgo v1.0.0 => ./v1.0.0
+	example.net/badgo v1.1.0 => ./v1.1.0
+	example.net/badgo v1.2.0 => ./v1.2.0
+	example.net/badgo v1.3.0 => ./v1.3.0
+	example.net/badgo v1.4.0 => ./v1.4.0
+	example.net/badgo v1.5.0 => ./v1.5.0
+	example.net/badgo v1.6.0 => ./v1.6.0
+)
+
+-- v1.0.0/go.mod --
+module example.net/badgo
+go 1.17.0
+
+-- v1.1.0/go.mod --
+module example.net/badgo
+go 1.17rc2
+
+-- v1.2.0/go.mod --
+module example.net/badgo
+go 1.17.1
+
+-- v1.3.0/go.mod --
+module example.net/badgo
+go v1.17.0
+
+-- v1.4.0/go.mod --
+module example.net/badgo
+go v1.17.0-rc.2
+
+-- v1.5.0/go.mod --
+module example.net/badgo
+go v1.17.1
+
+-- v1.6.0/go.mod --
+module example.net/badgo
+go X.Y
+
diff --git a/src/cmd/vendor/golang.org/x/mod/modfile/rule.go b/src/cmd/vendor/golang.org/x/mod/modfile/rule.go
index d8242de280..7299e15500 100644
--- a/src/cmd/vendor/golang.org/x/mod/modfile/rule.go
+++ b/src/cmd/vendor/golang.org/x/mod/modfile/rule.go
@@ -217,6 +217,7 @@ func parseToFile(file string, data []byte, fix VersionFixer, strict bool) (parse
 }
 
 var GoVersionRE = lazyregexp.New(`^([1-9][0-9]*)\.(0|[1-9][0-9]*)$`)
+var laxGoVersionRE = lazyregexp.New(`^v?(([1-9][0-9]*)\.(0|[1-9][0-9]*))([^0-9].*)$`)
 
 func (f *File) add(errs *ErrorList, block *LineBlock, line *Line, verb string, args []string, fix VersionFixer, strict bool) {
 	// If strict is false, this module is a dependency.
@@ -267,8 +268,17 @@ func (f *File) add(errs *ErrorList, block *LineBlock, line *Line, verb string, a
 			errorf("go directive expects exactly one argument")
 			return
 		} else if !GoVersionRE.MatchString(args[0]) {
-			errorf("invalid go version '%s': must match format 1.23", args[0])
-			return
+			fixed := false
+			if !strict {
+				if m := laxGoVersionRE.FindStringSubmatch(args[0]); m != nil {
+					args[0] = m[1]
+					fixed = true
+				}
+			}
+			if !fixed {
+				errorf("invalid go version '%s': must match format 1.23", args[0])
+				return
+			}
 		}
 
 		f.Go = &Go{Syntax: line}
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 10591f8041..016ec011a9 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -28,7 +28,7 @@ golang.org/x/arch/x86/x86asm
 ## explicit; go 1.17
 golang.org/x/crypto/ed25519
 golang.org/x/crypto/ed25519/internal/edwards25519
-# golang.org/x/mod v0.4.3-0.20210504181020-67f1c1edc27a
+# golang.org/x/mod v0.4.3-0.20210512182355-6088ed88cecd
 ## explicit; go 1.17
 golang.org/x/mod/internal/lazyregexp
 golang.org/x/mod/modfile
-- 
GitLab


From 7a7624a3fa4665e8d75919746b6d762d3984d471 Mon Sep 17 00:00:00 2001
From: Kevin Albertson <kevin.albertson@mongodb.com>
Date: Tue, 16 Feb 2021 14:40:49 +0000
Subject: [PATCH 2055/2400] cmd/go: permit .tbd files as a linker flag

A .tbd file is a macOS text-based stub library and is a valid input to
the macOS linker. This change adds .tbd to the allow-list for acceptable
linker flags.

Fixes golang/go#44263

Change-Id: Ie5439a13325dbc908e42f95ec70aca518bb549f9
GitHub-Last-Rev: 6055c3b5fa8c8146c0c5c976aa8e1d219e01e414
GitHub-Pull-Request: golang/go#44276
Reviewed-on: https://go-review.googlesource.com/c/go/+/292269
Reviewed-by: Cherry Mui <cherryyz@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Ian Lance Taylor <iant@golang.org>
---
 src/cmd/go/internal/work/security.go      | 4 ++--
 src/cmd/go/internal/work/security_test.go | 2 ++
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/cmd/go/internal/work/security.go b/src/cmd/go/internal/work/security.go
index 36bbab37ee..e9b9f6c6c0 100644
--- a/src/cmd/go/internal/work/security.go
+++ b/src/cmd/go/internal/work/security.go
@@ -208,8 +208,8 @@ var validLinkerFlags = []*lazyregexp.Regexp{
 	re(`-Wl,-z,(no)?execstack`),
 	re(`-Wl,-z,relro`),
 
-	re(`[a-zA-Z0-9_/].*\.(a|o|obj|dll|dylib|so)`), // direct linker inputs: x.o or libfoo.so (but not -foo.o or @foo.o)
-	re(`\./.*\.(a|o|obj|dll|dylib|so)`),
+	re(`[a-zA-Z0-9_/].*\.(a|o|obj|dll|dylib|so|tbd)`), // direct linker inputs: x.o or libfoo.so (but not -foo.o or @foo.o)
+	re(`\./.*\.(a|o|obj|dll|dylib|so|tbd)`),
 }
 
 var validLinkerFlagsWithNextArg = []string{
diff --git a/src/cmd/go/internal/work/security_test.go b/src/cmd/go/internal/work/security_test.go
index 4f2e0eb21a..8d4be0abfc 100644
--- a/src/cmd/go/internal/work/security_test.go
+++ b/src/cmd/go/internal/work/security_test.go
@@ -164,6 +164,8 @@ var goodLinkerFlags = [][]string{
 	{"-Wl,-framework", "-Wl,Chocolate"},
 	{"-Wl,-framework,Chocolate"},
 	{"-Wl,-unresolved-symbols=ignore-all"},
+	{"libcgotbdtest.tbd"},
+	{"./libcgotbdtest.tbd"},
 }
 
 var badLinkerFlags = [][]string{
-- 
GitLab


From 92c189f2117415ff7a4bd9652422ba9af1745cb9 Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Thu, 13 May 2021 16:36:32 -0400
Subject: [PATCH 2056/2400] cmd/link: resolve ABI alias for
 runtime.unreachableMethod

We redirect references to unreachable methods to
runtime.unreachableMethod. We choose to use ABIInternal symbol
for this, because runtime.unreachableMethod is a defined Go
function.

When linking against shared libraries, and ABI wrappers are not
enabled, the imported function symbols are all ABI0 and aliased
to ABIInternal. We need to resolve ABI alias in this case.

Change-Id: Idd64ef46ce0b5f54882ea0069ce0d59dc9b7a599
Reviewed-on: https://go-review.googlesource.com/c/go/+/319891
Trust: Cherry Mui <cherryyz@google.com>
Run-TryBot: Cherry Mui <cherryyz@google.com>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/link/internal/ld/data.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/cmd/link/internal/ld/data.go b/src/cmd/link/internal/ld/data.go
index 6659e95cc1..223df63d9d 100644
--- a/src/cmd/link/internal/ld/data.go
+++ b/src/cmd/link/internal/ld/data.go
@@ -340,6 +340,7 @@ func (st *relocSymState) relocsym(s loader.Sym, P []byte) {
 			if weak && !ldr.AttrReachable(rs) {
 				// Redirect it to runtime.unreachableMethod, which will throw if called.
 				rs = syms.unreachableMethod
+				rs = ldr.ResolveABIAlias(rs)
 			}
 			if target.IsExternal() {
 				nExtReloc++
@@ -623,6 +624,7 @@ func extreloc(ctxt *Link, ldr *loader.Loader, s loader.Sym, r loader.Reloc) (loa
 		rs := ldr.ResolveABIAlias(r.Sym())
 		if r.Weak() && !ldr.AttrReachable(rs) {
 			rs = ctxt.ArchSyms.unreachableMethod
+			rs = ldr.ResolveABIAlias(rs)
 		}
 		rs, off := FoldSubSymbolOffset(ldr, rs)
 		rr.Xadd = r.Add() + off
-- 
GitLab


From b4833f7c06c332ad2ef30666144a20fb7838aba1 Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Thu, 13 May 2021 16:48:50 -0400
Subject: [PATCH 2057/2400] cmd/link: always mark runtime.unreachableMethod
 symbol

In the deadcode path we mark runtime.unreachableMethod symbol,
which is a special symbol used for redirecting unreachable
methods. Currently this code is conditioned on not -linkshared.
This is wrong. It should be marked with -linkshared mode as well.

In fact, -linkshared should only affect the entry symbol. Change
the code accordingly.

Change-Id: I252abf850212a930f275589ef0035a43e52cb9cc
Reviewed-on: https://go-review.googlesource.com/c/go/+/319893
Trust: Cherry Mui <cherryyz@google.com>
Run-TryBot: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
---
 src/cmd/link/internal/ld/deadcode.go | 40 ++++++++++++++--------------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/src/cmd/link/internal/ld/deadcode.go b/src/cmd/link/internal/ld/deadcode.go
index 1ed5598c99..416e5da398 100644
--- a/src/cmd/link/internal/ld/deadcode.go
+++ b/src/cmd/link/internal/ld/deadcode.go
@@ -65,26 +65,26 @@ func (d *deadcodePass) init() {
 			}
 		}
 		names = append(names, *flagEntrySymbol)
-		// runtime.unreachableMethod is a function that will throw if called.
-		// We redirect unreachable methods to it.
-		names = append(names, "runtime.unreachableMethod")
-		if !d.ctxt.linkShared && d.ctxt.BuildMode != BuildModePlugin {
-			// runtime.buildVersion and runtime.modinfo are referenced in .go.buildinfo section
-			// (see function buildinfo in data.go). They should normally be reachable from the
-			// runtime. Just make it explicit, in case.
-			names = append(names, "runtime.buildVersion", "runtime.modinfo")
-		}
-		if d.ctxt.BuildMode == BuildModePlugin {
-			names = append(names, objabi.PathToPrefix(*flagPluginPath)+"..inittask", objabi.PathToPrefix(*flagPluginPath)+".main", "go.plugin.tabs")
-
-			// We don't keep the go.plugin.exports symbol,
-			// but we do keep the symbols it refers to.
-			exportsIdx := d.ldr.Lookup("go.plugin.exports", 0)
-			if exportsIdx != 0 {
-				relocs := d.ldr.Relocs(exportsIdx)
-				for i := 0; i < relocs.Count(); i++ {
-					d.mark(relocs.At(i).Sym(), 0)
-				}
+	}
+	// runtime.unreachableMethod is a function that will throw if called.
+	// We redirect unreachable methods to it.
+	names = append(names, "runtime.unreachableMethod")
+	if !d.ctxt.linkShared && d.ctxt.BuildMode != BuildModePlugin {
+		// runtime.buildVersion and runtime.modinfo are referenced in .go.buildinfo section
+		// (see function buildinfo in data.go). They should normally be reachable from the
+		// runtime. Just make it explicit, in case.
+		names = append(names, "runtime.buildVersion", "runtime.modinfo")
+	}
+	if d.ctxt.BuildMode == BuildModePlugin {
+		names = append(names, objabi.PathToPrefix(*flagPluginPath)+"..inittask", objabi.PathToPrefix(*flagPluginPath)+".main", "go.plugin.tabs")
+
+		// We don't keep the go.plugin.exports symbol,
+		// but we do keep the symbols it refers to.
+		exportsIdx := d.ldr.Lookup("go.plugin.exports", 0)
+		if exportsIdx != 0 {
+			relocs := d.ldr.Relocs(exportsIdx)
+			for i := 0; i < relocs.Count(); i++ {
+				d.mark(relocs.At(i).Sym(), 0)
 			}
 		}
 	}
-- 
GitLab


From 3a0453514a80b001e6135f98ec4e0da5a78ab267 Mon Sep 17 00:00:00 2001
From: John Bampton <jbampton@gmail.com>
Date: Fri, 7 May 2021 10:47:28 +0000
Subject: [PATCH 2058/2400] all: fix spelling

Change-Id: Id991d8e81e04835cabfb02d07a2199bfb553726c
GitHub-Last-Rev: 5d0b55d49127a2e2ba3148d20a58c52debcae12b
GitHub-Pull-Request: golang/go#44802
Reviewed-on: https://go-review.googlesource.com/c/go/+/299069
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Heschi Kreinick <heschi@google.com>
---
 src/net/http/httputil/reverseproxy_test.go | 2 +-
 src/net/http/socks_bundle.go               | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/net/http/httputil/reverseproxy_test.go b/src/net/http/httputil/reverseproxy_test.go
index b89eb90ad6..22720caf93 100644
--- a/src/net/http/httputil/reverseproxy_test.go
+++ b/src/net/http/httputil/reverseproxy_test.go
@@ -1209,7 +1209,7 @@ func TestReverseProxyWebSocket(t *testing.T) {
 	}
 }
 
-func TestReverseProxyWebSocketCancelation(t *testing.T) {
+func TestReverseProxyWebSocketCancellation(t *testing.T) {
 	n := 5
 	triggerCancelCh := make(chan bool, n)
 	nthResponse := func(i int) string {
diff --git a/src/net/http/socks_bundle.go b/src/net/http/socks_bundle.go
index e446669589..e6db1c7640 100644
--- a/src/net/http/socks_bundle.go
+++ b/src/net/http/socks_bundle.go
@@ -453,7 +453,7 @@ func (up *socksUsernamePassword) Authenticate(ctx context.Context, rw io.ReadWri
 		b = append(b, up.Username...)
 		b = append(b, byte(len(up.Password)))
 		b = append(b, up.Password...)
-		// TODO(mikio): handle IO deadlines and cancelation if
+		// TODO(mikio): handle IO deadlines and cancellation if
 		// necessary
 		if _, err := rw.Write(b); err != nil {
 			return err
-- 
GitLab


From 12d383c7c7406dda2cb969a89ce3801c220614c5 Mon Sep 17 00:00:00 2001
From: itchyny <itchyny@hatena.ne.jp>
Date: Thu, 13 May 2021 04:03:18 +0000
Subject: [PATCH 2059/2400] debug/macho: fix a typo in macho.go

Change-Id: Ica47b53decf6690fbd37e666e9de5098117b82de
GitHub-Last-Rev: 6aabb208a6499e29fe32a2f0d928c4e027d556b2
GitHub-Pull-Request: golang/go#46147
Reviewed-on: https://go-review.googlesource.com/c/go/+/319592
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
Trust: Brad Fitzpatrick <bradfitz@golang.org>
Trust: Heschi Kreinick <heschi@google.com>
---
 src/debug/macho/macho.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/debug/macho/macho.go b/src/debug/macho/macho.go
index 49e107eed3..9fa9f95752 100644
--- a/src/debug/macho/macho.go
+++ b/src/debug/macho/macho.go
@@ -4,7 +4,7 @@
 
 // Mach-O header data structures
 // Originally at:
-// http://developer.apple.com/mac/library/documentation/DeveloperTools/Conceptual/MachORuntime/Reference/reference.html (since deleted by Apply)
+// http://developer.apple.com/mac/library/documentation/DeveloperTools/Conceptual/MachORuntime/Reference/reference.html (since deleted by Apple)
 // Archived copy at:
 // https://web.archive.org/web/20090819232456/http://developer.apple.com/documentation/DeveloperTools/Conceptual/MachORuntime/index.html
 // For cloned PDF see:
-- 
GitLab


From c925e1546ee72e40ca5351f3773379e99a6b8cdf Mon Sep 17 00:00:00 2001
From: eric fang <eric.fang@arm.com>
Date: Fri, 7 May 2021 05:48:18 +0000
Subject: [PATCH 2060/2400] cmd/internal/obj/arm64: disable AL and NV for some
 condition operation instructions

According to the armv8-a reference manual, conditions AL and NV are not allowed
for instructions CINC, CINV, CNEG, CSET and CSETM. This CL adds this check and
the corresponding test cases.

Change-Id: Icb496b7b13a353f41491f2de4d939a5cd88abb04
Reviewed-on: https://go-review.googlesource.com/c/go/+/317912
Reviewed-by: eric fang <eric.fang@arm.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
Trust: eric fang <eric.fang@arm.com>
Run-TryBot: eric fang <eric.fang@arm.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 .../asm/internal/asm/testdata/arm64error.s    | 10 ++++++++
 src/cmd/internal/obj/arm64/asm7.go            | 24 +++++++++----------
 2 files changed, 21 insertions(+), 13 deletions(-)

diff --git a/src/cmd/asm/internal/asm/testdata/arm64error.s b/src/cmd/asm/internal/asm/testdata/arm64error.s
index 66fc910759..cf57179e43 100644
--- a/src/cmd/asm/internal/asm/testdata/arm64error.s
+++ b/src/cmd/asm/internal/asm/testdata/arm64error.s
@@ -52,6 +52,16 @@ TEXT errors(SB),$0
 	NEGSW	R7@>2, R5                                        // ERROR "unsupported shift operator"
 	CINC	CS, R2, R3, R4                                   // ERROR "illegal combination"
 	CSEL	LT, R1, R2                                       // ERROR "illegal combination"
+	CINC	AL, R2, R3                                       // ERROR "invalid condition"
+	CINC	NV, R2, R3                                       // ERROR "invalid condition"
+	CINVW	AL, R2, R3                                       // ERROR "invalid condition"
+	CINV	NV, R2, R3                                       // ERROR "invalid condition"
+	CNEG	AL, R2, R3                                       // ERROR "invalid condition"
+	CNEGW	NV, R2, R3                                       // ERROR "invalid condition"
+	CSET	AL, R2                                           // ERROR "invalid condition"
+	CSET	NV, R2                                           // ERROR "invalid condition"
+	CSETMW	AL, R2                                           // ERROR "invalid condition"
+	CSETM	NV, R2                                           // ERROR "invalid condition"
 	LDP.P	8(R2), (R2, R3)                                  // ERROR "constrained unpredictable behavior"
 	LDP.W	8(R3), (R2, R3)                                  // ERROR "constrained unpredictable behavior"
 	LDP	(R1), (R2, R2)                                   // ERROR "constrained unpredictable behavior"
diff --git a/src/cmd/internal/obj/arm64/asm7.go b/src/cmd/internal/obj/arm64/asm7.go
index 575436d764..b8c3cd97c7 100644
--- a/src/cmd/internal/obj/arm64/asm7.go
+++ b/src/cmd/internal/obj/arm64/asm7.go
@@ -3536,27 +3536,25 @@ func (c *ctxt7) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		o1 = c.oprrr(p, p.As)
 
 		cond := int(p.From.Reg)
-		if cond < COND_EQ || cond > COND_NV {
+		// AL and NV are not allowed for CINC/CINV/CNEG/CSET/CSETM instructions
+		if cond < COND_EQ || cond > COND_NV || (cond == COND_AL || cond == COND_NV) && p.From3Type() == obj.TYPE_NONE {
 			c.ctxt.Diag("invalid condition: %v", p)
 		} else {
 			cond -= COND_EQ
 		}
 
 		r := int(p.Reg)
-		var rf int
-		if r != 0 {
-			if p.From3Type() == obj.TYPE_NONE {
-				/* CINC/CINV/CNEG */
-				rf = r
-				cond ^= 1
-			} else {
-				rf = int(p.GetFrom3().Reg) /* CSEL */
+		var rf int = r
+		if p.From3Type() == obj.TYPE_NONE {
+			/* CINC/CINV/CNEG or CSET/CSETM*/
+			if r == 0 {
+				/* CSET/CSETM */
+				rf = REGZERO
+				r = rf
 			}
-		} else {
-			/* CSET */
-			rf = REGZERO
-			r = rf
 			cond ^= 1
+		} else {
+			rf = int(p.GetFrom3().Reg) /* CSEL */
 		}
 
 		rt := int(p.To.Reg)
-- 
GitLab


From d137b745398e8313c0f086d4d044751295be6163 Mon Sep 17 00:00:00 2001
From: Ben Hoyt <benhoyt@gmail.com>
Date: Fri, 14 May 2021 09:59:20 +1200
Subject: [PATCH 2061/2400] cmd/go: fix spacing in help text of -overlay flag

There was a space missing in the first line shown below, and an extra
space in the second line shown. Thanks Peter Bourgon for noting this.

BEFORE:
$ go help build | grep -A1 'has some limitations'
has some limitations:importantly, cgo files included from outside the
include path must be  in the same directory as the Go package they are

AFTER:
$ go help build | grep -A1 'has some limitations'
has some limitations: importantly, cgo files included from outside the
include path must be in the same directory as the Go package they are

Note that I edited alldocs.go by hand here, as the mkalldocs.sh script
produces a lot more changes, for example adding the -insecure flag
documentation in. Not sure what's wrong there.

Change-Id: I303f6d6b42b0e24cec0748a949dc23beec64b917
Reviewed-on: https://go-review.googlesource.com/c/go/+/319949
Reviewed-by: Jay Conrod <jayconrod@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/alldocs.go             | 4 ++--
 src/cmd/go/internal/work/build.go | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index 052b61c03d..fcc7f36335 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -174,8 +174,8 @@
 // 		a build will run as if the disk file path exists with the contents
 // 		given by the backing file paths, or as if the disk file path does not
 // 		exist if its backing file path is empty. Support for the -overlay flag
-// 		has some limitations:importantly, cgo files included from outside the
-// 		include path must be  in the same directory as the Go package they are
+// 		has some limitations: importantly, cgo files included from outside the
+// 		include path must be in the same directory as the Go package they are
 // 		included from, and overlays will not appear when binaries and tests are
 // 		run through go run and go test respectively.
 // 	-pkgdir dir
diff --git a/src/cmd/go/internal/work/build.go b/src/cmd/go/internal/work/build.go
index 1babbda889..0ed2389cd5 100644
--- a/src/cmd/go/internal/work/build.go
+++ b/src/cmd/go/internal/work/build.go
@@ -128,8 +128,8 @@ and test commands:
 		a build will run as if the disk file path exists with the contents
 		given by the backing file paths, or as if the disk file path does not
 		exist if its backing file path is empty. Support for the -overlay flag
-		has some limitations:importantly, cgo files included from outside the
-		include path must be  in the same directory as the Go package they are
+		has some limitations: importantly, cgo files included from outside the
+		include path must be in the same directory as the Go package they are
 		included from, and overlays will not appear when binaries and tests are
 		run through go run and go test respectively.
 	-pkgdir dir
-- 
GitLab


From a938e529861215d9721f5e2590d5166bfbf2d271 Mon Sep 17 00:00:00 2001
From: Manlio Perillo <manlio.perillo@gmail.com>
Date: Thu, 13 May 2021 16:08:59 +0200
Subject: [PATCH 2062/2400] cmd/go: fix a portability issue in the cd script
 command

Currently all script tests use the UNIX path separator with the cd
command, causing the PWD environment variable to have the incorrect path
separator on Windows.

Call filepath.FromSlash on the cd command argument.
Update the testdata/script/README to document that the cd argument must
use slashes.

Add a regression test.

To reproduce this issue, a test must use the cd command followed by a
stdout or stderr command containing the pattern $PWD.

Change-Id: Ib2dc5f185cc2476451402787996d14df91f7dddb
Reviewed-on: https://go-review.googlesource.com/c/go/+/319311
Reviewed-by: Jay Conrod <jayconrod@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/script_test.go                        |  2 +-
 src/cmd/go/testdata/script/README                |  1 +
 src/cmd/go/testdata/script/test_script_cmdcd.txt | 13 +++++++++++++
 3 files changed, 15 insertions(+), 1 deletion(-)
 create mode 100644 src/cmd/go/testdata/script/test_script_cmdcd.txt

diff --git a/src/cmd/go/script_test.go b/src/cmd/go/script_test.go
index 327eaff445..639e907db0 100644
--- a/src/cmd/go/script_test.go
+++ b/src/cmd/go/script_test.go
@@ -517,7 +517,7 @@ func (ts *testScript) cmdCd(want simpleStatus, args []string) {
 		ts.fatalf("usage: cd dir")
 	}
 
-	dir := args[0]
+	dir := filepath.FromSlash(args[0])
 	if !filepath.IsAbs(dir) {
 		dir = filepath.Join(ts.cd, dir)
 	}
diff --git a/src/cmd/go/testdata/script/README b/src/cmd/go/testdata/script/README
index d7e67bb7b6..48e4055b0b 100644
--- a/src/cmd/go/testdata/script/README
+++ b/src/cmd/go/testdata/script/README
@@ -102,6 +102,7 @@ The commands are:
 
 - cd dir
   Change to the given directory for future commands.
+  The directory must use slashes as path separator.
 
 - chmod perm path...
   Change the permissions of the files or directories named by the path arguments
diff --git a/src/cmd/go/testdata/script/test_script_cmdcd.txt b/src/cmd/go/testdata/script/test_script_cmdcd.txt
new file mode 100644
index 0000000000..6e6f67e13d
--- /dev/null
+++ b/src/cmd/go/testdata/script/test_script_cmdcd.txt
@@ -0,0 +1,13 @@
+# Tests that after a cd command, where usually the UNIX path separator is used,
+# a match against $PWD does not fail on Windows.
+
+cd $WORK/a/b/c/pkg
+
+go list -find -f {{.Root}}
+stdout $PWD
+
+-- $WORK/a/b/c/pkg/go.mod --
+module pkg
+
+-- $WORK/a/b/c/pkg/pkg.go --
+package pkg
-- 
GitLab


From 0eb38f2b164ec5b0094c5895cfe1b3a40c183d50 Mon Sep 17 00:00:00 2001
From: Manlio Perillo <manlio.perillo@gmail.com>
Date: Wed, 12 May 2021 12:09:18 +0200
Subject: [PATCH 2063/2400] cmd/go/internal/load: override Package.Root in
 module mode

The Context.ImportDir method in the go/build package sets Package.Root
to $GOPATH, if a package is inside a GOPATH workspace.  The
loadPackageData function keeps this value even when modules are enabled.

Override Package.Root when modules are enabled, instead of just set its
value when Context.ImportDir was unable to set it.

Add a regression test.

Fixes #46119

Change-Id: I900a33fe13a445cb771e2952d0d830f1b4a5921f
Reviewed-on: https://go-review.googlesource.com/c/go/+/319209
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Trust: Bryan C. Mills <bcmills@google.com>
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/internal/load/pkg.go               |  4 +++-
 .../testdata/script/list_gomod_in_gopath.txt  | 23 +++++++++++++++++++
 2 files changed, 26 insertions(+), 1 deletion(-)
 create mode 100644 src/cmd/go/testdata/script/list_gomod_in_gopath.txt

diff --git a/src/cmd/go/internal/load/pkg.go b/src/cmd/go/internal/load/pkg.go
index a3b96702ce..738904865e 100644
--- a/src/cmd/go/internal/load/pkg.go
+++ b/src/cmd/go/internal/load/pkg.go
@@ -849,7 +849,9 @@ func loadPackageData(ctx context.Context, path, parentPath, parentDir, parentRoo
 				buildMode = build.ImportComment
 			}
 			data.p, data.err = cfg.BuildContext.ImportDir(r.dir, buildMode)
-			if data.p.Root == "" && cfg.ModulesEnabled {
+			if cfg.ModulesEnabled {
+				// Override data.p.Root, since ImportDir sets it to $GOPATH, if
+				// the module is inside $GOPATH/src.
 				if info := modload.PackageModuleInfo(ctx, path); info != nil {
 					data.p.Root = info.Dir
 				}
diff --git a/src/cmd/go/testdata/script/list_gomod_in_gopath.txt b/src/cmd/go/testdata/script/list_gomod_in_gopath.txt
new file mode 100644
index 0000000000..064f33adc3
--- /dev/null
+++ b/src/cmd/go/testdata/script/list_gomod_in_gopath.txt
@@ -0,0 +1,23 @@
+# Issue 46119
+
+# When a module is inside a GOPATH workspace, Package.Root should be set to
+# Module.Dir instead of $GOPATH/src.
+
+env GOPATH=$WORK/tmp
+cd $WORK/tmp/src/test
+
+go list -f {{.Root}}
+stdout ^$PWD$
+
+# Were we really inside a GOPATH workspace?
+env GO111MODULE=off
+go list -f {{.Root}}
+stdout ^$WORK/tmp$
+
+-- $WORK/tmp/src/test/go.mod --
+module test
+
+-- $WORK/tmp/src/test/main.go --
+package main
+
+func main() {}
-- 
GitLab


From 3d324f127dbb916f38d7476e9c4ff106e5d54f99 Mon Sep 17 00:00:00 2001
From: Michael Fraenkel <michael.fraenkel@gmail.com>
Date: Thu, 13 May 2021 09:41:45 -0600
Subject: [PATCH 2064/2400] net/http: prevent infinite wait during
 TestMissingStatusNoPanic

If the client request never makes it to the server, the outstanding
accept is never broken. Change the test to always close the listening
socket when the client request completes.

Updates #45358

Change-Id: I744a91dfa11704e7e528163d7669c394e90456dc
Reviewed-on: https://go-review.googlesource.com/c/go/+/319275
Trust: Heschi Kreinick <heschi@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/net/http/transport_test.go | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/src/net/http/transport_test.go b/src/net/http/transport_test.go
index 5b6a5aa992..dcaacece61 100644
--- a/src/net/http/transport_test.go
+++ b/src/net/http/transport_test.go
@@ -5322,7 +5322,6 @@ func TestMissingStatusNoPanic(t *testing.T) {
 
 	ln := newLocalListener(t)
 	addr := ln.Addr().String()
-	shutdown := make(chan bool, 1)
 	done := make(chan bool)
 	fullAddrURL := fmt.Sprintf("http://%s", addr)
 	raw := "HTTP/1.1 400\r\n" +
@@ -5334,10 +5333,7 @@ func TestMissingStatusNoPanic(t *testing.T) {
 		"Aloha Olaa"
 
 	go func() {
-		defer func() {
-			ln.Close()
-			close(done)
-		}()
+		defer close(done)
 
 		conn, _ := ln.Accept()
 		if conn != nil {
@@ -5368,7 +5364,7 @@ func TestMissingStatusNoPanic(t *testing.T) {
 		t.Errorf("got=%v want=%q", err, want)
 	}
 
-	close(shutdown)
+	ln.Close()
 	<-done
 }
 
-- 
GitLab


From 02699f810a05215060ba2181f394d551819ad7d4 Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Thu, 13 May 2021 18:19:42 -0400
Subject: [PATCH 2065/2400] runtime: mark osyield nosplit on OpenBSD

osyield is called in code paths that are not allowed to split
stack, e.g. casgstatus called from entersyscall/exitsyscall.
It is nosplit on all other platforms. Mark it nosplit on OpenBSD
as well.

Change-Id: I3fed5d7f58b3d50610beca6eed2c7e902b8ec52c
Reviewed-on: https://go-review.googlesource.com/c/go/+/319969
Trust: Cherry Mui <cherryyz@google.com>
Run-TryBot: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Joel Sing <joel@sing.id.au>
---
 src/runtime/sys_openbsd1.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/runtime/sys_openbsd1.go b/src/runtime/sys_openbsd1.go
index 6f9ad356d4..cb5d35879c 100644
--- a/src/runtime/sys_openbsd1.go
+++ b/src/runtime/sys_openbsd1.go
@@ -23,6 +23,7 @@ func thrwakeup(ident uintptr, n int32) int32 {
 }
 func thrwakeup_trampoline()
 
+//go:nosplit
 func osyield() {
 	libcCall(unsafe.Pointer(funcPC(sched_yield_trampoline)), unsafe.Pointer(nil))
 }
-- 
GitLab


From ce92a2023ccd77ca609126aa8a6e881c9def57f0 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Thu, 13 May 2021 09:48:40 -0400
Subject: [PATCH 2066/2400] cmd/go: error out of 'go mod tidy' if the go
 version is newer than supported

Fixes #46142

Change-Id: Ib7a0a159e53cbe476be6aa9a050add10cc750dec
Reviewed-on: https://go-review.googlesource.com/c/go/+/319669
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modload/load.go           |  8 ++-
 .../go/testdata/script/mod_tidy_too_new.txt   | 57 +++++++++++++++++++
 2 files changed, 64 insertions(+), 1 deletion(-)
 create mode 100644 src/cmd/go/testdata/script/mod_tidy_too_new.txt

diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index f30ac6e0c8..83fc7c09c3 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -922,7 +922,8 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 	}
 
 	if params.GoVersion != "" {
-		if semver.Compare("v"+params.GoVersion, narrowAllVersionV) < 0 && !ld.UseVendorAll {
+		goVersionV := "v" + params.GoVersion
+		if semver.Compare(goVersionV, narrowAllVersionV) < 0 && !ld.UseVendorAll {
 			// The module's go version explicitly predates the change in "all" for lazy
 			// loading, so continue to use the older interpretation.
 			// (If params.GoVersion is empty, we are probably not in any module at all
@@ -930,6 +931,11 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 			ld.allClosesOverTests = true
 		}
 
+		if ld.Tidy && semver.Compare(goVersionV, "v"+latestGoVersion()) > 0 {
+			ld.errorf("go mod tidy: go.mod file indicates go %s, but maximum supported version is %s\n", params.GoVersion, latestGoVersion())
+			base.ExitIfErrors()
+		}
+
 		var err error
 		ld.requirements, err = convertDepth(ctx, ld.requirements, modDepthFromGoVersion(params.GoVersion))
 		if err != nil {
diff --git a/src/cmd/go/testdata/script/mod_tidy_too_new.txt b/src/cmd/go/testdata/script/mod_tidy_too_new.txt
new file mode 100644
index 0000000000..b9c53b510d
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_tidy_too_new.txt
@@ -0,0 +1,57 @@
+# https://golang.org/issue/46142: 'go mod tidy' should error out if the version
+# in the go.mod file is newer than the most recent supported version.
+
+cp go.mod go.mod.orig
+
+
+# If the go.mod file specifies an unsupported Go version, 'go mod tidy' should
+# refuse to edit it: we don't know what a tidy go.mod file for that version
+# would look like.
+
+! go mod tidy
+stderr 'go mod tidy: go.mod file indicates go 2000.0, but maximum supported version is '$goversion'$'
+cmp go.mod go.mod.orig
+
+
+# The -e flag should push past the error and edit the file anyway,
+# but preserve the too-high version.
+
+cp go.mod.orig go.mod
+go mod tidy -e
+stderr 'go mod tidy: go.mod file indicates go 2000.0, but maximum supported version is '$goversion'$'
+cmp go.mod go.mod.tidy
+
+
+# Explicitly switching to a supported version should suppress the error completely.
+
+cp go.mod.orig go.mod
+go mod tidy -go=1.17
+! stderr 'maximum supported version'
+go mod edit -go=1.17 go.mod.tidy
+cmp go.mod go.mod.tidy
+
+
+-- go.mod --
+module example.net/from/the/future
+
+go 2000.0
+
+replace example.net/m v0.0.0 => ./m
+-- go.mod.tidy --
+module example.net/from/the/future
+
+go 2000.0
+
+replace example.net/m v0.0.0 => ./m
+
+require example.net/m v0.0.0
+-- x.go --
+package x
+
+import "example.net/m"
+-- m/go.mod --
+module example.net/m
+
+go 1.17
+-- m/m.go --
+package m
-- 
GitLab


From bade680867c9b1eecc7b5d177ed94c455a72e50a Mon Sep 17 00:00:00 2001
From: Lynn Boger <laboger@linux.vnet.ibm.com>
Date: Wed, 12 May 2021 12:11:03 -0500
Subject: [PATCH 2067/2400] runtime/cgo: fix crosscall2 on ppc64x

Some uses of crosscall2 did not work on ppc64le and probably
aix-ppc64. In particular, if there was a main program compiled
with -buildmode=pie and used a plugin which invoked crosscall2,
then failures could occur due to R2 getting set incorrectly along the
way. The problem was due to R2 being saved on the caller's
stack; it is now saved on the crosscall2 stack. More details can be
found in the issue.

This adds a testcase where the main program is built with pie
and the plugin invokes crosscall2.

This also changes the save of the CR bits from MOVD to MOVW as
it should be.

Fixes #43228

Change-Id: Ib5673e25a2ec5ee46bf9a1ffb0cb1f3ef5449086
Reviewed-on: https://go-review.googlesource.com/c/go/+/319489
Run-TryBot: Lynn Boger <laboger@linux.vnet.ibm.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
Trust: Heschi Kreinick <heschi@google.com>
---
 misc/cgo/testplugin/plugin_test.go |  7 +++++++
 src/runtime/cgo/asm_ppc64x.s       | 12 ++++++++----
 2 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/misc/cgo/testplugin/plugin_test.go b/misc/cgo/testplugin/plugin_test.go
index 28a8c669c0..a6accc1dfb 100644
--- a/misc/cgo/testplugin/plugin_test.go
+++ b/misc/cgo/testplugin/plugin_test.go
@@ -263,6 +263,13 @@ func TestIssue25756(t *testing.T) {
 	}
 }
 
+// Test with main using -buildmode=pie with plugin for issue #43228
+func TestIssue25756pie(t *testing.T) {
+	goCmd(t, "build", "-buildmode=plugin", "-o", "life.so", "./issue25756/plugin")
+	goCmd(t, "build", "-buildmode=pie", "-o", "issue25756pie.exe", "./issue25756/main.go")
+	run(t, "./issue25756pie.exe")
+}
+
 func TestMethod(t *testing.T) {
 	// Exported symbol's method must be live.
 	goCmd(t, "build", "-buildmode=plugin", "-o", "plugin.so", "./method/plugin.go")
diff --git a/src/runtime/cgo/asm_ppc64x.s b/src/runtime/cgo/asm_ppc64x.s
index 9dec8d04ce..187b2d42f6 100644
--- a/src/runtime/cgo/asm_ppc64x.s
+++ b/src/runtime/cgo/asm_ppc64x.s
@@ -12,17 +12,20 @@
 // func crosscall2(fn, a unsafe.Pointer, n int32, ctxt uintptr)
 // Saves C callee-saved registers and calls cgocallback with three arguments.
 // fn is the PC of a func(a unsafe.Pointer) function.
+// The value of R2 is saved on the new stack frame, and not
+// the caller's frame due to issue #43228.
 TEXT crosscall2(SB),NOSPLIT|NOFRAME,$0
 	// Start with standard C stack frame layout and linkage
 	MOVD	LR, R0
 	MOVD	R0, 16(R1)	// Save LR in caller's frame
 	MOVW	CR, R0		// Save CR in caller's frame
-	MOVD	R0, 8(R1)
-	MOVD	R2, 24(R1)	// Save TOC in caller's frame
+	MOVW	R0, 8(R1)
 
 	BL	saveregs2<>(SB)
 
 	MOVDU	R1, (-288-3*8-FIXED_FRAME)(R1)
+	// Save the caller's R2
+	MOVD	R2, 24(R1)
 
 	// Initialize Go ABI environment
 	BL	runtime·reginit(SB)
@@ -41,12 +44,13 @@ TEXT crosscall2(SB),NOSPLIT|NOFRAME,$0
 	MOVD	R6, FIXED_FRAME+16(R1)	// ctxt uintptr
 	BL	runtime·cgocallback(SB)
 
+	// Restore the caller's R2
+	MOVD	24(R1), R2
 	ADD	$(288+3*8+FIXED_FRAME), R1
 
 	BL	restoreregs2<>(SB)
 
-	MOVD	24(R1), R2
-	MOVD	8(R1), R0
+	MOVW	8(R1), R0
 	MOVFL	R0, $0xff
 	MOVD	16(R1), R0
 	MOVD	R0, LR
-- 
GitLab


From b1aff42900133e4fbc9b7d7c1af13c77e4f647b0 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Mon, 10 May 2021 17:19:50 -0400
Subject: [PATCH 2068/2400] cmd/go: don't print 'go get' deprecation notices in
 the main module

If a user runs 'go get example.com/cmd' for a package in the main
module, it's more likely they intend to fill in missing dependencies
for that package (especially with -u). If the intent were only to
build and install, 'go install example.com/cmd' would be a better
choice.

For #43684

Resolving a comment on CL 305670.

Change-Id: I5c80ffdcdb3425b448f2f49cc20b07a18cb2bbe9
Reviewed-on: https://go-review.googlesource.com/c/go/+/318570
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go/internal/modget/get.go             |  8 +++----
 .../script/mod_get_deprecate_install.txt      | 21 +++++++++++++++++--
 2 files changed, 23 insertions(+), 6 deletions(-)

diff --git a/src/cmd/go/internal/modget/get.go b/src/cmd/go/internal/modget/get.go
index 3a24b6a2f7..2a7fe5226f 100644
--- a/src/cmd/go/internal/modget/get.go
+++ b/src/cmd/go/internal/modget/get.go
@@ -386,14 +386,14 @@ func runGet(ctx context.Context, cmd *base.Command, args []string) {
 		}
 		load.CheckPackageErrors(pkgs)
 
-		haveExe := false
+		haveExternalExe := false
 		for _, pkg := range pkgs {
-			if pkg.Name == "main" {
-				haveExe = true
+			if pkg.Name == "main" && pkg.Module != nil && pkg.Module.Path != modload.Target.Path {
+				haveExternalExe = true
 				break
 			}
 		}
-		if haveExe {
+		if haveExternalExe {
 			fmt.Fprint(os.Stderr, "go get: installing executables with 'go get' in module mode is deprecated.")
 			var altMsg string
 			if modload.HasModRoot() {
diff --git a/src/cmd/go/testdata/script/mod_get_deprecate_install.txt b/src/cmd/go/testdata/script/mod_get_deprecate_install.txt
index d832b5f2e8..63cd27a42d 100644
--- a/src/cmd/go/testdata/script/mod_get_deprecate_install.txt
+++ b/src/cmd/go/testdata/script/mod_get_deprecate_install.txt
@@ -7,16 +7,33 @@ go get example.com/cmd/a
 stderr '^go get: installing executables with ''go get'' in module mode is deprecated.$'
 stderr 'Use ''go install pkg@version'' instead.'
 
-
-go mod init m
+cp go.mod.orig go.mod
 
 # 'go get' inside a module with a non-main package does not print a message.
 # This will stop building in the future, but it's the command we want to use.
 go get rsc.io/quote
 ! stderr deprecated
+cp go.mod.orig go.mod
 
 # 'go get' inside a module with an executable prints a different
 # deprecation message.
 go get example.com/cmd/a
 stderr '^go get: installing executables with ''go get'' in module mode is deprecated.$'
 stderr 'To adjust and download dependencies of the current module, use ''go get -d'''
+cp go.mod.orig go.mod
+
+# 'go get' should not print a warning for a main package inside the main module.
+# The intent is most likely to update the dependencies of that package.
+# 'go install' would be used otherwise.
+go get m
+! stderr .
+cp go.mod.orig go.mod
+
+-- go.mod.orig --
+module m
+
+go 1.17
+-- main.go --
+package main
+
+func main() {}
-- 
GitLab


From b9b2bed8933a467dcc48eedeec83dfea7ff3148a Mon Sep 17 00:00:00 2001
From: "Andrew G. Morgan" <agm@google.com>
Date: Wed, 12 May 2021 20:41:26 -0700
Subject: [PATCH 2069/2400] syscall: some containers may fail
 syscall.TestSetuidEtc

The test previously had the hardcoded assumption that /proc/self/status
files had "Groups:" lines containing numerical IDs in ascending order.
Because of the possibility of non-monotonic ordering of GIDs in user
namespaces, this assumption was not universally true for all
/proc/self/gid_map setups.

To ensure this test can pass in those setups, sanity check failed
"Groups:" line matches with a string sorted version of the expected
values. (For the test cases here, numerical and string sorted order
are guaranteed to match.)

Fixes #46145

Change-Id: Ia060e80b123604bc394a15c02582fc406f944d36
Reviewed-on: https://go-review.googlesource.com/c/go/+/319591
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Tobias Klauser <tobias.klauser@gmail.com>
---
 misc/cgo/test/issue1435.go        | 21 +++++++++++++++++----
 src/syscall/syscall_linux_test.go | 21 +++++++++++++++++----
 2 files changed, 34 insertions(+), 8 deletions(-)

diff --git a/misc/cgo/test/issue1435.go b/misc/cgo/test/issue1435.go
index cf34ce8db6..92c6b99846 100644
--- a/misc/cgo/test/issue1435.go
+++ b/misc/cgo/test/issue1435.go
@@ -9,6 +9,7 @@ package cgotest
 import (
 	"fmt"
 	"os"
+	"sort"
 	"strings"
 	"syscall"
 	"testing"
@@ -105,11 +106,23 @@ func compareStatus(filter, expect string) error {
 				// "Pid:\t".
 			}
 			if strings.HasPrefix(line, filter) {
-				if line != expected {
-					return fmt.Errorf("%q got:%q want:%q (bad) [pid=%d file:'%s' %v]\n", tf, line, expected, pid, string(d), expectedProc)
+				if line == expected {
+					foundAThread = true
+					break
+				}
+				if filter == "Groups:" && strings.HasPrefix(line, "Groups:\t") {
+					// https://github.com/golang/go/issues/46145
+					// Containers don't reliably output this line in sorted order so manually sort and compare that.
+					a := strings.Split(line[8:], " ")
+					sort.Strings(a)
+					got := strings.Join(a, " ")
+					if got == expected[8:] {
+						foundAThread = true
+						break
+					}
+
 				}
-				foundAThread = true
-				break
+				return fmt.Errorf("%q got:%q want:%q (bad) [pid=%d file:'%s' %v]\n", tf, line, expected, pid, string(d), expectedProc)
 			}
 		}
 	}
diff --git a/src/syscall/syscall_linux_test.go b/src/syscall/syscall_linux_test.go
index adeb7c9ebb..442dc9f10e 100644
--- a/src/syscall/syscall_linux_test.go
+++ b/src/syscall/syscall_linux_test.go
@@ -14,6 +14,7 @@ import (
 	"os/signal"
 	"path/filepath"
 	"runtime"
+	"sort"
 	"strconv"
 	"strings"
 	"syscall"
@@ -583,11 +584,23 @@ func compareStatus(filter, expect string) error {
 				// "Pid:\t".
 			}
 			if strings.HasPrefix(line, filter) {
-				if line != expected {
-					return fmt.Errorf("%q got:%q want:%q (bad) [pid=%d file:'%s' %v]\n", tf, line, expected, pid, string(d), expectedProc)
+				if line == expected {
+					foundAThread = true
+					break
 				}
-				foundAThread = true
-				break
+				if filter == "Groups:" && strings.HasPrefix(line, "Groups:\t") {
+					// https://github.com/golang/go/issues/46145
+					// Containers don't reliably output this line in sorted order so manually sort and compare that.
+					a := strings.Split(line[8:], " ")
+					sort.Strings(a)
+					got := strings.Join(a, " ")
+					if got == expected[8:] {
+						foundAThread = true
+						break
+					}
+
+				}
+				return fmt.Errorf("%q got:%q want:%q (bad) [pid=%d file:'%s' %v]\n", tf, line, expected, pid, string(d), expectedProc)
 			}
 		}
 	}
-- 
GitLab


From a2c07a9a1a445c28fa4db9bd1472b28cad3ca818 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Mon, 17 May 2021 12:18:12 +0200
Subject: [PATCH 2070/2400] all: update golang.org/x/net to latest

To pull in CL 318309.

For #41184

Change-Id: I99adb0478e71dbd72e13551a87ed09eae2a0ef2c
Reviewed-on: https://go-review.googlesource.com/c/go/+/320312
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/go.mod                                | 2 +-
 src/go.sum                                | 4 ++--
 src/vendor/golang.org/x/net/route/empty.s | 1 +
 src/vendor/modules.txt                    | 2 +-
 4 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/go.mod b/src/go.mod
index a3ceb05890..93ff2d8d3c 100644
--- a/src/go.mod
+++ b/src/go.mod
@@ -4,7 +4,7 @@ go 1.17
 
 require (
 	golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e
-	golang.org/x/net v0.0.0-20210505024714-0287a6fb4125
+	golang.org/x/net v0.0.0-20210510120150-4163338589ed
 	golang.org/x/sys v0.0.0-20210503173754-0981d6026fa6 // indirect
 	golang.org/x/text v0.3.7-0.20210503195748-5c7c50ebbd4f // indirect
 )
diff --git a/src/go.sum b/src/go.sum
index 27513a350d..1390ce6d45 100644
--- a/src/go.sum
+++ b/src/go.sum
@@ -1,7 +1,7 @@
 golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e h1:8foAy0aoO5GkqCvAEJ4VC4P3zksTg4X4aJCDpZzmgQI=
 golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
-golang.org/x/net v0.0.0-20210505024714-0287a6fb4125 h1:Ugb8sMTWuWRC3+sz5WeN/4kejDx9BvIwnPUiJBjJE+8=
-golang.org/x/net v0.0.0-20210505024714-0287a6fb4125/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20210510120150-4163338589ed h1:p9UgmWI9wKpfYmgaV/IZKGdXc5qEK45tDwwwDyjS26I=
+golang.org/x/net v0.0.0-20210510120150-4163338589ed/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/sys v0.0.0-20210503173754-0981d6026fa6 h1:cdsMqa2nXzqlgs183pHxtvoVwU7CyzaCTAUOg94af4c=
 golang.org/x/sys v0.0.0-20210503173754-0981d6026fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/text v0.3.7-0.20210503195748-5c7c50ebbd4f h1:yQJrRE0hDxDFmZLlRaw+3vusO4fwNHgHIjUOMO7bHYI=
diff --git a/src/vendor/golang.org/x/net/route/empty.s b/src/vendor/golang.org/x/net/route/empty.s
index bff0231c7d..90ab4ca3d8 100644
--- a/src/vendor/golang.org/x/net/route/empty.s
+++ b/src/vendor/golang.org/x/net/route/empty.s
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build darwin && go1.12
 // +build darwin,go1.12
 
 // This exists solely so we can linkname in symbols from syscall.
diff --git a/src/vendor/modules.txt b/src/vendor/modules.txt
index 5b939af60d..1b850342a5 100644
--- a/src/vendor/modules.txt
+++ b/src/vendor/modules.txt
@@ -8,7 +8,7 @@ golang.org/x/crypto/curve25519
 golang.org/x/crypto/hkdf
 golang.org/x/crypto/internal/subtle
 golang.org/x/crypto/poly1305
-# golang.org/x/net v0.0.0-20210505024714-0287a6fb4125
+# golang.org/x/net v0.0.0-20210510120150-4163338589ed
 ## explicit; go 1.17
 golang.org/x/net/dns/dnsmessage
 golang.org/x/net/http/httpguts
-- 
GitLab


From bfe3573d58d7c49c4d58e0ab392eb0b5a660d262 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Mon, 17 May 2021 16:11:51 -0400
Subject: [PATCH 2071/2400] go/token: correct the interval notation used in
 some panic messages

Fix an apparent typo for the right-hand bound in a couple panic
messages, where '[' was used instead of ']'.

Fixes #46215

Change-Id: Ie419c404ca72ed085a83a2c38ea1a5d6ed326cca
Reviewed-on: https://go-review.googlesource.com/c/go/+/320510
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/token/position.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/go/token/position.go b/src/go/token/position.go
index bbcd8b022b..0d7982c670 100644
--- a/src/go/token/position.go
+++ b/src/go/token/position.go
@@ -278,7 +278,7 @@ func (f *File) Pos(offset int) Pos {
 //
 func (f *File) Offset(p Pos) int {
 	if int(p) < f.base || int(p) > f.base+f.size {
-		panic(fmt.Sprintf("invalid Pos value %d (should be in [%d, %d[)", p, f.base, f.base+f.size))
+		panic(fmt.Sprintf("invalid Pos value %d (should be in [%d, %d])", p, f.base, f.base+f.size))
 	}
 	return int(p) - f.base
 }
@@ -346,7 +346,7 @@ func (f *File) position(p Pos, adjusted bool) (pos Position) {
 func (f *File) PositionFor(p Pos, adjusted bool) (pos Position) {
 	if p != NoPos {
 		if int(p) < f.base || int(p) > f.base+f.size {
-			panic(fmt.Sprintf("invalid Pos value %d (should be in [%d, %d[)", p, f.base, f.base+f.size))
+			panic(fmt.Sprintf("invalid Pos value %d (should be in [%d, %d])", p, f.base, f.base+f.size))
 		}
 		pos = f.position(p, adjusted)
 	}
-- 
GitLab


From 5e191f8f4885cac105b6d7069e02c0c8d149c22c Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Mon, 17 May 2021 10:30:01 +1000
Subject: [PATCH 2072/2400] time: rewrite the documentation for layout strings

People continue to be confused by how these work. Address that by some
rejiggering.

Introduce a constant called Layout that both defines the time and
provides a reference point for Parse and Format to refer to. We can
then delete much redundancy, especially for Format's comments, but
Parse tightens a bit too.

Then change the way the concept of the layout string is introduced,
and provide a clearer catalog of what its elements are.

Fixes #38871

Change-Id: Ib967ae70c7d5798a97b865cdda1fda4daed8a99a
Reviewed-on: https://go-review.googlesource.com/c/go/+/320252
Trust: Rob Pike <r@golang.org>
Run-TryBot: Rob Pike <r@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/time/format.go | 163 +++++++++++++++++++++++----------------------
 1 file changed, 85 insertions(+), 78 deletions(-)

diff --git a/src/time/format.go b/src/time/format.go
index f6dc8ee621..6040ed5aeb 100644
--- a/src/time/format.go
+++ b/src/time/format.go
@@ -7,71 +7,89 @@ package time
 import "errors"
 
 // These are predefined layouts for use in Time.Format and time.Parse.
-// The reference time used in the layouts is the specific time:
-//	Mon Jan 2 15:04:05 MST 2006
-// which is Unix time 1136239445. Since MST is GMT-0700,
-// the reference time can be thought of as
+// The reference time used in these layouts is the specific time stamp:
 //	01/02 03:04:05PM '06 -0700
-// To define your own format, write down what the reference time would look
-// like formatted your way; see the values of constants like ANSIC,
-// StampMicro or Kitchen for examples. The model is to demonstrate what the
-// reference time looks like so that the Format and Parse methods can apply
-// the same transformation to a general time value.
+// (January 2, 15:04:05, 2006, in time zone seven hours west of GMT).
+// That value is recorded as the constant named Layout, listed below. As a Unix
+// time, this is 1136239445. Since MST is GMT-0700, the reference would be
+// printed by the Unix date command as:
+//	Mon Jan 2 15:04:05 MST 2006
+// It is a regrettable historic error that the date uses the American convention
+// of putting the numerical month before the day.
 //
-// Some valid layouts are invalid time values for time.Parse, due to formats
-// such as _ for space padding and Z for zone information.
+// The example for Time.Format demonstrates the working of the layout string
+// in detail and is a good reference.
+//
+// Note that the RFC822, RFC850, and RFC1123 formats should be applied
+// only to local times. Applying them to UTC times will use "UTC" as the
+// time zone abbreviation, while strictly speaking those RFCs require the
+// use of "GMT" in that case.
+// In general RFC1123Z should be used instead of RFC1123 for servers
+// that insist on that format, and RFC3339 should be preferred for new protocols.
+// RFC3339, RFC822, RFC822Z, RFC1123, and RFC1123Z are useful for formatting;
+// when used with time.Parse they do not accept all the time formats
+// permitted by the RFCs and they do accept time formats not formally defined.
+// The RFC3339Nano format removes trailing zeros from the seconds field
+// and thus may not sort correctly once formatted.
 //
-// Within the format string, an underscore _ represents a space that may be
-// replaced by a digit if the following number (a day) has two digits; for
-// compatibility with fixed-width Unix time formats.
+// Most programs can use one of the defined constants as the layout passed to
+// Format or Parse. The rest of this comment can be ignored unless you are
+// creating a custom layout string.
 //
-// A decimal point followed by one or more zeros represents a fractional
-// second, printed to the given number of decimal places.
-// Either a comma or decimal point followed by one or more nines represents
-// a fractional second, printed to the given number of decimal places, with
-// trailing zeros removed.
-// When parsing (only), the input may contain a fractional second
-// field immediately after the seconds field, even if the layout does not
-// signify its presence. In that case either a comma or a decimal point
-// followed by a maximal series of digits is parsed as a fractional second.
+// To define your own format, write down what the reference time would look like
+// formatted your way; see the values of constants like ANSIC, StampMicro or
+// Kitchen for examples. The model is to demonstrate what the reference time
+// looks like so that the Format and Parse methods can apply the same
+// transformation to a general time value.
+//
+// Here is a summary of the components of a layout string. Each element shows by
+// example the formatting of an element of the reference time. Only these values
+// are recognized. Text in the layout string that is not recognized as part of
+// the reference time is echoed verbatim during Format and expected to appear
+// verbatim in the input to Parse.
+//
+//	Year: "2006" "06"
+//	Month: "Jan" "January"
+//	Textual day of the week: "Mon" "Monday"
+//	Numeric day of the month: "2" "_2" "02"
+//	Numeric day of the year: "__2" "002"
+//	Hour: "15" "3" "03" (PM or AM)
+//	Minute: "4" "04"
+//	Second: "5" "05"
+//	AM/PM mark: "PM"
 //
 // Numeric time zone offsets format as follows:
-//	-0700  ±hhmm
-//	-07:00 ±hh:mm
-//	-07    ±hh
+//	"-0700"  ±hhmm
+//	"-07:00" ±hh:mm
+//	"-07"    ±hh
 // Replacing the sign in the format with a Z triggers
 // the ISO 8601 behavior of printing Z instead of an
 // offset for the UTC zone. Thus:
-//	Z0700  Z or ±hhmm
-//	Z07:00 Z or ±hh:mm
-//	Z07    Z or ±hh
+//	"Z0700"  Z or ±hhmm
+//	"Z07:00" Z or ±hh:mm
+//	"Z07"    Z or ±hh
 //
-// The recognized day of week formats are "Mon" and "Monday".
-// The recognized month formats are "Jan" and "January".
+// Within the format string, the underscores in "_2" and "__2" represent spaces
+// that may be replaced by digits if the following number has multiple digits,
+// for compatibility with fixed-width Unix time formats. A leading zero represents
+// a zero-padded value.
 //
-// The formats 2, _2, and 02 are unpadded, space-padded, and zero-padded
-// day of month. The formats __2 and 002 are space-padded and zero-padded
+// The formats  and 002 are space-padded and zero-padded
 // three-character day of year; there is no unpadded day of year format.
 //
-// Text in the format string that is not recognized as part of the reference
-// time is echoed verbatim during Format and expected to appear verbatim
-// in the input to Parse.
+// A decimal point followed by one or more zeros represents a fractional
+// second, printed to the given number of decimal places.
+// Either a comma or decimal point followed by one or more nines represents
+// a fractional second, printed to the given number of decimal places, with
+// trailing zeros removed.
+// For example "15:04:05,000" or "15:04:05.000" formats or parses with
+// millisecond precision.
 //
-// The executable example for Time.Format demonstrates the working
-// of the layout string in detail and is a good reference.
+// Some valid layouts are invalid time values for time.Parse, due to formats
+// such as _ for space padding and Z for zone information.
 //
-// Note that the RFC822, RFC850, and RFC1123 formats should be applied
-// only to local times. Applying them to UTC times will use "UTC" as the
-// time zone abbreviation, while strictly speaking those RFCs require the
-// use of "GMT" in that case.
-// In general RFC1123Z should be used instead of RFC1123 for servers
-// that insist on that format, and RFC3339 should be preferred for new protocols.
-// RFC3339, RFC822, RFC822Z, RFC1123, and RFC1123Z are useful for formatting;
-// when used with time.Parse they do not accept all the time formats
-// permitted by the RFCs and they do accept time formats not formally defined.
-// The RFC3339Nano format removes trailing zeros from the seconds field
-// and thus may not sort correctly once formatted.
 const (
+	Layout      = "01/02 03:04:05PM '06 -0700" // The reference time, in numerical order.
 	ANSIC       = "Mon Jan _2 15:04:05 2006"
 	UnixDate    = "Mon Jan _2 15:04:05 MST 2006"
 	RubyDate    = "Mon Jan 02 15:04:05 -0700 2006"
@@ -531,23 +549,12 @@ func (t Time) GoString() string {
 	return string(buf)
 }
 
-// Format returns a textual representation of the time value formatted
-// according to layout, which defines the format by showing how the reference
-// time, defined to be
-//	Mon Jan 2 15:04:05 -0700 MST 2006
-// would be displayed if it were the value; it serves as an example of the
-// desired output. The same display rules will then be applied to the time
-// value.
+// Format returns a textual representation of the time value formatted according
+// to the layout defined by the argument. See the documentation for the
+// constant called Layout to see how to represent the layout format.
 //
-// A fractional second is represented by adding either a comma or a
-// period and zeros to the end of the seconds section of layout string,
-// as in "15:04:05,000" or "15:04:05.000" to format a time stamp with
-// millisecond precision.
-//
-// Predefined layouts ANSIC, UnixDate, RFC3339 and others describe standard
-// and convenient representations of the reference time. For more information
-// about the formats and the definition of the reference time, see the
-// documentation for ANSIC and the other constants defined by this package.
+// The executable example for Time.Format demonstrates the working
+// of the layout string in detail and is a good reference.
 func (t Time) Format(layout string) string {
 	const bufSize = 64
 	var b []byte
@@ -855,21 +862,19 @@ func skip(value, prefix string) (string, error) {
 }
 
 // Parse parses a formatted string and returns the time value it represents.
-// The layout defines the format by showing how the reference time,
-// defined to be
-//	Mon Jan 2 15:04:05 -0700 MST 2006
-// would be interpreted if it were the value; it serves as an example of
-// the input format. The same interpretation will then be made to the
-// input string.
+// See the documentation for the constant called Layout to see how to
+// represent the format. The second argument must be parseable using
+// the format string (layout) provided as the first argument.
 //
-// Predefined layouts ANSIC, UnixDate, RFC3339 and others describe standard
-// and convenient representations of the reference time. For more information
-// about the formats and the definition of the reference time, see the
-// documentation for ANSIC and the other constants defined by this package.
-// Also, the executable example for Time.Format demonstrates the working
-// of the layout string in detail and is a good reference.
+// The example for Time.Format demonstrates the working of the layout string
+// in detail and is a good reference.
 //
-// Elements omitted from the value are assumed to be zero or, when
+// When parsing (only), the input may contain a fractional second
+// field immediately after the seconds field, even if the layout does not
+// signify its presence. In that case either a comma or a decimal point
+// followed by a maximal series of digits is parsed as a fractional second.
+//
+// Elements omitted from the layout are assumed to be zero or, when
 // zero is impossible, one, so parsing "3:04pm" returns the time
 // corresponding to Jan 1, year 0, 15:04:00 UTC (note that because the year is
 // 0, this time is before the zero Time).
@@ -879,6 +884,8 @@ func skip(value, prefix string) (string, error) {
 // For layouts specifying the two-digit year 06, a value NN >= 69 will be treated
 // as 19NN and a value NN < 69 will be treated as 20NN.
 //
+// The remainder of this comment describes the handling of time zones.
+//
 // In the absence of a time zone indicator, Parse returns a time in UTC.
 //
 // When parsing a time with a zone offset like -0700, if the offset corresponds
-- 
GitLab


From 8b0901fd32aa9c29a1fa4ed8cd517914920a1509 Mon Sep 17 00:00:00 2001
From: Jeff Widman <jeff@jeffwidman.com>
Date: Tue, 18 May 2021 06:09:20 +0000
Subject: [PATCH 2073/2400] doc/go1.17: fix typo "avoding" -> "avoiding"

Change-Id: Ice4a6e7ec8175caf3f049ac1ca39929059f90e9c
GitHub-Last-Rev: a2d59d55511ac7825cbeca6651a79b1060d90de3
GitHub-Pull-Request: golang/go#46227
Reviewed-on: https://go-review.googlesource.com/c/go/+/320729
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Alberto Donizetti <alb.donizetti@gmail.com>
Trust: Alberto Donizetti <alb.donizetti@gmail.com>
---
 doc/go1.17.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index cf856a1e73..4b2f4bce79 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -60,7 +60,7 @@ Do not send CLs removing the interior tags from such phrases.
 <p><!-- golang.org/issue/36460 -->
   If a module specifies <code>go</code> <code>1.17</code> or higher in its
   <code>go.mod</code> file, its transitive requirements are now loaded lazily,
-  avoding the need to download or read <code>go.mod</code> files for
+  avoiding the need to download or read <code>go.mod</code> files for
   otherwise-irrelevant dependencies. To support lazy loading, in Go 1.17 modules
   the <code>go</code> command maintains <em>explicit</em> requirements in
   the <code>go.mod</code> file for every dependency that provides any package
-- 
GitLab


From 690a8c3fb136431d4f22894c545ea99278758570 Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Thu, 13 May 2021 19:22:57 -0400
Subject: [PATCH 2074/2400] make.bash: fix misuse of continue

Apparently, in bash, the "continue" keyword can only be used
inside of a loop, not in an if block. If readelf exists but $CC
does not, make.bash emits a warning:

./make.bash: line 135: continue: only meaningful in a `for', `while', or `until' loop

Change it to a conditional.

Change-Id: I00a0940ed99bc0c565094e506705961b6b3d362e
Reviewed-on: https://go-review.googlesource.com/c/go/+/320170
Trust: Cherry Mui <cherryyz@google.com>
Run-TryBot: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
---
 src/make.bash | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/make.bash b/src/make.bash
index 3d1b0c87e7..4fb13f6275 100755
--- a/src/make.bash
+++ b/src/make.bash
@@ -132,10 +132,11 @@ fi
 
 # Test which linker/loader our system is using
 if type readelf >/dev/null 2>&1; then
-	echo "int main() { return 0; }" | ${CC:-cc} -o ./test-musl-ldso -x c - || continue
-	LDSO=$(readelf -l ./test-musl-ldso | grep 'interpreter:' | sed -e 's/^.*interpreter: \(.*\)[]]/\1/') >/dev/null 2>&1
-	[ -z "$LDSO" ] || export GO_LDSO="$LDSO"
-	rm -f ./test-musl-ldso
+	if echo "int main() { return 0; }" | ${CC:-cc} -o ./test-musl-ldso -x c - >/dev/null 2>&1; then
+		LDSO=$(readelf -l ./test-musl-ldso | grep 'interpreter:' | sed -e 's/^.*interpreter: \(.*\)[]]/\1/') >/dev/null 2>&1
+		[ -z "$LDSO" ] || export GO_LDSO="$LDSO"
+		rm -f ./test-musl-ldso
+	fi
 fi
 
 # Clean old generated file that will cause problems in the build.
-- 
GitLab


From 048cb4ceee652e358d84fbca260fc93d7a0dfbe3 Mon Sep 17 00:00:00 2001
From: Roland Shoemaker <roland@golang.org>
Date: Mon, 10 May 2021 09:59:07 -0700
Subject: [PATCH 2075/2400] crypto/x509: remove duplicate import

Change-Id: I86742ae7aa4ff49a38f8e3bc1d64fb223feae73e
Reviewed-on: https://go-review.googlesource.com/c/go/+/318409
Trust: Roland Shoemaker <roland@golang.org>
Trust: Katie Hockman <katie@golang.org>
Run-TryBot: Roland Shoemaker <roland@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
---
 src/crypto/x509/parser.go | 115 +++++++++++++++++++-------------------
 1 file changed, 57 insertions(+), 58 deletions(-)

diff --git a/src/crypto/x509/parser.go b/src/crypto/x509/parser.go
index 578227ab8e..3d51ddd7f5 100644
--- a/src/crypto/x509/parser.go
+++ b/src/crypto/x509/parser.go
@@ -24,7 +24,6 @@ import (
 	"unicode/utf8"
 
 	"golang.org/x/crypto/cryptobyte"
-	cbasn1 "golang.org/x/crypto/cryptobyte/asn1"
 	cryptobyte_asn1 "golang.org/x/crypto/cryptobyte/asn1"
 )
 
@@ -55,23 +54,23 @@ func isPrintable(b byte) bool {
 // UTF8String, BMPString, and IA5String. This is mostly copied from the
 // respective encoding/asn1.parse... methods, rather than just increasing
 // the API surface of that package.
-func parseASN1String(tag cbasn1.Tag, value []byte) (string, error) {
+func parseASN1String(tag cryptobyte_asn1.Tag, value []byte) (string, error) {
 	switch tag {
-	case cbasn1.T61String:
+	case cryptobyte_asn1.T61String:
 		return string(value), nil
-	case cbasn1.PrintableString:
+	case cryptobyte_asn1.PrintableString:
 		for _, b := range value {
 			if !isPrintable(b) {
 				return "", errors.New("invalid PrintableString")
 			}
 		}
 		return string(value), nil
-	case cbasn1.UTF8String:
+	case cryptobyte_asn1.UTF8String:
 		if !utf8.Valid(value) {
 			return "", errors.New("invalid UTF-8 string")
 		}
 		return string(value), nil
-	case cbasn1.Tag(asn1.TagBMPString):
+	case cryptobyte_asn1.Tag(asn1.TagBMPString):
 		if len(value)%2 != 0 {
 			return "", errors.New("invalid BMPString")
 		}
@@ -88,7 +87,7 @@ func parseASN1String(tag cbasn1.Tag, value []byte) (string, error) {
 		}
 
 		return string(utf16.Decode(s)), nil
-	case cbasn1.IA5String:
+	case cryptobyte_asn1.IA5String:
 		s := string(value)
 		if isIA5String(s) != nil {
 			return "", errors.New("invalid IA5String")
@@ -101,7 +100,7 @@ func parseASN1String(tag cbasn1.Tag, value []byte) (string, error) {
 // parseName parses a DER encoded Name as defined in RFC 5280. We may
 // want to export this function in the future for use in crypto/tls.
 func parseName(raw cryptobyte.String) (*pkix.RDNSequence, error) {
-	if !raw.ReadASN1(&raw, cbasn1.SEQUENCE) {
+	if !raw.ReadASN1(&raw, cryptobyte_asn1.SEQUENCE) {
 		return nil, errors.New("x509: invalid RDNSequence")
 	}
 
@@ -109,12 +108,12 @@ func parseName(raw cryptobyte.String) (*pkix.RDNSequence, error) {
 	for !raw.Empty() {
 		var rdnSet pkix.RelativeDistinguishedNameSET
 		var set cryptobyte.String
-		if !raw.ReadASN1(&set, cbasn1.SET) {
+		if !raw.ReadASN1(&set, cryptobyte_asn1.SET) {
 			return nil, errors.New("x509: invalid RDNSequence")
 		}
 		for !set.Empty() {
 			var atav cryptobyte.String
-			if !set.ReadASN1(&atav, cbasn1.SEQUENCE) {
+			if !set.ReadASN1(&atav, cryptobyte_asn1.SEQUENCE) {
 				return nil, errors.New("x509: invalid RDNSequence: invalid attribute")
 			}
 			var attr pkix.AttributeTypeAndValue
@@ -122,7 +121,7 @@ func parseName(raw cryptobyte.String) (*pkix.RDNSequence, error) {
 				return nil, errors.New("x509: invalid RDNSequence: invalid attribute type")
 			}
 			var rawValue cryptobyte.String
-			var valueTag cbasn1.Tag
+			var valueTag cryptobyte_asn1.Tag
 			if !atav.ReadAnyASN1(&rawValue, &valueTag) {
 				return nil, errors.New("x509: invalid RDNSequence: invalid attribute value")
 			}
@@ -149,7 +148,7 @@ func parseAI(der cryptobyte.String) (pkix.AlgorithmIdentifier, error) {
 		return ai, nil
 	}
 	var params cryptobyte.String
-	var tag cbasn1.Tag
+	var tag cryptobyte_asn1.Tag
 	if !der.ReadAnyASN1Element(&params, &tag) {
 		return ai, errors.New("x509: malformed parameters")
 	}
@@ -162,11 +161,11 @@ func parseValidity(der cryptobyte.String) (time.Time, time.Time, error) {
 	extract := func() (time.Time, error) {
 		var t time.Time
 		switch {
-		case der.PeekASN1Tag(cbasn1.UTCTime):
+		case der.PeekASN1Tag(cryptobyte_asn1.UTCTime):
 			// TODO(rolandshoemaker): once #45411 is fixed, the following code
 			// should be replaced with a call to der.ReadASN1UTCTime.
 			var utc cryptobyte.String
-			if !der.ReadASN1(&utc, cbasn1.UTCTime) {
+			if !der.ReadASN1(&utc, cryptobyte_asn1.UTCTime) {
 				return t, errors.New("x509: malformed UTCTime")
 			}
 			s := string(utc)
@@ -190,7 +189,7 @@ func parseValidity(der cryptobyte.String) (time.Time, time.Time, error) {
 				// UTCTime only encodes times prior to 2050. See https://tools.ietf.org/html/rfc5280#section-4.1.2.5.1
 				t = t.AddDate(-100, 0, 0)
 			}
-		case der.PeekASN1Tag(cbasn1.GeneralizedTime):
+		case der.PeekASN1Tag(cryptobyte_asn1.GeneralizedTime):
 			if !der.ReadASN1GeneralizedTime(&t) {
 				return t, errors.New("x509: malformed GeneralizedTime")
 			}
@@ -217,13 +216,13 @@ func parseExtension(der cryptobyte.String) (pkix.Extension, error) {
 	if !der.ReadASN1ObjectIdentifier(&ext.Id) {
 		return ext, errors.New("x509: malformed extention OID field")
 	}
-	if der.PeekASN1Tag(cbasn1.BOOLEAN) {
+	if der.PeekASN1Tag(cryptobyte_asn1.BOOLEAN) {
 		if !der.ReadASN1Boolean(&ext.Critical) {
 			return ext, errors.New("x509: malformed extention critical field")
 		}
 	}
 	var val cryptobyte.String
-	if !der.ReadASN1(&val, cbasn1.OCTET_STRING) {
+	if !der.ReadASN1(&val, cryptobyte_asn1.OCTET_STRING) {
 		return ext, errors.New("x509: malformed extention value field")
 	}
 	ext.Value = val
@@ -241,7 +240,7 @@ func parsePublicKey(algo PublicKeyAlgorithm, keyData *publicKeyInfo) (interface{
 		}
 
 		p := &pkcs1PublicKey{N: new(big.Int)}
-		if !der.ReadASN1(&der, cbasn1.SEQUENCE) {
+		if !der.ReadASN1(&der, cryptobyte_asn1.SEQUENCE) {
 			return nil, errors.New("x509: invalid RSA public key")
 		}
 		if !der.ReadASN1Integer(p.N) {
@@ -307,7 +306,7 @@ func parsePublicKey(algo PublicKeyAlgorithm, keyData *publicKeyInfo) (interface{
 			},
 		}
 		paramsDer := cryptobyte.String(keyData.Algorithm.Parameters.FullBytes)
-		if !paramsDer.ReadASN1(&paramsDer, cbasn1.SEQUENCE) ||
+		if !paramsDer.ReadASN1(&paramsDer, cryptobyte_asn1.SEQUENCE) ||
 			!paramsDer.ReadASN1Integer(pub.Parameters.P) ||
 			!paramsDer.ReadASN1Integer(pub.Parameters.Q) ||
 			!paramsDer.ReadASN1Integer(pub.Parameters.G) {
@@ -340,16 +339,16 @@ func parseKeyUsageExtension(der cryptobyte.String) (KeyUsage, error) {
 
 func parseBasicConstraintsExtension(der cryptobyte.String) (bool, int, error) {
 	var isCA bool
-	if !der.ReadASN1(&der, cbasn1.SEQUENCE) {
+	if !der.ReadASN1(&der, cryptobyte_asn1.SEQUENCE) {
 		return false, 0, errors.New("x509: invalid basic constraints a")
 	}
-	if der.PeekASN1Tag(cbasn1.BOOLEAN) {
+	if der.PeekASN1Tag(cryptobyte_asn1.BOOLEAN) {
 		if !der.ReadASN1Boolean(&isCA) {
 			return false, 0, errors.New("x509: invalid basic constraints b")
 		}
 	}
 	maxPathLen := -1
-	if !der.Empty() && der.PeekASN1Tag(cbasn1.INTEGER) {
+	if !der.Empty() && der.PeekASN1Tag(cryptobyte_asn1.INTEGER) {
 		if !der.ReadASN1Integer(&maxPathLen) {
 			return false, 0, errors.New("x509: invalid basic constraints c")
 		}
@@ -360,12 +359,12 @@ func parseBasicConstraintsExtension(der cryptobyte.String) (bool, int, error) {
 }
 
 func forEachSAN(der cryptobyte.String, callback func(tag int, data []byte) error) error {
-	if !der.ReadASN1(&der, cbasn1.SEQUENCE) {
+	if !der.ReadASN1(&der, cryptobyte_asn1.SEQUENCE) {
 		return errors.New("x509: invalid subject alternative names")
 	}
 	for !der.Empty() {
 		var san cryptobyte.String
-		var tag cbasn1.Tag
+		var tag cryptobyte_asn1.Tag
 		if !der.ReadAnyASN1(&san, &tag) {
 			return errors.New("x509: invalid subject alternative name")
 		}
@@ -425,7 +424,7 @@ func parseSANExtension(der cryptobyte.String) (dnsNames, emailAddresses []string
 func parseExtKeyUsageExtension(der cryptobyte.String) ([]ExtKeyUsage, []asn1.ObjectIdentifier, error) {
 	var extKeyUsages []ExtKeyUsage
 	var unknownUsages []asn1.ObjectIdentifier
-	if !der.ReadASN1(&der, cbasn1.SEQUENCE) {
+	if !der.ReadASN1(&der, cryptobyte_asn1.SEQUENCE) {
 		return nil, nil, errors.New("x509: invalid extended key usages")
 	}
 	for !der.Empty() {
@@ -444,12 +443,12 @@ func parseExtKeyUsageExtension(der cryptobyte.String) ([]ExtKeyUsage, []asn1.Obj
 
 func parseCertificatePoliciesExtension(der cryptobyte.String) ([]asn1.ObjectIdentifier, error) {
 	var oids []asn1.ObjectIdentifier
-	if !der.ReadASN1(&der, cbasn1.SEQUENCE) {
+	if !der.ReadASN1(&der, cryptobyte_asn1.SEQUENCE) {
 		return nil, errors.New("x509: invalid certificate policies")
 	}
 	for !der.Empty() {
 		var cp cryptobyte.String
-		if !der.ReadASN1(&cp, cbasn1.SEQUENCE) {
+		if !der.ReadASN1(&cp, cryptobyte_asn1.SEQUENCE) {
 			return nil, errors.New("x509: invalid certificate policies")
 		}
 		var oid asn1.ObjectIdentifier
@@ -697,31 +696,31 @@ func processExtensions(out *Certificate) error {
 				//     fullName                [0]     GeneralNames,
 				//     nameRelativeToCRLIssuer [1]     RelativeDistinguishedName }
 				val := cryptobyte.String(e.Value)
-				if !val.ReadASN1(&val, cbasn1.SEQUENCE) {
+				if !val.ReadASN1(&val, cryptobyte_asn1.SEQUENCE) {
 					return errors.New("x509: invalid CRL distribution points")
 				}
 				for !val.Empty() {
 					var dpDER cryptobyte.String
-					if !val.ReadASN1(&dpDER, cbasn1.SEQUENCE) {
+					if !val.ReadASN1(&dpDER, cryptobyte_asn1.SEQUENCE) {
 						return errors.New("x509: invalid CRL distribution point")
 					}
 					var dpNameDER cryptobyte.String
 					var dpNamePresent bool
-					if !dpDER.ReadOptionalASN1(&dpNameDER, &dpNamePresent, cbasn1.Tag(0).Constructed().ContextSpecific()) {
+					if !dpDER.ReadOptionalASN1(&dpNameDER, &dpNamePresent, cryptobyte_asn1.Tag(0).Constructed().ContextSpecific()) {
 						return errors.New("x509: invalid CRL distribution point")
 					}
 					if !dpNamePresent {
 						continue
 					}
-					if !dpNameDER.ReadASN1(&dpNameDER, cbasn1.Tag(0).Constructed().ContextSpecific()) {
+					if !dpNameDER.ReadASN1(&dpNameDER, cryptobyte_asn1.Tag(0).Constructed().ContextSpecific()) {
 						return errors.New("x509: invalid CRL distribution point")
 					}
 					for !dpNameDER.Empty() {
-						if !dpNameDER.PeekASN1Tag(cbasn1.Tag(6).ContextSpecific()) {
+						if !dpNameDER.PeekASN1Tag(cryptobyte_asn1.Tag(6).ContextSpecific()) {
 							break
 						}
 						var uri cryptobyte.String
-						if !dpNameDER.ReadASN1(&uri, cbasn1.Tag(6).ContextSpecific()) {
+						if !dpNameDER.ReadASN1(&uri, cryptobyte_asn1.Tag(6).ContextSpecific()) {
 							return errors.New("x509: invalid CRL distribution point")
 						}
 						out.CRLDistributionPoints = append(out.CRLDistributionPoints, string(uri))
@@ -732,10 +731,10 @@ func processExtensions(out *Certificate) error {
 				// RFC 5280, 4.2.1.1
 				val := cryptobyte.String(e.Value)
 				var akid cryptobyte.String
-				if !val.ReadASN1(&akid, cbasn1.SEQUENCE) {
+				if !val.ReadASN1(&akid, cryptobyte_asn1.SEQUENCE) {
 					return errors.New("x509: invalid authority key identifier")
 				}
-				if !akid.ReadASN1(&akid, cbasn1.Tag(0).ContextSpecific()) {
+				if !akid.ReadASN1(&akid, cryptobyte_asn1.Tag(0).ContextSpecific()) {
 					return errors.New("x509: invalid authority key identifier")
 				}
 				out.AuthorityKeyId = akid
@@ -748,7 +747,7 @@ func processExtensions(out *Certificate) error {
 				// RFC 5280, 4.2.1.2
 				val := cryptobyte.String(e.Value)
 				var skid cryptobyte.String
-				if !val.ReadASN1(&skid, cbasn1.OCTET_STRING) {
+				if !val.ReadASN1(&skid, cryptobyte_asn1.OCTET_STRING) {
 					return errors.New("x509: invalid subject key identifier")
 				}
 				out.SubjectKeyId = skid
@@ -764,22 +763,22 @@ func processExtensions(out *Certificate) error {
 		} else if e.Id.Equal(oidExtensionAuthorityInfoAccess) {
 			// RFC 5280 4.2.2.1: Authority Information Access
 			val := cryptobyte.String(e.Value)
-			if !val.ReadASN1(&val, cbasn1.SEQUENCE) {
+			if !val.ReadASN1(&val, cryptobyte_asn1.SEQUENCE) {
 				return errors.New("x509: invalid authority info access")
 			}
 			for !val.Empty() {
 				var aiaDER cryptobyte.String
-				if !val.ReadASN1(&aiaDER, cbasn1.SEQUENCE) {
+				if !val.ReadASN1(&aiaDER, cryptobyte_asn1.SEQUENCE) {
 					return errors.New("x509: invalid authority info access")
 				}
 				var method asn1.ObjectIdentifier
 				if !aiaDER.ReadASN1ObjectIdentifier(&method) {
 					return errors.New("x509: invalid authority info access")
 				}
-				if !aiaDER.PeekASN1Tag(cbasn1.Tag(6).ContextSpecific()) {
+				if !aiaDER.PeekASN1Tag(cryptobyte_asn1.Tag(6).ContextSpecific()) {
 					continue
 				}
-				if !aiaDER.ReadASN1(&aiaDER, cbasn1.Tag(6).ContextSpecific()) {
+				if !aiaDER.ReadASN1(&aiaDER, cryptobyte_asn1.Tag(6).ContextSpecific()) {
 					return errors.New("x509: invalid authority info access")
 				}
 				switch {
@@ -809,26 +808,26 @@ func parseCertificate(der []byte) (*Certificate, error) {
 	// we read the SEQUENCE including length and tag bytes so that
 	// we can populate Certificate.Raw, before unwrapping the
 	// SEQUENCE so it can be operated on
-	if !input.ReadASN1Element(&input, cbasn1.SEQUENCE) {
+	if !input.ReadASN1Element(&input, cryptobyte_asn1.SEQUENCE) {
 		return nil, errors.New("x509: malformed certificate")
 	}
 	cert.Raw = input
-	if !input.ReadASN1(&input, cbasn1.SEQUENCE) {
+	if !input.ReadASN1(&input, cryptobyte_asn1.SEQUENCE) {
 		return nil, errors.New("x509: malformed certificate")
 	}
 
 	var tbs cryptobyte.String
 	// do the same trick again as above to extract the raw
 	// bytes for Certificate.RawTBSCertificate
-	if !input.ReadASN1Element(&tbs, cbasn1.SEQUENCE) {
+	if !input.ReadASN1Element(&tbs, cryptobyte_asn1.SEQUENCE) {
 		return nil, errors.New("x509: malformed tbs certificate")
 	}
 	cert.RawTBSCertificate = tbs
-	if !tbs.ReadASN1(&tbs, cbasn1.SEQUENCE) {
+	if !tbs.ReadASN1(&tbs, cryptobyte_asn1.SEQUENCE) {
 		return nil, errors.New("x509: malformed tbs certificate")
 	}
 
-	if !tbs.ReadOptionalASN1Integer(&cert.Version, cbasn1.Tag(0).Constructed().ContextSpecific(), 0) {
+	if !tbs.ReadOptionalASN1Integer(&cert.Version, cryptobyte_asn1.Tag(0).Constructed().ContextSpecific(), 0) {
 		return nil, errors.New("x509: malformed version")
 	}
 	if cert.Version < 0 {
@@ -853,14 +852,14 @@ func parseCertificate(der []byte) (*Certificate, error) {
 	cert.SerialNumber = serial
 
 	var sigAISeq cryptobyte.String
-	if !tbs.ReadASN1(&sigAISeq, cbasn1.SEQUENCE) {
+	if !tbs.ReadASN1(&sigAISeq, cryptobyte_asn1.SEQUENCE) {
 		return nil, errors.New("x509: malformed signature algorithm identifier")
 	}
 	// Before parsing the inner algorithm identifier, extract
 	// the outer algorithm identifier and make sure that they
 	// match.
 	var outerSigAISeq cryptobyte.String
-	if !input.ReadASN1(&outerSigAISeq, cbasn1.SEQUENCE) {
+	if !input.ReadASN1(&outerSigAISeq, cryptobyte_asn1.SEQUENCE) {
 		return nil, errors.New("x509: malformed algorithm identifier")
 	}
 	if !bytes.Equal(outerSigAISeq, sigAISeq) {
@@ -873,7 +872,7 @@ func parseCertificate(der []byte) (*Certificate, error) {
 	cert.SignatureAlgorithm = getSignatureAlgorithmFromAI(sigAI)
 
 	var issuerSeq cryptobyte.String
-	if !tbs.ReadASN1Element(&issuerSeq, cbasn1.SEQUENCE) {
+	if !tbs.ReadASN1Element(&issuerSeq, cryptobyte_asn1.SEQUENCE) {
 		return nil, errors.New("x509: malformed issuer")
 	}
 	cert.RawIssuer = issuerSeq
@@ -884,7 +883,7 @@ func parseCertificate(der []byte) (*Certificate, error) {
 	cert.Issuer.FillFromRDNSequence(issuerRDNs)
 
 	var validity cryptobyte.String
-	if !tbs.ReadASN1(&validity, cbasn1.SEQUENCE) {
+	if !tbs.ReadASN1(&validity, cryptobyte_asn1.SEQUENCE) {
 		return nil, errors.New("x509: malformed validity")
 	}
 	cert.NotBefore, cert.NotAfter, err = parseValidity(validity)
@@ -893,7 +892,7 @@ func parseCertificate(der []byte) (*Certificate, error) {
 	}
 
 	var subjectSeq cryptobyte.String
-	if !tbs.ReadASN1Element(&subjectSeq, cbasn1.SEQUENCE) {
+	if !tbs.ReadASN1Element(&subjectSeq, cryptobyte_asn1.SEQUENCE) {
 		return nil, errors.New("x509: malformed issuer")
 	}
 	cert.RawSubject = subjectSeq
@@ -904,15 +903,15 @@ func parseCertificate(der []byte) (*Certificate, error) {
 	cert.Subject.FillFromRDNSequence(subjectRDNs)
 
 	var spki cryptobyte.String
-	if !tbs.ReadASN1Element(&spki, cbasn1.SEQUENCE) {
+	if !tbs.ReadASN1Element(&spki, cryptobyte_asn1.SEQUENCE) {
 		return nil, errors.New("x509: malformed spki")
 	}
 	cert.RawSubjectPublicKeyInfo = spki
-	if !spki.ReadASN1(&spki, cbasn1.SEQUENCE) {
+	if !spki.ReadASN1(&spki, cryptobyte_asn1.SEQUENCE) {
 		return nil, errors.New("x509: malformed spki")
 	}
 	var pkAISeq cryptobyte.String
-	if !spki.ReadASN1(&pkAISeq, cbasn1.SEQUENCE) {
+	if !spki.ReadASN1(&pkAISeq, cryptobyte_asn1.SEQUENCE) {
 		return nil, errors.New("x509: malformed public key algorithm identifier")
 	}
 	pkAI, err := parseAI(pkAISeq)
@@ -933,25 +932,25 @@ func parseCertificate(der []byte) (*Certificate, error) {
 	}
 
 	if cert.Version > 1 {
-		if !tbs.SkipOptionalASN1(cbasn1.Tag(1).Constructed().ContextSpecific()) {
+		if !tbs.SkipOptionalASN1(cryptobyte_asn1.Tag(1).Constructed().ContextSpecific()) {
 			return nil, errors.New("x509: malformed issuerUniqueID")
 		}
-		if !tbs.SkipOptionalASN1(cbasn1.Tag(2).Constructed().ContextSpecific()) {
+		if !tbs.SkipOptionalASN1(cryptobyte_asn1.Tag(2).Constructed().ContextSpecific()) {
 			return nil, errors.New("x509: malformed subjectUniqueID")
 		}
 		if cert.Version == 3 {
 			var extensions cryptobyte.String
 			var present bool
-			if !tbs.ReadOptionalASN1(&extensions, &present, cbasn1.Tag(3).Constructed().ContextSpecific()) {
+			if !tbs.ReadOptionalASN1(&extensions, &present, cryptobyte_asn1.Tag(3).Constructed().ContextSpecific()) {
 				return nil, errors.New("x509: malformed extensions")
 			}
 			if present {
-				if !extensions.ReadASN1(&extensions, cbasn1.SEQUENCE) {
+				if !extensions.ReadASN1(&extensions, cryptobyte_asn1.SEQUENCE) {
 					return nil, errors.New("x509: malformed extensions")
 				}
 				for !extensions.Empty() {
 					var extension cryptobyte.String
-					if !extensions.ReadASN1(&extension, cbasn1.SEQUENCE) {
+					if !extensions.ReadASN1(&extension, cryptobyte_asn1.SEQUENCE) {
 						return nil, errors.New("x509: malformed extension")
 					}
 					ext, err := parseExtension(extension)
-- 
GitLab


From 6d2ef2ef2a3ed375b5c782e6c8b0f8a59c3d3c8c Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Tue, 18 May 2021 12:58:02 -0400
Subject: [PATCH 2076/2400] cmd/compile: don't emit inltree for closure within
 body of inlined func

When inlining functions with closures, ensure that we don't mark the
body of the closure with a src.Pos marker that reflects the inline,
since this will result in the generation of an inltree table for the
closure itself (as opposed to the routine that the func-with-closure
was inlined into).

Fixes #46234.

Change-Id: I348296de6504fc4745d99adab436640f50be299a
Reviewed-on: https://go-review.googlesource.com/c/go/+/320913
Reviewed-by: Cherry Mui <cherryyz@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/inline/inl.go |  16 +++-
 test/closure3.dir/main.go              |   8 +-
 test/fixedbugs/issue46234.go           | 103 +++++++++++++++++++++++++
 test/inline.go                         |   4 +-
 4 files changed, 124 insertions(+), 7 deletions(-)
 create mode 100644 test/fixedbugs/issue46234.go

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index a6829e9835..d6b4ced4e1 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -1124,6 +1124,10 @@ type inlsubst struct {
 	newclofn *ir.Func
 
 	fn *ir.Func // For debug -- the func that is being inlined
+
+	// If true, then don't update source positions during substitution
+	// (retain old source positions).
+	noPosUpdate bool
 }
 
 // list inlines a list of nodes.
@@ -1219,7 +1223,14 @@ func (subst *inlsubst) clovar(n *ir.Name) *ir.Name {
 // closure node.
 func (subst *inlsubst) closure(n *ir.ClosureExpr) ir.Node {
 	m := ir.Copy(n)
-	m.SetPos(subst.updatedPos(m.Pos()))
+
+	// Prior to the subst edit, set a flag in the inlsubst to
+	// indicated that we don't want to update the source positions in
+	// the new closure. If we do this, it will appear that the closure
+	// itself has things inlined into it, which is not the case. See
+	// issue #46234 for more details.
+	defer func(prev bool) { subst.noPosUpdate = prev }(subst.noPosUpdate)
+	subst.noPosUpdate = true
 	ir.EditChildren(m, subst.edit)
 
 	//fmt.Printf("Inlining func %v with closure into %v\n", subst.fn, ir.FuncName(ir.CurFunc))
@@ -1445,6 +1456,9 @@ func (subst *inlsubst) node(n ir.Node) ir.Node {
 }
 
 func (subst *inlsubst) updatedPos(xpos src.XPos) src.XPos {
+	if subst.noPosUpdate {
+		return xpos
+	}
 	pos := base.Ctxt.PosTable.Pos(xpos)
 	oldbase := pos.Base() // can be nil
 	newbase := subst.bases[oldbase]
diff --git a/test/closure3.dir/main.go b/test/closure3.dir/main.go
index 2fc33753ed..662a2e967b 100644
--- a/test/closure3.dir/main.go
+++ b/test/closure3.dir/main.go
@@ -94,10 +94,10 @@ func main() {
 			return x + 2
 		}
 		y, sink = func() (func(int) int, int) { // ERROR "can inline main.func12"
-			return func(x int) int { // ERROR "can inline main.func12"
+			return func(x int) int { // ERROR "func literal does not escape" "can inline main.func12"
 				return x + 1
 			}, 42
-		}() // ERROR "func literal does not escape" "inlining call to main.func12"
+		}() // ERROR "inlining call to main.func12"
 		if y(40) != 41 {
 			ppanic("y(40) != 41")
 		}
@@ -109,10 +109,10 @@ func main() {
 				return x + 2
 			}
 			y, sink = func() (func(int) int, int) { // ERROR "can inline main.func13.2"
-				return func(x int) int { // ERROR "can inline main.func13.2"
+				return func(x int) int { // ERROR  "func literal does not escape" "can inline main.func13.2"
 					return x + 1
 				}, 42
-			}() // ERROR "inlining call to main.func13.2" "func literal does not escape"
+			}() // ERROR "inlining call to main.func13.2"
 			if y(40) != 41 {
 				ppanic("y(40) != 41")
 			}
diff --git a/test/fixedbugs/issue46234.go b/test/fixedbugs/issue46234.go
new file mode 100644
index 0000000000..c669cc01a6
--- /dev/null
+++ b/test/fixedbugs/issue46234.go
@@ -0,0 +1,103 @@
+// buildrun -t 30
+
+// +build !js
+
+// Copyright 2021 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.
+
+// Ensure that runtime traceback does not infinite loop for
+// the testcase below.
+
+package main
+
+import (
+	"bytes"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+)
+
+const prog = `
+
+package main
+
+import "context"
+
+var gpi *int
+
+type nAO struct {
+	eE bool
+}
+
+type NAO func(*nAO)
+
+func WEA() NAO {
+	return func(o *nAO) { o.eE = true }
+}
+
+type R struct {
+	cM *CM
+}
+
+type CM int
+
+type A string
+
+func (m *CM) NewA(ctx context.Context, cN string, nn *nAO, opts ...NAO) (*A, error) {
+	for _, o := range opts {
+		o(nn)
+	}
+	s := A("foo")
+	return &s, nil
+}
+
+func (r *R) CA(ctx context.Context, cN string, nn *nAO) (*int, error) {
+	cA, err := r.cM.NewA(ctx, cN, nn, WEA(), WEA())
+	if err == nil {
+		return nil, err
+	}
+	println(cA)
+	x := int(42)
+	return &x, nil
+}
+
+func main() {
+	c := CM(1)
+	r := R{cM: &c}
+	var ctx context.Context
+	nnr := nAO{}
+	pi, err := r.CA(ctx, "foo", nil)
+	if err != nil {
+		panic("bad")
+	}
+	println(nnr.eE)
+	gpi = pi
+}
+`
+
+func main() {
+	dir, err := ioutil.TempDir("", "46234")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer os.RemoveAll(dir)
+
+	file := filepath.Join(dir, "main.go")
+	if err := ioutil.WriteFile(file, []byte(prog), 0655); err != nil {
+		log.Fatalf("Write error %v", err)
+	}
+
+	cmd := exec.Command("go", "run", file)
+	output, err := cmd.CombinedOutput()
+	if err == nil {
+		log.Fatalf("Passed, expected an error")
+	}
+
+	want := []byte("segmentation violation")
+	if !bytes.Contains(output, want) {
+		log.Fatalf("Unmatched error message %q:\nin\n%s\nError: %v", want, output, err)
+	}
+}
diff --git a/test/inline.go b/test/inline.go
index bc23768d01..472a941dca 100644
--- a/test/inline.go
+++ b/test/inline.go
@@ -92,9 +92,9 @@ func o() int {
 	foo := func() int { return 1 } // ERROR "can inline o.func1" "func literal does not escape"
 	func(x int) {                  // ERROR "can inline o.func2"
 		if x > 10 {
-			foo = func() int { return 2 } // ERROR "can inline o.func2"
+			foo = func() int { return 2 } // ERROR "func literal does not escape" "can inline o.func2"
 		}
-	}(11) // ERROR "func literal does not escape" "inlining call to o.func2"
+	}(11) // ERROR "inlining call to o.func2"
 	return foo()
 }
 
-- 
GitLab


From eeadce2d871358306f2a95b0cfbe809ea017932a Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 18 May 2021 11:16:38 -0400
Subject: [PATCH 2077/2400] go/build/constraint: fix parsing of "// +build"
 (with no args)

"// +build" by itself was like "// +build !" - unsatisfiable.
Make it so again (right now it panics).

Fixes #44487.

Change-Id: Iacbc1398af6f988ef011f9f438e792eb62f8f434
Reviewed-on: https://go-review.googlesource.com/c/go/+/320829
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/go/build/constraint/expr.go      |  3 +++
 src/go/build/constraint/expr_test.go | 32 ++++++++++++++++------------
 2 files changed, 21 insertions(+), 14 deletions(-)

diff --git a/src/go/build/constraint/expr.go b/src/go/build/constraint/expr.go
index 1ef707ceac..957eb9b527 100644
--- a/src/go/build/constraint/expr.go
+++ b/src/go/build/constraint/expr.go
@@ -426,6 +426,9 @@ func parsePlusBuildExpr(text string) Expr {
 			x = or(x, y)
 		}
 	}
+	if x == nil {
+		x = tag("ignore")
+	}
 	return x
 }
 
diff --git a/src/go/build/constraint/expr_test.go b/src/go/build/constraint/expr_test.go
index 4979f8b5f2..15d189012e 100644
--- a/src/go/build/constraint/expr_test.go
+++ b/src/go/build/constraint/expr_test.go
@@ -216,6 +216,7 @@ var parsePlusBuildExprTests = []struct {
 	{"!!x", tag("ignore")},
 	{"!x", not(tag("x"))},
 	{"!", tag("ignore")},
+	{"", tag("ignore")},
 }
 
 func TestParsePlusBuildExpr(t *testing.T) {
@@ -232,19 +233,22 @@ func TestParsePlusBuildExpr(t *testing.T) {
 var constraintTests = []struct {
 	in  string
 	x   Expr
-	err error
+	err string
 }{
-	{"//+build x y", or(tag("x"), tag("y")), nil},
-	{"// +build x y \n", or(tag("x"), tag("y")), nil},
-	{"// +build x y \n ", nil, errNotConstraint},
-	{"// +build x y \nmore", nil, errNotConstraint},
-	{" //+build x y", nil, errNotConstraint},
+	{"//+build !", tag("ignore"), ""},
+	{"//+build", tag("ignore"), ""},
+	{"//+build x y", or(tag("x"), tag("y")), ""},
+	{"// +build x y \n", or(tag("x"), tag("y")), ""},
+	{"// +build x y \n ", nil, "not a build constraint"},
+	{"// +build x y \nmore", nil, "not a build constraint"},
+	{" //+build x y", nil, "not a build constraint"},
 
-	{"//go:build x && y", and(tag("x"), tag("y")), nil},
-	{"//go:build x && y\n", and(tag("x"), tag("y")), nil},
-	{"//go:build x && y\n ", nil, errNotConstraint},
-	{"//go:build x && y\nmore", nil, errNotConstraint},
-	{" //go:build x && y", nil, errNotConstraint},
+	{"//go:build x && y", and(tag("x"), tag("y")), ""},
+	{"//go:build x && y\n", and(tag("x"), tag("y")), ""},
+	{"//go:build x && y\n ", nil, "not a build constraint"},
+	{"//go:build x && y\nmore", nil, "not a build constraint"},
+	{" //go:build x && y", nil, "not a build constraint"},
+	{"//go:build\n", nil, "unexpected end of expression"},
 }
 
 func TestParse(t *testing.T) {
@@ -252,14 +256,14 @@ func TestParse(t *testing.T) {
 		t.Run(fmt.Sprint(i), func(t *testing.T) {
 			x, err := Parse(tt.in)
 			if err != nil {
-				if tt.err == nil {
+				if tt.err == "" {
 					t.Errorf("Constraint(%q): unexpected error: %v", tt.in, err)
-				} else if tt.err != err {
+				} else if !strings.Contains(err.Error(), tt.err) {
 					t.Errorf("Constraint(%q): error %v, want %v", tt.in, err, tt.err)
 				}
 				return
 			}
-			if tt.err != nil {
+			if tt.err != "" {
 				t.Errorf("Constraint(%q) = %v, want error %v", tt.in, x, tt.err)
 				return
 			}
-- 
GitLab


From 15a374d5c1336e9cc2f8b615477d5917e9477440 Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Tue, 18 May 2021 18:25:44 -0400
Subject: [PATCH 2078/2400] test: check portable error message on issue46234.go

issue46234.go expects an error output "segmentation violation",
which is UNIX-specific. Check for "nil pointer dereference"
instead, which is emitted by the Go runtime and should work on all
platforms.

Should fix Windows builders.

Change-Id: I3f5a66a687d43cae5eaf6a9e942b877e5a248900
Reviewed-on: https://go-review.googlesource.com/c/go/+/321072
Trust: Cherry Mui <cherryyz@google.com>
Run-TryBot: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 test/fixedbugs/issue46234.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/fixedbugs/issue46234.go b/test/fixedbugs/issue46234.go
index c669cc01a6..8e7eb8bf8d 100644
--- a/test/fixedbugs/issue46234.go
+++ b/test/fixedbugs/issue46234.go
@@ -96,7 +96,7 @@ func main() {
 		log.Fatalf("Passed, expected an error")
 	}
 
-	want := []byte("segmentation violation")
+	want := []byte("nil pointer dereference")
 	if !bytes.Contains(output, want) {
 		log.Fatalf("Unmatched error message %q:\nin\n%s\nError: %v", want, output, err)
 	}
-- 
GitLab


From 658b5e66ecbc41a49e6fb5aa63c5d9c804cf305f Mon Sep 17 00:00:00 2001
From: Michael Pratt <mpratt@google.com>
Date: Tue, 18 May 2021 12:23:56 -0400
Subject: [PATCH 2079/2400] net: return nil UDPAddr from ReadFromUDP

In cases where the socket operation has no underlying address,
golang.org/cl/291509 unintentionally changed ReadFromUDP from return a
nil *UDPAddr to a non-nil (but zero value) *UDPAddr.

This may break callers that assume "no address" is always addr == nil,
so change it back to remain nil.

Fixes #46238

Change-Id: I8531e8fa16b853ed7560088eabda0b9e3e53f5be
Reviewed-on: https://go-review.googlesource.com/c/go/+/320909
Trust: Michael Pratt <mpratt@google.com>
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>
---
 src/net/udpsock_posix.go |  3 +++
 src/net/udpsock_test.go  | 29 +++++++++++++++++++++++++++++
 2 files changed, 32 insertions(+)

diff --git a/src/net/udpsock_posix.go b/src/net/udpsock_posix.go
index fcfb9c004c..96fb373ce7 100644
--- a/src/net/udpsock_posix.go
+++ b/src/net/udpsock_posix.go
@@ -50,6 +50,9 @@ func (c *UDPConn) readFrom(b []byte, addr *UDPAddr) (int, *UDPAddr, error) {
 		*addr = UDPAddr{IP: sa.Addr[0:], Port: sa.Port}
 	case *syscall.SockaddrInet6:
 		*addr = UDPAddr{IP: sa.Addr[0:], Port: sa.Port, Zone: zoneCache.name(int(sa.ZoneId))}
+	default:
+		// No sockaddr, so don't return UDPAddr.
+		addr = nil
 	}
 	return n, addr, err
 }
diff --git a/src/net/udpsock_test.go b/src/net/udpsock_test.go
index b4000b5664..0e8c3511c3 100644
--- a/src/net/udpsock_test.go
+++ b/src/net/udpsock_test.go
@@ -8,7 +8,9 @@
 package net
 
 import (
+	"errors"
 	"internal/testenv"
+	"os"
 	"reflect"
 	"runtime"
 	"testing"
@@ -446,6 +448,33 @@ func TestUDPReadSizeError(t *testing.T) {
 	}
 }
 
+// TestUDPReadTimeout verifies that ReadFromUDP with timeout returns an error
+// without data or an address.
+func TestUDPReadTimeout(t *testing.T) {
+	la, err := ResolveUDPAddr("udp4", "127.0.0.1:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	c, err := ListenUDP("udp4", la)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer c.Close()
+
+	c.SetDeadline(time.Now())
+	b := make([]byte, 1)
+	n, addr, err := c.ReadFromUDP(b)
+	if !errors.Is(err, os.ErrDeadlineExceeded) {
+		t.Errorf("ReadFromUDP got err %v want os.ErrDeadlineExceeded", err)
+	}
+	if n != 0 {
+		t.Errorf("ReadFromUDP got n %d want 0", n)
+	}
+	if addr != nil {
+		t.Errorf("ReadFromUDP got addr %+#v want nil", addr)
+	}
+}
+
 func BenchmarkWriteToReadFromUDP(b *testing.B) {
 	conn, err := ListenUDP("udp4", &UDPAddr{IP: IPv4(127, 0, 0, 1)})
 	if err != nil {
-- 
GitLab


From 6c1c055d1ea417d050503efe92c1eead0da68cef Mon Sep 17 00:00:00 2001
From: Dmitri Shuralyov <dmitshur@golang.org>
Date: Tue, 18 May 2021 23:29:14 -0400
Subject: [PATCH 2080/2400] cmd/internal/moddeps: use filepath.SkipDir only on
 directories
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

If a filepath.WalkFunc returns filepath.SkipDir when invoked on a
non-directory file, it skips the remaining files in the containing
directory.¹

CL 276272 accidentally added a code path that triggers this behavior
whenever filepath.Walk reaches a non-directory file that begins with
a dot, such as .gitattributes or .DS_Store, causing findGorootModules
to return early without finding any modules in GOROOT. Tests that use
it ceased to provide test coverage that the tree is tidy.

Add an explicit check for info.IsDir in the 5 places that intend to
use filepath.SkipDir to skip traversing that directory. Even paths
like GOROOT/bin and GOROOT/pkg which are unlikely to be anything but
a directory are worth checking, since the goal of moddeps is to take
a possibly problematic GOROOT tree as input and detect problems.

While the goal of findGorootModules is to find all modules in GOROOT
programmatically (in case new modules are added or modified), there
are 4 modules now that are quite likely to exist, so check for their
presence to avoid similar regressions. (It's not hard to update this
test if a well-known GOROOT module is removed or otherwise modified;
but if it becomes hard we can simplify it to check for a reasonable
number of modules instead.)

Also fix the minor skew that has crept in since the test got disabled.

¹ This wasn't necessarily an intentional design decision, but it was
  found only when Go 1.4 was already out. See CL 11690 for details.

Fixes #46254.

Change-Id: Id55ed926f8c0094b1af923070de72bacca05996f
Reviewed-on: https://go-review.googlesource.com/c/go/+/320991
Trust: Dmitri Shuralyov <dmitshur@golang.org>
Run-TryBot: Dmitri Shuralyov <dmitshur@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
---
 src/cmd/internal/moddeps/moddeps_test.go   |  36 ++++--
 src/go.mod                                 |   2 +-
 src/go.sum                                 |   4 +-
 src/net/http/h2_bundle.go                  | 133 ++++++++++++++++-----
 src/net/http/socks_bundle.go               |   2 +-
 src/vendor/golang.org/x/sys/cpu/cpu.go     |   5 +-
 src/vendor/golang.org/x/sys/cpu/cpu_aix.go |   1 +
 src/vendor/modules.txt                     |   2 +-
 8 files changed, 137 insertions(+), 48 deletions(-)

diff --git a/src/cmd/internal/moddeps/moddeps_test.go b/src/cmd/internal/moddeps/moddeps_test.go
index ba574f4004..7723250468 100644
--- a/src/cmd/internal/moddeps/moddeps_test.go
+++ b/src/cmd/internal/moddeps/moddeps_test.go
@@ -227,7 +227,7 @@ func makeGOROOTCopy(t *testing.T) string {
 		if err != nil {
 			return err
 		}
-		if src == filepath.Join(runtime.GOROOT(), ".git") {
+		if info.IsDir() && src == filepath.Join(runtime.GOROOT(), ".git") {
 			return filepath.SkipDir
 		}
 
@@ -237,9 +237,8 @@ func makeGOROOTCopy(t *testing.T) string {
 		}
 		dst := filepath.Join(gorootCopyDir, rel)
 
-		switch src {
-		case filepath.Join(runtime.GOROOT(), "bin"),
-			filepath.Join(runtime.GOROOT(), "pkg"):
+		if info.IsDir() && (src == filepath.Join(runtime.GOROOT(), "bin") ||
+			src == filepath.Join(runtime.GOROOT(), "pkg")) {
 			// If the OS supports symlinks, use them instead
 			// of copying the bin and pkg directories.
 			if err := os.Symlink(src, dst); err == nil {
@@ -414,7 +413,7 @@ func findGorootModules(t *testing.T) []gorootModule {
 			if info.IsDir() && (info.Name() == "vendor" || info.Name() == "testdata") {
 				return filepath.SkipDir
 			}
-			if path == filepath.Join(runtime.GOROOT(), "pkg") {
+			if info.IsDir() && path == filepath.Join(runtime.GOROOT(), "pkg") {
 				// GOROOT/pkg contains generated artifacts, not source code.
 				//
 				// In https://golang.org/issue/37929 it was observed to somehow contain
@@ -422,7 +421,7 @@ func findGorootModules(t *testing.T) []gorootModule {
 				// running time of this test anyway.)
 				return filepath.SkipDir
 			}
-			if strings.HasPrefix(info.Name(), "_") || strings.HasPrefix(info.Name(), ".") {
+			if info.IsDir() && (strings.HasPrefix(info.Name(), "_") || strings.HasPrefix(info.Name(), ".")) {
 				// _ and . prefixed directories can be used for internal modules
 				// without a vendor directory that don't contribute to the build
 				// but might be used for example as code generators.
@@ -457,8 +456,31 @@ func findGorootModules(t *testing.T) []gorootModule {
 			goroot.modules = append(goroot.modules, m)
 			return nil
 		})
-	})
+		if goroot.err != nil {
+			return
+		}
 
+		// knownGOROOTModules is a hard-coded list of modules that are known to exist in GOROOT.
+		// If findGorootModules doesn't find a module, it won't be covered by tests at all,
+		// so make sure at least these modules are found. See issue 46254. If this list
+		// becomes a nuisance to update, can be replaced with len(goroot.modules) check.
+		knownGOROOTModules := [...]string{
+			"std",
+			"cmd",
+			"misc",
+			"test/bench/go1",
+		}
+		var seen = make(map[string]bool) // Key is module path.
+		for _, m := range goroot.modules {
+			seen[m.Path] = true
+		}
+		for _, m := range knownGOROOTModules {
+			if !seen[m] {
+				goroot.err = fmt.Errorf("findGorootModules didn't find the well-known module %q", m)
+				break
+			}
+		}
+	})
 	if goroot.err != nil {
 		t.Fatal(goroot.err)
 	}
diff --git a/src/go.mod b/src/go.mod
index 93ff2d8d3c..379dcf504e 100644
--- a/src/go.mod
+++ b/src/go.mod
@@ -5,6 +5,6 @@ go 1.17
 require (
 	golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e
 	golang.org/x/net v0.0.0-20210510120150-4163338589ed
-	golang.org/x/sys v0.0.0-20210503173754-0981d6026fa6 // indirect
+	golang.org/x/sys v0.0.0-20210511113859-b0526f3d8744 // indirect
 	golang.org/x/text v0.3.7-0.20210503195748-5c7c50ebbd4f // indirect
 )
diff --git a/src/go.sum b/src/go.sum
index 1390ce6d45..b3de6c526c 100644
--- a/src/go.sum
+++ b/src/go.sum
@@ -2,7 +2,7 @@ golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e h1:8foAy0aoO5GkqCvAEJ4VC4
 golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
 golang.org/x/net v0.0.0-20210510120150-4163338589ed h1:p9UgmWI9wKpfYmgaV/IZKGdXc5qEK45tDwwwDyjS26I=
 golang.org/x/net v0.0.0-20210510120150-4163338589ed/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/sys v0.0.0-20210503173754-0981d6026fa6 h1:cdsMqa2nXzqlgs183pHxtvoVwU7CyzaCTAUOg94af4c=
-golang.org/x/sys v0.0.0-20210503173754-0981d6026fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210511113859-b0526f3d8744 h1:yhBbb4IRs2HS9PPlAg6DMC6mUOKexJBNsLf4Z+6En1Q=
+golang.org/x/sys v0.0.0-20210511113859-b0526f3d8744/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/text v0.3.7-0.20210503195748-5c7c50ebbd4f h1:yQJrRE0hDxDFmZLlRaw+3vusO4fwNHgHIjUOMO7bHYI=
 golang.org/x/text v0.3.7-0.20210503195748-5c7c50ebbd4f/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
diff --git a/src/net/http/h2_bundle.go b/src/net/http/h2_bundle.go
index fd540ff255..a948ff3eed 100644
--- a/src/net/http/h2_bundle.go
+++ b/src/net/http/h2_bundle.go
@@ -53,6 +53,48 @@ import (
 	"golang.org/x/net/idna"
 )
 
+// asciiEqualFold is strings.EqualFold, ASCII only. It reports whether s and t
+// are equal, ASCII-case-insensitively.
+func http2asciiEqualFold(s, t string) bool {
+	if len(s) != len(t) {
+		return false
+	}
+	for i := 0; i < len(s); i++ {
+		if http2lower(s[i]) != http2lower(t[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+// lower returns the ASCII lowercase version of b.
+func http2lower(b byte) byte {
+	if 'A' <= b && b <= 'Z' {
+		return b + ('a' - 'A')
+	}
+	return b
+}
+
+// isASCIIPrint returns whether s is ASCII and printable according to
+// https://tools.ietf.org/html/rfc20#section-4.2.
+func http2isASCIIPrint(s string) bool {
+	for i := 0; i < len(s); i++ {
+		if s[i] < ' ' || s[i] > '~' {
+			return false
+		}
+	}
+	return true
+}
+
+// asciiToLower returns the lowercase version of s if s is ASCII and printable,
+// and whether or not it was.
+func http2asciiToLower(s string) (lower string, ok bool) {
+	if !http2isASCIIPrint(s) {
+		return "", false
+	}
+	return strings.ToLower(s), true
+}
+
 // A list of the possible cipher suite ids. Taken from
 // https://www.iana.org/assignments/tls-parameters/tls-parameters.txt
 
@@ -2907,6 +2949,20 @@ func http2traceGot1xxResponseFunc(trace *httptrace.ClientTrace) func(int, textpr
 	return nil
 }
 
+// dialTLSWithContext uses tls.Dialer, added in Go 1.15, to open a TLS
+// connection.
+func (t *http2Transport) dialTLSWithContext(ctx context.Context, network, addr string, cfg *tls.Config) (*tls.Conn, error) {
+	dialer := &tls.Dialer{
+		Config: cfg,
+	}
+	cn, err := dialer.DialContext(ctx, network, addr)
+	if err != nil {
+		return nil, err
+	}
+	tlsCn := cn.(*tls.Conn) // DialContext comment promises this will always succeed
+	return tlsCn, nil
+}
+
 var http2DebugGoroutines = os.Getenv("DEBUG_HTTP2_GOROUTINES") == "1"
 
 type http2goroutineLock uint64
@@ -3128,12 +3184,12 @@ func http2buildCommonHeaderMaps() {
 	}
 }
 
-func http2lowerHeader(v string) string {
+func http2lowerHeader(v string) (lower string, ascii bool) {
 	http2buildCommonHeaderMapsOnce()
 	if s, ok := http2commonLowerHeader[v]; ok {
-		return s
+		return s, true
 	}
-	return strings.ToLower(v)
+	return http2asciiToLower(v)
 }
 
 var (
@@ -3831,13 +3887,12 @@ func http2ConfigureServer(s *Server, conf *http2Server) error {
 
 	if s.TLSConfig == nil {
 		s.TLSConfig = new(tls.Config)
-	} else if s.TLSConfig.CipherSuites != nil {
-		// If they already provided a CipherSuite list, return
-		// an error if it has a bad order or is missing
-		// ECDHE_RSA_WITH_AES_128_GCM_SHA256 or ECDHE_ECDSA_WITH_AES_128_GCM_SHA256.
+	} else if s.TLSConfig.CipherSuites != nil && s.TLSConfig.MinVersion < tls.VersionTLS13 {
+		// If they already provided a TLS 1.0–1.2 CipherSuite list, return an
+		// error if it is missing ECDHE_RSA_WITH_AES_128_GCM_SHA256 or
+		// ECDHE_ECDSA_WITH_AES_128_GCM_SHA256.
 		haveRequired := false
-		sawBad := false
-		for i, cs := range s.TLSConfig.CipherSuites {
+		for _, cs := range s.TLSConfig.CipherSuites {
 			switch cs {
 			case tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
 				// Alternative MTI cipher to not discourage ECDSA-only servers.
@@ -3845,14 +3900,9 @@ func http2ConfigureServer(s *Server, conf *http2Server) error {
 				tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256:
 				haveRequired = true
 			}
-			if http2isBadCipher(cs) {
-				sawBad = true
-			} else if sawBad {
-				return fmt.Errorf("http2: TLSConfig.CipherSuites index %d contains an HTTP/2-approved cipher suite (%#04x), but it comes after unapproved cipher suites. With this configuration, clients that don't support previous, approved cipher suites may be given an unapproved one and reject the connection.", i, cs)
-			}
 		}
 		if !haveRequired {
-			return fmt.Errorf("http2: TLSConfig.CipherSuites is missing an HTTP/2-required AES_128_GCM_SHA256 cipher (need at least one of TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 or TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256).")
+			return fmt.Errorf("http2: TLSConfig.CipherSuites is missing an HTTP/2-required AES_128_GCM_SHA256 cipher (need at least one of TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 or TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)")
 		}
 	}
 
@@ -6394,8 +6444,12 @@ func (w *http2responseWriter) Push(target string, opts *PushOptions) error {
 		// but PUSH_PROMISE requests cannot have a body.
 		// http://tools.ietf.org/html/rfc7540#section-8.2
 		// Also disallow Host, since the promised URL must be absolute.
-		switch strings.ToLower(k) {
-		case "content-length", "content-encoding", "trailer", "te", "expect", "host":
+		if http2asciiEqualFold(k, "content-length") ||
+			http2asciiEqualFold(k, "content-encoding") ||
+			http2asciiEqualFold(k, "trailer") ||
+			http2asciiEqualFold(k, "te") ||
+			http2asciiEqualFold(k, "expect") ||
+			http2asciiEqualFold(k, "host") {
 			return fmt.Errorf("promised request headers cannot include %q", k)
 		}
 	}
@@ -7148,14 +7202,10 @@ func (t *http2Transport) dialTLS(ctx context.Context) func(string, string, *tls.
 		return t.DialTLS
 	}
 	return func(network, addr string, cfg *tls.Config) (net.Conn, error) {
-		dialer := &tls.Dialer{
-			Config: cfg,
-		}
-		cn, err := dialer.DialContext(ctx, network, addr)
+		tlsCn, err := t.dialTLSWithContext(ctx, network, addr, cfg)
 		if err != nil {
 			return nil, err
 		}
-		tlsCn := cn.(*tls.Conn) // DialContext comment promises this will always succeed
 		state := tlsCn.ConnectionState()
 		if p := state.NegotiatedProtocol; p != http2NextProtoTLS {
 			return nil, fmt.Errorf("http2: unexpected ALPN protocol %q; want %q", p, http2NextProtoTLS)
@@ -7163,7 +7213,7 @@ func (t *http2Transport) dialTLS(ctx context.Context) func(string, string, *tls.
 		if !state.NegotiatedProtocolIsMutual {
 			return nil, errors.New("http2: could not negotiate protocol mutually")
 		}
-		return cn, nil
+		return tlsCn, nil
 	}
 }
 
@@ -7552,7 +7602,7 @@ func http2checkConnHeaders(req *Request) error {
 	if vv := req.Header["Transfer-Encoding"]; len(vv) > 0 && (len(vv) > 1 || vv[0] != "" && vv[0] != "chunked") {
 		return fmt.Errorf("http2: invalid Transfer-Encoding request header: %q", vv)
 	}
-	if vv := req.Header["Connection"]; len(vv) > 0 && (len(vv) > 1 || vv[0] != "" && !strings.EqualFold(vv[0], "close") && !strings.EqualFold(vv[0], "keep-alive")) {
+	if vv := req.Header["Connection"]; len(vv) > 0 && (len(vv) > 1 || vv[0] != "" && !http2asciiEqualFold(vv[0], "close") && !http2asciiEqualFold(vv[0], "keep-alive")) {
 		return fmt.Errorf("http2: invalid Connection request header: %q", vv)
 	}
 	return nil
@@ -8078,19 +8128,21 @@ func (cc *http2ClientConn) encodeHeaders(req *Request, addGzipHeader bool, trail
 
 		var didUA bool
 		for k, vv := range req.Header {
-			if strings.EqualFold(k, "host") || strings.EqualFold(k, "content-length") {
+			if http2asciiEqualFold(k, "host") || http2asciiEqualFold(k, "content-length") {
 				// Host is :authority, already sent.
 				// Content-Length is automatic, set below.
 				continue
-			} else if strings.EqualFold(k, "connection") || strings.EqualFold(k, "proxy-connection") ||
-				strings.EqualFold(k, "transfer-encoding") || strings.EqualFold(k, "upgrade") ||
-				strings.EqualFold(k, "keep-alive") {
+			} else if http2asciiEqualFold(k, "connection") ||
+				http2asciiEqualFold(k, "proxy-connection") ||
+				http2asciiEqualFold(k, "transfer-encoding") ||
+				http2asciiEqualFold(k, "upgrade") ||
+				http2asciiEqualFold(k, "keep-alive") {
 				// Per 8.1.2.2 Connection-Specific Header
 				// Fields, don't send connection-specific
 				// fields. We have already checked if any
 				// are error-worthy so just ignore the rest.
 				continue
-			} else if strings.EqualFold(k, "user-agent") {
+			} else if http2asciiEqualFold(k, "user-agent") {
 				// Match Go's http1 behavior: at most one
 				// User-Agent. If set to nil or empty string,
 				// then omit it. Otherwise if not mentioned,
@@ -8103,7 +8155,7 @@ func (cc *http2ClientConn) encodeHeaders(req *Request, addGzipHeader bool, trail
 				if vv[0] == "" {
 					continue
 				}
-			} else if strings.EqualFold(k, "cookie") {
+			} else if http2asciiEqualFold(k, "cookie") {
 				// Per 8.1.2.5 To allow for better compression efficiency, the
 				// Cookie header field MAY be split into separate header fields,
 				// each with one or more cookie-pairs.
@@ -8162,7 +8214,12 @@ func (cc *http2ClientConn) encodeHeaders(req *Request, addGzipHeader bool, trail
 
 	// Header list size is ok. Write the headers.
 	enumerateHeaders(func(name, value string) {
-		name = strings.ToLower(name)
+		name, ascii := http2asciiToLower(name)
+		if !ascii {
+			// Skip writing invalid headers. Per RFC 7540, Section 8.1.2, header
+			// field names have to be ASCII characters (just as in HTTP/1.x).
+			return
+		}
 		cc.writeHeader(name, value)
 		if traceHeaders {
 			http2traceWroteHeaderField(trace, name, value)
@@ -8210,9 +8267,14 @@ func (cc *http2ClientConn) encodeTrailers(req *Request) ([]byte, error) {
 	}
 
 	for k, vv := range req.Trailer {
+		lowKey, ascii := http2asciiToLower(k)
+		if !ascii {
+			// Skip writing invalid headers. Per RFC 7540, Section 8.1.2, header
+			// field names have to be ASCII characters (just as in HTTP/1.x).
+			continue
+		}
 		// Transfer-Encoding, etc.. have already been filtered at the
 		// start of RoundTrip
-		lowKey := strings.ToLower(k)
 		for _, v := range vv {
 			cc.writeHeader(lowKey, v)
 		}
@@ -9635,7 +9697,12 @@ func http2encodeHeaders(enc *hpack.Encoder, h Header, keys []string) {
 	}
 	for _, k := range keys {
 		vv := h[k]
-		k = http2lowerHeader(k)
+		k, ascii := http2lowerHeader(k)
+		if !ascii {
+			// Skip writing invalid headers. Per RFC 7540, Section 8.1.2, header
+			// field names have to be ASCII characters (just as in HTTP/1.x).
+			continue
+		}
 		if !http2validWireHeaderFieldName(k) {
 			// Skip it as backup paranoia. Per
 			// golang.org/issue/14048, these should
diff --git a/src/net/http/socks_bundle.go b/src/net/http/socks_bundle.go
index e6db1c7640..e446669589 100644
--- a/src/net/http/socks_bundle.go
+++ b/src/net/http/socks_bundle.go
@@ -453,7 +453,7 @@ func (up *socksUsernamePassword) Authenticate(ctx context.Context, rw io.ReadWri
 		b = append(b, up.Username...)
 		b = append(b, byte(len(up.Password)))
 		b = append(b, up.Password...)
-		// TODO(mikio): handle IO deadlines and cancellation if
+		// TODO(mikio): handle IO deadlines and cancelation if
 		// necessary
 		if _, err := rw.Write(b); err != nil {
 			return err
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu.go b/src/vendor/golang.org/x/sys/cpu/cpu.go
index f77701fe86..abbec2d44b 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu.go
@@ -154,14 +154,13 @@ var MIPS64X struct {
 // For ppc64/ppc64le, it is safe to check only for ISA level starting on ISA v3.00,
 // since there are no optional categories. There are some exceptions that also
 // require kernel support to work (DARN, SCV), so there are feature bits for
-// those as well. The minimum processor requirement is POWER8 (ISA 2.07).
-// The struct is padded to avoid false sharing.
+// those as well. The struct is padded to avoid false sharing.
 var PPC64 struct {
 	_        CacheLinePad
 	HasDARN  bool // Hardware random number generator (requires kernel enablement)
 	HasSCV   bool // Syscall vectored (requires kernel enablement)
 	IsPOWER8 bool // ISA v2.07 (POWER8)
-	IsPOWER9 bool // ISA v3.00 (POWER9)
+	IsPOWER9 bool // ISA v3.00 (POWER9), implies IsPOWER8
 	_        CacheLinePad
 }
 
diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_aix.go b/src/vendor/golang.org/x/sys/cpu/cpu_aix.go
index 28b521643b..8aaeef545a 100644
--- a/src/vendor/golang.org/x/sys/cpu/cpu_aix.go
+++ b/src/vendor/golang.org/x/sys/cpu/cpu_aix.go
@@ -20,6 +20,7 @@ func archInit() {
 		PPC64.IsPOWER8 = true
 	}
 	if impl&_IMPL_POWER9 != 0 {
+		PPC64.IsPOWER8 = true
 		PPC64.IsPOWER9 = true
 	}
 
diff --git a/src/vendor/modules.txt b/src/vendor/modules.txt
index 1b850342a5..ff01db5cdc 100644
--- a/src/vendor/modules.txt
+++ b/src/vendor/modules.txt
@@ -18,7 +18,7 @@ golang.org/x/net/idna
 golang.org/x/net/lif
 golang.org/x/net/nettest
 golang.org/x/net/route
-# golang.org/x/sys v0.0.0-20210503173754-0981d6026fa6
+# golang.org/x/sys v0.0.0-20210511113859-b0526f3d8744
 ## explicit; go 1.17
 golang.org/x/sys/cpu
 # golang.org/x/text v0.3.7-0.20210503195748-5c7c50ebbd4f
-- 
GitLab


From a8d85918b63d481a414ec5ca3978d07b2b047363 Mon Sep 17 00:00:00 2001
From: Dmitri Shuralyov <dmitshur@golang.org>
Date: Wed, 19 May 2021 22:51:11 +0000
Subject: [PATCH 2081/2400] misc/cgo/testplugin: skip TestIssue25756pie on
 darwin/arm64 builder

This test is known to be broken on the darwin/arm64 builder.
Skip it while it's being investigated so it doesn't mask other failures.

For #46239.
Updates #43228.

Change-Id: I8fe57a0636bba84c3100337146dcb96cc264e524
Reviewed-on: https://go-review.googlesource.com/c/go/+/321349
Trust: Dmitri Shuralyov <dmitshur@golang.org>
Run-TryBot: Dmitri Shuralyov <dmitshur@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 misc/cgo/testplugin/plugin_test.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/misc/cgo/testplugin/plugin_test.go b/misc/cgo/testplugin/plugin_test.go
index a6accc1dfb..9697dbf7a7 100644
--- a/misc/cgo/testplugin/plugin_test.go
+++ b/misc/cgo/testplugin/plugin_test.go
@@ -265,6 +265,10 @@ func TestIssue25756(t *testing.T) {
 
 // Test with main using -buildmode=pie with plugin for issue #43228
 func TestIssue25756pie(t *testing.T) {
+	if os.Getenv("GO_BUILDER_NAME") == "darwin-arm64-11_0-toothrot" {
+		t.Skip("broken on darwin/arm64 builder in sharded mode; see issue 46239")
+	}
+
 	goCmd(t, "build", "-buildmode=plugin", "-o", "life.so", "./issue25756/plugin")
 	goCmd(t, "build", "-buildmode=pie", "-o", "issue25756pie.exe", "./issue25756/main.go")
 	run(t, "./issue25756pie.exe")
-- 
GitLab


From f07e4dae3c5cb608b4f0b9db57d1562d2125243b Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Wed, 19 May 2021 15:46:44 +0000
Subject: [PATCH 2082/2400] syscall: document NewCallback and NewCallbackCDecl
 limitations

Currently NewCallback and NewCallbackCDecl may only be called a limited
number of times in a single Go process, but this property of the API is
not documented. This change fixes that, but does not document the
precise limit to avoid making that limit part of the API, leaving us
open to increasing or decreasing the limit in the future as needed.

Although the API avoids documenting a limit, it does guarantee a minimum
callback count so users can rely on at least some amount of callbacks
working.

Updates #46184.

Change-Id: I5129bf5fe301efff73ac112ba1f207ab32058833
Reviewed-on: https://go-review.googlesource.com/c/go/+/321133
Trust: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/syscall/syscall_windows.go | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/syscall/syscall_windows.go b/src/syscall/syscall_windows.go
index fa0b5d959a..fc734effbb 100644
--- a/src/syscall/syscall_windows.go
+++ b/src/syscall/syscall_windows.go
@@ -174,6 +174,9 @@ func compileCallback(fn interface{}, cleanstack bool) uintptr
 // NewCallback converts a Go function to a function pointer conforming to the stdcall calling convention.
 // This is useful when interoperating with Windows code requiring callbacks.
 // The argument is expected to be a function with one uintptr-sized result. The function must not have arguments with size larger than the size of uintptr.
+// Only a limited number of callbacks may be created in a single Go process, and any memory allocated
+// for these callbacks is never released.
+// Between NewCallback and NewCallbackCDecl, at least 1024 callbacks can always be created.
 func NewCallback(fn interface{}) uintptr {
 	return compileCallback(fn, true)
 }
@@ -181,6 +184,9 @@ func NewCallback(fn interface{}) uintptr {
 // NewCallbackCDecl converts a Go function to a function pointer conforming to the cdecl calling convention.
 // This is useful when interoperating with Windows code requiring callbacks.
 // The argument is expected to be a function with one uintptr-sized result. The function must not have arguments with size larger than the size of uintptr.
+// Only a limited number of callbacks may be created in a single Go process, and any memory allocated
+// for these callbacks is never released.
+// Between NewCallback and NewCallbackCDecl, at least 1024 callbacks can always be created.
 func NewCallbackCDecl(fn interface{}) uintptr {
 	return compileCallback(fn, false)
 }
-- 
GitLab


From bb7495a46d6024da9d77722f04b438e573bcb26f Mon Sep 17 00:00:00 2001
From: Vishal Dalwadi <dalwadivishal26@gmail.com>
Date: Fri, 7 May 2021 10:25:27 +0530
Subject: [PATCH 2083/2400] doc/go1.17: document new math constants

Documents the newly introduced:
* MaxInt
* MinInt
* MaxUint

Updates #28538.
For #44513.
Fixes #46012.

Change-Id: Iab6bbcf8f76ebe105b973d5fd39b86b8cd078348
Reviewed-on: https://go-review.googlesource.com/c/go/+/317911
Trust: Heschi Kreinick <heschi@google.com>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 doc/go1.17.html | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 4b2f4bce79..4c7348a36d 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -334,7 +334,9 @@ Do not send CLs removing the interior tags from such phrases.
 <dl id="math"><dt><a href="/pkg/math/">math</a></dt>
   <dd>
     <p><!-- CL 247058 -->
-      TODO: <a href="https://golang.org/cl/247058">https://golang.org/cl/247058</a>: add MaxUint, MinInt, MaxInt
+      The math package now defines three more constants: <code>MaxUint</code>, <code>MaxInt</code> and <code>MinInt</code>.
+      For 32-bit systems their values are <code>2^32 - 1</code>, <code>2^31 - 1</code> and <code>-2^31</code>, respectively.
+      For 64-bit systems their values are <code>2^64 - 1</code>, <code>2^63 - 1</code> and <code>-2^63</code>, respectively.
     </p>
   </dd>
 </dl><!-- math -->
-- 
GitLab


From ef1f52cc38cc8773a4ae2e4e71219140a08ce98f Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Wed, 19 May 2021 16:07:52 -0400
Subject: [PATCH 2084/2400] doc/go1.17: add release note for windows/arm64 port

Updates #44513, #42604.

Change-Id: I8200e8087c219a0042ab2a6770a7275c3b17942a
Reviewed-on: https://go-review.googlesource.com/c/go/+/321309
Trust: Cherry Mui <cherryyz@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 doc/go1.17.html | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 4c7348a36d..ea8bc3ccd6 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -43,6 +43,13 @@ Do not send CLs removing the interior tags from such phrases.
   for previous versions has been discontinued.
 </p>
 
+<h3 id="windows">Windows</h3>
+
+<p><!-- golang.org/issue/36439 -->
+  Go 1.17 adds support of 64-bit ARM architecture on Windows (the
+  <code>windows/arm64</code> port). This port supports cgo.
+</p>
+
 <p>
   TODO: complete the Ports section
 </p>
-- 
GitLab


From def53605418c8134880ffa3700c6a4ba6c689234 Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Wed, 19 May 2021 16:22:34 -0400
Subject: [PATCH 2085/2400] doc/go1.17: add release notes for OpenBSD ports

Updates #44513.

Change-Id: I8758768f6231fd7fcbaa7109eb49ee56cd60d93d
Reviewed-on: https://go-review.googlesource.com/c/go/+/321310
Trust: Cherry Mui <cherryyz@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 doc/go1.17.html | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index ea8bc3ccd6..97307bc508 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -50,6 +50,24 @@ Do not send CLs removing the interior tags from such phrases.
   <code>windows/arm64</code> port). This port supports cgo.
 </p>
 
+<h3 id="openbsd">OpenBSD</h3>
+
+<p><!-- golang.org/issue/43005 -->
+  The 64-bit MIPS architecture on OpenBSD (the <code>openbsd/mips64</code>
+  port) now supports cgo.
+</p>
+
+<p><!-- golang.org/issue/36435 -->
+  In Go 1.16, on the 64-bit x86 and 64-bit ARM architectures on
+  OpenBSD (the <code>openbsd/amd64</code> and <code>openbsd/arm64</code>
+  ports) system calls are made through <code>libc</code>, instead
+  of directly using the machine instructions. In Go 1.17, this is
+  also done on the 32-bit x86 and 32-bit ARM architectures on OpenBSD
+  (the <code>openbsd/386</code> and <code>openbsd/arm</code> ports).
+  This ensures forward-compatibility with future versions of
+  OpenBSD.
+</p>
+
 <p>
   TODO: complete the Ports section
 </p>
-- 
GitLab


From f8be906d7437f2528abc7cd1a57fe46aa9348b97 Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Thu, 20 May 2021 02:23:04 +1000
Subject: [PATCH 2086/2400] test: re-enable test on riscv64 now that it
 supports external linking

Update #36739

Change-Id: I14ab2cd0e29966b9a2f992e8c3bcb415203e63e6
Reviewed-on: https://go-review.googlesource.com/c/go/+/321449
Trust: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Mui <cherryyz@google.com>
Run-TryBot: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 test/fixedbugs/issue10607.go | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/test/fixedbugs/issue10607.go b/test/fixedbugs/issue10607.go
index 448a37dcac..8a04bc9def 100644
--- a/test/fixedbugs/issue10607.go
+++ b/test/fixedbugs/issue10607.go
@@ -1,4 +1,4 @@
-// +build linux,!ppc64,!riscv64,gc
+// +build linux,!ppc64,gc
 // run
 
 // Copyright 2015 The Go Authors. All rights reserved.
@@ -8,9 +8,6 @@
 // Test that a -B option is passed through when using both internal
 // and external linking mode.
 
-// TODO(jsing): Re-enable on riscv64 when it has support for external
-// linking - see golang.org/issue/36739
-
 package main
 
 import (
-- 
GitLab


From ce9a3b79d5bb783f5f31c9d41665a488fe63f546 Mon Sep 17 00:00:00 2001
From: Lapo Luchini <lapo@lapo.it>
Date: Thu, 20 May 2021 15:41:02 +0000
Subject: [PATCH 2087/2400] crypto/x509: add new FreeBSD 12.2+ trusted
 certificate folder

Up to FreeBSD 12.1 the package ca_root_nss was needed in order to have
certificates under /usr/local/share/certs as the base system didn't have
a system trusted certificate store.

This has been fixed in FreeBSD 12.2 using /etc/ssl/certs:
https://svnweb.freebsd.org/base?view=revision&revision=357082

Fixes #46284

Change-Id: I912b1bacc30cdf20d19e3ef9d09b69bb8055ff49
GitHub-Last-Rev: 0fa5542ea3c70ecb03e621381d7c34fbadf7ea47
GitHub-Pull-Request: golang/go#46276
Reviewed-on: https://go-review.googlesource.com/c/go/+/321190
Reviewed-by: Filippo Valsorda <filippo@golang.org>
Run-TryBot: Filippo Valsorda <filippo@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/crypto/x509/root_bsd.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/crypto/x509/root_bsd.go b/src/crypto/x509/root_bsd.go
index 822e8573ff..6712ea32a6 100644
--- a/src/crypto/x509/root_bsd.go
+++ b/src/crypto/x509/root_bsd.go
@@ -18,6 +18,7 @@ var certFiles = []string{
 // Possible directories with certificate files; stop after successfully
 // reading at least one file from a directory.
 var certDirectories = []string{
+	"/etc/ssl/certs",         // FreeBSD 12.2+
 	"/usr/local/share/certs", // FreeBSD
 	"/etc/openssl/certs",     // NetBSD
 }
-- 
GitLab


From 7c692cc7ea69ba4d8603fbada112289443a6f526 Mon Sep 17 00:00:00 2001
From: Vishal Dalwadi <dalwadivishal26@gmail.com>
Date: Fri, 7 May 2021 10:05:36 +0530
Subject: [PATCH 2088/2400] doc/go1.17: document changes to os package

Documents the changes to File.WriteString method.

For #44513.
Fixes #46018.

Change-Id: I3a8ef9df9f84662614d54802710bd705d626b995
Reviewed-on: https://go-review.googlesource.com/c/go/+/317910
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Trust: Cherry Mui <cherryyz@google.com>
---
 doc/go1.17.html | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 97307bc508..48b5563602 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -428,7 +428,8 @@ Do not send CLs removing the interior tags from such phrases.
 <dl id="os"><dt><a href="/pkg/os/">os</a></dt>
   <dd>
     <p><!-- CL 268020 -->
-      TODO: <a href="https://golang.org/cl/268020">https://golang.org/cl/268020</a>: avoid allocation in File.WriteString
+      The <a href="/pkg/os/#File.WriteString"><code>File.WriteString</code></a> method
+      has been optimized to no longer make a copy of the input string.
     </p>
   </dd>
 </dl><!-- os -->
-- 
GitLab


From baa934d26dd6e201dcda0962dd51b0e5f6f69c1b Mon Sep 17 00:00:00 2001
From: Tim King <taking@google.com>
Date: Wed, 19 May 2021 18:45:53 -0700
Subject: [PATCH 2089/2400] cmd: go get golang.org/x/tools/analysis@49064d23 &&
 go mod vendor

This brings in CLs 312829, 317431, 319211.

Fixes #40356.
Fixes #46129.

Change-Id: I2ee1f858b2a41ffa60d88b0c17511ccad57f1816
Reviewed-on: https://go-review.googlesource.com/c/go/+/321389
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Trust: Tim King <taking@google.com>
Run-TryBot: Tim King <taking@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go.mod                                  |  2 +-
 src/cmd/go.sum                                  |  4 ++--
 .../x/tools/go/analysis/passes/printf/printf.go |  2 +-
 .../analysis/passes/sigchanyzer/sigchanyzer.go  | 11 +++++++++--
 .../go/analysis/passes/stdmethods/stdmethods.go | 17 +++++++++++++++++
 src/cmd/vendor/modules.txt                      |  2 +-
 6 files changed, 31 insertions(+), 7 deletions(-)

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index 88f5f2883a..1aa0320d07 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -10,6 +10,6 @@ require (
 	golang.org/x/mod v0.4.3-0.20210512182355-6088ed88cecd
 	golang.org/x/sys v0.0.0-20210511113859-b0526f3d8744 // indirect
 	golang.org/x/term v0.0.0-20210503060354-a79de5458b56
-	golang.org/x/tools v0.1.1-0.20210505014545-7cab0ef2e9a5
+	golang.org/x/tools v0.1.2-0.20210519160823-49064d2332f9
 	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
 )
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 73750802bc..9af4978d66 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -16,7 +16,7 @@ golang.org/x/sys v0.0.0-20210511113859-b0526f3d8744 h1:yhBbb4IRs2HS9PPlAg6DMC6mU
 golang.org/x/sys v0.0.0-20210511113859-b0526f3d8744/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20210503060354-a79de5458b56 h1:b8jxX3zqjpqb2LklXPzKSGJhzyxCOZSz8ncv8Nv+y7w=
 golang.org/x/term v0.0.0-20210503060354-a79de5458b56/go.mod h1:tfny5GFUkzUvx4ps4ajbZsCe5lw1metzhBm9T3x7oIY=
-golang.org/x/tools v0.1.1-0.20210505014545-7cab0ef2e9a5 h1:ImcI7RFHWLu2QWpFDXaReu0j+sQAHIy65vUFZImXiqY=
-golang.org/x/tools v0.1.1-0.20210505014545-7cab0ef2e9a5/go.mod h1:sH/Eidr0EddymY8HZSakBo32zU3fG5ovDq874hJLjVg=
+golang.org/x/tools v0.1.2-0.20210519160823-49064d2332f9 h1:2XlR/j4I4xz5GQZI7zBjqTfezYyRIE2jD5IMousB2rg=
+golang.org/x/tools v0.1.2-0.20210519160823-49064d2332f9/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/printf/printf.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/printf/printf.go
index ddad4c796c..822820f06e 100644
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/printf/printf.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/printf/printf.go
@@ -590,7 +590,7 @@ func checkPrintf(pass *analysis.Pass, kind Kind, call *ast.CallExpr, fn *types.F
 		}
 		if state.verb == 'w' {
 			if kind != KindErrorf {
-				pass.Reportf(call.Pos(), "%s call has error-wrapping directive %%w", state.name)
+				pass.Reportf(call.Pos(), "%s call has error-wrapping directive %%w, which is only supported by Errorf", state.name)
 				return
 			}
 			if anyW {
diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/sigchanyzer/sigchanyzer.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/sigchanyzer/sigchanyzer.go
index b00aa7e144..0d6c8ebf16 100644
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/sigchanyzer/sigchanyzer.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/sigchanyzer/sigchanyzer.go
@@ -59,12 +59,19 @@ func run(pass *analysis.Pass) (interface{}, error) {
 		if chanDecl == nil || len(chanDecl.Args) != 1 {
 			return
 		}
-		chanDecl.Args = append(chanDecl.Args, &ast.BasicLit{
+
+		// Make a copy of the channel's declaration to avoid
+		// mutating the AST. See https://golang.org/issue/46129.
+		chanDeclCopy := &ast.CallExpr{}
+		*chanDeclCopy = *chanDecl
+		chanDeclCopy.Args = append([]ast.Expr(nil), chanDecl.Args...)
+		chanDeclCopy.Args = append(chanDeclCopy.Args, &ast.BasicLit{
 			Kind:  token.INT,
 			Value: "1",
 		})
+
 		var buf bytes.Buffer
-		if err := format.Node(&buf, token.NewFileSet(), chanDecl); err != nil {
+		if err := format.Node(&buf, token.NewFileSet(), chanDeclCopy); err != nil {
 			return
 		}
 		pass.Report(analysis.Diagnostic{
diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/stdmethods/stdmethods.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/stdmethods/stdmethods.go
index 856c6ae0d8..64a28ac0b9 100644
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/stdmethods/stdmethods.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/stdmethods/stdmethods.go
@@ -61,10 +61,12 @@ var Analyzer = &analysis.Analyzer{
 // we let it go. But if it does have a fmt.ScanState, then the
 // rest has to match.
 var canonicalMethods = map[string]struct{ args, results []string }{
+	"As": {[]string{"interface{}"}, []string{"bool"}}, // errors.As
 	// "Flush": {{}, {"error"}}, // http.Flusher and jpeg.writer conflict
 	"Format":        {[]string{"=fmt.State", "rune"}, []string{}},                      // fmt.Formatter
 	"GobDecode":     {[]string{"[]byte"}, []string{"error"}},                           // gob.GobDecoder
 	"GobEncode":     {[]string{}, []string{"[]byte", "error"}},                         // gob.GobEncoder
+	"Is":            {[]string{"error"}, []string{"bool"}},                             // errors.Is
 	"MarshalJSON":   {[]string{}, []string{"[]byte", "error"}},                         // json.Marshaler
 	"MarshalXML":    {[]string{"*xml.Encoder", "xml.StartElement"}, []string{"error"}}, // xml.Marshaler
 	"ReadByte":      {[]string{}, []string{"byte", "error"}},                           // io.ByteReader
@@ -76,6 +78,7 @@ var canonicalMethods = map[string]struct{ args, results []string }{
 	"UnmarshalXML":  {[]string{"*xml.Decoder", "xml.StartElement"}, []string{"error"}}, // xml.Unmarshaler
 	"UnreadByte":    {[]string{}, []string{"error"}},
 	"UnreadRune":    {[]string{}, []string{"error"}},
+	"Unwrap":        {[]string{}, []string{"error"}},                      // errors.Unwrap
 	"WriteByte":     {[]string{"byte"}, []string{"error"}},                // jpeg.writer (matching bufio.Writer)
 	"WriteTo":       {[]string{"=io.Writer"}, []string{"int64", "error"}}, // io.WriterTo
 }
@@ -123,6 +126,14 @@ func canonicalMethod(pass *analysis.Pass, id *ast.Ident) {
 		return
 	}
 
+	// Special case: Is, As and Unwrap only apply when type
+	// implements error.
+	if id.Name == "Is" || id.Name == "As" || id.Name == "Unwrap" {
+		if recv := sign.Recv(); recv == nil || !implementsError(recv.Type()) {
+			return
+		}
+	}
+
 	// Do the =s (if any) all match?
 	if !matchParams(pass, expect.args, args, "=") || !matchParams(pass, expect.results, results, "=") {
 		return
@@ -185,3 +196,9 @@ func matchParamType(expect string, actual types.Type) bool {
 	// Overkill but easy.
 	return typeString(actual) == expect
 }
+
+var errorType = types.Universe.Lookup("error").Type().Underlying().(*types.Interface)
+
+func implementsError(actual types.Type) bool {
+	return types.Implements(actual, errorType)
+}
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 016ec011a9..9a1723d32c 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -48,7 +48,7 @@ golang.org/x/sys/windows
 # golang.org/x/term v0.0.0-20210503060354-a79de5458b56
 ## explicit; go 1.17
 golang.org/x/term
-# golang.org/x/tools v0.1.1-0.20210505014545-7cab0ef2e9a5
+# golang.org/x/tools v0.1.2-0.20210519160823-49064d2332f9
 ## explicit; go 1.17
 golang.org/x/tools/cover
 golang.org/x/tools/go/analysis
-- 
GitLab


From 831573cd21e65c37b4e1bf5d44dc23b125084b7a Mon Sep 17 00:00:00 2001
From: Adam Mitha <adam.mitha@gmail.com>
Date: Thu, 13 May 2021 20:52:41 -0700
Subject: [PATCH 2090/2400] io/fs: added an example for io/fs.WalkDir

The documentation currently does not show how to get an `FS` instance for the operating system's filesystem. This example demonstrates how to accomplish this using the `os` package.

Fixes #46083

Change-Id: I053111c12ab09ef13f0d04fcdff8a6ea0dccf379
Reviewed-on: https://go-review.googlesource.com/c/go/+/319989
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/io/fs/example_test.go | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 src/io/fs/example_test.go

diff --git a/src/io/fs/example_test.go b/src/io/fs/example_test.go
new file mode 100644
index 0000000000..c9027034c4
--- /dev/null
+++ b/src/io/fs/example_test.go
@@ -0,0 +1,25 @@
+// Copyright 2021 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 fs_test
+
+import (
+	"fmt"
+	"io/fs"
+	"log"
+	"os"
+)
+
+func ExampleWalkDir() {
+	root := "/usr/local/go/bin"
+	fileSystem := os.DirFS(root)
+
+	fs.WalkDir(fileSystem, ".", func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			log.Fatal(err)
+		}
+		fmt.Println(path)
+		return nil
+	})
+}
-- 
GitLab


From 7e63c8b765c30823131bd136d190afbe4c21abc9 Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Fri, 21 May 2021 12:01:39 +0200
Subject: [PATCH 2091/2400] runtime: wait for Go runtime to initialize in
 Windows signal test

The test harness waits for "ready" as a sign that the Go runtime has
installed its signal handler and is ready to be tested. But actually,
while LoadLibrary starts the loading of the Go runtime, it does so
asynchronously, so the "ready" sign is potentially premature and
certainly racy. However, all exported cgo entry points make a call to
_cgo_wait_runtime_init_done which waits for that asynchronous
initialization to complete. Therefore, this commit fixes the test to
call into the exported "Dummy" cgo function before emitting the "ready"
sign, so that we're sure the Go runtime is actually loaded.

Updates #45638.

Change-Id: I9b12b172d45bdcc09d54dd301de3a3e499544834
Reviewed-on: https://go-review.googlesource.com/c/go/+/321769
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/testdata/testwinlibsignal/main.c | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/src/runtime/testdata/testwinlibsignal/main.c b/src/runtime/testdata/testwinlibsignal/main.c
index 1787fef3b9..37f24823e6 100644
--- a/src/runtime/testdata/testwinlibsignal/main.c
+++ b/src/runtime/testdata/testwinlibsignal/main.c
@@ -19,13 +19,13 @@ int main(void)
 {
     waitForCtrlBreakEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
     if (!waitForCtrlBreakEvent) {
-        fprintf(stderr, "ERROR: Could not create event");
+        fprintf(stderr, "ERROR: Could not create event\n");
         return 1;
     }
 
     if (!SetConsoleCtrlHandler(CtrlHandler, TRUE))
     {
-        fprintf(stderr, "ERROR: Could not set control handler");
+        fprintf(stderr, "ERROR: Could not set control handler\n");
         return 1;
     }
 
@@ -34,7 +34,14 @@ int main(void)
     // This way the library handler gets called first.
     HMODULE dummyDll = LoadLibrary("dummy.dll");
     if (!dummyDll) {
-        fprintf(stderr, "ERROR: Could not load dummy.dll");
+        fprintf(stderr, "ERROR: Could not load dummy.dll\n");
+        return 1;
+    }
+
+    // Call the Dummy function so that Go initialization completes, since
+    // all cgo entry points call out to _cgo_wait_runtime_init_done.
+    if (((int(*)(void))GetProcAddress(dummyDll, "Dummy"))() != 42) {
+        fprintf(stderr, "ERROR: Dummy function did not return 42\n");
         return 1;
     }
 
@@ -42,7 +49,7 @@ int main(void)
     fflush(stdout);
 
     if (WaitForSingleObject(waitForCtrlBreakEvent, 5000) != WAIT_OBJECT_0) {
-        fprintf(stderr, "FAILURE: No signal received");
+        fprintf(stderr, "FAILURE: No signal received\n");
         return 1;
     }
 
-- 
GitLab


From 3148694f607b77731420a20ef2117ac7d0d55ba3 Mon Sep 17 00:00:00 2001
From: Tim Heckman <t@heckman.io>
Date: Thu, 20 May 2021 16:51:28 -0700
Subject: [PATCH 2092/2400] cmd/go: remove warning from module deprecation
 notice printing

Fixes #46294

Change-Id: I50023006dab83dee455f98a702ca1c72e61764ea
Reviewed-on: https://go-review.googlesource.com/c/go/+/321649
Trust: Jay Conrod <jayconrod@google.com>
Trust: Michael Matloob <matloob@golang.org>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modget/get.go                    | 2 +-
 src/cmd/go/testdata/script/mod_deprecate_message.txt | 8 ++++----
 src/cmd/go/testdata/script/mod_get_deprecated.txt    | 8 ++++----
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/cmd/go/internal/modget/get.go b/src/cmd/go/internal/modget/get.go
index 2a7fe5226f..563f1a988f 100644
--- a/src/cmd/go/internal/modget/get.go
+++ b/src/cmd/go/internal/modget/get.go
@@ -1598,7 +1598,7 @@ func (r *resolver) checkPackageProblems(ctx context.Context, pkgPatterns []strin
 	// Report deprecations, then retractions.
 	for _, mm := range deprecations {
 		if mm.message != "" {
-			fmt.Fprintf(os.Stderr, "go: warning: module %s is deprecated: %s\n", mm.m.Path, mm.message)
+			fmt.Fprintf(os.Stderr, "go: module %s is deprecated: %s\n", mm.m.Path, mm.message)
 		}
 	}
 	var retractPath string
diff --git a/src/cmd/go/testdata/script/mod_deprecate_message.txt b/src/cmd/go/testdata/script/mod_deprecate_message.txt
index 4a0674b808..567027935d 100644
--- a/src/cmd/go/testdata/script/mod_deprecate_message.txt
+++ b/src/cmd/go/testdata/script/mod_deprecate_message.txt
@@ -1,26 +1,26 @@
 # When there is a short single-line message, 'go get' should print it all.
 go get -d short
-stderr '^go: warning: module short is deprecated: short$'
+stderr '^go: module short is deprecated: short$'
 go list -m -u -f '{{.Deprecated}}' short
 stdout '^short$'
 
 # When there is a multi-line message, 'go get' should print the first line.
 go get -d multiline
-stderr '^go: warning: module multiline is deprecated: first line$'
+stderr '^go: module multiline is deprecated: first line$'
 ! stderr 'second line'
 go list -m -u -f '{{.Deprecated}}' multiline
 stdout '^first line\nsecond line.$'
 
 # When there is a long message, 'go get' should print a placeholder.
 go get -d long
-stderr '^go: warning: module long is deprecated: \(message omitted: too long\)$'
+stderr '^go: module long is deprecated: \(message omitted: too long\)$'
 go list -m -u -f '{{.Deprecated}}' long
 stdout '^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa$'
 
 # When a message contains unprintable chracters, 'go get' should say that
 # without printing the message.
 go get -d unprintable
-stderr '^go: warning: module unprintable is deprecated: \(message omitted: contains non-printable characters\)$'
+stderr '^go: module unprintable is deprecated: \(message omitted: contains non-printable characters\)$'
 go list -m -u -f '{{.Deprecated}}' unprintable
 stdout '^message contains ASCII BEL\x07$'
 
diff --git a/src/cmd/go/testdata/script/mod_get_deprecated.txt b/src/cmd/go/testdata/script/mod_get_deprecated.txt
index 4633009f69..7bdd7a58a8 100644
--- a/src/cmd/go/testdata/script/mod_get_deprecated.txt
+++ b/src/cmd/go/testdata/script/mod_get_deprecated.txt
@@ -4,14 +4,14 @@ go get -d ./use/nothing
 
 # 'go get pkg' should show a deprecation message for the module providing pkg.
 go get -d example.com/deprecated/a
-stderr '^go: warning: module example.com/deprecated/a is deprecated: in example.com/deprecated/a@v1.9.0$'
+stderr '^go: module example.com/deprecated/a is deprecated: in example.com/deprecated/a@v1.9.0$'
 go get -d example.com/deprecated/a@v1.0.0
-stderr '^go: warning: module example.com/deprecated/a is deprecated: in example.com/deprecated/a@v1.9.0$'
+stderr '^go: module example.com/deprecated/a is deprecated: in example.com/deprecated/a@v1.9.0$'
 
 # 'go get pkg' should show a deprecation message for a module providing
 # packages directly imported by pkg.
 go get -d ./use/a
-stderr '^go: warning: module example.com/deprecated/a is deprecated: in example.com/deprecated/a@v1.9.0$'
+stderr '^go: module example.com/deprecated/a is deprecated: in example.com/deprecated/a@v1.9.0$'
 
 # 'go get pkg' may show a deprecation message for an indirectly required module
 # if it provides a package named on the command line.
@@ -20,7 +20,7 @@ go get -d ./use/b
 go get -d local/use
 ! stderr 'module.*is deprecated'
 go get -d example.com/deprecated/b
-stderr '^go: warning: module example.com/deprecated/b is deprecated: in example.com/deprecated/b@v1.9.0$'
+stderr '^go: module example.com/deprecated/b is deprecated: in example.com/deprecated/b@v1.9.0$'
 
 # 'go get pkg' does not show a deprecation message for a module providing a
 # directly imported package if the module is no longer deprecated in its
-- 
GitLab


From 5fee772c872fcbf35c059b241d0b60c0aecd0f20 Mon Sep 17 00:00:00 2001
From: Aaron Sheah <aaronsheah@gmail.com>
Date: Tue, 18 May 2021 14:54:02 +0000
Subject: [PATCH 2093/2400] doc/go1.17: document archive/zip changes for Go
 1.17

For #44513. Fixes #46000

Change-Id: I299d0b5657f1f96174d6e35d60daac8b36e59d29
GitHub-Last-Rev: e63461bff042a8abe79e0ec3515eefbf56ba1d82
GitHub-Pull-Request: golang/go#46235
Reviewed-on: https://go-review.googlesource.com/c/go/+/320809
Reviewed-by: Heschi Kreinick <heschi@google.com>
Trust: Robert Findley <rfindley@google.com>
---
 doc/go1.17.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 48b5563602..ae9deabf65 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -272,7 +272,7 @@ Do not send CLs removing the interior tags from such phrases.
 <dl id="archive/zip"><dt><a href="/pkg/archive/zip/">archive/zip</a></dt>
   <dd>
     <p><!-- CL 312310 -->
-      TODO: <a href="https://golang.org/cl/312310">https://golang.org/cl/312310</a>: add File.OpenRaw, Writer.CreateRaw, Writer.Copy
+      The new methods <a href="/pkg/archive/zip#File.OpenRaw"><code>File.OpenRaw</code></a>, <a href="/pkg/archive/zip#Writer.CreateRaw"><code>Writer.CreateRaw</code></a>, <a href="/pkg/archive/zip#Writer.Copy"><code>Writer.Copy</code></a> provide support for cases where performance is a primary concern.
     </p>
   </dd>
 </dl><!-- archive/zip -->
-- 
GitLab


From 8876b9bd6a8a0c206c0a5d59302ce5167f26e9f3 Mon Sep 17 00:00:00 2001
From: Adam Mitha <adam.mitha@gmail.com>
Date: Fri, 14 May 2021 10:58:01 -0700
Subject: [PATCH 2094/2400] doc/go1.17: document io/fs changes for Go 1.17

For #44513
Fixes #46011

Change-Id: I862ef9a4314cd34fb8c828a8cd7d0a7b36c6f683
Reviewed-on: https://go-review.googlesource.com/c/go/+/320151
Reviewed-by: Heschi Kreinick <heschi@google.com>
Trust: Heschi Kreinick <heschi@google.com>
Trust: Robert Findley <rfindley@google.com>
Trust: Dmitri Shuralyov <dmitshur@golang.org>
---
 doc/go1.17.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index ae9deabf65..4561b6ccf5 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -351,7 +351,7 @@ Do not send CLs removing the interior tags from such phrases.
 <dl id="io/fs"><dt><a href="/pkg/io/fs/">io/fs</a></dt>
   <dd>
     <p><!-- CL 293649 -->
-      TODO: <a href="https://golang.org/cl/293649">https://golang.org/cl/293649</a>: implement FileInfoToDirEntry
+      The new <a href="/pkg/io/fs/#FileInfoToDirEntry"><code>FileInfoToDirEntry</code></a> function converts a <code>FileInfo</code> to a <code>DirEntry</code>.
     </p>
   </dd>
 </dl><!-- io/fs -->
-- 
GitLab


From 4fda54ce3f6761104e835fc4e7847f89e34b7d6d Mon Sep 17 00:00:00 2001
From: sryoya <ryoyasekino1993@gmail.com>
Date: Sun, 16 May 2021 23:36:05 +0900
Subject: [PATCH 2095/2400] doc/go1.17: document database/sql changes for Go
 1.17

For #44513
Fixes #46008

Change-Id: If80d484f73a0eb6946abdc654eb2c0d3dd6db416
Reviewed-on: https://go-review.googlesource.com/c/go/+/320251
Reviewed-by: Heschi Kreinick <heschi@google.com>
Trust: Robert Findley <rfindley@google.com>
---
 doc/go1.17.html | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 4561b6ccf5..3534f7be04 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -320,11 +320,19 @@ Do not send CLs removing the interior tags from such phrases.
 <dl id="database/sql"><dt><a href="/pkg/database/sql/">database/sql</a></dt>
   <dd>
     <p><!-- CL 258360 -->
-      TODO: <a href="https://golang.org/cl/258360">https://golang.org/cl/258360</a>: close driver.Connector if it implements io.Closer
+      The <a href="/pkg/database/sql/#DB.Close"><code>DB.Close</code></a> method now closes
+      the <code>connector</code> field if the type in this field implements the
+      <a href="/pkg/io/#Closer"><code>io.Closer</code></a> interface.
     </p>
 
     <p><!-- CL 311572 -->
-      TODO: <a href="https://golang.org/cl/311572">https://golang.org/cl/311572</a>: add NullInt16 and NullByte
+      The new
+      <a href="/pkg/database/sql/#NullInt16"><code>NullInt16</code></a> 
+      and 
+      <a href="/pkg/database/sql/#NullByte"><code>NullByte</code></a> 
+      structs represent the int16 and byte values that may be null. These can be used as
+      destinations of the <a href="/pkg/database/sql/#Scan"><code>Scan</code></a> method,
+      similar to NullString.
     </p>
   </dd>
 </dl><!-- database/sql -->
-- 
GitLab


From 4fb10b2118cb16445f2d089f79beb3d32db3db12 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Mon, 10 May 2021 18:10:18 -0400
Subject: [PATCH 2096/2400] cmd/go: in 'go mod download' without args, don't
 save module zip sums

'go mod download' without arguments is frequently used to populate the
module cache. It tends to fetch a lot of extra files (for modules in
the build list that aren't needed to build packages in the main
module). It's annoying when sums are written for these extra files.

'go mod download mod@version' will still write sums for specific
modules in the build list. 'go mod download all' still has the
previous behavior.

For now, all invocations of 'go mod download' still update go.mod and
go.sum with changes needed to load the build list (1.15 behavior).

Fixes #45332

Change-Id: I9e17d18a7466ac7271a0e1a2b663f6b3cb168c97
Reviewed-on: https://go-review.googlesource.com/c/go/+/318629
Trust: Jay Conrod <jayconrod@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 doc/go1.17.html                               | 11 ++++++
 src/cmd/go/internal/modcmd/download.go        | 29 +++++++++++++--
 .../go/testdata/mod/rsc.io_sampler_v1.2.1.txt |  2 +-
 src/cmd/go/testdata/script/mod_download.txt   | 37 +++++++++++++++++--
 .../script/mod_get_trailing_slash.txt         | 10 +++--
 src/cmd/go/testdata/script/mod_query.txt      |  5 ++-
 src/cmd/go/testdata/script/mod_retract.txt    |  8 ++--
 7 files changed, 85 insertions(+), 17 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 3534f7be04..f00c649e04 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -186,6 +186,17 @@ Do not send CLs removing the interior tags from such phrases.
   password-protected SSH keys.
 </p>
 
+<h4 id="go-mod-download"><code>go</code> <code>mod</code> <code>download</code></h4>
+
+<p><!-- golang.org/issue/45332 -->
+  When <code>go</code> <code>mod</code> <code>download</code> is invoked without
+  arguments, it will no longer save sums for downloaded module content to
+  <code>go.sum</code>. It may still make changes to <code>go.mod</code> and
+  <code>go.sum</code> needed to load the build list. This is the same as the
+  behavior in Go 1.15. To save sums for all modules, use <code>go</code>
+  <code>mod</code> <code>download</code> <code>all</code>.
+</p>
+
 <p><!-- CL 249759 -->
   TODO: <a href="https://golang.org/cl/249759">https://golang.org/cl/249759</a>: cmd/cover: replace code using optimized golang.org/x/tools/cover
 </p>
diff --git a/src/cmd/go/internal/modcmd/download.go b/src/cmd/go/internal/modcmd/download.go
index a6c6d914e1..42b06dbc95 100644
--- a/src/cmd/go/internal/modcmd/download.go
+++ b/src/cmd/go/internal/modcmd/download.go
@@ -86,9 +86,11 @@ func runDownload(ctx context.Context, cmd *base.Command, args []string) {
 	if !modload.HasModRoot() && len(args) == 0 {
 		base.Fatalf("go mod download: no modules specified (see 'go help mod download')")
 	}
-	if len(args) == 0 {
+	haveExplicitArgs := len(args) > 0
+	if !haveExplicitArgs {
 		args = []string{"all"}
-	} else if modload.HasModRoot() {
+	}
+	if modload.HasModRoot() {
 		modload.LoadModFile(ctx) // to fill Target
 		targetAtUpgrade := modload.Target.Path + "@upgrade"
 		targetAtPatch := modload.Target.Path + "@patch"
@@ -135,6 +137,18 @@ func runDownload(ctx context.Context, cmd *base.Command, args []string) {
 	type token struct{}
 	sem := make(chan token, runtime.GOMAXPROCS(0))
 	infos, infosErr := modload.ListModules(ctx, args, 0)
+	if !haveExplicitArgs {
+		// 'go mod download' is sometimes run without arguments to pre-populate
+		// the module cache. It may fetch modules that aren't needed to build
+		// packages in the main mdoule. This is usually not intended, so don't save
+		// sums for downloaded modules (golang.org/issue/45332).
+		// TODO(golang.org/issue/45551): For now, save sums needed to load the
+		// build list (same as 1.15 behavior). In the future, report an error if
+		// go.mod or go.sum need to be updated after loading the build list.
+		modload.WriteGoMod(ctx)
+		modload.DisallowWriteGoMod()
+	}
+
 	for _, info := range infos {
 		if info.Replace != nil {
 			info = info.Replace
@@ -185,8 +199,15 @@ func runDownload(ctx context.Context, cmd *base.Command, args []string) {
 		base.ExitIfErrors()
 	}
 
-	// Update go.mod and especially go.sum if needed.
-	modload.WriteGoMod(ctx)
+	// If there were explicit arguments, update go.mod and especially go.sum.
+	// 'go mod download mod@version' is a useful way to add a sum without using
+	// 'go get mod@version', which may have other side effects. We print this in
+	// some error message hints.
+	//
+	// Don't save sums for 'go mod download' without arguments; see comment above.
+	if haveExplicitArgs {
+		modload.WriteGoMod(ctx)
+	}
 
 	// If there was an error matching some of the requested packages, emit it now
 	// (after we've written the checksums for the modules that were downloaded
diff --git a/src/cmd/go/testdata/mod/rsc.io_sampler_v1.2.1.txt b/src/cmd/go/testdata/mod/rsc.io_sampler_v1.2.1.txt
index 00b71bf0d5..7982cccea1 100644
--- a/src/cmd/go/testdata/mod/rsc.io_sampler_v1.2.1.txt
+++ b/src/cmd/go/testdata/mod/rsc.io_sampler_v1.2.1.txt
@@ -5,7 +5,7 @@ module "rsc.io/sampler"
 
 require "golang.org/x/text" v0.0.0-20170915032832-14c0d48ead0c
 -- .info --
-{"Version":"v1.2.1","Name":"cac3af4f8a0ab40054fa6f8d423108a63a1255bb","Short":"cac3af4f8a0a","Time":"2018-02-13T18:16:22Z"}EOF
+{"Version":"v1.2.1","Name":"cac3af4f8a0ab40054fa6f8d423108a63a1255bb","Short":"cac3af4f8a0a","Time":"2018-02-13T18:16:22Z"}
 -- hello.go --
 // Copyright 2018 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/src/cmd/go/testdata/script/mod_download.txt b/src/cmd/go/testdata/script/mod_download.txt
index 8a9faffe4e..ad640b45de 100644
--- a/src/cmd/go/testdata/script/mod_download.txt
+++ b/src/cmd/go/testdata/script/mod_download.txt
@@ -107,13 +107,28 @@ stderr '^go mod download: skipping argument m that resolves to the main module\n
 ! go mod download m@latest
 stderr '^go mod download: m@latest: malformed module path "m": missing dot in first path element$'
 
-# download updates go.mod and populates go.sum
+# download without arguments updates go.mod and go.sum after loading the
+# build list, but does not save sums for downloaded zips.
 cd update
+cp go.mod.orig go.mod
 ! exists go.sum
 go mod download
+cmp go.mod.update go.mod
+cmp go.sum.update go.sum
+cp go.mod.orig go.mod
+rm go.sum
+
+# download with arguments (even "all") does update go.mod and go.sum.
+go mod download rsc.io/sampler
+cmp go.mod.update go.mod
 grep '^rsc.io/sampler v1.3.0 ' go.sum
-go list -m rsc.io/sampler
-stdout '^rsc.io/sampler v1.3.0$'
+cp go.mod.orig go.mod
+rm go.sum
+
+go mod download all
+cmp go.mod.update go.mod
+grep '^rsc.io/sampler v1.3.0 ' go.sum
+cd ..
 
 # allow go mod download without go.mod
 env GO111MODULE=auto
@@ -131,7 +146,7 @@ stderr 'get '$GOPROXY
 -- go.mod --
 module m
 
--- update/go.mod --
+-- update/go.mod.orig --
 module m
 
 go 1.16
@@ -140,3 +155,17 @@ require (
 	rsc.io/quote v1.5.2
 	rsc.io/sampler v1.2.1 // older version than in build list
 )
+-- update/go.mod.update --
+module m
+
+go 1.16
+
+require (
+	rsc.io/quote v1.5.2
+	rsc.io/sampler v1.3.0 // older version than in build list
+)
+-- update/go.sum.update --
+golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+rsc.io/quote v1.5.2/go.mod h1:LzX7hefJvL54yjefDEDHNONDjII0t9xZLPXsUe+TKr0=
+rsc.io/sampler v1.2.1/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
+rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
diff --git a/src/cmd/go/testdata/script/mod_get_trailing_slash.txt b/src/cmd/go/testdata/script/mod_get_trailing_slash.txt
index 3b38d8ba7d..c536693537 100644
--- a/src/cmd/go/testdata/script/mod_get_trailing_slash.txt
+++ b/src/cmd/go/testdata/script/mod_get_trailing_slash.txt
@@ -1,6 +1,3 @@
-# Populate go.sum
-go mod download
-
 # go list should succeed to load a package ending with ".go" if the path does
 # not correspond to an existing local file. Listing a pattern ending with
 # ".go/" should try to list a package regardless of whether a file exists at the
@@ -31,3 +28,10 @@ module m
 go 1.13
 
 require example.com/dotgo.go v1.0.0
+-- go.sum --
+example.com/dotgo.go v1.0.0 h1:XKJfs0V8x2PvY2tX8bJBCEbCDLnt15ma2onwhVpew/I=
+example.com/dotgo.go v1.0.0/go.mod h1:Qi6z/X3AC5vHiuMt6HF2ICx3KhIBGrMdrA7YoPDKqR0=
+-- use.go --
+package use
+
+import _ "example.com/dotgo.go"
diff --git a/src/cmd/go/testdata/script/mod_query.txt b/src/cmd/go/testdata/script/mod_query.txt
index e10185709d..a75f86ed7c 100644
--- a/src/cmd/go/testdata/script/mod_query.txt
+++ b/src/cmd/go/testdata/script/mod_query.txt
@@ -1,9 +1,7 @@
 env GO111MODULE=on
 
-# Populate go.sum.
 # TODO(golang.org/issue/41297): we shouldn't need go.sum. None of the commands
 # below depend on the build list.
-go mod download
 
 go list -m -versions rsc.io/quote
 stdout '^rsc.io/quote v1.0.0 v1.1.0 v1.2.0 v1.2.1 v1.3.0 v1.4.0 v1.5.0 v1.5.1 v1.5.2 v1.5.3-pre1$'
@@ -36,6 +34,9 @@ stdout 'no matching versions for query ">v1.5.3"'
 module x
 require rsc.io/quote v1.0.0
 
+-- go.sum --
+rsc.io/quote v1.0.0 h1:kQ3IZQzPTiDJxSZI98YaWgxFEhlNdYASHvh+MplbViw=
+rsc.io/quote v1.0.0/go.mod h1:v83Ri/njykPcgJltBc/gEkJTmjTsNgtO1Y7vyIK1CQA=
 -- use.go --
 package use
 
diff --git a/src/cmd/go/testdata/script/mod_retract.txt b/src/cmd/go/testdata/script/mod_retract.txt
index a52e05bc72..4f95ece8d7 100644
--- a/src/cmd/go/testdata/script/mod_retract.txt
+++ b/src/cmd/go/testdata/script/mod_retract.txt
@@ -1,8 +1,5 @@
 cp go.mod go.mod.orig
 
-# Populate go.sum.
-go mod download
-
 # 'go list pkg' does not report an error when a retracted version is used.
 go list -e -f '{{if .Error}}{{.Error}}{{end}}' ./use
 ! stdout .
@@ -32,6 +29,11 @@ go 1.15
 
 require example.com/retract v1.0.0-bad
 
+-- go.sum --
+example.com/retract v1.0.0-bad h1:liAW69rbtjY67x2CcNzat668L/w+YGgNX3lhJsWIJis=
+example.com/retract v1.0.0-bad/go.mod h1:0DvGGofJ9hr1q63cBrOY/jSY52OwhRGA0K47NE80I5Y=
+example.com/retract/self/prev v1.1.0 h1:0/8I/GTG+1eJTFeDQ/fUbgrMsVHHyKhh3Z8DSZp1fuA=
+example.com/retract/self/prev v1.1.0/go.mod h1:xl2EcklWuZZHVtHWcpzfSJQmnzAGpKZYpA/Wto7SZN4=
 -- use/use.go --
 package use
 
-- 
GitLab


From e4d7525c3e119de30490550fe2516fd6958eac30 Mon Sep 17 00:00:00 2001
From: Constantin Konstantinidis <constantinkonstantinidis@gmail.com>
Date: Fri, 14 May 2021 15:00:46 +0200
Subject: [PATCH 2097/2400] cmd/dist: display first class port status in json
 output
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fixes #38874

Change-Id: I819dd008fd6869d335888b4aa03dcf739da9a9a4
Reviewed-on: https://go-review.googlesource.com/c/go/+/320069
Run-TryBot: Dmitri Shuralyov <dmitshur@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Trust: Daniel Martí <mvdan@mvdan.cc>
---
 src/cmd/dist/build.go | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/src/cmd/dist/build.go b/src/cmd/dist/build.go
index 00e23ef179..1abb03bcc5 100644
--- a/src/cmd/dist/build.go
+++ b/src/cmd/dist/build.go
@@ -1607,6 +1607,18 @@ var incomplete = map[string]bool{
 	"linux/sparc64": true,
 }
 
+// List of platforms which are first class ports. See golang.org/issue/38874.
+var firstClass = map[string]bool{
+	"darwin/amd64":  true,
+	"darwin/arm64":  true,
+	"linux/386":     true,
+	"linux/amd64":   true,
+	"linux/arm":     true,
+	"linux/arm64":   true,
+	"windows/386":   true,
+	"windows/amd64": true,
+}
+
 func needCC() bool {
 	switch os.Getenv("CGO_ENABLED") {
 	case "1":
@@ -1743,6 +1755,7 @@ func cmdlist() {
 		GOOS         string
 		GOARCH       string
 		CgoSupported bool
+		FirstClass   bool
 	}
 	var results []jsonResult
 	for _, p := range plats {
@@ -1750,7 +1763,8 @@ func cmdlist() {
 		results = append(results, jsonResult{
 			GOOS:         fields[0],
 			GOARCH:       fields[1],
-			CgoSupported: cgoEnabled[p]})
+			CgoSupported: cgoEnabled[p],
+			FirstClass:   firstClass[p]})
 	}
 	out, err := json.MarshalIndent(results, "", "\t")
 	if err != nil {
-- 
GitLab


From 76b2d6afed1e22556bd6c52e74b546eb8bf9a225 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Fri, 21 May 2021 12:50:52 -0700
Subject: [PATCH 2098/2400] os: document that StartProcess puts files into
 blocking mode

Fixes #43894

Change-Id: I2add7b8a4f6ae69a5ef1c48703fde21a4b74307c
Reviewed-on: https://go-review.googlesource.com/c/go/+/321852
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 src/os/exec.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/os/exec.go b/src/os/exec.go
index edb773a092..bc75d4dd66 100644
--- a/src/os/exec.go
+++ b/src/os/exec.go
@@ -54,6 +54,9 @@ type ProcAttr struct {
 	// standard error. An implementation may support additional entries,
 	// depending on the underlying operating system. A nil entry corresponds
 	// to that file being closed when the process starts.
+	// On Unix systems, StartProcess will change these File values
+	// to blocking mode, which means that SetDeadline will stop working
+	// and calling Close will not interrupt a Read or Write.
 	Files []*File
 
 	// Operating system-specific process creation attributes.
-- 
GitLab


From 3c656445f139d8b6def40aa7beffd5da9fceccdb Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 21 May 2021 16:33:42 -0400
Subject: [PATCH 2099/2400] cmd/go: in TestScript/mod_replace, download an
 explicit module path
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

As of CL 318629, 'go mod download' without arguments does not save
checksums for module source code. Without a checksum, 'go list' will
not report the location of the source code even if it is present, in
order to prevent accidental access of mismatched code.

Downloading an explicit module here also more clearly expresses the
intent of the test (“download this module and see where it is”), and
may be somewhat more efficient (since the test doesn't need source
code for the other modules in the build list).

Updates #45332

Change-Id: Ic589b22478e3ed140b95365bb6729101dd598ccc
Reviewed-on: https://go-review.googlesource.com/c/go/+/321956
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/testdata/script/mod_replace.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/go/testdata/script/mod_replace.txt b/src/cmd/go/testdata/script/mod_replace.txt
index dc9667f1d0..a0a367fb1d 100644
--- a/src/cmd/go/testdata/script/mod_replace.txt
+++ b/src/cmd/go/testdata/script/mod_replace.txt
@@ -48,7 +48,7 @@ stderr 'module rsc.io/quote/v3@upgrade found \(v3.0.0, replaced by ./local/rsc.i
 # The reported Dir and GoMod for a replaced module should be accurate.
 cp go.mod.orig go.mod
 go mod edit -replace=rsc.io/quote/v3=not-rsc.io/quote@v0.1.0-nomod
-go mod download
+go mod download rsc.io/quote/v3
 go list -m -f '{{.Path}} {{.Version}} {{.Dir}} {{.GoMod}}{{with .Replace}} => {{.Path}} {{.Version}} {{.Dir}} {{.GoMod}}{{end}}' rsc.io/quote/v3
 stdout '^rsc.io/quote/v3 v3.0.0 '$GOPATH'[/\\]pkg[/\\]mod[/\\]not-rsc.io[/\\]quote@v0.1.0-nomod '$GOPATH'[/\\]pkg[/\\]mod[/\\]cache[/\\]download[/\\]not-rsc.io[/\\]quote[/\\]@v[/\\]v0.1.0-nomod.mod => not-rsc.io/quote v0.1.0-nomod '$GOPATH'[/\\]pkg[/\\]mod[/\\]not-rsc.io[/\\]quote@v0.1.0-nomod '$GOPATH'[/\\]pkg[/\\]mod[/\\]cache[/\\]download[/\\]not-rsc.io[/\\]quote[/\\]@v[/\\]v0.1.0-nomod.mod$'
 
-- 
GitLab


From 217f5dd496e14f0e0617c9efe0509073dec95d61 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Wed, 12 May 2021 13:55:59 -0700
Subject: [PATCH 2100/2400] doc: document additional atomic.Value methods

For #44513. Fixes #46022.

Change-Id: Id1d87fbd4034461953760ce77201f87ed723ff88
Reviewed-on: https://go-review.googlesource.com/c/go/+/319549
Trust: Keith Randall <khr@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 doc/go1.17.html | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index f00c649e04..5ab99c29ed 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -507,7 +507,9 @@ Do not send CLs removing the interior tags from such phrases.
 <dl id="sync/atomic"><dt><a href="/pkg/sync/atomic/">sync/atomic</a></dt>
   <dd>
     <p><!-- CL 241678 -->
-      TODO: <a href="https://golang.org/cl/241678">https://golang.org/cl/241678</a>: add (*Value).Swap and (*Value).CompareAndSwap
+      <code>atomic.Value</code> now has <a href="/pkg/sync/atomic/#Value.Swap"><code>Swap</code></a> and
+      <a href="/pkg/sync/atomic/#Value.CompareAndSwap"><code>CompareAndSwap</code></a> methods that provide
+      additional atomic operations.
     </p>
   </dd>
 </dl><!-- sync/atomic -->
-- 
GitLab


From f87194cbd7e79eef07c897a6240fbf2dc115f9ff Mon Sep 17 00:00:00 2001
From: ian woolf <btw515wolf2@gmail.com>
Date: Fri, 7 May 2021 16:31:00 +0800
Subject: [PATCH 2101/2400] doc/go1.17: document changes to net/http package

Changes include:
* ReadRequest function now returns an error when a request has multiple
  Host headers.

For #44513.
Updates #46015.

Change-Id: I48ea7c5cee3f1d1a247035fd37191362a53d1f04
Reviewed-on: https://go-review.googlesource.com/c/go/+/317914
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Trust: Heschi Kreinick <heschi@google.com>
---
 doc/go1.17.html | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 5ab99c29ed..46ee1da6fa 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -423,7 +423,8 @@ Do not send CLs removing the interior tags from such phrases.
     </p>
 
     <p><!-- CL 308952 -->
-      TODO: <a href="https://golang.org/cl/308952">https://golang.org/cl/308952</a>: make ReadRequest return an error when requests have multiple Host headers
+      The <a href="/pkg/net/http/#ReadRequest"><code>ReadRequest</code></a> function
+      now returns an error when the request has multiple Host headers.
     </p>
   </dd>
 </dl><!-- net/http -->
-- 
GitLab


From cca23a73733ff166722c69359f0bb45e12ccaa2b Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Fri, 21 May 2021 10:53:10 -0400
Subject: [PATCH 2102/2400] cmd/compile: revert CL/316890

This is a revert of https://go-review.googlesource.com/c/go/+/316890,
which has positive effects on debugging + DWARF variable locations
for register parameters when the reg abi is in effect, but also
turns out to interact badly with the register allocator.

Fixes #46304.

Change-Id: I624bd980493411a9cde45d44fcd3c46cad796909
Reviewed-on: https://go-review.googlesource.com/c/go/+/321830
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ssa/expand_calls.go | 16 -----
 test/fixedbugs/issue46304.go                 | 76 ++++++++++++++++++++
 2 files changed, 76 insertions(+), 16 deletions(-)
 create mode 100644 test/fixedbugs/issue46304.go

diff --git a/src/cmd/compile/internal/ssa/expand_calls.go b/src/cmd/compile/internal/ssa/expand_calls.go
index d37d06f8e7..7e973ab205 100644
--- a/src/cmd/compile/internal/ssa/expand_calls.go
+++ b/src/cmd/compile/internal/ssa/expand_calls.go
@@ -1717,22 +1717,6 @@ func (x *expandState) newArgToMemOrRegs(baseArg, toReplace *Value, offset int64,
 	} else {
 		w = baseArg.Block.NewValue0IA(pos, op, t, auxInt, aux)
 	}
-	// If we are creating an OpArgIntReg/OpArgFloatReg that
-	// corresponds to an in-param that fits entirely in a register,
-	// then enter it into the name/value table. The LocalSlot
-	// is somewhat fictitious, since there is no incoming live
-	// memory version of the parameter, but we need an entry in
-	// NamedValues in order for ssa debug tracking to include
-	// the value in the tracking analysis.
-	if len(pa.Registers) == 1 {
-		loc := LocalSlot{N: aux.Name, Type: t, Off: 0}
-		values, ok := x.f.NamedValues[loc]
-		if !ok {
-			ploc := x.f.localSlotAddr(loc)
-			x.f.Names = append(x.f.Names, ploc)
-		}
-		x.f.NamedValues[loc] = append(values, w)
-	}
 	x.commonArgs[key] = w
 	if toReplace != nil {
 		toReplace.copyOf(w)
diff --git a/test/fixedbugs/issue46304.go b/test/fixedbugs/issue46304.go
new file mode 100644
index 0000000000..b8ecfc93a5
--- /dev/null
+++ b/test/fixedbugs/issue46304.go
@@ -0,0 +1,76 @@
+// run
+
+// Copyright 2021 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.
+
+// This testcase caused a crash when the register ABI was in effect,
+// on amd64 (problem with register allocation).
+
+package main
+
+type Op struct {
+	tag   string
+	_x    []string
+	_q    [20]uint64
+	plist []P
+}
+
+type P struct {
+	tag string
+	_x  [10]uint64
+	b   bool
+}
+
+type M int
+
+//go:noinline
+func (w *M) walkP(p *P) *P {
+	np := &P{}
+	*np = *p
+	np.tag += "new"
+	return np
+}
+
+func (w *M) walkOp(op *Op) *Op {
+	if op == nil {
+		return nil
+	}
+
+	orig := op
+	cloned := false
+	clone := func() {
+		if !cloned {
+			cloned = true
+			op = &Op{}
+			*op = *orig
+		}
+	}
+
+	pCloned := false
+	for i := range op.plist {
+		if s := w.walkP(&op.plist[i]); s != &op.plist[i] {
+			if !pCloned {
+				pCloned = true
+				clone()
+				op.plist = make([]P, len(orig.plist))
+				copy(op.plist, orig.plist)
+			}
+			op.plist[i] = *s
+		}
+	}
+
+	return op
+}
+
+func main() {
+	var ww M
+	w := &ww
+	p1 := P{tag: "a"}
+	p1._x[1] = 9
+	o := Op{tag: "old", plist: []P{p1}}
+	no := w.walkOp(&o)
+	if no.plist[0].tag != "anew" {
+		panic("bad")
+	}
+}
-- 
GitLab


From 05819bc104c3021d20ad21aa685fb6b4db35ceb0 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 14 May 2021 23:14:22 -0400
Subject: [PATCH 2103/2400] cmd/go/internal/modcmd: factor out a type for flags
 whose arguments are Go versions

For #46141
Updates #45094

Change-Id: I6553600c69273762a81795ef021c66f4e0872b6b
Reviewed-on: https://go-review.googlesource.com/c/go/+/321069
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modcmd/edit.go            |  2 +-
 src/cmd/go/internal/modcmd/tidy.go            | 42 ++++++++++++++-----
 src/cmd/go/internal/modload/init.go           | 10 ++---
 src/cmd/go/internal/modload/load.go           |  4 +-
 src/cmd/go/internal/modload/modfile.go        |  2 +-
 .../go/testdata/script/mod_tidy_version.txt   | 12 +++++-
 6 files changed, 52 insertions(+), 20 deletions(-)

diff --git a/src/cmd/go/internal/modcmd/edit.go b/src/cmd/go/internal/modcmd/edit.go
index 79a93ca44b..e856e7c630 100644
--- a/src/cmd/go/internal/modcmd/edit.go
+++ b/src/cmd/go/internal/modcmd/edit.go
@@ -196,7 +196,7 @@ func runEdit(ctx context.Context, cmd *base.Command, args []string) {
 
 	if *editGo != "" {
 		if !modfile.GoVersionRE.MatchString(*editGo) {
-			base.Fatalf(`go mod: invalid -go option; expecting something like "-go 1.12"`)
+			base.Fatalf(`go mod: invalid -go option; expecting something like "-go %s"`, modload.LatestGoVersion())
 		}
 	}
 
diff --git a/src/cmd/go/internal/modcmd/tidy.go b/src/cmd/go/internal/modcmd/tidy.go
index c72ec30a57..9af624028a 100644
--- a/src/cmd/go/internal/modcmd/tidy.go
+++ b/src/cmd/go/internal/modcmd/tidy.go
@@ -12,8 +12,10 @@ import (
 	"cmd/go/internal/imports"
 	"cmd/go/internal/modload"
 	"context"
+	"fmt"
 
 	"golang.org/x/mod/modfile"
+	"golang.org/x/mod/semver"
 )
 
 var cmdTidy = &base.Command{
@@ -44,28 +46,48 @@ See https://golang.org/ref/mod#go-mod-tidy for more about 'go mod tidy'.
 }
 
 var (
-	tidyE  bool   // if true, report errors but proceed anyway.
-	tidyGo string // go version to write to the tidied go.mod file (toggles lazy loading)
+	tidyE  bool          // if true, report errors but proceed anyway.
+	tidyGo goVersionFlag // go version to write to the tidied go.mod file (toggles lazy loading)
 )
 
 func init() {
 	cmdTidy.Flag.BoolVar(&cfg.BuildV, "v", false, "")
 	cmdTidy.Flag.BoolVar(&tidyE, "e", false, "")
-	cmdTidy.Flag.StringVar(&tidyGo, "go", "", "")
+	cmdTidy.Flag.Var(&tidyGo, "go", "")
 	base.AddModCommonFlags(&cmdTidy.Flag)
 }
 
+// A goVersionFlag is a flag.Value representing a supported Go version.
+//
+// (Note that the -go argument to 'go mod edit' is *not* a goVersionFlag.
+// It intentionally allows newer-than-supported versions as arguments.)
+type goVersionFlag struct {
+	v string
+}
+
+func (f *goVersionFlag) String() string   { return f.v }
+func (f *goVersionFlag) Get() interface{} { return f.v }
+
+func (f *goVersionFlag) Set(s string) error {
+	if s != "" {
+		latest := modload.LatestGoVersion()
+		if !modfile.GoVersionRE.MatchString(s) {
+			return fmt.Errorf("expecting a Go version like %q", latest)
+		}
+		if semver.Compare("v"+s, "v"+latest) > 0 {
+			return fmt.Errorf("maximum supported Go version is %s", latest)
+		}
+	}
+
+	f.v = s
+	return nil
+}
+
 func runTidy(ctx context.Context, cmd *base.Command, args []string) {
 	if len(args) > 0 {
 		base.Fatalf("go mod tidy: no arguments allowed")
 	}
 
-	if tidyGo != "" {
-		if !modfile.GoVersionRE.MatchString(tidyGo) {
-			base.Fatalf(`go mod: invalid -go option %q; expecting something like "-go 1.17"`, tidyGo)
-		}
-	}
-
 	// Tidy aims to make 'go test' reproducible for any package in 'all', so we
 	// need to include test dependencies. For modules that specify go 1.15 or
 	// earlier this is a no-op (because 'all' saturates transitive test
@@ -80,7 +102,7 @@ func runTidy(ctx context.Context, cmd *base.Command, args []string) {
 	modload.RootMode = modload.NeedRoot
 
 	modload.LoadPackages(ctx, modload.PackageOpts{
-		GoVersion:                tidyGo,
+		GoVersion:                tidyGo.String(),
 		Tags:                     imports.AnyTags(),
 		Tidy:                     true,
 		VendorModulesInGOROOTSrc: true,
diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index 5cdea12cd3..e358230e74 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -405,7 +405,7 @@ func loadModFile(ctx context.Context) (rs *Requirements, needCommit bool) {
 	if modRoot == "" {
 		Target = module.Version{Path: "command-line-arguments"}
 		targetPrefix = "command-line-arguments"
-		goVersion := latestGoVersion()
+		goVersion := LatestGoVersion()
 		rawGoVersion.Store(Target, goVersion)
 		requirements = newRequirements(modDepthFromGoVersion(goVersion), nil, nil)
 		return requirements, false
@@ -448,7 +448,7 @@ func loadModFile(ctx context.Context) (rs *Requirements, needCommit bool) {
 		// TODO(#45551): Do something more principled instead of checking
 		// cfg.CmdName directly here.
 		if cfg.BuildMod == "mod" && cfg.CmdName != "mod graph" && cfg.CmdName != "mod why" {
-			addGoStmt(latestGoVersion())
+			addGoStmt(LatestGoVersion())
 			if go117EnableLazyLoading {
 				// We need to add a 'go' version to the go.mod file, but we must assume
 				// that its existing contents match something between Go 1.11 and 1.16.
@@ -500,7 +500,7 @@ func CreateModFile(ctx context.Context, modPath string) {
 	modFile = new(modfile.File)
 	modFile.AddModuleStmt(modPath)
 	initTarget(modFile.Module.Mod)
-	addGoStmt(latestGoVersion()) // Add the go directive before converted module requirements.
+	addGoStmt(LatestGoVersion()) // Add the go directive before converted module requirements.
 
 	convertedFrom, err := convertLegacyConfig(modPath)
 	if convertedFrom != "" {
@@ -793,9 +793,9 @@ func addGoStmt(v string) {
 	rawGoVersion.Store(Target, v)
 }
 
-// latestGoVersion returns the latest version of the Go language supported by
+// LatestGoVersion returns the latest version of the Go language supported by
 // this toolchain, like "1.17".
-func latestGoVersion() string {
+func LatestGoVersion() string {
 	tags := build.Default.ReleaseTags
 	version := tags[len(tags)-1]
 	if !strings.HasPrefix(version, "go") || !modfile.GoVersionRE.MatchString(version[2:]) {
diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index 83fc7c09c3..23ee3824f3 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -931,8 +931,8 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 			ld.allClosesOverTests = true
 		}
 
-		if ld.Tidy && semver.Compare(goVersionV, "v"+latestGoVersion()) > 0 {
-			ld.errorf("go mod tidy: go.mod file indicates go %s, but maximum supported version is %s\n", params.GoVersion, latestGoVersion())
+		if ld.Tidy && semver.Compare(goVersionV, "v"+LatestGoVersion()) > 0 {
+			ld.errorf("go mod tidy: go.mod file indicates go %s, but maximum supported version is %s\n", params.GoVersion, LatestGoVersion())
 			base.ExitIfErrors()
 		}
 
diff --git a/src/cmd/go/internal/modload/modfile.go b/src/cmd/go/internal/modload/modfile.go
index bafff3e080..a9c3a91d35 100644
--- a/src/cmd/go/internal/modload/modfile.go
+++ b/src/cmd/go/internal/modload/modfile.go
@@ -55,7 +55,7 @@ var modFile *modfile.File
 // in modFile are intepreted, or the latest Go version if modFile is nil.
 func modFileGoVersion() string {
 	if modFile == nil {
-		return latestGoVersion()
+		return LatestGoVersion()
 	}
 	if modFile.Go == nil || modFile.Go.Version == "" {
 		// The main module necessarily has a go.mod file, and that file lacks a
diff --git a/src/cmd/go/testdata/script/mod_tidy_version.txt b/src/cmd/go/testdata/script/mod_tidy_version.txt
index 5441d9cc06..eaa6ee7b0d 100644
--- a/src/cmd/go/testdata/script/mod_tidy_version.txt
+++ b/src/cmd/go/testdata/script/mod_tidy_version.txt
@@ -32,12 +32,22 @@
 
 cp go.mod go.mod.orig
 
+
 # An invalid argument should be rejected.
 
 ! go mod tidy -go=bananas
-stderr '^go mod: invalid -go option "bananas"; expecting something like "-go 1.17"$'
+stderr '^invalid value "bananas" for flag -go: expecting a Go version like "'$goversion'"$'
 cmp go.mod go.mod.orig
 
+! go mod tidy -go=0.9
+stderr '^invalid value "0.9" for flag -go: expecting a Go version like "'$goversion'"$'
+
+! go mod tidy -go=2000.0
+stderr '^invalid value "2000.0" for flag -go: maximum supported Go version is '$goversion'$'
+
+
+# Supported versions should change the go.mod file to be tidy according to the
+# indicated version.
 
 go mod tidy -go=1.15
 cmp go.mod go.mod.115
-- 
GitLab


From 52d7033ff6d56094b7fa852bbdf51b4525bd6bb2 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 14 May 2021 16:51:57 -0400
Subject: [PATCH 2104/2400] cmd/go/internal/modload: set the default GoVersion
 in a single location

For #46141
Updates #36460

Change-Id: Ie4c13c73a451650d1e8abb8e5cebfc30d0a71a70
Reviewed-on: https://go-review.googlesource.com/c/go/+/321070
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modload/load.go | 41 ++++++++++++-----------------
 1 file changed, 17 insertions(+), 24 deletions(-)

diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index 23ee3824f3..37b0032d43 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -314,10 +314,6 @@ func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (ma
 
 	initialRS, _ := loadModFile(ctx) // Ignore needCommit — we're going to commit at the end regardless.
 
-	if opts.GoVersion == "" {
-		opts.GoVersion = modFileGoVersion()
-	}
-
 	ld := loadFromRoots(ctx, loaderParams{
 		PackageOpts:  opts,
 		requirements: initialRS,
@@ -380,7 +376,7 @@ func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (ma
 
 	// Success! Update go.mod and go.sum (if needed) and return the results.
 	loaded = ld
-	commitRequirements(ctx, opts.GoVersion, loaded.requirements)
+	commitRequirements(ctx, loaded.GoVersion, loaded.requirements)
 
 	for _, pkg := range ld.pkgs {
 		if !pkg.isTest() {
@@ -605,10 +601,8 @@ func ImportFromFiles(ctx context.Context, gofiles []string) {
 		base.Fatalf("go: %v", err)
 	}
 
-	goVersion := modFileGoVersion()
 	loaded = loadFromRoots(ctx, loaderParams{
 		PackageOpts: PackageOpts{
-			GoVersion:             goVersion,
 			Tags:                  tags,
 			ResolveMissingImports: true,
 			SilencePackageErrors:  true,
@@ -620,7 +614,7 @@ func ImportFromFiles(ctx context.Context, gofiles []string) {
 			return roots
 		},
 	})
-	commitRequirements(ctx, goVersion, loaded.requirements)
+	commitRequirements(ctx, loaded.GoVersion, loaded.requirements)
 }
 
 // DirImportPath returns the effective import path for dir,
@@ -921,26 +915,25 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 		work:         par.NewQueue(runtime.GOMAXPROCS(0)),
 	}
 
-	if params.GoVersion != "" {
-		goVersionV := "v" + params.GoVersion
-		if semver.Compare(goVersionV, narrowAllVersionV) < 0 && !ld.UseVendorAll {
-			// The module's go version explicitly predates the change in "all" for lazy
-			// loading, so continue to use the older interpretation.
-			// (If params.GoVersion is empty, we are probably not in any module at all
-			// and should use the latest semantics.)
-			ld.allClosesOverTests = true
-		}
+	if ld.GoVersion == "" {
+		ld.GoVersion = modFileGoVersion()
 
-		if ld.Tidy && semver.Compare(goVersionV, "v"+LatestGoVersion()) > 0 {
-			ld.errorf("go mod tidy: go.mod file indicates go %s, but maximum supported version is %s\n", params.GoVersion, LatestGoVersion())
+		if ld.Tidy && semver.Compare("v"+ld.GoVersion, "v"+LatestGoVersion()) > 0 {
+			ld.errorf("go mod tidy: go.mod file indicates go %s, but maximum supported version is %s\n", ld.GoVersion, LatestGoVersion())
 			base.ExitIfErrors()
 		}
+	}
 
-		var err error
-		ld.requirements, err = convertDepth(ctx, ld.requirements, modDepthFromGoVersion(params.GoVersion))
-		if err != nil {
-			ld.errorf("go: %v\n", err)
-		}
+	if semver.Compare("v"+ld.GoVersion, narrowAllVersionV) < 0 && !ld.UseVendorAll {
+		// The module's go version explicitly predates the change in "all" for lazy
+		// loading, so continue to use the older interpretation.
+		ld.allClosesOverTests = true
+	}
+
+	var err error
+	ld.requirements, err = convertDepth(ctx, ld.requirements, modDepthFromGoVersion(ld.GoVersion))
+	if err != nil {
+		ld.errorf("go: %v\n", err)
 	}
 
 	if ld.requirements.depth == eager {
-- 
GitLab


From 4356e7e85fcd8f59de6bc1fd1db6e4f01a92f19e Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Fri, 21 May 2021 20:30:02 +0000
Subject: [PATCH 2105/2400] runtime: account for spill slots in Windows
 callback compilation

The Go ABI, as it stands, requires spill space to be reserved for
register arguments. syscall.NewCallback (because of compileCallback)
does not actually reserve this space, leading to issues if the Go code
it invokes actually makes use of it.

Fixes #46301.

Change-Id: Idbc3578accaaaa29e4ba32291ef08d464da0b7b0
Reviewed-on: https://go-review.googlesource.com/c/go/+/322029
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Egon Elbre <egonelbre@gmail.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 src/runtime/syscall_windows.go      | 23 ++++++++++++++++++++---
 src/runtime/syscall_windows_test.go | 15 +++++++++++++++
 2 files changed, 35 insertions(+), 3 deletions(-)

diff --git a/src/runtime/syscall_windows.go b/src/runtime/syscall_windows.go
index 6b9195bcd5..4763a440e7 100644
--- a/src/runtime/syscall_windows.go
+++ b/src/runtime/syscall_windows.go
@@ -64,6 +64,7 @@ type abiDesc struct {
 
 	srcStackSize uintptr // stdcall/fastcall stack space tracking
 	dstStackSize uintptr // Go stack space used
+	dstSpill     uintptr // Extra stack space for argument spill slots
 	dstRegisters int     // Go ABI int argument registers used
 
 	// retOffset is the offset of the uintptr-sized result in the Go
@@ -110,7 +111,14 @@ func (p *abiDesc) assignArg(t *_type) {
 	// arguments. The same is true on arm.
 
 	oldParts := p.parts
-	if !p.tryRegAssignArg(t, 0) {
+	if p.tryRegAssignArg(t, 0) {
+		// Account for spill space.
+		//
+		// TODO(mknyszek): Remove this when we no longer have
+		// caller reserved spill space.
+		p.dstSpill = alignUp(p.dstSpill, uintptr(t.align))
+		p.dstSpill += t.size
+	} else {
 		// Register assignment failed.
 		// Undo the work and stack assign.
 		p.parts = oldParts
@@ -277,7 +285,11 @@ func compileCallback(fn eface, cdecl bool) (code uintptr) {
 		abiMap.dstStackSize += sys.PtrSize
 	}
 
-	if abiMap.dstStackSize > callbackMaxFrame {
+	// TODO(mknyszek): Remove dstSpill from this calculation when we no longer have
+	// caller reserved spill space.
+	frameSize := alignUp(abiMap.dstStackSize, sys.PtrSize)
+	frameSize += abiMap.dstSpill
+	if frameSize > callbackMaxFrame {
 		panic("compileCallback: function argument frame too large")
 	}
 
@@ -356,9 +368,14 @@ func callbackWrap(a *callbackArgs) {
 		}
 	}
 
+	// TODO(mknyszek): Remove this when we no longer have
+	// caller reserved spill space.
+	frameSize := alignUp(c.abiMap.dstStackSize, sys.PtrSize)
+	frameSize += c.abiMap.dstSpill
+
 	// Even though this is copying back results, we can pass a nil
 	// type because those results must not require write barriers.
-	reflectcall(nil, unsafe.Pointer(c.fn), noescape(goArgs), uint32(c.abiMap.dstStackSize), uint32(c.abiMap.retOffset), uint32(c.abiMap.dstStackSize), &regs)
+	reflectcall(nil, unsafe.Pointer(c.fn), noescape(goArgs), uint32(c.abiMap.dstStackSize), uint32(c.abiMap.retOffset), uint32(frameSize), &regs)
 
 	// Extract the result.
 	//
diff --git a/src/runtime/syscall_windows_test.go b/src/runtime/syscall_windows_test.go
index 5e9694d444..e3f772ac4b 100644
--- a/src/runtime/syscall_windows_test.go
+++ b/src/runtime/syscall_windows_test.go
@@ -389,6 +389,10 @@ var cbFuncs = []cbFunc{
 	{func(i1, i2, i3, i4, i5 uint8Pair) uintptr {
 		return uintptr(i1.x + i1.y + i2.x + i2.y + i3.x + i3.y + i4.x + i4.y + i5.x + i5.y)
 	}},
+	{func(i1, i2, i3, i4, i5, i6, i7, i8, i9 uint32) uintptr {
+		runtime.GC()
+		return uintptr(i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9)
+	}},
 }
 
 //go:registerparams
@@ -461,6 +465,16 @@ func sum5andPair(i1, i2, i3, i4, i5 uint8Pair) uintptr {
 	return uintptr(i1.x + i1.y + i2.x + i2.y + i3.x + i3.y + i4.x + i4.y + i5.x + i5.y)
 }
 
+// This test forces a GC. The idea is to have enough arguments
+// that insufficient spill slots allocated (according to the ABI)
+// may cause compiler-generated spills to clobber the return PC.
+// Then, the GC stack scanning will catch that.
+//go:registerparams
+func sum9andGC(i1, i2, i3, i4, i5, i6, i7, i8, i9 uint32) uintptr {
+	runtime.GC()
+	return uintptr(i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9)
+}
+
 // TODO(register args): Remove this once we switch to using the register
 // calling convention by default, since this is redundant with the existing
 // tests.
@@ -479,6 +493,7 @@ var cbFuncsRegABI = []cbFunc{
 	{sum9int8},
 	{sum5mix},
 	{sum5andPair},
+	{sum9andGC},
 }
 
 func getCallbackTestFuncs() []cbFunc {
-- 
GitLab


From a22e3172200d4bdd0afcbbe6564dbb67fea4b03a Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Sat, 22 May 2021 21:59:00 -0700
Subject: [PATCH 2106/2400] cmd/compile: always include underlying type for map
 types

This is a different fix for #37716.

Should help make the fix for #46283 easier, since we will no longer
need to keep compiler-generated hash functions and the runtime
hash function in sync.

Change-Id: I84cb93144e425dcd03afc552b5fbd0f2d2cc6d39
Reviewed-on: https://go-review.googlesource.com/c/go/+/322150
Trust: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 .../compile/internal/reflectdata/reflect.go   |  9 +++
 src/cmd/internal/objabi/reloctype.go          |  3 +
 src/cmd/internal/objabi/reloctype_string.go   | 71 ++++++++++---------
 src/runtime/alg.go                            | 19 +----
 src/runtime/export_test.go                    | 25 -------
 src/runtime/hash_test.go                      | 49 -------------
 6 files changed, 49 insertions(+), 127 deletions(-)

diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index 8c0e33f6df..b3688fca67 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -1112,6 +1112,15 @@ func writeType(t *types.Type) *obj.LSym {
 		}
 		ot = objw.Uint32(lsym, ot, flags)
 		ot = dextratype(lsym, ot, t, 0)
+		if u := t.Underlying(); u != t {
+			// If t is a named map type, also keep the underlying map
+			// type live in the binary. This is important to make sure that
+			// a named map and that same map cast to its underlying type via
+			// reflection, use the same hash function. See issue 37716.
+			r := obj.Addrel(lsym)
+			r.Sym = writeType(u)
+			r.Type = objabi.R_KEEP
+		}
 
 	case types.TPTR:
 		if t.Elem().Kind() == types.TANY {
diff --git a/src/cmd/internal/objabi/reloctype.go b/src/cmd/internal/objabi/reloctype.go
index ea55fa3b0a..52827a6dee 100644
--- a/src/cmd/internal/objabi/reloctype.go
+++ b/src/cmd/internal/objabi/reloctype.go
@@ -101,6 +101,9 @@ const (
 	// *rtype, and may be set to zero by the linker if it determines the method
 	// text is unreachable by the linked program.
 	R_METHODOFF
+	// R_KEEP tells the linker to keep the referred-to symbol in the final binary
+	// if the symbol containing the R_KEEP relocation is in the final binary.
+	R_KEEP
 	R_POWER_TOC
 	R_GOTPCREL
 	// R_JMPMIPS (only used on mips64) resolves to non-PC-relative target address
diff --git a/src/cmd/internal/objabi/reloctype_string.go b/src/cmd/internal/objabi/reloctype_string.go
index 8882d19f88..4638ef14d9 100644
--- a/src/cmd/internal/objabi/reloctype_string.go
+++ b/src/cmd/internal/objabi/reloctype_string.go
@@ -34,44 +34,45 @@ func _() {
 	_ = x[R_USEIFACE-24]
 	_ = x[R_USEIFACEMETHOD-25]
 	_ = x[R_METHODOFF-26]
-	_ = x[R_POWER_TOC-27]
-	_ = x[R_GOTPCREL-28]
-	_ = x[R_JMPMIPS-29]
-	_ = x[R_DWARFSECREF-30]
-	_ = x[R_DWARFFILEREF-31]
-	_ = x[R_ARM64_TLS_LE-32]
-	_ = x[R_ARM64_TLS_IE-33]
-	_ = x[R_ARM64_GOTPCREL-34]
-	_ = x[R_ARM64_GOT-35]
-	_ = x[R_ARM64_PCREL-36]
-	_ = x[R_ARM64_LDST8-37]
-	_ = x[R_ARM64_LDST16-38]
-	_ = x[R_ARM64_LDST32-39]
-	_ = x[R_ARM64_LDST64-40]
-	_ = x[R_ARM64_LDST128-41]
-	_ = x[R_POWER_TLS_LE-42]
-	_ = x[R_POWER_TLS_IE-43]
-	_ = x[R_POWER_TLS-44]
-	_ = x[R_ADDRPOWER_DS-45]
-	_ = x[R_ADDRPOWER_GOT-46]
-	_ = x[R_ADDRPOWER_PCREL-47]
-	_ = x[R_ADDRPOWER_TOCREL-48]
-	_ = x[R_ADDRPOWER_TOCREL_DS-49]
-	_ = x[R_RISCV_PCREL_ITYPE-50]
-	_ = x[R_RISCV_PCREL_STYPE-51]
-	_ = x[R_RISCV_TLS_IE_ITYPE-52]
-	_ = x[R_RISCV_TLS_IE_STYPE-53]
-	_ = x[R_PCRELDBL-54]
-	_ = x[R_ADDRMIPSU-55]
-	_ = x[R_ADDRMIPSTLS-56]
-	_ = x[R_ADDRCUOFF-57]
-	_ = x[R_WASMIMPORT-58]
-	_ = x[R_XCOFFREF-59]
+	_ = x[R_KEEP-27]
+	_ = x[R_POWER_TOC-28]
+	_ = x[R_GOTPCREL-29]
+	_ = x[R_JMPMIPS-30]
+	_ = x[R_DWARFSECREF-31]
+	_ = x[R_DWARFFILEREF-32]
+	_ = x[R_ARM64_TLS_LE-33]
+	_ = x[R_ARM64_TLS_IE-34]
+	_ = x[R_ARM64_GOTPCREL-35]
+	_ = x[R_ARM64_GOT-36]
+	_ = x[R_ARM64_PCREL-37]
+	_ = x[R_ARM64_LDST8-38]
+	_ = x[R_ARM64_LDST16-39]
+	_ = x[R_ARM64_LDST32-40]
+	_ = x[R_ARM64_LDST64-41]
+	_ = x[R_ARM64_LDST128-42]
+	_ = x[R_POWER_TLS_LE-43]
+	_ = x[R_POWER_TLS_IE-44]
+	_ = x[R_POWER_TLS-45]
+	_ = x[R_ADDRPOWER_DS-46]
+	_ = x[R_ADDRPOWER_GOT-47]
+	_ = x[R_ADDRPOWER_PCREL-48]
+	_ = x[R_ADDRPOWER_TOCREL-49]
+	_ = x[R_ADDRPOWER_TOCREL_DS-50]
+	_ = x[R_RISCV_PCREL_ITYPE-51]
+	_ = x[R_RISCV_PCREL_STYPE-52]
+	_ = x[R_RISCV_TLS_IE_ITYPE-53]
+	_ = x[R_RISCV_TLS_IE_STYPE-54]
+	_ = x[R_PCRELDBL-55]
+	_ = x[R_ADDRMIPSU-56]
+	_ = x[R_ADDRMIPSTLS-57]
+	_ = x[R_ADDRCUOFF-58]
+	_ = x[R_WASMIMPORT-59]
+	_ = x[R_XCOFFREF-60]
 }
 
-const _RelocType_name = "R_ADDRR_ADDRPOWERR_ADDRARM64R_ADDRMIPSR_ADDROFFR_SIZER_CALLR_CALLARMR_CALLARM64R_CALLINDR_CALLPOWERR_CALLMIPSR_CALLRISCVR_CONSTR_PCRELR_TLS_LER_TLS_IER_GOTOFFR_PLT0R_PLT1R_PLT2R_USEFIELDR_USETYPER_USEIFACER_USEIFACEMETHODR_METHODOFFR_POWER_TOCR_GOTPCRELR_JMPMIPSR_DWARFSECREFR_DWARFFILEREFR_ARM64_TLS_LER_ARM64_TLS_IER_ARM64_GOTPCRELR_ARM64_GOTR_ARM64_PCRELR_ARM64_LDST8R_ARM64_LDST16R_ARM64_LDST32R_ARM64_LDST64R_ARM64_LDST128R_POWER_TLS_LER_POWER_TLS_IER_POWER_TLSR_ADDRPOWER_DSR_ADDRPOWER_GOTR_ADDRPOWER_PCRELR_ADDRPOWER_TOCRELR_ADDRPOWER_TOCREL_DSR_RISCV_PCREL_ITYPER_RISCV_PCREL_STYPER_RISCV_TLS_IE_ITYPER_RISCV_TLS_IE_STYPER_PCRELDBLR_ADDRMIPSUR_ADDRMIPSTLSR_ADDRCUOFFR_WASMIMPORTR_XCOFFREF"
+const _RelocType_name = "R_ADDRR_ADDRPOWERR_ADDRARM64R_ADDRMIPSR_ADDROFFR_SIZER_CALLR_CALLARMR_CALLARM64R_CALLINDR_CALLPOWERR_CALLMIPSR_CALLRISCVR_CONSTR_PCRELR_TLS_LER_TLS_IER_GOTOFFR_PLT0R_PLT1R_PLT2R_USEFIELDR_USETYPER_USEIFACER_USEIFACEMETHODR_METHODOFFR_KEEPR_POWER_TOCR_GOTPCRELR_JMPMIPSR_DWARFSECREFR_DWARFFILEREFR_ARM64_TLS_LER_ARM64_TLS_IER_ARM64_GOTPCRELR_ARM64_GOTR_ARM64_PCRELR_ARM64_LDST8R_ARM64_LDST16R_ARM64_LDST32R_ARM64_LDST64R_ARM64_LDST128R_POWER_TLS_LER_POWER_TLS_IER_POWER_TLSR_ADDRPOWER_DSR_ADDRPOWER_GOTR_ADDRPOWER_PCRELR_ADDRPOWER_TOCRELR_ADDRPOWER_TOCREL_DSR_RISCV_PCREL_ITYPER_RISCV_PCREL_STYPER_RISCV_TLS_IE_ITYPER_RISCV_TLS_IE_STYPER_PCRELDBLR_ADDRMIPSUR_ADDRMIPSTLSR_ADDRCUOFFR_WASMIMPORTR_XCOFFREF"
 
-var _RelocType_index = [...]uint16{0, 6, 17, 28, 38, 47, 53, 59, 68, 79, 88, 99, 109, 120, 127, 134, 142, 150, 158, 164, 170, 176, 186, 195, 205, 221, 232, 243, 253, 262, 275, 289, 303, 317, 333, 344, 357, 370, 384, 398, 412, 427, 441, 455, 466, 480, 495, 512, 530, 551, 570, 589, 609, 629, 639, 650, 663, 674, 686, 696}
+var _RelocType_index = [...]uint16{0, 6, 17, 28, 38, 47, 53, 59, 68, 79, 88, 99, 109, 120, 127, 134, 142, 150, 158, 164, 170, 176, 186, 195, 205, 221, 232, 238, 249, 259, 268, 281, 295, 309, 323, 339, 350, 363, 376, 390, 404, 418, 433, 447, 461, 472, 486, 501, 518, 536, 557, 576, 595, 615, 635, 645, 656, 669, 680, 692, 702}
 
 func (i RelocType) String() string {
 	i -= 1
diff --git a/src/runtime/alg.go b/src/runtime/alg.go
index 1b3bf1180d..39c7426842 100644
--- a/src/runtime/alg.go
+++ b/src/runtime/alg.go
@@ -178,28 +178,11 @@ func typehash(t *_type, p unsafe.Pointer, h uintptr) uintptr {
 		return h
 	case kindStruct:
 		s := (*structtype)(unsafe.Pointer(t))
-		memStart := uintptr(0)
-		memEnd := uintptr(0)
 		for _, f := range s.fields {
-			if memEnd > memStart && (f.name.isBlank() || f.offset() != memEnd || f.typ.tflag&tflagRegularMemory == 0) {
-				// flush any pending regular memory hashing
-				h = memhash(add(p, memStart), h, memEnd-memStart)
-				memStart = memEnd
-			}
 			if f.name.isBlank() {
 				continue
 			}
-			if f.typ.tflag&tflagRegularMemory == 0 {
-				h = typehash(f.typ, add(p, f.offset()), h)
-				continue
-			}
-			if memStart == memEnd {
-				memStart = f.offset()
-			}
-			memEnd = f.offset() + f.typ.size
-		}
-		if memEnd > memStart {
-			h = memhash(add(p, memStart), h, memEnd-memStart)
+			h = typehash(f.typ, add(p, f.offset()), h)
 		}
 		return h
 	default:
diff --git a/src/runtime/export_test.go b/src/runtime/export_test.go
index a6fc1e4785..c8d01fbb15 100644
--- a/src/runtime/export_test.go
+++ b/src/runtime/export_test.go
@@ -1148,31 +1148,6 @@ func SemNwait(addr *uint32) uint32 {
 	return atomic.Load(&root.nwait)
 }
 
-// MapHashCheck computes the hash of the key k for the map m, twice.
-// Method 1 uses the built-in hasher for the map.
-// Method 2 uses the typehash function (the one used by reflect).
-// Returns the two hash values, which should always be equal.
-func MapHashCheck(m interface{}, k interface{}) (uintptr, uintptr) {
-	// Unpack m.
-	mt := (*maptype)(unsafe.Pointer(efaceOf(&m)._type))
-	mh := (*hmap)(efaceOf(&m).data)
-
-	// Unpack k.
-	kt := efaceOf(&k)._type
-	var p unsafe.Pointer
-	if isDirectIface(kt) {
-		q := efaceOf(&k).data
-		p = unsafe.Pointer(&q)
-	} else {
-		p = efaceOf(&k).data
-	}
-
-	// Compute the hash functions.
-	x := mt.hasher(noescape(p), uintptr(mh.hash0))
-	y := typehash(kt, noescape(p), uintptr(mh.hash0))
-	return x, y
-}
-
 // mspan wrapper for testing.
 //go:notinheap
 type MSpan mspan
diff --git a/src/runtime/hash_test.go b/src/runtime/hash_test.go
index 502383557b..7048874a71 100644
--- a/src/runtime/hash_test.go
+++ b/src/runtime/hash_test.go
@@ -8,7 +8,6 @@ import (
 	"fmt"
 	"math"
 	"math/rand"
-	"reflect"
 	. "runtime"
 	"strings"
 	"testing"
@@ -49,54 +48,6 @@ func TestMemHash64Equality(t *testing.T) {
 	}
 }
 
-func TestCompilerVsRuntimeHash(t *testing.T) {
-	// Test to make sure the compiler's hash function and the runtime's hash function agree.
-	// See issue 37716.
-	for _, m := range []interface{}{
-		map[bool]int{},
-		map[int8]int{},
-		map[uint8]int{},
-		map[int16]int{},
-		map[uint16]int{},
-		map[int32]int{},
-		map[uint32]int{},
-		map[int64]int{},
-		map[uint64]int{},
-		map[int]int{},
-		map[uint]int{},
-		map[uintptr]int{},
-		map[*byte]int{},
-		map[chan int]int{},
-		map[unsafe.Pointer]int{},
-		map[float32]int{},
-		map[float64]int{},
-		map[complex64]int{},
-		map[complex128]int{},
-		map[string]int{},
-		//map[interface{}]int{},
-		//map[interface{F()}]int{},
-		map[[8]uint64]int{},
-		map[[8]string]int{},
-		map[struct{ a, b, c, d int32 }]int{}, // Note: tests AMEM128
-		map[struct{ a, b, _, d int32 }]int{},
-		map[struct {
-			a, b int32
-			c    float32
-			d, e [8]byte
-		}]int{},
-		map[struct {
-			a int16
-			b int64
-		}]int{},
-	} {
-		k := reflect.New(reflect.TypeOf(m).Key()).Elem().Interface() // the zero key
-		x, y := MapHashCheck(m, k)
-		if x != y {
-			t.Errorf("hashes did not match (%x vs %x) for map %T", x, y, m)
-		}
-	}
-}
-
 // Smhasher is a torture test for hash functions.
 // https://code.google.com/p/smhasher/
 // This code is a port of some of the Smhasher tests to Go.
-- 
GitLab


From b83610699a4ea7da22a146c0eefe0ae4d5ac4610 Mon Sep 17 00:00:00 2001
From: Alessandro Arzilli <alessandro.arzilli@gmail.com>
Date: Sun, 9 May 2021 09:05:45 +0200
Subject: [PATCH 2107/2400] cmd/compile: record regabi status in DW_AT_producer

Records if regabi was enabled during compilation in the DW_AT_producer
attribute of each compile unit.
This is useful to debuggers that support the debugCall protocol.

Change-Id: I5ad2c48ebf126aeb8bfb459b53a1a5304550036a
Reviewed-on: https://go-review.googlesource.com/c/go/+/318050
Trust: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/dwarfgen/dwarf.go | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/cmd/compile/internal/dwarfgen/dwarf.go b/src/cmd/compile/internal/dwarfgen/dwarf.go
index 5d7dc320aa..0e22b61bc3 100644
--- a/src/cmd/compile/internal/dwarfgen/dwarf.go
+++ b/src/cmd/compile/internal/dwarfgen/dwarf.go
@@ -531,6 +531,14 @@ func RecordFlags(flags ...string) {
 		fmt.Fprintf(&cmd, " -%s=%v", f.Name, getter.Get())
 	}
 
+	// Adds flag to producer string singalling whether regabi is turned on or
+	// off.
+	// Once regabi is turned on across the board and the relative GOEXPERIMENT
+	// knobs no longer exist this code should be removed.
+	if buildcfg.Experiment.RegabiArgs {
+		cmd.Write([]byte(" regabi"))
+	}
+
 	if cmd.Len() == 0 {
 		return
 	}
-- 
GitLab


From 873401df5b202a751523b8cbd92bf3a8aaf989c8 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Sun, 23 May 2021 12:38:59 -0700
Subject: [PATCH 2108/2400] cmd/compile: ensure equal functions don't do
 unaligned loads

On architectures which don't support unaligned loads, make sure we
don't generate code that requires them.

Generated hash functions also matter in this respect, but they all look ok.

Update #37716
Fixes #46283

Change-Id: I6197fdfe04da4428092c99bd871d93738789e16b
Reviewed-on: https://go-review.googlesource.com/c/go/+/322151
Trust: Keith Randall <khr@golang.org>
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Keith Randall <khr@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: eric fang <eric.fang@arm.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/reflectdata/alg.go | 20 +++++
 src/cmd/compile/internal/test/align_test.go | 96 +++++++++++++++++++++
 src/cmd/internal/sys/arch.go                | 19 ++++
 3 files changed, 135 insertions(+)
 create mode 100644 src/cmd/compile/internal/test/align_test.go

diff --git a/src/cmd/compile/internal/reflectdata/alg.go b/src/cmd/compile/internal/reflectdata/alg.go
index d12d9ca0a7..0707e0b61c 100644
--- a/src/cmd/compile/internal/reflectdata/alg.go
+++ b/src/cmd/compile/internal/reflectdata/alg.go
@@ -6,6 +6,7 @@ package reflectdata
 
 import (
 	"fmt"
+	"math/bits"
 	"sort"
 
 	"cmd/compile/internal/base"
@@ -47,6 +48,11 @@ func eqCanPanic(t *types.Type) bool {
 func AlgType(t *types.Type) types.AlgKind {
 	a, _ := types.AlgType(t)
 	if a == types.AMEM {
+		if t.Alignment() < int64(base.Ctxt.Arch.Alignment) && t.Alignment() < t.Width {
+			// For example, we can't treat [2]int16 as an int32 if int32s require
+			// 4-byte alignment. See issue 46283.
+			return a
+		}
 		switch t.Width {
 		case 0:
 			return types.AMEM0
@@ -769,6 +775,20 @@ func memrun(t *types.Type, start int) (size int64, next int) {
 		if f := t.Field(next); f.Sym.IsBlank() || !isRegularMemory(f.Type) {
 			break
 		}
+		// For issue 46283, don't combine fields if the resulting load would
+		// require a larger alignment than the component fields.
+		if base.Ctxt.Arch.Alignment > 1 {
+			align := t.Alignment()
+			if off := t.Field(start).Offset; off&(align-1) != 0 {
+				// Offset is less aligned than the containing type.
+				// Use offset to determine alignment.
+				align = 1 << uint(bits.TrailingZeros64(uint64(off)))
+			}
+			size := t.Field(next).End() - t.Field(start).Offset
+			if size > align {
+				break
+			}
+		}
 	}
 	return t.Field(next-1).End() - t.Field(start).Offset, next
 }
diff --git a/src/cmd/compile/internal/test/align_test.go b/src/cmd/compile/internal/test/align_test.go
new file mode 100644
index 0000000000..32afc92973
--- /dev/null
+++ b/src/cmd/compile/internal/test/align_test.go
@@ -0,0 +1,96 @@
+// Copyright 2021 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.
+
+// Test to make sure that equality functions (and hash
+// functions) don't do unaligned reads on architectures
+// that can't do unaligned reads. See issue 46283.
+
+package test
+
+import "testing"
+
+type T1 struct {
+	x          float32
+	a, b, c, d int16 // memequal64
+}
+type T2 struct {
+	x          float32
+	a, b, c, d int32 // memequal128
+}
+
+type A2 [2]byte // eq uses a 2-byte load
+type A4 [4]byte // eq uses a 4-byte load
+type A8 [8]byte // eq uses an 8-byte load
+
+//go:noinline
+func cmpT1(p, q *T1) {
+	if *p != *q {
+		panic("comparison test wrong")
+	}
+}
+
+//go:noinline
+func cmpT2(p, q *T2) {
+	if *p != *q {
+		panic("comparison test wrong")
+	}
+}
+
+//go:noinline
+func cmpA2(p, q *A2) {
+	if *p != *q {
+		panic("comparison test wrong")
+	}
+}
+
+//go:noinline
+func cmpA4(p, q *A4) {
+	if *p != *q {
+		panic("comparison test wrong")
+	}
+}
+
+//go:noinline
+func cmpA8(p, q *A8) {
+	if *p != *q {
+		panic("comparison test wrong")
+	}
+}
+
+func TestAlignEqual(t *testing.T) {
+	cmpT1(&T1{}, &T1{})
+	cmpT2(&T2{}, &T2{})
+
+	m1 := map[T1]bool{}
+	m1[T1{}] = true
+	m1[T1{}] = false
+	if len(m1) != 1 {
+		t.Fatalf("len(m1)=%d, want 1", len(m1))
+	}
+	m2 := map[T2]bool{}
+	m2[T2{}] = true
+	m2[T2{}] = false
+	if len(m2) != 1 {
+		t.Fatalf("len(m2)=%d, want 1", len(m2))
+	}
+
+	type X2 struct {
+		y byte
+		z A2
+	}
+	var x2 X2
+	cmpA2(&x2.z, &A2{})
+	type X4 struct {
+		y byte
+		z A4
+	}
+	var x4 X4
+	cmpA4(&x4.z, &A4{})
+	type X8 struct {
+		y byte
+		z A8
+	}
+	var x8 X8
+	cmpA8(&x8.z, &A8{})
+}
diff --git a/src/cmd/internal/sys/arch.go b/src/cmd/internal/sys/arch.go
index e8687363de..a3e39768b6 100644
--- a/src/cmd/internal/sys/arch.go
+++ b/src/cmd/internal/sys/arch.go
@@ -40,6 +40,12 @@ type Arch struct {
 
 	// MinLC is the minimum length of an instruction code.
 	MinLC int
+
+	// Alignment is maximum alignment required by the architecture
+	// for any (compiler-generated) load or store instruction.
+	// Loads or stores smaller than Alignment must be naturally aligned.
+	// Loads or stores larger than Alignment need only be Alignment-aligned.
+	Alignment int8
 }
 
 // InFamily reports whether a is a member of any of the specified
@@ -60,6 +66,7 @@ var Arch386 = &Arch{
 	PtrSize:   4,
 	RegSize:   4,
 	MinLC:     1,
+	Alignment: 1,
 }
 
 var ArchAMD64 = &Arch{
@@ -69,6 +76,7 @@ var ArchAMD64 = &Arch{
 	PtrSize:   8,
 	RegSize:   8,
 	MinLC:     1,
+	Alignment: 1,
 }
 
 var ArchARM = &Arch{
@@ -78,6 +86,7 @@ var ArchARM = &Arch{
 	PtrSize:   4,
 	RegSize:   4,
 	MinLC:     4,
+	Alignment: 4, // TODO: just for arm5?
 }
 
 var ArchARM64 = &Arch{
@@ -87,6 +96,7 @@ var ArchARM64 = &Arch{
 	PtrSize:   8,
 	RegSize:   8,
 	MinLC:     4,
+	Alignment: 1,
 }
 
 var ArchMIPS = &Arch{
@@ -96,6 +106,7 @@ var ArchMIPS = &Arch{
 	PtrSize:   4,
 	RegSize:   4,
 	MinLC:     4,
+	Alignment: 4,
 }
 
 var ArchMIPSLE = &Arch{
@@ -105,6 +116,7 @@ var ArchMIPSLE = &Arch{
 	PtrSize:   4,
 	RegSize:   4,
 	MinLC:     4,
+	Alignment: 4,
 }
 
 var ArchMIPS64 = &Arch{
@@ -114,6 +126,7 @@ var ArchMIPS64 = &Arch{
 	PtrSize:   8,
 	RegSize:   8,
 	MinLC:     4,
+	Alignment: 8,
 }
 
 var ArchMIPS64LE = &Arch{
@@ -123,6 +136,7 @@ var ArchMIPS64LE = &Arch{
 	PtrSize:   8,
 	RegSize:   8,
 	MinLC:     4,
+	Alignment: 8,
 }
 
 var ArchPPC64 = &Arch{
@@ -132,6 +146,7 @@ var ArchPPC64 = &Arch{
 	PtrSize:   8,
 	RegSize:   8,
 	MinLC:     4,
+	Alignment: 1,
 }
 
 var ArchPPC64LE = &Arch{
@@ -141,6 +156,7 @@ var ArchPPC64LE = &Arch{
 	PtrSize:   8,
 	RegSize:   8,
 	MinLC:     4,
+	Alignment: 1,
 }
 
 var ArchRISCV64 = &Arch{
@@ -150,6 +166,7 @@ var ArchRISCV64 = &Arch{
 	PtrSize:   8,
 	RegSize:   8,
 	MinLC:     4,
+	Alignment: 8, // riscv unaligned loads work, but are really slow (trap + simulated by OS)
 }
 
 var ArchS390X = &Arch{
@@ -159,6 +176,7 @@ var ArchS390X = &Arch{
 	PtrSize:   8,
 	RegSize:   8,
 	MinLC:     2,
+	Alignment: 1,
 }
 
 var ArchWasm = &Arch{
@@ -168,6 +186,7 @@ var ArchWasm = &Arch{
 	PtrSize:   8,
 	RegSize:   8,
 	MinLC:     1,
+	Alignment: 1,
 }
 
 var Archs = [...]*Arch{
-- 
GitLab


From 15d9d4a009e3d2c9f1ad501143ed97a8b2c6f2c4 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 14 May 2021 16:01:17 -0400
Subject: [PATCH 2109/2400] cmd/go: add tests illustrating what happens when Go
 1.16 is used in a Go 1.17 main module

For #46141
Updates #46160

Change-Id: Ib22435b8051aaf3fa74d43d3b7f2d091e67f05e2
Reviewed-on: https://go-review.googlesource.com/c/go/+/320172
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 .../go/testdata/script/mod_tidy_compat.txt    | 100 +++++++++++++++
 .../script/mod_tidy_compat_implicit.txt       | 120 ++++++++++++++++++
 .../script/mod_tidy_compat_incompatible.txt   | 116 +++++++++++++++++
 .../script/mod_tidy_compat_irrelevant.txt     | 105 +++++++++++++++
 4 files changed, 441 insertions(+)
 create mode 100644 src/cmd/go/testdata/script/mod_tidy_compat.txt
 create mode 100644 src/cmd/go/testdata/script/mod_tidy_compat_implicit.txt
 create mode 100644 src/cmd/go/testdata/script/mod_tidy_compat_incompatible.txt
 create mode 100644 src/cmd/go/testdata/script/mod_tidy_compat_irrelevant.txt

diff --git a/src/cmd/go/testdata/script/mod_tidy_compat.txt b/src/cmd/go/testdata/script/mod_tidy_compat.txt
new file mode 100644
index 0000000000..e6f88dc779
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_tidy_compat.txt
@@ -0,0 +1,100 @@
+# https://golang.org/issue/46141: 'go mod tidy' for a Go 1.17 module should by
+# default preserve enough checksums for the module to be used by Go 1.16.
+#
+# We don't have a copy of Go 1.16 handy, but we can simulate it by editing the
+# 'go' version in the go.mod file to 1.16, without actually updating the
+# requirements to match.
+
+[short] skip
+
+env MODFMT='{{with .Module}}{{.Path}} {{.Version}}{{end}}'
+
+
+# This module has the same module dependency graph in Go 1.16 as in Go 1.17,
+# but in 1.16 requires (checksums for) additional (irrelevant) go.mod files.
+#
+# The module graph under both versions looks like:
+#
+# m ---- example.com/version v1.1.0
+# |
+# + ---- example.net/lazy v0.1.0 ---- example.com/version v1.0.1
+#
+# Go 1.17 avoids loading the go.mod file for example.com/version v1.0.1
+# (because it is lower than the verison explicitly required by m,
+# and the module that requires it — m — specifies 'go 1.17').
+#
+# That go.mod file happens not to affect the final 1.16 module graph anyway,
+# so the pruned graph is equivalent to the unpruned one.
+
+cp go.mod go.mod.orig
+go mod tidy
+cmp go.mod go.mod.orig
+
+go list -m all
+cmp stdout m_all.txt
+
+go mod edit -go=1.16
+! go list -m all
+stderr '^go list -m: example.net/lazy@v0.1.0 requires\n\texample.com/version@v1.0.1: missing go.sum entry; to add it:\n\tgo mod download example.com/version$'
+
+
+# If we combine a Go 1.16 go.sum file...
+go mod tidy -go=1.16
+
+# ...with a Go 1.17 go.mod file...
+cp go.mod.orig go.mod
+
+# ...then Go 1.17 continues to work...
+go list -m all
+cmp stdout m_all.txt
+
+# ...and now 1.16 can load the same build list!
+go mod edit -go=1.16
+go list -m all
+cmp stdout m_all.txt
+
+
+# TODO(#46141): Add a cleaner way to tidy a Go 1.17 module while preserving
+# the checksums needed to work within it with Go 1.16.
+
+
+-- go.mod --
+// Module m happens to have the exact same build list as what would be
+// selected under Go 1.16, but computes that build list without looking at
+// as many go.mod files.
+module example.com/m
+
+go 1.17
+
+replace example.net/lazy v0.1.0 => ./lazy
+
+require (
+	example.com/version v1.1.0
+	example.net/lazy v0.1.0
+)
+-- m_all.txt --
+example.com/m
+example.com/version v1.1.0
+example.net/lazy v0.1.0 => ./lazy
+-- compatible.go --
+package compatible
+
+import (
+	_ "example.com/version"
+	_ "example.net/lazy"
+)
+-- lazy/go.mod --
+// Module lazy requires example.com/version v1.0.1.
+//
+// However, since this module is lazy, its dependents
+// should not need checksums for that version of the module
+// unless they actually import packages from it.
+module example.net/lazy
+
+go 1.17
+
+require example.com/version v1.0.1
+-- lazy/lazy.go --
+package lazy
+
+import _ "example.com/version"
diff --git a/src/cmd/go/testdata/script/mod_tidy_compat_implicit.txt b/src/cmd/go/testdata/script/mod_tidy_compat_implicit.txt
new file mode 100644
index 0000000000..baaa5d63e3
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_tidy_compat_implicit.txt
@@ -0,0 +1,120 @@
+# https://golang.org/issue/46141: 'go mod tidy' for a Go 1.17 module should by
+# default preserve enough checksums for the module to be used by Go 1.16.
+#
+# We don't have a copy of Go 1.16 handy, but we can simulate it by editing the
+# 'go' version in the go.mod file to 1.16, without actually updating the
+# requirements to match.
+
+[short] skip
+
+env MODFMT='{{with .Module}}{{.Path}} {{.Version}}{{end}}'
+
+
+# For this module, Go 1.16 selects the same versions of all explicit dependencies
+# as Go 1.17 does. However, Go 1.16 selects a higher version of an *implicit*
+# dependency, imported by a test of one of the (external) imported packages.
+# As a result, Go 1.16 also needs checksums for the module sources for that higher
+# version.
+#
+# The Go 1.16 module graph looks like:
+#
+# m ---- lazy v0.1.0 ---- incompatible v1.0.0
+#         |
+#         + ------------- requireincompatible v0.1.0 ---- incompatible v2.0.0+incompatible
+#
+# The Go 1.17 module graph is the same except that the dependencies of
+# requireincompatible are pruned out (because the module that requires
+# it — lazy v0.1.0 — specifies 'go 1.17', and it is not otherwise relevant to
+# the main module).
+
+cp go.mod go.mod.orig
+go mod tidy
+cmp go.mod go.mod.orig
+
+go list -deps -test -f $MODFMT all
+stdout '^example\.com/retract/incompatible v1\.0\.0$'
+
+go mod edit -go=1.16
+! go list -deps -test -f $MODFMT all
+
+	# TODO(#46160): -count=1 instead of -count=2.
+stderr -count=2 '^go: example\.net/lazy@v0\.1\.0 requires\n\texample\.com/retract/incompatible@v1\.0\.0: missing go\.sum entry; to add it:\n\tgo mod download example\.com/retract/incompatible$'
+
+
+# If we combine a Go 1.16 go.sum file...
+go mod tidy -go=1.16
+
+# ...with a Go 1.17 go.mod file...
+cp go.mod.orig go.mod
+
+# ...then Go 1.17 no longer works. 😞
+! go list -deps -test -f $MODFMT all
+stderr -count=1 '^can''t load test package: lazy/lazy_test.go:3:8: missing go\.sum entry for module providing package example\.com/retract/incompatible \(imported by example\.net/lazy\); to add:\n\tgo get -t example.net/lazy@v0\.1\.0$'
+
+
+# However, if we take the union of the go.sum files...
+go list -mod=mod -deps -test all
+cmp go.mod go.mod.orig
+
+# ...then Go 1.17 continues to work...
+go list -deps -test -f $MODFMT all
+stdout '^example\.com/retract/incompatible v1\.0\.0$'
+
+# ...and 1.16 also works(‽), but selects a different version for the
+# external-test dependency.
+go mod edit -go=1.16
+go list -deps -test -f $MODFMT all
+stdout '^example\.com/retract/incompatible v2\.0\.0\+incompatible$'
+
+
+# TODO(#46100): In compatibility mode, should we reject the above difference as
+# incompatible, or save checksums for both possible versions of the test
+# dependency?
+
+
+-- go.mod --
+// Module m imports packages from the same versions under Go 1.17
+// as under Go 1.16, but under 1.16 its (implicit) external test dependencies
+// are higher.
+module example.com/m
+
+go 1.17
+
+replace (
+	example.net/lazy v0.1.0 => ./lazy
+	example.net/requireincompatible v0.1.0 => ./requireincompatible
+)
+
+require example.net/lazy v0.1.0
+-- implicit.go --
+package implicit
+
+import _ "example.net/lazy"
+-- lazy/go.mod --
+// Module lazy requires example.com/retract/incompatible v1.0.0.
+//
+// When viewed from the outside it also has a transitive dependency
+// on v2.0.0+incompatible, but in lazy mode that transitive dependency
+// is pruned out.
+module example.net/lazy
+
+go 1.17
+
+exclude example.com/retract/incompatible v2.0.0+incompatible
+
+require (
+	example.com/retract/incompatible v1.0.0
+	example.net/requireincompatible v0.1.0
+)
+-- lazy/lazy.go --
+package lazy
+-- lazy/lazy_test.go --
+package lazy_test
+
+import _ "example.com/retract/incompatible"
+-- requireincompatible/go.mod --
+module example.net/requireincompatible
+
+go 1.15
+
+require example.com/retract/incompatible v2.0.0+incompatible
diff --git a/src/cmd/go/testdata/script/mod_tidy_compat_incompatible.txt b/src/cmd/go/testdata/script/mod_tidy_compat_incompatible.txt
new file mode 100644
index 0000000000..0861352408
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_tidy_compat_incompatible.txt
@@ -0,0 +1,116 @@
+# https://golang.org/issue/46141: 'go mod tidy' for a Go 1.17 module should by
+# default preserve enough checksums for the module to be used by Go 1.16.
+#
+# We don't have a copy of Go 1.16 handy, but we can simulate it by editing the
+# 'go' version in the go.mod file to 1.16, without actually updating the
+# requirements to match.
+
+[short] skip
+
+env MODFMT='{{with .Module}}{{.Path}} {{.Version}}{{end}}'
+
+
+# For this module, Go 1.17 prunes out a (transitive and otherwise-irrelevant)
+# requirement on a retracted higher version of a dependency.
+# However, when Go 1.16 reads the same requirements from the go.mod file,
+# it does not prune out that requirement, and selects the retracted version.
+#
+# The Go 1.16 module graph looks like:
+#
+# m ---- lazy v0.1.0 ---- requireincompatible v0.1.0 ---- incompatible v2.0.0+incompatible
+# |        |
+# + -------+------------- incompatible v1.0.0
+#
+# The Go 1.17 module graph is the same except that the dependencies of
+# requireincompatible are pruned out (because the module that requires
+# it — lazy v0.1.0 — specifies 'go 1.17', and it is not otherwise relevant to
+# the main module).
+
+
+# TODO(#46141): 'go mod tidy' should by default diagnose the difference in
+# dependencies as an error, but it should still be possible to simply drop
+# compatibility with Go 1.16 by passing an appropriate '-compat' flag.
+
+cp go.mod go.mod.orig
+go mod tidy
+cmp go.mod go.mod.orig
+
+go mod edit -go=1.16
+! go list -f $MODFMT -deps ./...
+	# TODO(#46160): -count=1 instead of -count=2.
+stderr -count=2 '^go: example\.net/lazy@v0\.1\.0 requires\n\texample\.net/requireincompatible@v0\.1\.0 requires\n\texample\.com/retract/incompatible@v2\.0\.0\+incompatible: missing go.sum entry; to add it:\n\tgo mod download example.com/retract/incompatible$'
+
+
+# There are two ways for the module author to bring the two into alignment.
+# One is to *explicitly* 'exclude' the version that is already *implicitly*
+# pruned out under 1.17.
+go mod edit -exclude=example.com/retract/incompatible@v2.0.0+incompatible
+go list -f $MODFMT -deps ./...
+stdout '^example.com/retract/incompatible v1\.0\.0$'
+! stdout 'v2\.0\.0'
+
+
+# The other is to explicitly upgrade the version required under Go 1.17
+# to match the version selected by Go 1.16.
+cp go.mod.orig go.mod
+
+go get -d example.com/retract/incompatible@v2.0.0+incompatible
+	# Note that we are not running 'go mod tidy' here: we need to preserve
+	# the checksum for v1.0.0 because it is also still in the module graph
+	# as seen by Go 1.16.
+
+go mod edit -go=1.16
+go list -f $MODFMT -deps ./...
+stdout '^example.com/retract/incompatible v2\.0\.0\+incompatible$'
+! stdout 'v1\.0\.0'
+
+
+-- go.mod --
+// Module m indirectly imports a package from
+// example.com/retract/incompatible. Its selected version of
+// that module is lower under Go 1.17 semantics than under Go 1.16.
+module example.com/m
+
+go 1.17
+
+replace (
+	example.net/lazy v0.1.0 => ./lazy
+	example.net/requireincompatible v0.1.0 => ./requireincompatible
+)
+
+require (
+	example.com/retract/incompatible v1.0.0 // indirect
+	example.net/lazy v0.1.0
+)
+-- incompatible.go --
+package incompatible
+
+import _ "example.net/lazy"
+
+-- lazy/go.mod --
+// Module lazy requires example.com/retract/incompatible v1.0.0.
+//
+// When viewed from the outside it also has a transitive dependency
+// on v2.0.0+incompatible, but in lazy mode that transitive dependency
+// is pruned out.
+module example.net/lazy
+
+go 1.17
+
+exclude example.com/retract/incompatible v2.0.0+incompatible
+
+require (
+	example.com/retract/incompatible v1.0.0
+	example.net/requireincompatible v0.1.0
+)
+-- lazy/lazy.go --
+package lazy
+
+import _ "example.com/retract/incompatible"
+
+-- requireincompatible/go.mod --
+module example.net/requireincompatible
+
+go 1.15
+
+require example.com/retract/incompatible v2.0.0+incompatible
diff --git a/src/cmd/go/testdata/script/mod_tidy_compat_irrelevant.txt b/src/cmd/go/testdata/script/mod_tidy_compat_irrelevant.txt
new file mode 100644
index 0000000000..d4371e0f7d
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_tidy_compat_irrelevant.txt
@@ -0,0 +1,105 @@
+# https://golang.org/issue/46141: 'go mod tidy' for a Go 1.17 module should by
+# default preserve enough checksums for the module to be used by Go 1.16.
+#
+# We don't have a copy of Go 1.16 handy, but we can simulate it by editing the
+# 'go' version in the go.mod file to 1.16, without actually updating the
+# requirements to match.
+
+[short] skip
+
+env MODFMT='{{with .Module}}{{.Path}} {{.Version}}{{end}}'
+
+
+# This module selects the same versions in Go 1.16 and 1.17 for all modules
+# that provide packages (or test dependencies of packages) imported by the
+# main module. However, in Go 1.16 it selects a higher version of a
+# transitive module dependency that is not otherwise relevant to the main module.
+# As a result, Go 1.16 needs an additional checksum for the go.mod file of
+# that irrelevant dependency.
+#
+# The Go 1.16 module graph looks like:
+#
+# m ---- lazy v0.1.0 ---- incompatible v1.0.0
+#         |
+#         + ------------- requireincompatible v0.1.0 ---- incompatible v2.0.0+incompatible
+
+cp go.mod go.mod.orig
+go mod tidy
+cmp go.mod go.mod.orig
+
+go list -m all
+stdout '^example\.com/retract/incompatible v1\.0\.0$'
+
+go mod edit -go=1.16
+! go list -deps -test -f $MODFMT all
+	# TODO(#46160): -count=1 instead of -count=2.
+stderr -count=2 '^go: example.net/lazy@v0.1.0 requires\n\texample.com/retract/incompatible@v1.0.0: missing go.sum entry; to add it:\n\tgo mod download example.com/retract/incompatible$'
+
+
+# If we combine a Go 1.16 go.sum file...
+go mod tidy -go=1.16
+
+# ...with a Go 1.17 go.mod file...
+cp go.mod.orig go.mod
+
+# ...then Go 1.17 continues to work...
+go list -deps -test -f $MODFMT all
+cp stdout out-117.txt
+
+# ...and 1.16 also works, and selects the same versions for all packages
+# even remotely relevant to the main module.
+go mod edit -go=1.16
+go list -deps -test -f $MODFMT all
+cmp stdout out-117.txt
+
+
+# TODO(#46160): Add a cleaner way to tidy a Go 1.17 module while preserving
+# the checksums needed to work within it with Go 1.16.
+
+
+-- go.mod --
+// Module m imports packages from the same versions under Go 1.17
+// as under Go 1.16, but under 1.16 its (implicit) external test dependencies
+// are higher.
+module example.com/m
+
+go 1.17
+
+replace (
+	example.net/lazy v0.1.0 => ./lazy
+	example.net/requireincompatible v0.1.0 => ./requireincompatible
+)
+
+require example.net/lazy v0.1.0
+-- m.go --
+package m
+
+import _ "example.net/lazy"
+-- lazy/go.mod --
+// Module lazy requires example.com/retract/incompatible v1.0.0.
+//
+// When viewed from the outside it also has a transitive dependency
+// on v2.0.0+incompatible, but in lazy mode that transitive dependency
+// is pruned out.
+module example.net/lazy
+
+go 1.17
+
+exclude example.com/retract/incompatible v2.0.0+incompatible
+
+require (
+	example.com/retract/incompatible v1.0.0
+	example.net/requireincompatible v0.1.0
+)
+-- lazy/lazy.go --
+package lazy
+-- lazy/unimported/unimported.go --
+package unimported
+
+import _ "example.com/retract/incompatible"
+-- requireincompatible/go.mod --
+module example.net/requireincompatible
+
+go 1.15
+
+require example.com/retract/incompatible v2.0.0+incompatible
-- 
GitLab


From 32b73ae18026e8a9dc4c5aa49999b1ea445bc68c Mon Sep 17 00:00:00 2001
From: Constantin Konstantinidis <constantinkonstantinidis@gmail.com>
Date: Sun, 16 May 2021 11:03:34 +0200
Subject: [PATCH 2110/2400] cmd/go: align checks of module path during
 initialization.

Fixes #45025.

Change-Id: I70c2b745f764484e4b3a2824adc470f168fb2c50
Reviewed-on: https://go-review.googlesource.com/c/go/+/320310
Trust: Jay Conrod <jayconrod@google.com>
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/internal/modload/init.go           | 68 ++++---------------
 src/cmd/go/testdata/script/mod_init_path.txt  |  2 +-
 .../go/testdata/script/mod_invalid_path.txt   |  9 +--
 3 files changed, 19 insertions(+), 60 deletions(-)

diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index e358230e74..df9f48e8ea 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -432,7 +432,10 @@ func loadModFile(ctx context.Context) (rs *Requirements, needCommit bool) {
 	initTarget(f.Module.Mod)
 	index = indexModFile(data, f, fixed)
 
-	if err := checkModulePathLax(f.Module.Mod.Path); err != nil {
+	if err := module.CheckImportPath(f.Module.Mod.Path); err != nil {
+		if pathErr, ok := err.(*module.InvalidPathError); ok {
+			pathErr.Kind = "module"
+		}
 		base.Fatalf("go: %v", err)
 	}
 
@@ -492,7 +495,15 @@ func CreateModFile(ctx context.Context, modPath string) {
 		if err != nil {
 			base.Fatalf("go: %v", err)
 		}
-	} else if err := checkModulePathLax(modPath); err != nil {
+	} else if err := module.CheckImportPath(modPath); err != nil {
+		if pathErr, ok := err.(*module.InvalidPathError); ok {
+			pathErr.Kind = "module"
+			// Same as build.IsLocalPath()
+			if pathErr.Path == "." || pathErr.Path == ".." ||
+				strings.HasPrefix(pathErr.Path, "./") || strings.HasPrefix(pathErr.Path, "../") {
+				pathErr.Err = errors.New("is a local import path")
+			}
+		}
 		base.Fatalf("go: %v", err)
 	}
 
@@ -536,49 +547,6 @@ func CreateModFile(ctx context.Context, modPath string) {
 	}
 }
 
-// checkModulePathLax checks that the path meets some minimum requirements
-// to avoid confusing users or the module cache. The requirements are weaker
-// than those of module.CheckPath to allow room for weakening module path
-// requirements in the future, but strong enough to help users avoid significant
-// problems.
-func checkModulePathLax(p string) error {
-	// TODO(matloob): Replace calls of this function in this CL with calls
-	// to module.CheckImportPath once it's been laxened, if it becomes laxened.
-	// See golang.org/issue/29101 for a discussion about whether to make CheckImportPath
-	// more lax or more strict.
-
-	errorf := func(format string, args ...interface{}) error {
-		return fmt.Errorf("invalid module path %q: %s", p, fmt.Sprintf(format, args...))
-	}
-
-	// Disallow shell characters " ' * < > ? ` | to avoid triggering bugs
-	// with file systems and subcommands. Disallow file path separators : and \
-	// because path separators other than / will confuse the module cache.
-	// See fileNameOK in golang.org/x/mod/module/module.go.
-	shellChars := "`" + `"'*<>?|`
-	fsChars := `\:`
-	if i := strings.IndexAny(p, shellChars); i >= 0 {
-		return errorf("contains disallowed shell character %q", p[i])
-	}
-	if i := strings.IndexAny(p, fsChars); i >= 0 {
-		return errorf("contains disallowed path separator character %q", p[i])
-	}
-
-	// Ensure path.IsAbs and build.IsLocalImport are false, and that the path is
-	// invariant under path.Clean, also to avoid confusing the module cache.
-	if path.IsAbs(p) {
-		return errorf("is an absolute path")
-	}
-	if build.IsLocalImport(p) {
-		return errorf("is a local import path")
-	}
-	if path.Clean(p) != p {
-		return errorf("is not clean")
-	}
-
-	return nil
-}
-
 // fixVersion returns a modfile.VersionFixer implemented using the Query function.
 //
 // It resolves commit hashes and branch names to versions,
@@ -918,14 +886,8 @@ func findModulePath(dir string) (string, error) {
 		}
 		if rel := search.InDir(dir, filepath.Join(gpdir, "src")); rel != "" && rel != "." {
 			path := filepath.ToSlash(rel)
-			// TODO(matloob): replace this with module.CheckImportPath
-			// once it's been laxened.
-			// Only checkModulePathLax here. There are some unpublishable
-			// module names that are compatible with checkModulePathLax
-			// but they already work in GOPATH so don't break users
-			// trying to do a build with modules. gorelease will alert users
-			// publishing their modules to fix their paths.
-			if err := checkModulePathLax(path); err != nil {
+			// gorelease will alert users publishing their modules to fix their paths.
+			if err := module.CheckImportPath(path); err != nil {
 				badPathErr = err
 				break
 			}
diff --git a/src/cmd/go/testdata/script/mod_init_path.txt b/src/cmd/go/testdata/script/mod_init_path.txt
index ccdfc92317..e5fd4ddbcb 100644
--- a/src/cmd/go/testdata/script/mod_init_path.txt
+++ b/src/cmd/go/testdata/script/mod_init_path.txt
@@ -1,7 +1,7 @@
 env GO111MODULE=on
 
 ! go mod init .
-stderr '^go: invalid module path "\.": is a local import path$'
+stderr '^go: malformed module path ".": is a local import path$'
 
 cd x
 go mod init example.com/x
diff --git a/src/cmd/go/testdata/script/mod_invalid_path.txt b/src/cmd/go/testdata/script/mod_invalid_path.txt
index c8c075daae..333a3ffa35 100644
--- a/src/cmd/go/testdata/script/mod_invalid_path.txt
+++ b/src/cmd/go/testdata/script/mod_invalid_path.txt
@@ -8,11 +8,8 @@ stderr '^go: no module declaration in go.mod. To specify the module path:\n\tgo
 # Test that go mod init in GOPATH doesn't add a module declaration
 # with a path that can't possibly be a module path, because
 # it isn't even a valid import path.
-# The single quote and backtick are the only characters  we don't allow
-# in checkModulePathLax, but is allowed in a Windows file name.
-# TODO(matloob): choose a different character once
-# module.CheckImportPath is laxened and replaces
-# checkModulePathLax.
+# The single quote and backtick are the only characters which are not allowed
+# but are a valid Windows file name.
 cd $WORK/'gopath/src/m''d'
 ! go mod init
 stderr 'cannot determine module path'
@@ -21,7 +18,7 @@ stderr 'cannot determine module path'
 # possibly be a module path, because it isn't even a valid import path
 cd $WORK/gopath/src/badname
 ! go list .
-stderr 'invalid module path'
+stderr 'malformed module path'
 
 # Test that an import path containing an element with a leading dot is valid,
 # but such a module path is not.
-- 
GitLab


From 08a8fa9c471603c7ec44895392c6bfa31a8ddcb6 Mon Sep 17 00:00:00 2001
From: Richard Musiol <mail@richard-musiol.de>
Date: Sun, 23 May 2021 23:06:43 +0200
Subject: [PATCH 2111/2400] misc/wasm: ensure correct stack pointer in catch
 clauses

The stack pointer may have changed after a call from JavaScript into Go
code because of stack growth. The normal case already updated the
sp variable accordingly, but the catch case did not yet.

Fixes #45433

Change-Id: I3e0a33381929626f6b21902948935eb5ffb26c96
Reviewed-on: https://go-review.googlesource.com/c/go/+/321936
Trust: Richard Musiol <neelance@gmail.com>
Run-TryBot: Richard Musiol <neelance@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 misc/wasm/wasm_exec.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/misc/wasm/wasm_exec.js b/misc/wasm/wasm_exec.js
index 3e41e628ef..231185a123 100644
--- a/misc/wasm/wasm_exec.js
+++ b/misc/wasm/wasm_exec.js
@@ -401,6 +401,7 @@
 							storeValue(sp + 56, result);
 							this.mem.setUint8(sp + 64, 1);
 						} catch (err) {
+							sp = this._inst.exports.getsp() >>> 0; // see comment above
 							storeValue(sp + 56, err);
 							this.mem.setUint8(sp + 64, 0);
 						}
@@ -417,6 +418,7 @@
 							storeValue(sp + 40, result);
 							this.mem.setUint8(sp + 48, 1);
 						} catch (err) {
+							sp = this._inst.exports.getsp() >>> 0; // see comment above
 							storeValue(sp + 40, err);
 							this.mem.setUint8(sp + 48, 0);
 						}
@@ -433,6 +435,7 @@
 							storeValue(sp + 40, result);
 							this.mem.setUint8(sp + 48, 1);
 						} catch (err) {
+							sp = this._inst.exports.getsp() >>> 0; // see comment above
 							storeValue(sp + 40, err);
 							this.mem.setUint8(sp + 48, 0);
 						}
-- 
GitLab


From c89f1224a544cde464fcb86e78ebb0cc97eedba2 Mon Sep 17 00:00:00 2001
From: Roland Shoemaker <roland@golang.org>
Date: Mon, 17 May 2021 10:06:51 -0700
Subject: [PATCH 2112/2400] net: verify results from Lookup* are valid domain
 names

For the methods LookupCNAME, LookupSRV, LookupMX, LookupNS, and
LookupAddr check that the returned domain names are in fact valid DNS
names using the existing isDomainName function.

Thanks to Philipp Jeitner and Haya Shulman from Fraunhofer SIT for
reporting this issue.

Fixes #46241
Fixes CVE-2021-33195

Change-Id: Icf231acd93178a3b6aec3f178cff7e693f74ef8c
Reviewed-on: https://go-review.googlesource.com/c/go/+/320949
Trust: Roland Shoemaker <roland@golang.org>
Trust: Katie Hockman <katie@golang.org>
Run-TryBot: Roland Shoemaker <roland@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
---
 src/net/dnsclient_unix_test.go | 121 +++++++++++++++++++++++++++++++++
 src/net/lookup.go              |  98 +++++++++++++++++++++++---
 2 files changed, 211 insertions(+), 8 deletions(-)

diff --git a/src/net/dnsclient_unix_test.go b/src/net/dnsclient_unix_test.go
index ec690a1c0c..69a9b972f0 100644
--- a/src/net/dnsclient_unix_test.go
+++ b/src/net/dnsclient_unix_test.go
@@ -1799,3 +1799,124 @@ func TestPTRandNonPTR(t *testing.T) {
 		t.Errorf("names = %q; want %q", names, want)
 	}
 }
+
+func TestCVE202133195(t *testing.T) {
+	fake := fakeDNSServer{
+		rh: func(n, _ string, q dnsmessage.Message, _ time.Time) (dnsmessage.Message, error) {
+			r := dnsmessage.Message{
+				Header: dnsmessage.Header{
+					ID:                 q.Header.ID,
+					Response:           true,
+					RCode:              dnsmessage.RCodeSuccess,
+					RecursionAvailable: true,
+				},
+				Questions: q.Questions,
+			}
+			switch q.Questions[0].Type {
+			case dnsmessage.TypeCNAME:
+				r.Answers = []dnsmessage.Resource{}
+			case dnsmessage.TypeA: // CNAME lookup uses a A/AAAA as a proxy
+				r.Answers = append(r.Answers,
+					dnsmessage.Resource{
+						Header: dnsmessage.ResourceHeader{
+							Name:   dnsmessage.MustNewName("<html>.golang.org."),
+							Type:   dnsmessage.TypeA,
+							Class:  dnsmessage.ClassINET,
+							Length: 4,
+						},
+						Body: &dnsmessage.AResource{
+							A: TestAddr,
+						},
+					},
+				)
+			case dnsmessage.TypeSRV:
+				n := q.Questions[0].Name
+				if n.String() == "_hdr._tcp.golang.org." {
+					n = dnsmessage.MustNewName("<html>.golang.org.")
+				}
+				r.Answers = append(r.Answers,
+					dnsmessage.Resource{
+						Header: dnsmessage.ResourceHeader{
+							Name:   n,
+							Type:   dnsmessage.TypeSRV,
+							Class:  dnsmessage.ClassINET,
+							Length: 4,
+						},
+						Body: &dnsmessage.SRVResource{
+							Target: dnsmessage.MustNewName("<html>.golang.org."),
+						},
+					},
+				)
+			case dnsmessage.TypeMX:
+				r.Answers = append(r.Answers,
+					dnsmessage.Resource{
+						Header: dnsmessage.ResourceHeader{
+							Name:   dnsmessage.MustNewName("<html>.golang.org."),
+							Type:   dnsmessage.TypeMX,
+							Class:  dnsmessage.ClassINET,
+							Length: 4,
+						},
+						Body: &dnsmessage.MXResource{
+							MX: dnsmessage.MustNewName("<html>.golang.org."),
+						},
+					},
+				)
+			case dnsmessage.TypeNS:
+				r.Answers = append(r.Answers,
+					dnsmessage.Resource{
+						Header: dnsmessage.ResourceHeader{
+							Name:   dnsmessage.MustNewName("<html>.golang.org."),
+							Type:   dnsmessage.TypeNS,
+							Class:  dnsmessage.ClassINET,
+							Length: 4,
+						},
+						Body: &dnsmessage.NSResource{
+							NS: dnsmessage.MustNewName("<html>.golang.org."),
+						},
+					},
+				)
+			case dnsmessage.TypePTR:
+				r.Answers = append(r.Answers,
+					dnsmessage.Resource{
+						Header: dnsmessage.ResourceHeader{
+							Name:   dnsmessage.MustNewName("<html>.golang.org."),
+							Type:   dnsmessage.TypePTR,
+							Class:  dnsmessage.ClassINET,
+							Length: 4,
+						},
+						Body: &dnsmessage.PTRResource{
+							PTR: dnsmessage.MustNewName("<html>.golang.org."),
+						},
+					},
+				)
+			}
+			return r, nil
+		},
+	}
+	r := Resolver{PreferGo: true, Dial: fake.DialContext}
+
+	_, err := r.LookupCNAME(context.Background(), "golang.org")
+	if expected := "lookup golang.org: CNAME target is invalid"; err.Error() != expected {
+		t.Errorf("LookupCNAME returned unexpected error, got %q, want %q", err.Error(), expected)
+	}
+	_, _, err = r.LookupSRV(context.Background(), "target", "tcp", "golang.org")
+	if expected := "lookup golang.org: SRV target is invalid"; err.Error() != expected {
+		t.Errorf("LookupSRV returned unexpected error, got %q, want %q", err.Error(), expected)
+	}
+	_, _, err = r.LookupSRV(context.Background(), "hdr", "tcp", "golang.org")
+	if expected := "lookup golang.org: SRV header name is invalid"; err.Error() != expected {
+		t.Errorf("LookupSRV returned unexpected error, got %q, want %q", err.Error(), expected)
+	}
+	_, err = r.LookupMX(context.Background(), "golang.org")
+	if expected := "lookup golang.org: MX target is invalid"; err.Error() != expected {
+		t.Errorf("LookupMX returned unexpected error, got %q, want %q", err.Error(), expected)
+	}
+	_, err = r.LookupNS(context.Background(), "golang.org")
+	if expected := "lookup golang.org: NS target is invalid"; err.Error() != expected {
+		t.Errorf("LookupNS returned unexpected error, got %q, want %q", err.Error(), expected)
+	}
+	_, err = r.LookupAddr(context.Background(), "1.2.3.4")
+	if expected := "lookup 1.2.3.4: PTR target is invalid"; err.Error() != expected {
+		t.Errorf("LookupAddr returned unexpected error, got %q, want %q", err.Error(), expected)
+	}
+}
diff --git a/src/net/lookup.go b/src/net/lookup.go
index 03599503bd..39d33796d5 100644
--- a/src/net/lookup.go
+++ b/src/net/lookup.go
@@ -396,6 +396,9 @@ func (r *Resolver) LookupPort(ctx context.Context, network, service string) (por
 // contain DNS "CNAME" records, as long as host resolves to
 // address records.
 //
+// The returned canonical name is validated to be a properly
+// formatted presentation-format domain name.
+//
 // LookupCNAME uses context.Background internally; to specify the context, use
 // Resolver.LookupCNAME.
 func LookupCNAME(host string) (cname string, err error) {
@@ -412,8 +415,18 @@ func LookupCNAME(host string) (cname string, err error) {
 // LookupCNAME does not return an error if host does not
 // contain DNS "CNAME" records, as long as host resolves to
 // address records.
-func (r *Resolver) LookupCNAME(ctx context.Context, host string) (cname string, err error) {
-	return r.lookupCNAME(ctx, host)
+//
+// The returned canonical name is validated to be a properly
+// formatted presentation-format domain name.
+func (r *Resolver) LookupCNAME(ctx context.Context, host string) (string, error) {
+	cname, err := r.lookupCNAME(ctx, host)
+	if err != nil {
+		return "", err
+	}
+	if !isDomainName(cname) {
+		return "", &DNSError{Err: "CNAME target is invalid", Name: host}
+	}
+	return cname, nil
 }
 
 // LookupSRV tries to resolve an SRV query of the given service,
@@ -425,6 +438,9 @@ func (r *Resolver) LookupCNAME(ctx context.Context, host string) (cname string,
 // That is, it looks up _service._proto.name. To accommodate services
 // publishing SRV records under non-standard names, if both service
 // and proto are empty strings, LookupSRV looks up name directly.
+//
+// The returned service names are validated to be properly
+// formatted presentation-format domain names.
 func LookupSRV(service, proto, name string) (cname string, addrs []*SRV, err error) {
 	return DefaultResolver.lookupSRV(context.Background(), service, proto, name)
 }
@@ -438,12 +454,33 @@ func LookupSRV(service, proto, name string) (cname string, addrs []*SRV, err err
 // That is, it looks up _service._proto.name. To accommodate services
 // publishing SRV records under non-standard names, if both service
 // and proto are empty strings, LookupSRV looks up name directly.
-func (r *Resolver) LookupSRV(ctx context.Context, service, proto, name string) (cname string, addrs []*SRV, err error) {
-	return r.lookupSRV(ctx, service, proto, name)
+//
+// The returned service names are validated to be properly
+// formatted presentation-format domain names.
+func (r *Resolver) LookupSRV(ctx context.Context, service, proto, name string) (string, []*SRV, error) {
+	cname, addrs, err := r.lookupSRV(ctx, service, proto, name)
+	if err != nil {
+		return "", nil, err
+	}
+	if cname != "" && !isDomainName(cname) {
+		return "", nil, &DNSError{Err: "SRV header name is invalid", Name: name}
+	}
+	for _, addr := range addrs {
+		if addr == nil {
+			continue
+		}
+		if !isDomainName(addr.Target) {
+			return "", nil, &DNSError{Err: "SRV target is invalid", Name: name}
+		}
+	}
+	return cname, addrs, nil
 }
 
 // LookupMX returns the DNS MX records for the given domain name sorted by preference.
 //
+// The returned mail server names are validated to be properly
+// formatted presentation-format domain names.
+//
 // LookupMX uses context.Background internally; to specify the context, use
 // Resolver.LookupMX.
 func LookupMX(name string) ([]*MX, error) {
@@ -451,12 +488,30 @@ func LookupMX(name string) ([]*MX, error) {
 }
 
 // LookupMX returns the DNS MX records for the given domain name sorted by preference.
+//
+// The returned mail server names are validated to be properly
+// formatted presentation-format domain names.
 func (r *Resolver) LookupMX(ctx context.Context, name string) ([]*MX, error) {
-	return r.lookupMX(ctx, name)
+	records, err := r.lookupMX(ctx, name)
+	if err != nil {
+		return nil, err
+	}
+	for _, mx := range records {
+		if mx == nil {
+			continue
+		}
+		if !isDomainName(mx.Host) {
+			return nil, &DNSError{Err: "MX target is invalid", Name: name}
+		}
+	}
+	return records, nil
 }
 
 // LookupNS returns the DNS NS records for the given domain name.
 //
+// The returned name server names are validated to be properly
+// formatted presentation-format domain names.
+//
 // LookupNS uses context.Background internally; to specify the context, use
 // Resolver.LookupNS.
 func LookupNS(name string) ([]*NS, error) {
@@ -464,8 +519,23 @@ func LookupNS(name string) ([]*NS, error) {
 }
 
 // LookupNS returns the DNS NS records for the given domain name.
+//
+// The returned name server names are validated to be properly
+// formatted presentation-format domain names.
 func (r *Resolver) LookupNS(ctx context.Context, name string) ([]*NS, error) {
-	return r.lookupNS(ctx, name)
+	records, err := r.lookupNS(ctx, name)
+	if err != nil {
+		return nil, err
+	}
+	for _, ns := range records {
+		if ns == nil {
+			continue
+		}
+		if !isDomainName(ns.Host) {
+			return nil, &DNSError{Err: "NS target is invalid", Name: name}
+		}
+	}
+	return records, nil
 }
 
 // LookupTXT returns the DNS TXT records for the given domain name.
@@ -495,6 +565,18 @@ func LookupAddr(addr string) (names []string, err error) {
 
 // LookupAddr performs a reverse lookup for the given address, returning a list
 // of names mapping to that address.
-func (r *Resolver) LookupAddr(ctx context.Context, addr string) (names []string, err error) {
-	return r.lookupAddr(ctx, addr)
+//
+// The returned names are validated to be properly
+// formatted presentation-format domain names.
+func (r *Resolver) LookupAddr(ctx context.Context, addr string) ([]string, error) {
+	names, err := r.lookupAddr(ctx, addr)
+	if err != nil {
+		return nil, err
+	}
+	for _, name := range names {
+		if !isDomainName(name) {
+			return nil, &DNSError{Err: "PTR target is invalid", Name: addr}
+		}
+	}
+	return names, nil
 }
-- 
GitLab


From 8b462d75670dcd8b6a08cf9af225eb8e7628d412 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 14 May 2021 16:53:06 -0400
Subject: [PATCH 2113/2400] cmd/go: add a -compat flag to 'go mod tidy'

Fixes #46141

Change-Id: I9d4032e75252ade9eaa937389ea97ef3fb287499
Reviewed-on: https://go-review.googlesource.com/c/go/+/321071
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 doc/go1.17.html                               |   5 +
 src/cmd/go.sum                                |  23 ++
 src/cmd/go/alldocs.go                         |  10 +-
 src/cmd/go/internal/modcmd/tidy.go            |  17 +-
 src/cmd/go/internal/modload/init.go           |  24 +-
 src/cmd/go/internal/modload/load.go           | 254 +++++++++++++++++-
 .../go/testdata/script/mod_tidy_compat.txt    |  21 +-
 .../testdata/script/mod_tidy_compat_added.txt | 105 ++++++++
 .../script/mod_tidy_compat_ambiguous.txt      |  98 +++++++
 .../script/mod_tidy_compat_deleted.txt        | 128 +++++++++
 .../script/mod_tidy_compat_implicit.txt       |  23 +-
 .../script/mod_tidy_compat_incompatible.txt   |  37 ++-
 .../script/mod_tidy_compat_irrelevant.txt     |  30 +--
 src/cmd/go/testdata/script/mod_tidy_oldgo.txt |  21 ++
 src/go.sum                                    |   7 +
 15 files changed, 749 insertions(+), 54 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/mod_tidy_compat_added.txt
 create mode 100644 src/cmd/go/testdata/script/mod_tidy_compat_ambiguous.txt
 create mode 100644 src/cmd/go/testdata/script/mod_tidy_compat_deleted.txt
 create mode 100644 src/cmd/go/testdata/script/mod_tidy_oldgo.txt

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 46ee1da6fa..6dd1d0d1db 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -106,6 +106,11 @@ Do not send CLs removing the interior tags from such phrases.
   go mod tidy -go=1.17
 </pre>
 
+<p><!-- golang.org/issue/46141 -->
+  TODO: Describe the <code>-compat</code> flag
+  for <code>go</code> <code>mod</code> <code>tidy</code>.
+</p>
+
 <h4 id="module-deprecation-comments">Module deprecation comments</h4>
 
 <p><!-- golang.org/issue/40357 -->
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 9af4978d66..eeb625fcf8 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -5,18 +5,41 @@ github.com/google/pprof v0.0.0-20210506205249-923b5ab0fc1a h1:jmAp/2PZAScNd62lTD
 github.com/google/pprof v0.0.0-20210506205249-923b5ab0fc1a/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
 github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639 h1:mV02weKRL81bEnm8A0HT1/CAelMQDBuQIfLw8n+d6xI=
 github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
+github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
 golang.org/x/arch v0.0.0-20210502124803-cbf565b21d1e h1:pv3V0NlNSh5Q6AX/StwGLBjcLS7UN4m4Gq+V+uSecqM=
 golang.org/x/arch v0.0.0-20210502124803-cbf565b21d1e/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e h1:8foAy0aoO5GkqCvAEJ4VC4P3zksTg4X4aJCDpZzmgQI=
 golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
+golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.3-0.20210512182355-6088ed88cecd h1:CuRnpyMrCCBulv0d/y0CswR4K0vGydgE3DZ2wYPIOo8=
 golang.org/x/mod v0.4.3-0.20210512182355-6088ed88cecd/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210511113859-b0526f3d8744 h1:yhBbb4IRs2HS9PPlAg6DMC6mUOKexJBNsLf4Z+6En1Q=
 golang.org/x/sys v0.0.0-20210511113859-b0526f3d8744/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210503060354-a79de5458b56 h1:b8jxX3zqjpqb2LklXPzKSGJhzyxCOZSz8ncv8Nv+y7w=
 golang.org/x/term v0.0.0-20210503060354-a79de5458b56/go.mod h1:tfny5GFUkzUvx4ps4ajbZsCe5lw1metzhBm9T3x7oIY=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.2-0.20210519160823-49064d2332f9 h1:2XlR/j4I4xz5GQZI7zBjqTfezYyRIE2jD5IMousB2rg=
 golang.org/x/tools v0.1.2-0.20210519160823-49064d2332f9/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=
diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index fcc7f36335..bad2b7f16e 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -1221,7 +1221,7 @@
 //
 // Usage:
 //
-// 	go mod tidy [-e] [-v] [-go=version]
+// 	go mod tidy [-e] [-v] [-go=version] [-compat=version]
 //
 // Tidy makes sure go.mod matches the source code in the module.
 // It adds any missing modules necessary to build the current module's
@@ -1241,6 +1241,14 @@
 // (Go versions 1.17 and higher retain more requirements in order to
 // support lazy module loading.)
 //
+// The -compat flag preserves any additional checksums needed for the
+// 'go' command from the indicated major Go release to successfully load
+// the module graph, and causes tidy to error out if that version of the
+// 'go' command would load any imported package from a different module
+// version. By default, tidy acts as if the -compat flag were set to the
+// version prior to the one indicated by the 'go' directive in the go.mod
+// file.
+//
 // See https://golang.org/ref/mod#go-mod-tidy for more about 'go mod tidy'.
 //
 //
diff --git a/src/cmd/go/internal/modcmd/tidy.go b/src/cmd/go/internal/modcmd/tidy.go
index 9af624028a..fe25507e94 100644
--- a/src/cmd/go/internal/modcmd/tidy.go
+++ b/src/cmd/go/internal/modcmd/tidy.go
@@ -19,7 +19,7 @@ import (
 )
 
 var cmdTidy = &base.Command{
-	UsageLine: "go mod tidy [-e] [-v] [-go=version]",
+	UsageLine: "go mod tidy [-e] [-v] [-go=version] [-compat=version]",
 	Short:     "add missing and remove unused modules",
 	Long: `
 Tidy makes sure go.mod matches the source code in the module.
@@ -40,20 +40,30 @@ are retained as explicit requirements in the go.mod file.
 (Go versions 1.17 and higher retain more requirements in order to
 support lazy module loading.)
 
+The -compat flag preserves any additional checksums needed for the
+'go' command from the indicated major Go release to successfully load
+the module graph, and causes tidy to error out if that version of the
+'go' command would load any imported package from a different module
+version. By default, tidy acts as if the -compat flag were set to the
+version prior to the one indicated by the 'go' directive in the go.mod
+file.
+
 See https://golang.org/ref/mod#go-mod-tidy for more about 'go mod tidy'.
 	`,
 	Run: runTidy,
 }
 
 var (
-	tidyE  bool          // if true, report errors but proceed anyway.
-	tidyGo goVersionFlag // go version to write to the tidied go.mod file (toggles lazy loading)
+	tidyE      bool          // if true, report errors but proceed anyway.
+	tidyGo     goVersionFlag // go version to write to the tidied go.mod file (toggles lazy loading)
+	tidyCompat goVersionFlag // go version for which the tidied go.mod and go.sum files should be “compatible”
 )
 
 func init() {
 	cmdTidy.Flag.BoolVar(&cfg.BuildV, "v", false, "")
 	cmdTidy.Flag.BoolVar(&tidyE, "e", false, "")
 	cmdTidy.Flag.Var(&tidyGo, "go", "")
+	cmdTidy.Flag.Var(&tidyCompat, "compat", "")
 	base.AddModCommonFlags(&cmdTidy.Flag)
 }
 
@@ -105,6 +115,7 @@ func runTidy(ctx context.Context, cmd *base.Command, args []string) {
 		GoVersion:                tidyGo.String(),
 		Tags:                     imports.AnyTags(),
 		Tidy:                     true,
+		TidyCompatibleVersion:    tidyCompat.String(),
 		VendorModulesInGOROOTSrc: true,
 		ResolveMissingImports:    true,
 		LoadTests:                true,
diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index df9f48e8ea..86c0db3fe4 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -767,11 +767,33 @@ func LatestGoVersion() string {
 	tags := build.Default.ReleaseTags
 	version := tags[len(tags)-1]
 	if !strings.HasPrefix(version, "go") || !modfile.GoVersionRE.MatchString(version[2:]) {
-		base.Fatalf("go: unrecognized default version %q", version)
+		base.Fatalf("go: internal error: unrecognized default version %q", version)
 	}
 	return version[2:]
 }
 
+// priorGoVersion returns the Go major release immediately preceding v,
+// or v itself if v is the first Go major release (1.0) or not a supported
+// Go version.
+func priorGoVersion(v string) string {
+	vTag := "go" + v
+	tags := build.Default.ReleaseTags
+	for i, tag := range tags {
+		if tag == vTag {
+			if i == 0 {
+				return v
+			}
+
+			version := tags[i-1]
+			if !strings.HasPrefix(version, "go") || !modfile.GoVersionRE.MatchString(version[2:]) {
+				base.Fatalf("go: internal error: unrecognized version %q", version)
+			}
+			return version[2:]
+		}
+	}
+	return v
+}
+
 var altConfigs = []string{
 	"Gopkg.lock",
 
diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index 37b0032d43..a9d1777125 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -152,6 +152,13 @@ type PackageOpts struct {
 	// packages.
 	Tidy bool
 
+	// TidyCompatibleVersion is the oldest Go version that must be able to
+	// reproducibly reload the requested packages.
+	//
+	// If empty, the compatible version is the Go version immediately prior to the
+	// 'go' version listed in the go.mod file.
+	TidyCompatibleVersion string
+
 	// VendorModulesInGOROOTSrc indicates that if we are within a module in
 	// GOROOT/src, packages in the module's vendor directory should be resolved as
 	// actual module dependencies (instead of standard-library packages).
@@ -371,7 +378,26 @@ func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (ma
 			}
 		}
 
-		modfetch.TrimGoSum(keepSums(ctx, ld, ld.requirements, loadedZipSumsOnly))
+		keep := keepSums(ctx, ld, ld.requirements, loadedZipSumsOnly)
+		if compatDepth := modDepthFromGoVersion(ld.TidyCompatibleVersion); compatDepth != ld.requirements.depth {
+			compatRS := newRequirements(compatDepth, ld.requirements.rootModules, ld.requirements.direct)
+			ld.checkTidyCompatibility(ctx, compatRS)
+
+			for m := range keepSums(ctx, ld, compatRS, loadedZipSumsOnly) {
+				keep[m] = true
+			}
+		}
+
+		if allowWriteGoMod {
+			modfetch.TrimGoSum(keep)
+
+			// commitRequirements below will also call WriteGoSum, but the "keep" map
+			// we have here could be strictly larger: commitRequirements only commits
+			// loaded.requirements, but here we may have also loaded (and want to
+			// preserve checksums for) additional entities from compatRS, which are
+			// only needed for compatibility with ld.TidyCompatibleVersion.
+			modfetch.WriteGoSum(keep)
+		}
 	}
 
 	// Success! Update go.mod and go.sum (if needed) and return the results.
@@ -924,6 +950,17 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 		}
 	}
 
+	if ld.Tidy {
+		if ld.TidyCompatibleVersion == "" {
+			ld.TidyCompatibleVersion = priorGoVersion(ld.GoVersion)
+		} else if semver.Compare("v"+ld.TidyCompatibleVersion, "v"+ld.GoVersion) > 0 {
+			// Each version of the Go toolchain knows how to interpret go.mod and
+			// go.sum files produced by all previous versions, so a compatibility
+			// version higher than the go.mod version adds nothing.
+			ld.TidyCompatibleVersion = ld.GoVersion
+		}
+	}
+
 	if semver.Compare("v"+ld.GoVersion, narrowAllVersionV) < 0 && !ld.UseVendorAll {
 		// The module's go version explicitly predates the change in "all" for lazy
 		// loading, so continue to use the older interpretation.
@@ -1072,7 +1109,7 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 			// If that is not the case, there is a bug in the loading loop above.
 			for _, m := range rs.rootModules {
 				if v, ok := ld.requirements.rootSelected(m.Path); !ok || v != m.Version {
-					ld.errorf("go: internal error: a requirement on %v is needed but was not added during package loading\n", m)
+					ld.errorf("go mod tidy: internal error: a requirement on %v is needed but was not added during package loading\n", m)
 					base.ExitIfErrors()
 				}
 			}
@@ -1743,6 +1780,219 @@ func (ld *loader) checkMultiplePaths() {
 	}
 }
 
+// checkTidyCompatibility emits an error if any package would be loaded from a
+// different module under rs than under ld.requirements.
+func (ld *loader) checkTidyCompatibility(ctx context.Context, rs *Requirements) {
+	suggestUpgrade := false
+	suggestEFlag := false
+	suggestFixes := func() {
+		if ld.AllowErrors {
+			// The user is explicitly ignoring these errors, so don't bother them with
+			// other options.
+			return
+		}
+
+		// We print directly to os.Stderr because this information is advice about
+		// how to fix errors, not actually an error itself.
+		// (The actual errors should have been logged already.)
+
+		fmt.Fprintln(os.Stderr)
+
+		goFlag := ""
+		if ld.GoVersion != modFileGoVersion() {
+			goFlag = " -go=" + ld.GoVersion
+		}
+
+		compatFlag := ""
+		if ld.TidyCompatibleVersion != priorGoVersion(ld.GoVersion) {
+			compatFlag = " -compat=" + ld.TidyCompatibleVersion
+		}
+		if suggestUpgrade {
+			eDesc := ""
+			eFlag := ""
+			if suggestEFlag {
+				eDesc = ", leaving some packages unresolved"
+				eFlag = " -e"
+			}
+			fmt.Fprintf(os.Stderr, "To upgrade to the versions selected by go %s%s:\n\tgo mod tidy%s -go=%s && go mod tidy%s -go=%s%s\n", ld.TidyCompatibleVersion, eDesc, eFlag, ld.TidyCompatibleVersion, eFlag, ld.GoVersion, compatFlag)
+		} else if suggestEFlag {
+			// If some packages are missing but no package is upgraded, then we
+			// shouldn't suggest upgrading to the Go 1.16 versions explicitly — that
+			// wouldn't actually fix anything for Go 1.16 users, and *would* break
+			// something for Go 1.17 users.
+			fmt.Fprintf(os.Stderr, "To proceed despite packages unresolved in go %s:\n\tgo mod tidy -e%s%s\n", ld.TidyCompatibleVersion, goFlag, compatFlag)
+		}
+
+		fmt.Fprintf(os.Stderr, "If reproducibility with go %s is not needed:\n\tgo mod tidy%s -compat=%s\n", ld.TidyCompatibleVersion, goFlag, ld.GoVersion)
+
+		// TODO(#46141): Populate the linked wiki page.
+		fmt.Fprintf(os.Stderr, "For other options, see:\n\thttps://golang.org/wiki/PruningModules\n")
+	}
+
+	mg, err := rs.Graph(ctx)
+	if err != nil {
+		ld.errorf("go mod tidy: error loading go %s module graph: %v\n", ld.TidyCompatibleVersion, err)
+		suggestFixes()
+		return
+	}
+
+	// Re-resolve packages in parallel.
+	//
+	// We re-resolve each package — rather than just checking versions — to ensure
+	// that we have fetched module source code (and, importantly, checksums for
+	// that source code) for all modules that are necessary to ensure that imports
+	// are unambiguous. That also produces clearer diagnostics, since we can say
+	// exactly what happened to the package if it became ambiguous or disappeared
+	// entirely.
+	//
+	// We re-resolve the packages in parallel because this process involves disk
+	// I/O to check for package sources, and because the process of checking for
+	// ambiguous imports may require us to download additional modules that are
+	// otherwise pruned out in Go 1.17 — we don't want to block progress on other
+	// packages while we wait for a single new download.
+	type mismatch struct {
+		mod module.Version
+		err error
+	}
+	mismatchMu := make(chan map[*loadPkg]mismatch, 1)
+	mismatchMu <- map[*loadPkg]mismatch{}
+	for _, pkg := range ld.pkgs {
+		if pkg.mod.Path == "" && pkg.err == nil {
+			// This package is from the standard library (which does not vary based on
+			// the module graph).
+			continue
+		}
+
+		pkg := pkg
+		ld.work.Add(func() {
+			mod, _, err := importFromModules(ctx, pkg.path, rs, mg)
+			if mod != pkg.mod {
+				mismatches := <-mismatchMu
+				mismatches[pkg] = mismatch{mod: mod, err: err}
+				mismatchMu <- mismatches
+			}
+		})
+	}
+	<-ld.work.Idle()
+
+	mismatches := <-mismatchMu
+	if len(mismatches) == 0 {
+		// Since we're running as part of 'go mod tidy', the roots of the module
+		// graph should contain only modules that are relevant to some package in
+		// the package graph. We checked every package in the package graph and
+		// didn't find any mismatches, so that must mean that all of the roots of
+		// the module graph are also consistent.
+		//
+		// If we're wrong, Go 1.16 in -mod=readonly mode will error out with
+		// "updates to go.mod needed", which would be very confusing. So instead,
+		// we'll double-check that our reasoning above actually holds — if it
+		// doesn't, we'll emit an internal error and hopefully the user will report
+		// it as a bug.
+		for _, m := range ld.requirements.rootModules {
+			if v := mg.Selected(m.Path); v != m.Version {
+				fmt.Fprintln(os.Stderr)
+				base.Fatalf("go: internal error: failed to diagnose selected-version mismatch for module %s: go %s selects %s, but go %s selects %s\n\tPlease report this at https://golang.org/issue.", m.Path, ld.GoVersion, m.Version, ld.TidyCompatibleVersion, v)
+			}
+		}
+		return
+	}
+
+	// Iterate over the packages (instead of the mismatches map) to emit errors in
+	// deterministic order.
+	for _, pkg := range ld.pkgs {
+		mismatch, ok := mismatches[pkg]
+		if !ok {
+			continue
+		}
+
+		if pkg.isTest() {
+			// We already did (or will) report an error for the package itself,
+			// so don't report a duplicate (and more vebose) error for its test.
+			if _, ok := mismatches[pkg.testOf]; !ok {
+				base.Fatalf("go: internal error: mismatch recorded for test %s, but not its non-test package", pkg.path)
+			}
+			continue
+		}
+
+		switch {
+		case mismatch.err != nil:
+			// pkg resolved successfully, but errors out using the requirements in rs.
+			//
+			// This could occur because the import is provided by a single lazy root
+			// (and is thus unambiguous in lazy mode) and also one or more
+			// transitive dependencies (and is ambiguous in eager mode).
+			//
+			// It could also occur because some transitive dependency upgrades the
+			// module that previously provided the package to a version that no
+			// longer does, or to a version for which the module source code (but
+			// not the go.mod file in isolation) has a checksum error.
+			if missing := (*ImportMissingError)(nil); errors.As(mismatch.err, &missing) {
+				selected := module.Version{
+					Path:    pkg.mod.Path,
+					Version: mg.Selected(pkg.mod.Path),
+				}
+				ld.errorf("%s loaded from %v,\n\tbut go %s would fail to locate it in %s\n", pkg.stackText(), pkg.mod, ld.TidyCompatibleVersion, selected)
+			} else {
+				if ambiguous := (*AmbiguousImportError)(nil); errors.As(mismatch.err, &ambiguous) {
+					// TODO: Is this check needed?
+				}
+				ld.errorf("%s loaded from %v,\n\tbut go %s would fail to locate it:\n\t%v\n", pkg.stackText(), pkg.mod, ld.TidyCompatibleVersion, mismatch.err)
+			}
+
+			suggestEFlag = true
+
+			// Even if we press ahead with the '-e' flag, the older version will
+			// error out in readonly mode if it thinks the go.mod file contains
+			// any *explicit* dependency that is not at its selected version,
+			// even if that dependency is not relevant to any package being loaded.
+			//
+			// We check for that condition here. If all of the roots are consistent
+			// the '-e' flag suffices, but otherwise we need to suggest an upgrade.
+			if !suggestUpgrade {
+				for _, m := range ld.requirements.rootModules {
+					if v := mg.Selected(m.Path); v != m.Version {
+						suggestUpgrade = true
+						break
+					}
+				}
+			}
+
+		case pkg.err != nil:
+			// pkg had an error in lazy mode (presumably suppressed with the -e flag),
+			// but not in eager mode.
+			//
+			// This is possible, if, say, the import is unresolved in lazy mode
+			// (because the "latest" version of each candidate module either is
+			// unavailable or does not contain the package), but is resolved in
+			// eager mode due to a newer-than-latest dependency that is normally
+			// runed out of the module graph.
+			//
+			// This could also occur if the source code for the module providing the
+			// package in lazy mode has a checksum error, but eager mode upgrades
+			// that module to a version with a correct checksum.
+			//
+			// pkg.err should have already been logged elsewhere — along with a
+			// stack trace — so log only the import path and non-error info here.
+			suggestUpgrade = true
+			ld.errorf("%s failed to load from any module,\n\tbut go %s would load it from %v\n", pkg.path, ld.TidyCompatibleVersion, mismatch.mod)
+
+		case pkg.mod != mismatch.mod:
+			// The package is loaded successfully by both Go versions, but from a
+			// different module in each. This could lead to subtle (and perhaps even
+			// unnoticed!) variations in behavior between builds with different
+			// toolchains.
+			suggestUpgrade = true
+			ld.errorf("%s loaded from %v,\n\tbut go %s would select %v\n", pkg.stackText(), pkg.mod, ld.TidyCompatibleVersion, mismatch.mod.Version)
+
+		default:
+			base.Fatalf("go: internal error: mismatch recorded for package %s, but no differences found", pkg.path)
+		}
+	}
+
+	suggestFixes()
+	base.ExitIfErrors()
+}
+
 // scanDir is like imports.ScanDir but elides known magic imports from the list,
 // so that we do not go looking for packages that don't really exist.
 //
diff --git a/src/cmd/go/testdata/script/mod_tidy_compat.txt b/src/cmd/go/testdata/script/mod_tidy_compat.txt
index e6f88dc779..e6edef5ee3 100644
--- a/src/cmd/go/testdata/script/mod_tidy_compat.txt
+++ b/src/cmd/go/testdata/script/mod_tidy_compat.txt
@@ -34,28 +34,23 @@ go list -m all
 cmp stdout m_all.txt
 
 go mod edit -go=1.16
-! go list -m all
-stderr '^go list -m: example.net/lazy@v0.1.0 requires\n\texample.com/version@v1.0.1: missing go.sum entry; to add it:\n\tgo mod download example.com/version$'
+go list -m all
+cmp stdout m_all.txt
 
 
-# If we combine a Go 1.16 go.sum file...
-go mod tidy -go=1.16
+# If we explicitly drop compatibility with 1.16, we retain fewer checksums,
+# which gives a cleaner go.sum file but causes 1.16 to fail in readonly mode.
 
-# ...with a Go 1.17 go.mod file...
 cp go.mod.orig go.mod
+go mod tidy -compat=1.17
+cmp go.mod go.mod.orig
 
-# ...then Go 1.17 continues to work...
 go list -m all
 cmp stdout m_all.txt
 
-# ...and now 1.16 can load the same build list!
 go mod edit -go=1.16
-go list -m all
-cmp stdout m_all.txt
-
-
-# TODO(#46141): Add a cleaner way to tidy a Go 1.17 module while preserving
-# the checksums needed to work within it with Go 1.16.
+! go list -m all
+stderr '^go list -m: example.net/lazy@v0.1.0 requires\n\texample.com/version@v1.0.1: missing go.sum entry; to add it:\n\tgo mod download example.com/version$'
 
 
 -- go.mod --
diff --git a/src/cmd/go/testdata/script/mod_tidy_compat_added.txt b/src/cmd/go/testdata/script/mod_tidy_compat_added.txt
new file mode 100644
index 0000000000..94fa79bc9f
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_tidy_compat_added.txt
@@ -0,0 +1,105 @@
+# https://golang.org/issue/46141: 'go mod tidy' for a Go 1.17 module should by
+# default preserve enough checksums for the module to be used by Go 1.16.
+#
+# We don't have a copy of Go 1.16 handy, but we can simulate it by editing the
+# 'go' version in the go.mod file to 1.16, without actually updating the
+# requirements to match.
+
+[short] skip
+
+env MODFMT='{{with .Module}}{{.Path}} {{.Version}}{{end}}'
+
+
+# For this module, Go 1.17 produces an error for one module, and Go 1.16
+# produces a different error for a different module.
+
+cp go.mod go.mod.orig
+
+! go mod tidy
+
+stderr '^example\.com/m imports\n\texample\.net/added: module example\.net/added@latest found \(v0\.3\.0, replaced by \./a1\), but does not contain package example\.net/added$'
+
+cmp go.mod go.mod.orig
+
+
+# When we run 'go mod tidy -e', we should proceed past the first error and follow
+# it with a second error describing the version descrepancy.
+#
+# We should not provide advice on how to push past the version descrepancy,
+# because the '-e' flag should already do that, writing out an otherwise-tidied
+# go.mod file.
+
+go mod tidy -e
+
+stderr '^example\.com/m imports\n\texample\.net/added: module example\.net/added@latest found \(v0\.3\.0, replaced by \./a1\), but does not contain package example\.net/added\nexample\.net/added failed to load from any module,\n\tbut go 1\.16 would load it from example\.net/added@v0\.2\.0$'
+
+! stderr '\n\tgo mod tidy'
+
+cmp go.mod go.mod.tidy
+
+
+-- go.mod --
+module example.com/m
+
+go 1.17
+
+replace (
+	example.net/added v0.1.0 => ./a1
+	example.net/added v0.2.0 => ./a2
+	example.net/added v0.3.0 => ./a1
+	example.net/lazy v0.1.0 => ./lazy
+	example.net/pruned v0.1.0 => ./pruned
+)
+
+require (
+	example.net/added v0.1.0
+	example.net/lazy v0.1.0
+)
+-- go.mod.tidy --
+module example.com/m
+
+go 1.17
+
+replace (
+	example.net/added v0.1.0 => ./a1
+	example.net/added v0.2.0 => ./a2
+	example.net/added v0.3.0 => ./a1
+	example.net/lazy v0.1.0 => ./lazy
+	example.net/pruned v0.1.0 => ./pruned
+)
+
+require example.net/lazy v0.1.0
+-- m.go --
+package m
+
+import (
+	_ "example.net/added"
+	_ "example.net/lazy"
+)
+
+-- a1/go.mod --
+module example.net/added
+
+go 1.17
+-- a2/go.mod --
+module example.net/added
+
+go 1.17
+-- a2/added.go --
+package added
+
+-- lazy/go.mod --
+module example.net/lazy
+
+go 1.17
+
+require example.net/pruned v0.1.0
+-- lazy/lazy.go --
+package lazy
+
+-- pruned/go.mod --
+module example.net/pruned
+
+go 1.17
+
+require example.net/added v0.2.0
diff --git a/src/cmd/go/testdata/script/mod_tidy_compat_ambiguous.txt b/src/cmd/go/testdata/script/mod_tidy_compat_ambiguous.txt
new file mode 100644
index 0000000000..ed1dd53eff
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_tidy_compat_ambiguous.txt
@@ -0,0 +1,98 @@
+# https://golang.org/issue/46141: 'go mod tidy' for a Go 1.17 module should by
+# default preserve enough checksums for the module to be used by Go 1.16.
+#
+# We don't have a copy of Go 1.16 handy, but we can simulate it by editing the
+# 'go' version in the go.mod file to 1.16, without actually updating the
+# requirements to match.
+
+[short] skip
+
+env MODFMT='{{with .Module}}{{.Path}} {{.Version}}{{end}}'
+
+# For this module, the dependency providing package
+# example.net/ambiguous/nested/pkg is unambiguous in Go 1.17 (because only one
+# root of the module graph contains the package), whereas it is ambiguous in
+# Go 1.16 (because two different modules contain plausible packages and Go 1.16
+# does not privilege roots above other dependencies).
+#
+# However, the overall build list is identical for both versions.
+
+cp go.mod go.mod.orig
+
+! go mod tidy
+
+stderr '^example\.com/m imports\n\texample\.net/indirect imports\n\texample\.net/ambiguous/nested/pkg loaded from example\.net/ambiguous/nested@v0\.1\.0,\n\tbut go 1.16 would fail to locate it:\n\tambiguous import: found package example\.net/ambiguous/nested/pkg in multiple modules:\n\texample\.net/ambiguous v0.1.0 \(.*\)\n\texample\.net/ambiguous/nested v0.1.0 \(.*\)\n\n'
+
+stderr '\n\nTo proceed despite packages unresolved in go 1\.16:\n\tgo mod tidy -e\nIf reproducibility with go 1.16 is not needed:\n\tgo mod tidy -compat=1\.17\nFor other options, see:\n\thttps://golang\.org/wiki/PruningModules\n'
+
+cmp go.mod go.mod.orig
+
+
+# If we run 'go mod tidy -e', we should still save enough checksums to run
+# 'go list -m all' reproducibly with go 1.16, even though we can't list
+# the specific package.
+
+go mod tidy -e
+! stderr '\n\tgo mod tidy'
+cmp go.mod go.mod.orig
+
+go list -m all
+cmp stdout all-m.txt
+
+go list -f $MODFMT example.net/ambiguous/nested/pkg
+stdout '^example.net/ambiguous/nested v0\.1\.0$'
+! stderr .
+
+go mod edit -go=1.16
+go list -m all
+cmp stdout all-m.txt
+
+! go list -f $MODFMT example.net/ambiguous/nested/pkg
+stderr '^ambiguous import: found package example\.net/ambiguous/nested/pkg in multiple modules:\n\texample\.net/ambiguous v0\.1\.0 \(.*\)\n\texample\.net/ambiguous/nested v0\.1\.0 \(.*\)\n'
+
+
+# On the other hand, if we use -compat=1.17, 1.16 can't even load
+# the build list (due to missing checksums).
+
+cp go.mod.orig go.mod
+go mod tidy -compat=1.17
+! stderr .
+go list -m all
+cmp stdout all-m.txt
+
+go mod edit -go=1.16
+! go list -m all
+stderr '^go list -m: example\.net/indirect@v0\.1\.0 requires\n\texample\.net/ambiguous@v0\.1\.0: missing go\.sum entry; to add it:\n\tgo mod download example\.net/ambiguous\n'
+
+
+-- go.mod --
+module example.com/m
+
+go 1.17
+
+replace example.net/indirect v0.1.0 => ./indirect
+
+require (
+	example.net/ambiguous/nested v0.1.0 // indirect
+	example.net/indirect v0.1.0
+)
+-- all-m.txt --
+example.com/m
+example.net/ambiguous v0.1.0
+example.net/ambiguous/nested v0.1.0
+example.net/indirect v0.1.0 => ./indirect
+-- m.go --
+package m
+
+import _ "example.net/indirect"
+
+-- indirect/go.mod --
+module example.net/indirect
+
+go 1.17
+
+require example.net/ambiguous v0.1.0
+-- indirect/indirect.go --
+package indirect
+
+import _ "example.net/ambiguous/nested/pkg"
diff --git a/src/cmd/go/testdata/script/mod_tidy_compat_deleted.txt b/src/cmd/go/testdata/script/mod_tidy_compat_deleted.txt
new file mode 100644
index 0000000000..3aacde2025
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_tidy_compat_deleted.txt
@@ -0,0 +1,128 @@
+# https://golang.org/issue/46141: 'go mod tidy' for a Go 1.17 module should by
+# default preserve enough checksums for the module to be used by Go 1.16.
+#
+# We don't have a copy of Go 1.16 handy, but we can simulate it by editing the
+# 'go' version in the go.mod file to 1.16, without actually updating the
+# requirements to match.
+
+[short] skip
+
+env MODFMT='{{with .Module}}{{.Path}} {{.Version}}{{end}}'
+
+
+# For this module, the "deleted" dependency contains an imported package, but
+# Go 1.16 selects a higher version (in which that package has been deleted).
+
+cp go.mod go.mod.orig
+
+! go mod tidy
+
+stderr '^example\.com/m imports\n\texample\.net/deleted loaded from example\.net/deleted@v0\.1\.0,\n\tbut go 1\.16 would fail to locate it in example\.net/deleted@v0\.2\.0\n\n'
+
+stderr '\n\nTo upgrade to the versions selected by go 1.16, leaving some packages unresolved:\n\tgo mod tidy -e -go=1\.16 && go mod tidy -e -go=1\.17\nIf reproducibility with go 1.16 is not needed:\n\tgo mod tidy -compat=1\.17\nFor other options, see:\n\thttps://golang\.org/wiki/PruningModules\n'
+
+
+# The suggested 'go mod tidy -e' command should proceed anyway.
+
+go mod tidy -e
+cmp go.mod go.mod.tidy
+
+
+# In 'go 1.16' mode we should error out in the way we claimed.
+
+cd 116-outside
+! go list -deps -f $MODFMT example.com/m
+stderr '^\.\.[/\\]m\.go:4:2: no required module provides package example\.net/deleted; to add it:\n\tgo get example\.net/deleted$'
+cd ..
+
+go mod edit -go=1.16
+! go list -deps -f $MODFMT example.com/m
+stderr '^go: updates to go\.mod needed; to update it:\n\tgo mod tidy$'
+
+! go mod tidy
+stderr '^example\.com/m imports\n\texample\.net/deleted: module example\.net/deleted@latest found \(v0\.2\.0, replaced by \./d2\), but does not contain package example\.net/deleted$'
+
+
+-- go.mod --
+module example.com/m
+
+go 1.17
+
+replace (
+	example.net/deleted v0.1.0 => ./d1
+	example.net/deleted v0.2.0 => ./d2
+	example.net/lazy v0.1.0 => ./lazy
+	example.net/pruned v0.1.0 => ./pruned
+)
+
+require (
+	example.net/deleted v0.1.0
+	example.net/deleted v0.1.0 // redundant
+	example.net/lazy v0.1.0
+)
+-- go.mod.tidy --
+module example.com/m
+
+go 1.17
+
+replace (
+	example.net/deleted v0.1.0 => ./d1
+	example.net/deleted v0.2.0 => ./d2
+	example.net/lazy v0.1.0 => ./lazy
+	example.net/pruned v0.1.0 => ./pruned
+)
+
+require (
+	example.net/deleted v0.1.0
+	example.net/lazy v0.1.0
+)
+-- 116-outside/go.mod --
+module outside
+
+go 1.16
+
+replace (
+	example.com/m => ../
+	example.net/deleted v0.1.0 => ../d1
+	example.net/deleted v0.2.0 => ../d2
+	example.net/lazy v0.1.0 => ../lazy
+	example.net/pruned v0.1.0 => ../pruned
+)
+
+require example.com/m v0.1.0
+-- m.go --
+package m
+
+import (
+	_ "example.net/deleted"
+	_ "example.net/lazy"
+)
+
+-- d1/go.mod --
+module example.net/deleted
+
+go 1.17
+-- d1/deleted.go --
+package deleted
+-- d2/go.mod --
+module example.net/deleted
+
+go 1.17
+-- d2/README --
+There is no longer a Go package here.
+
+-- lazy/go.mod --
+module example.net/lazy
+
+go 1.17
+
+require example.net/pruned v0.1.0
+-- lazy/lazy.go --
+package lazy
+
+-- pruned/go.mod --
+module example.net/pruned
+
+go 1.17
+
+require example.net/deleted v0.2.0
diff --git a/src/cmd/go/testdata/script/mod_tidy_compat_implicit.txt b/src/cmd/go/testdata/script/mod_tidy_compat_implicit.txt
index baaa5d63e3..e00aea930e 100644
--- a/src/cmd/go/testdata/script/mod_tidy_compat_implicit.txt
+++ b/src/cmd/go/testdata/script/mod_tidy_compat_implicit.txt
@@ -27,8 +27,22 @@ env MODFMT='{{with .Module}}{{.Path}} {{.Version}}{{end}}'
 # it — lazy v0.1.0 — specifies 'go 1.17', and it is not otherwise relevant to
 # the main module).
 
+# 'go mod tidy' should by default diagnose the difference in dependencies as an
+# error, with useful suggestions about how to resolve it.
+
 cp go.mod go.mod.orig
-go mod tidy
+! go mod tidy
+stderr '^example\.com/m imports\n\texample\.net/lazy tested by\n\texample\.net/lazy.test imports\n\texample\.com/retract/incompatible loaded from example\.com/retract/incompatible@v1\.0\.0,\n\tbut go 1\.16 would select v2\.0\.0\+incompatible\n\n'
+stderr '\n\nTo upgrade to the versions selected by go 1\.16:\n\tgo mod tidy -go=1\.16 && go mod tidy -go=1\.17\nIf reproducibility with go 1.16 is not needed:\n\tgo mod tidy -compat=1.17\nFor other options, see:\n\thttps://golang\.org/wiki/PruningModules\n'
+
+cmp go.mod go.mod.orig
+
+# The suggested '-compat' flag to ignore differences should silence the error
+# and leave go.mod unchanged, resulting in checksum errors when Go 1.16 tries
+# to load a module pruned out by Go 1.17.
+
+go mod tidy -compat=1.17
+! stderr .
 cmp go.mod go.mod.orig
 
 go list -deps -test -f $MODFMT all
@@ -49,7 +63,7 @@ cp go.mod.orig go.mod
 
 # ...then Go 1.17 no longer works. 😞
 ! go list -deps -test -f $MODFMT all
-stderr -count=1 '^can''t load test package: lazy/lazy_test.go:3:8: missing go\.sum entry for module providing package example\.com/retract/incompatible \(imported by example\.net/lazy\); to add:\n\tgo get -t example.net/lazy@v0\.1\.0$'
+stderr -count=1 '^can''t load test package: lazy[/\\]lazy_test.go:3:8: missing go\.sum entry for module providing package example\.com/retract/incompatible \(imported by example\.net/lazy\); to add:\n\tgo get -t example.net/lazy@v0\.1\.0$'
 
 
 # However, if we take the union of the go.sum files...
@@ -67,11 +81,6 @@ go list -deps -test -f $MODFMT all
 stdout '^example\.com/retract/incompatible v2\.0\.0\+incompatible$'
 
 
-# TODO(#46100): In compatibility mode, should we reject the above difference as
-# incompatible, or save checksums for both possible versions of the test
-# dependency?
-
-
 -- go.mod --
 // Module m imports packages from the same versions under Go 1.17
 // as under Go 1.16, but under 1.16 its (implicit) external test dependencies
diff --git a/src/cmd/go/testdata/script/mod_tidy_compat_incompatible.txt b/src/cmd/go/testdata/script/mod_tidy_compat_incompatible.txt
index 0861352408..2d8726544a 100644
--- a/src/cmd/go/testdata/script/mod_tidy_compat_incompatible.txt
+++ b/src/cmd/go/testdata/script/mod_tidy_compat_incompatible.txt
@@ -27,12 +27,23 @@ env MODFMT='{{with .Module}}{{.Path}} {{.Version}}{{end}}'
 # the main module).
 
 
-# TODO(#46141): 'go mod tidy' should by default diagnose the difference in
-# dependencies as an error, but it should still be possible to simply drop
-# compatibility with Go 1.16 by passing an appropriate '-compat' flag.
+# 'go mod tidy' should by default diagnose the difference in dependencies as an
+# error, with useful suggestions about how to resolve it.
 
 cp go.mod go.mod.orig
-go mod tidy
+! go mod tidy
+stderr '^example\.com/m imports\n\texample\.net/lazy imports\n\texample\.com/retract/incompatible loaded from example\.com/retract/incompatible@v1\.0\.0,\n\tbut go 1\.16 would select v2\.0\.0\+incompatible\n\n'
+stderr '\n\nTo upgrade to the versions selected by go 1\.16:\n\tgo mod tidy -go=1\.16 && go mod tidy -go=1\.17\nIf reproducibility with go 1\.16 is not needed:\n\tgo mod tidy -compat=1.17\nFor other options, see:\n\thttps://golang\.org/wiki/PruningModules\n'
+
+cmp go.mod go.mod.orig
+
+
+# The suggested '-compat' flag to ignore differences should silence the error
+# and leave go.mod unchanged, resulting in checksum errors when Go 1.16 tries
+# to load a module pruned out by Go 1.17.
+
+go mod tidy -compat=1.17
+! stderr .
 cmp go.mod go.mod.orig
 
 go mod edit -go=1.16
@@ -44,6 +55,7 @@ stderr -count=2 '^go: example\.net/lazy@v0\.1\.0 requires\n\texample\.net/requir
 # There are two ways for the module author to bring the two into alignment.
 # One is to *explicitly* 'exclude' the version that is already *implicitly*
 # pruned out under 1.17.
+
 go mod edit -exclude=example.com/retract/incompatible@v2.0.0+incompatible
 go list -f $MODFMT -deps ./...
 stdout '^example.com/retract/incompatible v1\.0\.0$'
@@ -51,13 +63,20 @@ stdout '^example.com/retract/incompatible v1\.0\.0$'
 
 
 # The other is to explicitly upgrade the version required under Go 1.17
-# to match the version selected by Go 1.16.
+# to match the version selected by Go 1.16. The commands suggested by
+# 'go mod tidy' should do exactly that.
+
 cp go.mod.orig go.mod
 
-go get -d example.com/retract/incompatible@v2.0.0+incompatible
-	# Note that we are not running 'go mod tidy' here: we need to preserve
-	# the checksum for v1.0.0 because it is also still in the module graph
-	# as seen by Go 1.16.
+go mod tidy -go=1.16
+go list -f $MODFMT -deps ./...
+stdout '^example.com/retract/incompatible v2\.0\.0\+incompatible$'
+! stdout 'v1\.0\.0'
+
+go mod tidy -go=1.17
+go list -f $MODFMT -deps ./...
+stdout '^example.com/retract/incompatible v2\.0\.0\+incompatible$'
+! stdout 'v1\.0\.0'
 
 go mod edit -go=1.16
 go list -f $MODFMT -deps ./...
diff --git a/src/cmd/go/testdata/script/mod_tidy_compat_irrelevant.txt b/src/cmd/go/testdata/script/mod_tidy_compat_irrelevant.txt
index d4371e0f7d..7c22fca6c0 100644
--- a/src/cmd/go/testdata/script/mod_tidy_compat_irrelevant.txt
+++ b/src/cmd/go/testdata/script/mod_tidy_compat_irrelevant.txt
@@ -27,34 +27,28 @@ cp go.mod go.mod.orig
 go mod tidy
 cmp go.mod go.mod.orig
 
-go list -m all
-stdout '^example\.com/retract/incompatible v1\.0\.0$'
+go list -deps -test -f $MODFMT all
+cp stdout out-117.txt
 
 go mod edit -go=1.16
-! go list -deps -test -f $MODFMT all
-	# TODO(#46160): -count=1 instead of -count=2.
-stderr -count=2 '^go: example.net/lazy@v0.1.0 requires\n\texample.com/retract/incompatible@v1.0.0: missing go.sum entry; to add it:\n\tgo mod download example.com/retract/incompatible$'
+go list -deps -test -f $MODFMT all
+cmp stdout out-117.txt
 
 
-# If we combine a Go 1.16 go.sum file...
-go mod tidy -go=1.16
+# If we explicitly drop compatibility with 1.16, we retain fewer checksums,
+# which gives a cleaner go.sum file but causes 1.16 to fail in readonly mode.
 
-# ...with a Go 1.17 go.mod file...
 cp go.mod.orig go.mod
+go mod tidy -compat=1.17
+cmp go.mod go.mod.orig
 
-# ...then Go 1.17 continues to work...
-go list -deps -test -f $MODFMT all
-cp stdout out-117.txt
-
-# ...and 1.16 also works, and selects the same versions for all packages
-# even remotely relevant to the main module.
-go mod edit -go=1.16
 go list -deps -test -f $MODFMT all
 cmp stdout out-117.txt
 
-
-# TODO(#46160): Add a cleaner way to tidy a Go 1.17 module while preserving
-# the checksums needed to work within it with Go 1.16.
+go mod edit -go=1.16
+! go list -deps -test -f $MODFMT all
+	# TODO(#46160): -count=1 instead of -count=2.
+stderr -count=2 '^go: example.net/lazy@v0.1.0 requires\n\texample.com/retract/incompatible@v1.0.0: missing go.sum entry; to add it:\n\tgo mod download example.com/retract/incompatible$'
 
 
 -- go.mod --
diff --git a/src/cmd/go/testdata/script/mod_tidy_oldgo.txt b/src/cmd/go/testdata/script/mod_tidy_oldgo.txt
new file mode 100644
index 0000000000..0e88b068a7
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_tidy_oldgo.txt
@@ -0,0 +1,21 @@
+# Modules were introduced in Go 1.11, but for various reasons users may
+# decide to declare a (much!) older go version in their go.mod file.
+# Modules with very old versions should not be rejected, and should have
+# the same module-graph semantics as in Go 1.11.
+
+cp go.mod go.mod.orig
+go mod tidy
+cmp go.mod go.mod.orig
+
+-- go.mod --
+module example.com/legacy/go1
+
+go 1.0
+
+require golang.org/x/text v0.3.0
+-- main.go --
+package main
+
+import _ "golang.org/x/text/language"
+
+func main() {}
diff --git a/src/go.sum b/src/go.sum
index b3de6c526c..6e869b96f7 100644
--- a/src/go.sum
+++ b/src/go.sum
@@ -1,8 +1,15 @@
 golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e h1:8foAy0aoO5GkqCvAEJ4VC4P3zksTg4X4aJCDpZzmgQI=
 golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210510120150-4163338589ed h1:p9UgmWI9wKpfYmgaV/IZKGdXc5qEK45tDwwwDyjS26I=
 golang.org/x/net v0.0.0-20210510120150-4163338589ed/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210511113859-b0526f3d8744 h1:yhBbb4IRs2HS9PPlAg6DMC6mUOKexJBNsLf4Z+6En1Q=
 golang.org/x/sys v0.0.0-20210511113859-b0526f3d8744/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7-0.20210503195748-5c7c50ebbd4f h1:yQJrRE0hDxDFmZLlRaw+3vusO4fwNHgHIjUOMO7bHYI=
 golang.org/x/text v0.3.7-0.20210503195748-5c7c50ebbd4f/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-- 
GitLab


From f22ec51debeddc0903096e66bfaf641568bede3b Mon Sep 17 00:00:00 2001
From: Dan Scales <danscales@google.com>
Date: Sat, 22 May 2021 13:40:20 -0700
Subject: [PATCH 2114/2400] doc: add Go 1.17 release note about inlining
 functions with closures

Fixes #45781

Change-Id: Ia5bc2845f7f94aff4f3f0ff15533feb148223adb
Reviewed-on: https://go-review.googlesource.com/c/go/+/322089
Trust: Dan Scales <danscales@google.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 doc/go1.17.html | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 6dd1d0d1db..c2317a4035 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -228,7 +228,14 @@ Do not send CLs removing the interior tags from such phrases.
 
 <h2 id="compiler">Compiler</h2>
 
-<p>
+<p><!-- CL 283112, golang.org/issue/28727 -->
+
+  Functions containing closures can now be inlined. One effect of this change is
+  that a function with a closure may actually produce a distinct closure function
+  for each place that the function is inlined. Hence, this change could reveal
+  bugs where Go functions are compared (incorrectly) by pointer value. Go
+  functions are by definition not comparable.
+
   TODO: complete the Compiler section, or delete if not needed
 </p>
 
-- 
GitLab


From 74242baa4136c7a9132a8ccd9881354442788c8c Mon Sep 17 00:00:00 2001
From: Roland Shoemaker <roland@golang.org>
Date: Tue, 11 May 2021 11:31:31 -0700
Subject: [PATCH 2115/2400] archive/zip: only preallocate File slice if
 reasonably sized

Since the number of files in the EOCD record isn't validated, it isn't
safe to preallocate Reader.Files using that field. A malformed archive
can indicate it contains up to 1 << 128 - 1 files. We can still safely
preallocate the slice by checking if the specified number of files in
the archive is reasonable, given the size of the archive.

Thanks to the OSS-Fuzz project for discovering this issue and to
Emmanuel Odeke for reporting it.

Fixes #46242
Fixes CVE-2021-33196

Change-Id: I3c76d8eec178468b380d87fdb4a3f2cb06f0ee76
Reviewed-on: https://go-review.googlesource.com/c/go/+/318909
Trust: Roland Shoemaker <roland@golang.org>
Trust: Katie Hockman <katie@golang.org>
Trust: Joe Tsai <thebrokentoaster@gmail.com>
Run-TryBot: Roland Shoemaker <roland@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
---
 src/archive/zip/reader.go      | 10 +++++-
 src/archive/zip/reader_test.go | 59 ++++++++++++++++++++++++++++++++++
 2 files changed, 68 insertions(+), 1 deletion(-)

diff --git a/src/archive/zip/reader.go b/src/archive/zip/reader.go
index 808cf274ca..2d53f4c723 100644
--- a/src/archive/zip/reader.go
+++ b/src/archive/zip/reader.go
@@ -96,7 +96,15 @@ func (z *Reader) init(r io.ReaderAt, size int64) error {
 		return err
 	}
 	z.r = r
-	z.File = make([]*File, 0, end.directoryRecords)
+	// Since the number of directory records is not validated, it is not
+	// safe to preallocate z.File without first checking that the specified
+	// number of files is reasonable, since a malformed archive may
+	// indicate it contains up to 1 << 128 - 1 files. Since each file has a
+	// header which will be _at least_ 30 bytes we can safely preallocate
+	// if (data size / 30) >= end.directoryRecords.
+	if (uint64(size)-end.directorySize)/30 >= end.directoryRecords {
+		z.File = make([]*File, 0, end.directoryRecords)
+	}
 	z.Comment = end.comment
 	rs := io.NewSectionReader(r, 0, size)
 	if _, err = rs.Seek(int64(end.directoryOffset), io.SeekStart); err != nil {
diff --git a/src/archive/zip/reader_test.go b/src/archive/zip/reader_test.go
index 35e681ec69..37dafe6c8e 100644
--- a/src/archive/zip/reader_test.go
+++ b/src/archive/zip/reader_test.go
@@ -1325,3 +1325,62 @@ func TestReadDataDescriptor(t *testing.T) {
 		})
 	}
 }
+
+func TestCVE202133196(t *testing.T) {
+	// Archive that indicates it has 1 << 128 -1 files,
+	// this would previously cause a panic due to attempting
+	// to allocate a slice with 1 << 128 -1 elements.
+	data := []byte{
+		0x50, 0x4b, 0x03, 0x04, 0x14, 0x00, 0x08, 0x08,
+		0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x02,
+		0x03, 0x62, 0x61, 0x65, 0x03, 0x04, 0x00, 0x00,
+		0xff, 0xff, 0x50, 0x4b, 0x07, 0x08, 0xbe, 0x20,
+		0x5c, 0x6c, 0x09, 0x00, 0x00, 0x00, 0x03, 0x00,
+		0x00, 0x00, 0x50, 0x4b, 0x01, 0x02, 0x14, 0x00,
+		0x14, 0x00, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0xbe, 0x20, 0x5c, 0x6c, 0x09, 0x00,
+		0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x01, 0x02, 0x03, 0x50, 0x4b, 0x06, 0x06, 0x2c,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2d,
+		0x00, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff,
+		0xff, 0xff, 0xff, 0x31, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x50, 0x4b, 0x06, 0x07, 0x00,
+		0x00, 0x00, 0x00, 0x6b, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50,
+		0x4b, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0xff,
+		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+		0xff, 0xff, 0xff, 0x00, 0x00,
+	}
+	_, err := NewReader(bytes.NewReader(data), int64(len(data)))
+	if err != ErrFormat {
+		t.Fatalf("unexpected error, got: %v, want: %v", err, ErrFormat)
+	}
+
+	// Also check that an archive containing a handful of empty
+	// files doesn't cause an issue
+	b := bytes.NewBuffer(nil)
+	w := NewWriter(b)
+	for i := 0; i < 5; i++ {
+		_, err := w.Create("")
+		if err != nil {
+			t.Fatalf("Writer.Create failed: %s", err)
+		}
+	}
+	if err := w.Close(); err != nil {
+		t.Fatalf("Writer.Close failed: %s", err)
+	}
+	r, err := NewReader(bytes.NewReader(b.Bytes()), int64(b.Len()))
+	if err != nil {
+		t.Fatalf("NewReader failed: %s", err)
+	}
+	if len(r.File) != 5 {
+		t.Errorf("Archive has unexpected number of files, got %d, want 5", len(r.File))
+	}
+}
-- 
GitLab


From d050238bb653711b47335583c5425c9efec30e4e Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Tue, 25 May 2021 10:33:02 +0200
Subject: [PATCH 2116/2400] doc/go1.17: fix formatting for time changes

Also add a link to the time.Time type and adjust the wording a bit.

Change-Id: I2f4210ada6d253eb5804e6327b2432487beb8a05
Reviewed-on: https://go-review.googlesource.com/c/go/+/321811
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 doc/go1.17.html | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index c2317a4035..bdde26bd10 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -558,9 +558,10 @@ Do not send CLs removing the interior tags from such phrases.
 <dl id="time"><dt><a href="/pkg/time/">time</a></dt>
   <dd>
     <p><!-- CL 260858 -->
-      time.Time now has a <a href="/pkg/time/#Time.GoString">GoString</a>
-      method that will return a more useful value for times when printed with
-      the <code>"%#v"</code> format specifier in the fmt package.
+      The <a href="/pkg/time/#Time"><code>Time</code></a> type now has a
+      <a href="/pkg/time/#Time.GoString"><code>GoString</code></a> method that
+      will return a more useful value for times when printed with the
+      <code>%#v</code> format specifier in the <code>fmt</code> package.
     </p>
 
     <p><!-- CL 264077 -->
-- 
GitLab


From e4615ad74d5becdd1fcee4879775a6d4118583c5 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 12 May 2021 23:04:25 -0400
Subject: [PATCH 2117/2400] math/big: move division into natdiv.go

Code moved and functions reordered to be in a consistent
top-down dependency order, but otherwise unchanged.

First step toward commenting division algorithms.

Change-Id: Ib5e604fb5b2867edff3a228ba4e57b5cb32c4137
Reviewed-on: https://go-review.googlesource.com/c/go/+/321077
Trust: Russ Cox <rsc@golang.org>
Trust: Katie Hockman <katie@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/math/big/arith.go  |  14 --
 src/math/big/nat.go    | 325 --------------------------------------
 src/math/big/natdiv.go | 346 +++++++++++++++++++++++++++++++++++++++++
 3 files changed, 346 insertions(+), 339 deletions(-)
 create mode 100644 src/math/big/natdiv.go

diff --git a/src/math/big/arith.go b/src/math/big/arith.go
index e1947936d4..8f55c195d4 100644
--- a/src/math/big/arith.go
+++ b/src/math/big/arith.go
@@ -267,20 +267,6 @@ func divWW(x1, x0, y, m Word) (q, r Word) {
 	return Word(qq), Word(r0 >> s)
 }
 
-func divWVW(z []Word, xn Word, x []Word, y Word) (r Word) {
-	r = xn
-	if len(x) == 1 {
-		qq, rr := bits.Div(uint(r), uint(x[0]), uint(y))
-		z[0] = Word(qq)
-		return Word(rr)
-	}
-	rec := reciprocalWord(y)
-	for i := len(z) - 1; i >= 0; i-- {
-		z[i], r = divWW(r, x[i], y, rec)
-	}
-	return r
-}
-
 // reciprocalWord return the reciprocal of the divisor. rec = floor(( _B^2 - 1 ) / u - _B). u = d1 << nlz(d1).
 func reciprocalWord(d1 Word) Word {
 	u := uint(d1 << nlz(d1))
diff --git a/src/math/big/nat.go b/src/math/big/nat.go
index bbd6c8850b..140c619c8c 100644
--- a/src/math/big/nat.go
+++ b/src/math/big/nat.go
@@ -631,48 +631,6 @@ func (z nat) mulRange(a, b uint64) nat {
 	return z.mul(nat(nil).mulRange(a, m), nat(nil).mulRange(m+1, b))
 }
 
-// q = (x-r)/y, with 0 <= r < y
-func (z nat) divW(x nat, y Word) (q nat, r Word) {
-	m := len(x)
-	switch {
-	case y == 0:
-		panic("division by zero")
-	case y == 1:
-		q = z.set(x) // result is x
-		return
-	case m == 0:
-		q = z[:0] // result is 0
-		return
-	}
-	// m > 0
-	z = z.make(m)
-	r = divWVW(z, 0, x, y)
-	q = z.norm()
-	return
-}
-
-func (z nat) div(z2, u, v nat) (q, r nat) {
-	if len(v) == 0 {
-		panic("division by zero")
-	}
-
-	if u.cmp(v) < 0 {
-		q = z[:0]
-		r = z2.set(u)
-		return
-	}
-
-	if len(v) == 1 {
-		var r2 Word
-		q, r2 = z.divW(u, v[0])
-		r = z2.setWord(r2)
-		return
-	}
-
-	q, r = z.divLarge(z2, u, v)
-	return
-}
-
 // getNat returns a *nat of len n. The contents may not be zero.
 // The pool holds *nat to avoid allocation when converting to interface{}.
 func getNat(n int) *nat {
@@ -693,276 +651,6 @@ func putNat(x *nat) {
 
 var natPool sync.Pool
 
-// q = (uIn-r)/vIn, with 0 <= r < vIn
-// Uses z as storage for q, and u as storage for r if possible.
-// See Knuth, Volume 2, section 4.3.1, Algorithm D.
-// Preconditions:
-//    len(vIn) >= 2
-//    len(uIn) >= len(vIn)
-//    u must not alias z
-func (z nat) divLarge(u, uIn, vIn nat) (q, r nat) {
-	n := len(vIn)
-	m := len(uIn) - n
-
-	// D1.
-	shift := nlz(vIn[n-1])
-	// do not modify vIn, it may be used by another goroutine simultaneously
-	vp := getNat(n)
-	v := *vp
-	shlVU(v, vIn, shift)
-
-	// u may safely alias uIn or vIn, the value of uIn is used to set u and vIn was already used
-	u = u.make(len(uIn) + 1)
-	u[len(uIn)] = shlVU(u[0:len(uIn)], uIn, shift)
-
-	// z may safely alias uIn or vIn, both values were used already
-	if alias(z, u) {
-		z = nil // z is an alias for u - cannot reuse
-	}
-	q = z.make(m + 1)
-
-	if n < divRecursiveThreshold {
-		q.divBasic(u, v)
-	} else {
-		q.divRecursive(u, v)
-	}
-	putNat(vp)
-
-	q = q.norm()
-	shrVU(u, u, shift)
-	r = u.norm()
-
-	return q, r
-}
-
-// divBasic performs word-by-word division of u by v.
-// The quotient is written in pre-allocated q.
-// The remainder overwrites input u.
-//
-// Precondition:
-// - q is large enough to hold the quotient u / v
-//   which has a maximum length of len(u)-len(v)+1.
-func (q nat) divBasic(u, v nat) {
-	n := len(v)
-	m := len(u) - n
-
-	qhatvp := getNat(n + 1)
-	qhatv := *qhatvp
-
-	// D2.
-	vn1 := v[n-1]
-	rec := reciprocalWord(vn1)
-	for j := m; j >= 0; j-- {
-		// D3.
-		qhat := Word(_M)
-		var ujn Word
-		if j+n < len(u) {
-			ujn = u[j+n]
-		}
-		if ujn != vn1 {
-			var rhat Word
-			qhat, rhat = divWW(ujn, u[j+n-1], vn1, rec)
-
-			// x1 | x2 = q̂v_{n-2}
-			vn2 := v[n-2]
-			x1, x2 := mulWW(qhat, vn2)
-			// test if q̂v_{n-2} > br̂ + u_{j+n-2}
-			ujn2 := u[j+n-2]
-			for greaterThan(x1, x2, rhat, ujn2) {
-				qhat--
-				prevRhat := rhat
-				rhat += vn1
-				// v[n-1] >= 0, so this tests for overflow.
-				if rhat < prevRhat {
-					break
-				}
-				x1, x2 = mulWW(qhat, vn2)
-			}
-		}
-
-		// D4.
-		// Compute the remainder u - (q̂*v) << (_W*j).
-		// The subtraction may overflow if q̂ estimate was off by one.
-		qhatv[n] = mulAddVWW(qhatv[0:n], v, qhat, 0)
-		qhl := len(qhatv)
-		if j+qhl > len(u) && qhatv[n] == 0 {
-			qhl--
-		}
-		c := subVV(u[j:j+qhl], u[j:], qhatv)
-		if c != 0 {
-			c := addVV(u[j:j+n], u[j:], v)
-			// If n == qhl, the carry from subVV and the carry from addVV
-			// cancel out and don't affect u[j+n].
-			if n < qhl {
-				u[j+n] += c
-			}
-			qhat--
-		}
-
-		if j == m && m == len(q) && qhat == 0 {
-			continue
-		}
-		q[j] = qhat
-	}
-
-	putNat(qhatvp)
-}
-
-const divRecursiveThreshold = 100
-
-// divRecursive performs word-by-word division of u by v.
-// The quotient is written in pre-allocated z.
-// The remainder overwrites input u.
-//
-// Precondition:
-// - len(z) >= len(u)-len(v)
-//
-// See Burnikel, Ziegler, "Fast Recursive Division", Algorithm 1 and 2.
-func (z nat) divRecursive(u, v nat) {
-	// Recursion depth is less than 2 log2(len(v))
-	// Allocate a slice of temporaries to be reused across recursion.
-	recDepth := 2 * bits.Len(uint(len(v)))
-	// large enough to perform Karatsuba on operands as large as v
-	tmp := getNat(3 * len(v))
-	temps := make([]*nat, recDepth)
-	z.clear()
-	z.divRecursiveStep(u, v, 0, tmp, temps)
-	for _, n := range temps {
-		if n != nil {
-			putNat(n)
-		}
-	}
-	putNat(tmp)
-}
-
-// divRecursiveStep computes the division of u by v.
-// - z must be large enough to hold the quotient
-// - the quotient will overwrite z
-// - the remainder will overwrite u
-func (z nat) divRecursiveStep(u, v nat, depth int, tmp *nat, temps []*nat) {
-	u = u.norm()
-	v = v.norm()
-
-	if len(u) == 0 {
-		z.clear()
-		return
-	}
-	n := len(v)
-	if n < divRecursiveThreshold {
-		z.divBasic(u, v)
-		return
-	}
-	m := len(u) - n
-	if m < 0 {
-		return
-	}
-
-	// Produce the quotient by blocks of B words.
-	// Division by v (length n) is done using a length n/2 division
-	// and a length n/2 multiplication for each block. The final
-	// complexity is driven by multiplication complexity.
-	B := n / 2
-
-	// Allocate a nat for qhat below.
-	if temps[depth] == nil {
-		temps[depth] = getNat(n)
-	} else {
-		*temps[depth] = temps[depth].make(B + 1)
-	}
-
-	j := m
-	for j > B {
-		// Divide u[j-B:j+n] by vIn. Keep remainder in u
-		// for next block.
-		//
-		// The following property will be used (Lemma 2):
-		// if u = u1 << s + u0
-		//    v = v1 << s + v0
-		// then floor(u1/v1) >= floor(u/v)
-		//
-		// Moreover, the difference is at most 2 if len(v1) >= len(u/v)
-		// We choose s = B-1 since len(v)-s >= B+1 >= len(u/v)
-		s := (B - 1)
-		// Except for the first step, the top bits are always
-		// a division remainder, so the quotient length is <= n.
-		uu := u[j-B:]
-
-		qhat := *temps[depth]
-		qhat.clear()
-		qhat.divRecursiveStep(uu[s:B+n], v[s:], depth+1, tmp, temps)
-		qhat = qhat.norm()
-		// Adjust the quotient:
-		//    u = u_h << s + u_l
-		//    v = v_h << s + v_l
-		//  u_h = q̂ v_h + rh
-		//    u = q̂ (v - v_l) + rh << s + u_l
-		// After the above step, u contains a remainder:
-		//    u = rh << s + u_l
-		// and we need to subtract q̂ v_l
-		//
-		// But it may be a bit too large, in which case q̂ needs to be smaller.
-		qhatv := tmp.make(3 * n)
-		qhatv.clear()
-		qhatv = qhatv.mul(qhat, v[:s])
-		for i := 0; i < 2; i++ {
-			e := qhatv.cmp(uu.norm())
-			if e <= 0 {
-				break
-			}
-			subVW(qhat, qhat, 1)
-			c := subVV(qhatv[:s], qhatv[:s], v[:s])
-			if len(qhatv) > s {
-				subVW(qhatv[s:], qhatv[s:], c)
-			}
-			addAt(uu[s:], v[s:], 0)
-		}
-		if qhatv.cmp(uu.norm()) > 0 {
-			panic("impossible")
-		}
-		c := subVV(uu[:len(qhatv)], uu[:len(qhatv)], qhatv)
-		if c > 0 {
-			subVW(uu[len(qhatv):], uu[len(qhatv):], c)
-		}
-		addAt(z, qhat, j-B)
-		j -= B
-	}
-
-	// Now u < (v<<B), compute lower bits in the same way.
-	// Choose shift = B-1 again.
-	s := B - 1
-	qhat := *temps[depth]
-	qhat.clear()
-	qhat.divRecursiveStep(u[s:].norm(), v[s:], depth+1, tmp, temps)
-	qhat = qhat.norm()
-	qhatv := tmp.make(3 * n)
-	qhatv.clear()
-	qhatv = qhatv.mul(qhat, v[:s])
-	// Set the correct remainder as before.
-	for i := 0; i < 2; i++ {
-		if e := qhatv.cmp(u.norm()); e > 0 {
-			subVW(qhat, qhat, 1)
-			c := subVV(qhatv[:s], qhatv[:s], v[:s])
-			if len(qhatv) > s {
-				subVW(qhatv[s:], qhatv[s:], c)
-			}
-			addAt(u[s:], v[s:], 0)
-		}
-	}
-	if qhatv.cmp(u.norm()) > 0 {
-		panic("impossible")
-	}
-	c := subVV(u[0:len(qhatv)], u[0:len(qhatv)], qhatv)
-	if c > 0 {
-		c = subVW(u[len(qhatv):], u[len(qhatv):], c)
-	}
-	if c > 0 {
-		panic("impossible")
-	}
-
-	// Done!
-	addAt(z, qhat.norm(), 0)
-}
-
 // Length of x in bits. x must be normalized.
 func (x nat) bitLen() int {
 	if i := len(x) - 1; i >= 0 {
@@ -1170,19 +858,6 @@ func (z nat) xor(x, y nat) nat {
 	return z.norm()
 }
 
-// greaterThan reports whether (x1<<_W + x2) > (y1<<_W + y2)
-func greaterThan(x1, x2, y1, y2 Word) bool {
-	return x1 > y1 || x1 == y1 && x2 > y2
-}
-
-// modW returns x % d.
-func (x nat) modW(d Word) (r Word) {
-	// TODO(agl): we don't actually need to store the q value.
-	var q nat
-	q = q.make(len(x))
-	return divWVW(q, 0, x, d)
-}
-
 // random creates a random integer in [0..limit), using the space in z if
 // possible. n is the bit length of limit.
 func (z nat) random(rand *rand.Rand, limit nat, n int) nat {
diff --git a/src/math/big/natdiv.go b/src/math/big/natdiv.go
new file mode 100644
index 0000000000..1330990c2c
--- /dev/null
+++ b/src/math/big/natdiv.go
@@ -0,0 +1,346 @@
+// Copyright 2009 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 big
+
+import "math/bits"
+
+func (z nat) div(z2, u, v nat) (q, r nat) {
+	if len(v) == 0 {
+		panic("division by zero")
+	}
+
+	if u.cmp(v) < 0 {
+		q = z[:0]
+		r = z2.set(u)
+		return
+	}
+
+	if len(v) == 1 {
+		var r2 Word
+		q, r2 = z.divW(u, v[0])
+		r = z2.setWord(r2)
+		return
+	}
+
+	q, r = z.divLarge(z2, u, v)
+	return
+}
+
+// q = (x-r)/y, with 0 <= r < y
+func (z nat) divW(x nat, y Word) (q nat, r Word) {
+	m := len(x)
+	switch {
+	case y == 0:
+		panic("division by zero")
+	case y == 1:
+		q = z.set(x) // result is x
+		return
+	case m == 0:
+		q = z[:0] // result is 0
+		return
+	}
+	// m > 0
+	z = z.make(m)
+	r = divWVW(z, 0, x, y)
+	q = z.norm()
+	return
+}
+
+// modW returns x % d.
+func (x nat) modW(d Word) (r Word) {
+	// TODO(agl): we don't actually need to store the q value.
+	var q nat
+	q = q.make(len(x))
+	return divWVW(q, 0, x, d)
+}
+
+func divWVW(z []Word, xn Word, x []Word, y Word) (r Word) {
+	r = xn
+	if len(x) == 1 {
+		qq, rr := bits.Div(uint(r), uint(x[0]), uint(y))
+		z[0] = Word(qq)
+		return Word(rr)
+	}
+	rec := reciprocalWord(y)
+	for i := len(z) - 1; i >= 0; i-- {
+		z[i], r = divWW(r, x[i], y, rec)
+	}
+	return r
+}
+
+// q = (uIn-r)/vIn, with 0 <= r < vIn
+// Uses z as storage for q, and u as storage for r if possible.
+// See Knuth, Volume 2, section 4.3.1, Algorithm D.
+// Preconditions:
+//    len(vIn) >= 2
+//    len(uIn) >= len(vIn)
+//    u must not alias z
+func (z nat) divLarge(u, uIn, vIn nat) (q, r nat) {
+	n := len(vIn)
+	m := len(uIn) - n
+
+	// D1.
+	shift := nlz(vIn[n-1])
+	// do not modify vIn, it may be used by another goroutine simultaneously
+	vp := getNat(n)
+	v := *vp
+	shlVU(v, vIn, shift)
+
+	// u may safely alias uIn or vIn, the value of uIn is used to set u and vIn was already used
+	u = u.make(len(uIn) + 1)
+	u[len(uIn)] = shlVU(u[0:len(uIn)], uIn, shift)
+
+	// z may safely alias uIn or vIn, both values were used already
+	if alias(z, u) {
+		z = nil // z is an alias for u - cannot reuse
+	}
+	q = z.make(m + 1)
+
+	if n < divRecursiveThreshold {
+		q.divBasic(u, v)
+	} else {
+		q.divRecursive(u, v)
+	}
+	putNat(vp)
+
+	q = q.norm()
+	shrVU(u, u, shift)
+	r = u.norm()
+
+	return q, r
+}
+
+// divBasic performs word-by-word division of u by v.
+// The quotient is written in pre-allocated q.
+// The remainder overwrites input u.
+//
+// Precondition:
+// - q is large enough to hold the quotient u / v
+//   which has a maximum length of len(u)-len(v)+1.
+func (q nat) divBasic(u, v nat) {
+	n := len(v)
+	m := len(u) - n
+
+	qhatvp := getNat(n + 1)
+	qhatv := *qhatvp
+
+	// D2.
+	vn1 := v[n-1]
+	rec := reciprocalWord(vn1)
+	for j := m; j >= 0; j-- {
+		// D3.
+		qhat := Word(_M)
+		var ujn Word
+		if j+n < len(u) {
+			ujn = u[j+n]
+		}
+		if ujn != vn1 {
+			var rhat Word
+			qhat, rhat = divWW(ujn, u[j+n-1], vn1, rec)
+
+			// x1 | x2 = q̂v_{n-2}
+			vn2 := v[n-2]
+			x1, x2 := mulWW(qhat, vn2)
+			// test if q̂v_{n-2} > br̂ + u_{j+n-2}
+			ujn2 := u[j+n-2]
+			for greaterThan(x1, x2, rhat, ujn2) {
+				qhat--
+				prevRhat := rhat
+				rhat += vn1
+				// v[n-1] >= 0, so this tests for overflow.
+				if rhat < prevRhat {
+					break
+				}
+				x1, x2 = mulWW(qhat, vn2)
+			}
+		}
+
+		// D4.
+		// Compute the remainder u - (q̂*v) << (_W*j).
+		// The subtraction may overflow if q̂ estimate was off by one.
+		qhatv[n] = mulAddVWW(qhatv[0:n], v, qhat, 0)
+		qhl := len(qhatv)
+		if j+qhl > len(u) && qhatv[n] == 0 {
+			qhl--
+		}
+		c := subVV(u[j:j+qhl], u[j:], qhatv)
+		if c != 0 {
+			c := addVV(u[j:j+n], u[j:], v)
+			// If n == qhl, the carry from subVV and the carry from addVV
+			// cancel out and don't affect u[j+n].
+			if n < qhl {
+				u[j+n] += c
+			}
+			qhat--
+		}
+
+		if j == m && m == len(q) && qhat == 0 {
+			continue
+		}
+		q[j] = qhat
+	}
+
+	putNat(qhatvp)
+}
+
+// greaterThan reports whether (x1<<_W + x2) > (y1<<_W + y2)
+func greaterThan(x1, x2, y1, y2 Word) bool {
+	return x1 > y1 || x1 == y1 && x2 > y2
+}
+
+const divRecursiveThreshold = 100
+
+// divRecursive performs word-by-word division of u by v.
+// The quotient is written in pre-allocated z.
+// The remainder overwrites input u.
+//
+// Precondition:
+// - len(z) >= len(u)-len(v)
+//
+// See Burnikel, Ziegler, "Fast Recursive Division", Algorithm 1 and 2.
+func (z nat) divRecursive(u, v nat) {
+	// Recursion depth is less than 2 log2(len(v))
+	// Allocate a slice of temporaries to be reused across recursion.
+	recDepth := 2 * bits.Len(uint(len(v)))
+	// large enough to perform Karatsuba on operands as large as v
+	tmp := getNat(3 * len(v))
+	temps := make([]*nat, recDepth)
+	z.clear()
+	z.divRecursiveStep(u, v, 0, tmp, temps)
+	for _, n := range temps {
+		if n != nil {
+			putNat(n)
+		}
+	}
+	putNat(tmp)
+}
+
+// divRecursiveStep computes the division of u by v.
+// - z must be large enough to hold the quotient
+// - the quotient will overwrite z
+// - the remainder will overwrite u
+func (z nat) divRecursiveStep(u, v nat, depth int, tmp *nat, temps []*nat) {
+	u = u.norm()
+	v = v.norm()
+
+	if len(u) == 0 {
+		z.clear()
+		return
+	}
+	n := len(v)
+	if n < divRecursiveThreshold {
+		z.divBasic(u, v)
+		return
+	}
+	m := len(u) - n
+	if m < 0 {
+		return
+	}
+
+	// Produce the quotient by blocks of B words.
+	// Division by v (length n) is done using a length n/2 division
+	// and a length n/2 multiplication for each block. The final
+	// complexity is driven by multiplication complexity.
+	B := n / 2
+
+	// Allocate a nat for qhat below.
+	if temps[depth] == nil {
+		temps[depth] = getNat(n)
+	} else {
+		*temps[depth] = temps[depth].make(B + 1)
+	}
+
+	j := m
+	for j > B {
+		// Divide u[j-B:j+n] by vIn. Keep remainder in u
+		// for next block.
+		//
+		// The following property will be used (Lemma 2):
+		// if u = u1 << s + u0
+		//    v = v1 << s + v0
+		// then floor(u1/v1) >= floor(u/v)
+		//
+		// Moreover, the difference is at most 2 if len(v1) >= len(u/v)
+		// We choose s = B-1 since len(v)-s >= B+1 >= len(u/v)
+		s := (B - 1)
+		// Except for the first step, the top bits are always
+		// a division remainder, so the quotient length is <= n.
+		uu := u[j-B:]
+
+		qhat := *temps[depth]
+		qhat.clear()
+		qhat.divRecursiveStep(uu[s:B+n], v[s:], depth+1, tmp, temps)
+		qhat = qhat.norm()
+		// Adjust the quotient:
+		//    u = u_h << s + u_l
+		//    v = v_h << s + v_l
+		//  u_h = q̂ v_h + rh
+		//    u = q̂ (v - v_l) + rh << s + u_l
+		// After the above step, u contains a remainder:
+		//    u = rh << s + u_l
+		// and we need to subtract q̂ v_l
+		//
+		// But it may be a bit too large, in which case q̂ needs to be smaller.
+		qhatv := tmp.make(3 * n)
+		qhatv.clear()
+		qhatv = qhatv.mul(qhat, v[:s])
+		for i := 0; i < 2; i++ {
+			e := qhatv.cmp(uu.norm())
+			if e <= 0 {
+				break
+			}
+			subVW(qhat, qhat, 1)
+			c := subVV(qhatv[:s], qhatv[:s], v[:s])
+			if len(qhatv) > s {
+				subVW(qhatv[s:], qhatv[s:], c)
+			}
+			addAt(uu[s:], v[s:], 0)
+		}
+		if qhatv.cmp(uu.norm()) > 0 {
+			panic("impossible")
+		}
+		c := subVV(uu[:len(qhatv)], uu[:len(qhatv)], qhatv)
+		if c > 0 {
+			subVW(uu[len(qhatv):], uu[len(qhatv):], c)
+		}
+		addAt(z, qhat, j-B)
+		j -= B
+	}
+
+	// Now u < (v<<B), compute lower bits in the same way.
+	// Choose shift = B-1 again.
+	s := B - 1
+	qhat := *temps[depth]
+	qhat.clear()
+	qhat.divRecursiveStep(u[s:].norm(), v[s:], depth+1, tmp, temps)
+	qhat = qhat.norm()
+	qhatv := tmp.make(3 * n)
+	qhatv.clear()
+	qhatv = qhatv.mul(qhat, v[:s])
+	// Set the correct remainder as before.
+	for i := 0; i < 2; i++ {
+		if e := qhatv.cmp(u.norm()); e > 0 {
+			subVW(qhat, qhat, 1)
+			c := subVV(qhatv[:s], qhatv[:s], v[:s])
+			if len(qhatv) > s {
+				subVW(qhatv[s:], qhatv[s:], c)
+			}
+			addAt(u[s:], v[s:], 0)
+		}
+	}
+	if qhatv.cmp(u.norm()) > 0 {
+		panic("impossible")
+	}
+	c := subVV(u[0:len(qhatv)], u[0:len(qhatv)], qhatv)
+	if c > 0 {
+		c = subVW(u[len(qhatv):], u[len(qhatv):], c)
+	}
+	if c > 0 {
+		panic("impossible")
+	}
+
+	// Done!
+	addAt(z, qhat.norm(), 0)
+}
-- 
GitLab


From bfd7798a6c756b22d7376db527339b41bf7f7327 Mon Sep 17 00:00:00 2001
From: tyltr <tylitianrui@126.com>
Date: Wed, 26 May 2021 15:41:27 +0000
Subject: [PATCH 2118/2400] runtime,cmd/link/internal/ld: fix typos

Change-Id: I558590cef7e2311aadbdcb4088033e350d3aae32
GitHub-Last-Rev: 513944a6238e0e32e2a2c266b70f7d50c9db508d
GitHub-Pull-Request: golang/go#46389
Reviewed-on: https://go-review.googlesource.com/c/go/+/322809
Reviewed-by: Cherry Mui <cherryyz@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/cmd/link/internal/ld/data.go | 2 +-
 src/runtime/malloc.go            | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/link/internal/ld/data.go b/src/cmd/link/internal/ld/data.go
index 223df63d9d..70fbb9dc4e 100644
--- a/src/cmd/link/internal/ld/data.go
+++ b/src/cmd/link/internal/ld/data.go
@@ -1550,7 +1550,7 @@ func (ctxt *Link) dodata(symGroupType []sym.SymKind) {
 
 	if ctxt.HeadType == objabi.Haix && ctxt.LinkMode == LinkExternal {
 		// These symbols must have the same alignment as their section.
-		// Otherwize, ld might change the layout of Go sections.
+		// Otherwise, ld might change the layout of Go sections.
 		ldr.SetSymAlign(ldr.Lookup("runtime.data", 0), state.dataMaxAlign[sym.SDATA])
 		ldr.SetSymAlign(ldr.Lookup("runtime.bss", 0), state.dataMaxAlign[sym.SBSS])
 	}
diff --git a/src/runtime/malloc.go b/src/runtime/malloc.go
index 81e5225883..2759bbdaf9 100644
--- a/src/runtime/malloc.go
+++ b/src/runtime/malloc.go
@@ -296,7 +296,7 @@ const (
 	// high addresses if viewed as unsigned).
 	//
 	// On aix/ppc64, this offset allows to keep the heapAddrBits to
-	// 48. Otherwize, it would be 60 in order to handle mmap addresses
+	// 48. Otherwise, it would be 60 in order to handle mmap addresses
 	// (in range 0x0a00000000000000 - 0x0afffffffffffff). But in this
 	// case, the memory reserved in (s *pageAlloc).init for chunks
 	// is causing important slowdowns.
-- 
GitLab


From 39da9ae5130afa58f8b9e4ea609a57d516bd78db Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 6 May 2021 22:28:37 -0400
Subject: [PATCH 2119/2400] go/types: ensure that Named.check is nilled out
 once it is expanded

To support lazy expansion of defined types, *Named holds on to a
*Checker field, which can pin the *Checker in memory. This can have
meaningful memory implications for applications that keep type
information around.

Ensure that the Checker field is nilled out for any Named types that are
instantiated during the type checking pass, by deferring a clean up to
'later' boundaries.

In testing this almost exactly offset the ~6% memory footprint increase
I observed with 1.17.

Fixes #45580

Change-Id: I8aa5bb777573a924afe36e79fa65f8729336bceb
Reviewed-on: https://go-review.googlesource.com/c/go/+/318849
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/decl.go     | 53 ++++++++++++++++++++++++++++++----------
 src/go/types/sanitize.go |  3 +++
 src/go/types/type.go     | 17 ++++++++++++-
 3 files changed, 59 insertions(+), 14 deletions(-)

diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index 5f38a346ce..9211febc6d 100644
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -577,15 +577,37 @@ func (check *Checker) varDecl(obj *Var, lhs []*Var, typ, init ast.Expr) {
 // n0.check != nil, the cycle is reported.
 func (n0 *Named) under() Type {
 	u := n0.underlying
-	if u == nil {
-		return Typ[Invalid]
+
+	if u == Typ[Invalid] {
+		return u
 	}
 
 	// If the underlying type of a defined type is not a defined
-	// type, then that is the desired underlying type.
+	// (incl. instance) type, then that is the desired underlying
+	// type.
+	switch u.(type) {
+	case nil:
+		return Typ[Invalid]
+	default:
+		// common case
+		return u
+	case *Named, *instance:
+		// handled below
+	}
+
+	if n0.check == nil {
+		panic("internal error: Named.check == nil but type is incomplete")
+	}
+
+	// Invariant: after this point n0 as well as any named types in its
+	// underlying chain should be set up when this function exits.
+	check := n0.check
+
+	// If we can't expand u at this point, it is invalid.
 	n := asNamed(u)
 	if n == nil {
-		return u // common case
+		n0.underlying = Typ[Invalid]
+		return n0.underlying
 	}
 
 	// Otherwise, follow the forward chain.
@@ -597,7 +619,16 @@ func (n0 *Named) under() Type {
 			u = Typ[Invalid]
 			break
 		}
-		n1 := asNamed(u)
+		var n1 *Named
+		switch u1 := u.(type) {
+		case *Named:
+			n1 = u1
+		case *instance:
+			n1, _ = u1.expand().(*Named)
+			if n1 == nil {
+				u = Typ[Invalid]
+			}
+		}
 		if n1 == nil {
 			break // end of chain
 		}
@@ -608,11 +639,7 @@ func (n0 *Named) under() Type {
 
 		if i, ok := seen[n]; ok {
 			// cycle
-			// TODO(rFindley) revert this to a method on Checker. Having a possibly
-			// nil Checker on Named and TypeParam is too subtle.
-			if n0.check != nil {
-				n0.check.cycleError(path[i:])
-			}
+			check.cycleError(path[i:])
 			u = Typ[Invalid]
 			break
 		}
@@ -622,8 +649,8 @@ func (n0 *Named) under() Type {
 		// We should never have to update the underlying type of an imported type;
 		// those underlying types should have been resolved during the import.
 		// Also, doing so would lead to a race condition (was issue #31749).
-		// Do this check always, not just in debug more (it's cheap).
-		if n0.check != nil && n.obj.pkg != n0.check.pkg {
+		// Do this check always, not just in debug mode (it's cheap).
+		if n.obj.pkg != check.pkg {
 			panic("internal error: imported type with unresolved underlying type")
 		}
 		n.underlying = u
@@ -665,7 +692,7 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *ast.TypeSpec, def *Named) {
 	} else {
 		// defined type declaration
 
-		named := &Named{check: check, obj: obj}
+		named := check.newNamed(obj, nil, nil)
 		def.setUnderlying(named)
 		obj.typ = named // make sure recursive type declarations terminate
 
diff --git a/src/go/types/sanitize.go b/src/go/types/sanitize.go
index 5970ab38c7..727ec173ea 100644
--- a/src/go/types/sanitize.go
+++ b/src/go/types/sanitize.go
@@ -135,6 +135,9 @@ func (s sanitizer) typ(typ Type) Type {
 		}
 
 	case *Named:
+		if debug && t.check != nil {
+			panic("internal error: Named.check != nil")
+		}
 		if orig := s.typ(t.orig); orig != t.orig {
 			t.orig = orig
 		}
diff --git a/src/go/types/type.go b/src/go/types/type.go
index 3303cfc077..3fdb2365a0 100644
--- a/src/go/types/type.go
+++ b/src/go/types/type.go
@@ -644,7 +644,7 @@ func (c *Chan) Elem() Type { return c.elem }
 
 // A Named represents a named (defined) type.
 type Named struct {
-	check      *Checker    // for Named.under implementation
+	check      *Checker    // for Named.under implementation; nilled once under has been called
 	info       typeInfo    // for cycle detection
 	obj        *TypeName   // corresponding declared object
 	orig       Type        // type (on RHS of declaration) this *Named type is derived of (for cycle reporting)
@@ -673,6 +673,21 @@ func (check *Checker) newNamed(obj *TypeName, underlying Type, methods []*Func)
 	if obj.typ == nil {
 		obj.typ = typ
 	}
+	// Ensure that typ is always expanded, at which point the check field can be
+	// nilled out.
+	//
+	// Note that currently we cannot nil out check inside typ.under(), because
+	// it's possible that typ is expanded multiple times.
+	//
+	// TODO(rFindley): clean this up so that under is the only function mutating
+	//                 named types.
+	check.later(func() {
+		switch typ.under().(type) {
+		case *Named, *instance:
+			panic("internal error: unexpanded underlying type")
+		}
+		typ.check = nil
+	})
 	return typ
 }
 
-- 
GitLab


From 55aefbb268d7d33ebf300ed5b1e38e55c10c8070 Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Wed, 19 May 2021 16:34:58 -0400
Subject: [PATCH 2120/2400] doc/go1.17: mention enabling frame pointer on all
 ARM64

Updates #44513.

Change-Id: I43e95de0423779b3311d96c56f7c8c1cc5be27b6
Reviewed-on: https://go-review.googlesource.com/c/go/+/321311
Trust: Cherry Mui <cherryyz@google.com>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
---
 doc/go1.17.html | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index bdde26bd10..5448b2af97 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -68,6 +68,14 @@ Do not send CLs removing the interior tags from such phrases.
   OpenBSD.
 </p>
 
+<h3 id="arm64">ARM64</h3>
+
+<p><!-- CL 288814 -->
+  Go programs now maintain stack frame pointers on the 64-bit ARM
+  architecture on all operating systems. Previously it maintained
+  stack frame pointers only on Linux, macOS, and iOS.
+</p>
+
 <p>
   TODO: complete the Ports section
 </p>
-- 
GitLab


From a92460fd2f5537bbd91a713ced00731d429563ac Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Wed, 26 May 2021 12:18:32 -0400
Subject: [PATCH 2121/2400] doc/go1.17: add release notes for runtime/metrics
 package

Updates #44513.

Change-Id: I571a791e9c76371be3b3f1a323f1ea8ff485cf0f
Reviewed-on: https://go-review.googlesource.com/c/go/+/322857
Trust: Cherry Mui <cherryyz@google.com>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 doc/go1.17.html | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 5448b2af97..da50935a61 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -496,6 +496,16 @@ Do not send CLs removing the interior tags from such phrases.
   </dd>
 </dl><!-- reflect -->
 
+<dl id="runtime/metrics"><dt><a href="/pkg/runtime/metrics">runtime/metrics</a></dt>
+  <dd>
+    <p><!-- CL 308933, CL 312431, CL 312909 -->
+      New metrics were added that track total bytes and objects allocated and freed.
+      A new metric tracking the distribution of goroutine scheduling latencies was
+      also added.
+    </p>
+  </dd>
+</dl><!-- runtime/metrics -->
+
 <dl id="strconv"><dt><a href="/pkg/strconv/">strconv</a></dt>
   <dd>
     <p><!-- CL 170079 -->
-- 
GitLab


From 02beecb3974e9010d2deefaf09266286b0c6f408 Mon Sep 17 00:00:00 2001
From: Damien Neil <dneil@google.com>
Date: Wed, 26 May 2021 13:43:15 -0700
Subject: [PATCH 2122/2400] mime: document use of the Shared MIME-Info Database

For #44513.
Fixes #46013.

Change-Id: I382603208aa94b66d5220cf0f418b8528a4e4148
Reviewed-on: https://go-review.googlesource.com/c/go/+/322892
Trust: Damien Neil <dneil@google.com>
Run-TryBot: Damien Neil <dneil@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 doc/go1.17.html  | 4 +++-
 src/mime/type.go | 6 ++++--
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index da50935a61..771e2a6c8d 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -408,7 +408,9 @@ Do not send CLs removing the interior tags from such phrases.
 <dl id="mime"><dt><a href="/pkg/mime/">mime</a></dt>
   <dd>
     <p><!-- CL 305230 -->
-      TODO: <a href="https://golang.org/cl/305230">https://golang.org/cl/305230</a>: support reading shared mime-info database on unix systems
+      On Unix systems, the table of MIME types is now read from the local system's
+      <a href="https://specifications.freedesktop.org/shared-mime-info-spec/shared-mime-info-spec-0.21.html">Shared MIME-info Database</a>
+      when available.
     </p>
   </dd>
 </dl><!-- mime -->
diff --git a/src/mime/type.go b/src/mime/type.go
index 9bbbf216a1..26424339af 100644
--- a/src/mime/type.go
+++ b/src/mime/type.go
@@ -96,9 +96,11 @@ func initMime() {
 // Extensions are looked up first case-sensitively, then case-insensitively.
 //
 // The built-in table is small but on unix it is augmented by the local
-// system's mime.types file(s) if available under one or more of these
-// names:
+// system's MIME-info database or mime.types file(s) if available under one or
+// more of these names:
 //
+//   /usr/local/share/mime/globs2
+//   /usr/share/mime/globs2
 //   /etc/mime.types
 //   /etc/apache2/mime.types
 //   /etc/apache/mime.types
-- 
GitLab


From 0fbecece98977f6d0578cef1e8f3ae00a54c8ac4 Mon Sep 17 00:00:00 2001
From: Damien Neil <dneil@google.com>
Date: Wed, 26 May 2021 11:12:43 -0700
Subject: [PATCH 2123/2400] doc/go1.17: document syscall changes

Fixes #46023

Change-Id: Ia63829d03afb0936862b16f0971175cbaa1095bc
Reviewed-on: https://go-review.googlesource.com/c/go/+/322890
Trust: Damien Neil <dneil@google.com>
Run-TryBot: Damien Neil <dneil@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 doc/go1.17.html | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 771e2a6c8d..194d3a0cd8 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -550,11 +550,16 @@ Do not send CLs removing the interior tags from such phrases.
 <dl id="syscall"><dt><a href="/pkg/syscall/">syscall</a></dt>
   <dd>
     <p><!-- CL 295371 -->
-      TODO: <a href="https://golang.org/cl/295371">https://golang.org/cl/295371</a>: do not overflow key memory in GetQueuedCompletionStatus
+    <p>
+      The <a href="/pkg/syscall/#GetQueuedCompletionStatus"><code>GetQueuedCompletionStatus</code></a> and
+      <a href="/pkg/syscall/#PostQueuedCompletionStatus"><code>PostQueuedCompletionStatus</code></a>
+      functions are now deprecated. These functions have incorrect signatures and are superseded by
+      equivalents in the <a href="https://godoc.org/golang.org/x/sys/windows"><code>golang.org/x/sys/windows</code></a> package.
     </p>
 
     <p><!-- CL 313653 -->
-      TODO: <a href="https://golang.org/cl/313653">https://golang.org/cl/313653</a>: restore signal mask after setting foreground process group
+      On Unix-like systems, the process group of a child process is now set with signals blocked.
+      This avoids sending a <code>SIGTTOU</code> to the child when the parent is in a background process group.
     </p>
   </dd>
 </dl><!-- syscall -->
-- 
GitLab


From 1d5298d46a695219ab4622ae5aa59898459fd0f5 Mon Sep 17 00:00:00 2001
From: Damien Neil <dneil@google.com>
Date: Wed, 26 May 2021 11:28:01 -0700
Subject: [PATCH 2124/2400] doc/go1.17: document net/... changes

For #44513.
Fixes #46014.
Fixes #46015.
Fixes #46016.
Fixes #46017.

Change-Id: I356483d68d07159281dfe2ea1e49430ddf200973
Reviewed-on: https://go-review.googlesource.com/c/go/+/322891
Trust: Damien Neil <dneil@google.com>
Run-TryBot: Damien Neil <dneil@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 doc/go1.17.html     | 23 +++++++++++++++++------
 src/os/pipe_test.go |  2 +-
 2 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 194d3a0cd8..8313c2bc57 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -418,15 +418,20 @@ Do not send CLs removing the interior tags from such phrases.
 <dl id="net"><dt><a href="/pkg/net/">net</a></dt>
   <dd>
     <p><!-- CL 272668 -->
-      TODO: <a href="https://golang.org/cl/272668">https://golang.org/cl/272668</a>: add IP.IsPrivate
+      The new method <a href="/pkg/net/#IP.IsPrivate"><code>IP.IsPrivate</code></a> reports whether an address is
+      a private IPv4 address according to <a href="http://tools.ietf.org/html/rfc1918">RFC 1918</a>
+      or a local IPv6 address according <a href="http://tools.ietf.org/html/rfc4193">RFC 4193</a>.
     </p>
 
     <p><!-- CL 301709 -->
-      TODO: <a href="https://golang.org/cl/301709">https://golang.org/cl/301709</a>: make go resolver aware of network parameter
+      The Go DNS resolver now only sends one DNS query when resolving an address for an IPv4-only or IPv6-only network,
+      rather than querying for both address families.
     </p>
 
     <p><!-- CL 307030 -->
-      TODO: <a href="https://golang.org/cl/307030">https://golang.org/cl/307030</a>: make ErrClosed and ParseError implement net.Error
+      The <a href="/pkg/net/#ErrClosed"><code>ErrClosed</code></a> sentinel error and
+      <a href="/pkg/net/#ParseError"><code>ParseError</code></a> error type now implement
+      the <a href="/pkg/net/#Error"><code>net.Error</code></a> interface.
     </p>
   </dd>
 </dl><!-- net -->
@@ -441,7 +446,9 @@ Do not send CLs removing the interior tags from such phrases.
     </p>
 
     <p><!-- CL 235437 -->
-      TODO: <a href="https://golang.org/cl/235437">https://golang.org/cl/235437</a>: add to deadlines only when positive
+      Setting the <a href="/pkg/net/http/#Server"><code>Server</code></a>
+      <code>ReadTimeout</code> or <code>WriteTimeout</code> fields to a negative value now indicates no timeout
+      rather than an immediate timeout.
     </p>
 
     <p><!-- CL 308952 -->
@@ -454,7 +461,10 @@ Do not send CLs removing the interior tags from such phrases.
 <dl id="net/http/httptest"><dt><a href="/pkg/net/http/httptest/">net/http/httptest</a></dt>
   <dd>
     <p><!-- CL 308950 -->
-      TODO: <a href="https://golang.org/cl/308950">https://golang.org/cl/308950</a>: panic on non-3 digit (XXX) status code in Recorder.WriteHeader
+      <a href="/pkg/net/http/httptest/#ResponseRecorder.WriteHeader"><code>ResponseRecorder.WriteHeader></code></a>
+      now panics when the provided code is not a valid three-digit HTTP status code.
+      This matches the behavior of <a href="/pkg/net/http/#ResponseWriter"><code>ResponseWriter></code></a>
+      implementations in the <a href="/pkg/net/http/"><code>net/http</code></a> package.
     </p>
   </dd>
 </dl><!-- net/http/httptest -->
@@ -462,7 +472,8 @@ Do not send CLs removing the interior tags from such phrases.
 <dl id="net/url"><dt><a href="/pkg/net/url/">net/url</a></dt>
   <dd>
     <p><!-- CL 314850 -->
-      TODO: <a href="https://golang.org/cl/314850">https://golang.org/cl/314850</a>: add Values.Has
+      The new method <a href="/pkg/net/url/#Values.Has"><code>Values.Has</code></a>
+      reports whether a query parameter is set.
     </p>
   </dd>
 </dl><!-- net/url -->
diff --git a/src/os/pipe_test.go b/src/os/pipe_test.go
index b663618502..b3d5380b8d 100644
--- a/src/os/pipe_test.go
+++ b/src/os/pipe_test.go
@@ -462,7 +462,7 @@ func TestFdReadRace(t *testing.T) {
 		// Give the other goroutine a chance to enter the Read.
 		// It doesn't matter if this occasionally fails, the test
 		// will still pass, it just won't test anything.
-		time.Sleep(10 * time.Millisecond)
+		//time.Sleep(10 * time.Millisecond)
 		r.Fd()
 
 		// The bug was that Fd would hang until Read timed out.
-- 
GitLab


From a62c08734f8e2fc5333036e3a069a55288d1f674 Mon Sep 17 00:00:00 2001
From: Damien Neil <dneil@google.com>
Date: Wed, 26 May 2021 15:44:46 -0700
Subject: [PATCH 2125/2400] src/os: revert accidentally submitted change

Change-Id: Ib34984a6bd0abc76266e8aac96f9f8ad8ae21d17
Reviewed-on: https://go-review.googlesource.com/c/go/+/322894
Trust: Damien Neil <dneil@google.com>
Run-TryBot: Damien Neil <dneil@google.com>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/os/pipe_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/os/pipe_test.go b/src/os/pipe_test.go
index b3d5380b8d..b663618502 100644
--- a/src/os/pipe_test.go
+++ b/src/os/pipe_test.go
@@ -462,7 +462,7 @@ func TestFdReadRace(t *testing.T) {
 		// Give the other goroutine a chance to enter the Read.
 		// It doesn't matter if this occasionally fails, the test
 		// will still pass, it just won't test anything.
-		//time.Sleep(10 * time.Millisecond)
+		time.Sleep(10 * time.Millisecond)
 		r.Fd()
 
 		// The bug was that Fd would hang until Read timed out.
-- 
GitLab


From 3075ffc93e962792ddf43b2a528ef19b1577ffb7 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Wed, 26 May 2021 15:17:27 -0700
Subject: [PATCH 2126/2400] os: deflake TestFdReadRace

The test would hang if the call to Fd set the pipe to be non-blocking
before the Read entered the first read system call. Avoid that problem
by writing data to the pipe to wake up the read.

For #24481
Fixes #44818

Change-Id: I0b798874c7b81e7308a38ebbf657efc4392ffacd
Reviewed-on: https://go-review.googlesource.com/c/go/+/322893
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Damien Neil <dneil@google.com>
---
 src/os/pipe_test.go | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/os/pipe_test.go b/src/os/pipe_test.go
index b663618502..41a1e9c78a 100644
--- a/src/os/pipe_test.go
+++ b/src/os/pipe_test.go
@@ -442,12 +442,14 @@ func TestFdReadRace(t *testing.T) {
 	defer r.Close()
 	defer w.Close()
 
-	c := make(chan bool)
+	const count = 10
+
+	c := make(chan bool, 1)
 	var wg sync.WaitGroup
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
-		var buf [10]byte
+		var buf [count]byte
 		r.SetReadDeadline(time.Now().Add(time.Minute))
 		c <- true
 		if _, err := r.Read(buf[:]); os.IsTimeout(err) {
@@ -466,8 +468,9 @@ func TestFdReadRace(t *testing.T) {
 		r.Fd()
 
 		// The bug was that Fd would hang until Read timed out.
-		// If the bug is fixed, then closing r here will cause
-		// the Read to exit before the timeout expires.
+		// If the bug is fixed, then writing to w and closing r here
+		// will cause the Read to exit before the timeout expires.
+		w.Write(make([]byte, count))
 		r.Close()
 	}()
 
-- 
GitLab


From 6ff0ae2aa4fdb9c6c267efb30927e87563387c49 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Thu, 13 May 2021 13:45:55 -0400
Subject: [PATCH 2127/2400] crypto/elliptic: fix typo in p521Point type name

Change-Id: I6cab3624c875d9a70441a560e84f91c9b2df17b9
Reviewed-on: https://go-review.googlesource.com/c/go/+/320070
Trust: Filippo Valsorda <filippo@golang.org>
Trust: Katie Hockman <katie@golang.org>
Run-TryBot: Filippo Valsorda <filippo@golang.org>
Run-TryBot: Katie Hockman <katie@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
---
 src/crypto/elliptic/p521.go | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/crypto/elliptic/p521.go b/src/crypto/elliptic/p521.go
index ce74e0539c..3d355943ec 100644
--- a/src/crypto/elliptic/p521.go
+++ b/src/crypto/elliptic/p521.go
@@ -52,7 +52,7 @@ func (curve p521Curve) IsOnCurve(x, y *big.Int) bool {
 	return x3.Equal(y2) == 1
 }
 
-type p512Point struct {
+type p521Point struct {
 	x, y, z *fiat.P521Element
 }
 
@@ -67,7 +67,7 @@ func fiatP521ToBigInt(x *fiat.P521Element) *big.Int {
 // affineFromJacobian brings a point in Jacobian coordinates back to affine
 // coordinates, with (0, 0) representing infinity by convention. It also goes
 // back to big.Int values to match the exposed API.
-func (curve p521Curve) affineFromJacobian(p *p512Point) (x, y *big.Int) {
+func (curve p521Curve) affineFromJacobian(p *p521Point) (x, y *big.Int) {
 	if p.z.IsZero() == 1 {
 		return new(big.Int), new(big.Int)
 	}
@@ -99,17 +99,17 @@ func bigIntToFiatP521(x *big.Int) *fiat.P521Element {
 // jacobianFromAffine converts (x, y) affine coordinates into (x, y, z) Jacobian
 // coordinates. It also converts from big.Int to fiat, which is necessarily a
 // messy and variable-time operation, which we can't avoid due to the exposed API.
-func (curve p521Curve) jacobianFromAffine(x, y *big.Int) *p512Point {
+func (curve p521Curve) jacobianFromAffine(x, y *big.Int) *p521Point {
 	// (0, 0) is by convention the point at infinity, which can't be represented
 	// in affine coordinates, but is (0, 0, 0) in Jacobian.
 	if x.Sign() == 0 && y.Sign() == 0 {
-		return &p512Point{
+		return &p521Point{
 			x: new(fiat.P521Element),
 			y: new(fiat.P521Element),
 			z: new(fiat.P521Element),
 		}
 	}
-	return &p512Point{
+	return &p521Point{
 		x: bigIntToFiatP521(x),
 		y: bigIntToFiatP521(y),
 		z: new(fiat.P521Element).One(),
@@ -123,7 +123,7 @@ func (curve p521Curve) Add(x1, y1, x2, y2 *big.Int) (*big.Int, *big.Int) {
 }
 
 // addJacobian sets q = p1 + p2, and returns q. The points may overlap.
-func (q *p512Point) addJacobian(p1, p2 *p512Point) *p512Point {
+func (q *p521Point) addJacobian(p1, p2 *p521Point) *p521Point {
 	// https://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#addition-add-2007-bl
 	z1IsZero := p1.z.IsZero()
 	z2IsZero := p2.z.IsZero()
@@ -189,7 +189,7 @@ func (curve p521Curve) Double(x1, y1 *big.Int) (*big.Int, *big.Int) {
 }
 
 // doubleJacobian sets q = p + p, and returns q. The points may overlap.
-func (q *p512Point) doubleJacobian(p *p512Point) *p512Point {
+func (q *p521Point) doubleJacobian(p *p521Point) *p521Point {
 	// https://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#doubling-dbl-2001-b
 	delta := new(fiat.P521Element).Square(p.z)
 	gamma := new(fiat.P521Element).Square(p.y)
@@ -230,11 +230,11 @@ func (q *p512Point) doubleJacobian(p *p512Point) *p512Point {
 
 func (curve p521Curve) ScalarMult(Bx, By *big.Int, scalar []byte) (*big.Int, *big.Int) {
 	B := curve.jacobianFromAffine(Bx, By)
-	p, t := &p512Point{
+	p, t := &p521Point{
 		x: new(fiat.P521Element),
 		y: new(fiat.P521Element),
 		z: new(fiat.P521Element),
-	}, &p512Point{
+	}, &p521Point{
 		x: new(fiat.P521Element),
 		y: new(fiat.P521Element),
 		z: new(fiat.P521Element),
-- 
GitLab


From 9bc52686da81b515cf3ad654dfb1a536fabceafa Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Tue, 25 May 2021 12:21:11 -0400
Subject: [PATCH 2128/2400] cmd/go,cmd/link: do not check for staleness in most
 tests

Instead, check that stale packages in the standard library
are not rebuilt when already present in the build cache,
and are not installed implicitly when rebuilt.

We retain the staleness checks for the runtime package in tests
involving '-i', because those are guaranteed to fail anyway if the
package is stale and the "stale" failure message is arguably clearer.
They can be removed if/when we remove the '-i' flag, but the runtime
package is less likely to become stale because it does not have cgo
dependencies.

Fixes #46347
Updates #33598
Updates #35459
Updates #41696

Change-Id: I7b0a808addd930f9f4911ff53ded62272af75a40
Reviewed-on: https://go-review.googlesource.com/c/go/+/322629
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 ...build_package_not_stale_trailing_slash.txt | 13 -----
 src/cmd/go/testdata/script/cgo_stale.txt      | 39 ++++++++++++++
 src/cmd/go/testdata/script/list_std_stale.txt | 31 -----------
 .../go/testdata/script/list_std_vendor.txt    | 32 ++++++++++++
 .../testdata/script/test_race_install_cgo.txt |  2 -
 src/cmd/go/testdata/script/toolexec.txt       |  6 +++
 src/cmd/link/dwarf_test.go                    | 52 +++++++++++++------
 7 files changed, 112 insertions(+), 63 deletions(-)
 delete mode 100644 src/cmd/go/testdata/script/build_package_not_stale_trailing_slash.txt
 create mode 100644 src/cmd/go/testdata/script/cgo_stale.txt
 delete mode 100644 src/cmd/go/testdata/script/list_std_stale.txt
 create mode 100644 src/cmd/go/testdata/script/list_std_vendor.txt

diff --git a/src/cmd/go/testdata/script/build_package_not_stale_trailing_slash.txt b/src/cmd/go/testdata/script/build_package_not_stale_trailing_slash.txt
deleted file mode 100644
index 38a151ef1f..0000000000
--- a/src/cmd/go/testdata/script/build_package_not_stale_trailing_slash.txt
+++ /dev/null
@@ -1,13 +0,0 @@
-# Tests Issue #12690
-
-[gccgo] skip 'gccgo does not have GOROOT'
-
-! stale runtime
-! stale os
-! stale io
-
-env GOROOT=$GOROOT'/'
-
-! stale runtime
-! stale os
-! stale io
\ No newline at end of file
diff --git a/src/cmd/go/testdata/script/cgo_stale.txt b/src/cmd/go/testdata/script/cgo_stale.txt
new file mode 100644
index 0000000000..9e46855ead
--- /dev/null
+++ b/src/cmd/go/testdata/script/cgo_stale.txt
@@ -0,0 +1,39 @@
+# golang.org/issue/46347: a stale runtime/cgo should only force a single rebuild
+
+[!cgo] skip
+[short] skip
+
+
+# If we set a unique CGO_CFLAGS, the installed copy of runtime/cgo
+# should be reported as stale.
+
+env CGO_CFLAGS=-DTestScript_cgo_stale=true
+stale runtime/cgo
+
+
+# If we then build a package that uses cgo, runtime/cgo should be rebuilt and
+# cached with the new flag, but not installed to GOROOT (and thus still stale).
+
+env GOCACHE=$WORK/cache  # Use a fresh cache to avoid interference between runs.
+
+go build -x .
+stderr '[/\\]cgo'$GOEXE'["]? .* -importpath runtime/cgo'
+stale runtime/cgo
+
+
+# After runtime/cgo has been rebuilt and cached, it should not be rebuilt again
+# even though it is still reported as stale.
+
+go build -x .
+! stderr '[/\\]cgo'$GOEXE'["]? .* -importpath runtime/cgo'
+stale runtime/cgo
+
+
+-- go.mod --
+module example.com/m
+
+go 1.17
+-- m.go --
+package m
+
+import "C"
diff --git a/src/cmd/go/testdata/script/list_std_stale.txt b/src/cmd/go/testdata/script/list_std_stale.txt
deleted file mode 100644
index e5c1f334fd..0000000000
--- a/src/cmd/go/testdata/script/list_std_stale.txt
+++ /dev/null
@@ -1,31 +0,0 @@
-# https://golang.org/issue/44725: packages in std should not be reported as stale,
-# regardless of whether they are listed from within or outside GOROOT/src.
-
-# Control case: net should not be stale at the start of the test,
-# and should depend on vendor/golang.org/… instead of golang.org/….
-
-! stale net
-
-go list -deps net
-stdout '^vendor/golang.org/x/net'
-! stdout '^golang.org/x/net'
-
-# Net should also not be stale when viewed from within GOROOT/src,
-# and should still report the same package dependencies.
-
-cd $GOROOT/src
-! stale net
-
-go list -deps net
-stdout '^vendor/golang.org/x/net'
-! stdout '^golang.org/x/net'
-
-
-# However, 'go mod' and 'go get' subcommands should report the original module
-# dependencies, not the vendored packages.
-
-[!net] stop
-
-env GOPROXY=
-go mod why -m golang.org/x/net
-stdout '^# golang.org/x/net\nnet\ngolang.org/x/net'
diff --git a/src/cmd/go/testdata/script/list_std_vendor.txt b/src/cmd/go/testdata/script/list_std_vendor.txt
new file mode 100644
index 0000000000..8f27cc1e8d
--- /dev/null
+++ b/src/cmd/go/testdata/script/list_std_vendor.txt
@@ -0,0 +1,32 @@
+# https://golang.org/issue/44725: packages in std should have the same
+# dependencies regardless of whether they are listed from within or outside
+# GOROOT/src.
+
+# Control case: net, viewed from outside the 'std' module,
+# should depend on vendor/golang.org/… instead of golang.org/….
+
+go list -deps net
+stdout '^vendor/golang.org/x/net'
+! stdout '^golang.org/x/net'
+cp stdout $WORK/net-deps.txt
+
+
+# It should still report the same package dependencies when viewed from
+# within GOROOT/src.
+
+cd $GOROOT/src
+
+go list -deps net
+stdout '^vendor/golang.org/x/net'
+! stdout '^golang.org/x/net'
+cmp stdout $WORK/net-deps.txt
+
+
+# However, 'go mod' and 'go get' subcommands should report the original module
+# dependencies, not the vendored packages.
+
+[!net] stop
+
+env GOPROXY=
+go mod why -m golang.org/x/net
+stdout '^# golang.org/x/net\nnet\ngolang.org/x/net'
diff --git a/src/cmd/go/testdata/script/test_race_install_cgo.txt b/src/cmd/go/testdata/script/test_race_install_cgo.txt
index 3f4eb90e3f..e1fe4f2ace 100644
--- a/src/cmd/go/testdata/script/test_race_install_cgo.txt
+++ b/src/cmd/go/testdata/script/test_race_install_cgo.txt
@@ -2,8 +2,6 @@
 
 [!race] skip
 
-[!darwin] ! stale cmd/cgo  # The darwin builders are spuriously stale; see #33598.
-
 env GOBIN=$WORK/bin
 go install m/mtime m/sametime
 
diff --git a/src/cmd/go/testdata/script/toolexec.txt b/src/cmd/go/testdata/script/toolexec.txt
index 4f26da6d26..bb86467942 100644
--- a/src/cmd/go/testdata/script/toolexec.txt
+++ b/src/cmd/go/testdata/script/toolexec.txt
@@ -3,6 +3,12 @@
 # Build our simple toolexec program.
 go build ./cmd/mytool
 
+# Use an ephemeral build cache so that our toolexec output is not cached
+# for any stale standard-library dependencies.
+#
+# TODO(#27628): This should not be necessary.
+env GOCACHE=$WORK/gocache
+
 # Build the main package with our toolexec program. For each action, it will
 # print the tool's name and the TOOLEXEC_IMPORTPATH value. We expect to compile
 # each package once, and link the main package once.
diff --git a/src/cmd/link/dwarf_test.go b/src/cmd/link/dwarf_test.go
index 0419613cbe..3ca59bd47f 100644
--- a/src/cmd/link/dwarf_test.go
+++ b/src/cmd/link/dwarf_test.go
@@ -19,6 +19,36 @@ import (
 	"testing"
 )
 
+// TestMain allows this test binary to run as a -toolexec wrapper for the 'go'
+// command. If LINK_TEST_TOOLEXEC is set, TestMain runs the binary as if it were
+// cmd/link, and otherwise runs the requested tool as a subprocess.
+//
+// This allows the test to verify the behavior of the current contents of the
+// cmd/link package even if the installed cmd/link binary is stale.
+func TestMain(m *testing.M) {
+	if os.Getenv("LINK_TEST_TOOLEXEC") == "" {
+		// Not running as a -toolexec wrapper. Just run the tests.
+		os.Exit(m.Run())
+	}
+
+	if strings.TrimSuffix(filepath.Base(os.Args[1]), ".exe") == "link" {
+		// Running as a -toolexec linker, and the tool is cmd/link.
+		// Substitute this test binary for the linker.
+		os.Args = os.Args[1:]
+		main()
+		os.Exit(0)
+	}
+
+	cmd := exec.Command(os.Args[1], os.Args[2:]...)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	if err := cmd.Run(); err != nil {
+		os.Exit(1)
+	}
+	os.Exit(0)
+}
+
 func testDWARF(t *testing.T, buildmode string, expectDWARF bool, env ...string) {
 	testenv.MustHaveCGO(t)
 	testenv.MustHaveGoBuild(t)
@@ -29,17 +59,6 @@ func testDWARF(t *testing.T, buildmode string, expectDWARF bool, env ...string)
 
 	t.Parallel()
 
-	out, err := exec.Command(testenv.GoToolPath(t), "list", "-f", "{{.Stale}}", "cmd/link").CombinedOutput()
-	if err != nil {
-		t.Fatalf("go list: %v\n%s", err, out)
-	}
-	if string(out) != "false\n" {
-		if strings.HasPrefix(testenv.Builder(), "darwin-") {
-			t.Skipf("cmd/link is spuriously stale on Darwin builders - see #33598")
-		}
-		t.Fatalf("cmd/link is stale - run go install cmd/link")
-	}
-
 	for _, prog := range []string{"testprog", "testprogcgo"} {
 		prog := prog
 		expectDWARF := expectDWARF
@@ -48,11 +67,11 @@ func testDWARF(t *testing.T, buildmode string, expectDWARF bool, env ...string)
 			if extld == "" {
 				extld = "gcc"
 			}
+			var err error
 			expectDWARF, err = cmddwarf.IsDWARFEnabledOnAIXLd(extld)
 			if err != nil {
 				t.Fatal(err)
 			}
-
 		}
 
 		t.Run(prog, func(t *testing.T) {
@@ -62,15 +81,14 @@ func testDWARF(t *testing.T, buildmode string, expectDWARF bool, env ...string)
 
 			exe := filepath.Join(tmpDir, prog+".exe")
 			dir := "../../runtime/testdata/" + prog
-			cmd := exec.Command(testenv.GoToolPath(t), "build", "-o", exe)
+			cmd := exec.Command(testenv.GoToolPath(t), "build", "-toolexec", os.Args[0], "-o", exe)
 			if buildmode != "" {
 				cmd.Args = append(cmd.Args, "-buildmode", buildmode)
 			}
 			cmd.Args = append(cmd.Args, dir)
-			if env != nil {
-				cmd.Env = append(os.Environ(), env...)
-				cmd.Env = append(cmd.Env, "CGO_CFLAGS=") // ensure CGO_CFLAGS does not contain any flags. Issue #35459
-			}
+			cmd.Env = append(os.Environ(), env...)
+			cmd.Env = append(cmd.Env, "CGO_CFLAGS=") // ensure CGO_CFLAGS does not contain any flags. Issue #35459
+			cmd.Env = append(cmd.Env, "LINK_TEST_TOOLEXEC=1")
 			out, err := cmd.CombinedOutput()
 			if err != nil {
 				t.Fatalf("go build -o %v %v: %v\n%s", exe, dir, err, out)
-- 
GitLab


From 950fa11c4cb01a145bb07eeb167d90a1846061b3 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Fri, 21 May 2021 14:02:30 -0400
Subject: [PATCH 2129/2400] net/http/httputil: always remove hop-by-hop headers

Previously, we'd fail to remove the Connection header from a request
like this:

    Connection:
    Connection: x-header

Fixes #46313
Fixes CVE-2021-33197

Change-Id: Ie3009e926ceecfa86dfa6bcc6fe14ff01086be7d
Reviewed-on: https://go-review.googlesource.com/c/go/+/321929
Run-TryBot: Filippo Valsorda <filippo@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
Trust: Katie Hockman <katie@golang.org>
Trust: Filippo Valsorda <filippo@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/net/http/httputil/reverseproxy.go      | 22 ++++----
 src/net/http/httputil/reverseproxy_test.go | 63 +++++++++++++++++++++-
 2 files changed, 70 insertions(+), 15 deletions(-)

diff --git a/src/net/http/httputil/reverseproxy.go b/src/net/http/httputil/reverseproxy.go
index 1432ee26d3..5d39955d62 100644
--- a/src/net/http/httputil/reverseproxy.go
+++ b/src/net/http/httputil/reverseproxy.go
@@ -253,22 +253,18 @@ func (p *ReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
 	// important is "Connection" because we want a persistent
 	// connection, regardless of what the client sent to us.
 	for _, h := range hopHeaders {
-		hv := outreq.Header.Get(h)
-		if hv == "" {
-			continue
-		}
-		if h == "Te" && hv == "trailers" {
-			// Issue 21096: tell backend applications that
-			// care about trailer support that we support
-			// trailers. (We do, but we don't go out of
-			// our way to advertise that unless the
-			// incoming client request thought it was
-			// worth mentioning)
-			continue
-		}
 		outreq.Header.Del(h)
 	}
 
+	// Issue 21096: tell backend applications that care about trailer support
+	// that we support trailers. (We do, but we don't go out of our way to
+	// advertise that unless the incoming client request thought it was worth
+	// mentioning.) Note that we look at req.Header, not outreq.Header, since
+	// the latter has passed through removeConnectionHeaders.
+	if httpguts.HeaderValuesContainsToken(req.Header["Te"], "trailers") {
+		outreq.Header.Set("Te", "trailers")
+	}
+
 	// After stripping all the hop-by-hop connection headers above, add back any
 	// necessary for protocol upgrades, such as for websockets.
 	if reqUpType != "" {
diff --git a/src/net/http/httputil/reverseproxy_test.go b/src/net/http/httputil/reverseproxy_test.go
index 22720caf93..1898ed8b8a 100644
--- a/src/net/http/httputil/reverseproxy_test.go
+++ b/src/net/http/httputil/reverseproxy_test.go
@@ -91,8 +91,9 @@ func TestReverseProxy(t *testing.T) {
 
 	getReq, _ := http.NewRequest("GET", frontend.URL, nil)
 	getReq.Host = "some-name"
-	getReq.Header.Set("Connection", "close")
-	getReq.Header.Set("Te", "trailers")
+	getReq.Header.Set("Connection", "close, TE")
+	getReq.Header.Add("Te", "foo")
+	getReq.Header.Add("Te", "bar, trailers")
 	getReq.Header.Set("Proxy-Connection", "should be deleted")
 	getReq.Header.Set("Upgrade", "foo")
 	getReq.Close = true
@@ -236,6 +237,64 @@ func TestReverseProxyStripHeadersPresentInConnection(t *testing.T) {
 	}
 }
 
+func TestReverseProxyStripEmptyConnection(t *testing.T) {
+	// See Issue 46313.
+	const backendResponse = "I am the backend"
+
+	// someConnHeader is some arbitrary header to be declared as a hop-by-hop header
+	// in the Request's Connection header.
+	const someConnHeader = "X-Some-Conn-Header"
+
+	backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if c := r.Header.Values("Connection"); len(c) != 0 {
+			t.Errorf("handler got header %q = %v; want empty", "Connection", c)
+		}
+		if c := r.Header.Get(someConnHeader); c != "" {
+			t.Errorf("handler got header %q = %q; want empty", someConnHeader, c)
+		}
+		w.Header().Add("Connection", "")
+		w.Header().Add("Connection", someConnHeader)
+		w.Header().Set(someConnHeader, "should be deleted")
+		io.WriteString(w, backendResponse)
+	}))
+	defer backend.Close()
+	backendURL, err := url.Parse(backend.URL)
+	if err != nil {
+		t.Fatal(err)
+	}
+	proxyHandler := NewSingleHostReverseProxy(backendURL)
+	frontend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		proxyHandler.ServeHTTP(w, r)
+		if c := r.Header.Get(someConnHeader); c != "should be deleted" {
+			t.Errorf("handler modified header %q = %q; want %q", someConnHeader, c, "should be deleted")
+		}
+	}))
+	defer frontend.Close()
+
+	getReq, _ := http.NewRequest("GET", frontend.URL, nil)
+	getReq.Header.Add("Connection", "")
+	getReq.Header.Add("Connection", someConnHeader)
+	getReq.Header.Set(someConnHeader, "should be deleted")
+	res, err := frontend.Client().Do(getReq)
+	if err != nil {
+		t.Fatalf("Get: %v", err)
+	}
+	defer res.Body.Close()
+	bodyBytes, err := io.ReadAll(res.Body)
+	if err != nil {
+		t.Fatalf("reading body: %v", err)
+	}
+	if got, want := string(bodyBytes), backendResponse; got != want {
+		t.Errorf("got body %q; want %q", got, want)
+	}
+	if c := res.Header.Get("Connection"); c != "" {
+		t.Errorf("handler got header %q = %q; want empty", "Connection", c)
+	}
+	if c := res.Header.Get(someConnHeader); c != "" {
+		t.Errorf("handler got header %q = %q; want empty", someConnHeader, c)
+	}
+}
+
 func TestXForwardedFor(t *testing.T) {
 	const prevForwardedFor = "client ip"
 	const backendResponse = "I am the backend"
-- 
GitLab


From fca7b8f3e690ec0562dd6ed609a8c7e6bef744c8 Mon Sep 17 00:00:00 2001
From: Roland Shoemaker <roland@golang.org>
Date: Thu, 27 May 2021 15:14:18 +0000
Subject: [PATCH 2130/2400] Revert "net: verify results from Lookup* are valid
 domain names"

This reverts commit c89f1224a544cde464fcb86e78ebb0cc97eedba2.

Reason for revert: reverting so we can apply follow-up fixes and do a single cherry pick.

Change-Id: I16c6283a0bcab056216f330fb98fa3b5f2b0780c
Reviewed-on: https://go-review.googlesource.com/c/go/+/323129
Reviewed-by: Katie Hockman <katie@golang.org>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
Trust: Katie Hockman <katie@golang.org>
Run-TryBot: Katie Hockman <katie@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/net/dnsclient_unix_test.go | 121 ---------------------------------
 src/net/lookup.go              |  98 +++-----------------------
 2 files changed, 8 insertions(+), 211 deletions(-)

diff --git a/src/net/dnsclient_unix_test.go b/src/net/dnsclient_unix_test.go
index 69a9b972f0..ec690a1c0c 100644
--- a/src/net/dnsclient_unix_test.go
+++ b/src/net/dnsclient_unix_test.go
@@ -1799,124 +1799,3 @@ func TestPTRandNonPTR(t *testing.T) {
 		t.Errorf("names = %q; want %q", names, want)
 	}
 }
-
-func TestCVE202133195(t *testing.T) {
-	fake := fakeDNSServer{
-		rh: func(n, _ string, q dnsmessage.Message, _ time.Time) (dnsmessage.Message, error) {
-			r := dnsmessage.Message{
-				Header: dnsmessage.Header{
-					ID:                 q.Header.ID,
-					Response:           true,
-					RCode:              dnsmessage.RCodeSuccess,
-					RecursionAvailable: true,
-				},
-				Questions: q.Questions,
-			}
-			switch q.Questions[0].Type {
-			case dnsmessage.TypeCNAME:
-				r.Answers = []dnsmessage.Resource{}
-			case dnsmessage.TypeA: // CNAME lookup uses a A/AAAA as a proxy
-				r.Answers = append(r.Answers,
-					dnsmessage.Resource{
-						Header: dnsmessage.ResourceHeader{
-							Name:   dnsmessage.MustNewName("<html>.golang.org."),
-							Type:   dnsmessage.TypeA,
-							Class:  dnsmessage.ClassINET,
-							Length: 4,
-						},
-						Body: &dnsmessage.AResource{
-							A: TestAddr,
-						},
-					},
-				)
-			case dnsmessage.TypeSRV:
-				n := q.Questions[0].Name
-				if n.String() == "_hdr._tcp.golang.org." {
-					n = dnsmessage.MustNewName("<html>.golang.org.")
-				}
-				r.Answers = append(r.Answers,
-					dnsmessage.Resource{
-						Header: dnsmessage.ResourceHeader{
-							Name:   n,
-							Type:   dnsmessage.TypeSRV,
-							Class:  dnsmessage.ClassINET,
-							Length: 4,
-						},
-						Body: &dnsmessage.SRVResource{
-							Target: dnsmessage.MustNewName("<html>.golang.org."),
-						},
-					},
-				)
-			case dnsmessage.TypeMX:
-				r.Answers = append(r.Answers,
-					dnsmessage.Resource{
-						Header: dnsmessage.ResourceHeader{
-							Name:   dnsmessage.MustNewName("<html>.golang.org."),
-							Type:   dnsmessage.TypeMX,
-							Class:  dnsmessage.ClassINET,
-							Length: 4,
-						},
-						Body: &dnsmessage.MXResource{
-							MX: dnsmessage.MustNewName("<html>.golang.org."),
-						},
-					},
-				)
-			case dnsmessage.TypeNS:
-				r.Answers = append(r.Answers,
-					dnsmessage.Resource{
-						Header: dnsmessage.ResourceHeader{
-							Name:   dnsmessage.MustNewName("<html>.golang.org."),
-							Type:   dnsmessage.TypeNS,
-							Class:  dnsmessage.ClassINET,
-							Length: 4,
-						},
-						Body: &dnsmessage.NSResource{
-							NS: dnsmessage.MustNewName("<html>.golang.org."),
-						},
-					},
-				)
-			case dnsmessage.TypePTR:
-				r.Answers = append(r.Answers,
-					dnsmessage.Resource{
-						Header: dnsmessage.ResourceHeader{
-							Name:   dnsmessage.MustNewName("<html>.golang.org."),
-							Type:   dnsmessage.TypePTR,
-							Class:  dnsmessage.ClassINET,
-							Length: 4,
-						},
-						Body: &dnsmessage.PTRResource{
-							PTR: dnsmessage.MustNewName("<html>.golang.org."),
-						},
-					},
-				)
-			}
-			return r, nil
-		},
-	}
-	r := Resolver{PreferGo: true, Dial: fake.DialContext}
-
-	_, err := r.LookupCNAME(context.Background(), "golang.org")
-	if expected := "lookup golang.org: CNAME target is invalid"; err.Error() != expected {
-		t.Errorf("LookupCNAME returned unexpected error, got %q, want %q", err.Error(), expected)
-	}
-	_, _, err = r.LookupSRV(context.Background(), "target", "tcp", "golang.org")
-	if expected := "lookup golang.org: SRV target is invalid"; err.Error() != expected {
-		t.Errorf("LookupSRV returned unexpected error, got %q, want %q", err.Error(), expected)
-	}
-	_, _, err = r.LookupSRV(context.Background(), "hdr", "tcp", "golang.org")
-	if expected := "lookup golang.org: SRV header name is invalid"; err.Error() != expected {
-		t.Errorf("LookupSRV returned unexpected error, got %q, want %q", err.Error(), expected)
-	}
-	_, err = r.LookupMX(context.Background(), "golang.org")
-	if expected := "lookup golang.org: MX target is invalid"; err.Error() != expected {
-		t.Errorf("LookupMX returned unexpected error, got %q, want %q", err.Error(), expected)
-	}
-	_, err = r.LookupNS(context.Background(), "golang.org")
-	if expected := "lookup golang.org: NS target is invalid"; err.Error() != expected {
-		t.Errorf("LookupNS returned unexpected error, got %q, want %q", err.Error(), expected)
-	}
-	_, err = r.LookupAddr(context.Background(), "1.2.3.4")
-	if expected := "lookup 1.2.3.4: PTR target is invalid"; err.Error() != expected {
-		t.Errorf("LookupAddr returned unexpected error, got %q, want %q", err.Error(), expected)
-	}
-}
diff --git a/src/net/lookup.go b/src/net/lookup.go
index 39d33796d5..03599503bd 100644
--- a/src/net/lookup.go
+++ b/src/net/lookup.go
@@ -396,9 +396,6 @@ func (r *Resolver) LookupPort(ctx context.Context, network, service string) (por
 // contain DNS "CNAME" records, as long as host resolves to
 // address records.
 //
-// The returned canonical name is validated to be a properly
-// formatted presentation-format domain name.
-//
 // LookupCNAME uses context.Background internally; to specify the context, use
 // Resolver.LookupCNAME.
 func LookupCNAME(host string) (cname string, err error) {
@@ -415,18 +412,8 @@ func LookupCNAME(host string) (cname string, err error) {
 // LookupCNAME does not return an error if host does not
 // contain DNS "CNAME" records, as long as host resolves to
 // address records.
-//
-// The returned canonical name is validated to be a properly
-// formatted presentation-format domain name.
-func (r *Resolver) LookupCNAME(ctx context.Context, host string) (string, error) {
-	cname, err := r.lookupCNAME(ctx, host)
-	if err != nil {
-		return "", err
-	}
-	if !isDomainName(cname) {
-		return "", &DNSError{Err: "CNAME target is invalid", Name: host}
-	}
-	return cname, nil
+func (r *Resolver) LookupCNAME(ctx context.Context, host string) (cname string, err error) {
+	return r.lookupCNAME(ctx, host)
 }
 
 // LookupSRV tries to resolve an SRV query of the given service,
@@ -438,9 +425,6 @@ func (r *Resolver) LookupCNAME(ctx context.Context, host string) (string, error)
 // That is, it looks up _service._proto.name. To accommodate services
 // publishing SRV records under non-standard names, if both service
 // and proto are empty strings, LookupSRV looks up name directly.
-//
-// The returned service names are validated to be properly
-// formatted presentation-format domain names.
 func LookupSRV(service, proto, name string) (cname string, addrs []*SRV, err error) {
 	return DefaultResolver.lookupSRV(context.Background(), service, proto, name)
 }
@@ -454,33 +438,12 @@ func LookupSRV(service, proto, name string) (cname string, addrs []*SRV, err err
 // That is, it looks up _service._proto.name. To accommodate services
 // publishing SRV records under non-standard names, if both service
 // and proto are empty strings, LookupSRV looks up name directly.
-//
-// The returned service names are validated to be properly
-// formatted presentation-format domain names.
-func (r *Resolver) LookupSRV(ctx context.Context, service, proto, name string) (string, []*SRV, error) {
-	cname, addrs, err := r.lookupSRV(ctx, service, proto, name)
-	if err != nil {
-		return "", nil, err
-	}
-	if cname != "" && !isDomainName(cname) {
-		return "", nil, &DNSError{Err: "SRV header name is invalid", Name: name}
-	}
-	for _, addr := range addrs {
-		if addr == nil {
-			continue
-		}
-		if !isDomainName(addr.Target) {
-			return "", nil, &DNSError{Err: "SRV target is invalid", Name: name}
-		}
-	}
-	return cname, addrs, nil
+func (r *Resolver) LookupSRV(ctx context.Context, service, proto, name string) (cname string, addrs []*SRV, err error) {
+	return r.lookupSRV(ctx, service, proto, name)
 }
 
 // LookupMX returns the DNS MX records for the given domain name sorted by preference.
 //
-// The returned mail server names are validated to be properly
-// formatted presentation-format domain names.
-//
 // LookupMX uses context.Background internally; to specify the context, use
 // Resolver.LookupMX.
 func LookupMX(name string) ([]*MX, error) {
@@ -488,30 +451,12 @@ func LookupMX(name string) ([]*MX, error) {
 }
 
 // LookupMX returns the DNS MX records for the given domain name sorted by preference.
-//
-// The returned mail server names are validated to be properly
-// formatted presentation-format domain names.
 func (r *Resolver) LookupMX(ctx context.Context, name string) ([]*MX, error) {
-	records, err := r.lookupMX(ctx, name)
-	if err != nil {
-		return nil, err
-	}
-	for _, mx := range records {
-		if mx == nil {
-			continue
-		}
-		if !isDomainName(mx.Host) {
-			return nil, &DNSError{Err: "MX target is invalid", Name: name}
-		}
-	}
-	return records, nil
+	return r.lookupMX(ctx, name)
 }
 
 // LookupNS returns the DNS NS records for the given domain name.
 //
-// The returned name server names are validated to be properly
-// formatted presentation-format domain names.
-//
 // LookupNS uses context.Background internally; to specify the context, use
 // Resolver.LookupNS.
 func LookupNS(name string) ([]*NS, error) {
@@ -519,23 +464,8 @@ func LookupNS(name string) ([]*NS, error) {
 }
 
 // LookupNS returns the DNS NS records for the given domain name.
-//
-// The returned name server names are validated to be properly
-// formatted presentation-format domain names.
 func (r *Resolver) LookupNS(ctx context.Context, name string) ([]*NS, error) {
-	records, err := r.lookupNS(ctx, name)
-	if err != nil {
-		return nil, err
-	}
-	for _, ns := range records {
-		if ns == nil {
-			continue
-		}
-		if !isDomainName(ns.Host) {
-			return nil, &DNSError{Err: "NS target is invalid", Name: name}
-		}
-	}
-	return records, nil
+	return r.lookupNS(ctx, name)
 }
 
 // LookupTXT returns the DNS TXT records for the given domain name.
@@ -565,18 +495,6 @@ func LookupAddr(addr string) (names []string, err error) {
 
 // LookupAddr performs a reverse lookup for the given address, returning a list
 // of names mapping to that address.
-//
-// The returned names are validated to be properly
-// formatted presentation-format domain names.
-func (r *Resolver) LookupAddr(ctx context.Context, addr string) ([]string, error) {
-	names, err := r.lookupAddr(ctx, addr)
-	if err != nil {
-		return nil, err
-	}
-	for _, name := range names {
-		if !isDomainName(name) {
-			return nil, &DNSError{Err: "PTR target is invalid", Name: addr}
-		}
-	}
-	return names, nil
+func (r *Resolver) LookupAddr(ctx context.Context, addr string) (names []string, err error) {
+	return r.lookupAddr(ctx, addr)
 }
-- 
GitLab


From 6b8c94b6c524710bc3290546176a0da2f7c8c9db Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 27 May 2021 12:35:01 -0400
Subject: [PATCH 2131/2400] go/types: guard against check==nil in newNamed

When importing generic named types, it is possible for Checker.newNamed
to be called during type instantiation when the Checker is nil.

In this case we should be able to safely skip this delayed expansion.

Updates #45580

Change-Id: I75422100464d57eba24642c93e06e8b47d904fc3
Reviewed-on: https://go-review.googlesource.com/c/go/+/322974
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/type.go | 22 ++++++++++------------
 1 file changed, 10 insertions(+), 12 deletions(-)

diff --git a/src/go/types/type.go b/src/go/types/type.go
index 3fdb2365a0..2660ce4408 100644
--- a/src/go/types/type.go
+++ b/src/go/types/type.go
@@ -661,11 +661,7 @@ func NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named {
 	if _, ok := underlying.(*Named); ok {
 		panic("types.NewNamed: underlying type must not be *Named")
 	}
-	typ := &Named{obj: obj, orig: underlying, underlying: underlying, methods: methods}
-	if obj.typ == nil {
-		obj.typ = typ
-	}
-	return typ
+	return (*Checker)(nil).newNamed(obj, underlying, methods)
 }
 
 func (check *Checker) newNamed(obj *TypeName, underlying Type, methods []*Func) *Named {
@@ -681,13 +677,15 @@ func (check *Checker) newNamed(obj *TypeName, underlying Type, methods []*Func)
 	//
 	// TODO(rFindley): clean this up so that under is the only function mutating
 	//                 named types.
-	check.later(func() {
-		switch typ.under().(type) {
-		case *Named, *instance:
-			panic("internal error: unexpanded underlying type")
-		}
-		typ.check = nil
-	})
+	if check != nil {
+		check.later(func() {
+			switch typ.under().(type) {
+			case *Named, *instance:
+				panic("internal error: unexpanded underlying type")
+			}
+			typ.check = nil
+		})
+	}
 	return typ
 }
 
-- 
GitLab


From db66e9e15d16cfdb555140b26a5f009fd0d23d0e Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Thu, 27 May 2021 10:11:42 -0400
Subject: [PATCH 2132/2400] cmd/link: accept Windows line-ending in
 TestTrampolineCgo

Apparently C printf emits "\r\n" on Windows. Accept that.

Change-Id: If87ba41435e3147d3892cfc3fe3a105b066ff0aa
Reviewed-on: https://go-review.googlesource.com/c/go/+/322973
Trust: Cherry Mui <cherryyz@google.com>
Run-TryBot: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/link/link_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/link/link_test.go b/src/cmd/link/link_test.go
index 8805ff1f02..4d6bc76aca 100644
--- a/src/cmd/link/link_test.go
+++ b/src/cmd/link/link_test.go
@@ -698,7 +698,7 @@ func TestTrampolineCgo(t *testing.T) {
 	if err != nil {
 		t.Errorf("executable failed to run: %v\n%s", err, out)
 	}
-	if string(out) != "hello\n" {
+	if string(out) != "hello\n" && string(out) != "hello\r\n" {
 		t.Errorf("unexpected output:\n%s", out)
 	}
 
@@ -717,7 +717,7 @@ func TestTrampolineCgo(t *testing.T) {
 	if err != nil {
 		t.Errorf("executable failed to run: %v\n%s", err, out)
 	}
-	if string(out) != "hello\n" {
+	if string(out) != "hello\n" && string(out) != "hello\r\n" {
 		t.Errorf("unexpected output:\n%s", out)
 	}
 }
-- 
GitLab


From 56af34f875f55485b4ebc521fe0c695dafb9bc23 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Tue, 25 May 2021 10:13:07 -0400
Subject: [PATCH 2133/2400] cmd/compile: place reg spills after
 OpArg{Int,Float}Reg ops

Tweak the register allocator to maintain the invariant that
OpArg{Int,Float}Reg values are placed together at the start of the
entry block, before any other non-pseudo-op values. Without this
change, when the register allocator adds spills we can wind up with an
interleaving of OpArg*Reg and stores, which complicates debug location
analysis.

Updates #40724.

Change-Id: Icf30dd814a9e25263ecbea2e48feb840a6e7f2bd
Reviewed-on: https://go-review.googlesource.com/c/go/+/322630
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/regalloc.go | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go
index c81d5574fe..3b90b8769c 100644
--- a/src/cmd/compile/internal/ssa/regalloc.go
+++ b/src/cmd/compile/internal/ssa/regalloc.go
@@ -1882,6 +1882,10 @@ func (s *regAllocState) placeSpills() {
 		phiRegs[b.ID] = m
 	}
 
+	mustBeFirst := func(op Op) bool {
+		return op.isLoweredGetClosurePtr() || op == OpPhi || op == OpArgIntReg || op == OpArgFloatReg
+	}
+
 	// Start maps block IDs to the list of spills
 	// that go at the start of the block (but after any phis).
 	start := map[ID][]*Value{}
@@ -1971,7 +1975,7 @@ func (s *regAllocState) placeSpills() {
 		// Put the spill in the best block we found.
 		spill.Block = best
 		spill.AddArg(bestArg)
-		if best == v.Block && v.Op != OpPhi {
+		if best == v.Block && !mustBeFirst(v.Op) {
 			// Place immediately after v.
 			after[v.ID] = append(after[v.ID], spill)
 		} else {
@@ -1983,15 +1987,15 @@ func (s *regAllocState) placeSpills() {
 	// Insert spill instructions into the block schedules.
 	var oldSched []*Value
 	for _, b := range s.visitOrder {
-		nphi := 0
+		nfirst := 0
 		for _, v := range b.Values {
-			if v.Op != OpPhi {
+			if !mustBeFirst(v.Op) {
 				break
 			}
-			nphi++
+			nfirst++
 		}
-		oldSched = append(oldSched[:0], b.Values[nphi:]...)
-		b.Values = b.Values[:nphi]
+		oldSched = append(oldSched[:0], b.Values[nfirst:]...)
+		b.Values = b.Values[:nfirst]
 		b.Values = append(b.Values, start[b.ID]...)
 		for _, v := range oldSched {
 			b.Values = append(b.Values, v)
-- 
GitLab


From 8bf5bf51738a198902e03bbec7e6ff220f4cb002 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Mon, 10 May 2021 07:31:57 -0400
Subject: [PATCH 2134/2400] cmd/compile: improve debug locations for partially
 live in-params

During DWARF debug location generation, as a preamble to the main data
flow analysis, examine the function entry block to look for in-params
arriving in registers that are partially or completely dead, and
insert new OpArg{Int,Float}Reg values for the dead or partially-dead
pieces. In addition, add entries to the f.NamedValues table for
incoming live register-resident params that don't already have
entries. This helps create better/saner DWARF location expressions for
params. Example:

  func foo(s string, used int, notused int) int {
      return len(s) + used
  }

When optimization is complete for this function, the parameter
"notused" is completely dead, meaning that there is no entry for it in
the f.NamedValues table (which then means we don't emit a DWARF
variable location expression for it in the function enty block). In
addition, since only the length field of "s" is used, there is no
DWARF location expression for the other component of "s", leading to
degraded DWARF.

There are still problems/issues with DWARF location generation, but
this does improve things with respect to being able to print the
values of incoming parameters when stopped in the debugger at the
entry point of a function (when optimization is enabled).

Updates #40724.

Change-Id: I5bb5253648942f9fd33b081fe1a5a36208e75785
Reviewed-on: https://go-review.googlesource.com/c/go/+/322631
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 src/cmd/compile/internal/ssa/debug.go | 217 ++++++++++++++++++++++++++
 1 file changed, 217 insertions(+)

diff --git a/src/cmd/compile/internal/ssa/debug.go b/src/cmd/compile/internal/ssa/debug.go
index a2c2a2d98e..eaa94975ec 100644
--- a/src/cmd/compile/internal/ssa/debug.go
+++ b/src/cmd/compile/internal/ssa/debug.go
@@ -7,10 +7,13 @@ package ssa
 import (
 	"cmd/compile/internal/abi"
 	"cmd/compile/internal/ir"
+	"cmd/compile/internal/types"
 	"cmd/internal/dwarf"
 	"cmd/internal/obj"
+	"cmd/internal/src"
 	"encoding/hex"
 	"fmt"
+	"internal/buildcfg"
 	"math/bits"
 	"sort"
 	"strings"
@@ -335,6 +338,216 @@ func (s *debugState) stateString(state stateAtPC) string {
 	return strings.Join(strs, "")
 }
 
+// slotCanonicalizer is a table used to lookup and canonicalize
+// LocalSlot's in a type insensitive way (e.g. taking into account the
+// base name, offset, and width of the slot, but ignoring the slot
+// type).
+type slotCanonicalizer struct {
+	slmap  map[slotKey]SlKeyIdx
+	slkeys []LocalSlot
+}
+
+func newSlotCanonicalizer() *slotCanonicalizer {
+	return &slotCanonicalizer{
+		slmap:  make(map[slotKey]SlKeyIdx),
+		slkeys: []LocalSlot{LocalSlot{N: nil}},
+	}
+}
+
+type SlKeyIdx uint32
+
+const noSlot = SlKeyIdx(0)
+
+// slotKey is a type-insensitive encapsulation of a LocalSlot; it
+// is used to key a map within slotCanonicalizer.
+type slotKey struct {
+	name        *ir.Name
+	offset      int64
+	width       int64
+	splitOf     SlKeyIdx // idx in slkeys slice in slotCanonicalizer
+	splitOffset int64
+}
+
+// lookup looks up a LocalSlot in the slot canonicalizer "sc", returning
+// a canonical index for the slot, and adding it to the table if need
+// be. Return value is the canonical slot index, and a boolean indicating
+// whether the slot was found in the table already (TRUE => found).
+func (sc *slotCanonicalizer) lookup(ls LocalSlot) (SlKeyIdx, bool) {
+	split := noSlot
+	if ls.SplitOf != nil {
+		split, _ = sc.lookup(*ls.SplitOf)
+	}
+	k := slotKey{
+		name: ls.N, offset: ls.Off, width: ls.Type.Width,
+		splitOf: split, splitOffset: ls.SplitOffset,
+	}
+	if idx, ok := sc.slmap[k]; ok {
+		return idx, true
+	}
+	rv := SlKeyIdx(len(sc.slkeys))
+	sc.slkeys = append(sc.slkeys, ls)
+	sc.slmap[k] = rv
+	return rv, false
+}
+
+func (sc *slotCanonicalizer) canonSlot(idx SlKeyIdx) LocalSlot {
+	return sc.slkeys[idx]
+}
+
+// PopulateABIInRegArgOps examines the entry block of the function
+// and looks for incoming parameters that have missing or partial
+// OpArg{Int,Float}Reg values, inserting additional values in
+// cases where they are missing. Example:
+//
+//      func foo(s string, used int, notused int) int {
+//        return len(s) + used
+//      }
+//
+// In the function above, the incoming parameter "used" is fully live,
+// "notused" is not live, and "s" is partially live (only the length
+// field of the string is used). At the point where debug value
+// analysis runs, we might expect to see an entry block with:
+//
+//   b1:
+//     v4 = ArgIntReg <uintptr> {s+8} [0] : BX
+//     v5 = ArgIntReg <int> {used} [0] : CX
+//
+// While this is an accurate picture of the live incoming params,
+// we also want to have debug locations for non-live params (or
+// their non-live pieces), e.g. something like
+//
+//   b1:
+//     v9 = ArgIntReg <*uint8> {s+0} [0] : AX
+//     v4 = ArgIntReg <uintptr> {s+8} [0] : BX
+//     v5 = ArgIntReg <int> {used} [0] : CX
+//     v10 = ArgIntReg <int> {unused} [0] : DI
+//
+// This function examines the live OpArg{Int,Float}Reg values and
+// synthesizes new (dead) values for the non-live params or the
+// non-live pieces of partially live params.
+//
+func PopulateABIInRegArgOps(f *Func) {
+	pri := f.ABISelf.ABIAnalyzeFuncType(f.Type.FuncType())
+
+	// When manufacturing new slots that correspond to splits of
+	// composite parameters, we want to avoid creating a new sub-slot
+	// that differs from some existing sub-slot only by type, since
+	// the debug location analysis will treat that slot as a separate
+	// entity. To achieve this, create a lookup table of existing
+	// slots that is type-insenstitive.
+	sc := newSlotCanonicalizer()
+	for _, sl := range f.Names {
+		sc.lookup(*sl)
+	}
+
+	// Add slot -> value entry to f.NamedValues if not already present.
+	addToNV := func(v *Value, sl LocalSlot) {
+		values, ok := f.NamedValues[sl]
+		if !ok {
+			// Haven't seen this slot yet.
+			sla := f.localSlotAddr(sl)
+			f.Names = append(f.Names, sla)
+		} else {
+			for _, ev := range values {
+				if v == ev {
+					return
+				}
+			}
+		}
+		values = append(values, v)
+		f.NamedValues[sl] = values
+	}
+
+	newValues := []*Value{}
+
+	abiRegIndexToRegister := func(reg abi.RegIndex) int8 {
+		i := f.ABISelf.FloatIndexFor(reg)
+		if i >= 0 { // float PR
+			return f.Config.floatParamRegs[i]
+		} else {
+			return f.Config.intParamRegs[reg]
+		}
+	}
+
+	// Helper to construct a new OpArg{Float,Int}Reg op value.
+	var pos src.XPos
+	if len(f.Entry.Values) != 0 {
+		pos = f.Entry.Values[0].Pos
+	}
+	synthesizeOpIntFloatArg := func(n *ir.Name, t *types.Type, reg abi.RegIndex, sl LocalSlot) *Value {
+		aux := &AuxNameOffset{n, sl.Off}
+		op, auxInt := ArgOpAndRegisterFor(reg, f.ABISelf)
+		v := f.newValueNoBlock(op, t, pos)
+		v.AuxInt = auxInt
+		v.Aux = aux
+		v.Args = nil
+		v.Block = f.Entry
+		newValues = append(newValues, v)
+		addToNV(v, sl)
+		f.setHome(v, &f.Config.registers[abiRegIndexToRegister(reg)])
+		return v
+	}
+
+	// Make a pass through the entry block looking for
+	// OpArg{Int,Float}Reg ops. Record the slots they use in a table
+	// ("sc"). We use a type-insensitive lookup for the slot table,
+	// since the type we get from the ABI analyzer won't always match
+	// what the compiler uses when creating OpArg{Int,Float}Reg ops.
+	for _, v := range f.Entry.Values {
+		if v.Op == OpArgIntReg || v.Op == OpArgFloatReg {
+			aux := v.Aux.(*AuxNameOffset)
+			sl := LocalSlot{N: aux.Name, Type: v.Type, Off: aux.Offset}
+			// install slot in lookup table
+			idx, _ := sc.lookup(sl)
+			// add to f.NamedValues if not already present
+			addToNV(v, sc.canonSlot(idx))
+		} else if v.Op.IsCall() {
+			// if we hit a call, we've gone too far.
+			break
+		}
+	}
+
+	// Now make a pass through the ABI in-params, looking for params
+	// or pieces of params that we didn't encounter in the loop above.
+	for _, inp := range pri.InParams() {
+		if !isNamedRegParam(inp) {
+			continue
+		}
+		n := inp.Name.(*ir.Name)
+
+		// Param is spread across one or more registers. Walk through
+		// each piece to see whether we've seen an arg reg op for it.
+		types, offsets := inp.RegisterTypesAndOffsets()
+		for k, t := range types {
+			// Note: this recipe for creating a LocalSlot is designed
+			// to be compatible with the one used in expand_calls.go
+			// as opposed to decompose.go. The expand calls code just
+			// takes the base name and creates an offset into it,
+			// without using the SplitOf/SplitOffset fields. The code
+			// in decompose.go does the opposite -- it creates a
+			// LocalSlot object with "Off" set to zero, but with
+			// SplitOf pointing to a parent slot, and SplitOffset
+			// holding the offset into the parent object.
+			pieceSlot := LocalSlot{N: n, Type: t, Off: offsets[k]}
+
+			// Look up this piece to see if we've seen a reg op
+			// for it. If not, create one.
+			_, found := sc.lookup(pieceSlot)
+			if !found {
+				// This slot doesn't appear in the map, meaning it
+				// corresponds to an in-param that is not live, or
+				// a portion of an in-param that is not live/used.
+				// Add a new dummy OpArg{Int,Float}Reg for it.
+				synthesizeOpIntFloatArg(n, t, inp.Registers[k],
+					pieceSlot)
+			}
+		}
+	}
+
+	// Insert the new values into the head of the block.
+	f.Entry.Values = append(newValues, f.Entry.Values...)
+}
+
 // BuildFuncDebug returns debug information for f.
 // f must be fully processed, so that each Value is where it will be when
 // machine code is emitted.
@@ -349,6 +562,10 @@ func BuildFuncDebug(ctxt *obj.Link, f *Func, loggingEnabled bool, stackOffset fu
 	state.stackOffset = stackOffset
 	state.ctxt = ctxt
 
+	if buildcfg.Experiment.RegabiArgs {
+		PopulateABIInRegArgOps(f)
+	}
+
 	if state.loggingEnabled {
 		state.logf("Generating location lists for function %q\n", f.Name)
 	}
-- 
GitLab


From cdcd02842da7c004efd023881e3719105209c908 Mon Sep 17 00:00:00 2001
From: Roland Shoemaker <roland@golang.org>
Date: Thu, 27 May 2021 10:40:06 -0700
Subject: [PATCH 2135/2400] net: verify results from Lookup* are valid domain
 names

For the methods LookupCNAME, LookupSRV, LookupMX, LookupNS, and
LookupAddr check that the returned domain names are in fact valid DNS
names using the existing isDomainName function.

Thanks to Philipp Jeitner and Haya Shulman from Fraunhofer SIT for
reporting this issue.

Fixes #46241
Fixes CVE-2021-33195

Change-Id: I47a4f58c031cb752f732e88bbdae7f819f0af4f3
Reviewed-on: https://go-review.googlesource.com/c/go/+/323131
Trust: Roland Shoemaker <roland@golang.org>
Run-TryBot: Roland Shoemaker <roland@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
---
 src/net/dnsclient_unix_test.go | 157 +++++++++++++++++++++++++++++++++
 src/net/lookup.go              | 111 ++++++++++++++++++++---
 2 files changed, 255 insertions(+), 13 deletions(-)

diff --git a/src/net/dnsclient_unix_test.go b/src/net/dnsclient_unix_test.go
index ec690a1c0c..a718e75a72 100644
--- a/src/net/dnsclient_unix_test.go
+++ b/src/net/dnsclient_unix_test.go
@@ -1799,3 +1799,160 @@ func TestPTRandNonPTR(t *testing.T) {
 		t.Errorf("names = %q; want %q", names, want)
 	}
 }
+
+func TestCVE202133195(t *testing.T) {
+	fake := fakeDNSServer{
+		rh: func(n, _ string, q dnsmessage.Message, _ time.Time) (dnsmessage.Message, error) {
+			r := dnsmessage.Message{
+				Header: dnsmessage.Header{
+					ID:                 q.Header.ID,
+					Response:           true,
+					RCode:              dnsmessage.RCodeSuccess,
+					RecursionAvailable: true,
+				},
+				Questions: q.Questions,
+			}
+			switch q.Questions[0].Type {
+			case dnsmessage.TypeCNAME:
+				r.Answers = []dnsmessage.Resource{}
+			case dnsmessage.TypeA: // CNAME lookup uses a A/AAAA as a proxy
+				r.Answers = append(r.Answers,
+					dnsmessage.Resource{
+						Header: dnsmessage.ResourceHeader{
+							Name:   dnsmessage.MustNewName("<html>.golang.org."),
+							Type:   dnsmessage.TypeA,
+							Class:  dnsmessage.ClassINET,
+							Length: 4,
+						},
+						Body: &dnsmessage.AResource{
+							A: TestAddr,
+						},
+					},
+				)
+			case dnsmessage.TypeSRV:
+				n := q.Questions[0].Name
+				if n.String() == "_hdr._tcp.golang.org." {
+					n = dnsmessage.MustNewName("<html>.golang.org.")
+				}
+				r.Answers = append(r.Answers,
+					dnsmessage.Resource{
+						Header: dnsmessage.ResourceHeader{
+							Name:   n,
+							Type:   dnsmessage.TypeSRV,
+							Class:  dnsmessage.ClassINET,
+							Length: 4,
+						},
+						Body: &dnsmessage.SRVResource{
+							Target: dnsmessage.MustNewName("<html>.golang.org."),
+						},
+					},
+				)
+			case dnsmessage.TypeMX:
+				r.Answers = append(r.Answers,
+					dnsmessage.Resource{
+						Header: dnsmessage.ResourceHeader{
+							Name:   dnsmessage.MustNewName("<html>.golang.org."),
+							Type:   dnsmessage.TypeMX,
+							Class:  dnsmessage.ClassINET,
+							Length: 4,
+						},
+						Body: &dnsmessage.MXResource{
+							MX: dnsmessage.MustNewName("<html>.golang.org."),
+						},
+					},
+				)
+			case dnsmessage.TypeNS:
+				r.Answers = append(r.Answers,
+					dnsmessage.Resource{
+						Header: dnsmessage.ResourceHeader{
+							Name:   dnsmessage.MustNewName("<html>.golang.org."),
+							Type:   dnsmessage.TypeNS,
+							Class:  dnsmessage.ClassINET,
+							Length: 4,
+						},
+						Body: &dnsmessage.NSResource{
+							NS: dnsmessage.MustNewName("<html>.golang.org."),
+						},
+					},
+				)
+			case dnsmessage.TypePTR:
+				r.Answers = append(r.Answers,
+					dnsmessage.Resource{
+						Header: dnsmessage.ResourceHeader{
+							Name:   dnsmessage.MustNewName("<html>.golang.org."),
+							Type:   dnsmessage.TypePTR,
+							Class:  dnsmessage.ClassINET,
+							Length: 4,
+						},
+						Body: &dnsmessage.PTRResource{
+							PTR: dnsmessage.MustNewName("<html>.golang.org."),
+						},
+					},
+				)
+			}
+			return r, nil
+		},
+	}
+
+	r := Resolver{PreferGo: true, Dial: fake.DialContext}
+	// Change the default resolver to match our manipulated resolver
+	originalDefault := DefaultResolver
+	DefaultResolver = &r
+	defer func() {
+		DefaultResolver = originalDefault
+	}()
+
+	_, err := r.LookupCNAME(context.Background(), "golang.org")
+	if expected := "lookup golang.org: CNAME target is invalid"; err == nil || err.Error() != expected {
+		t.Errorf("Resolver.LookupCNAME returned unexpected error, got %q, want %q", err.Error(), expected)
+	}
+	_, err = LookupCNAME("golang.org")
+	if expected := "lookup golang.org: CNAME target is invalid"; err == nil || err.Error() != expected {
+		t.Errorf("LookupCNAME returned unexpected error, got %q, want %q", err.Error(), expected)
+	}
+
+	_, _, err = r.LookupSRV(context.Background(), "target", "tcp", "golang.org")
+	if expected := "lookup golang.org: SRV target is invalid"; err == nil || err.Error() != expected {
+		t.Errorf("Resolver.LookupSRV returned unexpected error, got %q, want %q", err.Error(), expected)
+	}
+	_, _, err = LookupSRV("target", "tcp", "golang.org")
+	if expected := "lookup golang.org: SRV target is invalid"; err == nil || err.Error() != expected {
+		t.Errorf("LookupSRV returned unexpected error, got %q, want %q", err.Error(), expected)
+	}
+
+	_, _, err = r.LookupSRV(context.Background(), "hdr", "tcp", "golang.org")
+	if expected := "lookup golang.org: SRV header name is invalid"; err == nil || err.Error() != expected {
+		t.Errorf("Resolver.LookupSRV returned unexpected error, got %q, want %q", err.Error(), expected)
+	}
+	_, _, err = LookupSRV("hdr", "tcp", "golang.org")
+	if expected := "lookup golang.org: SRV header name is invalid"; err == nil || err.Error() != expected {
+		t.Errorf("LookupSRV returned unexpected error, got %q, want %q", err.Error(), expected)
+	}
+
+	_, err = r.LookupMX(context.Background(), "golang.org")
+	if expected := "lookup golang.org: MX target is invalid"; err == nil || err.Error() != expected {
+		t.Errorf("Resolver.LookupMX returned unexpected error, got %q, want %q", err.Error(), expected)
+	}
+	_, err = LookupMX("golang.org")
+	if expected := "lookup golang.org: MX target is invalid"; err == nil || err.Error() != expected {
+		t.Errorf("LookupMX returned unexpected error, got %q, want %q", err.Error(), expected)
+	}
+
+	_, err = r.LookupNS(context.Background(), "golang.org")
+	if expected := "lookup golang.org: NS target is invalid"; err == nil || err.Error() != expected {
+		t.Errorf("Resolver.LookupNS returned unexpected error, got %q, want %q", err.Error(), expected)
+	}
+	_, err = LookupNS("golang.org")
+	if expected := "lookup golang.org: NS target is invalid"; err == nil || err.Error() != expected {
+		t.Errorf("LookupNS returned unexpected error, got %q, want %q", err.Error(), expected)
+	}
+
+	_, err = r.LookupAddr(context.Background(), "1.2.3.4")
+	if expected := "lookup 1.2.3.4: PTR target is invalid"; err == nil || err.Error() != expected {
+		t.Errorf("Resolver.LookupAddr returned unexpected error, got %q, want %q", err.Error(), expected)
+	}
+	_, err = LookupAddr("1.2.3.4")
+	if expected := "lookup 1.2.3.4: PTR target is invalid"; err == nil || err.Error() != expected {
+		t.Errorf("LookupAddr returned unexpected error, got %q, want %q", err.Error(), expected)
+	}
+}
diff --git a/src/net/lookup.go b/src/net/lookup.go
index 03599503bd..02a4cdcd1e 100644
--- a/src/net/lookup.go
+++ b/src/net/lookup.go
@@ -396,10 +396,13 @@ func (r *Resolver) LookupPort(ctx context.Context, network, service string) (por
 // contain DNS "CNAME" records, as long as host resolves to
 // address records.
 //
+// The returned canonical name is validated to be a properly
+// formatted presentation-format domain name.
+//
 // LookupCNAME uses context.Background internally; to specify the context, use
 // Resolver.LookupCNAME.
 func LookupCNAME(host string) (cname string, err error) {
-	return DefaultResolver.lookupCNAME(context.Background(), host)
+	return DefaultResolver.LookupCNAME(context.Background(), host)
 }
 
 // LookupCNAME returns the canonical name for the given host.
@@ -412,8 +415,18 @@ func LookupCNAME(host string) (cname string, err error) {
 // LookupCNAME does not return an error if host does not
 // contain DNS "CNAME" records, as long as host resolves to
 // address records.
-func (r *Resolver) LookupCNAME(ctx context.Context, host string) (cname string, err error) {
-	return r.lookupCNAME(ctx, host)
+//
+// The returned canonical name is validated to be a properly
+// formatted presentation-format domain name.
+func (r *Resolver) LookupCNAME(ctx context.Context, host string) (string, error) {
+	cname, err := r.lookupCNAME(ctx, host)
+	if err != nil {
+		return "", err
+	}
+	if !isDomainName(cname) {
+		return "", &DNSError{Err: "CNAME target is invalid", Name: host}
+	}
+	return cname, nil
 }
 
 // LookupSRV tries to resolve an SRV query of the given service,
@@ -425,8 +438,11 @@ func (r *Resolver) LookupCNAME(ctx context.Context, host string) (cname string,
 // That is, it looks up _service._proto.name. To accommodate services
 // publishing SRV records under non-standard names, if both service
 // and proto are empty strings, LookupSRV looks up name directly.
+//
+// The returned service names are validated to be properly
+// formatted presentation-format domain names.
 func LookupSRV(service, proto, name string) (cname string, addrs []*SRV, err error) {
-	return DefaultResolver.lookupSRV(context.Background(), service, proto, name)
+	return DefaultResolver.LookupSRV(context.Background(), service, proto, name)
 }
 
 // LookupSRV tries to resolve an SRV query of the given service,
@@ -438,34 +454,88 @@ func LookupSRV(service, proto, name string) (cname string, addrs []*SRV, err err
 // That is, it looks up _service._proto.name. To accommodate services
 // publishing SRV records under non-standard names, if both service
 // and proto are empty strings, LookupSRV looks up name directly.
-func (r *Resolver) LookupSRV(ctx context.Context, service, proto, name string) (cname string, addrs []*SRV, err error) {
-	return r.lookupSRV(ctx, service, proto, name)
+//
+// The returned service names are validated to be properly
+// formatted presentation-format domain names.
+func (r *Resolver) LookupSRV(ctx context.Context, service, proto, name string) (string, []*SRV, error) {
+	cname, addrs, err := r.lookupSRV(ctx, service, proto, name)
+	if err != nil {
+		return "", nil, err
+	}
+	if cname != "" && !isDomainName(cname) {
+		return "", nil, &DNSError{Err: "SRV header name is invalid", Name: name}
+	}
+	for _, addr := range addrs {
+		if addr == nil {
+			continue
+		}
+		if !isDomainName(addr.Target) {
+			return "", nil, &DNSError{Err: "SRV target is invalid", Name: name}
+		}
+	}
+	return cname, addrs, nil
 }
 
 // LookupMX returns the DNS MX records for the given domain name sorted by preference.
 //
+// The returned mail server names are validated to be properly
+// formatted presentation-format domain names.
+//
 // LookupMX uses context.Background internally; to specify the context, use
 // Resolver.LookupMX.
 func LookupMX(name string) ([]*MX, error) {
-	return DefaultResolver.lookupMX(context.Background(), name)
+	return DefaultResolver.LookupMX(context.Background(), name)
 }
 
 // LookupMX returns the DNS MX records for the given domain name sorted by preference.
+//
+// The returned mail server names are validated to be properly
+// formatted presentation-format domain names.
 func (r *Resolver) LookupMX(ctx context.Context, name string) ([]*MX, error) {
-	return r.lookupMX(ctx, name)
+	records, err := r.lookupMX(ctx, name)
+	if err != nil {
+		return nil, err
+	}
+	for _, mx := range records {
+		if mx == nil {
+			continue
+		}
+		if !isDomainName(mx.Host) {
+			return nil, &DNSError{Err: "MX target is invalid", Name: name}
+		}
+	}
+	return records, nil
 }
 
 // LookupNS returns the DNS NS records for the given domain name.
 //
+// The returned name server names are validated to be properly
+// formatted presentation-format domain names.
+//
 // LookupNS uses context.Background internally; to specify the context, use
 // Resolver.LookupNS.
 func LookupNS(name string) ([]*NS, error) {
-	return DefaultResolver.lookupNS(context.Background(), name)
+	return DefaultResolver.LookupNS(context.Background(), name)
 }
 
 // LookupNS returns the DNS NS records for the given domain name.
+//
+// The returned name server names are validated to be properly
+// formatted presentation-format domain names.
 func (r *Resolver) LookupNS(ctx context.Context, name string) ([]*NS, error) {
-	return r.lookupNS(ctx, name)
+	records, err := r.lookupNS(ctx, name)
+	if err != nil {
+		return nil, err
+	}
+	for _, ns := range records {
+		if ns == nil {
+			continue
+		}
+		if !isDomainName(ns.Host) {
+			return nil, &DNSError{Err: "NS target is invalid", Name: name}
+		}
+	}
+	return records, nil
 }
 
 // LookupTXT returns the DNS TXT records for the given domain name.
@@ -484,17 +554,32 @@ func (r *Resolver) LookupTXT(ctx context.Context, name string) ([]string, error)
 // LookupAddr performs a reverse lookup for the given address, returning a list
 // of names mapping to that address.
 //
+// The returned names are validated to be properly formatted presentation-format
+// domain names.
+//
 // When using the host C library resolver, at most one result will be
 // returned. To bypass the host resolver, use a custom Resolver.
 //
 // LookupAddr uses context.Background internally; to specify the context, use
 // Resolver.LookupAddr.
 func LookupAddr(addr string) (names []string, err error) {
-	return DefaultResolver.lookupAddr(context.Background(), addr)
+	return DefaultResolver.LookupAddr(context.Background(), addr)
 }
 
 // LookupAddr performs a reverse lookup for the given address, returning a list
 // of names mapping to that address.
-func (r *Resolver) LookupAddr(ctx context.Context, addr string) (names []string, err error) {
-	return r.lookupAddr(ctx, addr)
+//
+// The returned names are validated to be properly formatted presentation-format
+// domain names.
+func (r *Resolver) LookupAddr(ctx context.Context, addr string) ([]string, error) {
+	names, err := r.lookupAddr(ctx, addr)
+	if err != nil {
+		return nil, err
+	}
+	for _, name := range names {
+		if !isDomainName(name) {
+			return nil, &DNSError{Err: "PTR target is invalid", Name: addr}
+		}
+	}
+	return names, nil
 }
-- 
GitLab


From 0ece95a0feafe151cadf1346464952bb5c95fab3 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Mon, 24 May 2021 16:47:45 -0400
Subject: [PATCH 2136/2400] cmd/go: don't let 'go mod download' save sums for
 inconsistent requirements

'go mod download' calls modload.LoadModFile early to find the main
module path in order to validate arguments. LoadModFile may write
go.mod and go.sum to fix formatting and add a go directive. This calls
keepSums, which, in eager mode, loaded the complete module graph in
order to find out what sums are needed to load the complete module
graph. If go.mod requires a lower version of a module than will be
selected later, keepSums causes the sum for that version's go.mod to
be retained, even though it isn't needed later after a consistent
go.mod is written.

This CL fixes keepSums not to load the graph if it hasn't already been
loaded (whether eager or lazy), addressing comments from CL 318629.

For #45332

Change-Id: I20d4404004e4ad335450fd0fd753e7bc0060f702
Reviewed-on: https://go-review.googlesource.com/c/go/+/322369
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/internal/modcmd/download.go      | 16 ++++++++--------
 src/cmd/go/internal/modload/init.go         | 11 +++++------
 src/cmd/go/testdata/script/mod_download.txt |  1 -
 3 files changed, 13 insertions(+), 15 deletions(-)

diff --git a/src/cmd/go/internal/modcmd/download.go b/src/cmd/go/internal/modcmd/download.go
index 42b06dbc95..0e5af85237 100644
--- a/src/cmd/go/internal/modcmd/download.go
+++ b/src/cmd/go/internal/modcmd/download.go
@@ -138,14 +138,14 @@ func runDownload(ctx context.Context, cmd *base.Command, args []string) {
 	sem := make(chan token, runtime.GOMAXPROCS(0))
 	infos, infosErr := modload.ListModules(ctx, args, 0)
 	if !haveExplicitArgs {
-		// 'go mod download' is sometimes run without arguments to pre-populate
-		// the module cache. It may fetch modules that aren't needed to build
-		// packages in the main mdoule. This is usually not intended, so don't save
-		// sums for downloaded modules (golang.org/issue/45332).
-		// TODO(golang.org/issue/45551): For now, save sums needed to load the
-		// build list (same as 1.15 behavior). In the future, report an error if
-		// go.mod or go.sum need to be updated after loading the build list.
-		modload.WriteGoMod(ctx)
+		// 'go mod download' is sometimes run without arguments to pre-populate the
+		// module cache. It may fetch modules that aren't needed to build packages
+		// in the main mdoule. This is usually not intended, so don't save sums for
+		// downloaded modules (golang.org/issue/45332).
+		// TODO(golang.org/issue/45551): For now, in ListModules, save sums needed
+		// to load the build list (same as 1.15 behavior). In the future, report an
+		// error if go.mod or go.sum need to be updated after loading the build
+		// list.
 		modload.DisallowWriteGoMod()
 	}
 
diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index 86c0db3fe4..ea404b9f78 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -1122,12 +1122,11 @@ func keepSums(ctx context.Context, ld *loader, rs *Requirements, which whichSums
 		}
 	}
 
-	if rs.depth == lazy && rs.graph.Load() == nil {
-		// The main module is lazy and we haven't needed to load the module graph so
-		// far. Don't incur the cost of loading it now — since we haven't loaded the
-		// graph, we probably don't have any checksums to contribute to the distant
-		// parts of the graph anyway. Instead, just request sums for the roots that
-		// we know about.
+	if rs.graph.Load() == nil {
+		// The module graph was not loaded, possibly because the main module is lazy
+		// or possibly because we haven't needed to load the graph yet.
+		// Save sums for the root modules (or their replacements), but don't
+		// incur the cost of loading the graph just to find and retain the sums.
 		for _, m := range rs.rootModules {
 			r := resolveReplacement(m)
 			keep[modkey(r)] = true
diff --git a/src/cmd/go/testdata/script/mod_download.txt b/src/cmd/go/testdata/script/mod_download.txt
index ad640b45de..c2b72b2a02 100644
--- a/src/cmd/go/testdata/script/mod_download.txt
+++ b/src/cmd/go/testdata/script/mod_download.txt
@@ -167,5 +167,4 @@ require (
 -- update/go.sum.update --
 golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 rsc.io/quote v1.5.2/go.mod h1:LzX7hefJvL54yjefDEDHNONDjII0t9xZLPXsUe+TKr0=
-rsc.io/sampler v1.2.1/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
 rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
-- 
GitLab


From ab2ef4aaa77dff91cd98ded88aeba0bf5b5b2e80 Mon Sep 17 00:00:00 2001
From: Damien Neil <dneil@google.com>
Date: Wed, 26 May 2021 18:06:26 -0700
Subject: [PATCH 2137/2400] doc/go1.17: document reflect changes

For #44513.
Fixes #46019.

Change-Id: Ica84edd5703a4ccf343ff01e10483f8d51d1c79f
Reviewed-on: https://go-review.googlesource.com/c/go/+/323069
Trust: Damien Neil <dneil@google.com>
Run-TryBot: Damien Neil <dneil@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 doc/go1.17.html | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 8313c2bc57..d0a0c0f33f 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -500,11 +500,13 @@ Do not send CLs removing the interior tags from such phrases.
     </p>
 
     <p><!-- CL 281233 -->
-      TODO: <a href="https://golang.org/cl/281233">https://golang.org/cl/281233</a>: add VisibleFields function
+      The new <a href="/pkg/reflect/#VisibleFields"><code>VisibleFields</code></a> function
+      returns all the visible fields in a struct type, including fields inside anonymous struct members.
     </p>
 
     <p><!-- CL 284136 -->
-      TODO: <a href="https://golang.org/cl/284136">https://golang.org/cl/284136</a>: panic if ArrayOf is called with negative length
+      The <a href="/pkg/reflect/#ArrayOf"><code>ArrayOf</code></a> function now panics when
+      called with a negative length.
     </p>
   </dd>
 </dl><!-- reflect -->
-- 
GitLab


From 193d5141318d65cea310d995258288bd000d734c Mon Sep 17 00:00:00 2001
From: Manlio Perillo <manlio.perillo@gmail.com>
Date: Thu, 27 May 2021 10:44:57 +0200
Subject: [PATCH 2138/2400] net/http: correct Client.Do doc about context
 cancelation

The documentation of the Client.Do method and Get function incorrectly
stated that, in case of context cancelation, the returned url.Error
Timeout method returns true.

Update the documentation to correctly match the implementation.
See also CL 200798 that, due to an oversight, corrected only the
documentation of the Client.Get method.

Remove a TODO note added in CL 125575 (net/http: document that Client
methods always return *url.Error), since it is no longer applicable
after CL 200798 (net/http: fix and lock-in Client.Do docs on request
cancelation).

Fixes #46402

Change-Id: Ied2ee971ba22b61777762dbb19f16e08686634ca
Reviewed-on: https://go-review.googlesource.com/c/go/+/323089
Reviewed-by: Damien Neil <dneil@google.com>
Trust: Michael Knyszek <mknyszek@google.com>
---
 src/net/http/client.go | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/src/net/http/client.go b/src/net/http/client.go
index 03c9155fbd..e0cabc9d4c 100644
--- a/src/net/http/client.go
+++ b/src/net/http/client.go
@@ -433,8 +433,7 @@ func basicAuth(username, password string) string {
 // An error is returned if there were too many redirects or if there
 // was an HTTP protocol error. A non-2xx response doesn't cause an
 // error. Any returned error will be of type *url.Error. The url.Error
-// value's Timeout method will report true if request timed out or was
-// canceled.
+// value's Timeout method will report true if the request timed out.
 //
 // When err is nil, resp always contains a non-nil resp.Body.
 // Caller should close resp.Body when done reading from it.
@@ -589,8 +588,7 @@ func urlErrorOp(method string) string {
 // standard library body types.
 //
 // Any returned error will be of type *url.Error. The url.Error
-// value's Timeout method will report true if request timed out or was
-// canceled.
+// value's Timeout method will report true if the request timed out.
 func (c *Client) Do(req *Request) (*Response, error) {
 	return c.do(req)
 }
@@ -729,7 +727,6 @@ func (c *Client) do(req *Request) (retres *Response, reterr error) {
 			reqBodyClosed = true
 			if !deadline.IsZero() && didTimeout() {
 				err = &httpError{
-					// TODO: early in cycle: s/Client.Timeout exceeded/timeout or context cancellation/
 					err:     err.Error() + " (Client.Timeout exceeded while awaiting headers)",
 					timeout: true,
 				}
-- 
GitLab


From 639acdc833bfd12b7edd43092d1b380d70cb2874 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Thu, 27 May 2021 16:12:12 -0700
Subject: [PATCH 2139/2400] doc/go1.17: clarify that compress/lzw Reader and
 Writer types are new

For #26535
For #44513
For #46005

Change-Id: I70d3711ab6451a61b526abb3da8e91243f637656
Reviewed-on: https://go-review.googlesource.com/c/go/+/323273
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
---
 doc/go1.17.html | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index d0a0c0f33f..b3485a0ca6 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -331,11 +331,16 @@ Do not send CLs removing the interior tags from such phrases.
 <dl id="compress/lzw"><dt><a href="/pkg/compress/lzw/">compress/lzw</a></dt>
   <dd>
     <p><!-- CL 273667 -->
-      The new
-      <a href="/pkg/compress/lzw/#Reader.Reset"><code>Reader.Reset</code></a>
-      and
-      <a href="/pkg/compress/lzw/#Writer.Reset"><code>Writer.Reset</code></a>
-      methods allow reuse of a <code>Reader</code> or <code>Writer</code>.
+      The <a href="/pkg/compress/lzw/#NewReader"><code>NewReader</code></a>
+      function is guaranteed to return a value of the new
+      type <a href="/pkg/compress/lzw/#Reader"><code>Reader</code></a>,
+      and similarly <a href="/pkg/compress/lzw/#NewWriter"><code>NewWriter</code></a>
+      is guaranteed to return a value of the new
+      type <a href="/pkg/compress/lzw/#Writer"><code>Writer</code></a>.
+      These new types both implement a <code>Reset</code> method
+      (<a href="/pkg/compress/lzw/#Reader.Reset"><code>Reader.Reset</code></a>,
+      <a href="/pkg/compress/lzw/#Writer.Reset"><code>Writer.Reset</code></a>)
+      that allows reuse of the <code>Reader</code> or <code>Writer</code>.
     </p>
   </dd>
 </dl><!-- compress/lzw -->
-- 
GitLab


From 3de3440fb9b2d7f8a14b33f96fcfcee8eb61ec55 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 27 May 2021 22:27:55 -0400
Subject: [PATCH 2140/2400] go/ast: remove FuncDecl.IsMethod for Go 1.17

The IsMethod method was added to FuncDecl in the process of working on
support for type parameters, but is now only used in one place. It also
didn't go through the proposal process. Remove it for 1.17.

Also clean up a doc comment that mentioned type parameters.

Fixes #46297

Change-Id: I432bdd626324f613baf059540b7c5436985b2b16
Reviewed-on: https://go-review.googlesource.com/c/go/+/323369
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/ast/ast.go        | 6 +-----
 src/go/types/resolver.go | 2 +-
 2 files changed, 2 insertions(+), 6 deletions(-)

diff --git a/src/go/ast/ast.go b/src/go/ast/ast.go
index c87529ec77..337c87fd79 100644
--- a/src/go/ast/ast.go
+++ b/src/go/ast/ast.go
@@ -259,7 +259,7 @@ func (f *FieldList) End() token.Pos {
 	return token.NoPos
 }
 
-// NumFields returns the number of (type) parameters or struct fields represented by a FieldList.
+// NumFields returns the number of parameters or struct fields represented by a FieldList.
 func (f *FieldList) NumFields() int {
 	n := 0
 	if f != nil {
@@ -973,10 +973,6 @@ type (
 	}
 )
 
-func (f *FuncDecl) IsMethod() bool {
-	return f.Recv.NumFields() != 0
-}
-
 // Pos and End implementations for declaration nodes.
 
 func (d *BadDecl) Pos() token.Pos  { return d.From }
diff --git a/src/go/types/resolver.go b/src/go/types/resolver.go
index f67fc65cd1..114647a2ff 100644
--- a/src/go/types/resolver.go
+++ b/src/go/types/resolver.go
@@ -383,7 +383,7 @@ func (check *Checker) collectObjects() {
 				info := &declInfo{file: fileScope, fdecl: d.decl}
 				name := d.decl.Name.Name
 				obj := NewFunc(d.decl.Name.Pos(), pkg, name, nil)
-				if !d.decl.IsMethod() {
+				if d.decl.Recv.NumFields() == 0 {
 					// regular function
 					if d.decl.Recv != nil {
 						check.error(d.decl.Recv, _BadRecv, "method is missing receiver")
-- 
GitLab


From ccd9784edf556673a340f3a8d55d9a8c64b95f59 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Thu, 27 May 2021 16:16:37 -0700
Subject: [PATCH 2141/2400] doc/go1.17: document new debug/elf constant

For #39677
For #44513

Change-Id: I8c4193fd4359b83e6739e7e30a3a42b5f21b0f1a
Reviewed-on: https://go-review.googlesource.com/c/go/+/323275
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 doc/go1.17.html | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index b3485a0ca6..4e847708e5 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -373,6 +373,15 @@ Do not send CLs removing the interior tags from such phrases.
   </dd>
 </dl><!-- database/sql -->
 
+<dl id="debug/elf"><dt><a href="/pkg/debug/elf/">debug/elf</a></dt>
+  <dd>
+    <p><!-- CL 239217 -->
+      The <a href="/pkg/debug/elf/#SHT_MIPS_ABIFLAGS"><code>SHT_MIPS_ABIFLAGS</code></a>
+      constant has been added.
+    </p>
+  </dd>
+</dl><!-- debug/elf -->
+
 <dl id="encoding/binary"><dt><a href="/pkg/encoding/binary/">encoding/binary</a></dt>
   <dd>
     <p><!-- CL 299531 -->
-- 
GitLab


From c295107708ad5fd26a78f9f1cb478f91aa7763e7 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Thu, 27 May 2021 16:24:49 -0700
Subject: [PATCH 2142/2400] doc/go1.17: mention new
 encoding/csv/Reader.FieldPos method

For #44221
For #44513

Change-Id: I2d2d1c55255f4411c11fd51f0f3ae726cbf4d136
Reviewed-on: https://go-review.googlesource.com/c/go/+/323349
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: roger peppe <rogpeppe@gmail.com>
---
 doc/go1.17.html | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 4e847708e5..9480b1205c 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -393,6 +393,18 @@ Do not send CLs removing the interior tags from such phrases.
   </dd>
 </dl><!-- encoding/binary -->
 
+<dl id="encoding/csv"><dt><a href="/pkg/encoding/csv/">encoding/csv</a></dt>
+  <dd>
+    <p><!-- CL 291290 -->
+      The new
+      <a href="/pkg/encoding/csv/#Reader.FieldPos"><code>Reader.FieldPos</code></a>
+      method returns the line and column corresponding to the start of
+      a given field in the record most recently returned by
+      <a href="/pkg/encoding/csv/#Reader.Read"><code>Read</code></a>.
+    </p>
+  </dd>
+</dl><!-- encoding/csv -->
+
 <dl id="flag"><dt><a href="/pkg/flag/">flag</a></dt>
   <dd>
     <p><!-- CL 271788 -->
-- 
GitLab


From 6f58088bd84daef583f30dcfdb7c2b9179bfff3a Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Thu, 27 May 2021 17:19:12 -0700
Subject: [PATCH 2143/2400] doc/go1.17: document new
 go/build/BuildContext.ToolTags field

For #44513

Change-Id: Ib21af742e574fcaa7e38bb437d42dbeed9d01f0b
Reviewed-on: https://go-review.googlesource.com/c/go/+/323350
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 doc/go1.17.html | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 9480b1205c..65d8efdc1b 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -413,6 +413,17 @@ Do not send CLs removing the interior tags from such phrases.
   </dd>
 </dl><!-- flag -->
 
+<dl id="go/build"><dt><a href="/pkg/go/build/">go/build</a></dt>
+  <dd>
+    <p><!-- CL 310732 -->
+      The new
+      <a href="/pkg/go/build/#Context.ToolTags"><code>Context.ToolTags</code></a>
+      field holds the build tags appropriate to the current Go
+      toolchain configuration.
+    </p>
+  </dd>
+</dl><!-- go/build -->
+
 <dl id="io/fs"><dt><a href="/pkg/io/fs/">io/fs</a></dt>
   <dd>
     <p><!-- CL 293649 -->
-- 
GitLab


From bbda92359289ae5992bbd8da9ce37932e531adda Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Thu, 27 May 2021 17:30:08 -0700
Subject: [PATCH 2144/2400] doc/go1.17: mention new Windows SysProcAttr fields

For #44011
For #44513

Change-Id: I512466f2e775e36098eb36ca7ef82333cd9e632a
Reviewed-on: https://go-review.googlesource.com/c/go/+/323352
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 doc/go1.17.html | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 65d8efdc1b..3e9587dbf7 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -611,6 +611,15 @@ Do not send CLs removing the interior tags from such phrases.
       On Unix-like systems, the process group of a child process is now set with signals blocked.
       This avoids sending a <code>SIGTTOU</code> to the child when the parent is in a background process group.
     </p>
+
+    <p><!-- CL 288298, CL 288300 -->
+      The Windows version of
+      <a href="/pkg/syscall/#SysProcAttr"><code>SysProcAttr</code></a>
+      has two new fields. <code>AdditionalInheritedHandles</code> is
+      a list of additional handles to be inherited by the new child
+      process. <code>ParentProcess</code> permits specifying the
+      parent process of the new process.
+    </p>
   </dd>
 </dl><!-- syscall -->
 
-- 
GitLab


From 6624771c8346d69ef41526b1134c505bca399340 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Thu, 27 May 2021 17:33:01 -0700
Subject: [PATCH 2145/2400] doc/go1.17: mention testing.[TB].Setenv methods

For #41260
For #44513

Change-Id: I47ac0c751dafeb05abfe66fdf77938774164915f
Reviewed-on: https://go-review.googlesource.com/c/go/+/323353
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: roger peppe <rogpeppe@gmail.com>
---
 doc/go1.17.html | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 3e9587dbf7..9d775e169a 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -628,6 +628,14 @@ Do not send CLs removing the interior tags from such phrases.
     <p><!-- CL 310033 -->
       TODO: <a href="https://golang.org/cl/310033">https://golang.org/cl/310033</a>: add -shuffle=off|on|N to alter the execution order of tests and benchmarks
     </p>
+
+    <p><!-- CL 260577 -->
+      The new
+      <a href="/pkg/testing/#T.Setenv"><code>T.Setenv</code></a>
+      and <a href="/pkg/testing/#B.Setenv"><code>B.Setenv</code></a>
+      methods support setting an environment variable for the duration
+      of the test or benchmark.
+    </p>
   </dd>
 </dl><!-- testing -->
 
-- 
GitLab


From 1419ca7cead4438c8c9f17d8901aeecd9c72f577 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Thu, 27 May 2021 17:25:43 -0700
Subject: [PATCH 2146/2400] doc/go1.17: mention new definitions of
 MSG_CMSG_CLOEXEC

For #44513

Change-Id: I8c0070b116ee520a76726eb9d3dcbdd489a1fb1f
Reviewed-on: https://go-review.googlesource.com/c/go/+/323351
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 doc/go1.17.html | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 9d775e169a..3395c4e670 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -619,6 +619,11 @@ Do not send CLs removing the interior tags from such phrases.
       a list of additional handles to be inherited by the new child
       process. <code>ParentProcess</code> permits specifying the
       parent process of the new process.
+
+    <p><!-- CL 311570 -->
+      The constant <code>MSG_CMSG_CLOEXEC</code> is now defined on
+      DragonFly and all OpenBSD systems (it was already defined on
+      some OpenBSD systems and all FreeBSD, NetBSD, and Linux systems).
     </p>
   </dd>
 </dl><!-- syscall -->
-- 
GitLab


From f6cc392d1ddd53a003c413fba4c1fc244ce2d85e Mon Sep 17 00:00:00 2001
From: Ariel Mashraki <ariel@mashraki.co.il>
Date: Mon, 19 Apr 2021 22:26:47 +0300
Subject: [PATCH 2147/2400] doc/go1.17: document
 text/template/parse.SkipFuncCheck

Documents the newly added mode that skips type checking
functions as per CL 301493.

Fixes #46025
For #34652
For #44513
For #38627

Change-Id: I56c4f65924702a931944796e39f43cfeb66abc8a
Reviewed-on: https://go-review.googlesource.com/c/go/+/311569
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Trust: Michael Knyszek <mknyszek@google.com>
---
 doc/go1.17.html | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 3395c4e670..3805a4c14e 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -647,7 +647,8 @@ Do not send CLs removing the interior tags from such phrases.
 <dl id="text/template/parse"><dt><a href="/pkg/text/template/parse/">text/template/parse</a></dt>
   <dd>
     <p><!-- CL 301493 -->
-      TODO: <a href="https://golang.org/cl/301493">https://golang.org/cl/301493</a>: add a mode to skip func-check on parsing
+      The new <a href="/pkg/text/template/parse/#Mode"><code>SkipFuncCheck</code></a> <a href=><code>Mode</code></a>
+      value changes the template parser to not verify that functions are defined.
     </p>
   </dd>
 </dl><!-- text/template/parse -->
-- 
GitLab


From 79bda650410c8617f0ae20dc552c6d5b8f8dcfc8 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Fri, 28 May 2021 17:32:15 -0700
Subject: [PATCH 2148/2400] doc/go1.17: mention time.Layout

For #44513

Change-Id: Id4624e977654f7e8c489508a9dce98c9fab621a6
Reviewed-on: https://go-review.googlesource.com/c/go/+/323490
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Rob Pike <r@golang.org>
---
 doc/go1.17.html | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 3805a4c14e..02a58f8984 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -673,6 +673,11 @@ Do not send CLs removing the interior tags from such phrases.
     <p><!-- CL 300996 -->
       TODO: <a href="https://golang.org/cl/300996">https://golang.org/cl/300996</a>: support &#34;,&#34; as separator for fractional seconds
     </p>
+
+    <p><!-- CL 320252 -->
+      The new constant <a href="/pkg/time/#Layout"><code>Layout</code></a>
+      defines the reference time.
+    </p>
   </dd>
 </dl><!-- time -->
 
-- 
GitLab


From 1607c2817241bd141af9331a3e6c3148e5cd5d8b Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Fri, 28 May 2021 11:58:05 -0400
Subject: [PATCH 2149/2400] go/types: unexport the GoVersion configuration
 option for Go 1.17

The GoVersion field was added to types.Config as part of the work on
type parameters. Specifically, it was added to be consistent with
cmd/compile/internal/types2, which requires such an option.

This configuration option is useful, but is also non-trivial and did not
go through the proposal process. Unexport it for Go 1.17; we can create
a proposal to export it for Go 1.18.

Fixes #46296

Change-Id: Id82d8a7096887dcfc404c4d6d8da9c761b316609
Reviewed-on: https://go-review.googlesource.com/c/go/+/323430
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/api.go         | 4 ++--
 src/go/types/check.go       | 4 ++--
 src/go/types/check_test.go  | 2 +-
 src/go/types/stdlib_test.go | 3 ++-
 src/go/types/types_test.go  | 6 ++++++
 5 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/src/go/types/api.go b/src/go/types/api.go
index ed62a785d6..8c0d9d22bf 100644
--- a/src/go/types/api.go
+++ b/src/go/types/api.go
@@ -101,12 +101,12 @@ type ImporterFrom interface {
 // A Config specifies the configuration for type checking.
 // The zero value for Config is a ready-to-use default configuration.
 type Config struct {
-	// GoVersion describes the accepted Go language version. The string
+	// goVersion describes the accepted Go language version. The string
 	// must follow the format "go%d.%d" (e.g. "go1.12") or it must be
 	// empty; an empty string indicates the latest language version.
 	// If the format is invalid, invoking the type checker will cause a
 	// panic.
-	GoVersion string
+	goVersion string
 
 	// If IgnoreFuncBodies is set, function bodies are not
 	// type-checked.
diff --git a/src/go/types/check.go b/src/go/types/check.go
index 25ea4906be..a923c3c612 100644
--- a/src/go/types/check.go
+++ b/src/go/types/check.go
@@ -179,9 +179,9 @@ func NewChecker(conf *Config, fset *token.FileSet, pkg *Package, info *Info) *Ch
 		info = new(Info)
 	}
 
-	version, err := parseGoVersion(conf.GoVersion)
+	version, err := parseGoVersion(conf.goVersion)
 	if err != nil {
-		panic(fmt.Sprintf("invalid Go version %q (%v)", conf.GoVersion, err))
+		panic(fmt.Sprintf("invalid Go version %q (%v)", conf.goVersion, err))
 	}
 
 	return &Checker{
diff --git a/src/go/types/check_test.go b/src/go/types/check_test.go
index c5dc93eade..9c71277264 100644
--- a/src/go/types/check_test.go
+++ b/src/go/types/check_test.go
@@ -240,7 +240,7 @@ func checkFiles(t *testing.T, sizes Sizes, goVersion string, filenames []string,
 	// typecheck and collect typechecker errors
 	var conf Config
 	conf.Sizes = sizes
-	conf.GoVersion = goVersion
+	SetGoVersion(&conf, goVersion)
 
 	// special case for importC.src
 	if len(filenames) == 1 {
diff --git a/src/go/types/stdlib_test.go b/src/go/types/stdlib_test.go
index 3dea8dcf1e..503d0a6f44 100644
--- a/src/go/types/stdlib_test.go
+++ b/src/go/types/stdlib_test.go
@@ -134,7 +134,8 @@ func testTestDir(t *testing.T, path string, ignore ...string) {
 		// parse and type-check file
 		file, err := parser.ParseFile(fset, filename, nil, 0)
 		if err == nil {
-			conf := Config{GoVersion: goVersion, Importer: stdLibImporter}
+			conf := Config{Importer: stdLibImporter}
+			SetGoVersion(&conf, goVersion)
 			_, err = conf.Check(filename, fset, []*ast.File{file}, nil)
 		}
 
diff --git a/src/go/types/types_test.go b/src/go/types/types_test.go
index fd9462c4a2..25cd996628 100644
--- a/src/go/types/types_test.go
+++ b/src/go/types/types_test.go
@@ -11,3 +11,9 @@ import "sync/atomic"
 // for tests where we may want to have a consistent
 // numbering for each individual test case.
 func ResetId() { atomic.StoreUint32(&lastId, 0) }
+
+// SetGoVersion sets the unexported goVersion field on config, so that tests
+// which assert on behavior for older Go versions can set it.
+func SetGoVersion(config *Config, goVersion string) {
+	config.goVersion = goVersion
+}
-- 
GitLab


From 3b770f2ccb1fa6fecc22ea822a19447b10b70c5c Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Sat, 29 May 2021 22:14:12 -0400
Subject: [PATCH 2150/2400] go/types: don't declare 'comparable' when
 typeparams are disabled

Fixes #46453

Change-Id: I92b9b1e43ec5182162b2eeeb667f1f548ea373a5
Reviewed-on: https://go-review.googlesource.com/c/go/+/323609
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/check_test.go | 8 ++++++++
 src/go/types/universe.go   | 5 ++++-
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/go/types/check_test.go b/src/go/types/check_test.go
index 9c71277264..6c3b630a1b 100644
--- a/src/go/types/check_test.go
+++ b/src/go/types/check_test.go
@@ -330,6 +330,14 @@ func TestIndexRepresentability(t *testing.T) {
 	checkFiles(t, &StdSizes{4, 4}, "", []string{"index.go"}, [][]byte{[]byte(src)}, false)
 }
 
+func TestIssue46453(t *testing.T) {
+	if typeparams.Enabled {
+		t.Skip("type params are enabled")
+	}
+	const src = "package p\ntype _ comparable // ERROR \"undeclared name: comparable\""
+	checkFiles(t, nil, "", []string{"issue46453.go"}, [][]byte{[]byte(src)}, false)
+}
+
 func TestCheck(t *testing.T)     { DefPredeclaredTestFuncs(); testDir(t, "check") }
 func TestExamples(t *testing.T)  { testDir(t, "examples") }
 func TestFixedbugs(t *testing.T) { testDir(t, "fixedbugs") }
diff --git a/src/go/types/universe.go b/src/go/types/universe.go
index 7c211fa6f7..d7feb2c609 100644
--- a/src/go/types/universe.go
+++ b/src/go/types/universe.go
@@ -8,6 +8,7 @@ package types
 
 import (
 	"go/constant"
+	"go/internal/typeparams"
 	"go/token"
 	"strings"
 )
@@ -237,7 +238,9 @@ func init() {
 	defPredeclaredConsts()
 	defPredeclaredNil()
 	defPredeclaredFuncs()
-	defPredeclaredComparable()
+	if typeparams.Enabled {
+		defPredeclaredComparable()
+	}
 
 	universeIota = Universe.Lookup("iota").(*Const)
 	universeByte = Universe.Lookup("byte").(*TypeName).typ.(*Basic)
-- 
GitLab


From 0b80cf11366f28ef5d0d8bae9c46813e96ffd071 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Wed, 26 May 2021 15:29:39 -0400
Subject: [PATCH 2151/2400] cmd/go: make 'go get' save sums for incidentally
 updated modules

When 'go get' updates a module, it may update another module in the
build list that provides a package in 'all' that wasn't loaded as part
of the 'go get' command. If 'go get' doesn't add a sum for that
module, builds may fail later.

With this change, 'go get' will fetch a sum for the content of an
updated module if we had a sum for the version before the update.

'go get' won't load the complete package graph, so there are still
cases where the build may be broken, like when an updated (but not
loaded) package imports a package from a new module.

Fixes #44129

Change-Id: I62eba3df4137a3e84e2ca8d549c36eec3670f08c
Reviewed-on: https://go-review.googlesource.com/c/go/+/322832
Trust: Jay Conrod <jayconrod@google.com>
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/internal/modget/get.go             |  54 +++++++-
 .../script/mod_get_update_unrelated_sum.txt   | 120 ++++++++++++++++++
 2 files changed, 173 insertions(+), 1 deletion(-)
 create mode 100644 src/cmd/go/testdata/script/mod_get_update_unrelated_sum.txt

diff --git a/src/cmd/go/internal/modget/get.go b/src/cmd/go/internal/modget/get.go
index 563f1a988f..8eee723f89 100644
--- a/src/cmd/go/internal/modget/get.go
+++ b/src/cmd/go/internal/modget/get.go
@@ -38,6 +38,7 @@ import (
 	"cmd/go/internal/base"
 	"cmd/go/internal/imports"
 	"cmd/go/internal/load"
+	"cmd/go/internal/modfetch"
 	"cmd/go/internal/modload"
 	"cmd/go/internal/par"
 	"cmd/go/internal/search"
@@ -1466,6 +1467,8 @@ func (r *resolver) chooseArbitrarily(cs pathSet) (isPackage bool, m module.Versi
 // checkPackageProblems reloads packages for the given patterns and reports
 // missing and ambiguous package errors. It also reports retractions and
 // deprecations for resolved modules and modules needed to build named packages.
+// It also adds a sum for each updated module in the build list if we had one
+// before and didn't get one while loading packages.
 //
 // We skip missing-package errors earlier in the process, since we want to
 // resolve pathSets ourselves, but at that point, we don't have enough context
@@ -1593,9 +1596,52 @@ func (r *resolver) checkPackageProblems(ctx context.Context, pkgPatterns []strin
 		})
 	}
 
+	// Load sums for updated modules that had sums before. When we update a
+	// module, we may update another module in the build list that provides a
+	// package in 'all' that wasn't loaded as part of this 'go get' command.
+	// If we don't add a sum for that module, builds may fail later.
+	// Note that an incidentally updated package could still import packages
+	// from unknown modules or from modules in the build list that we didn't
+	// need previously. We can't handle that case without loading 'all'.
+	sumErrs := make([]error, len(r.buildList))
+	for i := range r.buildList {
+		i := i
+		m := r.buildList[i]
+		mActual := m
+		if mRepl := modload.Replacement(m); mRepl.Path != "" {
+			mActual = mRepl
+		}
+		old := module.Version{Path: m.Path, Version: r.initialVersion[m.Path]}
+		if old.Version == "" {
+			continue
+		}
+		oldActual := old
+		if oldRepl := modload.Replacement(old); oldRepl.Path != "" {
+			oldActual = oldRepl
+		}
+		if mActual == oldActual || mActual.Version == "" || !modfetch.HaveSum(oldActual) {
+			continue
+		}
+		r.work.Add(func() {
+			if _, err := modfetch.DownloadZip(ctx, mActual); err != nil {
+				verb := "upgraded"
+				if semver.Compare(m.Version, old.Version) < 0 {
+					verb = "downgraded"
+				}
+				replaced := ""
+				if mActual != m {
+					replaced = fmt.Sprintf(" (replaced by %s)", mActual)
+				}
+				err = fmt.Errorf("%s %s %s => %s%s: error finding sum for %s: %v", verb, m.Path, old.Version, m.Version, replaced, mActual, err)
+				sumErrs[i] = err
+			}
+		})
+	}
+
 	<-r.work.Idle()
 
-	// Report deprecations, then retractions.
+	// Report deprecations, then retractions, then errors fetching sums.
+	// Only errors fetching sums are hard errors.
 	for _, mm := range deprecations {
 		if mm.message != "" {
 			fmt.Fprintf(os.Stderr, "go: module %s is deprecated: %s\n", mm.m.Path, mm.message)
@@ -1615,6 +1661,12 @@ func (r *resolver) checkPackageProblems(ctx context.Context, pkgPatterns []strin
 	if retractPath != "" {
 		fmt.Fprintf(os.Stderr, "go: to switch to the latest unretracted version, run:\n\tgo get %s@latest\n", retractPath)
 	}
+	for _, err := range sumErrs {
+		if err != nil {
+			base.Errorf("go: %v", err)
+		}
+	}
+	base.ExitIfErrors()
 }
 
 // reportChanges logs version changes to os.Stderr.
diff --git a/src/cmd/go/testdata/script/mod_get_update_unrelated_sum.txt b/src/cmd/go/testdata/script/mod_get_update_unrelated_sum.txt
new file mode 100644
index 0000000000..0093c0eda0
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_get_update_unrelated_sum.txt
@@ -0,0 +1,120 @@
+# Check that 'go get' adds sums for updated modules if we had sums before,
+# even if we didn't load packages from them.
+# Verifies #44129.
+
+env fmt='{{.ImportPath}}: {{if .Error}}{{.Error.Err}}{{else}}ok{{end}}'
+
+# Control case: before upgrading, we have the sums we need.
+# go list -deps -e -f $fmt .
+# stdout '^rsc.io/quote: ok$'
+# ! stdout rsc.io/sampler  # not imported by quote in this version
+cp go.mod.orig go.mod
+cp go.sum.orig go.sum
+go mod tidy
+cmp go.mod.orig go.mod
+cmp go.sum.orig go.sum
+
+
+# Upgrade a module. This also upgrades rsc.io/quote, and though we didn't load
+# a package from it, we had the sum for its old version, so we need the
+# sum for the new version, too.
+go get -d example.com/upgrade@v0.0.2
+grep '^rsc.io/quote v1.5.2 ' go.sum
+
+# The upgrade still breaks the build because the new version of quote imports
+# rsc.io/sampler, and we don't have its zip sum.
+go list -deps -e -f $fmt
+stdout 'rsc.io/quote: ok'
+stdout 'rsc.io/sampler: missing go.sum entry for module providing package rsc.io/sampler'
+cp go.mod.orig go.mod
+cp go.sum.orig go.sum
+
+
+# Replace the old version with a directory before upgrading.
+# We didn't need a sum for it before (even though we had one), so we won't
+# fetch a new sum.
+go mod edit -replace rsc.io/quote@v1.0.0=./dummy
+go get -d example.com/upgrade@v0.0.2
+! grep '^rsc.io/quote v1.5.2 ' go.sum
+cp go.mod.orig go.mod
+cp go.sum.orig go.sum
+
+
+# Replace the new version with a directory before upgrading.
+# We can't get a sum for a directory.
+go mod edit -replace rsc.io/quote@v1.5.2=./dummy
+go get -d example.com/upgrade@v0.0.2
+! grep '^rsc.io/quote v1.5.2 ' go.sum
+cp go.mod.orig go.mod
+cp go.sum.orig go.sum
+
+
+# Replace the new version with a different version.
+# We should get a sum for that version.
+go mod edit -replace rsc.io/quote@v1.5.2=rsc.io/quote@v1.5.1
+go get -d example.com/upgrade@v0.0.2
+! grep '^rsc.io/quote v1.5.2 ' go.sum
+grep '^rsc.io/quote v1.5.1 ' go.sum
+cp go.mod.orig go.mod
+cp go.sum.orig go.sum
+
+
+# Delete the new version's zip (but not mod) from the cache and go offline.
+# 'go get' should fail when fetching the zip.
+rm $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.5.2.zip
+env GOPROXY=off
+! go get -d example.com/upgrade@v0.0.2
+stderr '^go: upgraded rsc.io/quote v1.0.0 => v1.5.2: error finding sum for rsc.io/quote@v1.5.2: module lookup disabled by GOPROXY=off$'
+
+-- go.mod.orig --
+module m
+
+go 1.16
+
+require (
+	example.com/upgrade v0.0.1
+	rsc.io/quote v1.0.0
+)
+
+replace (
+	example.com/upgrade v0.0.1 => ./upgrade1
+	example.com/upgrade v0.0.2 => ./upgrade2
+)
+-- go.sum.orig --
+rsc.io/quote v1.0.0 h1:kQ3IZQzPTiDJxSZI98YaWgxFEhlNdYASHvh+MplbViw=
+rsc.io/quote v1.0.0/go.mod h1:v83Ri/njykPcgJltBc/gEkJTmjTsNgtO1Y7vyIK1CQA=
+-- go.sum.want --
+golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+rsc.io/quote v1.0.0 h1:kQ3IZQzPTiDJxSZI98YaWgxFEhlNdYASHvh+MplbViw=
+rsc.io/quote v1.0.0/go.mod h1:v83Ri/njykPcgJltBc/gEkJTmjTsNgtO1Y7vyIK1CQA=
+rsc.io/quote v1.5.2 h1:3fEykkD9k7lYzXqCYrwGAf7iNhbk4yCjHmKBN9td4L0=
+rsc.io/quote v1.5.2/go.mod h1:LzX7hefJvL54yjefDEDHNONDjII0t9xZLPXsUe+TKr0=
+rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
+-- use.go --
+package use
+
+import (
+	_ "example.com/upgrade"
+	_ "rsc.io/quote"
+)
+-- upgrade1/go.mod --
+module example.com/upgrade
+
+go 1.16
+-- upgrade1/upgrade.go --
+package upgrade
+-- upgrade2/go.mod --
+module example.com/upgrade
+
+go 1.16
+
+require rsc.io/quote v1.5.2 // indirect
+-- upgrade2/upgrade.go --
+package upgrade
+-- dummy/go.mod --
+module rsc.io/quote
+
+go 1.16
+-- dummy/quote.go --
+package quote
+
-- 
GitLab


From 2e59cc5fb4e81fbd2ee9f662caa707c1138bf5ae Mon Sep 17 00:00:00 2001
From: Vitaly Zdanevich <zdanevich.vitaly@ya.ru>
Date: Sat, 29 May 2021 13:49:51 +0000
Subject: [PATCH 2152/2400] cmd/go: add [-src] to documentation

Change-Id: I554b5021386575af6ff44571a95bb31b38a0547f
GitHub-Last-Rev: 20aaec3aa0baee6112fc2e4d72e83f78b72a44ea
GitHub-Pull-Request: golang/go#45956
Reviewed-on: https://go-review.googlesource.com/c/go/+/317109
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Trust: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go/alldocs.go          | 2 +-
 src/cmd/go/internal/doc/doc.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index bad2b7f16e..ab61017c4e 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -293,7 +293,7 @@
 //
 // Usage:
 //
-// 	go doc [-u] [-c] [package|[package.]symbol[.methodOrField]]
+// 	go doc [doc flags] [package|[package.]symbol[.methodOrField]]
 //
 // Doc prints the documentation comments associated with the item identified by its
 // arguments (a package, const, func, type, var, method, or struct field)
diff --git a/src/cmd/go/internal/doc/doc.go b/src/cmd/go/internal/doc/doc.go
index 67f76e2256..8580a5dc4d 100644
--- a/src/cmd/go/internal/doc/doc.go
+++ b/src/cmd/go/internal/doc/doc.go
@@ -13,7 +13,7 @@ import (
 
 var CmdDoc = &base.Command{
 	Run:         runDoc,
-	UsageLine:   "go doc [-u] [-c] [package|[package.]symbol[.methodOrField]]",
+	UsageLine:   "go doc [doc flags] [package|[package.]symbol[.methodOrField]]",
 	CustomFlags: true,
 	Short:       "show documentation for package or symbol",
 	Long: `
-- 
GitLab


From 2bec019fb5a7d379772c29be6e3487640d43e6fa Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Thu, 27 May 2021 10:13:00 -0400
Subject: [PATCH 2153/2400] doc/go1.17: add release notes for register ABI

Also delete the TODO for the linker section.

Updates #44513.
Updates #40724.

Change-Id: I4d62a907e8c3070831a052cdfe1e21648698df12
Reviewed-on: https://go-review.googlesource.com/c/go/+/323289
Trust: Cherry Mui <cherryyz@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
---
 doc/go1.17.html | 52 ++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 39 insertions(+), 13 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 02a58f8984..ee498f7603 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -226,31 +226,57 @@ Do not send CLs removing the interior tags from such phrases.
 
 <h2 id="runtime">Runtime</h2>
 
-<p><!-- CL 304470 -->
-  TODO: <a href="https://golang.org/cl/304470">https://golang.org/cl/304470</a>: cmd/compile, runtime: add metadata for argument printing in traceback
-</p>
-
 <p>
   TODO: complete the Runtime section
 </p>
 
 <h2 id="compiler">Compiler</h2>
 
-<p><!-- CL 283112, golang.org/issue/28727 -->
+<p><!-- golang.org/issue/40724 -->
+  Go 1.17 implements a new way of passing function arguments and results using
+  registers instead of the stack. This work is enabled for Linux, MacOS, and
+  Windows on the 64-bit x86 architecture (the <code>linux/amd64</code>,
+  <code>darwin/amd64</code>, <code>windows/amd64</code> ports). For a
+  representative set of Go  packages and programs, benchmarking has shown
+  performance improvements of about 5%, and a typical reduction in binary size
+  of about 2%.
+</p>
 
+<p>
+  This change does not affect the functionality of any safe Go code. It can affect
+  code outside the <a href="/doc/go1compat">compatibility guidelines</a> with
+  minimal impact. To maintain compatibility with existing assembly functions,
+  adapter functions converting between the new register-based calling convention
+  and the previous stack-based calling convention (also known as ABI wrappers)
+  are sometimes used. This is mostly invisible to users, except for assembly
+  functions that have their addresses taken in Go. Using <code>reflect.ValueOf(fn).Pointer()</code>
+  (or similar approaches such as via <code>unsafe.Pointer</code>) to get the address
+  of an assembly function will now return the address of the ABI wrapper. This is
+  mostly harmless, except for special-purpose assembly code (such as accessing
+  thread-local storage or requiring a special stack alignment). Assembly functions
+  called indirectly from Go via <code>func</code> values will now be made through
+  ABI wrappers, which may cause a very small performance overhead. Also, calling
+  Go functions from assembly may now go through ABI wrappers, with a very small
+  performance overhead.
+</p>
+
+<p><!-- CL 304470 -->
+  The format of stack traces from the runtime (printed when an uncaught panic
+  occurs, or when <code>runtime.Stack</code> is called) is improved. Previously,
+  the function arguments were printed as hexadecimal words based on the memory
+  layout. Now each argument in the source code is printed separately, separated
+  by commas. Aggregate-typed (struct, array, string, slice, interface, and complex)
+  arguments are delimited by curly braces. A caveat is that the value of an
+  argument that only lives in a register and is not stored to memory may be
+  inaccurate. Results (which were usually inaccurate) are no longer printed.
+</p>
+
+<p><!-- CL 283112, golang.org/issue/28727 -->
   Functions containing closures can now be inlined. One effect of this change is
   that a function with a closure may actually produce a distinct closure function
   for each place that the function is inlined. Hence, this change could reveal
   bugs where Go functions are compared (incorrectly) by pointer value. Go
   functions are by definition not comparable.
-
-  TODO: complete the Compiler section, or delete if not needed
-</p>
-
-<h2 id="linker">Linker</h2>
-
-<p>
-  TODO: complete the Linker section, or delete if not needed
 </p>
 
 <h2 id="library">Core library</h2>
-- 
GitLab


From 272552275f56345095b4ea7f404e5b317856cf07 Mon Sep 17 00:00:00 2001
From: OneOfOne <oneofone@gmail.com>
Date: Fri, 21 May 2021 15:29:46 -0500
Subject: [PATCH 2154/2400] A+C: update name

Change-Id: I1f88304858da5147bfd082c2fc2b7d24ed371cd8
Reviewed-on: https://go-review.googlesource.com/c/go/+/321955
Reviewed-by: Russ Cox <rsc@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 AUTHORS      | 2 +-
 CONTRIBUTORS | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/AUTHORS b/AUTHORS
index 48ce71f4cc..95d3158d20 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -41,7 +41,7 @@ Aeneas Rekkas (arekkas) <aeneas@ory.am>
 Afanasev Stanislav <phpprogger@gmail.com>
 Agis Anastasopoulos <agis.anast@gmail.com>
 Agniva De Sarker <agnivade@yahoo.co.in>
-Ahmed Wahed <oneofone@gmail.com>
+Ahmed W. Mones <oneofone@gmail.com>
 Ahmet Soormally <ahmet@mangomm.co.uk>
 Ahmy Yulrizka <yulrizka@gmail.com>
 Aiden Scandella <ai@uber.com>
diff --git a/CONTRIBUTORS b/CONTRIBUTORS
index 6c7262adb1..ee50a4c049 100644
--- a/CONTRIBUTORS
+++ b/CONTRIBUTORS
@@ -67,7 +67,7 @@ Aeneas Rekkas (arekkas) <aeneas@ory.am>
 Afanasev Stanislav <phpprogger@gmail.com>
 Agis Anastasopoulos <agis.anast@gmail.com>
 Agniva De Sarker <agnivade@yahoo.co.in>
-Ahmed Wahed <oneofone@gmail.com>
+Ahmed W. Mones <oneofone@gmail.com>
 Ahmet Alp Balkan <ahmetb@google.com>
 Ahmet Soormally <ahmet@mangomm.co.uk>
 Ahmy Yulrizka <yulrizka@gmail.com>
-- 
GitLab


From 24e9707cbfa6b1ed6abdd4b11f9ddaf3aac5ad88 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Tue, 25 May 2021 16:31:41 -0700
Subject: [PATCH 2155/2400] cmd/link, cmd/cgo: support -flto in CFLAGS

The linker now accepts unrecognized object files in external linking mode.
These objects will simply be passed to the external linker.
This permits using -flto which can generate pure byte code objects,
whose symbol table the linker does not know how to read.

The cgo tool now passes -fno-lto when generating objects whose symbols
it needs to read. The cgo tool now emits matching types in different
objects, so that the lto linker does not report a mismatch.

This is based on https://golang.org/cl/293290 by Derek Parker.

For #43505
Fixes #43830
Fixes #46295

Change-Id: I6787de213417466784ddef5af8899e453b4ae1ad
Reviewed-on: https://go-review.googlesource.com/c/go/+/322614
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
---
 src/cmd/cgo/gcc.go                            |  2 +
 src/cmd/cgo/out.go                            | 16 ++++++--
 src/cmd/dist/test.go                          | 29 ++++++++++----
 .../testdata/script/cgo_lto2_issue43830.txt   | 33 ++++++++++++++++
 .../go/testdata/script/cgo_lto_issue43830.txt | 39 +++++++++++++++++++
 src/cmd/link/internal/ld/ar.go                |  4 ++
 src/cmd/link/internal/ld/config.go            |  6 ++-
 src/cmd/link/internal/ld/lib.go               | 26 +++++++++++--
 8 files changed, 140 insertions(+), 15 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/cgo_lto2_issue43830.txt
 create mode 100644 src/cmd/go/testdata/script/cgo_lto_issue43830.txt

diff --git a/src/cmd/cgo/gcc.go b/src/cmd/cgo/gcc.go
index ae61725bc7..a73e998877 100644
--- a/src/cmd/cgo/gcc.go
+++ b/src/cmd/cgo/gcc.go
@@ -1638,6 +1638,8 @@ func (p *Package) gccCmd() []string {
 		c = append(c, "-maix64")
 		c = append(c, "-mcmodel=large")
 	}
+	// disable LTO so we get an object whose symbols we can read
+	c = append(c, "-fno-lto")
 	c = append(c, "-") //read input from standard input
 	return c
 }
diff --git a/src/cmd/cgo/out.go b/src/cmd/cgo/out.go
index 8c31d5b794..94152f4278 100644
--- a/src/cmd/cgo/out.go
+++ b/src/cmd/cgo/out.go
@@ -168,8 +168,18 @@ func (p *Package) writeDefs() {
 			if *gccgo {
 				fmt.Fprintf(fc, "extern byte *%s;\n", n.C)
 			} else {
-				fmt.Fprintf(fm, "extern char %s[];\n", n.C)
-				fmt.Fprintf(fm, "void *_cgohack_%s = %s;\n\n", n.C, n.C)
+				// Force a reference to all symbols so that
+				// the external linker will add DT_NEEDED
+				// entries as needed on ELF systems.
+				// Treat function variables differently
+				// to avoid type confict errors from LTO
+				// (Link Time Optimization).
+				if n.Kind == "fpvar" {
+					fmt.Fprintf(fm, "extern void %s();\n", n.C)
+				} else {
+					fmt.Fprintf(fm, "extern char %s[];\n", n.C)
+					fmt.Fprintf(fm, "void *_cgohack_%s = %s;\n\n", n.C, n.C)
+				}
 				fmt.Fprintf(fgo2, "//go:linkname __cgo_%s %s\n", n.C, n.C)
 				fmt.Fprintf(fgo2, "//go:cgo_import_static %s\n", n.C)
 				fmt.Fprintf(fgo2, "var __cgo_%s byte\n", n.C)
@@ -1042,7 +1052,7 @@ func (p *Package) writeExports(fgo2, fm, fgcc, fgcch io.Writer) {
 		// This unpacks the argument struct above and calls the Go function.
 		fmt.Fprintf(fgo2, "func _cgoexp%s_%s(a *%s) {\n", cPrefix, exp.ExpName, gotype)
 
-		fmt.Fprintf(fm, "int _cgoexp%s_%s;\n", cPrefix, exp.ExpName)
+		fmt.Fprintf(fm, "void _cgoexp%s_%s(void* p){}\n", cPrefix, exp.ExpName)
 
 		if gccResult != "void" {
 			// Write results back to frame.
diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go
index 50bf80ba59..bc49c6d804 100644
--- a/src/cmd/dist/test.go
+++ b/src/cmd/dist/test.go
@@ -722,14 +722,29 @@ func (t *tester) registerTests() {
 				},
 			})
 			if t.hasCxx() {
-				t.tests = append(t.tests, distTest{
-					name:    "swig_callback",
-					heading: "../misc/swig/callback",
-					fn: func(dt *distTest) error {
-						t.addCmd(dt, "misc/swig/callback", t.goTest())
-						return nil
+				t.tests = append(t.tests,
+					distTest{
+						name:    "swig_callback",
+						heading: "../misc/swig/callback",
+						fn: func(dt *distTest) error {
+							t.addCmd(dt, "misc/swig/callback", t.goTest())
+							return nil
+						},
+					},
+					distTest{
+						name:    "swig_callback_lto",
+						heading: "../misc/swig/callback",
+						fn: func(dt *distTest) error {
+							cmd := t.addCmd(dt, "misc/swig/callback", t.goTest())
+							cmd.Env = append(os.Environ(),
+								"CGO_CFLAGS=-flto",
+								"CGO_CXXFLAGS=-flto",
+								"CGO_LDFLAGS=-flto",
+							)
+							return nil
+						},
 					},
-				})
+				)
 			}
 		}
 	}
diff --git a/src/cmd/go/testdata/script/cgo_lto2_issue43830.txt b/src/cmd/go/testdata/script/cgo_lto2_issue43830.txt
new file mode 100644
index 0000000000..e2483ba784
--- /dev/null
+++ b/src/cmd/go/testdata/script/cgo_lto2_issue43830.txt
@@ -0,0 +1,33 @@
+# tests golang.org/issue/43830
+
+[!cgo] skip 'skipping test without cgo'
+[openbsd] env CC='clang'
+[openbsd] [!exec:clang] skip 'skipping test without clang present'
+[!openbsd] env CC='gcc'
+[!openbsd] [!exec:gcc] skip 'skipping test without gcc present'
+
+env CGO_CFLAGS='-Wno-ignored-optimization-argument -flto -ffat-lto-objects'
+
+go build main.go
+
+-- main.go --
+
+package main
+
+import "fmt"
+
+// #include "hello.h"
+import "C"
+
+func main() {
+	hello := C.hello
+	fmt.Printf("%v\n", hello)
+}
+
+-- hello.h --
+
+#include <stdio.h>
+
+void hello(void) {
+  printf("hello\n");
+}
diff --git a/src/cmd/go/testdata/script/cgo_lto_issue43830.txt b/src/cmd/go/testdata/script/cgo_lto_issue43830.txt
new file mode 100644
index 0000000000..06ab2f34c9
--- /dev/null
+++ b/src/cmd/go/testdata/script/cgo_lto_issue43830.txt
@@ -0,0 +1,39 @@
+# tests golang.org/issue/43830
+
+[!cgo] skip 'skipping test without cgo'
+[openbsd] env CC='clang'
+[openbsd] [!exec:clang] skip 'skipping test without clang present'
+[!openbsd] env CC='gcc'
+[!openbsd] [!exec:gcc] skip 'skipping test without gcc present'
+
+env CGO_CFLAGS='-Wno-ignored-optimization-argument -flto -ffat-lto-objects'
+
+go build main.go add.go
+
+-- main.go --
+
+package main
+
+/*
+int c_add(int a, int b) {
+	return myadd(a, b);
+}
+*/
+import "C"
+
+func main() {
+	println(C.c_add(1, 2))
+}
+
+-- add.go --
+
+package main
+
+import "C"
+
+/* test */
+
+//export myadd
+func myadd(a C.int, b C.int) C.int {
+	return a + b
+}
diff --git a/src/cmd/link/internal/ld/ar.go b/src/cmd/link/internal/ld/ar.go
index 22f53a4df2..23915f9032 100644
--- a/src/cmd/link/internal/ld/ar.go
+++ b/src/cmd/link/internal/ld/ar.go
@@ -124,6 +124,10 @@ func hostArchive(ctxt *Link, name string) {
 
 			libgcc := sym.Library{Pkg: "libgcc"}
 			h := ldobj(ctxt, f, &libgcc, l, pname, name)
+			if h.ld == nil {
+				Errorf(nil, "%s unrecognized object file at offset %d", name, off)
+				continue
+			}
 			f.MustSeek(h.off, 0)
 			h.ld(ctxt, f, h.pkg, h.length, h.pn)
 		}
diff --git a/src/cmd/link/internal/ld/config.go b/src/cmd/link/internal/ld/config.go
index ae0d7520eb..20f1d0b8c1 100644
--- a/src/cmd/link/internal/ld/config.go
+++ b/src/cmd/link/internal/ld/config.go
@@ -241,6 +241,10 @@ func mustLinkExternal(ctxt *Link) (res bool, reason string) {
 		return true, "dynamically linking with a shared library"
 	}
 
+	if unknownObjFormat {
+		return true, "some input objects have an unrecognized file format"
+	}
+
 	return false, ""
 }
 
@@ -248,7 +252,7 @@ func mustLinkExternal(ctxt *Link) (res bool, reason string) {
 //
 // It is called after flags are processed and inputs are processed,
 // so the ctxt.LinkMode variable has an initial value from the -linkmode
-// flag and the iscgo externalobj variables are set.
+// flag and the iscgo, externalobj, and unknownObjFormat variables are set.
 func determineLinkMode(ctxt *Link) {
 	extNeeded, extReason := mustLinkExternal(ctxt)
 	via := ""
diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index e8f001ba8e..644faeb2fb 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -343,10 +343,16 @@ var (
 const pkgdef = "__.PKGDEF"
 
 var (
-	// Set if we see an object compiled by the host compiler that is not
-	// from a package that is known to support internal linking mode.
+	// externalobj is set to true if we see an object compiled by
+	// the host compiler that is not from a package that is known
+	// to support internal linking mode.
 	externalobj = false
-	theline     string
+
+	// unknownObjFormat is set to true if we see an object whose
+	// format we don't recognize.
+	unknownObjFormat = false
+
+	theline string
 )
 
 func Lflag(ctxt *Link, arg string) {
@@ -1065,6 +1071,10 @@ func hostobjs(ctxt *Link) {
 		}
 
 		f.MustSeek(h.off, 0)
+		if h.ld == nil {
+			Errorf(nil, "%s: unrecognized object file format", h.pn)
+			continue
+		}
 		h.ld(ctxt, f, h.pkg, h.length, h.pn)
 		f.Close()
 	}
@@ -1855,6 +1865,14 @@ func ldobj(ctxt *Link, f *bio.Reader, lib *sym.Library, length int64, pn string,
 		return ldhostobj(ldxcoff, ctxt.HeadType, f, pkg, length, pn, file)
 	}
 
+	if c1 != 'g' || c2 != 'o' || c3 != ' ' || c4 != 'o' {
+		// An unrecognized object is just passed to the external linker.
+		// If we try to read symbols from this object, we will
+		// report an error at that time.
+		unknownObjFormat = true
+		return ldhostobj(nil, ctxt.HeadType, f, pkg, length, pn, file)
+	}
+
 	/* check the header */
 	line, err := f.ReadString('\n')
 	if err != nil {
@@ -1874,7 +1892,7 @@ func ldobj(ctxt *Link, f *bio.Reader, lib *sym.Library, length int64, pn string,
 			return nil
 		}
 
-		Errorf(nil, "%s: not an object file: @%d %02x%02x%02x%02x", pn, start, c1, c2, c3, c4)
+		Errorf(nil, "%s: not an object file: @%d %q", pn, start, line)
 		return nil
 	}
 
-- 
GitLab


From 567ee865f690cde59d5aeadc04bcc926d2316db8 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Tue, 1 Jun 2021 13:47:42 -0700
Subject: [PATCH 2156/2400] cmd/go: add declaration to cgo_lto_issue43830 test

This permits the test to work in C99 mode.

For #43830

Change-Id: Ide54bd62239cfe602e2664300f04e472df5daf43
Reviewed-on: https://go-review.googlesource.com/c/go/+/324009
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/testdata/script/cgo_lto_issue43830.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/cmd/go/testdata/script/cgo_lto_issue43830.txt b/src/cmd/go/testdata/script/cgo_lto_issue43830.txt
index 06ab2f34c9..8bc7d8a540 100644
--- a/src/cmd/go/testdata/script/cgo_lto_issue43830.txt
+++ b/src/cmd/go/testdata/script/cgo_lto_issue43830.txt
@@ -15,6 +15,7 @@ go build main.go add.go
 package main
 
 /*
+extern int myadd(int, int);
 int c_add(int a, int b) {
 	return myadd(a, b);
 }
-- 
GitLab


From cae68700cc76d3118e470180a1cbeac616f3dfad Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Tue, 1 Jun 2021 17:00:22 -0700
Subject: [PATCH 2157/2400] runtime: fix formatting

Fix up a gofmt complaint from CL 310591.

Change-Id: I73534ef064a4cfc53539e5e65a8653e2cd684c64
Reviewed-on: https://go-review.googlesource.com/c/go/+/324090
Trust: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/internal/atomic/atomic_arm64.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/internal/atomic/atomic_arm64.go b/src/runtime/internal/atomic/atomic_arm64.go
index 3c8736997f..dbb1796ec0 100644
--- a/src/runtime/internal/atomic/atomic_arm64.go
+++ b/src/runtime/internal/atomic/atomic_arm64.go
@@ -8,8 +8,8 @@
 package atomic
 
 import (
-	"unsafe"
 	"internal/cpu"
+	"unsafe"
 )
 
 const (
-- 
GitLab


From 84c0e5d47f46f2e1a7ce92341477d9801f0ef777 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Tue, 1 Jun 2021 14:58:36 -0700
Subject: [PATCH 2158/2400] cmd/link: move issue 43830 tests out of TestScript

These tests pass or fail depending on the exact compiler version,
which the TestScript tests don't support. Rewrite into Go.

For #43830
For #46295

Change-Id: I91b61dfe329d518e461ee56f186f0e9b42858e77
Reviewed-on: https://go-review.googlesource.com/c/go/+/324049
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 .../testdata/script/cgo_lto2_issue43830.txt   |  33 -----
 .../go/testdata/script/cgo_lto_issue43830.txt |  40 -----
 src/cmd/link/cgo_test.go                      | 138 ++++++++++++++++++
 3 files changed, 138 insertions(+), 73 deletions(-)
 delete mode 100644 src/cmd/go/testdata/script/cgo_lto2_issue43830.txt
 delete mode 100644 src/cmd/go/testdata/script/cgo_lto_issue43830.txt
 create mode 100644 src/cmd/link/cgo_test.go

diff --git a/src/cmd/go/testdata/script/cgo_lto2_issue43830.txt b/src/cmd/go/testdata/script/cgo_lto2_issue43830.txt
deleted file mode 100644
index e2483ba784..0000000000
--- a/src/cmd/go/testdata/script/cgo_lto2_issue43830.txt
+++ /dev/null
@@ -1,33 +0,0 @@
-# tests golang.org/issue/43830
-
-[!cgo] skip 'skipping test without cgo'
-[openbsd] env CC='clang'
-[openbsd] [!exec:clang] skip 'skipping test without clang present'
-[!openbsd] env CC='gcc'
-[!openbsd] [!exec:gcc] skip 'skipping test without gcc present'
-
-env CGO_CFLAGS='-Wno-ignored-optimization-argument -flto -ffat-lto-objects'
-
-go build main.go
-
--- main.go --
-
-package main
-
-import "fmt"
-
-// #include "hello.h"
-import "C"
-
-func main() {
-	hello := C.hello
-	fmt.Printf("%v\n", hello)
-}
-
--- hello.h --
-
-#include <stdio.h>
-
-void hello(void) {
-  printf("hello\n");
-}
diff --git a/src/cmd/go/testdata/script/cgo_lto_issue43830.txt b/src/cmd/go/testdata/script/cgo_lto_issue43830.txt
deleted file mode 100644
index 8bc7d8a540..0000000000
--- a/src/cmd/go/testdata/script/cgo_lto_issue43830.txt
+++ /dev/null
@@ -1,40 +0,0 @@
-# tests golang.org/issue/43830
-
-[!cgo] skip 'skipping test without cgo'
-[openbsd] env CC='clang'
-[openbsd] [!exec:clang] skip 'skipping test without clang present'
-[!openbsd] env CC='gcc'
-[!openbsd] [!exec:gcc] skip 'skipping test without gcc present'
-
-env CGO_CFLAGS='-Wno-ignored-optimization-argument -flto -ffat-lto-objects'
-
-go build main.go add.go
-
--- main.go --
-
-package main
-
-/*
-extern int myadd(int, int);
-int c_add(int a, int b) {
-	return myadd(a, b);
-}
-*/
-import "C"
-
-func main() {
-	println(C.c_add(1, 2))
-}
-
--- add.go --
-
-package main
-
-import "C"
-
-/* test */
-
-//export myadd
-func myadd(a C.int, b C.int) C.int {
-	return a + b
-}
diff --git a/src/cmd/link/cgo_test.go b/src/cmd/link/cgo_test.go
new file mode 100644
index 0000000000..09390daeb7
--- /dev/null
+++ b/src/cmd/link/cgo_test.go
@@ -0,0 +1,138 @@
+// Copyright 2021 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 (
+	"bytes"
+	"fmt"
+	"internal/testenv"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+)
+
+// Issues 43830, 46295
+func TestCGOLTO(t *testing.T) {
+	testenv.MustHaveCGO(t)
+	testenv.MustHaveGoBuild(t)
+
+	t.Parallel()
+
+	for _, cc := range []string{"gcc", "clang"} {
+		for test := 0; test < 2; test++ {
+			t.Run(fmt.Sprintf("%s-%d", cc, test), func(t *testing.T) {
+				testCGOLTO(t, cc, test)
+			})
+		}
+	}
+}
+
+const test1_main = `
+package main
+
+/*
+extern int myadd(int, int);
+int c_add(int a, int b) {
+	return myadd(a, b);
+}
+*/
+import "C"
+
+func main() {
+	println(C.c_add(1, 2))
+}
+`
+
+const test1_add = `
+package main
+
+import "C"
+
+/* test */
+
+//export myadd
+func myadd(a C.int, b C.int) C.int {
+	return a + b
+}
+`
+
+const test2_main = `
+package main
+
+import "fmt"
+
+/*
+#include <stdio.h>
+
+void hello(void) {
+  printf("hello\n");
+}
+*/
+import "C"
+
+func main() {
+	hello := C.hello
+	fmt.Printf("%v\n", hello)
+}
+`
+
+func testCGOLTO(t *testing.T, cc string, test int) {
+	t.Parallel()
+
+	if _, err := exec.LookPath(cc); err != nil {
+		t.Skipf("no %s compiler", cc)
+	}
+
+	dir := t.TempDir()
+
+	writeTempFile := func(name, contents string) {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0644); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	writeTempFile("go.mod", "module cgolto\n")
+
+	switch test {
+	case 0:
+		writeTempFile("main.go", test1_main)
+		writeTempFile("add.go", test1_add)
+	case 1:
+		writeTempFile("main.go", test2_main)
+	default:
+		t.Fatalf("bad case %d", test)
+	}
+
+	cmd := exec.Command(testenv.GoToolPath(t), "build")
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(),
+		"CC="+cc,
+		"CGO_CFLAGS=-flto",
+	)
+
+	t.Log("go build")
+	out, err := cmd.CombinedOutput()
+	t.Logf("%s", out)
+
+	if err != nil {
+		t.Logf("go build failed: %v", err)
+
+		// Error messages we've seen indicating that LTO is not supported.
+		var noLTO = []string{
+			`unrecognized command line option "-flto"`,
+			"unable to pass LLVM bit-code files to linker",
+			"file not recognized: File format not recognized",
+			"LTO support has not been enabled",
+		}
+		for _, msg := range noLTO {
+			if bytes.Contains(out, []byte(msg)) {
+				t.Skipf("C compiler %v does not support LTO", cc)
+			}
+		}
+
+		t.Error("failed")
+	}
+}
-- 
GitLab


From dc8f87b7493e173d65d3587389cc41468ba16dc0 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Tue, 1 Jun 2021 12:22:12 +0200
Subject: [PATCH 2159/2400] runtime/internal/sys: generate //go:build lines in
 gengoos.go

For #41184

Change-Id: If7a1c3980f47bc28d0a13fe497eaba6178c65c91
Reviewed-on: https://go-review.googlesource.com/c/go/+/323750
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/runtime/internal/sys/gengoos.go | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/src/runtime/internal/sys/gengoos.go b/src/runtime/internal/sys/gengoos.go
index 51f64a6e5c..ffe962f71d 100644
--- a/src/runtime/internal/sys/gengoos.go
+++ b/src/runtime/internal/sys/gengoos.go
@@ -48,18 +48,21 @@ func main() {
 		if target == "nacl" {
 			continue
 		}
-		var buf bytes.Buffer
-		fmt.Fprintf(&buf, "// Code generated by gengoos.go using 'go generate'. DO NOT EDIT.\n\n")
+		var tags []string
 		if target == "linux" {
-			fmt.Fprintf(&buf, "// +build !android\n") // must explicitly exclude android for linux
+			tags = append(tags, "!android") // must explicitly exclude android for linux
 		}
 		if target == "solaris" {
-			fmt.Fprintf(&buf, "// +build !illumos\n") // must explicitly exclude illumos for solaris
+			tags = append(tags, "!illumos") // must explicitly exclude illumos for solaris
 		}
 		if target == "darwin" {
-			fmt.Fprintf(&buf, "// +build !ios\n") // must explicitly exclude ios for darwin
+			tags = append(tags, "!ios") // must explicitly exclude ios for darwin
 		}
-		fmt.Fprintf(&buf, "// +build %s\n\n", target) // must explicitly include target for bootstrapping purposes
+		tags = append(tags, target) // must explicitly include target for bootstrapping purposes
+		var buf bytes.Buffer
+		fmt.Fprintf(&buf, "// Code generated by gengoos.go using 'go generate'. DO NOT EDIT.\n\n")
+		fmt.Fprintf(&buf, "//go:build %s\n", strings.Join(tags, " && "))
+		fmt.Fprintf(&buf, "// +build %s\n\n", strings.Join(tags, ","))
 		fmt.Fprintf(&buf, "package sys\n\n")
 		fmt.Fprintf(&buf, "const GOOS = `%s`\n\n", target)
 		for _, goos := range gooses {
@@ -81,6 +84,7 @@ func main() {
 		}
 		var buf bytes.Buffer
 		fmt.Fprintf(&buf, "// Code generated by gengoos.go using 'go generate'. DO NOT EDIT.\n\n")
+		fmt.Fprintf(&buf, "//go:build %s\n", target)
 		fmt.Fprintf(&buf, "// +build %s\n\n", target) // must explicitly include target for bootstrapping purposes
 		fmt.Fprintf(&buf, "package sys\n\n")
 		fmt.Fprintf(&buf, "const GOARCH = `%s`\n\n", target)
-- 
GitLab


From d743e67e0695a8082f03fd90bb07e71cf9f34cf1 Mon Sep 17 00:00:00 2001
From: KimMachineGun <geon0250@gmail.com>
Date: Sun, 23 May 2021 14:05:15 +0000
Subject: [PATCH 2160/2400] doc/go1.17: document flag changes for Go 1.17

For #44513
Fixes #46010

Change-Id: I1fe638e5db0b4f3b64dbfbd948154a7c7a80afc9
GitHub-Last-Rev: d5bd53b1df202329661ffb1818803f2ec1d3f57a
GitHub-Pull-Request: golang/go#46150
Reviewed-on: https://go-review.googlesource.com/c/go/+/319273
Reviewed-by: Heschi Kreinick <heschi@google.com>
Trust: Robert Findley <rfindley@google.com>
---
 doc/go1.17.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index ee498f7603..6ddef3d47e 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -434,7 +434,7 @@ Do not send CLs removing the interior tags from such phrases.
 <dl id="flag"><dt><a href="/pkg/flag/">flag</a></dt>
   <dd>
     <p><!-- CL 271788 -->
-      TODO: <a href="https://golang.org/cl/271788">https://golang.org/cl/271788</a>: panic if flag name begins with - or contains =
+      Flag declarations now panic if an invalid name is specified.
     </p>
   </dd>
 </dl><!-- flag -->
-- 
GitLab


From 1c6a2ea2ea4b04416f7344ee5effe81816c7200b Mon Sep 17 00:00:00 2001
From: Uddeshya Singh <singhuddeshyaofficial@gmail.com>
Date: Fri, 7 May 2021 13:18:05 +0530
Subject: [PATCH 2161/2400] doc/go1.17: document time changes for Go1.17

Documents the newly implemented changes of
- Time.IsDST() method
- Addition of Time.UnixMilli, Time.UnixMicro and to-Time helpers UnixMicro, UnixMilli methods
- Addition of comma "," support as separator for fraction seconds

For #44513
Fixes #46026

Change-Id: Ib8d3449d3b061f013112d33362b50e68ad6ddffa
Reviewed-on: https://go-review.googlesource.com/c/go/+/317913
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 doc/go1.17.html | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 6ddef3d47e..b287d41309 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -689,15 +689,26 @@ Do not send CLs removing the interior tags from such phrases.
     </p>
 
     <p><!-- CL 264077 -->
-      TODO: <a href="https://golang.org/cl/264077">https://golang.org/cl/264077</a>: add Time.IsDST() to check if its Location is in Daylight Savings Time
+      The new <a href="/pkg/time/#Time.IsDST"><code>Time.IsDST</code></a> method can be used to check whether the time
+      is in Daylight Savings Time in its configured location.
     </p>
 
     <p><!-- CL 293349 -->
-      TODO: <a href="https://golang.org/cl/293349">https://golang.org/cl/293349</a>: add Time.Unix{Milli,Micro} and to-Time helpers UnixMicro, UnixMilli
+      The new <a href="/pkg/time/#Time.UnixMilli"><code>Time.UnixMilli</code></a> and
+      <a href="/pkg/time/#Time.UnixMicro"><code>Time.UnixMicro</code></a> methods return the number of milliseconds and
+      microseconds elapsed since January 1, 1970 UTC respectively.<br>
+      The new <code>UnixMilli</code> and <code>UnixMicro</code> functions return local Time corresponding to given
+      Unix time.
     </p>
 
     <p><!-- CL 300996 -->
-      TODO: <a href="https://golang.org/cl/300996">https://golang.org/cl/300996</a>: support &#34;,&#34; as separator for fractional seconds
+      The package now accepts comma "," as a separator for fractional seconds when parsing and formatting time.
+      The following time formats are now accepted:
+      <ul>
+        <li>2006-01-02 14:06:03,999999999 -0700 MST</li>
+        <li>Mon Jan _2 14:06:03,120007 2006</li>
+        <li>Mon Jan 2 14:06:03,120007 2006</li>
+      </ul>
     </p>
 
     <p><!-- CL 320252 -->
-- 
GitLab


From ff9f5fb8591c6d3e4cd4881e75f49440a3a875c2 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Wed, 2 Jun 2021 07:43:57 -0700
Subject: [PATCH 2162/2400] cmd/link: recognize clang linker error in
 testCGOLTO

Also recognize a case in which GCC does not run (from
https://build.golang.org/log/7f6d8b35c905b9829f05906beccca44f208aa569).

Fixes #46517

Change-Id: I4fe4164a5df92b2dec08fd767f65a4d5479f3f36
Reviewed-on: https://go-review.googlesource.com/c/go/+/324169
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/cmd/link/cgo_test.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/cmd/link/cgo_test.go b/src/cmd/link/cgo_test.go
index 09390daeb7..26ab802454 100644
--- a/src/cmd/link/cgo_test.go
+++ b/src/cmd/link/cgo_test.go
@@ -121,11 +121,14 @@ func testCGOLTO(t *testing.T, cc string, test int) {
 		t.Logf("go build failed: %v", err)
 
 		// Error messages we've seen indicating that LTO is not supported.
+		// These errors come from GCC or clang, not Go.
 		var noLTO = []string{
 			`unrecognized command line option "-flto"`,
 			"unable to pass LLVM bit-code files to linker",
 			"file not recognized: File format not recognized",
 			"LTO support has not been enabled",
+			"linker command failed with exit code",
+			"gcc: can't load library",
 		}
 		for _, msg := range noLTO {
 			if bytes.Contains(out, []byte(msg)) {
-- 
GitLab


From 6e189afd3e7a3722c72b320ef604bf2910aee9e7 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Fri, 28 May 2021 17:28:12 -0700
Subject: [PATCH 2163/2400] doc/go1.17: mention SYS_WAIT6/WEXITED on NetBSD

For #13987
For #16028
For #44513

Change-Id: I7a73446fcc80a01fa6de24eec1e5b993e543be37
Reviewed-on: https://go-review.googlesource.com/c/go/+/323489
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 doc/go1.17.html | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index b287d41309..d80e68d434 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -651,6 +651,14 @@ Do not send CLs removing the interior tags from such phrases.
       DragonFly and all OpenBSD systems (it was already defined on
       some OpenBSD systems and all FreeBSD, NetBSD, and Linux systems).
     </p>
+
+    <p><!-- CL 315281 -->
+      The constants <code>SYS_WAIT6</code> and <code>WEXITED</code>
+      are now defined on NetBSD systems (<code>SYS_WAIT6</code> was
+      already defined on DragonFly and FreeBSD systems;
+      <code>WEXITED</code> was already defined on Darwin, DragonFly,
+      FreeBSD, Linux, and Solaris systems).
+    </p>
   </dd>
 </dl><!-- syscall -->
 
-- 
GitLab


From e11d14225c032a7c2722798db3c309762fa99757 Mon Sep 17 00:00:00 2001
From: Jeremy Faller <jeremy@golang.org>
Date: Wed, 2 Jun 2021 11:20:40 -0400
Subject: [PATCH 2164/2400] doc/go1.17: remove runtime section

Updates #44513

Change-Id: I359d56fc3eeece3005f092cca2cb485664affc23
Reviewed-on: https://go-review.googlesource.com/c/go/+/324209
Trust: Jeremy Faller <jeremy@golang.org>
Run-TryBot: Jeremy Faller <jeremy@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 doc/go1.17.html | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index d80e68d434..27ef524286 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -224,12 +224,6 @@ Do not send CLs removing the interior tags from such phrases.
   TODO: complete the Vet section
 </p>
 
-<h2 id="runtime">Runtime</h2>
-
-<p>
-  TODO: complete the Runtime section
-</p>
-
 <h2 id="compiler">Compiler</h2>
 
 <p><!-- golang.org/issue/40724 -->
-- 
GitLab


From 4f572d707661e3e84ff262d6c605eb6fa1f77abd Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Thu, 25 Feb 2021 08:21:52 -0800
Subject: [PATCH 2165/2400] io/fs: minor corrections to Sub docs

Fixes #44376

Change-Id: I9cd21adb9d4d434c3d8b8eb8af3042b70c763ea1
Reviewed-on: https://go-review.googlesource.com/c/go/+/296389
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/io/fs/sub.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/io/fs/sub.go b/src/io/fs/sub.go
index 7822e555ea..ae20e030a9 100644
--- a/src/io/fs/sub.go
+++ b/src/io/fs/sub.go
@@ -19,10 +19,10 @@ type SubFS interface {
 
 // Sub returns an FS corresponding to the subtree rooted at fsys's dir.
 //
-// If fs implements SubFS, Sub calls returns fsys.Sub(dir).
-// Otherwise, if dir is ".", Sub returns fsys unchanged.
+// If dir is ".", Sub returns fsys unchanged.
+// Otherwise, if fs implements SubFS, Sub returns fsys.Sub(dir).
 // Otherwise, Sub returns a new FS implementation sub that,
-// in effect, implements sub.Open(dir) as fsys.Open(path.Join(dir, name)).
+// in effect, implements sub.Open(name) as fsys.Open(path.Join(dir, name)).
 // The implementation also translates calls to ReadDir, ReadFile, and Glob appropriately.
 //
 // Note that Sub(os.DirFS("/"), "prefix") is equivalent to os.DirFS("/prefix")
-- 
GitLab


From dd7ba3ba2c860c40be6d70b63d4a678449cae80f Mon Sep 17 00:00:00 2001
From: Roland Shoemaker <roland@golang.org>
Date: Wed, 2 Jun 2021 09:20:22 -0700
Subject: [PATCH 2166/2400] net: don't rely on system hosts in TestCVE202133195

Also don't unnecessarily deref the error return.

Fixes #46504

Change-Id: I22d14ac76776f8988fa0774bdcb5fcd801ce0185
Reviewed-on: https://go-review.googlesource.com/c/go/+/324190
Trust: David Chase <drchase@google.com>
Trust: Damien Neil <dneil@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Damien Neil <dneil@google.com>
---
 src/net/dnsclient_unix_test.go | 39 +++++++++++++++++-----------------
 1 file changed, 20 insertions(+), 19 deletions(-)

diff --git a/src/net/dnsclient_unix_test.go b/src/net/dnsclient_unix_test.go
index a718e75a72..a59be7fea0 100644
--- a/src/net/dnsclient_unix_test.go
+++ b/src/net/dnsclient_unix_test.go
@@ -1898,61 +1898,62 @@ func TestCVE202133195(t *testing.T) {
 	// Change the default resolver to match our manipulated resolver
 	originalDefault := DefaultResolver
 	DefaultResolver = &r
-	defer func() {
-		DefaultResolver = originalDefault
-	}()
+	defer func() { DefaultResolver = originalDefault }()
+	// Redirect host file lookups.
+	defer func(orig string) { testHookHostsPath = orig }(testHookHostsPath)
+	testHookHostsPath = "testdata/hosts"
 
 	_, err := r.LookupCNAME(context.Background(), "golang.org")
 	if expected := "lookup golang.org: CNAME target is invalid"; err == nil || err.Error() != expected {
-		t.Errorf("Resolver.LookupCNAME returned unexpected error, got %q, want %q", err.Error(), expected)
+		t.Errorf("Resolver.LookupCNAME returned unexpected error, got %q, want %q", err, expected)
 	}
 	_, err = LookupCNAME("golang.org")
 	if expected := "lookup golang.org: CNAME target is invalid"; err == nil || err.Error() != expected {
-		t.Errorf("LookupCNAME returned unexpected error, got %q, want %q", err.Error(), expected)
+		t.Errorf("LookupCNAME returned unexpected error, got %q, want %q", err, expected)
 	}
 
 	_, _, err = r.LookupSRV(context.Background(), "target", "tcp", "golang.org")
 	if expected := "lookup golang.org: SRV target is invalid"; err == nil || err.Error() != expected {
-		t.Errorf("Resolver.LookupSRV returned unexpected error, got %q, want %q", err.Error(), expected)
+		t.Errorf("Resolver.LookupSRV returned unexpected error, got %q, want %q", err, expected)
 	}
 	_, _, err = LookupSRV("target", "tcp", "golang.org")
 	if expected := "lookup golang.org: SRV target is invalid"; err == nil || err.Error() != expected {
-		t.Errorf("LookupSRV returned unexpected error, got %q, want %q", err.Error(), expected)
+		t.Errorf("LookupSRV returned unexpected error, got %q, want %q", err, expected)
 	}
 
 	_, _, err = r.LookupSRV(context.Background(), "hdr", "tcp", "golang.org")
 	if expected := "lookup golang.org: SRV header name is invalid"; err == nil || err.Error() != expected {
-		t.Errorf("Resolver.LookupSRV returned unexpected error, got %q, want %q", err.Error(), expected)
+		t.Errorf("Resolver.LookupSRV returned unexpected error, got %q, want %q", err, expected)
 	}
 	_, _, err = LookupSRV("hdr", "tcp", "golang.org")
 	if expected := "lookup golang.org: SRV header name is invalid"; err == nil || err.Error() != expected {
-		t.Errorf("LookupSRV returned unexpected error, got %q, want %q", err.Error(), expected)
+		t.Errorf("LookupSRV returned unexpected error, got %q, want %q", err, expected)
 	}
 
 	_, err = r.LookupMX(context.Background(), "golang.org")
 	if expected := "lookup golang.org: MX target is invalid"; err == nil || err.Error() != expected {
-		t.Errorf("Resolver.LookupMX returned unexpected error, got %q, want %q", err.Error(), expected)
+		t.Errorf("Resolver.LookupMX returned unexpected error, got %q, want %q", err, expected)
 	}
 	_, err = LookupMX("golang.org")
 	if expected := "lookup golang.org: MX target is invalid"; err == nil || err.Error() != expected {
-		t.Errorf("LookupMX returned unexpected error, got %q, want %q", err.Error(), expected)
+		t.Errorf("LookupMX returned unexpected error, got %q, want %q", err, expected)
 	}
 
 	_, err = r.LookupNS(context.Background(), "golang.org")
 	if expected := "lookup golang.org: NS target is invalid"; err == nil || err.Error() != expected {
-		t.Errorf("Resolver.LookupNS returned unexpected error, got %q, want %q", err.Error(), expected)
+		t.Errorf("Resolver.LookupNS returned unexpected error, got %q, want %q", err, expected)
 	}
 	_, err = LookupNS("golang.org")
 	if expected := "lookup golang.org: NS target is invalid"; err == nil || err.Error() != expected {
-		t.Errorf("LookupNS returned unexpected error, got %q, want %q", err.Error(), expected)
+		t.Errorf("LookupNS returned unexpected error, got %q, want %q", err, expected)
 	}
 
-	_, err = r.LookupAddr(context.Background(), "1.2.3.4")
-	if expected := "lookup 1.2.3.4: PTR target is invalid"; err == nil || err.Error() != expected {
-		t.Errorf("Resolver.LookupAddr returned unexpected error, got %q, want %q", err.Error(), expected)
+	_, err = r.LookupAddr(context.Background(), "192.0.2.42")
+	if expected := "lookup 192.0.2.42: PTR target is invalid"; err == nil || err.Error() != expected {
+		t.Errorf("Resolver.LookupAddr returned unexpected error, got %q, want %q", err, expected)
 	}
-	_, err = LookupAddr("1.2.3.4")
-	if expected := "lookup 1.2.3.4: PTR target is invalid"; err == nil || err.Error() != expected {
-		t.Errorf("LookupAddr returned unexpected error, got %q, want %q", err.Error(), expected)
+	_, err = LookupAddr("192.0.2.42")
+	if expected := "lookup 192.0.2.42: PTR target is invalid"; err == nil || err.Error() != expected {
+		t.Errorf("LookupAddr returned unexpected error, got %q, want %q", err, expected)
 	}
 }
-- 
GitLab


From e0d029f75846f84f79e63f6100c57047f4a3fa98 Mon Sep 17 00:00:00 2001
From: Michael Pratt <mpratt@google.com>
Date: Wed, 2 Jun 2021 17:44:43 -0400
Subject: [PATCH 2167/2400] runtime: avoid gp.lockedm race in exitsyscall0

Following https://golang.org/cl/291329, exitsyscall0 accesses gp.lockedm
after releasing gp to the global runq. This creates a race window where
another M may schedule the (unlocked) G, which subsequently calls
LockOSThread, setting gp.lockedm and thus causing exitsyscall0 to think
it should call stoplockedm.

Avoid this race by checking if gp is locked before releasing it to the
global runq.

Fixes #46524

Change-Id: I3acdaf09e7a2178725adbe61e985130e9ebd0680
Reviewed-on: https://go-review.googlesource.com/c/go/+/324350
Trust: Michael Pratt <mpratt@google.com>
Run-TryBot: Michael Pratt <mpratt@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/proc.go | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index ded406cc28..59160c6525 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -4083,8 +4083,16 @@ func exitsyscall0(gp *g) {
 	if schedEnabled(gp) {
 		_p_ = pidleget()
 	}
+	var locked bool
 	if _p_ == nil {
 		globrunqput(gp)
+
+		// Below, we stoplockedm if gp is locked. globrunqput releases
+		// ownership of gp, so we must check if gp is locked prior to
+		// committing the release by unlocking sched.lock, otherwise we
+		// could race with another M transitioning gp from unlocked to
+		// locked.
+		locked = gp.lockedm != 0
 	} else if atomic.Load(&sched.sysmonwait) != 0 {
 		atomic.Store(&sched.sysmonwait, 0)
 		notewakeup(&sched.sysmonnote)
@@ -4094,7 +4102,7 @@ func exitsyscall0(gp *g) {
 		acquirep(_p_)
 		execute(gp, false) // Never returns.
 	}
-	if gp.lockedm != 0 {
+	if locked {
 		// Wait until another thread schedules gp and so m again.
 		//
 		// N.B. lockedm must be this M, as this g was running on this M
-- 
GitLab


From 6d9830111402d9bd69893a8ad6074ac92a5ddd0d Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Thu, 3 Jun 2021 14:50:10 -0400
Subject: [PATCH 2168/2400] cmd/link: use correct alignment in PE DWARF
 sections

Set the correct section flags to insure that .debug_* sections are
using 1-byte alignment instead of the default. This seems to be
important for later versions of LLVM-mingw on windows (shows up on the
windows/arm64 builder).

Updates #46406.

Change-Id: I023d5208374f867552ba68b45011f7990159868f
Reviewed-on: https://go-review.googlesource.com/c/go/+/324763
Trust: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/link/internal/ld/pe.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/link/internal/ld/pe.go b/src/cmd/link/internal/ld/pe.go
index 3540c07da1..8eb4231c3a 100644
--- a/src/cmd/link/internal/ld/pe.go
+++ b/src/cmd/link/internal/ld/pe.go
@@ -475,7 +475,7 @@ func (f *peFile) addDWARFSection(name string, size int) *peSection {
 	off := f.stringTable.add(name)
 	h := f.addSection(name, size, size)
 	h.shortName = fmt.Sprintf("/%d", off)
-	h.characteristics = IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_CNT_INITIALIZED_DATA
+	h.characteristics = IMAGE_SCN_ALIGN_1BYTES | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_CNT_INITIALIZED_DATA
 	return h
 }
 
-- 
GitLab


From b29b123e079183a05abc1066007a51d4f565cd88 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 3 Jun 2021 18:00:53 -0700
Subject: [PATCH 2169/2400] cmd/compile: remove spurious ir.Dump

This ir.Dump call is a debugging artifact introduced in
golang.org/cl/274103, which should never be printed for valid,
non-generic code, but evidently can now sometimes appear due to how
the parser handles invalid syntax.

The parser should probably not recognize "x[2]" as a type expression
in non-generics mode, but also probably we shouldn't try noding after
reporting syntax errors. Either way, this diagnostic has outlived its
usefulness, and noder's days are numbered anyway, so we might as well
just remove it to save end users any confusion.

Updates #46558.

Change-Id: Ib68502ef834d610b883c2f2bb11d9b385bc66e37
Reviewed-on: https://go-review.googlesource.com/c/go/+/324991
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/noder/noder.go | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/cmd/compile/internal/noder/noder.go b/src/cmd/compile/internal/noder/noder.go
index 4c7c9fc322..5fcad096c2 100644
--- a/src/cmd/compile/internal/noder/noder.go
+++ b/src/cmd/compile/internal/noder/noder.go
@@ -882,9 +882,6 @@ func (p *noder) typeExpr(typ syntax.Expr) ir.Ntype {
 	if n == nil {
 		return nil
 	}
-	if _, ok := n.(ir.Ntype); !ok {
-		ir.Dump("NOT NTYPE", n)
-	}
 	return n.(ir.Ntype)
 }
 
-- 
GitLab


From 962d5c997af450af1de9a38eb6510cdfc86ea689 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 2 Jun 2021 12:22:50 -0700
Subject: [PATCH 2170/2400] cmd/compile,go/types: restrict use of
 unsafe.{Add,Slice} to go1.17 or newer

This CL updates cmd/compile (including types2) and go/types to report
errors about using unsafe.Add and unsafe.Slice when language
compatibility is set to Go 1.16 or older.

Fixes #46525.

Change-Id: I1bfe025a672d9f4b929f443064ad1effd38d0363
Reviewed-on: https://go-review.googlesource.com/c/go/+/324369
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Robert Findley <rfindley@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/typecheck/func.go  | 12 ++++++++++++
 src/cmd/compile/internal/types2/builtins.go | 10 ++++++++++
 src/go/types/builtins.go                    | 10 ++++++++++
 test/fixedbugs/issue46525.go                | 14 ++++++++++++++
 4 files changed, 46 insertions(+)
 create mode 100644 test/fixedbugs/issue46525.go

diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index f381e1dbdc..a6dfbbf569 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -981,6 +981,12 @@ func tcRecover(n *ir.CallExpr) ir.Node {
 
 // tcUnsafeAdd typechecks an OUNSAFEADD node.
 func tcUnsafeAdd(n *ir.BinaryExpr) *ir.BinaryExpr {
+	if !types.AllowsGoVersion(curpkg(), 1, 17) {
+		base.ErrorfVers("go1.17", "unsafe.Add")
+		n.SetType(nil)
+		return n
+	}
+
 	n.X = AssignConv(Expr(n.X), types.Types[types.TUNSAFEPTR], "argument to unsafe.Add")
 	n.Y = DefaultLit(Expr(n.Y), types.Types[types.TINT])
 	if n.X.Type() == nil || n.Y.Type() == nil {
@@ -997,6 +1003,12 @@ func tcUnsafeAdd(n *ir.BinaryExpr) *ir.BinaryExpr {
 
 // tcUnsafeSlice typechecks an OUNSAFESLICE node.
 func tcUnsafeSlice(n *ir.BinaryExpr) *ir.BinaryExpr {
+	if !types.AllowsGoVersion(curpkg(), 1, 17) {
+		base.ErrorfVers("go1.17", "unsafe.Slice")
+		n.SetType(nil)
+		return n
+	}
+
 	n.X = Expr(n.X)
 	n.Y = Expr(n.Y)
 	if n.X.Type() == nil || n.Y.Type() == nil {
diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go
index b9e178dd57..f90e06f226 100644
--- a/src/cmd/compile/internal/types2/builtins.go
+++ b/src/cmd/compile/internal/types2/builtins.go
@@ -579,6 +579,11 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 
 	case _Add:
 		// unsafe.Add(ptr unsafe.Pointer, len IntegerType) unsafe.Pointer
+		if !check.allowVersion(check.pkg, 1, 17) {
+			check.error(call.Fun, "unsafe.Add requires go1.17 or later")
+			return
+		}
+
 		check.assignment(x, Typ[UnsafePointer], "argument to unsafe.Add")
 		if x.mode == invalid {
 			return
@@ -675,6 +680,11 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 
 	case _Slice:
 		// unsafe.Slice(ptr *T, len IntegerType) []T
+		if !check.allowVersion(check.pkg, 1, 17) {
+			check.error(call.Fun, "unsafe.Slice requires go1.17 or later")
+			return
+		}
+
 		typ := asPointer(x.typ)
 		if typ == nil {
 			check.errorf(x, invalidArg+"%s is not a pointer", x)
diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go
index 739051cc61..2a2d54da88 100644
--- a/src/go/types/builtins.go
+++ b/src/go/types/builtins.go
@@ -588,6 +588,11 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 
 	case _Add:
 		// unsafe.Add(ptr unsafe.Pointer, len IntegerType) unsafe.Pointer
+		if !check.allowVersion(check.pkg, 1, 17) {
+			check.errorf(call.Fun, _InvalidUnsafeAdd, "unsafe.Add requires go1.17 or later")
+			return
+		}
+
 		check.assignment(x, Typ[UnsafePointer], "argument to unsafe.Add")
 		if x.mode == invalid {
 			return
@@ -684,6 +689,11 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 
 	case _Slice:
 		// unsafe.Slice(ptr *T, len IntegerType) []T
+		if !check.allowVersion(check.pkg, 1, 17) {
+			check.errorf(call.Fun, _InvalidUnsafeSlice, "unsafe.Slice requires go1.17 or later")
+			return
+		}
+
 		typ := asPointer(x.typ)
 		if typ == nil {
 			check.invalidArg(x, _InvalidUnsafeSlice, "%s is not a pointer", x)
diff --git a/test/fixedbugs/issue46525.go b/test/fixedbugs/issue46525.go
new file mode 100644
index 0000000000..164e1473ce
--- /dev/null
+++ b/test/fixedbugs/issue46525.go
@@ -0,0 +1,14 @@
+// errorcheck -lang=go1.16
+
+// Copyright 2021 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 p
+
+import "unsafe"
+
+func main() {
+	_ = unsafe.Add(unsafe.Pointer(nil), 0) // ERROR "unsafe.Add requires go1.17 or later"
+	_ = unsafe.Slice(new(byte), 1)         // ERROR "unsafe.Slice requires go1.17 or later"
+}
-- 
GitLab


From 021444007590da4c1f6e504904e2871a1012c0bf Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Thu, 13 May 2021 13:19:14 +0200
Subject: [PATCH 2171/2400] syscall: do not pass console handles to
 PROC_THREAD_ATTRIBUTE_HANDLE_LIST on Windows 7

On Windows 7 (and below), console handles are not real kernel handles
but are rather userspace objects, with information passed via special
bits in the handle itself. That means they can't be passed in
PROC_THREAD_ATTRIBUTE_HANDLE_LIST, even though they can be inherited.
So, we filter the list passed to PROC_THREAD_ATTRIBUTE_HANDLE_LIST to
not have any console handles on Windows 7. At the same time, it turns
out that the presence of a NULL handle in the list is enough to render
PROC_THREAD_ATTRIBUTE_HANDLE_LIST completely useless, so filter these
out too. Console handles also can't be duplicated into parent processes,
as inhertance always happens from the present process, so duplicate
always into the present process even when a parent process is specified.

Fixes #45914.

Change-Id: I70b4ff4874dbf0507d9ec9278f63b9b4dd4f1999
Reviewed-on: https://go-review.googlesource.com/c/go/+/319310
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Trust: Alex Brainman <alex.brainman@gmail.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
---
 src/syscall/exec_windows.go     | 54 ++++++++++++++++++++++++++++-----
 src/syscall/syscall_windows.go  |  1 +
 src/syscall/zsyscall_windows.go |  7 +++++
 3 files changed, 55 insertions(+), 7 deletions(-)

diff --git a/src/syscall/exec_windows.go b/src/syscall/exec_windows.go
index 253e9e8c1f..18d15028c3 100644
--- a/src/syscall/exec_windows.go
+++ b/src/syscall/exec_windows.go
@@ -313,6 +313,17 @@ func StartProcess(argv0 string, argv []string, attr *ProcAttr) (pid int, handle
 		}
 	}
 
+	var maj, min, build uint32
+	rtlGetNtVersionNumbers(&maj, &min, &build)
+	isWin7 := maj < 6 || (maj == 6 && min <= 1)
+	// NT kernel handles are divisible by 4, with the bottom 3 bits left as
+	// a tag. The fully set tag correlates with the types of handles we're
+	// concerned about here.  Except, the kernel will interpret some
+	// special handle values, like -1, -2, and so forth, so kernelbase.dll
+	// checks to see that those bottom three bits are checked, but that top
+	// bit is not checked.
+	isLegacyWin7ConsoleHandle := func(handle Handle) bool { return isWin7 && handle&0x10000003 == 3 }
+
 	p, _ := GetCurrentProcess()
 	parentProcess := p
 	if sys.ParentProcess != 0 {
@@ -321,7 +332,15 @@ func StartProcess(argv0 string, argv []string, attr *ProcAttr) (pid int, handle
 	fd := make([]Handle, len(attr.Files))
 	for i := range attr.Files {
 		if attr.Files[i] > 0 {
-			err := DuplicateHandle(p, Handle(attr.Files[i]), parentProcess, &fd[i], 0, true, DUPLICATE_SAME_ACCESS)
+			destinationProcessHandle := parentProcess
+
+			// On Windows 7, console handles aren't real handles, and can only be duplicated
+			// into the current process, not a parent one, which amounts to the same thing.
+			if parentProcess != p && isLegacyWin7ConsoleHandle(Handle(attr.Files[i])) {
+				destinationProcessHandle = p
+			}
+
+			err := DuplicateHandle(p, Handle(attr.Files[i]), destinationProcessHandle, &fd[i], 0, true, DUPLICATE_SAME_ACCESS)
 			if err != nil {
 				return 0, 0, err
 			}
@@ -351,19 +370,40 @@ func StartProcess(argv0 string, argv []string, attr *ProcAttr) (pid int, handle
 	si.StdErr = fd[2]
 
 	fd = append(fd, sys.AdditionalInheritedHandles...)
+
+	// On Windows 7, console handles aren't real handles, so don't pass them
+	// through to PROC_THREAD_ATTRIBUTE_HANDLE_LIST.
+	for i := range fd {
+		if isLegacyWin7ConsoleHandle(fd[i]) {
+			fd[i] = 0
+		}
+	}
+
+	// The presence of a NULL handle in the list is enough to cause PROC_THREAD_ATTRIBUTE_HANDLE_LIST
+	// to treat the entire list as empty, so remove NULL handles.
+	j := 0
+	for i := range fd {
+		if fd[i] != 0 {
+			fd[j] = fd[i]
+			j++
+		}
+	}
+	fd = fd[:j]
+
 	// Do not accidentally inherit more than these handles.
-	err = updateProcThreadAttribute(si.ProcThreadAttributeList, 0, _PROC_THREAD_ATTRIBUTE_HANDLE_LIST, unsafe.Pointer(&fd[0]), uintptr(len(fd))*unsafe.Sizeof(fd[0]), nil, nil)
-	if err != nil {
-		return 0, 0, err
+	if len(fd) > 0 {
+		err = updateProcThreadAttribute(si.ProcThreadAttributeList, 0, _PROC_THREAD_ATTRIBUTE_HANDLE_LIST, unsafe.Pointer(&fd[0]), uintptr(len(fd))*unsafe.Sizeof(fd[0]), nil, nil)
+		if err != nil {
+			return 0, 0, err
+		}
 	}
 
 	pi := new(ProcessInformation)
-
 	flags := sys.CreationFlags | CREATE_UNICODE_ENVIRONMENT | _EXTENDED_STARTUPINFO_PRESENT
 	if sys.Token != 0 {
-		err = CreateProcessAsUser(sys.Token, argv0p, argvp, sys.ProcessAttributes, sys.ThreadAttributes, !sys.NoInheritHandles, flags, createEnvBlock(attr.Env), dirp, &si.StartupInfo, pi)
+		err = CreateProcessAsUser(sys.Token, argv0p, argvp, sys.ProcessAttributes, sys.ThreadAttributes, len(fd) > 0 && !sys.NoInheritHandles, flags, createEnvBlock(attr.Env), dirp, &si.StartupInfo, pi)
 	} else {
-		err = CreateProcess(argv0p, argvp, sys.ProcessAttributes, sys.ThreadAttributes, !sys.NoInheritHandles, flags, createEnvBlock(attr.Env), dirp, &si.StartupInfo, pi)
+		err = CreateProcess(argv0p, argvp, sys.ProcessAttributes, sys.ThreadAttributes, len(fd) > 0 && !sys.NoInheritHandles, flags, createEnvBlock(attr.Env), dirp, &si.StartupInfo, pi)
 	}
 	if err != nil {
 		return 0, 0, err
diff --git a/src/syscall/syscall_windows.go b/src/syscall/syscall_windows.go
index fc734effbb..660179ae9e 100644
--- a/src/syscall/syscall_windows.go
+++ b/src/syscall/syscall_windows.go
@@ -198,6 +198,7 @@ func NewCallbackCDecl(fn interface{}) uintptr {
 //sys	FreeLibrary(handle Handle) (err error)
 //sys	GetProcAddress(module Handle, procname string) (proc uintptr, err error)
 //sys	GetVersion() (ver uint32, err error)
+//sys	rtlGetNtVersionNumbers(majorVersion *uint32, minorVersion *uint32, buildNumber *uint32) = ntdll.RtlGetNtVersionNumbers
 //sys	formatMessage(flags uint32, msgsrc uintptr, msgid uint32, langid uint32, buf []uint16, args *byte) (n uint32, err error) = FormatMessageW
 //sys	ExitProcess(exitcode uint32)
 //sys	CreateFile(name *uint16, access uint32, mode uint32, sa *SecurityAttributes, createmode uint32, attrs uint32, templatefile int32) (handle Handle, err error) [failretval==InvalidHandle] = CreateFileW
diff --git a/src/syscall/zsyscall_windows.go b/src/syscall/zsyscall_windows.go
index 10d0f54e8c..b9e429693d 100644
--- a/src/syscall/zsyscall_windows.go
+++ b/src/syscall/zsyscall_windows.go
@@ -41,6 +41,7 @@ var (
 	moddnsapi   = NewLazyDLL(sysdll.Add("dnsapi.dll"))
 	modiphlpapi = NewLazyDLL(sysdll.Add("iphlpapi.dll"))
 	modkernel32 = NewLazyDLL(sysdll.Add("kernel32.dll"))
+	modntdll    = NewLazyDLL(sysdll.Add("ntdll.dll"))
 	modmswsock  = NewLazyDLL(sysdll.Add("mswsock.dll"))
 	modnetapi32 = NewLazyDLL(sysdll.Add("netapi32.dll"))
 	modsecur32  = NewLazyDLL(sysdll.Add("secur32.dll"))
@@ -167,6 +168,7 @@ var (
 	procNetApiBufferFree                   = modnetapi32.NewProc("NetApiBufferFree")
 	procNetGetJoinInformation              = modnetapi32.NewProc("NetGetJoinInformation")
 	procNetUserGetInfo                     = modnetapi32.NewProc("NetUserGetInfo")
+	procRtlGetNtVersionNumbers             = modntdll.NewProc("RtlGetNtVersionNumbers")
 	procGetUserNameExW                     = modsecur32.NewProc("GetUserNameExW")
 	procTranslateNameW                     = modsecur32.NewProc("TranslateNameW")
 	procCommandLineToArgvW                 = modshell32.NewProc("CommandLineToArgvW")
@@ -1213,6 +1215,11 @@ func NetUserGetInfo(serverName *uint16, userName *uint16, level uint32, buf **by
 	return
 }
 
+func rtlGetNtVersionNumbers(majorVersion *uint32, minorVersion *uint32, buildNumber *uint32) {
+	Syscall(procRtlGetNtVersionNumbers.Addr(), 3, uintptr(unsafe.Pointer(majorVersion)), uintptr(unsafe.Pointer(minorVersion)), uintptr(unsafe.Pointer(buildNumber)))
+	return
+}
+
 func GetUserNameEx(nameFormat uint32, nameBuffre *uint16, nSize *uint32) (err error) {
 	r1, _, e1 := Syscall(procGetUserNameExW.Addr(), 3, uintptr(nameFormat), uintptr(unsafe.Pointer(nameBuffre)), uintptr(unsafe.Pointer(nSize)))
 	if r1&0xff == 0 {
-- 
GitLab


From c6b62112292fa741d5708dfd63bd89eed3b6f8ee Mon Sep 17 00:00:00 2001
From: Aaron Sheah <aaronsheah@gmail.com>
Date: Thu, 3 Jun 2021 17:43:36 +0000
Subject: [PATCH 2172/2400] doc/go1.17: document testing changes for Go 1.17

For #44513. Fixes #46024

Change-Id: Icf3877d1fcd67448fbc79a0ce3db3f319ad4a0e9
GitHub-Last-Rev: 8c015935c2e376134d81aa577bffdca7fc03170d
GitHub-Pull-Request: golang/go#46324
Reviewed-on: https://go-review.googlesource.com/c/go/+/322109
Reviewed-by: Heschi Kreinick <heschi@google.com>
Trust: Jeremy Faller <jeremy@golang.org>
Trust: Dmitri Shuralyov <dmitshur@golang.org>
---
 doc/go1.17.html | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 27ef524286..7438d894fe 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -659,9 +659,8 @@ Do not send CLs removing the interior tags from such phrases.
 <dl id="testing"><dt><a href="/pkg/testing/">testing</a></dt>
   <dd>
     <p><!-- CL 310033 -->
-      TODO: <a href="https://golang.org/cl/310033">https://golang.org/cl/310033</a>: add -shuffle=off|on|N to alter the execution order of tests and benchmarks
+      Added a new <a href="/cmd/go/#hdr-Testing_flags">testing flag</a> <code>-shuffle</code> which controls the execution order of tests and benchmarks.
     </p>
-
     <p><!-- CL 260577 -->
       The new
       <a href="/pkg/testing/#T.Setenv"><code>T.Setenv</code></a>
-- 
GitLab


From 79cd407f88f640b889df7645bf3e0491ed25eac7 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 4 Jun 2021 10:56:06 -0400
Subject: [PATCH 2173/2400] syscall: regenerate zsyscall_windows.go

The declaration order in CL 319310 does not match what the generator
produces from scratch. That currently causes
cmd/internal/moddeps.TestAllDependencies to fail, since it is
explicitly checking for that kind of skew.

Updates #45914

Change-Id: If2a9cabc3d54e21deba7cb438fa364df205f38ac
Reviewed-on: https://go-review.googlesource.com/c/go/+/325112
Trust: Bryan C. Mills <bcmills@google.com>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/syscall/zsyscall_windows.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/syscall/zsyscall_windows.go b/src/syscall/zsyscall_windows.go
index b9e429693d..7bfff16be6 100644
--- a/src/syscall/zsyscall_windows.go
+++ b/src/syscall/zsyscall_windows.go
@@ -41,9 +41,9 @@ var (
 	moddnsapi   = NewLazyDLL(sysdll.Add("dnsapi.dll"))
 	modiphlpapi = NewLazyDLL(sysdll.Add("iphlpapi.dll"))
 	modkernel32 = NewLazyDLL(sysdll.Add("kernel32.dll"))
-	modntdll    = NewLazyDLL(sysdll.Add("ntdll.dll"))
 	modmswsock  = NewLazyDLL(sysdll.Add("mswsock.dll"))
 	modnetapi32 = NewLazyDLL(sysdll.Add("netapi32.dll"))
+	modntdll    = NewLazyDLL(sysdll.Add("ntdll.dll"))
 	modsecur32  = NewLazyDLL(sysdll.Add("secur32.dll"))
 	modshell32  = NewLazyDLL(sysdll.Add("shell32.dll"))
 	moduserenv  = NewLazyDLL(sysdll.Add("userenv.dll"))
-- 
GitLab


From 105c5b50e0098720b9e24aea5efa8e161c31db6d Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Tue, 25 May 2021 16:23:16 +0200
Subject: [PATCH 2174/2400] os: terminate windows processes via handle directly

We already have a handle to the process, so use that for termination,
rather than doing a new lookup based on the PID.

Change-Id: I2958c1817f12f3dd783412baacbf629049f6956a
Reviewed-on: https://go-review.googlesource.com/c/go/+/322509
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/os/exec_windows.go | 20 ++++++++------------
 1 file changed, 8 insertions(+), 12 deletions(-)

diff --git a/src/os/exec_windows.go b/src/os/exec_windows.go
index 5710401acd..b59a01a75e 100644
--- a/src/os/exec_windows.go
+++ b/src/os/exec_windows.go
@@ -45,16 +45,6 @@ func (p *Process) wait() (ps *ProcessState, err error) {
 	return &ProcessState{p.Pid, syscall.WaitStatus{ExitCode: ec}, &u}, nil
 }
 
-func terminateProcess(pid, exitcode int) error {
-	h, e := syscall.OpenProcess(syscall.PROCESS_TERMINATE, false, uint32(pid))
-	if e != nil {
-		return NewSyscallError("OpenProcess", e)
-	}
-	defer syscall.CloseHandle(h)
-	e = syscall.TerminateProcess(h, uint32(exitcode))
-	return NewSyscallError("TerminateProcess", e)
-}
-
 func (p *Process) signal(sig Signal) error {
 	handle := atomic.LoadUintptr(&p.handle)
 	if handle == uintptr(syscall.InvalidHandle) {
@@ -64,9 +54,15 @@ func (p *Process) signal(sig Signal) error {
 		return ErrProcessDone
 	}
 	if sig == Kill {
-		err := terminateProcess(p.Pid, 1)
+		var terminationHandle syscall.Handle
+		e := syscall.DuplicateHandle(^syscall.Handle(0), syscall.Handle(handle), ^syscall.Handle(0), &terminationHandle, syscall.PROCESS_TERMINATE, false, 0)
+		if e != nil {
+			return NewSyscallError("DuplicateHandle", e)
+		}
 		runtime.KeepAlive(p)
-		return err
+		defer syscall.CloseHandle(terminationHandle)
+		e = syscall.TerminateProcess(syscall.Handle(terminationHandle), 1)
+		return NewSyscallError("TerminateProcess", e)
 	}
 	// TODO(rsc): Handle Interrupt too?
 	return syscall.Errno(syscall.EWINDOWS)
-- 
GitLab


From 3a9d906edcfd0fa574ecd5498f8999b56f1e5fa1 Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Tue, 25 May 2021 16:24:41 +0200
Subject: [PATCH 2175/2400] os: avoid finalizer race in windows process object

If proc.Release is called concurrently, a handle will be double-freed.

Change-Id: I0c0c32e312e07bc8615e0bf9e9b691214444d8d5
Reviewed-on: https://go-review.googlesource.com/c/go/+/322510
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/os/exec_windows.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/os/exec_windows.go b/src/os/exec_windows.go
index b59a01a75e..239bed198f 100644
--- a/src/os/exec_windows.go
+++ b/src/os/exec_windows.go
@@ -69,7 +69,7 @@ func (p *Process) signal(sig Signal) error {
 }
 
 func (p *Process) release() error {
-	handle := atomic.LoadUintptr(&p.handle)
+	handle := atomic.SwapUintptr(&p.handle, uintptr(syscall.InvalidHandle))
 	if handle == uintptr(syscall.InvalidHandle) {
 		return syscall.EINVAL
 	}
@@ -77,7 +77,6 @@ func (p *Process) release() error {
 	if e != nil {
 		return NewSyscallError("CloseHandle", e)
 	}
-	atomic.StoreUintptr(&p.handle, uintptr(syscall.InvalidHandle))
 	// no need for a finalizer anymore
 	runtime.SetFinalizer(p, nil)
 	return nil
-- 
GitLab


From 831f9376d8d730b16fb33dfd775618dffe13ce7a Mon Sep 17 00:00:00 2001
From: Damien Neil <dneil@google.com>
Date: Fri, 12 Mar 2021 13:53:11 -0800
Subject: [PATCH 2176/2400] net/http: fix ResponseWriter.ReadFrom with short
 reads

CL 249238 changes ResponseWriter.ReadFrom to probe the source with
a single read of sniffLen bytes before writing the response header.
If the source returns less than sniffLen bytes without reaching
EOF, this can cause Content-Type and Content-Length detection to
fail.

Fix ResponseWrite.ReadFrom to copy a full sniffLen bytes from
the source as a probe.

Drop the explicit call to w.WriteHeader; writing the probe will
trigger a WriteHeader call.

Consistently use io.CopyBuffer; ReadFrom has already acquired a
copy buffer, so it may as well use it.

Fixes #44953.

Change-Id: Ic49305fb827a2bd7da4764b68d64b797b5157dc0
Reviewed-on: https://go-review.googlesource.com/c/go/+/301449
Trust: Damien Neil <dneil@google.com>
Run-TryBot: Damien Neil <dneil@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
---
 src/net/http/server.go     |  40 +++---------
 src/net/http/sniff_test.go | 122 +++++++++++++++++++++++++++++--------
 2 files changed, 107 insertions(+), 55 deletions(-)

diff --git a/src/net/http/server.go b/src/net/http/server.go
index 4e73508973..430019de50 100644
--- a/src/net/http/server.go
+++ b/src/net/http/server.go
@@ -577,37 +577,17 @@ func (w *response) ReadFrom(src io.Reader) (n int64, err error) {
 		return io.CopyBuffer(writerOnly{w}, src, buf)
 	}
 
-	// sendfile path:
-
-	// Do not start actually writing response until src is readable.
-	// If body length is <= sniffLen, sendfile/splice path will do
-	// little anyway. This small read also satisfies sniffing the
-	// body in case Content-Type is missing.
-	nr, er := src.Read(buf[:sniffLen])
-	atEOF := errors.Is(er, io.EOF)
-	n += int64(nr)
-
-	if nr > 0 {
-		// Write the small amount read normally.
-		nw, ew := w.Write(buf[:nr])
-		if ew != nil {
-			err = ew
-		} else if nr != nw {
-			err = io.ErrShortWrite
+	// Copy the first sniffLen bytes before switching to ReadFrom.
+	// This ensures we don't start writing the response before the
+	// source is available (see golang.org/issue/5660) and provides
+	// enough bytes to perform Content-Type sniffing when required.
+	if !w.cw.wroteHeader {
+		n0, err := io.CopyBuffer(writerOnly{w}, io.LimitReader(src, sniffLen), buf)
+		n += n0
+		if err != nil || n0 < sniffLen {
+			return n, err
 		}
 	}
-	if err == nil && er != nil && !atEOF {
-		err = er
-	}
-
-	// Do not send StatusOK in the error case where nothing has been written.
-	if err == nil && !w.wroteHeader {
-		w.WriteHeader(StatusOK) // nr == 0, no error (or EOF)
-	}
-
-	if err != nil || atEOF {
-		return n, err
-	}
 
 	w.w.Flush()  // get rid of any previous writes
 	w.cw.flush() // make sure Header is written; flush data to rwc
@@ -620,7 +600,7 @@ func (w *response) ReadFrom(src io.Reader) (n int64, err error) {
 		return n, err
 	}
 
-	n0, err := io.Copy(writerOnly{w}, src)
+	n0, err := io.CopyBuffer(writerOnly{w}, src, buf)
 	n += n0
 	return n, err
 }
diff --git a/src/net/http/sniff_test.go b/src/net/http/sniff_test.go
index 8d5350374d..e91335729a 100644
--- a/src/net/http/sniff_test.go
+++ b/src/net/http/sniff_test.go
@@ -157,9 +157,25 @@ func testServerIssue5953(t *testing.T, h2 bool) {
 	resp.Body.Close()
 }
 
-func TestContentTypeWithCopy_h1(t *testing.T) { testContentTypeWithCopy(t, h1Mode) }
-func TestContentTypeWithCopy_h2(t *testing.T) { testContentTypeWithCopy(t, h2Mode) }
-func testContentTypeWithCopy(t *testing.T, h2 bool) {
+type byteAtATimeReader struct {
+	buf []byte
+}
+
+func (b *byteAtATimeReader) Read(p []byte) (n int, err error) {
+	if len(p) < 1 {
+		return 0, nil
+	}
+	if len(b.buf) == 0 {
+		return 0, io.EOF
+	}
+	p[0] = b.buf[0]
+	b.buf = b.buf[1:]
+	return 1, nil
+}
+
+func TestContentTypeWithVariousSources_h1(t *testing.T) { testContentTypeWithVariousSources(t, h1Mode) }
+func TestContentTypeWithVariousSources_h2(t *testing.T) { testContentTypeWithVariousSources(t, h2Mode) }
+func testContentTypeWithVariousSources(t *testing.T, h2 bool) {
 	defer afterTest(t)
 
 	const (
@@ -167,30 +183,86 @@ func testContentTypeWithCopy(t *testing.T, h2 bool) {
 		expected = "text/html; charset=utf-8"
 	)
 
-	cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
-		// Use io.Copy from a bytes.Buffer to trigger ReadFrom.
-		buf := bytes.NewBuffer([]byte(input))
-		n, err := io.Copy(w, buf)
-		if int(n) != len(input) || err != nil {
-			t.Errorf("io.Copy(w, %q) = %v, %v want %d, nil", input, n, err, len(input))
-		}
-	}))
-	defer cst.close()
+	for _, test := range []struct {
+		name    string
+		handler func(ResponseWriter, *Request)
+	}{{
+		name: "write",
+		handler: func(w ResponseWriter, r *Request) {
+			// Write the whole input at once.
+			n, err := w.Write([]byte(input))
+			if int(n) != len(input) || err != nil {
+				t.Errorf("w.Write(%q) = %v, %v want %d, nil", input, n, err, len(input))
+			}
+		},
+	}, {
+		name: "write one byte at a time",
+		handler: func(w ResponseWriter, r *Request) {
+			// Write the input one byte at a time.
+			buf := []byte(input)
+			for i := range buf {
+				n, err := w.Write(buf[i : i+1])
+				if n != 1 || err != nil {
+					t.Errorf("w.Write(%q) = %v, %v want 1, nil", input, n, err)
+				}
+			}
+		},
+	}, {
+		name: "copy from Reader",
+		handler: func(w ResponseWriter, r *Request) {
+			// Use io.Copy from a plain Reader.
+			type readerOnly struct{ io.Reader }
+			buf := bytes.NewBuffer([]byte(input))
+			n, err := io.Copy(w, readerOnly{buf})
+			if int(n) != len(input) || err != nil {
+				t.Errorf("io.Copy(w, %q) = %v, %v want %d, nil", input, n, err, len(input))
+			}
+		},
+	}, {
+		name: "copy from bytes.Buffer",
+		handler: func(w ResponseWriter, r *Request) {
+			// Use io.Copy from a bytes.Buffer to trigger ReadFrom.
+			buf := bytes.NewBuffer([]byte(input))
+			n, err := io.Copy(w, buf)
+			if int(n) != len(input) || err != nil {
+				t.Errorf("io.Copy(w, %q) = %v, %v want %d, nil", input, n, err, len(input))
+			}
+		},
+	}, {
+		name: "copy one byte at a time",
+		handler: func(w ResponseWriter, r *Request) {
+			// Use io.Copy from a Reader that returns one byte at a time.
+			n, err := io.Copy(w, &byteAtATimeReader{[]byte(input)})
+			if int(n) != len(input) || err != nil {
+				t.Errorf("io.Copy(w, %q) = %v, %v want %d, nil", input, n, err, len(input))
+			}
+		},
+	}} {
+		t.Run(test.name, func(t *testing.T) {
+			cst := newClientServerTest(t, h2, HandlerFunc(test.handler))
+			defer cst.close()
+
+			resp, err := cst.c.Get(cst.ts.URL)
+			if err != nil {
+				t.Fatalf("Get: %v", err)
+			}
+			if ct := resp.Header.Get("Content-Type"); ct != expected {
+				t.Errorf("Content-Type = %q, want %q", ct, expected)
+			}
+			if want, got := resp.Header.Get("Content-Length"), fmt.Sprint(len(input)); want != got {
+				t.Errorf("Content-Length = %q, want %q", want, got)
+			}
+			data, err := io.ReadAll(resp.Body)
+			if err != nil {
+				t.Errorf("reading body: %v", err)
+			} else if !bytes.Equal(data, []byte(input)) {
+				t.Errorf("data is %q, want %q", data, input)
+			}
+			resp.Body.Close()
+
+		})
 
-	resp, err := cst.c.Get(cst.ts.URL)
-	if err != nil {
-		t.Fatalf("Get: %v", err)
-	}
-	if ct := resp.Header.Get("Content-Type"); ct != expected {
-		t.Errorf("Content-Type = %q, want %q", ct, expected)
-	}
-	data, err := io.ReadAll(resp.Body)
-	if err != nil {
-		t.Errorf("reading body: %v", err)
-	} else if !bytes.Equal(data, []byte(input)) {
-		t.Errorf("data is %q, want %q", data, input)
 	}
-	resp.Body.Close()
 }
 
 func TestSniffWriteSize_h1(t *testing.T) { testSniffWriteSize(t, h1Mode) }
-- 
GitLab


From 95939e8de71d9e8d8deea3d1605bd34130588292 Mon Sep 17 00:00:00 2001
From: sryoya <ryoyasekino1993@gmail.com>
Date: Sat, 5 Jun 2021 03:12:03 +0900
Subject: [PATCH 2177/2400] cmd/compile/internal/abi: fix typo in comment

Change-Id: I196045314b2b0e908d7b31ac0cea5b25404f3ee0
Reviewed-on: https://go-review.googlesource.com/c/go/+/325249
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Trust: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/abi/abiutils.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index cb8e9d7b0f..b8ea1955d1 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -449,7 +449,7 @@ func (config *ABIConfig) ABIAnalyze(t *types.Type, setNname bool) *ABIParamResul
 // parameterUpdateMu protects the Offset field of function/method parameters (a subset of structure Fields)
 var parameterUpdateMu sync.Mutex
 
-// FieldOffsetOf returns a concurency-safe version of f.Offset
+// FieldOffsetOf returns a concurrency-safe version of f.Offset
 func FieldOffsetOf(f *types.Field) int64 {
 	parameterUpdateMu.Lock()
 	defer parameterUpdateMu.Unlock()
-- 
GitLab


From 9d669ed47a502ca540c7f3329f84d89fc0c53971 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Fri, 4 Jun 2021 08:16:58 -0700
Subject: [PATCH 2178/2400] misc/cgo/errors: use expected column numbers

The test was using the wrong column numbers, and was erroneously
passing because there happened to be line numbers that matched those
column numbers. Change the test harness to require the expected line
number for the ERROR HERE regexp case, so that this doesn't happen again.

Also rename a couple of variables in the test to avoid useless
redeclaration errors.

Fixes #46534

Change-Id: I2fcbf5e379c346de5346035c73d174a3980c0927
Reviewed-on: https://go-review.googlesource.com/c/go/+/324970
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 misc/cgo/errors/errors_test.go   |  3 ++-
 misc/cgo/errors/testdata/err2.go | 12 ++++++------
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/misc/cgo/errors/errors_test.go b/misc/cgo/errors/errors_test.go
index a077b59478..68a30a44fe 100644
--- a/misc/cgo/errors/errors_test.go
+++ b/misc/cgo/errors/errors_test.go
@@ -40,7 +40,8 @@ func check(t *testing.T, file string) {
 			if len(frags) == 1 {
 				continue
 			}
-			re, err := regexp.Compile(string(frags[1]))
+			frag := fmt.Sprintf(":%d:.*%s", i+1, frags[1])
+			re, err := regexp.Compile(frag)
 			if err != nil {
 				t.Errorf("Invalid regexp after `ERROR HERE: `: %#q", frags[1])
 				continue
diff --git a/misc/cgo/errors/testdata/err2.go b/misc/cgo/errors/testdata/err2.go
index 1d22401aee..a90598fe35 100644
--- a/misc/cgo/errors/testdata/err2.go
+++ b/misc/cgo/errors/testdata/err2.go
@@ -40,15 +40,15 @@ func main() {
 	C.foop = x // ERROR HERE
 
 	// issue 13129: used to output error about C.unsignedshort with CC=clang
-	var x C.ushort
-	x = int(0) // ERROR HERE: C\.ushort
+	var x1 C.ushort
+	x1 = int(0) // ERROR HERE: C\.ushort
 
 	// issue 13423
 	_ = C.fopen() // ERROR HERE
 
 	// issue 13467
-	var x rune = '✈'
-	var _ rune = C.transform(x) // ERROR HERE: C\.int
+	var x2 rune = '✈'
+	var _ rune = C.transform(x2) // ERROR HERE: C\.int
 
 	// issue 13635: used to output error about C.unsignedchar.
 	// This test tests all such types.
@@ -91,10 +91,10 @@ func main() {
 
 	// issue 26745
 	_ = func(i int) int {
-		return C.i + 1 // ERROR HERE: :13
+		return C.i + 1 // ERROR HERE: 14
 	}
 	_ = func(i int) {
-		C.fi(i) // ERROR HERE: :6
+		C.fi(i) // ERROR HERE: 7
 	}
 
 	C.fi = C.fi // ERROR HERE
-- 
GitLab


From e3cb3817049ca5e9d96543500b72117f6ca659b8 Mon Sep 17 00:00:00 2001
From: Sergey Zagursky <gvozdoder@gmail.com>
Date: Fri, 4 Jun 2021 12:25:51 +0300
Subject: [PATCH 2179/2400] go/internal/gcimporter: don't waste CPU copying
 bytes in `io.ReadAll`

`io.ReadAll` dynamically reallocates byte slice because it doesn't know
its size in advance. We don't need to read an entire file into memory
and therefore may use `bufio.Reader` to read its contents.

Fixes #46564

Change-Id: Id504b1512662b6dea4775d523455896fa4162ab3
Reviewed-on: https://go-review.googlesource.com/c/go/+/325429
Reviewed-by: Dominik Honnef <dominik@honnef.co>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Dominik Honnef <dominik@honnef.co>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/go/internal/gcimporter/gcimporter.go | 11 ++++-------
 src/go/internal/gcimporter/iimport.go    | 21 +++++++++++----------
 2 files changed, 15 insertions(+), 17 deletions(-)

diff --git a/src/go/internal/gcimporter/gcimporter.go b/src/go/internal/gcimporter/gcimporter.go
index b74daca246..73cf6334fd 100644
--- a/src/go/internal/gcimporter/gcimporter.go
+++ b/src/go/internal/gcimporter/gcimporter.go
@@ -145,17 +145,14 @@ func Import(fset *token.FileSet, packages map[string]*types.Package, path, srcDi
 		err = fmt.Errorf("import %q: old textual export format no longer supported (recompile library)", path)
 
 	case "$$B\n":
-		var data []byte
-		data, err = io.ReadAll(buf)
-		if err != nil {
-			break
-		}
+		var exportFormat byte
+		exportFormat, err = buf.ReadByte()
 
 		// The indexed export format starts with an 'i'; the older
 		// binary export format starts with a 'c', 'd', or 'v'
 		// (from "version"). Select appropriate importer.
-		if len(data) > 0 && data[0] == 'i' {
-			_, pkg, err = iImportData(fset, packages, data[1:], id)
+		if err == nil && exportFormat == 'i' {
+			pkg, err = iImportData(fset, packages, buf, id)
 		} else {
 			err = fmt.Errorf("import %q: old binary export format no longer supported (recompile library)", path)
 		}
diff --git a/src/go/internal/gcimporter/iimport.go b/src/go/internal/gcimporter/iimport.go
index a3184e7641..76d47d08f1 100644
--- a/src/go/internal/gcimporter/iimport.go
+++ b/src/go/internal/gcimporter/iimport.go
@@ -8,6 +8,7 @@
 package gcimporter
 
 import (
+	"bufio"
 	"bytes"
 	"encoding/binary"
 	"fmt"
@@ -20,7 +21,7 @@ import (
 )
 
 type intReader struct {
-	*bytes.Reader
+	*bufio.Reader
 	path string
 }
 
@@ -61,7 +62,7 @@ const (
 // and returns the number of bytes consumed and a reference to the package.
 // If the export data version is not recognized or the format is otherwise
 // compromised, an error is returned.
-func iImportData(fset *token.FileSet, imports map[string]*types.Package, data []byte, path string) (_ int, pkg *types.Package, err error) {
+func iImportData(fset *token.FileSet, imports map[string]*types.Package, dataReader *bufio.Reader, path string) (pkg *types.Package, err error) {
 	const currentVersion = 1
 	version := int64(-1)
 	defer func() {
@@ -74,7 +75,7 @@ func iImportData(fset *token.FileSet, imports map[string]*types.Package, data []
 		}
 	}()
 
-	r := &intReader{bytes.NewReader(data), path}
+	r := &intReader{dataReader, path}
 
 	version = int64(r.uint64())
 	switch version {
@@ -86,10 +87,12 @@ func iImportData(fset *token.FileSet, imports map[string]*types.Package, data []
 	sLen := int64(r.uint64())
 	dLen := int64(r.uint64())
 
-	whence, _ := r.Seek(0, io.SeekCurrent)
-	stringData := data[whence : whence+sLen]
-	declData := data[whence+sLen : whence+sLen+dLen]
-	r.Seek(sLen+dLen, io.SeekCurrent)
+	data := make([]byte, sLen+dLen)
+	if _, err := io.ReadFull(r, data); err != nil {
+		errorf("cannot read %d bytes of stringData and declData: %s", len(data), err)
+	}
+	stringData := data[:sLen]
+	declData := data[sLen:]
 
 	p := iimporter{
 		ipath:   path,
@@ -165,9 +168,7 @@ func iImportData(fset *token.FileSet, imports map[string]*types.Package, data []
 
 	// package was imported completely and without errors
 	localpkg.MarkComplete()
-
-	consumed, _ := r.Seek(0, io.SeekCurrent)
-	return int(consumed), localpkg, nil
+	return localpkg, nil
 }
 
 type iimporter struct {
-- 
GitLab


From f4901341263adf7fc177e8e5e2e79576b490bb8f Mon Sep 17 00:00:00 2001
From: DQNEO <dqneoo@gmail.com>
Date: Mon, 31 May 2021 12:15:12 +0900
Subject: [PATCH 2180/2400] spec: improve wording by choosing an official term
 "keyword"

Replace "reserved word" by "keyword" as the latter is the official term.

Change-Id: I9f269759b872026034a9f47e4a761cff2d348ca0
Reviewed-on: https://go-review.googlesource.com/c/go/+/323729
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Ian Lance Taylor <iant@golang.org>
Trust: Robert Griesemer <gri@golang.org>
---
 doc/go_spec.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index e59b3554f2..7a2b3a80f0 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1,6 +1,6 @@
 <!--{
 	"Title": "The Go Programming Language Specification",
-	"Subtitle": "Version of Apr 28, 2021",
+	"Subtitle": "Version of Jun 2, 2021",
 	"Path": "/ref/spec"
 }-->
 
@@ -5020,7 +5020,7 @@ floating point, or string constants in case expressions.
 A type switch compares types rather than values. It is otherwise similar
 to an expression switch. It is marked by a special switch expression that
 has the form of a <a href="#Type_assertions">type assertion</a>
-using the reserved word <code>type</code> rather than an actual type:
+using the keyword <code>type</code> rather than an actual type:
 </p>
 
 <pre>
-- 
GitLab


From e1fa26026db313463a09289c2105591de33cf7b8 Mon Sep 17 00:00:00 2001
From: DQNEO <dqneoo@gmail.com>
Date: Mon, 31 May 2021 12:33:28 +0900
Subject: [PATCH 2181/2400] spec: improve wording consistency by eliminating
 "specifier"

The word "specifier" is used once only here and technically not defined.

Change-Id: Ifc9f0582f4eb3c3011ba60d8008234de511d4be6
Reviewed-on: https://go-review.googlesource.com/c/go/+/323730
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Ian Lance Taylor <iant@golang.org>
Trust: Robert Griesemer <gri@golang.org>
---
 doc/go_spec.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index 7a2b3a80f0..561d44271a 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -4909,7 +4909,7 @@ if x := f(); x &lt; y {
 
 <p>
 "Switch" statements provide multi-way execution.
-An expression or type specifier is compared to the "cases"
+An expression or type is compared to the "cases"
 inside the "switch" to determine which branch
 to execute.
 </p>
-- 
GitLab


From e3176bbc3ec7ab3889f02432f6fd088c90fc12dd Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Mon, 7 Jun 2021 10:24:11 -0400
Subject: [PATCH 2182/2400] crypto/tls: fix typo in Config.NextProtos docs

Change-Id: I916df584859595067e5e86c35607869397dbbd8c
Reviewed-on: https://go-review.googlesource.com/c/go/+/325651
Trust: Filippo Valsorda <filippo@golang.org>
Run-TryBot: Filippo Valsorda <filippo@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 src/crypto/tls/common.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/crypto/tls/common.go b/src/crypto/tls/common.go
index 77957ef82b..d561e61707 100644
--- a/src/crypto/tls/common.go
+++ b/src/crypto/tls/common.go
@@ -619,7 +619,7 @@ type Config struct {
 	// protocol will be one from this list, and the connection will fail
 	// if there is no mutually supported protocol. If NextProtos is empty
 	// or the peer doesn't support ALPN, the connection will succeed and
-	// ConnectionState.NegotiatedProtocol will be empty."
+	// ConnectionState.NegotiatedProtocol will be empty.
 	NextProtos []string
 
 	// ServerName is used to verify the hostname on the returned
-- 
GitLab


From 7406180012d828f536112c9bffb7d3edd9ea5c7e Mon Sep 17 00:00:00 2001
From: Branden J Brown <zephyrtronium@gmail.com>
Date: Wed, 2 Jun 2021 14:55:34 -0400
Subject: [PATCH 2183/2400] fmt: split package documentation into more sections

The package-level documentation on fmt previously had only two formal
sections, for printing and scanning. Because of this, the section on
printing was very long, including some pseudo-sections describing
particular features. This feature makes those pseudo-sections into
proper sections, both to improve readability and so that those sections
have hyperlinks on documentation sites.

Fixes #46522

Change-Id: I38b7bc3447610faca446051da235edcbbd063f61
Reviewed-on: https://go-review.googlesource.com/c/go/+/324349
Reviewed-by: Rob Pike <r@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Run-TryBot: Dmitri Shuralyov <dmitshur@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/fmt/doc.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/fmt/doc.go b/src/fmt/doc.go
index d05ee519c3..c584cc9465 100644
--- a/src/fmt/doc.go
+++ b/src/fmt/doc.go
@@ -189,7 +189,7 @@
 	When printing a struct, fmt cannot and therefore does not invoke
 	formatting methods such as Error or String on unexported fields.
 
-	Explicit argument indexes:
+	Explicit argument indexes
 
 	In Printf, Sprintf, and Fprintf, the default behavior is for each
 	formatting verb to format successive arguments passed in the call.
@@ -211,7 +211,7 @@
 		fmt.Sprintf("%d %d %#[1]x %#x", 16, 17)
 	will yield "16 17 0x10 0x11".
 
-	Format errors:
+	Format errors
 
 	If an invalid argument is given for a verb, such as providing
 	a string to %d, the generated string will contain a
-- 
GitLab


From 821270787109408ae7c86a01ccc93162be9c020c Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Mon, 7 Jun 2021 10:22:05 -0400
Subject: [PATCH 2184/2400] crypto/elliptic: update P-521 docs to say it's
 constant-time

This is true since CL 315274.

Also adjust the P-256 note, since Add, Double, and IsOnCurve use the
generic, non-constant-time implementation.

Change-Id: I4b3b340f65bce91dcca30bcf86456cc8ce4dd4bb
Reviewed-on: https://go-review.googlesource.com/c/go/+/325650
Trust: Filippo Valsorda <filippo@golang.org>
Trust: Katie Hockman <katie@golang.org>
Run-TryBot: Filippo Valsorda <filippo@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/crypto/elliptic/elliptic.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/crypto/elliptic/elliptic.go b/src/crypto/elliptic/elliptic.go
index b8e5a3097d..f072960bfe 100644
--- a/src/crypto/elliptic/elliptic.go
+++ b/src/crypto/elliptic/elliptic.go
@@ -455,7 +455,7 @@ func initP384() {
 // Multiple invocations of this function will return the same value, so it can
 // be used for equality checks and switch statements.
 //
-// The cryptographic operations are implemented using constant-time algorithms.
+// ScalarMult and ScalarBaseMult are implemented using constant-time algorithms.
 func P256() Curve {
 	initonce.Do(initAll)
 	return p256
@@ -479,7 +479,7 @@ func P384() Curve {
 // Multiple invocations of this function will return the same value, so it can
 // be used for equality checks and switch statements.
 //
-// The cryptographic operations do not use constant-time algorithms.
+// The cryptographic operations are implemented using constant-time algorithms.
 func P521() Curve {
 	initonce.Do(initAll)
 	return p521
-- 
GitLab


From 909dd5e010c99d48f1dc72d7da61fd8d3fd8f030 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Mon, 7 Jun 2021 10:51:33 -0700
Subject: [PATCH 2185/2400] strconv: ParseFloat: always return ErrSyntax for
 bad syntax

Previously we would sometimes return ErrRange if the parseable part of
the floating point number was out of range.

Fixes #46628

Change-Id: I15bbbb1e2a56fa27c19fe25ab5554d988cbfd9d2
Reviewed-on: https://go-review.googlesource.com/c/go/+/325750
Trust: Ian Lance Taylor <iant@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/strconv/atof.go      | 2 +-
 src/strconv/atof_test.go | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/strconv/atof.go b/src/strconv/atof.go
index 9010a66ca8..57556c7047 100644
--- a/src/strconv/atof.go
+++ b/src/strconv/atof.go
@@ -689,7 +689,7 @@ func atof64(s string) (f float64, n int, err error) {
 // as their respective special floating point values. It ignores case when matching.
 func ParseFloat(s string, bitSize int) (float64, error) {
 	f, n, err := parseFloatPrefix(s, bitSize)
-	if err == nil && n != len(s) {
+	if n != len(s) && (err == nil || err.(*NumError).Err != ErrSyntax) {
 		return 0, syntaxError(fnParseFloat, s)
 	}
 	return f, err
diff --git a/src/strconv/atof_test.go b/src/strconv/atof_test.go
index 3c058b9be5..aa587a473c 100644
--- a/src/strconv/atof_test.go
+++ b/src/strconv/atof_test.go
@@ -342,6 +342,9 @@ var atoftests = []atofTest{
 	{"0x12.345p-_12", "0", ErrSyntax},
 	{"0x12.345p+1__2", "0", ErrSyntax},
 	{"0x12.345p+12_", "0", ErrSyntax},
+
+	{"1e100x", "0", ErrSyntax},
+	{"1e1000x", "0", ErrSyntax},
 }
 
 var atof32tests = []atofTest{
-- 
GitLab


From dc8b55895166c808b02e93ef4a778c6648c10bf3 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Thu, 3 Jun 2021 14:15:12 -0700
Subject: [PATCH 2186/2400] cmd/dist: pass -Wno-lto-type-mismatch in
 swig_callback_lto

Fixes #46557

Change-Id: I95200ddd60e2879db15dd7353c2152b515c89020
Reviewed-on: https://go-review.googlesource.com/c/go/+/324909
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Damien Neil <dneil@google.com>
---
 src/cmd/dist/test.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go
index bc49c6d804..1ed2c0f631 100644
--- a/src/cmd/dist/test.go
+++ b/src/cmd/dist/test.go
@@ -737,9 +737,9 @@ func (t *tester) registerTests() {
 						fn: func(dt *distTest) error {
 							cmd := t.addCmd(dt, "misc/swig/callback", t.goTest())
 							cmd.Env = append(os.Environ(),
-								"CGO_CFLAGS=-flto",
-								"CGO_CXXFLAGS=-flto",
-								"CGO_LDFLAGS=-flto",
+								"CGO_CFLAGS=-flto -Wno-lto-type-mismatch",
+								"CGO_CXXFLAGS=-flto -Wno-lto-type-mismatch",
+								"CGO_LDFLAGS=-flto -Wno-lto-type-mismatch",
 							)
 							return nil
 						},
-- 
GitLab


From 39c39ae52f0f35085be8ca1e004dee509abc21de Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 7 Jun 2021 14:28:14 -0700
Subject: [PATCH 2187/2400] doc: document Go 1.17 language changes

Fixes #46020.

Change-Id: Iadf9a0ac4a8863e17155d6ba1af2cc497634a634
Reviewed-on: https://go-review.googlesource.com/c/go/+/325870
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 doc/go1.17.html | 44 +++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 39 insertions(+), 5 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 7438d894fe..c1978ff1c1 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -25,12 +25,46 @@ Do not send CLs removing the interior tags from such phrases.
 
 <h2 id="language">Changes to the language</h2>
 
-<p><!-- CL 216424 -->
-  TODO: <a href="https://golang.org/cl/216424">https://golang.org/cl/216424</a>: allow conversion from slice to array ptr
-</p>
+<p>
+  Go 1.17 includes three small enhancements to the language.
+</p>
+
+<ul>
+  <li><!-- CL 216424; issue 395 -->
+    <a href="/ref/spec#Conversions_from_slice_to_array_pointer">Conversions
+    from slice to array pointer</a>: An expression <code>s</code> of
+    type <code>[]T</code> may now be converted to array pointer type
+    <code>*[N]T</code>. If <code>a</code> is the result of such a
+    conversion, then corresponding indices that are in range refer to
+    the same underlying elements: <code>&amp;a[i] == &amp;s[i]</code>
+    for <code>0 &lt;= i &lt; N</code>. The conversion panics if
+    <code>len(s)</code> is less than <code>N</code>.
+  </li>
+
+  <li><!-- CL 312212; issue 40481 -->
+    <a href="/pkg/unsafe#Add"><code>unsafe.Add</code></a>:
+    <code>unsafe.Add(ptr, len)</code> adds <code>len</code>
+    to <code>ptr</code> and returns the updated pointer
+    <code>unsafe.Pointer(uintptr(ptr) + uintptr(len))</code>.
+  </li>
+
+  <li><!-- CL 312212; issue 19367 -->
+    <a href="/pkg/unsafe#Slice"><code>unsafe.Slice</code></a>:
+    For expression <code>ptr</code> of type <code>*T</code>,
+    <code>unsafe.Slice(ptr, len)</code> returns a slice of
+    type <code>[]T</code> whose underlying array starts
+    at <code>ptr</code> and whose length and capacity
+    are <code>len</code>.
+  </li>
+</ul>
 
-<p><!-- CL 312212 -->
-  TODO: <a href="https://golang.org/cl/312212">https://golang.org/cl/312212</a>: add unsafe.Add and unsafe.Slice
+<p>
+  These enhancements were added to simplify writing code that conforms
+  to <code>unsafe.Pointer</code>'s <a href="/pkg/unsafe/#Pointer">safety
+  rules</a>, but the rules remain unchanged. In particular, existing
+  programs that correctly use <code>unsafe.Pointer</code> remain
+  valid, and new programs must still follow the rules when
+  using <code>unsafe.Add</code> or <code>unsafe.Slice</code>.
 </p>
 
 <h2 id="ports">Ports</h2>
-- 
GitLab


From c20bcb64882d1134770683d663ee9f82fea715e6 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 7 Jun 2021 16:24:40 -0700
Subject: [PATCH 2188/2400] runtime: remove out-of-date comments about frame
 skipping

skipPleaseUseCallersFrames was removed in CL 152537.

Change-Id: Ide47feec85a33a6fb6882e16baf9e21492521640
Reviewed-on: https://go-review.googlesource.com/c/go/+/325949
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/runtime/traceback.go | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/runtime/traceback.go b/src/runtime/traceback.go
index 89780edc1f..814c323634 100644
--- a/src/runtime/traceback.go
+++ b/src/runtime/traceback.go
@@ -56,8 +56,6 @@ func tracebackdefers(gp *g, callback func(*stkframe, unsafe.Pointer) bool, v uns
 	}
 }
 
-const sizeofSkipFunction = 256
-
 // Generic traceback. Handles runtime stack prints (pcbuf == nil),
 // the runtime.Callers function (pcbuf != nil), as well as the garbage
 // collector (callback != nil).  A little clunky to merge these, but avoids
@@ -65,9 +63,7 @@ const sizeofSkipFunction = 256
 //
 // The skip argument is only valid with pcbuf != nil and counts the number
 // of logical frames to skip rather than physical frames (with inlining, a
-// PC in pcbuf can represent multiple calls). If a PC is partially skipped
-// and max > 1, pcbuf[1] will be runtime.skipPleaseUseCallersFrames+N where
-// N indicates the number of logical frames to skip in pcbuf[0].
+// PC in pcbuf can represent multiple calls).
 func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max int, callback func(*stkframe, unsafe.Pointer) bool, v unsafe.Pointer, flags uint) int {
 	if skip > 0 && callback != nil {
 		throw("gentraceback callback cannot be used with non-zero skip")
-- 
GitLab


From 2169deb35247a80794519589e7cd845c6ebf4e5a Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Sun, 30 May 2021 15:35:06 +0700
Subject: [PATCH 2189/2400] cmd/compile: use t.AllMethods when sorting
 typesByString

For interface types, t.Methods contains only unexpanded method set, i.e
exclusive of interface embedding. Thus, we can't use it to detect an
interface contains embedding empty interface, like in:

	type EI interface{}

	func f() interface{ EI } {
		return nil
	}

At the time we generate runtime types, we want to check against the full
method set of interface instead.

Fixes #46386

Change-Id: Idff53ad39276be6632eb5932b76e855c15cbdd2e
Reviewed-on: https://go-review.googlesource.com/c/go/+/323649
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 .../compile/internal/reflectdata/reflect.go   |  4 +--
 test/fixedbugs/issue46386.go                  | 32 +++++++++++++++++++
 2 files changed, 34 insertions(+), 2 deletions(-)
 create mode 100644 test/fixedbugs/issue46386.go

diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index b3688fca67..e07294be0f 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -1475,8 +1475,8 @@ func (a typesByString) Less(i, j int) bool {
 	// will be equal for the above checks, but different in DWARF output.
 	// Sort by source position to ensure deterministic order.
 	// See issues 27013 and 30202.
-	if a[i].t.Kind() == types.TINTER && a[i].t.Methods().Len() > 0 {
-		return a[i].t.Methods().Index(0).Pos.Before(a[j].t.Methods().Index(0).Pos)
+	if a[i].t.Kind() == types.TINTER && a[i].t.AllMethods().Len() > 0 {
+		return a[i].t.AllMethods().Index(0).Pos.Before(a[j].t.AllMethods().Index(0).Pos)
 	}
 	return false
 }
diff --git a/test/fixedbugs/issue46386.go b/test/fixedbugs/issue46386.go
new file mode 100644
index 0000000000..89dea8abf3
--- /dev/null
+++ b/test/fixedbugs/issue46386.go
@@ -0,0 +1,32 @@
+// compile -p=main
+
+// Copyright 2021 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
+
+type I interface {
+	M() interface{}
+}
+
+type S1 struct{}
+
+func (S1) M() interface{} {
+	return nil
+}
+
+type EI interface{}
+
+type S struct{}
+
+func (S) M(as interface{ I }) {}
+
+func f() interface{ EI } {
+	return &S1{}
+}
+
+func main() {
+	var i interface{ I }
+	(&S{}).M(i)
+}
-- 
GitLab


From 0fb3e2c18408cc8ff6cb87962fc13f2684d1df96 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Mon, 7 Jun 2021 17:04:32 -0400
Subject: [PATCH 2190/2400] doc/go1.17: add a release note for the '-compat'
 flag to 'go mod tidy'

Updates #46141

Change-Id: I7a6a84f816e3db19bb492f862366a29dc46ed2ee
Reviewed-on: https://go-review.googlesource.com/c/go/+/325910
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 doc/go1.17.html | 33 +++++++++++++++++++++++++++++----
 1 file changed, 29 insertions(+), 4 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index c1978ff1c1..ba6b8baf19 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -137,8 +137,9 @@ Do not send CLs removing the interior tags from such phrases.
   <!-- TODO(bcmills): replace the design-doc link with proper documentation. -->
 </p>
 
-<p><!-- golang.org/issue/45094 --> To facilitate the upgrade to lazy loading,
-  the <code>go</code> <code>mod</code> <code>tidy</code> subcommand now supports
+<p><!-- golang.org/issue/45094 -->
+  To facilitate the upgrade to lazy loading, the
+  <code>go</code> <code>mod</code> <code>tidy</code> subcommand now supports
   a <code>-go</code> flag to set or change the <code>go</code> version in
   the <code>go.mod</code> file. To enable lazy loading for an existing module
   without changing the selected versions of its dependencies, run:
@@ -149,8 +150,32 @@ Do not send CLs removing the interior tags from such phrases.
 </pre>
 
 <p><!-- golang.org/issue/46141 -->
-  TODO: Describe the <code>-compat</code> flag
-  for <code>go</code> <code>mod</code> <code>tidy</code>.
+  By default, <code>go</code> <code>mod</code> <code>tidy</code> verifies that
+  the selected versions of dependencies relevant to the main module are the same
+  versions that would be used by the prior Go release (Go 1.16 for a module that
+  spsecifies <code>go</code> <code>1.17</code>), and preserves
+  the <code>go.sum</code> entries needed by that release even for dependencies
+  that are not normally needed by other commands.
+</p>
+
+<p>
+  The <code>-compat</code> flag allows that version to be overridden to support
+  older (or only newer) versions, up to the version specified by
+  the <code>go</code> directive in the <code>go.mod</code> file. To tidy
+  a <code>go</code> <code>1.17</code> module for Go 1.17 only, without saving
+  checksums for (or checking for consistency with) Go 1.16:
+</p>
+
+<pre>
+  go mod tidy -compat=1.17
+</pre>
+
+<p>
+  Note that even if the main module is tidied with <code>-compat=1.17</code>,
+  users who <code>require</code> the module from a
+  <code>go</code> <code>1.16</code> or earlier module will still be able to
+  use it, provided that the packages use only compatible language and library
+  features.
 </p>
 
 <h4 id="module-deprecation-comments">Module deprecation comments</h4>
-- 
GitLab


From 949f00cebe9a40c7454bc42acaa77fdb8bf6c4e6 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Mon, 7 Jun 2021 10:20:38 -0400
Subject: [PATCH 2191/2400] doc/go1.17: add release notes for crypto packages

For #44513

Change-Id: I459b3a4f9936eaa2c09888177f91176140d04280
Reviewed-on: https://go-review.googlesource.com/c/go/+/325649
Trust: Filippo Valsorda <filippo@golang.org>
Trust: Katie Hockman <katie@golang.org>
Reviewed-by: Roland Shoemaker <roland@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
---
 doc/go1.17.html | 136 ++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 108 insertions(+), 28 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index ba6b8baf19..c1b3b3cef4 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -338,30 +338,6 @@ Do not send CLs removing the interior tags from such phrases.
   TODO: complete the Core library section
 </p>
 
-<h3 id="crypto/tls"><a href="/pkg/crypto/tls">crypto/tls</a></h3>
-
-<p><!-- CL 295370 -->
-  <a href="/pkg/crypto/tls#Conn.HandshakeContext">(*Conn).HandshakeContext</a> was added to
-  allow the user to control cancellation of an in-progress TLS Handshake.
-  The context provided is propagated into the
-  <a href="/pkg/crypto/tls#ClientHelloInfo">ClientHelloInfo</a>
-  and <a href="/pkg/crypto/tls#CertificateRequestInfo">CertificateRequestInfo</a>
-  structs and accessible through the new
-  <a href="/pkg/crypto/tls#ClientHelloInfo.Context">(*ClientHelloInfo).Context</a>
-  and
-  <a href="/pkg/crypto/tls#CertificateRequestInfo.Context">
-      (*CertificateRequestInfo).Context
-  </a> methods respectively. Canceling the context after the handshake has finished
-  has no effect.
-</p>
-
-<p><!-- CL 289209 -->
-  When <a href="/pkg/crypto/tls#Config">Config.NextProtos</a> is set, servers now
-  enforce that there is an overlap between the configured protocols and the protocols
-  advertised by the client, if any. If there is no overlap the connection is closed
-  with the <code>no_application_protocol</code> alert, as required by RFC 7301.
-</p>
-
 <h3 id="runtime/cgo"><a href="/pkg/runtime/cgo">Cgo</a></h3>
 
 <p>
@@ -424,13 +400,117 @@ Do not send CLs removing the interior tags from such phrases.
   </dd>
 </dl><!-- compress/lzw -->
 
-<dl id="crypto/rsa"><dt><a href="/pkg/crypto/rsa/">crypto/rsa</a></dt>
+<dl id="crypto/ed25519"><dt><a href="/pkg/crypto/ed25519/">crypto/ed25519</a></dt>
+  <dd>
+    <p><!-- CL 276272 -->
+      The <code>crypto/ed25519</code> package has been rewritten, and all
+      operations are now approximately twice as fast on amd64 and arm64.
+      The observable behavior has not otherwise changed.
+    </p>
+  </dd>
+</dl><!-- crypto/ed25519 -->
+
+<dl id="crypto/elliptic"><dt><a href="/pkg/crypto/elliptic/">crypto/elliptic</a></dt>
+  <dd>
+    <p><!-- CL 233939 -->
+      <a href="/pkg/crypto/elliptic#CurveParams"><code>CurveParams</code></a>
+      methods now automatically invoke faster and safer dedicated
+      implementations for known curves (P-224, P-256, and P-521) when
+      available. Note that this is a best-effort approach and applications
+      should avoid using the generic, not constant-time <code>CurveParams</code>
+      methods and instead use dedicated
+      <a href="/pkg/crypto/elliptic#Curve"><code>Curve</code></a> implementations
+      such as <a href="/pkg/crypto/elliptic#P256"><code>P256</code></a>.
+    </p>
+
+    <p><!-- CL 315271, CL 315274 -->
+      The <a href="/pkg/crypto/elliptic#P521"><code>P521</code></a> curve
+      implementation has been rewritten using code generated by the
+      <a href="https://github.com/mit-plv/fiat-crypto">fiat-crypto project</a>,
+      which is based on a formally-verified model of the arithmetic
+      operations. It is now constant-time and three times faster on amd64 and
+      arm64. The observable behavior has not otherwise changed.
+    </p>
+  </dd>
+</dl><!-- crypto/elliptic -->
+
+<dl id="crypto/rand"><dt><a href="/pkg/crypto/rand/">crypto/rand</a></dt>
+  <dd>
+    <p><!-- CL 302489, CL 299134, CL 269999 -->
+      The <code>crypto/rand</code> package now uses the <code>getentropy</code>
+      syscall on macOS and the <code>getrandom</code> syscall on Solaris,
+      Illumos, and DragonFlyBSD.
+    </p>
+  </dd>
+</dl><!-- crypto/rand -->
+
+<dl id="crypto/tls"><dt><a href="/pkg/crypto/tls/">crypto/tls</a></dt>
   <dd>
-    <p><!-- CL 302230 -->
-      TODO: <a href="https://golang.org/cl/302230">https://golang.org/cl/302230</a>: fix salt length calculation with PSSSaltLengthAuto
+    <p><!-- CL 295370 -->
+      The new <a href="/pkg/crypto/tls#Conn.HandshakeContext"><code>Conn.HandshakeContext</code></a>
+      method allows the user to control cancellation of an in-progress TLS
+      handshake. The provided context is accessible from various callbacks through the new
+      <a href="/pkg/crypto/tls#ClientHelloInfo.Context"><code>ClientHelloInfo.Context</code></a> and
+      <a href="/pkg/crypto/tls#CertificateRequestInfo.Context"><code>CertificateRequestInfo.Context</code></a>
+      methods. Canceling the context after the handshake has finished has no effect.
+    </p>
+
+    <p><!-- CL 289209 -->
+      When <a href="/pkg/crypto/tls#Config.NextProtos"><code>Config.NextProtos</code></a>
+      is set, servers now enforce that there is an overlap between the
+      configured protocols and the protocols advertised by the client, if any.
+      If there is no overlap the connection is closed with the
+      <code>no_application_protocol</code> alert, as required by RFC 7301.
+    </p>
+
+    <p><!-- CL 314609 -->
+      Cipher suite ordering is now handled entirely by the
+      <code>crypto/tls</code> package. Currently, cipher suites are sorted based
+      on their security, performance, and hardware support taking into account
+      both the local and peer's hardware. The order of the
+      <a href="/pkg/crypto/tls#Config.CipherSuites"><code>Config.CipherSuites</code></a>
+      field is now ignored, as well as the
+      <a href="/pkg/crypto/tls#Config.PreferServerCipherSuites"><code>Config.PreferServerCipherSuites</code></a>
+      field. Note that <code>Config.CipherSuites</code> still allows
+      applications to choose what TLS 1.0–1.2 cipher suites to enable.
+    </p>
+
+    <p>
+      The 3DES cipher suites have been moved to
+      <a href="/pkg/crypto/tls#InsecureCipherSuites"><code>InsecureCipherSuites</code></a>
+      due to <a href="https://sweet32.info/">fundamental block size-related
+      weakness</a>. They are still enabled by default but only as a last resort,
+      thanks to the cipher suite ordering change above.
+    </p>
+  </dd>
+</dl><!-- crypto/tls -->
+
+<dl id="crypto/x509"><dt><a href="/pkg/crypto/x509/">crypto/x509</a></dt>
+  <dd>
+    <p><!-- CL 224157 -->
+      <a href="/pkg/crypto/x509/#CreateCertificate"><code>CreateCertificate</code></a>
+      now returns an error if the provided private key doesn't match the
+      parent's public key, if any. The resulting certificate would have failed
+      to verify.
+    </p>
+
+    <p><!-- CL 315209 -->
+      The temporary <code>GODEBUG=x509ignoreCN=0</code> flag has been removed.
+    </p>
+
+    <p><!-- CL 274234 -->
+      <a href="/pkg/crypto/x509/#ParseCertificate"><code>ParseCertificate</code></a>
+      has been rewritten, and now consumes ~70% fewer resources. The observable
+      behavior has not otherwise changed, except for error messages.
+    </p>
+
+    <p><!-- CL 321190 -->
+      On BSD systems, <code>/etc/ssl/certs</code> is now searched for trusted
+      roots. This adds support for the new system trusted certificate store in
+      FreeBSD 12.2+.
     </p>
   </dd>
-</dl><!-- crypto/rsa -->
+</dl><!-- crypto/x509 -->
 
 <dl id="database/sql"><dt><a href="/pkg/database/sql/">database/sql</a></dt>
   <dd>
-- 
GitLab


From 9498b0155d4c38c018d00b83afaedaabbdbb9e85 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Mon, 7 Jun 2021 23:04:16 -0400
Subject: [PATCH 2192/2400] cmd/go: in Go 1.17+ modules, add indirect go.mod
 dependencies separately from direct ones

Fixes #45965

Change-Id: If5c0d7b29e9f81be0763f3fa68051d4ef5419990
Reviewed-on: https://go-review.googlesource.com/c/go/+/325922
Trust: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 doc/go1.17.html                               |   8 +
 src/cmd/go.mod                                |   2 +-
 src/cmd/go.sum                                |   4 +-
 src/cmd/go/internal/modload/init.go           |   6 +-
 src/cmd/go/internal/modload/modfile.go        |   5 +
 .../script/mod_go_version_missing.txt         |   7 +-
 .../script/mod_lazy_import_allmod.txt         |   3 +-
 .../testdata/script/mod_lazy_new_import.txt   |  10 +-
 .../script/mod_lazy_test_of_test_dep.txt      |   7 +-
 src/cmd/go/testdata/script/mod_retention.txt  |   3 +-
 .../testdata/script/mod_tidy_convergence.txt  |  18 +-
 .../go/testdata/script/mod_tidy_version.txt   |  22 +-
 .../vendor/golang.org/x/mod/modfile/read.go   |   7 +-
 .../vendor/golang.org/x/mod/modfile/rule.go   | 402 +++++++++++++-----
 src/cmd/vendor/modules.txt                    |   2 +-
 15 files changed, 372 insertions(+), 134 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index c1b3b3cef4..8b0fcea29d 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -137,6 +137,14 @@ Do not send CLs removing the interior tags from such phrases.
   <!-- TODO(bcmills): replace the design-doc link with proper documentation. -->
 </p>
 
+<p><!-- golang.org/issue/45965 -->
+  Because the number of additional explicit requirements in the go.mod file may
+  be substantial, in a Go 1.17 module the newly-added requirements
+  on <em>indirect</em> dependencies are maintained in a
+  separate <code>require</code> block from the block containing direct
+  dependencies.
+</p>
+
 <p><!-- golang.org/issue/45094 -->
   To facilitate the upgrade to lazy loading, the
   <code>go</code> <code>mod</code> <code>tidy</code> subcommand now supports
diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index 1aa0320d07..cd03968eed 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -7,7 +7,7 @@ require (
 	github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639 // indirect
 	golang.org/x/arch v0.0.0-20210502124803-cbf565b21d1e
 	golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e // indirect
-	golang.org/x/mod v0.4.3-0.20210512182355-6088ed88cecd
+	golang.org/x/mod v0.4.3-0.20210608190319-0f08993efd8a
 	golang.org/x/sys v0.0.0-20210511113859-b0526f3d8744 // indirect
 	golang.org/x/term v0.0.0-20210503060354-a79de5458b56
 	golang.org/x/tools v0.1.2-0.20210519160823-49064d2332f9
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index eeb625fcf8..d728acaec9 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -13,8 +13,8 @@ golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e h1:8foAy0aoO5GkqCvAEJ4VC4P3zksTg4X4aJCDpZzmgQI=
 golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.4.3-0.20210512182355-6088ed88cecd h1:CuRnpyMrCCBulv0d/y0CswR4K0vGydgE3DZ2wYPIOo8=
-golang.org/x/mod v0.4.3-0.20210512182355-6088ed88cecd/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
+golang.org/x/mod v0.4.3-0.20210608190319-0f08993efd8a h1:e8qnjKz4EE6OjRki9wTadWSIogINvq10sMcuBRORxMY=
+golang.org/x/mod v0.4.3-0.20210608190319-0f08993efd8a/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index ea404b9f78..eb9cfe629b 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -999,10 +999,14 @@ func commitRequirements(ctx context.Context, goVersion string, rs *Requirements)
 			Indirect: !rs.direct[m.Path],
 		})
 	}
-	modFile.SetRequire(list)
 	if goVersion != "" {
 		modFile.AddGoStmt(goVersion)
 	}
+	if semver.Compare("v"+modFileGoVersion(), separateIndirectVersionV) < 0 {
+		modFile.SetRequire(list)
+	} else {
+		modFile.SetRequireSeparateIndirect(list)
+	}
 	modFile.Cleanup()
 
 	dirty := index.modFileIsDirty(modFile)
diff --git a/src/cmd/go/internal/modload/modfile.go b/src/cmd/go/internal/modload/modfile.go
index a9c3a91d35..1145ac4ba5 100644
--- a/src/cmd/go/internal/modload/modfile.go
+++ b/src/cmd/go/internal/modload/modfile.go
@@ -35,6 +35,11 @@ const (
 	// module's go.mod file is expected to list explicit requirements on every
 	// module that provides any package transitively imported by that module.
 	lazyLoadingVersionV = "v1.17"
+
+	// separateIndirectVersionV is the Go version (plus leading "v") at which
+	// "// indirect" dependencies are added in a block separate from the direct
+	// ones. See https://golang.org/issue/45965.
+	separateIndirectVersionV = "v1.17"
 )
 
 const (
diff --git a/src/cmd/go/testdata/script/mod_go_version_missing.txt b/src/cmd/go/testdata/script/mod_go_version_missing.txt
index aca36a0450..d704816729 100644
--- a/src/cmd/go/testdata/script/mod_go_version_missing.txt
+++ b/src/cmd/go/testdata/script/mod_go_version_missing.txt
@@ -73,10 +73,9 @@ module example.com/m
 
 go $goversion
 
-require (
-	example.com/dep v0.1.0
-	example.com/testdep v0.1.0 // indirect
-)
+require example.com/dep v0.1.0
+
+require example.com/testdep v0.1.0 // indirect
 
 replace (
 	example.com/dep v0.1.0 => ./dep
diff --git a/src/cmd/go/testdata/script/mod_lazy_import_allmod.txt b/src/cmd/go/testdata/script/mod_lazy_import_allmod.txt
index 3dc1515df2..97718c4513 100644
--- a/src/cmd/go/testdata/script/mod_lazy_import_allmod.txt
+++ b/src/cmd/go/testdata/script/mod_lazy_import_allmod.txt
@@ -139,9 +139,10 @@ go 1.17
 require (
 	a v0.1.0
 	b v0.1.0
-	c v0.1.0 // indirect
 )
 
+require c v0.1.0 // indirect
+
 replace (
 	a v0.1.0 => ./a1
 	b v0.1.0 => ./b1
diff --git a/src/cmd/go/testdata/script/mod_lazy_new_import.txt b/src/cmd/go/testdata/script/mod_lazy_new_import.txt
index 86b14b64b6..4272a52de1 100644
--- a/src/cmd/go/testdata/script/mod_lazy_new_import.txt
+++ b/src/cmd/go/testdata/script/mod_lazy_new_import.txt
@@ -78,10 +78,9 @@ module example.com/lazy
 
 go 1.17
 
-require (
-	example.com/a v0.1.0
-	example.com/b v0.1.0 // indirect
-)
+require example.com/a v0.1.0
+
+require example.com/b v0.1.0 // indirect
 
 replace (
 	example.com/a v0.1.0 => ./a
@@ -94,8 +93,9 @@ module example.com/lazy
 
 go 1.17
 
+require example.com/a v0.1.0
+
 require (
-	example.com/a v0.1.0
 	example.com/b v0.1.0 // indirect
 	example.com/c v0.1.0 // indirect
 )
diff --git a/src/cmd/go/testdata/script/mod_lazy_test_of_test_dep.txt b/src/cmd/go/testdata/script/mod_lazy_test_of_test_dep.txt
index 722712d1f2..68a5b6dca2 100644
--- a/src/cmd/go/testdata/script/mod_lazy_test_of_test_dep.txt
+++ b/src/cmd/go/testdata/script/mod_lazy_test_of_test_dep.txt
@@ -148,10 +148,9 @@ module example.com/lazy
 
 go 1.17
 
-require (
-	example.com/a v0.1.0
-	example.com/b v0.1.0 // indirect
-)
+require example.com/a v0.1.0
+
+require example.com/b v0.1.0 // indirect
 
 replace (
 	example.com/a v0.1.0 => ./a
diff --git a/src/cmd/go/testdata/script/mod_retention.txt b/src/cmd/go/testdata/script/mod_retention.txt
index 0e639db551..7a371b1806 100644
--- a/src/cmd/go/testdata/script/mod_retention.txt
+++ b/src/cmd/go/testdata/script/mod_retention.txt
@@ -140,8 +140,9 @@ module m
 go $goversion
 
 require (
-	golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c // indirect
 	rsc.io/quote v1.5.2
 	rsc.io/sampler v1.3.0 // indirect
 	rsc.io/testonly v1.0.0 // indirect
 )
+
+require golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c // indirect
diff --git a/src/cmd/go/testdata/script/mod_tidy_convergence.txt b/src/cmd/go/testdata/script/mod_tidy_convergence.txt
index 22c8fc66c5..09c46f764b 100644
--- a/src/cmd/go/testdata/script/mod_tidy_convergence.txt
+++ b/src/cmd/go/testdata/script/mod_tidy_convergence.txt
@@ -90,7 +90,6 @@ cmp go.mod go.mod.postget
 cp go.mod.orig go.mod
 go mod edit -go=1.17 go.mod
 go mod edit -go=1.17 go.mod.tidye
-go mod edit -go=1.17 go.mod.postget
 
 go mod tidy -e
 cmp go.mod go.mod.tidye
@@ -99,7 +98,7 @@ stderr '^example\.net/m imports\n\texample\.net/x: package example\.net/x provid
 
 go get -d example.net/x@v0.1.0 example.net/y@v0.1.0
 go mod tidy
-cmp go.mod go.mod.postget
+cmp go.mod go.mod.postget-117
 
 
 -- go.mod --
@@ -144,6 +143,21 @@ require (
 	example.net/x v0.1.0
 	example.net/y v0.1.0 // indirect
 )
+-- go.mod.postget-117 --
+module example.net/m
+
+go 1.17
+
+replace (
+	example.net/x v0.1.0 => ./x1
+	example.net/x v0.2.0-pre => ./x2-pre
+	example.net/y v0.1.0 => ./y1
+	example.net/y v0.2.0 => ./y2
+)
+
+require example.net/x v0.1.0
+
+require example.net/y v0.1.0 // indirect
 -- m.go --
 package m
 
diff --git a/src/cmd/go/testdata/script/mod_tidy_version.txt b/src/cmd/go/testdata/script/mod_tidy_version.txt
index eaa6ee7b0d..3bc97bcb1e 100644
--- a/src/cmd/go/testdata/script/mod_tidy_version.txt
+++ b/src/cmd/go/testdata/script/mod_tidy_version.txt
@@ -92,8 +92,9 @@ cmpenv go.mod go.mod.latest
 -- go.mod --
 module example.com/m
 
+require example.net/a v0.1.0
+
 require (
-	example.net/a v0.1.0
 	example.net/c v0.1.0 // indirect
 	example.net/d v0.1.0 // indirect
 )
@@ -118,8 +119,9 @@ module example.com/m
 
 go 1.15
 
+require example.net/a v0.1.0
+
 require (
-	example.net/a v0.1.0
 	example.net/c v0.1.0 // indirect
 	example.net/d v0.1.0 // indirect
 )
@@ -139,8 +141,9 @@ module example.com/m
 
 go 1.15
 
+require example.net/a v0.1.0
+
 require (
-	example.net/a v0.1.0
 	example.net/c v0.1.0 // indirect
 	example.net/d v0.2.0 // indirect
 )
@@ -160,10 +163,9 @@ module example.com/m
 
 go 1.16
 
-require (
-	example.net/a v0.1.0
-	example.net/c v0.1.0 // indirect
-)
+require example.net/a v0.1.0
+
+require example.net/c v0.1.0 // indirect
 
 replace (
 	example.net/a v0.1.0 => ./a
@@ -180,8 +182,9 @@ module example.com/m
 
 go 1.17
 
+require example.net/a v0.1.0
+
 require (
-	example.net/a v0.1.0
 	example.net/b v0.1.0 // indirect
 	example.net/c v0.1.0 // indirect
 )
@@ -201,8 +204,9 @@ module example.com/m
 
 go $goversion
 
+require example.net/a v0.1.0
+
 require (
-	example.net/a v0.1.0
 	example.net/b v0.1.0 // indirect
 	example.net/c v0.1.0 // indirect
 )
diff --git a/src/cmd/vendor/golang.org/x/mod/modfile/read.go b/src/cmd/vendor/golang.org/x/mod/modfile/read.go
index 2a961ca81c..956f30cbb3 100644
--- a/src/cmd/vendor/golang.org/x/mod/modfile/read.go
+++ b/src/cmd/vendor/golang.org/x/mod/modfile/read.go
@@ -194,12 +194,15 @@ func (x *FileSyntax) updateLine(line *Line, tokens ...string) {
 	line.Token = tokens
 }
 
-func (x *FileSyntax) removeLine(line *Line) {
+// markRemoved modifies line so that it (and its end-of-line comment, if any)
+// will be dropped by (*FileSyntax).Cleanup.
+func (line *Line) markRemoved() {
 	line.Token = nil
+	line.Comments.Suffix = nil
 }
 
 // Cleanup cleans up the file syntax x after any edit operations.
-// To avoid quadratic behavior, removeLine marks the line as dead
+// To avoid quadratic behavior, (*Line).markRemoved marks the line as dead
 // by setting line.Token = nil but does not remove it from the slice
 // in which it appears. After edits have all been indicated,
 // calling Cleanup cleans out the dead lines.
diff --git a/src/cmd/vendor/golang.org/x/mod/modfile/rule.go b/src/cmd/vendor/golang.org/x/mod/modfile/rule.go
index 7299e15500..78f83fa714 100644
--- a/src/cmd/vendor/golang.org/x/mod/modfile/rule.go
+++ b/src/cmd/vendor/golang.org/x/mod/modfile/rule.go
@@ -58,13 +58,6 @@ type Go struct {
 	Syntax  *Line
 }
 
-// A Require is a single require statement.
-type Require struct {
-	Mod      module.Version
-	Indirect bool // has "// indirect" comment
-	Syntax   *Line
-}
-
 // An Exclude is a single exclude statement.
 type Exclude struct {
 	Mod    module.Version
@@ -93,6 +86,93 @@ type VersionInterval struct {
 	Low, High string
 }
 
+// A Require is a single require statement.
+type Require struct {
+	Mod      module.Version
+	Indirect bool // has "// indirect" comment
+	Syntax   *Line
+}
+
+func (r *Require) markRemoved() {
+	r.Syntax.markRemoved()
+	*r = Require{}
+}
+
+func (r *Require) setVersion(v string) {
+	r.Mod.Version = v
+
+	if line := r.Syntax; len(line.Token) > 0 {
+		if line.InBlock {
+			// If the line is preceded by an empty line, remove it; see
+			// https://golang.org/issue/33779.
+			if len(line.Comments.Before) == 1 && len(line.Comments.Before[0].Token) == 0 {
+				line.Comments.Before = line.Comments.Before[:0]
+			}
+			if len(line.Token) >= 2 { // example.com v1.2.3
+				line.Token[1] = v
+			}
+		} else {
+			if len(line.Token) >= 3 { // require example.com v1.2.3
+				line.Token[2] = v
+			}
+		}
+	}
+}
+
+// setIndirect sets line to have (or not have) a "// indirect" comment.
+func (r *Require) setIndirect(indirect bool) {
+	r.Indirect = indirect
+	line := r.Syntax
+	if isIndirect(line) == indirect {
+		return
+	}
+	if indirect {
+		// Adding comment.
+		if len(line.Suffix) == 0 {
+			// New comment.
+			line.Suffix = []Comment{{Token: "// indirect", Suffix: true}}
+			return
+		}
+
+		com := &line.Suffix[0]
+		text := strings.TrimSpace(strings.TrimPrefix(com.Token, string(slashSlash)))
+		if text == "" {
+			// Empty comment.
+			com.Token = "// indirect"
+			return
+		}
+
+		// Insert at beginning of existing comment.
+		com.Token = "// indirect; " + text
+		return
+	}
+
+	// Removing comment.
+	f := strings.TrimSpace(strings.TrimPrefix(line.Suffix[0].Token, string(slashSlash)))
+	if f == "indirect" {
+		// Remove whole comment.
+		line.Suffix = nil
+		return
+	}
+
+	// Remove comment prefix.
+	com := &line.Suffix[0]
+	i := strings.Index(com.Token, "indirect;")
+	com.Token = "//" + com.Token[i+len("indirect;"):]
+}
+
+// isIndirect reports whether line has a "// indirect" comment,
+// meaning it is in go.mod only for its effect on indirect dependencies,
+// so that it can be dropped entirely once the effective version of the
+// indirect dependency reaches the given minimum version.
+func isIndirect(line *Line) bool {
+	if len(line.Suffix) == 0 {
+		return false
+	}
+	f := strings.Fields(strings.TrimPrefix(line.Suffix[0].Token, string(slashSlash)))
+	return (len(f) == 1 && f[0] == "indirect" || len(f) > 1 && f[0] == "indirect;")
+}
+
 func (f *File) AddModuleStmt(path string) error {
 	if f.Syntax == nil {
 		f.Syntax = new(FileSyntax)
@@ -476,58 +556,6 @@ func (f *File) fixRetract(fix VersionFixer, errs *ErrorList) {
 	}
 }
 
-// isIndirect reports whether line has a "// indirect" comment,
-// meaning it is in go.mod only for its effect on indirect dependencies,
-// so that it can be dropped entirely once the effective version of the
-// indirect dependency reaches the given minimum version.
-func isIndirect(line *Line) bool {
-	if len(line.Suffix) == 0 {
-		return false
-	}
-	f := strings.Fields(strings.TrimPrefix(line.Suffix[0].Token, string(slashSlash)))
-	return (len(f) == 1 && f[0] == "indirect" || len(f) > 1 && f[0] == "indirect;")
-}
-
-// setIndirect sets line to have (or not have) a "// indirect" comment.
-func setIndirect(line *Line, indirect bool) {
-	if isIndirect(line) == indirect {
-		return
-	}
-	if indirect {
-		// Adding comment.
-		if len(line.Suffix) == 0 {
-			// New comment.
-			line.Suffix = []Comment{{Token: "// indirect", Suffix: true}}
-			return
-		}
-
-		com := &line.Suffix[0]
-		text := strings.TrimSpace(strings.TrimPrefix(com.Token, string(slashSlash)))
-		if text == "" {
-			// Empty comment.
-			com.Token = "// indirect"
-			return
-		}
-
-		// Insert at beginning of existing comment.
-		com.Token = "// indirect; " + text
-		return
-	}
-
-	// Removing comment.
-	f := strings.TrimSpace(strings.TrimPrefix(line.Suffix[0].Token, string(slashSlash)))
-	if f == "indirect" {
-		// Remove whole comment.
-		line.Suffix = nil
-		return
-	}
-
-	// Remove comment prefix.
-	com := &line.Suffix[0]
-	i := strings.Index(com.Token, "indirect;")
-	com.Token = "//" + com.Token[i+len("indirect;"):]
-}
-
 // IsDirectoryPath reports whether the given path should be interpreted
 // as a directory path. Just like on the go command line, relative paths
 // and rooted paths are directory paths; the rest are module paths.
@@ -835,6 +863,12 @@ func (f *File) AddGoStmt(version string) error {
 	return nil
 }
 
+// AddRequire sets the first require line for path to version vers,
+// preserving any existing comments for that line and removing all
+// other lines for path.
+//
+// If no line currently exists for path, AddRequire adds a new line
+// at the end of the last require block.
 func (f *File) AddRequire(path, vers string) error {
 	need := true
 	for _, r := range f.Require {
@@ -844,7 +878,7 @@ func (f *File) AddRequire(path, vers string) error {
 				f.Syntax.updateLine(r.Syntax, "require", AutoQuote(path), vers)
 				need = false
 			} else {
-				f.Syntax.removeLine(r.Syntax)
+				r.Syntax.markRemoved()
 				*r = Require{}
 			}
 		}
@@ -856,69 +890,235 @@ func (f *File) AddRequire(path, vers string) error {
 	return nil
 }
 
+// AddNewRequire adds a new require line for path at version vers at the end of
+// the last require block, regardless of any existing require lines for path.
 func (f *File) AddNewRequire(path, vers string, indirect bool) {
 	line := f.Syntax.addLine(nil, "require", AutoQuote(path), vers)
-	setIndirect(line, indirect)
-	f.Require = append(f.Require, &Require{module.Version{Path: path, Version: vers}, indirect, line})
+	r := &Require{
+		Mod:    module.Version{Path: path, Version: vers},
+		Syntax: line,
+	}
+	r.setIndirect(indirect)
+	f.Require = append(f.Require, r)
 }
 
+// SetRequire updates the requirements of f to contain exactly req, preserving
+// the existing block structure and line comment contents (except for 'indirect'
+// markings) for the first requirement on each named module path.
+//
+// The Syntax field is ignored for the requirements in req.
+//
+// Any requirements not already present in the file are added to the block
+// containing the last require line.
+//
+// The requirements in req must specify at most one distinct version for each
+// module path.
+//
+// If any existing requirements may be removed, the caller should call Cleanup
+// after all edits are complete.
 func (f *File) SetRequire(req []*Require) {
-	need := make(map[string]string)
-	indirect := make(map[string]bool)
+	type elem struct {
+		version  string
+		indirect bool
+	}
+	need := make(map[string]elem)
 	for _, r := range req {
-		need[r.Mod.Path] = r.Mod.Version
-		indirect[r.Mod.Path] = r.Indirect
+		if prev, dup := need[r.Mod.Path]; dup && prev.version != r.Mod.Version {
+			panic(fmt.Errorf("SetRequire called with conflicting versions for path %s (%s and %s)", r.Mod.Path, prev.version, r.Mod.Version))
+		}
+		need[r.Mod.Path] = elem{r.Mod.Version, r.Indirect}
 	}
 
+	// Update or delete the existing Require entries to preserve
+	// only the first for each module path in req.
 	for _, r := range f.Require {
-		if v, ok := need[r.Mod.Path]; ok {
-			r.Mod.Version = v
-			r.Indirect = indirect[r.Mod.Path]
+		e, ok := need[r.Mod.Path]
+		if ok {
+			r.setVersion(e.version)
+			r.setIndirect(e.indirect)
 		} else {
-			*r = Require{}
+			r.markRemoved()
+		}
+		delete(need, r.Mod.Path)
+	}
+
+	// Add new entries in the last block of the file for any paths that weren't
+	// already present.
+	//
+	// This step is nondeterministic, but the final result will be deterministic
+	// because we will sort the block.
+	for path, e := range need {
+		f.AddNewRequire(path, e.version, e.indirect)
+	}
+
+	f.SortBlocks()
+}
+
+// SetRequireSeparateIndirect updates the requirements of f to contain the given
+// requirements. Comment contents (except for 'indirect' markings) are retained
+// from the first existing requirement for each module path, and block structure
+// is maintained as long as the indirect markings match.
+//
+// Any requirements on paths not already present in the file are added. Direct
+// requirements are added to the last block containing *any* other direct
+// requirement. Indirect requirements are added to the last block containing
+// *only* other indirect requirements. If no suitable block exists, a new one is
+// added, with the last block containing a direct dependency (if any)
+// immediately before the first block containing only indirect dependencies.
+//
+// The Syntax field is ignored for requirements in the given blocks.
+func (f *File) SetRequireSeparateIndirect(req []*Require) {
+	type modKey struct {
+		path     string
+		indirect bool
+	}
+	need := make(map[modKey]string)
+	for _, r := range req {
+		need[modKey{r.Mod.Path, r.Indirect}] = r.Mod.Version
+	}
+
+	comments := make(map[string]Comments)
+	for _, r := range f.Require {
+		v, ok := need[modKey{r.Mod.Path, r.Indirect}]
+		if !ok {
+			if _, ok := need[modKey{r.Mod.Path, !r.Indirect}]; ok {
+				if _, dup := comments[r.Mod.Path]; !dup {
+					comments[r.Mod.Path] = r.Syntax.Comments
+				}
+			}
+			r.markRemoved()
+			continue
 		}
+		r.setVersion(v)
+		delete(need, modKey{r.Mod.Path, r.Indirect})
 	}
 
-	var newStmts []Expr
+	var (
+		lastDirectOrMixedBlock Expr
+		firstIndirectOnlyBlock Expr
+		lastIndirectOnlyBlock  Expr
+	)
 	for _, stmt := range f.Syntax.Stmt {
 		switch stmt := stmt.(type) {
+		case *Line:
+			if len(stmt.Token) == 0 || stmt.Token[0] != "require" {
+				continue
+			}
+			if isIndirect(stmt) {
+				lastIndirectOnlyBlock = stmt
+			} else {
+				lastDirectOrMixedBlock = stmt
+			}
 		case *LineBlock:
-			if len(stmt.Token) > 0 && stmt.Token[0] == "require" {
-				var newLines []*Line
+			if len(stmt.Token) == 0 || stmt.Token[0] != "require" {
+				continue
+			}
+			indirectOnly := true
+			for _, line := range stmt.Line {
+				if len(line.Token) == 0 {
+					continue
+				}
+				if !isIndirect(line) {
+					indirectOnly = false
+					break
+				}
+			}
+			if indirectOnly {
+				lastIndirectOnlyBlock = stmt
+				if firstIndirectOnlyBlock == nil {
+					firstIndirectOnlyBlock = stmt
+				}
+			} else {
+				lastDirectOrMixedBlock = stmt
+			}
+		}
+	}
+
+	isOrContainsStmt := func(stmt Expr, target Expr) bool {
+		if stmt == target {
+			return true
+		}
+		if stmt, ok := stmt.(*LineBlock); ok {
+			if target, ok := target.(*Line); ok {
 				for _, line := range stmt.Line {
-					if p, err := parseString(&line.Token[0]); err == nil && need[p] != "" {
-						if len(line.Comments.Before) == 1 && len(line.Comments.Before[0].Token) == 0 {
-							line.Comments.Before = line.Comments.Before[:0]
-						}
-						line.Token[1] = need[p]
-						delete(need, p)
-						setIndirect(line, indirect[p])
-						newLines = append(newLines, line)
+					if line == target {
+						return true
 					}
 				}
-				if len(newLines) == 0 {
-					continue // drop stmt
-				}
-				stmt.Line = newLines
 			}
+		}
+		return false
+	}
 
-		case *Line:
-			if len(stmt.Token) > 0 && stmt.Token[0] == "require" {
-				if p, err := parseString(&stmt.Token[1]); err == nil && need[p] != "" {
-					stmt.Token[2] = need[p]
-					delete(need, p)
-					setIndirect(stmt, indirect[p])
+	addRequire := func(path, vers string, indirect bool, comments Comments) {
+		var line *Line
+		if indirect {
+			if lastIndirectOnlyBlock != nil {
+				line = f.Syntax.addLine(lastIndirectOnlyBlock, "require", path, vers)
+			} else {
+				// Add a new require block after the last direct-only or mixed "require"
+				// block (if any).
+				//
+				// (f.Syntax.addLine would add the line to an existing "require" block if
+				// present, but here the existing "require" blocks are all direct-only, so
+				// we know we need to add a new block instead.)
+				line = &Line{Token: []string{"require", path, vers}}
+				lastIndirectOnlyBlock = line
+				firstIndirectOnlyBlock = line // only block implies first block
+				if lastDirectOrMixedBlock == nil {
+					f.Syntax.Stmt = append(f.Syntax.Stmt, line)
 				} else {
-					continue // drop stmt
+					for i, stmt := range f.Syntax.Stmt {
+						if isOrContainsStmt(stmt, lastDirectOrMixedBlock) {
+							f.Syntax.Stmt = append(f.Syntax.Stmt, nil)     // increase size
+							copy(f.Syntax.Stmt[i+2:], f.Syntax.Stmt[i+1:]) // shuffle elements up
+							f.Syntax.Stmt[i+1] = line
+							break
+						}
+					}
+				}
+			}
+		} else {
+			if lastDirectOrMixedBlock != nil {
+				line = f.Syntax.addLine(lastDirectOrMixedBlock, "require", path, vers)
+			} else {
+				// Add a new require block before the first indirect block (if any).
+				//
+				// That way if the file initially contains only indirect lines,
+				// the direct lines still appear before it: we preserve existing
+				// structure, but only to the extent that that structure already
+				// reflects the direct/indirect split.
+				line = &Line{Token: []string{"require", path, vers}}
+				lastDirectOrMixedBlock = line
+				if firstIndirectOnlyBlock == nil {
+					f.Syntax.Stmt = append(f.Syntax.Stmt, line)
+				} else {
+					for i, stmt := range f.Syntax.Stmt {
+						if isOrContainsStmt(stmt, firstIndirectOnlyBlock) {
+							f.Syntax.Stmt = append(f.Syntax.Stmt, nil)   // increase size
+							copy(f.Syntax.Stmt[i+1:], f.Syntax.Stmt[i:]) // shuffle elements up
+							f.Syntax.Stmt[i] = line
+							break
+						}
+					}
 				}
 			}
 		}
-		newStmts = append(newStmts, stmt)
+
+		line.Comments.Before = commentsAdd(line.Comments.Before, comments.Before)
+		line.Comments.Suffix = commentsAdd(line.Comments.Suffix, comments.Suffix)
+
+		r := &Require{
+			Mod:      module.Version{Path: path, Version: vers},
+			Indirect: indirect,
+			Syntax:   line,
+		}
+		r.setIndirect(indirect)
+		f.Require = append(f.Require, r)
 	}
-	f.Syntax.Stmt = newStmts
 
-	for path, vers := range need {
-		f.AddNewRequire(path, vers, indirect[path])
+	for k, vers := range need {
+		addRequire(k.path, vers, k.indirect, comments[k.path])
 	}
 	f.SortBlocks()
 }
@@ -926,7 +1126,7 @@ func (f *File) SetRequire(req []*Require) {
 func (f *File) DropRequire(path string) error {
 	for _, r := range f.Require {
 		if r.Mod.Path == path {
-			f.Syntax.removeLine(r.Syntax)
+			r.Syntax.markRemoved()
 			*r = Require{}
 		}
 	}
@@ -957,7 +1157,7 @@ func (f *File) AddExclude(path, vers string) error {
 func (f *File) DropExclude(path, vers string) error {
 	for _, x := range f.Exclude {
 		if x.Mod.Path == path && x.Mod.Version == vers {
-			f.Syntax.removeLine(x.Syntax)
+			x.Syntax.markRemoved()
 			*x = Exclude{}
 		}
 	}
@@ -988,7 +1188,7 @@ func (f *File) AddReplace(oldPath, oldVers, newPath, newVers string) error {
 				continue
 			}
 			// Already added; delete other replacements for same.
-			f.Syntax.removeLine(r.Syntax)
+			r.Syntax.markRemoved()
 			*r = Replace{}
 		}
 		if r.Old.Path == oldPath {
@@ -1004,7 +1204,7 @@ func (f *File) AddReplace(oldPath, oldVers, newPath, newVers string) error {
 func (f *File) DropReplace(oldPath, oldVers string) error {
 	for _, r := range f.Replace {
 		if r.Old.Path == oldPath && r.Old.Version == oldVers {
-			f.Syntax.removeLine(r.Syntax)
+			r.Syntax.markRemoved()
 			*r = Replace{}
 		}
 	}
@@ -1045,7 +1245,7 @@ func (f *File) AddRetract(vi VersionInterval, rationale string) error {
 func (f *File) DropRetract(vi VersionInterval) error {
 	for _, r := range f.Retract {
 		if r.VersionInterval == vi {
-			f.Syntax.removeLine(r.Syntax)
+			r.Syntax.markRemoved()
 			*r = Retract{}
 		}
 	}
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 9a1723d32c..34dbdaf5dd 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -28,7 +28,7 @@ golang.org/x/arch/x86/x86asm
 ## explicit; go 1.17
 golang.org/x/crypto/ed25519
 golang.org/x/crypto/ed25519/internal/edwards25519
-# golang.org/x/mod v0.4.3-0.20210512182355-6088ed88cecd
+# golang.org/x/mod v0.4.3-0.20210608190319-0f08993efd8a
 ## explicit; go 1.17
 golang.org/x/mod/internal/lazyregexp
 golang.org/x/mod/modfile
-- 
GitLab


From f753d7223e5c10f53af8bbe5f5558292b08d5e8a Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Mon, 7 Jun 2021 13:43:55 -0400
Subject: [PATCH 2193/2400] doc/go1.17: resolve TODO for cmd/cover

Updates #32211

Change-Id: Ie38e831fcf557534023afd552d9394fe9e055caa
Reviewed-on: https://go-review.googlesource.com/c/go/+/325909
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
---
 doc/go1.17.html | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 8b0fcea29d..ac315d4727 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -277,10 +277,6 @@ Do not send CLs removing the interior tags from such phrases.
   <code>mod</code> <code>download</code> <code>all</code>.
 </p>
 
-<p><!-- CL 249759 -->
-  TODO: <a href="https://golang.org/cl/249759">https://golang.org/cl/249759</a>: cmd/cover: replace code using optimized golang.org/x/tools/cover
-</p>
-
 <h3 id="vet">Vet</h3>
 
 <p><!-- CL 299532 -->
@@ -291,6 +287,14 @@ Do not send CLs removing the interior tags from such phrases.
   TODO: complete the Vet section
 </p>
 
+<h3 id="cover">Cover</h3>
+
+<p><!-- CL 249759 -->
+  The <code>cover</code> tool now uses an optimized parser
+  from <code>golang.org/x/tools/cover</code>, which may be noticeably faster
+  when parsing large coverage profiles.
+</p>
+
 <h2 id="compiler">Compiler</h2>
 
 <p><!-- golang.org/issue/40724 -->
-- 
GitLab


From 9afe071c605c65302066fa8ece7bdecd00730f8b Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Mon, 7 Jun 2021 17:11:32 -0400
Subject: [PATCH 2194/2400] doc/go1.17: remove TODO for Tools section

Change-Id: I6cd7376bd051222a830cbf18cf7e887072b61f3b
Reviewed-on: https://go-review.googlesource.com/c/go/+/325911
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 doc/go1.17.html | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index ac315d4727..42f3631b92 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -116,10 +116,6 @@ Do not send CLs removing the interior tags from such phrases.
 
 <h2 id="tools">Tools</h2>
 
-<p>
-  TODO: complete the Tools section
-</p>
-
 <h3 id="go-command">Go command</h3>
 
 <h4 id="lazy-loading">Lazy module loading</h4>
-- 
GitLab


From 689f4c7415acc8a135440574a483e0eeabba8b87 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Felix=20Geisend=C3=B6rfer?=
 <felix.geisendoerfer@datadoghq.com>
Date: Thu, 3 Jun 2021 15:33:08 +0200
Subject: [PATCH 2195/2400] doc/go1.17: mention block profile bias fix

Change-Id: I76fd872b2d74704396f0683ffa9cec40b7027247
Reviewed-on: https://go-review.googlesource.com/c/go/+/324471
Reviewed-by: Heschi Kreinick <heschi@google.com>
Trust: Dmitri Shuralyov <dmitshur@golang.org>
---
 doc/go1.17.html                 | 10 ++++++++++
 src/runtime/pprof/pprof_test.go | 22 ++++++++++++++++++++++
 2 files changed, 32 insertions(+)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 42f3631b92..1701508ea9 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -725,6 +725,16 @@ Do not send CLs removing the interior tags from such phrases.
   </dd>
 </dl><!-- runtime/metrics -->
 
+
+<dl id="runtime/pprof"><dt><a href="/pkg/runtime/pprof">runtime/pprof</a></dt>
+  <dd>
+    <p><!-- CL 299991 -->
+      Block profiles are no longer biased to favor infrequent long events over
+      frequent short events.
+    </p>
+  </dd>
+</dl><!-- runtime/pprof -->
+
 <dl id="strconv"><dt><a href="/pkg/strconv/">strconv</a></dt>
   <dd>
     <p><!-- CL 170079 -->
diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go
index 7cbb4fc7ae..e139ee787d 100644
--- a/src/runtime/pprof/pprof_test.go
+++ b/src/runtime/pprof/pprof_test.go
@@ -106,6 +106,28 @@ func TestCPUProfileMultithreaded(t *testing.T) {
 	})
 }
 
+func TestCPUProfileThreadBias(t *testing.T) {
+	cpuHogA := func(dur time.Duration) {
+		cpuHogger(cpuHog1, &salt2, dur)
+	}
+
+	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(2))
+	prof := testCPUProfile(t, stackContains, []string{"runtime/pprof.cpuHog1", "runtime/pprof.cpuHog2"}, avoidFunctions(), func(dur time.Duration) {
+		//c := make(chan int)
+		//go func() {
+		//cpuHogger(cpuHog1, &salt1, dur)
+		//c <- 1
+		//}()
+		cpuHogA(dur)
+		//<-c
+	})
+	fmt.Printf("%#v\n", prof)
+}
+
+func cpuHogA(dur time.Duration) {
+	cpuHogger(cpuHog1, &salt2, dur)
+}
+
 // containsInlinedCall reports whether the function body for the function f is
 // known to contain an inlined function call within the first maxBytes bytes.
 func containsInlinedCall(f interface{}, maxBytes int) bool {
-- 
GitLab


From da4a64014140adf83fb1434367ff68067249c267 Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Wed, 26 May 2021 12:14:19 -0400
Subject: [PATCH 2196/2400] doc/go1.17: revise OpenBSD release notes

Updates #44513.

Change-Id: I64077859fa3061fee8327599875ad3870d603a81
Reviewed-on: https://go-review.googlesource.com/c/go/+/322856
Trust: Cherry Mui <cherryyz@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Heschi Kreinick <heschi@google.com>
---
 doc/go1.17.html | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 1701508ea9..3a1b43a4e5 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -95,11 +95,13 @@ Do not send CLs removing the interior tags from such phrases.
   In Go 1.16, on the 64-bit x86 and 64-bit ARM architectures on
   OpenBSD (the <code>openbsd/amd64</code> and <code>openbsd/arm64</code>
   ports) system calls are made through <code>libc</code>, instead
-  of directly using the machine instructions. In Go 1.17, this is
-  also done on the 32-bit x86 and 32-bit ARM architectures on OpenBSD
+  of directly using machine instructions. In Go 1.17, this is also
+  done on the 32-bit x86 and 32-bit ARM architectures on OpenBSD
   (the <code>openbsd/386</code> and <code>openbsd/arm</code> ports).
   This ensures forward-compatibility with future versions of
-  OpenBSD.
+  OpenBSD, in particular, with OpenBSD 6.9 onwards, which requires
+  system calls to be made through <code>libc</code> for non-static
+  Go binaries.
 </p>
 
 <h3 id="arm64">ARM64</h3>
-- 
GitLab


From d3e3d03666bbd8784007bbb78a75864aac786967 Mon Sep 17 00:00:00 2001
From: Roland Shoemaker <roland@golang.org>
Date: Mon, 7 Jun 2021 10:21:29 -0700
Subject: [PATCH 2197/2400] net: reject leading zeros in IP address parsers

In both net.ParseIP and net.ParseCIDR reject leading zeros in the
dot-decimal notation of IPv4 addresses.

Fixes #30999
Fixes #43389

Change-Id: I2b6a31fe84db89ac828cf5ed03eaa586ee96ab68
Reviewed-on: https://go-review.googlesource.com/c/go/+/325829
Trust: Roland Shoemaker <roland@golang.org>
Trust: Katie Hockman <katie@golang.org>
Run-TryBot: Roland Shoemaker <roland@golang.org>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 doc/go1.17.html             | 10 ++++++++++
 src/net/hosts_test.go       |  4 ++--
 src/net/ip.go               |  4 ++++
 src/net/ip_test.go          |  8 ++++++--
 src/net/testdata/ipv4-hosts |  8 ++------
 5 files changed, 24 insertions(+), 10 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 3a1b43a4e5..56f88e6724 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -639,6 +639,16 @@ Do not send CLs removing the interior tags from such phrases.
       <a href="/pkg/net/#ParseError"><code>ParseError</code></a> error type now implement
       the <a href="/pkg/net/#Error"><code>net.Error</code></a> interface.
     </p>
+
+    <p><!-- CL325829 -->
+      The <a href="/pkg/net/#ParseIP"><code>ParseIP</code></a> and <a href="/pkg/net/#ParseCIDR"><code>ParseCIDR</code></a>
+      functions now reject IPv4 addresses which contain decimal components with leading zeros.
+
+      These components were always interpreted as decimal, but some operating systems treat them as octal.
+      This mismatch could hypothetically lead to security issues if a Go application was used to validate IP addresses
+      which were then used in their original form with non-Go applications which interpreted components as octal. Generally,
+      it is advisable to always re-encoded values after validation, which avoids this class of parser misalignment issues.
+    </p>
   </dd>
 </dl><!-- net -->
 
diff --git a/src/net/hosts_test.go b/src/net/hosts_test.go
index f850e2fccf..19c43999f9 100644
--- a/src/net/hosts_test.go
+++ b/src/net/hosts_test.go
@@ -36,7 +36,7 @@ var lookupStaticHostTests = []struct {
 		},
 	},
 	{
-		"testdata/ipv4-hosts", // see golang.org/issue/8996
+		"testdata/ipv4-hosts",
 		[]staticHostEntry{
 			{"localhost", []string{"127.0.0.1", "127.0.0.2", "127.0.0.3"}},
 			{"localhost.localdomain", []string{"127.0.0.3"}},
@@ -102,7 +102,7 @@ var lookupStaticAddrTests = []struct {
 		},
 	},
 	{
-		"testdata/ipv4-hosts", // see golang.org/issue/8996
+		"testdata/ipv4-hosts",
 		[]staticHostEntry{
 			{"127.0.0.1", []string{"localhost"}},
 			{"127.0.0.2", []string{"localhost"}},
diff --git a/src/net/ip.go b/src/net/ip.go
index 0477269761..38e1aa2247 100644
--- a/src/net/ip.go
+++ b/src/net/ip.go
@@ -574,6 +574,10 @@ func parseIPv4(s string) IP {
 		if !ok || n > 0xFF {
 			return nil
 		}
+		if c > 1 && s[0] == '0' {
+			// Reject non-zero components with leading zeroes.
+			return nil
+		}
 		s = s[c:]
 		p[i] = byte(n)
 	}
diff --git a/src/net/ip_test.go b/src/net/ip_test.go
index 3af5e41ceb..5bbda6024d 100644
--- a/src/net/ip_test.go
+++ b/src/net/ip_test.go
@@ -21,9 +21,7 @@ var parseIPTests = []struct {
 }{
 	{"127.0.1.2", IPv4(127, 0, 1, 2)},
 	{"127.0.0.1", IPv4(127, 0, 0, 1)},
-	{"127.001.002.003", IPv4(127, 1, 2, 3)},
 	{"::ffff:127.1.2.3", IPv4(127, 1, 2, 3)},
-	{"::ffff:127.001.002.003", IPv4(127, 1, 2, 3)},
 	{"::ffff:7f01:0203", IPv4(127, 1, 2, 3)},
 	{"0:0:0:0:0000:ffff:127.1.2.3", IPv4(127, 1, 2, 3)},
 	{"0:0:0:0:000000:ffff:127.1.2.3", IPv4(127, 1, 2, 3)},
@@ -43,6 +41,11 @@ var parseIPTests = []struct {
 	{"fe80::1%911", nil},
 	{"", nil},
 	{"a1:a2:a3:a4::b1:b2:b3:b4", nil}, // Issue 6628
+	{"127.001.002.003", nil},
+	{"::ffff:127.001.002.003", nil},
+	{"123.000.000.000", nil},
+	{"1.2..4", nil},
+	{"0123.0.0.1", nil},
 }
 
 func TestParseIP(t *testing.T) {
@@ -358,6 +361,7 @@ var parseCIDRTests = []struct {
 	{"0.0.-2.0/32", nil, nil, &ParseError{Type: "CIDR address", Text: "0.0.-2.0/32"}},
 	{"0.0.0.-3/32", nil, nil, &ParseError{Type: "CIDR address", Text: "0.0.0.-3/32"}},
 	{"0.0.0.0/-0", nil, nil, &ParseError{Type: "CIDR address", Text: "0.0.0.0/-0"}},
+	{"127.000.000.001/32", nil, nil, &ParseError{Type: "CIDR address", Text: "127.000.000.001/32"}},
 	{"", nil, nil, &ParseError{Type: "CIDR address", Text: ""}},
 }
 
diff --git a/src/net/testdata/ipv4-hosts b/src/net/testdata/ipv4-hosts
index 5208bb44ac..6b99675dfc 100644
--- a/src/net/testdata/ipv4-hosts
+++ b/src/net/testdata/ipv4-hosts
@@ -1,12 +1,8 @@
 # See https://tools.ietf.org/html/rfc1123.
-#
-# The literal IPv4 address parser in the net package is a relaxed
-# one. It may accept a literal IPv4 address in dotted-decimal notation
-# with leading zeros such as "001.2.003.4".
 
 # internet address and host name
 127.0.0.1	localhost	# inline comment separated by tab
-127.000.000.002	localhost       # inline comment separated by space
+127.0.0.2	localhost   # inline comment separated by space
 
 # internet address, host name and aliases
-127.000.000.003	localhost	localhost.localdomain
+127.0.0.3	localhost	localhost.localdomain
-- 
GitLab


From cb80937bf6b728fa56ee315d2c079f07c2f9f2a1 Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Tue, 8 Jun 2021 20:38:30 +0000
Subject: [PATCH 2198/2400] Revert "doc/go1.17: mention block profile bias fix"

This reverts CL 324471 (commit 689f4c7415acc8a135440574a483e0eeabba8b87).

Reason for revert: break ~all builders. And it is not a doc-only change.

Change-Id: Iadbdda34d2ca476a9f5e6c2d3a28592ed7ccb067
Reviewed-on: https://go-review.googlesource.com/c/go/+/326170
Trust: Cherry Mui <cherryyz@google.com>
Run-TryBot: Cherry Mui <cherryyz@google.com>
Reviewed-by: Heschi Kreinick <heschi@google.com>
---
 doc/go1.17.html                 | 10 ----------
 src/runtime/pprof/pprof_test.go | 22 ----------------------
 2 files changed, 32 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 56f88e6724..1e153377d6 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -737,16 +737,6 @@ Do not send CLs removing the interior tags from such phrases.
   </dd>
 </dl><!-- runtime/metrics -->
 
-
-<dl id="runtime/pprof"><dt><a href="/pkg/runtime/pprof">runtime/pprof</a></dt>
-  <dd>
-    <p><!-- CL 299991 -->
-      Block profiles are no longer biased to favor infrequent long events over
-      frequent short events.
-    </p>
-  </dd>
-</dl><!-- runtime/pprof -->
-
 <dl id="strconv"><dt><a href="/pkg/strconv/">strconv</a></dt>
   <dd>
     <p><!-- CL 170079 -->
diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go
index e139ee787d..7cbb4fc7ae 100644
--- a/src/runtime/pprof/pprof_test.go
+++ b/src/runtime/pprof/pprof_test.go
@@ -106,28 +106,6 @@ func TestCPUProfileMultithreaded(t *testing.T) {
 	})
 }
 
-func TestCPUProfileThreadBias(t *testing.T) {
-	cpuHogA := func(dur time.Duration) {
-		cpuHogger(cpuHog1, &salt2, dur)
-	}
-
-	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(2))
-	prof := testCPUProfile(t, stackContains, []string{"runtime/pprof.cpuHog1", "runtime/pprof.cpuHog2"}, avoidFunctions(), func(dur time.Duration) {
-		//c := make(chan int)
-		//go func() {
-		//cpuHogger(cpuHog1, &salt1, dur)
-		//c <- 1
-		//}()
-		cpuHogA(dur)
-		//<-c
-	})
-	fmt.Printf("%#v\n", prof)
-}
-
-func cpuHogA(dur time.Duration) {
-	cpuHogger(cpuHog1, &salt2, dur)
-}
-
 // containsInlinedCall reports whether the function body for the function f is
 // known to contain an inlined function call within the first maxBytes bytes.
 func containsInlinedCall(f interface{}, maxBytes int) bool {
-- 
GitLab


From 6551763a60ce25d171feaa69089a7f1ca60f43b6 Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Tue, 8 Jun 2021 16:42:02 -0400
Subject: [PATCH 2199/2400] doc/go1.17: mention block profile bias fix
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Re-apply the doc part of CL 324471, originally written by Felix Geisendörfer.

Change-Id: I831bead9a385bc5a5eed3058649a25ef17373bc6
Reviewed-on: https://go-review.googlesource.com/c/go/+/326171
Trust: Cherry Mui <cherryyz@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 doc/go1.17.html | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 1e153377d6..eb7932cd67 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -737,6 +737,15 @@ Do not send CLs removing the interior tags from such phrases.
   </dd>
 </dl><!-- runtime/metrics -->
 
+<dl id="runtime/pprof"><dt><a href="/pkg/runtime/pprof">runtime/pprof</a></dt>
+  <dd>
+    <p><!-- CL 299991 -->
+      Block profiles are no longer biased to favor infrequent long events over
+      frequent short events.
+    </p>
+  </dd>
+</dl><!-- runtime/pprof -->
+
 <dl id="strconv"><dt><a href="/pkg/strconv/">strconv</a></dt>
   <dd>
     <p><!-- CL 170079 -->
-- 
GitLab


From 63dcab2e91cfa40ae6dc1f0455b1f3c2801a00ec Mon Sep 17 00:00:00 2001
From: Tim King <taking@google.com>
Date: Tue, 25 May 2021 19:23:02 -0700
Subject: [PATCH 2200/2400] doc/go1.17: mention new vet checks sigchanyzer and
 stdmethods.

These vet checks were added in CL 299532 and CL 321389.

Also adds a TODO for buildtags.

Change-Id: I516dc77729f6d2dc147318260fe452831b115dfa
Reviewed-on: https://go-review.googlesource.com/c/go/+/322769
Trust: Tim King <taking@google.com>
Run-TryBot: Tim King <taking@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 doc/go1.17.html | 45 +++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 43 insertions(+), 2 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index eb7932cd67..cc3bcdf180 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -277,14 +277,55 @@ Do not send CLs removing the interior tags from such phrases.
 
 <h3 id="vet">Vet</h3>
 
+<h4 id="vet-buildtags">New warning within buildtags</h4>
+
+<p><!-- CL 240609 -->
+  TODO(rsc): Describe changes to buildtags <a href="https://golang.org/cl/240609">https://golang.org/cl/240609</a>
+</p>
+
+<h4 id="vet-sigchanyzer">New warning for calling <code>signal.Notify</code> on unbuffered channels</h4>
+
 <p><!-- CL 299532 -->
-  TODO: <a href="https://golang.org/cl/299532">https://golang.org/cl/299532</a>: cmd/vet: bring in sigchanyzer to report unbuffered channels to signal.Notify
+  The vet tool now warns about calls to <a href="/pkg/os/signal/#Notify">signal.Notify</a>
+  with incoming signals being sent to an unbuffered channel. Using an unbuffered channel
+  risks missing signals sent on them as <code>signal.Notify</code> does not block when
+  sending to a channel. For example:
 </p>
 
+<pre>
+c := make(chan os.Signal)
+// signals are sent on c before the channel is read from.
+// This signal may be dropped as c is unbuffered.
+signal.Notify(c, os.Interrupt)
+</pre>
+
 <p>
-  TODO: complete the Vet section
+  Users of <code>signal.Notify</code> should use channels with sufficient buffer space to keep up with the
+  expected signal rate.
 </p>
 
+<h4 id="vet-error-stdmethods">New warnings for Is, As and Unwrap methods</h4>
+
+<p><!-- CL 321389 -->
+  The vet tool now warns about methods named <code>As</code>, <code>Is</code> or <code>Unwrap</code>
+  on types implementing the <code>error</code> interface that have a different signature than the
+  one expected by the <code>errors</code> package. The <code>errors.{As,Is,Unwrap}</code> functions
+  expect such methods to implement either <code>Is(error)</code> <code>bool</code>,
+  <code>As(interface{})</code> <code>bool</code>, or <code>Unwrap()</code> <code>error</code>
+  respectively. The functions <code>errors.{As,Is,Unwrap}</code> will ignore methods with the same
+  names but a different signature. For example:
+</p>
+
+<pre>
+type MyError struct { hint string }
+func (m MyError) Error() string { ... } // MyError implements error.
+func (MyError) Is(target interface{}) bool { ... } // target is interface{} instead of error.
+func Foo() bool {
+	x, y := MyError{"A"}, MyError{"B"}
+	return errors.Is(x, y) // returns false as x != y and MyError does not have an `Is(error) bool` function.
+}
+</pre>
+
 <h3 id="cover">Cover</h3>
 
 <p><!-- CL 249759 -->
-- 
GitLab


From bcecae2af6ee43abebf84411385d538ec4e7d0ea Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Tue, 8 Jun 2021 12:42:02 -0700
Subject: [PATCH 2201/2400] doc/go1.17: mention new possibility of type
 conversion panicking

For #44513
For #46020

Change-Id: I07c7a4268465c536d1866cc6bb1fad76b2b88b15
Reviewed-on: https://go-review.googlesource.com/c/go/+/326149
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 doc/go1.17.html | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index cc3bcdf180..011377a84e 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -67,6 +67,14 @@ Do not send CLs removing the interior tags from such phrases.
   using <code>unsafe.Add</code> or <code>unsafe.Slice</code>.
 </p>
 
+
+<p>
+  Note that the new conversion from slice to array pointer is the
+  first case in which a type conversion can panic at run time.
+  Analysis tools that assume type conversions can never panic
+  should be updated to consider this possibility.
+</p>
+
 <h2 id="ports">Ports</h2>
 
 <h3 id="darwin">Darwin</h3>
-- 
GitLab


From 07ca28d529e1afb64a9f6f068214c05ee9772d34 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Tue, 8 Jun 2021 19:45:41 -0400
Subject: [PATCH 2202/2400] cmd/link: fix bug in -strictdups checking of BSS
 symbols

The linker's -strictdups debugging option was not properly checking
for cases where you have two dupok BSS symbols with different length
(the check examined data length and content, but not symbol size).

Updates #46653.

Change-Id: I3844f25ef76dd6e4a84ffd5caed5d19a1b1a57c9
Reviewed-on: https://go-review.googlesource.com/c/go/+/326210
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 src/cmd/link/internal/loader/loader.go | 12 +++++--
 src/cmd/link/link_test.go              | 43 +++++++++++++++++++-------
 2 files changed, 41 insertions(+), 14 deletions(-)

diff --git a/src/cmd/link/internal/loader/loader.go b/src/cmd/link/internal/loader/loader.go
index 1b71a66c6f..efca824d98 100644
--- a/src/cmd/link/internal/loader/loader.go
+++ b/src/cmd/link/internal/loader/loader.go
@@ -699,12 +699,18 @@ func (l *Loader) checkdup(name string, r *oReader, li uint32, dup Sym) {
 	p := r.Data(li)
 	rdup, ldup := l.toLocal(dup)
 	pdup := rdup.Data(ldup)
-	if bytes.Equal(p, pdup) {
-		return
-	}
 	reason := "same length but different contents"
 	if len(p) != len(pdup) {
 		reason = fmt.Sprintf("new length %d != old length %d", len(p), len(pdup))
+	} else if bytes.Equal(p, pdup) {
+		// For BSS symbols, we need to check size as well, see issue 46653.
+		szdup := l.SymSize(dup)
+		sz := int64(r.Sym(li).Siz())
+		if szdup == sz {
+			return
+		}
+		reason = fmt.Sprintf("different sizes: new size %d != old size %d",
+			sz, szdup)
 	}
 	fmt.Fprintf(os.Stderr, "cmd/link: while reading object for '%v': duplicate symbol '%s', previous def at '%v', with mismatched payload: %s\n", r.unit.Lib, name, rdup.unit.Lib, reason)
 
diff --git a/src/cmd/link/link_test.go b/src/cmd/link/link_test.go
index 4d6bc76aca..7230054bed 100644
--- a/src/cmd/link/link_test.go
+++ b/src/cmd/link/link_test.go
@@ -470,10 +470,30 @@ TEXT	·f(SB), NOSPLIT|DUPOK, $0-0
 	JMP	0(PC)
 `
 
+const testStrictDupAsmSrc3 = `
+#include "textflag.h"
+GLOBL ·rcon(SB), RODATA|DUPOK, $64
+`
+
+const testStrictDupAsmSrc4 = `
+#include "textflag.h"
+GLOBL ·rcon(SB), RODATA|DUPOK, $32
+`
+
 func TestStrictDup(t *testing.T) {
 	// Check that -strictdups flag works.
 	testenv.MustHaveGoBuild(t)
 
+	asmfiles := []struct {
+		fname   string
+		payload string
+	}{
+		{"a", testStrictDupAsmSrc1},
+		{"b", testStrictDupAsmSrc2},
+		{"c", testStrictDupAsmSrc3},
+		{"d", testStrictDupAsmSrc4},
+	}
+
 	t.Parallel()
 
 	tmpdir := t.TempDir()
@@ -483,15 +503,12 @@ func TestStrictDup(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	src = filepath.Join(tmpdir, "a.s")
-	err = ioutil.WriteFile(src, []byte(testStrictDupAsmSrc1), 0666)
-	if err != nil {
-		t.Fatal(err)
-	}
-	src = filepath.Join(tmpdir, "b.s")
-	err = ioutil.WriteFile(src, []byte(testStrictDupAsmSrc2), 0666)
-	if err != nil {
-		t.Fatal(err)
+	for _, af := range asmfiles {
+		src = filepath.Join(tmpdir, af.fname+".s")
+		err = ioutil.WriteFile(src, []byte(af.payload), 0666)
+		if err != nil {
+			t.Fatal(err)
+		}
 	}
 	src = filepath.Join(tmpdir, "go.mod")
 	err = ioutil.WriteFile(src, []byte("module teststrictdup\n"), 0666)
@@ -503,7 +520,7 @@ func TestStrictDup(t *testing.T) {
 	cmd.Dir = tmpdir
 	out, err := cmd.CombinedOutput()
 	if err != nil {
-		t.Errorf("linking with -strictdups=1 failed: %v", err)
+		t.Errorf("linking with -strictdups=1 failed: %v\n%s", err, string(out))
 	}
 	if !bytes.Contains(out, []byte("mismatched payload")) {
 		t.Errorf("unexpected output:\n%s", out)
@@ -515,7 +532,11 @@ func TestStrictDup(t *testing.T) {
 	if err == nil {
 		t.Errorf("linking with -strictdups=2 did not fail")
 	}
-	if !bytes.Contains(out, []byte("mismatched payload")) {
+	// NB: on amd64 we get the 'new length' error, on arm64 the 'different
+	// contents' error.
+	if !(bytes.Contains(out, []byte("mismatched payload: new length")) ||
+		bytes.Contains(out, []byte("mismatched payload: same length but different contents"))) ||
+		!bytes.Contains(out, []byte("mismatched payload: different sizes")) {
 		t.Errorf("unexpected output:\n%s", out)
 	}
 }
-- 
GitLab


From aa5540cd82170f82c6fe11511e12de96aa58cbc1 Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Tue, 8 Jun 2021 20:09:49 -0400
Subject: [PATCH 2203/2400] cmd/compile: make map.zero symbol
 content-addressable

The compiler machinery that generates "map.zero" symbols marks them as
RODATA and DUPOK, which is problematic when a given application has
multiple map zero symbols (from different packages) with varying
sizes: the dupok path in the loader assumes that if two symbols have
the same name, it is safe to pick any of the versions. In the case of
map.zero, the link needs to select the largest symbol, not an
arbitrary sym.

To fix this problem, mark map.zero symbols as content-addressable,
since the loader's content addressability processing path already
supports selection of the larger symbol in cases where there are dups.

Fixes #46653.

Change-Id: Iabd2feef01d448670ba795c7eaddc48c191ea276
Reviewed-on: https://go-review.googlesource.com/c/go/+/326211
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 src/cmd/compile/internal/gc/obj.go       |  1 +
 test/fixedbugs/issue46653.dir/bad/bad.go | 64 ++++++++++++++++++++++++
 test/fixedbugs/issue46653.dir/main.go    | 27 ++++++++++
 test/fixedbugs/issue46653.go             | 10 ++++
 4 files changed, 102 insertions(+)
 create mode 100644 test/fixedbugs/issue46653.dir/bad/bad.go
 create mode 100644 test/fixedbugs/issue46653.dir/main.go
 create mode 100644 test/fixedbugs/issue46653.go

diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 0b10cb8a9e..55a0ab7da7 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -148,6 +148,7 @@ func dumpdata() {
 	if reflectdata.ZeroSize > 0 {
 		zero := base.PkgLinksym("go.map", "zero", obj.ABI0)
 		objw.Global(zero, int32(reflectdata.ZeroSize), obj.DUPOK|obj.RODATA)
+		zero.Set(obj.AttrContentAddressable, true)
 	}
 
 	staticdata.WriteFuncSyms()
diff --git a/test/fixedbugs/issue46653.dir/bad/bad.go b/test/fixedbugs/issue46653.dir/bad/bad.go
new file mode 100644
index 0000000000..c1611b8347
--- /dev/null
+++ b/test/fixedbugs/issue46653.dir/bad/bad.go
@@ -0,0 +1,64 @@
+// Copyright 2021 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 a
+
+func Bad() {
+	m := make(map[int64]A)
+	a := m[0]
+	if len(a.B.C1.D2.E2.F1) != 0 ||
+		len(a.B.C1.D2.E2.F2) != 0 ||
+		len(a.B.C1.D2.E2.F3) != 0 ||
+		len(a.B.C1.D2.E2.F4) != 0 ||
+		len(a.B.C1.D2.E2.F5) != 0 ||
+		len(a.B.C1.D2.E2.F6) != 0 ||
+		len(a.B.C1.D2.E2.F7) != 0 ||
+		len(a.B.C1.D2.E2.F8) != 0 ||
+		len(a.B.C1.D2.E2.F9) != 0 ||
+		len(a.B.C1.D2.E2.F10) != 0 ||
+		len(a.B.C1.D2.E2.F11) != 0 ||
+		len(a.B.C1.D2.E2.F16) != 0 {
+		panic("bad")
+	}
+}
+
+type A struct {
+	B
+}
+
+type B struct {
+	C1 C
+	C2 C
+}
+
+type C struct {
+	D1 D
+	D2 D
+}
+
+type D struct {
+	E1 E
+	E2 E
+	E3 E
+	E4 E
+}
+
+type E struct {
+	F1  string
+	F2  string
+	F3  string
+	F4  string
+	F5  string
+	F6  string
+	F7  string
+	F8  string
+	F9  string
+	F10 string
+	F11 string
+	F12 string
+	F13 string
+	F14 string
+	F15 string
+	F16 string
+}
diff --git a/test/fixedbugs/issue46653.dir/main.go b/test/fixedbugs/issue46653.dir/main.go
new file mode 100644
index 0000000000..e2a96e54ec
--- /dev/null
+++ b/test/fixedbugs/issue46653.dir/main.go
@@ -0,0 +1,27 @@
+// Copyright 2021 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 (
+	bad "issue46653.dir/bad"
+)
+
+func main() {
+	bad.Bad()
+}
+
+func neverCalled() L {
+	m := make(map[string]L)
+	return m[""]
+}
+
+type L struct {
+	A Data
+	B Data
+}
+
+type Data struct {
+	F1 [22][]string
+}
diff --git a/test/fixedbugs/issue46653.go b/test/fixedbugs/issue46653.go
new file mode 100644
index 0000000000..e6283b1de5
--- /dev/null
+++ b/test/fixedbugs/issue46653.go
@@ -0,0 +1,10 @@
+// runindir
+
+// Copyright 2021 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.
+
+// Test to verify compiler and linker handling of multiple
+// competing map.zero symbol definitions.
+
+package ignored
-- 
GitLab


From 139e935d3cc8d38c9adc7ff7de8a87c28fe339c6 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 13 May 2021 10:46:58 -0400
Subject: [PATCH 2204/2400] math/big: comment division

The comments in the code refer to Knuth and to Burnikel and Ziegler,
but Knuth's presentation is inscrutable, and our recursive division
code does not bear much resemblance to Burnikel and Ziegler's paper
(which is fine, ours is nicer).

Add a standalone explanation of division instead of referring to
difficult or not-directly-used references.

Change-Id: Ic1b35dc167fb29a69ee00e0b4a768ac9cc9e1324
Reviewed-on: https://go-review.googlesource.com/c/go/+/321078
Trust: Russ Cox <rsc@golang.org>
Trust: Katie Hockman <katie@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
---
 src/math/big/natdiv.go | 684 ++++++++++++++++++++++++++++++++++++-----
 1 file changed, 611 insertions(+), 73 deletions(-)

diff --git a/src/math/big/natdiv.go b/src/math/big/natdiv.go
index 1330990c2c..882bb6d3ba 100644
--- a/src/math/big/natdiv.go
+++ b/src/math/big/natdiv.go
@@ -2,10 +2,506 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+/*
+
+Multi-precision division. Here be dragons.
+
+Given u and v, where u is n+m digits, and v is n digits (with no leading zeros),
+the goal is to return quo, rem such that u = quo*v + rem, where 0 ≤ rem < v.
+That is, quo = ⌊u/v⌋ where ⌊x⌋ denotes the floor (truncation to integer) of x,
+and rem = u - quo·v.
+
+
+Long Division
+
+Division in a computer proceeds the same as long division in elementary school,
+but computers are not as good as schoolchildren at following vague directions,
+so we have to be much more precise about the actual steps and what can happen.
+
+We work from most to least significant digit of the quotient, doing:
+
+ • Guess a digit q, the number of v to subtract from the current
+   section of u to zero out the topmost digit.
+ • Check the guess by multiplying q·v and comparing it against
+   the current section of u, adjusting the guess as needed.
+ • Subtract q·v from the current section of u.
+ • Add q to the corresponding section of the result quo.
+
+When all digits have been processed, the final remainder is left in u
+and returned as rem.
+
+For example, here is a sketch of dividing 5 digits by 3 digits (n=3, m=2).
+
+	                 q₂ q₁ q₀
+	         _________________
+	v₂ v₁ v₀ ) u₄ u₃ u₂ u₁ u₀
+	           ↓  ↓  ↓  |  |
+	          [u₄ u₃ u₂]|  |
+	        - [  q₂·v  ]|  |
+	        ----------- ↓  |
+	          [  rem  | u₁]|
+	        - [    q₁·v   ]|
+	           ----------- ↓
+	             [  rem  | u₀]
+	           - [    q₀·v   ]
+	              ------------
+	                [  rem   ]
+
+Instead of creating new storage for the remainders and copying digits from u
+as indicated by the arrows, we use u's storage directly as both the source
+and destination of the subtractions, so that the remainders overwrite
+successive overlapping sections of u as the division proceeds, using a slice
+of u to identify the current section. This avoids all the copying as well as
+shifting of remainders.
+
+Division of u with n+m digits by v with n digits (in base B) can in general
+produce at most m+1 digits, because:
+
+  • u < B^(n+m)               [B^(n+m) has n+m+1 digits]
+  • v ≥ B^(n-1)               [B^(n-1) is the smallest n-digit number]
+  • u/v < B^(n+m) / B^(n-1)   [divide bounds for u, v]
+  • u/v < B^(m+1)             [simplify]
+
+The first step is special: it takes the top n digits of u and divides them by
+the n digits of v, producing the first quotient digit and an n-digit remainder.
+In the example, q₂ = ⌊u₄u₃u₂ / v⌋.
+
+The first step divides n digits by n digits to ensure that it produces only a
+single digit.
+
+Each subsequent step appends the next digit from u to the remainder and divides
+those n+1 digits by the n digits of v, producing another quotient digit and a
+new n-digit remainder.
+
+Subsequent steps divide n+1 digits by n digits, an operation that in general
+might produce two digits. However, as used in the algorithm, that division is
+guaranteed to produce only a single digit. The dividend is of the form
+rem·B + d, where rem is a remainder from the previous step and d is a single
+digit, so:
+
+ • rem ≤ v - 1                 [rem is a remainder from dividing by v]
+ • rem·B ≤ v·B - B             [multiply by B]
+ • d ≤ B - 1                   [d is a single digit]
+ • rem·B + d ≤ v·B - 1         [add]
+ • rem·B + d < v·B             [change ≤ to <]
+ • (rem·B + d)/v < B           [divide by v]
+
+
+Guess and Check
+
+At each step we need to divide n+1 digits by n digits, but this is for the
+implementation of division by n digits, so we can't just invoke a division
+routine: we _are_ the division routine. Instead, we guess at the answer and
+then check it using multiplication. If the guess is wrong, we correct it.
+
+How can this guessing possibly be efficient? It turns out that the following
+statement (let's call it the Good Guess Guarantee) is true.
+
+If
+
+ • q = ⌊u/v⌋ where u is n+1 digits and v is n digits,
+ • q < B, and
+ • the topmost digit of v = vₙ₋₁ ≥ B/2,
+
+then q̂ = ⌊uₙuₙ₋₁ / vₙ₋₁⌋ satisfies q ≤ q̂ ≤ q+2. (Proof below.)
+
+That is, if we know the answer has only a single digit and we guess an answer
+by ignoring the bottom n-1 digits of u and v, using a 2-by-1-digit division,
+then that guess is at least as large as the correct answer. It is also not
+too much larger: it is off by at most two from the correct answer.
+
+Note that in the first step of the overall division, which is an n-by-n-digit
+division, the 2-by-1 guess uses an implicit uₙ = 0.
+
+Note that using a 2-by-1-digit division here does not mean calling ourselves
+recursively. Instead, we use an efficient direct hardware implementation of
+that operation.
+
+Note that because q is u/v rounded down, q·v must not exceed u: u ≥ q·v.
+If a guess q̂ is too big, it will not satisfy this test. Viewed a different way,
+the remainder r̂ for a given q̂ is u - q̂·v, which must be positive. If it is
+negative, then the guess q̂ is too big.
+
+This gives us a way to compute q. First compute q̂ with 2-by-1-digit division.
+Then, while u < q̂·v, decrement q̂; this loop executes at most twice, because
+q̂ ≤ q+2.
+
+
+Scaling Inputs
+
+The Good Guess Guarantee requires that the top digit of v (vₙ₋₁) be at least B/2.
+For example in base 10, ⌊172/19⌋ = 9, but ⌊18/1⌋ = 18: the guess is wildly off
+because the first digit 1 is smaller than B/2 = 5.
+
+We can ensure that v has a large top digit by multiplying both u and v by the
+right amount. Continuing the example, if we multiply both 172 and 19 by 3, we
+now have ⌊516/57⌋, the leading digit of v is now ≥ 5, and sure enough
+⌊51/5⌋ = 10 is much closer to the correct answer 9. It would be easier here
+to multiply by 4, because that can be done with a shift. Specifically, we can
+always count the number of leading zeros i in the first digit of v and then
+shift both u and v left by i bits.
+
+Having scaled u and v, the value ⌊u/v⌋ is unchanged, but the remainder will
+be scaled: 172 mod 19 is 1, but 516 mod 57 is 3. We have to divide the remainder
+by the scaling factor (shifting right i bits) when we finish.
+
+Note that these shifts happen before and after the entire division algorithm,
+not at each step in the per-digit iteration.
+
+Note the effect of scaling inputs on the size of the possible quotient.
+In the scaled u/v, u can gain a digit from scaling; v never does, because we
+pick the scaling factor to make v's top digit larger but without overflowing.
+If u and v have n+m and n digits after scaling, then:
+
+  • u < B^(n+m)               [B^(n+m) has n+m+1 digits]
+  • v ≥ B^n / 2               [vₙ₋₁ ≥ B/2, so vₙ₋₁·B^(n-1) ≥ B^n/2]
+  • u/v < B^(n+m) / (B^n / 2) [divide bounds for u, v]
+  • u/v < 2 B^m               [simplify]
+
+The quotient can still have m+1 significant digits, but if so the top digit
+must be a 1. This provides a different way to handle the first digit of the
+result: compare the top n digits of u against v and fill in either a 0 or a 1.
+
+
+Refining Guesses
+
+Before we check whether u < q̂·v, we can adjust our guess to change it from
+q̂ = ⌊uₙuₙ₋₁ / vₙ₋₁⌋ into the refined guess ⌊uₙuₙ₋₁uₙ₋₂ / vₙ₋₁vₙ₋₂⌋.
+Although not mentioned above, the Good Guess Guarantee also promises that this
+3-by-2-digit division guess is more precise and at most one away from the real
+answer q. The improvement from the 2-by-1 to the 3-by-2 guess can also be done
+without n-digit math.
+
+If we have a guess q̂ = ⌊uₙuₙ₋₁ / vₙ₋₁⌋ and we want to see if it also equal to
+⌊uₙuₙ₋₁uₙ₋₂ / vₙ₋₁vₙ₋₂⌋, we can use the same check we would for the full division:
+if uₙuₙ₋₁uₙ₋₂ < q̂·vₙ₋₁vₙ₋₂, then the guess is too large and should be reduced.
+
+Checking uₙuₙ₋₁uₙ₋₂ < q̂·vₙ₋₁vₙ₋₂ is the same as uₙuₙ₋₁uₙ₋₂ - q̂·vₙ₋₁vₙ₋₂ < 0,
+and
+
+	uₙuₙ₋₁uₙ₋₂ - q̂·vₙ₋₁vₙ₋₂ = (uₙuₙ₋₁·B + uₙ₋₂) - q̂·(vₙ₋₁·B + vₙ₋₂)
+	                          [splitting off the bottom digit]
+	                      = (uₙuₙ₋₁ - q̂·vₙ₋₁)·B + uₙ₋₂ - q̂·vₙ₋₂
+	                          [regrouping]
+
+The expression (uₙuₙ₋₁ - q̂·vₙ₋₁) is the remainder of uₙuₙ₋₁ / vₙ₋₁.
+If the initial guess returns both q̂ and its remainder r̂, then checking
+whether uₙuₙ₋₁uₙ₋₂ < q̂·vₙ₋₁vₙ₋₂ is the same as checking r̂·B + uₙ₋₂ < q̂·vₙ₋₂.
+
+If we find that r̂·B + uₙ₋₂ < q̂·vₙ₋₂, then we can adjust the guess by
+decrementing q̂ and adding vₙ₋₁ to r̂. We repeat until r̂·B + uₙ₋₂ ≥ q̂·vₙ₋₂.
+(As before, this fixup is only needed at most twice.)
+
+Now that q̂ = ⌊uₙuₙ₋₁uₙ₋₂ / vₙ₋₁vₙ₋₂⌋, as mentioned above it is at most one
+away from the correct q, and we've avoided doing any n-digit math.
+(If we need the new remainder, it can be computed as r̂·B + uₙ₋₂ - q̂·vₙ₋₂.)
+
+The final check u < q̂·v and the possible fixup must be done at full precision.
+For random inputs, a fixup at this step is exceedingly rare: the 3-by-2 guess
+is not often wrong at all. But still we must do the check. Note that since the
+3-by-2 guess is off by at most 1, it can be convenient to perform the final
+u < q̂·v as part of the computation of the remainder r = u - q̂·v. If the
+subtraction underflows, decremeting q̂ and adding one v back to r is enough to
+arrive at the final q, r.
+
+That's the entirety of long division: scale the inputs, and then loop over
+each output position, guessing, checking, and correcting the next output digit.
+
+For a 2n-digit number divided by an n-digit number (the worst size-n case for
+division complexity), this algorithm uses n+1 iterations, each of which must do
+at least the 1-by-n-digit multiplication q̂·v. That's O(n) iterations of
+O(n) time each, so O(n²) time overall.
+
+
+Recursive Division
+
+For very large inputs, it is possible to improve on the O(n²) algorithm.
+Let's call a group of n/2 real digits a (very) “wide digit”. We can run the
+standard long division algorithm explained above over the wide digits instead of
+the actual digits. This will result in many fewer steps, but the math involved in
+each step is more work.
+
+Where basic long division uses a 2-by-1-digit division to guess the initial q̂,
+the new algorithm must use a 2-by-1-wide-digit division, which is of course
+really an n-by-n/2-digit division. That's OK: if we implement n-digit division
+in terms of n/2-digit division, the recursion will terminate when the divisor
+becomes small enough to handle with standard long division or even with the
+2-by-1 hardware instruction.
+
+For example, here is a sketch of dividing 10 digits by 4, proceeding with
+wide digits corresponding to two regular digits. The first step, still special,
+must leave off a (regular) digit, dividing 5 by 4 and producing a 4-digit
+remainder less than v. The middle steps divide 6 digits by 4, guaranteed to
+produce two output digits each (one wide digit) with 4-digit remainders.
+The final step must use what it has: the 4-digit remainder plus one more,
+5 digits to divide by 4.
+
+	                       q₆ q₅ q₄ q₃ q₂ q₁ q₀
+	            _______________________________
+	v₃ v₂ v₁ v₀ ) u₉ u₈ u₇ u₆ u₅ u₄ u₃ u₂ u₁ u₀
+	              ↓  ↓  ↓  ↓  ↓  |  |  |  |  |
+	             [u₉ u₈ u₇ u₆ u₅]|  |  |  |  |
+	           - [    q₆q₅·v    ]|  |  |  |  |
+	           ----------------- ↓  ↓  |  |  |
+	                [    rem    |u₄ u₃]|  |  |
+	              - [     q₄q₃·v      ]|  |  |
+	              -------------------- ↓  ↓  |
+	                      [    rem    |u₂ u₁]|
+	                    - [     q₂q₁·v      ]|
+	                    -------------------- ↓
+	                            [    rem    |u₀]
+	                          - [     q₀·v     ]
+	                          ------------------
+	                               [    rem    ]
+
+An alternative would be to look ahead to how well n/2 divides into n+m and
+adjust the first step to use fewer digits as needed, making the first step
+more special to make the last step not special at all. For example, using the
+same input, we could choose to use only 4 digits in the first step, leaving
+a full wide digit for the last step:
+
+	                       q₆ q₅ q₄ q₃ q₂ q₁ q₀
+	            _______________________________
+	v₃ v₂ v₁ v₀ ) u₉ u₈ u₇ u₆ u₅ u₄ u₃ u₂ u₁ u₀
+	              ↓  ↓  ↓  ↓  |  |  |  |  |  |
+	             [u₉ u₈ u₇ u₆]|  |  |  |  |  |
+	           - [    q₆·v   ]|  |  |  |  |  |
+	           -------------- ↓  ↓  |  |  |  |
+	             [    rem    |u₅ u₄]|  |  |  |
+	           - [     q₅q₄·v      ]|  |  |  |
+	           -------------------- ↓  ↓  |  |
+	                   [    rem    |u₃ u₂]|  |
+	                 - [     q₃q₂·v      ]|  |
+	                 -------------------- ↓  ↓
+	                         [    rem    |u₁ u₀]
+	                       - [     q₁q₀·v      ]
+	                       ---------------------
+	                               [    rem    ]
+
+Today, the code in divRecursiveStep works like the first example. Perhaps in
+the future we will make it work like the alternative, to avoid a special case
+in the final iteration.
+
+Either way, each step is a 3-by-2-wide-digit division approximated first by
+a 2-by-1-wide-digit division, just as we did for regular digits in long division.
+Because the actual answer we want is a 3-by-2-wide-digit division, instead of
+multiplying q̂·v directly during the fixup, we can use the quick refinement
+from long division (an n/2-by-n/2 multiply) to correct q to its actual value
+and also compute the remainder (as mentioned above), and then stop after that,
+never doing a full n-by-n multiply.
+
+Instead of using an n-by-n/2-digit division to produce n/2 digits, we can add
+(not discard) one more real digit, doing an (n+1)-by-(n/2+1)-digit division that
+produces n/2+1 digits. That single extra digit tightens the Good Guess Guarantee
+to q ≤ q̂ ≤ q+1 and lets us drop long division's special treatment of the first
+digit. These benefits are discussed more after the Good Guess Guarantee proof
+below.
+
+
+How Fast is Recursive Division?
+
+For a 2n-by-n-digit division, this algorithm runs a 4-by-2 long division over
+wide digits, producing two wide digits plus a possible leading regular digit 1,
+which can be handled without a recursive call. That is, the algorithm uses two
+full iterations, each using an n-by-n/2-digit division and an n/2-by-n/2-digit
+multiplication, along with a few n-digit additions and subtractions. The standard
+n-by-n-digit multiplication algorithm requires O(n²) time, making the overall
+algorithm require time T(n) where
+
+	T(n) = 2T(n/2) + O(n) + O(n²)
+
+which, by the Bentley-Haken-Saxe theorem, ends up reducing to T(n) = O(n²).
+This is not an improvement over regular long division.
+
+When the number of digits n becomes large enough, Karatsuba's algorithm for
+multiplication can be used instead, which takes O(n^log₂3) = O(n^1.6) time.
+(Karatsuba multiplication is implemented in func karatsuba in nat.go.)
+That makes the overall recursive division algorithm take O(n^1.6) time as well,
+which is an improvement, but again only for large enough numbers.
+
+It is not critical to make sure that every recursion does only two recursive
+calls. While in general the number of recursive calls can change the time
+analysis, in this case doing three calls does not change the analysis:
+
+	T(n) = 3T(n/2) + O(n) + O(n^log₂3)
+
+ends up being T(n) = O(n^log₂3). Because the Karatsuba multiplication taking
+time O(n^log₂3) is itself doing 3 half-sized recursions, doing three for the
+division does not hurt the asymptotic performance. Of course, it is likely
+still faster in practice to do two.
+
+
+Proof of the Good Guess Guarantee
+
+Given numbers x, y, let us break them into the quotients and remainders when
+divided by some scaling factor S, with the added constraints that the quotient
+x/y and the high part of y are both less than some limit T, and that the high
+part of y is at least half as big as T.
+
+	x₁ = ⌊x/S⌋        y₁ = ⌊y/S⌋
+	x₀ = x mod S      y₀ = y mod S
+
+	x  = x₁·S + x₀    0 ≤ x₀ < S    x/y < T
+	y  = y₁·S + y₀    0 ≤ y₀ < S    T/2 ≤ y₁ < T
+
+And consider the two truncated quotients:
+
+	q = ⌊x/y⌋
+	q̂ = ⌊x₁/y₁⌋
+
+We will prove that q ≤ q̂ ≤ q+2.
+
+The guarantee makes no real demands on the scaling factor S: it is simply the
+magnitude of the digits cut from both x and y to produce x₁ and y₁.
+The guarantee makes only limited demands on T: it must be large enough to hold
+the quotient x/y, and y₁ must have roughly the same size.
+
+To apply to the earlier discussion of 2-by-1 guesses in long division,
+we would choose:
+
+	S  = Bⁿ⁻¹
+	T  = B
+	x  = u
+	x₁ = uₙuₙ₋₁
+	x₀ = uₙ₋₂...u₀
+	y  = v
+	y₁ = vₙ₋₁
+	y₀ = vₙ₋₂...u₀
+
+These simpler variables avoid repeating those longer expressions in the proof.
+
+Note also that, by definition, truncating division ⌊x/y⌋ satisfies
+
+	x/y - 1 < ⌊x/y⌋ ≤ x/y.
+
+This fact will be used a few times in the proofs.
+
+Proof that q ≤ q̂:
+
+	q̂·y₁ = ⌊x₁/y₁⌋·y₁                      [by definition, q̂ = ⌊x₁/y₁⌋]
+	     > (x₁/y₁ - 1)·y₁                  [x₁/y₁ - 1 < ⌊x₁/y₁⌋]
+	     = x₁ - y₁                         [distribute y₁]
+
+	So q̂·y₁ > x₁ - y₁.
+	Since q̂·y₁ is an integer, q̂·y₁ ≥ x₁ - y₁ + 1.
+
+	q̂ - q = q̂ - ⌊x/y⌋                      [by definition, q = ⌊x/y⌋]
+	      ≥ q̂ - x/y                        [⌊x/y⌋ < x/y]
+	      = (1/y)·(q̂·y - x)                [factor out 1/y]
+	      ≥ (1/y)·(q̂·y₁·S - x)             [y = y₁·S + y₀ ≥ y₁·S]
+	      ≥ (1/y)·((x₁ - y₁ + 1)·S - x)    [above: q̂·y₁ ≥ x₁ - y₁ + 1]
+	      = (1/y)·(x₁·S - y₁·S + S - x)    [distribute S]
+	      = (1/y)·(S - x₀ - y₁·S)          [-x = -x₁·S - x₀]
+	      > -y₁·S / y                      [x₀ < S, so S - x₀ < 0; drop it]
+	      ≥ -1                             [y₁·S ≤ y]
+
+	So q̂ - q > -1.
+	Since q̂ - q is an integer, q̂ - q ≥ 0, or equivalently q ≤ q̂.
+
+Proof that q̂ ≤ q+2:
+
+	x₁/y₁ - x/y = x₁·S/y₁·S - x/y          [multiply left term by S/S]
+	            ≤ x/y₁·S - x/y             [x₁S ≤ x]
+	            = (x/y)·(y/y₁·S - 1)       [factor out x/y]
+	            = (x/y)·((y - y₁·S)/y₁·S)  [move -1 into y/y₁·S fraction]
+	            = (x/y)·(y₀/y₁·S)          [y - y₁·S = y₀]
+	            = (x/y)·(1/y₁)·(y₀/S)      [factor out 1/y₁]
+	            < (x/y)·(1/y₁)             [y₀ < S, so y₀/S < 1]
+	            ≤ (x/y)·(2/T)              [y₁ ≥ T/2, so 1/y₁ ≤ 2/T]
+	            < T·(2/T)                  [x/y < T]
+	            = 2                        [T·(2/T) = 2]
+
+	So x₁/y₁ - x/y < 2.
+
+	q̂ - q = ⌊x₁/y₁⌋ - q                    [by definition, q̂ = ⌊x₁/y₁⌋]
+	      = ⌊x₁/y₁⌋ - ⌊x/y⌋                [by definition, q = ⌊x/y⌋]
+	      ≤ x₁/y₁ - ⌊x/y⌋                  [⌊x₁/y₁⌋ ≤ x₁/y₁]
+	      < x₁/y₁ - (x/y - 1)              [⌊x/y⌋ > x/y - 1]
+	      = (x₁/y₁ - x/y) + 1              [regrouping]
+	      < 2 + 1                          [above: x₁/y₁ - x/y < 2]
+	      = 3
+
+	So q̂ - q < 3.
+	Since q̂ - q is an integer, q̂ - q ≤ 2.
+
+Note that when x/y < T/2, the bounds tighten to x₁/y₁ - x/y < 1 and therefore
+q̂ - q ≤ 1.
+
+Note also that in the general case 2n-by-n division where we don't know that
+x/y < T, we do know that x/y < 2T, yielding the bound q̂ - q ≤ 4. So we could
+remove the special case first step of long division as long as we allow the
+first fixup loop to run up to four times. (Using a simple comparison to decide
+whether the first digit is 0 or 1 is still more efficient, though.)
+
+Finally, note that when dividing three leading base-B digits by two (scaled),
+we have T = B² and x/y < B = T/B, a much tighter bound than x/y < T.
+This in turn yields the much tighter bound x₁/y₁ - x/y < 2/B. This means that
+⌊x₁/y₁⌋ and ⌊x/y⌋ can only differ when x/y is less than 2/B greater than an
+integer. For random x and y, the chance of this is 2/B, or, for large B,
+approximately zero. This means that after we produce the 3-by-2 guess in the
+long division algorithm, the fixup loop essentially never runs.
+
+In the recursive algorithm, the extra digit in (2·⌊n/2⌋+1)-by-(⌊n/2⌋+1)-digit
+division has exactly the same effect: the probability of needing a fixup is the
+same 2/B. Even better, we can allow the general case x/y < 2T and the fixup
+probability only grows to 4/B, still essentially zero.
+
+
+References
+
+There are no great references for implementing long division; thus this comment.
+Here are some notes about what to expect from the obvious references.
+
+Knuth Volume 2 (Seminumerical Algorithms) section 4.3.1 is the usual canonical
+reference for long division, but that entire series is highly compressed, never
+repeating a necessary fact and leaving important insights to the exercises.
+For example, no rationale whatsoever is given for the calculation that extends
+q̂ from a 2-by-1 to a 3-by-2 guess, nor why it reduces the error bound.
+The proof that the calculation even has the desired effect is left to exercises.
+The solutions to those exercises provided at the back of the book are entirely
+calculations, still with no explanation as to what is going on or how you would
+arrive at the idea of doing those exact calculations. Nowhere is it mentioned
+that this test extends the 2-by-1 guess into a 3-by-2 guess. The proof of the
+Good Guess Guarantee is only for the 2-by-1 guess and argues by contradiction,
+making it difficult to understand how modifications like adding another digit
+or adjusting the quotient range affects the overall bound.
+
+All that said, Knuth remains the canonical reference. It is dense but packed
+full of information and references, and the proofs are simpler than many other
+presentations. The proofs above are reworkings of Knuth's to remove the
+arguments by contradiction and add explanations or steps that Knuth omitted.
+But beware of errors in older printings. Take the published errata with you.
+
+Brinch Hansen's “Multiple-length Division Revisited: a Tour of the Minefield”
+starts with a blunt critique of Knuth's presentation (among others) and then
+presents a more detailed and easier to follow treatment of long division,
+including an implementation in Pascal. But the algorithm and implementation
+work entirely in terms of 3-by-2 division, which is much less useful on modern
+hardware than an algorithm using 2-by-1 division. The proofs are a bit too
+focused on digit counting and seem needlessly complex, especially compared to
+the ones given above.
+
+Burnikel and Ziegler's “Fast Recursive Division” introduced the key insight of
+implementing division by an n-digit divisor using recursive calls to division
+by an n/2-digit divisor, relying on Karatsuba multiplication to yield a
+sub-quadratic run time. However, the presentation decisions are made almost
+entirely for the purpose of simplifying the run-time analysis, rather than
+simplifying the presentation. Instead of a single algorithm that loops over
+quotient digits, the paper presents two mutually-recursive algorithms, for
+2n-by-n and 3n-by-2n. The paper also does not present any general (n+m)-by-n
+algorithm.
+
+The proofs in the paper are remarkably complex, especially considering that
+the algorithm is at its core just long division on wide digits, so that the
+usual long division proofs apply essentially unaltered.
+*/
+
 package big
 
 import "math/bits"
 
+// div returns q, r such that q = ⌊u/v⌋ and r = u%v = u - q·v.
+// It uses z and z2 as the storage for q and r.
 func (z nat) div(z2, u, v nat) (q, r nat) {
 	if len(v) == 0 {
 		panic("division by zero")
@@ -18,6 +514,8 @@ func (z nat) div(z2, u, v nat) (q, r nat) {
 	}
 
 	if len(v) == 1 {
+		// Short division: long optimized for a single-word divisor.
+		// In that case, the 2-by-1 guess is all we need at each step.
 		var r2 Word
 		q, r2 = z.divW(u, v[0])
 		r = z2.setWord(r2)
@@ -28,7 +526,9 @@ func (z nat) div(z2, u, v nat) (q, r nat) {
 	return
 }
 
-// q = (x-r)/y, with 0 <= r < y
+// divW returns q, r such that q = ⌊x/y⌋ and r = x%y = x - q·y.
+// It uses z as the storage for q.
+// Note that y is a single digit (Word), not a big number.
 func (z nat) divW(x nat, y Word) (q nat, r Word) {
 	m := len(x)
 	switch {
@@ -56,6 +556,8 @@ func (x nat) modW(d Word) (r Word) {
 	return divWVW(q, 0, x, d)
 }
 
+// divWVW overwrites z with ⌊x/y⌋, returning the remainder r.
+// The caller must ensure that len(z) = len(x).
 func divWVW(z []Word, xn Word, x []Word, y Word) (r Word) {
 	r = xn
 	if len(x) == 1 {
@@ -70,34 +572,33 @@ func divWVW(z []Word, xn Word, x []Word, y Word) (r Word) {
 	return r
 }
 
-// q = (uIn-r)/vIn, with 0 <= r < vIn
-// Uses z as storage for q, and u as storage for r if possible.
-// See Knuth, Volume 2, section 4.3.1, Algorithm D.
-// Preconditions:
-//    len(vIn) >= 2
-//    len(uIn) >= len(vIn)
-//    u must not alias z
+// div returns q, r such that q = ⌊uIn/vIn⌋ and r = uIn%vIn = uIn - q·vIn.
+// It uses z and u as the storage for q and r.
+// The caller must ensure that len(vIn) ≥ 2 (use divW otherwise)
+// and that len(uIn) ≥ len(vIn) (the answer is 0, uIn otherwise).
 func (z nat) divLarge(u, uIn, vIn nat) (q, r nat) {
 	n := len(vIn)
 	m := len(uIn) - n
 
-	// D1.
+	// Scale the inputs so vIn's top bit is 1 (see “Scaling Inputs” above).
+	// vIn is treated as a read-only input (it may be in use by another
+	// goroutine), so we must make a copy.
+	// uIn is copied to u.
 	shift := nlz(vIn[n-1])
-	// do not modify vIn, it may be used by another goroutine simultaneously
 	vp := getNat(n)
 	v := *vp
 	shlVU(v, vIn, shift)
-
-	// u may safely alias uIn or vIn, the value of uIn is used to set u and vIn was already used
 	u = u.make(len(uIn) + 1)
 	u[len(uIn)] = shlVU(u[0:len(uIn)], uIn, shift)
 
-	// z may safely alias uIn or vIn, both values were used already
+	// The caller should not pass aliased z and u, since those are
+	// the two different outputs, but correct just in case.
 	if alias(z, u) {
-		z = nil // z is an alias for u - cannot reuse
+		z = nil
 	}
 	q = z.make(m + 1)
 
+	// Use basic or recursive long division depending on size.
 	if n < divRecursiveThreshold {
 		q.divBasic(u, v)
 	} else {
@@ -106,19 +607,17 @@ func (z nat) divLarge(u, uIn, vIn nat) (q, r nat) {
 	putNat(vp)
 
 	q = q.norm()
+
+	// Undo scaling of remainder.
 	shrVU(u, u, shift)
 	r = u.norm()
 
 	return q, r
 }
 
-// divBasic performs word-by-word division of u by v.
-// The quotient is written in pre-allocated q.
-// The remainder overwrites input u.
-//
-// Precondition:
-// - q is large enough to hold the quotient u / v
-//   which has a maximum length of len(u)-len(v)+1.
+// divBasic implements long division as described above.
+// It overwrites q with ⌊u/v⌋ and overwrites u with the remainder r.
+// q must be large enough to hold ⌊u/v⌋.
 func (q nat) divBasic(u, v nat) {
 	n := len(v)
 	m := len(u) - n
@@ -126,45 +625,56 @@ func (q nat) divBasic(u, v nat) {
 	qhatvp := getNat(n + 1)
 	qhatv := *qhatvp
 
-	// D2.
+	// Set up for divWW below, precomputing reciprocal argument.
 	vn1 := v[n-1]
 	rec := reciprocalWord(vn1)
+
+	// Compute each digit of quotient.
 	for j := m; j >= 0; j-- {
-		// D3.
+		// Compute the 2-by-1 guess q̂.
+		// The first iteration must invent a leading 0 for u.
 		qhat := Word(_M)
 		var ujn Word
 		if j+n < len(u) {
 			ujn = u[j+n]
 		}
+
+		// ujn ≤ vn1, or else q̂ would be more than one digit.
+		// For ujn == vn1, we set q̂ to the max digit M above.
+		// Otherwise, we compute the 2-by-1 guess.
 		if ujn != vn1 {
 			var rhat Word
 			qhat, rhat = divWW(ujn, u[j+n-1], vn1, rec)
 
-			// x1 | x2 = q̂v_{n-2}
+			// Refine q̂ to a 3-by-2 guess. See “Refining Guesses” above.
 			vn2 := v[n-2]
 			x1, x2 := mulWW(qhat, vn2)
-			// test if q̂v_{n-2} > br̂ + u_{j+n-2}
 			ujn2 := u[j+n-2]
-			for greaterThan(x1, x2, rhat, ujn2) {
+			for greaterThan(x1, x2, rhat, ujn2) { // x1x2 > r̂ u[j+n-2]
 				qhat--
 				prevRhat := rhat
 				rhat += vn1
-				// v[n-1] >= 0, so this tests for overflow.
+				// If r̂  overflows, then
+				// r̂ u[j+n-2]v[n-1] is now definitely > x1 x2.
 				if rhat < prevRhat {
 					break
 				}
+				// TODO(rsc): No need for a full mulWW.
+				// x2 += vn2; if x2 overflows, x1++
 				x1, x2 = mulWW(qhat, vn2)
 			}
 		}
 
-		// D4.
-		// Compute the remainder u - (q̂*v) << (_W*j).
-		// The subtraction may overflow if q̂ estimate was off by one.
+		// Compute q̂·v.
 		qhatv[n] = mulAddVWW(qhatv[0:n], v, qhat, 0)
 		qhl := len(qhatv)
 		if j+qhl > len(u) && qhatv[n] == 0 {
 			qhl--
 		}
+
+		// Subtract q̂·v from the current section of u.
+		// If it underflows, q̂·v > u, which we fix up
+		// by decrementing q̂ and adding v back.
 		c := subVV(u[j:j+qhl], u[j:], qhatv)
 		if c != 0 {
 			c := addVV(u[j:j+n], u[j:], v)
@@ -176,6 +686,8 @@ func (q nat) divBasic(u, v nat) {
 			qhat--
 		}
 
+		// Save quotient digit.
+		// Caller may know the top digit is zero and not leave room for it.
 		if j == m && m == len(q) && qhat == 0 {
 			continue
 		}
@@ -185,30 +697,34 @@ func (q nat) divBasic(u, v nat) {
 	putNat(qhatvp)
 }
 
-// greaterThan reports whether (x1<<_W + x2) > (y1<<_W + y2)
+// greaterThan reports whether the two digit numbers x1 x2 > y1 y2.
+// TODO(rsc): In contradiction to most of this file, x1 is the high
+// digit and x2 is the low digit. This should be fixed.
 func greaterThan(x1, x2, y1, y2 Word) bool {
 	return x1 > y1 || x1 == y1 && x2 > y2
 }
 
+// divRecursiveThreshold is the number of divisor digits
+// at which point divRecursive is faster than divBasic.
 const divRecursiveThreshold = 100
 
-// divRecursive performs word-by-word division of u by v.
-// The quotient is written in pre-allocated z.
-// The remainder overwrites input u.
-//
-// Precondition:
-// - len(z) >= len(u)-len(v)
-//
-// See Burnikel, Ziegler, "Fast Recursive Division", Algorithm 1 and 2.
+// divRecursive implements recursive division as described above.
+// It overwrites z with ⌊u/v⌋ and overwrites u with the remainder r.
+// z must be large enough to hold ⌊u/v⌋.
+// This function is just for allocating and freeing temporaries
+// around divRecursiveStep, the real implementation.
 func (z nat) divRecursive(u, v nat) {
-	// Recursion depth is less than 2 log2(len(v))
-	// Allocate a slice of temporaries to be reused across recursion.
+	// Recursion depth is (much) less than 2 log₂(len(v)).
+	// Allocate a slice of temporaries to be reused across recursion,
+	// plus one extra temporary not live across the recursion.
 	recDepth := 2 * bits.Len(uint(len(v)))
-	// large enough to perform Karatsuba on operands as large as v
 	tmp := getNat(3 * len(v))
 	temps := make([]*nat, recDepth)
+
 	z.clear()
 	z.divRecursiveStep(u, v, 0, tmp, temps)
+
+	// Free temporaries.
 	for _, n := range temps {
 		if n != nil {
 			putNat(n)
@@ -217,72 +733,92 @@ func (z nat) divRecursive(u, v nat) {
 	putNat(tmp)
 }
 
-// divRecursiveStep computes the division of u by v.
-// - z must be large enough to hold the quotient
-// - the quotient will overwrite z
-// - the remainder will overwrite u
+// divRecursiveStep is the actual implementation of recursive division.
+// It adds ⌊u/v⌋ to z and overwrites u with the remainder r.
+// z must be large enough to hold ⌊u/v⌋.
+// It uses temps[depth] (allocating if needed) as a temporary live across
+// the recursive call. It also uses tmp, but not live across the recursion.
 func (z nat) divRecursiveStep(u, v nat, depth int, tmp *nat, temps []*nat) {
+	// u is a subsection of the original and may have leading zeros.
+	// TODO(rsc): The v = v.norm() is useless and should be removed.
+	// We know (and require) that v's top digit is ≥ B/2.
 	u = u.norm()
 	v = v.norm()
-
 	if len(u) == 0 {
 		z.clear()
 		return
 	}
+
+	// Fall back to basic division if the problem is now small enough.
 	n := len(v)
 	if n < divRecursiveThreshold {
 		z.divBasic(u, v)
 		return
 	}
+
+	// Nothing to do if u is shorter than v (implies u < v).
 	m := len(u) - n
 	if m < 0 {
 		return
 	}
 
-	// Produce the quotient by blocks of B words.
-	// Division by v (length n) is done using a length n/2 division
-	// and a length n/2 multiplication for each block. The final
-	// complexity is driven by multiplication complexity.
+	// We consider B digits in a row as a single wide digit.
+	// (See “Recursive Division” above.)
+	//
+	// TODO(rsc): rename B to Wide, to avoid confusion with _B,
+	// which is something entirely different.
+	// TODO(rsc): Look into whether using ⌈n/2⌉ is better than ⌊n/2⌋.
 	B := n / 2
 
 	// Allocate a nat for qhat below.
 	if temps[depth] == nil {
-		temps[depth] = getNat(n)
+		temps[depth] = getNat(n) // TODO(rsc): Can be just B+1.
 	} else {
 		*temps[depth] = temps[depth].make(B + 1)
 	}
 
+	// Compute each wide digit of the quotient.
+	//
+	// TODO(rsc): Change the loop to be
+	//	for j := (m+B-1)/B*B; j > 0; j -= B {
+	// which will make the final step a regular step, letting us
+	// delete what amounts to an extra copy of the loop body below.
 	j := m
 	for j > B {
-		// Divide u[j-B:j+n] by vIn. Keep remainder in u
-		// for next block.
-		//
-		// The following property will be used (Lemma 2):
-		// if u = u1 << s + u0
-		//    v = v1 << s + v0
-		// then floor(u1/v1) >= floor(u/v)
+		// Divide u[j-B:j+n] (3 wide digits) by v (2 wide digits).
+		// First make the 2-by-1-wide-digit guess using a recursive call.
+		// Then extend the guess to the full 3-by-2 (see “Refining Guesses”).
 		//
-		// Moreover, the difference is at most 2 if len(v1) >= len(u/v)
-		// We choose s = B-1 since len(v)-s >= B+1 >= len(u/v)
+		// For the 2-by-1-wide-digit guess, instead of doing 2B-by-B-digit,
+		// we use a (2B+1)-by-(B+1) digit, which handles the possibility that
+		// the result has an extra leading 1 digit as well as guaranteeing
+		// that the computed q̂ will be off by at most 1 instead of 2.
+
+		// s is the number of digits to drop from the 3B- and 2B-digit chunks.
+		// We drop B-1 to be left with 2B+1 and B+1.
 		s := (B - 1)
-		// Except for the first step, the top bits are always
-		// a division remainder, so the quotient length is <= n.
+
+		// uu is the up-to-3B-digit section of u we are working on.
 		uu := u[j-B:]
 
+		// Compute the 2-by-1 guess q̂, leaving r̂ in uu[s:B+n].
 		qhat := *temps[depth]
 		qhat.clear()
 		qhat.divRecursiveStep(uu[s:B+n], v[s:], depth+1, tmp, temps)
 		qhat = qhat.norm()
-		// Adjust the quotient:
-		//    u = u_h << s + u_l
-		//    v = v_h << s + v_l
-		//  u_h = q̂ v_h + rh
-		//    u = q̂ (v - v_l) + rh << s + u_l
-		// After the above step, u contains a remainder:
-		//    u = rh << s + u_l
-		// and we need to subtract q̂ v_l
-		//
-		// But it may be a bit too large, in which case q̂ needs to be smaller.
+
+		// Extend to a 3-by-2 quotient and remainder.
+		// Because divRecursiveStep overwrote the top part of uu with
+		// the remainder r̂, the full uu already contains the equivalent
+		// of r̂·B + uₙ₋₂ from the “Refining Guesses” discussion.
+		// Subtracting q̂·vₙ₋₂ from it will compute the full-length remainder.
+		// If that subtraction underflows, q̂·v > u, which we fix up
+		// by decrementing q̂ and adding v back, same as in long division.
+
+		// TODO(rsc): Instead of subtract and fix-up, this code is computing
+		// q̂·vₙ₋₂ and decrementing q̂ until that product is ≤ u.
+		// But we can do the subtraction directly, as in the comment above
+		// and in long division, because we know that q̂ is wrong by at most one.
 		qhatv := tmp.make(3 * n)
 		qhatv.clear()
 		qhatv = qhatv.mul(qhat, v[:s])
@@ -309,6 +845,8 @@ func (z nat) divRecursiveStep(u, v nat, depth int, tmp *nat, temps []*nat) {
 		j -= B
 	}
 
+	// TODO(rsc): Rewrite loop as described above and delete all this code.
+
 	// Now u < (v<<B), compute lower bits in the same way.
 	// Choose shift = B-1 again.
 	s := B - 1
-- 
GitLab


From e6dda19888180c5159460486d30c0412e4980748 Mon Sep 17 00:00:00 2001
From: Katie Hockman <katie@golang.org>
Date: Mon, 7 Jun 2021 14:29:43 -0400
Subject: [PATCH 2205/2400] net/url: reject query values with semicolons

Semicolons are no longer valid separators, so
net/url.ParseQuery will now return an error
if any part of the query contains a semicolon.

net/http.(*Request).ParseMultipartForm has been
changed to fall through and continue parsing
even if the call to (*Request).ParseForm fails.

This change also includes a few minor refactors
to existing tests.

Fixes #25192

Change-Id: Iba3f108950fb99b9288e402c41fe71ca3a2ababd
Reviewed-on: https://go-review.googlesource.com/c/go/+/325697
Trust: Katie Hockman <katie@golang.org>
Run-TryBot: Katie Hockman <katie@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
---
 src/net/http/request.go      |  12 ++--
 src/net/http/request_test.go |  31 +++++++++-
 src/net/http/server.go       |   5 ++
 src/net/url/example_test.go  |   4 +-
 src/net/url/url.go           |  13 ++--
 src/net/url/url_test.go      | 116 +++++++++++++++++++++++++++--------
 6 files changed, 145 insertions(+), 36 deletions(-)

diff --git a/src/net/http/request.go b/src/net/http/request.go
index 7895417af5..09cb0c7f56 100644
--- a/src/net/http/request.go
+++ b/src/net/http/request.go
@@ -1293,16 +1293,18 @@ func (r *Request) ParseForm() error {
 // its file parts are stored in memory, with the remainder stored on
 // disk in temporary files.
 // ParseMultipartForm calls ParseForm if necessary.
+// If ParseForm returns an error, ParseMultipartForm returns it but also
+// continues parsing the request body.
 // After one call to ParseMultipartForm, subsequent calls have no effect.
 func (r *Request) ParseMultipartForm(maxMemory int64) error {
 	if r.MultipartForm == multipartByReader {
 		return errors.New("http: multipart handled by MultipartReader")
 	}
+	var parseFormErr error
 	if r.Form == nil {
-		err := r.ParseForm()
-		if err != nil {
-			return err
-		}
+		// Let errors in ParseForm fall through, and just
+		// return it at the end.
+		parseFormErr = r.ParseForm()
 	}
 	if r.MultipartForm != nil {
 		return nil
@@ -1329,7 +1331,7 @@ func (r *Request) ParseMultipartForm(maxMemory int64) error {
 
 	r.MultipartForm = f
 
-	return nil
+	return parseFormErr
 }
 
 // FormValue returns the first value for the named component of the query.
diff --git a/src/net/http/request_test.go b/src/net/http/request_test.go
index 952828b395..4e0c4ba207 100644
--- a/src/net/http/request_test.go
+++ b/src/net/http/request_test.go
@@ -32,9 +32,26 @@ func TestQuery(t *testing.T) {
 	}
 }
 
+// Issue #25192: Test that ParseForm fails but still parses the form when an URL
+// containing a semicolon is provided.
+func TestParseFormSemicolonSeparator(t *testing.T) {
+	for _, method := range []string{"POST", "PATCH", "PUT", "GET"} {
+		req, _ := NewRequest(method, "http://www.google.com/search?q=foo;q=bar&a=1",
+			strings.NewReader("q"))
+		err := req.ParseForm()
+		if err == nil {
+			t.Fatalf(`for method %s, ParseForm expected an error, got success`, method)
+		}
+		wantForm := url.Values{"a": []string{"1"}}
+		if !reflect.DeepEqual(req.Form, wantForm) {
+			t.Fatalf("for method %s, ParseForm expected req.Form = %v, want %v", method, req.Form, wantForm)
+		}
+	}
+}
+
 func TestParseFormQuery(t *testing.T) {
 	req, _ := NewRequest("POST", "http://www.google.com/search?q=foo&q=bar&both=x&prio=1&orphan=nope&empty=not",
-		strings.NewReader("z=post&both=y&prio=2&=nokey&orphan;empty=&"))
+		strings.NewReader("z=post&both=y&prio=2&=nokey&orphan&empty=&"))
 	req.Header.Set("Content-Type", "application/x-www-form-urlencoded; param=value")
 
 	if q := req.FormValue("q"); q != "foo" {
@@ -365,6 +382,18 @@ func TestMultipartRequest(t *testing.T) {
 	validateTestMultipartContents(t, req, false)
 }
 
+// Issue #25192: Test that ParseMultipartForm fails but still parses the
+// multi-part form when an URL containing a semicolon is provided.
+func TestParseMultipartFormSemicolonSeparator(t *testing.T) {
+	req := newTestMultipartRequest(t)
+	req.URL = &url.URL{RawQuery: "q=foo;q=bar"}
+	if err := req.ParseMultipartForm(25); err == nil {
+		t.Fatal("ParseMultipartForm expected error due to invalid semicolon, got nil")
+	}
+	defer req.MultipartForm.RemoveAll()
+	validateTestMultipartContents(t, req, false)
+}
+
 func TestMultipartRequestAuto(t *testing.T) {
 	// Test that FormValue and FormFile automatically invoke
 	// ParseMultipartForm and return the right values.
diff --git a/src/net/http/server.go b/src/net/http/server.go
index 430019de50..8a1847e67a 100644
--- a/src/net/http/server.go
+++ b/src/net/http/server.go
@@ -2863,6 +2863,11 @@ func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
 		handler = globalOptionsHandler{}
 	}
 	handler.ServeHTTP(rw, req)
+	if req.URL != nil && strings.Contains(req.URL.RawQuery, ";") {
+		// TODO(filippo): update this not to log if the special
+		// semicolon handler was called.
+		sh.srv.logf("http: URL query contains semicolon, which is no longer a supported separator; parts of the query may be stripped when parsed; see golang.org/issue/25192")
+	}
 }
 
 // ListenAndServe listens on the TCP network address srv.Addr and then
diff --git a/src/net/url/example_test.go b/src/net/url/example_test.go
index cb9e8922a2..476132a1c9 100644
--- a/src/net/url/example_test.go
+++ b/src/net/url/example_test.go
@@ -72,13 +72,13 @@ func ExampleURL_ResolveReference() {
 }
 
 func ExampleParseQuery() {
-	m, err := url.ParseQuery(`x=1&y=2&y=3;z`)
+	m, err := url.ParseQuery(`x=1&y=2&y=3`)
 	if err != nil {
 		log.Fatal(err)
 	}
 	fmt.Println(toJSON(m))
 	// Output:
-	// {"x":["1"], "y":["2", "3"], "z":[""]}
+	// {"x":["1"], "y":["2", "3"]}
 }
 
 func ExampleURL_EscapedPath() {
diff --git a/src/net/url/url.go b/src/net/url/url.go
index 73bef22e45..20de0f6f51 100644
--- a/src/net/url/url.go
+++ b/src/net/url/url.go
@@ -921,9 +921,10 @@ func (v Values) Has(key string) bool {
 // valid query parameters found; err describes the first decoding error
 // encountered, if any.
 //
-// Query is expected to be a list of key=value settings separated by
-// ampersands or semicolons. A setting without an equals sign is
-// interpreted as a key set to an empty value.
+// Query is expected to be a list of key=value settings separated by ampersands.
+// A setting without an equals sign is interpreted as a key set to an empty
+// value.
+// Settings containing a non-URL-encoded semicolon are considered invalid.
 func ParseQuery(query string) (Values, error) {
 	m := make(Values)
 	err := parseQuery(m, query)
@@ -933,11 +934,15 @@ func ParseQuery(query string) (Values, error) {
 func parseQuery(m Values, query string) (err error) {
 	for query != "" {
 		key := query
-		if i := strings.IndexAny(key, "&;"); i >= 0 {
+		if i := strings.IndexAny(key, "&"); i >= 0 {
 			key, query = key[:i], key[i+1:]
 		} else {
 			query = ""
 		}
+		if strings.Contains(key, ";") {
+			err = fmt.Errorf("invalid semicolon separator in query")
+			continue
+		}
 		if key == "" {
 			continue
 		}
diff --git a/src/net/url/url_test.go b/src/net/url/url_test.go
index 55348c4a7d..63c8e695af 100644
--- a/src/net/url/url_test.go
+++ b/src/net/url/url_test.go
@@ -1334,57 +1334,125 @@ func TestQueryValues(t *testing.T) {
 type parseTest struct {
 	query string
 	out   Values
+	ok    bool
 }
 
 var parseTests = []parseTest{
+	{
+		query: "a=1",
+		out:   Values{"a": []string{"1"}},
+		ok:    true,
+	},
 	{
 		query: "a=1&b=2",
 		out:   Values{"a": []string{"1"}, "b": []string{"2"}},
+		ok:    true,
 	},
 	{
 		query: "a=1&a=2&a=banana",
 		out:   Values{"a": []string{"1", "2", "banana"}},
+		ok:    true,
 	},
 	{
 		query: "ascii=%3Ckey%3A+0x90%3E",
 		out:   Values{"ascii": []string{"<key: 0x90>"}},
+		ok:    true,
+	}, {
+		query: "a=1;b=2",
+		out:   Values{},
+		ok:    false,
+	}, {
+		query: "a;b=1",
+		out:   Values{},
+		ok:    false,
+	}, {
+		query: "a=%3B", // hex encoding for semicolon
+		out:   Values{"a": []string{";"}},
+		ok:    true,
 	},
 	{
-		query: "a=1;b=2",
-		out:   Values{"a": []string{"1"}, "b": []string{"2"}},
+		query: "a%3Bb=1",
+		out:   Values{"a;b": []string{"1"}},
+		ok:    true,
 	},
 	{
 		query: "a=1&a=2;a=banana",
-		out:   Values{"a": []string{"1", "2", "banana"}},
+		out:   Values{"a": []string{"1"}},
+		ok:    false,
+	},
+	{
+		query: "a;b&c=1",
+		out:   Values{"c": []string{"1"}},
+		ok:    false,
+	},
+	{
+		query: "a=1&b=2;a=3&c=4",
+		out:   Values{"a": []string{"1"}, "c": []string{"4"}},
+		ok:    false,
+	},
+	{
+		query: "a=1&b=2;c=3",
+		out:   Values{"a": []string{"1"}},
+		ok:    false,
+	},
+	{
+		query: ";",
+		out:   Values{},
+		ok:    false,
+	},
+	{
+		query: "a=1;",
+		out:   Values{},
+		ok:    false,
+	},
+	{
+		query: "a=1&;",
+		out:   Values{"a": []string{"1"}},
+		ok:    false,
+	},
+	{
+		query: ";a=1&b=2",
+		out:   Values{"b": []string{"2"}},
+		ok:    false,
+	},
+	{
+		query: "a=1&b=2;",
+		out:   Values{"a": []string{"1"}},
+		ok:    false,
 	},
 }
 
 func TestParseQuery(t *testing.T) {
-	for i, test := range parseTests {
-		form, err := ParseQuery(test.query)
-		if err != nil {
-			t.Errorf("test %d: Unexpected error: %v", i, err)
-			continue
-		}
-		if len(form) != len(test.out) {
-			t.Errorf("test %d: len(form) = %d, want %d", i, len(form), len(test.out))
-		}
-		for k, evs := range test.out {
-			vs, ok := form[k]
-			if !ok {
-				t.Errorf("test %d: Missing key %q", i, k)
-				continue
+	for _, test := range parseTests {
+		t.Run(test.query, func(t *testing.T) {
+			form, err := ParseQuery(test.query)
+			if test.ok != (err == nil) {
+				want := "<error>"
+				if test.ok {
+					want = "<nil>"
+				}
+				t.Errorf("Unexpected error: %v, want %v", err, want)
 			}
-			if len(vs) != len(evs) {
-				t.Errorf("test %d: len(form[%q]) = %d, want %d", i, k, len(vs), len(evs))
-				continue
+			if len(form) != len(test.out) {
+				t.Errorf("len(form) = %d, want %d", len(form), len(test.out))
 			}
-			for j, ev := range evs {
-				if v := vs[j]; v != ev {
-					t.Errorf("test %d: form[%q][%d] = %q, want %q", i, k, j, v, ev)
+			for k, evs := range test.out {
+				vs, ok := form[k]
+				if !ok {
+					t.Errorf("Missing key %q", k)
+					continue
+				}
+				if len(vs) != len(evs) {
+					t.Errorf("len(form[%q]) = %d, want %d", k, len(vs), len(evs))
+					continue
+				}
+				for j, ev := range evs {
+					if v := vs[j]; v != ev {
+						t.Errorf("form[%q][%d] = %q, want %q", k, j, v, ev)
+					}
 				}
 			}
-		}
+		})
 	}
 }
 
-- 
GitLab


From ec3026d032be065fb26c5826b9abb7b6b806d7ef Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Wed, 9 Jun 2021 11:04:58 -0400
Subject: [PATCH 2206/2400] doc/go1.17: remove TODO for ports section

I'm not aware of anything more to mention for ports.

Change-Id: I686df8a230a55ad7f4c5eae43ca27f85fad9dd84
Reviewed-on: https://go-review.googlesource.com/c/go/+/326409
Trust: Cherry Mui <cherryyz@google.com>
Reviewed-by: Jeremy Faller <jeremy@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 doc/go1.17.html | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 011377a84e..2a56b6d270 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -120,10 +120,6 @@ Do not send CLs removing the interior tags from such phrases.
   stack frame pointers only on Linux, macOS, and iOS.
 </p>
 
-<p>
-  TODO: complete the Ports section
-</p>
-
 <h2 id="tools">Tools</h2>
 
 <h3 id="go-command">Go command</h3>
-- 
GitLab


From e4e7807d240eb62e1d4a73eec2706975c8cc847b Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Wed, 9 Jun 2021 07:43:57 -0400
Subject: [PATCH 2207/2400] net/http: add AllowQuerySemicolons

Fixes #45973

Change-Id: I6cbe05f5d1d3c324900c74314b0ea0e12524d7f2
Reviewed-on: https://go-review.googlesource.com/c/go/+/326309
Run-TryBot: Filippo Valsorda <filippo@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
Trust: Katie Hockman <katie@golang.org>
Trust: Filippo Valsorda <filippo@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/net/http/serve_test.go | 84 ++++++++++++++++++++++++++++++++++++++
 src/net/http/server.go     | 45 ++++++++++++++++++--
 2 files changed, 125 insertions(+), 4 deletions(-)

diff --git a/src/net/http/serve_test.go b/src/net/http/serve_test.go
index a9714682c7..c2f8811469 100644
--- a/src/net/http/serve_test.go
+++ b/src/net/http/serve_test.go
@@ -6524,3 +6524,87 @@ func TestMuxRedirectRelative(t *testing.T) {
 		t.Errorf("Expected response code %d; got %d", want, got)
 	}
 }
+
+// TestQuerySemicolon tests the behavior of semicolons in queries. See Issue 25192.
+func TestQuerySemicolon(t *testing.T) {
+	t.Cleanup(func() { afterTest(t) })
+
+	tests := []struct {
+		query           string
+		xNoSemicolons   string
+		xWithSemicolons string
+		warning         bool
+	}{
+		{"?a=1;x=bad&x=good", "good", "bad", true},
+		{"?a=1;b=bad&x=good", "good", "good", true},
+		{"?a=1%3Bx=bad&x=good%3B", "good;", "good;", false},
+		{"?a=1;x=good;x=bad", "", "good", true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.query+"/allow=false", func(t *testing.T) {
+			allowSemicolons := false
+			testQuerySemicolon(t, tt.query, tt.xNoSemicolons, allowSemicolons, tt.warning)
+		})
+		t.Run(tt.query+"/allow=true", func(t *testing.T) {
+			allowSemicolons, expectWarning := true, false
+			testQuerySemicolon(t, tt.query, tt.xWithSemicolons, allowSemicolons, expectWarning)
+		})
+	}
+}
+
+func testQuerySemicolon(t *testing.T, query string, wantX string, allowSemicolons, expectWarning bool) {
+	setParallel(t)
+
+	writeBackX := func(w ResponseWriter, r *Request) {
+		x := r.URL.Query().Get("x")
+		if expectWarning {
+			if err := r.ParseForm(); err == nil || !strings.Contains(err.Error(), "semicolon") {
+				t.Errorf("expected error mentioning semicolons from ParseForm, got %v", err)
+			}
+		} else {
+			if err := r.ParseForm(); err != nil {
+				t.Errorf("expected no error from ParseForm, got %v", err)
+			}
+		}
+		if got := r.FormValue("x"); x != got {
+			t.Errorf("got %q from FormValue, want %q", got, x)
+		}
+		fmt.Fprintf(w, "%s", x)
+	}
+
+	h := Handler(HandlerFunc(writeBackX))
+	if allowSemicolons {
+		h = AllowQuerySemicolons(h)
+	}
+
+	ts := httptest.NewUnstartedServer(h)
+	logBuf := &bytes.Buffer{}
+	ts.Config.ErrorLog = log.New(logBuf, "", 0)
+	ts.Start()
+	defer ts.Close()
+
+	req, _ := NewRequest("GET", ts.URL+query, nil)
+	res, err := ts.Client().Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	slurp, _ := io.ReadAll(res.Body)
+	res.Body.Close()
+	if got, want := res.StatusCode, 200; got != want {
+		t.Errorf("Status = %d; want = %d", got, want)
+	}
+	if got, want := string(slurp), wantX; got != want {
+		t.Errorf("Body = %q; want = %q", got, want)
+	}
+
+	if expectWarning {
+		if !strings.Contains(logBuf.String(), "semicolon") {
+			t.Errorf("got %q from ErrorLog, expected a mention of semicolons", logBuf.String())
+		}
+	} else {
+		if strings.Contains(logBuf.String(), "semicolon") {
+			t.Errorf("got %q from ErrorLog, expected no mention of semicolons", logBuf.String())
+		}
+	}
+}
diff --git a/src/net/http/server.go b/src/net/http/server.go
index 8a1847e67a..50fab4520d 100644
--- a/src/net/http/server.go
+++ b/src/net/http/server.go
@@ -2862,12 +2862,49 @@ func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
 	if req.RequestURI == "*" && req.Method == "OPTIONS" {
 		handler = globalOptionsHandler{}
 	}
-	handler.ServeHTTP(rw, req)
+
 	if req.URL != nil && strings.Contains(req.URL.RawQuery, ";") {
-		// TODO(filippo): update this not to log if the special
-		// semicolon handler was called.
-		sh.srv.logf("http: URL query contains semicolon, which is no longer a supported separator; parts of the query may be stripped when parsed; see golang.org/issue/25192")
+		var allowQuerySemicolonsInUse int32
+		req = req.WithContext(context.WithValue(req.Context(), silenceSemWarnContextKey, func() {
+			atomic.StoreInt32(&allowQuerySemicolonsInUse, 1)
+		}))
+		defer func() {
+			if atomic.LoadInt32(&allowQuerySemicolonsInUse) == 0 {
+				sh.srv.logf("http: URL query contains semicolon, which is no longer a supported separator; parts of the query may be stripped when parsed; see golang.org/issue/25192")
+			}
+		}()
 	}
+
+	handler.ServeHTTP(rw, req)
+}
+
+var silenceSemWarnContextKey = &contextKey{"silence-semicolons"}
+
+// AllowQuerySemicolons returns a handler that serves requests by converting any
+// unescaped semicolons in the URL query to ampersands, and invoking the handler h.
+//
+// This restores the pre-Go 1.17 behavior of splitting query parameters on both
+// semicolons and ampersands. (See golang.org/issue/25192). Note that this
+// behavior doesn't match that of many proxies, and the mismatch can lead to
+// security issues.
+//
+// AllowQuerySemicolons should be invoked before Request.ParseForm is called.
+func AllowQuerySemicolons(h Handler) Handler {
+	return HandlerFunc(func(w ResponseWriter, r *Request) {
+		if silenceSemicolonsWarning, ok := r.Context().Value(silenceSemWarnContextKey).(func()); ok {
+			silenceSemicolonsWarning()
+		}
+		if strings.Contains(r.URL.RawQuery, ";") {
+			r2 := new(Request)
+			*r2 = *r
+			r2.URL = new(url.URL)
+			*r2.URL = *r.URL
+			r2.URL.RawQuery = strings.ReplaceAll(r.URL.RawQuery, ";", "&")
+			h.ServeHTTP(w, r2)
+		} else {
+			h.ServeHTTP(w, r)
+		}
+	})
 }
 
 // ListenAndServe listens on the TCP network address srv.Addr and then
-- 
GitLab


From df35ade067f22ef1f3aad3c2f3576997ff9646b4 Mon Sep 17 00:00:00 2001
From: Heschi Kreinick <heschi@google.com>
Date: Tue, 8 Jun 2021 20:34:16 -0400
Subject: [PATCH 2208/2400] doc/go1.17: document //go:build lines

In 1.17, //go:build lines are fully supported. This entails changes to
the go command, vet, and gofmt. Document all of them.

I'm not Russ, but this is a significant change, it slipped under the
radar, and we're trying to get the release out. So here's what I got.

I wasn't sure where to put the go command change. On the one hand,
it's pretty significant. On the other, it certainly affects fewer
people than lazy loading. So it probably shouldn't be first, but I also
didn't want to bury it the middle of all the other module changes. Open
to suggestions.

Change-Id: Ia1a96bcfb1977973c5b0b0a6b18a9242a745af12
Reviewed-on: https://go-review.googlesource.com/c/go/+/326209
Trust: Heschi Kreinick <heschi@google.com>
Run-TryBot: Heschi Kreinick <heschi@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 doc/go1.17.html | 49 +++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 47 insertions(+), 2 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 2a56b6d270..6c53aaaa88 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -279,12 +279,41 @@ Do not send CLs removing the interior tags from such phrases.
   <code>mod</code> <code>download</code> <code>all</code>.
 </p>
 
+<h4 id="build-lines"><code>//go:build</code> lines</h4>
+
+<p>
+  The <code>go</code> command now understands <code>//go:build</code> lines
+  and prefers them over <code>// +build</code> lines. The new syntax uses
+  boolean expressions, just like Go, and should be less error-prone.
+  As of this release, the new syntax is fully supported, and all Go files
+  should be updated to have both forms with the same meaning. To aid in
+  migration, <a href="#gofmt"><code>gofmt</code></a> now automatically
+  synchronizes the two forms. For more details on the syntax and migration plan,
+  see
+  <a href="https://golang.org/design/draft-gobuild">https://golang.org/design/draft-gobuild</a>.
+</p>
+
+<h3 id="gofmt"><code>gofmt</code></h3>
+  <code>gofmt</code> (and <code>go</code> <code>fmt</code>) now synchronizes
+  <code>//go:build</code> lines with <code>// +build</code> lines. If a file
+  only has <code>// +build</code> lines, they will be moved to the appropriate
+  location in the file, and matching <code>//go:build</code> lines will be
+  added. Otherwise, <code>// +build</code> lines will be overwritten based on
+  any existing <code>//go:build</code> lines. For more information, see
+  <a href="https://golang.org/design/draft-gobuild">https://golang.org/design/draft-gobuild</a>.
+</h3>
+
 <h3 id="vet">Vet</h3>
 
-<h4 id="vet-buildtags">New warning within buildtags</h4>
+<h4 id="vet-buildtags">New warning for mismatched <code>//go:build</code> and <code>// +build</code> lines</h4>
 
 <p><!-- CL 240609 -->
-  TODO(rsc): Describe changes to buildtags <a href="https://golang.org/cl/240609">https://golang.org/cl/240609</a>
+  The <code>vet</code> tool now verifies that <code>//go:build</code> and
+  <code>// +build</code> lines are in the correct part of the file and
+  synchronized with each other. If they aren't,
+  <a href="#gofmt"><code>gofmt</code></a> can be used to fix them. For more
+  information, see
+  <a href="https://golang.org/design/draft-gobuild">https://golang.org/design/draft-gobuild</a>.
 </p>
 
 <h4 id="vet-sigchanyzer">New warning for calling <code>signal.Notify</code> on unbuffered channels</h4>
@@ -638,6 +667,22 @@ func Foo() bool {
   </dd>
 </dl><!-- go/build -->
 
+<dl id="go/format"><dt><a href="/pkg/go/format/">go/format</a></dt>
+  <dd>
+    <p>
+      The <a href="/pkg/go/format/#Source"><code>Source</code></a> and
+      <a href="/pkg/go/format/#Node"><code>Node</code></a> functions now
+      synchronize <code>//go:build</code> lines with <code>// +build</code>
+      lines. If a file only has <code>// +build</code> lines, they will be
+      moved to the appropriate location in the file, and matching
+      <code>//go:build</code> lines will be added. Otherwise,
+      <code>// +build</code> lines will be overwritten based on any existing
+      <code>//go:build</code> lines. For more information, see
+      <a href="https://golang.org/design/draft-gobuild">https://golang.org/design/draft-gobuild</a>.
+    </p>
+  </dd>
+</dl><!-- go/format -->
+
 <dl id="io/fs"><dt><a href="/pkg/io/fs/">io/fs</a></dt>
   <dd>
     <p><!-- CL 293649 -->
-- 
GitLab


From 1402b27d465d9949027a048ea2c86a3583400b4c Mon Sep 17 00:00:00 2001
From: Damien Neil <dneil@google.com>
Date: Mon, 7 Jun 2021 16:30:03 -0700
Subject: [PATCH 2209/2400] strconv: document parsing of leading +/-

Explicitly document the handling of a sign prefix, and the interaction
between the sign and base prefixes.

Fixes #46641.

Change-Id: I3cd6773e3f074fe671a944a05a79d2408137fcd4
Reviewed-on: https://go-review.googlesource.com/c/go/+/325875
Trust: Damien Neil <dneil@google.com>
Run-TryBot: Damien Neil <dneil@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Rob Pike <r@golang.org>
---
 src/strconv/atoi.go      | 11 ++++++++---
 src/strconv/atoi_test.go | 10 ++++++++++
 2 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/src/strconv/atoi.go b/src/strconv/atoi.go
index c9ba0383b3..631b487d97 100644
--- a/src/strconv/atoi.go
+++ b/src/strconv/atoi.go
@@ -57,6 +57,8 @@ const IntSize = intSize
 const maxUint64 = 1<<64 - 1
 
 // ParseUint is like ParseInt but for unsigned numbers.
+//
+// A sign prefix is not permitted.
 func ParseUint(s string, base int, bitSize int) (uint64, error) {
 	const fnParseUint = "ParseUint"
 
@@ -159,10 +161,13 @@ func ParseUint(s string, base int, bitSize int) (uint64, error) {
 // ParseInt interprets a string s in the given base (0, 2 to 36) and
 // bit size (0 to 64) and returns the corresponding value i.
 //
+// The string may begin with a leading sign: "+" or "-".
+//
 // If the base argument is 0, the true base is implied by the string's
-// prefix: 2 for "0b", 8 for "0" or "0o", 16 for "0x", and 10 otherwise.
-// Also, for argument base 0 only, underscore characters are permitted
-// as defined by the Go syntax for integer literals.
+// prefix following the sign (if present): 2 for "0b", 8 for "0" or "0o",
+// 16 for "0x", and 10 otherwise. Also, for argument base 0 only,
+// underscore characters are permitted as defined by the Go syntax for
+// integer literals.
 //
 // The bitSize argument specifies the integer type
 // that the result must fit into. Bit sizes 0, 8, 16, 32, and 64
diff --git a/src/strconv/atoi_test.go b/src/strconv/atoi_test.go
index 178fb01ea7..867fa66a14 100644
--- a/src/strconv/atoi_test.go
+++ b/src/strconv/atoi_test.go
@@ -33,6 +33,9 @@ var parseUint64Tests = []parseUint64Test{
 	{"_12345", 0, ErrSyntax},
 	{"1__2345", 0, ErrSyntax},
 	{"12345_", 0, ErrSyntax},
+	{"-0", 0, ErrSyntax},
+	{"-1", 0, ErrSyntax},
+	{"+1", 0, ErrSyntax},
 }
 
 type parseUint64BaseTest struct {
@@ -140,8 +143,10 @@ var parseInt64Tests = []parseInt64Test{
 	{"", 0, ErrSyntax},
 	{"0", 0, nil},
 	{"-0", 0, nil},
+	{"+0", 0, nil},
 	{"1", 1, nil},
 	{"-1", -1, nil},
+	{"+1", 1, nil},
 	{"12345", 12345, nil},
 	{"-12345", -12345, nil},
 	{"012345", 12345, nil},
@@ -236,6 +241,11 @@ var parseInt64BaseTests = []parseInt64BaseTest{
 	{"0__12345", 0, 0, ErrSyntax},
 	{"01234__5", 0, 0, ErrSyntax},
 	{"012345_", 0, 0, ErrSyntax},
+
+	{"+0xf", 0, 0xf, nil},
+	{"-0xf", 0, -0xf, nil},
+	{"0x+f", 0, 0, ErrSyntax},
+	{"0x-f", 0, 0, ErrSyntax},
 }
 
 type parseUint32Test struct {
-- 
GitLab


From a5bc060b42fe1bee8910a1081eff0a1047b15869 Mon Sep 17 00:00:00 2001
From: Damien Neil <dneil@google.com>
Date: Tue, 8 Jun 2021 14:26:13 -0700
Subject: [PATCH 2210/2400] doc/go1.17: document strconv changes for Go 1.17

For #44513.
Fixes #46021.

Change-Id: I40a4645fedfae24f67e249743c6a143e71b9f507
Reviewed-on: https://go-review.googlesource.com/c/go/+/326150
Trust: Damien Neil <dneil@google.com>
Run-TryBot: Damien Neil <dneil@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Heschi Kreinick <heschi@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 doc/go1.17.html | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 6c53aaaa88..988026f44d 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -838,12 +838,9 @@ func Foo() bool {
 
 <dl id="strconv"><dt><a href="/pkg/strconv/">strconv</a></dt>
   <dd>
-    <p><!-- CL 170079 -->
-      TODO: <a href="https://golang.org/cl/170079">https://golang.org/cl/170079</a>: implement Ryū-like algorithm for fixed precision ftoa
-    </p>
-
-    <p><!-- CL 170080 -->
-      TODO: <a href="https://golang.org/cl/170080">https://golang.org/cl/170080</a>: Implement Ryū algorithm for ftoa shortest mode
+    <p><!-- CL 170079, CL 170080 -->
+      The <code>strconv</code> package now uses Ulf Adams's Ryū algorithm for formatting floating-point numbers.
+      This algorithm improves performance on most inputs, and is more than 99% faster on worst-case inputs.
     </p>
 
     <p><!-- CL 314775 -->
-- 
GitLab


From 182157c81ad5a147ba13c6e80f844b2242598aed Mon Sep 17 00:00:00 2001
From: Heschi Kreinick <heschi@google.com>
Date: Wed, 9 Jun 2021 12:59:30 -0400
Subject: [PATCH 2211/2400] doc/go1.17: remove lingering TODO

As far as I can tell the Core Library section is complete. Remove its
TODO.

Change-Id: Ia84c6656fac045e25fae1a7ce8b488a3a26fd250
Reviewed-on: https://go-review.googlesource.com/c/go/+/326469
Trust: Heschi Kreinick <heschi@google.com>
Run-TryBot: Heschi Kreinick <heschi@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Damien Neil <dneil@google.com>
---
 doc/go1.17.html | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 988026f44d..49fbabdc3f 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -418,10 +418,6 @@ func Foo() bool {
 
 <h2 id="library">Core library</h2>
 
-<p>
-  TODO: complete the Core library section
-</p>
-
 <h3 id="runtime/cgo"><a href="/pkg/runtime/cgo">Cgo</a></h3>
 
 <p>
-- 
GitLab


From 27f83723e98d8e3795a07bdca2b3a8155b0d72b3 Mon Sep 17 00:00:00 2001
From: Heschi Kreinick <heschi@google.com>
Date: Wed, 9 Jun 2021 15:21:39 -0400
Subject: [PATCH 2212/2400] api: promote next to go1.17

Change-Id: If631878a2f6ec0317b4fad614f98ab102810ed47
Reviewed-on: https://go-review.googlesource.com/c/go/+/326410
Trust: Heschi Kreinick <heschi@google.com>
Run-TryBot: Heschi Kreinick <heschi@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 api/go1.17.txt | 159 +++++++++++++++++++++++++++++++++++++++++++++++++
 api/next.txt   |  99 ------------------------------
 2 files changed, 159 insertions(+), 99 deletions(-)
 create mode 100644 api/go1.17.txt

diff --git a/api/go1.17.txt b/api/go1.17.txt
new file mode 100644
index 0000000000..f054458715
--- /dev/null
+++ b/api/go1.17.txt
@@ -0,0 +1,159 @@
+pkg archive/zip, method (*File) OpenRaw() (io.Reader, error)
+pkg archive/zip, method (*Writer) Copy(*File) error
+pkg archive/zip, method (*Writer) CreateRaw(*FileHeader) (io.Writer, error)
+pkg compress/lzw, method (*Reader) Close() error
+pkg compress/lzw, method (*Reader) Read([]uint8) (int, error)
+pkg compress/lzw, method (*Reader) Reset(io.Reader, Order, int)
+pkg compress/lzw, method (*Writer) Close() error
+pkg compress/lzw, method (*Writer) Reset(io.Writer, Order, int)
+pkg compress/lzw, method (*Writer) Write([]uint8) (int, error)
+pkg compress/lzw, type Reader struct
+pkg compress/lzw, type Writer struct
+pkg crypto/tls, method (*CertificateRequestInfo) Context() context.Context
+pkg crypto/tls, method (*ClientHelloInfo) Context() context.Context
+pkg crypto/tls, method (*Conn) HandshakeContext(context.Context) error
+pkg database/sql, method (*NullByte) Scan(interface{}) error
+pkg database/sql, method (*NullInt16) Scan(interface{}) error
+pkg database/sql, method (NullByte) Value() (driver.Value, error)
+pkg database/sql, method (NullInt16) Value() (driver.Value, error)
+pkg database/sql, type NullByte struct
+pkg database/sql, type NullByte struct, Byte uint8
+pkg database/sql, type NullByte struct, Valid bool
+pkg database/sql, type NullInt16 struct
+pkg database/sql, type NullInt16 struct, Int16 int16
+pkg database/sql, type NullInt16 struct, Valid bool
+pkg debug/elf, const SHT_MIPS_ABIFLAGS = 1879048234
+pkg debug/elf, const SHT_MIPS_ABIFLAGS SectionType
+pkg encoding/csv, method (*Reader) FieldPos(int) (int, int)
+pkg go/build, type Context struct, ToolTags []string
+pkg go/parser, const SkipObjectResolution = 64
+pkg go/parser, const SkipObjectResolution Mode
+pkg io/fs, func FileInfoToDirEntry(FileInfo) DirEntry
+pkg math, const MaxFloat64 = 1.79769e+308  // 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368
+pkg math, const MaxInt = 9223372036854775807
+pkg math, const MaxInt ideal-int
+pkg math, const MaxUint = 18446744073709551615
+pkg math, const MaxUint ideal-int
+pkg math, const MinInt = -9223372036854775808
+pkg math, const MinInt ideal-int
+pkg math, const SmallestNonzeroFloat32 = 1.4013e-45  // 1/713623846352979940529142984724747568191373312
+pkg math, const SmallestNonzeroFloat64 = 4.94066e-324  // 1/202402253307310618352495346718917307049556649764142118356901358027430339567995346891960383701437124495187077864316811911389808737385793476867013399940738509921517424276566361364466907742093216341239767678472745068562007483424692698618103355649159556340810056512358769552333414615230502532186327508646006263307707741093494784
+pkg net, method (*ParseError) Temporary() bool
+pkg net, method (*ParseError) Timeout() bool
+pkg net, method (IP) IsPrivate() bool
+pkg net/http, func AllowQuerySemicolons(Handler) Handler
+pkg net/url, method (Values) Has(string) bool
+pkg reflect, func VisibleFields(Type) []StructField
+pkg reflect, method (Method) IsExported() bool
+pkg reflect, method (StructField) IsExported() bool
+pkg runtime/cgo (darwin-amd64-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (darwin-amd64-cgo), method (Handle) Delete()
+pkg runtime/cgo (darwin-amd64-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (darwin-amd64-cgo), type Handle uintptr
+pkg runtime/cgo (freebsd-386-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (freebsd-386-cgo), method (Handle) Delete()
+pkg runtime/cgo (freebsd-386-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (freebsd-386-cgo), type Handle uintptr
+pkg runtime/cgo (freebsd-amd64-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (freebsd-amd64-cgo), method (Handle) Delete()
+pkg runtime/cgo (freebsd-amd64-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (freebsd-amd64-cgo), type Handle uintptr
+pkg runtime/cgo (freebsd-arm-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (freebsd-arm-cgo), method (Handle) Delete()
+pkg runtime/cgo (freebsd-arm-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (freebsd-arm-cgo), type Handle uintptr
+pkg runtime/cgo (linux-386-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (linux-386-cgo), method (Handle) Delete()
+pkg runtime/cgo (linux-386-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (linux-386-cgo), type Handle uintptr
+pkg runtime/cgo (linux-amd64-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (linux-amd64-cgo), method (Handle) Delete()
+pkg runtime/cgo (linux-amd64-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (linux-amd64-cgo), type Handle uintptr
+pkg runtime/cgo (linux-arm-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (linux-arm-cgo), method (Handle) Delete()
+pkg runtime/cgo (linux-arm-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (linux-arm-cgo), type Handle uintptr
+pkg runtime/cgo (netbsd-386-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (netbsd-386-cgo), method (Handle) Delete()
+pkg runtime/cgo (netbsd-386-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (netbsd-386-cgo), type Handle uintptr
+pkg runtime/cgo (netbsd-amd64-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (netbsd-amd64-cgo), method (Handle) Delete()
+pkg runtime/cgo (netbsd-amd64-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (netbsd-amd64-cgo), type Handle uintptr
+pkg runtime/cgo (netbsd-arm-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (netbsd-arm-cgo), method (Handle) Delete()
+pkg runtime/cgo (netbsd-arm-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (netbsd-arm-cgo), type Handle uintptr
+pkg runtime/cgo (netbsd-arm64-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (netbsd-arm64-cgo), method (Handle) Delete()
+pkg runtime/cgo (netbsd-arm64-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (netbsd-arm64-cgo), type Handle uintptr
+pkg runtime/cgo (openbsd-386-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (openbsd-386-cgo), method (Handle) Delete()
+pkg runtime/cgo (openbsd-386-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (openbsd-386-cgo), type Handle uintptr
+pkg runtime/cgo (openbsd-amd64-cgo), func NewHandle(interface{}) Handle
+pkg runtime/cgo (openbsd-amd64-cgo), method (Handle) Delete()
+pkg runtime/cgo (openbsd-amd64-cgo), method (Handle) Value() interface{}
+pkg runtime/cgo (openbsd-amd64-cgo), type Handle uintptr
+pkg strconv, func QuotedPrefix(string) (string, error)
+pkg sync/atomic, method (*Value) CompareAndSwap(interface{}, interface{}) bool
+pkg sync/atomic, method (*Value) Swap(interface{}) interface{}
+pkg syscall (netbsd-386), const SYS_WAIT6 = 481
+pkg syscall (netbsd-386), const SYS_WAIT6 ideal-int
+pkg syscall (netbsd-386), const WEXITED = 32
+pkg syscall (netbsd-386), const WEXITED ideal-int
+pkg syscall (netbsd-386-cgo), const SYS_WAIT6 = 481
+pkg syscall (netbsd-386-cgo), const SYS_WAIT6 ideal-int
+pkg syscall (netbsd-386-cgo), const WEXITED = 32
+pkg syscall (netbsd-386-cgo), const WEXITED ideal-int
+pkg syscall (netbsd-amd64), const SYS_WAIT6 = 481
+pkg syscall (netbsd-amd64), const SYS_WAIT6 ideal-int
+pkg syscall (netbsd-amd64), const WEXITED = 32
+pkg syscall (netbsd-amd64), const WEXITED ideal-int
+pkg syscall (netbsd-amd64-cgo), const SYS_WAIT6 = 481
+pkg syscall (netbsd-amd64-cgo), const SYS_WAIT6 ideal-int
+pkg syscall (netbsd-amd64-cgo), const WEXITED = 32
+pkg syscall (netbsd-amd64-cgo), const WEXITED ideal-int
+pkg syscall (netbsd-arm), const SYS_WAIT6 = 481
+pkg syscall (netbsd-arm), const SYS_WAIT6 ideal-int
+pkg syscall (netbsd-arm), const WEXITED = 32
+pkg syscall (netbsd-arm), const WEXITED ideal-int
+pkg syscall (netbsd-arm-cgo), const SYS_WAIT6 = 481
+pkg syscall (netbsd-arm-cgo), const SYS_WAIT6 ideal-int
+pkg syscall (netbsd-arm-cgo), const WEXITED = 32
+pkg syscall (netbsd-arm-cgo), const WEXITED ideal-int
+pkg syscall (netbsd-arm64), const SYS_WAIT6 = 481
+pkg syscall (netbsd-arm64), const SYS_WAIT6 ideal-int
+pkg syscall (netbsd-arm64), const WEXITED = 32
+pkg syscall (netbsd-arm64), const WEXITED ideal-int
+pkg syscall (netbsd-arm64-cgo), const SYS_WAIT6 = 481
+pkg syscall (netbsd-arm64-cgo), const SYS_WAIT6 ideal-int
+pkg syscall (netbsd-arm64-cgo), const WEXITED = 32
+pkg syscall (netbsd-arm64-cgo), const WEXITED ideal-int
+pkg syscall (openbsd-386), const MSG_CMSG_CLOEXEC = 2048
+pkg syscall (openbsd-386), const MSG_CMSG_CLOEXEC ideal-int
+pkg syscall (openbsd-386-cgo), const MSG_CMSG_CLOEXEC = 2048
+pkg syscall (openbsd-386-cgo), const MSG_CMSG_CLOEXEC ideal-int
+pkg syscall (openbsd-amd64), const MSG_CMSG_CLOEXEC = 2048
+pkg syscall (openbsd-amd64), const MSG_CMSG_CLOEXEC ideal-int
+pkg syscall (openbsd-amd64-cgo), const MSG_CMSG_CLOEXEC = 2048
+pkg syscall (openbsd-amd64-cgo), const MSG_CMSG_CLOEXEC ideal-int
+pkg syscall (windows-386), type SysProcAttr struct, AdditionalInheritedHandles []Handle
+pkg syscall (windows-386), type SysProcAttr struct, ParentProcess Handle
+pkg syscall (windows-amd64), type SysProcAttr struct, AdditionalInheritedHandles []Handle
+pkg syscall (windows-amd64), type SysProcAttr struct, ParentProcess Handle
+pkg testing, method (*B) Setenv(string, string)
+pkg testing, method (*T) Setenv(string, string)
+pkg text/template/parse, const SkipFuncCheck = 2
+pkg text/template/parse, const SkipFuncCheck Mode
+pkg time, const Layout = "01/02 03:04:05PM '06 -0700"
+pkg time, const Layout ideal-string
+pkg time, func UnixMicro(int64) Time
+pkg time, func UnixMilli(int64) Time
+pkg time, method (*Time) IsDST() bool
+pkg time, method (Time) GoString() string
+pkg time, method (Time) UnixMicro() int64
+pkg time, method (Time) UnixMilli() int64
diff --git a/api/next.txt b/api/next.txt
index 9e996005c6..e69de29bb2 100644
--- a/api/next.txt
+++ b/api/next.txt
@@ -1,99 +0,0 @@
-pkg compress/lzw, method (*Reader) Close() error
-pkg compress/lzw, method (*Reader) Read([]uint8) (int, error)
-pkg compress/lzw, method (*Reader) Reset(io.Reader, Order, int)
-pkg compress/lzw, method (*Writer) Close() error
-pkg compress/lzw, method (*Writer) Reset(io.Writer, Order, int)
-pkg compress/lzw, method (*Writer) Write([]uint8) (int, error)
-pkg compress/lzw, type Reader struct
-pkg compress/lzw, type Writer struct
-pkg crypto/tls, method (*CertificateRequestInfo) Context() context.Context
-pkg crypto/tls, method (*ClientHelloInfo) Context() context.Context
-pkg crypto/tls, method (*Conn) HandshakeContext(context.Context) error
-pkg debug/elf, const SHT_MIPS_ABIFLAGS = 1879048234
-pkg debug/elf, const SHT_MIPS_ABIFLAGS SectionType
-pkg encoding/csv, method (*Reader) FieldPos(int) (int, int)
-pkg go/ast, method (*FuncDecl) IsMethod() bool
-pkg go/build, type Context struct, ToolTags []string
-pkg go/parser, const SkipObjectResolution = 64
-pkg go/parser, const SkipObjectResolution Mode
-pkg go/types, type Config struct, GoVersion string
-pkg io/fs, func FileInfoToDirEntry(FileInfo) DirEntry
-pkg net, method (*ParseError) Temporary() bool
-pkg net, method (*ParseError) Timeout() bool
-pkg net, method (IP) IsPrivate() bool
-pkg reflect, func VisibleFields(Type) []StructField
-pkg reflect, method (Method) IsExported() bool
-pkg reflect, method (StructField) IsExported() bool
-pkg runtime/cgo (darwin-amd64-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (darwin-amd64-cgo), method (Handle) Delete()
-pkg runtime/cgo (darwin-amd64-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (darwin-amd64-cgo), type Handle uintptr
-pkg runtime/cgo (freebsd-386-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (freebsd-386-cgo), method (Handle) Delete()
-pkg runtime/cgo (freebsd-386-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (freebsd-386-cgo), type Handle uintptr
-pkg runtime/cgo (freebsd-amd64-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (freebsd-amd64-cgo), method (Handle) Delete()
-pkg runtime/cgo (freebsd-amd64-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (freebsd-amd64-cgo), type Handle uintptr
-pkg runtime/cgo (freebsd-arm-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (freebsd-arm-cgo), method (Handle) Delete()
-pkg runtime/cgo (freebsd-arm-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (freebsd-arm-cgo), type Handle uintptr
-pkg runtime/cgo (linux-386-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (linux-386-cgo), method (Handle) Delete()
-pkg runtime/cgo (linux-386-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (linux-386-cgo), type Handle uintptr
-pkg runtime/cgo (linux-amd64-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (linux-amd64-cgo), method (Handle) Delete()
-pkg runtime/cgo (linux-amd64-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (linux-amd64-cgo), type Handle uintptr
-pkg runtime/cgo (linux-arm-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (linux-arm-cgo), method (Handle) Delete()
-pkg runtime/cgo (linux-arm-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (linux-arm-cgo), type Handle uintptr
-pkg runtime/cgo (netbsd-386-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (netbsd-386-cgo), method (Handle) Delete()
-pkg runtime/cgo (netbsd-386-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (netbsd-386-cgo), type Handle uintptr
-pkg runtime/cgo (netbsd-amd64-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (netbsd-amd64-cgo), method (Handle) Delete()
-pkg runtime/cgo (netbsd-amd64-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (netbsd-amd64-cgo), type Handle uintptr
-pkg runtime/cgo (netbsd-arm-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (netbsd-arm-cgo), method (Handle) Delete()
-pkg runtime/cgo (netbsd-arm-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (netbsd-arm-cgo), type Handle uintptr
-pkg runtime/cgo (netbsd-arm64-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (netbsd-arm64-cgo), method (Handle) Delete()
-pkg runtime/cgo (netbsd-arm64-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (netbsd-arm64-cgo), type Handle uintptr
-pkg runtime/cgo (openbsd-386-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (openbsd-386-cgo), method (Handle) Delete()
-pkg runtime/cgo (openbsd-386-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (openbsd-386-cgo), type Handle uintptr
-pkg runtime/cgo (openbsd-amd64-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (openbsd-amd64-cgo), method (Handle) Delete()
-pkg runtime/cgo (openbsd-amd64-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (openbsd-amd64-cgo), type Handle uintptr
-pkg syscall (openbsd-386), const MSG_CMSG_CLOEXEC = 2048
-pkg syscall (openbsd-386), const MSG_CMSG_CLOEXEC ideal-int
-pkg syscall (openbsd-386-cgo), const MSG_CMSG_CLOEXEC = 2048
-pkg syscall (openbsd-386-cgo), const MSG_CMSG_CLOEXEC ideal-int
-pkg syscall (openbsd-amd64), const MSG_CMSG_CLOEXEC = 2048
-pkg syscall (openbsd-amd64), const MSG_CMSG_CLOEXEC ideal-int
-pkg syscall (openbsd-amd64-cgo), const MSG_CMSG_CLOEXEC = 2048
-pkg syscall (openbsd-amd64-cgo), const MSG_CMSG_CLOEXEC ideal-int
-pkg syscall (windows-386), type SysProcAttr struct, AdditionalInheritedHandles []Handle
-pkg syscall (windows-386), type SysProcAttr struct, ParentProcess Handle
-pkg syscall (windows-amd64), type SysProcAttr struct, AdditionalInheritedHandles []Handle
-pkg syscall (windows-amd64), type SysProcAttr struct, ParentProcess Handle
-pkg testing, method (*B) Setenv(string, string)
-pkg testing, method (*T) Setenv(string, string)
-pkg text/template/parse, const SkipFuncCheck = 2
-pkg text/template/parse, const SkipFuncCheck Mode
-pkg time, func UnixMicro(int64) Time
-pkg time, func UnixMilli(int64) Time
-pkg time, method (*Time) IsDST() bool
-pkg time, method (Time) UnixMicro() int64
-pkg time, method (Time) UnixMilli() int64
-- 
GitLab


From dc00dc6c6bf3b5554e37f60799aec092276ff807 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Mon, 7 Jun 2021 08:24:22 -0400
Subject: [PATCH 2213/2400] crypto/tls: let HTTP/1.1 clients connect to servers
 with NextProtos "h2"

Fixes #46310

Change-Id: Idd5e30f05c439f736ae6f3904cbb9cc2ba772315
Reviewed-on: https://go-review.googlesource.com/c/go/+/325432
Trust: Filippo Valsorda <filippo@golang.org>
Run-TryBot: Filippo Valsorda <filippo@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Roland Shoemaker <roland@golang.org>
---
 src/crypto/tls/handshake_client.go            |  44 ++++----
 src/crypto/tls/handshake_client_tls13.go      |  14 +--
 src/crypto/tls/handshake_server.go            |  42 ++++++--
 src/crypto/tls/handshake_server_test.go       |  21 ++++
 src/crypto/tls/handshake_server_tls13.go      |  15 ++-
 .../tls/testdata/Server-TLSv12-ALPN-Fallback  |  91 ++++++++++++++++
 .../tls/testdata/Server-TLSv13-ALPN-Fallback  | 100 ++++++++++++++++++
 7 files changed, 277 insertions(+), 50 deletions(-)
 create mode 100644 src/crypto/tls/testdata/Server-TLSv12-ALPN-Fallback
 create mode 100644 src/crypto/tls/testdata/Server-TLSv13-ALPN-Fallback

diff --git a/src/crypto/tls/handshake_client.go b/src/crypto/tls/handshake_client.go
index 13a7f3442c..4af3d998a3 100644
--- a/src/crypto/tls/handshake_client.go
+++ b/src/crypto/tls/handshake_client.go
@@ -711,17 +711,11 @@ func (hs *clientHandshakeState) processServerHello() (bool, error) {
 		}
 	}
 
-	if hs.serverHello.alpnProtocol != "" {
-		if len(hs.hello.alpnProtocols) == 0 {
-			c.sendAlert(alertUnsupportedExtension)
-			return false, errors.New("tls: server advertised unrequested ALPN extension")
-		}
-		if mutualProtocol([]string{hs.serverHello.alpnProtocol}, hs.hello.alpnProtocols) == "" {
-			c.sendAlert(alertUnsupportedExtension)
-			return false, errors.New("tls: server selected unadvertised ALPN protocol")
-		}
-		c.clientProtocol = hs.serverHello.alpnProtocol
+	if err := checkALPN(hs.hello.alpnProtocols, hs.serverHello.alpnProtocol); err != nil {
+		c.sendAlert(alertUnsupportedExtension)
+		return false, err
 	}
+	c.clientProtocol = hs.serverHello.alpnProtocol
 
 	c.scts = hs.serverHello.scts
 
@@ -753,6 +747,23 @@ func (hs *clientHandshakeState) processServerHello() (bool, error) {
 	return true, nil
 }
 
+// checkALPN ensure that the server's choice of ALPN protocol is compatible with
+// the protocols that we advertised in the Client Hello.
+func checkALPN(clientProtos []string, serverProto string) error {
+	if serverProto == "" {
+		return nil
+	}
+	if len(clientProtos) == 0 {
+		return errors.New("tls: server advertised unrequested ALPN extension")
+	}
+	for _, proto := range clientProtos {
+		if proto == serverProto {
+			return nil
+		}
+	}
+	return errors.New("tls: server selected unadvertised ALPN protocol")
+}
+
 func (hs *clientHandshakeState) readFinished(out []byte) error {
 	c := hs.c
 
@@ -979,19 +990,6 @@ func clientSessionCacheKey(serverAddr net.Addr, config *Config) string {
 	return serverAddr.String()
 }
 
-// mutualProtocol finds the mutual ALPN protocol given list of possible
-// protocols and a list of the preference order.
-func mutualProtocol(protos, preferenceProtos []string) string {
-	for _, s := range preferenceProtos {
-		for _, c := range protos {
-			if s == c {
-				return s
-			}
-		}
-	}
-	return ""
-}
-
 // hostnameInSNI converts name into an appropriate hostname for SNI.
 // Literal IP addresses and absolute FQDNs are not permitted as SNI values.
 // See RFC 6066, Section 3.
diff --git a/src/crypto/tls/handshake_client_tls13.go b/src/crypto/tls/handshake_client_tls13.go
index be37c681c6..eb59ac90d1 100644
--- a/src/crypto/tls/handshake_client_tls13.go
+++ b/src/crypto/tls/handshake_client_tls13.go
@@ -396,17 +396,11 @@ func (hs *clientHandshakeStateTLS13) readServerParameters() error {
 	}
 	hs.transcript.Write(encryptedExtensions.marshal())
 
-	if encryptedExtensions.alpnProtocol != "" {
-		if len(hs.hello.alpnProtocols) == 0 {
-			c.sendAlert(alertUnsupportedExtension)
-			return errors.New("tls: server advertised unrequested ALPN extension")
-		}
-		if mutualProtocol([]string{encryptedExtensions.alpnProtocol}, hs.hello.alpnProtocols) == "" {
-			c.sendAlert(alertUnsupportedExtension)
-			return errors.New("tls: server selected unadvertised ALPN protocol")
-		}
-		c.clientProtocol = encryptedExtensions.alpnProtocol
+	if err := checkALPN(hs.hello.alpnProtocols, encryptedExtensions.alpnProtocol); err != nil {
+		c.sendAlert(alertUnsupportedExtension)
+		return err
 	}
+	c.clientProtocol = encryptedExtensions.alpnProtocol
 
 	return nil
 }
diff --git a/src/crypto/tls/handshake_server.go b/src/crypto/tls/handshake_server.go
index b231981e09..43f30e2fef 100644
--- a/src/crypto/tls/handshake_server.go
+++ b/src/crypto/tls/handshake_server.go
@@ -217,15 +217,13 @@ func (hs *serverHandshakeState) processClientHello() error {
 		c.serverName = hs.clientHello.serverName
 	}
 
-	if len(c.config.NextProtos) > 0 && len(hs.clientHello.alpnProtocols) > 0 {
-		selectedProto := mutualProtocol(hs.clientHello.alpnProtocols, c.config.NextProtos)
-		if selectedProto == "" {
-			c.sendAlert(alertNoApplicationProtocol)
-			return fmt.Errorf("tls: client requested unsupported application protocols (%s)", hs.clientHello.alpnProtocols)
-		}
-		hs.hello.alpnProtocol = selectedProto
-		c.clientProtocol = selectedProto
+	selectedProto, err := negotiateALPN(c.config.NextProtos, hs.clientHello.alpnProtocols)
+	if err != nil {
+		c.sendAlert(alertNoApplicationProtocol)
+		return err
 	}
+	hs.hello.alpnProtocol = selectedProto
+	c.clientProtocol = selectedProto
 
 	hs.cert, err = c.config.getCertificate(clientHelloInfo(hs.ctx, c, hs.clientHello))
 	if err != nil {
@@ -277,6 +275,34 @@ func (hs *serverHandshakeState) processClientHello() error {
 	return nil
 }
 
+// negotiateALPN picks a shared ALPN protocol that both sides support in server
+// preference order. If ALPN is not configured or the peer doesn't support it,
+// it returns "" and no error.
+func negotiateALPN(serverProtos, clientProtos []string) (string, error) {
+	if len(serverProtos) == 0 || len(clientProtos) == 0 {
+		return "", nil
+	}
+	var http11fallback bool
+	for _, s := range serverProtos {
+		for _, c := range clientProtos {
+			if s == c {
+				return s, nil
+			}
+			if s == "h2" && c == "http/1.1" {
+				http11fallback = true
+			}
+		}
+	}
+	// As a special case, let http/1.1 clients connect to h2 servers as if they
+	// didn't support ALPN. We used not to enforce protocol overlap, so over
+	// time a number of HTTP servers were configured with only "h2", but
+	// expected to accept connections from "http/1.1" clients. See Issue 46310.
+	if http11fallback {
+		return "", nil
+	}
+	return "", fmt.Errorf("tls: client requested unsupported application protocols (%s)", clientProtos)
+}
+
 // supportsECDHE returns whether ECDHE key exchanges can be used with this
 // pre-TLS 1.3 client.
 func supportsECDHE(c *Config, supportedCurves []CurveID, supportedPoints []uint8) bool {
diff --git a/src/crypto/tls/handshake_server_test.go b/src/crypto/tls/handshake_server_test.go
index 4483838045..f61b4c88ef 100644
--- a/src/crypto/tls/handshake_server_test.go
+++ b/src/crypto/tls/handshake_server_test.go
@@ -949,6 +949,27 @@ func TestHandshakeServerALPNNotConfigured(t *testing.T) {
 	runServerTestTLS13(t, test)
 }
 
+func TestHandshakeServerALPNFallback(t *testing.T) {
+	config := testConfig.Clone()
+	config.NextProtos = []string{"proto1", "h2", "proto2"}
+
+	test := &serverTest{
+		name: "ALPN-Fallback",
+		// Note that this needs OpenSSL 1.0.2 because that is the first
+		// version that supports the -alpn flag.
+		command: []string{"openssl", "s_client", "-alpn", "proto3,http/1.1,proto4", "-cipher", "ECDHE-RSA-CHACHA20-POLY1305", "-ciphersuites", "TLS_CHACHA20_POLY1305_SHA256"},
+		config:  config,
+		validate: func(state ConnectionState) error {
+			if state.NegotiatedProtocol != "" {
+				return fmt.Errorf("Got protocol %q, wanted nothing", state.NegotiatedProtocol)
+			}
+			return nil
+		},
+	}
+	runServerTestTLS12(t, test)
+	runServerTestTLS13(t, test)
+}
+
 // TestHandshakeServerSNI involves a client sending an SNI extension of
 // "snitest.com", which happens to match the CN of testSNICertificate. The test
 // verifies that the server correctly selects that certificate.
diff --git a/src/crypto/tls/handshake_server_tls13.go b/src/crypto/tls/handshake_server_tls13.go
index c375ec4246..08251b84de 100644
--- a/src/crypto/tls/handshake_server_tls13.go
+++ b/src/crypto/tls/handshake_server_tls13.go
@@ -11,7 +11,6 @@ import (
 	"crypto/hmac"
 	"crypto/rsa"
 	"errors"
-	"fmt"
 	"hash"
 	"io"
 	"sync/atomic"
@@ -551,15 +550,13 @@ func (hs *serverHandshakeStateTLS13) sendServerParameters() error {
 
 	encryptedExtensions := new(encryptedExtensionsMsg)
 
-	if len(c.config.NextProtos) > 0 && len(hs.clientHello.alpnProtocols) > 0 {
-		selectedProto := mutualProtocol(hs.clientHello.alpnProtocols, c.config.NextProtos)
-		if selectedProto == "" {
-			c.sendAlert(alertNoApplicationProtocol)
-			return fmt.Errorf("tls: client requested unsupported application protocols (%s)", hs.clientHello.alpnProtocols)
-		}
-		encryptedExtensions.alpnProtocol = selectedProto
-		c.clientProtocol = selectedProto
+	selectedProto, err := negotiateALPN(c.config.NextProtos, hs.clientHello.alpnProtocols)
+	if err != nil {
+		c.sendAlert(alertNoApplicationProtocol)
+		return err
 	}
+	encryptedExtensions.alpnProtocol = selectedProto
+	c.clientProtocol = selectedProto
 
 	hs.transcript.Write(encryptedExtensions.marshal())
 	if _, err := c.writeRecord(recordTypeHandshake, encryptedExtensions.marshal()); err != nil {
diff --git a/src/crypto/tls/testdata/Server-TLSv12-ALPN-Fallback b/src/crypto/tls/testdata/Server-TLSv12-ALPN-Fallback
new file mode 100644
index 0000000000..4fadf39062
--- /dev/null
+++ b/src/crypto/tls/testdata/Server-TLSv12-ALPN-Fallback
@@ -0,0 +1,91 @@
+>>> Flow 1 (client to server)
+00000000  16 03 01 00 a6 01 00 00  a2 03 03 b5 c9 ab 32 7f  |..............2.|
+00000010  e1 af 3f f2 ac 2a 11 dd  33 f9 b5 21 88 0d e4 29  |..?..*..3..!...)|
+00000020  e2 47 49 dc c7 31 a8 a5  25 81 0c 00 00 04 cc a8  |.GI..1..%.......|
+00000030  00 ff 01 00 00 75 00 0b  00 04 03 00 01 02 00 0a  |.....u..........|
+00000040  00 0c 00 0a 00 1d 00 17  00 1e 00 19 00 18 00 23  |...............#|
+00000050  00 00 00 10 00 19 00 17  06 70 72 6f 74 6f 33 08  |.........proto3.|
+00000060  68 74 74 70 2f 31 2e 31  06 70 72 6f 74 6f 34 00  |http/1.1.proto4.|
+00000070  16 00 00 00 17 00 00 00  0d 00 30 00 2e 04 03 05  |..........0.....|
+00000080  03 06 03 08 07 08 08 08  09 08 0a 08 0b 08 04 08  |................|
+00000090  05 08 06 04 01 05 01 06  01 03 03 02 03 03 01 02  |................|
+000000a0  01 03 02 02 02 04 02 05  02 06 02                 |...........|
+>>> Flow 2 (server to client)
+00000000  16 03 03 00 3b 02 00 00  37 03 03 00 00 00 00 00  |....;...7.......|
+00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
+00000020  00 00 00 44 4f 57 4e 47  52 44 01 00 cc a8 00 00  |...DOWNGRD......|
+00000030  0f 00 23 00 00 ff 01 00  01 00 00 0b 00 02 01 00  |..#.............|
+00000040  16 03 03 02 59 0b 00 02  55 00 02 52 00 02 4f 30  |....Y...U..R..O0|
+00000050  82 02 4b 30 82 01 b4 a0  03 02 01 02 02 09 00 e8  |..K0............|
+00000060  f0 9d 3f e2 5b ea a6 30  0d 06 09 2a 86 48 86 f7  |..?.[..0...*.H..|
+00000070  0d 01 01 0b 05 00 30 1f  31 0b 30 09 06 03 55 04  |......0.1.0...U.|
+00000080  0a 13 02 47 6f 31 10 30  0e 06 03 55 04 03 13 07  |...Go1.0...U....|
+00000090  47 6f 20 52 6f 6f 74 30  1e 17 0d 31 36 30 31 30  |Go Root0...16010|
+000000a0  31 30 30 30 30 30 30 5a  17 0d 32 35 30 31 30 31  |1000000Z..250101|
+000000b0  30 30 30 30 30 30 5a 30  1a 31 0b 30 09 06 03 55  |000000Z0.1.0...U|
+000000c0  04 0a 13 02 47 6f 31 0b  30 09 06 03 55 04 03 13  |....Go1.0...U...|
+000000d0  02 47 6f 30 81 9f 30 0d  06 09 2a 86 48 86 f7 0d  |.Go0..0...*.H...|
+000000e0  01 01 01 05 00 03 81 8d  00 30 81 89 02 81 81 00  |.........0......|
+000000f0  db 46 7d 93 2e 12 27 06  48 bc 06 28 21 ab 7e c4  |.F}...'.H..(!.~.|
+00000100  b6 a2 5d fe 1e 52 45 88  7a 36 47 a5 08 0d 92 42  |..]..RE.z6G....B|
+00000110  5b c2 81 c0 be 97 79 98  40 fb 4f 6d 14 fd 2b 13  |[.....y.@.Om..+.|
+00000120  8b c2 a5 2e 67 d8 d4 09  9e d6 22 38 b7 4a 0b 74  |....g....."8.J.t|
+00000130  73 2b c2 34 f1 d1 93 e5  96 d9 74 7b f3 58 9f 6c  |s+.4......t{.X.l|
+00000140  61 3c c0 b0 41 d4 d9 2b  2b 24 23 77 5b 1c 3b bd  |a<..A..++$#w[.;.|
+00000150  75 5d ce 20 54 cf a1 63  87 1d 1e 24 c4 f3 1d 1a  |u]. T..c...$....|
+00000160  50 8b aa b6 14 43 ed 97  a7 75 62 f4 14 c8 52 d7  |P....C...ub...R.|
+00000170  02 03 01 00 01 a3 81 93  30 81 90 30 0e 06 03 55  |........0..0...U|
+00000180  1d 0f 01 01 ff 04 04 03  02 05 a0 30 1d 06 03 55  |...........0...U|
+00000190  1d 25 04 16 30 14 06 08  2b 06 01 05 05 07 03 01  |.%..0...+.......|
+000001a0  06 08 2b 06 01 05 05 07  03 02 30 0c 06 03 55 1d  |..+.......0...U.|
+000001b0  13 01 01 ff 04 02 30 00  30 19 06 03 55 1d 0e 04  |......0.0...U...|
+000001c0  12 04 10 9f 91 16 1f 43  43 3e 49 a6 de 6d b6 80  |.......CC>I..m..|
+000001d0  d7 9f 60 30 1b 06 03 55  1d 23 04 14 30 12 80 10  |..`0...U.#..0...|
+000001e0  48 13 49 4d 13 7e 16 31  bb a3 01 d5 ac ab 6e 7b  |H.IM.~.1......n{|
+000001f0  30 19 06 03 55 1d 11 04  12 30 10 82 0e 65 78 61  |0...U....0...exa|
+00000200  6d 70 6c 65 2e 67 6f 6c  61 6e 67 30 0d 06 09 2a  |mple.golang0...*|
+00000210  86 48 86 f7 0d 01 01 0b  05 00 03 81 81 00 9d 30  |.H.............0|
+00000220  cc 40 2b 5b 50 a0 61 cb  ba e5 53 58 e1 ed 83 28  |.@+[P.a...SX...(|
+00000230  a9 58 1a a9 38 a4 95 a1  ac 31 5a 1a 84 66 3d 43  |.X..8....1Z..f=C|
+00000240  d3 2d d9 0b f2 97 df d3  20 64 38 92 24 3a 00 bc  |.-...... d8.$:..|
+00000250  cf 9c 7d b7 40 20 01 5f  aa d3 16 61 09 a2 76 fd  |..}.@ ._...a..v.|
+00000260  13 c3 cc e1 0c 5c ee b1  87 82 f1 6c 04 ed 73 bb  |.....\.....l..s.|
+00000270  b3 43 77 8d 0c 1c f1 0f  a1 d8 40 83 61 c9 4c 72  |.Cw.......@.a.Lr|
+00000280  2b 9d ae db 46 06 06 4d  f4 c1 b3 3e c0 d1 bd 42  |+...F..M...>...B|
+00000290  d4 db fe 3d 13 60 84 5c  21 d3 3b e9 fa e7 16 03  |...=.`.\!.;.....|
+000002a0  03 00 ac 0c 00 00 a8 03  00 1d 20 2f e5 7d a3 47  |.......... /.}.G|
+000002b0  cd 62 43 15 28 da ac 5f  bb 29 07 30 ff f6 84 af  |.bC.(.._.).0....|
+000002c0  c4 cf c2 ed 90 99 5f 58  cb 3b 74 08 04 00 80 5f  |......_X.;t...._|
+000002d0  37 27 84 58 1e ea 1e 40  1b de a9 8f 04 d4 94 64  |7'.X...@.......d|
+000002e0  4e 27 c7 f1 b3 30 d0 53  f5 3d 57 50 d2 17 97 c8  |N'...0.S.=WP....|
+000002f0  3d 61 af a6 21 ab 1c 34  47 70 f8 b1 3b 9c 06 86  |=a..!..4Gp..;...|
+00000300  87 00 e2 13 50 83 91 ad  bc 84 bd b4 7b f3 4b ed  |....P.......{.K.|
+00000310  ca 81 0c 94 37 a8 ec 67  ca 9c f3 00 f6 af c2 92  |....7..g........|
+00000320  c4 8c 78 07 18 0e 43 24  1b 98 16 50 5c 2b 75 0e  |..x...C$...P\+u.|
+00000330  40 66 dc 40 cd 10 1a 51  25 f3 96 25 1a 3e 70 af  |@f.@...Q%..%.>p.|
+00000340  16 24 d0 1c 0e 33 f9 c1  74 cf b7 e2 28 ac 60 16  |.$...3..t...(.`.|
+00000350  03 03 00 04 0e 00 00 00                           |........|
+>>> Flow 3 (client to server)
+00000000  16 03 03 00 25 10 00 00  21 20 30 f2 bb f7 a7 ac  |....%...! 0.....|
+00000010  23 20 22 ee 73 0d 49 9c  b3 7b c1 9a db 2c 85 f3  |# ".s.I..{...,..|
+00000020  c0 82 31 60 bd 8b 14 4e  73 43 14 03 03 00 01 01  |..1`...NsC......|
+00000030  16 03 03 00 20 09 8d c7  86 ee cc f4 c7 36 a3 49  |.... ........6.I|
+00000040  d3 f7 a1 4a 68 a2 1e b4  fc cc a2 15 cb 01 92 d8  |...Jh...........|
+00000050  72 b0 d1 6f eb                                    |r..o.|
+>>> Flow 4 (server to client)
+00000000  16 03 03 00 8b 04 00 00  87 00 00 00 00 00 81 50  |...............P|
+00000010  46 ad c1 db a8 38 86 7b  2b bb fd d0 c3 42 3e 00  |F....8.{+....B>.|
+00000020  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 94  |................|
+00000030  6f e0 18 83 51 ed 14 ef  68 ca 42 c5 4c a2 ac 05  |o...Q...h.B.L...|
+00000040  9c 69 69 99 08 9f de a4  d4 e7 37 ab 14 38 4c 47  |.ii.......7..8LG|
+00000050  70 f0 97 1d db 2d 0a 14  c2 1e f0 16 9f 6d 37 02  |p....-.......m7.|
+00000060  4b f1 16 be 98 3f df 74  83 7c 19 85 61 49 38 16  |K....?.t.|..aI8.|
+00000070  ee 35 7a e2 3f 74 fe 8d  e3 07 93 a1 5e fa f2 02  |.5z.?t......^...|
+00000080  e5 c8 60 3f 11 83 8b 0e  32 52 f1 aa 52 b7 0a 89  |..`?....2R..R...|
+00000090  14 03 03 00 01 01 16 03  03 00 20 9e 65 15 cf 45  |.......... .e..E|
+000000a0  a5 03 69 c9 b1 d8 9e 92  a3 a2 b0 df 2e 62 b1 3a  |..i..........b.:|
+000000b0  17 78 cd e5 1d f3 51 42  7e 4e 25 17 03 03 00 1d  |.x....QB~N%.....|
+000000c0  d9 ae d0 fa b7 90 a9 2f  28 8d 1d 6f 54 1f c0 1e  |......./(..oT...|
+000000d0  4d ae b6 91 f0 e8 84 cf  86 11 22 25 ea 15 03 03  |M........."%....|
+000000e0  00 12 0e 71 f2 11 9e 9f  58 ad c0 d8 fc fa 34 bc  |...q....X.....4.|
+000000f0  02 5a 60 00                                       |.Z`.|
diff --git a/src/crypto/tls/testdata/Server-TLSv13-ALPN-Fallback b/src/crypto/tls/testdata/Server-TLSv13-ALPN-Fallback
new file mode 100644
index 0000000000..6203e6877c
--- /dev/null
+++ b/src/crypto/tls/testdata/Server-TLSv13-ALPN-Fallback
@@ -0,0 +1,100 @@
+>>> Flow 1 (client to server)
+00000000  16 03 01 00 eb 01 00 00  e7 03 03 1c d3 8e 3b d9  |..............;.|
+00000010  fe 7d e7 f9 9f fa c6 51  c3 8c 1b dd dc 87 95 f4  |.}.....Q........|
+00000020  39 23 67 e4 d6 bd 94 93  fc 88 4e 20 c3 c0 e2 c1  |9#g.......N ....|
+00000030  3d 12 ec 4c 0a 3f 40 51  13 24 61 11 c0 5d 09 f9  |=..L.?@Q.$a..]..|
+00000040  08 d6 3e cd e7 b3 51 c3  06 8f b4 42 00 04 13 03  |..>...Q....B....|
+00000050  00 ff 01 00 00 9a 00 0b  00 04 03 00 01 02 00 0a  |................|
+00000060  00 0c 00 0a 00 1d 00 17  00 1e 00 19 00 18 00 23  |...............#|
+00000070  00 00 00 10 00 19 00 17  06 70 72 6f 74 6f 33 08  |.........proto3.|
+00000080  68 74 74 70 2f 31 2e 31  06 70 72 6f 74 6f 34 00  |http/1.1.proto4.|
+00000090  16 00 00 00 17 00 00 00  0d 00 1e 00 1c 04 03 05  |................|
+000000a0  03 06 03 08 07 08 08 08  09 08 0a 08 0b 08 04 08  |................|
+000000b0  05 08 06 04 01 05 01 06  01 00 2b 00 03 02 03 04  |..........+.....|
+000000c0  00 2d 00 02 01 01 00 33  00 26 00 24 00 1d 00 20  |.-.....3.&.$... |
+000000d0  f4 05 eb 4a 7a 73 20 18  74 aa 14 2a 0c 35 63 29  |...Jzs .t..*.5c)|
+000000e0  cb f2 ad d1 a2 3d bd 9d  02 b4 62 00 bc eb 10 58  |.....=....b....X|
+>>> Flow 2 (server to client)
+00000000  16 03 03 00 7a 02 00 00  76 03 03 00 00 00 00 00  |....z...v.......|
+00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
+00000020  00 00 00 00 00 00 00 00  00 00 00 20 c3 c0 e2 c1  |........... ....|
+00000030  3d 12 ec 4c 0a 3f 40 51  13 24 61 11 c0 5d 09 f9  |=..L.?@Q.$a..]..|
+00000040  08 d6 3e cd e7 b3 51 c3  06 8f b4 42 13 03 00 00  |..>...Q....B....|
+00000050  2e 00 2b 00 02 03 04 00  33 00 24 00 1d 00 20 2f  |..+.....3.$... /|
+00000060  e5 7d a3 47 cd 62 43 15  28 da ac 5f bb 29 07 30  |.}.G.bC.(.._.).0|
+00000070  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74 14  |.........._X.;t.|
+00000080  03 03 00 01 01 17 03 03  00 17 fb 75 d8 5c 50 35  |...........u.\P5|
+00000090  55 82 ba 65 1e 63 73 b8  c1 e9 d7 f5 28 68 3c c1  |U..e.cs.....(h<.|
+000000a0  5d 17 03 03 02 6d 56 c9  a9 09 73 6a bc fd 1a 3c  |]....mV...sj...<|
+000000b0  6a f8 3e 32 99 83 e8 f6  01 9e 5e 30 e8 53 7f 72  |j.>2......^0.S.r|
+000000c0  fd 86 72 a8 9e 47 25 67  c1 f1 9a 03 c0 9d 6f 9d  |..r..G%g......o.|
+000000d0  bd ed 29 30 8f 3c 01 ce  49 bb 5f dd 58 9a ae 80  |..)0.<..I._.X...|
+000000e0  5c 2d 81 fc ea 7b 03 03  3d 5d bb 92 23 73 67 89  |\-...{..=]..#sg.|
+000000f0  2e f0 ec 08 20 8a 36 eb  43 a6 a1 68 d0 39 95 37  |.... .6.C..h.9.7|
+00000100  6b 15 a9 0e 46 20 92 51  9c 04 bf 3b 07 97 84 cb  |k...F .Q...;....|
+00000110  1f 30 38 37 2e ff e7 0f  f5 14 93 5a 84 f1 f7 10  |.087.......Z....|
+00000120  c2 a5 0d bb 97 96 ef 4a  e0 13 c0 63 72 2b 60 f3  |.......J...cr+`.|
+00000130  59 b5 57 aa 5f d1 da a9  0e dd 9c dd c2 cb 61 fe  |Y.W._.........a.|
+00000140  e2 69 8e db 5d 70 6c 3a  33 e0 9e db 9a 31 26 6a  |.i..]pl:3....1&j|
+00000150  2b 9e 19 8e bb 5d 06 48  ea c0 a1 c6 11 24 fb c4  |+....].H.....$..|
+00000160  ce ae 48 54 64 81 d1 84  38 a6 e0 7a 7b 74 2b bc  |..HTd...8..z{t+.|
+00000170  ce 07 8b b6 04 1f 5b 4c  36 29 68 0c 8c c7 32 15  |......[L6)h...2.|
+00000180  93 e0 10 52 c2 27 23 96  c5 0c 9c e9 e2 a9 08 7d  |...R.'#........}|
+00000190  25 68 65 f5 4e 44 eb a9  85 78 13 e1 0d 86 5e dc  |%he.ND...x....^.|
+000001a0  fd e5 c6 dd 65 46 8e 2f  32 82 83 0b dd 67 f8 42  |....eF./2....g.B|
+000001b0  65 87 3b 08 fe b1 f5 12  e9 74 21 04 12 6d 75 35  |e.;......t!..mu5|
+000001c0  b2 eb 93 95 72 10 fa 56  96 77 c3 0c 17 8c 9e f6  |....r..V.w......|
+000001d0  77 19 28 37 96 3e 73 98  f4 d2 91 4f 40 db 76 56  |w.(7.>s....O@.vV|
+000001e0  ce b5 a8 7a b8 86 d0 9a  ba b5 8b 40 c2 63 e1 cf  |...z.......@.c..|
+000001f0  49 29 2c 5d 1a 9b 8b 56  cb 93 ca 2c c0 d0 15 b7  |I),]...V...,....|
+00000200  8a f1 6a d5 0a a8 81 57  b1 6e 10 cd a5 ff b1 4d  |..j....W.n.....M|
+00000210  47 c6 9b 35 f1 5f 83 91  22 f6 88 68 65 b3 b9 c9  |G..5._.."..he...|
+00000220  02 dc 4b f7 13 39 06 e6  3a ec 94 ef 51 15 05 72  |..K..9..:...Q..r|
+00000230  1d f4 9d 3b da ca 8d 2c  64 be 9b 45 99 2c 63 cc  |...;...,d..E.,c.|
+00000240  22 b3 8b 93 ad f6 2c f0  d2 d9 11 3f 5b c0 40 fa  |".....,....?[.@.|
+00000250  90 6e a0 76 b2 43 b9 4c  72 c4 24 28 a2 bf 56 d6  |.n.v.C.Lr.$(..V.|
+00000260  d2 a7 2a d1 8c 5e 1d eb  f8 be d0 43 da 7a c7 88  |..*..^.....C.z..|
+00000270  61 67 a2 69 85 23 43 3e  d4 88 f2 33 c3 5b 38 0a  |ag.i.#C>...3.[8.|
+00000280  1e de 28 3b 3b 19 de 95  2f 84 c0 37 88 80 59 2f  |..(;;.../..7..Y/|
+00000290  a6 ee 93 1a 69 08 c3 df  7c cf da c3 9b 96 70 d9  |....i...|.....p.|
+000002a0  60 c5 e9 0f 42 f6 1a f2  58 5e f2 32 61 6a b2 a3  |`...B...X^.2aj..|
+000002b0  1f 97 fa 08 6c 3f 4b 83  1f 04 66 80 8a 26 3a 7f  |....l?K...f..&:.|
+000002c0  24 30 ec 10 ae 7d 19 ff  39 91 ca 97 4e ed 0a d7  |$0...}..9...N...|
+000002d0  64 3b 6b 50 29 33 0d b2  10 bc 83 63 3c fb 9a 82  |d;kP)3.....c<...|
+000002e0  3b 7f bc 04 40 f1 33 64  4a 80 cd 01 f9 f4 c6 89  |;...@.3dJ.......|
+000002f0  65 27 25 f9 cf 4f 7e c8  6e d9 0e ec 47 4a 51 29  |e'%..O~.n...GJQ)|
+00000300  2f be 34 50 bd 9b d2 d8  b7 ea bb 0b a1 e0 20 1b  |/.4P.......... .|
+00000310  02 9c f2 17 03 03 00 99  61 dc 0b 3a 30 de 39 f6  |........a..:0.9.|
+00000320  f3 db f8 6c 3b fa 4e 1e  7e 62 a5 ae 73 ba e1 41  |...l;.N.~b..s..A|
+00000330  58 77 2a c1 7a 0c 50 bb  0c 57 b4 c4 25 bf 2f 9f  |Xw*.z.P..W..%./.|
+00000340  38 91 e2 65 22 9d ca ac  18 58 7e 81 2d fd 74 24  |8..e"....X~.-.t$|
+00000350  28 69 76 11 df 9d 23 b8  be ae 8b e0 93 8e 5d df  |(iv...#.......].|
+00000360  0a 64 d0 b7 02 68 aa 86  01 0d 55 11 3b 76 70 c6  |.d...h....U.;vp.|
+00000370  83 0c 5e 0a e3 37 a5 8b  ad 25 50 b9 e8 5c 6b 04  |..^..7...%P..\k.|
+00000380  b4 51 ec 9c d3 fa c6 b7  9c f0 46 aa 73 da 3c 0d  |.Q........F.s.<.|
+00000390  d3 bd 32 81 d4 d2 f1 1a  b0 92 f3 73 3e 54 2b 05  |..2........s>T+.|
+000003a0  92 24 34 75 df d6 18 a0  6a 82 95 4c 9b fc 7e b6  |.$4u....j..L..~.|
+000003b0  8e 17 03 03 00 35 8f 34  0e 3b 91 d8 e7 74 24 71  |.....5.4.;...t$q|
+000003c0  0e 7b f3 12 bb 76 2f 31  12 17 b8 9e 24 ce f9 2f  |.{...v/1....$../|
+000003d0  3f 5d f2 13 4b 2e 9b 1e  c4 78 03 a6 c8 07 11 a3  |?]..K....x......|
+000003e0  98 79 61 6e 4f 44 6e 18  ee c4 9b 17 03 03 00 93  |.yanODn.........|
+000003f0  64 dd 52 a9 d9 51 63 6a  a0 a3 c2 75 6b 5d 1d 54  |d.R..Qcj...uk].T|
+00000400  ce d4 53 7e 14 8e d9 26  93 28 78 65 16 1b 95 77  |..S~...&.(xe...w|
+00000410  68 0a 46 f1 82 36 bb 8a  fa 0d df 54 8c 3d 83 e0  |h.F..6.....T.=..|
+00000420  d7 de 2d 96 e9 c4 d7 22  d3 97 8e ae 90 f8 fc e6  |..-...."........|
+00000430  a6 4b 78 98 4c c5 28 87  91 46 fa f4 1c 8d 0e ec  |.Kx.L.(..F......|
+00000440  0d 71 40 9a 04 49 b4 e8  5b 62 6f cd 16 c1 d5 fb  |.q@..I..[bo.....|
+00000450  73 2a 96 8f e5 a2 f4 11  1e df 2d 40 45 6b d5 a9  |s*........-@Ek..|
+00000460  e4 e3 f7 93 fc fa d7 20  af d5 f7 b4 0e 09 ad d5  |....... ........|
+00000470  26 87 b8 6c e2 20 95 fb  c0 70 3e 38 be b7 b1 9f  |&..l. ...p>8....|
+00000480  70 da c1                                          |p..|
+>>> Flow 3 (client to server)
+00000000  14 03 03 00 01 01 17 03  03 00 35 29 d2 b9 bb 9b  |..........5)....|
+00000010  de 6c 5d 22 23 c1 fe 99  4c c5 33 bf fd 70 36 6b  |.l]"#...L.3..p6k|
+00000020  f1 a5 92 e8 bf 7c 3d 6e  ef 6a 44 73 bc cb 27 1c  |.....|=n.jDs..'.|
+00000030  09 5d bf 99 4c 19 24 c3  3b 30 91 b5 e3 b6 63 45  |.]..L.$.;0....cE|
+>>> Flow 4 (server to client)
+00000000  17 03 03 00 1e 52 55 85  7c b8 87 dd c7 b2 d9 5b  |.....RU.|......[|
+00000010  18 1d bb ac bf b6 ab 76  82 be 64 0e b2 7b 2c 0f  |.......v..d..{,.|
+00000020  aa 17 92 17 03 03 00 13  79 0a 60 b1 46 20 33 74  |........y.`.F 3t|
+00000030  ed 12 a0 23 de 68 88 fc  6f dd 8e                 |...#.h..o..|
-- 
GitLab


From 8d11b1d1172817359d08231deaf29f72d315b762 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Tue, 8 Jun 2021 15:53:08 -0400
Subject: [PATCH 2214/2400] cmd/go: report the imports of CompiledGoFiles in
 ImportMap

Ideally we should encode the load.PackageInternal data in a way that
doesn't rely on 1:1 correlations of slices, but this is a minimal fix
to unblock Go 1.17.

Fixes #46462

Change-Id: I6e029c69f757aadc54d4be02c01d6b294c217542
Reviewed-on: https://go-review.googlesource.com/c/go/+/326610
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/internal/list/list.go              | 14 ++++++-
 src/cmd/go/internal/load/pkg.go               |  4 +-
 .../script/list_cgo_compiled_importmap.txt    | 38 +++++++++++++++++++
 3 files changed, 52 insertions(+), 4 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/list_cgo_compiled_importmap.txt

diff --git a/src/cmd/go/internal/list/list.go b/src/cmd/go/internal/list/list.go
index 53aaf311ec..7cb9ec6d94 100644
--- a/src/cmd/go/internal/list/list.go
+++ b/src/cmd/go/internal/list/list.go
@@ -724,8 +724,18 @@ func runList(ctx context.Context, cmd *base.Command, args []string) {
 
 	// Record non-identity import mappings in p.ImportMap.
 	for _, p := range pkgs {
-		for i, srcPath := range p.Internal.RawImports {
-			path := p.Imports[i]
+		nRaw := len(p.Internal.RawImports)
+		for i, path := range p.Imports {
+			var srcPath string
+			if i < nRaw {
+				srcPath = p.Internal.RawImports[i]
+			} else {
+				// This path is not within the raw imports, so it must be an import
+				// found only within CompiledGoFiles. Those paths are found in
+				// CompiledImports.
+				srcPath = p.Internal.CompiledImports[i-nRaw]
+			}
+
 			if path != srcPath {
 				if p.ImportMap == nil {
 					p.ImportMap = make(map[string]string)
diff --git a/src/cmd/go/internal/load/pkg.go b/src/cmd/go/internal/load/pkg.go
index 738904865e..a83cc9a812 100644
--- a/src/cmd/go/internal/load/pkg.go
+++ b/src/cmd/go/internal/load/pkg.go
@@ -194,8 +194,8 @@ type PackageInternal struct {
 	// Unexported fields are not part of the public API.
 	Build             *build.Package
 	Imports           []*Package           // this package's direct imports
-	CompiledImports   []string             // additional Imports necessary when using CompiledGoFiles (all from standard library)
-	RawImports        []string             // this package's original imports as they appear in the text of the program
+	CompiledImports   []string             // additional Imports necessary when using CompiledGoFiles (all from standard library); 1:1 with the end of PackagePublic.Imports
+	RawImports        []string             // this package's original imports as they appear in the text of the program; 1:1 with the end of PackagePublic.Imports
 	ForceLibrary      bool                 // this package is a library (even if named "main")
 	CmdlineFiles      bool                 // package built from files listed on command line
 	CmdlinePkg        bool                 // package listed on command line
diff --git a/src/cmd/go/testdata/script/list_cgo_compiled_importmap.txt b/src/cmd/go/testdata/script/list_cgo_compiled_importmap.txt
new file mode 100644
index 0000000000..3d68ef3055
--- /dev/null
+++ b/src/cmd/go/testdata/script/list_cgo_compiled_importmap.txt
@@ -0,0 +1,38 @@
+# Regression test for https://golang.org/issue/46462.
+#
+# The "runtime/cgo" import found in synthesized .go files (reported in
+# the CompiledGoFiles field) should have a corresponding entry in the
+# ImportMap field when a runtime/cgo variant (such as a test variant)
+# will be used.
+
+[short] skip  # -compiled can be slow (because it compiles things)
+[!cgo] skip
+
+env CGO_ENABLED=1
+env GOFLAGS=-tags=netcgo  # Force net to use cgo even on Windows.
+
+
+# "runtime/cgo [runtime.test]" appears in the the test dependencies of "runtime",
+# because "runtime/cgo" itself depends on "runtime"
+
+go list -deps -test -compiled -f '{{if eq .ImportPath "net [runtime.test]"}}{{printf "%q" .Imports}}{{end}}' runtime
+
+	# Control case: the explicitly-imported package "sync" is a test variant,
+	# because "sync" depends on "runtime".
+stdout '"sync \[runtime\.test\]"'
+! stdout '"sync"'
+
+	# Experiment: the implicitly-imported package "runtime/cgo" is also a test variant,
+	# because "runtime/cgo" also depends on "runtime".
+stdout '"runtime/cgo \[runtime\.test\]"'
+! stdout '"runtime/cgo"'
+
+
+# Because the import of "runtime/cgo" in the cgo-generated file actually refers
+# to "runtime/cgo [runtime.test]", the latter should be listed in the ImportMap.
+# BUG(#46462): Today, it is not.
+
+go list -deps -test -compiled -f '{{if eq .ImportPath "net [runtime.test]"}}{{printf "%q" .ImportMap}}{{end}}' runtime
+
+stdout '"sync":"sync \[runtime\.test\]"'                # control
+stdout '"runtime/cgo":"runtime/cgo \[runtime\.test\]"'  # experiment
-- 
GitLab


From 770f1de8c54256d5b17447028e47b201ba8e62c8 Mon Sep 17 00:00:00 2001
From: Damien Neil <dneil@google.com>
Date: Thu, 10 Jun 2021 10:50:37 -0700
Subject: [PATCH 2215/2400] net/http: remove test-only private key from
 production binaries

The net/http/internal package contains a PEM-encoded private key used in
tests. This key is initialized at init time, which prevents it from
being stripped by the linker in non-test binaries.

Move the certificate and key to a new net/http/internal/testcert
package to ensure it is only included in binaries that reference it.

Fixes #46677.

Change-Id: Ie98bda529169314cc791063e7ce4d99ef99113c8
Reviewed-on: https://go-review.googlesource.com/c/go/+/326771
Trust: Damien Neil <dneil@google.com>
Run-TryBot: Damien Neil <dneil@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/go/build/deps_test.go                        | 4 +++-
 src/net/http/httptest/server.go                  | 4 ++--
 src/net/http/internal/{ => testcert}/testcert.go | 5 +++--
 src/net/http/serve_test.go                       | 7 ++++---
 src/net/http/transport_internal_test.go          | 4 ++--
 src/net/http/transport_test.go                   | 4 ++--
 6 files changed, 16 insertions(+), 12 deletions(-)
 rename src/net/http/internal/{ => testcert}/testcert.go (94%)

diff --git a/src/go/build/deps_test.go b/src/go/build/deps_test.go
index 5d1cf7f4c9..45e2f25df7 100644
--- a/src/go/build/deps_test.go
+++ b/src/go/build/deps_test.go
@@ -440,7 +440,8 @@ var depsRules = `
 	# HTTP, King of Dependencies.
 
 	FMT
-	< golang.org/x/net/http2/hpack, net/http/internal, net/http/internal/ascii;
+	< golang.org/x/net/http2/hpack
+	< net/http/internal, net/http/internal/ascii, net/http/internal/testcert;
 
 	FMT, NET, container/list, encoding/binary, log
 	< golang.org/x/text/transform
@@ -459,6 +460,7 @@ var depsRules = `
 	golang.org/x/net/http2/hpack,
 	net/http/internal,
 	net/http/internal/ascii,
+	net/http/internal/testcert,
 	net/http/httptrace,
 	mime/multipart,
 	log
diff --git a/src/net/http/httptest/server.go b/src/net/http/httptest/server.go
index a02a6d64c3..4f85ff55d8 100644
--- a/src/net/http/httptest/server.go
+++ b/src/net/http/httptest/server.go
@@ -14,7 +14,7 @@ import (
 	"log"
 	"net"
 	"net/http"
-	"net/http/internal"
+	"net/http/internal/testcert"
 	"os"
 	"strings"
 	"sync"
@@ -144,7 +144,7 @@ func (s *Server) StartTLS() {
 	if s.client == nil {
 		s.client = &http.Client{Transport: &http.Transport{}}
 	}
-	cert, err := tls.X509KeyPair(internal.LocalhostCert, internal.LocalhostKey)
+	cert, err := tls.X509KeyPair(testcert.LocalhostCert, testcert.LocalhostKey)
 	if err != nil {
 		panic(fmt.Sprintf("httptest: NewTLSServer: %v", err))
 	}
diff --git a/src/net/http/internal/testcert.go b/src/net/http/internal/testcert/testcert.go
similarity index 94%
rename from src/net/http/internal/testcert.go
rename to src/net/http/internal/testcert/testcert.go
index 2284a836fb..5f94704ef5 100644
--- a/src/net/http/internal/testcert.go
+++ b/src/net/http/internal/testcert/testcert.go
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package internal
+// Package testcert contains a test-only localhost certificate.
+package testcert
 
 import "strings"
 
@@ -25,7 +26,7 @@ h1fIw3cSS2OolhloGw/XM6RWPWtPAlGykKLciQrBru5NAPvCMsb/I1DAceTiotQM
 fblo6RBxUQ==
 -----END CERTIFICATE-----`)
 
-// LocalhostKey is the private key for localhostCert.
+// LocalhostKey is the private key for LocalhostCert.
 var LocalhostKey = []byte(testingKey(`-----BEGIN RSA TESTING KEY-----
 MIICXgIBAAKBgQDuLnQAI3mDgey3VBzWnB2L39JUU4txjeVE6myuDqkM/uGlfjb9
 SjY1bIw4iA5sBBZzHi3z0h1YV8QPuxEbi4nW91IJm2gsvvZhIrCHS3l6afab4pZB
diff --git a/src/net/http/serve_test.go b/src/net/http/serve_test.go
index c2f8811469..6394da3bb7 100644
--- a/src/net/http/serve_test.go
+++ b/src/net/http/serve_test.go
@@ -25,6 +25,7 @@ import (
 	"net/http/httptest"
 	"net/http/httputil"
 	"net/http/internal"
+	"net/http/internal/testcert"
 	"net/url"
 	"os"
 	"os/exec"
@@ -1475,7 +1476,7 @@ func TestServeTLS(t *testing.T) {
 	defer afterTest(t)
 	defer SetTestHookServerServe(nil)
 
-	cert, err := tls.X509KeyPair(internal.LocalhostCert, internal.LocalhostKey)
+	cert, err := tls.X509KeyPair(testcert.LocalhostCert, testcert.LocalhostKey)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1599,7 +1600,7 @@ func TestAutomaticHTTP2_Serve_WithTLSConfig(t *testing.T) {
 }
 
 func TestAutomaticHTTP2_ListenAndServe(t *testing.T) {
-	cert, err := tls.X509KeyPair(internal.LocalhostCert, internal.LocalhostKey)
+	cert, err := tls.X509KeyPair(testcert.LocalhostCert, testcert.LocalhostKey)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1609,7 +1610,7 @@ func TestAutomaticHTTP2_ListenAndServe(t *testing.T) {
 }
 
 func TestAutomaticHTTP2_ListenAndServe_GetCertificate(t *testing.T) {
-	cert, err := tls.X509KeyPair(internal.LocalhostCert, internal.LocalhostKey)
+	cert, err := tls.X509KeyPair(testcert.LocalhostCert, testcert.LocalhostKey)
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/src/net/http/transport_internal_test.go b/src/net/http/transport_internal_test.go
index 1097ffd173..1cce27235d 100644
--- a/src/net/http/transport_internal_test.go
+++ b/src/net/http/transport_internal_test.go
@@ -12,7 +12,7 @@ import (
 	"errors"
 	"io"
 	"net"
-	"net/http/internal"
+	"net/http/internal/testcert"
 	"strings"
 	"testing"
 )
@@ -191,7 +191,7 @@ func (f roundTripFunc) RoundTrip(r *Request) (*Response, error) {
 
 // Issue 25009
 func TestTransportBodyAltRewind(t *testing.T) {
-	cert, err := tls.X509KeyPair(internal.LocalhostCert, internal.LocalhostKey)
+	cert, err := tls.X509KeyPair(testcert.LocalhostCert, testcert.LocalhostKey)
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/src/net/http/transport_test.go b/src/net/http/transport_test.go
index dcaacece61..690e0c299d 100644
--- a/src/net/http/transport_test.go
+++ b/src/net/http/transport_test.go
@@ -30,7 +30,7 @@ import (
 	"net/http/httptest"
 	"net/http/httptrace"
 	"net/http/httputil"
-	"net/http/internal"
+	"net/http/internal/testcert"
 	"net/textproto"
 	"net/url"
 	"os"
@@ -4299,7 +4299,7 @@ func TestTransportReuseConnEmptyResponseBody(t *testing.T) {
 
 // Issue 13839
 func TestNoCrashReturningTransportAltConn(t *testing.T) {
-	cert, err := tls.X509KeyPair(internal.LocalhostCert, internal.LocalhostKey)
+	cert, err := tls.X509KeyPair(testcert.LocalhostCert, testcert.LocalhostKey)
 	if err != nil {
 		t.Fatal(err)
 	}
-- 
GitLab


From 2721da26083f253c46c2fd0c1dadee14ae4202f5 Mon Sep 17 00:00:00 2001
From: Rhys Hiltner <rhys@justin.tv>
Date: Thu, 10 Jun 2021 15:05:07 -0700
Subject: [PATCH 2216/2400] doc/go1.17: fix formatting near httptest

Change-Id: Ic1a0add3a1e137ca5cd0f3e9ce3266191b0b55cd
Reviewed-on: https://go-review.googlesource.com/c/go/+/326777
Trust: Alberto Donizetti <alb.donizetti@gmail.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 doc/go1.17.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 49fbabdc3f..101957aabd 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -763,9 +763,9 @@ func Foo() bool {
 <dl id="net/http/httptest"><dt><a href="/pkg/net/http/httptest/">net/http/httptest</a></dt>
   <dd>
     <p><!-- CL 308950 -->
-      <a href="/pkg/net/http/httptest/#ResponseRecorder.WriteHeader"><code>ResponseRecorder.WriteHeader></code></a>
+      <a href="/pkg/net/http/httptest/#ResponseRecorder.WriteHeader"><code>ResponseRecorder.WriteHeader</code></a>
       now panics when the provided code is not a valid three-digit HTTP status code.
-      This matches the behavior of <a href="/pkg/net/http/#ResponseWriter"><code>ResponseWriter></code></a>
+      This matches the behavior of <a href="/pkg/net/http/#ResponseWriter"><code>ResponseWriter</code></a>
       implementations in the <a href="/pkg/net/http/"><code>net/http</code></a> package.
     </p>
   </dd>
-- 
GitLab


From 2f1128461dcc6c9915f21327ce18fa1925269f30 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Thu, 10 Jun 2021 16:54:53 -0400
Subject: [PATCH 2217/2400] cmd/go: match Windows paths in
 TestScript/mod_invalid_version

Fixes #46691

Change-Id: I3bef9a773be640bed96eb2dc395cb11671a0767a
Reviewed-on: https://go-review.googlesource.com/c/go/+/326869
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/cmd/go/testdata/script/mod_invalid_version.txt | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/cmd/go/testdata/script/mod_invalid_version.txt b/src/cmd/go/testdata/script/mod_invalid_version.txt
index 34d9c47674..6846a792a5 100644
--- a/src/cmd/go/testdata/script/mod_invalid_version.txt
+++ b/src/cmd/go/testdata/script/mod_invalid_version.txt
@@ -19,7 +19,7 @@ cp go.mod.orig go.mod
 go mod edit -require golang.org/x/text@14c0d48ead0c
 cd outside
 ! go list -m golang.org/x/text
-stderr 'go list -m: example.com@v0.0.0 \(replaced by \./\..\): parsing ../go.mod: '$WORK'/gopath/src/go.mod:5: require golang.org/x/text: version "14c0d48ead0c" invalid: must be of the form v1.2.3'
+stderr 'go list -m: example.com@v0.0.0 \(replaced by \./\.\.\): parsing ..[/\\]go.mod: '$WORK'[/\\]gopath[/\\]src[/\\]go.mod:5: require golang.org/x/text: version "14c0d48ead0c" invalid: must be of the form v1.2.3'
 cd ..
 go list -m golang.org/x/text
 stdout 'golang.org/x/text v0.1.1-0.20170915032832-14c0d48ead0c'
@@ -47,10 +47,10 @@ cp go.mod.orig go.mod
 go mod edit -require golang.org/x/text@v2.1.1-0.20170915032832-14c0d48ead0c
 cd outside
 ! go list -m golang.org/x/text
-stderr 'go list -m: example.com@v0.0.0 \(replaced by \./\.\.\): parsing ../go.mod: '$WORK'/gopath/src/go.mod:5: require golang.org/x/text: version "v2.1.1-0.20170915032832-14c0d48ead0c" invalid: should be v0 or v1, not v2'
+stderr 'go list -m: example.com@v0.0.0 \(replaced by \./\.\.\): parsing ..[/\\]go.mod: '$WORK'[/\\]gopath[/\\]src[/\\]go.mod:5: require golang.org/x/text: version "v2.1.1-0.20170915032832-14c0d48ead0c" invalid: should be v0 or v1, not v2'
 cd ..
 ! go list -m golang.org/x/text
-stderr $WORK'/gopath/src/go.mod:5: require golang.org/x/text: version "v2.1.1-0.20170915032832-14c0d48ead0c" invalid: should be v0 or v1, not v2'
+stderr $WORK'[/\\]gopath[/\\]src[/\\]go.mod:5: require golang.org/x/text: version "v2.1.1-0.20170915032832-14c0d48ead0c" invalid: should be v0 or v1, not v2'
 
 # A pseudo-version with fewer than 12 digits of SHA-1 prefix is invalid.
 cp go.mod.orig go.mod
-- 
GitLab


From e2dc6dd5c9b6799c9bb987f3a4600fb0df686d09 Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Thu, 10 Jun 2021 14:40:58 -0700
Subject: [PATCH 2218/2400] doc/go1.17: clean up formatting of gofmt section

It was the only h3 in <code>, and it lacked <p> around its content.

It looked like it was part of the prior section:

    https://tip.golang.org/doc/go1.17#gofmt

Change-Id: I7e9ef70e9a03474225833f44420aabd70dab3cd5
Reviewed-on: https://go-review.googlesource.com/c/go/+/326774
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Trust: Brad Fitzpatrick <bradfitz@golang.org>
---
 doc/go1.17.html | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 101957aabd..4fa38921f0 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -293,7 +293,9 @@ Do not send CLs removing the interior tags from such phrases.
   <a href="https://golang.org/design/draft-gobuild">https://golang.org/design/draft-gobuild</a>.
 </p>
 
-<h3 id="gofmt"><code>gofmt</code></h3>
+<h3 id="gofmt">Gofmt</h3>
+
+<p>
   <code>gofmt</code> (and <code>go</code> <code>fmt</code>) now synchronizes
   <code>//go:build</code> lines with <code>// +build</code> lines. If a file
   only has <code>// +build</code> lines, they will be moved to the appropriate
@@ -301,7 +303,7 @@ Do not send CLs removing the interior tags from such phrases.
   added. Otherwise, <code>// +build</code> lines will be overwritten based on
   any existing <code>//go:build</code> lines. For more information, see
   <a href="https://golang.org/design/draft-gobuild">https://golang.org/design/draft-gobuild</a>.
-</h3>
+</p>
 
 <h3 id="vet">Vet</h3>
 
-- 
GitLab


From 77aa209b386a184e7f4b44938f2a05a1b5c5a3cf Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Thu, 10 Jun 2021 15:35:05 -0700
Subject: [PATCH 2219/2400] runtime: loop on EINTR in macOS sigNoteSleep

Fixes #46466

Change-Id: I8fb15d0c8ef7ef6e6fc1b9e0e033d213255fe0df
Reviewed-on: https://go-review.googlesource.com/c/go/+/326778
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 src/runtime/os_darwin.go | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/src/runtime/os_darwin.go b/src/runtime/os_darwin.go
index 00139351ab..079be107d7 100644
--- a/src/runtime/os_darwin.go
+++ b/src/runtime/os_darwin.go
@@ -118,10 +118,15 @@ func sigNoteWakeup(*note) {
 
 // sigNoteSleep waits for a note created by sigNoteSetup to be woken.
 func sigNoteSleep(*note) {
-	entersyscallblock()
-	var b byte
-	read(sigNoteRead, unsafe.Pointer(&b), 1)
-	exitsyscall()
+	for {
+		var b byte
+		entersyscallblock()
+		n := read(sigNoteRead, unsafe.Pointer(&b), 1)
+		exitsyscall()
+		if n != -_EINTR {
+			return
+		}
+	}
 }
 
 // BSD interface for threading.
-- 
GitLab


From 16b5d766d8af8bc348f93e6cb2b53a4e2d5d72ca Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Fri, 11 Jun 2021 17:36:50 +0200
Subject: [PATCH 2220/2400] syscall: do not load native libraries on non-native
 powershell on arm

The powershell that currently ships on ARM Windows isn't native, so it
won't load native DLLs. So just skip the tests for now, and reenable it
if this ever changes.

Updates #46701.

Change-Id: I2559fdf13cb65d3ecdc4c6f6df7dec1b490b9651
Reviewed-on: https://go-review.googlesource.com/c/go/+/327210
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
---
 src/syscall/syscall_windows_test.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/syscall/syscall_windows_test.go b/src/syscall/syscall_windows_test.go
index ea8fa191dc..3243952ded 100644
--- a/src/syscall/syscall_windows_test.go
+++ b/src/syscall/syscall_windows_test.go
@@ -10,6 +10,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"runtime"
 	"strings"
 	"syscall"
 	"testing"
@@ -79,6 +80,9 @@ func TestTOKEN_ALL_ACCESS(t *testing.T) {
 func TestStdioAreInheritable(t *testing.T) {
 	testenv.MustHaveGoBuild(t)
 	testenv.MustHaveExecPath(t, "gcc")
+	if runtime.GOARCH == "arm64" || runtime.GOARCH == "arm" {
+		t.Skip("Powershell is not native on ARM; see golang.org/issues/46701")
+	}
 
 	tmpdir := t.TempDir()
 
-- 
GitLab


From e552a6d31270c86064632af1d092e0db5a930250 Mon Sep 17 00:00:00 2001
From: Constantin Konstantinidis <constantinkonstantinidis@gmail.com>
Date: Sat, 5 Jun 2021 07:48:30 +0200
Subject: [PATCH 2221/2400] cmd/go: remove hint when no module is suggested

Fixes #46528

Change-Id: I2453d321ece878ea7823865758aa4a16b3ed7fe8
Reviewed-on: https://go-review.googlesource.com/c/go/+/325430
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Trust: Heschi Kreinick <heschi@google.com>
Trust: Dmitri Shuralyov <dmitshur@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/internal/modload/import.go           | 10 ++++++----
 src/cmd/go/testdata/script/mod_install_hint.txt |  5 +++++
 2 files changed, 11 insertions(+), 4 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/mod_install_hint.txt

diff --git a/src/cmd/go/internal/modload/import.go b/src/cmd/go/internal/modload/import.go
index f76befcfe3..60bd26fb22 100644
--- a/src/cmd/go/internal/modload/import.go
+++ b/src/cmd/go/internal/modload/import.go
@@ -178,11 +178,13 @@ func (e *ImportMissingSumError) Error() string {
 		// Importing package is unknown, or the missing package was named on the
 		// command line. Recommend 'go mod download' for the modules that could
 		// provide the package, since that shouldn't change go.mod.
-		args := make([]string, len(e.mods))
-		for i, mod := range e.mods {
-			args[i] = mod.Path
+		if len(e.mods) > 0 {
+			args := make([]string, len(e.mods))
+			for i, mod := range e.mods {
+				args[i] = mod.Path
+			}
+			hint = fmt.Sprintf("; to add:\n\tgo mod download %s", strings.Join(args, " "))
 		}
-		hint = fmt.Sprintf("; to add:\n\tgo mod download %s", strings.Join(args, " "))
 	} else {
 		// Importing package is known (common case). Recommend 'go get' on the
 		// current version of the importing package.
diff --git a/src/cmd/go/testdata/script/mod_install_hint.txt b/src/cmd/go/testdata/script/mod_install_hint.txt
new file mode 100644
index 0000000000..ab02840eb8
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_install_hint.txt
@@ -0,0 +1,5 @@
+# Module is replaced but not required. No hint appears as no module is suggested.
+go mod init m
+go mod edit -replace=github.com/notrequired@v0.5.0=github.com/doesnotexist@v0.5.0
+! go install github.com/notrequired
+! stderr 'to add it:'
\ No newline at end of file
-- 
GitLab


From 9d46ee5ac4acd6602692f70c5149a3f6db058558 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Fri, 11 Jun 2021 13:58:05 +0000
Subject: [PATCH 2222/2400] reflect: handle stack-to-register translation in
 callMethod

callMethod previously assumed erroneously that between the "value" and
"method" ABIs (that is, the ABI the caller is following to call this
method value and the actual ABI of the method), it could never happen
that an argument passed on the stack in the former could be passed in
registers in the latter. The cited reason was that the latter always
uses strictly more registers.

However, there are situations where the value ABI could pass a value on
the stack, but later is passed in a register. For instance, if the
receiver pushes a value passed in registers that uses multiple registers
to be passed on the stack, later arguments which were passed on the
stack may now be passed in registers.

This change fixes callMethod to no longer makes this assumption, and
handles the stack-to-register translation explicitly.

Fixes #46696.

Change-Id: I7100a664d97bbe401302cc893b3a98b28cdcdfc0
Reviewed-on: https://go-review.googlesource.com/c/go/+/327089
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 src/reflect/abi_test.go | 43 ++++++++++++++++++++++++++++++++++++++++-
 src/reflect/value.go    | 42 ++++++++++++++++++++++++++++++----------
 2 files changed, 74 insertions(+), 11 deletions(-)

diff --git a/src/reflect/abi_test.go b/src/reflect/abi_test.go
index 1a2a48b5ed..5a0130f7b4 100644
--- a/src/reflect/abi_test.go
+++ b/src/reflect/abi_test.go
@@ -79,7 +79,34 @@ func TestMethodValueCallABI(t *testing.T) {
 		t.Errorf("bad method value call: got %#v, want %#v", r2, a2)
 	}
 	if s.Value != 3 {
-		t.Errorf("bad method value call: failed to set s.Value: got %d, want %d", s.Value, 1)
+		t.Errorf("bad method value call: failed to set s.Value: got %d, want %d", s.Value, 3)
+	}
+
+	s, i = makeMethodValue("ValueRegMethodSpillInt")
+	f3 := i.(func(StructFillRegs, int, MagicLastTypeNameForTestingRegisterABI) (StructFillRegs, int))
+	r3a, r3b := f3(a2, 42, MagicLastTypeNameForTestingRegisterABI{})
+	if r3a != a2 {
+		t.Errorf("bad method value call: got %#v, want %#v", r3a, a2)
+	}
+	if r3b != 42 {
+		t.Errorf("bad method value call: got %#v, want %#v", r3b, 42)
+	}
+	if s.Value != 4 {
+		t.Errorf("bad method value call: failed to set s.Value: got %d, want %d", s.Value, 4)
+	}
+
+	s, i = makeMethodValue("ValueRegMethodSpillPtr")
+	f4 := i.(func(StructFillRegs, *byte, MagicLastTypeNameForTestingRegisterABI) (StructFillRegs, *byte))
+	vb := byte(10)
+	r4a, r4b := f4(a2, &vb, MagicLastTypeNameForTestingRegisterABI{})
+	if r4a != a2 {
+		t.Errorf("bad method value call: got %#v, want %#v", r4a, a2)
+	}
+	if r4b != &vb {
+		t.Errorf("bad method value call: got %#v, want %#v", r4b, &vb)
+	}
+	if s.Value != 5 {
+		t.Errorf("bad method value call: failed to set s.Value: got %d, want %d", s.Value, 5)
 	}
 }
 
@@ -112,6 +139,20 @@ func (m *StructWithMethods) SpillStructCall(s StructFillRegs, _ MagicLastTypeNam
 	return s
 }
 
+// When called as a method value, i is passed on the stack.
+// When called as a method, i is passed in a register.
+func (m *StructWithMethods) ValueRegMethodSpillInt(s StructFillRegs, i int, _ MagicLastTypeNameForTestingRegisterABI) (StructFillRegs, int) {
+	m.Value = 4
+	return s, i
+}
+
+// When called as a method value, i is passed on the stack.
+// When called as a method, i is passed in a register.
+func (m *StructWithMethods) ValueRegMethodSpillPtr(s StructFillRegs, i *byte, _ MagicLastTypeNameForTestingRegisterABI) (StructFillRegs, *byte) {
+	m.Value = 5
+	return s, i
+}
+
 func TestReflectCallABI(t *testing.T) {
 	// Enable register-based reflect.Call and ensure we don't
 	// use potentially incorrect cached versions by clearing
diff --git a/src/reflect/value.go b/src/reflect/value.go
index 418dff781f..c963a407bc 100644
--- a/src/reflect/value.go
+++ b/src/reflect/value.go
@@ -952,25 +952,47 @@ func callMethod(ctxt *methodValue, frame unsafe.Pointer, retValid *bool, regs *a
 			continue
 		}
 
-		// There are three cases to handle in translating each
+		// There are four cases to handle in translating each
 		// argument:
 		// 1. Stack -> stack translation.
-		// 2. Registers -> stack translation.
-		// 3. Registers -> registers translation.
-		// The fourth cases can't happen, because a method value
-		// call uses strictly fewer registers than a method call.
+		// 2. Stack -> registers translation.
+		// 3. Registers -> stack translation.
+		// 4. Registers -> registers translation.
+		// TODO(mknyszek): Cases 2 and 3 below only work on little endian
+		// architectures. This is OK for now, but this needs to be fixed
+		// before supporting the register ABI on big endian architectures.
 
 		// If the value ABI passes the value on the stack,
 		// then the method ABI does too, because it has strictly
 		// fewer arguments. Simply copy between the two.
 		if vStep := valueSteps[0]; vStep.kind == abiStepStack {
 			mStep := methodSteps[0]
-			if mStep.kind != abiStepStack || vStep.size != mStep.size {
-				panic("method ABI and value ABI do not align")
+			// Handle stack -> stack translation.
+			if mStep.kind == abiStepStack {
+				if vStep.size != mStep.size {
+					panic("method ABI and value ABI do not align")
+				}
+				typedmemmove(t,
+					add(methodFrame, mStep.stkOff, "precomputed stack offset"),
+					add(valueFrame, vStep.stkOff, "precomputed stack offset"))
+				continue
+			}
+			// Handle stack -> register translation.
+			for _, mStep := range methodSteps {
+				from := add(valueFrame, vStep.stkOff+mStep.offset, "precomputed stack offset")
+				switch mStep.kind {
+				case abiStepPointer:
+					// Do the pointer copy directly so we get a write barrier.
+					methodRegs.Ptrs[mStep.ireg] = *(*unsafe.Pointer)(from)
+					fallthrough // We need to make sure this ends up in Ints, too.
+				case abiStepIntReg:
+					memmove(unsafe.Pointer(&methodRegs.Ints[mStep.ireg]), from, mStep.size)
+				case abiStepFloatReg:
+					memmove(unsafe.Pointer(&methodRegs.Floats[mStep.freg]), from, mStep.size)
+				default:
+					panic("unexpected method step")
+				}
 			}
-			typedmemmove(t,
-				add(methodFrame, mStep.stkOff, "precomputed stack offset"),
-				add(valueFrame, vStep.stkOff, "precomputed stack offset"))
 			continue
 		}
 		// Handle register -> stack translation.
-- 
GitLab


From 1ed0d129e9ba9b55e9ae36ac1d7f2766ba16b373 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Fri, 11 Jun 2021 11:50:42 -0700
Subject: [PATCH 2223/2400] runtime: testprogcgo: don't call exported Go
 functions directly from Go

Instead route through a C function, to avoid declaration conflicts
between the declaration needed in the cgo comment and the declaration
generated by cgo in _cgo_export.h.

This is not something user code will ever do, so no need to make it
work in cgo.

Fixes #46502

Change-Id: I1bfffdc76ef8ea63e3829871298d0774157957a5
Reviewed-on: https://go-review.googlesource.com/c/go/+/327309
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
---
 src/runtime/testdata/testprogcgo/aprof.go            |  4 ++--
 src/runtime/testdata/testprogcgo/aprof_c.c           |  9 +++++++++
 src/runtime/testdata/testprogcgo/bigstack1_windows.c | 12 ++++++++++++
 src/runtime/testdata/testprogcgo/bigstack_windows.go |  4 ++--
 4 files changed, 25 insertions(+), 4 deletions(-)
 create mode 100644 src/runtime/testdata/testprogcgo/aprof_c.c
 create mode 100644 src/runtime/testdata/testprogcgo/bigstack1_windows.c

diff --git a/src/runtime/testdata/testprogcgo/aprof.go b/src/runtime/testdata/testprogcgo/aprof.go
index aabca9e1eb..44a15b0865 100644
--- a/src/runtime/testdata/testprogcgo/aprof.go
+++ b/src/runtime/testdata/testprogcgo/aprof.go
@@ -10,7 +10,7 @@ package main
 // The test fails when the function is the first C function.
 // The exported functions are the first C functions, so we use that.
 
-// extern void GoNop();
+// extern void CallGoNop();
 import "C"
 
 import (
@@ -38,7 +38,7 @@ func CgoCCodeSIGPROF() {
 					break
 				}
 			}
-			C.GoNop()
+			C.CallGoNop()
 		}
 		c <- true
 	}()
diff --git a/src/runtime/testdata/testprogcgo/aprof_c.c b/src/runtime/testdata/testprogcgo/aprof_c.c
new file mode 100644
index 0000000000..d588e13045
--- /dev/null
+++ b/src/runtime/testdata/testprogcgo/aprof_c.c
@@ -0,0 +1,9 @@
+// Copyright 2021 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.
+
+#include "_cgo_export.h"
+
+void CallGoNop() {
+	GoNop();
+}
diff --git a/src/runtime/testdata/testprogcgo/bigstack1_windows.c b/src/runtime/testdata/testprogcgo/bigstack1_windows.c
new file mode 100644
index 0000000000..551fb68309
--- /dev/null
+++ b/src/runtime/testdata/testprogcgo/bigstack1_windows.c
@@ -0,0 +1,12 @@
+// Copyright 2021 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.
+
+// This is not in bigstack_windows.c because it needs to be part of
+// testprogcgo but is not part of the DLL built from bigstack_windows.c.
+
+#include "_cgo_export.h"
+
+void CallGoBigStack1(char* p) {
+	goBigStack1(p);
+}
diff --git a/src/runtime/testdata/testprogcgo/bigstack_windows.go b/src/runtime/testdata/testprogcgo/bigstack_windows.go
index f58fcf993f..135b5fcfe0 100644
--- a/src/runtime/testdata/testprogcgo/bigstack_windows.go
+++ b/src/runtime/testdata/testprogcgo/bigstack_windows.go
@@ -6,7 +6,7 @@ package main
 
 /*
 typedef void callback(char*);
-extern void goBigStack1(char*);
+extern void CallGoBigStack1(char*);
 extern void bigStack(callback*);
 */
 import "C"
@@ -18,7 +18,7 @@ func init() {
 func BigStack() {
 	// Create a large thread stack and call back into Go to test
 	// if Go correctly determines the stack bounds.
-	C.bigStack((*C.callback)(C.goBigStack1))
+	C.bigStack((*C.callback)(C.CallGoBigStack1))
 }
 
 //export goBigStack1
-- 
GitLab


From 67b1b6a2e3a405e3e0b5c6a76f702b2a6071c1f0 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Sun, 13 Jun 2021 10:55:19 +0700
Subject: [PATCH 2224/2400] cmd/compile: allow ir.OSLICE2ARRPTR in mayCall

CL 301650 adds conversion from slice to array ptr. The conversion
expression may appear as argument to a function call, so it will be
tested by mayCall. But ir.OSLICE2ARRPTR  op is not handled by mayCall,
causes the compiler crashes.

Updates #395
Fixes #46720

Change-Id: I39e1b3e38e224a31f3dec46dbbdc855ff3b2c6a5
Reviewed-on: https://go-review.googlesource.com/c/go/+/327649
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/walk/walk.go |  2 +-
 test/fixedbugs/issue46720.go          | 15 +++++++++++++++
 2 files changed, 16 insertions(+), 1 deletion(-)
 create mode 100644 test/fixedbugs/issue46720.go

diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index fe2c62cd4f..26da6e3145 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -313,7 +313,7 @@ func mayCall(n ir.Node) bool {
 			return true
 
 		case ir.OINDEX, ir.OSLICE, ir.OSLICEARR, ir.OSLICE3, ir.OSLICE3ARR, ir.OSLICESTR,
-			ir.ODEREF, ir.ODOTPTR, ir.ODOTTYPE, ir.ODIV, ir.OMOD:
+			ir.ODEREF, ir.ODOTPTR, ir.ODOTTYPE, ir.ODIV, ir.OMOD, ir.OSLICE2ARRPTR:
 			// These ops might panic, make sure they are done
 			// before we start marshaling args for a call. See issue 16760.
 			return true
diff --git a/test/fixedbugs/issue46720.go b/test/fixedbugs/issue46720.go
new file mode 100644
index 0000000000..3b0151ae84
--- /dev/null
+++ b/test/fixedbugs/issue46720.go
@@ -0,0 +1,15 @@
+// compile
+
+// Copyright 2021 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 p
+
+func f() {
+	nonce := make([]byte, 24)
+	g((*[24]byte)(nonce))
+}
+
+//go:noinline
+func g(*[24]byte) {}
-- 
GitLab


From 24cff0f0444793be81062684c478a3f7ca955499 Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Sat, 12 Jun 2021 12:34:40 +0200
Subject: [PATCH 2225/2400] cmd/go, misc/cgo: skip test if no .edata

Clang does not produce binaries with an .edata section, even when it
exports symbols properly, so just skip this binutils-specific test for
that case. Later we can rewrite these tests entirely to do something
more robust.

Updates #46719.

Change-Id: I864b3c2d91e66800c55454ae11d4ab1623693d14
Reviewed-on: https://go-review.googlesource.com/c/go/+/327549
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 misc/cgo/testcshared/cshared_test.go |  2 +-
 src/cmd/go/go_test.go                | 10 +---------
 2 files changed, 2 insertions(+), 10 deletions(-)

diff --git a/misc/cgo/testcshared/cshared_test.go b/misc/cgo/testcshared/cshared_test.go
index 90d8c365e6..fdc6df9602 100644
--- a/misc/cgo/testcshared/cshared_test.go
+++ b/misc/cgo/testcshared/cshared_test.go
@@ -400,7 +400,7 @@ func main() {
 	defer f.Close()
 	section := f.Section(".edata")
 	if section == nil {
-		t.Fatalf(".edata section is not present")
+		t.Skip(".edata section is not present")
 	}
 
 	// TODO: deduplicate this struct from cmd/link/internal/ld/pe.go
diff --git a/src/cmd/go/go_test.go b/src/cmd/go/go_test.go
index a059a6dd90..c0c86ab9f5 100644
--- a/src/cmd/go/go_test.go
+++ b/src/cmd/go/go_test.go
@@ -72,7 +72,6 @@ func tooSlow(t *testing.T) {
 // (temp) directory.
 var testGOROOT string
 
-var testCC string
 var testGOCACHE string
 
 var testGo string
@@ -179,13 +178,6 @@ func TestMain(m *testing.M) {
 			os.Exit(2)
 		}
 
-		out, err = exec.Command(gotool, "env", "CC").CombinedOutput()
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "could not find testing CC: %v\n%s", err, out)
-			os.Exit(2)
-		}
-		testCC = strings.TrimSpace(string(out))
-
 		cmd := exec.Command(testGo, "env", "CGO_ENABLED")
 		cmd.Stderr = new(strings.Builder)
 		if out, err := cmd.Output(); err != nil {
@@ -2185,7 +2177,7 @@ func testBuildmodePIE(t *testing.T, useCgo, setBuildmodeToPIE bool) {
 			// See https://sourceware.org/bugzilla/show_bug.cgi?id=19011
 			section := f.Section(".edata")
 			if section == nil {
-				t.Fatalf(".edata section is not present")
+				t.Skip(".edata section is not present")
 			}
 			// TODO: deduplicate this struct from cmd/link/internal/ld/pe.go
 			type IMAGE_EXPORT_DIRECTORY struct {
-- 
GitLab


From 14305bf0b9ab87bcaca11416ab61e7a4ba09690d Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Fri, 11 Jun 2021 17:53:29 +0200
Subject: [PATCH 2226/2400] misc/cgo: generate Windows import libraries for
 clang

LLD won't import a .dll directly and instead requires an import library.
So generate these using -out-implib, the same way as was done in CL
312046, where it makes sense, and elsewhere build the import library
using a def file. We can't use -out-implib all the time, because the
output file gets overwritten each time the linker is called, rather than
merged.

Updates #46502.

Change-Id: Iefe54cb6c576004b83b1039ba673881b8640423d
Reviewed-on: https://go-review.googlesource.com/c/go/+/327211
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 misc/cgo/testcshared/cshared_test.go | 56 +++++++++++++++++++++++++++-
 1 file changed, 55 insertions(+), 1 deletion(-)

diff --git a/misc/cgo/testcshared/cshared_test.go b/misc/cgo/testcshared/cshared_test.go
index fdc6df9602..19ad8c76a8 100644
--- a/misc/cgo/testcshared/cshared_test.go
+++ b/misc/cgo/testcshared/cshared_test.go
@@ -292,11 +292,60 @@ func createHeaders() error {
 		"-installsuffix", "testcshared",
 		"-o", libgoname,
 		filepath.Join(".", "libgo", "libgo.go")}
+	if GOOS == "windows" && strings.HasSuffix(args[6], ".a") {
+		args[6] = strings.TrimSuffix(args[6], ".a") + ".dll"
+	}
 	cmd = exec.Command(args[0], args[1:]...)
 	out, err = cmd.CombinedOutput()
 	if err != nil {
 		return fmt.Errorf("command failed: %v\n%v\n%s\n", args, err, out)
 	}
+	if GOOS == "windows" {
+		// We can't simply pass -Wl,--out-implib, because this relies on having imports from multiple packages,
+		// which results in the linkers output implib getting overwritten at each step. So instead build the
+		// import library the traditional way, using a def file.
+		err = os.WriteFile("libgo.def",
+			[]byte("LIBRARY libgo.dll\nEXPORTS\n\tDidInitRun\n\tDidMainRun\n\tDivu\n\tFromPkg\n\t_cgo_dummy_export\n"),
+			0644)
+		if err != nil {
+			return fmt.Errorf("unable to write def file: %v", err)
+		}
+		out, err = exec.Command(cc[0], append(cc[1:], "-print-prog-name=dlltool")...).CombinedOutput()
+		if err != nil {
+			return fmt.Errorf("unable to find dlltool path: %v\n%s\n", err, out)
+		}
+		args := []string{strings.TrimSpace(string(out)), "-D", args[6], "-l", libgoname, "-d", "libgo.def"}
+
+		// This is an unfortunate workaround for https://github.com/mstorsjo/llvm-mingw/issues/205 in which
+		// we basically reimplement the contents of the dlltool.sh wrapper: https://git.io/JZFlU
+		dlltoolContents, err := os.ReadFile(args[0])
+		if err != nil {
+			return fmt.Errorf("unable to read dlltool: %v\n", err)
+		}
+		if bytes.HasPrefix(dlltoolContents, []byte("#!/bin/sh")) && bytes.Contains(dlltoolContents, []byte("llvm-dlltool")) {
+			base, name := filepath.Split(args[0])
+			args[0] = filepath.Join(base, "llvm-dlltool")
+			var machine string
+			switch strings.SplitN(name, "-", 2)[0] {
+			case "i686":
+				machine = "i386"
+			case "x86_64":
+				machine = "i386:x86-64"
+			case "armv7":
+				machine = "arm"
+			case "aarch64":
+				machine = "arm64"
+			}
+			if len(machine) > 0 {
+				args = append(args, "-m", machine)
+			}
+		}
+
+		out, err = exec.Command(args[0], args[1:]...).CombinedOutput()
+		if err != nil {
+			return fmt.Errorf("unable to run dlltool to create import library: %v\n%s\n", err, out)
+		}
+	}
 
 	if runtime.GOOS != GOOS && GOOS == "android" {
 		args = append(adbCmd(), "push", libgoname, fmt.Sprintf("%s/%s", androiddir, libgoname))
@@ -749,7 +798,12 @@ func TestGo2C2Go(t *testing.T) {
 	defer os.RemoveAll(tmpdir)
 
 	lib := filepath.Join(tmpdir, "libtestgo2c2go."+libSuffix)
-	run(t, nil, "go", "build", "-buildmode=c-shared", "-o", lib, "./go2c2go/go")
+	var env []string
+	if GOOS == "windows" && strings.HasSuffix(lib, ".a") {
+		env = append(env, "CGO_LDFLAGS=-Wl,--out-implib,"+lib, "CGO_LDFLAGS_ALLOW=.*")
+		lib = strings.TrimSuffix(lib, ".a") + ".dll"
+	}
+	run(t, env, "go", "build", "-buildmode=c-shared", "-o", lib, "./go2c2go/go")
 
 	cgoCflags := os.Getenv("CGO_CFLAGS")
 	if cgoCflags != "" {
-- 
GitLab


From 3249b645c986849bbf72c1dc71efc4f90df465ec Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Sun, 13 Jun 2021 22:26:21 +0700
Subject: [PATCH 2227/2400] cmd/compile: factor out rewrite multi-valued f()

So next CL can reuse code to rewrite OAS2FUNC.

Passes toolstash -cmp.

For #46725

Change-Id: I1113ed615b6d6b9494dd87000ce342d7a46d9e7b
Reviewed-on: https://go-review.googlesource.com/c/go/+/327650
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 .../compile/internal/typecheck/typecheck.go   | 31 ++++++++++++-------
 1 file changed, 19 insertions(+), 12 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 95f7b50259..391e18bd0a 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -945,16 +945,18 @@ func typecheckargs(n ir.InitNode) {
 		return
 	}
 
-	// Rewrite f(g()) into t1, t2, ... = g(); f(t1, t2, ...).
-
 	// Save n as n.Orig for fmt.go.
 	if ir.Orig(n) == n {
 		n.(ir.OrigNode).SetOrig(ir.SepCopy(n))
 	}
 
-	as := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
-	as.Rhs.Append(list...)
+	// Rewrite f(g()) into t1, t2, ... = g(); f(t1, t2, ...).
+	rewriteMultiValueCall(n, list[0])
+}
 
+// rewriteMultiValueCall rewrites multi-valued f() to use temporaries,
+// so the backend wouldn't need to worry about tuple-valued expressions.
+func rewriteMultiValueCall(n ir.InitNode, call ir.Node) {
 	// If we're outside of function context, then this call will
 	// be executed during the generated init function. However,
 	// init.go hasn't yet created it. Instead, associate the
@@ -964,25 +966,30 @@ func typecheckargs(n ir.InitNode) {
 	if static {
 		ir.CurFunc = InitTodoFunc
 	}
-	list = nil
-	for _, f := range t.FieldSlice() {
-		t := Temp(f.Type)
-		as.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, t))
-		as.Lhs.Append(t)
-		list = append(list, t)
+
+	as := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, []ir.Node{call})
+	results := call.Type().FieldSlice()
+	list := make([]ir.Node, len(results))
+	for i, result := range results {
+		tmp := Temp(result.Type)
+		as.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, tmp))
+		as.Lhs.Append(tmp)
+		list[i] = tmp
 	}
 	if static {
 		ir.CurFunc = nil
 	}
 
+	n.PtrInit().Append(Stmt(as))
+
 	switch n := n.(type) {
+	default:
+		base.Fatalf("rewriteMultiValueCall %+v", n.Op())
 	case *ir.CallExpr:
 		n.Args = list
 	case *ir.ReturnStmt:
 		n.Results = list
 	}
-
-	n.PtrInit().Append(Stmt(as))
 }
 
 func checksliceindex(l ir.Node, r ir.Node, tp *types.Type) bool {
-- 
GitLab


From 326ea438bb579a2010e38e00f515a04344ff96b0 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Sun, 13 Jun 2021 22:28:44 +0700
Subject: [PATCH 2228/2400] cmd/compile: rewrite a, b = f() to use temporaries
 when type not identical

If any of the LHS expressions of an OAS2FUNC are not identical to the
respective function call results, escape analysis mishandles the
implicit conversion, causes memory corruption.

Instead, we should insert autotmps like we already do for f(g()) calls
and return g() statements.

Fixes #46725

Change-Id: I71a08da0bf1a03d09a023da5b6f78fb37a4a4690
Reviewed-on: https://go-review.googlesource.com/c/go/+/327651
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/typecheck/stmt.go    | 14 +++++-
 .../compile/internal/typecheck/typecheck.go   | 10 ++++
 test/declbad.go                               |  4 +-
 test/fixedbugs/issue46725.go                  | 48 +++++++++++++++++++
 4 files changed, 73 insertions(+), 3 deletions(-)
 create mode 100644 test/fixedbugs/issue46725.go

diff --git a/src/cmd/compile/internal/typecheck/stmt.go b/src/cmd/compile/internal/typecheck/stmt.go
index 175216f279..922a01bfbe 100644
--- a/src/cmd/compile/internal/typecheck/stmt.go
+++ b/src/cmd/compile/internal/typecheck/stmt.go
@@ -204,8 +204,20 @@ assignOK:
 		r.Use = ir.CallUseList
 		rtyp := r.Type()
 
+		mismatched := false
+		failed := false
 		for i := range lhs {
-			assignType(i, rtyp.Field(i).Type)
+			result := rtyp.Field(i).Type
+			assignType(i, result)
+
+			if lhs[i].Type() == nil || result == nil {
+				failed = true
+			} else if lhs[i] != ir.BlankNode && !types.Identical(lhs[i].Type(), result) {
+				mismatched = true
+			}
+		}
+		if mismatched && !failed {
+			rewriteMultiValueCall(stmt, r)
 		}
 		return
 	}
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 391e18bd0a..bf52941b2c 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -989,6 +989,16 @@ func rewriteMultiValueCall(n ir.InitNode, call ir.Node) {
 		n.Args = list
 	case *ir.ReturnStmt:
 		n.Results = list
+	case *ir.AssignListStmt:
+		if n.Op() != ir.OAS2FUNC {
+			base.Fatalf("rewriteMultiValueCall: invalid op %v", n.Op())
+		}
+		as.SetOp(ir.OAS2FUNC)
+		n.SetOp(ir.OAS2)
+		n.Rhs = make([]ir.Node, len(list))
+		for i, tmp := range list {
+			n.Rhs[i] = AssignConv(tmp, n.Lhs[i].Type(), "assignment")
+		}
 	}
 }
 
diff --git a/test/declbad.go b/test/declbad.go
index 728eceb7f1..b978652a2b 100644
--- a/test/declbad.go
+++ b/test/declbad.go
@@ -23,13 +23,13 @@ func main() {
 	{
 		// change of type for f
 		i, f, s := f3()
-		f, g, t := f3() // ERROR "redeclared|cannot assign|incompatible"
+		f, g, t := f3() // ERROR "redeclared|cannot assign|incompatible|cannot use"
 		_, _, _, _, _ = i, f, s, g, t
 	}
 	{
 		// change of type for i
 		i, f, s := f3()
-		j, i, t := f3() // ERROR "redeclared|cannot assign|incompatible"
+		j, i, t := f3() // ERROR "redeclared|cannot assign|incompatible|cannot use"
 		_, _, _, _, _ = i, f, s, j, t
 	}
 	{
diff --git a/test/fixedbugs/issue46725.go b/test/fixedbugs/issue46725.go
new file mode 100644
index 0000000000..29799c7d7e
--- /dev/null
+++ b/test/fixedbugs/issue46725.go
@@ -0,0 +1,48 @@
+// run
+
+// Copyright 2021 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"
+
+type T [4]int
+
+//go:noinline
+func g(x []*T) ([]*T, []*T) { return x, x }
+
+func main() {
+	const Jenny = 8675309
+	s := [10]*T{{Jenny}}
+
+	done := make(chan struct{})
+	runtime.SetFinalizer(s[0], func(p *T) { close(done) })
+
+	var h, _ interface{} = g(s[:])
+
+	if wait(done) {
+		panic("GC'd early")
+	}
+
+	if h.([]*T)[0][0] != Jenny {
+		panic("lost Jenny's number")
+	}
+
+	if !wait(done) {
+		panic("never GC'd")
+	}
+}
+
+func wait(done <-chan struct{}) bool {
+	for i := 0; i < 10; i++ {
+		runtime.GC()
+		select {
+		case <-done:
+			return true
+		default:
+		}
+	}
+	return false
+}
-- 
GitLab


From fdab5be159c508c4c1cf5be84119fd2b38403cdf Mon Sep 17 00:00:00 2001
From: Joel Sing <joel@sing.id.au>
Date: Mon, 14 Jun 2021 23:47:10 +1000
Subject: [PATCH 2229/2400] doc/go1.17: further revise OpenBSD release notes

Simplify and remove forward-compatibility reference, as OpenBSD 6.9 has
already been released (1st of May 2021).

Updates #44513

Change-Id: I0a1abbb397f31d15c80a970edaa9723f894cafa9
Reviewed-on: https://go-review.googlesource.com/c/go/+/327652
Trust: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 doc/go1.17.html | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 4fa38921f0..35d0f97450 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -106,8 +106,7 @@ Do not send CLs removing the interior tags from such phrases.
   of directly using machine instructions. In Go 1.17, this is also
   done on the 32-bit x86 and 32-bit ARM architectures on OpenBSD
   (the <code>openbsd/386</code> and <code>openbsd/arm</code> ports).
-  This ensures forward-compatibility with future versions of
-  OpenBSD, in particular, with OpenBSD 6.9 onwards, which requires
+  This ensures compatibility with OpenBSD 6.9 onwards, which require
   system calls to be made through <code>libc</code> for non-static
   Go binaries.
 </p>
-- 
GitLab


From d4f34f8c63b753160716e9f90ca530016ce019d7 Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Mon, 14 Jun 2021 12:35:21 -0400
Subject: [PATCH 2230/2400] doc/go1.17: reword "results" in stack trace
 printing

"Results" may sound like the results from the previous sentence.
Reword to "function return values" for clarity.

Suggested by Tobias Kohlbau.

Change-Id: Ie78df36b5b191b06e98b802f9a46db6d067a8ea0
Reviewed-on: https://go-review.googlesource.com/c/go/+/327774
Trust: Cherry Mui <cherryyz@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Tobias Kohlbau <tobias@kohlbau.de>
---
 doc/go1.17.html | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 35d0f97450..e0856ff83a 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -406,7 +406,8 @@ func Foo() bool {
   by commas. Aggregate-typed (struct, array, string, slice, interface, and complex)
   arguments are delimited by curly braces. A caveat is that the value of an
   argument that only lives in a register and is not stored to memory may be
-  inaccurate. Results (which were usually inaccurate) are no longer printed.
+  inaccurate. Function return values (which were usually inaccurate) are no longer
+  printed.
 </p>
 
 <p><!-- CL 283112, golang.org/issue/28727 -->
-- 
GitLab


From 6bbb0a9d4a086af04d8eb16e17d1b144622a86f5 Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Fri, 11 Jun 2021 17:38:23 +0200
Subject: [PATCH 2231/2400] cmd/internal/sys: mark windows/arm64 as
 c-shared-capable

The platform supports c-shared now, so flip this on. I've given this a
small smoke test using [1], and it was able to pass packets and
generally function well. Since [1] uses quite a bit of Go functionality
under the hood, I think it's a decent test that a lot of things that
should be working are working. So this commit enables it.

[1] https://git.zx2c4.com/wireguard-windows/about/embeddable-dll-service/README.md

Updates #46502.

Change-Id: I5c771d033bd20e5ce472c315d7c207bbc1020b4a
Reviewed-on: https://go-review.googlesource.com/c/go/+/326310
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Trust: Alex Brainman <alex.brainman@gmail.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 src/cmd/dist/test.go              | 2 +-
 src/cmd/internal/sys/supported.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go
index 1ed2c0f631..f2c4cf0b43 100644
--- a/src/cmd/dist/test.go
+++ b/src/cmd/dist/test.go
@@ -1057,7 +1057,7 @@ func (t *tester) supportedBuildmode(mode string) bool {
 			"darwin-amd64", "darwin-arm64",
 			"freebsd-amd64",
 			"android-arm", "android-arm64", "android-386",
-			"windows-amd64", "windows-386":
+			"windows-amd64", "windows-386", "windows-arm64":
 			return true
 		}
 		return false
diff --git a/src/cmd/internal/sys/supported.go b/src/cmd/internal/sys/supported.go
index fa477b837f..0d2bad9612 100644
--- a/src/cmd/internal/sys/supported.go
+++ b/src/cmd/internal/sys/supported.go
@@ -74,7 +74,7 @@ func BuildModeSupported(compiler, buildmode, goos, goarch string) bool {
 			"android/amd64", "android/arm", "android/arm64", "android/386",
 			"freebsd/amd64",
 			"darwin/amd64", "darwin/arm64",
-			"windows/amd64", "windows/386":
+			"windows/amd64", "windows/386", "windows/arm64":
 			return true
 		}
 		return false
-- 
GitLab


From 0fd20ed5b67a950c7085b20c36dbfd9a70d2bfda Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Mon, 14 Jun 2021 14:30:46 -0700
Subject: [PATCH 2232/2400] reflect: use same conversion panic in reflect and
 runtime

Consistently say "pointer to array", not "array pointer".

Fixes #46743

Change-Id: I2388ec5c16f96e82a3a383b9b462b350686ddc5e
Reviewed-on: https://go-review.googlesource.com/c/go/+/327870
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/reflect/all_test.go | 2 +-
 src/reflect/value.go    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/reflect/all_test.go b/src/reflect/all_test.go
index 17104ad4fa..0db5e13217 100644
--- a/src/reflect/all_test.go
+++ b/src/reflect/all_test.go
@@ -4371,7 +4371,7 @@ func TestConvertPanic(t *testing.T) {
 	if !v.Type().ConvertibleTo(pt) {
 		t.Errorf("[]byte should be convertible to *[8]byte")
 	}
-	shouldPanic("reflect: cannot convert slice with length 4 to array pointer with length 8", func() {
+	shouldPanic("reflect: cannot convert slice with length 4 to pointer to array with length 8", func() {
 		_ = v.Convert(pt)
 	})
 }
diff --git a/src/reflect/value.go b/src/reflect/value.go
index c963a407bc..6ba6202a1a 100644
--- a/src/reflect/value.go
+++ b/src/reflect/value.go
@@ -3067,7 +3067,7 @@ func cvtSliceArrayPtr(v Value, t Type) Value {
 	n := t.Elem().Len()
 	h := (*unsafeheader.Slice)(v.ptr)
 	if n > h.Len {
-		panic("reflect: cannot convert slice with length " + itoa.Itoa(h.Len) + " to array pointer with length " + itoa.Itoa(n))
+		panic("reflect: cannot convert slice with length " + itoa.Itoa(h.Len) + " to pointer to array with length " + itoa.Itoa(n))
 	}
 	return Value{t.common(), h.Data, v.flag&^(flagIndir|flagAddr|flagKindMask) | flag(Ptr)}
 }
-- 
GitLab


From 9d13f8d43e88a349762c61aee84614ac83dab521 Mon Sep 17 00:00:00 2001
From: Eric Wang <wangchaogo1990@gmail.com>
Date: Mon, 14 Jun 2021 11:29:33 +0000
Subject: [PATCH 2233/2400] runtime: update the variable name in comment

The comment use allg to refer to allgs in code. Update the comment to
use the same variable name.

Change-Id: Id059fce7846776737fb038b86bcf8765a4a7c9c0
GitHub-Last-Rev: 234fb0a208f105352d33456159725a3fce3a3071
GitHub-Pull-Request: golang/go#46723
Reviewed-on: https://go-review.googlesource.com/c/go/+/327629
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Dmitri Shuralyov <dmitshur@golang.org>
---
 src/runtime/proc.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 59160c6525..8f1a443945 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -529,8 +529,8 @@ var (
 	allglock mutex
 	allgs    []*g
 
-	// allglen and allgptr are atomic variables that contain len(allg) and
-	// &allg[0] respectively. Proper ordering depends on totally-ordered
+	// allglen and allgptr are atomic variables that contain len(allgs) and
+	// &allgs[0] respectively. Proper ordering depends on totally-ordered
 	// loads and stores. Writes are protected by allglock.
 	//
 	// allgptr is updated before allglen. Readers should read allglen
-- 
GitLab


From 8a5a6f46dc51597174d0044dcd3bdffa950ae65e Mon Sep 17 00:00:00 2001
From: Victor Michel <victor@optimyze.cloud>
Date: Fri, 11 Jun 2021 05:44:00 +0000
Subject: [PATCH 2234/2400] debug/elf: don't apply DWARF relocations for
 ET_EXEC binaries

Some ET_EXEC binaries might have relocations for non-loadable sections
like .debug_info. These relocations must not be applied, because:
* They may be incorrect
* The correct relocations were already applied at link time

Binaries in Linux Kernel debug packages like Fedora/Centos kernel-debuginfo
are such examples. Relocations for .debug_* sections are included in the
final binaries because they are compiled with --emit-relocs, but the resulting
relocations are incorrect and shouldn't be used when reading DWARF sections.

Fixes #46673

Change-Id: I2b4214f1584bfc243446d0eaee41512657325b95
GitHub-Last-Rev: 8350fad059e70422d13dfaa5bab7fb8a56c0f76f
GitHub-Pull-Request: golang/go#46698
Reviewed-on: https://go-review.googlesource.com/c/go/+/327009
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 src/debug/elf/file.go | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/debug/elf/file.go b/src/debug/elf/file.go
index cd5bf8fab0..b25d8209e3 100644
--- a/src/debug/elf/file.go
+++ b/src/debug/elf/file.go
@@ -1164,6 +1164,13 @@ func (f *File) DWARF() (*dwarf.Data, error) {
 			b = dbuf
 		}
 
+		if f.Type == ET_EXEC {
+			// Do not apply relocations to DWARF sections for ET_EXEC binaries.
+			// Relocations should already be applied, and .rela sections may
+			// contain incorrect data.
+			return b, nil
+		}
+
 		for _, r := range f.Sections {
 			if r.Type != SHT_RELA && r.Type != SHT_REL {
 				continue
-- 
GitLab


From 7841cb14d95cf64c29b865c8a761a9e00fbbb37c Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Sun, 13 Jun 2021 16:00:28 -0700
Subject: [PATCH 2235/2400] doc/go1.17: assorted fixes

Change-Id: I64235ad920240de9e2414b9ee6f4cfc4006b2862
Reviewed-on: https://go-review.googlesource.com/c/go/+/327709
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 doc/go1.17.html | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index e0856ff83a..642bd60149 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -59,7 +59,7 @@ Do not send CLs removing the interior tags from such phrases.
 </ul>
 
 <p>
-  These enhancements were added to simplify writing code that conforms
+  The package unsafe enhancements were added to simplify writing code that conforms
   to <code>unsafe.Pointer</code>'s <a href="/pkg/unsafe/#Pointer">safety
   rules</a>, but the rules remain unchanged. In particular, existing
   programs that correctly use <code>unsafe.Pointer</code> remain
@@ -735,7 +735,7 @@ func Foo() bool {
       These components were always interpreted as decimal, but some operating systems treat them as octal.
       This mismatch could hypothetically lead to security issues if a Go application was used to validate IP addresses
       which were then used in their original form with non-Go applications which interpreted components as octal. Generally,
-      it is advisable to always re-encoded values after validation, which avoids this class of parser misalignment issues.
+      it is advisable to always re-encode values after validation, which avoids this class of parser misalignment issues.
     </p>
   </dd>
 </dl><!-- net -->
@@ -786,7 +786,7 @@ func Foo() bool {
   <dd>
     <p><!-- CL 268020 -->
       The <a href="/pkg/os/#File.WriteString"><code>File.WriteString</code></a> method
-      has been optimized to no longer make a copy of the input string.
+      has been optimized to not make a copy of the input string.
     </p>
   </dd>
 </dl><!-- os -->
@@ -812,6 +812,14 @@ func Foo() bool {
       The <a href="/pkg/reflect/#ArrayOf"><code>ArrayOf</code></a> function now panics when
       called with a negative length.
     </p>
+
+    <p><!-- CL 301652 -->
+      Checking the <a href="/pkg/reflect/#Type"><code>Type.ConvertibleTo</code></a> method
+      is no longer sufficient to guarantee that a call to
+      <a href="/pkg/reflect/#Value.Convert"><code>Value.Convert</code></a> will not panic.
+      It may panic when converting `[]T` to `*[N]T` if the slice's length is less than N.
+      See the language changes section above.
+    </p>
   </dd>
 </dl><!-- reflect -->
 
@@ -838,7 +846,7 @@ func Foo() bool {
   <dd>
     <p><!-- CL 170079, CL 170080 -->
       The <code>strconv</code> package now uses Ulf Adams's Ryū algorithm for formatting floating-point numbers.
-      This algorithm improves performance on most inputs, and is more than 99% faster on worst-case inputs.
+      This algorithm improves performance on most inputs and is more than 99% faster on worst-case inputs.
     </p>
 
     <p><!-- CL 314775 -->
-- 
GitLab


From cf4e3e3d3b3a713ec4df7e995d5bf5caef045a09 Mon Sep 17 00:00:00 2001
From: Joe Tsai <joetsai@digital-static.net>
Date: Sat, 12 Jun 2021 12:25:12 -0700
Subject: [PATCH 2236/2400] reflect: explain why convertible or comparable
 types may still panic

Conversions of slices to arrays may panic since the slice is too short.
Comparibility of interfaces may panic since the underlying value is incomparable.

This is a follow-up to CL 301652

Change-Id: Ia5d84a6e556a7b82c39add4be93ed7463e63cc8d
Reviewed-on: https://go-review.googlesource.com/c/go/+/327589
Trust: Joe Tsai <joetsai@digital-static.net>
Trust: Joe Tsai <thebrokentoaster@gmail.com>
Run-TryBot: Joe Tsai <thebrokentoaster@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/reflect/type.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/reflect/type.go b/src/reflect/type.go
index 39414fc2a6..df863ae106 100644
--- a/src/reflect/type.go
+++ b/src/reflect/type.go
@@ -107,10 +107,14 @@ type Type interface {
 
 	// ConvertibleTo reports whether a value of the type is convertible to type u.
 	// Even if ConvertibleTo returns true, the conversion may still panic.
+	// For example, a slice of type []T is convertible to *[N]T,
+	// but the conversion will panic if its length is less than N.
 	ConvertibleTo(u Type) bool
 
 	// Comparable reports whether values of this type are comparable.
 	// Even if Comparable returns true, the comparison may still panic.
+	// For example, values of interface type are comparable,
+	// but the comparison will panic if their dynamic type is not comparable.
 	Comparable() bool
 
 	// Methods applicable only to some types, depending on Kind.
-- 
GitLab


From 4061d3463bb02def972e24aff173b0e5f98c0c3d Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Tue, 15 Jun 2021 01:55:50 +0200
Subject: [PATCH 2237/2400] syscall: rewrite handle inheritance test to use C
 rather than Powershell

In CL 327210, we disabled this test on arm platforms, because the
powershell shipped with those systems isn't native, which means it'd
refuse to load native DLLs. This commit rewrites the test to simply not
use Powershell, and instead compiles a trivial C program that tests for
the same thing. Reverting CL 316269 makes this test fail, as desired,
while applying it makes this test succeed.

Fixes #46701

Change-Id: If39612c57bf74c63adf58e2c49b5cb739b461fe5
Reviewed-on: https://go-review.googlesource.com/c/go/+/327969
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Trust: Alex Brainman <alex.brainman@gmail.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
---
 src/syscall/syscall_windows_test.go | 38 +++++++++++++++++------------
 1 file changed, 22 insertions(+), 16 deletions(-)

diff --git a/src/syscall/syscall_windows_test.go b/src/syscall/syscall_windows_test.go
index 3243952ded..581a246cd9 100644
--- a/src/syscall/syscall_windows_test.go
+++ b/src/syscall/syscall_windows_test.go
@@ -10,7 +10,6 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
-	"runtime"
 	"strings"
 	"syscall"
 	"testing"
@@ -80,9 +79,6 @@ func TestTOKEN_ALL_ACCESS(t *testing.T) {
 func TestStdioAreInheritable(t *testing.T) {
 	testenv.MustHaveGoBuild(t)
 	testenv.MustHaveExecPath(t, "gcc")
-	if runtime.GOARCH == "arm64" || runtime.GOARCH == "arm" {
-		t.Skip("Powershell is not native on ARM; see golang.org/issues/46701")
-	}
 
 	tmpdir := t.TempDir()
 
@@ -114,18 +110,28 @@ func main() {}
 		t.Fatalf("failed to build go library: %s\n%s", err, out)
 	}
 
-	// run powershell script
-	psscript := fmt.Sprintf(`
-hostname;
-$signature = " [DllImport("%q")] public static extern void HelloWorld(); ";
-Add-Type -MemberDefinition $signature -Name World -Namespace Hello;
-[Hello.World]::HelloWorld();
-hostname;
-`, dll)
-	psscript = strings.ReplaceAll(psscript, "\n", "")
-	out, err = exec.Command("powershell", "-Command", psscript).CombinedOutput()
+	// build c exe
+	const exetext = `
+#include <stdlib.h>
+#include <windows.h>
+int main(int argc, char *argv[])
+{
+	system("hostname");
+	((void(*)(void))GetProcAddress(LoadLibraryA(%q), "HelloWorld"))();
+	system("hostname");
+	return 0;
+}
+`
+	exe := filepath.Join(tmpdir, "helloworld.exe")
+	cmd = exec.Command("gcc", "-o", exe, "-xc", "-")
+	cmd.Stdin = strings.NewReader(fmt.Sprintf(exetext, dll))
+	out, err = testenv.CleanCmdEnv(cmd).CombinedOutput()
+	if err != nil {
+		t.Fatalf("failed to build c executable: %s\n%s", err, out)
+	}
+	out, err = exec.Command(exe).CombinedOutput()
 	if err != nil {
-		t.Fatalf("Powershell command failed: %v: %v", err, string(out))
+		t.Fatalf("c program execution failed: %v: %v", err, string(out))
 	}
 
 	hostname, err := os.Hostname()
@@ -137,6 +143,6 @@ hostname;
 	have = strings.ReplaceAll(have, "\r", "")
 	want := fmt.Sprintf("%sHello World%s", hostname, hostname)
 	if have != want {
-		t.Fatalf("Powershell command output is wrong: got %q, want %q", have, want)
+		t.Fatalf("c program output is wrong: got %q, want %q", have, want)
 	}
 }
-- 
GitLab


From abc56fd1a0505d4fc27943cbcda81ac783fb2d2f Mon Sep 17 00:00:00 2001
From: cuishuang <imcusg@gmail.com>
Date: Tue, 15 Jun 2021 10:11:06 +0000
Subject: [PATCH 2238/2400] internal/bytealg: remove duplicate go:build line

Change-Id: I6b71bf468b9544820829f02e320673f5edd785fa
GitHub-Last-Rev: 8082ac5fba18e630dd2a21771837e6f0b1f9853f
GitHub-Pull-Request: golang/go#46683
Reviewed-on: https://go-review.googlesource.com/c/go/+/326730
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/internal/bytealg/index_generic.go | 1 -
 src/internal/bytealg/index_native.go  | 1 -
 2 files changed, 2 deletions(-)

diff --git a/src/internal/bytealg/index_generic.go b/src/internal/bytealg/index_generic.go
index 287bdba4c6..0a6eb90d2d 100644
--- a/src/internal/bytealg/index_generic.go
+++ b/src/internal/bytealg/index_generic.go
@@ -2,7 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// go:build !amd64 && !arm64 && !s390x && !ppc64le && !ppc64
 //go:build !amd64 && !arm64 && !s390x && !ppc64le && !ppc64
 // +build !amd64,!arm64,!s390x,!ppc64le,!ppc64
 
diff --git a/src/internal/bytealg/index_native.go b/src/internal/bytealg/index_native.go
index 75aff4b3cb..9547a5d8e2 100644
--- a/src/internal/bytealg/index_native.go
+++ b/src/internal/bytealg/index_native.go
@@ -2,7 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// go:build amd64 || arm64 || s390x || ppc64le || ppc64
 //go:build amd64 || arm64 || s390x || ppc64le || ppc64
 // +build amd64 arm64 s390x ppc64le ppc64
 
-- 
GitLab


From ea8612ef42bfbf837e22aef669e9f715100e532a Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Tue, 15 Jun 2021 17:04:01 +0200
Subject: [PATCH 2239/2400] syscall: disable c-shared test when no cgo, for
 windows/arm

The windows/arm port does not yet support cgo, so disable a test that
requires it. This fixes a regression from CL 327969, which added support
for arm64, but errantly dropped the t.Skip for both arm and arm64,
rather than just for arm64. With this commit, we make the test specific
to cgo, rather than the architecture.

Change-Id: Ibe1166c1965e007c7af899b07ded65f2a2633ddd
Reviewed-on: https://go-review.googlesource.com/c/go/+/327970
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/syscall/syscall_windows_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/syscall/syscall_windows_test.go b/src/syscall/syscall_windows_test.go
index 581a246cd9..194c87805c 100644
--- a/src/syscall/syscall_windows_test.go
+++ b/src/syscall/syscall_windows_test.go
@@ -78,6 +78,7 @@ func TestTOKEN_ALL_ACCESS(t *testing.T) {
 
 func TestStdioAreInheritable(t *testing.T) {
 	testenv.MustHaveGoBuild(t)
+	testenv.MustHaveCGO(t)
 	testenv.MustHaveExecPath(t, "gcc")
 
 	tmpdir := t.TempDir()
-- 
GitLab


From 033d885315dd67c509d6f7f12f3e3a26bb1ca127 Mon Sep 17 00:00:00 2001
From: Michael Matloob <matloob@golang.org>
Date: Thu, 10 Jun 2021 17:02:44 -0400
Subject: [PATCH 2240/2400] doc/go1.17: document go run pkg@version

Fixes #46687

Change-Id: I6c311f15d3871a9824306b901fa0b81818ed2df8
Reviewed-on: https://go-review.googlesource.com/c/go/+/326870
Trust: Michael Matloob <matloob@golang.org>
Run-TryBot: Michael Matloob <matloob@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 doc/go1.17.html | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 642bd60149..75c05c9e25 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -292,6 +292,18 @@ Do not send CLs removing the interior tags from such phrases.
   <a href="https://golang.org/design/draft-gobuild">https://golang.org/design/draft-gobuild</a>.
 </p>
 
+<h4 id="go run"><code>go</code> <code>run</code></h4>
+
+<p><!-- golang.org/issue/42088 -->
+  <code>go</code> <code>run</code> now accepts arguments with version suffixes
+  (for example, <code>go</code> <code>run</code>
+  <code>example.com/cmd@v1.0.0</code>).  This causes <code>go</code>
+  <code>run</code> to build and run packages in module-aware mode, ignoring the
+  <code>go.mod</code> file in the current directory or any parent directory, if
+  there is one. This is useful for running executables without installing them or
+  without changing dependencies of the current module.
+</p>
+
 <h3 id="gofmt">Gofmt</h3>
 
 <p>
-- 
GitLab


From 4d2d89ff42ca07eac5e600a3f5bba8fb137b6e99 Mon Sep 17 00:00:00 2001
From: Damien Neil <dneil@google.com>
Date: Wed, 2 Jun 2021 14:39:53 -0700
Subject: [PATCH 2241/2400] cmd/go, go/build: update docs to use //go:build
 syntax

Fixes #46124.

Change-Id: I6b8179032102a14befc37719f64ddace98397c97
Reviewed-on: https://go-review.googlesource.com/c/go/+/326931
Trust: Damien Neil <dneil@google.com>
Run-TryBot: Damien Neil <dneil@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/cmd/go/alldocs.go               | 42 +++++++++++++----------------
 src/cmd/go/internal/help/helpdoc.go | 42 +++++++++++++----------------
 src/go/build/doc.go                 |  2 +-
 3 files changed, 37 insertions(+), 49 deletions(-)

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index ab61017c4e..3febe880cd 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -1568,7 +1568,7 @@
 //
 // A build constraint, also known as a build tag, is a line comment that begins
 //
-// 	// +build
+// 	//go:build
 //
 // that lists the conditions under which a file should be included in the package.
 // Constraints may appear in any kind of source file (not just Go), but
@@ -1576,30 +1576,20 @@
 // only by blank lines and other line comments. These rules mean that in Go
 // files a build constraint must appear before the package clause.
 //
-// To distinguish build constraints from package documentation, a series of
-// build constraints must be followed by a blank line.
+// To distinguish build constraints from package documentation,
+// a build constraint should be followed by a blank line.
 //
-// A build constraint is evaluated as the OR of space-separated options.
-// Each option evaluates as the AND of its comma-separated terms.
-// Each term consists of letters, digits, underscores, and dots.
-// A term may be negated with a preceding !.
-// For example, the build constraint:
+// A build constraint is evaluated as an expression containing options
+// combined by ||, &&, and ! operators and parentheses. Operators have
+// the same meaning as in Go.
 //
-// 	// +build linux,386 darwin,!cgo
+// For example, the following build constraint constrains a file to
+// build when the "linux" and "386" constraints are satisfied, or when
+// "darwin" is satisfied and "cgo" is not:
 //
-// corresponds to the boolean formula:
+// 	//go:build (linux && 386) || (darwin && !cgo)
 //
-// 	(linux AND 386) OR (darwin AND (NOT cgo))
-//
-// A file may have multiple build constraints. The overall constraint is the AND
-// of the individual constraints. That is, the build constraints:
-//
-// 	// +build linux darwin
-// 	// +build amd64
-//
-// corresponds to the boolean formula:
-//
-// 	(linux OR darwin) AND amd64
+// It is an error for a file to have more than one //go:build line.
 //
 // During a particular build, the following words are satisfied:
 //
@@ -1637,24 +1627,28 @@
 //
 // To keep a file from being considered for the build:
 //
-// 	// +build ignore
+// 	//go:build ignore
 //
 // (any other unsatisfied word will work as well, but "ignore" is conventional.)
 //
 // To build a file only when using cgo, and only on Linux and OS X:
 //
-// 	// +build linux,cgo darwin,cgo
+// 	//go:build cgo && (linux || darwin)
 //
 // Such a file is usually paired with another file implementing the
 // default functionality for other systems, which in this case would
 // carry the constraint:
 //
-// 	// +build !linux,!darwin !cgo
+// 	//go:build !(cgo && (linux || darwin))
 //
 // Naming a file dns_windows.go will cause it to be included only when
 // building the package for Windows; similarly, math_386.s will be included
 // only when building the package for 32-bit x86.
 //
+// Go versions 1.16 and earlier used a different syntax for build constraints,
+// with a "// +build" prefix. The gofmt command will add an equivalent //go:build
+// constraint when encountering the older syntax.
+//
 //
 // Build modes
 //
diff --git a/src/cmd/go/internal/help/helpdoc.go b/src/cmd/go/internal/help/helpdoc.go
index 2f86e4195d..9ec6501892 100644
--- a/src/cmd/go/internal/help/helpdoc.go
+++ b/src/cmd/go/internal/help/helpdoc.go
@@ -784,7 +784,7 @@ var HelpBuildConstraint = &base.Command{
 	Long: `
 A build constraint, also known as a build tag, is a line comment that begins
 
-	// +build
+	//go:build
 
 that lists the conditions under which a file should be included in the package.
 Constraints may appear in any kind of source file (not just Go), but
@@ -792,30 +792,20 @@ they must appear near the top of the file, preceded
 only by blank lines and other line comments. These rules mean that in Go
 files a build constraint must appear before the package clause.
 
-To distinguish build constraints from package documentation, a series of
-build constraints must be followed by a blank line.
+To distinguish build constraints from package documentation,
+a build constraint should be followed by a blank line.
 
-A build constraint is evaluated as the OR of space-separated options.
-Each option evaluates as the AND of its comma-separated terms.
-Each term consists of letters, digits, underscores, and dots.
-A term may be negated with a preceding !.
-For example, the build constraint:
+A build constraint is evaluated as an expression containing options
+combined by ||, &&, and ! operators and parentheses. Operators have
+the same meaning as in Go.
 
-	// +build linux,386 darwin,!cgo
+For example, the following build constraint constrains a file to
+build when the "linux" and "386" constraints are satisfied, or when
+"darwin" is satisfied and "cgo" is not:
 
-corresponds to the boolean formula:
+	//go:build (linux && 386) || (darwin && !cgo)
 
-	(linux AND 386) OR (darwin AND (NOT cgo))
-
-A file may have multiple build constraints. The overall constraint is the AND
-of the individual constraints. That is, the build constraints:
-
-	// +build linux darwin
-	// +build amd64
-
-corresponds to the boolean formula:
-
-	(linux OR darwin) AND amd64
+It is an error for a file to have more than one //go:build line.
 
 During a particular build, the following words are satisfied:
 
@@ -853,22 +843,26 @@ in addition to ios tags and files.
 
 To keep a file from being considered for the build:
 
-	// +build ignore
+	//go:build ignore
 
 (any other unsatisfied word will work as well, but "ignore" is conventional.)
 
 To build a file only when using cgo, and only on Linux and OS X:
 
-	// +build linux,cgo darwin,cgo
+	//go:build cgo && (linux || darwin)
 
 Such a file is usually paired with another file implementing the
 default functionality for other systems, which in this case would
 carry the constraint:
 
-	// +build !linux,!darwin !cgo
+	//go:build !(cgo && (linux || darwin))
 
 Naming a file dns_windows.go will cause it to be included only when
 building the package for Windows; similarly, math_386.s will be included
 only when building the package for 32-bit x86.
+
+Go versions 1.16 and earlier used a different syntax for build constraints,
+with a "// +build" prefix. The gofmt command will add an equivalent //go:build
+constraint when encountering the older syntax.
 `,
 }
diff --git a/src/go/build/doc.go b/src/go/build/doc.go
index 2c6f0a83be..778b4f40f7 100644
--- a/src/go/build/doc.go
+++ b/src/go/build/doc.go
@@ -59,7 +59,7 @@
 //
 // A build constraint, also known as a build tag, is a line comment that begins
 //
-// 	// +build
+// 	//go:build
 //
 // that lists the conditions under which a file should be included in the
 // package. Build constraints may also be part of a file's name
-- 
GitLab


From 723f199edd8619c8eedc1c4e8df1e5f96599d51a Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Tue, 15 Jun 2021 08:01:54 -0400
Subject: [PATCH 2242/2400] cmd/link: set correct flags in .dynamic for PIE
 buildmode

For internal linking, when generating a PIE binary, set the proper
.dynamic section flags to mark the binary as position-independent.

Fixes #46747.

Change-Id: I2b899148c6d06f92c9d12257a9761278b4236dfc
Reviewed-on: https://go-review.googlesource.com/c/go/+/328089
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
Trust: Than McIntosh <thanm@google.com>
---
 src/cmd/link/internal/ld/elf.go | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/cmd/link/internal/ld/elf.go b/src/cmd/link/internal/ld/elf.go
index 6f81e74da2..81011638bc 100644
--- a/src/cmd/link/internal/ld/elf.go
+++ b/src/cmd/link/internal/ld/elf.go
@@ -950,6 +950,11 @@ func elfdynhash(ctxt *Link) {
 	}
 
 	s = ldr.CreateSymForUpdate(".dynamic", 0)
+	if ctxt.BuildMode == BuildModePIE {
+		// https://github.com/bminor/glibc/blob/895ef79e04a953cac1493863bcae29ad85657ee1/elf/elf.h#L986
+		const DTFLAGS_1_PIE = 0x08000000
+		Elfwritedynent(ctxt.Arch, s, elf.DT_FLAGS_1, uint64(DTFLAGS_1_PIE))
+	}
 	elfverneed = nfile
 	if elfverneed != 0 {
 		elfWriteDynEntSym(ctxt, s, elf.DT_VERNEED, gnuVersionR.Sym())
-- 
GitLab


From 219fe9d547d09d3de1b024c6c8b8314dd0bf12e4 Mon Sep 17 00:00:00 2001
From: unbyte <i@shangyes.net>
Date: Tue, 15 Jun 2021 17:11:05 +0000
Subject: [PATCH 2243/2400] cmd/go: ignore UTF8 BOM when reading source code

Fix the problem that UTF8 BOM can cause the parsing of import path and directives to fail.

Fixes #46198
Fixes #46290
Fixes #35726

Change-Id: I2d9995ee82b094bcfa5583f0cb4e8547cb973077
GitHub-Last-Rev: 98abf91377f155266fa60505c0c12beccad38eeb
GitHub-Pull-Request: golang/go#46643
Reviewed-on: https://go-review.googlesource.com/c/go/+/325990
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Trust: Bryan C. Mills <bcmills@google.com>
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/internal/imports/read.go           | 18 ++++++++--
 src/cmd/go/internal/imports/read_test.go      | 26 ++++++++++++++
 .../script/build_ignore_leading_bom.txt       | 27 ++++++++++++++
 src/go/build/read.go                          | 13 ++++++-
 src/go/build/read_test.go                     | 36 +++++++++++++++++++
 5 files changed, 117 insertions(+), 3 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/build_ignore_leading_bom.txt

diff --git a/src/cmd/go/internal/imports/read.go b/src/cmd/go/internal/imports/read.go
index 5e270781d7..70d5190450 100644
--- a/src/cmd/go/internal/imports/read.go
+++ b/src/cmd/go/internal/imports/read.go
@@ -8,6 +8,7 @@ package imports
 
 import (
 	"bufio"
+	"bytes"
 	"errors"
 	"io"
 	"unicode/utf8"
@@ -22,6 +23,19 @@ type importReader struct {
 	nerr int
 }
 
+var bom = []byte{0xef, 0xbb, 0xbf}
+
+func newImportReader(b *bufio.Reader) *importReader {
+	// Remove leading UTF-8 BOM.
+	// Per https://golang.org/ref/spec#Source_code_representation:
+	// a compiler may ignore a UTF-8-encoded byte order mark (U+FEFF)
+	// if it is the first Unicode code point in the source text.
+	if leadingBytes, err := b.Peek(3); err == nil && bytes.Equal(leadingBytes, bom) {
+		b.Discard(3)
+	}
+	return &importReader{b: b}
+}
+
 func isIdent(c byte) bool {
 	return 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || '0' <= c && c <= '9' || c == '_' || c >= utf8.RuneSelf
 }
@@ -201,7 +215,7 @@ func (r *importReader) readImport(imports *[]string) {
 // ReadComments is like io.ReadAll, except that it only reads the leading
 // block of comments in the file.
 func ReadComments(f io.Reader) ([]byte, error) {
-	r := &importReader{b: bufio.NewReader(f)}
+	r := newImportReader(bufio.NewReader(f))
 	r.peekByte(true)
 	if r.err == nil && !r.eof {
 		// Didn't reach EOF, so must have found a non-space byte. Remove it.
@@ -213,7 +227,7 @@ func ReadComments(f io.Reader) ([]byte, error) {
 // ReadImports is like io.ReadAll, except that it expects a Go file as input
 // and stops reading the input once the imports have completed.
 func ReadImports(f io.Reader, reportSyntaxError bool, imports *[]string) ([]byte, error) {
-	r := &importReader{b: bufio.NewReader(f)}
+	r := newImportReader(bufio.NewReader(f))
 
 	r.readKeyword("package")
 	r.readIdent()
diff --git a/src/cmd/go/internal/imports/read_test.go b/src/cmd/go/internal/imports/read_test.go
index 6ea356f1ff..6a1a6524a1 100644
--- a/src/cmd/go/internal/imports/read_test.go
+++ b/src/cmd/go/internal/imports/read_test.go
@@ -66,6 +66,10 @@ var readImportsTests = []readTest{
 		`,
 		"",
 	},
+	{
+		"\ufeff𝔻" + `package p; import "x";ℙvar x = 1`,
+		"",
+	},
 }
 
 var readCommentsTests = []readTest{
@@ -81,6 +85,10 @@ var readCommentsTests = []readTest{
 		`ℙpackage p; import . "x"`,
 		"",
 	},
+	{
+		"\ufeff𝔻" + `ℙpackage p; import . "x"`,
+		"",
+	},
 	{
 		`// foo
 
@@ -90,6 +98,19 @@ var readCommentsTests = []readTest{
 		
 		/*/ zot */
 
+		// asdf
+		ℙHello, world`,
+		"",
+	},
+	{
+		"\ufeff𝔻" + `// foo
+
+		/* bar */
+
+		/* quux */ // baz
+
+		/*/ zot */
+
 		// asdf
 		ℙHello, world`,
 		"",
@@ -107,6 +128,11 @@ func testRead(t *testing.T, tests []readTest, read func(io.Reader) ([]byte, erro
 			in = tt.in[:j] + tt.in[j+len("ℙ"):]
 			testOut = tt.in[:j]
 		}
+		d := strings.Index(tt.in, "𝔻")
+		if d >= 0 {
+			in = in[:d] + in[d+len("𝔻"):]
+			testOut = testOut[d+len("𝔻"):]
+		}
 		r := strings.NewReader(in)
 		buf, err := read(r)
 		if err != nil {
diff --git a/src/cmd/go/testdata/script/build_ignore_leading_bom.txt b/src/cmd/go/testdata/script/build_ignore_leading_bom.txt
new file mode 100644
index 0000000000..37141f3466
--- /dev/null
+++ b/src/cmd/go/testdata/script/build_ignore_leading_bom.txt
@@ -0,0 +1,27 @@
+# Per https://golang.org/ref/spec#Source_code_representation:
+# a compiler may ignore a UTF-8-encoded byte order mark (U+FEFF)
+# if it is the first Unicode code point in the source text.
+
+go list -f 'Imports: {{.Imports}} EmbedFiles: {{.EmbedFiles}}' .
+stdout '^Imports: \[embed m/hello\] EmbedFiles: \[.*file\]$'
+
+-- go.mod --
+module m
+
+go 1.16
+-- m.go --
+package main
+
+import (
+	_ "embed"
+
+	"m/hello"
+)
+
+//go:embed file
+var s string
+
+-- hello/hello.go --
+package hello
+
+-- file --
diff --git a/src/go/build/read.go b/src/go/build/read.go
index aa7c6ee59e..b98c7938a8 100644
--- a/src/go/build/read.go
+++ b/src/go/build/read.go
@@ -6,6 +6,7 @@ package build
 
 import (
 	"bufio"
+	"bytes"
 	"errors"
 	"fmt"
 	"go/ast"
@@ -28,9 +29,19 @@ type importReader struct {
 	pos  token.Position
 }
 
+var bom = []byte{0xef, 0xbb, 0xbf}
+
 func newImportReader(name string, r io.Reader) *importReader {
+	b := bufio.NewReader(r)
+	// Remove leading UTF-8 BOM.
+	// Per https://golang.org/ref/spec#Source_code_representation:
+	// a compiler may ignore a UTF-8-encoded byte order mark (U+FEFF)
+	// if it is the first Unicode code point in the source text.
+	if leadingBytes, err := b.Peek(3); err == nil && bytes.Equal(leadingBytes, bom) {
+		b.Discard(3)
+	}
 	return &importReader{
-		b: bufio.NewReader(r),
+		b: b,
 		pos: token.Position{
 			Filename: name,
 			Line:     1,
diff --git a/src/go/build/read_test.go b/src/go/build/read_test.go
index 32e6bae008..1e5e1c2de2 100644
--- a/src/go/build/read_test.go
+++ b/src/go/build/read_test.go
@@ -66,6 +66,10 @@ var readGoInfoTests = []readTest{
 		`,
 		"",
 	},
+	{
+		"\ufeff𝔻" + `package p; import "x";ℙvar x = 1`,
+		"",
+	},
 }
 
 var readCommentsTests = []readTest{
@@ -81,6 +85,10 @@ var readCommentsTests = []readTest{
 		`ℙpackage p; import . "x"`,
 		"",
 	},
+	{
+		"\ufeff𝔻" + `ℙpackage p; import . "x"`,
+		"",
+	},
 	{
 		`// foo
 
@@ -90,6 +98,19 @@ var readCommentsTests = []readTest{
 
 		/*/ zot */
 
+		// asdf
+		ℙHello, world`,
+		"",
+	},
+	{
+		"\ufeff𝔻" + `// foo
+
+		/* bar */
+
+		/* quux */ // baz
+
+		/*/ zot */
+
 		// asdf
 		ℙHello, world`,
 		"",
@@ -107,6 +128,11 @@ func testRead(t *testing.T, tests []readTest, read func(io.Reader) ([]byte, erro
 			in = tt.in[:j] + tt.in[j+len("ℙ"):]
 			testOut = tt.in[:j]
 		}
+		d := strings.Index(tt.in, "𝔻")
+		if d >= 0 {
+			in = in[:d] + in[d+len("𝔻"):]
+			testOut = testOut[d+len("𝔻"):]
+		}
 		r := strings.NewReader(in)
 		buf, err := read(r)
 		if err != nil {
@@ -264,6 +290,12 @@ var readEmbedTests = []struct {
 		 test:3:14:y
 		 test:3:16:z`,
 	},
+	{
+		"\ufeffpackage p\nimport \"embed\"\n//go:embed x y z\nvar files embed.FS",
+		`test:3:12:x
+		 test:3:14:y
+		 test:3:16:z`,
+	},
 	{
 		"package p\nimport \"embed\"\nvar s = \"/*\"\n//go:embed x\nvar files embed.FS",
 		`test:4:12:x`,
@@ -292,6 +324,10 @@ var readEmbedTests = []struct {
 		"package p\n//go:embed x y z\nvar files embed.FS", // no import, no scan
 		"",
 	},
+	{
+		"\ufeffpackage p\n//go:embed x y z\nvar files embed.FS", // no import, no scan
+		"",
+	},
 }
 
 func TestReadEmbed(t *testing.T) {
-- 
GitLab


From d77f4c0c5c966c37960cd691656fba184ae770ff Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Thu, 9 Jul 2020 18:49:05 -0400
Subject: [PATCH 2244/2400] net/http: improve some server docs

Change-Id: I04662a08e07c49f629f9067a89bf453e697d44dd
Reviewed-on: https://go-review.googlesource.com/c/go/+/327813
Trust: Filippo Valsorda <filippo@golang.org>
Run-TryBot: Filippo Valsorda <filippo@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Damien Neil <dneil@google.com>
---
 src/net/http/server.go | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/net/http/server.go b/src/net/http/server.go
index 50fab4520d..5b113cff97 100644
--- a/src/net/http/server.go
+++ b/src/net/http/server.go
@@ -333,7 +333,7 @@ func (c *conn) hijackLocked() (rwc net.Conn, buf *bufio.ReadWriter, err error) {
 const bufferBeforeChunkingSize = 2048
 
 // chunkWriter writes to a response's conn buffer, and is the writer
-// wrapped by the response.bufw buffered writer.
+// wrapped by the response.w buffered writer.
 //
 // chunkWriter also is responsible for finalizing the Header, including
 // conditionally setting the Content-Type and setting a Content-Length
@@ -1529,12 +1529,12 @@ func (w *response) bodyAllowed() bool {
 // The Writers are wired together like:
 //
 // 1. *response (the ResponseWriter) ->
-// 2. (*response).w, a *bufio.Writer of bufferBeforeChunkingSize bytes
+// 2. (*response).w, a *bufio.Writer of bufferBeforeChunkingSize bytes ->
 // 3. chunkWriter.Writer (whose writeHeader finalizes Content-Length/Type)
-//    and which writes the chunk headers, if needed.
-// 4. conn.buf, a bufio.Writer of default (4kB) bytes, writing to ->
+//    and which writes the chunk headers, if needed ->
+// 4. conn.bufw, a *bufio.Writer of default (4kB) bytes, writing to ->
 // 5. checkConnErrorWriter{c}, which notes any non-nil error on Write
-//    and populates c.werr with it if so. but otherwise writes to:
+//    and populates c.werr with it if so, but otherwise writes to ->
 // 6. the rwc, the net.Conn.
 //
 // TODO(bradfitz): short-circuit some of the buffering when the
-- 
GitLab


From a752bc07462f01a4c1ee1940c3ea316b270af146 Mon Sep 17 00:00:00 2001
From: Rahul Bajaj <rahulrb0509@gmail.com>
Date: Tue, 15 Jun 2021 13:23:10 +0000
Subject: [PATCH 2245/2400] syscall: fix TestGroupCleanupUserNamespace test
 failure on Fedora

Fixes #46752

Change-Id: I2eaa9d15fac4e859e18191fcf1372e5be94899df
GitHub-Last-Rev: 8a2672d8dc6713ec6cbd207d870e893062c8fe5b
GitHub-Pull-Request: golang/go#46753
Reviewed-on: https://go-review.googlesource.com/c/go/+/328109
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/syscall/exec_linux_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/syscall/exec_linux_test.go b/src/syscall/exec_linux_test.go
index 7d89eaae63..85b59ad00d 100644
--- a/src/syscall/exec_linux_test.go
+++ b/src/syscall/exec_linux_test.go
@@ -318,6 +318,7 @@ func TestGroupCleanupUserNamespace(t *testing.T) {
 		"uid=0(root) gid=0(root) groups=0(root),65534",
 		"uid=0(root) gid=0(root) groups=0(root),65534(nobody),65534(nobody),65534(nobody),65534(nobody),65534(nobody),65534(nobody),65534(nobody),65534(nobody),65534(nobody),65534(nobody)", // Alpine; see https://golang.org/issue/19938
 		"uid=0(root) gid=0(root) groups=0(root) context=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023",                                                                               // CentOS with SELinux context, see https://golang.org/issue/34547
+		"uid=0(root) gid=0(root) groups=0(root),65534(nobody) context=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023",                                                                 // Fedora with SElinux context, see https://golang.org/issue/46752
 	}
 	for _, e := range expected {
 		if strOut == e {
-- 
GitLab


From 785a8f677fbba9432ee67b14d41004ba7fd35ddb Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Tue, 15 Jun 2021 21:40:49 +0700
Subject: [PATCH 2246/2400] cmd/compile: better error message for invalid
 untyped operation

For typed vs un-typed operation, the compiler do the conversion
un-conditionally, so if the operation is invalid, the error report is
pointed to the conversion, instead of the invalid operation itself.

To fix this, only do the conversion when the operations are valid
for both types.

Fixes #46749

Change-Id: Ib71c7bcd3ed5454e6df55b6a8db4e0f189259ba7
Reviewed-on: https://go-review.googlesource.com/c/go/+/328050
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/typecheck/const.go | 20 ++++++-----
 test/fixedbugs/issue46749.go                | 37 +++++++++++++++++++++
 test/run.go                                 |  1 +
 3 files changed, 50 insertions(+), 8 deletions(-)
 create mode 100644 test/fixedbugs/issue46749.go

diff --git a/src/cmd/compile/internal/typecheck/const.go b/src/cmd/compile/internal/typecheck/const.go
index 5a35eeade9..761b043794 100644
--- a/src/cmd/compile/internal/typecheck/const.go
+++ b/src/cmd/compile/internal/typecheck/const.go
@@ -633,6 +633,17 @@ func defaultlit2(l ir.Node, r ir.Node, force bool) (ir.Node, ir.Node) {
 	if l.Type() == nil || r.Type() == nil {
 		return l, r
 	}
+
+	if !l.Type().IsInterface() && !r.Type().IsInterface() {
+		// Can't mix bool with non-bool, string with non-string.
+		if l.Type().IsBoolean() != r.Type().IsBoolean() {
+			return l, r
+		}
+		if l.Type().IsString() != r.Type().IsString() {
+			return l, r
+		}
+	}
+
 	if !l.Type().IsUntyped() {
 		r = convlit(r, l.Type())
 		return l, r
@@ -647,17 +658,10 @@ func defaultlit2(l ir.Node, r ir.Node, force bool) (ir.Node, ir.Node) {
 		return l, r
 	}
 
-	// Can't mix bool with non-bool, string with non-string, or nil with anything (untyped).
-	if l.Type().IsBoolean() != r.Type().IsBoolean() {
-		return l, r
-	}
-	if l.Type().IsString() != r.Type().IsString() {
-		return l, r
-	}
+	// Can't mix nil with anything untyped.
 	if ir.IsNil(l) || ir.IsNil(r) {
 		return l, r
 	}
-
 	t := defaultType(mixUntyped(l.Type(), r.Type()))
 	l = convlit(l, t)
 	r = convlit(r, t)
diff --git a/test/fixedbugs/issue46749.go b/test/fixedbugs/issue46749.go
new file mode 100644
index 0000000000..63ed19795e
--- /dev/null
+++ b/test/fixedbugs/issue46749.go
@@ -0,0 +1,37 @@
+// errorcheck
+
+// Copyright 2021 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 p
+
+var s string
+var b bool
+var i int
+var iface interface{}
+
+var (
+	_ = "" + b   // ERROR "invalid operation.*mismatched types.*untyped string and bool"
+	_ = "" + i   // ERROR "invalid operation.*mismatched types.*untyped string and int"
+	_ = "" + nil // ERROR "invalid operation.*mismatched types.*untyped string and nil"
+)
+
+var (
+	_ = s + false // ERROR "invalid operation.*mismatched types.*string and untyped bool"
+	_ = s + 1     // ERROR "invalid operation.*mismatched types.*string and untyped int"
+	_ = s + nil   // ERROR "invalid operation.*mismatched types.*string and nil"
+)
+
+var (
+	_ = "" + false // ERROR "invalid operation.*mismatched types.*untyped string and untyped bool"
+	_ = "" + 1     // ERROR "invalid operation.*mismatched types.*untyped string and untyped int"
+)
+
+var (
+	_ = b + 1         // ERROR "invalid operation.*mismatched types.*bool and untyped int"
+	_ = i + false     // ERROR "invalid operation.*mismatched types.*int and untyped bool"
+	_ = iface + 1     // ERROR "invalid operation.*mismatched types.*interface {} and int"
+	_ = iface + 1.0   // ERROR "invalid operation.*mismatched types.*interface {} and float64"
+	_ = iface + false // ERROR "invalid operation.*mismatched types.*interface {} and bool"
+)
diff --git a/test/run.go b/test/run.go
index 5e60de7624..d7f5d02391 100644
--- a/test/run.go
+++ b/test/run.go
@@ -2002,4 +2002,5 @@ var excluded = map[string]bool{
 	"fixedbugs/issue7525c.go":  true, // types2 reports init cycle error on different line - ok otherwise
 	"fixedbugs/issue7525d.go":  true, // types2 reports init cycle error on different line - ok otherwise
 	"fixedbugs/issue7525e.go":  true, // types2 reports init cycle error on different line - ok otherwise
+	"fixedbugs/issue46749.go":  true, // types2 reports can not convert error instead of type mismatched
 }
-- 
GitLab


From a6a853f94cf00d8f581d0e6fbcc28898e39557b2 Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Tue, 15 Jun 2021 12:47:57 -0400
Subject: [PATCH 2247/2400] cmd/asm: restore supporting of *1 scaling on ARM64

On ARM64, instruction like "MOVD (R1)(R2*1), R3" is accepted and
assembles correctly with Go 1.16, but errors out on tip with
"arm64 doesn't support scaled register format", since CL 289589.

"MOVD (R1)(R2), R3" is the preferred form. But the *1 form works
before and assembles correctly. Keep supporting it.

Fixes #46766.

Change-Id: I0f7fd71fa87ea698919a936b6c68aa5a91afd486
Reviewed-on: https://go-review.googlesource.com/c/go/+/328229
Trust: Cherry Mui <cherryyz@google.com>
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: eric fang <eric.fang@arm.com>
---
 src/cmd/asm/internal/asm/parse.go         | 3 ++-
 src/cmd/asm/internal/asm/testdata/arm64.s | 2 ++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/cmd/asm/internal/asm/parse.go b/src/cmd/asm/internal/asm/parse.go
index ab48632a44..4cddcf48a4 100644
--- a/src/cmd/asm/internal/asm/parse.go
+++ b/src/cmd/asm/internal/asm/parse.go
@@ -1003,7 +1003,8 @@ func (p *Parser) registerIndirect(a *obj.Addr, prefix rune) {
 				p.errorf("unimplemented two-register form")
 			}
 			a.Index = r1
-			if scale != 0 && p.arch.Family == sys.ARM64 {
+			if scale != 0 && scale != 1 && p.arch.Family == sys.ARM64 {
+				// Support (R1)(R2) (no scaling) and (R1)(R2*1).
 				p.errorf("arm64 doesn't support scaled register format")
 			} else {
 				a.Scale = int16(scale)
diff --git a/src/cmd/asm/internal/asm/testdata/arm64.s b/src/cmd/asm/internal/asm/testdata/arm64.s
index 1146c1a789..5f1e68545b 100644
--- a/src/cmd/asm/internal/asm/testdata/arm64.s
+++ b/src/cmd/asm/internal/asm/testdata/arm64.s
@@ -547,6 +547,7 @@ TEXT	foo(SB), DUPOK|NOSPLIT, $-8
 // shifted or extended register offset.
 	MOVD	(R2)(R6.SXTW), R4               // 44c866f8
 	MOVD	(R3)(R6), R5                    // 656866f8
+	MOVD	(R3)(R6*1), R5                  // 656866f8
 	MOVD	(R2)(R6), R4                    // 446866f8
 	MOVWU	(R19)(R20<<2), R20              // 747a74b8
 	MOVD	(R2)(R6<<3), R4                 // 447866f8
@@ -579,6 +580,7 @@ TEXT	foo(SB), DUPOK|NOSPLIT, $-8
 	MOVB	R4, (R2)(R6.SXTX)               // 44e82638
 	MOVB	R8, (R3)(R9.UXTW)               // 68482938
 	MOVB	R10, (R5)(R8)                   // aa682838
+	MOVB	R10, (R5)(R8*1)                 // aa682838
 	MOVH	R11, (R2)(R7.SXTW<<1)           // 4bd82778
 	MOVH	R5, (R1)(R2<<1)                 // 25782278
 	MOVH	R7, (R2)(R5.SXTX<<1)            // 47f82578
-- 
GitLab


From a294e4e798d75ee9cf167a75189b1b0dff3664f1 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 15 Jun 2021 12:46:11 -0400
Subject: [PATCH 2248/2400] math/rand: mention half-open intervals explicitly

If someone sees "in [0,n)" it might look like a typo.
Saying "in the half-open interval [0,n)" will give people
something to search the web for (half-open interval).

Change-Id: I3c343f0a7171891e106e709ca77ab9db5daa5c84
Reviewed-on: https://go-review.googlesource.com/c/go/+/328210
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/math/rand/rand.go | 32 +++++++++++++++-----------------
 1 file changed, 15 insertions(+), 17 deletions(-)

diff --git a/src/math/rand/rand.go b/src/math/rand/rand.go
index 8179d9f464..13f20ca5ef 100644
--- a/src/math/rand/rand.go
+++ b/src/math/rand/rand.go
@@ -12,9 +12,6 @@
 // The default Source is safe for concurrent use by multiple goroutines, but
 // Sources created by NewSource are not.
 //
-// Mathematical interval notation such as [0, n) is used throughout the
-// documentation for this package.
-//
 // This package's outputs might be easily predictable regardless of how it's
 // seeded. For random numbers suitable for security-sensitive work, see the
 // crypto/rand package.
@@ -106,7 +103,7 @@ func (r *Rand) Int() int {
 	return int(u << 1 >> 1) // clear sign bit if int == int32
 }
 
-// Int63n returns, as an int64, a non-negative pseudo-random number in [0,n).
+// Int63n returns, as an int64, a non-negative pseudo-random number in the half-open interval [0,n).
 // It panics if n <= 0.
 func (r *Rand) Int63n(n int64) int64 {
 	if n <= 0 {
@@ -123,7 +120,7 @@ func (r *Rand) Int63n(n int64) int64 {
 	return v % n
 }
 
-// Int31n returns, as an int32, a non-negative pseudo-random number in [0,n).
+// Int31n returns, as an int32, a non-negative pseudo-random number in the half-open interval [0,n).
 // It panics if n <= 0.
 func (r *Rand) Int31n(n int32) int32 {
 	if n <= 0 {
@@ -140,7 +137,7 @@ func (r *Rand) Int31n(n int32) int32 {
 	return v % n
 }
 
-// int31n returns, as an int32, a non-negative pseudo-random number in [0,n).
+// int31n returns, as an int32, a non-negative pseudo-random number in the half-open interval [0,n).
 // n must be > 0, but int31n does not check this; the caller must ensure it.
 // int31n exists because Int31n is inefficient, but Go 1 compatibility
 // requires that the stream of values produced by math/rand remain unchanged.
@@ -164,7 +161,7 @@ func (r *Rand) int31n(n int32) int32 {
 	return int32(prod >> 32)
 }
 
-// Intn returns, as an int, a non-negative pseudo-random number in [0,n).
+// Intn returns, as an int, a non-negative pseudo-random number in the half-open interval [0,n).
 // It panics if n <= 0.
 func (r *Rand) Intn(n int) int {
 	if n <= 0 {
@@ -176,7 +173,7 @@ func (r *Rand) Intn(n int) int {
 	return int(r.Int63n(int64(n)))
 }
 
-// Float64 returns, as a float64, a pseudo-random number in [0.0,1.0).
+// Float64 returns, as a float64, a pseudo-random number in the half-open interval [0.0,1.0).
 func (r *Rand) Float64() float64 {
 	// A clearer, simpler implementation would be:
 	//	return float64(r.Int63n(1<<53)) / (1<<53)
@@ -202,7 +199,7 @@ again:
 	return f
 }
 
-// Float32 returns, as a float32, a pseudo-random number in [0.0,1.0).
+// Float32 returns, as a float32, a pseudo-random number in the half-open interval [0.0,1.0).
 func (r *Rand) Float32() float32 {
 	// Same rationale as in Float64: we want to preserve the Go 1 value
 	// stream except we want to fix it not to return 1.0
@@ -215,7 +212,8 @@ again:
 	return f
 }
 
-// Perm returns, as a slice of n ints, a pseudo-random permutation of the integers [0,n).
+// Perm returns, as a slice of n ints, a pseudo-random permutation of the integers
+// in the half-open interval [0,n).
 func (r *Rand) Perm(n int) []int {
 	m := make([]int, n)
 	// In the following loop, the iteration when i=0 always swaps m[0] with m[0].
@@ -323,31 +321,31 @@ func Int31() int32 { return globalRand.Int31() }
 // Int returns a non-negative pseudo-random int from the default Source.
 func Int() int { return globalRand.Int() }
 
-// Int63n returns, as an int64, a non-negative pseudo-random number in [0,n)
+// Int63n returns, as an int64, a non-negative pseudo-random number in the half-open interval [0,n)
 // from the default Source.
 // It panics if n <= 0.
 func Int63n(n int64) int64 { return globalRand.Int63n(n) }
 
-// Int31n returns, as an int32, a non-negative pseudo-random number in [0,n)
+// Int31n returns, as an int32, a non-negative pseudo-random number in the half-open interval [0,n)
 // from the default Source.
 // It panics if n <= 0.
 func Int31n(n int32) int32 { return globalRand.Int31n(n) }
 
-// Intn returns, as an int, a non-negative pseudo-random number in [0,n)
+// Intn returns, as an int, a non-negative pseudo-random number in the half-open interval [0,n)
 // from the default Source.
 // It panics if n <= 0.
 func Intn(n int) int { return globalRand.Intn(n) }
 
-// Float64 returns, as a float64, a pseudo-random number in [0.0,1.0)
+// Float64 returns, as a float64, a pseudo-random number in the half-open interval [0.0,1.0)
 // from the default Source.
 func Float64() float64 { return globalRand.Float64() }
 
-// Float32 returns, as a float32, a pseudo-random number in [0.0,1.0)
+// Float32 returns, as a float32, a pseudo-random number in the half-open interval [0.0,1.0)
 // from the default Source.
 func Float32() float32 { return globalRand.Float32() }
 
-// Perm returns, as a slice of n ints, a pseudo-random permutation of the integers [0,n)
-// from the default Source.
+// Perm returns, as a slice of n ints, a pseudo-random permutation of the integers
+// in the half-open interval [0,n) from the default Source.
 func Perm(n int) []int { return globalRand.Perm(n) }
 
 // Shuffle pseudo-randomizes the order of elements using the default Source.
-- 
GitLab


From 6ea2af0890260fec6cc951b5f426c0464e43266d Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 11 Jun 2021 16:39:54 -0400
Subject: [PATCH 2249/2400] cmd/go: add a regression test for #45979

Change-Id: Id7f83b2e6a99af798e55b272b04880ebb588351f
Reviewed-on: https://go-review.googlesource.com/c/go/+/328230
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 .../testdata/script/mod_get_lazy_indirect.txt | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 src/cmd/go/testdata/script/mod_get_lazy_indirect.txt

diff --git a/src/cmd/go/testdata/script/mod_get_lazy_indirect.txt b/src/cmd/go/testdata/script/mod_get_lazy_indirect.txt
new file mode 100644
index 0000000000..60548e8429
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_get_lazy_indirect.txt
@@ -0,0 +1,38 @@
+# https://golang.org/issue/45979: after 'go get' on a package,
+# that package should be importable without error.
+
+
+# We start out with an unresolved dependency.
+# 'go list' suggests that we run 'go get' on that dependency.
+
+! go list -deps .
+stderr '^m.go:3:8: no required module provides package rsc\.io/quote; to add it:\n\tgo get rsc.io/quote$'
+
+
+# Unfortunately, the suggested 'go get' command leaves us with another problem.
+#
+# TODO(#45979): After 'go get', the 'go list' command from above should succeed.
+
+go get rsc.io/quote
+
+! go list -deps .
+stderr '^go: updates to go.mod needed; to update it:\n\tgo mod tidy'
+[!short] ! go build .
+stderr '^go: updates to go.mod needed; to update it:\n\tgo mod tidy'
+
+
+# After running the suggested 'go mod tidy' command, the build
+# should succeed.
+go mod tidy
+go list -deps .
+[!short] go build .
+
+
+-- go.mod --
+module example.com/m
+
+go 1.17
+-- m.go --
+package m
+
+import _ "rsc.io/quote"
-- 
GitLab


From 0e67ce3d28320e816dd8e7cf7d701c1804fb977e Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Tue, 15 Jun 2021 12:05:01 -0400
Subject: [PATCH 2250/2400] cmd/go: in lazy modules, add transitive imports for
 'go get' arguments

I needed to also update TestScript/mod_sumdb_golang.
It had been relying on 'go list -mod=mod' to add both the go.mod and
go.sum entries for the named package, but when 'go get' actually adds
all of the needed dependencies, lazy loading kicks in and 'go list'
doesn't end up needing the checksums for go.mod files.
We didn't detect the skew before because the 'go list' command was
(unexpectedly) also adding the missing dependencies, which triggered a
deep scan of the complete module graph.

For #45979

Change-Id: Ica917dee22c83ffa71c6ad0f2e189f911b73edf4
Reviewed-on: https://go-review.googlesource.com/c/go/+/328231
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modget/get.go             |  1 +
 src/cmd/go/internal/modload/buildlist.go      | 12 ++++---
 src/cmd/go/internal/modload/init.go           |  2 +-
 src/cmd/go/internal/modload/load.go           | 25 +++++++++++--
 .../testdata/script/mod_get_lazy_indirect.txt | 26 ++++++++------
 .../go/testdata/script/mod_sumdb_golang.txt   | 36 ++++++++++++++++---
 6 files changed, 79 insertions(+), 23 deletions(-)

diff --git a/src/cmd/go/internal/modget/get.go b/src/cmd/go/internal/modget/get.go
index 8eee723f89..ea5c4e229a 100644
--- a/src/cmd/go/internal/modget/get.go
+++ b/src/cmd/go/internal/modget/get.go
@@ -1153,6 +1153,7 @@ func (r *resolver) loadPackages(ctx context.Context, patterns []string, findPack
 		Tags:                     imports.AnyTags(),
 		VendorModulesInGOROOTSrc: true,
 		LoadTests:                *getT,
+		AssumeRootsImported:      true, // After 'go get foo', imports of foo should build.
 		SilencePackageErrors:     true, // May be fixed by subsequent upgrades or downgrades.
 	}
 
diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index e5db41c748..64eaa16e8b 100644
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -443,7 +443,7 @@ func expandGraph(ctx context.Context, rs *Requirements) (*Requirements, *ModuleG
 		// roots — but in a lazy module it may pull in previously-irrelevant
 		// transitive dependencies.
 
-		newRS, rsErr := updateRoots(ctx, rs.direct, rs, nil, nil)
+		newRS, rsErr := updateRoots(ctx, rs.direct, rs, nil, nil, false)
 		if rsErr != nil {
 			// Failed to update roots, perhaps because of an error in a transitive
 			// dependency needed for the update. Return the original Requirements
@@ -517,11 +517,11 @@ func tidyRoots(ctx context.Context, rs *Requirements, pkgs []*loadPkg) (*Require
 	return tidyLazyRoots(ctx, rs.direct, pkgs)
 }
 
-func updateRoots(ctx context.Context, direct map[string]bool, rs *Requirements, pkgs []*loadPkg, add []module.Version) (*Requirements, error) {
+func updateRoots(ctx context.Context, direct map[string]bool, rs *Requirements, pkgs []*loadPkg, add []module.Version, rootsImported bool) (*Requirements, error) {
 	if rs.depth == eager {
 		return updateEagerRoots(ctx, direct, rs, add)
 	}
-	return updateLazyRoots(ctx, direct, rs, pkgs, add)
+	return updateLazyRoots(ctx, direct, rs, pkgs, add, rootsImported)
 }
 
 // tidyLazyRoots returns a minimal set of root requirements that maintains the
@@ -661,7 +661,7 @@ func tidyLazyRoots(ctx context.Context, direct map[string]bool, pkgs []*loadPkg)
 //
 // (See https://golang.org/design/36460-lazy-module-loading#invariants for more
 // detail.)
-func updateLazyRoots(ctx context.Context, direct map[string]bool, rs *Requirements, pkgs []*loadPkg, add []module.Version) (*Requirements, error) {
+func updateLazyRoots(ctx context.Context, direct map[string]bool, rs *Requirements, pkgs []*loadPkg, add []module.Version, rootsImported bool) (*Requirements, error) {
 	roots := rs.rootModules
 	rootsUpgraded := false
 
@@ -688,6 +688,10 @@ func updateLazyRoots(ctx context.Context, direct map[string]bool, rs *Requiremen
 			//
 			// (This is the “import invariant” that makes lazy loading possible.)
 
+		case rootsImported && pkg.flags.has(pkgFromRoot):
+			// pkg is a transitive dependency of some root, and we are treating the
+			// roots as if they are imported by the main module (as in 'go get').
+
 		case pkg.flags.has(pkgIsRoot):
 			// pkg is a root of the package-import graph. (Generally this means that
 			// it matches a command-line argument.) We want future invocations of the
diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index eb9cfe629b..cbc7289afa 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -661,7 +661,7 @@ func requirementsFromModFile(ctx context.Context) *Requirements {
 	for _, n := range mPathCount {
 		if n > 1 {
 			var err error
-			rs, err = updateRoots(ctx, rs.direct, rs, nil, nil)
+			rs, err = updateRoots(ctx, rs.direct, rs, nil, nil, false)
 			if err != nil {
 				base.Fatalf("go: %v", err)
 			}
diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index a9d1777125..a3a8021c04 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -171,6 +171,11 @@ type PackageOpts struct {
 	// if the flag is set to "readonly" (the default) or "vendor".
 	ResolveMissingImports bool
 
+	// AssumeRootsImported indicates that the transitive dependencies of the root
+	// packages should be treated as if those roots will be imported by the main
+	// module.
+	AssumeRootsImported bool
+
 	// AllowPackage, if non-nil, is called after identifying the module providing
 	// each package. If AllowPackage returns a non-nil error, that error is set
 	// for the package, and the imports and test of that package will not be
@@ -875,6 +880,11 @@ const (
 	// are also roots (and must be marked pkgIsRoot).
 	pkgIsRoot
 
+	// pkgFromRoot indicates that the package is in the transitive closure of
+	// imports starting at the roots. (Note that every package marked as pkgIsRoot
+	// is also trivially marked pkgFromRoot.)
+	pkgFromRoot
+
 	// pkgImportsLoaded indicates that the imports and testImports fields of a
 	// loadPkg have been populated.
 	pkgImportsLoaded
@@ -1068,7 +1078,7 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 		// iteration so we don't need to also update it here. (That would waste time
 		// computing a "direct" map that we'll have to recompute later anyway.)
 		direct := ld.requirements.direct
-		rs, err := updateRoots(ctx, direct, ld.requirements, noPkgs, toAdd)
+		rs, err := updateRoots(ctx, direct, ld.requirements, noPkgs, toAdd, ld.AssumeRootsImported)
 		if err != nil {
 			// If an error was found in a newly added module, report the package
 			// import stack instead of the module requirement stack. Packages
@@ -1274,7 +1284,7 @@ func (ld *loader) updateRequirements(ctx context.Context) (changed bool, err err
 		addRoots = tidy.rootModules
 	}
 
-	rs, err = updateRoots(ctx, direct, rs, ld.pkgs, addRoots)
+	rs, err = updateRoots(ctx, direct, rs, ld.pkgs, addRoots, ld.AssumeRootsImported)
 	if err != nil {
 		// We don't actually know what even the root requirements are supposed to be,
 		// so we can't proceed with loading. Return the error to the caller
@@ -1433,6 +1443,9 @@ func (ld *loader) applyPkgFlags(ctx context.Context, pkg *loadPkg, flags loadPkg
 		// This package matches a root pattern by virtue of being in "all".
 		flags |= pkgIsRoot
 	}
+	if flags.has(pkgIsRoot) {
+		flags |= pkgFromRoot
+	}
 
 	old := pkg.flags.update(flags)
 	new := old | flags
@@ -1487,6 +1500,12 @@ func (ld *loader) applyPkgFlags(ctx context.Context, pkg *loadPkg, flags loadPkg
 			ld.applyPkgFlags(ctx, dep, pkgInAll)
 		}
 	}
+
+	if new.has(pkgFromRoot) && !old.has(pkgFromRoot|pkgImportsLoaded) {
+		for _, dep := range pkg.imports {
+			ld.applyPkgFlags(ctx, dep, pkgFromRoot)
+		}
+	}
 }
 
 // preloadRootModules loads the module requirements needed to identify the
@@ -1549,7 +1568,7 @@ func (ld *loader) preloadRootModules(ctx context.Context, rootPkgs []string) (ch
 	}
 	module.Sort(toAdd)
 
-	rs, err := updateRoots(ctx, ld.requirements.direct, ld.requirements, nil, toAdd)
+	rs, err := updateRoots(ctx, ld.requirements.direct, ld.requirements, nil, toAdd, ld.AssumeRootsImported)
 	if err != nil {
 		// We are missing some root dependency, and for some reason we can't load
 		// enough of the module dependency graph to add the missing root. Package
diff --git a/src/cmd/go/testdata/script/mod_get_lazy_indirect.txt b/src/cmd/go/testdata/script/mod_get_lazy_indirect.txt
index 60548e8429..13640cbc23 100644
--- a/src/cmd/go/testdata/script/mod_get_lazy_indirect.txt
+++ b/src/cmd/go/testdata/script/mod_get_lazy_indirect.txt
@@ -9,23 +9,27 @@
 stderr '^m.go:3:8: no required module provides package rsc\.io/quote; to add it:\n\tgo get rsc.io/quote$'
 
 
-# Unfortunately, the suggested 'go get' command leaves us with another problem.
+# When we run the suggested 'go get' command, the new dependency can be used
+# immediately, even though 'go get' marks it as 'indirect'.
 #
-# TODO(#45979): After 'go get', the 'go list' command from above should succeed.
+# TODO(#45979): Should we swap this default state, so that new dependencies
+# are added as direct unless otherwise noted?
 
 go get rsc.io/quote
+grep 'rsc.io/quote v\d+\.\d+\.\d+ // indirect$' go.mod
+! grep 'rsc.io/quote v\d+\.\d+\.\d+$' go.mod
 
-! go list -deps .
-stderr '^go: updates to go.mod needed; to update it:\n\tgo mod tidy'
-[!short] ! go build .
-stderr '^go: updates to go.mod needed; to update it:\n\tgo mod tidy'
-
-
-# After running the suggested 'go mod tidy' command, the build
-# should succeed.
-go mod tidy
 go list -deps .
+! stderr .
 [!short] go build .
+[!short] ! stderr .
+
+
+# 'go get .' (or 'go mod tidy') removes the indirect mark.
+
+go get .
+grep 'rsc.io/quote v\d+\.\d+\.\d+$' go.mod
+! grep 'rsc.io/quote v\d+\.\d+\.\d+ // indirect$' go.mod
 
 
 -- go.mod --
diff --git a/src/cmd/go/testdata/script/mod_sumdb_golang.txt b/src/cmd/go/testdata/script/mod_sumdb_golang.txt
index cc0b0da474..becd88b52e 100644
--- a/src/cmd/go/testdata/script/mod_sumdb_golang.txt
+++ b/src/cmd/go/testdata/script/mod_sumdb_golang.txt
@@ -10,45 +10,73 @@ go env GOSUMDB
 stdout '^sum.golang.org$'
 
 # Download direct from github.
+
 [!net] skip
 [!exec:git] skip
 env GOSUMDB=sum.golang.org
 env GOPROXY=direct
+
 go get -d rsc.io/quote@v1.5.2
 cp go.sum saved.sum
 
+
 # Download from proxy.golang.org with go.sum entry already.
 # Use 'go list' instead of 'go get' since the latter may download extra go.mod
 # files not listed in go.sum.
+
 go clean -modcache
 env GOSUMDB=
 env GOPROXY=
-go list -x -deps rsc.io/quote
+
+go list -x -m all  # Download go.mod files.
 ! stderr github
 stderr proxy.golang.org/rsc.io/quote
 ! stderr sum.golang.org/tile
 ! stderr sum.golang.org/lookup/rsc.io/quote
+
+go list -x -deps rsc.io/quote  # Download module source.
+! stderr github
+stderr proxy.golang.org/rsc.io/quote
+! stderr sum.golang.org/tile
+! stderr sum.golang.org/lookup/rsc.io/quote
+
 cmp go.sum saved.sum
 
+
 # Download again.
 # Should use the checksum database to validate new go.sum lines,
 # but not need to fetch any new data from the proxy.
+
 rm go.sum
-go list -mod=mod -x rsc.io/quote
+
+go list -mod=mod -x -m all  # Add checksums for go.mod files.
+stderr sum.golang.org/tile
 ! stderr github
 ! stderr proxy.golang.org/rsc.io/quote
-stderr sum.golang.org/tile
 stderr sum.golang.org/lookup/rsc.io/quote
+
+go list -mod=mod -x rsc.io/quote  # Add checksums for module source.
+! stderr .  # Adds checksums, but for entities already in the module cache.
+
 cmp go.sum saved.sum
 
+
 # test fallback to direct
+
 env TESTGOPROXY404=1
 go clean -modcache
 rm go.sum
-go list -mod=mod -x rsc.io/quote
+
+go list -mod=mod -x -m all  # Download go.mod files
+stderr 'proxy.golang.org.*404 testing'
+stderr github.com/rsc
+
+go list -mod=mod -x rsc.io/quote  # Download module source.
 stderr 'proxy.golang.org.*404 testing'
 stderr github.com/rsc
+
 cmp go.sum saved.sum
 
+
 -- go.mod --
 module m
-- 
GitLab


From 881b6ea7baaa38f54a1dbd989fd21a638d0e118d Mon Sep 17 00:00:00 2001
From: yangwenmai <yangwen.yw@gmail.com>
Date: Thu, 17 Jun 2021 07:01:16 +0800
Subject: [PATCH 2251/2400] doc/go1.17: fix redundant space

Change-Id: I6fccab7504f928452fbe490ae83e8d4b23a59f06
Reviewed-on: https://go-review.googlesource.com/c/go/+/328849
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 doc/go1.17.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 75c05c9e25..f8d7aad034 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -387,7 +387,7 @@ func Foo() bool {
   registers instead of the stack. This work is enabled for Linux, MacOS, and
   Windows on the 64-bit x86 architecture (the <code>linux/amd64</code>,
   <code>darwin/amd64</code>, <code>windows/amd64</code> ports). For a
-  representative set of Go  packages and programs, benchmarking has shown
+  representative set of Go packages and programs, benchmarking has shown
   performance improvements of about 5%, and a typical reduction in binary size
   of about 2%.
 </p>
-- 
GitLab


From b0355a3e72df384c82a688524c603a97c1d8e7a7 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 10 Jun 2021 15:14:01 -0400
Subject: [PATCH 2252/2400] time: fix receiver for Time.IsDST method

Only methods that modify the time take pointer receivers;
IsDST does not modify it and therefore should not.

For #42102 and #46688.

Change-Id: I4721ef7f4d7572236ae6e4d99a459b9ffb11999e
Reviewed-on: https://go-review.googlesource.com/c/go/+/326789
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 api/go1.17.txt   | 2 +-
 src/time/time.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/api/go1.17.txt b/api/go1.17.txt
index f054458715..257ca271d3 100644
--- a/api/go1.17.txt
+++ b/api/go1.17.txt
@@ -153,7 +153,7 @@ pkg time, const Layout = "01/02 03:04:05PM '06 -0700"
 pkg time, const Layout ideal-string
 pkg time, func UnixMicro(int64) Time
 pkg time, func UnixMilli(int64) Time
-pkg time, method (*Time) IsDST() bool
+pkg time, method (Time) IsDST() bool
 pkg time, method (Time) GoString() string
 pkg time, method (Time) UnixMicro() int64
 pkg time, method (Time) UnixMilli() int64
diff --git a/src/time/time.go b/src/time/time.go
index cd756bbf5f..1cf1e2bbf6 100644
--- a/src/time/time.go
+++ b/src/time/time.go
@@ -1340,7 +1340,7 @@ func UnixMicro(usec int64) Time {
 }
 
 // IsDST reports whether the time in the configured location is in Daylight Savings Time.
-func (t *Time) IsDST() bool {
+func (t Time) IsDST() bool {
 	_, _, _, _, isDST := t.loc.lookup(t.Unix())
 	return isDST
 }
-- 
GitLab


From 97cee43c93cfccded197cd281f0a5885cdb605b4 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Tue, 8 Jun 2021 15:33:54 +0200
Subject: [PATCH 2253/2400] testing: drop unusual characters from TempDir
 directory name

Only use safe characters of the test name for the os.MkdirTemp pattern.
This currently includes the alphanumeric characters and ASCII
punctuation characters known not to interact with globs.

Fixes #46624

Change-Id: I402c34775b943fed9b97963c52f79245cc16dc1d
Reviewed-on: https://go-review.googlesource.com/c/go/+/326010
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/testing/testing.go      | 34 ++++++++++++++++++++++------------
 src/testing/testing_test.go | 10 +++++++++-
 2 files changed, 31 insertions(+), 13 deletions(-)

diff --git a/src/testing/testing.go b/src/testing/testing.go
index 85a7fec65f..fdf57a3953 100644
--- a/src/testing/testing.go
+++ b/src/testing/testing.go
@@ -252,6 +252,8 @@ import (
 	"sync"
 	"sync/atomic"
 	"time"
+	"unicode"
+	"unicode/utf8"
 )
 
 var initRan bool
@@ -908,11 +910,6 @@ func (c *common) Cleanup(f func()) {
 	c.cleanups = append(c.cleanups, fn)
 }
 
-var tempDirReplacer struct {
-	sync.Once
-	r *strings.Replacer
-}
-
 // TempDir returns a temporary directory for the test to use.
 // The directory is automatically removed by Cleanup when the test and
 // all its subtests complete.
@@ -936,13 +933,26 @@ func (c *common) TempDir() string {
 	if nonExistent {
 		c.Helper()
 
-		// os.MkdirTemp doesn't like path separators in its pattern,
-		// so mangle the name to accommodate subtests.
-		tempDirReplacer.Do(func() {
-			tempDirReplacer.r = strings.NewReplacer("/", "_", "\\", "_", ":", "_")
-		})
-		pattern := tempDirReplacer.r.Replace(c.Name())
-
+		// Drop unusual characters (such as path separators or
+		// characters interacting with globs) from the directory name to
+		// avoid surprising os.MkdirTemp behavior.
+		mapper := func(r rune) rune {
+			if r < utf8.RuneSelf {
+				const allowed = "!#$%&()+,-.=@^_{}~ "
+				if '0' <= r && r <= '9' ||
+					'a' <= r && r <= 'z' ||
+					'A' <= r && r <= 'Z' {
+					return r
+				}
+				if strings.ContainsRune(allowed, r) {
+					return r
+				}
+			} else if unicode.IsLetter(r) || unicode.IsNumber(r) {
+				return r
+			}
+			return -1
+		}
+		pattern := strings.Map(mapper, c.Name())
 		c.tempDir, c.tempDirErr = os.MkdirTemp("", pattern)
 		if c.tempDirErr == nil {
 			c.Cleanup(func() {
diff --git a/src/testing/testing_test.go b/src/testing/testing_test.go
index 55a4df4739..08ae23991f 100644
--- a/src/testing/testing_test.go
+++ b/src/testing/testing_test.go
@@ -58,6 +58,9 @@ func TestTempDir(t *testing.T) {
 	t.Run("test:subtest", testTempDir)
 	t.Run("test/..", testTempDir)
 	t.Run("../test", testTempDir)
+	t.Run("test[]", testTempDir)
+	t.Run("test*", testTempDir)
+	t.Run("äöüéè", testTempDir)
 }
 
 func testTempDir(t *testing.T) {
@@ -74,7 +77,7 @@ func testTempDir(t *testing.T) {
 			if err != nil {
 				t.Fatal(err)
 			}
-			t.Errorf("directory %q stil exists: %v, isDir=%v", dir, fi, fi.IsDir())
+			t.Errorf("directory %q still exists: %v, isDir=%v", dir, fi, fi.IsDir())
 		default:
 			if !t.Failed() {
 				t.Fatal("never received dir channel")
@@ -108,6 +111,11 @@ func testTempDir(t *testing.T) {
 	if len(files) > 0 {
 		t.Errorf("unexpected %d files in TempDir: %v", len(files), files)
 	}
+
+	glob := filepath.Join(dir, "*.txt")
+	if _, err := filepath.Glob(glob); err != nil {
+		t.Error(err)
+	}
 }
 
 func TestSetenv(t *testing.T) {
-- 
GitLab


From 4dede025507fe6476e9881b4b2bd773a3680d618 Mon Sep 17 00:00:00 2001
From: Michael Pratt <mpratt@google.com>
Date: Mon, 7 Jun 2021 13:28:09 -0400
Subject: [PATCH 2254/2400] cmd/pprof: make ObjAddr a no-op

https://golang.org/cl/318049 replaced driver.ObjFile.Base with
driver.ObjFile.ObjAddr. We don't support shared libraries, so these
should be no-op, but CL 318049 accidentally failed to account from the
change in no-op behavior from returning 0 to passing through addr.

Fixes #46636

Change-Id: Iab82224c7db722a1e257ec6e305218e22114d0a8
Reviewed-on: https://go-review.googlesource.com/c/go/+/325809
Trust: Michael Pratt <mpratt@google.com>
Run-TryBot: Michael Pratt <mpratt@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 src/cmd/pprof/pprof.go        |   4 +-
 src/cmd/pprof/pprof_test.go   | 110 ++++++++++++++++++++++++++++++++++
 src/cmd/pprof/testdata/cpu.go |  41 +++++++++++++
 3 files changed, 153 insertions(+), 2 deletions(-)
 create mode 100644 src/cmd/pprof/pprof_test.go
 create mode 100644 src/cmd/pprof/testdata/cpu.go

diff --git a/src/cmd/pprof/pprof.go b/src/cmd/pprof/pprof.go
index 1d10a7b41f..e72c765adc 100644
--- a/src/cmd/pprof/pprof.go
+++ b/src/cmd/pprof/pprof.go
@@ -233,8 +233,8 @@ func (f *file) Name() string {
 }
 
 func (f *file) ObjAddr(addr uint64) (uint64, error) {
-	// No support for shared libraries.
-	return 0, nil
+	// No support for shared libraries, so translation is a no-op.
+	return addr, nil
 }
 
 func (f *file) BuildID() string {
diff --git a/src/cmd/pprof/pprof_test.go b/src/cmd/pprof/pprof_test.go
new file mode 100644
index 0000000000..170cdf3bb8
--- /dev/null
+++ b/src/cmd/pprof/pprof_test.go
@@ -0,0 +1,110 @@
+// Copyright 2021 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 (
+	"fmt"
+	"internal/testenv"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+var tmp, pprofExe string // populated by buildPprof
+
+func TestMain(m *testing.M) {
+	if !testenv.HasGoBuild() {
+		return
+	}
+
+	var exitcode int
+	if err := buildPprof(); err == nil {
+		exitcode = m.Run()
+	} else {
+		fmt.Println(err)
+		exitcode = 1
+	}
+	os.RemoveAll(tmp)
+	os.Exit(exitcode)
+}
+
+func buildPprof() error {
+	var err error
+	tmp, err = os.MkdirTemp("", "TestPprof")
+	if err != nil {
+		return fmt.Errorf("TempDir failed: %v", err)
+	}
+
+	pprofExe = filepath.Join(tmp, "testpprof.exe")
+	gotool, err := testenv.GoTool()
+	if err != nil {
+		return err
+	}
+	out, err := exec.Command(gotool, "build", "-o", pprofExe, "cmd/pprof").CombinedOutput()
+	if err != nil {
+		os.RemoveAll(tmp)
+		return fmt.Errorf("go build -o %v cmd/pprof: %v\n%s", pprofExe, err, string(out))
+	}
+
+	return nil
+}
+
+func mustHaveDisasm(t *testing.T) {
+	switch runtime.GOARCH {
+	case "mips", "mipsle", "mips64", "mips64le":
+		t.Skipf("skipping on %s, issue 12559", runtime.GOARCH)
+	case "riscv64":
+		t.Skipf("skipping on %s, issue 36738", runtime.GOARCH)
+	case "s390x":
+		t.Skipf("skipping on %s, issue 15255", runtime.GOARCH)
+	}
+
+	// Skip PIE platforms, pprof can't disassemble PIE.
+	if runtime.GOOS == "windows" {
+		t.Skipf("skipping on %s, issue 46639", runtime.GOOS)
+	}
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
+		t.Skipf("skipping on %s/%s, issue 46639", runtime.GOOS, runtime.GOARCH)
+	}
+}
+
+// TestDisasm verifies that cmd/pprof can successfully disassemble functions.
+//
+// This is a regression test for issue 46636.
+func TestDisasm(t *testing.T) {
+	mustHaveDisasm(t)
+	testenv.MustHaveGoBuild(t)
+
+	tmpdir := t.TempDir()
+	cpuExe := filepath.Join(tmpdir, "cpu.exe")
+	cmd := exec.Command(testenv.GoToolPath(t), "build", "-o", cpuExe, "cpu.go")
+	cmd.Dir = "testdata/"
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("build failed: %v\n%s", err, out)
+	}
+
+	profile := filepath.Join(tmpdir, "cpu.pprof")
+	cmd = exec.Command(cpuExe, "-output", profile)
+	out, err = cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("cpu failed: %v\n%s", err, out)
+	}
+
+	cmd = exec.Command(pprofExe, "-disasm", "main.main", cpuExe, profile)
+	out, err = cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("pprof failed: %v\n%s", err, out)
+	}
+
+	sout := string(out)
+	want := "ROUTINE ======================== main.main"
+	if !strings.Contains(sout, want) {
+		t.Errorf("pprof disasm got %s want contains %q", sout, want)
+	}
+}
diff --git a/src/cmd/pprof/testdata/cpu.go b/src/cmd/pprof/testdata/cpu.go
new file mode 100644
index 0000000000..5b682870db
--- /dev/null
+++ b/src/cmd/pprof/testdata/cpu.go
@@ -0,0 +1,41 @@
+// Copyright 2021 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 (
+	"flag"
+	"fmt"
+	"os"
+	"runtime/pprof"
+	"time"
+)
+
+var output = flag.String("output", "", "pprof profile output file")
+
+func main() {
+	flag.Parse()
+	if *output == "" {
+		fmt.Fprintf(os.Stderr, "usage: %s -output file.pprof\n", os.Args[0])
+		os.Exit(2)
+	}
+
+	f, err := os.Create(*output)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(2)
+	}
+	defer f.Close()
+
+	if err := pprof.StartCPUProfile(f); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(2)
+	}
+	defer pprof.StopCPUProfile()
+
+	// Spin for long enough to collect some samples.
+	start := time.Now()
+	for time.Since(start) < time.Second {
+	}
+}
-- 
GitLab


From ed834853ad8224611f44a3c467e00a22df341d91 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Thu, 17 Jun 2021 14:12:34 -0400
Subject: [PATCH 2255/2400] cmd/go: replace a TODO with an explanatory comment

I left a TODO to decide whether to add 'go get' arguments as indirect
(as we have in the past), or to make them direct. I considered both
options, and decided to keep the indirect default because it is easier
(and less invasive) for users to fix.

Updates #45979

Change-Id: I1f23a88db59a01bdd9e6fe48c2fffc8a3b55145a
Reviewed-on: https://go-review.googlesource.com/c/go/+/328971
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/testdata/script/mod_get_lazy_indirect.txt | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/cmd/go/testdata/script/mod_get_lazy_indirect.txt b/src/cmd/go/testdata/script/mod_get_lazy_indirect.txt
index 13640cbc23..1cef9d1c0c 100644
--- a/src/cmd/go/testdata/script/mod_get_lazy_indirect.txt
+++ b/src/cmd/go/testdata/script/mod_get_lazy_indirect.txt
@@ -10,10 +10,12 @@ stderr '^m.go:3:8: no required module provides package rsc\.io/quote; to add it:
 
 
 # When we run the suggested 'go get' command, the new dependency can be used
-# immediately, even though 'go get' marks it as 'indirect'.
+# immediately.
 #
-# TODO(#45979): Should we swap this default state, so that new dependencies
-# are added as direct unless otherwise noted?
+# 'go get' marks the new dependency as 'indirect', because it doesn't scan
+# enough source code to know whether it is direct, and it is easier and less
+# invasive to remove an incorrect indirect mark (e.g. using 'go get') than to
+# add one that is missing ('go mod tidy' or 'go mod vendor').
 
 go get rsc.io/quote
 grep 'rsc.io/quote v\d+\.\d+\.\d+ // indirect$' go.mod
-- 
GitLab


From 45f251ad6cfe0a8fa1aeac0c2c8e42bfe3549c29 Mon Sep 17 00:00:00 2001
From: Michael Pratt <mpratt@google.com>
Date: Thu, 17 Jun 2021 15:23:53 -0400
Subject: [PATCH 2256/2400] cmd/pprof,runtime/pprof: disable test on more
 broken platforms

runtime/pprof has a more complete list of platforms with broken
profiling than I used in cmd/pprof in https://golang.org/cl/325809.
Duplicate that list in cmd/pprof and clean it up a bit in runtime/pprof
for easier reference.

Change-Id: I8f2580aac223de9b73cfff4355f49916f7b76493
Reviewed-on: https://go-review.googlesource.com/c/go/+/329149
Trust: Michael Pratt <mpratt@google.com>
Run-TryBot: Michael Pratt <mpratt@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/pprof/pprof_test.go     | 17 +++++++++++++++++
 src/runtime/pprof/pprof_test.go | 32 ++++++++++++++++++++++----------
 2 files changed, 39 insertions(+), 10 deletions(-)

diff --git a/src/cmd/pprof/pprof_test.go b/src/cmd/pprof/pprof_test.go
index 170cdf3bb8..11e251bfde 100644
--- a/src/cmd/pprof/pprof_test.go
+++ b/src/cmd/pprof/pprof_test.go
@@ -54,6 +54,22 @@ func buildPprof() error {
 	return nil
 }
 
+// See also runtime/pprof.cpuProfilingBroken.
+func mustHaveCPUProfiling(t *testing.T) {
+	switch runtime.GOOS {
+	case "plan9":
+		t.Skipf("skipping on %s, unimplemented", runtime.GOOS)
+	case "aix":
+		t.Skipf("skipping on %s, issue 45170", runtime.GOOS)
+	case "ios", "dragonfly", "netbsd", "illumos", "solaris":
+		t.Skipf("skipping on %s, issue 13841", runtime.GOOS)
+	case "openbsd":
+		if runtime.GOARCH == "arm" || runtime.GOARCH == "arm64" {
+			t.Skipf("skipping on %s/%s, issue 13841", runtime.GOOS, runtime.GOARCH)
+		}
+	}
+}
+
 func mustHaveDisasm(t *testing.T) {
 	switch runtime.GOARCH {
 	case "mips", "mipsle", "mips64", "mips64le":
@@ -77,6 +93,7 @@ func mustHaveDisasm(t *testing.T) {
 //
 // This is a regression test for issue 46636.
 func TestDisasm(t *testing.T) {
+	mustHaveCPUProfiling(t)
 	mustHaveDisasm(t)
 	testenv.MustHaveGoBuild(t)
 
diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go
index 7cbb4fc7ae..f6ae15daab 100644
--- a/src/runtime/pprof/pprof_test.go
+++ b/src/runtime/pprof/pprof_test.go
@@ -260,6 +260,27 @@ func parseProfile(t *testing.T, valBytes []byte, f func(uintptr, []*profile.Loca
 	return p
 }
 
+func cpuProfilingBroken() bool {
+	switch runtime.GOOS {
+	case "plan9":
+		// Profiling unimplemented.
+		return true
+	case "aix":
+		// See https://golang.org/issue/45170.
+		return true
+	case "ios", "dragonfly", "netbsd", "illumos", "solaris":
+		// See https://golang.org/issue/13841.
+		return true
+	case "openbsd":
+		if runtime.GOARCH == "arm" || runtime.GOARCH == "arm64" {
+			// See https://golang.org/issue/13841.
+			return true
+		}
+	}
+
+	return false
+}
+
 // testCPUProfile runs f under the CPU profiler, checking for some conditions specified by need,
 // as interpreted by matches, and returns the parsed profile.
 func testCPUProfile(t *testing.T, matches matchFunc, need []string, avoid []string, f func(dur time.Duration)) *profile.Profile {
@@ -275,16 +296,7 @@ func testCPUProfile(t *testing.T, matches matchFunc, need []string, avoid []stri
 		t.Skip("skipping on plan9")
 	}
 
-	broken := false
-	switch runtime.GOOS {
-	// See https://golang.org/issue/45170 for AIX.
-	case "ios", "dragonfly", "netbsd", "illumos", "solaris", "aix":
-		broken = true
-	case "openbsd":
-		if runtime.GOARCH == "arm" || runtime.GOARCH == "arm64" {
-			broken = true
-		}
-	}
+	broken := cpuProfilingBroken()
 
 	maxDuration := 5 * time.Second
 	if testing.Short() && broken {
-- 
GitLab


From 6f22d2c682d5fb7e8c4e9d2ab3e6a762756c1e30 Mon Sep 17 00:00:00 2001
From: Nick Miyake <nmiyake@users.noreply.github.com>
Date: Fri, 18 Jun 2021 00:19:10 +0000
Subject: [PATCH 2257/2400] doc/go1.17: fix typo

Change-Id: Ie8629e0f710d3eb95b4bbcc9c680ffc5004c2f15
GitHub-Last-Rev: 52f48f429cdd65692b88f724f757efed1fa39cd2
GitHub-Pull-Request: golang/go#46812
Reviewed-on: https://go-review.googlesource.com/c/go/+/329289
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Tobias Klauser <tobias.klauser@gmail.com>
---
 doc/go1.17.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index f8d7aad034..6424709453 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -162,7 +162,7 @@ Do not send CLs removing the interior tags from such phrases.
   By default, <code>go</code> <code>mod</code> <code>tidy</code> verifies that
   the selected versions of dependencies relevant to the main module are the same
   versions that would be used by the prior Go release (Go 1.16 for a module that
-  spsecifies <code>go</code> <code>1.17</code>), and preserves
+  specifies <code>go</code> <code>1.17</code>), and preserves
   the <code>go.sum</code> entries needed by that release even for dependencies
   that are not normally needed by other commands.
 </p>
-- 
GitLab


From 57aaa19aae32a6c75a07ea8e3006fdcda7583385 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Thu, 17 Jun 2021 17:34:18 -0700
Subject: [PATCH 2258/2400] runtime: disable CPU profiling before removing the
 SIGPROF handler

Otherwise, in c-archive or c-shared mode, there is the chance of
getting a SIGPROF just after the signal handler is removed but before
profiling is disabled, in which case the program will die.

Fixes #46498

Change-Id: I5492beef45fec9fb9a7f58724356d6aedaf799ac
Reviewed-on: https://go-review.googlesource.com/c/go/+/329290
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/runtime/signal_unix.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index f2e526973d..03e2a40ce6 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -280,6 +280,8 @@ func setProcessCPUProfiler(hz int32) {
 		it.it_value = it.it_interval
 		setitimer(_ITIMER_PROF, &it, nil)
 	} else {
+		setitimer(_ITIMER_PROF, &itimerval{}, nil)
+
 		// If the Go signal handler should be disabled by default,
 		// switch back to the signal handler that was installed
 		// when we enabled profiling. We don't try to handle the case
@@ -303,8 +305,6 @@ func setProcessCPUProfiler(hz int32) {
 				setsig(_SIGPROF, h)
 			}
 		}
-
-		setitimer(_ITIMER_PROF, &itimerval{}, nil)
 	}
 }
 
-- 
GitLab


From 9401172166ee6ac64a5a74b4a8f2aa6d3f936ea1 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 17 Jun 2021 22:12:24 -0700
Subject: [PATCH 2259/2400] runtime: clarify Frames.Next documentation

I wrote code that relied on this API, but I misunderstood the original
description of the "more" result. As a consequence, my code always
stopped one frame early.

This CL expands the documentation to be more explicit and specifically
call out my confusion (i.e., that the "more" result indicates whether
the *next* Next call will return a valid Frame, and not whether this
call did).

Change-Id: If135f8f8c05425073d45377c4179e4f79e6bd6ca
Reviewed-on: https://go-review.googlesource.com/c/go/+/329389
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/runtime/example_test.go | 16 ++++++++++++----
 src/runtime/symtab.go       | 11 +++++++++--
 2 files changed, 21 insertions(+), 6 deletions(-)

diff --git a/src/runtime/example_test.go b/src/runtime/example_test.go
index e4912a5158..dcb8f7798e 100644
--- a/src/runtime/example_test.go
+++ b/src/runtime/example_test.go
@@ -12,12 +12,15 @@ import (
 
 func ExampleFrames() {
 	c := func() {
-		// Ask runtime.Callers for up to 10 pcs, including runtime.Callers itself.
+		// Ask runtime.Callers for up to 10 PCs, including runtime.Callers itself.
 		pc := make([]uintptr, 10)
 		n := runtime.Callers(0, pc)
 		if n == 0 {
-			// No pcs available. Stop now.
-			// This can happen if the first argument to runtime.Callers is large.
+			// No PCs available. This can happen if the first argument to
+			// runtime.Callers is large.
+			//
+			// Return now to avoid processing the zero Frame that would
+			// otherwise be returned by frames.Next below.
 			return
 		}
 
@@ -25,9 +28,12 @@ func ExampleFrames() {
 		frames := runtime.CallersFrames(pc)
 
 		// Loop to get frames.
-		// A fixed number of pcs can expand to an indefinite number of Frames.
+		// A fixed number of PCs can expand to an indefinite number of Frames.
 		for {
 			frame, more := frames.Next()
+
+			// Process this frame.
+			//
 			// To keep this example's output stable
 			// even if there are changes in the testing package,
 			// stop unwinding when we leave package runtime.
@@ -35,6 +41,8 @@ func ExampleFrames() {
 				break
 			}
 			fmt.Printf("- more:%v | %s\n", more, frame.Function)
+
+			// Check whether there are more frames to process after this one.
 			if !more {
 				break
 			}
diff --git a/src/runtime/symtab.go b/src/runtime/symtab.go
index 6b535dfcbf..999300a58e 100644
--- a/src/runtime/symtab.go
+++ b/src/runtime/symtab.go
@@ -68,8 +68,15 @@ func CallersFrames(callers []uintptr) *Frames {
 	return f
 }
 
-// Next returns frame information for the next caller.
-// If more is false, there are no more callers (the Frame value is valid).
+// Next returns a Frame representing the next call frame in the slice
+// of PC values. If it has already returned all call frames, Next
+// returns a zero Frame.
+//
+// The more result indicates whether the next call to Next will return
+// a valid Frame. It does not necessarily indicate whether this call
+// returned one.
+//
+// See the Frames example for idiomatic usage.
 func (ci *Frames) Next() (frame Frame, more bool) {
 	for len(ci.frames) < 2 {
 		// Find the next frame.
-- 
GitLab


From 86743e7d8652c316b5f77a84ffc83244ee10a41b Mon Sep 17 00:00:00 2001
From: Nigel Tao <nigeltao@golang.org>
Date: Sun, 18 Apr 2021 13:38:34 +1000
Subject: [PATCH 2260/2400] image: add RGBA64Image interface

The new RGBA64At method is equivalent to the existing At method (and the
new SetRGBA64 method is equivalent to the existing Set method in the
image/draw package), but they can avoid allocations from converting
concrete color types to the color.Color interface type.

Also update api/go1.17.txt and doc/go1.17.html

Fixes #44808

Change-Id: I8671f3144512b1200fa373840ed6729a5d61bc35
Reviewed-on: https://go-review.googlesource.com/c/go/+/311129
Trust: Nigel Tao <nigeltao@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Rob Pike <r@golang.org>
---
 api/go1.17.txt          |  34 ++++++-
 doc/go1.17.html         |  13 +++
 src/image/draw/draw.go  |  10 ++
 src/image/image.go      | 197 ++++++++++++++++++++++++++++++++++++++++
 src/image/image_test.go |  75 +++++++++++++++
 src/image/ycbcr.go      |  10 ++
 6 files changed, 338 insertions(+), 1 deletion(-)

diff --git a/api/go1.17.txt b/api/go1.17.txt
index 257ca271d3..c5eb381708 100644
--- a/api/go1.17.txt
+++ b/api/go1.17.txt
@@ -28,6 +28,38 @@ pkg encoding/csv, method (*Reader) FieldPos(int) (int, int)
 pkg go/build, type Context struct, ToolTags []string
 pkg go/parser, const SkipObjectResolution = 64
 pkg go/parser, const SkipObjectResolution Mode
+pkg image, method (*Alpha) RGBA64At(int, int) color.RGBA64
+pkg image, method (*Alpha) SetRGBA64(int, int, color.RGBA64)
+pkg image, method (*Alpha16) RGBA64At(int, int) color.RGBA64
+pkg image, method (*Alpha16) SetRGBA64(int, int, color.RGBA64)
+pkg image, method (*CMYK) RGBA64At(int, int) color.RGBA64
+pkg image, method (*CMYK) SetRGBA64(int, int, color.RGBA64)
+pkg image, method (*Gray) RGBA64At(int, int) color.RGBA64
+pkg image, method (*Gray) SetRGBA64(int, int, color.RGBA64)
+pkg image, method (*Gray16) RGBA64At(int, int) color.RGBA64
+pkg image, method (*Gray16) SetRGBA64(int, int, color.RGBA64)
+pkg image, method (*NRGBA) RGBA64At(int, int) color.RGBA64
+pkg image, method (*NRGBA) SetRGBA64(int, int, color.RGBA64)
+pkg image, method (*NRGBA64) RGBA64At(int, int) color.RGBA64
+pkg image, method (*NRGBA64) SetRGBA64(int, int, color.RGBA64)
+pkg image, method (*NYCbCrA) RGBA64At(int, int) color.RGBA64
+pkg image, method (*Paletted) RGBA64At(int, int) color.RGBA64
+pkg image, method (*Paletted) SetRGBA64(int, int, color.RGBA64)
+pkg image, method (*RGBA) RGBA64At(int, int) color.RGBA64
+pkg image, method (*RGBA) SetRGBA64(int, int, color.RGBA64)
+pkg image, method (*YCbCr) RGBA64At(int, int) color.RGBA64
+pkg image, type RGBA64Image interface { At, Bounds, ColorModel, RGBA64At }
+pkg image, type RGBA64Image interface, At(int, int) color.Color
+pkg image, type RGBA64Image interface, Bounds() Rectangle
+pkg image, type RGBA64Image interface, ColorModel() color.Model
+pkg image, type RGBA64Image interface, RGBA64At(int, int) color.RGBA64
+pkg image/draw, type RGBA64Image interface { At, Bounds, ColorModel, RGBA64At, Set, SetRGBA64 }
+pkg image/draw, type RGBA64Image interface, At(int, int) color.Color
+pkg image/draw, type RGBA64Image interface, Bounds() image.Rectangle
+pkg image/draw, type RGBA64Image interface, ColorModel() color.Model
+pkg image/draw, type RGBA64Image interface, RGBA64At(int, int) color.RGBA64
+pkg image/draw, type RGBA64Image interface, Set(int, int, color.Color)
+pkg image/draw, type RGBA64Image interface, SetRGBA64(int, int, color.RGBA64)
 pkg io/fs, func FileInfoToDirEntry(FileInfo) DirEntry
 pkg math, const MaxFloat64 = 1.79769e+308  // 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368
 pkg math, const MaxInt = 9223372036854775807
@@ -153,7 +185,7 @@ pkg time, const Layout = "01/02 03:04:05PM '06 -0700"
 pkg time, const Layout ideal-string
 pkg time, func UnixMicro(int64) Time
 pkg time, func UnixMilli(int64) Time
-pkg time, method (Time) IsDST() bool
 pkg time, method (Time) GoString() string
+pkg time, method (Time) IsDST() bool
 pkg time, method (Time) UnixMicro() int64
 pkg time, method (Time) UnixMilli() int64
diff --git a/doc/go1.17.html b/doc/go1.17.html
index 6424709453..9452651295 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -693,6 +693,19 @@ func Foo() bool {
   </dd>
 </dl><!-- go/format -->
 
+<dl id="image"><dt><a href="/pkg/image/">image</a></dt>
+  <dd>
+    <p><!-- CL 311129 -->
+      The concrete image types (<code>RGBA</code>, <code>Gray16</code> and so on)
+      now implement a new <a href="/pkg/image/#RGBA64Image"><code>RGBA64Image</code></a>
+      interface. Those concrete types, other than the chroma-subsampling
+      related <code>YCbCr</code> and <code>NYCbCrA</code>, also now implement
+      <a href="/pkg/image/draw/#RGBA64Image"><code>draw.RGBA64Image</code></a>, a
+      new interface in the <code>image/draw</code> package.
+    </p>
+  </dd>
+</dl><!-- image -->
+
 <dl id="io/fs"><dt><a href="/pkg/io/fs/">io/fs</a></dt>
   <dd>
     <p><!-- CL 293649 -->
diff --git a/src/image/draw/draw.go b/src/image/draw/draw.go
index 8f96aa2d18..13f6668293 100644
--- a/src/image/draw/draw.go
+++ b/src/image/draw/draw.go
@@ -23,6 +23,16 @@ type Image interface {
 	Set(x, y int, c color.Color)
 }
 
+// RGBA64Image extends both the Image and image.RGBA64Image interfaces with a
+// SetRGBA64 method to change a single pixel. SetRGBA64 is equivalent to
+// calling Set, but it can avoid allocations from converting concrete color
+// types to the color.Color interface type.
+type RGBA64Image interface {
+	image.RGBA64Image
+	Set(x, y int, c color.Color)
+	SetRGBA64(x, y int, c color.RGBA64)
+}
+
 // Quantizer produces a palette for an image.
 type Quantizer interface {
 	// Quantize appends up to cap(p) - len(p) colors to p and returns the
diff --git a/src/image/image.go b/src/image/image.go
index 8adba96ab6..930d9ac6c7 100644
--- a/src/image/image.go
+++ b/src/image/image.go
@@ -45,6 +45,17 @@ type Image interface {
 	At(x, y int) color.Color
 }
 
+// RGBA64Image is an Image whose pixels can be converted directly to a
+// color.RGBA64.
+type RGBA64Image interface {
+	// RGBA64At returns the RGBA64 color of the pixel at (x, y). It is
+	// equivalent to calling At(x, y).RGBA() and converting the resulting
+	// 32-bit return values to a color.RGBA64, but it can avoid allocations
+	// from converting concrete color types to the color.Color interface type.
+	RGBA64At(x, y int) color.RGBA64
+	Image
+}
+
 // PalettedImage is an image whose colors may come from a limited palette.
 // If m is a PalettedImage and m.ColorModel() returns a color.Palette p,
 // then m.At(x, y) should be equivalent to p[m.ColorIndexAt(x, y)]. If m's
@@ -90,6 +101,24 @@ func (p *RGBA) At(x, y int) color.Color {
 	return p.RGBAAt(x, y)
 }
 
+func (p *RGBA) RGBA64At(x, y int) color.RGBA64 {
+	if !(Point{x, y}.In(p.Rect)) {
+		return color.RGBA64{}
+	}
+	i := p.PixOffset(x, y)
+	s := p.Pix[i : i+4 : i+4] // Small cap improves performance, see https://golang.org/issue/27857
+	r := uint16(s[0])
+	g := uint16(s[1])
+	b := uint16(s[2])
+	a := uint16(s[3])
+	return color.RGBA64{
+		(r << 8) | r,
+		(g << 8) | g,
+		(b << 8) | b,
+		(a << 8) | a,
+	}
+}
+
 func (p *RGBA) RGBAAt(x, y int) color.RGBA {
 	if !(Point{x, y}.In(p.Rect)) {
 		return color.RGBA{}
@@ -118,6 +147,18 @@ func (p *RGBA) Set(x, y int, c color.Color) {
 	s[3] = c1.A
 }
 
+func (p *RGBA) SetRGBA64(x, y int, c color.RGBA64) {
+	if !(Point{x, y}.In(p.Rect)) {
+		return
+	}
+	i := p.PixOffset(x, y)
+	s := p.Pix[i : i+4 : i+4] // Small cap improves performance, see https://golang.org/issue/27857
+	s[0] = uint8(c.R >> 8)
+	s[1] = uint8(c.G >> 8)
+	s[2] = uint8(c.B >> 8)
+	s[3] = uint8(c.A >> 8)
+}
+
 func (p *RGBA) SetRGBA(x, y int, c color.RGBA) {
 	if !(Point{x, y}.In(p.Rect)) {
 		return
@@ -311,6 +352,11 @@ func (p *NRGBA) At(x, y int) color.Color {
 	return p.NRGBAAt(x, y)
 }
 
+func (p *NRGBA) RGBA64At(x, y int) color.RGBA64 {
+	r, g, b, a := p.NRGBAAt(x, y).RGBA()
+	return color.RGBA64{uint16(r), uint16(g), uint16(b), uint16(a)}
+}
+
 func (p *NRGBA) NRGBAAt(x, y int) color.NRGBA {
 	if !(Point{x, y}.In(p.Rect)) {
 		return color.NRGBA{}
@@ -339,6 +385,24 @@ func (p *NRGBA) Set(x, y int, c color.Color) {
 	s[3] = c1.A
 }
 
+func (p *NRGBA) SetRGBA64(x, y int, c color.RGBA64) {
+	if !(Point{x, y}.In(p.Rect)) {
+		return
+	}
+	r, g, b, a := uint32(c.R), uint32(c.G), uint32(c.B), uint32(c.A)
+	if (a != 0) && (a != 0xffff) {
+		r = (r * 0xffff) / a
+		g = (g * 0xffff) / a
+		b = (b * 0xffff) / a
+	}
+	i := p.PixOffset(x, y)
+	s := p.Pix[i : i+4 : i+4] // Small cap improves performance, see https://golang.org/issue/27857
+	s[0] = uint8(r >> 8)
+	s[1] = uint8(g >> 8)
+	s[2] = uint8(b >> 8)
+	s[3] = uint8(a >> 8)
+}
+
 func (p *NRGBA) SetNRGBA(x, y int, c color.NRGBA) {
 	if !(Point{x, y}.In(p.Rect)) {
 		return
@@ -415,6 +479,11 @@ func (p *NRGBA64) At(x, y int) color.Color {
 	return p.NRGBA64At(x, y)
 }
 
+func (p *NRGBA64) RGBA64At(x, y int) color.RGBA64 {
+	r, g, b, a := p.NRGBA64At(x, y).RGBA()
+	return color.RGBA64{uint16(r), uint16(g), uint16(b), uint16(a)}
+}
+
 func (p *NRGBA64) NRGBA64At(x, y int) color.NRGBA64 {
 	if !(Point{x, y}.In(p.Rect)) {
 		return color.NRGBA64{}
@@ -452,6 +521,28 @@ func (p *NRGBA64) Set(x, y int, c color.Color) {
 	s[7] = uint8(c1.A)
 }
 
+func (p *NRGBA64) SetRGBA64(x, y int, c color.RGBA64) {
+	if !(Point{x, y}.In(p.Rect)) {
+		return
+	}
+	r, g, b, a := uint32(c.R), uint32(c.G), uint32(c.B), uint32(c.A)
+	if (a != 0) && (a != 0xffff) {
+		r = (r * 0xffff) / a
+		g = (g * 0xffff) / a
+		b = (b * 0xffff) / a
+	}
+	i := p.PixOffset(x, y)
+	s := p.Pix[i : i+8 : i+8] // Small cap improves performance, see https://golang.org/issue/27857
+	s[0] = uint8(r >> 8)
+	s[1] = uint8(r)
+	s[2] = uint8(g >> 8)
+	s[3] = uint8(g)
+	s[4] = uint8(b >> 8)
+	s[5] = uint8(b)
+	s[6] = uint8(a >> 8)
+	s[7] = uint8(a)
+}
+
 func (p *NRGBA64) SetNRGBA64(x, y int, c color.NRGBA64) {
 	if !(Point{x, y}.In(p.Rect)) {
 		return
@@ -532,6 +623,12 @@ func (p *Alpha) At(x, y int) color.Color {
 	return p.AlphaAt(x, y)
 }
 
+func (p *Alpha) RGBA64At(x, y int) color.RGBA64 {
+	a := uint16(p.AlphaAt(x, y).A)
+	a |= a << 8
+	return color.RGBA64{a, a, a, a}
+}
+
 func (p *Alpha) AlphaAt(x, y int) color.Alpha {
 	if !(Point{x, y}.In(p.Rect)) {
 		return color.Alpha{}
@@ -554,6 +651,14 @@ func (p *Alpha) Set(x, y int, c color.Color) {
 	p.Pix[i] = color.AlphaModel.Convert(c).(color.Alpha).A
 }
 
+func (p *Alpha) SetRGBA64(x, y int, c color.RGBA64) {
+	if !(Point{x, y}.In(p.Rect)) {
+		return
+	}
+	i := p.PixOffset(x, y)
+	p.Pix[i] = uint8(c.A >> 8)
+}
+
 func (p *Alpha) SetAlpha(x, y int, c color.Alpha) {
 	if !(Point{x, y}.In(p.Rect)) {
 		return
@@ -626,6 +731,11 @@ func (p *Alpha16) At(x, y int) color.Color {
 	return p.Alpha16At(x, y)
 }
 
+func (p *Alpha16) RGBA64At(x, y int) color.RGBA64 {
+	a := p.Alpha16At(x, y).A
+	return color.RGBA64{a, a, a, a}
+}
+
 func (p *Alpha16) Alpha16At(x, y int) color.Alpha16 {
 	if !(Point{x, y}.In(p.Rect)) {
 		return color.Alpha16{}
@@ -650,6 +760,15 @@ func (p *Alpha16) Set(x, y int, c color.Color) {
 	p.Pix[i+1] = uint8(c1.A)
 }
 
+func (p *Alpha16) SetRGBA64(x, y int, c color.RGBA64) {
+	if !(Point{x, y}.In(p.Rect)) {
+		return
+	}
+	i := p.PixOffset(x, y)
+	p.Pix[i+0] = uint8(c.A >> 8)
+	p.Pix[i+1] = uint8(c.A)
+}
+
 func (p *Alpha16) SetAlpha16(x, y int, c color.Alpha16) {
 	if !(Point{x, y}.In(p.Rect)) {
 		return
@@ -723,6 +842,12 @@ func (p *Gray) At(x, y int) color.Color {
 	return p.GrayAt(x, y)
 }
 
+func (p *Gray) RGBA64At(x, y int) color.RGBA64 {
+	gray := uint16(p.GrayAt(x, y).Y)
+	gray |= gray << 8
+	return color.RGBA64{gray, gray, gray, 0xffff}
+}
+
 func (p *Gray) GrayAt(x, y int) color.Gray {
 	if !(Point{x, y}.In(p.Rect)) {
 		return color.Gray{}
@@ -745,6 +870,16 @@ func (p *Gray) Set(x, y int, c color.Color) {
 	p.Pix[i] = color.GrayModel.Convert(c).(color.Gray).Y
 }
 
+func (p *Gray) SetRGBA64(x, y int, c color.RGBA64) {
+	if !(Point{x, y}.In(p.Rect)) {
+		return
+	}
+	// This formula is the same as in color.grayModel.
+	gray := (19595*uint32(c.R) + 38470*uint32(c.G) + 7471*uint32(c.B) + 1<<15) >> 24
+	i := p.PixOffset(x, y)
+	p.Pix[i] = uint8(gray)
+}
+
 func (p *Gray) SetGray(x, y int, c color.Gray) {
 	if !(Point{x, y}.In(p.Rect)) {
 		return
@@ -804,6 +939,11 @@ func (p *Gray16) At(x, y int) color.Color {
 	return p.Gray16At(x, y)
 }
 
+func (p *Gray16) RGBA64At(x, y int) color.RGBA64 {
+	gray := p.Gray16At(x, y).Y
+	return color.RGBA64{gray, gray, gray, 0xffff}
+}
+
 func (p *Gray16) Gray16At(x, y int) color.Gray16 {
 	if !(Point{x, y}.In(p.Rect)) {
 		return color.Gray16{}
@@ -828,6 +968,17 @@ func (p *Gray16) Set(x, y int, c color.Color) {
 	p.Pix[i+1] = uint8(c1.Y)
 }
 
+func (p *Gray16) SetRGBA64(x, y int, c color.RGBA64) {
+	if !(Point{x, y}.In(p.Rect)) {
+		return
+	}
+	// This formula is the same as in color.gray16Model.
+	gray := (19595*uint32(c.R) + 38470*uint32(c.G) + 7471*uint32(c.B) + 1<<15) >> 16
+	i := p.PixOffset(x, y)
+	p.Pix[i+0] = uint8(gray >> 8)
+	p.Pix[i+1] = uint8(gray)
+}
+
 func (p *Gray16) SetGray16(x, y int, c color.Gray16) {
 	if !(Point{x, y}.In(p.Rect)) {
 		return
@@ -888,6 +1039,11 @@ func (p *CMYK) At(x, y int) color.Color {
 	return p.CMYKAt(x, y)
 }
 
+func (p *CMYK) RGBA64At(x, y int) color.RGBA64 {
+	r, g, b, a := p.CMYKAt(x, y).RGBA()
+	return color.RGBA64{uint16(r), uint16(g), uint16(b), uint16(a)}
+}
+
 func (p *CMYK) CMYKAt(x, y int) color.CMYK {
 	if !(Point{x, y}.In(p.Rect)) {
 		return color.CMYK{}
@@ -916,6 +1072,19 @@ func (p *CMYK) Set(x, y int, c color.Color) {
 	s[3] = c1.K
 }
 
+func (p *CMYK) SetRGBA64(x, y int, c color.RGBA64) {
+	if !(Point{x, y}.In(p.Rect)) {
+		return
+	}
+	cc, mm, yy, kk := color.RGBToCMYK(uint8(c.R>>8), uint8(c.G>>8), uint8(c.B>>8))
+	i := p.PixOffset(x, y)
+	s := p.Pix[i : i+4 : i+4] // Small cap improves performance, see https://golang.org/issue/27857
+	s[0] = cc
+	s[1] = mm
+	s[2] = yy
+	s[3] = kk
+}
+
 func (p *CMYK) SetCMYK(x, y int, c color.CMYK) {
 	if !(Point{x, y}.In(p.Rect)) {
 		return
@@ -988,6 +1157,26 @@ func (p *Paletted) At(x, y int) color.Color {
 	return p.Palette[p.Pix[i]]
 }
 
+func (p *Paletted) RGBA64At(x, y int) color.RGBA64 {
+	if len(p.Palette) == 0 {
+		return color.RGBA64{}
+	}
+	c := color.Color(nil)
+	if !(Point{x, y}.In(p.Rect)) {
+		c = p.Palette[0]
+	} else {
+		i := p.PixOffset(x, y)
+		c = p.Palette[p.Pix[i]]
+	}
+	r, g, b, a := c.RGBA()
+	return color.RGBA64{
+		uint16(r),
+		uint16(g),
+		uint16(b),
+		uint16(a),
+	}
+}
+
 // PixOffset returns the index of the first element of Pix that corresponds to
 // the pixel at (x, y).
 func (p *Paletted) PixOffset(x, y int) int {
@@ -1002,6 +1191,14 @@ func (p *Paletted) Set(x, y int, c color.Color) {
 	p.Pix[i] = uint8(p.Palette.Index(c))
 }
 
+func (p *Paletted) SetRGBA64(x, y int, c color.RGBA64) {
+	if !(Point{x, y}.In(p.Rect)) {
+		return
+	}
+	i := p.PixOffset(x, y)
+	p.Pix[i] = uint8(p.Palette.Index(c))
+}
+
 func (p *Paletted) ColorIndexAt(x, y int) uint8 {
 	if !(Point{x, y}.In(p.Rect)) {
 		return 0
diff --git a/src/image/image_test.go b/src/image/image_test.go
index b9b9bfaa28..c64b6107b7 100644
--- a/src/image/image_test.go
+++ b/src/image/image_test.go
@@ -6,6 +6,7 @@ package image
 
 import (
 	"image/color"
+	"image/color/palette"
 	"testing"
 )
 
@@ -191,6 +192,80 @@ func Test16BitsPerColorChannel(t *testing.T) {
 	}
 }
 
+func TestRGBA64Image(t *testing.T) {
+	// memset sets every element of s to v.
+	memset := func(s []byte, v byte) {
+		for i := range s {
+			s[i] = v
+		}
+	}
+
+	r := Rect(0, 0, 3, 2)
+	testCases := []Image{
+		NewAlpha(r),
+		NewAlpha16(r),
+		NewCMYK(r),
+		NewGray(r),
+		NewGray16(r),
+		NewNRGBA(r),
+		NewNRGBA64(r),
+		NewNYCbCrA(r, YCbCrSubsampleRatio444),
+		NewPaletted(r, palette.Plan9),
+		NewRGBA(r),
+		NewRGBA64(r),
+		NewYCbCr(r, YCbCrSubsampleRatio444),
+	}
+	for _, tc := range testCases {
+		switch tc := tc.(type) {
+		// Most of the concrete image types in the testCases implement the
+		// draw.RGBA64Image interface: they have a SetRGBA64 method. We use an
+		// interface literal here, instead of importing "image/draw", to avoid
+		// an import cycle.
+		//
+		// The YCbCr and NYCbCrA types are special-cased. Chroma subsampling
+		// means that setting one pixel can modify neighboring pixels. They
+		// don't have Set or SetRGBA64 methods because that side effect could
+		// be surprising. Here, we just memset the channel buffers instead.
+		case interface {
+			SetRGBA64(x, y int, c color.RGBA64)
+		}:
+			tc.SetRGBA64(1, 1, color.RGBA64{0x7FFF, 0x3FFF, 0x0000, 0x7FFF})
+
+		case *NYCbCrA:
+			memset(tc.YCbCr.Y, 0x77)
+			memset(tc.YCbCr.Cb, 0x88)
+			memset(tc.YCbCr.Cr, 0x99)
+			memset(tc.A, 0xAA)
+
+		case *YCbCr:
+			memset(tc.Y, 0x77)
+			memset(tc.Cb, 0x88)
+			memset(tc.Cr, 0x99)
+
+		default:
+			t.Errorf("could not initialize pixels for %T", tc)
+			continue
+		}
+
+		// Check that RGBA64At(x, y) is equivalent to At(x, y).RGBA().
+		rgba64Image, ok := tc.(RGBA64Image)
+		if !ok {
+			t.Errorf("%T is not an RGBA64Image", tc)
+			continue
+		}
+		got := rgba64Image.RGBA64At(1, 1)
+		wantR, wantG, wantB, wantA := tc.At(1, 1).RGBA()
+		if (uint32(got.R) != wantR) || (uint32(got.G) != wantG) ||
+			(uint32(got.B) != wantB) || (uint32(got.A) != wantA) {
+			t.Errorf("%T:\ngot  (0x%04X, 0x%04X, 0x%04X, 0x%04X)\n"+
+				"want (0x%04X, 0x%04X, 0x%04X, 0x%04X)", tc,
+				got.R, got.G, got.B, got.A,
+				wantR, wantG, wantB, wantA)
+			continue
+		}
+	}
+}
+
 func BenchmarkAt(b *testing.B) {
 	for _, tc := range testImages {
 		b.Run(tc.name, func(b *testing.B) {
diff --git a/src/image/ycbcr.go b/src/image/ycbcr.go
index fbdffe1bd1..328b90d152 100644
--- a/src/image/ycbcr.go
+++ b/src/image/ycbcr.go
@@ -71,6 +71,11 @@ func (p *YCbCr) At(x, y int) color.Color {
 	return p.YCbCrAt(x, y)
 }
 
+func (p *YCbCr) RGBA64At(x, y int) color.RGBA64 {
+	r, g, b, a := p.YCbCrAt(x, y).RGBA()
+	return color.RGBA64{uint16(r), uint16(g), uint16(b), uint16(a)}
+}
+
 func (p *YCbCr) YCbCrAt(x, y int) color.YCbCr {
 	if !(Point{x, y}.In(p.Rect)) {
 		return color.YCbCr{}
@@ -210,6 +215,11 @@ func (p *NYCbCrA) At(x, y int) color.Color {
 	return p.NYCbCrAAt(x, y)
 }
 
+func (p *NYCbCrA) RGBA64At(x, y int) color.RGBA64 {
+	r, g, b, a := p.NYCbCrAAt(x, y).RGBA()
+	return color.RGBA64{uint16(r), uint16(g), uint16(b), uint16(a)}
+}
+
 func (p *NYCbCrA) NYCbCrAAt(x, y int) color.NYCbCrA {
 	if !(Point{X: x, Y: y}.In(p.Rect)) {
 		return color.NYCbCrA{}
-- 
GitLab


From b73cc4b02b3801603b3ce0bcc57cf01d6aa9a4dd Mon Sep 17 00:00:00 2001
From: Daniel Theophanes <kardianos@gmail.com>
Date: Wed, 16 Jun 2021 11:46:00 -0500
Subject: [PATCH 2261/2400] database/sql: do not rely on timeout for deadlock
 test

Fixes #46783

Change-Id: I8a8d1716279a041a7411c0c47a440a7997b39c80
Reviewed-on: https://go-review.googlesource.com/c/go/+/328649
Run-TryBot: Daniel Theophanes <kardianos@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Trust: Carlos Amedee <carlos@golang.org>
---
 src/database/sql/sql_test.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/database/sql/sql_test.go b/src/database/sql/sql_test.go
index 80f63e877d..7d1cb9b85a 100644
--- a/src/database/sql/sql_test.go
+++ b/src/database/sql/sql_test.go
@@ -2838,9 +2838,10 @@ func TestTxStmtDeadlock(t *testing.T) {
 	db := newTestDB(t, "people")
 	defer closeDB(t, db)
 
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Millisecond)
+	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	tx, err := db.BeginTx(ctx, nil)
+	cancel()
 	if err != nil {
 		t.Fatal(err)
 	}
-- 
GitLab


From 460900a7b51f917888cb17608367979243178fe1 Mon Sep 17 00:00:00 2001
From: "Andrew G. Morgan" <agm@google.com>
Date: Sat, 19 Jun 2021 09:46:52 -0700
Subject: [PATCH 2262/2400] os/signal: test with a significantly longer fatal
 timeout

We've observed some occasional os-arch specific timeouts
in signal.TestSignalTrace(). While the main purpose of a
short timeout is to ensure the passing tests complete
quickly, the unexpected failure path can tolerate waiting
longer (the test is not intended to test how slow or
overloaded the OS is at the time it is run).

Fixes #46736
Change-Id: Ib392fc6ce485a919612784ca88ed76c30f4898e2
Reviewed-on: https://go-review.googlesource.com/c/go/+/329502
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/os/signal/signal_test.go | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/os/signal/signal_test.go b/src/os/signal/signal_test.go
index cea68742d2..649854b746 100644
--- a/src/os/signal/signal_test.go
+++ b/src/os/signal/signal_test.go
@@ -32,6 +32,11 @@ import (
 // The current value is set based on flakes observed in the Go builders.
 var settleTime = 100 * time.Millisecond
 
+// fatalWaitingTime is an absurdly long time to wait for signals to be
+// delivered but, using it, we (hopefully) eliminate test flakes on the
+// build servers. See #46736 for discussion.
+var fatalWaitingTime = 30 * time.Second
+
 func init() {
 	if testenv.Builder() == "solaris-amd64-oraclerel" {
 		// The solaris-amd64-oraclerel builder has been observed to time out in
@@ -84,7 +89,7 @@ func waitSig1(t *testing.T, c <-chan os.Signal, sig os.Signal, all bool) {
 	// General user code should filter out all unexpected signals instead of just
 	// SIGURG, but since os/signal is tightly coupled to the runtime it seems
 	// appropriate to be stricter here.
-	for time.Since(start) < settleTime {
+	for time.Since(start) < fatalWaitingTime {
 		select {
 		case s := <-c:
 			if s == sig {
@@ -97,7 +102,7 @@ func waitSig1(t *testing.T, c <-chan os.Signal, sig os.Signal, all bool) {
 			timer.Reset(settleTime / 10)
 		}
 	}
-	t.Fatalf("timeout after %v waiting for %v", settleTime, sig)
+	t.Fatalf("timeout after %v waiting for %v", fatalWaitingTime, sig)
 }
 
 // quiesce waits until we can be reasonably confident that all pending signals
-- 
GitLab


From 117ebe0f52efc5128a9c86722e07fe22cb65450d Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Wed, 16 Jun 2021 14:48:45 -0400
Subject: [PATCH 2263/2400] cmd/go: do not require the module cache to exist
 for 'go mod edit'

Updates #46695

Change-Id: I4afbc1401ef4183d94c1ac6271394fac1fff95ae
Reviewed-on: https://go-review.googlesource.com/c/go/+/328769
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modfetch/cache.go             |  2 +-
 .../go/testdata/script/mod_edit_no_modcache.txt   | 15 +++++++++++++++
 2 files changed, 16 insertions(+), 1 deletion(-)
 create mode 100644 src/cmd/go/testdata/script/mod_edit_no_modcache.txt

diff --git a/src/cmd/go/internal/modfetch/cache.go b/src/cmd/go/internal/modfetch/cache.go
index f3b58a172a..b01b467413 100644
--- a/src/cmd/go/internal/modfetch/cache.go
+++ b/src/cmd/go/internal/modfetch/cache.go
@@ -152,7 +152,7 @@ func lockVersion(mod module.Version) (unlock func(), err error) {
 // If err is nil, the caller MUST eventually call the unlock function.
 func SideLock() (unlock func(), err error) {
 	if err := checkCacheDir(); err != nil {
-		base.Fatalf("go: %v", err)
+		return nil, err
 	}
 
 	path := filepath.Join(cfg.GOMODCACHE, "cache", "lock")
diff --git a/src/cmd/go/testdata/script/mod_edit_no_modcache.txt b/src/cmd/go/testdata/script/mod_edit_no_modcache.txt
new file mode 100644
index 0000000000..ced15bb301
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_edit_no_modcache.txt
@@ -0,0 +1,15 @@
+# 'go mod edit' opportunistically locks the side-lock file in the module cache,
+# for compatibility with older versions of the 'go' command.
+# It does not otherwise depend on the module cache, so it should not
+# fail if the module cache directory cannot be created.
+
+[root] skip
+
+mkdir $WORK/readonly
+chmod 0555 $WORK/readonly
+env GOPATH=$WORK/readonly/nonexist
+
+go mod edit -go=1.17
+
+-- go.mod --
+module example.com/m
-- 
GitLab


From 1de332996c25bf99bb31c82393dc018e6cec18ae Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 17 Jun 2021 12:28:53 -0400
Subject: [PATCH 2264/2400] doc/go1.17: document go/parser.SkipObjectResolution

Documents the mode added in CL 306149 to skip object resolution.

Fixes #46298

Change-Id: I6a14aaa00790f9f7e4e4ba17033355f5e878d74b
Reviewed-on: https://go-review.googlesource.com/c/go/+/329009
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 doc/go1.17.html | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 9452651295..50559c8933 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -693,6 +693,16 @@ func Foo() bool {
   </dd>
 </dl><!-- go/format -->
 
+<dl id="go/parser"><dt><a href="/pkg/go/parser/">go/parser</a></dt>
+  <dd>
+    <p><!-- CL 306149 -->
+      The new <a href="/pkg/go/parser/#SkipObjectResolution"><code>SkipObjectResolution</code></a>
+      <code>Mode</code> value instructs the parser not to resolve identifiers to
+      their declaration. This may improve parsing speed.
+    </p>
+  </dd>
+</dl><!-- go/parser -->
+
 <dl id="image"><dt><a href="/pkg/image/">image</a></dt>
   <dd>
     <p><!-- CL 311129 -->
-- 
GitLab


From 85a2e24afd87d94c62f78672dc28c1991b2a271c Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Tue, 15 Jun 2021 07:13:08 -0400
Subject: [PATCH 2265/2400] doc/go1.17: add security-related release notes

Change-Id: I573def0f48fe66a1bc60fff321ab007c76b47ef0
Reviewed-on: https://go-review.googlesource.com/c/go/+/327810
Reviewed-by: Katie Hockman <katie@golang.org>
Trust: Katie Hockman <katie@golang.org>
Trust: Filippo Valsorda <filippo@golang.org>
---
 doc/go1.17.html | 124 ++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 115 insertions(+), 9 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 50559c8933..f1b3e3fdc7 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -441,6 +441,67 @@ func Foo() bool {
   <a href="/pkg/runtime/cgo#Handle">runtime/cgo.Handle</a> for more information.
 </p>
 
+<h3 id="semicolons">URL query parsing</h3>
+<!-- CL 325697, CL 326309 -->
+
+<p>
+  The <code>net/url</code> and <code>net/http</code> packages used to accept
+  <code>";"</code> (semicolon) as a setting separator in URL queries, in
+  addition to <code>"&"</code> (ampersand). Now, settings with non-percent-encoded
+  semicolons are rejected and <code>net/http</code> servers will log a warning to
+  <a href="/pkg/net/http#Server.ErrorLog"><code>Server.ErrorLog</code></a>
+  when encountering one in a request URL.
+</p>
+
+<p>
+  For example, before Go 1.17 the <a href="/pkg/net/url#URL.Query"><code>Query</code></a>
+  method of the URL <code>example?a=1;b=2&c=3</code> would have returned
+  <code>map[a:[1] b:[2] c:[3]]</code>, while now it returns <code>map[c:[3]]</code>.
+</p>
+
+<p>
+  When encountering such a query string,
+  <a href="/pkg/net/url#URL.Query"><code>URL.Query</code></a>
+  and
+  <a href="/pkg/net/http#Request.FormValue"><code>Request.FormValue</code></a>
+  ignore any settings that contain a semicolon,
+  <a href="/pkg/net/url#ParseQuery"><code>ParseQuery</code></a>
+  returns the remaining settings and an error, and
+  <a href="/pkg/net/http#Request.ParseForm"><code>Request.ParseForm</code></a>
+  and
+  <a href="/pkg/net/http#Request.ParseMultipartForm"><code>Request.ParseMultipartForm</code></a>
+  return an error but still set <code>Request</code> fields based on the
+  remaining settings.
+</p>
+
+<p>
+  <code>net/http</code> users can restore the original behavior by using the new
+  <a href="/pkg/net/http#AllowQuerySemicolons"><code>AllowQuerySemicolons</code></a>
+  handler wrapper. This will also suppress the <code>ErrorLog</code> warning.
+  Note that accepting semicolons as query separators can lead to security issues
+  if different systems interpret cache keys differently.
+  See <a href="https://golang.org/issue/25192">issue 25192</a> for more information.
+</p>
+
+<h3 id="ALPN">TLS strict ALPN</h3>
+<!-- CL 289209, CL 325432 -->
+
+<p>
+  When <a href="/pkg/crypto/tls#Config.NextProtos"><code>Config.NextProtos</code></a>
+  is set, servers now enforce that there is an overlap between the configured
+  protocols and the ALPN protocols advertised by the client, if any. If there is
+  no mutually supported protocol, the connection is closed with the
+  <code>no_application_protocol</code> alert, as required by RFC 7301. This
+  helps mitigate <a href="https://alpaca-attack.com/">the ALPACA cross-protocol attack</a>.
+</p>
+
+<p>
+  As an exception, when the value <code>"h2"</code> is included in the server's
+  <code>Config.NextProtos</code>, HTTP/1.1 clients will be allowed to connect as
+  if they didn't support ALPN.
+  See <a href="https://golang.org/issue/46310">issue 46310</a> for more information.
+</p>
+
 <h3 id="minor_library_changes">Minor changes to the library</h3>
 
 <p>
@@ -549,14 +610,6 @@ func Foo() bool {
       methods. Canceling the context after the handshake has finished has no effect.
     </p>
 
-    <p><!-- CL 289209 -->
-      When <a href="/pkg/crypto/tls#Config.NextProtos"><code>Config.NextProtos</code></a>
-      is set, servers now enforce that there is an overlap between the
-      configured protocols and the protocols advertised by the client, if any.
-      If there is no overlap the connection is closed with the
-      <code>no_application_protocol</code> alert, as required by RFC 7301.
-    </p>
-
     <p><!-- CL 314609 -->
       Cipher suite ordering is now handled entirely by the
       <code>crypto/tls</code> package. Currently, cipher suites are sorted based
@@ -658,6 +711,22 @@ func Foo() bool {
   </dd>
 </dl><!-- encoding/csv -->
 
+<dl id="encoding/xml"><dt><a href="/pkg/encoding/xml/">encoding/xml</a></dt>
+  <dd>
+    <p><!-- CL 277893 -->
+      When a comment appears within a
+      <a href="/pkg/encoding/xml/#Directive"><code>Directive</code></a>, it is now replaced
+      with a single space instead of being completely elided.
+    </p>
+
+    <p>
+      Invalid element or attribute names with leading, trailing, or multiple
+      colons are now stored unmodified into the
+      <a href="/pkg/encoding/xml/#Name"><code>Name.Local</code></a> field.
+    </p>
+  </dd>
+</dl><!-- encoding/xml -->
+
 <dl id="flag"><dt><a href="/pkg/flag/">flag</a></dt>
   <dd>
     <p><!-- CL 271788 -->
@@ -744,6 +813,20 @@ func Foo() bool {
   </dd>
 </dl><!-- mime -->
 
+<dl id="mime/multipart"><dt><a href="/pkg/mime/multipart/">mime/multipart</a></dt>
+  <dd>
+    <p><!-- CL 313809 -->
+      <a href="/pkg/mime/multipart/#Part.FileName"><code>Part.FileName</code></a>
+      now applies
+      <a href="/pkg/path/filepath/#Base"><code>filepath.Base</code></a> to the
+      return value. This mitigates potential path traversal vulnerabilities in
+      applications that accept multipart messages, such as <code>net/http</code>
+      servers that call
+      <a href="/pkg/net/http/#Request.FormFile"><code>Request.FormFile</code></a>.
+    </p>
+  </dd>
+</dl><!-- mime/multipart -->
+
 <dl id="net"><dt><a href="/pkg/net/">net</a></dt>
   <dd>
     <p><!-- CL 272668 -->
@@ -763,7 +846,7 @@ func Foo() bool {
       the <a href="/pkg/net/#Error"><code>net.Error</code></a> interface.
     </p>
 
-    <p><!-- CL325829 -->
+    <p><!-- CL 325829 -->
       The <a href="/pkg/net/#ParseIP"><code>ParseIP</code></a> and <a href="/pkg/net/#ParseCIDR"><code>ParseCIDR</code></a>
       functions now reject IPv4 addresses which contain decimal components with leading zeros.
 
@@ -794,6 +877,29 @@ func Foo() bool {
       The <a href="/pkg/net/http/#ReadRequest"><code>ReadRequest</code></a> function
       now returns an error when the request has multiple Host headers.
     </p>
+
+    <p><!-- CL 313950 -->
+      When producing a redirect to the cleaned version of a URL,
+      <a href="/pkg/net/http/#ServeMux"><code>ServeMux</code></a> now always
+      uses relative URLs in the <code>Location</code> header. Previously it
+      would echo the full URL of the request, which could lead to unintended
+      redirects if the client could be made to send an absolute request URL.
+    </p>
+
+    <p><!-- CL 308009, CL 313489 -->
+      When interpreting certain HTTP headers handled by <code>net/http</code>,
+      non-ASCII characters are now ignored or rejected.
+    </p>
+
+    <p><!-- CL 325697 -->
+      If
+      <a href="/pkg/net/http/#Request.ParseForm"><code>Request.ParseForm</code></a>
+      returns an error when called by
+      <a href="/pkg/net/http/#Request.ParseMultipartForm"><code>Request.ParseMultipartForm</code></a>,
+      the latter now continues populating
+      <a href="/pkg/net/http/#Request.MultipartForm"><code>Request.MultipartForm</code></a>
+      before returning it.
+    </p>
   </dd>
 </dl><!-- net/http -->
 
-- 
GitLab


From 7a5e7047a4606e1deab7d4adcf9f057c7f8ce88c Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo@golang.org>
Date: Tue, 15 Jun 2021 10:59:58 -0400
Subject: [PATCH 2266/2400] doc/go1.17: add Go 1.18 pre-announcements

Updates #41682
Updates #45428

Change-Id: Ia31d454284f0e114bd29ba398a2858fc90454032
Reviewed-on: https://go-review.googlesource.com/c/go/+/327811
Trust: Filippo Valsorda <filippo@golang.org>
Trust: Katie Hockman <katie@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
---
 doc/go1.17.html | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index f1b3e3fdc7..c9b64da244 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -629,6 +629,15 @@ func Foo() bool {
       weakness</a>. They are still enabled by default but only as a last resort,
       thanks to the cipher suite ordering change above.
     </p>
+
+    <p><!-- golang.org/issue/45428 -->
+      Beginning in the next release, Go 1.18, the
+      <a href="/pkg/crypto/tls/#Config.MinVersion"><code>Config.MinVersion</code></a>
+      for <code>crypto/tls</code> clients will default to TLS 1.2, disabling TLS 1.0
+      and TLS 1.1 by default. Applications will be able to override the change by
+      explicitly setting <code>Config.MinVersion</code>.
+      This will not affect <code>crypto/tls</code> servers.
+    </p>
   </dd>
 </dl><!-- crypto/tls -->
 
@@ -656,6 +665,14 @@ func Foo() bool {
       roots. This adds support for the new system trusted certificate store in
       FreeBSD 12.2+.
     </p>
+
+    <p><!-- golang.org/issue/41682 -->
+      Beginning in the next release, Go 1.18, <code>crypto/x509</code> will
+      reject certificates signed with the SHA-1 hash function. This doesn't
+      apply to self-signed root certificates. Practical attacks against SHA-1
+      <a href="https://shattered.io/">have been demonstrated in 2017</a> and publicly
+      trusted Certificate Authorities have not issued SHA-1 certificates since 2015.
+    </p>
   </dd>
 </dl><!-- crypto/x509 -->
 
-- 
GitLab


From ced0fdbad0655d63d535390b1a7126fd1fef8348 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Fri, 18 Jun 2021 15:07:00 -0700
Subject: [PATCH 2267/2400] doc/go1.17: note deprecation of 'go get' for
 installing commands

Fixes #43684

Change-Id: I8982f6816c002c71e62f37a926c8543e34b8b785
Reviewed-on: https://go-review.googlesource.com/c/go/+/329549
Trust: Jay Conrod <jayconrod@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 doc/go1.17.html | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index c9b64da244..02cd18d037 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -214,6 +214,16 @@ Do not send CLs removing the interior tags from such phrases.
   <code>environment</code> for details.
 </p>
 
+<p><!-- golang.org/issue/43684 -->
+  <code>go</code> <code>get</code> prints a deprecation warning when installing
+  commands outside the main module (without the <code>-d</code> flag).
+  <code>go</code> <code>install</code> <code>cmd@version</code> should be used
+  instead to install a command at a specific version, using a suffix like
+  <code>@latest</code> or <code>@v1.2.3</code>. In Go 1.18, the <code>-d</code>
+  flag will always be enabled, and <code>go</code> <code>get</code> will only
+  be used to change dependencies in <code>go.mod</code>.
+</p>
+
 <h4 id="missing-go-directive"><code>go.mod</code> files missing <code>go</code> directives</h4>
 
 <p><!-- golang.org/issue/44976 -->
-- 
GitLab


From 2e542c3c061950dbaf202645fb00bcf4aa5861a0 Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Mon, 21 Jun 2021 12:09:43 -0400
Subject: [PATCH 2268/2400] runtime/pprof: deflake TestMorestack more

Apparently, TestMorestack is still flaky on darwin/arm64 builder
after CL 307730. Let it spend more time in copying the stack.
With this CL, on my Apple M1 machine it passes reliably in short
mode for 1000 runs, and reliably gets 250+ samples in the 5-second
interval in long mode.

May fix #46755.

Change-Id: I07b36c1cf63ad35f7820e1f8e837e29376a37b2a
Reviewed-on: https://go-review.googlesource.com/c/go/+/329869
Trust: Cherry Mui <cherryyz@google.com>
Run-TryBot: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
---
 src/runtime/pprof/pprof_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go
index f6ae15daab..7c71d8263b 100644
--- a/src/runtime/pprof/pprof_test.go
+++ b/src/runtime/pprof/pprof_test.go
@@ -623,7 +623,7 @@ func growstack1() {
 
 //go:noinline
 func growstack(n int) {
-	var buf [8 << 16]byte
+	var buf [8 << 18]byte
 	use(buf)
 	if n > 0 {
 		growstack(n - 1)
@@ -631,7 +631,7 @@ func growstack(n int) {
 }
 
 //go:noinline
-func use(x [8 << 16]byte) {}
+func use(x [8 << 18]byte) {}
 
 func TestBlockProfile(t *testing.T) {
 	type TestCase struct {
-- 
GitLab


From 16e82be454cbf41299e6a055d54d489ca4612ee0 Mon Sep 17 00:00:00 2001
From: Derek Parker <parkerderek86@gmail.com>
Date: Thu, 17 Jun 2021 20:22:40 +0000
Subject: [PATCH 2269/2400] runtime: fix crash during VDSO calls on PowerPC

This patch reinstates a fix for PowerPC with regard to making VDSO calls
while receiving a signal, and subsequently crashing. The crash happens
because certain VDSO calls can modify the r30 register, which is where g
is stored. This change was reverted for PowerPC because r30 is supposed
to be a non-volatile register. This is true, but that only makes a
guarantee across function calls, but not "within" a function call. This
patch was seemingly fine before because the Linux kernel still had hand
rolled assembly VDSO function calls, however with a recent change to C
function calls it seems the compiler used can generate instructions
which temporarily clobber r30. This means that when we receive a signal
during one of these calls the value of r30 will not be the g as the
runtime expects, causing a segfault.

You can see from this assembly dump how the register is clobbered during
the call:

(the following is from a 5.13rc2 kernel)

```
Dump of assembler code for function __cvdso_clock_gettime_data:
   0x00007ffff7ff0700 <+0>:     cmplwi  r4,15
   0x00007ffff7ff0704 <+4>:     bgt     0x7ffff7ff07f0 <__cvdso_clock_gettime_data+240>
   0x00007ffff7ff0708 <+8>:     li      r9,1
   0x00007ffff7ff070c <+12>:    slw     r9,r9,r4
   0x00007ffff7ff0710 <+16>:    andi.   r10,r9,2179
   0x00007ffff7ff0714 <+20>:    beq     0x7ffff7ff0810 <__cvdso_clock_gettime_data+272>
   0x00007ffff7ff0718 <+24>:    rldicr  r10,r4,4,59
   0x00007ffff7ff071c <+28>:    lis     r9,32767
   0x00007ffff7ff0720 <+32>:    std     r30,-16(r1)
   0x00007ffff7ff0724 <+36>:    std     r31,-8(r1)
   0x00007ffff7ff0728 <+40>:    add     r6,r3,r10
   0x00007ffff7ff072c <+44>:    ori     r4,r9,65535
   0x00007ffff7ff0730 <+48>:    lwz     r8,0(r3)
   0x00007ffff7ff0734 <+52>:    andi.   r9,r8,1
   0x00007ffff7ff0738 <+56>:    bne     0x7ffff7ff07d0 <__cvdso_clock_gettime_data+208>
   0x00007ffff7ff073c <+60>:    lwsync
   0x00007ffff7ff0740 <+64>:    mftb    r30      <---- RIGHT HERE
=> 0x00007ffff7ff0744 <+68>:    ld      r12,40(r6)
```

What I believe is happening is that the kernel changed the PowerPC VDSO
calls to use standard C calls instead of using hand rolled assembly. The
hand rolled assembly calls never touched r30, so this change was safe to
roll back. That does not seem to be the case anymore as on the 5.13rc2
kernel the compiler *is* generating assembly which modifies r30, making
this change again unsafe and causing a crash when the program receives a
signal during these calls (which will happen often due to async
preempt). This change happened here:
https://lwn.net/ml/linux-kernel/235e5571959cfa89ced081d7e838ed5ff38447d2.1601365870.git.christophe.leroy@csgroup.eu/.

I realize this was reverted due to unexplained hangs in PowerPC
builders, but I think we should reinstate this change and investigate
those issues separately:
https://github.com/golang/go/commit/f4ca3c1e0a2066ca4f7bd6203866d282ed34acf2

Fixes #46803

Change-Id: Ib18d7bbfc80a1a9cb558f0098878d41081324b52
GitHub-Last-Rev: c3002bcfca3ef58b27485e31328e6297b7a9dfe7
GitHub-Pull-Request: golang/go#46767
Reviewed-on: https://go-review.googlesource.com/c/go/+/328110
Run-TryBot: Lynn Boger <laboger@linux.vnet.ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
Trust: Lynn Boger <laboger@linux.vnet.ibm.com>
---
 src/runtime/signal_unix.go     |  2 +-
 src/runtime/sys_linux_ppc64x.s | 86 +++++++++++++++++++++++++++++-----
 2 files changed, 74 insertions(+), 14 deletions(-)

diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index 03e2a40ce6..6096760b50 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -382,7 +382,7 @@ func preemptM(mp *m) {
 //go:nosplit
 func sigFetchG(c *sigctxt) *g {
 	switch GOARCH {
-	case "arm", "arm64":
+	case "arm", "arm64", "ppc64", "ppc64le":
 		if !iscgo && inVDSOPage(c.sigpc()) {
 			// When using cgo, we save the g on TLS and load it from there
 			// in sigtramp. Just use that.
diff --git a/src/runtime/sys_linux_ppc64x.s b/src/runtime/sys_linux_ppc64x.s
index 05b5916db4..005fa4d2b4 100644
--- a/src/runtime/sys_linux_ppc64x.s
+++ b/src/runtime/sys_linux_ppc64x.s
@@ -216,15 +216,45 @@ TEXT runtime·walltime(SB),NOSPLIT,$16-12
 	MOVD	(g_sched+gobuf_sp)(R7), R1	// Set SP to g0 stack
 
 noswitch:
-	SUB	$16, R1			// Space for results
-	RLDICR	$0, R1, $59, R1		// Align for C code
+	SUB	$16, R1                 // Space for results
+	RLDICR	$0, R1, $59, R1         // Align for C code
 	MOVD	R12, CTR
 	MOVD	R1, R4
-	BL	(CTR)			// Call from VDSO
-	MOVD	$0, R0			// Restore R0
-	MOVD	0(R1), R3		// sec
-	MOVD	8(R1), R5		// nsec
-	MOVD	R15, R1			// Restore SP
+
+	// Store g on gsignal's stack, so if we receive a signal
+	// during VDSO code we can find the g.
+	// If we don't have a signal stack, we won't receive signal,
+	// so don't bother saving g.
+	// When using cgo, we already saved g on TLS, also don't save
+	// g here.
+	// Also don't save g if we are already on the signal stack.
+	// We won't get a nested signal.
+	MOVBZ	runtime·iscgo(SB), R22
+	CMP	R22, $0
+	BNE	nosaveg
+	MOVD	m_gsignal(R21), R22	// g.m.gsignal
+	CMP	R22, $0
+	BEQ	nosaveg
+
+	CMP	g, R22
+	BEQ	nosaveg
+	MOVD	(g_stack+stack_lo)(R22), R22 // g.m.gsignal.stack.lo
+	MOVD	g, (R22)
+
+	BL	(CTR)	// Call from VDSO
+
+	MOVD	$0, (R22)	// clear g slot, R22 is unchanged by C code
+
+	JMP	finish
+
+nosaveg:
+	BL	(CTR)	// Call from VDSO
+
+finish:
+	MOVD	$0, R0		// Restore R0
+	MOVD	0(R1), R3	// sec
+	MOVD	8(R1), R5	// nsec
+	MOVD	R15, R1		// Restore SP
 
 	// Restore vdsoPC, vdsoSP
 	// We don't worry about being signaled between the two stores.
@@ -236,7 +266,7 @@ noswitch:
 	MOVD	32(R1), R6
 	MOVD	R6, m_vdsoPC(R21)
 
-finish:
+return:
 	MOVD	R3, sec+0(FP)
 	MOVW	R5, nsec+8(FP)
 	RET
@@ -247,7 +277,7 @@ fallback:
 	SYSCALL $SYS_clock_gettime
 	MOVD	32(R1), R3
 	MOVD	40(R1), R5
-	JMP	finish
+	JMP	return
 
 TEXT runtime·nanotime1(SB),NOSPLIT,$16-8
 	MOVD	$1, R3		// CLOCK_MONOTONIC
@@ -283,7 +313,37 @@ noswitch:
 	RLDICR	$0, R1, $59, R1		// Align for C code
 	MOVD	R12, CTR
 	MOVD	R1, R4
-	BL	(CTR)			// Call from VDSO
+
+	// Store g on gsignal's stack, so if we receive a signal
+	// during VDSO code we can find the g.
+	// If we don't have a signal stack, we won't receive signal,
+	// so don't bother saving g.
+	// When using cgo, we already saved g on TLS, also don't save
+	// g here.
+	// Also don't save g if we are already on the signal stack.
+	// We won't get a nested signal.
+	MOVBZ	runtime·iscgo(SB), R22
+	CMP	R22, $0
+	BNE	nosaveg
+	MOVD	m_gsignal(R21), R22	// g.m.gsignal
+	CMP	R22, $0
+	BEQ	nosaveg
+
+	CMP	g, R22
+	BEQ	nosaveg
+	MOVD	(g_stack+stack_lo)(R22), R22 // g.m.gsignal.stack.lo
+	MOVD	g, (R22)
+
+	BL	(CTR)	// Call from VDSO
+
+	MOVD	$0, (R22)	// clear g slot, R22 is unchanged by C code
+
+	JMP	finish
+
+nosaveg:
+	BL	(CTR)	// Call from VDSO
+
+finish:
 	MOVD	$0, R0			// Restore R0
 	MOVD	0(R1), R3		// sec
 	MOVD	8(R1), R5		// nsec
@@ -299,7 +359,7 @@ noswitch:
 	MOVD	32(R1), R6
 	MOVD	R6, m_vdsoPC(R21)
 
-finish:
+return:
 	// sec is in R3, nsec in R5
 	// return nsec in R3
 	MOVD	$1000000000, R4
@@ -314,7 +374,7 @@ fallback:
 	SYSCALL $SYS_clock_gettime
 	MOVD	32(R1), R3
 	MOVD	40(R1), R5
-	JMP	finish
+	JMP	return
 
 TEXT runtime·rtsigprocmask(SB),NOSPLIT|NOFRAME,$0-28
 	MOVW	how+0(FP), R3
@@ -469,7 +529,7 @@ TEXT sigtramp<>(SB),NOSPLIT|NOFRAME,$0
 	// this might be called in external code context,
 	// where g is not set.
 	MOVBZ	runtime·iscgo(SB), R6
-	CMP 	R6, $0
+	CMP	R6, $0
 	BEQ	2(PC)
 	BL	runtime·load_g(SB)
 
-- 
GitLab


From 44f9a3566ce564f9a21b1b92940a520ea241e065 Mon Sep 17 00:00:00 2001
From: Daniel Theophanes <kardianos@gmail.com>
Date: Mon, 21 Jun 2021 11:11:20 -0500
Subject: [PATCH 2270/2400] database/sql: fix deadlock test in prepare
 statement

The issue go#46783 correctly diagnosed the context timeout
caused an intermittent failure when the context was canceled
prior to the BeginTx call. However due to the asynchronous nature
of canceling a Tx through a context on fast systems, the tx.Prepare
also succeeded. On slower systems or if a time.Sleep was inserted
between the BeginTx and Prepare, the Prepare would fail.

Resolve this by moving the context cancel after the Prepare.
This will still trigger the deadlock which I tested locally.
In addition, I interspersed multiple time.Sleep calls and the
test still functioned.

Fixes #46852

Change-Id: I9cbf90d3c12b2555493a37799738772b615ae39d
Reviewed-on: https://go-review.googlesource.com/c/go/+/329830
Run-TryBot: Daniel Theophanes <kardianos@gmail.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Bryan C. Mills <bcmills@google.com>
---
 src/database/sql/sql_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/database/sql/sql_test.go b/src/database/sql/sql_test.go
index 7d1cb9b85a..f771dee4a9 100644
--- a/src/database/sql/sql_test.go
+++ b/src/database/sql/sql_test.go
@@ -2841,7 +2841,6 @@ func TestTxStmtDeadlock(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	tx, err := db.BeginTx(ctx, nil)
-	cancel()
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -2850,6 +2849,7 @@ func TestTxStmtDeadlock(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+	cancel()
 	// Run number of stmt queries to reproduce deadlock from context cancel
 	for i := 0; i < 1e3; i++ {
 		// Encounter any close related errors (e.g. ErrTxDone, stmt is closed)
-- 
GitLab


From 20bdfba32590c3dcce8885df875dc56a84b2d269 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Mon, 21 Jun 2021 12:52:17 -0400
Subject: [PATCH 2271/2400] go/scanner: fall back to next() when encountering 0
 bytes in parseIdentifier

CL 308611 optimized parseIdentifier for ASCII, but inadvertently skipped
error handling for 0 bytes. Don't take the optimized path when
encountering 0.

Fixes #46855

Change-Id: Ic584e077eb74c012611fefa20eb71ca09c81b3c7
Reviewed-on: https://go-review.googlesource.com/c/go/+/329790
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/scanner/scanner.go      | 2 +-
 src/go/scanner/scanner_test.go | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/go/scanner/scanner.go b/src/go/scanner/scanner.go
index 29cbf39721..f08e28cdd6 100644
--- a/src/go/scanner/scanner.go
+++ b/src/go/scanner/scanner.go
@@ -373,7 +373,7 @@ func (s *Scanner) scanIdentifier() string {
 			continue
 		}
 		s.rdOffset += rdOffset
-		if b < utf8.RuneSelf {
+		if 0 < b && b < utf8.RuneSelf {
 			// Optimization: we've encountered an ASCII character that's not a letter
 			// or number. Avoid the call into s.next() and corresponding set up.
 			//
diff --git a/src/go/scanner/scanner_test.go b/src/go/scanner/scanner_test.go
index ac8d257716..db123c32e0 100644
--- a/src/go/scanner/scanner_test.go
+++ b/src/go/scanner/scanner_test.go
@@ -812,6 +812,8 @@ var errors = []struct {
 	{"//\ufeff", token.COMMENT, 2, "//\ufeff", "illegal byte order mark"},                                // only first BOM is ignored
 	{"'\ufeff" + `'`, token.CHAR, 1, "'\ufeff" + `'`, "illegal byte order mark"},                         // only first BOM is ignored
 	{`"` + "abc\ufeffdef" + `"`, token.STRING, 4, `"` + "abc\ufeffdef" + `"`, "illegal byte order mark"}, // only first BOM is ignored
+	{"abc\x00def", token.IDENT, 3, "abc", "illegal character NUL"},
+	{"abc\x00", token.IDENT, 3, "abc", "illegal character NUL"},
 }
 
 func TestScanErrors(t *testing.T) {
-- 
GitLab


From 3f9ec83b10c6de2a992b7458eb3be279f48eb6f8 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Sun, 20 Jun 2021 12:22:16 -0700
Subject: [PATCH 2272/2400] cmd/go: document GOPPC64 environment variable

Change-Id: I2d2c02eec4ac6eca218fa5334d32650c1620692c
Reviewed-on: https://go-review.googlesource.com/c/go/+/329689
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Carlos Eduardo Seo <carlos.seo@linaro.org>
---
 src/cmd/go/alldocs.go               | 3 +++
 src/cmd/go/internal/help/helpdoc.go | 3 +++
 2 files changed, 6 insertions(+)

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index 3febe880cd..27f993aeb3 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -1887,6 +1887,9 @@
 // 	GOMIPS64
 // 		For GOARCH=mips64{,le}, whether to use floating point instructions.
 // 		Valid values are hardfloat (default), softfloat.
+// 	GOPPC64
+// 		For GOARCH=ppc64{,le}, the target ISA (Instruction Set Architecture).
+// 		Valid values are power8 (default), power9.
 // 	GOWASM
 // 		For GOARCH=wasm, comma-separated list of experimental WebAssembly features to use.
 // 		Valid values are satconv, signext.
diff --git a/src/cmd/go/internal/help/helpdoc.go b/src/cmd/go/internal/help/helpdoc.go
index 9ec6501892..b552777e3e 100644
--- a/src/cmd/go/internal/help/helpdoc.go
+++ b/src/cmd/go/internal/help/helpdoc.go
@@ -598,6 +598,9 @@ Architecture-specific environment variables:
 	GOMIPS64
 		For GOARCH=mips64{,le}, whether to use floating point instructions.
 		Valid values are hardfloat (default), softfloat.
+	GOPPC64
+		For GOARCH=ppc64{,le}, the target ISA (Instruction Set Architecture).
+		Valid values are power8 (default), power9.
 	GOWASM
 		For GOARCH=wasm, comma-separated list of experimental WebAssembly features to use.
 		Valid values are satconv, signext.
-- 
GitLab


From a0400420ade001265f656c5dd9be1b48d7c8e6fe Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Wed, 16 Jun 2021 14:34:54 -0400
Subject: [PATCH 2273/2400] cmd/internal/moddeps: use -mod=readonly instead of
 -mod=mod
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

TestAllDependencies is attempting to check that the modules in GOROOT
satisfy certain properties; it should not modify those modules itself.

The “quick” part of the test checks that vendored packages are present
and complete, without constructing a parallel GOROOT. It shouldn't
resolve new dependencies or change formatting in any way.

The longer version of the test already constructs a parallel GOROOT
and tidies the modules within it. That part of the test will flag any
modifications needed to the go.mod and go.sum files, without modifying
the original GOROOT.

From what I can tell, the failure mode in #46695 is caused by running
the test on a module rooted in $GOROOT proper. There is no such module
in the mainline Go repo, but it may have been introduced in the fork
and could also be introduced by stray edits in contributor CLs. It
should be diagnosed clearly.

For #46695

Change-Id: I62b90ccbd54cb3e3b413017021c952a7b1d455e7
Reviewed-on: https://go-review.googlesource.com/c/go/+/328770
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 src/cmd/internal/moddeps/moddeps_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/internal/moddeps/moddeps_test.go b/src/cmd/internal/moddeps/moddeps_test.go
index 7723250468..8d01b913c3 100644
--- a/src/cmd/internal/moddeps/moddeps_test.go
+++ b/src/cmd/internal/moddeps/moddeps_test.go
@@ -68,7 +68,7 @@ func TestAllDependencies(t *testing.T) {
 
 			// There is no vendor directory, so the module must have no dependencies.
 			// Check that the list of active modules contains only the main module.
-			cmd := exec.Command(goBin, "list", "-mod=mod", "-m", "all")
+			cmd := exec.Command(goBin, "list", "-mod=readonly", "-m", "all")
 			cmd.Env = append(os.Environ(), "GO111MODULE=on")
 			cmd.Dir = m.Dir
 			cmd.Stderr = new(strings.Builder)
-- 
GitLab


From 761edf71f64bb2ef949ceb588822c47d2e1cc6ac Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Wed, 16 Jun 2021 16:33:29 -0400
Subject: [PATCH 2274/2400] cmd/internal/moddeps: use a temporary directory for
 GOMODCACHE if needed

CL 328770 should be sufficient to fix the specific failure in the
report, but when attempting to reproduce it I noticed a related
failure mode, triggered by the environment variables set in
src/run.bash.

The failure mode is currently masked on the Go project builders due to
the lack of any 'longtest' builder running as a non-root user
(#10719).

It is also masked from Go contributors running 'run.bash' locally
because 'run.bash' does not actually run all of the tests unless
GO_TEST_SHORT=0 is set in the environment (#29266, #46054).

Fixes #46695

Change-Id: I272c09dae462734590dce59b3d3c5b6d3f733c92
Reviewed-on: https://go-review.googlesource.com/c/go/+/328771
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 src/cmd/internal/moddeps/moddeps_test.go | 33 ++++++++++++++++++++++--
 1 file changed, 31 insertions(+), 2 deletions(-)

diff --git a/src/cmd/internal/moddeps/moddeps_test.go b/src/cmd/internal/moddeps/moddeps_test.go
index 8d01b913c3..56c3b2585c 100644
--- a/src/cmd/internal/moddeps/moddeps_test.go
+++ b/src/cmd/internal/moddeps/moddeps_test.go
@@ -5,6 +5,7 @@
 package moddeps_test
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
 	"internal/testenv"
@@ -123,10 +124,38 @@ func TestAllDependencies(t *testing.T) {
 		t.Skip("skipping because a diff command with support for --recursive and --unified flags is unavailable")
 	}
 
+	// We're going to check the standard modules for tidiness, so we need a usable
+	// GOMODCACHE. If the default directory doesn't exist, use a temporary
+	// directory instead. (That can occur, for example, when running under
+	// run.bash with GO_TEST_SHORT=0: run.bash sets GOPATH=/nonexist-gopath, and
+	// GO_TEST_SHORT=0 causes it to run this portion of the test.)
+	var modcacheEnv []string
+	{
+		out, err := exec.Command(goBin, "env", "GOMODCACHE").Output()
+		if err != nil {
+			t.Fatalf("%s env GOMODCACHE: %v", goBin, err)
+		}
+		modcacheOk := false
+		if gomodcache := string(bytes.TrimSpace(out)); gomodcache != "" {
+			if _, err := os.Stat(gomodcache); err == nil {
+				modcacheOk = true
+			}
+		}
+		if !modcacheOk {
+			modcacheEnv = []string{
+				"GOMODCACHE=" + t.TempDir(),
+				"GOFLAGS=" + os.Getenv("GOFLAGS") + " -modcacherw", // Allow t.TempDir() to clean up subdirectories.
+			}
+		}
+	}
+
 	// Build the bundle binary at the golang.org/x/tools
 	// module version specified in GOROOT/src/cmd/go.mod.
 	bundleDir := t.TempDir()
-	r := runner{Dir: filepath.Join(runtime.GOROOT(), "src/cmd")}
+	r := runner{
+		Dir: filepath.Join(runtime.GOROOT(), "src/cmd"),
+		Env: append(os.Environ(), modcacheEnv...),
+	}
 	r.run(t, goBin, "build", "-mod=readonly", "-o", bundleDir, "golang.org/x/tools/cmd/bundle")
 
 	var gorootCopyDir string
@@ -160,7 +189,7 @@ func TestAllDependencies(t *testing.T) {
 			}
 			r := runner{
 				Dir: filepath.Join(gorootCopyDir, rel),
-				Env: append(os.Environ(),
+				Env: append(append(os.Environ(), modcacheEnv...),
 					// Set GOROOT.
 					"GOROOT="+gorootCopyDir,
 					// Explicitly override PWD and clear GOROOT_FINAL so that GOROOT=gorootCopyDir is definitely used.
-- 
GitLab


From 1bd5a20e3c8a3a82e87487c381b76c97b720cd52 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 18 Jun 2021 17:28:29 -0400
Subject: [PATCH 2275/2400] cmd/go: add a -go flag to 'go mod graph'

For #46366

Change-Id: I8417e6e4dbb8cb56ff7afc16893a01b7bb938217
Reviewed-on: https://go-review.googlesource.com/c/go/+/329529
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 doc/go1.17.html                               |   7 ++
 src/cmd/go/alldocs.go                         |   6 +-
 src/cmd/go/internal/modcmd/graph.go           |  13 ++-
 src/cmd/go/internal/modcmd/verify.go          |   3 +-
 src/cmd/go/internal/modget/get.go             |   6 +-
 src/cmd/go/internal/modload/buildlist.go      |  26 ++++-
 .../go/testdata/script/mod_graph_version.txt  | 101 ++++++++++++++++++
 7 files changed, 154 insertions(+), 8 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/mod_graph_version.txt

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 02cd18d037..22896c8c27 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -187,6 +187,13 @@ Do not send CLs removing the interior tags from such phrases.
   features.
 </p>
 
+<p><!-- golang.org/issue/46366 -->
+  The <code>go</code> <code>mod</code> <code>graph</code> subcommand also
+  supports the <code>-go</code> flag, which causes it to report the graph as
+  seen by the indicated Go version, showing dependencies that may otherwise be
+  pruned out by lazy loading.
+</p>
+
 <h4 id="module-deprecation-comments">Module deprecation comments</h4>
 
 <p><!-- golang.org/issue/40357 -->
diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index 27f993aeb3..fd95da23eb 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -1186,13 +1186,17 @@
 //
 // Usage:
 //
-// 	go mod graph
+// 	go mod graph [-go=version]
 //
 // Graph prints the module requirement graph (with replacements applied)
 // in text form. Each line in the output has two space-separated fields: a module
 // and one of its requirements. Each module is identified as a string of the form
 // path@version, except for the main module, which has no @version suffix.
 //
+// The -go flag causes graph to report the module graph as loaded by by the
+// given Go version, instead of the version indicated by the 'go' directive
+// in the go.mod file.
+//
 // See https://golang.org/ref/mod#go-mod-graph for more about 'go mod graph'.
 //
 //
diff --git a/src/cmd/go/internal/modcmd/graph.go b/src/cmd/go/internal/modcmd/graph.go
index 77853304e9..903bd9970f 100644
--- a/src/cmd/go/internal/modcmd/graph.go
+++ b/src/cmd/go/internal/modcmd/graph.go
@@ -18,7 +18,7 @@ import (
 )
 
 var cmdGraph = &base.Command{
-	UsageLine: "go mod graph",
+	UsageLine: "go mod graph [-go=version]",
 	Short:     "print module requirement graph",
 	Long: `
 Graph prints the module requirement graph (with replacements applied)
@@ -26,12 +26,21 @@ in text form. Each line in the output has two space-separated fields: a module
 and one of its requirements. Each module is identified as a string of the form
 path@version, except for the main module, which has no @version suffix.
 
+The -go flag causes graph to report the module graph as loaded by by the
+given Go version, instead of the version indicated by the 'go' directive
+in the go.mod file.
+
 See https://golang.org/ref/mod#go-mod-graph for more about 'go mod graph'.
 	`,
 	Run: runGraph,
 }
 
+var (
+	graphGo goVersionFlag
+)
+
 func init() {
+	cmdGraph.Flag.Var(&graphGo, "go", "")
 	base.AddModCommonFlags(&cmdGraph.Flag)
 }
 
@@ -41,7 +50,7 @@ func runGraph(ctx context.Context, cmd *base.Command, args []string) {
 	}
 	modload.ForceUseModules = true
 	modload.RootMode = modload.NeedRoot
-	mg := modload.LoadModGraph(ctx)
+	mg := modload.LoadModGraph(ctx, graphGo.String())
 
 	w := bufio.NewWriter(os.Stdout)
 	defer w.Flush()
diff --git a/src/cmd/go/internal/modcmd/verify.go b/src/cmd/go/internal/modcmd/verify.go
index 5c321c783a..5a6eca32cf 100644
--- a/src/cmd/go/internal/modcmd/verify.go
+++ b/src/cmd/go/internal/modcmd/verify.go
@@ -54,7 +54,8 @@ func runVerify(ctx context.Context, cmd *base.Command, args []string) {
 	sem := make(chan token, runtime.GOMAXPROCS(0))
 
 	// Use a slice of result channels, so that the output is deterministic.
-	mods := modload.LoadModGraph(ctx).BuildList()[1:]
+	const defaultGoVersion = ""
+	mods := modload.LoadModGraph(ctx, defaultGoVersion).BuildList()[1:]
 	errsChans := make([]<-chan []error, len(mods))
 
 	for i, mod := range mods {
diff --git a/src/cmd/go/internal/modget/get.go b/src/cmd/go/internal/modget/get.go
index ea5c4e229a..9672e5598e 100644
--- a/src/cmd/go/internal/modget/get.go
+++ b/src/cmd/go/internal/modget/get.go
@@ -506,7 +506,8 @@ type versionReason struct {
 func newResolver(ctx context.Context, queries []*query) *resolver {
 	// LoadModGraph also sets modload.Target, which is needed by various resolver
 	// methods.
-	mg := modload.LoadModGraph(ctx)
+	const defaultGoVersion = ""
+	mg := modload.LoadModGraph(ctx, defaultGoVersion)
 
 	buildList := mg.BuildList()
 	initialVersion := make(map[string]string, len(buildList))
@@ -1803,7 +1804,8 @@ func (r *resolver) updateBuildList(ctx context.Context, additions []module.Versi
 		return false
 	}
 
-	r.buildList = modload.LoadModGraph(ctx).BuildList()
+	const defaultGoVersion = ""
+	r.buildList = modload.LoadModGraph(ctx, defaultGoVersion).BuildList()
 	r.buildListVersion = make(map[string]string, len(r.buildList))
 	for _, m := range r.buildList {
 		r.buildListVersion[m.Path] = m.Version
diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index 64eaa16e8b..604a57b437 100644
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -403,11 +403,33 @@ func (mg *ModuleGraph) allRootsSelected() bool {
 // LoadModGraph loads and returns the graph of module dependencies of the main module,
 // without loading any packages.
 //
+// If the goVersion string is non-empty, the returned graph is the graph
+// as interpreted by the given Go version (instead of the version indicated
+// in the go.mod file).
+//
 // Modules are loaded automatically (and lazily) in LoadPackages:
 // LoadModGraph need only be called if LoadPackages is not,
 // typically in commands that care about modules but no particular package.
-func LoadModGraph(ctx context.Context) *ModuleGraph {
-	rs, mg, err := expandGraph(ctx, LoadModFile(ctx))
+func LoadModGraph(ctx context.Context, goVersion string) *ModuleGraph {
+	rs := LoadModFile(ctx)
+
+	if goVersion != "" {
+		depth := modDepthFromGoVersion(goVersion)
+		if depth == eager && rs.depth != eager {
+			// Use newRequirements instead of convertDepth because convertDepth
+			// also updates roots; here, we want to report the unmodified roots
+			// even though they may seem inconsistent.
+			rs = newRequirements(eager, rs.rootModules, rs.direct)
+		}
+
+		mg, err := rs.Graph(ctx)
+		if err != nil {
+			base.Fatalf("go: %v", err)
+		}
+		return mg
+	}
+
+	rs, mg, err := expandGraph(ctx, rs)
 	if err != nil {
 		base.Fatalf("go: %v", err)
 	}
diff --git a/src/cmd/go/testdata/script/mod_graph_version.txt b/src/cmd/go/testdata/script/mod_graph_version.txt
new file mode 100644
index 0000000000..f9a73f4617
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_graph_version.txt
@@ -0,0 +1,101 @@
+# For this module, Go 1.17 prunes out a (transitive and otherwise-irrelevant)
+# requirement on a retracted higher version of a dependency.
+# However, when Go 1.16 reads the same requirements from the go.mod file,
+# it does not prune out that requirement, and selects the retracted version.
+#
+# The Go 1.16 module graph looks like:
+#
+# m ---- lazy v0.1.0 ---- requireincompatible v0.1.0 ---- incompatible v2.0.0+incompatible
+# |        |
+# + -------+------------- incompatible v1.0.0
+#
+# The Go 1.17 module graph is the same except that the dependencies of
+# requireincompatible are pruned out (because the module that requires
+# it — lazy v0.1.0 — specifies 'go 1.17', and it is not otherwise relevant to
+# the main module).
+
+cp go.mod go.mod.orig
+
+go mod graph
+cp stdout graph-1.17.txt
+stdout '^example\.com/m example\.com/retract/incompatible@v1\.0\.0$'
+stdout '^example\.net/lazy@v0\.1\.0 example\.com/retract/incompatible@v1\.0\.0$'
+! stdout 'example\.com/retract/incompatible@v2\.0\.0\+incompatible'
+
+go mod graph -go=1.17
+cmp stdout graph-1.17.txt
+
+cmp go.mod go.mod.orig
+
+
+# Setting -go=1.16 should report the graph as viewed by Go 1.16,
+# but should not edit the go.mod file.
+
+go mod graph -go=1.16
+cp stdout graph-1.16.txt
+stdout '^example\.com/m example\.com/retract/incompatible@v1\.0\.0$'
+stdout '^example\.net/lazy@v0\.1\.0 example.com/retract/incompatible@v1\.0\.0$'
+stdout '^example.net/requireincompatible@v0.1.0 example.com/retract/incompatible@v2\.0\.0\+incompatible$'
+
+cmp go.mod go.mod.orig
+
+
+# If we actually update the go.mod file to the requested go version,
+# we should get the same selected versions, but the roots of the graph
+# may be updated.
+#
+# TODO(#45551): The roots should not be updated.
+
+go mod edit -go=1.16
+go mod graph
+! stdout '^example\.com/m example\.com/retract/incompatible@v1\.0\.0$'
+stdout '^example\.net/lazy@v0.1.0 example.com/retract/incompatible@v1\.0\.0$'
+stdout '^example.net/requireincompatible@v0.1.0 example.com/retract/incompatible@v2\.0\.0\+incompatible$'
+	# TODO(#45551): cmp stdout graph-1.16.txt
+
+
+# Unsupported go versions should be rejected, since we don't know
+# what versions they would report.
+! go mod graph -go=1.99999999999
+stderr '^invalid value "1\.99999999999" for flag -go: maximum supported Go version is '$goversion'\nusage: go mod graph \[-go=version\]\nRun ''go help mod graph'' for details.$'
+
+
+-- go.mod --
+// Module m indirectly imports a package from
+// example.com/retract/incompatible. Its selected version of
+// that module is lower under Go 1.17 semantics than under Go 1.16.
+module example.com/m
+
+go 1.17
+
+replace (
+	example.net/lazy v0.1.0 => ./lazy
+	example.net/requireincompatible v0.1.0 => ./requireincompatible
+)
+
+require (
+	example.com/retract/incompatible v1.0.0 // indirect
+	example.net/lazy v0.1.0
+)
+-- lazy/go.mod --
+// Module lazy requires example.com/retract/incompatible v1.0.0.
+//
+// When viewed from the outside it also has a transitive dependency
+// on v2.0.0+incompatible, but in lazy mode that transitive dependency
+// is pruned out.
+module example.net/lazy
+
+go 1.17
+
+exclude example.com/retract/incompatible v2.0.0+incompatible
+
+require (
+	example.com/retract/incompatible v1.0.0
+	example.net/requireincompatible v0.1.0
+)
+-- requireincompatible/go.mod --
+module example.net/requireincompatible
+
+go 1.15
+
+require example.com/retract/incompatible v2.0.0+incompatible
-- 
GitLab


From 9afd158eb228fbe191ffa27b1a334a8837c45ef7 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Mon, 21 Jun 2021 16:10:14 -0400
Subject: [PATCH 2276/2400] go/parser: parse an ast.IndexExpr for a[]

To be consistent with Go 1.16, and to preserve as much information in
the AST as possible, parse an ast.IndexExpr with BadExpr Index for the
invalid expression a[].

A go/types test had to be adjusted to account for an additional error
resulting from this change.

We don't have a lot of test coverage for parser error recovery, so
rather than write an ad-hoc test for this issue, add a new go/types test
that checks that the indexed operand is used.

Updates #46403

Change-Id: I21e6ff4179746aaa50e530d4091fded450e69824
Reviewed-on: https://go-review.googlesource.com/c/go/+/329791
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/parser/parser.go                        |  7 ++++++-
 src/go/types/testdata/examples/functions.go2   |  2 +-
 src/go/types/testdata/fixedbugs/issue46403.src | 11 +++++++++++
 3 files changed, 18 insertions(+), 2 deletions(-)
 create mode 100644 src/go/types/testdata/fixedbugs/issue46403.src

diff --git a/src/go/parser/parser.go b/src/go/parser/parser.go
index 3965641713..f10c8650af 100644
--- a/src/go/parser/parser.go
+++ b/src/go/parser/parser.go
@@ -1302,7 +1302,12 @@ func (p *parser) parseIndexOrSliceOrInstance(x ast.Expr) ast.Expr {
 		p.errorExpected(p.pos, "operand")
 		rbrack := p.pos
 		p.next()
-		return &ast.BadExpr{From: x.Pos(), To: rbrack}
+		return &ast.IndexExpr{
+			X:      x,
+			Lbrack: lbrack,
+			Index:  &ast.BadExpr{From: rbrack, To: rbrack},
+			Rbrack: rbrack,
+		}
 	}
 	p.exprLev++
 
diff --git a/src/go/types/testdata/examples/functions.go2 b/src/go/types/testdata/examples/functions.go2
index fb74ae7ae2..a053471202 100644
--- a/src/go/types/testdata/examples/functions.go2
+++ b/src/go/types/testdata/examples/functions.go2
@@ -210,5 +210,5 @@ func _() {
 func h[] /* ERROR empty type parameter list */ ()
 
 func _() {
-	h[] /* ERROR operand */ ()
+	h /* ERROR cannot index */ [] /* ERROR operand */ ()
 }
diff --git a/src/go/types/testdata/fixedbugs/issue46403.src b/src/go/types/testdata/fixedbugs/issue46403.src
new file mode 100644
index 0000000000..9d475222ad
--- /dev/null
+++ b/src/go/types/testdata/fixedbugs/issue46403.src
@@ -0,0 +1,11 @@
+// Copyright 2021 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 issue46403
+
+func _() {
+	// a should be used, despite the parser error below.
+	var a []int
+	var _ = a[] // ERROR expected operand
+}
-- 
GitLab


From 197a5ee2ab8b64c687c74b986bf92139057366b6 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Mon, 21 Jun 2021 20:14:21 -0400
Subject: [PATCH 2277/2400] cmd/gofmt: remove stale documentation for the -G
 flag

This documentation remained from the original dev.typeparams merge. This
flag no longer exists.

Change-Id: Ic9a82071c512614dc1382780d69ef13253fca21d
Reviewed-on: https://go-review.googlesource.com/c/go/+/329792
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/gofmt/doc.go | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/cmd/gofmt/doc.go b/src/cmd/gofmt/doc.go
index 68476e7d44..e340665594 100644
--- a/src/cmd/gofmt/doc.go
+++ b/src/cmd/gofmt/doc.go
@@ -26,9 +26,6 @@ The flags are:
 		Do not print reformatted sources to standard output.
 		If a file's formatting is different from gofmt's, print its name
 		to standard output.
-	-G
-		Allow generic code, using type parameters.
-		See golang.org/issues/43651 for more information.
 	-r rule
 		Apply the rewrite rule to the source before reformatting.
 	-s
-- 
GitLab


From 63daa774b566d7fe58b3aa82cda9e595929bb777 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Mon, 21 Jun 2021 20:16:37 -0400
Subject: [PATCH 2278/2400] go/types: guard against checking instantiation when
 generics is disabled

When type checking t[_], where t is a type name, it was possible to leak
an error message related to generics. Fix this by guarding on
typeparams.Enabled.

In order to test this fix, we need to be able to run the new go/types
test only if type parameters are disabled. Introduce the .go1 test data
suffix (similar to .go2) to control this behavior.

Originally found via fuzzing, though the test case was manually
simplified.

Updates #46404

Change-Id: Ib1e2c27cf974c2a5ca5b9d6d01b84a30ba4d583b
Reviewed-on: https://go-review.googlesource.com/c/go/+/329793
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/check_test.go                     | 13 ++++++++-----
 src/go/types/testdata/fixedbugs/issue46404.go1 |  8 ++++++++
 src/go/types/typexpr.go                        |  8 ++++++--
 3 files changed, 22 insertions(+), 7 deletions(-)
 create mode 100644 src/go/types/testdata/fixedbugs/issue46404.go1

diff --git a/src/go/types/check_test.go b/src/go/types/check_test.go
index 6c3b630a1b..5a3e57ba44 100644
--- a/src/go/types/check_test.go
+++ b/src/go/types/check_test.go
@@ -207,12 +207,15 @@ func checkFiles(t *testing.T, sizes Sizes, goVersion string, filenames []string,
 		t.Fatal("no source files")
 	}
 
+	if strings.HasSuffix(filenames[0], ".go2") && !typeparams.Enabled {
+		t.Skip("type params are not enabled")
+	}
+	if strings.HasSuffix(filenames[0], ".go1") && typeparams.Enabled {
+		t.Skip("type params are enabled")
+	}
+
 	mode := parser.AllErrors
-	if strings.HasSuffix(filenames[0], ".go2") {
-		if !typeparams.Enabled {
-			t.Skip("type params are not enabled")
-		}
-	} else {
+	if !strings.HasSuffix(filenames[0], ".go2") {
 		mode |= typeparams.DisallowParsing
 	}
 
diff --git a/src/go/types/testdata/fixedbugs/issue46404.go1 b/src/go/types/testdata/fixedbugs/issue46404.go1
new file mode 100644
index 0000000000..db604bc1ac
--- /dev/null
+++ b/src/go/types/testdata/fixedbugs/issue46404.go1
@@ -0,0 +1,8 @@
+// Copyright 2021 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 issue46404
+
+// Check that we don't type check t[_] as an instantiation.
+type t [t /* ERROR not a type */ [_]]_ // ERROR cannot use
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index 5185c33fcb..1738d864a6 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -463,8 +463,12 @@ func (check *Checker) typInternal(e0 ast.Expr, def *Named) (T Type) {
 		}
 
 	case *ast.IndexExpr:
-		exprs := typeparams.UnpackExpr(e.Index)
-		return check.instantiatedType(e.X, exprs, def)
+		if typeparams.Enabled {
+			exprs := typeparams.UnpackExpr(e.Index)
+			return check.instantiatedType(e.X, exprs, def)
+		}
+		check.errorf(e0, _NotAType, "%s is not a type", e0)
+		check.use(e.X)
 
 	case *ast.ParenExpr:
 		// Generic types must be instantiated before they can be used in any form.
-- 
GitLab


From 666315b4d38b99931bb9fd158a76e59928fd2852 Mon Sep 17 00:00:00 2001
From: Xing Gao <18340825824@163.com>
Date: Tue, 22 Jun 2021 02:12:29 +0000
Subject: [PATCH 2279/2400] runtime/internal/atomic: remove incorrect pointer
 indirection in comment

Change-Id: I9d743b7f6b001158299bea4af4aede678654bc8e
GitHub-Last-Rev: 7e07834abc861e21030fe4a8eb323bac01e18f7a
GitHub-Pull-Request: golang/go#46851
Reviewed-on: https://go-review.googlesource.com/c/go/+/329730
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Ben Shi <powerman1st@163.com>
---
 src/runtime/internal/atomic/atomic_386.s | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/internal/atomic/atomic_386.s b/src/runtime/internal/atomic/atomic_386.s
index 37318e0ad7..724d515231 100644
--- a/src/runtime/internal/atomic/atomic_386.s
+++ b/src/runtime/internal/atomic/atomic_386.s
@@ -65,7 +65,7 @@ TEXT ·Xaddint64(SB), NOSPLIT, $0-20
 
 // bool ·Cas64(uint64 *val, uint64 old, uint64 new)
 // Atomically:
-//	if(*val == *old){
+//	if(*val == old){
 //		*val = new;
 //		return 1;
 //	} else {
-- 
GitLab


From 5bd09e5efccf0d3df89085c9f214f94017f6e969 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 21 Jun 2021 22:20:11 -0700
Subject: [PATCH 2280/2400] spec: unsafe.Add/Slice are not permitted in
 statement context

Add unsafe.Add and unsafe.Slice to the list of built-in functions
which are not permitted in statement context. The compiler and
type checker already enforce this restriction, this just fixes
a documentation oversight.

For #19367.
For #40481.

Change-Id: Iabc63a8db048eaf40a5f5b5573fdf00b79d54119
Reviewed-on: https://go-review.googlesource.com/c/go/+/329925
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Rob Pike <r@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 doc/go_spec.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index 561d44271a..b59b37fd55 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1,6 +1,6 @@
 <!--{
 	"Title": "The Go Programming Language Specification",
-	"Subtitle": "Version of Jun 2, 2021",
+	"Subtitle": "Version of Jun 22, 2021",
 	"Path": "/ref/spec"
 }-->
 
@@ -4670,7 +4670,7 @@ The following built-in functions are not permitted in statement context:
 
 <pre>
 append cap complex imag len make new real
-unsafe.Alignof unsafe.Offsetof unsafe.Sizeof
+unsafe.Add unsafe.Alignof unsafe.Offsetof unsafe.Sizeof unsafe.Slice
 </pre>
 
 <pre>
-- 
GitLab


From 0ebd5a8de05823109263bef31b38be8c29d2cd54 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Mon, 21 Jun 2021 14:48:54 -0700
Subject: [PATCH 2281/2400] cmd/go: update ToolTags based on GOARCH value

The build.Context ToolTags value is set based on the set of enabled
experiments, which in turn depends on GOARCH. Before this CL the set
of experiments was being set based on GOARCH in the environment.
That is normally fine, but fails with cmd/go when somebody has run
"go env -w GOARCH=val"; in that case cmd/go changes its GOARCH value
after initialization. The new GOARCH value was affect the set of
enabled experiments, which can affect the ToolTags value. With this
CL, we update ToolTags in cmd/go based on the GOARCH value it is using.

This is a pretty ugly fix. We should do something cleaner for 1.18.

Fixes #46815

Change-Id: Ie9416781a168248813c3da8afdc257acdd3fef7e
Reviewed-on: https://go-review.googlesource.com/c/go/+/329930
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/go/internal/cfg/cfg.go                |  8 +++++
 .../go/testdata/script/env_cross_build.txt    | 29 +++++++++++++++++++
 src/internal/buildcfg/exp.go                  | 13 +++++++--
 3 files changed, 47 insertions(+), 3 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/env_cross_build.txt

diff --git a/src/cmd/go/internal/cfg/cfg.go b/src/cmd/go/internal/cfg/cfg.go
index b47eb812b5..fc6989097e 100644
--- a/src/cmd/go/internal/cfg/cfg.go
+++ b/src/cmd/go/internal/cfg/cfg.go
@@ -77,6 +77,14 @@ func defaultContext() build.Context {
 	ctxt.GOOS = envOr("GOOS", ctxt.GOOS)
 	ctxt.GOARCH = envOr("GOARCH", ctxt.GOARCH)
 
+	// The experiments flags are based on GOARCH, so they may
+	// need to change.  TODO: This should be cleaned up.
+	buildcfg.UpdateExperiments(ctxt.GOARCH)
+	ctxt.ToolTags = nil
+	for _, exp := range buildcfg.EnabledExperiments() {
+		ctxt.ToolTags = append(ctxt.ToolTags, "goexperiment."+exp)
+	}
+
 	// The go/build rule for whether cgo is enabled is:
 	//	1. If $CGO_ENABLED is set, respect it.
 	//	2. Otherwise, if this is a cross-compile, disable cgo.
diff --git a/src/cmd/go/testdata/script/env_cross_build.txt b/src/cmd/go/testdata/script/env_cross_build.txt
new file mode 100644
index 0000000000..3feeba6b14
--- /dev/null
+++ b/src/cmd/go/testdata/script/env_cross_build.txt
@@ -0,0 +1,29 @@
+# Test that the corect default GOEXPERIMENT is used when cross
+# building with GOENV (#46815).
+
+# Unset variables set by the TestScript harness. Users typically won't
+# explicitly configure these, and #46815 doesn't repro if they are.
+env GOOS=
+env GOARCH=
+env GOEXPERIMENT=
+
+env GOENV=windows-amd64
+go build internal/abi
+
+env GOENV=ios-arm64
+go build internal/abi
+
+env GOENV=linux-mips
+go build internal/abi
+
+-- windows-amd64 --
+GOOS=windows
+GOARCH=amd64
+
+-- ios-arm64 --
+GOOS=ios
+GOARCH=arm64
+
+-- linux-mips --
+GOOS=linux
+GOARCH=mips
diff --git a/src/internal/buildcfg/exp.go b/src/internal/buildcfg/exp.go
index 2435a79dce..640aa1934d 100644
--- a/src/internal/buildcfg/exp.go
+++ b/src/internal/buildcfg/exp.go
@@ -18,7 +18,7 @@ import (
 //
 // (This is not necessarily the set of experiments the compiler itself
 // was built with.)
-var Experiment goexperiment.Flags = parseExperiments()
+var Experiment goexperiment.Flags = parseExperiments(GOARCH)
 
 var regabiSupported = GOARCH == "amd64" && (GOOS == "android" || GOOS == "linux" || GOOS == "darwin" || GOOS == "windows")
 
@@ -42,7 +42,7 @@ var experimentBaseline = goexperiment.Flags{
 // Note: must agree with runtime.framepointer_enabled.
 var FramePointerEnabled = GOARCH == "amd64" || GOARCH == "arm64"
 
-func parseExperiments() goexperiment.Flags {
+func parseExperiments(goarch string) goexperiment.Flags {
 	// Start with the statically enabled set of experiments.
 	flags := experimentBaseline
 
@@ -99,7 +99,7 @@ func parseExperiments() goexperiment.Flags {
 	}
 
 	// regabi is only supported on amd64.
-	if GOARCH != "amd64" {
+	if goarch != "amd64" {
 		flags.RegabiWrappers = false
 		flags.RegabiG = false
 		flags.RegabiReflect = false
@@ -165,3 +165,10 @@ func EnabledExperiments() []string {
 func AllExperiments() []string {
 	return expList(&Experiment, nil, true)
 }
+
+// UpdateExperiments updates the Experiment global based on a new GOARCH value.
+// This is only required for cmd/go, which can change GOARCH after
+// program startup due to use of "go env -w".
+func UpdateExperiments(goarch string) {
+	Experiment = parseExperiments(goarch)
+}
-- 
GitLab


From 222ed1b38af0fb6f83f80062092a267dcbd354df Mon Sep 17 00:00:00 2001
From: siddharth <s@ricketyspace.net>
Date: Mon, 21 Jun 2021 21:50:09 -0400
Subject: [PATCH 2282/2400] os: enable TestFifoEOF on openbsd

The test successfully runs on currently supported versions (6.8 and
6.9) of openbsd.

Fixes #25877

Change-Id: I2694f08c5596b486453c2ac829f17b8bc455f828
Reviewed-on: https://go-review.googlesource.com/c/go/+/329732
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Tobias Klauser <tobias.klauser@gmail.com>
---
 src/os/fifo_test.go | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/os/fifo_test.go b/src/os/fifo_test.go
index 9b262f8205..007ed29129 100644
--- a/src/os/fifo_test.go
+++ b/src/os/fifo_test.go
@@ -26,9 +26,6 @@ func TestFifoEOF(t *testing.T) {
 	switch runtime.GOOS {
 	case "android":
 		t.Skip("skipping on Android; mkfifo syscall not available")
-	case "openbsd":
-		// On OpenBSD 6.2 this test just hangs for some reason.
-		t.Skip("skipping on OpenBSD; issue 25877")
 	}
 
 	dir := t.TempDir()
-- 
GitLab


From 73496e0df0ba4284f460d1955ddf6bb096957c9f Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Tue, 22 Jun 2021 21:24:57 -0400
Subject: [PATCH 2283/2400] net: use absDomainName in the Windows lookupPTR
 test helper

The real net code uses subtle heuristics to transform a domain name
to its absolute form. Since lookupPTR isn't checking that
transformation specifically, it should use the real code instead of
using a different heuristic.

Fixes #46882

Change-Id: I503357e0f62059c37c359cd54b44d343c7d5ab2a
Reviewed-on: https://go-review.googlesource.com/c/go/+/330249
Trust: Bryan C. Mills <bcmills@google.com>
Trust: Alex Brainman <alex.brainman@gmail.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/net/lookup_windows_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/net/lookup_windows_test.go b/src/net/lookup_windows_test.go
index 62b61ed6c2..aa95501d02 100644
--- a/src/net/lookup_windows_test.go
+++ b/src/net/lookup_windows_test.go
@@ -299,7 +299,7 @@ func lookupPTR(name string) (ptr []string, err error) {
 	ptr = make([]string, 0, 10)
 	rx := regexp.MustCompile(`(?m)^Pinging\s+([a-zA-Z0-9.\-]+)\s+\[.*$`)
 	for _, ans := range rx.FindAllStringSubmatch(r, -1) {
-		ptr = append(ptr, ans[1]+".")
+		ptr = append(ptr, absDomainName([]byte(ans[1])))
 	}
 	return
 }
-- 
GitLab


From 44a12e5f33bed2189735d8466b38fe455fe9b752 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Wed, 23 Jun 2021 15:28:37 -0400
Subject: [PATCH 2284/2400] cmd/go: search breadth-first instead of depth-first
 for test dependency cycles

When we are looking for a dependency cycle involving a specific
package, we need to keep track of visited packages in order to avoid
repeatedly traversing a cycle that does not involve that package.

If we're keeping track of all visited packages anyway, we're already
spending O(N) memory on the traversal, so we may as well use
breadth-first search. That not only keeps the bookkeeping simple, but
also guarantees that we will find a shortest path (rather than a
completely arbitrary one).

Fixes #45863

Change-Id: I810c7337857e42dcb83630abbdea75021554be45
Reviewed-on: https://go-review.googlesource.com/c/go/+/330430
Trust: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/load/test.go              | 50 +++++++++++++------
 .../testdata/script/mod_list_test_cycle.txt   | 23 +++++++++
 2 files changed, 59 insertions(+), 14 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/mod_list_test_cycle.txt

diff --git a/src/cmd/go/internal/load/test.go b/src/cmd/go/internal/load/test.go
index 6baa1db14f..c828296566 100644
--- a/src/cmd/go/internal/load/test.go
+++ b/src/cmd/go/internal/load/test.go
@@ -116,7 +116,7 @@ func TestPackagesAndErrors(ctx context.Context, opts PackageOpts, p *Package, co
 			// Can't change that code, because that code is only for loading the
 			// non-test copy of a package.
 			ptestErr = &PackageError{
-				ImportStack:   testImportStack(stk[0], p1, p.ImportPath),
+				ImportStack:   importCycleStack(p1, p.ImportPath),
 				Err:           errors.New("import cycle not allowed in test"),
 				IsImportCycle: true,
 			}
@@ -375,22 +375,44 @@ func TestPackagesAndErrors(ctx context.Context, opts PackageOpts, p *Package, co
 	return pmain, ptest, pxtest
 }
 
-func testImportStack(top string, p *Package, target string) []string {
-	stk := []string{top, p.ImportPath}
-Search:
-	for p.ImportPath != target {
-		for _, p1 := range p.Internal.Imports {
-			if p1.ImportPath == target || str.Contains(p1.Deps, target) {
-				stk = append(stk, p1.ImportPath)
-				p = p1
-				continue Search
+// importCycleStack returns an import stack from p to the package whose import
+// path is target.
+func importCycleStack(p *Package, target string) []string {
+	// importerOf maps each import path to its importer nearest to p.
+	importerOf := map[string]string{p.ImportPath: ""}
+
+	// q is a breadth-first queue of packages to search for target.
+	// Every package added to q has a corresponding entry in pathTo.
+	//
+	// We search breadth-first for two reasons:
+	//
+	// 	1. We want to report the shortest cycle.
+	//
+	// 	2. If p contains multiple cycles, the first cycle we encounter might not
+	// 	   contain target. To ensure termination, we have to break all cycles
+	// 	   other than the first.
+	q := []*Package{p}
+
+	for len(q) > 0 {
+		p := q[0]
+		q = q[1:]
+		if path := p.ImportPath; path == target {
+			var stk []string
+			for path != "" {
+				stk = append(stk, path)
+				path = importerOf[path]
+			}
+			return stk
+		}
+		for _, dep := range p.Internal.Imports {
+			if _, ok := importerOf[dep.ImportPath]; !ok {
+				importerOf[dep.ImportPath] = p.ImportPath
+				q = append(q, dep)
 			}
 		}
-		// Can't happen, but in case it does...
-		stk = append(stk, "<lost path to cycle>")
-		break
 	}
-	return stk
+
+	panic("lost path to cycle")
 }
 
 // recompileForTest copies and replaces certain packages in pmain's dependency
diff --git a/src/cmd/go/testdata/script/mod_list_test_cycle.txt b/src/cmd/go/testdata/script/mod_list_test_cycle.txt
new file mode 100644
index 0000000000..755e50b076
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_list_test_cycle.txt
@@ -0,0 +1,23 @@
+# https://golang.org/issue/45863: a typo in a test package leading to an
+# import cycle should be diagnosed, instead of causing an infinite loop.
+# The failure mode of this test prior to the fix was a timeout or OOM crash.
+
+go list -e -test -deps ./datastore/sql
+
+-- go.mod --
+module golang.org/issue45863
+
+go 1.17
+-- datastore/datastore_health.go --
+package datastore
+
+import (
+	"golang.org/issue45863/datastore"
+	"golang.org/issue45863/datastore/sql"
+)
+-- datastore/sql/sql.go --
+package sql
+-- datastore/sql/sql_test.go --
+package sql
+
+import _ "golang.org/issue45863/datastore"
-- 
GitLab


From 86d72fa2cba51342ba5617abf43a732f9fd668ca Mon Sep 17 00:00:00 2001
From: Andy Pan <panjf2000@gmail.com>
Date: Wed, 23 Jun 2021 12:59:48 +0800
Subject: [PATCH 2285/2400] time: handle invalid UTF-8 byte sequences in quote
 to prevent panic

Fixes #46883
Updates CL 267017

Change-Id: I15c307bfb0aaa2877a148d32527681f79df1a650
Reviewed-on: https://go-review.googlesource.com/c/go/+/330289
Reviewed-by: Kevin Burke <kev@inburke.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
---
 src/time/format.go    | 18 +++++++++++++++---
 src/time/time_test.go |  5 +++++
 2 files changed, 20 insertions(+), 3 deletions(-)

diff --git a/src/time/format.go b/src/time/format.go
index 6040ed5aeb..bb173a21c2 100644
--- a/src/time/format.go
+++ b/src/time/format.go
@@ -751,8 +751,11 @@ type ParseError struct {
 
 // These are borrowed from unicode/utf8 and strconv and replicate behavior in
 // that package, since we can't take a dependency on either.
-const runeSelf = 0x80
-const lowerhex = "0123456789abcdef"
+const (
+	lowerhex  = "0123456789abcdef"
+	runeSelf  = 0x80
+	runeError = '\uFFFD'
+)
 
 func quote(s string) string {
 	buf := make([]byte, 1, len(s)+2) // slice will be at least len(s) + quotes
@@ -765,7 +768,16 @@ func quote(s string) string {
 			// reproduce strconv.Quote's behavior with full fidelity but
 			// given how rarely we expect to hit these edge cases, speed and
 			// conciseness are better.
-			for j := 0; j < len(string(c)) && j < len(s); j++ {
+			var width int
+			if c == runeError {
+				width = 1
+				if i+2 < len(s) && s[i:i+3] == string(runeError) {
+					width = 3
+				}
+			} else {
+				width = len(string(c))
+			}
+			for j := 0; j < width; j++ {
 				buf = append(buf, `\x`...)
 				buf = append(buf, lowerhex[s[i+j]>>4])
 				buf = append(buf, lowerhex[s[i+j]&0xF])
diff --git a/src/time/time_test.go b/src/time/time_test.go
index f272bbd558..cea5f2d3f5 100644
--- a/src/time/time_test.go
+++ b/src/time/time_test.go
@@ -917,6 +917,11 @@ var parseDurationErrorTests = []struct {
 	{".s", `".s"`},
 	{"+.s", `"+.s"`},
 	{"1d", `"1d"`},
+	{"\x85\x85", `"\x85\x85"`},
+	{"\xffff", `"\xffff"`},
+	{"hello \xffff world", `"hello \xffff world"`},
+	{"\uFFFD", `"\xef\xbf\xbd"`},                                             // utf8.RuneError
+	{"\uFFFD hello \uFFFD world", `"\xef\xbf\xbd hello \xef\xbf\xbd world"`}, // utf8.RuneError
 	// overflow
 	{"9223372036854775810ns", `"9223372036854775810ns"`},
 	{"9223372036854775808ns", `"9223372036854775808ns"`},
-- 
GitLab


From a9bb38222a06333176cafc5637083e0322277c09 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Tue, 22 Jun 2021 21:48:11 -0400
Subject: [PATCH 2286/2400] net: remove hard-coded timeout in dialClosedPort
 test helper

The helper function claims that dialing a closed port should be
"nearly instantaneous", but that is empirically not the case on
OpenBSD or Windows. The tests do not appear to be particularly
sensitive to the exact upper bound otherwise, so let's just
remove the arbitrary latency assumption.

Fixes #46884

Change-Id: If00c9fdc3063da6aaf60d365d4a2ee2c94dc6df1
Reviewed-on: https://go-review.googlesource.com/c/go/+/330250
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/net/dial_test.go | 51 ++++++++++++++------------------------------
 1 file changed, 16 insertions(+), 35 deletions(-)

diff --git a/src/net/dial_test.go b/src/net/dial_test.go
index f899da10cf..723038c7a2 100644
--- a/src/net/dial_test.go
+++ b/src/net/dial_test.go
@@ -155,40 +155,27 @@ func slowDialTCP(ctx context.Context, network string, laddr, raddr *TCPAddr) (*T
 	return c, err
 }
 
-func dialClosedPort(t *testing.T) (actual, expected time.Duration) {
-	// Estimate the expected time for this platform.
-	// On Windows, dialing a closed port takes roughly 1 second,
-	// but other platforms should be instantaneous.
-	if runtime.GOOS == "windows" {
-		expected = 1500 * time.Millisecond
-	} else if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
-		expected = 150 * time.Millisecond
-	} else {
-		expected = 95 * time.Millisecond
-	}
+func dialClosedPort(t *testing.T) (dialLatency time.Duration) {
+	// On most platforms, dialing a closed port should be nearly instantaneous —
+	// less than a few hundred milliseconds. However, on some platforms it may be
+	// much slower: on Windows and OpenBSD, it has been observed to take up to a
+	// few seconds.
 
 	l, err := Listen("tcp", "127.0.0.1:0")
 	if err != nil {
-		t.Logf("dialClosedPort: Listen failed: %v", err)
-		return 999 * time.Hour, expected
+		t.Fatalf("dialClosedPort: Listen failed: %v", err)
 	}
 	addr := l.Addr().String()
 	l.Close()
-	// On OpenBSD, interference from TestTCPSelfConnect is mysteriously
-	// causing the first attempt to hang for a few seconds, so we throw
-	// away the first result and keep the second.
-	for i := 1; ; i++ {
-		startTime := time.Now()
-		c, err := Dial("tcp", addr)
-		if err == nil {
-			c.Close()
-		}
-		elapsed := time.Now().Sub(startTime)
-		if i == 2 {
-			t.Logf("dialClosedPort: measured delay %v", elapsed)
-			return elapsed, expected
-		}
+
+	startTime := time.Now()
+	c, err := Dial("tcp", addr)
+	if err == nil {
+		c.Close()
 	}
+	elapsed := time.Now().Sub(startTime)
+	t.Logf("dialClosedPort: measured delay %v", elapsed)
+	return elapsed
 }
 
 func TestDialParallel(t *testing.T) {
@@ -198,10 +185,7 @@ func TestDialParallel(t *testing.T) {
 		t.Skip("both IPv4 and IPv6 are required")
 	}
 
-	closedPortDelay, expectClosedPortDelay := dialClosedPort(t)
-	if closedPortDelay > expectClosedPortDelay {
-		t.Errorf("got %v; want <= %v", closedPortDelay, expectClosedPortDelay)
-	}
+	closedPortDelay := dialClosedPort(t)
 
 	const instant time.Duration = 0
 	const fallbackDelay = 200 * time.Millisecond
@@ -675,10 +659,7 @@ func TestDialerDualStack(t *testing.T) {
 		t.Skip("both IPv4 and IPv6 are required")
 	}
 
-	closedPortDelay, expectClosedPortDelay := dialClosedPort(t)
-	if closedPortDelay > expectClosedPortDelay {
-		t.Errorf("got %v; want <= %v", closedPortDelay, expectClosedPortDelay)
-	}
+	closedPortDelay := dialClosedPort(t)
 
 	origTestHookLookupIP := testHookLookupIP
 	defer func() { testHookLookupIP = origTestHookLookupIP }()
-- 
GitLab


From 600a2a4ffb9a273a3a1635b60120ffc768741aa9 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Wed, 23 Jun 2021 23:29:10 -0400
Subject: [PATCH 2287/2400] cmd/go: don't try to add replaced versions that
 won't be selected

In Go 1.12, we added a heuristic to 'go mod tidy' to resolve packages
by adding replaced-but-not-required modules before falling back to
searching for modules from the network. Unfortunately, that heuristic
fails when the replaced version is already lower than the selected
version: adding such a module to the build list doesn't change the
selected version of that module, and so it doesn't make progress
toward resolving the missing package.

Fixes #46659

Change-Id: I75e2387d5290e769f6b0fa1231dcc4605db68597
Reviewed-on: https://go-review.googlesource.com/c/go/+/330432
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modload/import.go         |  9 +++++
 .../testdata/script/mod_tidy_replace_old.txt  | 34 +++++++++++++++++++
 2 files changed, 43 insertions(+)
 create mode 100644 src/cmd/go/testdata/script/mod_tidy_replace_old.txt

diff --git a/src/cmd/go/internal/modload/import.go b/src/cmd/go/internal/modload/import.go
index 60bd26fb22..d2bbe5cbe0 100644
--- a/src/cmd/go/internal/modload/import.go
+++ b/src/cmd/go/internal/modload/import.go
@@ -428,6 +428,15 @@ func queryImport(ctx context.Context, path string, rs *Requirements) (module.Ver
 					mv = module.ZeroPseudoVersion("v0")
 				}
 			}
+			mg, err := rs.Graph(ctx)
+			if err != nil {
+				return module.Version{}, err
+			}
+			if cmpVersion(mg.Selected(mp), mv) >= 0 {
+				// We can't resolve the import by adding mp@mv to the module graph,
+				// because the selected version of mp is already at least mv.
+				continue
+			}
 			mods = append(mods, module.Version{Path: mp, Version: mv})
 		}
 
diff --git a/src/cmd/go/testdata/script/mod_tidy_replace_old.txt b/src/cmd/go/testdata/script/mod_tidy_replace_old.txt
new file mode 100644
index 0000000000..cfd3792600
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_tidy_replace_old.txt
@@ -0,0 +1,34 @@
+# Regression test for https://golang.org/issue/46659.
+#
+# If a 'replace' directive specifies an older-than-selected version of a module,
+# 'go mod tidy' shouldn't try to add that version to the build list to resolve a
+# missing package: it won't be selected, and would cause the module loader to
+# loop indefinitely trying to resolve the package.
+
+cp go.mod go.mod.orig
+
+! go mod tidy
+! stderr panic
+stderr '^golang\.org/issue46659 imports\n\texample\.com/missingpkg/deprecated: package example\.com/missingpkg/deprecated provided by example\.com/missingpkg at latest version v1\.0\.0 but not at required version v1\.0\.1-beta$'
+
+go mod tidy -e
+
+cmp go.mod go.mod.orig
+
+-- go.mod --
+module golang.org/issue46659
+
+go 1.17
+
+replace example.com/missingpkg v1.0.1-alpha => example.com/missingpkg v1.0.0
+
+require example.com/usemissingpre v1.0.0
+
+require example.com/missingpkg v1.0.1-beta // indirect
+-- m.go --
+package m
+
+import (
+	_ "example.com/missingpkg/deprecated"
+	_ "example.com/usemissingpre"
+)
-- 
GitLab


From cce621431a9bce86527b25898a01a7a693cc56a8 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Fri, 25 Jun 2021 01:45:32 +0700
Subject: [PATCH 2288/2400] cmd/compile: fix wrong type in SSA generation for
 OSLICE2ARRPTR

Fixes #46907

Change-Id: I6a2728d2f2159df583b32f40f6100d3e90c34dd7
Reviewed-on: https://go-review.googlesource.com/c/go/+/330672
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ssagen/ssa.go |  2 +-
 test/fixedbugs/issue46907.go           | 11 +++++++++++
 2 files changed, 12 insertions(+), 1 deletion(-)
 create mode 100644 test/fixedbugs/issue46907.go

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index 004e084f72..f1dc56e729 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -3174,7 +3174,7 @@ func (s *state) expr(n ir.Node) *ssa.Value {
 		arrlen := s.constInt(types.Types[types.TINT], n.Type().Elem().NumElem())
 		cap := s.newValue1(ssa.OpSliceLen, types.Types[types.TINT], v)
 		s.boundsCheck(arrlen, cap, ssa.BoundsConvert, false)
-		return s.newValue1(ssa.OpSlicePtrUnchecked, types.Types[types.TINT], v)
+		return s.newValue1(ssa.OpSlicePtrUnchecked, n.Type(), v)
 
 	case ir.OCALLFUNC:
 		n := n.(*ir.CallExpr)
diff --git a/test/fixedbugs/issue46907.go b/test/fixedbugs/issue46907.go
new file mode 100644
index 0000000000..bd82f4f2b1
--- /dev/null
+++ b/test/fixedbugs/issue46907.go
@@ -0,0 +1,11 @@
+// compile
+
+// Copyright 2021 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 p
+
+func f(b []byte) []byte {
+	return (*[32]byte)(b[:32])[:]
+}
-- 
GitLab


From c309c89db5aa15e1dad486c49ed4fd1babd23360 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 24 Jun 2021 10:44:39 -0700
Subject: [PATCH 2289/2400] reflect: document that InterfaceData is a
 low-entropy RNG

Change-Id: Ie26b9060630e2e774ac23d8492eaaf785bfca6b7
Reviewed-on: https://go-review.googlesource.com/c/go/+/330709
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/reflect/value.go | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/reflect/value.go b/src/reflect/value.go
index 6ba6202a1a..9dce251ac5 100644
--- a/src/reflect/value.go
+++ b/src/reflect/value.go
@@ -1381,10 +1381,16 @@ func valueInterface(v Value, safe bool) interface{} {
 	return packEface(v)
 }
 
-// InterfaceData returns the interface v's value as a uintptr pair.
+// InterfaceData returns a pair of unspecified uintptr values.
 // It panics if v's Kind is not Interface.
+//
+// In earlier versions of Go, this function returned the interface's
+// value as a uintptr pair. As of Go 1.4, the implementation of
+// interface values precludes any defined use of InterfaceData.
+//
+// Deprecated: The memory representation of interface values is not
+// compatible with InterfaceData.
 func (v Value) InterfaceData() [2]uintptr {
-	// TODO: deprecate this
 	v.mustBe(Interface)
 	// We treat this as a read operation, so we allow
 	// it even for unexported data, because the caller
-- 
GitLab


From 37f9a8f69d6299783eac8848d87e27eb563500ac Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 24 Jun 2021 11:01:49 -0400
Subject: [PATCH 2290/2400] go/types: fix a bug in package qualification logic

CL 313035 had a bug, initializing pkgPathMap by walking the imported
package being considered rather than check.pkg.

Fix this, and enhance our tests to exercise this bug as well as other
edge cases.

Also fix error assertions in issues.src to not use quotation marks
inside the error regexp. The check tests only matched the error regexp
up to the first quotation mark.

Fixes #46905

Change-Id: I6aa8eae4bec6495006a5c03fc063db0d66b44cd6
Reviewed-on: https://go-review.googlesource.com/c/go/+/330629
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/check_test.go             | 15 +++---
 src/go/types/errors.go                 |  2 +-
 src/go/types/issues_test.go            | 72 +++++++++++++++++---------
 src/go/types/testdata/check/issues.src |  4 +-
 4 files changed, 59 insertions(+), 34 deletions(-)

diff --git a/src/go/types/check_test.go b/src/go/types/check_test.go
index 5a3e57ba44..c85a8e46fb 100644
--- a/src/go/types/check_test.go
+++ b/src/go/types/check_test.go
@@ -202,7 +202,7 @@ func asGoVersion(s string) string {
 	return ""
 }
 
-func checkFiles(t *testing.T, sizes Sizes, goVersion string, filenames []string, srcs [][]byte, manual bool) {
+func checkFiles(t *testing.T, sizes Sizes, goVersion string, filenames []string, srcs [][]byte, manual bool, imp Importer) {
 	if len(filenames) == 0 {
 		t.Fatal("no source files")
 	}
@@ -252,7 +252,10 @@ func checkFiles(t *testing.T, sizes Sizes, goVersion string, filenames []string,
 		}
 	}
 
-	conf.Importer = importer.Default()
+	conf.Importer = imp
+	if imp == nil {
+		conf.Importer = importer.Default()
+	}
 	conf.Error = func(err error) {
 		if *haltOnError {
 			defer panic(err)
@@ -322,7 +325,7 @@ func TestManual(t *testing.T) {
 func TestLongConstants(t *testing.T) {
 	format := "package longconst\n\nconst _ = %s\nconst _ = %s // ERROR excessively long constant"
 	src := fmt.Sprintf(format, strings.Repeat("1", 9999), strings.Repeat("1", 10001))
-	checkFiles(t, nil, "", []string{"longconst.go"}, [][]byte{[]byte(src)}, false)
+	checkFiles(t, nil, "", []string{"longconst.go"}, [][]byte{[]byte(src)}, false, nil)
 }
 
 // TestIndexRepresentability tests that constant index operands must
@@ -330,7 +333,7 @@ func TestLongConstants(t *testing.T) {
 // represent larger values.
 func TestIndexRepresentability(t *testing.T) {
 	const src = "package index\n\nvar s []byte\nvar _ = s[int64 /* ERROR \"int64\\(1\\) << 40 \\(.*\\) overflows int\" */ (1) << 40]"
-	checkFiles(t, &StdSizes{4, 4}, "", []string{"index.go"}, [][]byte{[]byte(src)}, false)
+	checkFiles(t, &StdSizes{4, 4}, "", []string{"index.go"}, [][]byte{[]byte(src)}, false, nil)
 }
 
 func TestIssue46453(t *testing.T) {
@@ -338,7 +341,7 @@ func TestIssue46453(t *testing.T) {
 		t.Skip("type params are enabled")
 	}
 	const src = "package p\ntype _ comparable // ERROR \"undeclared name: comparable\""
-	checkFiles(t, nil, "", []string{"issue46453.go"}, [][]byte{[]byte(src)}, false)
+	checkFiles(t, nil, "", []string{"issue46453.go"}, [][]byte{[]byte(src)}, false, nil)
 }
 
 func TestCheck(t *testing.T)     { DefPredeclaredTestFuncs(); testDir(t, "check") }
@@ -388,5 +391,5 @@ func testPkg(t *testing.T, filenames []string, goVersion string, manual bool) {
 		}
 		srcs[i] = src
 	}
-	checkFiles(t, nil, goVersion, filenames, srcs, manual)
+	checkFiles(t, nil, goVersion, filenames, srcs, manual, nil)
 }
diff --git a/src/go/types/errors.go b/src/go/types/errors.go
index 19e9ae8d44..2263106417 100644
--- a/src/go/types/errors.go
+++ b/src/go/types/errors.go
@@ -31,7 +31,7 @@ func (check *Checker) qualifier(pkg *Package) string {
 		if check.pkgPathMap == nil {
 			check.pkgPathMap = make(map[string]map[string]bool)
 			check.seenPkgMap = make(map[*Package]bool)
-			check.markImports(pkg)
+			check.markImports(check.pkg)
 		}
 		// If the same package name was used by multiple packages, display the full path.
 		if len(check.pkgPathMap[pkg.name]) > 1 {
diff --git a/src/go/types/issues_test.go b/src/go/types/issues_test.go
index 44926919ef..519e199536 100644
--- a/src/go/types/issues_test.go
+++ b/src/go/types/issues_test.go
@@ -577,42 +577,64 @@ func TestIssue44515(t *testing.T) {
 }
 
 func TestIssue43124(t *testing.T) {
-	// TODO(rFindley) enhance the testdata tests to be able to express this type
-	//                of setup.
+	// TODO(rFindley) move this to testdata by enhancing support for importing.
 
 	// All involved packages have the same name (template). Error messages should
 	// disambiguate between text/template and html/template by printing the full
 	// path.
 	const (
 		asrc = `package a; import "text/template"; func F(template.Template) {}; func G(int) {}`
-		bsrc = `package b; import ("a"; "html/template"); func _() { a.F(template.Template{}) }`
-		csrc = `package c; import ("a"; "html/template"); func _() { a.G(template.Template{}) }`
+		bsrc = `
+package b
+
+import (
+	"a"
+	"html/template"
+)
+
+func _() {
+	// Packages should be fully qualified when there is ambiguity within the
+	// error string itself.
+	a.F(template /* ERROR cannot use.*html/template.* as .*text/template */ .Template{})
+}
+`
+		csrc = `
+package c
+
+import (
+	"a"
+	"fmt"
+	"html/template"
+)
+
+// Issue #46905: make sure template is not the first package qualified.
+var _ fmt.Stringer = 1 // ERROR cannot use 1.*as fmt\.Stringer
+
+// Packages should be fully qualified when there is ambiguity in reachable
+// packages. In this case both a (and for that matter html/template) import
+// text/template.
+func _() { a.G(template /* ERROR cannot use .*html/template.*Template */ .Template{}) }
+`
+
+		tsrc = `
+package template
+
+import "text/template"
+
+type T int
+
+// Verify that the current package name also causes disambiguation.
+var _ T = template /* ERROR cannot use.*text/template.* as T value */.Template{}
+`
 	)
 
 	a, err := pkgFor("a", asrc, nil)
 	if err != nil {
 		t.Fatalf("package a failed to typecheck: %v", err)
 	}
-	conf := Config{Importer: importHelper{pkg: a, fallback: importer.Default()}}
-
-	// Packages should be fully qualified when there is ambiguity within the
-	// error string itself.
-	bast := mustParse(t, bsrc)
-	_, err = conf.Check(bast.Name.Name, fset, []*ast.File{bast}, nil)
-	if err == nil {
-		t.Fatal("package b had no errors")
-	}
-	if !strings.Contains(err.Error(), "text/template") || !strings.Contains(err.Error(), "html/template") {
-		t.Errorf("type checking error for b does not disambiguate package template: %q", err)
-	}
+	imp := importHelper{pkg: a, fallback: importer.Default()}
 
-	// ...and also when there is any ambiguity in reachable packages.
-	cast := mustParse(t, csrc)
-	_, err = conf.Check(cast.Name.Name, fset, []*ast.File{cast}, nil)
-	if err == nil {
-		t.Fatal("package c had no errors")
-	}
-	if !strings.Contains(err.Error(), "html/template") {
-		t.Errorf("type checking error for c does not disambiguate package template: %q", err)
-	}
+	checkFiles(t, nil, "", []string{"b.go"}, [][]byte{[]byte(bsrc)}, false, imp)
+	checkFiles(t, nil, "", []string{"c.go"}, [][]byte{[]byte(csrc)}, false, imp)
+	checkFiles(t, nil, "", []string{"t.go"}, [][]byte{[]byte(tsrc)}, false, imp)
 }
diff --git a/src/go/types/testdata/check/issues.src b/src/go/types/testdata/check/issues.src
index e2ac06759b..74d185cbc3 100644
--- a/src/go/types/testdata/check/issues.src
+++ b/src/go/types/testdata/check/issues.src
@@ -332,7 +332,7 @@ func issue28281g() (... /* ERROR can only use ... with final parameter */ TT)
 func issue26234a(f *syn.File) {
 	// The error message below should refer to the actual package name (syntax)
 	// not the local package name (syn).
-	f.foo /* ERROR f.foo undefined \(type \*syntax.File has no field or method foo\) */
+	f.foo /* ERROR f\.foo undefined \(type \*syntax\.File has no field or method foo\) */
 }
 
 type T struct {
@@ -361,7 +361,7 @@ func issue35895() {
 
 	// Because both t1 and t2 have the same global package name (template),
 	// qualify packages with full path name in this case.
-	var _ t1.Template = t2 /* ERROR cannot use .* \(value of type "html/template".Template\) as "text/template".Template */ .Template{}
+	var _ t1.Template = t2 /* ERROR cannot use .* \(value of type .html/template.\.Template\) as .text/template.\.Template */ .Template{}
 }
 
 func issue42989(s uint) {
-- 
GitLab


From d01bc571f7e55c7376f34e86be4e5660887bd30c Mon Sep 17 00:00:00 2001
From: Tao Qingyun <qingyunha@gmail.com>
Date: Tue, 22 Jun 2021 00:24:05 +0000
Subject: [PATCH 2291/2400] runtime: make ncgocall a global counter

ncgocall was stored per M, runtime.NumCgoCall lost the counter when a M die.

Fixes #46789

Change-Id: I85831fbb2713f4c30d1800d07e1f47aa0031970e
GitHub-Last-Rev: cbc15fa870de776d3fbf3b62fc9a5e01792e6a26
GitHub-Pull-Request: golang/go#46842
Reviewed-on: https://go-review.googlesource.com/c/go/+/329729
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Alexander Rakoczy <alex@golang.org>
---
 src/runtime/cgocall.go | 2 ++
 src/runtime/debug.go   | 2 +-
 src/runtime/proc.go    | 2 ++
 3 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/runtime/cgocall.go b/src/runtime/cgocall.go
index 0e287d0b8e..8ffb48a888 100644
--- a/src/runtime/cgocall.go
+++ b/src/runtime/cgocall.go
@@ -110,6 +110,8 @@ func syscall_cgocaller(fn unsafe.Pointer, args ...uintptr) uintptr {
 	return as.retval
 }
 
+var ncgocall uint64 // number of cgo calls in total for dead m
+
 // Call from Go to C.
 //
 // This must be nosplit because it's used for syscalls on some
diff --git a/src/runtime/debug.go b/src/runtime/debug.go
index f411b22676..82deefa200 100644
--- a/src/runtime/debug.go
+++ b/src/runtime/debug.go
@@ -45,7 +45,7 @@ func NumCPU() int {
 
 // NumCgoCall returns the number of cgo calls made by the current process.
 func NumCgoCall() int64 {
-	var n int64
+	var n = int64(atomic.Load64(&ncgocall))
 	for mp := (*m)(atomic.Loadp(unsafe.Pointer(&allm))); mp != nil; mp = mp.alllink {
 		n += int64(mp.ncgocall)
 	}
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 8f1a443945..4c92588a66 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -1522,6 +1522,8 @@ found:
 	}
 	unlock(&sched.lock)
 
+	atomic.Xadd64(&ncgocall, int64(m.ncgocall))
+
 	// Release the P.
 	handoffp(releasep())
 	// After this point we must not have write barriers.
-- 
GitLab


From 5160896c69a83f14bc54beb04be4c089333a0387 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Wed, 23 Jun 2021 00:50:43 -0400
Subject: [PATCH 2292/2400] go/types: in TestStdlib, import from source instead
 of export data
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

TestStdlib was failing after running
	rm -r $(go env GOROOT)/pkg/*/cmd
as the builders do when building binary releases.¹

For users who write programs that depend on go/types, it should be
reasonable to run the tests for go/types as part of 'go test all', and
those tests should pass even if they installed Go from a binary
release.

I had originally drafted this as a fallback to import from source only
if the affected packages can't be imported by the default export-data
importer. Unfortunately, I realized that we don't currently have a
builder that tests the actual release (#46900), so it is quite likely
that the fallback path would bit-rot and produce unexpected test
regressions.

So instead, we now unconditionally import from source in TestStdlib.
That makes the test substantially slower (~15s instead of ~5s on my
workstation), but with less risk of regression, and TestStdlib is
skipped in short mode already so short-mode test time is unaffected.

If we change the builders to test the actual release configuration, we
can consider restoring the faster path when export data is available.

¹https://github.com/golang/build/blob/df58bbac082bc87c4a3cdfe336d1ffe60bbaa916/cmd/release/release.go#L533-L545

For #43232

Change-Id: I764ec56926c104053bb2ef23cf258c8f0f773290
Reviewed-on: https://go-review.googlesource.com/c/go/+/330252
Trust: Bryan C. Mills <bcmills@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/stdlib_test.go | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/go/types/stdlib_test.go b/src/go/types/stdlib_test.go
index 503d0a6f44..d86a77a110 100644
--- a/src/go/types/stdlib_test.go
+++ b/src/go/types/stdlib_test.go
@@ -26,9 +26,15 @@ import (
 	. "go/types"
 )
 
+// The cmd/*/internal packages may have been deleted as part of a binary
+// release. Import from source instead.
+//
+// (See https://golang.org/issue/43232 and
+// https://github.com/golang/build/blob/df58bbac082bc87c4a3cdfe336d1ffe60bbaa916/cmd/release/release.go#L533-L545.)
+//
 // Use the same importer for all std lib tests to
 // avoid repeated importing of the same packages.
-var stdLibImporter = importer.Default()
+var stdLibImporter = importer.ForCompiler(token.NewFileSet(), "source", nil)
 
 func TestStdlib(t *testing.T) {
 	testenv.MustHaveGoBuild(t)
-- 
GitLab


From d1916e5e843d0341c2d82edf08335ac181c41bd8 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Wed, 23 Jun 2021 22:06:50 -0400
Subject: [PATCH 2293/2400] go/types: in TestCheck/issues.src, import
 regexp/syntax instead of cmd/compile/internal/syntax

TestCheck/issues.src was failing after running
	rm -r $(go env GOROOT)/pkg/*/cmd
as the builders do when building binary releases.

For users who write programs that depend on go/types, it should be
reasonable for end users to run the tests for go/types as part of 'go
test all', and those tests should pass even if they installed Go from
a binary release.

The test case in issues.src was importing cmd/compile/internal/syntax
in order to check the reported package name.

I tried to fix the problem by having the test import from source
instead of from export data. Unfortunately, that changed the behavior
under test: the go/types.Package.Imports reports (and is documented to
report) a different set of imported packages when loading from source
as compared to when loading from export data.

For this particular test, after CL 313035 that difference resulted in
go/types treating the "syntax" name as ambiguous when importing from
source, because a transitive dependency on "regexp/syntax" is found
when loading from source but omitted when loading from export data.

The simple fix to make the package unambiguous again is to adapt the
test to import regexp/syntax directly. That not only makes the package
unambiguous with all importers, but also avoids depending on a
cmd-internal package that cannot be loaded from export data in binary
distributions of the Go toolchain.

For #43232

Change-Id: Iba45a680ea20d26daa86ac538fd8f1938e8b73ab
Reviewed-on: https://go-review.googlesource.com/c/go/+/330431
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 src/go/types/testdata/check/issues.src | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/go/types/testdata/check/issues.src b/src/go/types/testdata/check/issues.src
index 74d185cbc3..55fe220337 100644
--- a/src/go/types/testdata/check/issues.src
+++ b/src/go/types/testdata/check/issues.src
@@ -6,7 +6,7 @@ package issues
 
 import (
 	"fmt"
-	syn "cmd/compile/internal/syntax"
+	syn "regexp/syntax"
 	t1 "text/template"
 	t2 "html/template"
 )
@@ -329,10 +329,10 @@ func (... /* ERROR can only use ... with final parameter */ TT) f()
 func issue28281g() (... /* ERROR can only use ... with final parameter */ TT)
 
 // Issue #26234: Make various field/method lookup errors easier to read by matching cmd/compile's output
-func issue26234a(f *syn.File) {
+func issue26234a(f *syn.Prog) {
 	// The error message below should refer to the actual package name (syntax)
 	// not the local package name (syn).
-	f.foo /* ERROR f\.foo undefined \(type \*syntax\.File has no field or method foo\) */
+	f.foo /* ERROR f\.foo undefined \(type \*syntax\.Prog has no field or method foo\) */
 }
 
 type T struct {
@@ -357,7 +357,7 @@ func issue35895() {
 	var _ T = 0 // ERROR cannot use 0 \(untyped int constant\) as T
 
 	// There is only one package with name syntax imported, only use the (global) package name in error messages.
-	var _ *syn.File = 0 // ERROR cannot use 0 \(untyped int constant\) as \*syntax.File
+	var _ *syn.Prog = 0 // ERROR cannot use 0 \(untyped int constant\) as \*syntax.Prog
 
 	// Because both t1 and t2 have the same global package name (template),
 	// qualify packages with full path name in this case.
-- 
GitLab


From ed01ceaf4838cd67fd802df481769fa9ae9d0440 Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Fri, 25 Jun 2021 15:58:38 -0400
Subject: [PATCH 2294/2400] runtime/race: use race build tag on syso_test.go

All other test files in the runtime/race package have race build
tag, except syso_test.go. The test is only relevant if the race
detector is supported. So apply the build tag.

Fixes #46931.

Change-Id: Icdb94214d3821b4ccf61133412ef39b4d7cc7691
Reviewed-on: https://go-review.googlesource.com/c/go/+/331050
Trust: Cherry Mui <cherryyz@google.com>
Reviewed-by: Elias Naur <mail@eliasnaur.com>
Run-TryBot: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/race/syso_test.go | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/src/runtime/race/syso_test.go b/src/runtime/race/syso_test.go
index cbce5a8f18..f5095737a4 100644
--- a/src/runtime/race/syso_test.go
+++ b/src/runtime/race/syso_test.go
@@ -2,14 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build !android && !js && !ppc64le
-// +build !android,!js,!ppc64le
-
-// Note: we don't run on Android or ppc64 because if there is any non-race test
-// file in this package, the OS tries to link the .syso file into the
-// test (even when we're not in race mode), which fails. I'm not sure
-// why, but easiest to just punt - as long as a single builder runs
-// this test, we're good.
+//go:build race
+// +build race
 
 package race
 
-- 
GitLab


From c95464f0ea3f87232b1f3937d1b37da6f335f336 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 25 Jun 2021 13:24:10 -0700
Subject: [PATCH 2295/2400] internal/buildcfg: refactor GOEXPERIMENT parsing
 code somewhat

This CL extracts out a ParseGOEXPERIMENT helper function that parses
GOOS/GOARCH/GOEXPERIMENT values and returns active and baseline
experiment flag sets and an error value, without affecting any global
state. This will be used in the subsequent CL for 'go env' support for
GOEXPERIMENT to validate configuration changes.

The existing package initialization for Experiment and
experimentBaseline and also UpdateExperiments are updated to use it as
well.

Change-Id: Ic2ed3fd36d2a6f7f3d8172fccb865e02505c0052
Reviewed-on: https://go-review.googlesource.com/c/go/+/331109
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/go/internal/cfg/cfg.go |  2 +-
 src/internal/buildcfg/exp.go   | 65 +++++++++++++++++++++-------------
 2 files changed, 41 insertions(+), 26 deletions(-)

diff --git a/src/cmd/go/internal/cfg/cfg.go b/src/cmd/go/internal/cfg/cfg.go
index fc6989097e..57a3c1ff6f 100644
--- a/src/cmd/go/internal/cfg/cfg.go
+++ b/src/cmd/go/internal/cfg/cfg.go
@@ -79,7 +79,7 @@ func defaultContext() build.Context {
 
 	// The experiments flags are based on GOARCH, so they may
 	// need to change.  TODO: This should be cleaned up.
-	buildcfg.UpdateExperiments(ctxt.GOARCH)
+	buildcfg.UpdateExperiments(ctxt.GOOS, ctxt.GOARCH, envOr("GOEXPERIMENT", buildcfg.DefaultGOEXPERIMENT))
 	ctxt.ToolTags = nil
 	for _, exp := range buildcfg.EnabledExperiments() {
 		ctxt.ToolTags = append(ctxt.ToolTags, "goexperiment."+exp)
diff --git a/src/internal/buildcfg/exp.go b/src/internal/buildcfg/exp.go
index 640aa1934d..9a60253aab 100644
--- a/src/internal/buildcfg/exp.go
+++ b/src/internal/buildcfg/exp.go
@@ -6,7 +6,6 @@ package buildcfg
 
 import (
 	"fmt"
-	"os"
 	"reflect"
 	"strings"
 
@@ -18,20 +17,19 @@ import (
 //
 // (This is not necessarily the set of experiments the compiler itself
 // was built with.)
-var Experiment goexperiment.Flags = parseExperiments(GOARCH)
-
-var regabiSupported = GOARCH == "amd64" && (GOOS == "android" || GOOS == "linux" || GOOS == "darwin" || GOOS == "windows")
-
+//
 // experimentBaseline specifies the experiment flags that are enabled by
 // default in the current toolchain. This is, in effect, the "control"
 // configuration and any variation from this is an experiment.
-var experimentBaseline = goexperiment.Flags{
-	RegabiWrappers: regabiSupported,
-	RegabiG:        regabiSupported,
-	RegabiReflect:  regabiSupported,
-	RegabiDefer:    regabiSupported,
-	RegabiArgs:     regabiSupported,
-}
+var Experiment, experimentBaseline = func() (goexperiment.Flags, goexperiment.Flags) {
+	flags, baseline, err := ParseGOEXPERIMENT(GOOS, GOARCH, envOr("GOEXPERIMENT", defaultGOEXPERIMENT))
+	if err != nil {
+		Error = err
+	}
+	return flags, baseline
+}()
+
+const DefaultGOEXPERIMENT = defaultGOEXPERIMENT
 
 // FramePointerEnabled enables the use of platform conventions for
 // saving frame pointers.
@@ -42,16 +40,29 @@ var experimentBaseline = goexperiment.Flags{
 // Note: must agree with runtime.framepointer_enabled.
 var FramePointerEnabled = GOARCH == "amd64" || GOARCH == "arm64"
 
-func parseExperiments(goarch string) goexperiment.Flags {
+// ParseGOEXPERIMENT parses a (GOOS, GOARCH, GOEXPERIMENT)
+// configuration tuple and returns the enabled and baseline experiment
+// flag sets.
+//
+// TODO(mdempsky): Move to internal/goexperiment.
+func ParseGOEXPERIMENT(goos, goarch, goexp string) (flags, baseline goexperiment.Flags, err error) {
+	regabiSupported := goarch == "amd64" && (goos == "android" || goos == "linux" || goos == "darwin" || goos == "windows")
+
+	baseline = goexperiment.Flags{
+		RegabiWrappers: regabiSupported,
+		RegabiG:        regabiSupported,
+		RegabiReflect:  regabiSupported,
+		RegabiDefer:    regabiSupported,
+		RegabiArgs:     regabiSupported,
+	}
+
 	// Start with the statically enabled set of experiments.
-	flags := experimentBaseline
+	flags = baseline
 
 	// Pick up any changes to the baseline configuration from the
 	// GOEXPERIMENT environment. This can be set at make.bash time
 	// and overridden at build time.
-	env := envOr("GOEXPERIMENT", defaultGOEXPERIMENT)
-
-	if env != "" {
+	if goexp != "" {
 		// Create a map of known experiment names.
 		names := make(map[string]func(bool))
 		rv := reflect.ValueOf(&flags).Elem()
@@ -74,7 +85,7 @@ func parseExperiments(goarch string) goexperiment.Flags {
 		}
 
 		// Parse names.
-		for _, f := range strings.Split(env, ",") {
+		for _, f := range strings.Split(goexp, ",") {
 			if f == "" {
 				continue
 			}
@@ -91,8 +102,8 @@ func parseExperiments(goarch string) goexperiment.Flags {
 			}
 			set, ok := names[f]
 			if !ok {
-				fmt.Printf("unknown experiment %s\n", f)
-				os.Exit(2)
+				err = fmt.Errorf("unknown GOEXPERIMENT %s", f)
+				return
 			}
 			set(val)
 		}
@@ -108,12 +119,12 @@ func parseExperiments(goarch string) goexperiment.Flags {
 	}
 	// Check regabi dependencies.
 	if flags.RegabiG && !flags.RegabiWrappers {
-		Error = fmt.Errorf("GOEXPERIMENT regabig requires regabiwrappers")
+		err = fmt.Errorf("GOEXPERIMENT regabig requires regabiwrappers")
 	}
 	if flags.RegabiArgs && !(flags.RegabiWrappers && flags.RegabiG && flags.RegabiReflect && flags.RegabiDefer) {
-		Error = fmt.Errorf("GOEXPERIMENT regabiargs requires regabiwrappers,regabig,regabireflect,regabidefer")
+		err = fmt.Errorf("GOEXPERIMENT regabiargs requires regabiwrappers,regabig,regabireflect,regabidefer")
 	}
-	return flags
+	return
 }
 
 // expList returns the list of lower-cased experiment names for
@@ -169,6 +180,10 @@ func AllExperiments() []string {
 // UpdateExperiments updates the Experiment global based on a new GOARCH value.
 // This is only required for cmd/go, which can change GOARCH after
 // program startup due to use of "go env -w".
-func UpdateExperiments(goarch string) {
-	Experiment = parseExperiments(goarch)
+func UpdateExperiments(goos, goarch, goexperiment string) {
+	var err error
+	Experiment, experimentBaseline, err = ParseGOEXPERIMENT(goos, goarch, goexperiment)
+	if err != nil {
+		Error = err
+	}
 }
-- 
GitLab


From 361159c05507b7f6c28e29575c02a6b7b6656f84 Mon Sep 17 00:00:00 2001
From: Koichi Shiraishi <zchee.io@gmail.com>
Date: Sun, 27 Jun 2021 11:50:17 +0900
Subject: [PATCH 2296/2400] cmd/cgo: fix 'see gmp.go' to 'see doc.go'

Change-Id: I303edc9dfbf4185b5b461b121ab504f6ed9f8630
Reviewed-on: https://go-review.googlesource.com/c/go/+/330839
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Dmitri Shuralyov <dmitshur@golang.org>
---
 src/cmd/cgo/main.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/cgo/main.go b/src/cmd/cgo/main.go
index 03a662e689..c6a0c525e6 100644
--- a/src/cmd/cgo/main.go
+++ b/src/cmd/cgo/main.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Cgo; see gmp.go for an overview.
+// Cgo; see doc.go for an overview.
 
 // TODO(rsc):
 //	Emit correct line number annotations.
-- 
GitLab


From 901510ed4ef1a979321f33159b534e374290ef65 Mon Sep 17 00:00:00 2001
From: hao <tfzxyinhao@qq.com>
Date: Fri, 28 May 2021 03:40:12 +0000
Subject: [PATCH 2297/2400] cmd/link/internal/ld: skip the windows ASLR test
 when CGO_ENABLED=0

the test case is still using gcc when CGO is disabled.

Change-Id: I2d255bfaeb92816c8343ab72fd7984b6632d421d
GitHub-Last-Rev: de14748bd54c7db8687263a7c37080ec884d982a
GitHub-Pull-Request: golang/go#46120
Reviewed-on: https://go-review.googlesource.com/c/go/+/319169
Reviewed-by: Cherry Mui <cherryyz@google.com>
Run-TryBot: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dmitri Shuralyov <dmitshur@golang.org>
---
 src/cmd/link/internal/ld/ld_test.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/cmd/link/internal/ld/ld_test.go b/src/cmd/link/internal/ld/ld_test.go
index ca764632c3..3702a4d08f 100644
--- a/src/cmd/link/internal/ld/ld_test.go
+++ b/src/cmd/link/internal/ld/ld_test.go
@@ -174,6 +174,8 @@ func TestWindowsBuildmodeCSharedASLR(t *testing.T) {
 		t.Skip("skipping windows amd64/386 only test")
 	}
 
+	testenv.MustHaveCGO(t)
+
 	t.Run("aslr", func(t *testing.T) {
 		testWindowsBuildmodeCSharedASLR(t, true)
 	})
-- 
GitLab


From a1d27269d698d684497d0dc61c968a1c2dbe00b3 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sat, 19 Jun 2021 03:35:15 -0700
Subject: [PATCH 2298/2400] cmd/go: prep for 'go env' refactoring

This CL refactors code a little to make it easier to add GOEXPERIMENT
support in the future.

Change-Id: I87903056f7863049e58be72047b2b8a60a213baf
Reviewed-on: https://go-review.googlesource.com/c/go/+/329654
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Trust: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go/internal/envcmd/env.go        | 210 ++++++++++++-----------
 src/cmd/go/main.go                       |  64 +++----
 src/cmd/go/testdata/script/env_unset.txt |  23 +++
 3 files changed, 170 insertions(+), 127 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/env_unset.txt

diff --git a/src/cmd/go/internal/envcmd/env.go b/src/cmd/go/internal/envcmd/env.go
index b30c37ab27..d88dcce5c0 100644
--- a/src/cmd/go/internal/envcmd/env.go
+++ b/src/cmd/go/internal/envcmd/env.go
@@ -10,6 +10,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"go/build"
+	"internal/buildcfg"
 	"io"
 	"os"
 	"path/filepath"
@@ -197,6 +198,21 @@ func runEnv(ctx context.Context, cmd *base.Command, args []string) {
 	if *envU && *envW {
 		base.Fatalf("go env: cannot use -u with -w")
 	}
+
+	// Handle 'go env -w' and 'go env -u' before calling buildcfg.Check,
+	// so they can be used to recover from an invalid configuration.
+	if *envW {
+		runEnvW(args)
+		return
+	}
+
+	if *envU {
+		runEnvU(args)
+		return
+	}
+
+	buildcfg.Check()
+
 	env := cfg.CmdEnv
 	env = append(env, ExtraEnvVars()...)
 
@@ -206,14 +222,7 @@ func runEnv(ctx context.Context, cmd *base.Command, args []string) {
 
 	// Do we need to call ExtraEnvVarsCostly, which is a bit expensive?
 	needCostly := false
-	if *envU || *envW {
-		// We're overwriting or removing default settings,
-		// so it doesn't really matter what the existing settings are.
-		//
-		// Moreover, we haven't validated the new settings yet, so it is
-		// important that we NOT perform any actions based on them,
-		// such as initializing the builder to compute other variables.
-	} else if len(args) == 0 {
+	if len(args) == 0 {
 		// We're listing all environment variables ("go env"),
 		// including the expensive ones.
 		needCostly = true
@@ -238,95 +247,6 @@ func runEnv(ctx context.Context, cmd *base.Command, args []string) {
 		env = append(env, ExtraEnvVarsCostly()...)
 	}
 
-	if *envW {
-		// Process and sanity-check command line.
-		if len(args) == 0 {
-			base.Fatalf("go env -w: no KEY=VALUE arguments given")
-		}
-		osEnv := make(map[string]string)
-		for _, e := range cfg.OrigEnv {
-			if i := strings.Index(e, "="); i >= 0 {
-				osEnv[e[:i]] = e[i+1:]
-			}
-		}
-		add := make(map[string]string)
-		for _, arg := range args {
-			i := strings.Index(arg, "=")
-			if i < 0 {
-				base.Fatalf("go env -w: arguments must be KEY=VALUE: invalid argument: %s", arg)
-			}
-			key, val := arg[:i], arg[i+1:]
-			if err := checkEnvWrite(key, val); err != nil {
-				base.Fatalf("go env -w: %v", err)
-			}
-			if _, ok := add[key]; ok {
-				base.Fatalf("go env -w: multiple values for key: %s", key)
-			}
-			add[key] = val
-			if osVal := osEnv[key]; osVal != "" && osVal != val {
-				fmt.Fprintf(os.Stderr, "warning: go env -w %s=... does not override conflicting OS environment variable\n", key)
-			}
-		}
-
-		goos, okGOOS := add["GOOS"]
-		goarch, okGOARCH := add["GOARCH"]
-		if okGOOS || okGOARCH {
-			if !okGOOS {
-				goos = cfg.Goos
-			}
-			if !okGOARCH {
-				goarch = cfg.Goarch
-			}
-			if err := work.CheckGOOSARCHPair(goos, goarch); err != nil {
-				base.Fatalf("go env -w: %v", err)
-			}
-		}
-
-		gotmp, okGOTMP := add["GOTMPDIR"]
-		if okGOTMP {
-			if !filepath.IsAbs(gotmp) && gotmp != "" {
-				base.Fatalf("go env -w: GOTMPDIR must be an absolute path")
-			}
-		}
-
-		updateEnvFile(add, nil)
-		return
-	}
-
-	if *envU {
-		// Process and sanity-check command line.
-		if len(args) == 0 {
-			base.Fatalf("go env -u: no arguments given")
-		}
-		del := make(map[string]bool)
-		for _, arg := range args {
-			if err := checkEnvWrite(arg, ""); err != nil {
-				base.Fatalf("go env -u: %v", err)
-			}
-			del[arg] = true
-		}
-		if del["GOOS"] || del["GOARCH"] {
-			goos, goarch := cfg.Goos, cfg.Goarch
-			if del["GOOS"] {
-				goos = getOrigEnv("GOOS")
-				if goos == "" {
-					goos = build.Default.GOOS
-				}
-			}
-			if del["GOARCH"] {
-				goarch = getOrigEnv("GOARCH")
-				if goarch == "" {
-					goarch = build.Default.GOARCH
-				}
-			}
-			if err := work.CheckGOOSARCHPair(goos, goarch); err != nil {
-				base.Fatalf("go env -u: %v", err)
-			}
-		}
-		updateEnvFile(nil, del)
-		return
-	}
-
 	if len(args) > 0 {
 		if *envJson {
 			var es []cfg.EnvVar
@@ -351,6 +271,102 @@ func runEnv(ctx context.Context, cmd *base.Command, args []string) {
 	PrintEnv(os.Stdout, env)
 }
 
+func runEnvW(args []string) {
+	// Process and sanity-check command line.
+	if len(args) == 0 {
+		base.Fatalf("go env -w: no KEY=VALUE arguments given")
+	}
+	osEnv := make(map[string]string)
+	for _, e := range cfg.OrigEnv {
+		if i := strings.Index(e, "="); i >= 0 {
+			osEnv[e[:i]] = e[i+1:]
+		}
+	}
+	add := make(map[string]string)
+	for _, arg := range args {
+		i := strings.Index(arg, "=")
+		if i < 0 {
+			base.Fatalf("go env -w: arguments must be KEY=VALUE: invalid argument: %s", arg)
+		}
+		key, val := arg[:i], arg[i+1:]
+		if err := checkEnvWrite(key, val); err != nil {
+			base.Fatalf("go env -w: %v", err)
+		}
+		if _, ok := add[key]; ok {
+			base.Fatalf("go env -w: multiple values for key: %s", key)
+		}
+		add[key] = val
+		if osVal := osEnv[key]; osVal != "" && osVal != val {
+			fmt.Fprintf(os.Stderr, "warning: go env -w %s=... does not override conflicting OS environment variable\n", key)
+		}
+	}
+
+	if err := checkBuildConfig(add, nil); err != nil {
+		base.Fatalf("go env -w: %v", err)
+	}
+
+	gotmp, okGOTMP := add["GOTMPDIR"]
+	if okGOTMP {
+		if !filepath.IsAbs(gotmp) && gotmp != "" {
+			base.Fatalf("go env -w: GOTMPDIR must be an absolute path")
+		}
+	}
+
+	updateEnvFile(add, nil)
+}
+
+func runEnvU(args []string) {
+	// Process and sanity-check command line.
+	if len(args) == 0 {
+		base.Fatalf("go env -u: no arguments given")
+	}
+	del := make(map[string]bool)
+	for _, arg := range args {
+		if err := checkEnvWrite(arg, ""); err != nil {
+			base.Fatalf("go env -u: %v", err)
+		}
+		del[arg] = true
+	}
+
+	if err := checkBuildConfig(nil, del); err != nil {
+		base.Fatalf("go env -u: %v", err)
+	}
+
+	updateEnvFile(nil, del)
+}
+
+// checkBuildConfig checks whether the build configuration is valid
+// after the specified configuration environment changes are applied.
+func checkBuildConfig(add map[string]string, del map[string]bool) error {
+	// get returns the value for key after applying add and del and
+	// reports whether it changed. cur should be the current value
+	// (i.e., before applying changes) and def should be the default
+	// value (i.e., when no environment variables are provided at all).
+	get := func(key, cur, def string) (string, bool) {
+		if val, ok := add[key]; ok {
+			return val, true
+		}
+		if del[key] {
+			val := getOrigEnv(key)
+			if val == "" {
+				val = def
+			}
+			return val, true
+		}
+		return cur, false
+	}
+
+	goos, okGOOS := get("GOOS", cfg.Goos, build.Default.GOOS)
+	goarch, okGOARCH := get("GOARCH", cfg.Goarch, build.Default.GOARCH)
+	if okGOOS || okGOARCH {
+		if err := work.CheckGOOSARCHPair(goos, goarch); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
 // PrintEnv prints the environment variables to w.
 func PrintEnv(w io.Writer, env []cfg.EnvVar) {
 	for _, e := range env {
diff --git a/src/cmd/go/main.go b/src/cmd/go/main.go
index 02174a56ff..16361e02ca 100644
--- a/src/cmd/go/main.go
+++ b/src/cmd/go/main.go
@@ -145,24 +145,6 @@ func main() {
 		os.Exit(2)
 	}
 
-	if err := buildcfg.Error; err != nil {
-		fmt.Fprintf(os.Stderr, "go: %v\n", buildcfg.Error)
-		os.Exit(2)
-	}
-
-	// Set environment (GOOS, GOARCH, etc) explicitly.
-	// In theory all the commands we invoke should have
-	// the same default computation of these as we do,
-	// but in practice there might be skew
-	// This makes sure we all agree.
-	cfg.OrigEnv = os.Environ()
-	cfg.CmdEnv = envcmd.MkEnv()
-	for _, env := range cfg.CmdEnv {
-		if os.Getenv(env.Name) != env.Value {
-			os.Setenv(env.Name, env.Value)
-		}
-	}
-
 BigCmdLoop:
 	for bigCmd := base.Go; ; {
 		for _, cmd := range bigCmd.Commands {
@@ -188,18 +170,7 @@ BigCmdLoop:
 			if !cmd.Runnable() {
 				continue
 			}
-			cmd.Flag.Usage = func() { cmd.Usage() }
-			if cmd.CustomFlags {
-				args = args[1:]
-			} else {
-				base.SetFromGOFLAGS(&cmd.Flag)
-				cmd.Flag.Parse(args[1:])
-				args = cmd.Flag.Args()
-			}
-			ctx := maybeStartTrace(context.Background())
-			ctx, span := trace.StartSpan(ctx, fmt.Sprint("Running ", cmd.Name(), " command"))
-			cmd.Run(ctx, cmd, args)
-			span.Done()
+			invoke(cmd, args)
 			base.Exit()
 			return
 		}
@@ -213,6 +184,39 @@ BigCmdLoop:
 	}
 }
 
+func invoke(cmd *base.Command, args []string) {
+	// 'go env' handles checking the build config
+	if cmd != envcmd.CmdEnv {
+		buildcfg.Check()
+	}
+
+	// Set environment (GOOS, GOARCH, etc) explicitly.
+	// In theory all the commands we invoke should have
+	// the same default computation of these as we do,
+	// but in practice there might be skew
+	// This makes sure we all agree.
+	cfg.OrigEnv = os.Environ()
+	cfg.CmdEnv = envcmd.MkEnv()
+	for _, env := range cfg.CmdEnv {
+		if os.Getenv(env.Name) != env.Value {
+			os.Setenv(env.Name, env.Value)
+		}
+	}
+
+	cmd.Flag.Usage = func() { cmd.Usage() }
+	if cmd.CustomFlags {
+		args = args[1:]
+	} else {
+		base.SetFromGOFLAGS(&cmd.Flag)
+		cmd.Flag.Parse(args[1:])
+		args = cmd.Flag.Args()
+	}
+	ctx := maybeStartTrace(context.Background())
+	ctx, span := trace.StartSpan(ctx, fmt.Sprint("Running ", cmd.Name(), " command"))
+	cmd.Run(ctx, cmd, args)
+	span.Done()
+}
+
 func init() {
 	base.Usage = mainUsage
 }
diff --git a/src/cmd/go/testdata/script/env_unset.txt b/src/cmd/go/testdata/script/env_unset.txt
new file mode 100644
index 0000000000..35fbb0a8a2
--- /dev/null
+++ b/src/cmd/go/testdata/script/env_unset.txt
@@ -0,0 +1,23 @@
+# Test that we can unset variables, even if initially invalid,
+# as long as resulting config is valid.
+
+env GOENV=badenv
+env GOOS=
+env GOARCH=
+
+! go env
+stderr '^cmd/go: unsupported GOOS/GOARCH pair bados/badarch$'
+
+! go env -u GOOS
+stderr '^go env -u: unsupported GOOS/GOARCH pair \w+/badarch$'
+
+! go env -u GOARCH
+stderr '^go env -u: unsupported GOOS/GOARCH pair bados/\w+$'
+
+go env -u GOOS GOARCH
+
+go env
+
+-- badenv --
+GOOS=bados
+GOARCH=badarch
-- 
GitLab


From 956c81bfe60306e49e26f7edd4f48cbc24c8fe28 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 16 Jun 2021 15:10:57 -0700
Subject: [PATCH 2299/2400] cmd/go: add GOEXPERIMENT to `go env` output

This CL adds GOEXPERIMENT to `go env` output, and also makes it
configurable via `GOENV`. Thanks to Baokun Lee's CL 304350 for the
test and initial work on this.

Fixes #45226.

Change-Id: Ie7f92a8a503b6a2a4df3f6598f0b2bf2915e2e7d
Reviewed-on: https://go-review.googlesource.com/c/go/+/328751
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Trust: Bryan C. Mills <bcmills@google.com>
Trust: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/go/alldocs.go                    |  6 ++++++
 src/cmd/go/internal/envcmd/env.go        |  8 ++++++++
 src/cmd/go/internal/help/helpdoc.go      |  6 ++++++
 src/cmd/go/testdata/script/env_exp.txt   | 17 +++++++++++++++++
 src/cmd/go/testdata/script/env_unset.txt |  7 +++++++
 src/cmd/go/testdata/script/env_write.txt |  6 ++++++
 6 files changed, 50 insertions(+)
 create mode 100644 src/cmd/go/testdata/script/env_exp.txt

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index fd95da23eb..90eb3e2a00 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -1903,6 +1903,12 @@
 // 	GCCGOTOOLDIR
 // 		If set, where to find gccgo tools, such as cgo.
 // 		The default is based on how gccgo was configured.
+// 	GOEXPERIMENT
+// 		Comma-separated list of toolchain experiments to enable or disable.
+// 		The list of available experiments may change arbitrarily over time.
+// 		See src/internal/goexperiment/flags.go for currently valid values.
+// 		Warning: This variable is provided for the development and testing
+// 		of the Go toolchain itself. Use beyond that purpose is unsupported.
 // 	GOROOT_FINAL
 // 		The root of the installed Go tree, when it is
 // 		installed in a location other than where it is built.
diff --git a/src/cmd/go/internal/envcmd/env.go b/src/cmd/go/internal/envcmd/env.go
index d88dcce5c0..1553d26391 100644
--- a/src/cmd/go/internal/envcmd/env.go
+++ b/src/cmd/go/internal/envcmd/env.go
@@ -73,6 +73,7 @@ func MkEnv() []cfg.EnvVar {
 		{Name: "GOCACHE", Value: cache.DefaultDir()},
 		{Name: "GOENV", Value: envFile},
 		{Name: "GOEXE", Value: cfg.ExeSuffix},
+		{Name: "GOEXPERIMENT", Value: buildcfg.GOEXPERIMENT()},
 		{Name: "GOFLAGS", Value: cfg.Getenv("GOFLAGS")},
 		{Name: "GOHOSTARCH", Value: runtime.GOARCH},
 		{Name: "GOHOSTOS", Value: runtime.GOOS},
@@ -364,6 +365,13 @@ func checkBuildConfig(add map[string]string, del map[string]bool) error {
 		}
 	}
 
+	goexperiment, okGOEXPERIMENT := get("GOEXPERIMENT", buildcfg.GOEXPERIMENT(), "")
+	if okGOEXPERIMENT {
+		if _, _, err := buildcfg.ParseGOEXPERIMENT(goos, goarch, goexperiment); err != nil {
+			return err
+		}
+	}
+
 	return nil
 }
 
diff --git a/src/cmd/go/internal/help/helpdoc.go b/src/cmd/go/internal/help/helpdoc.go
index b552777e3e..490ff1fb7c 100644
--- a/src/cmd/go/internal/help/helpdoc.go
+++ b/src/cmd/go/internal/help/helpdoc.go
@@ -610,6 +610,12 @@ Special-purpose environment variables:
 	GCCGOTOOLDIR
 		If set, where to find gccgo tools, such as cgo.
 		The default is based on how gccgo was configured.
+	GOEXPERIMENT
+		Comma-separated list of toolchain experiments to enable or disable.
+		The list of available experiments may change arbitrarily over time.
+		See src/internal/goexperiment/flags.go for currently valid values.
+		Warning: This variable is provided for the development and testing
+		of the Go toolchain itself. Use beyond that purpose is unsupported.
 	GOROOT_FINAL
 		The root of the installed Go tree, when it is
 		installed in a location other than where it is built.
diff --git a/src/cmd/go/testdata/script/env_exp.txt b/src/cmd/go/testdata/script/env_exp.txt
new file mode 100644
index 0000000000..681512d87c
--- /dev/null
+++ b/src/cmd/go/testdata/script/env_exp.txt
@@ -0,0 +1,17 @@
+# Test GOEXPERIMENT variable
+
+# go env shows default empty GOEXPERIMENT
+go env
+stdout GOEXPERIMENT=
+
+# go env shows valid experiments
+env GOEXPERIMENT=fieldtrack,staticlockranking
+go env GOEXPERIMENT
+stdout '.*fieldtrack.*staticlockranking.*'
+go env
+stdout 'GOEXPERIMENT=.*fieldtrack.*staticlockranking.*'
+
+# go env rejects unknown experiments
+env GOEXPERIMENT=bad
+! go env GOEXPERIMENT
+stderr 'unknown GOEXPERIMENT bad'
diff --git a/src/cmd/go/testdata/script/env_unset.txt b/src/cmd/go/testdata/script/env_unset.txt
index 35fbb0a8a2..4e0f249509 100644
--- a/src/cmd/go/testdata/script/env_unset.txt
+++ b/src/cmd/go/testdata/script/env_unset.txt
@@ -4,6 +4,12 @@
 env GOENV=badenv
 env GOOS=
 env GOARCH=
+env GOEXPERIMENT=
+
+! go env
+stderr '^go(\.exe)?: unknown GOEXPERIMENT badexp$'
+
+go env -u GOEXPERIMENT
 
 ! go env
 stderr '^cmd/go: unsupported GOOS/GOARCH pair bados/badarch$'
@@ -21,3 +27,4 @@ go env
 -- badenv --
 GOOS=bados
 GOARCH=badarch
+GOEXPERIMENT=badexp
diff --git a/src/cmd/go/testdata/script/env_write.txt b/src/cmd/go/testdata/script/env_write.txt
index 4fa39df104..b5e9739167 100644
--- a/src/cmd/go/testdata/script/env_write.txt
+++ b/src/cmd/go/testdata/script/env_write.txt
@@ -179,3 +179,9 @@ stderr 'unsupported GOOS/GOARCH.*windows/mips$'
 stderr 'go env -w: GOMODCACHE entry is relative; must be absolute path: "~/test"'
 ! go env -w GOMODCACHE=./test
 stderr 'go env -w: GOMODCACHE entry is relative; must be absolute path: "./test"'
+
+# go env -w checks validity of GOEXPERIMENT
+env GOEXPERIMENT=
+! go env -w GOEXPERIMENT=badexp
+stderr 'unknown GOEXPERIMENT badexp'
+go env -w GOEXPERIMENT=fieldtrack
-- 
GitLab


From 5385e2386b64b10960c1b40113ee7dae271c8369 Mon Sep 17 00:00:00 2001
From: Mia Zhu <CrystalZhu1025getu@gmail.com>
Date: Mon, 28 Jun 2021 17:10:56 +0000
Subject: [PATCH 2300/2400] runtime/internal/atomic: drop Cas64 pointer
 indirection in comments

Change-Id: Ieff0065cbd81e045594ce12e10338b0666816d70
GitHub-Last-Rev: d842f5cb3e5d75f87957c068f6accc9d4a4ac224
GitHub-Pull-Request: golang/go#46949
Reviewed-on: https://go-review.googlesource.com/c/go/+/331309
Trust: Keith Randall <khr@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/runtime/internal/atomic/atomic_amd64.s   | 2 +-
 src/runtime/internal/atomic/atomic_arm64.s   | 2 +-
 src/runtime/internal/atomic/atomic_mips64x.s | 2 +-
 src/runtime/internal/atomic/atomic_ppc64x.s  | 2 +-
 src/runtime/internal/atomic/atomic_riscv64.s | 3 ++-
 5 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/runtime/internal/atomic/atomic_amd64.s b/src/runtime/internal/atomic/atomic_amd64.s
index 57cd59dd8c..d21514b36b 100644
--- a/src/runtime/internal/atomic/atomic_amd64.s
+++ b/src/runtime/internal/atomic/atomic_amd64.s
@@ -37,7 +37,7 @@ TEXT ·Cas(SB),NOSPLIT,$0-17
 
 // bool	·Cas64(uint64 *val, uint64 old, uint64 new)
 // Atomically:
-//	if(*val == *old){
+//	if(*val == old){
 //		*val = new;
 //		return 1;
 //	} else {
diff --git a/src/runtime/internal/atomic/atomic_arm64.s b/src/runtime/internal/atomic/atomic_arm64.s
index e9467afecd..5f77d92deb 100644
--- a/src/runtime/internal/atomic/atomic_arm64.s
+++ b/src/runtime/internal/atomic/atomic_arm64.s
@@ -192,7 +192,7 @@ ok:
 
 // bool ·Cas64(uint64 *ptr, uint64 old, uint64 new)
 // Atomically:
-//      if(*val == *old){
+//      if(*val == old){
 //              *val = new;
 //              return 1;
 //      } else {
diff --git a/src/runtime/internal/atomic/atomic_mips64x.s b/src/runtime/internal/atomic/atomic_mips64x.s
index fba668f94a..fedfc4a175 100644
--- a/src/runtime/internal/atomic/atomic_mips64x.s
+++ b/src/runtime/internal/atomic/atomic_mips64x.s
@@ -37,7 +37,7 @@ cas_fail:
 
 // bool	cas64(uint64 *ptr, uint64 old, uint64 new)
 // Atomically:
-//	if(*val == *old){
+//	if(*val == old){
 //		*val = new;
 //		return 1;
 //	} else {
diff --git a/src/runtime/internal/atomic/atomic_ppc64x.s b/src/runtime/internal/atomic/atomic_ppc64x.s
index dca26cb334..226b3b6216 100644
--- a/src/runtime/internal/atomic/atomic_ppc64x.s
+++ b/src/runtime/internal/atomic/atomic_ppc64x.s
@@ -107,7 +107,7 @@ cas_fail:
 
 // bool	·Cas64(uint64 *ptr, uint64 old, uint64 new)
 // Atomically:
-//	if(*val == *old){
+//	if(*val == old){
 //		*val = new;
 //		return 1;
 //	} else {
diff --git a/src/runtime/internal/atomic/atomic_riscv64.s b/src/runtime/internal/atomic/atomic_riscv64.s
index ec05302a78..21d5adcdbc 100644
--- a/src/runtime/internal/atomic/atomic_riscv64.s
+++ b/src/runtime/internal/atomic/atomic_riscv64.s
@@ -30,8 +30,9 @@
 
 #include "textflag.h"
 
+// func Cas(ptr *uint64, old, new uint64) bool
 // Atomically:
-//      if(*val == *old){
+//      if(*val == old){
 //              *val = new;
 //              return 1;
 //      } else {
-- 
GitLab


From 1519271a939ad27da133318dc4bde7e6a41a35b5 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 25 Jun 2021 11:17:43 -0700
Subject: [PATCH 2301/2400] spec: change unsafe.Slice((*T)(nil), 0) to return
 []T(nil)

Updates #46742.

Change-Id: I044933a657cd1a5cdb29863e49751df5fe9c258a
Reviewed-on: https://go-review.googlesource.com/c/go/+/331069
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Trust: Matthew Dempsky <mdempsky@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 doc/go_spec.html     | 10 ++++++++--
 src/unsafe/unsafe.go |  5 ++++-
 2 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index b59b37fd55..e0602418e8 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1,6 +1,6 @@
 <!--{
 	"Title": "The Go Programming Language Specification",
-	"Subtitle": "Version of Jun 22, 2021",
+	"Subtitle": "Version of Jun 28, 2021",
 	"Path": "/ref/spec"
 }-->
 
@@ -6789,11 +6789,17 @@ and whose length and capacity are <code>len</code>:
 (*[len]ArbitraryType)(unsafe.Pointer(ptr))[:]
 </pre>
 
+<p>
+As a special case, if <code>ptr</code> is <code>nil</code> and <code>len</code> is zero,
+<code>Slice</code> returns <code>nil</code>.
+</p>
+
 <p>
 The <code>len</code> argument must be of integer type or an untyped <a href="#Constants">constant</a>.
 A constant <code>len</code> argument must be non-negative and <a href="#Representability">representable</a> by a value of type <code>int</code>;
 if it is an untyped constant it is given type <code>int</code>.
-If <code>ptr</code> is <code>nil</code> or <code>len</code> is negative at run time,
+At run time, if <code>len</code> is negative,
+or if <code>ptr</code> is <code>nil</code> and <code>len</code> is not zero,
 a <a href="#Run_time_panics">run-time panic</a> occurs.
 </p>
 
diff --git a/src/unsafe/unsafe.go b/src/unsafe/unsafe.go
index ecbd28c523..eaf72c9618 100644
--- a/src/unsafe/unsafe.go
+++ b/src/unsafe/unsafe.go
@@ -221,8 +221,11 @@ func Add(ptr Pointer, len IntegerType) Pointer
 //
 //	(*[len]ArbitraryType)(unsafe.Pointer(ptr))[:]
 //
+// As a special case, if ptr is nil and len is zero, Slice returns nil.
+//
 // The len argument must be of integer type or an untyped constant.
 // A constant len argument must be non-negative and representable by a value of type int;
 // if it is an untyped constant it is given type int.
-// If ptr is nil or len is negative at run time, a run-time panic occurs.
+// At run time, if len is negative, or if ptr is nil and len is not zero,
+// a run-time panic occurs.
 func Slice(ptr *ArbitraryType, len IntegerType) []ArbitraryType
-- 
GitLab


From 4bb0847b088eb3eb6122a18a87e1ca7756281dcc Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 25 Jun 2021 11:07:28 -0700
Subject: [PATCH 2302/2400] cmd/compile,runtime: change unsafe.Slice((*T)(nil),
 0) to return []T(nil)

This CL removes the unconditional OCHECKNIL check added in
walkUnsafeSlice by instead passing it as a pointer to
runtime.unsafeslice, and hiding the check behind a `len == 0` check.

While here, this CL also implements checkptr functionality for
unsafe.Slice and disallows use of unsafe.Slice with //go:notinheap
types.

Updates #46742.

Change-Id: I743a445ac124304a4d7322a7fe089c4a21b9a655
Reviewed-on: https://go-review.googlesource.com/c/go/+/331070
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/cmd/compile/internal/typecheck/builtin.go |  5 ++--
 .../internal/typecheck/builtin/runtime.go     |  5 ++--
 src/cmd/compile/internal/typecheck/func.go    |  7 +++++
 src/cmd/compile/internal/walk/builtin.go      | 26 +++++++------------
 src/runtime/checkptr.go                       | 21 ++++++++++++++-
 src/runtime/checkptr_test.go                  |  2 ++
 src/runtime/slice.go                          | 24 ++++++++++++++---
 src/runtime/testdata/testprog/checkptr.go     | 13 ++++++++++
 test/unsafebuiltins.go                        |  7 +++--
 9 files changed, 83 insertions(+), 27 deletions(-)

diff --git a/src/cmd/compile/internal/typecheck/builtin.go b/src/cmd/compile/internal/typecheck/builtin.go
index 67a894c7ed..833b17b414 100644
--- a/src/cmd/compile/internal/typecheck/builtin.go
+++ b/src/cmd/compile/internal/typecheck/builtin.go
@@ -138,6 +138,7 @@ var runtimeDecls = [...]struct {
 	{"growslice", funcTag, 116},
 	{"unsafeslice", funcTag, 117},
 	{"unsafeslice64", funcTag, 118},
+	{"unsafeslicecheckptr", funcTag, 118},
 	{"memmove", funcTag, 119},
 	{"memclrNoHeapPointers", funcTag, 120},
 	{"memclrHasPointers", funcTag, 120},
@@ -341,8 +342,8 @@ func runtimeTypes() []*types.Type {
 	typs[114] = newSig(params(typs[1], typs[15], typs[15], typs[7]), params(typs[7]))
 	typs[115] = types.NewSlice(typs[2])
 	typs[116] = newSig(params(typs[1], typs[115], typs[15]), params(typs[115]))
-	typs[117] = newSig(params(typs[1], typs[15]), nil)
-	typs[118] = newSig(params(typs[1], typs[22]), nil)
+	typs[117] = newSig(params(typs[1], typs[7], typs[15]), nil)
+	typs[118] = newSig(params(typs[1], typs[7], typs[22]), nil)
 	typs[119] = newSig(params(typs[3], typs[3], typs[5]), nil)
 	typs[120] = newSig(params(typs[7], typs[5]), nil)
 	typs[121] = newSig(params(typs[3], typs[3], typs[5]), params(typs[6]))
diff --git a/src/cmd/compile/internal/typecheck/builtin/runtime.go b/src/cmd/compile/internal/typecheck/builtin/runtime.go
index ebeaeae79e..2b29ea3c08 100644
--- a/src/cmd/compile/internal/typecheck/builtin/runtime.go
+++ b/src/cmd/compile/internal/typecheck/builtin/runtime.go
@@ -183,8 +183,9 @@ func makeslice(typ *byte, len int, cap int) unsafe.Pointer
 func makeslice64(typ *byte, len int64, cap int64) unsafe.Pointer
 func makeslicecopy(typ *byte, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointer
 func growslice(typ *byte, old []any, cap int) (ary []any)
-func unsafeslice(typ *byte, len int)
-func unsafeslice64(typ *byte, len int64)
+func unsafeslice(typ *byte, ptr unsafe.Pointer, len int)
+func unsafeslice64(typ *byte, ptr unsafe.Pointer, len int64)
+func unsafeslicecheckptr(typ *byte, ptr unsafe.Pointer, len int64)
 
 func memmove(to *any, frm *any, length uintptr)
 func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index a6dfbbf569..fbcc784627 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -1018,7 +1018,14 @@ func tcUnsafeSlice(n *ir.BinaryExpr) *ir.BinaryExpr {
 	t := n.X.Type()
 	if !t.IsPtr() {
 		base.Errorf("first argument to unsafe.Slice must be pointer; have %L", t)
+	} else if t.Elem().NotInHeap() {
+		// TODO(mdempsky): This can be relaxed, but should only affect the
+		// Go runtime itself. End users should only see //go:notinheap
+		// types due to incomplete C structs in cgo, and those types don't
+		// have a meaningful size anyway.
+		base.Errorf("unsafe.Slice of incomplete (or unallocatable) type not allowed")
 	}
+
 	if !checkunsafeslice(&n.Y) {
 		n.SetType(nil)
 		return n
diff --git a/src/cmd/compile/internal/walk/builtin.go b/src/cmd/compile/internal/walk/builtin.go
index 62eb4298f4..1f08e4d312 100644
--- a/src/cmd/compile/internal/walk/builtin.go
+++ b/src/cmd/compile/internal/walk/builtin.go
@@ -654,36 +654,28 @@ func walkRecover(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 }
 
 func walkUnsafeSlice(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
+	ptr := safeExpr(n.X, init)
 	len := safeExpr(n.Y, init)
 
 	fnname := "unsafeslice64"
-	argtype := types.Types[types.TINT64]
+	lenType := types.Types[types.TINT64]
 
 	// Type checking guarantees that TIDEAL len/cap are positive and fit in an int.
 	// The case of len or cap overflow when converting TUINT or TUINTPTR to TINT
 	// will be handled by the negative range checks in unsafeslice during runtime.
-	if len.Type().IsKind(types.TIDEAL) || len.Type().Size() <= types.Types[types.TUINT].Size() {
+	if ir.ShouldCheckPtr(ir.CurFunc, 1) {
+		fnname = "unsafeslicecheckptr"
+		// for simplicity, unsafeslicecheckptr always uses int64
+	} else if len.Type().IsKind(types.TIDEAL) || len.Type().Size() <= types.Types[types.TUINT].Size() {
 		fnname = "unsafeslice"
-		argtype = types.Types[types.TINT]
+		lenType = types.Types[types.TINT]
 	}
 
 	t := n.Type()
 
-	// Call runtime.unsafeslice[64] to check that the length argument is
-	// non-negative and smaller than the max length allowed for the
-	// element type.
+	// Call runtime.unsafeslice{,64,checkptr} to check ptr and len.
 	fn := typecheck.LookupRuntime(fnname)
-	init.Append(mkcall1(fn, nil, init, reflectdata.TypePtr(t.Elem()), typecheck.Conv(len, argtype)))
-
-	ptr := walkExpr(n.X, init)
-
-	c := ir.NewUnaryExpr(n.Pos(), ir.OCHECKNIL, ptr)
-	c.SetTypecheck(1)
-	init.Append(c)
-
-	// TODO(mdempsky): checkptr instrumentation. Maybe merge into length
-	// check above, along with nil check? Need to be careful about
-	// notinheap pointers though: can't pass them as unsafe.Pointer.
+	init.Append(mkcall1(fn, nil, init, reflectdata.TypePtr(t.Elem()), typecheck.Conv(ptr, types.Types[types.TUNSAFEPTR]), typecheck.Conv(len, lenType)))
 
 	h := ir.NewSliceHeaderExpr(n.Pos(), t,
 		typecheck.Conv(ptr, types.Types[types.TUNSAFEPTR]),
diff --git a/src/runtime/checkptr.go b/src/runtime/checkptr.go
index 59891a06a5..d42950844b 100644
--- a/src/runtime/checkptr.go
+++ b/src/runtime/checkptr.go
@@ -16,11 +16,30 @@ func checkptrAlignment(p unsafe.Pointer, elem *_type, n uintptr) {
 	}
 
 	// Check that (*[n]elem)(p) doesn't straddle multiple heap objects.
-	if size := n * elem.size; size > 1 && checkptrBase(p) != checkptrBase(add(p, size-1)) {
+	// TODO(mdempsky): Fix #46938 so we don't need to worry about overflow here.
+	if checkptrStraddles(p, n*elem.size) {
 		throw("checkptr: converted pointer straddles multiple allocations")
 	}
 }
 
+// checkptrStraddles reports whether the first size-bytes of memory
+// addressed by ptr is known to straddle more than one Go allocation.
+func checkptrStraddles(ptr unsafe.Pointer, size uintptr) bool {
+	if size <= 1 {
+		return false
+	}
+
+	end := add(ptr, size-1)
+	if uintptr(end) < uintptr(ptr) {
+		return true
+	}
+
+	// TODO(mdempsky): Detect when [ptr, end] contains Go allocations,
+	// but neither ptr nor end point into one themselves.
+
+	return checkptrBase(ptr) != checkptrBase(end)
+}
+
 func checkptrArithmetic(p unsafe.Pointer, originals []unsafe.Pointer) {
 	if 0 < uintptr(p) && uintptr(p) < minLegalPointer {
 		throw("checkptr: pointer arithmetic computed bad pointer value")
diff --git a/src/runtime/checkptr_test.go b/src/runtime/checkptr_test.go
index 194cc1243a..2a5c364e97 100644
--- a/src/runtime/checkptr_test.go
+++ b/src/runtime/checkptr_test.go
@@ -30,6 +30,8 @@ func TestCheckPtr(t *testing.T) {
 		{"CheckPtrArithmetic2", "fatal error: checkptr: pointer arithmetic result points to invalid allocation\n"},
 		{"CheckPtrSize", "fatal error: checkptr: converted pointer straddles multiple allocations\n"},
 		{"CheckPtrSmall", "fatal error: checkptr: pointer arithmetic computed bad pointer value\n"},
+		{"CheckPtrSliceOK", ""},
+		{"CheckPtrSliceFail", "fatal error: checkptr: unsafe.Slice result straddles multiple allocations\n"},
 	}
 
 	for _, tc := range testCases {
diff --git a/src/runtime/slice.go b/src/runtime/slice.go
index f9d4154acf..01cdcaeee3 100644
--- a/src/runtime/slice.go
+++ b/src/runtime/slice.go
@@ -112,19 +112,37 @@ func makeslice64(et *_type, len64, cap64 int64) unsafe.Pointer {
 	return makeslice(et, len, cap)
 }
 
-func unsafeslice(et *_type, len int) {
+func unsafeslice(et *_type, ptr unsafe.Pointer, len int) {
+	if len == 0 {
+		return
+	}
+
+	if ptr == nil {
+		panic(errorString("unsafe.Slice: ptr is nil and len is not zero"))
+	}
+
 	mem, overflow := math.MulUintptr(et.size, uintptr(len))
 	if overflow || mem > maxAlloc || len < 0 {
 		panicunsafeslicelen()
 	}
 }
 
-func unsafeslice64(et *_type, len64 int64) {
+func unsafeslice64(et *_type, ptr unsafe.Pointer, len64 int64) {
 	len := int(len64)
 	if int64(len) != len64 {
 		panicunsafeslicelen()
 	}
-	unsafeslice(et, len)
+	unsafeslice(et, ptr, len)
+}
+
+func unsafeslicecheckptr(et *_type, ptr unsafe.Pointer, len64 int64) {
+	unsafeslice64(et, ptr, len64)
+
+	// Check that underlying array doesn't straddle multiple heap objects.
+	// unsafeslice64 has already checked for overflow.
+	if checkptrStraddles(ptr, uintptr(len64)*et.size) {
+		throw("checkptr: unsafe.Slice result straddles multiple allocations")
+	}
 }
 
 func panicunsafeslicelen() {
diff --git a/src/runtime/testdata/testprog/checkptr.go b/src/runtime/testdata/testprog/checkptr.go
index e0a2794f4c..f76b64ad96 100644
--- a/src/runtime/testdata/testprog/checkptr.go
+++ b/src/runtime/testdata/testprog/checkptr.go
@@ -13,6 +13,8 @@ func init() {
 	register("CheckPtrArithmetic2", CheckPtrArithmetic2)
 	register("CheckPtrSize", CheckPtrSize)
 	register("CheckPtrSmall", CheckPtrSmall)
+	register("CheckPtrSliceOK", CheckPtrSliceOK)
+	register("CheckPtrSliceFail", CheckPtrSliceFail)
 }
 
 func CheckPtrAlignmentNoPtr() {
@@ -49,3 +51,14 @@ func CheckPtrSize() {
 func CheckPtrSmall() {
 	sink2 = unsafe.Pointer(uintptr(1))
 }
+
+func CheckPtrSliceOK() {
+	p := new([4]int64)
+	sink2 = unsafe.Slice(&p[1], 3)
+}
+
+func CheckPtrSliceFail() {
+	p := new(int64)
+	sink2 = p
+	sink2 = unsafe.Slice(p, 100)
+}
diff --git a/test/unsafebuiltins.go b/test/unsafebuiltins.go
index c10f8084a7..4c940aa855 100644
--- a/test/unsafebuiltins.go
+++ b/test/unsafebuiltins.go
@@ -30,8 +30,11 @@ func main() {
 		assert(len(s) == len(p))
 		assert(cap(s) == len(p))
 
-		// nil pointer
-		mustPanic(func() { _ = unsafe.Slice((*int)(nil), 0) })
+		// nil pointer with zero length returns nil
+		assert(unsafe.Slice((*int)(nil), 0) == nil)
+
+		// nil pointer with positive length panics
+		mustPanic(func() { _ = unsafe.Slice((*int)(nil), 1) })
 
 		// negative length
 		var neg int = -1
-- 
GitLab


From e2e05af6e189131162b533184eb04de5d597d544 Mon Sep 17 00:00:00 2001
From: eric fang <eric.fang@arm.com>
Date: Mon, 21 Jun 2021 02:11:25 +0000
Subject: [PATCH 2303/2400] cmd/internal/obj/arm64: fix an encoding error of
 CMPW instruction

For arm64 CMP, ADD and other similar extended register instructions,
if there is no extension, the default extion is LSL<<0, but the default
encoding value (the value of 'option' field) of 32-bit instruction and
64-bit instruction is different, 32-bit is 2 and 64-bit is 3. But the
current assembler incorrectly encodes the value of 32-bit instruction
to 3. This CL fixes this error.

Change-Id: I0e09af2c9c5047a4ed2db7d1183290283db9c31c
Reviewed-on: https://go-review.googlesource.com/c/go/+/329749
Reviewed-by: eric fang <eric.fang@arm.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
Run-TryBot: eric fang <eric.fang@arm.com>
Run-TryBot: Cherry Mui <cherryyz@google.com>
Trust: Dmitri Shuralyov <dmitshur@golang.org>
---
 src/cmd/asm/internal/asm/testdata/arm64.s | 3 ++-
 src/cmd/internal/obj/arm64/asm7.go        | 4 +++-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/cmd/asm/internal/asm/testdata/arm64.s b/src/cmd/asm/internal/asm/testdata/arm64.s
index 5f1e68545b..d8a20edfc1 100644
--- a/src/cmd/asm/internal/asm/testdata/arm64.s
+++ b/src/cmd/asm/internal/asm/testdata/arm64.s
@@ -89,7 +89,7 @@ TEXT	foo(SB), DUPOK|NOSPLIT, $-8
 	CMP	R1<<33, R2
 	CMP	R22.SXTX, RSP                    // ffe336eb
 	CMP	$0x22220000, RSP                 // CMP $572653568, RSP   // 5b44a4d2ff633beb
-	CMPW	$0x22220000, RSP                 // CMPW $572653568, RSP  // 5b44a452ff633b6b
+	CMPW	$0x22220000, RSP                 // CMPW $572653568, RSP  // 5b44a452ff433b6b
 	CCMN	MI, ZR, R1, $4	                 // e44341ba
 	// MADD Rn,Rm,Ra,Rd
 	MADD	R1, R2, R3, R4                   // 6408019b
@@ -377,6 +377,7 @@ TEXT	foo(SB), DUPOK|NOSPLIT, $-8
 	MOVD	$0x1000100010001000, RSP      // MOVD	$1152939097061330944, RSP   // ff8304b2
 	MOVW	$0x10001000, RSP              // MOVW	$268439552, RSP             // ff830432
 	ADDW	$0x10001000, R1               // ADDW	$268439552, R1              // fb83043221001b0b
+	ADDW	$0x22220000, RSP, R3          // ADDW	$572653568, RSP, R3         // 5b44a452e3433b0b
 
 // move a large constant to a Vd.
 	VMOVS	$0x80402010, V11                                      // VMOVS	$2151686160, V11
diff --git a/src/cmd/internal/obj/arm64/asm7.go b/src/cmd/internal/obj/arm64/asm7.go
index b8c3cd97c7..d99afa3d27 100644
--- a/src/cmd/internal/obj/arm64/asm7.go
+++ b/src/cmd/internal/obj/arm64/asm7.go
@@ -4333,8 +4333,10 @@ func (c *ctxt7) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		if p.To.Reg == REG_RSP && isADDSop(p.As) {
 			c.ctxt.Diag("illegal destination register: %v\n", p)
 		}
+		lsl0 := LSL0_64
 		if isADDWop(p.As) || isANDWop(p.As) {
 			o1 = c.omovconst(AMOVW, p, &p.From, REGTMP)
+			lsl0 = LSL0_32
 		} else {
 			o1 = c.omovconst(AMOVD, p, &p.From, REGTMP)
 		}
@@ -4350,7 +4352,7 @@ func (c *ctxt7) asmout(p *obj.Prog, o *Optab, out []uint32) {
 		if p.To.Reg == REGSP || r == REGSP {
 			o2 = c.opxrrr(p, p.As, false)
 			o2 |= REGTMP & 31 << 16
-			o2 |= LSL0_64
+			o2 |= uint32(lsl0)
 		} else {
 			o2 = c.oprrr(p, p.As)
 			o2 |= REGTMP & 31 << 16 /* shift is 0 */
-- 
GitLab


From fd4b587da3f9a2bde193a5b9fd2ba96667e08f2d Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Tue, 29 Jun 2021 10:11:31 +0700
Subject: [PATCH 2304/2400] cmd/compile: suppress details error for invalid
 variadic argument type

CL 255241 made error message involving variadic calls clearer. To do it,
we added a check that the type of variadic argument must be a slice.
That's why the compiler crashes for invalid variadic argument type.

Instead, we can just omit the details error message, and report not
enough arguments error, which matches the behavior of go/types and types2.

Fixes #46957

Change-Id: I638d7e8f031f0ee344d5d802104fd93a60aae00a
Reviewed-on: https://go-review.googlesource.com/c/go/+/331569
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/typecheck/typecheck.go | 17 ++++++++++++-----
 test/fixedbugs/issue46957.go                    | 13 +++++++++++++
 2 files changed, 25 insertions(+), 5 deletions(-)
 create mode 100644 test/fixedbugs/issue46957.go

diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index bf52941b2c..359f662369 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -1460,15 +1460,22 @@ toomany:
 }
 
 func errorDetails(nl ir.Nodes, tstruct *types.Type, isddd bool) string {
-	// If we don't know any type at a call site, let's suppress any return
-	// message signatures. See Issue https://golang.org/issues/19012.
+	// Suppress any return message signatures if:
+	//
+	// (1) We don't know any type at a call site (see #19012).
+	// (2) Any node has an unknown type.
+	// (3) Invalid type for variadic parameter (see #46957).
 	if tstruct == nil {
-		return ""
+		return "" // case 1
 	}
-	// If any node has an unknown type, suppress it as well
+
+	if isddd && !nl[len(nl)-1].Type().IsSlice() {
+		return "" // case 3
+	}
+
 	for _, n := range nl {
 		if n.Type() == nil {
-			return ""
+			return "" // case 2
 		}
 	}
 	return fmt.Sprintf("\n\thave %s\n\twant %v", fmtSignature(nl, isddd), tstruct)
diff --git a/test/fixedbugs/issue46957.go b/test/fixedbugs/issue46957.go
new file mode 100644
index 0000000000..f3ed3c3def
--- /dev/null
+++ b/test/fixedbugs/issue46957.go
@@ -0,0 +1,13 @@
+// errorcheck
+
+// Copyright 2021 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
+
+func f(a int, b ...int) {}
+
+func main() {
+	f(nil...) // ERROR "not enough arguments in call to f$"
+}
-- 
GitLab


From 3463852b7631adbdd65646539fc87d967dcd13e6 Mon Sep 17 00:00:00 2001
From: tkawakita <tommycsth61@gmail.com>
Date: Wed, 30 Jun 2021 00:46:05 +0900
Subject: [PATCH 2305/2400] math/big: fix typo of comment (`BytesScanner` to
 `ByteScanner`)

Change-Id: I0c2d26d6ede1452008992efbea7392162da65014
Reviewed-on: https://go-review.googlesource.com/c/go/+/331651
Reviewed-by: Robert Griesemer <gri@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/math/big/int.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/math/big/int.go b/src/math/big/int.go
index 65f32487b5..7647346486 100644
--- a/src/math/big/int.go
+++ b/src/math/big/int.go
@@ -425,7 +425,7 @@ func (z *Int) SetString(s string, base int) (*Int, bool) {
 	return z.setFromScanner(strings.NewReader(s), base)
 }
 
-// setFromScanner implements SetString given an io.BytesScanner.
+// setFromScanner implements SetString given an io.ByteScanner.
 // For documentation see comments of SetString.
 func (z *Int) setFromScanner(r io.ByteScanner, base int) (*Int, bool) {
 	if _, _, err := z.scan(r, base); err != nil {
-- 
GitLab


From e294b8a49e5ff157041b4ac6c3c3413dafd13673 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Levi=EF=BC=88=E3=83=AA=E3=83=BC=E3=83=90=E3=82=A4=EF=BC=89?=
 <19405788+lescoggi@users.noreply.github.com>
Date: Tue, 29 Jun 2021 12:45:52 +0000
Subject: [PATCH 2306/2400] doc/go1.17: fix typo "MacOS" -> "macOS"

Change-Id: Ie2ada2bf875a93b1cc9e86a81c8a25de39ce4752
GitHub-Last-Rev: 462753db015949eb88c6c4e64b6aae1a49ac89b4
GitHub-Pull-Request: golang/go#46962
Reviewed-on: https://go-review.googlesource.com/c/go/+/331589
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 doc/go1.17.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 22896c8c27..3551ba46c8 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -401,7 +401,7 @@ func Foo() bool {
 
 <p><!-- golang.org/issue/40724 -->
   Go 1.17 implements a new way of passing function arguments and results using
-  registers instead of the stack. This work is enabled for Linux, MacOS, and
+  registers instead of the stack. This work is enabled for Linux, macOS, and
   Windows on the 64-bit x86 architecture (the <code>linux/amd64</code>,
   <code>darwin/amd64</code>, <code>windows/amd64</code> ports). For a
   representative set of Go packages and programs, benchmarking has shown
-- 
GitLab


From f9d50953b94c15936a72a39a205b3d72ea6dee41 Mon Sep 17 00:00:00 2001
From: Xiangdong Ji <xiangdong.ji@gmail.com>
Date: Mon, 28 Jun 2021 20:27:30 +0800
Subject: [PATCH 2307/2400] net: fix failure of TestCVE202133195

TestCVE202133195 fails in testing LookupSRV if /etc/resolv.conf sets the option
'ndots' larger than the number of dots in the domain name under query.

Fix the issue by making the input domain name in test codes 'rooted' to skip search
list qualifying.

Fixes #46955

Change-Id: I1909fa7e54e9c9af57623e57cafc905729ff99fa
Reviewed-on: https://go-review.googlesource.com/c/go/+/330842
Reviewed-by: Damien Neil <dneil@google.com>
Run-TryBot: Damien Neil <dneil@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dmitri Shuralyov <dmitshur@golang.org>
---
 src/net/dnsclient_unix_test.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/net/dnsclient_unix_test.go b/src/net/dnsclient_unix_test.go
index a59be7fea0..d69107a2f2 100644
--- a/src/net/dnsclient_unix_test.go
+++ b/src/net/dnsclient_unix_test.go
@@ -1921,12 +1921,12 @@ func TestCVE202133195(t *testing.T) {
 		t.Errorf("LookupSRV returned unexpected error, got %q, want %q", err, expected)
 	}
 
-	_, _, err = r.LookupSRV(context.Background(), "hdr", "tcp", "golang.org")
-	if expected := "lookup golang.org: SRV header name is invalid"; err == nil || err.Error() != expected {
+	_, _, err = r.LookupSRV(context.Background(), "hdr", "tcp", "golang.org.")
+	if expected := "lookup golang.org.: SRV header name is invalid"; err == nil || err.Error() != expected {
 		t.Errorf("Resolver.LookupSRV returned unexpected error, got %q, want %q", err, expected)
 	}
-	_, _, err = LookupSRV("hdr", "tcp", "golang.org")
-	if expected := "lookup golang.org: SRV header name is invalid"; err == nil || err.Error() != expected {
+	_, _, err = LookupSRV("hdr", "tcp", "golang.org.")
+	if expected := "lookup golang.org.: SRV header name is invalid"; err == nil || err.Error() != expected {
 		t.Errorf("LookupSRV returned unexpected error, got %q, want %q", err, expected)
 	}
 
-- 
GitLab


From c45e800e0cb237fcedc9a3e4fd243e3a7f47334c Mon Sep 17 00:00:00 2001
From: Roland Shoemaker <roland@golang.org>
Date: Tue, 29 Jun 2021 09:20:04 -0700
Subject: [PATCH 2308/2400] crypto/x509: don't fail on optional auth key id
 fields

If a certificate contains an AuthorityKeyIdentifier extension that
lacks the keyIdentifier field, but contains the authorityCertIssuer
and/or the authorityCertSerialNumber fields, don't return an error and
continue parsing.

Fixes #46854

Change-Id: I82739b415441f639a722755cc1f449d73078adfc
Reviewed-on: https://go-review.googlesource.com/c/go/+/331689
Trust: Roland Shoemaker <roland@golang.org>
Run-TryBot: Roland Shoemaker <roland@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
---
 src/crypto/x509/parser.go    |  8 ++++---
 src/crypto/x509/x509_test.go | 42 ++++++++++++++++++++++++++++++++++++
 2 files changed, 47 insertions(+), 3 deletions(-)

diff --git a/src/crypto/x509/parser.go b/src/crypto/x509/parser.go
index 3d51ddd7f5..f085162a4e 100644
--- a/src/crypto/x509/parser.go
+++ b/src/crypto/x509/parser.go
@@ -734,10 +734,12 @@ func processExtensions(out *Certificate) error {
 				if !val.ReadASN1(&akid, cryptobyte_asn1.SEQUENCE) {
 					return errors.New("x509: invalid authority key identifier")
 				}
-				if !akid.ReadASN1(&akid, cryptobyte_asn1.Tag(0).ContextSpecific()) {
-					return errors.New("x509: invalid authority key identifier")
+				if akid.PeekASN1Tag(cryptobyte_asn1.Tag(0).ContextSpecific()) {
+					if !akid.ReadASN1(&akid, cryptobyte_asn1.Tag(0).ContextSpecific()) {
+						return errors.New("x509: invalid authority key identifier")
+					}
+					out.AuthorityKeyId = akid
 				}
-				out.AuthorityKeyId = akid
 			case 37:
 				out.ExtKeyUsage, out.UnknownExtKeyUsage, err = parseExtKeyUsageExtension(e.Value)
 				if err != nil {
diff --git a/src/crypto/x509/x509_test.go b/src/crypto/x509/x509_test.go
index 802bce0f9a..a4053abf41 100644
--- a/src/crypto/x509/x509_test.go
+++ b/src/crypto/x509/x509_test.go
@@ -3174,3 +3174,45 @@ func TestSigAlgMismatch(t *testing.T) {
 		}
 	}
 }
+
+const optionalAuthKeyIDPEM = `-----BEGIN CERTIFICATE-----
+MIIFEjCCBHugAwIBAgICAQwwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1Zh
+bGlDZXJ0IFZhbGlkYXRpb24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIElu
+Yy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENsYXNzIDIgUG9saWN5IFZhbGlkYXRpb24g
+QXV0aG9yaXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAe
+BgkqhkiG9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTA0MDYyOTE3MzkxNloX
+DTI0MDYyOTE3MzkxNlowaDELMAkGA1UEBhMCVVMxJTAjBgNVBAoTHFN0YXJmaWVs
+ZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAsTKVN0YXJmaWVsZCBDbGFzcyAy
+IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIIBIDANBgkqhkiG9w0BAQEFAAOCAQ0A
+MIIBCAKCAQEAtzLI/ulxpgSFrQwRZN/OTe/IAxiHP6Gr+zymn/DDodrU2G4rU5D7
+JKQ+hPCe6F/s5SdE9SimP3ve4CrwyK9TL57KBQGTHo9mHDmnTfpatnMEJWbrd3/n
+WcZKmSUUVOsmx/N/GdUwcI+vsEYq/63rKe3Xn6oEh6PU+YmlNF/bQ5GCNtlmPLG4
+uYL9nDo+EMg77wZlZnqbGRg9/3FRPDAuX749d3OyXQZswyNWmiuFJpIcpwKz5D8N
+rwh5grg2Peqc0zWzvGnK9cyd6P1kjReAM25eSl2ZyR6HtJ0awNVuEzUjXt+bXz3v
+1vd2wuo+u3gNHEJnawTY+Nbab4vyRKABqwIBA6OCAfMwggHvMB0GA1UdDgQWBBS/
+X7fRzt0fhvRbVazc1xDCDqmI5zCB0gYDVR0jBIHKMIHHoYHBpIG+MIG7MSQwIgYD
+VQQHExtWYWxpQ2VydCBWYWxpZGF0aW9uIE5ldHdvcmsxFzAVBgNVBAoTDlZhbGlD
+ZXJ0LCBJbmMuMTUwMwYDVQQLEyxWYWxpQ2VydCBDbGFzcyAyIFBvbGljeSBWYWxp
+ZGF0aW9uIEF1dGhvcml0eTEhMB8GA1UEAxMYaHR0cDovL3d3dy52YWxpY2VydC5j
+b20vMSAwHgYJKoZIhvcNAQkBFhFpbmZvQHZhbGljZXJ0LmNvbYIBATAPBgNVHRMB
+Af8EBTADAQH/MDkGCCsGAQUFBwEBBC0wKzApBggrBgEFBQcwAYYdaHR0cDovL29j
+c3Auc3RhcmZpZWxkdGVjaC5jb20wSgYDVR0fBEMwQTA/oD2gO4Y5aHR0cDovL2Nl
+cnRpZmljYXRlcy5zdGFyZmllbGR0ZWNoLmNvbS9yZXBvc2l0b3J5L3Jvb3QuY3Js
+MFEGA1UdIARKMEgwRgYEVR0gADA+MDwGCCsGAQUFBwIBFjBodHRwOi8vY2VydGlm
+aWNhdGVzLnN0YXJmaWVsZHRlY2guY29tL3JlcG9zaXRvcnkwDgYDVR0PAQH/BAQD
+AgEGMA0GCSqGSIb3DQEBBQUAA4GBAKVi8afCXSWlcD284ipxs33kDTcdVWptobCr
+mADkhWBKIMuh8D1195TaQ39oXCUIuNJ9MxB73HZn8bjhU3zhxoNbKXuNSm8uf0So
+GkVrMgfHeMpkksK0hAzc3S1fTbvdiuo43NlmouxBulVtWmQ9twPMHOKRUJ7jCUSV
+FxdzPcwl
+-----END CERTIFICATE-----`
+
+func TestAuthKeyIdOptional(t *testing.T) {
+	b, _ := pem.Decode([]byte(optionalAuthKeyIDPEM))
+	if b == nil {
+		t.Fatalf("couldn't decode test certificate")
+	}
+	_, err := ParseCertificate(b.Bytes)
+	if err != nil {
+		t.Fatalf("ParseCertificate to failed to parse certificate with optional authority key identifier fields: %s", err)
+	}
+}
-- 
GitLab


From d19a53338fa6272b4fe9c39d66812a79e1464cd2 Mon Sep 17 00:00:00 2001
From: Nigel Tao <nigeltao@golang.org>
Date: Tue, 29 Jun 2021 16:53:44 +1000
Subject: [PATCH 2309/2400] image: add Uniform.RGBA64At and Rectangle.RGBA64At

These types already implemented the Image interface. They should also
implement the RGBA64Image interface (new in Go 1.17)

Updates #44808

Change-Id: I9a2b13e305997088ae874efb95ad9e1648f94812
Reviewed-on: https://go-review.googlesource.com/c/go/+/331570
Trust: Nigel Tao <nigeltao@golang.org>
Run-TryBot: Nigel Tao <nigeltao@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 api/go1.17.txt          |  2 ++
 doc/go1.17.html         |  4 ++--
 src/image/geom.go       |  8 ++++++++
 src/image/image_test.go | 12 ++++++++++++
 src/image/names.go      |  5 +++++
 5 files changed, 29 insertions(+), 2 deletions(-)

diff --git a/api/go1.17.txt b/api/go1.17.txt
index c5eb381708..8e4c0f5624 100644
--- a/api/go1.17.txt
+++ b/api/go1.17.txt
@@ -47,7 +47,9 @@ pkg image, method (*Paletted) RGBA64At(int, int) color.RGBA64
 pkg image, method (*Paletted) SetRGBA64(int, int, color.RGBA64)
 pkg image, method (*RGBA) RGBA64At(int, int) color.RGBA64
 pkg image, method (*RGBA) SetRGBA64(int, int, color.RGBA64)
+pkg image, method (*Uniform) RGBA64At(int, int) color.RGBA64
 pkg image, method (*YCbCr) RGBA64At(int, int) color.RGBA64
+pkg image, method (Rectangle) RGBA64At(int, int) color.RGBA64
 pkg image, type RGBA64Image interface { At, Bounds, ColorModel, RGBA64At }
 pkg image, type RGBA64Image interface, At(int, int) color.Color
 pkg image, type RGBA64Image interface, Bounds() Rectangle
diff --git a/doc/go1.17.html b/doc/go1.17.html
index 3551ba46c8..b72752d77d 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -811,8 +811,8 @@ func Foo() bool {
     <p><!-- CL 311129 -->
       The concrete image types (<code>RGBA</code>, <code>Gray16</code> and so on)
       now implement a new <a href="/pkg/image/#RGBA64Image"><code>RGBA64Image</code></a>
-      interface. Those concrete types, other than the chroma-subsampling
-      related <code>YCbCr</code> and <code>NYCbCrA</code>, also now implement
+      interface. The concrete types that previously implemented
+      <a href="/pkg/image/draw/#Image"><code>draw.Image</code></a> now also implement
       <a href="/pkg/image/draw/#RGBA64Image"><code>draw.RGBA64Image</code></a>, a
       new interface in the <code>image/draw</code> package.
     </p>
diff --git a/src/image/geom.go b/src/image/geom.go
index 78e9e49d4f..e71aa61187 100644
--- a/src/image/geom.go
+++ b/src/image/geom.go
@@ -246,6 +246,14 @@ func (r Rectangle) At(x, y int) color.Color {
 	return color.Transparent
 }
 
+// RGBA64At implements the RGBA64Image interface.
+func (r Rectangle) RGBA64At(x, y int) color.RGBA64 {
+	if (Point{x, y}).In(r) {
+		return color.RGBA64{0xffff, 0xffff, 0xffff, 0xffff}
+	}
+	return color.RGBA64{}
+}
+
 // Bounds implements the Image interface.
 func (r Rectangle) Bounds() Rectangle {
 	return r
diff --git a/src/image/image_test.go b/src/image/image_test.go
index c64b6107b7..7f41bcb6c7 100644
--- a/src/image/image_test.go
+++ b/src/image/image_test.go
@@ -213,7 +213,9 @@ func TestRGBA64Image(t *testing.T) {
 		NewPaletted(r, palette.Plan9),
 		NewRGBA(r),
 		NewRGBA64(r),
+		NewUniform(color.RGBA64{}),
 		NewYCbCr(r, YCbCrSubsampleRatio444),
+		r,
 	}
 	for _, tc := range testCases {
 		switch tc := tc.(type) {
@@ -226,6 +228,9 @@ func TestRGBA64Image(t *testing.T) {
 		// means that setting one pixel can modify neighboring pixels. They
 		// don't have Set or SetRGBA64 methods because that side effect could
 		// be surprising. Here, we just memset the channel buffers instead.
+		//
+		// The Uniform and Rectangle types are also special-cased, as they
+		// don't have a Set or SetRGBA64 method.
 		case interface {
 			SetRGBA64(x, y int, c color.RGBA64)
 		}:
@@ -237,11 +242,18 @@ func TestRGBA64Image(t *testing.T) {
 			memset(tc.YCbCr.Cr, 0x99)
 			memset(tc.A, 0xAA)
 
+		case *Uniform:
+			tc.C = color.RGBA64{0x7FFF, 0x3FFF, 0x0000, 0x7FFF}
+
 		case *YCbCr:
 			memset(tc.Y, 0x77)
 			memset(tc.Cb, 0x88)
 			memset(tc.Cr, 0x99)
 
+		case Rectangle:
+			// No-op. Rectangle pixels' colors are immutable. They're always
+			// color.Opaque.
+
 		default:
 			t.Errorf("could not initialize pixels for %T", tc)
 			continue
diff --git a/src/image/names.go b/src/image/names.go
index 8595a35014..17b06588ac 100644
--- a/src/image/names.go
+++ b/src/image/names.go
@@ -41,6 +41,11 @@ func (c *Uniform) Bounds() Rectangle { return Rectangle{Point{-1e9, -1e9}, Point
 
 func (c *Uniform) At(x, y int) color.Color { return c.C }
 
+func (c *Uniform) RGBA64At(x, y int) color.RGBA64 {
+	r, g, b, a := c.C.RGBA()
+	return color.RGBA64{uint16(r), uint16(g), uint16(b), uint16(a)}
+}
+
 // Opaque scans the entire image and reports whether it is fully opaque.
 func (c *Uniform) Opaque() bool {
 	_, _, _, a := c.C.RGBA()
-- 
GitLab


From 0fa3265fe14c775668fc8272f47adf4fbaa60bac Mon Sep 17 00:00:00 2001
From: Eli Bendersky <eliben@golang.org>
Date: Tue, 29 Jun 2021 16:31:18 -0700
Subject: [PATCH 2310/2400] os: change example to avoid deprecated function

The IsNotExist function is deprecated; change package example to avoid
it and use the recommended way instead.

Fixes #46976

Change-Id: I3c301d0a89b6bda42184df314ba8418062ca39ee
Reviewed-on: https://go-review.googlesource.com/c/go/+/331692
Trust: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/os/example_test.go | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/os/example_test.go b/src/os/example_test.go
index 3adce51784..e8554b0b12 100644
--- a/src/os/example_test.go
+++ b/src/os/example_test.go
@@ -5,6 +5,7 @@
 package os_test
 
 import (
+	"errors"
 	"fmt"
 	"io/fs"
 	"log"
@@ -71,9 +72,9 @@ func ExampleFileMode() {
 	}
 }
 
-func ExampleIsNotExist() {
+func ExampleErrNotExist() {
 	filename := "a-nonexistent-file"
-	if _, err := os.Stat(filename); os.IsNotExist(err) {
+	if _, err := os.Stat(filename); errors.Is(err, fs.ErrNotExist) {
 		fmt.Println("file does not exist")
 	}
 	// Output:
-- 
GitLab


From 7d0e9e6e74b45cf658257363151a79baf030033f Mon Sep 17 00:00:00 2001
From: uji <ujiprog@gmail.com>
Date: Wed, 30 Jun 2021 00:06:23 +0900
Subject: [PATCH 2311/2400] image/gif: fix typo in the comment (io.ReadByte ->
 io.ByteReader)

Fixes #46967

Change-Id: I66e69c70b74e904623e8ca854562d255692b2143
Reviewed-on: https://go-review.googlesource.com/c/go/+/331649
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Carlos Amedee <carlos@golang.org>
---
 src/image/gif/reader.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/image/gif/reader.go b/src/image/gif/reader.go
index e580ab049e..9e8268c86f 100644
--- a/src/image/gif/reader.go
+++ b/src/image/gif/reader.go
@@ -116,7 +116,7 @@ type decoder struct {
 // consumed when checking that the blockReader is exhausted.
 //
 // To avoid the allocation of a bufio.Reader for the lzw Reader, blockReader
-// implements io.ReadByte and buffers blocks into the decoder's "tmp" buffer.
+// implements io.ByteReader and buffers blocks into the decoder's "tmp" buffer.
 type blockReader struct {
 	d    *decoder
 	i, j uint8 // d.tmp[i:j] contains the buffered bytes
-- 
GitLab


From c080d0323bce56e25622a51dffecf756758c95a1 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Wed, 30 Jun 2021 10:19:02 -0700
Subject: [PATCH 2312/2400] cmd/dist: pass -Wno-unknown-warning-option in
 swig_callback_lto

For #46557
Fixes #46991

Change-Id: Ic88ebaa13d3edf904657dc19ada4fd4ff7f44a8f
Reviewed-on: https://go-review.googlesource.com/c/go/+/332010
Trust: Ian Lance Taylor <iant@golang.org>
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>
---
 src/cmd/dist/test.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go
index f2c4cf0b43..4acd357974 100644
--- a/src/cmd/dist/test.go
+++ b/src/cmd/dist/test.go
@@ -737,9 +737,9 @@ func (t *tester) registerTests() {
 						fn: func(dt *distTest) error {
 							cmd := t.addCmd(dt, "misc/swig/callback", t.goTest())
 							cmd.Env = append(os.Environ(),
-								"CGO_CFLAGS=-flto -Wno-lto-type-mismatch",
-								"CGO_CXXFLAGS=-flto -Wno-lto-type-mismatch",
-								"CGO_LDFLAGS=-flto -Wno-lto-type-mismatch",
+								"CGO_CFLAGS=-flto -Wno-lto-type-mismatch -Wno-unknown-warning-option",
+								"CGO_CXXFLAGS=-flto -Wno-lto-type-mismatch -Wno-unknown-warning-option",
+								"CGO_LDFLAGS=-flto -Wno-lto-type-mismatch -Wno-unknown-warning-option",
 							)
 							return nil
 						},
-- 
GitLab


From ed56ea73e8aa60269bbb3d33af9e7614e6b3babf Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Wed, 30 Jun 2021 09:44:30 -0700
Subject: [PATCH 2313/2400] path/filepath: deflake TestEvalSymlinksAboveRoot on
 darwin

On darwin, under load, it appears that the system occasionally
deletes the temp dir mid-test. Don't fail the test when that happens.

It would be nice to fix this in a deeper way.
See golang.org/cl/332009 for some discussion.

In the meantime, this will at least stop the flakiness.

Updates #37910

Change-Id: I6669e466fed9abda4a87ca88345c04cd7986b41e
Reviewed-on: https://go-review.googlesource.com/c/go/+/332009
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/path/filepath/path_test.go | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/src/path/filepath/path_test.go b/src/path/filepath/path_test.go
index cd107b6c85..bc5509b49c 100644
--- a/src/path/filepath/path_test.go
+++ b/src/path/filepath/path_test.go
@@ -1469,11 +1469,16 @@ func TestEvalSymlinksAboveRoot(t *testing.T) {
 	// Try different numbers of "..".
 	for _, i := range []int{c, c + 1, c + 2} {
 		check := strings.Join([]string{evalTmpDir, strings.Join(dd[:i], string(os.PathSeparator)), evalTmpDir[len(vol)+1:], "b", "file"}, string(os.PathSeparator))
-		if resolved, err := filepath.EvalSymlinks(check); err != nil {
+		resolved, err := filepath.EvalSymlinks(check)
+		switch {
+		case runtime.GOOS == "darwin" && errors.Is(err, fs.ErrNotExist):
+			// On darwin, the temp dir is sometimes cleaned up mid-test (issue 37910).
+			testenv.SkipFlaky(t, 37910)
+		case err != nil:
 			t.Errorf("EvalSymlinks(%q) failed: %v", check, err)
-		} else if !strings.HasSuffix(resolved, wantSuffix) {
+		case !strings.HasSuffix(resolved, wantSuffix):
 			t.Errorf("EvalSymlinks(%q) = %q does not end with %q", check, resolved, wantSuffix)
-		} else {
+		default:
 			t.Logf("EvalSymlinks(%q) = %q", check, resolved)
 		}
 	}
-- 
GitLab


From 4711bf30e5fec4cf290964785871deba5955c29a Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Wed, 30 Jun 2021 11:54:46 -0400
Subject: [PATCH 2314/2400] doc/go1.17: linkify "language changes" in the
 runtime section

Change-Id: I82bd3954bfc5da59c7952eba2a28ff0e3b41427f
Reviewed-on: https://go-review.googlesource.com/c/go/+/331969
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 doc/go1.17.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index b72752d77d..66b4f48b61 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -993,7 +993,7 @@ func Foo() bool {
       is no longer sufficient to guarantee that a call to
       <a href="/pkg/reflect/#Value.Convert"><code>Value.Convert</code></a> will not panic.
       It may panic when converting `[]T` to `*[N]T` if the slice's length is less than N.
-      See the language changes section above.
+      See the <a href="#language">language changes</a> section above.
     </p>
   </dd>
 </dl><!-- reflect -->
-- 
GitLab


From 9d65578b83f0d52f0d2f526212dd3b4ee1a5f031 Mon Sep 17 00:00:00 2001
From: fanzha02 <fannie.zhang@arm.com>
Date: Wed, 30 Jun 2021 10:51:54 +0800
Subject: [PATCH 2315/2400] cmd/compile: fix typos in document

Correct "a2Spill" to "a3Spill"

Change-Id: I6ac4c45973dfaeb16d3a90d835589b6af1aefe1d
Reviewed-on: https://go-review.googlesource.com/c/go/+/331850
Trust: fannie zhang <Fannie.Zhang@arm.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 src/cmd/compile/abi-internal.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/abi-internal.md b/src/cmd/compile/abi-internal.md
index 1ae3c2538f..2bb4055083 100644
--- a/src/cmd/compile/abi-internal.md
+++ b/src/cmd/compile/abi-internal.md
@@ -233,7 +233,7 @@ stack frame is laid out in the following sequence:
     r1.x    uintptr
     r1.y    [2]uintptr
     a1Spill uint8
-    a2Spill uint8
+    a3Spill uint8
     _       [6]uint8  // alignment padding
 
 In the stack frame, only the `a2` field is initialized on entry; the
-- 
GitLab


From eb437ba92cbb08a86ae064cbd7376c4a8e80485b Mon Sep 17 00:00:00 2001
From: go101 <tapir.liu@gmail.com>
Date: Thu, 1 Jul 2021 14:25:45 +0000
Subject: [PATCH 2316/2400] cmd/compile: make stack value size threshold
 comparisons consistent

Consistency is beautiful.

Change-Id: Ib110dcff0ce2fa87b5576c79cd79c83aab385a7c
GitHub-Last-Rev: b8758f8ae02cb025267aa87ebc5c2f9b4c32e742
GitHub-Pull-Request: golang/go#47011
Reviewed-on: https://go-review.googlesource.com/c/go/+/332230
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/escape/escape.go | 8 ++++----
 src/cmd/compile/internal/walk/builtin.go  | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index 3ac7ff1ebe..cd56f07b61 100644
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -2013,14 +2013,14 @@ func HeapAllocReason(n ir.Node) string {
 		return "too large for stack"
 	}
 
-	if (n.Op() == ir.ONEW || n.Op() == ir.OPTRLIT) && n.Type().Elem().Width >= ir.MaxImplicitStackVarSize {
+	if (n.Op() == ir.ONEW || n.Op() == ir.OPTRLIT) && n.Type().Elem().Width > ir.MaxImplicitStackVarSize {
 		return "too large for stack"
 	}
 
-	if n.Op() == ir.OCLOSURE && typecheck.ClosureType(n.(*ir.ClosureExpr)).Size() >= ir.MaxImplicitStackVarSize {
+	if n.Op() == ir.OCLOSURE && typecheck.ClosureType(n.(*ir.ClosureExpr)).Size() > ir.MaxImplicitStackVarSize {
 		return "too large for stack"
 	}
-	if n.Op() == ir.OCALLPART && typecheck.PartialCallType(n.(*ir.SelectorExpr)).Size() >= ir.MaxImplicitStackVarSize {
+	if n.Op() == ir.OCALLPART && typecheck.PartialCallType(n.(*ir.SelectorExpr)).Size() > ir.MaxImplicitStackVarSize {
 		return "too large for stack"
 	}
 
@@ -2033,7 +2033,7 @@ func HeapAllocReason(n ir.Node) string {
 		if !ir.IsSmallIntConst(r) {
 			return "non-constant size"
 		}
-		if t := n.Type(); t.Elem().Width != 0 && ir.Int64Val(r) >= ir.MaxImplicitStackVarSize/t.Elem().Width {
+		if t := n.Type(); t.Elem().Width != 0 && ir.Int64Val(r) > ir.MaxImplicitStackVarSize/t.Elem().Width {
 			return "too large for stack"
 		}
 	}
diff --git a/src/cmd/compile/internal/walk/builtin.go b/src/cmd/compile/internal/walk/builtin.go
index 1f08e4d312..14efc05e32 100644
--- a/src/cmd/compile/internal/walk/builtin.go
+++ b/src/cmd/compile/internal/walk/builtin.go
@@ -489,7 +489,7 @@ func walkNew(n *ir.UnaryExpr, init *ir.Nodes) ir.Node {
 		base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", n.Type().Elem())
 	}
 	if n.Esc() == ir.EscNone {
-		if t.Size() >= ir.MaxImplicitStackVarSize {
+		if t.Size() > ir.MaxImplicitStackVarSize {
 			base.Fatalf("large ONEW with EscNone: %v", n)
 		}
 		return stackTempAddr(init, t)
-- 
GitLab


From 835d86a17ebf32a3cb081f66119c74363dbd8825 Mon Sep 17 00:00:00 2001
From: Yasuhiro Matsumoto <mattn.jp@gmail.com>
Date: Wed, 23 Jun 2021 01:02:33 +0900
Subject: [PATCH 2317/2400] cmd/go: use path.Dir instead of filepath.Dir for
 package paths in 'go mod vendor'

copyMetadata walk-up to parent directory until the pkg become modPath.
But pkg should be slash-separated paths. It have to use path.Dir instead of
filepath.Dir.

Fixes #46867

Change-Id: I44cf1429fe52379a7415b94cc30ae3275cc430e8
Reviewed-on: https://go-review.googlesource.com/c/go/+/330149
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Trust: Bryan C. Mills <bcmills@google.com>
Trust: Alexander Rakoczy <alex@golang.org>
Trust: Carlos Amedee <carlos@golang.org>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/internal/modcmd/vendor.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/cmd/go/internal/modcmd/vendor.go b/src/cmd/go/internal/modcmd/vendor.go
index 8e1c0432f7..713d5f9f3f 100644
--- a/src/cmd/go/internal/modcmd/vendor.go
+++ b/src/cmd/go/internal/modcmd/vendor.go
@@ -13,6 +13,7 @@ import (
 	"io"
 	"io/fs"
 	"os"
+	"path"
 	"path/filepath"
 	"sort"
 	"strings"
@@ -299,7 +300,7 @@ func copyMetadata(modPath, pkg, dst, src string, copiedFiles map[string]bool) {
 		if modPath == pkg {
 			break
 		}
-		pkg = filepath.Dir(pkg)
+		pkg = path.Dir(pkg)
 		dst = filepath.Dir(dst)
 		src = filepath.Dir(src)
 	}
-- 
GitLab


From 770899f7e11e32ee8500fc033a0aad369a6a5f7b Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Thu, 1 Jul 2021 12:32:05 -0400
Subject: [PATCH 2318/2400] cmd/go: add a regression test for 'go mod vendor'
 path traversal

For #46867

Change-Id: I1547ebf7b91e9ddd7b67fd2f20e91391d79fa35d
Reviewed-on: https://go-review.googlesource.com/c/go/+/332250
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 .../testdata/script/mod_vendor_issue46867.txt | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 src/cmd/go/testdata/script/mod_vendor_issue46867.txt

diff --git a/src/cmd/go/testdata/script/mod_vendor_issue46867.txt b/src/cmd/go/testdata/script/mod_vendor_issue46867.txt
new file mode 100644
index 0000000000..38ae87b44a
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_vendor_issue46867.txt
@@ -0,0 +1,31 @@
+# Regression test for golang.org/issue/46867:
+# 'go mod vendor' on Windows attempted to open and copy
+# files from directories outside of the module.
+
+cd subdir
+go mod vendor
+! exists vendor/example.net/NOTICE
+exists vendor/example.net/m/NOTICE
+
+-- subdir/go.mod --
+module golang.org/issue46867
+
+go 1.17
+
+replace example.net/m v0.1.0 => ./m
+
+require example.net/m v0.1.0
+-- subdir/issue.go --
+package issue
+
+import _ "example.net/m/n"
+-- subdir/m/go.mod --
+module example.net/m
+
+go 1.17
+-- subdir/m/n/n.go --
+package n
+-- subdir/m/NOTICE --
+This notice is in module m and SHOULD be vendored.
+-- subdir/NOTICE --
+This notice is outside of module m and SHOULD NOT be vendored.
-- 
GitLab


From ef8ae82b37657ab788f490bd757ad1b5592b952f Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Thu, 1 Jul 2021 11:22:02 -0400
Subject: [PATCH 2319/2400] cmd/compile: fix bug in dwarf-gen var location
 generation
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This patch fixes a bug in the SSA back end's DWARF generation code
that determines variable locations / lifetimes.

The code in question was written to handle sequences of initial
pseudo-ops (zero width instructions such as OpPhi, OpArg, etc) in a
basic block, detecting these ops at the start of a block and then
treating the values specially when emitting ranges for the variables
in those values.  The logic in this code wasn't quite correct, meaning
that a flag variable wasn't being set properly to record the presence
of a block of zero-width value-bearing ops, leading to incorrect or
missing DWARF locations for register params.

Also in this patch is a tweak to some sanity-checking code intended to
catch scheduling problems with OpArg/OpPhi etc. The checks need to
allow for the possibility of an Arg op scheduled after a spill of an
incoming register param inserted by the register allocator. Example:

    b1:
      v13 = ArgIntReg <int> {p1+16} [2] : CX
      v14 = ArgIntReg <int> {p2+16} [5] : R8
      v38 = ArgIntReg <int> {p3+16} [8] : R11
      v35 = ArgIntReg <int> {p1+0} [0] : AX
      v15 = StoreReg <int> v35 : .autotmp_4[int]
      v40  = Arg <int> {p4} [16] : p4+16[int]
      v1 = InitMem <mem>
      v3 = SB <uintptr> : SB
      v18 = CMPQ <flags> v14 v13
      NE v18 → b3 b2 (unlikely) (18)

Here the register allocator has decided to spill v35, meaning that the
OpArg v40 is no longer going to be positioned prior to all other
non-zero-width ops; this is a valid scenario and needs to be handled
properly by the debug code.

Fixes #46425.

Change-Id: I239b3ad56a9c1b8ebf68af42e1f57308293ed7e6
Reviewed-on: https://go-review.googlesource.com/c/go/+/332269
Trust: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/ssa/debug.go | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/debug.go b/src/cmd/compile/internal/ssa/debug.go
index eaa94975ec..8e2872363b 100644
--- a/src/cmd/compile/internal/ssa/debug.go
+++ b/src/cmd/compile/internal/ssa/debug.go
@@ -1115,8 +1115,14 @@ func (state *debugState) buildLocationLists(blockLocs []*BlockDebug) {
 			continue
 		}
 
+		mustBeFirst := func(v *Value) bool {
+			return v.Op == OpPhi || v.Op.isLoweredGetClosurePtr() ||
+				v.Op == OpArgIntReg || v.Op == OpArgFloatReg
+		}
+
 		zeroWidthPending := false
-		apcChangedSize := 0 // size of changedVars for leading Args, Phi, ClosurePtr
+		blockPrologComplete := false // set to true at first non-zero-width op
+		apcChangedSize := 0          // size of changedVars for leading Args, Phi, ClosurePtr
 		// expect to see values in pattern (apc)* (zerowidth|real)*
 		for _, v := range b.Values {
 			slots := state.valueNames[v.ID]
@@ -1125,16 +1131,16 @@ func (state *debugState) buildLocationLists(blockLocs []*BlockDebug) {
 
 			if opcodeTable[v.Op].zeroWidth {
 				if changed {
-					if hasAnyArgOp(v) || v.Op == OpPhi || v.Op.isLoweredGetClosurePtr() {
+					if mustBeFirst(v) || v.Op == OpArg {
 						// These ranges begin at true beginning of block, not after first instruction
-						if zeroWidthPending {
-							panic(fmt.Errorf("Unexpected op '%s' mixed with OpArg/OpPhi/OpLoweredGetClosurePtr at beginning of block %s in %s\n%s", v.LongString(), b, b.Func.Name, b.Func))
+						if blockPrologComplete && mustBeFirst(v) {
+							panic(fmt.Errorf("Unexpected placement of op '%s' appearing after non-pseudo-op at beginning of block %s in %s\n%s", v.LongString(), b, b.Func.Name, b.Func))
 						}
 						apcChangedSize = len(state.changedVars.contents())
+						// Other zero-width ops must wait on a "real" op.
+						zeroWidthPending = true
 						continue
 					}
-					// Other zero-width ops must wait on a "real" op.
-					zeroWidthPending = true
 				}
 				continue
 			}
@@ -1145,6 +1151,7 @@ func (state *debugState) buildLocationLists(blockLocs []*BlockDebug) {
 			// Not zero-width; i.e., a "real" instruction.
 
 			zeroWidthPending = false
+			blockPrologComplete = true
 			for i, varID := range state.changedVars.contents() {
 				if i < apcChangedSize { // buffered true start-of-block changes
 					state.updateVar(VarID(varID), v.Block, BlockStart)
-- 
GitLab


From 877688c838c35c48f8c658891ead6c381e21f6fa Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 10 Jun 2021 15:17:17 -0400
Subject: [PATCH 2320/2400] testing: add TB.Setenv

For #41260 and #46688.

Change-Id: I6f42742cc3234a90003136ae8798a6b0e1291788
Reviewed-on: https://go-review.googlesource.com/c/go/+/326790
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 api/go1.17.txt         | 1 +
 src/testing/testing.go | 1 +
 2 files changed, 2 insertions(+)

diff --git a/api/go1.17.txt b/api/go1.17.txt
index 8e4c0f5624..3d0a464fec 100644
--- a/api/go1.17.txt
+++ b/api/go1.17.txt
@@ -181,6 +181,7 @@ pkg syscall (windows-amd64), type SysProcAttr struct, AdditionalInheritedHandles
 pkg syscall (windows-amd64), type SysProcAttr struct, ParentProcess Handle
 pkg testing, method (*B) Setenv(string, string)
 pkg testing, method (*T) Setenv(string, string)
+pkg testing, type TB interface, Setenv(string, string)
 pkg text/template/parse, const SkipFuncCheck = 2
 pkg text/template/parse, const SkipFuncCheck Mode
 pkg time, const Layout = "01/02 03:04:05PM '06 -0700"
diff --git a/src/testing/testing.go b/src/testing/testing.go
index fdf57a3953..eeee0aac17 100644
--- a/src/testing/testing.go
+++ b/src/testing/testing.go
@@ -644,6 +644,7 @@ type TB interface {
 	Log(args ...interface{})
 	Logf(format string, args ...interface{})
 	Name() string
+	Setenv(key, value string)
 	Skip(args ...interface{})
 	SkipNow()
 	Skipf(format string, args ...interface{})
-- 
GitLab


From 03761ede028d811dd7d7cf8a2690d4bfa2771d85 Mon Sep 17 00:00:00 2001
From: Roland Shoemaker <roland@golang.org>
Date: Wed, 30 Jun 2021 14:28:18 -0700
Subject: [PATCH 2321/2400] net: don't reject null mx records

Bypass hostname validity checking when a null mx record is returned as,
defined in RFC 7505.

Updates #46979

Change-Id: Ibe683bd6b47333a8ff30909fb2680ec8e10696ef
Reviewed-on: https://go-review.googlesource.com/c/go/+/332094
Trust: Roland Shoemaker <roland@golang.org>
Trust: Katie Hockman <katie@golang.org>
Run-TryBot: Roland Shoemaker <roland@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
---
 src/net/dnsclient_unix_test.go | 40 ++++++++++++++++++++++++++++++++++
 src/net/lookup.go              |  4 +++-
 2 files changed, 43 insertions(+), 1 deletion(-)

diff --git a/src/net/dnsclient_unix_test.go b/src/net/dnsclient_unix_test.go
index d69107a2f2..59cdd2bf3e 100644
--- a/src/net/dnsclient_unix_test.go
+++ b/src/net/dnsclient_unix_test.go
@@ -1957,3 +1957,43 @@ func TestCVE202133195(t *testing.T) {
 		t.Errorf("LookupAddr returned unexpected error, got %q, want %q", err, expected)
 	}
 }
+
+func TestNullMX(t *testing.T) {
+	fake := fakeDNSServer{
+		rh: func(n, _ string, q dnsmessage.Message, _ time.Time) (dnsmessage.Message, error) {
+			r := dnsmessage.Message{
+				Header: dnsmessage.Header{
+					ID:       q.Header.ID,
+					Response: true,
+					RCode:    dnsmessage.RCodeSuccess,
+				},
+				Questions: q.Questions,
+				Answers: []dnsmessage.Resource{
+					{
+						Header: dnsmessage.ResourceHeader{
+							Name:  q.Questions[0].Name,
+							Type:  dnsmessage.TypeMX,
+							Class: dnsmessage.ClassINET,
+						},
+						Body: &dnsmessage.MXResource{
+							MX: dnsmessage.MustNewName("."),
+						},
+					},
+				},
+			}
+			return r, nil
+		},
+	}
+	r := Resolver{PreferGo: true, Dial: fake.DialContext}
+	rrset, err := r.LookupMX(context.Background(), "golang.org")
+	if err != nil {
+		t.Fatalf("LookupMX: %v", err)
+	}
+	if want := []*MX{&MX{Host: "."}}; !reflect.DeepEqual(rrset, want) {
+		records := []string{}
+		for _, rr := range rrset {
+			records = append(records, fmt.Sprintf("%v", rr))
+		}
+		t.Errorf("records = [%v]; want [%v]", strings.Join(records, " "), want[0])
+	}
+}
diff --git a/src/net/lookup.go b/src/net/lookup.go
index 02a4cdcd1e..b5af3a0f86 100644
--- a/src/net/lookup.go
+++ b/src/net/lookup.go
@@ -500,7 +500,9 @@ func (r *Resolver) LookupMX(ctx context.Context, name string) ([]*MX, error) {
 		if mx == nil {
 			continue
 		}
-		if !isDomainName(mx.Host) {
+		// Bypass the hostname validity check for targets which contain only a dot,
+		// as this is used to represent a 'Null' MX record.
+		if mx.Host != "." && !isDomainName(mx.Host) {
 			return nil, &DNSError{Err: "MX target is invalid", Name: name}
 		}
 	}
-- 
GitLab


From 6125d0c4265067cdb67af1340bf689975dd128f4 Mon Sep 17 00:00:00 2001
From: komisan19 <komiyama6219@gmail.com>
Date: Fri, 2 Jul 2021 05:41:10 +0000
Subject: [PATCH 2322/2400] cmd/dist: correct comment: SysProcAttri ->
 SysProcAttr

Fixes #46982

Change-Id: I07a18507b7aad828714b187f296fa7268f32b1c4
GitHub-Last-Rev: f498febffdae0bc93ae1794d1ee62b2ef3ecf1bb
GitHub-Pull-Request: golang/go#46983
Reviewed-on: https://go-review.googlesource.com/c/go/+/331869
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/dist/test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go
index 4acd357974..f40fa926df 100644
--- a/src/cmd/dist/test.go
+++ b/src/cmd/dist/test.go
@@ -781,7 +781,7 @@ func (t *tester) registerTests() {
 			t.registerTest("testasan", "../misc/cgo/testasan", "go", "run", ".")
 		}
 		if goos == "linux" && goarch != "ppc64le" {
-			// because syscall.SysProcAttri struct used in misc/cgo/testsanitizers is only built on linux.
+			// because syscall.SysProcAttr struct used in misc/cgo/testsanitizers is only built on linux.
 			// Some inconsistent failures happen on ppc64le so disable for now.
 			t.registerHostTest("testsanitizers", "../misc/cgo/testsanitizers", "misc/cgo/testsanitizers", ".")
 		}
-- 
GitLab


From 743f03eeb0bdcb596b46fae51d23c0fcf0db0474 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Thu, 1 Jul 2021 16:52:59 -0700
Subject: [PATCH 2323/2400] spec, unsafe: clarify unsafe.Slice docs

For #19367

Change-Id: If0ff8ddba3b6b48e2e198cf3653e73284c7572a3
Reviewed-on: https://go-review.googlesource.com/c/go/+/332409
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 doc/go_spec.html     | 8 +++++---
 src/unsafe/unsafe.go | 6 ++++--
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index e0602418e8..ad21ffb1b8 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1,6 +1,6 @@
 <!--{
 	"Title": "The Go Programming Language Specification",
-	"Subtitle": "Version of Jun 28, 2021",
+	"Subtitle": "Version of Jul 1, 2021",
 	"Path": "/ref/spec"
 }-->
 
@@ -6782,7 +6782,8 @@ The rules for <a href="/pkg/unsafe#Pointer">valid uses</a> of <code>Pointer</cod
 
 <p>
 The function <code>Slice</code> returns a slice whose underlying array starts at <code>ptr</code>
-and whose length and capacity are <code>len</code>:
+and whose length and capacity are <code>len</code>.
+<code>Slice(ptr, len)</code> is equivalent to
 </p>
 
 <pre>
@@ -6790,7 +6791,8 @@ and whose length and capacity are <code>len</code>:
 </pre>
 
 <p>
-As a special case, if <code>ptr</code> is <code>nil</code> and <code>len</code> is zero,
+except that, as a special case, if <code>ptr</code>
+is <code>nil</code> and <code>len</code> is zero,
 <code>Slice</code> returns <code>nil</code>.
 </p>
 
diff --git a/src/unsafe/unsafe.go b/src/unsafe/unsafe.go
index eaf72c9618..16e3890d0b 100644
--- a/src/unsafe/unsafe.go
+++ b/src/unsafe/unsafe.go
@@ -217,11 +217,13 @@ func Alignof(x ArbitraryType) uintptr
 func Add(ptr Pointer, len IntegerType) Pointer
 
 // The function Slice returns a slice whose underlying array starts at ptr
-// and whose length and capacity are len:
+// and whose length and capacity are len.
+// Slice(ptr, len) is equivalent to
 //
 //	(*[len]ArbitraryType)(unsafe.Pointer(ptr))[:]
 //
-// As a special case, if ptr is nil and len is zero, Slice returns nil.
+// except that, as a special case, if ptr is nil and len is zero,
+// Slice returns nil.
 //
 // The len argument must be of integer type or an untyped constant.
 // A constant len argument must be non-negative and representable by a value of type int;
-- 
GitLab


From 287c5e8066396e953254d7980a80ec082edf11bd Mon Sep 17 00:00:00 2001
From: go101 <tapir.liu@gmail.com>
Date: Fri, 2 Jul 2021 08:01:20 +0000
Subject: [PATCH 2324/2400] cmd/compile: fix stack growing algorithm

The current stack growing implementation looks not right.
Specially, the line runtime/stack.go#L1068 never gets executed,
which causes many unnecessary copystack calls.

This PR is trying to correct the implementation.
As I'm not familiar with the code, the fix is just a guess.

Change-Id: I0bea1148175fad34f74f19d455c240c94d3cb78b
GitHub-Last-Rev: 57205f91fe6f7cecbf0b7aad0d90d2f81270b1e8
GitHub-Pull-Request: golang/go#47010
Reviewed-on: https://go-review.googlesource.com/c/go/+/332229
Reviewed-by: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dmitri Shuralyov <dmitshur@golang.org>
---
 src/runtime/stack.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/runtime/stack.go b/src/runtime/stack.go
index b21c9c9518..6e0d157630 100644
--- a/src/runtime/stack.go
+++ b/src/runtime/stack.go
@@ -1064,7 +1064,9 @@ func newstack() {
 	// recheck the bounds on return.)
 	if f := findfunc(gp.sched.pc); f.valid() {
 		max := uintptr(funcMaxSPDelta(f))
-		for newsize-gp.sched.sp < max+_StackGuard {
+		needed := max + _StackGuard
+		used := gp.stack.hi - gp.sched.sp
+		for newsize-used < needed {
 			newsize *= 2
 		}
 	}
-- 
GitLab


From 912f0750472dd4f674b69ca1616bfaf377af1805 Mon Sep 17 00:00:00 2001
From: Sean Liao <seankhliao@gmail.com>
Date: Tue, 8 Jun 2021 20:13:23 +0200
Subject: [PATCH 2325/2400] net/http: mention socks5 support in proxy

Change-Id: I55b6d5c77221569eeafea625379affd476a65772
Reviewed-on: https://go-review.googlesource.com/c/go/+/326011
Reviewed-by: Damien Neil <dneil@google.com>
Trust: Dmitri Shuralyov <dmitshur@golang.org>
---
 src/net/http/transport.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/net/http/transport.go b/src/net/http/transport.go
index 47cb992a50..309194e8e5 100644
--- a/src/net/http/transport.go
+++ b/src/net/http/transport.go
@@ -427,6 +427,7 @@ func (t *Transport) onceSetNextProtoDefaults() {
 //
 // The environment values may be either a complete URL or a
 // "host[:port]", in which case the "http" scheme is assumed.
+// The schemes "http", "https", and "socks5" are supported.
 // An error is returned if the value is a different form.
 //
 // A nil URL and nil error are returned if no proxy is defined in the
-- 
GitLab


From c96833e5badedb025761de6a74ed5f9c848059de Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Wed, 7 Jul 2021 14:58:36 +0000
Subject: [PATCH 2326/2400] doc: remove stale comment about arm64 port

Fixes #47079.

Change-Id: I8a671e3fdc13083e44e8d89064a5e7621e53bc4c
Reviewed-on: https://go-review.googlesource.com/c/go/+/333075
Trust: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Keith Randall <khr@golang.org>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 doc/asm.html | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/doc/asm.html b/doc/asm.html
index 7173d9bd51..d578800086 100644
--- a/doc/asm.html
+++ b/doc/asm.html
@@ -827,10 +827,6 @@ The other codes are <code>-&gt;</code> (arithmetic right shift),
 
 <h3 id="arm64">ARM64</h3>
 
-<p>
-The ARM64 port is in an experimental state.
-</p>
-
 <p>
 <code>R18</code> is the "platform register", reserved on the Apple platform.
 To prevent accidental misuse, the register is named <code>R18_PLATFORM</code>.
-- 
GitLab


From f264879f74efc8b9a9bcf4e04df0f8f5affa11a9 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 2 Jul 2021 14:00:49 -0400
Subject: [PATCH 2327/2400] cmd/go/internal/modload: fix an apparent typo in
 the AutoRoot comment

Updates #40276

Change-Id: Ic192d51f9f0306e5c206c550ef02f6d4495d0851
Reviewed-on: https://go-review.googlesource.com/c/go/+/332569
Trust: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modload/init.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index cbc7289afa..09136b7de1 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -71,7 +71,7 @@ type Root int
 const (
 	// AutoRoot is the default for most commands. modload.Init will look for
 	// a go.mod file in the current directory or any parent. If none is found,
-	// modules may be disabled (GO111MODULE=on) or commands may run in a
+	// modules may be disabled (GO111MODULE=auto) or commands may run in a
 	// limited module mode.
 	AutoRoot Root = iota
 
-- 
GitLab


From 00c00558e1513d4f110f0b778242c965e7f6505a Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 2 Jul 2021 11:27:37 -0400
Subject: [PATCH 2328/2400] cmd/go/internal/modload: remove unused functions

Also unexport functions that are not used outside the modload package.

Change-Id: I0de187cbb673cadafce95a27f5ccff934ae21104
Reviewed-on: https://go-review.googlesource.com/c/go/+/332570
Trust: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modload/load.go  | 37 ----------------------------
 src/cmd/go/internal/modload/query.go |  4 +--
 2 files changed, 2 insertions(+), 39 deletions(-)

diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index a3a8021c04..771b142b73 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -675,20 +675,6 @@ func DirImportPath(ctx context.Context, dir string) string {
 	return "."
 }
 
-// TargetPackages returns the list of packages in the target (top-level) module
-// matching pattern, which may be relative to the working directory, under all
-// build tag settings.
-func TargetPackages(ctx context.Context, pattern string) *search.Match {
-	// TargetPackages is relative to the main module, so ensure that the main
-	// module is a thing that can contain packages.
-	LoadModFile(ctx) // Sets Target.
-	ModRoot()        // Emits an error if Target cannot contain packages.
-
-	m := search.NewMatch(pattern)
-	matchPackages(ctx, m, imports.AnyTags(), omitStd, []module.Version{Target})
-	return m
-}
-
 // ImportMap returns the actual package import path
 // for an import path found in source code.
 // If the given import path does not appear in the source code
@@ -720,29 +706,6 @@ func PackageModule(path string) module.Version {
 	return pkg.mod
 }
 
-// PackageImports returns the imports for the package named by the import path.
-// Test imports will be returned as well if tests were loaded for the package
-// (i.e., if "all" was loaded or if LoadTests was set and the path was matched
-// by a command line argument). PackageImports will return nil for
-// unknown package paths.
-func PackageImports(path string) (imports, testImports []string) {
-	pkg, ok := loaded.pkgCache.Get(path).(*loadPkg)
-	if !ok {
-		return nil, nil
-	}
-	imports = make([]string, len(pkg.imports))
-	for i, p := range pkg.imports {
-		imports[i] = p.path
-	}
-	if pkg.test != nil {
-		testImports = make([]string, len(pkg.test.imports))
-		for i, p := range pkg.test.imports {
-			testImports[i] = p.path
-		}
-	}
-	return imports, testImports
-}
-
 // Lookup returns the source directory, import path, and any loading error for
 // the package at path as imported from the package in parentDir.
 // Lookup requires that one of the Load functions in this package has already
diff --git a/src/cmd/go/internal/modload/query.go b/src/cmd/go/internal/modload/query.go
index 6f6c6e8c98..dda9004a9f 100644
--- a/src/cmd/go/internal/modload/query.go
+++ b/src/cmd/go/internal/modload/query.go
@@ -920,8 +920,8 @@ func (e *PackageNotInModuleError) ImportPath() string {
 	return ""
 }
 
-// ModuleHasRootPackage returns whether module m contains a package m.Path.
-func ModuleHasRootPackage(ctx context.Context, m module.Version) (bool, error) {
+// moduleHasRootPackage returns whether module m contains a package m.Path.
+func moduleHasRootPackage(ctx context.Context, m module.Version) (bool, error) {
 	needSum := false
 	root, isLocal, err := fetch(ctx, m, needSum)
 	if err != nil {
-- 
GitLab


From 186a3bb4b0939837c855a4f0689d4a4401aff608 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 25 Jun 2021 12:49:51 -0400
Subject: [PATCH 2329/2400] cmd/go/internal/modfetch/codehost: skip hg tests if
 no hg binary is present

Change-Id: I5cf57bf1153eb662bcab71e3d2c04848212559a6
Reviewed-on: https://go-review.googlesource.com/c/go/+/330989
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 .../go/internal/modfetch/codehost/git_test.go | 49 +++++++++----------
 1 file changed, 23 insertions(+), 26 deletions(-)

diff --git a/src/cmd/go/internal/modfetch/codehost/git_test.go b/src/cmd/go/internal/modfetch/codehost/git_test.go
index 89a73baad9..a684fa1a9b 100644
--- a/src/cmd/go/internal/modfetch/codehost/git_test.go
+++ b/src/cmd/go/internal/modfetch/codehost/git_test.go
@@ -8,7 +8,6 @@ import (
 	"archive/zip"
 	"bytes"
 	"flag"
-	"fmt"
 	"internal/testenv"
 	"io"
 	"io/fs"
@@ -47,12 +46,6 @@ var altRepos = []string{
 var localGitRepo string
 
 func testMain(m *testing.M) int {
-	if _, err := exec.LookPath("git"); err != nil {
-		fmt.Fprintln(os.Stderr, "skipping because git binary not found")
-		fmt.Println("PASS")
-		return 0
-	}
-
 	dir, err := os.MkdirTemp("", "gitrepo-test-")
 	if err != nil {
 		log.Fatal(err)
@@ -60,23 +53,25 @@ func testMain(m *testing.M) int {
 	defer os.RemoveAll(dir)
 
 	if testenv.HasExternalNetwork() && testenv.HasExec() {
-		// Clone gitrepo1 into a local directory.
-		// If we use a file:// URL to access the local directory,
-		// then git starts up all the usual protocol machinery,
-		// which will let us test remote git archive invocations.
-		localGitRepo = filepath.Join(dir, "gitrepo2")
-		if _, err := Run("", "git", "clone", "--mirror", gitrepo1, localGitRepo); err != nil {
-			log.Fatal(err)
-		}
-		if _, err := Run(localGitRepo, "git", "config", "daemon.uploadarch", "true"); err != nil {
-			log.Fatal(err)
+		if _, err := exec.LookPath("git"); err == nil {
+			// Clone gitrepo1 into a local directory.
+			// If we use a file:// URL to access the local directory,
+			// then git starts up all the usual protocol machinery,
+			// which will let us test remote git archive invocations.
+			localGitRepo = filepath.Join(dir, "gitrepo2")
+			if _, err := Run("", "git", "clone", "--mirror", gitrepo1, localGitRepo); err != nil {
+				log.Fatal(err)
+			}
+			if _, err := Run(localGitRepo, "git", "config", "daemon.uploadarch", "true"); err != nil {
+				log.Fatal(err)
+			}
 		}
 	}
 
 	return m.Run()
 }
 
-func testRepo(remote string) (Repo, error) {
+func testRepo(t *testing.T, remote string) (Repo, error) {
 	if remote == "localGitRepo" {
 		// Convert absolute path to file URL. LocalGitRepo will not accept
 		// Windows absolute paths because they look like a host:path remote.
@@ -87,15 +82,17 @@ func testRepo(remote string) (Repo, error) {
 		} else {
 			url = "file:///" + filepath.ToSlash(localGitRepo)
 		}
+		testenv.MustHaveExecPath(t, "git")
 		return LocalGitRepo(url)
 	}
-	kind := "git"
+	vcs := "git"
 	for _, k := range []string{"hg"} {
 		if strings.Contains(remote, "/"+k+"/") {
-			kind = k
+			vcs = k
 		}
 	}
-	return NewRepo(kind, remote)
+	testenv.MustHaveExecPath(t, vcs)
+	return NewRepo(vcs, remote)
 }
 
 var tagsTests = []struct {
@@ -116,7 +113,7 @@ func TestTags(t *testing.T) {
 
 	for _, tt := range tagsTests {
 		f := func(t *testing.T) {
-			r, err := testRepo(tt.repo)
+			r, err := testRepo(t, tt.repo)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -168,7 +165,7 @@ func TestLatest(t *testing.T) {
 
 	for _, tt := range latestTests {
 		f := func(t *testing.T) {
-			r, err := testRepo(tt.repo)
+			r, err := testRepo(t, tt.repo)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -221,7 +218,7 @@ func TestReadFile(t *testing.T) {
 
 	for _, tt := range readFileTests {
 		f := func(t *testing.T) {
-			r, err := testRepo(tt.repo)
+			r, err := testRepo(t, tt.repo)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -412,7 +409,7 @@ func TestReadZip(t *testing.T) {
 
 	for _, tt := range readZipTests {
 		f := func(t *testing.T) {
-			r, err := testRepo(tt.repo)
+			r, err := testRepo(t, tt.repo)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -581,7 +578,7 @@ func TestStat(t *testing.T) {
 
 	for _, tt := range statTests {
 		f := func(t *testing.T) {
-			r, err := testRepo(tt.repo)
+			r, err := testRepo(t, tt.repo)
 			if err != nil {
 				t.Fatal(err)
 			}
-- 
GitLab


From 991fd381d52e7cec37ab54732613d3e465916206 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Tue, 6 Jul 2021 10:38:18 -0700
Subject: [PATCH 2330/2400] cmd/go: don't lock .mod and .sum files for read in
 overlay

On Plan 9, locking a file requires a chmod call. In general, the go
command should not modify files in the overlay, even metadata. With
this change, we won't lock these files for reading.

The go command already reported errors when attempting to write these
files if they were in the overlay, but this change moves those checks
to the point of access for clearer error
messages. cmd/go/internal/lockedfile no longer imports
cmd/go/internal/fsys.

Fixes #44700

Change-Id: Ib544459dd6cf56ca0f7a27b3285f045f08040d7e
Reviewed-on: https://go-review.googlesource.com/c/go/+/333012
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 .../internal/lockedfile/lockedfile_filelock.go |  3 +--
 .../go/internal/lockedfile/lockedfile_plan9.go |  6 ++----
 src/cmd/go/internal/modfetch/fetch.go          | 17 ++++++++++++++++-
 src/cmd/go/internal/modload/init.go            | 18 +++++++++++++++++-
 src/cmd/go/internal/modload/modfile.go         | 14 ++++++++++++--
 src/cmd/go/testdata/script/mod_overlay.txt     | 10 +++++-----
 6 files changed, 53 insertions(+), 15 deletions(-)

diff --git a/src/cmd/go/internal/lockedfile/lockedfile_filelock.go b/src/cmd/go/internal/lockedfile/lockedfile_filelock.go
index 729df5c681..e4923f6876 100644
--- a/src/cmd/go/internal/lockedfile/lockedfile_filelock.go
+++ b/src/cmd/go/internal/lockedfile/lockedfile_filelock.go
@@ -11,7 +11,6 @@ import (
 	"io/fs"
 	"os"
 
-	"cmd/go/internal/fsys"
 	"cmd/go/internal/lockedfile/internal/filelock"
 )
 
@@ -21,7 +20,7 @@ func openFile(name string, flag int, perm fs.FileMode) (*os.File, error) {
 	// calls for Linux and Windows anyway, so it's simpler to use that approach
 	// consistently.
 
-	f, err := fsys.OpenFile(name, flag&^os.O_TRUNC, perm)
+	f, err := os.OpenFile(name, flag&^os.O_TRUNC, perm)
 	if err != nil {
 		return nil, err
 	}
diff --git a/src/cmd/go/internal/lockedfile/lockedfile_plan9.go b/src/cmd/go/internal/lockedfile/lockedfile_plan9.go
index 3d4b97d78e..979118b10a 100644
--- a/src/cmd/go/internal/lockedfile/lockedfile_plan9.go
+++ b/src/cmd/go/internal/lockedfile/lockedfile_plan9.go
@@ -13,8 +13,6 @@ import (
 	"os"
 	"strings"
 	"time"
-
-	"cmd/go/internal/fsys"
 )
 
 // Opening an exclusive-use file returns an error.
@@ -59,7 +57,7 @@ func openFile(name string, flag int, perm fs.FileMode) (*os.File, error) {
 	// If the file was unpacked or created by some other program, it might not
 	// have the ModeExclusive bit set. Set it before we call OpenFile, so that we
 	// can be confident that a successful OpenFile implies exclusive use.
-	if fi, err := fsys.Stat(name); err == nil {
+	if fi, err := os.Stat(name); err == nil {
 		if fi.Mode()&fs.ModeExclusive == 0 {
 			if err := os.Chmod(name, fi.Mode()|fs.ModeExclusive); err != nil {
 				return nil, err
@@ -72,7 +70,7 @@ func openFile(name string, flag int, perm fs.FileMode) (*os.File, error) {
 	nextSleep := 1 * time.Millisecond
 	const maxSleep = 500 * time.Millisecond
 	for {
-		f, err := fsys.OpenFile(name, flag, perm|fs.ModeExclusive)
+		f, err := os.OpenFile(name, flag, perm|fs.ModeExclusive)
 		if err == nil {
 			return f, nil
 		}
diff --git a/src/cmd/go/internal/modfetch/fetch.go b/src/cmd/go/internal/modfetch/fetch.go
index e40593abae..d3d30d970b 100644
--- a/src/cmd/go/internal/modfetch/fetch.go
+++ b/src/cmd/go/internal/modfetch/fetch.go
@@ -22,6 +22,7 @@ import (
 
 	"cmd/go/internal/base"
 	"cmd/go/internal/cfg"
+	"cmd/go/internal/fsys"
 	"cmd/go/internal/lockedfile"
 	"cmd/go/internal/par"
 	"cmd/go/internal/robustio"
@@ -416,7 +417,18 @@ func initGoSum() (bool, error) {
 
 	goSum.m = make(map[module.Version][]string)
 	goSum.status = make(map[modSum]modSumStatus)
-	data, err := lockedfile.Read(GoSumFile)
+	var (
+		data []byte
+		err  error
+	)
+	if actualSumFile, ok := fsys.OverlayPath(GoSumFile); ok {
+		// Don't lock go.sum if it's part of the overlay.
+		// On Plan 9, locking requires chmod, and we don't want to modify any file
+		// in the overlay. See #44700.
+		data, err = os.ReadFile(actualSumFile)
+	} else {
+		data, err = lockedfile.Read(GoSumFile)
+	}
 	if err != nil && !os.IsNotExist(err) {
 		return false, err
 	}
@@ -716,6 +728,9 @@ Outer:
 	if cfg.BuildMod == "readonly" {
 		base.Fatalf("go: updates to go.sum needed, disabled by -mod=readonly")
 	}
+	if _, ok := fsys.OverlayPath(GoSumFile); ok {
+		base.Fatalf("go: updates to go.sum needed, but go.sum is part of the overlay specified with -overlay")
+	}
 
 	// Make a best-effort attempt to acquire the side lock, only to exclude
 	// previous versions of the 'go' command from making simultaneous edits.
diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index 09136b7de1..a8cbd9fe16 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -412,7 +412,16 @@ func loadModFile(ctx context.Context) (rs *Requirements, needCommit bool) {
 	}
 
 	gomod := ModFilePath()
-	data, err := lockedfile.Read(gomod)
+	var data []byte
+	var err error
+	if gomodActual, ok := fsys.OverlayPath(gomod); ok {
+		// Don't lock go.mod if it's part of the overlay.
+		// On Plan 9, locking requires chmod, and we don't want to modify any file
+		// in the overlay. See #44700.
+		data, err = os.ReadFile(gomodActual)
+	} else {
+		data, err = lockedfile.Read(gomodActual)
+	}
 	if err != nil {
 		base.Fatalf("go: %v", err)
 	}
@@ -1026,6 +1035,13 @@ func commitRequirements(ctx context.Context, goVersion string, rs *Requirements)
 		}
 		return
 	}
+	gomod := ModFilePath()
+	if _, ok := fsys.OverlayPath(gomod); ok {
+		if dirty {
+			base.Fatalf("go: updates to go.mod needed, but go.mod is part of the overlay specified with -overlay")
+		}
+		return
+	}
 
 	new, err := modFile.Format()
 	if err != nil {
diff --git a/src/cmd/go/internal/modload/modfile.go b/src/cmd/go/internal/modload/modfile.go
index 1145ac4ba5..d280945ea6 100644
--- a/src/cmd/go/internal/modload/modfile.go
+++ b/src/cmd/go/internal/modload/modfile.go
@@ -8,6 +8,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"os"
 	"path/filepath"
 	"strings"
 	"sync"
@@ -15,6 +16,7 @@ import (
 
 	"cmd/go/internal/base"
 	"cmd/go/internal/cfg"
+	"cmd/go/internal/fsys"
 	"cmd/go/internal/lockedfile"
 	"cmd/go/internal/modfetch"
 	"cmd/go/internal/par"
@@ -601,8 +603,16 @@ func rawGoModSummary(m module.Version) (*modFileSummary, error) {
 				dir = filepath.Join(ModRoot(), dir)
 			}
 			gomod := filepath.Join(dir, "go.mod")
-
-			data, err := lockedfile.Read(gomod)
+			var data []byte
+			var err error
+			if gomodActual, ok := fsys.OverlayPath(gomod); ok {
+				// Don't lock go.mod if it's part of the overlay.
+				// On Plan 9, locking requires chmod, and we don't want to modify any file
+				// in the overlay. See #44700.
+				data, err = os.ReadFile(gomodActual)
+			} else {
+				data, err = lockedfile.Read(gomodActual)
+			}
 			if err != nil {
 				return cached{nil, module.VersionError(m, fmt.Errorf("reading %s: %v", base.ShortPath(gomod), err))}
 			}
diff --git a/src/cmd/go/testdata/script/mod_overlay.txt b/src/cmd/go/testdata/script/mod_overlay.txt
index 92e79c725a..86ab04bd3c 100644
--- a/src/cmd/go/testdata/script/mod_overlay.txt
+++ b/src/cmd/go/testdata/script/mod_overlay.txt
@@ -21,7 +21,7 @@ go list -deps -overlay overlay.json .
 cd $WORK/gopath/src/get-doesnt-add-dep
 cp $WORK/overlay/get_doesnt_add_dep_go_mod $WORK/want_go_mod
 ! go get -d -overlay overlay.json .
-stderr 'overlaid files can''t be opened for write'
+stderr '^go: updates to go.mod needed, but go.mod is part of the overlay specified with -overlay$'
 cmp $WORK/overlay/get_doesnt_add_dep_go_mod $WORK/want_go_mod
 
 # Content of overlaid go.sum is used.
@@ -41,10 +41,10 @@ go mod verify -overlay overlay.json
 # attempting to update the file
 cp incomplete-sum-file $WORK/overlay/overlay-sum-used-correct-sums
 ! go get -d -overlay overlay.json .
-stderr 'overlaid files can''t be opened for write'
+stderr '^go: updates to go.sum needed, but go.sum is part of the overlay specified with -overlay$'
 cmp incomplete-sum-file $WORK/overlay/overlay-sum-used-correct-sums
 ! go mod tidy -overlay overlay.json
-stderr 'overlaid files can''t be opened for write'
+stderr '^go: updates to go.sum needed, but go.sum is part of the overlay specified with -overlay$'
 cmp incomplete-sum-file $WORK/overlay/overlay-sum-used-correct-sums
 
 # -overlay works with -modfile.
@@ -56,7 +56,7 @@ go list -modfile=alternate.mod -overlay overlay.json .
 stdout 'found.the/module'
 # Even with -modfile, overlaid files can't be opened for write.
 ! go get -modfile=alternate.mod -overlay overlay.json -d rsc.io/quote
-stderr 'overlaid files can''t be opened for write'
+stderr '^go: updates to go.mod needed, but go.mod is part of the overlay specified with -overlay$'
 
 # Carving out a module by adding an overlaid go.mod file
 cd $WORK/gopath/src/carve
@@ -78,7 +78,7 @@ go list -overlay overlay.json all
 stdout ^carve2/nomod$
 # Editing go.mod file fails because overlay is read only
 ! go get -overlay overlay.json -d rsc.io/quote
-stderr 'overlaid files can''t be opened for write'
+stderr '^go: updates to go.mod needed, but go.mod is part of the overlay specified with -overlay$'
 ! grep rsc.io/quote $WORK/overlay/carve2-nomod-go.mod
 # Editing go.mod file succeeds because we use -modfile to redirect to same file
 go get -overlay overlay.json -modfile $WORK/overlay/carve2-nomod-go.mod -d rsc.io/quote
-- 
GitLab


From 11f5df2d6703b3fbd61a256e4e32ba67d835e7ad Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 7 Jul 2021 12:11:37 -0700
Subject: [PATCH 2331/2400] cmd/compile: extract pkgqual from symfmt

The logic in symfmt for deciding how to package-qualify an identifier
is easily refactored into a separate function, loosely similar to
go/types.Qualifier's API.

Passes toolstash -cmp.

Updates #47087.

Change-Id: Ib3e7cc35a6577dc28df8eca79ba3457c48168e86
Reviewed-on: https://go-review.googlesource.com/c/go/+/333161
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/types/fmt.go | 43 +++++++++++++--------------
 1 file changed, 20 insertions(+), 23 deletions(-)

diff --git a/src/cmd/compile/internal/types/fmt.go b/src/cmd/compile/internal/types/fmt.go
index b538ea8054..0ce423dae7 100644
--- a/src/cmd/compile/internal/types/fmt.go
+++ b/src/cmd/compile/internal/types/fmt.go
@@ -137,47 +137,44 @@ func sconv2(b *bytes.Buffer, s *Sym, verb rune, mode fmtMode) {
 }
 
 func symfmt(b *bytes.Buffer, s *Sym, verb rune, mode fmtMode) {
+	if q := pkgqual(s.Pkg, verb, mode); q != "" {
+		b.WriteString(q)
+		b.WriteByte('.')
+	}
+	b.WriteString(s.Name)
+}
+
+// pkgqual returns the qualifier that should be used for printing
+// symbols from the given package in the given mode.
+// If it returns the empty string, no qualification is needed.
+func pkgqual(pkg *Pkg, verb rune, mode fmtMode) string {
 	if verb != 'S' {
 		switch mode {
 		case fmtGo: // This is for the user
-			if s.Pkg == BuiltinPkg || s.Pkg == LocalPkg {
-				b.WriteString(s.Name)
-				return
+			if pkg == BuiltinPkg || pkg == LocalPkg {
+				return ""
 			}
 
 			// If the name was used by multiple packages, display the full path,
-			if s.Pkg.Name != "" && NumImport[s.Pkg.Name] > 1 {
-				fmt.Fprintf(b, "%q.%s", s.Pkg.Path, s.Name)
-				return
+			if pkg.Name != "" && NumImport[pkg.Name] > 1 {
+				return strconv.Quote(pkg.Path)
 			}
-			b.WriteString(s.Pkg.Name)
-			b.WriteByte('.')
-			b.WriteString(s.Name)
-			return
+			return pkg.Name
 
 		case fmtDebug:
-			b.WriteString(s.Pkg.Name)
-			b.WriteByte('.')
-			b.WriteString(s.Name)
-			return
+			return pkg.Name
 
 		case fmtTypeIDName:
 			// dcommontype, typehash
-			b.WriteString(s.Pkg.Name)
-			b.WriteByte('.')
-			b.WriteString(s.Name)
-			return
+			return pkg.Name
 
 		case fmtTypeID:
 			// (methodsym), typesym, weaksym
-			b.WriteString(s.Pkg.Prefix)
-			b.WriteByte('.')
-			b.WriteString(s.Name)
-			return
+			return pkg.Prefix
 		}
 	}
 
-	b.WriteString(s.Name)
+	return ""
 }
 
 // Type
-- 
GitLab


From b003a8b1ae26fa684ec35eb7543efa1ded1bcae7 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 7 Jul 2021 12:33:40 -0700
Subject: [PATCH 2332/2400] cmd/compile: optimize types.sconv

Now that symfmt is simpler, we can simply manually inline it into
sconv. Importantly, this allows us to avoid allocating a buffer +
writing a string + re-interning it when we don't need to qualify the
identifier.

Passes toolstash -cmp.

Updates #47087.

Change-Id: I47b57aef22301ba242556a645346f478f0c1a7d1
Reviewed-on: https://go-review.googlesource.com/c/go/+/333162
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/types/fmt.go | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/types/fmt.go b/src/cmd/compile/internal/types/fmt.go
index 0ce423dae7..7b284aa661 100644
--- a/src/cmd/compile/internal/types/fmt.go
+++ b/src/cmd/compile/internal/types/fmt.go
@@ -112,11 +112,19 @@ func sconv(s *Sym, verb rune, mode fmtMode) string {
 	if s.Name == "_" {
 		return "_"
 	}
+
+	q := pkgqual(s.Pkg, verb, mode)
+	if q == "" {
+		return s.Name
+	}
+
 	buf := fmtBufferPool.Get().(*bytes.Buffer)
 	buf.Reset()
 	defer fmtBufferPool.Put(buf)
 
-	symfmt(buf, s, verb, mode)
+	buf.WriteString(q)
+	buf.WriteByte('.')
+	buf.WriteString(s.Name)
 	return InternString(buf.Bytes())
 }
 
-- 
GitLab


From 5c59e11f5e1fe2e6d5b684f9a348022c07807126 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 7 Jul 2021 13:18:42 -0700
Subject: [PATCH 2333/2400] cmd/compile: remove special-casing of blank in
 types.sconv{,2}

I'm not sure why blank was special-cased here before, but it's
wrong. Blank is a non-exported identifier, and writing it out without
package-qualification can result in linker symbol collisions.

Fixes #47087.

Change-Id: Ie600037c8e54e3d4fdaeec21e2ca212badbd830b
Reviewed-on: https://go-review.googlesource.com/c/go/+/333163
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/types/fmt.go |  8 --------
 test/fixedbugs/issue47087.dir/a.go    |  9 +++++++++
 test/fixedbugs/issue47087.dir/b.go    |  9 +++++++++
 test/fixedbugs/issue47087.dir/main.go | 19 +++++++++++++++++++
 test/fixedbugs/issue47087.go          |  7 +++++++
 5 files changed, 44 insertions(+), 8 deletions(-)
 create mode 100644 test/fixedbugs/issue47087.dir/a.go
 create mode 100644 test/fixedbugs/issue47087.dir/b.go
 create mode 100644 test/fixedbugs/issue47087.dir/main.go
 create mode 100644 test/fixedbugs/issue47087.go

diff --git a/src/cmd/compile/internal/types/fmt.go b/src/cmd/compile/internal/types/fmt.go
index 7b284aa661..8b988952a7 100644
--- a/src/cmd/compile/internal/types/fmt.go
+++ b/src/cmd/compile/internal/types/fmt.go
@@ -109,10 +109,6 @@ func sconv(s *Sym, verb rune, mode fmtMode) string {
 		return "<S>"
 	}
 
-	if s.Name == "_" {
-		return "_"
-	}
-
 	q := pkgqual(s.Pkg, verb, mode)
 	if q == "" {
 		return s.Name
@@ -136,10 +132,6 @@ func sconv2(b *bytes.Buffer, s *Sym, verb rune, mode fmtMode) {
 		b.WriteString("<S>")
 		return
 	}
-	if s.Name == "_" {
-		b.WriteString("_")
-		return
-	}
 
 	symfmt(b, s, verb, mode)
 }
diff --git a/test/fixedbugs/issue47087.dir/a.go b/test/fixedbugs/issue47087.dir/a.go
new file mode 100644
index 0000000000..6093092ace
--- /dev/null
+++ b/test/fixedbugs/issue47087.dir/a.go
@@ -0,0 +1,9 @@
+// Copyright 2021 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 a
+
+func F() interface{} { return struct{ _ []int }{} }
+
+var X = F()
diff --git a/test/fixedbugs/issue47087.dir/b.go b/test/fixedbugs/issue47087.dir/b.go
new file mode 100644
index 0000000000..8f96d25a12
--- /dev/null
+++ b/test/fixedbugs/issue47087.dir/b.go
@@ -0,0 +1,9 @@
+// Copyright 2021 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 b
+
+func F() interface{} { return struct{ _ []int }{} }
+
+var X = F()
diff --git a/test/fixedbugs/issue47087.dir/main.go b/test/fixedbugs/issue47087.dir/main.go
new file mode 100644
index 0000000000..ccd0891a61
--- /dev/null
+++ b/test/fixedbugs/issue47087.dir/main.go
@@ -0,0 +1,19 @@
+// Copyright 2021 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 (
+	"a"
+	"b"
+)
+
+func main() {
+	if a.F() == b.F() {
+		panic("FAIL")
+	}
+	if a.X == b.X {
+		panic("FAIL")
+	}
+}
diff --git a/test/fixedbugs/issue47087.go b/test/fixedbugs/issue47087.go
new file mode 100644
index 0000000000..40df49f83b
--- /dev/null
+++ b/test/fixedbugs/issue47087.go
@@ -0,0 +1,7 @@
+// rundir
+
+// Copyright 2021 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 ignored
-- 
GitLab


From 2ca44fe2213b53ccaf6f555c11858c6e36490624 Mon Sep 17 00:00:00 2001
From: Tobias Klauser <tklauser@distanz.ch>
Date: Mon, 5 Jul 2021 10:35:53 +0200
Subject: [PATCH 2334/2400] doc/go1.17: linkify time.UnixMilli and
 time.UnixMicro

Change-Id: I8503c4649fc42670f13d981f98af480467d6a3e8
Reviewed-on: https://go-review.googlesource.com/c/go/+/332829
Trust: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 doc/go1.17.html | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 66b4f48b61..4fa30158bb 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -1132,10 +1132,13 @@ func Foo() bool {
 
     <p><!-- CL 293349 -->
       The new <a href="/pkg/time/#Time.UnixMilli"><code>Time.UnixMilli</code></a> and
-      <a href="/pkg/time/#Time.UnixMicro"><code>Time.UnixMicro</code></a> methods return the number of milliseconds and
-      microseconds elapsed since January 1, 1970 UTC respectively.<br>
-      The new <code>UnixMilli</code> and <code>UnixMicro</code> functions return local Time corresponding to given
-      Unix time.
+      <a href="/pkg/time/#Time.UnixMicro"><code>Time.UnixMicro</code></a>
+      methods return the number of milliseconds and microseconds elapsed since
+      January 1, 1970 UTC respectively.
+      <br />
+      The new <a href="/pkg/time/#UnixMilli"><code>UnixMilli</code></a> and
+      <a href="/pkg/time/#UnixMicro"><code>UnixMicro</code></a> functions
+      return the local <code>Time</code> corresponding to the given Unix time.
     </p>
 
     <p><!-- CL 300996 -->
-- 
GitLab


From ce76298ee7b2cc237b015f798abbfe891a6f5463 Mon Sep 17 00:00:00 2001
From: makdon <makdon@makdon.me>
Date: Mon, 17 May 2021 16:27:11 +0000
Subject: [PATCH 2335/2400] Update oudated comment

Update comment cause gc/select.go has been moved to walk/select.go and gc/reflect.go has been moved to reflectdata/reflect.go

Change-Id: I6894527e1e9dbca50ace92a51bf942f9495ce88c
GitHub-Last-Rev: 6d6a4471440403218b68ba32d4038ca41eae2901
GitHub-Pull-Request: golang/go#45976
Reviewed-on: https://go-review.googlesource.com/c/go/+/317191
Reviewed-by: Keith Randall <khr@golang.org>
Trust: Michael Pratt <mpratt@google.com>
---
 src/cmd/compile/internal/reflectdata/reflect.go |  2 +-
 src/cmd/link/internal/ld/decodesym.go           |  4 ++--
 src/internal/reflectlite/type.go                |  4 ++--
 src/reflect/type.go                             | 10 +++++-----
 src/runtime/runtime2.go                         |  4 ++--
 src/runtime/select.go                           |  2 +-
 src/runtime/type.go                             |  6 +++---
 7 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index e07294be0f..eb9a8a6c9b 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -669,7 +669,7 @@ var kinds = []int{
 // tflag is documented in reflect/type.go.
 //
 // tflag values must be kept in sync with copies in:
-//	cmd/compile/internal/gc/reflect.go
+//	cmd/compile/internal/reflectdata/reflect.go
 //	cmd/link/internal/ld/decodesym.go
 //	reflect/type.go
 //	runtime/type.go
diff --git a/src/cmd/link/internal/ld/decodesym.go b/src/cmd/link/internal/ld/decodesym.go
index c41d97706e..629bdcf4ca 100644
--- a/src/cmd/link/internal/ld/decodesym.go
+++ b/src/cmd/link/internal/ld/decodesym.go
@@ -16,12 +16,12 @@ import (
 
 // Decoding the type.* symbols.	 This has to be in sync with
 // ../../runtime/type.go, or more specifically, with what
-// cmd/compile/internal/gc/reflect.go stuffs in these.
+// cmd/compile/internal/reflectdata/reflect.go stuffs in these.
 
 // tflag is documented in reflect/type.go.
 //
 // tflag values must be kept in sync with copies in:
-//	cmd/compile/internal/gc/reflect.go
+//	cmd/compile/internal/reflectdata/reflect.go
 //	cmd/link/internal/ld/decodesym.go
 //	reflect/type.go
 //	runtime/type.go
diff --git a/src/internal/reflectlite/type.go b/src/internal/reflectlite/type.go
index f529f7c5fc..b1899b0191 100644
--- a/src/internal/reflectlite/type.go
+++ b/src/internal/reflectlite/type.go
@@ -68,7 +68,7 @@ type Type interface {
 }
 
 /*
- * These data structures are known to the compiler (../../cmd/internal/gc/reflect.go).
+ * These data structures are known to the compiler (../../cmd/internal/reflectdata/reflect.go).
  * A few are known to ../runtime/type.go to convey to debuggers.
  * They are also known to ../runtime/type.go.
  */
@@ -111,7 +111,7 @@ const (
 // available in the memory directly following the rtype value.
 //
 // tflag values must be kept in sync with copies in:
-//	cmd/compile/internal/gc/reflect.go
+//	cmd/compile/internal/reflectdata/reflect.go
 //	cmd/link/internal/ld/decodesym.go
 //	runtime/type.go
 type tflag uint8
diff --git a/src/reflect/type.go b/src/reflect/type.go
index df863ae106..f672a7a5d5 100644
--- a/src/reflect/type.go
+++ b/src/reflect/type.go
@@ -228,7 +228,7 @@ type Type interface {
 // See https://golang.org/issue/4876 for more details.
 
 /*
- * These data structures are known to the compiler (../../cmd/internal/gc/reflect.go).
+ * These data structures are known to the compiler (../../cmd/internal/reflectdata/reflect.go).
  * A few are known to ../runtime/type.go to convey to debuggers.
  * They are also known to ../runtime/type.go.
  */
@@ -271,7 +271,7 @@ const (
 // available in the memory directly following the rtype value.
 //
 // tflag values must be kept in sync with copies in:
-//	cmd/compile/internal/gc/reflect.go
+//	cmd/compile/internal/reflectdata/reflect.go
 //	cmd/link/internal/ld/decodesym.go
 //	runtime/type.go
 type tflag uint8
@@ -1910,7 +1910,7 @@ func MapOf(key, elem Type) Type {
 
 	// Make a map type.
 	// Note: flag values must match those used in the TMAP case
-	// in ../cmd/compile/internal/gc/reflect.go:writeType.
+	// in ../cmd/compile/internal/reflectdata/reflect.go:writeType.
 	var imap interface{} = (map[unsafe.Pointer]unsafe.Pointer)(nil)
 	mt := **(**mapType)(unsafe.Pointer(&imap))
 	mt.str = resolveReflectName(newName(s, "", false))
@@ -2841,7 +2841,7 @@ func runtimeStructField(field StructField) (structField, string) {
 
 // typeptrdata returns the length in bytes of the prefix of t
 // containing pointer data. Anything after this offset is scalar data.
-// keep in sync with ../cmd/compile/internal/gc/reflect.go
+// keep in sync with ../cmd/compile/internal/reflectdata/reflect.go
 func typeptrdata(t *rtype) uintptr {
 	switch t.Kind() {
 	case Struct:
@@ -2865,7 +2865,7 @@ func typeptrdata(t *rtype) uintptr {
 	}
 }
 
-// See cmd/compile/internal/gc/reflect.go for derivation of constant.
+// See cmd/compile/internal/reflectdata/reflect.go for derivation of constant.
 const maxPtrmaskBytes = 2048
 
 // ArrayOf returns the array type with the given length and element type.
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index 0e0eb0b728..2a66826f34 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -895,7 +895,7 @@ type funcinl struct {
 // layout of Itab known to compilers
 // allocated in non-garbage-collected memory
 // Needs to be in sync with
-// ../cmd/compile/internal/gc/reflect.go:/^func.WriteTabs.
+// ../cmd/compile/internal/reflectdata/reflect.go:/^func.WriteTabs.
 type itab struct {
 	inter *interfacetype
 	_type *_type
@@ -940,7 +940,7 @@ func extendRandom(r []byte, n int) {
 
 // A _defer holds an entry on the list of deferred calls.
 // If you add a field here, add code to clear it in freedefer and deferProcStack
-// This struct must match the code in cmd/compile/internal/gc/reflect.go:deferstruct
+// This struct must match the code in cmd/compile/internal/reflectdata/reflect.go:deferstruct
 // and cmd/compile/internal/gc/ssa.go:(*state).call.
 // Some defers will be allocated on the stack and some on the heap.
 // All defers are logically part of the stack, so write barriers to
diff --git a/src/runtime/select.go b/src/runtime/select.go
index e72761bfa9..06edb69f42 100644
--- a/src/runtime/select.go
+++ b/src/runtime/select.go
@@ -15,7 +15,7 @@ const debugSelect = false
 
 // Select case descriptor.
 // Known to compiler.
-// Changes here must also be made in src/cmd/internal/gc/select.go's scasetype.
+// Changes here must also be made in src/cmd/compile/internal/walk/select.go's scasetype.
 type scase struct {
 	c    *hchan         // chan
 	elem unsafe.Pointer // data element
diff --git a/src/runtime/type.go b/src/runtime/type.go
index 335fc57f4b..4039273695 100644
--- a/src/runtime/type.go
+++ b/src/runtime/type.go
@@ -11,7 +11,7 @@ import "unsafe"
 // tflag is documented in reflect/type.go.
 //
 // tflag values must be kept in sync with copies in:
-//	cmd/compile/internal/gc/reflect.go
+//	cmd/compile/internal/reflectdata/reflect.go
 //	cmd/link/internal/ld/decodesym.go
 //	reflect/type.go
 //      internal/reflectlite/type.go
@@ -25,7 +25,7 @@ const (
 )
 
 // Needs to be in sync with ../cmd/link/internal/ld/decodesym.go:/^func.commonsize,
-// ../cmd/compile/internal/gc/reflect.go:/^func.dcommontype and
+// ../cmd/compile/internal/reflectdata/reflect.go:/^func.dcommontype and
 // ../reflect/type.go:/^type.rtype.
 // ../internal/reflectlite/type.go:/^type.rtype.
 type _type struct {
@@ -383,7 +383,7 @@ type maptype struct {
 }
 
 // Note: flag values must match those used in the TMAP case
-// in ../cmd/compile/internal/gc/reflect.go:writeType.
+// in ../cmd/compile/internal/reflectdata/reflect.go:writeType.
 func (mt *maptype) indirectkey() bool { // store ptr to key instead of key itself
 	return mt.flags&1 != 0
 }
-- 
GitLab


From 296ddf2a936a30866303a64d49bc0e3e034730a8 Mon Sep 17 00:00:00 2001
From: Roland Shoemaker <roland@golang.org>
Date: Fri, 2 Jul 2021 10:25:49 -0700
Subject: [PATCH 2336/2400] net: filter bad names from Lookup functions instead
 of hard failing

Instead of hard failing on a single bad record, filter the bad records
and return anything valid. This only applies to the methods which can
return multiple records, LookupMX, LookupNS, LookupSRV, and LookupAddr.

When bad results are filtered out, also return an error, indicating
that this filtering has happened.

Updates #46241
Fixes #46979

Change-Id: I6493e0002beaf89f5a9795333a93605abd30d171
Reviewed-on: https://go-review.googlesource.com/c/go/+/332549
Trust: Roland Shoemaker <roland@golang.org>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
---
 src/net/dnsclient_unix_test.go | 222 +++++++++++++++++++++++++--------
 src/net/lookup.go              |  74 ++++++++---
 2 files changed, 229 insertions(+), 67 deletions(-)

diff --git a/src/net/dnsclient_unix_test.go b/src/net/dnsclient_unix_test.go
index 59cdd2bf3e..350ad5def7 100644
--- a/src/net/dnsclient_unix_test.go
+++ b/src/net/dnsclient_unix_test.go
@@ -1846,6 +1846,17 @@ func TestCVE202133195(t *testing.T) {
 							Target: dnsmessage.MustNewName("<html>.golang.org."),
 						},
 					},
+					dnsmessage.Resource{
+						Header: dnsmessage.ResourceHeader{
+							Name:   n,
+							Type:   dnsmessage.TypeSRV,
+							Class:  dnsmessage.ClassINET,
+							Length: 4,
+						},
+						Body: &dnsmessage.SRVResource{
+							Target: dnsmessage.MustNewName("good.golang.org."),
+						},
+					},
 				)
 			case dnsmessage.TypeMX:
 				r.Answers = append(r.Answers,
@@ -1860,6 +1871,17 @@ func TestCVE202133195(t *testing.T) {
 							MX: dnsmessage.MustNewName("<html>.golang.org."),
 						},
 					},
+					dnsmessage.Resource{
+						Header: dnsmessage.ResourceHeader{
+							Name:   dnsmessage.MustNewName("good.golang.org."),
+							Type:   dnsmessage.TypeMX,
+							Class:  dnsmessage.ClassINET,
+							Length: 4,
+						},
+						Body: &dnsmessage.MXResource{
+							MX: dnsmessage.MustNewName("good.golang.org."),
+						},
+					},
 				)
 			case dnsmessage.TypeNS:
 				r.Answers = append(r.Answers,
@@ -1874,6 +1896,17 @@ func TestCVE202133195(t *testing.T) {
 							NS: dnsmessage.MustNewName("<html>.golang.org."),
 						},
 					},
+					dnsmessage.Resource{
+						Header: dnsmessage.ResourceHeader{
+							Name:   dnsmessage.MustNewName("good.golang.org."),
+							Type:   dnsmessage.TypeNS,
+							Class:  dnsmessage.ClassINET,
+							Length: 4,
+						},
+						Body: &dnsmessage.NSResource{
+							NS: dnsmessage.MustNewName("good.golang.org."),
+						},
+					},
 				)
 			case dnsmessage.TypePTR:
 				r.Answers = append(r.Answers,
@@ -1888,6 +1921,17 @@ func TestCVE202133195(t *testing.T) {
 							PTR: dnsmessage.MustNewName("<html>.golang.org."),
 						},
 					},
+					dnsmessage.Resource{
+						Header: dnsmessage.ResourceHeader{
+							Name:   dnsmessage.MustNewName("good.golang.org."),
+							Type:   dnsmessage.TypePTR,
+							Class:  dnsmessage.ClassINET,
+							Length: 4,
+						},
+						Body: &dnsmessage.PTRResource{
+							PTR: dnsmessage.MustNewName("good.golang.org."),
+						},
+					},
 				)
 			}
 			return r, nil
@@ -1903,59 +1947,139 @@ func TestCVE202133195(t *testing.T) {
 	defer func(orig string) { testHookHostsPath = orig }(testHookHostsPath)
 	testHookHostsPath = "testdata/hosts"
 
-	_, err := r.LookupCNAME(context.Background(), "golang.org")
-	if expected := "lookup golang.org: CNAME target is invalid"; err == nil || err.Error() != expected {
-		t.Errorf("Resolver.LookupCNAME returned unexpected error, got %q, want %q", err, expected)
-	}
-	_, err = LookupCNAME("golang.org")
-	if expected := "lookup golang.org: CNAME target is invalid"; err == nil || err.Error() != expected {
-		t.Errorf("LookupCNAME returned unexpected error, got %q, want %q", err, expected)
-	}
-
-	_, _, err = r.LookupSRV(context.Background(), "target", "tcp", "golang.org")
-	if expected := "lookup golang.org: SRV target is invalid"; err == nil || err.Error() != expected {
-		t.Errorf("Resolver.LookupSRV returned unexpected error, got %q, want %q", err, expected)
-	}
-	_, _, err = LookupSRV("target", "tcp", "golang.org")
-	if expected := "lookup golang.org: SRV target is invalid"; err == nil || err.Error() != expected {
-		t.Errorf("LookupSRV returned unexpected error, got %q, want %q", err, expected)
-	}
-
-	_, _, err = r.LookupSRV(context.Background(), "hdr", "tcp", "golang.org.")
-	if expected := "lookup golang.org.: SRV header name is invalid"; err == nil || err.Error() != expected {
-		t.Errorf("Resolver.LookupSRV returned unexpected error, got %q, want %q", err, expected)
-	}
-	_, _, err = LookupSRV("hdr", "tcp", "golang.org.")
-	if expected := "lookup golang.org.: SRV header name is invalid"; err == nil || err.Error() != expected {
-		t.Errorf("LookupSRV returned unexpected error, got %q, want %q", err, expected)
-	}
-
-	_, err = r.LookupMX(context.Background(), "golang.org")
-	if expected := "lookup golang.org: MX target is invalid"; err == nil || err.Error() != expected {
-		t.Errorf("Resolver.LookupMX returned unexpected error, got %q, want %q", err, expected)
-	}
-	_, err = LookupMX("golang.org")
-	if expected := "lookup golang.org: MX target is invalid"; err == nil || err.Error() != expected {
-		t.Errorf("LookupMX returned unexpected error, got %q, want %q", err, expected)
+	tests := []struct {
+		name string
+		f    func(*testing.T)
+	}{
+		{
+			name: "CNAME",
+			f: func(t *testing.T) {
+				expectedErr := &DNSError{Err: errMalformedDNSRecordsDetail, Name: "golang.org"}
+				_, err := r.LookupCNAME(context.Background(), "golang.org")
+				if err.Error() != expectedErr.Error() {
+					t.Fatalf("unexpected error: %s", err)
+				}
+				_, err = LookupCNAME("golang.org")
+				if err.Error() != expectedErr.Error() {
+					t.Fatalf("unexpected error: %s", err)
+				}
+			},
+		},
+		{
+			name: "SRV (bad record)",
+			f: func(t *testing.T) {
+				expected := []*SRV{
+					{
+						Target: "good.golang.org.",
+					},
+				}
+				expectedErr := &DNSError{Err: errMalformedDNSRecordsDetail, Name: "golang.org"}
+				_, records, err := r.LookupSRV(context.Background(), "target", "tcp", "golang.org")
+				if err.Error() != expectedErr.Error() {
+					t.Fatalf("unexpected error: %s", err)
+				}
+				if !reflect.DeepEqual(records, expected) {
+					t.Error("Unexpected record set")
+				}
+				_, records, err = LookupSRV("target", "tcp", "golang.org")
+				if err.Error() != expectedErr.Error() {
+					t.Errorf("unexpected error: %s", err)
+				}
+				if !reflect.DeepEqual(records, expected) {
+					t.Error("Unexpected record set")
+				}
+			},
+		},
+		{
+			name: "SRV (bad header)",
+			f: func(t *testing.T) {
+				_, _, err := r.LookupSRV(context.Background(), "hdr", "tcp", "golang.org.")
+				if expected := "lookup golang.org.: SRV header name is invalid"; err == nil || err.Error() != expected {
+					t.Errorf("Resolver.LookupSRV returned unexpected error, got %q, want %q", err, expected)
+				}
+				_, _, err = LookupSRV("hdr", "tcp", "golang.org.")
+				if expected := "lookup golang.org.: SRV header name is invalid"; err == nil || err.Error() != expected {
+					t.Errorf("LookupSRV returned unexpected error, got %q, want %q", err, expected)
+				}
+			},
+		},
+		{
+			name: "MX",
+			f: func(t *testing.T) {
+				expected := []*MX{
+					{
+						Host: "good.golang.org.",
+					},
+				}
+				expectedErr := &DNSError{Err: errMalformedDNSRecordsDetail, Name: "golang.org"}
+				records, err := r.LookupMX(context.Background(), "golang.org")
+				if err.Error() != expectedErr.Error() {
+					t.Fatalf("unexpected error: %s", err)
+				}
+				if !reflect.DeepEqual(records, expected) {
+					t.Error("Unexpected record set")
+				}
+				records, err = LookupMX("golang.org")
+				if err.Error() != expectedErr.Error() {
+					t.Fatalf("unexpected error: %s", err)
+				}
+				if !reflect.DeepEqual(records, expected) {
+					t.Error("Unexpected record set")
+				}
+			},
+		},
+		{
+			name: "NS",
+			f: func(t *testing.T) {
+				expected := []*NS{
+					{
+						Host: "good.golang.org.",
+					},
+				}
+				expectedErr := &DNSError{Err: errMalformedDNSRecordsDetail, Name: "golang.org"}
+				records, err := r.LookupNS(context.Background(), "golang.org")
+				if err.Error() != expectedErr.Error() {
+					t.Fatalf("unexpected error: %s", err)
+				}
+				if !reflect.DeepEqual(records, expected) {
+					t.Error("Unexpected record set")
+				}
+				records, err = LookupNS("golang.org")
+				if err.Error() != expectedErr.Error() {
+					t.Fatalf("unexpected error: %s", err)
+				}
+				if !reflect.DeepEqual(records, expected) {
+					t.Error("Unexpected record set")
+				}
+			},
+		},
+		{
+			name: "Addr",
+			f: func(t *testing.T) {
+				expected := []string{"good.golang.org."}
+				expectedErr := &DNSError{Err: errMalformedDNSRecordsDetail, Name: "192.0.2.42"}
+				records, err := r.LookupAddr(context.Background(), "192.0.2.42")
+				if err.Error() != expectedErr.Error() {
+					t.Fatalf("unexpected error: %s", err)
+				}
+				if !reflect.DeepEqual(records, expected) {
+					t.Error("Unexpected record set")
+				}
+				records, err = LookupAddr("192.0.2.42")
+				if err.Error() != expectedErr.Error() {
+					t.Fatalf("unexpected error: %s", err)
+				}
+				if !reflect.DeepEqual(records, expected) {
+					t.Error("Unexpected record set")
+				}
+			},
+		},
 	}
 
-	_, err = r.LookupNS(context.Background(), "golang.org")
-	if expected := "lookup golang.org: NS target is invalid"; err == nil || err.Error() != expected {
-		t.Errorf("Resolver.LookupNS returned unexpected error, got %q, want %q", err, expected)
-	}
-	_, err = LookupNS("golang.org")
-	if expected := "lookup golang.org: NS target is invalid"; err == nil || err.Error() != expected {
-		t.Errorf("LookupNS returned unexpected error, got %q, want %q", err, expected)
+	for _, tc := range tests {
+		t.Run(tc.name, tc.f)
 	}
 
-	_, err = r.LookupAddr(context.Background(), "192.0.2.42")
-	if expected := "lookup 192.0.2.42: PTR target is invalid"; err == nil || err.Error() != expected {
-		t.Errorf("Resolver.LookupAddr returned unexpected error, got %q, want %q", err, expected)
-	}
-	_, err = LookupAddr("192.0.2.42")
-	if expected := "lookup 192.0.2.42: PTR target is invalid"; err == nil || err.Error() != expected {
-		t.Errorf("LookupAddr returned unexpected error, got %q, want %q", err, expected)
-	}
 }
 
 func TestNullMX(t *testing.T) {
diff --git a/src/net/lookup.go b/src/net/lookup.go
index b5af3a0f86..d350ef7fc0 100644
--- a/src/net/lookup.go
+++ b/src/net/lookup.go
@@ -424,7 +424,7 @@ func (r *Resolver) LookupCNAME(ctx context.Context, host string) (string, error)
 		return "", err
 	}
 	if !isDomainName(cname) {
-		return "", &DNSError{Err: "CNAME target is invalid", Name: host}
+		return "", &DNSError{Err: errMalformedDNSRecordsDetail, Name: host}
 	}
 	return cname, nil
 }
@@ -440,7 +440,9 @@ func (r *Resolver) LookupCNAME(ctx context.Context, host string) (string, error)
 // and proto are empty strings, LookupSRV looks up name directly.
 //
 // The returned service names are validated to be properly
-// formatted presentation-format domain names.
+// formatted presentation-format domain names. If the response contains
+// invalid names, those records are filtered out and an error
+// will be returned alongside the the remaining results, if any.
 func LookupSRV(service, proto, name string) (cname string, addrs []*SRV, err error) {
 	return DefaultResolver.LookupSRV(context.Background(), service, proto, name)
 }
@@ -456,7 +458,9 @@ func LookupSRV(service, proto, name string) (cname string, addrs []*SRV, err err
 // and proto are empty strings, LookupSRV looks up name directly.
 //
 // The returned service names are validated to be properly
-// formatted presentation-format domain names.
+// formatted presentation-format domain names. If the response contains
+// invalid names, those records are filtered out and an error
+// will be returned alongside the the remaining results, if any.
 func (r *Resolver) LookupSRV(ctx context.Context, service, proto, name string) (string, []*SRV, error) {
 	cname, addrs, err := r.lookupSRV(ctx, service, proto, name)
 	if err != nil {
@@ -465,21 +469,28 @@ func (r *Resolver) LookupSRV(ctx context.Context, service, proto, name string) (
 	if cname != "" && !isDomainName(cname) {
 		return "", nil, &DNSError{Err: "SRV header name is invalid", Name: name}
 	}
+	filteredAddrs := make([]*SRV, 0, len(addrs))
 	for _, addr := range addrs {
 		if addr == nil {
 			continue
 		}
 		if !isDomainName(addr.Target) {
-			return "", nil, &DNSError{Err: "SRV target is invalid", Name: name}
+			continue
 		}
+		filteredAddrs = append(filteredAddrs, addr)
+	}
+	if len(addrs) != len(filteredAddrs) {
+		return cname, filteredAddrs, &DNSError{Err: errMalformedDNSRecordsDetail, Name: name}
 	}
-	return cname, addrs, nil
+	return cname, filteredAddrs, nil
 }
 
 // LookupMX returns the DNS MX records for the given domain name sorted by preference.
 //
 // The returned mail server names are validated to be properly
-// formatted presentation-format domain names.
+// formatted presentation-format domain names. If the response contains
+// invalid names, those records are filtered out and an error
+// will be returned alongside the the remaining results, if any.
 //
 // LookupMX uses context.Background internally; to specify the context, use
 // Resolver.LookupMX.
@@ -490,12 +501,15 @@ func LookupMX(name string) ([]*MX, error) {
 // LookupMX returns the DNS MX records for the given domain name sorted by preference.
 //
 // The returned mail server names are validated to be properly
-// formatted presentation-format domain names.
+// formatted presentation-format domain names. If the response contains
+// invalid names, those records are filtered out and an error
+// will be returned alongside the the remaining results, if any.
 func (r *Resolver) LookupMX(ctx context.Context, name string) ([]*MX, error) {
 	records, err := r.lookupMX(ctx, name)
 	if err != nil {
 		return nil, err
 	}
+	filteredMX := make([]*MX, 0, len(records))
 	for _, mx := range records {
 		if mx == nil {
 			continue
@@ -503,16 +517,22 @@ func (r *Resolver) LookupMX(ctx context.Context, name string) ([]*MX, error) {
 		// Bypass the hostname validity check for targets which contain only a dot,
 		// as this is used to represent a 'Null' MX record.
 		if mx.Host != "." && !isDomainName(mx.Host) {
-			return nil, &DNSError{Err: "MX target is invalid", Name: name}
+			continue
 		}
+		filteredMX = append(filteredMX, mx)
+	}
+	if len(records) != len(filteredMX) {
+		return filteredMX, &DNSError{Err: errMalformedDNSRecordsDetail, Name: name}
 	}
-	return records, nil
+	return filteredMX, nil
 }
 
 // LookupNS returns the DNS NS records for the given domain name.
 //
 // The returned name server names are validated to be properly
-// formatted presentation-format domain names.
+// formatted presentation-format domain names. If the response contains
+// invalid names, those records are filtered out and an error
+// will be returned alongside the the remaining results, if any.
 //
 // LookupNS uses context.Background internally; to specify the context, use
 // Resolver.LookupNS.
@@ -523,21 +543,28 @@ func LookupNS(name string) ([]*NS, error) {
 // LookupNS returns the DNS NS records for the given domain name.
 //
 // The returned name server names are validated to be properly
-// formatted presentation-format domain names.
+// formatted presentation-format domain names. If the response contains
+// invalid names, those records are filtered out and an error
+// will be returned alongside the the remaining results, if any.
 func (r *Resolver) LookupNS(ctx context.Context, name string) ([]*NS, error) {
 	records, err := r.lookupNS(ctx, name)
 	if err != nil {
 		return nil, err
 	}
+	filteredNS := make([]*NS, 0, len(records))
 	for _, ns := range records {
 		if ns == nil {
 			continue
 		}
 		if !isDomainName(ns.Host) {
-			return nil, &DNSError{Err: "NS target is invalid", Name: name}
+			continue
 		}
+		filteredNS = append(filteredNS, ns)
+	}
+	if len(records) != len(filteredNS) {
+		return filteredNS, &DNSError{Err: errMalformedDNSRecordsDetail, Name: name}
 	}
-	return records, nil
+	return filteredNS, nil
 }
 
 // LookupTXT returns the DNS TXT records for the given domain name.
@@ -557,7 +584,8 @@ func (r *Resolver) LookupTXT(ctx context.Context, name string) ([]string, error)
 // of names mapping to that address.
 //
 // The returned names are validated to be properly formatted presentation-format
-// domain names.
+// domain names. If the response contains invalid names, those records are filtered
+// out and an error will be returned alongside the the remaining results, if any.
 //
 // When using the host C library resolver, at most one result will be
 // returned. To bypass the host resolver, use a custom Resolver.
@@ -572,16 +600,26 @@ func LookupAddr(addr string) (names []string, err error) {
 // of names mapping to that address.
 //
 // The returned names are validated to be properly formatted presentation-format
-// domain names.
+// domain names. If the response contains invalid names, those records are filtered
+// out and an error will be returned alongside the the remaining results, if any.
 func (r *Resolver) LookupAddr(ctx context.Context, addr string) ([]string, error) {
 	names, err := r.lookupAddr(ctx, addr)
 	if err != nil {
 		return nil, err
 	}
+	filteredNames := make([]string, 0, len(names))
 	for _, name := range names {
-		if !isDomainName(name) {
-			return nil, &DNSError{Err: "PTR target is invalid", Name: addr}
+		if isDomainName(name) {
+			filteredNames = append(filteredNames, name)
 		}
 	}
-	return names, nil
+	if len(names) != len(filteredNames) {
+		return filteredNames, &DNSError{Err: errMalformedDNSRecordsDetail, Name: addr}
+	}
+	return filteredNames, nil
 }
+
+// errMalformedDNSRecordsDetail is the DNSError detail which is returned when a Resolver.Lookup...
+// method recieves DNS records which contain invalid DNS names. This may be returned alongside
+// results which have had the malformed records filtered out.
+var errMalformedDNSRecordsDetail = "DNS response contained records which contain invalid names"
-- 
GitLab


From ab4085ce84f8378b4ec2dfdbbc44c98cb92debe5 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Fri, 9 Jul 2021 17:34:07 +0000
Subject: [PATCH 2337/2400] runtime/pprof: call runtime.GC twice in memory
 profile test

This change fixes #46500 by working around #45315 which may cause freed
objects to get missed in the heap profile published for the test.

By calling runtime.GC one more time this change ensures that all freed
objects are accounted for.

Fixes #46500.

Change-Id: Iedcd0b37dbaffa688b0ff8631a8b79f7a1169634
Reviewed-on: https://go-review.googlesource.com/c/go/+/333549
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Austin Clements <austin@google.com>
---
 src/runtime/pprof/mprof_test.go | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/runtime/pprof/mprof_test.go b/src/runtime/pprof/mprof_test.go
index 3ef40d3de7..b4680fbdee 100644
--- a/src/runtime/pprof/mprof_test.go
+++ b/src/runtime/pprof/mprof_test.go
@@ -86,6 +86,17 @@ func TestMemoryProfiler(t *testing.T) {
 
 	runtime.GC() // materialize stats
 
+	// TODO(mknyszek): Fix #45315 and remove this extra call.
+	//
+	// Unfortunately, it's possible for the sweep termination condition
+	// to flap, so with just one runtime.GC call, a freed object could be
+	// missed, leading this test to fail. A second call reduces the chance
+	// of this happening to zero, because sweeping actually has to finish
+	// to move on to the next GC, during which nothing will happen.
+	//
+	// See #46500 for more details.
+	runtime.GC()
+
 	memoryProfilerRun++
 
 	tests := []struct {
-- 
GitLab


From cfbd73ba33fc6a3635b3a63096fd6c6bff9d73e8 Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Fri, 9 Jul 2021 16:22:32 -0400
Subject: [PATCH 2338/2400] doc/go1.17: editing pass over the "Compiler"
 section

Change-Id: I08c082f548daa7011a8dc42769371329684c90e6
Reviewed-on: https://go-review.googlesource.com/c/go/+/333609
Trust: Austin Clements <austin@google.com>
Trust: Dan Scales <danscales@google.com>
Reviewed-by: Dan Scales <danscales@google.com>
---
 doc/go1.17.html | 62 ++++++++++++++++++++++++++++---------------------
 1 file changed, 36 insertions(+), 26 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 4fa30158bb..fa8f14de99 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -401,30 +401,37 @@ func Foo() bool {
 
 <p><!-- golang.org/issue/40724 -->
   Go 1.17 implements a new way of passing function arguments and results using
-  registers instead of the stack. This work is enabled for Linux, macOS, and
-  Windows on the 64-bit x86 architecture (the <code>linux/amd64</code>,
-  <code>darwin/amd64</code>, <code>windows/amd64</code> ports). For a
-  representative set of Go packages and programs, benchmarking has shown
-  performance improvements of about 5%, and a typical reduction in binary size
-  of about 2%.
+  registers instead of the stack.
+  Benchmarks for a representative set of Go packages and programs show
+  performance improvements of about 5%, and a typical reduction in
+  binary size of about 2%.
+  This is currently enabled for Linux, macOS, and Windows on the
+  64-bit x86 architecture (the <code>linux/amd64</code>,
+  <code>darwin/amd64</code>, and <code>windows/amd64</code> ports).
 </p>
 
 <p>
-  This change does not affect the functionality of any safe Go code. It can affect
-  code outside the <a href="/doc/go1compat">compatibility guidelines</a> with
-  minimal impact. To maintain compatibility with existing assembly functions,
-  adapter functions converting between the new register-based calling convention
-  and the previous stack-based calling convention (also known as ABI wrappers)
-  are sometimes used. This is mostly invisible to users, except for assembly
-  functions that have their addresses taken in Go. Using <code>reflect.ValueOf(fn).Pointer()</code>
-  (or similar approaches such as via <code>unsafe.Pointer</code>) to get the address
-  of an assembly function will now return the address of the ABI wrapper. This is
-  mostly harmless, except for special-purpose assembly code (such as accessing
-  thread-local storage or requiring a special stack alignment). Assembly functions
-  called indirectly from Go via <code>func</code> values will now be made through
-  ABI wrappers, which may cause a very small performance overhead. Also, calling
-  Go functions from assembly may now go through ABI wrappers, with a very small
-  performance overhead.
+  This change does not affect the functionality of any safe Go code
+  and is designed to have no impact on most assembly code.
+  It may affect code that violates
+  the <a href="/pkg/unsafe#Pointer"><code>unsafe.Pointer</code></a>
+  rules when accessing function arguments, or that depends on
+  undocumented behavior involving comparing function code pointers.
+  To maintain compatibility with existing assembly functions, the
+  compiler generates adapter functions that convert between the new
+  register-based calling convention and the previous stack-based
+  calling convention.
+  These adapters are typically invisible to users, except that taking
+  the address of a Go function in assembly code or taking the address
+  of an assembly function in Go code
+  using <code>reflect.ValueOf(fn).Pointer()</code>
+  or <code>unsafe.Pointer</code> will now return the address of the
+  adapter.
+  Code that depends on the value of these code pointers may no longer
+  behave as expected.
+  Adapters also may cause a very small performance overhead in two
+  cases: calling an assembly function indirectly from Go via
+  a <code>func</code> value, and calling Go functions from assembly.
 </p>
 
 <p><!-- CL 304470 -->
@@ -440,11 +447,14 @@ func Foo() bool {
 </p>
 
 <p><!-- CL 283112, golang.org/issue/28727 -->
-  Functions containing closures can now be inlined. One effect of this change is
-  that a function with a closure may actually produce a distinct closure function
-  for each place that the function is inlined. Hence, this change could reveal
-  bugs where Go functions are compared (incorrectly) by pointer value. Go
-  functions are by definition not comparable.
+  Functions containing closures can now be inlined.
+  One effect of this change is that a function with a closure may
+  produce a distinct closure code pointer for each place that the
+  function is inlined.
+  Go function values are not directly comparable, but this change
+  could reveal bugs in code that uses <code>reflect</code>
+  or <code>unsafe.Pointer</code> to bypass this language restriction
+  and compare functions by code pointer.
 </p>
 
 <h2 id="library">Core library</h2>
-- 
GitLab


From a98589711da5e9d935e8d690cfca92892e86d557 Mon Sep 17 00:00:00 2001
From: Roland Shoemaker <roland@golang.org>
Date: Wed, 9 Jun 2021 11:31:27 -0700
Subject: [PATCH 2339/2400] crypto/tls: test key type when casting

When casting the certificate public key in generateClientKeyExchange,
check the type is appropriate. This prevents a panic when a server
agrees to a RSA based key exchange, but then sends an ECDSA (or
other) certificate.

Fixes #47143
Fixes CVE-2021-34558

Thanks to Imre Rad for reporting this issue.

Change-Id: Iabccacca6052769a605cccefa1216a9f7b7f6aea
Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1116723
Reviewed-by: Filippo Valsorda <valsorda@google.com>
Reviewed-by: Katie Hockman <katiehockman@google.com>
Reviewed-on: https://go-review.googlesource.com/c/go/+/334031
Trust: Filippo Valsorda <filippo@golang.org>
Run-TryBot: Filippo Valsorda <filippo@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 src/crypto/tls/key_agreement.go | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/crypto/tls/key_agreement.go b/src/crypto/tls/key_agreement.go
index 8cfbd734f1..c28a64f3a8 100644
--- a/src/crypto/tls/key_agreement.go
+++ b/src/crypto/tls/key_agreement.go
@@ -86,7 +86,11 @@ func (ka rsaKeyAgreement) generateClientKeyExchange(config *Config, clientHello
 		return nil, nil, err
 	}
 
-	encrypted, err := rsa.EncryptPKCS1v15(config.rand(), cert.PublicKey.(*rsa.PublicKey), preMasterSecret)
+	rsaKey, ok := cert.PublicKey.(*rsa.PublicKey)
+	if !ok {
+		return nil, nil, errors.New("tls: server certificate contains incorrect key type for selected ciphersuite")
+	}
+	encrypted, err := rsa.EncryptPKCS1v15(config.rand(), rsaKey, preMasterSecret)
 	if err != nil {
 		return nil, nil, err
 	}
-- 
GitLab


From ddfd72f7d10a40a87513a320dae8c52b6dfdb778 Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Tue, 13 Jul 2021 16:26:10 +0000
Subject: [PATCH 2340/2400] [release-branch.go1.17] go1.17rc1

Change-Id: Idc207e34c54b9bff0ae59348e4bc97474b1c11d2
Reviewed-on: https://go-review.googlesource.com/c/go/+/334254
Run-TryBot: Cherry Mui <cherryyz@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Cherry Mui <cherryyz@google.com>
---
 VERSION | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 VERSION

diff --git a/VERSION b/VERSION
new file mode 100644
index 0000000000..cc1496155f
--- /dev/null
+++ b/VERSION
@@ -0,0 +1 @@
+go1.17rc1
\ No newline at end of file
-- 
GitLab


From d8f348a589b3df4bb48636023be4ccf9ac96d307 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Tue, 13 Jul 2021 17:25:26 -0400
Subject: [PATCH 2341/2400] cmd/go: remove a duplicated word from 'go help mod
 graph'

For #46366

Change-Id: Ie9735027a3c4c0f4a604df30ca4d64dcdc62b45a
Reviewed-on: https://go-review.googlesource.com/c/go/+/334375
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/alldocs.go               | 2 +-
 src/cmd/go/internal/modcmd/graph.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index 90eb3e2a00..954caae9fb 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -1193,7 +1193,7 @@
 // and one of its requirements. Each module is identified as a string of the form
 // path@version, except for the main module, which has no @version suffix.
 //
-// The -go flag causes graph to report the module graph as loaded by by the
+// The -go flag causes graph to report the module graph as loaded by the
 // given Go version, instead of the version indicated by the 'go' directive
 // in the go.mod file.
 //
diff --git a/src/cmd/go/internal/modcmd/graph.go b/src/cmd/go/internal/modcmd/graph.go
index 903bd9970f..ac81f26dad 100644
--- a/src/cmd/go/internal/modcmd/graph.go
+++ b/src/cmd/go/internal/modcmd/graph.go
@@ -26,7 +26,7 @@ in text form. Each line in the output has two space-separated fields: a module
 and one of its requirements. Each module is identified as a string of the form
 path@version, except for the main module, which has no @version suffix.
 
-The -go flag causes graph to report the module graph as loaded by by the
+The -go flag causes graph to report the module graph as loaded by the
 given Go version, instead of the version indicated by the 'go' directive
 in the go.mod file.
 
-- 
GitLab


From c3b47cb598e1ecdbbec110325d9d1979553351fc Mon Sep 17 00:00:00 2001
From: Dmitri Shuralyov <dmitshur@golang.org>
Date: Tue, 13 Jul 2021 17:47:13 -0400
Subject: [PATCH 2342/2400] [release-branch.go1.17] update codereview.cfg for
 release-branch.go1.17

The initial "branch: master" configuration was inherited from when
the release-branch.go1.17 branch was branched off the master branch.
Update the "branch" key, otherwise a modern git-codereview will mail
CLs to the wrong branch.

We can set "parent-branch" so that 'git codereview sync-branch' works
to merge latest master into release-branch.go1.17, something we want
to do for subsequent RCs, maybe up to the final release. (At some point
the release freeze will end and tree will open for Go 1.18 development,
so we'll be switching to using cherry-picks only. Having parent-branch
will not be useful then, but I think harmless.)

Change-Id: I36ab977eaeb52bc0a84cc59e807572054f54c789
Reviewed-on: https://go-review.googlesource.com/c/go/+/334376
Reviewed-by: Cherry Mui <cherryyz@google.com>
Reviewed-by: Heschi Kreinick <heschi@google.com>
Trust: Dmitri Shuralyov <dmitshur@golang.org>
---
 codereview.cfg | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/codereview.cfg b/codereview.cfg
index 77a74f108e..9d5ebe82eb 100644
--- a/codereview.cfg
+++ b/codereview.cfg
@@ -1 +1,2 @@
-branch: master
+branch: release-branch.go1.17
+parent-branch: master
-- 
GitLab


From 60ddf42b4627fb4ff5f92d2193c294456175af9a Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 2 Jul 2021 16:41:22 -0400
Subject: [PATCH 2343/2400] cmd/go: change link in error message from /wiki to
 /doc.

The /doc link is currently a redirect (CL 334389),
but I plan to update it soon with a more detailed guide.

Updates #36460

Change-Id: I9e4a47ad0c8bcb7361cfa3e5b9d07ad241b13ba6
Reviewed-on: https://go-review.googlesource.com/c/go/+/332573
Trust: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modload/load.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index 771b142b73..bce9ad85f4 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -1808,7 +1808,7 @@ func (ld *loader) checkTidyCompatibility(ctx context.Context, rs *Requirements)
 		fmt.Fprintf(os.Stderr, "If reproducibility with go %s is not needed:\n\tgo mod tidy%s -compat=%s\n", ld.TidyCompatibleVersion, goFlag, ld.GoVersion)
 
 		// TODO(#46141): Populate the linked wiki page.
-		fmt.Fprintf(os.Stderr, "For other options, see:\n\thttps://golang.org/wiki/PruningModules\n")
+		fmt.Fprintf(os.Stderr, "For other options, see:\n\thttps://golang.org/doc/modules/pruning\n")
 	}
 
 	mg, err := rs.Graph(ctx)
-- 
GitLab


From 2b00a54baf2b677b2aaddd93c25b11ea4642a86f Mon Sep 17 00:00:00 2001
From: WANG Xuerui <git@xen0n.name>
Date: Mon, 12 Jul 2021 04:40:28 +0000
Subject: [PATCH 2344/2400] go/build, runtime/internal/sys: reserve
 GOARCH=loong64

Per discussion at #46229 we are taking the "loong64" GOARCH value for
the upcoming LoongArch 64-bit port. It is not clear whether any 32-bit
non-bare-metal userland will exist for LoongArch, so only reserve
"loong64" for now.

Change-Id: I97d262b4ab68ff61c22ccf83e26baf70eefd568d
GitHub-Last-Rev: ecdd8c53bdee57fec093ddba18ec8878b8ae7c74
GitHub-Pull-Request: golang/go#47129
Reviewed-on: https://go-review.googlesource.com/c/go/+/333909
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Alexander Rakoczy <alex@golang.org>
---
 src/go/build/syslist.go                       |  2 +-
 src/runtime/internal/sys/zgoarch_386.go       |  1 +
 src/runtime/internal/sys/zgoarch_amd64.go     |  1 +
 src/runtime/internal/sys/zgoarch_arm.go       |  1 +
 src/runtime/internal/sys/zgoarch_arm64.go     |  1 +
 src/runtime/internal/sys/zgoarch_arm64be.go   |  1 +
 src/runtime/internal/sys/zgoarch_armbe.go     |  1 +
 src/runtime/internal/sys/zgoarch_loong64.go   | 33 +++++++++++++++++++
 src/runtime/internal/sys/zgoarch_mips.go      |  1 +
 src/runtime/internal/sys/zgoarch_mips64.go    |  1 +
 src/runtime/internal/sys/zgoarch_mips64le.go  |  1 +
 src/runtime/internal/sys/zgoarch_mips64p32.go |  1 +
 .../internal/sys/zgoarch_mips64p32le.go       |  1 +
 src/runtime/internal/sys/zgoarch_mipsle.go    |  1 +
 src/runtime/internal/sys/zgoarch_ppc.go       |  1 +
 src/runtime/internal/sys/zgoarch_ppc64.go     |  1 +
 src/runtime/internal/sys/zgoarch_ppc64le.go   |  1 +
 src/runtime/internal/sys/zgoarch_riscv.go     |  1 +
 src/runtime/internal/sys/zgoarch_riscv64.go   |  1 +
 src/runtime/internal/sys/zgoarch_s390.go      |  1 +
 src/runtime/internal/sys/zgoarch_s390x.go     |  1 +
 src/runtime/internal/sys/zgoarch_sparc.go     |  1 +
 src/runtime/internal/sys/zgoarch_sparc64.go   |  1 +
 src/runtime/internal/sys/zgoarch_wasm.go      |  1 +
 24 files changed, 56 insertions(+), 1 deletion(-)
 create mode 100644 src/runtime/internal/sys/zgoarch_loong64.go

diff --git a/src/go/build/syslist.go b/src/go/build/syslist.go
index 1275f7c986..60ac5511bd 100644
--- a/src/go/build/syslist.go
+++ b/src/go/build/syslist.go
@@ -8,4 +8,4 @@ package build
 // Do not remove from this list, as these are used for go/build filename matching.
 
 const goosList = "aix android darwin dragonfly freebsd hurd illumos ios js linux nacl netbsd openbsd plan9 solaris windows zos "
-const goarchList = "386 amd64 amd64p32 arm armbe arm64 arm64be ppc64 ppc64le mips mipsle mips64 mips64le mips64p32 mips64p32le ppc riscv riscv64 s390 s390x sparc sparc64 wasm "
+const goarchList = "386 amd64 amd64p32 arm armbe arm64 arm64be ppc64 ppc64le loong64 mips mipsle mips64 mips64le mips64p32 mips64p32le ppc riscv riscv64 s390 s390x sparc sparc64 wasm "
diff --git a/src/runtime/internal/sys/zgoarch_386.go b/src/runtime/internal/sys/zgoarch_386.go
index 98a2401bfe..5b189e7e73 100644
--- a/src/runtime/internal/sys/zgoarch_386.go
+++ b/src/runtime/internal/sys/zgoarch_386.go
@@ -16,6 +16,7 @@ const GoarchArm64 = 0
 const GoarchArm64be = 0
 const GoarchPpc64 = 0
 const GoarchPpc64le = 0
+const GoarchLoong64 = 0
 const GoarchMips = 0
 const GoarchMipsle = 0
 const GoarchMips64 = 0
diff --git a/src/runtime/internal/sys/zgoarch_amd64.go b/src/runtime/internal/sys/zgoarch_amd64.go
index d8faa5c786..312977d079 100644
--- a/src/runtime/internal/sys/zgoarch_amd64.go
+++ b/src/runtime/internal/sys/zgoarch_amd64.go
@@ -16,6 +16,7 @@ const GoarchArm64 = 0
 const GoarchArm64be = 0
 const GoarchPpc64 = 0
 const GoarchPpc64le = 0
+const GoarchLoong64 = 0
 const GoarchMips = 0
 const GoarchMipsle = 0
 const GoarchMips64 = 0
diff --git a/src/runtime/internal/sys/zgoarch_arm.go b/src/runtime/internal/sys/zgoarch_arm.go
index b64a69c9b4..5781870324 100644
--- a/src/runtime/internal/sys/zgoarch_arm.go
+++ b/src/runtime/internal/sys/zgoarch_arm.go
@@ -16,6 +16,7 @@ const GoarchArm64 = 0
 const GoarchArm64be = 0
 const GoarchPpc64 = 0
 const GoarchPpc64le = 0
+const GoarchLoong64 = 0
 const GoarchMips = 0
 const GoarchMipsle = 0
 const GoarchMips64 = 0
diff --git a/src/runtime/internal/sys/zgoarch_arm64.go b/src/runtime/internal/sys/zgoarch_arm64.go
index de6f85347b..f72a1f2161 100644
--- a/src/runtime/internal/sys/zgoarch_arm64.go
+++ b/src/runtime/internal/sys/zgoarch_arm64.go
@@ -16,6 +16,7 @@ const GoarchArm64 = 1
 const GoarchArm64be = 0
 const GoarchPpc64 = 0
 const GoarchPpc64le = 0
+const GoarchLoong64 = 0
 const GoarchMips = 0
 const GoarchMipsle = 0
 const GoarchMips64 = 0
diff --git a/src/runtime/internal/sys/zgoarch_arm64be.go b/src/runtime/internal/sys/zgoarch_arm64be.go
index b762bb069f..e805646058 100644
--- a/src/runtime/internal/sys/zgoarch_arm64be.go
+++ b/src/runtime/internal/sys/zgoarch_arm64be.go
@@ -16,6 +16,7 @@ const GoarchArm64 = 0
 const GoarchArm64be = 1
 const GoarchPpc64 = 0
 const GoarchPpc64le = 0
+const GoarchLoong64 = 0
 const GoarchMips = 0
 const GoarchMipsle = 0
 const GoarchMips64 = 0
diff --git a/src/runtime/internal/sys/zgoarch_armbe.go b/src/runtime/internal/sys/zgoarch_armbe.go
index e5297e4b16..d8d4e56d9a 100644
--- a/src/runtime/internal/sys/zgoarch_armbe.go
+++ b/src/runtime/internal/sys/zgoarch_armbe.go
@@ -16,6 +16,7 @@ const GoarchArm64 = 0
 const GoarchArm64be = 0
 const GoarchPpc64 = 0
 const GoarchPpc64le = 0
+const GoarchLoong64 = 0
 const GoarchMips = 0
 const GoarchMipsle = 0
 const GoarchMips64 = 0
diff --git a/src/runtime/internal/sys/zgoarch_loong64.go b/src/runtime/internal/sys/zgoarch_loong64.go
new file mode 100644
index 0000000000..6f35eb44a3
--- /dev/null
+++ b/src/runtime/internal/sys/zgoarch_loong64.go
@@ -0,0 +1,33 @@
+// Code generated by gengoos.go using 'go generate'. DO NOT EDIT.
+
+//go:build loong64
+// +build loong64
+
+package sys
+
+const GOARCH = `loong64`
+
+const Goarch386 = 0
+const GoarchAmd64 = 0
+const GoarchAmd64p32 = 0
+const GoarchArm = 0
+const GoarchArmbe = 0
+const GoarchArm64 = 0
+const GoarchArm64be = 0
+const GoarchPpc64 = 0
+const GoarchPpc64le = 0
+const GoarchLoong64 = 1
+const GoarchMips = 0
+const GoarchMipsle = 0
+const GoarchMips64 = 0
+const GoarchMips64le = 0
+const GoarchMips64p32 = 0
+const GoarchMips64p32le = 0
+const GoarchPpc = 0
+const GoarchRiscv = 0
+const GoarchRiscv64 = 0
+const GoarchS390 = 0
+const GoarchS390x = 0
+const GoarchSparc = 0
+const GoarchSparc64 = 0
+const GoarchWasm = 0
diff --git a/src/runtime/internal/sys/zgoarch_mips.go b/src/runtime/internal/sys/zgoarch_mips.go
index b5f4ed390c..bd58a92a0e 100644
--- a/src/runtime/internal/sys/zgoarch_mips.go
+++ b/src/runtime/internal/sys/zgoarch_mips.go
@@ -16,6 +16,7 @@ const GoarchArm64 = 0
 const GoarchArm64be = 0
 const GoarchPpc64 = 0
 const GoarchPpc64le = 0
+const GoarchLoong64 = 0
 const GoarchMips = 1
 const GoarchMipsle = 0
 const GoarchMips64 = 0
diff --git a/src/runtime/internal/sys/zgoarch_mips64.go b/src/runtime/internal/sys/zgoarch_mips64.go
index 73777cceb2..8e4a3dcd52 100644
--- a/src/runtime/internal/sys/zgoarch_mips64.go
+++ b/src/runtime/internal/sys/zgoarch_mips64.go
@@ -16,6 +16,7 @@ const GoarchArm64 = 0
 const GoarchArm64be = 0
 const GoarchPpc64 = 0
 const GoarchPpc64le = 0
+const GoarchLoong64 = 0
 const GoarchMips = 0
 const GoarchMipsle = 0
 const GoarchMips64 = 1
diff --git a/src/runtime/internal/sys/zgoarch_mips64le.go b/src/runtime/internal/sys/zgoarch_mips64le.go
index 0c81c36c09..d8e00339ea 100644
--- a/src/runtime/internal/sys/zgoarch_mips64le.go
+++ b/src/runtime/internal/sys/zgoarch_mips64le.go
@@ -16,6 +16,7 @@ const GoarchArm64 = 0
 const GoarchArm64be = 0
 const GoarchPpc64 = 0
 const GoarchPpc64le = 0
+const GoarchLoong64 = 0
 const GoarchMips = 0
 const GoarchMipsle = 0
 const GoarchMips64 = 0
diff --git a/src/runtime/internal/sys/zgoarch_mips64p32.go b/src/runtime/internal/sys/zgoarch_mips64p32.go
index d63ce27d24..8549cc0ba3 100644
--- a/src/runtime/internal/sys/zgoarch_mips64p32.go
+++ b/src/runtime/internal/sys/zgoarch_mips64p32.go
@@ -16,6 +16,7 @@ const GoarchArm64 = 0
 const GoarchArm64be = 0
 const GoarchPpc64 = 0
 const GoarchPpc64le = 0
+const GoarchLoong64 = 0
 const GoarchMips = 0
 const GoarchMipsle = 0
 const GoarchMips64 = 0
diff --git a/src/runtime/internal/sys/zgoarch_mips64p32le.go b/src/runtime/internal/sys/zgoarch_mips64p32le.go
index 2d577890b2..667b6fe514 100644
--- a/src/runtime/internal/sys/zgoarch_mips64p32le.go
+++ b/src/runtime/internal/sys/zgoarch_mips64p32le.go
@@ -16,6 +16,7 @@ const GoarchArm64 = 0
 const GoarchArm64be = 0
 const GoarchPpc64 = 0
 const GoarchPpc64le = 0
+const GoarchLoong64 = 0
 const GoarchMips = 0
 const GoarchMipsle = 0
 const GoarchMips64 = 0
diff --git a/src/runtime/internal/sys/zgoarch_mipsle.go b/src/runtime/internal/sys/zgoarch_mipsle.go
index 8af919d03a..8bedb2bb90 100644
--- a/src/runtime/internal/sys/zgoarch_mipsle.go
+++ b/src/runtime/internal/sys/zgoarch_mipsle.go
@@ -16,6 +16,7 @@ const GoarchArm64 = 0
 const GoarchArm64be = 0
 const GoarchPpc64 = 0
 const GoarchPpc64le = 0
+const GoarchLoong64 = 0
 const GoarchMips = 0
 const GoarchMipsle = 1
 const GoarchMips64 = 0
diff --git a/src/runtime/internal/sys/zgoarch_ppc.go b/src/runtime/internal/sys/zgoarch_ppc.go
index f6f12a5ddc..fe2196a327 100644
--- a/src/runtime/internal/sys/zgoarch_ppc.go
+++ b/src/runtime/internal/sys/zgoarch_ppc.go
@@ -16,6 +16,7 @@ const GoarchArm64 = 0
 const GoarchArm64be = 0
 const GoarchPpc64 = 0
 const GoarchPpc64le = 0
+const GoarchLoong64 = 0
 const GoarchMips = 0
 const GoarchMipsle = 0
 const GoarchMips64 = 0
diff --git a/src/runtime/internal/sys/zgoarch_ppc64.go b/src/runtime/internal/sys/zgoarch_ppc64.go
index a8379601f4..bd7cc43de3 100644
--- a/src/runtime/internal/sys/zgoarch_ppc64.go
+++ b/src/runtime/internal/sys/zgoarch_ppc64.go
@@ -16,6 +16,7 @@ const GoarchArm64 = 0
 const GoarchArm64be = 0
 const GoarchPpc64 = 1
 const GoarchPpc64le = 0
+const GoarchLoong64 = 0
 const GoarchMips = 0
 const GoarchMipsle = 0
 const GoarchMips64 = 0
diff --git a/src/runtime/internal/sys/zgoarch_ppc64le.go b/src/runtime/internal/sys/zgoarch_ppc64le.go
index f2ec5dcba7..e101892401 100644
--- a/src/runtime/internal/sys/zgoarch_ppc64le.go
+++ b/src/runtime/internal/sys/zgoarch_ppc64le.go
@@ -16,6 +16,7 @@ const GoarchArm64 = 0
 const GoarchArm64be = 0
 const GoarchPpc64 = 0
 const GoarchPpc64le = 1
+const GoarchLoong64 = 0
 const GoarchMips = 0
 const GoarchMipsle = 0
 const GoarchMips64 = 0
diff --git a/src/runtime/internal/sys/zgoarch_riscv.go b/src/runtime/internal/sys/zgoarch_riscv.go
index 83a3312f5f..559f86071a 100644
--- a/src/runtime/internal/sys/zgoarch_riscv.go
+++ b/src/runtime/internal/sys/zgoarch_riscv.go
@@ -16,6 +16,7 @@ const GoarchArm64 = 0
 const GoarchArm64be = 0
 const GoarchPpc64 = 0
 const GoarchPpc64le = 0
+const GoarchLoong64 = 0
 const GoarchMips = 0
 const GoarchMipsle = 0
 const GoarchMips64 = 0
diff --git a/src/runtime/internal/sys/zgoarch_riscv64.go b/src/runtime/internal/sys/zgoarch_riscv64.go
index 1dfcc84997..8485a94b3d 100644
--- a/src/runtime/internal/sys/zgoarch_riscv64.go
+++ b/src/runtime/internal/sys/zgoarch_riscv64.go
@@ -16,6 +16,7 @@ const GoarchArm64 = 0
 const GoarchArm64be = 0
 const GoarchPpc64 = 0
 const GoarchPpc64le = 0
+const GoarchLoong64 = 0
 const GoarchMips = 0
 const GoarchMipsle = 0
 const GoarchMips64 = 0
diff --git a/src/runtime/internal/sys/zgoarch_s390.go b/src/runtime/internal/sys/zgoarch_s390.go
index 91aba5a0f6..4c4569e376 100644
--- a/src/runtime/internal/sys/zgoarch_s390.go
+++ b/src/runtime/internal/sys/zgoarch_s390.go
@@ -16,6 +16,7 @@ const GoarchArm64 = 0
 const GoarchArm64be = 0
 const GoarchPpc64 = 0
 const GoarchPpc64le = 0
+const GoarchLoong64 = 0
 const GoarchMips = 0
 const GoarchMipsle = 0
 const GoarchMips64 = 0
diff --git a/src/runtime/internal/sys/zgoarch_s390x.go b/src/runtime/internal/sys/zgoarch_s390x.go
index edce50234e..e50d2edbb5 100644
--- a/src/runtime/internal/sys/zgoarch_s390x.go
+++ b/src/runtime/internal/sys/zgoarch_s390x.go
@@ -16,6 +16,7 @@ const GoarchArm64 = 0
 const GoarchArm64be = 0
 const GoarchPpc64 = 0
 const GoarchPpc64le = 0
+const GoarchLoong64 = 0
 const GoarchMips = 0
 const GoarchMipsle = 0
 const GoarchMips64 = 0
diff --git a/src/runtime/internal/sys/zgoarch_sparc.go b/src/runtime/internal/sys/zgoarch_sparc.go
index 5ae9560ab0..0d08752c7b 100644
--- a/src/runtime/internal/sys/zgoarch_sparc.go
+++ b/src/runtime/internal/sys/zgoarch_sparc.go
@@ -16,6 +16,7 @@ const GoarchArm64 = 0
 const GoarchArm64be = 0
 const GoarchPpc64 = 0
 const GoarchPpc64le = 0
+const GoarchLoong64 = 0
 const GoarchMips = 0
 const GoarchMipsle = 0
 const GoarchMips64 = 0
diff --git a/src/runtime/internal/sys/zgoarch_sparc64.go b/src/runtime/internal/sys/zgoarch_sparc64.go
index e2a0134aff..ba405bbf35 100644
--- a/src/runtime/internal/sys/zgoarch_sparc64.go
+++ b/src/runtime/internal/sys/zgoarch_sparc64.go
@@ -16,6 +16,7 @@ const GoarchArm64 = 0
 const GoarchArm64be = 0
 const GoarchPpc64 = 0
 const GoarchPpc64le = 0
+const GoarchLoong64 = 0
 const GoarchMips = 0
 const GoarchMipsle = 0
 const GoarchMips64 = 0
diff --git a/src/runtime/internal/sys/zgoarch_wasm.go b/src/runtime/internal/sys/zgoarch_wasm.go
index 52e85dea37..7c3e5afd1e 100644
--- a/src/runtime/internal/sys/zgoarch_wasm.go
+++ b/src/runtime/internal/sys/zgoarch_wasm.go
@@ -16,6 +16,7 @@ const GoarchArm64 = 0
 const GoarchArm64be = 0
 const GoarchPpc64 = 0
 const GoarchPpc64le = 0
+const GoarchLoong64 = 0
 const GoarchMips = 0
 const GoarchMipsle = 0
 const GoarchMips64 = 0
-- 
GitLab


From 21a04e33353316635b5f3351e807916f3bb1e844 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Wed, 14 Jul 2021 16:04:49 -0700
Subject: [PATCH 2345/2400] doc/go1.17: mention GOARCH=loong64

For #46229

Change-Id: I54d01d90f2b0c892d76121f1350c0e8cf4b2772f
Reviewed-on: https://go-review.googlesource.com/c/go/+/334729
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 doc/go1.17.html | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index fa8f14de99..b31006fe65 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -119,6 +119,17 @@ Do not send CLs removing the interior tags from such phrases.
   stack frame pointers only on Linux, macOS, and iOS.
 </p>
 
+<h3 id="loong64">loong64 GOARCH value reserved</h3>
+
+<p><!-- CL 333909 -->
+  The main Go compiler does not yet support the LoongArch
+  architecture, but we've reserved the <code>GOARCH</code> value
+  "<code>loong64</code>".
+  This means that Go files named <code>*_loong64.go</code> will now
+  be <a href="/pkg/go/build/#hdr-Build_Constraints">ignored by Go
+  tools</a> except when that GOARCH value is being used.
+</p>
+
 <h2 id="tools">Tools</h2>
 
 <h3 id="go-command">Go command</h3>
-- 
GitLab


From c1cc9f9c3d5ed789a080ef9f8dd9c11eca7e2026 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Thu, 15 Jul 2021 00:56:44 +0700
Subject: [PATCH 2346/2400] cmd/compile: fix lookup package of redeclared dot
 import symbol

The compiler is relying on Sym.Def field to lookup symbol package in
DotImportRefs map. But the Sym.Def field is clear whenever the compiler
finish processing a file. If the dot import happen in file A, then the
redeclaration happen in file B, then the symbol lookup in file B will
see a nil Sym.Def, that cause the compiler crashes.

To fix this, we can interate over DotImportRefs and check for matching
symbol name and return the corresponding package. Though this operation
can be slow, but it only happens in invalid program, when printing error
message, so it's not worth to optimize it further.

Fixes #47201

Change-Id: I4ca1cb0a8e7432b19cf71434592a4cbb58d54adf
Reviewed-on: https://go-review.googlesource.com/c/go/+/334589
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
---
 src/cmd/compile/internal/typecheck/dcl.go | 12 +++++++++++-
 test/fixedbugs/issue47201.dir/a.go        | 13 +++++++++++++
 test/fixedbugs/issue47201.dir/b.go        |  9 +++++++++
 test/fixedbugs/issue47201.go              |  7 +++++++
 4 files changed, 40 insertions(+), 1 deletion(-)
 create mode 100644 test/fixedbugs/issue47201.dir/a.go
 create mode 100644 test/fixedbugs/issue47201.dir/b.go
 create mode 100644 test/fixedbugs/issue47201.go

diff --git a/src/cmd/compile/internal/typecheck/dcl.go b/src/cmd/compile/internal/typecheck/dcl.go
index f3058d8811..5b771e3c0b 100644
--- a/src/cmd/compile/internal/typecheck/dcl.go
+++ b/src/cmd/compile/internal/typecheck/dcl.go
@@ -106,7 +106,17 @@ func Export(n *ir.Name) {
 // Redeclared emits a diagnostic about symbol s being redeclared at pos.
 func Redeclared(pos src.XPos, s *types.Sym, where string) {
 	if !s.Lastlineno.IsKnown() {
-		pkgName := DotImportRefs[s.Def.(*ir.Ident)]
+		var pkgName *ir.PkgName
+		if s.Def == nil {
+			for id, pkg := range DotImportRefs {
+				if id.Sym().Name == s.Name {
+					pkgName = pkg
+					break
+				}
+			}
+		} else {
+			pkgName = DotImportRefs[s.Def.(*ir.Ident)]
+		}
 		base.ErrorfAt(pos, "%v redeclared %s\n"+
 			"\t%v: previous declaration during import %q", s, where, base.FmtPos(pkgName.Pos()), pkgName.Pkg.Path)
 	} else {
diff --git a/test/fixedbugs/issue47201.dir/a.go b/test/fixedbugs/issue47201.dir/a.go
new file mode 100644
index 0000000000..54b7079092
--- /dev/null
+++ b/test/fixedbugs/issue47201.dir/a.go
@@ -0,0 +1,13 @@
+// Copyright 2021 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 (
+	. "fmt"
+)
+
+func test() {
+	Println("foo")
+}
diff --git a/test/fixedbugs/issue47201.dir/b.go b/test/fixedbugs/issue47201.dir/b.go
new file mode 100644
index 0000000000..5fd0635af2
--- /dev/null
+++ b/test/fixedbugs/issue47201.dir/b.go
@@ -0,0 +1,9 @@
+// Copyright 2021 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
+
+func Println() {} // ERROR "Println redeclared in this block"
+
+func main() {}
diff --git a/test/fixedbugs/issue47201.go b/test/fixedbugs/issue47201.go
new file mode 100644
index 0000000000..e3a470b419
--- /dev/null
+++ b/test/fixedbugs/issue47201.go
@@ -0,0 +1,7 @@
+// errorcheckdir
+
+// Copyright 2021 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 ignored
-- 
GitLab


From 69728ead871f15cc1fd7e70b67e6768dd1100bae Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Thu, 15 Jul 2021 14:48:45 -0400
Subject: [PATCH 2347/2400] cmd/go: update error messages in tests to match CL
 332573

I neglected to run the 'longtest' builder, and the tests
that cover the error message changed in CL 332573 apparently
do not run in short mode.

Updates #36460
Updates #42661

Change-Id: I53500ddaca8ac9f0dfaab538923b3c9a4f71665e
Reviewed-on: https://go-review.googlesource.com/c/go/+/334889
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/go/testdata/script/mod_tidy_compat_ambiguous.txt    | 2 +-
 src/cmd/go/testdata/script/mod_tidy_compat_deleted.txt      | 2 +-
 src/cmd/go/testdata/script/mod_tidy_compat_implicit.txt     | 2 +-
 src/cmd/go/testdata/script/mod_tidy_compat_incompatible.txt | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/cmd/go/testdata/script/mod_tidy_compat_ambiguous.txt b/src/cmd/go/testdata/script/mod_tidy_compat_ambiguous.txt
index ed1dd53eff..c544cb7413 100644
--- a/src/cmd/go/testdata/script/mod_tidy_compat_ambiguous.txt
+++ b/src/cmd/go/testdata/script/mod_tidy_compat_ambiguous.txt
@@ -23,7 +23,7 @@ cp go.mod go.mod.orig
 
 stderr '^example\.com/m imports\n\texample\.net/indirect imports\n\texample\.net/ambiguous/nested/pkg loaded from example\.net/ambiguous/nested@v0\.1\.0,\n\tbut go 1.16 would fail to locate it:\n\tambiguous import: found package example\.net/ambiguous/nested/pkg in multiple modules:\n\texample\.net/ambiguous v0.1.0 \(.*\)\n\texample\.net/ambiguous/nested v0.1.0 \(.*\)\n\n'
 
-stderr '\n\nTo proceed despite packages unresolved in go 1\.16:\n\tgo mod tidy -e\nIf reproducibility with go 1.16 is not needed:\n\tgo mod tidy -compat=1\.17\nFor other options, see:\n\thttps://golang\.org/wiki/PruningModules\n'
+stderr '\n\nTo proceed despite packages unresolved in go 1\.16:\n\tgo mod tidy -e\nIf reproducibility with go 1.16 is not needed:\n\tgo mod tidy -compat=1\.17\nFor other options, see:\n\thttps://golang\.org/doc/modules/pruning\n'
 
 cmp go.mod go.mod.orig
 
diff --git a/src/cmd/go/testdata/script/mod_tidy_compat_deleted.txt b/src/cmd/go/testdata/script/mod_tidy_compat_deleted.txt
index 3aacde2025..dcf13e2049 100644
--- a/src/cmd/go/testdata/script/mod_tidy_compat_deleted.txt
+++ b/src/cmd/go/testdata/script/mod_tidy_compat_deleted.txt
@@ -19,7 +19,7 @@ cp go.mod go.mod.orig
 
 stderr '^example\.com/m imports\n\texample\.net/deleted loaded from example\.net/deleted@v0\.1\.0,\n\tbut go 1\.16 would fail to locate it in example\.net/deleted@v0\.2\.0\n\n'
 
-stderr '\n\nTo upgrade to the versions selected by go 1.16, leaving some packages unresolved:\n\tgo mod tidy -e -go=1\.16 && go mod tidy -e -go=1\.17\nIf reproducibility with go 1.16 is not needed:\n\tgo mod tidy -compat=1\.17\nFor other options, see:\n\thttps://golang\.org/wiki/PruningModules\n'
+stderr '\n\nTo upgrade to the versions selected by go 1.16, leaving some packages unresolved:\n\tgo mod tidy -e -go=1\.16 && go mod tidy -e -go=1\.17\nIf reproducibility with go 1.16 is not needed:\n\tgo mod tidy -compat=1\.17\nFor other options, see:\n\thttps://golang\.org/doc/modules/pruning\n'
 
 
 # The suggested 'go mod tidy -e' command should proceed anyway.
diff --git a/src/cmd/go/testdata/script/mod_tidy_compat_implicit.txt b/src/cmd/go/testdata/script/mod_tidy_compat_implicit.txt
index e00aea930e..186a3f8e67 100644
--- a/src/cmd/go/testdata/script/mod_tidy_compat_implicit.txt
+++ b/src/cmd/go/testdata/script/mod_tidy_compat_implicit.txt
@@ -33,7 +33,7 @@ env MODFMT='{{with .Module}}{{.Path}} {{.Version}}{{end}}'
 cp go.mod go.mod.orig
 ! go mod tidy
 stderr '^example\.com/m imports\n\texample\.net/lazy tested by\n\texample\.net/lazy.test imports\n\texample\.com/retract/incompatible loaded from example\.com/retract/incompatible@v1\.0\.0,\n\tbut go 1\.16 would select v2\.0\.0\+incompatible\n\n'
-stderr '\n\nTo upgrade to the versions selected by go 1\.16:\n\tgo mod tidy -go=1\.16 && go mod tidy -go=1\.17\nIf reproducibility with go 1.16 is not needed:\n\tgo mod tidy -compat=1.17\nFor other options, see:\n\thttps://golang\.org/wiki/PruningModules\n'
+stderr '\n\nTo upgrade to the versions selected by go 1\.16:\n\tgo mod tidy -go=1\.16 && go mod tidy -go=1\.17\nIf reproducibility with go 1.16 is not needed:\n\tgo mod tidy -compat=1.17\nFor other options, see:\n\thttps://golang\.org/doc/modules/pruning\n'
 
 cmp go.mod go.mod.orig
 
diff --git a/src/cmd/go/testdata/script/mod_tidy_compat_incompatible.txt b/src/cmd/go/testdata/script/mod_tidy_compat_incompatible.txt
index 2d8726544a..ea9e42e87e 100644
--- a/src/cmd/go/testdata/script/mod_tidy_compat_incompatible.txt
+++ b/src/cmd/go/testdata/script/mod_tidy_compat_incompatible.txt
@@ -33,7 +33,7 @@ env MODFMT='{{with .Module}}{{.Path}} {{.Version}}{{end}}'
 cp go.mod go.mod.orig
 ! go mod tidy
 stderr '^example\.com/m imports\n\texample\.net/lazy imports\n\texample\.com/retract/incompatible loaded from example\.com/retract/incompatible@v1\.0\.0,\n\tbut go 1\.16 would select v2\.0\.0\+incompatible\n\n'
-stderr '\n\nTo upgrade to the versions selected by go 1\.16:\n\tgo mod tidy -go=1\.16 && go mod tidy -go=1\.17\nIf reproducibility with go 1\.16 is not needed:\n\tgo mod tidy -compat=1.17\nFor other options, see:\n\thttps://golang\.org/wiki/PruningModules\n'
+stderr '\n\nTo upgrade to the versions selected by go 1\.16:\n\tgo mod tidy -go=1\.16 && go mod tidy -go=1\.17\nIf reproducibility with go 1\.16 is not needed:\n\tgo mod tidy -compat=1.17\nFor other options, see:\n\thttps://golang\.org/doc/modules/pruning\n'
 
 cmp go.mod go.mod.orig
 
-- 
GitLab


From 0941dbca6ae805dd7b5f7871d5811b7b7f14f77f Mon Sep 17 00:00:00 2001
From: "Matt T. Proud" <matt.proud@gmail.com>
Date: Wed, 14 Jul 2021 22:42:31 +0200
Subject: [PATCH 2348/2400] testing: clarify in docs that TestMain is advanced

Beginner and intermediate Go users periodically use TestMain when
requirements do not necessitate TestMain (exceeding least-mechanism
design). This commit expands package testing's documentation to convey
that the TestMain feature itself is somewhat low-level and potentially
unsuitable for casual testing where ordinary test functions would
suffice.

Fixes #42161
Updates #44200

Change-Id: I91ba0b048c3d6f79110fe8f0fbb58d896edca366
Reviewed-on: https://go-review.googlesource.com/c/go/+/334649
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Rob Pike <r@golang.org>
---
 src/testing/testing.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/testing/testing.go b/src/testing/testing.go
index eeee0aac17..681f99ef93 100644
--- a/src/testing/testing.go
+++ b/src/testing/testing.go
@@ -233,6 +233,8 @@
 //		os.Exit(m.Run())
 //	}
 //
+// TestMain is a low-level primitive and should not be necessary for casual
+// testing needs, where ordinary test functions suffice.
 package testing
 
 import (
-- 
GitLab


From aa4e0f528e1e018e2847decb549cfc5ac07ecf20 Mon Sep 17 00:00:00 2001
From: shota3506 <s.shota.710.3506@gmail.com>
Date: Tue, 13 Jul 2021 21:27:05 +0000
Subject: [PATCH 2349/2400] net/http:  correct capitalization in cancelTimeBody
 comment

Change-Id: I7acda22c01c5350ebf5ddabb1c12af96d368de5d
GitHub-Last-Rev: 3e5c022f8764d4abf91c964ceb4fc0e01ebd1352
GitHub-Pull-Request: golang/go#47160
Reviewed-on: https://go-review.googlesource.com/c/go/+/334229
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Cherry Mui <cherryyz@google.com>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
---
 src/net/http/client.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/net/http/client.go b/src/net/http/client.go
index e0cabc9d4c..4d380c65db 100644
--- a/src/net/http/client.go
+++ b/src/net/http/client.go
@@ -951,7 +951,7 @@ func (c *Client) CloseIdleConnections() {
 }
 
 // cancelTimerBody is an io.ReadCloser that wraps rc with two features:
-// 1) on Read error or close, the stop func is called.
+// 1) On Read error or close, the stop func is called.
 // 2) On Read failure, if reqDidTimeout is true, the error is wrapped and
 //    marked as net.Error that hit its timeout.
 type cancelTimerBody struct {
-- 
GitLab


From 650fc2117aaffbc4d596dc35cc88400ba11b2f25 Mon Sep 17 00:00:00 2001
From: mehradsadeghi <2012.linkinpark@gmail.com>
Date: Fri, 16 Jul 2021 21:25:28 +0000
Subject: [PATCH 2350/2400] text/scanner: use Go convention in Position doc
 comment

Change-Id: Ib872f139af7bfb0a75cc21dace5358fe8fcf2cf0
GitHub-Last-Rev: 8fd5ab01fab3bc1d7701092f31071d07ab79acc5
GitHub-Pull-Request: golang/go#47250
Reviewed-on: https://go-review.googlesource.com/c/go/+/335149
Reviewed-by: Robert Griesemer <gri@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Robert Griesemer <gri@golang.org>
---
 src/text/scanner/scanner.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/text/scanner/scanner.go b/src/text/scanner/scanner.go
index e0847a7239..c5fc4ff93b 100644
--- a/src/text/scanner/scanner.go
+++ b/src/text/scanner/scanner.go
@@ -23,7 +23,7 @@ import (
 	"unicode/utf8"
 )
 
-// A source position is represented by a Position value.
+// Position is a value that represents a source position.
 // A position is valid if Line > 0.
 type Position struct {
 	Filename string // filename, if any
-- 
GitLab


From a66190eceeea63aab0b5410ae3222454e5e0cd96 Mon Sep 17 00:00:00 2001
From: nimelehin <nimelehin@gmail.com>
Date: Fri, 16 Jul 2021 20:41:21 +0000
Subject: [PATCH 2351/2400] test/bench/go1: fix size for RegexpMatchMedium_32

Change-Id: Idc67abb95248bc010820a89dd6096a2da334e723
GitHub-Last-Rev: ae9014b011efb2692f853888c1860920d1acc3cb
GitHub-Pull-Request: golang/go#47254
Reviewed-on: https://go-review.googlesource.com/c/go/+/335189
Reviewed-by: Rob Pike <r@golang.org>
Run-TryBot: Rob Pike <r@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Alberto Donizetti <alb.donizetti@gmail.com>
---
 test/bench/go1/regexp_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/bench/go1/regexp_test.go b/test/bench/go1/regexp_test.go
index 3ce9f3a2c6..dd1034fde5 100644
--- a/test/bench/go1/regexp_test.go
+++ b/test/bench/go1/regexp_test.go
@@ -53,7 +53,7 @@ func BenchmarkRegexpMatchEasy0_32(b *testing.B)  { benchmark(b, easy0, 32<<0) }
 func BenchmarkRegexpMatchEasy0_1K(b *testing.B)  { benchmark(b, easy0, 1<<10) }
 func BenchmarkRegexpMatchEasy1_32(b *testing.B)  { benchmark(b, easy1, 32<<0) }
 func BenchmarkRegexpMatchEasy1_1K(b *testing.B)  { benchmark(b, easy1, 1<<10) }
-func BenchmarkRegexpMatchMedium_32(b *testing.B) { benchmark(b, medium, 1<<0) }
+func BenchmarkRegexpMatchMedium_32(b *testing.B) { benchmark(b, medium, 32<<0) }
 func BenchmarkRegexpMatchMedium_1K(b *testing.B) { benchmark(b, medium, 1<<10) }
 func BenchmarkRegexpMatchHard_32(b *testing.B)   { benchmark(b, hard, 32<<0) }
 func BenchmarkRegexpMatchHard_1K(b *testing.B)   { benchmark(b, hard, 1<<10) }
-- 
GitLab


From 49402bee36fd3d5cee9f4b2d2e1e8560ead0203b Mon Sep 17 00:00:00 2001
From: Than McIntosh <thanm@google.com>
Date: Thu, 15 Jul 2021 16:29:36 -0400
Subject: [PATCH 2352/2400] cmd/{compile,link}: fix bug in map.zero handling

In CL 326211 a change was made to switch "go.map.zero" symbols from
non-pkg DUPOK symbols to hashed symbols. The intent of this change was
ensure that in cases where there are multiple competing go.map.zero
symbols feeding into a link, the largest map.zero symbol is selected.
The change was buggy, however, and resulted in duplicate symbols in
the final binary (see bug cited below for details). This duplication
was relatively benign for linux/ELF, but causes duplicate definition
errors on Windows.

This patch switches "go.map.zero" symbols back from hashed symbols to
non-pkg DUPOK symbols, and updates the relevant code in the loader to
ensure that we do the right thing when there are multiple competing
DUPOK symbols with different sizes.

Fixes #47185.

Change-Id: I8aeb910c65827f5380144d07646006ba553c9251
Reviewed-on: https://go-review.googlesource.com/c/go/+/334930
Trust: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 src/cmd/compile/internal/gc/obj.go       |  2 +-
 src/cmd/link/internal/loader/loader.go   |  9 +++
 test/fixedbugs/issue47185.dir/bad/bad.go | 72 ++++++++++++++++++++++++
 test/fixedbugs/issue47185.dir/main.go    | 28 +++++++++
 test/fixedbugs/issue47185.go             | 11 ++++
 5 files changed, 121 insertions(+), 1 deletion(-)
 create mode 100644 test/fixedbugs/issue47185.dir/bad/bad.go
 create mode 100644 test/fixedbugs/issue47185.dir/main.go
 create mode 100644 test/fixedbugs/issue47185.go

diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 55a0ab7da7..474d718525 100644
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -148,7 +148,7 @@ func dumpdata() {
 	if reflectdata.ZeroSize > 0 {
 		zero := base.PkgLinksym("go.map", "zero", obj.ABI0)
 		objw.Global(zero, int32(reflectdata.ZeroSize), obj.DUPOK|obj.RODATA)
-		zero.Set(obj.AttrContentAddressable, true)
+		zero.Set(obj.AttrStatic, true)
 	}
 
 	staticdata.WriteFuncSyms()
diff --git a/src/cmd/link/internal/loader/loader.go b/src/cmd/link/internal/loader/loader.go
index efca824d98..9d5319c312 100644
--- a/src/cmd/link/internal/loader/loader.go
+++ b/src/cmd/link/internal/loader/loader.go
@@ -459,6 +459,15 @@ func (st *loadState) addSym(name string, ver int, r *oReader, li uint32, kind in
 		if l.flags&FlagStrictDups != 0 {
 			l.checkdup(name, r, li, oldi)
 		}
+		// Fix for issue #47185 -- given two dupok symbols with
+		// different sizes, favor symbol with larger size. See
+		// also issue #46653.
+		szdup := l.SymSize(oldi)
+		sz := int64(r.Sym(li).Siz())
+		if szdup < sz {
+			// new symbol overwrites old symbol.
+			l.objSyms[oldi] = objSym{r.objidx, li}
+		}
 		return oldi
 	}
 	oldr, oldli := l.toLocal(oldi)
diff --git a/test/fixedbugs/issue47185.dir/bad/bad.go b/test/fixedbugs/issue47185.dir/bad/bad.go
new file mode 100644
index 0000000000..1aa4fbb909
--- /dev/null
+++ b/test/fixedbugs/issue47185.dir/bad/bad.go
@@ -0,0 +1,72 @@
+// Copyright 2021 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 a
+
+// Note that the use of CGO here is solely to trigger external
+// linking, since that is required to trigger that bad behavior
+// in this bug.
+
+// #include <stdlib.h>
+import "C"
+
+func Bad() {
+	m := make(map[int64]A)
+	a := m[0]
+	if len(a.B.C1.D2.E2.F1) != 0 ||
+		len(a.B.C1.D2.E2.F2) != 0 ||
+		len(a.B.C1.D2.E2.F3) != 0 ||
+		len(a.B.C1.D2.E2.F4) != 0 ||
+		len(a.B.C1.D2.E2.F5) != 0 ||
+		len(a.B.C1.D2.E2.F6) != 0 ||
+		len(a.B.C1.D2.E2.F7) != 0 ||
+		len(a.B.C1.D2.E2.F8) != 0 ||
+		len(a.B.C1.D2.E2.F9) != 0 ||
+		len(a.B.C1.D2.E2.F10) != 0 ||
+		len(a.B.C1.D2.E2.F11) != 0 ||
+		len(a.B.C1.D2.E2.F16) != 0 {
+		panic("bad")
+	}
+	C.malloc(100)
+}
+
+type A struct {
+	B
+}
+
+type B struct {
+	C1 C
+	C2 C
+}
+
+type C struct {
+	D1 D
+	D2 D
+}
+
+type D struct {
+	E1 E
+	E2 E
+	E3 E
+	E4 E
+}
+
+type E struct {
+	F1  string
+	F2  string
+	F3  string
+	F4  string
+	F5  string
+	F6  string
+	F7  string
+	F8  string
+	F9  string
+	F10 string
+	F11 string
+	F12 string
+	F13 string
+	F14 string
+	F15 string
+	F16 string
+}
diff --git a/test/fixedbugs/issue47185.dir/main.go b/test/fixedbugs/issue47185.dir/main.go
new file mode 100644
index 0000000000..7b46e55d8b
--- /dev/null
+++ b/test/fixedbugs/issue47185.dir/main.go
@@ -0,0 +1,28 @@
+// Copyright 2021 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 (
+	bad "issue47185.dir/bad"
+)
+
+func main() {
+	another()
+	bad.Bad()
+}
+
+func another() L {
+	m := make(map[string]L)
+	return m[""]
+}
+
+type L struct {
+	A Data
+	B Data
+}
+
+type Data struct {
+	F1 [22][]string
+}
diff --git a/test/fixedbugs/issue47185.go b/test/fixedbugs/issue47185.go
new file mode 100644
index 0000000000..9c921b8698
--- /dev/null
+++ b/test/fixedbugs/issue47185.go
@@ -0,0 +1,11 @@
+// +build cgo
+// runindir
+
+// Copyright 2021 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.
+
+// Another test to verify compiler and linker handling of multiple
+// competing map.zero symbol definitions.
+
+package ignored
-- 
GitLab


From 6298cfe6724e3ca24dedd3f62b2b358aafe17276 Mon Sep 17 00:00:00 2001
From: Leonard Wang <wangdeyu0907@gmail.com>
Date: Sun, 11 Jul 2021 11:46:26 +0800
Subject: [PATCH 2353/2400] cmd/compile: fix typo in fatal message of
 builtinCall

Change-Id: I523d5fd810b82154a204670d46fc250a0fc66791
Reviewed-on: https://go-review.googlesource.com/c/go/+/333849
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/cmd/compile/internal/typecheck/iimport.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index a5ddbb5a74..37f5a7bba0 100644
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -1540,7 +1540,7 @@ func (r *importReader) exprsOrNil() (a, b ir.Node) {
 func builtinCall(pos src.XPos, op ir.Op) *ir.CallExpr {
 	if go117ExportTypes {
 		// These should all be encoded as direct ops, not OCALL.
-		base.Fatalf("builtinCall should not be invoked when types are included in inport/export")
+		base.Fatalf("builtinCall should not be invoked when types are included in import/export")
 	}
 	return ir.NewCallExpr(pos, ir.OCALL, ir.NewIdent(base.Pos, types.BuiltinPkg.Lookup(ir.OpNames[op])), nil)
 }
-- 
GitLab


From 404127c30f3f66eb234da2dc1a78e6eea0ef4ee0 Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Wed, 14 Jul 2021 18:52:44 -0400
Subject: [PATCH 2354/2400] cmd/compile: fix off-by-one error in traceback
 argument counting

For traceback argument printing, we want to print at most 10
words, then print "..." if there are still more args and/or
fields. The current code has off-by-one error that for 11
non-aggregate typed args, it prints the first 10 but without the
"...". Also, for aggregate-typed args, in some cases it may print
an extra "..." when there is actually no more fields.

The problem for this is that visitType return false (meaning not
to continue visiting) if it reaches the limit anywhere during the
recursive visit. It doesn't distinguish whether it has printed
anything for the current arg. If it reaches the limit before it
prints anything, it means that we're visiting the extra arg/field,
so the caller should print "..." and stop. If it prints
something then reaches the limit, however, the caller should keep
going, and only print "..." at the next iteration when there is
actually an extra arg/field. This CL does so.

Fixes #47159.

Change-Id: I93fc25b73ada2b5a98df780c45e5b0c9565dc2fc
Reviewed-on: https://go-review.googlesource.com/c/go/+/334710
Trust: Cherry Mui <cherryyz@google.com>
Run-TryBot: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/cmd/compile/internal/ssagen/ssa.go |  43 +++---
 src/runtime/traceback_test.go          | 179 ++++++++++++++++++++++++-
 2 files changed, 190 insertions(+), 32 deletions(-)

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index f1dc56e729..a5cb0857b3 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -6598,6 +6598,7 @@ func EmitArgInfo(f *ir.Func, abiInfo *abi.ABIParamResultInfo) *obj.LSym {
 	x := base.Ctxt.Lookup(fmt.Sprintf("%s.arginfo%d", f.LSym.Name, f.ABI))
 
 	PtrSize := int64(types.PtrSize)
+	uintptrTyp := types.Types[types.TUINTPTR]
 
 	isAggregate := func(t *types.Type) bool {
 		return t.IsStruct() || t.IsArray() || t.IsComplex() || t.IsInterface() || t.IsString() || t.IsSlice()
@@ -6641,12 +6642,8 @@ func EmitArgInfo(f *ir.Func, abiInfo *abi.ABIParamResultInfo) *obj.LSym {
 	n := 0
 	writebyte := func(o uint8) { wOff = objw.Uint8(x, wOff, o) }
 
-	// Write one non-aggrgate arg/field/element if there is room.
-	// Returns whether to continue.
-	write1 := func(sz, offset int64) bool {
-		if n >= limit {
-			return false
-		}
+	// Write one non-aggrgate arg/field/element.
+	write1 := func(sz, offset int64) {
 		if offset >= _special {
 			writebyte(_offsetTooLarge)
 		} else {
@@ -6654,7 +6651,6 @@ func EmitArgInfo(f *ir.Func, abiInfo *abi.ABIParamResultInfo) *obj.LSym {
 			writebyte(uint8(sz))
 		}
 		n++
-		return true
 	}
 
 	// Visit t recursively and write it out.
@@ -6662,10 +6658,12 @@ func EmitArgInfo(f *ir.Func, abiInfo *abi.ABIParamResultInfo) *obj.LSym {
 	var visitType func(baseOffset int64, t *types.Type, depth int) bool
 	visitType = func(baseOffset int64, t *types.Type, depth int) bool {
 		if n >= limit {
+			writebyte(_dotdotdot)
 			return false
 		}
 		if !isAggregate(t) {
-			return write1(t.Size(), baseOffset)
+			write1(t.Size(), baseOffset)
+			return true
 		}
 		writebyte(_startAgg)
 		depth++
@@ -6675,58 +6673,47 @@ func EmitArgInfo(f *ir.Func, abiInfo *abi.ABIParamResultInfo) *obj.LSym {
 			n++
 			return true
 		}
-		var r bool
 		switch {
 		case t.IsInterface(), t.IsString():
-			r = write1(PtrSize, baseOffset) &&
-				write1(PtrSize, baseOffset+PtrSize)
+			_ = visitType(baseOffset, uintptrTyp, depth) &&
+				visitType(baseOffset+PtrSize, uintptrTyp, depth)
 		case t.IsSlice():
-			r = write1(PtrSize, baseOffset) &&
-				write1(PtrSize, baseOffset+PtrSize) &&
-				write1(PtrSize, baseOffset+PtrSize*2)
+			_ = visitType(baseOffset, uintptrTyp, depth) &&
+				visitType(baseOffset+PtrSize, uintptrTyp, depth) &&
+				visitType(baseOffset+PtrSize*2, uintptrTyp, depth)
 		case t.IsComplex():
-			r = write1(t.Size()/2, baseOffset) &&
-				write1(t.Size()/2, baseOffset+t.Size()/2)
+			_ = visitType(baseOffset, types.FloatForComplex(t), depth) &&
+				visitType(baseOffset+t.Size()/2, types.FloatForComplex(t), depth)
 		case t.IsArray():
-			r = true
 			if t.NumElem() == 0 {
 				n++ // {} counts as a component
 				break
 			}
 			for i := int64(0); i < t.NumElem(); i++ {
 				if !visitType(baseOffset, t.Elem(), depth) {
-					r = false
 					break
 				}
 				baseOffset += t.Elem().Size()
 			}
 		case t.IsStruct():
-			r = true
 			if t.NumFields() == 0 {
 				n++ // {} counts as a component
 				break
 			}
 			for _, field := range t.Fields().Slice() {
 				if !visitType(baseOffset+field.Offset, field.Type, depth) {
-					r = false
 					break
 				}
 			}
 		}
-		if !r {
-			writebyte(_dotdotdot)
-		}
 		writebyte(_endAgg)
-		return r
+		return true
 	}
 
-	c := true
 	for _, a := range abiInfo.InParams() {
-		if !c {
-			writebyte(_dotdotdot)
+		if !visitType(a.FrameOffset(abiInfo), a.Type, 0) {
 			break
 		}
-		c = visitType(a.FrameOffset(abiInfo), a.Type, 0)
 	}
 	writebyte(_endSeq)
 	if wOff > maxLen {
diff --git a/src/runtime/traceback_test.go b/src/runtime/traceback_test.go
index 2a0497e9a9..83b86a7e90 100644
--- a/src/runtime/traceback_test.go
+++ b/src/runtime/traceback_test.go
@@ -19,8 +19,8 @@ func TestTracebackArgs(t *testing.T) {
 	}{
 		// simple ints
 		{
-			func() int { return testTracebackArgs1(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12) },
-			"testTracebackArgs1(0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, ...)",
+			func() int { return testTracebackArgs1(1, 2, 3, 4, 5) },
+			"testTracebackArgs1(0x1, 0x2, 0x3, 0x4, 0x5)",
 		},
 		// some aggregates
 		{
@@ -53,6 +53,58 @@ func TestTracebackArgs(t *testing.T) {
 			},
 			"testTracebackArgs5(0x0, {0x1, {}, {{}, {}}}, {}, {}, {}, {}, {}, ...)",
 		},
+
+		// edge cases for ...
+		// no ... for 10 args
+		{
+			func() int { return testTracebackArgs6a(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) },
+			"testTracebackArgs6a(0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa)",
+		},
+		// has ... for 11 args
+		{
+			func() int { return testTracebackArgs6b(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11) },
+			"testTracebackArgs6b(0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, ...)",
+		},
+		// no ... for aggregates with 10 words
+		{
+			func() int { return testTracebackArgs7a([10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) },
+			"testTracebackArgs7a({0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa})",
+		},
+		// has ... for aggregates with 11 words
+		{
+			func() int { return testTracebackArgs7b([11]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}) },
+			"testTracebackArgs7b({0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, ...})",
+		},
+		// no ... for aggregates, but with more args
+		{
+			func() int { return testTracebackArgs7c([10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 11) },
+			"testTracebackArgs7c({0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa}, ...)",
+		},
+		// has ... for aggregates and also for more args
+		{
+			func() int { return testTracebackArgs7d([11]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, 12) },
+			"testTracebackArgs7d({0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, ...}, ...)",
+		},
+		// nested aggregates, no ...
+		{
+			func() int { return testTracebackArgs8a(testArgsType8a{1, 2, 3, 4, 5, 6, 7, 8, [2]int{9, 10}}) },
+			"testTracebackArgs8a({0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, {0x9, 0xa}})",
+		},
+		// nested aggregates, ... in inner but not outer
+		{
+			func() int { return testTracebackArgs8b(testArgsType8b{1, 2, 3, 4, 5, 6, 7, 8, [3]int{9, 10, 11}}) },
+			"testTracebackArgs8b({0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, {0x9, 0xa, ...}})",
+		},
+		// nested aggregates, ... in outer but not inner
+		{
+			func() int { return testTracebackArgs8c(testArgsType8c{1, 2, 3, 4, 5, 6, 7, 8, [2]int{9, 10}, 11}) },
+			"testTracebackArgs8c({0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, {0x9, 0xa}, ...})",
+		},
+		// nested aggregates, ... in both inner and outer
+		{
+			func() int { return testTracebackArgs8d(testArgsType8d{1, 2, 3, 4, 5, 6, 7, 8, [3]int{9, 10, 11}, 12}) },
+			"testTracebackArgs8d({0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, {0x9, 0xa, ...}, ...})",
+		},
 	}
 	for _, test := range tests {
 		n := test.fn()
@@ -64,11 +116,11 @@ func TestTracebackArgs(t *testing.T) {
 }
 
 //go:noinline
-func testTracebackArgs1(a, b, c, d, e, f, g, h, i, j, k, l int) int {
+func testTracebackArgs1(a, b, c, d, e int) int {
 	n := runtime.Stack(testTracebackArgsBuf[:], false)
 	if a < 0 {
 		// use in-reg args to keep them alive
-		return a + b + c + d + e + f + g + h + i + j + k + l
+		return a + b + c + d + e
 	}
 	return n
 }
@@ -119,3 +171,122 @@ func testTracebackArgs5(a bool, x struct {
 	}
 	return n
 }
+
+//go:noinline
+func testTracebackArgs6a(a, b, c, d, e, f, g, h, i, j int) int {
+	n := runtime.Stack(testTracebackArgsBuf[:], false)
+	if a < 0 {
+		// use in-reg args to keep them alive
+		return a + b + c + d + e + f + g + h + i + j
+	}
+	return n
+}
+
+//go:noinline
+func testTracebackArgs6b(a, b, c, d, e, f, g, h, i, j, k int) int {
+	n := runtime.Stack(testTracebackArgsBuf[:], false)
+	if a < 0 {
+		// use in-reg args to keep them alive
+		return a + b + c + d + e + f + g + h + i + j + k
+	}
+	return n
+}
+
+//go:noinline
+func testTracebackArgs7a(a [10]int) int {
+	n := runtime.Stack(testTracebackArgsBuf[:], false)
+	if a[0] < 0 {
+		// use in-reg args to keep them alive
+		return a[1] + a[2] + a[3] + a[4] + a[5] + a[6] + a[7] + a[8] + a[9]
+	}
+	return n
+}
+
+//go:noinline
+func testTracebackArgs7b(a [11]int) int {
+	n := runtime.Stack(testTracebackArgsBuf[:], false)
+	if a[0] < 0 {
+		// use in-reg args to keep them alive
+		return a[1] + a[2] + a[3] + a[4] + a[5] + a[6] + a[7] + a[8] + a[9] + a[10]
+	}
+	return n
+}
+
+//go:noinline
+func testTracebackArgs7c(a [10]int, b int) int {
+	n := runtime.Stack(testTracebackArgsBuf[:], false)
+	if a[0] < 0 {
+		// use in-reg args to keep them alive
+		return a[1] + a[2] + a[3] + a[4] + a[5] + a[6] + a[7] + a[8] + a[9] + b
+	}
+	return n
+}
+
+//go:noinline
+func testTracebackArgs7d(a [11]int, b int) int {
+	n := runtime.Stack(testTracebackArgsBuf[:], false)
+	if a[0] < 0 {
+		// use in-reg args to keep them alive
+		return a[1] + a[2] + a[3] + a[4] + a[5] + a[6] + a[7] + a[8] + a[9] + a[10] + b
+	}
+	return n
+}
+
+type testArgsType8a struct {
+	a, b, c, d, e, f, g, h int
+	i                      [2]int
+}
+type testArgsType8b struct {
+	a, b, c, d, e, f, g, h int
+	i                      [3]int
+}
+type testArgsType8c struct {
+	a, b, c, d, e, f, g, h int
+	i                      [2]int
+	j                      int
+}
+type testArgsType8d struct {
+	a, b, c, d, e, f, g, h int
+	i                      [3]int
+	j                      int
+}
+
+//go:noinline
+func testTracebackArgs8a(a testArgsType8a) int {
+	n := runtime.Stack(testTracebackArgsBuf[:], false)
+	if a.a < 0 {
+		// use in-reg args to keep them alive
+		return a.b + a.c + a.d + a.e + a.f + a.g + a.h + a.i[0] + a.i[1]
+	}
+	return n
+}
+
+//go:noinline
+func testTracebackArgs8b(a testArgsType8b) int {
+	n := runtime.Stack(testTracebackArgsBuf[:], false)
+	if a.a < 0 {
+		// use in-reg args to keep them alive
+		return a.b + a.c + a.d + a.e + a.f + a.g + a.h + a.i[0] + a.i[1] + a.i[2]
+	}
+	return n
+}
+
+//go:noinline
+func testTracebackArgs8c(a testArgsType8c) int {
+	n := runtime.Stack(testTracebackArgsBuf[:], false)
+	if a.a < 0 {
+		// use in-reg args to keep them alive
+		return a.b + a.c + a.d + a.e + a.f + a.g + a.h + a.i[0] + a.i[1] + a.j
+	}
+	return n
+}
+
+//go:noinline
+func testTracebackArgs8d(a testArgsType8d) int {
+	n := runtime.Stack(testTracebackArgsBuf[:], false)
+	if a.a < 0 {
+		// use in-reg args to keep them alive
+		return a.b + a.c + a.d + a.e + a.f + a.g + a.h + a.i[0] + a.i[1] + a.i[2] + a.j
+	}
+	return n
+}
-- 
GitLab


From 1d91551b7326383343c7c143a8ac299d0a685289 Mon Sep 17 00:00:00 2001
From: helloPiers <git@hellopiers.io>
Date: Mon, 19 Jul 2021 20:08:50 +0000
Subject: [PATCH 2355/2400] time: correct typo in documentation for UnixMicro

Fixes #47283.

Change-Id: Ibdc35433d22be3caa70197b6a95c66999812a16a
GitHub-Last-Rev: 75962b029467a5e26e1ee78a38bf01c954445ea1
GitHub-Pull-Request: golang/go#47284
Reviewed-on: https://go-review.googlesource.com/c/go/+/335549
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Than McIntosh <thanm@google.com>
---
 src/time/time.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/time/time.go b/src/time/time.go
index 1cf1e2bbf6..4ecc3d82dc 100644
--- a/src/time/time.go
+++ b/src/time/time.go
@@ -1334,7 +1334,7 @@ func UnixMilli(msec int64) Time {
 }
 
 // UnixMicro returns the local Time corresponding to the given Unix time,
-// usec milliseconds since January 1, 1970 UTC.
+// usec microseconds since January 1, 1970 UTC.
 func UnixMicro(usec int64) Time {
 	return Unix(usec/1e6, (usec%1e6)*1e3)
 }
-- 
GitLab


From c8f4e6152d5f0b767a8177b7d09884cf2279d8e6 Mon Sep 17 00:00:00 2001
From: Piers <helloPiers@users.noreply.github.com>
Date: Mon, 19 Jul 2021 20:11:29 +0000
Subject: [PATCH 2356/2400] spec: correct example comment in Conversions from
 slice to array

Fixes #47280

Change-Id: I78a8d235949b4878c7f075ac4ca37700e7e6c31c
GitHub-Last-Rev: 067f96eeb2c918eb4f775c428edc945c75af44d8
GitHub-Pull-Request: golang/go#47282
Reviewed-on: https://go-review.googlesource.com/c/go/+/335470
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Trust: Than McIntosh <thanm@google.com>
---
 doc/go_spec.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index ad21ffb1b8..df256f0f0e 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -4334,7 +4334,7 @@ s4 := (*[4]byte)(s)      // panics: len([4]byte) > len(s)
 
 var t []string
 t0 := (*[0]string)(t)    // t0 == nil
-t1 := (*[1]string)(t)    // panics: len([1]string) > len(s)
+t1 := (*[1]string)(t)    // panics: len([1]string) > len(t)
 </pre>
 
 <h3 id="Constant_expressions">Constant expressions</h3>
-- 
GitLab


From d568e6e075e6434635268d3caf55963f4e564579 Mon Sep 17 00:00:00 2001
From: Benny Siegert <bsiegert@google.com>
Date: Tue, 20 Jul 2021 09:36:08 -0400
Subject: [PATCH 2357/2400] runtime/debug: skip TestPanicOnFault on netbsd/arm

This test has been failing since the builder was updated to
NetBSD 9. While the issue is under investigation, skip the test
so that we do not miss other breakage.

Update issue #45026

Change-Id: Id083901c517f3f88e6b4bc2b51208f65170d47a6
Reviewed-on: https://go-review.googlesource.com/c/go/+/335909
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Keith Randall <khr@golang.org>
Trust: Benny Siegert <bsiegert@gmail.com>
Run-TryBot: Benny Siegert <bsiegert@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/runtime/debug/panic_test.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/runtime/debug/panic_test.go b/src/runtime/debug/panic_test.go
index b93631e1d8..65f9555f37 100644
--- a/src/runtime/debug/panic_test.go
+++ b/src/runtime/debug/panic_test.go
@@ -24,6 +24,9 @@ func TestPanicOnFault(t *testing.T) {
 	if runtime.GOOS == "ios" {
 		t.Skip("iOS doesn't provide fault addresses")
 	}
+	if runtime.GOOS == "netbsd" && runtime.GOARCH == "arm" {
+		t.Skip("netbsd-arm doesn't provide fault address (golang.org/issue/45026)")
+	}
 	m, err := syscall.Mmap(-1, 0, 0x1000, syscall.PROT_READ /* Note: no PROT_WRITE */, syscall.MAP_SHARED|syscall.MAP_ANON)
 	if err != nil {
 		t.Fatalf("can't map anonymous memory: %s", err)
-- 
GitLab


From 9e26569293c13974d210fd588ebfd29b857d8525 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Sun, 18 Jul 2021 13:58:13 -0700
Subject: [PATCH 2358/2400] cmd/go: don't add C compiler ID to hash for
 standard library

No test because a real test requires installing two different compilers.

For #40042
For #47251

Change-Id: Iefddd67830d242a119378b7ce20be481904806e4
Reviewed-on: https://go-review.googlesource.com/c/go/+/335409
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/go_test.go            | 32 ++++++++++++++++++++++++++++++++
 src/cmd/go/internal/work/exec.go | 11 +++++++++--
 2 files changed, 41 insertions(+), 2 deletions(-)

diff --git a/src/cmd/go/go_test.go b/src/cmd/go/go_test.go
index c0c86ab9f5..6ce276537b 100644
--- a/src/cmd/go/go_test.go
+++ b/src/cmd/go/go_test.go
@@ -2848,3 +2848,35 @@ func TestExecInDeletedDir(t *testing.T) {
 	// `go version` should not fail
 	tg.run("version")
 }
+
+// A missing C compiler should not force the net package to be stale.
+// Issue 47215.
+func TestMissingCC(t *testing.T) {
+	if !canCgo {
+		t.Skip("test is only meaningful on systems with cgo")
+	}
+	cc := os.Getenv("CC")
+	if cc == "" {
+		cc = "gcc"
+	}
+	if filepath.IsAbs(cc) {
+		t.Skipf(`"CC" (%s) is an absolute path`, cc)
+	}
+	_, err := exec.LookPath(cc)
+	if err != nil {
+		t.Skipf(`"CC" (%s) not on PATH`, cc)
+	}
+
+	tg := testgo(t)
+	defer tg.cleanup()
+	netStale, _ := tg.isStale("net")
+	if netStale {
+		t.Skip(`skipping test because "net" package is currently stale`)
+	}
+
+	tg.setenv("PATH", "") // No C compiler on PATH.
+	netStale, _ = tg.isStale("net")
+	if netStale {
+		t.Error(`clearing "PATH" causes "net" to be stale`)
+	}
+}
diff --git a/src/cmd/go/internal/work/exec.go b/src/cmd/go/internal/work/exec.go
index b506b83656..5a225fb9f1 100644
--- a/src/cmd/go/internal/work/exec.go
+++ b/src/cmd/go/internal/work/exec.go
@@ -252,8 +252,15 @@ func (b *Builder) buildActionID(a *Action) cache.ActionID {
 
 		ccExe := b.ccExe()
 		fmt.Fprintf(h, "CC=%q %q %q %q\n", ccExe, cppflags, cflags, ldflags)
-		if ccID, err := b.gccToolID(ccExe[0], "c"); err == nil {
-			fmt.Fprintf(h, "CC ID=%q\n", ccID)
+		// Include the C compiler tool ID so that if the C
+		// compiler changes we rebuild the package.
+		// But don't do that for standard library packages like net,
+		// so that the prebuilt .a files from a Go binary install
+		// don't need to be rebuilt with the local compiler.
+		if !p.Standard {
+			if ccID, err := b.gccToolID(ccExe[0], "c"); err == nil {
+				fmt.Fprintf(h, "CC ID=%q\n", ccID)
+			}
 		}
 		if len(p.CXXFiles)+len(p.SwigCXXFiles) > 0 {
 			cxxExe := b.cxxExe()
-- 
GitLab


From 48c88f1b1bac1ef4fc81246a7f31933f8f922706 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Wed, 14 Jul 2021 14:46:09 -0700
Subject: [PATCH 2359/2400] reflect: add Value.CanConvert

For #395
For #46746

Change-Id: I4bfc094cf1cecd27ce48e31f92384cf470f371a6
Reviewed-on: https://go-review.googlesource.com/c/go/+/334669
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
---
 api/go1.17.txt          |  1 +
 doc/go1.17.html         | 12 ++++++++++++
 src/reflect/all_test.go |  9 +++++++++
 src/reflect/value.go    | 20 ++++++++++++++++++++
 4 files changed, 42 insertions(+)

diff --git a/api/go1.17.txt b/api/go1.17.txt
index 3d0a464fec..48505381f1 100644
--- a/api/go1.17.txt
+++ b/api/go1.17.txt
@@ -80,6 +80,7 @@ pkg net/url, method (Values) Has(string) bool
 pkg reflect, func VisibleFields(Type) []StructField
 pkg reflect, method (Method) IsExported() bool
 pkg reflect, method (StructField) IsExported() bool
+pkg reflect, method (Value) CanConvert(Type) bool
 pkg runtime/cgo (darwin-amd64-cgo), func NewHandle(interface{}) Handle
 pkg runtime/cgo (darwin-amd64-cgo), method (Handle) Delete()
 pkg runtime/cgo (darwin-amd64-cgo), method (Handle) Value() interface{}
diff --git a/doc/go1.17.html b/doc/go1.17.html
index b31006fe65..7739d1c62e 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -989,6 +989,18 @@ func Foo() bool {
 
 <dl id="reflect"><dt><a href="/pkg/reflect/">reflect</a></dt>
   <dd>
+    <p><!-- CL 334669 -->
+      The new
+      <a href="/pkg/reflect/#Value.CanConvert"><code>Value.CanConvert</code></a>
+      method reports whether a value can be converted to a type.
+      This may be used to avoid a panic when converting a slice to an
+      array pointer type if the slice is too short.
+      Previously it was sufficient to use
+      <a href="/pkg/reflect/#Type.ConvertibleTo"><code>Type.ConvertibleTo</code></a>
+      for this, but the newly permitted conversion from slice to array
+      pointer type can panic even if the types are convertible.
+    </p>
+
     <p><!-- CL 266197 -->
       The new
       <a href="/pkg/reflect/#StructField.IsExported"><code>StructField.IsExported</code></a>
diff --git a/src/reflect/all_test.go b/src/reflect/all_test.go
index 0db5e13217..eac27e886f 100644
--- a/src/reflect/all_test.go
+++ b/src/reflect/all_test.go
@@ -4304,6 +4304,9 @@ func TestConvert(t *testing.T) {
 
 		// vout1 represents the in value converted to the in type.
 		v1 := tt.in
+		if !v1.CanConvert(t1) {
+			t.Errorf("ValueOf(%T(%[1]v)).CanConvert(%s) = false, want true", tt.in.Interface(), t1)
+		}
 		vout1 := v1.Convert(t1)
 		out1 := vout1.Interface()
 		if vout1.Type() != tt.in.Type() || !DeepEqual(out1, tt.in.Interface()) {
@@ -4311,6 +4314,9 @@ func TestConvert(t *testing.T) {
 		}
 
 		// vout2 represents the in value converted to the out type.
+		if !v1.CanConvert(t2) {
+			t.Errorf("ValueOf(%T(%[1]v)).CanConvert(%s) = false, want true", tt.in.Interface(), t2)
+		}
 		vout2 := v1.Convert(t2)
 		out2 := vout2.Interface()
 		if vout2.Type() != tt.out.Type() || !DeepEqual(out2, tt.out.Interface()) {
@@ -4371,6 +4377,9 @@ func TestConvertPanic(t *testing.T) {
 	if !v.Type().ConvertibleTo(pt) {
 		t.Errorf("[]byte should be convertible to *[8]byte")
 	}
+	if v.CanConvert(pt) {
+		t.Errorf("slice with length 4 should not be convertible to *[8]byte")
+	}
 	shouldPanic("reflect: cannot convert slice with length 4 to pointer to array with length 8", func() {
 		_ = v.Convert(pt)
 	})
diff --git a/src/reflect/value.go b/src/reflect/value.go
index 9dce251ac5..6f878eba5b 100644
--- a/src/reflect/value.go
+++ b/src/reflect/value.go
@@ -2811,6 +2811,26 @@ func (v Value) Convert(t Type) Value {
 	return op(v, t)
 }
 
+// CanConvert reports whether the value v can be converted to type t.
+// If v.CanConvert(t) returns true then v.Convert(t) will not panic.
+func (v Value) CanConvert(t Type) bool {
+	vt := v.Type()
+	if !vt.ConvertibleTo(t) {
+		return false
+	}
+	// Currently the only conversion that is OK in terms of type
+	// but that can panic depending on the value is converting
+	// from slice to pointer-to-array.
+	if vt.Kind() == Slice && t.Kind() == Ptr && t.Elem().Kind() == Array {
+		n := t.Elem().Len()
+		h := (*unsafeheader.Slice)(v.ptr)
+		if n > h.Len {
+			return false
+		}
+	}
+	return true
+}
+
 // convertOp returns the function to convert a value of type src
 // to a value of type dst. If the conversion is illegal, convertOp returns nil.
 func convertOp(dst, src *rtype) func(Value, Type) Value {
-- 
GitLab


From 3e48c0381fd1beb78e993e940c3b46ca9898ce6d Mon Sep 17 00:00:00 2001
From: wdvxdr <wdvxdr1123@gmail.com>
Date: Wed, 21 Jul 2021 11:59:45 +0800
Subject: [PATCH 2360/2400] reflect: add missing copyright header

Change-Id: I5a2f7203f83be02b03aa7be5fe386e485bf68ca3
Reviewed-on: https://go-review.googlesource.com/c/go/+/336189
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Robert Findley <rfindley@google.com>
---
 src/reflect/visiblefields.go      | 4 ++++
 src/reflect/visiblefields_test.go | 4 ++++
 2 files changed, 8 insertions(+)

diff --git a/src/reflect/visiblefields.go b/src/reflect/visiblefields.go
index c068979dcc..1a2b53570b 100644
--- a/src/reflect/visiblefields.go
+++ b/src/reflect/visiblefields.go
@@ -1,3 +1,7 @@
+// Copyright 2021 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 reflect
 
 // VisibleFields returns all the visible fields in t, which must be a
diff --git a/src/reflect/visiblefields_test.go b/src/reflect/visiblefields_test.go
index 2688b63091..915bbee867 100644
--- a/src/reflect/visiblefields_test.go
+++ b/src/reflect/visiblefields_test.go
@@ -1,3 +1,7 @@
+// Copyright 2021 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 reflect_test
 
 import (
-- 
GitLab


From fdb45acd1f062884c77ea6961fb638e004af1b8e Mon Sep 17 00:00:00 2001
From: David Chase <drchase@google.com>
Date: Wed, 21 Jul 2021 18:38:05 -0400
Subject: [PATCH 2361/2400] runtime: move mem profile sampling into m-acquired
 section

It was not safe to do mcache profiling updates outside the critical
section, but we got lucky because the runtime was not preemptible.
Adding chunked memory clearing (CL 270943) created preemption
opportunities, which led to corruption of runtime data structures.

Fixes #47304.
Fixes #47302.

Change-Id: I461615470d62328a83ccbac537fbdc6dcde81c85
Reviewed-on: https://go-review.googlesource.com/c/go/+/336449
Trust: David Chase <drchase@google.com>
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Austin Clements <austin@google.com>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/runtime/malloc.go | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/src/runtime/malloc.go b/src/runtime/malloc.go
index 2759bbdaf9..cc22b0f276 100644
--- a/src/runtime/malloc.go
+++ b/src/runtime/malloc.go
@@ -1135,13 +1135,21 @@ func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 		msanmalloc(x, size)
 	}
 
+	if rate := MemProfileRate; rate > 0 {
+		// Note cache c only valid while m acquired; see #47302
+		if rate != 1 && size < c.nextSample {
+			c.nextSample -= size
+		} else {
+			profilealloc(mp, x, size)
+		}
+	}
 	mp.mallocing = 0
 	releasem(mp)
 
 	// Pointerfree data can be zeroed late in a context where preemption can occur.
 	// x will keep the memory alive.
 	if !isZeroed && needzero {
-		memclrNoHeapPointersChunked(size, x)
+		memclrNoHeapPointersChunked(size, x) // This is a possible preemption point: see #47302
 	}
 
 	if debug.malloc {
@@ -1155,16 +1163,6 @@ func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 		}
 	}
 
-	if rate := MemProfileRate; rate > 0 {
-		if rate != 1 && size < c.nextSample {
-			c.nextSample -= size
-		} else {
-			mp := acquirem()
-			profilealloc(mp, x, size)
-			releasem(mp)
-		}
-	}
-
 	if assistG != nil {
 		// Account for internal fragmentation in the assist
 		// debt now that we know it.
-- 
GitLab


From 798ec73519a7226d6d436e42498a54aed23b8468 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Wed, 21 Jul 2021 19:57:56 -0700
Subject: [PATCH 2362/2400] runtime: don't clear timerModifiedEarliest if
 adjustTimers is 0

This avoids a race when a new timerModifiedEarlier timer is created by
a different goroutine.

Fixes #47329

Change-Id: I6f6c87b4a9b5491b201c725c10bc98e23e0ed9d1
Reviewed-on: https://go-review.googlesource.com/c/go/+/336432
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
---
 src/runtime/runtime2.go |  2 +-
 src/runtime/time.go     |  5 -----
 src/time/sleep_test.go  | 34 ++++++++++++++++++++++++++++++++++
 3 files changed, 35 insertions(+), 6 deletions(-)

diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index 2a66826f34..8a15787382 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -681,7 +681,7 @@ type p struct {
 	// timerModifiedEarlier status. Because the timer may have been
 	// modified again, there need not be any timer with this value.
 	// This is updated using atomic functions.
-	// This is 0 if the value is unknown.
+	// This is 0 if there are no timerModifiedEarlier timers.
 	timerModifiedEarliest uint64
 
 	// Per-P GC state
diff --git a/src/runtime/time.go b/src/runtime/time.go
index dee6a674e4..7b84d2af57 100644
--- a/src/runtime/time.go
+++ b/src/runtime/time.go
@@ -668,11 +668,6 @@ func adjusttimers(pp *p, now int64) {
 		if verifyTimers {
 			verifyTimerHeap(pp)
 		}
-		// There are no timers to adjust, so it is safe to clear
-		// timerModifiedEarliest. Do so in case it is stale.
-		// Everything will work if we don't do this,
-		// but clearing here may save future calls to adjusttimers.
-		atomic.Store64(&pp.timerModifiedEarliest, 0)
 		return
 	}
 
diff --git a/src/time/sleep_test.go b/src/time/sleep_test.go
index 6ee0631a85..e0172bf5e0 100644
--- a/src/time/sleep_test.go
+++ b/src/time/sleep_test.go
@@ -527,6 +527,40 @@ func TestZeroTimer(t *testing.T) {
 	}
 }
 
+// Test that rapidly moving a timer earlier doesn't cause it to get dropped.
+// Issue 47329.
+func TestTimerModifiedEarlier(t *testing.T) {
+	past := Until(Unix(0, 0))
+	count := 1000
+	fail := 0
+	for i := 0; i < count; i++ {
+		timer := NewTimer(Hour)
+		for j := 0; j < 10; j++ {
+			if !timer.Stop() {
+				<-timer.C
+			}
+			timer.Reset(past)
+		}
+
+		deadline := NewTimer(10 * Second)
+		defer deadline.Stop()
+		now := Now()
+		select {
+		case <-timer.C:
+			if since := Since(now); since > 8*Second {
+				t.Errorf("timer took too long (%v)", since)
+				fail++
+			}
+		case <-deadline.C:
+			t.Error("deadline expired")
+		}
+	}
+
+	if fail > 0 {
+		t.Errorf("%d failures", fail)
+	}
+}
+
 // Benchmark timer latency when the thread that creates the timer is busy with
 // other work and the timers must be serviced by other threads.
 // https://golang.org/issue/38860
-- 
GitLab


From 052da5717e02659da49707873b3868fe36f2aaf0 Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Thu, 22 Jul 2021 12:42:09 -0400
Subject: [PATCH 2363/2400] cmd/compile: do not change field offset in ABI
 analysis

Currently, the ABI analysis assigns parameter/result offsets
to the fields of function *Type. In some cases, we may have
an ABI0 function reference and an ABIInternal reference share
the same function *Type. For example, for an ABI0 function F,
"f := F" will make f and (ABI0) F having the same *Type. But f,
as a func value, should use ABIInternal. Analyses on F and f will
collide and cause ICE.

Also, changing field offsets in ABI analysis has to be done very
carefully to avoid data races. It has been causing
trickiness/difficulty.

This CL removes the change of field offsets in ABI analysis
altogether. The analysis result is stored in ABIParamAssignment,
which is the only way to access parameter/result stack offset now.

Fixes #47317.
Fixes #47227.

Change-Id: I23a3e081a6cf327ac66855da222daaa636ed1ead
Reviewed-on: https://go-review.googlesource.com/c/go/+/336629
Trust: Cherry Mui <cherryyz@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Than McIntosh <thanm@google.com>
---
 src/cmd/compile/internal/abi/abiutils.go | 21 +++------------------
 src/cmd/compile/internal/ssagen/ssa.go   | 11 +++++++----
 test/fixedbugs/issue47317.dir/a.s        |  6 ++++++
 test/fixedbugs/issue47317.dir/x.go       | 17 +++++++++++++++++
 test/fixedbugs/issue47317.go             |  7 +++++++
 5 files changed, 40 insertions(+), 22 deletions(-)
 create mode 100644 test/fixedbugs/issue47317.dir/a.s
 create mode 100644 test/fixedbugs/issue47317.dir/x.go
 create mode 100644 test/fixedbugs/issue47317.go

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index b8ea1955d1..d657ddc867 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -446,35 +446,20 @@ func (config *ABIConfig) ABIAnalyze(t *types.Type, setNname bool) *ABIParamResul
 	return result
 }
 
-// parameterUpdateMu protects the Offset field of function/method parameters (a subset of structure Fields)
-var parameterUpdateMu sync.Mutex
-
-// FieldOffsetOf returns a concurrency-safe version of f.Offset
-func FieldOffsetOf(f *types.Field) int64 {
-	parameterUpdateMu.Lock()
-	defer parameterUpdateMu.Unlock()
-	return f.Offset
-}
-
 func (config *ABIConfig) updateOffset(result *ABIParamResultInfo, f *types.Field, a ABIParamAssignment, isReturn, setNname bool) {
 	// Everything except return values in registers has either a frame home (if not in a register) or a frame spill location.
 	if !isReturn || len(a.Registers) == 0 {
 		// The type frame offset DOES NOT show effects of minimum frame size.
 		// Getting this wrong breaks stackmaps, see liveness/plive.go:WriteFuncMap and typebits/typebits.go:Set
-		parameterUpdateMu.Lock()
-		defer parameterUpdateMu.Unlock()
 		off := a.FrameOffset(result)
 		fOffset := f.Offset
 		if fOffset == types.BOGUS_FUNARG_OFFSET {
-			// Set the Offset the first time. After that, we may recompute it, but it should never change.
-			f.Offset = off
-			if f.Nname != nil {
-				// always set it in this case.
+			if setNname && f.Nname != nil {
 				f.Nname.(*ir.Name).SetFrameOffset(off)
 				f.Nname.(*ir.Name).SetIsOutputParamInRegisters(false)
 			}
-		} else if fOffset != off {
-			base.Fatalf("offset for %s at %s changed from %d to %d", f.Sym.Name, base.FmtPos(f.Pos), fOffset, off)
+		} else {
+			base.Fatalf("field offset for %s at %s has been set to %d", f.Sym.Name, base.FmtPos(f.Pos), fOffset)
 		}
 	} else {
 		if setNname && f.Nname != nil {
diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index a5cb0857b3..dfa76006de 100644
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -1296,7 +1296,7 @@ func (s *state) instrumentFields(t *types.Type, addr *ssa.Value, kind instrument
 		if f.Sym.IsBlank() {
 			continue
 		}
-		offptr := s.newValue1I(ssa.OpOffPtr, types.NewPtr(f.Type), abi.FieldOffsetOf(f), addr)
+		offptr := s.newValue1I(ssa.OpOffPtr, types.NewPtr(f.Type), f.Offset, addr)
 		s.instrumentFields(f.Type, offptr, kind)
 	}
 }
@@ -5053,19 +5053,23 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		ft := fn.Type()
 		off := t.FieldOff(12) // TODO register args: be sure this isn't a hardcoded param stack offset.
 		args := n.Args
+		i0 := 0
 
 		// Set receiver (for interface calls). Always a pointer.
 		if rcvr != nil {
 			p := s.newValue1I(ssa.OpOffPtr, ft.Recv().Type.PtrTo(), off, addr)
 			s.store(types.Types[types.TUINTPTR], p, rcvr)
+			i0 = 1
 		}
 		// Set receiver (for method calls).
 		if n.Op() == ir.OCALLMETH {
 			base.Fatalf("OCALLMETH missed by walkCall")
 		}
 		// Set other args.
-		for _, f := range ft.Params().Fields().Slice() {
-			s.storeArgWithBase(args[0], f.Type, addr, off+abi.FieldOffsetOf(f))
+		// This code is only used when RegabiDefer is not enabled, and arguments are always
+		// passed on stack.
+		for i, f := range ft.Params().Fields().Slice() {
+			s.storeArgWithBase(args[0], f.Type, addr, off+params.InParam(i+i0).FrameOffset(params))
 			args = args[1:]
 		}
 
@@ -5078,7 +5082,6 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val
 		if stksize < int64(types.PtrSize) {
 			// We need room for both the call to deferprocStack and the call to
 			// the deferred function.
-			// TODO(register args) Revisit this if/when we pass args in registers.
 			stksize = int64(types.PtrSize)
 		}
 		call.AuxInt = stksize
diff --git a/test/fixedbugs/issue47317.dir/a.s b/test/fixedbugs/issue47317.dir/a.s
new file mode 100644
index 0000000000..b969ddb972
--- /dev/null
+++ b/test/fixedbugs/issue47317.dir/a.s
@@ -0,0 +1,6 @@
+// Copyright 2021 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.
+
+TEXT	·G(SB),4,$0
+	RET
diff --git a/test/fixedbugs/issue47317.dir/x.go b/test/fixedbugs/issue47317.dir/x.go
new file mode 100644
index 0000000000..83b5542144
--- /dev/null
+++ b/test/fixedbugs/issue47317.dir/x.go
@@ -0,0 +1,17 @@
+// Copyright 2021 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.
+
+// Issue 47317: ICE when calling ABI0 function via func value.
+
+package main
+
+func main() { F() }
+
+func F() interface{} {
+	g := G
+	g(1)
+	return G
+}
+
+func G(x int) [2]int
diff --git a/test/fixedbugs/issue47317.go b/test/fixedbugs/issue47317.go
new file mode 100644
index 0000000000..3548e90d02
--- /dev/null
+++ b/test/fixedbugs/issue47317.go
@@ -0,0 +1,7 @@
+// builddir
+
+// Copyright 2021 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 ignored
-- 
GitLab


From 0914646ab91a3157666d845d74d8d9a4a2831e1e Mon Sep 17 00:00:00 2001
From: Alberto Donizetti <alb.donizetti@gmail.com>
Date: Fri, 23 Jul 2021 18:45:41 +0200
Subject: [PATCH 2364/2400] doc/1.17: fix two dead rfc links

Updates #44513

Change-Id: Ia0c6b48bde2719f3a99cb216b6166d82159198d1
Reviewed-on: https://go-review.googlesource.com/c/go/+/336930
Trust: Alberto Donizetti <alb.donizetti@gmail.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 doc/go1.17.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 7739d1c62e..48811e6b67 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -886,8 +886,8 @@ func Foo() bool {
   <dd>
     <p><!-- CL 272668 -->
       The new method <a href="/pkg/net/#IP.IsPrivate"><code>IP.IsPrivate</code></a> reports whether an address is
-      a private IPv4 address according to <a href="http://tools.ietf.org/html/rfc1918">RFC 1918</a>
-      or a local IPv6 address according <a href="http://tools.ietf.org/html/rfc4193">RFC 4193</a>.
+      a private IPv4 address according to <a href="https://datatracker.ietf.org/doc/rfc1918">RFC 1918</a>
+      or a local IPv6 address according <a href="https://datatracker.ietf.org/doc/rfc4193">RFC 4193</a>.
     </p>
 
     <p><!-- CL 301709 -->
-- 
GitLab


From 849b7911293c3cb11d76ff2778ed560100f987d1 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Sat, 24 Jul 2021 16:53:02 -0700
Subject: [PATCH 2365/2400] spec: use consistent capitalization for rune
 literal hex constants

Fixes #47368

Change-Id: I2f65c0008658532123f04d08e99e5d083f33461a
Reviewed-on: https://go-review.googlesource.com/c/go/+/337234
Trust: Ian Lance Taylor <iant@golang.org>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 doc/go_spec.html | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index df256f0f0e..cc7ed6a561 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1,6 +1,6 @@
 <!--{
 	"Title": "The Go Programming Language Specification",
-	"Subtitle": "Version of Jul 1, 2021",
+	"Subtitle": "Version of Jul 24, 2021",
 	"Path": "/ref/spec"
 }-->
 
@@ -490,8 +490,8 @@ After a backslash, certain single-character escapes represent special values:
 \n   U+000A line feed or newline
 \r   U+000D carriage return
 \t   U+0009 horizontal tab
-\v   U+000b vertical tab
-\\   U+005c backslash
+\v   U+000B vertical tab
+\\   U+005C backslash
 \'   U+0027 single quote  (valid escape only within rune literals)
 \"   U+0022 double quote  (valid escape only within string literals)
 </pre>
-- 
GitLab


From 1868f8296eb15d11c45c2c7c1d373b211f745d84 Mon Sep 17 00:00:00 2001
From: Dmitri Shuralyov <dmitshur@golang.org>
Date: Sun, 25 Jul 2021 21:04:33 -0400
Subject: [PATCH 2366/2400] crypto/x509: update iOS bundled roots to version
 55188.120.1.0.1

Updates #38843.

Change-Id: I6e003ed03cd13d8ecf86ce05ab0e11c47e271c0b
Reviewed-on: https://go-review.googlesource.com/c/go/+/337329
Trust: Dmitri Shuralyov <dmitshur@golang.org>
Run-TryBot: Dmitri Shuralyov <dmitshur@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
---
 src/crypto/x509/root.go     |  2 +-
 src/crypto/x509/root_ios.go | 37 ++++++++++++++++++++++++++++++++++++-
 2 files changed, 37 insertions(+), 2 deletions(-)

diff --git a/src/crypto/x509/root.go b/src/crypto/x509/root.go
index cc53f7aefc..eef9c047b2 100644
--- a/src/crypto/x509/root.go
+++ b/src/crypto/x509/root.go
@@ -8,7 +8,7 @@ package x509
 // argument to the latest security_certificates version from
 // https://opensource.apple.com/source/security_certificates/
 // and run "go generate". See https://golang.org/issue/38843.
-//go:generate go run root_ios_gen.go -version 55188.40.9
+//go:generate go run root_ios_gen.go -version 55188.120.1.0.1
 
 import "sync"
 
diff --git a/src/crypto/x509/root_ios.go b/src/crypto/x509/root_ios.go
index 50432f3d2c..9bc62f8abb 100644
--- a/src/crypto/x509/root_ios.go
+++ b/src/crypto/x509/root_ios.go
@@ -1,4 +1,4 @@
-// Code generated by root_ios_gen.go -version 55188.40.9; DO NOT EDIT.
+// Code generated by root_ios_gen.go -version 55188.120.1.0.1; DO NOT EDIT.
 // Update the version in root.go and regenerate with "go generate".
 
 //go:build ios && !x509omitbundledroots
@@ -2223,6 +2223,41 @@ uOJAf/sKbvu+M8k8o4TVMAoGCCqGSM49BAMCA0gAMEUCIQDckqGgE6bPA7DmxCGX
 kPoUVy0D7O48027KqGx2vKLeuwIgJ6iFJzWbVsaj8kfSt24bAgAXqmemFZHe+pTs
 ewv4n4Q=
 -----END CERTIFICATE-----
+# "GlobalSign"
+# 2C AB EA FE 37 D0 6C A2 2A BA 73 91 C0 03 3D 25
+# 98 29 52 C4 53 64 73 49 76 3A 3A B5 AD 6C CF 69
+-----BEGIN CERTIFICATE-----
+MIIFgzCCA2ugAwIBAgIORea7A4Mzw4VlSOb/RVEwDQYJKoZIhvcNAQEMBQAwTDEg
+MB4GA1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjYxEzARBgNVBAoTCkdsb2Jh
+bFNpZ24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMTQxMjEwMDAwMDAwWhcNMzQx
+MjEwMDAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSNjET
+MBEGA1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCAiIwDQYJ
+KoZIhvcNAQEBBQADggIPADCCAgoCggIBAJUH6HPKZvnsFMp7PPcNCPG0RQssgrRI
+xutbPK6DuEGSMxSkb3/pKszGsIhrxbaJ0cay/xTOURQh7ErdG1rG1ofuTToVBu1k
+ZguSgMpE3nOUTvOniX9PeGMIyBJQbUJmL025eShNUhqKGoC3GYEOfsSKvGRMIRxD
+aNc9PIrFsmbVkJq3MQbFvuJtMgamHvm566qjuL++gmNQ0PAYid/kD3n16qIfKtJw
+LnvnvJO7bVPiSHyMEAc4/2ayd2F+4OqMPKq0pPbzlUoSB239jLKJz9CgYXfIWHSw
+1CM69106yqLbnQneXUQtkPGBzVeS+n68UARjNN9rkxi+azayOeSsJDa38O+2HBNX
+k7besvjihbdzorg1qkXy4J02oW9UivFyVm4uiMVRQkQVlO6jxTiWm05OWgtH8wY2
+SXcwvHE35absIQh1/OZhFj931dmRl4QKbNQCTXTAFO39OfuD8l4UoQSwC+n+7o/h
+bguyCLNhZglqsQY6ZZZZwPA1/cnaKI0aEYdwgQqomnUdnjqGBQCe24DWJfncBZ4n
+WUx2OVvq+aWh2IMP0f/fMBH5hc8zSPXKbWQULHpYT9NLCEnFlWQaYw55PfWzjMpY
+rZxCRXluDocZXFSxZba/jJvcE+kNb7gu3GduyYsRtYQUigAZcIN5kZeR1Bonvzce
+MgfYFGM8KEyvAgMBAAGjYzBhMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTAD
+AQH/MB0GA1UdDgQWBBSubAWjkxPioufi1xzWx/B/yGdToDAfBgNVHSMEGDAWgBSu
+bAWjkxPioufi1xzWx/B/yGdToDANBgkqhkiG9w0BAQwFAAOCAgEAgyXt6NH9lVLN
+nsAEoJFp5lzQhN7craJP6Ed41mWYqVuoPId8AorRbrcWc+ZfwFSY1XS+wc3iEZGt
+Ixg93eFyRJa0lV7Ae46ZeBZDE1ZXs6KzO7V33EByrKPrmzU+sQghoefEQzd5Mr61
+55wsTLxDKZmOMNOsIeDjHfrYBzN2VAAiKrlNIC5waNrlU/yDXNOd8v9EDERm8tLj
+vUYAGm0CuiVdjaExUd1URhxN25mW7xocBFymFe944Hn+Xds+qkxV/ZoVqW/hpvvf
+cDDpw+5CRu3CkwWJ+n1jez/QcYF8AOiYrg54NMMl+68KnyBr3TsTjxKM4kEaSHpz
+oHdpx7Zcf4LIHv5YGygrqGytXm3ABdJ7t+uA/iU3/gKbaKxCXcPu9czc8FB10jZp
+nOZ7BN9uBmm23goJSFmH63sUYHpkqmlD75HHTOwY3WzvUy2MmeFe8nI+z1TIvWfs
+pA9MRf/TuTAjB0yPEL+GltmZWrSZVxykzLsViVO6LAUP5MSeGbEYNNVMnbrt9x+v
+JJUEeKgDu+6B5dpffItKoZB0JaezPkvILFa9x8jvOOJckvB595yEunQtYQEgfn7R
+8k8HWV+LLUNS60YMlOH1Zkd5d9VUWx+tJDfLRVpOoERIyNiwmcUVhAn21klJwGW4
+5hpxbqCo8YLoRT5s1gLXCmeDBVrJpBA=
+-----END CERTIFICATE-----
 # "GlobalSign Root CA"
 # EB D4 10 40 E4 BB 3E C7 42 C9 E3 81 D3 1E F2 A4
 # 1A 48 B6 68 5C 96 E7 CE F3 C1 DF 6C D4 33 1C 99
-- 
GitLab


From ecaa6816bfdbcef2ad749958a11a321de5c2ebd8 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Sat, 24 Jul 2021 18:34:16 +0700
Subject: [PATCH 2367/2400] doc: clarify non-nil zero length slice to array
 pointer conversion

There is an example for nil slice already, so adding example for non-nil
zero length slice, too, clarifying to the reader that the result is also
non-nil and different from nil slice case.

Updates #395

Change-Id: I019db1b1a1c0c621161ecaaacab5a4d888764b1a
Reviewed-on: https://go-review.googlesource.com/c/go/+/336890
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 doc/go_spec.html | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index cc7ed6a561..0e14a1f3b6 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1,6 +1,6 @@
 <!--{
 	"Title": "The Go Programming Language Specification",
-	"Subtitle": "Version of Jul 24, 2021",
+	"Subtitle": "Version of Jul 26, 2021",
 	"Path": "/ref/spec"
 }-->
 
@@ -4335,6 +4335,9 @@ s4 := (*[4]byte)(s)      // panics: len([4]byte) > len(s)
 var t []string
 t0 := (*[0]string)(t)    // t0 == nil
 t1 := (*[1]string)(t)    // panics: len([1]string) > len(t)
+
+u := make([]byte, 0)
+u0 = (*[0]byte)(u)       // u0 != nil
 </pre>
 
 <h3 id="Constant_expressions">Constant expressions</h3>
-- 
GitLab


From 9c81fd53b3ae52e286d3020ee8b381328b6b9bd2 Mon Sep 17 00:00:00 2001
From: 180909 <734461790@qq.com>
Date: Sun, 25 Jul 2021 11:21:14 +0000
Subject: [PATCH 2368/2400] cmd/vet: add missing copyright header

Change-Id: I78942dde77547f91daebe763328f52b4c476ddaf
GitHub-Last-Rev: 423f1683fc7db8c1764383cf0a61c54ee21c06f2
GitHub-Pull-Request: golang/go#47334
Reviewed-on: https://go-review.googlesource.com/c/go/+/336434
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Than McIntosh <thanm@google.com>
---
 src/cmd/vet/main.go                               | 4 ++++
 src/cmd/vet/testdata/copylock/copylock.go         | 4 ++++
 src/cmd/vet/testdata/httpresponse/httpresponse.go | 4 ++++
 src/cmd/vet/testdata/testingpkg/tests.go          | 4 ++++
 src/cmd/vet/testdata/testingpkg/tests_test.go     | 4 ++++
 5 files changed, 20 insertions(+)

diff --git a/src/cmd/vet/main.go b/src/cmd/vet/main.go
index a33bba2466..7da8606ece 100644
--- a/src/cmd/vet/main.go
+++ b/src/cmd/vet/main.go
@@ -1,3 +1,7 @@
+// Copyright 2012 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 (
diff --git a/src/cmd/vet/testdata/copylock/copylock.go b/src/cmd/vet/testdata/copylock/copylock.go
index 8079cf3248..7cfafe6408 100644
--- a/src/cmd/vet/testdata/copylock/copylock.go
+++ b/src/cmd/vet/testdata/copylock/copylock.go
@@ -1,3 +1,7 @@
+// Copyright 2018 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 copylock
 
 import "sync"
diff --git a/src/cmd/vet/testdata/httpresponse/httpresponse.go b/src/cmd/vet/testdata/httpresponse/httpresponse.go
index 6141f6e06d..98e394a271 100644
--- a/src/cmd/vet/testdata/httpresponse/httpresponse.go
+++ b/src/cmd/vet/testdata/httpresponse/httpresponse.go
@@ -1,3 +1,7 @@
+// Copyright 2018 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 httpresponse
 
 import (
diff --git a/src/cmd/vet/testdata/testingpkg/tests.go b/src/cmd/vet/testdata/testingpkg/tests.go
index 69d29d3c6c..8f4674d33c 100644
--- a/src/cmd/vet/testdata/testingpkg/tests.go
+++ b/src/cmd/vet/testdata/testingpkg/tests.go
@@ -1 +1,5 @@
+// Copyright 2018 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 testdata
diff --git a/src/cmd/vet/testdata/testingpkg/tests_test.go b/src/cmd/vet/testdata/testingpkg/tests_test.go
index 09bb98d980..815dcc8a95 100644
--- a/src/cmd/vet/testdata/testingpkg/tests_test.go
+++ b/src/cmd/vet/testdata/testingpkg/tests_test.go
@@ -1,3 +1,7 @@
+// Copyright 2018 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 testdata
 
 func Example_BadSuffix() {} // ERROR "Example_BadSuffix has malformed example suffix: BadSuffix"
-- 
GitLab


From bfbb288574841f2db2499a580d7bf985a5df4556 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Sun, 25 Jul 2021 16:26:13 -0700
Subject: [PATCH 2369/2400] runtime: remove adjustTimers counter

In CL 336432 we changed adjusttimers so that it no longer cleared
timerModifiedEarliest if there were no timersModifiedEarlier timers.
This caused some Google internal tests to time out, presumably due
to the increased contention on timersLock.  We can avoid that by
simply not skipping the loop in adjusttimers, which lets us safely
clear timerModifiedEarliest.  And if we don't skip the loop, then there
isn't much reason to keep the count of timerModifiedEarlier timers at all.
So remove it.

The effect will be that for programs that create some timerModifiedEarlier
timers and then remove them all, the program will do an occasional
additional loop over all the timers.  And, programs that have some
timerModifiedEarlier timers will always loop over all the timers,
without the quicker exit when they have all been seen.  But the loops
should not occur all that often, due to timerModifiedEarliest.

For #47329

Change-Id: I7b244c1244d97b169a3c7fbc8f8a8b115731ddee
Reviewed-on: https://go-review.googlesource.com/c/go/+/337309
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
---
 src/runtime/proc.go     |  1 -
 src/runtime/runtime2.go |  6 -----
 src/runtime/time.go     | 53 +++++++----------------------------------
 3 files changed, 8 insertions(+), 52 deletions(-)

diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 4c92588a66..7bc2a92590 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -4919,7 +4919,6 @@ func (pp *p) destroy() {
 		moveTimers(plocal, pp.timers)
 		pp.timers = nil
 		pp.numTimers = 0
-		pp.adjustTimers = 0
 		pp.deletedTimers = 0
 		atomic.Store64(&pp.timer0When, 0)
 		unlock(&pp.timersLock)
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index 8a15787382..5051ec4d3e 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -727,12 +727,6 @@ type p struct {
 	// Modified using atomic instructions.
 	numTimers uint32
 
-	// Number of timerModifiedEarlier timers on P's heap.
-	// This should only be modified while holding timersLock,
-	// or while the timer status is in a transient state
-	// such as timerModifying.
-	adjustTimers uint32
-
 	// Number of timerDeleted timers in P's heap.
 	// Modified using atomic instructions.
 	deletedTimers uint32
diff --git a/src/runtime/time.go b/src/runtime/time.go
index 7b84d2af57..666b242316 100644
--- a/src/runtime/time.go
+++ b/src/runtime/time.go
@@ -333,7 +333,6 @@ func deltimer(t *timer) bool {
 				// Must fetch t.pp before setting status
 				// to timerDeleted.
 				tpp := t.pp.ptr()
-				atomic.Xadd(&tpp.adjustTimers, -1)
 				if !atomic.Cas(&t.status, timerModifying, timerDeleted) {
 					badTimer()
 				}
@@ -510,20 +509,9 @@ loop:
 
 		tpp := t.pp.ptr()
 
-		// Update the adjustTimers field.  Subtract one if we
-		// are removing a timerModifiedEarlier, add one if we
-		// are adding a timerModifiedEarlier.
-		adjust := int32(0)
-		if status == timerModifiedEarlier {
-			adjust--
-		}
 		if newStatus == timerModifiedEarlier {
-			adjust++
 			updateTimerModifiedEarliest(tpp, when)
 		}
-		if adjust != 0 {
-			atomic.Xadd(&tpp.adjustTimers, adjust)
-		}
 
 		// Set the new status of the timer.
 		if !atomic.Cas(&t.status, timerModifying, newStatus) {
@@ -591,9 +579,6 @@ func cleantimers(pp *p) {
 			// Move t to the right position.
 			dodeltimer0(pp)
 			doaddtimer(pp, t)
-			if s == timerModifiedEarlier {
-				atomic.Xadd(&pp.adjustTimers, -1)
-			}
 			if !atomic.Cas(&t.status, timerMoving, timerWaiting) {
 				badTimer()
 			}
@@ -664,32 +649,23 @@ func moveTimers(pp *p, timers []*timer) {
 // it also moves timers that have been modified to run later,
 // and removes deleted timers. The caller must have locked the timers for pp.
 func adjusttimers(pp *p, now int64) {
-	if atomic.Load(&pp.adjustTimers) == 0 {
-		if verifyTimers {
-			verifyTimerHeap(pp)
-		}
-		return
-	}
-
 	// If we haven't yet reached the time of the first timerModifiedEarlier
 	// timer, don't do anything. This speeds up programs that adjust
 	// a lot of timers back and forth if the timers rarely expire.
 	// We'll postpone looking through all the adjusted timers until
 	// one would actually expire.
-	if first := atomic.Load64(&pp.timerModifiedEarliest); first != 0 {
-		if int64(first) > now {
-			if verifyTimers {
-				verifyTimerHeap(pp)
-			}
-			return
+	first := atomic.Load64(&pp.timerModifiedEarliest)
+	if first == 0 || int64(first) > now {
+		if verifyTimers {
+			verifyTimerHeap(pp)
 		}
-
-		// We are going to clear all timerModifiedEarlier timers.
-		atomic.Store64(&pp.timerModifiedEarliest, 0)
+		return
 	}
 
+	// We are going to clear all timerModifiedEarlier timers.
+	atomic.Store64(&pp.timerModifiedEarliest, 0)
+
 	var moved []*timer
-loop:
 	for i := 0; i < len(pp.timers); i++ {
 		t := pp.timers[i]
 		if t.pp.ptr() != pp {
@@ -716,11 +692,6 @@ loop:
 				// loop to skip some other timer.
 				dodeltimer(pp, i)
 				moved = append(moved, t)
-				if s == timerModifiedEarlier {
-					if n := atomic.Xadd(&pp.adjustTimers, -1); int32(n) <= 0 {
-						break loop
-					}
-				}
 				// Look at this heap position again.
 				i--
 			}
@@ -819,9 +790,6 @@ func runtimer(pp *p, now int64) int64 {
 			t.when = t.nextwhen
 			dodeltimer0(pp)
 			doaddtimer(pp, t)
-			if s == timerModifiedEarlier {
-				atomic.Xadd(&pp.adjustTimers, -1)
-			}
 			if !atomic.Cas(&t.status, timerMoving, timerWaiting) {
 				badTimer()
 			}
@@ -916,7 +884,6 @@ func clearDeletedTimers(pp *p) {
 	atomic.Store64(&pp.timerModifiedEarliest, 0)
 
 	cdel := int32(0)
-	cearlier := int32(0)
 	to := 0
 	changedHeap := false
 	timers := pp.timers
@@ -941,9 +908,6 @@ nextTimer:
 					if !atomic.Cas(&t.status, timerMoving, timerWaiting) {
 						badTimer()
 					}
-					if s == timerModifiedEarlier {
-						cearlier++
-					}
 					continue nextTimer
 				}
 			case timerDeleted:
@@ -980,7 +944,6 @@ nextTimer:
 
 	atomic.Xadd(&pp.deletedTimers, -cdel)
 	atomic.Xadd(&pp.numTimers, -cdel)
-	atomic.Xadd(&pp.adjustTimers, -cearlier)
 
 	timers = timers[:to]
 	pp.timers = timers
-- 
GitLab


From 840e583ff340d22a6263a348922283e6d5cd2e31 Mon Sep 17 00:00:00 2001
From: Koichi Shiraishi <zchee.io@gmail.com>
Date: Sun, 25 Jul 2021 03:00:04 +0900
Subject: [PATCH 2370/2400] runtime: correct variable name in comment

Change-Id: Ic35ec2ed320c3c266afbeec8bdea1dedac4725e4
Reviewed-on: https://go-review.googlesource.com/c/go/+/336892
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Austin Clements <austin@google.com>
---
 src/runtime/race.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/race.go b/src/runtime/race.go
index cc8c5db1bd..ce6b5b5468 100644
--- a/src/runtime/race.go
+++ b/src/runtime/race.go
@@ -343,7 +343,7 @@ func racereadrangepc1(addr, size, pc uintptr)
 func racewriterangepc1(addr, size, pc uintptr)
 func racecallbackthunk(uintptr)
 
-// racecall allows calling an arbitrary function f from C race runtime
+// racecall allows calling an arbitrary function fn from C race runtime
 // with up to 4 uintptr arguments.
 func racecall(fn *byte, arg0, arg1, arg2, arg3 uintptr)
 
-- 
GitLab


From 33ff1559702388c57c45f9e6cd032f06e8c3c163 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Mon, 26 Jul 2021 16:33:44 -0400
Subject: [PATCH 2371/2400] go/types: preserve untyped constants on the RHS of
 a shift expression

CL 291316 fixed go/types to verify that untyped shift counts are
representable by uint, but as a side effect also converted their types
to uint.

Rearrange the logic to keep the check for representability, but not
actually convert untyped integer constants. Untyped non-integer
constants are still converted, to preserve the behavior of 1.16. This
behavior for non-integer types is a bug, filed as #47410.

Updates #47410
Fixes #47243

Change-Id: I5eab4aab35b97f932fccdee2d4a18623ee2ccad5
Reviewed-on: https://go-review.googlesource.com/c/go/+/337529
Trust: Robert Findley <rfindley@google.com>
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/go/types/api_test.go   | 12 ++++++++++++
 src/go/types/check_test.go |  7 +++++++
 src/go/types/expr.go       | 34 +++++++++++++++++++++++++---------
 3 files changed, 44 insertions(+), 9 deletions(-)

diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go
index f37b91d5a4..f964c656f9 100644
--- a/src/go/types/api_test.go
+++ b/src/go/types/api_test.go
@@ -322,6 +322,18 @@ func TestTypesInfo(t *testing.T) {
 			`[][]struct{}`,
 		},
 
+		// issue 47243
+		{`package issue47243_a; var x int32; var _ = x << 3`, `3`, `untyped int`},
+		{`package issue47243_b; var x int32; var _ = x << 3.`, `3.`, `uint`}, // issue 47410: should be untyped float
+		{`package issue47243_c; var x int32; var _ = 1 << x`, `1 << x`, `int`},
+		{`package issue47243_d; var x int32; var _ = 1 << x`, `1`, `int`},
+		{`package issue47243_e; var x int32; var _ = 1 << 2`, `1`, `untyped int`},
+		{`package issue47243_f; var x int32; var _ = 1 << 2`, `2`, `untyped int`},
+		{`package issue47243_g; var x int32; var _ = int(1) << 2`, `2`, `untyped int`},
+		{`package issue47243_h; var x int32; var _ = 1 << (2 << x)`, `1`, `int`},
+		{`package issue47243_i; var x int32; var _ = 1 << (2 << x)`, `(2 << x)`, `untyped int`},
+		{`package issue47243_j; var x int32; var _ = 1 << (2 << x)`, `2`, `untyped int`},
+
 		// tests for broken code that doesn't parse or type-check
 		{broken + `x0; func _() { var x struct {f string}; x.f := 0 }`, `x.f`, `string`},
 		{broken + `x1; func _() { var z string; type x struct {f string}; y := &x{q: z}}`, `z`, `string`},
diff --git a/src/go/types/check_test.go b/src/go/types/check_test.go
index c85a8e46fb..f83abf11ce 100644
--- a/src/go/types/check_test.go
+++ b/src/go/types/check_test.go
@@ -344,6 +344,13 @@ func TestIssue46453(t *testing.T) {
 	checkFiles(t, nil, "", []string{"issue46453.go"}, [][]byte{[]byte(src)}, false, nil)
 }
 
+func TestIssue47243_TypedRHS(t *testing.T) {
+	// The RHS of the shift expression below overflows uint on 32bit platforms,
+	// but this is OK as it is explicitly typed.
+	const src = "package issue47243\n\nvar a uint64; var _ = a << uint64(4294967296)" // uint64(1<<32)
+	checkFiles(t, &StdSizes{4, 4}, "", []string{"p.go"}, [][]byte{[]byte(src)}, false, nil)
+}
+
 func TestCheck(t *testing.T)     { DefPredeclaredTestFuncs(); testDir(t, "check") }
 func TestExamples(t *testing.T)  { testDir(t, "examples") }
 func TestFixedbugs(t *testing.T) { testDir(t, "fixedbugs") }
diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 5c65fad447..58962e777b 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -778,32 +778,48 @@ func (check *Checker) shift(x, y *operand, e ast.Expr, op token.Token) {
 	// spec: "The right operand in a shift expression must have integer type
 	// or be an untyped constant representable by a value of type uint."
 
-	// Provide a good error message for negative shift counts.
+	// Check that constants are representable by uint, but do not convert them
+	// (see also issue #47243).
 	if y.mode == constant_ {
+		// Provide a good error message for negative shift counts.
 		yval := constant.ToInt(y.val) // consider -1, 1.0, but not -1.1
 		if yval.Kind() == constant.Int && constant.Sign(yval) < 0 {
 			check.invalidOp(y, _InvalidShiftCount, "negative shift count %s", y)
 			x.mode = invalid
 			return
 		}
+
+		if isUntyped(y.typ) {
+			// Caution: Check for representability here, rather than in the switch
+			// below, because isInteger includes untyped integers (was bug #43697).
+			check.representable(y, Typ[Uint])
+			if y.mode == invalid {
+				x.mode = invalid
+				return
+			}
+		}
 	}
 
-	// Caution: Check for isUntyped first because isInteger includes untyped
-	//          integers (was bug #43697).
-	if isUntyped(y.typ) {
+	// Check that RHS is otherwise at least of integer type.
+	switch {
+	case isInteger(y.typ):
+		if !isUnsigned(y.typ) && !check.allowVersion(check.pkg, 1, 13) {
+			check.invalidOp(y, _InvalidShiftCount, "signed shift count %s requires go1.13 or later", y)
+			x.mode = invalid
+			return
+		}
+	case isUntyped(y.typ):
+		// This is incorrect, but preserves pre-existing behavior.
+		// See also bug #47410.
 		check.convertUntyped(y, Typ[Uint])
 		if y.mode == invalid {
 			x.mode = invalid
 			return
 		}
-	} else if !isInteger(y.typ) {
+	default:
 		check.invalidOp(y, _InvalidShiftCount, "shift count %s must be integer", y)
 		x.mode = invalid
 		return
-	} else if !isUnsigned(y.typ) && !check.allowVersion(check.pkg, 1, 13) {
-		check.invalidOp(y, _InvalidShiftCount, "signed shift count %s requires go1.13 or later", y)
-		x.mode = invalid
-		return
 	}
 
 	if x.mode == constant_ {
-- 
GitLab


From 7ba8e796c91eaf4befcacc4d24127ae54475d6a5 Mon Sep 17 00:00:00 2001
From: Changkun Ou <hi@changkun.de>
Date: Mon, 26 Jul 2021 15:04:48 +0200
Subject: [PATCH 2372/2400] testing: clarify T.Name returns a distinct name of
 the running test

According to the discussion, it is clear that T.Name returns a
distinct name among all tests. However, there is no specification
of how sub-tests with the same specified test name are constructed.
This change only clarifies the uniqueness and the components of the
name without suggesting any explicit format of the returned name.

Fixes #46488

Change-Id: I6cebd419b69fb08d8646cb744a129548452042ef
Reviewed-on: https://go-review.googlesource.com/c/go/+/337392
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/testing/testing.go | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/testing/testing.go b/src/testing/testing.go
index 681f99ef93..a19238d31e 100644
--- a/src/testing/testing.go
+++ b/src/testing/testing.go
@@ -680,7 +680,11 @@ type T struct {
 
 func (c *common) private() {}
 
-// Name returns the name of the running test or benchmark.
+// Name returns the name of the running (sub-) test or benchmark.
+//
+// The name will include the name of the test along with the names of
+// any nested sub-tests. If two sibling sub-tests have the same name,
+// Name will append a suffix to guarantee the returned name is unique.
 func (c *common) Name() string {
 	return c.name
 }
-- 
GitLab


From c8cf0f74e4a8f078ab5570e76c37621a0daf0309 Mon Sep 17 00:00:00 2001
From: 180909 <734461790@qq.com>
Date: Tue, 27 Jul 2021 09:49:55 +0000
Subject: [PATCH 2373/2400] cmd/go: add missing flag in UsageLine

Change-Id: I31689dc8de1f6b95bb35578b20533c63903f7258
GitHub-Last-Rev: 5bfee0535ded703f84d45390d5a87295b6e5fe5a
GitHub-Pull-Request: golang/go#47418
Reviewed-on: https://go-review.googlesource.com/c/go/+/337691
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Trust: Jay Conrod <jayconrod@google.com>
Trust: Russ Cox <rsc@golang.org>
---
 src/cmd/go/alldocs.go              | 4 ++--
 src/cmd/go/internal/modcmd/edit.go | 2 +-
 src/cmd/go/internal/modcmd/init.go | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index 954caae9fb..7f88d3216c 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -1078,7 +1078,7 @@
 //
 // Usage:
 //
-// 	go mod edit [editing flags] [go.mod]
+// 	go mod edit [editing flags] [-fmt|-print|-json] [go.mod]
 //
 // Edit provides a command-line interface for editing go.mod,
 // for use primarily by tools or scripts. It reads only go.mod;
@@ -1204,7 +1204,7 @@
 //
 // Usage:
 //
-// 	go mod init [module]
+// 	go mod init [module-path]
 //
 // Init initializes and writes a new go.mod file in the current directory, in
 // effect creating a new module rooted at the current directory. The go.mod file
diff --git a/src/cmd/go/internal/modcmd/edit.go b/src/cmd/go/internal/modcmd/edit.go
index e856e7c630..bb3d521092 100644
--- a/src/cmd/go/internal/modcmd/edit.go
+++ b/src/cmd/go/internal/modcmd/edit.go
@@ -25,7 +25,7 @@ import (
 )
 
 var cmdEdit = &base.Command{
-	UsageLine: "go mod edit [editing flags] [go.mod]",
+	UsageLine: "go mod edit [editing flags] [-fmt|-print|-json] [go.mod]",
 	Short:     "edit go.mod from tools or scripts",
 	Long: `
 Edit provides a command-line interface for editing go.mod,
diff --git a/src/cmd/go/internal/modcmd/init.go b/src/cmd/go/internal/modcmd/init.go
index 73cc282d81..958c3066ac 100644
--- a/src/cmd/go/internal/modcmd/init.go
+++ b/src/cmd/go/internal/modcmd/init.go
@@ -13,7 +13,7 @@ import (
 )
 
 var cmdInit = &base.Command{
-	UsageLine: "go mod init [module]",
+	UsageLine: "go mod init [module-path]",
 	Short:     "initialize new module in current directory",
 	Long: `
 Init initializes and writes a new go.mod file in the current directory, in
-- 
GitLab


From 7cd10c1149e51a9d2f0868babaf66b8091b9c0b9 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Tue, 27 Jul 2021 10:22:35 -0700
Subject: [PATCH 2374/2400] cmd/go: use .mod instead of .zip to determine if
 version has go.mod file

When checking for updates, the go command checks whether the highest
compatible version has a go.mod file in order to determine whether
+incompatible versions may be considered "latest". Previously, to
perform this check, the go command would download the content of the
module (the .zip file) to see whether a go.mod file was present at the
root. This is slower than necessary, and it caused 'go list -m -u' to
try to save the sum for the .zip file in go.sum in some cases.

With this change, the go command only downloads the .mod file and
checks whether it appears to be a fake file generated for a version
that didn't have a go.mod file. This is faster and requires less
verification. Fake files only have a "module" directive. It's possible
to commit a file that passes this test, but it would be difficult to
do accidentally: Go 1.12 and later at least add a "go" directive. A
false positive here would cause version queries to have slightly
different results but would not affect builds.

Fixes #47377

Change-Id: Ie5ffd0b45e39bd0921328a60af99a9f6e5ab6346
Reviewed-on: https://go-review.googlesource.com/c/go/+/337850
Trust: Jay Conrod <jayconrod@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
---
 src/cmd/go/internal/modfetch/coderepo.go      | 23 ++---
 src/cmd/go/internal/modload/modfile.go        | 83 ++++++++++---------
 src/cmd/go/internal/modload/query.go          | 30 +++++--
 .../script/mod_update_sum_readonly.txt        | 34 ++++++++
 4 files changed, 114 insertions(+), 56 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/mod_update_sum_readonly.txt

diff --git a/src/cmd/go/internal/modfetch/coderepo.go b/src/cmd/go/internal/modfetch/coderepo.go
index f817a04583..dfef9f73c2 100644
--- a/src/cmd/go/internal/modfetch/coderepo.go
+++ b/src/cmd/go/internal/modfetch/coderepo.go
@@ -864,22 +864,25 @@ func (r *codeRepo) GoMod(version string) (data []byte, err error) {
 	data, err = r.code.ReadFile(rev, path.Join(dir, "go.mod"), codehost.MaxGoMod)
 	if err != nil {
 		if os.IsNotExist(err) {
-			return r.legacyGoMod(rev, dir), nil
+			return LegacyGoMod(r.modPath), nil
 		}
 		return nil, err
 	}
 	return data, nil
 }
 
-func (r *codeRepo) legacyGoMod(rev, dir string) []byte {
-	// We used to try to build a go.mod reflecting pre-existing
-	// package management metadata files, but the conversion
-	// was inherently imperfect (because those files don't have
-	// exactly the same semantics as go.mod) and, when done
-	// for dependencies in the middle of a build, impossible to
-	// correct. So we stopped.
-	// Return a fake go.mod that simply declares the module path.
-	return []byte(fmt.Sprintf("module %s\n", modfile.AutoQuote(r.modPath)))
+// LegacyGoMod generates a fake go.mod file for a module that doesn't have one.
+// The go.mod file contains a module directive and nothing else: no go version,
+// no requirements.
+//
+// We used to try to build a go.mod reflecting pre-existing
+// package management metadata files, but the conversion
+// was inherently imperfect (because those files don't have
+// exactly the same semantics as go.mod) and, when done
+// for dependencies in the middle of a build, impossible to
+// correct. So we stopped.
+func LegacyGoMod(modPath string) []byte {
+	return []byte(fmt.Sprintf("module %s\n", modfile.AutoQuote(modPath)))
 }
 
 func (r *codeRepo) modPrefix(rev string) string {
diff --git a/src/cmd/go/internal/modload/modfile.go b/src/cmd/go/internal/modload/modfile.go
index d280945ea6..6145e8b2f0 100644
--- a/src/cmd/go/internal/modload/modfile.go
+++ b/src/cmd/go/internal/modload/modfile.go
@@ -595,47 +595,14 @@ func rawGoModSummary(m module.Version) (*modFileSummary, error) {
 	}
 	c := rawGoModSummaryCache.Do(m, func() interface{} {
 		summary := new(modFileSummary)
-		var f *modfile.File
-		if m.Version == "" {
-			// m is a replacement module with only a file path.
-			dir := m.Path
-			if !filepath.IsAbs(dir) {
-				dir = filepath.Join(ModRoot(), dir)
-			}
-			gomod := filepath.Join(dir, "go.mod")
-			var data []byte
-			var err error
-			if gomodActual, ok := fsys.OverlayPath(gomod); ok {
-				// Don't lock go.mod if it's part of the overlay.
-				// On Plan 9, locking requires chmod, and we don't want to modify any file
-				// in the overlay. See #44700.
-				data, err = os.ReadFile(gomodActual)
-			} else {
-				data, err = lockedfile.Read(gomodActual)
-			}
-			if err != nil {
-				return cached{nil, module.VersionError(m, fmt.Errorf("reading %s: %v", base.ShortPath(gomod), err))}
-			}
-			f, err = modfile.ParseLax(gomod, data, nil)
-			if err != nil {
-				return cached{nil, module.VersionError(m, fmt.Errorf("parsing %s: %v", base.ShortPath(gomod), err))}
-			}
-		} else {
-			if !semver.IsValid(m.Version) {
-				// Disallow the broader queries supported by fetch.Lookup.
-				base.Fatalf("go: internal error: %s@%s: unexpected invalid semantic version", m.Path, m.Version)
-			}
-
-			data, err := modfetch.GoMod(m.Path, m.Version)
-			if err != nil {
-				return cached{nil, err}
-			}
-			f, err = modfile.ParseLax("go.mod", data, nil)
-			if err != nil {
-				return cached{nil, module.VersionError(m, fmt.Errorf("parsing go.mod: %v", err))}
-			}
+		name, data, err := rawGoModData(m)
+		if err != nil {
+			return cached{nil, err}
+		}
+		f, err := modfile.ParseLax(name, data, nil)
+		if err != nil {
+			return cached{nil, module.VersionError(m, fmt.Errorf("parsing %s: %v", base.ShortPath(name), err))}
 		}
-
 		if f.Module != nil {
 			summary.module = f.Module.Mod
 			summary.deprecated = f.Module.Deprecated
@@ -671,6 +638,42 @@ func rawGoModSummary(m module.Version) (*modFileSummary, error) {
 
 var rawGoModSummaryCache par.Cache // module.Version → rawGoModSummary result
 
+// rawGoModData returns the content of the go.mod file for module m, ignoring
+// all replacements that may apply to m.
+//
+// rawGoModData cannot be used on the Target module.
+//
+// Unlike rawGoModSummary, rawGoModData does not cache its results in memory.
+// Use rawGoModSummary instead unless you specifically need these bytes.
+func rawGoModData(m module.Version) (name string, data []byte, err error) {
+	if m.Version == "" {
+		// m is a replacement module with only a file path.
+		dir := m.Path
+		if !filepath.IsAbs(dir) {
+			dir = filepath.Join(ModRoot(), dir)
+		}
+		gomod := filepath.Join(dir, "go.mod")
+		if gomodActual, ok := fsys.OverlayPath(gomod); ok {
+			// Don't lock go.mod if it's part of the overlay.
+			// On Plan 9, locking requires chmod, and we don't want to modify any file
+			// in the overlay. See #44700.
+			data, err = os.ReadFile(gomodActual)
+		} else {
+			data, err = lockedfile.Read(gomodActual)
+		}
+		if err != nil {
+			return gomod, nil, module.VersionError(m, fmt.Errorf("reading %s: %v", base.ShortPath(gomod), err))
+		}
+	} else {
+		if !semver.IsValid(m.Version) {
+			// Disallow the broader queries supported by fetch.Lookup.
+			base.Fatalf("go: internal error: %s@%s: unexpected invalid semantic version", m.Path, m.Version)
+		}
+		data, err = modfetch.GoMod(m.Path, m.Version)
+	}
+	return "go.mod", data, err
+}
+
 // queryLatestVersionIgnoringRetractions looks up the latest version of the
 // module with the given path without considering retracted or excluded
 // versions.
diff --git a/src/cmd/go/internal/modload/query.go b/src/cmd/go/internal/modload/query.go
index dda9004a9f..e737ca90fc 100644
--- a/src/cmd/go/internal/modload/query.go
+++ b/src/cmd/go/internal/modload/query.go
@@ -5,13 +5,13 @@
 package modload
 
 import (
+	"bytes"
 	"context"
 	"errors"
 	"fmt"
 	"io/fs"
 	"os"
 	pathpkg "path"
-	"path/filepath"
 	"sort"
 	"strings"
 	"sync"
@@ -931,14 +931,32 @@ func moduleHasRootPackage(ctx context.Context, m module.Version) (bool, error) {
 	return ok, err
 }
 
-func versionHasGoMod(ctx context.Context, m module.Version) (bool, error) {
-	needSum := false
-	root, _, err := fetch(ctx, m, needSum)
+// versionHasGoMod returns whether a version has a go.mod file.
+//
+// versionHasGoMod fetches the go.mod file (possibly a fake) and true if it
+// contains anything other than a module directive with the same path. When a
+// module does not have a real go.mod file, the go command acts as if it had one
+// that only contained a module directive. Normal go.mod files created after
+// 1.12 at least have a go directive.
+//
+// This function is a heuristic, since it's possible to commit a file that would
+// pass this test. However, we only need a heurstic for determining whether
+// +incompatible versions may be "latest", which is what this function is used
+// for.
+//
+// This heuristic is useful for two reasons: first, when using a proxy,
+// this lets us fetch from the .mod endpoint which is much faster than the .zip
+// endpoint. The .mod file is used anyway, even if the .zip file contains a
+// go.mod with different content. Second, if we don't fetch the .zip, then
+// we don't need to verify it in go.sum. This makes 'go list -m -u' faster
+// and simpler.
+func versionHasGoMod(_ context.Context, m module.Version) (bool, error) {
+	_, data, err := rawGoModData(m)
 	if err != nil {
 		return false, err
 	}
-	fi, err := os.Stat(filepath.Join(root, "go.mod"))
-	return err == nil && !fi.IsDir(), nil
+	isFake := bytes.Equal(data, modfetch.LegacyGoMod(m.Path))
+	return !isFake, nil
 }
 
 // A versionRepo is a subset of modfetch.Repo that can report information about
diff --git a/src/cmd/go/testdata/script/mod_update_sum_readonly.txt b/src/cmd/go/testdata/script/mod_update_sum_readonly.txt
new file mode 100644
index 0000000000..41f12e4084
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_update_sum_readonly.txt
@@ -0,0 +1,34 @@
+# When finding the latest version of a module, we should not download version
+# contents. Previously, we downloaded .zip files to determine whether a real
+# .mod file was present in order to decide whether +incompatible versions
+# could be "latest".
+#
+# Verifies #47377.
+
+# rsc.io/breaker has two versions, neither of which has a .mod file.
+go list -m -versions rsc.io/breaker
+stdout '^rsc.io/breaker v1.0.0 v2.0.0\+incompatible$'
+go mod download rsc.io/breaker@v1.0.0
+! grep '^go' $GOPATH/pkg/mod/cache/download/rsc.io/breaker/@v/v1.0.0.mod
+go mod download rsc.io/breaker@v2.0.0+incompatible
+! grep '^go' $GOPATH/pkg/mod/cache/download/rsc.io/breaker/@v/v2.0.0+incompatible.mod
+
+# Delete downloaded .zip files.
+go clean -modcache
+
+# Check for updates.
+go list -m -u rsc.io/breaker
+stdout '^rsc.io/breaker v1.0.0 \[v2.0.0\+incompatible\]$'
+
+# We should not have downloaded zips.
+! exists $GOPATH/pkg/mod/cache/download/rsc.io/breaker/@v/v1.0.0.zip
+! exists $GOPATH/pkg/mod/cache/download/rsc.io/breaker/@v/v2.0.0+incompatible.zip
+
+-- go.mod --
+module m
+
+go 1.16
+
+require rsc.io/breaker v1.0.0
+-- go.sum --
+rsc.io/breaker v1.0.0/go.mod h1:s5yxDXvD88U1/ESC23I2FK3Lkv4YIKaB1ij/Hbm805g=
-- 
GitLab


From b39e0f461c099abf98f5a8c81d58d32d9a765a03 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 27 Jul 2021 18:30:38 -0700
Subject: [PATCH 2375/2400] runtime: don't crash on nil pointers in
 checkptrAlignment

Ironically, checkptrAlignment had a latent case of bad pointer
arithmetic: if ptr is nil, then `add(ptr, size-1)` might produce an
illegal pointer value.

The fix is to simply check for nil at the top of checkptrAlignment,
and short-circuit if so.

This CL also adds a more explicit bounds check in checkptrStraddles,
rather than relying on `add(ptr, size-1)` to wrap around. I don't
think this is necessary today, but it seems prudent to be careful.

Fixes #47430.

Change-Id: I5c50b2f7f41415dbebbd803e1b8e7766ca95e1fd
Reviewed-on: https://go-review.googlesource.com/c/go/+/338029
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 src/runtime/checkptr.go                   | 11 +++++--
 src/runtime/checkptr_test.go              |  1 +
 src/runtime/testdata/testprog/checkptr.go | 36 ++++++++++++++++++++++-
 3 files changed, 45 insertions(+), 3 deletions(-)

diff --git a/src/runtime/checkptr.go b/src/runtime/checkptr.go
index d42950844b..2d4afd5cf6 100644
--- a/src/runtime/checkptr.go
+++ b/src/runtime/checkptr.go
@@ -7,6 +7,11 @@ package runtime
 import "unsafe"
 
 func checkptrAlignment(p unsafe.Pointer, elem *_type, n uintptr) {
+	// nil pointer is always suitably aligned (#47430).
+	if p == nil {
+		return
+	}
+
 	// Check that (*[n]elem)(p) is appropriately aligned.
 	// Note that we allow unaligned pointers if the types they point to contain
 	// no pointers themselves. See issue 37298.
@@ -29,10 +34,12 @@ func checkptrStraddles(ptr unsafe.Pointer, size uintptr) bool {
 		return false
 	}
 
-	end := add(ptr, size-1)
-	if uintptr(end) < uintptr(ptr) {
+	// Check that add(ptr, size-1) won't overflow. This avoids the risk
+	// of producing an illegal pointer value (assuming ptr is legal).
+	if uintptr(ptr) >= -(size - 1) {
 		return true
 	}
+	end := add(ptr, size-1)
 
 	// TODO(mdempsky): Detect when [ptr, end] contains Go allocations,
 	// but neither ptr nor end point into one themselves.
diff --git a/src/runtime/checkptr_test.go b/src/runtime/checkptr_test.go
index 2a5c364e97..d5dd101adb 100644
--- a/src/runtime/checkptr_test.go
+++ b/src/runtime/checkptr_test.go
@@ -26,6 +26,7 @@ func TestCheckPtr(t *testing.T) {
 	}{
 		{"CheckPtrAlignmentPtr", "fatal error: checkptr: misaligned pointer conversion\n"},
 		{"CheckPtrAlignmentNoPtr", ""},
+		{"CheckPtrAlignmentNilPtr", ""},
 		{"CheckPtrArithmetic", "fatal error: checkptr: pointer arithmetic result points to invalid allocation\n"},
 		{"CheckPtrArithmetic2", "fatal error: checkptr: pointer arithmetic result points to invalid allocation\n"},
 		{"CheckPtrSize", "fatal error: checkptr: converted pointer straddles multiple allocations\n"},
diff --git a/src/runtime/testdata/testprog/checkptr.go b/src/runtime/testdata/testprog/checkptr.go
index f76b64ad96..9c5561396e 100644
--- a/src/runtime/testdata/testprog/checkptr.go
+++ b/src/runtime/testdata/testprog/checkptr.go
@@ -4,11 +4,16 @@
 
 package main
 
-import "unsafe"
+import (
+	"runtime"
+	"time"
+	"unsafe"
+)
 
 func init() {
 	register("CheckPtrAlignmentNoPtr", CheckPtrAlignmentNoPtr)
 	register("CheckPtrAlignmentPtr", CheckPtrAlignmentPtr)
+	register("CheckPtrAlignmentNilPtr", CheckPtrAlignmentNilPtr)
 	register("CheckPtrArithmetic", CheckPtrArithmetic)
 	register("CheckPtrArithmetic2", CheckPtrArithmetic2)
 	register("CheckPtrSize", CheckPtrSize)
@@ -29,6 +34,35 @@ func CheckPtrAlignmentPtr() {
 	sink2 = (**int64)(unsafe.Pointer(uintptr(p) + 1))
 }
 
+// CheckPtrAlignmentNilPtr tests that checkptrAlignment doesn't crash
+// on nil pointers (#47430).
+func CheckPtrAlignmentNilPtr() {
+	var do func(int)
+	do = func(n int) {
+		// Inflate the stack so runtime.shrinkstack gets called during GC
+		if n > 0 {
+			do(n - 1)
+		}
+
+		var p unsafe.Pointer
+		_ = (*int)(p)
+	}
+
+	go func() {
+		for {
+			runtime.GC()
+		}
+	}()
+
+	go func() {
+		for i := 0; ; i++ {
+			do(i % 1024)
+		}
+	}()
+
+	time.Sleep(time.Second)
+}
+
 func CheckPtrArithmetic() {
 	var x int
 	i := uintptr(unsafe.Pointer(&x))
-- 
GitLab


From 9eee0ed4391942c73157c868a9ddcfdef48982f9 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Wed, 28 Jul 2021 11:52:14 -0700
Subject: [PATCH 2376/2400] cmd/go: fix go.mod file name printed in error
 messages for replacements

This fixes a logic error introduced in CL 337850.

Fixes #47444

Change-Id: I6a49c8fc71fdde4ecb7f2e3329ad1f2cd286b7eb
Reviewed-on: https://go-review.googlesource.com/c/go/+/338189
Run-TryBot: Jay Conrod <jayconrod@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
Trust: Jay Conrod <jayconrod@google.com>
---
 src/cmd/go/internal/modload/modfile.go | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/cmd/go/internal/modload/modfile.go b/src/cmd/go/internal/modload/modfile.go
index 6145e8b2f0..03e02e73b6 100644
--- a/src/cmd/go/internal/modload/modfile.go
+++ b/src/cmd/go/internal/modload/modfile.go
@@ -652,8 +652,8 @@ func rawGoModData(m module.Version) (name string, data []byte, err error) {
 		if !filepath.IsAbs(dir) {
 			dir = filepath.Join(ModRoot(), dir)
 		}
-		gomod := filepath.Join(dir, "go.mod")
-		if gomodActual, ok := fsys.OverlayPath(gomod); ok {
+		name = filepath.Join(dir, "go.mod")
+		if gomodActual, ok := fsys.OverlayPath(name); ok {
 			// Don't lock go.mod if it's part of the overlay.
 			// On Plan 9, locking requires chmod, and we don't want to modify any file
 			// in the overlay. See #44700.
@@ -662,16 +662,17 @@ func rawGoModData(m module.Version) (name string, data []byte, err error) {
 			data, err = lockedfile.Read(gomodActual)
 		}
 		if err != nil {
-			return gomod, nil, module.VersionError(m, fmt.Errorf("reading %s: %v", base.ShortPath(gomod), err))
+			return "", nil, module.VersionError(m, fmt.Errorf("reading %s: %v", base.ShortPath(name), err))
 		}
 	} else {
 		if !semver.IsValid(m.Version) {
 			// Disallow the broader queries supported by fetch.Lookup.
 			base.Fatalf("go: internal error: %s@%s: unexpected invalid semantic version", m.Path, m.Version)
 		}
+		name = "go.mod"
 		data, err = modfetch.GoMod(m.Path, m.Version)
 	}
-	return "go.mod", data, err
+	return name, data, err
 }
 
 // queryLatestVersionIgnoringRetractions looks up the latest version of the
-- 
GitLab


From 70fd4e47d73b92fe90e44ac785e2f98f9df0ab67 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Wed, 28 Jul 2021 21:09:31 -0700
Subject: [PATCH 2377/2400] runtime: avoid possible preemption when returning
 from Go to C

When returning from Go to C, it was possible for the goroutine to be
preempted after calling unlockOSThread. This could happen when there
a context function installed by SetCgoTraceback set a non-zero context,
leading to a defer call in cgocallbackg1. The defer function wrapper,
introduced in 1.17 as part of the regabi support, was not nosplit,
and hence was a potential preemption point. If it did get preempted,
the G would move to a new M. It would then attempt to return to C
code on a different stack, typically leading to a SIGSEGV.

Fix this in a simple way by postponing the unlockOSThread until after
the other defer. Also check for the failure condition and fail early,
rather than waiting for a SIGSEGV.

Without the fix to cgocall.go, the test case fails about 50% of the
time on my laptop.

Fixes #47441

Change-Id: Ib8ca13215bd36cddc2a49e86698824a29c6a68ba
Reviewed-on: https://go-review.googlesource.com/c/go/+/338197
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 src/runtime/cgocall.go                        | 20 +++++++----
 src/runtime/crash_cgo_test.go                 |  9 +++++
 .../testdata/testprogcgo/tracebackctxt.go     | 33 +++++++++++++++++--
 .../testdata/testprogcgo/tracebackctxt_c.c    | 14 +++++++-
 4 files changed, 67 insertions(+), 9 deletions(-)

diff --git a/src/runtime/cgocall.go b/src/runtime/cgocall.go
index 8ffb48a888..2626216f95 100644
--- a/src/runtime/cgocall.go
+++ b/src/runtime/cgocall.go
@@ -212,6 +212,8 @@ func cgocallbackg(fn, frame unsafe.Pointer, ctxt uintptr) {
 	// a different M. The call to unlockOSThread is in unwindm.
 	lockOSThread()
 
+	checkm := gp.m
+
 	// Save current syscall parameters, so m.syscall can be
 	// used again if callback decide to make syscall.
 	syscall := gp.m.syscall
@@ -227,15 +229,20 @@ func cgocallbackg(fn, frame unsafe.Pointer, ctxt uintptr) {
 
 	osPreemptExtExit(gp.m)
 
-	cgocallbackg1(fn, frame, ctxt)
+	cgocallbackg1(fn, frame, ctxt) // will call unlockOSThread
 
 	// At this point unlockOSThread has been called.
 	// The following code must not change to a different m.
 	// This is enforced by checking incgo in the schedule function.
 
+	gp.m.incgo = true
+
+	if gp.m != checkm {
+		throw("m changed unexpectedly in cgocallbackg")
+	}
+
 	osPreemptExtEnter(gp.m)
 
-	gp.m.incgo = true
 	// going back to cgo call
 	reentersyscall(savedpc, uintptr(savedsp))
 
@@ -244,6 +251,11 @@ func cgocallbackg(fn, frame unsafe.Pointer, ctxt uintptr) {
 
 func cgocallbackg1(fn, frame unsafe.Pointer, ctxt uintptr) {
 	gp := getg()
+
+	// When we return, undo the call to lockOSThread in cgocallbackg.
+	// We must still stay on the same m.
+	defer unlockOSThread()
+
 	if gp.m.needextram || atomic.Load(&extraMWaiters) > 0 {
 		gp.m.needextram = false
 		systemstack(newextram)
@@ -323,10 +335,6 @@ func unwindm(restore *bool) {
 
 		releasem(mp)
 	}
-
-	// Undo the call to lockOSThread in cgocallbackg.
-	// We must still stay on the same m.
-	unlockOSThread()
 }
 
 // called from assembly
diff --git a/src/runtime/crash_cgo_test.go b/src/runtime/crash_cgo_test.go
index 7d25c51aa2..5729942cee 100644
--- a/src/runtime/crash_cgo_test.go
+++ b/src/runtime/crash_cgo_test.go
@@ -282,6 +282,15 @@ func TestCgoTracebackContext(t *testing.T) {
 	}
 }
 
+func TestCgoTracebackContextPreemption(t *testing.T) {
+	t.Parallel()
+	got := runTestProg(t, "testprogcgo", "TracebackContextPreemption")
+	want := "OK\n"
+	if got != want {
+		t.Errorf("expected %q got %v", want, got)
+	}
+}
+
 func testCgoPprof(t *testing.T, buildArg, runArg, top, bottom string) {
 	t.Parallel()
 	if runtime.GOOS != "linux" || (runtime.GOARCH != "amd64" && runtime.GOARCH != "ppc64le") {
diff --git a/src/runtime/testdata/testprogcgo/tracebackctxt.go b/src/runtime/testdata/testprogcgo/tracebackctxt.go
index 51fa4ad25c..62ff8eccd6 100644
--- a/src/runtime/testdata/testprogcgo/tracebackctxt.go
+++ b/src/runtime/testdata/testprogcgo/tracebackctxt.go
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// The __attribute__((weak)) used below doesn't seem to work on Windows.
-
 package main
 
 // Test the context argument to SetCgoTraceback.
@@ -14,20 +12,24 @@ package main
 extern void C1(void);
 extern void C2(void);
 extern void tcContext(void*);
+extern void tcContextSimple(void*);
 extern void tcTraceback(void*);
 extern void tcSymbolizer(void*);
 extern int getContextCount(void);
+extern void TracebackContextPreemptionCallGo(int);
 */
 import "C"
 
 import (
 	"fmt"
 	"runtime"
+	"sync"
 	"unsafe"
 )
 
 func init() {
 	register("TracebackContext", TracebackContext)
+	register("TracebackContextPreemption", TracebackContextPreemption)
 }
 
 var tracebackOK bool
@@ -105,3 +107,30 @@ wantLoop:
 		tracebackOK = false
 	}
 }
+
+// Issue 47441.
+func TracebackContextPreemption() {
+	runtime.SetCgoTraceback(0, unsafe.Pointer(C.tcTraceback), unsafe.Pointer(C.tcContextSimple), unsafe.Pointer(C.tcSymbolizer))
+
+	const funcs = 10
+	const calls = 1e5
+	var wg sync.WaitGroup
+	for i := 0; i < funcs; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			for j := 0; j < calls; j++ {
+				C.TracebackContextPreemptionCallGo(C.int(i*calls + j))
+			}
+		}(i)
+	}
+	wg.Wait()
+
+	fmt.Println("OK")
+}
+
+//export TracebackContextPreemptionGoFunction
+func TracebackContextPreemptionGoFunction(i C.int) {
+	// Do some busy work.
+	fmt.Sprintf("%d\n", i)
+}
diff --git a/src/runtime/testdata/testprogcgo/tracebackctxt_c.c b/src/runtime/testdata/testprogcgo/tracebackctxt_c.c
index 900cada0d3..910cb7b899 100644
--- a/src/runtime/testdata/testprogcgo/tracebackctxt_c.c
+++ b/src/runtime/testdata/testprogcgo/tracebackctxt_c.c
@@ -11,6 +11,7 @@
 // Functions exported from Go.
 extern void G1(void);
 extern void G2(void);
+extern void TracebackContextPreemptionGoFunction(int);
 
 void C1() {
 	G1();
@@ -62,10 +63,17 @@ void tcContext(void* parg) {
 	}
 }
 
+void tcContextSimple(void* parg) {
+	struct cgoContextArg* arg = (struct cgoContextArg*)(parg);
+	if (arg->context == 0) {
+		arg->context = 1;
+	}
+}
+
 void tcTraceback(void* parg) {
 	int base, i;
 	struct cgoTracebackArg* arg = (struct cgoTracebackArg*)(parg);
-	if (arg->context == 0) {
+	if (arg->context == 0 && arg->sigContext == 0) {
 		// This shouldn't happen in this program.
 		abort();
 	}
@@ -89,3 +97,7 @@ void tcSymbolizer(void *parg) {
 	arg->func = "cFunction";
 	arg->lineno = arg->pc + (arg->more << 16);
 }
+
+void TracebackContextPreemptionCallGo(int i) {
+	TracebackContextPreemptionGoFunction(i);
+}
-- 
GitLab


From b7a85e0003cedb1b48a1fd3ae5b746ec6330102e Mon Sep 17 00:00:00 2001
From: Damien Neil <dneil@google.com>
Date: Wed, 7 Jul 2021 16:34:34 -0700
Subject: [PATCH 2378/2400] net/http/httputil: close incoming ReverseProxy
 request body

Reading from an incoming request body after the request handler aborts
with a panic can cause a panic, becuse http.Server does not (contrary
to its documentation) close the request body in this case.

Always close the incoming request body in ReverseProxy.ServeHTTP to
ensure that any in-flight outgoing requests using the body do not
read from it.

Updates #46866
Fixes CVE-2021-36221

Change-Id: I310df269200ad8732c5d9f1a2b00de68725831df
Reviewed-on: https://go-review.googlesource.com/c/go/+/333191
Trust: Damien Neil <dneil@google.com>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
---
 src/net/http/httputil/reverseproxy.go      |  9 +++++
 src/net/http/httputil/reverseproxy_test.go | 39 ++++++++++++++++++++++
 2 files changed, 48 insertions(+)

diff --git a/src/net/http/httputil/reverseproxy.go b/src/net/http/httputil/reverseproxy.go
index 5d39955d62..8b63368386 100644
--- a/src/net/http/httputil/reverseproxy.go
+++ b/src/net/http/httputil/reverseproxy.go
@@ -235,6 +235,15 @@ func (p *ReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
 	if req.ContentLength == 0 {
 		outreq.Body = nil // Issue 16036: nil Body for http.Transport retries
 	}
+	if outreq.Body != nil {
+		// Reading from the request body after returning from a handler is not
+		// allowed, and the RoundTrip goroutine that reads the Body can outlive
+		// this handler. This can lead to a crash if the handler panics (see
+		// Issue 46866). Although calling Close doesn't guarantee there isn't
+		// any Read in flight after the handle returns, in practice it's safe to
+		// read after closing it.
+		defer outreq.Body.Close()
+	}
 	if outreq.Header == nil {
 		outreq.Header = make(http.Header) // Issue 33142: historical behavior was to always allocate
 	}
diff --git a/src/net/http/httputil/reverseproxy_test.go b/src/net/http/httputil/reverseproxy_test.go
index 1898ed8b8a..4b6ad77a29 100644
--- a/src/net/http/httputil/reverseproxy_test.go
+++ b/src/net/http/httputil/reverseproxy_test.go
@@ -1122,6 +1122,45 @@ func TestReverseProxy_PanicBodyError(t *testing.T) {
 	rproxy.ServeHTTP(httptest.NewRecorder(), req)
 }
 
+// Issue #46866: panic without closing incoming request body causes a panic
+func TestReverseProxy_PanicClosesIncomingBody(t *testing.T) {
+	backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		out := "this call was relayed by the reverse proxy"
+		// Coerce a wrong content length to induce io.ErrUnexpectedEOF
+		w.Header().Set("Content-Length", fmt.Sprintf("%d", len(out)*2))
+		fmt.Fprintln(w, out)
+	}))
+	defer backend.Close()
+	backendURL, err := url.Parse(backend.URL)
+	if err != nil {
+		t.Fatal(err)
+	}
+	proxyHandler := NewSingleHostReverseProxy(backendURL)
+	proxyHandler.ErrorLog = log.New(io.Discard, "", 0) // quiet for tests
+	frontend := httptest.NewServer(proxyHandler)
+	defer frontend.Close()
+	frontendClient := frontend.Client()
+
+	var wg sync.WaitGroup
+	for i := 0; i < 2; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < 10; j++ {
+				const reqLen = 6 * 1024 * 1024
+				req, _ := http.NewRequest("POST", frontend.URL, &io.LimitedReader{R: neverEnding('x'), N: reqLen})
+				req.ContentLength = reqLen
+				resp, _ := frontendClient.Transport.RoundTrip(req)
+				if resp != nil {
+					io.Copy(io.Discard, resp.Body)
+					resp.Body.Close()
+				}
+			}
+		}()
+	}
+	wg.Wait()
+}
+
 func TestSelectFlushInterval(t *testing.T) {
 	tests := []struct {
 		name string
-- 
GitLab


From b8ca6e59eda969c1d3aed9b0c5bd9e99cf0e7dfe Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Fri, 30 Jul 2021 11:04:36 -0700
Subject: [PATCH 2379/2400] all: gofmt

Change-Id: Icfafcfb62a389d9fd2e7a4d17809486ed91f15c3
Reviewed-on: https://go-review.googlesource.com/c/go/+/338629
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/crypto/ed25519/internal/edwards25519/field/fe_amd64.go | 1 +
 src/runtime/export_debug_regabiargs_off_test.go            | 3 +--
 src/runtime/export_debug_regabiargs_on_test.go             | 3 +--
 3 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/crypto/ed25519/internal/edwards25519/field/fe_amd64.go b/src/crypto/ed25519/internal/edwards25519/field/fe_amd64.go
index 44dc8e8caf..8fe583939f 100644
--- a/src/crypto/ed25519/internal/edwards25519/field/fe_amd64.go
+++ b/src/crypto/ed25519/internal/edwards25519/field/fe_amd64.go
@@ -1,5 +1,6 @@
 // Code generated by command: go run fe_amd64_asm.go -out ../fe_amd64.s -stubs ../fe_amd64.go -pkg field. DO NOT EDIT.
 
+//go:build amd64 && gc && !purego
 // +build amd64,gc,!purego
 
 package field
diff --git a/src/runtime/export_debug_regabiargs_off_test.go b/src/runtime/export_debug_regabiargs_off_test.go
index fce37ab4d1..5009003d27 100644
--- a/src/runtime/export_debug_regabiargs_off_test.go
+++ b/src/runtime/export_debug_regabiargs_off_test.go
@@ -3,8 +3,7 @@
 // license that can be found in the LICENSE file.
 
 //go:build amd64 && linux && !goexperiment.regabiargs
-// +build amd64,linux
-// +build !goexperiment.regabiargs
+// +build amd64,linux,!goexperiment.regabiargs
 
 package runtime
 
diff --git a/src/runtime/export_debug_regabiargs_on_test.go b/src/runtime/export_debug_regabiargs_on_test.go
index 3c65127e56..e1b72efd0f 100644
--- a/src/runtime/export_debug_regabiargs_on_test.go
+++ b/src/runtime/export_debug_regabiargs_on_test.go
@@ -3,8 +3,7 @@
 // license that can be found in the LICENSE file.
 
 //go:build amd64 && linux && goexperiment.regabiargs
-// +build amd64,linux
-// +build goexperiment.regabiargs
+// +build amd64,linux,goexperiment.regabiargs
 
 package runtime
 
-- 
GitLab


From 8a7ee4c51e992174d432ce0f40d9387a32d6ee4a Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Sat, 31 Jul 2021 15:39:08 -0700
Subject: [PATCH 2380/2400] io/fs: don't use absolute path in DirEntry.Name doc

Fixes #47485

Change-Id: I64ac00905a403b7594c706141679051a93058a31
Reviewed-on: https://go-review.googlesource.com/c/go/+/338889
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
---
 src/io/fs/fs.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/io/fs/fs.go b/src/io/fs/fs.go
index e1be32478e..e603afadb0 100644
--- a/src/io/fs/fs.go
+++ b/src/io/fs/fs.go
@@ -86,7 +86,7 @@ type File interface {
 type DirEntry interface {
 	// Name returns the name of the file (or subdirectory) described by the entry.
 	// This name is only the final element of the path (the base name), not the entire path.
-	// For example, Name would return "hello.go" not "/home/gopher/hello.go".
+	// For example, Name would return "hello.go" not "home/gopher/hello.go".
 	Name() string
 
 	// IsDir reports whether the entry describes a directory.
-- 
GitLab


From 72ab3ff68b1ec894fe5599ec82b8849f3baa9d94 Mon Sep 17 00:00:00 2001
From: Alexander Rakoczy <alex@golang.org>
Date: Mon, 2 Aug 2021 12:43:59 -0400
Subject: [PATCH 2381/2400] [release-branch.go1.17] go1.17rc2

Change-Id: I1f1ada15d7365db3e48599fbaddd6a65a8e5d06c
Reviewed-on: https://go-review.googlesource.com/c/go/+/339130
Run-TryBot: Alexander Rakoczy <alex@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Alexander Rakoczy <alex@golang.org>
Reviewed-by: David Chase <drchase@google.com>
---
 VERSION | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/VERSION b/VERSION
index cc1496155f..718f37b97d 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-go1.17rc1
\ No newline at end of file
+go1.17rc2
\ No newline at end of file
-- 
GitLab


From 6e738868a7a943d7d4fd6bb1963e7f6d78111726 Mon Sep 17 00:00:00 2001
From: Damien Neil <dneil@google.com>
Date: Tue, 3 Aug 2021 19:38:37 -0700
Subject: [PATCH 2382/2400] net/http: speed up and deflake
 TestCancelRequestWhenSharingConnection

This test made many requests over the same connection for 10
seconds, trusting that this will exercise the request cancelation
race from #41600.

Change the test to exhibit the specific race in a targeted fashion
with only two requests.

Updates #41600.
Updates #47016.

Change-Id: If99c9b9331ff645f6bb67fe9fb79b8aab8784710
Reviewed-on: https://go-review.googlesource.com/c/go/+/339594
Trust: Damien Neil <dneil@google.com>
Run-TryBot: Damien Neil <dneil@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Heschi Kreinick <heschi@google.com>
---
 src/net/http/transport_test.go | 77 ++++++++++++++++++++++------------
 1 file changed, 51 insertions(+), 26 deletions(-)

diff --git a/src/net/http/transport_test.go b/src/net/http/transport_test.go
index 690e0c299d..eeaa492644 100644
--- a/src/net/http/transport_test.go
+++ b/src/net/http/transport_test.go
@@ -6441,10 +6441,11 @@ func TestErrorWriteLoopRace(t *testing.T) {
 // Test that a new request which uses the connection of an active request
 // cannot cause it to be canceled as well.
 func TestCancelRequestWhenSharingConnection(t *testing.T) {
-	if testing.Short() {
-		t.Skip("skipping in short mode")
-	}
+	reqc := make(chan chan struct{}, 2)
 	ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, req *Request) {
+		ch := make(chan struct{}, 1)
+		reqc <- ch
+		<-ch
 		w.Header().Add("Content-Length", "0")
 	}))
 	defer ts.Close()
@@ -6456,34 +6457,58 @@ func TestCancelRequestWhenSharingConnection(t *testing.T) {
 
 	var wg sync.WaitGroup
 
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	wg.Add(1)
+	putidlec := make(chan chan struct{})
+	go func() {
+		defer wg.Done()
+		ctx := httptrace.WithClientTrace(context.Background(), &httptrace.ClientTrace{
+			PutIdleConn: func(error) {
+				// Signal that the idle conn has been returned to the pool,
+				// and wait for the order to proceed.
+				ch := make(chan struct{})
+				putidlec <- ch
+				<-ch
+			},
+		})
+		req, _ := NewRequestWithContext(ctx, "GET", ts.URL, nil)
+		res, err := client.Do(req)
+		if err == nil {
+			res.Body.Close()
+		}
+		if err != nil {
+			t.Errorf("request 1: got err %v, want nil", err)
+		}
+	}()
 
-	for i := 0; i < 10; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			for ctx.Err() == nil {
-				reqctx, reqcancel := context.WithCancel(ctx)
-				go reqcancel()
-				req, _ := NewRequestWithContext(reqctx, "GET", ts.URL, nil)
-				res, err := client.Do(req)
-				if err == nil {
-					res.Body.Close()
-				}
-			}
-		}()
-	}
+	// Wait for the first request to receive a response and return the
+	// connection to the idle pool.
+	r1c := <-reqc
+	close(r1c)
+	idlec := <-putidlec
 
-	for ctx.Err() == nil {
-		req, _ := NewRequest("GET", ts.URL, nil)
-		if res, err := client.Do(req); err != nil {
-			t.Errorf("unexpected: %p %v", req, err)
-			break
-		} else {
+	wg.Add(1)
+	cancelctx, cancel := context.WithCancel(context.Background())
+	go func() {
+		defer wg.Done()
+		req, _ := NewRequestWithContext(cancelctx, "GET", ts.URL, nil)
+		res, err := client.Do(req)
+		if err == nil {
 			res.Body.Close()
 		}
-	}
+		if !errors.Is(err, context.Canceled) {
+			t.Errorf("request 2: got err %v, want Canceled", err)
+		}
+	}()
 
+	// Wait for the second request to arrive at the server, and then cancel
+	// the request context.
+	r2c := <-reqc
 	cancel()
+
+	// Give the cancelation a moment to take effect, and then unblock the first request.
+	time.Sleep(1 * time.Millisecond)
+	close(idlec)
+
+	close(r2c)
 	wg.Wait()
 }
-- 
GitLab


From fd45e267c2f6ce7c6a88842e3ad94d3469223e42 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 5 Aug 2021 13:05:23 -0700
Subject: [PATCH 2383/2400] runtime: warn that KeepAlive is not an
 unsafe.Pointer workaround

Even experienced users occasionally mistake that runtime.KeepAlive can
be used as a workaround for following the unsafe.Pointer safety rules,
but it cannot. Add an explicit warning to this effect to dissuade
users from trying to use it as such.

Fixes #47562.

Change-Id: I842e33a3e1c080933c6b1bd1b6318448adbf495c
Reviewed-on: https://go-review.googlesource.com/c/go/+/340269
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/runtime/mfinal.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/runtime/mfinal.go b/src/runtime/mfinal.go
index fd318d49a8..c134a0f22d 100644
--- a/src/runtime/mfinal.go
+++ b/src/runtime/mfinal.go
@@ -466,6 +466,10 @@ okarg:
 // Without the KeepAlive call, the finalizer could run at the start of
 // syscall.Read, closing the file descriptor before syscall.Read makes
 // the actual system call.
+//
+// Note: KeepAlive should only be used to prevent finalizers from
+// running prematurely. In particular, when used with unsafe.Pointer,
+// the rules for valid uses of unsafe.Pointer still apply.
 func KeepAlive(x interface{}) {
 	// Introduce a use of x that the compiler can't eliminate.
 	// This makes sure x is alive on entry. We need x to be alive
-- 
GitLab


From 70546f6404c5927a9868a80ccbf4c6c2beaea671 Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Thu, 5 Aug 2021 13:37:29 +0200
Subject: [PATCH 2384/2400] runtime: allow arm64 SEH to be called if illegal
 instruction

DLLs built with recent Microsoft toolchains for ARM64 test for ARMv8.1
atomics by potentially calling an illegal instruction, and then trapping
the exception to disable use of them by way of a structured exception
handler. However, vectored exception handlers are always called before
structured exception handlers. When LoadLibrary-ing DLLs that do this
probing during initialization, our lastcontinuehandler winds up being
called, and then crashing, but actually it should give execution back to
the library to handle the exception and fix up the state. So special
case this for arm64 with illegal instructions, and hope that we're not
masking other things in external DLLs that might more fatally trigger an
illegal instruction exception.

Updates #47576.

Change-Id: I341ab99cd8d513ae999b75596749d49779072022
Reviewed-on: https://go-review.googlesource.com/c/go/+/340070
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 src/runtime/signal_windows.go | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/runtime/signal_windows.go b/src/runtime/signal_windows.go
index f2ce24d735..b720ddcf16 100644
--- a/src/runtime/signal_windows.go
+++ b/src/runtime/signal_windows.go
@@ -183,6 +183,17 @@ func lastcontinuehandler(info *exceptionrecord, r *context, gp *g) int32 {
 		return _EXCEPTION_CONTINUE_SEARCH
 	}
 
+	// VEH is called before SEH, but arm64 MSVC DLLs use SEH to trap
+	// illegal instructions during runtime initialization to determine
+	// CPU features, so if we make it to the last handler and we're
+	// arm64 and it's an illegal instruction and this is coming from
+	// non-Go code, then assume it's this runtime probing happen, and
+	// pass that onward to SEH.
+	if GOARCH == "arm64" && info.exceptioncode == _EXCEPTION_ILLEGAL_INSTRUCTION &&
+		(r.ip() < firstmoduledata.text || firstmoduledata.etext < r.ip()) {
+		return _EXCEPTION_CONTINUE_SEARCH
+	}
+
 	winthrow(info, r, gp)
 	return 0 // not reached
 }
-- 
GitLab


From 63b968f4f86f4c23ce92b7ac2feda4fc7ca17c8e Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 16 Jul 2021 16:51:11 -0400
Subject: [PATCH 2385/2400] doc/go1.17: clarify Modules changes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Writing CL 333629 clarified my thinking about the behavioral changes
associated with lazy loading. There are really two interrelated
changes — graph pruning, and lazy loading proper — that are both made
possible by the added redundancy in the go.mod file.

(I had initially approached the whole cluster of features as “lazy
loading” because that was the starting point for the design. Graph
pruning came into the picture when we looked at how to bound the
worst-case behavior of lazy loading, but it is really the more
important of the two aspects of the design.)

Note that this change adds links to doc anchors added in CL 333629.

Fixes #36460
Fixes #47397

Change-Id: I0ef4af57f647bf5ee210ea7099191fb4befa2cc1
Reviewed-on: https://go-review.googlesource.com/c/go/+/335135
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
---
 doc/go1.17.html | 70 +++++++++++++++++++++++++++++++------------------
 1 file changed, 45 insertions(+), 25 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 48811e6b67..a8307bacac 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -134,35 +134,54 @@ Do not send CLs removing the interior tags from such phrases.
 
 <h3 id="go-command">Go command</h3>
 
-<h4 id="lazy-loading">Lazy module loading</h4>
+<a id="lazy-loading"><!-- for existing links only --></a>
+<h4 id="graph-pruning">Pruned module graphs in <code>go 1.17</code> modules</h4>
 
 <p><!-- golang.org/issue/36460 -->
+  If a module specifies <code>go</code> <code>1.17</code> or higher, the module
+  graph includes only the <em>immediate</em> dependencies of
+  other <code>go</code> <code>1.17</code> modules, not their full transitive
+  dependencies. (See <a href="/ref/mod#graph-pruning">Module graph pruning</a>
+  for more detail.)
+</p>
+
+<p>
+  For the <code>go</code> command to correctly resolve transitive imports using
+  the pruned module graph, the <code>go.mod</code> file for each module needs to
+  include more detail about the transitive dependencies relevant to that module.
   If a module specifies <code>go</code> <code>1.17</code> or higher in its
-  <code>go.mod</code> file, its transitive requirements are now loaded lazily,
-  avoiding the need to download or read <code>go.mod</code> files for
-  otherwise-irrelevant dependencies. To support lazy loading, in Go 1.17 modules
-  the <code>go</code> command maintains <em>explicit</em> requirements in
-  the <code>go.mod</code> file for every dependency that provides any package
-  transitively imported by any package or test within the module.
-  See <a href="https://golang.org/design/36460-lazy-module-loading">the design
-  document</a> for more detail.
-  <!-- TODO(bcmills): replace the design-doc link with proper documentation. -->
+  <code>go.mod</code> file, its <codeg>go.mod</code> file now contains an
+  explicit <a href="/ref/mod#go-mod-file-require"><code>require</code>
+  directive</a> for every module that provides a transitively-imported package.
+  (In previous versions, the <code>go.mod</code> file typically only included
+  explicit requirements for <em>directly</em>-imported packages.)
+<p>
+
+<p>
+  Since the expanded <code>go.mod</code> file needed for module graph pruning
+  includes all of the dependencies needed to load the imports of any package in
+  the main module, if the main module specifies
+  <code>go</code> <code>1.17</code> or higher the <code>go</code> tool no longer
+  reads (or even downloads) <code>go.mod</code> files for dependencies if they
+  are not needed in order to complete the requested command.
+  (See <a href="/ref/mod#lazy-loading">Lazy loading</a>.)
 </p>
 
 <p><!-- golang.org/issue/45965 -->
-  Because the number of additional explicit requirements in the go.mod file may
-  be substantial, in a Go 1.17 module the newly-added requirements
-  on <em>indirect</em> dependencies are maintained in a
-  separate <code>require</code> block from the block containing direct
-  dependencies.
+  Because the number of explicit requirements may be substantially larger in an
+  expanded Go 1.17 <code>go.mod</code> file, the newly-added requirements
+  on <em>indirect</em> dependencies in a <code>go</code> <code>1.17</code>
+  module are maintained in a separate <code>require</code> block from the block
+  containing direct dependencies.
 </p>
 
 <p><!-- golang.org/issue/45094 -->
-  To facilitate the upgrade to lazy loading, the
-  <code>go</code> <code>mod</code> <code>tidy</code> subcommand now supports
-  a <code>-go</code> flag to set or change the <code>go</code> version in
-  the <code>go.mod</code> file. To enable lazy loading for an existing module
-  without changing the selected versions of its dependencies, run:
+  To facilitate the upgrade to Go 1.17 pruned module graphs, the
+  <a href="/ref/mod#go-mod-tidy"><code>go</code> <code>mod</code> <code>tidy</code></a>
+  subcommand now supports a <code>-go</code> flag to set or change
+  the <code>go</code> version in the <code>go.mod</code> file. To convert
+  the <code>go.mod</code> file for an existing module to Go 1.17 without
+  changing the selected versions of its dependencies, run:
 </p>
 
 <pre>
@@ -199,10 +218,10 @@ Do not send CLs removing the interior tags from such phrases.
 </p>
 
 <p><!-- golang.org/issue/46366 -->
-  The <code>go</code> <code>mod</code> <code>graph</code> subcommand also
-  supports the <code>-go</code> flag, which causes it to report the graph as
-  seen by the indicated Go version, showing dependencies that may otherwise be
-  pruned out by lazy loading.
+  The <a href="/ref/mod#go-mod-graph"><code>go</code> <code>mod</code> <code>graph</code></a>
+  subcommand also supports the <code>-go</code> flag, which causes it to report
+  the graph as seen by the indicated Go version, showing dependencies that may
+  otherwise be pruned out.
 </p>
 
 <h4 id="module-deprecation-comments">Module deprecation comments</h4>
@@ -270,7 +289,8 @@ Do not send CLs removing the interior tags from such phrases.
 
 <p><!-- golang.org/issue/36876 -->
   If the main module specifies <code>go</code> <code>1.17</code> or higher,
-  <code>go</code> <code>mod</code> <code>vendor</code> now annotates
+  <a href="/ref/mod#go-mod-vendor"><code>go</code> <code>mod</code> <code>vendor</code></a>
+  now annotates
   <code>vendor/modules.txt</code> with the <code>go</code> version indicated by
   each vendored module in its own <code>go.mod</code> file. The annotated
   version is used when building the module's packages from vendored source code.
-- 
GitLab


From 8eaf4d16bc69724cd450345cbaf55f2e2aef9b9c Mon Sep 17 00:00:00 2001
From: Cherry Mui <cherryyz@google.com>
Date: Fri, 6 Aug 2021 15:37:10 -0400
Subject: [PATCH 2386/2400] make.bash: do not overwrite GO_LDSO if already set

Change-Id: I704bdb411bda3d8a40906c12f182e268dca4718f
Reviewed-on: https://go-review.googlesource.com/c/go/+/340450
Trust: Cherry Mui <cherryyz@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 src/make.bash | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/make.bash b/src/make.bash
index 4fb13f6275..f5e1b60bd5 100755
--- a/src/make.bash
+++ b/src/make.bash
@@ -130,8 +130,8 @@ if [ "$(uname -s)" = "GNU/kFreeBSD" ]; then
 	export CGO_ENABLED=0
 fi
 
-# Test which linker/loader our system is using
-if type readelf >/dev/null 2>&1; then
+# Test which linker/loader our system is using, if GO_LDSO is not set.
+if [ -z "$GO_LDSO" ] && type readelf >/dev/null 2>&1; then
 	if echo "int main() { return 0; }" | ${CC:-cc} -o ./test-musl-ldso -x c - >/dev/null 2>&1; then
 		LDSO=$(readelf -l ./test-musl-ldso | grep 'interpreter:' | sed -e 's/^.*interpreter: \(.*\)[]]/\1/') >/dev/null 2>&1
 		[ -z "$LDSO" ] || export GO_LDSO="$LDSO"
-- 
GitLab


From 891547e2d4bc2a23973e2c9f972ce69b2b48478e Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" <bcmills@google.com>
Date: Fri, 6 Aug 2021 21:10:31 -0400
Subject: [PATCH 2387/2400] doc/go1.17: fix a typo introduced in CL 335135

Change-Id: I62388bcb6d6f910ffa95d3db856ea29838573256
Reviewed-on: https://go-review.googlesource.com/c/go/+/340590
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Rob Pike <r@golang.org>
---
 doc/go1.17.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index a8307bacac..d469f400ad 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -150,7 +150,7 @@ Do not send CLs removing the interior tags from such phrases.
   the pruned module graph, the <code>go.mod</code> file for each module needs to
   include more detail about the transitive dependencies relevant to that module.
   If a module specifies <code>go</code> <code>1.17</code> or higher in its
-  <code>go.mod</code> file, its <codeg>go.mod</code> file now contains an
+  <code>go.mod</code> file, its <code>go.mod</code> file now contains an
   explicit <a href="/ref/mod#go-mod-file-require"><code>require</code>
   directive</a> for every module that provides a transitively-imported package.
   (In previous versions, the <code>go.mod</code> file typically only included
-- 
GitLab


From 507cc341ec2cb96b0199800245f222146f799266 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Mon, 9 Aug 2021 00:52:21 +0700
Subject: [PATCH 2388/2400] doc: add example for conversion from slice
 expressions to array ptr

Fixes #47599

Change-Id: I8f4ccd3b0c2bcdb057ee853163b4421229141333
Reviewed-on: https://go-review.googlesource.com/c/go/+/340351
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
---
 doc/go_spec.html | 1 +
 1 file changed, 1 insertion(+)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index 0e14a1f3b6..fd5fee46eb 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -4329,6 +4329,7 @@ a <a href="#Run_time_panics">run-time panic</a> occurs.
 <pre>
 s := make([]byte, 2, 4)
 s0 := (*[0]byte)(s)      // s0 != nil
+s1 := (*[1]byte)(s[1:])  // &amp;s1[0] == &amp;s[1]
 s2 := (*[2]byte)(s)      // &amp;s2[0] == &amp;s[0]
 s4 := (*[4]byte)(s)      // panics: len([4]byte) > len(s)
 
-- 
GitLab


From 7aeaad5c86174f61b084d72d89fb02d7fc64391c Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Wed, 4 Aug 2021 20:55:28 -0700
Subject: [PATCH 2389/2400] runtime/cgo: when using msan explicitly unpoison
 cgoCallers

This avoids an incorrect msan uninitialized memory report when using
runtime.SetCgoTraceback when a signal occurs while the fifth argument
register is undefined. See the issue for more details.

Fixes #47543

Change-Id: I3d1b673e2c93471ccdae0171a99b88b5a6062840
Reviewed-on: https://go-review.googlesource.com/c/go/+/339902
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Austin Clements <austin@google.com>
---
 misc/cgo/testsanitizers/msan_test.go      |   1 +
 misc/cgo/testsanitizers/testdata/msan8.go | 109 ++++++++++++++++++++++
 src/runtime/cgo/gcc_traceback.c           |  20 ++++
 3 files changed, 130 insertions(+)
 create mode 100644 misc/cgo/testsanitizers/testdata/msan8.go

diff --git a/misc/cgo/testsanitizers/msan_test.go b/misc/cgo/testsanitizers/msan_test.go
index 2a3494fbfc..5ee9947a58 100644
--- a/misc/cgo/testsanitizers/msan_test.go
+++ b/misc/cgo/testsanitizers/msan_test.go
@@ -42,6 +42,7 @@ func TestMSAN(t *testing.T) {
 		{src: "msan5.go"},
 		{src: "msan6.go"},
 		{src: "msan7.go"},
+		{src: "msan8.go"},
 		{src: "msan_fail.go", wantErr: true},
 	}
 	for _, tc := range cases {
diff --git a/misc/cgo/testsanitizers/testdata/msan8.go b/misc/cgo/testsanitizers/testdata/msan8.go
new file mode 100644
index 0000000000..1cb5c5677f
--- /dev/null
+++ b/misc/cgo/testsanitizers/testdata/msan8.go
@@ -0,0 +1,109 @@
+// Copyright 2021 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
+
+/*
+#include <pthread.h>
+#include <signal.h>
+#include <stdint.h>
+
+#include <sanitizer/msan_interface.h>
+
+// cgoTracebackArg is the type of the argument passed to msanGoTraceback.
+struct cgoTracebackArg {
+	uintptr_t context;
+	uintptr_t sigContext;
+	uintptr_t* buf;
+	uintptr_t max;
+};
+
+// msanGoTraceback is registered as the cgo traceback function.
+// This will be called when a signal occurs.
+void msanGoTraceback(void* parg) {
+	struct cgoTracebackArg* arg = (struct cgoTracebackArg*)(parg);
+        arg->buf[0] = 0;
+}
+
+// msanGoWait will be called with all registers undefined as far as
+// msan is concerned. It just waits for a signal.
+// Because the registers are msan-undefined, the signal handler will
+// be invoked with all registers msan-undefined.
+__attribute__((noinline))
+void msanGoWait(unsigned long a1, unsigned long a2, unsigned long a3, unsigned long a4, unsigned long a5, unsigned long a6) {
+	sigset_t mask;
+
+	sigemptyset(&mask);
+        sigsuspend(&mask);
+}
+
+// msanGoSignalThread is the thread ID of the msanGoLoop thread.
+static pthread_t msanGoSignalThread;
+
+// msanGoSignalThreadSet is used to record that msanGoSignalThread
+// has been initialized. This is accessed atomically.
+static int32_t msanGoSignalThreadSet;
+
+// uninit is explicitly poisoned, so that we can make all registers
+// undefined by calling msanGoWait.
+static unsigned long uninit;
+
+// msanGoLoop loops calling msanGoWait, with the arguments passed
+// such that msan thinks that they are undefined. msan permits
+// undefined values to be used as long as they are not used to
+// for conditionals or for memory access.
+void msanGoLoop() {
+	int i;
+
+	msanGoSignalThread = pthread_self();
+        __atomic_store_n(&msanGoSignalThreadSet, 1, __ATOMIC_SEQ_CST);
+
+	// Force uninit to be undefined for msan.
+	__msan_poison(&uninit, sizeof uninit);
+	for (i = 0; i < 100; i++) {
+		msanGoWait(uninit, uninit, uninit, uninit, uninit, uninit);
+        }
+}
+
+// msanGoReady returns whether msanGoSignalThread is set.
+int msanGoReady() {
+	return __atomic_load_n(&msanGoSignalThreadSet, __ATOMIC_SEQ_CST) != 0;
+}
+
+// msanGoSendSignal sends a signal to the msanGoLoop thread.
+void msanGoSendSignal() {
+	pthread_kill(msanGoSignalThread, SIGWINCH);
+}
+*/
+import "C"
+
+import (
+	"runtime"
+	"time"
+)
+
+func main() {
+	runtime.SetCgoTraceback(0, C.msanGoTraceback, nil, nil)
+
+	c := make(chan bool)
+	go func() {
+		defer func() { c <- true }()
+		C.msanGoLoop()
+	}()
+
+	for C.msanGoReady() == 0 {
+		time.Sleep(time.Microsecond)
+	}
+
+loop:
+	for {
+		select {
+		case <-c:
+			break loop
+		default:
+			C.msanGoSendSignal()
+			time.Sleep(time.Microsecond)
+		}
+	}
+}
diff --git a/src/runtime/cgo/gcc_traceback.c b/src/runtime/cgo/gcc_traceback.c
index d86331c583..6e9470c43c 100644
--- a/src/runtime/cgo/gcc_traceback.c
+++ b/src/runtime/cgo/gcc_traceback.c
@@ -7,6 +7,14 @@
 #include <stdint.h>
 #include "libcgo.h"
 
+#ifndef __has_feature
+#define __has_feature(x) 0
+#endif
+
+#if __has_feature(memory_sanitizer)
+#include <sanitizer/msan_interface.h>
+#endif
+
 // Call the user's traceback function and then call sigtramp.
 // The runtime signal handler will jump to this code.
 // We do it this way so that the user's traceback function will be called
@@ -19,6 +27,18 @@ x_cgo_callers(uintptr_t sig, void *info, void *context, void (*cgoTraceback)(str
 	arg.SigContext = (uintptr_t)(context);
 	arg.Buf = cgoCallers;
 	arg.Max = 32; // must match len(runtime.cgoCallers)
+
+#if __has_feature(memory_sanitizer)
+        // This function is called directly from the signal handler.
+        // The arguments are passed in registers, so whether msan
+        // considers cgoCallers to be initialized depends on whether
+        // it considers the appropriate register to be initialized.
+        // That can cause false reports in rare cases.
+        // Explicitly unpoison the memory to avoid that.
+        // See issue #47543 for more details.
+        __msan_unpoison(&arg, sizeof arg);
+#endif
+
 	(*cgoTraceback)(&arg);
 	sigtramp(sig, info, context);
 }
-- 
GitLab


From f1dce319ffd9d3663f522141abfb9c1ec9d92e04 Mon Sep 17 00:00:00 2001
From: Jay Conrod <jayconrod@google.com>
Date: Thu, 5 Aug 2021 15:18:42 -0700
Subject: [PATCH 2390/2400] cmd/go: with -mod=vendor, don't panic if there are
 duplicate requirements

In loadModFile with -mod=vendor, load the vendor list and use it to
initialize the module graph before calling updateRoots.

In updateLazyRoots with any mode other than "mod", return the original
*Requirements if no roots needed to be upgraded, even if there are
inconsistencies. This means 'go list -m -mod=readonly' and -mod=vendor
may succeed if there are duplicate requirements or requirements on
versions of the main module.

Fixes #47565

Change-Id: I4640dffc4a7359367cc910da0d29e3538bfd1ca4
Reviewed-on: https://go-review.googlesource.com/c/go/+/340252
Trust: Jay Conrod <jayconrod@google.com>
Trust: Bryan C. Mills <bcmills@google.com>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
---
 src/cmd/go/internal/modload/buildlist.go      | 19 +++++++++
 src/cmd/go/internal/modload/init.go           | 39 +++++++++----------
 .../go/testdata/script/mod_tidy_lazy_self.txt | 17 +++-----
 .../mod_vendor_redundant_requirement.txt      | 29 ++++++++++++++
 4 files changed, 72 insertions(+), 32 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/mod_vendor_redundant_requirement.txt

diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index 604a57b437..bf69567316 100644
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -191,6 +191,19 @@ func (rs *Requirements) rootSelected(path string) (version string, ok bool) {
 	return "", false
 }
 
+// hasRedundantRoot returns true if the root list contains multiple requirements
+// of the same module or a requirement on any version of the main module.
+// Redundant requirements should be pruned, but they may influence version
+// selection.
+func (rs *Requirements) hasRedundantRoot() bool {
+	for i, m := range rs.rootModules {
+		if m.Path == Target.Path || (i > 0 && m.Path == rs.rootModules[i-1].Path) {
+			return true
+		}
+	}
+	return false
+}
+
 // Graph returns the graph of module requirements loaded from the current
 // root modules (as reported by RootModules).
 //
@@ -882,6 +895,12 @@ func updateLazyRoots(ctx context.Context, direct map[string]bool, rs *Requiremen
 		// and (trivially) version.
 
 		if !rootsUpgraded {
+			if cfg.BuildMod != "mod" {
+				// The only changes to the root set (if any) were to remove duplicates.
+				// The requirements are consistent (if perhaps redundant), so keep the
+				// original rs to preserve its ModuleGraph.
+				return rs, nil
+			}
 			// The root set has converged: every root going into this iteration was
 			// already at its selected version, although we have have removed other
 			// (redundant) roots for the same path.
diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index a8cbd9fe16..45f724d5e3 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -449,13 +449,22 @@ func loadModFile(ctx context.Context) (rs *Requirements, needCommit bool) {
 	}
 
 	setDefaultBuildMod() // possibly enable automatic vendoring
-	rs = requirementsFromModFile(ctx)
-
+	rs = requirementsFromModFile()
 	if cfg.BuildMod == "vendor" {
 		readVendorList()
 		checkVendorConsistency()
 		rs.initVendor(vendorList)
 	}
+	if rs.hasRedundantRoot() {
+		// If any module path appears more than once in the roots, we know that the
+		// go.mod file needs to be updated even though we have not yet loaded any
+		// transitive dependencies.
+		rs, err = updateRoots(ctx, rs.direct, rs, nil, nil, false)
+		if err != nil {
+			base.Fatalf("go: %v", err)
+		}
+	}
+
 	if index.goVersionV == "" {
 		// TODO(#45551): Do something more principled instead of checking
 		// cfg.CmdName directly here.
@@ -530,7 +539,12 @@ func CreateModFile(ctx context.Context, modPath string) {
 		base.Fatalf("go: %v", err)
 	}
 
-	commitRequirements(ctx, modFileGoVersion(), requirementsFromModFile(ctx))
+	rs := requirementsFromModFile()
+	rs, err = updateRoots(ctx, rs.direct, rs, nil, nil, false)
+	if err != nil {
+		base.Fatalf("go: %v", err)
+	}
+	commitRequirements(ctx, modFileGoVersion(), rs)
 
 	// Suggest running 'go mod tidy' unless the project is empty. Even if we
 	// imported all the correct requirements above, we're probably missing
@@ -641,9 +655,8 @@ func initTarget(m module.Version) {
 
 // requirementsFromModFile returns the set of non-excluded requirements from
 // the global modFile.
-func requirementsFromModFile(ctx context.Context) *Requirements {
+func requirementsFromModFile() *Requirements {
 	roots := make([]module.Version, 0, len(modFile.Require))
-	mPathCount := map[string]int{Target.Path: 1}
 	direct := map[string]bool{}
 	for _, r := range modFile.Require {
 		if index != nil && index.exclude[r.Mod] {
@@ -656,28 +669,12 @@ func requirementsFromModFile(ctx context.Context) *Requirements {
 		}
 
 		roots = append(roots, r.Mod)
-		mPathCount[r.Mod.Path]++
 		if !r.Indirect {
 			direct[r.Mod.Path] = true
 		}
 	}
 	module.Sort(roots)
 	rs := newRequirements(modDepthFromGoVersion(modFileGoVersion()), roots, direct)
-
-	// If any module path appears more than once in the roots, we know that the
-	// go.mod file needs to be updated even though we have not yet loaded any
-	// transitive dependencies.
-	for _, n := range mPathCount {
-		if n > 1 {
-			var err error
-			rs, err = updateRoots(ctx, rs.direct, rs, nil, nil, false)
-			if err != nil {
-				base.Fatalf("go: %v", err)
-			}
-			break
-		}
-	}
-
 	return rs
 }
 
diff --git a/src/cmd/go/testdata/script/mod_tidy_lazy_self.txt b/src/cmd/go/testdata/script/mod_tidy_lazy_self.txt
index ffcea18603..9abbabd2eb 100644
--- a/src/cmd/go/testdata/script/mod_tidy_lazy_self.txt
+++ b/src/cmd/go/testdata/script/mod_tidy_lazy_self.txt
@@ -2,18 +2,13 @@
 # 'go mod tidy' should not panic if the main module initially
 # requires an older version of itself.
 
+# A module may require an older version of itself without error. This is
+# inconsistent (the required version is never selected), but we still get
+# a reproducible build list.
+go list -m all
+stdout '^golang.org/issue/46078$'
 
-# A module that explicitly requires an older version of itself should be
-# rejected as inconsistent: we enforce that every explicit requirement is the
-# selected version of its module path, but the selected version of the main
-# module is always itself — not some explicit version.
-
-! go list -m all
-stderr '^go: updates to go\.mod needed; to update it:\n\tgo mod tidy$'
-
-
-# The suggested 'go mod tidy' command should succeed (not crash).
-
+# 'go mod tidy' should fix this (and not crash).
 go mod tidy
 
 
diff --git a/src/cmd/go/testdata/script/mod_vendor_redundant_requirement.txt b/src/cmd/go/testdata/script/mod_vendor_redundant_requirement.txt
new file mode 100644
index 0000000000..3f6f5c5276
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_vendor_redundant_requirement.txt
@@ -0,0 +1,29 @@
+# 'go list -mod=vendor' should succeed even when go.mod contains redundant
+# requirements. Verifies #47565.
+go list -mod=vendor
+
+-- go.mod --
+module m
+
+go 1.17
+
+require example.com/m v0.0.0
+require example.com/m v0.0.0
+
+replace example.com/m v0.0.0 => ./m
+-- m/go.mod --
+module example.com/m
+
+go 1.17
+-- m/m.go --
+package m
+-- use.go --
+package use
+
+import _ "example.com/m"
+-- vendor/example.com/m/m.go --
+package m
+-- vendor/modules.txt --
+# example.com/m v0.0.0 => ./m
+## explicit; go 1.17
+example.com/m
-- 
GitLab


From 1f9c9d853067635305f72e247c5b49e3fa5da8af Mon Sep 17 00:00:00 2001
From: fanzha02 <fannie.zhang@arm.com>
Date: Tue, 3 Aug 2021 12:11:29 +0800
Subject: [PATCH 2391/2400] doc: use "high address/low address" instead of
 "top/bottom"

The current document uses the "top" and "bottom" when talking
about the address within a frame, which may easily lead to
misunderstandings. This patch directly uses "high address"
and "low address" to make the expression clearer.

Change-Id: I7469330bbdc158672d7f0314fe6680ebdd9ab79a
Reviewed-on: https://go-review.googlesource.com/c/go/+/339369
Trust: fannie zhang <Fannie.Zhang@arm.com>
Reviewed-by: Austin Clements <austin@google.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 doc/asm.html                     | 8 ++++----
 src/cmd/internal/obj/textflag.go | 4 ++--
 src/runtime/textflag.h           | 4 ++--
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/doc/asm.html b/doc/asm.html
index d578800086..51f85eb948 100644
--- a/doc/asm.html
+++ b/doc/asm.html
@@ -166,7 +166,7 @@ jumps and branches.
 </li>
 
 <li>
-<code>SP</code>: Stack pointer: top of stack.
+<code>SP</code>: Stack pointer: the highest address within the local stack frame.
 </li>
 
 </ul>
@@ -216,7 +216,7 @@ If a Go prototype does not name its result, the expected assembly name is <code>
 The <code>SP</code> pseudo-register is a virtual stack pointer
 used to refer to frame-local variables and the arguments being
 prepared for function calls.
-It points to the top of the local stack frame, so references should use negative offsets
+It points to the highest address within the local stack frame, so references should use negative offsets
 in the range [−framesize, 0):
 <code>x-8(SP)</code>, <code>y-4(SP)</code>, and so on.
 </p>
@@ -409,7 +409,7 @@ The linker will choose one of the duplicates to use.
 (For <code>TEXT</code> items.)
 Don't insert the preamble to check if the stack must be split.
 The frame for the routine, plus anything it calls, must fit in the
-spare space at the top of the stack segment.
+spare space remaining in the current stack segment.
 Used to protect routines such as the stack splitting code itself.
 </li>
 <li>
@@ -460,7 +460,7 @@ Only valid on functions that declare a frame size of 0.
 <code>TOPFRAME</code> = 2048
 <br>
 (For <code>TEXT</code> items.)
-Function is the top of the call stack. Traceback should stop at this function.
+Function is the outermost frame of the call stack. Traceback should stop at this function.
 </li>
 </ul>
 
diff --git a/src/cmd/internal/obj/textflag.go b/src/cmd/internal/obj/textflag.go
index 881e192203..5ae75027c2 100644
--- a/src/cmd/internal/obj/textflag.go
+++ b/src/cmd/internal/obj/textflag.go
@@ -49,8 +49,8 @@ const (
 	// Function can call reflect.Type.Method or reflect.Type.MethodByName.
 	REFLECTMETHOD = 1024
 
-	// Function is the top of the call stack. Call stack unwinders should stop
-	// at this function.
+	// Function is the outermost frame of the call stack. Call stack unwinders
+	// should stop at this function.
 	TOPFRAME = 2048
 
 	// Function is an ABI wrapper.
diff --git a/src/runtime/textflag.h b/src/runtime/textflag.h
index e727208cd0..214075e360 100644
--- a/src/runtime/textflag.h
+++ b/src/runtime/textflag.h
@@ -32,8 +32,8 @@
 #define NOFRAME 512
 // Function can call reflect.Type.Method or reflect.Type.MethodByName.
 #define REFLECTMETHOD 1024
-// Function is the top of the call stack. Call stack unwinders should stop
-// at this function.
+// Function is the outermost frame of the call stack. Call stack unwinders
+// should stop at this function.
 #define TOPFRAME 2048
 // Function is an ABI wrapper.
 #define ABIWRAPPER 4096
-- 
GitLab


From d4c0ed26ace91cb21fc0a67f088648674052aa3d Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Wed, 11 Aug 2021 09:10:55 -0700
Subject: [PATCH 2392/2400] doc/go1.17: linker passes -I to extld as
 -Wl,--dynamic-linker

For #22446

Change-Id: I71a30761a28e81c50b7089d5a28be99c736c2dc8
Reviewed-on: https://go-review.googlesource.com/c/go/+/341332
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Heschi Kreinick <heschi@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
---
 doc/go1.17.html | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index d469f400ad..972f9c3559 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -488,6 +488,15 @@ func Foo() bool {
   and compare functions by code pointer.
 </p>
 
+<h3 id="link">Linker</h3>
+
+<p><!-- CL 310349 -->
+  When the linker uses external linking mode, which is the default
+  when linking a program that uses cgo, and the linker is invoked
+  with a <code>-I</code> option, the option will now be passed to the
+  external linker as a <code>-Wl,--dynamic-linker</code> option.
+</p>
+
 <h2 id="library">Core library</h2>
 
 <h3 id="runtime/cgo"><a href="/pkg/runtime/cgo">Cgo</a></h3>
-- 
GitLab


From dea23e9ca80dd629041cba03ae2544dad19948ee Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 11 Aug 2021 12:40:12 -0700
Subject: [PATCH 2393/2400] src/make.*: make --no-clean flag a no-op that
 prints a warning

This flag is undocumented and is no longer useful. Users who want to
install additional toolchains without cleaning the installed packages
should just use `go install`.

This CL changes cmd/dist to print a warning that --no-clean is
deprecated and to advise users to use `go install std cmd` instead,
and then otherwise ignores it:

```
$ ./make.bash --no-clean
Building Go cmd/dist using $GOROOT_BOOTSTRAP. (devel +b7a85e0003 linux/amd64)
warning: --no-clean is deprecated and has no effect; use 'go install std cmd' instead
Building Go toolchain1 using $GOROOT_BOOTSTRAP.
```

Fixes #47204.

Change-Id: I275031832098401a49e491e324e8de3427973630
Reviewed-on: https://go-review.googlesource.com/c/go/+/341392
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/cmd/dist/build.go |  7 ++++++-
 src/make.bash         |  8 +-------
 src/make.bat          | 20 ++++++++++----------
 src/make.rc           |  7 +------
 4 files changed, 18 insertions(+), 24 deletions(-)

diff --git a/src/cmd/dist/build.go b/src/cmd/dist/build.go
index 1abb03bcc5..bec17696f3 100644
--- a/src/cmd/dist/build.go
+++ b/src/cmd/dist/build.go
@@ -1263,14 +1263,19 @@ func cmdbootstrap() {
 	timelog("start", "dist bootstrap")
 	defer timelog("end", "dist bootstrap")
 
-	var noBanner bool
+	var noBanner, noClean bool
 	var debug bool
 	flag.BoolVar(&rebuildall, "a", rebuildall, "rebuild all")
 	flag.BoolVar(&debug, "d", debug, "enable debugging of bootstrap process")
 	flag.BoolVar(&noBanner, "no-banner", noBanner, "do not print banner")
+	flag.BoolVar(&noClean, "no-clean", noClean, "print deprecation warning")
 
 	xflagparse(0)
 
+	if noClean {
+		xprintf("warning: --no-clean is deprecated and has no effect; use 'go install std cmd' instead\n")
+	}
+
 	// Set GOPATH to an internal directory. We shouldn't actually
 	// need to store files here, since the toolchain won't
 	// depend on modules outside of vendor directories, but if
diff --git a/src/make.bash b/src/make.bash
index f5e1b60bd5..7986125a06 100755
--- a/src/make.bash
+++ b/src/make.bash
@@ -203,16 +203,10 @@ if [ "$1" = "--dist-tool" ]; then
 	exit 0
 fi
 
-buildall="-a"
-if [ "$1" = "--no-clean" ]; then
-	buildall=""
-	shift
-fi
-
 # Run dist bootstrap to complete make.bash.
 # Bootstrap installs a proper cmd/dist, built with the new toolchain.
 # Throw ours, built with Go 1.4, away after bootstrap.
-./cmd/dist/dist bootstrap $buildall $vflag $GO_DISTFLAGS "$@"
+./cmd/dist/dist bootstrap -a $vflag $GO_DISTFLAGS "$@"
 rm -f ./cmd/dist/dist
 
 # DO NOT ADD ANY NEW CODE HERE.
diff --git a/src/make.bat b/src/make.bat
index b4a8e70849..8f2825b09a 100644
--- a/src/make.bat
+++ b/src/make.bat
@@ -112,20 +112,20 @@ if x%2==x--dist-tool goto copydist
 if x%3==x--dist-tool goto copydist
 if x%4==x--dist-tool goto copydist
 
-set buildall=-a
-if x%1==x--no-clean set buildall=
-if x%2==x--no-clean set buildall=
-if x%3==x--no-clean set buildall=
-if x%4==x--no-clean set buildall=
-if x%1==x--no-banner set buildall=%buildall% --no-banner
-if x%2==x--no-banner set buildall=%buildall% --no-banner
-if x%3==x--no-banner set buildall=%buildall% --no-banner
-if x%4==x--no-banner set buildall=%buildall% --no-banner
+set bootstrapflags=
+if x%1==x--no-clean set bootstrapflags=--no-clean
+if x%2==x--no-clean set bootstrapflags=--no-clean
+if x%3==x--no-clean set bootstrapflags=--no-clean
+if x%4==x--no-clean set bootstrapflags=--no-clean
+if x%1==x--no-banner set bootstrapflags=%bootstrapflags% --no-banner
+if x%2==x--no-banner set bootstrapflags=%bootstrapflags% --no-banner
+if x%3==x--no-banner set bootstrapflags=%bootstrapflags% --no-banner
+if x%4==x--no-banner set bootstrapflags=%bootstrapflags% --no-banner
 
 :: Run dist bootstrap to complete make.bash.
 :: Bootstrap installs a proper cmd/dist, built with the new toolchain.
 :: Throw ours, built with Go 1.4, away after bootstrap.
-.\cmd\dist\dist.exe bootstrap %vflag% %buildall%
+.\cmd\dist\dist.exe bootstrap -a %vflag% %bootstrapflags%
 if errorlevel 1 goto fail
 del .\cmd\dist\dist.exe
 goto end
diff --git a/src/make.rc b/src/make.rc
index f5e57e9755..7bdc7dea1c 100755
--- a/src/make.rc
+++ b/src/make.rc
@@ -92,15 +92,10 @@ if(~ $1 --dist-tool){
 	exit
 }
 
-buildall = -a
-if(~ $1 --no-clean) {
-	buildall = ()
-	shift
-}
 # Run dist bootstrap to complete make.bash.
 # Bootstrap installs a proper cmd/dist, built with the new toolchain.
 # Throw ours, built with Go 1.4, away after bootstrap.
-./cmd/dist/dist bootstrap $vflag $buildall $*
+./cmd/dist/dist bootstrap -a $vflag $*
 rm -f ./cmd/dist/dist
 
 # DO NOT ADD ANY NEW CODE HERE.
-- 
GitLab


From 095bb790e132a498ba191ad6d27f89c1fc4c0232 Mon Sep 17 00:00:00 2001
From: Dmitri Shuralyov <dmitshur@golang.org>
Date: Wed, 11 Aug 2021 22:02:59 -0400
Subject: [PATCH 2394/2400] os/exec: re-enable LookPathTest/16

This failure was confirmed to be due to a bug in prerelease versions
of Windows, and has been fixed by now. Remove the skip for this test.

Fixes #44379.

Change-Id: Idfb92ffd6b9d416d4c78ef3800a5ffdda06c6562
Reviewed-on: https://go-review.googlesource.com/c/go/+/341455
Trust: Dmitri Shuralyov <dmitshur@golang.org>
Run-TryBot: Dmitri Shuralyov <dmitshur@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
---
 src/os/exec/lp_windows_test.go | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/os/exec/lp_windows_test.go b/src/os/exec/lp_windows_test.go
index f834ffede0..bbf6a9b7f1 100644
--- a/src/os/exec/lp_windows_test.go
+++ b/src/os/exec/lp_windows_test.go
@@ -312,9 +312,6 @@ func TestLookPath(t *testing.T) {
 	// Run all tests.
 	for i, test := range lookPathTests {
 		t.Run(fmt.Sprint(i), func(t *testing.T) {
-			if i == 16 {
-				t.Skip("golang.org/issue/44379")
-			}
 			dir := filepath.Join(tmp, "d"+strconv.Itoa(i))
 			err := os.Mkdir(dir, 0700)
 			if err != nil {
-- 
GitLab


From 39634e7daee29a0c7d29ca74e32668d04c842758 Mon Sep 17 00:00:00 2001
From: Carlos Amedee <carlos@golang.org>
Date: Thu, 12 Aug 2021 12:10:47 -0400
Subject: [PATCH 2395/2400] CONTRIBUTORS: update for the Go 1.17 release

This update was created using the updatecontrib command:

	go get golang.org/x/build/cmd/updatecontrib
	cd gotip
	GO111MODULE=off updatecontrib

With manual changes based on publicly available information
to canonicalize letter case and formatting for a few names.

For #12042.

Change-Id: I96718c0fe438cd97b62499a027252748a1fa0779
Reviewed-on: https://go-review.googlesource.com/c/go/+/341709
Trust: Carlos Amedee <carlos@golang.org>
Run-TryBot: Carlos Amedee <carlos@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 CONTRIBUTORS | 136 ++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 135 insertions(+), 1 deletion(-)

diff --git a/CONTRIBUTORS b/CONTRIBUTORS
index ee50a4c049..1984d44c53 100644
--- a/CONTRIBUTORS
+++ b/CONTRIBUTORS
@@ -33,6 +33,7 @@ Aaron Jacobs <jacobsa@google.com>
 Aaron Jensen <jensen.aaro@gmail.com>
 Aaron Kemp <kemp.aaron@gmail.com>
 Aaron Patterson <tenderlove@ruby-lang.org>
+Aaron Sheah <aaronsheah@gmail.com>
 Aaron Stein <aaronstein12@gmail.com>
 Aaron Torres <tcboox@gmail.com>
 Aaron Zinman <aaron@azinman.com>
@@ -47,6 +48,7 @@ Adam Harvey <aharvey@php.net>
 Adam Kisala <adam.kisala@gmail.com>
 Adam Langley <agl@golang.org>
 Adam Medzinski <adam.medzinski@gmail.com>
+Adam Mitha <adam.mitha@gmail.com>
 Adam Shannon <adamkshannon@gmail.com>
 Adam Shelton <aashelt90@gmail.com>
 Adam Sindelar <adamsh@google.com>
@@ -54,6 +56,8 @@ Adam Thomason <athomason@gmail.com>
 Adam Williams <pwnfactory@gmail.com>
 Adam Woodbeck <adam@woodbeck.net>
 Adarsh Ravichandran <adarshravichandran91@gmail.com>
+Adel Rodríguez <adel.rodriguez@leftfieldlabs.com>
+Adin Scannell <ascannell@google.com>
 Aditya Harindar <aditya.harindar@gmail.com>
 Aditya Mukerjee <dev@chimeracoder.net>
 Adrian Hesketh <adrianhesketh@hushmail.com>
@@ -68,6 +72,7 @@ Afanasev Stanislav <phpprogger@gmail.com>
 Agis Anastasopoulos <agis.anast@gmail.com>
 Agniva De Sarker <agnivade@yahoo.co.in>
 Ahmed W. Mones <oneofone@gmail.com>
+Ahmet Aktürk <aakturk000@gmail.com>
 Ahmet Alp Balkan <ahmetb@google.com>
 Ahmet Soormally <ahmet@mangomm.co.uk>
 Ahmy Yulrizka <yulrizka@gmail.com>
@@ -92,11 +97,13 @@ Alberto Bertogli <albertito@blitiri.com.ar>
 Alberto Donizetti <alb.donizetti@gmail.com>
 Alberto García Hierro <alberto@garciahierro.com> <alberto.garcia.hierro@gmail.com>
 Alec Benzer <alec.benzer@gmail.com>
+Alejandro García Montoro <alejandro.garciamontoro@gmail.com>
 Aleksa Sarai <cyphar@cyphar.com>
 Aleksandar Dezelin <dezelin@gmail.com>
 Aleksandr Lukinykh <a.lukinykh@xsolla.com>
 Aleksandr Razumov <ar@cydev.ru>
 Alekseev Artem <a.artem060@gmail.com>
+Aleksei Tirman <aleksei.tirman@jetbrains.com>
 Alessandro Arzilli <alessandro.arzilli@gmail.com>
 Alessandro Baffa <alessandro.baffa@gmail.com>
 Alex A Skinner <alex@lx.lc>
@@ -165,6 +172,7 @@ Ali Rizvi-Santiago <arizvisa@gmail.com>
 Aliaksandr Valialkin <valyala@gmail.com>
 Alice Merrick <amerrick@google.com>
 Alif Rachmawadi <subosito@gmail.com>
+Allan Guwatudde <guwats10@gmail.com>
 Allan Simon <allan.simon@supinfo.com>
 Allen Li <ayatane@google.com>
 Alok Menghrajani <alok.menghrajani@gmail.com>
@@ -172,6 +180,7 @@ Alwin Doss <alwindoss84@gmail.com>
 Aman Gupta <aman@tmm1.net>
 Amarjeet Anand <amarjeetanandsingh@gmail.com>
 Amir Mohammad Saied <amir@gluegadget.com>
+Amit Kumar <mittalmailbox@gmail.com>
 Amr Mohammed <merodiro@gmail.com>
 Amrut Joshi <amrut.joshi@gmail.com>
 An Long <aisk1988@gmail.com>
@@ -185,6 +194,7 @@ André Carvalho <asantostc@gmail.com>
 André Martins <aanm90@gmail.com>
 Andre Nathan <andrenth@gmail.com>
 Andrea Nodari <andrea.nodari91@gmail.com>
+Andrea Simonini <andrea.simonini@gmail.com>
 Andrea Spadaccini <spadaccio@google.com>
 Andreas Auernhammer <aead@mail.de>
 Andreas Jellinghaus <andreas@ionisiert.de> <anj@google.com>
@@ -244,6 +254,7 @@ Andy Pan <panjf2000@gmail.com> <panjf2000@golangcn.org> <i@andypan.me>
 Andy Walker <walkeraj@gmail.com>
 Andy Wang <cbeuw.andy@gmail.com>
 Andy Williams <andy@andy.xyz>
+Andy Zhao <andyzhao@google.com>
 Andzej Maciusovic <andzej.maciusovic@gmail.com>
 Anfernee Yongkun Gui <anfernee.gui@gmail.com>
 Angelo Bulfone <mbulfone@gmail.com>
@@ -269,6 +280,7 @@ Anton Kuklin <anton.a.kuklin@gmail.com>
 Antonin Amand <antonin.amand@gmail.com>
 Antonio Antelo <aantelov87@gmail.com>
 Antonio Bibiano <antbbn@gmail.com>
+Antonio Garcia <garcia.olais@gmail.com>
 Antonio Huete Jimenez <tuxillo@quantumachine.net>
 Antonio Murdaca <runcom@redhat.com>
 Antonio Troina <thoeni@gmail.com>
@@ -292,8 +304,10 @@ Artem Khvastunov <artem.khvastunov@jetbrains.com>
 Artem Kolin <artemkaxboy@gmail.com>
 Arthur Fabre <arthur@arthurfabre.com>
 Arthur Khashaev <arthur@khashaev.ru>
+Artur M. Wolff <artur.m.wolff@gmail.com>
 Artyom Pervukhin <artyom.pervukhin@gmail.com>
 Arvindh Rajesh Tamilmani <art@a-30.net>
+Ashish Bhate <ab.listsubs@gmail.com>
 Ashish Gandhi <ag@ashishgandhi.org>
 Asim Shankar <asimshankar@gmail.com>
 Assel Meher <asselmeher@gmail.com>
@@ -325,6 +339,7 @@ Baokun Lee <nototon@gmail.com> <bk@golangcn.org>
 Barnaby Keene <accounts@southcla.ws>
 Bartosz Grzybowski <melkorm@gmail.com>
 Bartosz Oler <brtsz@google.com>
+Bassam Ojeil <bojeil@google.com>
 Bastian Ike <bastian.ike@gmail.com>
 Ben Burkert <ben@benburkert.com>
 Ben Cartwright-Cox <Ben@Benjojo.co.uk>
@@ -332,6 +347,7 @@ Ben Eitzen <eitzenb@golang.org>
 Ben Fried <ben.fried@gmail.com>
 Ben Haines <bhainesva@gmail.com>
 Ben Hoyt <benhoyt@gmail.com>
+Ben Hutchings <ben.hutchings@essensium.com>
 Ben Kraft <benkraft@khanacademy.org>
 Ben Laurie <ben@links.org> <benl@google.com>
 Ben Lubar <ben.lubar@gmail.com>
@@ -430,6 +446,7 @@ Carl Henrik Lunde <chlunde@ifi.uio.no>
 Carl Jackson <carl@stripe.com>
 Carl Johnson <me@carlmjohnson.net>
 Carl Mastrangelo <notcarl@google.com>
+Carl Menezes <carleeto@gmail.com>
 Carl Shapiro <cshapiro@google.com> <cshapiro@golang.org>
 Carlisia Campos <carlisia@grokkingtech.io>
 Carlo Alberto Ferraris <cafxx@strayorange.com>
@@ -443,6 +460,7 @@ Carlos Iriarte <ciriarte@gmail.com>
 Carlos Souza <carloshrsouza@gmail.com>
 Carolyn Van Slyck <me@carolynvanslyck.com>
 Carrie Bynon <cbynon@gmail.com>
+Carson Hoffman <c@rsonhoffman.com>
 Cary Hull <chull@google.com>
 Case Nelson <case.nelson@gmail.com>
 Casey Callendrello <squeed@gmail.com>
@@ -462,6 +480,7 @@ Charles Kenney <charlesc.kenney@gmail.com>
 Charles L. Dorian <cldorian@gmail.com>
 Charles Lee <zombie.fml@gmail.com>
 Charles Weill <weill@google.com>
+Charlie Moog <moogcharlie@gmail.com>
 Charlotte Brandhorst-Satzkorn <catzkorn@gmail.com>
 Chauncy Cullitan <chauncyc@google.com>
 Chen Zhidong <njutczd@gmail.com>
@@ -516,6 +535,7 @@ Christopher Nelson <nadiasvertex@gmail.com>
 Christopher Nielsen <m4dh4tt3r@gmail.com>
 Christopher Redden <christopher.redden@gmail.com>
 Christopher Swenson <cswenson@google.com>
+Christopher Thomas <53317512+chrisssthomas@users.noreply.github.com>
 Christopher Wedgwood <cw@f00f.org>
 Christos Zoulas <christos@zoulas.com> <zoulasc@gmail.com>
 Christy Perez <christy@linux.vnet.ibm.com>
@@ -541,6 +561,8 @@ Cosmos Nicolaou <cnicolaou@google.com>
 Costin Chirvasuta <ctin@google.com>
 Craig Citro <craigcitro@google.com>
 Cristian Staretu <unclejacksons@gmail.com>
+Cristo García <cgg.code@gmail.com>
+cui fliter <imcusg@gmail.com>
 Cuihtlauac ALVARADO <cuihtlauac.alvarado@orange.com>
 Cuong Manh Le <cuong@orijtech.com>
 Curtis La Graff <curtis@lagraff.me>
@@ -560,6 +582,7 @@ Dan Callahan <dan.callahan@gmail.com>
 Dan Harrington <harringtond@google.com>
 Dan Jacques <dnj@google.com>
 Dan Johnson <computerdruid@google.com>
+Dan McArdle <dmcardle@google.com>
 Dan Peterson <dpiddy@gmail.com>
 Dan Pupius <dan@medium.com>
 Dan Scales <danscales@google.com>
@@ -611,6 +634,7 @@ Dave Russell <forfuncsake@gmail.com>
 David Anderson <danderson@google.com>
 David Barnett <dbarnett@google.com>
 David Benjamin <davidben@google.com>
+David Black <dblack@atlassian.com>
 David Bond <davidsbond93@gmail.com>
 David Brophy <dave@brophy.uk>
 David Bürgin <676c7473@gmail.com>
@@ -654,6 +678,7 @@ Davor Kapsa <davor.kapsa@gmail.com>
 Dean Eigenmann <7621705+decanus@users.noreply.github.com>
 Dean Prichard <dean.prichard@gmail.com>
 Deepak Jois <deepak.jois@gmail.com>
+Deepak S <deepakspavoodath@gmail.com>
 Denis Bernard <db047h@gmail.com>
 Denis Brandolini <denis.brandolini@gmail.com>
 Denis Isaev <idenx@yandex.com>
@@ -676,8 +701,10 @@ Dhiru Kholia <dhiru.kholia@gmail.com>
 Dhruvdutt Jadhav <dhruvdutt.jadhav@gmail.com>
 Di Xiao <dixiao@google.com>
 Didier Spezia <didier.06@gmail.com>
+Diego Medina <fmpwizard@gmail.com>
 Diego Siqueira <diego9889@gmail.com>
 Dieter Plaetinck <dieter@raintank.io>
+Dilyn Corner <dilyn.corner@gmail.com>
 Dimitri Sokolyuk <sokolyuk@gmail.com>
 Dimitri Tcaciuc <dtcaciuc@gmail.com>
 Dina Garmash <dgrmsh@gmail.com>
@@ -714,6 +741,7 @@ Doug Fawley <dfawley@google.com>
 Douglas Danger Manley <doug.manley@gmail.com>
 Drew Flower <drewvanstone@gmail.com>
 Drew Hintz <adhintz@google.com>
+Drew Richardson <drewrichardson@gmail.com>
 Duco van Amstel <duco.vanamstel@gmail.com>
 Duncan Holm <mail@frou.org>
 Dustin Carlino <dcarlino@google.com>
@@ -735,6 +763,7 @@ Egon Elbre <egonelbre@gmail.com>
 Ehren Kret <ehren.kret@gmail.com>
 Eitan Adler <lists@eitanadler.com>
 Eivind Uggedal <eivind@uggedal.com>
+El Mostafa Idrassi <el.mostafa.idrassi@gmail.com>
 Elbert Fliek <efliek@gmail.com>
 Eldar Rakhimberdin <ibeono@gmail.com>
 Elena Grahovac <elena@grahovac.me>
@@ -742,6 +771,7 @@ Eli Bendersky <eliben@google.com>
 Elias Naur <mail@eliasnaur.com> <elias.naur@gmail.com>
 Elliot Morrison-Reed <elliotmr@gmail.com>
 Ellison Leão <ellisonleao@gmail.com>
+Elvina Yakubova <elvinayakubova@gmail.com>
 Emerson Lin <linyintor@gmail.com>
 Emil Bektimirov <lefelys@gmail.com>
 Emil Hessman <emil@hessman.se>
@@ -767,6 +797,7 @@ Eric Rescorla <ekr@rtfm.com>
 Eric Roshan-Eisner <eric.d.eisner@gmail.com>
 Eric Rutherford <erutherford@gmail.com>
 Eric Rykwalder <e.rykwalder@gmail.com>
+Eric Wang <wangchaogo1990@gmail.com>
 Erick Tryzelaar <etryzelaar@google.com>
 Erik Aigner <aigner.erik@gmail.com>
 Erik Dubbelboer <erik@dubbelboer.com>
@@ -778,6 +809,7 @@ Ernest Chiang <ernest_chiang@htc.com>
 Erwin Oegema <blablaechthema@hotmail.com>
 Esko Luontola <esko.luontola@gmail.com>
 Ethan Burns <eaburns@google.com>
+Ethan Hur <ethan0311@gmail.com>
 Ethan Miller <eamiller@us.ibm.com>
 Euan Kemp <euank@euank.com>
 Eugene Formanenko <mo4islona@gmail.com>
@@ -818,6 +850,7 @@ Felix Cornelius <9767036+fcornelius@users.noreply.github.com>
 Felix Geisendörfer <haimuiba@gmail.com>
 Felix Kollmann <fk@konsorten.de>
 Ferenc Szabo <frncmx@gmail.com>
+Fernandez Ludovic <lfernandez.dev@gmail.com>
 Filip Gruszczyński <gruszczy@gmail.com>
 Filip Haglund <drathier@users.noreply.github.com>
 Filip Stanis <fstanis@google.com>
@@ -858,6 +891,7 @@ Gabriel Nelle <tehsphinx@web.de>
 Gabriel Nicolas Avellaneda <avellaneda.gabriel@gmail.com>
 Gabriel Rosenhouse <rosenhouse@gmail.com>
 Gabriel Russell <gabriel.russell@gmail.com>
+Gabriel Vasile <gabriel.vasile0793@gmail.com>
 Gareth Paul Jones <gpj@foursquare.com>
 Garret Kelly <gdk@google.com>
 Garrick Evans <garrick@google.com>
@@ -891,6 +925,8 @@ Gianguido Sora` <g.sora4@gmail.com>
 Gideon Jan-Wessel Redelinghuys <gjredelinghuys@gmail.com>
 Giles Lean <giles.lean@pobox.com>
 Giovanni Bajo <rasky@develer.com>
+GitHub User @180909 (70465953) <734461790@qq.com>
+GitHub User @6543 (24977596) <6543@obermui.de>
 GitHub User @aca (50316549) <acadx0@gmail.com>
 GitHub User @ajnirp (1688456) <ajnirp@users.noreply.github.com>
 GitHub User @ajz01 (4744634) <ajzdenek@gmail.com>
@@ -904,10 +940,12 @@ GitHub User @bontequero (2674999) <bontequero@gmail.com>
 GitHub User @cch123 (384546) <buaa.cch@gmail.com>
 GitHub User @chainhelen (7046329) <chainhelen@gmail.com>
 GitHub User @chanxuehong (3416908) <chanxuehong@gmail.com>
+GitHub User @Cluas (10056928) <Cluas@live.cn>
 GitHub User @cncal (23520240) <flycalvin@qq.com>
 GitHub User @DQNEO (188741) <dqneoo@gmail.com>
 GitHub User @Dreamacro (8615343) <chuainian@gmail.com>
 GitHub User @dupoxy (1143957) <dupoxy@users.noreply.github.com>
+GitHub User @EndlessCheng (7086966) <loli.con@qq.com>
 GitHub User @erifan (31343225) <eric.fang@arm.com>
 GitHub User @esell (9735165) <eujon.sellers@gmail.com>
 GitHub User @fatedier (7346661) <fatedier@gmail.com>
@@ -916,12 +954,15 @@ GitHub User @geedchin (11672310) <geedchin@gmail.com>
 GitHub User @GrigoriyMikhalkin (3637857) <grigoriymikhalkin@gmail.com>
 GitHub User @hengwu0 (41297446) <41297446+hengwu0@users.noreply.github.com>
 GitHub User @hitzhangjie (3725760) <hit.zhangjie@gmail.com>
+GitHub User @hqpko (13887251) <whaibin01@hotmail.com>
 GitHub User @itchyny (375258) <itchyny@hatena.ne.jp>
 GitHub User @jinmiaoluo (39730824) <jinmiaoluo@icloud.com>
 GitHub User @jopbrown (6345470) <msshane2008@gmail.com>
 GitHub User @kazyshr (30496953) <kazyshr0301@gmail.com>
 GitHub User @kc1212 (1093806) <kc1212@users.noreply.github.com>
+GitHub User @komisan19 (18901496) <komiyama6219@gmail.com>
 GitHub User @Kropekk (13366453) <kamilkropiewnicki@gmail.com>
+GitHub User @lhl2617 (33488131) <l.h.lee2617@gmail.com>
 GitHub User @linguohua (3434367) <lghchinaidea@gmail.com>
 GitHub User @LotusFenn (13775899) <fenn.lotus@gmail.com>
 GitHub User @ly303550688 (11519839) <yang.liu636@gmail.com>
@@ -936,10 +977,14 @@ GitHub User @OlgaVlPetrova (44112727) <OVPpetrova@gmail.com>
 GitHub User @pityonline (438222) <pityonline@gmail.com>
 GitHub User @po3rin (29445112) <abctail30@gmail.com>
 GitHub User @pokutuna (57545) <popopopopokutuna@gmail.com>
+GitHub User @povsister (11040951) <pov@mahou-shoujo.moe>
 GitHub User @pytimer (17105586) <lixin20101023@gmail.com>
+GitHub User @qcrao (7698088) <qcrao91@gmail.com>
 GitHub User @ramenjuniti (32011829) <ramenjuniti@gmail.com>
 GitHub User @saitarunreddy (21041941) <saitarunreddypalla@gmail.com>
+GitHub User @SataQiu (9354727) <shidaqiu2018@gmail.com>
 GitHub User @shogo-ma (9860598) <Choroma194@gmail.com>
+GitHub User @sivchari (55221074) <shibuuuu5@gmail.com>
 GitHub User @skanehira (7888591) <sho19921005@gmail.com>
 GitHub User @soolaugust (10558124) <soolaugust@gmail.com>
 GitHub User @surechen (7249331) <surechen17@gmail.com>
@@ -947,9 +992,12 @@ GitHub User @tatsumack (4510569) <tatsu.mack@gmail.com>
 GitHub User @tell-k (26263) <ffk2005@gmail.com>
 GitHub User @tennashi (10219626) <tennashio@gmail.com>
 GitHub User @uhei (2116845) <uhei@users.noreply.github.com>
+GitHub User @uji (49834542) <ujiprog@gmail.com>
+GitHub User @unbyte (5772358) <i@shangyes.net>
 GitHub User @uropek (39370426) <uropek@gmail.com>
 GitHub User @utkarsh-extc (53217283) <utkarsh.extc@gmail.com>
 GitHub User @witchard (4994659) <witchard@hotmail.co.uk>
+GitHub User @wolf1996 (5901874) <ksgiv37@gmail.com>
 GitHub User @yah01 (12216890) <kagaminehuan@gmail.com>
 GitHub User @yuanhh (1298735) <yuan415030@gmail.com>
 GitHub User @zikaeroh (48577114) <zikaeroh@gmail.com>
@@ -962,6 +1010,7 @@ Glenn Brown <glennb@google.com>
 Glenn Lewis <gmlewis@google.com>
 Gordon Klaus <gordon.klaus@gmail.com>
 Gordon Tyler <gordon@doxxx.net>
+Grace Han <hgrace503@gmail.com>
 Graham King <graham4king@gmail.com>
 Graham Miller <graham.miller@gmail.com>
 Grant Griffiths <ggp493@gmail.com>
@@ -977,10 +1026,12 @@ Guilherme Caruso <gui.martinscaruso@gmail.com>
 Guilherme Garnier <guilherme.garnier@gmail.com>
 Guilherme Goncalves <guilhermeaugustosg@gmail.com>
 Guilherme Rezende <guilhermebr@gmail.com>
+Guilherme Souza <32180229+gqgs@users.noreply.github.com>
 Guillaume J. Charmes <guillaume@charmes.net>
 Guillaume Sottas <guillaumesottas@gmail.com>
 Günther Noack <gnoack@google.com>
 Guobiao Mei <meiguobiao@gmail.com>
+Guodong Li <guodongli@google.com>
 Guoliang Wang <iamwgliang@gmail.com>
 Gustav Paul <gustav.paul@gmail.com>
 Gustav Westling <gustav@westling.xyz>
@@ -995,6 +1046,7 @@ HAMANO Tsukasa <hamano@osstech.co.jp>
 Han-Wen Nienhuys <hanwen@google.com>
 Hang Qian <hangqian90@gmail.com>
 Hanjun Kim <hallazzang@gmail.com>
+Hanlin He <hanling.he@gmail.com>
 Hanlin Shi <shihanlin9@gmail.com>
 Haoran Luo <haoran.luo@chaitin.com>
 Haosdent Huang <haosdent@gmail.com>
@@ -1026,18 +1078,19 @@ Herbie Ong <herbie@google.com>
 Heschi Kreinick <heschi@google.com>
 Hidetatsu Yaginuma <ygnmhdtt@gmail.com>
 Hilko Bengen <bengen@hilluzination.de>
+Himanshu Kishna Srivastava <28himanshu@gmail.com>
 Hiroaki Nakamura <hnakamur@gmail.com>
 Hiromichi Ema <ema.hiro@gmail.com>
 Hironao OTSUBO <motemen@gmail.com>
 Hiroshi Ioka <hirochachacha@gmail.com>
 Hitoshi Mitake <mitake.hitoshi@gmail.com>
 Holden Huang <ttyh061@gmail.com>
-Songlin Jiang <hollowman@hollowman.ml>
 Hong Ruiqi <hongruiqi@gmail.com>
 Hongfei Tan <feilengcui008@gmail.com>
 Horacio Duran <horacio.duran@gmail.com>
 Horst Rutter <hhrutter@gmail.com>
 Hossein Sheikh Attar <hattar@google.com>
+Hossein Zolfi <hossein.zolfi@gmail.com>
 Howard Zhang <howard.zhang@arm.com>
 Hsin Tsao <tsao@google.com>
 Hsin-Ho Yeh <yhh92u@gmail.com>
@@ -1054,11 +1107,14 @@ Ian Haken <ihaken@netflix.com>
 Ian Kent <iankent85@gmail.com>
 Ian Lance Taylor <iant@golang.org>
 Ian Leue <ian@appboy.com>
+Ian Mckay <iann0036@gmail.com>
 Ian Tay <iantay@google.com>
+Ian Woolf <btw515wolf2@gmail.com>
 Ian Zapolsky <ianzapolsky@gmail.com>
 Ibrahim AshShohail <ibra.sho@gmail.com>
 Icarus Sparry <golang@icarus.freeuk.com>
 Iccha Sethi <icchasethi@gmail.com>
+Ichinose Shogo <shogo82148@gmail.com>
 Idora Shinatose <idora.shinatose@gmail.com>
 Ignacio Hagopian <jsign.uy@gmail.com>
 Igor Bernstein <igorbernstein@google.com>
@@ -1068,6 +1124,7 @@ Igor Vashyst <ivashyst@gmail.com>
 Igor Zhilianin <igor.zhilianin@gmail.com>
 Ikko Ashimine <eltociear@gmail.com>
 Illya Yalovyy <yalovoy@gmail.com>
+Ilya Chukov <56119080+Elias506@users.noreply.github.com>
 Ilya Sinelnikov <sidhmangh@gmail.com>
 Ilya Tocar <ilya.tocar@intel.com>
 INADA Naoki <songofacandy@gmail.com>
@@ -1122,6 +1179,7 @@ James Cowgill <James.Cowgill@imgtec.com>
 James Craig Burley <james-github@burleyarch.com>
 James David Chalfant <james.chalfant@gmail.com>
 James Eady <jmeady@google.com>
+James Fennell <jpfennell@google.com>
 James Fysh <james.fysh@gmail.com>
 James Gray <james@james4k.com>
 James Hartig <fastest963@gmail.com>
@@ -1178,6 +1236,7 @@ Jason Wangsadinata <jwangsadinata@gmail.com>
 Javier Kohen <jkohen@google.com>
 Javier Revillas <jrevillas@massivedynamic.io>
 Javier Segura <javism@gmail.com>
+Jay Chen <chenjie@chenjie.info>
 Jay Conrod <jayconrod@google.com>
 Jay Lee <BusyJayLee@gmail.com>
 Jay Taylor <outtatime@gmail.com>
@@ -1200,6 +1259,7 @@ Jeff Johnson <jrjohnson@google.com>
 Jeff R. Allen <jra@nella.org> <jeff.allen@gmail.com>
 Jeff Sickel <jas@corpus-callosum.com>
 Jeff Wendling <jeff@spacemonkey.com>
+Jeff Widman <jeff@jeffwidman.com>
 Jeffrey H <jeffreyh192@gmail.com>
 Jelte Fennema <github-tech@jeltef.nl>
 Jens Frederich <jfrederich@gmail.com>
@@ -1210,6 +1270,7 @@ Jeremy Faller <jeremy@golang.org>
 Jeremy Jackins <jeremyjackins@gmail.com>
 Jeremy Jay <jeremy@pbnjay.com>
 Jeremy Schlatter <jeremy.schlatter@gmail.com>
+Jero Bado <tokidokitalkyou@gmail.com>
 Jeroen Bobbeldijk <jerbob92@gmail.com>
 Jeroen Simonetti <jeroen@simonetti.nl>
 Jérôme Doucet <jerdct@gmail.com>
@@ -1251,6 +1312,8 @@ Joe Richey <joerichey@google.com>
 Joe Shaw <joe@joeshaw.org>
 Joe Sylve <joe.sylve@gmail.com>
 Joe Tsai <joetsai@digital-static.net>
+Joel Courtney <euphemize@gmail.com>
+Joel Ferrier <joelferrier@google.com>
 Joel Sing <joel@sing.id.au> <jsing@google.com>
 Joël Stemmer <jstemmer@google.com>
 Joel Stemmer <stemmertech@gmail.com>
@@ -1260,7 +1323,9 @@ Johan Euphrosine <proppy@google.com>
 Johan Jansson <johan.jansson@iki.fi>
 Johan Knutzen <johan@senri.se>
 Johan Sageryd <j@1616.se>
+Johannes Huning <johannes.huning@gmail.com>
 John Asmuth <jasmuth@gmail.com>
+John Bampton <jbampton@gmail.com>
 John Beisley <huin@google.com>
 John C Barstow <jbowtie@amathaine.com>
 John DeNero <denero@google.com>
@@ -1269,6 +1334,7 @@ John Gibb <johngibb@gmail.com>
 John Gilik <john@jgilik.com>
 John Graham-Cumming <jgc@jgc.org> <jgrahamc@gmail.com>
 John Howard Palevich <jack.palevich@gmail.com>
+John Jago <johnjago@protonmail.com>
 John Jeffery <jjeffery@sp.com.au>
 John Jenkins <twodopeshaggy@gmail.com>
 John Leidegren <john.leidegren@gmail.com>
@@ -1320,6 +1386,7 @@ Josa Gesell <josa@gesell.me>
 Jose Luis Vázquez González <josvazg@gmail.com>
 Joseph Bonneau <jcb@google.com>
 Joseph Holsten <joseph@josephholsten.com>
+Joseph Morag <sefim96@gmail.com>
 Josh Baum <joshbaum@google.com>
 Josh Bleecher Snyder <josharian@gmail.com>
 Josh Chorlton <jchorlton@gmail.com>
@@ -1327,12 +1394,14 @@ Josh Deprez <josh.deprez@gmail.com>
 Josh Goebel <dreamer3@gmail.com>
 Josh Hoak <jhoak@google.com>
 Josh Holland <jrh@joshh.co.uk>
+Josh Rickmar <jrick@companyzero.com>
 Josh Roppo <joshroppo@gmail.com>
 Josh Varga <josh.varga@gmail.com>
 Joshua Bezaleel Abednego <joshua.bezaleel@gmail.com>
 Joshua Boelter <joshua.boelter@intel.com>
 Joshua Chase <jcjoshuachase@gmail.com>
 Joshua Crowgey <jcrowgey@uw.edu>
+Joshua Harshman <joshgreyhat@gmail.com>
 Joshua M. Clulow <josh.clulow@joyent.com>
 Joshua Rubin <joshua@rubixconsulting.com>
 Josselin Costanzi <josselin@costanzi.fr>
@@ -1353,6 +1422,7 @@ Julie Qiu <julie@golang.org>
 Julien Kauffmann <julien.kauffmann@freelan.org>
 Julien Salleyron <julien.salleyron@gmail.com>
 Julien Schmidt <google@julienschmidt.com>
+Julien Tant <julien@craftyx.fr>
 Julio Montes <julio.montes@intel.com>
 Jun Zhang <jim.zoumo@gmail.com>
 Junchen Li <junchen.li@arm.com>
@@ -1419,10 +1489,12 @@ Kenta Mori <zoncoen@gmail.com>
 Kerollos Magdy <kerolloz@yahoo.com>
 Ketan Parmar <ketanbparmar@gmail.com>
 Kevan Swanberg <kevswanberg@gmail.com>
+Kevin Albertson <kevin.albertson@mongodb.com>
 Kevin Ballard <kevin@sb.org>
 Kevin Burke <kev@inburke.com>
 Kévin Dunglas <dunglas@gmail.com>
 Kevin Gillette <extemporalgenome@gmail.com>
+Kevin Herro <kevin109104@gmail.com>
 Kevin Kirsche <kev.kirsche@gmail.com>
 Kevin Klues <klueska@gmail.com> <klueska@google.com>
 Kevin Malachowski <chowski@google.com>
@@ -1457,6 +1529,7 @@ Koya IWAMURA <kiwamura0314@gmail.com>
 Kris Kwiatkowski <kris@cloudflare.com>
 Kris Nova <kris@nivenly.com>
 Kris Rousey <krousey@google.com>
+Krishna Birla <krishnabirla16@gmail.com>
 Kristopher Watts <traetox@gmail.com>
 Krzysztof Dąbrowski <krzysdabro@live.com>
 Kshitij Saraogi <kshitijsaraogi@gmail.com>
@@ -1480,6 +1553,7 @@ Lajos Papp <lalyos@yahoo.com>
 Lakshay Garg <lakshay.garg.1996@gmail.com>
 Lann Martin <lannm@google.com>
 Lanre Adelowo <yo@lanre.wtf>
+Lapo Luchini <lapo@lapo.it>
 Larry Clapp <larry@theclapp.org>
 Larry Hosken <lahosken@golang.org>
 Lars Jeppesen <jeppesen.lars@gmail.com>
@@ -1496,6 +1570,7 @@ Leigh McCulloch <leighmcc@gmail.com>
 Leo Antunes <leo@costela.net>
 Leo Rudberg <ljr@google.com>
 Leon Klingele <git@leonklingele.de>
+Leonard Wang <wangdeyu0907@gmail.com>
 Leonardo Comelli <leonardo.comelli@gmail.com>
 Leonel Quinteros <leonel.quinteros@gmail.com>
 Lev Shamardin <shamardin@gmail.com>
@@ -1506,7 +1581,9 @@ Lily Chung <lilithkchung@gmail.com>
 Lingchao Xin <douglarek@gmail.com>
 Lion Yang <lion@aosc.xyz>
 Liz Rice <liz@lizrice.com>
+Lize Cai <lizzzcai1@gmail.com>
 Lloyd Dewolf <foolswisdom@gmail.com>
+Lluís Batlle i Rossell <viric@viric.name>
 Lorenz Bauer <lmb@cloudflare.com>
 Lorenz Brun <lorenz@brun.one>
 Lorenz Nickel <mail@lorenznickel.de>
@@ -1531,6 +1608,7 @@ Lukasz Milewski <lmmilewski@gmail.com>
 Luke Champine <luke.champine@gmail.com>
 Luke Curley <qpingu@gmail.com>
 Luke Granger-Brown <git@lukegb.com>
+Luke Shumaker <lukeshu@datawire.io>
 Luke Young <bored-engineer@users.noreply.github.com>
 Luna Duclos <luna.duclos@palmstonegames.com>
 Luuk van Dijk <lvd@golang.org> <lvd@google.com>
@@ -1550,6 +1628,7 @@ Mal Curtis <mal@mal.co.nz>
 Manfred Touron <m@42.am>
 Manigandan Dharmalingam <manigandan.jeff@gmail.com>
 Manish Goregaokar <manishsmail@gmail.com>
+Manlio Perillo <manlio.perillo@gmail.com>
 Manoj Dayaram <platform-dev@moovweb.com> <manoj.dayaram@moovweb.com>
 Mansour Rahimi <rahimi.mnr@gmail.com>
 Manu Garg <manugarg@google.com>
@@ -1646,6 +1725,8 @@ Matt Joiner <anacrolix@gmail.com>
 Matt Jones <mrjones@google.com>
 Matt Juran <thepciet@gmail.com>
 Matt Layher <mdlayher@gmail.com>
+Matt Masurka <masurka@google.com>
+Matt Pearring <broskies@google.com>
 Matt Reiferson <mreiferson@gmail.com>
 Matt Robenolt <matt@ydekproductions.com>
 Matt Strong <mstrong1341@gmail.com>
@@ -1659,9 +1740,12 @@ Matthew Denton <mdenton@skyportsystems.com>
 Matthew Holt <Matthew.Holt+git@gmail.com>
 Matthew Horsnell <matthew.horsnell@gmail.com>
 Matthew Waters <mwwaters@gmail.com>
+Matthias Frei <matthias.frei@inf.ethz.ch>
 Matthieu Hauglustaine <matt.hauglustaine@gmail.com>
 Matthieu Olivier <olivier.matthieu@gmail.com>
 Matthijs Kooijman <matthijs@stdin.nl>
+Mattias Appelgren <mattias@ppelgren.se>
+Mauricio Alvarado <mauricio.alvarado@leftfieldlabs.com>
 Max Drosdo.www <g1ran1q@gmail.com>
 Max Riveiro <kavu13@gmail.com>
 Max Schmitt <max@schmitt.mx>
@@ -1677,9 +1761,11 @@ Máximo Cuadros Ortiz <mcuadros@gmail.com>
 Maxwell Krohn <themax@gmail.com>
 Maya Rashish <maya@NetBSD.org>
 Mayank Kumar <krmayankk@gmail.com>
+Mehrad Sadeghi <2012.linkinpark@gmail.com>
 Meir Fischer <meirfischer@gmail.com>
 Meng Zhuo <mengzhuo1203@gmail.com> <mzh@golangcn.org>
 Mhd Sulhan <m.shulhan@gmail.com>
+Mia Zhu <CrystalZhu1025getu@gmail.com>
 Micah Stetson <micah.stetson@gmail.com>
 Michael Anthony Knyszek <mknyszek@google.com>
 Michael Brandenburg <mbrandenburg@bolste.com>
@@ -1730,8 +1816,10 @@ Michal Franc <lam.michal.franc@gmail.com>
 Michał Łowicki <mlowicki@gmail.com>
 Michal Pristas <michal.pristas@gmail.com>
 Michal Rostecki <mrostecki@suse.de>
+Michal Stokluska <mstoklus@redhat.com>
 Michalis Kargakis <michaliskargakis@gmail.com>
 Michel Lespinasse <walken@google.com>
+Michel Levieux <mlevieux42@gmail.com>
 Michele Di Pede <michele.di.pede@gmail.com>
 Mickael Kerjean <mickael.kerjean@gmail.com>
 Mickey Reiss <mickeyreiss@gmail.com>
@@ -1790,7 +1878,9 @@ Muir Manders <muir@mnd.rs>
 Mukesh Sharma <sharma.mukesh439@gmail.com>
 Mura Li <mura_li@castech.com.tw>
 Mykhailo Lesyk <mikhail@lesyk.org>
+Nahum Shalman <nahamu@gmail.com>
 Naman Aggarwal <aggarwal.nam@gmail.com>
+Naman Gera <namangera15@gmail.com>
 Nan Deng <monnand@gmail.com>
 Nao Yonashiro <owan.orisano@gmail.com>
 Naoki Kanatani <k12naoki@gmail.com>
@@ -1818,6 +1908,7 @@ Neven Sajko <nsajko@gmail.com>
 Nevins Bartolomeo <nevins.bartolomeo@gmail.com>
 Niall Sheridan <nsheridan@gmail.com>
 Nic Day <nic.day@me.com>
+Nicholas Asimov <nicholas@asimov.me>
 Nicholas Katsaros <nick@nickkatsaros.com>
 Nicholas Maniscalco <nicholas@maniscalco.com>
 Nicholas Ng <nickng@nickng.io>
@@ -1847,6 +1938,7 @@ Nik Nyby <nnyby@columbia.edu>
 Nikhil Benesch <nikhil.benesch@gmail.com>
 Nikita Gillmann <nikita@n0.is> <ng0@n0.is>
 Nikita Kryuchkov <nkryuchkov10@gmail.com>
+Nikita Melekhin <nimelehin@gmail.com>
 Nikita Vanyasin <nikita.vanyasin@gmail.com>
 Niklas Schnelle <niklas.schnelle@gmail.com>
 Niko Dziemba <niko@dziemba.com>
@@ -1858,6 +1950,7 @@ Niranjan Godbole <niranjan8192@gmail.com>
 Nishanth Shanmugham <nishanth.gerrard@gmail.com>
 Noah Campbell <noahcampbell@gmail.com>
 Noah Goldman <noahg34@gmail.com>
+Noah Santschi-Cooney <noah@santschi-cooney.ch>
 Noble Johnson <noblepoly@gmail.com>
 Nodir Turakulov <nodir@google.com>
 Noel Georgi <git@frezbo.com>
@@ -1894,6 +1987,7 @@ Pablo Rozas Larraondo <pablo.larraondo@anu.edu.au>
 Pablo Santiago Blum de Aguiar <scorphus@gmail.com>
 Padraig Kitterick <padraigkitterick@gmail.com>
 Pallat Anchaleechamaikorn <yod.pallat@gmail.com>
+Pan Chenglong <1004907659@qq.com>
 Panos Georgiadis <pgeorgiadis@suse.de>
 Pantelis Sampaziotis <psampaz@gmail.com>
 Paolo Giarrusso <p.giarrusso@gmail.com>
@@ -1947,6 +2041,7 @@ Paulo Casaretto <pcasaretto@gmail.com>
 Paulo Flabiano Smorigo <pfsmorigo@linux.vnet.ibm.com>
 Paulo Gomes <paulo.gomes.uk@gmail.com>
 Pavel Paulau <pavel.paulau@gmail.com>
+Pavel Watson <watsonpavel@gmail.com>
 Pavel Zinovkin <pavel.zinovkin@gmail.com>
 Pavlo Sumkin <ymkins@gmail.com>
 Pawel Knap <pawelknap88@gmail.com>
@@ -1954,6 +2049,8 @@ Pawel Szczur <filemon@google.com>
 Paweł Szulik <pawel.szulik@intel.com>
 Pei Xian Chee <luciolas1991@gmail.com>
 Pei-Ming Wu <p408865@gmail.com>
+Pen Tree <appletree2479@outlook.com>
+Peng Gao <peng.gao.dut@gmail.com>
 Percy Wegmann <ox.to.a.cart@gmail.com>
 Perry Abbott <perry.j.abbott@gmail.com>
 Petar Dambovaliev <petar.atanasov.1987@gmail.com>
@@ -1992,6 +2089,7 @@ Philip Brown <phil@bolthole.com>
 Philip Hofer <phofer@umich.edu>
 Philip K. Warren <pkwarren@gmail.com>
 Philip Nelson <me@pnelson.ca>
+Philipp Sauter <sauterp@protonmail.com>
 Philipp Stephani <phst@google.com>
 Phillip Campbell <15082+phillc@users.noreply.github.com>
 Pierre Carru <pierre.carru@eshard.com>
@@ -2007,6 +2105,7 @@ Poh Zi How <poh.zihow@gmail.com>
 Polina Osadcha <polliosa@google.com>
 Pontus Leitzler <leitzler@gmail.com>
 Povilas Versockas <p.versockas@gmail.com>
+Prajwal Koirala <16564273+Prajwal-Koirala@users.noreply.github.com>
 Prasanga Siripala <pj@pjebs.com.au>
 Prasanna Swaminathan <prasanna@mediamath.com>
 Prashant Agrawal <prashant.a.vjti@gmail.com>
@@ -2027,11 +2126,13 @@ Quim Muntal <quimmuntal@gmail.com>
 Quinn Slack <sqs@sourcegraph.com>
 Quinten Yearsley <qyearsley@chromium.org>
 Quoc-Viet Nguyen <afelion@gmail.com>
+Rabin Gaire <rabingaire20@gmail.com>
 Radek Simko <radek.simko@gmail.com>
 Radek Sohlich <sohlich@gmail.com>
 Radu Berinde <radu@cockroachlabs.com>
 Rafal Jeczalik <rjeczalik@gmail.com>
 Raghavendra Nagaraj <jamdagni86@gmail.com>
+Rahul Bajaj <rahulrb0509@gmail.com>
 Rahul Chaudhry <rahulchaudhry@chromium.org>
 Rahul Wadhwani <rahulwadhwani21@gmail.com>
 Raif S. Naffah <go@naffah-raif.name>
@@ -2041,12 +2142,14 @@ Rajender Reddy Kompally <rajenderreddykompally@gmail.com>
 Ralph Corderoy <ralph@inputplus.co.uk>
 Ramazan AYYILDIZ <rayyildiz@gmail.com>
 Ramesh Dharan <dharan@google.com>
+Randy Reddig <randy@alta.software>
 Raph Levien <raph@google.com>
 Raphael Geronimi <raphael.geronimi@gmail.com>
 Raul Silvera <rsilvera@google.com>
 Ravil Bikbulatov <weeellz12@gmail.com>
 RaviTeja Pothana <ravi.tezu@gmail.com>
 Ray Tung <rtung@thoughtworks.com>
+Ray Wu <ray@liftoff.io>
 Raymond Kazlauskas <raima220@gmail.com>
 Rebecca Stambler <rstambler@golang.org>
 Reilly Watson <reillywatson@gmail.com>
@@ -2066,6 +2169,7 @@ Richard Eric Gavaletz <gavaletz@gmail.com>
 Richard Gibson <richard.gibson@gmail.com>
 Richard Miller <miller.research@gmail.com>
 Richard Musiol <mail@richard-musiol.de> <neelance@gmail.com>
+Richard Pickering <richard.pickering@hotmail.co.uk>
 Richard Ulmer <codesoap@mailbox.org>
 Richard Wilkes <wilkes@me.com>
 Rick Arnold <rickarnoldjr@gmail.com>
@@ -2124,6 +2228,7 @@ Rowan Worth <sqweek@gmail.com>
 Rudi Kramer <rudi.kramer@gmail.com>
 Rui Ueyama <ruiu@google.com>
 Ruixin Bao <ruixin.bao@ibm.com>
+Ruslan Andreev <ruslan.andreev@huawei.com>
 Ruslan Nigmatullin <elessar@dropbox.com>
 Russ Cox <rsc@golang.org>
 Russell Haering <russellhaering@gmail.com>
@@ -2141,6 +2246,7 @@ Ryan Seys <ryan@ryanseys.com>
 Ryan Slade <ryanslade@gmail.com>
 Ryan Zhang <ryan.zhang@docker.com>
 Ryoichi KATO <ryo1kato@gmail.com>
+Ryoya Sekino <ryoyasekino1993@gmail.com>
 Ryuji Iwata <qt.luigi@gmail.com>
 Ryuma Yoshida <ryuma.y1117@gmail.com>
 Ryuzo Yamamoto <ryuzo.yamamoto@gmail.com>
@@ -2176,8 +2282,10 @@ Sardorbek Pulatov <sardorbek.pulatov@outlook.com>
 Sascha Brawer <sascha@brawer.ch>
 Sasha Lionheart <lionhearts@google.com>
 Sasha Sobol <sasha@scaledinference.com>
+Satoru Kitaguchi <rule.the.fate.myfirststory@gmail.com>
 Scott Barron <scott.barron@github.com>
 Scott Bell <scott@sctsm.com>
+Scott Cotton <scott@mindowl.com>
 Scott Crunkleton <crunk1@gmail.com>
 Scott Ferguson <scottwferg@gmail.com>
 Scott Lawrence <bytbox@gmail.com>
@@ -2191,6 +2299,7 @@ Sean Chittenden <seanc@joyent.com>
 Sean Christopherson <sean.j.christopherson@intel.com>
 Sean Dolphin <Sean.Dolphin@kpcompass.com>
 Sean Harger <sharger@google.com>
+Sean Harrington <sean.harrington@leftfieldlabs.com>
 Sean Hildebrand <seanwhildebrand@gmail.com>
 Sean Liao <seankhliao@gmail.com>
 Sean Rees <sean@erifax.org>
@@ -2212,6 +2321,7 @@ Sergey Dobrodey <sergey.dobrodey@synesis.ru>
 Sergey Frolov <sfrolov@google.com>
 Sergey Glushchenko <gsserge@gmail.com>
 Sergey Ivanov <ser1325@gmail.com>
+Sergey Kacheev <S.Kacheev@gmail.com>
 Sergey Lukjanov <me@slukjanov.name>
 Sergey Mishin <sergeymishine@gmail.com>
 Sergey Mudrik <sergey.mudrik@gmail.com>
@@ -2223,6 +2333,7 @@ Serhat Giydiren <serhatgiydiren@gmail.com>
 Serhii Aheienko <serhii.aheienko@gmail.com>
 Seth Hoenig <seth.a.hoenig@gmail.com>
 Seth Vargo <sethvargo@gmail.com>
+Shaba Abhiram <shabarivas.abhiram@gmail.com>
 Shahar Kohanim <skohanim@gmail.com>
 Shailesh Suryawanshi <ss.shailesh28@gmail.com>
 Shamil Garatuev <garatuev@gmail.com>
@@ -2250,9 +2361,13 @@ Shivakumar GN <shivakumar.gn@gmail.com>
 Shivani Singhal <shivani.singhal2804@gmail.com>
 Shivansh Rai <shivansh@freebsd.org>
 Shivashis Padhi <shivashispadhi@gmail.com>
+Shoshin Nikita <shoshin_nikita@fastmail.com>
+Shota Sugiura <s.shota.710.3506@gmail.com>
 Shubham Sharma <shubham.sha12@gmail.com>
+Shuhei Takahashi <nya@chromium.org>
 Shun Fan <sfan@google.com>
 Silvan Jegen <s.jegen@gmail.com>
+Simão Gomes Viana <simaogmv@gmail.com>
 Simarpreet Singh <simar@linux.com>
 Simon Drake <simondrake1990@gmail.com>
 Simon Ferquel <simon.ferquel@docker.com>
@@ -2267,13 +2382,16 @@ Sina Siadat <siadat@gmail.com>
 Sjoerd Siebinga <sjoerd.siebinga@gmail.com>
 Sokolov Yura <funny.falcon@gmail.com>
 Song Gao <song@gao.io>
+Song Lim <songlim327@gmail.com>
 Songjiayang <songjiayang1@gmail.com>
+Songlin Jiang <hollowman@hollowman.ml>
 Soojin Nam <jsunam@gmail.com>
 Søren L. Hansen <soren@linux2go.dk>
 Sparrow Li <liyuancylx@gmail.com>
 Spencer Kocot <spencerkocot@gmail.com>
 Spencer Nelson <s@spenczar.com>
 Spencer Tung <spencertung@google.com>
+Spenser Black <spenserblack01@gmail.com>
 Spring Mc <heresy.mc@gmail.com>
 Srdjan Petrovic <spetrovic@google.com>
 Sridhar Venkatakrishnan <sridhar@laddoo.net>
@@ -2324,6 +2442,7 @@ Suyash <dextrous93@gmail.com>
 Suzy Mueller <suzmue@golang.org>
 Sven Almgren <sven@tras.se>
 Sven Blumenstein <svbl@google.com>
+Sven Lee <lee1300394324@gmail.com>
 Sven Taute <sven.taute@gmail.com>
 Sylvain Zimmer <sylvain@sylvainzimmer.com>
 Syohei YOSHIDA <syohex@gmail.com>
@@ -2406,12 +2525,14 @@ Tiwei Bie <tiwei.btw@antgroup.com>
 Tobias Assarsson <tobias.assarsson@gmail.com>
 Tobias Columbus <tobias.columbus@gmail.com> <tobias.columbus@googlemail.com>
 Tobias Klauser <tklauser@distanz.ch>
+Tobias Kohlbau <tobias@kohlbau.de>
 Toby Burress <kurin@google.com>
 Todd Kulesza <tkulesza@google.com>
 Todd Neal <todd@tneal.org>
 Todd Wang <toddwang@gmail.com>
 Tom Anthony <git@tomanthony.co.uk>
 Tom Bergan <tombergan@google.com>
+Tom Freudenberg <tom.freudenberg@4commerce.de>
 Tom Heng <zhm20070928@gmail.com>
 Tom Lanyon <tomlanyon@google.com>
 Tom Levy <tomlevy93@gmail.com>
@@ -2440,6 +2561,7 @@ Toshiki Shima <hayabusa1419@gmail.com>
 Totoro W <tw19881113@gmail.com>
 Travis Bischel <travis.bischel@gmail.com>
 Travis Cline <travis.cline@gmail.com>
+Trevor Dixon <trevordixon@gmail.com>
 Trevor Strohman <trevor.strohman@gmail.com>
 Trey Lawrence <lawrence.trey@gmail.com>
 Trey Roessig <trey.roessig@gmail.com>
@@ -2463,6 +2585,7 @@ Tzach Shabtay <tzachshabtay@gmail.com>
 Tzu-Chiao Yeh <su3g4284zo6y7@gmail.com>
 Tzu-Jung Lee <roylee17@currant.com>
 Udalov Max <re.udalov@gmail.com>
+Uddeshya Singh <singhuddeshyaofficial@gmail.com>
 Ugorji Nwoke <ugorji@gmail.com>
 Ulf Holm Nielsen <doktor@dyregod.dk>
 Ulrich Kunitz <uli.kunitz@gmail.com>
@@ -2475,6 +2598,7 @@ Vadim Grek <vadimprog@gmail.com>
 Vadim Vygonets <unixdj@gmail.com>
 Val Polouchkine <vpolouch@justin.tv>
 Valentin Vidic <vvidic@valentin-vidic.from.hr>
+Vaughn Iverson <vsivsi@yahoo.com>
 Vee Zhang <veezhang@126.com> <vveezhang@gmail.com>
 Vega Garcia Luis Alfonso <vegacom@gmail.com>
 Venil Noronha <veniln@vmware.com>
@@ -2491,6 +2615,7 @@ Vincent Batts <vbatts@hashbangbash.com> <vbatts@gmail.com>
 Vincent Vanackere <vincent.vanackere@gmail.com>
 Vinu Rajashekhar <vinutheraj@gmail.com>
 Vish Subramanian <vish@google.com>
+Vishal Dalwadi <dalwadivishal26@gmail.com>
 Vishvananda Ishaya <vishvananda@gmail.com>
 Visweswara R <r.visweswara@gmail.com>
 Vitaly Zdanevich <zdanevich.vitaly@ya.ru>
@@ -2542,6 +2667,7 @@ Willem van der Schyff <willemvds@gmail.com>
 William Chan <willchan@chromium.org>
 William Chang <mr.williamchang@gmail.com>
 William Josephson <wjosephson@gmail.com>
+William Langford <wlangfor@gmail.com>
 William Orr <will@worrbase.com> <ay1244@gmail.com>
 William Poussier <william.poussier@gmail.com>
 Wisdom Omuya <deafgoat@gmail.com>
@@ -2550,6 +2676,7 @@ Xi Ruoyao <xry23333@gmail.com>
 Xia Bin <snyh@snyh.org>
 Xiangdong Ji <xiangdong.ji@arm.com>
 Xiaodong Liu <teaofmoli@gmail.com>
+Xing Gao <18340825824@163.com>
 Xing Xing <mikespook@gmail.com>
 Xingqang Bai <bxq2011hust@qq.com>
 Xu Fei <badgangkiller@gmail.com>
@@ -2571,6 +2698,7 @@ Yasha Bubnov <girokompass@gmail.com>
 Yasser Abdolmaleki <yasser@yasser.ca>
 Yasuharu Goto <matope.ono@gmail.com>
 Yasuhiro Matsumoto <mattn.jp@gmail.com>
+Yasutaka Shinzaki <shinzaki@yasu26.tech>
 Yasuyuki Oka <yasuyk@gmail.com>
 Yazen Shunnar <yazen.shunnar@gmail.com>
 Yestin Sun <ylh@pdx.edu>
@@ -2583,14 +2711,18 @@ Yorman Arias <cixtords@gmail.com>
 Yoshiyuki Kanno <nekotaroh@gmail.com> <yoshiyuki.kanno@stoic.co.jp>
 Yoshiyuki Mineo <yoshiyuki.mineo@gmail.com>
 Yosuke Akatsuka <yosuke.akatsuka@gmail.com>
+Youfu Zhang <zhangyoufu@gmail.com>
 Yu Heng Zhang <annita.zhang@cn.ibm.com>
 Yu Xuan Zhang <zyxsh@cn.ibm.com>
+Yu, Li-Yu <afg984@gmail.com>
 Yuichi Kishimoto <yk2220s@gmail.com>
 Yuichi Nishiwaki <yuichi.nishiwaki@gmail.com>
 Yuji Yaginuma <yuuji.yaginuma@gmail.com>
+Yuki Ito <mrno110y@gmail.com>
 Yuki OKUSHI <huyuumi.dev@gmail.com>
 Yuki Yugui Sonoda <yugui@google.com>
 Yukihiro Nishinaka <6elpinal@gmail.com>
+YunQiang Su <syq@debian.org>
 Yury Smolsky <yury@smolsky.by>
 Yusuke Kagiwada <block.rxckin.beats@gmail.com>
 Yuusei Kuwana <kuwana@kumama.org>
@@ -2599,6 +2731,7 @@ Yves Junqueira <yvesj@google.com> <yves.junqueira@gmail.com>
 Zac Bergquist <zbergquist99@gmail.com>
 Zach Bintliff <zbintliff@gmail.com>
 Zach Gershman <zachgersh@gmail.com>
+Zach Hoffman <zrhoffman@apache.org>
 Zach Jones <zachj1@gmail.com>
 Zachary Amsden <zach@thundertoken.com>
 Zachary Gershman <zgershman@pivotal.io>
@@ -2617,6 +2750,7 @@ Zhou Peng <p@ctriple.cn>
 Ziad Hatahet <hatahet@gmail.com>
 Ziheng Liu <lzhfromustc@gmail.com>
 Zorion Arrizabalaga <zorionk@gmail.com>
+Zvonimir Pavlinovic <zpavlinovic@google.com>
 Zyad A. Ali <zyad.ali.me@gmail.com>
 Максадбек Ахмедов <a.maksadbek@gmail.com>
 Максим Федосеев <max.faceless.frei@gmail.com>
-- 
GitLab


From 5805efc78e11e54c2c887ae10f277b09bbf81cf4 Mon Sep 17 00:00:00 2001
From: Dmitri Shuralyov <dmitshur@golang.org>
Date: Thu, 12 Aug 2021 12:12:56 -0400
Subject: [PATCH 2396/2400] doc/go1.17: remove draft notice

Fixes #44513.

Change-Id: I82c44a681b1fa67df123af86ee02a980b13acdc8
Reviewed-on: https://go-review.googlesource.com/c/go/+/341673
Trust: Dmitri Shuralyov <dmitshur@golang.org>
Trust: Carlos Amedee <carlos@golang.org>
Reviewed-by: Carlos Amedee <carlos@golang.org>
Run-TryBot: Carlos Amedee <carlos@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 doc/go1.17.html | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index 972f9c3559..b65d13a040 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -14,13 +14,13 @@ Do not send CLs removing the interior tags from such phrases.
   main ul li { margin: 0.5em 0; }
 </style>
 
-<h2 id="introduction">DRAFT RELEASE NOTES — Introduction to Go 1.17</h2>
+<h2 id="introduction">Introduction to Go 1.17</h2>
 
 <p>
-  <strong>
-    Go 1.17 is not yet released. These are work-in-progress
-    release notes. Go 1.17 is expected to be released in August 2021.
-  </strong>
+  The latest Go release, version 1.17, arrives six months after <a href="/doc/go1.16">Go 1.16</a>.
+  Most of its changes are in the implementation of the toolchain, runtime, and libraries.
+  As always, the release maintains the Go 1 <a href="/doc/go1compat">promise of compatibility</a>.
+  We expect almost all Go programs to continue to compile and run as before.
 </p>
 
 <h2 id="language">Changes to the language</h2>
-- 
GitLab


From 4397d66bdd98a243f0e1a501d92bc9484660ec41 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 6 Aug 2021 13:21:25 -0400
Subject: [PATCH 2397/2400] [release-branch.go1.17] time: fix docs for new
 comma layouts

The current text is slightly inaccurate. Make it more correct.

Change-Id: Iebe0051b74649d13982d7eefe3697f9e69c9b75d
Reviewed-on: https://go-review.googlesource.com/c/go/+/340449
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Reviewed-by: Damien Neil <dneil@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-on: https://go-review.googlesource.com/c/go/+/341949
Trust: Dmitri Shuralyov <dmitshur@golang.org>
Run-TryBot: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 doc/go1.17.html    | 14 +++++++-------
 src/time/format.go |  6 +++---
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/doc/go1.17.html b/doc/go1.17.html
index b65d13a040..c1b5ab3f6f 100644
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
@@ -753,9 +753,9 @@ func Foo() bool {
 
     <p><!-- CL 311572 -->
       The new
-      <a href="/pkg/database/sql/#NullInt16"><code>NullInt16</code></a> 
-      and 
-      <a href="/pkg/database/sql/#NullByte"><code>NullByte</code></a> 
+      <a href="/pkg/database/sql/#NullInt16"><code>NullInt16</code></a>
+      and
+      <a href="/pkg/database/sql/#NullByte"><code>NullByte</code></a>
       structs represent the int16 and byte values that may be null. These can be used as
       destinations of the <a href="/pkg/database/sql/#Scan"><code>Scan</code></a> method,
       similar to NullString.
@@ -1205,11 +1205,11 @@ func Foo() bool {
 
     <p><!-- CL 300996 -->
       The package now accepts comma "," as a separator for fractional seconds when parsing and formatting time.
-      The following time formats are now accepted:
+      For example, the following time layouts are now accepted:
       <ul>
-        <li>2006-01-02 14:06:03,999999999 -0700 MST</li>
-        <li>Mon Jan _2 14:06:03,120007 2006</li>
-        <li>Mon Jan 2 14:06:03,120007 2006</li>
+        <li>2006-01-02 15:04:05,999999999 -0700 MST</li>
+        <li>Mon Jan _2 15:04:05,000000 2006</li>
+        <li>Monday, January 2 15:04:05,000 2006</li>
       </ul>
     </p>
 
diff --git a/src/time/format.go b/src/time/format.go
index bb173a21c2..f4b4f48142 100644
--- a/src/time/format.go
+++ b/src/time/format.go
@@ -77,9 +77,9 @@ import "errors"
 // The formats  and 002 are space-padded and zero-padded
 // three-character day of year; there is no unpadded day of year format.
 //
-// A decimal point followed by one or more zeros represents a fractional
-// second, printed to the given number of decimal places.
-// Either a comma or decimal point followed by one or more nines represents
+// A comma or decimal point followed by one or more zeros represents
+// a fractional second, printed to the given number of decimal places.
+// A comma or decimal point followed by one or more nines represents
 // a fractional second, printed to the given number of decimal places, with
 // trailing zeros removed.
 // For example "15:04:05,000" or "15:04:05.000" formats or parses with
-- 
GitLab


From f7b9470992bfae96fe61d45bec40b7fc282f15f0 Mon Sep 17 00:00:00 2001
From: Michael Pratt <mpratt@google.com>
Date: Thu, 12 Aug 2021 17:17:51 -0400
Subject: [PATCH 2398/2400] [release-branch.go1.17] runtime: drop SIGPROF while
 in ARM < 7 kernel helpers

On Linux ARMv6 and below runtime/internal/atomic.Cas calls into a kernel
cas helper at a fixed address. If a SIGPROF arrives while executing the
kernel helper, the sigprof lostAtomic logic will miss that we are
potentially in the spinlock critical section, which could cause
a deadlock when using atomics later in sigprof.

For #47505
Fixes #47688

Change-Id: If8ba0d0fc47e45d4e6c68eca98fac4c6ed4e43c1
Reviewed-on: https://go-review.googlesource.com/c/go/+/341889
Trust: Michael Pratt <mpratt@google.com>
Run-TryBot: Michael Pratt <mpratt@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
(cherry picked from commit 20a620fd9f7bc35739c1af3602d53808d0430814)
Reviewed-on: https://go-review.googlesource.com/c/go/+/341890
---
 src/runtime/proc.go | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 7bc2a92590..a144b36ec8 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -4686,7 +4686,7 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
 		return
 	}
 
-	// On mips{,le}, 64bit atomics are emulated with spinlocks, in
+	// On mips{,le}/arm, 64bit atomics are emulated with spinlocks, in
 	// runtime/internal/atomic. If SIGPROF arrives while the program is inside
 	// the critical section, it creates a deadlock (when writing the sample).
 	// As a workaround, create a counter of SIGPROFs while in critical section
@@ -4699,6 +4699,13 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
 				return
 			}
 		}
+		if GOARCH == "arm" && goarm < 7 && GOOS == "linux" && pc&0xffff0000 == 0xffff0000 {
+			// runtime/internal/atomic functions call into kernel
+			// helpers on arm < 7. See
+			// runtime/internal/atomic/sys_linux_arm.s.
+			cpuprof.lostAtomic++
+			return
+		}
 	}
 
 	// Profiling runs concurrently with GC, so it must not allocate.
-- 
GitLab


From fdd6dfd50722780fdd185c10bdb182706b6b0a67 Mon Sep 17 00:00:00 2001
From: Jeff Wentworth <j.wentworth@gmail.com>
Date: Sat, 14 Aug 2021 09:46:32 +0000
Subject: [PATCH 2399/2400] [release-branch.go1.17] sync/atomic: fix
 documentation for CompareAndSwap
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The documentation for CompareAndSwap atomic/value incorrectly labelled
the function as CompareAndSwapPointer. This PR fixes that.

Updates #47699.
Fixes #47703.

Change-Id: I6db08fdfe166570b775248fd24550f5d28e3434e
GitHub-Last-Rev: 41f78707928f48c9cdac26b6a4f618d4284e1ca1
GitHub-Pull-Request: golang/go#47700
Reviewed-on: https://go-review.googlesource.com/c/go/+/342210
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Daniel Martí <mvdan@mvdan.cc>
Trust: Daniel Martí <mvdan@mvdan.cc>
Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
TryBot-Result: Go Bot <gobot@golang.org>
(cherry picked from commit 0a0a160d4df488939892a1adaca6c530fb784cc8)
Reviewed-on: https://go-review.googlesource.com/c/go/+/342329
Trust: Dmitri Shuralyov <dmitshur@golang.org>
Run-TryBot: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
---
 src/sync/atomic/value.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/sync/atomic/value.go b/src/sync/atomic/value.go
index 61f81d8fd3..3500cd22f4 100644
--- a/src/sync/atomic/value.go
+++ b/src/sync/atomic/value.go
@@ -126,7 +126,7 @@ func (v *Value) Swap(new interface{}) (old interface{}) {
 	}
 }
 
-// CompareAndSwapPointer executes the compare-and-swap operation for the Value.
+// CompareAndSwap executes the compare-and-swap operation for the Value.
 //
 // All calls to CompareAndSwap for a given Value must use values of the same
 // concrete type. CompareAndSwap of an inconsistent type panics, as does
-- 
GitLab


From ec5170397c724a8ae440b2bc529f857c86f0e6b1 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Mon, 16 Aug 2021 15:23:02 +0000
Subject: [PATCH 2400/2400] [release-branch.go1.17] go1.17

Change-Id: Ie59feb7f043574c7db4c7f14184603442638e4c0
Reviewed-on: https://go-review.googlesource.com/c/go/+/342470
Run-TryBot: Michael Knyszek <mknyszek@google.com>
Trust: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Heschi Kreinick <heschi@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
---
 VERSION | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/VERSION b/VERSION
index 718f37b97d..dd2329269c 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-go1.17rc2
\ No newline at end of file
+go1.17
\ No newline at end of file
-- 
GitLab